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