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>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/videodev2.h>
26 #include <linux/delay.h>
27 #include <linux/dvb/frontend.h>
28 #include <linux/i2c.h>
30 #include "dvb_frontend.h"
33 #include "tuner-i2c.h"
36 module_param(debug, int, 0644);
37 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39 static int xc5000_load_fw_on_attach;
40 module_param_named(init_fw, xc5000_load_fw_on_attach, int, 0644);
41 MODULE_PARM_DESC(init_fw, "Load firmware during driver initialization.");
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)
49 #define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.1.fw"
50 #define XC5000_DEFAULT_FIRMWARE_SIZE 12332
53 struct tuner_i2c_props i2c_props;
54 struct list_head hybrid_tuner_instance_list;
63 int (*tuner_callback) (void *priv, int command, int arg);
67 #define MAX_TV_STANDARD 23
68 #define XC_MAX_I2C_WRITE_LENGTH 64
71 #define XC_RF_MODE_AIR 0
72 #define XC_RF_MODE_CABLE 1
75 #define XC_RESULT_SUCCESS 0
76 #define XC_RESULT_RESET_FAILURE 1
77 #define XC_RESULT_I2C_WRITE_FAILURE 2
78 #define XC_RESULT_I2C_READ_FAILURE 3
79 #define XC_RESULT_OUT_OF_RANGE 5
82 #define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
83 #define XC_PRODUCT_ID_FW_LOADED 0x1388
86 #define XREG_INIT 0x00
87 #define XREG_VIDEO_MODE 0x01
88 #define XREG_AUDIO_MODE 0x02
89 #define XREG_RF_FREQ 0x03
90 #define XREG_D_CODE 0x04
91 #define XREG_IF_OUT 0x05
92 #define XREG_SEEK_MODE 0x07
93 #define XREG_POWER_DOWN 0x0A
94 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
95 #define XREG_SMOOTHEDCVBS 0x0E
96 #define XREG_XTALFREQ 0x0F
97 #define XREG_FINERFFREQ 0x10
98 #define XREG_DDIMODE 0x11
100 #define XREG_ADC_ENV 0x00
101 #define XREG_QUALITY 0x01
102 #define XREG_FRAME_LINES 0x02
103 #define XREG_HSYNC_FREQ 0x03
104 #define XREG_LOCK 0x04
105 #define XREG_FREQ_ERROR 0x05
106 #define XREG_SNR 0x06
107 #define XREG_VERSION 0x07
108 #define XREG_PRODUCT_ID 0x08
109 #define XREG_BUSY 0x09
112 Basic firmware description. This will remain with
113 the driver for documentation purposes.
115 This represents an I2C firmware file encoded as a
116 string of unsigned char. Format is as follows:
118 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
119 char[1 ]=len0_LSB -> length of first write transaction
120 char[2 ]=data0 -> first byte to be sent
124 char[M ]=dataN -> last byte to be sent
125 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
126 char[M+2]=len1_LSB -> length of second write transaction
132 The [len] value should be interpreted as follows:
134 len= len_MSB _ len_LSB
135 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
136 len=0000_0000_0000_0000 : Reset command: Do hardware reset
137 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
138 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
140 For the RESET and WAIT commands, the two following bytes will contain
141 immediately the length of the following transaction.
150 /* Tuner standards */
151 #define MN_NTSC_PAL_BTSC 0
152 #define MN_NTSC_PAL_A2 1
153 #define MN_NTSC_PAL_EIAJ 2
154 #define MN_NTSC_PAL_Mono 3
156 #define BG_PAL_NICAM 5
157 #define BG_PAL_MONO 6
158 #define I_PAL_NICAM 7
159 #define I_PAL_NICAM_MONO 8
161 #define DK_PAL_NICAM 10
162 #define DK_PAL_MONO 11
163 #define DK_SECAM_A2DK1 12
164 #define DK_SECAM_A2LDK3 13
165 #define DK_SECAM_A2MONO 14
166 #define L_SECAM_NICAM 15
167 #define LC_SECAM_NICAM 16
172 #define FM_Radio_INPUT2 21
173 #define FM_Radio_INPUT1 22
175 static XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
176 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
177 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
178 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
179 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
180 {"B/G-PAL-A2", 0x0A00, 0x8049},
181 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
182 {"B/G-PAL-MONO", 0x0878, 0x8059},
183 {"I-PAL-NICAM", 0x1080, 0x8009},
184 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
185 {"D/K-PAL-A2", 0x1600, 0x8009},
186 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
187 {"D/K-PAL-MONO", 0x1478, 0x8009},
188 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
189 {"D/K-SECAM-A2 L/DK3",0x0E00, 0x8009},
190 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
191 {"L-SECAM-NICAM", 0x8E82, 0x0009},
192 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
193 {"DTV6", 0x00C0, 0x8002},
194 {"DTV8", 0x00C0, 0x800B},
195 {"DTV7/8", 0x00C0, 0x801B},
196 {"DTV7", 0x00C0, 0x8007},
197 {"FM Radio-INPUT2", 0x9802, 0x9002},
198 {"FM Radio-INPUT1", 0x0208, 0x9002}
201 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
202 static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
203 static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
204 static void xc5000_TunerReset(struct dvb_frontend *fe);
206 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
208 return xc5000_writeregs(priv, buf, len)
209 ? XC_RESULT_I2C_WRITE_FAILURE : XC_RESULT_SUCCESS;
212 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
214 return xc5000_readregs(priv, buf, len)
215 ? XC_RESULT_I2C_READ_FAILURE : XC_RESULT_SUCCESS;
218 static int xc_reset(struct dvb_frontend *fe)
220 xc5000_TunerReset(fe);
221 return XC_RESULT_SUCCESS;
224 static void xc_wait(int wait_ms)
229 static void xc5000_TunerReset(struct dvb_frontend *fe)
231 struct xc5000_priv *priv = fe->tuner_priv;
234 dprintk(1, "%s()\n", __func__);
236 if (priv->tuner_callback) {
237 ret = priv->tuner_callback(priv->devptr, XC5000_TUNER_RESET, 0);
239 printk(KERN_ERR "xc5000: reset failed\n");
241 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
244 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
247 int WatchDogTimer = 5;
250 buf[0] = (regAddr >> 8) & 0xFF;
251 buf[1] = regAddr & 0xFF;
252 buf[2] = (i2cData >> 8) & 0xFF;
253 buf[3] = i2cData & 0xFF;
254 result = xc_send_i2c_data(priv, buf, 4);
255 if (result == XC_RESULT_SUCCESS) {
256 /* wait for busy flag to clear */
257 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
261 result = xc_send_i2c_data(priv, buf, 2);
262 if (result == XC_RESULT_SUCCESS) {
263 result = xc_read_i2c_data(priv, buf, 2);
264 if (result == XC_RESULT_SUCCESS) {
265 if ((buf[0] == 0) && (buf[1] == 0)) {
266 /* busy flag cleared */
269 xc_wait(100); /* wait 5 ms */
276 if (WatchDogTimer < 0)
277 result = XC_RESULT_I2C_WRITE_FAILURE;
282 static int xc_read_reg(struct xc5000_priv *priv, u16 regAddr, u16 *i2cData)
287 buf[0] = (regAddr >> 8) & 0xFF;
288 buf[1] = regAddr & 0xFF;
289 result = xc_send_i2c_data(priv, buf, 2);
290 if (result != XC_RESULT_SUCCESS)
293 result = xc_read_i2c_data(priv, buf, 2);
294 if (result != XC_RESULT_SUCCESS)
297 *i2cData = buf[0] * 256 + buf[1];
301 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
303 struct xc5000_priv *priv = fe->tuner_priv;
305 int i, nbytes_to_send, result;
306 unsigned int len, pos, index;
307 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
310 while ((i2c_sequence[index]!=0xFF) || (i2c_sequence[index+1]!=0xFF)) {
311 len = i2c_sequence[index]* 256 + i2c_sequence[index+1];
314 result = xc_reset(fe);
316 if (result != XC_RESULT_SUCCESS)
318 } else if (len & 0x8000) {
320 xc_wait(len & 0x7FFF);
323 /* Send i2c data whilst ensuring individual transactions
324 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
327 buf[0] = i2c_sequence[index];
328 buf[1] = i2c_sequence[index + 1];
331 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) {
332 nbytes_to_send = XC_MAX_I2C_WRITE_LENGTH;
334 nbytes_to_send = (len - pos + 2);
336 for (i=2; i<nbytes_to_send; i++) {
337 buf[i] = i2c_sequence[index + pos + i - 2];
339 result = xc_send_i2c_data(priv, buf, nbytes_to_send);
341 if (result != XC_RESULT_SUCCESS)
344 pos += nbytes_to_send - 2;
349 return XC_RESULT_SUCCESS;
352 static int xc_initialize(struct xc5000_priv *priv)
354 dprintk(1, "%s()\n", __func__);
355 return xc_write_reg(priv, XREG_INIT, 0);
358 static int xc_SetTVStandard(struct xc5000_priv *priv,
359 u16 VideoMode, u16 AudioMode)
362 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
363 dprintk(1, "%s() Standard = %s\n",
365 XC5000_Standard[priv->video_standard].Name);
367 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
368 if (ret == XC_RESULT_SUCCESS)
369 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
374 static int xc_shutdown(struct xc5000_priv *priv)
376 return XC_RESULT_SUCCESS;
377 /* Fixme: cannot bring tuner back alive once shutdown
378 * without reloading the driver modules.
379 * return xc_write_reg(priv, XREG_POWER_DOWN, 0);
383 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
385 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
386 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
388 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE))
390 rf_mode = XC_RF_MODE_CABLE;
392 "%s(), Invalid mode, defaulting to CABLE",
395 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
398 static const struct dvb_tuner_ops xc5000_tuner_ops;
400 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
404 dprintk(1, "%s(%u)\n", __func__, freq_hz);
406 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
407 (freq_hz < xc5000_tuner_ops.info.frequency_min))
408 return XC_RESULT_OUT_OF_RANGE;
410 freq_code = (u16)(freq_hz / 15625);
412 return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
416 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
418 u32 freq_code = (freq_khz * 1024)/1000;
419 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
420 __func__, freq_khz, freq_code);
422 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
426 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
428 return xc_read_reg(priv, XREG_ADC_ENV, adc_envelope);
431 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
437 result = xc_read_reg(priv, XREG_FREQ_ERROR, ®Data);
442 (*freq_error_hz) = (tmp * 15625) / 1000;
446 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
448 return xc_read_reg(priv, XREG_LOCK, lock_status);
451 static int xc_get_version(struct xc5000_priv *priv,
452 u8 *hw_majorversion, u8 *hw_minorversion,
453 u8 *fw_majorversion, u8 *fw_minorversion)
458 result = xc_read_reg(priv, XREG_VERSION, &data);
462 (*hw_majorversion) = (data >> 12) & 0x0F;
463 (*hw_minorversion) = (data >> 8) & 0x0F;
464 (*fw_majorversion) = (data >> 4) & 0x0F;
465 (*fw_minorversion) = data & 0x0F;
470 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
475 result = xc_read_reg(priv, XREG_HSYNC_FREQ, ®Data);
479 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
483 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
485 return xc_read_reg(priv, XREG_FRAME_LINES, frame_lines);
488 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
490 return xc_read_reg(priv, XREG_QUALITY, quality);
493 static u16 WaitForLock(struct xc5000_priv *priv)
496 int watchDogCount = 40;
498 while ((lockState == 0) && (watchDogCount > 0)) {
499 xc_get_lock_status(priv, &lockState);
500 if (lockState != 1) {
508 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz)
512 dprintk(1, "%s(%u)\n", __func__, freq_hz);
514 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
517 if (WaitForLock(priv) == 1)
523 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
525 u8 buf[2] = { reg >> 8, reg & 0xff };
526 u8 bval[2] = { 0, 0 };
527 struct i2c_msg msg[2] = {
528 { .addr = priv->i2c_props.addr,
529 .flags = 0, .buf = &buf[0], .len = 2 },
530 { .addr = priv->i2c_props.addr,
531 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
534 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
535 printk(KERN_WARNING "xc5000: I2C read failed\n");
539 *val = (bval[0] << 8) | bval[1];
543 static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len)
545 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
546 .flags = 0, .buf = buf, .len = len };
548 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
549 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n",
556 static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len)
558 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
559 .flags = I2C_M_RD, .buf = buf, .len = len };
561 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
562 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n",(int)len);
568 static int xc5000_fwupload(struct dvb_frontend* fe)
570 struct xc5000_priv *priv = fe->tuner_priv;
571 const struct firmware *fw;
574 /* request the firmware, this will block and timeout */
575 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
576 XC5000_DEFAULT_FIRMWARE);
578 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE, &priv->i2c_props.adap->dev);
580 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
581 ret = XC_RESULT_RESET_FAILURE;
584 printk(KERN_INFO "xc5000: firmware read %Zu bytes.\n",
586 ret = XC_RESULT_SUCCESS;
589 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
590 printk(KERN_ERR "xc5000: firmware incorrect size\n");
591 ret = XC_RESULT_RESET_FAILURE;
593 printk(KERN_INFO "xc5000: firmware upload\n");
594 ret = xc_load_i2c_sequence(fe, fw->data );
598 release_firmware(fw);
602 static void xc_debug_dump(struct xc5000_priv *priv)
605 u32 freq_error_hz = 0;
607 u32 hsync_freq_hz = 0;
610 u8 hw_majorversion = 0, hw_minorversion = 0;
611 u8 fw_majorversion = 0, fw_minorversion = 0;
613 /* Wait for stats to stabilize.
614 * Frame Lines needs two frame times after initial lock
615 * before it is valid.
619 xc_get_ADC_Envelope(priv, &adc_envelope);
620 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
622 xc_get_frequency_error(priv, &freq_error_hz);
623 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
625 xc_get_lock_status(priv, &lock_status);
626 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
629 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
630 &fw_majorversion, &fw_minorversion);
631 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
632 hw_majorversion, hw_minorversion,
633 fw_majorversion, fw_minorversion);
635 xc_get_hsync_freq(priv, &hsync_freq_hz);
636 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
638 xc_get_frame_lines(priv, &frame_lines);
639 dprintk(1, "*** Frame lines = %d\n", frame_lines);
641 xc_get_quality(priv, &quality);
642 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
645 static int xc5000_set_params(struct dvb_frontend *fe,
646 struct dvb_frontend_parameters *params)
648 struct xc5000_priv *priv = fe->tuner_priv;
651 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
653 switch(params->u.vsb.modulation) {
656 dprintk(1, "%s() VSB modulation\n", __func__);
657 priv->rf_mode = XC_RF_MODE_AIR;
658 priv->freq_hz = params->frequency - 1750000;
659 priv->bandwidth = BANDWIDTH_6_MHZ;
660 priv->video_standard = DTV6;
665 dprintk(1, "%s() QAM modulation\n", __func__);
666 priv->rf_mode = XC_RF_MODE_CABLE;
667 priv->freq_hz = params->frequency - 1750000;
668 priv->bandwidth = BANDWIDTH_6_MHZ;
669 priv->video_standard = DTV6;
675 dprintk(1, "%s() frequency=%d (compensated)\n",
676 __func__, priv->freq_hz);
678 ret = xc_SetSignalSource(priv, priv->rf_mode);
679 if (ret != XC_RESULT_SUCCESS) {
681 "xc5000: xc_SetSignalSource(%d) failed\n",
686 ret = xc_SetTVStandard(priv,
687 XC5000_Standard[priv->video_standard].VideoMode,
688 XC5000_Standard[priv->video_standard].AudioMode);
689 if (ret != XC_RESULT_SUCCESS) {
690 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
694 ret = xc_set_IF_frequency(priv, priv->if_khz);
695 if (ret != XC_RESULT_SUCCESS) {
696 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
701 xc_tune_channel(priv, priv->freq_hz);
709 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
711 struct xc5000_priv *priv = fe->tuner_priv;
715 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
716 if (ret == XC_RESULT_SUCCESS) {
717 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
718 ret = XC_RESULT_RESET_FAILURE;
720 ret = XC_RESULT_SUCCESS;
723 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
724 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
728 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
730 static int xc5000_set_analog_params(struct dvb_frontend *fe,
731 struct analog_parameters *params)
733 struct xc5000_priv *priv = fe->tuner_priv;
736 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
737 xc_load_fw_and_init_tuner(fe);
739 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
740 __func__, params->frequency);
742 priv->rf_mode = XC_RF_MODE_CABLE; /* Fix me: it could be air. */
744 /* params->frequency is in units of 62.5khz */
745 priv->freq_hz = params->frequency * 62500;
747 /* FIX ME: Some video standards may have several possible audio
748 standards. We simply default to one of them here.
750 if(params->std & V4L2_STD_MN) {
751 /* default to BTSC audio standard */
752 priv->video_standard = MN_NTSC_PAL_BTSC;
756 if(params->std & V4L2_STD_PAL_BG) {
757 /* default to NICAM audio standard */
758 priv->video_standard = BG_PAL_NICAM;
762 if(params->std & V4L2_STD_PAL_I) {
763 /* default to NICAM audio standard */
764 priv->video_standard = I_PAL_NICAM;
768 if(params->std & V4L2_STD_PAL_DK) {
769 /* default to NICAM audio standard */
770 priv->video_standard = DK_PAL_NICAM;
774 if(params->std & V4L2_STD_SECAM_DK) {
775 /* default to A2 DK1 audio standard */
776 priv->video_standard = DK_SECAM_A2DK1;
780 if(params->std & V4L2_STD_SECAM_L) {
781 priv->video_standard = L_SECAM_NICAM;
785 if(params->std & V4L2_STD_SECAM_LC) {
786 priv->video_standard = LC_SECAM_NICAM;
791 ret = xc_SetSignalSource(priv, priv->rf_mode);
792 if (ret != XC_RESULT_SUCCESS) {
794 "xc5000: xc_SetSignalSource(%d) failed\n",
799 ret = xc_SetTVStandard(priv,
800 XC5000_Standard[priv->video_standard].VideoMode,
801 XC5000_Standard[priv->video_standard].AudioMode);
802 if (ret != XC_RESULT_SUCCESS) {
803 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
807 xc_tune_channel(priv, priv->freq_hz);
815 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
817 struct xc5000_priv *priv = fe->tuner_priv;
818 dprintk(1, "%s()\n", __func__);
819 *freq = priv->freq_hz;
823 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
825 struct xc5000_priv *priv = fe->tuner_priv;
826 dprintk(1, "%s()\n", __func__);
828 *bw = priv->bandwidth;
832 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
834 struct xc5000_priv *priv = fe->tuner_priv;
837 xc_get_lock_status(priv, &lock_status);
839 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
841 *status = lock_status;
846 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
848 struct xc5000_priv *priv = fe->tuner_priv;
851 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
852 ret = xc5000_fwupload(fe);
853 if (ret != XC_RESULT_SUCCESS)
857 /* Start the tuner self-calibration process */
858 ret |= xc_initialize(priv);
860 /* Wait for calibration to complete.
861 * We could continue but XC5000 will clock stretch subsequent
862 * I2C transactions until calibration is complete. This way we
863 * don't have to rely on clock stretching working.
867 /* Default to "CABLE" mode */
868 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
873 static int xc5000_sleep(struct dvb_frontend *fe)
875 struct xc5000_priv *priv = fe->tuner_priv;
878 dprintk(1, "%s()\n", __func__);
880 /* On Pinnacle PCTV HD 800i, the tuner cannot be reinitialized
881 * once shutdown without reloading the driver. Maybe I am not
882 * doing something right.
886 ret = xc_shutdown(priv);
887 if(ret != XC_RESULT_SUCCESS) {
889 "xc5000: %s() unable to shutdown tuner\n",
894 return XC_RESULT_SUCCESS;
898 static int xc5000_init(struct dvb_frontend *fe)
900 struct xc5000_priv *priv = fe->tuner_priv;
901 dprintk(1, "%s()\n", __func__);
903 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
904 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
914 static int xc5000_release(struct dvb_frontend *fe)
916 struct xc5000_priv *priv = fe->tuner_priv;
918 dprintk(1, "%s()\n", __func__);
920 mutex_lock(&xc5000_list_mutex);
923 hybrid_tuner_release_state(priv);
925 mutex_unlock(&xc5000_list_mutex);
927 fe->tuner_priv = NULL;
932 static const struct dvb_tuner_ops xc5000_tuner_ops = {
934 .name = "Xceive XC5000",
935 .frequency_min = 1000000,
936 .frequency_max = 1023000000,
937 .frequency_step = 50000,
940 .release = xc5000_release,
942 .sleep = xc5000_sleep,
944 .set_params = xc5000_set_params,
945 .set_analog_params = xc5000_set_analog_params,
946 .get_frequency = xc5000_get_frequency,
947 .get_bandwidth = xc5000_get_bandwidth,
948 .get_status = xc5000_get_status
951 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
952 struct i2c_adapter *i2c,
953 struct xc5000_config *cfg, void *devptr)
955 struct xc5000_priv *priv = NULL;
959 dprintk(1, "%s(%d-%04x)\n", __func__,
960 i2c ? i2c_adapter_id(i2c) : -1,
961 cfg ? cfg->i2c_address : -1);
963 mutex_lock(&xc5000_list_mutex);
965 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
966 hybrid_tuner_instance_list,
967 i2c, cfg->i2c_address, "xc5000");
973 /* new tuner instance */
974 priv->bandwidth = BANDWIDTH_6_MHZ;
975 priv->devptr = devptr;
976 priv->if_khz = cfg->if_khz;
977 priv->tuner_callback = cfg->tuner_callback;
979 fe->tuner_priv = priv;
982 /* existing tuner instance */
983 fe->tuner_priv = priv;
987 /* Check if firmware has been loaded. It is possible that another
988 instance of the driver has loaded the firmware.
990 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
994 case XC_PRODUCT_ID_FW_LOADED:
996 "xc5000: Successfully identified at address 0x%02x\n",
999 "xc5000: Firmware has been loaded previously\n");
1001 case XC_PRODUCT_ID_FW_NOT_LOADED:
1003 "xc5000: Successfully identified at address 0x%02x\n",
1006 "xc5000: Firmware has not been loaded previously\n");
1010 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1011 cfg->i2c_address, id);
1015 mutex_unlock(&xc5000_list_mutex);
1017 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1018 sizeof(struct dvb_tuner_ops));
1020 if (xc5000_load_fw_on_attach)
1025 mutex_unlock(&xc5000_list_mutex);
1030 EXPORT_SYMBOL(xc5000_attach);
1032 MODULE_AUTHOR("Steven Toth");
1033 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1034 MODULE_LICENSE("GPL");