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