?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: introduce host commands callbacks
[linux/fpc-iii.git] / drivers / media / dvb / ttpci / budget-ci.c
blob509349211d4fc40594fb99a27980eeed2ae66e31
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 = 0;
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 = STV0229_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", __FUNCTION__);
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");
Linux with added FPC-III support