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