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)
52 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
53 #define XC5000_DEFAULT_FIRMWARE_SIZE 12401
56 struct tuner_i2c_props i2c_props;
57 struct list_head hybrid_tuner_instance_list;
68 #define MAX_TV_STANDARD 23
69 #define XC_MAX_I2C_WRITE_LENGTH 64
72 #define XC_RF_MODE_AIR 0
73 #define XC_RF_MODE_CABLE 1
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
83 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
84 #define XC_PRODUCT_ID_FW_LOADED 0x1388
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 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
96 #define XREG_SMOOTHEDCVBS 0x0E
97 #define XREG_XTALFREQ 0x0F
98 #define XREG_FINERFREQ 0x10
99 #define XREG_DDIMODE 0x11
101 #define XREG_ADC_ENV 0x00
102 #define XREG_QUALITY 0x01
103 #define XREG_FRAME_LINES 0x02
104 #define XREG_HSYNC_FREQ 0x03
105 #define XREG_LOCK 0x04
106 #define XREG_FREQ_ERROR 0x05
107 #define XREG_SNR 0x06
108 #define XREG_VERSION 0x07
109 #define XREG_PRODUCT_ID 0x08
110 #define XREG_BUSY 0x09
111 #define XREG_BUILD 0x0D
114 Basic firmware description. This will remain with
115 the driver for documentation purposes.
117 This represents an I2C firmware file encoded as a
118 string of unsigned char. Format is as follows:
120 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
121 char[1 ]=len0_LSB -> length of first write transaction
122 char[2 ]=data0 -> first byte to be sent
126 char[M ]=dataN -> last byte to be sent
127 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
128 char[M+2]=len1_LSB -> length of second write transaction
134 The [len] value should be interpreted as follows:
136 len= len_MSB _ len_LSB
137 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
138 len=0000_0000_0000_0000 : Reset command: Do hardware reset
139 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
140 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
142 For the RESET and WAIT commands, the two following bytes will contain
143 immediately the length of the following transaction.
146 struct XC_TV_STANDARD {
152 /* Tuner standards */
153 #define MN_NTSC_PAL_BTSC 0
154 #define MN_NTSC_PAL_A2 1
155 #define MN_NTSC_PAL_EIAJ 2
156 #define MN_NTSC_PAL_Mono 3
158 #define BG_PAL_NICAM 5
159 #define BG_PAL_MONO 6
160 #define I_PAL_NICAM 7
161 #define I_PAL_NICAM_MONO 8
163 #define DK_PAL_NICAM 10
164 #define DK_PAL_MONO 11
165 #define DK_SECAM_A2DK1 12
166 #define DK_SECAM_A2LDK3 13
167 #define DK_SECAM_A2MONO 14
168 #define L_SECAM_NICAM 15
169 #define LC_SECAM_NICAM 16
174 #define FM_Radio_INPUT2 21
175 #define FM_Radio_INPUT1 22
177 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
178 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
179 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
180 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
181 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
182 {"B/G-PAL-A2", 0x0A00, 0x8049},
183 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
184 {"B/G-PAL-MONO", 0x0878, 0x8059},
185 {"I-PAL-NICAM", 0x1080, 0x8009},
186 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
187 {"D/K-PAL-A2", 0x1600, 0x8009},
188 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
189 {"D/K-PAL-MONO", 0x1478, 0x8009},
190 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
191 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
192 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
193 {"L-SECAM-NICAM", 0x8E82, 0x0009},
194 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
195 {"DTV6", 0x00C0, 0x8002},
196 {"DTV8", 0x00C0, 0x800B},
197 {"DTV7/8", 0x00C0, 0x801B},
198 {"DTV7", 0x00C0, 0x8007},
199 {"FM Radio-INPUT2", 0x9802, 0x9002},
200 {"FM Radio-INPUT1", 0x0208, 0x9002}
203 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
204 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
205 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
206 static int xc5000_TunerReset(struct dvb_frontend *fe);
208 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
210 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
211 .flags = 0, .buf = buf, .len = len };
213 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
214 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
215 return XC_RESULT_I2C_WRITE_FAILURE;
217 return XC_RESULT_SUCCESS;
220 /* This routine is never used because the only time we read data from the
221 i2c bus is when we read registers, and we want that to be an atomic i2c
222 transaction in case we are on a multi-master bus */
223 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
225 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
226 .flags = I2C_M_RD, .buf = buf, .len = len };
228 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
229 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
235 static void xc_wait(int wait_ms)
240 static int xc5000_TunerReset(struct dvb_frontend *fe)
242 struct xc5000_priv *priv = fe->tuner_priv;
245 dprintk(1, "%s()\n", __func__);
248 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
250 priv->i2c_props.adap->algo_data,
251 DVB_FRONTEND_COMPONENT_TUNER,
252 XC5000_TUNER_RESET, 0);
254 printk(KERN_ERR "xc5000: reset failed\n");
255 return XC_RESULT_RESET_FAILURE;
258 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
259 return XC_RESULT_RESET_FAILURE;
261 return XC_RESULT_SUCCESS;
264 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
267 int WatchDogTimer = 100;
270 buf[0] = (regAddr >> 8) & 0xFF;
271 buf[1] = regAddr & 0xFF;
272 buf[2] = (i2cData >> 8) & 0xFF;
273 buf[3] = i2cData & 0xFF;
274 result = xc_send_i2c_data(priv, buf, 4);
275 if (result == XC_RESULT_SUCCESS) {
276 /* wait for busy flag to clear */
277 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
281 result = xc_send_i2c_data(priv, buf, 2);
282 if (result == XC_RESULT_SUCCESS) {
283 result = xc_read_i2c_data(priv, buf, 2);
284 if (result == XC_RESULT_SUCCESS) {
285 if ((buf[0] == 0) && (buf[1] == 0)) {
286 /* busy flag cleared */
289 xc_wait(5); /* wait 5 ms */
296 if (WatchDogTimer < 0)
297 result = XC_RESULT_I2C_WRITE_FAILURE;
302 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
304 struct xc5000_priv *priv = fe->tuner_priv;
306 int i, nbytes_to_send, result;
307 unsigned int len, pos, index;
308 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
311 while ((i2c_sequence[index] != 0xFF) ||
312 (i2c_sequence[index + 1] != 0xFF)) {
313 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
316 result = xc5000_TunerReset(fe);
318 if (result != XC_RESULT_SUCCESS)
320 } else if (len & 0x8000) {
322 xc_wait(len & 0x7FFF);
325 /* Send i2c data whilst ensuring individual transactions
326 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
329 buf[0] = i2c_sequence[index];
330 buf[1] = i2c_sequence[index + 1];
333 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
335 XC_MAX_I2C_WRITE_LENGTH;
337 nbytes_to_send = (len - pos + 2);
338 for (i = 2; i < nbytes_to_send; i++) {
339 buf[i] = i2c_sequence[index + pos +
342 result = xc_send_i2c_data(priv, buf,
345 if (result != XC_RESULT_SUCCESS)
348 pos += nbytes_to_send - 2;
353 return XC_RESULT_SUCCESS;
356 static int xc_initialize(struct xc5000_priv *priv)
358 dprintk(1, "%s()\n", __func__);
359 return xc_write_reg(priv, XREG_INIT, 0);
362 static int xc_SetTVStandard(struct xc5000_priv *priv,
363 u16 VideoMode, u16 AudioMode)
366 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
367 dprintk(1, "%s() Standard = %s\n",
369 XC5000_Standard[priv->video_standard].Name);
371 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
372 if (ret == XC_RESULT_SUCCESS)
373 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
378 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
380 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
381 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
383 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
384 rf_mode = XC_RF_MODE_CABLE;
386 "%s(), Invalid mode, defaulting to CABLE",
389 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
392 static const struct dvb_tuner_ops xc5000_tuner_ops;
394 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
398 dprintk(1, "%s(%u)\n", __func__, freq_hz);
400 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
401 (freq_hz < xc5000_tuner_ops.info.frequency_min))
402 return XC_RESULT_OUT_OF_RANGE;
404 freq_code = (u16)(freq_hz / 15625);
406 /* Starting in firmware version 1.1.44, Xceive recommends using the
407 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
408 only be used for fast scanning for channel lock) */
409 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
413 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
415 u32 freq_code = (freq_khz * 1024)/1000;
416 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
417 __func__, freq_khz, freq_code);
419 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
423 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
425 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
428 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
434 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
435 if (result != XC_RESULT_SUCCESS)
439 (*freq_error_hz) = (tmp * 15625) / 1000;
443 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
445 return xc5000_readreg(priv, XREG_LOCK, lock_status);
448 static int xc_get_version(struct xc5000_priv *priv,
449 u8 *hw_majorversion, u8 *hw_minorversion,
450 u8 *fw_majorversion, u8 *fw_minorversion)
455 result = xc5000_readreg(priv, XREG_VERSION, &data);
456 if (result != XC_RESULT_SUCCESS)
459 (*hw_majorversion) = (data >> 12) & 0x0F;
460 (*hw_minorversion) = (data >> 8) & 0x0F;
461 (*fw_majorversion) = (data >> 4) & 0x0F;
462 (*fw_minorversion) = data & 0x0F;
467 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
469 return xc5000_readreg(priv, XREG_BUILD, buildrev);
472 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
477 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
478 if (result != XC_RESULT_SUCCESS)
481 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
485 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
487 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
490 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
492 return xc5000_readreg(priv, XREG_QUALITY, quality);
495 static u16 WaitForLock(struct xc5000_priv *priv)
498 int watchDogCount = 40;
500 while ((lockState == 0) && (watchDogCount > 0)) {
501 xc_get_lock_status(priv, &lockState);
502 if (lockState != 1) {
510 #define XC_TUNE_ANALOG 0
511 #define XC_TUNE_DIGITAL 1
512 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
516 dprintk(1, "%s(%u)\n", __func__, freq_hz);
518 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
521 if (mode == XC_TUNE_ANALOG) {
522 if (WaitForLock(priv) == 1)
529 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
531 u8 buf[2] = { reg >> 8, reg & 0xff };
532 u8 bval[2] = { 0, 0 };
533 struct i2c_msg msg[2] = {
534 { .addr = priv->i2c_props.addr,
535 .flags = 0, .buf = &buf[0], .len = 2 },
536 { .addr = priv->i2c_props.addr,
537 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
540 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
541 printk(KERN_WARNING "xc5000: I2C read failed\n");
545 *val = (bval[0] << 8) | bval[1];
546 return XC_RESULT_SUCCESS;
549 static int xc5000_fwupload(struct dvb_frontend *fe)
551 struct xc5000_priv *priv = fe->tuner_priv;
552 const struct firmware *fw;
555 /* request the firmware, this will block and timeout */
556 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
557 XC5000_DEFAULT_FIRMWARE);
559 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
560 priv->i2c_props.adap->dev.parent);
562 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
563 ret = XC_RESULT_RESET_FAILURE;
566 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
568 ret = XC_RESULT_SUCCESS;
571 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
572 printk(KERN_ERR "xc5000: firmware incorrect size\n");
573 ret = XC_RESULT_RESET_FAILURE;
575 printk(KERN_INFO "xc5000: firmware uploading...\n");
576 ret = xc_load_i2c_sequence(fe, fw->data);
577 printk(KERN_INFO "xc5000: firmware upload complete...\n");
581 release_firmware(fw);
585 static void xc_debug_dump(struct xc5000_priv *priv)
588 u32 freq_error_hz = 0;
590 u32 hsync_freq_hz = 0;
593 u8 hw_majorversion = 0, hw_minorversion = 0;
594 u8 fw_majorversion = 0, fw_minorversion = 0;
595 u16 fw_buildversion = 0;
597 /* Wait for stats to stabilize.
598 * Frame Lines needs two frame times after initial lock
599 * before it is valid.
603 xc_get_ADC_Envelope(priv, &adc_envelope);
604 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
606 xc_get_frequency_error(priv, &freq_error_hz);
607 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
609 xc_get_lock_status(priv, &lock_status);
610 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
613 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
614 &fw_majorversion, &fw_minorversion);
615 xc_get_buildversion(priv, &fw_buildversion);
616 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
617 hw_majorversion, hw_minorversion,
618 fw_majorversion, fw_minorversion, fw_buildversion);
620 xc_get_hsync_freq(priv, &hsync_freq_hz);
621 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
623 xc_get_frame_lines(priv, &frame_lines);
624 dprintk(1, "*** Frame lines = %d\n", frame_lines);
626 xc_get_quality(priv, &quality);
627 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
630 static int xc5000_set_params(struct dvb_frontend *fe,
631 struct dvb_frontend_parameters *params)
633 struct xc5000_priv *priv = fe->tuner_priv;
636 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
637 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
638 dprintk(1, "Unable to load firmware and init tuner\n");
643 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
645 if (fe->ops.info.type == FE_ATSC) {
646 dprintk(1, "%s() ATSC\n", __func__);
647 switch (params->u.vsb.modulation) {
650 dprintk(1, "%s() VSB modulation\n", __func__);
651 priv->rf_mode = XC_RF_MODE_AIR;
652 priv->freq_hz = params->frequency - 1750000;
653 priv->bandwidth = BANDWIDTH_6_MHZ;
654 priv->video_standard = DTV6;
659 dprintk(1, "%s() QAM modulation\n", __func__);
660 priv->rf_mode = XC_RF_MODE_CABLE;
661 priv->freq_hz = params->frequency - 1750000;
662 priv->bandwidth = BANDWIDTH_6_MHZ;
663 priv->video_standard = DTV6;
668 } else if (fe->ops.info.type == FE_OFDM) {
669 dprintk(1, "%s() OFDM\n", __func__);
670 switch (params->u.ofdm.bandwidth) {
671 case BANDWIDTH_6_MHZ:
672 priv->bandwidth = BANDWIDTH_6_MHZ;
673 priv->video_standard = DTV6;
674 priv->freq_hz = params->frequency - 1750000;
676 case BANDWIDTH_7_MHZ:
677 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
679 case BANDWIDTH_8_MHZ:
680 priv->bandwidth = BANDWIDTH_8_MHZ;
681 priv->video_standard = DTV8;
682 priv->freq_hz = params->frequency - 2750000;
685 printk(KERN_ERR "xc5000 bandwidth not set!\n");
688 priv->rf_mode = XC_RF_MODE_AIR;
690 printk(KERN_ERR "xc5000 modulation type not supported!\n");
694 dprintk(1, "%s() frequency=%d (compensated)\n",
695 __func__, priv->freq_hz);
697 ret = xc_SetSignalSource(priv, priv->rf_mode);
698 if (ret != XC_RESULT_SUCCESS) {
700 "xc5000: xc_SetSignalSource(%d) failed\n",
705 ret = xc_SetTVStandard(priv,
706 XC5000_Standard[priv->video_standard].VideoMode,
707 XC5000_Standard[priv->video_standard].AudioMode);
708 if (ret != XC_RESULT_SUCCESS) {
709 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
713 ret = xc_set_IF_frequency(priv, priv->if_khz);
714 if (ret != XC_RESULT_SUCCESS) {
715 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
720 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
728 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
730 struct xc5000_priv *priv = fe->tuner_priv;
734 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
735 if (ret == XC_RESULT_SUCCESS) {
736 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
737 ret = XC_RESULT_RESET_FAILURE;
739 ret = XC_RESULT_SUCCESS;
742 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
743 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
747 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
748 struct analog_parameters *params)
750 struct xc5000_priv *priv = fe->tuner_priv;
753 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
754 __func__, params->frequency);
756 /* Fix me: it could be air. */
757 priv->rf_mode = params->mode;
758 if (params->mode > XC_RF_MODE_CABLE)
759 priv->rf_mode = XC_RF_MODE_CABLE;
761 /* params->frequency is in units of 62.5khz */
762 priv->freq_hz = params->frequency * 62500;
764 /* FIX ME: Some video standards may have several possible audio
765 standards. We simply default to one of them here.
767 if (params->std & V4L2_STD_MN) {
768 /* default to BTSC audio standard */
769 priv->video_standard = MN_NTSC_PAL_BTSC;
773 if (params->std & V4L2_STD_PAL_BG) {
774 /* default to NICAM audio standard */
775 priv->video_standard = BG_PAL_NICAM;
779 if (params->std & V4L2_STD_PAL_I) {
780 /* default to NICAM audio standard */
781 priv->video_standard = I_PAL_NICAM;
785 if (params->std & V4L2_STD_PAL_DK) {
786 /* default to NICAM audio standard */
787 priv->video_standard = DK_PAL_NICAM;
791 if (params->std & V4L2_STD_SECAM_DK) {
792 /* default to A2 DK1 audio standard */
793 priv->video_standard = DK_SECAM_A2DK1;
797 if (params->std & V4L2_STD_SECAM_L) {
798 priv->video_standard = L_SECAM_NICAM;
802 if (params->std & V4L2_STD_SECAM_LC) {
803 priv->video_standard = LC_SECAM_NICAM;
808 ret = xc_SetSignalSource(priv, priv->rf_mode);
809 if (ret != XC_RESULT_SUCCESS) {
811 "xc5000: xc_SetSignalSource(%d) failed\n",
816 ret = xc_SetTVStandard(priv,
817 XC5000_Standard[priv->video_standard].VideoMode,
818 XC5000_Standard[priv->video_standard].AudioMode);
819 if (ret != XC_RESULT_SUCCESS) {
820 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
824 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
832 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
833 struct analog_parameters *params)
835 struct xc5000_priv *priv = fe->tuner_priv;
839 dprintk(1, "%s() frequency=%d (in units of khz)\n",
840 __func__, params->frequency);
842 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
843 dprintk(1, "%s() radio input not configured\n", __func__);
847 if (priv->radio_input == XC5000_RADIO_FM1)
848 radio_input = FM_Radio_INPUT1;
849 else if (priv->radio_input == XC5000_RADIO_FM2)
850 radio_input = FM_Radio_INPUT2;
852 dprintk(1, "%s() unknown radio input %d\n", __func__,
857 priv->freq_hz = params->frequency * 125 / 2;
859 priv->rf_mode = XC_RF_MODE_AIR;
861 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
862 XC5000_Standard[radio_input].AudioMode);
864 if (ret != XC_RESULT_SUCCESS) {
865 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
869 ret = xc_SetSignalSource(priv, priv->rf_mode);
870 if (ret != XC_RESULT_SUCCESS) {
872 "xc5000: xc_SetSignalSource(%d) failed\n",
877 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
882 static int xc5000_set_analog_params(struct dvb_frontend *fe,
883 struct analog_parameters *params)
885 struct xc5000_priv *priv = fe->tuner_priv;
888 if (priv->i2c_props.adap == NULL)
891 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
892 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
893 dprintk(1, "Unable to load firmware and init tuner\n");
898 switch (params->mode) {
899 case V4L2_TUNER_RADIO:
900 ret = xc5000_set_radio_freq(fe, params);
902 case V4L2_TUNER_ANALOG_TV:
903 case V4L2_TUNER_DIGITAL_TV:
904 ret = xc5000_set_tv_freq(fe, params);
912 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
914 struct xc5000_priv *priv = fe->tuner_priv;
915 dprintk(1, "%s()\n", __func__);
916 *freq = priv->freq_hz;
920 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
922 struct xc5000_priv *priv = fe->tuner_priv;
923 dprintk(1, "%s()\n", __func__);
925 *bw = priv->bandwidth;
929 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
931 struct xc5000_priv *priv = fe->tuner_priv;
934 xc_get_lock_status(priv, &lock_status);
936 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
938 *status = lock_status;
943 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
945 struct xc5000_priv *priv = fe->tuner_priv;
948 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
949 ret = xc5000_fwupload(fe);
950 if (ret != XC_RESULT_SUCCESS)
954 /* Start the tuner self-calibration process */
955 ret |= xc_initialize(priv);
957 /* Wait for calibration to complete.
958 * We could continue but XC5000 will clock stretch subsequent
959 * I2C transactions until calibration is complete. This way we
960 * don't have to rely on clock stretching working.
964 /* Default to "CABLE" mode */
965 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
970 static int xc5000_sleep(struct dvb_frontend *fe)
974 dprintk(1, "%s()\n", __func__);
976 /* Avoid firmware reload on slow devices */
980 /* According to Xceive technical support, the "powerdown" register
981 was removed in newer versions of the firmware. The "supported"
982 way to sleep the tuner is to pull the reset pin low for 10ms */
983 ret = xc5000_TunerReset(fe);
984 if (ret != XC_RESULT_SUCCESS) {
986 "xc5000: %s() unable to shutdown tuner\n",
990 return XC_RESULT_SUCCESS;
993 static int xc5000_init(struct dvb_frontend *fe)
995 struct xc5000_priv *priv = fe->tuner_priv;
996 dprintk(1, "%s()\n", __func__);
998 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
999 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1004 xc_debug_dump(priv);
1009 static int xc5000_release(struct dvb_frontend *fe)
1011 struct xc5000_priv *priv = fe->tuner_priv;
1013 dprintk(1, "%s()\n", __func__);
1015 mutex_lock(&xc5000_list_mutex);
1018 hybrid_tuner_release_state(priv);
1020 mutex_unlock(&xc5000_list_mutex);
1022 fe->tuner_priv = NULL;
1027 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1029 .name = "Xceive XC5000",
1030 .frequency_min = 1000000,
1031 .frequency_max = 1023000000,
1032 .frequency_step = 50000,
1035 .release = xc5000_release,
1036 .init = xc5000_init,
1037 .sleep = xc5000_sleep,
1039 .set_params = xc5000_set_params,
1040 .set_analog_params = xc5000_set_analog_params,
1041 .get_frequency = xc5000_get_frequency,
1042 .get_bandwidth = xc5000_get_bandwidth,
1043 .get_status = xc5000_get_status
1046 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1047 struct i2c_adapter *i2c,
1048 struct xc5000_config *cfg)
1050 struct xc5000_priv *priv = NULL;
1054 dprintk(1, "%s(%d-%04x)\n", __func__,
1055 i2c ? i2c_adapter_id(i2c) : -1,
1056 cfg ? cfg->i2c_address : -1);
1058 mutex_lock(&xc5000_list_mutex);
1060 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1061 hybrid_tuner_instance_list,
1062 i2c, cfg->i2c_address, "xc5000");
1068 /* new tuner instance */
1069 priv->bandwidth = BANDWIDTH_6_MHZ;
1070 fe->tuner_priv = priv;
1073 /* existing tuner instance */
1074 fe->tuner_priv = priv;
1078 if (priv->if_khz == 0) {
1079 /* If the IF hasn't been set yet, use the value provided by
1080 the caller (occurs in hybrid devices where the analog
1081 call to xc5000_attach occurs before the digital side) */
1082 priv->if_khz = cfg->if_khz;
1085 if (priv->radio_input == 0)
1086 priv->radio_input = cfg->radio_input;
1088 /* Check if firmware has been loaded. It is possible that another
1089 instance of the driver has loaded the firmware.
1091 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1095 case XC_PRODUCT_ID_FW_LOADED:
1097 "xc5000: Successfully identified at address 0x%02x\n",
1100 "xc5000: Firmware has been loaded previously\n");
1102 case XC_PRODUCT_ID_FW_NOT_LOADED:
1104 "xc5000: Successfully identified at address 0x%02x\n",
1107 "xc5000: Firmware has not been loaded previously\n");
1111 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1112 cfg->i2c_address, id);
1116 mutex_unlock(&xc5000_list_mutex);
1118 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1119 sizeof(struct dvb_tuner_ops));
1123 mutex_unlock(&xc5000_list_mutex);
1128 EXPORT_SYMBOL(xc5000_attach);
1130 MODULE_AUTHOR("Steven Toth");
1131 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1132 MODULE_LICENSE("GPL");