1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/videodev2.h>
28#include <linux/delay.h>
29#include <linux/dvb/frontend.h>
30#include <linux/i2c.h>
31#include <linux/mutex.h>
32#include <asm/unaligned.h>
33
34#include "dvb_frontend.h"
35
36#include "xc4000.h"
37#include "tuner-i2c.h"
38#include "tuner-xc2028-types.h"
39
40static int debug;
41module_param(debug, int, 0644);
42MODULE_PARM_DESC(debug, "Debugging level (0 to 2, default: 0 (off)).");
43
44static int no_poweroff;
45module_param(no_poweroff, int, 0644);
46MODULE_PARM_DESC(no_poweroff, "Power management (1: disabled, 2: enabled, "
47 "0 (default): use device-specific default mode).");
48
49static int audio_std;
50module_param(audio_std, int, 0644);
51MODULE_PARM_DESC(audio_std, "Audio standard. XC4000 audio decoder explicitly "
52 "needs to know what audio standard is needed for some video standards "
53 "with audio A2 or NICAM. The valid settings are a sum of:\n"
54 " 1: use NICAM/B or A2/B instead of NICAM/A or A2/A\n"
55 " 2: use A2 instead of NICAM or BTSC\n"
56 " 4: use SECAM/K3 instead of K1\n"
57 " 8: use PAL-D/K audio for SECAM-D/K\n"
58 "16: use FM radio input 1 instead of input 2\n"
59 "32: use mono audio (the lower three bits are ignored)");
60
61static char firmware_name[30];
62module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
63MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
64 "default firmware name.");
65
66static DEFINE_MUTEX(xc4000_list_mutex);
67static LIST_HEAD(hybrid_tuner_instance_list);
68
69#define dprintk(level, fmt, arg...) if (debug >= level) \
70 printk(KERN_INFO "%s: " fmt, "xc4000", ## arg)
71
72
73struct firmware_description {
74 unsigned int type;
75 v4l2_std_id id;
76 __u16 int_freq;
77 unsigned char *ptr;
78 unsigned int size;
79};
80
81struct firmware_properties {
82 unsigned int type;
83 v4l2_std_id id;
84 v4l2_std_id std_req;
85 __u16 int_freq;
86 unsigned int scode_table;
87 int scode_nr;
88};
89
90struct xc4000_priv {
91 struct tuner_i2c_props i2c_props;
92 struct list_head hybrid_tuner_instance_list;
93 struct firmware_description *firm;
94 int firm_size;
95 u32 if_khz;
96 u32 freq_hz, freq_offset;
97 u32 bandwidth;
98 u8 video_standard;
99 u8 rf_mode;
100 u8 default_pm;
101 u8 dvb_amplitude;
102 u8 set_smoothedcvbs;
103 u8 ignore_i2c_write_errors;
104 __u16 firm_version;
105 struct firmware_properties cur_fw;
106 __u16 hwmodel;
107 __u16 hwvers;
108 struct mutex lock;
109};
110
111#define XC4000_AUDIO_STD_B 1
112#define XC4000_AUDIO_STD_A2 2
113#define XC4000_AUDIO_STD_K3 4
114#define XC4000_AUDIO_STD_L 8
115#define XC4000_AUDIO_STD_INPUT1 16
116#define XC4000_AUDIO_STD_MONO 32
117
118#define XC4000_DEFAULT_FIRMWARE "dvb-fe-xc4000-1.4.fw"
119#define XC4000_DEFAULT_FIRMWARE_NEW "dvb-fe-xc4000-1.4.1.fw"
120
121
122#define MAX_TV_STANDARD 24
123#define XC_MAX_I2C_WRITE_LENGTH 64
124#define XC_POWERED_DOWN 0x80000000U
125
126
127#define XC_RF_MODE_AIR 0
128#define XC_RF_MODE_CABLE 1
129
130
131#define XC_PRODUCT_ID_FW_NOT_LOADED 0x2000
132#define XC_PRODUCT_ID_XC4000 0x0FA0
133#define XC_PRODUCT_ID_XC4100 0x1004
134
135
136#define XREG_INIT 0x00
137#define XREG_VIDEO_MODE 0x01
138#define XREG_AUDIO_MODE 0x02
139#define XREG_RF_FREQ 0x03
140#define XREG_D_CODE 0x04
141#define XREG_DIRECTSITTING_MODE 0x05
142#define XREG_SEEK_MODE 0x06
143#define XREG_POWER_DOWN 0x08
144#define XREG_SIGNALSOURCE 0x0A
145#define XREG_SMOOTHEDCVBS 0x0E
146#define XREG_AMPLITUDE 0x10
147
148
149#define XREG_ADC_ENV 0x00
150#define XREG_QUALITY 0x01
151#define XREG_FRAME_LINES 0x02
152#define XREG_HSYNC_FREQ 0x03
153#define XREG_LOCK 0x04
154#define XREG_FREQ_ERROR 0x05
155#define XREG_SNR 0x06
156#define XREG_VERSION 0x07
157#define XREG_PRODUCT_ID 0x08
158#define XREG_SIGNAL_LEVEL 0x0A
159#define XREG_NOISE_LEVEL 0x0B
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194struct XC_TV_STANDARD {
195 const char *Name;
196 u16 audio_mode;
197 u16 video_mode;
198 u16 int_freq;
199};
200
201
202#define XC4000_MN_NTSC_PAL_BTSC 0
203#define XC4000_MN_NTSC_PAL_A2 1
204#define XC4000_MN_NTSC_PAL_EIAJ 2
205#define XC4000_MN_NTSC_PAL_Mono 3
206#define XC4000_BG_PAL_A2 4
207#define XC4000_BG_PAL_NICAM 5
208#define XC4000_BG_PAL_MONO 6
209#define XC4000_I_PAL_NICAM 7
210#define XC4000_I_PAL_NICAM_MONO 8
211#define XC4000_DK_PAL_A2 9
212#define XC4000_DK_PAL_NICAM 10
213#define XC4000_DK_PAL_MONO 11
214#define XC4000_DK_SECAM_A2DK1 12
215#define XC4000_DK_SECAM_A2LDK3 13
216#define XC4000_DK_SECAM_A2MONO 14
217#define XC4000_DK_SECAM_NICAM 15
218#define XC4000_L_SECAM_NICAM 16
219#define XC4000_LC_SECAM_NICAM 17
220#define XC4000_DTV6 18
221#define XC4000_DTV8 19
222#define XC4000_DTV7_8 20
223#define XC4000_DTV7 21
224#define XC4000_FM_Radio_INPUT2 22
225#define XC4000_FM_Radio_INPUT1 23
226
227static struct XC_TV_STANDARD xc4000_standard[MAX_TV_STANDARD] = {
228 {"M/N-NTSC/PAL-BTSC", 0x0000, 0x80A0, 4500},
229 {"M/N-NTSC/PAL-A2", 0x0000, 0x80A0, 4600},
230 {"M/N-NTSC/PAL-EIAJ", 0x0040, 0x80A0, 4500},
231 {"M/N-NTSC/PAL-Mono", 0x0078, 0x80A0, 4500},
232 {"B/G-PAL-A2", 0x0000, 0x8159, 5640},
233 {"B/G-PAL-NICAM", 0x0004, 0x8159, 5740},
234 {"B/G-PAL-MONO", 0x0078, 0x8159, 5500},
235 {"I-PAL-NICAM", 0x0080, 0x8049, 6240},
236 {"I-PAL-NICAM-MONO", 0x0078, 0x8049, 6000},
237 {"D/K-PAL-A2", 0x0000, 0x8049, 6380},
238 {"D/K-PAL-NICAM", 0x0080, 0x8049, 6200},
239 {"D/K-PAL-MONO", 0x0078, 0x8049, 6500},
240 {"D/K-SECAM-A2 DK1", 0x0000, 0x8049, 6340},
241 {"D/K-SECAM-A2 L/DK3", 0x0000, 0x8049, 6000},
242 {"D/K-SECAM-A2 MONO", 0x0078, 0x8049, 6500},
243 {"D/K-SECAM-NICAM", 0x0080, 0x8049, 6200},
244 {"L-SECAM-NICAM", 0x8080, 0x0009, 6200},
245 {"L'-SECAM-NICAM", 0x8080, 0x4009, 6200},
246 {"DTV6", 0x00C0, 0x8002, 0},
247 {"DTV8", 0x00C0, 0x800B, 0},
248 {"DTV7/8", 0x00C0, 0x801B, 0},
249 {"DTV7", 0x00C0, 0x8007, 0},
250 {"FM Radio-INPUT2", 0x0008, 0x9800, 10700},
251 {"FM Radio-INPUT1", 0x0008, 0x9000, 10700}
252};
253
254static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val);
255static int xc4000_tuner_reset(struct dvb_frontend *fe);
256static void xc_debug_dump(struct xc4000_priv *priv);
257
258static int xc_send_i2c_data(struct xc4000_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 if (i2c_transfer(priv->i2c_props.adap, &msg, 1) != 1) {
263 if (priv->ignore_i2c_write_errors == 0) {
264 printk(KERN_ERR "xc4000: I2C write failed (len=%i)\n",
265 len);
266 if (len == 4) {
267 printk(KERN_ERR "bytes %*ph\n", 4, buf);
268 }
269 return -EREMOTEIO;
270 }
271 }
272 return 0;
273}
274
275static int xc4000_tuner_reset(struct dvb_frontend *fe)
276{
277 struct xc4000_priv *priv = fe->tuner_priv;
278 int ret;
279
280 dprintk(1, "%s()\n", __func__);
281
282 if (fe->callback) {
283 ret = fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
284 fe->dvb->priv :
285 priv->i2c_props.adap->algo_data,
286 DVB_FRONTEND_COMPONENT_TUNER,
287 XC4000_TUNER_RESET, 0);
288 if (ret) {
289 printk(KERN_ERR "xc4000: reset failed\n");
290 return -EREMOTEIO;
291 }
292 } else {
293 printk(KERN_ERR "xc4000: no tuner reset callback function, "
294 "fatal\n");
295 return -EINVAL;
296 }
297 return 0;
298}
299
300static int xc_write_reg(struct xc4000_priv *priv, u16 regAddr, u16 i2cData)
301{
302 u8 buf[4];
303 int result;
304
305 buf[0] = (regAddr >> 8) & 0xFF;
306 buf[1] = regAddr & 0xFF;
307 buf[2] = (i2cData >> 8) & 0xFF;
308 buf[3] = i2cData & 0xFF;
309 result = xc_send_i2c_data(priv, buf, 4);
310
311 return result;
312}
313
314static int xc_load_i2c_sequence(struct dvb_frontend *fe, const u8 *i2c_sequence)
315{
316 struct xc4000_priv *priv = fe->tuner_priv;
317
318 int i, nbytes_to_send, result;
319 unsigned int len, pos, index;
320 u8 buf[XC_MAX_I2C_WRITE_LENGTH];
321
322 index = 0;
323 while ((i2c_sequence[index] != 0xFF) ||
324 (i2c_sequence[index + 1] != 0xFF)) {
325 len = i2c_sequence[index] * 256 + i2c_sequence[index+1];
326 if (len == 0x0000) {
327
328
329
330 index += 2;
331 } else if (len & 0x8000) {
332
333 msleep(len & 0x7FFF);
334 index += 2;
335 } else {
336
337
338
339 index += 2;
340 buf[0] = i2c_sequence[index];
341 buf[1] = i2c_sequence[index + 1];
342 pos = 2;
343 while (pos < len) {
344 if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2)
345 nbytes_to_send =
346 XC_MAX_I2C_WRITE_LENGTH;
347 else
348 nbytes_to_send = (len - pos + 2);
349 for (i = 2; i < nbytes_to_send; i++) {
350 buf[i] = i2c_sequence[index + pos +
351 i - 2];
352 }
353 result = xc_send_i2c_data(priv, buf,
354 nbytes_to_send);
355
356 if (result != 0)
357 return result;
358
359 pos += nbytes_to_send - 2;
360 }
361 index += len;
362 }
363 }
364 return 0;
365}
366
367static int xc_set_tv_standard(struct xc4000_priv *priv,
368 u16 video_mode, u16 audio_mode)
369{
370 int ret;
371 dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, video_mode, audio_mode);
372 dprintk(1, "%s() Standard = %s\n",
373 __func__,
374 xc4000_standard[priv->video_standard].Name);
375
376
377 priv->ignore_i2c_write_errors = 1;
378
379 ret = xc_write_reg(priv, XREG_VIDEO_MODE, video_mode);
380 if (ret == 0)
381 ret = xc_write_reg(priv, XREG_AUDIO_MODE, audio_mode);
382
383 priv->ignore_i2c_write_errors = 0;
384
385 return ret;
386}
387
388static int xc_set_signal_source(struct xc4000_priv *priv, u16 rf_mode)
389{
390 dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
391 rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
392
393 if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE)) {
394 rf_mode = XC_RF_MODE_CABLE;
395 printk(KERN_ERR
396 "%s(), Invalid mode, defaulting to CABLE",
397 __func__);
398 }
399 return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
400}
401
402static const struct dvb_tuner_ops xc4000_tuner_ops;
403
404static int xc_set_rf_frequency(struct xc4000_priv *priv, u32 freq_hz)
405{
406 u16 freq_code;
407
408 dprintk(1, "%s(%u)\n", __func__, freq_hz);
409
410 if ((freq_hz > xc4000_tuner_ops.info.frequency_max) ||
411 (freq_hz < xc4000_tuner_ops.info.frequency_min))
412 return -EINVAL;
413
414 freq_code = (u16)(freq_hz / 15625);
415
416
417
418
419
420 return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
421}
422
423static int xc_get_adc_envelope(struct xc4000_priv *priv, u16 *adc_envelope)
424{
425 return xc4000_readreg(priv, XREG_ADC_ENV, adc_envelope);
426}
427
428static int xc_get_frequency_error(struct xc4000_priv *priv, u32 *freq_error_hz)
429{
430 int result;
431 u16 regData;
432 u32 tmp;
433
434 result = xc4000_readreg(priv, XREG_FREQ_ERROR, ®Data);
435 if (result != 0)
436 return result;
437
438 tmp = (u32)regData & 0xFFFFU;
439 tmp = (tmp < 0x8000U ? tmp : 0x10000U - tmp);
440 (*freq_error_hz) = tmp * 15625;
441 return result;
442}
443
444static int xc_get_lock_status(struct xc4000_priv *priv, u16 *lock_status)
445{
446 return xc4000_readreg(priv, XREG_LOCK, lock_status);
447}
448
449static int xc_get_version(struct xc4000_priv *priv,
450 u8 *hw_majorversion, u8 *hw_minorversion,
451 u8 *fw_majorversion, u8 *fw_minorversion)
452{
453 u16 data;
454 int result;
455
456 result = xc4000_readreg(priv, XREG_VERSION, &data);
457 if (result != 0)
458 return result;
459
460 (*hw_majorversion) = (data >> 12) & 0x0F;
461 (*hw_minorversion) = (data >> 8) & 0x0F;
462 (*fw_majorversion) = (data >> 4) & 0x0F;
463 (*fw_minorversion) = data & 0x0F;
464
465 return 0;
466}
467
468static int xc_get_hsync_freq(struct xc4000_priv *priv, u32 *hsync_freq_hz)
469{
470 u16 regData;
471 int result;
472
473 result = xc4000_readreg(priv, XREG_HSYNC_FREQ, ®Data);
474 if (result != 0)
475 return result;
476
477 (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
478 return result;
479}
480
481static int xc_get_frame_lines(struct xc4000_priv *priv, u16 *frame_lines)
482{
483 return xc4000_readreg(priv, XREG_FRAME_LINES, frame_lines);
484}
485
486static int xc_get_quality(struct xc4000_priv *priv, u16 *quality)
487{
488 return xc4000_readreg(priv, XREG_QUALITY, quality);
489}
490
491static int xc_get_signal_level(struct xc4000_priv *priv, u16 *signal)
492{
493 return xc4000_readreg(priv, XREG_SIGNAL_LEVEL, signal);
494}
495
496static int xc_get_noise_level(struct xc4000_priv *priv, u16 *noise)
497{
498 return xc4000_readreg(priv, XREG_NOISE_LEVEL, noise);
499}
500
501static u16 xc_wait_for_lock(struct xc4000_priv *priv)
502{
503 u16 lock_state = 0;
504 int watchdog_count = 40;
505
506 while ((lock_state == 0) && (watchdog_count > 0)) {
507 xc_get_lock_status(priv, &lock_state);
508 if (lock_state != 1) {
509 msleep(5);
510 watchdog_count--;
511 }
512 }
513 return lock_state;
514}
515
516static int xc_tune_channel(struct xc4000_priv *priv, u32 freq_hz)
517{
518 int found = 1;
519 int result;
520
521 dprintk(1, "%s(%u)\n", __func__, freq_hz);
522
523
524 priv->ignore_i2c_write_errors = 1;
525 result = xc_set_rf_frequency(priv, freq_hz);
526 priv->ignore_i2c_write_errors = 0;
527
528 if (result != 0)
529 return 0;
530
531
532 if ((priv->cur_fw.type & (FM | DTV6 | DTV7 | DTV78 | DTV8)) == 0) {
533 if (xc_wait_for_lock(priv) != 1)
534 found = 0;
535 }
536
537
538
539
540
541 msleep(debug ? 100 : 10);
542
543 if (debug)
544 xc_debug_dump(priv);
545
546 return found;
547}
548
549static int xc4000_readreg(struct xc4000_priv *priv, u16 reg, u16 *val)
550{
551 u8 buf[2] = { reg >> 8, reg & 0xff };
552 u8 bval[2] = { 0, 0 };
553 struct i2c_msg msg[2] = {
554 { .addr = priv->i2c_props.addr,
555 .flags = 0, .buf = &buf[0], .len = 2 },
556 { .addr = priv->i2c_props.addr,
557 .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
558 };
559
560 if (i2c_transfer(priv->i2c_props.adap, msg, 2) != 2) {
561 printk(KERN_ERR "xc4000: I2C read failed\n");
562 return -EREMOTEIO;
563 }
564
565 *val = (bval[0] << 8) | bval[1];
566 return 0;
567}
568
569#define dump_firm_type(t) dump_firm_type_and_int_freq(t, 0)
570static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
571{
572 if (type & BASE)
573 printk(KERN_CONT "BASE ");
574 if (type & INIT1)
575 printk(KERN_CONT "INIT1 ");
576 if (type & F8MHZ)
577 printk(KERN_CONT "F8MHZ ");
578 if (type & MTS)
579 printk(KERN_CONT "MTS ");
580 if (type & D2620)
581 printk(KERN_CONT "D2620 ");
582 if (type & D2633)
583 printk(KERN_CONT "D2633 ");
584 if (type & DTV6)
585 printk(KERN_CONT "DTV6 ");
586 if (type & QAM)
587 printk(KERN_CONT "QAM ");
588 if (type & DTV7)
589 printk(KERN_CONT "DTV7 ");
590 if (type & DTV78)
591 printk(KERN_CONT "DTV78 ");
592 if (type & DTV8)
593 printk(KERN_CONT "DTV8 ");
594 if (type & FM)
595 printk(KERN_CONT "FM ");
596 if (type & INPUT1)
597 printk(KERN_CONT "INPUT1 ");
598 if (type & LCD)
599 printk(KERN_CONT "LCD ");
600 if (type & NOGD)
601 printk(KERN_CONT "NOGD ");
602 if (type & MONO)
603 printk(KERN_CONT "MONO ");
604 if (type & ATSC)
605 printk(KERN_CONT "ATSC ");
606 if (type & IF)
607 printk(KERN_CONT "IF ");
608 if (type & LG60)
609 printk(KERN_CONT "LG60 ");
610 if (type & ATI638)
611 printk(KERN_CONT "ATI638 ");
612 if (type & OREN538)
613 printk(KERN_CONT "OREN538 ");
614 if (type & OREN36)
615 printk(KERN_CONT "OREN36 ");
616 if (type & TOYOTA388)
617 printk(KERN_CONT "TOYOTA388 ");
618 if (type & TOYOTA794)
619 printk(KERN_CONT "TOYOTA794 ");
620 if (type & DIBCOM52)
621 printk(KERN_CONT "DIBCOM52 ");
622 if (type & ZARLINK456)
623 printk(KERN_CONT "ZARLINK456 ");
624 if (type & CHINA)
625 printk(KERN_CONT "CHINA ");
626 if (type & F6MHZ)
627 printk(KERN_CONT "F6MHZ ");
628 if (type & INPUT2)
629 printk(KERN_CONT "INPUT2 ");
630 if (type & SCODE)
631 printk(KERN_CONT "SCODE ");
632 if (type & HAS_IF)
633 printk(KERN_CONT "HAS_IF_%d ", int_freq);
634}
635
636static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
637 v4l2_std_id *id)
638{
639 struct xc4000_priv *priv = fe->tuner_priv;
640 int i, best_i = -1;
641 unsigned int best_nr_diffs = 255U;
642
643 if (!priv->firm) {
644 printk(KERN_ERR "Error! firmware not loaded\n");
645 return -EINVAL;
646 }
647
648 if (((type & ~SCODE) == 0) && (*id == 0))
649 *id = V4L2_STD_PAL;
650
651
652 for (i = 0; i < priv->firm_size; i++) {
653 v4l2_std_id id_diff_mask =
654 (priv->firm[i].id ^ (*id)) & (*id);
655 unsigned int type_diff_mask =
656 (priv->firm[i].type ^ type)
657 & (BASE_TYPES | DTV_TYPES | LCD | NOGD | MONO | SCODE);
658 unsigned int nr_diffs;
659
660 if (type_diff_mask
661 & (BASE | INIT1 | FM | DTV6 | DTV7 | DTV78 | DTV8 | SCODE))
662 continue;
663
664 nr_diffs = hweight64(id_diff_mask) + hweight32(type_diff_mask);
665 if (!nr_diffs)
666 goto found;
667
668 if (nr_diffs < best_nr_diffs) {
669 best_nr_diffs = nr_diffs;
670 best_i = i;
671 }
672 }
673
674
675 if (best_i < 0) {
676 i = -ENOENT;
677 goto ret;
678 }
679
680 if (best_nr_diffs > 0U) {
681 printk(KERN_WARNING
682 "Selecting best matching firmware (%u bits differ) for "
683 "type=(%x), id %016llx:\n",
684 best_nr_diffs, type, (unsigned long long)*id);
685 i = best_i;
686 }
687
688found:
689 *id = priv->firm[i].id;
690
691ret:
692 if (debug) {
693 printk(KERN_DEBUG "%s firmware for type=",
694 (i < 0) ? "Can't find" : "Found");
695 dump_firm_type(type);
696 printk(KERN_DEBUG "(%x), id %016llx.\n", type, (unsigned long long)*id);
697 }
698 return i;
699}
700
701static int load_firmware(struct dvb_frontend *fe, unsigned int type,
702 v4l2_std_id *id)
703{
704 struct xc4000_priv *priv = fe->tuner_priv;
705 int pos, rc;
706 unsigned char *p;
707
708 pos = seek_firmware(fe, type, id);
709 if (pos < 0)
710 return pos;
711
712 p = priv->firm[pos].ptr;
713
714
715 priv->ignore_i2c_write_errors = 1;
716
717 rc = xc_load_i2c_sequence(fe, p);
718
719 priv->ignore_i2c_write_errors = 0;
720
721 return rc;
722}
723
724static int xc4000_fwupload(struct dvb_frontend *fe)
725{
726 struct xc4000_priv *priv = fe->tuner_priv;
727 const struct firmware *fw = NULL;
728 const unsigned char *p, *endp;
729 int rc = 0;
730 int n, n_array;
731 char name[33];
732 const char *fname;
733
734 if (firmware_name[0] != '\0') {
735 fname = firmware_name;
736
737 dprintk(1, "Reading custom firmware %s\n", fname);
738 rc = request_firmware(&fw, fname,
739 priv->i2c_props.adap->dev.parent);
740 } else {
741 fname = XC4000_DEFAULT_FIRMWARE_NEW;
742 dprintk(1, "Trying to read firmware %s\n", fname);
743 rc = request_firmware(&fw, fname,
744 priv->i2c_props.adap->dev.parent);
745 if (rc == -ENOENT) {
746 fname = XC4000_DEFAULT_FIRMWARE;
747 dprintk(1, "Trying to read firmware %s\n", fname);
748 rc = request_firmware(&fw, fname,
749 priv->i2c_props.adap->dev.parent);
750 }
751 }
752
753 if (rc < 0) {
754 if (rc == -ENOENT)
755 printk(KERN_ERR "Error: firmware %s not found.\n", fname);
756 else
757 printk(KERN_ERR "Error %d while requesting firmware %s\n",
758 rc, fname);
759
760 return rc;
761 }
762 dprintk(1, "Loading Firmware: %s\n", fname);
763
764 p = fw->data;
765 endp = p + fw->size;
766
767 if (fw->size < sizeof(name) - 1 + 2 + 2) {
768 printk(KERN_ERR "Error: firmware file %s has invalid size!\n",
769 fname);
770 goto corrupt;
771 }
772
773 memcpy(name, p, sizeof(name) - 1);
774 name[sizeof(name) - 1] = '\0';
775 p += sizeof(name) - 1;
776
777 priv->firm_version = get_unaligned_le16(p);
778 p += 2;
779
780 n_array = get_unaligned_le16(p);
781 p += 2;
782
783 dprintk(1, "Loading %d firmware images from %s, type: %s, ver %d.%d\n",
784 n_array, fname, name,
785 priv->firm_version >> 8, priv->firm_version & 0xff);
786
787 priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
788 if (priv->firm == NULL) {
789 printk(KERN_ERR "Not enough memory to load firmware file.\n");
790 rc = -ENOMEM;
791 goto done;
792 }
793 priv->firm_size = n_array;
794
795 n = -1;
796 while (p < endp) {
797 __u32 type, size;
798 v4l2_std_id id;
799 __u16 int_freq = 0;
800
801 n++;
802 if (n >= n_array) {
803 printk(KERN_ERR "More firmware images in file than "
804 "were expected!\n");
805 goto corrupt;
806 }
807
808
809 if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
810 goto header;
811
812 type = get_unaligned_le32(p);
813 p += sizeof(type);
814
815 id = get_unaligned_le64(p);
816 p += sizeof(id);
817
818 if (type & HAS_IF) {
819 int_freq = get_unaligned_le16(p);
820 p += sizeof(int_freq);
821 if (endp - p < sizeof(size))
822 goto header;
823 }
824
825 size = get_unaligned_le32(p);
826 p += sizeof(size);
827
828 if (!size || size > endp - p) {
829 printk(KERN_ERR "Firmware type (%x), id %llx is corrupted (size=%d, expected %d)\n",
830 type, (unsigned long long)id,
831 (unsigned)(endp - p), size);
832 goto corrupt;
833 }
834
835 priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
836 if (priv->firm[n].ptr == NULL) {
837 printk(KERN_ERR "Not enough memory to load firmware file.\n");
838 rc = -ENOMEM;
839 goto done;
840 }
841
842 if (debug) {
843 printk(KERN_DEBUG "Reading firmware type ");
844 dump_firm_type_and_int_freq(type, int_freq);
845 printk(KERN_DEBUG "(%x), id %llx, size=%d.\n",
846 type, (unsigned long long)id, size);
847 }
848
849 memcpy(priv->firm[n].ptr, p, size);
850 priv->firm[n].type = type;
851 priv->firm[n].id = id;
852 priv->firm[n].size = size;
853 priv->firm[n].int_freq = int_freq;
854
855 p += size;
856 }
857
858 if (n + 1 != priv->firm_size) {
859 printk(KERN_ERR "Firmware file is incomplete!\n");
860 goto corrupt;
861 }
862
863 goto done;
864
865header:
866 printk(KERN_ERR "Firmware header is incomplete!\n");
867corrupt:
868 rc = -EINVAL;
869 printk(KERN_ERR "Error: firmware file is corrupted!\n");
870
871done:
872 release_firmware(fw);
873 if (rc == 0)
874 dprintk(1, "Firmware files loaded.\n");
875
876 return rc;
877}
878
879static int load_scode(struct dvb_frontend *fe, unsigned int type,
880 v4l2_std_id *id, __u16 int_freq, int scode)
881{
882 struct xc4000_priv *priv = fe->tuner_priv;
883 int pos, rc;
884 unsigned char *p;
885 u8 scode_buf[13];
886 u8 indirect_mode[5];
887
888 dprintk(1, "%s called int_freq=%d\n", __func__, int_freq);
889
890 if (!int_freq) {
891 pos = seek_firmware(fe, type, id);
892 if (pos < 0)
893 return pos;
894 } else {
895 for (pos = 0; pos < priv->firm_size; pos++) {
896 if ((priv->firm[pos].int_freq == int_freq) &&
897 (priv->firm[pos].type & HAS_IF))
898 break;
899 }
900 if (pos == priv->firm_size)
901 return -ENOENT;
902 }
903
904 p = priv->firm[pos].ptr;
905
906 if (priv->firm[pos].size != 12 * 16 || scode >= 16)
907 return -EINVAL;
908 p += 12 * scode;
909
910 if (debug) {
911 tuner_info("Loading SCODE for type=");
912 dump_firm_type_and_int_freq(priv->firm[pos].type,
913 priv->firm[pos].int_freq);
914 printk(KERN_CONT "(%x), id %016llx.\n", priv->firm[pos].type,
915 (unsigned long long)*id);
916 }
917
918 scode_buf[0] = 0x00;
919 memcpy(&scode_buf[1], p, 12);
920
921
922 rc = xc_write_reg(priv, XREG_DIRECTSITTING_MODE, 0);
923 if (rc < 0) {
924 printk(KERN_ERR "failed to put device into direct mode!\n");
925 return -EIO;
926 }
927
928 rc = xc_send_i2c_data(priv, scode_buf, 13);
929 if (rc != 0) {
930
931
932 printk(KERN_ERR "Failed to set scode %d\n", rc);
933 }
934
935
936 memset(indirect_mode, 0, sizeof(indirect_mode));
937 indirect_mode[4] = 0x88;
938 xc_send_i2c_data(priv, indirect_mode, sizeof(indirect_mode));
939 msleep(10);
940
941 return 0;
942}
943
944static int check_firmware(struct dvb_frontend *fe, unsigned int type,
945 v4l2_std_id std, __u16 int_freq)
946{
947 struct xc4000_priv *priv = fe->tuner_priv;
948 struct firmware_properties new_fw;
949 int rc = 0, is_retry = 0;
950 u16 hwmodel;
951 v4l2_std_id std0;
952 u8 hw_major = 0, hw_minor = 0, fw_major = 0, fw_minor = 0;
953
954 dprintk(1, "%s called\n", __func__);
955
956 if (!priv->firm) {
957 rc = xc4000_fwupload(fe);
958 if (rc < 0)
959 return rc;
960 }
961
962retry:
963 new_fw.type = type;
964 new_fw.id = std;
965 new_fw.std_req = std;
966 new_fw.scode_table = SCODE;
967 new_fw.scode_nr = 0;
968 new_fw.int_freq = int_freq;
969
970 dprintk(1, "checking firmware, user requested type=");
971 if (debug) {
972 dump_firm_type(new_fw.type);
973 printk(KERN_CONT "(%x), id %016llx, ", new_fw.type,
974 (unsigned long long)new_fw.std_req);
975 if (!int_freq)
976 printk(KERN_CONT "scode_tbl ");
977 else
978 printk(KERN_CONT "int_freq %d, ", new_fw.int_freq);
979 printk(KERN_CONT "scode_nr %d\n", new_fw.scode_nr);
980 }
981
982
983 if (priv->cur_fw.type & BASE) {
984 dprintk(1, "BASE firmware not changed.\n");
985 goto skip_base;
986 }
987
988
989 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
990
991
992 rc = xc4000_tuner_reset(fe);
993 if (rc < 0)
994 goto fail;
995
996
997 std0 = 0;
998 rc = load_firmware(fe, BASE, &std0);
999 if (rc < 0) {
1000 printk(KERN_ERR "Error %d while loading base firmware\n", rc);
1001 goto fail;
1002 }
1003
1004
1005 dprintk(1, "Load init1 firmware, if exists\n");
1006
1007 rc = load_firmware(fe, BASE | INIT1, &std0);
1008 if (rc == -ENOENT)
1009 rc = load_firmware(fe, BASE | INIT1, &std0);
1010 if (rc < 0 && rc != -ENOENT) {
1011 tuner_err("Error %d while loading init1 firmware\n",
1012 rc);
1013 goto fail;
1014 }
1015
1016skip_base:
1017
1018
1019
1020
1021 if (priv->cur_fw.type == (BASE | new_fw.type) &&
1022 priv->cur_fw.std_req == std) {
1023 dprintk(1, "Std-specific firmware already loaded.\n");
1024 goto skip_std_specific;
1025 }
1026
1027
1028 priv->cur_fw.scode_table = 0;
1029
1030
1031 rc = load_firmware(fe, new_fw.type, &new_fw.id);
1032
1033 if (rc < 0)
1034 goto fail;
1035
1036skip_std_specific:
1037 if (priv->cur_fw.scode_table == new_fw.scode_table &&
1038 priv->cur_fw.scode_nr == new_fw.scode_nr) {
1039 dprintk(1, "SCODE firmware already loaded.\n");
1040 goto check_device;
1041 }
1042
1043
1044 rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
1045 new_fw.int_freq, new_fw.scode_nr);
1046 if (rc != 0)
1047 dprintk(1, "load scode failed %d\n", rc);
1048
1049check_device:
1050 rc = xc4000_readreg(priv, XREG_PRODUCT_ID, &hwmodel);
1051
1052 if (xc_get_version(priv, &hw_major, &hw_minor, &fw_major,
1053 &fw_minor) != 0) {
1054 printk(KERN_ERR "Unable to read tuner registers.\n");
1055 goto fail;
1056 }
1057
1058 dprintk(1, "Device is Xceive %d version %d.%d, "
1059 "firmware version %d.%d\n",
1060 hwmodel, hw_major, hw_minor, fw_major, fw_minor);
1061
1062
1063 if (priv->firm_version != ((fw_major << 8) | fw_minor)) {
1064 printk(KERN_WARNING
1065 "Incorrect readback of firmware version %d.%d.\n",
1066 fw_major, fw_minor);
1067 goto fail;
1068 }
1069
1070
1071 if (priv->hwmodel == 0 &&
1072 (hwmodel == XC_PRODUCT_ID_XC4000 ||
1073 hwmodel == XC_PRODUCT_ID_XC4100)) {
1074 priv->hwmodel = hwmodel;
1075 priv->hwvers = (hw_major << 8) | hw_minor;
1076 } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
1077 priv->hwvers != ((hw_major << 8) | hw_minor)) {
1078 printk(KERN_WARNING
1079 "Read invalid device hardware information - tuner "
1080 "hung?\n");
1081 goto fail;
1082 }
1083
1084 priv->cur_fw = new_fw;
1085
1086
1087
1088
1089
1090
1091
1092 priv->cur_fw.type |= BASE;
1093
1094 return 0;
1095
1096fail:
1097 memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
1098 if (!is_retry) {
1099 msleep(50);
1100 is_retry = 1;
1101 dprintk(1, "Retrying firmware load\n");
1102 goto retry;
1103 }
1104
1105 if (rc == -ENOENT)
1106 rc = -EINVAL;
1107 return rc;
1108}
1109
1110static void xc_debug_dump(struct xc4000_priv *priv)
1111{
1112 u16 adc_envelope;
1113 u32 freq_error_hz = 0;
1114 u16 lock_status;
1115 u32 hsync_freq_hz = 0;
1116 u16 frame_lines;
1117 u16 quality;
1118 u16 signal = 0;
1119 u16 noise = 0;
1120 u8 hw_majorversion = 0, hw_minorversion = 0;
1121 u8 fw_majorversion = 0, fw_minorversion = 0;
1122
1123 xc_get_adc_envelope(priv, &adc_envelope);
1124 dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
1125
1126 xc_get_frequency_error(priv, &freq_error_hz);
1127 dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
1128
1129 xc_get_lock_status(priv, &lock_status);
1130 dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
1131 lock_status);
1132
1133 xc_get_version(priv, &hw_majorversion, &hw_minorversion,
1134 &fw_majorversion, &fw_minorversion);
1135 dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
1136 hw_majorversion, hw_minorversion,
1137 fw_majorversion, fw_minorversion);
1138
1139 if (priv->video_standard < XC4000_DTV6) {
1140 xc_get_hsync_freq(priv, &hsync_freq_hz);
1141 dprintk(1, "*** Horizontal sync frequency = %d Hz\n",
1142 hsync_freq_hz);
1143
1144 xc_get_frame_lines(priv, &frame_lines);
1145 dprintk(1, "*** Frame lines = %d\n", frame_lines);
1146 }
1147
1148 xc_get_quality(priv, &quality);
1149 dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
1150
1151 xc_get_signal_level(priv, &signal);
1152 dprintk(1, "*** Signal level = -%ddB (%d)\n", signal >> 8, signal);
1153
1154 xc_get_noise_level(priv, &noise);
1155 dprintk(1, "*** Noise level = %ddB (%d)\n", noise >> 8, noise);
1156}
1157
1158static int xc4000_set_params(struct dvb_frontend *fe)
1159{
1160 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1161 u32 delsys = c->delivery_system;
1162 u32 bw = c->bandwidth_hz;
1163 struct xc4000_priv *priv = fe->tuner_priv;
1164 unsigned int type;
1165 int ret = -EREMOTEIO;
1166
1167 dprintk(1, "%s() frequency=%d (Hz)\n", __func__, c->frequency);
1168
1169 mutex_lock(&priv->lock);
1170
1171 switch (delsys) {
1172 case SYS_ATSC:
1173 dprintk(1, "%s() VSB modulation\n", __func__);
1174 priv->rf_mode = XC_RF_MODE_AIR;
1175 priv->freq_offset = 1750000;
1176 priv->video_standard = XC4000_DTV6;
1177 type = DTV6;
1178 break;
1179 case SYS_DVBC_ANNEX_B:
1180 dprintk(1, "%s() QAM modulation\n", __func__);
1181 priv->rf_mode = XC_RF_MODE_CABLE;
1182 priv->freq_offset = 1750000;
1183 priv->video_standard = XC4000_DTV6;
1184 type = DTV6;
1185 break;
1186 case SYS_DVBT:
1187 case SYS_DVBT2:
1188 dprintk(1, "%s() OFDM\n", __func__);
1189 if (bw == 0) {
1190 if (c->frequency < 400000000) {
1191 priv->freq_offset = 2250000;
1192 } else {
1193 priv->freq_offset = 2750000;
1194 }
1195 priv->video_standard = XC4000_DTV7_8;
1196 type = DTV78;
1197 } else if (bw <= 6000000) {
1198 priv->video_standard = XC4000_DTV6;
1199 priv->freq_offset = 1750000;
1200 type = DTV6;
1201 } else if (bw <= 7000000) {
1202 priv->video_standard = XC4000_DTV7;
1203 priv->freq_offset = 2250000;
1204 type = DTV7;
1205 } else {
1206 priv->video_standard = XC4000_DTV8;
1207 priv->freq_offset = 2750000;
1208 type = DTV8;
1209 }
1210 priv->rf_mode = XC_RF_MODE_AIR;
1211 break;
1212 default:
1213 printk(KERN_ERR "xc4000 delivery system not supported!\n");
1214 ret = -EINVAL;
1215 goto fail;
1216 }
1217
1218 priv->freq_hz = c->frequency - priv->freq_offset;
1219
1220 dprintk(1, "%s() frequency=%d (compensated)\n",
1221 __func__, priv->freq_hz);
1222
1223
1224 if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1225 goto fail;
1226
1227 priv->bandwidth = c->bandwidth_hz;
1228
1229 ret = xc_set_signal_source(priv, priv->rf_mode);
1230 if (ret != 0) {
1231 printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1232 priv->rf_mode);
1233 goto fail;
1234 } else {
1235 u16 video_mode, audio_mode;
1236 video_mode = xc4000_standard[priv->video_standard].video_mode;
1237 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1238 if (type == DTV6 && priv->firm_version != 0x0102)
1239 video_mode |= 0x0001;
1240 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1241 if (ret != 0) {
1242 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1243
1244
1245 }
1246 }
1247
1248 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1249 ret = 0;
1250 if (priv->dvb_amplitude != 0) {
1251 if (xc_write_reg(priv, XREG_AMPLITUDE,
1252 (priv->firm_version != 0x0102 ||
1253 priv->dvb_amplitude != 134 ?
1254 priv->dvb_amplitude : 132)) != 0)
1255 ret = -EREMOTEIO;
1256 }
1257 if (priv->set_smoothedcvbs != 0) {
1258 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1259 ret = -EREMOTEIO;
1260 }
1261 if (ret != 0) {
1262 printk(KERN_ERR "xc4000: setting registers failed\n");
1263
1264 }
1265
1266 xc_tune_channel(priv, priv->freq_hz);
1267
1268 ret = 0;
1269
1270fail:
1271 mutex_unlock(&priv->lock);
1272
1273 return ret;
1274}
1275
1276static int xc4000_set_analog_params(struct dvb_frontend *fe,
1277 struct analog_parameters *params)
1278{
1279 struct xc4000_priv *priv = fe->tuner_priv;
1280 unsigned int type = 0;
1281 int ret = -EREMOTEIO;
1282
1283 if (params->mode == V4L2_TUNER_RADIO) {
1284 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1285 __func__, params->frequency);
1286
1287 mutex_lock(&priv->lock);
1288
1289 params->std = 0;
1290 priv->freq_hz = params->frequency * 125L / 2;
1291
1292 if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1293 priv->video_standard = XC4000_FM_Radio_INPUT1;
1294 type = FM | INPUT1;
1295 } else {
1296 priv->video_standard = XC4000_FM_Radio_INPUT2;
1297 type = FM | INPUT2;
1298 }
1299
1300 goto tune_channel;
1301 }
1302
1303 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1304 __func__, params->frequency);
1305
1306 mutex_lock(&priv->lock);
1307
1308
1309 priv->freq_hz = params->frequency * 62500;
1310
1311 params->std &= V4L2_STD_ALL;
1312
1313 if (!params->std)
1314 params->std = V4L2_STD_PAL_BG;
1315
1316 if (audio_std & XC4000_AUDIO_STD_MONO)
1317 type = MONO;
1318
1319 if (params->std & V4L2_STD_MN) {
1320 params->std = V4L2_STD_MN;
1321 if (audio_std & XC4000_AUDIO_STD_MONO) {
1322 priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1323 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1324 params->std |= V4L2_STD_A2;
1325 priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1326 } else {
1327 params->std |= V4L2_STD_BTSC;
1328 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1329 }
1330 goto tune_channel;
1331 }
1332
1333 if (params->std & V4L2_STD_PAL_BG) {
1334 params->std = V4L2_STD_PAL_BG;
1335 if (audio_std & XC4000_AUDIO_STD_MONO) {
1336 priv->video_standard = XC4000_BG_PAL_MONO;
1337 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1338 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1339 params->std |= V4L2_STD_NICAM_A;
1340 priv->video_standard = XC4000_BG_PAL_NICAM;
1341 } else {
1342 params->std |= V4L2_STD_NICAM_B;
1343 priv->video_standard = XC4000_BG_PAL_NICAM;
1344 }
1345 } else {
1346 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1347 params->std |= V4L2_STD_A2_A;
1348 priv->video_standard = XC4000_BG_PAL_A2;
1349 } else {
1350 params->std |= V4L2_STD_A2_B;
1351 priv->video_standard = XC4000_BG_PAL_A2;
1352 }
1353 }
1354 goto tune_channel;
1355 }
1356
1357 if (params->std & V4L2_STD_PAL_I) {
1358
1359 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1360 if (audio_std & XC4000_AUDIO_STD_MONO)
1361 priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1362 else
1363 priv->video_standard = XC4000_I_PAL_NICAM;
1364 goto tune_channel;
1365 }
1366
1367 if (params->std & V4L2_STD_PAL_DK) {
1368 params->std = V4L2_STD_PAL_DK;
1369 if (audio_std & XC4000_AUDIO_STD_MONO) {
1370 priv->video_standard = XC4000_DK_PAL_MONO;
1371 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1372 params->std |= V4L2_STD_A2;
1373 priv->video_standard = XC4000_DK_PAL_A2;
1374 } else {
1375 params->std |= V4L2_STD_NICAM;
1376 priv->video_standard = XC4000_DK_PAL_NICAM;
1377 }
1378 goto tune_channel;
1379 }
1380
1381 if (params->std & V4L2_STD_SECAM_DK) {
1382
1383 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1384 if (audio_std & XC4000_AUDIO_STD_L) {
1385 type = 0;
1386 priv->video_standard = XC4000_DK_SECAM_NICAM;
1387 } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1388 priv->video_standard = XC4000_DK_SECAM_A2MONO;
1389 } else if (audio_std & XC4000_AUDIO_STD_K3) {
1390 params->std |= V4L2_STD_SECAM_K3;
1391 priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1392 } else {
1393 priv->video_standard = XC4000_DK_SECAM_A2DK1;
1394 }
1395 goto tune_channel;
1396 }
1397
1398 if (params->std & V4L2_STD_SECAM_L) {
1399
1400 type = 0;
1401 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1402 priv->video_standard = XC4000_L_SECAM_NICAM;
1403 goto tune_channel;
1404 }
1405
1406 if (params->std & V4L2_STD_SECAM_LC) {
1407
1408 type = 0;
1409 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1410 priv->video_standard = XC4000_LC_SECAM_NICAM;
1411 goto tune_channel;
1412 }
1413
1414tune_channel:
1415
1416 priv->rf_mode = XC_RF_MODE_CABLE;
1417
1418 if (check_firmware(fe, type, params->std,
1419 xc4000_standard[priv->video_standard].int_freq) != 0)
1420 goto fail;
1421
1422 ret = xc_set_signal_source(priv, priv->rf_mode);
1423 if (ret != 0) {
1424 printk(KERN_ERR
1425 "xc4000: xc_set_signal_source(%d) failed\n",
1426 priv->rf_mode);
1427 goto fail;
1428 } else {
1429 u16 video_mode, audio_mode;
1430 video_mode = xc4000_standard[priv->video_standard].video_mode;
1431 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1432 if (priv->video_standard < XC4000_BG_PAL_A2) {
1433 if (type & NOGD)
1434 video_mode &= 0xFF7F;
1435 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1436 if (priv->firm_version == 0x0102)
1437 video_mode &= 0xFEFF;
1438 if (audio_std & XC4000_AUDIO_STD_B)
1439 video_mode |= 0x0080;
1440 }
1441 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1442 if (ret != 0) {
1443 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1444 goto fail;
1445 }
1446 }
1447
1448 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1449 ret = 0;
1450 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1451 ret = -EREMOTEIO;
1452 if (priv->set_smoothedcvbs != 0) {
1453 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1454 ret = -EREMOTEIO;
1455 }
1456 if (ret != 0) {
1457 printk(KERN_ERR "xc4000: setting registers failed\n");
1458 goto fail;
1459 }
1460
1461 xc_tune_channel(priv, priv->freq_hz);
1462
1463 ret = 0;
1464
1465fail:
1466 mutex_unlock(&priv->lock);
1467
1468 return ret;
1469}
1470
1471static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength)
1472{
1473 struct xc4000_priv *priv = fe->tuner_priv;
1474 u16 value = 0;
1475 int rc;
1476
1477 mutex_lock(&priv->lock);
1478 rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1479 mutex_unlock(&priv->lock);
1480
1481 if (rc < 0)
1482 goto ret;
1483
1484
1485
1486
1487 tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value);
1488
1489
1490 if ((priv->video_standard == XC4000_DTV6) ||
1491 (priv->video_standard == XC4000_DTV7) ||
1492 (priv->video_standard == XC4000_DTV7_8) ||
1493 (priv->video_standard == XC4000_DTV8))
1494 goto digital;
1495
1496
1497
1498
1499
1500
1501 mutex_lock(&priv->lock);
1502 rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1503 mutex_unlock(&priv->lock);
1504
1505 tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value);
1506
1507
1508 if (value >= 0x2000) {
1509 value = 0;
1510 } else {
1511 value = (~value << 3) & 0xffff;
1512 }
1513
1514 goto ret;
1515
1516
1517
1518
1519digital:
1520
1521 if (value <= 0x3200) {
1522 value = 0xffff;
1523
1524 } else if (value >= 0x713A) {
1525 value = 0;
1526 } else {
1527 value = ~(value - 0x3200) << 2;
1528 }
1529
1530ret:
1531 *strength = value;
1532
1533 return rc;
1534}
1535
1536static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1537{
1538 struct xc4000_priv *priv = fe->tuner_priv;
1539
1540 *freq = priv->freq_hz + priv->freq_offset;
1541
1542 if (debug) {
1543 mutex_lock(&priv->lock);
1544 if ((priv->cur_fw.type
1545 & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1546 u16 snr = 0;
1547 if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1548 mutex_unlock(&priv->lock);
1549 dprintk(1, "%s() freq = %u, SNR = %d\n",
1550 __func__, *freq, snr);
1551 return 0;
1552 }
1553 }
1554 mutex_unlock(&priv->lock);
1555 }
1556
1557 dprintk(1, "%s()\n", __func__);
1558
1559 return 0;
1560}
1561
1562static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1563{
1564 struct xc4000_priv *priv = fe->tuner_priv;
1565 dprintk(1, "%s()\n", __func__);
1566
1567 *bw = priv->bandwidth;
1568 return 0;
1569}
1570
1571static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1572{
1573 struct xc4000_priv *priv = fe->tuner_priv;
1574 u16 lock_status = 0;
1575
1576 mutex_lock(&priv->lock);
1577
1578 if (priv->cur_fw.type & BASE)
1579 xc_get_lock_status(priv, &lock_status);
1580
1581 *status = (lock_status == 1 ?
1582 TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1583 if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1584 *status &= (~TUNER_STATUS_STEREO);
1585
1586 mutex_unlock(&priv->lock);
1587
1588 dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1589
1590 return 0;
1591}
1592
1593static int xc4000_sleep(struct dvb_frontend *fe)
1594{
1595 struct xc4000_priv *priv = fe->tuner_priv;
1596 int ret = 0;
1597
1598 dprintk(1, "%s()\n", __func__);
1599
1600 mutex_lock(&priv->lock);
1601
1602
1603 if ((no_poweroff == 2 ||
1604 (no_poweroff == 0 && priv->default_pm != 0)) &&
1605 (priv->cur_fw.type & BASE) != 0) {
1606
1607 priv->cur_fw.type = XC_POWERED_DOWN;
1608
1609 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1610 printk(KERN_ERR
1611 "xc4000: %s() unable to shutdown tuner\n",
1612 __func__);
1613 ret = -EREMOTEIO;
1614 }
1615 msleep(20);
1616 }
1617
1618 mutex_unlock(&priv->lock);
1619
1620 return ret;
1621}
1622
1623static int xc4000_init(struct dvb_frontend *fe)
1624{
1625 dprintk(1, "%s()\n", __func__);
1626
1627 return 0;
1628}
1629
1630static int xc4000_release(struct dvb_frontend *fe)
1631{
1632 struct xc4000_priv *priv = fe->tuner_priv;
1633
1634 dprintk(1, "%s()\n", __func__);
1635
1636 mutex_lock(&xc4000_list_mutex);
1637
1638 if (priv)
1639 hybrid_tuner_release_state(priv);
1640
1641 mutex_unlock(&xc4000_list_mutex);
1642
1643 fe->tuner_priv = NULL;
1644
1645 return 0;
1646}
1647
1648static const struct dvb_tuner_ops xc4000_tuner_ops = {
1649 .info = {
1650 .name = "Xceive XC4000",
1651 .frequency_min = 1000000,
1652 .frequency_max = 1023000000,
1653 .frequency_step = 50000,
1654 },
1655
1656 .release = xc4000_release,
1657 .init = xc4000_init,
1658 .sleep = xc4000_sleep,
1659
1660 .set_params = xc4000_set_params,
1661 .set_analog_params = xc4000_set_analog_params,
1662 .get_frequency = xc4000_get_frequency,
1663 .get_rf_strength = xc4000_get_signal,
1664 .get_bandwidth = xc4000_get_bandwidth,
1665 .get_status = xc4000_get_status
1666};
1667
1668struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1669 struct i2c_adapter *i2c,
1670 struct xc4000_config *cfg)
1671{
1672 struct xc4000_priv *priv = NULL;
1673 int instance;
1674 u16 id = 0;
1675
1676 dprintk(1, "%s(%d-%04x)\n", __func__,
1677 i2c ? i2c_adapter_id(i2c) : -1,
1678 cfg ? cfg->i2c_address : -1);
1679
1680 mutex_lock(&xc4000_list_mutex);
1681
1682 instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1683 hybrid_tuner_instance_list,
1684 i2c, cfg->i2c_address, "xc4000");
1685 switch (instance) {
1686 case 0:
1687 goto fail;
1688 case 1:
1689
1690 priv->bandwidth = 6000000;
1691
1692 priv->if_khz = 4560;
1693 priv->default_pm = 0;
1694 priv->dvb_amplitude = 134;
1695 priv->set_smoothedcvbs = 1;
1696 mutex_init(&priv->lock);
1697 fe->tuner_priv = priv;
1698 break;
1699 default:
1700
1701 fe->tuner_priv = priv;
1702 break;
1703 }
1704
1705 if (cfg->if_khz != 0) {
1706
1707 priv->if_khz = cfg->if_khz;
1708 priv->default_pm = cfg->default_pm;
1709 priv->dvb_amplitude = cfg->dvb_amplitude;
1710 priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1711 }
1712
1713
1714
1715
1716
1717 if (instance == 1) {
1718 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1719 goto fail;
1720 } else {
1721 id = ((priv->cur_fw.type & BASE) != 0 ?
1722 priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1723 }
1724
1725 switch (id) {
1726 case XC_PRODUCT_ID_XC4000:
1727 case XC_PRODUCT_ID_XC4100:
1728 printk(KERN_INFO
1729 "xc4000: Successfully identified at address 0x%02x\n",
1730 cfg->i2c_address);
1731 printk(KERN_INFO
1732 "xc4000: Firmware has been loaded previously\n");
1733 break;
1734 case XC_PRODUCT_ID_FW_NOT_LOADED:
1735 printk(KERN_INFO
1736 "xc4000: Successfully identified at address 0x%02x\n",
1737 cfg->i2c_address);
1738 printk(KERN_INFO
1739 "xc4000: Firmware has not been loaded previously\n");
1740 break;
1741 default:
1742 printk(KERN_ERR
1743 "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1744 cfg->i2c_address, id);
1745 goto fail;
1746 }
1747
1748 mutex_unlock(&xc4000_list_mutex);
1749
1750 memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1751 sizeof(struct dvb_tuner_ops));
1752
1753 if (instance == 1) {
1754 int ret;
1755 mutex_lock(&priv->lock);
1756 ret = xc4000_fwupload(fe);
1757 mutex_unlock(&priv->lock);
1758 if (ret != 0)
1759 goto fail2;
1760 }
1761
1762 return fe;
1763fail:
1764 mutex_unlock(&xc4000_list_mutex);
1765fail2:
1766 xc4000_release(fe);
1767 return NULL;
1768}
1769EXPORT_SYMBOL(xc4000_attach);
1770
1771MODULE_AUTHOR("Steven Toth, Davide Ferri");
1772MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1773MODULE_LICENSE("GPL");
1774MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE_NEW);
1775MODULE_FIRMWARE(XC4000_DEFAULT_FIRMWARE);
1776
