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

+            }
         };
     };
-    printf("%s failed\n", __FUNCTION__);
+    DRM_ERROR("%s failed\n", __FUNCTION__);
     return -1;
         os_display->vrefresh = drm_mode_vrefresh(mode);
         sysSetScreen(fb->width, fb->height, fb->pitches[0]);
-        dbgprintf("new mode %d x %d pitch %d\n",
+        DRM_DEBUG_KMS("new mode %d x %d pitch %d\n",
                        fb->width, fb->height, fb->pitches[0]);
+    }
     else
         DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
         connector->encoder = encoder;
         crtc = encoder->crtc;
-        dbgprintf("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x",
+        DRM_DEBUG_KMS("CONNECTOR %x ID:  %d status %d encoder %x\n crtc %x",
                    connector, connector->base.id,
                    connector->status, connector->encoder,
     cursor_t  *cursor;
     u32_t      ifl;
     int        err;
-//    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",
+            DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
                       connector, connector->base.id);
             continue;
+        }
         connector->encoder = encoder;
         crtc = encoder->crtc;
-        dbgprintf("CONNECTOR %x ID:%d status:%d ENCODER %x CRTC %x ID:%d\n",
+        DRM_DEBUG_KMS("CONNECTOR %x ID:%d status:%d ENCODER %x CRTC %x ID:%d\n",
                connector, connector->base.id,
                connector->status, connector->encoder,
                crtc, crtc->base.id );
         break;
     };
     if(connector == NULL)
+    {
     };
     if(crtc == NULL)
+    {
-        dbgprintf("No CRTC for encoder %d\n", encoder->base.id);
+        DRM_ERROR("No CRTC for encoder %d\n", encoder->base.id);
         return -1;
     };
     main_device = dev;
-    err = init_bitmaps();
-    if( !err )
-    {
-        printf("Initialize bitmap manager\n");
-    };
-//    LEAVE();
+    err = init_bitmaps();
     return 0;
 };
-int get_videomodes(videomode_t *mode, int *count)
-    int err = -1;
+int get_videomodes(videomode_t *mode, int *count)
+{
-//    ENTER();
+    int err = -1;
         };
         *count = i;
         err = 0;
     };
-//    LEAVE();
+    return err;
-    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( 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);
-    list_del(&cursor->list);
+    i915_gem_object_unpin(cursor->cobj);
-//    radeon_bo_unpin(cursor->robj);
+    mutex_lock(&main_device->struct_mutex);
+    drm_gem_object_unreference(&cursor->cobj->base);
+    mutex_unlock(&main_device->struct_mutex);
 //    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 *bits;
+    uint32_t *src;
-    uint32_t *src;
+    void     *mapped;
-    int       i,j;
     int       ret;
     int       i,j;
-//    ENTER();
+    int       ret;
     if (dev_priv->info->cursor_needs_physical)
 /* You don't need to worry about fragmentation issues.
  * GTT space is continuous. I guarantee it.                           */
-        bits = (u32*)MapIoMem(dev_priv->mm.gtt->gma_bus_addr + obj->gtt_offset,
+        mapped = bits = (u32*)MapIoMem(dev_priv->mm.gtt->gma_bus_addr + obj->gtt_offset,
                     CURSOR_WIDTH*CURSOR_HEIGHT*4, PG_SW);
         if (unlikely(bits == NULL))
+    }
     for(i = 0; i < CURSOR_WIDTH*(CURSOR_HEIGHT-32); i++)
         *bits++ = 0;
+    FreeKernelSpace(mapped);
 // release old cursor
     KernelFree(cursor->data);
-    cursor->data = bits;
     cursor->data = bits;
     cursor->header.destroy = destroy_cursor;
+typedef int v4si __attribute__ ((vector_size (16)));
 typedef int v4si __attribute__ ((vector_size (16)));
 static void
-static void
+i915_gem_execbuffer_retire_commands(struct drm_device *dev,
-i915_gem_execbuffer_retire_commands(struct drm_device *dev,
-                    struct intel_ring_buffer *ring)
-{
-    struct drm_i915_gem_request *request;
-    u32 invalidate;
+                    struct drm_file *file,
-    u32 req;
-    /*
-     * Ensure that the commands in the batch buffer are
-     * finished before the interrupt fires.
-     *
-     * The sampler always gets flushed on i965 (sigh).
-     */
-    invalidate = I915_GEM_DOMAIN_COMMAND;
+                    struct intel_ring_buffer *ring)
-    if (INTEL_INFO(dev)->gen >= 4)
-        invalidate |= I915_GEM_DOMAIN_SAMPLER;
-    if (ring->flush(ring, invalidate, 0)) {
         i915_gem_next_request_seqno(ring);
-        return;
+    /* Unconditionally force add_request to emit a full flush. */
-    }
-    /* Add a breadcrumb for the completion of the batch buffer */
+    ring->gpu_caches_dirty = true;
-    if (request == NULL || i915_add_request(ring, NULL, &req)) {
-        i915_gem_next_request_seqno(ring);
-    }
-}
     /* Add a breadcrumb for the completion of the batch buffer */
     (void)i915_add_request(ring, file, NULL);
+}
     u32_t      br13, cmd, slot_mask, *b;
     u32_t      offset;
     u8         slot;
     int      n=0;
+    int        ret;
     if(unlikely(hbitmap==0))
         return -1;
         b[n++] = MI_NOOP;
     context->cmd_buffer+= n*4;
+    context->obj->base.pending_read_domains |= I915_GEM_DOMAIN_COMMAND;
+    mutex_lock(&main_device->struct_mutex);
-//    i915_gem_object_set_to_gtt_domain(bitmap->obj, false);
+    i915_gem_object_set_to_gtt_domain(bitmap->obj, false);
+    if (HAS_BLT(main_device))
-    if (HAS_BLT(main_device))
+    {
         u32 seqno;
-        int ret;
+        int i;
+        ring = &dev_priv->ring[BCS];
+//        printf("dispatch...  ");
+        i915_gem_object_sync(bitmap->obj, ring);
+        intel_ring_invalidate_all_caches(ring);
+        seqno = i915_gem_next_request_seqno(ring);
+//        printf("seqno = %d\n", seqno);
+        for (i = 0; i < ARRAY_SIZE(ring->sync_seqno); i++) {
+            if (seqno < ring->sync_seqno[i]) {
+            /* The GPU can not handle its semaphore value wrapping,
+             * so every billion or so execbuffers, we need to stall
+             * the GPU in order to reset the counters.
+             */
+                DRM_DEBUG("wrap seqno\n");
+                ret = i915_gpu_idle(main_device);
+                if (ret)
+                    goto fail;
+                i915_gem_retire_requests(main_device);
+                BUG_ON(ring->sync_seqno[i]);
+            }
+        }
-        ring = &dev_priv->ring[BCS];
+        ret = ring->dispatch_execbuffer(ring, offset, n*4);
+        if (ret)
+            goto fail;
+//        printf("done\n");
+        bitmap->obj->base.read_domains = bitmap->obj->base.pending_read_domains;
+        bitmap->obj->base.write_domain = bitmap->obj->base.pending_write_domain;
-//        printf("dispatch...  ");
+        bitmap->obj->fenced_gpu_access = bitmap->obj->pending_fenced_gpu_access;
         ring->dispatch_execbuffer(ring, offset, n*4);
-//        printf("done\n");
+        i915_gem_object_move_to_active(bitmap->obj, ring, seqno);
-        i915_gem_execbuffer_retire_commands(main_device, ring);
+        i915_gem_execbuffer_retire_commands(main_device, NULL, ring);
 //        printf("retire\n");
+    }
     else
+    {
         ring = &dev_priv->ring[RCS];
         ring->dispatch_execbuffer(ring, offset, n*4);
         ring->flush(ring, 0, I915_GEM_DOMAIN_RENDER);
     };
-    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_CPU;
+//    bitmap->obj->base.read_domains = I915_GEM_DOMAIN_CPU;
-    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
+//    bitmap->obj->base.write_domain = I915_GEM_DOMAIN_CPU;
 int __queue_work(struct workqueue_struct *wq,
                          struct work_struct *work)
+{
     unsigned long flags;
 //    ENTER();
 //    dbgprintf("wq: %x, work: %x\n",
 //               wq, work );
     spin_unlock_irqrestore(&wq->lock, flags);
 //    dbgprintf("wq: %x head %x, next %x\n",
 //               wq, &wq->worklist, wq->worklist.next);
 //    LEAVE();
     return 1;
 };
-void __stdcall delayed_work_timer_fn(unsigned long __data)
 void __stdcall delayed_work_timer_fn(unsigned long __data)
 //    ENTER();
     struct delayed_work *dwork = (struct delayed_work *)__data;
     struct workqueue_struct *wq = dwork->work.data;
-//    dbgprintf("wq: %x, work: %x\n",
-//               wq, &dwork->work );
+//    dbgprintf("wq: %x, work: %x\n",
 //               wq, &dwork->work );
     __queue_work(wq, &dwork->work);
 int queue_delayed_work(struct workqueue_struct *wq,
                         struct delayed_work *dwork, unsigned long delay)
+{
     u32  flags;
-//    ENTER();
 //    dbgprintf("wq: %x, work: %x\n",
 //               wq, &dwork->work );

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c @ 4293 – Rev 3033 → 3037