1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright(c) 2017-2019 Intel Corporation.
3
4 #include <linux/cleanup.h>
5 #include <linux/device.h>
6 #include <linux/debugfs.h>
7 #include <linux/firmware.h>
8 #include <linux/mod_devicetable.h>
9 #include <linux/pm_runtime.h>
10 #include <linux/slab.h>
11 #include <linux/soundwire/sdw.h>
12 #include <linux/soundwire/sdw_registers.h>
13 #include <linux/string_choices.h>
14 #include "bus.h"
15
16 static struct dentry *sdw_debugfs_root;
17
sdw_bus_debugfs_init(struct sdw_bus * bus)18 void sdw_bus_debugfs_init(struct sdw_bus *bus)
19 {
20 char name[16];
21
22 if (!sdw_debugfs_root)
23 return;
24
25 /* create the debugfs master-N */
26 snprintf(name, sizeof(name), "master-%d-%d", bus->controller_id, bus->link_id);
27 bus->debugfs = debugfs_create_dir(name, sdw_debugfs_root);
28 }
29
sdw_bus_debugfs_exit(struct sdw_bus * bus)30 void sdw_bus_debugfs_exit(struct sdw_bus *bus)
31 {
32 debugfs_remove_recursive(bus->debugfs);
33 }
34
35 #define RD_BUF (3 * PAGE_SIZE)
36
sdw_sprintf(struct sdw_slave * slave,char * buf,size_t pos,unsigned int reg)37 static ssize_t sdw_sprintf(struct sdw_slave *slave,
38 char *buf, size_t pos, unsigned int reg)
39 {
40 int value;
41
42 value = sdw_read_no_pm(slave, reg);
43
44 if (value < 0)
45 return scnprintf(buf + pos, RD_BUF - pos, "%3x\tXX\n", reg);
46 else
47 return scnprintf(buf + pos, RD_BUF - pos,
48 "%3x\t%2x\n", reg, value);
49 }
50
sdw_slave_reg_show(struct seq_file * s_file,void * data)51 static int sdw_slave_reg_show(struct seq_file *s_file, void *data)
52 {
53 struct sdw_slave *slave = s_file->private;
54 ssize_t ret;
55 int i, j;
56
57 char *buf __free(kfree) = kzalloc(RD_BUF, GFP_KERNEL);
58 if (!buf)
59 return -ENOMEM;
60
61 ret = pm_runtime_get_sync(&slave->dev);
62 if (ret < 0 && ret != -EACCES) {
63 pm_runtime_put_noidle(&slave->dev);
64 return ret;
65 }
66
67 ret = scnprintf(buf, RD_BUF, "Register Value\n");
68
69 /* DP0 non-banked registers */
70 ret += scnprintf(buf + ret, RD_BUF - ret, "\nDP0\n");
71 for (i = SDW_DP0_INT; i <= SDW_DP0_PREPARECTRL; i++)
72 ret += sdw_sprintf(slave, buf, ret, i);
73
74 /* DP0 Bank 0 registers */
75 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank0\n");
76 ret += sdw_sprintf(slave, buf, ret, SDW_DP0_CHANNELEN);
77 for (i = SDW_DP0_SAMPLECTRL1; i <= SDW_DP0_LANECTRL; i++)
78 ret += sdw_sprintf(slave, buf, ret, i);
79
80 /* DP0 Bank 1 registers */
81 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank1\n");
82 ret += sdw_sprintf(slave, buf, ret,
83 SDW_DP0_CHANNELEN + SDW_BANK1_OFFSET);
84 for (i = SDW_DP0_SAMPLECTRL1 + SDW_BANK1_OFFSET;
85 i <= SDW_DP0_LANECTRL + SDW_BANK1_OFFSET; i++)
86 ret += sdw_sprintf(slave, buf, ret, i);
87
88 /* SCP registers */
89 ret += scnprintf(buf + ret, RD_BUF - ret, "\nSCP\n");
90 for (i = SDW_SCP_INT1; i <= SDW_SCP_BUS_CLOCK_BASE; i++)
91 ret += sdw_sprintf(slave, buf, ret, i);
92 for (i = SDW_SCP_DEVID_0; i <= SDW_SCP_DEVID_5; i++)
93 ret += sdw_sprintf(slave, buf, ret, i);
94 for (i = SDW_SCP_SDCA_INT1; i <= SDW_SCP_SDCA_INTMASK4; i++)
95 ret += sdw_sprintf(slave, buf, ret, i);
96 for (i = SDW_SCP_FRAMECTRL_B0; i <= SDW_SCP_BUSCLOCK_SCALE_B0; i++)
97 ret += sdw_sprintf(slave, buf, ret, i);
98 for (i = SDW_SCP_FRAMECTRL_B1; i <= SDW_SCP_BUSCLOCK_SCALE_B1; i++)
99 ret += sdw_sprintf(slave, buf, ret, i);
100 for (i = SDW_SCP_PHY_OUT_CTRL_0; i <= SDW_SCP_PHY_OUT_CTRL_7; i++)
101 ret += sdw_sprintf(slave, buf, ret, i);
102
103
104 /*
105 * SCP Bank 0/1 registers are read-only and cannot be
106 * retrieved from the Slave. The Master typically keeps track
107 * of the current frame size so the information can be found
108 * in other places
109 */
110
111 /* DP1..14 registers */
112 for (i = 1; SDW_VALID_PORT_RANGE(i); i++) {
113
114 /* DPi registers */
115 ret += scnprintf(buf + ret, RD_BUF - ret, "\nDP%d\n", i);
116 for (j = SDW_DPN_INT(i); j <= SDW_DPN_PREPARECTRL(i); j++)
117 ret += sdw_sprintf(slave, buf, ret, j);
118
119 /* DPi Bank0 registers */
120 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank0\n");
121 for (j = SDW_DPN_CHANNELEN_B0(i);
122 j <= SDW_DPN_LANECTRL_B0(i); j++)
123 ret += sdw_sprintf(slave, buf, ret, j);
124
125 /* DPi Bank1 registers */
126 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank1\n");
127 for (j = SDW_DPN_CHANNELEN_B1(i);
128 j <= SDW_DPN_LANECTRL_B1(i); j++)
129 ret += sdw_sprintf(slave, buf, ret, j);
130 }
131
132 seq_printf(s_file, "%s", buf);
133
134 pm_runtime_mark_last_busy(&slave->dev);
135 pm_runtime_put(&slave->dev);
136
137 return 0;
138 }
139 DEFINE_SHOW_ATTRIBUTE(sdw_slave_reg);
140
141 #define MAX_CMD_BYTES (1024 * 1024)
142
143 static int cmd;
144 static int cmd_type;
145 static u32 start_addr;
146 static size_t num_bytes;
147 static u8 read_buffer[MAX_CMD_BYTES];
148 static char *firmware_file;
149
set_command(void * data,u64 value)150 static int set_command(void *data, u64 value)
151 {
152 struct sdw_slave *slave = data;
153
154 if (value > 1)
155 return -EINVAL;
156
157 /* Userspace changed the hardware state behind the kernel's back */
158 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
159
160 dev_dbg(&slave->dev, "command: %s\n", str_read_write(value));
161 cmd = value;
162
163 return 0;
164 }
165 DEFINE_DEBUGFS_ATTRIBUTE(set_command_fops, NULL,
166 set_command, "%llu\n");
167
set_command_type(void * data,u64 value)168 static int set_command_type(void *data, u64 value)
169 {
170 struct sdw_slave *slave = data;
171
172 if (value > 1)
173 return -EINVAL;
174
175 /* Userspace changed the hardware state behind the kernel's back */
176 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
177
178 dev_dbg(&slave->dev, "command type: %s\n", value ? "BRA" : "Column0");
179
180 cmd_type = (int)value;
181
182 return 0;
183 }
184 DEFINE_DEBUGFS_ATTRIBUTE(set_command_type_fops, NULL,
185 set_command_type, "%llu\n");
186
set_start_address(void * data,u64 value)187 static int set_start_address(void *data, u64 value)
188 {
189 struct sdw_slave *slave = data;
190
191 /* Userspace changed the hardware state behind the kernel's back */
192 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
193
194 dev_dbg(&slave->dev, "start address %#llx\n", value);
195
196 start_addr = value;
197
198 return 0;
199 }
200 DEFINE_DEBUGFS_ATTRIBUTE(set_start_address_fops, NULL,
201 set_start_address, "%llu\n");
202
set_num_bytes(void * data,u64 value)203 static int set_num_bytes(void *data, u64 value)
204 {
205 struct sdw_slave *slave = data;
206
207 if (value == 0 || value > MAX_CMD_BYTES)
208 return -EINVAL;
209
210 /* Userspace changed the hardware state behind the kernel's back */
211 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
212
213 dev_dbg(&slave->dev, "number of bytes %lld\n", value);
214
215 num_bytes = value;
216
217 return 0;
218 }
219 DEFINE_DEBUGFS_ATTRIBUTE(set_num_bytes_fops, NULL,
220 set_num_bytes, "%llu\n");
221
do_bpt_sequence(struct sdw_slave * slave,bool write,u8 * buffer)222 static int do_bpt_sequence(struct sdw_slave *slave, bool write, u8 *buffer)
223 {
224 struct sdw_bpt_msg msg = {0};
225 struct sdw_bpt_section *sec;
226
227 sec = kcalloc(1, sizeof(*sec), GFP_KERNEL);
228 if (!sec)
229 return -ENOMEM;
230 msg.sections = 1;
231
232 sec[0].addr = start_addr;
233 sec[0].len = num_bytes;
234
235 msg.sec = sec;
236 msg.dev_num = slave->dev_num;
237 if (write)
238 msg.flags = SDW_MSG_FLAG_WRITE;
239 else
240 msg.flags = SDW_MSG_FLAG_READ;
241 sec[0].buf = buffer;
242
243 return sdw_bpt_send_sync(slave->bus, slave, &msg);
244 }
245
cmd_go(void * data,u64 value)246 static int cmd_go(void *data, u64 value)
247 {
248 const struct firmware *fw = NULL;
249 struct sdw_slave *slave = data;
250 ktime_t start_t;
251 ktime_t finish_t;
252 int ret;
253
254 if (value != 1)
255 return -EINVAL;
256
257 /* one last check */
258 if (start_addr > SDW_REG_MAX ||
259 num_bytes == 0 || num_bytes > MAX_CMD_BYTES)
260 return -EINVAL;
261
262 ret = pm_runtime_get_sync(&slave->dev);
263 if (ret < 0 && ret != -EACCES) {
264 pm_runtime_put_noidle(&slave->dev);
265 return ret;
266 }
267
268 if (cmd == 0) {
269 ret = request_firmware(&fw, firmware_file, &slave->dev);
270 if (ret < 0) {
271 dev_err(&slave->dev, "firmware %s not found\n", firmware_file);
272 goto out;
273 }
274 if (fw->size < num_bytes) {
275 dev_err(&slave->dev,
276 "firmware %s: firmware size %zd, desired %zd\n",
277 firmware_file, fw->size, num_bytes);
278 goto out;
279 }
280 }
281
282 /* Userspace changed the hardware state behind the kernel's back */
283 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
284
285 dev_dbg(&slave->dev, "starting command\n");
286 start_t = ktime_get();
287
288 if (cmd == 0) {
289 if (cmd_type)
290 ret = do_bpt_sequence(slave, true, (u8 *)fw->data);
291 else
292 ret = sdw_nwrite_no_pm(slave, start_addr, num_bytes, fw->data);
293 } else {
294 memset(read_buffer, 0, sizeof(read_buffer));
295
296 if (cmd_type)
297 ret = do_bpt_sequence(slave, false, read_buffer);
298 else
299 ret = sdw_nread_no_pm(slave, start_addr, num_bytes, read_buffer);
300 }
301
302 finish_t = ktime_get();
303
304 dev_dbg(&slave->dev, "command completed, num_byte %zu status %d, time %lld ms\n",
305 num_bytes, ret, div_u64(finish_t - start_t, NSEC_PER_MSEC));
306
307 out:
308 if (fw)
309 release_firmware(fw);
310
311 pm_runtime_mark_last_busy(&slave->dev);
312 pm_runtime_put(&slave->dev);
313
314 return ret;
315 }
316 DEFINE_DEBUGFS_ATTRIBUTE(cmd_go_fops, NULL,
317 cmd_go, "%llu\n");
318
319 #define MAX_LINE_LEN 128
320
read_buffer_show(struct seq_file * s_file,void * data)321 static int read_buffer_show(struct seq_file *s_file, void *data)
322 {
323 char buf[MAX_LINE_LEN];
324 int i;
325
326 if (num_bytes == 0 || num_bytes > MAX_CMD_BYTES)
327 return -EINVAL;
328
329 for (i = 0; i < num_bytes; i++) {
330 scnprintf(buf, MAX_LINE_LEN, "address %#x val 0x%02x\n",
331 start_addr + i, read_buffer[i]);
332 seq_printf(s_file, "%s", buf);
333 }
334
335 return 0;
336 }
337 DEFINE_SHOW_ATTRIBUTE(read_buffer);
338
sdw_slave_debugfs_init(struct sdw_slave * slave)339 void sdw_slave_debugfs_init(struct sdw_slave *slave)
340 {
341 struct dentry *master;
342 struct dentry *d;
343 char name[32];
344
345 master = slave->bus->debugfs;
346
347 /* create the debugfs slave-name */
348 snprintf(name, sizeof(name), "%s", dev_name(&slave->dev));
349 d = debugfs_create_dir(name, master);
350
351 debugfs_create_file("registers", 0400, d, slave, &sdw_slave_reg_fops);
352
353 /* interface to send arbitrary commands */
354 debugfs_create_file("command", 0200, d, slave, &set_command_fops);
355 debugfs_create_file("command_type", 0200, d, slave, &set_command_type_fops);
356 debugfs_create_file("start_address", 0200, d, slave, &set_start_address_fops);
357 debugfs_create_file("num_bytes", 0200, d, slave, &set_num_bytes_fops);
358 debugfs_create_file("go", 0200, d, slave, &cmd_go_fops);
359
360 debugfs_create_file("read_buffer", 0400, d, slave, &read_buffer_fops);
361 firmware_file = NULL;
362 debugfs_create_str("firmware_file", 0200, d, &firmware_file);
363
364 slave->debugfs = d;
365 }
366
sdw_slave_debugfs_exit(struct sdw_slave * slave)367 void sdw_slave_debugfs_exit(struct sdw_slave *slave)
368 {
369 debugfs_remove_recursive(slave->debugfs);
370 }
371
sdw_debugfs_init(void)372 void sdw_debugfs_init(void)
373 {
374 sdw_debugfs_root = debugfs_create_dir("soundwire", NULL);
375 }
376
sdw_debugfs_exit(void)377 void sdw_debugfs_exit(void)
378 {
379 debugfs_remove_recursive(sdw_debugfs_root);
380 }
381