1/* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
2*
3* Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
4* Copyright (C) 2006 Marco Gittler (g.marco@freenet.de)
5*
6*	This program is free software; you can redistribute it and/or modify it
7*	under the terms of the GNU General Public License as published by the Free
8*	Software Foundation, version 2.
9*
10* see Documentation/dvb/README.dvb-usb for more information
11*/
12
13#include "opera1.h"
14#include "stv0299.h"
15
16#define OPERA_READ_MSG 0
17#define OPERA_WRITE_MSG 1
18#define OPERA_I2C_TUNER 0xd1
19
20#define READ_FX2_REG_REQ  0xba
21#define READ_MAC_ADDR 0x08
22#define OPERA_WRITE_FX2 0xbb
23#define OPERA_TUNER_REQ 0xb1
24#define REG_1F_SYMBOLRATE_BYTE0 0x1f
25#define REG_20_SYMBOLRATE_BYTE1 0x20
26#define REG_21_SYMBOLRATE_BYTE2 0x21
27
28#define ADDR_B600_VOLTAGE_13V (0x02)
29#define ADDR_B601_VOLTAGE_18V (0x03)
30#define ADDR_B1A6_STREAM_CTRL (0x04)
31#define ADDR_B880_READ_REMOTE (0x05)
32
33struct opera1_state {
34	u32 last_key_pressed;
35};
36struct opera_rc_keys {
37	u32 keycode;
38	u32 event;
39};
40
41int dvb_usb_opera1_debug;
42module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
43MODULE_PARM_DESC(debug,
44		 "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
45		 DVB_USB_DEBUG_STATUS);
46
47static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
48			    u8 * data, u16 len, int flags)
49{
50	int ret;
51	u8 r;
52	u8 u8buf[len];
53
54	unsigned int pipe = (flags == OPERA_READ_MSG) ?
55		usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
56	u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
57
58	if (flags == OPERA_WRITE_MSG)
59		memcpy(u8buf, data, len);
60	ret =
61		usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR,
62			value, 0x0, u8buf, len, 2000);
63
64	if (request == OPERA_TUNER_REQ) {
65		if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
66				OPERA_TUNER_REQ, USB_DIR_IN | USB_TYPE_VENDOR,
67				0x01, 0x0, &r, 1, 2000)<1 || r!=0x08)
68					return 0;
69	}
70	if (flags == OPERA_READ_MSG)
71		memcpy(data, u8buf, len);
72	return ret;
73}
74
75/* I2C */
76
77static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
78				  u8 * buf, u16 len)
79{
80	int ret = 0;
81	u8 request;
82	u16 value;
83
84	if (!dev) {
85		info("no usb_device");
86		return -EINVAL;
87	}
88	if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
89		return -EAGAIN;
90
91	switch (addr>>1){
92		case ADDR_B600_VOLTAGE_13V:
93			request=0xb6;
94			value=0x00;
95			break;
96		case ADDR_B601_VOLTAGE_18V:
97			request=0xb6;
98			value=0x01;
99			break;
100		case ADDR_B1A6_STREAM_CTRL:
101			request=0xb1;
102			value=0xa6;
103			break;
104		case ADDR_B880_READ_REMOTE:
105			request=0xb8;
106			value=0x80;
107			break;
108		default:
109			request=0xb1;
110			value=addr;
111	}
112	ret = opera1_xilinx_rw(dev->udev, request,
113		value, buf, len,
114		addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);
115
116	mutex_unlock(&dev->usb_mutex);
117	return ret;
118}
119
120static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
121			   int num)
122{
123	struct dvb_usb_device *d = i2c_get_adapdata(adap);
124	int i = 0, tmp = 0;
125
126	if (!d)
127		return -ENODEV;
128	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
129		return -EAGAIN;
130
131	for (i = 0; i < num; i++) {
132		if ((tmp = opera1_usb_i2c_msgxfer(d,
133					(msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0),
134					msg[i].buf,
135					msg[i].len
136					)!= msg[i].len)) {
137			break;
138		}
139		if (dvb_usb_opera1_debug & 0x10)
140			info("sending i2c mesage %d %d", tmp, msg[i].len);
141	}
142	mutex_unlock(&d->i2c_mutex);
143	return num;
144}
145
146static u32 opera1_i2c_func(struct i2c_adapter *adapter)
147{
148	return I2C_FUNC_I2C;
149}
150
151static struct i2c_algorithm opera1_i2c_algo = {
152	.master_xfer = opera1_i2c_xfer,
153	.functionality = opera1_i2c_func,
154};
155
156static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
157{
158	static u8 command_13v[1]={0x00};
159	static u8 command_18v[1]={0x01};
160	struct i2c_msg msg[] = {
161		{.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
162	};
163	struct dvb_usb_adapter *udev_adap =
164	    (struct dvb_usb_adapter *)(fe->dvb->priv);
165	if (voltage == SEC_VOLTAGE_18) {
166		msg[0].addr = ADDR_B601_VOLTAGE_18V;
167		msg[0].buf = command_18v;
168	}
169	i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
170	return 0;
171}
172
173static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
174					  u32 ratio)
175{
176	stv0299_writereg(fe, 0x13, 0x98);
177	stv0299_writereg(fe, 0x14, 0x95);
178	stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
179	stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
180	stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
181	return 0;
182
183}
184static u8 opera1_inittab[] = {
185	0x00, 0xa1,
186	0x01, 0x15,
187	0x02, 0x00,
188	0x03, 0x00,
189	0x04, 0x7d,
190	0x05, 0x05,
191	0x06, 0x02,
192	0x07, 0x00,
193	0x0b, 0x00,
194	0x0c, 0x01,
195	0x0d, 0x81,
196	0x0e, 0x44,
197	0x0f, 0x19,
198	0x10, 0x3f,
199	0x11, 0x84,
200	0x12, 0xda,
201	0x13, 0x98,
202	0x14, 0x95,
203	0x15, 0xc9,
204	0x16, 0xeb,
205	0x17, 0x00,
206	0x18, 0x19,
207	0x19, 0x8b,
208	0x1a, 0x00,
209	0x1b, 0x82,
210	0x1c, 0x7f,
211	0x1d, 0x00,
212	0x1e, 0x00,
213	REG_1F_SYMBOLRATE_BYTE0, 0x06,
214	REG_20_SYMBOLRATE_BYTE1, 0x50,
215	REG_21_SYMBOLRATE_BYTE2, 0x10,
216	0x22, 0x00,
217	0x23, 0x00,
218	0x24, 0x37,
219	0x25, 0xbc,
220	0x26, 0x00,
221	0x27, 0x00,
222	0x28, 0x00,
223	0x29, 0x1e,
224	0x2a, 0x14,
225	0x2b, 0x1f,
226	0x2c, 0x09,
227	0x2d, 0x0a,
228	0x2e, 0x00,
229	0x2f, 0x00,
230	0x30, 0x00,
231	0x31, 0x1f,
232	0x32, 0x19,
233	0x33, 0xfc,
234	0x34, 0x13,
235	0xff, 0xff,
236};
237
238static struct stv0299_config opera1_stv0299_config = {
239	.demod_address = 0xd0>>1,
240	.min_delay_ms = 100,
241	.mclk = 88000000UL,
242	.invert = 1,
243	.skip_reinit = 0,
244	.lock_output = STV0229_LOCKOUTPUT_0,
245	.volt13_op0_op1 = STV0299_VOLT13_OP0,
246	.inittab = opera1_inittab,
247	.set_symbol_rate = opera1_stv0299_set_symbol_rate,
248};
249
250static int opera1_frontend_attach(struct dvb_usb_adapter *d)
251{
252	if ((d->fe =
253	     dvb_attach(stv0299_attach, &opera1_stv0299_config,
254			&d->dev->i2c_adap)) != NULL) {
255		d->fe->ops.set_voltage = opera1_set_voltage;
256		return 0;
257	}
258	info("not attached stv0299");
259	return -EIO;
260}
261
262static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
263{
264	dvb_attach(
265		dvb_pll_attach, adap->fe, 0xc0>>1,
266		&adap->dev->i2c_adap, &dvb_pll_opera1
267	);
268	return 0;
269}
270
271static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
272{
273	u8 val = onoff ? 0x01 : 0x00;
274
275	if (dvb_usb_opera1_debug)
276		info("power %s", onoff ? "on" : "off");
277	return opera1_xilinx_rw(d->udev, 0xb7, val,
278				&val, 1, OPERA_WRITE_MSG);
279}
280
281static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
282{
283	static u8 buf_start[2] = { 0xff, 0x03 };
284	static u8 buf_stop[2] = { 0xff, 0x00 };
285	struct i2c_msg start_tuner[] = {
286		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
287	};
288	if (dvb_usb_opera1_debug)
289		info("streaming %s", onoff ? "on" : "off");
290	i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
291	return 0;
292}
293
294static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
295			     int onoff)
296{
297	u8 b_pid[3];
298	struct i2c_msg msg[] = {
299		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
300	};
301	if (dvb_usb_opera1_debug)
302		info("pidfilter index: %d pid: %d %s", index, pid,
303			onoff ? "on" : "off");
304	b_pid[0] = (2 * index) + 4;
305	b_pid[1] = onoff ? (pid & 0xff) : (0x00);
306	b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
307	i2c_transfer(&adap->dev->i2c_adap, msg, 1);
308	return 0;
309}
310
311static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
312{
313	int u = 0x04;
314	u8 b_pid[3];
315	struct i2c_msg msg[] = {
316		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
317	};
318	if (dvb_usb_opera1_debug)
319		info("%s hw-pidfilter", onoff ? "enable" : "disable");
320	for (; u < 0x7e; u += 2) {
321		b_pid[0] = u;
322		b_pid[1] = 0;
323		b_pid[2] = 0x80;
324		i2c_transfer(&adap->dev->i2c_adap, msg, 1);
325	}
326	return 0;
327}
328
329static struct dvb_usb_rc_key opera1_rc_keys[] = {
330	{0x5f, 0xa0, KEY_1},
331	{0x51, 0xaf, KEY_2},
332	{0x5d, 0xa2, KEY_3},
333	{0x41, 0xbe, KEY_4},
334	{0x0b, 0xf5, KEY_5},
335	{0x43, 0xbd, KEY_6},
336	{0x47, 0xb8, KEY_7},
337	{0x49, 0xb6, KEY_8},
338	{0x05, 0xfa, KEY_9},
339	{0x45, 0xba, KEY_0},
340	{0x09, 0xf6, KEY_UP},	/*chanup */
341	{0x1b, 0xe5, KEY_DOWN},	/*chandown */
342	{0x5d, 0xa3, KEY_LEFT},	/*voldown */
343	{0x5f, 0xa1, KEY_RIGHT},	/*volup */
344	{0x07, 0xf8, KEY_SPACE},	/*tab */
345	{0x1f, 0xe1, KEY_ENTER},	/*play ok */
346	{0x1b, 0xe4, KEY_Z},	/*zoom */
347	{0x59, 0xa6, KEY_M},	/*mute */
348	{0x5b, 0xa5, KEY_F},	/*tv/f */
349	{0x19, 0xe7, KEY_R},	/*rec */
350	{0x01, 0xfe, KEY_S},	/*Stop */
351	{0x03, 0xfd, KEY_P},	/*pause */
352	{0x03, 0xfc, KEY_W},	/*<- -> */
353	{0x07, 0xf9, KEY_C},	/*capture */
354	{0x47, 0xb9, KEY_Q},	/*exit */
355	{0x43, 0xbc, KEY_O},	/*power */
356
357};
358
359static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
360{
361	struct opera1_state *opst = dev->priv;
362	u8 rcbuffer[32];
363	const u16 startmarker1 = 0x10ed;
364	const u16 startmarker2 = 0x11ec;
365	struct i2c_msg read_remote[] = {
366		{.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
367	};
368	int i = 0;
369	u32 send_key = 0;
370
371	if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
372		for (i = 0; i < 32; i++) {
373			if (rcbuffer[i])
374				send_key |= 1;
375			if (i < 31)
376				send_key = send_key << 1;
377		}
378		if (send_key & 0x8000)
379			send_key = (send_key << 1) | (send_key >> 15 & 0x01);
380
381		if (send_key == 0xffff && opst->last_key_pressed != 0) {
382			*state = REMOTE_KEY_REPEAT;
383			*event = opst->last_key_pressed;
384			return 0;
385		}
386		for (; send_key != 0;) {
387			if (send_key >> 16 == startmarker2) {
388				break;
389			} else if (send_key >> 16 == startmarker1) {
390				send_key =
391					(send_key & 0xfffeffff) | (startmarker1 << 16);
392				break;
393			} else
394				send_key >>= 1;
395		}
396
397		if (send_key == 0)
398			return 0;
399
400		send_key = (send_key & 0xffff) | 0x0100;
401
402		for (i = 0; i < ARRAY_SIZE(opera1_rc_keys); i++) {
403			if ((opera1_rc_keys[i].custom * 256 +
404					opera1_rc_keys[i].data) == (send_key & 0xffff)) {
405				*state = REMOTE_KEY_PRESSED;
406				*event = opera1_rc_keys[i].event;
407				opst->last_key_pressed =
408					opera1_rc_keys[i].event;
409				break;
410			}
411			opst->last_key_pressed = 0;
412		}
413	} else
414		*state = REMOTE_NO_KEY_PRESSED;
415	return 0;
416}
417
418static struct usb_device_id opera1_table[] = {
419	{USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
420	{USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
421	{}
422};
423
424MODULE_DEVICE_TABLE(usb, opera1_table);
425
426static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
427{
428	u8 command[] = { READ_MAC_ADDR };
429	opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
430	opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
431	return 0;
432}
433static int opera1_xilinx_load_firmware(struct usb_device *dev,
434				       const char *filename)
435{
436	const struct firmware *fw = NULL;
437	u8 *b, *p;
438	int ret = 0, i;
439	u8 testval;
440	info("start downloading fpga firmware");
441
442	if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
443		err("did not find the firmware file. (%s) "
444			"Please see linux/Documentation/dvb/ for more details on firmware-problems.",
445			filename);
446		return ret;
447	} else {
448		p = kmalloc(fw->size, GFP_KERNEL);
449		opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
450		if (p != NULL && testval != 0x67) {
451
452			u8 reset = 0, fpga_command = 0;
453			memcpy(p, fw->data, fw->size);
454			/* clear fpga ? */
455			opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
456					 OPERA_WRITE_MSG);
457			for (i = 0; p[i] != 0 && i < fw->size;) {
458				b = (u8 *) p + i;
459				if (opera1_xilinx_rw
460					(dev, OPERA_WRITE_FX2, 0x0, b + 1, b[0],
461						OPERA_WRITE_MSG) != b[0]
462					) {
463					err("error while transferring firmware");
464					ret = -EINVAL;
465					break;
466				}
467				i = i + 1 + b[0];
468			}
469			/* restart the CPU */
470			if (ret || opera1_xilinx_rw
471					(dev, 0xa0, 0xe600, &reset, 1,
472					OPERA_WRITE_MSG) != 1) {
473				err("could not restart the USB controller CPU.");
474				ret = -EINVAL;
475			}
476			kfree(p);
477		}
478	}
479	if (fw) {
480		release_firmware(fw);
481	}
482	return ret;
483}
484
485static struct dvb_usb_device_properties opera1_properties = {
486	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
487	.usb_ctrl = CYPRESS_FX2,
488	.firmware = "dvb-usb-opera-01.fw",
489	.size_of_priv = sizeof(struct opera1_state),
490
491	.power_ctrl = opera1_power_ctrl,
492	.i2c_algo = &opera1_i2c_algo,
493
494	.rc_key_map = opera1_rc_keys,
495	.rc_key_map_size = ARRAY_SIZE(opera1_rc_keys),
496	.rc_interval = 200,
497	.rc_query = opera1_rc_query,
498	.read_mac_address = opera1_read_mac_address,
499	.generic_bulk_ctrl_endpoint = 0x00,
500	/* parameter for the MPEG2-data transfer */
501	.num_adapters = 1,
502	.adapter = {
503		{
504			.frontend_attach = opera1_frontend_attach,
505			.streaming_ctrl = opera1_streaming_ctrl,
506			.tuner_attach = opera1_tuner_attach,
507			.caps =
508				DVB_USB_ADAP_HAS_PID_FILTER |
509				DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
510			.pid_filter = opera1_pid_filter,
511			.pid_filter_ctrl = opera1_pid_filter_control,
512			.pid_filter_count = 252,
513			.stream = {
514				.type = USB_BULK,
515				.count = 10,
516				.endpoint = 0x82,
517				.u = {
518					.bulk = {
519						.buffersize = 4096,
520					}
521				}
522			},
523		}
524	},
525	.num_device_descs = 1,
526	.devices = {
527		{"Opera1 DVB-S USB2.0",
528			{&opera1_table[0], NULL},
529			{&opera1_table[1], NULL},
530		},
531	}
532};
533
534static int opera1_probe(struct usb_interface *intf,
535			const struct usb_device_id *id)
536{
537	struct dvb_usb_device *d;
538	struct usb_device *udev = interface_to_usbdev(intf);
539
540	if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
541		udev->descriptor.idVendor == USB_VID_OPERA1 &&
542		(d == NULL
543			|| opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga.fw") != 0)
544		) {
545		return -EINVAL;
546	}
547
548	if (dvb_usb_device_init(intf, &opera1_properties, THIS_MODULE, &d) != 0)
549		return -EINVAL;
550	return 0;
551}
552
553static struct usb_driver opera1_driver = {
554	.name = "opera1",
555	.probe = opera1_probe,
556	.disconnect = dvb_usb_device_exit,
557	.id_table = opera1_table,
558};
559
560static int __init opera1_module_init(void)
561{
562	int result = 0;
563	if ((result = usb_register(&opera1_driver))) {
564		err("usb_register failed. Error number %d", result);
565	}
566	return result;
567}
568
569static void __exit opera1_module_exit(void)
570{
571	usb_deregister(&opera1_driver);
572}
573
574module_init(opera1_module_init);
575module_exit(opera1_module_exit);
576
577MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
578MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
579MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
580MODULE_VERSION("0.1");
581MODULE_LICENSE("GPL");
582