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 256 140 141 static int cmd; 142 static u32 start_addr; 143 static size_t num_bytes; 144 static u8 read_buffer[MAX_CMD_BYTES]; 145 static char *firmware_file; 146 147 static int set_command(void *data, u64 value) 148 { 149 struct sdw_slave *slave = data; 150 151 if (value > 1) 152 return -EINVAL; 153 154 /* Userspace changed the hardware state behind the kernel's back */ 155 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 156 157 dev_dbg(&slave->dev, "command: %s\n", str_read_write(value)); 158 cmd = value; 159 160 return 0; 161 } 162 DEFINE_DEBUGFS_ATTRIBUTE(set_command_fops, NULL, 163 set_command, "%llu\n"); 164 165 static int set_start_address(void *data, u64 value) 166 { 167 struct sdw_slave *slave = data; 168 169 /* Userspace changed the hardware state behind the kernel's back */ 170 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 171 172 dev_dbg(&slave->dev, "start address %#llx\n", value); 173 174 start_addr = value; 175 176 return 0; 177 } 178 DEFINE_DEBUGFS_ATTRIBUTE(set_start_address_fops, NULL, 179 set_start_address, "%llu\n"); 180 181 static int set_num_bytes(void *data, u64 value) 182 { 183 struct sdw_slave *slave = data; 184 185 if (value == 0 || value > MAX_CMD_BYTES) 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, "number of bytes %lld\n", value); 192 193 num_bytes = value; 194 195 return 0; 196 } 197 DEFINE_DEBUGFS_ATTRIBUTE(set_num_bytes_fops, NULL, 198 set_num_bytes, "%llu\n"); 199 200 static int cmd_go(void *data, u64 value) 201 { 202 struct sdw_slave *slave = data; 203 int ret; 204 205 if (value != 1) 206 return -EINVAL; 207 208 /* one last check */ 209 if (start_addr > SDW_REG_MAX || 210 num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 211 return -EINVAL; 212 213 ret = pm_runtime_get_sync(&slave->dev); 214 if (ret < 0 && ret != -EACCES) { 215 pm_runtime_put_noidle(&slave->dev); 216 return ret; 217 } 218 219 /* Userspace changed the hardware state behind the kernel's back */ 220 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 221 222 dev_dbg(&slave->dev, "starting command\n"); 223 224 if (cmd == 0) { 225 const struct firmware *fw; 226 227 ret = request_firmware(&fw, firmware_file, &slave->dev); 228 if (ret < 0) { 229 dev_err(&slave->dev, "firmware %s not found\n", firmware_file); 230 goto out; 231 } 232 233 if (fw->size != num_bytes) { 234 dev_err(&slave->dev, 235 "firmware %s: unexpected size %zd, desired %zd\n", 236 firmware_file, fw->size, num_bytes); 237 release_firmware(fw); 238 goto out; 239 } 240 241 ret = sdw_nwrite_no_pm(slave, start_addr, num_bytes, fw->data); 242 release_firmware(fw); 243 } else { 244 ret = sdw_nread_no_pm(slave, start_addr, num_bytes, read_buffer); 245 } 246 247 dev_dbg(&slave->dev, "command completed %d\n", ret); 248 249 out: 250 pm_runtime_mark_last_busy(&slave->dev); 251 pm_runtime_put(&slave->dev); 252 253 return ret; 254 } 255 DEFINE_DEBUGFS_ATTRIBUTE(cmd_go_fops, NULL, 256 cmd_go, "%llu\n"); 257 258 #define MAX_LINE_LEN 128 259 260 static int read_buffer_show(struct seq_file *s_file, void *data) 261 { 262 char buf[MAX_LINE_LEN]; 263 int i; 264 265 if (num_bytes == 0 || num_bytes > MAX_CMD_BYTES) 266 return -EINVAL; 267 268 for (i = 0; i < num_bytes; i++) { 269 scnprintf(buf, MAX_LINE_LEN, "address %#x val 0x%02x\n", 270 start_addr + i, read_buffer[i]); 271 seq_printf(s_file, "%s", buf); 272 } 273 274 return 0; 275 } 276 DEFINE_SHOW_ATTRIBUTE(read_buffer); 277 278 void sdw_slave_debugfs_init(struct sdw_slave *slave) 279 { 280 struct dentry *master; 281 struct dentry *d; 282 char name[32]; 283 284 master = slave->bus->debugfs; 285 286 /* create the debugfs slave-name */ 287 snprintf(name, sizeof(name), "%s", dev_name(&slave->dev)); 288 d = debugfs_create_dir(name, master); 289 290 debugfs_create_file("registers", 0400, d, slave, &sdw_slave_reg_fops); 291 292 /* interface to send arbitrary commands */ 293 debugfs_create_file("command", 0200, d, slave, &set_command_fops); 294 debugfs_create_file("start_address", 0200, d, slave, &set_start_address_fops); 295 debugfs_create_file("num_bytes", 0200, d, slave, &set_num_bytes_fops); 296 debugfs_create_file("go", 0200, d, slave, &cmd_go_fops); 297 298 debugfs_create_file("read_buffer", 0400, d, slave, &read_buffer_fops); 299 firmware_file = NULL; 300 debugfs_create_str("firmware_file", 0200, d, &firmware_file); 301 302 slave->debugfs = d; 303 } 304 305 void sdw_slave_debugfs_exit(struct sdw_slave *slave) 306 { 307 debugfs_remove_recursive(slave->debugfs); 308 } 309 310 void sdw_debugfs_init(void) 311 { 312 sdw_debugfs_root = debugfs_create_dir("soundwire", NULL); 313 } 314 315 void sdw_debugfs_exit(void) 316 { 317 debugfs_remove_recursive(sdw_debugfs_root); 318 } 319