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