projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (11802): xc5000: switch to new xc5000 firmware 1.6.114 with redistribution...
[deliverable/linux.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];
aacb9d31
ST		 265 int WatchDogTimer = 5;
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 {
287 xc_wait(100); /* wait 5 ms */
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
8f3cd530 639 switch (params->u.vsb.modulation) {
aacb9d31
ST		 640 case VSB_8:
641 case VSB_16:
271ddbf7 642 dprintk(1, "%s() VSB modulation\n", __func__);
aacb9d31 643 priv->rf_mode = XC_RF_MODE_AIR;
e12671cf
ST		 644 priv->freq_hz = params->frequency - 1750000;
645 priv->bandwidth = BANDWIDTH_6_MHZ;
646 priv->video_standard = DTV6;
aacb9d31
ST		 647 break;
648 case QAM_64:
649 case QAM_256:
650 case QAM_AUTO:
271ddbf7 651 dprintk(1, "%s() QAM modulation\n", __func__);
aacb9d31 652 priv->rf_mode = XC_RF_MODE_CABLE;
e12671cf
ST		 653 priv->freq_hz = params->frequency - 1750000;
654 priv->bandwidth = BANDWIDTH_6_MHZ;
655 priv->video_standard = DTV6;
aacb9d31
ST		 656 break;
657 default:
658 return -EINVAL;
659 }
660
661 dprintk(1, "%s() frequency=%d (compensated)\n",
271ddbf7 662 __func__, priv->freq_hz);
aacb9d31 663
e12671cf
ST		 664 ret = xc_SetSignalSource(priv, priv->rf_mode);
665 if (ret != XC_RESULT_SUCCESS) {
666 printk(KERN_ERR
667 "xc5000: xc_SetSignalSource(%d) failed\n",
668 priv->rf_mode);
669 return -EREMOTEIO;
670 }
aacb9d31 671
e12671cf 672 ret = xc_SetTVStandard(priv,
aacb9d31
ST		 673 XC5000_Standard[priv->video_standard].VideoMode,
674 XC5000_Standard[priv->video_standard].AudioMode);
e12671cf
ST		 675 if (ret != XC_RESULT_SUCCESS) {
676 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
677 return -EREMOTEIO;
678 }
679
2a6003c2 680 ret = xc_set_IF_frequency(priv, priv->if_khz);
e12671cf
ST		 681 if (ret != XC_RESULT_SUCCESS) {
682 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
2a6003c2 683 priv->if_khz);
e12671cf
ST		 684 return -EIO;
685 }
686
a78baacf 687 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
aacb9d31 688
e12671cf
ST		 689 if (debug)
690 xc_debug_dump(priv);
aacb9d31
ST		 691
692 return 0;
693}
694
e470d817
ST		 695static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
696{
697 struct xc5000_priv *priv = fe->tuner_priv;
698 int ret;
699 u16 id;
700
701 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
702 if (ret == XC_RESULT_SUCCESS) {
703 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
704 ret = XC_RESULT_RESET_FAILURE;
705 else
706 ret = XC_RESULT_SUCCESS;
707 }
708
709 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
710 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
711 return ret;
712}
713
27c685a4
ST		 714static int xc5000_set_analog_params(struct dvb_frontend *fe,
715 struct analog_parameters *params)
716{
717 struct xc5000_priv *priv = fe->tuner_priv;
718 int ret;
719
e470d817 720 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS)
27c685a4
ST		 721 xc_load_fw_and_init_tuner(fe);
722
723 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
271ddbf7 724 __func__, params->frequency);
27c685a4 725
1fab14ed
MCC		 726 /* Fix me: it could be air. */
727 priv->rf_mode = params->mode;
728 if (params->mode > XC_RF_MODE_CABLE)
729 priv->rf_mode = XC_RF_MODE_CABLE;
27c685a4
ST		 730
731 /* params->frequency is in units of 62.5khz */
732 priv->freq_hz = params->frequency * 62500;
733
734 /* FIX ME: Some video standards may have several possible audio
735 standards. We simply default to one of them here.
736 */
8f3cd530 737 if (params->std & V4L2_STD_MN) {
27c685a4
ST		 738 /* default to BTSC audio standard */
739 priv->video_standard = MN_NTSC_PAL_BTSC;
740 goto tune_channel;
741 }
742
8f3cd530 743 if (params->std & V4L2_STD_PAL_BG) {
27c685a4
ST		 744 /* default to NICAM audio standard */
745 priv->video_standard = BG_PAL_NICAM;
746 goto tune_channel;
747 }
748
8f3cd530 749 if (params->std & V4L2_STD_PAL_I) {
27c685a4
ST		 750 /* default to NICAM audio standard */
751 priv->video_standard = I_PAL_NICAM;
752 goto tune_channel;
753 }
754
8f3cd530 755 if (params->std & V4L2_STD_PAL_DK) {
27c685a4
ST		 756 /* default to NICAM audio standard */
757 priv->video_standard = DK_PAL_NICAM;
758 goto tune_channel;
759 }
760
8f3cd530 761 if (params->std & V4L2_STD_SECAM_DK) {
27c685a4
ST		 762 /* default to A2 DK1 audio standard */
763 priv->video_standard = DK_SECAM_A2DK1;
764 goto tune_channel;
765 }
766
8f3cd530 767 if (params->std & V4L2_STD_SECAM_L) {
27c685a4
ST		 768 priv->video_standard = L_SECAM_NICAM;
769 goto tune_channel;
770 }
771
8f3cd530 772 if (params->std & V4L2_STD_SECAM_LC) {
27c685a4
ST		 773 priv->video_standard = LC_SECAM_NICAM;
774 goto tune_channel;
775 }
776
777tune_channel:
778 ret = xc_SetSignalSource(priv, priv->rf_mode);
779 if (ret != XC_RESULT_SUCCESS) {
8f3cd530 780 printk(KERN_ERR
27c685a4
ST		 781 "xc5000: xc_SetSignalSource(%d) failed\n",
782 priv->rf_mode);
783 return -EREMOTEIO;
784 }
785
786 ret = xc_SetTVStandard(priv,
787 XC5000_Standard[priv->video_standard].VideoMode,
788 XC5000_Standard[priv->video_standard].AudioMode);
789 if (ret != XC_RESULT_SUCCESS) {
790 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
791 return -EREMOTEIO;
792 }
793
a78baacf 794 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
27c685a4
ST		 795
796 if (debug)
797 xc_debug_dump(priv);
798
799 return 0;
800}
801
aacb9d31
ST		 802static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
803{
804 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 805 dprintk(1, "%s()\n", __func__);
e12671cf 806 *freq = priv->freq_hz;
aacb9d31
ST		 807 return 0;
808}
809
810static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
811{
812 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 813 dprintk(1, "%s()\n", __func__);
27c685a4 814
aacb9d31
ST		 815 *bw = priv->bandwidth;
816 return 0;
817}
818
819static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
820{
821 struct xc5000_priv *priv = fe->tuner_priv;
e12671cf 822 u16 lock_status = 0;
aacb9d31
ST		 823
824 xc_get_lock_status(priv, &lock_status);
825
271ddbf7 826 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
aacb9d31
ST		 827
828 *status = lock_status;
829
830 return 0;
831}
832
e12671cf 833static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
aacb9d31
ST		 834{
835 struct xc5000_priv *priv = fe->tuner_priv;
27c685a4 836 int ret = 0;
aacb9d31 837
e470d817 838 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
aacb9d31 839 ret = xc5000_fwupload(fe);
e12671cf
ST		 840 if (ret != XC_RESULT_SUCCESS)
841 return ret;
aacb9d31
ST		 842 }
843
844 /* Start the tuner self-calibration process */
845 ret |= xc_initialize(priv);
846
847 /* Wait for calibration to complete.
848 * We could continue but XC5000 will clock stretch subsequent
849 * I2C transactions until calibration is complete. This way we
850 * don't have to rely on clock stretching working.
851 */
8f3cd530 852 xc_wait(100);
aacb9d31
ST		 853
854 /* Default to "CABLE" mode */
855 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
856
857 return ret;
858}
859
e12671cf
ST		 860static int xc5000_sleep(struct dvb_frontend *fe)
861{
27c685a4
ST		 862 int ret;
863
271ddbf7 864 dprintk(1, "%s()\n", __func__);
e12671cf 865
b6bd5eb8
DH		 866 /* Avoid firmware reload on slow devices */
867 if (no_poweroff)
868 return 0;
869
7f05b530
DH		 870 /* According to Xceive technical support, the "powerdown" register
871 was removed in newer versions of the firmware. The "supported"
872 way to sleep the tuner is to pull the reset pin low for 10ms */
873 ret = xc5000_TunerReset(fe);
8f3cd530 874 if (ret != XC_RESULT_SUCCESS) {
27c685a4
ST		 875 printk(KERN_ERR
876 "xc5000: %s() unable to shutdown tuner\n",
271ddbf7 877 __func__);
27c685a4 878 return -EREMOTEIO;
8f3cd530 879 } else
27c685a4 880 return XC_RESULT_SUCCESS;
e12671cf
ST		 881}
882
aacb9d31
ST		 883static int xc5000_init(struct dvb_frontend *fe)
884{
885 struct xc5000_priv *priv = fe->tuner_priv;
271ddbf7 886 dprintk(1, "%s()\n", __func__);
aacb9d31 887
e12671cf
ST		 888 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
889 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
890 return -EREMOTEIO;
891 }
892
893 if (debug)
894 xc_debug_dump(priv);
aacb9d31
ST		 895
896 return 0;
897}
898
899static int xc5000_release(struct dvb_frontend *fe)
900{
89fd2854
MK		 901 struct xc5000_priv *priv = fe->tuner_priv;
902
271ddbf7 903 dprintk(1, "%s()\n", __func__);
89fd2854
MK		 904
905 mutex_lock(&xc5000_list_mutex);
906
907 if (priv)
908 hybrid_tuner_release_state(priv);
909
910 mutex_unlock(&xc5000_list_mutex);
911
aacb9d31 912 fe->tuner_priv = NULL;
89fd2854 913
aacb9d31
ST		 914 return 0;
915}
916
917static const struct dvb_tuner_ops xc5000_tuner_ops = {
918 .info = {
919 .name = "Xceive XC5000",
920 .frequency_min = 1000000,
921 .frequency_max = 1023000000,
922 .frequency_step = 50000,
923 },
924
27c685a4
ST		 925 .release = xc5000_release,
926 .init = xc5000_init,
927 .sleep = xc5000_sleep,
aacb9d31 928
27c685a4
ST		 929 .set_params = xc5000_set_params,
930 .set_analog_params = xc5000_set_analog_params,
931 .get_frequency = xc5000_get_frequency,
932 .get_bandwidth = xc5000_get_bandwidth,
933 .get_status = xc5000_get_status
aacb9d31
ST		 934};
935
48723543
MK		 936struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
937 struct i2c_adapter *i2c,
30650961 938 struct xc5000_config *cfg)
aacb9d31
ST		 939{
940 struct xc5000_priv *priv = NULL;
89fd2854 941 int instance;
aacb9d31
ST		 942 u16 id = 0;
943
89fd2854
MK		 944 dprintk(1, "%s(%d-%04x)\n", __func__,
945 i2c ? i2c_adapter_id(i2c) : -1,
946 cfg ? cfg->i2c_address : -1);
aacb9d31 947
89fd2854 948 mutex_lock(&xc5000_list_mutex);
aacb9d31 949
89fd2854
MK		 950 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
951 hybrid_tuner_instance_list,
952 i2c, cfg->i2c_address, "xc5000");
953 switch (instance) {
954 case 0:
955 goto fail;
956 break;
957 case 1:
958 /* new tuner instance */
89fd2854 959 priv->bandwidth = BANDWIDTH_6_MHZ;
89fd2854
MK		 960 fe->tuner_priv = priv;
961 break;
962 default:
963 /* existing tuner instance */
964 fe->tuner_priv = priv;
965 break;
966 }
aacb9d31 967
ea227863
DH		 968 if (priv->if_khz == 0) {
969 /* If the IF hasn't been set yet, use the value provided by
970 the caller (occurs in hybrid devices where the analog
971 call to xc5000_attach occurs before the digital side) */
972 priv->if_khz = cfg->if_khz;
973 }
974
27c685a4
ST		 975 /* Check if firmware has been loaded. It is possible that another
976 instance of the driver has loaded the firmware.
977 */
7988fc21 978 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
89fd2854 979 goto fail;
aacb9d31 980
8f3cd530 981 switch (id) {
27c685a4
ST		 982 case XC_PRODUCT_ID_FW_LOADED:
983 printk(KERN_INFO
984 "xc5000: Successfully identified at address 0x%02x\n",
985 cfg->i2c_address);
986 printk(KERN_INFO
987 "xc5000: Firmware has been loaded previously\n");
27c685a4
ST		 988 break;
989 case XC_PRODUCT_ID_FW_NOT_LOADED:
990 printk(KERN_INFO
991 "xc5000: Successfully identified at address 0x%02x\n",
992 cfg->i2c_address);
993 printk(KERN_INFO
994 "xc5000: Firmware has not been loaded previously\n");
27c685a4
ST		 995 break;
996 default:
aacb9d31
ST		 997 printk(KERN_ERR
998 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
999 cfg->i2c_address, id);
89fd2854 1000 goto fail;
aacb9d31
ST		 1001 }
1002
89fd2854
MK		 1003 mutex_unlock(&xc5000_list_mutex);
1004
aacb9d31
ST		 1005 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1006 sizeof(struct dvb_tuner_ops));
1007
aacb9d31 1008 return fe;
89fd2854
MK		 1009fail:
1010 mutex_unlock(&xc5000_list_mutex);
1011
1012 xc5000_release(fe);
1013 return NULL;
aacb9d31
ST		 1014}
1015EXPORT_SYMBOL(xc5000_attach);
1016
1017MODULE_AUTHOR("Steven Toth");
e12671cf 1018MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
aacb9d31 1019MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.257311 seconds and 5 git commands to generate.