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