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-1)");
  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 struct pulse8 {
 168         struct device *dev;
 169         struct serio *serio;
 170         struct cec_adapter *adap;
 171         unsigned int vers;
 172         struct completion cmd_done;
 173         struct work_struct work;
 174         u8 work_result;
 175         struct delayed_work ping_eeprom_work;
 176         struct cec_msg rx_msg;
 177         u8 data[DATA_SIZE];
 178         unsigned int len;
 179         u8 buf[DATA_SIZE];
 180         unsigned int idx;
 181         bool escape;
 182         bool started;
 183         struct mutex config_lock;
 184         struct mutex write_lock;
 185         bool config_pending;
 186         bool restoring_config;
 187         bool autonomous;
 188 };
 189
 190 static int pulse8_send(struct serio *serio, const u8 *command, u8 cmd_len)
 191 {
 192         int err = 0;
 193
 194         err = serio_write(serio, MSGSTART);
 195         if (err)
 196                 return err;
 197         for (; !err && cmd_len; command++, cmd_len--) {
 198                 if (*command >= MSGESC) {
 199                         err = serio_write(serio, MSGESC);
 200                         if (!err)
 201                                 err = serio_write(serio, *command - MSGOFFSET);
 202                 } else {
 203                         err = serio_write(serio, *command);
 204                 }
 205         }
 206         if (!err)
 207                 err = serio_write(serio, MSGEND);
 208
 209         return err;
 210 }
 211
 212 static int pulse8_send_and_wait_once(struct pulse8 *pulse8,
 213                                      const u8 *cmd, u8 cmd_len,
 214                                      u8 response, u8 size)
 215 {
 216         int err;
 217
 218         /* dev_info(pulse8->dev, "transmit %s: %*ph\n", pulse8_msgname(cmd[0]), cmd_len, cmd); */
 219         init_completion(&pulse8->cmd_done);
 220
 221         err = pulse8_send(pulse8->serio, cmd, cmd_len);
 222         if (err)
 223                 return err;
 224
 225         if (!wait_for_completion_timeout(&pulse8->cmd_done, HZ))
 226                 return -ETIMEDOUT;
 227         if ((pulse8->data[0] & 0x3f) == MSGCODE_COMMAND_REJECTED &&
 228             cmd[0] != MSGCODE_SET_CONTROLLED &&
 229             cmd[0] != MSGCODE_SET_AUTO_ENABLED &&
 230             cmd[0] != MSGCODE_GET_BUILDDATE)
 231                 return -ENOTTY;
 232         if (response &&
 233             ((pulse8->data[0] & 0x3f) != response || pulse8->len < size + 1)) {
 234                 dev_info(pulse8->dev, "transmit %s: failed %s\n",
 235                          pulse8_msgname(cmd[0]), pulse8_msgname(pulse8->data[0]));
 236                 return -EIO;
 237         }
 238         return 0;
 239 }
 240
 241 static int pulse8_send_and_wait(struct pulse8 *pulse8,
 242                                 const u8 *cmd, u8 cmd_len, u8 response, u8 size)
 243 {
 244         u8 cmd_sc[2];
 245         int err;
 246
 247         mutex_lock(&pulse8->write_lock);
 248         err = pulse8_send_and_wait_once(pulse8, cmd, cmd_len, response, size);
 249
 250         if (err == -ENOTTY) {
 251                 cmd_sc[0] = MSGCODE_SET_CONTROLLED;
 252                 cmd_sc[1] = 1;
 253                 err = pulse8_send_and_wait_once(pulse8, cmd_sc, 2,
 254                                                 MSGCODE_COMMAND_ACCEPTED, 1);
 255                 if (err)
 256                         goto unlock;
 257                 err = pulse8_send_and_wait_once(pulse8, cmd, cmd_len,
 258                                                 response, size);
 259         }
 260
 261 unlock:
 262         mutex_unlock(&pulse8->write_lock);
 263         return err == -ENOTTY ? -EIO : err;
 264 }
 265
 266 static void pulse8_irq_work_handler(struct work_struct *work)
 267 {
 268         struct pulse8 *pulse8 =
 269                 container_of(work, struct pulse8, work);
 270         u8 result = pulse8->work_result;
 271
 272         pulse8->work_result = 0;
 273         switch (result & 0x3f) {
 274         case MSGCODE_FRAME_DATA:
 275                 cec_received_msg(pulse8->adap, &pulse8->rx_msg);
 276                 break;
 277         case MSGCODE_TRANSMIT_SUCCEEDED:
 278                 cec_transmit_attempt_done(pulse8->adap, CEC_TX_STATUS_OK);
 279                 break;
 280         case MSGCODE_TRANSMIT_FAILED_ACK:
 281                 cec_transmit_attempt_done(pulse8->adap, CEC_TX_STATUS_NACK);
 282                 break;
 283         case MSGCODE_TRANSMIT_FAILED_LINE:
 284         case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
 285         case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
 286                 cec_transmit_attempt_done(pulse8->adap, CEC_TX_STATUS_ERROR);
 287                 break;
 288         }
 289 }
 290
 291 static irqreturn_t pulse8_interrupt(struct serio *serio, unsigned char data,
 292                                     unsigned int flags)
 293 {
 294         struct pulse8 *pulse8 = serio_get_drvdata(serio);
 295
 296         if (!pulse8->started && data != MSGSTART)
 297                 return IRQ_HANDLED;
 298         if (data == MSGESC) {
 299                 pulse8->escape = true;
 300                 return IRQ_HANDLED;
 301         }
 302         if (pulse8->escape) {
 303                 data += MSGOFFSET;
 304                 pulse8->escape = false;
 305         } else if (data == MSGEND) {
 306                 struct cec_msg *msg = &pulse8->rx_msg;
 307                 u8 msgcode = pulse8->buf[0];
 308
 309                 if (debug)
 310                         dev_info(pulse8->dev, "received %s: %*ph\n",
 311                                  pulse8_msgname(msgcode), pulse8->idx, pulse8->buf);
 312                 switch (msgcode & 0x3f) {
 313                 case MSGCODE_FRAME_START:
 314                         msg->len = 1;
 315                         msg->msg[0] = pulse8->buf[1];
 316                         break;
 317                 case MSGCODE_FRAME_DATA:
 318                         if (msg->len == CEC_MAX_MSG_SIZE)
 319                                 break;
 320                         msg->msg[msg->len++] = pulse8->buf[1];
 321                         if (msgcode & MSGCODE_FRAME_EOM) {
 322                                 WARN_ON(pulse8->work_result);
 323                                 pulse8->work_result = msgcode;
 324                                 schedule_work(&pulse8->work);
 325                                 break;
 326                         }
 327                         break;
 328                 case MSGCODE_TRANSMIT_SUCCEEDED:
 329                 case MSGCODE_TRANSMIT_FAILED_LINE:
 330                 case MSGCODE_TRANSMIT_FAILED_ACK:
 331                 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
 332                 case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
 333                         WARN_ON(pulse8->work_result);
 334                         pulse8->work_result = msgcode;
 335                         schedule_work(&pulse8->work);
 336                         break;
 337                 case MSGCODE_HIGH_ERROR:
 338                 case MSGCODE_LOW_ERROR:
 339                 case MSGCODE_RECEIVE_FAILED:
 340                 case MSGCODE_TIMEOUT_ERROR:
 341                         break;
 342                 case MSGCODE_COMMAND_ACCEPTED:
 343                 case MSGCODE_COMMAND_REJECTED:
 344                 default:
 345                         if (pulse8->idx == 0)
 346                                 break;
 347                         memcpy(pulse8->data, pulse8->buf, pulse8->idx);
 348                         pulse8->len = pulse8->idx;
 349                         complete(&pulse8->cmd_done);
 350                         break;
 351                 }
 352                 pulse8->idx = 0;
 353                 pulse8->started = false;
 354                 return IRQ_HANDLED;
 355         } else if (data == MSGSTART) {
 356                 pulse8->idx = 0;
 357                 pulse8->started = true;
 358                 return IRQ_HANDLED;
 359         }
 360
 361         if (pulse8->idx >= DATA_SIZE) {
 362                 dev_dbg(pulse8->dev,
 363                         "throwing away %d bytes of garbage\n", pulse8->idx);
 364                 pulse8->idx = 0;
 365         }
 366         pulse8->buf[pulse8->idx++] = data;
 367         return IRQ_HANDLED;
 368 }
 369
 370 static int pulse8_cec_adap_enable(struct cec_adapter *adap, bool enable)
 371 {
 372         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 373         u8 cmd[16];
 374         int err;
 375
 376         cmd[0] = MSGCODE_SET_CONTROLLED;
 377         cmd[1] = enable;
 378         err = pulse8_send_and_wait(pulse8, cmd, 2,
 379                                    MSGCODE_COMMAND_ACCEPTED, 1);
 380         return enable ? err : 0;
 381 }
 382
 383 static int pulse8_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
 384 {
 385         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 386         u16 mask = 0;
 387         u16 pa = adap->phys_addr;
 388         u8 cmd[16];
 389         int err = 0;
 390
 391         mutex_lock(&pulse8->config_lock);
 392         if (log_addr != CEC_LOG_ADDR_INVALID)
 393                 mask = 1 << log_addr;
 394         cmd[0] = MSGCODE_SET_ACK_MASK;
 395         cmd[1] = mask >> 8;
 396         cmd[2] = mask & 0xff;
 397         err = pulse8_send_and_wait(pulse8, cmd, 3,
 398                                    MSGCODE_COMMAND_ACCEPTED, 0);
 399         if ((err && mask != 0) || pulse8->restoring_config)
 400                 goto unlock;
 401
 402         cmd[0] = MSGCODE_SET_AUTO_ENABLED;
 403         cmd[1] = log_addr == CEC_LOG_ADDR_INVALID ? 0 : 1;
 404         err = pulse8_send_and_wait(pulse8, cmd, 2,
 405                                    MSGCODE_COMMAND_ACCEPTED, 0);
 406         if (err)
 407                 goto unlock;
 408         pulse8->autonomous = cmd[1];
 409         if (log_addr == CEC_LOG_ADDR_INVALID)
 410                 goto unlock;
 411
 412         cmd[0] = MSGCODE_SET_DEVICE_TYPE;
 413         cmd[1] = adap->log_addrs.primary_device_type[0];
 414         err = pulse8_send_and_wait(pulse8, cmd, 2,
 415                                    MSGCODE_COMMAND_ACCEPTED, 0);
 416         if (err)
 417                 goto unlock;
 418
 419         switch (adap->log_addrs.primary_device_type[0]) {
 420         case CEC_OP_PRIM_DEVTYPE_TV:
 421                 mask = CEC_LOG_ADDR_MASK_TV;
 422                 break;
 423         case CEC_OP_PRIM_DEVTYPE_RECORD:
 424                 mask = CEC_LOG_ADDR_MASK_RECORD;
 425                 break;
 426         case CEC_OP_PRIM_DEVTYPE_TUNER:
 427                 mask = CEC_LOG_ADDR_MASK_TUNER;
 428                 break;
 429         case CEC_OP_PRIM_DEVTYPE_PLAYBACK:
 430                 mask = CEC_LOG_ADDR_MASK_PLAYBACK;
 431                 break;
 432         case CEC_OP_PRIM_DEVTYPE_AUDIOSYSTEM:
 433                 mask = CEC_LOG_ADDR_MASK_AUDIOSYSTEM;
 434                 break;
 435         case CEC_OP_PRIM_DEVTYPE_SWITCH:
 436                 mask = CEC_LOG_ADDR_MASK_UNREGISTERED;
 437                 break;
 438         case CEC_OP_PRIM_DEVTYPE_PROCESSOR:
 439                 mask = CEC_LOG_ADDR_MASK_SPECIFIC;
 440                 break;
 441         default:
 442                 mask = 0;
 443                 break;
 444         }
 445         cmd[0] = MSGCODE_SET_LOGICAL_ADDRESS_MASK;
 446         cmd[1] = mask >> 8;
 447         cmd[2] = mask & 0xff;
 448         err = pulse8_send_and_wait(pulse8, cmd, 3,
 449                                    MSGCODE_COMMAND_ACCEPTED, 0);
 450         if (err)
 451                 goto unlock;
 452
 453         cmd[0] = MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS;
 454         cmd[1] = log_addr;
 455         err = pulse8_send_and_wait(pulse8, cmd, 2,
 456                                    MSGCODE_COMMAND_ACCEPTED, 0);
 457         if (err)
 458                 goto unlock;
 459
 460         cmd[0] = MSGCODE_SET_PHYSICAL_ADDRESS;
 461         cmd[1] = pa >> 8;
 462         cmd[2] = pa & 0xff;
 463         err = pulse8_send_and_wait(pulse8, cmd, 3,
 464                                    MSGCODE_COMMAND_ACCEPTED, 0);
 465         if (err)
 466                 goto unlock;
 467
 468         cmd[0] = MSGCODE_SET_HDMI_VERSION;
 469         cmd[1] = adap->log_addrs.cec_version;
 470         err = pulse8_send_and_wait(pulse8, cmd, 2,
 471                                    MSGCODE_COMMAND_ACCEPTED, 0);
 472         if (err)
 473                 goto unlock;
 474
 475         if (adap->log_addrs.osd_name[0]) {
 476                 size_t osd_len = strlen(adap->log_addrs.osd_name);
 477                 char *osd_str = cmd + 1;
 478
 479                 cmd[0] = MSGCODE_SET_OSD_NAME;
 480                 strscpy(cmd + 1, adap->log_addrs.osd_name, sizeof(cmd) - 1);
 481                 if (osd_len < 4) {
 482                         memset(osd_str + osd_len, ' ', 4 - osd_len);
 483                         osd_len = 4;
 484                         osd_str[osd_len] = '\0';
 485                         strscpy(adap->log_addrs.osd_name, osd_str,
 486                                 sizeof(adap->log_addrs.osd_name));
 487                 }
 488                 err = pulse8_send_and_wait(pulse8, cmd, 1 + osd_len,
 489                                            MSGCODE_COMMAND_ACCEPTED, 0);
 490                 if (err)
 491                         goto unlock;
 492         }
 493
 494 unlock:
 495         if (pulse8->restoring_config)
 496                 pulse8->restoring_config = false;
 497         else
 498                 pulse8->config_pending = true;
 499         mutex_unlock(&pulse8->config_lock);
 500         return log_addr == CEC_LOG_ADDR_INVALID ? 0 : err;
 501 }
 502
 503 static int pulse8_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
 504                                     u32 signal_free_time, struct cec_msg *msg)
 505 {
 506         struct pulse8 *pulse8 = cec_get_drvdata(adap);
 507         u8 cmd[2];
 508         unsigned int i;
 509         int err;
 510
 511         cmd[0] = MSGCODE_TRANSMIT_IDLETIME;
 512         cmd[1] = signal_free_time;
 513         err = pulse8_send_and_wait(pulse8, cmd, 2,
 514                                    MSGCODE_COMMAND_ACCEPTED, 1);
 515         cmd[0] = MSGCODE_TRANSMIT_ACK_POLARITY;
 516         cmd[1] = cec_msg_is_broadcast(msg);
 517         if (!err)
 518                 err = pulse8_send_and_wait(pulse8, cmd, 2,
 519                                            MSGCODE_COMMAND_ACCEPTED, 1);
 520         cmd[0] = msg->len == 1 ? MSGCODE_TRANSMIT_EOM : MSGCODE_TRANSMIT;
 521         cmd[1] = msg->msg[0];
 522         if (!err)
 523                 err = pulse8_send_and_wait(pulse8, cmd, 2,
 524                                            MSGCODE_COMMAND_ACCEPTED, 1);
 525         if (!err && msg->len > 1) {
 526                 cmd[0] = msg->len == 2 ? MSGCODE_TRANSMIT_EOM :
 527                                          MSGCODE_TRANSMIT;
 528                 cmd[1] = msg->msg[1];
 529                 err = pulse8_send_and_wait(pulse8, cmd, 2,
 530                                            MSGCODE_COMMAND_ACCEPTED, 1);
 531                 for (i = 0; !err && i + 2 < msg->len; i++) {
 532                         cmd[0] = (i + 2 == msg->len - 1) ?
 533                                 MSGCODE_TRANSMIT_EOM : MSGCODE_TRANSMIT;
 534                         cmd[1] = msg->msg[i + 2];
 535                         err = pulse8_send_and_wait(pulse8, cmd, 2,
 536                                                    MSGCODE_COMMAND_ACCEPTED, 1);
 537                 }
 538         }
 539
 540         return err;
 541 }
 542
 543 static const struct cec_adap_ops pulse8_cec_adap_ops = {
 544         .adap_enable = pulse8_cec_adap_enable,
 545         .adap_log_addr = pulse8_cec_adap_log_addr,
 546         .adap_transmit = pulse8_cec_adap_transmit,
 547 };
 548
 549 static void pulse8_disconnect(struct serio *serio)
 550 {
 551         struct pulse8 *pulse8 = serio_get_drvdata(serio);
 552
 553         cec_unregister_adapter(pulse8->adap);
 554         cancel_delayed_work_sync(&pulse8->ping_eeprom_work);
 555         dev_info(&serio->dev, "disconnected\n");
 556         serio_close(serio);
 557         serio_set_drvdata(serio, NULL);
 558         kfree(pulse8);
 559 }
 560
 561 static int pulse8_setup(struct pulse8 *pulse8, struct serio *serio,
 562                         struct cec_log_addrs *log_addrs, u16 *pa)
 563 {
 564         u8 *data = pulse8->data + 1;
 565         u8 cmd[2];
 566         int err;
 567         struct tm tm;
 568         time64_t date;
 569
 570         pulse8->vers = 0;
 571
 572         cmd[0] = MSGCODE_FIRMWARE_VERSION;
 573         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 2);
 574         if (err)
 575                 return err;
 576         pulse8->vers = (data[0] << 8) | data[1];
 577         dev_info(pulse8->dev, "Firmware version %04x\n", pulse8->vers);
 578         if (pulse8->vers < 2) {
 579                 *pa = CEC_PHYS_ADDR_INVALID;
 580                 return 0;
 581         }
 582
 583         cmd[0] = MSGCODE_GET_BUILDDATE;
 584         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 4);
 585         if (err)
 586                 return err;
 587         date = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
 588         time64_to_tm(date, 0, &tm);
 589         dev_info(pulse8->dev, "Firmware build date %04ld.%02d.%02d %02d:%02d:%02d\n",
 590                  tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
 591                  tm.tm_hour, tm.tm_min, tm.tm_sec);
 592
 593         dev_dbg(pulse8->dev, "Persistent config:\n");
 594         cmd[0] = MSGCODE_GET_AUTO_ENABLED;
 595         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 596         if (err)
 597                 return err;
 598         pulse8->autonomous = data[0];
 599         dev_dbg(pulse8->dev, "Autonomous mode: %s",
 600                 data[0] ? "on" : "off");
 601
 602         cmd[0] = MSGCODE_GET_DEVICE_TYPE;
 603         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 604         if (err)
 605                 return err;
 606         log_addrs->primary_device_type[0] = data[0];
 607         dev_dbg(pulse8->dev, "Primary device type: %d\n", data[0]);
 608         switch (log_addrs->primary_device_type[0]) {
 609         case CEC_OP_PRIM_DEVTYPE_TV:
 610                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_TV;
 611                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_TV;
 612                 break;
 613         case CEC_OP_PRIM_DEVTYPE_RECORD:
 614                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_RECORD;
 615                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_RECORD;
 616                 break;
 617         case CEC_OP_PRIM_DEVTYPE_TUNER:
 618                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_TUNER;
 619                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_TUNER;
 620                 break;
 621         case CEC_OP_PRIM_DEVTYPE_PLAYBACK:
 622                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_PLAYBACK;
 623                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_PLAYBACK;
 624                 break;
 625         case CEC_OP_PRIM_DEVTYPE_AUDIOSYSTEM:
 626                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_PLAYBACK;
 627                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_AUDIOSYSTEM;
 628                 break;
 629         case CEC_OP_PRIM_DEVTYPE_SWITCH:
 630                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_UNREGISTERED;
 631                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 632                 break;
 633         case CEC_OP_PRIM_DEVTYPE_PROCESSOR:
 634                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_SPECIFIC;
 635                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 636                 break;
 637         default:
 638                 log_addrs->log_addr_type[0] = CEC_LOG_ADDR_TYPE_UNREGISTERED;
 639                 log_addrs->all_device_types[0] = CEC_OP_ALL_DEVTYPE_SWITCH;
 640                 dev_info(pulse8->dev, "Unknown Primary Device Type: %d\n",
 641                          log_addrs->primary_device_type[0]);
 642                 break;
 643         }
 644
 645         cmd[0] = MSGCODE_GET_LOGICAL_ADDRESS_MASK;
 646         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 2);
 647         if (err)
 648                 return err;
 649         log_addrs->log_addr_mask = (data[0] << 8) | data[1];
 650         dev_dbg(pulse8->dev, "Logical address ACK mask: %x\n",
 651                 log_addrs->log_addr_mask);
 652         if (log_addrs->log_addr_mask)
 653                 log_addrs->num_log_addrs = 1;
 654
 655         cmd[0] = MSGCODE_GET_PHYSICAL_ADDRESS;
 656         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 657         if (err)
 658                 return err;
 659         *pa = (data[0] << 8) | data[1];
 660         dev_dbg(pulse8->dev, "Physical address: %x.%x.%x.%x\n",
 661                 cec_phys_addr_exp(*pa));
 662
 663         cmd[0] = MSGCODE_GET_HDMI_VERSION;
 664         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 1);
 665         if (err)
 666                 return err;
 667         log_addrs->cec_version = data[0];
 668         dev_dbg(pulse8->dev, "CEC version: %d\n", log_addrs->cec_version);
 669
 670         cmd[0] = MSGCODE_GET_OSD_NAME;
 671         err = pulse8_send_and_wait(pulse8, cmd, 1, cmd[0], 0);
 672         if (err)
 673                 return err;
 674         strscpy(log_addrs->osd_name, data, sizeof(log_addrs->osd_name));
 675         dev_dbg(pulse8->dev, "OSD name: %s\n", log_addrs->osd_name);
 676
 677         return 0;
 678 }
 679
 680 static int pulse8_apply_persistent_config(struct pulse8 *pulse8,
 681                                           struct cec_log_addrs *log_addrs,
 682                                           u16 pa)
 683 {
 684         int err;
 685
 686         err = cec_s_log_addrs(pulse8->adap, log_addrs, false);
 687         if (err)
 688                 return err;
 689
 690         cec_s_phys_addr(pulse8->adap, pa, false);
 691
 692         return 0;
 693 }
 694
 695 static void pulse8_ping_eeprom_work_handler(struct work_struct *work)
 696 {
 697         struct pulse8 *pulse8 =
 698                 container_of(work, struct pulse8, ping_eeprom_work.work);
 699         u8 cmd;
 700
 701         schedule_delayed_work(&pulse8->ping_eeprom_work, PING_PERIOD);
 702         cmd = MSGCODE_PING;
 703         pulse8_send_and_wait(pulse8, &cmd, 1,
 704                              MSGCODE_COMMAND_ACCEPTED, 0);
 705
 706         if (pulse8->vers < 2)
 707                 return;
 708
 709         mutex_lock(&pulse8->config_lock);
 710         if (pulse8->config_pending && persistent_config) {
 711                 dev_dbg(pulse8->dev, "writing pending config to EEPROM\n");
 712                 cmd = MSGCODE_WRITE_EEPROM;
 713                 if (pulse8_send_and_wait(pulse8, &cmd, 1,
 714                                          MSGCODE_COMMAND_ACCEPTED, 0))
 715                         dev_info(pulse8->dev, "failed to write pending config to EEPROM\n");
 716                 else
 717                         pulse8->config_pending = false;
 718         }
 719         mutex_unlock(&pulse8->config_lock);
 720 }
 721
 722 static int pulse8_connect(struct serio *serio, struct serio_driver *drv)
 723 {
 724         u32 caps = CEC_CAP_DEFAULTS | CEC_CAP_PHYS_ADDR | CEC_CAP_MONITOR_ALL;
 725         struct pulse8 *pulse8;
 726         int err = -ENOMEM;
 727         struct cec_log_addrs log_addrs = {};
 728         u16 pa = CEC_PHYS_ADDR_INVALID;
 729
 730         pulse8 = kzalloc(sizeof(*pulse8), GFP_KERNEL);
 731
 732         if (!pulse8)
 733                 return -ENOMEM;
 734
 735         pulse8->serio = serio;
 736         pulse8->adap = cec_allocate_adapter(&pulse8_cec_adap_ops, pulse8,
 737                                             dev_name(&serio->dev), caps, 1);
 738         err = PTR_ERR_OR_ZERO(pulse8->adap);
 739         if (err < 0)
 740                 goto free_device;
 741
 742         pulse8->dev = &serio->dev;
 743         serio_set_drvdata(serio, pulse8);
 744         INIT_WORK(&pulse8->work, pulse8_irq_work_handler);
 745         mutex_init(&pulse8->write_lock);
 746         mutex_init(&pulse8->config_lock);
 747         pulse8->config_pending = false;
 748
 749         err = serio_open(serio, drv);
 750         if (err)
 751                 goto delete_adap;
 752
 753         err = pulse8_setup(pulse8, serio, &log_addrs, &pa);
 754         if (err)
 755                 goto close_serio;
 756
 757         err = cec_register_adapter(pulse8->adap, &serio->dev);
 758         if (err < 0)
 759                 goto close_serio;
 760
 761         pulse8->dev = &pulse8->adap->devnode.dev;
 762
 763         if (persistent_config && pulse8->autonomous) {
 764                 err = pulse8_apply_persistent_config(pulse8, &log_addrs, pa);
 765                 if (err)
 766                         goto close_serio;
 767                 pulse8->restoring_config = true;
 768         }
 769
 770         INIT_DELAYED_WORK(&pulse8->ping_eeprom_work,
 771                           pulse8_ping_eeprom_work_handler);
 772         schedule_delayed_work(&pulse8->ping_eeprom_work, PING_PERIOD);
 773
 774         return 0;
 775
 776 close_serio:
 777         serio_close(serio);
 778 delete_adap:
 779         cec_delete_adapter(pulse8->adap);
 780         serio_set_drvdata(serio, NULL);
 781 free_device:
 782         kfree(pulse8);
 783         return err;
 784 }
 785
 786 static const struct serio_device_id pulse8_serio_ids[] = {
 787         {
 788                 .type   = SERIO_RS232,
 789                 .proto  = SERIO_PULSE8_CEC,
 790                 .id     = SERIO_ANY,
 791                 .extra  = SERIO_ANY,
 792         },
 793         { 0 }
 794 };
 795
 796 MODULE_DEVICE_TABLE(serio, pulse8_serio_ids);
 797
 798 static struct serio_driver pulse8_drv = {
 799         .driver         = {
 800                 .name   = "pulse8-cec",
 801         },
 802         .description    = "Pulse Eight HDMI CEC driver",
 803         .id_table       = pulse8_serio_ids,
 804         .interrupt      = pulse8_interrupt,
 805         .connect        = pulse8_connect,
 806         .disconnect     = pulse8_disconnect,
 807 };
 808
 809 module_serio_driver(pulse8_drv);