?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / pci / ttpci / budget-av.c
blobabc98f1ad26c3f30435fca60a69ee40b161cc7dd
1 /*
2 * budget-av.c: driver for the SAA7146 based Budget DVB cards
3 * with analog video in
4 *
5 * Compiled from various sources by Michael Hunold <michael@mihu.de>
6 *
7 * CI interface support (c) 2004 Olivier Gournet <ogournet@anevia.com> &
8 * Andrew de Quincey <adq_dvb@lidskialf.net>
9 *
10 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
11 *
12 * Copyright (C) 1999-2002 Ralph Metzler
13 * & Marcus Metzler for convergence integrated media GmbH
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * To obtain the license, point your browser to
27 * http://www.gnu.org/copyleft/gpl.html
28 *
29 *
30 * the project's page is at https://linuxtv.org
31 */
32
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34
35 #include "budget.h"
36 #include "stv0299.h"
37 #include "stb0899_drv.h"
38 #include "stb0899_reg.h"
39 #include "stb0899_cfg.h"
40 #include "tda8261.h"
41 #include "tda8261_cfg.h"
42 #include "tda1002x.h"
43 #include "tda1004x.h"
44 #include "tua6100.h"
45 #include "dvb-pll.h"
46 #include <media/drv-intf/saa7146_vv.h>
47 #include <linux/module.h>
48 #include <linux/errno.h>
49 #include <linux/slab.h>
50 #include <linux/interrupt.h>
51 #include <linux/input.h>
52 #include <linux/spinlock.h>
53
54 #include <media/dvb_ca_en50221.h>
55
56 #define DEBICICAM 0x02420000
57
58 #define SLOTSTATUS_NONE 1
59 #define SLOTSTATUS_PRESENT 2
60 #define SLOTSTATUS_RESET 4
61 #define SLOTSTATUS_READY 8
62 #define SLOTSTATUS_OCCUPIED (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
63
64 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
65
66 struct budget_av {
67 struct budget budget;
68 struct video_device vd;
69 int cur_input;
70 int has_saa7113;
71 struct tasklet_struct ciintf_irq_tasklet;
72 int slot_status;
73 struct dvb_ca_en50221 ca;
74 u8 reinitialise_demod:1;
75 };
76
77 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot);
78
79
80 /* GPIO Connections:
81 * 0 - Vcc/Reset (Reset is controlled by capacitor). Resets the frontend *AS WELL*!
82 * 1 - CI memory select 0=>IO memory, 1=>Attribute Memory
83 * 2 - CI Card Enable (Active Low)
84 * 3 - CI Card Detect
85 */
86
87 /****************************************************************************
88 * INITIALIZATION
89 ****************************************************************************/
90
91 static u8 i2c_readreg(struct i2c_adapter *i2c, u8 id, u8 reg)
92 {
93 u8 mm1[] = { 0x00 };
94 u8 mm2[] = { 0x00 };
95 struct i2c_msg msgs[2];
96
97 msgs[0].flags = 0;
98 msgs[1].flags = I2C_M_RD;
99 msgs[0].addr = msgs[1].addr = id / 2;
100 mm1[0] = reg;
101 msgs[0].len = 1;
102 msgs[1].len = 1;
103 msgs[0].buf = mm1;
104 msgs[1].buf = mm2;
105
106 i2c_transfer(i2c, msgs, 2);
107
108 return mm2[0];
109 }
110
111 static int i2c_readregs(struct i2c_adapter *i2c, u8 id, u8 reg, u8 * buf, u8 len)
112 {
113 u8 mm1[] = { reg };
114 struct i2c_msg msgs[2] = {
115 {.addr = id / 2,.flags = 0,.buf = mm1,.len = 1},
116 {.addr = id / 2,.flags = I2C_M_RD,.buf = buf,.len = len}
117 };
118
119 if (i2c_transfer(i2c, msgs, 2) != 2)
120 return -EIO;
121
122 return 0;
123 }
124
125 static int i2c_writereg(struct i2c_adapter *i2c, u8 id, u8 reg, u8 val)
126 {
127 u8 msg[2] = { reg, val };
128 struct i2c_msg msgs;
129
130 msgs.flags = 0;
131 msgs.addr = id / 2;
132 msgs.len = 2;
133 msgs.buf = msg;
134 return i2c_transfer(i2c, &msgs, 1);
135 }
136
137 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
138 {
139 struct budget_av *budget_av = (struct budget_av *) ca->data;
140 int result;
141
142 if (slot != 0)
143 return -EINVAL;
144
145 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
146 udelay(1);
147
148 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 0xfff, 1, 0, 1);
149 if (result == -ETIMEDOUT) {
150 ciintf_slot_shutdown(ca, slot);
151 pr_info("cam ejected 1\n");
152 }
153 return result;
154 }
155
156 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
157 {
158 struct budget_av *budget_av = (struct budget_av *) ca->data;
159 int result;
160
161 if (slot != 0)
162 return -EINVAL;
163
164 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
165 udelay(1);
166
167 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 0xfff, 1, value, 0, 1);
168 if (result == -ETIMEDOUT) {
169 ciintf_slot_shutdown(ca, slot);
170 pr_info("cam ejected 2\n");
171 }
172 return result;
173 }
174
175 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
176 {
177 struct budget_av *budget_av = (struct budget_av *) ca->data;
178 int result;
179
180 if (slot != 0)
181 return -EINVAL;
182
183 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
184 udelay(1);
185
186 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0);
187 if (result == -ETIMEDOUT) {
188 ciintf_slot_shutdown(ca, slot);
189 pr_info("cam ejected 3\n");
190 return -ETIMEDOUT;
191 }
192 return result;
193 }
194
195 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
196 {
197 struct budget_av *budget_av = (struct budget_av *) ca->data;
198 int result;
199
200 if (slot != 0)
201 return -EINVAL;
202
203 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
204 udelay(1);
205
206 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 3, 1, value, 0, 0);
207 if (result == -ETIMEDOUT) {
208 ciintf_slot_shutdown(ca, slot);
209 pr_info("cam ejected 5\n");
210 }
211 return result;
212 }
213
214 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
215 {
216 struct budget_av *budget_av = (struct budget_av *) ca->data;
217 struct saa7146_dev *saa = budget_av->budget.dev;
218
219 if (slot != 0)
220 return -EINVAL;
221
222 dprintk(1, "ciintf_slot_reset\n");
223 budget_av->slot_status = SLOTSTATUS_RESET;
224
225 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
226
227 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); /* Vcc off */
228 msleep(2);
229 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); /* Vcc on */
230 msleep(20); /* 20 ms Vcc settling time */
231
232 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); /* enable card */
233 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
234 msleep(20);
235
236 /* reinitialise the frontend if necessary */
237 if (budget_av->reinitialise_demod)
238 dvb_frontend_reinitialise(budget_av->budget.dvb_frontend);
239
240 return 0;
241 }
242
243 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
244 {
245 struct budget_av *budget_av = (struct budget_av *) ca->data;
246 struct saa7146_dev *saa = budget_av->budget.dev;
247
248 if (slot != 0)
249 return -EINVAL;
250
251 dprintk(1, "ciintf_slot_shutdown\n");
252
253 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
254 budget_av->slot_status = SLOTSTATUS_NONE;
255
256 return 0;
257 }
258
259 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
260 {
261 struct budget_av *budget_av = (struct budget_av *) ca->data;
262 struct saa7146_dev *saa = budget_av->budget.dev;
263
264 if (slot != 0)
265 return -EINVAL;
266
267 dprintk(1, "ciintf_slot_ts_enable: %d\n", budget_av->slot_status);
268
269 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
270
271 return 0;
272 }
273
274 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
275 {
276 struct budget_av *budget_av = (struct budget_av *) ca->data;
277 struct saa7146_dev *saa = budget_av->budget.dev;
278 int result;
279
280 if (slot != 0)
281 return -EINVAL;
282
283 /* test the card detect line - needs to be done carefully
284 * since it never goes high for some CAMs on this interface (e.g. topuptv) */
285 if (budget_av->slot_status == SLOTSTATUS_NONE) {
286 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
287 udelay(1);
288 if (saa7146_read(saa, PSR) & MASK_06) {
289 if (budget_av->slot_status == SLOTSTATUS_NONE) {
290 budget_av->slot_status = SLOTSTATUS_PRESENT;
291 pr_info("cam inserted A\n");
292 }
293 }
294 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
295 }
296
297 /* We also try and read from IO memory to work round the above detection bug. If
298 * there is no CAM, we will get a timeout. Only done if there is no cam
299 * present, since this test actually breaks some cams :(
300 *
301 * if the CI interface is not open, we also do the above test since we
302 * don't care if the cam has problems - we'll be resetting it on open() anyway */
303 if ((budget_av->slot_status == SLOTSTATUS_NONE) || (!open)) {
304 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
305 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, 0, 1, 0, 1);
306 if ((result >= 0) && (budget_av->slot_status == SLOTSTATUS_NONE)) {
307 budget_av->slot_status = SLOTSTATUS_PRESENT;
308 pr_info("cam inserted B\n");
309 } else if (result < 0) {
310 if (budget_av->slot_status != SLOTSTATUS_NONE) {
311 ciintf_slot_shutdown(ca, slot);
312 pr_info("cam ejected 5\n");
313 return 0;
314 }
315 }
316 }
317
318 /* read from attribute memory in reset/ready state to know when the CAM is ready */
319 if (budget_av->slot_status == SLOTSTATUS_RESET) {
320 result = ciintf_read_attribute_mem(ca, slot, 0);
321 if (result == 0x1d) {
322 budget_av->slot_status = SLOTSTATUS_READY;
323 }
324 }
325
326 /* work out correct return code */
327 if (budget_av->slot_status != SLOTSTATUS_NONE) {
328 if (budget_av->slot_status & SLOTSTATUS_READY) {
329 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
330 }
331 return DVB_CA_EN50221_POLL_CAM_PRESENT;
332 }
333 return 0;
334 }
335
336 static int ciintf_init(struct budget_av *budget_av)
337 {
338 struct saa7146_dev *saa = budget_av->budget.dev;
339 int result;
340
341 memset(&budget_av->ca, 0, sizeof(struct dvb_ca_en50221));
342
343 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
344 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
345 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO);
346 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
347
348 /* Enable DEBI pins */
349 saa7146_write(saa, MC1, MASK_27 | MASK_11);
350
351 /* register CI interface */
352 budget_av->ca.owner = THIS_MODULE;
353 budget_av->ca.read_attribute_mem = ciintf_read_attribute_mem;
354 budget_av->ca.write_attribute_mem = ciintf_write_attribute_mem;
355 budget_av->ca.read_cam_control = ciintf_read_cam_control;
356 budget_av->ca.write_cam_control = ciintf_write_cam_control;
357 budget_av->ca.slot_reset = ciintf_slot_reset;
358 budget_av->ca.slot_shutdown = ciintf_slot_shutdown;
359 budget_av->ca.slot_ts_enable = ciintf_slot_ts_enable;
360 budget_av->ca.poll_slot_status = ciintf_poll_slot_status;
361 budget_av->ca.data = budget_av;
362 budget_av->budget.ci_present = 1;
363 budget_av->slot_status = SLOTSTATUS_NONE;
364
365 if ((result = dvb_ca_en50221_init(&budget_av->budget.dvb_adapter,
366 &budget_av->ca, 0, 1)) != 0) {
367 pr_err("ci initialisation failed\n");
368 goto error;
369 }
370
371 pr_info("ci interface initialised\n");
372 return 0;
373
374 error:
375 saa7146_write(saa, MC1, MASK_27);
376 return result;
377 }
378
379 static void ciintf_deinit(struct budget_av *budget_av)
380 {
381 struct saa7146_dev *saa = budget_av->budget.dev;
382
383 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
384 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
385 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
386 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
387
388 /* release the CA device */
389 dvb_ca_en50221_release(&budget_av->ca);
390
391 /* disable DEBI pins */
392 saa7146_write(saa, MC1, MASK_27);
393 }
394
395
396 static const u8 saa7113_tab[] = {
397 0x01, 0x08,
398 0x02, 0xc0,
399 0x03, 0x33,
400 0x04, 0x00,
401 0x05, 0x00,
402 0x06, 0xeb,
403 0x07, 0xe0,
404 0x08, 0x28,
405 0x09, 0x00,
406 0x0a, 0x80,
407 0x0b, 0x47,
408 0x0c, 0x40,
409 0x0d, 0x00,
410 0x0e, 0x01,
411 0x0f, 0x44,
412
413 0x10, 0x08,
414 0x11, 0x0c,
415 0x12, 0x7b,
416 0x13, 0x00,
417 0x15, 0x00, 0x16, 0x00, 0x17, 0x00,
418
419 0x57, 0xff,
420 0x40, 0x82, 0x58, 0x00, 0x59, 0x54, 0x5a, 0x07,
421 0x5b, 0x83, 0x5e, 0x00,
422 0xff
423 };
424
425 static int saa7113_init(struct budget_av *budget_av)
426 {
427 struct budget *budget = &budget_av->budget;
428 struct saa7146_dev *saa = budget->dev;
429 const u8 *data = saa7113_tab;
430
431 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI);
432 msleep(200);
433
434 if (i2c_writereg(&budget->i2c_adap, 0x4a, 0x01, 0x08) != 1) {
435 dprintk(1, "saa7113 not found on KNC card\n");
436 return -ENODEV;
437 }
438
439 dprintk(1, "saa7113 detected and initializing\n");
440
441 while (*data != 0xff) {
442 i2c_writereg(&budget->i2c_adap, 0x4a, *data, *(data + 1));
443 data += 2;
444 }
445
446 dprintk(1, "saa7113 status=%02x\n", i2c_readreg(&budget->i2c_adap, 0x4a, 0x1f));
447
448 return 0;
449 }
450
451 static int saa7113_setinput(struct budget_av *budget_av, int input)
452 {
453 struct budget *budget = &budget_av->budget;
454
455 if (1 != budget_av->has_saa7113)
456 return -ENODEV;
457
458 if (input == 1) {
459 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc7);
460 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x80);
461 } else if (input == 0) {
462 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc0);
463 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x00);
464 } else
465 return -EINVAL;
466
467 budget_av->cur_input = input;
468 return 0;
469 }
470
471
472 static int philips_su1278_ty_ci_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
473 {
474 u8 aclk = 0;
475 u8 bclk = 0;
476 u8 m1;
477
478 aclk = 0xb5;
479 if (srate < 2000000)
480 bclk = 0x86;
481 else if (srate < 5000000)
482 bclk = 0x89;
483 else if (srate < 15000000)
484 bclk = 0x8f;
485 else if (srate < 45000000)
486 bclk = 0x95;
487
488 m1 = 0x14;
489 if (srate < 4000000)
490 m1 = 0x10;
491
492 stv0299_writereg(fe, 0x13, aclk);
493 stv0299_writereg(fe, 0x14, bclk);
494 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
495 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
496 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
497 stv0299_writereg(fe, 0x0f, 0x80 | m1);
498
499 return 0;
500 }
501
502 static int philips_su1278_ty_ci_tuner_set_params(struct dvb_frontend *fe)
503 {
504 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
505 u32 div;
506 u8 buf[4];
507 struct budget *budget = (struct budget *) fe->dvb->priv;
508 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
509
510 if ((c->frequency < 950000) || (c->frequency > 2150000))
511 return -EINVAL;
512
513 div = (c->frequency + (125 - 1)) / 125; /* round correctly */
514 buf[0] = (div >> 8) & 0x7f;
515 buf[1] = div & 0xff;
516 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
517 buf[3] = 0x20;
518
519 if (c->symbol_rate < 4000000)
520 buf[3] |= 1;
521
522 if (c->frequency < 1250000)
523 buf[3] |= 0;
524 else if (c->frequency < 1550000)
525 buf[3] |= 0x40;
526 else if (c->frequency < 2050000)
527 buf[3] |= 0x80;
528 else if (c->frequency < 2150000)
529 buf[3] |= 0xC0;
530
531 if (fe->ops.i2c_gate_ctrl)
532 fe->ops.i2c_gate_ctrl(fe, 1);
533 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
534 return -EIO;
535 return 0;
536 }
537
538 static u8 typhoon_cinergy1200s_inittab[] = {
539 0x01, 0x15,
540 0x02, 0x30,
541 0x03, 0x00,
542 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
543 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
544 0x06, 0x40, /* DAC not used, set to high impendance mode */
545 0x07, 0x00, /* DAC LSB */
546 0x08, 0x40, /* DiSEqC off */
547 0x09, 0x00, /* FIFO */
548 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
549 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
550 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
551 0x10, 0x3f, // AGC2 0x3d
552 0x11, 0x84,
553 0x12, 0xb9,
554 0x15, 0xc9, // lock detector threshold
555 0x16, 0x00,
556 0x17, 0x00,
557 0x18, 0x00,
558 0x19, 0x00,
559 0x1a, 0x00,
560 0x1f, 0x50,
561 0x20, 0x00,
562 0x21, 0x00,
563 0x22, 0x00,
564 0x23, 0x00,
565 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
566 0x29, 0x1e, // 1/2 threshold
567 0x2a, 0x14, // 2/3 threshold
568 0x2b, 0x0f, // 3/4 threshold
569 0x2c, 0x09, // 5/6 threshold
570 0x2d, 0x05, // 7/8 threshold
571 0x2e, 0x01,
572 0x31, 0x1f, // test all FECs
573 0x32, 0x19, // viterbi and synchro search
574 0x33, 0xfc, // rs control
575 0x34, 0x93, // error control
576 0x0f, 0x92,
577 0xff, 0xff
578 };
579
580 static const struct stv0299_config typhoon_config = {
581 .demod_address = 0x68,
582 .inittab = typhoon_cinergy1200s_inittab,
583 .mclk = 88000000UL,
584 .invert = 0,
585 .skip_reinit = 0,
586 .lock_output = STV0299_LOCKOUTPUT_1,
587 .volt13_op0_op1 = STV0299_VOLT13_OP0,
588 .min_delay_ms = 100,
589 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
590 };
591
592
593 static const struct stv0299_config cinergy_1200s_config = {
594 .demod_address = 0x68,
595 .inittab = typhoon_cinergy1200s_inittab,
596 .mclk = 88000000UL,
597 .invert = 0,
598 .skip_reinit = 0,
599 .lock_output = STV0299_LOCKOUTPUT_0,
600 .volt13_op0_op1 = STV0299_VOLT13_OP0,
601 .min_delay_ms = 100,
602 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
603 };
604
605 static const struct stv0299_config cinergy_1200s_1894_0010_config = {
606 .demod_address = 0x68,
607 .inittab = typhoon_cinergy1200s_inittab,
608 .mclk = 88000000UL,
609 .invert = 1,
610 .skip_reinit = 0,
611 .lock_output = STV0299_LOCKOUTPUT_1,
612 .volt13_op0_op1 = STV0299_VOLT13_OP0,
613 .min_delay_ms = 100,
614 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
615 };
616
617 static int philips_cu1216_tuner_set_params(struct dvb_frontend *fe)
618 {
619 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
620 struct budget *budget = (struct budget *) fe->dvb->priv;
621 u8 buf[6];
622 struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
623 int i;
624
625 #define CU1216_IF 36125000
626 #define TUNER_MUL 62500
627
628 u32 div = (c->frequency + CU1216_IF + TUNER_MUL / 2) / TUNER_MUL;
629
630 buf[0] = (div >> 8) & 0x7f;
631 buf[1] = div & 0xff;
632 buf[2] = 0xce;
633 buf[3] = (c->frequency < 150000000 ? 0x01 :
634 c->frequency < 445000000 ? 0x02 : 0x04);
635 buf[4] = 0xde;
636 buf[5] = 0x20;
637
638 if (fe->ops.i2c_gate_ctrl)
639 fe->ops.i2c_gate_ctrl(fe, 1);
640 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
641 return -EIO;
642
643 /* wait for the pll lock */
644 msg.flags = I2C_M_RD;
645 msg.len = 1;
646 for (i = 0; i < 20; i++) {
647 if (fe->ops.i2c_gate_ctrl)
648 fe->ops.i2c_gate_ctrl(fe, 1);
649 if (i2c_transfer(&budget->i2c_adap, &msg, 1) == 1 && (buf[0] & 0x40))
650 break;
651 msleep(10);
652 }
653
654 /* switch the charge pump to the lower current */
655 msg.flags = 0;
656 msg.len = 2;
657 msg.buf = &buf[2];
658 buf[2] &= ~0x40;
659 if (fe->ops.i2c_gate_ctrl)
660 fe->ops.i2c_gate_ctrl(fe, 1);
661 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
662 return -EIO;
663
664 return 0;
665 }
666
667 static struct tda1002x_config philips_cu1216_config = {
668 .demod_address = 0x0c,
669 .invert = 1,
670 };
671
672 static struct tda1002x_config philips_cu1216_config_altaddress = {
673 .demod_address = 0x0d,
674 .invert = 0,
675 };
676
677 static struct tda10023_config philips_cu1216_tda10023_config = {
678 .demod_address = 0x0c,
679 .invert = 1,
680 };
681
682 static int philips_tu1216_tuner_init(struct dvb_frontend *fe)
683 {
684 struct budget *budget = (struct budget *) fe->dvb->priv;
685 static u8 tu1216_init[] = { 0x0b, 0xf5, 0x85, 0xab };
686 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) };
687
688 // setup PLL configuration
689 if (fe->ops.i2c_gate_ctrl)
690 fe->ops.i2c_gate_ctrl(fe, 1);
691 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
692 return -EIO;
693 msleep(1);
694
695 return 0;
696 }
697
698 static int philips_tu1216_tuner_set_params(struct dvb_frontend *fe)
699 {
700 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
701 struct budget *budget = (struct budget *) fe->dvb->priv;
702 u8 tuner_buf[4];
703 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tuner_buf,.len =
704 sizeof(tuner_buf) };
705 int tuner_frequency = 0;
706 u8 band, cp, filter;
707
708 // determine charge pump
709 tuner_frequency = c->frequency + 36166000;
710 if (tuner_frequency < 87000000)
711 return -EINVAL;
712 else if (tuner_frequency < 130000000)
713 cp = 3;
714 else if (tuner_frequency < 160000000)
715 cp = 5;
716 else if (tuner_frequency < 200000000)
717 cp = 6;
718 else if (tuner_frequency < 290000000)
719 cp = 3;
720 else if (tuner_frequency < 420000000)
721 cp = 5;
722 else if (tuner_frequency < 480000000)
723 cp = 6;
724 else if (tuner_frequency < 620000000)
725 cp = 3;
726 else if (tuner_frequency < 830000000)
727 cp = 5;
728 else if (tuner_frequency < 895000000)
729 cp = 7;
730 else
731 return -EINVAL;
732
733 // determine band
734 if (c->frequency < 49000000)
735 return -EINVAL;
736 else if (c->frequency < 161000000)
737 band = 1;
738 else if (c->frequency < 444000000)
739 band = 2;
740 else if (c->frequency < 861000000)
741 band = 4;
742 else
743 return -EINVAL;
744
745 // setup PLL filter
746 switch (c->bandwidth_hz) {
747 case 6000000:
748 filter = 0;
749 break;
750
751 case 7000000:
752 filter = 0;
753 break;
754
755 case 8000000:
756 filter = 1;
757 break;
758
759 default:
760 return -EINVAL;
761 }
762
763 // calculate divisor
764 // ((36166000+((1000000/6)/2)) + Finput)/(1000000/6)
765 tuner_frequency = (((c->frequency / 1000) * 6) + 217496) / 1000;
766
767 // setup tuner buffer
768 tuner_buf[0] = (tuner_frequency >> 8) & 0x7f;
769 tuner_buf[1] = tuner_frequency & 0xff;
770 tuner_buf[2] = 0xca;
771 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
772
773 if (fe->ops.i2c_gate_ctrl)
774 fe->ops.i2c_gate_ctrl(fe, 1);
775 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
776 return -EIO;
777
778 msleep(1);
779 return 0;
780 }
781
782 static int philips_tu1216_request_firmware(struct dvb_frontend *fe,
783 const struct firmware **fw, char *name)
784 {
785 struct budget *budget = (struct budget *) fe->dvb->priv;
786
787 return request_firmware(fw, name, &budget->dev->pci->dev);
788 }
789
790 static struct tda1004x_config philips_tu1216_config = {
791
792 .demod_address = 0x8,
793 .invert = 1,
794 .invert_oclk = 1,
795 .xtal_freq = TDA10046_XTAL_4M,
796 .agc_config = TDA10046_AGC_DEFAULT,
797 .if_freq = TDA10046_FREQ_3617,
798 .request_firmware = philips_tu1216_request_firmware,
799 };
800
801 static u8 philips_sd1878_inittab[] = {
802 0x01, 0x15,
803 0x02, 0x30,
804 0x03, 0x00,
805 0x04, 0x7d,
806 0x05, 0x35,
807 0x06, 0x40,
808 0x07, 0x00,
809 0x08, 0x43,
810 0x09, 0x02,
811 0x0C, 0x51,
812 0x0D, 0x82,
813 0x0E, 0x23,
814 0x10, 0x3f,
815 0x11, 0x84,
816 0x12, 0xb9,
817 0x15, 0xc9,
818 0x16, 0x19,
819 0x17, 0x8c,
820 0x18, 0x59,
821 0x19, 0xf8,
822 0x1a, 0xfe,
823 0x1c, 0x7f,
824 0x1d, 0x00,
825 0x1e, 0x00,
826 0x1f, 0x50,
827 0x20, 0x00,
828 0x21, 0x00,
829 0x22, 0x00,
830 0x23, 0x00,
831 0x28, 0x00,
832 0x29, 0x28,
833 0x2a, 0x14,
834 0x2b, 0x0f,
835 0x2c, 0x09,
836 0x2d, 0x09,
837 0x31, 0x1f,
838 0x32, 0x19,
839 0x33, 0xfc,
840 0x34, 0x93,
841 0xff, 0xff
842 };
843
844 static int philips_sd1878_ci_set_symbol_rate(struct dvb_frontend *fe,
845 u32 srate, u32 ratio)
846 {
847 u8 aclk = 0;
848 u8 bclk = 0;
849 u8 m1;
850
851 aclk = 0xb5;
852 if (srate < 2000000)
853 bclk = 0x86;
854 else if (srate < 5000000)
855 bclk = 0x89;
856 else if (srate < 15000000)
857 bclk = 0x8f;
858 else if (srate < 45000000)
859 bclk = 0x95;
860
861 m1 = 0x14;
862 if (srate < 4000000)
863 m1 = 0x10;
864
865 stv0299_writereg(fe, 0x0e, 0x23);
866 stv0299_writereg(fe, 0x0f, 0x94);
867 stv0299_writereg(fe, 0x10, 0x39);
868 stv0299_writereg(fe, 0x13, aclk);
869 stv0299_writereg(fe, 0x14, bclk);
870 stv0299_writereg(fe, 0x15, 0xc9);
871 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
872 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
873 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
874 stv0299_writereg(fe, 0x0f, 0x80 | m1);
875
876 return 0;
877 }
878
879 static const struct stv0299_config philips_sd1878_config = {
880 .demod_address = 0x68,
881 .inittab = philips_sd1878_inittab,
882 .mclk = 88000000UL,
883 .invert = 0,
884 .skip_reinit = 0,
885 .lock_output = STV0299_LOCKOUTPUT_1,
886 .volt13_op0_op1 = STV0299_VOLT13_OP0,
887 .min_delay_ms = 100,
888 .set_symbol_rate = philips_sd1878_ci_set_symbol_rate,
889 };
890
891 /* KNC1 DVB-S (STB0899) Inittab */
892 static const struct stb0899_s1_reg knc1_stb0899_s1_init_1[] = {
893
894 { STB0899_DEV_ID , 0x81 },
895 { STB0899_DISCNTRL1 , 0x32 },
896 { STB0899_DISCNTRL2 , 0x80 },
897 { STB0899_DISRX_ST0 , 0x04 },
898 { STB0899_DISRX_ST1 , 0x00 },
899 { STB0899_DISPARITY , 0x00 },
900 { STB0899_DISSTATUS , 0x20 },
901 { STB0899_DISF22 , 0x8c },
902 { STB0899_DISF22RX , 0x9a },
903 { STB0899_SYSREG , 0x0b },
904 { STB0899_ACRPRESC , 0x11 },
905 { STB0899_ACRDIV1 , 0x0a },
906 { STB0899_ACRDIV2 , 0x05 },
907 { STB0899_DACR1 , 0x00 },
908 { STB0899_DACR2 , 0x00 },
909 { STB0899_OUTCFG , 0x00 },
910 { STB0899_MODECFG , 0x00 },
911 { STB0899_IRQSTATUS_3 , 0x30 },
912 { STB0899_IRQSTATUS_2 , 0x00 },
913 { STB0899_IRQSTATUS_1 , 0x00 },
914 { STB0899_IRQSTATUS_0 , 0x00 },
915 { STB0899_IRQMSK_3 , 0xf3 },
916 { STB0899_IRQMSK_2 , 0xfc },
917 { STB0899_IRQMSK_1 , 0xff },
918 { STB0899_IRQMSK_0 , 0xff },
919 { STB0899_IRQCFG , 0x00 },
920 { STB0899_I2CCFG , 0x88 },
921 { STB0899_I2CRPT , 0x58 }, /* Repeater=8, Stop=disabled */
922 { STB0899_IOPVALUE5 , 0x00 },
923 { STB0899_IOPVALUE4 , 0x20 },
924 { STB0899_IOPVALUE3 , 0xc9 },
925 { STB0899_IOPVALUE2 , 0x90 },
926 { STB0899_IOPVALUE1 , 0x40 },
927 { STB0899_IOPVALUE0 , 0x00 },
928 { STB0899_GPIO00CFG , 0x82 },
929 { STB0899_GPIO01CFG , 0x82 },
930 { STB0899_GPIO02CFG , 0x82 },
931 { STB0899_GPIO03CFG , 0x82 },
932 { STB0899_GPIO04CFG , 0x82 },
933 { STB0899_GPIO05CFG , 0x82 },
934 { STB0899_GPIO06CFG , 0x82 },
935 { STB0899_GPIO07CFG , 0x82 },
936 { STB0899_GPIO08CFG , 0x82 },
937 { STB0899_GPIO09CFG , 0x82 },
938 { STB0899_GPIO10CFG , 0x82 },
939 { STB0899_GPIO11CFG , 0x82 },
940 { STB0899_GPIO12CFG , 0x82 },
941 { STB0899_GPIO13CFG , 0x82 },
942 { STB0899_GPIO14CFG , 0x82 },
943 { STB0899_GPIO15CFG , 0x82 },
944 { STB0899_GPIO16CFG , 0x82 },
945 { STB0899_GPIO17CFG , 0x82 },
946 { STB0899_GPIO18CFG , 0x82 },
947 { STB0899_GPIO19CFG , 0x82 },
948 { STB0899_GPIO20CFG , 0x82 },
949 { STB0899_SDATCFG , 0xb8 },
950 { STB0899_SCLTCFG , 0xba },
951 { STB0899_AGCRFCFG , 0x08 }, /* 0x1c */
952 { STB0899_GPIO22 , 0x82 }, /* AGCBB2CFG */
953 { STB0899_GPIO21 , 0x91 }, /* AGCBB1CFG */
954 { STB0899_DIRCLKCFG , 0x82 },
955 { STB0899_CLKOUT27CFG , 0x7e },
956 { STB0899_STDBYCFG , 0x82 },
957 { STB0899_CS0CFG , 0x82 },
958 { STB0899_CS1CFG , 0x82 },
959 { STB0899_DISEQCOCFG , 0x20 },
960 { STB0899_GPIO32CFG , 0x82 },
961 { STB0899_GPIO33CFG , 0x82 },
962 { STB0899_GPIO34CFG , 0x82 },
963 { STB0899_GPIO35CFG , 0x82 },
964 { STB0899_GPIO36CFG , 0x82 },
965 { STB0899_GPIO37CFG , 0x82 },
966 { STB0899_GPIO38CFG , 0x82 },
967 { STB0899_GPIO39CFG , 0x82 },
968 { STB0899_NCOARSE , 0x15 }, /* 0x15 = 27 Mhz Clock, F/3 = 198MHz, F/6 = 99MHz */
969 { STB0899_SYNTCTRL , 0x02 }, /* 0x00 = CLK from CLKI, 0x02 = CLK from XTALI */
970 { STB0899_FILTCTRL , 0x00 },
971 { STB0899_SYSCTRL , 0x00 },
972 { STB0899_STOPCLK1 , 0x20 },
973 { STB0899_STOPCLK2 , 0x00 },
974 { STB0899_INTBUFSTATUS , 0x00 },
975 { STB0899_INTBUFCTRL , 0x0a },
976 { 0xffff , 0xff },
977 };
978
979 static const struct stb0899_s1_reg knc1_stb0899_s1_init_3[] = {
980 { STB0899_DEMOD , 0x00 },
981 { STB0899_RCOMPC , 0xc9 },
982 { STB0899_AGC1CN , 0x41 },
983 { STB0899_AGC1REF , 0x08 },
984 { STB0899_RTC , 0x7a },
985 { STB0899_TMGCFG , 0x4e },
986 { STB0899_AGC2REF , 0x33 },
987 { STB0899_TLSR , 0x84 },
988 { STB0899_CFD , 0xee },
989 { STB0899_ACLC , 0x87 },
990 { STB0899_BCLC , 0x94 },
991 { STB0899_EQON , 0x41 },
992 { STB0899_LDT , 0xdd },
993 { STB0899_LDT2 , 0xc9 },
994 { STB0899_EQUALREF , 0xb4 },
995 { STB0899_TMGRAMP , 0x10 },
996 { STB0899_TMGTHD , 0x30 },
997 { STB0899_IDCCOMP , 0xfb },
998 { STB0899_QDCCOMP , 0x03 },
999 { STB0899_POWERI , 0x3b },
1000 { STB0899_POWERQ , 0x3d },
1001 { STB0899_RCOMP , 0x81 },
1002 { STB0899_AGCIQIN , 0x80 },
1003 { STB0899_AGC2I1 , 0x04 },
1004 { STB0899_AGC2I2 , 0xf5 },
1005 { STB0899_TLIR , 0x25 },
1006 { STB0899_RTF , 0x80 },
1007 { STB0899_DSTATUS , 0x00 },
1008 { STB0899_LDI , 0xca },
1009 { STB0899_CFRM , 0xf1 },
1010 { STB0899_CFRL , 0xf3 },
1011 { STB0899_NIRM , 0x2a },
1012 { STB0899_NIRL , 0x05 },
1013 { STB0899_ISYMB , 0x17 },
1014 { STB0899_QSYMB , 0xfa },
1015 { STB0899_SFRH , 0x2f },
1016 { STB0899_SFRM , 0x68 },
1017 { STB0899_SFRL , 0x40 },
1018 { STB0899_SFRUPH , 0x2f },
1019 { STB0899_SFRUPM , 0x68 },
1020 { STB0899_SFRUPL , 0x40 },
1021 { STB0899_EQUAI1 , 0xfd },
1022 { STB0899_EQUAQ1 , 0x04 },
1023 { STB0899_EQUAI2 , 0x0f },
1024 { STB0899_EQUAQ2 , 0xff },
1025 { STB0899_EQUAI3 , 0xdf },
1026 { STB0899_EQUAQ3 , 0xfa },
1027 { STB0899_EQUAI4 , 0x37 },
1028 { STB0899_EQUAQ4 , 0x0d },
1029 { STB0899_EQUAI5 , 0xbd },
1030 { STB0899_EQUAQ5 , 0xf7 },
1031 { STB0899_DSTATUS2 , 0x00 },
1032 { STB0899_VSTATUS , 0x00 },
1033 { STB0899_VERROR , 0xff },
1034 { STB0899_IQSWAP , 0x2a },
1035 { STB0899_ECNT1M , 0x00 },
1036 { STB0899_ECNT1L , 0x00 },
1037 { STB0899_ECNT2M , 0x00 },
1038 { STB0899_ECNT2L , 0x00 },
1039 { STB0899_ECNT3M , 0x00 },
1040 { STB0899_ECNT3L , 0x00 },
1041 { STB0899_FECAUTO1 , 0x06 },
1042 { STB0899_FECM , 0x01 },
1043 { STB0899_VTH12 , 0xf0 },
1044 { STB0899_VTH23 , 0xa0 },
1045 { STB0899_VTH34 , 0x78 },
1046 { STB0899_VTH56 , 0x4e },
1047 { STB0899_VTH67 , 0x48 },
1048 { STB0899_VTH78 , 0x38 },
1049 { STB0899_PRVIT , 0xff },
1050 { STB0899_VITSYNC , 0x19 },
1051 { STB0899_RSULC , 0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
1052 { STB0899_TSULC , 0x42 },
1053 { STB0899_RSLLC , 0x40 },
1054 { STB0899_TSLPL , 0x12 },
1055 { STB0899_TSCFGH , 0x0c },
1056 { STB0899_TSCFGM , 0x00 },
1057 { STB0899_TSCFGL , 0x0c },
1058 { STB0899_TSOUT , 0x4d }, /* 0x0d for CAM */
1059 { STB0899_RSSYNCDEL , 0x00 },
1060 { STB0899_TSINHDELH , 0x02 },
1061 { STB0899_TSINHDELM , 0x00 },
1062 { STB0899_TSINHDELL , 0x00 },
1063 { STB0899_TSLLSTKM , 0x00 },
1064 { STB0899_TSLLSTKL , 0x00 },
1065 { STB0899_TSULSTKM , 0x00 },
1066 { STB0899_TSULSTKL , 0xab },
1067 { STB0899_PCKLENUL , 0x00 },
1068 { STB0899_PCKLENLL , 0xcc },
1069 { STB0899_RSPCKLEN , 0xcc },
1070 { STB0899_TSSTATUS , 0x80 },
1071 { STB0899_ERRCTRL1 , 0xb6 },
1072 { STB0899_ERRCTRL2 , 0x96 },
1073 { STB0899_ERRCTRL3 , 0x89 },
1074 { STB0899_DMONMSK1 , 0x27 },
1075 { STB0899_DMONMSK0 , 0x03 },
1076 { STB0899_DEMAPVIT , 0x5c },
1077 { STB0899_PLPARM , 0x1f },
1078 { STB0899_PDELCTRL , 0x48 },
1079 { STB0899_PDELCTRL2 , 0x00 },
1080 { STB0899_BBHCTRL1 , 0x00 },
1081 { STB0899_BBHCTRL2 , 0x00 },
1082 { STB0899_HYSTTHRESH , 0x77 },
1083 { STB0899_MATCSTM , 0x00 },
1084 { STB0899_MATCSTL , 0x00 },
1085 { STB0899_UPLCSTM , 0x00 },
1086 { STB0899_UPLCSTL , 0x00 },
1087 { STB0899_DFLCSTM , 0x00 },
1088 { STB0899_DFLCSTL , 0x00 },
1089 { STB0899_SYNCCST , 0x00 },
1090 { STB0899_SYNCDCSTM , 0x00 },
1091 { STB0899_SYNCDCSTL , 0x00 },
1092 { STB0899_ISI_ENTRY , 0x00 },
1093 { STB0899_ISI_BIT_EN , 0x00 },
1094 { STB0899_MATSTRM , 0x00 },
1095 { STB0899_MATSTRL , 0x00 },
1096 { STB0899_UPLSTRM , 0x00 },
1097 { STB0899_UPLSTRL , 0x00 },
1098 { STB0899_DFLSTRM , 0x00 },
1099 { STB0899_DFLSTRL , 0x00 },
1100 { STB0899_SYNCSTR , 0x00 },
1101 { STB0899_SYNCDSTRM , 0x00 },
1102 { STB0899_SYNCDSTRL , 0x00 },
1103 { STB0899_CFGPDELSTATUS1 , 0x10 },
1104 { STB0899_CFGPDELSTATUS2 , 0x00 },
1105 { STB0899_BBFERRORM , 0x00 },
1106 { STB0899_BBFERRORL , 0x00 },
1107 { STB0899_UPKTERRORM , 0x00 },
1108 { STB0899_UPKTERRORL , 0x00 },
1109 { 0xffff , 0xff },
1110 };
1111
1112 /* STB0899 demodulator config for the KNC1 and clones */
1113 static struct stb0899_config knc1_dvbs2_config = {
1114 .init_dev = knc1_stb0899_s1_init_1,
1115 .init_s2_demod = stb0899_s2_init_2,
1116 .init_s1_demod = knc1_stb0899_s1_init_3,
1117 .init_s2_fec = stb0899_s2_init_4,
1118 .init_tst = stb0899_s1_init_5,
1119
1120 .postproc = NULL,
1121
1122 .demod_address = 0x68,
1123 // .ts_output_mode = STB0899_OUT_PARALLEL, /* types = SERIAL/PARALLEL */
1124 .block_sync_mode = STB0899_SYNC_FORCED, /* DSS, SYNC_FORCED/UNSYNCED */
1125 // .ts_pfbit_toggle = STB0899_MPEG_NORMAL, /* DirecTV, MPEG toggling seq */
1126
1127 .xtal_freq = 27000000,
1128 .inversion = IQ_SWAP_OFF,
1129
1130 .lo_clk = 76500000,
1131 .hi_clk = 90000000,
1132
1133 .esno_ave = STB0899_DVBS2_ESNO_AVE,
1134 .esno_quant = STB0899_DVBS2_ESNO_QUANT,
1135 .avframes_coarse = STB0899_DVBS2_AVFRAMES_COARSE,
1136 .avframes_fine = STB0899_DVBS2_AVFRAMES_FINE,
1137 .miss_threshold = STB0899_DVBS2_MISS_THRESHOLD,
1138 .uwp_threshold_acq = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
1139 .uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
1140 .uwp_threshold_sof = STB0899_DVBS2_UWP_THRESHOLD_SOF,
1141 .sof_search_timeout = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
1142
1143 .btr_nco_bits = STB0899_DVBS2_BTR_NCO_BITS,
1144 .btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
1145 .crl_nco_bits = STB0899_DVBS2_CRL_NCO_BITS,
1146 .ldpc_max_iter = STB0899_DVBS2_LDPC_MAX_ITER,
1147
1148 .tuner_get_frequency = tda8261_get_frequency,
1149 .tuner_set_frequency = tda8261_set_frequency,
1150 .tuner_set_bandwidth = NULL,
1151 .tuner_get_bandwidth = tda8261_get_bandwidth,
1152 .tuner_set_rfsiggain = NULL
1153 };
1154
1155 /*
1156 * SD1878/SHA tuner config
1157 * 1F, Single I/P, Horizontal mount, High Sensitivity
1158 */
1159 static const struct tda8261_config sd1878c_config = {
1160 // .name = "SD1878/SHA",
1161 .addr = 0x60,
1162 .step_size = TDA8261_STEP_1000 /* kHz */
1163 };
1164
1165 static u8 read_pwm(struct budget_av *budget_av)
1166 {
1167 u8 b = 0xff;
1168 u8 pwm;
1169 struct i2c_msg msg[] = { {.addr = 0x50,.flags = 0,.buf = &b,.len = 1},
1170 {.addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1}
1171 };
1172
1173 if ((i2c_transfer(&budget_av->budget.i2c_adap, msg, 2) != 2)
1174 || (pwm == 0xff))
1175 pwm = 0x48;
1176
1177 return pwm;
1178 }
1179
1180 #define SUBID_DVBS_KNC1 0x0010
1181 #define SUBID_DVBS_KNC1_PLUS 0x0011
1182 #define SUBID_DVBS_TYPHOON 0x4f56
1183 #define SUBID_DVBS_CINERGY1200 0x1154
1184 #define SUBID_DVBS_CYNERGY1200N 0x1155
1185 #define SUBID_DVBS_TV_STAR 0x0014
1186 #define SUBID_DVBS_TV_STAR_PLUS_X4 0x0015
1187 #define SUBID_DVBS_TV_STAR_CI 0x0016
1188 #define SUBID_DVBS2_KNC1 0x0018
1189 #define SUBID_DVBS2_KNC1_OEM 0x0019
1190 #define SUBID_DVBS_EASYWATCH_1 0x001a
1191 #define SUBID_DVBS_EASYWATCH_2 0x001b
1192 #define SUBID_DVBS2_EASYWATCH 0x001d
1193 #define SUBID_DVBS_EASYWATCH 0x001e
1194
1195 #define SUBID_DVBC_EASYWATCH 0x002a
1196 #define SUBID_DVBC_EASYWATCH_MK3 0x002c
1197 #define SUBID_DVBC_KNC1 0x0020
1198 #define SUBID_DVBC_KNC1_PLUS 0x0021
1199 #define SUBID_DVBC_KNC1_MK3 0x0022
1200 #define SUBID_DVBC_KNC1_TDA10024 0x0028
1201 #define SUBID_DVBC_KNC1_PLUS_MK3 0x0023
1202 #define SUBID_DVBC_CINERGY1200 0x1156
1203 #define SUBID_DVBC_CINERGY1200_MK3 0x1176
1204
1205 #define SUBID_DVBT_EASYWATCH 0x003a
1206 #define SUBID_DVBT_KNC1_PLUS 0x0031
1207 #define SUBID_DVBT_KNC1 0x0030
1208 #define SUBID_DVBT_CINERGY1200 0x1157
1209
1210 static void frontend_init(struct budget_av *budget_av)
1211 {
1212 struct saa7146_dev * saa = budget_av->budget.dev;
1213 struct dvb_frontend * fe = NULL;
1214
1215 /* Enable / PowerON Frontend */
1216 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
1217
1218 /* Wait for PowerON */
1219 msleep(100);
1220
1221 /* additional setup necessary for the PLUS cards */
1222 switch (saa->pci->subsystem_device) {
1223 case SUBID_DVBS_KNC1_PLUS:
1224 case SUBID_DVBC_KNC1_PLUS:
1225 case SUBID_DVBT_KNC1_PLUS:
1226 case SUBID_DVBC_EASYWATCH:
1227 case SUBID_DVBC_KNC1_PLUS_MK3:
1228 case SUBID_DVBS2_KNC1:
1229 case SUBID_DVBS2_KNC1_OEM:
1230 case SUBID_DVBS2_EASYWATCH:
1231 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
1232 break;
1233 }
1234
1235 switch (saa->pci->subsystem_device) {
1236
1237 case SUBID_DVBS_KNC1:
1238 /*
1239 * maybe that setting is needed for other dvb-s cards as well,
1240 * but so far it has been only confirmed for this type
1241 */
1242 budget_av->reinitialise_demod = 1;
1243 /* fall through */
1244 case SUBID_DVBS_KNC1_PLUS:
1245 case SUBID_DVBS_EASYWATCH_1:
1246 if (saa->pci->subsystem_vendor == 0x1894) {
1247 fe = dvb_attach(stv0299_attach, &cinergy_1200s_1894_0010_config,
1248 &budget_av->budget.i2c_adap);
1249 if (fe) {
1250 dvb_attach(tua6100_attach, fe, 0x60, &budget_av->budget.i2c_adap);
1251 }
1252 } else {
1253 fe = dvb_attach(stv0299_attach, &typhoon_config,
1254 &budget_av->budget.i2c_adap);
1255 if (fe) {
1256 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1257 }
1258 }
1259 break;
1260
1261 case SUBID_DVBS_TV_STAR:
1262 case SUBID_DVBS_TV_STAR_PLUS_X4:
1263 case SUBID_DVBS_TV_STAR_CI:
1264 case SUBID_DVBS_CYNERGY1200N:
1265 case SUBID_DVBS_EASYWATCH:
1266 case SUBID_DVBS_EASYWATCH_2:
1267 fe = dvb_attach(stv0299_attach, &philips_sd1878_config,
1268 &budget_av->budget.i2c_adap);
1269 if (fe) {
1270 dvb_attach(dvb_pll_attach, fe, 0x60,
1271 &budget_av->budget.i2c_adap,
1272 DVB_PLL_PHILIPS_SD1878_TDA8261);
1273 }
1274 break;
1275
1276 case SUBID_DVBS_TYPHOON:
1277 fe = dvb_attach(stv0299_attach, &typhoon_config,
1278 &budget_av->budget.i2c_adap);
1279 if (fe) {
1280 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1281 }
1282 break;
1283 case SUBID_DVBS2_KNC1:
1284 case SUBID_DVBS2_KNC1_OEM:
1285 case SUBID_DVBS2_EASYWATCH:
1286 budget_av->reinitialise_demod = 1;
1287 if ((fe = dvb_attach(stb0899_attach, &knc1_dvbs2_config, &budget_av->budget.i2c_adap)))
1288 dvb_attach(tda8261_attach, fe, &sd1878c_config, &budget_av->budget.i2c_adap);
1289
1290 break;
1291 case SUBID_DVBS_CINERGY1200:
1292 fe = dvb_attach(stv0299_attach, &cinergy_1200s_config,
1293 &budget_av->budget.i2c_adap);
1294 if (fe) {
1295 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1296 }
1297 break;
1298
1299 case SUBID_DVBC_KNC1:
1300 case SUBID_DVBC_KNC1_PLUS:
1301 case SUBID_DVBC_CINERGY1200:
1302 case SUBID_DVBC_EASYWATCH:
1303 budget_av->reinitialise_demod = 1;
1304 budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
1305 fe = dvb_attach(tda10021_attach, &philips_cu1216_config,
1306 &budget_av->budget.i2c_adap,
1307 read_pwm(budget_av));
1308 if (fe == NULL)
1309 fe = dvb_attach(tda10021_attach, &philips_cu1216_config_altaddress,
1310 &budget_av->budget.i2c_adap,
1311 read_pwm(budget_av));
1312 if (fe) {
1313 fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
1314 }
1315 break;
1316
1317 case SUBID_DVBC_EASYWATCH_MK3:
1318 case SUBID_DVBC_CINERGY1200_MK3:
1319 case SUBID_DVBC_KNC1_MK3:
1320 case SUBID_DVBC_KNC1_TDA10024:
1321 case SUBID_DVBC_KNC1_PLUS_MK3:
1322 budget_av->reinitialise_demod = 1;
1323 budget_av->budget.dev->i2c_bitrate = SAA7146_I2C_BUS_BIT_RATE_240;
1324 fe = dvb_attach(tda10023_attach,
1325 &philips_cu1216_tda10023_config,
1326 &budget_av->budget.i2c_adap,
1327 read_pwm(budget_av));
1328 if (fe) {
1329 fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
1330 }
1331 break;
1332
1333 case SUBID_DVBT_EASYWATCH:
1334 case SUBID_DVBT_KNC1:
1335 case SUBID_DVBT_KNC1_PLUS:
1336 case SUBID_DVBT_CINERGY1200:
1337 budget_av->reinitialise_demod = 1;
1338 fe = dvb_attach(tda10046_attach, &philips_tu1216_config,
1339 &budget_av->budget.i2c_adap);
1340 if (fe) {
1341 fe->ops.tuner_ops.init = philips_tu1216_tuner_init;
1342 fe->ops.tuner_ops.set_params = philips_tu1216_tuner_set_params;
1343 }
1344 break;
1345 }
1346
1347 if (fe == NULL) {
1348 pr_err("A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
1349 saa->pci->vendor,
1350 saa->pci->device,
1351 saa->pci->subsystem_vendor,
1352 saa->pci->subsystem_device);
1353 return;
1354 }
1355
1356 budget_av->budget.dvb_frontend = fe;
1357
1358 if (dvb_register_frontend(&budget_av->budget.dvb_adapter,
1359 budget_av->budget.dvb_frontend)) {
1360 pr_err("Frontend registration failed!\n");
1361 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1362 budget_av->budget.dvb_frontend = NULL;
1363 }
1364 }
1365
1366
1367 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr)
1368 {
1369 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1370
1371 dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av);
1372
1373 if (*isr & MASK_10)
1374 ttpci_budget_irq10_handler(dev, isr);
1375 }
1376
1377 static int budget_av_detach(struct saa7146_dev *dev)
1378 {
1379 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1380 int err;
1381
1382 dprintk(2, "dev: %p\n", dev);
1383
1384 if (1 == budget_av->has_saa7113) {
1385 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO);
1386
1387 msleep(200);
1388
1389 saa7146_unregister_device(&budget_av->vd, dev);
1390
1391 saa7146_vv_release(dev);
1392 }
1393
1394 if (budget_av->budget.ci_present)
1395 ciintf_deinit(budget_av);
1396
1397 if (budget_av->budget.dvb_frontend != NULL) {
1398 dvb_unregister_frontend(budget_av->budget.dvb_frontend);
1399 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1400 }
1401 err = ttpci_budget_deinit(&budget_av->budget);
1402
1403 kfree(budget_av);
1404
1405 return err;
1406 }
1407
1408 #define KNC1_INPUTS 2
1409 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = {
1410 { 0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0,
1411 V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0, V4L2_IN_CAP_STD },
1412 { 1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0,
1413 V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0, V4L2_IN_CAP_STD },
1414 };
1415
1416 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
1417 {
1418 dprintk(1, "VIDIOC_ENUMINPUT %d\n", i->index);
1419 if (i->index >= KNC1_INPUTS)
1420 return -EINVAL;
1421 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input));
1422 return 0;
1423 }
1424
1425 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
1426 {
1427 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
1428 struct budget_av *budget_av = (struct budget_av *)dev->ext_priv;
1429
1430 *i = budget_av->cur_input;
1431
1432 dprintk(1, "VIDIOC_G_INPUT %d\n", *i);
1433 return 0;
1434 }
1435
1436 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
1437 {
1438 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
1439 struct budget_av *budget_av = (struct budget_av *)dev->ext_priv;
1440
1441 dprintk(1, "VIDIOC_S_INPUT %d\n", input);
1442 return saa7113_setinput(budget_av, input);
1443 }
1444
1445 static struct saa7146_ext_vv vv_data;
1446
1447 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1448 {
1449 struct budget_av *budget_av;
1450 u8 *mac;
1451 int err;
1452
1453 dprintk(2, "dev: %p\n", dev);
1454
1455 if (!(budget_av = kzalloc(sizeof(struct budget_av), GFP_KERNEL)))
1456 return -ENOMEM;
1457
1458 budget_av->has_saa7113 = 0;
1459 budget_av->budget.ci_present = 0;
1460
1461 dev->ext_priv = budget_av;
1462
1463 err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE,
1464 adapter_nr);
1465 if (err) {
1466 kfree(budget_av);
1467 return err;
1468 }
1469
1470 /* knc1 initialization */
1471 saa7146_write(dev, DD1_STREAM_B, 0x04000000);
1472 saa7146_write(dev, DD1_INIT, 0x07000600);
1473 saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26);
1474
1475 if (saa7113_init(budget_av) == 0) {
1476 budget_av->has_saa7113 = 1;
1477 err = saa7146_vv_init(dev, &vv_data);
1478 if (err != 0) {
1479 /* fixme: proper cleanup here */
1480 ERR("cannot init vv subsystem\n");
1481 return err;
1482 }
1483 vv_data.vid_ops.vidioc_enum_input = vidioc_enum_input;
1484 vv_data.vid_ops.vidioc_g_input = vidioc_g_input;
1485 vv_data.vid_ops.vidioc_s_input = vidioc_s_input;
1486
1487 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_GRABBER))) {
1488 /* fixme: proper cleanup here */
1489 ERR("cannot register capture v4l2 device\n");
1490 saa7146_vv_release(dev);
1491 return err;
1492 }
1493
1494 /* beware: this modifies dev->vv ... */
1495 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A,
1496 SAA7146_HPS_SYNC_PORT_A);
1497
1498 saa7113_setinput(budget_av, 0);
1499 }
1500
1501 /* fixme: find some sane values here... */
1502 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1503
1504 mac = budget_av->budget.dvb_adapter.proposed_mac;
1505 if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) {
1506 pr_err("KNC1-%d: Could not read MAC from KNC1 card\n",
1507 budget_av->budget.dvb_adapter.num);
1508 eth_zero_addr(mac);
1509 } else {
1510 pr_info("KNC1-%d: MAC addr = %pM\n",
1511 budget_av->budget.dvb_adapter.num, mac);
1512 }
1513
1514 budget_av->budget.dvb_adapter.priv = budget_av;
1515 frontend_init(budget_av);
1516 ciintf_init(budget_av);
1517
1518 ttpci_budget_init_hooks(&budget_av->budget);
1519
1520 return 0;
1521 }
1522
1523 static struct saa7146_standard standard[] = {
1524 {.name = "PAL",.id = V4L2_STD_PAL,
1525 .v_offset = 0x17,.v_field = 288,
1526 .h_offset = 0x14,.h_pixels = 680,
1527 .v_max_out = 576,.h_max_out = 768 },
1528
1529 {.name = "NTSC",.id = V4L2_STD_NTSC,
1530 .v_offset = 0x16,.v_field = 240,
1531 .h_offset = 0x06,.h_pixels = 708,
1532 .v_max_out = 480,.h_max_out = 640, },
1533 };
1534
1535 static struct saa7146_ext_vv vv_data = {
1536 .inputs = 2,
1537 .capabilities = 0, // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113
1538 .flags = 0,
1539 .stds = &standard[0],
1540 .num_stds = ARRAY_SIZE(standard),
1541 };
1542
1543 static struct saa7146_extension budget_extension;
1544
1545 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S);
1546 MAKE_BUDGET_INFO(knc1s2,"KNC1 DVB-S2", BUDGET_KNC1S2);
1547 MAKE_BUDGET_INFO(sates2,"Satelco EasyWatch DVB-S2", BUDGET_KNC1S2);
1548 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C);
1549 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T);
1550 MAKE_BUDGET_INFO(kncxs, "KNC TV STAR DVB-S", BUDGET_TVSTAR);
1551 MAKE_BUDGET_INFO(satewpls, "Satelco EasyWatch DVB-S light", BUDGET_TVSTAR);
1552 MAKE_BUDGET_INFO(satewpls1, "Satelco EasyWatch DVB-S light", BUDGET_KNC1S);
1553 MAKE_BUDGET_INFO(satewps, "Satelco EasyWatch DVB-S", BUDGET_KNC1S);
1554 MAKE_BUDGET_INFO(satewplc, "Satelco EasyWatch DVB-C", BUDGET_KNC1CP);
1555 MAKE_BUDGET_INFO(satewcmk3, "Satelco EasyWatch DVB-C MK3", BUDGET_KNC1C_MK3);
1556 MAKE_BUDGET_INFO(satewt, "Satelco EasyWatch DVB-T", BUDGET_KNC1T);
1557 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
1558 MAKE_BUDGET_INFO(knc1spx4, "KNC1 DVB-S Plus X4", BUDGET_KNC1SP);
1559 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
1560 MAKE_BUDGET_INFO(knc1cmk3, "KNC1 DVB-C MK3", BUDGET_KNC1C_MK3);
1561 MAKE_BUDGET_INFO(knc1ctda10024, "KNC1 DVB-C TDA10024", BUDGET_KNC1C_TDA10024);
1562 MAKE_BUDGET_INFO(knc1cpmk3, "KNC1 DVB-C Plus MK3", BUDGET_KNC1CP_MK3);
1563 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
1564 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1565 MAKE_BUDGET_INFO(cin1200sn, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1566 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
1567 MAKE_BUDGET_INFO(cin1200cmk3, "Terratec Cinergy 1200 DVB-C MK3", BUDGET_CIN1200C_MK3);
1568 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
1569
1570 static const struct pci_device_id pci_tbl[] = {
1571 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56),
1572 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010),
1573 MAKE_EXTENSION_PCI(knc1s, 0x1894, 0x0010),
1574 MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011),
1575 MAKE_EXTENSION_PCI(knc1sp, 0x1894, 0x0011),
1576 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0014),
1577 MAKE_EXTENSION_PCI(knc1spx4, 0x1894, 0x0015),
1578 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0016),
1579 MAKE_EXTENSION_PCI(knc1s2, 0x1894, 0x0018),
1580 MAKE_EXTENSION_PCI(knc1s2, 0x1894, 0x0019),
1581 MAKE_EXTENSION_PCI(sates2, 0x1894, 0x001d),
1582 MAKE_EXTENSION_PCI(satewpls, 0x1894, 0x001e),
1583 MAKE_EXTENSION_PCI(satewpls1, 0x1894, 0x001a),
1584 MAKE_EXTENSION_PCI(satewps, 0x1894, 0x001b),
1585 MAKE_EXTENSION_PCI(satewplc, 0x1894, 0x002a),
1586 MAKE_EXTENSION_PCI(satewcmk3, 0x1894, 0x002c),
1587 MAKE_EXTENSION_PCI(satewt, 0x1894, 0x003a),
1588 MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
1589 MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
1590 MAKE_EXTENSION_PCI(knc1cmk3, 0x1894, 0x0022),
1591 MAKE_EXTENSION_PCI(knc1ctda10024, 0x1894, 0x0028),
1592 MAKE_EXTENSION_PCI(knc1cpmk3, 0x1894, 0x0023),
1593 MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
1594 MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
1595 MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
1596 MAKE_EXTENSION_PCI(cin1200sn, 0x153b, 0x1155),
1597 MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
1598 MAKE_EXTENSION_PCI(cin1200cmk3, 0x153b, 0x1176),
1599 MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
1600 {
1601 .vendor = 0,
1602 }
1603 };
1604
1605 MODULE_DEVICE_TABLE(pci, pci_tbl);
1606
1607 static struct saa7146_extension budget_extension = {
1608 .name = "budget_av",
1609 .flags = SAA7146_USE_I2C_IRQ,
1610
1611 .pci_tbl = pci_tbl,
1612
1613 .module = THIS_MODULE,
1614 .attach = budget_av_attach,
1615 .detach = budget_av_detach,
1616
1617 .irq_mask = MASK_10,
1618 .irq_func = budget_av_irq,
1619 };
1620
1621 static int __init budget_av_init(void)
1622 {
1623 return saa7146_register_extension(&budget_extension);
1624 }
1625
1626 static void __exit budget_av_exit(void)
1627 {
1628 saa7146_unregister_extension(&budget_extension);
1629 }
1630
1631 module_init(budget_av_init);
1632 module_exit(budget_av_exit);
1633
1634 MODULE_LICENSE("GPL");
1635 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others");
1636 MODULE_DESCRIPTION("driver for the SAA7146 based so-called budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)");
CRIS linux kernel tree