drm/nouveau/flcn/qmgr: rename remaining nvkm_msgqueue bits to nvkm_falcon_qmgr (a15d8f58) · Commits · 戴 / test

drivers/gpu/drm/nouveau/nvkm/falcon/cmdq.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -152,7 +152,7 @@ nvkm_msgqueue_post(struct nvkm_msgqueue *priv, enum msgqueue_msg_priority prio,
		struct nvkm_msgqueue_hdr *cmd, nvkm_falcon_qmgr_callback cb,
		struct completion *completion, bool wait_init)
		{
		struct nvkm_msgqueue_seq *seq;
		struct nvkm_falcon_qmgr_seq *seq;
		struct nvkm_msgqueue_queue *queue;
		int ret;

drivers/gpu/drm/nouveau/nvkm/falcon/msgq.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -139,9 +139,9 @@ msgqueue_msg_handle(struct nvkm_msgqueue *priv,
		struct nv_falcon_msg *hdr)
		{
		const struct nvkm_subdev *subdev = priv->falcon->owner;
		struct nvkm_msgqueue_seq *seq;
		struct nvkm_falcon_qmgr_seq *seq;

		seq = &msgq->qmgr->seq[hdr->seq_id];
		seq = &msgq->qmgr->seq.id[hdr->seq_id];
		if (seq->state != SEQ_STATE_USED && seq->state != SEQ_STATE_CANCELLED) {
		nvkm_error(subdev, "msg for unknown sequence %d", seq->id);
		return -EINVAL;

drivers/gpu/drm/nouveau/nvkm/falcon/qmgr.c

+19 −19

Original line number	Diff line number	Diff line
		@@ -22,38 +22,38 @@
		*/
		#include "qmgr.h"

		struct nvkm_msgqueue_seq *
		nvkm_falcon_qmgr_seq_acquire(struct nvkm_falcon_qmgr *priv)
		struct nvkm_falcon_qmgr_seq *
		nvkm_falcon_qmgr_seq_acquire(struct nvkm_falcon_qmgr *qmgr)
		{
		const struct nvkm_subdev *subdev = priv->falcon->owner;
		struct nvkm_msgqueue_seq *seq;
		const struct nvkm_subdev *subdev = qmgr->falcon->owner;
		struct nvkm_falcon_qmgr_seq *seq;
		u32 index;

		mutex_lock(&priv->seq_lock);
		index = find_first_zero_bit(priv->seq_tbl, NVKM_MSGQUEUE_NUM_SEQUENCES);
		if (index >= NVKM_MSGQUEUE_NUM_SEQUENCES) {
		mutex_lock(&qmgr->seq.mutex);
		index = find_first_zero_bit(qmgr->seq.tbl, NVKM_FALCON_QMGR_SEQ_NUM);
		if (index >= NVKM_FALCON_QMGR_SEQ_NUM) {
		nvkm_error(subdev, "no free sequence available\n");
		mutex_unlock(&priv->seq_lock);
		mutex_unlock(&qmgr->seq.mutex);
		return ERR_PTR(-EAGAIN);
		}

		set_bit(index, priv->seq_tbl);
		mutex_unlock(&priv->seq_lock);
		set_bit(index, qmgr->seq.tbl);
		mutex_unlock(&qmgr->seq.mutex);

		seq = &priv->seq[index];
		seq = &qmgr->seq.id[index];
		seq->state = SEQ_STATE_PENDING;
		return seq;
		}

		void
		nvkm_falcon_qmgr_seq_release(struct nvkm_falcon_qmgr *priv,
		struct nvkm_msgqueue_seq *seq)
		nvkm_falcon_qmgr_seq_release(struct nvkm_falcon_qmgr *qmgr,
		struct nvkm_falcon_qmgr_seq *seq)
		{
		/* no need to acquire seq_lock since clear_bit is atomic */
		/* no need to acquire seq.mutex since clear_bit is atomic */
		seq->state = SEQ_STATE_FREE;
		seq->callback = NULL;
		reinit_completion(&seq->done);
		clear_bit(seq->id, priv->seq_tbl);
		clear_bit(seq->id, qmgr->seq.tbl);
		}

		void
		@@ -77,10 +77,10 @@ nvkm_falcon_qmgr_new(struct nvkm_falcon *falcon,
		return -ENOMEM;

		qmgr->falcon = falcon;
		mutex_init(&qmgr->seq_lock);
		for (i = 0; i < NVKM_MSGQUEUE_NUM_SEQUENCES; i++) {
		qmgr->seq[i].id = i;
		init_completion(&qmgr->seq[i].done);
		mutex_init(&qmgr->seq.mutex);
		for (i = 0; i < NVKM_FALCON_QMGR_SEQ_NUM; i++) {
		qmgr->seq.id[i].id = i;
		init_completion(&qmgr->seq.id[i].done);
		}

		return 0;

drivers/gpu/drm/nouveau/nvkm/falcon/qmgr.h

+10 −8

Original line number	Diff line number	Diff line
		@@ -10,7 +10,7 @@
		#define MSG_BUF_SIZE 128

		/**
		* struct nvkm_msgqueue_seq - keep track of ongoing commands
		* struct nvkm_falcon_qmgr_seq - keep track of ongoing commands
		*
		* Every time a command is sent, a sequence is assigned to it so the
		* corresponding message can be matched. Upon receiving the message, a callback
		@@ -21,7 +21,7 @@
		* @callback: callback to call upon receiving matching message
		* @completion: completion to signal after callback is called
		*/
		struct nvkm_msgqueue_seq {
		struct nvkm_falcon_qmgr_seq {
		u16 id;
		enum {
		SEQ_STATE_FREE = 0,
		@@ -40,20 +40,22 @@ struct nvkm_msgqueue_seq {
		* We can have an arbitrary number of sequences, but realistically we will
		* probably not use that much simultaneously.
		*/
		#define NVKM_MSGQUEUE_NUM_SEQUENCES 16
		#define NVKM_FALCON_QMGR_SEQ_NUM 16

		struct nvkm_falcon_qmgr {
		struct nvkm_falcon *falcon;

		struct mutex seq_lock;
		struct nvkm_msgqueue_seq seq[NVKM_MSGQUEUE_NUM_SEQUENCES];
		unsigned long seq_tbl[BITS_TO_LONGS(NVKM_MSGQUEUE_NUM_SEQUENCES)];
		struct {
		struct mutex mutex;
		struct nvkm_falcon_qmgr_seq id[NVKM_FALCON_QMGR_SEQ_NUM];
		unsigned long tbl[BITS_TO_LONGS(NVKM_FALCON_QMGR_SEQ_NUM)];
		} seq;
		};

		struct nvkm_msgqueue_seq *
		struct nvkm_falcon_qmgr_seq *
		nvkm_falcon_qmgr_seq_acquire(struct nvkm_falcon_qmgr *);
		void nvkm_falcon_qmgr_seq_release(struct nvkm_falcon_qmgr *,
		struct nvkm_msgqueue_seq *);
		struct nvkm_falcon_qmgr_seq *);

		#define FLCNQ_PRINTK(t,q,f,a...) \
		FLCN_PRINTK(t, (q)->qmgr->falcon, "%s: "f, (q)->name, ##a)

Admin message