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