WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/radeon_ring.c

 int radeon_ib_get(struct radeon_device *rdev, struct radeon_ib **ib)
+{
 	struct radeon_fence *fence;
-	struct radeon_ib *nib;
-	unsigned long i;
+	struct radeon_ib *nib;
-	int r = 0;
+	int r = 0, i, c;
 	*ib = NULL;
 	r = radeon_fence_create(rdev, &fence);
 	if (r) {
-		DRM_ERROR("failed to create fence for new IB\n");
+		dev_err(rdev->dev, "failed to create fence for new IB\n");
 		return r;
 	}
     mutex_lock(&rdev->ib_pool.mutex);
-	i = find_first_zero_bit(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
-	if (i < RADEON_IB_POOL_SIZE) {
+	for (i = rdev->ib_pool.head_id, c = 0, nib = NULL; c < RADEON_IB_POOL_SIZE; c++, i++) {
-		set_bit(i, rdev->ib_pool.alloc_bm);
+		i &= (RADEON_IB_POOL_SIZE - 1);
-		rdev->ib_pool.ibs[i].length_dw = 0;
-		*ib = &rdev->ib_pool.ibs[i];
+		if (rdev->ib_pool.ibs[i].free) {
-		mutex_unlock(&rdev->ib_pool.mutex);
+			nib = &rdev->ib_pool.ibs[i];
+			break;
-		goto out;
+	}
 	}
-	if (list_empty(&rdev->ib_pool.scheduled_ibs)) {
+	if (nib == NULL) {
-		/* we go do nothings here */
+		/* This should never happen, it means we allocated all
-		mutex_unlock(&rdev->ib_pool.mutex);
-		DRM_ERROR("all IB allocated none scheduled.\n");
+		 * IB and haven't scheduled one yet, return EBUSY to
-		r = -EINVAL;
+		 * userspace hoping that on ioctl recall we get better
-		goto out;
-	}
+		 * luck
-	/* get the first ib on the scheduled list */
-	nib = list_entry(rdev->ib_pool.scheduled_ibs.next,
-			 struct radeon_ib, list);
-	if (nib->fence == NULL) {
+		 */
-		/* we go do nothings here */
+		dev_err(rdev->dev, "no free indirect buffer !\n");
 		mutex_unlock(&rdev->ib_pool.mutex);
-		DRM_ERROR("IB %lu scheduled without a fence.\n", nib->idx);
-		r = -EINVAL;
+		radeon_fence_unref(&fence);
+		return -EBUSY;
+	}
+	rdev->ib_pool.head_id = (nib->idx + 1) & (RADEON_IB_POOL_SIZE - 1);
-		goto out;
+	nib->free = false;
-	}
-	mutex_unlock(&rdev->ib_pool.mutex);
+	if (nib->fence) {
 		mutex_unlock(&rdev->ib_pool.mutex);
 	r = radeon_fence_wait(nib->fence, false);
 	if (r) {
+			dev_err(rdev->dev, "error waiting fence of IB(%u:0x%016lX:%u)\n",
+				nib->idx, (unsigned long)nib->gpu_addr, nib->length_dw);
-		DRM_ERROR("radeon: IB(%lu:0x%016lX:%u)\n", nib->idx,
+			mutex_lock(&rdev->ib_pool.mutex);
+			nib->free = true;
-			  (unsigned long)nib->gpu_addr, nib->length_dw);
+			mutex_unlock(&rdev->ib_pool.mutex);
+			radeon_fence_unref(&fence);
+			return r;
 		DRM_ERROR("radeon: GPU lockup detected, fail to get a IB\n");
-		goto out;
+		mutex_lock(&rdev->ib_pool.mutex);
-	}
+	}
 	radeon_fence_unref(&nib->fence);
-	nib->length_dw = 0;
-	/* scheduled list is accessed here */
-	mutex_lock(&rdev->ib_pool.mutex);
-	list_del(&nib->list);
+	nib->fence = fence;
-	INIT_LIST_HEAD(&nib->list);
-	mutex_unlock(&rdev->ib_pool.mutex);
+	nib->length_dw = 0;
-	*ib = nib;
-out:
-	if (r) {
-		radeon_fence_unref(&fence);
-	} else {
-		(*ib)->fence = fence;
+	mutex_unlock(&rdev->ib_pool.mutex);
 	*ib = nib;
-	return r;
+	return 0;
+}
 void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib **ib)
+{
 	struct radeon_ib *tmp = *ib;
-	*ib = NULL;
-	if (tmp == NULL) {
-		return;
-	}
-	mutex_lock(&rdev->ib_pool.mutex);
-	if (!list_empty(&tmp->list) && !radeon_fence_signaled(tmp->fence)) {
-		/* IB is scheduled & not signaled don't do anythings */
-		mutex_unlock(&rdev->ib_pool.mutex);
-		return;
+	*ib = NULL;
 	if (tmp == NULL) {
-	list_del(&tmp->list);
-	INIT_LIST_HEAD(&tmp->list);
+		return;
-	if (tmp->fence)
+	}
-		radeon_fence_unref(&tmp->fence);
+	if (!tmp->fence->emited)
 		radeon_fence_unref(&tmp->fence);
-	tmp->length_dw = 0;
+	mutex_lock(&rdev->ib_pool.mutex);
-	clear_bit(tmp->idx, rdev->ib_pool.alloc_bm);
+	tmp->free = true;
 	mutex_unlock(&rdev->ib_pool.mutex);
+}
 int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib)
+{
 	int r = 0;
 	if (!ib->length_dw || !rdev->cp.ready) {
 		return r;
+	}
 	radeon_ring_ib_execute(rdev, ib);
 	radeon_fence_emit(rdev, ib->fence);
 	mutex_lock(&rdev->ib_pool.mutex);
-	list_add_tail(&ib->list, &rdev->ib_pool.scheduled_ibs);
+	/* once scheduled IB is considered free and protected by the fence */
+	ib->free = true;
 	mutex_unlock(&rdev->ib_pool.mutex);
 	radeon_ring_unlock_commit(rdev);
 	return 0;
+}
 #endif
 	int r = 0;
 	if (rdev->ib_pool.robj)
 		return 0;
-	/* Allocate 1M object buffer */
-	INIT_LIST_HEAD(&rdev->ib_pool.scheduled_ibs);
+	/* Allocate 1M object buffer */
 	r = radeon_bo_create(rdev, NULL,  RADEON_IB_POOL_SIZE*64*1024,
 				 true, RADEON_GEM_DOMAIN_GTT,
 				&rdev->ib_pool.robj);
 	if (r) {
 		offset = i * 64 * 1024;
 		rdev->ib_pool.ibs[i].gpu_addr = gpu_addr + offset;
 		rdev->ib_pool.ibs[i].ptr = ptr + offset;
 		rdev->ib_pool.ibs[i].idx = i;
 		rdev->ib_pool.ibs[i].length_dw = 0;
-		INIT_LIST_HEAD(&rdev->ib_pool.ibs[i].list);
+		rdev->ib_pool.ibs[i].free = true;
+	}
-	bitmap_zero(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
+	rdev->ib_pool.head_id = 0;
 	rdev->ib_pool.ready = true;
 	DRM_INFO("radeon: ib pool ready.\n");
 	if (radeon_debugfs_ib_init(rdev)) {
 		DRM_ERROR("Failed to register debugfs file for IB !\n");
+	}
 	if (!rdev->ib_pool.ready) {
 		return;
+	}
-	mutex_lock(&rdev->ib_pool.mutex);
-	bitmap_zero(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
+	mutex_lock(&rdev->ib_pool.mutex);
 	if (rdev->ib_pool.robj) {
 		r = radeon_bo_reserve(rdev->ib_pool.robj, false);
 		if (likely(r == 0)) {
 			radeon_bo_kunmap(rdev->ib_pool.robj);
 	unsigned i;
 	if (ib == NULL) {
 		return 0;
 	}
-	seq_printf(m, "IB %04lu\n", ib->idx);
+	seq_printf(m, "IB %04u\n", ib->idx);
 	seq_printf(m, "IB fence %p\n", ib->fence);
 	seq_printf(m, "IB size %05u dwords\n", ib->length_dw);
 	for (i = 0; i < ib->length_dw; i++) {
 		seq_printf(m, "[%05u]=0x%08X\n", i, ib->ptr[i]);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_ring.c – Rev 1404 → 1428