drivers/media/usb/rainshadow-cec/rainshadow-cec.c

   1 /*
   2  * RainShadow Tech 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  * The higher level protocols are currently disabled. This can be added
  17  * later, similar to how this is done for the Pulse Eight CEC driver.
  18  *
  19  * Documentation of the protocol is available here:
  20  *
  21  * http://rainshadowtech.com/doc/HDMICECtoUSBandRS232v2.0.pdf
  22  */
  23
  24 #include <linux/completion.h>
  25 #include <linux/ctype.h>
  26 #include <linux/delay.h>
  27 #include <linux/init.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/serio.h>
  32 #include <linux/slab.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/time.h>
  35 #include <linux/workqueue.h>
  36
  37 #include <media/cec.h>
  38
  39 MODULE_AUTHOR("Hans Verkuil <hverkuil@xs4all.nl>");
  40 MODULE_DESCRIPTION("RainShadow Tech HDMI CEC driver");
  41 MODULE_LICENSE("GPL");
  42
  43 #define DATA_SIZE 256
  44
  45 struct rain {
  46         struct device *dev;
  47         struct serio *serio;
  48         struct cec_adapter *adap;
  49         struct completion cmd_done;
  50         struct work_struct work;
  51
  52         /* Low-level ringbuffer, collecting incoming characters */
  53         char buf[DATA_SIZE];
  54         unsigned int buf_rd_idx;
  55         unsigned int buf_wr_idx;
  56         unsigned int buf_len;
  57         spinlock_t buf_lock;
  58
  59         /* command buffer */
  60         char cmd[DATA_SIZE];
  61         unsigned int cmd_idx;
  62         bool cmd_started;
  63
  64         /* reply to a command, only used to store the firmware version */
  65         char cmd_reply[DATA_SIZE];
  66
  67         struct mutex write_lock;
  68 };
  69
  70 static void rain_process_msg(struct rain *rain)
  71 {
  72         struct cec_msg msg = {};
  73         const char *cmd = rain->cmd + 3;
  74         int stat = -1;
  75
  76         for (; *cmd; cmd++) {
  77                 if (!isxdigit(*cmd))
  78                         continue;
  79                 if (isxdigit(cmd[0]) && isxdigit(cmd[1])) {
  80                         if (msg.len == CEC_MAX_MSG_SIZE)
  81                                 break;
  82                         if (hex2bin(msg.msg + msg.len, cmd, 1))
  83                                 continue;
  84                         msg.len++;
  85                         cmd++;
  86                         continue;
  87                 }
  88                 if (!cmd[1])
  89                         stat = hex_to_bin(cmd[0]);
  90                 break;
  91         }
  92
  93         if (rain->cmd[0] == 'R') {
  94                 if (stat == 1 || stat == 2)
  95                         cec_received_msg(rain->adap, &msg);
  96                 return;
  97         }
  98
  99         switch (stat) {
 100         case 1:
 101                 cec_transmit_attempt_done(rain->adap, CEC_TX_STATUS_OK);
 102                 break;
 103         case 2:
 104                 cec_transmit_attempt_done(rain->adap, CEC_TX_STATUS_NACK);
 105                 break;
 106         default:
 107                 cec_transmit_attempt_done(rain->adap, CEC_TX_STATUS_LOW_DRIVE);
 108                 break;
 109         }
 110 }
 111
 112 static void rain_irq_work_handler(struct work_struct *work)
 113 {
 114         struct rain *rain =
 115                 container_of(work, struct rain, work);
 116
 117         while (true) {
 118                 unsigned long flags;
 119                 char data;
 120
 121                 spin_lock_irqsave(&rain->buf_lock, flags);
 122                 if (!rain->buf_len) {
 123                         spin_unlock_irqrestore(&rain->buf_lock, flags);
 124                         break;
 125                 }
 126
 127                 data = rain->buf[rain->buf_rd_idx];
 128                 rain->buf_len--;
 129                 rain->buf_rd_idx = (rain->buf_rd_idx + 1) & 0xff;
 130
 131                 spin_unlock_irqrestore(&rain->buf_lock, flags);
 132
 133                 if (!rain->cmd_started && data != '?')
 134                         continue;
 135
 136                 switch (data) {
 137                 case '\r':
 138                         rain->cmd[rain->cmd_idx] = '\0';
 139                         dev_dbg(rain->dev, "received: %s\n", rain->cmd);
 140                         if (!memcmp(rain->cmd, "REC", 3) ||
 141                             !memcmp(rain->cmd, "STA", 3)) {
 142                                 rain_process_msg(rain);
 143                         } else {
 144                                 strscpy(rain->cmd_reply, rain->cmd,
 145                                         sizeof(rain->cmd_reply));
 146                                 complete(&rain->cmd_done);
 147                         }
 148                         rain->cmd_idx = 0;
 149                         rain->cmd_started = false;
 150                         break;
 151
 152                 case '\n':
 153                         rain->cmd_idx = 0;
 154                         rain->cmd_started = false;
 155                         break;
 156
 157                 case '?':
 158                         rain->cmd_idx = 0;
 159                         rain->cmd_started = true;
 160                         break;
 161
 162                 default:
 163                         if (rain->cmd_idx >= DATA_SIZE - 1) {
 164                                 dev_dbg(rain->dev,
 165                                         "throwing away %d bytes of garbage\n", rain->cmd_idx);
 166                                 rain->cmd_idx = 0;
 167                         }
 168                         rain->cmd[rain->cmd_idx++] = data;
 169                         break;
 170                 }
 171         }
 172 }
 173
 174 static irqreturn_t rain_interrupt(struct serio *serio, unsigned char data,
 175                                     unsigned int flags)
 176 {
 177         struct rain *rain = serio_get_drvdata(serio);
 178
 179         if (rain->buf_len == DATA_SIZE) {
 180                 dev_warn_once(rain->dev, "buffer overflow\n");
 181                 return IRQ_HANDLED;
 182         }
 183         spin_lock(&rain->buf_lock);
 184         rain->buf_len++;
 185         rain->buf[rain->buf_wr_idx] = data;
 186         rain->buf_wr_idx = (rain->buf_wr_idx + 1) & 0xff;
 187         spin_unlock(&rain->buf_lock);
 188         schedule_work(&rain->work);
 189         return IRQ_HANDLED;
 190 }
 191
 192 static void rain_disconnect(struct serio *serio)
 193 {
 194         struct rain *rain = serio_get_drvdata(serio);
 195
 196         cancel_work_sync(&rain->work);
 197         cec_unregister_adapter(rain->adap);
 198         dev_info(&serio->dev, "disconnected\n");
 199         serio_close(serio);
 200         serio_set_drvdata(serio, NULL);
 201         kfree(rain);
 202 }
 203
 204 static int rain_send(struct rain *rain, const char *command)
 205 {
 206         int err = serio_write(rain->serio, '!');
 207
 208         dev_dbg(rain->dev, "send: %s\n", command);
 209         while (!err && *command)
 210                 err = serio_write(rain->serio, *command++);
 211         if (!err)
 212                 err = serio_write(rain->serio, '~');
 213
 214         return err;
 215 }
 216
 217 static int rain_send_and_wait(struct rain *rain,
 218                               const char *cmd, const char *reply)
 219 {
 220         int err;
 221
 222         init_completion(&rain->cmd_done);
 223
 224         mutex_lock(&rain->write_lock);
 225         err = rain_send(rain, cmd);
 226         if (err)
 227                 goto err;
 228
 229         if (!wait_for_completion_timeout(&rain->cmd_done, HZ)) {
 230                 err = -ETIMEDOUT;
 231                 goto err;
 232         }
 233         if (reply && strncmp(rain->cmd_reply, reply, strlen(reply))) {
 234                 dev_dbg(rain->dev,
 235                          "transmit of '%s': received '%s' instead of '%s'\n",
 236                          cmd, rain->cmd_reply, reply);
 237                 err = -EIO;
 238         }
 239 err:
 240         mutex_unlock(&rain->write_lock);
 241         return err;
 242 }
 243
 244 static int rain_setup(struct rain *rain, struct serio *serio,
 245                         struct cec_log_addrs *log_addrs, u16 *pa)
 246 {
 247         int err;
 248
 249         err = rain_send_and_wait(rain, "R", "REV");
 250         if (err)
 251                 return err;
 252         dev_info(rain->dev, "Firmware version %s\n", rain->cmd_reply + 4);
 253
 254         err = rain_send_and_wait(rain, "Q 1", "QTY");
 255         if (err)
 256                 return err;
 257         err = rain_send_and_wait(rain, "c0000", "CFG");
 258         if (err)
 259                 return err;
 260         return rain_send_and_wait(rain, "A F 0000", "ADR");
 261 }
 262
 263 static int rain_cec_adap_enable(struct cec_adapter *adap, bool enable)
 264 {
 265         return 0;
 266 }
 267
 268 static int rain_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
 269 {
 270         struct rain *rain = cec_get_drvdata(adap);
 271         u8 cmd[16];
 272
 273         if (log_addr == CEC_LOG_ADDR_INVALID)
 274                 log_addr = CEC_LOG_ADDR_UNREGISTERED;
 275         snprintf(cmd, sizeof(cmd), "A %x", log_addr);
 276         return rain_send_and_wait(rain, cmd, "ADR");
 277 }
 278
 279 static int rain_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
 280                                     u32 signal_free_time, struct cec_msg *msg)
 281 {
 282         struct rain *rain = cec_get_drvdata(adap);
 283         char cmd[2 * CEC_MAX_MSG_SIZE + 16];
 284         unsigned int i;
 285         int err;
 286
 287         if (msg->len == 1) {
 288                 snprintf(cmd, sizeof(cmd), "x%x", cec_msg_destination(msg));
 289         } else {
 290                 char hex[3];
 291
 292                 snprintf(cmd, sizeof(cmd), "x%x %02x ",
 293                          cec_msg_destination(msg), msg->msg[1]);
 294                 for (i = 2; i < msg->len; i++) {
 295                         snprintf(hex, sizeof(hex), "%02x", msg->msg[i]);
 296                         strlcat(cmd, hex, sizeof(cmd));
 297                 }
 298         }
 299         mutex_lock(&rain->write_lock);
 300         err = rain_send(rain, cmd);
 301         mutex_unlock(&rain->write_lock);
 302         return err;
 303 }
 304
 305 static const struct cec_adap_ops rain_cec_adap_ops = {
 306         .adap_enable = rain_cec_adap_enable,
 307         .adap_log_addr = rain_cec_adap_log_addr,
 308         .adap_transmit = rain_cec_adap_transmit,
 309 };
 310
 311 static int rain_connect(struct serio *serio, struct serio_driver *drv)
 312 {
 313         u32 caps = CEC_CAP_DEFAULTS | CEC_CAP_PHYS_ADDR | CEC_CAP_MONITOR_ALL;
 314         struct rain *rain;
 315         int err = -ENOMEM;
 316         struct cec_log_addrs log_addrs = {};
 317         u16 pa = CEC_PHYS_ADDR_INVALID;
 318
 319         rain = kzalloc(sizeof(*rain), GFP_KERNEL);
 320
 321         if (!rain)
 322                 return -ENOMEM;
 323
 324         rain->serio = serio;
 325         rain->adap = cec_allocate_adapter(&rain_cec_adap_ops, rain,
 326                                           dev_name(&serio->dev), caps, 1);
 327         err = PTR_ERR_OR_ZERO(rain->adap);
 328         if (err < 0)
 329                 goto free_device;
 330
 331         rain->dev = &serio->dev;
 332         serio_set_drvdata(serio, rain);
 333         INIT_WORK(&rain->work, rain_irq_work_handler);
 334         mutex_init(&rain->write_lock);
 335         spin_lock_init(&rain->buf_lock);
 336
 337         err = serio_open(serio, drv);
 338         if (err)
 339                 goto delete_adap;
 340
 341         err = rain_setup(rain, serio, &log_addrs, &pa);
 342         if (err)
 343                 goto close_serio;
 344
 345         err = cec_register_adapter(rain->adap, &serio->dev);
 346         if (err < 0)
 347                 goto close_serio;
 348
 349         rain->dev = &rain->adap->devnode.dev;
 350         return 0;
 351
 352 close_serio:
 353         serio_close(serio);
 354 delete_adap:
 355         cec_delete_adapter(rain->adap);
 356         serio_set_drvdata(serio, NULL);
 357 free_device:
 358         kfree(rain);
 359         return err;
 360 }
 361
 362 static const struct serio_device_id rain_serio_ids[] = {
 363         {
 364                 .type   = SERIO_RS232,
 365                 .proto  = SERIO_RAINSHADOW_CEC,
 366                 .id     = SERIO_ANY,
 367                 .extra  = SERIO_ANY,
 368         },
 369         { 0 }
 370 };
 371
 372 MODULE_DEVICE_TABLE(serio, rain_serio_ids);
 373
 374 static struct serio_driver rain_drv = {
 375         .driver         = {
 376                 .name   = "rainshadow-cec",
 377         },
 378         .description    = "RainShadow Tech HDMI CEC driver",
 379         .id_table       = rain_serio_ids,
 380         .interrupt      = rain_interrupt,
 381         .connect        = rain_connect,
 382         .disconnect     = rain_disconnect,
 383 };
 384
 385 module_serio_driver(rain_drv);