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