drivers/media/platform/vivid/vivid-cec.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vivid-cec.c - A Virtual Video Test Driver, cec emulation
   4  *
   5  * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   6  */
   7
   8 #include <media/cec.h>
   9
  10 #include "vivid-core.h"
  11 #include "vivid-cec.h"
  12
  13 #define CEC_TIM_START_BIT_TOTAL         4500
  14 #define CEC_TIM_START_BIT_LOW           3700
  15 #define CEC_TIM_START_BIT_HIGH          800
  16 #define CEC_TIM_DATA_BIT_TOTAL          2400
  17 #define CEC_TIM_DATA_BIT_0_LOW          1500
  18 #define CEC_TIM_DATA_BIT_0_HIGH         900
  19 #define CEC_TIM_DATA_BIT_1_LOW          600
  20 #define CEC_TIM_DATA_BIT_1_HIGH         1800
  21
  22 void vivid_cec_bus_free_work(struct vivid_dev *dev)
  23 {
  24         spin_lock(&dev->cec_slock);
  25         while (!list_empty(&dev->cec_work_list)) {
  26                 struct vivid_cec_work *cw =
  27                         list_first_entry(&dev->cec_work_list,
  28                                          struct vivid_cec_work, list);
  29
  30                 spin_unlock(&dev->cec_slock);
  31                 cancel_delayed_work_sync(&cw->work);
  32                 spin_lock(&dev->cec_slock);
  33                 list_del(&cw->list);
  34                 cec_transmit_attempt_done(cw->adap, CEC_TX_STATUS_LOW_DRIVE);
  35                 kfree(cw);
  36         }
  37         spin_unlock(&dev->cec_slock);
  38 }
  39
  40 static bool vivid_cec_find_dest_adap(struct vivid_dev *dev,
  41                                      struct cec_adapter *adap, u8 dest)
  42 {
  43         unsigned int i;
  44
  45         if (dest >= 0xf)
  46                 return false;
  47
  48         if (adap != dev->cec_rx_adap && dev->cec_rx_adap &&
  49             dev->cec_rx_adap->is_configured &&
  50             cec_has_log_addr(dev->cec_rx_adap, dest))
  51                 return true;
  52
  53         for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++) {
  54                 if (adap == dev->cec_tx_adap[i])
  55                         continue;
  56                 if (!dev->cec_tx_adap[i]->is_configured)
  57                         continue;
  58                 if (cec_has_log_addr(dev->cec_tx_adap[i], dest))
  59                         return true;
  60         }
  61         return false;
  62 }
  63
  64 static void vivid_cec_pin_adap_events(struct cec_adapter *adap, ktime_t ts,
  65                                       const struct cec_msg *msg, bool nacked)
  66 {
  67         unsigned int len = nacked ? 1 : msg->len;
  68         unsigned int i;
  69         bool bit;
  70
  71         if (adap == NULL)
  72                 return;
  73
  74         /*
  75          * Suffix ULL on constant 10 makes the expression
  76          * CEC_TIM_START_BIT_TOTAL + 10ULL * len * CEC_TIM_DATA_BIT_TOTAL
  77          * to be evaluated using 64-bit unsigned arithmetic (u64), which
  78          * is what ktime_sub_us expects as second argument.
  79          */
  80         ts = ktime_sub_us(ts, CEC_TIM_START_BIT_TOTAL +
  81                                10ULL * len * CEC_TIM_DATA_BIT_TOTAL);
  82         cec_queue_pin_cec_event(adap, false, false, ts);
  83         ts = ktime_add_us(ts, CEC_TIM_START_BIT_LOW);
  84         cec_queue_pin_cec_event(adap, true, false, ts);
  85         ts = ktime_add_us(ts, CEC_TIM_START_BIT_HIGH);
  86
  87         for (i = 0; i < 10 * len; i++) {
  88                 switch (i % 10) {
  89                 case 0 ... 7:
  90                         bit = msg->msg[i / 10] & (0x80 >> (i % 10));
  91                         break;
  92                 case 8: /* EOM */
  93                         bit = i / 10 == msg->len - 1;
  94                         break;
  95                 case 9: /* ACK */
  96                         bit = cec_msg_is_broadcast(msg) ^ nacked;
  97                         break;
  98                 }
  99                 cec_queue_pin_cec_event(adap, false, false, ts);
 100                 if (bit)
 101                         ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_1_LOW);
 102                 else
 103                         ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_0_LOW);
 104                 cec_queue_pin_cec_event(adap, true, false, ts);
 105                 if (bit)
 106                         ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_1_HIGH);
 107                 else
 108                         ts = ktime_add_us(ts, CEC_TIM_DATA_BIT_0_HIGH);
 109         }
 110 }
 111
 112 static void vivid_cec_pin_events(struct vivid_dev *dev,
 113                                  const struct cec_msg *msg, bool nacked)
 114 {
 115         ktime_t ts = ktime_get();
 116         unsigned int i;
 117
 118         vivid_cec_pin_adap_events(dev->cec_rx_adap, ts, msg, nacked);
 119         for (i = 0; i < MAX_OUTPUTS; i++)
 120                 vivid_cec_pin_adap_events(dev->cec_tx_adap[i], ts, msg, nacked);
 121 }
 122
 123 static void vivid_cec_xfer_done_worker(struct work_struct *work)
 124 {
 125         struct vivid_cec_work *cw =
 126                 container_of(work, struct vivid_cec_work, work.work);
 127         struct vivid_dev *dev = cw->dev;
 128         struct cec_adapter *adap = cw->adap;
 129         u8 dest = cec_msg_destination(&cw->msg);
 130         bool valid_dest;
 131         unsigned int i;
 132
 133         valid_dest = cec_msg_is_broadcast(&cw->msg);
 134         if (!valid_dest)
 135                 valid_dest = vivid_cec_find_dest_adap(dev, adap, dest);
 136
 137         cw->tx_status = valid_dest ? CEC_TX_STATUS_OK : CEC_TX_STATUS_NACK;
 138         spin_lock(&dev->cec_slock);
 139         dev->cec_xfer_time_jiffies = 0;
 140         dev->cec_xfer_start_jiffies = 0;
 141         list_del(&cw->list);
 142         spin_unlock(&dev->cec_slock);
 143         vivid_cec_pin_events(dev, &cw->msg, !valid_dest);
 144         cec_transmit_attempt_done(cw->adap, cw->tx_status);
 145
 146         /* Broadcast message */
 147         if (adap != dev->cec_rx_adap)
 148                 cec_received_msg(dev->cec_rx_adap, &cw->msg);
 149         for (i = 0; i < MAX_OUTPUTS && dev->cec_tx_adap[i]; i++)
 150                 if (adap != dev->cec_tx_adap[i])
 151                         cec_received_msg(dev->cec_tx_adap[i], &cw->msg);
 152         kfree(cw);
 153 }
 154
 155 static void vivid_cec_xfer_try_worker(struct work_struct *work)
 156 {
 157         struct vivid_cec_work *cw =
 158                 container_of(work, struct vivid_cec_work, work.work);
 159         struct vivid_dev *dev = cw->dev;
 160
 161         spin_lock(&dev->cec_slock);
 162         if (dev->cec_xfer_time_jiffies) {
 163                 list_del(&cw->list);
 164                 spin_unlock(&dev->cec_slock);
 165                 cec_transmit_attempt_done(cw->adap, CEC_TX_STATUS_ARB_LOST);
 166                 kfree(cw);
 167         } else {
 168                 INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_done_worker);
 169                 dev->cec_xfer_start_jiffies = jiffies;
 170                 dev->cec_xfer_time_jiffies = usecs_to_jiffies(cw->usecs);
 171                 spin_unlock(&dev->cec_slock);
 172                 schedule_delayed_work(&cw->work, dev->cec_xfer_time_jiffies);
 173         }
 174 }
 175
 176 static int vivid_cec_adap_enable(struct cec_adapter *adap, bool enable)
 177 {
 178         adap->cec_pin_is_high = true;
 179         return 0;
 180 }
 181
 182 static int vivid_cec_adap_log_addr(struct cec_adapter *adap, u8 log_addr)
 183 {
 184         return 0;
 185 }
 186
 187 /*
 188  * One data bit takes 2400 us, each byte needs 10 bits so that's 24000 us
 189  * per byte.
 190  */
 191 #define USECS_PER_BYTE 24000
 192
 193 static int vivid_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
 194                                    u32 signal_free_time, struct cec_msg *msg)
 195 {
 196         struct vivid_dev *dev = cec_get_drvdata(adap);
 197         struct vivid_cec_work *cw = kzalloc(sizeof(*cw), GFP_KERNEL);
 198         long delta_jiffies = 0;
 199
 200         if (cw == NULL)
 201                 return -ENOMEM;
 202         cw->dev = dev;
 203         cw->adap = adap;
 204         cw->usecs = CEC_FREE_TIME_TO_USEC(signal_free_time) +
 205                     msg->len * USECS_PER_BYTE;
 206         cw->msg = *msg;
 207
 208         spin_lock(&dev->cec_slock);
 209         list_add(&cw->list, &dev->cec_work_list);
 210         if (dev->cec_xfer_time_jiffies == 0) {
 211                 INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_done_worker);
 212                 dev->cec_xfer_start_jiffies = jiffies;
 213                 dev->cec_xfer_time_jiffies = usecs_to_jiffies(cw->usecs);
 214                 delta_jiffies = dev->cec_xfer_time_jiffies;
 215         } else {
 216                 INIT_DELAYED_WORK(&cw->work, vivid_cec_xfer_try_worker);
 217                 delta_jiffies = dev->cec_xfer_start_jiffies +
 218                         dev->cec_xfer_time_jiffies - jiffies;
 219         }
 220         spin_unlock(&dev->cec_slock);
 221         schedule_delayed_work(&cw->work, delta_jiffies < 0 ? 0 : delta_jiffies);
 222         return 0;
 223 }
 224
 225 static int vivid_received(struct cec_adapter *adap, struct cec_msg *msg)
 226 {
 227         struct vivid_dev *dev = cec_get_drvdata(adap);
 228         struct cec_msg reply;
 229         u8 dest = cec_msg_destination(msg);
 230         u8 disp_ctl;
 231         char osd[14];
 232
 233         if (cec_msg_is_broadcast(msg))
 234                 dest = adap->log_addrs.log_addr[0];
 235         cec_msg_init(&reply, dest, cec_msg_initiator(msg));
 236
 237         switch (cec_msg_opcode(msg)) {
 238         case CEC_MSG_SET_OSD_STRING:
 239                 if (!cec_is_sink(adap))
 240                         return -ENOMSG;
 241                 cec_ops_set_osd_string(msg, &disp_ctl, osd);
 242                 switch (disp_ctl) {
 243                 case CEC_OP_DISP_CTL_DEFAULT:
 244                         strcpy(dev->osd, osd);
 245                         dev->osd_jiffies = jiffies;
 246                         break;
 247                 case CEC_OP_DISP_CTL_UNTIL_CLEARED:
 248                         strcpy(dev->osd, osd);
 249                         dev->osd_jiffies = 0;
 250                         break;
 251                 case CEC_OP_DISP_CTL_CLEAR:
 252                         dev->osd[0] = 0;
 253                         dev->osd_jiffies = 0;
 254                         break;
 255                 default:
 256                         cec_msg_feature_abort(&reply, cec_msg_opcode(msg),
 257                                               CEC_OP_ABORT_INVALID_OP);
 258                         cec_transmit_msg(adap, &reply, false);
 259                         break;
 260                 }
 261                 break;
 262         default:
 263                 return -ENOMSG;
 264         }
 265         return 0;
 266 }
 267
 268 static const struct cec_adap_ops vivid_cec_adap_ops = {
 269         .adap_enable = vivid_cec_adap_enable,
 270         .adap_log_addr = vivid_cec_adap_log_addr,
 271         .adap_transmit = vivid_cec_adap_transmit,
 272         .received = vivid_received,
 273 };
 274
 275 struct cec_adapter *vivid_cec_alloc_adap(struct vivid_dev *dev,
 276                                          unsigned int idx,
 277                                          bool is_source)
 278 {
 279         char name[sizeof(dev->vid_out_dev.name) + 2];
 280         u32 caps = CEC_CAP_DEFAULTS | CEC_CAP_MONITOR_ALL | CEC_CAP_MONITOR_PIN;
 281
 282         snprintf(name, sizeof(name), "%s%d",
 283                  is_source ? dev->vid_out_dev.name : dev->vid_cap_dev.name,
 284                  idx);
 285         return cec_allocate_adapter(&vivid_cec_adap_ops, dev,
 286                 name, caps, 1);
 287 }