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