1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * CEC driver for ChromeOS Embedded Controller 4 * 5 * Copyright (c) 2018 BayLibre, SAS 6 * Author: Neil Armstrong <narmstrong@baylibre.com> 7 */ 8 9#include <linux/kernel.h> 10#include <linux/module.h> 11#include <linux/platform_device.h> 12#include <linux/dmi.h> 13#include <linux/pci.h> 14#include <linux/cec.h> 15#include <linux/slab.h> 16#include <linux/interrupt.h> 17#include <linux/platform_data/cros_ec_commands.h> 18#include <linux/platform_data/cros_ec_proto.h> 19#include <media/cec.h> 20#include <media/cec-notifier.h> 21 22#define DRV_NAME "cros-ec-cec" 23 24/** 25 * struct cros_ec_cec_port - Driver data for a single EC CEC port 26 * 27 * @port_num: port number 28 * @adap: CEC adapter 29 * @notify: CEC notifier pointer 30 * @rx_msg: storage for a received message 31 * @cros_ec_cec: pointer to the parent struct 32 */ 33struct cros_ec_cec_port { 34 int port_num; 35 struct cec_adapter *adap; 36 struct cec_notifier *notify; 37 struct cec_msg rx_msg; 38 struct cros_ec_cec *cros_ec_cec; 39}; 40 41/** 42 * struct cros_ec_cec - Driver data for EC CEC 43 * 44 * @cros_ec: Pointer to EC device 45 * @notifier: Notifier info for responding to EC events 46 * @write_cmd_version: Highest supported version of EC_CMD_CEC_WRITE_MSG. 47 * @num_ports: Number of CEC ports 48 * @ports: Array of ports 49 */ 50struct cros_ec_cec { 51 struct cros_ec_device *cros_ec; 52 struct notifier_block notifier; 53 int write_cmd_version; 54 int num_ports; 55 struct cros_ec_cec_port *ports[EC_CEC_MAX_PORTS]; 56}; 57 58static void cros_ec_cec_received_message(struct cros_ec_cec_port *port, 59 uint8_t *msg, uint8_t len) 60{ 61 if (len > CEC_MAX_MSG_SIZE) 62 len = CEC_MAX_MSG_SIZE; 63 64 port->rx_msg.len = len; 65 memcpy(port->rx_msg.msg, msg, len); 66 67 cec_received_msg(port->adap, &port->rx_msg); 68} 69 70static void handle_cec_message(struct cros_ec_cec *cros_ec_cec) 71{ 72 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 73 uint8_t *cec_message = cros_ec->event_data.data.cec_message; 74 unsigned int len = cros_ec->event_size; 75 struct cros_ec_cec_port *port; 76 /* 77 * There are two ways of receiving CEC messages: 78 * 1. Old EC firmware which only supports one port sends the data in a 79 * cec_message MKBP event. 80 * 2. New EC firmware which supports multiple ports uses 81 * EC_MKBP_CEC_HAVE_DATA to notify that data is ready and 82 * EC_CMD_CEC_READ_MSG to read it. 83 * Check that the EC only has one CEC port, and then we can assume the 84 * message is from port 0. 85 */ 86 if (cros_ec_cec->num_ports != 1) { 87 dev_err(cros_ec->dev, 88 "received cec_message on device with %d ports\n", 89 cros_ec_cec->num_ports); 90 return; 91 } 92 port = cros_ec_cec->ports[0]; 93 94 cros_ec_cec_received_message(port, cec_message, len); 95} 96 97static void cros_ec_cec_read_message(struct cros_ec_cec_port *port) 98{ 99 struct cros_ec_device *cros_ec = port->cros_ec_cec->cros_ec; 100 struct ec_params_cec_read params = { 101 .port = port->port_num, 102 }; 103 struct ec_response_cec_read response; 104 int ret; 105 106 ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_READ_MSG, ¶ms, 107 sizeof(params), &response, sizeof(response)); 108 if (ret < 0) { 109 dev_err(cros_ec->dev, 110 "error reading CEC message on EC: %d\n", ret); 111 return; 112 } 113 114 cros_ec_cec_received_message(port, response.msg, response.msg_len); 115} 116 117static void handle_cec_event(struct cros_ec_cec *cros_ec_cec) 118{ 119 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 120 uint32_t cec_events = cros_ec->event_data.data.cec_events; 121 uint32_t port_num = EC_MKBP_EVENT_CEC_GET_PORT(cec_events); 122 uint32_t events = EC_MKBP_EVENT_CEC_GET_EVENTS(cec_events); 123 struct cros_ec_cec_port *port; 124 125 if (port_num >= cros_ec_cec->num_ports) { 126 dev_err(cros_ec->dev, 127 "received CEC event for invalid port %d\n", port_num); 128 return; 129 } 130 port = cros_ec_cec->ports[port_num]; 131 132 if (events & EC_MKBP_CEC_SEND_OK) 133 cec_transmit_attempt_done(port->adap, CEC_TX_STATUS_OK); 134 135 /* FW takes care of all retries, tell core to avoid more retries */ 136 if (events & EC_MKBP_CEC_SEND_FAILED) 137 cec_transmit_attempt_done(port->adap, 138 CEC_TX_STATUS_MAX_RETRIES | 139 CEC_TX_STATUS_NACK); 140 141 if (events & EC_MKBP_CEC_HAVE_DATA) 142 cros_ec_cec_read_message(port); 143} 144 145static int cros_ec_cec_event(struct notifier_block *nb, 146 unsigned long queued_during_suspend, 147 void *_notify) 148{ 149 struct cros_ec_cec *cros_ec_cec; 150 struct cros_ec_device *cros_ec; 151 152 cros_ec_cec = container_of(nb, struct cros_ec_cec, notifier); 153 cros_ec = cros_ec_cec->cros_ec; 154 155 if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_EVENT) { 156 handle_cec_event(cros_ec_cec); 157 return NOTIFY_OK; 158 } 159 160 if (cros_ec->event_data.event_type == EC_MKBP_EVENT_CEC_MESSAGE) { 161 handle_cec_message(cros_ec_cec); 162 return NOTIFY_OK; 163 } 164 165 return NOTIFY_DONE; 166} 167 168static int cros_ec_cec_set_log_addr(struct cec_adapter *adap, u8 logical_addr) 169{ 170 struct cros_ec_cec_port *port = adap->priv; 171 struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec; 172 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 173 struct ec_params_cec_set params = { 174 .cmd = CEC_CMD_LOGICAL_ADDRESS, 175 .port = port->port_num, 176 .val = logical_addr, 177 }; 178 int ret; 179 180 ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_SET, ¶ms, sizeof(params), 181 NULL, 0); 182 if (ret < 0) { 183 dev_err(cros_ec->dev, 184 "error setting CEC logical address on EC: %d\n", ret); 185 return ret; 186 } 187 188 return 0; 189} 190 191static int cros_ec_cec_transmit(struct cec_adapter *adap, u8 attempts, 192 u32 signal_free_time, struct cec_msg *cec_msg) 193{ 194 struct cros_ec_cec_port *port = adap->priv; 195 struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec; 196 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 197 struct ec_params_cec_write params; 198 struct ec_params_cec_write_v1 params_v1; 199 int ret; 200 201 if (cros_ec_cec->write_cmd_version == 0) { 202 memcpy(params.msg, cec_msg->msg, cec_msg->len); 203 ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_WRITE_MSG, ¶ms, 204 cec_msg->len, NULL, 0); 205 } else { 206 params_v1.port = port->port_num; 207 params_v1.msg_len = cec_msg->len; 208 memcpy(params_v1.msg, cec_msg->msg, cec_msg->len); 209 ret = cros_ec_cmd(cros_ec, cros_ec_cec->write_cmd_version, 210 EC_CMD_CEC_WRITE_MSG, ¶ms_v1, 211 sizeof(params_v1), NULL, 0); 212 } 213 214 if (ret < 0) { 215 dev_err(cros_ec->dev, 216 "error writing CEC msg on EC: %d\n", ret); 217 return ret; 218 } 219 220 return 0; 221} 222 223static int cros_ec_cec_adap_enable(struct cec_adapter *adap, bool enable) 224{ 225 struct cros_ec_cec_port *port = adap->priv; 226 struct cros_ec_cec *cros_ec_cec = port->cros_ec_cec; 227 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 228 struct ec_params_cec_set params = { 229 .cmd = CEC_CMD_ENABLE, 230 .port = port->port_num, 231 .val = enable, 232 }; 233 int ret; 234 235 ret = cros_ec_cmd(cros_ec, 0, EC_CMD_CEC_SET, ¶ms, sizeof(params), 236 NULL, 0); 237 if (ret < 0) { 238 dev_err(cros_ec->dev, 239 "error %sabling CEC on EC: %d\n", 240 (enable ? "en" : "dis"), ret); 241 return ret; 242 } 243 244 return 0; 245} 246 247static const struct cec_adap_ops cros_ec_cec_ops = { 248 .adap_enable = cros_ec_cec_adap_enable, 249 .adap_log_addr = cros_ec_cec_set_log_addr, 250 .adap_transmit = cros_ec_cec_transmit, 251}; 252 253#ifdef CONFIG_PM_SLEEP 254static int cros_ec_cec_suspend(struct device *dev) 255{ 256 struct platform_device *pdev = to_platform_device(dev); 257 struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev); 258 259 if (device_may_wakeup(dev)) 260 enable_irq_wake(cros_ec_cec->cros_ec->irq); 261 262 return 0; 263} 264 265static int cros_ec_cec_resume(struct device *dev) 266{ 267 struct platform_device *pdev = to_platform_device(dev); 268 struct cros_ec_cec *cros_ec_cec = dev_get_drvdata(&pdev->dev); 269 270 if (device_may_wakeup(dev)) 271 disable_irq_wake(cros_ec_cec->cros_ec->irq); 272 273 return 0; 274} 275#endif 276 277static SIMPLE_DEV_PM_OPS(cros_ec_cec_pm_ops, 278 cros_ec_cec_suspend, cros_ec_cec_resume); 279 280#if IS_ENABLED(CONFIG_PCI) && IS_ENABLED(CONFIG_DMI) 281 282/* 283 * Specify the DRM device name handling the HDMI output and the HDMI connector 284 * corresponding to each CEC port. The order of connectors must match the order 285 * in the EC (first connector is EC port 0, ...), and the number of connectors 286 * must match the number of ports in the EC (which can be queried using the 287 * EC_CMD_CEC_PORT_COUNT host command). 288 */ 289 290struct cec_dmi_match { 291 const char *sys_vendor; 292 const char *product_name; 293 const char *devname; 294 const char *const *conns; 295}; 296 297static const char *const port_b_conns[] = { "Port B", NULL }; 298static const char *const port_db_conns[] = { "Port D", "Port B", NULL }; 299static const char *const port_ba_conns[] = { "Port B", "Port A", NULL }; 300static const char *const port_d_conns[] = { "Port D", NULL }; 301 302static const struct cec_dmi_match cec_dmi_match_table[] = { 303 /* Google Fizz */ 304 { "Google", "Fizz", "0000:00:02.0", port_b_conns }, 305 /* Google Brask */ 306 { "Google", "Brask", "0000:00:02.0", port_b_conns }, 307 /* Google Moli */ 308 { "Google", "Moli", "0000:00:02.0", port_b_conns }, 309 /* Google Kinox */ 310 { "Google", "Kinox", "0000:00:02.0", port_b_conns }, 311 /* Google Kuldax */ 312 { "Google", "Kuldax", "0000:00:02.0", port_b_conns }, 313 /* Google Aurash */ 314 { "Google", "Aurash", "0000:00:02.0", port_b_conns }, 315 /* Google Gladios */ 316 { "Google", "Gladios", "0000:00:02.0", port_b_conns }, 317 /* Google Lisbon */ 318 { "Google", "Lisbon", "0000:00:02.0", port_b_conns }, 319 /* Google Dibbi */ 320 { "Google", "Dibbi", "0000:00:02.0", port_db_conns }, 321 /* Google Constitution */ 322 { "Google", "Constitution", "0000:00:02.0", port_ba_conns }, 323 /* Google Boxy */ 324 { "Google", "Boxy", "0000:00:02.0", port_d_conns }, 325 /* Google Taranza */ 326 { "Google", "Taranza", "0000:00:02.0", port_db_conns }, 327 /* Google Dexi */ 328 { "Google", "Dexi", "0000:00:02.0", port_db_conns }, 329 /* Google Dita */ 330 { "Google", "Dita", "0000:00:02.0", port_db_conns }, 331}; 332 333static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev, 334 const char * const **conns) 335{ 336 int i; 337 338 for (i = 0 ; i < ARRAY_SIZE(cec_dmi_match_table) ; ++i) { 339 const struct cec_dmi_match *m = &cec_dmi_match_table[i]; 340 341 if (dmi_match(DMI_SYS_VENDOR, m->sys_vendor) && 342 dmi_match(DMI_PRODUCT_NAME, m->product_name)) { 343 struct device *d; 344 345 /* Find the device, bail out if not yet registered */ 346 d = bus_find_device_by_name(&pci_bus_type, NULL, 347 m->devname); 348 if (!d) 349 return ERR_PTR(-EPROBE_DEFER); 350 put_device(d); 351 *conns = m->conns; 352 return d; 353 } 354 } 355 356 /* Hardware support must be added in the cec_dmi_match_table */ 357 dev_warn(dev, "CEC notifier not configured for this hardware\n"); 358 359 return ERR_PTR(-ENODEV); 360} 361 362#else 363 364static struct device *cros_ec_cec_find_hdmi_dev(struct device *dev, 365 const char * const **conns) 366{ 367 return ERR_PTR(-ENODEV); 368} 369 370#endif 371 372static int cros_ec_cec_get_num_ports(struct cros_ec_cec *cros_ec_cec) 373{ 374 struct ec_response_cec_port_count response; 375 int ret; 376 377 ret = cros_ec_cmd(cros_ec_cec->cros_ec, 0, EC_CMD_CEC_PORT_COUNT, NULL, 378 0, &response, sizeof(response)); 379 if (ret < 0) { 380 /* 381 * Old EC firmware only supports one port and does not support 382 * the port count command, so fall back to assuming one port. 383 */ 384 cros_ec_cec->num_ports = 1; 385 return 0; 386 } 387 388 if (response.port_count == 0) { 389 dev_err(cros_ec_cec->cros_ec->dev, 390 "EC reports 0 CEC ports\n"); 391 return -ENODEV; 392 } 393 394 if (response.port_count > EC_CEC_MAX_PORTS) { 395 dev_err(cros_ec_cec->cros_ec->dev, 396 "EC reports too many ports: %d\n", response.port_count); 397 return -EINVAL; 398 } 399 400 cros_ec_cec->num_ports = response.port_count; 401 return 0; 402} 403 404static int cros_ec_cec_get_write_cmd_version(struct cros_ec_cec *cros_ec_cec) 405{ 406 struct cros_ec_device *cros_ec = cros_ec_cec->cros_ec; 407 struct ec_params_get_cmd_versions_v1 params = { 408 .cmd = EC_CMD_CEC_WRITE_MSG, 409 }; 410 struct ec_response_get_cmd_versions response; 411 int ret; 412 413 ret = cros_ec_cmd(cros_ec, 1, EC_CMD_GET_CMD_VERSIONS, ¶ms, 414 sizeof(params), &response, sizeof(response)); 415 if (ret < 0) { 416 dev_err(cros_ec->dev, 417 "error getting CEC write command version: %d\n", ret); 418 return ret; 419 } 420 421 if (response.version_mask & EC_VER_MASK(1)) { 422 cros_ec_cec->write_cmd_version = 1; 423 } else { 424 if (cros_ec_cec->num_ports != 1) { 425 dev_err(cros_ec->dev, 426 "v0 write command only supports 1 port, %d reported\n", 427 cros_ec_cec->num_ports); 428 return -EINVAL; 429 } 430 cros_ec_cec->write_cmd_version = 0; 431 } 432 433 return 0; 434} 435 436static int cros_ec_cec_init_port(struct device *dev, 437 struct cros_ec_cec *cros_ec_cec, 438 int port_num, struct device *hdmi_dev, 439 const char * const *conns) 440{ 441 struct cros_ec_cec_port *port; 442 int ret; 443 444 port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); 445 if (!port) 446 return -ENOMEM; 447 448 port->cros_ec_cec = cros_ec_cec; 449 port->port_num = port_num; 450 451 port->adap = cec_allocate_adapter(&cros_ec_cec_ops, port, DRV_NAME, 452 CEC_CAP_DEFAULTS | 453 CEC_CAP_CONNECTOR_INFO, 1); 454 if (IS_ERR(port->adap)) 455 return PTR_ERR(port->adap); 456 457 if (!conns[port_num]) { 458 dev_err(dev, "no conn for port %d\n", port_num); 459 ret = -ENODEV; 460 goto out_probe_adapter; 461 } 462 463 port->notify = cec_notifier_cec_adap_register(hdmi_dev, conns[port_num], 464 port->adap); 465 if (!port->notify) { 466 ret = -ENOMEM; 467 goto out_probe_adapter; 468 } 469 470 ret = cec_register_adapter(port->adap, dev); 471 if (ret < 0) 472 goto out_probe_notify; 473 474 cros_ec_cec->ports[port_num] = port; 475 476 return 0; 477 478out_probe_notify: 479 cec_notifier_cec_adap_unregister(port->notify, port->adap); 480out_probe_adapter: 481 cec_delete_adapter(port->adap); 482 return ret; 483} 484 485static int cros_ec_cec_probe(struct platform_device *pdev) 486{ 487 struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent); 488 struct cros_ec_device *cros_ec = ec_dev->ec_dev; 489 struct cros_ec_cec *cros_ec_cec; 490 struct cros_ec_cec_port *port; 491 struct device *hdmi_dev; 492 const char * const *conns = NULL; 493 int ret; 494 495 hdmi_dev = cros_ec_cec_find_hdmi_dev(&pdev->dev, &conns); 496 if (IS_ERR(hdmi_dev)) 497 return PTR_ERR(hdmi_dev); 498 499 cros_ec_cec = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_cec), 500 GFP_KERNEL); 501 if (!cros_ec_cec) 502 return -ENOMEM; 503 504 platform_set_drvdata(pdev, cros_ec_cec); 505 cros_ec_cec->cros_ec = cros_ec; 506 507 device_init_wakeup(&pdev->dev, 1); 508 509 ret = cros_ec_cec_get_num_ports(cros_ec_cec); 510 if (ret) 511 return ret; 512 513 ret = cros_ec_cec_get_write_cmd_version(cros_ec_cec); 514 if (ret) 515 return ret; 516 517 for (int i = 0; i < cros_ec_cec->num_ports; i++) { 518 ret = cros_ec_cec_init_port(&pdev->dev, cros_ec_cec, i, 519 hdmi_dev, conns); 520 if (ret) 521 goto unregister_ports; 522 } 523 524 /* Get CEC events from the EC. */ 525 cros_ec_cec->notifier.notifier_call = cros_ec_cec_event; 526 ret = blocking_notifier_chain_register(&cros_ec->event_notifier, 527 &cros_ec_cec->notifier); 528 if (ret) { 529 dev_err(&pdev->dev, "failed to register notifier\n"); 530 goto unregister_ports; 531 } 532 533 return 0; 534 535unregister_ports: 536 /* 537 * Unregister any adapters which have been registered. We don't add the 538 * port to the array until the adapter has been registered successfully, 539 * so any non-NULL ports must have been registered. 540 */ 541 for (int i = 0; i < cros_ec_cec->num_ports; i++) { 542 port = cros_ec_cec->ports[i]; 543 if (!port) 544 break; 545 cec_notifier_cec_adap_unregister(port->notify, port->adap); 546 cec_unregister_adapter(port->adap); 547 } 548 return ret; 549} 550 551static void cros_ec_cec_remove(struct platform_device *pdev) 552{ 553 struct cros_ec_cec *cros_ec_cec = platform_get_drvdata(pdev); 554 struct device *dev = &pdev->dev; 555 struct cros_ec_cec_port *port; 556 int ret; 557 558 /* 559 * blocking_notifier_chain_unregister() only fails if the notifier isn't 560 * in the list. We know it was added to it by .probe(), so there should 561 * be no need for error checking. Be cautious and still check. 562 */ 563 ret = blocking_notifier_chain_unregister( 564 &cros_ec_cec->cros_ec->event_notifier, 565 &cros_ec_cec->notifier); 566 if (ret) 567 dev_err(dev, "failed to unregister notifier\n"); 568 569 for (int i = 0; i < cros_ec_cec->num_ports; i++) { 570 port = cros_ec_cec->ports[i]; 571 cec_notifier_cec_adap_unregister(port->notify, port->adap); 572 cec_unregister_adapter(port->adap); 573 } 574} 575 576static struct platform_driver cros_ec_cec_driver = { 577 .probe = cros_ec_cec_probe, 578 .remove_new = cros_ec_cec_remove, 579 .driver = { 580 .name = DRV_NAME, 581 .pm = &cros_ec_cec_pm_ops, 582 }, 583}; 584 585module_platform_driver(cros_ec_cec_driver); 586 587MODULE_DESCRIPTION("CEC driver for ChromeOS ECs"); 588MODULE_AUTHOR("Neil Armstrong <narmstrong@baylibre.com>"); 589MODULE_LICENSE("GPL"); 590MODULE_ALIAS("platform:" DRV_NAME); 591