2 * Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
4 * Copyright (c) 2007 Xceive Corporation
5 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
6 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
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.
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
17 * GNU General Public License for more details.
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.
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>
31 #include "dvb_frontend.h"
34 #include "tuner-i2c.h"
37 module_param(debug, int, 0644);
38 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
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");
46 static DEFINE_MUTEX(xc5000_list_mutex);
47 static LIST_HEAD(hybrid_tuner_instance_list);
49 #define dprintk(level, fmt, arg...) if (debug >= level) \
50 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
53 struct tuner_i2c_props i2c_props;
54 struct list_head hybrid_tuner_instance_list;
66 u8 init_status_supported;
67 u8 fw_checksum_supported;
71 #define MAX_TV_STANDARD 24
72 #define XC_MAX_I2C_WRITE_LENGTH 64
75 #define XC_RF_MODE_AIR 0
76 #define XC_RF_MODE_CABLE 1
79 #define XC_RESULT_SUCCESS 0
80 #define XC_RESULT_RESET_FAILURE 1
81 #define XC_RESULT_I2C_WRITE_FAILURE 2
82 #define XC_RESULT_I2C_READ_FAILURE 3
83 #define XC_RESULT_OUT_OF_RANGE 5
86 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
87 #define XC_PRODUCT_ID_FW_LOADED 0x1388
90 #define XREG_INIT 0x00
91 #define XREG_VIDEO_MODE 0x01
92 #define XREG_AUDIO_MODE 0x02
93 #define XREG_RF_FREQ 0x03
94 #define XREG_D_CODE 0x04
95 #define XREG_IF_OUT 0x05
96 #define XREG_SEEK_MODE 0x07
97 #define XREG_POWER_DOWN 0x0A /* Obsolete */
98 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
99 #define XREG_OUTPUT_AMP 0x0B
100 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
101 #define XREG_SMOOTHEDCVBS 0x0E
102 #define XREG_XTALFREQ 0x0F
103 #define XREG_FINERFREQ 0x10
104 #define XREG_DDIMODE 0x11
106 #define XREG_ADC_ENV 0x00
107 #define XREG_QUALITY 0x01
108 #define XREG_FRAME_LINES 0x02
109 #define XREG_HSYNC_FREQ 0x03
110 #define XREG_LOCK 0x04
111 #define XREG_FREQ_ERROR 0x05
112 #define XREG_SNR 0x06
113 #define XREG_VERSION 0x07
114 #define XREG_PRODUCT_ID 0x08
115 #define XREG_BUSY 0x09
116 #define XREG_BUILD 0x0D
117 #define XREG_TOTALGAIN 0x0F
118 #define XREG_FW_CHECKSUM 0x12
119 #define XREG_INIT_STATUS 0x13
122 Basic firmware description. This will remain with
123 the driver for documentation purposes.
125 This represents an I2C firmware file encoded as a
126 string of unsigned char. Format is as follows:
128 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
129 char[1 ]=len0_LSB -> length of first write transaction
130 char[2 ]=data0 -> first byte to be sent
134 char[M ]=dataN -> last byte to be sent
135 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
136 char[M+2]=len1_LSB -> length of second write transaction
142 The [len] value should be interpreted as follows:
144 len= len_MSB _ len_LSB
145 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
146 len=0000_0000_0000_0000 : Reset command: Do hardware reset
147 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
148 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
150 For the RESET and WAIT commands, the two following bytes will contain
151 immediately the length of the following transaction.
154 struct XC_TV_STANDARD {
160 /* Tuner standards */
161 #define MN_NTSC_PAL_BTSC 0
162 #define MN_NTSC_PAL_A2 1
163 #define MN_NTSC_PAL_EIAJ 2
164 #define MN_NTSC_PAL_Mono 3
166 #define BG_PAL_NICAM 5
167 #define BG_PAL_MONO 6
168 #define I_PAL_NICAM 7
169 #define I_PAL_NICAM_MONO 8
171 #define DK_PAL_NICAM 10
172 #define DK_PAL_MONO 11
173 #define DK_SECAM_A2DK1 12
174 #define DK_SECAM_A2LDK3 13
175 #define DK_SECAM_A2MONO 14
176 #define L_SECAM_NICAM 15
177 #define LC_SECAM_NICAM 16
182 #define FM_Radio_INPUT2 21
183 #define FM_Radio_INPUT1 22
184 #define FM_Radio_INPUT1_MONO 23
186 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
187 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
188 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
189 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
190 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
191 {"B/G-PAL-A2", 0x0A00, 0x8049},
192 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
193 {"B/G-PAL-MONO", 0x0878, 0x8059},
194 {"I-PAL-NICAM", 0x1080, 0x8009},
195 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
196 {"D/K-PAL-A2", 0x1600, 0x8009},
197 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
198 {"D/K-PAL-MONO", 0x1478, 0x8009},
199 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
200 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
201 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
202 {"L-SECAM-NICAM", 0x8E82, 0x0009},
203 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
204 {"DTV6", 0x00C0, 0x8002},
205 {"DTV8", 0x00C0, 0x800B},
206 {"DTV7/8", 0x00C0, 0x801B},
207 {"DTV7", 0x00C0, 0x8007},
208 {"FM Radio-INPUT2", 0x9802, 0x9002},
209 {"FM Radio-INPUT1", 0x0208, 0x9002},
210 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
214 struct xc5000_fw_cfg {
218 u8 init_status_supported;
219 u8 fw_checksum_supported;
222 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
223 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
224 .name = XC5000A_FIRMWARE,
229 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
230 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
231 .name = XC5000C_FIRMWARE,
234 .init_status_supported = 1,
235 .fw_checksum_supported = 1,
238 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
243 return &xc5000a_1_6_114;
245 return &xc5000c_41_024_5;
249 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
250 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
251 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
252 static int xc5000_TunerReset(struct dvb_frontend *fe);
254 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
256 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
257 .flags = 0, .buf = buf, .len = len };
259 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
260 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
261 return XC_RESULT_I2C_WRITE_FAILURE;
263 return XC_RESULT_SUCCESS;
267 /* This routine is never used because the only time we read data from the
268 i2c bus is when we read registers, and we want that to be an atomic i2c
269 transaction in case we are on a multi-master bus */
270 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
272 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
273 .flags = I2C_M_RD, .buf = buf, .len = len };
275 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
276 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
283 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
285 u8 buf[2] = { reg >> 8, reg & 0xff };
286 u8 bval[2] = { 0, 0 };
287 struct i2c_msg msg[2] = {
288 { .addr = priv->i2c_props.addr,
289 .flags = 0, .buf = &buf[0], .len = 2 },
290 { .addr = priv->i2c_props.addr,
291 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
294 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
295 printk(KERN_WARNING "xc5000: I2C read failed\n");
299 *val = (bval[0] << 8) | bval[1];
300 return XC_RESULT_SUCCESS;
303 static void xc_wait(int wait_ms)
308 static int xc5000_TunerReset(struct dvb_frontend *fe)
310 struct xc5000_priv *priv = fe->tuner_priv;
313 dprintk(1, "%s()\n", __func__);
316 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
318 priv->i2c_props.adap->algo_data,
319 DVB_FRONTEND_COMPONENT_TUNER,
320 XC5000_TUNER_RESET, 0);
322 printk(KERN_ERR "xc5000: reset failed\n");
323 return XC_RESULT_RESET_FAILURE;
326 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
327 return XC_RESULT_RESET_FAILURE;
329 return XC_RESULT_SUCCESS;
332 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
335 int WatchDogTimer = 100;
338 buf[0] = (regAddr >> 8) & 0xFF;
339 buf[1] = regAddr & 0xFF;
340 buf[2] = (i2cData >> 8) & 0xFF;
341 buf[3] = i2cData & 0xFF;
342 result = xc_send_i2c_data(priv, buf, 4);
343 if (result == XC_RESULT_SUCCESS) {
344 /* wait for busy flag to clear */
345 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
346 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
347 if (result == XC_RESULT_SUCCESS) {
348 if ((buf[0] == 0) && (buf[1] == 0)) {
349 /* busy flag cleared */
352 xc_wait(5); /* wait 5 ms */
358 if (WatchDogTimer <= 0)
359 result = XC_RESULT_I2C_WRITE_FAILURE;
364 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
366 struct xc5000_priv *priv = fe->tuner_priv;
368 int i, nbytes_to_send, result;
369 unsigned int len, pos, index;
370 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
373 while ((i2c_sequence[index] != 0xFF) ||
374 (i2c_sequence[index + 1] != 0xFF)) {
375 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
378 result = xc5000_TunerReset(fe);
380 if (result != XC_RESULT_SUCCESS)
382 } else if (len & 0x8000) {
384 xc_wait(len & 0x7FFF);
387 /* Send i2c data whilst ensuring individual transactions
388 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
391 buf[0] = i2c_sequence[index];
392 buf[1] = i2c_sequence[index + 1];
395 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
397 XC_MAX_I2C_WRITE_LENGTH;
399 nbytes_to_send = (len - pos + 2);
400 for (i = 2; i < nbytes_to_send; i++) {
401 buf[i] = i2c_sequence[index + pos +
404 result = xc_send_i2c_data(priv, buf,
407 if (result != XC_RESULT_SUCCESS)
410 pos += nbytes_to_send - 2;
415 return XC_RESULT_SUCCESS;
418 static int xc_initialize(struct xc5000_priv *priv)
420 dprintk(1, "%s()\n", __func__);
421 return xc_write_reg(priv, XREG_INIT, 0);
424 static int xc_SetTVStandard(struct xc5000_priv *priv,
425 u16 VideoMode, u16 AudioMode)
428 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
429 dprintk(1, "%s() Standard = %s\n",
431 XC5000_Standard[priv->video_standard].Name);
433 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
434 if (ret == XC_RESULT_SUCCESS)
435 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
440 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
442 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
443 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
445 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
446 rf_mode = XC_RF_MODE_CABLE;
448 "%s(), Invalid mode, defaulting to CABLE",
451 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
454 static const struct dvb_tuner_ops xc5000_tuner_ops;
456 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
460 dprintk(1, "%s(%u)\n", __func__, freq_hz);
462 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
463 (freq_hz < xc5000_tuner_ops.info.frequency_min))
464 return XC_RESULT_OUT_OF_RANGE;
466 freq_code = (u16)(freq_hz / 15625);
468 /* Starting in firmware version 1.1.44, Xceive recommends using the
469 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
470 only be used for fast scanning for channel lock) */
471 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
475 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
477 u32 freq_code = (freq_khz * 1024)/1000;
478 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
479 __func__, freq_khz, freq_code);
481 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
485 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
487 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
490 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
496 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
497 if (result != XC_RESULT_SUCCESS)
501 (*freq_error_hz) = (tmp * 15625) / 1000;
505 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
507 return xc5000_readreg(priv, XREG_LOCK, lock_status);
510 static int xc_get_version(struct xc5000_priv *priv,
511 u8 *hw_majorversion, u8 *hw_minorversion,
512 u8 *fw_majorversion, u8 *fw_minorversion)
517 result = xc5000_readreg(priv, XREG_VERSION, &data);
518 if (result != XC_RESULT_SUCCESS)
521 (*hw_majorversion) = (data >> 12) & 0x0F;
522 (*hw_minorversion) = (data >> 8) & 0x0F;
523 (*fw_majorversion) = (data >> 4) & 0x0F;
524 (*fw_minorversion) = data & 0x0F;
529 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
531 return xc5000_readreg(priv, XREG_BUILD, buildrev);
534 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
539 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
540 if (result != XC_RESULT_SUCCESS)
543 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
547 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
549 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
552 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
554 return xc5000_readreg(priv, XREG_QUALITY, quality);
557 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
559 return xc5000_readreg(priv, XREG_SNR, snr);
562 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
564 return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
567 static u16 WaitForLock(struct xc5000_priv *priv)
570 int watchDogCount = 40;
572 while ((lockState == 0) && (watchDogCount > 0)) {
573 xc_get_lock_status(priv, &lockState);
574 if (lockState != 1) {
582 #define XC_TUNE_ANALOG 0
583 #define XC_TUNE_DIGITAL 1
584 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
588 dprintk(1, "%s(%u)\n", __func__, freq_hz);
590 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
593 if (mode == XC_TUNE_ANALOG) {
594 if (WaitForLock(priv) == 1)
601 static int xc_set_xtal(struct dvb_frontend *fe)
603 struct xc5000_priv *priv = fe->tuner_priv;
604 int ret = XC_RESULT_SUCCESS;
606 switch (priv->chip_id) {
609 /* 32.000 MHz xtal is default */
612 switch (priv->xtal_khz) {
615 /* 32.000 MHz xtal is default */
618 /* 31.875 MHz xtal configuration */
619 ret = xc_write_reg(priv, 0x000f, 0x8081);
627 static int xc5000_fwupload(struct dvb_frontend *fe)
629 struct xc5000_priv *priv = fe->tuner_priv;
630 const struct firmware *fw;
632 const struct xc5000_fw_cfg *desired_fw =
633 xc5000_assign_firmware(priv->chip_id);
634 priv->pll_register_no = desired_fw->pll_reg;
635 priv->init_status_supported = desired_fw->init_status_supported;
636 priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
638 /* request the firmware, this will block and timeout */
639 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
642 ret = request_firmware(&fw, desired_fw->name,
643 priv->i2c_props.adap->dev.parent);
645 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
646 ret = XC_RESULT_RESET_FAILURE;
649 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
651 ret = XC_RESULT_SUCCESS;
654 if (fw->size != desired_fw->size) {
655 printk(KERN_ERR "xc5000: firmware incorrect size\n");
656 ret = XC_RESULT_RESET_FAILURE;
658 printk(KERN_INFO "xc5000: firmware uploading...\n");
659 ret = xc_load_i2c_sequence(fe, fw->data);
660 if (XC_RESULT_SUCCESS == ret)
661 ret = xc_set_xtal(fe);
662 if (XC_RESULT_SUCCESS == ret)
663 printk(KERN_INFO "xc5000: firmware upload complete...\n");
665 printk(KERN_ERR "xc5000: firmware upload failed...\n");
669 release_firmware(fw);
673 static void xc_debug_dump(struct xc5000_priv *priv)
676 u32 freq_error_hz = 0;
678 u32 hsync_freq_hz = 0;
683 u8 hw_majorversion = 0, hw_minorversion = 0;
684 u8 fw_majorversion = 0, fw_minorversion = 0;
685 u16 fw_buildversion = 0;
688 /* Wait for stats to stabilize.
689 * Frame Lines needs two frame times after initial lock
690 * before it is valid.
694 xc_get_ADC_Envelope(priv, &adc_envelope);
695 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
697 xc_get_frequency_error(priv, &freq_error_hz);
698 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
700 xc_get_lock_status(priv, &lock_status);
701 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
704 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
705 &fw_majorversion, &fw_minorversion);
706 xc_get_buildversion(priv, &fw_buildversion);
707 dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
708 hw_majorversion, hw_minorversion,
709 fw_majorversion, fw_minorversion, fw_buildversion);
711 xc_get_hsync_freq(priv, &hsync_freq_hz);
712 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
714 xc_get_frame_lines(priv, &frame_lines);
715 dprintk(1, "*** Frame lines = %d\n", frame_lines);
717 xc_get_quality(priv, &quality);
718 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
720 xc_get_analogsnr(priv, &snr);
721 dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
723 xc_get_totalgain(priv, &totalgain);
724 dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
725 (totalgain % 256) * 100 / 256);
727 if (priv->pll_register_no) {
728 xc5000_readreg(priv, priv->pll_register_no, ®val);
729 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
733 static int xc5000_set_params(struct dvb_frontend *fe)
736 struct xc5000_priv *priv = fe->tuner_priv;
737 u32 bw = fe->dtv_property_cache.bandwidth_hz;
738 u32 freq = fe->dtv_property_cache.frequency;
739 u32 delsys = fe->dtv_property_cache.delivery_system;
741 if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
742 dprintk(1, "Unable to load firmware and init tuner\n");
746 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
750 dprintk(1, "%s() VSB modulation\n", __func__);
751 priv->rf_mode = XC_RF_MODE_AIR;
752 priv->freq_hz = freq - 1750000;
753 priv->video_standard = DTV6;
755 case SYS_DVBC_ANNEX_B:
756 dprintk(1, "%s() QAM modulation\n", __func__);
757 priv->rf_mode = XC_RF_MODE_CABLE;
758 priv->freq_hz = freq - 1750000;
759 priv->video_standard = DTV6;
762 /* All ISDB-T are currently for 6 MHz bw */
765 /* fall to OFDM handling */
769 dprintk(1, "%s() OFDM\n", __func__);
772 priv->video_standard = DTV6;
773 priv->freq_hz = freq - 1750000;
776 priv->video_standard = DTV7;
777 priv->freq_hz = freq - 2250000;
780 priv->video_standard = DTV8;
781 priv->freq_hz = freq - 2750000;
784 printk(KERN_ERR "xc5000 bandwidth not set!\n");
787 priv->rf_mode = XC_RF_MODE_AIR;
789 case SYS_DVBC_ANNEX_A:
790 case SYS_DVBC_ANNEX_C:
791 dprintk(1, "%s() QAM modulation\n", __func__);
792 priv->rf_mode = XC_RF_MODE_CABLE;
794 priv->video_standard = DTV6;
795 priv->freq_hz = freq - 1750000;
797 } else if (bw <= 7000000) {
798 priv->video_standard = DTV7;
799 priv->freq_hz = freq - 2250000;
802 priv->video_standard = DTV7_8;
803 priv->freq_hz = freq - 2750000;
806 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
810 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
814 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
815 __func__, freq, priv->freq_hz);
817 ret = xc_SetSignalSource(priv, priv->rf_mode);
818 if (ret != XC_RESULT_SUCCESS) {
820 "xc5000: xc_SetSignalSource(%d) failed\n",
825 ret = xc_SetTVStandard(priv,
826 XC5000_Standard[priv->video_standard].VideoMode,
827 XC5000_Standard[priv->video_standard].AudioMode);
828 if (ret != XC_RESULT_SUCCESS) {
829 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
833 ret = xc_set_IF_frequency(priv, priv->if_khz);
834 if (ret != XC_RESULT_SUCCESS) {
835 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
840 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
842 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
847 priv->bandwidth = bw;
852 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
854 struct xc5000_priv *priv = fe->tuner_priv;
858 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
859 if (ret == XC_RESULT_SUCCESS) {
860 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
861 ret = XC_RESULT_RESET_FAILURE;
863 ret = XC_RESULT_SUCCESS;
866 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
867 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
871 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
872 struct analog_parameters *params)
874 struct xc5000_priv *priv = fe->tuner_priv;
878 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
879 __func__, params->frequency);
881 /* Fix me: it could be air. */
882 priv->rf_mode = params->mode;
883 if (params->mode > XC_RF_MODE_CABLE)
884 priv->rf_mode = XC_RF_MODE_CABLE;
886 /* params->frequency is in units of 62.5khz */
887 priv->freq_hz = params->frequency * 62500;
889 /* FIX ME: Some video standards may have several possible audio
890 standards. We simply default to one of them here.
892 if (params->std & V4L2_STD_MN) {
893 /* default to BTSC audio standard */
894 priv->video_standard = MN_NTSC_PAL_BTSC;
898 if (params->std & V4L2_STD_PAL_BG) {
899 /* default to NICAM audio standard */
900 priv->video_standard = BG_PAL_NICAM;
904 if (params->std & V4L2_STD_PAL_I) {
905 /* default to NICAM audio standard */
906 priv->video_standard = I_PAL_NICAM;
910 if (params->std & V4L2_STD_PAL_DK) {
911 /* default to NICAM audio standard */
912 priv->video_standard = DK_PAL_NICAM;
916 if (params->std & V4L2_STD_SECAM_DK) {
917 /* default to A2 DK1 audio standard */
918 priv->video_standard = DK_SECAM_A2DK1;
922 if (params->std & V4L2_STD_SECAM_L) {
923 priv->video_standard = L_SECAM_NICAM;
927 if (params->std & V4L2_STD_SECAM_LC) {
928 priv->video_standard = LC_SECAM_NICAM;
933 ret = xc_SetSignalSource(priv, priv->rf_mode);
934 if (ret != XC_RESULT_SUCCESS) {
936 "xc5000: xc_SetSignalSource(%d) failed\n",
941 ret = xc_SetTVStandard(priv,
942 XC5000_Standard[priv->video_standard].VideoMode,
943 XC5000_Standard[priv->video_standard].AudioMode);
944 if (ret != XC_RESULT_SUCCESS) {
945 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
949 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
951 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
956 if (priv->pll_register_no != 0) {
958 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
959 if (pll_lock_status > 63) {
960 /* PLL is unlocked, force reload of the firmware */
961 dprintk(1, "xc5000: PLL not locked (0x%x). Reloading...\n",
963 if (xc_load_fw_and_init_tuner(fe, 1) != XC_RESULT_SUCCESS) {
964 printk(KERN_ERR "xc5000: Unable to reload fw\n");
974 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
975 struct analog_parameters *params)
977 struct xc5000_priv *priv = fe->tuner_priv;
981 dprintk(1, "%s() frequency=%d (in units of khz)\n",
982 __func__, params->frequency);
984 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
985 dprintk(1, "%s() radio input not configured\n", __func__);
989 if (priv->radio_input == XC5000_RADIO_FM1)
990 radio_input = FM_Radio_INPUT1;
991 else if (priv->radio_input == XC5000_RADIO_FM2)
992 radio_input = FM_Radio_INPUT2;
993 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
994 radio_input = FM_Radio_INPUT1_MONO;
996 dprintk(1, "%s() unknown radio input %d\n", __func__,
1001 priv->freq_hz = params->frequency * 125 / 2;
1003 priv->rf_mode = XC_RF_MODE_AIR;
1005 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
1006 XC5000_Standard[radio_input].AudioMode);
1008 if (ret != XC_RESULT_SUCCESS) {
1009 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
1013 ret = xc_SetSignalSource(priv, priv->rf_mode);
1014 if (ret != XC_RESULT_SUCCESS) {
1016 "xc5000: xc_SetSignalSource(%d) failed\n",
1021 if ((priv->radio_input == XC5000_RADIO_FM1) ||
1022 (priv->radio_input == XC5000_RADIO_FM2))
1023 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1024 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
1025 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1027 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1032 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1033 struct analog_parameters *params)
1035 struct xc5000_priv *priv = fe->tuner_priv;
1038 if (priv->i2c_props.adap == NULL)
1041 if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1042 dprintk(1, "Unable to load firmware and init tuner\n");
1046 switch (params->mode) {
1047 case V4L2_TUNER_RADIO:
1048 ret = xc5000_set_radio_freq(fe, params);
1050 case V4L2_TUNER_ANALOG_TV:
1051 case V4L2_TUNER_DIGITAL_TV:
1052 ret = xc5000_set_tv_freq(fe, params);
1060 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1062 struct xc5000_priv *priv = fe->tuner_priv;
1063 dprintk(1, "%s()\n", __func__);
1064 *freq = priv->freq_hz;
1068 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1070 struct xc5000_priv *priv = fe->tuner_priv;
1071 dprintk(1, "%s()\n", __func__);
1072 *freq = priv->if_khz * 1000;
1076 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1078 struct xc5000_priv *priv = fe->tuner_priv;
1079 dprintk(1, "%s()\n", __func__);
1081 *bw = priv->bandwidth;
1085 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1087 struct xc5000_priv *priv = fe->tuner_priv;
1088 u16 lock_status = 0;
1090 xc_get_lock_status(priv, &lock_status);
1092 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1094 *status = lock_status;
1099 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1101 struct xc5000_priv *priv = fe->tuner_priv;
1102 int ret = XC_RESULT_SUCCESS;
1103 u16 pll_lock_status;
1106 if (force || xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1110 ret = xc5000_fwupload(fe);
1111 if (ret != XC_RESULT_SUCCESS)
1116 if (priv->fw_checksum_supported) {
1117 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)
1118 != XC_RESULT_SUCCESS) {
1119 dprintk(1, "%s() FW checksum reading failed.\n",
1125 dprintk(1, "%s() FW checksum failed = 0x%04x\n",
1131 /* Start the tuner self-calibration process */
1132 ret |= xc_initialize(priv);
1134 if (ret != XC_RESULT_SUCCESS)
1137 /* Wait for calibration to complete.
1138 * We could continue but XC5000 will clock stretch subsequent
1139 * I2C transactions until calibration is complete. This way we
1140 * don't have to rely on clock stretching working.
1144 if (priv->init_status_supported) {
1145 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck) != XC_RESULT_SUCCESS) {
1146 dprintk(1, "%s() FW failed reading init status.\n",
1152 dprintk(1, "%s() FW init status failed = 0x%04x\n", __func__, fw_ck);
1157 if (priv->pll_register_no) {
1158 xc5000_readreg(priv, priv->pll_register_no,
1160 if (pll_lock_status > 63) {
1161 /* PLL is unlocked, force reload of the firmware */
1162 printk(KERN_ERR "xc5000: PLL not running after fwload.\n");
1167 /* Default to "CABLE" mode */
1168 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1174 static int xc5000_sleep(struct dvb_frontend *fe)
1178 dprintk(1, "%s()\n", __func__);
1180 /* Avoid firmware reload on slow devices */
1184 /* According to Xceive technical support, the "powerdown" register
1185 was removed in newer versions of the firmware. The "supported"
1186 way to sleep the tuner is to pull the reset pin low for 10ms */
1187 ret = xc5000_TunerReset(fe);
1188 if (ret != XC_RESULT_SUCCESS) {
1190 "xc5000: %s() unable to shutdown tuner\n",
1194 return XC_RESULT_SUCCESS;
1197 static int xc5000_init(struct dvb_frontend *fe)
1199 struct xc5000_priv *priv = fe->tuner_priv;
1200 dprintk(1, "%s()\n", __func__);
1202 if (xc_load_fw_and_init_tuner(fe, 0) != XC_RESULT_SUCCESS) {
1203 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1208 xc_debug_dump(priv);
1213 static int xc5000_release(struct dvb_frontend *fe)
1215 struct xc5000_priv *priv = fe->tuner_priv;
1217 dprintk(1, "%s()\n", __func__);
1219 mutex_lock(&xc5000_list_mutex);
1222 hybrid_tuner_release_state(priv);
1224 mutex_unlock(&xc5000_list_mutex);
1226 fe->tuner_priv = NULL;
1231 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1233 struct xc5000_priv *priv = fe->tuner_priv;
1234 struct xc5000_config *p = priv_cfg;
1236 dprintk(1, "%s()\n", __func__);
1239 priv->if_khz = p->if_khz;
1242 priv->radio_input = p->radio_input;
1248 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1250 .name = "Xceive XC5000",
1251 .frequency_min = 1000000,
1252 .frequency_max = 1023000000,
1253 .frequency_step = 50000,
1256 .release = xc5000_release,
1257 .init = xc5000_init,
1258 .sleep = xc5000_sleep,
1260 .set_config = xc5000_set_config,
1261 .set_params = xc5000_set_params,
1262 .set_analog_params = xc5000_set_analog_params,
1263 .get_frequency = xc5000_get_frequency,
1264 .get_if_frequency = xc5000_get_if_frequency,
1265 .get_bandwidth = xc5000_get_bandwidth,
1266 .get_status = xc5000_get_status
1269 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1270 struct i2c_adapter *i2c,
1271 const struct xc5000_config *cfg)
1273 struct xc5000_priv *priv = NULL;
1277 dprintk(1, "%s(%d-%04x)\n", __func__,
1278 i2c ? i2c_adapter_id(i2c) : -1,
1279 cfg ? cfg->i2c_address : -1);
1281 mutex_lock(&xc5000_list_mutex);
1283 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1284 hybrid_tuner_instance_list,
1285 i2c, cfg->i2c_address, "xc5000");
1291 /* new tuner instance */
1292 priv->bandwidth = 6000000;
1293 fe->tuner_priv = priv;
1296 /* existing tuner instance */
1297 fe->tuner_priv = priv;
1301 if (priv->if_khz == 0) {
1302 /* If the IF hasn't been set yet, use the value provided by
1303 the caller (occurs in hybrid devices where the analog
1304 call to xc5000_attach occurs before the digital side) */
1305 priv->if_khz = cfg->if_khz;
1308 if (priv->xtal_khz == 0)
1309 priv->xtal_khz = cfg->xtal_khz;
1311 if (priv->radio_input == 0)
1312 priv->radio_input = cfg->radio_input;
1314 /* don't override chip id if it's already been set
1315 unless explicitly specified */
1316 if ((priv->chip_id == 0) || (cfg->chip_id))
1317 /* use default chip id if none specified, set to 0 so
1318 it can be overridden if this is a hybrid driver */
1319 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1321 /* Check if firmware has been loaded. It is possible that another
1322 instance of the driver has loaded the firmware.
1324 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1328 case XC_PRODUCT_ID_FW_LOADED:
1330 "xc5000: Successfully identified at address 0x%02x\n",
1333 "xc5000: Firmware has been loaded previously\n");
1335 case XC_PRODUCT_ID_FW_NOT_LOADED:
1337 "xc5000: Successfully identified at address 0x%02x\n",
1340 "xc5000: Firmware has not been loaded previously\n");
1344 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1345 cfg->i2c_address, id);
1349 mutex_unlock(&xc5000_list_mutex);
1351 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1352 sizeof(struct dvb_tuner_ops));
1356 mutex_unlock(&xc5000_list_mutex);
1361 EXPORT_SYMBOL(xc5000_attach);
1363 MODULE_AUTHOR("Steven Toth");
1364 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1365 MODULE_LICENSE("GPL");
1366 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1367 MODULE_FIRMWARE(XC5000C_FIRMWARE);