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 bool inited;
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
xc5000_assign_firmware(int chip_id)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
xc_send_i2c_data(struct xc5000_priv * priv,u8 * buf,int len)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
xc5000_readreg(struct xc5000_priv * priv,u16 reg,u16 * val)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
xc5000_tuner_reset(struct dvb_frontend * fe)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
xc_write_reg(struct xc5000_priv * priv,u16 reg_addr,u16 i2c_data)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
xc_load_i2c_sequence(struct dvb_frontend * fe,const u8 * i2c_sequence)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
xc_initialize(struct xc5000_priv * priv)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
xc_set_tv_standard(struct xc5000_priv * priv,u16 video_mode,u16 audio_mode,u8 radio_mode)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
xc_set_signal_source(struct xc5000_priv * priv,u16 rf_mode)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
xc_set_rf_frequency(struct xc5000_priv * priv,u32 freq_hz)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
xc_set_IF_frequency(struct xc5000_priv * priv,u32 freq_khz)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
xc_get_adc_envelope(struct xc5000_priv * priv,u16 * adc_envelope)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
xc_get_frequency_error(struct xc5000_priv * priv,u32 * freq_error_hz)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, ®_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
xc_get_lock_status(struct xc5000_priv * priv,u16 * lock_status)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
xc_get_version(struct xc5000_priv * priv,u8 * hw_majorversion,u8 * hw_minorversion,u8 * fw_majorversion,u8 * fw_minorversion)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
xc_get_buildversion(struct xc5000_priv * priv,u16 * buildrev)520 static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
521 {
522 return xc5000_readreg(priv, XREG_BUILD, buildrev);
523 }
524
xc_get_hsync_freq(struct xc5000_priv * priv,u32 * hsync_freq_hz)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, ®_data);
531 if (result != 0)
532 return result;
533
534 (*hsync_freq_hz) = ((reg_data & 0x0fff) * 763)/100;
535 return result;
536 }
537
xc_get_frame_lines(struct xc5000_priv * priv,u16 * frame_lines)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
xc_get_quality(struct xc5000_priv * priv,u16 * quality)543 static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
544 {
545 return xc5000_readreg(priv, XREG_QUALITY, quality);
546 }
547
xc_get_analogsnr(struct xc5000_priv * priv,u16 * snr)548 static int xc_get_analogsnr(struct xc5000_priv *priv, u16 *snr)
549 {
550 return xc5000_readreg(priv, XREG_SNR, snr);
551 }
552
xc_get_totalgain(struct xc5000_priv * priv,u16 * totalgain)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
xc_tune_channel(struct xc5000_priv * priv,u32 freq_hz,int mode)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
xc_set_xtal(struct dvb_frontend * fe)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
xc5000_fwupload(struct dvb_frontend * fe,const struct xc5000_fw_cfg * desired_fw,const struct firmware * fw)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
xc_debug_dump(struct xc5000_priv * priv)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, ®val))
679 dprintk(1, "*** PLL lock status = 0x%04x\n", regval);
680 }
681 }
682
xc5000_tune_digital(struct dvb_frontend * fe)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
xc5000_set_digital_params(struct dvb_frontend * fe)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 fallthrough;
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
xc5000_is_firmware_loaded(struct dvb_frontend * fe)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
xc5000_config_tv(struct dvb_frontend * fe,struct analog_parameters * params)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
xc5000_set_tv_freq(struct dvb_frontend * fe)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
xc5000_config_radio(struct dvb_frontend * fe,struct analog_parameters * params)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
xc5000_set_radio_freq(struct dvb_frontend * fe)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
xc5000_set_params(struct dvb_frontend * fe)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
xc5000_set_analog_params(struct dvb_frontend * fe,struct analog_parameters * params)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
xc5000_get_frequency(struct dvb_frontend * fe,u32 * freq)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
xc5000_get_if_frequency(struct dvb_frontend * fe,u32 * freq)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
xc5000_get_bandwidth(struct dvb_frontend * fe,u32 * bw)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
xc5000_get_status(struct dvb_frontend * fe,u32 * status)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
xc_load_fw_and_init_tuner(struct dvb_frontend * fe,int force)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 ret = request_firmware(&fw, desired_fw->name,
1114 priv->i2c_props.adap->dev.parent);
1115 if (ret) {
1116 pr_err("xc5000: Upload failed. rc %d\n", ret);
1117 return ret;
1118 }
1119 dprintk(1, "firmware read %zu bytes.\n", fw->size);
1120
1121 if (fw->size != desired_fw->size) {
1122 pr_err("xc5000: Firmware file with incorrect size\n");
1123 release_firmware(fw);
1124 return -EINVAL;
1125 }
1126
1127 /* Try up to 5 times to load firmware */
1128 for (i = 0; i < 5; i++) {
1129 if (i)
1130 printk(KERN_CONT " - retrying to upload firmware.\n");
1131
1132 ret = xc5000_fwupload(fe, desired_fw, fw);
1133 if (ret != 0)
1134 goto err;
1135
1136 msleep(20);
1137
1138 if (priv->fw_checksum_supported) {
1139 if (xc5000_readreg(priv, XREG_FW_CHECKSUM, &fw_ck)) {
1140 printk(KERN_ERR
1141 "xc5000: FW checksum reading failed.");
1142 continue;
1143 }
1144
1145 if (!fw_ck) {
1146 printk(KERN_ERR
1147 "xc5000: FW checksum failed = 0x%04x.",
1148 fw_ck);
1149 continue;
1150 }
1151 }
1152
1153 /* Start the tuner self-calibration process */
1154 ret = xc_initialize(priv);
1155 if (ret) {
1156 printk(KERN_ERR "xc5000: Can't request self-calibration.");
1157 continue;
1158 }
1159
1160 /* Wait for calibration to complete.
1161 * We could continue but XC5000 will clock stretch subsequent
1162 * I2C transactions until calibration is complete. This way we
1163 * don't have to rely on clock stretching working.
1164 */
1165 msleep(100);
1166
1167 if (priv->init_status_supported) {
1168 if (xc5000_readreg(priv, XREG_INIT_STATUS, &fw_ck)) {
1169 printk(KERN_ERR
1170 "xc5000: FW failed reading init status.");
1171 continue;
1172 }
1173
1174 if (!fw_ck) {
1175 printk(KERN_ERR
1176 "xc5000: FW init status failed = 0x%04x.",
1177 fw_ck);
1178 continue;
1179 }
1180 }
1181
1182 if (priv->pll_register_no) {
1183 ret = xc5000_readreg(priv, priv->pll_register_no,
1184 &pll_lock_status);
1185 if (ret)
1186 continue;
1187 if (pll_lock_status > 63) {
1188 /* PLL is unlocked, force reload of the firmware */
1189 printk(KERN_ERR
1190 "xc5000: PLL not running after fwload.");
1191 continue;
1192 }
1193 }
1194
1195 /* Default to "CABLE" mode */
1196 ret = xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
1197 if (!ret)
1198 break;
1199 printk(KERN_ERR "xc5000: can't set to cable mode.");
1200 }
1201
1202 err:
1203 release_firmware(fw);
1204 if (!ret)
1205 printk(KERN_INFO "xc5000: Firmware %s loaded and running.\n",
1206 desired_fw->name);
1207 else
1208 printk(KERN_CONT " - too many retries. Giving up\n");
1209
1210 return ret;
1211 }
1212
xc5000_do_timer_sleep(struct work_struct * timer_sleep)1213 static void xc5000_do_timer_sleep(struct work_struct *timer_sleep)
1214 {
1215 struct xc5000_priv *priv =container_of(timer_sleep, struct xc5000_priv,
1216 timer_sleep.work);
1217 struct dvb_frontend *fe = priv->fe;
1218 int ret;
1219
1220 dprintk(1, "%s()\n", __func__);
1221
1222 /* According to Xceive technical support, the "powerdown" register
1223 was removed in newer versions of the firmware. The "supported"
1224 way to sleep the tuner is to pull the reset pin low for 10ms */
1225 ret = xc5000_tuner_reset(fe);
1226 if (ret != 0)
1227 printk(KERN_ERR
1228 "xc5000: %s() unable to shutdown tuner\n",
1229 __func__);
1230 }
1231
xc5000_sleep(struct dvb_frontend * fe)1232 static int xc5000_sleep(struct dvb_frontend *fe)
1233 {
1234 struct xc5000_priv *priv = fe->tuner_priv;
1235
1236 dprintk(1, "%s()\n", __func__);
1237
1238 /* Avoid firmware reload on slow devices */
1239 if (no_poweroff)
1240 return 0;
1241
1242 schedule_delayed_work(&priv->timer_sleep,
1243 msecs_to_jiffies(XC5000_SLEEP_TIME));
1244
1245 return 0;
1246 }
1247
xc5000_suspend(struct dvb_frontend * fe)1248 static int xc5000_suspend(struct dvb_frontend *fe)
1249 {
1250 struct xc5000_priv *priv = fe->tuner_priv;
1251 int ret;
1252
1253 dprintk(1, "%s()\n", __func__);
1254
1255 cancel_delayed_work(&priv->timer_sleep);
1256
1257 ret = xc5000_tuner_reset(fe);
1258 if (ret != 0)
1259 printk(KERN_ERR
1260 "xc5000: %s() unable to shutdown tuner\n",
1261 __func__);
1262
1263 return 0;
1264 }
1265
xc5000_resume(struct dvb_frontend * fe)1266 static int xc5000_resume(struct dvb_frontend *fe)
1267 {
1268 struct xc5000_priv *priv = fe->tuner_priv;
1269
1270 dprintk(1, "%s()\n", __func__);
1271
1272 /* suspended before firmware is loaded.
1273 Avoid firmware load in resume path. */
1274 if (!priv->inited)
1275 return 0;
1276
1277 return xc5000_set_params(fe);
1278 }
1279
xc5000_init(struct dvb_frontend * fe)1280 static int xc5000_init(struct dvb_frontend *fe)
1281 {
1282 struct xc5000_priv *priv = fe->tuner_priv;
1283 dprintk(1, "%s()\n", __func__);
1284
1285 if (xc_load_fw_and_init_tuner(fe, 0) != 0) {
1286 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
1287 return -EREMOTEIO;
1288 }
1289
1290 if (debug)
1291 xc_debug_dump(priv);
1292
1293 priv->inited = true;
1294
1295 return 0;
1296 }
1297
xc5000_release(struct dvb_frontend * fe)1298 static void xc5000_release(struct dvb_frontend *fe)
1299 {
1300 struct xc5000_priv *priv = fe->tuner_priv;
1301
1302 dprintk(1, "%s()\n", __func__);
1303
1304 mutex_lock(&xc5000_list_mutex);
1305
1306 if (priv) {
1307 cancel_delayed_work(&priv->timer_sleep);
1308 hybrid_tuner_release_state(priv);
1309 }
1310
1311 mutex_unlock(&xc5000_list_mutex);
1312
1313 fe->tuner_priv = NULL;
1314 }
1315
xc5000_set_config(struct dvb_frontend * fe,void * priv_cfg)1316 static int xc5000_set_config(struct dvb_frontend *fe, void *priv_cfg)
1317 {
1318 struct xc5000_priv *priv = fe->tuner_priv;
1319 struct xc5000_config *p = priv_cfg;
1320
1321 dprintk(1, "%s()\n", __func__);
1322
1323 if (p->if_khz)
1324 priv->if_khz = p->if_khz;
1325
1326 if (p->radio_input)
1327 priv->radio_input = p->radio_input;
1328
1329 if (p->output_amp)
1330 priv->output_amp = p->output_amp;
1331
1332 return 0;
1333 }
1334
1335
1336 static const struct dvb_tuner_ops xc5000_tuner_ops = {
1337 .info = {
1338 .name = "Xceive XC5000",
1339 .frequency_min_hz = 1 * MHz,
1340 .frequency_max_hz = 1023 * MHz,
1341 .frequency_step_hz = 50 * kHz,
1342 },
1343
1344 .release = xc5000_release,
1345 .init = xc5000_init,
1346 .sleep = xc5000_sleep,
1347 .suspend = xc5000_suspend,
1348 .resume = xc5000_resume,
1349
1350 .set_config = xc5000_set_config,
1351 .set_params = xc5000_set_digital_params,
1352 .set_analog_params = xc5000_set_analog_params,
1353 .get_frequency = xc5000_get_frequency,
1354 .get_if_frequency = xc5000_get_if_frequency,
1355 .get_bandwidth = xc5000_get_bandwidth,
1356 .get_status = xc5000_get_status
1357 };
1358
xc5000_attach(struct dvb_frontend * fe,struct i2c_adapter * i2c,const struct xc5000_config * cfg)1359 struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1360 struct i2c_adapter *i2c,
1361 const struct xc5000_config *cfg)
1362 {
1363 struct xc5000_priv *priv = NULL;
1364 int instance;
1365 u16 id = 0;
1366
1367 dprintk(1, "%s(%d-%04x)\n", __func__,
1368 i2c ? i2c_adapter_id(i2c) : -1,
1369 cfg ? cfg->i2c_address : -1);
1370
1371 mutex_lock(&xc5000_list_mutex);
1372
1373 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1374 hybrid_tuner_instance_list,
1375 i2c, cfg->i2c_address, "xc5000");
1376 switch (instance) {
1377 case 0:
1378 goto fail;
1379 case 1:
1380 /* new tuner instance */
1381 priv->bandwidth = 6000000;
1382 fe->tuner_priv = priv;
1383 priv->fe = fe;
1384 INIT_DELAYED_WORK(&priv->timer_sleep, xc5000_do_timer_sleep);
1385 break;
1386 default:
1387 /* existing tuner instance */
1388 fe->tuner_priv = priv;
1389 break;
1390 }
1391
1392 if (priv->if_khz == 0) {
1393 /* If the IF hasn't been set yet, use the value provided by
1394 the caller (occurs in hybrid devices where the analog
1395 call to xc5000_attach occurs before the digital side) */
1396 priv->if_khz = cfg->if_khz;
1397 }
1398
1399 if (priv->xtal_khz == 0)
1400 priv->xtal_khz = cfg->xtal_khz;
1401
1402 if (priv->radio_input == 0)
1403 priv->radio_input = cfg->radio_input;
1404
1405 /* don't override chip id if it's already been set
1406 unless explicitly specified */
1407 if ((priv->chip_id == 0) || (cfg->chip_id))
1408 /* use default chip id if none specified, set to 0 so
1409 it can be overridden if this is a hybrid driver */
1410 priv->chip_id = (cfg->chip_id) ? cfg->chip_id : 0;
1411
1412 /* don't override output_amp if it's already been set
1413 unless explicitly specified */
1414 if ((priv->output_amp == 0) || (cfg->output_amp))
1415 /* use default output_amp value if none specified */
1416 priv->output_amp = (cfg->output_amp) ? cfg->output_amp : 0x8a;
1417
1418 /* Check if firmware has been loaded. It is possible that another
1419 instance of the driver has loaded the firmware.
1420 */
1421 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1422 goto fail;
1423
1424 switch (id) {
1425 case XC_PRODUCT_ID_FW_LOADED:
1426 printk(KERN_INFO
1427 "xc5000: Successfully identified at address 0x%02x\n",
1428 cfg->i2c_address);
1429 printk(KERN_INFO
1430 "xc5000: Firmware has been loaded previously\n");
1431 break;
1432 case XC_PRODUCT_ID_FW_NOT_LOADED:
1433 printk(KERN_INFO
1434 "xc5000: Successfully identified at address 0x%02x\n",
1435 cfg->i2c_address);
1436 printk(KERN_INFO
1437 "xc5000: Firmware has not been loaded previously\n");
1438 break;
1439 default:
1440 printk(KERN_ERR
1441 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1442 cfg->i2c_address, id);
1443 goto fail;
1444 }
1445
1446 mutex_unlock(&xc5000_list_mutex);
1447
1448 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1449 sizeof(struct dvb_tuner_ops));
1450
1451 return fe;
1452 fail:
1453 mutex_unlock(&xc5000_list_mutex);
1454
1455 xc5000_release(fe);
1456 return NULL;
1457 }
1458 EXPORT_SYMBOL_GPL(xc5000_attach);
1459
1460 MODULE_AUTHOR("Steven Toth");
1461 MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1462 MODULE_LICENSE("GPL");
1463 MODULE_FIRMWARE(XC5000A_FIRMWARE);
1464 MODULE_FIRMWARE(XC5000C_FIRMWARE);
1465