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