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