projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (11794): au0828: reduce reset time for xc5000 to 10ms
[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>
aacb9d31
ST		 6 *
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.
11 *
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
15 *
16 * GNU General Public License for more details.
17 *
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.
21 */
22
23#include <linux/module.h>
24#include <linux/moduleparam.h>
4917019d 25#include <linux/videodev2.h>
aacb9d31
ST		 26#include <linux/delay.h>
27#include <linux/dvb/frontend.h>
28#include <linux/i2c.h>
29
30#include "dvb_frontend.h"
31
32#include "xc5000.h"
89fd2854 33#include "tuner-i2c.h"
aacb9d31
ST		 34
35static int debug;
36module_param(debug, int, 0644);
37MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
38
89fd2854
MK		 39static DEFINE_MUTEX(xc5000_list_mutex);
40static LIST_HEAD(hybrid_tuner_instance_list);
41
8f3cd530 42#define dprintk(level, fmt, arg...) if (debug >= level) \
aacb9d31
ST		 43 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
44
361d4892
DH		 45#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.4.68.fw"
46#define XC5000_DEFAULT_FIRMWARE_SIZE 12378
aacb9d31 47
ffb41234 48struct xc5000_priv {
89fd2854
MK		 49 struct tuner_i2c_props i2c_props;
50 struct list_head hybrid_tuner_instance_list;
ffb41234 51
2a6003c2 52 u32 if_khz;
ffb41234
MK		 53 u32 freq_hz;
54 u32 bandwidth;
55 u8 video_standard;
56 u8 rf_mode;
ffb41234
MK		 57};
58
aacb9d31
ST		 59/* Misc Defines */
60#define MAX_TV_STANDARD 23
61#define XC_MAX_I2C_WRITE_LENGTH 64
62
63/* Signal Types */
64#define XC_RF_MODE_AIR 0
65#define XC_RF_MODE_CABLE 1
66
67/* Result codes */
68#define XC_RESULT_SUCCESS 0
69#define XC_RESULT_RESET_FAILURE 1
70#define XC_RESULT_I2C_WRITE_FAILURE 2
71#define XC_RESULT_I2C_READ_FAILURE 3
72#define XC_RESULT_OUT_OF_RANGE 5
73
27c685a4
ST		 74/* Product id */
75#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
76#define XC_PRODUCT_ID_FW_LOADED 0x1388
77
aacb9d31
ST		 78/* Registers */
79#define XREG_INIT 0x00
80#define XREG_VIDEO_MODE 0x01
81#define XREG_AUDIO_MODE 0x02
82#define XREG_RF_FREQ 0x03
83#define XREG_D_CODE 0x04
84#define XREG_IF_OUT 0x05
85#define XREG_SEEK_MODE 0x07
7f05b530 86#define XREG_POWER_DOWN 0x0A /* Obsolete */
aacb9d31
ST		 87#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
88#define XREG_SMOOTHEDCVBS 0x0E
89#define XREG_XTALFREQ 0x0F
90#define XREG_FINERFFREQ 0x10
91#define XREG_DDIMODE 0x11
92
93#define XREG_ADC_ENV 0x00
94#define XREG_QUALITY 0x01
95#define XREG_FRAME_LINES 0x02
96#define XREG_HSYNC_FREQ 0x03
97#define XREG_LOCK 0x04
98#define XREG_FREQ_ERROR 0x05
99#define XREG_SNR 0x06
100#define XREG_VERSION 0x07
101#define XREG_PRODUCT_ID 0x08
102#define XREG_BUSY 0x09
103
104/*
105 Basic firmware description. This will remain with
106 the driver for documentation purposes.
107
108 This represents an I2C firmware file encoded as a
109 string of unsigned char. Format is as follows:
110
111 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
112 char[1 ]=len0_LSB -> length of first write transaction
113 char[2 ]=data0 -> first byte to be sent
114 char[3 ]=data1
115 char[4 ]=data2
116 char[ ]=...
117 char[M ]=dataN -> last byte to be sent
118 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
119 char[M+2]=len1_LSB -> length of second write transaction
120 char[M+3]=data0
121 char[M+4]=data1
122 ...
123 etc.
124
125 The [len] value should be interpreted as follows:
126
127 len= len_MSB _ len_LSB
128 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
129 len=0000_0000_0000_0000 : Reset command: Do hardware reset
130 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
131 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
132
133 For the RESET and WAIT commands, the two following bytes will contain
134 immediately the length of the following transaction.
135
136*/
8f3cd530 137struct XC_TV_STANDARD {
aacb9d31 138 char *Name;
e12671cf
ST		 139 u16 AudioMode;
140 u16 VideoMode;
8f3cd530 141};
aacb9d31
ST		 142
143/* Tuner standards */
27c685a4
ST		 144#define MN_NTSC_PAL_BTSC 0
145#define MN_NTSC_PAL_A2 1
146#define MN_NTSC_PAL_EIAJ 2
147#define MN_NTSC_PAL_Mono 3
148#define BG_PAL_A2 4
149#define BG_PAL_NICAM 5
150#define BG_PAL_MONO 6
151#define I_PAL_NICAM 7
152#define I_PAL_NICAM_MONO 8
153#define DK_PAL_A2 9
154#define DK_PAL_NICAM 10
155#define DK_PAL_MONO 11
156#define DK_SECAM_A2DK1 12
157#define DK_SECAM_A2LDK3 13
158#define DK_SECAM_A2MONO 14
159#define L_SECAM_NICAM 15
160#define LC_SECAM_NICAM 16
161#define DTV6 17
162#define DTV8 18
163#define DTV7_8 19
164#define DTV7 20
165#define FM_Radio_INPUT2 21
166#define FM_Radio_INPUT1 22
aacb9d31 167
8f3cd530 168static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
aacb9d31
ST		 169 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
170 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
171 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
172 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
173 {"B/G-PAL-A2", 0x0A00, 0x8049},
174 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
175 {"B/G-PAL-MONO", 0x0878, 0x8059},
176 {"I-PAL-NICAM", 0x1080, 0x8009},
177 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
178 {"D/K-PAL-A2", 0x1600, 0x8009},
179 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
180 {"D/K-PAL-MONO", 0x1478, 0x8009},
181 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
8f3cd530 182 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
aacb9d31
ST		 183 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
184 {"L-SECAM-NICAM", 0x8E82, 0x0009},
185 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
186 {"DTV6", 0x00C0, 0x8002},
187 {"DTV8", 0x00C0, 0x800B},
188 {"DTV7/8", 0x00C0, 0x801B},
189 {"DTV7", 0x00C0, 0x8007},
190 {"FM Radio-INPUT2", 0x9802, 0x9002},
191 {"FM Radio-INPUT1", 0x0208, 0x9002}
192};
193
8e4c6797 194static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
91bd625e 195static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
bdd33563 196static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
91bd625e 197static int xc5000_TunerReset(struct dvb_frontend *fe);
aacb9d31 198
e12671cf 199static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
aacb9d31 200{
d7800d4e
DH		 201 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
202 .flags = 0, .buf = buf, .len = len };
203
204 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
205 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
206 return XC_RESULT_I2C_WRITE_FAILURE;
207 }
208 return XC_RESULT_SUCCESS;
aacb9d31
ST		 209}
210
bdd33563
DH		 211/* This routine is never used because the only time we read data from the
212 i2c bus is when we read registers, and we want that to be an atomic i2c
213 transaction in case we are on a multi-master bus */
e12671cf 214static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
aacb9d31 215{
bdd33563
DH		 216 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
217 .flags = I2C_M_RD, .buf = buf, .len = len };
218
219 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
220 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
221 return -EREMOTEIO;
222 }
223 return 0;
aacb9d31
ST		 224}
225
e12671cf 226static void xc_wait(int wait_ms)
aacb9d31 227{
e12671cf 228 msleep(wait_ms);
aacb9d31
ST		 229}
230
91bd625e 231static int xc5000_TunerReset(struct dvb_frontend *fe)
aacb9d31
ST		 232{
233 struct xc5000_priv *priv = fe->tuner_priv;
234 int ret;
235
271ddbf7 236 dprintk(1, "%s()\n", __func__);
aacb9d31 237
d7cba043
MK		 238 if (fe->callback) {
239 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
30650961
MK		 240 fe->dvb->priv :
241 priv->i2c_props.adap->algo_data,
d7cba043 242 DVB_FRONTEND_COMPONENT_TUNER,
30650961 243 XC5000_TUNER_RESET, 0);
91bd625e 244 if (ret) {
aacb9d31 245 printk(KERN_ERR "xc5000: reset failed\n");
91bd625e
DH		 246 return XC_RESULT_RESET_FAILURE;
247 }
248 } else {
27c685a4 249 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
91bd625e
DH		 250 return XC_RESULT_RESET_FAILURE;
251 }
252 return XC_RESULT_SUCCESS;
aacb9d31
ST		 253}
254
e12671cf 255static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
aacb9d31 256{
e12671cf 257 u8 buf[4];
aacb9d31
ST		 258 int WatchDogTimer = 5;
259 int result;
260
261 buf[0] = (regAddr >> 8) & 0xFF;
262 buf[1] = regAddr & 0xFF;
263 buf[2] = (i2cData >> 8) & 0xFF;
264 buf[3] = i2cData & 0xFF;
265 result = xc_send_i2c_data(priv, buf, 4);
e12671cf 266 if (result == XC_RESULT_SUCCESS) {
aacb9d31
ST		 267 /* wait for busy flag to clear */
268 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
269 buf[0] = 0;
270 buf[1] = XREG_BUSY;
271
272 result = xc_send_i2c_data(priv, buf, 2);
273 if (result == XC_RESULT_SUCCESS) {
274 result = xc_read_i2c_data(priv, buf, 2);
275 if (result == XC_RESULT_SUCCESS) {
276 if ((buf[0] == 0) && (buf[1] == 0)) {
277 /* busy flag cleared */
278 break;
279 } else {
280 xc_wait(100); /* wait 5 ms */
281 WatchDogTimer--;
282 }
283 }
284 }
285 }
286 }
287 if (WatchDogTimer < 0)
288 result = XC_RESULT_I2C_WRITE_FAILURE;
289
290 return result;
291}
292
c63e87e9 293static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
aacb9d31
ST		 294{
295 struct xc5000_priv *priv = fe->tuner_priv;
296
297 int i, nbytes_to_send, result;
298 unsigned int len, pos, index;
e12671cf 299 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
aacb9d31 300
8f3cd530
ST		 301 index = 0;
302 while ((i2c_sequence[index] != 0xFF) ||
303 (i2c_sequence[index + 1] != 0xFF)) {
304 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
e12671cf 305 if (len == 0x0000) {
aacb9d31 306 /* RESET command */
91bd625e 307 result = xc5000_TunerReset(fe);
aacb9d31 308 index += 2;
e12671cf 309 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 310 return result;
311 } else if (len & 0x8000) {
312 /* WAIT command */
313 xc_wait(len & 0x7FFF);
314 index += 2;
315 } else {
316 /* Send i2c data whilst ensuring individual transactions
317 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
318 */
319 index += 2;
320 buf[0] = i2c_sequence[index];
321 buf[1] = i2c_sequence[index + 1];
322 pos = 2;
323 while (pos < len) {
8f3cd530
ST		 324 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
325 nbytes_to_send =
326 XC_MAX_I2C_WRITE_LENGTH;
327 else
aacb9d31 328 nbytes_to_send = (len - pos + 2);
8f3cd530
ST		 329 for (i = 2; i < nbytes_to_send; i++) {
330 buf[i] = i2c_sequence[index + pos +
331 i - 2];
aacb9d31 332 }
8f3cd530
ST		 333 result = xc_send_i2c_data(priv, buf,
334 nbytes_to_send);
aacb9d31 335
e12671cf 336 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 337 return result;
338
339 pos += nbytes_to_send - 2;
340 }
341 index += len;
342 }
343 }
344 return XC_RESULT_SUCCESS;
345}
346
e12671cf 347static int xc_initialize(struct xc5000_priv *priv)
aacb9d31 348{
271ddbf7 349 dprintk(1, "%s()\n", __func__);
aacb9d31
ST		 350 return xc_write_reg(priv, XREG_INIT, 0);
351}
352
e12671cf
ST		 353static int xc_SetTVStandard(struct xc5000_priv *priv,
354 u16 VideoMode, u16 AudioMode)
aacb9d31
ST		 355{
356 int ret;
271ddbf7 357 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
aacb9d31 358 dprintk(1, "%s() Standard = %s\n",
271ddbf7 359 __func__,
aacb9d31
ST		 360 XC5000_Standard[priv->video_standard].Name);
361
362 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
363 if (ret == XC_RESULT_SUCCESS)
364 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
365
366 return ret;
367}
368
e12671cf 369static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
aacb9d31 370{
271ddbf7 371 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
aacb9d31
ST		 372 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
373
8f3cd530 374 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
aacb9d31
ST		 375 rf_mode = XC_RF_MODE_CABLE;
376 printk(KERN_ERR
377 "%s(), Invalid mode, defaulting to CABLE",
271ddbf7 378 __func__);
aacb9d31
ST		 379 }
380 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
381}
382
e12671cf 383static const struct dvb_tuner_ops xc5000_tuner_ops;
aacb9d31 384
e12671cf
ST		 385static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
386{
387 u16 freq_code;
aacb9d31 388
271ddbf7 389 dprintk(1, "%s(%u)\n", __func__, freq_hz);
aacb9d31 390
e12671cf
ST		 391 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
392 (freq_hz < xc5000_tuner_ops.info.frequency_min))
aacb9d31
ST		 393 return XC_RESULT_OUT_OF_RANGE;
394
e12671cf
ST		 395 freq_code = (u16)(freq_hz / 15625);
396
397 return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
aacb9d31
ST		 398}
399
aacb9d31 400
e12671cf
ST		 401static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
402{
403 u32 freq_code = (freq_khz * 1024)/1000;
404 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
271ddbf7 405 __func__, freq_khz, freq_code);
aacb9d31 406
e12671cf 407 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
aacb9d31
ST		 408}
409
aacb9d31 410
e12671cf 411static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
aacb9d31 412{
bdd33563 413 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
aacb9d31
ST		 414}
415
e12671cf 416static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
aacb9d31
ST		 417{
418 int result;
e12671cf 419 u16 regData;
aacb9d31
ST		 420 u32 tmp;
421
bdd33563 422 result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
7988fc21 423 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 424 return result;
425
426 tmp = (u32)regData;
e12671cf 427 (*freq_error_hz) = (tmp * 15625) / 1000;
aacb9d31
ST		 428 return result;
429}
430
e12671cf 431static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
aacb9d31 432{
bdd33563 433 return xc5000_readreg(priv, XREG_LOCK, lock_status);
aacb9d31
ST		 434}
435
e12671cf
ST		 436static int xc_get_version(struct xc5000_priv *priv,
437 u8 *hw_majorversion, u8 *hw_minorversion,
438 u8 *fw_majorversion, u8 *fw_minorversion)
aacb9d31 439{
e12671cf 440 u16 data;
aacb9d31
ST		 441 int result;
442
bdd33563 443 result = xc5000_readreg(priv, XREG_VERSION, &data);
7988fc21 444 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 445 return result;
446
e12671cf
ST		 447 (*hw_majorversion) = (data >> 12) & 0x0F;
448 (*hw_minorversion) = (data >> 8) & 0x0F;
449 (*fw_majorversion) = (data >> 4) & 0x0F;
450 (*fw_minorversion) = data & 0x0F;
aacb9d31
ST		 451
452 return 0;
453}
454
e12671cf 455static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
aacb9d31 456{
e12671cf 457 u16 regData;
aacb9d31
ST		 458 int result;
459
bdd33563 460 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
7988fc21 461 if (result != XC_RESULT_SUCCESS)
aacb9d31
ST		 462 return result;
463
464 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
465 return result;
466}
467
e12671cf 468static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
aacb9d31 469{
bdd33563 470 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
aacb9d31
ST		 471}
472
e12671cf 473static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
aacb9d31 474{
bdd33563 475 return xc5000_readreg(priv, XREG_QUALITY, quality);
aacb9d31
ST		 476}
477
e12671cf 478static u16 WaitForLock(struct xc5000_priv *priv)
aacb9d31 479{
e12671cf 480 u16 lockState = 0;
aacb9d31 481 int watchDogCount = 40;
e12671cf
ST		 482
483 while ((lockState == 0) && (watchDogCount > 0)) {
aacb9d31 484 xc_get_lock_status(priv, &lockState);
e12671cf 485 if (lockState != 1) {
aacb9d31
ST		 486 xc_wait(5);
487 watchDogCount--;
488 }
489 }
490 return lockState;
491}
492
a78baacf
DH		 493#define XC_TUNE_ANALOG 0
494#define XC_TUNE_DIGITAL 1
495static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
aacb9d31
ST		 496{
497 int found = 0;
498
271ddbf7 499 dprintk(1, "%s(%u)\n", __func__, freq_hz);
aacb9d31 500
e12671cf 501 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
aacb9d31
ST		 502 return 0;
503
a78baacf
DH		 504 if (mode == XC_TUNE_ANALOG) {
505 if (WaitForLock(priv) == 1)
506 found = 1;
507 }
aacb9d31
ST		 508
509 return found;
510}
511
512static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
513{
514 u8 buf[2] = { reg >> 8, reg & 0xff };
515 u8 bval[2] = { 0, 0 };
516 struct i2c_msg msg[2] = {
89fd2854 517 { .addr = priv->i2c_props.addr,
aacb9d31 518 .flags = 0, .buf = &buf[0], .len = 2 },
89fd2854 519 { .addr = priv->i2c_props.addr,
aacb9d31
ST		 520 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
521 };
522
89fd2854 523 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
27c685a4 524 printk(KERN_WARNING "xc5000: I2C read failed\n");
aacb9d31
ST		 525 return -EREMOTEIO;
526 }
527
528 *val = (bval[0] << 8) | bval[1];
bdd33563 529 return XC_RESULT_SUCCESS;
aacb9d31
ST		 530}
531
8f3cd530 532static int xc5000_fwupload(struct dvb_frontend *fe)
aacb9d31
ST		 533{
534 struct xc5000_priv *priv = fe->tuner_priv;
535 const struct firmware *fw;
536 int ret;
537
e12671cf
ST		 538 /* request the firmware, this will block and timeout */
539 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
540 XC5000_DEFAULT_FIRMWARE);
541
8f3cd530 542 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
e9785250 543 priv->i2c_props.adap->dev.parent);
aacb9d31
ST		 544 if (ret) {
545 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
546 ret = XC_RESULT_RESET_FAILURE;
5ea60531 547 goto out;
aacb9d31 548 } else {
3f51451b
MK		 549 printk(KERN_INFO "xc5000: firmware read %Zu bytes.\n",
550 fw->size);
aacb9d31
ST		 551 ret = XC_RESULT_SUCCESS;
552 }
553
e12671cf 554 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
aacb9d31
ST		 555 printk(KERN_ERR "xc5000: firmware incorrect size\n");
556 ret = XC_RESULT_RESET_FAILURE;
557 } else {
558 printk(KERN_INFO "xc5000: firmware upload\n");
8f3cd530 559 ret = xc_load_i2c_sequence(fe, fw->data);
aacb9d31
ST		 560 }
561
5ea60531 562out:
aacb9d31
ST		 563 release_firmware(fw);
564 return ret;
565}
566
e12671cf 567static void xc_debug_dump(struct xc5000_priv *priv)
aacb9d31 568{
e12671cf
ST		 569 u16 adc_envelope;
570 u32 freq_error_hz = 0;
571 u16 lock_status;
572 u32 hsync_freq_hz = 0;
573 u16 frame_lines;
574 u16 quality;
575 u8 hw_majorversion = 0, hw_minorversion = 0;
576 u8 fw_majorversion = 0, fw_minorversion = 0;
aacb9d31
ST		 577
578 /* Wait for stats to stabilize.
579 * Frame Lines needs two frame times after initial lock
580 * before it is valid.
581 */
e12671cf 582 xc_wait(100);
aacb9d31 583
e12671cf
ST		 584 xc_get_ADC_Envelope(priv, &adc_envelope);
585 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
aacb9d31 586
e12671cf
ST		 587 xc_get_frequency_error(priv, &freq_error_hz);
588 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
aacb9d31 589
e12671cf
ST		 590 xc_get_lock_status(priv, &lock_status);
591 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
aacb9d31
ST		 592 lock_status);
593
594 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
e12671cf 595 &fw_majorversion, &fw_minorversion);
aacb9d31
ST		 596 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
597 hw_majorversion, hw_minorversion,
598 fw_majorversion, fw_minorversion);
599
e12671cf
ST		 600 xc_get_hsync_freq(priv, &hsync_freq_hz);
601 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
aacb9d31 602
e12671cf
ST		 603 xc_get_frame_lines(priv, &frame_lines);
604 dprintk(1, "*** Frame lines = %d\n", frame_lines);
aacb9d31 605
e12671cf
ST		 606 xc_get_quality(priv, &quality);
607 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
aacb9d31
ST		 608}
609
610static int xc5000_set_params(struct dvb_frontend *fe,
611 struct dvb_frontend_parameters *params)
612{
613 struct xc5000_priv *priv = fe->tuner_priv;
e12671cf 614 int ret;
aacb9d31 615
8e4c6797
DH		 616 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
617 xc_load_fw_and_init_tuner(fe);
618
271ddbf7 619 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
aacb9d31 620
8f3cd530 621 switch (params->u.vsb.modulation) {
aacb9d31
ST		 622 case VSB_8:
623 case VSB_16:
271ddbf7 624 dprintk(1, "%s() VSB modulation\n", __func__);
aacb9d31 625 priv->rf_mode = XC_RF_MODE_AIR;
e12671cf
ST		 626 priv->freq_hz = params->frequency - 1750000;
627 priv->bandwidth = BANDWIDTH_6_MHZ;
628 priv->video_standard = DTV6;
aacb9d31
ST		 629 break;
630 case QAM_64:
631 case QAM_256:
632 case QAM_AUTO:
271ddbf7 633 dprintk(1, "%s() QAM modulation\n", __func__);
aacb9d31 634 priv->rf_mode = XC_RF_MODE_CABLE;
e12671cf
ST		 635 priv->freq_hz = params->frequency - 1750000;
636 priv->bandwidth = BANDWIDTH_6_MHZ;
637 priv->video_standard = DTV6;
aacb9d31
ST		 638 break;
639 default:
640 return -EINVAL;
641 }
642
643 dprintk(1, "%s() frequency=%d (compensated)\n",
271ddbf7 644 __func__, priv->freq_hz);
aacb9d31 645
e12671cf
ST		 646 ret = xc_SetSignalSource(priv, priv->rf_mode);
647 if (ret != XC_RESULT_SUCCESS) {
648 printk(KERN_ERR
649 "xc5000: xc_SetSignalSource(%d) failed\n",
650 priv->rf_mode);
651 return -EREMOTEIO;
652 }
aacb9d31 653
e12671cf 654 ret = xc_SetTVStandard(priv,
aacb9d31
ST		 655 XC5000_Standard[priv->video_standard].VideoMode,
656 XC5000_Standard[priv->video_standard].AudioMode);
e12671cf
ST		 657 if (ret != XC_RESULT_SUCCESS) {
658 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
659 return -EREMOTEIO;
660 }
661
2a6003c2 662 ret = xc_set_IF_frequency(priv, priv->if_khz);
e12671cf
ST		 663 if (ret != XC_RESULT_SUCCESS) {
664 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
2a6003c2 665 priv->if_khz);
e12671cf
ST		 666 return -EIO;
667 }
668
a78baacf 669 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
aacb9d31 670
e12671cf
ST		 671 if (debug)
672 xc_debug_dump(priv);
aacb9d31
ST		 673
674 return 0;
675}
676
e470d817
ST		 677static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
678{
679 struct xc5000_priv *priv = fe->tuner_priv;
680 int ret;
681 u16 id;
682
683 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
684 if (ret == XC_RESULT_SUCCESS) {
685 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
686 ret = XC_RESULT_RESET_FAILURE;
687 else
688 ret = XC_RESULT_SUCCESS;
689 }
690
691 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
692 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
693 return ret;
694}
695
27c685a4
ST		 696static int xc5000_set_analog_params(struct dvb_frontend *fe,
697 struct analog_parameters *params)
698{
699 struct xc5000_priv *priv = fe->tuner_priv;
700 int ret;
701
e470d817 702 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
27c685a4
ST		 703 xc_load_fw_and_init_tuner(fe);
704
705 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
271ddbf7 706 __func__, params->frequency);
27c685a4 707
1fab14ed
MCC		 708 /* Fix me: it could be air. */
709 priv->rf_mode = params->mode;
710 if (params->mode > XC_RF_MODE_CABLE)
711 priv->rf_mode = XC_RF_MODE_CABLE;
27c685a4
ST		 712
713 /* params->frequency is in units of 62.5khz */
714 priv->freq_hz = params->frequency * 62500;
715
716 /* FIX ME: Some video standards may have several possible audio
717 standards. We simply default to one of them here.
718 */
8f3cd530 719 if (params->std & V4L2_STD_MN) {
27c685a4
ST		 720 /* default to BTSC audio standard */
721 priv->video_standard = MN_NTSC_PAL_BTSC;
722 goto tune_channel;
723 }
724
8f3cd530 725 if (params->std & V4L2_STD_PAL_BG) {
27c685a4
ST		 726 /* default to NICAM audio standard */
727 priv->video_standard = BG_PAL_NICAM;
728 goto tune_channel;
729 }
730
8f3cd530 731 if (params->std & V4L2_STD_PAL_I) {
27c685a4
ST		 732 /* default to NICAM audio standard */
733 priv->video_standard = I_PAL_NICAM;
734 goto tune_channel;
735 }
736
8f3cd530 737 if (params->std & V4L2_STD_PAL_DK) {
27c685a4
ST		 738 /* default to NICAM audio standard */
739 priv->video_standard = DK_PAL_NICAM;
740 goto tune_channel;
741 }
742
8f3cd530 743 if (params->std & V4L2_STD_SECAM_DK) {
27c685a4
ST		 744 /* default to A2 DK1 audio standard */
745 priv->video_standard = DK_SECAM_A2DK1;
746 goto tune_channel;
747 }
748
8f3cd530 749 if (params->std & V4L2_STD_SECAM_L) {
27c685a4
ST		 750 priv->video_standard = L_SECAM_NICAM;
751 goto tune_channel;
752 }
753
8f3cd530 754 if (params->std & V4L2_STD_SECAM_LC) {
27c685a4
ST		 755 priv->video_standard = LC_SECAM_NICAM;
756 goto tune_channel;
757 }
758
759tune_channel:
760 ret = xc_SetSignalSource(priv, priv->rf_mode);
761 if (ret != XC_RESULT_SUCCESS) {
8f3cd530 762 printk(KERN_ERR
27c685a4
ST		 763 "xc5000: xc_SetSignalSource(%d) failed\n",
764 priv->rf_mode);
765 return -EREMOTEIO;
766 }
767
768 ret = xc_SetTVStandard(priv,
769 XC5000_Standard[priv->video_standard].VideoMode,
770 XC5000_Standard[priv->video_standard].AudioMode);
771 if (ret != XC_RESULT_SUCCESS) {
772 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
773 return -EREMOTEIO;
774 }
775
a78baacf 776 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
27c685a4
ST		 777
778 if (debug)
779 xc_debug_dump(priv);
780
781 return 0;
782}
783
aacb9d31
ST		 784static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
785{
786 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 787 dprintk(1, "%s()\n", __func__);
e12671cf 788 *freq = priv->freq_hz;
aacb9d31
ST		 789 return 0;
790}
791
792static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
793{
794 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 795 dprintk(1, "%s()\n", __func__);
27c685a4 796
aacb9d31
ST		 797 *bw = priv->bandwidth;
798 return 0;
799}
800
801static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
802{
803 struct xc5000_priv *priv = fe->tuner_priv;
e12671cf 804 u16 lock_status = 0;
aacb9d31
ST		 805
806 xc_get_lock_status(priv, &lock_status);
807
271ddbf7 808 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
aacb9d31
ST		 809
810 *status = lock_status;
811
812 return 0;
813}
814
e12671cf 815static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
aacb9d31
ST		 816{
817 struct xc5000_priv *priv = fe->tuner_priv;
27c685a4 818 int ret = 0;
aacb9d31 819
e470d817 820 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
aacb9d31 821 ret = xc5000_fwupload(fe);
e12671cf
ST		 822 if (ret != XC_RESULT_SUCCESS)
823 return ret;
aacb9d31
ST		 824 }
825
826 /* Start the tuner self-calibration process */
827 ret |= xc_initialize(priv);
828
829 /* Wait for calibration to complete.
830 * We could continue but XC5000 will clock stretch subsequent
831 * I2C transactions until calibration is complete. This way we
832 * don't have to rely on clock stretching working.
833 */
8f3cd530 834 xc_wait(100);
aacb9d31
ST		 835
836 /* Default to "CABLE" mode */
837 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
838
839 return ret;
840}
841
e12671cf
ST		 842static int xc5000_sleep(struct dvb_frontend *fe)
843{
27c685a4
ST		 844 int ret;
845
271ddbf7 846 dprintk(1, "%s()\n", __func__);
e12671cf 847
7f05b530
DH		 848 /* According to Xceive technical support, the "powerdown" register
849 was removed in newer versions of the firmware. The "supported"
850 way to sleep the tuner is to pull the reset pin low for 10ms */
851 ret = xc5000_TunerReset(fe);
8f3cd530 852 if (ret != XC_RESULT_SUCCESS) {
27c685a4
ST		 853 printk(KERN_ERR
854 "xc5000: %s() unable to shutdown tuner\n",
271ddbf7 855 __func__);
27c685a4 856 return -EREMOTEIO;
8f3cd530 857 } else
27c685a4 858 return XC_RESULT_SUCCESS;
e12671cf
ST		 859}
860
aacb9d31
ST		 861static int xc5000_init(struct dvb_frontend *fe)
862{
863 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 864 dprintk(1, "%s()\n", __func__);
aacb9d31 865
e12671cf
ST		 866 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
867 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
868 return -EREMOTEIO;
869 }
870
871 if (debug)
872 xc_debug_dump(priv);
aacb9d31
ST		 873
874 return 0;
875}
876
877static int xc5000_release(struct dvb_frontend *fe)
878{
89fd2854
MK		 879 struct xc5000_priv *priv = fe->tuner_priv;
880
271ddbf7 881 dprintk(1, "%s()\n", __func__);
89fd2854
MK		 882
883 mutex_lock(&xc5000_list_mutex);
884
885 if (priv)
886 hybrid_tuner_release_state(priv);
887
888 mutex_unlock(&xc5000_list_mutex);
889
aacb9d31 890 fe->tuner_priv = NULL;
89fd2854 891
aacb9d31
ST		 892 return 0;
893}
894
895static const struct dvb_tuner_ops xc5000_tuner_ops = {
896 .info = {
897 .name = "Xceive XC5000",
898 .frequency_min = 1000000,
899 .frequency_max = 1023000000,
900 .frequency_step = 50000,
901 },
902
27c685a4
ST		 903 .release = xc5000_release,
904 .init = xc5000_init,
905 .sleep = xc5000_sleep,
aacb9d31 906
27c685a4
ST		 907 .set_params = xc5000_set_params,
908 .set_analog_params = xc5000_set_analog_params,
909 .get_frequency = xc5000_get_frequency,
910 .get_bandwidth = xc5000_get_bandwidth,
911 .get_status = xc5000_get_status
aacb9d31
ST		 912};
913
48723543
MK		 914struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
915 struct i2c_adapter *i2c,
30650961 916 struct xc5000_config *cfg)
aacb9d31
ST		 917{
918 struct xc5000_priv *priv = NULL;
89fd2854 919 int instance;
aacb9d31
ST		 920 u16 id = 0;
921
89fd2854
MK		 922 dprintk(1, "%s(%d-%04x)\n", __func__,
923 i2c ? i2c_adapter_id(i2c) : -1,
924 cfg ? cfg->i2c_address : -1);
aacb9d31 925
89fd2854 926 mutex_lock(&xc5000_list_mutex);
aacb9d31 927
89fd2854
MK		 928 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
929 hybrid_tuner_instance_list,
930 i2c, cfg->i2c_address, "xc5000");
931 switch (instance) {
932 case 0:
933 goto fail;
934 break;
935 case 1:
936 /* new tuner instance */
89fd2854 937 priv->bandwidth = BANDWIDTH_6_MHZ;
89fd2854
MK		 938 fe->tuner_priv = priv;
939 break;
940 default:
941 /* existing tuner instance */
942 fe->tuner_priv = priv;
943 break;
944 }
aacb9d31 945
ea227863
DH		 946 if (priv->if_khz == 0) {
947 /* If the IF hasn't been set yet, use the value provided by
948 the caller (occurs in hybrid devices where the analog
949 call to xc5000_attach occurs before the digital side) */
950 priv->if_khz = cfg->if_khz;
951 }
952
27c685a4
ST		 953 /* Check if firmware has been loaded. It is possible that another
954 instance of the driver has loaded the firmware.
955 */
7988fc21 956 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
89fd2854 957 goto fail;
aacb9d31 958
8f3cd530 959 switch (id) {
27c685a4
ST		 960 case XC_PRODUCT_ID_FW_LOADED:
961 printk(KERN_INFO
962 "xc5000: Successfully identified at address 0x%02x\n",
963 cfg->i2c_address);
964 printk(KERN_INFO
965 "xc5000: Firmware has been loaded previously\n");
27c685a4
ST		 966 break;
967 case XC_PRODUCT_ID_FW_NOT_LOADED:
968 printk(KERN_INFO
969 "xc5000: Successfully identified at address 0x%02x\n",
970 cfg->i2c_address);
971 printk(KERN_INFO
972 "xc5000: Firmware has not been loaded previously\n");
27c685a4
ST		 973 break;
974 default:
aacb9d31
ST		 975 printk(KERN_ERR
976 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
977 cfg->i2c_address, id);
89fd2854 978 goto fail;
aacb9d31
ST		 979 }
980
89fd2854
MK		 981 mutex_unlock(&xc5000_list_mutex);
982
aacb9d31
ST		 983 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
984 sizeof(struct dvb_tuner_ops));
985
aacb9d31 986 return fe;
89fd2854
MK		 987fail:
988 mutex_unlock(&xc5000_list_mutex);
989
990 xc5000_release(fe);
991 return NULL;
aacb9d31
ST		 992}
993EXPORT_SYMBOL(xc5000_attach);
994
995MODULE_AUTHOR("Steven Toth");
e12671cf 996MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
aacb9d31 997MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)