7f98984e4fad0526fbe98335a29b166cf6bba428
[~shefty/rdma-dev.git] / drivers / media / common / tuners / 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@linuxtv.org>
6  *  Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/videodev2.h>
27 #include <linux/delay.h>
28 #include <linux/dvb/frontend.h>
29 #include <linux/i2c.h>
30
31 #include "dvb_frontend.h"
32
33 #include "xc5000.h"
34 #include "tuner-i2c.h"
35
36 static int debug;
37 module_param(debug, int, 0644);
38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39
40 static int no_poweroff;
41 module_param(no_poweroff, int, 0644);
42 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
43         "\t\t1 keep device energized and with tuner ready all the times.\n"
44         "\t\tFaster, but consumes more power and keeps the device hotter");
45
46 static DEFINE_MUTEX(xc5000_list_mutex);
47 static LIST_HEAD(hybrid_tuner_instance_list);
48
49 #define dprintk(level, fmt, arg...) if (debug >= level) \
50         printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
51
52 struct xc5000_priv {
53         struct tuner_i2c_props i2c_props;
54         struct list_head hybrid_tuner_instance_list;
55
56         u32 if_khz;
57         u32 freq_hz;
58         u32 bandwidth;
59         u8  video_standard;
60         u8  rf_mode;
61         u8  radio_input;
62
63         int chip_id;
64 };
65
66 /* Misc Defines */
67 #define MAX_TV_STANDARD                 24
68 #define XC_MAX_I2C_WRITE_LENGTH         64
69
70 /* Signal Types */
71 #define XC_RF_MODE_AIR                  0
72 #define XC_RF_MODE_CABLE                1
73
74 /* Result codes */
75 #define XC_RESULT_SUCCESS               0
76 #define XC_RESULT_RESET_FAILURE         1
77 #define XC_RESULT_I2C_WRITE_FAILURE     2
78 #define XC_RESULT_I2C_READ_FAILURE      3
79 #define XC_RESULT_OUT_OF_RANGE          5
80
81 /* Product id */
82 #define XC_PRODUCT_ID_FW_NOT_LOADED     0x2000
83 #define XC_PRODUCT_ID_FW_LOADED         0x1388
84
85 /* Registers */
86 #define XREG_INIT         0x00
87 #define XREG_VIDEO_MODE   0x01
88 #define XREG_AUDIO_MODE   0x02
89 #define XREG_RF_FREQ      0x03
90 #define XREG_D_CODE       0x04
91 #define XREG_IF_OUT       0x05
92 #define XREG_SEEK_MODE    0x07
93 #define XREG_POWER_DOWN   0x0A /* Obsolete */
94 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
95 #define XREG_OUTPUT_AMP   0x0B
96 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
97 #define XREG_SMOOTHEDCVBS 0x0E
98 #define XREG_XTALFREQ     0x0F
99 #define XREG_FINERFREQ    0x10
100 #define XREG_DDIMODE      0x11
101
102 #define XREG_ADC_ENV      0x00
103 #define XREG_QUALITY      0x01
104 #define XREG_FRAME_LINES  0x02
105 #define XREG_HSYNC_FREQ   0x03
106 #define XREG_LOCK         0x04
107 #define XREG_FREQ_ERROR   0x05
108 #define XREG_SNR          0x06
109 #define XREG_VERSION      0x07
110 #define XREG_PRODUCT_ID   0x08
111 #define XREG_BUSY         0x09
112 #define XREG_BUILD        0x0D
113
114 /*
115    Basic firmware description. This will remain with
116    the driver for documentation purposes.
117
118    This represents an I2C firmware file encoded as a
119    string of unsigned char. Format is as follows:
120
121    char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
122    char[1  ]=len0_LSB  -> length of first write transaction
123    char[2  ]=data0 -> first byte to be sent
124    char[3  ]=data1
125    char[4  ]=data2
126    char[   ]=...
127    char[M  ]=dataN  -> last byte to be sent
128    char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
129    char[M+2]=len1_LSB  -> length of second write transaction
130    char[M+3]=data0
131    char[M+4]=data1
132    ...
133    etc.
134
135    The [len] value should be interpreted as follows:
136
137    len= len_MSB _ len_LSB
138    len=1111_1111_1111_1111   : End of I2C_SEQUENCE
139    len=0000_0000_0000_0000   : Reset command: Do hardware reset
140    len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
141    len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
142
143    For the RESET and WAIT commands, the two following bytes will contain
144    immediately the length of the following transaction.
145
146 */
147 struct XC_TV_STANDARD {
148         char *Name;
149         u16 AudioMode;
150         u16 VideoMode;
151 };
152
153 /* Tuner standards */
154 #define MN_NTSC_PAL_BTSC        0
155 #define MN_NTSC_PAL_A2          1
156 #define MN_NTSC_PAL_EIAJ        2
157 #define MN_NTSC_PAL_Mono        3
158 #define BG_PAL_A2               4
159 #define BG_PAL_NICAM            5
160 #define BG_PAL_MONO             6
161 #define I_PAL_NICAM             7
162 #define I_PAL_NICAM_MONO        8
163 #define DK_PAL_A2               9
164 #define DK_PAL_NICAM            10
165 #define DK_PAL_MONO             11
166 #define DK_SECAM_A2DK1          12
167 #define DK_SECAM_A2LDK3         13
168 #define DK_SECAM_A2MONO         14
169 #define L_SECAM_NICAM           15
170 #define LC_SECAM_NICAM          16
171 #define DTV6                    17
172 #define DTV8                    18
173 #define DTV7_8                  19
174 #define DTV7                    20
175 #define FM_Radio_INPUT2         21
176 #define FM_Radio_INPUT1         22
177 #define FM_Radio_INPUT1_MONO    23
178
179 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
180         {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
181         {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
182         {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
183         {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
184         {"B/G-PAL-A2",        0x0A00, 0x8049},
185         {"B/G-PAL-NICAM",     0x0C04, 0x8049},
186         {"B/G-PAL-MONO",      0x0878, 0x8059},
187         {"I-PAL-NICAM",       0x1080, 0x8009},
188         {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
189         {"D/K-PAL-A2",        0x1600, 0x8009},
190         {"D/K-PAL-NICAM",     0x0E80, 0x8009},
191         {"D/K-PAL-MONO",      0x1478, 0x8009},
192         {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
193         {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
194         {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
195         {"L-SECAM-NICAM",     0x8E82, 0x0009},
196         {"L'-SECAM-NICAM",    0x8E82, 0x4009},
197         {"DTV6",              0x00C0, 0x8002},
198         {"DTV8",              0x00C0, 0x800B},
199         {"DTV7/8",            0x00C0, 0x801B},
200         {"DTV7",              0x00C0, 0x8007},
201         {"FM Radio-INPUT2",   0x9802, 0x9002},
202         {"FM Radio-INPUT1",   0x0208, 0x9002},
203         {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
204 };
205
206
207 struct xc5000_fw_cfg {
208         char *name;
209         u16 size;
210 };
211
212 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
213         .name = "dvb-fe-xc5000-1.6.114.fw",
214         .size = 12401,
215 };
216
217 static const struct xc5000_fw_cfg xc5000c_41_024_5_31875 = {
218         .name = "dvb-fe-xc5000c-41.024.5-31875.fw",
219         .size = 16503,
220 };
221
222 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
223 {
224         switch (chip_id) {
225         default:
226         case XC5000A:
227                 return &xc5000a_1_6_114;
228         case XC5000C:
229                 return &xc5000c_41_024_5_31875;
230         }
231 }
232
233 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
234 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
235 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
236 static int xc5000_TunerReset(struct dvb_frontend *fe);
237
238 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
239 {
240         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
241                                .flags = 0, .buf = buf, .len = len };
242
243         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
244                 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
245                 return XC_RESULT_I2C_WRITE_FAILURE;
246         }
247         return XC_RESULT_SUCCESS;
248 }
249
250 #if 0
251 /* This routine is never used because the only time we read data from the
252    i2c bus is when we read registers, and we want that to be an atomic i2c
253    transaction in case we are on a multi-master bus */
254 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
255 {
256         struct i2c_msg msg = { .addr = priv->i2c_props.addr,
257                 .flags = I2C_M_RD, .buf = buf, .len = len };
258
259         if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
260                 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
261                 return -EREMOTEIO;
262         }
263         return 0;
264 }
265 #endif
266
267 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
268 {
269         u8 buf[2] = { reg >> 8, reg & 0xff };
270         u8 bval[2] = { 0, 0 };
271         struct i2c_msg msg[2] = {
272                 { .addr = priv->i2c_props.addr,
273                         .flags = 0, .buf = &buf[0], .len = 2 },
274                 { .addr = priv->i2c_props.addr,
275                         .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
276         };
277
278         if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
279                 printk(KERN_WARNING "xc5000: I2C read failed\n");
280                 return -EREMOTEIO;
281         }
282
283         *val = (bval[0] << 8) | bval[1];
284         return XC_RESULT_SUCCESS;
285 }
286
287 static void xc_wait(int wait_ms)
288 {
289         msleep(wait_ms);
290 }
291
292 static int xc5000_TunerReset(struct dvb_frontend *fe)
293 {
294         struct xc5000_priv *priv = fe->tuner_priv;
295         int ret;
296
297         dprintk(1, "%s()\n", __func__);
298
299         if (fe->callback) {
300                 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
301                                            fe->dvb->priv :
302                                            priv->i2c_props.adap->algo_data,
303                                            DVB_FRONTEND_COMPONENT_TUNER,
304                                            XC5000_TUNER_RESET, 0);
305                 if (ret) {
306                         printk(KERN_ERR "xc5000: reset failed\n");
307                         return XC_RESULT_RESET_FAILURE;
308                 }
309         } else {
310                 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
311                 return XC_RESULT_RESET_FAILURE;
312         }
313         return XC_RESULT_SUCCESS;
314 }
315
316 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
317 {
318         u8 buf[4];
319         int WatchDogTimer = 100;
320         int result;
321
322         buf[0] = (regAddr >> 8) & 0xFF;
323         buf[1] = regAddr & 0xFF;
324         buf[2] = (i2cData >> 8) & 0xFF;
325         buf[3] = i2cData & 0xFF;
326         result = xc_send_i2c_data(priv, buf, 4);
327         if (result == XC_RESULT_SUCCESS) {
328                 /* wait for busy flag to clear */
329                 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
330                         result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
331                         if (result == XC_RESULT_SUCCESS) {
332                                 if ((buf[0] == 0) && (buf[1] == 0)) {
333                                         /* busy flag cleared */
334                                         break;
335                                 } else {
336                                         xc_wait(5); /* wait 5 ms */
337                                         WatchDogTimer--;
338                                 }
339                         }
340                 }
341         }
342         if (WatchDogTimer < 0)
343                 result = XC_RESULT_I2C_WRITE_FAILURE;
344
345         return result;
346 }
347
348 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
349 {
350         struct xc5000_priv *priv = fe->tuner_priv;
351
352         int i, nbytes_to_send, result;
353         unsigned int len, pos, index;
354         u8 buf[XC_MAX_I2C_WRITE_LENGTH];
355
356         index = 0;
357         while ((i2c_sequence[index] != 0xFF) ||
358                 (i2c_sequence[index + 1] != 0xFF)) {
359                 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
360                 if (len == 0x0000) {
361                         /* RESET command */
362                         result = xc5000_TunerReset(fe);
363                         index += 2;
364                         if (result != XC_RESULT_SUCCESS)
365                                 return result;
366                 } else if (len & 0x8000) {
367                         /* WAIT command */
368                         xc_wait(len & 0x7FFF);
369                         index += 2;
370                 } else {
371                         /* Send i2c data whilst ensuring individual transactions
372                          * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
373                          */
374                         index += 2;
375                         buf[0] = i2c_sequence[index];
376                         buf[1] = i2c_sequence[index + 1];
377                         pos = 2;
378                         while (pos < len) {
379                                 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
380                                         nbytes_to_send =
381                                                 XC_MAX_I2C_WRITE_LENGTH;
382                                 else
383                                         nbytes_to_send = (len - pos + 2);
384                                 for (i = 2; i < nbytes_to_send; i++) {
385                                         buf[i] = i2c_sequence[index + pos +
386                                                 i - 2];
387                                 }
388                                 result = xc_send_i2c_data(priv, buf,
389                                         nbytes_to_send);
390
391                                 if (result != XC_RESULT_SUCCESS)
392                                         return result;
393
394                                 pos += nbytes_to_send - 2;
395                         }
396                         index += len;
397                 }
398         }
399         return XC_RESULT_SUCCESS;
400 }
401
402 static int xc_initialize(struct xc5000_priv *priv)
403 {
404         dprintk(1, "%s()\n", __func__);
405         return xc_write_reg(priv, XREG_INIT, 0);
406 }
407
408 static int xc_SetTVStandard(struct xc5000_priv *priv,
409         u16 VideoMode, u16 AudioMode)
410 {
411         int ret;
412         dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
413         dprintk(1, "%s() Standard = %s\n",
414                 __func__,
415                 XC5000_Standard[priv->video_standard].Name);
416
417         ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
418         if (ret == XC_RESULT_SUCCESS)
419                 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
420
421         return ret;
422 }
423
424 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
425 {
426         dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
427                 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
428
429         if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
430                 rf_mode = XC_RF_MODE_CABLE;
431                 printk(KERN_ERR
432                         "%s(), Invalid mode, defaulting to CABLE",
433                         __func__);
434         }
435         return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
436 }
437
438 static const struct dvb_tuner_ops xc5000_tuner_ops;
439
440 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
441 {
442         u16 freq_code;
443
444         dprintk(1, "%s(%u)\n", __func__, freq_hz);
445
446         if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
447                 (freq_hz < xc5000_tuner_ops.info.frequency_min))
448                 return XC_RESULT_OUT_OF_RANGE;
449
450         freq_code = (u16)(freq_hz / 15625);
451
452         /* Starting in firmware version 1.1.44, Xceive recommends using the
453            FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
454            only be used for fast scanning for channel lock) */
455         return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
456 }
457
458
459 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
460 {
461         u32 freq_code = (freq_khz * 1024)/1000;
462         dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
463                 __func__, freq_khz, freq_code);
464
465         return xc_write_reg(priv, XREG_IF_OUT, freq_code);
466 }
467
468
469 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
470 {
471         return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
472 }
473
474 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
475 {
476         int result;
477         u16 regData;
478         u32 tmp;
479
480         result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
481         if (result != XC_RESULT_SUCCESS)
482                 return result;
483
484         tmp = (u32)regData;
485         (*freq_error_hz) = (tmp * 15625) / 1000;
486         return result;
487 }
488
489 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
490 {
491         return xc5000_readreg(priv, XREG_LOCK, lock_status);
492 }
493
494 static int xc_get_version(struct xc5000_priv *priv,
495         u8 *hw_majorversion, u8 *hw_minorversion,
496         u8 *fw_majorversion, u8 *fw_minorversion)
497 {
498         u16 data;
499         int result;
500
501         result = xc5000_readreg(priv, XREG_VERSION, &data);
502         if (result != XC_RESULT_SUCCESS)
503                 return result;
504
505         (*hw_majorversion) = (data >> 12) & 0x0F;
506         (*hw_minorversion) = (data >>  8) & 0x0F;
507         (*fw_majorversion) = (data >>  4) & 0x0F;
508         (*fw_minorversion) = data & 0x0F;
509
510         return 0;
511 }
512
513 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
514 {
515         return xc5000_readreg(priv, XREG_BUILD, buildrev);
516 }
517
518 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
519 {
520         u16 regData;
521         int result;
522
523         result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
524         if (result != XC_RESULT_SUCCESS)
525                 return result;
526
527         (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
528         return result;
529 }
530
531 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
532 {
533         return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
534 }
535
536 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
537 {
538         return xc5000_readreg(priv, XREG_QUALITY, quality);
539 }
540
541 static u16 WaitForLock(struct xc5000_priv *priv)
542 {
543         u16 lockState = 0;
544         int watchDogCount = 40;
545
546         while ((lockState == 0) && (watchDogCount > 0)) {
547                 xc_get_lock_status(priv, &lockState);
548                 if (lockState != 1) {
549                         xc_wait(5);
550                         watchDogCount--;
551                 }
552         }
553         return lockState;
554 }
555
556 #define XC_TUNE_ANALOG  0
557 #define XC_TUNE_DIGITAL 1
558 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
559 {
560         int found = 0;
561
562         dprintk(1, "%s(%u)\n", __func__, freq_hz);
563
564         if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
565                 return 0;
566
567         if (mode == XC_TUNE_ANALOG) {
568                 if (WaitForLock(priv) == 1)
569                         found = 1;
570         }
571
572         return found;
573 }
574
575
576 static int xc5000_fwupload(struct dvb_frontend *fe)
577 {
578         struct xc5000_priv *priv = fe->tuner_priv;
579         const struct firmware *fw;
580         int ret;
581         const struct xc5000_fw_cfg *desired_fw =
582                 xc5000_assign_firmware(priv->chip_id);
583
584         /* request the firmware, this will block and timeout */
585         printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
586                 desired_fw->name);
587
588         ret = request_firmware(&fw, desired_fw->name,
589                 priv->i2c_props.adap->dev.parent);
590         if (ret) {
591                 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
592                 ret = XC_RESULT_RESET_FAILURE;
593                 goto out;
594         } else {
595                 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
596                        fw->size);
597                 ret = XC_RESULT_SUCCESS;
598         }
599
600         if (fw->size != desired_fw->size) {
601                 printk(KERN_ERR "xc5000: firmware incorrect size\n");
602                 ret = XC_RESULT_RESET_FAILURE;
603         } else {
604                 printk(KERN_INFO "xc5000: firmware uploading...\n");
605                 ret = xc_load_i2c_sequence(fe,  fw->data);
606                 printk(KERN_INFO "xc5000: firmware upload complete...\n");
607         }
608
609 out:
610         release_firmware(fw);
611         return ret;
612 }
613
614 static void xc_debug_dump(struct xc5000_priv *priv)
615 {
616         u16 adc_envelope;
617         u32 freq_error_hz = 0;
618         u16 lock_status;
619         u32 hsync_freq_hz = 0;
620         u16 frame_lines;
621         u16 quality;
622         u8 hw_majorversion = 0, hw_minorversion = 0;
623         u8 fw_majorversion = 0, fw_minorversion = 0;
624         u16 fw_buildversion = 0;
625
626         /* Wait for stats to stabilize.
627          * Frame Lines needs two frame times after initial lock
628          * before it is valid.
629          */
630         xc_wait(100);
631
632         xc_get_ADC_Envelope(priv,  &adc_envelope);
633         dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
634
635         xc_get_frequency_error(priv, &freq_error_hz);
636         dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
637
638         xc_get_lock_status(priv,  &lock_status);
639         dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
640                 lock_status);
641
642         xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
643                 &fw_majorversion, &fw_minorversion);
644         xc_get_buildversion(priv,  &fw_buildversion);
645         dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
646                 hw_majorversion, hw_minorversion,
647                 fw_majorversion, fw_minorversion, fw_buildversion);
648
649         xc_get_hsync_freq(priv,  &hsync_freq_hz);
650         dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
651
652         xc_get_frame_lines(priv,  &frame_lines);
653         dprintk(1, "*** Frame lines = %d\n", frame_lines);
654
655         xc_get_quality(priv,  &quality);
656         dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
657 }
658
659 static int xc5000_set_params(struct dvb_frontend *fe)
660 {
661         int ret, b;
662         struct xc5000_priv *priv = fe->tuner_priv;
663         u32 bw = fe->dtv_property_cache.bandwidth_hz;
664         u32 freq = fe->dtv_property_cache.frequency;
665         u32 delsys  = fe->dtv_property_cache.delivery_system;
666
667         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
668                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
669                         dprintk(1, "Unable to load firmware and init tuner\n");
670                         return -EINVAL;
671                 }
672         }
673
674         dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
675
676         switch (delsys) {
677         case SYS_ATSC:
678                 dprintk(1, "%s() VSB modulation\n", __func__);
679                 priv->rf_mode = XC_RF_MODE_AIR;
680                 priv->freq_hz = freq - 1750000;
681                 priv->video_standard = DTV6;
682                 break;
683         case SYS_DVBC_ANNEX_B:
684                 dprintk(1, "%s() QAM modulation\n", __func__);
685                 priv->rf_mode = XC_RF_MODE_CABLE;
686                 priv->freq_hz = freq - 1750000;
687                 priv->video_standard = DTV6;
688                 break;
689         case SYS_DVBT:
690         case SYS_DVBT2:
691                 dprintk(1, "%s() OFDM\n", __func__);
692                 switch (bw) {
693                 case 6000000:
694                         priv->video_standard = DTV6;
695                         priv->freq_hz = freq - 1750000;
696                         break;
697                 case 7000000:
698                         priv->video_standard = DTV7;
699                         priv->freq_hz = freq - 2250000;
700                         break;
701                 case 8000000:
702                         priv->video_standard = DTV8;
703                         priv->freq_hz = freq - 2750000;
704                         break;
705                 default:
706                         printk(KERN_ERR "xc5000 bandwidth not set!\n");
707                         return -EINVAL;
708                 }
709                 priv->rf_mode = XC_RF_MODE_AIR;
710         case SYS_DVBC_ANNEX_A:
711         case SYS_DVBC_ANNEX_C:
712                 dprintk(1, "%s() QAM modulation\n", __func__);
713                 priv->rf_mode = XC_RF_MODE_CABLE;
714                 if (bw <= 6000000) {
715                         priv->video_standard = DTV6;
716                         priv->freq_hz = freq - 1750000;
717                         b = 6;
718                 } else if (bw <= 7000000) {
719                         priv->video_standard = DTV7;
720                         priv->freq_hz = freq - 2250000;
721                         b = 7;
722                 } else {
723                         priv->video_standard = DTV7_8;
724                         priv->freq_hz = freq - 2750000;
725                         b = 8;
726                 }
727                 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
728                         b, bw);
729                 break;
730         default:
731                 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
732                 return -EINVAL;
733         }
734
735         dprintk(1, "%s() frequency=%d (compensated to %d)\n",
736                 __func__, freq, priv->freq_hz);
737
738         ret = xc_SetSignalSource(priv, priv->rf_mode);
739         if (ret != XC_RESULT_SUCCESS) {
740                 printk(KERN_ERR
741                         "xc5000: xc_SetSignalSource(%d) failed\n",
742                         priv->rf_mode);
743                 return -EREMOTEIO;
744         }
745
746         ret = xc_SetTVStandard(priv,
747                 XC5000_Standard[priv->video_standard].VideoMode,
748                 XC5000_Standard[priv->video_standard].AudioMode);
749         if (ret != XC_RESULT_SUCCESS) {
750                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
751                 return -EREMOTEIO;
752         }
753
754         ret = xc_set_IF_frequency(priv, priv->if_khz);
755         if (ret != XC_RESULT_SUCCESS) {
756                 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
757                        priv->if_khz);
758                 return -EIO;
759         }
760
761         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
762
763         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
764
765         if (debug)
766                 xc_debug_dump(priv);
767
768         priv->bandwidth = bw;
769
770         return 0;
771 }
772
773 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
774 {
775         struct xc5000_priv *priv = fe->tuner_priv;
776         int ret;
777         u16 id;
778
779         ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
780         if (ret == XC_RESULT_SUCCESS) {
781                 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
782                         ret = XC_RESULT_RESET_FAILURE;
783                 else
784                         ret = XC_RESULT_SUCCESS;
785         }
786
787         dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
788                 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
789         return ret;
790 }
791
792 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
793         struct analog_parameters *params)
794 {
795         struct xc5000_priv *priv = fe->tuner_priv;
796         int ret;
797
798         dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
799                 __func__, params->frequency);
800
801         /* Fix me: it could be air. */
802         priv->rf_mode = params->mode;
803         if (params->mode > XC_RF_MODE_CABLE)
804                 priv->rf_mode = XC_RF_MODE_CABLE;
805
806         /* params->frequency is in units of 62.5khz */
807         priv->freq_hz = params->frequency * 62500;
808
809         /* FIX ME: Some video standards may have several possible audio
810                    standards. We simply default to one of them here.
811          */
812         if (params->std & V4L2_STD_MN) {
813                 /* default to BTSC audio standard */
814                 priv->video_standard = MN_NTSC_PAL_BTSC;
815                 goto tune_channel;
816         }
817
818         if (params->std & V4L2_STD_PAL_BG) {
819                 /* default to NICAM audio standard */
820                 priv->video_standard = BG_PAL_NICAM;
821                 goto tune_channel;
822         }
823
824         if (params->std & V4L2_STD_PAL_I) {
825                 /* default to NICAM audio standard */
826                 priv->video_standard = I_PAL_NICAM;
827                 goto tune_channel;
828         }
829
830         if (params->std & V4L2_STD_PAL_DK) {
831                 /* default to NICAM audio standard */
832                 priv->video_standard = DK_PAL_NICAM;
833                 goto tune_channel;
834         }
835
836         if (params->std & V4L2_STD_SECAM_DK) {
837                 /* default to A2 DK1 audio standard */
838                 priv->video_standard = DK_SECAM_A2DK1;
839                 goto tune_channel;
840         }
841
842         if (params->std & V4L2_STD_SECAM_L) {
843                 priv->video_standard = L_SECAM_NICAM;
844                 goto tune_channel;
845         }
846
847         if (params->std & V4L2_STD_SECAM_LC) {
848                 priv->video_standard = LC_SECAM_NICAM;
849                 goto tune_channel;
850         }
851
852 tune_channel:
853         ret = xc_SetSignalSource(priv, priv->rf_mode);
854         if (ret != XC_RESULT_SUCCESS) {
855                 printk(KERN_ERR
856                         "xc5000: xc_SetSignalSource(%d) failed\n",
857                         priv->rf_mode);
858                 return -EREMOTEIO;
859         }
860
861         ret = xc_SetTVStandard(priv,
862                 XC5000_Standard[priv->video_standard].VideoMode,
863                 XC5000_Standard[priv->video_standard].AudioMode);
864         if (ret != XC_RESULT_SUCCESS) {
865                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
866                 return -EREMOTEIO;
867         }
868
869         xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
870
871         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
872
873         if (debug)
874                 xc_debug_dump(priv);
875
876         return 0;
877 }
878
879 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
880         struct analog_parameters *params)
881 {
882         struct xc5000_priv *priv = fe->tuner_priv;
883         int ret = -EINVAL;
884         u8 radio_input;
885
886         dprintk(1, "%s() frequency=%d (in units of khz)\n",
887                 __func__, params->frequency);
888
889         if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
890                 dprintk(1, "%s() radio input not configured\n", __func__);
891                 return -EINVAL;
892         }
893
894         if (priv->radio_input == XC5000_RADIO_FM1)
895                 radio_input = FM_Radio_INPUT1;
896         else if  (priv->radio_input == XC5000_RADIO_FM2)
897                 radio_input = FM_Radio_INPUT2;
898         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
899                 radio_input = FM_Radio_INPUT1_MONO;
900         else {
901                 dprintk(1, "%s() unknown radio input %d\n", __func__,
902                         priv->radio_input);
903                 return -EINVAL;
904         }
905
906         priv->freq_hz = params->frequency * 125 / 2;
907
908         priv->rf_mode = XC_RF_MODE_AIR;
909
910         ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
911                                XC5000_Standard[radio_input].AudioMode);
912
913         if (ret != XC_RESULT_SUCCESS) {
914                 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
915                 return -EREMOTEIO;
916         }
917
918         ret = xc_SetSignalSource(priv, priv->rf_mode);
919         if (ret != XC_RESULT_SUCCESS) {
920                 printk(KERN_ERR
921                         "xc5000: xc_SetSignalSource(%d) failed\n",
922                         priv->rf_mode);
923                 return -EREMOTEIO;
924         }
925
926         if ((priv->radio_input == XC5000_RADIO_FM1) ||
927                                 (priv->radio_input == XC5000_RADIO_FM2))
928                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
929         else if  (priv->radio_input == XC5000_RADIO_FM1_MONO)
930                 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
931
932         xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
933
934         return 0;
935 }
936
937 static int xc5000_set_analog_params(struct dvb_frontend *fe,
938                              struct analog_parameters *params)
939 {
940         struct xc5000_priv *priv = fe->tuner_priv;
941         int ret = -EINVAL;
942
943         if (priv->i2c_props.adap == NULL)
944                 return -EINVAL;
945
946         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
947                 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
948                         dprintk(1, "Unable to load firmware and init tuner\n");
949                         return -EINVAL;
950                 }
951         }
952
953         switch (params->mode) {
954         case V4L2_TUNER_RADIO:
955                 ret = xc5000_set_radio_freq(fe, params);
956                 break;
957         case V4L2_TUNER_ANALOG_TV:
958         case V4L2_TUNER_DIGITAL_TV:
959                 ret = xc5000_set_tv_freq(fe, params);
960                 break;
961         }
962
963         return ret;
964 }
965
966
967 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
968 {
969         struct xc5000_priv *priv = fe->tuner_priv;
970         dprintk(1, "%s()\n", __func__);
971         *freq = priv->freq_hz;
972         return 0;
973 }
974
975 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
976 {
977         struct xc5000_priv *priv = fe->tuner_priv;
978         dprintk(1, "%s()\n", __func__);
979         *freq = priv->if_khz * 1000;
980         return 0;
981 }
982
983 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
984 {
985         struct xc5000_priv *priv = fe->tuner_priv;
986         dprintk(1, "%s()\n", __func__);
987
988         *bw = priv->bandwidth;
989         return 0;
990 }
991
992 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
993 {
994         struct xc5000_priv *priv = fe->tuner_priv;
995         u16 lock_status = 0;
996
997         xc_get_lock_status(priv, &lock_status);
998
999         dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1000
1001         *status = lock_status;
1002
1003         return 0;
1004 }
1005
1006 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
1007 {
1008         struct xc5000_priv *priv = fe->tuner_priv;
1009         int ret = 0;
1010
1011         if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1012                 ret = xc5000_fwupload(fe);
1013                 if (ret != XC_RESULT_SUCCESS)
1014                         return ret;
1015         }
1016
1017         /* Start the tuner self-calibration process */
1018         ret |= xc_initialize(priv);
1019
1020         /* Wait for calibration to complete.
1021          * We could continue but XC5000 will clock stretch subsequent
1022          * I2C transactions until calibration is complete.  This way we
1023          * don't have to rely on clock stretching working.
1024          */
1025         xc_wait(100);
1026
1027         /* Default to "CABLE" mode */
1028         ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1029
1030         return ret;
1031 }
1032
1033 static int xc5000_sleep(struct dvb_frontend *fe)
1034 {
1035         int ret;
1036
1037         dprintk(1, "%s()\n", __func__);
1038
1039         /* Avoid firmware reload on slow devices */
1040         if (no_poweroff)
1041                 return 0;
1042
1043         /* According to Xceive technical support, the "powerdown" register
1044            was removed in newer versions of the firmware.  The "supported"
1045            way to sleep the tuner is to pull the reset pin low for 10ms */
1046         ret = xc5000_TunerReset(fe);
1047         if (ret != XC_RESULT_SUCCESS) {
1048                 printk(KERN_ERR
1049                         "xc5000: %s() unable to shutdown tuner\n",
1050                         __func__);
1051                 return -EREMOTEIO;
1052         } else
1053                 return XC_RESULT_SUCCESS;
1054 }
1055
1056 static int xc5000_init(struct dvb_frontend *fe)
1057 {
1058         struct xc5000_priv *priv = fe->tuner_priv;
1059         dprintk(1, "%s()\n", __func__);
1060
1061         if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1062                 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1063                 return -EREMOTEIO;
1064         }
1065
1066         if (debug)
1067                 xc_debug_dump(priv);
1068
1069         return 0;
1070 }
1071
1072 static int xc5000_release(struct dvb_frontend *fe)
1073 {
1074         struct xc5000_priv *priv = fe->tuner_priv;
1075
1076         dprintk(1, "%s()\n", __func__);
1077
1078         mutex_lock(&xc5000_list_mutex);
1079
1080         if (priv)
1081                 hybrid_tuner_release_state(priv);
1082
1083         mutex_unlock(&xc5000_list_mutex);
1084
1085         fe->tuner_priv = NULL;
1086
1087         return 0;
1088 }
1089
1090 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1091 {
1092         struct xc5000_priv *priv = fe->tuner_priv;
1093         struct xc5000_config *p = priv_cfg;
1094
1095         dprintk(1, "%s()\n", __func__);
1096
1097         if (p->if_khz)
1098                 priv->if_khz = p->if_khz;
1099
1100         if (p->radio_input)
1101                 priv->radio_input = p->radio_input;
1102
1103         return 0;
1104 }
1105
1106
1107 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1108         .info = {
1109                 .name           = "Xceive XC5000",
1110                 .frequency_min  =    1000000,
1111                 .frequency_max  = 1023000000,
1112                 .frequency_step =      50000,
1113         },
1114
1115         .release           = xc5000_release,
1116         .init              = xc5000_init,
1117         .sleep             = xc5000_sleep,
1118
1119         .set_config        = xc5000_set_config,
1120         .set_params        = xc5000_set_params,
1121         .set_analog_params = xc5000_set_analog_params,
1122         .get_frequency     = xc5000_get_frequency,
1123         .get_if_frequency  = xc5000_get_if_frequency,
1124         .get_bandwidth     = xc5000_get_bandwidth,
1125         .get_status        = xc5000_get_status
1126 };
1127
1128 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1129                                    struct i2c_adapter *i2c,
1130                                    const struct xc5000_config *cfg)
1131 {
1132         struct xc5000_priv *priv = NULL;
1133         int instance;
1134         u16 id = 0;
1135
1136         dprintk(1, "%s(%d-%04x)\n", __func__,
1137                 i2c ? i2c_adapter_id(i2c) : -1,
1138                 cfg ? cfg->i2c_address : -1);
1139
1140         mutex_lock(&xc5000_list_mutex);
1141
1142         instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1143                                               hybrid_tuner_instance_list,
1144                                               i2c, cfg->i2c_address, "xc5000");
1145         switch (instance) {
1146         case 0:
1147                 goto fail;
1148                 break;
1149         case 1:
1150                 /* new tuner instance */
1151                 priv->bandwidth = 6000000;
1152                 fe->tuner_priv = priv;
1153                 break;
1154         default:
1155                 /* existing tuner instance */
1156                 fe->tuner_priv = priv;
1157                 break;
1158         }
1159
1160         if (priv->if_khz == 0) {
1161                 /* If the IF hasn't been set yet, use the value provided by
1162                    the caller (occurs in hybrid devices where the analog
1163                    call to xc5000_attach occurs before the digital side) */
1164                 priv->if_khz = cfg->if_khz;
1165         }
1166
1167         if (priv->radio_input == 0)
1168                 priv->radio_input = cfg->radio_input;
1169
1170         /* don't override chip id if it's already been set
1171            unless explicitly specified */
1172         if ((priv->chip_id == 0) || (cfg->chip_id))
1173                 /* use default chip id if none specified, set to 0 so
1174                    it can be overridden if this is a hybrid driver */
1175                 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1176
1177         /* Check if firmware has been loaded. It is possible that another
1178            instance of the driver has loaded the firmware.
1179          */
1180         if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1181                 goto fail;
1182
1183         switch (id) {
1184         case XC_PRODUCT_ID_FW_LOADED:
1185                 printk(KERN_INFO
1186                         "xc5000: Successfully identified at address 0x%02x\n",
1187                         cfg->i2c_address);
1188                 printk(KERN_INFO
1189                         "xc5000: Firmware has been loaded previously\n");
1190                 break;
1191         case XC_PRODUCT_ID_FW_NOT_LOADED:
1192                 printk(KERN_INFO
1193                         "xc5000: Successfully identified at address 0x%02x\n",
1194                         cfg->i2c_address);
1195                 printk(KERN_INFO
1196                         "xc5000: Firmware has not been loaded previously\n");
1197                 break;
1198         default:
1199                 printk(KERN_ERR
1200                         "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1201                         cfg->i2c_address, id);
1202                 goto fail;
1203         }
1204
1205         mutex_unlock(&xc5000_list_mutex);
1206
1207         memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1208                 sizeof(struct dvb_tuner_ops));
1209
1210         return fe;
1211 fail:
1212         mutex_unlock(&xc5000_list_mutex);
1213
1214         xc5000_release(fe);
1215         return NULL;
1216 }
1217 EXPORT_SYMBOL(xc5000_attach);
1218
1219 MODULE_AUTHOR("Steven Toth");
1220 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1221 MODULE_LICENSE("GPL");