Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include "radeon_drm.h"

#include "radeon.h"

#include "radeon_object.h"

#define CURSOR_HEIGHT 64

typedef struct tag_display display_t;

{

    uint32_t   magic;

    void      *destroy;

    kobj_t    *fd;

    kobj_t    *bk;

    uint32_t   pid;

};

{

    kobj_t     header;

    uint32_t   hot_x;

    uint32_t   hot_y;

    struct radeon_object *robj;

}cursor_t;

cursor_t*  __stdcall select_cursor(cursor_t *cursor);

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

void       __stdcall restore_cursor(int x, int y);

{

    int  x;

    int  y;

    int  width;

    int  height;

    int  bpp;

    int  vrefresh;

    int  pitch;

    int  lfb;

    struct drm_crtc   *crtc;

    int       (*init_cursor)(cursor_t*);

    cursor_t* (__stdcall *select_cursor)(cursor_t*);

    void      (*show_cursor)(int show);

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

    void      (__stdcall *restore_cursor)(int x, int y);

{

    ENTER();

    rdisplay->crtc = crtc;

    LEAVE();

}

{

    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;

};

{

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    struct radeon_device *rdev = crtc->dev->dev_private;

        WREG32(RADEON_MM_INDEX, AVIVO_D1CUR_CONTROL + radeon_crtc->crtc_offset);

        WREG32(RADEON_MM_DATA, AVIVO_D1CURSOR_EN |

                 (AVIVO_D1CURSOR_MODE_24BPP << AVIVO_D1CURSOR_MODE_SHIFT));

    } else {

        switch (radeon_crtc->crtc_id) {

        case 0:

            WREG32(RADEON_MM_INDEX, RADEON_CRTC_GEN_CNTL);

            break;

        case 1:

            WREG32(RADEON_MM_INDEX, RADEON_CRTC2_GEN_CNTL);

            break;

        default:

            return;

        }

                      (RADEON_CRTC_CUR_MODE_24BPP << RADEON_CRTC_CUR_MODE_SHIFT)),

             ~(RADEON_CRTC_CUR_EN | RADEON_CRTC_CUR_MODE_MASK));

    }

}

{

    struct radeon_device *rdev = crtc->dev->dev_private;

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    uint32_t cur_lock;

        cur_lock = RREG32(AVIVO_D1CUR_UPDATE + radeon_crtc->crtc_offset);

        if (lock)

            cur_lock |= AVIVO_D1CURSOR_UPDATE_LOCK;

        else

            cur_lock &= ~AVIVO_D1CURSOR_UPDATE_LOCK;

        WREG32(AVIVO_D1CUR_UPDATE + radeon_crtc->crtc_offset, cur_lock);

    } else {

        cur_lock = RREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset);

        if (lock)

            cur_lock |= RADEON_CUR_LOCK;

        else

            cur_lock &= ~RADEON_CUR_LOCK;

        WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset, cur_lock);

    }

}

{

    struct radeon_device *rdev;

    struct radeon_crtc   *radeon_crtc;

    cursor_t *old;

    uint32_t  gpu_addr;

    radeon_crtc = to_radeon_crtc(rdisplay->crtc);

    gpu_addr = cursor->robj->gpu_addr;

        WREG32(AVIVO_D1CUR_SURFACE_ADDRESS + radeon_crtc->crtc_offset, gpu_addr);

    else {

        radeon_crtc->legacy_cursor_offset = gpu_addr - radeon_crtc->legacy_display_base_addr;

        /* offset is from DISP(2)_BASE_ADDRESS */

        WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset, radeon_crtc->legacy_cursor_offset);

    }

};

{

    struct radeon_device *rdev;

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

    struct drm_crtc *crtc = rdisplay->crtc;

    struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);

    int hot_y = cursor->hot_y;

    if (ASIC_IS_AVIVO(rdev))

    {

        int w = 32;

        int i = 0;

        struct drm_crtc *crtc_p;

//        x += crtc->x;

//        y += crtc->y;

#if 0

        /* avivo cursor image can't end on 128 pixel boundry or

         * go past the end of the frame if both crtcs are enabled

         */

        list_for_each_entry(crtc_p, &crtc->dev->mode_config.crtc_list, head) {

            if (crtc_p->enabled)

                i++;

        }

        if (i > 1) {

            int cursor_end, frame_end;

            frame_end = crtc->x + crtc->mode.crtc_hdisplay;

            if (cursor_end >= frame_end) {

                w = w - (cursor_end - frame_end);

                if (!(frame_end & 0x7f))

                    w--;

            } else {

                if (!(cursor_end & 0x7f))

                    w--;

            }

            if (w <= 0)

                w = 1;

        }

#endif

        WREG32(AVIVO_D1CUR_POSITION + radeon_crtc->crtc_offset,

               (x << 16) | y);

        WREG32(AVIVO_D1CUR_HOT_SPOT + radeon_crtc->crtc_offset,

               (hot_x << 16) | hot_y);

        WREG32(AVIVO_D1CUR_SIZE + radeon_crtc->crtc_offset,

               ((w - 1) << 16) | 31);

    } else {

        if (crtc->mode.flags & DRM_MODE_FLAG_DBLSCAN)

            y *= 2;

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

        WREG32(RADEON_CUR_HORZ_VERT_POSN + radeon_crtc->crtc_offset,

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

        WREG32(RADEON_CUR_OFFSET + radeon_crtc->crtc_offset,

         (radeon_crtc->legacy_cursor_offset + (hot_y * 256)));

    }

    radeon_lock_cursor(crtc, false);

}

{

};

{

    static char name[4];

    name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';

    name[2] = (x[1] & 0x1F) + '@';

    name[3] = 0;

}

{

    struct drm_connector *connector;

    {

        struct drm_display_mode *mode;

        struct drm_crtc     *crtc;

            continue;

        if( encoder == NULL)

            continue;

            continue;

        {

            char *con_name, *enc_name;

                drm_mode_height(mode) == height)

            {

                char con_edid[128];

                                      struct drm_framebuffer, filp_head);

                manufacturer_name(con_edid + 0x08),

                (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),

                (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)

                    + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));

                enc_name = drm_get_encoder_name(encoder);

                           width, height, con_name, enc_name);

                fb->height = height;

                fb->pitch = radeon_align_pitch(dev->dev_private, width, 32, false) * ((32 + 1) / 8);

                crtc->enabled = true;

                rdisplay->crtc = crtc;

                rdisplay->height = fb->height;

                rdisplay->pitch  = fb->pitch;

                {

                    dbgprintf("new mode %d %d pitch %d\n",fb->width, fb->height, fb->pitch);

                }

                else

                {

                    DRM_ERROR("failed to set mode %d_%d on crtc %p\n",

                               fb->width, fb->height, crtc);

                };

            };

        }

    };

    LEAVE();

    return ret;

};

{

    cursor_t  *cursor;

    {

        init_cursor(cursor);

    };

        (usermode->height != 0) )

    {

        set_mode(rdev->ddev, usermode->width, usermode->height);

    }

    else

        set_mode(rdev->ddev, 800, 600);

    radeon_show_cursor(rdisplay->crtc);

    rdisplay->select_cursor = select_cursor;

    rdisplay->show_cursor   = NULL;

    rdisplay->move_cursor   = move_cursor;

    rdisplay->restore_cursor = restore_cursor;

};

{

    char* p = *cmd;

    int val = 0;

        switch (*p) {

        case '0' ... '9':

            val = 10*val+(*p-'0');

            break;

        default:

            *cmd = p;

            return val;

        }

    }

}

{

    char c;

    {

        p--;

        p++;

        p++;

    }

};

{

    char  c;

    p--;

    while( (c = *log++ = *p++) && (c != ' '));

    *log = 0;

};

{

    char *p = cmdline;

    {

        if( c == '-')

        {

            switch(*p++)

            {

                case 'm':

                    p = parse_mode(p, mode);

                    break;

                    p = parse_path(p, log);

                    break;

            };

        };

        c = *p++;

    };

};