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

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