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.
20 #include <linux/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/videodev2.h>
23 #include <linux/delay.h>
24 #include <linux/workqueue.h>
25 #include <linux/dvb/frontend.h>
26 #include <linux/i2c.h>
28 #include "dvb_frontend.h"
31 #include "tuner-i2c.h"
34 module_param(debug, int, 0644);
35 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
37 static int no_poweroff;
38 module_param(no_poweroff, int, 0644);
39 MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
40 "\t\t1 keep device energized and with tuner ready all the times.\n"
41 "\t\tFaster, but consumes more power and keeps the device hotter");
43 static DEFINE_MUTEX(xc5000_list_mutex);
44 static LIST_HEAD(hybrid_tuner_instance_list);
46 #define dprintk(level, fmt, arg...) if (debug >= level) \
47 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
50 struct tuner_i2c_props i2c_props;
51 struct list_head hybrid_tuner_instance_list;
55 u32 freq_hz, freq_offset;
65 u8 init_status_supported;
66 u8 fw_checksum_supported;
68 struct dvb_frontend *fe;
69 struct delayed_work timer_sleep;
71 const struct firmware *firmware;
75 #define MAX_TV_STANDARD 24
76 #define XC_MAX_I2C_WRITE_LENGTH 64
78 /* Time to suspend after the .sleep callback is called */
79 #define XC5000_SLEEP_TIME 5000 /* ms */
82 #define XC_RF_MODE_AIR 0
83 #define XC_RF_MODE_CABLE 1
86 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
87 #define XC_PRODUCT_ID_FW_LOADED 0x1388
90 #define XREG_INIT 0x00
91 #define XREG_VIDEO_MODE 0x01
92 #define XREG_AUDIO_MODE 0x02
93 #define XREG_RF_FREQ 0x03
94 #define XREG_D_CODE 0x04
95 #define XREG_IF_OUT 0x05
96 #define XREG_SEEK_MODE 0x07
97 #define XREG_POWER_DOWN 0x0A /* Obsolete */
98 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
99 #define XREG_OUTPUT_AMP 0x0B
100 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
101 #define XREG_SMOOTHEDCVBS 0x0E
102 #define XREG_XTALFREQ 0x0F
103 #define XREG_FINERFREQ 0x10
104 #define XREG_DDIMODE 0x11
106 #define XREG_ADC_ENV 0x00
107 #define XREG_QUALITY 0x01
108 #define XREG_FRAME_LINES 0x02
109 #define XREG_HSYNC_FREQ 0x03
110 #define XREG_LOCK 0x04
111 #define XREG_FREQ_ERROR 0x05
112 #define XREG_SNR 0x06
113 #define XREG_VERSION 0x07
114 #define XREG_PRODUCT_ID 0x08
115 #define XREG_BUSY 0x09
116 #define XREG_BUILD 0x0D
117 #define XREG_TOTALGAIN 0x0F
118 #define XREG_FW_CHECKSUM 0x12
119 #define XREG_INIT_STATUS 0x13
122 Basic firmware description. This will remain with
123 the driver for documentation purposes.
125 This represents an I2C firmware file encoded as a
126 string of unsigned char. Format is as follows:
128 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
129 char[1 ]=len0_LSB -> length of first write transaction
130 char[2 ]=data0 -> first byte to be sent
134 char[M ]=dataN -> last byte to be sent
135 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
136 char[M+2]=len1_LSB -> length of second write transaction
142 The [len] value should be interpreted as follows:
144 len= len_MSB _ len_LSB
145 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
146 len=0000_0000_0000_0000 : Reset command: Do hardware reset
147 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
148 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
150 For the RESET and WAIT commands, the two following bytes will contain
151 immediately the length of the following transaction.
154 struct XC_TV_STANDARD {
160 /* Tuner standards */
161 #define MN_NTSC_PAL_BTSC 0
162 #define MN_NTSC_PAL_A2 1
163 #define MN_NTSC_PAL_EIAJ 2
164 #define MN_NTSC_PAL_MONO 3
166 #define BG_PAL_NICAM 5
167 #define BG_PAL_MONO 6
168 #define I_PAL_NICAM 7
169 #define I_PAL_NICAM_MONO 8
171 #define DK_PAL_NICAM 10
172 #define DK_PAL_MONO 11
173 #define DK_SECAM_A2DK1 12
174 #define DK_SECAM_A2LDK3 13
175 #define DK_SECAM_A2MONO 14
176 #define L_SECAM_NICAM 15
177 #define LC_SECAM_NICAM 16
182 #define FM_RADIO_INPUT2 21
183 #define FM_RADIO_INPUT1 22
184 #define FM_RADIO_INPUT1_MONO 23
186 static struct XC_TV_STANDARD xc5000_standard[MAX_TV_STANDARD] = {
187 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
188 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
189 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
190 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
191 {"B/G-PAL-A2", 0x0A00, 0x8049},
192 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
193 {"B/G-PAL-MONO", 0x0878, 0x8059},
194 {"I-PAL-NICAM", 0x1080, 0x8009},
195 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
196 {"D/K-PAL-A2", 0x1600, 0x8009},
197 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
198 {"D/K-PAL-MONO", 0x1478, 0x8009},
199 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
200 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
201 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
202 {"L-SECAM-NICAM", 0x8E82, 0x0009},
203 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
204 {"DTV6", 0x00C0, 0x8002},
205 {"DTV8", 0x00C0, 0x800B},
206 {"DTV7/8", 0x00C0, 0x801B},
207 {"DTV7", 0x00C0, 0x8007},
208 {"FM Radio-INPUT2", 0x9802, 0x9002},
209 {"FM Radio-INPUT1", 0x0208, 0x9002},
210 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
214 struct xc5000_fw_cfg {
218 u8 init_status_supported;
219 u8 fw_checksum_supported;
222 #define XC5000A_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
223 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
224 .name = XC5000A_FIRMWARE,
229 #define XC5000C_FIRMWARE "dvb-fe-xc5000c-4.1.30.7.fw"
230 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
231 .name = XC5000C_FIRMWARE,
234 .init_status_supported = 1,
235 .fw_checksum_supported = 1,
238 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
243 return &xc5000a_1_6_114;
245 return &xc5000c_41_024_5;
249 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force);
250 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
251 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
252 static int xc5000_tuner_reset(struct dvb_frontend *fe);
254 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
256 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
257 .flags = 0, .buf = buf, .len = len };
259 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
260 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
267 /* This routine is never used because the only time we read data from the
268 i2c bus is when we read registers, and we want that to be an atomic i2c
269 transaction in case we are on a multi-master bus */
270 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
272 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
273 .flags = I2C_M_RD, .buf = buf, .len = len };
275 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
276 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
283 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
285 u8 buf[2] = { reg >> 8, reg & 0xff };
286 u8 bval[2] = { 0, 0 };
287 struct i2c_msg msg[2] = {
288 { .addr = priv->i2c_props.addr,
289 .flags = 0, .buf = &buf[0], .len = 2 },
290 { .addr = priv->i2c_props.addr,
291 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
294 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
295 printk(KERN_WARNING "xc5000: I2C read failed\n");
299 *val = (bval[0] << 8) | bval[1];
303 static int xc5000_tuner_reset(struct dvb_frontend *fe)
305 struct xc5000_priv *priv = fe->tuner_priv;
308 dprintk(1, "%s()\n", __func__);
311 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
313 priv->i2c_props.adap->algo_data,
314 DVB_FRONTEND_COMPONENT_TUNER,
315 XC5000_TUNER_RESET, 0);
317 printk(KERN_ERR "xc5000: reset failed\n");
321 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
327 static int xc_write_reg(struct xc5000_priv *priv, u16 reg_addr, u16 i2c_data)
330 int watch_dog_timer = 100;
333 buf[0] = (reg_addr >> 8) & 0xFF;
334 buf[1] = reg_addr & 0xFF;
335 buf[2] = (i2c_data >> 8) & 0xFF;
336 buf[3] = i2c_data & 0xFF;
337 result = xc_send_i2c_data(priv, buf, 4);
339 /* wait for busy flag to clear */
340 while ((watch_dog_timer > 0) && (result == 0)) {
341 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
343 if ((buf[0] == 0) && (buf[1] == 0)) {
344 /* busy flag cleared */
347 msleep(5); /* wait 5 ms */
353 if (watch_dog_timer <= 0)
359 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
361 struct xc5000_priv *priv = fe->tuner_priv;
363 int i, nbytes_to_send, result;
364 unsigned int len, pos, index;
365 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
368 while ((i2c_sequence[index] != 0xFF) ||
369 (i2c_sequence[index + 1] != 0xFF)) {
370 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
373 result = xc5000_tuner_reset(fe);
377 } else if (len & 0x8000) {
379 msleep(len & 0x7FFF);
382 /* Send i2c data whilst ensuring individual transactions
383 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
386 buf[0] = i2c_sequence[index];
387 buf[1] = i2c_sequence[index + 1];
390 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
392 XC_MAX_I2C_WRITE_LENGTH;
394 nbytes_to_send = (len - pos + 2);
395 for (i = 2; i < nbytes_to_send; i++) {
396 buf[i] = i2c_sequence[index + pos +
399 result = xc_send_i2c_data(priv, buf,
405 pos += nbytes_to_send - 2;
413 static int xc_initialize(struct xc5000_priv *priv)
415 dprintk(1, "%s()\n", __func__);
416 return xc_write_reg(priv, XREG_INIT, 0);
419 static int xc_set_tv_standard(struct xc5000_priv *priv,
420 u16 video_mode, u16 audio_mode, u8 radio_mode)
423 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
425 dprintk(1, "%s() Standard = %s\n",
427 xc5000_standard[radio_mode].name);
429 dprintk(1, "%s() Standard = %s\n",
431 xc5000_standard[priv->video_standard].name);
434 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
436 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
441 static int xc_set_signal_source(struct xc5000_priv *priv, u16 rf_mode)
443 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
444 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
446 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
447 rf_mode = XC_RF_MODE_CABLE;
449 "%s(), Invalid mode, defaulting to CABLE",
452 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
455 static const struct dvb_tuner_ops xc5000_tuner_ops;
457 static int xc_set_rf_frequency(struct xc5000_priv *priv, u32 freq_hz)
461 dprintk(1, "%s(%u)\n", __func__, freq_hz);
463 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
464 (freq_hz < xc5000_tuner_ops.info.frequency_min))
467 freq_code = (u16)(freq_hz / 15625);
469 /* Starting in firmware version 1.1.44, Xceive recommends using the
470 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
471 only be used for fast scanning for channel lock) */
472 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
476 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
478 u32 freq_code = (freq_khz * 1024)/1000;
479 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
480 __func__, freq_khz, freq_code);
482 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
486 static int xc_get_adc_envelope(struct xc5000_priv *priv, u16 *adc_envelope)
488 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
491 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
497 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®_data);
502 (*freq_error_hz) = (tmp * 15625) / 1000;
506 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
508 return xc5000_readreg(priv, XREG_LOCK, lock_status);
511 static int xc_get_version(struct xc5000_priv *priv,
512 u8 *hw_majorversion, u8 *hw_minorversion,
513 u8 *fw_majorversion, u8 *fw_minorversion)
518 result = xc5000_readreg(priv, XREG_VERSION, &data);
522 (*hw_majorversion) = (data >> 12) & 0x0F;
523 (*hw_minorversion) = (data >> 8) & 0x0F;
524 (*fw_majorversion) = (data >> 4) & 0x0F;
525 (*fw_minorversion) = data & 0x0F;
530 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
532 return xc5000_readreg(priv, XREG_BUILD, buildrev);
535 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
540 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®_data);
544 (*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100;
548 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
550 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
553 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
555 return xc5000_readreg(priv, XREG_QUALITY, quality);
558 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
560 return xc5000_readreg(priv, XREG_SNR, snr);
563 static int xc_get_totalgain(struct xc5000_priv *priv, u16 *totalgain)
565 return xc5000_readreg(priv, XREG_TOTALGAIN, totalgain);
568 static u16 wait_for_lock(struct xc5000_priv *priv)
571 int watch_dog_count = 40;
573 while ((lock_state == 0) && (watch_dog_count > 0)) {
574 xc_get_lock_status(priv, &lock_state);
575 if (lock_state != 1) {
583 #define XC_TUNE_ANALOG 0
584 #define XC_TUNE_DIGITAL 1
585 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
589 dprintk(1, "%s(%u)\n", __func__, freq_hz);
591 if (xc_set_rf_frequency(priv, freq_hz) != 0)
594 if (mode == XC_TUNE_ANALOG) {
595 if (wait_for_lock(priv) == 1)
602 static int xc_set_xtal(struct dvb_frontend *fe)
604 struct xc5000_priv *priv = fe->tuner_priv;
607 switch (priv->chip_id) {
610 /* 32.000 MHz xtal is default */
613 switch (priv->xtal_khz) {
616 /* 32.000 MHz xtal is default */
619 /* 31.875 MHz xtal configuration */
620 ret = xc_write_reg(priv, 0x000f, 0x8081);
628 static int xc5000_fwupload(struct dvb_frontend *fe,
629 const struct xc5000_fw_cfg *desired_fw,
630 const struct firmware *fw)
632 struct xc5000_priv *priv = fe->tuner_priv;
635 /* request the firmware, this will block and timeout */
636 dprintk(1, "waiting for firmware upload (%s)...\n",
639 priv->pll_register_no = desired_fw->pll_reg;
640 priv->init_status_supported = desired_fw->init_status_supported;
641 priv->fw_checksum_supported = desired_fw->fw_checksum_supported;
644 dprintk(1, "firmware uploading...\n");
645 ret = xc_load_i2c_sequence(fe, fw->data);
647 ret = xc_set_xtal(fe);
648 dprintk(1, "Firmware upload complete...\n");
650 printk(KERN_ERR "xc5000: firmware upload failed...\n");
655 static void xc_debug_dump(struct xc5000_priv *priv)
658 u32 freq_error_hz = 0;
660 u32 hsync_freq_hz = 0;
665 u8 hw_majorversion = 0, hw_minorversion = 0;
666 u8 fw_majorversion = 0, fw_minorversion = 0;
667 u16 fw_buildversion = 0;
670 /* Wait for stats to stabilize.
671 * Frame Lines needs two frame times after initial lock
672 * before it is valid.
676 xc_get_adc_envelope(priv, &adc_envelope);
677 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
679 xc_get_frequency_error(priv, &freq_error_hz);
680 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
682 xc_get_lock_status(priv, &lock_status);
683 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
686 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
687 &fw_majorversion, &fw_minorversion);
688 xc_get_buildversion(priv, &fw_buildversion);
689 dprintk(1, "*** HW: V%d.%d, FW: V %d.%d.%d\n",
690 hw_majorversion, hw_minorversion,
691 fw_majorversion, fw_minorversion, fw_buildversion);
693 xc_get_hsync_freq(priv, &hsync_freq_hz);
694 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
696 xc_get_frame_lines(priv, &frame_lines);
697 dprintk(1, "*** Frame lines = %d\n", frame_lines);
699 xc_get_quality(priv, &quality);
700 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality & 0x07);
702 xc_get_analogsnr(priv, &snr);
703 dprintk(1, "*** Unweighted analog SNR = %d dB\n", snr & 0x3f);
705 xc_get_totalgain(priv, &totalgain);
706 dprintk(1, "*** Total gain = %d.%d dB\n", totalgain / 256,
707 (totalgain % 256) * 100 / 256);
709 if (priv->pll_register_no) {
710 xc5000_readreg(priv, priv->pll_register_no, ®val);
711 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
715 static int xc5000_tune_digital(struct dvb_frontend *fe)
717 struct xc5000_priv *priv = fe->tuner_priv;
719 u32 bw = fe->dtv_property_cache.bandwidth_hz;
721 ret = xc_set_signal_source(priv, priv->rf_mode);
724 "xc5000: xc_set_signal_source(%d) failed\n",
729 ret = xc_set_tv_standard(priv,
730 xc5000_standard[priv->video_standard].video_mode,
731 xc5000_standard[priv->video_standard].audio_mode, 0);
733 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
737 ret = xc_set_IF_frequency(priv, priv->if_khz);
739 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
744 dprintk(1, "%s() setting OUTPUT_AMP to 0x%x\n",
745 __func__, priv->output_amp);
746 xc_write_reg(priv, XREG_OUTPUT_AMP, priv->output_amp);
748 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
753 priv->bandwidth = bw;
758 static int xc5000_set_digital_params(struct dvb_frontend *fe)
761 struct xc5000_priv *priv = fe->tuner_priv;
762 u32 bw = fe->dtv_property_cache.bandwidth_hz;
763 u32 freq = fe->dtv_property_cache.frequency;
764 u32 delsys = fe->dtv_property_cache.delivery_system;
766 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
767 dprintk(1, "Unable to load firmware and init tuner\n");
771 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
775 dprintk(1, "%s() VSB modulation\n", __func__);
776 priv->rf_mode = XC_RF_MODE_AIR;
777 priv->freq_offset = 1750000;
778 priv->video_standard = DTV6;
780 case SYS_DVBC_ANNEX_B:
781 dprintk(1, "%s() QAM modulation\n", __func__);
782 priv->rf_mode = XC_RF_MODE_CABLE;
783 priv->freq_offset = 1750000;
784 priv->video_standard = DTV6;
787 /* All ISDB-T are currently for 6 MHz bw */
790 /* fall to OFDM handling */
794 dprintk(1, "%s() OFDM\n", __func__);
797 priv->video_standard = DTV6;
798 priv->freq_offset = 1750000;
801 priv->video_standard = DTV7;
802 priv->freq_offset = 2250000;
805 priv->video_standard = DTV8;
806 priv->freq_offset = 2750000;
809 printk(KERN_ERR "xc5000 bandwidth not set!\n");
812 priv->rf_mode = XC_RF_MODE_AIR;
814 case SYS_DVBC_ANNEX_A:
815 case SYS_DVBC_ANNEX_C:
816 dprintk(1, "%s() QAM modulation\n", __func__);
817 priv->rf_mode = XC_RF_MODE_CABLE;
819 priv->video_standard = DTV6;
820 priv->freq_offset = 1750000;
822 } else if (bw <= 7000000) {
823 priv->video_standard = DTV7;
824 priv->freq_offset = 2250000;
827 priv->video_standard = DTV7_8;
828 priv->freq_offset = 2750000;
831 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
835 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
839 priv->freq_hz = freq - priv->freq_offset;
840 priv->mode = V4L2_TUNER_DIGITAL_TV;
842 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
843 __func__, freq, priv->freq_hz);
845 return xc5000_tune_digital(fe);
848 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
850 struct xc5000_priv *priv = fe->tuner_priv;
854 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
856 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
862 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
863 ret == 0 ? "True" : "False", id);
867 static void xc5000_config_tv(struct dvb_frontend *fe,
868 struct analog_parameters *params)
870 struct xc5000_priv *priv = fe->tuner_priv;
872 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
873 __func__, params->frequency);
875 /* Fix me: it could be air. */
876 priv->rf_mode = params->mode;
877 if (params->mode > XC_RF_MODE_CABLE)
878 priv->rf_mode = XC_RF_MODE_CABLE;
880 /* params->frequency is in units of 62.5khz */
881 priv->freq_hz = params->frequency * 62500;
883 /* FIX ME: Some video standards may have several possible audio
884 standards. We simply default to one of them here.
886 if (params->std & V4L2_STD_MN) {
887 /* default to BTSC audio standard */
888 priv->video_standard = MN_NTSC_PAL_BTSC;
892 if (params->std & V4L2_STD_PAL_BG) {
893 /* default to NICAM audio standard */
894 priv->video_standard = BG_PAL_NICAM;
898 if (params->std & V4L2_STD_PAL_I) {
899 /* default to NICAM audio standard */
900 priv->video_standard = I_PAL_NICAM;
904 if (params->std & V4L2_STD_PAL_DK) {
905 /* default to NICAM audio standard */
906 priv->video_standard = DK_PAL_NICAM;
910 if (params->std & V4L2_STD_SECAM_DK) {
911 /* default to A2 DK1 audio standard */
912 priv->video_standard = DK_SECAM_A2DK1;
916 if (params->std & V4L2_STD_SECAM_L) {
917 priv->video_standard = L_SECAM_NICAM;
921 if (params->std & V4L2_STD_SECAM_LC) {
922 priv->video_standard = LC_SECAM_NICAM;
927 static int xc5000_set_tv_freq(struct dvb_frontend *fe)
929 struct xc5000_priv *priv = fe->tuner_priv;
934 ret = xc_set_signal_source(priv, priv->rf_mode);
937 "xc5000: xc_set_signal_source(%d) failed\n",
942 ret = xc_set_tv_standard(priv,
943 xc5000_standard[priv->video_standard].video_mode,
944 xc5000_standard[priv->video_standard].audio_mode, 0);
946 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
950 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
952 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
957 if (priv->pll_register_no != 0) {
959 xc5000_readreg(priv, priv->pll_register_no, &pll_lock_status);
960 if (pll_lock_status > 63) {
961 /* PLL is unlocked, force reload of the firmware */
962 dprintk(1, "xc5000: PLL not locked (0x%x). Reloading...\n",
964 if (xc_load_fw_and_init_tuner(fe, 1) != 0) {
965 printk(KERN_ERR "xc5000: Unable to reload fw\n");
975 static int xc5000_config_radio(struct dvb_frontend *fe,
976 struct analog_parameters *params)
979 struct xc5000_priv *priv = fe->tuner_priv;
981 dprintk(1, "%s() frequency=%d (in units of khz)\n",
982 __func__, params->frequency);
984 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
985 dprintk(1, "%s() radio input not configured\n", __func__);
989 priv->freq_hz = params->frequency * 125 / 2;
990 priv->rf_mode = XC_RF_MODE_AIR;
995 static int xc5000_set_radio_freq(struct dvb_frontend *fe)
997 struct xc5000_priv *priv = fe->tuner_priv;
1001 if (priv->radio_input == XC5000_RADIO_FM1)
1002 radio_input = FM_RADIO_INPUT1;
1003 else if (priv->radio_input == XC5000_RADIO_FM2)
1004 radio_input = FM_RADIO_INPUT2;
1005 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
1006 radio_input = FM_RADIO_INPUT1_MONO;
1008 dprintk(1, "%s() unknown radio input %d\n", __func__,
1013 ret = xc_set_tv_standard(priv, xc5000_standard[radio_input].video_mode,
1014 xc5000_standard[radio_input].audio_mode, radio_input);
1017 printk(KERN_ERR "xc5000: xc_set_tv_standard failed\n");
1021 ret = xc_set_signal_source(priv, priv->rf_mode);
1024 "xc5000: xc_set_signal_source(%d) failed\n",
1029 if ((priv->radio_input == XC5000_RADIO_FM1) ||
1030 (priv->radio_input == XC5000_RADIO_FM2))
1031 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
1032 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
1033 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
1035 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
1040 static int xc5000_set_params(struct dvb_frontend *fe)
1042 struct xc5000_priv *priv = fe->tuner_priv;
1044 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1045 dprintk(1, "Unable to load firmware and init tuner\n");
1049 switch (priv->mode) {
1050 case V4L2_TUNER_RADIO:
1051 return xc5000_set_radio_freq(fe);
1052 case V4L2_TUNER_ANALOG_TV:
1053 return xc5000_set_tv_freq(fe);
1054 case V4L2_TUNER_DIGITAL_TV:
1055 return xc5000_tune_digital(fe);
1061 static int xc5000_set_analog_params(struct dvb_frontend *fe,
1062 struct analog_parameters *params)
1064 struct xc5000_priv *priv = fe->tuner_priv;
1067 if (priv->i2c_props.adap == NULL)
1070 switch (params->mode) {
1071 case V4L2_TUNER_RADIO:
1072 ret = xc5000_config_radio(fe, params);
1076 case V4L2_TUNER_ANALOG_TV:
1077 xc5000_config_tv(fe, params);
1082 priv->mode = params->mode;
1084 return xc5000_set_params(fe);
1087 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1089 struct xc5000_priv *priv = fe->tuner_priv;
1090 dprintk(1, "%s()\n", __func__);
1091 *freq = priv->freq_hz + priv->freq_offset;
1095 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1097 struct xc5000_priv *priv = fe->tuner_priv;
1098 dprintk(1, "%s()\n", __func__);
1099 *freq = priv->if_khz * 1000;
1103 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1105 struct xc5000_priv *priv = fe->tuner_priv;
1106 dprintk(1, "%s()\n", __func__);
1108 *bw = priv->bandwidth;
1112 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1114 struct xc5000_priv *priv = fe->tuner_priv;
1115 u16 lock_status = 0;
1117 xc_get_lock_status(priv, &lock_status);
1119 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1121 *status = lock_status;
1126 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe, int force)
1128 struct xc5000_priv *priv = fe->tuner_priv;
1129 const struct xc5000_fw_cfg *desired_fw = xc5000_assign_firmware(priv->chip_id);
1130 const struct firmware *fw;
1132 u16 pll_lock_status;
1135 cancel_delayed_work(&priv->timer_sleep);
1137 if (!force && xc5000_is_firmware_loaded(fe) == 0)
1140 if (!priv->firmware) {
1141 ret = request_firmware(&fw, desired_fw->name,
1142 priv->i2c_props.adap->dev.parent);
1144 pr_err("xc5000: Upload failed. rc %d\n", ret);
1147 dprintk(1, "firmware read %zu bytes.\n", fw->size);
1149 if (fw->size != desired_fw->size) {
1150 pr_err("xc5000: Firmware file with incorrect size\n");
1151 release_firmware(fw);
1154 priv->firmware = fw;
1156 fw = priv->firmware;
1158 /* Try up to 5 times to load firmware */
1159 for (i = 0; i < 5; i++) {
1161 printk(KERN_CONT " - retrying to upload firmware.\n");
1163 ret = xc5000_fwupload(fe, desired_fw, fw);
1169 if (priv->fw_checksum_supported) {
1170 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1172 "xc5000: FW checksum reading failed.");
1178 "xc5000: FW checksum failed = 0x%04x.",
1184 /* Start the tuner self-calibration process */
1185 ret = xc_initialize(priv);
1187 printk(KERN_ERR "xc5000: Can't request self-calibration.");
1191 /* Wait for calibration to complete.
1192 * We could continue but XC5000 will clock stretch subsequent
1193 * I2C transactions until calibration is complete. This way we
1194 * don't have to rely on clock stretching working.
1198 if (priv->init_status_supported) {
1199 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1201 "xc5000: FW failed reading init status.");
1207 "xc5000: FW init status failed = 0x%04x.",
1213 if (priv->pll_register_no) {
1214 xc5000_readreg(priv, priv->pll_register_no,
1216 if (pll_lock_status > 63) {
1217 /* PLL is unlocked, force reload of the firmware */
1219 "xc5000: PLL not running after fwload.");
1224 /* Default to "CABLE" mode */
1225 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1228 printk(KERN_ERR "xc5000: can't set to cable mode.");
1233 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1236 printk(KERN_CONT " - too many retries. Giving up\n");
1241 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1243 struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1245 struct dvb_frontend *fe = priv->fe;
1248 dprintk(1, "%s()\n", __func__);
1250 /* According to Xceive technical support, the "powerdown" register
1251 was removed in newer versions of the firmware. The "supported"
1252 way to sleep the tuner is to pull the reset pin low for 10ms */
1253 ret = xc5000_tuner_reset(fe);
1256 "xc5000: %s() unable to shutdown tuner\n",
1260 static int xc5000_sleep(struct dvb_frontend *fe)
1262 struct xc5000_priv *priv = fe->tuner_priv;
1264 dprintk(1, "%s()\n", __func__);
1266 /* Avoid firmware reload on slow devices */
1270 schedule_delayed_work(&priv->timer_sleep,
1271 msecs_to_jiffies(XC5000_SLEEP_TIME));
1276 static int xc5000_suspend(struct dvb_frontend *fe)
1278 struct xc5000_priv *priv = fe->tuner_priv;
1281 dprintk(1, "%s()\n", __func__);
1283 cancel_delayed_work(&priv->timer_sleep);
1285 ret = xc5000_tuner_reset(fe);
1288 "xc5000: %s() unable to shutdown tuner\n",
1294 static int xc5000_resume(struct dvb_frontend *fe)
1296 struct xc5000_priv *priv = fe->tuner_priv;
1298 dprintk(1, "%s()\n", __func__);
1300 /* suspended before firmware is loaded.
1301 Avoid firmware load in resume path. */
1302 if (!priv->firmware)
1305 return xc5000_set_params(fe);
1308 static int xc5000_init(struct dvb_frontend *fe)
1310 struct xc5000_priv *priv = fe->tuner_priv;
1311 dprintk(1, "%s()\n", __func__);
1313 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1314 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1319 xc_debug_dump(priv);
1324 static void xc5000_release(struct dvb_frontend *fe)
1326 struct xc5000_priv *priv = fe->tuner_priv;
1328 dprintk(1, "%s()\n", __func__);
1330 mutex_lock(&xc5000_list_mutex);
1333 cancel_delayed_work(&priv->timer_sleep);
1334 if (priv->firmware) {
1335 release_firmware(priv->firmware);
1336 priv->firmware = NULL;
1338 hybrid_tuner_release_state(priv);
1341 mutex_unlock(&xc5000_list_mutex);
1343 fe->tuner_priv = NULL;
1346 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1348 struct xc5000_priv *priv = fe->tuner_priv;
1349 struct xc5000_config *p = priv_cfg;
1351 dprintk(1, "%s()\n", __func__);
1354 priv->if_khz = p->if_khz;
1357 priv->radio_input = p->radio_input;
1360 priv->output_amp = p->output_amp;
1366 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1368 .name = "Xceive XC5000",
1369 .frequency_min = 1000000,
1370 .frequency_max = 1023000000,
1371 .frequency_step = 50000,
1374 .release = xc5000_release,
1375 .init = xc5000_init,
1376 .sleep = xc5000_sleep,
1377 .suspend = xc5000_suspend,
1378 .resume = xc5000_resume,
1380 .set_config = xc5000_set_config,
1381 .set_params = xc5000_set_digital_params,
1382 .set_analog_params = xc5000_set_analog_params,
1383 .get_frequency = xc5000_get_frequency,
1384 .get_if_frequency = xc5000_get_if_frequency,
1385 .get_bandwidth = xc5000_get_bandwidth,
1386 .get_status = xc5000_get_status
1389 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1390 struct i2c_adapter *i2c,
1391 const struct xc5000_config *cfg)
1393 struct xc5000_priv *priv = NULL;
1397 dprintk(1, "%s(%d-%04x)\n", __func__,
1398 i2c ? i2c_adapter_id(i2c) : -1,
1399 cfg ? cfg->i2c_address : -1);
1401 mutex_lock(&xc5000_list_mutex);
1403 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1404 hybrid_tuner_instance_list,
1405 i2c, cfg->i2c_address, "xc5000");
1410 /* new tuner instance */
1411 priv->bandwidth = 6000000;
1412 fe->tuner_priv = priv;
1414 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1417 /* existing tuner instance */
1418 fe->tuner_priv = priv;
1422 if (priv->if_khz == 0) {
1423 /* If the IF hasn't been set yet, use the value provided by
1424 the caller (occurs in hybrid devices where the analog
1425 call to xc5000_attach occurs before the digital side) */
1426 priv->if_khz = cfg->if_khz;
1429 if (priv->xtal_khz == 0)
1430 priv->xtal_khz = cfg->xtal_khz;
1432 if (priv->radio_input == 0)
1433 priv->radio_input = cfg->radio_input;
1435 /* don't override chip id if it's already been set
1436 unless explicitly specified */
1437 if ((priv->chip_id == 0) || (cfg->chip_id))
1438 /* use default chip id if none specified, set to 0 so
1439 it can be overridden if this is a hybrid driver */
1440 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1442 /* don't override output_amp if it's already been set
1443 unless explicitly specified */
1444 if ((priv->output_amp == 0) || (cfg->output_amp))
1445 /* use default output_amp value if none specified */
1446 priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
1448 /* Check if firmware has been loaded. It is possible that another
1449 instance of the driver has loaded the firmware.
1451 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1455 case XC_PRODUCT_ID_FW_LOADED:
1457 "xc5000: Successfully identified at address 0x%02x\n",
1460 "xc5000: Firmware has been loaded previously\n");
1462 case XC_PRODUCT_ID_FW_NOT_LOADED:
1464 "xc5000: Successfully identified at address 0x%02x\n",
1467 "xc5000: Firmware has not been loaded previously\n");
1471 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1472 cfg->i2c_address, id);
1476 mutex_unlock(&xc5000_list_mutex);
1478 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1479 sizeof(struct dvb_tuner_ops));
1483 mutex_unlock(&xc5000_list_mutex);
1488 EXPORT_SYMBOL(xc5000_attach);
1490 MODULE_AUTHOR("Steven Toth");
1491 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1492 MODULE_LICENSE("GPL");
1493 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1494 MODULE_FIRMWARE(XC5000C_FIRMWARE);