projects / deliverable / linux.git / blob
? search:


8c2a29007db5b7aba8bd31e5f7faafd3b223f589
[deliverable/linux.git] / drivers / media / dvb / ttpci / budget-av.c
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 <media/saa7146_vv.h>
41 #include <linux/module.h>
42 #include <linux/errno.h>
43 #include <linux/slab.h>
44 #include <linux/interrupt.h>
45 #include <linux/input.h>
46 #include <linux/spinlock.h>
47
48 #include "dvb_ca_en50221.h"
49
50 #define DEBICICAM 0x02420000
51
52 struct budget_av {
53 struct budget budget;
54 struct video_device *vd;
55 int cur_input;
56 int has_saa7113;
57 struct tasklet_struct ciintf_irq_tasklet;
58 int slot_status;
59 struct dvb_ca_en50221 ca;
60 };
61
62 /* GPIO CI Connections:
63 * 0 - Vcc/Reset (Reset is controlled by capacitor)
64 * 1 - Attribute Memory
65 * 2 - Card Enable (Active Low)
66 * 3 - Card Detect
67 */
68
69 /****************************************************************************
70 * INITIALIZATION
71 ****************************************************************************/
72
73 static u8 i2c_readreg(struct i2c_adapter *i2c, u8 id, u8 reg)
74 {
75 u8 mm1[] = { 0x00 };
76 u8 mm2[] = { 0x00 };
77 struct i2c_msg msgs[2];
78
79 msgs[0].flags = 0;
80 msgs[1].flags = I2C_M_RD;
81 msgs[0].addr = msgs[1].addr = id / 2;
82 mm1[0] = reg;
83 msgs[0].len = 1;
84 msgs[1].len = 1;
85 msgs[0].buf = mm1;
86 msgs[1].buf = mm2;
87
88 i2c_transfer(i2c, msgs, 2);
89
90 return mm2[0];
91 }
92
93 static int i2c_readregs(struct i2c_adapter *i2c, u8 id, u8 reg, u8 * buf, u8 len)
94 {
95 u8 mm1[] = { reg };
96 struct i2c_msg msgs[2] = {
97 {.addr = id / 2,.flags = 0,.buf = mm1,.len = 1},
98 {.addr = id / 2,.flags = I2C_M_RD,.buf = buf,.len = len}
99 };
100
101 if (i2c_transfer(i2c, msgs, 2) != 2)
102 return -EIO;
103
104 return 0;
105 }
106
107 static int i2c_writereg(struct i2c_adapter *i2c, u8 id, u8 reg, u8 val)
108 {
109 u8 msg[2] = { reg, val };
110 struct i2c_msg msgs;
111
112 msgs.flags = 0;
113 msgs.addr = id / 2;
114 msgs.len = 2;
115 msgs.buf = msg;
116 return i2c_transfer(i2c, &msgs, 1);
117 }
118
119 static int ciintf_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
120 {
121 struct budget_av *budget_av = (struct budget_av *) ca->data;
122 int result;
123
124 if (slot != 0)
125 return -EINVAL;
126
127 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTHI);
128 udelay(1);
129
130 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 0xfff, 1, 0, 0);
131
132 if (result == -ETIMEDOUT)
133 budget_av->slot_status = 0;
134 return result;
135 }
136
137 static int ciintf_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
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_debiwrite(&budget_av->budget, DEBICICAM, address & 0xfff, 1, value, 0, 0);
149
150 if (result == -ETIMEDOUT)
151 budget_av->slot_status = 0;
152 return result;
153 }
154
155 static int ciintf_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
156 {
157 struct budget_av *budget_av = (struct budget_av *) ca->data;
158 int result;
159
160 if (slot != 0)
161 return -EINVAL;
162
163 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
164 udelay(1);
165
166 result = ttpci_budget_debiread(&budget_av->budget, DEBICICAM, address & 3, 1, 0, 0);
167
168 if (result == -ETIMEDOUT)
169 budget_av->slot_status = 0;
170 return result;
171 }
172
173 static int ciintf_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
174 {
175 struct budget_av *budget_av = (struct budget_av *) ca->data;
176 int result;
177
178 if (slot != 0)
179 return -EINVAL;
180
181 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
182 udelay(1);
183
184 result = ttpci_budget_debiwrite(&budget_av->budget, DEBICICAM, address & 3, 1, value, 0, 0);
185
186 if (result == -ETIMEDOUT)
187 budget_av->slot_status = 0;
188 return result;
189 }
190
191 static int ciintf_slot_reset(struct dvb_ca_en50221 *ca, int slot)
192 {
193 struct budget_av *budget_av = (struct budget_av *) ca->data;
194 struct saa7146_dev *saa = budget_av->budget.dev;
195 int timeout = 500; // 5 seconds (4.4.6 Ready)
196
197 if (slot != 0)
198 return -EINVAL;
199
200 dprintk(1, "ciintf_slot_reset\n");
201
202 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
203
204 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI); /* Vcc off */
205 msleep(2);
206 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO); /* Vcc on */
207 msleep(20); /* 20 ms Vcc settling time */
208
209 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO); /* enable card */
210
211 /* This should have been based on pin 16 READY of the pcmcia port,
212 * but AFAICS it is not routed to the saa7146 */
213 while (--timeout > 0 && ciintf_read_attribute_mem(ca, slot, 0) != 0x1d)
214 msleep(100);
215
216 if (timeout <= 0)
217 {
218 printk(KERN_ERR "budget-av: cam reset failed (timeout).\n");
219 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
220 return -ETIMEDOUT;
221 }
222
223 return 0;
224 }
225
226 static int ciintf_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
227 {
228 struct budget_av *budget_av = (struct budget_av *) ca->data;
229 struct saa7146_dev *saa = budget_av->budget.dev;
230
231 if (slot != 0)
232 return -EINVAL;
233
234 dprintk(1, "ciintf_slot_shutdown\n");
235
236 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTB);
237 budget_av->slot_status = 0;
238 return 0;
239 }
240
241 static int ciintf_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
242 {
243 struct budget_av *budget_av = (struct budget_av *) ca->data;
244 struct saa7146_dev *saa = budget_av->budget.dev;
245
246 if (slot != 0)
247 return -EINVAL;
248
249 dprintk(1, "ciintf_slot_ts_enable: %d\n", budget_av->slot_status);
250
251 ttpci_budget_set_video_port(saa, BUDGET_VIDEO_PORTA);
252 return 0;
253 }
254
255 static int ciintf_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
256 {
257 struct budget_av *budget_av = (struct budget_av *) ca->data;
258 struct saa7146_dev *saa = budget_av->budget.dev;
259
260 if (slot != 0)
261 return -EINVAL;
262
263 if (!budget_av->slot_status) {
264 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
265 udelay(1);
266 if (saa7146_read(saa, PSR) & MASK_06)
267 {
268 printk(KERN_INFO "budget-av: cam inserted\n");
269 budget_av->slot_status = 1;
270 }
271 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
272 } else if (!open) {
273 saa7146_setgpio(budget_av->budget.dev, 1, SAA7146_GPIO_OUTLO);
274 if (ttpci_budget_debiread(&budget_av->budget, DEBICICAM, 0, 1, 0, 1) == -ETIMEDOUT)
275 {
276 printk(KERN_INFO "budget-av: cam ejected\n");
277 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTHI); /* disable card */
278 budget_av->slot_status = 0;
279 }
280 }
281
282 if (budget_av->slot_status == 1)
283 return DVB_CA_EN50221_POLL_CAM_PRESENT | DVB_CA_EN50221_POLL_CAM_READY;
284
285 return 0;
286 }
287
288 static int ciintf_init(struct budget_av *budget_av)
289 {
290 struct saa7146_dev *saa = budget_av->budget.dev;
291 int result;
292
293 memset(&budget_av->ca, 0, sizeof(struct dvb_ca_en50221));
294
295 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTLO);
296 saa7146_setgpio(saa, 1, SAA7146_GPIO_OUTLO);
297 saa7146_setgpio(saa, 2, SAA7146_GPIO_OUTLO);
298 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTLO);
299
300 /* Enable DEBI pins */
301 saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16) | 0x800);
302
303 /* register CI interface */
304 budget_av->ca.owner = THIS_MODULE;
305 budget_av->ca.read_attribute_mem = ciintf_read_attribute_mem;
306 budget_av->ca.write_attribute_mem = ciintf_write_attribute_mem;
307 budget_av->ca.read_cam_control = ciintf_read_cam_control;
308 budget_av->ca.write_cam_control = ciintf_write_cam_control;
309 budget_av->ca.slot_reset = ciintf_slot_reset;
310 budget_av->ca.slot_shutdown = ciintf_slot_shutdown;
311 budget_av->ca.slot_ts_enable = ciintf_slot_ts_enable;
312 budget_av->ca.poll_slot_status = ciintf_poll_slot_status;
313 budget_av->ca.data = budget_av;
314
315 if ((result = dvb_ca_en50221_init(&budget_av->budget.dvb_adapter,
316 &budget_av->ca, 0, 1)) != 0) {
317 printk(KERN_ERR "budget-av: ci initialisation failed.\n");
318 goto error;
319 }
320
321 printk(KERN_INFO "budget-av: ci interface initialised.\n");
322 budget_av->budget.ci_present = 1;
323 return 0;
324
325 error:
326 saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16));
327 return result;
328 }
329
330 static void ciintf_deinit(struct budget_av *budget_av)
331 {
332 struct saa7146_dev *saa = budget_av->budget.dev;
333
334 saa7146_setgpio(saa, 0, SAA7146_GPIO_INPUT);
335 saa7146_setgpio(saa, 1, SAA7146_GPIO_INPUT);
336 saa7146_setgpio(saa, 2, SAA7146_GPIO_INPUT);
337 saa7146_setgpio(saa, 3, SAA7146_GPIO_INPUT);
338
339 /* release the CA device */
340 dvb_ca_en50221_release(&budget_av->ca);
341
342 /* disable DEBI pins */
343 saa7146_write(saa, MC1, saa7146_read(saa, MC1) | (0x800 << 16));
344 }
345
346
347 static const u8 saa7113_tab[] = {
348 0x01, 0x08,
349 0x02, 0xc0,
350 0x03, 0x33,
351 0x04, 0x00,
352 0x05, 0x00,
353 0x06, 0xeb,
354 0x07, 0xe0,
355 0x08, 0x28,
356 0x09, 0x00,
357 0x0a, 0x80,
358 0x0b, 0x47,
359 0x0c, 0x40,
360 0x0d, 0x00,
361 0x0e, 0x01,
362 0x0f, 0x44,
363
364 0x10, 0x08,
365 0x11, 0x0c,
366 0x12, 0x7b,
367 0x13, 0x00,
368 0x15, 0x00, 0x16, 0x00, 0x17, 0x00,
369
370 0x57, 0xff,
371 0x40, 0x82, 0x58, 0x00, 0x59, 0x54, 0x5a, 0x07,
372 0x5b, 0x83, 0x5e, 0x00,
373 0xff
374 };
375
376 static int saa7113_init(struct budget_av *budget_av)
377 {
378 struct budget *budget = &budget_av->budget;
379 struct saa7146_dev *saa = budget->dev;
380 const u8 *data = saa7113_tab;
381
382 saa7146_setgpio(saa, 0, SAA7146_GPIO_OUTHI);
383 msleep(200);
384
385 if (i2c_writereg(&budget->i2c_adap, 0x4a, 0x01, 0x08) != 1) {
386 dprintk(1, "saa7113 not found on KNC card\n");
387 return -ENODEV;
388 }
389
390 dprintk(1, "saa7113 detected and initializing\n");
391
392 while (*data != 0xff) {
393 i2c_writereg(&budget->i2c_adap, 0x4a, *data, *(data + 1));
394 data += 2;
395 }
396
397 dprintk(1, "saa7113 status=%02x\n", i2c_readreg(&budget->i2c_adap, 0x4a, 0x1f));
398
399 return 0;
400 }
401
402 static int saa7113_setinput(struct budget_av *budget_av, int input)
403 {
404 struct budget *budget = &budget_av->budget;
405
406 if (1 != budget_av->has_saa7113)
407 return -ENODEV;
408
409 if (input == 1) {
410 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc7);
411 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x80);
412 } else if (input == 0) {
413 i2c_writereg(&budget->i2c_adap, 0x4a, 0x02, 0xc0);
414 i2c_writereg(&budget->i2c_adap, 0x4a, 0x09, 0x00);
415 } else
416 return -EINVAL;
417
418 budget_av->cur_input = input;
419 return 0;
420 }
421
422
423 static int philips_su1278_ty_ci_set_symbol_rate(struct dvb_frontend *fe, u32 srate, u32 ratio)
424 {
425 u8 aclk = 0;
426 u8 bclk = 0;
427 u8 m1;
428
429 aclk = 0xb5;
430 if (srate < 2000000)
431 bclk = 0x86;
432 else if (srate < 5000000)
433 bclk = 0x89;
434 else if (srate < 15000000)
435 bclk = 0x8f;
436 else if (srate < 45000000)
437 bclk = 0x95;
438
439 m1 = 0x14;
440 if (srate < 4000000)
441 m1 = 0x10;
442
443 stv0299_writereg(fe, 0x13, aclk);
444 stv0299_writereg(fe, 0x14, bclk);
445 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
446 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
447 stv0299_writereg(fe, 0x21, (ratio) & 0xf0);
448 stv0299_writereg(fe, 0x0f, 0x80 | m1);
449
450 return 0;
451 }
452
453 static int philips_su1278_ty_ci_pll_set(struct dvb_frontend *fe,
454 struct i2c_adapter *i2c,
455 struct dvb_frontend_parameters *params)
456 {
457 u32 div;
458 u8 buf[4];
459 struct i2c_msg msg = {.addr = 0x61,.flags = 0,.buf = buf,.len = sizeof(buf) };
460
461 if ((params->frequency < 950000) || (params->frequency > 2150000))
462 return -EINVAL;
463
464 div = (params->frequency + (125 - 1)) / 125; // round correctly
465 buf[0] = (div >> 8) & 0x7f;
466 buf[1] = div & 0xff;
467 buf[2] = 0x80 | ((div & 0x18000) >> 10) | 4;
468 buf[3] = 0x20;
469
470 if (params->u.qpsk.symbol_rate < 4000000)
471 buf[3] |= 1;
472
473 if (params->frequency < 1250000)
474 buf[3] |= 0;
475 else if (params->frequency < 1550000)
476 buf[3] |= 0x40;
477 else if (params->frequency < 2050000)
478 buf[3] |= 0x80;
479 else if (params->frequency < 2150000)
480 buf[3] |= 0xC0;
481
482 if (i2c_transfer(i2c, &msg, 1) != 1)
483 return -EIO;
484 return 0;
485 }
486
487 static u8 typhoon_cinergy1200s_inittab[] = {
488 0x01, 0x15,
489 0x02, 0x30,
490 0x03, 0x00,
491 0x04, 0x7d, /* F22FR = 0x7d, F22 = f_VCO / 128 / 0x7d = 22 kHz */
492 0x05, 0x35, /* I2CT = 0, SCLT = 1, SDAT = 1 */
493 0x06, 0x40, /* DAC not used, set to high impendance mode */
494 0x07, 0x00, /* DAC LSB */
495 0x08, 0x40, /* DiSEqC off */
496 0x09, 0x00, /* FIFO */
497 0x0c, 0x51, /* OP1 ctl = Normal, OP1 val = 1 (LNB Power ON) */
498 0x0d, 0x82, /* DC offset compensation = ON, beta_agc1 = 2 */
499 0x0e, 0x23, /* alpha_tmg = 2, beta_tmg = 3 */
500 0x10, 0x3f, // AGC2 0x3d
501 0x11, 0x84,
502 0x12, 0xb5, // Lock detect: -64 Carrier freq detect:on
503 0x15, 0xc9, // lock detector threshold
504 0x16, 0x00,
505 0x17, 0x00,
506 0x18, 0x00,
507 0x19, 0x00,
508 0x1a, 0x00,
509 0x1f, 0x50,
510 0x20, 0x00,
511 0x21, 0x00,
512 0x22, 0x00,
513 0x23, 0x00,
514 0x28, 0x00, // out imp: normal out type: parallel FEC mode:0
515 0x29, 0x1e, // 1/2 threshold
516 0x2a, 0x14, // 2/3 threshold
517 0x2b, 0x0f, // 3/4 threshold
518 0x2c, 0x09, // 5/6 threshold
519 0x2d, 0x05, // 7/8 threshold
520 0x2e, 0x01,
521 0x31, 0x1f, // test all FECs
522 0x32, 0x19, // viterbi and synchro search
523 0x33, 0xfc, // rs control
524 0x34, 0x93, // error control
525 0x0f, 0x92,
526 0xff, 0xff
527 };
528
529 static struct stv0299_config typhoon_config = {
530 .demod_address = 0x68,
531 .inittab = typhoon_cinergy1200s_inittab,
532 .mclk = 88000000UL,
533 .invert = 0,
534 .enhanced_tuning = 0,
535 .skip_reinit = 0,
536 .lock_output = STV0229_LOCKOUTPUT_1,
537 .volt13_op0_op1 = STV0299_VOLT13_OP0,
538 .min_delay_ms = 100,
539 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
540 .pll_set = philips_su1278_ty_ci_pll_set,
541 };
542
543
544 static struct stv0299_config cinergy_1200s_config = {
545 .demod_address = 0x68,
546 .inittab = typhoon_cinergy1200s_inittab,
547 .mclk = 88000000UL,
548 .invert = 0,
549 .enhanced_tuning = 0,
550 .skip_reinit = 0,
551 .lock_output = STV0229_LOCKOUTPUT_0,
552 .volt13_op0_op1 = STV0299_VOLT13_OP0,
553 .min_delay_ms = 100,
554 .set_symbol_rate = philips_su1278_ty_ci_set_symbol_rate,
555 .pll_set = philips_su1278_ty_ci_pll_set,
556 };
557
558
559 static int philips_cu1216_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
560 {
561 struct budget *budget = (struct budget *) fe->dvb->priv;
562 u8 buf[4];
563 struct i2c_msg msg = {.addr = 0x60,.flags = 0,.buf = buf,.len = sizeof(buf) };
564
565 #define TUNER_MUL 62500
566
567 u32 div = (params->frequency + 36125000 + TUNER_MUL / 2) / TUNER_MUL;
568
569 buf[0] = (div >> 8) & 0x7f;
570 buf[1] = div & 0xff;
571 buf[2] = 0x86;
572 buf[3] = (params->frequency < 150000000 ? 0x01 :
573 params->frequency < 445000000 ? 0x02 : 0x04);
574
575 if (i2c_transfer(&budget->i2c_adap, &msg, 1) != 1)
576 return -EIO;
577 return 0;
578 }
579
580 static struct tda10021_config philips_cu1216_config = {
581 .demod_address = 0x0c,
582 .pll_set = philips_cu1216_pll_set,
583 };
584
585
586
587
588 static int philips_tu1216_pll_init(struct dvb_frontend *fe)
589 {
590 struct budget *budget = (struct budget *) fe->dvb->priv;
591 static u8 tu1216_init[] = { 0x0b, 0xf5, 0x85, 0xab };
592 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tu1216_init,.len = sizeof(tu1216_init) };
593
594 // setup PLL configuration
595 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
596 return -EIO;
597 msleep(1);
598
599 return 0;
600 }
601
602 static int philips_tu1216_pll_set(struct dvb_frontend *fe, struct dvb_frontend_parameters *params)
603 {
604 struct budget *budget = (struct budget *) fe->dvb->priv;
605 u8 tuner_buf[4];
606 struct i2c_msg tuner_msg = {.addr = 0x60,.flags = 0,.buf = tuner_buf,.len =
607 sizeof(tuner_buf) };
608 int tuner_frequency = 0;
609 u8 band, cp, filter;
610
611 // determine charge pump
612 tuner_frequency = params->frequency + 36166000;
613 if (tuner_frequency < 87000000)
614 return -EINVAL;
615 else if (tuner_frequency < 130000000)
616 cp = 3;
617 else if (tuner_frequency < 160000000)
618 cp = 5;
619 else if (tuner_frequency < 200000000)
620 cp = 6;
621 else if (tuner_frequency < 290000000)
622 cp = 3;
623 else if (tuner_frequency < 420000000)
624 cp = 5;
625 else if (tuner_frequency < 480000000)
626 cp = 6;
627 else if (tuner_frequency < 620000000)
628 cp = 3;
629 else if (tuner_frequency < 830000000)
630 cp = 5;
631 else if (tuner_frequency < 895000000)
632 cp = 7;
633 else
634 return -EINVAL;
635
636 // determine band
637 if (params->frequency < 49000000)
638 return -EINVAL;
639 else if (params->frequency < 161000000)
640 band = 1;
641 else if (params->frequency < 444000000)
642 band = 2;
643 else if (params->frequency < 861000000)
644 band = 4;
645 else
646 return -EINVAL;
647
648 // setup PLL filter
649 switch (params->u.ofdm.bandwidth) {
650 case BANDWIDTH_6_MHZ:
651 filter = 0;
652 break;
653
654 case BANDWIDTH_7_MHZ:
655 filter = 0;
656 break;
657
658 case BANDWIDTH_8_MHZ:
659 filter = 1;
660 break;
661
662 default:
663 return -EINVAL;
664 }
665
666 // calculate divisor
667 // ((36166000+((1000000/6)/2)) + Finput)/(1000000/6)
668 tuner_frequency = (((params->frequency / 1000) * 6) + 217496) / 1000;
669
670 // setup tuner buffer
671 tuner_buf[0] = (tuner_frequency >> 8) & 0x7f;
672 tuner_buf[1] = tuner_frequency & 0xff;
673 tuner_buf[2] = 0xca;
674 tuner_buf[3] = (cp << 5) | (filter << 3) | band;
675
676 if (i2c_transfer(&budget->i2c_adap, &tuner_msg, 1) != 1)
677 return -EIO;
678
679 msleep(1);
680 return 0;
681 }
682
683 static int philips_tu1216_request_firmware(struct dvb_frontend *fe,
684 const struct firmware **fw, char *name)
685 {
686 struct budget *budget = (struct budget *) fe->dvb->priv;
687
688 return request_firmware(fw, name, &budget->dev->pci->dev);
689 }
690
691 static struct tda1004x_config philips_tu1216_config = {
692
693 .demod_address = 0x8,
694 .invert = 1,
695 .invert_oclk = 1,
696 .xtal_freq = TDA10046_XTAL_4M,
697 .agc_config = TDA10046_AGC_DEFAULT,
698 .if_freq = TDA10046_FREQ_3617,
699 .pll_init = philips_tu1216_pll_init,
700 .pll_set = philips_tu1216_pll_set,
701 .pll_sleep = NULL,
702 .request_firmware = philips_tu1216_request_firmware,
703 };
704
705
706
707
708 static u8 read_pwm(struct budget_av *budget_av)
709 {
710 u8 b = 0xff;
711 u8 pwm;
712 struct i2c_msg msg[] = { {.addr = 0x50,.flags = 0,.buf = &b,.len = 1},
713 {.addr = 0x50,.flags = I2C_M_RD,.buf = &pwm,.len = 1}
714 };
715
716 if ((i2c_transfer(&budget_av->budget.i2c_adap, msg, 2) != 2)
717 || (pwm == 0xff))
718 pwm = 0x48;
719
720 return pwm;
721 }
722
723 #define SUBID_DVBS_KNC1 0x0010
724 #define SUBID_DVBS_KNC1_PLUS 0x0011
725 #define SUBID_DVBS_TYPHOON 0x4f56
726 #define SUBID_DVBS_CINERGY1200 0x1154
727
728 #define SUBID_DVBC_KNC1 0x0020
729 #define SUBID_DVBC_KNC1_PLUS 0x0021
730 #define SUBID_DVBC_CINERGY1200 0x1156
731
732 #define SUBID_DVBT_KNC1_PLUS 0x0031
733 #define SUBID_DVBT_KNC1 0x0030
734 #define SUBID_DVBT_CINERGY1200 0x1157
735
736 static void frontend_init(struct budget_av *budget_av)
737 {
738 struct saa7146_dev * saa = budget_av->budget.dev;
739 struct dvb_frontend * fe = NULL;
740
741 switch (saa->pci->subsystem_device) {
742 case SUBID_DVBS_KNC1_PLUS:
743 case SUBID_DVBC_KNC1_PLUS:
744 case SUBID_DVBT_KNC1_PLUS:
745 // Enable / PowerON Frontend
746 saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
747 break;
748 }
749
750 switch (saa->pci->subsystem_device) {
751
752 case SUBID_DVBS_KNC1:
753 case SUBID_DVBS_KNC1_PLUS:
754 case SUBID_DVBS_TYPHOON:
755 fe = stv0299_attach(&typhoon_config,
756 &budget_av->budget.i2c_adap);
757 break;
758
759 case SUBID_DVBS_CINERGY1200:
760 fe = stv0299_attach(&cinergy_1200s_config,
761 &budget_av->budget.i2c_adap);
762 break;
763
764 case SUBID_DVBC_KNC1:
765 case SUBID_DVBC_KNC1_PLUS:
766 fe = tda10021_attach(&philips_cu1216_config,
767 &budget_av->budget.i2c_adap,
768 read_pwm(budget_av));
769 break;
770
771 case SUBID_DVBT_KNC1:
772 case SUBID_DVBT_KNC1_PLUS:
773 fe = tda10046_attach(&philips_tu1216_config,
774 &budget_av->budget.i2c_adap);
775 break;
776
777 case SUBID_DVBC_CINERGY1200:
778 fe = tda10021_attach(&philips_cu1216_config,
779 &budget_av->budget.i2c_adap,
780 read_pwm(budget_av));
781 break;
782
783 case SUBID_DVBT_CINERGY1200:
784 fe = tda10046_attach(&philips_tu1216_config,
785 &budget_av->budget.i2c_adap);
786 break;
787 }
788
789 if (fe == NULL) {
790 printk(KERN_ERR "budget-av: A frontend driver was not found "
791 "for device %04x/%04x subsystem %04x/%04x\n",
792 saa->pci->vendor,
793 saa->pci->device,
794 saa->pci->subsystem_vendor,
795 saa->pci->subsystem_device);
796 return;
797 }
798
799 budget_av->budget.dvb_frontend = fe;
800
801 if (dvb_register_frontend(&budget_av->budget.dvb_adapter,
802 budget_av->budget.dvb_frontend)) {
803 printk(KERN_ERR "budget-av: Frontend registration failed!\n");
804 if (budget_av->budget.dvb_frontend->ops->release)
805 budget_av->budget.dvb_frontend->ops->release(budget_av->budget.dvb_frontend);
806 budget_av->budget.dvb_frontend = NULL;
807 }
808 }
809
810
811 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr)
812 {
813 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
814
815 dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av);
816
817 if (*isr & MASK_10)
818 ttpci_budget_irq10_handler(dev, isr);
819 }
820
821 static int budget_av_detach(struct saa7146_dev *dev)
822 {
823 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
824 int err;
825
826 dprintk(2, "dev: %p\n", dev);
827
828 if (1 == budget_av->has_saa7113) {
829 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO);
830
831 msleep(200);
832
833 saa7146_unregister_device(&budget_av->vd, dev);
834 }
835
836 if (budget_av->budget.ci_present)
837 ciintf_deinit(budget_av);
838
839 if (budget_av->budget.dvb_frontend != NULL)
840 dvb_unregister_frontend(budget_av->budget.dvb_frontend);
841 err = ttpci_budget_deinit(&budget_av->budget);
842
843 kfree(budget_av);
844
845 return err;
846 }
847
848 static struct saa7146_ext_vv vv_data;
849
850 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
851 {
852 struct budget_av *budget_av;
853 u8 *mac;
854 int err;
855
856 dprintk(2, "dev: %p\n", dev);
857
858 if (!(budget_av = kmalloc(sizeof(struct budget_av), GFP_KERNEL)))
859 return -ENOMEM;
860
861 memset(budget_av, 0, sizeof(struct budget_av));
862
863 budget_av->has_saa7113 = 0;
864 budget_av->budget.ci_present = 0;
865
866 dev->ext_priv = budget_av;
867
868 if ((err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE))) {
869 kfree(budget_av);
870 return err;
871 }
872
873 /* knc1 initialization */
874 saa7146_write(dev, DD1_STREAM_B, 0x04000000);
875 saa7146_write(dev, DD1_INIT, 0x07000600);
876 saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26);
877
878 if (saa7113_init(budget_av) == 0) {
879 budget_av->has_saa7113 = 1;
880
881 if (0 != saa7146_vv_init(dev, &vv_data)) {
882 /* fixme: proper cleanup here */
883 ERR(("cannot init vv subsystem.\n"));
884 return err;
885 }
886
887 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_GRABBER))) {
888 /* fixme: proper cleanup here */
889 ERR(("cannot register capture v4l2 device.\n"));
890 return err;
891 }
892
893 /* beware: this modifies dev->vv ... */
894 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A,
895 SAA7146_HPS_SYNC_PORT_A);
896
897 saa7113_setinput(budget_av, 0);
898 } else {
899 ciintf_init(budget_av);
900 }
901
902 /* fixme: find some sane values here... */
903 saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
904
905 mac = budget_av->budget.dvb_adapter.proposed_mac;
906 if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) {
907 printk(KERN_ERR "KNC1-%d: Could not read MAC from KNC1 card\n",
908 budget_av->budget.dvb_adapter.num);
909 memset(mac, 0, 6);
910 } else {
911 printk(KERN_INFO "KNC1-%d: MAC addr = %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
912 budget_av->budget.dvb_adapter.num,
913 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
914 }
915
916 budget_av->budget.dvb_adapter.priv = budget_av;
917 frontend_init(budget_av);
918
919 return 0;
920 }
921
922 #define KNC1_INPUTS 2
923 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = {
924 {0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
925 {1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
926 };
927
928 static struct saa7146_extension_ioctls ioctls[] = {
929 {VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE},
930 {VIDIOC_G_INPUT, SAA7146_EXCLUSIVE},
931 {VIDIOC_S_INPUT, SAA7146_EXCLUSIVE},
932 {0, 0}
933 };
934
935 static int av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
936 {
937 struct saa7146_dev *dev = fh->dev;
938 struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
939
940 switch (cmd) {
941 case VIDIOC_ENUMINPUT:{
942 struct v4l2_input *i = arg;
943
944 dprintk(1, "VIDIOC_ENUMINPUT %d.\n", i->index);
945 if (i->index < 0 || i->index >= KNC1_INPUTS) {
946 return -EINVAL;
947 }
948 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input));
949 return 0;
950 }
951 case VIDIOC_G_INPUT:{
952 int *input = (int *) arg;
953
954 *input = budget_av->cur_input;
955
956 dprintk(1, "VIDIOC_G_INPUT %d.\n", *input);
957 return 0;
958 }
959 case VIDIOC_S_INPUT:{
960 int input = *(int *) arg;
961 dprintk(1, "VIDIOC_S_INPUT %d.\n", input);
962 return saa7113_setinput(budget_av, input);
963 }
964 default:
965 return -ENOIOCTLCMD;
966 }
967 return 0;
968 }
969
970 static struct saa7146_standard standard[] = {
971 {.name = "PAL",.id = V4L2_STD_PAL,
972 .v_offset = 0x17,.v_field = 288,
973 .h_offset = 0x14,.h_pixels = 680,
974 .v_max_out = 576,.h_max_out = 768 },
975
976 {.name = "NTSC",.id = V4L2_STD_NTSC,
977 .v_offset = 0x16,.v_field = 240,
978 .h_offset = 0x06,.h_pixels = 708,
979 .v_max_out = 480,.h_max_out = 640, },
980 };
981
982 static struct saa7146_ext_vv vv_data = {
983 .inputs = 2,
984 .capabilities = 0, // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113
985 .flags = 0,
986 .stds = &standard[0],
987 .num_stds = sizeof(standard) / sizeof(struct saa7146_standard),
988 .ioctls = &ioctls[0],
989 .ioctl = av_ioctl,
990 };
991
992 static struct saa7146_extension budget_extension;
993
994 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S);
995 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C);
996 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T);
997 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
998 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
999 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
1000 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1001 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
1002 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
1003
1004 static struct pci_device_id pci_tbl[] = {
1005 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56),
1006 MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010),
1007 MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011),
1008 MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
1009 MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
1010 MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
1011 MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
1012 MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
1013 MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
1014 MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
1015 {
1016 .vendor = 0,
1017 }
1018 };
1019
1020 MODULE_DEVICE_TABLE(pci, pci_tbl);
1021
1022 static struct saa7146_extension budget_extension = {
1023 .name = "budget_av",
1024 .pci_tbl = pci_tbl,
1025
1026 .module = THIS_MODULE,
1027 .attach = budget_av_attach,
1028 .detach = budget_av_detach,
1029
1030 .irq_mask = MASK_10,
1031 .irq_func = budget_av_irq,
1032 };
1033
1034 static int __init budget_av_init(void)
1035 {
1036 return saa7146_register_extension(&budget_extension);
1037 }
1038
1039 static void __exit budget_av_exit(void)
1040 {
1041 saa7146_unregister_extension(&budget_extension);
1042 }
1043
1044 module_init(budget_av_init);
1045 module_exit(budget_av_exit);
1046
1047 MODULE_LICENSE("GPL");
1048 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others");
1049 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1050 "budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)");
Linux kernel - Deliverables
This page took 0.057197 seconds and 4 git commands to generate.