1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright 2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 4 */ 5 6 #include <linux/delay.h> 7 #include <linux/slab.h> 8 #include <linux/sched/types.h> 9 10 #include <media/cec-pin.h> 11 #include "cec-pin-priv.h" 12 13 struct cec_error_inj_cmd { 14 unsigned int mode_offset; 15 int arg_idx; 16 const char *cmd; 17 }; 18 19 static const struct cec_error_inj_cmd cec_error_inj_cmds[] = { 20 { CEC_ERROR_INJ_RX_NACK_OFFSET, -1, "rx-nack" }, 21 { CEC_ERROR_INJ_RX_LOW_DRIVE_OFFSET, 22 CEC_ERROR_INJ_RX_LOW_DRIVE_ARG_IDX, "rx-low-drive" }, 23 { CEC_ERROR_INJ_RX_ADD_BYTE_OFFSET, -1, "rx-add-byte" }, 24 { CEC_ERROR_INJ_RX_REMOVE_BYTE_OFFSET, -1, "rx-remove-byte" }, 25 { CEC_ERROR_INJ_RX_ARB_LOST_OFFSET, 26 CEC_ERROR_INJ_RX_ARB_LOST_ARG_IDX, "rx-arb-lost" }, 27 28 { CEC_ERROR_INJ_TX_NO_EOM_OFFSET, -1, "tx-no-eom" }, 29 { CEC_ERROR_INJ_TX_EARLY_EOM_OFFSET, -1, "tx-early-eom" }, 30 { CEC_ERROR_INJ_TX_ADD_BYTES_OFFSET, 31 CEC_ERROR_INJ_TX_ADD_BYTES_ARG_IDX, "tx-add-bytes" }, 32 { CEC_ERROR_INJ_TX_REMOVE_BYTE_OFFSET, -1, "tx-remove-byte" }, 33 { CEC_ERROR_INJ_TX_SHORT_BIT_OFFSET, 34 CEC_ERROR_INJ_TX_SHORT_BIT_ARG_IDX, "tx-short-bit" }, 35 { CEC_ERROR_INJ_TX_LONG_BIT_OFFSET, 36 CEC_ERROR_INJ_TX_LONG_BIT_ARG_IDX, "tx-long-bit" }, 37 { CEC_ERROR_INJ_TX_CUSTOM_BIT_OFFSET, 38 CEC_ERROR_INJ_TX_CUSTOM_BIT_ARG_IDX, "tx-custom-bit" }, 39 { CEC_ERROR_INJ_TX_SHORT_START_OFFSET, -1, "tx-short-start" }, 40 { CEC_ERROR_INJ_TX_LONG_START_OFFSET, -1, "tx-long-start" }, 41 { CEC_ERROR_INJ_TX_CUSTOM_START_OFFSET, -1, "tx-custom-start" }, 42 { CEC_ERROR_INJ_TX_LAST_BIT_OFFSET, 43 CEC_ERROR_INJ_TX_LAST_BIT_ARG_IDX, "tx-last-bit" }, 44 { CEC_ERROR_INJ_TX_LOW_DRIVE_OFFSET, 45 CEC_ERROR_INJ_TX_LOW_DRIVE_ARG_IDX, "tx-low-drive" }, 46 { 0, -1, NULL } 47 }; 48 49 u16 cec_pin_rx_error_inj(struct cec_pin *pin) 50 { 51 u16 cmd = CEC_ERROR_INJ_OP_ANY; 52 53 /* Only when 18 bits have been received do we have a valid cmd */ 54 if (!(pin->error_inj[cmd] & CEC_ERROR_INJ_RX_MASK) && 55 pin->rx_bit >= 18) 56 cmd = pin->rx_msg.msg[1]; 57 return (pin->error_inj[cmd] & CEC_ERROR_INJ_RX_MASK) ? cmd : 58 CEC_ERROR_INJ_OP_ANY; 59 } 60 61 u16 cec_pin_tx_error_inj(struct cec_pin *pin) 62 { 63 u16 cmd = CEC_ERROR_INJ_OP_ANY; 64 65 if (!(pin->error_inj[cmd] & CEC_ERROR_INJ_TX_MASK) && 66 pin->tx_msg.len > 1) 67 cmd = pin->tx_msg.msg[1]; 68 return (pin->error_inj[cmd] & CEC_ERROR_INJ_TX_MASK) ? cmd : 69 CEC_ERROR_INJ_OP_ANY; 70 } 71 72 bool cec_pin_error_inj_parse_line(struct cec_adapter *adap, char *line) 73 { 74 static const char *delims = " \t\r"; 75 struct cec_pin *pin = adap->pin; 76 unsigned int i; 77 bool has_pos = false; 78 char *p = line; 79 char *token; 80 char *comma; 81 u64 *error; 82 u8 *args; 83 bool has_op; 84 u8 op; 85 u8 mode; 86 u8 pos; 87 88 p = skip_spaces(p); 89 token = strsep(&p, delims); 90 if (!strcmp(token, "clear")) { 91 memset(pin->error_inj, 0, sizeof(pin->error_inj)); 92 pin->rx_toggle = pin->tx_toggle = false; 93 pin->tx_ignore_nack_until_eom = false; 94 pin->tx_custom_pulse = false; 95 pin->tx_custom_low_usecs = CEC_TIM_CUSTOM_DEFAULT; 96 pin->tx_custom_high_usecs = CEC_TIM_CUSTOM_DEFAULT; 97 return true; 98 } 99 if (!strcmp(token, "rx-clear")) { 100 for (i = 0; i <= CEC_ERROR_INJ_OP_ANY; i++) 101 pin->error_inj[i] &= ~CEC_ERROR_INJ_RX_MASK; 102 pin->rx_toggle = false; 103 return true; 104 } 105 if (!strcmp(token, "tx-clear")) { 106 for (i = 0; i <= CEC_ERROR_INJ_OP_ANY; i++) 107 pin->error_inj[i] &= ~CEC_ERROR_INJ_TX_MASK; 108 pin->tx_toggle = false; 109 pin->tx_ignore_nack_until_eom = false; 110 pin->tx_custom_pulse = false; 111 pin->tx_custom_low_usecs = CEC_TIM_CUSTOM_DEFAULT; 112 pin->tx_custom_high_usecs = CEC_TIM_CUSTOM_DEFAULT; 113 return true; 114 } 115 if (!strcmp(token, "tx-ignore-nack-until-eom")) { 116 pin->tx_ignore_nack_until_eom = true; 117 return true; 118 } 119 if (!strcmp(token, "tx-custom-pulse")) { 120 pin->tx_custom_pulse = true; 121 cec_pin_start_timer(pin); 122 return true; 123 } 124 if (!p) 125 return false; 126 127 p = skip_spaces(p); 128 if (!strcmp(token, "tx-custom-low-usecs")) { 129 u32 usecs; 130 131 if (kstrtou32(p, 0, &usecs) || usecs > 10000000) 132 return false; 133 pin->tx_custom_low_usecs = usecs; 134 return true; 135 } 136 if (!strcmp(token, "tx-custom-high-usecs")) { 137 u32 usecs; 138 139 if (kstrtou32(p, 0, &usecs) || usecs > 10000000) 140 return false; 141 pin->tx_custom_high_usecs = usecs; 142 return true; 143 } 144 145 comma = strchr(token, ','); 146 if (comma) 147 *comma++ = '\0'; 148 if (!strcmp(token, "any")) { 149 has_op = false; 150 error = pin->error_inj + CEC_ERROR_INJ_OP_ANY; 151 args = pin->error_inj_args[CEC_ERROR_INJ_OP_ANY]; 152 } else if (!kstrtou8(token, 0, &op)) { 153 has_op = true; 154 error = pin->error_inj + op; 155 args = pin->error_inj_args[op]; 156 } else { 157 return false; 158 } 159 160 mode = CEC_ERROR_INJ_MODE_ONCE; 161 if (comma) { 162 if (!strcmp(comma, "off")) 163 mode = CEC_ERROR_INJ_MODE_OFF; 164 else if (!strcmp(comma, "once")) 165 mode = CEC_ERROR_INJ_MODE_ONCE; 166 else if (!strcmp(comma, "always")) 167 mode = CEC_ERROR_INJ_MODE_ALWAYS; 168 else if (!strcmp(comma, "toggle")) 169 mode = CEC_ERROR_INJ_MODE_TOGGLE; 170 else 171 return false; 172 } 173 174 token = strsep(&p, delims); 175 if (p) { 176 p = skip_spaces(p); 177 has_pos = !kstrtou8(p, 0, &pos); 178 } 179 180 if (!strcmp(token, "clear")) { 181 *error = 0; 182 return true; 183 } 184 if (!strcmp(token, "rx-clear")) { 185 *error &= ~CEC_ERROR_INJ_RX_MASK; 186 return true; 187 } 188 if (!strcmp(token, "tx-clear")) { 189 *error &= ~CEC_ERROR_INJ_TX_MASK; 190 return true; 191 } 192 193 for (i = 0; cec_error_inj_cmds[i].cmd; i++) { 194 const char *cmd = cec_error_inj_cmds[i].cmd; 195 unsigned int mode_offset; 196 u64 mode_mask; 197 int arg_idx; 198 bool is_bit_pos = true; 199 200 if (strcmp(token, cmd)) 201 continue; 202 203 mode_offset = cec_error_inj_cmds[i].mode_offset; 204 mode_mask = CEC_ERROR_INJ_MODE_MASK << mode_offset; 205 arg_idx = cec_error_inj_cmds[i].arg_idx; 206 207 if (mode_offset == CEC_ERROR_INJ_RX_ARB_LOST_OFFSET) { 208 if (has_op) 209 return false; 210 if (!has_pos) 211 pos = 0x0f; 212 is_bit_pos = false; 213 } else if (mode_offset == CEC_ERROR_INJ_TX_ADD_BYTES_OFFSET) { 214 if (!has_pos || !pos) 215 return false; 216 is_bit_pos = false; 217 } 218 219 if (arg_idx >= 0 && is_bit_pos) { 220 if (!has_pos || pos >= 160) 221 return false; 222 if (has_op && pos < 10 + 8) 223 return false; 224 /* Invalid bit position may not be the Ack bit */ 225 if ((mode_offset == CEC_ERROR_INJ_TX_SHORT_BIT_OFFSET || 226 mode_offset == CEC_ERROR_INJ_TX_LONG_BIT_OFFSET || 227 mode_offset == CEC_ERROR_INJ_TX_CUSTOM_BIT_OFFSET) && 228 (pos % 10) == 9) 229 return false; 230 } 231 *error &= ~mode_mask; 232 *error |= (u64)mode << mode_offset; 233 if (arg_idx >= 0) 234 args[arg_idx] = pos; 235 return true; 236 } 237 return false; 238 } 239 240 static void cec_pin_show_cmd(struct seq_file *sf, u32 cmd, u8 mode) 241 { 242 if (cmd == CEC_ERROR_INJ_OP_ANY) 243 seq_puts(sf, "any,"); 244 else 245 seq_printf(sf, "0x%02x,", cmd); 246 switch (mode) { 247 case CEC_ERROR_INJ_MODE_ONCE: 248 seq_puts(sf, "once "); 249 break; 250 case CEC_ERROR_INJ_MODE_ALWAYS: 251 seq_puts(sf, "always "); 252 break; 253 case CEC_ERROR_INJ_MODE_TOGGLE: 254 seq_puts(sf, "toggle "); 255 break; 256 default: 257 seq_puts(sf, "off "); 258 break; 259 } 260 } 261 262 int cec_pin_error_inj_show(struct cec_adapter *adap, struct seq_file *sf) 263 { 264 struct cec_pin *pin = adap->pin; 265 unsigned int i, j; 266 267 seq_puts(sf, "# Clear error injections:\n"); 268 seq_puts(sf, "# clear clear all rx and tx error injections\n"); 269 seq_puts(sf, "# rx-clear clear all rx error injections\n"); 270 seq_puts(sf, "# tx-clear clear all tx error injections\n"); 271 seq_puts(sf, "# <op> clear clear all rx and tx error injections for <op>\n"); 272 seq_puts(sf, "# <op> rx-clear clear all rx error injections for <op>\n"); 273 seq_puts(sf, "# <op> tx-clear clear all tx error injections for <op>\n"); 274 seq_puts(sf, "#\n"); 275 seq_puts(sf, "# RX error injection:\n"); 276 seq_puts(sf, "# <op>[,<mode>] rx-nack NACK the message instead of sending an ACK\n"); 277 seq_puts(sf, "# <op>[,<mode>] rx-low-drive <bit> force a low-drive condition at this bit position\n"); 278 seq_puts(sf, "# <op>[,<mode>] rx-add-byte add a spurious byte to the received CEC message\n"); 279 seq_puts(sf, "# <op>[,<mode>] rx-remove-byte remove the last byte from the received CEC message\n"); 280 seq_puts(sf, "# <op>[,<mode>] rx-arb-lost <poll> generate a POLL message to trigger an arbitration lost\n"); 281 seq_puts(sf, "#\n"); 282 seq_puts(sf, "# TX error injection settings:\n"); 283 seq_puts(sf, "# tx-ignore-nack-until-eom ignore early NACKs until EOM\n"); 284 seq_puts(sf, "# tx-custom-low-usecs <usecs> define the 'low' time for the custom pulse\n"); 285 seq_puts(sf, "# tx-custom-high-usecs <usecs> define the 'high' time for the custom pulse\n"); 286 seq_puts(sf, "# tx-custom-pulse transmit the custom pulse once the bus is idle\n"); 287 seq_puts(sf, "#\n"); 288 seq_puts(sf, "# TX error injection:\n"); 289 seq_puts(sf, "# <op>[,<mode>] tx-no-eom don't set the EOM bit\n"); 290 seq_puts(sf, "# <op>[,<mode>] tx-early-eom set the EOM bit one byte too soon\n"); 291 seq_puts(sf, "# <op>[,<mode>] tx-add-bytes <num> append <num> (1-255) spurious bytes to the message\n"); 292 seq_puts(sf, "# <op>[,<mode>] tx-remove-byte drop the last byte from the message\n"); 293 seq_puts(sf, "# <op>[,<mode>] tx-short-bit <bit> make this bit shorter than allowed\n"); 294 seq_puts(sf, "# <op>[,<mode>] tx-long-bit <bit> make this bit longer than allowed\n"); 295 seq_puts(sf, "# <op>[,<mode>] tx-custom-bit <bit> send the custom pulse instead of this bit\n"); 296 seq_puts(sf, "# <op>[,<mode>] tx-short-start send a start pulse that's too short\n"); 297 seq_puts(sf, "# <op>[,<mode>] tx-long-start send a start pulse that's too long\n"); 298 seq_puts(sf, "# <op>[,<mode>] tx-custom-start send the custom pulse instead of the start pulse\n"); 299 seq_puts(sf, "# <op>[,<mode>] tx-last-bit <bit> stop sending after this bit\n"); 300 seq_puts(sf, "# <op>[,<mode>] tx-low-drive <bit> force a low-drive condition at this bit position\n"); 301 seq_puts(sf, "#\n"); 302 seq_puts(sf, "# <op> CEC message opcode (0-255) or 'any'\n"); 303 seq_puts(sf, "# <mode> 'once' (default), 'always', 'toggle' or 'off'\n"); 304 seq_puts(sf, "# <bit> CEC message bit (0-159)\n"); 305 seq_puts(sf, "# 10 bits per 'byte': bits 0-7: data, bit 8: EOM, bit 9: ACK\n"); 306 seq_puts(sf, "# <poll> CEC poll message used to test arbitration lost (0x00-0xff, default 0x0f)\n"); 307 seq_puts(sf, "# <usecs> microseconds (0-10000000, default 1000)\n"); 308 309 seq_puts(sf, "\nclear\n"); 310 311 for (i = 0; i < ARRAY_SIZE(pin->error_inj); i++) { 312 u64 e = pin->error_inj[i]; 313 314 for (j = 0; cec_error_inj_cmds[j].cmd; j++) { 315 const char *cmd = cec_error_inj_cmds[j].cmd; 316 unsigned int mode; 317 unsigned int mode_offset; 318 int arg_idx; 319 320 mode_offset = cec_error_inj_cmds[j].mode_offset; 321 arg_idx = cec_error_inj_cmds[j].arg_idx; 322 mode = (e >> mode_offset) & CEC_ERROR_INJ_MODE_MASK; 323 if (!mode) 324 continue; 325 cec_pin_show_cmd(sf, i, mode); 326 seq_puts(sf, cmd); 327 if (arg_idx >= 0) 328 seq_printf(sf, " %u", 329 pin->error_inj_args[i][arg_idx]); 330 seq_puts(sf, "\n"); 331 } 332 } 333 334 if (pin->tx_ignore_nack_until_eom) 335 seq_puts(sf, "tx-ignore-nack-until-eom\n"); 336 if (pin->tx_custom_pulse) 337 seq_puts(sf, "tx-custom-pulse\n"); 338 if (pin->tx_custom_low_usecs != CEC_TIM_CUSTOM_DEFAULT) 339 seq_printf(sf, "tx-custom-low-usecs %u\n", 340 pin->tx_custom_low_usecs); 341 if (pin->tx_custom_high_usecs != CEC_TIM_CUSTOM_DEFAULT) 342 seq_printf(sf, "tx-custom-high-usecs %u\n", 343 pin->tx_custom_high_usecs); 344 return 0; 345 } 346