Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/media/pci/ttpci/av7110.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us