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