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