// SPDX-License-Identifier: GPL-2.0-only /* * Copyright 2021-2024 Cisco Systems, Inc. and/or its affiliates. All rights reserved. */ /* * Currently this driver does not fully support the serial port of the * Extron, only the USB port is fully supported. * * Issues specific to using the serial port instead of the USB since the * serial port doesn't detect if the device is powered off: * * - Some periodic ping mechanism is needed to detect when the Extron is * powered off and when it is powered on again. * - What to do when it is powered off and the driver is modprobed? Keep * trying to contact the Extron indefinitely? */ #include #include #include #include #include #include #include #include #include #include "extron-da-hd-4k-plus.h" MODULE_AUTHOR("Hans Verkuil "); MODULE_DESCRIPTION("Extron DA HD 4K PLUS HDMI CEC driver"); MODULE_LICENSE("GPL"); static int debug; module_param(debug, int, 0644); MODULE_PARM_DESC(debug, "debug level (0-1)"); static unsigned int vendor_id; module_param(vendor_id, uint, 0444); MODULE_PARM_DESC(vendor_id, "CEC Vendor ID"); static char manufacturer_name[4]; module_param_string(manufacturer_name, manufacturer_name, sizeof(manufacturer_name), 0644); MODULE_PARM_DESC(manufacturer_name, "EDID Vendor String (3 uppercase characters)"); static bool hpd_never_low; module_param(hpd_never_low, bool, 0644); MODULE_PARM_DESC(hpd_never_low, "Input HPD will never go low (1), or go low if all output HPDs are low (0, default)"); #define EXTRON_TIMEOUT_SECS 6 static const u8 hdmi_edid[256] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78, 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0x20, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c, 0x45, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18, 0x87, 0x11, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x68, 0x64, 0x6d, 0x69, 0x2d, 0x31, 0x30, 0x38, 0x30, 0x70, 0x36, 0x30, 0x0a, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x73, 0x65, 0x72, 0x69, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x95, 0x02, 0x03, 0x1b, 0xf1, 0x42, 0x10, 0x01, 0x23, 0x09, 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x68, 0x03, 0x0c, 0x00, 0x10, 0x00, 0x00, 0x21, 0x01, 0xe2, 0x00, 0xca, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x89, }; static const u8 hdmi_edid_4k_300[256] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78, 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0x20, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c, 0x45, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18, 0x87, 0x3c, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x68, 0x64, 0x6d, 0x69, 0x2d, 0x34, 0x6b, 0x2d, 0x36, 0x30, 0x30, 0x0a, 0x20, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x73, 0x65, 0x72, 0x69, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x87, 0x02, 0x03, 0x1f, 0xf1, 0x43, 0x10, 0x5f, 0x01, 0x23, 0x09, 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6b, 0x03, 0x0c, 0x00, 0x10, 0x00, 0x00, 0x3c, 0x21, 0x00, 0x20, 0x01, 0xe2, 0x00, 0xca, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, }; static const u8 hdmi_edid_4k_600[256] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x31, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x03, 0x80, 0x60, 0x36, 0x78, 0x0f, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0x20, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0xe8, 0x00, 0x30, 0xf2, 0x70, 0x5a, 0x80, 0xb0, 0x58, 0x8a, 0x00, 0xc0, 0x1c, 0x32, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18, 0x55, 0x18, 0x87, 0x3c, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x68, 0x64, 0x6d, 0x69, 0x2d, 0x34, 0x6b, 0x2d, 0x36, 0x30, 0x30, 0x0a, 0x20, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x73, 0x65, 0x72, 0x69, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0x4c, 0x02, 0x03, 0x28, 0xf1, 0x44, 0x61, 0x5f, 0x10, 0x01, 0x23, 0x09, 0x07, 0x07, 0x83, 0x01, 0x00, 0x00, 0x6b, 0x03, 0x0c, 0x00, 0x10, 0x00, 0x00, 0x3c, 0x21, 0x00, 0x20, 0x01, 0x67, 0xd8, 0x5d, 0xc4, 0x01, 0x78, 0x00, 0x00, 0xe2, 0x00, 0xca, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, }; static int extron_send_byte(struct serio *serio, char byte) { int err, i; for (i = 0; i < 100; i++) { err = serio_write(serio, byte); if (!err) break; usleep_range(80, 120); } if (err) dev_warn(&serio->dev, "unable to write byte after 100 attempts\n"); return err ? -EIO : 0; } static int extron_send_len(struct serio *serio, const char *command, const unsigned char *bin, unsigned int len) { int err = 0; for (; !err && *command; command++) err = extron_send_byte(serio, *command); if (!err) err = extron_send_byte(serio, '\r'); if (bin) for (; !err && len; len--) err = extron_send_byte(serio, *bin++); return err; } static int extron_send_and_wait_len(struct extron *extron, struct extron_port *port, const char *cmd, const unsigned char *bin, unsigned int len, const char *response) { int timeout = EXTRON_TIMEOUT_SECS * HZ; int err; if (debug) { if (response) dev_info(extron->dev, "transmit %s (response: %s)\n", cmd, response); else dev_info(extron->dev, "transmit %s\n", cmd); } mutex_lock(&extron->serio_lock); if (port) { init_completion(&port->cmd_done); port->cmd_error = 0; port->response = response; } else { init_completion(&extron->cmd_done); extron->cmd_error = 0; extron->response = response; } err = extron_send_len(extron->serio, cmd, bin, len); if (!err && response && !wait_for_completion_timeout(port ? &port->cmd_done : &extron->cmd_done, timeout)) { dev_info(extron->dev, "transmit %s failed with %s (expected: %s)\n", cmd, extron->reply, response); err = -ETIMEDOUT; } if (!err && response && (port ? port->cmd_error : extron->cmd_error)) { dev_info(extron->dev, "transmit %s failed with E%02u (expected: %s)\n", cmd, port ? port->cmd_error : extron->cmd_error, response); if (port) port->cmd_error = 0; else extron->cmd_error = 0; err = -EPROTO; } if (port) port->response = NULL; else extron->response = NULL; mutex_unlock(&extron->serio_lock); return err; } static int extron_send_and_wait(struct extron *extron, struct extron_port *port, const char *cmd, const char *response) { return extron_send_and_wait_len(extron, port, cmd, NULL, 0, response); } static void extron_parse_edid(struct extron_port *port) { const u8 *edid = port->edid; unsigned int i, end; u8 d; port->has_4kp30 = false; port->has_4kp60 = false; port->has_qy = false; port->has_qs = false; /* Store Established Timings 1 and 2 */ port->est_i = edid[0x23]; port->est_ii = edid[0x24]; // Check DTDs in base block for (i = 0; i < 4; i++) { const u8 *dtd = edid + 0x36 + i * 18; unsigned int w, h; unsigned int mhz; u64 pclk; if (!dtd[0] && !dtd[1]) continue; w = dtd[2] + ((dtd[4] & 0xf0) << 4); h = dtd[5] + ((dtd[7] & 0xf0) << 4); if (w != 3840 || h != 2160) continue; w += dtd[3] + ((dtd[4] & 0x0f) << 8); h += dtd[6] + ((dtd[7] & 0x0f) << 8); pclk = dtd[0] + (dtd[1] << 8); pclk *= 100000; mhz = div_u64(pclk, w * h); if (mhz >= 297) port->has_4kp30 = true; if (mhz >= 594) port->has_4kp60 = true; } if (port->edid_blocks == 1) return; edid += 128; /* Return if not a CTA-861 extension block */ if (edid[0] != 0x02 || edid[1] != 0x03) return; /* search Video Data Block (tag 2) */ d = edid[2] & 0x7f; /* Check if there are Data Blocks */ if (d <= 4) return; i = 4; end = d; do { u8 tag = edid[i] >> 5; u8 len = edid[i] & 0x1f; /* Avoid buffer overrun in case the EDID is malformed */ if (i + len + 1 > 0x7f) return; switch (tag) { case 2: /* Video Data Block */ /* Search for VIC 97 */ if (memchr(edid + i + 1, 97, len)) port->has_4kp60 = true; /* Search for VIC 95 */ if (memchr(edid + i + 1, 95, len)) port->has_4kp30 = true; break; case 7: /* Use Extended Tag */ switch (edid[i + 1]) { case 0: /* Video Capability Data Block */ if (edid[i + 2] & 0x80) port->has_qy = true; if (edid[i + 2] & 0x40) port->has_qs = true; break; } break; } i += len + 1; } while (i < end); } static int get_edid_tag_location(const u8 *edid, unsigned int size, u8 want_tag, u8 ext_tag) { unsigned int offset = 128; int i, end; u8 d; edid += offset; /* Return if not a CTA-861 extension block */ if (size < 256 || edid[0] != 0x02 || edid[1] != 0x03) return -ENOENT; /* search tag */ d = edid[0x02] & 0x7f; if (d <= 4) return -ENOENT; i = 0x04; end = 0x00 + d; do { unsigned char tag = edid[i] >> 5; unsigned char len = edid[i] & 0x1f; if (tag != want_tag || i + len > end) { i += len + 1; continue; } if (tag < 7 || (len >= 1 && edid[i + 1] == ext_tag)) return offset + i; i += len + 1; } while (i < end); return -ENOENT; } static void extron_edid_crc(u8 *edid) { u8 sum = 0; int offset; /* Update CRC */ for (offset = 0; offset < 127; offset++) sum += edid[offset]; edid[127] = 256 - sum; } /* * Fill in EDID string. As per VESA EDID-1.3, strings are at most 13 chars * long. If shorter then add a 0x0a character after the string and pad the * remainder with spaces. */ static void extron_set_edid_string(u8 *start, const char *s) { const unsigned int max_len = 13; int len = strlen(s); memset(start, ' ', max_len); if (len > max_len) len = max_len; memcpy(start, s, len); if (len < max_len) start[len] = 0x0a; } static void extron_update_edid(struct extron_port *port, unsigned int blocks) { int offset; u8 c1, c2; c1 = ((manufacturer_name[0] - '@') << 2) | (((manufacturer_name[1] - '@') >> 3) & 0x03); c2 = (((manufacturer_name[1] - '@') & 0x07) << 5) | ((manufacturer_name[2] - '@') & 0x1f); port->edid_tmp[8] = c1; port->edid_tmp[9] = c2; /* Set Established Timings, but always enable VGA */ port->edid_tmp[0x23] = port->est_i | 0x20; port->edid_tmp[0x24] = port->est_ii; /* Set the Monitor Name to the unit name */ extron_set_edid_string(port->edid_tmp + 0x5f, port->extron->unit_name); /* Set the ASCII String to the CEC adapter name */ extron_set_edid_string(port->edid_tmp + 0x71, port->adap->name); extron_edid_crc(port->edid_tmp); /* Find Video Capability Data Block */ offset = get_edid_tag_location(port->edid_tmp, blocks * 128, 7, 0); if (offset > 0) { port->edid_tmp[offset + 2] &= ~0xc0; if (port->has_qy) port->edid_tmp[offset + 2] |= 0x80; if (port->has_qs) port->edid_tmp[offset + 2] |= 0x40; } extron_edid_crc(port->edid_tmp + 128); } static int extron_write_edid(struct extron_port *port, const u8 *edid, unsigned int blocks) { struct extron *extron = port->extron; u16 phys_addr = CEC_PHYS_ADDR_INVALID; int ret; if (cec_get_edid_spa_location(edid, blocks * 128)) phys_addr = 0; if (mutex_lock_interruptible(&extron->edid_lock)) return -EINTR; memcpy(port->edid_tmp, edid, blocks * 128); if (manufacturer_name[0]) extron_update_edid(port, blocks); ret = extron_send_and_wait_len(port->extron, port, "W+UF256,in.bin", port->edid_tmp, sizeof(port->edid_tmp), "Upl"); if (ret) goto unlock; ret = extron_send_and_wait(port->extron, port, "WI1,in.binEDID", "EdidI01"); if (ret) goto unlock; port->edid_blocks = blocks; memcpy(port->edid, port->edid_tmp, blocks * 128); port->read_edid = true; mutex_unlock(&extron->edid_lock); cec_s_phys_addr(port->adap, phys_addr, false); return 0; unlock: mutex_unlock(&extron->edid_lock); return ret; } static void update_edid_work(struct work_struct *w) { struct extron *extron = container_of(w, struct extron, work_update_edid.work); struct extron_port *in = extron->ports[extron->num_out_ports]; struct extron_port *p; bool has_edid = false; bool has_4kp30 = true; bool has_4kp60 = true; bool has_qy = true; bool has_qs = true; u8 est_i = 0xff; u8 est_ii = 0xff; unsigned int out; for (out = 0; has_4kp60 && out < extron->num_out_ports; out++) { p = extron->ports[out]; if (p->read_edid) { has_4kp60 = p->has_4kp60; est_i &= p->est_i; est_ii &= p->est_ii; has_edid = true; } } for (out = 0; has_4kp30 && out < extron->num_out_ports; out++) if (extron->ports[out]->read_edid) has_4kp30 = extron->ports[out]->has_4kp30; for (out = 0; has_qy && out < extron->num_out_ports; out++) if (extron->ports[out]->read_edid) has_qy = extron->ports[out]->has_qy; for (out = 0; has_qs && out < extron->num_out_ports; out++) if (extron->ports[out]->read_edid) has_qs = extron->ports[out]->has_qs; /* exit if no output port had an EDID */ if (!has_edid) return; /* exit if the input EDID properties remained unchanged */ if (has_4kp60 == in->has_4kp60 && has_4kp30 == in->has_4kp30 && has_qy == in->has_qy && has_qs == in->has_qs && est_i == in->est_i && est_ii == in->est_ii) return; in->has_4kp60 = has_4kp60; in->has_4kp30 = has_4kp30; in->has_qy = has_qy; in->has_qs = has_qs; in->est_i = est_i; in->est_ii = est_ii; extron_write_edid(extron->ports[extron->num_out_ports], has_4kp60 ? hdmi_edid_4k_600 : (has_4kp30 ? hdmi_edid_4k_300 : hdmi_edid), 2); } static void extron_read_edid(struct extron_port *port) { struct extron *extron = port->extron; char cmd[10], reply[10]; unsigned int idx; idx = port->port.port + (port->is_input ? 0 : extron->num_in_ports); snprintf(cmd, sizeof(cmd), "WR%uEDID", idx); snprintf(reply, sizeof(reply), "EdidR%u", idx); if (mutex_lock_interruptible(&extron->edid_lock)) return; if (port->read_edid) goto unlock; extron->edid_bytes_read = 0; extron->edid_port = port; port->edid_blocks = 0; if (!port->has_edid) goto no_edid; extron->edid_reading = true; if (!extron_send_and_wait(extron, port, cmd, reply)) wait_for_completion_killable_timeout(&extron->edid_completion, msecs_to_jiffies(1000)); if (port->edid_blocks) { extron_parse_edid(port); port->read_edid = true; if (!port->is_input) v4l2_ctrl_s_ctrl(port->ctrl_tx_edid_present, 1); } no_edid: extron->edid_reading = false; unlock: mutex_unlock(&extron->edid_lock); cancel_delayed_work_sync(&extron->work_update_edid); if (manufacturer_name[0]) schedule_delayed_work(&extron->work_update_edid, msecs_to_jiffies(1000)); } static void extron_irq_work_handler(struct work_struct *work) { struct extron_port *port = container_of(work, struct extron_port, irq_work); struct extron *extron = port->extron; unsigned long flags; bool update_pa; u16 pa; bool update_has_signal; bool has_signal; bool update_has_edid; bool has_edid; u32 status; spin_lock_irqsave(&port->msg_lock, flags); while (port->rx_msg_num) { spin_unlock_irqrestore(&port->msg_lock, flags); cec_received_msg(port->adap, &port->rx_msg[port->rx_msg_cur_idx]); spin_lock_irqsave(&port->msg_lock, flags); if (port->rx_msg_num) port->rx_msg_num--; port->rx_msg_cur_idx = (port->rx_msg_cur_idx + 1) % NUM_MSGS; } update_pa = port->update_phys_addr; pa = port->phys_addr; port->update_phys_addr = false; update_has_signal = port->update_has_signal; has_signal = port->has_signal; port->update_has_signal = false; update_has_edid = port->update_has_edid; has_edid = port->has_edid; port->update_has_edid = false; status = port->tx_done_status; port->tx_done_status = 0; spin_unlock_irqrestore(&port->msg_lock, flags); if (status) cec_transmit_done(port->adap, status, 0, 0, 0, 0); if (update_has_signal && port->is_input) v4l2_ctrl_s_ctrl(port->ctrl_rx_power_present, has_signal); if (update_has_edid && !port->is_input) { v4l2_ctrl_s_ctrl(port->ctrl_tx_hotplug, port->has_edid); if (port->has_edid) { port->port.found_sink = true; port->port.lost_sink_ts = ktime_set(0, 0); } else { port->port.lost_sink_ts = ktime_get(); } if (!has_edid) { port->edid_blocks = 0; port->read_edid = false; if (extron->edid_reading && !has_edid && extron->edid_port == port) extron->edid_reading = false; v4l2_ctrl_s_ctrl(port->ctrl_tx_edid_present, 0); } else if (!extron->edid_reading || extron->edid_port != port) { extron_read_edid(port); } } if (update_pa) cec_s_phys_addr(port->adap, pa, false); } static void extron_process_received(struct extron_port *port, const char *data) { struct cec_msg msg = {}; unsigned int len = strlen(data); unsigned long irq_flags; unsigned int idx; if (!port || port->disconnected) return; if (len < 5 || (len - 2) % 3 || data[len - 2] != '*') goto malformed; while (*data != '*') { int v = hex2bin(&msg.msg[msg.len], data + 1, 1); if (*data != '%' || v) goto malformed; msg.len++; data += 3; } spin_lock_irqsave(&port->msg_lock, irq_flags); idx = (port->rx_msg_cur_idx + port->rx_msg_num) % NUM_MSGS; if (port->rx_msg_num == NUM_MSGS) { dev_warn(port->dev, "message queue is full, dropping %*ph\n", msg.len, msg.msg); spin_unlock_irqrestore(&port->msg_lock, irq_flags); return; } port->rx_msg_num++; port->rx_msg[idx] = msg; spin_unlock_irqrestore(&port->msg_lock, irq_flags); if (!port->disconnected) schedule_work(&port->irq_work); return; malformed: dev_info(port->extron->dev, "malformed msg received: '%s'\n", data); } static void extron_port_signal_change(struct extron_port *port, bool has_sig) { unsigned long irq_flags; bool update = false; if (!port) return; spin_lock_irqsave(&port->msg_lock, irq_flags); if (!port->update_has_signal && port->has_signal != has_sig) { port->update_has_signal = true; update = true; } port->has_signal = has_sig; spin_unlock_irqrestore(&port->msg_lock, irq_flags); if (update && !port->disconnected) schedule_work(&port->irq_work); } static void extron_process_signal_change(struct extron *extron, const char *data) { unsigned int i; extron_port_signal_change(extron->ports[extron->num_out_ports], data[0] == '1'); for (i = 0; i < extron->num_out_ports; i++) extron_port_signal_change(extron->ports[i], data[2 + 2 * i] != '0'); } static void extron_port_edid_change(struct extron_port *port, bool has_edid) { unsigned long irq_flags; bool update = false; if (!port) return; spin_lock_irqsave(&port->msg_lock, irq_flags); if (!port->update_has_edid && port->has_edid != has_edid) { port->update_has_edid = true; update = true; } port->has_edid = has_edid; spin_unlock_irqrestore(&port->msg_lock, irq_flags); if (update && !port->disconnected) schedule_work(&port->irq_work); } static void extron_process_edid_change(struct extron *extron, const char *data) { unsigned int i; /* * Do nothing if the Extron isn't ready yet. Trying to do this * while the Extron firmware is still settling will fail. */ if (!extron->is_ready) return; for (i = 0; i < extron->num_out_ports; i++) extron_port_edid_change(extron->ports[i], data[2 + 2 * i] != '0'); } static void extron_phys_addr_change(struct extron_port *port, u16 pa) { unsigned long irq_flags; bool update = false; if (!port) return; spin_lock_irqsave(&port->msg_lock, irq_flags); if (!port->update_phys_addr && port->phys_addr != pa) { update = true; port->update_phys_addr = true; } port->phys_addr = pa; spin_unlock_irqrestore(&port->msg_lock, irq_flags); if (update && !port->disconnected) schedule_work(&port->irq_work); } static void extron_process_tx_done(struct extron_port *port, char status) { unsigned long irq_flags; unsigned int tx_status; if (!port) return; switch (status) { case '0': tx_status = CEC_TX_STATUS_NACK | CEC_TX_STATUS_MAX_RETRIES; break; case '1': tx_status = CEC_TX_STATUS_OK; break; default: tx_status = CEC_TX_STATUS_ERROR; break; } spin_lock_irqsave(&port->msg_lock, irq_flags); port->tx_done_status = tx_status; spin_unlock_irqrestore(&port->msg_lock, irq_flags); if (!port->disconnected) schedule_work(&port->irq_work); } static void extron_add_edid(struct extron_port *port, const char *hex) { struct extron *extron = port ? port->extron : NULL; if (!port || port != extron->edid_port) return; while (extron->edid_bytes_read < sizeof(port->edid) && *hex) { int err = hex2bin(&port->edid[extron->edid_bytes_read], hex, 1); if (err) { extron->edid_reading = false; complete(&extron->edid_completion); break; } extron->edid_bytes_read++; hex += 2; } if (extron->edid_bytes_read == 128 && port->edid[126] == 0) { /* There are no extension blocks, we're done */ port->edid_blocks = 1; extron->edid_reading = false; complete(&extron->edid_completion); } if (extron->edid_bytes_read < sizeof(port->edid)) return; if (!*hex) port->edid_blocks = 2; extron->edid_reading = false; complete(&extron->edid_completion); } static irqreturn_t extron_interrupt(struct serio *serio, unsigned char data, unsigned int flags) { struct extron *extron = serio_get_drvdata(serio); struct extron_port *port = NULL; bool found_response; unsigned int p; if (data == '\r' || data == '\n') { if (extron->idx == 0) return IRQ_HANDLED; memcpy(extron->data, extron->buf, extron->idx); extron->len = extron->idx; extron->data[extron->len] = 0; if (debug) dev_info(extron->dev, "received %s\n", extron->data); extron->idx = 0; if (!memcmp(extron->data, "Sig", 3) && extron->data[4] == '*') { extron_process_signal_change(extron, extron->data + 3); } else if (!memcmp(extron->data, "Hdcp", 4) && extron->data[5] == '*') { extron_process_edid_change(extron, extron->data + 4); } else if (!memcmp(extron->data, "DcecI", 5) && extron->data[5] >= '1' && extron->data[5] < '1' + extron->num_in_ports) { unsigned int p = extron->data[5] - '1'; p += extron->num_out_ports; extron_process_tx_done(extron->ports[p], extron->data[extron->len - 1]); } else if (!memcmp(extron->data, "Ceci", 4) && extron->data[4] >= '1' && extron->data[4] < '1' + extron->num_in_ports && extron->data[5] == '*') { unsigned int p = extron->data[4] - '1'; p += extron->num_out_ports; extron_process_received(extron->ports[p], extron->data + 6); } else if (!memcmp(extron->data, "DcecO", 5) && extron->data[5] >= '1' && extron->data[5] < '1' + extron->num_out_ports) { unsigned int p = extron->data[5] - '1'; extron_process_tx_done(extron->ports[p], extron->data[extron->len - 1]); } else if (!memcmp(extron->data, "Ceco", 4) && extron->data[4] >= '1' && extron->data[4] < '1' + extron->num_out_ports && extron->data[5] == '*') { unsigned int p = extron->data[4] - '1'; extron_process_received(extron->ports[p], extron->data + 6); } else if (!memcmp(extron->data, "Pceco", 5) && extron->data[5] >= '1' && extron->data[5] < '1' + extron->num_out_ports) { unsigned int p = extron->data[5] - '1'; unsigned int tmp_pa[2] = { 0xff, 0xff }; if (sscanf(extron->data + 7, "%%%02x%%%02x", &tmp_pa[0], &tmp_pa[1]) == 2) extron_phys_addr_change(extron->ports[p], tmp_pa[0] << 8 | tmp_pa[1]); } else if (!memcmp(extron->data, "Pceci", 5) && extron->data[5] >= '1' && extron->data[5] < '1' + extron->num_in_ports) { unsigned int p = extron->data[5] - '1'; unsigned int tmp_pa[2] = { 0xff, 0xff }; p += extron->num_out_ports; if (sscanf(extron->data + 7, "%%%02x%%%02x", &tmp_pa[0], &tmp_pa[1]) == 2) extron_phys_addr_change(extron->ports[p], tmp_pa[0] << 8 | tmp_pa[1]); } else if (!memcmp(extron->data, "EdidR", 5) && extron->data[5] >= '1' && extron->data[5] < '1' + extron->num_ports && extron->data[6] == '*') { unsigned int p = extron->data[5] - '1'; if (p) p--; else p = extron->num_out_ports; extron_add_edid(extron->ports[p], extron->data + 7); } else if (extron->edid_reading && extron->len == 32 && extron->edid_port) { extron_add_edid(extron->edid_port, extron->data); } found_response = false; if (extron->response && !strncmp(extron->response, extron->data, strlen(extron->response))) found_response = true; for (p = 0; !found_response && p < extron->num_ports; p++) { port = extron->ports[p]; if (port && port->response && !strncmp(port->response, extron->data, strlen(port->response))) found_response = true; } if (!found_response && extron->response && extron->data[0] == 'E' && isdigit(extron->data[1]) && isdigit(extron->data[2]) && !extron->data[3]) { extron->cmd_error = (extron->data[1] - '0') * 10 + extron->data[2] - '0'; extron->response = NULL; complete(&extron->cmd_done); } if (!found_response) return IRQ_HANDLED; memcpy(extron->reply, extron->data, extron->len); extron->reply[extron->len] = 0; if (!port) { extron->response = NULL; complete(&extron->cmd_done); } else { port->response = NULL; complete(&port->cmd_done); } return IRQ_HANDLED; } if (extron->idx >= DATA_SIZE - 1) { dev_info(extron->dev, "throwing away %d bytes of garbage\n", extron->idx); extron->idx = 0; } extron->buf[extron->idx++] = (char)data; return IRQ_HANDLED; } static int extron_cec_adap_enable(struct cec_adapter *adap, bool enable) { struct extron_port *port = cec_get_drvdata(adap); return (port->disconnected && enable) ? -ENODEV : 0; } static int extron_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr) { struct extron_port *port = cec_get_drvdata(adap); char cmd[26]; char resp[25]; u8 la = log_addr == CEC_LOG_ADDR_INVALID ? 15 : log_addr; int err; if (port->disconnected) return -ENODEV; snprintf(cmd, sizeof(cmd), "W%c%u*%uLCEC", port->direction, port->port.port, la); snprintf(resp, sizeof(resp), "Lcec%c%u*%u", port->direction, port->port.port, la); err = extron_send_and_wait(port->extron, port, cmd, resp); return log_addr != CEC_LOG_ADDR_INVALID && err ? err : 0; } static int extron_cec_adap_transmit(struct cec_adapter *adap, u8 attempts, u32 signal_free_time, struct cec_msg *msg) { struct extron_port *port = cec_get_drvdata(adap); char buf[CEC_MAX_MSG_SIZE * 3 + 1]; char cmd[CEC_MAX_MSG_SIZE * 3 + 13]; unsigned int i; if (port->disconnected) return -ENODEV; buf[0] = 0; for (i = 0; i < msg->len - 1; i++) sprintf(buf + i * 3, "%%%02X", msg->msg[i + 1]); snprintf(cmd, sizeof(cmd), "W%c%u*%u*%u*%sDCEC", port->direction, port->port.port, cec_msg_initiator(msg), cec_msg_destination(msg), buf); return extron_send_and_wait(port->extron, port, cmd, NULL); } static void extron_cec_adap_unconfigured(struct cec_adapter *adap) { struct extron_port *port = cec_get_drvdata(adap); if (port->disconnected) return; if (debug) dev_info(port->extron->dev, "unconfigured port %d (%s)\n", port->port.port, port->extron->splitter.is_standby ? "Off" : "On"); if (!port->is_input) cec_splitter_unconfigured_output(&port->port); } static void extron_cec_configured(struct cec_adapter *adap) { struct extron_port *port = cec_get_drvdata(adap); if (port->disconnected) return; if (debug) dev_info(port->extron->dev, "configured port %d (%s)\n", port->port.port, port->extron->splitter.is_standby ? "Off" : "On"); if (!port->is_input) cec_splitter_configured_output(&port->port); } static void extron_cec_adap_nb_transmit_canceled(struct cec_adapter *adap, const struct cec_msg *msg) { struct extron_port *port = cec_get_drvdata(adap); struct cec_adapter *input_adap; if (!vendor_id) return; if (port->disconnected || port->is_input) return; input_adap = port->extron->ports[port->extron->num_out_ports]->adap; cec_splitter_nb_transmit_canceled_output(&port->port, msg, input_adap); } static int extron_received(struct cec_adapter *adap, struct cec_msg *msg) { struct extron_port *port = cec_get_drvdata(adap); if (!vendor_id) return -ENOMSG; if (port->disconnected) return -ENOMSG; if (port->is_input) return cec_splitter_received_input(&port->port, msg); return cec_splitter_received_output(&port->port, msg, port->extron->ports[port->extron->num_out_ports]->adap); } #define log_printf(adap, file, fmt, arg...) \ do { \ if (file) \ seq_printf((file), fmt, ## arg); \ else \ pr_info("cec-%s: " fmt, (adap)->name, ## arg); \ } while (0) static const char * const pwr_state[] = { "on", "standby", "to on", "to standby", }; static void extron_adap_status_port(struct extron_port *port, struct seq_file *file) { struct cec_adapter *adap = port->adap; if (port->disconnected) { log_printf(adap, file, "\tport %u: disconnected\n", port->port.port); return; } if (port->is_input) log_printf(adap, file, "\tport %u: %s signal, %s edid, %s 4kp30, %s 4kp60, %sQS/%sQY, is %s\n", port->port.port, port->has_signal ? "has" : "no", port->has_edid ? "has" : "no", port->has_4kp30 ? "has" : "no", port->has_4kp60 ? "has" : "no", port->has_qs ? "" : "no ", port->has_qy ? "" : "no ", !port->port.adap->is_configured ? "not configured" : pwr_state[port->extron->splitter.is_standby]); else log_printf(adap, file, "\tport %u: %s sink, %s signal, %s edid, %s 4kp30, %s 4kp60, %sQS/%sQY, is %sactive source, is %s\n", port->port.port, port->port.found_sink ? "found" : "no", port->has_signal ? "has" : "no", port->has_edid ? "has" : "no", port->has_4kp30 ? "has" : "no", port->has_4kp60 ? "has" : "no", port->has_qs ? "" : "no ", port->has_qy ? "" : "no ", port->port.is_active_source ? "" : "not ", !port->port.adap->is_configured ? "not configured" : pwr_state[port->port.power_status & 3]); if (port->port.out_give_device_power_status_seq) log_printf(adap, file, "\tport %u: querying power status (%u, %lldms)\n", port->port.port, port->port.out_give_device_power_status_seq & ~(1 << 31), ktime_ms_delta(ktime_get(), port->port.out_give_device_power_status_ts)); if (port->port.out_request_current_latency_seq) log_printf(adap, file, "\tport %u: querying latency (%u, %lldms)\n", port->port.port, port->port.out_request_current_latency_seq & ~(1 << 31), ktime_ms_delta(ktime_get(), port->port.out_request_current_latency_ts)); } static void extron_adap_status(struct cec_adapter *adap, struct seq_file *file) { struct extron_port *port = cec_get_drvdata(adap); struct extron *extron = port->extron; unsigned int i; log_printf(adap, file, "name: %s type: %s\n", extron->unit_name, extron->unit_type); log_printf(adap, file, "model: 60-160%c-01 (1 input, %u outputs)\n", '6' + extron->num_out_ports / 2, extron->num_out_ports); log_printf(adap, file, "firmware version: %s CEC engine version: %s\n", extron->unit_fw_version, extron->unit_cec_engine_version); if (extron->hpd_never_low) log_printf(adap, file, "always keep input HPD high\n"); else log_printf(adap, file, "pull input HPD low if all output HPDs are low\n"); if (vendor_id) log_printf(adap, file, "splitter vendor ID: 0x%06x\n", vendor_id); if (manufacturer_name[0]) log_printf(adap, file, "splitter manufacturer name: %s\n", manufacturer_name); log_printf(adap, file, "splitter power status: %s\n", pwr_state[extron->splitter.is_standby]); log_printf(adap, file, "%s port: %d (%s)\n", port->is_input ? "input" : "output", port->port.port, port->name); log_printf(adap, file, "splitter input port:\n"); extron_adap_status_port(extron->ports[extron->num_out_ports], file); log_printf(adap, file, "splitter output ports:\n"); for (i = 0; i < extron->num_out_ports; i++) extron_adap_status_port(extron->ports[i], file); if (!port->has_edid || !port->read_edid) return; for (i = 0; i < port->edid_blocks * 128; i += 16) { if (i % 128 == 0) log_printf(adap, file, "\n"); log_printf(adap, file, "EDID: %*ph\n", 16, port->edid + i); } } static const struct cec_adap_ops extron_cec_adap_ops = { .adap_enable = extron_cec_adap_enable, .adap_log_addr = extron_cec_adap_log_addr, .adap_transmit = extron_cec_adap_transmit, .adap_nb_transmit_canceled = extron_cec_adap_nb_transmit_canceled, .adap_unconfigured = extron_cec_adap_unconfigured, .adap_status = extron_adap_status, .configured = extron_cec_configured, .received = extron_received, }; static int extron_querycap(struct file *file, void *priv, struct v4l2_capability *cap) { struct extron_port *port = video_drvdata(file); strscpy(cap->driver, "extron-da-hd-4k-plus-cec", sizeof(cap->driver)); strscpy(cap->card, cap->driver, sizeof(cap->card)); snprintf(cap->bus_info, sizeof(cap->bus_info), "serio:%s", port->name); return 0; } static int extron_enum_input(struct file *file, void *priv, struct v4l2_input *inp) { struct extron_port *port = video_drvdata(file); if (inp->index) return -EINVAL; inp->type = V4L2_INPUT_TYPE_CAMERA; snprintf(inp->name, sizeof(inp->name), "HDMI IN %u", port->port.port); inp->status = v4l2_ctrl_g_ctrl(port->ctrl_rx_power_present) ? 0 : V4L2_IN_ST_NO_SIGNAL; return 0; } static int extron_g_input(struct file *file, void *priv, unsigned int *i) { *i = 0; return 0; } static int extron_s_input(struct file *file, void *priv, unsigned int i) { return i ? -EINVAL : 0; } static int extron_enum_output(struct file *file, void *priv, struct v4l2_output *out) { struct extron_port *port = video_drvdata(file); if (out->index) return -EINVAL; out->type = V4L2_OUTPUT_TYPE_ANALOG; snprintf(out->name, sizeof(out->name), "HDMI OUT %u", port->port.port); return 0; } static int extron_g_output(struct file *file, void *priv, unsigned int *o) { *o = 0; return 0; } static int extron_s_output(struct file *file, void *priv, unsigned int o) { return o ? -EINVAL : 0; } static int extron_g_edid(struct file *file, void *_fh, struct v4l2_edid *edid) { struct extron_port *port = video_drvdata(file); memset(edid->reserved, 0, sizeof(edid->reserved)); if (port->disconnected) return -ENODEV; if (edid->pad) return -EINVAL; if (!port->has_edid) return -ENODATA; if (!port->read_edid) extron_read_edid(port); if (!port->read_edid) return -ENODATA; if (edid->start_block == 0 && edid->blocks == 0) { edid->blocks = port->edid_blocks; return 0; } if (edid->start_block >= port->edid_blocks) return -EINVAL; if (edid->blocks > port->edid_blocks - edid->start_block) edid->blocks = port->edid_blocks - edid->start_block; memcpy(edid->edid, port->edid + edid->start_block * 128, edid->blocks * 128); return 0; } static int extron_s_edid(struct file *file, void *_fh, struct v4l2_edid *edid) { struct extron_port *port = video_drvdata(file); memset(edid->reserved, 0, sizeof(edid->reserved)); if (port->disconnected) return -ENODEV; if (edid->pad) return -EINVAL; /* Unfortunately it is not possible to clear the EDID */ if (edid->blocks == 0) return -EINVAL; if (edid->blocks > MAX_EDID_BLOCKS) { edid->blocks = MAX_EDID_BLOCKS; return -E2BIG; } if (cec_get_edid_spa_location(edid->edid, edid->blocks * 128)) v4l2_set_edid_phys_addr(edid->edid, edid->blocks * 128, 0); extron_parse_edid(port); return extron_write_edid(port, edid->edid, edid->blocks); } static int extron_log_status(struct file *file, void *priv) { struct extron_port *port = video_drvdata(file); extron_adap_status(port->adap, NULL); return v4l2_ctrl_log_status(file, priv); } static const struct v4l2_ioctl_ops extron_ioctl_ops = { .vidioc_querycap = extron_querycap, .vidioc_enum_input = extron_enum_input, .vidioc_g_input = extron_g_input, .vidioc_s_input = extron_s_input, .vidioc_enum_output = extron_enum_output, .vidioc_g_output = extron_g_output, .vidioc_s_output = extron_s_output, .vidioc_g_edid = extron_g_edid, .vidioc_s_edid = extron_s_edid, .vidioc_log_status = extron_log_status, .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, .vidioc_unsubscribe_event = v4l2_event_unsubscribe, }; static const struct v4l2_file_operations extron_fops = { .owner = THIS_MODULE, .open = v4l2_fh_open, .release = v4l2_fh_release, .poll = v4l2_ctrl_poll, .unlocked_ioctl = video_ioctl2, }; static const struct video_device extron_videodev = { .name = "extron-da-hd-4k-plus-cec", .vfl_dir = VFL_DIR_RX, .fops = &extron_fops, .ioctl_ops = &extron_ioctl_ops, .minor = -1, .release = video_device_release_empty, }; static void extron_disconnect(struct serio *serio) { struct extron *extron = serio_get_drvdata(serio); unsigned int p; kthread_stop(extron->kthread_setup); for (p = 0; p < extron->num_ports; p++) { struct extron_port *port = extron->ports[p]; if (!port) continue; port->disconnected = true; cancel_work_sync(&port->irq_work); } cancel_delayed_work_sync(&extron->work_update_edid); for (p = 0; p < extron->num_ports; p++) { struct extron_port *port = extron->ports[p]; if (!port) continue; if (port->cec_was_registered) { if (cec_is_registered(port->adap)) cec_unregister_adapter(port->adap); /* * After registering the adapter, the * extron_setup_thread() function took an extra * reference to the device. We call the corresponding * put here. */ cec_put_device(port->adap); } else { cec_delete_adapter(port->adap); } video_unregister_device(&port->vdev); } complete(&extron->edid_completion); for (p = 0; p < extron->num_ports; p++) { struct extron_port *port = extron->ports[p]; if (!port) continue; v4l2_ctrl_handler_free(&port->hdl); mutex_destroy(&port->video_lock); kfree(port); } mutex_destroy(&extron->edid_lock); mutex_destroy(&extron->serio_lock); extron->serio = NULL; serio_set_drvdata(serio, NULL); serio_close(serio); } static int extron_setup(struct extron *extron) { struct serio *serio = extron->serio; struct extron_port *port; u8 *reply = extron->reply; unsigned int p; unsigned int major, minor; int err; /* * Attempt to disable CEC: avoid received CEC messages * from interfering with the other serial port traffic. */ extron_send_and_wait(extron, NULL, "WI1*0CCEC", NULL); extron_send_and_wait(extron, NULL, "WO0*CCEC", NULL); /* Obtain unit part number */ err = extron_send_and_wait(extron, NULL, "N", "Pno"); if (err) return err; dev_info(extron->dev, "Unit part number: %s\n", reply + 3); if (strcmp(reply + 3, "60-1607-01") && strcmp(reply + 3, "60-1608-01") && strcmp(reply + 3, "60-1609-01")) { dev_err(extron->dev, "Unsupported model\n"); return -ENODEV; } /* Up to 6 output ports and one input port */ extron->num_out_ports = 2 * (reply[9] - '6'); extron->splitter.num_out_ports = extron->num_out_ports; extron->splitter.ports = extron->splitter_ports; extron->splitter.dev = extron->dev; extron->num_in_ports = 1; extron->num_ports = extron->num_out_ports + extron->num_in_ports; dev_info(extron->dev, "Unit output ports: %d\n", extron->num_out_ports); dev_info(extron->dev, "Unit input ports: %d\n", extron->num_in_ports); err = extron_send_and_wait(extron, NULL, "W CN", "Ipn "); if (err) return err; dev_info(extron->dev, "Unit name: %s\n", reply + 4); strscpy(extron->unit_name, reply + 4, sizeof(extron->unit_name)); err = extron_send_and_wait(extron, NULL, "*Q", "Bld"); if (err) return err; dev_info(extron->dev, "Unit FW Version: %s\n", reply + 3); strscpy(extron->unit_fw_version, reply + 3, sizeof(extron->unit_fw_version)); if (sscanf(reply + 3, "%u.%u.", &major, &minor) < 2 || major < 1 || minor < 2) { dev_err(extron->dev, "Unsupported FW version (only 1.02 or up is supported)\n"); return -ENODEV; } err = extron_send_and_wait(extron, NULL, "2i", "Inf02*"); if (err) return err; dev_info(extron->dev, "Unit Type: %s\n", reply + 6); strscpy(extron->unit_type, reply + 6, sizeof(extron->unit_type)); err = extron_send_and_wait(extron, NULL, "39Q", "Ver39*"); if (err) return err; dev_info(extron->dev, "CEC Engine Version: %s\n", reply + 6); strscpy(extron->unit_cec_engine_version, reply + 6, sizeof(extron->unit_cec_engine_version)); /* Disable CEC */ err = extron_send_and_wait(extron, NULL, "WI1*0CCEC", "CcecI1*"); if (err) return err; err = extron_send_and_wait(extron, NULL, "WO0*CCEC", "CcecO0"); if (err) return err; extron->hpd_never_low = hpd_never_low; /* Pull input port HPD low if all output ports also have a low HPD */ if (hpd_never_low) { dev_info(extron->dev, "Always keep input HPD high\n"); } else { dev_info(extron->dev, "Pull input HPD low if all output HPDs are low\n"); extron_send_and_wait(extron, NULL, "W1ihpd", "Ihpd1"); } for (p = 0; p < extron->num_ports; p++) { u32 caps = CEC_CAP_DEFAULTS | CEC_CAP_MONITOR_ALL; if (vendor_id) caps &= ~CEC_CAP_LOG_ADDRS; port = kzalloc(sizeof(*port), GFP_KERNEL); if (!port) return -ENOMEM; INIT_WORK(&port->irq_work, extron_irq_work_handler); spin_lock_init(&port->msg_lock); mutex_init(&port->video_lock); port->extron = extron; port->is_input = p >= extron->num_out_ports; port->direction = port->is_input ? 'I' : 'O'; port->port.port = 1 + (port->is_input ? p - extron->num_out_ports : p); port->port.splitter = &extron->splitter; port->phys_addr = CEC_PHYS_ADDR_INVALID; snprintf(port->name, sizeof(port->name), "%s-%s-%u", dev_name(&serio->dev), port->is_input ? "in" : "out", port->port.port); port->dev = extron->dev; port->adap = cec_allocate_adapter(&extron_cec_adap_ops, port, port->name, caps, 1); err = PTR_ERR_OR_ZERO(port->adap); if (err < 0) { kfree(port); return err; } port->adap->xfer_timeout_ms = EXTRON_TIMEOUT_SECS * 1000; port->port.adap = port->adap; port->vdev = extron_videodev; port->vdev.lock = &port->video_lock; port->vdev.v4l2_dev = &extron->v4l2_dev; port->vdev.ctrl_handler = &port->hdl; port->vdev.device_caps = V4L2_CAP_EDID; video_set_drvdata(&port->vdev, port); v4l2_ctrl_handler_init(&port->hdl, 2); if (port->is_input) { port->vdev.vfl_dir = VFL_DIR_RX; port->ctrl_rx_power_present = v4l2_ctrl_new_std(&port->hdl, NULL, V4L2_CID_DV_RX_POWER_PRESENT, 0, 1, 0, 0); port->has_edid = true; } else { port->vdev.vfl_dir = VFL_DIR_TX; port->ctrl_tx_hotplug = v4l2_ctrl_new_std(&port->hdl, NULL, V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0); port->ctrl_tx_edid_present = v4l2_ctrl_new_std(&port->hdl, NULL, V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0); } err = port->hdl.error; if (err < 0) { cec_delete_adapter(port->adap); kfree(port); return err; } extron->ports[p] = port; extron->splitter_ports[p] = &port->port; if (port->is_input && manufacturer_name[0]) extron_write_edid(port, hdmi_edid, 2); } /* Enable CEC (manual mode, i.e. controlled by the driver) */ err = extron_send_and_wait(extron, NULL, "WI1*20CCEC", "CcecI1*"); if (err) return err; err = extron_send_and_wait(extron, NULL, "WO20*CCEC", "CcecO20"); if (err) return err; /* Set logical addresses to 15 */ err = extron_send_and_wait(extron, NULL, "WI1*15LCEC", "LcecI1*15"); if (err) return err; for (p = 0; p < extron->num_out_ports; p++) { char cmd[20]; char resp[20]; snprintf(cmd, sizeof(cmd), "WO%u*15LCEC", p + 1); snprintf(resp, sizeof(resp), "LcecO%u*15", p + 1); err = extron_send_and_wait(extron, extron->ports[p], cmd, resp); if (err) return err; } /* * The Extron is now ready for operation. Specifically it is now * possible to retrieve EDIDs. */ extron->is_ready = true; /* Query HDCP and Signal states, used to update the initial state */ err = extron_send_and_wait(extron, NULL, "WHDCP", "Hdcp"); if (err) return err; return extron_send_and_wait(extron, NULL, "WLS", "Sig"); } static int extron_setup_thread(void *_extron) { struct extron *extron = _extron; struct extron_port *port; unsigned int p; bool poll_splitter = false; bool was_connected = true; int err; while (1) { if (kthread_should_stop()) return 0; err = extron_send_and_wait(extron, NULL, "W3CV", "Vrb3"); // that should make it possible to detect a serio disconnect // here by stopping the workqueue if (err >= 0) break; was_connected = false; ssleep(1); } /* * If the Extron was not connected at probe() time, i.e. it just got * powered up and while the serial port is working, the firmware is * still booting up, then wait 10 seconds for the firmware to settle. * * Trying to continue too soon means that some commands will not * work yet. */ if (!was_connected) ssleep(10); err = extron_setup(extron); if (err) goto disable_ports; for (p = 0; p < extron->num_ports; p++) { struct cec_log_addrs log_addrs = {}; port = extron->ports[p]; if (port->is_input && manufacturer_name[0]) v4l2_disable_ioctl(&port->vdev, VIDIOC_S_EDID); err = video_register_device(&port->vdev, VFL_TYPE_VIDEO, -1); if (err) { v4l2_err(&extron->v4l2_dev, "Failed to register video device\n"); goto disable_ports; } err = cec_register_adapter(port->adap, extron->dev); if (err < 0) goto disable_ports; port->dev = &port->adap->devnode.dev; port->cec_was_registered = true; /* * This driver is unusual in that the whole setup takes place * in a thread since it can take such a long time before the * Extron Splitter boots up, and you do not want to block the * probe function on this driver. In addition, as soon as * CEC adapters come online, they can be used, and you cannot * just unregister them again if an error occurs, since that * can delete the underlying CEC adapter, which might already * be in use. * * So we take an additional reference to the adapter. This * allows us to unregister the device node if needed, without * deleting the actual adapter. * * In the disconnect function we will do the corresponding * put call to ensure the adapter is deleted. */ cec_get_device(port->adap); /* * If vendor_id wasn't set, then userspace configures the * CEC devices. Otherwise the driver configures the CEC * devices as TV (input) and Playback (outputs) devices * and the driver processes all CEC messages. */ if (!vendor_id) continue; log_addrs.cec_version = CEC_OP_CEC_VERSION_2_0; log_addrs.num_log_addrs = 1; log_addrs.vendor_id = vendor_id; if (port->is_input) { strscpy(log_addrs.osd_name, "Splitter In", sizeof(log_addrs.osd_name)); log_addrs.log_addr_type[0] = CEC_LOG_ADDR_TYPE_TV; log_addrs.primary_device_type[0] = CEC_OP_PRIM_DEVTYPE_TV; log_addrs.all_device_types[0] = CEC_OP_ALL_DEVTYPE_TV; } else { snprintf(log_addrs.osd_name, sizeof(log_addrs.osd_name), "Splitter Out%u", port->port.port); log_addrs.log_addr_type[0] = CEC_LOG_ADDR_TYPE_PLAYBACK; log_addrs.primary_device_type[0] = CEC_OP_PRIM_DEVTYPE_PLAYBACK; log_addrs.all_device_types[0] = CEC_OP_ALL_DEVTYPE_PLAYBACK; } err = cec_s_log_addrs(port->adap, &log_addrs, false); if (err < 0) goto disable_ports; } poll_splitter = true; port = extron->ports[extron->num_out_ports]; while (!kthread_should_stop()) { ssleep(1); if (hpd_never_low != extron->hpd_never_low) { /* * Keep input port HPD high at all times, or pull it low * if all output ports also have a low HPD */ if (hpd_never_low) { dev_info(extron->dev, "Always keep input HPD high\n"); extron_send_and_wait(extron, NULL, "W0ihpd", "Ihpd0"); } else { dev_info(extron->dev, "Pull input HPD low if all output HPDs are low\n"); extron_send_and_wait(extron, NULL, "W1ihpd", "Ihpd1"); } extron->hpd_never_low = hpd_never_low; } if (poll_splitter && cec_splitter_poll(&extron->splitter, port->adap, debug) && manufacturer_name[0]) { /* * Sinks were lost, so see if the input edid needs to * be updated. */ cancel_delayed_work_sync(&extron->work_update_edid); schedule_delayed_work(&extron->work_update_edid, msecs_to_jiffies(1000)); } } return 0; disable_ports: extron->is_ready = false; for (p = 0; p < extron->num_ports; p++) { struct extron_port *port = extron->ports[p]; if (!port) continue; port->disconnected = true; cancel_work_sync(&port->irq_work); video_unregister_device(&port->vdev); if (port->cec_was_registered) cec_unregister_adapter(port->adap); } cancel_delayed_work_sync(&extron->work_update_edid); complete(&extron->edid_completion); dev_err(extron->dev, "Setup failed with error %d\n", err); while (!kthread_should_stop()) ssleep(1); return err; } static int extron_connect(struct serio *serio, struct serio_driver *drv) { struct extron *extron; int err = -ENOMEM; if (manufacturer_name[0] && (!isupper(manufacturer_name[0]) || !isupper(manufacturer_name[1]) || !isupper(manufacturer_name[2]))) { dev_warn(&serio->dev, "ignoring invalid manufacturer name\n"); manufacturer_name[0] = 0; } extron = kzalloc(sizeof(*extron), GFP_KERNEL); if (!extron) return -ENOMEM; extron->serio = serio; extron->dev = &serio->dev; mutex_init(&extron->serio_lock); mutex_init(&extron->edid_lock); INIT_DELAYED_WORK(&extron->work_update_edid, update_edid_work); err = v4l2_device_register(extron->dev, &extron->v4l2_dev); if (err) goto free_device; err = serio_open(serio, drv); if (err) goto unreg_v4l2_dev; serio_set_drvdata(serio, extron); init_completion(&extron->edid_completion); extron->kthread_setup = kthread_run(extron_setup_thread, extron, "extron-da-hd-4k-plus-cec-%s", dev_name(&serio->dev)); if (!IS_ERR(extron->kthread_setup)) return 0; dev_err(extron->dev, "kthread_run() failed\n"); err = PTR_ERR(extron->kthread_setup); extron->serio = NULL; serio_set_drvdata(serio, NULL); serio_close(serio); unreg_v4l2_dev: v4l2_device_unregister(&extron->v4l2_dev); free_device: mutex_destroy(&extron->edid_lock); mutex_destroy(&extron->serio_lock); kfree(extron); return err; } static const struct serio_device_id extron_serio_ids[] = { { .type = SERIO_RS232, .proto = SERIO_EXTRON_DA_HD_4K_PLUS, .id = SERIO_ANY, .extra = SERIO_ANY, }, { 0 } }; MODULE_DEVICE_TABLE(serio, extron_serio_ids); static struct serio_driver extron_drv = { .driver = { .name = "extron-da-hd-4k-plus-cec", }, .description = "Extron DA HD 4K PLUS HDMI CEC driver", .id_table = extron_serio_ids, .interrupt = extron_interrupt, .connect = extron_connect, .disconnect = extron_disconnect, }; module_serio_driver(extron_drv);