1 /*
2  * E3C EC168 DVB USB driver
3  *
4  * Copyright (C) 2009 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  *    You should have received a copy of the GNU General Public License
17  *    along with this program; if not, write to the Free Software
18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  *
20  */
21 
22 #include "ec168.h"
23 #include "ec100.h"
24 #include "mxl5005s.h"
25 
26 /* debug */
27 static int dvb_usb_ec168_debug;
28 module_param_named(debug, dvb_usb_ec168_debug, int, 0644);
29 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
30 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
31 
32 static struct ec100_config ec168_ec100_config;
33 
ec168_rw_udev(struct usb_device * udev,struct ec168_req * req)34 static int ec168_rw_udev(struct usb_device *udev, struct ec168_req *req)
35 {
36 	int ret;
37 	unsigned int pipe;
38 	u8 request, requesttype;
39 	u8 *buf;
40 
41 
42 
43 	switch (req->cmd) {
44 	case DOWNLOAD_FIRMWARE:
45 	case GPIO:
46 	case WRITE_I2C:
47 	case STREAMING_CTRL:
48 		requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
49 		request = req->cmd;
50 		break;
51 	case READ_I2C:
52 		requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
53 		request = req->cmd;
54 		break;
55 	case GET_CONFIG:
56 		requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
57 		request = CONFIG;
58 		break;
59 	case SET_CONFIG:
60 		requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
61 		request = CONFIG;
62 		break;
63 	case WRITE_DEMOD:
64 		requesttype = (USB_TYPE_VENDOR | USB_DIR_OUT);
65 		request = DEMOD_RW;
66 		break;
67 	case READ_DEMOD:
68 		requesttype = (USB_TYPE_VENDOR | USB_DIR_IN);
69 		request = DEMOD_RW;
70 		break;
71 	default:
72 		err("unknown command:%02x", req->cmd);
73 		ret = -EPERM;
74 		goto error;
75 	}
76 
77 	buf = kmalloc(req->size, GFP_KERNEL);
78 	if (!buf) {
79 		ret = -ENOMEM;
80 		goto error;
81 	}
82 
83 	if (requesttype == (USB_TYPE_VENDOR | USB_DIR_OUT)) {
84 		/* write */
85 		memcpy(buf, req->data, req->size);
86 		pipe = usb_sndctrlpipe(udev, 0);
87 	} else {
88 		/* read */
89 		pipe = usb_rcvctrlpipe(udev, 0);
90 	}
91 
92 	msleep(1); /* avoid I2C errors */
93 
94 	ret = usb_control_msg(udev, pipe, request, requesttype, req->value,
95 		req->index, buf, req->size, EC168_USB_TIMEOUT);
96 
97 	ec168_debug_dump(request, requesttype, req->value, req->index, buf,
98 		req->size, deb_xfer);
99 
100 	if (ret < 0)
101 		goto err_dealloc;
102 	else
103 		ret = 0;
104 
105 	/* read request, copy returned data to return buf */
106 	if (!ret && requesttype == (USB_TYPE_VENDOR | USB_DIR_IN))
107 		memcpy(req->data, buf, req->size);
108 
109 	kfree(buf);
110 	return ret;
111 
112 err_dealloc:
113 	kfree(buf);
114 error:
115 	deb_info("%s: failed:%d\n", __func__, ret);
116 	return ret;
117 }
118 
ec168_ctrl_msg(struct dvb_usb_device * d,struct ec168_req * req)119 static int ec168_ctrl_msg(struct dvb_usb_device *d, struct ec168_req *req)
120 {
121 	return ec168_rw_udev(d->udev, req);
122 }
123 
124 /* I2C */
ec168_i2c_xfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)125 static int ec168_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
126 	int num)
127 {
128 	struct dvb_usb_device *d = i2c_get_adapdata(adap);
129 	struct ec168_req req;
130 	int i = 0;
131 	int ret;
132 
133 	if (num > 2)
134 		return -EINVAL;
135 
136 	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
137 		return -EAGAIN;
138 
139 	while (i < num) {
140 		if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
141 			if (msg[i].addr == ec168_ec100_config.demod_address) {
142 				req.cmd = READ_DEMOD;
143 				req.value = 0;
144 				req.index = 0xff00 + msg[i].buf[0]; /* reg */
145 				req.size = msg[i+1].len; /* bytes to read */
146 				req.data = &msg[i+1].buf[0];
147 				ret = ec168_ctrl_msg(d, &req);
148 				i += 2;
149 			} else {
150 				err("I2C read not implemented");
151 				ret = -ENOSYS;
152 				i += 2;
153 			}
154 		} else {
155 			if (msg[i].addr == ec168_ec100_config.demod_address) {
156 				req.cmd = WRITE_DEMOD;
157 				req.value = msg[i].buf[1]; /* val */
158 				req.index = 0xff00 + msg[i].buf[0]; /* reg */
159 				req.size = 0;
160 				req.data = NULL;
161 				ret = ec168_ctrl_msg(d, &req);
162 				i += 1;
163 			} else {
164 				req.cmd = WRITE_I2C;
165 				req.value = msg[i].buf[0]; /* val */
166 				req.index = 0x0100 + msg[i].addr; /* I2C addr */
167 				req.size = msg[i].len-1;
168 				req.data = &msg[i].buf[1];
169 				ret = ec168_ctrl_msg(d, &req);
170 				i += 1;
171 			}
172 		}
173 		if (ret)
174 			goto error;
175 
176 	}
177 	ret = i;
178 
179 error:
180 	mutex_unlock(&d->i2c_mutex);
181 	return i;
182 }
183 
184 
ec168_i2c_func(struct i2c_adapter * adapter)185 static u32 ec168_i2c_func(struct i2c_adapter *adapter)
186 {
187 	return I2C_FUNC_I2C;
188 }
189 
190 static struct i2c_algorithm ec168_i2c_algo = {
191 	.master_xfer   = ec168_i2c_xfer,
192 	.functionality = ec168_i2c_func,
193 };
194 
195 /* Callbacks for DVB USB */
196 static struct ec100_config ec168_ec100_config = {
197 	.demod_address = 0xff, /* not real address, demod is integrated */
198 };
199 
ec168_ec100_frontend_attach(struct dvb_usb_adapter * adap)200 static int ec168_ec100_frontend_attach(struct dvb_usb_adapter *adap)
201 {
202 	deb_info("%s:\n", __func__);
203 	adap->fe_adap[0].fe = dvb_attach(ec100_attach, &ec168_ec100_config,
204 		&adap->dev->i2c_adap);
205 	if (adap->fe_adap[0].fe == NULL)
206 		return -ENODEV;
207 
208 	return 0;
209 }
210 
211 static struct mxl5005s_config ec168_mxl5003s_config = {
212 	.i2c_address     = 0xc6,
213 	.if_freq         = IF_FREQ_4570000HZ,
214 	.xtal_freq       = CRYSTAL_FREQ_16000000HZ,
215 	.agc_mode        = MXL_SINGLE_AGC,
216 	.tracking_filter = MXL_TF_OFF,
217 	.rssi_enable     = MXL_RSSI_ENABLE,
218 	.cap_select      = MXL_CAP_SEL_ENABLE,
219 	.div_out         = MXL_DIV_OUT_4,
220 	.clock_out       = MXL_CLOCK_OUT_DISABLE,
221 	.output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
222 	.top		 = MXL5005S_TOP_25P2,
223 	.mod_mode        = MXL_DIGITAL_MODE,
224 	.if_mode         = MXL_ZERO_IF,
225 	.AgcMasterByte   = 0x00,
226 };
227 
ec168_mxl5003s_tuner_attach(struct dvb_usb_adapter * adap)228 static int ec168_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
229 {
230 	deb_info("%s:\n", __func__);
231 	return dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap,
232 		&ec168_mxl5003s_config) == NULL ? -ENODEV : 0;
233 }
234 
ec168_streaming_ctrl(struct dvb_usb_adapter * adap,int onoff)235 static int ec168_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
236 {
237 	struct ec168_req req = {STREAMING_CTRL, 0x7f01, 0x0202, 0, NULL};
238 	deb_info("%s: onoff:%d\n", __func__, onoff);
239 	if (onoff)
240 		req.index = 0x0102;
241 	return ec168_ctrl_msg(adap->dev, &req);
242 }
243 
ec168_download_firmware(struct usb_device * udev,const struct firmware * fw)244 static int ec168_download_firmware(struct usb_device *udev,
245 	const struct firmware *fw)
246 {
247 	int i, len, packets, remainder, ret;
248 	u16 addr = 0x0000; /* firmware start address */
249 	struct ec168_req req = {DOWNLOAD_FIRMWARE, 0, 0, 0, NULL};
250 	deb_info("%s:\n", __func__);
251 
252 	#define FW_PACKET_MAX_DATA  2048
253 	packets = fw->size / FW_PACKET_MAX_DATA;
254 	remainder = fw->size % FW_PACKET_MAX_DATA;
255 	len = FW_PACKET_MAX_DATA;
256 	for (i = 0; i <= packets; i++) {
257 		if (i == packets)  /* set size of the last packet */
258 			len = remainder;
259 
260 		req.size = len;
261 		req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
262 		req.index = addr;
263 		addr += FW_PACKET_MAX_DATA;
264 
265 		ret = ec168_rw_udev(udev, &req);
266 		if (ret) {
267 			err("firmware download failed:%d packet:%d", ret, i);
268 			goto error;
269 		}
270 	}
271 	req.size = 0;
272 
273 	/* set "warm"? */
274 	req.cmd = SET_CONFIG;
275 	req.value = 0;
276 	req.index = 0x0001;
277 	ret = ec168_rw_udev(udev, &req);
278 	if (ret)
279 		goto error;
280 
281 	/* really needed - no idea what does */
282 	req.cmd = GPIO;
283 	req.value = 0;
284 	req.index = 0x0206;
285 	ret = ec168_rw_udev(udev, &req);
286 	if (ret)
287 		goto error;
288 
289 	/* activate tuner I2C? */
290 	req.cmd = WRITE_I2C;
291 	req.value = 0;
292 	req.index = 0x00c6;
293 	ret = ec168_rw_udev(udev, &req);
294 	if (ret)
295 		goto error;
296 
297 	return ret;
298 error:
299 	deb_info("%s: failed:%d\n", __func__, ret);
300 	return ret;
301 }
302 
ec168_identify_state(struct usb_device * udev,struct dvb_usb_device_properties * props,struct dvb_usb_device_description ** desc,int * cold)303 static int ec168_identify_state(struct usb_device *udev,
304 	struct dvb_usb_device_properties *props,
305 	struct dvb_usb_device_description **desc, int *cold)
306 {
307 	int ret;
308 	u8 reply;
309 	struct ec168_req req = {GET_CONFIG, 0, 1, sizeof(reply), &reply};
310 	deb_info("%s:\n", __func__);
311 
312 	ret = ec168_rw_udev(udev, &req);
313 	if (ret)
314 		goto error;
315 
316 	deb_info("%s: reply:%02x\n", __func__, reply);
317 
318 	if (reply == 0x01)
319 		*cold = 0;
320 	else
321 		*cold = 1;
322 
323 	return ret;
324 error:
325 	deb_info("%s: failed:%d\n", __func__, ret);
326 	return ret;
327 }
328 
329 /* DVB USB Driver stuff */
330 static struct dvb_usb_device_properties ec168_properties;
331 
ec168_probe(struct usb_interface * intf,const struct usb_device_id * id)332 static int ec168_probe(struct usb_interface *intf,
333 	const struct usb_device_id *id)
334 {
335 	int ret;
336 	deb_info("%s: interface:%d\n", __func__,
337 		intf->cur_altsetting->desc.bInterfaceNumber);
338 
339 	ret = dvb_usb_device_init(intf, &ec168_properties, THIS_MODULE, NULL,
340 		adapter_nr);
341 	if (ret)
342 		goto error;
343 
344 	return ret;
345 error:
346 	deb_info("%s: failed:%d\n", __func__, ret);
347 	return ret;
348 }
349 
350 #define E3C_EC168_1689                          0
351 #define E3C_EC168_FFFA                          1
352 #define E3C_EC168_FFFB                          2
353 #define E3C_EC168_1001                          3
354 #define E3C_EC168_1002                          4
355 
356 static struct usb_device_id ec168_id[] = {
357 	[E3C_EC168_1689] =
358 		{USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168)},
359 	[E3C_EC168_FFFA] =
360 		{USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_2)},
361 	[E3C_EC168_FFFB] =
362 		{USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_3)},
363 	[E3C_EC168_1001] =
364 		{USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_4)},
365 	[E3C_EC168_1002] =
366 		{USB_DEVICE(USB_VID_E3C, USB_PID_E3C_EC168_5)},
367 	{} /* terminating entry */
368 };
369 
370 MODULE_DEVICE_TABLE(usb, ec168_id);
371 
372 static struct dvb_usb_device_properties ec168_properties = {
373 	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
374 
375 	.usb_ctrl = DEVICE_SPECIFIC,
376 	.download_firmware = ec168_download_firmware,
377 	.firmware = "dvb-usb-ec168.fw",
378 	.no_reconnect = 1,
379 
380 	.size_of_priv = 0,
381 
382 	.num_adapters = 1,
383 	.adapter = {
384 		{
385 		.num_frontends = 1,
386 		.fe = {{
387 			.streaming_ctrl   = ec168_streaming_ctrl,
388 			.frontend_attach  = ec168_ec100_frontend_attach,
389 			.tuner_attach     = ec168_mxl5003s_tuner_attach,
390 			.stream = {
391 				.type = USB_BULK,
392 				.count = 6,
393 				.endpoint = 0x82,
394 				.u = {
395 					.bulk = {
396 						.buffersize = (32*512),
397 					}
398 				}
399 			},
400 		}},
401 		}
402 	},
403 
404 	.identify_state = ec168_identify_state,
405 
406 	.i2c_algo = &ec168_i2c_algo,
407 
408 	.num_device_descs = 1,
409 	.devices = {
410 		{
411 			.name = "E3C EC168 DVB-T USB2.0 reference design",
412 			.cold_ids = {
413 				&ec168_id[E3C_EC168_1689],
414 				&ec168_id[E3C_EC168_FFFA],
415 				&ec168_id[E3C_EC168_FFFB],
416 				&ec168_id[E3C_EC168_1001],
417 				&ec168_id[E3C_EC168_1002],
418 				NULL},
419 			.warm_ids = {NULL},
420 		},
421 	}
422 };
423 
424 static struct usb_driver ec168_driver = {
425 	.name       = "dvb_usb_ec168",
426 	.probe      = ec168_probe,
427 	.disconnect = dvb_usb_device_exit,
428 	.id_table   = ec168_id,
429 };
430 
431 module_usb_driver(ec168_driver);
432 
433 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
434 MODULE_DESCRIPTION("E3C EC168 DVB-T USB2.0 driver");
435 MODULE_LICENSE("GPL");
436