path: root/drivers/gpu/drm/qxl/qxl_cmd.c

/* QXL cmd/ring handling */

#include "qxl_drv.h"
#include "qxl_object.h"

struct ring {
	struct qxl_ring_header      header;
	uint8_t                     elements[0];
};

struct qxl_ring {
	volatile struct ring *ring;
	int			element_size;
	int			n_elements;
	int			prod_notify;
};

void qxl_ring_free(struct qxl_ring *ring)
{
	kfree(ring);
}

struct qxl_ring *
qxl_ring_create(struct qxl_ring_header *header,
		int element_size,
		int n_elements,
		int prod_notify)
{
	struct qxl_ring *ring;

	ring = kmalloc (sizeof(*ring), GFP_KERNEL);
	if (!ring)
		return NULL;

	ring->ring = (volatile struct ring *)header;
	ring->element_size = element_size;
	ring->n_elements = n_elements;
	ring->prod_notify = prod_notify;

	return ring;
}

void qxl_ring_push(struct qxl_ring *ring,
		   const void *new_elt)
{
	volatile struct qxl_ring_header *header = &(ring->ring->header);
	volatile uint8_t *elt;
	int idx;

	// TODO - wait on interrupt
	while (header->prod - header->cons == header->num_items) {
		header->notify_on_cons = header->cons + 1;
		mb();
	}

	idx = header->prod & (ring->n_elements - 1);
	elt = ring->ring->elements + idx * ring->element_size;

	memcpy((void *)elt, new_elt, ring->element_size);

	header->prod++;
	
	mb();

	if (header->prod == header->notify_on_prod)
		outb (0, ring->prod_notify);
}

bool qxl_ring_pop (struct qxl_ring *ring,
		   void *element)
{
	volatile struct qxl_ring_header *header = &(ring->ring->header);
	volatile uint8_t *ring_elt;
	int idx;

	if (header->cons == header->prod)
		return false;

	idx = header->cons & (ring->n_elements - 1);
	ring_elt = ring->ring->elements + idx * ring->element_size;

	memcpy (element, (void *)ring_elt, ring->element_size);

	header->cons++;

	return true;
}

void qxl_ring_wait_idle (struct qxl_ring *ring)
{
	// TODO: wait on interrupt
	while (ring->ring->header.cons != ring->ring->header.prod)
	{
		msleep (1);
		mb();
	}
}

void qxl_bo_free(struct qxl_bo *bo)
{
	int ret;
	ret = qxl_bo_reserve(bo, false);
	if (!ret) {
		qxl_bo_kunmap(bo);
		qxl_bo_unpin(bo);
		qxl_bo_unreserve(bo);
	}
	drm_gem_object_release(&bo->gem_base);
	qxl_bo_unref(&bo);
}

struct drm_qxl_release *qxl_release_from_id_locked(struct qxl_device *qdev, uint64_t id)
{
	struct drm_qxl_release *release;

	release = idr_find(&qdev->release_idr, id);
	if (!release) {
		DRM_ERROR("failed to find id in release_idr\n");
		return NULL;
	}
	if (release->bo_count < 1) {
		DRM_ERROR("read a released resource with 0 bos\n");
		return NULL;
	}
	//QXL_INFO(qdev, "got release %d bos\n", release->bo_count);
	return release;
}

int qxl_garbage_collect(struct qxl_device *qdev)
{
	struct drm_qxl_release *release;
	uint64_t id;
	int i = 0;
	union qxl_release_info *info;
    
	mutex_lock(&qdev->release_idr_mutex);
	while (qxl_ring_pop (qdev->release_ring, &id)) {
		QXL_INFO(qdev, "popped %lld\n", id);
		while (id) {
			release = qxl_release_from_id_locked(qdev, id);
			if (release == NULL) {
				break;
			}
			info = (union qxl_release_info*)release->bos[0]->kptr;
			//struct qxl_cursor_cmd *cmd = (struct qxl_cursor_cmd *)info;
			QXL_INFO(qdev, "popped %lld, next %lld\n", id, info->next);

			switch (release->type) {
			case QXL_RELEASE_DRAWABLE:
			case QXL_RELEASE_SURFACE_CMD:
			case QXL_RELEASE_CURSOR_CMD:
				break;
			default:
				DRM_ERROR("unexpected release type\n");
				break;
			}
#if 0
			if (is_cursor && cmd->type == QXL_CURSOR_SET) {
				struct qxl_cursor *cursor = (void *)qxl_virtual_address
					(qdev, (void *)cmd->u.set.shape);
				qxl_free(qdev->mem, cursor);
			} else if (!is_cursor && drawable->type == QXL_DRAW_COPY) {
				struct qxl_image *image = qxl_virtual_address(qdev, 
									      (void *)drawable->u.copy.src_bitmap);
				qxl_image_destroy (qdev, image);
			}
#endif
			id = info->next;
			qxl_release_free_locked(qdev, release);
			++i;
		}
	}
	mutex_unlock(&qdev->release_idr_mutex);
	QXL_INFO(qdev, "%s: %lld\n", __FUNCTION__, i);

	return i;
}

/* create and pin bo */
static struct qxl_bo *qxl_create_pinned_bo(struct qxl_device *qdev,
					   unsigned long size)
{
	struct qxl_bo *bo;
	int ret;

	ret = qxl_bo_create(qdev, size, false /* not kernel - device */,
			   QXL_GEM_DOMAIN_VRAM, &bo);
	if (ret) {
		DRM_ERROR("failed to allocate VRAM BO\n");
		return NULL;
	}
	ret = qxl_bo_reserve(bo, false);
	if (unlikely(ret != 0))
		goto out_unref;

	ret = qxl_bo_pin(bo, QXL_GEM_DOMAIN_VRAM, NULL);
	if (ret) {
		DRM_ERROR("failed to pin VRAM BO %d\n", ret);
		goto out_unref;
	}

	ret = qxl_bo_kmap(bo, NULL);
	qxl_bo_unreserve(bo); /* this memory will be reserved via mmap */
	//qxl_io_log(qdev, "%s: gpu offset 0x%llX, kptr 0x%p\n", __func__,
	//	 qxl_bo_gpu_offset(bo), bo->kptr);
	if (ret)
		goto out_unref;
	return bo;
out_unref:
	qxl_bo_unref(&bo);
	return NULL;
}

void *qxl_allocnf(struct qxl_device *qdev, unsigned long size,
	          struct drm_qxl_release *release)
{
	struct qxl_bo *bo;

	qxl_garbage_collect(qdev);
	bo = qxl_create_pinned_bo(qdev, size);
	qxl_release_add_res(qdev, release, bo);
	//QXL_INFO(qdev, "allocated %lu bytes (really TODO)\n", size);
	return bo->kptr;
}

static void wait_for_io_cmd(struct qxl_device *qdev, uint8_t val, long port)
{
	int irq_num = atomic_read(&qdev->irq_received_io_cmd);
	long addr = qdev->io_base + port;

	mutex_lock(&qdev->async_io_mutex);
	outb(val, addr);
	wait_event_interruptible(qdev->io_cmd_event,
		atomic_read(&qdev->irq_received_io_cmd) > irq_num);
	mutex_unlock(&qdev->async_io_mutex);
}

void qxl_io_update_area(struct qxl_device *qdev, uint32_t surface_id,
                        const struct qxl_rect *area)
{
	qdev->ram_header->update_area = *area;
	qdev->ram_header->update_surface = surface_id;
	wait_for_io_cmd(qdev, 0, QXL_IO_UPDATE_AREA_ASYNC);
}

void qxl_io_notify_oom(struct qxl_device *qdev)
{
	// TODO: async (add lock, implement interrupt, wait on lock)
	outb(0, qdev->io_base + QXL_IO_NOTIFY_OOM);
}

void qxl_io_update_screen(struct qxl_device *qdev)
{
	struct qxl_rect area;
	u32 height, width;

	height = qdev->fbdev_qfb->base.height;
	width = qdev->fbdev_qfb->base.width;
	QXL_INFO(qdev, "%s: bad bad bad %dx%d\n", __func__,
		 width, height);
	area.left = area.top = 0;
	area.right = width;
	area.bottom = height;

	qxl_io_update_area(qdev, 0, &area);
}

void qxl_io_destroy_primary(struct qxl_device *qdev)
{
	if (!qdev->primary_created) {
		return;
	}
	wait_for_io_cmd(qdev, 0, QXL_IO_DESTROY_PRIMARY_ASYNC);
	qdev->primary_created = 0;
}

void qxl_io_create_primary(struct qxl_device *qdev, unsigned width, unsigned height)
{
	struct qxl_surface_create *create;
	int32_t stride = width * 4;

	QXL_INFO(qdev, "%s: qdev %p, ram_header %p\n", __func__, qdev,
		 qdev->ram_header);
	create = &qdev->ram_header->create_surface;
	create->format = SPICE_SURFACE_FMT_32_xRGB;
	create->width = width;
	create->height = height;
	// TODO? stride should be positive
	//create->stride = stride;
	//create->mem = qxl_physical_address(qdev, 0, qdev->main_mem_slot);
	create->stride = -stride;
	create->mem = qxl_bo_physical_address(qdev,
					      qdev->surface0_bo, 0,
					      qdev->main_mem_slot);
	QXL_INFO(qdev, "%s: mem = %llx, from %p\n", __func__, create->mem,
		 qdev->surface0_bo->kptr);

	create->flags = 0;
	create->type = QXL_SURF_TYPE_PRIMARY;

	qdev->primary_created = 1;
	qdev->primary_width = width;
	qdev->primary_height = height;

	wait_for_io_cmd(qdev, 0, QXL_IO_CREATE_PRIMARY_ASYNC);
}

void qxl_io_memslot_add(struct qxl_device *qdev, uint8_t id)
{
	QXL_INFO(qdev, "qxl_memslot_add %d\n", id);
	wait_for_io_cmd(qdev, id, QXL_IO_MEMSLOT_ADD_ASYNC);
}

void qxl_io_log(struct qxl_device *qdev, const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	vsnprintf(qdev->ram_header->log_buf, QXL_LOG_BUF_SIZE, fmt, args);
	va_end(args);
	// DO not do a DRM output here - this will call printk, which will
	// call back into qxl for rendering (qxl_fb)
	//DRM_ERROR("%s", qdev->ram_header->log_buf);
	outb(0, qdev->io_base + QXL_IO_LOG);
}

void qxl_io_reset(struct qxl_device *qdev)
{
	outb(0, qdev->io_base + QXL_IO_RESET);
}

void qxl_io_monitors_config(struct qxl_device *qdev)
{
	wait_for_io_cmd(qdev, 0, QXL_IO_MONITORS_CONFIG_ASYNC);
}