Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfashe...
[linux-2.6] / drivers / media / dvb / frontends / lgdt330x.c
1 /*
2  *    Support for LGDT3302 and LGDT3303 - VSB/QAM
3  *
4  *    Copyright (C) 2005 Wilson Michaels <wilsonmichaels@earthlink.net>
5  *
6  *    This program is free software; you can redistribute it and/or modify
7  *    it under the terms of the GNU General Public License as published by
8  *    the Free Software Foundation; either version 2 of the License, or
9  *    (at your option) any later version.
10  *
11  *    This program is distributed in the hope that it will be useful,
12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *    GNU General Public License for more details.
15  *
16  *    You should have received a copy of the GNU General Public License
17  *    along with this program; if not, write to the Free Software
18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  *
20  */
21
22 /*
23  *                      NOTES ABOUT THIS DRIVER
24  *
25  * This Linux driver supports:
26  *   DViCO FusionHDTV 3 Gold-Q
27  *   DViCO FusionHDTV 3 Gold-T
28  *   DViCO FusionHDTV 5 Gold
29  *   DViCO FusionHDTV 5 Lite
30  *   DViCO FusionHDTV 5 USB Gold
31  *   Air2PC/AirStar 2 ATSC 3rd generation (HD5000)
32  *   pcHDTV HD5500
33  *
34  */
35
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/moduleparam.h>
39 #include <linux/init.h>
40 #include <linux/delay.h>
41 #include <linux/string.h>
42 #include <linux/slab.h>
43 #include <asm/byteorder.h>
44
45 #include "dvb_frontend.h"
46 #include "dvb_math.h"
47 #include "lgdt330x_priv.h"
48 #include "lgdt330x.h"
49
50 /* Use Equalizer Mean Squared Error instead of Phaser Tracker MSE */
51 /* #define USE_EQMSE */
52
53 static int debug = 0;
54 module_param(debug, int, 0644);
55 MODULE_PARM_DESC(debug,"Turn on/off lgdt330x frontend debugging (default:off).");
56 #define dprintk(args...) \
57 do { \
58 if (debug) printk(KERN_DEBUG "lgdt330x: " args); \
59 } while (0)
60
61 struct lgdt330x_state
62 {
63         struct i2c_adapter* i2c;
64
65         /* Configuration settings */
66         const struct lgdt330x_config* config;
67
68         struct dvb_frontend frontend;
69
70         /* Demodulator private data */
71         fe_modulation_t current_modulation;
72         u32 snr; /* Result of last SNR calculation */
73
74         /* Tuner private data */
75         u32 current_frequency;
76 };
77
78 static int i2c_write_demod_bytes (struct lgdt330x_state* state,
79                                   u8 *buf, /* data bytes to send */
80                                   int len  /* number of bytes to send */ )
81 {
82         struct i2c_msg msg =
83                 { .addr = state->config->demod_address,
84                   .flags = 0,
85                   .buf = buf,
86                   .len = 2 };
87         int i;
88         int err;
89
90         for (i=0; i<len-1; i+=2){
91                 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
92                         printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __FUNCTION__, msg.buf[0], msg.buf[1], err);
93                         if (err < 0)
94                                 return err;
95                         else
96                                 return -EREMOTEIO;
97                 }
98                 msg.buf += 2;
99         }
100         return 0;
101 }
102
103 /*
104  * This routine writes the register (reg) to the demod bus
105  * then reads the data returned for (len) bytes.
106  */
107
108 static u8 i2c_read_demod_bytes (struct lgdt330x_state* state,
109                                enum I2C_REG reg, u8* buf, int len)
110 {
111         u8 wr [] = { reg };
112         struct i2c_msg msg [] = {
113                 { .addr = state->config->demod_address,
114                   .flags = 0, .buf = wr,  .len = 1 },
115                 { .addr = state->config->demod_address,
116                   .flags = I2C_M_RD, .buf = buf, .len = len },
117         };
118         int ret;
119         ret = i2c_transfer(state->i2c, msg, 2);
120         if (ret != 2) {
121                 printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __FUNCTION__, state->config->demod_address, reg, ret);
122         } else {
123                 ret = 0;
124         }
125         return ret;
126 }
127
128 /* Software reset */
129 static int lgdt3302_SwReset(struct lgdt330x_state* state)
130 {
131         u8 ret;
132         u8 reset[] = {
133                 IRQ_MASK,
134                 0x00 /* bit 6 is active low software reset
135                       * bits 5-0 are 1 to mask interrupts */
136         };
137
138         ret = i2c_write_demod_bytes(state,
139                                     reset, sizeof(reset));
140         if (ret == 0) {
141
142                 /* force reset high (inactive) and unmask interrupts */
143                 reset[1] = 0x7f;
144                 ret = i2c_write_demod_bytes(state,
145                                             reset, sizeof(reset));
146         }
147         return ret;
148 }
149
150 static int lgdt3303_SwReset(struct lgdt330x_state* state)
151 {
152         u8 ret;
153         u8 reset[] = {
154                 0x02,
155                 0x00 /* bit 0 is active low software reset */
156         };
157
158         ret = i2c_write_demod_bytes(state,
159                                     reset, sizeof(reset));
160         if (ret == 0) {
161
162                 /* force reset high (inactive) */
163                 reset[1] = 0x01;
164                 ret = i2c_write_demod_bytes(state,
165                                             reset, sizeof(reset));
166         }
167         return ret;
168 }
169
170 static int lgdt330x_SwReset(struct lgdt330x_state* state)
171 {
172         switch (state->config->demod_chip) {
173         case LGDT3302:
174                 return lgdt3302_SwReset(state);
175         case LGDT3303:
176                 return lgdt3303_SwReset(state);
177         default:
178                 return -ENODEV;
179         }
180 }
181
182 static int lgdt330x_init(struct dvb_frontend* fe)
183 {
184         /* Hardware reset is done using gpio[0] of cx23880x chip.
185          * I'd like to do it here, but don't know how to find chip address.
186          * cx88-cards.c arranges for the reset bit to be inactive (high).
187          * Maybe there needs to be a callable function in cx88-core or
188          * the caller of this function needs to do it. */
189
190         /*
191          * Array of byte pairs <address, value>
192          * to initialize each different chip
193          */
194         static u8 lgdt3302_init_data[] = {
195                 /* Use 50MHz parameter values from spec sheet since xtal is 50 */
196                 /* Change the value of NCOCTFV[25:0] of carrier
197                    recovery center frequency register */
198                 VSB_CARRIER_FREQ0, 0x00,
199                 VSB_CARRIER_FREQ1, 0x87,
200                 VSB_CARRIER_FREQ2, 0x8e,
201                 VSB_CARRIER_FREQ3, 0x01,
202                 /* Change the TPCLK pin polarity
203                    data is valid on falling clock */
204                 DEMUX_CONTROL, 0xfb,
205                 /* Change the value of IFBW[11:0] of
206                    AGC IF/RF loop filter bandwidth register */
207                 AGC_RF_BANDWIDTH0, 0x40,
208                 AGC_RF_BANDWIDTH1, 0x93,
209                 AGC_RF_BANDWIDTH2, 0x00,
210                 /* Change the value of bit 6, 'nINAGCBY' and
211                    'NSSEL[1:0] of ACG function control register 2 */
212                 AGC_FUNC_CTRL2, 0xc6,
213                 /* Change the value of bit 6 'RFFIX'
214                    of AGC function control register 3 */
215                 AGC_FUNC_CTRL3, 0x40,
216                 /* Set the value of 'INLVTHD' register 0x2a/0x2c
217                    to 0x7fe */
218                 AGC_DELAY0, 0x07,
219                 AGC_DELAY2, 0xfe,
220                 /* Change the value of IAGCBW[15:8]
221                    of inner AGC loop filter bandwidth */
222                 AGC_LOOP_BANDWIDTH0, 0x08,
223                 AGC_LOOP_BANDWIDTH1, 0x9a
224         };
225
226         static u8 lgdt3303_init_data[] = {
227                 0x4c, 0x14
228         };
229
230         static u8 flip_lgdt3303_init_data[] = {
231                 0x4c, 0x14,
232                 0x87, 0xf3
233         };
234
235         struct lgdt330x_state* state = fe->demodulator_priv;
236         char  *chip_name;
237         int    err;
238
239         switch (state->config->demod_chip) {
240         case LGDT3302:
241                 chip_name = "LGDT3302";
242                 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
243                                             sizeof(lgdt3302_init_data));
244                 break;
245         case LGDT3303:
246                 chip_name = "LGDT3303";
247                 if (state->config->clock_polarity_flip) {
248                         err = i2c_write_demod_bytes(state, flip_lgdt3303_init_data,
249                                                     sizeof(flip_lgdt3303_init_data));
250                 } else {
251                         err = i2c_write_demod_bytes(state, lgdt3303_init_data,
252                                                     sizeof(lgdt3303_init_data));
253                 }
254                 break;
255         default:
256                 chip_name = "undefined";
257                 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
258                 err = -ENODEV;
259         }
260         dprintk("%s entered as %s\n", __FUNCTION__, chip_name);
261         if (err < 0)
262                 return err;
263         return lgdt330x_SwReset(state);
264 }
265
266 static int lgdt330x_read_ber(struct dvb_frontend* fe, u32* ber)
267 {
268         *ber = 0; /* Not supplied by the demod chips */
269         return 0;
270 }
271
272 static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
273 {
274         struct lgdt330x_state* state = fe->demodulator_priv;
275         int err;
276         u8 buf[2];
277
278         switch (state->config->demod_chip) {
279         case LGDT3302:
280                 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
281                                            buf, sizeof(buf));
282                 break;
283         case LGDT3303:
284                 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
285                                            buf, sizeof(buf));
286                 break;
287         default:
288                 printk(KERN_WARNING
289                        "Only LGDT3302 and LGDT3303 are supported chips.\n");
290                 err = -ENODEV;
291         }
292
293         *ucblocks = (buf[0] << 8) | buf[1];
294         return 0;
295 }
296
297 static int lgdt330x_set_parameters(struct dvb_frontend* fe,
298                                    struct dvb_frontend_parameters *param)
299 {
300         /*
301          * Array of byte pairs <address, value>
302          * to initialize 8VSB for lgdt3303 chip 50 MHz IF
303          */
304         static u8 lgdt3303_8vsb_44_data[] = {
305                 0x04, 0x00,
306                 0x0d, 0x40,
307                 0x0e, 0x87,
308                 0x0f, 0x8e,
309                 0x10, 0x01,
310                 0x47, 0x8b };
311
312         /*
313          * Array of byte pairs <address, value>
314          * to initialize QAM for lgdt3303 chip
315          */
316         static u8 lgdt3303_qam_data[] = {
317                 0x04, 0x00,
318                 0x0d, 0x00,
319                 0x0e, 0x00,
320                 0x0f, 0x00,
321                 0x10, 0x00,
322                 0x51, 0x63,
323                 0x47, 0x66,
324                 0x48, 0x66,
325                 0x4d, 0x1a,
326                 0x49, 0x08,
327                 0x4a, 0x9b };
328
329         struct lgdt330x_state* state = fe->demodulator_priv;
330
331         static u8 top_ctrl_cfg[]   = { TOP_CONTROL, 0x03 };
332
333         int err;
334         /* Change only if we are actually changing the modulation */
335         if (state->current_modulation != param->u.vsb.modulation) {
336                 switch(param->u.vsb.modulation) {
337                 case VSB_8:
338                         dprintk("%s: VSB_8 MODE\n", __FUNCTION__);
339
340                         /* Select VSB mode */
341                         top_ctrl_cfg[1] = 0x03;
342
343                         /* Select ANT connector if supported by card */
344                         if (state->config->pll_rf_set)
345                                 state->config->pll_rf_set(fe, 1);
346
347                         if (state->config->demod_chip == LGDT3303) {
348                                 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
349                                                             sizeof(lgdt3303_8vsb_44_data));
350                         }
351                         break;
352
353                 case QAM_64:
354                         dprintk("%s: QAM_64 MODE\n", __FUNCTION__);
355
356                         /* Select QAM_64 mode */
357                         top_ctrl_cfg[1] = 0x00;
358
359                         /* Select CABLE connector if supported by card */
360                         if (state->config->pll_rf_set)
361                                 state->config->pll_rf_set(fe, 0);
362
363                         if (state->config->demod_chip == LGDT3303) {
364                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
365                                                                                         sizeof(lgdt3303_qam_data));
366                         }
367                         break;
368
369                 case QAM_256:
370                         dprintk("%s: QAM_256 MODE\n", __FUNCTION__);
371
372                         /* Select QAM_256 mode */
373                         top_ctrl_cfg[1] = 0x01;
374
375                         /* Select CABLE connector if supported by card */
376                         if (state->config->pll_rf_set)
377                                 state->config->pll_rf_set(fe, 0);
378
379                         if (state->config->demod_chip == LGDT3303) {
380                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
381                                                                                         sizeof(lgdt3303_qam_data));
382                         }
383                         break;
384                 default:
385                         printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __FUNCTION__, param->u.vsb.modulation);
386                         return -1;
387                 }
388                 /*
389                  * select serial or parallel MPEG harware interface
390                  * Serial:   0x04 for LGDT3302 or 0x40 for LGDT3303
391                  * Parallel: 0x00
392                  */
393                 top_ctrl_cfg[1] |= state->config->serial_mpeg;
394
395                 /* Select the requested mode */
396                 i2c_write_demod_bytes(state, top_ctrl_cfg,
397                                       sizeof(top_ctrl_cfg));
398                 if (state->config->set_ts_params)
399                         state->config->set_ts_params(fe, 0);
400                 state->current_modulation = param->u.vsb.modulation;
401         }
402
403         /* Tune to the specified frequency */
404         if (fe->ops.tuner_ops.set_params) {
405                 fe->ops.tuner_ops.set_params(fe, param);
406                 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
407         }
408
409         /* Keep track of the new frequency */
410         /* FIXME this is the wrong way to do this...           */
411         /* The tuner is shared with the video4linux analog API */
412         state->current_frequency = param->frequency;
413
414         lgdt330x_SwReset(state);
415         return 0;
416 }
417
418 static int lgdt330x_get_frontend(struct dvb_frontend* fe,
419                                  struct dvb_frontend_parameters* param)
420 {
421         struct lgdt330x_state *state = fe->demodulator_priv;
422         param->frequency = state->current_frequency;
423         return 0;
424 }
425
426 static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
427 {
428         struct lgdt330x_state* state = fe->demodulator_priv;
429         u8 buf[3];
430
431         *status = 0; /* Reset status result */
432
433         /* AGC status register */
434         i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
435         dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
436         if ((buf[0] & 0x0c) == 0x8){
437                 /* Test signal does not exist flag */
438                 /* as well as the AGC lock flag.   */
439                 *status |= FE_HAS_SIGNAL;
440         }
441
442         /*
443          * You must set the Mask bits to 1 in the IRQ_MASK in order
444          * to see that status bit in the IRQ_STATUS register.
445          * This is done in SwReset();
446          */
447         /* signal status */
448         i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
449         dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __FUNCTION__, buf[0], buf[1], buf[2]);
450
451
452         /* sync status */
453         if ((buf[2] & 0x03) == 0x01) {
454                 *status |= FE_HAS_SYNC;
455         }
456
457         /* FEC error status */
458         if ((buf[2] & 0x0c) == 0x08) {
459                 *status |= FE_HAS_LOCK;
460                 *status |= FE_HAS_VITERBI;
461         }
462
463         /* Carrier Recovery Lock Status Register */
464         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
465         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
466         switch (state->current_modulation) {
467         case QAM_256:
468         case QAM_64:
469                 /* Need to undestand why there are 3 lock levels here */
470                 if ((buf[0] & 0x07) == 0x07)
471                         *status |= FE_HAS_CARRIER;
472                 break;
473         case VSB_8:
474                 if ((buf[0] & 0x80) == 0x80)
475                         *status |= FE_HAS_CARRIER;
476                 break;
477         default:
478                 printk("KERN_WARNING lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
479         }
480
481         return 0;
482 }
483
484 static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
485 {
486         struct lgdt330x_state* state = fe->demodulator_priv;
487         int err;
488         u8 buf[3];
489
490         *status = 0; /* Reset status result */
491
492         /* lgdt3303 AGC status register */
493         err = i2c_read_demod_bytes(state, 0x58, buf, 1);
494         if (err < 0)
495                 return err;
496
497         dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
498         if ((buf[0] & 0x21) == 0x01){
499                 /* Test input signal does not exist flag */
500                 /* as well as the AGC lock flag.   */
501                 *status |= FE_HAS_SIGNAL;
502         }
503
504         /* Carrier Recovery Lock Status Register */
505         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
506         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
507         switch (state->current_modulation) {
508         case QAM_256:
509         case QAM_64:
510                 /* Need to undestand why there are 3 lock levels here */
511                 if ((buf[0] & 0x07) == 0x07)
512                         *status |= FE_HAS_CARRIER;
513                 else
514                         break;
515                 i2c_read_demod_bytes(state, 0x8a, buf, 1);
516                 if ((buf[0] & 0x04) == 0x04)
517                         *status |= FE_HAS_SYNC;
518                 if ((buf[0] & 0x01) == 0x01)
519                         *status |= FE_HAS_LOCK;
520                 if ((buf[0] & 0x08) == 0x08)
521                         *status |= FE_HAS_VITERBI;
522                 break;
523         case VSB_8:
524                 if ((buf[0] & 0x80) == 0x80)
525                         *status |= FE_HAS_CARRIER;
526                 else
527                         break;
528                 i2c_read_demod_bytes(state, 0x38, buf, 1);
529                 if ((buf[0] & 0x02) == 0x00)
530                         *status |= FE_HAS_SYNC;
531                 if ((buf[0] & 0x01) == 0x01) {
532                         *status |= FE_HAS_LOCK;
533                         *status |= FE_HAS_VITERBI;
534                 }
535                 break;
536         default:
537                 printk("KERN_WARNING lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
538         }
539         return 0;
540 }
541
542 /* Calculate SNR estimation (scaled by 2^24)
543
544    8-VSB SNR equations from LGDT3302 and LGDT3303 datasheets, QAM
545    equations from LGDT3303 datasheet.  VSB is the same between the '02
546    and '03, so maybe QAM is too?  Perhaps someone with a newer datasheet
547    that has QAM information could verify?
548
549    For 8-VSB: (two ways, take your pick)
550    LGDT3302:
551      SNR_EQ = 10 * log10(25 * 24^2 / EQ_MSE)
552    LGDT3303:
553      SNR_EQ = 10 * log10(25 * 32^2 / EQ_MSE)
554    LGDT3302 & LGDT3303:
555      SNR_PT = 10 * log10(25 * 32^2 / PT_MSE)  (we use this one)
556    For 64-QAM:
557      SNR    = 10 * log10( 688128   / MSEQAM)
558    For 256-QAM:
559      SNR    = 10 * log10( 696320   / MSEQAM)
560
561    We re-write the snr equation as:
562      SNR * 2^24 = 10*(c - intlog10(MSE))
563    Where for 256-QAM, c = log10(696320) * 2^24, and so on. */
564
565 static u32 calculate_snr(u32 mse, u32 c)
566 {
567         if (mse == 0) /* No signal */
568                 return 0;
569
570         mse = intlog10(mse);
571         if (mse > c) {
572                 /* Negative SNR, which is possible, but realisticly the
573                 demod will lose lock before the signal gets this bad.  The
574                 API only allows for unsigned values, so just return 0 */
575                 return 0;
576         }
577         return 10*(c - mse);
578 }
579
580 static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
581 {
582         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
583         u8 buf[5];      /* read data buffer */
584         u32 noise;      /* noise value */
585         u32 c;          /* per-modulation SNR calculation constant */
586
587         switch(state->current_modulation) {
588         case VSB_8:
589                 i2c_read_demod_bytes(state, LGDT3302_EQPH_ERR0, buf, 5);
590 #ifdef USE_EQMSE
591                 /* Use Equalizer Mean-Square Error Register */
592                 /* SNR for ranges from -15.61 to +41.58 */
593                 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
594                 c = 69765745; /* log10(25*24^2)*2^24 */
595 #else
596                 /* Use Phase Tracker Mean-Square Error Register */
597                 /* SNR for ranges from -13.11 to +44.08 */
598                 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
599                 c = 73957994; /* log10(25*32^2)*2^24 */
600 #endif
601                 break;
602         case QAM_64:
603         case QAM_256:
604                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
605                 noise = ((buf[0] & 3) << 8) | buf[1];
606                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
607                 /* log10(688128)*2^24 and log10(696320)*2^24 */
608                 break;
609         default:
610                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
611                        __FUNCTION__);
612                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
613         }
614
615         state->snr = calculate_snr(noise, c);
616         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
617
618         dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __FUNCTION__, noise,
619                 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
620
621         return 0;
622 }
623
624 static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
625 {
626         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
627         u8 buf[5];      /* read data buffer */
628         u32 noise;      /* noise value */
629         u32 c;          /* per-modulation SNR calculation constant */
630
631         switch(state->current_modulation) {
632         case VSB_8:
633                 i2c_read_demod_bytes(state, LGDT3303_EQPH_ERR0, buf, 5);
634 #ifdef USE_EQMSE
635                 /* Use Equalizer Mean-Square Error Register */
636                 /* SNR for ranges from -16.12 to +44.08 */
637                 noise = ((buf[0] & 0x78) << 13) | (buf[1] << 8) | buf[2];
638                 c = 73957994; /* log10(25*32^2)*2^24 */
639 #else
640                 /* Use Phase Tracker Mean-Square Error Register */
641                 /* SNR for ranges from -13.11 to +44.08 */
642                 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
643                 c = 73957994; /* log10(25*32^2)*2^24 */
644 #endif
645                 break;
646         case QAM_64:
647         case QAM_256:
648                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
649                 noise = (buf[0] << 8) | buf[1];
650                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
651                 /* log10(688128)*2^24 and log10(696320)*2^24 */
652                 break;
653         default:
654                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
655                        __FUNCTION__);
656                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
657         }
658
659         state->snr = calculate_snr(noise, c);
660         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
661
662         dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __FUNCTION__, noise,
663                 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
664
665         return 0;
666 }
667
668 static int lgdt330x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
669 {
670         /* Calculate Strength from SNR up to 35dB */
671         /* Even though the SNR can go higher than 35dB, there is some comfort */
672         /* factor in having a range of strong signals that can show at 100%   */
673         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
674         u16 snr;
675         int ret;
676
677         ret = fe->ops.read_snr(fe, &snr);
678         if (ret != 0)
679                 return ret;
680         /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
681         /* scale the range 0 - 35*2^24 into 0 - 65535 */
682         if (state->snr >= 8960 * 0x10000)
683                 *strength = 0xffff;
684         else
685                 *strength = state->snr / 8960;
686
687         return 0;
688 }
689
690 static int lgdt330x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
691 {
692         /* I have no idea about this - it may not be needed */
693         fe_tune_settings->min_delay_ms = 500;
694         fe_tune_settings->step_size = 0;
695         fe_tune_settings->max_drift = 0;
696         return 0;
697 }
698
699 static void lgdt330x_release(struct dvb_frontend* fe)
700 {
701         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
702         kfree(state);
703 }
704
705 static struct dvb_frontend_ops lgdt3302_ops;
706 static struct dvb_frontend_ops lgdt3303_ops;
707
708 struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
709                                      struct i2c_adapter* i2c)
710 {
711         struct lgdt330x_state* state = NULL;
712         u8 buf[1];
713
714         /* Allocate memory for the internal state */
715         state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
716         if (state == NULL)
717                 goto error;
718
719         /* Setup the state */
720         state->config = config;
721         state->i2c = i2c;
722
723         /* Create dvb_frontend */
724         switch (config->demod_chip) {
725         case LGDT3302:
726                 memcpy(&state->frontend.ops, &lgdt3302_ops, sizeof(struct dvb_frontend_ops));
727                 break;
728         case LGDT3303:
729                 memcpy(&state->frontend.ops, &lgdt3303_ops, sizeof(struct dvb_frontend_ops));
730                 break;
731         default:
732                 goto error;
733         }
734         state->frontend.demodulator_priv = state;
735
736         /* Verify communication with demod chip */
737         if (i2c_read_demod_bytes(state, 2, buf, 1))
738                 goto error;
739
740         state->current_frequency = -1;
741         state->current_modulation = -1;
742
743         return &state->frontend;
744
745 error:
746         kfree(state);
747         dprintk("%s: ERROR\n",__FUNCTION__);
748         return NULL;
749 }
750
751 static struct dvb_frontend_ops lgdt3302_ops = {
752         .info = {
753                 .name= "LG Electronics LGDT3302 VSB/QAM Frontend",
754                 .type = FE_ATSC,
755                 .frequency_min= 54000000,
756                 .frequency_max= 858000000,
757                 .frequency_stepsize= 62500,
758                 .symbol_rate_min    = 5056941,  /* QAM 64 */
759                 .symbol_rate_max    = 10762000, /* VSB 8  */
760                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
761         },
762         .init                 = lgdt330x_init,
763         .set_frontend         = lgdt330x_set_parameters,
764         .get_frontend         = lgdt330x_get_frontend,
765         .get_tune_settings    = lgdt330x_get_tune_settings,
766         .read_status          = lgdt3302_read_status,
767         .read_ber             = lgdt330x_read_ber,
768         .read_signal_strength = lgdt330x_read_signal_strength,
769         .read_snr             = lgdt3302_read_snr,
770         .read_ucblocks        = lgdt330x_read_ucblocks,
771         .release              = lgdt330x_release,
772 };
773
774 static struct dvb_frontend_ops lgdt3303_ops = {
775         .info = {
776                 .name= "LG Electronics LGDT3303 VSB/QAM Frontend",
777                 .type = FE_ATSC,
778                 .frequency_min= 54000000,
779                 .frequency_max= 858000000,
780                 .frequency_stepsize= 62500,
781                 .symbol_rate_min    = 5056941,  /* QAM 64 */
782                 .symbol_rate_max    = 10762000, /* VSB 8  */
783                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
784         },
785         .init                 = lgdt330x_init,
786         .set_frontend         = lgdt330x_set_parameters,
787         .get_frontend         = lgdt330x_get_frontend,
788         .get_tune_settings    = lgdt330x_get_tune_settings,
789         .read_status          = lgdt3303_read_status,
790         .read_ber             = lgdt330x_read_ber,
791         .read_signal_strength = lgdt330x_read_signal_strength,
792         .read_snr             = lgdt3303_read_snr,
793         .read_ucblocks        = lgdt330x_read_ucblocks,
794         .release              = lgdt330x_release,
795 };
796
797 MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
798 MODULE_AUTHOR("Wilson Michaels");
799 MODULE_LICENSE("GPL");
800
801 EXPORT_SYMBOL(lgdt330x_attach);
802
803 /*
804  * Local variables:
805  * c-basic-offset: 8
806  * End:
807  */