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