 @@ -1,14 +1,14 @@
-/*	$NetBSD: vmwgfx_cmdbuf.c,v 1.5 2022/10/25 23:32:04 riastradh Exp $	*/
+/*	$NetBSD: vmwgfx_cmdbuf.c,v 1.6 2022/10/25 23:33:44 riastradh Exp $	*/
 // SPDX-License-Identifier: GPL-2.0 OR MIT
 /**************************************************************************
+ *
  * Copyright 2015 VMware, Inc., Palo Alto, CA., USA
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
 @@ -18,27 +18,27 @@
  * of the Software.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
  **************************************************************************/
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vmwgfx_cmdbuf.c,v 1.5 2022/10/25 23:32:04 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vmwgfx_cmdbuf.c,v 1.6 2022/10/25 23:33:44 riastradh Exp $");
 #include <linux/dmapool.h>
 #include <linux/pci.h>
 #include <drm/ttm/ttm_bo_api.h>
 #include "vmwgfx_drv.h"
 #include <linux/nbsd-namespace.h>
 /*
  * Size of inline command buffers. Try to make sure that a page size is a
  * multiple of the DMA pool allocation size.
 @@ -122,28 +122,28 @@ struct vmw_cmdbuf_man {
 	struct vmw_cmdbuf_context ctx[SVGA_CB_CONTEXT_MAX];
 	struct list_head error;
 	struct drm_mm mm;
 	struct ttm_buffer_object *cmd_space;
 	struct ttm_bo_kmap_obj map_obj;
 	u8 *map;
 	struct vmw_cmdbuf_header *cur;
 	size_t cur_pos;
 	size_t default_size;
 	unsigned max_hw_submitted;
 	spinlock_t lock;
 	struct dma_pool *headers;
 	struct dma_pool *dheaders;
-	wait_queue_head_t alloc_queue;
+	drm_waitqueue_t alloc_queue;
-	wait_queue_head_t idle_queue;
+	drm_waitqueue_t idle_queue;
 	bool irq_on;
 	bool using_mob;
 	bool has_pool;
 #ifdef __NetBSD__
 	bus_dmamap_t dmamap;
 	bus_dma_segment_t dmaseg;
 #endif
 	dma_addr_t handle;
 	size_t size;
 	u32 num_contexts;
 };
 /**
 @@ -266,27 +266,27 @@ static void vmw_cmdbuf_header_inline_fre
  */
 static void __vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header)
+{
 	struct vmw_cmdbuf_man *man = header->man;
 	lockdep_assert_held_once(&man->lock);
 	if (header->inline_space) {
 		vmw_cmdbuf_header_inline_free(header);
 		return;
+	}
 	drm_mm_remove_node(&header->node);
-	wake_up_all(&man->alloc_queue);
+	DRM_SPIN_WAKEUP_ALL(&man->alloc_queue, &man->lock); /* XXX */
 	if (header->cb_header)
 		dma_pool_free(man->headers, header->cb_header,
 			      header->handle);
 	kfree(header);
+}
 /**
  * vmw_cmdbuf_header_free - Free a struct vmw_cmdbuf_header  and its
  * associated structures.
+ *
  * @header: Pointer to the header to free.
  */
 void vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header)
 @@ -381,36 +381,38 @@ static void vmw_cmdbuf_ctx_submit(struct
  * @man: The command buffer manager.
  * @ctx: The command buffer context.
+ *
  * Submit command buffers to hardware if possible, and process finished
  * buffers. Typically freeing them, but on preemption or error take
  * appropriate action. Wake up waiters if appropriate.
  */
 static void vmw_cmdbuf_ctx_process(struct vmw_cmdbuf_man *man,
 				   struct vmw_cmdbuf_context *ctx,
 				   int *notempty)
+{
 	struct vmw_cmdbuf_header *entry, *next;
 	assert_spin_locked(&man->lock);
 	vmw_cmdbuf_ctx_submit(man, ctx);
 	list_for_each_entry_safe(entry, next, &ctx->hw_submitted, list) {
 		SVGACBStatus status = entry->cb_header->status;
 		if (status == SVGA_CB_STATUS_NONE)
 			break;
 		list_del(&entry->list);
-		wake_up_all(&man->idle_queue);
+		DRM_SPIN_WAKEUP_ONE(&man->idle_queue, &man->lock);
 		ctx->num_hw_submitted--;
 		switch (status) {
 		case SVGA_CB_STATUS_COMPLETED:
 			__vmw_cmdbuf_header_free(entry);
 			break;
 		case SVGA_CB_STATUS_COMMAND_ERROR:
 			WARN_ONCE(true, "Command buffer error.\n");
 			entry->cb_header->status = SVGA_CB_STATUS_NONE;
 			list_add_tail(&entry->list, &man->error);
 			schedule_work(&man->work);
 			break;
 		case SVGA_CB_STATUS_PREEMPTED:
 			entry->cb_header->status = SVGA_CB_STATUS_NONE;
 @@ -438,26 +440,28 @@ static void vmw_cmdbuf_ctx_process(struc
+ *
  * @man: The command buffer manager.
+ *
  * Calls vmw_cmdbuf_ctx_process() on all contexts. If any context has
  * command buffers left that are not submitted to hardware, Make sure
  * IRQ handling is turned on. Otherwise, make sure it's turned off.
  */
 static void vmw_cmdbuf_man_process(struct vmw_cmdbuf_man *man)
+{
 	int notempty;
 	struct vmw_cmdbuf_context *ctx;
 	int i;
 	assert_spin_locked(&man->lock);
 retry:
 	notempty = 0;
 	for_each_cmdbuf_ctx(man, i, ctx)
 		vmw_cmdbuf_ctx_process(man, ctx, &notempty);
 	if (man->irq_on && !notempty) {
 		vmw_generic_waiter_remove(man->dev_priv,
 					  SVGA_IRQFLAG_COMMAND_BUFFER,
 					  &man->dev_priv->cmdbuf_waiters);
 		man->irq_on = false;
 	} else if (!man->irq_on && notempty) {
 		vmw_generic_waiter_add(man->dev_priv,
 				       SVGA_IRQFLAG_COMMAND_BUFFER,
 @@ -612,60 +616,61 @@ static void vmw_cmdbuf_work_func(struct
 		ctx->block_submission = false;
 		list_splice_init(&restart_head[i], &ctx->submitted);
+	}
 	vmw_cmdbuf_man_process(man);
 	spin_unlock(&man->lock);
 	if (global_block && vmw_cmdbuf_startstop(man, 0, true))
 		DRM_ERROR("Failed restarting command buffer contexts\n");
 	/* Send a new fence in case one was removed */
 	if (send_fence) {
 		vmw_fifo_send_fence(man->dev_priv, &dummy);
-		wake_up_all(&man->idle_queue);
+		spin_lock(&man->lock);
 		DRM_SPIN_WAKEUP_ALL(&man->idle_queue, &man->lock);
 		spin_unlock(&man->lock);
+	}
 	mutex_unlock(&man->error_mutex);
+}
 /**
  * vmw_cmdbuf_man idle - Check whether the command buffer manager is idle.
+ *
  * @man: The command buffer manager.
  * @check_preempted: Check also the preempted queue for pending command buffers.
+ *
  */
 static bool vmw_cmdbuf_man_idle(struct vmw_cmdbuf_man *man,
 				bool check_preempted)
+{
 	struct vmw_cmdbuf_context *ctx;
 	bool idle = false;
 	int i;
-	spin_lock(&man->lock);
+	assert_spin_locked(&man->lock);
 	vmw_cmdbuf_man_process(man);
 	for_each_cmdbuf_ctx(man, i, ctx) {
 		if (!list_empty(&ctx->submitted) ||
 		    !list_empty(&ctx->hw_submitted) ||
 		    (check_preempted && !list_empty(&ctx->preempted)))
-			goto out_unlock;
+			goto out;
+	}
 	idle = list_empty(&man->error);
-out_unlock:
+out:
 	spin_unlock(&man->lock);
 	return idle;
+}
 /**
  * __vmw_cmdbuf_cur_flush - Flush the current command buffer for small kernel
  * command submissions
+ *
  * @man: The command buffer manager.
+ *
  * Flushes the current command buffer without allocating a new one. A new one
  * is automatically allocated when needed. Call with @man->cur_mutex held.
  */
 static void __vmw_cmdbuf_cur_flush(struct vmw_cmdbuf_man *man)
 @@ -722,48 +727,48 @@ int vmw_cmdbuf_cur_flush(struct vmw_cmdb
  * @interruptible: Sleep interruptible while waiting.
  * @timeout: Time out after this many ticks.
+ *
  * Wait until the command buffer manager has processed all command buffers,
  * or until a timeout occurs. If a timeout occurs, the function will return
  * -EBUSY.
  */
 int vmw_cmdbuf_idle(struct vmw_cmdbuf_man *man, bool interruptible,
 		    unsigned long timeout)
+{
 	int ret;
 	ret = vmw_cmdbuf_cur_flush(man, interruptible);
 	spin_lock(&man->lock);
 	vmw_generic_waiter_add(man->dev_priv,
 			       SVGA_IRQFLAG_COMMAND_BUFFER,
 			       &man->dev_priv->cmdbuf_waiters);
 	if (interruptible) {
-		ret = wait_event_interruptible_timeout
+		DRM_SPIN_TIMED_WAIT_UNTIL(ret, &man->idle_queue, &man->lock,
-			(man->idle_queue, vmw_cmdbuf_man_idle(man, true),
+		    timeout, vmw_cmdbuf_man_idle(man, true));
 			 timeout);
 	} else {
-		ret = wait_event_timeout
+		DRM_SPIN_TIMED_WAIT_NOINTR_UNTIL(ret, &man->idle_queue,
-			(man->idle_queue, vmw_cmdbuf_man_idle(man, true),
+		    &man->lock,
-			 timeout);
+		    timeout, vmw_cmdbuf_man_idle(man, true));
+	}
 	vmw_generic_waiter_remove(man->dev_priv,
 				  SVGA_IRQFLAG_COMMAND_BUFFER,
 				  &man->dev_priv->cmdbuf_waiters);
 	if (ret == 0) {
 		if (!vmw_cmdbuf_man_idle(man, true))
 			ret = -EBUSY;
 		else
 			ret = 0;
+	}
 	spin_unlock(&man->lock);
 	if (ret > 0)
 		ret = 0;
 	return ret;
+}
 /**
  * vmw_cmdbuf_try_alloc - Try to allocate buffer space from the main pool.
+ *
  * @man: The command buffer manager.
  * @info: Allocation info. Will hold the size on entry and allocated mm node
  * on successful return.
+ *
 @@ -815,55 +820,62 @@ static int vmw_cmdbuf_alloc_space(struct
 	info.node = node;
 	info.done = false;
 	/*
 	 * To prevent starvation of large requests, only one allocating call
 	 * at a time waiting for space.
 	 */
 	if (interruptible) {
 		if (mutex_lock_interruptible(&man->space_mutex))
 			return -ERESTARTSYS;
 	} else {
 		mutex_lock(&man->space_mutex);
+	}
 	spin_lock(&man->lock);
 	/* Try to allocate space without waiting. */
 	if (vmw_cmdbuf_try_alloc(man, &info))
 		goto out_unlock;
 	vmw_generic_waiter_add(man->dev_priv,
 			       SVGA_IRQFLAG_COMMAND_BUFFER,
 			       &man->dev_priv->cmdbuf_waiters);
 	if (interruptible) {
 		int ret;
-		ret = wait_event_interruptible
+		DRM_SPIN_WAIT_UNTIL(ret, &man->alloc_queue, &man->lock,
-			(man->alloc_queue, vmw_cmdbuf_try_alloc(man, &info));
+		    vmw_cmdbuf_try_alloc(man, &info));
 		if (ret) {
 			vmw_generic_waiter_remove
 				(man->dev_priv, SVGA_IRQFLAG_COMMAND_BUFFER,
 				 &man->dev_priv->cmdbuf_waiters);
 			spin_unlock(&man->lock);
 			mutex_unlock(&man->space_mutex);
 			return ret;
+		}
 	} else {
-		wait_event(man->alloc_queue, vmw_cmdbuf_try_alloc(man, &info));
+		int ret;
 		DRM_SPIN_WAIT_NOINTR_UNTIL(ret, &man->alloc_queue, &man->lock,
 		    vmw_cmdbuf_try_alloc(man, &info));
 		BUG_ON(ret);
+	}
 	vmw_generic_waiter_remove(man->dev_priv,
 				  SVGA_IRQFLAG_COMMAND_BUFFER,
 				  &man->dev_priv->cmdbuf_waiters);
 out_unlock:
 	spin_unlock(&man->lock);
 	mutex_unlock(&man->space_mutex);
 	return 0;
+}
 /**
  * vmw_cmdbuf_space_pool - Set up a command buffer header with command buffer
  * space from the main pool.
+ *
  * @man: The command buffer manager.
  * @header: Pointer to the header to set up.
  * @size: The requested size of the buffer space.
  * @interruptible: Whether to sleep interruptible while waiting for space.
 @@ -1377,28 +1389,28 @@ struct vmw_cmdbuf_man *vmw_cmdbuf_man_cr
 		ret = -ENOMEM;
 		goto out_no_dpool;
+	}
 	for_each_cmdbuf_ctx(man, i, ctx)
 		vmw_cmdbuf_ctx_init(ctx);
 	INIT_LIST_HEAD(&man->error);
 	spin_lock_init(&man->lock);
 	mutex_init(&man->cur_mutex);
 	mutex_init(&man->space_mutex);
 	mutex_init(&man->error_mutex);
 	man->default_size = VMW_CMDBUF_INLINE_SIZE;
-	init_waitqueue_head(&man->alloc_queue);
+	DRM_INIT_WAITQUEUE(&man->alloc_queue, "vmwgfxaq");
-	init_waitqueue_head(&man->idle_queue);
+	DRM_INIT_WAITQUEUE(&man->idle_queue, "vmwgfxiq");
 	man->dev_priv = dev_priv;
 	man->max_hw_submitted = SVGA_CB_MAX_QUEUED_PER_CONTEXT - 1;
 	INIT_WORK(&man->work, &vmw_cmdbuf_work_func);
 	vmw_generic_waiter_add(dev_priv, SVGA_IRQFLAG_ERROR,
 			       &dev_priv->error_waiters);
 	ret = vmw_cmdbuf_startstop(man, 0, true);
 	if (ret) {
 		DRM_ERROR("Failed starting command buffer contexts\n");
 		vmw_cmdbuf_man_destroy(man);
 		return ERR_PTR(ret);
+	}
 	return man;
 @@ -1458,18 +1470,21 @@ void vmw_cmdbuf_remove_pool(struct vmw_c
 void vmw_cmdbuf_man_destroy(struct vmw_cmdbuf_man *man)
+{
 	WARN_ON_ONCE(man->has_pool);
 	(void) vmw_cmdbuf_idle(man, false, 10*HZ);
 	if (vmw_cmdbuf_startstop(man, 0, false))
 		DRM_ERROR("Failed stopping command buffer contexts.\n");
 	vmw_generic_waiter_remove(man->dev_priv, SVGA_IRQFLAG_ERROR,
 				  &man->dev_priv->error_waiters);
 	(void) cancel_work_sync(&man->work);
 	dma_pool_destroy(man->dheaders);
 	dma_pool_destroy(man->headers);
 	DRM_DESTROY_WAITQUEUE(&man->idle_queue);
 	DRM_DESTROY_WAITQUEUE(&man->alloc_queue);
 	mutex_destroy(&man->cur_mutex);
 	mutex_destroy(&man->space_mutex);
 	mutex_destroy(&man->error_mutex);
 	spin_lock_destroy(&man->lock);
 	kfree(man);
+}