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;
67 #define MAX_TV_STANDARD 24
68 #define XC_MAX_I2C_WRITE_LENGTH 64
71 #define XC_RF_MODE_AIR 0
72 #define XC_RF_MODE_CABLE 1
75 #define XC_RESULT_SUCCESS 0
76 #define XC_RESULT_RESET_FAILURE 1
77 #define XC_RESULT_I2C_WRITE_FAILURE 2
78 #define XC_RESULT_I2C_READ_FAILURE 3
79 #define XC_RESULT_OUT_OF_RANGE 5
82 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
83 #define XC_PRODUCT_ID_FW_LOADED 0x1388
86 #define XREG_INIT 0x00
87 #define XREG_VIDEO_MODE 0x01
88 #define XREG_AUDIO_MODE 0x02
89 #define XREG_RF_FREQ 0x03
90 #define XREG_D_CODE 0x04
91 #define XREG_IF_OUT 0x05
92 #define XREG_SEEK_MODE 0x07
93 #define XREG_POWER_DOWN 0x0A /* Obsolete */
94 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
95 #define XREG_OUTPUT_AMP 0x0B
96 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
97 #define XREG_SMOOTHEDCVBS 0x0E
98 #define XREG_XTALFREQ 0x0F
99 #define XREG_FINERFREQ 0x10
100 #define XREG_DDIMODE 0x11
102 #define XREG_ADC_ENV 0x00
103 #define XREG_QUALITY 0x01
104 #define XREG_FRAME_LINES 0x02
105 #define XREG_HSYNC_FREQ 0x03
106 #define XREG_LOCK 0x04
107 #define XREG_FREQ_ERROR 0x05
108 #define XREG_SNR 0x06
109 #define XREG_VERSION 0x07
110 #define XREG_PRODUCT_ID 0x08
111 #define XREG_BUSY 0x09
112 #define XREG_BUILD 0x0D
115 Basic firmware description. This will remain with
116 the driver for documentation purposes.
118 This represents an I2C firmware file encoded as a
119 string of unsigned char. Format is as follows:
121 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
122 char[1 ]=len0_LSB -> length of first write transaction
123 char[2 ]=data0 -> first byte to be sent
127 char[M ]=dataN -> last byte to be sent
128 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
129 char[M+2]=len1_LSB -> length of second write transaction
135 The [len] value should be interpreted as follows:
137 len= len_MSB _ len_LSB
138 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
139 len=0000_0000_0000_0000 : Reset command: Do hardware reset
140 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
141 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
143 For the RESET and WAIT commands, the two following bytes will contain
144 immediately the length of the following transaction.
147 struct XC_TV_STANDARD {
153 /* Tuner standards */
154 #define MN_NTSC_PAL_BTSC 0
155 #define MN_NTSC_PAL_A2 1
156 #define MN_NTSC_PAL_EIAJ 2
157 #define MN_NTSC_PAL_Mono 3
159 #define BG_PAL_NICAM 5
160 #define BG_PAL_MONO 6
161 #define I_PAL_NICAM 7
162 #define I_PAL_NICAM_MONO 8
164 #define DK_PAL_NICAM 10
165 #define DK_PAL_MONO 11
166 #define DK_SECAM_A2DK1 12
167 #define DK_SECAM_A2LDK3 13
168 #define DK_SECAM_A2MONO 14
169 #define L_SECAM_NICAM 15
170 #define LC_SECAM_NICAM 16
175 #define FM_Radio_INPUT2 21
176 #define FM_Radio_INPUT1 22
177 #define FM_Radio_INPUT1_MONO 23
179 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
180 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
181 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
182 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
183 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
184 {"B/G-PAL-A2", 0x0A00, 0x8049},
185 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
186 {"B/G-PAL-MONO", 0x0878, 0x8059},
187 {"I-PAL-NICAM", 0x1080, 0x8009},
188 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
189 {"D/K-PAL-A2", 0x1600, 0x8009},
190 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
191 {"D/K-PAL-MONO", 0x1478, 0x8009},
192 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
193 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
194 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
195 {"L-SECAM-NICAM", 0x8E82, 0x0009},
196 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
197 {"DTV6", 0x00C0, 0x8002},
198 {"DTV8", 0x00C0, 0x800B},
199 {"DTV7/8", 0x00C0, 0x801B},
200 {"DTV7", 0x00C0, 0x8007},
201 {"FM Radio-INPUT2", 0x9802, 0x9002},
202 {"FM Radio-INPUT1", 0x0208, 0x9002},
203 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
207 struct xc5000_fw_cfg {
212 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
213 .name = "dvb-fe-xc5000-1.6.114.fw",
217 static const struct xc5000_fw_cfg xc5000c_41_024_5_31875 = {
218 .name = "dvb-fe-xc5000c-41.024.5-31875.fw",
222 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
227 return &xc5000a_1_6_114;
229 return &xc5000c_41_024_5_31875;
233 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
234 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
235 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
236 static int xc5000_TunerReset(struct dvb_frontend *fe);
238 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
240 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
241 .flags = 0, .buf = buf, .len = len };
243 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
244 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
245 return XC_RESULT_I2C_WRITE_FAILURE;
247 return XC_RESULT_SUCCESS;
251 /* This routine is never used because the only time we read data from the
252 i2c bus is when we read registers, and we want that to be an atomic i2c
253 transaction in case we are on a multi-master bus */
254 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
256 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
257 .flags = I2C_M_RD, .buf = buf, .len = len };
259 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
260 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
267 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
269 u8 buf[2] = { reg >> 8, reg & 0xff };
270 u8 bval[2] = { 0, 0 };
271 struct i2c_msg msg[2] = {
272 { .addr = priv->i2c_props.addr,
273 .flags = 0, .buf = &buf[0], .len = 2 },
274 { .addr = priv->i2c_props.addr,
275 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
278 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
279 printk(KERN_WARNING "xc5000: I2C read failed\n");
283 *val = (bval[0] << 8) | bval[1];
284 return XC_RESULT_SUCCESS;
287 static void xc_wait(int wait_ms)
292 static int xc5000_TunerReset(struct dvb_frontend *fe)
294 struct xc5000_priv *priv = fe->tuner_priv;
297 dprintk(1, "%s()\n", __func__);
300 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
302 priv->i2c_props.adap->algo_data,
303 DVB_FRONTEND_COMPONENT_TUNER,
304 XC5000_TUNER_RESET, 0);
306 printk(KERN_ERR "xc5000: reset failed\n");
307 return XC_RESULT_RESET_FAILURE;
310 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
311 return XC_RESULT_RESET_FAILURE;
313 return XC_RESULT_SUCCESS;
316 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
319 int WatchDogTimer = 100;
322 buf[0] = (regAddr >> 8) & 0xFF;
323 buf[1] = regAddr & 0xFF;
324 buf[2] = (i2cData >> 8) & 0xFF;
325 buf[3] = i2cData & 0xFF;
326 result = xc_send_i2c_data(priv, buf, 4);
327 if (result == XC_RESULT_SUCCESS) {
328 /* wait for busy flag to clear */
329 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
330 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
331 if (result == XC_RESULT_SUCCESS) {
332 if ((buf[0] == 0) && (buf[1] == 0)) {
333 /* busy flag cleared */
336 xc_wait(5); /* wait 5 ms */
342 if (WatchDogTimer < 0)
343 result = XC_RESULT_I2C_WRITE_FAILURE;
348 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
350 struct xc5000_priv *priv = fe->tuner_priv;
352 int i, nbytes_to_send, result;
353 unsigned int len, pos, index;
354 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
357 while ((i2c_sequence[index] != 0xFF) ||
358 (i2c_sequence[index + 1] != 0xFF)) {
359 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
362 result = xc5000_TunerReset(fe);
364 if (result != XC_RESULT_SUCCESS)
366 } else if (len & 0x8000) {
368 xc_wait(len & 0x7FFF);
371 /* Send i2c data whilst ensuring individual transactions
372 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
375 buf[0] = i2c_sequence[index];
376 buf[1] = i2c_sequence[index + 1];
379 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
381 XC_MAX_I2C_WRITE_LENGTH;
383 nbytes_to_send = (len - pos + 2);
384 for (i = 2; i < nbytes_to_send; i++) {
385 buf[i] = i2c_sequence[index + pos +
388 result = xc_send_i2c_data(priv, buf,
391 if (result != XC_RESULT_SUCCESS)
394 pos += nbytes_to_send - 2;
399 return XC_RESULT_SUCCESS;
402 static int xc_initialize(struct xc5000_priv *priv)
404 dprintk(1, "%s()\n", __func__);
405 return xc_write_reg(priv, XREG_INIT, 0);
408 static int xc_SetTVStandard(struct xc5000_priv *priv,
409 u16 VideoMode, u16 AudioMode)
412 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
413 dprintk(1, "%s() Standard = %s\n",
415 XC5000_Standard[priv->video_standard].Name);
417 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
418 if (ret == XC_RESULT_SUCCESS)
419 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
424 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
426 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
427 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
429 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
430 rf_mode = XC_RF_MODE_CABLE;
432 "%s(), Invalid mode, defaulting to CABLE",
435 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
438 static const struct dvb_tuner_ops xc5000_tuner_ops;
440 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
444 dprintk(1, "%s(%u)\n", __func__, freq_hz);
446 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
447 (freq_hz < xc5000_tuner_ops.info.frequency_min))
448 return XC_RESULT_OUT_OF_RANGE;
450 freq_code = (u16)(freq_hz / 15625);
452 /* Starting in firmware version 1.1.44, Xceive recommends using the
453 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
454 only be used for fast scanning for channel lock) */
455 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
459 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
461 u32 freq_code = (freq_khz * 1024)/1000;
462 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
463 __func__, freq_khz, freq_code);
465 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
469 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
471 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
474 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
480 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
481 if (result != XC_RESULT_SUCCESS)
485 (*freq_error_hz) = (tmp * 15625) / 1000;
489 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
491 return xc5000_readreg(priv, XREG_LOCK, lock_status);
494 static int xc_get_version(struct xc5000_priv *priv,
495 u8 *hw_majorversion, u8 *hw_minorversion,
496 u8 *fw_majorversion, u8 *fw_minorversion)
501 result = xc5000_readreg(priv, XREG_VERSION, &data);
502 if (result != XC_RESULT_SUCCESS)
505 (*hw_majorversion) = (data >> 12) & 0x0F;
506 (*hw_minorversion) = (data >> 8) & 0x0F;
507 (*fw_majorversion) = (data >> 4) & 0x0F;
508 (*fw_minorversion) = data & 0x0F;
513 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
515 return xc5000_readreg(priv, XREG_BUILD, buildrev);
518 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
523 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
524 if (result != XC_RESULT_SUCCESS)
527 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
531 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
533 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
536 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
538 return xc5000_readreg(priv, XREG_QUALITY, quality);
541 static u16 WaitForLock(struct xc5000_priv *priv)
544 int watchDogCount = 40;
546 while ((lockState == 0) && (watchDogCount > 0)) {
547 xc_get_lock_status(priv, &lockState);
548 if (lockState != 1) {
556 #define XC_TUNE_ANALOG 0
557 #define XC_TUNE_DIGITAL 1
558 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
562 dprintk(1, "%s(%u)\n", __func__, freq_hz);
564 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
567 if (mode == XC_TUNE_ANALOG) {
568 if (WaitForLock(priv) == 1)
576 static int xc5000_fwupload(struct dvb_frontend *fe)
578 struct xc5000_priv *priv = fe->tuner_priv;
579 const struct firmware *fw;
581 const struct xc5000_fw_cfg *desired_fw =
582 xc5000_assign_firmware(priv->chip_id);
584 /* request the firmware, this will block and timeout */
585 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
588 ret = request_firmware(&fw, desired_fw->name,
589 priv->i2c_props.adap->dev.parent);
591 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
592 ret = XC_RESULT_RESET_FAILURE;
595 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
597 ret = XC_RESULT_SUCCESS;
600 if (fw->size != desired_fw->size) {
601 printk(KERN_ERR "xc5000: firmware incorrect size\n");
602 ret = XC_RESULT_RESET_FAILURE;
604 printk(KERN_INFO "xc5000: firmware uploading...\n");
605 ret = xc_load_i2c_sequence(fe, fw->data);
606 printk(KERN_INFO "xc5000: firmware upload complete...\n");
610 release_firmware(fw);
614 static void xc_debug_dump(struct xc5000_priv *priv)
617 u32 freq_error_hz = 0;
619 u32 hsync_freq_hz = 0;
622 u8 hw_majorversion = 0, hw_minorversion = 0;
623 u8 fw_majorversion = 0, fw_minorversion = 0;
624 u16 fw_buildversion = 0;
626 /* Wait for stats to stabilize.
627 * Frame Lines needs two frame times after initial lock
628 * before it is valid.
632 xc_get_ADC_Envelope(priv, &adc_envelope);
633 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
635 xc_get_frequency_error(priv, &freq_error_hz);
636 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
638 xc_get_lock_status(priv, &lock_status);
639 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
642 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
643 &fw_majorversion, &fw_minorversion);
644 xc_get_buildversion(priv, &fw_buildversion);
645 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
646 hw_majorversion, hw_minorversion,
647 fw_majorversion, fw_minorversion, fw_buildversion);
649 xc_get_hsync_freq(priv, &hsync_freq_hz);
650 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
652 xc_get_frame_lines(priv, &frame_lines);
653 dprintk(1, "*** Frame lines = %d\n", frame_lines);
655 xc_get_quality(priv, &quality);
656 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
659 static int xc5000_set_params(struct dvb_frontend *fe)
662 struct xc5000_priv *priv = fe->tuner_priv;
663 u32 bw = fe->dtv_property_cache.bandwidth_hz;
664 u32 freq = fe->dtv_property_cache.frequency;
665 u32 delsys = fe->dtv_property_cache.delivery_system;
667 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
668 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
669 dprintk(1, "Unable to load firmware and init tuner\n");
674 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
678 dprintk(1, "%s() VSB modulation\n", __func__);
679 priv->rf_mode = XC_RF_MODE_AIR;
680 priv->freq_hz = freq - 1750000;
681 priv->video_standard = DTV6;
683 case SYS_DVBC_ANNEX_B:
684 dprintk(1, "%s() QAM modulation\n", __func__);
685 priv->rf_mode = XC_RF_MODE_CABLE;
686 priv->freq_hz = freq - 1750000;
687 priv->video_standard = DTV6;
691 dprintk(1, "%s() OFDM\n", __func__);
694 priv->video_standard = DTV6;
695 priv->freq_hz = freq - 1750000;
698 priv->video_standard = DTV7;
699 priv->freq_hz = freq - 2250000;
702 priv->video_standard = DTV8;
703 priv->freq_hz = freq - 2750000;
706 printk(KERN_ERR "xc5000 bandwidth not set!\n");
709 priv->rf_mode = XC_RF_MODE_AIR;
710 case SYS_DVBC_ANNEX_A:
711 case SYS_DVBC_ANNEX_C:
712 dprintk(1, "%s() QAM modulation\n", __func__);
713 priv->rf_mode = XC_RF_MODE_CABLE;
715 priv->video_standard = DTV6;
716 priv->freq_hz = freq - 1750000;
718 } else if (bw <= 7000000) {
719 priv->video_standard = DTV7;
720 priv->freq_hz = freq - 2250000;
723 priv->video_standard = DTV7_8;
724 priv->freq_hz = freq - 2750000;
727 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
731 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
735 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
736 __func__, freq, priv->freq_hz);
738 ret = xc_SetSignalSource(priv, priv->rf_mode);
739 if (ret != XC_RESULT_SUCCESS) {
741 "xc5000: xc_SetSignalSource(%d) failed\n",
746 ret = xc_SetTVStandard(priv,
747 XC5000_Standard[priv->video_standard].VideoMode,
748 XC5000_Standard[priv->video_standard].AudioMode);
749 if (ret != XC_RESULT_SUCCESS) {
750 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
754 ret = xc_set_IF_frequency(priv, priv->if_khz);
755 if (ret != XC_RESULT_SUCCESS) {
756 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
761 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
763 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
768 priv->bandwidth = bw;
773 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
775 struct xc5000_priv *priv = fe->tuner_priv;
779 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
780 if (ret == XC_RESULT_SUCCESS) {
781 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
782 ret = XC_RESULT_RESET_FAILURE;
784 ret = XC_RESULT_SUCCESS;
787 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
788 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
792 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
793 struct analog_parameters *params)
795 struct xc5000_priv *priv = fe->tuner_priv;
798 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
799 __func__, params->frequency);
801 /* Fix me: it could be air. */
802 priv->rf_mode = params->mode;
803 if (params->mode > XC_RF_MODE_CABLE)
804 priv->rf_mode = XC_RF_MODE_CABLE;
806 /* params->frequency is in units of 62.5khz */
807 priv->freq_hz = params->frequency * 62500;
809 /* FIX ME: Some video standards may have several possible audio
810 standards. We simply default to one of them here.
812 if (params->std & V4L2_STD_MN) {
813 /* default to BTSC audio standard */
814 priv->video_standard = MN_NTSC_PAL_BTSC;
818 if (params->std & V4L2_STD_PAL_BG) {
819 /* default to NICAM audio standard */
820 priv->video_standard = BG_PAL_NICAM;
824 if (params->std & V4L2_STD_PAL_I) {
825 /* default to NICAM audio standard */
826 priv->video_standard = I_PAL_NICAM;
830 if (params->std & V4L2_STD_PAL_DK) {
831 /* default to NICAM audio standard */
832 priv->video_standard = DK_PAL_NICAM;
836 if (params->std & V4L2_STD_SECAM_DK) {
837 /* default to A2 DK1 audio standard */
838 priv->video_standard = DK_SECAM_A2DK1;
842 if (params->std & V4L2_STD_SECAM_L) {
843 priv->video_standard = L_SECAM_NICAM;
847 if (params->std & V4L2_STD_SECAM_LC) {
848 priv->video_standard = LC_SECAM_NICAM;
853 ret = xc_SetSignalSource(priv, priv->rf_mode);
854 if (ret != XC_RESULT_SUCCESS) {
856 "xc5000: xc_SetSignalSource(%d) failed\n",
861 ret = xc_SetTVStandard(priv,
862 XC5000_Standard[priv->video_standard].VideoMode,
863 XC5000_Standard[priv->video_standard].AudioMode);
864 if (ret != XC_RESULT_SUCCESS) {
865 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
869 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
871 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
879 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
880 struct analog_parameters *params)
882 struct xc5000_priv *priv = fe->tuner_priv;
886 dprintk(1, "%s() frequency=%d (in units of khz)\n",
887 __func__, params->frequency);
889 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
890 dprintk(1, "%s() radio input not configured\n", __func__);
894 if (priv->radio_input == XC5000_RADIO_FM1)
895 radio_input = FM_Radio_INPUT1;
896 else if (priv->radio_input == XC5000_RADIO_FM2)
897 radio_input = FM_Radio_INPUT2;
898 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
899 radio_input = FM_Radio_INPUT1_MONO;
901 dprintk(1, "%s() unknown radio input %d\n", __func__,
906 priv->freq_hz = params->frequency * 125 / 2;
908 priv->rf_mode = XC_RF_MODE_AIR;
910 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
911 XC5000_Standard[radio_input].AudioMode);
913 if (ret != XC_RESULT_SUCCESS) {
914 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
918 ret = xc_SetSignalSource(priv, priv->rf_mode);
919 if (ret != XC_RESULT_SUCCESS) {
921 "xc5000: xc_SetSignalSource(%d) failed\n",
926 if ((priv->radio_input == XC5000_RADIO_FM1) ||
927 (priv->radio_input == XC5000_RADIO_FM2))
928 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
929 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
930 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
932 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
937 static int xc5000_set_analog_params(struct dvb_frontend *fe,
938 struct analog_parameters *params)
940 struct xc5000_priv *priv = fe->tuner_priv;
943 if (priv->i2c_props.adap == NULL)
946 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
947 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
948 dprintk(1, "Unable to load firmware and init tuner\n");
953 switch (params->mode) {
954 case V4L2_TUNER_RADIO:
955 ret = xc5000_set_radio_freq(fe, params);
957 case V4L2_TUNER_ANALOG_TV:
958 case V4L2_TUNER_DIGITAL_TV:
959 ret = xc5000_set_tv_freq(fe, params);
967 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
969 struct xc5000_priv *priv = fe->tuner_priv;
970 dprintk(1, "%s()\n", __func__);
971 *freq = priv->freq_hz;
975 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
977 struct xc5000_priv *priv = fe->tuner_priv;
978 dprintk(1, "%s()\n", __func__);
979 *freq = priv->if_khz * 1000;
983 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
985 struct xc5000_priv *priv = fe->tuner_priv;
986 dprintk(1, "%s()\n", __func__);
988 *bw = priv->bandwidth;
992 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
994 struct xc5000_priv *priv = fe->tuner_priv;
997 xc_get_lock_status(priv, &lock_status);
999 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1001 *status = lock_status;
1006 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
1008 struct xc5000_priv *priv = fe->tuner_priv;
1011 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1012 ret = xc5000_fwupload(fe);
1013 if (ret != XC_RESULT_SUCCESS)
1017 /* Start the tuner self-calibration process */
1018 ret |= xc_initialize(priv);
1020 /* Wait for calibration to complete.
1021 * We could continue but XC5000 will clock stretch subsequent
1022 * I2C transactions until calibration is complete. This way we
1023 * don't have to rely on clock stretching working.
1027 /* Default to "CABLE" mode */
1028 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1033 static int xc5000_sleep(struct dvb_frontend *fe)
1037 dprintk(1, "%s()\n", __func__);
1039 /* Avoid firmware reload on slow devices */
1043 /* According to Xceive technical support, the "powerdown" register
1044 was removed in newer versions of the firmware. The "supported"
1045 way to sleep the tuner is to pull the reset pin low for 10ms */
1046 ret = xc5000_TunerReset(fe);
1047 if (ret != XC_RESULT_SUCCESS) {
1049 "xc5000: %s() unable to shutdown tuner\n",
1053 return XC_RESULT_SUCCESS;
1056 static int xc5000_init(struct dvb_frontend *fe)
1058 struct xc5000_priv *priv = fe->tuner_priv;
1059 dprintk(1, "%s()\n", __func__);
1061 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1062 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1067 xc_debug_dump(priv);
1072 static int xc5000_release(struct dvb_frontend *fe)
1074 struct xc5000_priv *priv = fe->tuner_priv;
1076 dprintk(1, "%s()\n", __func__);
1078 mutex_lock(&xc5000_list_mutex);
1081 hybrid_tuner_release_state(priv);
1083 mutex_unlock(&xc5000_list_mutex);
1085 fe->tuner_priv = NULL;
1090 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1092 struct xc5000_priv *priv = fe->tuner_priv;
1093 struct xc5000_config *p = priv_cfg;
1095 dprintk(1, "%s()\n", __func__);
1098 priv->if_khz = p->if_khz;
1101 priv->radio_input = p->radio_input;
1107 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1109 .name = "Xceive XC5000",
1110 .frequency_min = 1000000,
1111 .frequency_max = 1023000000,
1112 .frequency_step = 50000,
1115 .release = xc5000_release,
1116 .init = xc5000_init,
1117 .sleep = xc5000_sleep,
1119 .set_config = xc5000_set_config,
1120 .set_params = xc5000_set_params,
1121 .set_analog_params = xc5000_set_analog_params,
1122 .get_frequency = xc5000_get_frequency,
1123 .get_if_frequency = xc5000_get_if_frequency,
1124 .get_bandwidth = xc5000_get_bandwidth,
1125 .get_status = xc5000_get_status
1128 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1129 struct i2c_adapter *i2c,
1130 const struct xc5000_config *cfg)
1132 struct xc5000_priv *priv = NULL;
1136 dprintk(1, "%s(%d-%04x)\n", __func__,
1137 i2c ? i2c_adapter_id(i2c) : -1,
1138 cfg ? cfg->i2c_address : -1);
1140 mutex_lock(&xc5000_list_mutex);
1142 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1143 hybrid_tuner_instance_list,
1144 i2c, cfg->i2c_address, "xc5000");
1150 /* new tuner instance */
1151 priv->bandwidth = 6000000;
1152 fe->tuner_priv = priv;
1155 /* existing tuner instance */
1156 fe->tuner_priv = priv;
1160 if (priv->if_khz == 0) {
1161 /* If the IF hasn't been set yet, use the value provided by
1162 the caller (occurs in hybrid devices where the analog
1163 call to xc5000_attach occurs before the digital side) */
1164 priv->if_khz = cfg->if_khz;
1167 if (priv->radio_input == 0)
1168 priv->radio_input = cfg->radio_input;
1170 /* don't override chip id if it's already been set
1171 unless explicitly specified */
1172 if ((priv->chip_id == 0) || (cfg->chip_id))
1173 /* use default chip id if none specified, set to 0 so
1174 it can be overridden if this is a hybrid driver */
1175 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1177 /* Check if firmware has been loaded. It is possible that another
1178 instance of the driver has loaded the firmware.
1180 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1184 case XC_PRODUCT_ID_FW_LOADED:
1186 "xc5000: Successfully identified at address 0x%02x\n",
1189 "xc5000: Firmware has been loaded previously\n");
1191 case XC_PRODUCT_ID_FW_NOT_LOADED:
1193 "xc5000: Successfully identified at address 0x%02x\n",
1196 "xc5000: Firmware has not been loaded previously\n");
1200 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1201 cfg->i2c_address, id);
1205 mutex_unlock(&xc5000_list_mutex);
1207 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1208 sizeof(struct dvb_tuner_ops));
1212 mutex_unlock(&xc5000_list_mutex);
1217 EXPORT_SYMBOL(xc5000_attach);
1219 MODULE_AUTHOR("Steven Toth");
1220 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1221 MODULE_LICENSE("GPL");