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