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