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


#define iowrite32(v, addr)      writel((v), (addr))
 
#include 
#include 
#include "i915_drv.h"
#include "intel_drv.h"
#include 
 
#include 
#include 
 
 
#include 
 
#include "bitmap.h"
#include 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
display_t *os_display;
struct drm_i915_gem_object *main_fb_obj;
 
u32 cmd_buffer;
u32 cmd_offset;
 
void init_render();
int  sna_init();
 
 
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;
}
 
static int set_mode(struct drm_device *dev, struct drm_connector *connector,
                    struct drm_crtc *crtc, videomode_t *reqmode, bool strict)
{
    struct drm_i915_private *dev_priv   = dev->dev_private;
 
    struct drm_mode_config  *config     = &dev->mode_config;
    struct drm_display_mode *mode       = NULL, *tmpmode;
    struct drm_framebuffer  *fb         = NULL;
    struct drm_mode_set     set;
    const char *con_name;
    unsigned hdisplay, vdisplay;
    int stride;
    int ret;
 
    drm_modeset_lock_all(dev);
 
    list_for_each_entry(tmpmode, &connector->modes, head)
    {
        if( (tmpmode->hdisplay == reqmode->width)  &&
            (tmpmode->vdisplay == 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( (tmpmode->hdisplay == reqmode->width)  &&
                (tmpmode->vdisplay == reqmode->height) )
            {
                mode = tmpmode;
                goto do_set;
            }
        };
    };
 
    DRM_ERROR("%s failed\n", __FUNCTION__);
 
    return -1;
 
do_set:
 
    con_name = connector->name;
 
    DRM_DEBUG_KMS("set mode %d %d: crtc %d connector %s\n",
              reqmode->width, reqmode->height, crtc->base.id,
              con_name);
 
    drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 
    hdisplay = mode->hdisplay;
    vdisplay = mode->vdisplay;
 
    if (crtc->invert_dimensions)
        swap(hdisplay, vdisplay);
 
    fb = crtc->primary->fb;
 
    fb->width  = reqmode->width;
    fb->height = reqmode->height;
 
        main_fb_obj->tiling_mode = I915_TILING_X;
 
    if( main_fb_obj->tiling_mode == I915_TILING_X)
    {
        if(IS_GEN3(dev))
            for (stride = 512; stride < reqmode->width * 4; stride <<= 1);
        else
            stride = ALIGN(reqmode->width * 4, 512);
    }
    else
    {
        stride = ALIGN(reqmode->width * 4, 64);
    }
 
    fb->pitches[0]  =
    fb->pitches[1]  =
    fb->pitches[2]  =
    fb->pitches[3]  = stride;
 
    main_fb_obj->stride  = stride;
 
    fb->bits_per_pixel = 32;
    fb->depth = 24;
 
    crtc->enabled = true;
    os_display->crtc = crtc;
 
//    i915_gem_object_unpin_fence(main_fb_obj);
    i915_gem_object_put_fence(main_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 = drm_mode_set_config_internal(&set);
 
    drm_modeset_unlock_all(dev);
 
    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_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;
            DRM_DEBUG_KMS("use CRTC %p ID %d\n", tmp_crtc, tmp_crtc->base.id);
            return tmp_crtc;
        };
        crtc_mask <<= 1;
    };
    return NULL;
};
 
static int choose_config(struct drm_device *dev, struct drm_connector **boot_connector,
                  struct drm_crtc **boot_crtc)
{
    struct drm_connector_helper_funcs *connector_funcs;
    struct drm_connector *connector;
    struct drm_encoder   *encoder;
    struct drm_crtc      *crtc;
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        if( connector->status != connector_status_connected)
            continue;
 
        encoder = connector->encoder;
 
        if(encoder == NULL)
        {
            connector_funcs = connector->helper_private;
            encoder = connector_funcs->best_encoder(connector);
 
        if( encoder == NULL)
        {
            DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
                        connector, connector->base.id);
            continue;
        };
        }
 
        crtc = encoder->crtc;
        if(crtc == NULL)
            crtc = get_possible_crtc(dev, encoder);
 
        if(crtc != NULL)
        {
            *boot_connector = connector;
            *boot_crtc = crtc;
 
            DRM_DEBUG_KMS("CONNECTOR %p ID:%d status:%d ENCODER %p ID: %d CRTC %p ID:%d\n",
                           connector, connector->base.id, connector->status,
                           encoder, encoder->base.id, crtc, crtc->base.id );
            return 0;
        }
        else
            DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
 
    };
 
    return -ENOENT;
};
 
static 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",
                mode->hdisplay, mode->vdisplay,
                drm_mode_vrefresh(mode));
 
        if( os_display->width  == mode->hdisplay &&
            os_display->height == mode->vdisplay &&
            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_helper_funcs *connector_funcs;
    struct drm_connector    *connector = NULL;
    struct drm_crtc         *crtc = NULL;
    struct drm_framebuffer  *fb;
 
    cursor_t  *cursor;
    u32      ifl;
    int        ret;
 
    mutex_lock(&dev->mode_config.mutex);
 
    ret = choose_config(dev, &connector, &crtc);
    if(ret)
    {
        DRM_DEBUG_KMS("No active connectors!\n");
        mutex_unlock(&dev->mode_config.mutex);
        return -1;
    };
 
    mutex_lock(&dev->object_name_lock);
    idr_preload(GFP_KERNEL);
 
    if (!main_fb_obj->base.name) {
        ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT);
 
        main_fb_obj->base.name = ret;
 
        /* Allocate a reference for the name table.  */
        drm_gem_object_reference(&main_fb_obj->base);
 
        DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, main_fb_obj->base.name );
    }
 
    idr_preload_end();
    mutex_unlock(&dev->object_name_lock);
    drm_gem_object_unreference(&main_fb_obj->base);
 
    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();
    {
        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;
 
        crtc->cursor_x = os_display->width/2;
        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  = mode->hdisplay;
            usermode->height = mode->vdisplay;
            usermode->freq   = drm_mode_vrefresh(mode);
        };
    };
 
    mutex_unlock(&dev->mode_config.mutex);
 
    set_mode(dev, os_display->connector, os_display->crtc, 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  = drmmode->hdisplay;
                mode->height = drmmode->vdisplay;
                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)
{
 
//    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) ) )
    {
        return set_mode(os_display->ddev, os_display->connector, os_display->crtc, mode, true);
    };
 
    return -1;
};
 
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)
{
    struct drm_i915_gem_object *obj = cursor->cobj;
    list_del(&cursor->list);
 
    i915_gem_object_ggtt_unpin(cursor->cobj);
 
    mutex_lock(&main_device->struct_mutex);
    drm_gem_object_unreference(&obj->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(KMS_CURSOR_WIDTH*KMS_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, KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4);
        if (unlikely(obj == NULL))
            return -ENOMEM;
 
        ret = i915_gem_obj_ggtt_pin(obj, 0,PIN_MAPPABLE | PIN_NONBLOCK);
        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_ggtt_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),
                    KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4, PG_SW);
 
        if (unlikely(bits == NULL))
        {
            i915_gem_object_ggtt_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 < KMS_CURSOR_WIDTH; j++)
            *bits++ = 0;
    }
    for(i = 0; i < KMS_CURSOR_WIDTH*(KMS_CURSOR_HEIGHT-32); i++)
        *bits++ = 0;
 
    FreeKernelSpace(mapped);
 
// release old cursor
 
    KernelFree(cursor->data);
 
    cursor->data = bits;
 
    cursor->header.destroy = destroy_cursor;
 
    return 0;
}
 
 
void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y)
{
    struct drm_crtc *crtc = os_display->crtc;
    x-= cursor->hot_x;
    y-= cursor->hot_y;
 
	crtc->cursor_x = x;
	crtc->cursor_y = y;
 
	intel_crtc_update_cursor(crtc, 1);
 
//    if (crtc->funcs->cursor_move)
//        crtc->funcs->cursor_move(crtc, x, y);
 
};
 
 
cursor_t* __stdcall select_cursor_kms(cursor_t *cursor)
{
    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
    struct drm_crtc   *crtc = os_display->crtc;
    struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
    cursor_t *old;
 
    old = os_display->cursor;
    os_display->cursor = cursor;
 
    intel_crtc->cursor_bo = cursor->cobj;
 
    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 = 64;
    intel_crtc->cursor_height = 64;
 
    move_cursor_kms(cursor, crtc->cursor_x, 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)
 
 
 
 
 
 
 
 
 
 
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_map);
            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 = os_display->win_map;
        src_offset+= winrc.top*os_display->width + winrc.left;
 
 
 
        dst_offset = (u8*)mask->bo_map;
 
        u32 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);
    }
 
err2:
    mutex_unlock(&dev->struct_mutex);
err1:
    drm_gem_object_unreference(obj);
 
    return ret;
}
 
int i915_mask_update_ex(struct drm_device *dev, void *data,
            struct drm_file *file)
{
    struct drm_i915_mask_update *mask = data;
    struct drm_gem_object *obj;
    static unsigned int mask_seqno[256];
    static warn_count;
 
    rect_t win;
    u32    winw,winh;
    u32    ml,mt,mr,mb;
    u32    slot;
    int    ret = 0;
    slot = *((u8*)CURRENT_TASK);
 
    if( mask_seqno[slot] == os_display->mask_seqno)
        return 0;
 
    GetWindowRect(&win);
    win.right+= 1;
    win.bottom+=  1;
 
    winw = win.right - win.left;
    winh = win.bottom - win.top;
 
    if(mask->dx >= winw ||
       mask->dy >= winh)
       return 1;
 
    ml = win.left + mask->dx;
    mt = win.top  + mask->dy;
    mr = ml + mask->width;
    mb = mt + mask->height;
 
    if( ml >= win.right || mt >= win.bottom ||
        mr < win.left   || mb < win.top )
        return 1;
 
    if( mr > win.right )
        mr = win.right;
 
    if( mb > win.bottom )
        mb = win.bottom;
 
    mask->width  = mr - ml;
    mask->height = mb - mt;
 
    if( mask->width == 0 ||
        mask->height== 0 )
        return 1;
 
    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;
    }
 
#if 0
    if(warn_count < 1000)
    {
        printf("left %d top %d right %d bottom %d\n",
                ml, mt, mr, mb);
        warn_count++;
    };
#endif
 
 
#if 1
 
    {
        u8* src_offset;
        u8* dst_offset;
        u32 ifl;
 
        ret = i915_mutex_lock_interruptible(dev);
        if (ret)
            goto err1;
 
        i915_gem_object_set_to_cpu_domain(to_intel_bo(obj), true);
 
        src_offset = os_display->win_map;
        src_offset+= mt*os_display->width + ml;
        dst_offset = (u8*)mask->bo_map;
 
        u32 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);
 
        i915_gem_object_set_to_gtt_domain(to_intel_bo(obj), false);
    }
#endif
 
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;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 

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

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 5060 → 5354