drivers/media/cec/cec-pin-error-inj.c

   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 }