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