drivers/media/usb/pulse8-cec/pulse8-cec.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Pulse Eight HDMI CEC driver
   4  *
   5  * Copyright 2016 Hans Verkuil <hverkuil@xs4all.nl
   6  */
   7
   8 /*
   9  * Notes:
  10  *
  11  * - Devices with firmware version < 2 do not store their configuration in
  12  *   EEPROM.
  13  *
  14  * - In autonomous mode, only messages from a TV will be acknowledged, even
  15  *   polling messages. Upon receiving a message from a TV, the dongle will
  16  *   respond to messages from any logical address.
  17  *
  18  * - In autonomous mode, the dongle will by default reply Feature Abort
  19  *   [Unrecognized Opcode] when it receives Give Device Vendor ID. It will
  20  *   however observe vendor ID's reported by other devices and possibly
  21  *   alter this behavior. When TV's (and TV's only) report that their vendor ID
  22  *   is LG (0x00e091), the dongle will itself reply that it has the same vendor
  23  *   ID, and it will respond to at least one vendor specific command.
  24  *
  25  * - In autonomous mode, the dongle is known to attempt wakeup if it receives
  26  *   <User Control Pressed> ["Power On"], ["Power] or ["Power Toggle"], or if it
  27  *   receives <Set Stream Path> with its own physical address. It also does this
  28  *   if it receives <Vendor Specific Command> [0x03 0x00] from an LG TV.
  29  */
  30
  31 #include <linux/completion.h>
  32 #include <linux/init.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/workqueue.h>
  37 #include <linux/serio.h>
  38 #include <linux/slab.h>
  39 #include <linux/time.h>
  40 #include <linux/delay.h>
  41
  42 #include <media/cec.h>
  43
  44 MODULE_AUTHOR("Hans Verkuil <hverkuil@xs4all.nl>");
  45 MODULE_DESCRIPTION("Pulse Eight HDMI CEC driver");
  46 MODULE_LICENSE("GPL");
  47
  48 static int debug;
  49 static int persistent_config;
  50 module_param(debug, int, 0644);
  51 module_param(persistent_config, int, 0644);
  52 MODULE_PARM_DESC(debug, "debug level (0-2)");
  53 MODULE_PARM_DESC(persistent_config, "read config from persistent memory (0-1)");
  54
  55 enum pulse8_msgcodes {
  56         MSGCODE_NOTHING = 0,
  57         MSGCODE_PING,
  58         MSGCODE_TIMEOUT_ERROR,
  59         MSGCODE_HIGH_ERROR,
  60         MSGCODE_LOW_ERROR,
  61         MSGCODE_FRAME_START,
  62         MSGCODE_FRAME_DATA,
  63         MSGCODE_RECEIVE_FAILED,
  64         MSGCODE_COMMAND_ACCEPTED,       /* 0x08 */
  65         MSGCODE_COMMAND_REJECTED,
  66         MSGCODE_SET_ACK_MASK,
  67         MSGCODE_TRANSMIT,
  68         MSGCODE_TRANSMIT_EOM,
  69         MSGCODE_TRANSMIT_IDLETIME,
  70         MSGCODE_TRANSMIT_ACK_POLARITY,
  71         MSGCODE_TRANSMIT_LINE_TIMEOUT,
  72         MSGCODE_TRANSMIT_SUCCEEDED,     /* 0x10 */
  73         MSGCODE_TRANSMIT_FAILED_LINE,
  74         MSGCODE_TRANSMIT_FAILED_ACK,
  75         MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA,
  76         MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE,
  77         MSGCODE_FIRMWARE_VERSION,
  78         MSGCODE_START_BOOTLOADER,
  79         MSGCODE_GET_BUILDDATE,
  80         MSGCODE_SET_CONTROLLED,         /* 0x18 */
  81         MSGCODE_GET_AUTO_ENABLED,
  82         MSGCODE_SET_AUTO_ENABLED,
  83         MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS,
  84         MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS,
  85         MSGCODE_GET_LOGICAL_ADDRESS_MASK,
  86         MSGCODE_SET_LOGICAL_ADDRESS_MASK,
  87         MSGCODE_GET_PHYSICAL_ADDRESS,
  88         MSGCODE_SET_PHYSICAL_ADDRESS,   /* 0x20 */
  89         MSGCODE_GET_DEVICE_TYPE,
  90         MSGCODE_SET_DEVICE_TYPE,
  91         MSGCODE_GET_HDMI_VERSION,
  92         MSGCODE_SET_HDMI_VERSION,
  93         MSGCODE_GET_OSD_NAME,
  94         MSGCODE_SET_OSD_NAME,
  95         MSGCODE_WRITE_EEPROM,
  96         MSGCODE_GET_ADAPTER_TYPE,       /* 0x28 */
  97         MSGCODE_SET_ACTIVE_SOURCE,
  98
  99         MSGCODE_FRAME_EOM = 0x80,
 100         MSGCODE_FRAME_ACK = 0x40,
 101 };
 102
 103 static const char * const pulse8_msgnames[] = {
 104         "NOTHING",
 105         "PING",
 106         "TIMEOUT_ERROR",
 107         "HIGH_ERROR",
 108         "LOW_ERROR",
 109         "FRAME_START",
 110         "FRAME_DATA",
 111         "RECEIVE_FAILED",
 112         "COMMAND_ACCEPTED",
 113         "COMMAND_REJECTED",
 114         "SET_ACK_MASK",
 115         "TRANSMIT",
 116         "TRANSMIT_EOM",
 117         "TRANSMIT_IDLETIME",
 118         "TRANSMIT_ACK_POLARITY",
 119         "TRANSMIT_LINE_TIMEOUT",
 120         "TRANSMIT_SUCCEEDED",
 121         "TRANSMIT_FAILED_LINE",
 122         "TRANSMIT_FAILED_ACK",
 123         "TRANSMIT_FAILED_TIMEOUT_DATA",
 124         "TRANSMIT_FAILED_TIMEOUT_LINE",
 125         "FIRMWARE_VERSION",
 126         "START_BOOTLOADER",
 127         "GET_BUILDDATE",
 128         "SET_CONTROLLED",
 129         "GET_AUTO_ENABLED",
 130         "SET_AUTO_ENABLED",
 131         "GET_DEFAULT_LOGICAL_ADDRESS",
 132         "SET_DEFAULT_LOGICAL_ADDRESS",
 133         "GET_LOGICAL_ADDRESS_MASK",
 134         "SET_LOGICAL_ADDRESS_MASK",
 135         "GET_PHYSICAL_ADDRESS",
 136         "SET_PHYSICAL_ADDRESS",
 137         "GET_DEVICE_TYPE",
 138         "SET_DEVICE_TYPE",
 139         "GET_HDMI_VERSION",
 140         "SET_HDMI_VERSION",
 141         "GET_OSD_NAME",
 142         "SET_OSD_NAME",
 143         "WRITE_EEPROM",
 144         "GET_ADAPTER_TYPE",
 145         "SET_ACTIVE_SOURCE",
 146 };
 147
 148 static const char *pulse8_msgname(u8 cmd)
 149 {
 150         static char unknown_msg[5];
 151
 152         if ((cmd & 0x3f) < ARRAY_SIZE(pulse8_msgnames))
 153                 return pulse8_msgnames[cmd & 0x3f];
 154         snprintf(unknown_msg, sizeof(unknown_msg), "0x%02x", cmd);
 155         return unknown_msg;
 156 }
 157
 158 #define MSGSTART        0xff
 159 #define MSGEND          0xfe
 160 #define MSGESC          0xfd
 161 #define MSGOFFSET       3
 162
 163 #define DATA_SIZE 256
 164
 165 #define PING_PERIOD     (15 * HZ)
 166
 167 #define NUM_MSGS 8
 168
 169 struct pulse8 {
 170         struct device *dev;
 171         struct serio *serio;
 172         struct cec_adapter *adap;
 173         unsigned int vers;
 174
 175         struct delayed_work ping_eeprom_work;
 176
 177         struct work_struct irq_work;
 178         struct cec_msg rx_msg[NUM_MSGS];
 179         unsigned int rx_msg_cur_idx, rx_msg_num;
 180         /* protect rx_msg_cur_idx and rx_msg_num */
 181         spinlock_t msg_lock;
 182         u8 new_rx_msg[CEC_MAX_MSG_SIZE];
 183         u8 new_rx_msg_len;
 184
 185         struct work_struct tx_work;
 186         u32 tx_done_status;
 187         u32 tx_signal_free_time;
 188         struct cec_msg tx_msg;
 189         bool tx_msg_is_bcast;
 190
 191         struct completion cmd_done;
 192         u8 data[DATA_SIZE];
 193         unsigned int len;
 194         u8 buf[DATA_SIZE];
 195         unsigned int idx;
 196         bool escape;
 197         bool started;
 198
 199         /* locks access to the adapter */
 200         struct mutex lock;
 201         bool config_pending;
 202         bool restoring_config;
 203         bool autonomous;
 204 };
 205
 206 static int pulse8_send(struct serio *serio, const u8 *command, u8 cmd_len)
 207 {
 208         int err = 0;
 209
 210         err = serio_write(serio, MSGSTART);
 211         if (err)
 212                 return err;
 213         for (; !err && cmd_len; command++, cmd_len--) {
 214                 if (*command >= MSGESC) {
 215                         err = serio_write(serio, MSGESC);
 216                         if (!err)
 217                                 err = serio_write(serio, *command - MSGOFFSET);
 218                 } else {
 219                         err = serio_write(serio, *command);
 220                 }
 221         }
 222         if (!err)
 223                 err = serio_write(serio, MSGEND);
 224
 225         return err;
 226 }
 227
 228 static int pulse8_send_and_wait_once(struct pulse8 *pulse8,
 229                                      const u8 *cmd, u8 cmd_len,
 230                                      u8 response, u8 size)
 231 {
 232         int err;
 233
 234         if (debug > 1)
 235                 dev_info(pulse8->dev, "transmit %s: %*ph\n",
 236                          pulse8_msgname(cmd[0]), cmd_len, cmd);
 237         init_completion(&pulse8->cmd_done);
 238
 239         err = pulse8_send(pulse8->serio, cmd, cmd_len);
 240         if (err)
 241                 return err;
 242
 243         if (!wait_for_completion_timeout(&pulse8->cmd_done, HZ))
 244                 return -ETIMEDOUT;
 245         if ((pulse8->data[0] & 0x3f) == MSGCODE_COMMAND_REJECTED &&
 246             cmd[0] != MSGCODE_SET_CONTROLLED &&
 247             cmd[0] != MSGCODE_SET_AUTO_ENABLED &&
 248             cmd[0] != MSGCODE_GET_BUILDDATE)
 249                 return -ENOTTY;
 250         if (response &&
 251             ((pulse8->data[0] & 0x3f) != response || pulse8->len < size + 1)) {
 252                 dev_info(pulse8->dev, "transmit %s failed with %s\n",
 253                          pulse8_msgname(cmd[0]),
 254                          pulse8_msgname(pulse8->data[0]));
 255                 return -EIO;
 256         }
 257         return 0;
 258 }
 259
 260 static int pulse8_send_and_wait(struct pulse8 *pulse8,
 261                                 const u8 *cmd, u8 cmd_len, u8 response, u8 size)
 262 {
 263         u8 cmd_sc[2];
 264         int err;
 265
 266         err = pulse8_send_and_wait_once(pulse8, cmd, cmd_len, response, size);
 267         if (err != -ENOTTY)
 268                 return err;
 269
 270         cmd_sc[0] = MSGCODE_SET_CONTROLLED;
 271         cmd_sc[1] = 1;
 272         err = pulse8_send_and_wait_once(pulse8, cmd_sc, 2,
 273                                         MSGCODE_COMMAND_ACCEPTED, 1);
 274         if (!err)
 275                 err = pulse8_send_and_wait_once(pulse8, cmd, cmd_len,
 276                                                 response, size);
 277         return err == -ENOTTY ? -EIO : err;
 278 }
 279
 280 static void pulse8_tx_work_handler(struct work_struct *work)
 281 {
 282         struct pulse8 *pulse8 = container_of(work, struct pulse8, tx_work);
 283         struct cec_msg *msg = &pulse8->tx_msg;
 284         unsigned int i;
 285         u8 cmd[2];
 286         int err;
 287
 288         if (msg->len == 0)
 289                 return;
 290
 291         mutex_lock(&pulse8->lock);
 292         cmd[0] = MSGCODE_TRANSMIT_IDLETIME;
 293         cmd[1] = pulse8->tx_signal_free_time;
 294         err = pulse8_send_and_wait(pulse8, cmd, 2,
 295                                    MSGCODE_COMMAND_ACCEPTED, 1);
 296         cmd[0] = MSGCODE_TRANSMIT_ACK_POLARITY;
 297         cmd[1] = cec_msg_is_broadcast(msg);
 298         pulse8->tx_msg_is_bcast = cec_msg_is_broadcast(msg);
 299         if (!err)
 300                 err = pulse8_send_and_wait(pulse8, cmd, 2,
 301                                            MSGCODE_COMMAND_ACCEPTED, 1);
 302         cmd[0] = msg->len == 1 ? MSGCODE_TRANSMIT_EOM : MSGCODE_TRANSMIT;
 303         cmd[1] = msg->msg[0];
 304         if (!err)
 305                 err = pulse8_send_and_wait(pulse8, cmd, 2,
 306                                            MSGCODE_COMMAND_ACCEPTED, 1);
 307         if (!err && msg->len > 1) {
 308                 for (i = 1; !err && i < msg->len; i++) {
 309                         cmd[0] = ((i == msg->len - 1)) ?
 310                                 MSGCODE_TRANSMIT_EOM : MSGCODE_TRANSMIT;
 311                         cmd[1] = msg->msg[i];
 312                         err = pulse8_send_and_wait(pulse8, cmd, 2,
 313                                                    MSGCODE_COMMAND_ACCEPTED, 1);
 314                 }
 315         }
 316         if (err && debug)
 317                 dev_info(pulse8->dev, "%s(0x%02x) failed with error %d for msg %*ph\n",
 318                          pulse8_msgname(cmd[0]), cmd[1],
 319                          err, msg->len, msg->msg);
 320         msg->len = 0;
 321         mutex_unlock(&pulse8->lock);
 322         if (err)
 323                 cec_transmit_attempt_done(pulse8->adap, CEC_TX_STATUS_ERROR);
 324 }
 325
 326 static void pulse8_irq_work_handler(struct work_struct *work)
 327 {
 328         struct pulse8 *pulse8 =
 329                 container_of(work, struct pulse8, irq_work);
 330         unsigned long flags;
 331         u32 status;
 332
 333         spin_lock_irqsave(&pulse8->msg_lock, flags);
 334         while (pulse8->rx_msg_num) {
 335                 spin_unlock_irqrestore(&pulse8->msg_lock, flags);
 336                 if (debug)
 337                         dev_info(pulse8->dev, "adap received %*ph\n",
 338                                  pulse8->rx_msg[pulse8->rx_msg_cur_idx].len,
 339                                  pulse8->rx_msg[pulse8->rx_msg_cur_idx].msg);
 340                 cec_received_msg(pulse8->adap,
 341                                  &pulse8->rx_msg[pulse8->rx_msg_cur_idx]);
 342                 spin_lock_irqsave(&pulse8->msg_lock, flags);
 343                 if (pulse8->rx_msg_num)
 344                         pulse8->rx_msg_num--;
 345                 pulse8->rx_msg_cur_idx =
 346                         (pulse8->rx_msg_cur_idx + 1) % NUM_MSGS;
 347         }
 348         spin_unlock_irqrestore(&pulse8->msg_lock, flags);
 349
 350         mutex_lock(&pulse8->lock);
 351         status = pulse8->tx_done_status;
 352         pulse8->tx_done_status = 0;
 353         mutex_unlock(&pulse8->lock);
 354         if (status)
 355                 cec_transmit_attempt_done(pulse8->adap, status);
 356 }
 357
 358 static irqreturn_t pulse8_interrupt(struct serio *serio, unsigned char data,
 359                                     unsigned int flags)
 360 {
 361         struct pulse8 *pulse8 = serio_get_drvdata(serio);
 362         unsigned long irq_flags;
 363         unsigned int idx;
 364
 365         if (!pulse8->started && data != MSGSTART)
 366                 return IRQ_HANDLED;
 367         if (data == MSGESC) {
 368                 pulse8->escape = true;
 369                 return IRQ_HANDLED;
 370         }
 371         if (pulse8->escape) {
 372                 data += MSGOFFSET;
 373                 pulse8->escape = false;
 374         } else if (data == MSGEND) {
 375                 u8 msgcode = pulse8->buf[0];
 376
 377                 if (debug > 1)
 378                         dev_info(pulse8->dev, "received %s: %*ph\n",
 379                                  pulse8_msgname(msgcode),
 380                                  pulse8->idx, pulse8->buf);
 381                 switch (msgcode & 0x3f) {
 382                 case MSGCODE_FRAME_START:
 383                         /*
 384                          * Test if we are receiving a new msg when a previous
 385                          * message is still pending.
 386                          */
 387                         if (!(msgcode & MSGCODE_FRAME_EOM)) {
 388                                 pulse8->new_rx_msg_len = 1;
 389                                 pulse8->new_rx_msg[0] = pulse8->buf[1];
 390                                 break;
 391                         }
 392                         /* fall through */
 393                 case MSGCODE_FRAME_DATA:
 394                         if (pulse8->new_rx_msg_len < CEC_MAX_MSG_SIZE)
 395                                 pulse8->new_rx_msg[pulse8->new_rx_msg_len++] =
 396                                         pulse8->buf[1];
 397                         if (!(msgcode & MSGCODE_FRAME_EOM))
 398                                 break;
 399
 400                         spin_lock_irqsave(&pulse8->msg_lock, irq_flags);
 401                         idx = (pulse8->rx_msg_cur_idx + pulse8->rx_msg_num) %
 402                                 NUM_MSGS;
 403                         if (pulse8->rx_msg_num == NUM_MSGS) {
 404                                 dev_warn(pulse8->dev,
 405                                          "message queue is full, dropping %*ph\n",
 406                                          pulse8->new_rx_msg_len,
 407                                          pulse8->new_rx_msg);
 408                                 spin_unlock_irqrestore(&pulse8->msg_lock,
 409                                                        irq_flags);
 410                                 pulse8->new_rx_msg_len = 0;
 411                                 break;
 412                         }
 413                         pulse8->rx_msg_num++;
 414                         memcpy(pulse8->rx_msg[idx].msg, pulse8->new_rx_msg,
 415                                pulse8->new_rx_msg_len);
 416                         pulse8->rx_msg[idx].len = pulse8->new_rx_msg_len;
 417                         spin_unlock_irqrestore(&pulse8->msg_lock, irq_flags);
 418                         schedule_work(&pulse8->irq_work);
 419                         pulse8->new_rx_msg_len = 0;
 420                         break;
 421                 case MSGCODE_TRANSMIT_SUCCEEDED:
 422                         WARN_ON(pulse8->tx_done_status);
 423                         pulse8->tx_done_status = CEC_TX_STATUS_OK;
 424                         schedule_work(&pulse8->irq_work);
 425                         break;
 426                 case MSGCODE_TRANSMIT_FAILED_ACK:
 427                         /*
 428                          * A NACK for a broadcast message makes no sense, these
 429                          * seem to be spurious messages and are skipped.
 430                          */
 431                         if (pulse8->tx_msg_is_bcast)
 432                                 break;
 433                         WARN_ON(pulse8->tx_done_status);
 434                         pulse8->tx_done_status = CEC_TX_STATUS_NACK;
 435                         schedule_work(&pulse8->irq_work);
 436                         break;
 437                 case MSGCODE_TRANSMIT_FAILED_LINE:
 438                 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
 439                 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
 440                         WARN_ON(pulse8->tx_done_status);
 441                         pulse8->tx_done_status = CEC_TX_STATUS_ERROR;
 442                         schedule_work(&pulse8->irq_work);
 443                         break;
 444                 case MSGCODE_HIGH_ERROR:
 445                 case MSGCODE_LOW_ERROR:
 446                 case MSGCODE_RECEIVE_FAILED:
 447                 case MSGCODE_TIMEOUT_ERROR:
 448                         pulse8->new_rx_msg_len = 0;
 449                         break;
 450                 case MSGCODE_COMMAND_ACCEPTED:
 451                 case MSGCODE_COMMAND_REJECTED:
 452                 default:
 453                         if (pulse8->idx == 0)
 454                                 break;
 455                         memcpy(pulse8->data, pulse8->buf, pulse8->idx);
 456                         pulse8->len = pulse8->idx;
 457                         complete(&pulse8->cmd_done);
 458                         break;
 459                 }
 460                 pulse8->idx = 0;
 461                 pulse8->started = false;
 462                 return IRQ_HANDLED;
 463         } else if (data == MSGSTART) {
 464                 pulse8->idx = 0;
 465                 pulse8->started = true;
 466                 return IRQ_HANDLED;
 467         }
 468
 469         if (pulse8->idx >= DATA_SIZE) {
 470                 dev_dbg(pulse8->dev,
 471                         "throwing away %d bytes of garbage\n", pulse8->idx);
 472                 pulse8->idx = 0;
 473         }
 474         pulse8->buf[pulse8->idx++] = data;
 475         return IRQ_HANDLED;
 476 }
 477
 478 static int pulse8_cec_adap_enable(struct cec_adapter *adap, bool enable)
 479 {
 480         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 481         u8 cmd[16];
 482         int err;
 483
 484         mutex_lock(&pulse8->lock);
 485         cmd[0] = MSGCODE_SET_CONTROLLED;
 486         cmd[1] = enable;
 487         err = pulse8_send_and_wait(pulse8, cmd, 2,
 488                                    MSGCODE_COMMAND_ACCEPTED, 1);
 489         if (!enable) {
 490                 pulse8->rx_msg_num = 0;
 491                 pulse8->tx_done_status = 0;
 492         }
 493         mutex_unlock(&pulse8->lock);
 494         return enable ? err : 0;
 495 }
 496
 497 static int pulse8_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
 498 {
 499         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 500         u16 mask = 0;
 501         u16 pa = adap->phys_addr;
 502         u8 cmd[16];
 503         int err = 0;
 504
 505         mutex_lock(&pulse8->lock);
 506         if (log_addr != CEC_LOG_ADDR_INVALID)
 507                 mask = 1 << log_addr;
 508         cmd[0] = MSGCODE_SET_ACK_MASK;
 509         cmd[1] = mask >> 8;
 510         cmd[2] = mask & 0xff;
 511         err = pulse8_send_and_wait(pulse8, cmd, 3,
 512                                    MSGCODE_COMMAND_ACCEPTED, 0);
 513         if ((err && mask != 0) || pulse8->restoring_config)
 514                 goto unlock;
 515
 516         cmd[0] = MSGCODE_SET_AUTO_ENABLED;
 517         cmd[1] = log_addr == CEC_LOG_ADDR_INVALID ? 0 : 1;
 518         err = pulse8_send_and_wait(pulse8, cmd, 2,
 519                                    MSGCODE_COMMAND_ACCEPTED, 0);
 520         if (err)
 521                 goto unlock;
 522         pulse8->autonomous = cmd[1];
 523         if (log_addr == CEC_LOG_ADDR_INVALID)
 524                 goto unlock;
 525
 526         cmd[0] = MSGCODE_SET_DEVICE_TYPE;
 527         cmd[1] = adap->log_addrs.primary_device_type[0];
 528         err = pulse8_send_and_wait(pulse8, cmd, 2,
 529                                    MSGCODE_COMMAND_ACCEPTED, 0);
 530         if (err)
 531                 goto unlock;
 532
 533         switch (adap->log_addrs.primary_device_type[0]) {
 534         case CEC_OP_PRIM_DEVTYPE_TV:
 535                 mask = CEC_LOG_ADDR_MASK_TV;
 536                 break;
 537         case CEC_OP_PRIM_DEVTYPE_RECORD:
 538                 mask = CEC_LOG_ADDR_MASK_RECORD;
 539                 break;
 540         case CEC_OP_PRIM_DEVTYPE_TUNER:
 541                 mask = CEC_LOG_ADDR_MASK_TUNER;
 542                 break;
 543         case CEC_OP_PRIM_DEVTYPE_PLAYBACK:
 544                 mask = CEC_LOG_ADDR_MASK_PLAYBACK;
 545                 break;
 546         case CEC_OP_PRIM_DEVTYPE_AUDIOSYSTEM:
 547                 mask = CEC_LOG_ADDR_MASK_AUDIOSYSTEM;
 548                 break;
 549         case CEC_OP_PRIM_DEVTYPE_SWITCH:
 550                 mask = CEC_LOG_ADDR_MASK_UNREGISTERED;
 551                 break;
 552         case CEC_OP_PRIM_DEVTYPE_PROCESSOR:
 553                 mask = CEC_LOG_ADDR_MASK_SPECIFIC;
 554                 break;
 555         default:
 556                 mask = 0;
 557                 break;
 558         }
 559         cmd[0] = MSGCODE_SET_LOGICAL_ADDRESS_MASK;
 560         cmd[1] = mask >> 8;
 561         cmd[2] = mask & 0xff;
 562         err = pulse8_send_and_wait(pulse8, cmd, 3,
 563                                    MSGCODE_COMMAND_ACCEPTED, 0);
 564         if (err)
 565                 goto unlock;
 566
 567         cmd[0] = MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS;
 568         cmd[1] = log_addr;
 569         err = pulse8_send_and_wait(pulse8, cmd, 2,
 570                                    MSGCODE_COMMAND_ACCEPTED, 0);
 571         if (err)
 572                 goto unlock;
 573
 574         cmd[0] = MSGCODE_SET_PHYSICAL_ADDRESS;
 575         cmd[1] = pa >> 8;
 576         cmd[2] = pa & 0xff;
 577         err = pulse8_send_and_wait(pulse8, cmd, 3,
 578                                    MSGCODE_COMMAND_ACCEPTED, 0);
 579         if (err)
 580                 goto unlock;
 581
 582         cmd[0] = MSGCODE_SET_HDMI_VERSION;
 583         cmd[1] = adap->log_addrs.cec_version;
 584         err = pulse8_send_and_wait(pulse8, cmd, 2,
 585                                    MSGCODE_COMMAND_ACCEPTED, 0);
 586         if (err)
 587                 goto unlock;
 588
 589         if (adap->log_addrs.osd_name[0]) {
 590                 size_t osd_len = strlen(adap->log_addrs.osd_name);
 591                 char *osd_str = cmd + 1;
 592
 593                 cmd[0] = MSGCODE_SET_OSD_NAME;
 594                 strscpy(cmd + 1, adap->log_addrs.osd_name, sizeof(cmd) - 1);
 595                 if (osd_len < 4) {
 596                         memset(osd_str + osd_len, ' ', 4 - osd_len);
 597                         osd_len = 4;
 598                         osd_str[osd_len] = '\0';
 599                         strscpy(adap->log_addrs.osd_name, osd_str,
 600                                 sizeof(adap->log_addrs.osd_name));
 601                 }
 602                 err = pulse8_send_and_wait(pulse8, cmd, 1 + osd_len,
 603                                            MSGCODE_COMMAND_ACCEPTED, 0);
 604                 if (err)
 605                         goto unlock;
 606         }
 607
 608 unlock:
 609         if (pulse8->restoring_config)
 610                 pulse8->restoring_config = false;
 611         else
 612                 pulse8->config_pending = true;
 613         mutex_unlock(&pulse8->lock);
 614         return log_addr == CEC_LOG_ADDR_INVALID ? 0 : err;
 615 }
 616
 617 static int pulse8_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
 618                                     u32 signal_free_time, struct cec_msg *msg)
 619 {
 620         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 621
 622         pulse8->tx_msg = *msg;
 623         if (debug)
 624                 dev_info(pulse8->dev, "adap transmit %*ph\n",
 625                          msg->len, msg->msg);
 626         pulse8->tx_signal_free_time = signal_free_time;
 627         schedule_work(&pulse8->tx_work);
 628         return 0;
 629 }
 630
 631 static void pulse8_cec_adap_free(struct cec_adapter *adap)
 632 {
 633         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 634
 635         cancel_delayed_work_sync(&pulse8->ping_eeprom_work);
 636         cancel_work_sync(&pulse8->irq_work);
 637         cancel_work_sync(&pulse8->tx_work);
 638         serio_close(pulse8->serio);
 639         serio_set_drvdata(pulse8->serio, NULL);
 640         kfree(pulse8);
 641 }
 642
 643 static const struct cec_adap_ops pulse8_cec_adap_ops = {
 644         .adap_enable = pulse8_cec_adap_enable,
 645         .adap_log_addr = pulse8_cec_adap_log_addr,
 646         .adap_transmit = pulse8_cec_adap_transmit,
 647         .adap_free = pulse8_cec_adap_free,
 648 };
 649
 650 static void pulse8_disconnect(struct serio *serio)
 651 {
 652         struct pulse8 *pulse8 = serio_get_drvdata(serio);
 653
 654         cec_unregister_adapter(pulse8->adap);
 655 }
 656
 657 static int pulse8_setup(struct pulse8 *pulse8, struct serio *serio,
 658                         struct cec_log_addrs *log_addrs, u16 *pa)
 659 {
 660         u8 *data = pulse8->data + 1;
 661         u8 cmd[2];
 662         int err;
 663         struct tm tm;
 664         time64_t date;
 665
 666         pulse8->vers = 0;
 667
 668         cmd[0] = MSGCODE_FIRMWARE_VERSION;
 669         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 2);
 670         if (err)
 671                 return err;
 672         pulse8->vers = (data[0] << 8) | data[1];
 673         dev_info(pulse8->dev, "Firmware version %04x\n", pulse8->vers);
 674         if (pulse8->vers < 2) {
 675                 *pa = CEC_PHYS_ADDR_INVALID;
 676                 return 0;
 677         }
 678
 679         cmd[0] = MSGCODE_GET_BUILDDATE;
 680         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 4);
 681         if (err)
 682                 return err;
 683         date = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
 684         time64_to_tm(date, 0, &tm);
 685         dev_info(pulse8->dev, "Firmware build date %04ld.%02d.%02d %02d:%02d:%02d\n",
 686                  tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 687                  tm.tm_hour, tm.tm_min, tm.tm_sec);
 688
 689         dev_dbg(pulse8->dev, "Persistent config:\n");
 690         cmd[0] = MSGCODE_GET_AUTO_ENABLED;
 691         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 692         if (err)
 693                 return err;
 694         pulse8->autonomous = data[0];
 695         dev_dbg(pulse8->dev, "Autonomous mode: %s",
 696                 data[0] ? "on" : "off");
 697
 698         cmd[0] = MSGCODE_GET_DEVICE_TYPE;
 699         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 700         if (err)
 701                 return err;
 702         log_addrs->primary_device_type[0] = data[0];
 703         dev_dbg(pulse8->dev, "Primary device type: %d\n", data[0]);
 704         switch (log_addrs->primary_device_type[0]) {
 705         case CEC_OP_PRIM_DEVTYPE_TV:
 706                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_TV;
 707                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_TV;
 708                 break;
 709         case CEC_OP_PRIM_DEVTYPE_RECORD:
 710                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_RECORD;
 711                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_RECORD;
 712                 break;
 713         case CEC_OP_PRIM_DEVTYPE_TUNER:
 714                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_TUNER;
 715                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_TUNER;
 716                 break;
 717         case CEC_OP_PRIM_DEVTYPE_PLAYBACK:
 718                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_PLAYBACK;
 719                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_PLAYBACK;
 720                 break;
 721         case CEC_OP_PRIM_DEVTYPE_AUDIOSYSTEM:
 722                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_PLAYBACK;
 723                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_AUDIOSYSTEM;
 724                 break;
 725         case CEC_OP_PRIM_DEVTYPE_SWITCH:
 726                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_UNREGISTERED;
 727                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 728                 break;
 729         case CEC_OP_PRIM_DEVTYPE_PROCESSOR:
 730                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_SPECIFIC;
 731                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 732                 break;
 733         default:
 734                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_UNREGISTERED;
 735                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 736                 dev_info(pulse8->dev, "Unknown Primary Device Type: %d\n",
 737                          log_addrs->primary_device_type[0]);
 738                 break;
 739         }
 740
 741         cmd[0] = MSGCODE_GET_LOGICAL_ADDRESS_MASK;
 742         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 2);
 743         if (err)
 744                 return err;
 745         log_addrs->log_addr_mask = (data[0] << 8) | data[1];
 746         dev_dbg(pulse8->dev, "Logical address ACK mask: %x\n",
 747                 log_addrs->log_addr_mask);
 748         if (log_addrs->log_addr_mask)
 749                 log_addrs->num_log_addrs = 1;
 750
 751         cmd[0] = MSGCODE_GET_PHYSICAL_ADDRESS;
 752         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 753         if (err)
 754                 return err;
 755         *pa = (data[0] << 8) | data[1];
 756         dev_dbg(pulse8->dev, "Physical address: %x.%x.%x.%x\n",
 757                 cec_phys_addr_exp(*pa));
 758
 759         cmd[0] = MSGCODE_GET_HDMI_VERSION;
 760         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 761         if (err)
 762                 return err;
 763         log_addrs->cec_version = data[0];
 764         dev_dbg(pulse8->dev, "CEC version: %d\n", log_addrs->cec_version);
 765
 766         cmd[0] = MSGCODE_GET_OSD_NAME;
 767         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 0);
 768         if (err)
 769                 return err;
 770         strscpy(log_addrs->osd_name, data, sizeof(log_addrs->osd_name));
 771         dev_dbg(pulse8->dev, "OSD name: %s\n", log_addrs->osd_name);
 772
 773         return 0;
 774 }
 775
 776 static int pulse8_apply_persistent_config(struct pulse8 *pulse8,
 777                                           struct cec_log_addrs *log_addrs,
 778                                           u16 pa)
 779 {
 780         int err;
 781
 782         err = cec_s_log_addrs(pulse8->adap, log_addrs, false);
 783         if (err)
 784                 return err;
 785
 786         cec_s_phys_addr(pulse8->adap, pa, false);
 787
 788         return 0;
 789 }
 790
 791 static void pulse8_ping_eeprom_work_handler(struct work_struct *work)
 792 {
 793         struct pulse8 *pulse8 =
 794                 container_of(work, struct pulse8, ping_eeprom_work.work);
 795         u8 cmd;
 796
 797         mutex_lock(&pulse8->lock);
 798         cmd = MSGCODE_PING;
 799         pulse8_send_and_wait(pulse8, &cmd, 1,
 800                              MSGCODE_COMMAND_ACCEPTED, 0);
 801
 802         if (pulse8->vers < 2)
 803                 goto unlock;
 804
 805         if (pulse8->config_pending && persistent_config) {
 806                 dev_dbg(pulse8->dev, "writing pending config to EEPROM\n");
 807                 cmd = MSGCODE_WRITE_EEPROM;
 808                 if (pulse8_send_and_wait(pulse8, &cmd, 1,
 809                                          MSGCODE_COMMAND_ACCEPTED, 0))
 810                         dev_info(pulse8->dev, "failed to write pending config to EEPROM\n");
 811                 else
 812                         pulse8->config_pending = false;
 813         }
 814 unlock:
 815         schedule_delayed_work(&pulse8->ping_eeprom_work, PING_PERIOD);
 816         mutex_unlock(&pulse8->lock);
 817 }
 818
 819 static int pulse8_connect(struct serio *serio, struct serio_driver *drv)
 820 {
 821         u32 caps = CEC_CAP_DEFAULTS | CEC_CAP_PHYS_ADDR | CEC_CAP_MONITOR_ALL;
 822         struct pulse8 *pulse8;
 823         int err = -ENOMEM;
 824         struct cec_log_addrs log_addrs = {};
 825         u16 pa = CEC_PHYS_ADDR_INVALID;
 826
 827         pulse8 = kzalloc(sizeof(*pulse8), GFP_KERNEL);
 828
 829         if (!pulse8)
 830                 return -ENOMEM;
 831
 832         pulse8->serio = serio;
 833         pulse8->adap = cec_allocate_adapter(&pulse8_cec_adap_ops, pulse8,
 834                                             dev_name(&serio->dev), caps, 1);
 835         err = PTR_ERR_OR_ZERO(pulse8->adap);
 836         if (err < 0)
 837                 goto free_device;
 838
 839         pulse8->dev = &serio->dev;
 840         serio_set_drvdata(serio, pulse8);
 841         INIT_WORK(&pulse8->irq_work, pulse8_irq_work_handler);
 842         INIT_WORK(&pulse8->tx_work, pulse8_tx_work_handler);
 843         mutex_init(&pulse8->lock);
 844         spin_lock_init(&pulse8->msg_lock);
 845         pulse8->config_pending = false;
 846
 847         err = serio_open(serio, drv);
 848         if (err)
 849                 goto delete_adap;
 850
 851         err = pulse8_setup(pulse8, serio, &log_addrs, &pa);
 852         if (err)
 853                 goto close_serio;
 854
 855         err = cec_register_adapter(pulse8->adap, &serio->dev);
 856         if (err < 0)
 857                 goto close_serio;
 858
 859         pulse8->dev = &pulse8->adap->devnode.dev;
 860
 861         if (persistent_config && pulse8->autonomous) {
 862                 err = pulse8_apply_persistent_config(pulse8, &log_addrs, pa);
 863                 if (err)
 864                         goto close_serio;
 865                 pulse8->restoring_config = true;
 866         }
 867
 868         INIT_DELAYED_WORK(&pulse8->ping_eeprom_work,
 869                           pulse8_ping_eeprom_work_handler);
 870         schedule_delayed_work(&pulse8->ping_eeprom_work, PING_PERIOD);
 871
 872         return 0;
 873
 874 close_serio:
 875         serio_close(serio);
 876 delete_adap:
 877         cec_delete_adapter(pulse8->adap);
 878         serio_set_drvdata(serio, NULL);
 879 free_device:
 880         kfree(pulse8);
 881         return err;
 882 }
 883
 884 static const struct serio_device_id pulse8_serio_ids[] = {
 885         {
 886                 .type   = SERIO_RS232,
 887                 .proto  = SERIO_PULSE8_CEC,
 888                 .id     = SERIO_ANY,
 889                 .extra  = SERIO_ANY,
 890         },
 891         { 0 }
 892 };
 893
 894 MODULE_DEVICE_TABLE(serio, pulse8_serio_ids);
 895
 896 static struct serio_driver pulse8_drv = {
 897         .driver         = {
 898                 .name   = "pulse8-cec",
 899         },
 900         .description    = "Pulse Eight HDMI CEC driver",
 901         .id_table       = pulse8_serio_ids,
 902         .interrupt      = pulse8_interrupt,
 903         .connect        = pulse8_connect,
 904         .disconnect     = pulse8_disconnect,
 905 };
 906
 907 module_serio_driver(pulse8_drv);