1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/module.h>
25#include <linux/moduleparam.h>
26#include <linux/videodev2.h>
27#include <linux/delay.h>
28#include <linux/dvb/frontend.h>
29#include <linux/i2c.h>
30
31#include "dvb_frontend.h"
32
33#include "xc5000.h"
34#include "tuner-i2c.h"
35
36static int debug;
37module_param(debug, int, 0644);
38MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
39
40static int no_poweroff;
41module_param(no_poweroff, int, 0644);
42MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
43 "\t\t1 keep device energized and with tuner ready all the times.\n"
44 "\t\tFaster, but consumes more power and keeps the device hotter");
45
46static DEFINE_MUTEX(xc5000_list_mutex);
47static LIST_HEAD(hybrid_tuner_instance_list);
48
49#define dprintk(level, fmt, arg...) if (debug >= level) \
50 printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
51
52#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.6.114.fw"
53#define XC5000_DEFAULT_FIRMWARE_SIZE 12401
54
55struct xc5000_priv {
56 struct tuner_i2c_props i2c_props;
57 struct list_head hybrid_tuner_instance_list;
58
59 u32 if_khz;
60 u32 freq_hz;
61 u32 bandwidth;
62 u8 video_standard;
63 u8 rf_mode;
64 u8 radio_input;
65};
66
67
68#define MAX_TV_STANDARD 23
69#define XC_MAX_I2C_WRITE_LENGTH 64
70
71
72#define XC_RF_MODE_AIR 0
73#define XC_RF_MODE_CABLE 1
74
75
76#define XC_RESULT_SUCCESS 0
77#define XC_RESULT_RESET_FAILURE 1
78#define XC_RESULT_I2C_WRITE_FAILURE 2
79#define XC_RESULT_I2C_READ_FAILURE 3
80#define XC_RESULT_OUT_OF_RANGE 5
81
82
83#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
84#define XC_PRODUCT_ID_FW_LOADED 0x1388
85
86
87#define XREG_INIT 0x00
88#define XREG_VIDEO_MODE 0x01
89#define XREG_AUDIO_MODE 0x02
90#define XREG_RF_FREQ 0x03
91#define XREG_D_CODE 0x04
92#define XREG_IF_OUT 0x05
93#define XREG_SEEK_MODE 0x07
94#define XREG_POWER_DOWN 0x0A
95#define XREG_SIGNALSOURCE 0x0D
96#define XREG_SMOOTHEDCVBS 0x0E
97#define XREG_XTALFREQ 0x0F
98#define XREG_FINERFREQ 0x10
99#define XREG_DDIMODE 0x11
100
101#define XREG_ADC_ENV 0x00
102#define XREG_QUALITY 0x01
103#define XREG_FRAME_LINES 0x02
104#define XREG_HSYNC_FREQ 0x03
105#define XREG_LOCK 0x04
106#define XREG_FREQ_ERROR 0x05
107#define XREG_SNR 0x06
108#define XREG_VERSION 0x07
109#define XREG_PRODUCT_ID 0x08
110#define XREG_BUSY 0x09
111#define XREG_BUILD 0x0D
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146struct XC_TV_STANDARD {
147 char *Name;
148 u16 AudioMode;
149 u16 VideoMode;
150};
151
152
153#define MN_NTSC_PAL_BTSC 0
154#define MN_NTSC_PAL_A2 1
155#define MN_NTSC_PAL_EIAJ 2
156#define MN_NTSC_PAL_Mono 3
157#define BG_PAL_A2 4
158#define BG_PAL_NICAM 5
159#define BG_PAL_MONO 6
160#define I_PAL_NICAM 7
161#define I_PAL_NICAM_MONO 8
162#define DK_PAL_A2 9
163#define DK_PAL_NICAM 10
164#define DK_PAL_MONO 11
165#define DK_SECAM_A2DK1 12
166#define DK_SECAM_A2LDK3 13
167#define DK_SECAM_A2MONO 14
168#define L_SECAM_NICAM 15
169#define LC_SECAM_NICAM 16
170#define DTV6 17
171#define DTV8 18
172#define DTV7_8 19
173#define DTV7 20
174#define FM_Radio_INPUT2 21
175#define FM_Radio_INPUT1 22
176
177static struct XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
178 {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
179 {"M/N-NTSC/PAL-A2", 0x0600, 0x8020},
180 {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
181 {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
182 {"B/G-PAL-A2", 0x0A00, 0x8049},
183 {"B/G-PAL-NICAM", 0x0C04, 0x8049},
184 {"B/G-PAL-MONO", 0x0878, 0x8059},
185 {"I-PAL-NICAM", 0x1080, 0x8009},
186 {"I-PAL-NICAM-MONO", 0x0E78, 0x8009},
187 {"D/K-PAL-A2", 0x1600, 0x8009},
188 {"D/K-PAL-NICAM", 0x0E80, 0x8009},
189 {"D/K-PAL-MONO", 0x1478, 0x8009},
190 {"D/K-SECAM-A2 DK1", 0x1200, 0x8009},
191 {"D/K-SECAM-A2 L/DK3", 0x0E00, 0x8009},
192 {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
193 {"L-SECAM-NICAM", 0x8E82, 0x0009},
194 {"L'-SECAM-NICAM", 0x8E82, 0x4009},
195 {"DTV6", 0x00C0, 0x8002},
196 {"DTV8", 0x00C0, 0x800B},
197 {"DTV7/8", 0x00C0, 0x801B},
198 {"DTV7", 0x00C0, 0x8007},
199 {"FM Radio-INPUT2", 0x9802, 0x9002},
200 {"FM Radio-INPUT1", 0x0208, 0x9002}
201};
202
203static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
204static int xc5000_is_firmware_loaded(struct dvb_frontend *fe);
205static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val);
206static int xc5000_TunerReset(struct dvb_frontend *fe);
207
208static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
209{
210 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
211 .flags = 0, .buf = buf, .len = len };
212
213 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
214 printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n", len);
215 return XC_RESULT_I2C_WRITE_FAILURE;
216 }
217 return XC_RESULT_SUCCESS;
218}
219
220#if 0
221
222
223
224static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
225{
226 struct i2c_msg msg = { .addr = priv->i2c_props.addr,
227 .flags = I2C_M_RD, .buf = buf, .len = len };
228
229 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
230 printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n", len);
231 return -EREMOTEIO;
232 }
233 return 0;
234}
235#endif
236
237static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
238{
239 u8 buf[2] = { reg >> 8, reg & 0xff };
240 u8 bval[2] = { 0, 0 };
241 struct i2c_msg msg[2] = {
242 { .addr = priv->i2c_props.addr,
243 .flags = 0, .buf = &buf[0], .len = 2 },
244 { .addr = priv->i2c_props.addr,
245 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
246 };
247
248 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
249 printk(KERN_WARNING "xc5000: I2C read failed\n");
250 return -EREMOTEIO;
251 }
252
253 *val = (bval[0] << 8) | bval[1];
254 return XC_RESULT_SUCCESS;
255}
256
257static void xc_wait(int wait_ms)
258{
259 msleep(wait_ms);
260}
261
262static int xc5000_TunerReset(struct dvb_frontend *fe)
263{
264 struct xc5000_priv *priv = fe->tuner_priv;
265 int ret;
266
267 dprintk(1, "%s()\n", __func__);
268
269 if (fe->callback) {
270 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
271 fe->dvb->priv :
272 priv->i2c_props.adap->algo_data,
273 DVB_FRONTEND_COMPONENT_TUNER,
274 XC5000_TUNER_RESET, 0);
275 if (ret) {
276 printk(KERN_ERR "xc5000: reset failed\n");
277 return XC_RESULT_RESET_FAILURE;
278 }
279 } else {
280 printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
281 return XC_RESULT_RESET_FAILURE;
282 }
283 return XC_RESULT_SUCCESS;
284}
285
286static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
287{
288 u8 buf[4];
289 int WatchDogTimer = 100;
290 int result;
291
292 buf[0] = (regAddr >> 8) & 0xFF;
293 buf[1] = regAddr & 0xFF;
294 buf[2] = (i2cData >> 8) & 0xFF;
295 buf[3] = i2cData & 0xFF;
296 result = xc_send_i2c_data(priv, buf, 4);
297 if (result == XC_RESULT_SUCCESS) {
298
299 while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
300 result = xc5000_readreg(priv, XREG_BUSY, (u16 *)buf);
301 if (result == XC_RESULT_SUCCESS) {
302 if ((buf[0] == 0) && (buf[1] == 0)) {
303
304 break;
305 } else {
306 xc_wait(5);
307 WatchDogTimer--;
308 }
309 }
310 }
311 }
312 if (WatchDogTimer < 0)
313 result = XC_RESULT_I2C_WRITE_FAILURE;
314
315 return result;
316}
317
318static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
319{
320 struct xc5000_priv *priv = fe->tuner_priv;
321
322 int i, nbytes_to_send, result;
323 unsigned int len, pos, index;
324 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
325
326 index = 0;
327 while ((i2c_sequence[index] != 0xFF) ||
328 (i2c_sequence[index + 1] != 0xFF)) {
329 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
330 if (len == 0x0000) {
331
332 result = xc5000_TunerReset(fe);
333 index += 2;
334 if (result != XC_RESULT_SUCCESS)
335 return result;
336 } else if (len & 0x8000) {
337
338 xc_wait(len & 0x7FFF);
339 index += 2;
340 } else {
341
342
343
344 index += 2;
345 buf[0] = i2c_sequence[index];
346 buf[1] = i2c_sequence[index + 1];
347 pos = 2;
348 while (pos < len) {
349 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
350 nbytes_to_send =
351 XC_MAX_I2C_WRITE_LENGTH;
352 else
353 nbytes_to_send = (len - pos + 2);
354 for (i = 2; i < nbytes_to_send; i++) {
355 buf[i] = i2c_sequence[index + pos +
356 i - 2];
357 }
358 result = xc_send_i2c_data(priv, buf,
359 nbytes_to_send);
360
361 if (result != XC_RESULT_SUCCESS)
362 return result;
363
364 pos += nbytes_to_send - 2;
365 }
366 index += len;
367 }
368 }
369 return XC_RESULT_SUCCESS;
370}
371
372static int xc_initialize(struct xc5000_priv *priv)
373{
374 dprintk(1, "%s()\n", __func__);
375 return xc_write_reg(priv, XREG_INIT, 0);
376}
377
378static int xc_SetTVStandard(struct xc5000_priv *priv,
379 u16 VideoMode, u16 AudioMode)
380{
381 int ret;
382 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
383 dprintk(1, "%s() Standard = %s\n",
384 __func__,
385 XC5000_Standard[priv->video_standard].Name);
386
387 ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
388 if (ret == XC_RESULT_SUCCESS)
389 ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
390
391 return ret;
392}
393
394static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
395{
396 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
397 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
398
399 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
400 rf_mode = XC_RF_MODE_CABLE;
401 printk(KERN_ERR
402 "%s(), Invalid mode, defaulting to CABLE",
403 __func__);
404 }
405 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
406}
407
408static const struct dvb_tuner_ops xc5000_tuner_ops;
409
410static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
411{
412 u16 freq_code;
413
414 dprintk(1, "%s(%u)\n", __func__, freq_hz);
415
416 if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
417 (freq_hz < xc5000_tuner_ops.info.frequency_min))
418 return XC_RESULT_OUT_OF_RANGE;
419
420 freq_code = (u16)(freq_hz / 15625);
421
422
423
424
425 return xc_write_reg(priv, XREG_FINERFREQ, freq_code);
426}
427
428
429static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
430{
431 u32 freq_code = (freq_khz * 1024)/1000;
432 dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
433 __func__, freq_khz, freq_code);
434
435 return xc_write_reg(priv, XREG_IF_OUT, freq_code);
436}
437
438
439static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
440{
441 return xc5000_readreg(priv, XREG_ADC_ENV, adc_envelope);
442}
443
444static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
445{
446 int result;
447 u16 regData;
448 u32 tmp;
449
450 result = xc5000_readreg(priv, XREG_FREQ_ERROR, ®Data);
451 if (result != XC_RESULT_SUCCESS)
452 return result;
453
454 tmp = (u32)regData;
455 (*freq_error_hz) = (tmp * 15625) / 1000;
456 return result;
457}
458
459static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
460{
461 return xc5000_readreg(priv, XREG_LOCK, lock_status);
462}
463
464static int xc_get_version(struct xc5000_priv *priv,
465 u8 *hw_majorversion, u8 *hw_minorversion,
466 u8 *fw_majorversion, u8 *fw_minorversion)
467{
468 u16 data;
469 int result;
470
471 result = xc5000_readreg(priv, XREG_VERSION, &data);
472 if (result != XC_RESULT_SUCCESS)
473 return result;
474
475 (*hw_majorversion) = (data >> 12) & 0x0F;
476 (*hw_minorversion) = (data >> 8) & 0x0F;
477 (*fw_majorversion) = (data >> 4) & 0x0F;
478 (*fw_minorversion) = data & 0x0F;
479
480 return 0;
481}
482
483static int xc_get_buildversion(struct xc5000_priv *priv, u16 *buildrev)
484{
485 return xc5000_readreg(priv, XREG_BUILD, buildrev);
486}
487
488static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
489{
490 u16 regData;
491 int result;
492
493 result = xc5000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
494 if (result != XC_RESULT_SUCCESS)
495 return result;
496
497 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
498 return result;
499}
500
501static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
502{
503 return xc5000_readreg(priv, XREG_FRAME_LINES, frame_lines);
504}
505
506static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
507{
508 return xc5000_readreg(priv, XREG_QUALITY, quality);
509}
510
511static u16 WaitForLock(struct xc5000_priv *priv)
512{
513 u16 lockState = 0;
514 int watchDogCount = 40;
515
516 while ((lockState == 0) && (watchDogCount > 0)) {
517 xc_get_lock_status(priv, &lockState);
518 if (lockState != 1) {
519 xc_wait(5);
520 watchDogCount--;
521 }
522 }
523 return lockState;
524}
525
526#define XC_TUNE_ANALOG 0
527#define XC_TUNE_DIGITAL 1
528static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz, int mode)
529{
530 int found = 0;
531
532 dprintk(1, "%s(%u)\n", __func__, freq_hz);
533
534 if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
535 return 0;
536
537 if (mode == XC_TUNE_ANALOG) {
538 if (WaitForLock(priv) == 1)
539 found = 1;
540 }
541
542 return found;
543}
544
545
546static int xc5000_fwupload(struct dvb_frontend *fe)
547{
548 struct xc5000_priv *priv = fe->tuner_priv;
549 const struct firmware *fw;
550 int ret;
551
552
553 printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
554 XC5000_DEFAULT_FIRMWARE);
555
556 ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE,
557 priv->i2c_props.adap->dev.parent);
558 if (ret) {
559 printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
560 ret = XC_RESULT_RESET_FAILURE;
561 goto out;
562 } else {
563 printk(KERN_DEBUG "xc5000: firmware read %Zu bytes.\n",
564 fw->size);
565 ret = XC_RESULT_SUCCESS;
566 }
567
568 if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
569 printk(KERN_ERR "xc5000: firmware incorrect size\n");
570 ret = XC_RESULT_RESET_FAILURE;
571 } else {
572 printk(KERN_INFO "xc5000: firmware uploading...\n");
573 ret = xc_load_i2c_sequence(fe, fw->data);
574 printk(KERN_INFO "xc5000: firmware upload complete...\n");
575 }
576
577out:
578 release_firmware(fw);
579 return ret;
580}
581
582static void xc_debug_dump(struct xc5000_priv *priv)
583{
584 u16 adc_envelope;
585 u32 freq_error_hz = 0;
586 u16 lock_status;
587 u32 hsync_freq_hz = 0;
588 u16 frame_lines;
589 u16 quality;
590 u8 hw_majorversion = 0, hw_minorversion = 0;
591 u8 fw_majorversion = 0, fw_minorversion = 0;
592 u16 fw_buildversion = 0;
593
594
595
596
597
598 xc_wait(100);
599
600 xc_get_ADC_Envelope(priv, &adc_envelope);
601 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
602
603 xc_get_frequency_error(priv, &freq_error_hz);
604 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
605
606 xc_get_lock_status(priv, &lock_status);
607 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
608 lock_status);
609
610 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
611 &fw_majorversion, &fw_minorversion);
612 xc_get_buildversion(priv, &fw_buildversion);
613 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x.%04x\n",
614 hw_majorversion, hw_minorversion,
615 fw_majorversion, fw_minorversion, fw_buildversion);
616
617 xc_get_hsync_freq(priv, &hsync_freq_hz);
618 dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
619
620 xc_get_frame_lines(priv, &frame_lines);
621 dprintk(1, "*** Frame lines = %d\n", frame_lines);
622
623 xc_get_quality(priv, &quality);
624 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
625}
626
627static int xc5000_set_params(struct dvb_frontend *fe,
628 struct dvb_frontend_parameters *params)
629{
630 struct xc5000_priv *priv = fe->tuner_priv;
631 int ret;
632
633 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
634 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
635 dprintk(1, "Unable to load firmware and init tuner\n");
636 return -EINVAL;
637 }
638 }
639
640 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
641
642 if (fe->ops.info.type == FE_ATSC) {
643 dprintk(1, "%s() ATSC\n", __func__);
644 switch (params->u.vsb.modulation) {
645 case VSB_8:
646 case VSB_16:
647 dprintk(1, "%s() VSB modulation\n", __func__);
648 priv->rf_mode = XC_RF_MODE_AIR;
649 priv->freq_hz = params->frequency - 1750000;
650 priv->bandwidth = BANDWIDTH_6_MHZ;
651 priv->video_standard = DTV6;
652 break;
653 case QAM_64:
654 case QAM_256:
655 case QAM_AUTO:
656 dprintk(1, "%s() QAM modulation\n", __func__);
657 priv->rf_mode = XC_RF_MODE_CABLE;
658 priv->freq_hz = params->frequency - 1750000;
659 priv->bandwidth = BANDWIDTH_6_MHZ;
660 priv->video_standard = DTV6;
661 break;
662 default:
663 return -EINVAL;
664 }
665 } else if (fe->ops.info.type == FE_OFDM) {
666 dprintk(1, "%s() OFDM\n", __func__);
667 switch (params->u.ofdm.bandwidth) {
668 case BANDWIDTH_6_MHZ:
669 priv->bandwidth = BANDWIDTH_6_MHZ;
670 priv->video_standard = DTV6;
671 priv->freq_hz = params->frequency - 1750000;
672 break;
673 case BANDWIDTH_7_MHZ:
674 printk(KERN_ERR "xc5000 bandwidth 7MHz not supported\n");
675 return -EINVAL;
676 case BANDWIDTH_8_MHZ:
677 priv->bandwidth = BANDWIDTH_8_MHZ;
678 priv->video_standard = DTV8;
679 priv->freq_hz = params->frequency - 2750000;
680 break;
681 default:
682 printk(KERN_ERR "xc5000 bandwidth not set!\n");
683 return -EINVAL;
684 }
685 priv->rf_mode = XC_RF_MODE_AIR;
686 } else {
687 printk(KERN_ERR "xc5000 modulation type not supported!\n");
688 return -EINVAL;
689 }
690
691 dprintk(1, "%s() frequency=%d (compensated)\n",
692 __func__, priv->freq_hz);
693
694 ret = xc_SetSignalSource(priv, priv->rf_mode);
695 if (ret != XC_RESULT_SUCCESS) {
696 printk(KERN_ERR
697 "xc5000: xc_SetSignalSource(%d) failed\n",
698 priv->rf_mode);
699 return -EREMOTEIO;
700 }
701
702 ret = xc_SetTVStandard(priv,
703 XC5000_Standard[priv->video_standard].VideoMode,
704 XC5000_Standard[priv->video_standard].AudioMode);
705 if (ret != XC_RESULT_SUCCESS) {
706 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
707 return -EREMOTEIO;
708 }
709
710 ret = xc_set_IF_frequency(priv, priv->if_khz);
711 if (ret != XC_RESULT_SUCCESS) {
712 printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
713 priv->if_khz);
714 return -EIO;
715 }
716
717 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_DIGITAL);
718
719 if (debug)
720 xc_debug_dump(priv);
721
722 return 0;
723}
724
725static int xc5000_is_firmware_loaded(struct dvb_frontend *fe)
726{
727 struct xc5000_priv *priv = fe->tuner_priv;
728 int ret;
729 u16 id;
730
731 ret = xc5000_readreg(priv, XREG_PRODUCT_ID, &id);
732 if (ret == XC_RESULT_SUCCESS) {
733 if (id == XC_PRODUCT_ID_FW_NOT_LOADED)
734 ret = XC_RESULT_RESET_FAILURE;
735 else
736 ret = XC_RESULT_SUCCESS;
737 }
738
739 dprintk(1, "%s() returns %s id = 0x%x\n", __func__,
740 ret == XC_RESULT_SUCCESS ? "True" : "False", id);
741 return ret;
742}
743
744static int xc5000_set_tv_freq(struct dvb_frontend *fe,
745 struct analog_parameters *params)
746{
747 struct xc5000_priv *priv = fe->tuner_priv;
748 int ret;
749
750 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
751 __func__, params->frequency);
752
753
754 priv->rf_mode = params->mode;
755 if (params->mode > XC_RF_MODE_CABLE)
756 priv->rf_mode = XC_RF_MODE_CABLE;
757
758
759 priv->freq_hz = params->frequency * 62500;
760
761
762
763
764 if (params->std & V4L2_STD_MN) {
765
766 priv->video_standard = MN_NTSC_PAL_BTSC;
767 goto tune_channel;
768 }
769
770 if (params->std & V4L2_STD_PAL_BG) {
771
772 priv->video_standard = BG_PAL_NICAM;
773 goto tune_channel;
774 }
775
776 if (params->std & V4L2_STD_PAL_I) {
777
778 priv->video_standard = I_PAL_NICAM;
779 goto tune_channel;
780 }
781
782 if (params->std & V4L2_STD_PAL_DK) {
783
784 priv->video_standard = DK_PAL_NICAM;
785 goto tune_channel;
786 }
787
788 if (params->std & V4L2_STD_SECAM_DK) {
789
790 priv->video_standard = DK_SECAM_A2DK1;
791 goto tune_channel;
792 }
793
794 if (params->std & V4L2_STD_SECAM_L) {
795 priv->video_standard = L_SECAM_NICAM;
796 goto tune_channel;
797 }
798
799 if (params->std & V4L2_STD_SECAM_LC) {
800 priv->video_standard = LC_SECAM_NICAM;
801 goto tune_channel;
802 }
803
804tune_channel:
805 ret = xc_SetSignalSource(priv, priv->rf_mode);
806 if (ret != XC_RESULT_SUCCESS) {
807 printk(KERN_ERR
808 "xc5000: xc_SetSignalSource(%d) failed\n",
809 priv->rf_mode);
810 return -EREMOTEIO;
811 }
812
813 ret = xc_SetTVStandard(priv,
814 XC5000_Standard[priv->video_standard].VideoMode,
815 XC5000_Standard[priv->video_standard].AudioMode);
816 if (ret != XC_RESULT_SUCCESS) {
817 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
818 return -EREMOTEIO;
819 }
820
821 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
822
823 if (debug)
824 xc_debug_dump(priv);
825
826 return 0;
827}
828
829static int xc5000_set_radio_freq(struct dvb_frontend *fe,
830 struct analog_parameters *params)
831{
832 struct xc5000_priv *priv = fe->tuner_priv;
833 int ret = -EINVAL;
834 u8 radio_input;
835
836 dprintk(1, "%s() frequency=%d (in units of khz)\n",
837 __func__, params->frequency);
838
839 if (priv->radio_input == XC5000_RADIO_NOT_CONFIGURED) {
840 dprintk(1, "%s() radio input not configured\n", __func__);
841 return -EINVAL;
842 }
843
844 if (priv->radio_input == XC5000_RADIO_FM1)
845 radio_input = FM_Radio_INPUT1;
846 else if (priv->radio_input == XC5000_RADIO_FM2)
847 radio_input = FM_Radio_INPUT2;
848 else {
849 dprintk(1, "%s() unknown radio input %d\n", __func__,
850 priv->radio_input);
851 return -EINVAL;
852 }
853
854 priv->freq_hz = params->frequency * 125 / 2;
855
856 priv->rf_mode = XC_RF_MODE_AIR;
857
858 ret = xc_SetTVStandard(priv, XC5000_Standard[radio_input].VideoMode,
859 XC5000_Standard[radio_input].AudioMode);
860
861 if (ret != XC_RESULT_SUCCESS) {
862 printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
863 return -EREMOTEIO;
864 }
865
866 ret = xc_SetSignalSource(priv, priv->rf_mode);
867 if (ret != XC_RESULT_SUCCESS) {
868 printk(KERN_ERR
869 "xc5000: xc_SetSignalSource(%d) failed\n",
870 priv->rf_mode);
871 return -EREMOTEIO;
872 }
873
874 xc_tune_channel(priv, priv->freq_hz, XC_TUNE_ANALOG);
875
876 return 0;
877}
878
879static int xc5000_set_analog_params(struct dvb_frontend *fe,
880 struct analog_parameters *params)
881{
882 struct xc5000_priv *priv = fe->tuner_priv;
883 int ret = -EINVAL;
884
885 if (priv->i2c_props.adap == NULL)
886 return -EINVAL;
887
888 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
889 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
890 dprintk(1, "Unable to load firmware and init tuner\n");
891 return -EINVAL;
892 }
893 }
894
895 switch (params->mode) {
896 case V4L2_TUNER_RADIO:
897 ret = xc5000_set_radio_freq(fe, params);
898 break;
899 case V4L2_TUNER_ANALOG_TV:
900 case V4L2_TUNER_DIGITAL_TV:
901 ret = xc5000_set_tv_freq(fe, params);
902 break;
903 }
904
905 return ret;
906}
907
908
909static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
910{
911 struct xc5000_priv *priv = fe->tuner_priv;
912 dprintk(1, "%s()\n", __func__);
913 *freq = priv->freq_hz;
914 return 0;
915}
916
917static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
918{
919 struct xc5000_priv *priv = fe->tuner_priv;
920 dprintk(1, "%s()\n", __func__);
921
922 *bw = priv->bandwidth;
923 return 0;
924}
925
926static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
927{
928 struct xc5000_priv *priv = fe->tuner_priv;
929 u16 lock_status = 0;
930
931 xc_get_lock_status(priv, &lock_status);
932
933 dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
934
935 *status = lock_status;
936
937 return 0;
938}
939
940static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
941{
942 struct xc5000_priv *priv = fe->tuner_priv;
943 int ret = 0;
944
945 if (xc5000_is_firmware_loaded(fe) != XC_RESULT_SUCCESS) {
946 ret = xc5000_fwupload(fe);
947 if (ret != XC_RESULT_SUCCESS)
948 return ret;
949 }
950
951
952 ret |= xc_initialize(priv);
953
954
955
956
957
958
959 xc_wait(100);
960
961
962 ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
963
964 return ret;
965}
966
967static int xc5000_sleep(struct dvb_frontend *fe)
968{
969 int ret;
970
971 dprintk(1, "%s()\n", __func__);
972
973
974 if (no_poweroff)
975 return 0;
976
977
978
979
980 ret = xc5000_TunerReset(fe);
981 if (ret != XC_RESULT_SUCCESS) {
982 printk(KERN_ERR
983 "xc5000: %s() unable to shutdown tuner\n",
984 __func__);
985 return -EREMOTEIO;
986 } else
987 return XC_RESULT_SUCCESS;
988}
989
990static int xc5000_init(struct dvb_frontend *fe)
991{
992 struct xc5000_priv *priv = fe->tuner_priv;
993 dprintk(1, "%s()\n", __func__);
994
995 if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
996 printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
997 return -EREMOTEIO;
998 }
999
1000 if (debug)
1001 xc_debug_dump(priv);
1002
1003 return 0;
1004}
1005
1006static int xc5000_release(struct dvb_frontend *fe)
1007{
1008 struct xc5000_priv *priv = fe->tuner_priv;
1009
1010 dprintk(1, "%s()\n", __func__);
1011
1012 mutex_lock(&xc5000_list_mutex);
1013
1014 if (priv)
1015 hybrid_tuner_release_state(priv);
1016
1017 mutex_unlock(&xc5000_list_mutex);
1018
1019 fe->tuner_priv = NULL;
1020
1021 return 0;
1022}
1023
1024static const struct dvb_tuner_ops xc5000_tuner_ops = {
1025 .info = {
1026 .name = "Xceive XC5000",
1027 .frequency_min = 1000000,
1028 .frequency_max = 1023000000,
1029 .frequency_step = 50000,
1030 },
1031
1032 .release = xc5000_release,
1033 .init = xc5000_init,
1034 .sleep = xc5000_sleep,
1035
1036 .set_params = xc5000_set_params,
1037 .set_analog_params = xc5000_set_analog_params,
1038 .get_frequency = xc5000_get_frequency,
1039 .get_bandwidth = xc5000_get_bandwidth,
1040 .get_status = xc5000_get_status
1041};
1042
1043struct dvb_frontend *xc5000_attach(struct dvb_frontend *fe,
1044 struct i2c_adapter *i2c,
1045 const struct xc5000_config *cfg)
1046{
1047 struct xc5000_priv *priv = NULL;
1048 int instance;
1049 u16 id = 0;
1050
1051 dprintk(1, "%s(%d-%04x)\n", __func__,
1052 i2c ? i2c_adapter_id(i2c) : -1,
1053 cfg ? cfg->i2c_address : -1);
1054
1055 mutex_lock(&xc5000_list_mutex);
1056
1057 instance = hybrid_tuner_request_state(struct xc5000_priv, priv,
1058 hybrid_tuner_instance_list,
1059 i2c, cfg->i2c_address, "xc5000");
1060 switch (instance) {
1061 case 0:
1062 goto fail;
1063 break;
1064 case 1:
1065
1066 priv->bandwidth = BANDWIDTH_6_MHZ;
1067 fe->tuner_priv = priv;
1068 break;
1069 default:
1070
1071 fe->tuner_priv = priv;
1072 break;
1073 }
1074
1075 if (priv->if_khz == 0) {
1076
1077
1078
1079 priv->if_khz = cfg->if_khz;
1080 }
1081
1082 if (priv->radio_input == 0)
1083 priv->radio_input = cfg->radio_input;
1084
1085
1086
1087
1088 if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != XC_RESULT_SUCCESS)
1089 goto fail;
1090
1091 switch (id) {
1092 case XC_PRODUCT_ID_FW_LOADED:
1093 printk(KERN_INFO
1094 "xc5000: Successfully identified at address 0x%02x\n",
1095 cfg->i2c_address);
1096 printk(KERN_INFO
1097 "xc5000: Firmware has been loaded previously\n");
1098 break;
1099 case XC_PRODUCT_ID_FW_NOT_LOADED:
1100 printk(KERN_INFO
1101 "xc5000: Successfully identified at address 0x%02x\n",
1102 cfg->i2c_address);
1103 printk(KERN_INFO
1104 "xc5000: Firmware has not been loaded previously\n");
1105 break;
1106 default:
1107 printk(KERN_ERR
1108 "xc5000: Device not found at addr 0x%02x (0x%x)\n",
1109 cfg->i2c_address, id);
1110 goto fail;
1111 }
1112
1113 mutex_unlock(&xc5000_list_mutex);
1114
1115 memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
1116 sizeof(struct dvb_tuner_ops));
1117
1118 return fe;
1119fail:
1120 mutex_unlock(&xc5000_list_mutex);
1121
1122 xc5000_release(fe);
1123 return NULL;
1124}
1125EXPORT_SYMBOL(xc5000_attach);
1126
1127MODULE_AUTHOR("Steven Toth");
1128MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
1129MODULE_LICENSE("GPL");
1130