projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cfq-iosched: fix use-after-free of cfqq
[deliverable/linux.git] / 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/
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/spinlock.h>
37 #include <media/rc-core.h>
38
39 #include "budget.h"
40
41 #include "dvb_ca_en50221.h"
42 #include "stv0299.h"
43 #include "stv0297.h"
44 #include "tda1004x.h"
45 #include "stb0899_drv.h"
46 #include "stb0899_reg.h"
47 #include "stb0899_cfg.h"
48 #include "stb6100.h"
49 #include "stb6100_cfg.h"
50 #include "lnbp21.h"
51 #include "bsbe1.h"
52 #include "bsru6.h"
53 #include "tda1002x.h"
54 #include "tda827x.h"
55 #include "bsbe1-d01a.h"
56
57 #define MODULE_NAME "budget_ci"
58
59 /*
60 * Regarding DEBIADDR_IR:
61 * Some CI modules hang if random addresses are read.
62 * Using address 0x4000 for the IR read means that we
63 * use the same address as for CI version, which should
64 * be a safe default.
65 */
66 #define DEBIADDR_IR 0x4000
67 #define DEBIADDR_CICONTROL 0x0000
68 #define DEBIADDR_CIVERSION 0x4000
69 #define DEBIADDR_IO 0x1000
70 #define DEBIADDR_ATTR 0x3000
71
72 #define CICONTROL_RESET 0x01
73 #define CICONTROL_ENABLETS 0x02
74 #define CICONTROL_CAMDETECT 0x08
75
76 #define DEBICICTL 0x00420000
77 #define DEBICICAM 0x02420000
78
79 #define SLOTSTATUS_NONE 1
80 #define SLOTSTATUS_PRESENT 2
81 #define SLOTSTATUS_RESET 4
82 #define SLOTSTATUS_READY 8
83 #define SLOTSTATUS_OCCUPIED (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
84
85 /* RC5 device wildcard */
86 #define IR_DEVICE_ANY 255
87
88 static int rc5_device = -1;
89 module_param(rc5_device, int, 0644);
90 MODULE_PARM_DESC(rc5_device, "only IR commands to given RC5 device (device = 0 - 31, any device = 255, default: autodetect)");
91
92 static int ir_debug;
93 module_param(ir_debug, int, 0644);
94 MODULE_PARM_DESC(ir_debug, "enable debugging information for IR decoding");
95
96 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
97
98 struct budget_ci_ir {
99 struct rc_dev *dev;
100 struct tasklet_struct msp430_irq_tasklet;
101 char name[72]; /* 40 + 32 for (struct saa7146_dev).name */
102 char phys[32];
103 int rc5_device;
104 u32 ir_key;
105 bool have_command;
106 bool full_rc5; /* Outputs a full RC5 code */
107 };
108
109 struct budget_ci {
110 struct budget budget;
111 struct tasklet_struct ciintf_irq_tasklet;
112 int slot_status;
113 int ci_irq;
114 struct dvb_ca_en50221 ca;
115 struct budget_ci_ir ir;
116 u8 tuner_pll_address; /* used for philips_tdm1316l configs */
117 };
118
119 static void msp430_ir_interrupt(unsigned long data)
120 {
121 struct budget_ci *budget_ci = (struct budget_ci *) data;
122 struct rc_dev *dev = budget_ci->ir.dev;
123 u32 command = ttpci_budget_debiread(&budget_ci->budget, DEBINOSWAP, DEBIADDR_IR, 2, 1, 0) >> 8;
124
125 /*
126 * The msp430 chip can generate two different bytes, command and device
127 *
128 * type1: X1CCCCCC, C = command bits (0 - 63)
129 * type2: X0TDDDDD, D = device bits (0 - 31), T = RC5 toggle bit
130 *
131 * Each signal from the remote control can generate one or more command
132 * bytes and one or more device bytes. For the repeated bytes, the
133 * highest bit (X) is set. The first command byte is always generated
134 * before the first device byte. Other than that, no specific order
135 * seems to apply. To make life interesting, bytes can also be lost.
136 *
137 * Only when we have a command and device byte, a keypress is
138 * generated.
139 */
140
141 if (ir_debug)
142 printk("budget_ci: received byte 0x%02x\n", command);
143
144 /* Remove repeat bit, we use every command */
145 command = command & 0x7f;
146
147 /* Is this a RC5 command byte? */
148 if (command & 0x40) {
149 budget_ci->ir.have_command = true;
150 budget_ci->ir.ir_key = command & 0x3f;
151 return;
152 }
153
154 /* It's a RC5 device byte */
155 if (!budget_ci->ir.have_command)
156 return;
157 budget_ci->ir.have_command = false;
158
159 if (budget_ci->ir.rc5_device != IR_DEVICE_ANY &&
160 budget_ci->ir.rc5_device != (command & 0x1f))
161 return;
162
163 if (budget_ci->ir.full_rc5) {
164 rc_keydown(dev,
165 budget_ci->ir.rc5_device <<8 | budget_ci->ir.ir_key,
166 (command & 0x20) ? 1 : 0);
167 return;
168 }
169
170 /* FIXME: We should generate complete scancodes for all devices */
171 rc_keydown(dev, budget_ci->ir.ir_key, (command & 0x20) ? 1 : 0);
172 }
173
174 static int msp430_ir_init(struct budget_ci *budget_ci)
175 {
176 struct saa7146_dev *saa = budget_ci->budget.dev;
177 struct rc_dev *dev;
178 int error;
179
180 dev = rc_allocate_device();
181 if (!dev) {
182 printk(KERN_ERR "budget_ci: IR interface initialisation failed\n");
183 return -ENOMEM;
184 }
185
186 snprintf(budget_ci->ir.name, sizeof(budget_ci->ir.name),
187 "Budget-CI dvb ir receiver %s", saa->name);
188 snprintf(budget_ci->ir.phys, sizeof(budget_ci->ir.phys),
189 "pci-%s/ir0", pci_name(saa->pci));
190
191 dev->driver_name = MODULE_NAME;
192 dev->input_name = budget_ci->ir.name;
193 dev->input_phys = budget_ci->ir.phys;
194 dev->input_id.bustype = BUS_PCI;
195 dev->input_id.version = 1;
196 dev->scanmask = 0xff;
197 if (saa->pci->subsystem_vendor) {
198 dev->input_id.vendor = saa->pci->subsystem_vendor;
199 dev->input_id.product = saa->pci->subsystem_device;
200 } else {
201 dev->input_id.vendor = saa->pci->vendor;
202 dev->input_id.product = saa->pci->device;
203 }
204 dev->dev.parent = &saa->pci->dev;
205
206 if (rc5_device < 0)
207 budget_ci->ir.rc5_device = IR_DEVICE_ANY;
208 else
209 budget_ci->ir.rc5_device = rc5_device;
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 dev->map_name = RC_MAP_HAUPPAUGE;
219 budget_ci->ir.full_rc5 = true;
220
221 if (rc5_device < 0)
222 budget_ci->ir.rc5_device = 0x1f;
223 break;
224 case 0x1010:
225 case 0x1017:
226 case 0x1019:
227 case 0x101a:
228 case 0x101b:
229 /* for the Technotrend 1500 bundled remote */
230 dev->map_name = RC_MAP_TT_1500;
231 break;
232 default:
233 /* unknown remote */
234 dev->map_name = RC_MAP_BUDGET_CI_OLD;
235 break;
236 }
237
238 error = rc_register_device(dev);
239 if (error) {
240 printk(KERN_ERR "budget_ci: could not init driver for IR device (code %d)\n", error);
241 rc_free_device(dev);
242 return error;
243 }
244
245 budget_ci->ir.dev = dev;
246
247 tasklet_init(&budget_ci->ir.msp430_irq_tasklet, msp430_ir_interrupt,
248 (unsigned long) budget_ci);
249
250 SAA7146_IER_ENABLE(saa, MASK_06);
251 saa7146_setgpio(saa, 3, SAA7146_GPIO_IRQHI);
252
253 return 0;
254 }
255
256 static void msp430_ir_deinit(struct budget_ci *budget_ci)
257 {
258 struct saa7146_dev *saa = budget_ci->budget.dev;
259
260 SAA7146_IER_DISABLE(saa, MASK_06);
261 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
262 tasklet_kill(&budget_ci->ir.msp430_irq_tasklet);
263
264 rc_unregister_device(budget_ci->ir.dev);
265 }
266
267 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
268 {
269 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
270
271 if (slot != 0)
272 return -EINVAL;
273
274 return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
275 DEBIADDR_ATTR | (address & 0xfff), 1, 1, 0);
276 }
277
278 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
279 {
280 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
281
282 if (slot != 0)
283 return -EINVAL;
284
285 return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
286 DEBIADDR_ATTR | (address & 0xfff), 1, value, 1, 0);
287 }
288
289 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
290 {
291 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
292
293 if (slot != 0)
294 return -EINVAL;
295
296 return ttpci_budget_debiread(&budget_ci->budget, DEBICICAM,
297 DEBIADDR_IO | (address & 3), 1, 1, 0);
298 }
299
300 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
301 {
302 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
303
304 if (slot != 0)
305 return -EINVAL;
306
307 return ttpci_budget_debiwrite(&budget_ci->budget, DEBICICAM,
308 DEBIADDR_IO | (address & 3), 1, value, 1, 0);
309 }
310
311 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
312 {
313 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
314 struct saa7146_dev *saa = budget_ci->budget.dev;
315
316 if (slot != 0)
317 return -EINVAL;
318
319 if (budget_ci->ci_irq) {
320 // trigger on RISING edge during reset so we know when READY is re-asserted
321 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
322 }
323 budget_ci->slot_status = SLOTSTATUS_RESET;
324 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
325 msleep(1);
326 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
327 CICONTROL_RESET, 1, 0);
328
329 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
330 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
331 return 0;
332 }
333
334 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
335 {
336 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
337 struct saa7146_dev *saa = budget_ci->budget.dev;
338
339 if (slot != 0)
340 return -EINVAL;
341
342 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTHI);
343 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
344 return 0;
345 }
346
347 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
348 {
349 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
350 struct saa7146_dev *saa = budget_ci->budget.dev;
351 int tmp;
352
353 if (slot != 0)
354 return -EINVAL;
355
356 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
357
358 tmp = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
359 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
360 tmp | CICONTROL_ENABLETS, 1, 0);
361
362 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
363 return 0;
364 }
365
366 static void ciintf_interrupt(unsigned long data)
367 {
368 struct budget_ci *budget_ci = (struct budget_ci *) data;
369 struct saa7146_dev *saa = budget_ci->budget.dev;
370 unsigned int flags;
371
372 // ensure we don't get spurious IRQs during initialisation
373 if (!budget_ci->budget.ci_present)
374 return;
375
376 // read the CAM status
377 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
378 if (flags & CICONTROL_CAMDETECT) {
379
380 // GPIO should be set to trigger on falling edge if a CAM is present
381 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
382
383 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
384 // CAM insertion IRQ
385 budget_ci->slot_status = SLOTSTATUS_PRESENT;
386 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
387 DVB_CA_EN50221_CAMCHANGE_INSERTED);
388
389 } else if (budget_ci->slot_status & SLOTSTATUS_RESET) {
390 // CAM ready (reset completed)
391 budget_ci->slot_status = SLOTSTATUS_READY;
392 dvb_ca_en50221_camready_irq(&budget_ci->ca, 0);
393
394 } else if (budget_ci->slot_status & SLOTSTATUS_READY) {
395 // FR/DA IRQ
396 dvb_ca_en50221_frda_irq(&budget_ci->ca, 0);
397 }
398 } else {
399
400 // trigger on rising edge if a CAM is not present - when a CAM is inserted, we
401 // only want to get the IRQ when it sets READY. If we trigger on the falling edge,
402 // the CAM might not actually be ready yet.
403 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
404
405 // generate a CAM removal IRQ if we haven't already
406 if (budget_ci->slot_status & SLOTSTATUS_OCCUPIED) {
407 // CAM removal IRQ
408 budget_ci->slot_status = SLOTSTATUS_NONE;
409 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0,
410 DVB_CA_EN50221_CAMCHANGE_REMOVED);
411 }
412 }
413 }
414
415 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
416 {
417 struct budget_ci *budget_ci = (struct budget_ci *) ca->data;
418 unsigned int flags;
419
420 // ensure we don't get spurious IRQs during initialisation
421 if (!budget_ci->budget.ci_present)
422 return -EINVAL;
423
424 // read the CAM status
425 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
426 if (flags & CICONTROL_CAMDETECT) {
427 // mark it as present if it wasn't before
428 if (budget_ci->slot_status & SLOTSTATUS_NONE) {
429 budget_ci->slot_status = SLOTSTATUS_PRESENT;
430 }
431
432 // during a RESET, we check if we can read from IO memory to see when CAM is ready
433 if (budget_ci->slot_status & SLOTSTATUS_RESET) {
434 if (ciintf_read_attribute_mem(ca, slot, 0) == 0x1d) {
435 budget_ci->slot_status = SLOTSTATUS_READY;
436 }
437 }
438 } else {
439 budget_ci->slot_status = SLOTSTATUS_NONE;
440 }
441
442 if (budget_ci->slot_status != SLOTSTATUS_NONE) {
443 if (budget_ci->slot_status & SLOTSTATUS_READY) {
444 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
445 }
446 return DVB_CA_EN50221_POLL_CAM_PRESENT;
447 }
448
449 return 0;
450 }
451
452 static int ciintf_init(struct budget_ci *budget_ci)
453 {
454 struct saa7146_dev *saa = budget_ci->budget.dev;
455 int flags;
456 int result;
457 int ci_version;
458 int ca_flags;
459
460 memset(&budget_ci->ca, 0, sizeof(struct dvb_ca_en50221));
461
462 // enable DEBI pins
463 saa7146_write(saa, MC1, MASK_27 | MASK_11);
464
465 // test if it is there
466 ci_version = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CIVERSION, 1, 1, 0);
467 if ((ci_version & 0xa0) != 0xa0) {
468 result = -ENODEV;
469 goto error;
470 }
471
472 // determine whether a CAM is present or not
473 flags = ttpci_budget_debiread(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 1, 0);
474 budget_ci->slot_status = SLOTSTATUS_NONE;
475 if (flags & CICONTROL_CAMDETECT)
476 budget_ci->slot_status = SLOTSTATUS_PRESENT;
477
478 // version 0xa2 of the CI firmware doesn't generate interrupts
479 if (ci_version == 0xa2) {
480 ca_flags = 0;
481 budget_ci->ci_irq = 0;
482 } else {
483 ca_flags = DVB_CA_EN50221_FLAG_IRQ_CAMCHANGE |
484 DVB_CA_EN50221_FLAG_IRQ_FR |
485 DVB_CA_EN50221_FLAG_IRQ_DA;
486 budget_ci->ci_irq = 1;
487 }
488
489 // register CI interface
490 budget_ci->ca.owner = THIS_MODULE;
491 budget_ci->ca.read_attribute_mem = ciintf_read_attribute_mem;
492 budget_ci->ca.write_attribute_mem = ciintf_write_attribute_mem;
493 budget_ci->ca.read_cam_control = ciintf_read_cam_control;
494 budget_ci->ca.write_cam_control = ciintf_write_cam_control;
495 budget_ci->ca.slot_reset = ciintf_slot_reset;
496 budget_ci->ca.slot_shutdown = ciintf_slot_shutdown;
497 budget_ci->ca.slot_ts_enable = ciintf_slot_ts_enable;
498 budget_ci->ca.poll_slot_status = ciintf_poll_slot_status;
499 budget_ci->ca.data = budget_ci;
500 if ((result = dvb_ca_en50221_init(&budget_ci->budget.dvb_adapter,
501 &budget_ci->ca,
502 ca_flags, 1)) != 0) {
503 printk("budget_ci: CI interface detected, but initialisation failed.\n");
504 goto error;
505 }
506
507 // Setup CI slot IRQ
508 if (budget_ci->ci_irq) {
509 tasklet_init(&budget_ci->ciintf_irq_tasklet, ciintf_interrupt, (unsigned long) budget_ci);
510 if (budget_ci->slot_status != SLOTSTATUS_NONE) {
511 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQLO);
512 } else {
513 saa7146_setgpio(saa, 0, SAA7146_GPIO_IRQHI);
514 }
515 SAA7146_IER_ENABLE(saa, MASK_03);
516 }
517
518 // enable interface
519 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
520 CICONTROL_RESET, 1, 0);
521
522 // success!
523 printk("budget_ci: CI interface initialised\n");
524 budget_ci->budget.ci_present = 1;
525
526 // forge a fake CI IRQ so the CAM state is setup correctly
527 if (budget_ci->ci_irq) {
528 flags = DVB_CA_EN50221_CAMCHANGE_REMOVED;
529 if (budget_ci->slot_status != SLOTSTATUS_NONE)
530 flags = DVB_CA_EN50221_CAMCHANGE_INSERTED;
531 dvb_ca_en50221_camchange_irq(&budget_ci->ca, 0, flags);
532 }
533
534 return 0;
535
536 error:
537 saa7146_write(saa, MC1, MASK_27);
538 return result;
539 }
540
541 static void ciintf_deinit(struct budget_ci *budget_ci)
542 {
543 struct saa7146_dev *saa = budget_ci->budget.dev;
544
545 // disable CI interrupts
546 if (budget_ci->ci_irq) {
547 SAA7146_IER_DISABLE(saa, MASK_03);
548 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
549 tasklet_kill(&budget_ci->ciintf_irq_tasklet);
550 }
551
552 // reset interface
553 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1, 0, 1, 0);
554 msleep(1);
555 ttpci_budget_debiwrite(&budget_ci->budget, DEBICICTL, DEBIADDR_CICONTROL, 1,
556 CICONTROL_RESET, 1, 0);
557
558 // disable TS data stream to CI interface
559 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
560
561 // release the CA device
562 dvb_ca_en50221_release(&budget_ci->ca);
563
564 // disable DEBI pins
565 saa7146_write(saa, MC1, MASK_27);
566 }
567
568 static void budget_ci_irq(struct saa7146_dev *dev, u32 * isr)
569 {
570 struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
571
572 dprintk(8, "dev: %p, budget_ci: %p\n", dev, budget_ci);
573
574 if (*isr & MASK_06)
575 tasklet_schedule(&budget_ci->ir.msp430_irq_tasklet);
576
577 if (*isr & MASK_10)
578 ttpci_budget_irq10_handler(dev, isr);
579
580 if ((*isr & MASK_03) && (budget_ci->budget.ci_present) && (budget_ci->ci_irq))
581 tasklet_schedule(&budget_ci->ciintf_irq_tasklet);
582 }
583
584 static u8 philips_su1278_tt_inittab[] = {
585 0x01, 0x0f,
586 0x02, 0x30,
587 0x03, 0x00,
588 0x04, 0x5b,
589 0x05, 0x85,
590 0x06, 0x02,
591 0x07, 0x00,
592 0x08, 0x02,
593 0x09, 0x00,
594 0x0C, 0x01,
595 0x0D, 0x81,
596 0x0E, 0x44,
597 0x0f, 0x14,
598 0x10, 0x3c,
599 0x11, 0x84,
600 0x12, 0xda,
601 0x13, 0x97,
602 0x14, 0x95,
603 0x15, 0xc9,
604 0x16, 0x19,
605 0x17, 0x8c,
606 0x18, 0x59,
607 0x19, 0xf8,
608 0x1a, 0xfe,
609 0x1c, 0x7f,
610 0x1d, 0x00,
611 0x1e, 0x00,
612 0x1f, 0x50,
613 0x20, 0x00,
614 0x21, 0x00,
615 0x22, 0x00,
616 0x23, 0x00,
617 0x28, 0x00,
618 0x29, 0x28,
619 0x2a, 0x14,
620 0x2b, 0x0f,
621 0x2c, 0x09,
622 0x2d, 0x09,
623 0x31, 0x1f,
624 0x32, 0x19,
625 0x33, 0xfc,
626 0x34, 0x93,
627 0xff, 0xff
628 };
629
630 static int philips_su1278_tt_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
631 {
632 stv0299_writereg(fe, 0x0e, 0x44);
633 if (srate >= 10000000) {
634 stv0299_writereg(fe, 0x13, 0x97);
635 stv0299_writereg(fe, 0x14, 0x95);
636 stv0299_writereg(fe, 0x15, 0xc9);
637 stv0299_writereg(fe, 0x17, 0x8c);
638 stv0299_writereg(fe, 0x1a, 0xfe);
639 stv0299_writereg(fe, 0x1c, 0x7f);
640 stv0299_writereg(fe, 0x2d, 0x09);
641 } else {
642 stv0299_writereg(fe, 0x13, 0x99);
643 stv0299_writereg(fe, 0x14, 0x8d);
644 stv0299_writereg(fe, 0x15, 0xce);
645 stv0299_writereg(fe, 0x17, 0x43);
646 stv0299_writereg(fe, 0x1a, 0x1d);
647 stv0299_writereg(fe, 0x1c, 0x12);
648 stv0299_writereg(fe, 0x2d, 0x05);
649 }
650 stv0299_writereg(fe, 0x0e, 0x23);
651 stv0299_writereg(fe, 0x0f, 0x94);
652 stv0299_writereg(fe, 0x10, 0x39);
653 stv0299_writereg(fe, 0x15, 0xc9);
654
655 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
656 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
657 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
658
659 return 0;
660 }
661
662 static int philips_su1278_tt_tuner_set_params(struct dvb_frontend *fe,
663 struct dvb_frontend_parameters *params)
664 {
665 struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
666 u32 div;
667 u8 buf[4];
668 struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
669
670 if ((params->frequency < 950000) || (params->frequency > 2150000))
671 return -EINVAL;
672
673 div = (params->frequency + (500 - 1)) / 500; // round correctly
674 buf[0] = (div >> 8) & 0x7f;
675 buf[1] = div & 0xff;
676 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 2;
677 buf[3] = 0x20;
678
679 if (params->u.qpsk.symbol_rate < 4000000)
680 buf[3] |= 1;
681
682 if (params->frequency < 1250000)
683 buf[3] |= 0;
684 else if (params->frequency < 1550000)
685 buf[3] |= 0x40;
686 else if (params->frequency < 2050000)
687 buf[3] |= 0x80;
688 else if (params->frequency < 2150000)
689 buf[3] |= 0xC0;
690
691 if (fe->ops.i2c_gate_ctrl)
692 fe->ops.i2c_gate_ctrl(fe, 1);
693 if (i2c_transfer(&budget_ci->budget.i2c_adap, &msg, 1) != 1)
694 return -EIO;
695 return 0;
696 }
697
698 static struct stv0299_config philips_su1278_tt_config = {
699
700 .demod_address = 0x68,
701 .inittab = philips_su1278_tt_inittab,
702 .mclk = 64000000UL,
703 .invert = 0,
704 .skip_reinit = 1,
705 .lock_output = STV0299_LOCKOUTPUT_1,
706 .volt13_op0_op1 = STV0299_VOLT13_OP1,
707 .min_delay_ms = 50,
708 .set_symbol_rate = philips_su1278_tt_set_symbol_rate,
709 };
710
711
712
713 static int philips_tdm1316l_tuner_init(struct dvb_frontend *fe)
714 {
715 struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
716 static u8 td1316_init[] = { 0x0b, 0xf5, 0x85, 0xab };
717 static u8 disable_mc44BC374c[] = { 0x1d, 0x74, 0xa0, 0x68 };
718 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = td1316_init,.len =
719 sizeof(td1316_init) };
720
721 // setup PLL configuration
722 if (fe->ops.i2c_gate_ctrl)
723 fe->ops.i2c_gate_ctrl(fe, 1);
724 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
725 return -EIO;
726 msleep(1);
727
728 // disable the mc44BC374c (do not check for errors)
729 tuner_msg.addr = 0x65;
730 tuner_msg.buf = disable_mc44BC374c;
731 tuner_msg.len = sizeof(disable_mc44BC374c);
732 if (fe->ops.i2c_gate_ctrl)
733 fe->ops.i2c_gate_ctrl(fe, 1);
734 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1) {
735 if (fe->ops.i2c_gate_ctrl)
736 fe->ops.i2c_gate_ctrl(fe, 1);
737 i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1);
738 }
739
740 return 0;
741 }
742
743 static int philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
744 {
745 struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
746 u8 tuner_buf[4];
747 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,.flags = 0,.buf = tuner_buf,.len = sizeof(tuner_buf) };
748 int tuner_frequency = 0;
749 u8 band, cp, filter;
750
751 // determine charge pump
752 tuner_frequency = params->frequency + 36130000;
753 if (tuner_frequency < 87000000)
754 return -EINVAL;
755 else if (tuner_frequency < 130000000)
756 cp = 3;
757 else if (tuner_frequency < 160000000)
758 cp = 5;
759 else if (tuner_frequency < 200000000)
760 cp = 6;
761 else if (tuner_frequency < 290000000)
762 cp = 3;
763 else if (tuner_frequency < 420000000)
764 cp = 5;
765 else if (tuner_frequency < 480000000)
766 cp = 6;
767 else if (tuner_frequency < 620000000)
768 cp = 3;
769 else if (tuner_frequency < 830000000)
770 cp = 5;
771 else if (tuner_frequency < 895000000)
772 cp = 7;
773 else
774 return -EINVAL;
775
776 // determine band
777 if (params->frequency < 49000000)
778 return -EINVAL;
779 else if (params->frequency < 159000000)
780 band = 1;
781 else if (params->frequency < 444000000)
782 band = 2;
783 else if (params->frequency < 861000000)
784 band = 4;
785 else
786 return -EINVAL;
787
788 // setup PLL filter and TDA9889
789 switch (params->u.ofdm.bandwidth) {
790 case BANDWIDTH_6_MHZ:
791 tda1004x_writereg(fe, 0x0C, 0x14);
792 filter = 0;
793 break;
794
795 case BANDWIDTH_7_MHZ:
796 tda1004x_writereg(fe, 0x0C, 0x80);
797 filter = 0;
798 break;
799
800 case BANDWIDTH_8_MHZ:
801 tda1004x_writereg(fe, 0x0C, 0x14);
802 filter = 1;
803 break;
804
805 default:
806 return -EINVAL;
807 }
808
809 // calculate divisor
810 // ((36130000+((1000000/6)/2)) + Finput)/(1000000/6)
811 tuner_frequency = (((params->frequency / 1000) * 6) + 217280) / 1000;
812
813 // setup tuner buffer
814 tuner_buf[0] = tuner_frequency >> 8;
815 tuner_buf[1] = tuner_frequency & 0xff;
816 tuner_buf[2] = 0xca;
817 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
818
819 if (fe->ops.i2c_gate_ctrl)
820 fe->ops.i2c_gate_ctrl(fe, 1);
821 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
822 return -EIO;
823
824 msleep(1);
825 return 0;
826 }
827
828 static int philips_tdm1316l_request_firmware(struct dvb_frontend *fe,
829 const struct firmware **fw, char *name)
830 {
831 struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
832
833 return request_firmware(fw, name, &budget_ci->budget.dev->pci->dev);
834 }
835
836 static struct tda1004x_config philips_tdm1316l_config = {
837
838 .demod_address = 0x8,
839 .invert = 0,
840 .invert_oclk = 0,
841 .xtal_freq = TDA10046_XTAL_4M,
842 .agc_config = TDA10046_AGC_DEFAULT,
843 .if_freq = TDA10046_FREQ_3617,
844 .request_firmware = philips_tdm1316l_request_firmware,
845 };
846
847 static struct tda1004x_config philips_tdm1316l_config_invert = {
848
849 .demod_address = 0x8,
850 .invert = 1,
851 .invert_oclk = 0,
852 .xtal_freq = TDA10046_XTAL_4M,
853 .agc_config = TDA10046_AGC_DEFAULT,
854 .if_freq = TDA10046_FREQ_3617,
855 .request_firmware = philips_tdm1316l_request_firmware,
856 };
857
858 static int dvbc_philips_tdm1316l_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
859 {
860 struct budget_ci *budget_ci = (struct budget_ci *) fe->dvb->priv;
861 u8 tuner_buf[5];
862 struct i2c_msg tuner_msg = {.addr = budget_ci->tuner_pll_address,
863 .flags = 0,
864 .buf = tuner_buf,
865 .len = sizeof(tuner_buf) };
866 int tuner_frequency = 0;
867 u8 band, cp, filter;
868
869 // determine charge pump
870 tuner_frequency = params->frequency + 36125000;
871 if (tuner_frequency < 87000000)
872 return -EINVAL;
873 else if (tuner_frequency < 130000000) {
874 cp = 3;
875 band = 1;
876 } else if (tuner_frequency < 160000000) {
877 cp = 5;
878 band = 1;
879 } else if (tuner_frequency < 200000000) {
880 cp = 6;
881 band = 1;
882 } else if (tuner_frequency < 290000000) {
883 cp = 3;
884 band = 2;
885 } else if (tuner_frequency < 420000000) {
886 cp = 5;
887 band = 2;
888 } else if (tuner_frequency < 480000000) {
889 cp = 6;
890 band = 2;
891 } else if (tuner_frequency < 620000000) {
892 cp = 3;
893 band = 4;
894 } else if (tuner_frequency < 830000000) {
895 cp = 5;
896 band = 4;
897 } else if (tuner_frequency < 895000000) {
898 cp = 7;
899 band = 4;
900 } else
901 return -EINVAL;
902
903 // assume PLL filter should always be 8MHz for the moment.
904 filter = 1;
905
906 // calculate divisor
907 tuner_frequency = (params->frequency + 36125000 + (62500/2)) / 62500;
908
909 // setup tuner buffer
910 tuner_buf[0] = tuner_frequency >> 8;
911 tuner_buf[1] = tuner_frequency & 0xff;
912 tuner_buf[2] = 0xc8;
913 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
914 tuner_buf[4] = 0x80;
915
916 if (fe->ops.i2c_gate_ctrl)
917 fe->ops.i2c_gate_ctrl(fe, 1);
918 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
919 return -EIO;
920
921 msleep(50);
922
923 if (fe->ops.i2c_gate_ctrl)
924 fe->ops.i2c_gate_ctrl(fe, 1);
925 if (i2c_transfer(&budget_ci->budget.i2c_adap, &tuner_msg, 1) != 1)
926 return -EIO;
927
928 msleep(1);
929
930 return 0;
931 }
932
933 static u8 dvbc_philips_tdm1316l_inittab[] = {
934 0x80, 0x01,
935 0x80, 0x00,
936 0x81, 0x01,
937 0x81, 0x00,
938 0x00, 0x09,
939 0x01, 0x69,
940 0x03, 0x00,
941 0x04, 0x00,
942 0x07, 0x00,
943 0x08, 0x00,
944 0x20, 0x00,
945 0x21, 0x40,
946 0x22, 0x00,
947 0x23, 0x00,
948 0x24, 0x40,
949 0x25, 0x88,
950 0x30, 0xff,
951 0x31, 0x00,
952 0x32, 0xff,
953 0x33, 0x00,
954 0x34, 0x50,
955 0x35, 0x7f,
956 0x36, 0x00,
957 0x37, 0x20,
958 0x38, 0x00,
959 0x40, 0x1c,
960 0x41, 0xff,
961 0x42, 0x29,
962 0x43, 0x20,
963 0x44, 0xff,
964 0x45, 0x00,
965 0x46, 0x00,
966 0x49, 0x04,
967 0x4a, 0x00,
968 0x4b, 0x7b,
969 0x52, 0x30,
970 0x55, 0xae,
971 0x56, 0x47,
972 0x57, 0xe1,
973 0x58, 0x3a,
974 0x5a, 0x1e,
975 0x5b, 0x34,
976 0x60, 0x00,
977 0x63, 0x00,
978 0x64, 0x00,
979 0x65, 0x00,
980 0x66, 0x00,
981 0x67, 0x00,
982 0x68, 0x00,
983 0x69, 0x00,
984 0x6a, 0x02,
985 0x6b, 0x00,
986 0x70, 0xff,
987 0x71, 0x00,
988 0x72, 0x00,
989 0x73, 0x00,
990 0x74, 0x0c,
991 0x80, 0x00,
992 0x81, 0x00,
993 0x82, 0x00,
994 0x83, 0x00,
995 0x84, 0x04,
996 0x85, 0x80,
997 0x86, 0x24,
998 0x87, 0x78,
999 0x88, 0x10,
1000 0x89, 0x00,
1001 0x90, 0x01,
1002 0x91, 0x01,
1003 0xa0, 0x04,
1004 0xa1, 0x00,
1005 0xa2, 0x00,
1006 0xb0, 0x91,
1007 0xb1, 0x0b,
1008 0xc0, 0x53,
1009 0xc1, 0x70,
1010 0xc2, 0x12,
1011 0xd0, 0x00,
1012 0xd1, 0x00,
1013 0xd2, 0x00,
1014 0xd3, 0x00,
1015 0xd4, 0x00,
1016 0xd5, 0x00,
1017 0xde, 0x00,
1018 0xdf, 0x00,
1019 0x61, 0x38,
1020 0x62, 0x0a,
1021 0x53, 0x13,
1022 0x59, 0x08,
1023 0xff, 0xff,
1024 };
1025
1026 static struct stv0297_config dvbc_philips_tdm1316l_config = {
1027 .demod_address = 0x1c,
1028 .inittab = dvbc_philips_tdm1316l_inittab,
1029 .invert = 0,
1030 .stop_during_read = 1,
1031 };
1032
1033 static struct tda10023_config tda10023_config = {
1034 .demod_address = 0xc,
1035 .invert = 0,
1036 .xtal = 16000000,
1037 .pll_m = 11,
1038 .pll_p = 3,
1039 .pll_n = 1,
1040 .deltaf = 0xa511,
1041 };
1042
1043 static struct tda827x_config tda827x_config = {
1044 .config = 0,
1045 };
1046
1047 /* TT S2-3200 DVB-S (STB0899) Inittab */
1048 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_1[] = {
1049
1050 { STB0899_DEV_ID , 0x81 },
1051 { STB0899_DISCNTRL1 , 0x32 },
1052 { STB0899_DISCNTRL2 , 0x80 },
1053 { STB0899_DISRX_ST0 , 0x04 },
1054 { STB0899_DISRX_ST1 , 0x00 },
1055 { STB0899_DISPARITY , 0x00 },
1056 { STB0899_DISSTATUS , 0x20 },
1057 { STB0899_DISF22 , 0x8c },
1058 { STB0899_DISF22RX , 0x9a },
1059 { STB0899_SYSREG , 0x0b },
1060 { STB0899_ACRPRESC , 0x11 },
1061 { STB0899_ACRDIV1 , 0x0a },
1062 { STB0899_ACRDIV2 , 0x05 },
1063 { STB0899_DACR1 , 0x00 },
1064 { STB0899_DACR2 , 0x00 },
1065 { STB0899_OUTCFG , 0x00 },
1066 { STB0899_MODECFG , 0x00 },
1067 { STB0899_IRQSTATUS_3 , 0x30 },
1068 { STB0899_IRQSTATUS_2 , 0x00 },
1069 { STB0899_IRQSTATUS_1 , 0x00 },
1070 { STB0899_IRQSTATUS_0 , 0x00 },
1071 { STB0899_IRQMSK_3 , 0xf3 },
1072 { STB0899_IRQMSK_2 , 0xfc },
1073 { STB0899_IRQMSK_1 , 0xff },
1074 { STB0899_IRQMSK_0 , 0xff },
1075 { STB0899_IRQCFG , 0x00 },
1076 { STB0899_I2CCFG , 0x88 },
1077 { STB0899_I2CRPT , 0x48 }, /* 12k Pullup, Repeater=16, Stop=disabled */
1078 { STB0899_IOPVALUE5 , 0x00 },
1079 { STB0899_IOPVALUE4 , 0x20 },
1080 { STB0899_IOPVALUE3 , 0xc9 },
1081 { STB0899_IOPVALUE2 , 0x90 },
1082 { STB0899_IOPVALUE1 , 0x40 },
1083 { STB0899_IOPVALUE0 , 0x00 },
1084 { STB0899_GPIO00CFG , 0x82 },
1085 { STB0899_GPIO01CFG , 0x82 },
1086 { STB0899_GPIO02CFG , 0x82 },
1087 { STB0899_GPIO03CFG , 0x82 },
1088 { STB0899_GPIO04CFG , 0x82 },
1089 { STB0899_GPIO05CFG , 0x82 },
1090 { STB0899_GPIO06CFG , 0x82 },
1091 { STB0899_GPIO07CFG , 0x82 },
1092 { STB0899_GPIO08CFG , 0x82 },
1093 { STB0899_GPIO09CFG , 0x82 },
1094 { STB0899_GPIO10CFG , 0x82 },
1095 { STB0899_GPIO11CFG , 0x82 },
1096 { STB0899_GPIO12CFG , 0x82 },
1097 { STB0899_GPIO13CFG , 0x82 },
1098 { STB0899_GPIO14CFG , 0x82 },
1099 { STB0899_GPIO15CFG , 0x82 },
1100 { STB0899_GPIO16CFG , 0x82 },
1101 { STB0899_GPIO17CFG , 0x82 },
1102 { STB0899_GPIO18CFG , 0x82 },
1103 { STB0899_GPIO19CFG , 0x82 },
1104 { STB0899_GPIO20CFG , 0x82 },
1105 { STB0899_SDATCFG , 0xb8 },
1106 { STB0899_SCLTCFG , 0xba },
1107 { STB0899_AGCRFCFG , 0x1c }, /* 0x11 */
1108 { STB0899_GPIO22 , 0x82 }, /* AGCBB2CFG */
1109 { STB0899_GPIO21 , 0x91 }, /* AGCBB1CFG */
1110 { STB0899_DIRCLKCFG , 0x82 },
1111 { STB0899_CLKOUT27CFG , 0x7e },
1112 { STB0899_STDBYCFG , 0x82 },
1113 { STB0899_CS0CFG , 0x82 },
1114 { STB0899_CS1CFG , 0x82 },
1115 { STB0899_DISEQCOCFG , 0x20 },
1116 { STB0899_GPIO32CFG , 0x82 },
1117 { STB0899_GPIO33CFG , 0x82 },
1118 { STB0899_GPIO34CFG , 0x82 },
1119 { STB0899_GPIO35CFG , 0x82 },
1120 { STB0899_GPIO36CFG , 0x82 },
1121 { STB0899_GPIO37CFG , 0x82 },
1122 { STB0899_GPIO38CFG , 0x82 },
1123 { STB0899_GPIO39CFG , 0x82 },
1124 { STB0899_NCOARSE , 0x15 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */
1125 { STB0899_SYNTCTRL , 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */
1126 { STB0899_FILTCTRL , 0x00 },
1127 { STB0899_SYSCTRL , 0x00 },
1128 { STB0899_STOPCLK1 , 0x20 },
1129 { STB0899_STOPCLK2 , 0x00 },
1130 { STB0899_INTBUFSTATUS , 0x00 },
1131 { STB0899_INTBUFCTRL , 0x0a },
1132 { 0xffff , 0xff },
1133 };
1134
1135 static const struct stb0899_s1_reg tt3200_stb0899_s1_init_3[] = {
1136 { STB0899_DEMOD , 0x00 },
1137 { STB0899_RCOMPC , 0xc9 },
1138 { STB0899_AGC1CN , 0x41 },
1139 { STB0899_AGC1REF , 0x10 },
1140 { STB0899_RTC , 0x7a },
1141 { STB0899_TMGCFG , 0x4e },
1142 { STB0899_AGC2REF , 0x34 },
1143 { STB0899_TLSR , 0x84 },
1144 { STB0899_CFD , 0xc7 },
1145 { STB0899_ACLC , 0x87 },
1146 { STB0899_BCLC , 0x94 },
1147 { STB0899_EQON , 0x41 },
1148 { STB0899_LDT , 0xdd },
1149 { STB0899_LDT2 , 0xc9 },
1150 { STB0899_EQUALREF , 0xb4 },
1151 { STB0899_TMGRAMP , 0x10 },
1152 { STB0899_TMGTHD , 0x30 },
1153 { STB0899_IDCCOMP , 0xfb },
1154 { STB0899_QDCCOMP , 0x03 },
1155 { STB0899_POWERI , 0x3b },
1156 { STB0899_POWERQ , 0x3d },
1157 { STB0899_RCOMP , 0x81 },
1158 { STB0899_AGCIQIN , 0x80 },
1159 { STB0899_AGC2I1 , 0x04 },
1160 { STB0899_AGC2I2 , 0xf5 },
1161 { STB0899_TLIR , 0x25 },
1162 { STB0899_RTF , 0x80 },
1163 { STB0899_DSTATUS , 0x00 },
1164 { STB0899_LDI , 0xca },
1165 { STB0899_CFRM , 0xf1 },
1166 { STB0899_CFRL , 0xf3 },
1167 { STB0899_NIRM , 0x2a },
1168 { STB0899_NIRL , 0x05 },
1169 { STB0899_ISYMB , 0x17 },
1170 { STB0899_QSYMB , 0xfa },
1171 { STB0899_SFRH , 0x2f },
1172 { STB0899_SFRM , 0x68 },
1173 { STB0899_SFRL , 0x40 },
1174 { STB0899_SFRUPH , 0x2f },
1175 { STB0899_SFRUPM , 0x68 },
1176 { STB0899_SFRUPL , 0x40 },
1177 { STB0899_EQUAI1 , 0xfd },
1178 { STB0899_EQUAQ1 , 0x04 },
1179 { STB0899_EQUAI2 , 0x0f },
1180 { STB0899_EQUAQ2 , 0xff },
1181 { STB0899_EQUAI3 , 0xdf },
1182 { STB0899_EQUAQ3 , 0xfa },
1183 { STB0899_EQUAI4 , 0x37 },
1184 { STB0899_EQUAQ4 , 0x0d },
1185 { STB0899_EQUAI5 , 0xbd },
1186 { STB0899_EQUAQ5 , 0xf7 },
1187 { STB0899_DSTATUS2 , 0x00 },
1188 { STB0899_VSTATUS , 0x00 },
1189 { STB0899_VERROR , 0xff },
1190 { STB0899_IQSWAP , 0x2a },
1191 { STB0899_ECNT1M , 0x00 },
1192 { STB0899_ECNT1L , 0x00 },
1193 { STB0899_ECNT2M , 0x00 },
1194 { STB0899_ECNT2L , 0x00 },
1195 { STB0899_ECNT3M , 0x00 },
1196 { STB0899_ECNT3L , 0x00 },
1197 { STB0899_FECAUTO1 , 0x06 },
1198 { STB0899_FECM , 0x01 },
1199 { STB0899_VTH12 , 0xf0 },
1200 { STB0899_VTH23 , 0xa0 },
1201 { STB0899_VTH34 , 0x78 },
1202 { STB0899_VTH56 , 0x4e },
1203 { STB0899_VTH67 , 0x48 },
1204 { STB0899_VTH78 , 0x38 },
1205 { STB0899_PRVIT , 0xff },
1206 { STB0899_VITSYNC , 0x19 },
1207 { STB0899_RSULC , 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
1208 { STB0899_TSULC , 0x42 },
1209 { STB0899_RSLLC , 0x40 },
1210 { STB0899_TSLPL , 0x12 },
1211 { STB0899_TSCFGH , 0x0c },
1212 { STB0899_TSCFGM , 0x00 },
1213 { STB0899_TSCFGL , 0x0c },
1214 { STB0899_TSOUT , 0x4d }, /* 0x0d for CAM */
1215 { STB0899_RSSYNCDEL , 0x00 },
1216 { STB0899_TSINHDELH , 0x02 },
1217 { STB0899_TSINHDELM , 0x00 },
1218 { STB0899_TSINHDELL , 0x00 },
1219 { STB0899_TSLLSTKM , 0x00 },
1220 { STB0899_TSLLSTKL , 0x00 },
1221 { STB0899_TSULSTKM , 0x00 },
1222 { STB0899_TSULSTKL , 0xab },
1223 { STB0899_PCKLENUL , 0x00 },
1224 { STB0899_PCKLENLL , 0xcc },
1225 { STB0899_RSPCKLEN , 0xcc },
1226 { STB0899_TSSTATUS , 0x80 },
1227 { STB0899_ERRCTRL1 , 0xb6 },
1228 { STB0899_ERRCTRL2 , 0x96 },
1229 { STB0899_ERRCTRL3 , 0x89 },
1230 { STB0899_DMONMSK1 , 0x27 },
1231 { STB0899_DMONMSK0 , 0x03 },
1232 { STB0899_DEMAPVIT , 0x5c },
1233 { STB0899_PLPARM , 0x1f },
1234 { STB0899_PDELCTRL , 0x48 },
1235 { STB0899_PDELCTRL2 , 0x00 },
1236 { STB0899_BBHCTRL1 , 0x00 },
1237 { STB0899_BBHCTRL2 , 0x00 },
1238 { STB0899_HYSTTHRESH , 0x77 },
1239 { STB0899_MATCSTM , 0x00 },
1240 { STB0899_MATCSTL , 0x00 },
1241 { STB0899_UPLCSTM , 0x00 },
1242 { STB0899_UPLCSTL , 0x00 },
1243 { STB0899_DFLCSTM , 0x00 },
1244 { STB0899_DFLCSTL , 0x00 },
1245 { STB0899_SYNCCST , 0x00 },
1246 { STB0899_SYNCDCSTM , 0x00 },
1247 { STB0899_SYNCDCSTL , 0x00 },
1248 { STB0899_ISI_ENTRY , 0x00 },
1249 { STB0899_ISI_BIT_EN , 0x00 },
1250 { STB0899_MATSTRM , 0x00 },
1251 { STB0899_MATSTRL , 0x00 },
1252 { STB0899_UPLSTRM , 0x00 },
1253 { STB0899_UPLSTRL , 0x00 },
1254 { STB0899_DFLSTRM , 0x00 },
1255 { STB0899_DFLSTRL , 0x00 },
1256 { STB0899_SYNCSTR , 0x00 },
1257 { STB0899_SYNCDSTRM , 0x00 },
1258 { STB0899_SYNCDSTRL , 0x00 },
1259 { STB0899_CFGPDELSTATUS1 , 0x10 },
1260 { STB0899_CFGPDELSTATUS2 , 0x00 },
1261 { STB0899_BBFERRORM , 0x00 },
1262 { STB0899_BBFERRORL , 0x00 },
1263 { STB0899_UPKTERRORM , 0x00 },
1264 { STB0899_UPKTERRORL , 0x00 },
1265 { 0xffff , 0xff },
1266 };
1267
1268 static struct stb0899_config tt3200_config = {
1269 .init_dev = tt3200_stb0899_s1_init_1,
1270 .init_s2_demod = stb0899_s2_init_2,
1271 .init_s1_demod = tt3200_stb0899_s1_init_3,
1272 .init_s2_fec = stb0899_s2_init_4,
1273 .init_tst = stb0899_s1_init_5,
1274
1275 .postproc = NULL,
1276
1277 .demod_address = 0x68,
1278
1279 .xtal_freq = 27000000,
1280 .inversion = IQ_SWAP_ON, /* 1 */
1281
1282 .lo_clk = 76500000,
1283 .hi_clk = 99000000,
1284
1285 .esno_ave = STB0899_DVBS2_ESNO_AVE,
1286 .esno_quant = STB0899_DVBS2_ESNO_QUANT,
1287 .avframes_coarse = STB0899_DVBS2_AVFRAMES_COARSE,
1288 .avframes_fine = STB0899_DVBS2_AVFRAMES_FINE,
1289 .miss_threshold = STB0899_DVBS2_MISS_THRESHOLD,
1290 .uwp_threshold_acq = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
1291 .uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
1292 .uwp_threshold_sof = STB0899_DVBS2_UWP_THRESHOLD_SOF,
1293 .sof_search_timeout = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
1294
1295 .btr_nco_bits = STB0899_DVBS2_BTR_NCO_BITS,
1296 .btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
1297 .crl_nco_bits = STB0899_DVBS2_CRL_NCO_BITS,
1298 .ldpc_max_iter = STB0899_DVBS2_LDPC_MAX_ITER,
1299
1300 .tuner_get_frequency = stb6100_get_frequency,
1301 .tuner_set_frequency = stb6100_set_frequency,
1302 .tuner_set_bandwidth = stb6100_set_bandwidth,
1303 .tuner_get_bandwidth = stb6100_get_bandwidth,
1304 .tuner_set_rfsiggain = NULL
1305 };
1306
1307 static struct stb6100_config tt3200_stb6100_config = {
1308 .tuner_address = 0x60,
1309 .refclock = 27000000,
1310 };
1311
1312 static void frontend_init(struct budget_ci *budget_ci)
1313 {
1314 switch (budget_ci->budget.dev->pci->subsystem_device) {
1315 case 0x100c: // Hauppauge/TT Nova-CI budget (stv0299/ALPS BSRU6(tsa5059))
1316 budget_ci->budget.dvb_frontend =
1317 dvb_attach(stv0299_attach, &alps_bsru6_config, &budget_ci->budget.i2c_adap);
1318 if (budget_ci->budget.dvb_frontend) {
1319 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsru6_tuner_set_params;
1320 budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1321 break;
1322 }
1323 break;
1324
1325 case 0x100f: // Hauppauge/TT Nova-CI budget (stv0299b/Philips su1278(tsa5059))
1326 budget_ci->budget.dvb_frontend =
1327 dvb_attach(stv0299_attach, &philips_su1278_tt_config, &budget_ci->budget.i2c_adap);
1328 if (budget_ci->budget.dvb_frontend) {
1329 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_su1278_tt_tuner_set_params;
1330 break;
1331 }
1332 break;
1333
1334 case 0x1010: // TT DVB-C CI budget (stv0297/Philips tdm1316l(tda6651tt))
1335 budget_ci->tuner_pll_address = 0x61;
1336 budget_ci->budget.dvb_frontend =
1337 dvb_attach(stv0297_attach, &dvbc_philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1338 if (budget_ci->budget.dvb_frontend) {
1339 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = dvbc_philips_tdm1316l_tuner_set_params;
1340 break;
1341 }
1342 break;
1343
1344 case 0x1011: // Hauppauge/TT Nova-T budget (tda10045/Philips tdm1316l(tda6651tt) + TDA9889)
1345 budget_ci->tuner_pll_address = 0x63;
1346 budget_ci->budget.dvb_frontend =
1347 dvb_attach(tda10045_attach, &philips_tdm1316l_config, &budget_ci->budget.i2c_adap);
1348 if (budget_ci->budget.dvb_frontend) {
1349 budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1350 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1351 break;
1352 }
1353 break;
1354
1355 case 0x1012: // TT DVB-T CI budget (tda10046/Philips tdm1316l(tda6651tt))
1356 budget_ci->tuner_pll_address = 0x60;
1357 budget_ci->budget.dvb_frontend =
1358 dvb_attach(tda10046_attach, &philips_tdm1316l_config_invert, &budget_ci->budget.i2c_adap);
1359 if (budget_ci->budget.dvb_frontend) {
1360 budget_ci->budget.dvb_frontend->ops.tuner_ops.init = philips_tdm1316l_tuner_init;
1361 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = philips_tdm1316l_tuner_set_params;
1362 break;
1363 }
1364 break;
1365
1366 case 0x1017: // TT S-1500 PCI
1367 budget_ci->budget.dvb_frontend = dvb_attach(stv0299_attach, &alps_bsbe1_config, &budget_ci->budget.i2c_adap);
1368 if (budget_ci->budget.dvb_frontend) {
1369 budget_ci->budget.dvb_frontend->ops.tuner_ops.set_params = alps_bsbe1_tuner_set_params;
1370 budget_ci->budget.dvb_frontend->tuner_priv = &budget_ci->budget.i2c_adap;
1371
1372 budget_ci->budget.dvb_frontend->ops.dishnetwork_send_legacy_command = NULL;
1373 if (dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, LNBP21_LLC, 0) == NULL) {
1374 printk("%s: No LNBP21 found!\n", __func__);
1375 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1376 budget_ci->budget.dvb_frontend = NULL;
1377 }
1378 }
1379 break;
1380
1381 case 0x101a: /* TT Budget-C-1501 (philips tda10023/philips tda8274A) */
1382 budget_ci->budget.dvb_frontend = dvb_attach(tda10023_attach, &tda10023_config, &budget_ci->budget.i2c_adap, 0x48);
1383 if (budget_ci->budget.dvb_frontend) {
1384 if (dvb_attach(tda827x_attach, budget_ci->budget.dvb_frontend, 0x61, &budget_ci->budget.i2c_adap, &tda827x_config) == NULL) {
1385 printk(KERN_ERR "%s: No tda827x found!\n", __func__);
1386 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1387 budget_ci->budget.dvb_frontend = NULL;
1388 }
1389 }
1390 break;
1391
1392 case 0x101b: /* TT S-1500B (BSBE1-D01A - STV0288/STB6000/LNBP21) */
1393 budget_ci->budget.dvb_frontend = dvb_attach(stv0288_attach, &stv0288_bsbe1_d01a_config, &budget_ci->budget.i2c_adap);
1394 if (budget_ci->budget.dvb_frontend) {
1395 if (dvb_attach(stb6000_attach, budget_ci->budget.dvb_frontend, 0x63, &budget_ci->budget.i2c_adap)) {
1396 if (!dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, 0, 0)) {
1397 printk(KERN_ERR "%s: No LNBP21 found!\n", __func__);
1398 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1399 budget_ci->budget.dvb_frontend = NULL;
1400 }
1401 } else {
1402 printk(KERN_ERR "%s: No STB6000 found!\n", __func__);
1403 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1404 budget_ci->budget.dvb_frontend = NULL;
1405 }
1406 }
1407 break;
1408
1409 case 0x1019: // TT S2-3200 PCI
1410 /*
1411 * NOTE! on some STB0899 versions, the internal PLL takes a longer time
1412 * to settle, aka LOCK. On the older revisions of the chip, we don't see
1413 * this, as a result on the newer chips the entire clock tree, will not
1414 * be stable after a freshly POWER 'ed up situation.
1415 * In this case, we should RESET the STB0899 (Active LOW) and wait for
1416 * PLL stabilization.
1417 *
1418 * On the TT S2 3200 and clones, the STB0899 demodulator's RESETB is
1419 * connected to the SAA7146 GPIO, GPIO2, Pin 142
1420 */
1421 /* Reset Demodulator */
1422 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTLO);
1423 /* Wait for everything to die */
1424 msleep(50);
1425 /* Pull it up out of Reset state */
1426 saa7146_setgpio(budget_ci->budget.dev, 2, SAA7146_GPIO_OUTHI);
1427 /* Wait for PLL to stabilize */
1428 msleep(250);
1429 /*
1430 * PLL state should be stable now. Ideally, we should check
1431 * for PLL LOCK status. But well, never mind!
1432 */
1433 budget_ci->budget.dvb_frontend = dvb_attach(stb0899_attach, &tt3200_config, &budget_ci->budget.i2c_adap);
1434 if (budget_ci->budget.dvb_frontend) {
1435 if (dvb_attach(stb6100_attach, budget_ci->budget.dvb_frontend, &tt3200_stb6100_config, &budget_ci->budget.i2c_adap)) {
1436 if (!dvb_attach(lnbp21_attach, budget_ci->budget.dvb_frontend, &budget_ci->budget.i2c_adap, 0, 0)) {
1437 printk("%s: No LNBP21 found!\n", __func__);
1438 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1439 budget_ci->budget.dvb_frontend = NULL;
1440 }
1441 } else {
1442 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1443 budget_ci->budget.dvb_frontend = NULL;
1444 }
1445 }
1446 break;
1447
1448 }
1449
1450 if (budget_ci->budget.dvb_frontend == NULL) {
1451 printk("budget-ci: A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
1452 budget_ci->budget.dev->pci->vendor,
1453 budget_ci->budget.dev->pci->device,
1454 budget_ci->budget.dev->pci->subsystem_vendor,
1455 budget_ci->budget.dev->pci->subsystem_device);
1456 } else {
1457 if (dvb_register_frontend
1458 (&budget_ci->budget.dvb_adapter, budget_ci->budget.dvb_frontend)) {
1459 printk("budget-ci: Frontend registration failed!\n");
1460 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1461 budget_ci->budget.dvb_frontend = NULL;
1462 }
1463 }
1464 }
1465
1466 static int budget_ci_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1467 {
1468 struct budget_ci *budget_ci;
1469 int err;
1470
1471 budget_ci = kzalloc(sizeof(struct budget_ci), GFP_KERNEL);
1472 if (!budget_ci) {
1473 err = -ENOMEM;
1474 goto out1;
1475 }
1476
1477 dprintk(2, "budget_ci: %p\n", budget_ci);
1478
1479 dev->ext_priv = budget_ci;
1480
1481 err = ttpci_budget_init(&budget_ci->budget, dev, info, THIS_MODULE,
1482 adapter_nr);
1483 if (err)
1484 goto out2;
1485
1486 err = msp430_ir_init(budget_ci);
1487 if (err)
1488 goto out3;
1489
1490 ciintf_init(budget_ci);
1491
1492 budget_ci->budget.dvb_adapter.priv = budget_ci;
1493 frontend_init(budget_ci);
1494
1495 ttpci_budget_init_hooks(&budget_ci->budget);
1496
1497 return 0;
1498
1499 out3:
1500 ttpci_budget_deinit(&budget_ci->budget);
1501 out2:
1502 kfree(budget_ci);
1503 out1:
1504 return err;
1505 }
1506
1507 static int budget_ci_detach(struct saa7146_dev *dev)
1508 {
1509 struct budget_ci *budget_ci = (struct budget_ci *) dev->ext_priv;
1510 struct saa7146_dev *saa = budget_ci->budget.dev;
1511 int err;
1512
1513 if (budget_ci->budget.ci_present)
1514 ciintf_deinit(budget_ci);
1515 msp430_ir_deinit(budget_ci);
1516 if (budget_ci->budget.dvb_frontend) {
1517 dvb_unregister_frontend(budget_ci->budget.dvb_frontend);
1518 dvb_frontend_detach(budget_ci->budget.dvb_frontend);
1519 }
1520 err = ttpci_budget_deinit(&budget_ci->budget);
1521
1522 // disable frontend and CI interface
1523 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
1524
1525 kfree(budget_ci);
1526
1527 return err;
1528 }
1529
1530 static struct saa7146_extension budget_extension;
1531
1532 MAKE_BUDGET_INFO(ttbs2, "TT-Budget/S-1500 PCI", BUDGET_TT);
1533 MAKE_BUDGET_INFO(ttbci, "TT-Budget/WinTV-NOVA-CI PCI", BUDGET_TT_HW_DISEQC);
1534 MAKE_BUDGET_INFO(ttbt2, "TT-Budget/WinTV-NOVA-T PCI", BUDGET_TT);
1535 MAKE_BUDGET_INFO(ttbtci, "TT-Budget-T-CI PCI", BUDGET_TT);
1536 MAKE_BUDGET_INFO(ttbcci, "TT-Budget-C-CI PCI", BUDGET_TT);
1537 MAKE_BUDGET_INFO(ttc1501, "TT-Budget C-1501 PCI", BUDGET_TT);
1538 MAKE_BUDGET_INFO(tt3200, "TT-Budget S2-3200 PCI", BUDGET_TT);
1539 MAKE_BUDGET_INFO(ttbs1500b, "TT-Budget S-1500B PCI", BUDGET_TT);
1540
1541 static struct pci_device_id pci_tbl[] = {
1542 MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100c),
1543 MAKE_EXTENSION_PCI(ttbci, 0x13c2, 0x100f),
1544 MAKE_EXTENSION_PCI(ttbcci, 0x13c2, 0x1010),
1545 MAKE_EXTENSION_PCI(ttbt2, 0x13c2, 0x1011),
1546 MAKE_EXTENSION_PCI(ttbtci, 0x13c2, 0x1012),
1547 MAKE_EXTENSION_PCI(ttbs2, 0x13c2, 0x1017),
1548 MAKE_EXTENSION_PCI(ttc1501, 0x13c2, 0x101a),
1549 MAKE_EXTENSION_PCI(tt3200, 0x13c2, 0x1019),
1550 MAKE_EXTENSION_PCI(ttbs1500b, 0x13c2, 0x101b),
1551 {
1552 .vendor = 0,
1553 }
1554 };
1555
1556 MODULE_DEVICE_TABLE(pci, pci_tbl);
1557
1558 static struct saa7146_extension budget_extension = {
1559 .name = "budget_ci dvb",
1560 .flags = SAA7146_USE_I2C_IRQ,
1561
1562 .module = THIS_MODULE,
1563 .pci_tbl = &pci_tbl[0],
1564 .attach = budget_ci_attach,
1565 .detach = budget_ci_detach,
1566
1567 .irq_mask = MASK_03 | MASK_06 | MASK_10,
1568 .irq_func = budget_ci_irq,
1569 };
1570
1571 static int __init budget_ci_init(void)
1572 {
1573 return saa7146_register_extension(&budget_extension);
1574 }
1575
1576 static void __exit budget_ci_exit(void)
1577 {
1578 saa7146_unregister_extension(&budget_extension);
1579 }
1580
1581 module_init(budget_ci_init);
1582 module_exit(budget_ci_exit);
1583
1584 MODULE_LICENSE("GPL");
1585 MODULE_AUTHOR("Michael Hunold, Jack Thomasson, Andrew de Quincey, others");
1586 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1587 "budget PCI DVB cards w/ CI-module produced by "
1588 "Siemens, Technotrend, Hauppauge");
Linux kernel - Deliverables
This page took 0.097213 seconds and 5 git commands to generate.