1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ZyDAS ZD1301 driver (USB interface) 4 * 5 * Copyright (C) 2015 Antti Palosaari <crope@iki.fi> 6 */ 7 8 #include "dvb_usb.h" 9 #include "zd1301_demod.h" 10 #include "mt2060.h" 11 #include <linux/i2c.h> 12 #include <linux/platform_device.h> 13 14 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 15 16 struct zd1301_dev { 17 #define BUF_LEN 8 18 u8 buf[BUF_LEN]; /* bulk USB control message */ 19 struct zd1301_demod_platform_data demod_pdata; 20 struct mt2060_platform_data mt2060_pdata; 21 struct platform_device *platform_device_demod; 22 struct i2c_client *i2c_client_tuner; 23 }; 24 25 static int zd1301_ctrl_msg(struct dvb_usb_device *d, const u8 *wbuf, 26 unsigned int wlen, u8 *rbuf, unsigned int rlen) 27 { 28 struct zd1301_dev *dev = d_to_priv(d); 29 struct usb_interface *intf = d->intf; 30 int ret, actual_length; 31 32 mutex_lock(&d->usb_mutex); 33 34 memcpy(&dev->buf, wbuf, wlen); 35 36 dev_dbg(&intf->dev, ">>> %*ph\n", wlen, dev->buf); 37 38 ret = usb_bulk_msg(d->udev, usb_sndbulkpipe(d->udev, 0x04), dev->buf, 39 wlen, &actual_length, 1000); 40 if (ret) { 41 dev_err(&intf->dev, "1st usb_bulk_msg() failed %d\n", ret); 42 goto err_mutex_unlock; 43 } 44 45 if (rlen) { 46 ret = usb_bulk_msg(d->udev, usb_rcvbulkpipe(d->udev, 0x83), 47 dev->buf, rlen, &actual_length, 1000); 48 if (ret) { 49 dev_err(&intf->dev, 50 "2nd usb_bulk_msg() failed %d\n", ret); 51 goto err_mutex_unlock; 52 } 53 54 dev_dbg(&intf->dev, "<<< %*ph\n", actual_length, dev->buf); 55 56 if (actual_length != rlen) { 57 /* 58 * Chip replies often with 3 byte len stub. On that case 59 * we have to query new reply. 60 */ 61 dev_dbg(&intf->dev, "repeating reply message\n"); 62 63 ret = usb_bulk_msg(d->udev, 64 usb_rcvbulkpipe(d->udev, 0x83), 65 dev->buf, rlen, &actual_length, 66 1000); 67 if (ret) { 68 dev_err(&intf->dev, 69 "3rd usb_bulk_msg() failed %d\n", ret); 70 goto err_mutex_unlock; 71 } 72 73 dev_dbg(&intf->dev, 74 "<<< %*ph\n", actual_length, dev->buf); 75 } 76 77 memcpy(rbuf, dev->buf, rlen); 78 } 79 80 err_mutex_unlock: 81 mutex_unlock(&d->usb_mutex); 82 return ret; 83 } 84 85 static int zd1301_demod_wreg(void *reg_priv, u16 reg, u8 val) 86 { 87 struct dvb_usb_device *d = reg_priv; 88 struct usb_interface *intf = d->intf; 89 int ret; 90 u8 buf[7] = {0x07, 0x00, 0x03, 0x01, 91 (reg >> 0) & 0xff, (reg >> 8) & 0xff, val}; 92 93 ret = zd1301_ctrl_msg(d, buf, 7, NULL, 0); 94 if (ret) 95 goto err; 96 97 return 0; 98 err: 99 dev_dbg(&intf->dev, "failed=%d\n", ret); 100 return ret; 101 } 102 103 static int zd1301_demod_rreg(void *reg_priv, u16 reg, u8 *val) 104 { 105 struct dvb_usb_device *d = reg_priv; 106 struct usb_interface *intf = d->intf; 107 int ret; 108 u8 buf[7] = {0x07, 0x00, 0x04, 0x01, 109 (reg >> 0) & 0xff, (reg >> 8) & 0xff, 0}; 110 111 ret = zd1301_ctrl_msg(d, buf, 7, buf, 7); 112 if (ret) 113 goto err; 114 115 *val = buf[6]; 116 117 return 0; 118 err: 119 dev_dbg(&intf->dev, "failed=%d\n", ret); 120 return ret; 121 } 122 123 static int zd1301_frontend_attach(struct dvb_usb_adapter *adap) 124 { 125 struct dvb_usb_device *d = adap_to_d(adap); 126 struct zd1301_dev *dev = adap_to_priv(adap); 127 struct usb_interface *intf = d->intf; 128 struct platform_device *pdev; 129 struct i2c_client *client; 130 struct i2c_board_info board_info; 131 struct i2c_adapter *adapter; 132 struct dvb_frontend *frontend; 133 int ret; 134 135 dev_dbg(&intf->dev, "\n"); 136 137 /* Add platform demod */ 138 dev->demod_pdata.reg_priv = d; 139 dev->demod_pdata.reg_read = zd1301_demod_rreg; 140 dev->demod_pdata.reg_write = zd1301_demod_wreg; 141 request_module("%s", "zd1301_demod"); 142 pdev = platform_device_register_data(&intf->dev, 143 "zd1301_demod", 144 PLATFORM_DEVID_AUTO, 145 &dev->demod_pdata, 146 sizeof(dev->demod_pdata)); 147 if (IS_ERR(pdev)) { 148 ret = PTR_ERR(pdev); 149 goto err; 150 } 151 if (!pdev->dev.driver) { 152 ret = -ENODEV; 153 goto err_platform_device_unregister; 154 } 155 if (!try_module_get(pdev->dev.driver->owner)) { 156 ret = -ENODEV; 157 goto err_platform_device_unregister; 158 } 159 160 adapter = zd1301_demod_get_i2c_adapter(pdev); 161 frontend = zd1301_demod_get_dvb_frontend(pdev); 162 if (!adapter || !frontend) { 163 ret = -ENODEV; 164 goto err_module_put_demod; 165 } 166 167 /* Add I2C tuner */ 168 dev->mt2060_pdata.i2c_write_max = 9; 169 dev->mt2060_pdata.dvb_frontend = frontend; 170 memset(&board_info, 0, sizeof(board_info)); 171 strscpy(board_info.type, "mt2060", I2C_NAME_SIZE); 172 board_info.addr = 0x60; 173 board_info.platform_data = &dev->mt2060_pdata; 174 request_module("%s", "mt2060"); 175 client = i2c_new_client_device(adapter, &board_info); 176 if (!i2c_client_has_driver(client)) { 177 ret = -ENODEV; 178 goto err_module_put_demod; 179 } 180 if (!try_module_get(client->dev.driver->owner)) { 181 ret = -ENODEV; 182 goto err_i2c_unregister_device; 183 } 184 185 dev->platform_device_demod = pdev; 186 dev->i2c_client_tuner = client; 187 adap->fe[0] = frontend; 188 189 return 0; 190 err_i2c_unregister_device: 191 i2c_unregister_device(client); 192 err_module_put_demod: 193 module_put(pdev->dev.driver->owner); 194 err_platform_device_unregister: 195 platform_device_unregister(pdev); 196 err: 197 dev_dbg(&intf->dev, "failed=%d\n", ret); 198 return ret; 199 } 200 201 static int zd1301_frontend_detach(struct dvb_usb_adapter *adap) 202 { 203 struct dvb_usb_device *d = adap_to_d(adap); 204 struct zd1301_dev *dev = d_to_priv(d); 205 struct usb_interface *intf = d->intf; 206 struct platform_device *pdev; 207 struct i2c_client *client; 208 209 dev_dbg(&intf->dev, "\n"); 210 211 client = dev->i2c_client_tuner; 212 pdev = dev->platform_device_demod; 213 214 /* Remove I2C tuner */ 215 if (client) { 216 module_put(client->dev.driver->owner); 217 i2c_unregister_device(client); 218 } 219 220 /* Remove platform demod */ 221 if (pdev) { 222 module_put(pdev->dev.driver->owner); 223 platform_device_unregister(pdev); 224 } 225 226 return 0; 227 } 228 229 static int zd1301_streaming_ctrl(struct dvb_frontend *fe, int onoff) 230 { 231 struct dvb_usb_device *d = fe_to_d(fe); 232 struct usb_interface *intf = d->intf; 233 int ret; 234 u8 buf[3] = {0x03, 0x00, onoff ? 0x07 : 0x08}; 235 236 dev_dbg(&intf->dev, "onoff=%d\n", onoff); 237 238 ret = zd1301_ctrl_msg(d, buf, 3, NULL, 0); 239 if (ret) 240 goto err; 241 242 return 0; 243 err: 244 dev_dbg(&intf->dev, "failed=%d\n", ret); 245 return ret; 246 } 247 248 static const struct dvb_usb_device_properties zd1301_props = { 249 .driver_name = KBUILD_MODNAME, 250 .owner = THIS_MODULE, 251 .adapter_nr = adapter_nr, 252 .size_of_priv = sizeof(struct zd1301_dev), 253 254 .frontend_attach = zd1301_frontend_attach, 255 .frontend_detach = zd1301_frontend_detach, 256 .streaming_ctrl = zd1301_streaming_ctrl, 257 258 .num_adapters = 1, 259 .adapter = { 260 { 261 .stream = DVB_USB_STREAM_BULK(0x81, 6, 21 * 188), 262 }, 263 }, 264 }; 265 266 static const struct usb_device_id zd1301_id_table[] = { 267 {DVB_USB_DEVICE(USB_VID_ZYDAS, 0x13a1, &zd1301_props, 268 "ZyDAS ZD1301 reference design", NULL)}, 269 {} 270 }; 271 MODULE_DEVICE_TABLE(usb, zd1301_id_table); 272 273 /* Usb specific object needed to register this driver with the usb subsystem */ 274 static struct usb_driver zd1301_usb_driver = { 275 .name = KBUILD_MODNAME, 276 .id_table = zd1301_id_table, 277 .probe = dvb_usbv2_probe, 278 .disconnect = dvb_usbv2_disconnect, 279 .suspend = dvb_usbv2_suspend, 280 .resume = dvb_usbv2_resume, 281 .reset_resume = dvb_usbv2_reset_resume, 282 .no_dynamic_id = 1, 283 .soft_unbind = 1, 284 }; 285 module_usb_driver(zd1301_usb_driver); 286 287 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 288 MODULE_DESCRIPTION("ZyDAS ZD1301 driver"); 289 MODULE_LICENSE("GPL"); 290