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