Subversion Repositories Kolibri OS

#include 

#include "i915_drv.h"

#include "intel_drv.h"

#include 

#include 

#include 

#include 

struct drm_i915_gem_object *main_fb_obj;

u32 cmd_offset;

int  sna_init();

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

{};

{};

{

    static char name[4];

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

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

    name[3] = 0;

}

                    struct drm_crtc *crtc, videomode_t *reqmode, bool strict)

{

    struct drm_i915_private *dev_priv   = dev->dev_private;

    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;

    {

        if( (tmpmode->hdisplay == reqmode->width)  &&

            (tmpmode->vdisplay == reqmode->height) &&

            (drm_mode_vrefresh(tmpmode) == reqmode->freq) )

        {

            mode = tmpmode;

            goto do_set;

        }

    };

    {

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

        {

            if( (tmpmode->hdisplay == reqmode->width)  &&

                (tmpmode->vdisplay == reqmode->height) )

            {

                mode = tmpmode;

                goto do_set;

            }

        };

    };

              reqmode->width, reqmode->height, crtc->base.id,

              con_name);

    vdisplay = mode->vdisplay;

        swap(hdisplay, vdisplay);

    fb->height = reqmode->height;

    {

        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[1]  =

    fb->pitches[2]  =

    fb->pitches[3]  = stride;

    fb->depth = 24;

    os_display->crtc = crtc;

    i915_gem_object_put_fence(main_fb_obj);

    set.x = 0;

    set.y = 0;

    set.mode = mode;

    set.connectors = &connector;

    set.num_connectors = 1;

    set.fb = fb;

    {

        os_display->width    = fb->width;

        os_display->height   = fb->height;

        os_display->vrefresh = drm_mode_vrefresh(mode);

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

}

{

    struct drm_display_mode  *mode;

    int count = 0;

    {

        count++;

    };

    return count;

};

{

    struct drm_crtc *tmp_crtc;

    int crtc_mask = 1;

    {

        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;

};

                  struct drm_crtc **boot_crtc)

{

    struct drm_connector_helper_funcs *connector_funcs;

    struct drm_connector *connector;

    struct drm_encoder   *encoder;

    struct drm_crtc      *crtc;

    {

        if( connector->status != connector_status_connected)

            continue;

        {

            connector_funcs = connector->helper_private;

            encoder = connector_funcs->best_encoder(connector);

        {

            DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",

                        connector, connector->base.id);

            continue;

        };

        }

        if(crtc == NULL)

            crtc = get_possible_crtc(dev, encoder);

        {

            *boot_connector = connector;

            *boot_crtc = crtc;

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

};

{

    struct drm_display_mode *mode;

    {

        DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",

                mode->hdisplay, mode->vdisplay,

                drm_mode_vrefresh(mode));

            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;

}

{

    struct drm_connector_helper_funcs *connector_funcs;

    struct drm_connector    *connector = NULL;

    struct drm_crtc         *crtc = NULL;

    struct drm_framebuffer  *fb;

    u32      ifl;

    int        ret;

    if(ret)

    {

        DRM_DEBUG_KMS("No active connectors!\n");

        mutex_unlock(&dev->mode_config.mutex);

        return -1;

    };

    idr_preload(GFP_KERNEL);

        ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT);

        drm_gem_object_reference(&main_fb_obj->base);

    }

    mutex_unlock(&dev->object_name_lock);

    drm_gem_object_unreference(&main_fb_obj->base);

    os_display->ddev = dev;

    os_display->connector = connector;

    os_display->crtc = crtc;

    {

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

        {

            init_cursor(cursor);

        };

        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_y = os_display->height/2;

    };

    safe_sti(ifl);

        (usermode->height == 0))

    {

        if( !get_boot_mode(connector, usermode))

        {

            struct drm_display_mode *mode;

            usermode->width  = mode->hdisplay;

            usermode->height = mode->vdisplay;

            usermode->freq   = drm_mode_vrefresh(mode);

        };

    };

    err = init_bitmaps();

#endif

};

{

    int err = -1;

    {

        *count = os_display->supported_modes;

        err = 0;

    }

    else if( mode != NULL )

    {

        struct drm_display_mode  *drmmode;

        int i = 0;

            *count = os_display->supported_modes;

        {

            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;

};

{

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

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

    };

};

{

    const struct drm_connector_funcs *f = os_display->connector->funcs;

};

{

    struct drm_i915_gem_object *obj = cursor->cobj;

    list_del(&cursor->list);

    drm_gem_object_unreference(&obj->base);

    mutex_unlock(&main_device->struct_mutex);

};

{

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

    {

        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;

        if (ret) {

            drm_gem_object_unreference(&obj->base);

            return ret;

        }

        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.                           */

                    KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4, PG_SW);

        {

            i915_gem_object_ggtt_unpin(obj);

            drm_gem_object_unreference(&obj->base);

            return -ENOMEM;

        };

        cursor->cobj = obj;

    };

    {

        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;

}

{

    struct drm_crtc *crtc = os_display->crtc;

    x-= cursor->hot_x;

    y-= cursor->hot_y;

	crtc->cursor_y = y;

//        crtc->funcs->cursor_move(crtc, x, y);

{

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

    os_display->cursor = cursor;

       intel_crtc->cursor_addr = i915_gem_obj_ggtt_offset(cursor->cobj);

    else

        intel_crtc->cursor_addr = (addr_t)cursor->cobj;

    intel_crtc->cursor_height = 64;

    return old;

};

{

    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;

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

    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;

}

{

    int left;

    int top;

    int right;

    int bottom;

}rect_t;

            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;

    if (obj == NULL)

        return -ENOENT;

        drm_gem_object_unreference_unlocked(obj);

        return -EINVAL;

    }

    {

//        static warn_count;

        mask->height   = winrc.bottom - winrc.top + 1;

        mask->bo_pitch = (mask->width+15) & ~15;

        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

    {

        u8* src_offset;

        u8* dst_offset;

        u32 ifl;

        if (ret)

            goto err1;

        if(ret != 0 )

        {

            dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__);

            goto err2;

        };

        src_offset+= winrc.top*os_display->width + winrc.left;

        {

            mask_seqno[slot] = os_display->mask_seqno;

            "movd       %[slot],   %%xmm6         \n"

            "punpckldq  %%xmm6, %%xmm6            \n"

            "punpcklqdq %%xmm6, %%xmm6            \n"

            :: [slot]  "m" (slot)

            :"xmm6");

            {

                int tmp_w = mask->width;

                u8* tmp_dst = dst_offset;

                dst_offset+= mask->bo_pitch;

                {

                    __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"

                    :"xmm0","xmm1","xmm2","xmm3");

                    tmp_w -= 64;

                    tmp_src += 64;

                    tmp_dst += 64;

                }

                {

                    __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"

                    :"xmm0","xmm1");

                    tmp_w -= 32;

                    tmp_src += 32;

                    tmp_dst += 32;

                }

                {

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

                }

                {

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

    }

    mutex_unlock(&dev->struct_mutex);

err1:

    drm_gem_object_unreference(obj);

}

            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;

    u32    winw,winh;

    u32    ml,mt,mr,mb;

    u32    slot;

    int    ret = 0;

    slot = *((u8*)CURRENT_TASK);

        return 0;

    win.right+= 1;

    win.bottom+=  1;

    winh = win.bottom - win.top;

       mask->dy >= winh)

       return 1;

    mt = win.top  + mask->dy;

    mr = ml + mask->width;

    mb = mt + mask->height;

        mr < win.left   || mb < win.top )

        return 1;

        mr = win.right;

        mb = win.bottom;

    mask->height = mb - mt;

        mask->height== 0 )

        return 1;

    if (obj == NULL)

        return -ENOENT;

        drm_gem_object_unreference_unlocked(obj);

        return -EINVAL;

    }

    if(warn_count < 1000)

    {

        printf("left %d top %d right %d bottom %d\n",

                ml, mt, mr, mb);

        warn_count++;

    };

#endif

        u8* src_offset;

        u8* dst_offset;

        u32 ifl;

        if (ret)

            goto err1;

        src_offset+= mt*os_display->width + ml;

        dst_offset = (u8*)mask->bo_map;

        {

            mask_seqno[slot] = os_display->mask_seqno;

            "movd       %[slot],   %%xmm6         \n"

            "punpckldq  %%xmm6, %%xmm6            \n"

            "punpcklqdq %%xmm6, %%xmm6            \n"

            :: [slot]  "m" (slot)

            :"xmm6");

            {

                int tmp_w = mask->width;

                u8* tmp_dst = dst_offset;

                dst_offset+= mask->bo_pitch;

                {

                    __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"

                    :"xmm0","xmm1","xmm2","xmm3");

                    tmp_w -= 64;

                    tmp_src += 64;

                    tmp_dst += 64;

                }

                {

                    __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"

                    :"xmm0","xmm1");

                    tmp_w -= 32;

                    tmp_src += 32;

                    tmp_dst += 32;

                }

                {

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

                }

                {

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

    }

#endif

    mutex_unlock(&dev->struct_mutex);

err1:

    drm_gem_object_unreference(obj);

}

{

    u32 tmp = GetTimerTicks();

    ts->tv_nsec = (tmp - ts->tv_sec*100)*10000000;

}

{

    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;

}

prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state)

{

    unsigned long flags;

    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;

    /*

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

    }

}

{

    list_del_init(&wait->task_list);