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/workqueue.h>
29 #include <linux/dvb/frontend.h>
30 #include <linux/i2c.h>
32 #include "dvb_frontend.h"
35 #include "tuner-i2c.h"
38 module_param(debug, int, 0644);
39 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
41 static int no_poweroff;
42 module_param(no_poweroff, int, 0644);
43 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
44 "\t\t1 keep device energized and with tuner ready all the times.\n"
45 "\t\tFaster, but consumes more power and keeps the device hotter");
47 static DEFINE_MUTEX(xc5000_list_mutex);
48 static LIST_HEAD(hybrid_tuner_instance_list);
50 #define dprintk(level, fmt, arg...) if (debug >= level) \
51 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
54 struct tuner_i2c_props i2c_props;
55 struct list_head hybrid_tuner_instance_list;
59 u32 freq_hz, freq_offset;
68 u8 init_status_supported;
69 u8 fw_checksum_supported;
71 struct dvb_frontend *fe;
72 struct delayed_work timer_sleep;
74 const struct firmware *firmware;
78 #define MAX_TV_STANDARD 24
79 #define XC_MAX_I2C_WRITE_LENGTH 64
81 /* Time to suspend after the .sleep callback is called */
82 #define XC5000_SLEEP_TIME 5000 /* ms */
85 #define XC_RF_MODE_AIR 0
86 #define XC_RF_MODE_CABLE 1
89 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
90 #define XC_PRODUCT_ID_FW_LOADED 0x1388
93 #define XREG_INIT 0x00
94 #define XREG_VIDEO_MODE 0x01
95 #define XREG_AUDIO_MODE 0x02
96 #define XREG_RF_FREQ 0x03
97 #define XREG_D_CODE 0x04
98 #define XREG_IF_OUT 0x05
99 #define XREG_SEEK_MODE 0x07
100 #define XREG_POWER_DOWN 0x0A /* Obsolete */
101 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
102 #define XREG_OUTPUT_AMP 0x0B
103 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
104 #define XREG_SMOOTHEDCVBS 0x0E
105 #define XREG_XTALFREQ 0x0F
106 #define XREG_FINERFREQ 0x10
107 #define XREG_DDIMODE 0x11
109 #define XREG_ADC_ENV 0x00
110 #define XREG_QUALITY 0x01
111 #define XREG_FRAME_LINES 0x02
112 #define XREG_HSYNC_FREQ 0x03
113 #define XREG_LOCK 0x04
114 #define XREG_FREQ_ERROR 0x05
115 #define XREG_SNR 0x06
116 #define XREG_VERSION 0x07
117 #define XREG_PRODUCT_ID 0x08
118 #define XREG_BUSY 0x09
119 #define XREG_BUILD 0x0D
120 #define XREG_TOTALGAIN 0x0F
121 #define XREG_FW_CHECKSUM 0x12
122 #define XREG_INIT_STATUS 0x13
125 Basic firmware description. This will remain with
126 the driver for documentation purposes.
128 This represents an I2C firmware file encoded as a
129 string of unsigned char. Format is as follows:
131 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
132 char[1 ]=len0_LSB -> length of first write transaction
133 char[2 ]=data0 -> first byte to be sent
137 char[M ]=dataN -> last byte to be sent
138 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
139 char[M+2]=len1_LSB -> length of second write transaction
145 The [len] value should be interpreted as follows:
147 len= len_MSB _ len_LSB
148 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
149 len=0000_0000_0000_0000 : Reset command: Do hardware reset
150 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
151 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
153 For the RESET and WAIT commands, the two following bytes will contain
154 immediately the length of the following transaction.
157 struct XC_TV_STANDARD {
163 /* Tuner standards */
164 #define MN_NTSC_PAL_BTSC 0
165 #define MN_NTSC_PAL_A2 1
166 #define MN_NTSC_PAL_EIAJ 2
167 #define MN_NTSC_PAL_MONO 3
169 #define BG_PAL_NICAM 5
170 #define BG_PAL_MONO 6
171 #define I_PAL_NICAM 7
172 #define I_PAL_NICAM_MONO 8
174 #define DK_PAL_NICAM 10
175 #define DK_PAL_MONO 11
176 #define DK_SECAM_A2DK1 12
177 #define DK_SECAM_A2LDK3 13
178 #define DK_SECAM_A2MONO 14
179 #define L_SECAM_NICAM 15
180 #define LC_SECAM_NICAM 16
185 #define FM_RADIO_INPUT2 21
186 #define FM_RADIO_INPUT1 22
187 #define FM_RADIO_INPUT1_MONO 23
189 static struct XC_TV_STANDARD xc5000_standard[MAX_TV_STANDARD] = {
190 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
191 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
192 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
193 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
194 {"B/G-PAL-A2", 0x0A00, 0x8049},
195 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
196 {"B/G-PAL-MONO", 0x0878, 0x8059},
197 {"I-PAL-NICAM", 0x1080, 0x8009},
198 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
199 {"D/K-PAL-A2", 0x1600, 0x8009},
200 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
201 {"D/K-PAL-MONO", 0x1478, 0x8009},
202 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
203 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
204 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
205 {"L-SECAM-NICAM", 0x8E82, 0x0009},
206 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
207 {"DTV6", 0x00C0, 0x8002},
208 {"DTV8", 0x00C0, 0x800B},
209 {"DTV7/8", 0x00C0, 0x801B},
210 {"DTV7", 0x00C0, 0x8007},
211 {"FM Radio-INPUT2", 0x9802, 0x9002},
212 {"FM Radio-INPUT1", 0x0208, 0x9002},
213 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
217 struct xc5000_fw_cfg {
221 u8 init_status_supported;
222 u8 fw_checksum_supported;
225 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
226 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
227 .name = XC5000A_FIRMWARE,
232 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
233 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
234 .name = XC5000C_FIRMWARE,
237 .init_status_supported = 1,
238 .fw_checksum_supported = 1,
241 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
246 return &xc5000a_1_6_114;
248 return &xc5000c_41_024_5;
252 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
253 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
254 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
255 static int xc5000_tuner_reset(struct dvb_frontend *fe);
257 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
259 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
260 .flags = 0, .buf = buf, .len = len };
262 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
263 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
270 /* This routine is never used because the only time we read data from the
271 i2c bus is when we read registers, and we want that to be an atomic i2c
272 transaction in case we are on a multi-master bus */
273 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
275 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
276 .flags = I2C_M_RD, .buf = buf, .len = len };
278 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
279 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
286 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
288 u8 buf[2] = { reg >> 8, reg & 0xff };
289 u8 bval[2] = { 0, 0 };
290 struct i2c_msg msg[2] = {
291 { .addr = priv->i2c_props.addr,
292 .flags = 0, .buf = &buf[0], .len = 2 },
293 { .addr = priv->i2c_props.addr,
294 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
297 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
298 printk(KERN_WARNING "xc5000: I2C read failed\n");
302 *val = (bval[0] << 8) | bval[1];
306 static int xc5000_tuner_reset(struct dvb_frontend *fe)
308 struct xc5000_priv *priv = fe->tuner_priv;
311 dprintk(1, "%s()\n", __func__);
314 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
316 priv->i2c_props.adap->algo_data,
317 DVB_FRONTEND_COMPONENT_TUNER,
318 XC5000_TUNER_RESET, 0);
320 printk(KERN_ERR "xc5000: reset failed\n");
324 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
330 static int xc_write_reg(struct xc5000_priv *priv, u16 reg_addr, u16 i2c_data)
333 int watch_dog_timer = 100;
336 buf[0] = (reg_addr >> 8) & 0xFF;
337 buf[1] = reg_addr & 0xFF;
338 buf[2] = (i2c_data >> 8) & 0xFF;
339 buf[3] = i2c_data & 0xFF;
340 result = xc_send_i2c_data(priv, buf, 4);
342 /* wait for busy flag to clear */
343 while ((watch_dog_timer > 0) && (result == 0)) {
344 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
346 if ((buf[0] == 0) && (buf[1] == 0)) {
347 /* busy flag cleared */
350 msleep(5); /* wait 5 ms */
356 if (watch_dog_timer <= 0)
362 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
364 struct xc5000_priv *priv = fe->tuner_priv;
366 int i, nbytes_to_send, result;
367 unsigned int len, pos, index;
368 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
371 while ((i2c_sequence[index] != 0xFF) ||
372 (i2c_sequence[index + 1] != 0xFF)) {
373 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
376 result = xc5000_tuner_reset(fe);
380 } else if (len & 0x8000) {
382 msleep(len & 0x7FFF);
385 /* Send i2c data whilst ensuring individual transactions
386 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
389 buf[0] = i2c_sequence[index];
390 buf[1] = i2c_sequence[index + 1];
393 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
395 XC_MAX_I2C_WRITE_LENGTH;
397 nbytes_to_send = (len - pos + 2);
398 for (i = 2; i < nbytes_to_send; i++) {
399 buf[i] = i2c_sequence[index + pos +
402 result = xc_send_i2c_data(priv, buf,
408 pos += nbytes_to_send - 2;
416 static int xc_initialize(struct xc5000_priv *priv)
418 dprintk(1, "%s()\n", __func__);
419 return xc_write_reg(priv, XREG_INIT, 0);
422 static int xc_set_tv_standard(struct xc5000_priv *priv,
423 u16 video_mode, u16 audio_mode, u8 radio_mode)
426 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
428 dprintk(1, "%s() Standard = %s\n",
430 xc5000_standard[radio_mode].name);
432 dprintk(1, "%s() Standard = %s\n",
434 xc5000_standard[priv->video_standard].name);
437 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
439 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
444 static int xc_set_signal_source(struct xc5000_priv *priv, u16 rf_mode)
446 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
447 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
449 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
450 rf_mode = XC_RF_MODE_CABLE;
452 "%s(), Invalid mode, defaulting to CABLE",
455 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
458 static const struct dvb_tuner_ops xc5000_tuner_ops;
460 static int xc_set_rf_frequency(struct xc5000_priv *priv, u32 freq_hz)
464 dprintk(1, "%s(%u)\n", __func__, freq_hz);
466 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
467 (freq_hz < xc5000_tuner_ops.info.frequency_min))
470 freq_code = (u16)(freq_hz / 15625);
472 /* Starting in firmware version 1.1.44, Xceive recommends using the
473 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
474 only be used for fast scanning for channel lock) */
475 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
479 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
481 u32 freq_code = (freq_khz * 1024)/1000;
482 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
483 __func__, freq_khz, freq_code);
485 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
489 static int xc_get_adc_envelope(struct xc5000_priv *priv, u16 *adc_envelope)
491 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
494 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
500 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®_data);
505 (*freq_error_hz) = (tmp * 15625) / 1000;
509 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
511 return xc5000_readreg(priv, XREG_LOCK, lock_status);
514 static int xc_get_version(struct xc5000_priv *priv,
515 u8 *hw_majorversion, u8 *hw_minorversion,
516 u8 *fw_majorversion, u8 *fw_minorversion)
521 result = xc5000_readreg(priv, XREG_VERSION, &data);
525 (*hw_majorversion) = (data >> 12) & 0x0F;
526 (*hw_minorversion) = (data >> 8) & 0x0F;
527 (*fw_majorversion) = (data >> 4) & 0x0F;
528 (*fw_minorversion) = data & 0x0F;
533 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
535 return xc5000_readreg(priv, XREG_BUILD, buildrev);
538 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
543 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®_data);
547 (*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100;
551 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
553 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
556 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
558 return xc5000_readreg(priv, XREG_QUALITY, quality);
561 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
563 return xc5000_readreg(priv, XREG_SNR, snr);
566 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
568 return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
571 static u16 wait_for_lock(struct xc5000_priv *priv)
574 int watch_dog_count = 40;
576 while ((lock_state == 0) && (watch_dog_count > 0)) {
577 xc_get_lock_status(priv, &lock_state);
578 if (lock_state != 1) {
586 #define XC_TUNE_ANALOG 0
587 #define XC_TUNE_DIGITAL 1
588 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
592 dprintk(1, "%s(%u)\n", __func__, freq_hz);
594 if (xc_set_rf_frequency(priv, freq_hz) != 0)
597 if (mode == XC_TUNE_ANALOG) {
598 if (wait_for_lock(priv) == 1)
605 static int xc_set_xtal(struct dvb_frontend *fe)
607 struct xc5000_priv *priv = fe->tuner_priv;
610 switch (priv->chip_id) {
613 /* 32.000 MHz xtal is default */
616 switch (priv->xtal_khz) {
619 /* 32.000 MHz xtal is default */
622 /* 31.875 MHz xtal configuration */
623 ret = xc_write_reg(priv, 0x000f, 0x8081);
631 static int xc5000_fwupload(struct dvb_frontend *fe,
632 const struct xc5000_fw_cfg *desired_fw,
633 const struct firmware *fw)
635 struct xc5000_priv *priv = fe->tuner_priv;
638 /* request the firmware, this will block and timeout */
639 dprintk(1, "waiting for firmware upload (%s)...\n",
642 priv->pll_register_no = desired_fw->pll_reg;
643 priv->init_status_supported = desired_fw->init_status_supported;
644 priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
647 dprintk(1, "firmware uploading...\n");
648 ret = xc_load_i2c_sequence(fe, fw->data);
650 ret = xc_set_xtal(fe);
651 dprintk(1, "Firmware upload complete...\n");
653 printk(KERN_ERR "xc5000: firmware upload failed...\n");
658 static void xc_debug_dump(struct xc5000_priv *priv)
661 u32 freq_error_hz = 0;
663 u32 hsync_freq_hz = 0;
668 u8 hw_majorversion = 0, hw_minorversion = 0;
669 u8 fw_majorversion = 0, fw_minorversion = 0;
670 u16 fw_buildversion = 0;
673 /* Wait for stats to stabilize.
674 * Frame Lines needs two frame times after initial lock
675 * before it is valid.
679 xc_get_adc_envelope(priv, &adc_envelope);
680 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
682 xc_get_frequency_error(priv, &freq_error_hz);
683 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
685 xc_get_lock_status(priv, &lock_status);
686 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
689 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
690 &fw_majorversion, &fw_minorversion);
691 xc_get_buildversion(priv, &fw_buildversion);
692 dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
693 hw_majorversion, hw_minorversion,
694 fw_majorversion, fw_minorversion, fw_buildversion);
696 xc_get_hsync_freq(priv, &hsync_freq_hz);
697 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
699 xc_get_frame_lines(priv, &frame_lines);
700 dprintk(1, "*** Frame lines = %d\n", frame_lines);
702 xc_get_quality(priv, &quality);
703 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
705 xc_get_analogsnr(priv, &snr);
706 dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
708 xc_get_totalgain(priv, &totalgain);
709 dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
710 (totalgain % 256) * 100 / 256);
712 if (priv->pll_register_no) {
713 xc5000_readreg(priv, priv->pll_register_no, ®val);
714 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
718 static int xc5000_tune_digital(struct dvb_frontend *fe)
720 struct xc5000_priv *priv = fe->tuner_priv;
722 u32 bw = fe->dtv_property_cache.bandwidth_hz;
724 ret = xc_set_signal_source(priv, priv->rf_mode);
727 "xc5000: xc_set_signal_source(%d) failed\n",
732 ret = xc_set_tv_standard(priv,
733 xc5000_standard[priv->video_standard].video_mode,
734 xc5000_standard[priv->video_standard].audio_mode, 0);
736 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
740 ret = xc_set_IF_frequency(priv, priv->if_khz);
742 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
747 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
749 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
754 priv->bandwidth = bw;
759 static int xc5000_set_digital_params(struct dvb_frontend *fe)
762 struct xc5000_priv *priv = fe->tuner_priv;
763 u32 bw = fe->dtv_property_cache.bandwidth_hz;
764 u32 freq = fe->dtv_property_cache.frequency;
765 u32 delsys = fe->dtv_property_cache.delivery_system;
767 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
768 dprintk(1, "Unable to load firmware and init tuner\n");
772 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
776 dprintk(1, "%s() VSB modulation\n", __func__);
777 priv->rf_mode = XC_RF_MODE_AIR;
778 priv->freq_offset = 1750000;
779 priv->video_standard = DTV6;
781 case SYS_DVBC_ANNEX_B:
782 dprintk(1, "%s() QAM modulation\n", __func__);
783 priv->rf_mode = XC_RF_MODE_CABLE;
784 priv->freq_offset = 1750000;
785 priv->video_standard = DTV6;
788 /* All ISDB-T are currently for 6 MHz bw */
791 /* fall to OFDM handling */
795 dprintk(1, "%s() OFDM\n", __func__);
798 priv->video_standard = DTV6;
799 priv->freq_offset = 1750000;
802 priv->video_standard = DTV7;
803 priv->freq_offset = 2250000;
806 priv->video_standard = DTV8;
807 priv->freq_offset = 2750000;
810 printk(KERN_ERR "xc5000 bandwidth not set!\n");
813 priv->rf_mode = XC_RF_MODE_AIR;
815 case SYS_DVBC_ANNEX_A:
816 case SYS_DVBC_ANNEX_C:
817 dprintk(1, "%s() QAM modulation\n", __func__);
818 priv->rf_mode = XC_RF_MODE_CABLE;
820 priv->video_standard = DTV6;
821 priv->freq_offset = 1750000;
823 } else if (bw <= 7000000) {
824 priv->video_standard = DTV7;
825 priv->freq_offset = 2250000;
828 priv->video_standard = DTV7_8;
829 priv->freq_offset = 2750000;
832 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
836 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
840 priv->freq_hz = freq - priv->freq_offset;
841 priv->mode = V4L2_TUNER_DIGITAL_TV;
843 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
844 __func__, freq, priv->freq_hz);
846 return xc5000_tune_digital(fe);
849 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
851 struct xc5000_priv *priv = fe->tuner_priv;
855 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
857 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
863 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
864 ret == 0 ? "True" : "False", id);
868 static void xc5000_config_tv(struct dvb_frontend *fe,
869 struct analog_parameters *params)
871 struct xc5000_priv *priv = fe->tuner_priv;
873 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
874 __func__, params->frequency);
876 /* Fix me: it could be air. */
877 priv->rf_mode = params->mode;
878 if (params->mode > XC_RF_MODE_CABLE)
879 priv->rf_mode = XC_RF_MODE_CABLE;
881 /* params->frequency is in units of 62.5khz */
882 priv->freq_hz = params->frequency * 62500;
884 /* FIX ME: Some video standards may have several possible audio
885 standards. We simply default to one of them here.
887 if (params->std & V4L2_STD_MN) {
888 /* default to BTSC audio standard */
889 priv->video_standard = MN_NTSC_PAL_BTSC;
893 if (params->std & V4L2_STD_PAL_BG) {
894 /* default to NICAM audio standard */
895 priv->video_standard = BG_PAL_NICAM;
899 if (params->std & V4L2_STD_PAL_I) {
900 /* default to NICAM audio standard */
901 priv->video_standard = I_PAL_NICAM;
905 if (params->std & V4L2_STD_PAL_DK) {
906 /* default to NICAM audio standard */
907 priv->video_standard = DK_PAL_NICAM;
911 if (params->std & V4L2_STD_SECAM_DK) {
912 /* default to A2 DK1 audio standard */
913 priv->video_standard = DK_SECAM_A2DK1;
917 if (params->std & V4L2_STD_SECAM_L) {
918 priv->video_standard = L_SECAM_NICAM;
922 if (params->std & V4L2_STD_SECAM_LC) {
923 priv->video_standard = LC_SECAM_NICAM;
928 static int xc5000_set_tv_freq(struct dvb_frontend *fe)
930 struct xc5000_priv *priv = fe->tuner_priv;
935 ret = xc_set_signal_source(priv, priv->rf_mode);
938 "xc5000: xc_set_signal_source(%d) failed\n",
943 ret = xc_set_tv_standard(priv,
944 xc5000_standard[priv->video_standard].video_mode,
945 xc5000_standard[priv->video_standard].audio_mode, 0);
947 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
951 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
953 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
958 if (priv->pll_register_no != 0) {
960 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
961 if (pll_lock_status > 63) {
962 /* PLL is unlocked, force reload of the firmware */
963 dprintk(1, "xc5000: PLL not locked (0x%x). Reloading...\n",
965 if (xc_load_fw_and_init_tuner(fe, 1) != 0) {
966 printk(KERN_ERR "xc5000: Unable to reload fw\n");
976 static int xc5000_config_radio(struct dvb_frontend *fe,
977 struct analog_parameters *params)
980 struct xc5000_priv *priv = fe->tuner_priv;
982 dprintk(1, "%s() frequency=%d (in units of khz)\n",
983 __func__, params->frequency);
985 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
986 dprintk(1, "%s() radio input not configured\n", __func__);
990 priv->freq_hz = params->frequency * 125 / 2;
991 priv->rf_mode = XC_RF_MODE_AIR;
996 static int xc5000_set_radio_freq(struct dvb_frontend *fe)
998 struct xc5000_priv *priv = fe->tuner_priv;
1002 if (priv->radio_input == XC5000_RADIO_FM1)
1003 radio_input = FM_RADIO_INPUT1;
1004 else if (priv->radio_input == XC5000_RADIO_FM2)
1005 radio_input = FM_RADIO_INPUT2;
1006 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
1007 radio_input = FM_RADIO_INPUT1_MONO;
1009 dprintk(1, "%s() unknown radio input %d\n", __func__,
1014 ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode,
1015 xc5000_standard[radio_input].audio_mode, radio_input);
1018 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
1022 ret = xc_set_signal_source(priv, priv->rf_mode);
1025 "xc5000: xc_set_signal_source(%d) failed\n",
1030 if ((priv->radio_input == XC5000_RADIO_FM1) ||
1031 (priv->radio_input == XC5000_RADIO_FM2))
1032 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1033 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
1034 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1036 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1041 static int xc5000_set_params(struct dvb_frontend *fe)
1043 struct xc5000_priv *priv = fe->tuner_priv;
1045 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1046 dprintk(1, "Unable to load firmware and init tuner\n");
1050 switch (priv->mode) {
1051 case V4L2_TUNER_RADIO:
1052 return xc5000_set_radio_freq(fe);
1053 case V4L2_TUNER_ANALOG_TV:
1054 return xc5000_set_tv_freq(fe);
1055 case V4L2_TUNER_DIGITAL_TV:
1056 return xc5000_tune_digital(fe);
1062 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1063 struct analog_parameters *params)
1065 struct xc5000_priv *priv = fe->tuner_priv;
1068 if (priv->i2c_props.adap == NULL)
1071 switch (params->mode) {
1072 case V4L2_TUNER_RADIO:
1073 ret = xc5000_config_radio(fe, params);
1077 case V4L2_TUNER_ANALOG_TV:
1078 xc5000_config_tv(fe, params);
1083 priv->mode = params->mode;
1085 return xc5000_set_params(fe);
1088 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1090 struct xc5000_priv *priv = fe->tuner_priv;
1091 dprintk(1, "%s()\n", __func__);
1092 *freq = priv->freq_hz + priv->freq_offset;
1096 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1098 struct xc5000_priv *priv = fe->tuner_priv;
1099 dprintk(1, "%s()\n", __func__);
1100 *freq = priv->if_khz * 1000;
1104 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1106 struct xc5000_priv *priv = fe->tuner_priv;
1107 dprintk(1, "%s()\n", __func__);
1109 *bw = priv->bandwidth;
1113 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1115 struct xc5000_priv *priv = fe->tuner_priv;
1116 u16 lock_status = 0;
1118 xc_get_lock_status(priv, &lock_status);
1120 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1122 *status = lock_status;
1127 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1129 struct xc5000_priv *priv = fe->tuner_priv;
1130 const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id);
1131 const struct firmware *fw;
1133 u16 pll_lock_status;
1136 cancel_delayed_work(&priv->timer_sleep);
1138 if (!force && xc5000_is_firmware_loaded(fe) == 0)
1141 if (!priv->firmware) {
1142 ret = request_firmware(&fw, desired_fw->name,
1143 priv->i2c_props.adap->dev.parent);
1145 pr_err("xc5000: Upload failed. rc %d\n", ret);
1148 dprintk(1, "firmware read %Zu bytes.\n", fw->size);
1150 if (fw->size != desired_fw->size) {
1151 pr_err("xc5000: Firmware file with incorrect size\n");
1152 release_firmware(fw);
1155 priv->firmware = fw;
1157 fw = priv->firmware;
1159 /* Try up to 5 times to load firmware */
1160 for (i = 0; i < 5; i++) {
1162 printk(KERN_CONT " - retrying to upload firmware.\n");
1164 ret = xc5000_fwupload(fe, desired_fw, fw);
1170 if (priv->fw_checksum_supported) {
1171 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1173 "xc5000: FW checksum reading failed.");
1179 "xc5000: FW checksum failed = 0x%04x.",
1185 /* Start the tuner self-calibration process */
1186 ret = xc_initialize(priv);
1189 "xc5000: Can't request Self-callibration.");
1193 /* Wait for calibration to complete.
1194 * We could continue but XC5000 will clock stretch subsequent
1195 * I2C transactions until calibration is complete. This way we
1196 * don't have to rely on clock stretching working.
1200 if (priv->init_status_supported) {
1201 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1203 "xc5000: FW failed reading init status.");
1209 "xc5000: FW init status failed = 0x%04x.",
1215 if (priv->pll_register_no) {
1216 xc5000_readreg(priv, priv->pll_register_no,
1218 if (pll_lock_status > 63) {
1219 /* PLL is unlocked, force reload of the firmware */
1221 "xc5000: PLL not running after fwload.");
1226 /* Default to "CABLE" mode */
1227 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1230 printk(KERN_ERR "xc5000: can't set to cable mode.");
1235 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1238 printk(KERN_CONT " - too many retries. Giving up\n");
1243 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1245 struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1247 struct dvb_frontend *fe = priv->fe;
1250 dprintk(1, "%s()\n", __func__);
1252 /* According to Xceive technical support, the "powerdown" register
1253 was removed in newer versions of the firmware. The "supported"
1254 way to sleep the tuner is to pull the reset pin low for 10ms */
1255 ret = xc5000_tuner_reset(fe);
1258 "xc5000: %s() unable to shutdown tuner\n",
1262 static int xc5000_sleep(struct dvb_frontend *fe)
1264 struct xc5000_priv *priv = fe->tuner_priv;
1266 dprintk(1, "%s()\n", __func__);
1268 /* Avoid firmware reload on slow devices */
1272 schedule_delayed_work(&priv->timer_sleep,
1273 msecs_to_jiffies(XC5000_SLEEP_TIME));
1278 static int xc5000_suspend(struct dvb_frontend *fe)
1280 struct xc5000_priv *priv = fe->tuner_priv;
1283 dprintk(1, "%s()\n", __func__);
1285 cancel_delayed_work(&priv->timer_sleep);
1287 ret = xc5000_tuner_reset(fe);
1290 "xc5000: %s() unable to shutdown tuner\n",
1296 static int xc5000_resume(struct dvb_frontend *fe)
1298 struct xc5000_priv *priv = fe->tuner_priv;
1300 dprintk(1, "%s()\n", __func__);
1302 /* suspended before firmware is loaded.
1303 Avoid firmware load in resume path. */
1304 if (!priv->firmware)
1307 return xc5000_set_params(fe);
1310 static int xc5000_init(struct dvb_frontend *fe)
1312 struct xc5000_priv *priv = fe->tuner_priv;
1313 dprintk(1, "%s()\n", __func__);
1315 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1316 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1321 xc_debug_dump(priv);
1326 static int xc5000_release(struct dvb_frontend *fe)
1328 struct xc5000_priv *priv = fe->tuner_priv;
1330 dprintk(1, "%s()\n", __func__);
1332 mutex_lock(&xc5000_list_mutex);
1335 cancel_delayed_work(&priv->timer_sleep);
1336 hybrid_tuner_release_state(priv);
1338 release_firmware(priv->firmware);
1341 mutex_unlock(&xc5000_list_mutex);
1343 fe->tuner_priv = NULL;
1348 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1350 struct xc5000_priv *priv = fe->tuner_priv;
1351 struct xc5000_config *p = priv_cfg;
1353 dprintk(1, "%s()\n", __func__);
1356 priv->if_khz = p->if_khz;
1359 priv->radio_input = p->radio_input;
1365 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1367 .name = "Xceive XC5000",
1368 .frequency_min = 1000000,
1369 .frequency_max = 1023000000,
1370 .frequency_step = 50000,
1373 .release = xc5000_release,
1374 .init = xc5000_init,
1375 .sleep = xc5000_sleep,
1376 .suspend = xc5000_suspend,
1377 .resume = xc5000_resume,
1379 .set_config = xc5000_set_config,
1380 .set_params = xc5000_set_digital_params,
1381 .set_analog_params = xc5000_set_analog_params,
1382 .get_frequency = xc5000_get_frequency,
1383 .get_if_frequency = xc5000_get_if_frequency,
1384 .get_bandwidth = xc5000_get_bandwidth,
1385 .get_status = xc5000_get_status
1388 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1389 struct i2c_adapter *i2c,
1390 const struct xc5000_config *cfg)
1392 struct xc5000_priv *priv = NULL;
1396 dprintk(1, "%s(%d-%04x)\n", __func__,
1397 i2c ? i2c_adapter_id(i2c) : -1,
1398 cfg ? cfg->i2c_address : -1);
1400 mutex_lock(&xc5000_list_mutex);
1402 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1403 hybrid_tuner_instance_list,
1404 i2c, cfg->i2c_address, "xc5000");
1409 /* new tuner instance */
1410 priv->bandwidth = 6000000;
1411 fe->tuner_priv = priv;
1413 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1416 /* existing tuner instance */
1417 fe->tuner_priv = priv;
1421 if (priv->if_khz == 0) {
1422 /* If the IF hasn't been set yet, use the value provided by
1423 the caller (occurs in hybrid devices where the analog
1424 call to xc5000_attach occurs before the digital side) */
1425 priv->if_khz = cfg->if_khz;
1428 if (priv->xtal_khz == 0)
1429 priv->xtal_khz = cfg->xtal_khz;
1431 if (priv->radio_input == 0)
1432 priv->radio_input = cfg->radio_input;
1434 /* don't override chip id if it's already been set
1435 unless explicitly specified */
1436 if ((priv->chip_id == 0) || (cfg->chip_id))
1437 /* use default chip id if none specified, set to 0 so
1438 it can be overridden if this is a hybrid driver */
1439 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1441 /* Check if firmware has been loaded. It is possible that another
1442 instance of the driver has loaded the firmware.
1444 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1448 case XC_PRODUCT_ID_FW_LOADED:
1450 "xc5000: Successfully identified at address 0x%02x\n",
1453 "xc5000: Firmware has been loaded previously\n");
1455 case XC_PRODUCT_ID_FW_NOT_LOADED:
1457 "xc5000: Successfully identified at address 0x%02x\n",
1460 "xc5000: Firmware has not been loaded previously\n");
1464 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1465 cfg->i2c_address, id);
1469 mutex_unlock(&xc5000_list_mutex);
1471 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1472 sizeof(struct dvb_tuner_ops));
1476 mutex_unlock(&xc5000_list_mutex);
1481 EXPORT_SYMBOL(xc5000_attach);
1483 MODULE_AUTHOR("Steven Toth");
1484 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1485 MODULE_LICENSE("GPL");
1486 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1487 MODULE_FIRMWARE(XC5000C_FIRMWARE);