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