Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "radeon_drm.h"

#include "radeon.h"

#include "radeon_object.h"

#include "display.h"

static void       __stdcall move_cursor(cursor_t *cursor, int x, int y);

{};

{

    struct radeon_device *rdev;

    uint32_t *src;

    int       r;

                     false,

                     RADEON_GEM_DOMAIN_VRAM,

                     false, &cursor->robj);

        return r;

    if (r) {

         DRM_ERROR("radeon: failed to map cursor (%d).\n", r);

         return r;

    };

    {

        for(j = 0; j < 32; j++)

            *bits++ = *src++;

        for(j = 32; j < CURSOR_WIDTH; j++)

            *bits++ = 0;

    }

    for(i = 0; i < CURSOR_WIDTH*(CURSOR_HEIGHT-32); i++)

        *bits++ = 0;

};

{

    list_del(&cursor->list);

    radeon_object_unpin(cursor->robj);

    KernelFree(cursor->data);

    __DestroyObject(cursor);

};

{

    struct radeon_device *rdev = (struct radeon_device *)rdisplay->ddev->dev_private;

        WREG32(RADEON_MM_INDEX, AVIVO_D1CUR_CONTROL);

        WREG32(RADEON_MM_DATA, AVIVO_D1CURSOR_EN |

                 (AVIVO_D1CURSOR_MODE_24BPP << AVIVO_D1CURSOR_MODE_SHIFT));

    } else {

        WREG32(RADEON_MM_INDEX, RADEON_CRTC_GEN_CNTL);

        WREG32_P(RADEON_MM_DATA, (RADEON_CRTC_CUR_EN |

                      (RADEON_CRTC_CUR_MODE_24BPP << RADEON_CRTC_CUR_MODE_SHIFT)),

             ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_CUR_MODE_MASK));

    }

}

{

    struct radeon_device *rdev;

    cursor_t *old;

    uint32_t  gpu_addr;

    gpu_addr = cursor->robj->gpu_addr;

        WREG32(AVIVO_D1CUR_SURFACE_ADDRESS,  gpu_addr);

    else {

        WREG32(RADEON_CUR_OFFSET, gpu_addr - rdev->mc.vram_location);

    }

};

{

    struct radeon_device *rdev;

        cur_lock = RREG32(AVIVO_D1CUR_UPDATE);

        if (lock)

            cur_lock |= AVIVO_D1CURSOR_UPDATE_LOCK;

        else

            cur_lock &= ~AVIVO_D1CURSOR_UPDATE_LOCK;

        WREG32(AVIVO_D1CUR_UPDATE, cur_lock);

    } else {

        cur_lock = RREG32(RADEON_CUR_OFFSET);

        if (lock)

            cur_lock |= RADEON_CUR_LOCK;

        else

            cur_lock &= ~RADEON_CUR_LOCK;

        WREG32(RADEON_CUR_OFFSET, cur_lock);

    }

}

{

    struct radeon_device *rdev;

    rdev = (struct radeon_device *)rdisplay->ddev->dev_private;

    int hot_y = cursor->hot_y;

    if (ASIC_IS_AVIVO(rdev))

    {

        int w = 32;

        int i = 0;

        WREG32(AVIVO_D1CUR_HOT_SPOT, (hot_x << 16) | hot_y);

        WREG32(AVIVO_D1CUR_SIZE, ((w - 1) << 16) | 31);

    } else {

        uint32_t  gpu_addr;

               (RADEON_CUR_LOCK | (hot_x << 16) | hot_y ));

        WREG32(RADEON_CUR_HORZ_VERT_POSN,

               (RADEON_CUR_LOCK | (x << 16) | y));

        WREG32(RADEON_CUR_OFFSET,

         (gpu_addr - rdev->mc.vram_location + (hot_y * 256)));

    }

    radeon_lock_cursor(false);

}

{

};

{

    struct drm_device   *dev;

    bool                 retval = true;

    u32_t                ifl;

    {

        list_for_each_entry(cursor, &rdisplay->cursors, list)

        {

            init_cursor(cursor);

        };

        rdisplay->init_cursor    = init_cursor;

        rdisplay->select_cursor  = select_cursor;

        rdisplay->show_cursor    = NULL;

        rdisplay->move_cursor    = move_cursor;

        rdisplay->restore_cursor = restore_cursor;

        rdisplay->disable_mouse  = disable_mouse;

        radeon_show_cursor();

    };

    safe_sti(ifl);

};