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