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 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 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 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 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_FRAMECTRL_B0; i <= SDW_SCP_BUSCLOCK_SCALE_B0; i++) 95 ret += sdw_sprintf(slave, buf, ret, i); 96 for (i = SDW_SCP_FRAMECTRL_B1; i <= SDW_SCP_BUSCLOCK_SCALE_B1; i++) 97 ret += sdw_sprintf(slave, buf, ret, i); 98 for (i = SDW_SCP_PHY_OUT_CTRL_0; i <= SDW_SCP_PHY_OUT_CTRL_7; i++) 99 ret += sdw_sprintf(slave, buf, ret, i); 100 101 102 /* 103 * SCP Bank 0/1 registers are read-only and cannot be 104 * retrieved from the Slave. The Master typically keeps track 105 * of the current frame size so the information can be found 106 * in other places 107 */ 108 109 /* DP1..14 registers */ 110 for (i = 1; SDW_VALID_PORT_RANGE(i); i++) { 111 112 /* DPi registers */ 113 ret += scnprintf(buf + ret, RD_BUF - ret, "\nDP%d\n", i); 114 for (j = SDW_DPN_INT(i); j <= SDW_DPN_PREPARECTRL(i); j++) 115 ret += sdw_sprintf(slave, buf, ret, j); 116 117 /* DPi Bank0 registers */ 118 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank0\n"); 119 for (j = SDW_DPN_CHANNELEN_B0(i); 120 j <= SDW_DPN_LANECTRL_B0(i); j++) 121 ret += sdw_sprintf(slave, buf, ret, j); 122 123 /* DPi Bank1 registers */ 124 ret += scnprintf(buf + ret, RD_BUF - ret, "Bank1\n"); 125 for (j = SDW_DPN_CHANNELEN_B1(i); 126 j <= SDW_DPN_LANECTRL_B1(i); j++) 127 ret += sdw_sprintf(slave, buf, ret, j); 128 } 129 130 seq_printf(s_file, "%s", buf); 131 132 pm_runtime_mark_last_busy(&slave->dev); 133 pm_runtime_put(&slave->dev); 134 135 return 0; 136 } 137 DEFINE_SHOW_ATTRIBUTE(sdw_slave_reg); 138 139 #define MAX_CMD_BYTES (1024 * 1024) 140 141 static int cmd; 142 static int cmd_type; 143 static u32 start_addr; 144 static size_t num_bytes; 145 static u8 read_buffer[MAX_CMD_BYTES]; 146 static char *firmware_file; 147 148 static int set_command(void *data, u64 value) 149 { 150 struct sdw_slave *slave = data; 151 152 if (value > 1) 153 return -EINVAL; 154 155 /* Userspace changed the hardware state behind the kernel's back */ 156 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 157 158 dev_dbg(&slave->dev, "command: %s\n", str_read_write(value)); 159 cmd = value; 160 161 return 0; 162 } 163 DEFINE_DEBUGFS_ATTRIBUTE(set_command_fops, NULL, 164 set_command, "%llu\n"); 165 166 static int set_command_type(void *data, u64 value) 167 { 168 struct sdw_slave *slave = data; 169 170 if (value > 1) 171 return -EINVAL; 172 173 /* Userspace changed the hardware state behind the kernel's back */ 174 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 175 176 dev_dbg(&slave->dev, "command type: %s\n", value ? "BRA" : "Column0"); 177 178 cmd_type = (int)value; 179 180 return 0; 181 } 182 DEFINE_DEBUGFS_ATTRIBUTE(set_command_type_fops, NULL, 183 set_command_type, "%llu\n"); 184 185 static int set_start_address(void *data, u64 value) 186 { 187 struct sdw_slave *slave = data; 188 189 /* Userspace changed the hardware state behind the kernel's back */ 190 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 191 192 dev_dbg(&slave->dev, "start address %#llx\n", value); 193 194 start_addr = value; 195 196 return 0; 197 } 198 DEFINE_DEBUGFS_ATTRIBUTE(set_start_address_fops, NULL, 199 set_start_address, "%llu\n"); 200 201 static int set_num_bytes(void *data, u64 value) 202 { 203 struct sdw_slave *slave = data; 204 205 if (value == 0 || value > MAX_CMD_BYTES) 206 return -EINVAL; 207 208 /* Userspace changed the hardware state behind the kernel's back */ 209 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 210 211 dev_dbg(&slave->dev, "number of bytes %lld\n", value); 212 213 num_bytes = value; 214 215 return 0; 216 } 217 DEFINE_DEBUGFS_ATTRIBUTE(set_num_bytes_fops, NULL, 218 set_num_bytes, "%llu\n"); 219 220 static int do_bpt_sequence(struct sdw_slave *slave, bool write, u8 *buffer) 221 { 222 struct sdw_bpt_msg msg = {0}; 223 224 msg.addr = start_addr; 225 msg.len = num_bytes; 226 msg.dev_num = slave->dev_num; 227 if (write) 228 msg.flags = SDW_MSG_FLAG_WRITE; 229 else 230 msg.flags = SDW_MSG_FLAG_READ; 231 msg.buf = buffer; 232 233 return sdw_bpt_send_sync(slave->bus, slave, &msg); 234 } 235 236 static int cmd_go(void *data, u64 value) 237 { 238 const struct firmware *fw = NULL; 239 struct sdw_slave *slave = data; 240 ktime_t start_t; 241 ktime_t finish_t; 242 int ret; 243 244 if (value != 1) 245 return -EINVAL; 246 247 /* one last check */ 248 if (start_addr > SDW_REG_MAX || 249 num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 250 return -EINVAL; 251 252 ret = pm_runtime_get_sync(&slave->dev); 253 if (ret < 0 && ret != -EACCES) { 254 pm_runtime_put_noidle(&slave->dev); 255 return ret; 256 } 257 258 if (cmd == 0) { 259 ret = request_firmware(&fw, firmware_file, &slave->dev); 260 if (ret < 0) { 261 dev_err(&slave->dev, "firmware %s not found\n", firmware_file); 262 goto out; 263 } 264 if (fw->size < num_bytes) { 265 dev_err(&slave->dev, 266 "firmware %s: firmware size %zd, desired %zd\n", 267 firmware_file, fw->size, num_bytes); 268 goto out; 269 } 270 } 271 272 /* Userspace changed the hardware state behind the kernel's back */ 273 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 274 275 dev_dbg(&slave->dev, "starting command\n"); 276 start_t = ktime_get(); 277 278 if (cmd == 0) { 279 if (cmd_type) 280 ret = do_bpt_sequence(slave, true, (u8 *)fw->data); 281 else 282 ret = sdw_nwrite_no_pm(slave, start_addr, num_bytes, fw->data); 283 } else { 284 memset(read_buffer, 0, sizeof(read_buffer)); 285 286 if (cmd_type) 287 ret = do_bpt_sequence(slave, false, read_buffer); 288 else 289 ret = sdw_nread_no_pm(slave, start_addr, num_bytes, read_buffer); 290 } 291 292 finish_t = ktime_get(); 293 294 out: 295 if (fw) 296 release_firmware(fw); 297 298 pm_runtime_mark_last_busy(&slave->dev); 299 pm_runtime_put(&slave->dev); 300 301 dev_dbg(&slave->dev, "command completed, num_byte %zu status %d, time %lld ms\n", 302 num_bytes, ret, div_u64(finish_t - start_t, NSEC_PER_MSEC)); 303 304 return ret; 305 } 306 DEFINE_DEBUGFS_ATTRIBUTE(cmd_go_fops, NULL, 307 cmd_go, "%llu\n"); 308 309 #define MAX_LINE_LEN 128 310 311 static int read_buffer_show(struct seq_file *s_file, void *data) 312 { 313 char buf[MAX_LINE_LEN]; 314 int i; 315 316 if (num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 317 return -EINVAL; 318 319 for (i = 0; i < num_bytes; i++) { 320 scnprintf(buf, MAX_LINE_LEN, "address %#x val 0x%02x\n", 321 start_addr + i, read_buffer[i]); 322 seq_printf(s_file, "%s", buf); 323 } 324 325 return 0; 326 } 327 DEFINE_SHOW_ATTRIBUTE(read_buffer); 328 329 void sdw_slave_debugfs_init(struct sdw_slave *slave) 330 { 331 struct dentry *master; 332 struct dentry *d; 333 char name[32]; 334 335 master = slave->bus->debugfs; 336 337 /* create the debugfs slave-name */ 338 snprintf(name, sizeof(name), "%s", dev_name(&slave->dev)); 339 d = debugfs_create_dir(name, master); 340 341 debugfs_create_file("registers", 0400, d, slave, &sdw_slave_reg_fops); 342 343 /* interface to send arbitrary commands */ 344 debugfs_create_file("command", 0200, d, slave, &set_command_fops); 345 debugfs_create_file("command_type", 0200, d, slave, &set_command_type_fops); 346 debugfs_create_file("start_address", 0200, d, slave, &set_start_address_fops); 347 debugfs_create_file("num_bytes", 0200, d, slave, &set_num_bytes_fops); 348 debugfs_create_file("go", 0200, d, slave, &cmd_go_fops); 349 350 debugfs_create_file("read_buffer", 0400, d, slave, &read_buffer_fops); 351 firmware_file = NULL; 352 debugfs_create_str("firmware_file", 0200, d, &firmware_file); 353 354 slave->debugfs = d; 355 } 356 357 void sdw_slave_debugfs_exit(struct sdw_slave *slave) 358 { 359 debugfs_remove_recursive(slave->debugfs); 360 } 361 362 void sdw_debugfs_init(void) 363 { 364 sdw_debugfs_root = debugfs_create_dir("soundwire", NULL); 365 } 366 367 void sdw_debugfs_exit(void) 368 { 369 debugfs_remove_recursive(sdw_debugfs_root); 370 } 371