projects / deliverable / linux.git / blob
? search:


bac8009e1d4979680211fddcd8a06e7c71a4e23c
[deliverable/linux.git] / drivers / media / common / tuners / xc5000.c
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 struct xc5000_priv {
53 struct tuner_i2c_props i2c_props;
54 struct list_head hybrid_tuner_instance_list;
55
56 u32 if_khz;
57 u16 xtal_khz;
58 u32 freq_hz;
59 u32 bandwidth;
60 u8 video_standard;
61 u8 rf_mode;
62 u8 radio_input;
63
64 int chip_id;
65 };
66
67 /* Misc Defines */
68 #define MAX_TV_STANDARD 24
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 /* Set the output amplitude - SIF for analog, DTVP/DTVN for digital */
96 #define XREG_OUTPUT_AMP 0x0B
97 #define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
98 #define XREG_SMOOTHEDCVBS 0x0E
99 #define XREG_XTALFREQ 0x0F
100 #define XREG_FINERFREQ 0x10
101 #define XREG_DDIMODE 0x11
102
103 #define XREG_ADC_ENV 0x00
104 #define XREG_QUALITY 0x01
105 #define XREG_FRAME_LINES 0x02
106 #define XREG_HSYNC_FREQ 0x03
107 #define XREG_LOCK 0x04
108 #define XREG_FREQ_ERROR 0x05
109 #define XREG_SNR 0x06
110 #define XREG_VERSION 0x07
111 #define XREG_PRODUCT_ID 0x08
112 #define XREG_BUSY 0x09
113 #define XREG_BUILD 0x0D
114
115 /*
116 Basic firmware description. This will remain with
117 the driver for documentation purposes.
118
119 This represents an I2C firmware file encoded as a
120 string of unsigned char. Format is as follows:
121
122 char[0 ]=len0_MSB -> len = len_MSB * 256 + len_LSB
123 char[1 ]=len0_LSB -> length of first write transaction
124 char[2 ]=data0 -> first byte to be sent
125 char[3 ]=data1
126 char[4 ]=data2
127 char[ ]=...
128 char[M ]=dataN -> last byte to be sent
129 char[M+1]=len1_MSB -> len = len_MSB * 256 + len_LSB
130 char[M+2]=len1_LSB -> length of second write transaction
131 char[M+3]=data0
132 char[M+4]=data1
133 ...
134 etc.
135
136 The [len] value should be interpreted as follows:
137
138 len= len_MSB _ len_LSB
139 len=1111_1111_1111_1111 : End of I2C_SEQUENCE
140 len=0000_0000_0000_0000 : Reset command: Do hardware reset
141 len=0NNN_NNNN_NNNN_NNNN : Normal transaction: number of bytes = {1:32767)
142 len=1WWW_WWWW_WWWW_WWWW : Wait command: wait for {1:32767} ms
143
144 For the RESET and WAIT commands, the two following bytes will contain
145 immediately the length of the following transaction.
146
147 */
148 struct XC_TV_STANDARD {
149 char *Name;
150 u16 AudioMode;
151 u16 VideoMode;
152 };
153
154 /* Tuner standards */
155 #define MN_NTSC_PAL_BTSC 0
156 #define MN_NTSC_PAL_A2 1
157 #define MN_NTSC_PAL_EIAJ 2
158 #define MN_NTSC_PAL_Mono 3
159 #define BG_PAL_A2 4
160 #define BG_PAL_NICAM 5
161 #define BG_PAL_MONO 6
162 #define I_PAL_NICAM 7
163 #define I_PAL_NICAM_MONO 8
164 #define DK_PAL_A2 9
165 #define DK_PAL_NICAM 10
166 #define DK_PAL_MONO 11
167 #define DK_SECAM_A2DK1 12
168 #define DK_SECAM_A2LDK3 13
169 #define DK_SECAM_A2MONO 14
170 #define L_SECAM_NICAM 15
171 #define LC_SECAM_NICAM 16
172 #define DTV6 17
173 #define DTV8 18
174 #define DTV7_8 19
175 #define DTV7 20
176 #define FM_Radio_INPUT2 21
177 #define FM_Radio_INPUT1 22
178 #define FM_Radio_INPUT1_MONO 23
179
180 static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
181 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
182 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
183 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
184 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
185 {"B/G-PAL-A2", 0x0A00, 0x8049},
186 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
187 {"B/G-PAL-MONO", 0x0878, 0x8059},
188 {"I-PAL-NICAM", 0x1080, 0x8009},
189 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
190 {"D/K-PAL-A2", 0x1600, 0x8009},
191 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
192 {"D/K-PAL-MONO", 0x1478, 0x8009},
193 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
194 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
195 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
196 {"L-SECAM-NICAM", 0x8E82, 0x0009},
197 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
198 {"DTV6", 0x00C0, 0x8002},
199 {"DTV8", 0x00C0, 0x800B},
200 {"DTV7/8", 0x00C0, 0x801B},
201 {"DTV7", 0x00C0, 0x8007},
202 {"FM Radio-INPUT2", 0x9802, 0x9002},
203 {"FM Radio-INPUT1", 0x0208, 0x9002},
204 {"FM Radio-INPUT1_MONO", 0x0278, 0x9002}
205 };
206
207
208 struct xc5000_fw_cfg {
209 char *name;
210 u16 size;
211 };
212
213 static const struct xc5000_fw_cfg xc5000a_1_6_114 = {
214 .name = "dvb-fe-xc5000-1.6.114.fw",
215 .size = 12401,
216 };
217
218 static const struct xc5000_fw_cfg xc5000c_41_024_5 = {
219 .name = "dvb-fe-xc5000c-41.024.5.fw",
220 .size = 16497,
221 };
222
223 static inline const struct xc5000_fw_cfg *xc5000_assign_firmware(int chip_id)
224 {
225 switch (chip_id) {
226 default:
227 case XC5000A:
228 return &xc5000a_1_6_114;
229 case XC5000C:
230 return &xc5000c_41_024_5;
231 }
232 }
233
234 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
235 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
236 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
237 static int xc5000_TunerReset(struct dvb_frontend *fe);
238
239 static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
240 {
241 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
242 .flags = 0, .buf = buf, .len = len };
243
244 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
245 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
246 return XC_RESULT_I2C_WRITE_FAILURE;
247 }
248 return XC_RESULT_SUCCESS;
249 }
250
251 #if 0
252 /* This routine is never used because the only time we read data from the
253 i2c bus is when we read registers, and we want that to be an atomic i2c
254 transaction in case we are on a multi-master bus */
255 static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
256 {
257 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
258 .flags = I2C_M_RD, .buf = buf, .len = len };
259
260 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
261 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
262 return -EREMOTEIO;
263 }
264 return 0;
265 }
266 #endif
267
268 static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
269 {
270 u8 buf[2] = { reg >> 8, reg & 0xff };
271 u8 bval[2] = { 0, 0 };
272 struct i2c_msg msg[2] = {
273 { .addr = priv->i2c_props.addr,
274 .flags = 0, .buf = &buf[0], .len = 2 },
275 { .addr = priv->i2c_props.addr,
276 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
277 };
278
279 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
280 printk(KERN_WARNING "xc5000: I2C read failed\n");
281 return -EREMOTEIO;
282 }
283
284 *val = (bval[0] << 8) | bval[1];
285 return XC_RESULT_SUCCESS;
286 }
287
288 static void xc_wait(int wait_ms)
289 {
290 msleep(wait_ms);
291 }
292
293 static int xc5000_TunerReset(struct dvb_frontend *fe)
294 {
295 struct xc5000_priv *priv = fe->tuner_priv;
296 int ret;
297
298 dprintk(1, "%s()\n", __func__);
299
300 if (fe->callback) {
301 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
302 fe->dvb->priv :
303 priv->i2c_props.adap->algo_data,
304 DVB_FRONTEND_COMPONENT_TUNER,
305 XC5000_TUNER_RESET, 0);
306 if (ret) {
307 printk(KERN_ERR "xc5000: reset failed\n");
308 return XC_RESULT_RESET_FAILURE;
309 }
310 } else {
311 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
312 return XC_RESULT_RESET_FAILURE;
313 }
314 return XC_RESULT_SUCCESS;
315 }
316
317 static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
318 {
319 u8 buf[4];
320 int WatchDogTimer = 100;
321 int result;
322
323 buf[0] = (regAddr >> 8) & 0xFF;
324 buf[1] = regAddr & 0xFF;
325 buf[2] = (i2cData >> 8) & 0xFF;
326 buf[3] = i2cData & 0xFF;
327 result = xc_send_i2c_data(priv, buf, 4);
328 if (result == XC_RESULT_SUCCESS) {
329 /* wait for busy flag to clear */
330 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
331 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
332 if (result == XC_RESULT_SUCCESS) {
333 if ((buf[0] == 0) && (buf[1] == 0)) {
334 /* busy flag cleared */
335 break;
336 } else {
337 xc_wait(5); /* wait 5 ms */
338 WatchDogTimer--;
339 }
340 }
341 }
342 }
343 if (WatchDogTimer < 0)
344 result = XC_RESULT_I2C_WRITE_FAILURE;
345
346 return result;
347 }
348
349 static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
350 {
351 struct xc5000_priv *priv = fe->tuner_priv;
352
353 int i, nbytes_to_send, result;
354 unsigned int len, pos, index;
355 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
356
357 index = 0;
358 while ((i2c_sequence[index] != 0xFF) ||
359 (i2c_sequence[index + 1] != 0xFF)) {
360 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
361 if (len == 0x0000) {
362 /* RESET command */
363 result = xc5000_TunerReset(fe);
364 index += 2;
365 if (result != XC_RESULT_SUCCESS)
366 return result;
367 } else if (len & 0x8000) {
368 /* WAIT command */
369 xc_wait(len & 0x7FFF);
370 index += 2;
371 } else {
372 /* Send i2c data whilst ensuring individual transactions
373 * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
374 */
375 index += 2;
376 buf[0] = i2c_sequence[index];
377 buf[1] = i2c_sequence[index + 1];
378 pos = 2;
379 while (pos < len) {
380 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
381 nbytes_to_send =
382 XC_MAX_I2C_WRITE_LENGTH;
383 else
384 nbytes_to_send = (len - pos + 2);
385 for (i = 2; i < nbytes_to_send; i++) {
386 buf[i] = i2c_sequence[index + pos +
387 i - 2];
388 }
389 result = xc_send_i2c_data(priv, buf,
390 nbytes_to_send);
391
392 if (result != XC_RESULT_SUCCESS)
393 return result;
394
395 pos += nbytes_to_send - 2;
396 }
397 index += len;
398 }
399 }
400 return XC_RESULT_SUCCESS;
401 }
402
403 static int xc_initialize(struct xc5000_priv *priv)
404 {
405 dprintk(1, "%s()\n", __func__);
406 return xc_write_reg(priv, XREG_INIT, 0);
407 }
408
409 static int xc_SetTVStandard(struct xc5000_priv *priv,
410 u16 VideoMode, u16 AudioMode)
411 {
412 int ret;
413 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
414 dprintk(1, "%s() Standard = %s\n",
415 __func__,
416 XC5000_Standard[priv->video_standard].Name);
417
418 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
419 if (ret == XC_RESULT_SUCCESS)
420 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
421
422 return ret;
423 }
424
425 static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
426 {
427 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
428 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
429
430 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
431 rf_mode = XC_RF_MODE_CABLE;
432 printk(KERN_ERR
433 "%s(), Invalid mode, defaulting to CABLE",
434 __func__);
435 }
436 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
437 }
438
439 static const struct dvb_tuner_ops xc5000_tuner_ops;
440
441 static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
442 {
443 u16 freq_code;
444
445 dprintk(1, "%s(%u)\n", __func__, freq_hz);
446
447 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
448 (freq_hz < xc5000_tuner_ops.info.frequency_min))
449 return XC_RESULT_OUT_OF_RANGE;
450
451 freq_code = (u16)(freq_hz / 15625);
452
453 /* Starting in firmware version 1.1.44, Xceive recommends using the
454 FINERFREQ for all normal tuning (the doc indicates reg 0x03 should
455 only be used for fast scanning for channel lock) */
456 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
457 }
458
459
460 static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
461 {
462 u32 freq_code = (freq_khz * 1024)/1000;
463 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
464 __func__, freq_khz, freq_code);
465
466 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
467 }
468
469
470 static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
471 {
472 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
473 }
474
475 static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
476 {
477 int result;
478 u16 regData;
479 u32 tmp;
480
481 result = xc5000_readreg(priv, XREG_FREQ_ERROR, &regData);
482 if (result != XC_RESULT_SUCCESS)
483 return result;
484
485 tmp = (u32)regData;
486 (*freq_error_hz) = (tmp * 15625) / 1000;
487 return result;
488 }
489
490 static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
491 {
492 return xc5000_readreg(priv, XREG_LOCK, lock_status);
493 }
494
495 static int xc_get_version(struct xc5000_priv *priv,
496 u8 *hw_majorversion, u8 *hw_minorversion,
497 u8 *fw_majorversion, u8 *fw_minorversion)
498 {
499 u16 data;
500 int result;
501
502 result = xc5000_readreg(priv, XREG_VERSION, &data);
503 if (result != XC_RESULT_SUCCESS)
504 return result;
505
506 (*hw_majorversion) = (data >> 12) & 0x0F;
507 (*hw_minorversion) = (data >> 8) & 0x0F;
508 (*fw_majorversion) = (data >> 4) & 0x0F;
509 (*fw_minorversion) = data & 0x0F;
510
511 return 0;
512 }
513
514 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
515 {
516 return xc5000_readreg(priv, XREG_BUILD, buildrev);
517 }
518
519 static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
520 {
521 u16 regData;
522 int result;
523
524 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, &regData);
525 if (result != XC_RESULT_SUCCESS)
526 return result;
527
528 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
529 return result;
530 }
531
532 static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
533 {
534 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
535 }
536
537 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
538 {
539 return xc5000_readreg(priv, XREG_QUALITY, quality);
540 }
541
542 static u16 WaitForLock(struct xc5000_priv *priv)
543 {
544 u16 lockState = 0;
545 int watchDogCount = 40;
546
547 while ((lockState == 0) && (watchDogCount > 0)) {
548 xc_get_lock_status(priv, &lockState);
549 if (lockState != 1) {
550 xc_wait(5);
551 watchDogCount--;
552 }
553 }
554 return lockState;
555 }
556
557 #define XC_TUNE_ANALOG 0
558 #define XC_TUNE_DIGITAL 1
559 static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
560 {
561 int found = 0;
562
563 dprintk(1, "%s(%u)\n", __func__, freq_hz);
564
565 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
566 return 0;
567
568 if (mode == XC_TUNE_ANALOG) {
569 if (WaitForLock(priv) == 1)
570 found = 1;
571 }
572
573 return found;
574 }
575
576 static int xc_set_xtal(struct dvb_frontend *fe)
577 {
578 struct xc5000_priv *priv = fe->tuner_priv;
579 int ret = XC_RESULT_SUCCESS;
580
581 switch (priv->chip_id) {
582 default:
583 case XC5000A:
584 /* 32.000 MHz xtal is default */
585 break;
586 case XC5000C:
587 switch (priv->xtal_khz) {
588 default:
589 case 32000:
590 /* 32.000 MHz xtal is default */
591 break;
592 case 31875:
593 /* 31.875 MHz xtal configuration */
594 ret = xc_write_reg(priv, 0x000f, 0x8081);
595 break;
596 }
597 break;
598 }
599 return ret;
600 }
601
602 static int xc5000_fwupload(struct dvb_frontend *fe)
603 {
604 struct xc5000_priv *priv = fe->tuner_priv;
605 const struct firmware *fw;
606 int ret;
607 const struct xc5000_fw_cfg *desired_fw =
608 xc5000_assign_firmware(priv->chip_id);
609
610 /* request the firmware, this will block and timeout */
611 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
612 desired_fw->name);
613
614 ret = request_firmware(&fw, desired_fw->name,
615 priv->i2c_props.adap->dev.parent);
616 if (ret) {
617 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
618 ret = XC_RESULT_RESET_FAILURE;
619 goto out;
620 } else {
621 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
622 fw->size);
623 ret = XC_RESULT_SUCCESS;
624 }
625
626 if (fw->size != desired_fw->size) {
627 printk(KERN_ERR "xc5000: firmware incorrect size\n");
628 ret = XC_RESULT_RESET_FAILURE;
629 } else {
630 printk(KERN_INFO "xc5000: firmware uploading...\n");
631 ret = xc_load_i2c_sequence(fe, fw->data);
632 if (XC_RESULT_SUCCESS == ret)
633 ret = xc_set_xtal(fe);
634 if (XC_RESULT_SUCCESS == ret)
635 printk(KERN_INFO "xc5000: firmware upload complete...\n");
636 else
637 printk(KERN_ERR "xc5000: firmware upload failed...\n");
638 }
639
640 out:
641 release_firmware(fw);
642 return ret;
643 }
644
645 static void xc_debug_dump(struct xc5000_priv *priv)
646 {
647 u16 adc_envelope;
648 u32 freq_error_hz = 0;
649 u16 lock_status;
650 u32 hsync_freq_hz = 0;
651 u16 frame_lines;
652 u16 quality;
653 u8 hw_majorversion = 0, hw_minorversion = 0;
654 u8 fw_majorversion = 0, fw_minorversion = 0;
655 u16 fw_buildversion = 0;
656
657 /* Wait for stats to stabilize.
658 * Frame Lines needs two frame times after initial lock
659 * before it is valid.
660 */
661 xc_wait(100);
662
663 xc_get_ADC_Envelope(priv, &adc_envelope);
664 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
665
666 xc_get_frequency_error(priv, &freq_error_hz);
667 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
668
669 xc_get_lock_status(priv, &lock_status);
670 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
671 lock_status);
672
673 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
674 &fw_majorversion, &fw_minorversion);
675 xc_get_buildversion(priv, &fw_buildversion);
676 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
677 hw_majorversion, hw_minorversion,
678 fw_majorversion, fw_minorversion, fw_buildversion);
679
680 xc_get_hsync_freq(priv, &hsync_freq_hz);
681 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
682
683 xc_get_frame_lines(priv, &frame_lines);
684 dprintk(1, "*** Frame lines = %d\n", frame_lines);
685
686 xc_get_quality(priv, &quality);
687 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
688 }
689
690 static int xc5000_set_params(struct dvb_frontend *fe)
691 {
692 int ret, b;
693 struct xc5000_priv *priv = fe->tuner_priv;
694 u32 bw = fe->dtv_property_cache.bandwidth_hz;
695 u32 freq = fe->dtv_property_cache.frequency;
696 u32 delsys = fe->dtv_property_cache.delivery_system;
697
698 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
699 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
700 dprintk(1, "Unable to load firmware and init tuner\n");
701 return -EINVAL;
702 }
703 }
704
705 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, freq);
706
707 switch (delsys) {
708 case SYS_ATSC:
709 dprintk(1, "%s() VSB modulation\n", __func__);
710 priv->rf_mode = XC_RF_MODE_AIR;
711 priv->freq_hz = freq - 1750000;
712 priv->video_standard = DTV6;
713 break;
714 case SYS_DVBC_ANNEX_B:
715 dprintk(1, "%s() QAM modulation\n", __func__);
716 priv->rf_mode = XC_RF_MODE_CABLE;
717 priv->freq_hz = freq - 1750000;
718 priv->video_standard = DTV6;
719 break;
720 case SYS_ISDBT:
721 /* All ISDB-T are currently for 6 MHz bw */
722 if (!bw)
723 bw = 6000000;
724 /* fall to OFDM handling */
725 case SYS_DMBTH:
726 case SYS_DVBT:
727 case SYS_DVBT2:
728 dprintk(1, "%s() OFDM\n", __func__);
729 switch (bw) {
730 case 6000000:
731 priv->video_standard = DTV6;
732 priv->freq_hz = freq - 1750000;
733 break;
734 case 7000000:
735 priv->video_standard = DTV7;
736 priv->freq_hz = freq - 2250000;
737 break;
738 case 8000000:
739 priv->video_standard = DTV8;
740 priv->freq_hz = freq - 2750000;
741 break;
742 default:
743 printk(KERN_ERR "xc5000 bandwidth not set!\n");
744 return -EINVAL;
745 }
746 priv->rf_mode = XC_RF_MODE_AIR;
747 case SYS_DVBC_ANNEX_A:
748 case SYS_DVBC_ANNEX_C:
749 dprintk(1, "%s() QAM modulation\n", __func__);
750 priv->rf_mode = XC_RF_MODE_CABLE;
751 if (bw <= 6000000) {
752 priv->video_standard = DTV6;
753 priv->freq_hz = freq - 1750000;
754 b = 6;
755 } else if (bw <= 7000000) {
756 priv->video_standard = DTV7;
757 priv->freq_hz = freq - 2250000;
758 b = 7;
759 } else {
760 priv->video_standard = DTV7_8;
761 priv->freq_hz = freq - 2750000;
762 b = 8;
763 }
764 dprintk(1, "%s() Bandwidth %dMHz (%d)\n", __func__,
765 b, bw);
766 break;
767 default:
768 printk(KERN_ERR "xc5000: delivery system is not supported!\n");
769 return -EINVAL;
770 }
771
772 dprintk(1, "%s() frequency=%d (compensated to %d)\n",
773 __func__, freq, priv->freq_hz);
774
775 ret = xc_SetSignalSource(priv, priv->rf_mode);
776 if (ret != XC_RESULT_SUCCESS) {
777 printk(KERN_ERR
778 "xc5000: xc_SetSignalSource(%d) failed\n",
779 priv->rf_mode);
780 return -EREMOTEIO;
781 }
782
783 ret = xc_SetTVStandard(priv,
784 XC5000_Standard[priv->video_standard].VideoMode,
785 XC5000_Standard[priv->video_standard].AudioMode);
786 if (ret != XC_RESULT_SUCCESS) {
787 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
788 return -EREMOTEIO;
789 }
790
791 ret = xc_set_IF_frequency(priv, priv->if_khz);
792 if (ret != XC_RESULT_SUCCESS) {
793 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
794 priv->if_khz);
795 return -EIO;
796 }
797
798 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x8a);
799
800 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
801
802 if (debug)
803 xc_debug_dump(priv);
804
805 priv->bandwidth = bw;
806
807 return 0;
808 }
809
810 static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
811 {
812 struct xc5000_priv *priv = fe->tuner_priv;
813 int ret;
814 u16 id;
815
816 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
817 if (ret == XC_RESULT_SUCCESS) {
818 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
819 ret = XC_RESULT_RESET_FAILURE;
820 else
821 ret = XC_RESULT_SUCCESS;
822 }
823
824 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
825 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
826 return ret;
827 }
828
829 static int xc5000_set_tv_freq(struct dvb_frontend *fe,
830 struct analog_parameters *params)
831 {
832 struct xc5000_priv *priv = fe->tuner_priv;
833 int ret;
834
835 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
836 __func__, params->frequency);
837
838 /* Fix me: it could be air. */
839 priv->rf_mode = params->mode;
840 if (params->mode > XC_RF_MODE_CABLE)
841 priv->rf_mode = XC_RF_MODE_CABLE;
842
843 /* params->frequency is in units of 62.5khz */
844 priv->freq_hz = params->frequency * 62500;
845
846 /* FIX ME: Some video standards may have several possible audio
847 standards. We simply default to one of them here.
848 */
849 if (params->std & V4L2_STD_MN) {
850 /* default to BTSC audio standard */
851 priv->video_standard = MN_NTSC_PAL_BTSC;
852 goto tune_channel;
853 }
854
855 if (params->std & V4L2_STD_PAL_BG) {
856 /* default to NICAM audio standard */
857 priv->video_standard = BG_PAL_NICAM;
858 goto tune_channel;
859 }
860
861 if (params->std & V4L2_STD_PAL_I) {
862 /* default to NICAM audio standard */
863 priv->video_standard = I_PAL_NICAM;
864 goto tune_channel;
865 }
866
867 if (params->std & V4L2_STD_PAL_DK) {
868 /* default to NICAM audio standard */
869 priv->video_standard = DK_PAL_NICAM;
870 goto tune_channel;
871 }
872
873 if (params->std & V4L2_STD_SECAM_DK) {
874 /* default to A2 DK1 audio standard */
875 priv->video_standard = DK_SECAM_A2DK1;
876 goto tune_channel;
877 }
878
879 if (params->std & V4L2_STD_SECAM_L) {
880 priv->video_standard = L_SECAM_NICAM;
881 goto tune_channel;
882 }
883
884 if (params->std & V4L2_STD_SECAM_LC) {
885 priv->video_standard = LC_SECAM_NICAM;
886 goto tune_channel;
887 }
888
889 tune_channel:
890 ret = xc_SetSignalSource(priv, priv->rf_mode);
891 if (ret != XC_RESULT_SUCCESS) {
892 printk(KERN_ERR
893 "xc5000: xc_SetSignalSource(%d) failed\n",
894 priv->rf_mode);
895 return -EREMOTEIO;
896 }
897
898 ret = xc_SetTVStandard(priv,
899 XC5000_Standard[priv->video_standard].VideoMode,
900 XC5000_Standard[priv->video_standard].AudioMode);
901 if (ret != XC_RESULT_SUCCESS) {
902 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
903 return -EREMOTEIO;
904 }
905
906 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
907
908 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
909
910 if (debug)
911 xc_debug_dump(priv);
912
913 return 0;
914 }
915
916 static int xc5000_set_radio_freq(struct dvb_frontend *fe,
917 struct analog_parameters *params)
918 {
919 struct xc5000_priv *priv = fe->tuner_priv;
920 int ret = -EINVAL;
921 u8 radio_input;
922
923 dprintk(1, "%s() frequency=%d (in units of khz)\n",
924 __func__, params->frequency);
925
926 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
927 dprintk(1, "%s() radio input not configured\n", __func__);
928 return -EINVAL;
929 }
930
931 if (priv->radio_input == XC5000_RADIO_FM1)
932 radio_input = FM_Radio_INPUT1;
933 else if (priv->radio_input == XC5000_RADIO_FM2)
934 radio_input = FM_Radio_INPUT2;
935 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
936 radio_input = FM_Radio_INPUT1_MONO;
937 else {
938 dprintk(1, "%s() unknown radio input %d\n", __func__,
939 priv->radio_input);
940 return -EINVAL;
941 }
942
943 priv->freq_hz = params->frequency * 125 / 2;
944
945 priv->rf_mode = XC_RF_MODE_AIR;
946
947 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
948 XC5000_Standard[radio_input].AudioMode);
949
950 if (ret != XC_RESULT_SUCCESS) {
951 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
952 return -EREMOTEIO;
953 }
954
955 ret = xc_SetSignalSource(priv, priv->rf_mode);
956 if (ret != XC_RESULT_SUCCESS) {
957 printk(KERN_ERR
958 "xc5000: xc_SetSignalSource(%d) failed\n",
959 priv->rf_mode);
960 return -EREMOTEIO;
961 }
962
963 if ((priv->radio_input == XC5000_RADIO_FM1) ||
964 (priv->radio_input == XC5000_RADIO_FM2))
965 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x09);
966 else if (priv->radio_input == XC5000_RADIO_FM1_MONO)
967 xc_write_reg(priv, XREG_OUTPUT_AMP, 0x06);
968
969 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
970
971 return 0;
972 }
973
974 static int xc5000_set_analog_params(struct dvb_frontend *fe,
975 struct analog_parameters *params)
976 {
977 struct xc5000_priv *priv = fe->tuner_priv;
978 int ret = -EINVAL;
979
980 if (priv->i2c_props.adap == NULL)
981 return -EINVAL;
982
983 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
984 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
985 dprintk(1, "Unable to load firmware and init tuner\n");
986 return -EINVAL;
987 }
988 }
989
990 switch (params->mode) {
991 case V4L2_TUNER_RADIO:
992 ret = xc5000_set_radio_freq(fe, params);
993 break;
994 case V4L2_TUNER_ANALOG_TV:
995 case V4L2_TUNER_DIGITAL_TV:
996 ret = xc5000_set_tv_freq(fe, params);
997 break;
998 }
999
1000 return ret;
1001 }
1002
1003
1004 static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1005 {
1006 struct xc5000_priv *priv = fe->tuner_priv;
1007 dprintk(1, "%s()\n", __func__);
1008 *freq = priv->freq_hz;
1009 return 0;
1010 }
1011
1012 static int xc5000_get_if_frequency(struct dvb_frontend *fe, u32 *freq)
1013 {
1014 struct xc5000_priv *priv = fe->tuner_priv;
1015 dprintk(1, "%s()\n", __func__);
1016 *freq = priv->if_khz * 1000;
1017 return 0;
1018 }
1019
1020 static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1021 {
1022 struct xc5000_priv *priv = fe->tuner_priv;
1023 dprintk(1, "%s()\n", __func__);
1024
1025 *bw = priv->bandwidth;
1026 return 0;
1027 }
1028
1029 static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
1030 {
1031 struct xc5000_priv *priv = fe->tuner_priv;
1032 u16 lock_status = 0;
1033
1034 xc_get_lock_status(priv, &lock_status);
1035
1036 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
1037
1038 *status = lock_status;
1039
1040 return 0;
1041 }
1042
1043 static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
1044 {
1045 struct xc5000_priv *priv = fe->tuner_priv;
1046 int ret = 0;
1047
1048 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
1049 ret = xc5000_fwupload(fe);
1050 if (ret != XC_RESULT_SUCCESS)
1051 return ret;
1052 }
1053
1054 /* Start the tuner self-calibration process */
1055 ret |= xc_initialize(priv);
1056
1057 /* Wait for calibration to complete.
1058 * We could continue but XC5000 will clock stretch subsequent
1059 * I2C transactions until calibration is complete. This way we
1060 * don't have to rely on clock stretching working.
1061 */
1062 xc_wait(100);
1063
1064 /* Default to "CABLE" mode */
1065 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1066
1067 return ret;
1068 }
1069
1070 static int xc5000_sleep(struct dvb_frontend *fe)
1071 {
1072 int ret;
1073
1074 dprintk(1, "%s()\n", __func__);
1075
1076 /* Avoid firmware reload on slow devices */
1077 if (no_poweroff)
1078 return 0;
1079
1080 /* According to Xceive technical support, the "powerdown" register
1081 was removed in newer versions of the firmware. The "supported"
1082 way to sleep the tuner is to pull the reset pin low for 10ms */
1083 ret = xc5000_TunerReset(fe);
1084 if (ret != XC_RESULT_SUCCESS) {
1085 printk(KERN_ERR
1086 "xc5000: %s() unable to shutdown tuner\n",
1087 __func__);
1088 return -EREMOTEIO;
1089 } else
1090 return XC_RESULT_SUCCESS;
1091 }
1092
1093 static int xc5000_init(struct dvb_frontend *fe)
1094 {
1095 struct xc5000_priv *priv = fe->tuner_priv;
1096 dprintk(1, "%s()\n", __func__);
1097
1098 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
1099 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1100 return -EREMOTEIO;
1101 }
1102
1103 if (debug)
1104 xc_debug_dump(priv);
1105
1106 return 0;
1107 }
1108
1109 static int xc5000_release(struct dvb_frontend *fe)
1110 {
1111 struct xc5000_priv *priv = fe->tuner_priv;
1112
1113 dprintk(1, "%s()\n", __func__);
1114
1115 mutex_lock(&xc5000_list_mutex);
1116
1117 if (priv)
1118 hybrid_tuner_release_state(priv);
1119
1120 mutex_unlock(&xc5000_list_mutex);
1121
1122 fe->tuner_priv = NULL;
1123
1124 return 0;
1125 }
1126
1127 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1128 {
1129 struct xc5000_priv *priv = fe->tuner_priv;
1130 struct xc5000_config *p = priv_cfg;
1131
1132 dprintk(1, "%s()\n", __func__);
1133
1134 if (p->if_khz)
1135 priv->if_khz = p->if_khz;
1136
1137 if (p->radio_input)
1138 priv->radio_input = p->radio_input;
1139
1140 return 0;
1141 }
1142
1143
1144 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1145 .info = {
1146 .name = "Xceive XC5000",
1147 .frequency_min = 1000000,
1148 .frequency_max = 1023000000,
1149 .frequency_step = 50000,
1150 },
1151
1152 .release = xc5000_release,
1153 .init = xc5000_init,
1154 .sleep = xc5000_sleep,
1155
1156 .set_config = xc5000_set_config,
1157 .set_params = xc5000_set_params,
1158 .set_analog_params = xc5000_set_analog_params,
1159 .get_frequency = xc5000_get_frequency,
1160 .get_if_frequency = xc5000_get_if_frequency,
1161 .get_bandwidth = xc5000_get_bandwidth,
1162 .get_status = xc5000_get_status
1163 };
1164
1165 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1166 struct i2c_adapter *i2c,
1167 const struct xc5000_config *cfg)
1168 {
1169 struct xc5000_priv *priv = NULL;
1170 int instance;
1171 u16 id = 0;
1172
1173 dprintk(1, "%s(%d-%04x)\n", __func__,
1174 i2c ? i2c_adapter_id(i2c) : -1,
1175 cfg ? cfg->i2c_address : -1);
1176
1177 mutex_lock(&xc5000_list_mutex);
1178
1179 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1180 hybrid_tuner_instance_list,
1181 i2c, cfg->i2c_address, "xc5000");
1182 switch (instance) {
1183 case 0:
1184 goto fail;
1185 break;
1186 case 1:
1187 /* new tuner instance */
1188 priv->bandwidth = 6000000;
1189 fe->tuner_priv = priv;
1190 break;
1191 default:
1192 /* existing tuner instance */
1193 fe->tuner_priv = priv;
1194 break;
1195 }
1196
1197 if (priv->if_khz == 0) {
1198 /* If the IF hasn't been set yet, use the value provided by
1199 the caller (occurs in hybrid devices where the analog
1200 call to xc5000_attach occurs before the digital side) */
1201 priv->if_khz = cfg->if_khz;
1202 }
1203
1204 if (priv->xtal_khz == 0)
1205 priv->xtal_khz = cfg->xtal_khz;
1206
1207 if (priv->radio_input == 0)
1208 priv->radio_input = cfg->radio_input;
1209
1210 /* don't override chip id if it's already been set
1211 unless explicitly specified */
1212 if ((priv->chip_id == 0) || (cfg->chip_id))
1213 /* use default chip id if none specified, set to 0 so
1214 it can be overridden if this is a hybrid driver */
1215 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1216
1217 /* Check if firmware has been loaded. It is possible that another
1218 instance of the driver has loaded the firmware.
1219 */
1220 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1221 goto fail;
1222
1223 switch (id) {
1224 case XC_PRODUCT_ID_FW_LOADED:
1225 printk(KERN_INFO
1226 "xc5000: Successfully identified at address 0x%02x\n",
1227 cfg->i2c_address);
1228 printk(KERN_INFO
1229 "xc5000: Firmware has been loaded previously\n");
1230 break;
1231 case XC_PRODUCT_ID_FW_NOT_LOADED:
1232 printk(KERN_INFO
1233 "xc5000: Successfully identified at address 0x%02x\n",
1234 cfg->i2c_address);
1235 printk(KERN_INFO
1236 "xc5000: Firmware has not been loaded previously\n");
1237 break;
1238 default:
1239 printk(KERN_ERR
1240 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1241 cfg->i2c_address, id);
1242 goto fail;
1243 }
1244
1245 mutex_unlock(&xc5000_list_mutex);
1246
1247 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1248 sizeof(struct dvb_tuner_ops));
1249
1250 return fe;
1251 fail:
1252 mutex_unlock(&xc5000_list_mutex);
1253
1254 xc5000_release(fe);
1255 return NULL;
1256 }
1257 EXPORT_SYMBOL(xc5000_attach);
1258
1259 MODULE_AUTHOR("Steven Toth");
1260 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1261 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.054674 seconds and 4 git commands to generate.