projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] em28xx: Fix some Terratec entries (H5 and XS)
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / common / tuners / xc5000.c
CommitLineData
aacb9d31
ST		 1/*
2 * Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
3 *
4 * Copyright (c) 2007 Xceive Corporation
6d897616 5 * Copyright (c) 2007 Steven Toth <stoth@linuxtv.org>
e80858e8 6 * Copyright (c) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
aacb9d31
ST		 7 *
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.
12 *
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
16 *
17 * GNU General Public License for more details.
18 *
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.
22 */
23
24#include <linux/module.h>
25#include <linux/moduleparam.h>
4917019d 26#include <linux/videodev2.h>
aacb9d31
ST		 27#include <linux/delay.h>
28#include <linux/dvb/frontend.h>
29#include <linux/i2c.h>
30
31#include "dvb_frontend.h"
32
33#include "xc5000.h"
89fd2854 34#include "tuner-i2c.h"
aacb9d31
ST		 35
36static int debug;
37module_param(debug, int, 0644);
38MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39
b6bd5eb8
DH		 40static int no_poweroff;
41module_param(no_poweroff, int, 0644);
42MODULE_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");
45
89fd2854
MK		 46static DEFINE_MUTEX(xc5000_list_mutex);
47static LIST_HEAD(hybrid_tuner_instance_list);
48
8f3cd530 49#define dprintk(level, fmt, arg...) if (debug >= level) \
aacb9d31
ST		 50 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
51
a6301d1d
DH		 52#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
53#define XC5000_DEFAULT_FIRMWARE_SIZE 12401
aacb9d31 54
ffb41234 55struct xc5000_priv {
89fd2854
MK		 56 struct tuner_i2c_props i2c_props;
57 struct list_head hybrid_tuner_instance_list;
ffb41234 58
2a6003c2 59 u32 if_khz;
ffb41234
MK		 60 u32 freq_hz;
61 u32 bandwidth;
62 u8 video_standard;
63 u8 rf_mode;
496e9057 64 u8 radio_input;
ffb41234
MK		 65};
66
aacb9d31 67/* Misc Defines */
724dcbfa 68#define MAX_TV_STANDARD 24
aacb9d31
ST		 69#define XC_MAX_I2C_WRITE_LENGTH 64
70
71/* Signal Types */
72#define XC_RF_MODE_AIR 0
73#define XC_RF_MODE_CABLE 1
74
75/* Result codes */
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
81
27c685a4
ST		 82/* Product id */
83#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
84#define XC_PRODUCT_ID_FW_LOADED 0x1388
85
aacb9d31
ST		 86/* Registers */
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
7f05b530 94#define XREG_POWER_DOWN 0x0A /* Obsolete */
724dcbfa
DB		 95/* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
96#define XREG_OUTPUT_AMP 0x0B
aacb9d31
ST		 97#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
98#define XREG_SMOOTHEDCVBS 0x0E
99#define XREG_XTALFREQ 0x0F
81c4dfe7 100#define XREG_FINERFREQ 0x10
aacb9d31
ST		 101#define XREG_DDIMODE 0x11
102
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
bae7b7d7 113#define XREG_BUILD 0x0D
aacb9d31
ST		 114
115/*
116 Basic firmware description. This will remain with
117 the driver for documentation purposes.
118
119 This represents an I2C firmware file encoded as a
120 string of unsigned char. Format is as follows:
121
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
125 char[3 ]=data1
126 char[4 ]=data2
127 char[ ]=...
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
131 char[M+3]=data0
132 char[M+4]=data1
133 ...
134 etc.
135
136 The [len] value should be interpreted as follows:
137
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
143
144 For the RESET and WAIT commands, the two following bytes will contain
145 immediately the length of the following transaction.
146
147*/
8f3cd530 148struct XC_TV_STANDARD {
aacb9d31 149 char *Name;
e12671cf
ST		 150 u16 AudioMode;
151 u16 VideoMode;
8f3cd530 152};
aacb9d31
ST		 153
154/* Tuner standards */
27c685a4
ST		 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
159#define BG_PAL_A2 4
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
164#define DK_PAL_A2 9
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
172#define DTV6 17
173#define DTV8 18
174#define DTV7_8 19
175#define DTV7 20
176#define FM_Radio_INPUT2 21
177#define FM_Radio_INPUT1 22
724dcbfa 178#define FM_Radio_INPUT1_MONO 23
aacb9d31 179
8f3cd530 180static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
aacb9d31
ST		 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},
8f3cd530 194 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
aacb9d31
ST		 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},
724dcbfa
DB		 203 {"FM Radio-INPUT1", 0x0208, 0x9002},
204 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
aacb9d31
ST		 205};
206
8e4c6797 207static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
91bd625e 208static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
bdd33563 209static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
91bd625e 210static int xc5000_TunerReset(struct dvb_frontend *fe);
aacb9d31 211
e12671cf 212static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
aacb9d31 213{
d7800d4e
DH		 214 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
215 .flags = 0, .buf = buf, .len = len };
216
217 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
218 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
219 return XC_RESULT_I2C_WRITE_FAILURE;
220 }
221 return XC_RESULT_SUCCESS;
aacb9d31
ST		 222}
223
1cdffda7 224#if 0
bdd33563
DH		 225/* This routine is never used because the only time we read data from the
226 i2c bus is when we read registers, and we want that to be an atomic i2c
227 transaction in case we are on a multi-master bus */
e12671cf 228static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
aacb9d31 229{
bdd33563
DH		 230 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
231 .flags = I2C_M_RD, .buf = buf, .len = len };
232
233 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
234 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
235 return -EREMOTEIO;
236 }
237 return 0;
aacb9d31 238}
1cdffda7 239#endif
aacb9d31 240
4743319f
DB		 241static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
242{
243 u8 buf[2] = { reg >> 8, reg & 0xff };
244 u8 bval[2] = { 0, 0 };
245 struct i2c_msg msg[2] = {
246 { .addr = priv->i2c_props.addr,
247 .flags = 0, .buf = &buf[0], .len = 2 },
248 { .addr = priv->i2c_props.addr,
249 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
250 };
251
252 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
253 printk(KERN_WARNING "xc5000: I2C read failed\n");
254 return -EREMOTEIO;
255 }
256
257 *val = (bval[0] << 8) | bval[1];
258 return XC_RESULT_SUCCESS;
259}
260
e12671cf 261static void xc_wait(int wait_ms)
aacb9d31 262{
e12671cf 263 msleep(wait_ms);
aacb9d31
ST		 264}
265
91bd625e 266static int xc5000_TunerReset(struct dvb_frontend *fe)
aacb9d31
ST		 267{
268 struct xc5000_priv *priv = fe->tuner_priv;
269 int ret;
270
271ddbf7 271 dprintk(1, "%s()\n", __func__);
aacb9d31 272
d7cba043
MK		 273 if (fe->callback) {
274 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
30650961
MK		 275 fe->dvb->priv :
276 priv->i2c_props.adap->algo_data,
d7cba043 277 DVB_FRONTEND_COMPONENT_TUNER,
30650961 278 XC5000_TUNER_RESET, 0);
91bd625e 279 if (ret) {
aacb9d31 280 printk(KERN_ERR "xc5000: reset failed\n");
91bd625e
DH		 281 return XC_RESULT_RESET_FAILURE;
282 }
283 } else {
27c685a4 284 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
91bd625e
DH		 285 return XC_RESULT_RESET_FAILURE;
286 }
287 return XC_RESULT_SUCCESS;
aacb9d31
ST		 288}
289
e12671cf 290static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
aacb9d31 291{
e12671cf 292 u8 buf[4];
a37791c5 293 int WatchDogTimer = 100;
aacb9d31
ST		 294 int result;
295
296 buf[0] = (regAddr >> 8) & 0xFF;
297 buf[1] = regAddr & 0xFF;
298 buf[2] = (i2cData >> 8) & 0xFF;
299 buf[3] = i2cData & 0xFF;
300 result = xc_send_i2c_data(priv, buf, 4);
e12671cf 301 if (result == XC_RESULT_SUCCESS) {
aacb9d31
ST		 302 /* wait for busy flag to clear */
303 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
1cdffda7 304 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
aacb9d31 305 if (result == XC_RESULT_SUCCESS) {
4743319f
DB		 306 if ((buf[0] == 0) && (buf[1] == 0)) {
307 /* busy flag cleared */
aacb9d31 308 break;
4743319f
DB		 309 } else {
310 xc_wait(5); /* wait 5 ms */
311 WatchDogTimer--;
aacb9d31
ST		 312 }
313 }
314 }
315 }
316 if (WatchDogTimer < 0)
317 result = XC_RESULT_I2C_WRITE_FAILURE;
318
319 return result;
320}
321
c63e87e9 322static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
aacb9d31
ST		 323{
324 struct xc5000_priv *priv = fe->tuner_priv;
325
326 int i, nbytes_to_send, result;
327 unsigned int len, pos, index;
e12671cf 328 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
aacb9d31 329
8f3cd530
ST		 330 index = 0;
331 while ((i2c_sequence[index] != 0xFF) ||
332 (i2c_sequence[index + 1] != 0xFF)) {
333 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
e12671cf 334 if (len == 0x0000) {
aacb9d31 335 /* RESET command */
91bd625e 336 result = xc5000_TunerReset(fe);
aacb9d31 337 index += 2;
e12671cf 338 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 339 return result;
340 } else if (len & 0x8000) {
341 /* WAIT command */
342 xc_wait(len & 0x7FFF);
343 index += 2;
344 } else {
345 /* Send i2c data whilst ensuring individual transactions
346 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
347 */
348 index += 2;
349 buf[0] = i2c_sequence[index];
350 buf[1] = i2c_sequence[index + 1];
351 pos = 2;
352 while (pos < len) {
8f3cd530
ST		 353 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
354 nbytes_to_send =
355 XC_MAX_I2C_WRITE_LENGTH;
356 else
aacb9d31 357 nbytes_to_send = (len - pos + 2);
8f3cd530
ST		 358 for (i = 2; i < nbytes_to_send; i++) {
359 buf[i] = i2c_sequence[index + pos +
360 i - 2];
aacb9d31 361 }
8f3cd530
ST		 362 result = xc_send_i2c_data(priv, buf,
363 nbytes_to_send);
aacb9d31 364
e12671cf 365 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 366 return result;
367
368 pos += nbytes_to_send - 2;
369 }
370 index += len;
371 }
372 }
373 return XC_RESULT_SUCCESS;
374}
375
e12671cf 376static int xc_initialize(struct xc5000_priv *priv)
aacb9d31 377{
271ddbf7 378 dprintk(1, "%s()\n", __func__);
aacb9d31
ST		 379 return xc_write_reg(priv, XREG_INIT, 0);
380}
381
e12671cf
ST		 382static int xc_SetTVStandard(struct xc5000_priv *priv,
383 u16 VideoMode, u16 AudioMode)
aacb9d31
ST		 384{
385 int ret;
271ddbf7 386 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
aacb9d31 387 dprintk(1, "%s() Standard = %s\n",
271ddbf7 388 __func__,
aacb9d31
ST		 389 XC5000_Standard[priv->video_standard].Name);
390
391 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
392 if (ret == XC_RESULT_SUCCESS)
393 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
394
395 return ret;
396}
397
e12671cf 398static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
aacb9d31 399{
271ddbf7 400 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
aacb9d31
ST		 401 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
402
8f3cd530 403 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
aacb9d31
ST		 404 rf_mode = XC_RF_MODE_CABLE;
405 printk(KERN_ERR
406 "%s(), Invalid mode, defaulting to CABLE",
271ddbf7 407 __func__);
aacb9d31
ST		 408 }
409 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
410}
411
e12671cf 412static const struct dvb_tuner_ops xc5000_tuner_ops;
aacb9d31 413
e12671cf
ST		 414static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
415{
416 u16 freq_code;
aacb9d31 417
271ddbf7 418 dprintk(1, "%s(%u)\n", __func__, freq_hz);
aacb9d31 419
e12671cf
ST		 420 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
421 (freq_hz < xc5000_tuner_ops.info.frequency_min))
aacb9d31
ST		 422 return XC_RESULT_OUT_OF_RANGE;
423
e12671cf
ST		 424 freq_code = (u16)(freq_hz / 15625);
425
81c4dfe7
DH		 426 /* Starting in firmware version 1.1.44, Xceive recommends using the
427 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
428 only be used for fast scanning for channel lock) */
429 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
aacb9d31
ST		 430}
431
aacb9d31 432
e12671cf
ST		 433static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
434{
435 u32 freq_code = (freq_khz * 1024)/1000;
436 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
271ddbf7 437 __func__, freq_khz, freq_code);
aacb9d31 438
e12671cf 439 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
aacb9d31
ST		 440}
441
aacb9d31 442
e12671cf 443static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
aacb9d31 444{
bdd33563 445 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
aacb9d31
ST		 446}
447
e12671cf 448static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
aacb9d31
ST		 449{
450 int result;
e12671cf 451 u16 regData;
aacb9d31
ST		 452 u32 tmp;
453
bdd33563 454 result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
7988fc21 455 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 456 return result;
457
458 tmp = (u32)regData;
e12671cf 459 (*freq_error_hz) = (tmp * 15625) / 1000;
aacb9d31
ST		 460 return result;
461}
462
e12671cf 463static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
aacb9d31 464{
bdd33563 465 return xc5000_readreg(priv, XREG_LOCK, lock_status);
aacb9d31
ST		 466}
467
e12671cf
ST		 468static int xc_get_version(struct xc5000_priv *priv,
469 u8 *hw_majorversion, u8 *hw_minorversion,
470 u8 *fw_majorversion, u8 *fw_minorversion)
aacb9d31 471{
e12671cf 472 u16 data;
aacb9d31
ST		 473 int result;
474
bdd33563 475 result = xc5000_readreg(priv, XREG_VERSION, &data);
7988fc21 476 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 477 return result;
478
e12671cf
ST		 479 (*hw_majorversion) = (data >> 12) & 0x0F;
480 (*hw_minorversion) = (data >> 8) & 0x0F;
481 (*fw_majorversion) = (data >> 4) & 0x0F;
482 (*fw_minorversion) = data & 0x0F;
aacb9d31
ST		 483
484 return 0;
485}
486
bae7b7d7
DH		 487static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
488{
489 return xc5000_readreg(priv, XREG_BUILD, buildrev);
490}
491
e12671cf 492static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
aacb9d31 493{
e12671cf 494 u16 regData;
aacb9d31
ST		 495 int result;
496
bdd33563 497 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
7988fc21 498 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 499 return result;
500
501 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
502 return result;
503}
504
e12671cf 505static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
aacb9d31 506{
bdd33563 507 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
aacb9d31
ST		 508}
509
e12671cf 510static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
aacb9d31 511{
bdd33563 512 return xc5000_readreg(priv, XREG_QUALITY, quality);
aacb9d31
ST		 513}
514
e12671cf 515static u16 WaitForLock(struct xc5000_priv *priv)
aacb9d31 516{
e12671cf 517 u16 lockState = 0;
aacb9d31 518 int watchDogCount = 40;
e12671cf
ST		 519
520 while ((lockState == 0) && (watchDogCount > 0)) {
aacb9d31 521 xc_get_lock_status(priv, &lockState);
e12671cf 522 if (lockState != 1) {
aacb9d31
ST		 523 xc_wait(5);
524 watchDogCount--;
525 }
526 }
527 return lockState;
528}
529
a78baacf
DH		 530#define XC_TUNE_ANALOG 0
531#define XC_TUNE_DIGITAL 1
532static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
aacb9d31
ST		 533{
534 int found = 0;
535
271ddbf7 536 dprintk(1, "%s(%u)\n", __func__, freq_hz);
aacb9d31 537
e12671cf 538 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
aacb9d31
ST		 539 return 0;
540
a78baacf
DH		 541 if (mode == XC_TUNE_ANALOG) {
542 if (WaitForLock(priv) == 1)
543 found = 1;
544 }
aacb9d31
ST		 545
546 return found;
547}
548
aacb9d31 549
8f3cd530 550static int xc5000_fwupload(struct dvb_frontend *fe)
aacb9d31
ST		 551{
552 struct xc5000_priv *priv = fe->tuner_priv;
553 const struct firmware *fw;
554 int ret;
555
e12671cf
ST		 556 /* request the firmware, this will block and timeout */
557 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
558 XC5000_DEFAULT_FIRMWARE);
559
8f3cd530 560 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
e9785250 561 priv->i2c_props.adap->dev.parent);
aacb9d31
ST		 562 if (ret) {
563 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
564 ret = XC_RESULT_RESET_FAILURE;
5ea60531 565 goto out;
aacb9d31 566 } else {
34a0db92 567 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
3f51451b 568 fw->size);
aacb9d31
ST		 569 ret = XC_RESULT_SUCCESS;
570 }
571
e12671cf 572 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
aacb9d31
ST		 573 printk(KERN_ERR "xc5000: firmware incorrect size\n");
574 ret = XC_RESULT_RESET_FAILURE;
575 } else {
34a0db92 576 printk(KERN_INFO "xc5000: firmware uploading...\n");
8f3cd530 577 ret = xc_load_i2c_sequence(fe, fw->data);
34a0db92 578 printk(KERN_INFO "xc5000: firmware upload complete...\n");
aacb9d31
ST		 579 }
580
5ea60531 581out:
aacb9d31
ST		 582 release_firmware(fw);
583 return ret;
584}
585
e12671cf 586static void xc_debug_dump(struct xc5000_priv *priv)
aacb9d31 587{
e12671cf
ST		 588 u16 adc_envelope;
589 u32 freq_error_hz = 0;
590 u16 lock_status;
591 u32 hsync_freq_hz = 0;
592 u16 frame_lines;
593 u16 quality;
594 u8 hw_majorversion = 0, hw_minorversion = 0;
595 u8 fw_majorversion = 0, fw_minorversion = 0;
bae7b7d7 596 u16 fw_buildversion = 0;
aacb9d31
ST		 597
598 /* Wait for stats to stabilize.
599 * Frame Lines needs two frame times after initial lock
600 * before it is valid.
601 */
e12671cf 602 xc_wait(100);
aacb9d31 603
e12671cf
ST		 604 xc_get_ADC_Envelope(priv, &adc_envelope);
605 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
aacb9d31 606
e12671cf
ST		 607 xc_get_frequency_error(priv, &freq_error_hz);
608 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
aacb9d31 609
e12671cf
ST		 610 xc_get_lock_status(priv, &lock_status);
611 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
aacb9d31
ST		 612 lock_status);
613
614 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
e12671cf 615 &fw_majorversion, &fw_minorversion);
bae7b7d7
DH		 616 xc_get_buildversion(priv, &fw_buildversion);
617 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
aacb9d31 618 hw_majorversion, hw_minorversion,
bae7b7d7 619 fw_majorversion, fw_minorversion, fw_buildversion);
aacb9d31 620
e12671cf
ST		 621 xc_get_hsync_freq(priv, &hsync_freq_hz);
622 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
aacb9d31 623
e12671cf
ST		 624 xc_get_frame_lines(priv, &frame_lines);
625 dprintk(1, "*** Frame lines = %d\n", frame_lines);
aacb9d31 626
e12671cf
ST		 627 xc_get_quality(priv, &quality);
628 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
aacb9d31
ST		 629}
630
631static int xc5000_set_params(struct dvb_frontend *fe,
632 struct dvb_frontend_parameters *params)
633{
634 struct xc5000_priv *priv = fe->tuner_priv;
e12671cf 635 int ret;
2440f7af 636 u32 bw;
aacb9d31 637
760c466c
DH		 638 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
639 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
640 dprintk(1, "Unable to load firmware and init tuner\n");
641 return -EINVAL;
642 }
643 }
8e4c6797 644
271ddbf7 645 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
aacb9d31 646
6c99080d
DW		 647 if (fe->ops.info.type == FE_ATSC) {
648 dprintk(1, "%s() ATSC\n", __func__);
649 switch (params->u.vsb.modulation) {
650 case VSB_8:
651 case VSB_16:
652 dprintk(1, "%s() VSB modulation\n", __func__);
653 priv->rf_mode = XC_RF_MODE_AIR;
654 priv->freq_hz = params->frequency - 1750000;
655 priv->bandwidth = BANDWIDTH_6_MHZ;
656 priv->video_standard = DTV6;
657 break;
658 case QAM_64:
659 case QAM_256:
660 case QAM_AUTO:
661 dprintk(1, "%s() QAM modulation\n", __func__);
662 priv->rf_mode = XC_RF_MODE_CABLE;
663 priv->freq_hz = params->frequency - 1750000;
664 priv->bandwidth = BANDWIDTH_6_MHZ;
665 priv->video_standard = DTV6;
666 break;
667 default:
668 return -EINVAL;
669 }
670 } else if (fe->ops.info.type == FE_OFDM) {
671 dprintk(1, "%s() OFDM\n", __func__);
672 switch (params->u.ofdm.bandwidth) {
673 case BANDWIDTH_6_MHZ:
674 priv->bandwidth = BANDWIDTH_6_MHZ;
675 priv->video_standard = DTV6;
676 priv->freq_hz = params->frequency - 1750000;
677 break;
678 case BANDWIDTH_7_MHZ:
679 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
680 return -EINVAL;
681 case BANDWIDTH_8_MHZ:
682 priv->bandwidth = BANDWIDTH_8_MHZ;
683 priv->video_standard = DTV8;
684 priv->freq_hz = params->frequency - 2750000;
685 break;
686 default:
687 printk(KERN_ERR "xc5000 bandwidth not set!\n");
688 return -EINVAL;
689 }
aacb9d31 690 priv->rf_mode = XC_RF_MODE_AIR;
e80edce1 691 } else if (fe->ops.info.type == FE_QAM) {
e80edce1 692 switch (params->u.qam.modulation) {
e0df5417
MCC		 693 case QAM_256:
694 case QAM_AUTO:
e80edce1
IL		 695 case QAM_16:
696 case QAM_32:
697 case QAM_64:
698 case QAM_128:
e80edce1 699 dprintk(1, "%s() QAM modulation\n", __func__);
e80edce1 700 priv->rf_mode = XC_RF_MODE_CABLE;
e0df5417 701 /*
2440f7af
MCC		 702 * Using a higher bandwidth at the tuner filter may
703 * allow inter-carrier interference.
704 * So, determine the minimal channel spacing, in order
705 * to better adjust the tuner filter.
706 * According with ITU-T J.83, the bandwidth is given by:
707 * bw = Simbol Rate * (1 + roll_off), where the roll_off
708 * is equal to 0.15 for Annex A, and 0.13 for annex C
e0df5417 709 */
2440f7af
MCC		 710 if (fe->dtv_property_cache.rolloff == ROLLOFF_13)
711 bw = (params->u.qam.symbol_rate * 13) / 10;
712 else
713 bw = (params->u.qam.symbol_rate * 15) / 10;
714 if (bw <= 6000000) {
e0df5417
MCC		 715 priv->bandwidth = BANDWIDTH_6_MHZ;
716 priv->video_standard = DTV6;
717 priv->freq_hz = params->frequency - 1750000;
718 } else {
719 priv->bandwidth = BANDWIDTH_8_MHZ;
720 priv->video_standard = DTV7_8;
721 priv->freq_hz = params->frequency - 2750000;
722 }
e80edce1
IL		 723 break;
724 default:
e0df5417 725 dprintk(1, "%s() Unsupported QAM type\n", __func__);
e80edce1
IL		 726 return -EINVAL;
727 }
6c99080d
DW		 728 } else {
729 printk(KERN_ERR "xc5000 modulation type not supported!\n");
aacb9d31
ST		 730 return -EINVAL;
731 }
732
733 dprintk(1, "%s() frequency=%d (compensated)\n",
271ddbf7 734 __func__, priv->freq_hz);
aacb9d31 735
e12671cf
ST		 736 ret = xc_SetSignalSource(priv, priv->rf_mode);
737 if (ret != XC_RESULT_SUCCESS) {
738 printk(KERN_ERR
739 "xc5000: xc_SetSignalSource(%d) failed\n",
740 priv->rf_mode);
741 return -EREMOTEIO;
742 }
aacb9d31 743
e12671cf 744 ret = xc_SetTVStandard(priv,
aacb9d31
ST		 745 XC5000_Standard[priv->video_standard].VideoMode,
746 XC5000_Standard[priv->video_standard].AudioMode);
e12671cf
ST		 747 if (ret != XC_RESULT_SUCCESS) {
748 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
749 return -EREMOTEIO;
750 }
751
2a6003c2 752 ret = xc_set_IF_frequency(priv, priv->if_khz);
e12671cf
ST		 753 if (ret != XC_RESULT_SUCCESS) {
754 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
2a6003c2 755 priv->if_khz);
e12671cf
ST		 756 return -EIO;
757 }
758
724dcbfa
DB		 759 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
760
a78baacf 761 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
aacb9d31 762
e12671cf
ST		 763 if (debug)
764 xc_debug_dump(priv);
aacb9d31
ST		 765
766 return 0;
767}
768
e470d817
ST		 769static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
770{
771 struct xc5000_priv *priv = fe->tuner_priv;
772 int ret;
773 u16 id;
774
775 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
776 if (ret == XC_RESULT_SUCCESS) {
777 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
778 ret = XC_RESULT_RESET_FAILURE;
779 else
780 ret = XC_RESULT_SUCCESS;
781 }
782
783 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
784 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
785 return ret;
786}
787
d7009cdc 788static int xc5000_set_tv_freq(struct dvb_frontend *fe,
27c685a4
ST		 789 struct analog_parameters *params)
790{
791 struct xc5000_priv *priv = fe->tuner_priv;
792 int ret;
793
27c685a4 794 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
271ddbf7 795 __func__, params->frequency);
27c685a4 796
1fab14ed
MCC		 797 /* Fix me: it could be air. */
798 priv->rf_mode = params->mode;
799 if (params->mode > XC_RF_MODE_CABLE)
800 priv->rf_mode = XC_RF_MODE_CABLE;
27c685a4
ST		 801
802 /* params->frequency is in units of 62.5khz */
803 priv->freq_hz = params->frequency * 62500;
804
805 /* FIX ME: Some video standards may have several possible audio
806 standards. We simply default to one of them here.
807 */
8f3cd530 808 if (params->std & V4L2_STD_MN) {
27c685a4
ST		 809 /* default to BTSC audio standard */
810 priv->video_standard = MN_NTSC_PAL_BTSC;
811 goto tune_channel;
812 }
813
8f3cd530 814 if (params->std & V4L2_STD_PAL_BG) {
27c685a4
ST		 815 /* default to NICAM audio standard */
816 priv->video_standard = BG_PAL_NICAM;
817 goto tune_channel;
818 }
819
8f3cd530 820 if (params->std & V4L2_STD_PAL_I) {
27c685a4
ST		 821 /* default to NICAM audio standard */
822 priv->video_standard = I_PAL_NICAM;
823 goto tune_channel;
824 }
825
8f3cd530 826 if (params->std & V4L2_STD_PAL_DK) {
27c685a4
ST		 827 /* default to NICAM audio standard */
828 priv->video_standard = DK_PAL_NICAM;
829 goto tune_channel;
830 }
831
8f3cd530 832 if (params->std & V4L2_STD_SECAM_DK) {
27c685a4
ST		 833 /* default to A2 DK1 audio standard */
834 priv->video_standard = DK_SECAM_A2DK1;
835 goto tune_channel;
836 }
837
8f3cd530 838 if (params->std & V4L2_STD_SECAM_L) {
27c685a4
ST		 839 priv->video_standard = L_SECAM_NICAM;
840 goto tune_channel;
841 }
842
8f3cd530 843 if (params->std & V4L2_STD_SECAM_LC) {
27c685a4
ST		 844 priv->video_standard = LC_SECAM_NICAM;
845 goto tune_channel;
846 }
847
848tune_channel:
849 ret = xc_SetSignalSource(priv, priv->rf_mode);
850 if (ret != XC_RESULT_SUCCESS) {
8f3cd530 851 printk(KERN_ERR
27c685a4
ST		 852 "xc5000: xc_SetSignalSource(%d) failed\n",
853 priv->rf_mode);
854 return -EREMOTEIO;
855 }
856
857 ret = xc_SetTVStandard(priv,
858 XC5000_Standard[priv->video_standard].VideoMode,
859 XC5000_Standard[priv->video_standard].AudioMode);
860 if (ret != XC_RESULT_SUCCESS) {
861 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
862 return -EREMOTEIO;
863 }
864
724dcbfa
DB		 865 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
866
a78baacf 867 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
27c685a4
ST		 868
869 if (debug)
870 xc_debug_dump(priv);
871
872 return 0;
873}
874
d7009cdc
BILDB		 875static int xc5000_set_radio_freq(struct dvb_frontend *fe,
876 struct analog_parameters *params)
877{
878 struct xc5000_priv *priv = fe->tuner_priv;
879 int ret = -EINVAL;
496e9057 880 u8 radio_input;
d7009cdc
BILDB		 881
882 dprintk(1, "%s() frequency=%d (in units of khz)\n",
883 __func__, params->frequency);
884
496e9057
DH		 885 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
886 dprintk(1, "%s() radio input not configured\n", __func__);
887 return -EINVAL;
888 }
889
890 if (priv->radio_input == XC5000_RADIO_FM1)
891 radio_input = FM_Radio_INPUT1;
892 else if (priv->radio_input == XC5000_RADIO_FM2)
893 radio_input = FM_Radio_INPUT2;
724dcbfa
DB		 894 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
895 radio_input = FM_Radio_INPUT1_MONO;
496e9057
DH		 896 else {
897 dprintk(1, "%s() unknown radio input %d\n", __func__,
898 priv->radio_input);
899 return -EINVAL;
900 }
901
d7009cdc
BILDB		 902 priv->freq_hz = params->frequency * 125 / 2;
903
904 priv->rf_mode = XC_RF_MODE_AIR;
905
496e9057
DH		 906 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
907 XC5000_Standard[radio_input].AudioMode);
d7009cdc
BILDB		 908
909 if (ret != XC_RESULT_SUCCESS) {
910 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
911 return -EREMOTEIO;
912 }
913
914 ret = xc_SetSignalSource(priv, priv->rf_mode);
915 if (ret != XC_RESULT_SUCCESS) {
916 printk(KERN_ERR
917 "xc5000: xc_SetSignalSource(%d) failed\n",
918 priv->rf_mode);
919 return -EREMOTEIO;
920 }
921
724dcbfa
DB		 922 if ((priv->radio_input == XC5000_RADIO_FM1) ||
923 (priv->radio_input == XC5000_RADIO_FM2))
924 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
925 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
926 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
927
d7009cdc
BILDB		 928 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
929
930 return 0;
931}
932
933static int xc5000_set_analog_params(struct dvb_frontend *fe,
934 struct analog_parameters *params)
935{
936 struct xc5000_priv *priv = fe->tuner_priv;
937 int ret = -EINVAL;
938
939 if (priv->i2c_props.adap == NULL)
940 return -EINVAL;
941
760c466c
DH		 942 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
943 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
944 dprintk(1, "Unable to load firmware and init tuner\n");
945 return -EINVAL;
946 }
947 }
d7009cdc
BILDB		 948
949 switch (params->mode) {
950 case V4L2_TUNER_RADIO:
951 ret = xc5000_set_radio_freq(fe, params);
952 break;
953 case V4L2_TUNER_ANALOG_TV:
954 case V4L2_TUNER_DIGITAL_TV:
955 ret = xc5000_set_tv_freq(fe, params);
956 break;
957 }
958
959 return ret;
960}
961
962
aacb9d31
ST		 963static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
964{
965 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 966 dprintk(1, "%s()\n", __func__);
e12671cf 967 *freq = priv->freq_hz;
aacb9d31
ST		 968 return 0;
969}
970
971static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
972{
973 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 974 dprintk(1, "%s()\n", __func__);
27c685a4 975
aacb9d31
ST		 976 *bw = priv->bandwidth;
977 return 0;
978}
979
980static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
981{
982 struct xc5000_priv *priv = fe->tuner_priv;
e12671cf 983 u16 lock_status = 0;
aacb9d31
ST		 984
985 xc_get_lock_status(priv, &lock_status);
986
271ddbf7 987 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
aacb9d31
ST		 988
989 *status = lock_status;
990
991 return 0;
992}
993
e12671cf 994static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
aacb9d31
ST		 995{
996 struct xc5000_priv *priv = fe->tuner_priv;
27c685a4 997 int ret = 0;
aacb9d31 998
e470d817 999 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
aacb9d31 1000 ret = xc5000_fwupload(fe);
e12671cf
ST		 1001 if (ret != XC_RESULT_SUCCESS)
1002 return ret;
aacb9d31
ST		 1003 }
1004
1005 /* Start the tuner self-calibration process */
1006 ret |= xc_initialize(priv);
1007
1008 /* Wait for calibration to complete.
1009 * We could continue but XC5000 will clock stretch subsequent
1010 * I2C transactions until calibration is complete. This way we
1011 * don't have to rely on clock stretching working.
1012 */
8f3cd530 1013 xc_wait(100);
aacb9d31
ST		 1014
1015 /* Default to "CABLE" mode */
1016 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1017
1018 return ret;
1019}
1020
e12671cf
ST		 1021static int xc5000_sleep(struct dvb_frontend *fe)
1022{
27c685a4
ST		 1023 int ret;
1024
271ddbf7 1025 dprintk(1, "%s()\n", __func__);
e12671cf 1026
b6bd5eb8
DH		 1027 /* Avoid firmware reload on slow devices */
1028 if (no_poweroff)
1029 return 0;
1030
7f05b530
DH		 1031 /* According to Xceive technical support, the "powerdown" register
1032 was removed in newer versions of the firmware. The "supported"
1033 way to sleep the tuner is to pull the reset pin low for 10ms */
1034 ret = xc5000_TunerReset(fe);
8f3cd530 1035 if (ret != XC_RESULT_SUCCESS) {
27c685a4
ST		 1036 printk(KERN_ERR
1037 "xc5000: %s() unable to shutdown tuner\n",
271ddbf7 1038 __func__);
27c685a4 1039 return -EREMOTEIO;
8f3cd530 1040 } else
27c685a4 1041 return XC_RESULT_SUCCESS;
e12671cf
ST		 1042}
1043
aacb9d31
ST		 1044static int xc5000_init(struct dvb_frontend *fe)
1045{
1046 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 1047 dprintk(1, "%s()\n", __func__);
aacb9d31 1048
e12671cf
ST		 1049 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1050 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1051 return -EREMOTEIO;
1052 }
1053
1054 if (debug)
1055 xc_debug_dump(priv);
aacb9d31
ST		 1056
1057 return 0;
1058}
1059
1060static int xc5000_release(struct dvb_frontend *fe)
1061{
89fd2854
MK		 1062 struct xc5000_priv *priv = fe->tuner_priv;
1063
271ddbf7 1064 dprintk(1, "%s()\n", __func__);
89fd2854
MK		 1065
1066 mutex_lock(&xc5000_list_mutex);
1067
1068 if (priv)
1069 hybrid_tuner_release_state(priv);
1070
1071 mutex_unlock(&xc5000_list_mutex);
1072
aacb9d31 1073 fe->tuner_priv = NULL;
89fd2854 1074
aacb9d31
ST		 1075 return 0;
1076}
1077
724dcbfa
DB		 1078static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1079{
1080 struct xc5000_priv *priv = fe->tuner_priv;
1081 struct xc5000_config *p = priv_cfg;
1082
1083 dprintk(1, "%s()\n", __func__);
1084
1085 if (p->if_khz)
1086 priv->if_khz = p->if_khz;
1087
1088 if (p->radio_input)
1089 priv->radio_input = p->radio_input;
1090
1091 return 0;
1092}
1093
1094
aacb9d31
ST		 1095static const struct dvb_tuner_ops xc5000_tuner_ops = {
1096 .info = {
1097 .name = "Xceive XC5000",
1098 .frequency_min = 1000000,
1099 .frequency_max = 1023000000,
1100 .frequency_step = 50000,
1101 },
1102
27c685a4
ST		 1103 .release = xc5000_release,
1104 .init = xc5000_init,
1105 .sleep = xc5000_sleep,
aacb9d31 1106
724dcbfa 1107 .set_config = xc5000_set_config,
27c685a4
ST		 1108 .set_params = xc5000_set_params,
1109 .set_analog_params = xc5000_set_analog_params,
1110 .get_frequency = xc5000_get_frequency,
1111 .get_bandwidth = xc5000_get_bandwidth,
1112 .get_status = xc5000_get_status
aacb9d31
ST		 1113};
1114
48723543
MK		 1115struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1116 struct i2c_adapter *i2c,
2e4e98e7 1117 const struct xc5000_config *cfg)
aacb9d31
ST		 1118{
1119 struct xc5000_priv *priv = NULL;
89fd2854 1120 int instance;
aacb9d31
ST		 1121 u16 id = 0;
1122
89fd2854
MK		 1123 dprintk(1, "%s(%d-%04x)\n", __func__,
1124 i2c ? i2c_adapter_id(i2c) : -1,
1125 cfg ? cfg->i2c_address : -1);
aacb9d31 1126
89fd2854 1127 mutex_lock(&xc5000_list_mutex);
aacb9d31 1128
89fd2854
MK		 1129 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1130 hybrid_tuner_instance_list,
1131 i2c, cfg->i2c_address, "xc5000");
1132 switch (instance) {
1133 case 0:
1134 goto fail;
1135 break;
1136 case 1:
1137 /* new tuner instance */
89fd2854 1138 priv->bandwidth = BANDWIDTH_6_MHZ;
89fd2854
MK		 1139 fe->tuner_priv = priv;
1140 break;
1141 default:
1142 /* existing tuner instance */
1143 fe->tuner_priv = priv;
1144 break;
1145 }
aacb9d31 1146
ea227863
DH		 1147 if (priv->if_khz == 0) {
1148 /* If the IF hasn't been set yet, use the value provided by
1149 the caller (occurs in hybrid devices where the analog
1150 call to xc5000_attach occurs before the digital side) */
1151 priv->if_khz = cfg->if_khz;
1152 }
1153
496e9057
DH		 1154 if (priv->radio_input == 0)
1155 priv->radio_input = cfg->radio_input;
1156
27c685a4
ST		 1157 /* Check if firmware has been loaded. It is possible that another
1158 instance of the driver has loaded the firmware.
1159 */
7988fc21 1160 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
89fd2854 1161 goto fail;
aacb9d31 1162
8f3cd530 1163 switch (id) {
27c685a4
ST		 1164 case XC_PRODUCT_ID_FW_LOADED:
1165 printk(KERN_INFO
1166 "xc5000: Successfully identified at address 0x%02x\n",
1167 cfg->i2c_address);
1168 printk(KERN_INFO
1169 "xc5000: Firmware has been loaded previously\n");
27c685a4
ST		 1170 break;
1171 case XC_PRODUCT_ID_FW_NOT_LOADED:
1172 printk(KERN_INFO
1173 "xc5000: Successfully identified at address 0x%02x\n",
1174 cfg->i2c_address);
1175 printk(KERN_INFO
1176 "xc5000: Firmware has not been loaded previously\n");
27c685a4
ST		 1177 break;
1178 default:
aacb9d31
ST		 1179 printk(KERN_ERR
1180 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1181 cfg->i2c_address, id);
89fd2854 1182 goto fail;
aacb9d31
ST		 1183 }
1184
89fd2854
MK		 1185 mutex_unlock(&xc5000_list_mutex);
1186
aacb9d31
ST		 1187 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1188 sizeof(struct dvb_tuner_ops));
1189
aacb9d31 1190 return fe;
89fd2854
MK		 1191fail:
1192 mutex_unlock(&xc5000_list_mutex);
1193
1194 xc5000_release(fe);
1195 return NULL;
aacb9d31
ST		 1196}
1197EXPORT_SYMBOL(xc5000_attach);
1198
1199MODULE_AUTHOR("Steven Toth");
e12671cf 1200MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
aacb9d31 1201MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)