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

 /* 1 second timeout */
 #define UVD_IDLE_TIMEOUT_MS	1000
+/* Firmware Names */
+#define FIRMWARE_R600		"radeon/R600_uvd.bin"
 #define FIRMWARE_RS780		"radeon/RS780_uvd.bin"
-/* Firmware Names */
+#define FIRMWARE_RV770		"radeon/RV770_uvd.bin"
 #define FIRMWARE_RV710		"radeon/RV710_uvd.bin"
 #define FIRMWARE_CYPRESS	"radeon/CYPRESS_uvd.bin"
 #define FIRMWARE_SUMO		"radeon/SUMO_uvd.bin"
 	int i, r;
 //   INIT_DELAYED_WORK(&rdev->uvd.idle_work, radeon_uvd_idle_work_handler);
+	switch (rdev->family) {
+	case CHIP_RV610:
+	case CHIP_RV630:
+	case CHIP_RV670:
+	case CHIP_RV620:
+	case CHIP_RV635:
+		fw_name = FIRMWARE_R600;
+		break;
+	case CHIP_RS780:
+	case CHIP_RS880:
+		fw_name = FIRMWARE_RS780;
+		break;
+	case CHIP_RV770:
+		fw_name = FIRMWARE_RV770;
 		break;
 	switch (rdev->family) {
 	case CHIP_RV710:
 	case CHIP_RV730:
 	case CHIP_RV740:
 	release_firmware(rdev->uvd_fw);
+}
 int radeon_uvd_suspend(struct radeon_device *rdev)
-{
-	unsigned size;
-	void *ptr;
+{
-	int i;
+	int i, r;
 	if (rdev->uvd.vcpu_bo == NULL)
 		return 0;
+	for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i) {
-	for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i)
+		uint32_t handle = atomic_read(&rdev->uvd.handles[i]);
-		if (atomic_read(&rdev->uvd.handles[i]))
-			break;
+		if (handle != 0) {
+			struct radeon_fence *fence;
+			radeon_uvd_note_usage(rdev);
+			r = radeon_uvd_get_destroy_msg(rdev,
-	if (i == RADEON_MAX_UVD_HANDLES)
+				R600_RING_TYPE_UVD_INDEX, handle, &fence);
-		return 0;
+			if (r) {
+				DRM_ERROR("Error destroying UVD (%d)!\n", r);
-	size = radeon_bo_size(rdev->uvd.vcpu_bo);
+				continue;
+			}
-	size -= rdev->uvd_fw->size;
+			radeon_fence_wait(fence, false);
 			radeon_fence_unref(&fence);
 	ptr = rdev->uvd.cpu_addr;
 	size -= rdev->uvd_fw->size;
 	ptr = rdev->uvd.cpu_addr;
-	ptr += rdev->uvd_fw->size;
-	if (rdev->uvd.saved_bo != NULL) {
-		memcpy(ptr, rdev->uvd.saved_bo, size);
-		kfree(rdev->uvd.saved_bo);
-		rdev->uvd.saved_bo = NULL;
+	ptr += rdev->uvd_fw->size;
 	} else
-		memset(ptr, 0, size);
+	memset(ptr, 0, size);
 	buf_sizes[0x1] = dpb_size;
 	buf_sizes[0x2] = image_size;
 	return 0;
+}
+static int radeon_uvd_validate_codec(struct radeon_cs_parser *p,
+				     unsigned stream_type)
+{
+	switch (stream_type) {
+	case 0: /* H264 */
+	case 1: /* VC1 */
+		/* always supported */
+		return 0;
+	case 3: /* MPEG2 */
+	case 4: /* MPEG4 */
+		/* only since UVD 3 */
+		if (p->rdev->family >= CHIP_PALM)
+			return 0;
+		/* fall through */
+	default:
+		DRM_ERROR("UVD codec not supported by hardware %d!\n",
+			  stream_type);
+		return -EINVAL;
+	}
+}
 static int radeon_uvd_cs_msg(struct radeon_cs_parser *p, struct radeon_bo *bo,
 			     unsigned offset, unsigned buf_sizes[])
+{
 	int32_t *msg, msg_type, handle;
 	if (handle == 0) {
 		DRM_ERROR("Invalid UVD handle!\n");
 		return -EINVAL;
+	}
-	if (msg_type == 1) {
-		/* it's a decode msg, calc buffer sizes */
-		r = radeon_uvd_cs_msg_decode(msg, buf_sizes);
-		/* calc image size (width * height) */
-		img_size = msg[6] * msg[7];
-		radeon_bo_kunmap(bo);
-		if (r)
-			return r;
-	} else if (msg_type == 2) {
-		/* it's a destroy msg, free the handle */
-		for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i)
-			atomic_cmpxchg(&p->rdev->uvd.handles[i], handle, 0);
-		radeon_bo_kunmap(bo);
-		return 0;
+	switch (msg_type) {
-	} else {
+	case 0:
 		/* it's a create msg, calc image size (width * height) */
+		img_size = msg[7] * msg[8];
-		img_size = msg[7] * msg[8];
+		r = radeon_uvd_validate_codec(p, msg[4]);
+		radeon_bo_kunmap(bo);
+		if (r)
-		radeon_bo_kunmap(bo);
+			return r;
+		/* try to alloc a new handle */
+		for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i) {
-		if (msg_type != 0) {
+			if (atomic_read(&p->rdev->uvd.handles[i]) == handle) {
-			DRM_ERROR("Illegal UVD message type (%d)!\n", msg_type);
+				DRM_ERROR("Handle 0x%x already in use!\n", handle);
-			return -EINVAL;
+				return -EINVAL;
+			}
+			if (!atomic_cmpxchg(&p->rdev->uvd.handles[i], 0, handle)) {
+				p->rdev->uvd.filp[i] = p->filp;
 				p->rdev->uvd.img_size[i] = img_size;
+				return 0;
+			}
+		}
+		DRM_ERROR("No more free UVD handles!\n");
+		return -EINVAL;
+	case 1:
+		/* it's a decode msg, validate codec and calc buffer sizes */
+		r = radeon_uvd_validate_codec(p, msg[4]);
+		if (!r)
+			r = radeon_uvd_cs_msg_decode(msg, buf_sizes);
+		radeon_bo_kunmap(bo);
-		/* it's a create msg, no special handling needed */
+		if (r)
-	}
+			return r;
+		/* validate the handle */
+		for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i) {
+			if (atomic_read(&p->rdev->uvd.handles[i]) == handle) {
 				if (p->rdev->uvd.filp[i] != p->filp) {
-	/* create or decode, validate the handle */
+					DRM_ERROR("UVD handle collision detected!\n");
+					return -EINVAL;
+				}
+				return 0;
+			}
+		}
-	for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i) {
-		if (atomic_read(&p->rdev->uvd.handles[i]) == handle)
+		DRM_ERROR("Invalid UVD handle 0x%x!\n", handle);
-			return 0;
+		return -ENOENT;
-	}
-	/* handle not found try to alloc a new one */
+	case 2:
+		/* it's a destroy msg, free the handle */
+		for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i)
-	for (i = 0; i < RADEON_MAX_UVD_HANDLES; ++i) {
+			atomic_cmpxchg(&p->rdev->uvd.handles[i], handle, 0);
+		radeon_bo_kunmap(bo);
+		return 0;
 		if (!atomic_cmpxchg(&p->rdev->uvd.handles[i], 0, handle)) {
-			p->rdev->uvd.filp[i] = p->filp;
+	default:
 			p->rdev->uvd.img_size[i] = img_size;
-			return 0;
+		DRM_ERROR("Illegal UVD message type (%d)!\n", msg_type);
 		return -EINVAL;
+	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/radeon_uvd.c – Rev 5271 → 6104