drm/i2c/tda9950.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  TDA9950 Consumer Electronics Control driver
0004  *
0005  * The NXP TDA9950 implements the HDMI Consumer Electronics Control
0006  * interface.  The host interface is similar to a mailbox: the data
0007  * registers starting at REG_CDR0 are written to send a command to the
0008  * internal CPU, and replies are read from these registers.
0009  *
0010  * As the data registers represent a mailbox, they must be accessed
0011  * as a single I2C transaction.  See the TDA9950 data sheet for details.
0012  */
0013 #include <linux/delay.h>
0014 #include <linux/i2c.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/module.h>
0017 #include <linux/platform_data/tda9950.h>
0018 #include <linux/slab.h>
0019 #include <drm/drm_edid.h>
0020 #include <media/cec.h>
0021 #include <media/cec-notifier.h>
0022
0023 enum {
0024     REG_CSR = 0x00,
0025     CSR_BUSY = BIT(7),
0026     CSR_INT  = BIT(6),
0027     CSR_ERR  = BIT(5),
0028
0029     REG_CER = 0x01,
0030
0031     REG_CVR = 0x02,
0032
0033     REG_CCR = 0x03,
0034     CCR_RESET = BIT(7),
0035     CCR_ON    = BIT(6),
0036
0037     REG_ACKH = 0x04,
0038     REG_ACKL = 0x05,
0039
0040     REG_CCONR = 0x06,
0041     CCONR_ENABLE_ERROR = BIT(4),
0042     CCONR_RETRY_MASK = 7,
0043
0044     REG_CDR0 = 0x07,
0045
0046     CDR1_REQ = 0x00,
0047     CDR1_CNF = 0x01,
0048     CDR1_IND = 0x81,
0049     CDR1_ERR = 0x82,
0050     CDR1_IER = 0x83,
0051
0052     CDR2_CNF_SUCCESS    = 0x00,
0053     CDR2_CNF_OFF_STATE  = 0x80,
0054     CDR2_CNF_BAD_REQ    = 0x81,
0055     CDR2_CNF_CEC_ACCESS = 0x82,
0056     CDR2_CNF_ARB_ERROR  = 0x83,
0057     CDR2_CNF_BAD_TIMING = 0x84,
0058     CDR2_CNF_NACK_ADDR  = 0x85,
0059     CDR2_CNF_NACK_DATA  = 0x86,
0060 };
0061
0062 struct tda9950_priv {
0063     struct i2c_client *client;
0064     struct device *hdmi;
0065     struct cec_adapter *adap;
0066     struct tda9950_glue *glue;
0067     u16 addresses;
0068     struct cec_msg rx_msg;
0069     struct cec_notifier *notify;
0070     bool open;
0071 };
0072
0073 static int tda9950_write_range(struct i2c_client *client, u8 addr, u8 *p, int cnt)
0074 {
0075     struct i2c_msg msg;
0076     u8 buf[CEC_MAX_MSG_SIZE + 3];
0077     int ret;
0078
0079     if (WARN_ON(cnt > sizeof(buf) - 1))
0080         return -EINVAL;
0081
0082     buf[0] = addr;
0083     memcpy(buf + 1, p, cnt);
0084
0085     msg.addr = client->addr;
0086     msg.flags = 0;
0087     msg.len = cnt + 1;
0088     msg.buf = buf;
0089
0090     dev_dbg(&client->dev, "wr 0x%02x: %*ph\n", addr, cnt, p);
0091
0092     ret = i2c_transfer(client->adapter, &msg, 1);
0093     if (ret < 0)
0094         dev_err(&client->dev, "Error %d writing to cec:0x%x\n", ret, addr);
0095     return ret < 0 ? ret : 0;
0096 }
0097
0098 static void tda9950_write(struct i2c_client *client, u8 addr, u8 val)
0099 {
0100     tda9950_write_range(client, addr, &val, 1);
0101 }
0102
0103 static int tda9950_read_range(struct i2c_client *client, u8 addr, u8 *p, int cnt)
0104 {
0105     struct i2c_msg msg[2];
0106     int ret;
0107
0108     msg[0].addr = client->addr;
0109     msg[0].flags = 0;
0110     msg[0].len = 1;
0111     msg[0].buf = &addr;
0112     msg[1].addr = client->addr;
0113     msg[1].flags = I2C_M_RD;
0114     msg[1].len = cnt;
0115     msg[1].buf = p;
0116
0117     ret = i2c_transfer(client->adapter, msg, 2);
0118     if (ret < 0)
0119         dev_err(&client->dev, "Error %d reading from cec:0x%x\n", ret, addr);
0120
0121     dev_dbg(&client->dev, "rd 0x%02x: %*ph\n", addr, cnt, p);
0122
0123     return ret;
0124 }
0125
0126 static u8 tda9950_read(struct i2c_client *client, u8 addr)
0127 {
0128     int ret;
0129     u8 val;
0130
0131     ret = tda9950_read_range(client, addr, &val, 1);
0132     if (ret < 0)
0133         val = 0;
0134
0135     return val;
0136 }
0137
0138 static irqreturn_t tda9950_irq(int irq, void *data)
0139 {
0140     struct tda9950_priv *priv = data;
0141     unsigned int tx_status;
0142     u8 csr, cconr, buf[19];
0143     u8 arb_lost_cnt, nack_cnt, err_cnt;
0144
0145     if (!priv->open)
0146         return IRQ_NONE;
0147
0148     csr = tda9950_read(priv->client, REG_CSR);
0149     if (!(csr & CSR_INT))
0150         return IRQ_NONE;
0151
0152     cconr = tda9950_read(priv->client, REG_CCONR) & CCONR_RETRY_MASK;
0153
0154     tda9950_read_range(priv->client, REG_CDR0, buf, sizeof(buf));
0155
0156     /*
0157      * This should never happen: the data sheet says that there will
0158      * always be a valid message if the interrupt line is asserted.
0159      */
0160     if (buf[0] == 0) {
0161         dev_warn(&priv->client->dev, "interrupt pending, but no message?\n");
0162         return IRQ_NONE;
0163     }
0164
0165     switch (buf[1]) {
0166     case CDR1_CNF: /* transmit result */
0167         arb_lost_cnt = nack_cnt = err_cnt = 0;
0168         switch (buf[2]) {
0169         case CDR2_CNF_SUCCESS:
0170             tx_status = CEC_TX_STATUS_OK;
0171             break;
0172
0173         case CDR2_CNF_ARB_ERROR:
0174             tx_status = CEC_TX_STATUS_ARB_LOST;
0175             arb_lost_cnt = cconr;
0176             break;
0177
0178         case CDR2_CNF_NACK_ADDR:
0179             tx_status = CEC_TX_STATUS_NACK;
0180             nack_cnt = cconr;
0181             break;
0182
0183         default: /* some other error, refer to TDA9950 docs */
0184             dev_err(&priv->client->dev, "CNF reply error 0x%02x\n",
0185                 buf[2]);
0186             tx_status = CEC_TX_STATUS_ERROR;
0187             err_cnt = cconr;
0188             break;
0189         }
0190         /* TDA9950 executes all retries for us */
0191         if (tx_status != CEC_TX_STATUS_OK)
0192             tx_status |= CEC_TX_STATUS_MAX_RETRIES;
0193         cec_transmit_done(priv->adap, tx_status, arb_lost_cnt,
0194                   nack_cnt, 0, err_cnt);
0195         break;
0196
0197     case CDR1_IND:
0198         priv->rx_msg.len = buf[0] - 2;
0199         if (priv->rx_msg.len > CEC_MAX_MSG_SIZE)
0200             priv->rx_msg.len = CEC_MAX_MSG_SIZE;
0201
0202         memcpy(priv->rx_msg.msg, buf + 2, priv->rx_msg.len);
0203         cec_received_msg(priv->adap, &priv->rx_msg);
0204         break;
0205
0206     default: /* unknown */
0207         dev_err(&priv->client->dev, "unknown service id 0x%02x\n",
0208             buf[1]);
0209         break;
0210     }
0211
0212     return IRQ_HANDLED;
0213 }
0214
0215 static int tda9950_cec_transmit(struct cec_adapter *adap, u8 attempts,
0216                 u32 signal_free_time, struct cec_msg *msg)
0217 {
0218     struct tda9950_priv *priv = adap->priv;
0219     u8 buf[CEC_MAX_MSG_SIZE + 2];
0220
0221     buf[0] = 2 + msg->len;
0222     buf[1] = CDR1_REQ;
0223     memcpy(buf + 2, msg->msg, msg->len);
0224
0225     if (attempts > 5)
0226         attempts = 5;
0227
0228     tda9950_write(priv->client, REG_CCONR, attempts);
0229
0230     return tda9950_write_range(priv->client, REG_CDR0, buf, 2 + msg->len);
0231 }
0232
0233 static int tda9950_cec_adap_log_addr(struct cec_adapter *adap, u8 addr)
0234 {
0235     struct tda9950_priv *priv = adap->priv;
0236     u16 addresses;
0237     u8 buf[2];
0238
0239     if (addr == CEC_LOG_ADDR_INVALID)
0240         addresses = priv->addresses = 0;
0241     else
0242         addresses = priv->addresses |= BIT(addr);
0243
0244     /* TDA9950 doesn't want address 15 set */
0245     addresses &= 0x7fff;
0246     buf[0] = addresses >> 8;
0247     buf[1] = addresses;
0248
0249     return tda9950_write_range(priv->client, REG_ACKH, buf, 2);
0250 }
0251
0252 /*
0253  * When operating as part of the TDA998x, we need additional handling
0254  * to initialise and shut down the TDA9950 part of the device.  These
0255  * two hooks are provided to allow the TDA998x code to perform those
0256  * activities.
0257  */
0258 static int tda9950_glue_open(struct tda9950_priv *priv)
0259 {
0260     int ret = 0;
0261
0262     if (priv->glue && priv->glue->open)
0263         ret = priv->glue->open(priv->glue->data);
0264
0265     priv->open = true;
0266
0267     return ret;
0268 }
0269
0270 static void tda9950_glue_release(struct tda9950_priv *priv)
0271 {
0272     priv->open = false;
0273
0274     if (priv->glue && priv->glue->release)
0275         priv->glue->release(priv->glue->data);
0276 }
0277
0278 static int tda9950_open(struct tda9950_priv *priv)
0279 {
0280     struct i2c_client *client = priv->client;
0281     int ret;
0282
0283     ret = tda9950_glue_open(priv);
0284     if (ret)
0285         return ret;
0286
0287     /* Reset the TDA9950, and wait 250ms for it to recover */
0288     tda9950_write(client, REG_CCR, CCR_RESET);
0289     msleep(250);
0290
0291     tda9950_cec_adap_log_addr(priv->adap, CEC_LOG_ADDR_INVALID);
0292
0293     /* Start the command processor */
0294     tda9950_write(client, REG_CCR, CCR_ON);
0295
0296     return 0;
0297 }
0298
0299 static void tda9950_release(struct tda9950_priv *priv)
0300 {
0301     struct i2c_client *client = priv->client;
0302     int timeout = 50;
0303     u8 csr;
0304
0305     /* Stop the command processor */
0306     tda9950_write(client, REG_CCR, 0);
0307
0308     /* Wait up to .5s for it to signal non-busy */
0309     do {
0310         csr = tda9950_read(client, REG_CSR);
0311         if (!(csr & CSR_BUSY) || !--timeout)
0312             break;
0313         msleep(10);
0314     } while (1);
0315
0316     /* Warn the user that their IRQ may die if it's shared. */
0317     if (csr & CSR_BUSY)
0318         dev_warn(&client->dev, "command processor failed to stop, irq%d may die (csr=0x%02x)\n",
0319              client->irq, csr);
0320
0321     tda9950_glue_release(priv);
0322 }
0323
0324 static int tda9950_cec_adap_enable(struct cec_adapter *adap, bool enable)
0325 {
0326     struct tda9950_priv *priv = adap->priv;
0327
0328     if (!enable) {
0329         tda9950_release(priv);
0330         return 0;
0331     } else {
0332         return tda9950_open(priv);
0333     }
0334 }
0335
0336 static const struct cec_adap_ops tda9950_cec_ops = {
0337     .adap_enable = tda9950_cec_adap_enable,
0338     .adap_log_addr = tda9950_cec_adap_log_addr,
0339     .adap_transmit = tda9950_cec_transmit,
0340 };
0341
0342 /*
0343  * When operating as part of the TDA998x, we need to claim additional
0344  * resources.  These two hooks permit the management of those resources.
0345  */
0346 static void tda9950_devm_glue_exit(void *data)
0347 {
0348     struct tda9950_glue *glue = data;
0349
0350     if (glue && glue->exit)
0351         glue->exit(glue->data);
0352 }
0353
0354 static int tda9950_devm_glue_init(struct device *dev, struct tda9950_glue *glue)
0355 {
0356     int ret;
0357
0358     if (glue && glue->init) {
0359         ret = glue->init(glue->data);
0360         if (ret)
0361             return ret;
0362     }
0363
0364     ret = devm_add_action(dev, tda9950_devm_glue_exit, glue);
0365     if (ret)
0366         tda9950_devm_glue_exit(glue);
0367
0368     return ret;
0369 }
0370
0371 static void tda9950_cec_del(void *data)
0372 {
0373     struct tda9950_priv *priv = data;
0374
0375     cec_delete_adapter(priv->adap);
0376 }
0377
0378 static int tda9950_probe(struct i2c_client *client,
0379              const struct i2c_device_id *id)
0380 {
0381     struct tda9950_glue *glue = client->dev.platform_data;
0382     struct device *dev = &client->dev;
0383     struct tda9950_priv *priv;
0384     unsigned long irqflags;
0385     int ret;
0386     u8 cvr;
0387
0388     /*
0389      * We must have I2C functionality: our multi-byte accesses
0390      * must be performed as a single contiguous transaction.
0391      */
0392     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
0393         dev_err(&client->dev,
0394             "adapter does not support I2C functionality\n");
0395         return -ENXIO;
0396     }
0397
0398     /* We must have an interrupt to be functional. */
0399     if (client->irq <= 0) {
0400         dev_err(&client->dev, "driver requires an interrupt\n");
0401         return -ENXIO;
0402     }
0403
0404     priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0405     if (!priv)
0406         return -ENOMEM;
0407
0408     priv->client = client;
0409     priv->glue = glue;
0410
0411     i2c_set_clientdata(client, priv);
0412
0413     /*
0414      * If we're part of a TDA998x, we want the class devices to be
0415      * associated with the HDMI Tx so we have a tight relationship
0416      * between the HDMI interface and the CEC interface.
0417      */
0418     priv->hdmi = dev;
0419     if (glue && glue->parent)
0420         priv->hdmi = glue->parent;
0421
0422     priv->adap = cec_allocate_adapter(&tda9950_cec_ops, priv, "tda9950",
0423                       CEC_CAP_DEFAULTS |
0424                       CEC_CAP_CONNECTOR_INFO,
0425                       CEC_MAX_LOG_ADDRS);
0426     if (IS_ERR(priv->adap))
0427         return PTR_ERR(priv->adap);
0428
0429     ret = devm_add_action(dev, tda9950_cec_del, priv);
0430     if (ret) {
0431         cec_delete_adapter(priv->adap);
0432         return ret;
0433     }
0434
0435     ret = tda9950_devm_glue_init(dev, glue);
0436     if (ret)
0437         return ret;
0438
0439     ret = tda9950_glue_open(priv);
0440     if (ret)
0441         return ret;
0442
0443     cvr = tda9950_read(client, REG_CVR);
0444
0445     dev_info(&client->dev,
0446          "TDA9950 CEC interface, hardware version %u.%u\n",
0447          cvr >> 4, cvr & 15);
0448
0449     tda9950_glue_release(priv);
0450
0451     irqflags = IRQF_TRIGGER_FALLING;
0452     if (glue)
0453         irqflags = glue->irq_flags;
0454
0455     ret = devm_request_threaded_irq(dev, client->irq, NULL, tda9950_irq,
0456                     irqflags | IRQF_SHARED | IRQF_ONESHOT,
0457                     dev_name(&client->dev), priv);
0458     if (ret < 0)
0459         return ret;
0460
0461     priv->notify = cec_notifier_cec_adap_register(priv->hdmi, NULL,
0462                               priv->adap);
0463     if (!priv->notify)
0464         return -ENOMEM;
0465
0466     ret = cec_register_adapter(priv->adap, priv->hdmi);
0467     if (ret < 0) {
0468         cec_notifier_cec_adap_unregister(priv->notify, priv->adap);
0469         return ret;
0470     }
0471
0472     /*
0473      * CEC documentation says we must not call cec_delete_adapter
0474      * after a successful call to cec_register_adapter().
0475      */
0476     devm_remove_action(dev, tda9950_cec_del, priv);
0477
0478     return 0;
0479 }
0480
0481 static int tda9950_remove(struct i2c_client *client)
0482 {
0483     struct tda9950_priv *priv = i2c_get_clientdata(client);
0484
0485     cec_notifier_cec_adap_unregister(priv->notify, priv->adap);
0486     cec_unregister_adapter(priv->adap);
0487
0488     return 0;
0489 }
0490
0491 static struct i2c_device_id tda9950_ids[] = {
0492     { "tda9950", 0 },
0493     { },
0494 };
0495 MODULE_DEVICE_TABLE(i2c, tda9950_ids);
0496
0497 static struct i2c_driver tda9950_driver = {
0498     .probe = tda9950_probe,
0499     .remove = tda9950_remove,
0500     .driver = {
0501         .name = "tda9950",
0502     },
0503     .id_table = tda9950_ids,
0504 };
0505
0506 module_i2c_driver(tda9950_driver);
0507
0508 MODULE_AUTHOR("Russell King <rmk+kernel@armlinux.org.uk>");
0509 MODULE_DESCRIPTION("TDA9950/TDA998x Consumer Electronics Control Driver");
0510 MODULE_LICENSE("GPL v2");