adf_transport_debug.c

  1// SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0-only)
  2/* Copyright(c) 2014 - 2020 Intel Corporation */
  3#include <linux/mutex.h>
  4#include <linux/slab.h>
  5#include <linux/seq_file.h>
  6#include "adf_accel_devices.h"
  7#include "adf_transport_internal.h"
  8#include "adf_transport_access_macros.h"
  9
 10static DEFINE_MUTEX(ring_read_lock);
 11static DEFINE_MUTEX(bank_read_lock);
 12
 13#define ADF_RING_NUM_MSGS(ring)					\
 14	(ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size) /	\
 15	ADF_MSG_SIZE_TO_BYTES(ring->msg_size))
 16
 17static void *adf_ring_start(struct seq_file *sfile, loff_t *pos)
 18{
 19	struct adf_etr_ring_data *ring = sfile->private;
 20	unsigned int num_msg = ADF_RING_NUM_MSGS(ring);
 21	loff_t val = *pos;
 22
 23	mutex_lock(&ring_read_lock);
 24	if (val == 0)
 25		return SEQ_START_TOKEN;
 26
 27	if (val >= num_msg)
 28		return NULL;
 29
 30	return ring->base_addr +
 31		(ADF_MSG_SIZE_TO_BYTES(ring->msg_size) * (*pos)++);
 32}
 33
 34static void *adf_ring_next(struct seq_file *sfile, void *v, loff_t *pos)
 35{
 36	struct adf_etr_ring_data *ring = sfile->private;
 37	unsigned int num_msg = ADF_RING_NUM_MSGS(ring);
 38	loff_t val = *pos;
 39
 40	(*pos)++;
 41
 42	if (val >= num_msg)
 43		return NULL;
 44
 45	return ring->base_addr + (ADF_MSG_SIZE_TO_BYTES(ring->msg_size) * val);
 46}
 47
 48static int adf_ring_show(struct seq_file *sfile, void *v)
 49{
 50	struct adf_etr_ring_data *ring = sfile->private;
 51	struct adf_etr_bank_data *bank = ring->bank;
 52	struct adf_hw_csr_ops *csr_ops = GET_CSR_OPS(bank->accel_dev);
 53	void __iomem *csr = ring->bank->csr_addr;
 54
 55	if (v == SEQ_START_TOKEN) {
 56		int head, tail, empty;
 57
 58		head = csr_ops->read_csr_ring_head(csr, bank->bank_number,
 59						   ring->ring_number);
 60		tail = csr_ops->read_csr_ring_tail(csr, bank->bank_number,
 61						   ring->ring_number);
 62		empty = csr_ops->read_csr_e_stat(csr, bank->bank_number);
 63
 64		seq_puts(sfile, "------- Ring configuration -------\n");
 65		seq_printf(sfile, "ring name: %s\n",
 66			   ring->ring_debug->ring_name);
 67		seq_printf(sfile, "ring num %d, bank num %d\n",
 68			   ring->ring_number, ring->bank->bank_number);
 69		seq_printf(sfile, "head %x, tail %x, empty: %d\n",
 70			   head, tail, (empty & 1 << ring->ring_number)
 71			   >> ring->ring_number);
 72		seq_printf(sfile, "ring size %lld, msg size %d\n",
 73			   (long long)ADF_SIZE_TO_RING_SIZE_IN_BYTES(ring->ring_size),
 74			   ADF_MSG_SIZE_TO_BYTES(ring->msg_size));
 75		seq_puts(sfile, "----------- Ring data ------------\n");
 76		return 0;
 77	}
 78	seq_hex_dump(sfile, "", DUMP_PREFIX_ADDRESS, 32, 4,
 79		     v, ADF_MSG_SIZE_TO_BYTES(ring->msg_size), false);
 80	return 0;
 81}
 82
 83static void adf_ring_stop(struct seq_file *sfile, void *v)
 84{
 85	mutex_unlock(&ring_read_lock);
 86}
 87
 88static const struct seq_operations adf_ring_debug_sops = {
 89	.start = adf_ring_start,
 90	.next = adf_ring_next,
 91	.stop = adf_ring_stop,
 92	.show = adf_ring_show
 93};
 94
 95DEFINE_SEQ_ATTRIBUTE(adf_ring_debug);
 96
 97int adf_ring_debugfs_add(struct adf_etr_ring_data *ring, const char *name)
 98{
 99	struct adf_etr_ring_debug_entry *ring_debug;
100	char entry_name[16];
101
102	ring_debug = kzalloc(sizeof(*ring_debug), GFP_KERNEL);
103	if (!ring_debug)
104		return -ENOMEM;
105
106	strscpy(ring_debug->ring_name, name, sizeof(ring_debug->ring_name));
107	snprintf(entry_name, sizeof(entry_name), "ring_%02d",
108		 ring->ring_number);
109
110	ring_debug->debug = debugfs_create_file(entry_name, S_IRUSR,
111						ring->bank->bank_debug_dir,
112						ring, &adf_ring_debug_fops);
113	ring->ring_debug = ring_debug;
114	return 0;
115}
116
117void adf_ring_debugfs_rm(struct adf_etr_ring_data *ring)
118{
119	if (ring->ring_debug) {
120		debugfs_remove(ring->ring_debug->debug);
121		kfree(ring->ring_debug);
122		ring->ring_debug = NULL;
123	}
124}
125
126static void *adf_bank_start(struct seq_file *sfile, loff_t *pos)
127{
128	struct adf_etr_bank_data *bank = sfile->private;
129	u8 num_rings_per_bank = GET_NUM_RINGS_PER_BANK(bank->accel_dev);
130
131	mutex_lock(&bank_read_lock);
132	if (*pos == 0)
133		return SEQ_START_TOKEN;
134
135	if (*pos >= num_rings_per_bank)
136		return NULL;
137
138	return pos;
139}
140
141static void *adf_bank_next(struct seq_file *sfile, void *v, loff_t *pos)
142{
143	struct adf_etr_bank_data *bank = sfile->private;
144	u8 num_rings_per_bank = GET_NUM_RINGS_PER_BANK(bank->accel_dev);
145
146	if (++(*pos) >= num_rings_per_bank)
147		return NULL;
148
149	return pos;
150}
151
152static int adf_bank_show(struct seq_file *sfile, void *v)
153{
154	struct adf_etr_bank_data *bank = sfile->private;
155	struct adf_hw_csr_ops *csr_ops = GET_CSR_OPS(bank->accel_dev);
156
157	if (v == SEQ_START_TOKEN) {
158		seq_printf(sfile, "------- Bank %d configuration -------\n",
159			   bank->bank_number);
160	} else {
161		int ring_id = *((int *)v) - 1;
162		struct adf_etr_ring_data *ring = &bank->rings[ring_id];
163		void __iomem *csr = bank->csr_addr;
164		int head, tail, empty;
165
166		if (!(bank->ring_mask & 1 << ring_id))
167			return 0;
168
169		head = csr_ops->read_csr_ring_head(csr, bank->bank_number,
170						   ring->ring_number);
171		tail = csr_ops->read_csr_ring_tail(csr, bank->bank_number,
172						   ring->ring_number);
173		empty = csr_ops->read_csr_e_stat(csr, bank->bank_number);
174
175		seq_printf(sfile,
176			   "ring num %02d, head %04x, tail %04x, empty: %d\n",
177			   ring->ring_number, head, tail,
178			   (empty & 1 << ring->ring_number) >>
179			   ring->ring_number);
180	}
181	return 0;
182}
183
184static void adf_bank_stop(struct seq_file *sfile, void *v)
185{
186	mutex_unlock(&bank_read_lock);
187}
188
189static const struct seq_operations adf_bank_debug_sops = {
190	.start = adf_bank_start,
191	.next = adf_bank_next,
192	.stop = adf_bank_stop,
193	.show = adf_bank_show
194};
195
196DEFINE_SEQ_ATTRIBUTE(adf_bank_debug);
197
198int adf_bank_debugfs_add(struct adf_etr_bank_data *bank)
199{
200	struct adf_accel_dev *accel_dev = bank->accel_dev;
201	struct dentry *parent = accel_dev->transport->debug;
202	char name[16];
203
204	snprintf(name, sizeof(name), "bank_%02d", bank->bank_number);
205	bank->bank_debug_dir = debugfs_create_dir(name, parent);
206	bank->bank_debug_cfg = debugfs_create_file("config", S_IRUSR,
207						   bank->bank_debug_dir, bank,
208						   &adf_bank_debug_fops);
209	return 0;
210}
211
212void adf_bank_debugfs_rm(struct adf_etr_bank_data *bank)
213{
214	debugfs_remove(bank->bank_debug_cfg);
215	debugfs_remove(bank->bank_debug_dir);
216}