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