usb/dvb-usb-v2/zd1301.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * ZyDAS ZD1301 driver (USB interface)
0004  *
0005  * Copyright (C) 2015 Antti Palosaari <crope@iki.fi>
0006  */
0007
0008 #include "dvb_usb.h"
0009 #include "zd1301_demod.h"
0010 #include "mt2060.h"
0011 #include <linux/i2c.h>
0012 #include <linux/platform_device.h>
0013
0014 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0015
0016 struct zd1301_dev {
0017     #define BUF_LEN 8
0018     u8 buf[BUF_LEN]; /* bulk USB control message */
0019     struct zd1301_demod_platform_data demod_pdata;
0020     struct mt2060_platform_data mt2060_pdata;
0021     struct platform_device *platform_device_demod;
0022     struct i2c_client *i2c_client_tuner;
0023 };
0024
0025 static int zd1301_ctrl_msg(struct dvb_usb_device *d, const u8 *wbuf,
0026                unsigned int wlen, u8 *rbuf, unsigned int rlen)
0027 {
0028     struct zd1301_dev *dev = d_to_priv(d);
0029     struct usb_interface *intf = d->intf;
0030     int ret, actual_length;
0031
0032     mutex_lock(&d->usb_mutex);
0033
0034     memcpy(&dev->buf, wbuf, wlen);
0035
0036     dev_dbg(&intf->dev, ">>> %*ph\n", wlen, dev->buf);
0037
0038     ret = usb_bulk_msg(d->udev, usb_sndbulkpipe(d->udev, 0x04), dev->buf,
0039                wlen, &actual_length, 1000);
0040     if (ret) {
0041         dev_err(&intf->dev, "1st usb_bulk_msg() failed %d\n", ret);
0042         goto err_mutex_unlock;
0043     }
0044
0045     if (rlen) {
0046         ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev, 0x83),
0047                    dev->buf, rlen, &actual_length, 1000);
0048         if (ret) {
0049             dev_err(&intf->dev,
0050                 "2nd usb_bulk_msg() failed %d\n", ret);
0051             goto err_mutex_unlock;
0052         }
0053
0054         dev_dbg(&intf->dev, "<<< %*ph\n", actual_length, dev->buf);
0055
0056         if (actual_length != rlen) {
0057             /*
0058              * Chip replies often with 3 byte len stub. On that case
0059              * we have to query new reply.
0060              */
0061             dev_dbg(&intf->dev, "repeating reply message\n");
0062
0063             ret = usb_bulk_msg(d->udev,
0064                        usb_rcvbulkpipe(d->udev, 0x83),
0065                        dev->buf, rlen, &actual_length,
0066                        1000);
0067             if (ret) {
0068                 dev_err(&intf->dev,
0069                     "3rd usb_bulk_msg() failed %d\n", ret);
0070                 goto err_mutex_unlock;
0071             }
0072
0073             dev_dbg(&intf->dev,
0074                 "<<< %*ph\n", actual_length, dev->buf);
0075         }
0076
0077         memcpy(rbuf, dev->buf, rlen);
0078     }
0079
0080 err_mutex_unlock:
0081     mutex_unlock(&d->usb_mutex);
0082     return ret;
0083 }
0084
0085 static int zd1301_demod_wreg(void *reg_priv, u16 reg, u8 val)
0086 {
0087     struct dvb_usb_device *d = reg_priv;
0088     struct usb_interface *intf = d->intf;
0089     int ret;
0090     u8 buf[7] = {0x07, 0x00, 0x03, 0x01,
0091              (reg >> 0) & 0xff, (reg >> 8) & 0xff, val};
0092
0093     ret = zd1301_ctrl_msg(d, buf, 7, NULL, 0);
0094     if (ret)
0095         goto err;
0096
0097     return 0;
0098 err:
0099     dev_dbg(&intf->dev, "failed=%d\n", ret);
0100     return ret;
0101 }
0102
0103 static int zd1301_demod_rreg(void *reg_priv, u16 reg, u8 *val)
0104 {
0105     struct dvb_usb_device *d = reg_priv;
0106     struct usb_interface *intf = d->intf;
0107     int ret;
0108     u8 buf[7] = {0x07, 0x00, 0x04, 0x01,
0109              (reg >> 0) & 0xff, (reg >> 8) & 0xff, 0};
0110
0111     ret = zd1301_ctrl_msg(d, buf, 7, buf, 7);
0112     if (ret)
0113         goto err;
0114
0115     *val = buf[6];
0116
0117     return 0;
0118 err:
0119     dev_dbg(&intf->dev, "failed=%d\n", ret);
0120     return ret;
0121 }
0122
0123 static int zd1301_frontend_attach(struct dvb_usb_adapter *adap)
0124 {
0125     struct dvb_usb_device *d = adap_to_d(adap);
0126     struct zd1301_dev *dev = adap_to_priv(adap);
0127     struct usb_interface *intf = d->intf;
0128     struct platform_device *pdev;
0129     struct i2c_client *client;
0130     struct i2c_board_info board_info;
0131     struct i2c_adapter *adapter;
0132     struct dvb_frontend *frontend;
0133     int ret;
0134
0135     dev_dbg(&intf->dev, "\n");
0136
0137     /* Add platform demod */
0138     dev->demod_pdata.reg_priv = d;
0139     dev->demod_pdata.reg_read = zd1301_demod_rreg;
0140     dev->demod_pdata.reg_write = zd1301_demod_wreg;
0141     request_module("%s", "zd1301_demod");
0142     pdev = platform_device_register_data(&intf->dev,
0143                          "zd1301_demod",
0144                          PLATFORM_DEVID_AUTO,
0145                          &dev->demod_pdata,
0146                          sizeof(dev->demod_pdata));
0147     if (IS_ERR(pdev)) {
0148         ret = PTR_ERR(pdev);
0149         goto err;
0150     }
0151     if (!pdev->dev.driver) {
0152         ret = -ENODEV;
0153         goto err_platform_device_unregister;
0154     }
0155     if (!try_module_get(pdev->dev.driver->owner)) {
0156         ret = -ENODEV;
0157         goto err_platform_device_unregister;
0158     }
0159
0160     adapter = zd1301_demod_get_i2c_adapter(pdev);
0161     frontend = zd1301_demod_get_dvb_frontend(pdev);
0162     if (!adapter || !frontend) {
0163         ret = -ENODEV;
0164         goto err_module_put_demod;
0165     }
0166
0167     /* Add I2C tuner */
0168     dev->mt2060_pdata.i2c_write_max = 9;
0169     dev->mt2060_pdata.dvb_frontend = frontend;
0170     memset(&board_info, 0, sizeof(board_info));
0171     strscpy(board_info.type, "mt2060", I2C_NAME_SIZE);
0172     board_info.addr = 0x60;
0173     board_info.platform_data = &dev->mt2060_pdata;
0174     request_module("%s", "mt2060");
0175     client = i2c_new_client_device(adapter, &board_info);
0176     if (!i2c_client_has_driver(client)) {
0177         ret = -ENODEV;
0178         goto err_module_put_demod;
0179     }
0180     if (!try_module_get(client->dev.driver->owner)) {
0181         ret = -ENODEV;
0182         goto err_i2c_unregister_device;
0183     }
0184
0185     dev->platform_device_demod = pdev;
0186     dev->i2c_client_tuner = client;
0187     adap->fe[0] = frontend;
0188
0189     return 0;
0190 err_i2c_unregister_device:
0191     i2c_unregister_device(client);
0192 err_module_put_demod:
0193     module_put(pdev->dev.driver->owner);
0194 err_platform_device_unregister:
0195     platform_device_unregister(pdev);
0196 err:
0197     dev_dbg(&intf->dev, "failed=%d\n", ret);
0198     return ret;
0199 }
0200
0201 static int zd1301_frontend_detach(struct dvb_usb_adapter *adap)
0202 {
0203     struct dvb_usb_device *d = adap_to_d(adap);
0204     struct zd1301_dev *dev = d_to_priv(d);
0205     struct usb_interface *intf = d->intf;
0206     struct platform_device *pdev;
0207     struct i2c_client *client;
0208
0209     dev_dbg(&intf->dev, "\n");
0210
0211     client = dev->i2c_client_tuner;
0212     pdev = dev->platform_device_demod;
0213
0214     /* Remove I2C tuner */
0215     if (client) {
0216         module_put(client->dev.driver->owner);
0217         i2c_unregister_device(client);
0218     }
0219
0220     /* Remove platform demod */
0221     if (pdev) {
0222         module_put(pdev->dev.driver->owner);
0223         platform_device_unregister(pdev);
0224     }
0225
0226     return 0;
0227 }
0228
0229 static int zd1301_streaming_ctrl(struct dvb_frontend *fe, int onoff)
0230 {
0231     struct dvb_usb_device *d = fe_to_d(fe);
0232     struct usb_interface *intf = d->intf;
0233     int ret;
0234     u8 buf[3] = {0x03, 0x00, onoff ? 0x07 : 0x08};
0235
0236     dev_dbg(&intf->dev, "onoff=%d\n", onoff);
0237
0238     ret = zd1301_ctrl_msg(d, buf, 3, NULL, 0);
0239     if (ret)
0240         goto err;
0241
0242     return 0;
0243 err:
0244     dev_dbg(&intf->dev, "failed=%d\n", ret);
0245     return ret;
0246 }
0247
0248 static const struct dvb_usb_device_properties zd1301_props = {
0249     .driver_name = KBUILD_MODNAME,
0250     .owner = THIS_MODULE,
0251     .adapter_nr = adapter_nr,
0252     .size_of_priv = sizeof(struct zd1301_dev),
0253
0254     .frontend_attach = zd1301_frontend_attach,
0255     .frontend_detach = zd1301_frontend_detach,
0256     .streaming_ctrl  = zd1301_streaming_ctrl,
0257
0258     .num_adapters = 1,
0259     .adapter = {
0260         {
0261             .stream = DVB_USB_STREAM_BULK(0x81, 6, 21 * 188),
0262         },
0263     },
0264 };
0265
0266 static const struct usb_device_id zd1301_id_table[] = {
0267     {DVB_USB_DEVICE(USB_VID_ZYDAS, 0x13a1, &zd1301_props,
0268             "ZyDAS ZD1301 reference design", NULL)},
0269     {}
0270 };
0271 MODULE_DEVICE_TABLE(usb, zd1301_id_table);
0272
0273 /* Usb specific object needed to register this driver with the usb subsystem */
0274 static struct usb_driver zd1301_usb_driver = {
0275     .name = KBUILD_MODNAME,
0276     .id_table = zd1301_id_table,
0277     .probe = dvb_usbv2_probe,
0278     .disconnect = dvb_usbv2_disconnect,
0279     .suspend = dvb_usbv2_suspend,
0280     .resume = dvb_usbv2_resume,
0281     .reset_resume = dvb_usbv2_reset_resume,
0282     .no_dynamic_id = 1,
0283     .soft_unbind = 1,
0284 };
0285 module_usb_driver(zd1301_usb_driver);
0286
0287 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
0288 MODULE_DESCRIPTION("ZyDAS ZD1301 driver");
0289 MODULE_LICENSE("GPL");