V4L/DVB (6884): Add support for the Xceive xc5000 silicon tuner
[linux-2.6.git] / drivers / media / dvb / frontends / xc5000.c
1 /*
2  *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
3  *
4  *  Copyright (c) 2007 Xceive Corporation
5  *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.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  *
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/delay.h>
26 #include <linux/dvb/frontend.h>
27 #include <linux/i2c.h>
28
29 #include "dvb_frontend.h"
30
31 #include "xc5000.h"
32 #include "xc5000_priv.h"
33
34 static int debug;
35 module_param(debug, int, 0644);
36 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
37
38 #define dprintk(level,fmt, arg...) if (debug >= level) \
39         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
40
41 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.1.fw"
42 #define XC5000_DEFAULT_FIRMWARE_SIZE 12400
43
44 /* Misc Defines */
45 #define MAX_TV_STANDARD                 23
46 #define XC_MAX_I2C_WRITE_LENGTH         64
47
48 /* Signal Types */
49 #define XC_RF_MODE_AIR                  0
50 #define XC_RF_MODE_CABLE                1
51
52 /* Result codes */
53 #define XC_RESULT_SUCCESS               0
54 #define XC_RESULT_RESET_FAILURE         1
55 #define XC_RESULT_I2C_WRITE_FAILURE     2
56 #define XC_RESULT_I2C_READ_FAILURE      3
57 #define XC_RESULT_OUT_OF_RANGE          5
58
59 /* Registers */
60 #define XREG_INIT         0x00
61 #define XREG_VIDEO_MODE   0x01
62 #define XREG_AUDIO_MODE   0x02
63 #define XREG_RF_FREQ      0x03
64 #define XREG_D_CODE       0x04
65 #define XREG_IF_OUT       0x05
66 #define XREG_SEEK_MODE    0x07
67 #define XREG_POWER_DOWN   0x0A
68 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
69 #define XREG_SMOOTHEDCVBS 0x0E
70 #define XREG_XTALFREQ     0x0F
71 #define XREG_FINERFFREQ   0x10
72 #define XREG_DDIMODE      0x11
73
74 #define XREG_ADC_ENV      0x00
75 #define XREG_QUALITY      0x01
76 #define XREG_FRAME_LINES  0x02
77 #define XREG_HSYNC_FREQ   0x03
78 #define XREG_LOCK         0x04
79 #define XREG_FREQ_ERROR   0x05
80 #define XREG_SNR          0x06
81 #define XREG_VERSION      0x07
82 #define XREG_PRODUCT_ID   0x08
83 #define XREG_BUSY         0x09
84
85 /*
86    Basic firmware description. This will remain with
87    the driver for documentation purposes.
88
89    This represents an I2C firmware file encoded as a
90    string of unsigned char. Format is as follows:
91
92    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
93    char[1  ]=len0_LSB  -> length of first write transaction
94    char[2  ]=data0 -> first byte to be sent
95    char[3  ]=data1
96    char[4  ]=data2
97    char[   ]=...
98    char[M  ]=dataN  -> last byte to be sent
99    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
100    char[M+2]=len1_LSB  -> length of second write transaction
101    char[M+3]=data0
102    char[M+4]=data1
103    ...
104    etc.
105
106    The [len] value should be interpreted as follows:
107
108    len= len_MSB _ len_LSB
109    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
110    len=0000_0000_0000_0000   : Reset command: Do hardware reset
111    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
112    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
113
114    For the RESET and WAIT commands, the two following bytes will contain
115    immediately the length of the following transaction.
116
117 */
118 typedef struct {
119         char *Name;
120         unsigned short AudioMode;
121         unsigned short VideoMode;
122 } XC_TV_STANDARD;
123
124 /* Tuner standards */
125 #define DTV6    17
126
127 XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
128         {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
129         {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
130         {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
131         {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
132         {"B/G-PAL-A2",        0x0A00, 0x8049},
133         {"B/G-PAL-NICAM",     0x0C04, 0x8049},
134         {"B/G-PAL-MONO",      0x0878, 0x8059},
135         {"I-PAL-NICAM",       0x1080, 0x8009},
136         {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
137         {"D/K-PAL-A2",        0x1600, 0x8009},
138         {"D/K-PAL-NICAM",     0x0E80, 0x8009},
139         {"D/K-PAL-MONO",      0x1478, 0x8009},
140         {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
141         {"D/K-SECAM-A2 L/DK3",0x0E00, 0x8009},
142         {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
143         {"L-SECAM-NICAM",     0x8E82, 0x0009},
144         {"L'-SECAM-NICAM",    0x8E82, 0x4009},
145         {"DTV6",              0x00C0, 0x8002},
146         {"DTV8",              0x00C0, 0x800B},
147         {"DTV7/8",            0x00C0, 0x801B},
148         {"DTV7",              0x00C0, 0x8007},
149         {"FM Radio-INPUT2",   0x9802, 0x9002},
150         {"FM Radio-INPUT1",   0x0208, 0x9002}
151 };
152
153 static int  xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
154 static int  xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
155 static void xc5000_TunerReset(struct dvb_frontend *fe);
156
157 int xc_send_i2c_data(struct xc5000_priv *priv,
158         unsigned char *bytes_to_send, int nb_bytes_to_send)
159 {
160         return xc5000_writeregs(priv, bytes_to_send, nb_bytes_to_send)
161                 ? XC_RESULT_I2C_WRITE_FAILURE : XC_RESULT_SUCCESS;
162 }
163
164 int xc_read_i2c_data(struct xc5000_priv *priv, unsigned char *bytes_received,
165         int nb_bytes_to_receive)
166 {
167         return xc5000_readregs(priv, bytes_received, nb_bytes_to_receive)
168                 ? XC_RESULT_I2C_READ_FAILURE : XC_RESULT_SUCCESS;
169 }
170
171 int xc_reset(struct dvb_frontend *fe)
172 {
173         xc5000_TunerReset(fe);
174         return XC_RESULT_SUCCESS;
175 }
176
177 void xc_wait(int wait_ms)
178 {
179         msleep( wait_ms );
180 }
181
182 static void xc5000_TunerReset(struct dvb_frontend *fe)
183 {
184         struct xc5000_priv *priv = fe->tuner_priv;
185         int ret;
186
187         dprintk(1, "%s()\n", __FUNCTION__);
188
189         if(priv->cfg->tuner_reset) {
190                 ret = priv->cfg->tuner_reset(fe);
191                 if (ret)
192                         printk(KERN_ERR "xc5000: reset failed\n");
193         } else
194                 printk(KERN_ERR "xc5000: no tuner reset function, fatal\n");
195 }
196
197 int xc_write_reg(struct xc5000_priv *priv, unsigned short int regAddr,
198         unsigned short int i2cData)
199 {
200         unsigned char buf[4];
201         int WatchDogTimer = 5;
202         int result;
203
204         buf[0] = (regAddr >> 8) & 0xFF;
205         buf[1] = regAddr & 0xFF;
206         buf[2] = (i2cData >> 8) & 0xFF;
207         buf[3] = i2cData & 0xFF;
208         result = xc_send_i2c_data(priv, buf, 4);
209         if ( result == XC_RESULT_SUCCESS) {
210                 /* wait for busy flag to clear */
211                 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
212                         buf[0] = 0;
213                         buf[1] = XREG_BUSY;
214
215                         result = xc_send_i2c_data(priv, buf, 2);
216                         if (result == XC_RESULT_SUCCESS) {
217                                 result = xc_read_i2c_data(priv, buf, 2);
218                                 if (result == XC_RESULT_SUCCESS) {
219                                         if ((buf[0] == 0) && (buf[1] == 0)) {
220                                                 /* busy flag cleared */
221                                         break;
222                                         } else {
223                                                 xc_wait(100); /* wait 5 ms */
224                                                 WatchDogTimer--;
225                                         }
226                                 }
227                         }
228                 }
229         }
230         if (WatchDogTimer < 0)
231                 result = XC_RESULT_I2C_WRITE_FAILURE;
232
233         return result;
234 }
235
236 int xc_read_reg(struct xc5000_priv *priv, unsigned short int regAddr,
237         unsigned short int *i2cData)
238 {
239         unsigned char buf[2];
240         int result;
241
242         buf[0] = (regAddr >> 8) & 0xFF;
243         buf[1] = regAddr & 0xFF;
244         result = xc_send_i2c_data(priv, buf, 2);
245         if (result!=XC_RESULT_SUCCESS)
246                 return result;
247
248         result = xc_read_i2c_data(priv, buf, 2);
249         if (result!=XC_RESULT_SUCCESS)
250                 return result;
251
252         *i2cData = buf[0] * 256 + buf[1];
253         return result;
254 }
255
256 int xc_load_i2c_sequence(struct dvb_frontend *fe, unsigned char i2c_sequence[])
257 {
258         struct xc5000_priv *priv = fe->tuner_priv;
259
260         int i, nbytes_to_send, result;
261         unsigned int len, pos, index;
262         unsigned char buf[XC_MAX_I2C_WRITE_LENGTH];
263
264         index=0;
265         while ((i2c_sequence[index]!=0xFF) || (i2c_sequence[index+1]!=0xFF)) {
266
267                 len = i2c_sequence[index]* 256 + i2c_sequence[index+1];
268                 if (len==0x0000) {
269                         /* RESET command */
270                         result = xc_reset(fe);
271                         index += 2;
272                         if (result!=XC_RESULT_SUCCESS)
273                                 return result;
274                 } else if (len & 0x8000) {
275                         /* WAIT command */
276                         xc_wait(len & 0x7FFF);
277                         index += 2;
278                 } else {
279                         /* Send i2c data whilst ensuring individual transactions
280                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
281                          */
282                         index += 2;
283                         buf[0] = i2c_sequence[index];
284                         buf[1] = i2c_sequence[index + 1];
285                         pos = 2;
286                         while (pos < len) {
287                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) {
288                                         nbytes_to_send = XC_MAX_I2C_WRITE_LENGTH;
289                                 } else {
290                                         nbytes_to_send = (len - pos + 2);
291                                 }
292                                 for (i=2; i<nbytes_to_send; i++) {
293                                         buf[i] = i2c_sequence[index + pos + i - 2];
294                                 }
295                                 result = xc_send_i2c_data(priv, buf, nbytes_to_send);
296
297                                 if (result!=XC_RESULT_SUCCESS)
298                                         return result;
299
300                                 pos += nbytes_to_send - 2;
301                         }
302                         index += len;
303                 }
304         }
305         return XC_RESULT_SUCCESS;
306 }
307
308 int xc_initialize(struct xc5000_priv *priv)
309 {
310         dprintk(1, "%s()\n", __FUNCTION__);
311         return xc_write_reg(priv, XREG_INIT, 0);
312 }
313
314 int xc_SetTVStandard(struct xc5000_priv *priv, unsigned short int VideoMode,
315         unsigned short int AudioMode)
316 {
317         int ret;
318         dprintk(1, "%s(%d,%d)\n", __FUNCTION__, VideoMode, AudioMode);
319         dprintk(1, "%s() Standard = %s\n",
320                 __FUNCTION__,
321                 XC5000_Standard[priv->video_standard].Name);
322
323         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
324         if (ret == XC_RESULT_SUCCESS)
325                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
326
327         return ret;
328 }
329
330 int xc_shutdown(struct xc5000_priv *priv)
331 {
332         return xc_write_reg(priv, XREG_POWER_DOWN, 0);
333 }
334
335 int xc_SetSignalSource(struct xc5000_priv *priv, unsigned short int rf_mode)
336 {
337         dprintk(1, "%s(%d) Source = %s\n", __FUNCTION__, rf_mode,
338                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
339
340         if( (rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE) )
341         {
342                 rf_mode = XC_RF_MODE_CABLE;
343                 printk(KERN_ERR
344                         "%s(), Invalid mode, defaulting to CABLE",
345                         __FUNCTION__);
346         }
347         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
348 }
349
350 int xc_set_RF_frequency(struct xc5000_priv *priv, long frequency_in_hz)
351 {
352         unsigned int frequency_code = (unsigned int)(frequency_in_hz / 15625);
353
354         if ((frequency_in_hz>1023000000) || (frequency_in_hz<1000000))
355                 return XC_RESULT_OUT_OF_RANGE;
356
357         return xc_write_reg(priv, XREG_RF_FREQ ,frequency_code);
358 }
359
360 int xc_FineTune_RF_frequency(struct xc5000_priv *priv, long frequency_in_hz)
361 {
362         unsigned int frequency_code = (unsigned int)(frequency_in_hz / 15625);
363         if ((frequency_in_hz>1023000000) || (frequency_in_hz<1000000))
364                 return XC_RESULT_OUT_OF_RANGE;
365
366         return xc_write_reg(priv, XREG_FINERFFREQ ,frequency_code);
367 }
368
369 int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_hz)
370 {
371         u32 freq_code = (freq_hz * 1024)/1000000;
372         dprintk(1, "%s(%d)\n", __FUNCTION__, freq_hz);
373
374         printk(KERN_ERR "FIXME - Hardcoded IF, FIXME\n");
375         freq_code = 0x1585;
376
377         return xc_write_reg(priv, XREG_IF_OUT ,freq_code);
378 }
379
380 int xc_set_Xtal_frequency(struct xc5000_priv *priv, long xtalFreqInKHz)
381 {
382         unsigned int xtalRatio = (32000 * 0x8000)/xtalFreqInKHz;
383         return xc_write_reg(priv, XREG_XTALFREQ ,xtalRatio);
384 }
385
386 int xc_get_ADC_Envelope(struct xc5000_priv *priv,
387         unsigned short int *adc_envelope)
388 {
389         return xc_read_reg(priv, XREG_ADC_ENV, adc_envelope);
390 }
391
392 int xc_get_frequency_error(struct xc5000_priv *priv, u32 *frequency_error_hz)
393 {
394         int result;
395         unsigned short int regData;
396         u32 tmp;
397
398         result = xc_read_reg(priv, XREG_FREQ_ERROR, &regData);
399         if (result)
400                 return result;
401
402         tmp = (u32)regData;
403         (*frequency_error_hz) = (tmp * 15625) / 1000;
404         return result;
405 }
406
407 int xc_get_lock_status(struct xc5000_priv *priv,
408         unsigned short int *lock_status)
409 {
410         return xc_read_reg(priv, XREG_LOCK, lock_status);
411 }
412
413 int xc_get_version(struct xc5000_priv *priv,
414         unsigned char* hw_majorversion,
415         unsigned char* hw_minorversion,
416         unsigned char* fw_majorversion,
417         unsigned char* fw_minorversion)
418 {
419         unsigned short int data;
420         int result;
421
422         result = xc_read_reg(priv, XREG_VERSION, &data);
423         if (result)
424                 return result;
425
426         (*hw_majorversion) = (data>>12) & 0x0F;
427         (*hw_minorversion) = (data>>8) & 0x0F;
428         (*fw_majorversion) = (data>>4) & 0x0F;
429         (*fw_minorversion) = (data) & 0x0F;
430
431         return 0;
432 }
433
434 int xc_get_product_id(struct xc5000_priv *priv, unsigned short int *product_id)
435 {
436         return xc_read_reg(priv, XREG_PRODUCT_ID, product_id);
437 }
438
439 int xc_get_hsync_freq(struct xc5000_priv *priv, int *hsync_freq_hz)
440 {
441         unsigned short int regData;
442         int result;
443
444         result = xc_read_reg(priv, XREG_HSYNC_FREQ, &regData);
445         if (result)
446                 return result;
447
448         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
449         return result;
450 }
451
452 int xc_get_frame_lines(struct xc5000_priv *priv,
453         unsigned short int *frame_lines)
454 {
455         return xc_read_reg(priv, XREG_FRAME_LINES, frame_lines);
456 }
457
458 int xc_get_quality(struct xc5000_priv *priv, unsigned short int *quality)
459 {
460         return xc_read_reg(priv, XREG_QUALITY, quality);
461 }
462
463 unsigned short int WaitForLock(struct xc5000_priv *priv)
464 {
465         unsigned short int lockState = 0;
466         int watchDogCount = 40;
467         while ((lockState == 0) && (watchDogCount > 0))
468         {
469                 xc_get_lock_status(priv, &lockState);
470                 if (lockState != 1)
471                 {
472                         xc_wait(5);
473                         watchDogCount--;
474                 }
475         }
476         return lockState;
477 }
478
479 int xc_tune_channel(struct xc5000_priv *priv, u32 freq)
480 {
481         int found = 0;
482
483         dprintk(1, "%s(%d)\n", __FUNCTION__, freq);
484
485         if (xc_set_RF_frequency(priv, freq) != XC_RESULT_SUCCESS)
486                 return 0;
487
488         if (WaitForLock(priv)== 1)
489                 found = 1;
490
491         return found;
492 }
493
494 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
495 {
496         u8 buf[2] = { reg >> 8, reg & 0xff };
497         u8 bval[2] = { 0, 0 };
498         struct i2c_msg msg[2] = {
499                 { .addr = priv->cfg->i2c_address,
500                         .flags = 0, .buf = &buf[0], .len = 2 },
501                 { .addr = priv->cfg->i2c_address,
502                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
503         };
504
505         if (i2c_transfer(priv->i2c, msg, 2) != 2) {
506                 printk(KERN_WARNING "xc5000 I2C read failed\n");
507                 return -EREMOTEIO;
508         }
509
510         *val = (bval[0] << 8) | bval[1];
511         return 0;
512 }
513
514 static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len)
515 {
516         struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
517                 .flags = 0, .buf = buf, .len = len };
518
519         if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
520                 printk(KERN_ERR "xc5000 I2C write failed (len=%i)\n",
521                         (int)len);
522                 return -EREMOTEIO;
523         }
524         return 0;
525 }
526
527 static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len)
528 {
529         struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
530                 .flags = I2C_M_RD, .buf = buf, .len = len };
531
532         if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
533                 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n",(int)len);
534                 return -EREMOTEIO;
535         }
536         return 0;
537 }
538
539 static int xc5000_fwupload(struct dvb_frontend* fe)
540 {
541         struct xc5000_priv *priv = fe->tuner_priv;
542         const struct firmware *fw;
543         int ret;
544
545         /* request the firmware, this will block until someone uploads it */
546         printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
547                 XC5000_DEFAULT_FIRMWARE);
548
549         if(!priv->cfg->request_firmware) {
550                 printk(KERN_ERR "xc5000: no firmware callback, fatal\n");
551                 return -EIO;
552         }
553
554         ret = priv->cfg->request_firmware(fe, &fw, XC5000_DEFAULT_FIRMWARE);
555         if (ret) {
556                 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
557                 ret = XC_RESULT_RESET_FAILURE;
558         } else {
559                 printk(KERN_INFO "xc5000: firmware read %d bytes.\n", fw->size);
560                 ret = XC_RESULT_SUCCESS;
561         }
562
563         if(fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
564                 printk(KERN_ERR "xc5000: firmware incorrect size\n");
565                 ret = XC_RESULT_RESET_FAILURE;
566         } else {
567                 printk(KERN_INFO "xc5000: firmware upload\n");
568                 ret = xc_load_i2c_sequence(fe,  fw->data );
569         }
570
571         release_firmware(fw);
572         return ret;
573 }
574
575 void xc_debug_dump(struct xc5000_priv *priv)
576 {
577         unsigned short  adc_envelope;
578         u32             frequency_error_hz;
579         unsigned short  lock_status;
580         unsigned char   hw_majorversion, hw_minorversion = 0;
581         unsigned char   fw_majorversion, fw_minorversion = 0;
582         int             hsync_freq_hz;
583         unsigned short  frame_lines;
584         unsigned short  quality;
585
586         /* Wait for stats to stabilize.
587          * Frame Lines needs two frame times after initial lock
588          * before it is valid.
589          */
590         xc_wait( 100 );
591
592         xc_get_ADC_Envelope(priv,  &adc_envelope );
593         dprintk(1, "*** ADC envelope (0-1023) = %u\n", adc_envelope);
594
595         xc_get_frequency_error(priv,  &frequency_error_hz );
596         dprintk(1, "*** Frequency error = %d Hz\n", frequency_error_hz);
597
598         xc_get_lock_status(priv,  &lock_status );
599         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %u\n",
600                 lock_status);
601
602         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
603                 &fw_majorversion, &fw_minorversion );
604         dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
605                 hw_majorversion, hw_minorversion,
606                 fw_majorversion, fw_minorversion);
607
608         xc_get_hsync_freq(priv,  &hsync_freq_hz );
609         dprintk(1, "*** Horizontal sync frequency = %u Hz\n", hsync_freq_hz);
610
611         xc_get_frame_lines(priv,  &frame_lines );
612         dprintk(1, "*** Frame lines = %u\n", frame_lines);
613
614         xc_get_quality(priv,  &quality );
615         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %u\n", quality);
616 }
617
618 static int xc5000_set_params(struct dvb_frontend *fe,
619         struct dvb_frontend_parameters *params)
620 {
621         struct xc5000_priv *priv = fe->tuner_priv;
622
623         dprintk(1, "%s() frequency=%d\n", __FUNCTION__, params->frequency);
624
625         priv->frequency = params->frequency - 1750000;
626         priv->bandwidth = 6;
627         priv->video_standard = DTV6;
628
629         switch(params->u.vsb.modulation) {
630         case VSB_8:
631         case VSB_16:
632                 dprintk(1, "%s() VSB modulation\n", __FUNCTION__);
633                 priv->rf_mode = XC_RF_MODE_AIR;
634                 break;
635         case QAM_64:
636         case QAM_256:
637         case QAM_AUTO:
638                 dprintk(1, "%s() QAM modulation\n", __FUNCTION__);
639                 priv->rf_mode = XC_RF_MODE_CABLE;
640                 break;
641         default:
642                 return -EINVAL;
643         }
644
645         dprintk(1, "%s() frequency=%d (compensated)\n",
646                 __FUNCTION__, priv->frequency);
647
648         /* FIXME: check result codes */
649         xc_SetSignalSource(priv, priv->rf_mode);
650
651         xc_SetTVStandard(priv,
652                 XC5000_Standard[priv->video_standard].VideoMode,
653                 XC5000_Standard[priv->video_standard].AudioMode);
654
655         xc_set_IF_frequency(priv, priv->cfg->if_frequency);
656         xc_tune_channel(priv, priv->frequency);
657         xc_debug_dump(priv);
658
659         return 0;
660 }
661
662 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
663 {
664         struct xc5000_priv *priv = fe->tuner_priv;
665         dprintk(1, "%s()\n", __FUNCTION__);
666         *freq = priv->frequency;
667         return 0;
668 }
669
670 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
671 {
672         struct xc5000_priv *priv = fe->tuner_priv;
673         dprintk(1, "%s()\n", __FUNCTION__);
674         *bw = priv->bandwidth;
675         return 0;
676 }
677
678 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
679 {
680         struct xc5000_priv *priv = fe->tuner_priv;
681         unsigned short int lock_status = 0;
682
683         xc_get_lock_status(priv, &lock_status);
684
685         dprintk(1, "%s() lock_status = 0x%08x\n", __FUNCTION__, lock_status);
686
687         *status = lock_status;
688
689         return 0;
690 }
691
692 int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
693 {
694         struct xc5000_priv *priv = fe->tuner_priv;
695         int ret;
696
697         if(priv->fwloaded == 0) {
698                 ret = xc5000_fwupload(fe);
699                 if( ret != XC_RESULT_SUCCESS )
700                         return -EREMOTEIO;
701
702                 priv->fwloaded = 1;
703         }
704
705         /* Start the tuner self-calibration process */
706         ret |= xc_initialize(priv);
707
708         /* Wait for calibration to complete.
709          * We could continue but XC5000 will clock stretch subsequent
710          * I2C transactions until calibration is complete.  This way we
711          * don't have to rely on clock stretching working.
712          */
713         xc_wait( 100 );
714
715         /* Default to "CABLE" mode */
716         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
717
718         return ret;
719 }
720
721 static int xc5000_init(struct dvb_frontend *fe)
722 {
723         struct xc5000_priv *priv = fe->tuner_priv;
724         dprintk(1, "%s()\n", __FUNCTION__);
725
726         xc_load_fw_and_init_tuner(fe);
727         xc_debug_dump(priv);
728
729         return 0;
730 }
731
732 static int xc5000_release(struct dvb_frontend *fe)
733 {
734         dprintk(1, "%s()\n", __FUNCTION__);
735         kfree(fe->tuner_priv);
736         fe->tuner_priv = NULL;
737         return 0;
738 }
739
740 static const struct dvb_tuner_ops xc5000_tuner_ops = {
741         .info = {
742                 .name           = "Xceive XC5000",
743                 .frequency_min  =    1000000,
744                 .frequency_max  = 1023000000,
745                 .frequency_step =      50000,
746         },
747
748         .release       = xc5000_release,
749         .init          = xc5000_init,
750
751         .set_params    = xc5000_set_params,
752         .get_frequency = xc5000_get_frequency,
753         .get_bandwidth = xc5000_get_bandwidth,
754         .get_status    = xc5000_get_status
755 };
756
757 struct dvb_frontend * xc5000_attach(struct dvb_frontend *fe,
758         struct i2c_adapter *i2c,
759         struct xc5000_config *cfg)
760 {
761         struct xc5000_priv *priv = NULL;
762         u16 id = 0;
763
764         dprintk(1, "%s()\n", __FUNCTION__);
765
766         priv = kzalloc(sizeof(struct xc5000_priv), GFP_KERNEL);
767         if (priv == NULL)
768                 return NULL;
769
770         priv->cfg = cfg;
771         priv->bandwidth = 6000000; /* 6MHz */
772         priv->i2c = i2c;
773         priv->fwloaded = 0;
774
775         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) {
776                 kfree(priv);
777                 return NULL;
778         }
779
780         if ( (id != 0x2000) && (id != 0x1388) ) {
781                 printk(KERN_ERR
782                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
783                         cfg->i2c_address, id);
784                 kfree(priv);
785                 return NULL;
786         }
787
788         printk(KERN_INFO "xc5000: successfully identified at address 0x%02x\n",
789                 cfg->i2c_address);
790
791         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
792                 sizeof(struct dvb_tuner_ops));
793
794         fe->tuner_priv = priv;
795
796         return fe;
797 }
798 EXPORT_SYMBOL(xc5000_attach);
799
800 MODULE_AUTHOR("Steven Toth");
801 MODULE_DESCRIPTION("Xceive XC5000 silicon tuner driver");
802 MODULE_LICENSE("GPL");