?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / drivers / media / tuners / xc4000.c
blobe71decbfd0afdf495c28a407930eb6768233d06c
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, freq_offset;
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_offset = 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_offset = 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_offset = 2250000;
1177 } else {
1178 priv->freq_offset = 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_offset = 1750000;
1185 type = DTV6;
1186 } else if (bw <= 7000000) {
1187 priv->video_standard = XC4000_DTV7;
1188 priv->freq_offset = 2250000;
1189 type = DTV7;
1190 } else {
1191 priv->video_standard = XC4000_DTV8;
1192 priv->freq_offset = 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 priv->freq_hz = c->frequency - priv->freq_offset;
1204
1205 dprintk(1, "%s() frequency=%d (compensated)\n",
1206 __func__, priv->freq_hz);
1207
1208 /* Make sure the correct firmware type is loaded */
1209 if (check_firmware(fe, type, 0, priv->if_khz) != 0)
1210 goto fail;
1211
1212 priv->bandwidth = c->bandwidth_hz;
1213
1214 ret = xc_set_signal_source(priv, priv->rf_mode);
1215 if (ret != 0) {
1216 printk(KERN_ERR "xc4000: xc_set_signal_source(%d) failed\n",
1217 priv->rf_mode);
1218 goto fail;
1219 } else {
1220 u16 video_mode, audio_mode;
1221 video_mode = xc4000_standard[priv->video_standard].video_mode;
1222 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1223 if (type == DTV6 && priv->firm_version != 0x0102)
1224 video_mode |= 0x0001;
1225 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1226 if (ret != 0) {
1227 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1228 /* DJH - do not return when it fails... */
1229 /* goto fail; */
1230 }
1231 }
1232
1233 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1234 ret = 0;
1235 if (priv->dvb_amplitude != 0) {
1236 if (xc_write_reg(priv, XREG_AMPLITUDE,
1237 (priv->firm_version != 0x0102 ||
1238 priv->dvb_amplitude != 134 ?
1239 priv->dvb_amplitude : 132)) != 0)
1240 ret = -EREMOTEIO;
1241 }
1242 if (priv->set_smoothedcvbs != 0) {
1243 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1244 ret = -EREMOTEIO;
1245 }
1246 if (ret != 0) {
1247 printk(KERN_ERR "xc4000: setting registers failed\n");
1248 /* goto fail; */
1249 }
1250
1251 xc_tune_channel(priv, priv->freq_hz);
1252
1253 ret = 0;
1254
1255 fail:
1256 mutex_unlock(&priv->lock);
1257
1258 return ret;
1259 }
1260
1261 static int xc4000_set_analog_params(struct dvb_frontend *fe,
1262 struct analog_parameters *params)
1263 {
1264 struct xc4000_priv *priv = fe->tuner_priv;
1265 unsigned int type = 0;
1266 int ret = -EREMOTEIO;
1267
1268 if (params->mode == V4L2_TUNER_RADIO) {
1269 dprintk(1, "%s() frequency=%d (in units of 62.5Hz)\n",
1270 __func__, params->frequency);
1271
1272 mutex_lock(&priv->lock);
1273
1274 params->std = 0;
1275 priv->freq_hz = params->frequency * 125L / 2;
1276
1277 if (audio_std & XC4000_AUDIO_STD_INPUT1) {
1278 priv->video_standard = XC4000_FM_Radio_INPUT1;
1279 type = FM | INPUT1;
1280 } else {
1281 priv->video_standard = XC4000_FM_Radio_INPUT2;
1282 type = FM | INPUT2;
1283 }
1284
1285 goto tune_channel;
1286 }
1287
1288 dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
1289 __func__, params->frequency);
1290
1291 mutex_lock(&priv->lock);
1292
1293 /* params->frequency is in units of 62.5khz */
1294 priv->freq_hz = params->frequency * 62500;
1295
1296 params->std &= V4L2_STD_ALL;
1297 /* if std is not defined, choose one */
1298 if (!params->std)
1299 params->std = V4L2_STD_PAL_BG;
1300
1301 if (audio_std & XC4000_AUDIO_STD_MONO)
1302 type = MONO;
1303
1304 if (params->std & V4L2_STD_MN) {
1305 params->std = V4L2_STD_MN;
1306 if (audio_std & XC4000_AUDIO_STD_MONO) {
1307 priv->video_standard = XC4000_MN_NTSC_PAL_Mono;
1308 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1309 params->std |= V4L2_STD_A2;
1310 priv->video_standard = XC4000_MN_NTSC_PAL_A2;
1311 } else {
1312 params->std |= V4L2_STD_BTSC;
1313 priv->video_standard = XC4000_MN_NTSC_PAL_BTSC;
1314 }
1315 goto tune_channel;
1316 }
1317
1318 if (params->std & V4L2_STD_PAL_BG) {
1319 params->std = V4L2_STD_PAL_BG;
1320 if (audio_std & XC4000_AUDIO_STD_MONO) {
1321 priv->video_standard = XC4000_BG_PAL_MONO;
1322 } else if (!(audio_std & XC4000_AUDIO_STD_A2)) {
1323 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1324 params->std |= V4L2_STD_NICAM_A;
1325 priv->video_standard = XC4000_BG_PAL_NICAM;
1326 } else {
1327 params->std |= V4L2_STD_NICAM_B;
1328 priv->video_standard = XC4000_BG_PAL_NICAM;
1329 }
1330 } else {
1331 if (!(audio_std & XC4000_AUDIO_STD_B)) {
1332 params->std |= V4L2_STD_A2_A;
1333 priv->video_standard = XC4000_BG_PAL_A2;
1334 } else {
1335 params->std |= V4L2_STD_A2_B;
1336 priv->video_standard = XC4000_BG_PAL_A2;
1337 }
1338 }
1339 goto tune_channel;
1340 }
1341
1342 if (params->std & V4L2_STD_PAL_I) {
1343 /* default to NICAM audio standard */
1344 params->std = V4L2_STD_PAL_I | V4L2_STD_NICAM;
1345 if (audio_std & XC4000_AUDIO_STD_MONO)
1346 priv->video_standard = XC4000_I_PAL_NICAM_MONO;
1347 else
1348 priv->video_standard = XC4000_I_PAL_NICAM;
1349 goto tune_channel;
1350 }
1351
1352 if (params->std & V4L2_STD_PAL_DK) {
1353 params->std = V4L2_STD_PAL_DK;
1354 if (audio_std & XC4000_AUDIO_STD_MONO) {
1355 priv->video_standard = XC4000_DK_PAL_MONO;
1356 } else if (audio_std & XC4000_AUDIO_STD_A2) {
1357 params->std |= V4L2_STD_A2;
1358 priv->video_standard = XC4000_DK_PAL_A2;
1359 } else {
1360 params->std |= V4L2_STD_NICAM;
1361 priv->video_standard = XC4000_DK_PAL_NICAM;
1362 }
1363 goto tune_channel;
1364 }
1365
1366 if (params->std & V4L2_STD_SECAM_DK) {
1367 /* default to A2 audio standard */
1368 params->std = V4L2_STD_SECAM_DK | V4L2_STD_A2;
1369 if (audio_std & XC4000_AUDIO_STD_L) {
1370 type = 0;
1371 priv->video_standard = XC4000_DK_SECAM_NICAM;
1372 } else if (audio_std & XC4000_AUDIO_STD_MONO) {
1373 priv->video_standard = XC4000_DK_SECAM_A2MONO;
1374 } else if (audio_std & XC4000_AUDIO_STD_K3) {
1375 params->std |= V4L2_STD_SECAM_K3;
1376 priv->video_standard = XC4000_DK_SECAM_A2LDK3;
1377 } else {
1378 priv->video_standard = XC4000_DK_SECAM_A2DK1;
1379 }
1380 goto tune_channel;
1381 }
1382
1383 if (params->std & V4L2_STD_SECAM_L) {
1384 /* default to NICAM audio standard */
1385 type = 0;
1386 params->std = V4L2_STD_SECAM_L | V4L2_STD_NICAM;
1387 priv->video_standard = XC4000_L_SECAM_NICAM;
1388 goto tune_channel;
1389 }
1390
1391 if (params->std & V4L2_STD_SECAM_LC) {
1392 /* default to NICAM audio standard */
1393 type = 0;
1394 params->std = V4L2_STD_SECAM_LC | V4L2_STD_NICAM;
1395 priv->video_standard = XC4000_LC_SECAM_NICAM;
1396 goto tune_channel;
1397 }
1398
1399 tune_channel:
1400 /* FIXME: it could be air. */
1401 priv->rf_mode = XC_RF_MODE_CABLE;
1402
1403 if (check_firmware(fe, type, params->std,
1404 xc4000_standard[priv->video_standard].int_freq) != 0)
1405 goto fail;
1406
1407 ret = xc_set_signal_source(priv, priv->rf_mode);
1408 if (ret != 0) {
1409 printk(KERN_ERR
1410 "xc4000: xc_set_signal_source(%d) failed\n",
1411 priv->rf_mode);
1412 goto fail;
1413 } else {
1414 u16 video_mode, audio_mode;
1415 video_mode = xc4000_standard[priv->video_standard].video_mode;
1416 audio_mode = xc4000_standard[priv->video_standard].audio_mode;
1417 if (priv->video_standard < XC4000_BG_PAL_A2) {
1418 if (type & NOGD)
1419 video_mode &= 0xFF7F;
1420 } else if (priv->video_standard < XC4000_I_PAL_NICAM) {
1421 if (priv->firm_version == 0x0102)
1422 video_mode &= 0xFEFF;
1423 if (audio_std & XC4000_AUDIO_STD_B)
1424 video_mode |= 0x0080;
1425 }
1426 ret = xc_set_tv_standard(priv, video_mode, audio_mode);
1427 if (ret != 0) {
1428 printk(KERN_ERR "xc4000: xc_set_tv_standard failed\n");
1429 goto fail;
1430 }
1431 }
1432
1433 if (xc_write_reg(priv, XREG_D_CODE, 0) == 0)
1434 ret = 0;
1435 if (xc_write_reg(priv, XREG_AMPLITUDE, 1) != 0)
1436 ret = -EREMOTEIO;
1437 if (priv->set_smoothedcvbs != 0) {
1438 if (xc_write_reg(priv, XREG_SMOOTHEDCVBS, 1) != 0)
1439 ret = -EREMOTEIO;
1440 }
1441 if (ret != 0) {
1442 printk(KERN_ERR "xc4000: setting registers failed\n");
1443 goto fail;
1444 }
1445
1446 xc_tune_channel(priv, priv->freq_hz);
1447
1448 ret = 0;
1449
1450 fail:
1451 mutex_unlock(&priv->lock);
1452
1453 return ret;
1454 }
1455
1456 static int xc4000_get_signal(struct dvb_frontend *fe, u16 *strength)
1457 {
1458 struct xc4000_priv *priv = fe->tuner_priv;
1459 u16 value = 0;
1460 int rc;
1461
1462 mutex_lock(&priv->lock);
1463 rc = xc4000_readreg(priv, XREG_SIGNAL_LEVEL, &value);
1464 mutex_unlock(&priv->lock);
1465
1466 if (rc < 0)
1467 goto ret;
1468
1469 /* Informations from real testing of DVB-T and radio part,
1470 coeficient for one dB is 0xff.
1471 */
1472 tuner_dbg("Signal strength: -%ddB (%05d)\n", value >> 8, value);
1473
1474 /* all known digital modes */
1475 if ((priv->video_standard == XC4000_DTV6) ||
1476 (priv->video_standard == XC4000_DTV7) ||
1477 (priv->video_standard == XC4000_DTV7_8) ||
1478 (priv->video_standard == XC4000_DTV8))
1479 goto digital;
1480
1481 /* Analog mode has NOISE LEVEL important, signal
1482 depends only on gain of antenna and amplifiers,
1483 but it doesn't tell anything about real quality
1484 of reception.
1485 */
1486 mutex_lock(&priv->lock);
1487 rc = xc4000_readreg(priv, XREG_NOISE_LEVEL, &value);
1488 mutex_unlock(&priv->lock);
1489
1490 tuner_dbg("Noise level: %ddB (%05d)\n", value >> 8, value);
1491
1492 /* highest noise level: 32dB */
1493 if (value >= 0x2000) {
1494 value = 0;
1495 } else {
1496 value = ~value << 3;
1497 }
1498
1499 goto ret;
1500
1501 /* Digital mode has SIGNAL LEVEL important and real
1502 noise level is stored in demodulator registers.
1503 */
1504 digital:
1505 /* best signal: -50dB */
1506 if (value <= 0x3200) {
1507 value = 0xffff;
1508 /* minimum: -114dB - should be 0x7200 but real zero is 0x713A */
1509 } else if (value >= 0x713A) {
1510 value = 0;
1511 } else {
1512 value = ~(value - 0x3200) << 2;
1513 }
1514
1515 ret:
1516 *strength = value;
1517
1518 return rc;
1519 }
1520
1521 static int xc4000_get_frequency(struct dvb_frontend *fe, u32 *freq)
1522 {
1523 struct xc4000_priv *priv = fe->tuner_priv;
1524
1525 *freq = priv->freq_hz + priv->freq_offset;
1526
1527 if (debug) {
1528 mutex_lock(&priv->lock);
1529 if ((priv->cur_fw.type
1530 & (BASE | FM | DTV6 | DTV7 | DTV78 | DTV8)) == BASE) {
1531 u16 snr = 0;
1532 if (xc4000_readreg(priv, XREG_SNR, &snr) == 0) {
1533 mutex_unlock(&priv->lock);
1534 dprintk(1, "%s() freq = %u, SNR = %d\n",
1535 __func__, *freq, snr);
1536 return 0;
1537 }
1538 }
1539 mutex_unlock(&priv->lock);
1540 }
1541
1542 dprintk(1, "%s()\n", __func__);
1543
1544 return 0;
1545 }
1546
1547 static int xc4000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
1548 {
1549 struct xc4000_priv *priv = fe->tuner_priv;
1550 dprintk(1, "%s()\n", __func__);
1551
1552 *bw = priv->bandwidth;
1553 return 0;
1554 }
1555
1556 static int xc4000_get_status(struct dvb_frontend *fe, u32 *status)
1557 {
1558 struct xc4000_priv *priv = fe->tuner_priv;
1559 u16 lock_status = 0;
1560
1561 mutex_lock(&priv->lock);
1562
1563 if (priv->cur_fw.type & BASE)
1564 xc_get_lock_status(priv, &lock_status);
1565
1566 *status = (lock_status == 1 ?
1567 TUNER_STATUS_LOCKED | TUNER_STATUS_STEREO : 0);
1568 if (priv->cur_fw.type & (DTV6 | DTV7 | DTV78 | DTV8))
1569 *status &= (~TUNER_STATUS_STEREO);
1570
1571 mutex_unlock(&priv->lock);
1572
1573 dprintk(2, "%s() lock_status = %d\n", __func__, lock_status);
1574
1575 return 0;
1576 }
1577
1578 static int xc4000_sleep(struct dvb_frontend *fe)
1579 {
1580 struct xc4000_priv *priv = fe->tuner_priv;
1581 int ret = 0;
1582
1583 dprintk(1, "%s()\n", __func__);
1584
1585 mutex_lock(&priv->lock);
1586
1587 /* Avoid firmware reload on slow devices */
1588 if ((no_poweroff == 2 ||
1589 (no_poweroff == 0 && priv->default_pm != 0)) &&
1590 (priv->cur_fw.type & BASE) != 0) {
1591 /* force reset and firmware reload */
1592 priv->cur_fw.type = XC_POWERED_DOWN;
1593
1594 if (xc_write_reg(priv, XREG_POWER_DOWN, 0) != 0) {
1595 printk(KERN_ERR
1596 "xc4000: %s() unable to shutdown tuner\n",
1597 __func__);
1598 ret = -EREMOTEIO;
1599 }
1600 msleep(20);
1601 }
1602
1603 mutex_unlock(&priv->lock);
1604
1605 return ret;
1606 }
1607
1608 static int xc4000_init(struct dvb_frontend *fe)
1609 {
1610 dprintk(1, "%s()\n", __func__);
1611
1612 return 0;
1613 }
1614
1615 static int xc4000_release(struct dvb_frontend *fe)
1616 {
1617 struct xc4000_priv *priv = fe->tuner_priv;
1618
1619 dprintk(1, "%s()\n", __func__);
1620
1621 mutex_lock(&xc4000_list_mutex);
1622
1623 if (priv)
1624 hybrid_tuner_release_state(priv);
1625
1626 mutex_unlock(&xc4000_list_mutex);
1627
1628 fe->tuner_priv = NULL;
1629
1630 return 0;
1631 }
1632
1633 static const struct dvb_tuner_ops xc4000_tuner_ops = {
1634 .info = {
1635 .name = "Xceive XC4000",
1636 .frequency_min = 1000000,
1637 .frequency_max = 1023000000,
1638 .frequency_step = 50000,
1639 },
1640
1641 .release = xc4000_release,
1642 .init = xc4000_init,
1643 .sleep = xc4000_sleep,
1644
1645 .set_params = xc4000_set_params,
1646 .set_analog_params = xc4000_set_analog_params,
1647 .get_frequency = xc4000_get_frequency,
1648 .get_rf_strength = xc4000_get_signal,
1649 .get_bandwidth = xc4000_get_bandwidth,
1650 .get_status = xc4000_get_status
1651 };
1652
1653 struct dvb_frontend *xc4000_attach(struct dvb_frontend *fe,
1654 struct i2c_adapter *i2c,
1655 struct xc4000_config *cfg)
1656 {
1657 struct xc4000_priv *priv = NULL;
1658 int instance;
1659 u16 id = 0;
1660
1661 dprintk(1, "%s(%d-%04x)\n", __func__,
1662 i2c ? i2c_adapter_id(i2c) : -1,
1663 cfg ? cfg->i2c_address : -1);
1664
1665 mutex_lock(&xc4000_list_mutex);
1666
1667 instance = hybrid_tuner_request_state(struct xc4000_priv, priv,
1668 hybrid_tuner_instance_list,
1669 i2c, cfg->i2c_address, "xc4000");
1670 switch (instance) {
1671 case 0:
1672 goto fail;
1673 break;
1674 case 1:
1675 /* new tuner instance */
1676 priv->bandwidth = 6000000;
1677 /* set default configuration */
1678 priv->if_khz = 4560;
1679 priv->default_pm = 0;
1680 priv->dvb_amplitude = 134;
1681 priv->set_smoothedcvbs = 1;
1682 mutex_init(&priv->lock);
1683 fe->tuner_priv = priv;
1684 break;
1685 default:
1686 /* existing tuner instance */
1687 fe->tuner_priv = priv;
1688 break;
1689 }
1690
1691 if (cfg->if_khz != 0) {
1692 /* copy configuration if provided by the caller */
1693 priv->if_khz = cfg->if_khz;
1694 priv->default_pm = cfg->default_pm;
1695 priv->dvb_amplitude = cfg->dvb_amplitude;
1696 priv->set_smoothedcvbs = cfg->set_smoothedcvbs;
1697 }
1698
1699 /* Check if firmware has been loaded. It is possible that another
1700 instance of the driver has loaded the firmware.
1701 */
1702
1703 if (instance == 1) {
1704 if (xc4000_readreg(priv, XREG_PRODUCT_ID, &id) != 0)
1705 goto fail;
1706 } else {
1707 id = ((priv->cur_fw.type & BASE) != 0 ?
1708 priv->hwmodel : XC_PRODUCT_ID_FW_NOT_LOADED);
1709 }
1710
1711 switch (id) {
1712 case XC_PRODUCT_ID_XC4000:
1713 case XC_PRODUCT_ID_XC4100:
1714 printk(KERN_INFO
1715 "xc4000: Successfully identified at address 0x%02x\n",
1716 cfg->i2c_address);
1717 printk(KERN_INFO
1718 "xc4000: Firmware has been loaded previously\n");
1719 break;
1720 case XC_PRODUCT_ID_FW_NOT_LOADED:
1721 printk(KERN_INFO
1722 "xc4000: Successfully identified at address 0x%02x\n",
1723 cfg->i2c_address);
1724 printk(KERN_INFO
1725 "xc4000: Firmware has not been loaded previously\n");
1726 break;
1727 default:
1728 printk(KERN_ERR
1729 "xc4000: Device not found at addr 0x%02x (0x%x)\n",
1730 cfg->i2c_address, id);
1731 goto fail;
1732 }
1733
1734 mutex_unlock(&xc4000_list_mutex);
1735
1736 memcpy(&fe->ops.tuner_ops, &xc4000_tuner_ops,
1737 sizeof(struct dvb_tuner_ops));
1738
1739 if (instance == 1) {
1740 int ret;
1741 mutex_lock(&priv->lock);
1742 ret = xc4000_fwupload(fe);
1743 mutex_unlock(&priv->lock);
1744 if (ret != 0)
1745 goto fail2;
1746 }
1747
1748 return fe;
1749 fail:
1750 mutex_unlock(&xc4000_list_mutex);
1751 fail2:
1752 xc4000_release(fe);
1753 return NULL;
1754 }
1755 EXPORT_SYMBOL(xc4000_attach);
1756
1757 MODULE_AUTHOR("Steven Toth, Davide Ferri");
1758 MODULE_DESCRIPTION("Xceive xc4000 silicon tuner driver");
1759 MODULE_LICENSE("GPL");
Linux with added FPC-III support