[PATCH] dvb: Twinhan DST: frontend polarization fix
[linux-2.6.git] / drivers / media / dvb / bt8xx / dst.c
1 /*
2
3         Frontend/Card driver for TwinHan DST Frontend
4         Copyright (C) 2003 Jamie Honan
5         Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
6
7         This program is free software; you can redistribute it and/or modify
8         it under the terms of the GNU General Public License as published by
9         the Free Software Foundation; either version 2 of the License, or
10         (at your option) any later version.
11
12         This program is distributed in the hope that it will be useful,
13         but WITHOUT ANY WARRANTY; without even the implied warranty of
14         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15         GNU General Public License for more details.
16
17         You should have received a copy of the GNU General Public License
18         along with this program; if not, write to the Free Software
19         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22
23 #include <linux/kernel.h>
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/string.h>
27 #include <linux/slab.h>
28 #include <linux/vmalloc.h>
29 #include <linux/delay.h>
30 #include <asm/div64.h>
31
32 #include "dvb_frontend.h"
33 #include "dst_priv.h"
34 #include "dst_common.h"
35
36
37 static unsigned int verbose = 1;
38 module_param(verbose, int, 0644);
39 MODULE_PARM_DESC(verbose, "verbose startup messages, default is 1 (yes)");
40
41 static unsigned int debug = 1;
42 module_param(debug, int, 0644);
43 MODULE_PARM_DESC(debug, "debug messages, default is 0 (yes)");
44
45 static unsigned int dst_addons;
46 module_param(dst_addons, int, 0644);
47 MODULE_PARM_DESC(dst_addons, "CA daughterboard, default is 0 (No addons)");
48
49 #define dprintk if (debug) printk
50
51 #define HAS_LOCK        1
52 #define ATTEMPT_TUNE    2
53 #define HAS_POWER       4
54
55 static void dst_packsize(struct dst_state* state, int psize)
56 {
57         union dst_gpio_packet bits;
58
59         bits.psize = psize;
60         bt878_device_control(state->bt, DST_IG_TS, &bits);
61 }
62
63 int dst_gpio_outb(struct dst_state* state, u32 mask, u32 enbb, u32 outhigh, int delay)
64 {
65         union dst_gpio_packet enb;
66         union dst_gpio_packet bits;
67         int err;
68
69         enb.enb.mask = mask;
70         enb.enb.enable = enbb;
71         if (verbose > 4)
72                 dprintk("%s: mask=[%04x], enbb=[%04x], outhigh=[%04x]\n", __FUNCTION__, mask, enbb, outhigh);
73
74         if ((err = bt878_device_control(state->bt, DST_IG_ENABLE, &enb)) < 0) {
75                 dprintk("%s: dst_gpio_enb error (err == %i, mask == %02x, enb == %02x)\n", __FUNCTION__, err, mask, enbb);
76                 return -EREMOTEIO;
77         }
78         udelay(1000);
79         /* because complete disabling means no output, no need to do output packet */
80         if (enbb == 0)
81                 return 0;
82
83         if (delay)
84                 msleep(10);
85
86         bits.outp.mask = enbb;
87         bits.outp.highvals = outhigh;
88
89         if ((err = bt878_device_control(state->bt, DST_IG_WRITE, &bits)) < 0) {
90                 dprintk("%s: dst_gpio_outb error (err == %i, enbb == %02x, outhigh == %02x)\n", __FUNCTION__, err, enbb, outhigh);
91                 return -EREMOTEIO;
92         }
93         return 0;
94 }
95 EXPORT_SYMBOL(dst_gpio_outb);
96
97 int dst_gpio_inb(struct dst_state *state, u8 * result)
98 {
99         union dst_gpio_packet rd_packet;
100         int err;
101
102         *result = 0;
103
104         if ((err = bt878_device_control(state->bt, DST_IG_READ, &rd_packet)) < 0) {
105                 dprintk("%s: dst_gpio_inb error (err == %i)\n", __FUNCTION__, err);
106                 return -EREMOTEIO;
107         }
108
109         *result = (u8) rd_packet.rd.value;
110         return 0;
111 }
112 EXPORT_SYMBOL(dst_gpio_inb);
113
114 int rdc_reset_state(struct dst_state *state)
115 {
116         if (verbose > 1)
117                 dprintk("%s: Resetting state machine\n", __FUNCTION__);
118
119         if (dst_gpio_outb(state, RDC_8820_INT, RDC_8820_INT, 0, NO_DELAY) < 0) {
120                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
121                 return -1;
122         }
123
124         msleep(10);
125
126         if (dst_gpio_outb(state, RDC_8820_INT, RDC_8820_INT, RDC_8820_INT, NO_DELAY) < 0) {
127                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
128                 msleep(10);
129                 return -1;
130         }
131
132         return 0;
133 }
134 EXPORT_SYMBOL(rdc_reset_state);
135
136 int rdc_8820_reset(struct dst_state *state)
137 {
138         if (verbose > 1)
139                 dprintk("%s: Resetting DST\n", __FUNCTION__);
140
141         if (dst_gpio_outb(state, RDC_8820_RESET, RDC_8820_RESET, 0, NO_DELAY) < 0) {
142                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
143                 return -1;
144         }
145         udelay(1000);
146         if (dst_gpio_outb(state, RDC_8820_RESET, RDC_8820_RESET, RDC_8820_RESET, DELAY) < 0) {
147                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
148                 return -1;
149         }
150
151         return 0;
152 }
153 EXPORT_SYMBOL(rdc_8820_reset);
154
155 int dst_pio_enable(struct dst_state *state)
156 {
157         if (dst_gpio_outb(state, ~0, RDC_8820_PIO_0_ENABLE, 0, NO_DELAY) < 0) {
158                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
159                 return -1;
160         }
161         udelay(1000);
162         return 0;
163 }
164 EXPORT_SYMBOL(dst_pio_enable);
165
166 int dst_pio_disable(struct dst_state *state)
167 {
168         if (dst_gpio_outb(state, ~0, RDC_8820_PIO_0_DISABLE, RDC_8820_PIO_0_DISABLE, NO_DELAY) < 0) {
169                 dprintk("%s: dst_gpio_outb ERROR !\n", __FUNCTION__);
170                 return -1;
171         }
172         if (state->type_flags & DST_TYPE_HAS_FW_1)
173                 udelay(1000);
174
175         return 0;
176 }
177 EXPORT_SYMBOL(dst_pio_disable);
178
179 int dst_wait_dst_ready(struct dst_state *state, u8 delay_mode)
180 {
181         u8 reply;
182         int i;
183
184         for (i = 0; i < 200; i++) {
185                 if (dst_gpio_inb(state, &reply) < 0) {
186                         dprintk("%s: dst_gpio_inb ERROR !\n", __FUNCTION__);
187                         return -1;
188                 }
189
190                 if ((reply & RDC_8820_PIO_0_ENABLE) == 0) {
191                         if (verbose > 4)
192                                 dprintk("%s: dst wait ready after %d\n", __FUNCTION__, i);
193                         return 1;
194                 }
195                 msleep(10);
196         }
197         if (verbose > 1)
198                 dprintk("%s: dst wait NOT ready after %d\n", __FUNCTION__, i);
199
200         return 0;
201 }
202 EXPORT_SYMBOL(dst_wait_dst_ready);
203
204 int dst_error_recovery(struct dst_state *state)
205 {
206         dprintk("%s: Trying to return from previous errors...\n", __FUNCTION__);
207         dst_pio_disable(state);
208         msleep(10);
209         dst_pio_enable(state);
210         msleep(10);
211
212         return 0;
213 }
214 EXPORT_SYMBOL(dst_error_recovery);
215
216 int dst_error_bailout(struct dst_state *state)
217 {
218         dprintk("%s: Trying to bailout from previous error...\n", __FUNCTION__);
219         rdc_8820_reset(state);
220         dst_pio_disable(state);
221         msleep(10);
222
223         return 0;
224 }
225 EXPORT_SYMBOL(dst_error_bailout);
226
227
228 int dst_comm_init(struct dst_state* state)
229 {
230         if (verbose > 1)
231                 dprintk ("%s: Initializing DST..\n", __FUNCTION__);
232         if ((dst_pio_enable(state)) < 0) {
233                 dprintk("%s: PIO Enable Failed.\n", __FUNCTION__);
234                 return -1;
235         }
236         if ((rdc_reset_state(state)) < 0) {
237                 dprintk("%s: RDC 8820 State RESET Failed.\n", __FUNCTION__);
238                 return -1;
239         }
240         if (state->type_flags & DST_TYPE_HAS_FW_1)
241                 msleep(100);
242         else
243                 msleep(5);
244
245         return 0;
246 }
247 EXPORT_SYMBOL(dst_comm_init);
248
249
250 int write_dst(struct dst_state *state, u8 *data, u8 len)
251 {
252         struct i2c_msg msg = {
253                 .addr = state->config->demod_address,.flags = 0,.buf = data,.len = len
254         };
255
256         int err;
257         int cnt;
258         if (debug && (verbose > 4)) {
259                 u8 i;
260                 if (verbose > 4) {
261                         dprintk("%s writing [ ", __FUNCTION__);
262                         for (i = 0; i < len; i++)
263                                 dprintk("%02x ", data[i]);
264                         dprintk("]\n");
265                 }
266         }
267         for (cnt = 0; cnt < 2; cnt++) {
268                 if ((err = i2c_transfer(state->i2c, &msg, 1)) < 0) {
269                         dprintk("%s: _write_dst error (err == %i, len == 0x%02x, b0 == 0x%02x)\n", __FUNCTION__, err, len, data[0]);
270                         dst_error_recovery(state);
271                         continue;
272                 } else
273                         break;
274         }
275
276         if (cnt >= 2) {
277                 if (verbose > 1)
278                         printk("%s: RDC 8820 RESET...\n", __FUNCTION__);
279                 dst_error_bailout(state);
280
281                 return -1;
282         }
283
284         return 0;
285 }
286 EXPORT_SYMBOL(write_dst);
287
288 int read_dst(struct dst_state *state, u8 * ret, u8 len)
289 {
290         struct i2c_msg msg = {.addr = state->config->demod_address,.flags = I2C_M_RD,.buf = ret,.len = len };
291         int err;
292         int cnt;
293
294         for (cnt = 0; cnt < 2; cnt++) {
295                 if ((err = i2c_transfer(state->i2c, &msg, 1)) < 0) {
296
297                         dprintk("%s: read_dst error (err == %i, len == 0x%02x, b0 == 0x%02x)\n", __FUNCTION__, err, len, ret[0]);
298                         dst_error_recovery(state);
299
300                         continue;
301                 } else
302                         break;
303         }
304         if (cnt >= 2) {
305                 if (verbose > 1)
306                         printk("%s: RDC 8820 RESET...\n", __FUNCTION__);
307                 dst_error_bailout(state);
308
309                 return -1;
310         }
311         if (debug && (verbose > 4)) {
312                 dprintk("%s reply is 0x%x\n", __FUNCTION__, ret[0]);
313                 for (err = 1; err < len; err++)
314                         dprintk(" 0x%x", ret[err]);
315                 if (err > 1)
316                         dprintk("\n");
317         }
318
319         return 0;
320 }
321 EXPORT_SYMBOL(read_dst);
322
323 static int dst_set_polarization(struct dst_state *state)
324 {
325         switch (state->voltage) {
326                 case SEC_VOLTAGE_13:    // vertical
327                         printk("%s: Polarization=[Vertical]\n", __FUNCTION__);
328                         state->tx_tuna[8] &= ~0x40;  //1
329                         break;
330
331                 case SEC_VOLTAGE_18:    // horizontal
332                         printk("%s: Polarization=[Horizontal]\n", __FUNCTION__);
333                         state->tx_tuna[8] |= 0x40;  // 0
334                         break;
335
336                 case SEC_VOLTAGE_OFF:
337
338                         break;
339         }
340
341         return 0;
342 }
343
344 static int dst_set_freq(struct dst_state *state, u32 freq)
345 {
346         state->frequency = freq;
347         if (debug > 4)
348                 dprintk("%s: set Frequency %u\n", __FUNCTION__, freq);
349
350         if (state->dst_type == DST_TYPE_IS_SAT) {
351                 freq = freq / 1000;
352                 if (freq < 950 || freq > 2150)
353                         return -EINVAL;
354
355                 state->tx_tuna[2] = (freq >> 8);
356                 state->tx_tuna[3] = (u8) freq;
357                 state->tx_tuna[4] = 0x01;
358                 state->tx_tuna[8] &= ~0x04;
359                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS) {
360                         if (freq < 1531)
361                                 state->tx_tuna[8] |= 0x04;
362                 }
363
364         } else if (state->dst_type == DST_TYPE_IS_TERR) {
365                 freq = freq / 1000;
366                 if (freq < 137000 || freq > 858000)
367                         return -EINVAL;
368
369                 state->tx_tuna[2] = (freq >> 16) & 0xff;
370                 state->tx_tuna[3] = (freq >> 8) & 0xff;
371                 state->tx_tuna[4] = (u8) freq;
372
373         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
374                 state->tx_tuna[2] = (freq >> 16) & 0xff;
375                 state->tx_tuna[3] = (freq >> 8) & 0xff;
376                 state->tx_tuna[4] = (u8) freq;
377
378         } else
379                 return -EINVAL;
380         return 0;
381 }
382
383 static int dst_set_bandwidth(struct dst_state* state, fe_bandwidth_t bandwidth)
384 {
385         state->bandwidth = bandwidth;
386
387         if (state->dst_type != DST_TYPE_IS_TERR)
388                 return 0;
389
390         switch (bandwidth) {
391                 case BANDWIDTH_6_MHZ:
392                         if (state->dst_hw_cap & DST_TYPE_HAS_CA)
393                                 state->tx_tuna[7] = 0x06;
394                         else {
395                                 state->tx_tuna[6] = 0x06;
396                                 state->tx_tuna[7] = 0x00;
397                         }
398                         break;
399
400                 case BANDWIDTH_7_MHZ:
401                         if (state->dst_hw_cap & DST_TYPE_HAS_CA)
402                                 state->tx_tuna[7] = 0x07;
403                         else {
404                                 state->tx_tuna[6] = 0x07;
405                                 state->tx_tuna[7] = 0x00;
406                         }
407                         break;
408
409                 case BANDWIDTH_8_MHZ:
410                         if (state->dst_hw_cap & DST_TYPE_HAS_CA)
411                                 state->tx_tuna[7] = 0x08;
412                         else {
413                                 state->tx_tuna[6] = 0x08;
414                                 state->tx_tuna[7] = 0x00;
415                         }
416                         break;
417
418                 default:
419                         return -EINVAL;
420         }
421         return 0;
422 }
423
424 static int dst_set_inversion(struct dst_state* state, fe_spectral_inversion_t inversion)
425 {
426         state->inversion = inversion;
427         switch (inversion) {
428                 case INVERSION_OFF:     // Inversion = Normal
429                         state->tx_tuna[8] &= ~0x80;
430                         break;
431
432                 case INVERSION_ON:
433                         state->tx_tuna[8] |= 0x80;
434                         break;
435                 default:
436                         return -EINVAL;
437         }
438         return 0;
439 }
440
441 static int dst_set_fec(struct dst_state* state, fe_code_rate_t fec)
442 {
443         state->fec = fec;
444         return 0;
445 }
446
447 static fe_code_rate_t dst_get_fec(struct dst_state* state)
448 {
449         return state->fec;
450 }
451
452 static int dst_set_symbolrate(struct dst_state* state, u32 srate)
453 {
454         u8 *val;
455         u32 symcalc;
456         u64 sval;
457
458         state->symbol_rate = srate;
459
460         if (state->dst_type == DST_TYPE_IS_TERR) {
461                 return 0;
462         }
463         if (debug > 4)
464                 dprintk("%s: set symrate %u\n", __FUNCTION__, srate);
465         srate /= 1000;
466         val = &state->tx_tuna[0];
467
468         if (state->type_flags & DST_TYPE_HAS_SYMDIV) {
469                 sval = srate;
470                 sval <<= 20;
471                 do_div(sval, 88000);
472                 symcalc = (u32) sval;
473
474                 if (debug > 4)
475                         dprintk("%s: set symcalc %u\n", __FUNCTION__, symcalc);
476
477                 val[5] = (u8) (symcalc >> 12);
478                 val[6] = (u8) (symcalc >> 4);
479                 val[7] = (u8) (symcalc << 4);
480         } else {
481                 val[5] = (u8) (srate >> 16) & 0x7f;
482                 val[6] = (u8) (srate >> 8);
483                 val[7] = (u8) srate;
484         }
485         val[8] &= ~0x20;
486         if (srate > 8000)
487                 val[8] |= 0x20;
488         return 0;
489 }
490
491
492 static int dst_set_modulation(struct dst_state *state, fe_modulation_t modulation)
493 {
494         if (state->dst_type != DST_TYPE_IS_CABLE)
495                 return 0;
496
497         state->modulation = modulation;
498         switch (modulation) {
499                 case QAM_16:
500                         state->tx_tuna[8] = 0x10;
501                         break;
502
503                 case QAM_32:
504                         state->tx_tuna[8] = 0x20;
505                         break;
506
507                 case QAM_64:
508                         state->tx_tuna[8] = 0x40;
509                         break;
510
511                 case QAM_128:
512                         state->tx_tuna[8] = 0x80;
513                         break;
514
515                 case QAM_256:
516                         state->tx_tuna[8] = 0x00;
517                         break;
518
519                 case QPSK:
520                 case QAM_AUTO:
521                 case VSB_8:
522                 case VSB_16:
523                 default:
524                         return -EINVAL;
525
526         }
527
528         return 0;
529 }
530
531 static fe_modulation_t dst_get_modulation(struct dst_state *state)
532 {
533         return state->modulation;
534 }
535
536
537 u8 dst_check_sum(u8 * buf, u32 len)
538 {
539         u32 i;
540         u8 val = 0;
541         if (!len)
542                 return 0;
543         for (i = 0; i < len; i++) {
544                 val += buf[i];
545         }
546         return ((~val) + 1);
547 }
548 EXPORT_SYMBOL(dst_check_sum);
549
550 static void dst_type_flags_print(u32 type_flags)
551 {
552         printk("DST type flags :");
553         if (type_flags & DST_TYPE_HAS_NEWTUNE)
554                 printk(" 0x%x newtuner", DST_TYPE_HAS_NEWTUNE);
555         if (type_flags & DST_TYPE_HAS_TS204)
556                 printk(" 0x%x ts204", DST_TYPE_HAS_TS204);
557         if (type_flags & DST_TYPE_HAS_SYMDIV)
558                 printk(" 0x%x symdiv", DST_TYPE_HAS_SYMDIV);
559         if (type_flags & DST_TYPE_HAS_FW_1)
560                 printk(" 0x%x firmware version = 1", DST_TYPE_HAS_FW_1);
561         if (type_flags & DST_TYPE_HAS_FW_2)
562                 printk(" 0x%x firmware version = 2", DST_TYPE_HAS_FW_2);
563         if (type_flags & DST_TYPE_HAS_FW_3)
564                 printk(" 0x%x firmware version = 3", DST_TYPE_HAS_FW_3);
565 //      if ((type_flags & DST_TYPE_HAS_FW_BUILD) && new_fw)
566
567         printk("\n");
568 }
569
570
571 static int dst_type_print (u8 type)
572 {
573         char *otype;
574         switch (type) {
575         case DST_TYPE_IS_SAT:
576                 otype = "satellite";
577                 break;
578
579         case DST_TYPE_IS_TERR:
580                 otype = "terrestrial";
581                 break;
582
583         case DST_TYPE_IS_CABLE:
584                 otype = "cable";
585                 break;
586
587         default:
588                 printk("%s: invalid dst type %d\n", __FUNCTION__, type);
589                 return -EINVAL;
590         }
591         printk("DST type : %s\n", otype);
592
593         return 0;
594 }
595
596 /*
597         Known cards list
598         Satellite
599         -------------------
600                   200103A
601         VP-1020   DST-MOT       LG(old), TS=188
602
603         VP-1020   DST-03T       LG(new), TS=204
604         VP-1022   DST-03T       LG(new), TS=204
605         VP-1025   DST-03T       LG(new), TS=204
606
607         VP-1030   DSTMCI,       LG(new), TS=188
608         VP-1032   DSTMCI,       LG(new), TS=188
609
610         Cable
611         -------------------
612         VP-2030   DCT-CI,       Samsung, TS=204
613         VP-2021   DCT-CI,       Unknown, TS=204
614         VP-2031   DCT-CI,       Philips, TS=188
615         VP-2040   DCT-CI,       Philips, TS=188, with CA daughter board
616         VP-2040   DCT-CI,       Philips, TS=204, without CA daughter board
617
618         Terrestrial
619         -------------------
620         VP-3050  DTTNXT                  TS=188
621         VP-3040  DTT-CI,        Philips, TS=188
622         VP-3040  DTT-CI,        Philips, TS=204
623
624         ATSC
625         -------------------
626         VP-3220  ATSCDI,                 TS=188
627         VP-3250  ATSCAD,                 TS=188
628
629 */
630
631 struct dst_types dst_tlist[] = {
632         {
633                 .device_id = "200103A",
634                 .offset = 0,
635                 .dst_type =  DST_TYPE_IS_SAT,
636                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1 | DST_TYPE_HAS_OBS_REGS,
637                 .dst_feature = 0
638         },      /*      obsolete        */
639
640         {
641                 .device_id = "DST-020",
642                 .offset = 0,
643                 .dst_type =  DST_TYPE_IS_SAT,
644                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1,
645                 .dst_feature = 0
646         },      /*      obsolete        */
647
648         {
649                 .device_id = "DST-030",
650                 .offset =  0,
651                 .dst_type = DST_TYPE_IS_SAT,
652                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_1,
653                 .dst_feature = 0
654         },      /*      obsolete        */
655
656         {
657                 .device_id = "DST-03T",
658                 .offset = 0,
659                 .dst_type = DST_TYPE_IS_SAT,
660                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_TS204 | DST_TYPE_HAS_FW_2,
661                 .dst_feature = DST_TYPE_HAS_DISEQC3 | DST_TYPE_HAS_DISEQC4 | DST_TYPE_HAS_DISEQC5
662                                                          | DST_TYPE_HAS_MAC | DST_TYPE_HAS_MOTO
663          },
664
665         {
666                 .device_id = "DST-MOT",
667                 .offset =  0,
668                 .dst_type = DST_TYPE_IS_SAT,
669                 .type_flags = DST_TYPE_HAS_SYMDIV | DST_TYPE_HAS_FW_1,
670                 .dst_feature = 0
671         },      /*      obsolete        */
672
673         {
674                 .device_id = "DST-CI",
675                 .offset = 1,
676                 .dst_type = DST_TYPE_IS_SAT,
677                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_1,
678                 .dst_feature = DST_TYPE_HAS_CA
679         },      /*      An OEM board    */
680
681         {
682                 .device_id = "DSTMCI",
683                 .offset = 1,
684                 .dst_type = DST_TYPE_IS_SAT,
685                 .type_flags = DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_FW_BUILD | DST_TYPE_HAS_INC_COUNT,
686                 .dst_feature = DST_TYPE_HAS_CA | DST_TYPE_HAS_DISEQC3 | DST_TYPE_HAS_DISEQC4
687                                                         | DST_TYPE_HAS_MOTO | DST_TYPE_HAS_MAC
688         },
689
690         {
691                 .device_id = "DSTFCI",
692                 .offset = 1,
693                 .dst_type = DST_TYPE_IS_SAT,
694                 .type_flags = DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_1,
695                 .dst_feature = 0
696         },      /* unknown to vendor    */
697
698         {
699                 .device_id = "DCT-CI",
700                 .offset = 1,
701                 .dst_type = DST_TYPE_IS_CABLE,
702                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_1
703                                                         | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_FW_BUILD,
704                 .dst_feature = DST_TYPE_HAS_CA
705         },
706
707         {
708                 .device_id = "DCTNEW",
709                 .offset = 1,
710                 .dst_type = DST_TYPE_IS_CABLE,
711                 .type_flags = DST_TYPE_HAS_NEWTUNE | DST_TYPE_HAS_FW_3,
712                 .dst_feature = 0
713         },
714
715         {
716                 .device_id = "DTT-CI",
717                 .offset = 1,
718                 .dst_type = DST_TYPE_IS_TERR,
719                 .type_flags = DST_TYPE_HAS_TS204 | DST_TYPE_HAS_FW_2 | DST_TYPE_HAS_FW_BUILD,
720                 .dst_feature = 0
721         },
722
723         {
724                 .device_id = "DTTDIG",
725                 .offset = 1,
726                 .dst_type = DST_TYPE_IS_TERR,
727                 .type_flags = DST_TYPE_HAS_FW_2,
728                 .dst_feature = 0
729         },
730
731         {
732                 .device_id = "DTTNXT",
733                 .offset = 1,
734                 .dst_type = DST_TYPE_IS_TERR,
735                 .type_flags = DST_TYPE_HAS_FW_2,
736                 .dst_feature = DST_TYPE_HAS_ANALOG
737         },
738
739         {
740                 .device_id = "ATSCDI",
741                 .offset = 1,
742                 .dst_type = DST_TYPE_IS_ATSC,
743                 .type_flags = DST_TYPE_HAS_FW_2,
744                 .dst_feature = 0
745         },
746
747         {
748                 .device_id = "ATSCAD",
749                 .offset = 1,
750                 .dst_type = DST_TYPE_IS_ATSC,
751                 .type_flags = DST_TYPE_HAS_FW_2,
752                 .dst_feature = 0
753         },
754
755         { }
756
757 };
758
759
760 static int dst_get_device_id(struct dst_state *state)
761 {
762         u8 reply;
763
764         int i;
765         struct dst_types *p_dst_type;
766         u8 use_dst_type = 0;
767         u32 use_type_flags = 0;
768
769         static u8 device_type[8] = {0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff};
770
771         device_type[7] = dst_check_sum(device_type, 7);
772
773         if (write_dst(state, device_type, FIXED_COMM))
774                 return -1;              /*      Write failed            */
775
776         if ((dst_pio_disable(state)) < 0)
777                 return -1;
778
779         if (read_dst(state, &reply, GET_ACK))
780                 return -1;              /*      Read failure            */
781
782         if (reply != ACK) {
783                 dprintk("%s: Write not Acknowledged! [Reply=0x%02x]\n", __FUNCTION__, reply);
784                 return -1;              /*      Unack'd write           */
785         }
786
787         if (!dst_wait_dst_ready(state, DEVICE_INIT))
788                 return -1;              /*      DST not ready yet       */
789
790         if (read_dst(state, state->rxbuffer, FIXED_COMM))
791                 return -1;
792
793         dst_pio_disable(state);
794
795         if (state->rxbuffer[7] != dst_check_sum(state->rxbuffer, 7)) {
796                 dprintk("%s: Checksum failure! \n", __FUNCTION__);
797                 return -1;              /*      Checksum failure        */
798         }
799
800         state->rxbuffer[7] = '\0';
801
802         for (i = 0, p_dst_type = dst_tlist; i < ARRAY_SIZE (dst_tlist); i++, p_dst_type++) {
803                 if (!strncmp (&state->rxbuffer[p_dst_type->offset], p_dst_type->device_id, strlen (p_dst_type->device_id))) {
804                         use_type_flags = p_dst_type->type_flags;
805                         use_dst_type = p_dst_type->dst_type;
806
807                         /*      Card capabilities       */
808                         state->dst_hw_cap = p_dst_type->dst_feature;
809                         printk ("%s: Recognise [%s]\n", __FUNCTION__, p_dst_type->device_id);
810
811                         break;
812                 }
813         }
814
815         if (i >= sizeof (dst_tlist) / sizeof (dst_tlist [0])) {
816                 printk("%s: Unable to recognize %s or %s\n", __FUNCTION__, &state->rxbuffer[0], &state->rxbuffer[1]);
817                 printk("%s: please email linux-dvb@linuxtv.org with this type in\n", __FUNCTION__);
818                 use_dst_type = DST_TYPE_IS_SAT;
819                 use_type_flags = DST_TYPE_HAS_SYMDIV;
820         }
821
822         dst_type_print(use_dst_type);
823         state->type_flags = use_type_flags;
824         state->dst_type = use_dst_type;
825         dst_type_flags_print(state->type_flags);
826
827         if (state->type_flags & DST_TYPE_HAS_TS204) {
828                 dst_packsize(state, 204);
829         }
830
831         return 0;
832 }
833
834 static int dst_probe(struct dst_state *state)
835 {
836         if ((rdc_8820_reset(state)) < 0) {
837                 dprintk("%s: RDC 8820 RESET Failed.\n", __FUNCTION__);
838                 return -1;
839         }
840         if (dst_addons & DST_TYPE_HAS_CA)
841                 msleep(4000);
842         else
843                 msleep(100);
844
845         if ((dst_comm_init(state)) < 0) {
846                 dprintk("%s: DST Initialization Failed.\n", __FUNCTION__);
847                 return -1;
848         }
849         msleep(100);
850         if (dst_get_device_id(state) < 0) {
851                 dprintk("%s: unknown device.\n", __FUNCTION__);
852                 return -1;
853         }
854
855         return 0;
856 }
857
858 int dst_command(struct dst_state* state, u8 * data, u8 len)
859 {
860         u8 reply;
861         if ((dst_comm_init(state)) < 0) {
862                 dprintk("%s: DST Communication Initialization Failed.\n", __FUNCTION__);
863                 return -1;
864         }
865
866         if (write_dst(state, data, len)) {
867                 if (verbose > 1)
868                         dprintk("%s: Tring to recover.. \n", __FUNCTION__);
869                 if ((dst_error_recovery(state)) < 0) {
870                         dprintk("%s: Recovery Failed.\n", __FUNCTION__);
871                         return -1;
872                 }
873                 return -1;
874         }
875         if ((dst_pio_disable(state)) < 0) {
876                 dprintk("%s: PIO Disable Failed.\n", __FUNCTION__);
877                 return -1;
878         }
879         if (state->type_flags & DST_TYPE_HAS_FW_1)
880                 udelay(3000);
881
882         if (read_dst(state, &reply, GET_ACK)) {
883                 if (verbose > 1)
884                         dprintk("%s: Trying to recover.. \n", __FUNCTION__);
885                 if ((dst_error_recovery(state)) < 0) {
886                         dprintk("%s: Recovery Failed.\n", __FUNCTION__);
887                         return -1;
888                 }
889                 return -1;
890         }
891
892         if (reply != ACK) {
893                 dprintk("%s: write not acknowledged 0x%02x \n", __FUNCTION__, reply);
894                 return -1;
895         }
896         if (len >= 2 && data[0] == 0 && (data[1] == 1 || data[1] == 3))
897                 return 0;
898
899 //      udelay(3000);
900         if (state->type_flags & DST_TYPE_HAS_FW_1)
901                 udelay(3000);
902         else
903                 udelay(2000);
904
905         if (!dst_wait_dst_ready(state, NO_DELAY))
906                 return -1;
907
908         if (read_dst(state, state->rxbuffer, FIXED_COMM)) {
909                 if (verbose > 1)
910                         dprintk("%s: Trying to recover.. \n", __FUNCTION__);
911                 if ((dst_error_recovery(state)) < 0) {
912                         dprintk("%s: Recovery failed.\n", __FUNCTION__);
913                         return -1;
914                 }
915                 return -1;
916         }
917
918         if (state->rxbuffer[7] != dst_check_sum(state->rxbuffer, 7)) {
919                 dprintk("%s: checksum failure\n", __FUNCTION__);
920                 return -1;
921         }
922
923         return 0;
924 }
925 EXPORT_SYMBOL(dst_command);
926
927 static int dst_get_signal(struct dst_state* state)
928 {
929         int retval;
930         u8 get_signal[] = { 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb };
931         printk("%s: Getting Signal strength and other parameters !!!!!!!!\n", __FUNCTION__);
932         if ((state->diseq_flags & ATTEMPT_TUNE) == 0) {
933                 state->decode_lock = state->decode_strength = state->decode_snr = 0;
934                 return 0;
935         }
936         if (0 == (state->diseq_flags & HAS_LOCK)) {
937                 state->decode_lock = state->decode_strength = state->decode_snr = 0;
938                 return 0;
939         }
940         if (time_after_eq(jiffies, state->cur_jiff + (HZ / 5))) {
941                 retval = dst_command(state, get_signal, 8);
942                 if (retval < 0)
943                         return retval;
944                 if (state->dst_type == DST_TYPE_IS_SAT) {
945                         state->decode_lock = ((state->rxbuffer[6] & 0x10) == 0) ? 1 : 0;
946                         state->decode_strength = state->rxbuffer[5] << 8;
947                         state->decode_snr = state->rxbuffer[2] << 8 | state->rxbuffer[3];
948                 } else if ((state->dst_type == DST_TYPE_IS_TERR) || (state->dst_type == DST_TYPE_IS_CABLE)) {
949                         state->decode_lock = (state->rxbuffer[1]) ? 1 : 0;
950                         state->decode_strength = state->rxbuffer[4] << 8;
951                         state->decode_snr = state->rxbuffer[3] << 8;
952                 }
953                 state->cur_jiff = jiffies;
954         }
955         return 0;
956 }
957
958 static int dst_tone_power_cmd(struct dst_state* state)
959 {
960         u8 paket[8] = { 0x00, 0x09, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00 };
961
962         if (state->dst_type == DST_TYPE_IS_TERR)
963                 return 0;
964
965         paket[4] = state->tx_tuna[4];
966         paket[2] = state->tx_tuna[2];
967         paket[3] = state->tx_tuna[3];
968         paket[7] = dst_check_sum (paket, 7);
969         dst_command(state, paket, 8);
970
971         return 0;
972 }
973
974 static int dst_get_tuna(struct dst_state* state)
975 {
976         int retval;
977
978         if ((state->diseq_flags & ATTEMPT_TUNE) == 0)
979                 return 0;
980
981         state->diseq_flags &= ~(HAS_LOCK);
982         if (!dst_wait_dst_ready(state, NO_DELAY))
983                 return 0;
984
985         if (state->type_flags & DST_TYPE_HAS_NEWTUNE) {
986                 /* how to get variable length reply ???? */
987                 retval = read_dst(state, state->rx_tuna, 10);
988         } else {
989                 retval = read_dst(state, &state->rx_tuna[2], FIXED_COMM);
990         }
991
992         if (retval < 0) {
993                 dprintk("%s: read not successful\n", __FUNCTION__);
994                 return 0;
995         }
996
997         if (state->type_flags & DST_TYPE_HAS_NEWTUNE) {
998                 if (state->rx_tuna[9] != dst_check_sum(&state->rx_tuna[0], 9)) {
999                         dprintk("%s: checksum failure?\n", __FUNCTION__);
1000                         return 0;
1001                 }
1002         } else {
1003                 if (state->rx_tuna[9] != dst_check_sum(&state->rx_tuna[2], 7)) {
1004                         dprintk("%s: checksum failure?\n", __FUNCTION__);
1005                         return 0;
1006                 }
1007         }
1008         if (state->rx_tuna[2] == 0 && state->rx_tuna[3] == 0)
1009                 return 0;
1010         state->decode_freq = ((state->rx_tuna[2] & 0x7f) << 8) + state->rx_tuna[3];
1011
1012         state->decode_lock = 1;
1013         state->diseq_flags |= HAS_LOCK;
1014
1015         return 1;
1016 }
1017
1018 static int dst_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage);
1019
1020 static int dst_write_tuna(struct dvb_frontend* fe)
1021 {
1022         struct dst_state* state = fe->demodulator_priv;
1023         int retval;
1024         u8 reply;
1025
1026         if (debug > 4)
1027                 dprintk("%s: type_flags 0x%x \n", __FUNCTION__, state->type_flags);
1028
1029         state->decode_freq = 0;
1030         state->decode_lock = state->decode_strength = state->decode_snr = 0;
1031         if (state->dst_type == DST_TYPE_IS_SAT) {
1032                 if (!(state->diseq_flags & HAS_POWER))
1033                         dst_set_voltage(fe, SEC_VOLTAGE_13);
1034         }
1035         state->diseq_flags &= ~(HAS_LOCK | ATTEMPT_TUNE);
1036
1037         if ((dst_comm_init(state)) < 0) {
1038                 dprintk("%s: DST Communication initialization failed.\n", __FUNCTION__);
1039                 return -1;
1040         }
1041
1042         if (state->type_flags & DST_TYPE_HAS_NEWTUNE) {
1043                 state->tx_tuna[9] = dst_check_sum(&state->tx_tuna[0], 9);
1044                 retval = write_dst(state, &state->tx_tuna[0], 10);
1045
1046         } else {
1047                 state->tx_tuna[9] = dst_check_sum(&state->tx_tuna[2], 7);
1048                 retval = write_dst(state, &state->tx_tuna[2], FIXED_COMM);
1049         }
1050         if (retval < 0) {
1051                 dst_pio_disable(state);
1052                 dprintk("%s: write not successful\n", __FUNCTION__);
1053                 return retval;
1054         }
1055
1056         if ((dst_pio_disable(state)) < 0) {
1057                 dprintk("%s: DST PIO disable failed !\n", __FUNCTION__);
1058                 return -1;
1059         }
1060
1061         if ((read_dst(state, &reply, GET_ACK) < 0)) {
1062                 dprintk("%s: read verify not successful.\n", __FUNCTION__);
1063                 return -1;
1064         }
1065         if (reply != ACK) {
1066                 dprintk("%s: write not acknowledged 0x%02x \n", __FUNCTION__, reply);
1067                 return 0;
1068         }
1069         state->diseq_flags |= ATTEMPT_TUNE;
1070
1071         return dst_get_tuna(state);
1072 }
1073
1074 /*
1075  * line22k0    0x00, 0x09, 0x00, 0xff, 0x01, 0x00, 0x00, 0x00
1076  * line22k1    0x00, 0x09, 0x01, 0xff, 0x01, 0x00, 0x00, 0x00
1077  * line22k2    0x00, 0x09, 0x02, 0xff, 0x01, 0x00, 0x00, 0x00
1078  * tone        0x00, 0x09, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00
1079  * data        0x00, 0x09, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00
1080  * power_off   0x00, 0x09, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00
1081  * power_on    0x00, 0x09, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00
1082  * Diseqc 1    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf0, 0xec
1083  * Diseqc 2    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf4, 0xe8
1084  * Diseqc 3    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf8, 0xe4
1085  * Diseqc 4    0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xfc, 0xe0
1086  */
1087
1088 static int dst_set_diseqc(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd* cmd)
1089 {
1090         struct dst_state* state = fe->demodulator_priv;
1091         u8 paket[8] = { 0x00, 0x08, 0x04, 0xe0, 0x10, 0x38, 0xf0, 0xec };
1092
1093         if (state->dst_type != DST_TYPE_IS_SAT)
1094                 return 0;
1095
1096         if (cmd->msg_len == 0 || cmd->msg_len > 4)
1097                 return -EINVAL;
1098         memcpy(&paket[3], cmd->msg, cmd->msg_len);
1099         paket[7] = dst_check_sum(&paket[0], 7);
1100         dst_command(state, paket, 8);
1101         return 0;
1102 }
1103
1104 static int dst_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
1105 {
1106         int need_cmd;
1107         struct dst_state* state = fe->demodulator_priv;
1108
1109         state->voltage = voltage;
1110
1111         if (state->dst_type != DST_TYPE_IS_SAT)
1112                 return 0;
1113
1114         need_cmd = 0;
1115         switch (voltage) {
1116                 case SEC_VOLTAGE_13:
1117                 case SEC_VOLTAGE_18:
1118                         if ((state->diseq_flags & HAS_POWER) == 0)
1119                                 need_cmd = 1;
1120                         state->diseq_flags |= HAS_POWER;
1121                         state->tx_tuna[4] = 0x01;
1122                         break;
1123
1124                 case SEC_VOLTAGE_OFF:
1125                         need_cmd = 1;
1126                         state->diseq_flags &= ~(HAS_POWER | HAS_LOCK | ATTEMPT_TUNE);
1127                         state->tx_tuna[4] = 0x00;
1128                         break;
1129
1130                 default:
1131                         return -EINVAL;
1132         }
1133         if (need_cmd)
1134                 dst_tone_power_cmd(state);
1135
1136         return 0;
1137 }
1138
1139 static int dst_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
1140 {
1141         struct dst_state* state = fe->demodulator_priv;
1142
1143         state->tone = tone;
1144
1145         if (state->dst_type != DST_TYPE_IS_SAT)
1146                 return 0;
1147
1148         switch (tone) {
1149                 case SEC_TONE_OFF:
1150                         state->tx_tuna[2] = 0xff;
1151                         break;
1152
1153                 case SEC_TONE_ON:
1154                         state->tx_tuna[2] = 0x02;
1155                         break;
1156
1157                 default:
1158                         return -EINVAL;
1159         }
1160         dst_tone_power_cmd(state);
1161
1162         return 0;
1163 }
1164
1165 static int dst_send_burst(struct dvb_frontend *fe, fe_sec_mini_cmd_t minicmd)
1166 {
1167         struct dst_state *state = fe->demodulator_priv;
1168
1169         if (state->dst_type != DST_TYPE_IS_SAT)
1170                 return 0;
1171
1172         state->minicmd = minicmd;
1173
1174         switch (minicmd) {
1175                 case SEC_MINI_A:
1176                         state->tx_tuna[3] = 0x02;
1177                         break;
1178                 case SEC_MINI_B:
1179                         state->tx_tuna[3] = 0xff;
1180                         break;
1181         }
1182         dst_tone_power_cmd(state);
1183
1184         return 0;
1185 }
1186
1187
1188 static int dst_init(struct dvb_frontend* fe)
1189 {
1190         struct dst_state* state = fe->demodulator_priv;
1191         static u8 ini_satci_tuna[] = { 9, 0, 3, 0xb6, 1, 0, 0x73, 0x21, 0, 0 };
1192         static u8 ini_satfta_tuna[] = { 0, 0, 3, 0xb6, 1, 0x55, 0xbd, 0x50, 0, 0 };
1193         static u8 ini_tvfta_tuna[] = { 0, 0, 3, 0xb6, 1, 7, 0x0, 0x0, 0, 0 };
1194         static u8 ini_tvci_tuna[] = { 9, 0, 3, 0xb6, 1, 7, 0x0, 0x0, 0, 0 };
1195         static u8 ini_cabfta_tuna[] = { 0, 0, 3, 0xb6, 1, 7, 0x0, 0x0, 0, 0 };
1196         static u8 ini_cabci_tuna[] = { 9, 0, 3, 0xb6, 1, 7, 0x0, 0x0, 0, 0 };
1197 //      state->inversion = INVERSION_ON;
1198         state->inversion = INVERSION_OFF;
1199         state->voltage = SEC_VOLTAGE_13;
1200         state->tone = SEC_TONE_OFF;
1201         state->symbol_rate = 29473000;
1202         state->fec = FEC_AUTO;
1203         state->diseq_flags = 0;
1204         state->k22 = 0x02;
1205         state->bandwidth = BANDWIDTH_7_MHZ;
1206         state->cur_jiff = jiffies;
1207         if (state->dst_type == DST_TYPE_IS_SAT) {
1208                 state->frequency = 950000;
1209                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_NEWTUNE) ? ini_satci_tuna : ini_satfta_tuna), sizeof(ini_satfta_tuna));
1210         } else if (state->dst_type == DST_TYPE_IS_TERR) {
1211                 state->frequency = 137000000;
1212                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_NEWTUNE) ? ini_tvci_tuna : ini_tvfta_tuna), sizeof(ini_tvfta_tuna));
1213         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
1214                 state->frequency = 51000000;
1215                 memcpy(state->tx_tuna, ((state->type_flags & DST_TYPE_HAS_NEWTUNE) ? ini_cabci_tuna : ini_cabfta_tuna), sizeof(ini_cabfta_tuna));
1216         }
1217
1218         return 0;
1219 }
1220
1221 static int dst_read_status(struct dvb_frontend* fe, fe_status_t* status)
1222 {
1223         struct dst_state* state = fe->demodulator_priv;
1224
1225         *status = 0;
1226         if (state->diseq_flags & HAS_LOCK) {
1227 //              dst_get_signal(state);  // don't require(?) to ask MCU
1228                 if (state->decode_lock)
1229                         *status |= FE_HAS_LOCK | FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_SYNC | FE_HAS_VITERBI;
1230         }
1231
1232         return 0;
1233 }
1234
1235 static int dst_read_signal_strength(struct dvb_frontend* fe, u16* strength)
1236 {
1237         struct dst_state* state = fe->demodulator_priv;
1238
1239         dst_get_signal(state);
1240         *strength = state->decode_strength;
1241
1242         return 0;
1243 }
1244
1245 static int dst_read_snr(struct dvb_frontend* fe, u16* snr)
1246 {
1247         struct dst_state* state = fe->demodulator_priv;
1248
1249         dst_get_signal(state);
1250         *snr = state->decode_snr;
1251
1252         return 0;
1253 }
1254
1255 static int dst_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
1256 {
1257         struct dst_state* state = fe->demodulator_priv;
1258
1259         dst_set_freq(state, p->frequency);
1260         if (verbose > 4)
1261                 dprintk("Set Frequency=[%d]\n", p->frequency);
1262
1263 //      dst_set_inversion(state, p->inversion);
1264         if (state->dst_type == DST_TYPE_IS_SAT) {
1265                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1266                         dst_set_inversion(state, p->inversion);
1267
1268                 dst_set_fec(state, p->u.qpsk.fec_inner);
1269                 dst_set_symbolrate(state, p->u.qpsk.symbol_rate);
1270                 dst_set_polarization(state);
1271                 if (verbose > 4)
1272                         dprintk("Set Symbolrate=[%d]\n", p->u.qpsk.symbol_rate);
1273
1274         } else if (state->dst_type == DST_TYPE_IS_TERR) {
1275                 dst_set_bandwidth(state, p->u.ofdm.bandwidth);
1276         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
1277                 dst_set_fec(state, p->u.qam.fec_inner);
1278                 dst_set_symbolrate(state, p->u.qam.symbol_rate);
1279                 dst_set_modulation(state, p->u.qam.modulation);
1280         }
1281         dst_write_tuna(fe);
1282
1283         return 0;
1284 }
1285
1286 static int dst_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
1287 {
1288         struct dst_state* state = fe->demodulator_priv;
1289
1290         p->frequency = state->decode_freq;
1291 //      p->inversion = state->inversion;
1292         if (state->dst_type == DST_TYPE_IS_SAT) {
1293                 if (state->type_flags & DST_TYPE_HAS_OBS_REGS)
1294                         p->inversion = state->inversion;
1295
1296                 p->u.qpsk.symbol_rate = state->symbol_rate;
1297                 p->u.qpsk.fec_inner = dst_get_fec(state);
1298         } else if (state->dst_type == DST_TYPE_IS_TERR) {
1299                 p->u.ofdm.bandwidth = state->bandwidth;
1300         } else if (state->dst_type == DST_TYPE_IS_CABLE) {
1301                 p->u.qam.symbol_rate = state->symbol_rate;
1302                 p->u.qam.fec_inner = dst_get_fec(state);
1303 //              p->u.qam.modulation = QAM_AUTO;
1304                 p->u.qam.modulation = dst_get_modulation(state);
1305         }
1306
1307         return 0;
1308 }
1309
1310 static void dst_release(struct dvb_frontend* fe)
1311 {
1312         struct dst_state* state = fe->demodulator_priv;
1313         kfree(state);
1314 }
1315
1316 static struct dvb_frontend_ops dst_dvbt_ops;
1317 static struct dvb_frontend_ops dst_dvbs_ops;
1318 static struct dvb_frontend_ops dst_dvbc_ops;
1319
1320 struct dst_state* dst_attach(struct dst_state *state, struct dvb_adapter *dvb_adapter)
1321 {
1322
1323         /* check if the ASIC is there */
1324         if (dst_probe(state) < 0) {
1325                 if (state)
1326                         kfree(state);
1327
1328                 return NULL;
1329         }
1330         /* determine settings based on type */
1331         switch (state->dst_type) {
1332         case DST_TYPE_IS_TERR:
1333                 memcpy(&state->ops, &dst_dvbt_ops, sizeof(struct dvb_frontend_ops));
1334                 break;
1335
1336         case DST_TYPE_IS_CABLE:
1337                 memcpy(&state->ops, &dst_dvbc_ops, sizeof(struct dvb_frontend_ops));
1338                 break;
1339
1340         case DST_TYPE_IS_SAT:
1341                 memcpy(&state->ops, &dst_dvbs_ops, sizeof(struct dvb_frontend_ops));
1342                 break;
1343
1344         default:
1345                 printk("%s: unknown DST type. please report to the LinuxTV.org DVB mailinglist.\n", __FUNCTION__);
1346                 if (state)
1347                         kfree(state);
1348
1349                 return NULL;
1350         }
1351
1352         /* create dvb_frontend */
1353         state->frontend.ops = &state->ops;
1354         state->frontend.demodulator_priv = state;
1355
1356         return state;                           /*      Manu (DST is a card not a frontend)     */
1357 }
1358
1359 EXPORT_SYMBOL(dst_attach);
1360
1361 static struct dvb_frontend_ops dst_dvbt_ops = {
1362
1363         .info = {
1364                 .name = "DST DVB-T",
1365                 .type = FE_OFDM,
1366                 .frequency_min = 137000000,
1367                 .frequency_max = 858000000,
1368                 .frequency_stepsize = 166667,
1369                 .caps = FE_CAN_FEC_AUTO | FE_CAN_QAM_AUTO | FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_GUARD_INTERVAL_AUTO
1370         },
1371
1372         .release = dst_release,
1373
1374         .init = dst_init,
1375
1376         .set_frontend = dst_set_frontend,
1377         .get_frontend = dst_get_frontend,
1378
1379         .read_status = dst_read_status,
1380         .read_signal_strength = dst_read_signal_strength,
1381         .read_snr = dst_read_snr,
1382 };
1383
1384 static struct dvb_frontend_ops dst_dvbs_ops = {
1385
1386         .info = {
1387                 .name = "DST DVB-S",
1388                 .type = FE_QPSK,
1389                 .frequency_min = 950000,
1390                 .frequency_max = 2150000,
1391                 .frequency_stepsize = 1000,     /* kHz for QPSK frontends */
1392                 .frequency_tolerance = 29500,
1393                 .symbol_rate_min = 1000000,
1394                 .symbol_rate_max = 45000000,
1395         /*     . symbol_rate_tolerance  =       ???,*/
1396                 .caps = FE_CAN_FEC_AUTO | FE_CAN_QPSK
1397         },
1398
1399         .release = dst_release,
1400
1401         .init = dst_init,
1402
1403         .set_frontend = dst_set_frontend,
1404         .get_frontend = dst_get_frontend,
1405
1406         .read_status = dst_read_status,
1407         .read_signal_strength = dst_read_signal_strength,
1408         .read_snr = dst_read_snr,
1409
1410         .diseqc_send_burst = dst_send_burst,
1411         .diseqc_send_master_cmd = dst_set_diseqc,
1412         .set_voltage = dst_set_voltage,
1413         .set_tone = dst_set_tone,
1414 };
1415
1416 static struct dvb_frontend_ops dst_dvbc_ops = {
1417
1418         .info = {
1419                 .name = "DST DVB-C",
1420                 .type = FE_QAM,
1421                 .frequency_stepsize = 62500,
1422                 .frequency_min = 51000000,
1423                 .frequency_max = 858000000,
1424                 .symbol_rate_min = 1000000,
1425                 .symbol_rate_max = 45000000,
1426         /*     . symbol_rate_tolerance  =       ???,*/
1427                 .caps = FE_CAN_FEC_AUTO | FE_CAN_QAM_AUTO
1428         },
1429
1430         .release = dst_release,
1431
1432         .init = dst_init,
1433
1434         .set_frontend = dst_set_frontend,
1435         .get_frontend = dst_get_frontend,
1436
1437         .read_status = dst_read_status,
1438         .read_signal_strength = dst_read_signal_strength,
1439         .read_snr = dst_read_snr,
1440 };
1441
1442
1443 MODULE_DESCRIPTION("DST DVB-S/T/C Combo Frontend driver");
1444 MODULE_AUTHOR("Jamie Honan, Manu Abraham");
1445 MODULE_LICENSE("GPL");