drivers/gpu/drm/bridge/adv7511/adv7511_cec.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * adv7511_cec.c - Analog Devices ADV7511/33 cec driver
   4  *
   5  * Copyright 2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/clk.h>
  12
  13 #include <media/cec.h>
  14
  15 #include "adv7511.h"
  16
  17 static const u8 ADV7511_REG_CEC_RX_FRAME_HDR[] = {
  18         ADV7511_REG_CEC_RX1_FRAME_HDR,
  19         ADV7511_REG_CEC_RX2_FRAME_HDR,
  20         ADV7511_REG_CEC_RX3_FRAME_HDR,
  21 };
  22
  23 static const u8 ADV7511_REG_CEC_RX_FRAME_LEN[] = {
  24         ADV7511_REG_CEC_RX1_FRAME_LEN,
  25         ADV7511_REG_CEC_RX2_FRAME_LEN,
  26         ADV7511_REG_CEC_RX3_FRAME_LEN,
  27 };
  28
  29 #define ADV7511_INT1_CEC_MASK \
  30         (ADV7511_INT1_CEC_TX_READY | ADV7511_INT1_CEC_TX_ARBIT_LOST | \
  31          ADV7511_INT1_CEC_TX_RETRY_TIMEOUT | ADV7511_INT1_CEC_RX_READY1 | \
  32          ADV7511_INT1_CEC_RX_READY2 | ADV7511_INT1_CEC_RX_READY3)
  33
  34 static void adv_cec_tx_raw_status(struct adv7511 *adv7511, u8 tx_raw_status)
  35 {
  36         unsigned int offset = adv7511->info->reg_cec_offset;
  37         unsigned int val;
  38
  39         if (regmap_read(adv7511->regmap_cec,
  40                         ADV7511_REG_CEC_TX_ENABLE + offset, &val))
  41                 return;
  42
  43         if ((val & 0x01) == 0)
  44                 return;
  45
  46         if (tx_raw_status & ADV7511_INT1_CEC_TX_ARBIT_LOST) {
  47                 cec_transmit_attempt_done(adv7511->cec_adap,
  48                                           CEC_TX_STATUS_ARB_LOST);
  49                 return;
  50         }
  51         if (tx_raw_status & ADV7511_INT1_CEC_TX_RETRY_TIMEOUT) {
  52                 u8 status;
  53                 u8 err_cnt = 0;
  54                 u8 nack_cnt = 0;
  55                 u8 low_drive_cnt = 0;
  56                 unsigned int cnt;
  57
  58                 /*
  59                  * We set this status bit since this hardware performs
  60                  * retransmissions.
  61                  */
  62                 status = CEC_TX_STATUS_MAX_RETRIES;
  63                 if (regmap_read(adv7511->regmap_cec,
  64                             ADV7511_REG_CEC_TX_LOW_DRV_CNT + offset, &cnt)) {
  65                         err_cnt = 1;
  66                         status |= CEC_TX_STATUS_ERROR;
  67                 } else {
  68                         nack_cnt = cnt & 0xf;
  69                         if (nack_cnt)
  70                                 status |= CEC_TX_STATUS_NACK;
  71                         low_drive_cnt = cnt >> 4;
  72                         if (low_drive_cnt)
  73                                 status |= CEC_TX_STATUS_LOW_DRIVE;
  74                 }
  75                 cec_transmit_done(adv7511->cec_adap, status,
  76                                   0, nack_cnt, low_drive_cnt, err_cnt);
  77                 return;
  78         }
  79         if (tx_raw_status & ADV7511_INT1_CEC_TX_READY) {
  80                 cec_transmit_attempt_done(adv7511->cec_adap, CEC_TX_STATUS_OK);
  81                 return;
  82         }
  83 }
  84
  85 static void adv7511_cec_rx(struct adv7511 *adv7511, int rx_buf)
  86 {
  87         unsigned int offset = adv7511->info->reg_cec_offset;
  88         struct cec_msg msg = {};
  89         unsigned int len;
  90         unsigned int val;
  91         u8 i;
  92
  93         if (regmap_read(adv7511->regmap_cec,
  94                         ADV7511_REG_CEC_RX_FRAME_LEN[rx_buf] + offset, &len))
  95                 return;
  96
  97         msg.len = len & 0x1f;
  98
  99         if (msg.len > 16)
 100                 msg.len = 16;
 101
 102         if (!msg.len)
 103                 return;
 104
 105         for (i = 0; i < msg.len; i++) {
 106                 regmap_read(adv7511->regmap_cec,
 107                             i + ADV7511_REG_CEC_RX_FRAME_HDR[rx_buf] + offset,
 108                             &val);
 109                 msg.msg[i] = val;
 110         }
 111
 112         /* Toggle RX Ready Clear bit to re-enable this RX buffer */
 113         regmap_update_bits(adv7511->regmap_cec,
 114                            ADV7511_REG_CEC_RX_BUFFERS + offset, BIT(rx_buf),
 115                            BIT(rx_buf));
 116         regmap_update_bits(adv7511->regmap_cec,
 117                            ADV7511_REG_CEC_RX_BUFFERS + offset, BIT(rx_buf), 0);
 118
 119         cec_received_msg(adv7511->cec_adap, &msg);
 120 }
 121
 122 void adv7511_cec_irq_process(struct adv7511 *adv7511, unsigned int irq1)
 123 {
 124         unsigned int offset = adv7511->info->reg_cec_offset;
 125         const u32 irq_tx_mask = ADV7511_INT1_CEC_TX_READY |
 126                                 ADV7511_INT1_CEC_TX_ARBIT_LOST |
 127                                 ADV7511_INT1_CEC_TX_RETRY_TIMEOUT;
 128         const u32 irq_rx_mask = ADV7511_INT1_CEC_RX_READY1 |
 129                                 ADV7511_INT1_CEC_RX_READY2 |
 130                                 ADV7511_INT1_CEC_RX_READY3;
 131         unsigned int rx_status;
 132         int rx_order[3] = { -1, -1, -1 };
 133         int i;
 134
 135         if (irq1 & irq_tx_mask)
 136                 adv_cec_tx_raw_status(adv7511, irq1);
 137
 138         if (!(irq1 & irq_rx_mask))
 139                 return;
 140
 141         if (regmap_read(adv7511->regmap_cec,
 142                         ADV7511_REG_CEC_RX_STATUS + offset, &rx_status))
 143                 return;
 144
 145         /*
 146          * ADV7511_REG_CEC_RX_STATUS[5:0] contains the reception order of RX
 147          * buffers 0, 1, and 2 in bits [1:0], [3:2], and [5:4] respectively.
 148          * The values are to be interpreted as follows:
 149          *
 150          *   0 = buffer unused
 151          *   1 = buffer contains oldest received frame (if applicable)
 152          *   2 = buffer contains second oldest received frame (if applicable)
 153          *   3 = buffer contains third oldest received frame (if applicable)
 154          *
 155          * Fill rx_order with the sequence of RX buffer indices to
 156          * read from in order, where -1 indicates that there are no
 157          * more buffers to process.
 158          */
 159         for (i = 0; i < 3; i++) {
 160                 unsigned int timestamp = (rx_status >> (2 * i)) & 0x3;
 161
 162                 if (timestamp)
 163                         rx_order[timestamp - 1] = i;
 164         }
 165
 166         /* Read CEC RX buffers in the appropriate order as prescribed above */
 167         for (i = 0; i < 3; i++) {
 168                 int rx_buf = rx_order[i];
 169
 170                 if (rx_buf < 0)
 171                         break;
 172
 173                 adv7511_cec_rx(adv7511, rx_buf);
 174         }
 175 }
 176
 177 static int adv7511_cec_adap_enable(struct cec_adapter *adap, bool enable)
 178 {
 179         struct adv7511 *adv7511 = cec_get_drvdata(adap);
 180         unsigned int offset = adv7511->info->reg_cec_offset;
 181
 182         if (adv7511->i2c_cec == NULL)
 183                 return -EIO;
 184
 185         if (!adv7511->cec_enabled_adap && enable) {
 186                 /* power up cec section */
 187                 regmap_update_bits(adv7511->regmap_cec,
 188                                    ADV7511_REG_CEC_CLK_DIV + offset,
 189                                    0x03, 0x01);
 190                 /* non-legacy mode and clear all rx buffers */
 191                 regmap_write(adv7511->regmap_cec,
 192                              ADV7511_REG_CEC_RX_BUFFERS + offset, 0x0f);
 193                 regmap_write(adv7511->regmap_cec,
 194                              ADV7511_REG_CEC_RX_BUFFERS + offset, 0x08);
 195                 /* initially disable tx */
 196                 regmap_update_bits(adv7511->regmap_cec,
 197                                    ADV7511_REG_CEC_TX_ENABLE + offset, 1, 0);
 198                 /* enabled irqs: */
 199                 /* tx: ready */
 200                 /* tx: arbitration lost */
 201                 /* tx: retry timeout */
 202                 /* rx: ready 1-3 */
 203                 regmap_update_bits(adv7511->regmap,
 204                                    ADV7511_REG_INT_ENABLE(1), 0x3f,
 205                                    ADV7511_INT1_CEC_MASK);
 206         } else if (adv7511->cec_enabled_adap && !enable) {
 207                 regmap_update_bits(adv7511->regmap,
 208                                    ADV7511_REG_INT_ENABLE(1), 0x3f, 0);
 209                 /* disable address mask 1-3 */
 210                 regmap_update_bits(adv7511->regmap_cec,
 211                                    ADV7511_REG_CEC_LOG_ADDR_MASK + offset,
 212                                    0x70, 0x00);
 213                 /* power down cec section */
 214                 regmap_update_bits(adv7511->regmap_cec,
 215                                    ADV7511_REG_CEC_CLK_DIV + offset,
 216                                    0x03, 0x00);
 217                 adv7511->cec_valid_addrs = 0;
 218         }
 219         adv7511->cec_enabled_adap = enable;
 220         return 0;
 221 }
 222
 223 static int adv7511_cec_adap_log_addr(struct cec_adapter *adap, u8 addr)
 224 {
 225         struct adv7511 *adv7511 = cec_get_drvdata(adap);
 226         unsigned int offset = adv7511->info->reg_cec_offset;
 227         unsigned int i, free_idx = ADV7511_MAX_ADDRS;
 228
 229         if (!adv7511->cec_enabled_adap)
 230                 return addr == CEC_LOG_ADDR_INVALID ? 0 : -EIO;
 231
 232         if (addr == CEC_LOG_ADDR_INVALID) {
 233                 regmap_update_bits(adv7511->regmap_cec,
 234                                    ADV7511_REG_CEC_LOG_ADDR_MASK + offset,
 235                                    0x70, 0);
 236                 adv7511->cec_valid_addrs = 0;
 237                 return 0;
 238         }
 239
 240         for (i = 0; i < ADV7511_MAX_ADDRS; i++) {
 241                 bool is_valid = adv7511->cec_valid_addrs & (1 << i);
 242
 243                 if (free_idx == ADV7511_MAX_ADDRS && !is_valid)
 244                         free_idx = i;
 245                 if (is_valid && adv7511->cec_addr[i] == addr)
 246                         return 0;
 247         }
 248         if (i == ADV7511_MAX_ADDRS) {
 249                 i = free_idx;
 250                 if (i == ADV7511_MAX_ADDRS)
 251                         return -ENXIO;
 252         }
 253         adv7511->cec_addr[i] = addr;
 254         adv7511->cec_valid_addrs |= 1 << i;
 255
 256         switch (i) {
 257         case 0:
 258                 /* enable address mask 0 */
 259                 regmap_update_bits(adv7511->regmap_cec,
 260                                    ADV7511_REG_CEC_LOG_ADDR_MASK + offset,
 261                                    0x10, 0x10);
 262                 /* set address for mask 0 */
 263                 regmap_update_bits(adv7511->regmap_cec,
 264                                    ADV7511_REG_CEC_LOG_ADDR_0_1 + offset,
 265                                    0x0f, addr);
 266                 break;
 267         case 1:
 268                 /* enable address mask 1 */
 269                 regmap_update_bits(adv7511->regmap_cec,
 270                                    ADV7511_REG_CEC_LOG_ADDR_MASK + offset,
 271                                    0x20, 0x20);
 272                 /* set address for mask 1 */
 273                 regmap_update_bits(adv7511->regmap_cec,
 274                                    ADV7511_REG_CEC_LOG_ADDR_0_1 + offset,
 275                                    0xf0, addr << 4);
 276                 break;
 277         case 2:
 278                 /* enable address mask 2 */
 279                 regmap_update_bits(adv7511->regmap_cec,
 280                                    ADV7511_REG_CEC_LOG_ADDR_MASK + offset,
 281                                    0x40, 0x40);
 282                 /* set address for mask 1 */
 283                 regmap_update_bits(adv7511->regmap_cec,
 284                                    ADV7511_REG_CEC_LOG_ADDR_2 + offset,
 285                                    0x0f, addr);
 286                 break;
 287         }
 288         return 0;
 289 }
 290
 291 static int adv7511_cec_adap_transmit(struct cec_adapter *adap, u8 attempts,
 292                                      u32 signal_free_time, struct cec_msg *msg)
 293 {
 294         struct adv7511 *adv7511 = cec_get_drvdata(adap);
 295         unsigned int offset = adv7511->info->reg_cec_offset;
 296         u8 len = msg->len;
 297         unsigned int i;
 298
 299         /*
 300          * The number of retries is the number of attempts - 1, but retry
 301          * at least once. It's not clear if a value of 0 is allowed, so
 302          * let's do at least one retry.
 303          */
 304         regmap_update_bits(adv7511->regmap_cec,
 305                            ADV7511_REG_CEC_TX_RETRY + offset,
 306                            0x70, max(1, attempts - 1) << 4);
 307
 308         /* blocking, clear cec tx irq status */
 309         regmap_update_bits(adv7511->regmap, ADV7511_REG_INT(1), 0x38, 0x38);
 310
 311         /* write data */
 312         for (i = 0; i < len; i++)
 313                 regmap_write(adv7511->regmap_cec,
 314                              i + ADV7511_REG_CEC_TX_FRAME_HDR + offset,
 315                              msg->msg[i]);
 316
 317         /* set length (data + header) */
 318         regmap_write(adv7511->regmap_cec,
 319                      ADV7511_REG_CEC_TX_FRAME_LEN + offset, len);
 320         /* start transmit, enable tx */
 321         regmap_write(adv7511->regmap_cec,
 322                      ADV7511_REG_CEC_TX_ENABLE + offset, 0x01);
 323         return 0;
 324 }
 325
 326 static const struct cec_adap_ops adv7511_cec_adap_ops = {
 327         .adap_enable = adv7511_cec_adap_enable,
 328         .adap_log_addr = adv7511_cec_adap_log_addr,
 329         .adap_transmit = adv7511_cec_adap_transmit,
 330 };
 331
 332 static int adv7511_cec_parse_dt(struct device *dev, struct adv7511 *adv7511)
 333 {
 334         adv7511->cec_clk = devm_clk_get(dev, "cec");
 335         if (IS_ERR(adv7511->cec_clk)) {
 336                 int ret = PTR_ERR(adv7511->cec_clk);
 337
 338                 adv7511->cec_clk = NULL;
 339                 return ret;
 340         }
 341         clk_prepare_enable(adv7511->cec_clk);
 342         adv7511->cec_clk_freq = clk_get_rate(adv7511->cec_clk);
 343         return 0;
 344 }
 345
 346 int adv7511_cec_init(struct device *dev, struct adv7511 *adv7511)
 347 {
 348         unsigned int offset = adv7511->info->reg_cec_offset;
 349         int ret = adv7511_cec_parse_dt(dev, adv7511);
 350
 351         if (ret)
 352                 goto err_cec_parse_dt;
 353
 354         adv7511->cec_adap = cec_allocate_adapter(&adv7511_cec_adap_ops,
 355                 adv7511, dev_name(dev), CEC_CAP_DEFAULTS, ADV7511_MAX_ADDRS);
 356         if (IS_ERR(adv7511->cec_adap)) {
 357                 ret = PTR_ERR(adv7511->cec_adap);
 358                 goto err_cec_alloc;
 359         }
 360
 361         regmap_write(adv7511->regmap, ADV7511_REG_CEC_CTRL, 0);
 362         /* cec soft reset */
 363         regmap_write(adv7511->regmap_cec,
 364                      ADV7511_REG_CEC_SOFT_RESET + offset, 0x01);
 365         regmap_write(adv7511->regmap_cec,
 366                      ADV7511_REG_CEC_SOFT_RESET + offset, 0x00);
 367
 368         /* non-legacy mode - use all three RX buffers */
 369         regmap_write(adv7511->regmap_cec,
 370                      ADV7511_REG_CEC_RX_BUFFERS + offset, 0x08);
 371
 372         regmap_write(adv7511->regmap_cec,
 373                      ADV7511_REG_CEC_CLK_DIV + offset,
 374                      ((adv7511->cec_clk_freq / 750000) - 1) << 2);
 375
 376         ret = cec_register_adapter(adv7511->cec_adap, dev);
 377         if (ret)
 378                 goto err_cec_register;
 379         return 0;
 380
 381 err_cec_register:
 382         cec_delete_adapter(adv7511->cec_adap);
 383         adv7511->cec_adap = NULL;
 384 err_cec_alloc:
 385         dev_info(dev, "Initializing CEC failed with error %d, disabling CEC\n",
 386                  ret);
 387 err_cec_parse_dt:
 388         regmap_write(adv7511->regmap, ADV7511_REG_CEC_CTRL,
 389                      ADV7511_CEC_CTRL_POWER_DOWN);
 390         return ret == -EPROBE_DEFER ? ret : 0;
 391 }