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;
67 #define MAX_TV_STANDARD 23
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 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
95 #define XREG_SMOOTHEDCVBS 0x0E
96 #define XREG_XTALFREQ 0x0F
97 #define XREG_FINERFREQ 0x10
98 #define XREG_DDIMODE 0x11
100 #define XREG_ADC_ENV 0x00
101 #define XREG_QUALITY 0x01
102 #define XREG_FRAME_LINES 0x02
103 #define XREG_HSYNC_FREQ 0x03
104 #define XREG_LOCK 0x04
105 #define XREG_FREQ_ERROR 0x05
106 #define XREG_SNR 0x06
107 #define XREG_VERSION 0x07
108 #define XREG_PRODUCT_ID 0x08
109 #define XREG_BUSY 0x09
110 #define XREG_BUILD 0x0D
113 Basic firmware description. This will remain with
114 the driver for documentation purposes.
116 This represents an I2C firmware file encoded as a
117 string of unsigned char. Format is as follows:
119 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
120 char[1 ]=len0_LSB -> length of first write transaction
121 char[2 ]=data0 -> first byte to be sent
125 char[M ]=dataN -> last byte to be sent
126 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
127 char[M+2]=len1_LSB -> length of second write transaction
133 The [len] value should be interpreted as follows:
135 len= len_MSB _ len_LSB
136 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
137 len=0000_0000_0000_0000 : Reset command: Do hardware reset
138 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
139 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
141 For the RESET and WAIT commands, the two following bytes will contain
142 immediately the length of the following transaction.
145 struct XC_TV_STANDARD {
151 /* Tuner standards */
152 #define MN_NTSC_PAL_BTSC 0
153 #define MN_NTSC_PAL_A2 1
154 #define MN_NTSC_PAL_EIAJ 2
155 #define MN_NTSC_PAL_Mono 3
157 #define BG_PAL_NICAM 5
158 #define BG_PAL_MONO 6
159 #define I_PAL_NICAM 7
160 #define I_PAL_NICAM_MONO 8
162 #define DK_PAL_NICAM 10
163 #define DK_PAL_MONO 11
164 #define DK_SECAM_A2DK1 12
165 #define DK_SECAM_A2LDK3 13
166 #define DK_SECAM_A2MONO 14
167 #define L_SECAM_NICAM 15
168 #define LC_SECAM_NICAM 16
173 #define FM_Radio_INPUT2 21
174 #define FM_Radio_INPUT1 22
176 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
177 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
178 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
179 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
180 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
181 {"B/G-PAL-A2", 0x0A00, 0x8049},
182 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
183 {"B/G-PAL-MONO", 0x0878, 0x8059},
184 {"I-PAL-NICAM", 0x1080, 0x8009},
185 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
186 {"D/K-PAL-A2", 0x1600, 0x8009},
187 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
188 {"D/K-PAL-MONO", 0x1478, 0x8009},
189 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
190 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
191 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
192 {"L-SECAM-NICAM", 0x8E82, 0x0009},
193 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
194 {"DTV6", 0x00C0, 0x8002},
195 {"DTV8", 0x00C0, 0x800B},
196 {"DTV7/8", 0x00C0, 0x801B},
197 {"DTV7", 0x00C0, 0x8007},
198 {"FM Radio-INPUT2", 0x9802, 0x9002},
199 {"FM Radio-INPUT1", 0x0208, 0x9002}
202 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
203 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
204 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
205 static int xc5000_TunerReset(struct dvb_frontend *fe);
207 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
209 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
210 .flags = 0, .buf = buf, .len = len };
212 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
213 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
214 return XC_RESULT_I2C_WRITE_FAILURE;
216 return XC_RESULT_SUCCESS;
219 /* This routine is never used because the only time we read data from the
220 i2c bus is when we read registers, and we want that to be an atomic i2c
221 transaction in case we are on a multi-master bus */
222 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
224 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
225 .flags = I2C_M_RD, .buf = buf, .len = len };
227 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
228 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
234 static void xc_wait(int wait_ms)
239 static int xc5000_TunerReset(struct dvb_frontend *fe)
241 struct xc5000_priv *priv = fe->tuner_priv;
244 dprintk(1, "%s()\n", __func__);
247 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
249 priv->i2c_props.adap->algo_data,
250 DVB_FRONTEND_COMPONENT_TUNER,
251 XC5000_TUNER_RESET, 0);
253 printk(KERN_ERR "xc5000: reset failed\n");
254 return XC_RESULT_RESET_FAILURE;
257 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
258 return XC_RESULT_RESET_FAILURE;
260 return XC_RESULT_SUCCESS;
263 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
266 int WatchDogTimer = 100;
269 buf[0] = (regAddr >> 8) & 0xFF;
270 buf[1] = regAddr & 0xFF;
271 buf[2] = (i2cData >> 8) & 0xFF;
272 buf[3] = i2cData & 0xFF;
273 result = xc_send_i2c_data(priv, buf, 4);
274 if (result == XC_RESULT_SUCCESS) {
275 /* wait for busy flag to clear */
276 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
280 result = xc_send_i2c_data(priv, buf, 2);
281 if (result == XC_RESULT_SUCCESS) {
282 result = xc_read_i2c_data(priv, buf, 2);
283 if (result == XC_RESULT_SUCCESS) {
284 if ((buf[0] == 0) && (buf[1] == 0)) {
285 /* busy flag cleared */
288 xc_wait(5); /* wait 5 ms */
295 if (WatchDogTimer < 0)
296 result = XC_RESULT_I2C_WRITE_FAILURE;
301 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
303 struct xc5000_priv *priv = fe->tuner_priv;
305 int i, nbytes_to_send, result;
306 unsigned int len, pos, index;
307 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
310 while ((i2c_sequence[index] != 0xFF) ||
311 (i2c_sequence[index + 1] != 0xFF)) {
312 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
315 result = xc5000_TunerReset(fe);
317 if (result != XC_RESULT_SUCCESS)
319 } else if (len & 0x8000) {
321 xc_wait(len & 0x7FFF);
324 /* Send i2c data whilst ensuring individual transactions
325 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
328 buf[0] = i2c_sequence[index];
329 buf[1] = i2c_sequence[index + 1];
332 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
334 XC_MAX_I2C_WRITE_LENGTH;
336 nbytes_to_send = (len - pos + 2);
337 for (i = 2; i < nbytes_to_send; i++) {
338 buf[i] = i2c_sequence[index + pos +
341 result = xc_send_i2c_data(priv, buf,
344 if (result != XC_RESULT_SUCCESS)
347 pos += nbytes_to_send - 2;
352 return XC_RESULT_SUCCESS;
355 static int xc_initialize(struct xc5000_priv *priv)
357 dprintk(1, "%s()\n", __func__);
358 return xc_write_reg(priv, XREG_INIT, 0);
361 static int xc_SetTVStandard(struct xc5000_priv *priv,
362 u16 VideoMode, u16 AudioMode)
365 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
366 dprintk(1, "%s() Standard = %s\n",
368 XC5000_Standard[priv->video_standard].Name);
370 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
371 if (ret == XC_RESULT_SUCCESS)
372 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
377 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
379 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
380 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
382 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
383 rf_mode = XC_RF_MODE_CABLE;
385 "%s(), Invalid mode, defaulting to CABLE",
388 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
391 static const struct dvb_tuner_ops xc5000_tuner_ops;
393 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
397 dprintk(1, "%s(%u)\n", __func__, freq_hz);
399 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
400 (freq_hz < xc5000_tuner_ops.info.frequency_min))
401 return XC_RESULT_OUT_OF_RANGE;
403 freq_code = (u16)(freq_hz / 15625);
405 /* Starting in firmware version 1.1.44, Xceive recommends using the
406 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
407 only be used for fast scanning for channel lock) */
408 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
412 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
414 u32 freq_code = (freq_khz * 1024)/1000;
415 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
416 __func__, freq_khz, freq_code);
418 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
422 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
424 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
427 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
433 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
434 if (result != XC_RESULT_SUCCESS)
438 (*freq_error_hz) = (tmp * 15625) / 1000;
442 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
444 return xc5000_readreg(priv, XREG_LOCK, lock_status);
447 static int xc_get_version(struct xc5000_priv *priv,
448 u8 *hw_majorversion, u8 *hw_minorversion,
449 u8 *fw_majorversion, u8 *fw_minorversion)
454 result = xc5000_readreg(priv, XREG_VERSION, &data);
455 if (result != XC_RESULT_SUCCESS)
458 (*hw_majorversion) = (data >> 12) & 0x0F;
459 (*hw_minorversion) = (data >> 8) & 0x0F;
460 (*fw_majorversion) = (data >> 4) & 0x0F;
461 (*fw_minorversion) = data & 0x0F;
466 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
468 return xc5000_readreg(priv, XREG_BUILD, buildrev);
471 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
476 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
477 if (result != XC_RESULT_SUCCESS)
480 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
484 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
486 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
489 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
491 return xc5000_readreg(priv, XREG_QUALITY, quality);
494 static u16 WaitForLock(struct xc5000_priv *priv)
497 int watchDogCount = 40;
499 while ((lockState == 0) && (watchDogCount > 0)) {
500 xc_get_lock_status(priv, &lockState);
501 if (lockState != 1) {
509 #define XC_TUNE_ANALOG 0
510 #define XC_TUNE_DIGITAL 1
511 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
515 dprintk(1, "%s(%u)\n", __func__, freq_hz);
517 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
520 if (mode == XC_TUNE_ANALOG) {
521 if (WaitForLock(priv) == 1)
528 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
530 u8 buf[2] = { reg >> 8, reg & 0xff };
531 u8 bval[2] = { 0, 0 };
532 struct i2c_msg msg[2] = {
533 { .addr = priv->i2c_props.addr,
534 .flags = 0, .buf = &buf[0], .len = 2 },
535 { .addr = priv->i2c_props.addr,
536 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
539 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
540 printk(KERN_WARNING "xc5000: I2C read failed\n");
544 *val = (bval[0] << 8) | bval[1];
545 return XC_RESULT_SUCCESS;
548 static int xc5000_fwupload(struct dvb_frontend *fe)
550 struct xc5000_priv *priv = fe->tuner_priv;
551 const struct firmware *fw;
554 /* request the firmware, this will block and timeout */
555 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
556 XC5000_DEFAULT_FIRMWARE);
558 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
559 priv->i2c_props.adap->dev.parent);
561 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
562 ret = XC_RESULT_RESET_FAILURE;
565 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
567 ret = XC_RESULT_SUCCESS;
570 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
571 printk(KERN_ERR "xc5000: firmware incorrect size\n");
572 ret = XC_RESULT_RESET_FAILURE;
574 printk(KERN_INFO "xc5000: firmware uploading...\n");
575 ret = xc_load_i2c_sequence(fe, fw->data);
576 printk(KERN_INFO "xc5000: firmware upload complete...\n");
580 release_firmware(fw);
584 static void xc_debug_dump(struct xc5000_priv *priv)
587 u32 freq_error_hz = 0;
589 u32 hsync_freq_hz = 0;
592 u8 hw_majorversion = 0, hw_minorversion = 0;
593 u8 fw_majorversion = 0, fw_minorversion = 0;
594 u16 fw_buildversion = 0;
596 /* Wait for stats to stabilize.
597 * Frame Lines needs two frame times after initial lock
598 * before it is valid.
602 xc_get_ADC_Envelope(priv, &adc_envelope);
603 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
605 xc_get_frequency_error(priv, &freq_error_hz);
606 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
608 xc_get_lock_status(priv, &lock_status);
609 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
612 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
613 &fw_majorversion, &fw_minorversion);
614 xc_get_buildversion(priv, &fw_buildversion);
615 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
616 hw_majorversion, hw_minorversion,
617 fw_majorversion, fw_minorversion, fw_buildversion);
619 xc_get_hsync_freq(priv, &hsync_freq_hz);
620 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
622 xc_get_frame_lines(priv, &frame_lines);
623 dprintk(1, "*** Frame lines = %d\n", frame_lines);
625 xc_get_quality(priv, &quality);
626 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
629 static int xc5000_set_params(struct dvb_frontend *fe,
630 struct dvb_frontend_parameters *params)
632 struct xc5000_priv *priv = fe->tuner_priv;
635 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
636 xc_load_fw_and_init_tuner(fe);
638 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
640 if (fe->ops.info.type == FE_ATSC) {
641 dprintk(1, "%s() ATSC\n", __func__);
642 switch (params->u.vsb.modulation) {
645 dprintk(1, "%s() VSB modulation\n", __func__);
646 priv->rf_mode = XC_RF_MODE_AIR;
647 priv->freq_hz = params->frequency - 1750000;
648 priv->bandwidth = BANDWIDTH_6_MHZ;
649 priv->video_standard = DTV6;
654 dprintk(1, "%s() QAM modulation\n", __func__);
655 priv->rf_mode = XC_RF_MODE_CABLE;
656 priv->freq_hz = params->frequency - 1750000;
657 priv->bandwidth = BANDWIDTH_6_MHZ;
658 priv->video_standard = DTV6;
663 } else if (fe->ops.info.type == FE_OFDM) {
664 dprintk(1, "%s() OFDM\n", __func__);
665 switch (params->u.ofdm.bandwidth) {
666 case BANDWIDTH_6_MHZ:
667 priv->bandwidth = BANDWIDTH_6_MHZ;
668 priv->video_standard = DTV6;
669 priv->freq_hz = params->frequency - 1750000;
671 case BANDWIDTH_7_MHZ:
672 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
674 case BANDWIDTH_8_MHZ:
675 priv->bandwidth = BANDWIDTH_8_MHZ;
676 priv->video_standard = DTV8;
677 priv->freq_hz = params->frequency - 2750000;
680 printk(KERN_ERR "xc5000 bandwidth not set!\n");
683 priv->rf_mode = XC_RF_MODE_AIR;
685 printk(KERN_ERR "xc5000 modulation type not supported!\n");
689 dprintk(1, "%s() frequency=%d (compensated)\n",
690 __func__, priv->freq_hz);
692 ret = xc_SetSignalSource(priv, priv->rf_mode);
693 if (ret != XC_RESULT_SUCCESS) {
695 "xc5000: xc_SetSignalSource(%d) failed\n",
700 ret = xc_SetTVStandard(priv,
701 XC5000_Standard[priv->video_standard].VideoMode,
702 XC5000_Standard[priv->video_standard].AudioMode);
703 if (ret != XC_RESULT_SUCCESS) {
704 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
708 ret = xc_set_IF_frequency(priv, priv->if_khz);
709 if (ret != XC_RESULT_SUCCESS) {
710 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
715 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
723 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
725 struct xc5000_priv *priv = fe->tuner_priv;
729 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
730 if (ret == XC_RESULT_SUCCESS) {
731 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
732 ret = XC_RESULT_RESET_FAILURE;
734 ret = XC_RESULT_SUCCESS;
737 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
738 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
742 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
743 struct analog_parameters *params)
745 struct xc5000_priv *priv = fe->tuner_priv;
748 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
749 __func__, params->frequency);
751 /* Fix me: it could be air. */
752 priv->rf_mode = params->mode;
753 if (params->mode > XC_RF_MODE_CABLE)
754 priv->rf_mode = XC_RF_MODE_CABLE;
756 /* params->frequency is in units of 62.5khz */
757 priv->freq_hz = params->frequency * 62500;
759 /* FIX ME: Some video standards may have several possible audio
760 standards. We simply default to one of them here.
762 if (params->std & V4L2_STD_MN) {
763 /* default to BTSC audio standard */
764 priv->video_standard = MN_NTSC_PAL_BTSC;
768 if (params->std & V4L2_STD_PAL_BG) {
769 /* default to NICAM audio standard */
770 priv->video_standard = BG_PAL_NICAM;
774 if (params->std & V4L2_STD_PAL_I) {
775 /* default to NICAM audio standard */
776 priv->video_standard = I_PAL_NICAM;
780 if (params->std & V4L2_STD_PAL_DK) {
781 /* default to NICAM audio standard */
782 priv->video_standard = DK_PAL_NICAM;
786 if (params->std & V4L2_STD_SECAM_DK) {
787 /* default to A2 DK1 audio standard */
788 priv->video_standard = DK_SECAM_A2DK1;
792 if (params->std & V4L2_STD_SECAM_L) {
793 priv->video_standard = L_SECAM_NICAM;
797 if (params->std & V4L2_STD_SECAM_LC) {
798 priv->video_standard = LC_SECAM_NICAM;
803 ret = xc_SetSignalSource(priv, priv->rf_mode);
804 if (ret != XC_RESULT_SUCCESS) {
806 "xc5000: xc_SetSignalSource(%d) failed\n",
811 ret = xc_SetTVStandard(priv,
812 XC5000_Standard[priv->video_standard].VideoMode,
813 XC5000_Standard[priv->video_standard].AudioMode);
814 if (ret != XC_RESULT_SUCCESS) {
815 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
819 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
827 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
828 struct analog_parameters *params)
830 struct xc5000_priv *priv = fe->tuner_priv;
833 dprintk(1, "%s() frequency=%d (in units of khz)\n",
834 __func__, params->frequency);
836 priv->freq_hz = params->frequency * 125 / 2;
838 priv->rf_mode = XC_RF_MODE_AIR;
840 ret = xc_SetTVStandard(priv,
841 XC5000_Standard[FM_Radio_INPUT1].VideoMode,
842 XC5000_Standard[FM_Radio_INPUT1].AudioMode);
844 if (ret != XC_RESULT_SUCCESS) {
845 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
849 ret = xc_SetSignalSource(priv, priv->rf_mode);
850 if (ret != XC_RESULT_SUCCESS) {
852 "xc5000: xc_SetSignalSource(%d) failed\n",
857 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
862 static int xc5000_set_analog_params(struct dvb_frontend *fe,
863 struct analog_parameters *params)
865 struct xc5000_priv *priv = fe->tuner_priv;
868 if (priv->i2c_props.adap == NULL)
871 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
872 xc_load_fw_and_init_tuner(fe);
874 switch (params->mode) {
875 case V4L2_TUNER_RADIO:
876 ret = xc5000_set_radio_freq(fe, params);
878 case V4L2_TUNER_ANALOG_TV:
879 case V4L2_TUNER_DIGITAL_TV:
880 ret = xc5000_set_tv_freq(fe, params);
888 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
890 struct xc5000_priv *priv = fe->tuner_priv;
891 dprintk(1, "%s()\n", __func__);
892 *freq = priv->freq_hz;
896 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
898 struct xc5000_priv *priv = fe->tuner_priv;
899 dprintk(1, "%s()\n", __func__);
901 *bw = priv->bandwidth;
905 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
907 struct xc5000_priv *priv = fe->tuner_priv;
910 xc_get_lock_status(priv, &lock_status);
912 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
914 *status = lock_status;
919 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
921 struct xc5000_priv *priv = fe->tuner_priv;
924 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
925 ret = xc5000_fwupload(fe);
926 if (ret != XC_RESULT_SUCCESS)
930 /* Start the tuner self-calibration process */
931 ret |= xc_initialize(priv);
933 /* Wait for calibration to complete.
934 * We could continue but XC5000 will clock stretch subsequent
935 * I2C transactions until calibration is complete. This way we
936 * don't have to rely on clock stretching working.
940 /* Default to "CABLE" mode */
941 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
946 static int xc5000_sleep(struct dvb_frontend *fe)
950 dprintk(1, "%s()\n", __func__);
952 /* Avoid firmware reload on slow devices */
956 /* According to Xceive technical support, the "powerdown" register
957 was removed in newer versions of the firmware. The "supported"
958 way to sleep the tuner is to pull the reset pin low for 10ms */
959 ret = xc5000_TunerReset(fe);
960 if (ret != XC_RESULT_SUCCESS) {
962 "xc5000: %s() unable to shutdown tuner\n",
966 return XC_RESULT_SUCCESS;
969 static int xc5000_init(struct dvb_frontend *fe)
971 struct xc5000_priv *priv = fe->tuner_priv;
972 dprintk(1, "%s()\n", __func__);
974 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
975 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
985 static int xc5000_release(struct dvb_frontend *fe)
987 struct xc5000_priv *priv = fe->tuner_priv;
989 dprintk(1, "%s()\n", __func__);
991 mutex_lock(&xc5000_list_mutex);
994 hybrid_tuner_release_state(priv);
996 mutex_unlock(&xc5000_list_mutex);
998 fe->tuner_priv = NULL;
1003 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1005 .name = "Xceive XC5000",
1006 .frequency_min = 1000000,
1007 .frequency_max = 1023000000,
1008 .frequency_step = 50000,
1011 .release = xc5000_release,
1012 .init = xc5000_init,
1013 .sleep = xc5000_sleep,
1015 .set_params = xc5000_set_params,
1016 .set_analog_params = xc5000_set_analog_params,
1017 .get_frequency = xc5000_get_frequency,
1018 .get_bandwidth = xc5000_get_bandwidth,
1019 .get_status = xc5000_get_status
1022 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1023 struct i2c_adapter *i2c,
1024 struct xc5000_config *cfg)
1026 struct xc5000_priv *priv = NULL;
1030 dprintk(1, "%s(%d-%04x)\n", __func__,
1031 i2c ? i2c_adapter_id(i2c) : -1,
1032 cfg ? cfg->i2c_address : -1);
1034 mutex_lock(&xc5000_list_mutex);
1036 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1037 hybrid_tuner_instance_list,
1038 i2c, cfg->i2c_address, "xc5000");
1044 /* new tuner instance */
1045 priv->bandwidth = BANDWIDTH_6_MHZ;
1046 fe->tuner_priv = priv;
1049 /* existing tuner instance */
1050 fe->tuner_priv = priv;
1054 if (priv->if_khz == 0) {
1055 /* If the IF hasn't been set yet, use the value provided by
1056 the caller (occurs in hybrid devices where the analog
1057 call to xc5000_attach occurs before the digital side) */
1058 priv->if_khz = cfg->if_khz;
1061 /* Check if firmware has been loaded. It is possible that another
1062 instance of the driver has loaded the firmware.
1064 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1068 case XC_PRODUCT_ID_FW_LOADED:
1070 "xc5000: Successfully identified at address 0x%02x\n",
1073 "xc5000: Firmware has been loaded previously\n");
1075 case XC_PRODUCT_ID_FW_NOT_LOADED:
1077 "xc5000: Successfully identified at address 0x%02x\n",
1080 "xc5000: Firmware has not been loaded previously\n");
1084 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1085 cfg->i2c_address, id);
1089 mutex_unlock(&xc5000_list_mutex);
1091 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1092 sizeof(struct dvb_tuner_ops));
1096 mutex_unlock(&xc5000_list_mutex);
1101 EXPORT_SYMBOL(xc5000_attach);
1103 MODULE_AUTHOR("Steven Toth");
1104 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1105 MODULE_LICENSE("GPL");