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