Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jbarnes...
[linux-2.6] / drivers / media / dvb / ttpci / budget-ci.c
1 /*
2  * budget-ci.c: driver for the SAA7146 based Budget DVB cards
3  *
4  * Compiled from various sources by Michael Hunold <michael@mihu.de>
5  *
6  *     msp430 IR support contributed by Jack Thomasson <jkt@Helius.COM>
7  *     partially based on the Siemens DVB driver by Ralph+Marcus Metzler
8  *
9  * CI interface support (c) 2004 Andrew de Quincey <adq_dvb@lidskialf.net>
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/dvb/
30  */
31
32 #include <linux/module.h>
33 #include <linux/errno.h>
34 #include <linux/slab.h>
35 #include <linux/interrupt.h>
36 #include <linux/input.h>
37 #include <linux/spinlock.h>
38 #include <media/ir-common.h>
39
40 #include "budget.h"
41
42 #include "dvb_ca_en50221.h"
43 #include "stv0299.h"
44 #include "stv0297.h"
45 #include "tda1004x.h"
46 #include "lnbp21.h"
47 #include "bsbe1.h"
48 #include "bsru6.h"
49
50 /*
51  * Regarding DEBIADDR_IR:
52  * Some CI modules hang if random addresses are read.
53  * Using address 0x4000 for the IR read means that we
54  * use the same address as for CI version, which should
55  * be a safe default.
56  */
57 #define DEBIADDR_IR             0x4000
58 #define DEBIADDR_CICONTROL      0x0000
59 #define DEBIADDR_CIVERSION      0x4000
60 #define DEBIADDR_IO             0x1000
61 #define DEBIADDR_ATTR           0x3000
62
63 #define CICONTROL_RESET         0x01
64 #define CICONTROL_ENABLETS      0x02
65 #define CICONTROL_CAMDETECT     0x08
66
67 #define DEBICICTL               0x00420000
68 #define DEBICICAM               0x02420000
69
70 #define SLOTSTATUS_NONE         1
71 #define SLOTSTATUS_PRESENT      2
72 #define SLOTSTATUS_RESET        4
73 #define SLOTSTATUS_READY        8
74 #define SLOTSTATUS_OCCUPIED     (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
75
76 /*
77  * Milliseconds during which a key is regarded as pressed.
78  * If an identical command arrives within this time, the timer will start over.
79  */
80 #define IR_KEYPRESS_TIMEOUT     250
81
82 /* RC5 device wildcard */
83 #define IR_DEVICE_ANY           255
84
85 static int rc5_device = -1;
86 module_param(rc5_device, int, 0644);
87 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
88
89 static int ir_debug;
90 module_param(ir_debug, int, 0644);
91 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
92
93 struct budget_ci_ir {
94         struct input_dev *dev;
95         struct tasklet_struct msp430_irq_tasklet;
96         struct timer_list timer_keyup;
97         char name[72]; /* 40 + 32 for (struct saa7146_dev).name */
98         char phys[32];
99         struct ir_input_state state;
100         int rc5_device;
101         u32 last_raw;
102         u32 ir_key;
103         bool have_command;
104 };
105
106 struct budget_ci {
107         struct budget budget;
108         struct tasklet_struct ciintf_irq_tasklet;
109         int slot_status;
110         int ci_irq;
111         struct dvb_ca_en50221 ca;
112         struct budget_ci_ir ir;
113         u8 tuner_pll_address; /* used for philips_tdm1316l configs */
114 };
115
116 static void msp430_ir_keyup(unsigned long data)
117 {
118         struct budget_ci_ir *ir = (struct budget_ci_ir *) data;
119         ir_input_nokey(ir->dev, &ir->state);
120 }
121
122 static void msp430_ir_interrupt(unsigned long data)
123 {
124         struct budget_ci *budget_ci = (struct budget_ci *) data;
125         struct input_dev *dev = budget_ci->ir.dev;
126         u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
127         u32 raw;
128
129         /*
130          * The msp430 chip can generate two different bytes, command and device
131          *
132          * type1: X1CCCCCC, C = command bits (0 - 63)
133          * type2: X0TDDDDD, D = device bits (0 - 31), T = RC5 toggle bit
134          *
135          * Each signal from the remote control can generate one or more command
136          * bytes and one or more device bytes. For the repeated bytes, the
137          * highest bit (X) is set. The first command byte is always generated
138          * before the first device byte. Other than that, no specific order
139          * seems to apply. To make life interesting, bytes can also be lost.
140          *
141          * Only when we have a command and device byte, a keypress is
142          * generated.
143          */
144
145         if (ir_debug)
146                 printk("budget_ci: received byte 0x%02x\n", command);
147
148         /* Remove repeat bit, we use every command */
149         command = command & 0x7f;
150
151         /* Is this a RC5 command byte? */
152         if (command & 0x40) {
153                 budget_ci->ir.have_command = true;
154                 budget_ci->ir.ir_key = command & 0x3f;
155                 return;
156         }
157
158         /* It's a RC5 device byte */
159         if (!budget_ci->ir.have_command)
160                 return;
161         budget_ci->ir.have_command = false;
162
163         if (budget_ci->ir.rc5_device != IR_DEVICE_ANY &&
164             budget_ci->ir.rc5_device != (command & 0x1f))
165                 return;
166
167         /* Is this a repeated key sequence? (same device, command, toggle) */
168         raw = budget_ci->ir.ir_key | (command << 8);
169         if (budget_ci->ir.last_raw != raw || !timer_pending(&budget_ci->ir.timer_keyup)) {
170                 ir_input_nokey(dev, &budget_ci->ir.state);
171                 ir_input_keydown(dev, &budget_ci->ir.state,
172                                  budget_ci->ir.ir_key, raw);
173                 budget_ci->ir.last_raw = raw;
174         }
175
176         mod_timer(&budget_ci->ir.timer_keyup, jiffies + msecs_to_jiffies(IR_KEYPRESS_TIMEOUT));
177 }
178
179 static int msp430_ir_init(struct budget_ci *budget_ci)
180 {
181         struct saa7146_dev *saa = budget_ci->budget.dev;
182         struct input_dev *input_dev = budget_ci->ir.dev;
183         int error;
184
185         budget_ci->ir.dev = input_dev = input_allocate_device();
186         if (!input_dev) {
187                 printk(KERN_ERR "budget_ci: IR interface initialisation failed\n");
188                 error = -ENOMEM;
189                 goto out1;
190         }
191
192         snprintf(budget_ci->ir.name, sizeof(budget_ci->ir.name),
193                  "Budget-CI dvb ir receiver %s", saa->name);
194         snprintf(budget_ci->ir.phys, sizeof(budget_ci->ir.phys),
195                  "pci-%s/ir0", pci_name(saa->pci));
196
197         input_dev->name = budget_ci->ir.name;
198
199         input_dev->phys = budget_ci->ir.phys;
200         input_dev->id.bustype = BUS_PCI;
201         input_dev->id.version = 1;
202         if (saa->pci->subsystem_vendor) {
203                 input_dev->id.vendor = saa->pci->subsystem_vendor;
204                 input_dev->id.product = saa->pci->subsystem_device;
205         } else {
206                 input_dev->id.vendor = saa->pci->vendor;
207                 input_dev->id.product = saa->pci->device;
208         }
209         input_dev->dev.parent = &saa->pci->dev;
210
211         /* Select keymap and address */
212         switch (budget_ci->budget.dev->pci->subsystem_device) {
213         case 0x100c:
214         case 0x100f:
215         case 0x1011:
216         case 0x1012:
217                 /* The hauppauge keymap is a superset of these remotes */
218                 ir_input_init(input_dev, &budget_ci->ir.state,
219                               IR_TYPE_RC5, ir_codes_hauppauge_new);
220
221                 if (rc5_device < 0)
222                         budget_ci->ir.rc5_device = 0x1f;
223                 else
224                         budget_ci->ir.rc5_device = rc5_device;
225                 break;
226         case 0x1010:
227         case 0x1017:
228                 /* for the Technotrend 1500 bundled remote */
229                 ir_input_init(input_dev, &budget_ci->ir.state,
230                               IR_TYPE_RC5, ir_codes_tt_1500);
231
232                 if (rc5_device < 0)
233                         budget_ci->ir.rc5_device = IR_DEVICE_ANY;
234                 else
235                         budget_ci->ir.rc5_device = rc5_device;
236                 break;
237         default:
238                 /* unknown remote */
239                 ir_input_init(input_dev, &budget_ci->ir.state,
240                               IR_TYPE_RC5, ir_codes_budget_ci_old);
241
242                 if (rc5_device < 0)
243                         budget_ci->ir.rc5_device = IR_DEVICE_ANY;
244                 else
245                         budget_ci->ir.rc5_device = rc5_device;
246                 break;
247         }
248
249         /* initialise the key-up timeout handler */
250         init_timer(&budget_ci->ir.timer_keyup);
251         budget_ci->ir.timer_keyup.function = msp430_ir_keyup;
252         budget_ci->ir.timer_keyup.data = (unsigned long) &budget_ci->ir;
253         budget_ci->ir.last_raw = 0xffff; /* An impossible value */
254         error = input_register_device(input_dev);
255         if (error) {
256                 printk(KERN_ERR "budget_ci: could not init driver for IR device (code %d)\n", error);
257                 goto out2;
258         }
259
260         /* note: these must be after input_register_device */
261         input_dev->rep[REP_DELAY] = 400;
262         input_dev->rep[REP_PERIOD] = 250;
263
264         tasklet_init(&budget_ci->ir.msp430_irq_tasklet, msp430_ir_interrupt,
265                      (unsigned long) budget_ci);
266
267         SAA7146_IER_ENABLE(saa, MASK_06);
268         saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI);
269
270         return 0;
271
272 out2:
273         input_free_device(input_dev);
274 out1:
275         return error;
276 }
277
278 static void msp430_ir_deinit(struct budget_ci *budget_ci)
279 {
280         struct saa7146_dev *saa = budget_ci->budget.dev;
281         struct input_dev *dev = budget_ci->ir.dev;
282
283         SAA7146_IER_DISABLE(saa, MASK_06);
284         saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
285         tasklet_kill(&budget_ci->ir.msp430_irq_tasklet);
286
287         del_timer_sync(&dev->timer);
288         ir_input_nokey(dev, &budget_ci->ir.state);
289
290         input_unregister_device(dev);
291 }
292
293 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
294 {
295         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
296
297         if (slot != 0)
298                 return -EINVAL;
299
300         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
301                                      DEBIADDR_ATTR | (address & 0xfff), 1, 1, 0);
302 }
303
304 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
305 {
306         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
307
308         if (slot != 0)
309                 return -EINVAL;
310
311         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
312                                       DEBIADDR_ATTR | (address & 0xfff), 1, value, 1, 0);
313 }
314
315 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
316 {
317         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
318
319         if (slot != 0)
320                 return -EINVAL;
321
322         return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
323                                      DEBIADDR_IO | (address & 3), 1, 1, 0);
324 }
325
326 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
327 {
328         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
329
330         if (slot != 0)
331                 return -EINVAL;
332
333         return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
334                                       DEBIADDR_IO | (address & 3), 1, value, 1, 0);
335 }
336
337 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
338 {
339         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
340         struct saa7146_dev *saa = budget_ci->budget.dev;
341
342         if (slot != 0)
343                 return -EINVAL;
344
345         if (budget_ci->ci_irq) {
346                 // trigger on RISING edge during reset so we know when READY is re-asserted
347                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
348         }
349         budget_ci->slot_status = SLOTSTATUS_RESET;
350         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
351         msleep(1);
352         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
353                                CICONTROL_RESET, 1, 0);
354
355         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
356         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
357         return 0;
358 }
359
360 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
361 {
362         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
363         struct saa7146_dev *saa = budget_ci->budget.dev;
364
365         if (slot != 0)
366                 return -EINVAL;
367
368         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
369         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
370         return 0;
371 }
372
373 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
374 {
375         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
376         struct saa7146_dev *saa = budget_ci->budget.dev;
377         int tmp;
378
379         if (slot != 0)
380                 return -EINVAL;
381
382         saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
383
384         tmp = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
385         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
386                                tmp | CICONTROL_ENABLETS, 1, 0);
387
388         ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
389         return 0;
390 }
391
392 static void ciintf_interrupt(unsigned long data)
393 {
394         struct budget_ci *budget_ci = (struct budget_ci *) data;
395         struct saa7146_dev *saa = budget_ci->budget.dev;
396         unsigned int flags;
397
398         // ensure we don't get spurious IRQs during initialisation
399         if (!budget_ci->budget.ci_present)
400                 return;
401
402         // read the CAM status
403         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
404         if (flags & CICONTROL_CAMDETECT) {
405
406                 // GPIO should be set to trigger on falling edge if a CAM is present
407                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
408
409                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
410                         // CAM insertion IRQ
411                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
412                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
413                                                      DVB_CA_EN50221_CAMCHANGE_INSERTED);
414
415                 } else if (budget_ci->slot_status & SLOTSTATUS_RESET) {
416                         // CAM ready (reset completed)
417                         budget_ci->slot_status = SLOTSTATUS_READY;
418                         dvb_ca_en50221_camready_irq(&budget_ci->ca, 0);
419
420                 } else if (budget_ci->slot_status & SLOTSTATUS_READY) {
421                         // FR/DA IRQ
422                         dvb_ca_en50221_frda_irq(&budget_ci->ca, 0);
423                 }
424         } else {
425
426                 // trigger on rising edge if a CAM is not present - when a CAM is inserted, we
427                 // only want to get the IRQ when it sets READY. If we trigger on the falling edge,
428                 // the CAM might not actually be ready yet.
429                 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
430
431                 // generate a CAM removal IRQ if we haven't already
432                 if (budget_ci->slot_status & SLOTSTATUS_OCCUPIED) {
433                         // CAM removal IRQ
434                         budget_ci->slot_status = SLOTSTATUS_NONE;
435                         dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
436                                                      DVB_CA_EN50221_CAMCHANGE_REMOVED);
437                 }
438         }
439 }
440
441 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
442 {
443         struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
444         unsigned int flags;
445
446         // ensure we don't get spurious IRQs during initialisation
447         if (!budget_ci->budget.ci_present)
448                 return -EINVAL;
449
450         // read the CAM status
451         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
452         if (flags & CICONTROL_CAMDETECT) {
453                 // mark it as present if it wasn't before
454                 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
455                         budget_ci->slot_status = SLOTSTATUS_PRESENT;
456                 }
457
458                 // during a RESET, we check if we can read from IO memory to see when CAM is ready
459                 if (budget_ci->slot_status & SLOTSTATUS_RESET) {
460                         if (ciintf_read_attribute_mem(ca, slot, 0) == 0x1d) {
461                                 budget_ci->slot_status = SLOTSTATUS_READY;
462                         }
463                 }
464         } else {
465                 budget_ci->slot_status = SLOTSTATUS_NONE;
466         }
467
468         if (budget_ci->slot_status != SLOTSTATUS_NONE) {
469                 if (budget_ci->slot_status & SLOTSTATUS_READY) {
470                         return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
471                 }
472                 return DVB_CA_EN50221_POLL_CAM_PRESENT;
473         }
474
475         return 0;
476 }
477
478 static int ciintf_init(struct budget_ci *budget_ci)
479 {
480         struct saa7146_dev *saa = budget_ci->budget.dev;
481         int flags;
482         int result;
483         int ci_version;
484         int ca_flags;
485
486         memset(&budget_ci->ca, 0, sizeof(struct dvb_ca_en50221));
487
488         // enable DEBI pins
489         saa7146_write(saa, MC1, MASK_27 | MASK_11);
490
491         // test if it is there
492         ci_version = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CIVERSION, 1, 1, 0);
493         if ((ci_version & 0xa0) != 0xa0) {
494                 result = -ENODEV;
495                 goto error;
496         }
497
498         // determine whether a CAM is present or not
499         flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
500         budget_ci->slot_status = SLOTSTATUS_NONE;
501         if (flags & CICONTROL_CAMDETECT)
502                 budget_ci->slot_status = SLOTSTATUS_PRESENT;
503
504         // version 0xa2 of the CI firmware doesn't generate interrupts
505         if (ci_version == 0xa2) {
506                 ca_flags = 0;
507                 budget_ci->ci_irq = 0;
508         } else {
509                 ca_flags = DVB_CA_EN50221_FLAG_IRQ_CAMCHANGE |
510                                 DVB_CA_EN50221_FLAG_IRQ_FR |
511                                 DVB_CA_EN50221_FLAG_IRQ_DA;
512                 budget_ci->ci_irq = 1;
513         }
514
515         // register CI interface
516         budget_ci->ca.owner = THIS_MODULE;
517         budget_ci->ca.read_attribute_mem = ciintf_read_attribute_mem;
518         budget_ci->ca.write_attribute_mem = ciintf_write_attribute_mem;
519         budget_ci->ca.read_cam_control = ciintf_read_cam_control;
520         budget_ci->ca.write_cam_control = ciintf_write_cam_control;
521         budget_ci->ca.slot_reset = ciintf_slot_reset;
522         budget_ci->ca.slot_shutdown = ciintf_slot_shutdown;
523         budget_ci->ca.slot_ts_enable = ciintf_slot_ts_enable;
524         budget_ci->ca.poll_slot_status = ciintf_poll_slot_status;
525         budget_ci->ca.data = budget_ci;
526         if ((result = dvb_ca_en50221_init(&budget_ci->budget.dvb_adapter,
527                                           &budget_ci->ca,
528                                           ca_flags, 1)) != 0) {
529                 printk("budget_ci: CI interface detected, but initialisation failed.\n");
530                 goto error;
531         }
532
533         // Setup CI slot IRQ
534         if (budget_ci->ci_irq) {
535                 tasklet_init(&budget_ci->ciintf_irq_tasklet, ciintf_interrupt, (unsigned long) budget_ci);
536                 if (budget_ci->slot_status != SLOTSTATUS_NONE) {
537                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
538                 } else {
539                         saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
540                 }
541                 SAA7146_IER_ENABLE(saa, MASK_03);
542         }
543
544         // enable interface
545         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
546                                CICONTROL_RESET, 1, 0);
547
548         // success!
549         printk("budget_ci: CI interface initialised\n");
550         budget_ci->budget.ci_present = 1;
551
552         // forge a fake CI IRQ so the CAM state is setup correctly
553         if (budget_ci->ci_irq) {
554                 flags = DVB_CA_EN50221_CAMCHANGE_REMOVED;
555                 if (budget_ci->slot_status != SLOTSTATUS_NONE)
556                         flags = DVB_CA_EN50221_CAMCHANGE_INSERTED;
557                 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, flags);
558         }
559
560         return 0;
561
562 error:
563         saa7146_write(saa, MC1, MASK_27);
564         return result;
565 }
566
567 static void ciintf_deinit(struct budget_ci *budget_ci)
568 {
569         struct saa7146_dev *saa = budget_ci->budget.dev;
570
571         // disable CI interrupts
572         if (budget_ci->ci_irq) {
573                 SAA7146_IER_DISABLE(saa, MASK_03);
574                 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
575                 tasklet_kill(&budget_ci->ciintf_irq_tasklet);
576         }
577
578         // reset interface
579         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
580         msleep(1);
581         ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
582                                CICONTROL_RESET, 1, 0);
583
584         // disable TS data stream to CI interface
585         saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
586
587         // release the CA device
588         dvb_ca_en50221_release(&budget_ci->ca);
589
590         // disable DEBI pins
591         saa7146_write(saa, MC1, MASK_27);
592 }
593
594 static void budget_ci_irq(struct saa7146_dev *dev, u32 * isr)
595 {
596         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
597
598         dprintk(8, "dev: %p, budget_ci: %p\n", dev, budget_ci);
599
600         if (*isr & MASK_06)
601                 tasklet_schedule(&budget_ci->ir.msp430_irq_tasklet);
602
603         if (*isr & MASK_10)
604                 ttpci_budget_irq10_handler(dev, isr);
605
606         if ((*isr & MASK_03) && (budget_ci->budget.ci_present) && (budget_ci->ci_irq))
607                 tasklet_schedule(&budget_ci->ciintf_irq_tasklet);
608 }
609
610 static u8 philips_su1278_tt_inittab[] = {
611         0x01, 0x0f,
612         0x02, 0x30,
613         0x03, 0x00,
614         0x04, 0x5b,
615         0x05, 0x85,
616         0x06, 0x02,
617         0x07, 0x00,
618         0x08, 0x02,
619         0x09, 0x00,
620         0x0C, 0x01,
621         0x0D, 0x81,
622         0x0E, 0x44,
623         0x0f, 0x14,
624         0x10, 0x3c,
625         0x11, 0x84,
626         0x12, 0xda,
627         0x13, 0x97,
628         0x14, 0x95,
629         0x15, 0xc9,
630         0x16, 0x19,
631         0x17, 0x8c,
632         0x18, 0x59,
633         0x19, 0xf8,
634         0x1a, 0xfe,
635         0x1c, 0x7f,
636         0x1d, 0x00,
637         0x1e, 0x00,
638         0x1f, 0x50,
639         0x20, 0x00,
640         0x21, 0x00,
641         0x22, 0x00,
642         0x23, 0x00,
643         0x28, 0x00,
644         0x29, 0x28,
645         0x2a, 0x14,
646         0x2b, 0x0f,
647         0x2c, 0x09,
648         0x2d, 0x09,
649         0x31, 0x1f,
650         0x32, 0x19,
651         0x33, 0xfc,
652         0x34, 0x93,
653         0xff, 0xff
654 };
655
656 static int philips_su1278_tt_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
657 {
658         stv0299_writereg(fe, 0x0e, 0x44);
659         if (srate >= 10000000) {
660                 stv0299_writereg(fe, 0x13, 0x97);
661                 stv0299_writereg(fe, 0x14, 0x95);
662                 stv0299_writereg(fe, 0x15, 0xc9);
663                 stv0299_writereg(fe, 0x17, 0x8c);
664                 stv0299_writereg(fe, 0x1a, 0xfe);
665                 stv0299_writereg(fe, 0x1c, 0x7f);
666                 stv0299_writereg(fe, 0x2d, 0x09);
667         } else {
668                 stv0299_writereg(fe, 0x13, 0x99);
669                 stv0299_writereg(fe, 0x14, 0x8d);
670                 stv0299_writereg(fe, 0x15, 0xce);
671                 stv0299_writereg(fe, 0x17, 0x43);
672                 stv0299_writereg(fe, 0x1a, 0x1d);
673                 stv0299_writereg(fe, 0x1c, 0x12);
674                 stv0299_writereg(fe, 0x2d, 0x05);
675         }
676         stv0299_writereg(fe, 0x0e, 0x23);
677         stv0299_writereg(fe, 0x0f, 0x94);
678         stv0299_writereg(fe, 0x10, 0x39);
679         stv0299_writereg(fe, 0x15, 0xc9);
680
681         stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
682         stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
683         stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
684
685         return 0;
686 }
687
688 static int philips_su1278_tt_tuner_set_params(struct dvb_frontend *fe,
689                                            struct dvb_frontend_parameters *params)
690 {
691         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
692         u32 div;
693         u8 buf[4];
694         struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
695
696         if ((params->frequency < 950000) || (params->frequency > 2150000))
697                 return -EINVAL;
698
699         div = (params->frequency + (500 - 1)) / 500;    // round correctly
700         buf[0] = (div >> 8) & 0x7f;
701         buf[1] = div & 0xff;
702         buf[2] = 0x80 | ((div & 0x18000) >> 10) | 2;
703         buf[3] = 0x20;
704
705         if (params->u.qpsk.symbol_rate < 4000000)
706                 buf[3] |= 1;
707
708         if (params->frequency < 1250000)
709                 buf[3] |= 0;
710         else if (params->frequency < 1550000)
711                 buf[3] |= 0x40;
712         else if (params->frequency < 2050000)
713                 buf[3] |= 0x80;
714         else if (params->frequency < 2150000)
715                 buf[3] |= 0xC0;
716
717         if (fe->ops.i2c_gate_ctrl)
718                 fe->ops.i2c_gate_ctrl(fe, 1);
719         if (i2c_transfer(&budget_ci->budget.i2c_adap, &msg, 1) != 1)
720                 return -EIO;
721         return 0;
722 }
723
724 static struct stv0299_config philips_su1278_tt_config = {
725
726         .demod_address = 0x68,
727         .inittab = philips_su1278_tt_inittab,
728         .mclk = 64000000UL,
729         .invert = 0,
730         .skip_reinit = 1,
731         .lock_output = STV0299_LOCKOUTPUT_1,
732         .volt13_op0_op1 = STV0299_VOLT13_OP1,
733         .min_delay_ms = 50,
734         .set_symbol_rate = philips_su1278_tt_set_symbol_rate,
735 };
736
737
738
739 static int philips_tdm1316l_tuner_init(struct dvb_frontend *fe)
740 {
741         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
742         static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
743         static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
744         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = td1316_init,.len =
745                         sizeof(td1316_init) };
746
747         // setup PLL configuration
748         if (fe->ops.i2c_gate_ctrl)
749                 fe->ops.i2c_gate_ctrl(fe, 1);
750         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
751                 return -EIO;
752         msleep(1);
753
754         // disable the mc44BC374c (do not check for errors)
755         tuner_msg.addr = 0x65;
756         tuner_msg.buf = disable_mc44BC374c;
757         tuner_msg.len = sizeof(disable_mc44BC374c);
758         if (fe->ops.i2c_gate_ctrl)
759                 fe->ops.i2c_gate_ctrl(fe, 1);
760         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) {
761                 if (fe->ops.i2c_gate_ctrl)
762                         fe->ops.i2c_gate_ctrl(fe, 1);
763                 i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1);
764         }
765
766         return 0;
767 }
768
769 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
770 {
771         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
772         u8 tuner_buf[4];
773         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = tuner_buf,.len = sizeof(tuner_buf) };
774         int tuner_frequency = 0;
775         u8 band, cp, filter;
776
777         // determine charge pump
778         tuner_frequency = params->frequency + 36130000;
779         if (tuner_frequency < 87000000)
780                 return -EINVAL;
781         else if (tuner_frequency < 130000000)
782                 cp = 3;
783         else if (tuner_frequency < 160000000)
784                 cp = 5;
785         else if (tuner_frequency < 200000000)
786                 cp = 6;
787         else if (tuner_frequency < 290000000)
788                 cp = 3;
789         else if (tuner_frequency < 420000000)
790                 cp = 5;
791         else if (tuner_frequency < 480000000)
792                 cp = 6;
793         else if (tuner_frequency < 620000000)
794                 cp = 3;
795         else if (tuner_frequency < 830000000)
796                 cp = 5;
797         else if (tuner_frequency < 895000000)
798                 cp = 7;
799         else
800                 return -EINVAL;
801
802         // determine band
803         if (params->frequency < 49000000)
804                 return -EINVAL;
805         else if (params->frequency < 159000000)
806                 band = 1;
807         else if (params->frequency < 444000000)
808                 band = 2;
809         else if (params->frequency < 861000000)
810                 band = 4;
811         else
812                 return -EINVAL;
813
814         // setup PLL filter and TDA9889
815         switch (params->u.ofdm.bandwidth) {
816         case BANDWIDTH_6_MHZ:
817                 tda1004x_writereg(fe, 0x0C, 0x14);
818                 filter = 0;
819                 break;
820
821         case BANDWIDTH_7_MHZ:
822                 tda1004x_writereg(fe, 0x0C, 0x80);
823                 filter = 0;
824                 break;
825
826         case BANDWIDTH_8_MHZ:
827                 tda1004x_writereg(fe, 0x0C, 0x14);
828                 filter = 1;
829                 break;
830
831         default:
832                 return -EINVAL;
833         }
834
835         // calculate divisor
836         // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
837         tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
838
839         // setup tuner buffer
840         tuner_buf[0] = tuner_frequency >> 8;
841         tuner_buf[1] = tuner_frequency & 0xff;
842         tuner_buf[2] = 0xca;
843         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
844
845         if (fe->ops.i2c_gate_ctrl)
846                 fe->ops.i2c_gate_ctrl(fe, 1);
847         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
848                 return -EIO;
849
850         msleep(1);
851         return 0;
852 }
853
854 static int philips_tdm1316l_request_firmware(struct dvb_frontend *fe,
855                                              const struct firmware **fw, char *name)
856 {
857         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
858
859         return request_firmware(fw, name, &budget_ci->budget.dev->pci->dev);
860 }
861
862 static struct tda1004x_config philips_tdm1316l_config = {
863
864         .demod_address = 0x8,
865         .invert = 0,
866         .invert_oclk = 0,
867         .xtal_freq = TDA10046_XTAL_4M,
868         .agc_config = TDA10046_AGC_DEFAULT,
869         .if_freq = TDA10046_FREQ_3617,
870         .request_firmware = philips_tdm1316l_request_firmware,
871 };
872
873 static struct tda1004x_config philips_tdm1316l_config_invert = {
874
875         .demod_address = 0x8,
876         .invert = 1,
877         .invert_oclk = 0,
878         .xtal_freq = TDA10046_XTAL_4M,
879         .agc_config = TDA10046_AGC_DEFAULT,
880         .if_freq = TDA10046_FREQ_3617,
881         .request_firmware = philips_tdm1316l_request_firmware,
882 };
883
884 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
885 {
886         struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
887         u8 tuner_buf[5];
888         struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,
889                                     .flags = 0,
890                                     .buf = tuner_buf,
891                                     .len = sizeof(tuner_buf) };
892         int tuner_frequency = 0;
893         u8 band, cp, filter;
894
895         // determine charge pump
896         tuner_frequency = params->frequency + 36125000;
897         if (tuner_frequency < 87000000)
898                 return -EINVAL;
899         else if (tuner_frequency < 130000000) {
900                 cp = 3;
901                 band = 1;
902         } else if (tuner_frequency < 160000000) {
903                 cp = 5;
904                 band = 1;
905         } else if (tuner_frequency < 200000000) {
906                 cp = 6;
907                 band = 1;
908         } else if (tuner_frequency < 290000000) {
909                 cp = 3;
910                 band = 2;
911         } else if (tuner_frequency < 420000000) {
912                 cp = 5;
913                 band = 2;
914         } else if (tuner_frequency < 480000000) {
915                 cp = 6;
916                 band = 2;
917         } else if (tuner_frequency < 620000000) {
918                 cp = 3;
919                 band = 4;
920         } else if (tuner_frequency < 830000000) {
921                 cp = 5;
922                 band = 4;
923         } else if (tuner_frequency < 895000000) {
924                 cp = 7;
925                 band = 4;
926         } else
927                 return -EINVAL;
928
929         // assume PLL filter should always be 8MHz for the moment.
930         filter = 1;
931
932         // calculate divisor
933         tuner_frequency = (params->frequency + 36125000 + (62500/2)) / 62500;
934
935         // setup tuner buffer
936         tuner_buf[0] = tuner_frequency >> 8;
937         tuner_buf[1] = tuner_frequency & 0xff;
938         tuner_buf[2] = 0xc8;
939         tuner_buf[3] = (cp << 5) | (filter << 3) | band;
940         tuner_buf[4] = 0x80;
941
942         if (fe->ops.i2c_gate_ctrl)
943                 fe->ops.i2c_gate_ctrl(fe, 1);
944         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
945                 return -EIO;
946
947         msleep(50);
948
949         if (fe->ops.i2c_gate_ctrl)
950                 fe->ops.i2c_gate_ctrl(fe, 1);
951         if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
952                 return -EIO;
953
954         msleep(1);
955
956         return 0;
957 }
958
959 static u8 dvbc_philips_tdm1316l_inittab[] = {
960         0x80, 0x01,
961         0x80, 0x00,
962         0x81, 0x01,
963         0x81, 0x00,
964         0x00, 0x09,
965         0x01, 0x69,
966         0x03, 0x00,
967         0x04, 0x00,
968         0x07, 0x00,
969         0x08, 0x00,
970         0x20, 0x00,
971         0x21, 0x40,
972         0x22, 0x00,
973         0x23, 0x00,
974         0x24, 0x40,
975         0x25, 0x88,
976         0x30, 0xff,
977         0x31, 0x00,
978         0x32, 0xff,
979         0x33, 0x00,
980         0x34, 0x50,
981         0x35, 0x7f,
982         0x36, 0x00,
983         0x37, 0x20,
984         0x38, 0x00,
985         0x40, 0x1c,
986         0x41, 0xff,
987         0x42, 0x29,
988         0x43, 0x20,
989         0x44, 0xff,
990         0x45, 0x00,
991         0x46, 0x00,
992         0x49, 0x04,
993         0x4a, 0x00,
994         0x4b, 0x7b,
995         0x52, 0x30,
996         0x55, 0xae,
997         0x56, 0x47,
998         0x57, 0xe1,
999         0x58, 0x3a,
1000         0x5a, 0x1e,
1001         0x5b, 0x34,
1002         0x60, 0x00,
1003         0x63, 0x00,
1004         0x64, 0x00,
1005         0x65, 0x00,
1006         0x66, 0x00,
1007         0x67, 0x00,
1008         0x68, 0x00,
1009         0x69, 0x00,
1010         0x6a, 0x02,
1011         0x6b, 0x00,
1012         0x70, 0xff,
1013         0x71, 0x00,
1014         0x72, 0x00,
1015         0x73, 0x00,
1016         0x74, 0x0c,
1017         0x80, 0x00,
1018         0x81, 0x00,
1019         0x82, 0x00,
1020         0x83, 0x00,
1021         0x84, 0x04,
1022         0x85, 0x80,
1023         0x86, 0x24,
1024         0x87, 0x78,
1025         0x88, 0x10,
1026         0x89, 0x00,
1027         0x90, 0x01,
1028         0x91, 0x01,
1029         0xa0, 0x04,
1030         0xa1, 0x00,
1031         0xa2, 0x00,
1032         0xb0, 0x91,
1033         0xb1, 0x0b,
1034         0xc0, 0x53,
1035         0xc1, 0x70,
1036         0xc2, 0x12,
1037         0xd0, 0x00,
1038         0xd1, 0x00,
1039         0xd2, 0x00,
1040         0xd3, 0x00,
1041         0xd4, 0x00,
1042         0xd5, 0x00,
1043         0xde, 0x00,
1044         0xdf, 0x00,
1045         0x61, 0x38,
1046         0x62, 0x0a,
1047         0x53, 0x13,
1048         0x59, 0x08,
1049         0xff, 0xff,
1050 };
1051
1052 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1053         .demod_address = 0x1c,
1054         .inittab = dvbc_philips_tdm1316l_inittab,
1055         .invert = 0,
1056         .stop_during_read = 1,
1057 };
1058
1059
1060
1061
1062 static void frontend_init(struct budget_ci *budget_ci)
1063 {
1064         switch (budget_ci->budget.dev->pci->subsystem_device) {
1065         case 0x100c:            // Hauppauge/TT Nova-CI budget (stv0299/ALPS BSRU6(tsa5059))
1066                 budget_ci->budget.dvb_frontend =
1067                         dvb_attach(stv0299_attach, &alps_bsru6_config, &budget_ci->budget.i2c_adap);
1068                 if (budget_ci->budget.dvb_frontend) {
1069                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
1070                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1071                         break;
1072                 }
1073                 break;
1074
1075         case 0x100f:            // Hauppauge/TT Nova-CI budget (stv0299b/Philips su1278(tsa5059))
1076                 budget_ci->budget.dvb_frontend =
1077                         dvb_attach(stv0299_attach, &philips_su1278_tt_config, &budget_ci->budget.i2c_adap);
1078                 if (budget_ci->budget.dvb_frontend) {
1079                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_su1278_tt_tuner_set_params;
1080                         break;
1081                 }
1082                 break;
1083
1084         case 0x1010:            // TT DVB-C CI budget (stv0297/Philips tdm1316l(tda6651tt))
1085                 budget_ci->tuner_pll_address = 0x61;
1086                 budget_ci->budget.dvb_frontend =
1087                         dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1088                 if (budget_ci->budget.dvb_frontend) {
1089                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1090                         break;
1091                 }
1092                 break;
1093
1094         case 0x1011:            // Hauppauge/TT Nova-T budget (tda10045/Philips tdm1316l(tda6651tt) + TDA9889)
1095                 budget_ci->tuner_pll_address = 0x63;
1096                 budget_ci->budget.dvb_frontend =
1097                         dvb_attach(tda10045_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1098                 if (budget_ci->budget.dvb_frontend) {
1099                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1100                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1101                         break;
1102                 }
1103                 break;
1104
1105         case 0x1012:            // TT DVB-T CI budget (tda10046/Philips tdm1316l(tda6651tt))
1106                 budget_ci->tuner_pll_address = 0x60;
1107                 budget_ci->budget.dvb_frontend =
1108                         dvb_attach(tda10046_attach, &philips_tdm1316l_config_invert, &budget_ci->budget.i2c_adap);
1109                 if (budget_ci->budget.dvb_frontend) {
1110                         budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1111                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1112                         break;
1113                 }
1114                 break;
1115
1116         case 0x1017:            // TT S-1500 PCI
1117                 budget_ci->budget.dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config, &budget_ci->budget.i2c_adap);
1118                 if (budget_ci->budget.dvb_frontend) {
1119                         budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
1120                         budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1121
1122                         budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
1123                         if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) {
1124                                 printk("%s: No LNBP21 found!\n", __func__);
1125                                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1126                                 budget_ci->budget.dvb_frontend = NULL;
1127                         }
1128                 }
1129
1130                 break;
1131         }
1132
1133         if (budget_ci->budget.dvb_frontend == NULL) {
1134                 printk("budget-ci: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
1135                        budget_ci->budget.dev->pci->vendor,
1136                        budget_ci->budget.dev->pci->device,
1137                        budget_ci->budget.dev->pci->subsystem_vendor,
1138                        budget_ci->budget.dev->pci->subsystem_device);
1139         } else {
1140                 if (dvb_register_frontend
1141                     (&budget_ci->budget.dvb_adapter, budget_ci->budget.dvb_frontend)) {
1142                         printk("budget-ci: Frontend registration failed!\n");
1143                         dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1144                         budget_ci->budget.dvb_frontend = NULL;
1145                 }
1146         }
1147 }
1148
1149 static int budget_ci_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1150 {
1151         struct budget_ci *budget_ci;
1152         int err;
1153
1154         budget_ci = kzalloc(sizeof(struct budget_ci), GFP_KERNEL);
1155         if (!budget_ci) {
1156                 err = -ENOMEM;
1157                 goto out1;
1158         }
1159
1160         dprintk(2, "budget_ci: %p\n", budget_ci);
1161
1162         dev->ext_priv = budget_ci;
1163
1164         err = ttpci_budget_init(&budget_ci->budget, dev, info, THIS_MODULE);
1165         if (err)
1166                 goto out2;
1167
1168         err = msp430_ir_init(budget_ci);
1169         if (err)
1170                 goto out3;
1171
1172         ciintf_init(budget_ci);
1173
1174         budget_ci->budget.dvb_adapter.priv = budget_ci;
1175         frontend_init(budget_ci);
1176
1177         ttpci_budget_init_hooks(&budget_ci->budget);
1178
1179         return 0;
1180
1181 out3:
1182         ttpci_budget_deinit(&budget_ci->budget);
1183 out2:
1184         kfree(budget_ci);
1185 out1:
1186         return err;
1187 }
1188
1189 static int budget_ci_detach(struct saa7146_dev *dev)
1190 {
1191         struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
1192         struct saa7146_dev *saa = budget_ci->budget.dev;
1193         int err;
1194
1195         if (budget_ci->budget.ci_present)
1196                 ciintf_deinit(budget_ci);
1197         msp430_ir_deinit(budget_ci);
1198         if (budget_ci->budget.dvb_frontend) {
1199                 dvb_unregister_frontend(budget_ci->budget.dvb_frontend);
1200                 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1201         }
1202         err = ttpci_budget_deinit(&budget_ci->budget);
1203
1204         // disable frontend and CI interface
1205         saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
1206
1207         kfree(budget_ci);
1208
1209         return err;
1210 }
1211
1212 static struct saa7146_extension budget_extension;
1213
1214 MAKE_BUDGET_INFO(ttbs2, "TT-Budget/S-1500 PCI", BUDGET_TT);
1215 MAKE_BUDGET_INFO(ttbci, "TT-Budget/WinTV-NOVA-CI PCI", BUDGET_TT_HW_DISEQC);
1216 MAKE_BUDGET_INFO(ttbt2, "TT-Budget/WinTV-NOVA-T  PCI", BUDGET_TT);
1217 MAKE_BUDGET_INFO(ttbtci, "TT-Budget-T-CI PCI", BUDGET_TT);
1218 MAKE_BUDGET_INFO(ttbcci, "TT-Budget-C-CI PCI", BUDGET_TT);
1219
1220 static struct pci_device_id pci_tbl[] = {
1221         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100c),
1222         MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100f),
1223         MAKE_EXTENSION_PCI(ttbcci, 0x13c2, 0x1010),
1224         MAKE_EXTENSION_PCI(ttbt2, 0x13c2, 0x1011),
1225         MAKE_EXTENSION_PCI(ttbtci, 0x13c2, 0x1012),
1226         MAKE_EXTENSION_PCI(ttbs2, 0x13c2, 0x1017),
1227         {
1228          .vendor = 0,
1229          }
1230 };
1231
1232 MODULE_DEVICE_TABLE(pci, pci_tbl);
1233
1234 static struct saa7146_extension budget_extension = {
1235         .name = "budget_ci dvb",
1236         .flags = SAA7146_USE_I2C_IRQ,
1237
1238         .module = THIS_MODULE,
1239         .pci_tbl = &pci_tbl[0],
1240         .attach = budget_ci_attach,
1241         .detach = budget_ci_detach,
1242
1243         .irq_mask = MASK_03 | MASK_06 | MASK_10,
1244         .irq_func = budget_ci_irq,
1245 };
1246
1247 static int __init budget_ci_init(void)
1248 {
1249         return saa7146_register_extension(&budget_extension);
1250 }
1251
1252 static void __exit budget_ci_exit(void)
1253 {
1254         saa7146_unregister_extension(&budget_extension);
1255 }
1256
1257 module_init(budget_ci_init);
1258 module_exit(budget_ci_exit);
1259
1260 MODULE_LICENSE("GPL");
1261 MODULE_AUTHOR("Michael Hunold, Jack Thomasson, Andrew de Quincey, others");
1262 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1263                    "budget PCI DVB cards w/ CI-module produced by "
1264                    "Siemens, Technotrend, Hauppauge");