WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/kms_display.c


#define iowrite32(v, addr)      writel((v), (addr))
 
#include "drmP.h"
#include "drm.h"
#include "i915_drm.h"
#include "i915_drv.h"
#include "intel_drv.h"
 
#include 
#include 
#include 
#include 
#include 
 
#include 
 
#include "bitmap.h"
 
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;
 
};
 
 
static display_t *os_display;
 
u32_t cmd_buffer;
u32_t cmd_offset;
 
void init_render();
int  sna_init();
 
int init_cursor(cursor_t *cursor);
static cursor_t*  __stdcall select_cursor_kms(cursor_t *cursor);
static void       __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);
 
void __stdcall restore_cursor(int x, int y)
{};
 
void disable_mouse(void)
{};
 
static char *manufacturer_name(unsigned char *x)
{
    static char name[4];
 
    name[0] = ((x[0] & 0x7C) >> 2) + '@';
    name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
    name[2] = (x[1] & 0x1F) + '@';
    name[3] = 0;
 
    return name;
}
 
bool set_mode(struct drm_device *dev, struct drm_connector *connector,
              videomode_t *reqmode, bool strict)
{
    drm_i915_private_t      *dev_priv   = dev->dev_private;
    struct drm_fb_helper    *fb_helper  = &dev_priv->fbdev->helper;
 
    struct drm_mode_config  *config     = &dev->mode_config;
    struct drm_display_mode *mode       = NULL, *tmpmode;
    struct drm_framebuffer  *fb         = NULL;
    struct drm_crtc         *crtc;
    struct drm_encoder      *encoder;
    struct drm_i915_gem_object *fb_obj;
    struct drm_mode_set     set;
    const char *con_name;
    const char *enc_name;
    unsigned hdisplay, vdisplay;
    int ret;
 
    mutex_lock(&dev->mode_config.mutex);
 
    list_for_each_entry(tmpmode, &connector->modes, head)
    {
        if( (drm_mode_width(tmpmode)    == reqmode->width)  &&
            (drm_mode_height(tmpmode)   == reqmode->height) &&
            (drm_mode_vrefresh(tmpmode) == reqmode->freq) )
        {
            mode = tmpmode;
            goto do_set;
        }
    };
 
    if( (mode == NULL) && (strict == false) )
    {
        list_for_each_entry(tmpmode, &connector->modes, head)
        {
            if( (drm_mode_width(tmpmode)  == reqmode->width)  &&
                (drm_mode_height(tmpmode) == reqmode->height) )
            {
                mode = tmpmode;
                goto do_set;
            }
        };
    };
 
    DRM_ERROR("%s failed\n", __FUNCTION__);
 
    return -1;
 
do_set:
 
    encoder = connector->encoder;
    crtc = encoder->crtc;
 
    con_name = drm_get_connector_name(connector);
    enc_name = drm_get_encoder_name(encoder);
 
    DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s encoder %s\n",
              reqmode->width, reqmode->height, crtc->base.id,
              con_name, enc_name);
 
    drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 
    hdisplay = mode->hdisplay;
    vdisplay = mode->vdisplay;
 
    if (crtc->invert_dimensions)
        swap(hdisplay, vdisplay);
 
    fb_obj = get_fb_obj();
    fb = fb_helper->fb;
 
    fb->width  = reqmode->width;
    fb->height = reqmode->height;
 
    fb->pitches[0]  = fb->pitches[1]  = fb->pitches[2]  =
                      fb->pitches[3]  = ALIGN(reqmode->width * 4, 512);
 
    fb_obj->stride = fb->pitches[0];
 
    fb->bits_per_pixel = 32;
    fb->depth = 24;
 
    crtc->fb = fb;
    crtc->enabled = true;
    os_display->crtc = crtc;
 
    i915_gem_object_put_fence(fb_obj);
 
    set.crtc = crtc;
    set.x = 0;
    set.y = 0;
    set.mode = mode;
    set.connectors = &connector;
    set.num_connectors = 1;
    set.fb = fb;
    ret = crtc->funcs->set_config(&set);
    mutex_unlock(&dev->mode_config.mutex);
 
    if ( !ret )
    {
        os_display->width    = fb->width;
        os_display->height   = fb->height;
        os_display->vrefresh = drm_mode_vrefresh(mode);
 
        sysSetScreen(fb->width, fb->height, fb->pitches[0]);
 
        DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
                       fb->width, fb->height, fb->pitches[0]);
    }
    else
        DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
                   fb->width, fb->height, crtc);
 
    return ret;
}
 
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;
};
 
static struct drm_connector* get_def_connector(struct drm_device *dev)
{
    struct drm_connector  *connector;
    struct drm_connector_helper_funcs *connector_funcs;
 
    struct drm_connector  *def_connector = NULL;
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        struct drm_encoder  *encoder;
        struct drm_crtc     *crtc;
 
        if( connector->status != connector_status_connected)
            continue;
 
        connector_funcs = connector->helper_private;
        encoder = connector_funcs->best_encoder(connector);
        if( encoder == NULL)
            continue;
 
        connector->encoder = encoder;
 
        crtc = encoder->crtc;
 
        DRM_DEBUG_KMS("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x",
                   connector, connector->base.id,
                   connector->status, connector->encoder,
                   crtc);
 
//        if (crtc == NULL)
//            continue;
 
        def_connector = connector;
 
        break;
    };
 
    return def_connector;
};
 
struct drm_connector *get_active_connector(struct drm_device *dev)
{
    struct drm_connector *tmp = NULL;
    struct drm_connector_helper_funcs *connector_funcs;
    struct drm_encoder      *encoder;
 
    list_for_each_entry(tmp, &dev->mode_config.connector_list, head)
    {
        if( tmp->status != connector_status_connected)
            continue;
 
        connector_funcs = tmp->helper_private;
        encoder = connector_funcs->best_encoder(tmp);
        if( encoder == NULL)
        {
            DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
                      tmp, tmp->base.id);
            continue;
        };
 
        tmp->encoder = encoder;
 
        DRM_DEBUG_KMS("CONNECTOR %p ID:%d status:%d ENCODER %x CRTC %p ID:%d\n",
               tmp, tmp->base.id, tmp->status, tmp->encoder,
               tmp->encoder->crtc, tmp->encoder->crtc->base.id );
 
        return tmp;
    };
 
    return NULL;
}
 
struct drm_crtc *get_possible_crtc(struct drm_device *dev, struct drm_encoder *encoder)
{
        struct drm_crtc *tmp_crtc;
        int crtc_mask = 1;
 
        list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)
        {
            if (encoder->possible_crtcs & crtc_mask)
            {
            encoder->crtc = tmp_crtc;
            dbgprintf("CRTC %p\n", tmp_crtc);
            return tmp_crtc;
            };
            crtc_mask <<= 1;
        };
    return NULL;
};
 
int get_boot_mode(struct drm_connector *connector, videomode_t *usermode)
{
    struct drm_display_mode *mode;
 
    list_for_each_entry(mode, &connector->modes, head)
    {
        DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",
                drm_mode_width(mode), drm_mode_height(mode),
                drm_mode_vrefresh(mode));
 
        if( os_display->width  == drm_mode_width(mode)  &&
            os_display->height == drm_mode_height(mode) &&
            drm_mode_vrefresh(mode) == 60)
        {
            usermode->width  = os_display->width;
            usermode->height = os_display->height;
            usermode->freq   = 60;
            return 1;
        }
    }
    return 0;
}
 
int init_display_kms(struct drm_device *dev, videomode_t *usermode)
{
    struct drm_connector    *connector;
    struct drm_connector_helper_funcs *connector_funcs;
    struct drm_encoder      *encoder;
    struct drm_crtc         *crtc;
    struct drm_framebuffer  *fb;
 
    cursor_t  *cursor;
    u32_t      ifl;
    int        err;
 
    mutex_lock(&dev->mode_config.mutex);
 
    connector = get_active_connector(dev) ;
    if(connector == NULL)
    {
        DRM_DEBUG_KMS("No active connectors!\n");
        mutex_unlock(&dev->mode_config.mutex);
        return -1;
    };
 
    encoder = connector->encoder;
    crtc = encoder->crtc;
 
    if(crtc == NULL)
        crtc = get_possible_crtc(dev, encoder);
 
    if(crtc == NULL)
    {
        DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
        mutex_unlock(&dev->mode_config.mutex);
        return -1;
    };
 
    DRM_DEBUG_KMS("[Select CRTC: %p ID:%d]\n",crtc, crtc->base.id);
 
    os_display = GetDisplay();
    os_display->ddev = dev;
    os_display->connector = connector;
    os_display->crtc = crtc;
 
    os_display->supported_modes = count_connector_modes(connector);
 
 
    ifl = safe_cli();
    {
        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);
 
    if( (usermode->width == 0) ||
        (usermode->height == 0))
    {
        if( !get_boot_mode(connector, usermode))
        {
        struct drm_display_mode *mode;
 
            mode = list_entry(connector->modes.next, typeof(*mode), head);
            usermode->width  = drm_mode_width(mode);
            usermode->height = drm_mode_height(mode);
            usermode->freq   = drm_mode_vrefresh(mode);
        };
    };
 
    mutex_unlock(&dev->mode_config.mutex);
 
    set_mode(dev, os_display->connector, usermode, false);
 
#ifdef __HWA__
    err = init_bitmaps();
#endif
 
    LEAVE();
 
    return 0;
};
 
 
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;
};
 
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;
};
 
void i915_dpms(struct drm_device *dev, int mode)
{
    const struct drm_connector_funcs *f = os_display->connector->funcs;
 
    f->dpms(os_display->connector, mode);
};
 
void __attribute__((regparm(1))) destroy_cursor(cursor_t *cursor)
{
    list_del(&cursor->list);
 
    i915_gem_object_unpin(cursor->cobj);
 
    mutex_lock(&main_device->struct_mutex);
    drm_gem_object_unreference(&cursor->cobj->base);
    mutex_unlock(&main_device->struct_mutex);
 
    __DestroyObject(cursor);
};
 
int init_cursor(cursor_t *cursor)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct drm_i915_gem_object *obj;
    uint32_t *bits;
    uint32_t *src;
    void     *mapped;
 
    int       i,j;
    int       ret;
 
    if (dev_priv->info->cursor_needs_physical)
    {
        bits = (uint32_t*)KernelAlloc(CURSOR_WIDTH*CURSOR_HEIGHT*4);
        if (unlikely(bits == NULL))
            return ENOMEM;
        cursor->cobj = (struct drm_i915_gem_object *)GetPgAddr(bits);
    }
    else
    {
        obj = i915_gem_alloc_object(os_display->ddev, CURSOR_WIDTH*CURSOR_HEIGHT*4);
        if (unlikely(obj == NULL))
            return -ENOMEM;
 
        ret = i915_gem_obj_ggtt_pin(obj, CURSOR_WIDTH*CURSOR_HEIGHT*4, true, true);
        if (ret) {
            drm_gem_object_unreference(&obj->base);
            return ret;
        }
 
        ret = i915_gem_object_set_to_gtt_domain(obj, true);
        if (ret)
        {
            i915_gem_object_unpin(obj);
            drm_gem_object_unreference(&obj->base);
            return ret;
        }
/* You don't need to worry about fragmentation issues.
 * GTT space is continuous. I guarantee it.                           */
 
        mapped = bits = (u32*)MapIoMem(dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(obj),
                    CURSOR_WIDTH*CURSOR_HEIGHT*4, PG_SW);
 
        if (unlikely(bits == NULL))
        {
            i915_gem_object_unpin(obj);
            drm_gem_object_unreference(&obj->base);
            return -ENOMEM;
        };
        cursor->cobj = obj;
    };
 
    src = cursor->data;
 
    for(i = 0; i < 32; i++)
    {
        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;
 
    FreeKernelSpace(mapped);
 
// release old cursor
 
    KernelFree(cursor->data);
 
    cursor->data = bits;
 
    cursor->header.destroy = destroy_cursor;
 
    return 0;
}
 
 
static void i9xx_update_cursor(struct drm_crtc *crtc, u32 base)
{
    struct drm_device *dev = crtc->dev;
    struct drm_i915_private *dev_priv = dev->dev_private;
    struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
    int pipe = intel_crtc->pipe;
    bool visible = base != 0;
 
    if (intel_crtc->cursor_visible != visible) {
        uint32_t cntl = I915_READ(CURCNTR(pipe));
        if (base) {
            cntl &= ~(CURSOR_MODE | MCURSOR_PIPE_SELECT);
            cntl |= CURSOR_MODE_64_ARGB_AX | MCURSOR_GAMMA_ENABLE;
            cntl |= pipe << 28; /* Connect to correct pipe */
        } else {
            cntl &= ~(CURSOR_MODE | MCURSOR_GAMMA_ENABLE);
            cntl |= CURSOR_MODE_DISABLE;
        }
        I915_WRITE(CURCNTR(pipe), cntl);
 
        intel_crtc->cursor_visible = visible;
    }
    /* and commit changes on next vblank */
    I915_WRITE(CURBASE(pipe), base);
}
 
void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
    u32 base, pos;
    bool visible;
 
    int pipe = intel_crtc->pipe;
 
    intel_crtc->cursor_x = x;
    intel_crtc->cursor_y = y;
 
    x = x - cursor->hot_x;
    y = y - cursor->hot_y;
 
 
    pos = 0;
 
    base = intel_crtc->cursor_addr;
    if (x >= os_display->width)
        base = 0;
 
    if (y >= os_display->height)
        base = 0;
 
    if (x < 0)
    {
        if (x + intel_crtc->cursor_width < 0)
            base = 0;
 
        pos |= CURSOR_POS_SIGN << CURSOR_X_SHIFT;
        x = -x;
    }
    pos |= x << CURSOR_X_SHIFT;
 
    if (y < 0)
    {
        if (y + intel_crtc->cursor_height < 0)
            base = 0;
 
        pos |= CURSOR_POS_SIGN << CURSOR_Y_SHIFT;
        y = -y;
    }
    pos |= y << CURSOR_Y_SHIFT;
 
    visible = base != 0;
    if (!visible && !intel_crtc->cursor_visible)
        return;
 
    I915_WRITE(CURPOS(pipe), pos);
//    if (IS_845G(dev) || IS_I865G(dev))
//        i845_update_cursor(crtc, base);
//    else
        i9xx_update_cursor(os_display->crtc, base);
 
};
 
 
cursor_t* __stdcall select_cursor_kms(cursor_t *cursor)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
    cursor_t *old;
 
    old = os_display->cursor;
    os_display->cursor = cursor;
 
    if (!dev_priv->info->cursor_needs_physical)
       intel_crtc->cursor_addr = i915_gem_obj_ggtt_offset(cursor->cobj);
    else
        intel_crtc->cursor_addr = (addr_t)cursor->cobj;
 
    intel_crtc->cursor_width = 32;
    intel_crtc->cursor_height = 32;
 
    move_cursor_kms(cursor, intel_crtc->cursor_x, intel_crtc->cursor_y);
    return old;
};
 
int i915_fbinfo(struct drm_i915_fb_info *fb)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
 
    struct drm_i915_gem_object *obj = get_fb_obj();
 
    fb->name   = obj->base.name;
    fb->width  = os_display->width;
    fb->height = os_display->height;
    fb->pitch  = obj->stride;
    fb->tiling = obj->tiling_mode;
    fb->crtc   = crtc->base.base.id;
    fb->pipe   = crtc->pipe;
 
    return 0;
}
 
 
typedef struct
{
    int left;
    int top;
    int right;
    int bottom;
}rect_t;
 
 
#define CURRENT_TASK             (0x80003000)
 
static u32_t get_display_map()
{
    u32_t   addr;
 
    addr = (u32_t)os_display;
    addr+= sizeof(display_t);            /*  shoot me  */
    return *(u32_t*)addr;
}
 
void  FASTCALL GetWindowRect(rect_t *rc)__asm__("GetWindowRect");
 
int i915_mask_update(struct drm_device *dev, void *data,
            struct drm_file *file)
{
    struct drm_i915_mask *mask = data;
    struct drm_gem_object *obj;
    static unsigned int mask_seqno[256];
    rect_t winrc;
    u32    slot;
    int    ret=0;
 
 
 
 
 
 
 
    obj = drm_gem_object_lookup(dev, file, mask->handle);
    if (obj == NULL)
        return -ENOENT;
 
    if (!obj->filp) {
        drm_gem_object_unreference_unlocked(obj);
        return -EINVAL;
    }
 
    GetWindowRect(&winrc);
    {
//        static warn_count;
 
        mask->width    = winrc.right - winrc.left + 1;
        mask->height   = winrc.bottom - winrc.top + 1;
        mask->bo_pitch = (mask->width+15) & ~15;
 
#if 0
        if(warn_count < 1)
        {
            printf("left %d top %d right %d bottom %d\n",
                    winrc.left, winrc.top, winrc.right, winrc.bottom);
            printf("mask pitch %d data %p\n", mask->bo_pitch, mask->bo_size);
            warn_count++;
        };
#endif
 
     };
 
 
    slot = *((u8*)CURRENT_TASK);
 
    if( mask_seqno[slot] != os_display->mask_seqno)
    {
        u8* src_offset;
        u8* dst_offset;
        u32 ifl;
 
        ret = i915_mutex_lock_interruptible(dev);
        if (ret)
            goto err1;
 
        ret = i915_gem_object_set_to_cpu_domain(to_intel_bo(obj), true);
        if(ret != 0 )
        {
            dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__);
            goto err2;
        };
 
//        printf("width %d height %d\n", winrc.right, winrc.bottom);
 
//        slot = 0x01;
 
 
        src_offset = (u8*)( winrc.top*os_display->width + winrc.left);
        src_offset+= get_display_map();
        dst_offset = (u8*)mask->bo_map;
 
        u32_t tmp_h = mask->height;
 
        ifl = safe_cli();
        {
            mask_seqno[slot] = os_display->mask_seqno;
 
            slot|= (slot<<8)|(slot<<16)|(slot<<24);
 
            __asm__ __volatile__ (
                "movd       %[slot],   %%xmm6    \n"
            "punpckldq  %%xmm6, %%xmm6            \n"
            "punpcklqdq %%xmm6, %%xmm6            \n"
            :: [slot]  "m" (slot)
            :"xmm6");
 
            while( tmp_h--)
            {
                int tmp_w = mask->width;
 
                u8* tmp_src = src_offset;
                u8* tmp_dst = dst_offset;
 
                src_offset+= os_display->width;
                dst_offset+= mask->bo_pitch;
 
                while(tmp_w >= 64)
                {
                    __asm__ __volatile__ (
                    "movdqu     (%0),   %%xmm0            \n"
                    "movdqu   16(%0),   %%xmm1            \n"
                    "movdqu   32(%0),   %%xmm2            \n"
                    "movdqu   48(%0),   %%xmm3            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm1            \n"
                    "pcmpeqb    %%xmm6, %%xmm2            \n"
                    "pcmpeqb    %%xmm6, %%xmm3            \n"
                    "movdqa     %%xmm0,   (%%edi)         \n"
                    "movdqa     %%xmm1, 16(%%edi)         \n"
                    "movdqa     %%xmm2, 32(%%edi)         \n"
                    "movdqa     %%xmm3, 48(%%edi)         \n"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1","xmm2","xmm3");
                    tmp_w -= 64;
                    tmp_src += 64;
                    tmp_dst += 64;
                }
 
                if( tmp_w >= 32 )
                {
                    __asm__ __volatile__ (
                    "movdqu     (%0),   %%xmm0            \n"
                    "movdqu   16(%0),   %%xmm1            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm1            \n"
                    "movdqa     %%xmm0,   (%%edi)         \n"
                    "movdqa     %%xmm1, 16(%%edi)         \n"
 
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0","xmm1");
                    tmp_w -= 32;
                    tmp_src += 32;
                    tmp_dst += 32;
                }
 
                if( tmp_w >= 16 )
                {
                    __asm__ __volatile__ (
                    "movdqu     (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movdqa     %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 16;
                    tmp_src += 16;
                    tmp_dst += 16;
                }
 
                if( tmp_w >= 8 )
                {
                    __asm__ __volatile__ (
                    "movq       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movq       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 8;
                    tmp_src += 8;
                    tmp_dst += 8;
                }
                if( tmp_w >= 4 )
                {
                    __asm__ __volatile__ (
                    "movd       (%0),   %%xmm0            \n"
                    "pcmpeqb    %%xmm6, %%xmm0            \n"
                    "movd       %%xmm0,   (%%edi)         \n"
                    :: "r" (tmp_src), "D" (tmp_dst)
                    :"xmm0");
                    tmp_w -= 4;
                    tmp_src += 4;
                    tmp_dst += 4;
                }
                while(tmp_w--)
                    *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00;
            };
        };
        safe_sti(ifl);
 
        ret = i915_gem_object_set_to_gtt_domain(to_intel_bo(obj), false);
        if(ret != 0 )
        {
            dbgprintf("%s: i915_gem_object_set_to_gtt_domain failed\n", __FUNCTION__);
        };
    }
 
err2:
    mutex_unlock(&dev->struct_mutex);
err1:
    drm_gem_object_unreference(obj);
 
    return ret;
}
 
 
 
 
 
 
 
 
 
 
 
 
#define NSEC_PER_SEC    1000000000L
 
void getrawmonotonic(struct timespec *ts)
{
    u32 tmp = GetTimerTicks();
 
    ts->tv_sec  = tmp/100;
    ts->tv_nsec = (tmp - ts->tv_sec*100)*10000000;
}
 
void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
{
    while (nsec >= NSEC_PER_SEC) {
        /*
         * The following asm() prevents the compiler from
         * optimising this loop into a modulo operation. See
         * also __iter_div_u64_rem() in include/linux/time.h
         */
        asm("" : "+rm"(nsec));
        nsec -= NSEC_PER_SEC;
        ++sec;
    }
    while (nsec < 0) {
        asm("" : "+rm"(nsec));
        nsec += NSEC_PER_SEC;
        --sec;
    }
    ts->tv_sec = sec;
    ts->tv_nsec = nsec;
}
 
void
prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)
{
    unsigned long flags;
 
//    wait->flags &= ~WQ_FLAG_EXCLUSIVE;
    spin_lock_irqsave(&q->lock, flags);
    if (list_empty(&wait->task_list))
            __add_wait_queue(q, wait);
    spin_unlock_irqrestore(&q->lock, flags);
}
 
/**
 * finish_wait - clean up after waiting in a queue
 * @q: waitqueue waited on
 * @wait: wait descriptor
 *
 * Sets current thread back to running state and removes
 * the wait descriptor from the given waitqueue if still
 * queued.
 */
void finish_wait(wait_queue_head_t *q, wait_queue_t *wait)
{
    unsigned long flags;
 
//    __set_current_state(TASK_RUNNING);
    /*
     * We can check for list emptiness outside the lock
     * IFF:
     *  - we use the "careful" check that verifies both
     *    the next and prev pointers, so that there cannot
     *    be any half-pending updates in progress on other
     *    CPU's that we haven't seen yet (and that might
     *    still change the stack area.
     * and
     *  - all other users take the lock (ie we can only
     *    have _one_ other CPU that looks at or modifies
     *    the list).
     */
    if (!list_empty_careful(&wait->task_list)) {
            spin_lock_irqsave(&q->lock, flags);
            list_del_init(&wait->task_list);
            spin_unlock_irqrestore(&q->lock, flags);
    }
 
    DestroyEvent(wait->evnt);
}
 
int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
    list_del_init(&wait->task_list);
    return 1;
}
 
unsigned int hweight16(unsigned int w)
{
    unsigned int res = w - ((w >> 1) & 0x5555);
    res = (res & 0x3333) + ((res >> 2) & 0x3333);
    res = (res + (res >> 4)) & 0x0F0F;
    return (res + (res >> 8)) & 0x00FF;
}
 
 
unsigned long round_jiffies_up_relative(unsigned long j)
{
    unsigned long j0 = GetTimerTicks();
 
        /* Use j0 because jiffies might change while we run */
    return round_jiffies_common(j + j0, true) - j0;
}
 
>
 
>
 
>
 
>
 
>
 
>

Rev 4389	Rev 4398
1	#define iowrite32(v, addr) writel((v), (addr))	1	#define iowrite32(v, addr) writel((v), (addr))
2		2
3	#include "drmP.h"	3	#include "drmP.h"
4	#include "drm.h"	4	#include "drm.h"
5	#include "i915_drm.h"	5	#include "i915_drm.h"
6	#include "i915_drv.h"	6	#include "i915_drv.h"
7	#include "intel_drv.h"	7	#include "intel_drv.h"
8		8
9	#include	9	#include
10	#include	10	#include
11	#include	11	#include
12	#include	12	#include
13	#include	13	#include
14		14
15	#include	15	#include
16		16
17	#include "bitmap.h"	17	#include "bitmap.h"
18		18
19	typedef struct	19	typedef struct
20	{	20	{
21	kobj_t header;	21	kobj_t header;
22		22
23	uint32_t *data;	23	uint32_t *data;
24	uint32_t hot_x;	24	uint32_t hot_x;
25	uint32_t hot_y;	25	uint32_t hot_y;
26		26
27	struct list_head list;	27	struct list_head list;
28	struct drm_i915_gem_object *cobj;	28	struct drm_i915_gem_object *cobj;
29	}cursor_t;	29	}cursor_t;
30		30
31	#define CURSOR_WIDTH 64	31	#define CURSOR_WIDTH 64
32	#define CURSOR_HEIGHT 64	32	#define CURSOR_HEIGHT 64
33		33
34		34
35	struct tag_display	35	struct tag_display
36	{	36	{
37	int x;	37	int x;
38	int y;	38	int y;
39	int width;	39	int width;
40	int height;	40	int height;
41	int bpp;	41	int bpp;
42	int vrefresh;	42	int vrefresh;
43	int pitch;	43	int pitch;
44	int lfb;	44	int lfb;
45		45
46	int supported_modes;	46	int supported_modes;
47	struct drm_device *ddev;	47	struct drm_device *ddev;
48	struct drm_connector *connector;	48	struct drm_connector *connector;
49	struct drm_crtc *crtc;	49	struct drm_crtc *crtc;
50		50
51	struct list_head cursors;	51	struct list_head cursors;
52		52
53	cursor_t *cursor;	53	cursor_t *cursor;
54	int (init_cursor)(cursor_t);	54	int (init_cursor)(cursor_t);
55	cursor_t* (__stdcall select_cursor)(cursor_t);	55	cursor_t* (__stdcall select_cursor)(cursor_t);
56	void (*show_cursor)(int show);	56	void (*show_cursor)(int show);
57	void (__stdcall move_cursor)(cursor_t cursor, int x, int y);	57	void (__stdcall move_cursor)(cursor_t cursor, int x, int y);
58	void (__stdcall *restore_cursor)(int x, int y);	58	void (__stdcall *restore_cursor)(int x, int y);
59	void (*disable_mouse)(void);	59	void (*disable_mouse)(void);
60	u32 mask_seqno;	60	u32 mask_seqno;
61	u32 check_mouse;	61	u32 check_mouse;
62	u32 check_m_pixel;	62	u32 check_m_pixel;
63		63
64	};	64	};
65		65
66		66
67	static display_t *os_display;	67	static display_t *os_display;
68		68
69	u32_t cmd_buffer;	69	u32_t cmd_buffer;
70	u32_t cmd_offset;	70	u32_t cmd_offset;
71		71
72	void init_render();	72	void init_render();
73	int sna_init();	73	int sna_init();
74		74
75	int init_cursor(cursor_t *cursor);	75	int init_cursor(cursor_t *cursor);
76	static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);	76	static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);
77	static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);	77	static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);
78		78
79	void __stdcall restore_cursor(int x, int y)	79	void __stdcall restore_cursor(int x, int y)
80	{};	80	{};
81		81
82	void disable_mouse(void)	82	void disable_mouse(void)
83	{};	83	{};
84		84
85	static char manufacturer_name(unsigned char x)	85	static char manufacturer_name(unsigned char x)
86	{	86	{
87	static char name[4];	87	static char name[4];
88		88
89	name[0] = ((x[0] & 0x7C) >> 2) + '@';	89	name[0] = ((x[0] & 0x7C) >> 2) + '@';
90	name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';	90	name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
91	name[2] = (x[1] & 0x1F) + '@';	91	name[2] = (x[1] & 0x1F) + '@';
92	name[3] = 0;	92	name[3] = 0;
93		93
94	return name;	94	return name;
95	}	95	}
96		96
97	bool set_mode(struct drm_device dev, struct drm_connector connector,	97	bool set_mode(struct drm_device dev, struct drm_connector connector,
98	videomode_t *reqmode, bool strict)	98	videomode_t *reqmode, bool strict)
99	{	99	{
100	drm_i915_private_t *dev_priv = dev->dev_private;	100	drm_i915_private_t *dev_priv = dev->dev_private;
101	struct drm_fb_helper *fb_helper = &dev_priv->fbdev->helper;	101	struct drm_fb_helper *fb_helper = &dev_priv->fbdev->helper;
102		102
103	struct drm_mode_config *config = &dev->mode_config;	103	struct drm_mode_config *config = &dev->mode_config;
104	struct drm_display_mode mode = NULL, tmpmode;	104	struct drm_display_mode mode = NULL, tmpmode;
105	struct drm_framebuffer *fb = NULL;	105	struct drm_framebuffer *fb = NULL;
106	struct drm_crtc *crtc;	106	struct drm_crtc *crtc;
107	struct drm_encoder *encoder;	107	struct drm_encoder *encoder;
108	struct drm_i915_gem_object *fb_obj;	108	struct drm_i915_gem_object *fb_obj;
109	struct drm_mode_set set;	109	struct drm_mode_set set;
110	const char *con_name;	110	const char *con_name;
111	const char *enc_name;	111	const char *enc_name;
112	unsigned hdisplay, vdisplay;	112	unsigned hdisplay, vdisplay;
113	int ret;	113	int ret;
114		114
115	mutex_lock(&dev->mode_config.mutex);	115	mutex_lock(&dev->mode_config.mutex);
116		116
117	list_for_each_entry(tmpmode, &connector->modes, head)	117	list_for_each_entry(tmpmode, &connector->modes, head)
118	{	118	{
119	if( (drm_mode_width(tmpmode) == reqmode->width) &&	119	if( (drm_mode_width(tmpmode) == reqmode->width) &&
120	(drm_mode_height(tmpmode) == reqmode->height) &&	120	(drm_mode_height(tmpmode) == reqmode->height) &&
121	(drm_mode_vrefresh(tmpmode) == reqmode->freq) )	121	(drm_mode_vrefresh(tmpmode) == reqmode->freq) )
122	{	122	{
123	mode = tmpmode;	123	mode = tmpmode;
124	goto do_set;	124	goto do_set;
125	}	125	}
126	};	126	};
127		127
128	if( (mode == NULL) && (strict == false) )	128	if( (mode == NULL) && (strict == false) )
129	{	129	{
130	list_for_each_entry(tmpmode, &connector->modes, head)	130	list_for_each_entry(tmpmode, &connector->modes, head)
131	{	131	{
132	if( (drm_mode_width(tmpmode) == reqmode->width) &&	132	if( (drm_mode_width(tmpmode) == reqmode->width) &&
133	(drm_mode_height(tmpmode) == reqmode->height) )	133	(drm_mode_height(tmpmode) == reqmode->height) )
134	{	134	{
135	mode = tmpmode;	135	mode = tmpmode;
136	goto do_set;	136	goto do_set;
137	}	137	}
138	};	138	};
139	};	139	};
140		140
141	DRM_ERROR("%s failed\n", __FUNCTION__);	141	DRM_ERROR("%s failed\n", __FUNCTION__);
142		142
143	return -1;	143	return -1;
144		144
145	do_set:	145	do_set:
146		146
147	encoder = connector->encoder;	147	encoder = connector->encoder;
148	crtc = encoder->crtc;	148	crtc = encoder->crtc;
149		149
150	con_name = drm_get_connector_name(connector);	150	con_name = drm_get_connector_name(connector);
151	enc_name = drm_get_encoder_name(encoder);	151	enc_name = drm_get_encoder_name(encoder);
152		152
153	DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s encoder %s\n",	153	DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s encoder %s\n",
154	reqmode->width, reqmode->height, crtc->base.id,	154	reqmode->width, reqmode->height, crtc->base.id,
155	con_name, enc_name);	155	con_name, enc_name);
156		156
157	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);	157	drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
158		158
159	hdisplay = mode->hdisplay;	159	hdisplay = mode->hdisplay;
160	vdisplay = mode->vdisplay;	160	vdisplay = mode->vdisplay;
161		161
162	if (crtc->invert_dimensions)	162	if (crtc->invert_dimensions)
163	swap(hdisplay, vdisplay);	163	swap(hdisplay, vdisplay);
164		164
165	fb_obj = get_fb_obj();	165	fb_obj = get_fb_obj();
166	fb = fb_helper->fb;	166	fb = fb_helper->fb;
167		167
168	fb->width = reqmode->width;	168	fb->width = reqmode->width;
169	fb->height = reqmode->height;	169	fb->height = reqmode->height;
170		170
171	fb->pitches[0] = fb->pitches[1] = fb->pitches[2] =	171	fb->pitches[0] = fb->pitches[1] = fb->pitches[2] =
172	fb->pitches[3] = ALIGN(reqmode->width * 4, 512);	172	fb->pitches[3] = ALIGN(reqmode->width * 4, 512);
173		173
174	fb_obj->stride = fb->pitches[0];	174	fb_obj->stride = fb->pitches[0];
175		175
176	fb->bits_per_pixel = 32;	176	fb->bits_per_pixel = 32;
177	fb->depth = 24;	177	fb->depth = 24;
178		178
179	crtc->fb = fb;	179	crtc->fb = fb;
180	crtc->enabled = true;	180	crtc->enabled = true;
181	os_display->crtc = crtc;	181	os_display->crtc = crtc;
182		182
183	i915_gem_object_put_fence(fb_obj);	183	i915_gem_object_put_fence(fb_obj);
184		184
185	set.crtc = crtc;	185	set.crtc = crtc;
186	set.x = 0;	186	set.x = 0;
187	set.y = 0;	187	set.y = 0;
188	set.mode = mode;	188	set.mode = mode;
189	set.connectors = &connector;	189	set.connectors = &connector;
190	set.num_connectors = 1;	190	set.num_connectors = 1;
191	set.fb = fb;	191	set.fb = fb;
192	ret = crtc->funcs->set_config(&set);	192	ret = crtc->funcs->set_config(&set);
193	mutex_unlock(&dev->mode_config.mutex);	193	mutex_unlock(&dev->mode_config.mutex);
194		194
195	if ( !ret )	195	if ( !ret )
196	{	196	{
197	os_display->width = fb->width;	197	os_display->width = fb->width;
198	os_display->height = fb->height;	198	os_display->height = fb->height;
199	os_display->vrefresh = drm_mode_vrefresh(mode);	199	os_display->vrefresh = drm_mode_vrefresh(mode);
200		200
201	sysSetScreen(fb->width, fb->height, fb->pitches[0]);	201	sysSetScreen(fb->width, fb->height, fb->pitches[0]);
202		202
203	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",	203	DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
204	fb->width, fb->height, fb->pitches[0]);	204	fb->width, fb->height, fb->pitches[0]);
205	}	205	}
206	else	206	else
207	DRM_ERROR("failed to set mode %d_%d on crtc %p\n",	207	DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
208	fb->width, fb->height, crtc);	208	fb->width, fb->height, crtc);
209		209
210	return ret;	210	return ret;
211	}	211	}
212		212
213	static int count_connector_modes(struct drm_connector* connector)	213	static int count_connector_modes(struct drm_connector* connector)
214	{	214	{
215	struct drm_display_mode *mode;	215	struct drm_display_mode *mode;
216	int count = 0;	216	int count = 0;
217		217
218	list_for_each_entry(mode, &connector->modes, head)	218	list_for_each_entry(mode, &connector->modes, head)
219	{	219	{
220	count++;	220	count++;
221	};	221	};
222	return count;	222	return count;
223	};	223	};
224		224
225	static struct drm_connector* get_def_connector(struct drm_device *dev)	225	static struct drm_connector* get_def_connector(struct drm_device *dev)
226	{	226	{
227	struct drm_connector *connector;	227	struct drm_connector *connector;
228	struct drm_connector_helper_funcs *connector_funcs;	228	struct drm_connector_helper_funcs *connector_funcs;
229		229
230	struct drm_connector *def_connector = NULL;	230	struct drm_connector *def_connector = NULL;
231		231
232	list_for_each_entry(connector, &dev->mode_config.connector_list, head)	232	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
233	{	233	{
234	struct drm_encoder *encoder;	234	struct drm_encoder *encoder;
235	struct drm_crtc *crtc;	235	struct drm_crtc *crtc;
236		236
237	if( connector->status != connector_status_connected)	237	if( connector->status != connector_status_connected)
238	continue;	238	continue;
239		239
240	connector_funcs = connector->helper_private;	240	connector_funcs = connector->helper_private;
241	encoder = connector_funcs->best_encoder(connector);	241	encoder = connector_funcs->best_encoder(connector);
242	if( encoder == NULL)	242	if( encoder == NULL)
243	continue;	243	continue;
244		244
245	connector->encoder = encoder;	245	connector->encoder = encoder;
246		246
247	crtc = encoder->crtc;	247	crtc = encoder->crtc;
248		248
249	DRM_DEBUG_KMS("CONNECTOR %x ID: %d status %d encoder %x\n crtc %x",	249	DRM_DEBUG_KMS("CONNECTOR %x ID: %d status %d encoder %x\n crtc %x",
250	connector, connector->base.id,	250	connector, connector->base.id,
251	connector->status, connector->encoder,	251	connector->status, connector->encoder,
252	crtc);	252	crtc);
253		253
254	// if (crtc == NULL)	254	// if (crtc == NULL)
255	// continue;	255	// continue;
256		256
257	def_connector = connector;	257	def_connector = connector;
258		258
259	break;	259	break;
260	};	260	};
261		261
262	return def_connector;	262	return def_connector;
263	};	263	};
264		264
265	struct drm_connector get_active_connector(struct drm_device dev)	265	struct drm_connector get_active_connector(struct drm_device dev)
266	{	266	{
267	struct drm_connector *tmp = NULL;	267	struct drm_connector *tmp = NULL;
268	struct drm_connector_helper_funcs *connector_funcs;	268	struct drm_connector_helper_funcs *connector_funcs;
269	struct drm_encoder *encoder;	269	struct drm_encoder *encoder;
270		270
271	list_for_each_entry(tmp, &dev->mode_config.connector_list, head)	271	list_for_each_entry(tmp, &dev->mode_config.connector_list, head)
272	{	272	{
273	if( tmp->status != connector_status_connected)	273	if( tmp->status != connector_status_connected)
274	continue;	274	continue;
275		275
276	connector_funcs = tmp->helper_private;	276	connector_funcs = tmp->helper_private;
277	encoder = connector_funcs->best_encoder(tmp);	277	encoder = connector_funcs->best_encoder(tmp);
278	if( encoder == NULL)	278	if( encoder == NULL)
279	{	279	{
280	DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",	280	DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
281	tmp, tmp->base.id);	281	tmp, tmp->base.id);
282	continue;	282	continue;
283	};	283	};
284		284
285	tmp->encoder = encoder;	285	tmp->encoder = encoder;
286		286
287	DRM_DEBUG_KMS("CONNECTOR %p ID:%d status:%d ENCODER %x CRTC %p ID:%d\n",	287	DRM_DEBUG_KMS("CONNECTOR %p ID:%d status:%d ENCODER %x CRTC %p ID:%d\n",
288	tmp, tmp->base.id, tmp->status, tmp->encoder,	288	tmp, tmp->base.id, tmp->status, tmp->encoder,
289	tmp->encoder->crtc, tmp->encoder->crtc->base.id );	289	tmp->encoder->crtc, tmp->encoder->crtc->base.id );
290		290
291	return tmp;	291	return tmp;
292	};	292	};
293		293
294	return NULL;	294	return NULL;
295	}	295	}
296		296
297	struct drm_crtc get_possible_crtc(struct drm_device dev, struct drm_encoder *encoder)	297	struct drm_crtc get_possible_crtc(struct drm_device dev, struct drm_encoder *encoder)
298	{	298	{
299	struct drm_crtc *tmp_crtc;	299	struct drm_crtc *tmp_crtc;
300	int crtc_mask = 1;	300	int crtc_mask = 1;
301		301
302	list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)	302	list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head)
303	{	303	{
304	if (encoder->possible_crtcs & crtc_mask)	304	if (encoder->possible_crtcs & crtc_mask)
305	{	305	{
306	encoder->crtc = tmp_crtc;	306	encoder->crtc = tmp_crtc;
307	dbgprintf("CRTC %p\n", tmp_crtc);	307	dbgprintf("CRTC %p\n", tmp_crtc);
308	return tmp_crtc;	308	return tmp_crtc;
309	};	309	};
310	crtc_mask <<= 1;	310	crtc_mask <<= 1;
311	};	311	};
312	return NULL;	312	return NULL;
313	};	313	};
314		314
315	int get_boot_mode(struct drm_connector connector, videomode_t usermode)	315	int get_boot_mode(struct drm_connector connector, videomode_t usermode)
316	{	316	{
317	struct drm_display_mode *mode;	317	struct drm_display_mode *mode;
318		318
319	list_for_each_entry(mode, &connector->modes, head)	319	list_for_each_entry(mode, &connector->modes, head)
320	{	320	{
321	DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",	321	DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",
322	drm_mode_width(mode), drm_mode_height(mode),	322	drm_mode_width(mode), drm_mode_height(mode),
323	drm_mode_vrefresh(mode));	323	drm_mode_vrefresh(mode));
324		324
325	if( os_display->width == drm_mode_width(mode) &&	325	if( os_display->width == drm_mode_width(mode) &&
326	os_display->height == drm_mode_height(mode) &&	326	os_display->height == drm_mode_height(mode) &&
327	drm_mode_vrefresh(mode) == 60)	327	drm_mode_vrefresh(mode) == 60)
328	{	328	{
329	usermode->width = os_display->width;	329	usermode->width = os_display->width;
330	usermode->height = os_display->height;	330	usermode->height = os_display->height;
331	usermode->freq = 60;	331	usermode->freq = 60;
332	return 1;	332	return 1;
333	}	333	}
334	}	334	}
335	return 0;	335	return 0;
336	}	336	}
337		337
338	int init_display_kms(struct drm_device dev, videomode_t usermode)	338	int init_display_kms(struct drm_device dev, videomode_t usermode)
339	{	339	{
340	struct drm_connector *connector;	340	struct drm_connector *connector;
341	struct drm_connector_helper_funcs *connector_funcs;	341	struct drm_connector_helper_funcs *connector_funcs;
342	struct drm_encoder *encoder;	342	struct drm_encoder *encoder;
343	struct drm_crtc *crtc;	343	struct drm_crtc *crtc;
344	struct drm_framebuffer *fb;	344	struct drm_framebuffer *fb;
345		345
346	cursor_t *cursor;	346	cursor_t *cursor;
347	u32_t ifl;	347	u32_t ifl;
348	int err;	348	int err;
349		349
350	mutex_lock(&dev->mode_config.mutex);	350	mutex_lock(&dev->mode_config.mutex);
351		351
352	connector = get_active_connector(dev) ;	352	connector = get_active_connector(dev) ;
353	if(connector == NULL)	353	if(connector == NULL)
354	{	354	{
355	DRM_DEBUG_KMS("No active connectors!\n");	355	DRM_DEBUG_KMS("No active connectors!\n");
356	mutex_unlock(&dev->mode_config.mutex);	356	mutex_unlock(&dev->mode_config.mutex);
357	return -1;	357	return -1;
358	};	358	};
359		359
360	encoder = connector->encoder;	360	encoder = connector->encoder;
361	crtc = encoder->crtc;	361	crtc = encoder->crtc;
362		362
363	if(crtc == NULL)	363	if(crtc == NULL)
364	crtc = get_possible_crtc(dev, encoder);	364	crtc = get_possible_crtc(dev, encoder);
365		365
366	if(crtc == NULL)	366	if(crtc == NULL)
367	{	367	{
368	DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);	368	DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
369	mutex_unlock(&dev->mode_config.mutex);	369	mutex_unlock(&dev->mode_config.mutex);
370	return -1;	370	return -1;
371	};	371	};
372		372
373	DRM_DEBUG_KMS("[Select CRTC: %p ID:%d]\n",crtc, crtc->base.id);	373	DRM_DEBUG_KMS("[Select CRTC: %p ID:%d]\n",crtc, crtc->base.id);
374		374
375	os_display = GetDisplay();	375	os_display = GetDisplay();
376	os_display->ddev = dev;	376	os_display->ddev = dev;
377	os_display->connector = connector;	377	os_display->connector = connector;
378	os_display->crtc = crtc;	378	os_display->crtc = crtc;
379		379
380	os_display->supported_modes = count_connector_modes(connector);	380	os_display->supported_modes = count_connector_modes(connector);
381		381
382		382
383	ifl = safe_cli();	383	ifl = safe_cli();
384	{	384	{
385	struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);	385	struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
386		386
387	list_for_each_entry(cursor, &os_display->cursors, list)	387	list_for_each_entry(cursor, &os_display->cursors, list)
388	{	388	{
389	init_cursor(cursor);	389	init_cursor(cursor);
390	};	390	};
391		391
392	os_display->restore_cursor(0,0);	392	os_display->restore_cursor(0,0);
393	os_display->init_cursor = init_cursor;	393	os_display->init_cursor = init_cursor;
394	os_display->select_cursor = select_cursor_kms;	394	os_display->select_cursor = select_cursor_kms;
395	os_display->show_cursor = NULL;	395	os_display->show_cursor = NULL;
396	os_display->move_cursor = move_cursor_kms;	396	os_display->move_cursor = move_cursor_kms;
397	os_display->restore_cursor = restore_cursor;	397	os_display->restore_cursor = restore_cursor;
398	os_display->disable_mouse = disable_mouse;	398	os_display->disable_mouse = disable_mouse;
399		399
400	intel_crtc->cursor_x = os_display->width/2;	400	intel_crtc->cursor_x = os_display->width/2;
401	intel_crtc->cursor_y = os_display->height/2;	401	intel_crtc->cursor_y = os_display->height/2;
402		402
403	select_cursor_kms(os_display->cursor);	403	select_cursor_kms(os_display->cursor);
404	};	404	};
405	safe_sti(ifl);	405	safe_sti(ifl);
406		406
407	if( (usermode->width == 0) \|\|	407	if( (usermode->width == 0) \|\|
408	(usermode->height == 0))	408	(usermode->height == 0))
409	{	409	{
410	if( !get_boot_mode(connector, usermode))	410	if( !get_boot_mode(connector, usermode))
411	{	411	{
412	struct drm_display_mode *mode;	412	struct drm_display_mode *mode;
413		413
414	mode = list_entry(connector->modes.next, typeof(*mode), head);	414	mode = list_entry(connector->modes.next, typeof(*mode), head);
415	usermode->width = drm_mode_width(mode);	415	usermode->width = drm_mode_width(mode);
416	usermode->height = drm_mode_height(mode);	416	usermode->height = drm_mode_height(mode);
417	usermode->freq = drm_mode_vrefresh(mode);	417	usermode->freq = drm_mode_vrefresh(mode);
418	};	418	};
419	};	419	};
420		420
421	mutex_unlock(&dev->mode_config.mutex);	421	mutex_unlock(&dev->mode_config.mutex);
422		422
423	set_mode(dev, os_display->connector, usermode, false);	423	set_mode(dev, os_display->connector, usermode, false);
424		424
425	#ifdef __HWA__	425	#ifdef __HWA__
426	err = init_bitmaps();	426	err = init_bitmaps();
427	#endif	427	#endif
428		428
429	LEAVE();	429	LEAVE();
430		430
431	return 0;	431	return 0;
432	};	432	};
433		433
434		434
435	int get_videomodes(videomode_t mode, int count)	435	int get_videomodes(videomode_t mode, int count)
436	{	436	{
437	int err = -1;	437	int err = -1;
438		438
439	// dbgprintf("mode %x count %d\n", mode, *count);	439	// dbgprintf("mode %x count %d\n", mode, *count);
440		440
441	if( *count == 0 )	441	if( *count == 0 )
442	{	442	{
443	*count = os_display->supported_modes;	443	*count = os_display->supported_modes;
444	err = 0;	444	err = 0;
445	}	445	}
446	else if( mode != NULL )	446	else if( mode != NULL )
447	{	447	{
448	struct drm_display_mode *drmmode;	448	struct drm_display_mode *drmmode;
449	int i = 0;	449	int i = 0;
450		450
451	if( *count > os_display->supported_modes)	451	if( *count > os_display->supported_modes)
452	*count = os_display->supported_modes;	452	*count = os_display->supported_modes;
453		453
454	list_for_each_entry(drmmode, &os_display->connector->modes, head)	454	list_for_each_entry(drmmode, &os_display->connector->modes, head)
455	{	455	{
456	if( i < *count)	456	if( i < *count)
457	{	457	{
458	mode->width = drm_mode_width(drmmode);	458	mode->width = drm_mode_width(drmmode);
459	mode->height = drm_mode_height(drmmode);	459	mode->height = drm_mode_height(drmmode);
460	mode->bpp = 32;	460	mode->bpp = 32;
461	mode->freq = drm_mode_vrefresh(drmmode);	461	mode->freq = drm_mode_vrefresh(drmmode);
462	i++;	462	i++;
463	mode++;	463	mode++;
464	}	464	}
465	else break;	465	else break;
466	};	466	};
467	*count = i;	467	*count = i;
468	err = 0;	468	err = 0;
469	};	469	};
470	return err;	470	return err;
471	};	471	};
472		472
473	int set_user_mode(videomode_t *mode)	473	int set_user_mode(videomode_t *mode)
474	{	474	{
475	int err = -1;	475	int err = -1;
476		476
477	// dbgprintf("width %d height %d vrefresh %d\n",	477	// dbgprintf("width %d height %d vrefresh %d\n",
478	// mode->width, mode->height, mode->freq);	478	// mode->width, mode->height, mode->freq);
479		479
480	if( (mode->width != 0) &&	480	if( (mode->width != 0) &&
481	(mode->height != 0) &&	481	(mode->height != 0) &&
482	(mode->freq != 0 ) &&	482	(mode->freq != 0 ) &&
483	( (mode->width != os_display->width) \|\|	483	( (mode->width != os_display->width) \|\|
484	(mode->height != os_display->height) \|\|	484	(mode->height != os_display->height) \|\|
485	(mode->freq != os_display->vrefresh) ) )	485	(mode->freq != os_display->vrefresh) ) )
486	{	486	{
487	if( set_mode(os_display->ddev, os_display->connector, mode, true) )	487	if( set_mode(os_display->ddev, os_display->connector, mode, true) )
488	err = 0;	488	err = 0;
489	};	489	};
490		490
491	return err;	491	return err;
492	};	492	};
493		493
494	void i915_dpms(struct drm_device *dev, int mode)	494	void i915_dpms(struct drm_device *dev, int mode)
495	{	495	{
496	const struct drm_connector_funcs *f = os_display->connector->funcs;	496	const struct drm_connector_funcs *f = os_display->connector->funcs;
497		497
498	f->dpms(os_display->connector, mode);	498	f->dpms(os_display->connector, mode);
499	};	499	};
500		500

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 4389 → 4398