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