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