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;
68 #define MAX_TV_STANDARD 24
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 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
96 #define XREG_OUTPUT_AMP 0x0B
97 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
98 #define XREG_SMOOTHEDCVBS 0x0E
99 #define XREG_XTALFREQ 0x0F
100 #define XREG_FINERFREQ 0x10
101 #define XREG_DDIMODE 0x11
103 #define XREG_ADC_ENV 0x00
104 #define XREG_QUALITY 0x01
105 #define XREG_FRAME_LINES 0x02
106 #define XREG_HSYNC_FREQ 0x03
107 #define XREG_LOCK 0x04
108 #define XREG_FREQ_ERROR 0x05
109 #define XREG_SNR 0x06
110 #define XREG_VERSION 0x07
111 #define XREG_PRODUCT_ID 0x08
112 #define XREG_BUSY 0x09
113 #define XREG_BUILD 0x0D
116 Basic firmware description. This will remain with
117 the driver for documentation purposes.
119 This represents an I2C firmware file encoded as a
120 string of unsigned char. Format is as follows:
122 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
123 char[1 ]=len0_LSB -> length of first write transaction
124 char[2 ]=data0 -> first byte to be sent
128 char[M ]=dataN -> last byte to be sent
129 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
130 char[M+2]=len1_LSB -> length of second write transaction
136 The [len] value should be interpreted as follows:
138 len= len_MSB _ len_LSB
139 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
140 len=0000_0000_0000_0000 : Reset command: Do hardware reset
141 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
142 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
144 For the RESET and WAIT commands, the two following bytes will contain
145 immediately the length of the following transaction.
148 struct XC_TV_STANDARD {
154 /* Tuner standards */
155 #define MN_NTSC_PAL_BTSC 0
156 #define MN_NTSC_PAL_A2 1
157 #define MN_NTSC_PAL_EIAJ 2
158 #define MN_NTSC_PAL_Mono 3
160 #define BG_PAL_NICAM 5
161 #define BG_PAL_MONO 6
162 #define I_PAL_NICAM 7
163 #define I_PAL_NICAM_MONO 8
165 #define DK_PAL_NICAM 10
166 #define DK_PAL_MONO 11
167 #define DK_SECAM_A2DK1 12
168 #define DK_SECAM_A2LDK3 13
169 #define DK_SECAM_A2MONO 14
170 #define L_SECAM_NICAM 15
171 #define LC_SECAM_NICAM 16
176 #define FM_Radio_INPUT2 21
177 #define FM_Radio_INPUT1 22
178 #define FM_Radio_INPUT1_MONO 23
180 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
181 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
182 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
183 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
184 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
185 {"B/G-PAL-A2", 0x0A00, 0x8049},
186 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
187 {"B/G-PAL-MONO", 0x0878, 0x8059},
188 {"I-PAL-NICAM", 0x1080, 0x8009},
189 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
190 {"D/K-PAL-A2", 0x1600, 0x8009},
191 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
192 {"D/K-PAL-MONO", 0x1478, 0x8009},
193 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
194 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
195 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
196 {"L-SECAM-NICAM", 0x8E82, 0x0009},
197 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
198 {"DTV6", 0x00C0, 0x8002},
199 {"DTV8", 0x00C0, 0x800B},
200 {"DTV7/8", 0x00C0, 0x801B},
201 {"DTV7", 0x00C0, 0x8007},
202 {"FM Radio-INPUT2", 0x9802, 0x9002},
203 {"FM Radio-INPUT1", 0x0208, 0x9002},
204 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
208 struct xc5000_fw_cfg {
213 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
214 .name = "dvb-fe-xc5000-1.6.114.fw",
218 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
219 .name = "dvb-fe-xc5000c-41.024.5.fw",
223 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
228 return &xc5000a_1_6_114;
230 return &xc5000c_41_024_5;
234 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
235 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
236 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
237 static int xc5000_TunerReset(struct dvb_frontend *fe);
239 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
241 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
242 .flags = 0, .buf = buf, .len = len };
244 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
245 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
246 return XC_RESULT_I2C_WRITE_FAILURE;
248 return XC_RESULT_SUCCESS;
252 /* This routine is never used because the only time we read data from the
253 i2c bus is when we read registers, and we want that to be an atomic i2c
254 transaction in case we are on a multi-master bus */
255 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
257 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
258 .flags = I2C_M_RD, .buf = buf, .len = len };
260 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
261 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
268 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
270 u8 buf[2] = { reg >> 8, reg & 0xff };
271 u8 bval[2] = { 0, 0 };
272 struct i2c_msg msg[2] = {
273 { .addr = priv->i2c_props.addr,
274 .flags = 0, .buf = &buf[0], .len = 2 },
275 { .addr = priv->i2c_props.addr,
276 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
279 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
280 printk(KERN_WARNING "xc5000: I2C read failed\n");
284 *val = (bval[0] << 8) | bval[1];
285 return XC_RESULT_SUCCESS;
288 static void xc_wait(int wait_ms)
293 static int xc5000_TunerReset(struct dvb_frontend *fe)
295 struct xc5000_priv *priv = fe->tuner_priv;
298 dprintk(1, "%s()\n", __func__);
301 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
303 priv->i2c_props.adap->algo_data,
304 DVB_FRONTEND_COMPONENT_TUNER,
305 XC5000_TUNER_RESET, 0);
307 printk(KERN_ERR "xc5000: reset failed\n");
308 return XC_RESULT_RESET_FAILURE;
311 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
312 return XC_RESULT_RESET_FAILURE;
314 return XC_RESULT_SUCCESS;
317 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
320 int WatchDogTimer = 100;
323 buf[0] = (regAddr >> 8) & 0xFF;
324 buf[1] = regAddr & 0xFF;
325 buf[2] = (i2cData >> 8) & 0xFF;
326 buf[3] = i2cData & 0xFF;
327 result = xc_send_i2c_data(priv, buf, 4);
328 if (result == XC_RESULT_SUCCESS) {
329 /* wait for busy flag to clear */
330 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
331 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
332 if (result == XC_RESULT_SUCCESS) {
333 if ((buf[0] == 0) && (buf[1] == 0)) {
334 /* busy flag cleared */
337 xc_wait(5); /* wait 5 ms */
343 if (WatchDogTimer < 0)
344 result = XC_RESULT_I2C_WRITE_FAILURE;
349 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
351 struct xc5000_priv *priv = fe->tuner_priv;
353 int i, nbytes_to_send, result;
354 unsigned int len, pos, index;
355 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
358 while ((i2c_sequence[index] != 0xFF) ||
359 (i2c_sequence[index + 1] != 0xFF)) {
360 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
363 result = xc5000_TunerReset(fe);
365 if (result != XC_RESULT_SUCCESS)
367 } else if (len & 0x8000) {
369 xc_wait(len & 0x7FFF);
372 /* Send i2c data whilst ensuring individual transactions
373 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
376 buf[0] = i2c_sequence[index];
377 buf[1] = i2c_sequence[index + 1];
380 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
382 XC_MAX_I2C_WRITE_LENGTH;
384 nbytes_to_send = (len - pos + 2);
385 for (i = 2; i < nbytes_to_send; i++) {
386 buf[i] = i2c_sequence[index + pos +
389 result = xc_send_i2c_data(priv, buf,
392 if (result != XC_RESULT_SUCCESS)
395 pos += nbytes_to_send - 2;
400 return XC_RESULT_SUCCESS;
403 static int xc_initialize(struct xc5000_priv *priv)
405 dprintk(1, "%s()\n", __func__);
406 return xc_write_reg(priv, XREG_INIT, 0);
409 static int xc_SetTVStandard(struct xc5000_priv *priv,
410 u16 VideoMode, u16 AudioMode)
413 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
414 dprintk(1, "%s() Standard = %s\n",
416 XC5000_Standard[priv->video_standard].Name);
418 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
419 if (ret == XC_RESULT_SUCCESS)
420 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
425 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
427 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
428 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
430 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
431 rf_mode = XC_RF_MODE_CABLE;
433 "%s(), Invalid mode, defaulting to CABLE",
436 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
439 static const struct dvb_tuner_ops xc5000_tuner_ops;
441 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
445 dprintk(1, "%s(%u)\n", __func__, freq_hz);
447 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
448 (freq_hz < xc5000_tuner_ops.info.frequency_min))
449 return XC_RESULT_OUT_OF_RANGE;
451 freq_code = (u16)(freq_hz / 15625);
453 /* Starting in firmware version 1.1.44, Xceive recommends using the
454 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
455 only be used for fast scanning for channel lock) */
456 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
460 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
462 u32 freq_code = (freq_khz * 1024)/1000;
463 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
464 __func__, freq_khz, freq_code);
466 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
470 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
472 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
475 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
481 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
482 if (result != XC_RESULT_SUCCESS)
486 (*freq_error_hz) = (tmp * 15625) / 1000;
490 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
492 return xc5000_readreg(priv, XREG_LOCK, lock_status);
495 static int xc_get_version(struct xc5000_priv *priv,
496 u8 *hw_majorversion, u8 *hw_minorversion,
497 u8 *fw_majorversion, u8 *fw_minorversion)
502 result = xc5000_readreg(priv, XREG_VERSION, &data);
503 if (result != XC_RESULT_SUCCESS)
506 (*hw_majorversion) = (data >> 12) & 0x0F;
507 (*hw_minorversion) = (data >> 8) & 0x0F;
508 (*fw_majorversion) = (data >> 4) & 0x0F;
509 (*fw_minorversion) = data & 0x0F;
514 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
516 return xc5000_readreg(priv, XREG_BUILD, buildrev);
519 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
524 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
525 if (result != XC_RESULT_SUCCESS)
528 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
532 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
534 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
537 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
539 return xc5000_readreg(priv, XREG_QUALITY, quality);
542 static u16 WaitForLock(struct xc5000_priv *priv)
545 int watchDogCount = 40;
547 while ((lockState == 0) && (watchDogCount > 0)) {
548 xc_get_lock_status(priv, &lockState);
549 if (lockState != 1) {
557 #define XC_TUNE_ANALOG 0
558 #define XC_TUNE_DIGITAL 1
559 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
563 dprintk(1, "%s(%u)\n", __func__, freq_hz);
565 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
568 if (mode == XC_TUNE_ANALOG) {
569 if (WaitForLock(priv) == 1)
576 static int xc_set_xtal(struct dvb_frontend *fe)
578 struct xc5000_priv *priv = fe->tuner_priv;
579 int ret = XC_RESULT_SUCCESS;
581 switch (priv->chip_id) {
584 /* 32.000 MHz xtal is default */
587 switch (priv->xtal_khz) {
590 /* 32.000 MHz xtal is default */
593 /* 31.875 MHz xtal configuration */
594 ret = xc_write_reg(priv, 0x000f, 0x8081);
602 static int xc5000_fwupload(struct dvb_frontend *fe)
604 struct xc5000_priv *priv = fe->tuner_priv;
605 const struct firmware *fw;
607 const struct xc5000_fw_cfg *desired_fw =
608 xc5000_assign_firmware(priv->chip_id);
610 /* request the firmware, this will block and timeout */
611 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
614 ret = request_firmware(&fw, desired_fw->name,
615 priv->i2c_props.adap->dev.parent);
617 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
618 ret = XC_RESULT_RESET_FAILURE;
621 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
623 ret = XC_RESULT_SUCCESS;
626 if (fw->size != desired_fw->size) {
627 printk(KERN_ERR "xc5000: firmware incorrect size\n");
628 ret = XC_RESULT_RESET_FAILURE;
630 printk(KERN_INFO "xc5000: firmware uploading...\n");
631 ret = xc_load_i2c_sequence(fe, fw->data);
632 if (XC_RESULT_SUCCESS == ret)
633 ret = xc_set_xtal(fe);
634 if (XC_RESULT_SUCCESS == ret)
635 printk(KERN_INFO "xc5000: firmware upload complete...\n");
637 printk(KERN_ERR "xc5000: firmware upload failed...\n");
641 release_firmware(fw);
645 static void xc_debug_dump(struct xc5000_priv *priv)
648 u32 freq_error_hz = 0;
650 u32 hsync_freq_hz = 0;
653 u8 hw_majorversion = 0, hw_minorversion = 0;
654 u8 fw_majorversion = 0, fw_minorversion = 0;
655 u16 fw_buildversion = 0;
657 /* Wait for stats to stabilize.
658 * Frame Lines needs two frame times after initial lock
659 * before it is valid.
663 xc_get_ADC_Envelope(priv, &adc_envelope);
664 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
666 xc_get_frequency_error(priv, &freq_error_hz);
667 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
669 xc_get_lock_status(priv, &lock_status);
670 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
673 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
674 &fw_majorversion, &fw_minorversion);
675 xc_get_buildversion(priv, &fw_buildversion);
676 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
677 hw_majorversion, hw_minorversion,
678 fw_majorversion, fw_minorversion, fw_buildversion);
680 xc_get_hsync_freq(priv, &hsync_freq_hz);
681 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
683 xc_get_frame_lines(priv, &frame_lines);
684 dprintk(1, "*** Frame lines = %d\n", frame_lines);
686 xc_get_quality(priv, &quality);
687 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
690 static int xc5000_set_params(struct dvb_frontend *fe)
693 struct xc5000_priv *priv = fe->tuner_priv;
694 u32 bw = fe->dtv_property_cache.bandwidth_hz;
695 u32 freq = fe->dtv_property_cache.frequency;
696 u32 delsys = fe->dtv_property_cache.delivery_system;
698 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
699 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
700 dprintk(1, "Unable to load firmware and init tuner\n");
705 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
709 dprintk(1, "%s() VSB modulation\n", __func__);
710 priv->rf_mode = XC_RF_MODE_AIR;
711 priv->freq_hz = freq - 1750000;
712 priv->video_standard = DTV6;
714 case SYS_DVBC_ANNEX_B:
715 dprintk(1, "%s() QAM modulation\n", __func__);
716 priv->rf_mode = XC_RF_MODE_CABLE;
717 priv->freq_hz = freq - 1750000;
718 priv->video_standard = DTV6;
722 dprintk(1, "%s() OFDM\n", __func__);
725 priv->video_standard = DTV6;
726 priv->freq_hz = freq - 1750000;
729 priv->video_standard = DTV7;
730 priv->freq_hz = freq - 2250000;
733 priv->video_standard = DTV8;
734 priv->freq_hz = freq - 2750000;
737 printk(KERN_ERR "xc5000 bandwidth not set!\n");
740 priv->rf_mode = XC_RF_MODE_AIR;
741 case SYS_DVBC_ANNEX_A:
742 case SYS_DVBC_ANNEX_C:
743 dprintk(1, "%s() QAM modulation\n", __func__);
744 priv->rf_mode = XC_RF_MODE_CABLE;
746 priv->video_standard = DTV6;
747 priv->freq_hz = freq - 1750000;
749 } else if (bw <= 7000000) {
750 priv->video_standard = DTV7;
751 priv->freq_hz = freq - 2250000;
754 priv->video_standard = DTV7_8;
755 priv->freq_hz = freq - 2750000;
758 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
762 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
766 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
767 __func__, freq, priv->freq_hz);
769 ret = xc_SetSignalSource(priv, priv->rf_mode);
770 if (ret != XC_RESULT_SUCCESS) {
772 "xc5000: xc_SetSignalSource(%d) failed\n",
777 ret = xc_SetTVStandard(priv,
778 XC5000_Standard[priv->video_standard].VideoMode,
779 XC5000_Standard[priv->video_standard].AudioMode);
780 if (ret != XC_RESULT_SUCCESS) {
781 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
785 ret = xc_set_IF_frequency(priv, priv->if_khz);
786 if (ret != XC_RESULT_SUCCESS) {
787 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
792 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
794 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
799 priv->bandwidth = bw;
804 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
806 struct xc5000_priv *priv = fe->tuner_priv;
810 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
811 if (ret == XC_RESULT_SUCCESS) {
812 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
813 ret = XC_RESULT_RESET_FAILURE;
815 ret = XC_RESULT_SUCCESS;
818 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
819 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
823 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
824 struct analog_parameters *params)
826 struct xc5000_priv *priv = fe->tuner_priv;
829 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
830 __func__, params->frequency);
832 /* Fix me: it could be air. */
833 priv->rf_mode = params->mode;
834 if (params->mode > XC_RF_MODE_CABLE)
835 priv->rf_mode = XC_RF_MODE_CABLE;
837 /* params->frequency is in units of 62.5khz */
838 priv->freq_hz = params->frequency * 62500;
840 /* FIX ME: Some video standards may have several possible audio
841 standards. We simply default to one of them here.
843 if (params->std & V4L2_STD_MN) {
844 /* default to BTSC audio standard */
845 priv->video_standard = MN_NTSC_PAL_BTSC;
849 if (params->std & V4L2_STD_PAL_BG) {
850 /* default to NICAM audio standard */
851 priv->video_standard = BG_PAL_NICAM;
855 if (params->std & V4L2_STD_PAL_I) {
856 /* default to NICAM audio standard */
857 priv->video_standard = I_PAL_NICAM;
861 if (params->std & V4L2_STD_PAL_DK) {
862 /* default to NICAM audio standard */
863 priv->video_standard = DK_PAL_NICAM;
867 if (params->std & V4L2_STD_SECAM_DK) {
868 /* default to A2 DK1 audio standard */
869 priv->video_standard = DK_SECAM_A2DK1;
873 if (params->std & V4L2_STD_SECAM_L) {
874 priv->video_standard = L_SECAM_NICAM;
878 if (params->std & V4L2_STD_SECAM_LC) {
879 priv->video_standard = LC_SECAM_NICAM;
884 ret = xc_SetSignalSource(priv, priv->rf_mode);
885 if (ret != XC_RESULT_SUCCESS) {
887 "xc5000: xc_SetSignalSource(%d) failed\n",
892 ret = xc_SetTVStandard(priv,
893 XC5000_Standard[priv->video_standard].VideoMode,
894 XC5000_Standard[priv->video_standard].AudioMode);
895 if (ret != XC_RESULT_SUCCESS) {
896 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
900 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
902 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
910 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
911 struct analog_parameters *params)
913 struct xc5000_priv *priv = fe->tuner_priv;
917 dprintk(1, "%s() frequency=%d (in units of khz)\n",
918 __func__, params->frequency);
920 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
921 dprintk(1, "%s() radio input not configured\n", __func__);
925 if (priv->radio_input == XC5000_RADIO_FM1)
926 radio_input = FM_Radio_INPUT1;
927 else if (priv->radio_input == XC5000_RADIO_FM2)
928 radio_input = FM_Radio_INPUT2;
929 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
930 radio_input = FM_Radio_INPUT1_MONO;
932 dprintk(1, "%s() unknown radio input %d\n", __func__,
937 priv->freq_hz = params->frequency * 125 / 2;
939 priv->rf_mode = XC_RF_MODE_AIR;
941 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
942 XC5000_Standard[radio_input].AudioMode);
944 if (ret != XC_RESULT_SUCCESS) {
945 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
949 ret = xc_SetSignalSource(priv, priv->rf_mode);
950 if (ret != XC_RESULT_SUCCESS) {
952 "xc5000: xc_SetSignalSource(%d) failed\n",
957 if ((priv->radio_input == XC5000_RADIO_FM1) ||
958 (priv->radio_input == XC5000_RADIO_FM2))
959 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
960 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
961 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
963 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
968 static int xc5000_set_analog_params(struct dvb_frontend *fe,
969 struct analog_parameters *params)
971 struct xc5000_priv *priv = fe->tuner_priv;
974 if (priv->i2c_props.adap == NULL)
977 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
978 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
979 dprintk(1, "Unable to load firmware and init tuner\n");
984 switch (params->mode) {
985 case V4L2_TUNER_RADIO:
986 ret = xc5000_set_radio_freq(fe, params);
988 case V4L2_TUNER_ANALOG_TV:
989 case V4L2_TUNER_DIGITAL_TV:
990 ret = xc5000_set_tv_freq(fe, params);
998 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1000 struct xc5000_priv *priv = fe->tuner_priv;
1001 dprintk(1, "%s()\n", __func__);
1002 *freq = priv->freq_hz;
1006 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1008 struct xc5000_priv *priv = fe->tuner_priv;
1009 dprintk(1, "%s()\n", __func__);
1010 *freq = priv->if_khz * 1000;
1014 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1016 struct xc5000_priv *priv = fe->tuner_priv;
1017 dprintk(1, "%s()\n", __func__);
1019 *bw = priv->bandwidth;
1023 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1025 struct xc5000_priv *priv = fe->tuner_priv;
1026 u16 lock_status = 0;
1028 xc_get_lock_status(priv, &lock_status);
1030 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1032 *status = lock_status;
1037 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
1039 struct xc5000_priv *priv = fe->tuner_priv;
1042 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1043 ret = xc5000_fwupload(fe);
1044 if (ret != XC_RESULT_SUCCESS)
1048 /* Start the tuner self-calibration process */
1049 ret |= xc_initialize(priv);
1051 /* Wait for calibration to complete.
1052 * We could continue but XC5000 will clock stretch subsequent
1053 * I2C transactions until calibration is complete. This way we
1054 * don't have to rely on clock stretching working.
1058 /* Default to "CABLE" mode */
1059 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1064 static int xc5000_sleep(struct dvb_frontend *fe)
1068 dprintk(1, "%s()\n", __func__);
1070 /* Avoid firmware reload on slow devices */
1074 /* According to Xceive technical support, the "powerdown" register
1075 was removed in newer versions of the firmware. The "supported"
1076 way to sleep the tuner is to pull the reset pin low for 10ms */
1077 ret = xc5000_TunerReset(fe);
1078 if (ret != XC_RESULT_SUCCESS) {
1080 "xc5000: %s() unable to shutdown tuner\n",
1084 return XC_RESULT_SUCCESS;
1087 static int xc5000_init(struct dvb_frontend *fe)
1089 struct xc5000_priv *priv = fe->tuner_priv;
1090 dprintk(1, "%s()\n", __func__);
1092 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1093 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1098 xc_debug_dump(priv);
1103 static int xc5000_release(struct dvb_frontend *fe)
1105 struct xc5000_priv *priv = fe->tuner_priv;
1107 dprintk(1, "%s()\n", __func__);
1109 mutex_lock(&xc5000_list_mutex);
1112 hybrid_tuner_release_state(priv);
1114 mutex_unlock(&xc5000_list_mutex);
1116 fe->tuner_priv = NULL;
1121 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1123 struct xc5000_priv *priv = fe->tuner_priv;
1124 struct xc5000_config *p = priv_cfg;
1126 dprintk(1, "%s()\n", __func__);
1129 priv->if_khz = p->if_khz;
1132 priv->radio_input = p->radio_input;
1138 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1140 .name = "Xceive XC5000",
1141 .frequency_min = 1000000,
1142 .frequency_max = 1023000000,
1143 .frequency_step = 50000,
1146 .release = xc5000_release,
1147 .init = xc5000_init,
1148 .sleep = xc5000_sleep,
1150 .set_config = xc5000_set_config,
1151 .set_params = xc5000_set_params,
1152 .set_analog_params = xc5000_set_analog_params,
1153 .get_frequency = xc5000_get_frequency,
1154 .get_if_frequency = xc5000_get_if_frequency,
1155 .get_bandwidth = xc5000_get_bandwidth,
1156 .get_status = xc5000_get_status
1159 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1160 struct i2c_adapter *i2c,
1161 const struct xc5000_config *cfg)
1163 struct xc5000_priv *priv = NULL;
1167 dprintk(1, "%s(%d-%04x)\n", __func__,
1168 i2c ? i2c_adapter_id(i2c) : -1,
1169 cfg ? cfg->i2c_address : -1);
1171 mutex_lock(&xc5000_list_mutex);
1173 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1174 hybrid_tuner_instance_list,
1175 i2c, cfg->i2c_address, "xc5000");
1181 /* new tuner instance */
1182 priv->bandwidth = 6000000;
1183 fe->tuner_priv = priv;
1186 /* existing tuner instance */
1187 fe->tuner_priv = priv;
1191 if (priv->if_khz == 0) {
1192 /* If the IF hasn't been set yet, use the value provided by
1193 the caller (occurs in hybrid devices where the analog
1194 call to xc5000_attach occurs before the digital side) */
1195 priv->if_khz = cfg->if_khz;
1198 if (priv->xtal_khz == 0)
1199 priv->xtal_khz = cfg->xtal_khz;
1201 if (priv->radio_input == 0)
1202 priv->radio_input = cfg->radio_input;
1204 /* don't override chip id if it's already been set
1205 unless explicitly specified */
1206 if ((priv->chip_id == 0) || (cfg->chip_id))
1207 /* use default chip id if none specified, set to 0 so
1208 it can be overridden if this is a hybrid driver */
1209 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1211 /* Check if firmware has been loaded. It is possible that another
1212 instance of the driver has loaded the firmware.
1214 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1218 case XC_PRODUCT_ID_FW_LOADED:
1220 "xc5000: Successfully identified at address 0x%02x\n",
1223 "xc5000: Firmware has been loaded previously\n");
1225 case XC_PRODUCT_ID_FW_NOT_LOADED:
1227 "xc5000: Successfully identified at address 0x%02x\n",
1230 "xc5000: Firmware has not been loaded previously\n");
1234 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1235 cfg->i2c_address, id);
1239 mutex_unlock(&xc5000_list_mutex);
1241 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1242 sizeof(struct dvb_tuner_ops));
1246 mutex_unlock(&xc5000_list_mutex);
1251 EXPORT_SYMBOL(xc5000_attach);
1253 MODULE_AUTHOR("Steven Toth");
1254 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1255 MODULE_LICENSE("GPL");