?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (4921): Budget-av, budget-ci: Fix MC1 register programming
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / media / dvb / ttpci / budget-av.c
blob89ab4b59155cde27035bcb4ce4d8f3a887c8eac7
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 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
31 *
32 *
33 * the project's page is at http://www.linuxtv.org/dvb/
34 */
35
36 #include "budget.h"
37 #include "stv0299.h"
38 #include "tda10021.h"
39 #include "tda1004x.h"
40 #include "tua6100.h"
41 #include "dvb-pll.h"
42 #include <media/saa7146_vv.h>
43 #include <linux/module.h>
44 #include <linux/errno.h>
45 #include <linux/slab.h>
46 #include <linux/interrupt.h>
47 #include <linux/input.h>
48 #include <linux/spinlock.h>
49
50 #include "dvb_ca_en50221.h"
51
52 #define DEBICICAM 0x02420000
53
54 #define SLOTSTATUS_NONE 1
55 #define SLOTSTATUS_PRESENT 2
56 #define SLOTSTATUS_RESET 4
57 #define SLOTSTATUS_READY 8
58 #define SLOTSTATUS_OCCUPIED (SLOTSTATUS_PRESENT|SLOTSTATUS_RESET|SLOTSTATUS_READY)
59
60 struct budget_av {
61 struct budget budget;
62 struct video_device *vd;
63 int cur_input;
64 int has_saa7113;
65 struct tasklet_struct ciintf_irq_tasklet;
66 int slot_status;
67 struct dvb_ca_en50221 ca;
68 u8 reinitialise_demod:1;
69 u8 tda10021_poclkp:1;
70 u8 tda10021_ts_enabled;
71 int (*tda10021_set_frontend)(struct dvb_frontend *fe, struct dvb_frontend_parameters *p);
72 };
73
74 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot);
75
76
77 /* GPIO Connections:
78 * 0 - Vcc/Reset (Reset is controlled by capacitor). Resets the frontend *AS WELL*!
79 * 1 - CI memory select 0=>IO memory, 1=>Attribute Memory
80 * 2 - CI Card Enable (Active Low)
81 * 3 - CI Card Detect
82 */
83
84 /****************************************************************************
85 * INITIALIZATION
86 ****************************************************************************/
87
88 static u8 i2c_readreg(struct i2c_adapter *i2c, u8 id, u8 reg)
89 {
90 u8 mm1[] = { 0x00 };
91 u8 mm2[] = { 0x00 };
92 struct i2c_msg msgs[2];
93
94 msgs[0].flags = 0;
95 msgs[1].flags = I2C_M_RD;
96 msgs[0].addr = msgs[1].addr = id / 2;
97 mm1[0] = reg;
98 msgs[0].len = 1;
99 msgs[1].len = 1;
100 msgs[0].buf = mm1;
101 msgs[1].buf = mm2;
102
103 i2c_transfer(i2c, msgs, 2);
104
105 return mm2[0];
106 }
107
108 static int i2c_readregs(struct i2c_adapter *i2c, u8 id, u8 reg, u8 * buf, u8 len)
109 {
110 u8 mm1[] = { reg };
111 struct i2c_msg msgs[2] = {
112 {.addr = id / 2,.flags = 0,.buf = mm1,.len = 1},
113 {.addr = id / 2,.flags = I2C_M_RD,.buf = buf,.len = len}
114 };
115
116 if (i2c_transfer(i2c, msgs, 2) != 2)
117 return -EIO;
118
119 return 0;
120 }
121
122 static int i2c_writereg(struct i2c_adapter *i2c, u8 id, u8 reg, u8 val)
123 {
124 u8 msg[2] = { reg, val };
125 struct i2c_msg msgs;
126
127 msgs.flags = 0;
128 msgs.addr = id / 2;
129 msgs.len = 2;
130 msgs.buf = msg;
131 return i2c_transfer(i2c, &msgs, 1);
132 }
133
134 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
135 {
136 struct budget_av *budget_av = (struct budget_av *) ca->data;
137 int result;
138
139 if (slot != 0)
140 return -EINVAL;
141
142 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
143 udelay(1);
144
145 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 0xfff, 1, 0, 1);
146 if (result == -ETIMEDOUT) {
147 ciintf_slot_shutdown(ca, slot);
148 printk(KERN_INFO "budget-av: cam ejected 1\n");
149 }
150 return result;
151 }
152
153 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
154 {
155 struct budget_av *budget_av = (struct budget_av *) ca->data;
156 int result;
157
158 if (slot != 0)
159 return -EINVAL;
160
161 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
162 udelay(1);
163
164 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 0xfff, 1, value, 0, 1);
165 if (result == -ETIMEDOUT) {
166 ciintf_slot_shutdown(ca, slot);
167 printk(KERN_INFO "budget-av: cam ejected 2\n");
168 }
169 return result;
170 }
171
172 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
173 {
174 struct budget_av *budget_av = (struct budget_av *) ca->data;
175 int result;
176
177 if (slot != 0)
178 return -EINVAL;
179
180 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
181 udelay(1);
182
183 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0);
184 if ((result == -ETIMEDOUT) || ((result == 0xff) && ((address & 3) < 2))) {
185 ciintf_slot_shutdown(ca, slot);
186 printk(KERN_INFO "budget-av: cam ejected 3\n");
187 return -ETIMEDOUT;
188 }
189 return result;
190 }
191
192 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
193 {
194 struct budget_av *budget_av = (struct budget_av *) ca->data;
195 int result;
196
197 if (slot != 0)
198 return -EINVAL;
199
200 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
201 udelay(1);
202
203 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 3, 1, value, 0, 0);
204 if (result == -ETIMEDOUT) {
205 ciintf_slot_shutdown(ca, slot);
206 printk(KERN_INFO "budget-av: cam ejected 5\n");
207 }
208 return result;
209 }
210
211 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
212 {
213 struct budget_av *budget_av = (struct budget_av *) ca->data;
214 struct saa7146_dev *saa = budget_av->budget.dev;
215
216 if (slot != 0)
217 return -EINVAL;
218
219 dprintk(1, "ciintf_slot_reset\n");
220 budget_av->slot_status = SLOTSTATUS_RESET;
221
222 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
223
224 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); /* Vcc off */
225 msleep(2);
226 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); /* Vcc on */
227 msleep(20); /* 20 ms Vcc settling time */
228
229 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); /* enable card */
230 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
231 msleep(20);
232
233 /* reinitialise the frontend if necessary */
234 if (budget_av->reinitialise_demod)
235 dvb_frontend_reinitialise(budget_av->budget.dvb_frontend);
236
237 /* set tda10021 back to original clock configuration on reset */
238 if (budget_av->tda10021_poclkp) {
239 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
240 budget_av->tda10021_ts_enabled = 0;
241 }
242
243 return 0;
244 }
245
246 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
247 {
248 struct budget_av *budget_av = (struct budget_av *) ca->data;
249 struct saa7146_dev *saa = budget_av->budget.dev;
250
251 if (slot != 0)
252 return -EINVAL;
253
254 dprintk(1, "ciintf_slot_shutdown\n");
255
256 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
257 budget_av->slot_status = SLOTSTATUS_NONE;
258
259 /* set tda10021 back to original clock configuration when cam removed */
260 if (budget_av->tda10021_poclkp) {
261 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
262 budget_av->tda10021_ts_enabled = 0;
263 }
264 return 0;
265 }
266
267 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
268 {
269 struct budget_av *budget_av = (struct budget_av *) ca->data;
270 struct saa7146_dev *saa = budget_av->budget.dev;
271
272 if (slot != 0)
273 return -EINVAL;
274
275 dprintk(1, "ciintf_slot_ts_enable: %d\n", budget_av->slot_status);
276
277 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
278
279 /* tda10021 seems to need a different TS clock config when data is routed to the CAM */
280 if (budget_av->tda10021_poclkp) {
281 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
282 budget_av->tda10021_ts_enabled = 1;
283 }
284
285 return 0;
286 }
287
288 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
289 {
290 struct budget_av *budget_av = (struct budget_av *) ca->data;
291 struct saa7146_dev *saa = budget_av->budget.dev;
292 int result;
293
294 if (slot != 0)
295 return -EINVAL;
296
297 /* test the card detect line - needs to be done carefully
298 * since it never goes high for some CAMs on this interface (e.g. topuptv) */
299 if (budget_av->slot_status == SLOTSTATUS_NONE) {
300 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
301 udelay(1);
302 if (saa7146_read(saa, PSR) & MASK_06) {
303 if (budget_av->slot_status == SLOTSTATUS_NONE) {
304 budget_av->slot_status = SLOTSTATUS_PRESENT;
305 printk(KERN_INFO "budget-av: cam inserted A\n");
306 }
307 }
308 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
309 }
310
311 /* We also try and read from IO memory to work round the above detection bug. If
312 * there is no CAM, we will get a timeout. Only done if there is no cam
313 * present, since this test actually breaks some cams :(
314 *
315 * if the CI interface is not open, we also do the above test since we
316 * don't care if the cam has problems - we'll be resetting it on open() anyway */
317 if ((budget_av->slot_status == SLOTSTATUS_NONE) || (!open)) {
318 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
319 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, 0, 1, 0, 1);
320 if ((result >= 0) && (budget_av->slot_status == SLOTSTATUS_NONE)) {
321 budget_av->slot_status = SLOTSTATUS_PRESENT;
322 printk(KERN_INFO "budget-av: cam inserted B\n");
323 } else if (result < 0) {
324 if (budget_av->slot_status != SLOTSTATUS_NONE) {
325 ciintf_slot_shutdown(ca, slot);
326 printk(KERN_INFO "budget-av: cam ejected 5\n");
327 return 0;
328 }
329 }
330 }
331
332 /* read from attribute memory in reset/ready state to know when the CAM is ready */
333 if (budget_av->slot_status == SLOTSTATUS_RESET) {
334 result = ciintf_read_attribute_mem(ca, slot, 0);
335 if (result == 0x1d) {
336 budget_av->slot_status = SLOTSTATUS_READY;
337 }
338 }
339
340 /* work out correct return code */
341 if (budget_av->slot_status != SLOTSTATUS_NONE) {
342 if (budget_av->slot_status & SLOTSTATUS_READY) {
343 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
344 }
345 return DVB_CA_EN50221_POLL_CAM_PRESENT;
346 }
347 return 0;
348 }
349
350 static int ciintf_init(struct budget_av *budget_av)
351 {
352 struct saa7146_dev *saa = budget_av->budget.dev;
353 int result;
354
355 memset(&budget_av->ca, 0, sizeof(struct dvb_ca_en50221));
356
357 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
358 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
359 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO);
360 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
361
362 /* Enable DEBI pins */
363 saa7146_write(saa, MC1, MASK_27 | MASK_11);
364
365 /* register CI interface */
366 budget_av->ca.owner = THIS_MODULE;
367 budget_av->ca.read_attribute_mem = ciintf_read_attribute_mem;
368 budget_av->ca.write_attribute_mem = ciintf_write_attribute_mem;
369 budget_av->ca.read_cam_control = ciintf_read_cam_control;
370 budget_av->ca.write_cam_control = ciintf_write_cam_control;
371 budget_av->ca.slot_reset = ciintf_slot_reset;
372 budget_av->ca.slot_shutdown = ciintf_slot_shutdown;
373 budget_av->ca.slot_ts_enable = ciintf_slot_ts_enable;
374 budget_av->ca.poll_slot_status = ciintf_poll_slot_status;
375 budget_av->ca.data = budget_av;
376 budget_av->budget.ci_present = 1;
377 budget_av->slot_status = SLOTSTATUS_NONE;
378
379 if ((result = dvb_ca_en50221_init(&budget_av->budget.dvb_adapter,
380 &budget_av->ca, 0, 1)) != 0) {
381 printk(KERN_ERR "budget-av: ci initialisation failed.\n");
382 goto error;
383 }
384
385 printk(KERN_INFO "budget-av: ci interface initialised.\n");
386 return 0;
387
388 error:
389 saa7146_write(saa, MC1, MASK_27);
390 return result;
391 }
392
393 static void ciintf_deinit(struct budget_av *budget_av)
394 {
395 struct saa7146_dev *saa = budget_av->budget.dev;
396
397 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
398 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
399 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
400 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
401
402 /* release the CA device */
403 dvb_ca_en50221_release(&budget_av->ca);
404
405 /* disable DEBI pins */
406 saa7146_write(saa, MC1, MASK_27);
407 }
408
409
410 static const u8 saa7113_tab[] = {
411 0x01, 0x08,
412 0x02, 0xc0,
413 0x03, 0x33,
414 0x04, 0x00,
415 0x05, 0x00,
416 0x06, 0xeb,
417 0x07, 0xe0,
418 0x08, 0x28,
419 0x09, 0x00,
420 0x0a, 0x80,
421 0x0b, 0x47,
422 0x0c, 0x40,
423 0x0d, 0x00,
424 0x0e, 0x01,
425 0x0f, 0x44,
426
427 0x10, 0x08,
428 0x11, 0x0c,
429 0x12, 0x7b,
430 0x13, 0x00,
431 0x15, 0x00, 0x16, 0x00, 0x17, 0x00,
432
433 0x57, 0xff,
434 0x40, 0x82, 0x58, 0x00, 0x59, 0x54, 0x5a, 0x07,
435 0x5b, 0x83, 0x5e, 0x00,
436 0xff
437 };
438
439 static int saa7113_init(struct budget_av *budget_av)
440 {
441 struct budget *budget = &budget_av->budget;
442 struct saa7146_dev *saa = budget->dev;
443 const u8 *data = saa7113_tab;
444
445 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI);
446 msleep(200);
447
448 if (i2c_writereg(&budget->i2c_adap, 0x4a, 0x01, 0x08) != 1) {
449 dprintk(1, "saa7113 not found on KNC card\n");
450 return -ENODEV;
451 }
452
453 dprintk(1, "saa7113 detected and initializing\n");
454
455 while (*data != 0xff) {
456 i2c_writereg(&budget->i2c_adap, 0x4a, *data, *(data + 1));
457 data += 2;
458 }
459
460 dprintk(1, "saa7113 status=%02x\n", i2c_readreg(&budget->i2c_adap, 0x4a, 0x1f));
461
462 return 0;
463 }
464
465 static int saa7113_setinput(struct budget_av *budget_av, int input)
466 {
467 struct budget *budget = &budget_av->budget;
468
469 if (1 != budget_av->has_saa7113)
470 return -ENODEV;
471
472 if (input == 1) {
473 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc7);
474 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x80);
475 } else if (input == 0) {
476 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc0);
477 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x00);
478 } else
479 return -EINVAL;
480
481 budget_av->cur_input = input;
482 return 0;
483 }
484
485
486 static int philips_su1278_ty_ci_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
487 {
488 u8 aclk = 0;
489 u8 bclk = 0;
490 u8 m1;
491
492 aclk = 0xb5;
493 if (srate < 2000000)
494 bclk = 0x86;
495 else if (srate < 5000000)
496 bclk = 0x89;
497 else if (srate < 15000000)
498 bclk = 0x8f;
499 else if (srate < 45000000)
500 bclk = 0x95;
501
502 m1 = 0x14;
503 if (srate < 4000000)
504 m1 = 0x10;
505
506 stv0299_writereg(fe, 0x13, aclk);
507 stv0299_writereg(fe, 0x14, bclk);
508 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
509 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
510 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
511 stv0299_writereg(fe, 0x0f, 0x80 | m1);
512
513 return 0;
514 }
515
516 static int philips_su1278_ty_ci_tuner_set_params(struct dvb_frontend *fe,
517 struct dvb_frontend_parameters *params)
518 {
519 u32 div;
520 u8 buf[4];
521 struct budget *budget = (struct budget *) fe->dvb->priv;
522 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
523
524 if ((params->frequency < 950000) || (params->frequency > 2150000))
525 return -EINVAL;
526
527 div = (params->frequency + (125 - 1)) / 125; // round correctly
528 buf[0] = (div >> 8) & 0x7f;
529 buf[1] = div & 0xff;
530 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
531 buf[3] = 0x20;
532
533 if (params->u.qpsk.symbol_rate < 4000000)
534 buf[3] |= 1;
535
536 if (params->frequency < 1250000)
537 buf[3] |= 0;
538 else if (params->frequency < 1550000)
539 buf[3] |= 0x40;
540 else if (params->frequency < 2050000)
541 buf[3] |= 0x80;
542 else if (params->frequency < 2150000)
543 buf[3] |= 0xC0;
544
545 if (fe->ops.i2c_gate_ctrl)
546 fe->ops.i2c_gate_ctrl(fe, 1);
547 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
548 return -EIO;
549 return 0;
550 }
551
552 static u8 typhoon_cinergy1200s_inittab[] = {
553 0x01, 0x15,
554 0x02, 0x30,
555 0x03, 0x00,
556 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
557 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
558 0x06, 0x40, /* DAC not used, set to high impendance mode */
559 0x07, 0x00, /* DAC LSB */
560 0x08, 0x40, /* DiSEqC off */
561 0x09, 0x00, /* FIFO */
562 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
563 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
564 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
565 0x10, 0x3f, // AGC2 0x3d
566 0x11, 0x84,
567 0x12, 0xb9,
568 0x15, 0xc9, // lock detector threshold
569 0x16, 0x00,
570 0x17, 0x00,
571 0x18, 0x00,
572 0x19, 0x00,
573 0x1a, 0x00,
574 0x1f, 0x50,
575 0x20, 0x00,
576 0x21, 0x00,
577 0x22, 0x00,
578 0x23, 0x00,
579 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
580 0x29, 0x1e, // 1/2 threshold
581 0x2a, 0x14, // 2/3 threshold
582 0x2b, 0x0f, // 3/4 threshold
583 0x2c, 0x09, // 5/6 threshold
584 0x2d, 0x05, // 7/8 threshold
585 0x2e, 0x01,
586 0x31, 0x1f, // test all FECs
587 0x32, 0x19, // viterbi and synchro search
588 0x33, 0xfc, // rs control
589 0x34, 0x93, // error control
590 0x0f, 0x92,
591 0xff, 0xff
592 };
593
594 static struct stv0299_config typhoon_config = {
595 .demod_address = 0x68,
596 .inittab = typhoon_cinergy1200s_inittab,
597 .mclk = 88000000UL,
598 .invert = 0,
599 .skip_reinit = 0,
600 .lock_output = STV0229_LOCKOUTPUT_1,
601 .volt13_op0_op1 = STV0299_VOLT13_OP0,
602 .min_delay_ms = 100,
603 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
604 };
605
606
607 static struct stv0299_config cinergy_1200s_config = {
608 .demod_address = 0x68,
609 .inittab = typhoon_cinergy1200s_inittab,
610 .mclk = 88000000UL,
611 .invert = 0,
612 .skip_reinit = 0,
613 .lock_output = STV0229_LOCKOUTPUT_0,
614 .volt13_op0_op1 = STV0299_VOLT13_OP0,
615 .min_delay_ms = 100,
616 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
617 };
618
619 static struct stv0299_config cinergy_1200s_1894_0010_config = {
620 .demod_address = 0x68,
621 .inittab = typhoon_cinergy1200s_inittab,
622 .mclk = 88000000UL,
623 .invert = 1,
624 .skip_reinit = 0,
625 .lock_output = STV0229_LOCKOUTPUT_1,
626 .volt13_op0_op1 = STV0299_VOLT13_OP0,
627 .min_delay_ms = 100,
628 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
629 };
630
631 static int philips_cu1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
632 {
633 struct budget *budget = (struct budget *) fe->dvb->priv;
634 u8 buf[4];
635 struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
636
637 #define TUNER_MUL 62500
638
639 u32 div = (params->frequency + 36125000 + TUNER_MUL / 2) / TUNER_MUL;
640
641 buf[0] = (div >> 8) & 0x7f;
642 buf[1] = div & 0xff;
643 buf[2] = 0x86;
644 buf[3] = (params->frequency < 150000000 ? 0x01 :
645 params->frequency < 445000000 ? 0x02 : 0x04);
646
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)
650 return -EIO;
651 return 0;
652 }
653
654 static struct tda10021_config philips_cu1216_config = {
655 .demod_address = 0x0c,
656 };
657
658 static struct tda10021_config philips_cu1216_config_altaddress = {
659 .demod_address = 0x0d,
660 };
661
662
663
664
665 static int philips_tu1216_tuner_init(struct dvb_frontend *fe)
666 {
667 struct budget *budget = (struct budget *) fe->dvb->priv;
668 static u8 tu1216_init[] = { 0x0b, 0xf5, 0x85, 0xab };
669 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) };
670
671 // setup PLL configuration
672 if (fe->ops.i2c_gate_ctrl)
673 fe->ops.i2c_gate_ctrl(fe, 1);
674 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
675 return -EIO;
676 msleep(1);
677
678 return 0;
679 }
680
681 static int philips_tu1216_tuner_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
682 {
683 struct budget *budget = (struct budget *) fe->dvb->priv;
684 u8 tuner_buf[4];
685 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tuner_buf,.len =
686 sizeof(tuner_buf) };
687 int tuner_frequency = 0;
688 u8 band, cp, filter;
689
690 // determine charge pump
691 tuner_frequency = params->frequency + 36166000;
692 if (tuner_frequency < 87000000)
693 return -EINVAL;
694 else if (tuner_frequency < 130000000)
695 cp = 3;
696 else if (tuner_frequency < 160000000)
697 cp = 5;
698 else if (tuner_frequency < 200000000)
699 cp = 6;
700 else if (tuner_frequency < 290000000)
701 cp = 3;
702 else if (tuner_frequency < 420000000)
703 cp = 5;
704 else if (tuner_frequency < 480000000)
705 cp = 6;
706 else if (tuner_frequency < 620000000)
707 cp = 3;
708 else if (tuner_frequency < 830000000)
709 cp = 5;
710 else if (tuner_frequency < 895000000)
711 cp = 7;
712 else
713 return -EINVAL;
714
715 // determine band
716 if (params->frequency < 49000000)
717 return -EINVAL;
718 else if (params->frequency < 161000000)
719 band = 1;
720 else if (params->frequency < 444000000)
721 band = 2;
722 else if (params->frequency < 861000000)
723 band = 4;
724 else
725 return -EINVAL;
726
727 // setup PLL filter
728 switch (params->u.ofdm.bandwidth) {
729 case BANDWIDTH_6_MHZ:
730 filter = 0;
731 break;
732
733 case BANDWIDTH_7_MHZ:
734 filter = 0;
735 break;
736
737 case BANDWIDTH_8_MHZ:
738 filter = 1;
739 break;
740
741 default:
742 return -EINVAL;
743 }
744
745 // calculate divisor
746 // ((36166000+((1000000/6)/2)) + Finput)/(1000000/6)
747 tuner_frequency = (((params->frequency / 1000) * 6) + 217496) / 1000;
748
749 // setup tuner buffer
750 tuner_buf[0] = (tuner_frequency >> 8) & 0x7f;
751 tuner_buf[1] = tuner_frequency & 0xff;
752 tuner_buf[2] = 0xca;
753 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
754
755 if (fe->ops.i2c_gate_ctrl)
756 fe->ops.i2c_gate_ctrl(fe, 1);
757 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
758 return -EIO;
759
760 msleep(1);
761 return 0;
762 }
763
764 static int philips_tu1216_request_firmware(struct dvb_frontend *fe,
765 const struct firmware **fw, char *name)
766 {
767 struct budget *budget = (struct budget *) fe->dvb->priv;
768
769 return request_firmware(fw, name, &budget->dev->pci->dev);
770 }
771
772 static struct tda1004x_config philips_tu1216_config = {
773
774 .demod_address = 0x8,
775 .invert = 1,
776 .invert_oclk = 1,
777 .xtal_freq = TDA10046_XTAL_4M,
778 .agc_config = TDA10046_AGC_DEFAULT,
779 .if_freq = TDA10046_FREQ_3617,
780 .request_firmware = philips_tu1216_request_firmware,
781 };
782
783 static u8 philips_sd1878_inittab[] = {
784 0x01, 0x15,
785 0x02, 0x30,
786 0x03, 0x00,
787 0x04, 0x7d,
788 0x05, 0x35,
789 0x06, 0x40,
790 0x07, 0x00,
791 0x08, 0x43,
792 0x09, 0x02,
793 0x0C, 0x51,
794 0x0D, 0x82,
795 0x0E, 0x23,
796 0x10, 0x3f,
797 0x11, 0x84,
798 0x12, 0xb9,
799 0x15, 0xc9,
800 0x16, 0x19,
801 0x17, 0x8c,
802 0x18, 0x59,
803 0x19, 0xf8,
804 0x1a, 0xfe,
805 0x1c, 0x7f,
806 0x1d, 0x00,
807 0x1e, 0x00,
808 0x1f, 0x50,
809 0x20, 0x00,
810 0x21, 0x00,
811 0x22, 0x00,
812 0x23, 0x00,
813 0x28, 0x00,
814 0x29, 0x28,
815 0x2a, 0x14,
816 0x2b, 0x0f,
817 0x2c, 0x09,
818 0x2d, 0x09,
819 0x31, 0x1f,
820 0x32, 0x19,
821 0x33, 0xfc,
822 0x34, 0x93,
823 0xff, 0xff
824 };
825
826 static int philips_sd1878_tda8261_tuner_set_params(struct dvb_frontend *fe,
827 struct dvb_frontend_parameters *params)
828 {
829 u8 buf[4];
830 int rc;
831 struct i2c_msg tuner_msg = {.addr=0x60,.flags=0,.buf=buf,.len=sizeof(buf)};
832 struct budget *budget = (struct budget *) fe->dvb->priv;
833
834 if((params->frequency < 950000) || (params->frequency > 2150000))
835 return -EINVAL;
836
837 rc=dvb_pll_configure(&dvb_pll_philips_sd1878_tda8261, buf,
838 params->frequency, 0);
839 if(rc < 0) return rc;
840
841 if (fe->ops.i2c_gate_ctrl)
842 fe->ops.i2c_gate_ctrl(fe, 1);
843 if(i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
844 return -EIO;
845
846 return 0;
847 }
848
849 static int philips_sd1878_ci_set_symbol_rate(struct dvb_frontend *fe,
850 u32 srate, u32 ratio)
851 {
852 u8 aclk = 0;
853 u8 bclk = 0;
854 u8 m1;
855
856 aclk = 0xb5;
857 if (srate < 2000000)
858 bclk = 0x86;
859 else if (srate < 5000000)
860 bclk = 0x89;
861 else if (srate < 15000000)
862 bclk = 0x8f;
863 else if (srate < 45000000)
864 bclk = 0x95;
865
866 m1 = 0x14;
867 if (srate < 4000000)
868 m1 = 0x10;
869
870 stv0299_writereg(fe, 0x0e, 0x23);
871 stv0299_writereg(fe, 0x0f, 0x94);
872 stv0299_writereg(fe, 0x10, 0x39);
873 stv0299_writereg(fe, 0x13, aclk);
874 stv0299_writereg(fe, 0x14, bclk);
875 stv0299_writereg(fe, 0x15, 0xc9);
876 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
877 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
878 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
879 stv0299_writereg(fe, 0x0f, 0x80 | m1);
880
881 return 0;
882 }
883
884 static struct stv0299_config philips_sd1878_config = {
885 .demod_address = 0x68,
886 .inittab = philips_sd1878_inittab,
887 .mclk = 88000000UL,
888 .invert = 0,
889 .skip_reinit = 0,
890 .lock_output = STV0229_LOCKOUTPUT_1,
891 .volt13_op0_op1 = STV0299_VOLT13_OP0,
892 .min_delay_ms = 100,
893 .set_symbol_rate = philips_sd1878_ci_set_symbol_rate,
894 };
895
896 static u8 read_pwm(struct budget_av *budget_av)
897 {
898 u8 b = 0xff;
899 u8 pwm;
900 struct i2c_msg msg[] = { {.addr = 0x50,.flags = 0,.buf = &b,.len = 1},
901 {.addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1}
902 };
903
904 if ((i2c_transfer(&budget_av->budget.i2c_adap, msg, 2) != 2)
905 || (pwm == 0xff))
906 pwm = 0x48;
907
908 return pwm;
909 }
910
911 #define SUBID_DVBS_KNC1 0x0010
912 #define SUBID_DVBS_KNC1_PLUS 0x0011
913 #define SUBID_DVBS_TYPHOON 0x4f56
914 #define SUBID_DVBS_CINERGY1200 0x1154
915 #define SUBID_DVBS_CYNERGY1200N 0x1155
916
917 #define SUBID_DVBS_TV_STAR 0x0014
918 #define SUBID_DVBS_TV_STAR_CI 0x0016
919 #define SUBID_DVBS_EASYWATCH_1 0x001a
920 #define SUBID_DVBS_EASYWATCH 0x001e
921 #define SUBID_DVBC_EASYWATCH 0x002a
922 #define SUBID_DVBC_KNC1 0x0020
923 #define SUBID_DVBC_KNC1_PLUS 0x0021
924 #define SUBID_DVBC_CINERGY1200 0x1156
925
926 #define SUBID_DVBT_KNC1_PLUS 0x0031
927 #define SUBID_DVBT_KNC1 0x0030
928 #define SUBID_DVBT_CINERGY1200 0x1157
929
930
931 static int tda10021_set_frontend(struct dvb_frontend *fe,
932 struct dvb_frontend_parameters *p)
933 {
934 struct budget_av* budget_av = fe->dvb->priv;
935 int result;
936
937 result = budget_av->tda10021_set_frontend(fe, p);
938 if (budget_av->tda10021_ts_enabled) {
939 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa1);
940 } else {
941 tda10021_writereg(budget_av->budget.dvb_frontend, 0x12, 0xa0);
942 }
943
944 return result;
945 }
946
947 static void frontend_init(struct budget_av *budget_av)
948 {
949 struct saa7146_dev * saa = budget_av->budget.dev;
950 struct dvb_frontend * fe = NULL;
951
952 /* Enable / PowerON Frontend */
953 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
954
955 /* Wait for PowerON */
956 msleep(100);
957
958 /* additional setup necessary for the PLUS cards */
959 switch (saa->pci->subsystem_device) {
960 case SUBID_DVBS_KNC1_PLUS:
961 case SUBID_DVBC_KNC1_PLUS:
962 case SUBID_DVBT_KNC1_PLUS:
963 case SUBID_DVBC_EASYWATCH:
964 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
965 break;
966 }
967
968 switch (saa->pci->subsystem_device) {
969
970 case SUBID_DVBS_KNC1:
971 case SUBID_DVBS_KNC1_PLUS:
972 case SUBID_DVBS_EASYWATCH_1:
973 if (saa->pci->subsystem_vendor == 0x1894) {
974 fe = dvb_attach(stv0299_attach, &cinergy_1200s_1894_0010_config,
975 &budget_av->budget.i2c_adap);
976 if (fe) {
977 dvb_attach(tua6100_attach, fe, 0x60, &budget_av->budget.i2c_adap);
978 }
979 } else {
980 fe = dvb_attach(stv0299_attach, &typhoon_config,
981 &budget_av->budget.i2c_adap);
982 if (fe) {
983 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
984 }
985 }
986 break;
987
988 case SUBID_DVBS_TV_STAR:
989 case SUBID_DVBS_TV_STAR_CI:
990 case SUBID_DVBS_CYNERGY1200N:
991 case SUBID_DVBS_EASYWATCH:
992 fe = dvb_attach(stv0299_attach, &philips_sd1878_config,
993 &budget_av->budget.i2c_adap);
994 if (fe) {
995 fe->ops.tuner_ops.set_params = philips_sd1878_tda8261_tuner_set_params;
996 }
997 break;
998
999 case SUBID_DVBS_TYPHOON:
1000 fe = dvb_attach(stv0299_attach, &typhoon_config,
1001 &budget_av->budget.i2c_adap);
1002 if (fe) {
1003 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1004 }
1005 break;
1006
1007 case SUBID_DVBS_CINERGY1200:
1008 fe = dvb_attach(stv0299_attach, &cinergy_1200s_config,
1009 &budget_av->budget.i2c_adap);
1010 if (fe) {
1011 fe->ops.tuner_ops.set_params = philips_su1278_ty_ci_tuner_set_params;
1012 }
1013 break;
1014
1015 case SUBID_DVBC_KNC1:
1016 case SUBID_DVBC_KNC1_PLUS:
1017 case SUBID_DVBC_CINERGY1200:
1018 case SUBID_DVBC_EASYWATCH:
1019 budget_av->reinitialise_demod = 1;
1020 fe = dvb_attach(tda10021_attach, &philips_cu1216_config,
1021 &budget_av->budget.i2c_adap,
1022 read_pwm(budget_av));
1023 if (fe == NULL)
1024 fe = dvb_attach(tda10021_attach, &philips_cu1216_config_altaddress,
1025 &budget_av->budget.i2c_adap,
1026 read_pwm(budget_av));
1027 if (fe) {
1028 budget_av->tda10021_poclkp = 1;
1029 budget_av->tda10021_set_frontend = fe->ops.set_frontend;
1030 fe->ops.set_frontend = tda10021_set_frontend;
1031 fe->ops.tuner_ops.set_params = philips_cu1216_tuner_set_params;
1032 }
1033 break;
1034
1035 case SUBID_DVBT_KNC1:
1036 case SUBID_DVBT_KNC1_PLUS:
1037 case SUBID_DVBT_CINERGY1200:
1038 budget_av->reinitialise_demod = 1;
1039 fe = dvb_attach(tda10046_attach, &philips_tu1216_config,
1040 &budget_av->budget.i2c_adap);
1041 if (fe) {
1042 fe->ops.tuner_ops.init = philips_tu1216_tuner_init;
1043 fe->ops.tuner_ops.set_params = philips_tu1216_tuner_set_params;
1044 }
1045 break;
1046 }
1047
1048 if (fe == NULL) {
1049 printk(KERN_ERR "budget-av: A frontend driver was not found "
1050 "for device %04x/%04x subsystem %04x/%04x\n",
1051 saa->pci->vendor,
1052 saa->pci->device,
1053 saa->pci->subsystem_vendor,
1054 saa->pci->subsystem_device);
1055 return;
1056 }
1057
1058 budget_av->budget.dvb_frontend = fe;
1059
1060 if (dvb_register_frontend(&budget_av->budget.dvb_adapter,
1061 budget_av->budget.dvb_frontend)) {
1062 printk(KERN_ERR "budget-av: Frontend registration failed!\n");
1063 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1064 budget_av->budget.dvb_frontend = NULL;
1065 }
1066 }
1067
1068
1069 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr)
1070 {
1071 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1072
1073 dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av);
1074
1075 if (*isr & MASK_10)
1076 ttpci_budget_irq10_handler(dev, isr);
1077 }
1078
1079 static int budget_av_detach(struct saa7146_dev *dev)
1080 {
1081 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1082 int err;
1083
1084 dprintk(2, "dev: %p\n", dev);
1085
1086 if (1 == budget_av->has_saa7113) {
1087 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO);
1088
1089 msleep(200);
1090
1091 saa7146_unregister_device(&budget_av->vd, dev);
1092 }
1093
1094 if (budget_av->budget.ci_present)
1095 ciintf_deinit(budget_av);
1096
1097 if (budget_av->budget.dvb_frontend != NULL) {
1098 dvb_unregister_frontend(budget_av->budget.dvb_frontend);
1099 dvb_frontend_detach(budget_av->budget.dvb_frontend);
1100 }
1101 err = ttpci_budget_deinit(&budget_av->budget);
1102
1103 kfree(budget_av);
1104
1105 return err;
1106 }
1107
1108 static struct saa7146_ext_vv vv_data;
1109
1110 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
1111 {
1112 struct budget_av *budget_av;
1113 u8 *mac;
1114 int err;
1115
1116 dprintk(2, "dev: %p\n", dev);
1117
1118 if (!(budget_av = kzalloc(sizeof(struct budget_av), GFP_KERNEL)))
1119 return -ENOMEM;
1120
1121 budget_av->has_saa7113 = 0;
1122 budget_av->budget.ci_present = 0;
1123
1124 dev->ext_priv = budget_av;
1125
1126 if ((err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE))) {
1127 kfree(budget_av);
1128 return err;
1129 }
1130
1131 /* knc1 initialization */
1132 saa7146_write(dev, DD1_STREAM_B, 0x04000000);
1133 saa7146_write(dev, DD1_INIT, 0x07000600);
1134 saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26);
1135
1136 if (saa7113_init(budget_av) == 0) {
1137 budget_av->has_saa7113 = 1;
1138
1139 if (0 != saa7146_vv_init(dev, &vv_data)) {
1140 /* fixme: proper cleanup here */
1141 ERR(("cannot init vv subsystem.\n"));
1142 return err;
1143 }
1144
1145 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_GRABBER))) {
1146 /* fixme: proper cleanup here */
1147 ERR(("cannot register capture v4l2 device.\n"));
1148 return err;
1149 }
1150
1151 /* beware: this modifies dev->vv ... */
1152 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A,
1153 SAA7146_HPS_SYNC_PORT_A);
1154
1155 saa7113_setinput(budget_av, 0);
1156 }
1157
1158 /* fixme: find some sane values here... */
1159 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
1160
1161 mac = budget_av->budget.dvb_adapter.proposed_mac;
1162 if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) {
1163 printk(KERN_ERR "KNC1-%d: Could not read MAC from KNC1 card\n",
1164 budget_av->budget.dvb_adapter.num);
1165 memset(mac, 0, 6);
1166 } else {
1167 printk(KERN_INFO "KNC1-%d: MAC addr = %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
1168 budget_av->budget.dvb_adapter.num,
1169 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
1170 }
1171
1172 budget_av->budget.dvb_adapter.priv = budget_av;
1173 frontend_init(budget_av);
1174 ciintf_init(budget_av);
1175
1176 ttpci_budget_init_hooks(&budget_av->budget);
1177
1178 return 0;
1179 }
1180
1181 #define KNC1_INPUTS 2
1182 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = {
1183 {0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
1184 {1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
1185 };
1186
1187 static struct saa7146_extension_ioctls ioctls[] = {
1188 {VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE},
1189 {VIDIOC_G_INPUT, SAA7146_EXCLUSIVE},
1190 {VIDIOC_S_INPUT, SAA7146_EXCLUSIVE},
1191 {0, 0}
1192 };
1193
1194 static int av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
1195 {
1196 struct saa7146_dev *dev = fh->dev;
1197 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
1198
1199 switch (cmd) {
1200 case VIDIOC_ENUMINPUT:{
1201 struct v4l2_input *i = arg;
1202
1203 dprintk(1, "VIDIOC_ENUMINPUT %d.\n", i->index);
1204 if (i->index < 0 || i->index >= KNC1_INPUTS) {
1205 return -EINVAL;
1206 }
1207 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input));
1208 return 0;
1209 }
1210 case VIDIOC_G_INPUT:{
1211 int *input = (int *) arg;
1212
1213 *input = budget_av->cur_input;
1214
1215 dprintk(1, "VIDIOC_G_INPUT %d.\n", *input);
1216 return 0;
1217 }
1218 case VIDIOC_S_INPUT:{
1219 int input = *(int *) arg;
1220 dprintk(1, "VIDIOC_S_INPUT %d.\n", input);
1221 return saa7113_setinput(budget_av, input);
1222 }
1223 default:
1224 return -ENOIOCTLCMD;
1225 }
1226 return 0;
1227 }
1228
1229 static struct saa7146_standard standard[] = {
1230 {.name = "PAL",.id = V4L2_STD_PAL,
1231 .v_offset = 0x17,.v_field = 288,
1232 .h_offset = 0x14,.h_pixels = 680,
1233 .v_max_out = 576,.h_max_out = 768 },
1234
1235 {.name = "NTSC",.id = V4L2_STD_NTSC,
1236 .v_offset = 0x16,.v_field = 240,
1237 .h_offset = 0x06,.h_pixels = 708,
1238 .v_max_out = 480,.h_max_out = 640, },
1239 };
1240
1241 static struct saa7146_ext_vv vv_data = {
1242 .inputs = 2,
1243 .capabilities = 0, // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113
1244 .flags = 0,
1245 .stds = &standard[0],
1246 .num_stds = sizeof(standard) / sizeof(struct saa7146_standard),
1247 .ioctls = &ioctls[0],
1248 .ioctl = av_ioctl,
1249 };
1250
1251 static struct saa7146_extension budget_extension;
1252
1253 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S);
1254 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C);
1255 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T);
1256 MAKE_BUDGET_INFO(kncxs, "KNC TV STAR DVB-S", BUDGET_TVSTAR);
1257 MAKE_BUDGET_INFO(satewpls, "Satelco EasyWatch DVB-S light", BUDGET_TVSTAR);
1258 MAKE_BUDGET_INFO(satewpls1, "Satelco EasyWatch DVB-S light", BUDGET_KNC1S);
1259 MAKE_BUDGET_INFO(satewplc, "Satelco EasyWatch DVB-C", BUDGET_KNC1CP);
1260 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
1261 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
1262 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
1263 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1264 MAKE_BUDGET_INFO(cin1200sn, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1265 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
1266 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
1267
1268 static struct pci_device_id pci_tbl[] = {
1269 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56),
1270 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010),
1271 MAKE_EXTENSION_PCI(knc1s, 0x1894, 0x0010),
1272 MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011),
1273 MAKE_EXTENSION_PCI(knc1sp, 0x1894, 0x0011),
1274 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0014),
1275 MAKE_EXTENSION_PCI(kncxs, 0x1894, 0x0016),
1276 MAKE_EXTENSION_PCI(satewpls, 0x1894, 0x001e),
1277 MAKE_EXTENSION_PCI(satewpls1, 0x1894, 0x001a),
1278 MAKE_EXTENSION_PCI(satewplc, 0x1894, 0x002a),
1279 MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
1280 MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
1281 MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
1282 MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
1283 MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
1284 MAKE_EXTENSION_PCI(cin1200sn, 0x153b, 0x1155),
1285 MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
1286 MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
1287 {
1288 .vendor = 0,
1289 }
1290 };
1291
1292 MODULE_DEVICE_TABLE(pci, pci_tbl);
1293
1294 static struct saa7146_extension budget_extension = {
1295 .name = "budget_av",
1296 .flags = SAA7146_USE_I2C_IRQ,
1297
1298 .pci_tbl = pci_tbl,
1299
1300 .module = THIS_MODULE,
1301 .attach = budget_av_attach,
1302 .detach = budget_av_detach,
1303
1304 .irq_mask = MASK_10,
1305 .irq_func = budget_av_irq,
1306 };
1307
1308 static int __init budget_av_init(void)
1309 {
1310 return saa7146_register_extension(&budget_extension);
1311 }
1312
1313 static void __exit budget_av_exit(void)
1314 {
1315 saa7146_unregister_extension(&budget_extension);
1316 }
1317
1318 module_init(budget_av_init);
1319 module_exit(budget_av_exit);
1320
1321 MODULE_LICENSE("GPL");
1322 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others");
1323 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1324 "budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree