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