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 "bitmap.h"
 #include
+void  FASTCALL sysSetFramebuffer(void *fb)__asm__("SetFramebuffer");
+void kolibri_framebuffer_update(struct drm_i915_private *dev_priv, struct kos_framebuffer *kfb);
+void init_system_cursors(struct drm_device *dev);
 addr_t dummy_fb_page;
-display_t *os_display;
 struct drm_i915_gem_object *main_fb_obj;
-struct drm_framebuffer     *main_framebuffer;
+display_t *os_display;
 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)
-{};
-struct mutex cursor_lock;
 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 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;
 };
+struct drm_framebuffer *get_framebuffer(struct drm_device *dev, struct drm_display_mode *mode, int tiling)
+{
+    struct drm_i915_private *dev_priv = dev->dev_private;
+    struct intel_fbdev     *ifbdev = dev_priv->fbdev;
+    struct intel_framebuffer *intel_fb = ifbdev->fb;
+    struct drm_framebuffer *fb = &intel_fb->base;
+    struct drm_i915_gem_object *obj = NULL;
+    int stride, size;
+ENTER();
+    stride = mode->hdisplay *4;
+    if(tiling)
+    {
+        int gen3size;
+        if(IS_GEN3(dev))
+            for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1);
+        else
+            stride = ALIGN(stride, 512);
+        size = stride * ALIGN(mode->vdisplay, 8);
+        if(IS_GEN3(dev))
+        {
+            for (gen3size = 1024*1024; gen3size < size; gen3size <<= 1);
+            size = gen3size;
+        }
+        else
+            size = ALIGN(size, 4096);
+    }
+    else
+    {
+        stride = ALIGN(stride, 64);
+        size = stride * ALIGN(mode->vdisplay, 2);
+    }
+    dbgprintf("size %x stride %x\n", size, stride);
+    if(intel_fb == NULL || size > intel_fb->obj->base.size)
+    {
+        struct drm_mode_fb_cmd2 mode_cmd = {};
+        int ret;
+        DRM_DEBUG_KMS("remove old framebuffer\n");
+        drm_framebuffer_remove(fb);
+        ifbdev->fb = NULL;
+        fb = NULL;
+        DRM_DEBUG_KMS("create new framebuffer\n");
+        mode_cmd.width  = mode->hdisplay;
+        mode_cmd.height = mode->vdisplay;
+        mode_cmd.pitches[0] = stride;
+        mode_cmd.pixel_format = DRM_FORMAT_XRGB8888;
+        mutex_lock(&dev->struct_mutex);
+        /* If the FB is too big, just don't use it since fbdev is not very
+        * important and we should probably use that space with FBC or other
+        * features. */
+        if (size * 2 < dev_priv->gtt.stolen_usable_size)
+            obj = i915_gem_object_create_stolen(dev, size);
+        if (obj == NULL)
+            obj = i915_gem_alloc_object(dev, size);
+        if (!obj) {
+            DRM_ERROR("failed to allocate framebuffer\n");
+            ret = -ENOMEM;
+            goto out;
+        }
+        fb = __intel_framebuffer_create(dev, &mode_cmd, obj);
+        if (IS_ERR(fb)) {
+            ret = PTR_ERR(fb);
+            goto out_unref;
+        }
+        /* Flush everything out, we'll be doing GTT only from now on */
+        ret = intel_pin_and_fence_fb_obj(NULL, fb, NULL, NULL, NULL);
+        if (ret) {
+            DRM_ERROR("failed to pin obj: %d\n", ret);
+            goto out_fb;
+        }
+        mutex_unlock(&dev->struct_mutex);
+        ifbdev->fb = to_intel_framebuffer(fb);
+    }
+    obj = ifbdev->fb->obj;
+    if(tiling)
+    {
+        obj->tiling_mode = I915_TILING_X;
+        fb->modifier[0]  = I915_FORMAT_MOD_X_TILED;
+        obj->fence_dirty = true;
+        obj->stride      = stride;
+    };
+    fb->width  = mode->hdisplay;
+    fb->height = mode->vdisplay;
+    fb->pitches[0]  =
+    fb->pitches[1]  =
+    fb->pitches[2]  =
+    fb->pitches[3]  = stride;
+    fb->bits_per_pixel = 32;
+    fb->depth = 24;
+LEAVE();
+    return fb;
+out_fb:
+    drm_framebuffer_remove(fb);
+out_unref:
+    drm_gem_object_unreference(&obj->base);
+out:
+    mutex_unlock(&dev->struct_mutex);
+    return NULL;
+}
 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_mode_config  *config     = &dev->mode_config;
     struct drm_display_mode *mode       = NULL, *tmpmode;
     struct drm_connector    *tmpc;
     struct drm_framebuffer  *fb         = NULL;
     struct drm_mode_set     set;
-    const char *con_name;
+    char  con_edid[128];
-    unsigned hdisplay, vdisplay;
+    int ret;
-    int stride;
-    int ret;
     drm_modeset_lock_all(dev);
     list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
+    {
         const struct drm_connector_funcs *f = tmpc->funcs;
         if(tmpc == connector)
             continue;
         f->dpms(tmpc, DRM_MODE_DPMS_OFF);
     };
     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;
+            }
         };
     };
+out:
+    drm_modeset_unlock_all(dev);
     DRM_ERROR("%s failed\n", __FUNCTION__);
     return -1;
 do_set:
+    drm_modeset_unlock_all(dev);
+    fb = get_framebuffer(dev, mode, 1);
+    if(fb == NULL)
+    {
+        DRM_ERROR("%s failed\n", __FUNCTION__);
+        return -1;
+    };
-    con_name = connector->name;
+    drm_framebuffer_reference(fb);
+    drm_modeset_lock_all(dev);
-    char  con_edid[128];
+    memcpy(con_edid, connector->edid_blob_ptr->data, 128);
+    DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"
                   "monitor: %s model %x serial number %u\n",
-    memcpy(con_edid, connector->edid_blob_ptr->data, 128);
+                mode->hdisplay, mode->vdisplay,
-    DRM_DEBUG_KMS("Manufacturer: %s Model %x Serial Number %u\n",
+                crtc->base.id, connector->name,
             manufacturer_name(con_edid + 0x08),
             (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
             (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
             + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
-    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;
-    if(fb == NULL)
-        fb = main_framebuffer;
-    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_put_fence(main_fb_obj);
-    printf("fb:%p %dx%dx pitch %d format %x\n",
+    DRM_DEBUG_KMS("fb:%p %dx%dx pitch %d format %x\n",
             fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
     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);
     if ( !ret )
+    {
-        os_display->width    = fb->width;
+        struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
+        struct kos_framebuffer *kfb = intel_fb->private;
+        kolibri_framebuffer_update(dev_priv, kfb);
+        DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb);
+        os_display->width    = mode->hdisplay;
-        os_display->height   = fb->height;
+        os_display->height   = mode->vdisplay;
         os_display->vrefresh = drm_mode_vrefresh(mode);
         sysSetFramebuffer(intel_fb->private);
+        sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);
+        os_display->connector = connector;
+        os_display->crtc = connector->encoder->crtc;
+        os_display->supported_modes = count_connector_modes(connector);
+        crtc->cursor_x = os_display->width/2;
+        crtc->cursor_y = os_display->height/2;
-        sysSetScreen(fb->width, fb->height, fb->pitches[0]);
+        os_display->select_cursor(os_display->cursor);
         DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
-                       fb->width, fb->height, fb->pitches[0]);
+                       mode->hdisplay, mode->vdisplay, fb->pitches[0]);
+    }
     else
         DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
                    fb->width, fb->height, crtc);
+    drm_framebuffer_unreference(fb);
     drm_modeset_unlock_all(dev);
     return ret;
+}
 static int set_mode_ex(struct drm_device *dev,
                        struct drm_connector *connector, struct drm_display_mode *mode)
+{
     struct drm_i915_private *dev_priv = dev->dev_private;
     struct drm_connector    *tmpc;
     struct drm_mode_config  *config   = &dev->mode_config;
     struct drm_framebuffer  *fb       = NULL;
     struct drm_mode_set     set;
-    char  con_edid[128];
+    struct drm_crtc *crtc = NULL;
+    char  con_edid[128];
     int stride;
     int ret;
+    fb = get_framebuffer(dev, mode, 1);
+    if(fb == NULL)
+    {
+        DRM_ERROR("%s failed\n", __FUNCTION__);
+        return -1;
+    };
+    drm_framebuffer_reference(fb);
     drm_modeset_lock_all(dev);
     list_for_each_entry(tmpc, &dev->mode_config.connector_list, head)
+    {
         const struct drm_connector_funcs *f = tmpc->funcs;
         if(tmpc == connector)
             continue;
         f->dpms(tmpc, DRM_MODE_DPMS_OFF);
     };
-    drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
-    fb = connector->encoder->crtc->primary->fb;
+    crtc = connector->encoder->crtc;
-    if(fb == NULL)
-        fb = main_framebuffer;
-    fb->width  = mode->hdisplay;
-    fb->height = mode->vdisplay;;
-    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 < mode->hdisplay * 4; stride <<= 1);
-        else
-            stride = ALIGN(mode->hdisplay * 4, 512);
-    }
-    else
-    {
-        stride = ALIGN(mode->hdisplay * 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;
-    connector->encoder->crtc->enabled = true;
-    i915_gem_object_put_fence(main_fb_obj);
     memcpy(con_edid, connector->edid_blob_ptr->data, 128);
     DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n"
                   "monitor: %s model %x serial number %u\n",
-                fb->width, fb->height,
+                mode->hdisplay, mode->vdisplay,
                 connector->encoder->crtc->base.id, connector->name,
                 manufacturer_name(con_edid + 0x08),
                 (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
                 (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
                 + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
+    drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+    crtc->enabled = true;
+    os_display->crtc = crtc;
     DRM_DEBUG_KMS("use framebuffer %p %dx%d pitch %d format %x\n",
             fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format);
-    set.crtc = connector->encoder->crtc;
+    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);
     if ( !ret )
+    {
-        struct drm_crtc *crtc = os_display->crtc;
+        struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
+        struct kos_framebuffer *kfb = intel_fb->private;
+        kolibri_framebuffer_update(dev_priv, kfb);
+        DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb);
-        os_display->width    = fb->width;
+        os_display->width    = mode->hdisplay;
-        os_display->height   = fb->height;
+        os_display->height   = mode->vdisplay;
         os_display->vrefresh = drm_mode_vrefresh(mode);
+        sysSetFramebuffer(intel_fb->private);
-        sysSetScreen(fb->width, fb->height, fb->pitches[0]);
+        sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]);
         os_display->connector = connector;
         os_display->crtc = connector->encoder->crtc;
         os_display->supported_modes = count_connector_modes(connector);
         crtc->cursor_x = os_display->width/2;
         crtc->cursor_y = os_display->height/2;
-        select_cursor_kms(os_display->cursor);
+        os_display->select_cursor(os_display->cursor);
         DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
-                       fb->width, fb->height, fb->pitches[0]);
+                       mode->hdisplay, mode->vdisplay, fb->pitches[0]);
+    }
     else
         DRM_ERROR(" failed to set mode %d_%d on crtc %p\n",
                    fb->width, fb->height, connector->encoder->crtc);
+    drm_framebuffer_unreference(fb);
     drm_modeset_unlock_all(dev);
     return ret;
+}
 static int set_cmdline_mode(struct drm_device *dev, struct drm_connector *connector)
+{
     struct drm_display_mode *mode;
     int retval;
     mode = drm_mode_create_from_cmdline_mode(dev, &connector->cmdline_mode);
     if(mode == NULL)
         return EINVAL;
     retval = set_mode_ex(dev, connector, mode);
     drm_mode_destroy(dev, mode);
     return retval;
 };
 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 check_connector(struct drm_device *dev, struct drm_connector *connector)
+{
     const struct drm_connector_helper_funcs *connector_funcs;
     struct drm_encoder   *encoder;
     struct drm_crtc      *crtc;
     if( connector->status != connector_status_connected)
         return -EINVAL;
     encoder = connector->encoder;
     if(encoder == NULL)
+    {
         connector_funcs = connector->helper_private;
         encoder = connector_funcs->best_encoder(connector);
         if( encoder == NULL)
+        {
             DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n",
             connector->name, connector->base.id);
             return -EINVAL;
         };
         connector->encoder = encoder;
+    }
     crtc = encoder->crtc;
     if(crtc == NULL)
         crtc = get_possible_crtc(dev, encoder);
     if(crtc != NULL)
+    {
         DRM_DEBUG_KMS("%s connector: %p encode: %p crtc: %p\n",__FUNCTION__,
                connector, encoder, crtc);
         return 0;
+    }
     else
         DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
     return -EINVAL;
+}
 static struct drm_connector* get_cmdline_connector(struct drm_device *dev, const char *cmdline)
+{
     struct drm_connector *connector;
     list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    {
         int name_len = __builtin_strlen(connector->name);
         if (name_len == 0)
             continue;
         if (__builtin_strncmp(connector->name, cmdline, name_len))
             continue;
         if(check_connector(dev, connector) == 0)
             return connector;
+    }
     return NULL;
+}
 static int choose_config(struct drm_device *dev, struct drm_connector **boot_connector,
                   struct drm_crtc **boot_crtc)
+{
     struct drm_connector *connector;
     if((i915.cmdline_mode != NULL) && (*i915.cmdline_mode != 0))
+    {
         connector = get_cmdline_connector(dev, i915.cmdline_mode);
         if(connector != NULL)
+        {
             *boot_connector = connector;
             *boot_crtc = connector->encoder->crtc;
             return 0;
+        }
+    }
     list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    {
         if(check_connector(dev, connector) == 0)
+        {
             *boot_connector = connector;
             *boot_crtc = connector->encoder->crtc;
             return 0;
         };
     };
     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)
+    {
         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;
+    struct drm_plane *plane;
-    cursor_t  *cursor;
-    u32      ifl;
     int       ret;
+ENTER();
+    drm_for_each_plane(plane, dev)
+    {
+        drm_plane_helper_disable(plane);
+    };
     mutex_lock(&dev->mode_config.mutex);
     ret = choose_config(dev, &connector, &crtc);
     if(ret)
+    {
         mutex_unlock(&dev->mode_config.mutex);
         DRM_DEBUG_KMS("No active connectors!\n");
         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;
         main_fb_obj->base.handle_count++;
         DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, main_fb_obj->base.name );
+    }
     idr_preload_end();
-    idr_preload_end();
     mutex_unlock(&dev->object_name_lock);
 */
+    dummy_fb_page = AllocPage();
     os_display = GetDisplay();
     os_display->ddev = dev;
     os_display->connector = connector;
     os_display->crtc = crtc;
     os_display->supported_modes = count_connector_modes(connector);
     mutex_unlock(&dev->mode_config.mutex);
-    mutex_init(&cursor_lock);
+    init_system_cursors(dev);
-    mutex_lock(&dev->struct_mutex);
-    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);
-    mutex_unlock(&dev->struct_mutex);
     ret = -1;
     if(connector->cmdline_mode.specified == true)
         ret = set_cmdline_mode(dev, connector);
     if(ret !=0)
+    {
         mutex_lock(&dev->mode_config.mutex);
         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 ret;
 };
 int set_cmdline_mode_ext(struct drm_device *dev, const char *cmdline)
+{
     struct drm_connector_helper_funcs *connector_funcs;
     struct drm_connector    *connector;
     struct drm_cmdline_mode cmd_mode = {0};
     struct drm_display_mode *mode;
     char *mode_option;
     int retval = 0;
     char  con_edid[128];
     if((cmdline == NULL) || (*cmdline == 0))
         return EINVAL;
     mutex_lock(&dev->mode_config.mutex);
     connector = get_cmdline_connector(dev, cmdline);
     mutex_unlock(&dev->mode_config.mutex);
     if(connector == NULL)
         return EINVAL;
     mode_option = __builtin_strchr(cmdline,':');
     if(mode_option == NULL)
         return EINVAL;
     mode_option++;
     if( !drm_mode_parse_command_line_for_connector(mode_option, connector, &cmd_mode))
         return EINVAL;
     DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
                    connector->name,
                    cmd_mode.xres, cmd_mode.yres,
                    cmd_mode.refresh_specified ? cmd_mode.refresh : 60,
                    cmd_mode.rb ? " reduced blanking" : "",
                    cmd_mode.margins ? " with margins" : "",
                    cmd_mode.interlace ?  " interlaced" : "");
     mode = drm_mode_create_from_cmdline_mode(dev, &cmd_mode);
     if(mode == NULL)
         return EINVAL;
     memcpy(con_edid, connector->edid_blob_ptr->data, 128);
     DRM_DEBUG_KMS("connector: %s monitor: %s model %x serial number %u\n",
             connector->name,
             manufacturer_name(con_edid + 0x08),
             (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
             (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
             + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
     retval = set_mode_ex(dev, connector, mode);
     drm_mode_destroy(dev, mode);
     return retval;
+}
 void list_connectors(struct drm_device *dev)
+{
     struct drm_connector *connector;
     char  con_edid[128];
     mutex_lock(&dev->mode_config.mutex);
     list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+    {
         if( connector->status != connector_status_connected)
             continue;
         memcpy(con_edid, connector->edid_blob_ptr->data, 128);
         if(connector ==  os_display->connector)
+        {
             printf("%s mode %dx%d connected %s model %x serial number %u\n",
                    connector->name, os_display->width, os_display->height,
                    manufacturer_name(con_edid + 0x08),
                    (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
                    (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
                    + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
             continue;
+        }
         else
+        {
             printf("%s connected: %s model %x serial number %u\n",
                 connector->name, manufacturer_name(con_edid + 0x08),
                 (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)),
                 (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8)
                 + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24)));
+        }
     };
     mutex_unlock(&dev->mode_config.mutex);
+}
 int list_connector_modes(struct drm_device *dev, const char* name)
+{
     struct drm_connector *connector;
     struct drm_display_mode  *drmmode;
     mutex_lock(&dev->mode_config.mutex);
     connector = get_cmdline_connector(dev, name);
     if(connector == NULL)
+    {
         mutex_unlock(&dev->mode_config.mutex);
         return EINVAL;
     };
     printf("connector %s probed modes :\n", connector->name);
     list_for_each_entry(drmmode, &connector->modes, head)
+    {
         printf("%dx%d@%d\n", drmmode->hdisplay, drmmode->vdisplay, drm_mode_vrefresh(drmmode));
     };
     mutex_unlock(&dev->mode_config.mutex);
     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)
+int i915_fbinfo(struct drm_i915_fb_info *fb)
-{
-    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*8);
+    u32 ifl;
-        if (unlikely(bits == NULL))
-            return ENOMEM;
-        cursor->cobj = (struct drm_i915_gem_object *)GetPgAddr(bits);
-    else
+    ifl = safe_cli();
     {
+        struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
+        struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
-        obj = i915_gem_alloc_object(os_display->ddev, KMS_CURSOR_WIDTH*KMS_CURSOR_HEIGHT*4);
+        struct kos_framebuffer *kfb = os_display->current_lfb;
+        struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)kfb->private;
+        struct drm_i915_gem_object *obj = intel_fb->obj;
-        if (unlikely(obj == NULL))
-            return -ENOMEM;
+        fb->name   = obj->base.name;
+        fb->width  = os_display->width;
+        fb->height = os_display->height;
-        ret = i915_gem_object_ggtt_pin(obj, &i915_ggtt_view_normal, 128*1024, PIN_GLOBAL);
+        fb->pitch  = obj->stride;
-        if (ret) {
+        fb->tiling = obj->tiling_mode;
-            drm_gem_object_unreference(&obj->base);
-            return ret;
-        }
+        fb->crtc   = crtc->base.base.id;
-        ret = i915_gem_object_set_to_gtt_domain(obj, true);
-        if (ret)
-        {
+        fb->pipe   = crtc->pipe;
             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.                           */
+    safe_sti(ifl);
     return 0;
-        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))
+int kolibri_framebuffer_init(struct intel_framebuffer *intel_fb)
-        {
-            i915_gem_object_ggtt_unpin(obj);
+{
-            drm_gem_object_unreference(&obj->base);
+    struct kos_framebuffer *kfb;
-            return -ENOMEM;
+    addr_t dummy_table;
-        };
+    addr_t *pt_addr = NULL;
-        cursor->cobj = obj;
+    int pde;
-    };
+ENTER();
-    src = cursor->data;
+    kfb = kzalloc(sizeof(struct kos_framebuffer),0);
-    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;
+    kfb->private = intel_fb;
+    for(pde = 0; pde < 8; pde++)
+    {
+        dummy_table = AllocPage();
+        kfb->pde[pde] = dummy_table|PG_UW;
     FreeKernelSpace(mapped);
+        pt_addr = kmap((struct page*)dummy_table);
+        __builtin_memset(pt_addr,0,4096);
+        kunmap((struct page*)dummy_table);
+    };
+    intel_fb->private = kfb;
+LEAVE();
-    KernelFree(cursor->data);
+    return 0;
+#if 0
     struct sg_page_iter sg_iter;
-    cursor->data = bits;
-    cursor->header.destroy = destroy_cursor;
-    return 0;
-}
-void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y)
-{
+    num_pages = obj->base.size/4096;
-    struct drm_crtc *crtc = os_display->crtc;
-    struct drm_plane_state *cursor_state = crtc->cursor->state;
-    x-= cursor->hot_x;
-    y-= cursor->hot_y;
-	crtc->cursor_x = x;
-	crtc->cursor_y = y;
+    printf("num_pages %d\n",num_pages);
-    cursor_state->crtc_x = x;
-    cursor_state->crtc_y = y;
+    pte = 0;
-	intel_crtc_update_cursor(crtc, 1);
+    pde = 0;
-};
+    pt_addr = NULL;
-cursor_t* __stdcall select_cursor_kms(cursor_t *cursor)
+    __sg_page_iter_start(&sg_iter, obj->pages->sgl, sg_nents(obj->pages->sgl), 0);
-{
-    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
+    while (__sg_page_iter_next(&sg_iter))
-    struct drm_crtc   *crtc = os_display->crtc;
-    struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+    {
+        if (pt_addr == NULL)
-    cursor_t *old;
+    {
+            addr_t pt = AllocPage();
-    old = os_display->cursor;
+            kfb->pde[pde] = pt|PG_UW;
-    mutex_lock(&cursor_lock);
+            pde++;
+            pt_addr = kmap_atomic((struct page*)pt);
-    os_display->cursor = cursor;
+    }
+        pt_addr[pte] = sg_page_iter_dma_address(&sg_iter)|PG_UW|PG_WRITEC;
+        if( (pte & 15) == 0)
+            DRM_DEBUG_KMS("pte %x\n",pt_addr[pte]);
+        if (++pte == 1024)
+    {
+            kunmap_atomic(pt_addr);
+            pt_addr = NULL;
-    if (!dev_priv->info.cursor_needs_physical)
+            if (pde == 8)
+                break;
-       intel_crtc->cursor_addr = i915_gem_obj_ggtt_offset(cursor->cobj);
+            pte = 0;
-    else
+        }
         intel_crtc->cursor_addr = (addr_t)cursor->cobj;
-	intel_crtc->base.cursor->state->crtc_w = 64;
-	intel_crtc->base.cursor->state->crtc_h = 64;
+    if(pt_addr)
-    intel_crtc->base.cursor->state->rotation = 0;
-    mutex_unlock(&cursor_lock);
+        {
+        for(;pte < 1024; pte++)
-    move_cursor_kms(cursor, crtc->cursor_x, crtc->cursor_y);
+            pt_addr[pte] = dummy_page|PG_UW;
-    return old;
+        kunmap_atomic(pt_addr);
-};
+        }
+#endif
-int i915_fbinfo(struct drm_i915_fb_info *fb)
+};
+void kolibri_framebuffer_update(struct drm_i915_private *dev_priv, struct kos_framebuffer *kfb)
+{
+    struct intel_framebuffer *intel_fb = kfb->private;
+    addr_t *pt_addr = NULL;
+    int pte = 0;
+    int pde = 0;
+    int num_pages;
+    addr_t pfn;
-{
+ENTER();
+    num_pages = intel_fb->obj->base.size/4096;
+    pfn = dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(intel_fb->obj);
+    while(num_pages)
+        {
+        if (pt_addr == NULL)
+        {
+            addr_t pt = kfb->pde[pde] & 0xFFFFF000;
+            pde++;
-    struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
+            pt_addr = kmap_atomic((struct page*)pt);
+        }
+        pt_addr[pte] = pfn|PG_UW|PG_WRITEC;
+        pfn+= 4096;
+        num_pages--;
+        if (++pte == 1024)
+        {
+            kunmap_atomic(pt_addr);
+            pt_addr = NULL;
-    struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
+            if (pde == 8)
-    struct drm_i915_gem_object *obj = get_fb_obj();
+                break;
             pte = 0;
     fb->name   = obj->base.name;
     fb->width  = os_display->width;
     fb->height = os_display->height;
-    fb->pitch  = obj->stride;
+    if(pt_addr)
     fb->tiling = obj->tiling_mode;
-    fb->crtc   = crtc->base.base.id;
+        for(;pte < 1024; pte++)
-    fb->pipe   = crtc->pipe;
+            pt_addr[pte] = dummy_fb_page|PG_UW;
         kunmap_atomic(pt_addr);
     return 0;
 LEAVE();
 };
 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->forced == 0 && mask_seqno[slot] == os_display->mask_seqno)
         return 0;
     if(mask->forced)
         memset((void*)mask->bo_map,0,mask->width * mask->height);
     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;
     ret = i915_mutex_lock_interruptible(dev);
     if (ret)
         return ret;
     obj = drm_gem_object_lookup(dev, file, mask->handle);
     if (obj == NULL)
+    {
         ret = -ENOENT;
         goto unlock;
+    }
     if (!obj->filp)
+    {
         ret = -ENOENT;
         goto out;
+    }
 #if 0
     if(warn_count < 100)
+    {
         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;
         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
 out:
     drm_gem_object_unreference(obj);
 unlock:
     mutex_unlock(&dev->struct_mutex);
     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 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;
+}
+>
+>
+>
+>
+>
+>
+>
+>
+>
+>
+>
+>

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 6131 → 6283