1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* driver for the SAA7146 based AV110 cards (like the Fujitsu-Siemens DVB)
4	* av7110.c: initialization and demux stuff
5	*
6	* Copyright (C) 1999-2002 Ralph Metzler
7	* & Marcus Metzler for convergence integrated media GmbH
8	*
9	* originally based on code by:
10	* Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
11	*
12	* the project's page is at https://linuxtv.org
13	*/
14
15
16	#include <linux/module.h>
17	#include <linux/kmod.h>
18	#include <linux/delay.h>
19	#include <linux/fs.h>
20	#include <linux/timer.h>
21	#include <linux/poll.h>
22
23	#include <linux/kernel.h>
24	#include <linux/sched.h>
25	#include <linux/types.h>
26	#include <linux/fcntl.h>
27	#include <linux/interrupt.h>
28	#include <linux/string.h>
29	#include <linux/pci.h>
30	#include <linux/vmalloc.h>
31	#include <linux/firmware.h>
32	#include <linux/crc32.h>
33	#include <linux/i2c.h>
34	#include <linux/kthread.h>
35	#include <linux/slab.h>
36	#include <asm/unaligned.h>
37	#include <asm/byteorder.h>
38
39
40	#include <linux/dvb/frontend.h>
41
42	#include <media/dvb_frontend.h>
43
44	#include "ttpci-eeprom.h"
45	#include "av7110.h"
46	#include "av7110_hw.h"
47	#include "av7110_av.h"
48	#include "av7110_ca.h"
49	#include "av7110_ipack.h"
50
51	#include "bsbe1.h"
52	#include "lnbp21.h"
53	#include "bsru6.h"
54
55	#define TS_WIDTH 376
56	#define TS_HEIGHT 512
57	#define TS_BUFLEN (TS_WIDTH*TS_HEIGHT)
58	#define TS_MAX_PACKETS (TS_BUFLEN/TS_SIZE)
59
60
61	int av7110_debug;
62
63	static int vidmode = CVBS_RGB_OUT;
64	static int pids_off;
65	static int adac = DVB_ADAC_TI;
66	static int hw_sections;
67	static int rgb_on;
68	static int volume = 255;
69	static int budgetpatch;
70	static int wss_cfg_4_3 = 0x4008;
71	static int wss_cfg_16_9 = 0x0007;
72	static int tv_standard;
73	static int full_ts;
74
75	module_param_named(debug, av7110_debug, int, 0644);
76	MODULE_PARM_DESC(debug, "debug level (bitmask, default 0)");
77	module_param(vidmode, int, 0444);
78	MODULE_PARM_DESC(vidmode,"analog video out: 0 off, 1 CVBS+RGB (default), 2 CVBS+YC, 3 YC");
79	module_param(pids_off, int, 0444);
80	MODULE_PARM_DESC(pids_off,"clear video/audio/PCR PID filters when demux is closed");
81	module_param(adac, int, 0444);
82	MODULE_PARM_DESC(adac,"audio DAC type: 0 TI, 1 CRYSTAL, 2 MSP (use if autodetection fails)");
83	module_param(hw_sections, int, 0444);
84	MODULE_PARM_DESC(hw_sections, "0 use software section filter, 1 use hardware");
85	module_param(rgb_on, int, 0444);
86	MODULE_PARM_DESC(rgb_on, "For Siemens DVB-C cards only: Enable RGB control signal on SCART pin 16 to switch SCART video mode from CVBS to RGB");
87	module_param(volume, int, 0444);
88	MODULE_PARM_DESC(volume, "initial volume: default 255 (range 0-255)");
89	module_param(budgetpatch, int, 0444);
90	MODULE_PARM_DESC(budgetpatch, "use budget-patch hardware modification: default 0 (0 no, 1 autodetect, 2 always)");
91	module_param(full_ts, int, 0444);
92	MODULE_PARM_DESC(full_ts, "enable code for full-ts hardware modification: 0 disable (default), 1 enable");
93	module_param(wss_cfg_4_3, int, 0444);
94	MODULE_PARM_DESC(wss_cfg_4_3, "WSS 4:3 - default 0x4008 - bit 15: disable, 14: burst mode, 13..0: wss data");
95	module_param(wss_cfg_16_9, int, 0444);
96	MODULE_PARM_DESC(wss_cfg_16_9, "WSS 16:9 - default 0x0007 - bit 15: disable, 14: burst mode, 13..0: wss data");
97	module_param(tv_standard, int, 0444);
98	MODULE_PARM_DESC(tv_standard, "TV standard: 0 PAL (default), 1 NTSC");
99
100	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
101
102	static void restart_feeds(struct av7110 *av7110);
103	static int budget_start_feed(struct dvb_demux_feed *feed);
104	static int budget_stop_feed(struct dvb_demux_feed *feed);
105
106	static int av7110_num;
107
108	#define FE_FUNC_OVERRIDE(fe_func, av7110_copy, av7110_func) \
109	{\
110	if (fe_func != NULL) { \
111	av7110_copy = fe_func; \
112	fe_func = av7110_func; \
113	} \
114	}
115
116
117	static void init_av7110_av(struct av7110 *av7110)
118	{
119	int ret;
120	struct saa7146_dev *dev = av7110->dev;
121
122	/* set internal volume control to maximum */
123	av7110->adac_type = DVB_ADAC_TI;
124	ret = av7110_set_volume(av7110, volleft: av7110->mixer.volume_left, volright: av7110->mixer.volume_right);
125	if (ret < 0)
126	printk("dvb-ttpci:cannot set internal volume to maximum:%d\n",ret);
127
128	ret = av7110_fw_cmd(av7110, type: COMTYPE_ENCODER, com: SetMonitorType,
129	num: 1, (u16) av7110->display_ar);
130	if (ret < 0)
131	printk("dvb-ttpci: unable to set aspect ratio\n");
132	ret = av7110_fw_cmd(av7110, type: COMTYPE_ENCODER, com: SetPanScanType,
133	num: 1, av7110->display_panscan);
134	if (ret < 0)
135	printk("dvb-ttpci: unable to set pan scan\n");
136
137	ret = av7110_fw_cmd(av7110, type: COMTYPE_ENCODER, com: SetWSSConfig, num: 2, 2, wss_cfg_4_3);
138	if (ret < 0)
139	printk("dvb-ttpci: unable to configure 4:3 wss\n");
140	ret = av7110_fw_cmd(av7110, type: COMTYPE_ENCODER, com: SetWSSConfig, num: 2, 3, wss_cfg_16_9);
141	if (ret < 0)
142	printk("dvb-ttpci: unable to configure 16:9 wss\n");
143
144	ret = av7710_set_video_mode(av7110, mode: vidmode);
145	if (ret < 0)
146	printk("dvb-ttpci:cannot set video mode:%d\n",ret);
147
148	/* handle different card types */
149	/* remaining inits according to card and frontend type */
150	av7110->analog_tuner_flags = 0;
151	av7110->current_input = 0;
152	if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000a)
153	av7110_fw_cmd(av7110, type: COMTYPE_AUDIODAC, com: ADSwitch, num: 1, 0); // SPDIF on
154	if (i2c_writereg(av7110, id: 0x20, reg: 0x00, val: 0x00) == 1) {
155	printk ("dvb-ttpci: Crystal audio DAC @ card %d detected\n",
156	av7110->dvb_adapter.num);
157	av7110->adac_type = DVB_ADAC_CRYSTAL;
158	i2c_writereg(av7110, id: 0x20, reg: 0x01, val: 0xd2);
159	i2c_writereg(av7110, id: 0x20, reg: 0x02, val: 0x49);
160	i2c_writereg(av7110, id: 0x20, reg: 0x03, val: 0x00);
161	i2c_writereg(av7110, id: 0x20, reg: 0x04, val: 0x00);
162
163	/**
164	* some special handling for the Siemens DVB-C cards...
165	*/
166	} else if (0 == av7110_init_analog_module(av7110)) {
167	/* done. */
168	}
169	else if (dev->pci->subsystem_vendor == 0x110a) {
170	printk("dvb-ttpci: DVB-C w/o analog module @ card %d detected\n",
171	av7110->dvb_adapter.num);
172	av7110->adac_type = DVB_ADAC_NONE;
173	}
174	else {
175	av7110->adac_type = adac;
176	printk("dvb-ttpci: adac type set to %d @ card %d\n",
177	av7110->adac_type, av7110->dvb_adapter.num);
178	}
179
180	if (av7110->adac_type == DVB_ADAC_NONE || av7110->adac_type == DVB_ADAC_MSP34x0) {
181	// switch DVB SCART on
182	ret = av7110_fw_cmd(av7110, type: COMTYPE_AUDIODAC, com: MainSwitch, num: 1, 0);
183	if (ret < 0)
184	printk("dvb-ttpci:cannot switch on SCART(Main):%d\n",ret);
185	ret = av7110_fw_cmd(av7110, type: COMTYPE_AUDIODAC, com: ADSwitch, num: 1, 1);
186	if (ret < 0)
187	printk("dvb-ttpci:cannot switch on SCART(AD):%d\n",ret);
188	if (rgb_on &&
189	((av7110->dev->pci->subsystem_vendor == 0x110a) ||
190	(av7110->dev->pci->subsystem_vendor == 0x13c2)) &&
191	(av7110->dev->pci->subsystem_device == 0x0000)) {
192	saa7146_setgpio(dev, port: 1, SAA7146_GPIO_OUTHI); // RGB on, SCART pin 16
193	//saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO); // SCARTpin 8
194	}
195	}
196
197	if (dev->pci->subsystem_vendor == 0x13c2 && dev->pci->subsystem_device == 0x000e)
198	av7110_fw_cmd(av7110, type: COMTYPE_AUDIODAC, com: SpdifSwitch, num: 1, 0); // SPDIF on
199
200	ret = av7110_set_volume(av7110, volleft: av7110->mixer.volume_left, volright: av7110->mixer.volume_right);
201	if (ret < 0)
202	printk("dvb-ttpci:cannot set volume :%d\n",ret);
203	}
204
205	static void recover_arm(struct av7110 *av7110)
206	{
207	dprintk(4, "%p\n",av7110);
208
209	av7110_bootarm(av7110);
210	msleep(msecs: 100);
211
212	init_av7110_av(av7110);
213
214	/* card-specific recovery */
215	if (av7110->recover)
216	av7110->recover(av7110);
217
218	restart_feeds(av7110);
219
220	#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
221	av7110_set_ir_config(av7110);
222	#endif
223	}
224
225	static void av7110_arm_sync(struct av7110 *av7110)
226	{
227	if (av7110->arm_thread)
228	kthread_stop(k: av7110->arm_thread);
229
230	av7110->arm_thread = NULL;
231	}
232
233	static int arm_thread(void *data)
234	{
235	struct av7110 *av7110 = data;
236	u16 newloops = 0;
237	int timeout;
238
239	dprintk(4, "%p\n",av7110);
240
241	for (;;) {
242	timeout = wait_event_interruptible_timeout(av7110->arm_wait,
243	kthread_should_stop(), 5 * HZ);
244
245	if (-ERESTARTSYS == timeout || kthread_should_stop()) {
246	/* got signal or told to quit*/
247	break;
248	}
249
250	if (!av7110->arm_ready)
251	continue;
252
253	if (mutex_lock_interruptible(&av7110->dcomlock))
254	break;
255	newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, val: 0, count: 2);
256	mutex_unlock(lock: &av7110->dcomlock);
257
258	if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
259	printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
260	av7110->dvb_adapter.num);
261
262	recover_arm(av7110);
263
264	if (mutex_lock_interruptible(&av7110->dcomlock))
265	break;
266	newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, val: 0, count: 2) - 1;
267	mutex_unlock(lock: &av7110->dcomlock);
268	}
269	av7110->arm_loops = newloops;
270	av7110->arm_errors = 0;
271	}
272
273	return 0;
274	}
275
276
277	/****************************************************************************
278	* IRQ handling
279	****************************************************************************/
280
281	static int DvbDmxFilterCallback(u8 *buffer1, size_t buffer1_len,
282	u8 *buffer2, size_t buffer2_len,
283	struct dvb_demux_filter *dvbdmxfilter,
284	struct av7110 *av7110)
285	{
286	if (!dvbdmxfilter->feed->demux->dmx.frontend)
287	return 0;
288	if (dvbdmxfilter->feed->demux->dmx.frontend->source == DMX_MEMORY_FE)
289	return 0;
290
291	switch (dvbdmxfilter->type) {
292	case DMX_TYPE_SEC:
293	if ((((buffer1[1] << 8) | buffer1[2]) & 0xfff) + 3 != buffer1_len)
294	return 0;
295	if (dvbdmxfilter->doneq) {
296	struct dmx_section_filter *filter = &dvbdmxfilter->filter;
297	int i;
298	u8 xor, neq = 0;
299
300	for (i = 0; i < DVB_DEMUX_MASK_MAX; i++) {
301	xor = filter->filter_value[i] ^ buffer1[i];
302	neq |= dvbdmxfilter->maskandnotmode[i] & xor;
303	}
304	if (!neq)
305	return 0;
306	}
307	return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
308	buffer2, buffer2_len,
309	&dvbdmxfilter->filter, NULL);
310	case DMX_TYPE_TS:
311	if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
312	return 0;
313	if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
314	return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
315	buffer2, buffer2_len,
316	&dvbdmxfilter->feed->feed.ts,
317	NULL);
318	else
319	av7110_p2t_write(buf: buffer1, length: buffer1_len,
320	pid: dvbdmxfilter->feed->pid,
321	p: &av7110->p2t_filter[dvbdmxfilter->index]);
322	return 0;
323	default:
324	return 0;
325	}
326	}
327
328
329	//#define DEBUG_TIMING
330	static inline void print_time(char *s)
331	{
332	#ifdef DEBUG_TIMING
333	struct timespec64 ts;
334	ktime_get_real_ts64(&ts);
335	printk("%s: %lld.%09ld\n", s, (s64)ts.tv_sec, ts.tv_nsec);
336	#endif
337	}
338
339	#define DEBI_READ 0
340	#define DEBI_WRITE 1
341	static inline void start_debi_dma(struct av7110 *av7110, int dir,
342	unsigned long addr, unsigned int len)
343	{
344	dprintk(8, "%c %08lx %u\n", dir == DEBI_READ ? 'R' : 'W', addr, len);
345	if (saa7146_wait_for_debi_done(dev: av7110->dev, nobusyloop: 0)) {
346	printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
347	return;
348	}
349
350	SAA7146_ISR_CLEAR(av7110->dev, MASK_19); /* for good measure */
351	SAA7146_IER_ENABLE(x: av7110->dev, MASK_19);
352	if (len < 5)
353	len = 5; /* we want a real DEBI DMA */
354	if (dir == DEBI_WRITE)
355	iwdebi(av7110, DEBISWAB, addr, val: 0, count: (len + 3) & ~3);
356	else
357	irdebi(av7110, DEBISWAB, addr, val: 0, count: len);
358	}
359
360	static void debiirq(struct tasklet_struct *t)
361	{
362	struct av7110 *av7110 = from_tasklet(av7110, t, debi_tasklet);
363	int type = av7110->debitype;
364	int handle = (type >> 8) & 0x1f;
365	unsigned int xfer = 0;
366
367	print_time(s: "debi");
368	dprintk(4, "type 0x%04x\n", type);
369
370	if (type == -1) {
371	printk("DEBI irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
372	jiffies, saa7146_read(av7110->dev, PSR),
373	saa7146_read(av7110->dev, SSR));
374	goto debi_done;
375	}
376	av7110->debitype = -1;
377
378	switch (type & 0xff) {
379
380	case DATA_TS_RECORD:
381	dvb_dmx_swfilter_packets(demux: &av7110->demux,
382	buf: (const u8 *) av7110->debi_virt,
383	count: av7110->debilen / 188);
384	xfer = RX_BUFF;
385	break;
386
387	case DATA_PES_RECORD:
388	if (av7110->demux.recording)
389	av7110_record_cb(p2t: &av7110->p2t[handle],
390	buf: (u8 *) av7110->debi_virt,
391	len: av7110->debilen);
392	xfer = RX_BUFF;
393	break;
394
395	case DATA_IPMPE:
396	case DATA_FSECTION:
397	case DATA_PIPING:
398	if (av7110->handle2filter[handle])
399	DvbDmxFilterCallback(buffer1: (u8 *)av7110->debi_virt,
400	buffer1_len: av7110->debilen, NULL, buffer2_len: 0,
401	dvbdmxfilter: av7110->handle2filter[handle],
402	av7110);
403	xfer = RX_BUFF;
404	break;
405
406	case DATA_CI_GET:
407	{
408	u8 *data = av7110->debi_virt;
409	u8 data_0 = data[0];
410
411	if (data_0 < 2 && data[2] == 0xff) {
412	int flags = 0;
413	if (data[5] > 0)
414	flags |= CA_CI_MODULE_PRESENT;
415	if (data[5] > 5)
416	flags |= CA_CI_MODULE_READY;
417	av7110->ci_slot[data_0].flags = flags;
418	} else
419	ci_get_data(cibuf: &av7110->ci_rbuffer,
420	data: av7110->debi_virt,
421	len: av7110->debilen);
422	xfer = RX_BUFF;
423	break;
424	}
425
426	case DATA_COMMON_INTERFACE:
427	CI_handle(av7110, data: (u8 *)av7110->debi_virt, len: av7110->debilen);
428	xfer = RX_BUFF;
429	break;
430
431	case DATA_DEBUG_MESSAGE:
432	((s8*)av7110->debi_virt)[Reserved_SIZE - 1] = 0;
433	printk("%s\n", (s8 *) av7110->debi_virt);
434	xfer = RX_BUFF;
435	break;
436
437	case DATA_CI_PUT:
438	dprintk(4, "debi DATA_CI_PUT\n");
439	xfer = TX_BUFF;
440	break;
441	case DATA_MPEG_PLAY:
442	dprintk(4, "debi DATA_MPEG_PLAY\n");
443	xfer = TX_BUFF;
444	break;
445	case DATA_BMP_LOAD:
446	dprintk(4, "debi DATA_BMP_LOAD\n");
447	xfer = TX_BUFF;
448	break;
449	default:
450	break;
451	}
452	debi_done:
453	spin_lock(lock: &av7110->debilock);
454	if (xfer)
455	iwdebi(av7110, DEBINOSWAP, addr: xfer, val: 0, count: 2);
456	ARM_ClearMailBox(av7110);
457	spin_unlock(lock: &av7110->debilock);
458	}
459
460	/* irq from av7110 firmware writing the mailbox register in the DPRAM */
461	static void gpioirq(struct tasklet_struct *t)
462	{
463	struct av7110 *av7110 = from_tasklet(av7110, t, gpio_tasklet);
464	u32 rxbuf, txbuf;
465	int len;
466
467	if (av7110->debitype != -1)
468	/* we shouldn't get any irq while a debi xfer is running */
469	printk("dvb-ttpci: GPIO0 irq oops @ %ld, psr:0x%08x, ssr:0x%08x\n",
470	jiffies, saa7146_read(av7110->dev, PSR),
471	saa7146_read(av7110->dev, SSR));
472
473	if (saa7146_wait_for_debi_done(dev: av7110->dev, nobusyloop: 0)) {
474	printk(KERN_ERR "%s: saa7146_wait_for_debi_done timed out\n", __func__);
475	BUG(); /* maybe we should try resetting the debi? */
476	}
477
478	spin_lock(lock: &av7110->debilock);
479	ARM_ClearIrq(av7110);
480
481	/* see what the av7110 wants */
482	av7110->debitype = irdebi(av7110, DEBINOSWAP, IRQ_STATE, val: 0, count: 2);
483	av7110->debilen = irdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
484	rxbuf = irdebi(av7110, DEBINOSWAP, RX_BUFF, val: 0, count: 2);
485	txbuf = irdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
486	len = (av7110->debilen + 3) & ~3;
487
488	print_time(s: "gpio");
489	dprintk(8, "GPIO0 irq 0x%04x %d\n", av7110->debitype, av7110->debilen);
490
491	switch (av7110->debitype & 0xff) {
492
493	case DATA_TS_PLAY:
494	case DATA_PES_PLAY:
495	break;
496
497	case DATA_MPEG_VIDEO_EVENT:
498	{
499	u32 h_ar;
500	struct video_event event;
501
502	av7110->video_size.w = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_WIDTH, val: 0, count: 2);
503	h_ar = irdebi(av7110, DEBINOSWAP, STATUS_MPEG_HEIGHT_AR, val: 0, count: 2);
504
505	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
506	iwdebi(av7110, DEBINOSWAP, RX_BUFF, val: 0, count: 2);
507
508	av7110->video_size.h = h_ar & 0xfff;
509
510	event.type = VIDEO_EVENT_SIZE_CHANGED;
511	event.u.size.w = av7110->video_size.w;
512	event.u.size.h = av7110->video_size.h;
513	switch ((h_ar >> 12) & 0xf)
514	{
515	case 3:
516	av7110->video_size.aspect_ratio = VIDEO_FORMAT_16_9;
517	event.u.size.aspect_ratio = VIDEO_FORMAT_16_9;
518	av7110->videostate.video_format = VIDEO_FORMAT_16_9;
519	break;
520	case 4:
521	av7110->video_size.aspect_ratio = VIDEO_FORMAT_221_1;
522	event.u.size.aspect_ratio = VIDEO_FORMAT_221_1;
523	av7110->videostate.video_format = VIDEO_FORMAT_221_1;
524	break;
525	default:
526	av7110->video_size.aspect_ratio = VIDEO_FORMAT_4_3;
527	event.u.size.aspect_ratio = VIDEO_FORMAT_4_3;
528	av7110->videostate.video_format = VIDEO_FORMAT_4_3;
529	}
530
531	dprintk(8, "GPIO0 irq: DATA_MPEG_VIDEO_EVENT: w/h/ar = %u/%u/%u\n",
532	av7110->video_size.w, av7110->video_size.h,
533	av7110->video_size.aspect_ratio);
534
535	dvb_video_add_event(av7110, event: &event);
536	break;
537	}
538
539	case DATA_CI_PUT:
540	{
541	int avail;
542	struct dvb_ringbuffer *cibuf = &av7110->ci_wbuffer;
543
544	avail = dvb_ringbuffer_avail(rbuf: cibuf);
545	if (avail <= 2) {
546	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
547	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: 0, count: 2);
548	iwdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
549	break;
550	}
551	len = DVB_RINGBUFFER_PEEK(cibuf, 0) << 8;
552	len |= DVB_RINGBUFFER_PEEK(cibuf, 1);
553	if (avail < len + 2) {
554	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
555	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: 0, count: 2);
556	iwdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
557	break;
558	}
559	DVB_RINGBUFFER_SKIP(cibuf, 2);
560
561	dvb_ringbuffer_read(rbuf: cibuf, buf: av7110->debi_virt, len);
562
563	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: len, count: 2);
564	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: len, count: 2);
565	dprintk(8, "DMA: CI\n");
566	start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
567	spin_unlock(lock: &av7110->debilock);
568	wake_up(&cibuf->queue);
569	return;
570	}
571
572	case DATA_MPEG_PLAY:
573	if (!av7110->playing) {
574	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
575	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: 0, count: 2);
576	iwdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
577	break;
578	}
579	len = 0;
580	if (av7110->debitype & 0x100) {
581	spin_lock(lock: &av7110->aout.lock);
582	len = av7110_pes_play(dest: av7110->debi_virt, buf: &av7110->aout, dlen: 2048);
583	spin_unlock(lock: &av7110->aout.lock);
584	}
585	if (len <= 0 && (av7110->debitype & 0x200)
586	&&av7110->videostate.play_state != VIDEO_FREEZED) {
587	spin_lock(lock: &av7110->avout.lock);
588	len = av7110_pes_play(dest: av7110->debi_virt, buf: &av7110->avout, dlen: 2048);
589	spin_unlock(lock: &av7110->avout.lock);
590	}
591	if (len <= 0) {
592	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
593	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: 0, count: 2);
594	iwdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
595	break;
596	}
597	dprintk(8, "GPIO0 PES_PLAY len=%04x\n", len);
598	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: len, count: 2);
599	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: len, count: 2);
600	dprintk(8, "DMA: MPEG_PLAY\n");
601	start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE + txbuf, len);
602	spin_unlock(lock: &av7110->debilock);
603	return;
604
605	case DATA_BMP_LOAD:
606	len = av7110->debilen;
607	dprintk(8, "gpio DATA_BMP_LOAD len %d\n", len);
608	if (!len) {
609	av7110->bmp_state = BMP_LOADED;
610	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: 0, count: 2);
611	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: 0, count: 2);
612	iwdebi(av7110, DEBINOSWAP, TX_BUFF, val: 0, count: 2);
613	wake_up(&av7110->bmpq);
614	dprintk(8, "gpio DATA_BMP_LOAD done\n");
615	break;
616	}
617	if (len > av7110->bmplen)
618	len = av7110->bmplen;
619	if (len > 2 * 1024)
620	len = 2 * 1024;
621	iwdebi(av7110, DEBINOSWAP, TX_LEN, val: len, count: 2);
622	iwdebi(av7110, DEBINOSWAP, IRQ_STATE_EXT, val: len, count: 2);
623	memcpy(av7110->debi_virt, av7110->bmpbuf+av7110->bmpp, len);
624	av7110->bmpp += len;
625	av7110->bmplen -= len;
626	dprintk(8, "gpio DATA_BMP_LOAD DMA len %d\n", len);
627	start_debi_dma(av7110, DEBI_WRITE, DPRAM_BASE+txbuf, len);
628	spin_unlock(lock: &av7110->debilock);
629	return;
630
631	case DATA_CI_GET:
632	case DATA_COMMON_INTERFACE:
633	case DATA_FSECTION:
634	case DATA_IPMPE:
635	case DATA_PIPING:
636	if (!len || len > 4 * 1024) {
637	iwdebi(av7110, DEBINOSWAP, RX_BUFF, val: 0, count: 2);
638	break;
639	}
640	fallthrough;
641
642	case DATA_TS_RECORD:
643	case DATA_PES_RECORD:
644	dprintk(8, "DMA: TS_REC etc.\n");
645	start_debi_dma(av7110, DEBI_READ, DPRAM_BASE+rxbuf, len);
646	spin_unlock(lock: &av7110->debilock);
647	return;
648
649	case DATA_DEBUG_MESSAGE:
650	if (!len || len > 0xff) {
651	iwdebi(av7110, DEBINOSWAP, RX_BUFF, val: 0, count: 2);
652	break;
653	}
654	start_debi_dma(av7110, DEBI_READ, Reserved, len);
655	spin_unlock(lock: &av7110->debilock);
656	return;
657
658	case DATA_IRCOMMAND:
659	#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
660	av7110_ir_handler(av7110,
661	swahw32(irdebi(av7110, DEBINOSWAP, Reserved,
662	0, 4)));
663	#endif
664	iwdebi(av7110, DEBINOSWAP, RX_BUFF, val: 0, count: 2);
665	break;
666
667	default:
668	printk("dvb-ttpci: gpioirq unknown type=%d len=%d\n",
669	av7110->debitype, av7110->debilen);
670	break;
671	}
672	av7110->debitype = -1;
673	ARM_ClearMailBox(av7110);
674	spin_unlock(lock: &av7110->debilock);
675	}
676
677
678	#ifdef CONFIG_DVB_AV7110_OSD
679	static int dvb_osd_ioctl(struct file *file,
680	unsigned int cmd, void *parg)
681	{
682	struct dvb_device *dvbdev = file->private_data;
683	struct av7110 *av7110 = dvbdev->priv;
684
685	dprintk(4, "%p\n", av7110);
686
687	if (cmd == OSD_SEND_CMD)
688	return av7110_osd_cmd(av7110, dc: (osd_cmd_t *) parg);
689	if (cmd == OSD_GET_CAPABILITY)
690	return av7110_osd_capability(av7110, cap: (osd_cap_t *) parg);
691
692	return -EINVAL;
693	}
694
695
696	static const struct file_operations dvb_osd_fops = {
697	.owner = THIS_MODULE,
698	.unlocked_ioctl = dvb_generic_ioctl,
699	.open = dvb_generic_open,
700	.release = dvb_generic_release,
701	.llseek = noop_llseek,
702	};
703
704	static struct dvb_device dvbdev_osd = {
705	.priv = NULL,
706	.users = 1,
707	.writers = 1,
708	.fops = &dvb_osd_fops,
709	.kernel_ioctl = dvb_osd_ioctl,
710	};
711	#endif /* CONFIG_DVB_AV7110_OSD */
712
713
714	static inline int SetPIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
715	u16 subpid, u16 pcrpid)
716	{
717	u16 aflags = 0;
718
719	dprintk(4, "%p\n", av7110);
720
721	if (vpid == 0x1fff || apid == 0x1fff ||
722	ttpid == 0x1fff || subpid == 0x1fff || pcrpid == 0x1fff) {
723	vpid = apid = ttpid = subpid = pcrpid = 0;
724	av7110->pids[DMX_PES_VIDEO] = 0;
725	av7110->pids[DMX_PES_AUDIO] = 0;
726	av7110->pids[DMX_PES_TELETEXT] = 0;
727	av7110->pids[DMX_PES_PCR] = 0;
728	}
729
730	if (av7110->audiostate.bypass_mode)
731	aflags |= 0x8000;
732
733	return av7110_fw_cmd(av7110, type: COMTYPE_PIDFILTER, com: MultiPID, num: 6,
734	pcrpid, vpid, apid, ttpid, subpid, aflags);
735	}
736
737	int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
738	u16 subpid, u16 pcrpid)
739	{
740	int ret = 0;
741	dprintk(4, "%p\n", av7110);
742
743	if (mutex_lock_interruptible(&av7110->pid_mutex))
744	return -ERESTARTSYS;
745
746	if (!(vpid & 0x8000))
747	av7110->pids[DMX_PES_VIDEO] = vpid;
748	if (!(apid & 0x8000))
749	av7110->pids[DMX_PES_AUDIO] = apid;
750	if (!(ttpid & 0x8000))
751	av7110->pids[DMX_PES_TELETEXT] = ttpid;
752	if (!(pcrpid & 0x8000))
753	av7110->pids[DMX_PES_PCR] = pcrpid;
754
755	av7110->pids[DMX_PES_SUBTITLE] = 0;
756
757	if (av7110->fe_synced) {
758	pcrpid = av7110->pids[DMX_PES_PCR];
759	ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
760	}
761
762	mutex_unlock(lock: &av7110->pid_mutex);
763	return ret;
764	}
765
766
767	/******************************************************************************
768	* hardware filter functions
769	******************************************************************************/
770
771	static int StartHWFilter(struct dvb_demux_filter *dvbdmxfilter)
772	{
773	struct dvb_demux_feed *dvbdmxfeed = dvbdmxfilter->feed;
774	struct av7110 *av7110 = dvbdmxfeed->demux->priv;
775	u16 buf[20];
776	int ret, i;
777	u16 handle;
778	// u16 mode = 0x0320;
779	u16 mode = 0xb96a;
780
781	dprintk(4, "%p\n", av7110);
782
783	if (av7110->full_ts)
784	return 0;
785
786	if (dvbdmxfilter->type == DMX_TYPE_SEC) {
787	if (hw_sections) {
788	buf[4] = (dvbdmxfilter->filter.filter_value[0] << 8) |
789	dvbdmxfilter->maskandmode[0];
790	for (i = 3; i < 18; i++)
791	buf[i + 4 - 2] =
792	(dvbdmxfilter->filter.filter_value[i] << 8) |
793	dvbdmxfilter->maskandmode[i];
794	mode = 4;
795	}
796	} else if ((dvbdmxfeed->ts_type & TS_PACKET) &&
797	!(dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)) {
798	av7110_p2t_init(p: &av7110->p2t_filter[dvbdmxfilter->index], feed: dvbdmxfeed);
799	}
800
801	buf[0] = (COMTYPE_PID_FILTER << 8) + AddPIDFilter;
802	buf[1] = 16;
803	buf[2] = dvbdmxfeed->pid;
804	buf[3] = mode;
805
806	ret = av7110_fw_request(av7110, request_buf: buf, request_buf_len: 20, reply_buf: &handle, reply_buf_len: 1);
807	if (ret != 0 || handle >= 32) {
808	printk(KERN_ERR "dvb-ttpci: %s error buf %04x %04x %04x %04x ret %d handle %04x\n",
809	__func__, buf[0], buf[1], buf[2], buf[3],
810	ret, handle);
811	dvbdmxfilter->hw_handle = 0xffff;
812	if (!ret)
813	ret = -1;
814	return ret;
815	}
816
817	av7110->handle2filter[handle] = dvbdmxfilter;
818	dvbdmxfilter->hw_handle = handle;
819
820	return ret;
821	}
822
823	static int StopHWFilter(struct dvb_demux_filter *dvbdmxfilter)
824	{
825	struct av7110 *av7110 = dvbdmxfilter->feed->demux->priv;
826	u16 buf[3];
827	u16 answ[2];
828	int ret;
829	u16 handle;
830
831	dprintk(4, "%p\n", av7110);
832
833	if (av7110->full_ts)
834	return 0;
835
836	handle = dvbdmxfilter->hw_handle;
837	if (handle >= 32) {
838	printk("%s tried to stop invalid filter %04x, filter type = %x\n",
839	__func__, handle, dvbdmxfilter->type);
840	return -EINVAL;
841	}
842
843	av7110->handle2filter[handle] = NULL;
844
845	buf[0] = (COMTYPE_PID_FILTER << 8) + DelPIDFilter;
846	buf[1] = 1;
847	buf[2] = handle;
848	ret = av7110_fw_request(av7110, request_buf: buf, request_buf_len: 3, reply_buf: answ, reply_buf_len: 2);
849	if (ret != 0 || answ[1] != handle) {
850	printk(KERN_ERR "dvb-ttpci: %s error cmd %04x %04x %04x ret %x resp %04x %04x pid %d\n",
851	__func__, buf[0], buf[1], buf[2], ret,
852	answ[0], answ[1], dvbdmxfilter->feed->pid);
853	if (!ret)
854	ret = -1;
855	}
856	return ret;
857	}
858
859
860	static int dvb_feed_start_pid(struct dvb_demux_feed *dvbdmxfeed)
861	{
862	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
863	struct av7110 *av7110 = dvbdmx->priv;
864	u16 *pid = dvbdmx->pids, npids[5];
865	int i;
866	int ret = 0;
867
868	dprintk(4, "%p\n", av7110);
869
870	npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
871	i = dvbdmxfeed->pes_type;
872	npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
873	if ((i == 2) && npids[i] && (dvbdmxfeed->ts_type & TS_PACKET)) {
874	npids[i] = 0;
875	ret = ChangePIDs(av7110, vpid: npids[1], apid: npids[0], ttpid: npids[2], subpid: npids[3], pcrpid: npids[4]);
876	if (!ret)
877	ret = StartHWFilter(dvbdmxfilter: dvbdmxfeed->filter);
878	return ret;
879	}
880	if (dvbdmxfeed->pes_type <= 2 || dvbdmxfeed->pes_type == 4) {
881	ret = ChangePIDs(av7110, vpid: npids[1], apid: npids[0], ttpid: npids[2], subpid: npids[3], pcrpid: npids[4]);
882	if (ret)
883	return ret;
884	}
885
886	if (dvbdmxfeed->pes_type < 2 && npids[0])
887	if (av7110->fe_synced)
888	{
889	ret = av7110_fw_cmd(av7110, type: COMTYPE_PIDFILTER, com: Scan, num: 0);
890	if (ret)
891	return ret;
892	}
893
894	if ((dvbdmxfeed->ts_type & TS_PACKET) && !av7110->full_ts) {
895	if (dvbdmxfeed->pes_type == 0 && !(dvbdmx->pids[0] & 0x8000))
896	ret = av7110_av_start_record(av7110, RP_AUDIO, dvbdmxfeed);
897	if (dvbdmxfeed->pes_type == 1 && !(dvbdmx->pids[1] & 0x8000))
898	ret = av7110_av_start_record(av7110, RP_VIDEO, dvbdmxfeed);
899	}
900	return ret;
901	}
902
903	static int dvb_feed_stop_pid(struct dvb_demux_feed *dvbdmxfeed)
904	{
905	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
906	struct av7110 *av7110 = dvbdmx->priv;
907	u16 *pid = dvbdmx->pids, npids[5];
908	int i;
909
910	int ret = 0;
911
912	dprintk(4, "%p\n", av7110);
913
914	if (dvbdmxfeed->pes_type <= 1) {
915	ret = av7110_av_stop(av7110, av: dvbdmxfeed->pes_type ? RP_VIDEO : RP_AUDIO);
916	if (ret)
917	return ret;
918	if (!av7110->rec_mode)
919	dvbdmx->recording = 0;
920	if (!av7110->playing)
921	dvbdmx->playing = 0;
922	}
923	npids[0] = npids[1] = npids[2] = npids[3] = npids[4] = 0xffff;
924	i = dvbdmxfeed->pes_type;
925	switch (i) {
926	case 2: //teletext
927	if (dvbdmxfeed->ts_type & TS_PACKET)
928	ret = StopHWFilter(dvbdmxfilter: dvbdmxfeed->filter);
929	npids[2] = 0;
930	break;
931	case 0:
932	case 1:
933	case 4:
934	if (!pids_off)
935	return 0;
936	npids[i] = (pid[i]&0x8000) ? 0 : pid[i];
937	break;
938	}
939	if (!ret)
940	ret = ChangePIDs(av7110, vpid: npids[1], apid: npids[0], ttpid: npids[2], subpid: npids[3], pcrpid: npids[4]);
941	return ret;
942	}
943
944	static int av7110_start_feed(struct dvb_demux_feed *feed)
945	{
946	struct dvb_demux *demux = feed->demux;
947	struct av7110 *av7110 = demux->priv;
948	int ret = 0;
949
950	dprintk(4, "%p\n", av7110);
951
952	if (!demux->dmx.frontend)
953	return -EINVAL;
954
955	if (!av7110->full_ts && feed->pid > 0x1fff)
956	return -EINVAL;
957
958	if (feed->type == DMX_TYPE_TS) {
959	if ((feed->ts_type & TS_DECODER) &&
960	(feed->pes_type <= DMX_PES_PCR)) {
961	switch (demux->dmx.frontend->source) {
962	case DMX_MEMORY_FE:
963	if (feed->ts_type & TS_DECODER)
964	if (feed->pes_type < 2 &&
965	!(demux->pids[0] & 0x8000) &&
966	!(demux->pids[1] & 0x8000)) {
967	dvb_ringbuffer_flush_spinlock_wakeup(rbuf: &av7110->avout);
968	dvb_ringbuffer_flush_spinlock_wakeup(rbuf: &av7110->aout);
969	ret = av7110_av_start_play(av7110,RP_AV);
970	if (!ret)
971	demux->playing = 1;
972	}
973	break;
974	default:
975	ret = dvb_feed_start_pid(dvbdmxfeed: feed);
976	break;
977	}
978	} else if ((feed->ts_type & TS_PACKET) &&
979	(demux->dmx.frontend->source != DMX_MEMORY_FE)) {
980	ret = StartHWFilter(dvbdmxfilter: feed->filter);
981	}
982	}
983
984	if (av7110->full_ts) {
985	budget_start_feed(feed);
986	return ret;
987	}
988
989	if (feed->type == DMX_TYPE_SEC) {
990	int i;
991
992	for (i = 0; i < demux->filternum; i++) {
993	if (demux->filter[i].state != DMX_STATE_READY)
994	continue;
995	if (demux->filter[i].type != DMX_TYPE_SEC)
996	continue;
997	if (demux->filter[i].filter.parent != &feed->feed.sec)
998	continue;
999	demux->filter[i].state = DMX_STATE_GO;
1000	if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1001	ret = StartHWFilter(dvbdmxfilter: &demux->filter[i]);
1002	if (ret)
1003	break;
1004	}
1005	}
1006	}
1007
1008	return ret;
1009	}
1010
1011
1012	static int av7110_stop_feed(struct dvb_demux_feed *feed)
1013	{
1014	struct dvb_demux *demux = feed->demux;
1015	struct av7110 *av7110 = demux->priv;
1016	int i, rc, ret = 0;
1017	dprintk(4, "%p\n", av7110);
1018
1019	if (feed->type == DMX_TYPE_TS) {
1020	if (feed->ts_type & TS_DECODER) {
1021	if (feed->pes_type >= DMX_PES_OTHER ||
1022	!demux->pesfilter[feed->pes_type])
1023	return -EINVAL;
1024	demux->pids[feed->pes_type] |= 0x8000;
1025	demux->pesfilter[feed->pes_type] = NULL;
1026	}
1027	if (feed->ts_type & TS_DECODER &&
1028	feed->pes_type < DMX_PES_OTHER) {
1029	ret = dvb_feed_stop_pid(dvbdmxfeed: feed);
1030	} else
1031	if ((feed->ts_type & TS_PACKET) &&
1032	(demux->dmx.frontend->source != DMX_MEMORY_FE))
1033	ret = StopHWFilter(dvbdmxfilter: feed->filter);
1034	}
1035
1036	if (av7110->full_ts) {
1037	budget_stop_feed(feed);
1038	return ret;
1039	}
1040
1041	if (feed->type == DMX_TYPE_SEC) {
1042	for (i = 0; i<demux->filternum; i++) {
1043	if (demux->filter[i].state == DMX_STATE_GO &&
1044	demux->filter[i].filter.parent == &feed->feed.sec) {
1045	demux->filter[i].state = DMX_STATE_READY;
1046	if (demux->dmx.frontend->source != DMX_MEMORY_FE) {
1047	rc = StopHWFilter(dvbdmxfilter: &demux->filter[i]);
1048	if (!ret)
1049	ret = rc;
1050	/* keep going, stop as many filters as possible */
1051	}
1052	}
1053	}
1054	}
1055
1056	return ret;
1057	}
1058
1059
1060	static void restart_feeds(struct av7110 *av7110)
1061	{
1062	struct dvb_demux *dvbdmx = &av7110->demux;
1063	struct dvb_demux_feed *feed;
1064	int mode;
1065	int feeding;
1066	int i, j;
1067
1068	dprintk(4, "%p\n", av7110);
1069
1070	mode = av7110->playing;
1071	av7110->playing = 0;
1072	av7110->rec_mode = 0;
1073
1074	feeding = av7110->feeding1; /* full_ts mod */
1075
1076	for (i = 0; i < dvbdmx->feednum; i++) {
1077	feed = &dvbdmx->feed[i];
1078	if (feed->state == DMX_STATE_GO) {
1079	if (feed->type == DMX_TYPE_SEC) {
1080	for (j = 0; j < dvbdmx->filternum; j++) {
1081	if (dvbdmx->filter[j].type != DMX_TYPE_SEC)
1082	continue;
1083	if (dvbdmx->filter[j].filter.parent != &feed->feed.sec)
1084	continue;
1085	if (dvbdmx->filter[j].state == DMX_STATE_GO)
1086	dvbdmx->filter[j].state = DMX_STATE_READY;
1087	}
1088	}
1089	av7110_start_feed(feed);
1090	}
1091	}
1092
1093	av7110->feeding1 = feeding; /* full_ts mod */
1094
1095	if (mode)
1096	av7110_av_start_play(av7110, av: mode);
1097	}
1098
1099	static int dvb_get_stc(struct dmx_demux *demux, unsigned int num,
1100	uint64_t *stc, unsigned int *base)
1101	{
1102	int ret;
1103	u16 fwstc[4];
1104	u16 tag = ((COMTYPE_REQUEST << 8) + ReqSTC);
1105	struct dvb_demux *dvbdemux;
1106	struct av7110 *av7110;
1107
1108	/* pointer casting paranoia... */
1109	if (WARN_ON(!demux))
1110	return -EIO;
1111	dvbdemux = demux->priv;
1112	if (WARN_ON(!dvbdemux))
1113	return -EIO;
1114	av7110 = dvbdemux->priv;
1115
1116	dprintk(4, "%p\n", av7110);
1117
1118	if (num != 0)
1119	return -EINVAL;
1120
1121	ret = av7110_fw_request(av7110, request_buf: &tag, request_buf_len: 0, reply_buf: fwstc, reply_buf_len: 4);
1122	if (ret) {
1123	printk(KERN_ERR "%s: av7110_fw_request error\n", __func__);
1124	return ret;
1125	}
1126	dprintk(2, "fwstc = %04hx %04hx %04hx %04hx\n",
1127	fwstc[0], fwstc[1], fwstc[2], fwstc[3]);
1128
1129	*stc = (((uint64_t) ((fwstc[3] & 0x8000) >> 15)) << 32) |
1130	(((uint64_t) fwstc[1]) << 16) | ((uint64_t) fwstc[0]);
1131	*base = 1;
1132
1133	dprintk(4, "stc = %lu\n", (unsigned long)*stc);
1134
1135	return 0;
1136	}
1137
1138
1139	/******************************************************************************
1140	* SEC device file operations
1141	******************************************************************************/
1142
1143
1144	static int av7110_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
1145	{
1146	struct av7110* av7110 = fe->dvb->priv;
1147
1148	switch (tone) {
1149	case SEC_TONE_ON:
1150	return Set22K(av7110, state: 1);
1151
1152	case SEC_TONE_OFF:
1153	return Set22K(av7110, state: 0);
1154
1155	default:
1156	return -EINVAL;
1157	}
1158	}
1159
1160	static int av7110_diseqc_send_master_cmd(struct dvb_frontend* fe,
1161	struct dvb_diseqc_master_cmd* cmd)
1162	{
1163	struct av7110* av7110 = fe->dvb->priv;
1164
1165	return av7110_diseqc_send(av7110, len: cmd->msg_len, msg: cmd->msg, burst: -1);
1166	}
1167
1168	static int av7110_diseqc_send_burst(struct dvb_frontend* fe,
1169	enum fe_sec_mini_cmd minicmd)
1170	{
1171	struct av7110* av7110 = fe->dvb->priv;
1172
1173	return av7110_diseqc_send(av7110, len: 0, NULL, burst: minicmd);
1174	}
1175
1176	/* simplified code from budget-core.c */
1177	static int stop_ts_capture(struct av7110 *budget)
1178	{
1179	dprintk(2, "budget: %p\n", budget);
1180
1181	if (--budget->feeding1)
1182	return budget->feeding1;
1183	saa7146_write(budget->dev, MC1, MASK_20); /* DMA3 off */
1184	SAA7146_IER_DISABLE(x: budget->dev, MASK_10);
1185	SAA7146_ISR_CLEAR(budget->dev, MASK_10);
1186	return 0;
1187	}
1188
1189	static int start_ts_capture(struct av7110 *budget)
1190	{
1191	unsigned y;
1192
1193	dprintk(2, "budget: %p\n", budget);
1194
1195	if (budget->feeding1)
1196	return ++budget->feeding1;
1197	for (y = 0; y < TS_HEIGHT; y++)
1198	memset(budget->grabbing + y * TS_WIDTH, 0x00, TS_WIDTH);
1199	budget->ttbp = 0;
1200	SAA7146_ISR_CLEAR(budget->dev, MASK_10); /* VPE */
1201	SAA7146_IER_ENABLE(x: budget->dev, MASK_10); /* VPE */
1202	saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1203	return ++budget->feeding1;
1204	}
1205
1206	static int budget_start_feed(struct dvb_demux_feed *feed)
1207	{
1208	struct dvb_demux *demux = feed->demux;
1209	struct av7110 *budget = demux->priv;
1210	int status;
1211
1212	dprintk(2, "av7110: %p\n", budget);
1213
1214	spin_lock(lock: &budget->feedlock1);
1215	feed->pusi_seen = false; /* have a clean section start */
1216	status = start_ts_capture(budget);
1217	spin_unlock(lock: &budget->feedlock1);
1218	return status;
1219	}
1220
1221	static int budget_stop_feed(struct dvb_demux_feed *feed)
1222	{
1223	struct dvb_demux *demux = feed->demux;
1224	struct av7110 *budget = demux->priv;
1225	int status;
1226
1227	dprintk(2, "budget: %p\n", budget);
1228
1229	spin_lock(lock: &budget->feedlock1);
1230	status = stop_ts_capture(budget);
1231	spin_unlock(lock: &budget->feedlock1);
1232	return status;
1233	}
1234
1235	static void vpeirq(struct tasklet_struct *t)
1236	{
1237	struct av7110 *budget = from_tasklet(budget, t, vpe_tasklet);
1238	u8 *mem = (u8 *) (budget->grabbing);
1239	u32 olddma = budget->ttbp;
1240	u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1241	struct dvb_demux *demux = budget->full_ts ? &budget->demux : &budget->demux1;
1242
1243	/* nearest lower position divisible by 188 */
1244	newdma -= newdma % 188;
1245
1246	if (newdma >= TS_BUFLEN)
1247	return;
1248
1249	budget->ttbp = newdma;
1250
1251	if (!budget->feeding1 || (newdma == olddma))
1252	return;
1253
1254	/* Ensure streamed PCI data is synced to CPU */
1255	dma_sync_sg_for_cpu(dev: &budget->dev->pci->dev, sg: budget->pt.slist,
1256	nelems: budget->pt.nents, dir: DMA_FROM_DEVICE);
1257
1258	#if 0
1259	/* track rps1 activity */
1260	printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1261	mem[olddma],
1262	saa7146_read(budget->dev, EC1R) & 0x3fff);
1263	#endif
1264
1265	if (newdma > olddma)
1266	/* no wraparound, dump olddma..newdma */
1267	dvb_dmx_swfilter_packets(demux, buf: mem + olddma, count: (newdma - olddma) / 188);
1268	else {
1269	/* wraparound, dump olddma..buflen and 0..newdma */
1270	dvb_dmx_swfilter_packets(demux, buf: mem + olddma, count: (TS_BUFLEN - olddma) / 188);
1271	dvb_dmx_swfilter_packets(demux, buf: mem, count: newdma / 188);
1272	}
1273	}
1274
1275	static int av7110_register(struct av7110 *av7110)
1276	{
1277	int ret, i;
1278	struct dvb_demux *dvbdemux = &av7110->demux;
1279	struct dvb_demux *dvbdemux1 = &av7110->demux1;
1280
1281	dprintk(4, "%p\n", av7110);
1282
1283	if (av7110->registered)
1284	return -1;
1285
1286	av7110->registered = 1;
1287
1288	dvbdemux->priv = (void *) av7110;
1289
1290	for (i = 0; i < 32; i++)
1291	av7110->handle2filter[i] = NULL;
1292
1293	dvbdemux->filternum = (av7110->full_ts) ? 256 : 32;
1294	dvbdemux->feednum = (av7110->full_ts) ? 256 : 32;
1295	dvbdemux->start_feed = av7110_start_feed;
1296	dvbdemux->stop_feed = av7110_stop_feed;
1297	dvbdemux->write_to_decoder = av7110_write_to_decoder;
1298	dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1299	DMX_MEMORY_BASED_FILTERING);
1300
1301	dvb_dmx_init(demux: &av7110->demux);
1302	av7110->demux.dmx.get_stc = dvb_get_stc;
1303
1304	av7110->dmxdev.filternum = (av7110->full_ts) ? 256 : 32;
1305	av7110->dmxdev.demux = &dvbdemux->dmx;
1306	av7110->dmxdev.capabilities = 0;
1307
1308	dvb_dmxdev_init(dmxdev: &av7110->dmxdev, adap: &av7110->dvb_adapter);
1309
1310	av7110->hw_frontend.source = DMX_FRONTEND_0;
1311
1312	ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1313
1314	if (ret < 0)
1315	return ret;
1316
1317	av7110->mem_frontend.source = DMX_MEMORY_FE;
1318
1319	ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1320
1321	if (ret < 0)
1322	return ret;
1323
1324	ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1325	&av7110->hw_frontend);
1326	if (ret < 0)
1327	return ret;
1328
1329	av7110_av_register(av7110);
1330	av7110_ca_register(av7110);
1331
1332	#ifdef CONFIG_DVB_AV7110_OSD
1333	dvb_register_device(adap: &av7110->dvb_adapter, pdvbdev: &av7110->osd_dev,
1334	template: &dvbdev_osd, priv: av7110, type: DVB_DEVICE_OSD, demux_sink_pads: 0);
1335	#endif
1336
1337	dvb_net_init(adap: &av7110->dvb_adapter, dvbnet: &av7110->dvb_net, dmxdemux: &dvbdemux->dmx);
1338
1339	if (budgetpatch) {
1340	/* initialize software demux1 without its own frontend
1341	* demux1 hardware is connected to frontend0 of demux0
1342	*/
1343	dvbdemux1->priv = (void *) av7110;
1344
1345	dvbdemux1->filternum = 256;
1346	dvbdemux1->feednum = 256;
1347	dvbdemux1->start_feed = budget_start_feed;
1348	dvbdemux1->stop_feed = budget_stop_feed;
1349	dvbdemux1->write_to_decoder = NULL;
1350
1351	dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1352	DMX_MEMORY_BASED_FILTERING);
1353
1354	dvb_dmx_init(demux: &av7110->demux1);
1355
1356	av7110->dmxdev1.filternum = 256;
1357	av7110->dmxdev1.demux = &dvbdemux1->dmx;
1358	av7110->dmxdev1.capabilities = 0;
1359
1360	dvb_dmxdev_init(dmxdev: &av7110->dmxdev1, adap: &av7110->dvb_adapter);
1361
1362	dvb_net_init(adap: &av7110->dvb_adapter, dvbnet: &av7110->dvb_net1, dmxdemux: &dvbdemux1->dmx);
1363	printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1364	}
1365	return 0;
1366	}
1367
1368
1369	static void dvb_unregister(struct av7110 *av7110)
1370	{
1371	struct dvb_demux *dvbdemux = &av7110->demux;
1372	struct dvb_demux *dvbdemux1 = &av7110->demux1;
1373
1374	dprintk(4, "%p\n", av7110);
1375
1376	if (!av7110->registered)
1377	return;
1378
1379	if (budgetpatch) {
1380	dvb_net_release(dvbnet: &av7110->dvb_net1);
1381	dvbdemux->dmx.close(&dvbdemux1->dmx);
1382	dvb_dmxdev_release(dmxdev: &av7110->dmxdev1);
1383	dvb_dmx_release(demux: &av7110->demux1);
1384	}
1385
1386	dvb_net_release(dvbnet: &av7110->dvb_net);
1387
1388	dvbdemux->dmx.close(&dvbdemux->dmx);
1389	dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1390	dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1391
1392	dvb_dmxdev_release(dmxdev: &av7110->dmxdev);
1393	dvb_dmx_release(demux: &av7110->demux);
1394
1395	if (av7110->fe != NULL) {
1396	dvb_unregister_frontend(fe: av7110->fe);
1397	dvb_frontend_detach(fe: av7110->fe);
1398	}
1399	dvb_unregister_device(dvbdev: av7110->osd_dev);
1400	av7110_av_unregister(av7110);
1401	av7110_ca_unregister(av7110);
1402	}
1403
1404
1405	/****************************************************************************
1406	* I2C client commands
1407	****************************************************************************/
1408
1409	int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1410	{
1411	u8 msg[2] = { reg, val };
1412	struct i2c_msg msgs;
1413
1414	msgs.flags = 0;
1415	msgs.addr = id / 2;
1416	msgs.len = 2;
1417	msgs.buf = msg;
1418	return i2c_transfer(adap: &av7110->i2c_adap, msgs: &msgs, num: 1);
1419	}
1420
1421	u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1422	{
1423	u8 mm1[] = {0x00};
1424	u8 mm2[] = {0x00};
1425	struct i2c_msg msgs[2];
1426
1427	msgs[0].flags = 0;
1428	msgs[1].flags = I2C_M_RD;
1429	msgs[0].addr = msgs[1].addr = id / 2;
1430	mm1[0] = reg;
1431	msgs[0].len = 1; msgs[1].len = 1;
1432	msgs[0].buf = mm1; msgs[1].buf = mm2;
1433	i2c_transfer(adap: &av7110->i2c_adap, msgs, num: 2);
1434
1435	return mm2[0];
1436	}
1437
1438	/****************************************************************************
1439	* INITIALIZATION
1440	****************************************************************************/
1441
1442
1443	static int check_firmware(struct av7110* av7110)
1444	{
1445	u32 crc = 0, len = 0;
1446	unsigned char *ptr;
1447
1448	/* check for firmware magic */
1449	ptr = av7110->bin_fw;
1450	if (ptr[0] != 'A' || ptr[1] != 'V' ||
1451	ptr[2] != 'F' || ptr[3] != 'W') {
1452	printk("dvb-ttpci: this is not an av7110 firmware\n");
1453	return -EINVAL;
1454	}
1455	ptr += 4;
1456
1457	/* check dpram file */
1458	crc = get_unaligned_be32(p: ptr);
1459	ptr += 4;
1460	len = get_unaligned_be32(p: ptr);
1461	ptr += 4;
1462	if (len >= 512) {
1463	printk("dvb-ttpci: dpram file is way too big.\n");
1464	return -EINVAL;
1465	}
1466	if (crc != crc32_le(crc: 0, p: ptr, len)) {
1467	printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1468	return -EINVAL;
1469	}
1470	av7110->bin_dpram = ptr;
1471	av7110->size_dpram = len;
1472	ptr += len;
1473
1474	/* check root file */
1475	crc = get_unaligned_be32(p: ptr);
1476	ptr += 4;
1477	len = get_unaligned_be32(p: ptr);
1478	ptr += 4;
1479
1480	if (len <= 200000 || len >= 300000 ||
1481	len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1482	printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1483	return -EINVAL;
1484	}
1485	if( crc != crc32_le(crc: 0, p: ptr, len)) {
1486	printk("dvb-ttpci: crc32 of root file does not match.\n");
1487	return -EINVAL;
1488	}
1489	av7110->bin_root = ptr;
1490	av7110->size_root = len;
1491	return 0;
1492	}
1493
1494	static void put_firmware(struct av7110* av7110)
1495	{
1496	vfree(addr: av7110->bin_fw);
1497	}
1498
1499	static int get_firmware(struct av7110* av7110)
1500	{
1501	int ret;
1502	const struct firmware *fw;
1503
1504	/* request the av7110 firmware, this will block until someone uploads it */
1505	ret = request_firmware(fw: &fw, name: "dvb-ttpci-01.fw", device: &av7110->dev->pci->dev);
1506	if (ret) {
1507	if (ret == -ENOENT) {
1508	printk(KERN_ERR "dvb-ttpci: could not load firmware, file not found: dvb-ttpci-01.fw\n");
1509	printk(KERN_ERR "dvb-ttpci: usually this should be in /usr/lib/hotplug/firmware or /lib/firmware\n");
1510	printk(KERN_ERR "dvb-ttpci: and can be downloaded from https://linuxtv.org/download/dvb/firmware/\n");
1511	} else
1512	printk(KERN_ERR "dvb-ttpci: cannot request firmware (error %i)\n",
1513	ret);
1514	return -EINVAL;
1515	}
1516
1517	if (fw->size <= 200000) {
1518	printk("dvb-ttpci: this firmware is way too small.\n");
1519	release_firmware(fw);
1520	return -EINVAL;
1521	}
1522
1523	/* check if the firmware is available */
1524	av7110->bin_fw = vmalloc(size: fw->size);
1525	if (NULL == av7110->bin_fw) {
1526	dprintk(1, "out of memory\n");
1527	release_firmware(fw);
1528	return -ENOMEM;
1529	}
1530
1531	memcpy(av7110->bin_fw, fw->data, fw->size);
1532	av7110->size_fw = fw->size;
1533	if ((ret = check_firmware(av7110)))
1534	vfree(addr: av7110->bin_fw);
1535
1536	release_firmware(fw);
1537	return ret;
1538	}
1539
1540	static int alps_bsrv2_tuner_set_params(struct dvb_frontend *fe)
1541	{
1542	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1543	struct av7110* av7110 = fe->dvb->priv;
1544	u8 pwr = 0;
1545	u8 buf[4];
1546	struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1547	u32 div = (p->frequency + 479500) / 125;
1548
1549	if (p->frequency > 2000000)
1550	pwr = 3;
1551	else if (p->frequency > 1800000)
1552	pwr = 2;
1553	else if (p->frequency > 1600000)
1554	pwr = 1;
1555	else if (p->frequency > 1200000)
1556	pwr = 0;
1557	else if (p->frequency >= 1100000)
1558	pwr = 1;
1559	else
1560	pwr = 2;
1561
1562	buf[0] = (div >> 8) & 0x7f;
1563	buf[1] = div & 0xff;
1564	buf[2] = ((div & 0x18000) >> 10) | 0x95;
1565	buf[3] = (pwr << 6) | 0x30;
1566
1567	// NOTE: since we're using a prescaler of 2, we set the
1568	// divisor frequency to 62.5kHz and divide by 125 above
1569
1570	if (fe->ops.i2c_gate_ctrl)
1571	fe->ops.i2c_gate_ctrl(fe, 1);
1572	if (i2c_transfer (adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1)
1573	return -EIO;
1574	return 0;
1575	}
1576
1577	static struct ves1x93_config alps_bsrv2_config = {
1578	.demod_address = 0x08,
1579	.xin = 90100000UL,
1580	.invert_pwm = 0,
1581	};
1582
1583	static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1584	{
1585	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1586	struct av7110* av7110 = fe->dvb->priv;
1587	u32 div;
1588	u8 data[4];
1589	struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1590
1591	div = (p->frequency + 35937500 + 31250) / 62500;
1592
1593	data[0] = (div >> 8) & 0x7f;
1594	data[1] = div & 0xff;
1595	data[2] = 0x85 | ((div >> 10) & 0x60);
1596	data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1597
1598	if (fe->ops.i2c_gate_ctrl)
1599	fe->ops.i2c_gate_ctrl(fe, 1);
1600	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1)
1601	return -EIO;
1602	return 0;
1603	}
1604
1605	static struct ves1820_config alps_tdbe2_config = {
1606	.demod_address = 0x09,
1607	.xin = 57840000UL,
1608	.invert = 1,
1609	.selagc = VES1820_SELAGC_SIGNAMPERR,
1610	};
1611
1612
1613
1614
1615	static int grundig_29504_451_tuner_set_params(struct dvb_frontend *fe)
1616	{
1617	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1618	struct av7110* av7110 = fe->dvb->priv;
1619	u32 div;
1620	u8 data[4];
1621	struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1622
1623	div = p->frequency / 125;
1624	data[0] = (div >> 8) & 0x7f;
1625	data[1] = div & 0xff;
1626	data[2] = 0x8e;
1627	data[3] = 0x00;
1628
1629	if (fe->ops.i2c_gate_ctrl)
1630	fe->ops.i2c_gate_ctrl(fe, 1);
1631	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1)
1632	return -EIO;
1633	return 0;
1634	}
1635
1636	static struct tda8083_config grundig_29504_451_config = {
1637	.demod_address = 0x68,
1638	};
1639
1640
1641
1642	static int philips_cd1516_tuner_set_params(struct dvb_frontend *fe)
1643	{
1644	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1645	struct av7110* av7110 = fe->dvb->priv;
1646	u32 div;
1647	u32 f = p->frequency;
1648	u8 data[4];
1649	struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1650
1651	div = (f + 36125000 + 31250) / 62500;
1652
1653	data[0] = (div >> 8) & 0x7f;
1654	data[1] = div & 0xff;
1655	data[2] = 0x8e;
1656	data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1657
1658	if (fe->ops.i2c_gate_ctrl)
1659	fe->ops.i2c_gate_ctrl(fe, 1);
1660	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1)
1661	return -EIO;
1662	return 0;
1663	}
1664
1665	static struct ves1820_config philips_cd1516_config = {
1666	.demod_address = 0x09,
1667	.xin = 57840000UL,
1668	.invert = 1,
1669	.selagc = VES1820_SELAGC_SIGNAMPERR,
1670	};
1671
1672
1673
1674	static int alps_tdlb7_tuner_set_params(struct dvb_frontend *fe)
1675	{
1676	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1677	struct av7110* av7110 = fe->dvb->priv;
1678	u32 div, pwr;
1679	u8 data[4];
1680	struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1681
1682	div = (p->frequency + 36200000) / 166666;
1683
1684	if (p->frequency <= 782000000)
1685	pwr = 1;
1686	else
1687	pwr = 2;
1688
1689	data[0] = (div >> 8) & 0x7f;
1690	data[1] = div & 0xff;
1691	data[2] = 0x85;
1692	data[3] = pwr << 6;
1693
1694	if (fe->ops.i2c_gate_ctrl)
1695	fe->ops.i2c_gate_ctrl(fe, 1);
1696	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1)
1697	return -EIO;
1698	return 0;
1699	}
1700
1701	static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1702	{
1703	#if IS_ENABLED(CONFIG_DVB_SP8870)
1704	struct av7110* av7110 = fe->dvb->priv;
1705
1706	return request_firmware(fw, name, device: &av7110->dev->pci->dev);
1707	#else
1708	return -EINVAL;
1709	#endif
1710	}
1711
1712	static const struct sp8870_config alps_tdlb7_config = {
1713
1714	.demod_address = 0x71,
1715	.request_firmware = alps_tdlb7_request_firmware,
1716	};
1717
1718
1719	static u8 nexusca_stv0297_inittab[] = {
1720	0x80, 0x01,
1721	0x80, 0x00,
1722	0x81, 0x01,
1723	0x81, 0x00,
1724	0x00, 0x09,
1725	0x01, 0x69,
1726	0x03, 0x00,
1727	0x04, 0x00,
1728	0x07, 0x00,
1729	0x08, 0x00,
1730	0x20, 0x00,
1731	0x21, 0x40,
1732	0x22, 0x00,
1733	0x23, 0x00,
1734	0x24, 0x40,
1735	0x25, 0x88,
1736	0x30, 0xff,
1737	0x31, 0x00,
1738	0x32, 0xff,
1739	0x33, 0x00,
1740	0x34, 0x50,
1741	0x35, 0x7f,
1742	0x36, 0x00,
1743	0x37, 0x20,
1744	0x38, 0x00,
1745	0x40, 0x1c,
1746	0x41, 0xff,
1747	0x42, 0x29,
1748	0x43, 0x00,
1749	0x44, 0xff,
1750	0x45, 0x00,
1751	0x46, 0x00,
1752	0x49, 0x04,
1753	0x4a, 0x00,
1754	0x4b, 0x7b,
1755	0x52, 0x30,
1756	0x55, 0xae,
1757	0x56, 0x47,
1758	0x57, 0xe1,
1759	0x58, 0x3a,
1760	0x5a, 0x1e,
1761	0x5b, 0x34,
1762	0x60, 0x00,
1763	0x63, 0x00,
1764	0x64, 0x00,
1765	0x65, 0x00,
1766	0x66, 0x00,
1767	0x67, 0x00,
1768	0x68, 0x00,
1769	0x69, 0x00,
1770	0x6a, 0x02,
1771	0x6b, 0x00,
1772	0x70, 0xff,
1773	0x71, 0x00,
1774	0x72, 0x00,
1775	0x73, 0x00,
1776	0x74, 0x0c,
1777	0x80, 0x00,
1778	0x81, 0x00,
1779	0x82, 0x00,
1780	0x83, 0x00,
1781	0x84, 0x04,
1782	0x85, 0x80,
1783	0x86, 0x24,
1784	0x87, 0x78,
1785	0x88, 0x10,
1786	0x89, 0x00,
1787	0x90, 0x01,
1788	0x91, 0x01,
1789	0xa0, 0x04,
1790	0xa1, 0x00,
1791	0xa2, 0x00,
1792	0xb0, 0x91,
1793	0xb1, 0x0b,
1794	0xc0, 0x53,
1795	0xc1, 0x70,
1796	0xc2, 0x12,
1797	0xd0, 0x00,
1798	0xd1, 0x00,
1799	0xd2, 0x00,
1800	0xd3, 0x00,
1801	0xd4, 0x00,
1802	0xd5, 0x00,
1803	0xde, 0x00,
1804	0xdf, 0x00,
1805	0x61, 0x49,
1806	0x62, 0x0b,
1807	0x53, 0x08,
1808	0x59, 0x08,
1809	0xff, 0xff,
1810	};
1811
1812	static int nexusca_stv0297_tuner_set_params(struct dvb_frontend *fe)
1813	{
1814	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1815	struct av7110* av7110 = fe->dvb->priv;
1816	u32 div;
1817	u8 data[4];
1818	struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1819	struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1820	int i;
1821
1822	div = (p->frequency + 36150000 + 31250) / 62500;
1823
1824	data[0] = (div >> 8) & 0x7f;
1825	data[1] = div & 0xff;
1826	data[2] = 0xce;
1827
1828	if (p->frequency < 45000000)
1829	return -EINVAL;
1830	else if (p->frequency < 137000000)
1831	data[3] = 0x01;
1832	else if (p->frequency < 403000000)
1833	data[3] = 0x02;
1834	else if (p->frequency < 860000000)
1835	data[3] = 0x04;
1836	else
1837	return -EINVAL;
1838
1839	if (fe->ops.i2c_gate_ctrl)
1840	fe->ops.i2c_gate_ctrl(fe, 1);
1841	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1) {
1842	printk("nexusca: pll transfer failed!\n");
1843	return -EIO;
1844	}
1845
1846	// wait for PLL lock
1847	for(i = 0; i < 20; i++) {
1848	if (fe->ops.i2c_gate_ctrl)
1849	fe->ops.i2c_gate_ctrl(fe, 1);
1850	if (i2c_transfer(adap: &av7110->i2c_adap, msgs: &readmsg, num: 1) == 1)
1851	if (data[0] & 0x40) break;
1852	msleep(msecs: 10);
1853	}
1854
1855	return 0;
1856	}
1857
1858	static struct stv0297_config nexusca_stv0297_config = {
1859
1860	.demod_address = 0x1C,
1861	.inittab = nexusca_stv0297_inittab,
1862	.invert = 1,
1863	.stop_during_read = 1,
1864	};
1865
1866
1867
1868	static int grundig_29504_401_tuner_set_params(struct dvb_frontend *fe)
1869	{
1870	struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1871	struct av7110* av7110 = fe->dvb->priv;
1872	u32 div;
1873	u8 cfg, cpump, band_select;
1874	u8 data[4];
1875	struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1876
1877	div = (36125000 + p->frequency) / 166666;
1878
1879	cfg = 0x88;
1880
1881	if (p->frequency < 175000000)
1882	cpump = 2;
1883	else if (p->frequency < 390000000)
1884	cpump = 1;
1885	else if (p->frequency < 470000000)
1886	cpump = 2;
1887	else if (p->frequency < 750000000)
1888	cpump = 1;
1889	else
1890	cpump = 3;
1891
1892	if (p->frequency < 175000000)
1893	band_select = 0x0e;
1894	else if (p->frequency < 470000000)
1895	band_select = 0x05;
1896	else
1897	band_select = 0x03;
1898
1899	data[0] = (div >> 8) & 0x7f;
1900	data[1] = div & 0xff;
1901	data[2] = ((div >> 10) & 0x60) | cfg;
1902	data[3] = (cpump << 6) | band_select;
1903
1904	if (fe->ops.i2c_gate_ctrl)
1905	fe->ops.i2c_gate_ctrl(fe, 1);
1906	if (i2c_transfer (adap: &av7110->i2c_adap, msgs: &msg, num: 1) != 1) return -EIO;
1907	return 0;
1908	}
1909
1910	static struct l64781_config grundig_29504_401_config = {
1911	.demod_address = 0x55,
1912	};
1913
1914
1915
1916	static int av7110_fe_lock_fix(struct av7110 *av7110, enum fe_status status)
1917	{
1918	int ret = 0;
1919	int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1920
1921	av7110->fe_status = status;
1922
1923	if (av7110->fe_synced == synced)
1924	return 0;
1925
1926	if (av7110->playing) {
1927	av7110->fe_synced = synced;
1928	return 0;
1929	}
1930
1931	if (mutex_lock_interruptible(&av7110->pid_mutex))
1932	return -ERESTARTSYS;
1933
1934	if (synced) {
1935	ret = SetPIDs(av7110, vpid: av7110->pids[DMX_PES_VIDEO],
1936	apid: av7110->pids[DMX_PES_AUDIO],
1937	ttpid: av7110->pids[DMX_PES_TELETEXT], subpid: 0,
1938	pcrpid: av7110->pids[DMX_PES_PCR]);
1939	if (!ret)
1940	ret = av7110_fw_cmd(av7110, type: COMTYPE_PIDFILTER, com: Scan, num: 0);
1941	} else {
1942	ret = SetPIDs(av7110, vpid: 0, apid: 0, ttpid: 0, subpid: 0, pcrpid: 0);
1943	if (!ret) {
1944	ret = av7110_fw_cmd(av7110, type: COMTYPE_PID_FILTER, com: FlushTSQueue, num: 0);
1945	if (!ret)
1946	ret = av7110_wait_msgstate(av7110, GPMQBusy);
1947	}
1948	}
1949
1950	if (!ret)
1951	av7110->fe_synced = synced;
1952
1953	mutex_unlock(lock: &av7110->pid_mutex);
1954	return ret;
1955	}
1956
1957	static int av7110_fe_set_frontend(struct dvb_frontend *fe)
1958	{
1959	struct av7110* av7110 = fe->dvb->priv;
1960
1961	int ret = av7110_fe_lock_fix(av7110, status: 0);
1962	if (!ret)
1963	ret = av7110->fe_set_frontend(fe);
1964
1965	return ret;
1966	}
1967
1968	static int av7110_fe_init(struct dvb_frontend* fe)
1969	{
1970	struct av7110* av7110 = fe->dvb->priv;
1971
1972	int ret = av7110_fe_lock_fix(av7110, status: 0);
1973	if (!ret)
1974	ret = av7110->fe_init(fe);
1975	return ret;
1976	}
1977
1978	static int av7110_fe_read_status(struct dvb_frontend *fe,
1979	enum fe_status *status)
1980	{
1981	struct av7110* av7110 = fe->dvb->priv;
1982
1983	/* call the real implementation */
1984	int ret = av7110->fe_read_status(fe, status);
1985	if (!ret)
1986	if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
1987	ret = av7110_fe_lock_fix(av7110, status: *status);
1988	return ret;
1989	}
1990
1991	static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
1992	{
1993	struct av7110* av7110 = fe->dvb->priv;
1994
1995	int ret = av7110_fe_lock_fix(av7110, status: 0);
1996	if (!ret)
1997	ret = av7110->fe_diseqc_reset_overload(fe);
1998	return ret;
1999	}
2000
2001	static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2002	struct dvb_diseqc_master_cmd* cmd)
2003	{
2004	struct av7110* av7110 = fe->dvb->priv;
2005
2006	int ret = av7110_fe_lock_fix(av7110, status: 0);
2007	if (!ret) {
2008	av7110->saved_master_cmd = *cmd;
2009	ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2010	}
2011	return ret;
2012	}
2013
2014	static int av7110_fe_diseqc_send_burst(struct dvb_frontend *fe,
2015	enum fe_sec_mini_cmd minicmd)
2016	{
2017	struct av7110* av7110 = fe->dvb->priv;
2018
2019	int ret = av7110_fe_lock_fix(av7110, status: 0);
2020	if (!ret) {
2021	av7110->saved_minicmd = minicmd;
2022	ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2023	}
2024	return ret;
2025	}
2026
2027	static int av7110_fe_set_tone(struct dvb_frontend *fe,
2028	enum fe_sec_tone_mode tone)
2029	{
2030	struct av7110* av7110 = fe->dvb->priv;
2031
2032	int ret = av7110_fe_lock_fix(av7110, status: 0);
2033	if (!ret) {
2034	av7110->saved_tone = tone;
2035	ret = av7110->fe_set_tone(fe, tone);
2036	}
2037	return ret;
2038	}
2039
2040	static int av7110_fe_set_voltage(struct dvb_frontend *fe,
2041	enum fe_sec_voltage voltage)
2042	{
2043	struct av7110* av7110 = fe->dvb->priv;
2044
2045	int ret = av7110_fe_lock_fix(av7110, status: 0);
2046	if (!ret) {
2047	av7110->saved_voltage = voltage;
2048	ret = av7110->fe_set_voltage(fe, voltage);
2049	}
2050	return ret;
2051	}
2052
2053	static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2054	{
2055	struct av7110* av7110 = fe->dvb->priv;
2056
2057	int ret = av7110_fe_lock_fix(av7110, status: 0);
2058	if (!ret)
2059	ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2060	return ret;
2061	}
2062
2063	static void dvb_s_recover(struct av7110* av7110)
2064	{
2065	av7110_fe_init(fe: av7110->fe);
2066
2067	av7110_fe_set_voltage(fe: av7110->fe, voltage: av7110->saved_voltage);
2068	if (av7110->saved_master_cmd.msg_len) {
2069	msleep(msecs: 20);
2070	av7110_fe_diseqc_send_master_cmd(fe: av7110->fe, cmd: &av7110->saved_master_cmd);
2071	}
2072	msleep(msecs: 20);
2073	av7110_fe_diseqc_send_burst(fe: av7110->fe, minicmd: av7110->saved_minicmd);
2074	msleep(msecs: 20);
2075	av7110_fe_set_tone(fe: av7110->fe, tone: av7110->saved_tone);
2076
2077	av7110_fe_set_frontend(fe: av7110->fe);
2078	}
2079
2080	static u8 read_pwm(struct av7110* av7110)
2081	{
2082	u8 b = 0xff;
2083	u8 pwm;
2084	struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2085	{ .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2086
2087	if ((i2c_transfer(adap: &av7110->i2c_adap, msgs: msg, num: 2) != 2) || (pwm == 0xff))
2088	pwm = 0x48;
2089
2090	return pwm;
2091	}
2092
2093	static int frontend_init(struct av7110 *av7110)
2094	{
2095	int ret;
2096
2097	if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2098	switch(av7110->dev->pci->subsystem_device) {
2099	case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2100	av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2101	&av7110->i2c_adap, read_pwm(av7110));
2102	if (av7110->fe) {
2103	av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2104	}
2105	break;
2106	}
2107
2108	} else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2109	switch(av7110->dev->pci->subsystem_device) {
2110	case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2111	case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2112	case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2113
2114	// try the ALPS BSRV2 first of all
2115	av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2116	if (av7110->fe) {
2117	av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2118	av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2119	av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2120	av7110->fe->ops.set_tone = av7110_set_tone;
2121	av7110->recover = dvb_s_recover;
2122	break;
2123	}
2124
2125	// try the ALPS BSRU6 now
2126	av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2127	if (av7110->fe) {
2128	av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2129	av7110->fe->tuner_priv = &av7110->i2c_adap;
2130
2131	av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2132	av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2133	av7110->fe->ops.set_tone = av7110_set_tone;
2134	av7110->recover = dvb_s_recover;
2135	break;
2136	}
2137
2138	// Try the grundig 29504-451
2139	av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2140	if (av7110->fe) {
2141	av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2142	av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2143	av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2144	av7110->fe->ops.set_tone = av7110_set_tone;
2145	av7110->recover = dvb_s_recover;
2146	break;
2147	}
2148
2149	/* Try DVB-C cards */
2150	switch(av7110->dev->pci->subsystem_device) {
2151	case 0x0000:
2152	/* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2153	av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2154	read_pwm(av7110));
2155	if (av7110->fe) {
2156	av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2157	}
2158	break;
2159	case 0x0003:
2160	/* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2161	av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2162	read_pwm(av7110));
2163	if (av7110->fe) {
2164	av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2165	}
2166	break;
2167	}
2168	break;
2169
2170	case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2171	{
2172	struct dvb_frontend *fe;
2173
2174	// try ALPS TDLB7 first, then Grundig 29504-401
2175	fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2176	if (fe) {
2177	fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2178	av7110->fe = fe;
2179	break;
2180	}
2181	}
2182	fallthrough;
2183
2184	case 0x0008: // Hauppauge/TT DVB-T
2185	// Grundig 29504-401
2186	av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2187	if (av7110->fe)
2188	av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2189	break;
2190
2191	case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2192
2193	av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2194	if (av7110->fe) {
2195	av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2196	}
2197	break;
2198
2199	case 0x0004: // Galaxis DVB-S rev1.3
2200	/* ALPS BSRV2 */
2201	av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2202	if (av7110->fe) {
2203	av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2204	av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2205	av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2206	av7110->fe->ops.set_tone = av7110_set_tone;
2207	av7110->recover = dvb_s_recover;
2208	}
2209	break;
2210
2211	case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2212	/* Grundig 29504-451 */
2213	av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2214	if (av7110->fe) {
2215	av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2216	av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2217	av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2218	av7110->fe->ops.set_tone = av7110_set_tone;
2219	av7110->recover = dvb_s_recover;
2220	}
2221	break;
2222
2223	case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2224
2225	av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2226	if (av7110->fe) {
2227	av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2228
2229	/* set TDA9819 into DVB mode */
2230	saa7146_setgpio(dev: av7110->dev, port: 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2231	saa7146_setgpio(dev: av7110->dev, port: 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2232
2233	/* tuner on this needs a slower i2c bus speed */
2234	av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2235	break;
2236	}
2237	break;
2238
2239	case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2240	/* ALPS BSBE1 */
2241	av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2242	if (av7110->fe) {
2243	av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2244	av7110->fe->tuner_priv = &av7110->i2c_adap;
2245
2246	if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2247	printk("dvb-ttpci: LNBP21 not found!\n");
2248	if (av7110->fe->ops.release)
2249	av7110->fe->ops.release(av7110->fe);
2250	av7110->fe = NULL;
2251	} else {
2252	av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2253	av7110->recover = dvb_s_recover;
2254	}
2255	}
2256	break;
2257	}
2258	}
2259
2260	if (!av7110->fe) {
2261	/* FIXME: propagate the failure code from the lower layers */
2262	ret = -ENOMEM;
2263	printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2264	av7110->dev->pci->vendor,
2265	av7110->dev->pci->device,
2266	av7110->dev->pci->subsystem_vendor,
2267	av7110->dev->pci->subsystem_device);
2268	} else {
2269	FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2270	FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2271	FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2272	FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2273	FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2274	FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2275	FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2276	FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2277	FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2278
2279	ret = dvb_register_frontend(dvb: &av7110->dvb_adapter, fe: av7110->fe);
2280	if (ret < 0) {
2281	printk("av7110: Frontend registration failed!\n");
2282	dvb_frontend_detach(fe: av7110->fe);
2283	av7110->fe = NULL;
2284	}
2285	}
2286	return ret;
2287	}
2288
2289	/* Budgetpatch note:
2290	* Original hardware design by Roberto Deza:
2291	* There is a DVB_Wiki at
2292	* https://linuxtv.org
2293	*
2294	* New software triggering design by Emard that works on
2295	* original Roberto Deza's hardware:
2296	*
2297	* rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2298	* GPIO3 is in budget-patch hardware connectd to port B VSYNC
2299	* HS is an internal event of 7146, accessible with RPS
2300	* and temporarily raised high every n lines
2301	* (n in defined in the RPS_THRESH1 counter threshold)
2302	* I think HS is raised high on the beginning of the n-th line
2303	* and remains high until this n-th line that triggered
2304	* it is completely received. When the reception of n-th line
2305	* ends, HS is lowered.
2306	*
2307	* To transmit data over DMA, 7146 needs changing state at
2308	* port B VSYNC pin. Any changing of port B VSYNC will
2309	* cause some DMA data transfer, with more or less packets loss.
2310	* It depends on the phase and frequency of VSYNC and
2311	* the way of 7146 is instructed to trigger on port B (defined
2312	* in DD1_INIT register, 3rd nibble from the right valid
2313	* numbers are 0-7, see datasheet)
2314	*
2315	* The correct triggering can minimize packet loss,
2316	* dvbtraffic should give this stable bandwidths:
2317	* 22k transponder = 33814 kbit/s
2318	* 27.5k transponder = 38045 kbit/s
2319	* by experiment it is found that the best results
2320	* (stable bandwidths and almost no packet loss)
2321	* are obtained using DD1_INIT triggering number 2
2322	* (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2323	* and a VSYNC phase that occurs in the middle of DMA transfer
2324	* (about byte 188*512=96256 in the DMA window).
2325	*
2326	* Phase of HS is still not clear to me how to control,
2327	* It just happens to be so. It can be seen if one enables
2328	* RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2329	* time RPS_INTERRUPT is called, the Event Counter 1 will
2330	* increment. That's how the 7146 is programmed to do event
2331	* counting in this budget-patch.c
2332	* I *think* HPS setting has something to do with the phase
2333	* of HS but I can't be 100% sure in that.
2334	*
2335	* hardware debug note: a working budget card (including budget patch)
2336	* with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2337	* generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2338	* and that means 3*25=75 Hz of interrupt frequency, as seen by
2339	* watch cat /proc/interrupts
2340	*
2341	* If this frequency is 3x lower (and data received in the DMA
2342	* buffer don't start with 0x47, but in the middle of packets,
2343	* whose lengths appear to be like 188 292 188 104 etc.
2344	* this means VSYNC line is not connected in the hardware.
2345	* (check soldering pcb and pins)
2346	* The same behaviour of missing VSYNC can be duplicated on budget
2347	* cards, by setting DD1_INIT trigger mode 7 in 3rd nibble.
2348	*/
2349	static int av7110_attach(struct saa7146_dev* dev,
2350	struct saa7146_pci_extension_data *pci_ext)
2351	{
2352	const int length = TS_WIDTH * TS_HEIGHT;
2353	struct pci_dev *pdev = dev->pci;
2354	struct av7110 *av7110;
2355	struct task_struct *thread;
2356	int ret, count = 0;
2357
2358	dprintk(4, "dev: %p\n", dev);
2359
2360	/* Set RPS_IRQ to 1 to track rps1 activity.
2361	* Enabling this won't send any interrupt to PC CPU.
2362	*/
2363	#define RPS_IRQ 0
2364
2365	if (budgetpatch == 1) {
2366	budgetpatch = 0;
2367	/* autodetect the presence of budget patch
2368	* this only works if saa7146 has been recently
2369	* reset with MASK_31 to MC1
2370	*
2371	* will wait for VBI_B event (vertical blank at port B)
2372	* and will reset GPIO3 after VBI_B is detected.
2373	* (GPIO3 should be raised high by CPU to
2374	* test if GPIO3 will generate vertical blank signal
2375	* in budget patch GPIO3 is connected to VSYNC_B
2376	*/
2377
2378	/* RESET SAA7146 */
2379	saa7146_write(dev, MC1, MASK_31);
2380	/* autodetection success seems to be time-dependend after reset */
2381
2382	/* Fix VSYNC level */
2383	saa7146_setgpio(dev, port: 3, SAA7146_GPIO_OUTLO);
2384	/* set vsync_b triggering */
2385	saa7146_write(dev, DD1_STREAM_B, 0);
2386	/* port B VSYNC at rising edge */
2387	saa7146_write(dev, DD1_INIT, 0x00000200);
2388	saa7146_write(dev, BRS_CTRL, 0x00000000); // VBI
2389	saa7146_write(dev, MC2,
2390	1 * (MASK_08 | MASK_24) | // BRS control
2391	0 * (MASK_09 | MASK_25) | // a
2392	1 * (MASK_10 | MASK_26) | // b
2393	0 * (MASK_06 | MASK_22) | // HPS_CTRL1
2394	0 * (MASK_05 | MASK_21) | // HPS_CTRL2
2395	0 * (MASK_01 | MASK_15) // DEBI
2396	);
2397
2398	/* start writing RPS1 code from beginning */
2399	count = 0;
2400	/* Disable RPS1 */
2401	saa7146_write(dev, MC1, MASK_29);
2402	/* RPS1 timeout disable */
2403	saa7146_write(dev, RPS_TOV1, 0);
2404	WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2405	WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2406	WRITE_RPS1(GPIO3_MSK);
2407	WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2408	#if RPS_IRQ
2409	/* issue RPS1 interrupt to increment counter */
2410	WRITE_RPS1(CMD_INTERRUPT);
2411	#endif
2412	WRITE_RPS1(CMD_STOP);
2413	/* Jump to begin of RPS program as safety measure (p37) */
2414	WRITE_RPS1(CMD_JUMP);
2415	WRITE_RPS1(dev->d_rps1.dma_handle);
2416
2417	#if RPS_IRQ
2418	/* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2419	* use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2420	* use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2421	*/
2422	saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2423	/* set event counter 1 threshold to maximum allowed value (rEC p55) */
2424	saa7146_write(dev, ECT1R, 0x3fff );
2425	#endif
2426	/* Set RPS1 Address register to point to RPS code (r108 p42) */
2427	saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2428	/* Enable RPS1, (rFC p33) */
2429	saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2430
2431	mdelay(10);
2432	/* now send VSYNC_B to rps1 by rising GPIO3 */
2433	saa7146_setgpio(dev, port: 3, SAA7146_GPIO_OUTHI);
2434	mdelay(10);
2435	/* if rps1 responded by lowering the GPIO3,
2436	* then we have budgetpatch hardware
2437	*/
2438	if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2439	budgetpatch = 1;
2440	printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2441	}
2442	/* Disable RPS1 */
2443	saa7146_write(dev, MC1, ( MASK_29 ));
2444	#if RPS_IRQ
2445	printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2446	#endif
2447	}
2448
2449	/* prepare the av7110 device struct */
2450	av7110 = kzalloc(size: sizeof(struct av7110), GFP_KERNEL);
2451	if (!av7110) {
2452	dprintk(1, "out of memory\n");
2453	return -ENOMEM;
2454	}
2455
2456	av7110->card_name = (char*) pci_ext->ext_priv;
2457	av7110->dev = dev;
2458	dev->ext_priv = av7110;
2459
2460	ret = get_firmware(av7110);
2461	if (ret < 0)
2462	goto err_kfree_0;
2463
2464	ret = dvb_register_adapter(adap: &av7110->dvb_adapter, name: av7110->card_name,
2465	THIS_MODULE, device: &dev->pci->dev, adapter_nums: adapter_nr);
2466	if (ret < 0)
2467	goto err_put_firmware_1;
2468
2469	/* the Siemens DVB needs this if you want to have the i2c chips
2470	get recognized before the main driver is fully loaded */
2471	saa7146_write(dev, GPIO_CTRL, 0x500000);
2472
2473	strscpy(av7110->i2c_adap.name, pci_ext->ext_priv,
2474	sizeof(av7110->i2c_adap.name));
2475
2476	saa7146_i2c_adapter_prepare(dev, i2c_adapter: &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2477
2478	ret = i2c_add_adapter(adap: &av7110->i2c_adap);
2479	if (ret < 0)
2480	goto err_dvb_unregister_adapter_2;
2481
2482	ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2483	av7110->dvb_adapter.proposed_mac);
2484	ret = -ENOMEM;
2485
2486	/* full-ts mod? */
2487	if (full_ts)
2488	av7110->full_ts = true;
2489
2490	/* check for full-ts flag in eeprom */
2491	if (i2c_readreg(av7110, id: 0xaa, reg: 0) == 0x4f && i2c_readreg(av7110, id: 0xaa, reg: 1) == 0x45) {
2492	u8 flags = i2c_readreg(av7110, id: 0xaa, reg: 2);
2493	if (flags != 0xff && (flags & 0x01))
2494	av7110->full_ts = true;
2495	}
2496
2497	if (av7110->full_ts) {
2498	printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2499	spin_lock_init(&av7110->feedlock1);
2500	av7110->grabbing = saa7146_vmalloc_build_pgtable(pci: pdev, length,
2501	pt: &av7110->pt);
2502	if (!av7110->grabbing)
2503	goto err_i2c_del_3;
2504
2505	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2506	saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2507
2508	saa7146_write(dev, DD1_INIT, 0x00000600);
2509	saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2510
2511	saa7146_write(dev, BRS_CTRL, 0x60000000);
2512	saa7146_write(dev, MC2, MASK_08 | MASK_24);
2513
2514	/* dma3 */
2515	saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2516	saa7146_write(dev, BASE_ODD3, 0);
2517	saa7146_write(dev, BASE_EVEN3, 0);
2518	saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2519	saa7146_write(dev, PITCH3, TS_WIDTH);
2520	saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2521	saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2522	saa7146_write(dev, MC2, MASK_04 | MASK_20);
2523
2524	tasklet_setup(t: &av7110->vpe_tasklet, callback: vpeirq);
2525
2526	} else if (budgetpatch) {
2527	spin_lock_init(&av7110->feedlock1);
2528	av7110->grabbing = saa7146_vmalloc_build_pgtable(pci: pdev, length,
2529	pt: &av7110->pt);
2530	if (!av7110->grabbing)
2531	goto err_i2c_del_3;
2532
2533	saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2534	saa7146_write(dev, BCS_CTRL, 0x80400040);
2535	/* set dd1 stream a & b */
2536	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2537	saa7146_write(dev, DD1_INIT, 0x03000200);
2538	saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2539	saa7146_write(dev, BRS_CTRL, 0x60000000);
2540	saa7146_write(dev, BASE_ODD3, 0);
2541	saa7146_write(dev, BASE_EVEN3, 0);
2542	saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2543	saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2544
2545	saa7146_write(dev, PITCH3, TS_WIDTH);
2546	saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2547
2548	/* upload all */
2549	saa7146_write(dev, MC2, 0x077c077c);
2550	saa7146_write(dev, GPIO_CTRL, 0x000000);
2551	#if RPS_IRQ
2552	/* set event counter 1 source as RPS1 interrupt (0x03) (rE4 p53)
2553	* use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2554	* use 0x15 to track VPE interrupts - increase by 1 every vpeirq() is called
2555	*/
2556	saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2557	/* set event counter 1 threshold to maximum allowed value (rEC p55) */
2558	saa7146_write(dev, ECT1R, 0x3fff );
2559	#endif
2560	/* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2561	count = 0;
2562
2563	/* Wait Source Line Counter Threshold (p36) */
2564	WRITE_RPS1(CMD_PAUSE | EVT_HS);
2565	/* Set GPIO3=1 (p42) */
2566	WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2567	WRITE_RPS1(GPIO3_MSK);
2568	WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2569	#if RPS_IRQ
2570	/* issue RPS1 interrupt */
2571	WRITE_RPS1(CMD_INTERRUPT);
2572	#endif
2573	/* Wait reset Source Line Counter Threshold (p36) */
2574	WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2575	/* Set GPIO3=0 (p42) */
2576	WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2577	WRITE_RPS1(GPIO3_MSK);
2578	WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2579	#if RPS_IRQ
2580	/* issue RPS1 interrupt */
2581	WRITE_RPS1(CMD_INTERRUPT);
2582	#endif
2583	/* Jump to begin of RPS program (p37) */
2584	WRITE_RPS1(CMD_JUMP);
2585	WRITE_RPS1(dev->d_rps1.dma_handle);
2586
2587	/* Fix VSYNC level */
2588	saa7146_setgpio(dev, port: 3, SAA7146_GPIO_OUTLO);
2589	/* Set RPS1 Address register to point to RPS code (r108 p42) */
2590	saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2591	/* Set Source Line Counter Threshold, using BRS (rCC p43)
2592	* It generates HS event every TS_HEIGHT lines
2593	* this is related to TS_WIDTH set in register
2594	* NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2595	* are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2596	* then RPS_THRESH1 should be set to trigger
2597	* every TS_HEIGHT (512) lines.
2598	*/
2599	saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2600
2601	/* Enable RPS1 (rFC p33) */
2602	saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2603
2604	/* end of budgetpatch register initialization */
2605	tasklet_setup(t: &av7110->vpe_tasklet, callback: vpeirq);
2606	} else {
2607	saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2608	saa7146_write(dev, BCS_CTRL, 0x80400040);
2609
2610	/* set dd1 stream a & b */
2611	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2612	saa7146_write(dev, DD1_INIT, 0x03000000);
2613	saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2614
2615	/* upload all */
2616	saa7146_write(dev, MC2, 0x077c077c);
2617	saa7146_write(dev, GPIO_CTRL, 0x000000);
2618	}
2619
2620	tasklet_setup(t: &av7110->debi_tasklet, callback: debiirq);
2621	tasklet_setup(t: &av7110->gpio_tasklet, callback: gpioirq);
2622
2623	mutex_init(&av7110->pid_mutex);
2624
2625	/* locks for data transfers from/to AV7110 */
2626	spin_lock_init(&av7110->debilock);
2627	mutex_init(&av7110->dcomlock);
2628	av7110->debitype = -1;
2629
2630	/* default OSD window */
2631	av7110->osdwin = 1;
2632	mutex_init(&av7110->osd_mutex);
2633
2634	/* TV standard */
2635	av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2636	: AV7110_VIDEO_MODE_PAL;
2637
2638	/* ARM "watchdog" */
2639	init_waitqueue_head(&av7110->arm_wait);
2640	av7110->arm_thread = NULL;
2641
2642	/* allocate and init buffers */
2643	av7110->debi_virt = dma_alloc_coherent(dev: &pdev->dev, size: 8192,
2644	dma_handle: &av7110->debi_bus, GFP_KERNEL);
2645	if (!av7110->debi_virt)
2646	goto err_saa71466_vfree_4;
2647
2648
2649	av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2650	if (!av7110->iobuf)
2651	goto err_pci_free_5;
2652
2653	ret = av7110_av_init(av7110);
2654	if (ret < 0)
2655	goto err_iobuf_vfree_6;
2656
2657	/* init BMP buffer */
2658	av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2659	init_waitqueue_head(&av7110->bmpq);
2660
2661	ret = av7110_ca_init(av7110);
2662	if (ret < 0)
2663	goto err_av7110_av_exit_7;
2664
2665	/* load firmware into AV7110 cards */
2666	ret = av7110_bootarm(av7110);
2667	if (ret < 0)
2668	goto err_av7110_ca_exit_8;
2669
2670	ret = av7110_firmversion(av7110);
2671	if (ret < 0)
2672	goto err_stop_arm_9;
2673
2674	if (FW_VERSION(av7110->arm_app)<0x2501)
2675	printk(KERN_WARNING
2676	"dvb-ttpci: Warning, firmware version 0x%04x is too old. System might be unstable!\n",
2677	FW_VERSION(av7110->arm_app));
2678
2679	thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2680	if (IS_ERR(ptr: thread)) {
2681	ret = PTR_ERR(ptr: thread);
2682	goto err_stop_arm_9;
2683	}
2684	av7110->arm_thread = thread;
2685
2686	/* set initial volume in mixer struct */
2687	av7110->mixer.volume_left = volume;
2688	av7110->mixer.volume_right = volume;
2689
2690	ret = av7110_register(av7110);
2691	if (ret < 0)
2692	goto err_arm_thread_stop_10;
2693
2694	init_av7110_av(av7110);
2695
2696	/* special case DVB-C: these cards have an analog tuner
2697	plus need some special handling, so we have separate
2698	saa7146_ext_vv data for these... */
2699	ret = av7110_init_v4l(av7110);
2700	if (ret < 0)
2701	goto err_av7110_unregister_11;
2702
2703	av7110->dvb_adapter.priv = av7110;
2704	ret = frontend_init(av7110);
2705	if (ret < 0)
2706	goto err_av7110_exit_v4l_12;
2707
2708	mutex_init(&av7110->ioctl_mutex);
2709
2710	#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2711	av7110_ir_init(av7110);
2712	#endif
2713	printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2714	av7110_num++;
2715	out:
2716	return ret;
2717
2718	err_av7110_exit_v4l_12:
2719	av7110_exit_v4l(av7110);
2720	err_av7110_unregister_11:
2721	dvb_unregister(av7110);
2722	err_arm_thread_stop_10:
2723	av7110_arm_sync(av7110);
2724	err_stop_arm_9:
2725	/* Nothing to do. Rejoice. */
2726	err_av7110_ca_exit_8:
2727	av7110_ca_exit(av7110);
2728	err_av7110_av_exit_7:
2729	av7110_av_exit(av7110);
2730	err_iobuf_vfree_6:
2731	vfree(addr: av7110->iobuf);
2732	err_pci_free_5:
2733	dma_free_coherent(dev: &pdev->dev, size: 8192, cpu_addr: av7110->debi_virt,
2734	dma_handle: av7110->debi_bus);
2735	err_saa71466_vfree_4:
2736	if (av7110->grabbing)
2737	saa7146_vfree_destroy_pgtable(pci: pdev, mem: av7110->grabbing, pt: &av7110->pt);
2738	err_i2c_del_3:
2739	i2c_del_adapter(adap: &av7110->i2c_adap);
2740	err_dvb_unregister_adapter_2:
2741	dvb_unregister_adapter(adap: &av7110->dvb_adapter);
2742	err_put_firmware_1:
2743	put_firmware(av7110);
2744	err_kfree_0:
2745	kfree(objp: av7110);
2746	goto out;
2747	}
2748
2749	static int av7110_detach(struct saa7146_dev* saa)
2750	{
2751	struct av7110 *av7110 = saa->ext_priv;
2752	dprintk(4, "%p\n", av7110);
2753
2754	#if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2755	av7110_ir_exit(av7110);
2756	#endif
2757	if (budgetpatch || av7110->full_ts) {
2758	if (budgetpatch) {
2759	/* Disable RPS1 */
2760	saa7146_write(saa, MC1, MASK_29);
2761	/* VSYNC LOW (inactive) */
2762	saa7146_setgpio(dev: saa, port: 3, SAA7146_GPIO_OUTLO);
2763	}
2764	saa7146_write(saa, MC1, MASK_20); /* DMA3 off */
2765	SAA7146_IER_DISABLE(x: saa, MASK_10);
2766	SAA7146_ISR_CLEAR(saa, MASK_10);
2767	msleep(msecs: 50);
2768	tasklet_kill(t: &av7110->vpe_tasklet);
2769	saa7146_vfree_destroy_pgtable(pci: saa->pci, mem: av7110->grabbing, pt: &av7110->pt);
2770	}
2771	av7110_exit_v4l(av7110);
2772
2773	av7110_arm_sync(av7110);
2774
2775	tasklet_kill(t: &av7110->debi_tasklet);
2776	tasklet_kill(t: &av7110->gpio_tasklet);
2777
2778	dvb_unregister(av7110);
2779
2780	SAA7146_IER_DISABLE(x: saa, MASK_19 | MASK_03);
2781	SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2782
2783	av7110_ca_exit(av7110);
2784	av7110_av_exit(av7110);
2785
2786	vfree(addr: av7110->iobuf);
2787	dma_free_coherent(dev: &saa->pci->dev, size: 8192, cpu_addr: av7110->debi_virt,
2788	dma_handle: av7110->debi_bus);
2789
2790	i2c_del_adapter(adap: &av7110->i2c_adap);
2791
2792	dvb_unregister_adapter (adap: &av7110->dvb_adapter);
2793
2794	av7110_num--;
2795
2796	put_firmware(av7110);
2797
2798	kfree(objp: av7110);
2799
2800	saa->ext_priv = NULL;
2801
2802	return 0;
2803	}
2804
2805
2806	static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2807	{
2808	struct av7110 *av7110 = dev->ext_priv;
2809
2810	//print_time("av7110_irq");
2811
2812	/* Note: Don't try to handle the DEBI error irq (MASK_18), in
2813	* intel mode the timeout is asserted all the time...
2814	*/
2815
2816	if (*isr & MASK_19) {
2817	//printk("av7110_irq: DEBI\n");
2818	/* Note 1: The DEBI irq is level triggered: We must enable it
2819	* only after we started a DMA xfer, and disable it here
2820	* immediately, or it will be signalled all the time while
2821	* DEBI is idle.
2822	* Note 2: You would think that an irq which is masked is
2823	* not signalled by the hardware. Not so for the SAA7146:
2824	* An irq is signalled as long as the corresponding bit
2825	* in the ISR is set, and disabling irqs just prevents the
2826	* hardware from setting the ISR bit. This means a) that we
2827	* must clear the ISR *after* disabling the irq (which is why
2828	* we must do it here even though saa7146_core did it already),
2829	* and b) that if we were to disable an edge triggered irq
2830	* (like the gpio irqs sadly are) temporarily we would likely
2831	* loose some. This sucks :-(
2832	*/
2833	SAA7146_IER_DISABLE(x: av7110->dev, MASK_19);
2834	SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2835	tasklet_schedule(t: &av7110->debi_tasklet);
2836	}
2837
2838	if (*isr & MASK_03) {
2839	//printk("av7110_irq: GPIO\n");
2840	tasklet_schedule(t: &av7110->gpio_tasklet);
2841	}
2842
2843	if (*isr & MASK_10)
2844	tasklet_schedule(t: &av7110->vpe_tasklet);
2845	}
2846
2847
2848	static struct saa7146_extension av7110_extension_driver;
2849
2850	#define MAKE_AV7110_INFO(x_var,x_name) \
2851	static struct saa7146_pci_extension_data x_var = { \
2852	.ext_priv = x_name, \
2853	.ext = &av7110_extension_driver }
2854
2855	MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2856	MAKE_AV7110_INFO(ttt_1_X, "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2857	MAKE_AV7110_INFO(ttc_1_X, "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2858	MAKE_AV7110_INFO(ttc_2_X, "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2859	MAKE_AV7110_INFO(tts_2_X, "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2860	MAKE_AV7110_INFO(tts_2_3, "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2861	MAKE_AV7110_INFO(tts_1_3se, "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2862	MAKE_AV7110_INFO(ttt, "Technotrend/Hauppauge DVB-T");
2863	MAKE_AV7110_INFO(fsc, "Fujitsu Siemens DVB-C");
2864	MAKE_AV7110_INFO(fss, "Fujitsu Siemens DVB-S rev1.6");
2865	MAKE_AV7110_INFO(gxs_1_3, "Galaxis DVB-S rev1.3");
2866
2867	static const struct pci_device_id pci_tbl[] = {
2868	MAKE_EXTENSION_PCI(fsc, 0x110a, 0x0000),
2869	MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2870	MAKE_EXTENSION_PCI(ttt_1_X, 0x13c2, 0x0001),
2871	MAKE_EXTENSION_PCI(ttc_2_X, 0x13c2, 0x0002),
2872	MAKE_EXTENSION_PCI(tts_2_X, 0x13c2, 0x0003),
2873	MAKE_EXTENSION_PCI(gxs_1_3, 0x13c2, 0x0004),
2874	MAKE_EXTENSION_PCI(fss, 0x13c2, 0x0006),
2875	MAKE_EXTENSION_PCI(ttt, 0x13c2, 0x0008),
2876	MAKE_EXTENSION_PCI(ttc_1_X, 0x13c2, 0x000a),
2877	MAKE_EXTENSION_PCI(tts_2_3, 0x13c2, 0x000e),
2878	MAKE_EXTENSION_PCI(tts_1_3se, 0x13c2, 0x1002),
2879
2880	/* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2881	/* MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2882
2883	{
2884	.vendor = 0,
2885	}
2886	};
2887
2888	MODULE_DEVICE_TABLE(pci, pci_tbl);
2889
2890
2891	static struct saa7146_extension av7110_extension_driver = {
2892	.name = "av7110",
2893	.flags = SAA7146_USE_I2C_IRQ,
2894
2895	.module = THIS_MODULE,
2896	.pci_tbl = &pci_tbl[0],
2897	.attach = av7110_attach,
2898	.detach = av7110_detach,
2899
2900	.irq_mask = MASK_19 | MASK_03 | MASK_10,
2901	.irq_func = av7110_irq,
2902	};
2903
2904
2905	static int __init av7110_init(void)
2906	{
2907	return saa7146_register_extension(&av7110_extension_driver);
2908	}
2909
2910
2911	static void __exit av7110_exit(void)
2912	{
2913	saa7146_unregister_extension(&av7110_extension_driver);
2914	}
2915
2916	module_init(av7110_init);
2917	module_exit(av7110_exit);
2918
2919	MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by Siemens, Technotrend, Hauppauge");
2920	MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2921	MODULE_LICENSE("GPL");
2922