Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

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_DVB_AV7110_IR)
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_DVB_AV7110_IR)
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, enum fe_sec_tone_mode 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                                     enum fe_sec_mini_cmd 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         unsigned y;
1223 
1224         dprintk(2, "budget: %p\n", budget);
1225 
1226         if (budget->feeding1)
1227                 return ++budget->feeding1;
1228         for (y = 0; y < TS_HEIGHT; y++)
1229                 memset(budget->grabbing + y * TS_WIDTH, 0x00, TS_WIDTH);
1230         budget->ttbp = 0;
1231         SAA7146_ISR_CLEAR(budget->dev, MASK_10);  /* VPE */
1232         SAA7146_IER_ENABLE(budget->dev, MASK_10); /* VPE */
1233         saa7146_write(budget->dev, MC1, (MASK_04 | MASK_20)); /* DMA3 on */
1234         return ++budget->feeding1;
1235 }
1236 
1237 static int budget_start_feed(struct dvb_demux_feed *feed)
1238 {
1239         struct dvb_demux *demux = feed->demux;
1240         struct av7110 *budget = demux->priv;
1241         int status;
1242 
1243         dprintk(2, "av7110: %p\n", budget);
1244 
1245         spin_lock(&budget->feedlock1);
1246         feed->pusi_seen = 0; /* have a clean section start */
1247         status = start_ts_capture(budget);
1248         spin_unlock(&budget->feedlock1);
1249         return status;
1250 }
1251 
1252 static int budget_stop_feed(struct dvb_demux_feed *feed)
1253 {
1254         struct dvb_demux *demux = feed->demux;
1255         struct av7110 *budget = demux->priv;
1256         int status;
1257 
1258         dprintk(2, "budget: %p\n", budget);
1259 
1260         spin_lock(&budget->feedlock1);
1261         status = stop_ts_capture(budget);
1262         spin_unlock(&budget->feedlock1);
1263         return status;
1264 }
1265 
1266 static void vpeirq(unsigned long cookie)
1267 {
1268         struct av7110 *budget = (struct av7110 *)cookie;
1269         u8 *mem = (u8 *) (budget->grabbing);
1270         u32 olddma = budget->ttbp;
1271         u32 newdma = saa7146_read(budget->dev, PCI_VDP3);
1272         struct dvb_demux *demux = budget->full_ts ? &budget->demux : &budget->demux1;
1273 
1274         /* nearest lower position divisible by 188 */
1275         newdma -= newdma % 188;
1276 
1277         if (newdma >= TS_BUFLEN)
1278                 return;
1279 
1280         budget->ttbp = newdma;
1281 
1282         if (!budget->feeding1 || (newdma == olddma))
1283                 return;
1284 
1285         /* Ensure streamed PCI data is synced to CPU */
1286         pci_dma_sync_sg_for_cpu(budget->dev->pci, budget->pt.slist, budget->pt.nents, PCI_DMA_FROMDEVICE);
1287 
1288 #if 0
1289         /* track rps1 activity */
1290         printk("vpeirq: %02x Event Counter 1 0x%04x\n",
1291                mem[olddma],
1292                saa7146_read(budget->dev, EC1R) & 0x3fff);
1293 #endif
1294 
1295         if (newdma > olddma)
1296                 /* no wraparound, dump olddma..newdma */
1297                 dvb_dmx_swfilter_packets(demux, mem + olddma, (newdma - olddma) / 188);
1298         else {
1299                 /* wraparound, dump olddma..buflen and 0..newdma */
1300                 dvb_dmx_swfilter_packets(demux, mem + olddma, (TS_BUFLEN - olddma) / 188);
1301                 dvb_dmx_swfilter_packets(demux, mem, newdma / 188);
1302         }
1303 }
1304 
1305 static int av7110_register(struct av7110 *av7110)
1306 {
1307         int ret, i;
1308         struct dvb_demux *dvbdemux = &av7110->demux;
1309         struct dvb_demux *dvbdemux1 = &av7110->demux1;
1310 
1311         dprintk(4, "%p\n", av7110);
1312 
1313         if (av7110->registered)
1314                 return -1;
1315 
1316         av7110->registered = 1;
1317 
1318         dvbdemux->priv = (void *) av7110;
1319 
1320         for (i = 0; i < 32; i++)
1321                 av7110->handle2filter[i] = NULL;
1322 
1323         dvbdemux->filternum = (av7110->full_ts) ? 256 : 32;
1324         dvbdemux->feednum = (av7110->full_ts) ? 256 : 32;
1325         dvbdemux->start_feed = av7110_start_feed;
1326         dvbdemux->stop_feed = av7110_stop_feed;
1327         dvbdemux->write_to_decoder = av7110_write_to_decoder;
1328         dvbdemux->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1329                                       DMX_MEMORY_BASED_FILTERING);
1330 
1331         dvb_dmx_init(&av7110->demux);
1332         av7110->demux.dmx.get_stc = dvb_get_stc;
1333 
1334         av7110->dmxdev.filternum = (av7110->full_ts) ? 256 : 32;
1335         av7110->dmxdev.demux = &dvbdemux->dmx;
1336         av7110->dmxdev.capabilities = 0;
1337 
1338         dvb_dmxdev_init(&av7110->dmxdev, &av7110->dvb_adapter);
1339 
1340         av7110->hw_frontend.source = DMX_FRONTEND_0;
1341 
1342         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1343 
1344         if (ret < 0)
1345                 return ret;
1346 
1347         av7110->mem_frontend.source = DMX_MEMORY_FE;
1348 
1349         ret = dvbdemux->dmx.add_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1350 
1351         if (ret < 0)
1352                 return ret;
1353 
1354         ret = dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1355                                              &av7110->hw_frontend);
1356         if (ret < 0)
1357                 return ret;
1358 
1359         av7110_av_register(av7110);
1360         av7110_ca_register(av7110);
1361 
1362 #ifdef CONFIG_DVB_AV7110_OSD
1363         dvb_register_device(&av7110->dvb_adapter, &av7110->osd_dev,
1364                             &dvbdev_osd, av7110, DVB_DEVICE_OSD);
1365 #endif
1366 
1367         dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net, &dvbdemux->dmx);
1368 
1369         if (budgetpatch) {
1370                 /* initialize software demux1 without its own frontend
1371                  * demux1 hardware is connected to frontend0 of demux0
1372                  */
1373                 dvbdemux1->priv = (void *) av7110;
1374 
1375                 dvbdemux1->filternum = 256;
1376                 dvbdemux1->feednum = 256;
1377                 dvbdemux1->start_feed = budget_start_feed;
1378                 dvbdemux1->stop_feed = budget_stop_feed;
1379                 dvbdemux1->write_to_decoder = NULL;
1380 
1381                 dvbdemux1->dmx.capabilities = (DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1382                                                DMX_MEMORY_BASED_FILTERING);
1383 
1384                 dvb_dmx_init(&av7110->demux1);
1385 
1386                 av7110->dmxdev1.filternum = 256;
1387                 av7110->dmxdev1.demux = &dvbdemux1->dmx;
1388                 av7110->dmxdev1.capabilities = 0;
1389 
1390                 dvb_dmxdev_init(&av7110->dmxdev1, &av7110->dvb_adapter);
1391 
1392                 dvb_net_init(&av7110->dvb_adapter, &av7110->dvb_net1, &dvbdemux1->dmx);
1393                 printk("dvb-ttpci: additional demux1 for budget-patch registered\n");
1394         }
1395         return 0;
1396 }
1397 
1398 
1399 static void dvb_unregister(struct av7110 *av7110)
1400 {
1401         struct dvb_demux *dvbdemux = &av7110->demux;
1402         struct dvb_demux *dvbdemux1 = &av7110->demux1;
1403 
1404         dprintk(4, "%p\n", av7110);
1405 
1406         if (!av7110->registered)
1407                 return;
1408 
1409         if (budgetpatch) {
1410                 dvb_net_release(&av7110->dvb_net1);
1411                 dvbdemux->dmx.close(&dvbdemux1->dmx);
1412                 dvb_dmxdev_release(&av7110->dmxdev1);
1413                 dvb_dmx_release(&av7110->demux1);
1414         }
1415 
1416         dvb_net_release(&av7110->dvb_net);
1417 
1418         dvbdemux->dmx.close(&dvbdemux->dmx);
1419         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->hw_frontend);
1420         dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &av7110->mem_frontend);
1421 
1422         dvb_dmxdev_release(&av7110->dmxdev);
1423         dvb_dmx_release(&av7110->demux);
1424 
1425         if (av7110->fe != NULL) {
1426                 dvb_unregister_frontend(av7110->fe);
1427                 dvb_frontend_detach(av7110->fe);
1428         }
1429         dvb_unregister_device(av7110->osd_dev);
1430         av7110_av_unregister(av7110);
1431         av7110_ca_unregister(av7110);
1432 }
1433 
1434 
1435 /****************************************************************************
1436  * I2C client commands
1437  ****************************************************************************/
1438 
1439 int i2c_writereg(struct av7110 *av7110, u8 id, u8 reg, u8 val)
1440 {
1441         u8 msg[2] = { reg, val };
1442         struct i2c_msg msgs;
1443 
1444         msgs.flags = 0;
1445         msgs.addr = id / 2;
1446         msgs.len = 2;
1447         msgs.buf = msg;
1448         return i2c_transfer(&av7110->i2c_adap, &msgs, 1);
1449 }
1450 
1451 u8 i2c_readreg(struct av7110 *av7110, u8 id, u8 reg)
1452 {
1453         u8 mm1[] = {0x00};
1454         u8 mm2[] = {0x00};
1455         struct i2c_msg msgs[2];
1456 
1457         msgs[0].flags = 0;
1458         msgs[1].flags = I2C_M_RD;
1459         msgs[0].addr = msgs[1].addr = id / 2;
1460         mm1[0] = reg;
1461         msgs[0].len = 1; msgs[1].len = 1;
1462         msgs[0].buf = mm1; msgs[1].buf = mm2;
1463         i2c_transfer(&av7110->i2c_adap, msgs, 2);
1464 
1465         return mm2[0];
1466 }
1467 
1468 /****************************************************************************
1469  * INITIALIZATION
1470  ****************************************************************************/
1471 
1472 
1473 static int check_firmware(struct av7110* av7110)
1474 {
1475         u32 crc = 0, len = 0;
1476         unsigned char *ptr;
1477 
1478         /* check for firmware magic */
1479         ptr = av7110->bin_fw;
1480         if (ptr[0] != 'A' || ptr[1] != 'V' ||
1481             ptr[2] != 'F' || ptr[3] != 'W') {
1482                 printk("dvb-ttpci: this is not an av7110 firmware\n");
1483                 return -EINVAL;
1484         }
1485         ptr += 4;
1486 
1487         /* check dpram file */
1488         crc = get_unaligned_be32(ptr);
1489         ptr += 4;
1490         len = get_unaligned_be32(ptr);
1491         ptr += 4;
1492         if (len >= 512) {
1493                 printk("dvb-ttpci: dpram file is way too big.\n");
1494                 return -EINVAL;
1495         }
1496         if (crc != crc32_le(0, ptr, len)) {
1497                 printk("dvb-ttpci: crc32 of dpram file does not match.\n");
1498                 return -EINVAL;
1499         }
1500         av7110->bin_dpram = ptr;
1501         av7110->size_dpram = len;
1502         ptr += len;
1503 
1504         /* check root file */
1505         crc = get_unaligned_be32(ptr);
1506         ptr += 4;
1507         len = get_unaligned_be32(ptr);
1508         ptr += 4;
1509 
1510         if (len <= 200000 || len >= 300000 ||
1511             len > ((av7110->bin_fw + av7110->size_fw) - ptr)) {
1512                 printk("dvb-ttpci: root file has strange size (%d). aborting.\n", len);
1513                 return -EINVAL;
1514         }
1515         if( crc != crc32_le(0, ptr, len)) {
1516                 printk("dvb-ttpci: crc32 of root file does not match.\n");
1517                 return -EINVAL;
1518         }
1519         av7110->bin_root = ptr;
1520         av7110->size_root = len;
1521         return 0;
1522 }
1523 
1524 static void put_firmware(struct av7110* av7110)
1525 {
1526         vfree(av7110->bin_fw);
1527 }
1528 
1529 static int get_firmware(struct av7110* av7110)
1530 {
1531         int ret;
1532         const struct firmware *fw;
1533 
1534         /* request the av7110 firmware, this will block until someone uploads it */
1535         ret = request_firmware(&fw, "dvb-ttpci-01.fw", &av7110->dev->pci->dev);
1536         if (ret) {
1537                 if (ret == -ENOENT) {
1538                         printk(KERN_ERR "dvb-ttpci: could not load firmware,"
1539                                " file not found: dvb-ttpci-01.fw\n");
1540                         printk(KERN_ERR "dvb-ttpci: usually this should be in "
1541                                "/usr/lib/hotplug/firmware or /lib/firmware\n");
1542                         printk(KERN_ERR "dvb-ttpci: and can be downloaded from"
1543                                " http://www.linuxtv.org/download/dvb/firmware/\n");
1544                 } else
1545                         printk(KERN_ERR "dvb-ttpci: cannot request firmware"
1546                                " (error %i)\n", ret);
1547                 return -EINVAL;
1548         }
1549 
1550         if (fw->size <= 200000) {
1551                 printk("dvb-ttpci: this firmware is way too small.\n");
1552                 release_firmware(fw);
1553                 return -EINVAL;
1554         }
1555 
1556         /* check if the firmware is available */
1557         av7110->bin_fw = vmalloc(fw->size);
1558         if (NULL == av7110->bin_fw) {
1559                 dprintk(1, "out of memory\n");
1560                 release_firmware(fw);
1561                 return -ENOMEM;
1562         }
1563 
1564         memcpy(av7110->bin_fw, fw->data, fw->size);
1565         av7110->size_fw = fw->size;
1566         if ((ret = check_firmware(av7110)))
1567                 vfree(av7110->bin_fw);
1568 
1569         release_firmware(fw);
1570         return ret;
1571 }
1572 
1573 static int alps_bsrv2_tuner_set_params(struct dvb_frontend *fe)
1574 {
1575         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1576         struct av7110* av7110 = fe->dvb->priv;
1577         u8 pwr = 0;
1578         u8 buf[4];
1579         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = buf, .len = sizeof(buf) };
1580         u32 div = (p->frequency + 479500) / 125;
1581 
1582         if (p->frequency > 2000000)
1583                 pwr = 3;
1584         else if (p->frequency > 1800000)
1585                 pwr = 2;
1586         else if (p->frequency > 1600000)
1587                 pwr = 1;
1588         else if (p->frequency > 1200000)
1589                 pwr = 0;
1590         else if (p->frequency >= 1100000)
1591                 pwr = 1;
1592         else
1593                 pwr = 2;
1594 
1595         buf[0] = (div >> 8) & 0x7f;
1596         buf[1] = div & 0xff;
1597         buf[2] = ((div & 0x18000) >> 10) | 0x95;
1598         buf[3] = (pwr << 6) | 0x30;
1599 
1600         // NOTE: since we're using a prescaler of 2, we set the
1601         // divisor frequency to 62.5kHz and divide by 125 above
1602 
1603         if (fe->ops.i2c_gate_ctrl)
1604                 fe->ops.i2c_gate_ctrl(fe, 1);
1605         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1)
1606                 return -EIO;
1607         return 0;
1608 }
1609 
1610 static struct ves1x93_config alps_bsrv2_config = {
1611         .demod_address = 0x08,
1612         .xin = 90100000UL,
1613         .invert_pwm = 0,
1614 };
1615 
1616 static int alps_tdbe2_tuner_set_params(struct dvb_frontend *fe)
1617 {
1618         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1619         struct av7110* av7110 = fe->dvb->priv;
1620         u32 div;
1621         u8 data[4];
1622         struct i2c_msg msg = { .addr = 0x62, .flags = 0, .buf = data, .len = sizeof(data) };
1623 
1624         div = (p->frequency + 35937500 + 31250) / 62500;
1625 
1626         data[0] = (div >> 8) & 0x7f;
1627         data[1] = div & 0xff;
1628         data[2] = 0x85 | ((div >> 10) & 0x60);
1629         data[3] = (p->frequency < 174000000 ? 0x88 : p->frequency < 470000000 ? 0x84 : 0x81);
1630 
1631         if (fe->ops.i2c_gate_ctrl)
1632                 fe->ops.i2c_gate_ctrl(fe, 1);
1633         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1634                 return -EIO;
1635         return 0;
1636 }
1637 
1638 static struct ves1820_config alps_tdbe2_config = {
1639         .demod_address = 0x09,
1640         .xin = 57840000UL,
1641         .invert = 1,
1642         .selagc = VES1820_SELAGC_SIGNAMPERR,
1643 };
1644 
1645 
1646 
1647 
1648 static int grundig_29504_451_tuner_set_params(struct dvb_frontend *fe)
1649 {
1650         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1651         struct av7110* av7110 = fe->dvb->priv;
1652         u32 div;
1653         u8 data[4];
1654         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1655 
1656         div = p->frequency / 125;
1657         data[0] = (div >> 8) & 0x7f;
1658         data[1] = div & 0xff;
1659         data[2] = 0x8e;
1660         data[3] = 0x00;
1661 
1662         if (fe->ops.i2c_gate_ctrl)
1663                 fe->ops.i2c_gate_ctrl(fe, 1);
1664         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1665                 return -EIO;
1666         return 0;
1667 }
1668 
1669 static struct tda8083_config grundig_29504_451_config = {
1670         .demod_address = 0x68,
1671 };
1672 
1673 
1674 
1675 static int philips_cd1516_tuner_set_params(struct dvb_frontend *fe)
1676 {
1677         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1678         struct av7110* av7110 = fe->dvb->priv;
1679         u32 div;
1680         u32 f = p->frequency;
1681         u8 data[4];
1682         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1683 
1684         div = (f + 36125000 + 31250) / 62500;
1685 
1686         data[0] = (div >> 8) & 0x7f;
1687         data[1] = div & 0xff;
1688         data[2] = 0x8e;
1689         data[3] = (f < 174000000 ? 0xa1 : f < 470000000 ? 0x92 : 0x34);
1690 
1691         if (fe->ops.i2c_gate_ctrl)
1692                 fe->ops.i2c_gate_ctrl(fe, 1);
1693         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1694                 return -EIO;
1695         return 0;
1696 }
1697 
1698 static struct ves1820_config philips_cd1516_config = {
1699         .demod_address = 0x09,
1700         .xin = 57840000UL,
1701         .invert = 1,
1702         .selagc = VES1820_SELAGC_SIGNAMPERR,
1703 };
1704 
1705 
1706 
1707 static int alps_tdlb7_tuner_set_params(struct dvb_frontend *fe)
1708 {
1709         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1710         struct av7110* av7110 = fe->dvb->priv;
1711         u32 div, pwr;
1712         u8 data[4];
1713         struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
1714 
1715         div = (p->frequency + 36200000) / 166666;
1716 
1717         if (p->frequency <= 782000000)
1718                 pwr = 1;
1719         else
1720                 pwr = 2;
1721 
1722         data[0] = (div >> 8) & 0x7f;
1723         data[1] = div & 0xff;
1724         data[2] = 0x85;
1725         data[3] = pwr << 6;
1726 
1727         if (fe->ops.i2c_gate_ctrl)
1728                 fe->ops.i2c_gate_ctrl(fe, 1);
1729         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1)
1730                 return -EIO;
1731         return 0;
1732 }
1733 
1734 static int alps_tdlb7_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
1735 {
1736 #if IS_ENABLED(CONFIG_DVB_SP8870)
1737         struct av7110* av7110 = fe->dvb->priv;
1738 
1739         return request_firmware(fw, name, &av7110->dev->pci->dev);
1740 #else
1741         return -EINVAL;
1742 #endif
1743 }
1744 
1745 static struct sp8870_config alps_tdlb7_config = {
1746 
1747         .demod_address = 0x71,
1748         .request_firmware = alps_tdlb7_request_firmware,
1749 };
1750 
1751 
1752 static u8 nexusca_stv0297_inittab[] = {
1753         0x80, 0x01,
1754         0x80, 0x00,
1755         0x81, 0x01,
1756         0x81, 0x00,
1757         0x00, 0x09,
1758         0x01, 0x69,
1759         0x03, 0x00,
1760         0x04, 0x00,
1761         0x07, 0x00,
1762         0x08, 0x00,
1763         0x20, 0x00,
1764         0x21, 0x40,
1765         0x22, 0x00,
1766         0x23, 0x00,
1767         0x24, 0x40,
1768         0x25, 0x88,
1769         0x30, 0xff,
1770         0x31, 0x00,
1771         0x32, 0xff,
1772         0x33, 0x00,
1773         0x34, 0x50,
1774         0x35, 0x7f,
1775         0x36, 0x00,
1776         0x37, 0x20,
1777         0x38, 0x00,
1778         0x40, 0x1c,
1779         0x41, 0xff,
1780         0x42, 0x29,
1781         0x43, 0x00,
1782         0x44, 0xff,
1783         0x45, 0x00,
1784         0x46, 0x00,
1785         0x49, 0x04,
1786         0x4a, 0x00,
1787         0x4b, 0x7b,
1788         0x52, 0x30,
1789         0x55, 0xae,
1790         0x56, 0x47,
1791         0x57, 0xe1,
1792         0x58, 0x3a,
1793         0x5a, 0x1e,
1794         0x5b, 0x34,
1795         0x60, 0x00,
1796         0x63, 0x00,
1797         0x64, 0x00,
1798         0x65, 0x00,
1799         0x66, 0x00,
1800         0x67, 0x00,
1801         0x68, 0x00,
1802         0x69, 0x00,
1803         0x6a, 0x02,
1804         0x6b, 0x00,
1805         0x70, 0xff,
1806         0x71, 0x00,
1807         0x72, 0x00,
1808         0x73, 0x00,
1809         0x74, 0x0c,
1810         0x80, 0x00,
1811         0x81, 0x00,
1812         0x82, 0x00,
1813         0x83, 0x00,
1814         0x84, 0x04,
1815         0x85, 0x80,
1816         0x86, 0x24,
1817         0x87, 0x78,
1818         0x88, 0x10,
1819         0x89, 0x00,
1820         0x90, 0x01,
1821         0x91, 0x01,
1822         0xa0, 0x04,
1823         0xa1, 0x00,
1824         0xa2, 0x00,
1825         0xb0, 0x91,
1826         0xb1, 0x0b,
1827         0xc0, 0x53,
1828         0xc1, 0x70,
1829         0xc2, 0x12,
1830         0xd0, 0x00,
1831         0xd1, 0x00,
1832         0xd2, 0x00,
1833         0xd3, 0x00,
1834         0xd4, 0x00,
1835         0xd5, 0x00,
1836         0xde, 0x00,
1837         0xdf, 0x00,
1838         0x61, 0x49,
1839         0x62, 0x0b,
1840         0x53, 0x08,
1841         0x59, 0x08,
1842         0xff, 0xff,
1843 };
1844 
1845 static int nexusca_stv0297_tuner_set_params(struct dvb_frontend *fe)
1846 {
1847         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1848         struct av7110* av7110 = fe->dvb->priv;
1849         u32 div;
1850         u8 data[4];
1851         struct i2c_msg msg = { .addr = 0x63, .flags = 0, .buf = data, .len = sizeof(data) };
1852         struct i2c_msg readmsg = { .addr = 0x63, .flags = I2C_M_RD, .buf = data, .len = 1 };
1853         int i;
1854 
1855         div = (p->frequency + 36150000 + 31250) / 62500;
1856 
1857         data[0] = (div >> 8) & 0x7f;
1858         data[1] = div & 0xff;
1859         data[2] = 0xce;
1860 
1861         if (p->frequency < 45000000)
1862                 return -EINVAL;
1863         else if (p->frequency < 137000000)
1864                 data[3] = 0x01;
1865         else if (p->frequency < 403000000)
1866                 data[3] = 0x02;
1867         else if (p->frequency < 860000000)
1868                 data[3] = 0x04;
1869         else
1870                 return -EINVAL;
1871 
1872         if (fe->ops.i2c_gate_ctrl)
1873                 fe->ops.i2c_gate_ctrl(fe, 1);
1874         if (i2c_transfer(&av7110->i2c_adap, &msg, 1) != 1) {
1875                 printk("nexusca: pll transfer failed!\n");
1876                 return -EIO;
1877         }
1878 
1879         // wait for PLL lock
1880         for(i = 0; i < 20; i++) {
1881                 if (fe->ops.i2c_gate_ctrl)
1882                         fe->ops.i2c_gate_ctrl(fe, 1);
1883                 if (i2c_transfer(&av7110->i2c_adap, &readmsg, 1) == 1)
1884                         if (data[0] & 0x40) break;
1885                 msleep(10);
1886         }
1887 
1888         return 0;
1889 }
1890 
1891 static struct stv0297_config nexusca_stv0297_config = {
1892 
1893         .demod_address = 0x1C,
1894         .inittab = nexusca_stv0297_inittab,
1895         .invert = 1,
1896         .stop_during_read = 1,
1897 };
1898 
1899 
1900 
1901 static int grundig_29504_401_tuner_set_params(struct dvb_frontend *fe)
1902 {
1903         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1904         struct av7110* av7110 = fe->dvb->priv;
1905         u32 div;
1906         u8 cfg, cpump, band_select;
1907         u8 data[4];
1908         struct i2c_msg msg = { .addr = 0x61, .flags = 0, .buf = data, .len = sizeof(data) };
1909 
1910         div = (36125000 + p->frequency) / 166666;
1911 
1912         cfg = 0x88;
1913 
1914         if (p->frequency < 175000000)
1915                 cpump = 2;
1916         else if (p->frequency < 390000000)
1917                 cpump = 1;
1918         else if (p->frequency < 470000000)
1919                 cpump = 2;
1920         else if (p->frequency < 750000000)
1921                 cpump = 1;
1922         else
1923                 cpump = 3;
1924 
1925         if (p->frequency < 175000000)
1926                 band_select = 0x0e;
1927         else if (p->frequency < 470000000)
1928                 band_select = 0x05;
1929         else
1930                 band_select = 0x03;
1931 
1932         data[0] = (div >> 8) & 0x7f;
1933         data[1] = div & 0xff;
1934         data[2] = ((div >> 10) & 0x60) | cfg;
1935         data[3] = (cpump << 6) | band_select;
1936 
1937         if (fe->ops.i2c_gate_ctrl)
1938                 fe->ops.i2c_gate_ctrl(fe, 1);
1939         if (i2c_transfer (&av7110->i2c_adap, &msg, 1) != 1) return -EIO;
1940         return 0;
1941 }
1942 
1943 static struct l64781_config grundig_29504_401_config = {
1944         .demod_address = 0x55,
1945 };
1946 
1947 
1948 
1949 static int av7110_fe_lock_fix(struct av7110 *av7110, enum fe_status status)
1950 {
1951         int ret = 0;
1952         int synced = (status & FE_HAS_LOCK) ? 1 : 0;
1953 
1954         av7110->fe_status = status;
1955 
1956         if (av7110->fe_synced == synced)
1957                 return 0;
1958 
1959         if (av7110->playing) {
1960                 av7110->fe_synced = synced;
1961                 return 0;
1962         }
1963 
1964         if (mutex_lock_interruptible(&av7110->pid_mutex))
1965                 return -ERESTARTSYS;
1966 
1967         if (synced) {
1968                 ret = SetPIDs(av7110, av7110->pids[DMX_PES_VIDEO],
1969                         av7110->pids[DMX_PES_AUDIO],
1970                         av7110->pids[DMX_PES_TELETEXT], 0,
1971                         av7110->pids[DMX_PES_PCR]);
1972                 if (!ret)
1973                         ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
1974         } else {
1975                 ret = SetPIDs(av7110, 0, 0, 0, 0, 0);
1976                 if (!ret) {
1977                         ret = av7110_fw_cmd(av7110, COMTYPE_PID_FILTER, FlushTSQueue, 0);
1978                         if (!ret)
1979                                 ret = av7110_wait_msgstate(av7110, GPMQBusy);
1980                 }
1981         }
1982 
1983         if (!ret)
1984                 av7110->fe_synced = synced;
1985 
1986         mutex_unlock(&av7110->pid_mutex);
1987         return ret;
1988 }
1989 
1990 static int av7110_fe_set_frontend(struct dvb_frontend *fe)
1991 {
1992         struct av7110* av7110 = fe->dvb->priv;
1993 
1994         int ret = av7110_fe_lock_fix(av7110, 0);
1995         if (!ret)
1996                 ret = av7110->fe_set_frontend(fe);
1997 
1998         return ret;
1999 }
2000 
2001 static int av7110_fe_init(struct dvb_frontend* fe)
2002 {
2003         struct av7110* av7110 = fe->dvb->priv;
2004 
2005         int ret = av7110_fe_lock_fix(av7110, 0);
2006         if (!ret)
2007                 ret = av7110->fe_init(fe);
2008         return ret;
2009 }
2010 
2011 static int av7110_fe_read_status(struct dvb_frontend *fe,
2012                                  enum fe_status *status)
2013 {
2014         struct av7110* av7110 = fe->dvb->priv;
2015 
2016         /* call the real implementation */
2017         int ret = av7110->fe_read_status(fe, status);
2018         if (!ret)
2019                 if (((*status ^ av7110->fe_status) & FE_HAS_LOCK) && (*status & FE_HAS_LOCK))
2020                         ret = av7110_fe_lock_fix(av7110, *status);
2021         return ret;
2022 }
2023 
2024 static int av7110_fe_diseqc_reset_overload(struct dvb_frontend* fe)
2025 {
2026         struct av7110* av7110 = fe->dvb->priv;
2027 
2028         int ret = av7110_fe_lock_fix(av7110, 0);
2029         if (!ret)
2030                 ret = av7110->fe_diseqc_reset_overload(fe);
2031         return ret;
2032 }
2033 
2034 static int av7110_fe_diseqc_send_master_cmd(struct dvb_frontend* fe,
2035                                             struct dvb_diseqc_master_cmd* cmd)
2036 {
2037         struct av7110* av7110 = fe->dvb->priv;
2038 
2039         int ret = av7110_fe_lock_fix(av7110, 0);
2040         if (!ret) {
2041                 av7110->saved_master_cmd = *cmd;
2042                 ret = av7110->fe_diseqc_send_master_cmd(fe, cmd);
2043         }
2044         return ret;
2045 }
2046 
2047 static int av7110_fe_diseqc_send_burst(struct dvb_frontend *fe,
2048                                        enum fe_sec_mini_cmd minicmd)
2049 {
2050         struct av7110* av7110 = fe->dvb->priv;
2051 
2052         int ret = av7110_fe_lock_fix(av7110, 0);
2053         if (!ret) {
2054                 av7110->saved_minicmd = minicmd;
2055                 ret = av7110->fe_diseqc_send_burst(fe, minicmd);
2056         }
2057         return ret;
2058 }
2059 
2060 static int av7110_fe_set_tone(struct dvb_frontend *fe,
2061                               enum fe_sec_tone_mode tone)
2062 {
2063         struct av7110* av7110 = fe->dvb->priv;
2064 
2065         int ret = av7110_fe_lock_fix(av7110, 0);
2066         if (!ret) {
2067                 av7110->saved_tone = tone;
2068                 ret = av7110->fe_set_tone(fe, tone);
2069         }
2070         return ret;
2071 }
2072 
2073 static int av7110_fe_set_voltage(struct dvb_frontend *fe,
2074                                  enum fe_sec_voltage voltage)
2075 {
2076         struct av7110* av7110 = fe->dvb->priv;
2077 
2078         int ret = av7110_fe_lock_fix(av7110, 0);
2079         if (!ret) {
2080                 av7110->saved_voltage = voltage;
2081                 ret = av7110->fe_set_voltage(fe, voltage);
2082         }
2083         return ret;
2084 }
2085 
2086 static int av7110_fe_dishnetwork_send_legacy_command(struct dvb_frontend* fe, unsigned long cmd)
2087 {
2088         struct av7110* av7110 = fe->dvb->priv;
2089 
2090         int ret = av7110_fe_lock_fix(av7110, 0);
2091         if (!ret)
2092                 ret = av7110->fe_dishnetwork_send_legacy_command(fe, cmd);
2093         return ret;
2094 }
2095 
2096 static void dvb_s_recover(struct av7110* av7110)
2097 {
2098         av7110_fe_init(av7110->fe);
2099 
2100         av7110_fe_set_voltage(av7110->fe, av7110->saved_voltage);
2101         if (av7110->saved_master_cmd.msg_len) {
2102                 msleep(20);
2103                 av7110_fe_diseqc_send_master_cmd(av7110->fe, &av7110->saved_master_cmd);
2104         }
2105         msleep(20);
2106         av7110_fe_diseqc_send_burst(av7110->fe, av7110->saved_minicmd);
2107         msleep(20);
2108         av7110_fe_set_tone(av7110->fe, av7110->saved_tone);
2109 
2110         av7110_fe_set_frontend(av7110->fe);
2111 }
2112 
2113 static u8 read_pwm(struct av7110* av7110)
2114 {
2115         u8 b = 0xff;
2116         u8 pwm;
2117         struct i2c_msg msg[] = { { .addr = 0x50,.flags = 0,.buf = &b,.len = 1 },
2118                                  { .addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1} };
2119 
2120         if ((i2c_transfer(&av7110->i2c_adap, msg, 2) != 2) || (pwm == 0xff))
2121                 pwm = 0x48;
2122 
2123         return pwm;
2124 }
2125 
2126 static int frontend_init(struct av7110 *av7110)
2127 {
2128         int ret;
2129 
2130         if (av7110->dev->pci->subsystem_vendor == 0x110a) {
2131                 switch(av7110->dev->pci->subsystem_device) {
2132                 case 0x0000: // Fujitsu/Siemens DVB-Cable (ves1820/Philips CD1516(??))
2133                         av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config,
2134                                                     &av7110->i2c_adap, read_pwm(av7110));
2135                         if (av7110->fe) {
2136                                 av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2137                         }
2138                         break;
2139                 }
2140 
2141         } else if (av7110->dev->pci->subsystem_vendor == 0x13c2) {
2142                 switch(av7110->dev->pci->subsystem_device) {
2143                 case 0x0000: // Hauppauge/TT WinTV DVB-S rev1.X
2144                 case 0x0003: // Hauppauge/TT WinTV Nexus-S Rev 2.X
2145                 case 0x1002: // Hauppauge/TT WinTV DVB-S rev1.3SE
2146 
2147                         // try the ALPS BSRV2 first of all
2148                         av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2149                         if (av7110->fe) {
2150                                 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2151                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2152                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2153                                 av7110->fe->ops.set_tone = av7110_set_tone;
2154                                 av7110->recover = dvb_s_recover;
2155                                 break;
2156                         }
2157 
2158                         // try the ALPS BSRU6 now
2159                         av7110->fe = dvb_attach(stv0299_attach, &alps_bsru6_config, &av7110->i2c_adap);
2160                         if (av7110->fe) {
2161                                 av7110->fe->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
2162                                 av7110->fe->tuner_priv = &av7110->i2c_adap;
2163 
2164                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2165                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2166                                 av7110->fe->ops.set_tone = av7110_set_tone;
2167                                 av7110->recover = dvb_s_recover;
2168                                 break;
2169                         }
2170 
2171                         // Try the grundig 29504-451
2172                         av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2173                         if (av7110->fe) {
2174                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2175                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2176                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2177                                 av7110->fe->ops.set_tone = av7110_set_tone;
2178                                 av7110->recover = dvb_s_recover;
2179                                 break;
2180                         }
2181 
2182                         /* Try DVB-C cards */
2183                         switch(av7110->dev->pci->subsystem_device) {
2184                         case 0x0000:
2185                                 /* Siemens DVB-C (full-length card) VES1820/Philips CD1516 */
2186                                 av7110->fe = dvb_attach(ves1820_attach, &philips_cd1516_config, &av7110->i2c_adap,
2187                                                         read_pwm(av7110));
2188                                 if (av7110->fe) {
2189                                         av7110->fe->ops.tuner_ops.set_params = philips_cd1516_tuner_set_params;
2190                                 }
2191                                 break;
2192                         case 0x0003:
2193                                 /* Hauppauge DVB-C 2.1 VES1820/ALPS TDBE2 */
2194                                 av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap,
2195                                                         read_pwm(av7110));
2196                                 if (av7110->fe) {
2197                                         av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2198                                 }
2199                                 break;
2200                         }
2201                         break;
2202 
2203                 case 0x0001: // Hauppauge/TT Nexus-T premium rev1.X
2204                         // try ALPS TDLB7 first, then Grundig 29504-401
2205                         av7110->fe = dvb_attach(sp8870_attach, &alps_tdlb7_config, &av7110->i2c_adap);
2206                         if (av7110->fe) {
2207                                 av7110->fe->ops.tuner_ops.set_params = alps_tdlb7_tuner_set_params;
2208                                 break;
2209                         }
2210                         /* fall-thru */
2211 
2212                 case 0x0008: // Hauppauge/TT DVB-T
2213                         // Grundig 29504-401
2214                         av7110->fe = dvb_attach(l64781_attach, &grundig_29504_401_config, &av7110->i2c_adap);
2215                         if (av7110->fe)
2216                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_401_tuner_set_params;
2217                         break;
2218 
2219                 case 0x0002: // Hauppauge/TT DVB-C premium rev2.X
2220 
2221                         av7110->fe = dvb_attach(ves1820_attach, &alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
2222                         if (av7110->fe) {
2223                                 av7110->fe->ops.tuner_ops.set_params = alps_tdbe2_tuner_set_params;
2224                         }
2225                         break;
2226 
2227                 case 0x0004: // Galaxis DVB-S rev1.3
2228                         /* ALPS BSRV2 */
2229                         av7110->fe = dvb_attach(ves1x93_attach, &alps_bsrv2_config, &av7110->i2c_adap);
2230                         if (av7110->fe) {
2231                                 av7110->fe->ops.tuner_ops.set_params = alps_bsrv2_tuner_set_params;
2232                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2233                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2234                                 av7110->fe->ops.set_tone = av7110_set_tone;
2235                                 av7110->recover = dvb_s_recover;
2236                         }
2237                         break;
2238 
2239                 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
2240                         /* Grundig 29504-451 */
2241                         av7110->fe = dvb_attach(tda8083_attach, &grundig_29504_451_config, &av7110->i2c_adap);
2242                         if (av7110->fe) {
2243                                 av7110->fe->ops.tuner_ops.set_params = grundig_29504_451_tuner_set_params;
2244                                 av7110->fe->ops.diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
2245                                 av7110->fe->ops.diseqc_send_burst = av7110_diseqc_send_burst;
2246                                 av7110->fe->ops.set_tone = av7110_set_tone;
2247                                 av7110->recover = dvb_s_recover;
2248                         }
2249                         break;
2250 
2251                 case 0x000A: // Hauppauge/TT Nexus-CA rev1.X
2252 
2253                         av7110->fe = dvb_attach(stv0297_attach, &nexusca_stv0297_config, &av7110->i2c_adap);
2254                         if (av7110->fe) {
2255                                 av7110->fe->ops.tuner_ops.set_params = nexusca_stv0297_tuner_set_params;
2256 
2257                                 /* set TDA9819 into DVB mode */
2258                                 saa7146_setgpio(av7110->dev, 1, SAA7146_GPIO_OUTLO); // TDA9819 pin9(STD)
2259                                 saa7146_setgpio(av7110->dev, 3, SAA7146_GPIO_OUTLO); // TDA9819 pin30(VIF)
2260 
2261                                 /* tuner on this needs a slower i2c bus speed */
2262                                 av7110->dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
2263                                 break;
2264                         }
2265                         break;
2266 
2267                 case 0x000E: /* Hauppauge/TT Nexus-S rev 2.3 */
2268                         /* ALPS BSBE1 */
2269                         av7110->fe = dvb_attach(stv0299_attach, &alps_bsbe1_config, &av7110->i2c_adap);
2270                         if (av7110->fe) {
2271                                 av7110->fe->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
2272                                 av7110->fe->tuner_priv = &av7110->i2c_adap;
2273 
2274                                 if (dvb_attach(lnbp21_attach, av7110->fe, &av7110->i2c_adap, 0, 0) == NULL) {
2275                                         printk("dvb-ttpci: LNBP21 not found!\n");
2276                                         if (av7110->fe->ops.release)
2277                                                 av7110->fe->ops.release(av7110->fe);
2278                                         av7110->fe = NULL;
2279                                 } else {
2280                                         av7110->fe->ops.dishnetwork_send_legacy_command = NULL;
2281                                         av7110->recover = dvb_s_recover;
2282                                 }
2283                         }
2284                         break;
2285                 }
2286         }
2287 
2288         if (!av7110->fe) {
2289                 /* FIXME: propagate the failure code from the lower layers */
2290                 ret = -ENOMEM;
2291                 printk("dvb-ttpci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
2292                        av7110->dev->pci->vendor,
2293                        av7110->dev->pci->device,
2294                        av7110->dev->pci->subsystem_vendor,
2295                        av7110->dev->pci->subsystem_device);
2296         } else {
2297                 FE_FUNC_OVERRIDE(av7110->fe->ops.init, av7110->fe_init, av7110_fe_init);
2298                 FE_FUNC_OVERRIDE(av7110->fe->ops.read_status, av7110->fe_read_status, av7110_fe_read_status);
2299                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_reset_overload, av7110->fe_diseqc_reset_overload, av7110_fe_diseqc_reset_overload);
2300                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_master_cmd, av7110->fe_diseqc_send_master_cmd, av7110_fe_diseqc_send_master_cmd);
2301                 FE_FUNC_OVERRIDE(av7110->fe->ops.diseqc_send_burst, av7110->fe_diseqc_send_burst, av7110_fe_diseqc_send_burst);
2302                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_tone, av7110->fe_set_tone, av7110_fe_set_tone);
2303                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_voltage, av7110->fe_set_voltage, av7110_fe_set_voltage);
2304                 FE_FUNC_OVERRIDE(av7110->fe->ops.dishnetwork_send_legacy_command, av7110->fe_dishnetwork_send_legacy_command, av7110_fe_dishnetwork_send_legacy_command);
2305                 FE_FUNC_OVERRIDE(av7110->fe->ops.set_frontend, av7110->fe_set_frontend, av7110_fe_set_frontend);
2306 
2307                 ret = dvb_register_frontend(&av7110->dvb_adapter, av7110->fe);
2308                 if (ret < 0) {
2309                         printk("av7110: Frontend registration failed!\n");
2310                         dvb_frontend_detach(av7110->fe);
2311                         av7110->fe = NULL;
2312                 }
2313         }
2314         return ret;
2315 }
2316 
2317 /* Budgetpatch note:
2318  * Original hardware design by Roberto Deza:
2319  * There is a DVB_Wiki at
2320  * http://www.linuxtv.org/
2321  *
2322  * New software triggering design by Emard that works on
2323  * original Roberto Deza's hardware:
2324  *
2325  * rps1 code for budgetpatch will copy internal HS event to GPIO3 pin.
2326  * GPIO3 is in budget-patch hardware connectd to port B VSYNC
2327  * HS is an internal event of 7146, accessible with RPS
2328  * and temporarily raised high every n lines
2329  * (n in defined in the RPS_THRESH1 counter threshold)
2330  * I think HS is raised high on the beginning of the n-th line
2331  * and remains high until this n-th line that triggered
2332  * it is completely received. When the receiption of n-th line
2333  * ends, HS is lowered.
2334  *
2335  * To transmit data over DMA, 7146 needs changing state at
2336  * port B VSYNC pin. Any changing of port B VSYNC will
2337  * cause some DMA data transfer, with more or less packets loss.
2338  * It depends on the phase and frequency of VSYNC and
2339  * the way of 7146 is instructed to trigger on port B (defined
2340  * in DD1_INIT register, 3rd nibble from the right valid
2341  * numbers are 0-7, see datasheet)
2342  *
2343  * The correct triggering can minimize packet loss,
2344  * dvbtraffic should give this stable bandwidths:
2345  *   22k transponder = 33814 kbit/s
2346  * 27.5k transponder = 38045 kbit/s
2347  * by experiment it is found that the best results
2348  * (stable bandwidths and almost no packet loss)
2349  * are obtained using DD1_INIT triggering number 2
2350  * (Va at rising edge of VS Fa = HS x VS-failing forced toggle)
2351  * and a VSYNC phase that occurs in the middle of DMA transfer
2352  * (about byte 188*512=96256 in the DMA window).
2353  *
2354  * Phase of HS is still not clear to me how to control,
2355  * It just happens to be so. It can be seen if one enables
2356  * RPS_IRQ and print Event Counter 1 in vpeirq(). Every
2357  * time RPS_INTERRUPT is called, the Event Counter 1 will
2358  * increment. That's how the 7146 is programmed to do event
2359  * counting in this budget-patch.c
2360  * I *think* HPS setting has something to do with the phase
2361  * of HS but I can't be 100% sure in that.
2362  *
2363  * hardware debug note: a working budget card (including budget patch)
2364  * with vpeirq() interrupt setup in mode "0x90" (every 64K) will
2365  * generate 3 interrupts per 25-Hz DMA frame of 2*188*512 bytes
2366  * and that means 3*25=75 Hz of interrupt freqency, as seen by
2367  * watch cat /proc/interrupts
2368  *
2369  * If this frequency is 3x lower (and data received in the DMA
2370  * buffer don't start with 0x47, but in the middle of packets,
2371  * whose lengths appear to be like 188 292 188 104 etc.
2372  * this means VSYNC line is not connected in the hardware.
2373  * (check soldering pcb and pins)
2374  * The same behaviour of missing VSYNC can be duplicated on budget
2375  * cards, by seting DD1_INIT trigger mode 7 in 3rd nibble.
2376  */
2377 static int av7110_attach(struct saa7146_dev* dev,
2378                          struct saa7146_pci_extension_data *pci_ext)
2379 {
2380         const int length = TS_WIDTH * TS_HEIGHT;
2381         struct pci_dev *pdev = dev->pci;
2382         struct av7110 *av7110;
2383         struct task_struct *thread;
2384         int ret, count = 0;
2385 
2386         dprintk(4, "dev: %p\n", dev);
2387 
2388         /* Set RPS_IRQ to 1 to track rps1 activity.
2389          * Enabling this won't send any interrupt to PC CPU.
2390          */
2391 #define RPS_IRQ 0
2392 
2393         if (budgetpatch == 1) {
2394                 budgetpatch = 0;
2395                 /* autodetect the presence of budget patch
2396                  * this only works if saa7146 has been recently
2397                  * reset with with MASK_31 to MC1
2398                  *
2399                  * will wait for VBI_B event (vertical blank at port B)
2400                  * and will reset GPIO3 after VBI_B is detected.
2401                  * (GPIO3 should be raised high by CPU to
2402                  * test if GPIO3 will generate vertical blank signal
2403                  * in budget patch GPIO3 is connected to VSYNC_B
2404                  */
2405 
2406                 /* RESET SAA7146 */
2407                 saa7146_write(dev, MC1, MASK_31);
2408                 /* autodetection success seems to be time-dependend after reset */
2409 
2410                 /* Fix VSYNC level */
2411                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2412                 /* set vsync_b triggering */
2413                 saa7146_write(dev, DD1_STREAM_B, 0);
2414                 /* port B VSYNC at rising edge */
2415                 saa7146_write(dev, DD1_INIT, 0x00000200);
2416                 saa7146_write(dev, BRS_CTRL, 0x00000000);  // VBI
2417                 saa7146_write(dev, MC2,
2418                               1 * (MASK_08 | MASK_24)  |   // BRS control
2419                               0 * (MASK_09 | MASK_25)  |   // a
2420                               1 * (MASK_10 | MASK_26)  |   // b
2421                               0 * (MASK_06 | MASK_22)  |   // HPS_CTRL1
2422                               0 * (MASK_05 | MASK_21)  |   // HPS_CTRL2
2423                               0 * (MASK_01 | MASK_15)      // DEBI
2424                 );
2425 
2426                 /* start writing RPS1 code from beginning */
2427                 count = 0;
2428                 /* Disable RPS1 */
2429                 saa7146_write(dev, MC1, MASK_29);
2430                 /* RPS1 timeout disable */
2431                 saa7146_write(dev, RPS_TOV1, 0);
2432                 WRITE_RPS1(CMD_PAUSE | EVT_VBI_B);
2433                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2434                 WRITE_RPS1(GPIO3_MSK);
2435                 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2436 #if RPS_IRQ
2437                 /* issue RPS1 interrupt to increment counter */
2438                 WRITE_RPS1(CMD_INTERRUPT);
2439 #endif
2440                 WRITE_RPS1(CMD_STOP);
2441                 /* Jump to begin of RPS program as safety measure               (p37) */
2442                 WRITE_RPS1(CMD_JUMP);
2443                 WRITE_RPS1(dev->d_rps1.dma_handle);
2444 
2445 #if RPS_IRQ
2446                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2447                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2448                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2449                  */
2450                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2451                 /* set event counter 1 threshold to maximum allowed value        (rEC p55) */
2452                 saa7146_write(dev, ECT1R,  0x3fff );
2453 #endif
2454                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2455                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2456                 /* Enable RPS1,                                                 (rFC p33) */
2457                 saa7146_write(dev, MC1, (MASK_13 | MASK_29 ));
2458 
2459                 mdelay(10);
2460                 /* now send VSYNC_B to rps1 by rising GPIO3 */
2461                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTHI);
2462                 mdelay(10);
2463                 /* if rps1 responded by lowering the GPIO3,
2464                  * then we have budgetpatch hardware
2465                  */
2466                 if ((saa7146_read(dev, GPIO_CTRL) & 0x10000000) == 0) {
2467                         budgetpatch = 1;
2468                         printk("dvb-ttpci: BUDGET-PATCH DETECTED.\n");
2469                 }
2470                 /* Disable RPS1 */
2471                 saa7146_write(dev, MC1, ( MASK_29 ));
2472 #if RPS_IRQ
2473                 printk("dvb-ttpci: Event Counter 1 0x%04x\n", saa7146_read(dev, EC1R) & 0x3fff );
2474 #endif
2475         }
2476 
2477         /* prepare the av7110 device struct */
2478         av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
2479         if (!av7110) {
2480                 dprintk(1, "out of memory\n");
2481                 return -ENOMEM;
2482         }
2483 
2484         av7110->card_name = (char*) pci_ext->ext_priv;
2485         av7110->dev = dev;
2486         dev->ext_priv = av7110;
2487 
2488         ret = get_firmware(av7110);
2489         if (ret < 0)
2490                 goto err_kfree_0;
2491 
2492         ret = dvb_register_adapter(&av7110->dvb_adapter, av7110->card_name,
2493                                    THIS_MODULE, &dev->pci->dev, adapter_nr);
2494         if (ret < 0)
2495                 goto err_put_firmware_1;
2496 
2497         /* the Siemens DVB needs this if you want to have the i2c chips
2498            get recognized before the main driver is fully loaded */
2499         saa7146_write(dev, GPIO_CTRL, 0x500000);
2500 
2501         strlcpy(av7110->i2c_adap.name, pci_ext->ext_priv, sizeof(av7110->i2c_adap.name));
2502 
2503         saa7146_i2c_adapter_prepare(dev, &av7110->i2c_adap, SAA7146_I2C_BUS_BIT_RATE_120); /* 275 kHz */
2504 
2505         ret = i2c_add_adapter(&av7110->i2c_adap);
2506         if (ret < 0)
2507                 goto err_dvb_unregister_adapter_2;
2508 
2509         ttpci_eeprom_parse_mac(&av7110->i2c_adap,
2510                                av7110->dvb_adapter.proposed_mac);
2511         ret = -ENOMEM;
2512 
2513         /* full-ts mod? */
2514         if (full_ts)
2515                 av7110->full_ts = true;
2516 
2517         /* check for full-ts flag in eeprom */
2518         if (i2c_readreg(av7110, 0xaa, 0) == 0x4f && i2c_readreg(av7110, 0xaa, 1) == 0x45) {
2519                 u8 flags = i2c_readreg(av7110, 0xaa, 2);
2520                 if (flags != 0xff && (flags & 0x01))
2521                         av7110->full_ts = true;
2522         }
2523 
2524         if (av7110->full_ts) {
2525                 printk(KERN_INFO "dvb-ttpci: full-ts mode enabled for saa7146 port B\n");
2526                 spin_lock_init(&av7110->feedlock1);
2527                 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2528                                                                  &av7110->pt);
2529                 if (!av7110->grabbing)
2530                         goto err_i2c_del_3;
2531 
2532                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2533                 saa7146_write(dev, MC2, (MASK_10 | MASK_26));
2534 
2535                 saa7146_write(dev, DD1_INIT, 0x00000600);
2536                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2537 
2538                 saa7146_write(dev, BRS_CTRL, 0x60000000);
2539                 saa7146_write(dev, MC2, MASK_08 | MASK_24);
2540 
2541                 /* dma3 */
2542                 saa7146_write(dev, PCI_BT_V1, 0x001c0000 | (saa7146_read(dev, PCI_BT_V1) & ~0x001f0000));
2543                 saa7146_write(dev, BASE_ODD3, 0);
2544                 saa7146_write(dev, BASE_EVEN3, 0);
2545                 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2546                 saa7146_write(dev, PITCH3, TS_WIDTH);
2547                 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2548                 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2549                 saa7146_write(dev, MC2, MASK_04 | MASK_20);
2550 
2551                 tasklet_init(&av7110->vpe_tasklet, vpeirq, (unsigned long) av7110);
2552 
2553         } else if (budgetpatch) {
2554                 spin_lock_init(&av7110->feedlock1);
2555                 av7110->grabbing = saa7146_vmalloc_build_pgtable(pdev, length,
2556                                                                  &av7110->pt);
2557                 if (!av7110->grabbing)
2558                         goto err_i2c_del_3;
2559 
2560                 saa7146_write(dev, PCI_BT_V1, 0x1c1f101f);
2561                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2562                 /* set dd1 stream a & b */
2563                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2564                 saa7146_write(dev, DD1_INIT, 0x03000200);
2565                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2566                 saa7146_write(dev, BRS_CTRL, 0x60000000);
2567                 saa7146_write(dev, BASE_ODD3, 0);
2568                 saa7146_write(dev, BASE_EVEN3, 0);
2569                 saa7146_write(dev, PROT_ADDR3, TS_WIDTH * TS_HEIGHT);
2570                 saa7146_write(dev, BASE_PAGE3, av7110->pt.dma | ME1 | 0x90);
2571 
2572                 saa7146_write(dev, PITCH3, TS_WIDTH);
2573                 saa7146_write(dev, NUM_LINE_BYTE3, (TS_HEIGHT << 16) | TS_WIDTH);
2574 
2575                 /* upload all */
2576                 saa7146_write(dev, MC2, 0x077c077c);
2577                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2578 #if RPS_IRQ
2579                 /* set event counter 1 source as RPS1 interrupt (0x03)          (rE4 p53)
2580                  * use 0x03 to track RPS1 interrupts - increase by 1 every gpio3 is toggled
2581                  * use 0x15 to track VPE  interrupts - increase by 1 every vpeirq() is called
2582                  */
2583                 saa7146_write(dev, EC1SSR, (0x03<<2) | 3 );
2584                 /* set event counter 1 threshold to maximum allowed value        (rEC p55) */
2585                 saa7146_write(dev, ECT1R,  0x3fff );
2586 #endif
2587                 /* Setup BUDGETPATCH MAIN RPS1 "program" (p35) */
2588                 count = 0;
2589 
2590                 /* Wait Source Line Counter Threshold                           (p36) */
2591                 WRITE_RPS1(CMD_PAUSE | EVT_HS);
2592                 /* Set GPIO3=1                                                  (p42) */
2593                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2594                 WRITE_RPS1(GPIO3_MSK);
2595                 WRITE_RPS1(SAA7146_GPIO_OUTHI<<24);
2596 #if RPS_IRQ
2597                 /* issue RPS1 interrupt */
2598                 WRITE_RPS1(CMD_INTERRUPT);
2599 #endif
2600                 /* Wait reset Source Line Counter Threshold                     (p36) */
2601                 WRITE_RPS1(CMD_PAUSE | RPS_INV | EVT_HS);
2602                 /* Set GPIO3=0                                                  (p42) */
2603                 WRITE_RPS1(CMD_WR_REG_MASK | (GPIO_CTRL>>2));
2604                 WRITE_RPS1(GPIO3_MSK);
2605                 WRITE_RPS1(SAA7146_GPIO_OUTLO<<24);
2606 #if RPS_IRQ
2607                 /* issue RPS1 interrupt */
2608                 WRITE_RPS1(CMD_INTERRUPT);
2609 #endif
2610                 /* Jump to begin of RPS program                                 (p37) */
2611                 WRITE_RPS1(CMD_JUMP);
2612                 WRITE_RPS1(dev->d_rps1.dma_handle);
2613 
2614                 /* Fix VSYNC level */
2615                 saa7146_setgpio(dev, 3, SAA7146_GPIO_OUTLO);
2616                 /* Set RPS1 Address register to point to RPS code               (r108 p42) */
2617                 saa7146_write(dev, RPS_ADDR1, dev->d_rps1.dma_handle);
2618                 /* Set Source Line Counter Threshold, using BRS                 (rCC p43)
2619                  * It generates HS event every TS_HEIGHT lines
2620                  * this is related to TS_WIDTH set in register
2621                  * NUM_LINE_BYTE3. If NUM_LINE_BYTE low 16 bits
2622                  * are set to TS_WIDTH bytes (TS_WIDTH=2*188),
2623                  * then RPS_THRESH1 should be set to trigger
2624                  * every TS_HEIGHT (512) lines.
2625                  */
2626                 saa7146_write(dev, RPS_THRESH1, (TS_HEIGHT*1) | MASK_12 );
2627 
2628                 /* Enable RPS1                                                  (rFC p33) */
2629                 saa7146_write(dev, MC1, (MASK_13 | MASK_29));
2630 
2631                 /* end of budgetpatch register initialization */
2632                 tasklet_init (&av7110->vpe_tasklet,  vpeirq,  (unsigned long) av7110);
2633         } else {
2634                 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
2635                 saa7146_write(dev, BCS_CTRL, 0x80400040);
2636 
2637                 /* set dd1 stream a & b */
2638                 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
2639                 saa7146_write(dev, DD1_INIT, 0x03000000);
2640                 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
2641 
2642                 /* upload all */
2643                 saa7146_write(dev, MC2, 0x077c077c);
2644                 saa7146_write(dev, GPIO_CTRL, 0x000000);
2645         }
2646 
2647         tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
2648         tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
2649 
2650         mutex_init(&av7110->pid_mutex);
2651 
2652         /* locks for data transfers from/to AV7110 */
2653         spin_lock_init(&av7110->debilock);
2654         mutex_init(&av7110->dcomlock);
2655         av7110->debitype = -1;
2656 
2657         /* default OSD window */
2658         av7110->osdwin = 1;
2659         mutex_init(&av7110->osd_mutex);
2660 
2661         /* TV standard */
2662         av7110->vidmode = tv_standard == 1 ? AV7110_VIDEO_MODE_NTSC
2663                                            : AV7110_VIDEO_MODE_PAL;
2664 
2665         /* ARM "watchdog" */
2666         init_waitqueue_head(&av7110->arm_wait);
2667         av7110->arm_thread = NULL;
2668 
2669         /* allocate and init buffers */
2670         av7110->debi_virt = pci_alloc_consistent(pdev, 8192, &av7110->debi_bus);
2671         if (!av7110->debi_virt)
2672                 goto err_saa71466_vfree_4;
2673 
2674 
2675         av7110->iobuf = vmalloc(AVOUTLEN+AOUTLEN+BMPLEN+4*IPACKS);
2676         if (!av7110->iobuf)
2677                 goto err_pci_free_5;
2678 
2679         ret = av7110_av_init(av7110);
2680         if (ret < 0)
2681                 goto err_iobuf_vfree_6;
2682 
2683         /* init BMP buffer */
2684         av7110->bmpbuf = av7110->iobuf+AVOUTLEN+AOUTLEN;
2685         init_waitqueue_head(&av7110->bmpq);
2686 
2687         ret = av7110_ca_init(av7110);
2688         if (ret < 0)
2689                 goto err_av7110_av_exit_7;
2690 
2691         /* load firmware into AV7110 cards */
2692         ret = av7110_bootarm(av7110);
2693         if (ret < 0)
2694                 goto err_av7110_ca_exit_8;
2695 
2696         ret = av7110_firmversion(av7110);
2697         if (ret < 0)
2698                 goto err_stop_arm_9;
2699 
2700         if (FW_VERSION(av7110->arm_app)<0x2501)
2701                 printk ("dvb-ttpci: Warning, firmware version 0x%04x is too old. "
2702                         "System might be unstable!\n", FW_VERSION(av7110->arm_app));
2703 
2704         thread = kthread_run(arm_thread, (void *) av7110, "arm_mon");
2705         if (IS_ERR(thread)) {
2706                 ret = PTR_ERR(thread);
2707                 goto err_stop_arm_9;
2708         }
2709         av7110->arm_thread = thread;
2710 
2711         /* set initial volume in mixer struct */
2712         av7110->mixer.volume_left  = volume;
2713         av7110->mixer.volume_right = volume;
2714 
2715         ret = av7110_register(av7110);
2716         if (ret < 0)
2717                 goto err_arm_thread_stop_10;
2718 
2719         init_av7110_av(av7110);
2720 
2721         /* special case DVB-C: these cards have an analog tuner
2722            plus need some special handling, so we have separate
2723            saa7146_ext_vv data for these... */
2724         ret = av7110_init_v4l(av7110);
2725         if (ret < 0)
2726                 goto err_av7110_unregister_11;
2727 
2728         av7110->dvb_adapter.priv = av7110;
2729         ret = frontend_init(av7110);
2730         if (ret < 0)
2731                 goto err_av7110_exit_v4l_12;
2732 
2733         mutex_init(&av7110->ioctl_mutex);
2734 
2735 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2736         av7110_ir_init(av7110);
2737 #endif
2738         printk(KERN_INFO "dvb-ttpci: found av7110-%d.\n", av7110_num);
2739         av7110_num++;
2740 out:
2741         return ret;
2742 
2743 err_av7110_exit_v4l_12:
2744         av7110_exit_v4l(av7110);
2745 err_av7110_unregister_11:
2746         dvb_unregister(av7110);
2747 err_arm_thread_stop_10:
2748         av7110_arm_sync(av7110);
2749 err_stop_arm_9:
2750         /* Nothing to do. Rejoice. */
2751 err_av7110_ca_exit_8:
2752         av7110_ca_exit(av7110);
2753 err_av7110_av_exit_7:
2754         av7110_av_exit(av7110);
2755 err_iobuf_vfree_6:
2756         vfree(av7110->iobuf);
2757 err_pci_free_5:
2758         pci_free_consistent(pdev, 8192, av7110->debi_virt, av7110->debi_bus);
2759 err_saa71466_vfree_4:
2760         if (av7110->grabbing)
2761                 saa7146_vfree_destroy_pgtable(pdev, av7110->grabbing, &av7110->pt);
2762 err_i2c_del_3:
2763         i2c_del_adapter(&av7110->i2c_adap);
2764 err_dvb_unregister_adapter_2:
2765         dvb_unregister_adapter(&av7110->dvb_adapter);
2766 err_put_firmware_1:
2767         put_firmware(av7110);
2768 err_kfree_0:
2769         kfree(av7110);
2770         goto out;
2771 }
2772 
2773 static int av7110_detach(struct saa7146_dev* saa)
2774 {
2775         struct av7110 *av7110 = saa->ext_priv;
2776         dprintk(4, "%p\n", av7110);
2777 
2778 #if IS_ENABLED(CONFIG_DVB_AV7110_IR)
2779         av7110_ir_exit(av7110);
2780 #endif
2781         if (budgetpatch || av7110->full_ts) {
2782                 if (budgetpatch) {
2783                         /* Disable RPS1 */
2784                         saa7146_write(saa, MC1, MASK_29);
2785                         /* VSYNC LOW (inactive) */
2786                         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
2787                 }
2788                 saa7146_write(saa, MC1, MASK_20);       /* DMA3 off */
2789                 SAA7146_IER_DISABLE(saa, MASK_10);
2790                 SAA7146_ISR_CLEAR(saa, MASK_10);
2791                 msleep(50);
2792                 tasklet_kill(&av7110->vpe_tasklet);
2793                 saa7146_vfree_destroy_pgtable(saa->pci, av7110->grabbing, &av7110->pt);
2794         }
2795         av7110_exit_v4l(av7110);
2796 
2797         av7110_arm_sync(av7110);
2798 
2799         tasklet_kill(&av7110->debi_tasklet);
2800         tasklet_kill(&av7110->gpio_tasklet);
2801 
2802         dvb_unregister(av7110);
2803 
2804         SAA7146_IER_DISABLE(saa, MASK_19 | MASK_03);
2805         SAA7146_ISR_CLEAR(saa, MASK_19 | MASK_03);
2806 
2807         av7110_ca_exit(av7110);
2808         av7110_av_exit(av7110);
2809 
2810         vfree(av7110->iobuf);
2811         pci_free_consistent(saa->pci, 8192, av7110->debi_virt,
2812                             av7110->debi_bus);
2813 
2814         i2c_del_adapter(&av7110->i2c_adap);
2815 
2816         dvb_unregister_adapter (&av7110->dvb_adapter);
2817 
2818         av7110_num--;
2819 
2820         put_firmware(av7110);
2821 
2822         kfree(av7110);
2823 
2824         saa->ext_priv = NULL;
2825 
2826         return 0;
2827 }
2828 
2829 
2830 static void av7110_irq(struct saa7146_dev* dev, u32 *isr)
2831 {
2832         struct av7110 *av7110 = dev->ext_priv;
2833 
2834         //print_time("av7110_irq");
2835 
2836         /* Note: Don't try to handle the DEBI error irq (MASK_18), in
2837          * intel mode the timeout is asserted all the time...
2838          */
2839 
2840         if (*isr & MASK_19) {
2841                 //printk("av7110_irq: DEBI\n");
2842                 /* Note 1: The DEBI irq is level triggered: We must enable it
2843                  * only after we started a DMA xfer, and disable it here
2844                  * immediately, or it will be signalled all the time while
2845                  * DEBI is idle.
2846                  * Note 2: You would think that an irq which is masked is
2847                  * not signalled by the hardware. Not so for the SAA7146:
2848                  * An irq is signalled as long as the corresponding bit
2849                  * in the ISR is set, and disabling irqs just prevents the
2850                  * hardware from setting the ISR bit. This means a) that we
2851                  * must clear the ISR *after* disabling the irq (which is why
2852                  * we must do it here even though saa7146_core did it already),
2853                  * and b) that if we were to disable an edge triggered irq
2854                  * (like the gpio irqs sadly are) temporarily we would likely
2855                  * loose some. This sucks :-(
2856                  */
2857                 SAA7146_IER_DISABLE(av7110->dev, MASK_19);
2858                 SAA7146_ISR_CLEAR(av7110->dev, MASK_19);
2859                 tasklet_schedule(&av7110->debi_tasklet);
2860         }
2861 
2862         if (*isr & MASK_03) {
2863                 //printk("av7110_irq: GPIO\n");
2864                 tasklet_schedule(&av7110->gpio_tasklet);
2865         }
2866 
2867         if (*isr & MASK_10)
2868                 tasklet_schedule(&av7110->vpe_tasklet);
2869 }
2870 
2871 
2872 static struct saa7146_extension av7110_extension_driver;
2873 
2874 #define MAKE_AV7110_INFO(x_var,x_name) \
2875 static struct saa7146_pci_extension_data x_var = { \
2876         .ext_priv = x_name, \
2877         .ext = &av7110_extension_driver }
2878 
2879 MAKE_AV7110_INFO(tts_1_X_fsc,"Technotrend/Hauppauge WinTV DVB-S rev1.X or Fujitsu Siemens DVB-C");
2880 MAKE_AV7110_INFO(ttt_1_X,    "Technotrend/Hauppauge WinTV DVB-T rev1.X");
2881 MAKE_AV7110_INFO(ttc_1_X,    "Technotrend/Hauppauge WinTV Nexus-CA rev1.X");
2882 MAKE_AV7110_INFO(ttc_2_X,    "Technotrend/Hauppauge WinTV DVB-C rev2.X");
2883 MAKE_AV7110_INFO(tts_2_X,    "Technotrend/Hauppauge WinTV Nexus-S rev2.X");
2884 MAKE_AV7110_INFO(tts_2_3,    "Technotrend/Hauppauge WinTV Nexus-S rev2.3");
2885 MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
2886 MAKE_AV7110_INFO(ttt,        "Technotrend/Hauppauge DVB-T");
2887 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
2888 MAKE_AV7110_INFO(fss,        "Fujitsu Siemens DVB-S rev1.6");
2889 MAKE_AV7110_INFO(gxs_1_3,    "Galaxis DVB-S rev1.3");
2890 
2891 static struct pci_device_id pci_tbl[] = {
2892         MAKE_EXTENSION_PCI(fsc,         0x110a, 0x0000),
2893         MAKE_EXTENSION_PCI(tts_1_X_fsc, 0x13c2, 0x0000),
2894         MAKE_EXTENSION_PCI(ttt_1_X,     0x13c2, 0x0001),
2895         MAKE_EXTENSION_PCI(ttc_2_X,     0x13c2, 0x0002),
2896         MAKE_EXTENSION_PCI(tts_2_X,     0x13c2, 0x0003),
2897         MAKE_EXTENSION_PCI(gxs_1_3,     0x13c2, 0x0004),
2898         MAKE_EXTENSION_PCI(fss,         0x13c2, 0x0006),
2899         MAKE_EXTENSION_PCI(ttt,         0x13c2, 0x0008),
2900         MAKE_EXTENSION_PCI(ttc_1_X,     0x13c2, 0x000a),
2901         MAKE_EXTENSION_PCI(tts_2_3,     0x13c2, 0x000e),
2902         MAKE_EXTENSION_PCI(tts_1_3se,   0x13c2, 0x1002),
2903 
2904 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
2905 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
2906 
2907         {
2908                 .vendor    = 0,
2909         }
2910 };
2911 
2912 MODULE_DEVICE_TABLE(pci, pci_tbl);
2913 
2914 
2915 static struct saa7146_extension av7110_extension_driver = {
2916         .name           = "av7110",
2917         .flags          = SAA7146_USE_I2C_IRQ,
2918 
2919         .module         = THIS_MODULE,
2920         .pci_tbl        = &pci_tbl[0],
2921         .attach         = av7110_attach,
2922         .detach         = av7110_detach,
2923 
2924         .irq_mask       = MASK_19 | MASK_03 | MASK_10,
2925         .irq_func       = av7110_irq,
2926 };
2927 
2928 
2929 static int __init av7110_init(void)
2930 {
2931         int retval;
2932         retval = saa7146_register_extension(&av7110_extension_driver);
2933         return retval;
2934 }
2935 
2936 
2937 static void __exit av7110_exit(void)
2938 {
2939         saa7146_unregister_extension(&av7110_extension_driver);
2940 }
2941 
2942 module_init(av7110_init);
2943 module_exit(av7110_exit);
2944 
2945 MODULE_DESCRIPTION("driver for the SAA7146 based AV110 PCI DVB cards by "
2946                    "Siemens, Technotrend, Hauppauge");
2947 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, others");
2948 MODULE_LICENSE("GPL");
2949 

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