Subversion Repositories Kolibri OS

            break;

#include "vmwgfx_kms.h"

void kms_update();

//#define iowrite32(v, addr)      writel((v), (addr))

//#include "bitmap.h"

extern struct drm_device *main_device;

typedef struct

{

    kobj_t     header;

    uint32_t  *data;

    uint32_t   hot_x;

    uint32_t   hot_y;

    struct list_head   list;

//    struct drm_i915_gem_object  *cobj;

}cursor_t;

#define CURSOR_WIDTH 64

#define CURSOR_HEIGHT 64

struct tag_display

{

    int  x;

    int  y;

    int  width;

    int  height;

    int  bpp;

    int  vrefresh;

    int  pitch;

    int  lfb;

    int  supported_modes;

    struct drm_device    *ddev;

    struct drm_connector *connector;

    struct drm_crtc      *crtc;

    struct list_head   cursors;

    cursor_t   *cursor;

    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);

    void      (*disable_mouse)(void);

    u32  mask_seqno;

    u32  check_mouse;

    u32  check_m_pixel;

    u32  dirty;

    void (*update)(void);

};

static display_t *os_display;

static int count_connector_modes(struct drm_connector* connector)

{

    struct drm_display_mode  *mode;

    int count = 0;

    list_for_each_entry(mode, &connector->modes, head)

    {

        count++;

    };

    return count;

};

int kms_init(struct drm_device *dev)

{

    struct drm_connector    *connector;

    struct drm_connector_helper_funcs *connector_funcs;

    struct drm_encoder      *encoder;

    struct drm_crtc         *crtc = NULL;

    struct drm_framebuffer  *fb;

    cursor_t  *cursor;

    int        mode_count;

    u32_t      ifl;

    int        err;

    ENTER();

    crtc = list_entry(dev->mode_config.crtc_list.next, typeof(*crtc), head);

    encoder = list_entry(dev->mode_config.encoder_list.next, typeof(*encoder), head);

    connector = list_entry(dev->mode_config.connector_list.next, typeof(*connector), head);

    connector->encoder = encoder;

    mode_count = count_connector_modes(connector);

    if(mode_count == 0)

    {

        struct drm_display_mode *mode;

        connector->funcs->fill_modes(connector,

                                     dev->mode_config.max_width,

                                     dev->mode_config.max_height);

        list_for_each_entry(mode, &connector->modes, head)

        mode_count++;

    };

    printf("%s %d\n",__FUNCTION__, mode_count);

    DRM_DEBUG_KMS("CONNECTOR %x ID:%d status:%d ENCODER %x CRTC %x ID:%d\n",

               connector, connector->base.id,

               connector->status, connector->encoder,

               crtc, crtc->base.id );

    DRM_DEBUG_KMS("[Select CRTC:%d]\n", crtc->base.id);

    os_display = GetDisplay();

    ifl = safe_cli();

    {

        os_display->ddev = dev;

        os_display->connector = connector;

        os_display->crtc = crtc;

        os_display->supported_modes = mode_count;

        os_display->update = kms_update;

//        struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);

//        list_for_each_entry(cursor, &os_display->cursors, list)

//        {

//            init_cursor(cursor);

//        };

//        os_display->restore_cursor(0,0);

//        os_display->init_cursor    = init_cursor;

//        os_display->select_cursor  = select_cursor_kms;

//        os_display->show_cursor    = NULL;

//        os_display->move_cursor    = move_cursor_kms;

//        os_display->restore_cursor = restore_cursor;

//        os_display->disable_mouse  = disable_mouse;

//        intel_crtc->cursor_x = os_display->width/2;

//        intel_crtc->cursor_y = os_display->height/2;

//        select_cursor_kms(os_display->cursor);

    };

    safe_sti(ifl);

    main_device = dev;

#ifdef __HWA__

    err = init_bitmaps();

#endif

    LEAVE();

    return 0;

};

void kms_update()

{

    struct vmw_private *dev_priv = vmw_priv(main_device);

    size_t fifo_size;

    int i;

    struct {

        uint32_t header;

        SVGAFifoCmdUpdate body;

    } *cmd;

    fifo_size = sizeof(*cmd);

    cmd = vmw_fifo_reserve(dev_priv, fifo_size);

    if (unlikely(cmd == NULL)) {

        DRM_ERROR("Fifo reserve failed.\n");

        return;

    }

    cmd->header = cpu_to_le32(SVGA_CMD_UPDATE);

    cmd->body.x = 0;

    cmd->body.y = 0;

    cmd->body.width  = os_display->width; //cpu_to_le32(clips->x2 - clips->x1);

    cmd->body.height = os_display->height; //cpu_to_le32(clips->y2 - clips->y1);

    vmw_fifo_commit(dev_priv, fifo_size);

}

int get_videomodes(videomode_t *mode, int *count)

{

    int err = -1;

    dbgprintf("mode %x count %d\n", mode, *count);

    if( *count == 0 )

    {

        *count = os_display->supported_modes;

        err = 0;

    }

    else if( mode != NULL )

    {

        struct drm_display_mode  *drmmode;

        int i = 0;

        if( *count > os_display->supported_modes)

            *count = os_display->supported_modes;

        list_for_each_entry(drmmode, &os_display->connector->modes, head)

        {

            if( i < *count)

            {

                mode->width  = drm_mode_width(drmmode);

                mode->height = drm_mode_height(drmmode);

                mode->bpp    = 32;

                mode->freq   = drm_mode_vrefresh(drmmode);

                i++;

                mode++;

            }

            else break;

        };

        *count = i;

        err = 0;

    };

    return err;

};

bool set_mode(struct drm_device *dev, struct drm_connector *connector,

              videomode_t *reqmode, bool strict);

int set_user_mode(videomode_t *mode)

{

    int err = -1;

    dbgprintf("width %d height %d vrefresh %d\n",

               mode->width, mode->height, mode->freq);

    if( (mode->width  != 0)  &&

        (mode->height != 0)  &&

        (mode->freq   != 0 ) &&

        ( (mode->width   != os_display->width)  ||

          (mode->height  != os_display->height) ||

          (mode->freq    != os_display->vrefresh) ) )

    {

        if( set_mode(os_display->ddev, os_display->connector, mode, true) )

            err = 0;

    };

    return err;