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