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"
 
extern struct drm_device *main_device;
 
 
typedef struct
{
    kobj_t     header;
 
    uint32_t  *data;
    uint32_t   hot_x;
    uint32_t   hot_y;
 
    struct list_head   list;
    struct drm_i915_gem_object  *cobj;
}cursor_t;
 
#define CURSOR_WIDTH 64
#define CURSOR_HEIGHT 64
 
 
struct tag_display
{
    int  x;
    int  y;
    int  width;
    int  height;
    int  bpp;
    int  vrefresh;
    int  pitch;
    int  lfb;
 
    int  supported_modes;
    struct drm_device    *ddev;
    struct drm_connector *connector;
    struct drm_crtc      *crtc;
 
    struct list_head   cursors;
 
    cursor_t   *cursor;
    int       (*init_cursor)(cursor_t*);
    cursor_t* (__stdcall *select_cursor)(cursor_t*);
    void      (*show_cursor)(int show);
    void      (__stdcall *move_cursor)(cursor_t *cursor, int x, int y);
    void      (__stdcall *restore_cursor)(int x, int y);
    void      (*disable_mouse)(void);
};
 
 
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 int count_connector_modes(struct drm_connector* connector)
{
    struct drm_display_mode  *mode;
    int count = 0;
 
    list_for_each_entry(mode, &connector->modes, head)
    {
        count++;
    };
    return count;
};
 
int init_display_kms(struct drm_device *dev)
{
    struct drm_connector    *connector;
    struct drm_connector_helper_funcs *connector_funcs;
    struct drm_encoder      *encoder;
    struct drm_crtc         *crtc = NULL;
    struct drm_framebuffer  *fb;
 
    cursor_t  *cursor;
    u32_t      ifl;
 
    ENTER();
 
    list_for_each_entry(connector, &dev->mode_config.connector_list, head)
    {
        if( connector->status != connector_status_connected)
            continue;
 
        connector_funcs = connector->helper_private;
        encoder = connector_funcs->best_encoder(connector);
        if( encoder == NULL)
        {
            dbgprintf("CONNECTOR %x ID: %d no active encoders\n",
                      connector, connector->base.id);
            continue;
        }
        connector->encoder = encoder;
 
        dbgprintf("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x\n",
               connector, connector->base.id,
               connector->status, connector->encoder,
               encoder->crtc);
 
        crtc = encoder->crtc;
        break;
    };
 
    if(connector == NULL)
    {
        dbgprintf("No active connectors!\n");
        return -1;
    };
 
    if(crtc == NULL)
    {
        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)
            {
                crtc = tmp_crtc;
                encoder->crtc = crtc;
                break;
            };
            crtc_mask <<= 1;
        };
    };
 
    if(crtc == NULL)
    {
        dbgprintf("No CRTC for encoder %d\n", encoder->base.id);
        return -1;
    };
 
 
    DRM_DEBUG_KMS("[Select CRTC:%d]\n", 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);
 
#define XY_COLOR_BLT        ((2<<29)|(0x50<<22)|(0x4))
#define BLT_WRITE_ALPHA     (1<<21)
#define BLT_WRITE_RGB       (1<<20)
 
#if 1
    {
 
        drm_i915_private_t *dev_priv = dev->dev_private;
        struct drm_i915_gem_object *obj;
        struct intel_ring_buffer *ring;
 
        obj = i915_gem_alloc_object(dev, 4096);
        i915_gem_object_pin(obj, 4096, true);
 
        cmd_buffer = MapIoMem(obj->pages[0], 4096, PG_SW|PG_NOCACHE);
        cmd_offset = obj->gtt_offset;
    };
#endif
 
    main_device = dev;
 
    int err;
 
    err = init_bitmaps();
    if( !err )
    {
        printf("Initialize bitmap manager\n");
    };
 
    sna_init();
 
    LEAVE();
 
    return 0;
};
 
 
bool set_mode(struct drm_device *dev, struct drm_connector *connector,
              videomode_t *reqmode, bool strict)
{
    struct drm_display_mode  *mode = NULL, *tmpmode;
    drm_i915_private_t *dev_priv = dev->dev_private;
    struct drm_fb_helper *fb_helper = &dev_priv->fbdev->helper;
 
    bool ret = false;
 
    ENTER();
 
    dbgprintf("width %d height %d vrefresh %d\n",
               reqmode->width, reqmode->height, reqmode->freq);
 
    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;
            }
        };
    };
 
do_set:
 
    if( mode != NULL )
    {
        struct drm_framebuffer   *fb;
        struct drm_encoder       *encoder;
        struct drm_crtc          *crtc;
 
        char *con_name;
        char *enc_name;
 
        encoder = connector->encoder;
        crtc = encoder->crtc;
 
        con_name = drm_get_connector_name(connector);
        enc_name = drm_get_encoder_name(encoder);
 
        dbgprintf("set mode %d %d connector %s encoder %s\n",
                   reqmode->width, reqmode->height, con_name, enc_name);
 
        fb = fb_helper->fb;
 
        fb->width  = reqmode->width;
        fb->height = reqmode->height;
        fb->pitches[0]  = ALIGN(reqmode->width * 4, 64);
        fb->pitches[1]  = ALIGN(reqmode->width * 4, 64);
        fb->pitches[2]  = ALIGN(reqmode->width * 4, 64);
        fb->pitches[3]  = ALIGN(reqmode->width * 4, 64);
 
        fb->bits_per_pixel = 32;
        fb->depth == 24;
 
        crtc->fb = fb;
        crtc->enabled = true;
        os_display->crtc = crtc;
 
        ret = drm_crtc_helper_set_mode(crtc, mode, 0, 0, fb);
 
//        select_cursor_kms(rdisplay->cursor);
//        radeon_show_cursor_kms(crtc);
 
        if (ret == true)
        {
            os_display->width    = fb->width;
            os_display->height   = fb->height;
            os_display->pitch    = fb->pitches[0];
            os_display->vrefresh = drm_mode_vrefresh(mode);
 
            sysSetScreen(fb->width, fb->height, fb->pitches[0]);
 
            dbgprintf("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);
    }
 
    LEAVE();
    return ret;
};
 
 
 
int get_videomodes(videomode_t *mode, int *count)
{
    int err = -1;
 
    ENTER();
 
    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;
    };
    LEAVE();
    return err;
};
 
int set_user_mode(videomode_t *mode)
{
    int err = -1;
 
    ENTER();
 
    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;
    };
 
    LEAVE();
    return err;
};
 
void __attribute__((regparm(1))) destroy_cursor(cursor_t *cursor)
{
/*  FIXME    synchronization */
 
    list_del(&cursor->list);
//    radeon_bo_unpin(cursor->robj);
//    KernelFree(cursor->data);
    __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;
 
    int       i,j;
    int       ret;
 
    ENTER();
 
    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_object_pin(obj, CURSOR_WIDTH*CURSOR_HEIGHT*4, true);
        if (ret) {
            drm_gem_object_unreference(&obj->base);
            return ret;
        }
 
/* You don't need to worry about fragmentation issues.
 * GTT space is continuous. I guarantee it.                           */
 
        bits = (u32*)MapIoMem(get_bus_addr() + obj->gtt_offset,
                    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;
 
// release old cursor
 
    KernelFree(cursor->data);
 
    cursor->data = bits;
 
    cursor->header.destroy = destroy_cursor;
    LEAVE();
 
    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 = cursor->cobj->gtt_offset;
    else
        intel_crtc->cursor_addr = 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;
};
 
 
 
#define XY_SRC_COPY_BLT_CMD     ((2<<29)|(0x53<<22)|6)
 
 
typedef struct
{
    int left;
    int top;
    int right;
    int bottom;
}rect_t;
 
 
#include "clip.inc"
 
void  FASTCALL GetWindowRect(rect_t *rc)__asm__("GetWindowRect");
 
#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;
}
 
#define XY_SRC_COPY_CHROMA_CMD     ((2<<29)|(0x73<<22)|8)
#define ROP_COPY_SRC               0xCC
#define FORMAT8888                 3
 
typedef int v4si __attribute__ ((vector_size (16)));
 
 
int blit_video(u32 hbitmap, int  dst_x, int dst_y,
               int src_x, int src_y, u32 w, u32 h)
{
    drm_i915_private_t *dev_priv = main_device->dev_private;
    struct intel_ring_buffer *ring;
 
    bitmap_t  *bitmap;
    rect_t     winrc;
    clip_t     dst_clip;
    clip_t     src_clip;
    u32_t      width;
    u32_t      height;
 
    u32_t      br13, cmd, slot_mask, *b;
    u32_t      offset;
    u8         slot;
    int      n=0;
 
    if(unlikely(hbitmap==0))
        return -1;
 
    bitmap = (bitmap_t*)hman_get_data(&bm_man, hbitmap);
 
    if(unlikely(bitmap==NULL))
        return -1;
 
 
    GetWindowRect(&winrc);
 
    dst_clip.xmin   = 0;
    dst_clip.ymin   = 0;
    dst_clip.xmax   = winrc.right-winrc.left-1;
    dst_clip.ymax   = winrc.bottom -winrc.top -1;
 
    src_clip.xmin   = 0;
    src_clip.ymin   = 0;
    src_clip.xmax   = bitmap->width  - 1;
    src_clip.ymax   = bitmap->height - 1;
 
    width  = w;
    height = h;
 
    if( blit_clip(&dst_clip, &dst_x, &dst_y,
                  &src_clip, &src_x, &src_y,
                  &width, &height) )
        return 0;
 
    dst_x+= winrc.left;
    dst_y+= winrc.top;
 
    slot = *((u8*)CURRENT_TASK);
 
    slot_mask = (u32_t)slot<<24;
 
    {
#if 0
        static v4si write_mask = {0xFF000000, 0xFF000000,
                                  0xFF000000, 0xFF000000};
 
        u8* src_offset;
        u8* dst_offset;
 
        src_offset = (u8*)(src_y*bitmap->pitch + src_x*4);
        src_offset += (u32)bitmap->uaddr;
 
        dst_offset = (u8*)(dst_y*os_display->width + dst_x);
        dst_offset+= get_display_map();
 
        u32_t tmp_h = height;
 
        __asm__ __volatile__ (
        "movdqa     %[write_mask],  %%xmm7    \n"
        "movd       %[slot_mask],   %%xmm6    \n"
        "punpckldq  %%xmm6, %%xmm6            \n"
        "punpcklqdq %%xmm6, %%xmm6            \n"
        :: [write_mask] "m" (write_mask),
           [slot_mask]  "g" (slot_mask)
        :"xmm7", "xmm6");
 
        while( tmp_h--)
        {
            u32_t tmp_w = width;
 
            u8* tmp_src = src_offset;
            u8* tmp_dst = dst_offset;
 
            src_offset+= bitmap->pitch;
            dst_offset+= os_display->width;
 
            while( tmp_w >= 8 )
            {
                __asm__ __volatile__ (
                "movq       (%0),   %%xmm0            \n"
                "punpcklbw  %%xmm0, %%xmm0            \n"
                "movdqa     %%xmm0, %%xmm1            \n"
                "punpcklwd  %%xmm0, %%xmm0            \n"
                "punpckhwd  %%xmm1, %%xmm1            \n"
                "pcmpeqb    %%xmm6, %%xmm0            \n"
                "pcmpeqb    %%xmm6, %%xmm1            \n"
                "maskmovdqu %%xmm7, %%xmm0            \n"
                "addl       $16, %%edi                \n"
                "maskmovdqu %%xmm7, %%xmm1            \n"
                :: "r" (tmp_dst), "D" (tmp_src)
                :"xmm0", "xmm1");
                __asm__ __volatile__ ("":::"edi");
                tmp_w -= 8;
                tmp_src += 32;
                tmp_dst += 8;
            };
 
            if( tmp_w >= 4 )
            {
                __asm__ __volatile__ (
                "movd       (%0),   %%xmm0            \n"
                "punpcklbw  %%xmm0, %%xmm0            \n"
                "punpcklwd  %%xmm0, %%xmm0            \n"
                "pcmpeqb    %%xmm6, %%xmm0            \n"
                "maskmovdqu %%xmm7, %%xmm0            \n"
                :: "r" (tmp_dst), "D" (tmp_src)
                :"xmm0");
                tmp_w -= 4;
                tmp_src += 16;
                tmp_dst += 4;
            };
 
            while( tmp_w--)
            {
                *(tmp_src+3) = (*tmp_dst==slot)?0xFF:0x00;
                tmp_src+=4;
                tmp_dst++;
            };
        };
#else
        u8* src_offset;
        u8* dst_offset;
        u32 ifl;
 
        src_offset = (u8*)(src_y*bitmap->pitch + src_x*4);
        src_offset += (u32)bitmap->uaddr;
 
        dst_offset = (u8*)(dst_y*os_display->width + dst_x);
        dst_offset+= get_display_map();
 
        u32_t tmp_h = height;
 
      ifl = safe_cli();
        while( tmp_h--)
        {
            u32_t tmp_w = width;
 
            u8* tmp_src = src_offset;
            u8* tmp_dst = dst_offset;
 
            src_offset+= bitmap->pitch;
            dst_offset+= os_display->width;
 
            while( tmp_w--)
            {
                *(tmp_src+3) = (*tmp_dst==slot)?0xFF:0x00;
                tmp_src+=4;
                tmp_dst++;
            };
        };
      safe_sti(ifl);
    }
#endif
 
    if((cmd_buffer & 0xFC0)==0xFC0)
        cmd_buffer&= 0xFFFFF000;
 
    b = (u32_t*)ALIGN(cmd_buffer,16);
 
    offset = cmd_offset + ((u32_t)b & 0xFFF);
 
    cmd = XY_SRC_COPY_CHROMA_CMD | BLT_WRITE_RGB | BLT_WRITE_ALPHA;
    cmd |= 3 << 17;
 
    br13 = os_display->pitch;
    br13|= ROP_COPY_SRC << 16;
    br13|= FORMAT8888   << 24;
 
    b[n++] = cmd;
    b[n++] = br13;
    b[n++] = (dst_y << 16) | dst_x;                   // left, top
    b[n++] = ((dst_y+height-1)<< 16)|(dst_x+width-1); // bottom, right
    b[n++] = 0;                          // destination
    b[n++] = (src_y << 16) | src_x;      // source left & top
    b[n++] = bitmap->pitch;              // source pitch
    b[n++] = bitmap->gaddr;              // source
 
    b[n++] = 0;                          // Transparency Color Low
    b[n++] = 0x00FFFFFF;                 // Transparency Color High
 
    b[n++] = MI_BATCH_BUFFER_END;
    if( n & 1)
        b[n++] = MI_NOOP;
 
    i915_gem_object_set_to_gtt_domain(bitmap->obj, false);
 
    if (HAS_BLT(main_device))
    {
 
        int ret;
 
        ring = &dev_priv->ring[BCS];
        ring->dispatch_execbuffer(ring, cmd_offset, n*4);
 
 
 
        ret = intel_ring_begin(ring, 4);
        if (ret)
            return ret;
 
        intel_ring_emit(ring, MI_FLUSH_DW);
        intel_ring_emit(ring, 0);
        intel_ring_emit(ring, 0);
        intel_ring_emit(ring, MI_NOOP);
        intel_ring_advance(ring);
    }
    else
    {
        ring = &dev_priv->ring[RCS];
        ring->dispatch_execbuffer(ring, cmd_offset, n*4);
        ring->flush(ring, 0, I915_GEM_DOMAIN_RENDER);
    };
 
    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_CPU;
    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
 
    return 0;
fail:
    return -1;
};
 
 
/* For display hotplug interrupt */
static void
ironlake_enable_display_irq(drm_i915_private_t *dev_priv, u32 mask)
{
    if ((dev_priv->irq_mask & mask) != 0) {
        dev_priv->irq_mask &= ~mask;
        I915_WRITE(DEIMR, dev_priv->irq_mask);
        POSTING_READ(DEIMR);
    }
}
 
static int ironlake_enable_vblank(struct drm_device *dev, int pipe)
{
    drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
    unsigned long irqflags;
 
//    if (!i915_pipe_enabled(dev, pipe))
//        return -EINVAL;
 
    spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
    ironlake_enable_display_irq(dev_priv, (pipe == 0) ?
                    DE_PIPEA_VBLANK : DE_PIPEB_VBLANK);
    spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
 
    return 0;
}
 
 
 
static int i915_interrupt_info(struct drm_device *dev)
{
    drm_i915_private_t *dev_priv = dev->dev_private;
    int ret, i, pipe;
 
    if (!HAS_PCH_SPLIT(dev)) {
        dbgprintf("Interrupt enable:    %08x\n",
               I915_READ(IER));
        dbgprintf("Interrupt identity:  %08x\n",
               I915_READ(IIR));
        dbgprintf("Interrupt mask:      %08x\n",
               I915_READ(IMR));
        for_each_pipe(pipe)
            dbgprintf("Pipe %c stat:         %08x\n",
                   pipe_name(pipe),
                   I915_READ(PIPESTAT(pipe)));
    } else {
        dbgprintf("North Display Interrupt enable:      %08x\n",
           I915_READ(DEIER));
        dbgprintf("North Display Interrupt identity:    %08x\n",
           I915_READ(DEIIR));
        dbgprintf("North Display Interrupt mask:        %08x\n",
           I915_READ(DEIMR));
        dbgprintf("South Display Interrupt enable:      %08x\n",
           I915_READ(SDEIER));
        dbgprintf("South Display Interrupt identity:    %08x\n",
           I915_READ(SDEIIR));
        dbgprintf("South Display Interrupt mask:        %08x\n",
           I915_READ(SDEIMR));
        dbgprintf("Graphics Interrupt enable:           %08x\n",
           I915_READ(GTIER));
        dbgprintf("Graphics Interrupt identity:         %08x\n",
           I915_READ(GTIIR));
        dbgprintf("Graphics Interrupt mask:             %08x\n",
               I915_READ(GTIMR));
    }
    dbgprintf("Interrupts received: %d\n",
           atomic_read(&dev_priv->irq_received));
    for (i = 0; i < I915_NUM_RINGS; i++) {
        if (IS_GEN6(dev) || IS_GEN7(dev)) {
            printf("Graphics Interrupt mask (%s):       %08x\n",
                   dev_priv->ring[i].name,
                   I915_READ_IMR(&dev_priv->ring[i]));
        }
//        i915_ring_seqno_info(m, &dev_priv->ring[i]);
    }
 
    return 0;
}
 
void execute_buffer (struct drm_i915_gem_object *buffer, uint32_t offset,
                     int size)
{
    struct intel_ring_buffer *ring;
    drm_i915_private_t *dev_priv = main_device->dev_private;
    u32 invalidate;
    u32 seqno = 2;
 
    offset += buffer->gtt_offset;
//    dbgprintf("execute %x size %d\n", offset, size);
 
//    asm volatile(
//    "mfence \n"
//    "wbinvd \n"
//    "mfence  \n"
//    :::"memory");
 
    ring = &dev_priv->ring[RCS];
    ring->dispatch_execbuffer(ring, offset, size);
 
    invalidate = I915_GEM_DOMAIN_COMMAND;
    if (INTEL_INFO(main_device)->gen >= 4)
        invalidate |= I915_GEM_DOMAIN_SAMPLER;
    if (ring->flush(ring, invalidate, 0))
        i915_gem_next_request_seqno(ring);
 
    ring->irq_get(ring);
 
    ring->add_request(ring, &seqno);
 
//    i915_interrupt_info(main_device);
 
//    ironlake_enable_vblank(main_device, 0);
};
 
 
int blit_textured(u32 hbitmap, int  dst_x, int dst_y,
               int src_x, int src_y, u32 w, u32 h)
{
    drm_i915_private_t *dev_priv = main_device->dev_private;
 
    bitmap_t  *src_bitmap, *dst_bitmap;
    bitmap_t   screen;
 
    rect_t     winrc;
 
//    dbgprintf("  handle: %d dx %d dy %d sx %d sy %d w %d h %d\n",
//              hbitmap, dst_x, dst_y, src_x, src_y, w, h);
 
    if(unlikely(hbitmap==0))
        return -1;
 
    src_bitmap = (bitmap_t*)hman_get_data(&bm_man, hbitmap);
//    dbgprintf("bitmap %x\n", src_bitmap);
 
    if(unlikely(src_bitmap==NULL))
        return -1;
 
    GetWindowRect(&winrc);
 
    screen.pitch  = os_display->pitch;
    screen.gaddr  = 0;
    screen.width  = os_display->width;
    screen.height = os_display->height;
    screen.obj    = (void*)-1;
 
    dst_bitmap = &screen;
 
    dst_x+= winrc.left;
    dst_y+= winrc.top;
 
    i915_gem_object_set_to_gtt_domain(src_bitmap->obj, false);
 
    sna_blit_copy(dst_bitmap, dst_x, dst_y, w, h, src_bitmap, src_x, src_y);
 
    src_bitmap->obj->base.read_domains = I915_GEM_DOMAIN_CPU;
    src_bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
 
};
 
>
 
>
#define>
#define>
#define>
#define>
 
 
typedef>
 
 
typedef>
 
 
typedef>
 
 
typedef>
 
#if>
 
#if>
#define>
#define>
#define>
#define>
#define>
#define>
 

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

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 2344 → 2351