Merge master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / 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, 0, SAA7146_GPIO_OUTLO);
747                         saa7146_setgpio(saa, 3, SAA7146_GPIO_OUTHI);
748                         break;
749         }
750
751         switch (saa->pci->subsystem_device) {
752
753         case SUBID_DVBS_KNC1:
754         case SUBID_DVBS_KNC1_PLUS:
755         case SUBID_DVBS_TYPHOON:
756                 fe = stv0299_attach(&typhoon_config,
757                                     &budget_av->budget.i2c_adap);
758                 break;
759
760         case SUBID_DVBS_CINERGY1200:
761                 fe = stv0299_attach(&cinergy_1200s_config,
762                                     &budget_av->budget.i2c_adap);
763                 break;
764
765         case SUBID_DVBC_KNC1:
766         case SUBID_DVBC_KNC1_PLUS:
767                 fe = tda10021_attach(&philips_cu1216_config,
768                                      &budget_av->budget.i2c_adap,
769                                      read_pwm(budget_av));
770                 break;
771
772         case SUBID_DVBT_KNC1:
773         case SUBID_DVBT_KNC1_PLUS:
774                 fe = tda10046_attach(&philips_tu1216_config,
775                                      &budget_av->budget.i2c_adap);
776                 break;
777
778         case SUBID_DVBC_CINERGY1200:
779                 fe = tda10021_attach(&philips_cu1216_config,
780                                      &budget_av->budget.i2c_adap,
781                                      read_pwm(budget_av));
782                 break;
783
784         case SUBID_DVBT_CINERGY1200:
785                 fe = tda10046_attach(&philips_tu1216_config,
786                                      &budget_av->budget.i2c_adap);
787                 break;
788         }
789
790         if (fe == NULL) {
791                 printk(KERN_ERR "budget-av: A frontend driver was not found "
792                                 "for device %04x/%04x subsystem %04x/%04x\n",
793                        saa->pci->vendor,
794                        saa->pci->device,
795                        saa->pci->subsystem_vendor,
796                        saa->pci->subsystem_device);
797                 return;
798         }
799
800         budget_av->budget.dvb_frontend = fe;
801
802         if (dvb_register_frontend(&budget_av->budget.dvb_adapter,
803                                   budget_av->budget.dvb_frontend)) {
804                 printk(KERN_ERR "budget-av: Frontend registration failed!\n");
805                 if (budget_av->budget.dvb_frontend->ops->release)
806                         budget_av->budget.dvb_frontend->ops->release(budget_av->budget.dvb_frontend);
807                 budget_av->budget.dvb_frontend = NULL;
808         }
809 }
810
811
812 static void budget_av_irq(struct saa7146_dev *dev, u32 * isr)
813 {
814         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
815
816         dprintk(8, "dev: %p, budget_av: %p\n", dev, budget_av);
817
818         if (*isr & MASK_10)
819                 ttpci_budget_irq10_handler(dev, isr);
820 }
821
822 static int budget_av_detach(struct saa7146_dev *dev)
823 {
824         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
825         int err;
826
827         dprintk(2, "dev: %p\n", dev);
828
829         if (1 == budget_av->has_saa7113) {
830                 saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTLO);
831
832                 msleep(200);
833
834                 saa7146_unregister_device(&budget_av->vd, dev);
835         }
836
837         if (budget_av->budget.ci_present)
838                 ciintf_deinit(budget_av);
839
840         if (budget_av->budget.dvb_frontend != NULL)
841                 dvb_unregister_frontend(budget_av->budget.dvb_frontend);
842         err = ttpci_budget_deinit(&budget_av->budget);
843
844         kfree(budget_av);
845
846         return err;
847 }
848
849 static struct saa7146_ext_vv vv_data;
850
851 static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
852 {
853         struct budget_av *budget_av;
854         u8 *mac;
855         int err;
856
857         dprintk(2, "dev: %p\n", dev);
858
859         if (!(budget_av = kmalloc(sizeof(struct budget_av), GFP_KERNEL)))
860                 return -ENOMEM;
861
862         memset(budget_av, 0, sizeof(struct budget_av));
863
864         budget_av->has_saa7113 = 0;
865         budget_av->budget.ci_present = 0;
866
867         dev->ext_priv = budget_av;
868
869         if ((err = ttpci_budget_init(&budget_av->budget, dev, info, THIS_MODULE))) {
870                 kfree(budget_av);
871                 return err;
872         }
873
874         /* knc1 initialization */
875         saa7146_write(dev, DD1_STREAM_B, 0x04000000);
876         saa7146_write(dev, DD1_INIT, 0x07000600);
877         saa7146_write(dev, MC2, MASK_09 | MASK_25 | MASK_10 | MASK_26);
878
879         if (saa7113_init(budget_av) == 0) {
880                 budget_av->has_saa7113 = 1;
881
882                 if (0 != saa7146_vv_init(dev, &vv_data)) {
883                         /* fixme: proper cleanup here */
884                         ERR(("cannot init vv subsystem.\n"));
885                         return err;
886                 }
887
888                 if ((err = saa7146_register_device(&budget_av->vd, dev, "knc1", VFL_TYPE_GRABBER))) {
889                         /* fixme: proper cleanup here */
890                         ERR(("cannot register capture v4l2 device.\n"));
891                         return err;
892                 }
893
894                 /* beware: this modifies dev->vv ... */
895                 saa7146_set_hps_source_and_sync(dev, SAA7146_HPS_SOURCE_PORT_A,
896                                                 SAA7146_HPS_SYNC_PORT_A);
897
898                 saa7113_setinput(budget_av, 0);
899         } else {
900                 ciintf_init(budget_av);
901         }
902
903         /* fixme: find some sane values here... */
904         saa7146_write(dev, PCI_BT_V1, 0x1c00101f);
905
906         mac = budget_av->budget.dvb_adapter.proposed_mac;
907         if (i2c_readregs(&budget_av->budget.i2c_adap, 0xa0, 0x30, mac, 6)) {
908                 printk(KERN_ERR "KNC1-%d: Could not read MAC from KNC1 card\n",
909                        budget_av->budget.dvb_adapter.num);
910                 memset(mac, 0, 6);
911         } else {
912                 printk(KERN_INFO "KNC1-%d: MAC addr = %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
913                        budget_av->budget.dvb_adapter.num,
914                        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
915         }
916
917         budget_av->budget.dvb_adapter.priv = budget_av;
918         frontend_init(budget_av);
919
920         return 0;
921 }
922
923 #define KNC1_INPUTS 2
924 static struct v4l2_input knc1_inputs[KNC1_INPUTS] = {
925         {0, "Composite", V4L2_INPUT_TYPE_TUNER, 1, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
926         {1, "S-Video", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG | V4L2_STD_NTSC_M, 0},
927 };
928
929 static struct saa7146_extension_ioctls ioctls[] = {
930         {VIDIOC_ENUMINPUT, SAA7146_EXCLUSIVE},
931         {VIDIOC_G_INPUT, SAA7146_EXCLUSIVE},
932         {VIDIOC_S_INPUT, SAA7146_EXCLUSIVE},
933         {0, 0}
934 };
935
936 static int av_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
937 {
938         struct saa7146_dev *dev = fh->dev;
939         struct budget_av *budget_av = (struct budget_av *) dev->ext_priv;
940
941         switch (cmd) {
942         case VIDIOC_ENUMINPUT:{
943                 struct v4l2_input *i = arg;
944
945                 dprintk(1, "VIDIOC_ENUMINPUT %d.\n", i->index);
946                 if (i->index < 0 || i->index >= KNC1_INPUTS) {
947                         return -EINVAL;
948                 }
949                 memcpy(i, &knc1_inputs[i->index], sizeof(struct v4l2_input));
950                 return 0;
951         }
952         case VIDIOC_G_INPUT:{
953                 int *input = (int *) arg;
954
955                 *input = budget_av->cur_input;
956
957                 dprintk(1, "VIDIOC_G_INPUT %d.\n", *input);
958                 return 0;
959         }
960         case VIDIOC_S_INPUT:{
961                 int input = *(int *) arg;
962                 dprintk(1, "VIDIOC_S_INPUT %d.\n", input);
963                 return saa7113_setinput(budget_av, input);
964         }
965         default:
966                 return -ENOIOCTLCMD;
967         }
968         return 0;
969 }
970
971 static struct saa7146_standard standard[] = {
972         {.name = "PAL",.id = V4L2_STD_PAL,
973          .v_offset = 0x17,.v_field = 288,
974          .h_offset = 0x14,.h_pixels = 680,
975          .v_max_out = 576,.h_max_out = 768 },
976
977         {.name = "NTSC",.id = V4L2_STD_NTSC,
978          .v_offset = 0x16,.v_field = 240,
979          .h_offset = 0x06,.h_pixels = 708,
980          .v_max_out = 480,.h_max_out = 640, },
981 };
982
983 static struct saa7146_ext_vv vv_data = {
984         .inputs = 2,
985         .capabilities = 0,      // perhaps later: V4L2_CAP_VBI_CAPTURE, but that need tweaking with the saa7113
986         .flags = 0,
987         .stds = &standard[0],
988         .num_stds = sizeof(standard) / sizeof(struct saa7146_standard),
989         .ioctls = &ioctls[0],
990         .ioctl = av_ioctl,
991 };
992
993 static struct saa7146_extension budget_extension;
994
995 MAKE_BUDGET_INFO(knc1s, "KNC1 DVB-S", BUDGET_KNC1S);
996 MAKE_BUDGET_INFO(knc1c, "KNC1 DVB-C", BUDGET_KNC1C);
997 MAKE_BUDGET_INFO(knc1t, "KNC1 DVB-T", BUDGET_KNC1T);
998 MAKE_BUDGET_INFO(knc1sp, "KNC1 DVB-S Plus", BUDGET_KNC1SP);
999 MAKE_BUDGET_INFO(knc1cp, "KNC1 DVB-C Plus", BUDGET_KNC1CP);
1000 MAKE_BUDGET_INFO(knc1tp, "KNC1 DVB-T Plus", BUDGET_KNC1TP);
1001 MAKE_BUDGET_INFO(cin1200s, "TerraTec Cinergy 1200 DVB-S", BUDGET_CIN1200S);
1002 MAKE_BUDGET_INFO(cin1200c, "Terratec Cinergy 1200 DVB-C", BUDGET_CIN1200C);
1003 MAKE_BUDGET_INFO(cin1200t, "Terratec Cinergy 1200 DVB-T", BUDGET_CIN1200T);
1004
1005 static struct pci_device_id pci_tbl[] = {
1006         MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x4f56),
1007         MAKE_EXTENSION_PCI(knc1s, 0x1131, 0x0010),
1008         MAKE_EXTENSION_PCI(knc1sp, 0x1131, 0x0011),
1009         MAKE_EXTENSION_PCI(knc1c, 0x1894, 0x0020),
1010         MAKE_EXTENSION_PCI(knc1cp, 0x1894, 0x0021),
1011         MAKE_EXTENSION_PCI(knc1t, 0x1894, 0x0030),
1012         MAKE_EXTENSION_PCI(knc1tp, 0x1894, 0x0031),
1013         MAKE_EXTENSION_PCI(cin1200s, 0x153b, 0x1154),
1014         MAKE_EXTENSION_PCI(cin1200c, 0x153b, 0x1156),
1015         MAKE_EXTENSION_PCI(cin1200t, 0x153b, 0x1157),
1016         {
1017          .vendor = 0,
1018         }
1019 };
1020
1021 MODULE_DEVICE_TABLE(pci, pci_tbl);
1022
1023 static struct saa7146_extension budget_extension = {
1024         .name = "budget_av",
1025         .pci_tbl = pci_tbl,
1026
1027         .module = THIS_MODULE,
1028         .attach = budget_av_attach,
1029         .detach = budget_av_detach,
1030
1031         .irq_mask = MASK_10,
1032         .irq_func = budget_av_irq,
1033 };
1034
1035 static int __init budget_av_init(void)
1036 {
1037         return saa7146_register_extension(&budget_extension);
1038 }
1039
1040 static void __exit budget_av_exit(void)
1041 {
1042         saa7146_unregister_extension(&budget_extension);
1043 }
1044
1045 module_init(budget_av_init);
1046 module_exit(budget_av_exit);
1047
1048 MODULE_LICENSE("GPL");
1049 MODULE_AUTHOR("Ralph Metzler, Marcus Metzler, Michael Hunold, others");
1050 MODULE_DESCRIPTION("driver for the SAA7146 based so-called "
1051                    "budget PCI DVB w/ analog input and CI-module (e.g. the KNC cards)");