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