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_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 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 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 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 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 222 static int do_bpt_sequence(struct sdw_slave *slave, bool write, u8 *buffer) 223 { 224 struct sdw_bpt_msg msg = {0}; 225 226 msg.addr = start_addr; 227 msg.len = num_bytes; 228 msg.dev_num = slave->dev_num; 229 if (write) 230 msg.flags = SDW_MSG_FLAG_WRITE; 231 else 232 msg.flags = SDW_MSG_FLAG_READ; 233 msg.buf = buffer; 234 235 return sdw_bpt_send_sync(slave->bus, slave, &msg); 236 } 237 238 static int cmd_go(void *data, u64 value) 239 { 240 const struct firmware *fw = NULL; 241 struct sdw_slave *slave = data; 242 ktime_t start_t; 243 ktime_t finish_t; 244 int ret; 245 246 if (value != 1) 247 return -EINVAL; 248 249 /* one last check */ 250 if (start_addr > SDW_REG_MAX || 251 num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 252 return -EINVAL; 253 254 ret = pm_runtime_get_sync(&slave->dev); 255 if (ret < 0 && ret != -EACCES) { 256 pm_runtime_put_noidle(&slave->dev); 257 return ret; 258 } 259 260 if (cmd == 0) { 261 ret = request_firmware(&fw, firmware_file, &slave->dev); 262 if (ret < 0) { 263 dev_err(&slave->dev, "firmware %s not found\n", firmware_file); 264 goto out; 265 } 266 if (fw->size < num_bytes) { 267 dev_err(&slave->dev, 268 "firmware %s: firmware size %zd, desired %zd\n", 269 firmware_file, fw->size, num_bytes); 270 goto out; 271 } 272 } 273 274 /* Userspace changed the hardware state behind the kernel's back */ 275 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 276 277 dev_dbg(&slave->dev, "starting command\n"); 278 start_t = ktime_get(); 279 280 if (cmd == 0) { 281 if (cmd_type) 282 ret = do_bpt_sequence(slave, true, (u8 *)fw->data); 283 else 284 ret = sdw_nwrite_no_pm(slave, start_addr, num_bytes, fw->data); 285 } else { 286 memset(read_buffer, 0, sizeof(read_buffer)); 287 288 if (cmd_type) 289 ret = do_bpt_sequence(slave, false, read_buffer); 290 else 291 ret = sdw_nread_no_pm(slave, start_addr, num_bytes, read_buffer); 292 } 293 294 finish_t = ktime_get(); 295 296 dev_dbg(&slave->dev, "command completed, num_byte %zu status %d, time %lld ms\n", 297 num_bytes, ret, div_u64(finish_t - start_t, NSEC_PER_MSEC)); 298 299 out: 300 if (fw) 301 release_firmware(fw); 302 303 pm_runtime_mark_last_busy(&slave->dev); 304 pm_runtime_put(&slave->dev); 305 306 return ret; 307 } 308 DEFINE_DEBUGFS_ATTRIBUTE(cmd_go_fops, NULL, 309 cmd_go, "%llu\n"); 310 311 #define MAX_LINE_LEN 128 312 313 static int read_buffer_show(struct seq_file *s_file, void *data) 314 { 315 char buf[MAX_LINE_LEN]; 316 int i; 317 318 if (num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 319 return -EINVAL; 320 321 for (i = 0; i < num_bytes; i++) { 322 scnprintf(buf, MAX_LINE_LEN, "address %#x val 0x%02x\n", 323 start_addr + i, read_buffer[i]); 324 seq_printf(s_file, "%s", buf); 325 } 326 327 return 0; 328 } 329 DEFINE_SHOW_ATTRIBUTE(read_buffer); 330 331 void sdw_slave_debugfs_init(struct sdw_slave *slave) 332 { 333 struct dentry *master; 334 struct dentry *d; 335 char name[32]; 336 337 master = slave->bus->debugfs; 338 339 /* create the debugfs slave-name */ 340 snprintf(name, sizeof(name), "%s", dev_name(&slave->dev)); 341 d = debugfs_create_dir(name, master); 342 343 debugfs_create_file("registers", 0400, d, slave, &sdw_slave_reg_fops); 344 345 /* interface to send arbitrary commands */ 346 debugfs_create_file("command", 0200, d, slave, &set_command_fops); 347 debugfs_create_file("command_type", 0200, d, slave, &set_command_type_fops); 348 debugfs_create_file("start_address", 0200, d, slave, &set_start_address_fops); 349 debugfs_create_file("num_bytes", 0200, d, slave, &set_num_bytes_fops); 350 debugfs_create_file("go", 0200, d, slave, &cmd_go_fops); 351 352 debugfs_create_file("read_buffer", 0400, d, slave, &read_buffer_fops); 353 firmware_file = NULL; 354 debugfs_create_str("firmware_file", 0200, d, &firmware_file); 355 356 slave->debugfs = d; 357 } 358 359 void sdw_slave_debugfs_exit(struct sdw_slave *slave) 360 { 361 debugfs_remove_recursive(slave->debugfs); 362 } 363 364 void sdw_debugfs_init(void) 365 { 366 sdw_debugfs_root = debugfs_create_dir("soundwire", NULL); 367 } 368 369 void sdw_debugfs_exit(void) 370 { 371 debugfs_remove_recursive(sdw_debugfs_root); 372 } 373