1/* DVB USB compliant linux driver for Nebula Electronics uDigiTV DVB-T USB2.0
2 * receiver
3 *
4 * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
5 *
6 * partly based on the SDK published by Nebula Electronics
7 *
8 *	This program is free software; you can redistribute it and/or modify it
9 *	under the terms of the GNU General Public License as published by the Free
10 *	Software Foundation, version 2.
11 *
12 * see Documentation/dvb/README.dvb-usb for more information
13 */
14#include "digitv.h"
15
16#include "mt352.h"
17#include "nxt6000.h"
18
19/* debug */
20int dvb_usb_digitv_debug;
21module_param_named(debug,dvb_usb_digitv_debug, int, 0644);
22MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
23
24static int digitv_ctrl_msg(struct dvb_usb_device *d,
25		u8 cmd, u8 vv, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
26{
27	int wo = (rbuf == NULL || rlen == 0); /* write-only */
28	u8 sndbuf[7],rcvbuf[7];
29	memset(sndbuf,0,7); memset(rcvbuf,0,7);
30
31	sndbuf[0] = cmd;
32	sndbuf[1] = vv;
33	sndbuf[2] = wo ? wlen : rlen;
34
35	if (wo) {
36		memcpy(&sndbuf[3],wbuf,wlen);
37		dvb_usb_generic_write(d,sndbuf,7);
38	} else {
39		dvb_usb_generic_rw(d,sndbuf,7,rcvbuf,7,10);
40		memcpy(rbuf,&rcvbuf[3],rlen);
41	}
42	return 0;
43}
44
45/* I2C */
46static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
47{
48	struct dvb_usb_device *d = i2c_get_adapdata(adap);
49	int i;
50
51	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
52		return -EAGAIN;
53
54	if (num > 2)
55		warn("more than 2 i2c messages at a time is not handled yet. TODO.");
56
57	for (i = 0; i < num; i++) {
58		/* write/read request */
59		if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
60			if (digitv_ctrl_msg(d, USB_READ_COFDM, msg[i].buf[0], NULL, 0,
61						msg[i+1].buf,msg[i+1].len) < 0)
62				break;
63			i++;
64		} else
65			if (digitv_ctrl_msg(d,USB_WRITE_COFDM, msg[i].buf[0],
66						&msg[i].buf[1],msg[i].len-1,NULL,0) < 0)
67				break;
68	}
69
70	mutex_unlock(&d->i2c_mutex);
71	return i;
72}
73
74static u32 digitv_i2c_func(struct i2c_adapter *adapter)
75{
76	return I2C_FUNC_I2C;
77}
78
79static struct i2c_algorithm digitv_i2c_algo = {
80	.master_xfer   = digitv_i2c_xfer,
81	.functionality = digitv_i2c_func,
82};
83
84/* Callbacks for DVB USB */
85static int digitv_identify_state (struct usb_device *udev, struct
86		dvb_usb_device_properties *props, struct dvb_usb_device_description **desc,
87		int *cold)
88{
89	*cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0;
90	return 0;
91}
92
93static int digitv_mt352_demod_init(struct dvb_frontend *fe)
94{
95	static u8 reset_buf[] = { 0x89, 0x38,  0x8a, 0x2d, 0x50, 0x80 };
96	static u8 init_buf[] = { 0x68, 0xa0,  0x8e, 0x40,  0x53, 0x50,
97			0x67, 0x20,  0x7d, 0x01,  0x7c, 0x00,  0x7a, 0x00,
98			0x79, 0x20,  0x57, 0x05,  0x56, 0x31,  0x88, 0x0f,
99			0x75, 0x32 };
100	int i;
101
102	for (i = 0; i < ARRAY_SIZE(reset_buf); i += 2)
103		mt352_write(fe, &reset_buf[i], 2);
104
105	msleep(1);
106
107	for (i = 0; i < ARRAY_SIZE(init_buf); i += 2)
108		mt352_write(fe, &init_buf[i], 2);
109
110	return 0;
111}
112
113static struct mt352_config digitv_mt352_config = {
114	.demod_init = digitv_mt352_demod_init,
115};
116
117static int digitv_nxt6000_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *fep)
118{
119	struct dvb_usb_adapter *adap = fe->dvb->priv;
120	u8 b[5];
121	dvb_usb_tuner_calc_regs(fe,fep,b, 5);
122	if (fe->ops.i2c_gate_ctrl)
123		fe->ops.i2c_gate_ctrl(fe, 1);
124	return digitv_ctrl_msg(adap->dev, USB_WRITE_TUNER, 0, &b[1], 4, NULL, 0);
125}
126
127static struct nxt6000_config digitv_nxt6000_config = {
128	.clock_inversion = 1,
129};
130
131static int digitv_frontend_attach(struct dvb_usb_adapter *adap)
132{
133	if ((adap->fe = dvb_attach(mt352_attach, &digitv_mt352_config, &adap->dev->i2c_adap)) != NULL) {
134		adap->fe->ops.tuner_ops.calc_regs = dvb_usb_tuner_calc_regs;
135		return 0;
136	}
137	if ((adap->fe = dvb_attach(nxt6000_attach, &digitv_nxt6000_config, &adap->dev->i2c_adap)) != NULL) {
138		adap->fe->ops.tuner_ops.set_params = digitv_nxt6000_tuner_set_params;
139		return 0;
140	}
141	return -EIO;
142}
143
144static int digitv_tuner_attach(struct dvb_usb_adapter *adap)
145{
146	adap->pll_addr = 0x60;
147	adap->pll_desc = &dvb_pll_tded4;
148	return 0;
149}
150
151static struct dvb_usb_rc_key digitv_rc_keys[] = {
152	{ 0x5f, 0x55, KEY_0 },
153	{ 0x6f, 0x55, KEY_1 },
154	{ 0x9f, 0x55, KEY_2 },
155	{ 0xaf, 0x55, KEY_3 },
156	{ 0x5f, 0x56, KEY_4 },
157	{ 0x6f, 0x56, KEY_5 },
158	{ 0x9f, 0x56, KEY_6 },
159	{ 0xaf, 0x56, KEY_7 },
160	{ 0x5f, 0x59, KEY_8 },
161	{ 0x6f, 0x59, KEY_9 },
162	{ 0x9f, 0x59, KEY_TV },
163	{ 0xaf, 0x59, KEY_AUX },
164	{ 0x5f, 0x5a, KEY_DVD },
165	{ 0x6f, 0x5a, KEY_POWER },
166	{ 0x9f, 0x5a, KEY_MHP },     /* labelled 'Picture' */
167	{ 0xaf, 0x5a, KEY_AUDIO },
168	{ 0x5f, 0x65, KEY_INFO },
169	{ 0x6f, 0x65, KEY_F13 },     /* 16:9 */
170	{ 0x9f, 0x65, KEY_F14 },     /* 14:9 */
171	{ 0xaf, 0x65, KEY_EPG },
172	{ 0x5f, 0x66, KEY_EXIT },
173	{ 0x6f, 0x66, KEY_MENU },
174	{ 0x9f, 0x66, KEY_UP },
175	{ 0xaf, 0x66, KEY_DOWN },
176	{ 0x5f, 0x69, KEY_LEFT },
177	{ 0x6f, 0x69, KEY_RIGHT },
178	{ 0x9f, 0x69, KEY_ENTER },
179	{ 0xaf, 0x69, KEY_CHANNELUP },
180	{ 0x5f, 0x6a, KEY_CHANNELDOWN },
181	{ 0x6f, 0x6a, KEY_VOLUMEUP },
182	{ 0x9f, 0x6a, KEY_VOLUMEDOWN },
183	{ 0xaf, 0x6a, KEY_RED },
184	{ 0x5f, 0x95, KEY_GREEN },
185	{ 0x6f, 0x95, KEY_YELLOW },
186	{ 0x9f, 0x95, KEY_BLUE },
187	{ 0xaf, 0x95, KEY_SUBTITLE },
188	{ 0x5f, 0x96, KEY_F15 },     /* AD */
189	{ 0x6f, 0x96, KEY_TEXT },
190	{ 0x9f, 0x96, KEY_MUTE },
191	{ 0xaf, 0x96, KEY_REWIND },
192	{ 0x5f, 0x99, KEY_STOP },
193	{ 0x6f, 0x99, KEY_PLAY },
194	{ 0x9f, 0x99, KEY_FASTFORWARD },
195	{ 0xaf, 0x99, KEY_F16 },     /* chapter */
196	{ 0x5f, 0x9a, KEY_PAUSE },
197	{ 0x6f, 0x9a, KEY_PLAY },
198	{ 0x9f, 0x9a, KEY_RECORD },
199	{ 0xaf, 0x9a, KEY_F17 },     /* picture in picture */
200	{ 0x5f, 0xa5, KEY_KPPLUS },  /* zoom in */
201	{ 0x6f, 0xa5, KEY_KPMINUS }, /* zoom out */
202	{ 0x9f, 0xa5, KEY_F18 },     /* capture */
203	{ 0xaf, 0xa5, KEY_F19 },     /* web */
204	{ 0x5f, 0xa6, KEY_EMAIL },
205	{ 0x6f, 0xa6, KEY_PHONE },
206	{ 0x9f, 0xa6, KEY_PC },
207};
208
209static int digitv_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
210{
211	int i;
212	u8 key[5];
213	u8 b[4] = { 0 };
214
215	*event = 0;
216	*state = REMOTE_NO_KEY_PRESSED;
217
218	digitv_ctrl_msg(d,USB_READ_REMOTE,0,NULL,0,&key[1],4);
219
220	/* Tell the device we've read the remote. Not sure how necessary
221	   this is, but the Nebula SDK does it. */
222	digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
223
224	/* if something is inside the buffer, simulate key press */
225	if (key[1] != 0)
226	{
227		  for (i = 0; i < d->props.rc_key_map_size; i++) {
228			if (d->props.rc_key_map[i].custom == key[1] &&
229			    d->props.rc_key_map[i].data == key[2]) {
230				*event = d->props.rc_key_map[i].event;
231				*state = REMOTE_KEY_PRESSED;
232				return 0;
233			}
234		}
235	}
236
237	if (key[0] != 0)
238		deb_rc("key: %x %x %x %x %x\n",key[0],key[1],key[2],key[3],key[4]);
239	return 0;
240}
241
242/* DVB USB Driver stuff */
243static struct dvb_usb_device_properties digitv_properties;
244
245static int digitv_probe(struct usb_interface *intf,
246		const struct usb_device_id *id)
247{
248	struct dvb_usb_device *d;
249	int ret;
250	if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) {
251		u8 b[4] = { 0 };
252
253		if (d != NULL) { /* do that only when the firmware is loaded */
254			b[0] = 1;
255			digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
256
257			b[0] = 0;
258			digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
259		}
260	}
261	return ret;
262}
263
264static struct usb_device_id digitv_table [] = {
265		{ USB_DEVICE(USB_VID_ANCHOR, USB_PID_NEBULA_DIGITV) },
266		{ }		/* Terminating entry */
267};
268MODULE_DEVICE_TABLE (usb, digitv_table);
269
270static struct dvb_usb_device_properties digitv_properties = {
271	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
272
273	.usb_ctrl = CYPRESS_FX2,
274	.firmware = "dvb-usb-digitv-02.fw",
275
276	.num_adapters = 1,
277	.adapter = {
278		{
279			.frontend_attach  = digitv_frontend_attach,
280			.tuner_attach     = digitv_tuner_attach,
281
282			/* parameter for the MPEG2-data transfer */
283			.stream = {
284				.type = USB_BULK,
285				.count = 7,
286				.endpoint = 0x02,
287				.u = {
288					.bulk = {
289						.buffersize = 4096,
290					}
291				}
292			},
293		}
294	},
295	.identify_state   = digitv_identify_state,
296
297	.rc_interval      = 1000,
298	.rc_key_map       = digitv_rc_keys,
299	.rc_key_map_size  = ARRAY_SIZE(digitv_rc_keys),
300	.rc_query         = digitv_rc_query,
301
302	.i2c_algo         = &digitv_i2c_algo,
303
304	.generic_bulk_ctrl_endpoint = 0x01,
305
306	.num_device_descs = 1,
307	.devices = {
308		{   "Nebula Electronics uDigiTV DVB-T USB2.0)",
309			{ &digitv_table[0], NULL },
310			{ NULL },
311		},
312		{ NULL },
313	}
314};
315
316static struct usb_driver digitv_driver = {
317	.name		= "dvb_usb_digitv",
318	.probe		= digitv_probe,
319	.disconnect = dvb_usb_device_exit,
320	.id_table	= digitv_table,
321};
322
323/* module stuff */
324static int __init digitv_module_init(void)
325{
326	int result;
327	if ((result = usb_register(&digitv_driver))) {
328		err("usb_register failed. Error number %d",result);
329		return result;
330	}
331
332	return 0;
333}
334
335static void __exit digitv_module_exit(void)
336{
337	/* deregister this driver from the USB subsystem */
338	usb_deregister(&digitv_driver);
339}
340
341module_init (digitv_module_init);
342module_exit (digitv_module_exit);
343
344MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
345MODULE_DESCRIPTION("Driver for Nebula Electronics uDigiTV DVB-T USB2.0");
346MODULE_VERSION("1.0-alpha");
347MODULE_LICENSE("GPL");
348