[go: nahoru, domu]

1/* tuner-xc2028
2 *
3 * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
4 *
5 * Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)
6 *       - frontend interface
7 *
8 * This code is placed under the terms of the GNU General Public License v2
9 */
10
11#include <linux/i2c.h>
12#include <asm/div64.h>
13#include <linux/firmware.h>
14#include <linux/videodev2.h>
15#include <linux/delay.h>
16#include <media/tuner.h>
17#include <linux/mutex.h>
18#include <linux/slab.h>
19#include <asm/unaligned.h>
20#include "tuner-i2c.h"
21#include "tuner-xc2028.h"
22#include "tuner-xc2028-types.h"
23
24#include <linux/dvb/frontend.h>
25#include "dvb_frontend.h"
26
27/* Max transfer size done by I2C transfer functions */
28#define MAX_XFER_SIZE  80
29
30/* Registers (Write-only) */
31#define XREG_INIT         0x00
32#define XREG_RF_FREQ      0x02
33#define XREG_POWER_DOWN   0x08
34
35/* Registers (Read-only) */
36#define XREG_FREQ_ERROR   0x01
37#define XREG_LOCK         0x02
38#define XREG_VERSION      0x04
39#define XREG_PRODUCT_ID   0x08
40#define XREG_HSYNC_FREQ   0x10
41#define XREG_FRAME_LINES  0x20
42#define XREG_SNR          0x40
43
44#define XREG_ADC_ENV      0x0100
45
46static int debug;
47module_param(debug, int, 0644);
48MODULE_PARM_DESC(debug, "enable verbose debug messages");
49
50static int no_poweroff;
51module_param(no_poweroff, int, 0644);
52MODULE_PARM_DESC(no_poweroff, "0 (default) powers device off when not used.\n"
53	"1 keep device energized and with tuner ready all the times.\n"
54	"  Faster, but consumes more power and keeps the device hotter\n");
55
56static char audio_std[8];
57module_param_string(audio_std, audio_std, sizeof(audio_std), 0);
58MODULE_PARM_DESC(audio_std,
59	"Audio standard. XC3028 audio decoder explicitly "
60	"needs to know what audio\n"
61	"standard is needed for some video standards with audio A2 or NICAM.\n"
62	"The valid values are:\n"
63	"A2\n"
64	"A2/A\n"
65	"A2/B\n"
66	"NICAM\n"
67	"NICAM/A\n"
68	"NICAM/B\n");
69
70static char firmware_name[30];
71module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
72MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
73				"default firmware name\n");
74
75static LIST_HEAD(hybrid_tuner_instance_list);
76static DEFINE_MUTEX(xc2028_list_mutex);
77
78/* struct for storing firmware table */
79struct firmware_description {
80	unsigned int  type;
81	v4l2_std_id   id;
82	__u16         int_freq;
83	unsigned char *ptr;
84	unsigned int  size;
85};
86
87struct firmware_properties {
88	unsigned int	type;
89	v4l2_std_id	id;
90	v4l2_std_id	std_req;
91	__u16		int_freq;
92	unsigned int	scode_table;
93	int 		scode_nr;
94};
95
96enum xc2028_state {
97	XC2028_NO_FIRMWARE = 0,
98	XC2028_WAITING_FIRMWARE,
99	XC2028_ACTIVE,
100	XC2028_SLEEP,
101	XC2028_NODEV,
102};
103
104struct xc2028_data {
105	struct list_head        hybrid_tuner_instance_list;
106	struct tuner_i2c_props  i2c_props;
107	__u32			frequency;
108
109	enum xc2028_state	state;
110	const char		*fname;
111
112	struct firmware_description *firm;
113	int			firm_size;
114	__u16			firm_version;
115
116	__u16			hwmodel;
117	__u16			hwvers;
118
119	struct xc2028_ctrl	ctrl;
120
121	struct firmware_properties cur_fw;
122
123	struct mutex lock;
124};
125
126#define i2c_send(priv, buf, size) ({					\
127	int _rc;							\
128	_rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);		\
129	if (size != _rc)						\
130		tuner_info("i2c output error: rc = %d (should be %d)\n",\
131			   _rc, (int)size);				\
132	if (priv->ctrl.msleep)						\
133		msleep(priv->ctrl.msleep);				\
134	_rc;								\
135})
136
137#define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({		\
138	int _rc;							\
139	_rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize,	\
140				       ibuf, isize);			\
141	if (isize != _rc)						\
142		tuner_err("i2c input error: rc = %d (should be %d)\n",	\
143			   _rc, (int)isize); 				\
144	if (priv->ctrl.msleep)						\
145		msleep(priv->ctrl.msleep);				\
146	_rc;								\
147})
148
149#define send_seq(priv, data...)	({					\
150	static u8 _val[] = data;					\
151	int _rc;							\
152	if (sizeof(_val) !=						\
153			(_rc = tuner_i2c_xfer_send(&priv->i2c_props,	\
154						_val, sizeof(_val)))) {	\
155		tuner_err("Error on line %d: %d\n", __LINE__, _rc);	\
156	} else if (priv->ctrl.msleep)					\
157		msleep(priv->ctrl.msleep);				\
158	_rc;								\
159})
160
161static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val)
162{
163	unsigned char buf[2];
164	unsigned char ibuf[2];
165
166	tuner_dbg("%s %04x called\n", __func__, reg);
167
168	buf[0] = reg >> 8;
169	buf[1] = (unsigned char) reg;
170
171	if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2)
172		return -EIO;
173
174	*val = (ibuf[1]) | (ibuf[0] << 8);
175	return 0;
176}
177
178#define dump_firm_type(t) 	dump_firm_type_and_int_freq(t, 0)
179static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
180{
181	if (type & BASE)
182		printk("BASE ");
183	if (type & INIT1)
184		printk("INIT1 ");
185	if (type & F8MHZ)
186		printk("F8MHZ ");
187	if (type & MTS)
188		printk("MTS ");
189	if (type & D2620)
190		printk("D2620 ");
191	if (type & D2633)
192		printk("D2633 ");
193	if (type & DTV6)
194		printk("DTV6 ");
195	if (type & QAM)
196		printk("QAM ");
197	if (type & DTV7)
198		printk("DTV7 ");
199	if (type & DTV78)
200		printk("DTV78 ");
201	if (type & DTV8)
202		printk("DTV8 ");
203	if (type & FM)
204		printk("FM ");
205	if (type & INPUT1)
206		printk("INPUT1 ");
207	if (type & LCD)
208		printk("LCD ");
209	if (type & NOGD)
210		printk("NOGD ");
211	if (type & MONO)
212		printk("MONO ");
213	if (type & ATSC)
214		printk("ATSC ");
215	if (type & IF)
216		printk("IF ");
217	if (type & LG60)
218		printk("LG60 ");
219	if (type & ATI638)
220		printk("ATI638 ");
221	if (type & OREN538)
222		printk("OREN538 ");
223	if (type & OREN36)
224		printk("OREN36 ");
225	if (type & TOYOTA388)
226		printk("TOYOTA388 ");
227	if (type & TOYOTA794)
228		printk("TOYOTA794 ");
229	if (type & DIBCOM52)
230		printk("DIBCOM52 ");
231	if (type & ZARLINK456)
232		printk("ZARLINK456 ");
233	if (type & CHINA)
234		printk("CHINA ");
235	if (type & F6MHZ)
236		printk("F6MHZ ");
237	if (type & INPUT2)
238		printk("INPUT2 ");
239	if (type & SCODE)
240		printk("SCODE ");
241	if (type & HAS_IF)
242		printk("HAS_IF_%d ", int_freq);
243}
244
245static  v4l2_std_id parse_audio_std_option(void)
246{
247	if (strcasecmp(audio_std, "A2") == 0)
248		return V4L2_STD_A2;
249	if (strcasecmp(audio_std, "A2/A") == 0)
250		return V4L2_STD_A2_A;
251	if (strcasecmp(audio_std, "A2/B") == 0)
252		return V4L2_STD_A2_B;
253	if (strcasecmp(audio_std, "NICAM") == 0)
254		return V4L2_STD_NICAM;
255	if (strcasecmp(audio_std, "NICAM/A") == 0)
256		return V4L2_STD_NICAM_A;
257	if (strcasecmp(audio_std, "NICAM/B") == 0)
258		return V4L2_STD_NICAM_B;
259
260	return 0;
261}
262
263static int check_device_status(struct xc2028_data *priv)
264{
265	switch (priv->state) {
266	case XC2028_NO_FIRMWARE:
267	case XC2028_WAITING_FIRMWARE:
268		return -EAGAIN;
269	case XC2028_ACTIVE:
270		return 1;
271	case XC2028_SLEEP:
272		return 0;
273	case XC2028_NODEV:
274		return -ENODEV;
275	}
276	return 0;
277}
278
279static void free_firmware(struct xc2028_data *priv)
280{
281	int i;
282	tuner_dbg("%s called\n", __func__);
283
284	if (!priv->firm)
285		return;
286
287	for (i = 0; i < priv->firm_size; i++)
288		kfree(priv->firm[i].ptr);
289
290	kfree(priv->firm);
291
292	priv->firm = NULL;
293	priv->firm_size = 0;
294	priv->state = XC2028_NO_FIRMWARE;
295
296	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
297}
298
299static int load_all_firmwares(struct dvb_frontend *fe,
300			      const struct firmware *fw)
301{
302	struct xc2028_data    *priv = fe->tuner_priv;
303	const unsigned char   *p, *endp;
304	int                   rc = 0;
305	int		      n, n_array;
306	char		      name[33];
307
308	tuner_dbg("%s called\n", __func__);
309
310	p = fw->data;
311	endp = p + fw->size;
312
313	if (fw->size < sizeof(name) - 1 + 2 + 2) {
314		tuner_err("Error: firmware file %s has invalid size!\n",
315			  priv->fname);
316		goto corrupt;
317	}
318
319	memcpy(name, p, sizeof(name) - 1);
320	name[sizeof(name) - 1] = 0;
321	p += sizeof(name) - 1;
322
323	priv->firm_version = get_unaligned_le16(p);
324	p += 2;
325
326	n_array = get_unaligned_le16(p);
327	p += 2;
328
329	tuner_info("Loading %d firmware images from %s, type: %s, ver %d.%d\n",
330		   n_array, priv->fname, name,
331		   priv->firm_version >> 8, priv->firm_version & 0xff);
332
333	priv->firm = kcalloc(n_array, sizeof(*priv->firm), GFP_KERNEL);
334	if (priv->firm == NULL) {
335		tuner_err("Not enough memory to load firmware file.\n");
336		rc = -ENOMEM;
337		goto err;
338	}
339	priv->firm_size = n_array;
340
341	n = -1;
342	while (p < endp) {
343		__u32 type, size;
344		v4l2_std_id id;
345		__u16 int_freq = 0;
346
347		n++;
348		if (n >= n_array) {
349			tuner_err("More firmware images in file than "
350				  "were expected!\n");
351			goto corrupt;
352		}
353
354		/* Checks if there's enough bytes to read */
355		if (endp - p < sizeof(type) + sizeof(id) + sizeof(size))
356			goto header;
357
358		type = get_unaligned_le32(p);
359		p += sizeof(type);
360
361		id = get_unaligned_le64(p);
362		p += sizeof(id);
363
364		if (type & HAS_IF) {
365			int_freq = get_unaligned_le16(p);
366			p += sizeof(int_freq);
367			if (endp - p < sizeof(size))
368				goto header;
369		}
370
371		size = get_unaligned_le32(p);
372		p += sizeof(size);
373
374		if (!size || size > endp - p) {
375			tuner_err("Firmware type ");
376			dump_firm_type(type);
377			printk("(%x), id %llx is corrupted "
378			       "(size=%d, expected %d)\n",
379			       type, (unsigned long long)id,
380			       (unsigned)(endp - p), size);
381			goto corrupt;
382		}
383
384		priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
385		if (priv->firm[n].ptr == NULL) {
386			tuner_err("Not enough memory to load firmware file.\n");
387			rc = -ENOMEM;
388			goto err;
389		}
390		tuner_dbg("Reading firmware type ");
391		if (debug) {
392			dump_firm_type_and_int_freq(type, int_freq);
393			printk("(%x), id %llx, size=%d.\n",
394			       type, (unsigned long long)id, size);
395		}
396
397		memcpy(priv->firm[n].ptr, p, size);
398		priv->firm[n].type = type;
399		priv->firm[n].id   = id;
400		priv->firm[n].size = size;
401		priv->firm[n].int_freq = int_freq;
402
403		p += size;
404	}
405
406	if (n + 1 != priv->firm_size) {
407		tuner_err("Firmware file is incomplete!\n");
408		goto corrupt;
409	}
410
411	goto done;
412
413header:
414	tuner_err("Firmware header is incomplete!\n");
415corrupt:
416	rc = -EINVAL;
417	tuner_err("Error: firmware file is corrupted!\n");
418
419err:
420	tuner_info("Releasing partially loaded firmware file.\n");
421	free_firmware(priv);
422
423done:
424	if (rc == 0)
425		tuner_dbg("Firmware files loaded.\n");
426	else
427		priv->state = XC2028_NODEV;
428
429	return rc;
430}
431
432static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
433			 v4l2_std_id *id)
434{
435	struct xc2028_data *priv = fe->tuner_priv;
436	int                 i, best_i = -1, best_nr_matches = 0;
437	unsigned int        type_mask = 0;
438
439	tuner_dbg("%s called, want type=", __func__);
440	if (debug) {
441		dump_firm_type(type);
442		printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
443	}
444
445	if (!priv->firm) {
446		tuner_err("Error! firmware not loaded\n");
447		return -EINVAL;
448	}
449
450	if (((type & ~SCODE) == 0) && (*id == 0))
451		*id = V4L2_STD_PAL;
452
453	if (type & BASE)
454		type_mask = BASE_TYPES;
455	else if (type & SCODE) {
456		type &= SCODE_TYPES;
457		type_mask = SCODE_TYPES & ~HAS_IF;
458	} else if (type & DTV_TYPES)
459		type_mask = DTV_TYPES;
460	else if (type & STD_SPECIFIC_TYPES)
461		type_mask = STD_SPECIFIC_TYPES;
462
463	type &= type_mask;
464
465	if (!(type & SCODE))
466		type_mask = ~0;
467
468	/* Seek for exact match */
469	for (i = 0; i < priv->firm_size; i++) {
470		if ((type == (priv->firm[i].type & type_mask)) &&
471		    (*id == priv->firm[i].id))
472			goto found;
473	}
474
475	/* Seek for generic video standard match */
476	for (i = 0; i < priv->firm_size; i++) {
477		v4l2_std_id match_mask;
478		int nr_matches;
479
480		if (type != (priv->firm[i].type & type_mask))
481			continue;
482
483		match_mask = *id & priv->firm[i].id;
484		if (!match_mask)
485			continue;
486
487		if ((*id & match_mask) == *id)
488			goto found; /* Supports all the requested standards */
489
490		nr_matches = hweight64(match_mask);
491		if (nr_matches > best_nr_matches) {
492			best_nr_matches = nr_matches;
493			best_i = i;
494		}
495	}
496
497	if (best_nr_matches > 0) {
498		tuner_dbg("Selecting best matching firmware (%d bits) for "
499			  "type=", best_nr_matches);
500		dump_firm_type(type);
501		printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
502		i = best_i;
503		goto found;
504	}
505
506	/*FIXME: Would make sense to seek for type "hint" match ? */
507
508	i = -ENOENT;
509	goto ret;
510
511found:
512	*id = priv->firm[i].id;
513
514ret:
515	tuner_dbg("%s firmware for type=", (i < 0) ? "Can't find" : "Found");
516	if (debug) {
517		dump_firm_type(type);
518		printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
519	}
520	return i;
521}
522
523static inline int do_tuner_callback(struct dvb_frontend *fe, int cmd, int arg)
524{
525	struct xc2028_data *priv = fe->tuner_priv;
526
527	/* analog side (tuner-core) uses i2c_adap->algo_data.
528	 * digital side is not guaranteed to have algo_data defined.
529	 *
530	 * digital side will always have fe->dvb defined.
531	 * analog side (tuner-core) doesn't (yet) define fe->dvb.
532	 */
533
534	return (!fe->callback) ? -EINVAL :
535		fe->callback(((fe->dvb) && (fe->dvb->priv)) ?
536				fe->dvb->priv : priv->i2c_props.adap->algo_data,
537			     DVB_FRONTEND_COMPONENT_TUNER, cmd, arg);
538}
539
540static int load_firmware(struct dvb_frontend *fe, unsigned int type,
541			 v4l2_std_id *id)
542{
543	struct xc2028_data *priv = fe->tuner_priv;
544	int                pos, rc;
545	unsigned char      *p, *endp, buf[MAX_XFER_SIZE];
546
547	if (priv->ctrl.max_len > sizeof(buf))
548		priv->ctrl.max_len = sizeof(buf);
549
550	tuner_dbg("%s called\n", __func__);
551
552	pos = seek_firmware(fe, type, id);
553	if (pos < 0)
554		return pos;
555
556	tuner_info("Loading firmware for type=");
557	dump_firm_type(priv->firm[pos].type);
558	printk("(%x), id %016llx.\n", priv->firm[pos].type,
559	       (unsigned long long)*id);
560
561	p = priv->firm[pos].ptr;
562	endp = p + priv->firm[pos].size;
563
564	while (p < endp) {
565		__u16 size;
566
567		/* Checks if there's enough bytes to read */
568		if (p + sizeof(size) > endp) {
569			tuner_err("Firmware chunk size is wrong\n");
570			return -EINVAL;
571		}
572
573		size = le16_to_cpu(*(__le16 *) p);
574		p += sizeof(size);
575
576		if (size == 0xffff)
577			return 0;
578
579		if (!size) {
580			/* Special callback command received */
581			rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0);
582			if (rc < 0) {
583				tuner_err("Error at RESET code %d\n",
584					   (*p) & 0x7f);
585				return -EINVAL;
586			}
587			continue;
588		}
589		if (size >= 0xff00) {
590			switch (size) {
591			case 0xff00:
592				rc = do_tuner_callback(fe, XC2028_RESET_CLK, 0);
593				if (rc < 0) {
594					tuner_err("Error at RESET code %d\n",
595						  (*p) & 0x7f);
596					return -EINVAL;
597				}
598				break;
599			default:
600				tuner_info("Invalid RESET code %d\n",
601					   size & 0x7f);
602				return -EINVAL;
603
604			}
605			continue;
606		}
607
608		/* Checks for a sleep command */
609		if (size & 0x8000) {
610			msleep(size & 0x7fff);
611			continue;
612		}
613
614		if ((size + p > endp)) {
615			tuner_err("missing bytes: need %d, have %d\n",
616				   size, (int)(endp - p));
617			return -EINVAL;
618		}
619
620		buf[0] = *p;
621		p++;
622		size--;
623
624		/* Sends message chunks */
625		while (size > 0) {
626			int len = (size < priv->ctrl.max_len - 1) ?
627				   size : priv->ctrl.max_len - 1;
628
629			memcpy(buf + 1, p, len);
630
631			rc = i2c_send(priv, buf, len + 1);
632			if (rc < 0) {
633				tuner_err("%d returned from send\n", rc);
634				return -EINVAL;
635			}
636
637			p += len;
638			size -= len;
639		}
640
641		/* silently fail if the frontend doesn't support I2C flush */
642		rc = do_tuner_callback(fe, XC2028_I2C_FLUSH, 0);
643		if ((rc < 0) && (rc != -EINVAL)) {
644			tuner_err("error executing flush: %d\n", rc);
645			return rc;
646		}
647	}
648	return 0;
649}
650
651static int load_scode(struct dvb_frontend *fe, unsigned int type,
652			 v4l2_std_id *id, __u16 int_freq, int scode)
653{
654	struct xc2028_data *priv = fe->tuner_priv;
655	int                pos, rc;
656	unsigned char	   *p;
657
658	tuner_dbg("%s called\n", __func__);
659
660	if (!int_freq) {
661		pos = seek_firmware(fe, type, id);
662		if (pos < 0)
663			return pos;
664	} else {
665		for (pos = 0; pos < priv->firm_size; pos++) {
666			if ((priv->firm[pos].int_freq == int_freq) &&
667			    (priv->firm[pos].type & HAS_IF))
668				break;
669		}
670		if (pos == priv->firm_size)
671			return -ENOENT;
672	}
673
674	p = priv->firm[pos].ptr;
675
676	if (priv->firm[pos].type & HAS_IF) {
677		if (priv->firm[pos].size != 12 * 16 || scode >= 16)
678			return -EINVAL;
679		p += 12 * scode;
680	} else {
681		/* 16 SCODE entries per file; each SCODE entry is 12 bytes and
682		 * has a 2-byte size header in the firmware format. */
683		if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||
684		    le16_to_cpu(*(__le16 *)(p + 14 * scode)) != 12)
685			return -EINVAL;
686		p += 14 * scode + 2;
687	}
688
689	tuner_info("Loading SCODE for type=");
690	dump_firm_type_and_int_freq(priv->firm[pos].type,
691				    priv->firm[pos].int_freq);
692	printk("(%x), id %016llx.\n", priv->firm[pos].type,
693	       (unsigned long long)*id);
694
695	if (priv->firm_version < 0x0202)
696		rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00});
697	else
698		rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00});
699	if (rc < 0)
700		return -EIO;
701
702	rc = i2c_send(priv, p, 12);
703	if (rc < 0)
704		return -EIO;
705
706	rc = send_seq(priv, {0x00, 0x8c});
707	if (rc < 0)
708		return -EIO;
709
710	return 0;
711}
712
713static int xc2028_sleep(struct dvb_frontend *fe);
714
715static int check_firmware(struct dvb_frontend *fe, unsigned int type,
716			  v4l2_std_id std, __u16 int_freq)
717{
718	struct xc2028_data         *priv = fe->tuner_priv;
719	struct firmware_properties new_fw;
720	int			   rc, retry_count = 0;
721	u16			   version, hwmodel;
722	v4l2_std_id		   std0;
723
724	tuner_dbg("%s called\n", __func__);
725
726	rc = check_device_status(priv);
727	if (rc < 0)
728		return rc;
729
730	if (priv->ctrl.mts && !(type & FM))
731		type |= MTS;
732
733retry:
734	new_fw.type = type;
735	new_fw.id = std;
736	new_fw.std_req = std;
737	new_fw.scode_table = SCODE | priv->ctrl.scode_table;
738	new_fw.scode_nr = 0;
739	new_fw.int_freq = int_freq;
740
741	tuner_dbg("checking firmware, user requested type=");
742	if (debug) {
743		dump_firm_type(new_fw.type);
744		printk("(%x), id %016llx, ", new_fw.type,
745		       (unsigned long long)new_fw.std_req);
746		if (!int_freq) {
747			printk("scode_tbl ");
748			dump_firm_type(priv->ctrl.scode_table);
749			printk("(%x), ", priv->ctrl.scode_table);
750		} else
751			printk("int_freq %d, ", new_fw.int_freq);
752		printk("scode_nr %d\n", new_fw.scode_nr);
753	}
754
755	/*
756	 * No need to reload base firmware if it matches and if the tuner
757	 * is not at sleep mode
758	 */
759	if ((priv->state == XC2028_ACTIVE) &&
760	    (((BASE | new_fw.type) & BASE_TYPES) ==
761	    (priv->cur_fw.type & BASE_TYPES))) {
762		tuner_dbg("BASE firmware not changed.\n");
763		goto skip_base;
764	}
765
766	/* Updating BASE - forget about all currently loaded firmware */
767	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
768
769	/* Reset is needed before loading firmware */
770	rc = do_tuner_callback(fe, XC2028_TUNER_RESET, 0);
771	if (rc < 0)
772		goto fail;
773
774	/* BASE firmwares are all std0 */
775	std0 = 0;
776	rc = load_firmware(fe, BASE | new_fw.type, &std0);
777	if (rc < 0) {
778		tuner_err("Error %d while loading base firmware\n",
779			  rc);
780		goto fail;
781	}
782
783	/* Load INIT1, if needed */
784	tuner_dbg("Load init1 firmware, if exists\n");
785
786	rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0);
787	if (rc == -ENOENT)
788		rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ,
789				   &std0);
790	if (rc < 0 && rc != -ENOENT) {
791		tuner_err("Error %d while loading init1 firmware\n",
792			  rc);
793		goto fail;
794	}
795
796skip_base:
797	/*
798	 * No need to reload standard specific firmware if base firmware
799	 * was not reloaded and requested video standards have not changed.
800	 */
801	if (priv->cur_fw.type == (BASE | new_fw.type) &&
802	    priv->cur_fw.std_req == std) {
803		tuner_dbg("Std-specific firmware already loaded.\n");
804		goto skip_std_specific;
805	}
806
807	/* Reloading std-specific firmware forces a SCODE update */
808	priv->cur_fw.scode_table = 0;
809
810	rc = load_firmware(fe, new_fw.type, &new_fw.id);
811	if (rc == -ENOENT)
812		rc = load_firmware(fe, new_fw.type & ~F8MHZ, &new_fw.id);
813
814	if (rc < 0)
815		goto fail;
816
817skip_std_specific:
818	if (priv->cur_fw.scode_table == new_fw.scode_table &&
819	    priv->cur_fw.scode_nr == new_fw.scode_nr) {
820		tuner_dbg("SCODE firmware already loaded.\n");
821		goto check_device;
822	}
823
824	if (new_fw.type & FM)
825		goto check_device;
826
827	/* Load SCODE firmware, if exists */
828	tuner_dbg("Trying to load scode %d\n", new_fw.scode_nr);
829
830	rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
831			new_fw.int_freq, new_fw.scode_nr);
832
833check_device:
834	if (xc2028_get_reg(priv, 0x0004, &version) < 0 ||
835	    xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) {
836		tuner_err("Unable to read tuner registers.\n");
837		goto fail;
838	}
839
840	tuner_dbg("Device is Xceive %d version %d.%d, "
841		  "firmware version %d.%d\n",
842		  hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8,
843		  (version & 0xf0) >> 4, version & 0xf);
844
845
846	if (priv->ctrl.read_not_reliable)
847		goto read_not_reliable;
848
849	/* Check firmware version against what we downloaded. */
850	if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
851		if (!priv->ctrl.read_not_reliable) {
852			tuner_err("Incorrect readback of firmware version.\n");
853			goto fail;
854		} else {
855			tuner_err("Returned an incorrect version. However, "
856				  "read is not reliable enough. Ignoring it.\n");
857			hwmodel = 3028;
858		}
859	}
860
861	/* Check that the tuner hardware model remains consistent over time. */
862	if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) {
863		priv->hwmodel = hwmodel;
864		priv->hwvers  = version & 0xff00;
865	} else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
866		   priv->hwvers != (version & 0xff00)) {
867		tuner_err("Read invalid device hardware information - tuner "
868			  "hung?\n");
869		goto fail;
870	}
871
872read_not_reliable:
873	priv->cur_fw = new_fw;
874
875	/*
876	 * By setting BASE in cur_fw.type only after successfully loading all
877	 * firmwares, we can:
878	 * 1. Identify that BASE firmware with type=0 has been loaded;
879	 * 2. Tell whether BASE firmware was just changed the next time through.
880	 */
881	priv->cur_fw.type |= BASE;
882	priv->state = XC2028_ACTIVE;
883
884	return 0;
885
886fail:
887	priv->state = XC2028_NO_FIRMWARE;
888
889	memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
890	if (retry_count < 8) {
891		msleep(50);
892		retry_count++;
893		tuner_dbg("Retrying firmware load\n");
894		goto retry;
895	}
896
897	/* Firmware didn't load. Put the device to sleep */
898	xc2028_sleep(fe);
899
900	if (rc == -ENOENT)
901		rc = -EINVAL;
902	return rc;
903}
904
905static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
906{
907	struct xc2028_data *priv = fe->tuner_priv;
908	u16                 frq_lock, signal = 0;
909	int                 rc, i;
910
911	tuner_dbg("%s called\n", __func__);
912
913	rc = check_device_status(priv);
914	if (rc < 0)
915		return rc;
916
917	/* If the device is sleeping, no channel is tuned */
918	if (!rc) {
919		*strength = 0;
920		return 0;
921	}
922
923	mutex_lock(&priv->lock);
924
925	/* Sync Lock Indicator */
926	for (i = 0; i < 3; i++) {
927		rc = xc2028_get_reg(priv, XREG_LOCK, &frq_lock);
928		if (rc < 0)
929			goto ret;
930
931		if (frq_lock)
932			break;
933		msleep(6);
934	}
935
936	/* Frequency didn't lock */
937	if (frq_lock == 2)
938		goto ret;
939
940	/* Get SNR of the video signal */
941	rc = xc2028_get_reg(priv, XREG_SNR, &signal);
942	if (rc < 0)
943		goto ret;
944
945	/* Signal level is 3 bits only */
946
947	signal = ((1 << 12) - 1) | ((signal & 0x07) << 12);
948
949ret:
950	mutex_unlock(&priv->lock);
951
952	*strength = signal;
953
954	tuner_dbg("signal strength is %d\n", signal);
955
956	return rc;
957}
958
959static int xc2028_get_afc(struct dvb_frontend *fe, s32 *afc)
960{
961	struct xc2028_data *priv = fe->tuner_priv;
962	int i, rc;
963	u16 frq_lock = 0;
964	s16 afc_reg = 0;
965
966	rc = check_device_status(priv);
967	if (rc < 0)
968		return rc;
969
970	/* If the device is sleeping, no channel is tuned */
971	if (!rc) {
972		*afc = 0;
973		return 0;
974	}
975
976	mutex_lock(&priv->lock);
977
978	/* Sync Lock Indicator */
979	for (i = 0; i < 3; i++) {
980		rc = xc2028_get_reg(priv, XREG_LOCK, &frq_lock);
981		if (rc < 0)
982			goto ret;
983
984		if (frq_lock)
985			break;
986		msleep(6);
987	}
988
989	/* Frequency didn't lock */
990	if (frq_lock == 2)
991		goto ret;
992
993	/* Get AFC */
994	rc = xc2028_get_reg(priv, XREG_FREQ_ERROR, &afc_reg);
995	if (rc < 0)
996		goto ret;
997
998	*afc = afc_reg * 15625; /* Hz */
999
1000	tuner_dbg("AFC is %d Hz\n", *afc);
1001
1002ret:
1003	mutex_unlock(&priv->lock);
1004
1005	return rc;
1006}
1007
1008#define DIV 15625
1009
1010static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */,
1011			    enum v4l2_tuner_type new_type,
1012			    unsigned int type,
1013			    v4l2_std_id std,
1014			    u16 int_freq)
1015{
1016	struct xc2028_data *priv = fe->tuner_priv;
1017	int		   rc = -EINVAL;
1018	unsigned char	   buf[4];
1019	u32		   div, offset = 0;
1020
1021	tuner_dbg("%s called\n", __func__);
1022
1023	mutex_lock(&priv->lock);
1024
1025	tuner_dbg("should set frequency %d kHz\n", freq / 1000);
1026
1027	if (check_firmware(fe, type, std, int_freq) < 0)
1028		goto ret;
1029
1030	/* On some cases xc2028 can disable video output, if
1031	 * very weak signals are received. By sending a soft
1032	 * reset, this is re-enabled. So, it is better to always
1033	 * send a soft reset before changing channels, to be sure
1034	 * that xc2028 will be in a safe state.
1035	 * Maybe this might also be needed for DTV.
1036	 */
1037	switch (new_type) {
1038	case V4L2_TUNER_ANALOG_TV:
1039		rc = send_seq(priv, {0x00, 0x00});
1040
1041		/* Analog mode requires offset = 0 */
1042		break;
1043	case V4L2_TUNER_RADIO:
1044		/* Radio mode requires offset = 0 */
1045		break;
1046	case V4L2_TUNER_DIGITAL_TV:
1047		/*
1048		 * Digital modes require an offset to adjust to the
1049		 * proper frequency. The offset depends on what
1050		 * firmware version is used.
1051		 */
1052
1053		/*
1054		 * Adjust to the center frequency. This is calculated by the
1055		 * formula: offset = 1.25MHz - BW/2
1056		 * For DTV 7/8, the firmware uses BW = 8000, so it needs a
1057		 * further adjustment to get the frequency center on VHF
1058		 */
1059
1060		/*
1061		 * The firmware DTV78 used to work fine in UHF band (8 MHz
1062		 * bandwidth) but not at all in VHF band (7 MHz bandwidth).
1063		 * The real problem was connected to the formula used to
1064		 * calculate the center frequency offset in VHF band.
1065		 * In fact, removing the 500KHz adjustment fixed the problem.
1066		 * This is coherent to what was implemented for the DTV7
1067		 * firmware.
1068		 * In the end, now the center frequency is the same for all 3
1069		 * firmwares (DTV7, DTV8, DTV78) and doesn't depend on channel
1070		 * bandwidth.
1071		 */
1072
1073		if (priv->cur_fw.type & DTV6)
1074			offset = 1750000;
1075		else	/* DTV7 or DTV8 or DTV78 */
1076			offset = 2750000;
1077
1078		/*
1079		 * xc3028 additional "magic"
1080		 * Depending on the firmware version, it needs some adjustments
1081		 * to properly centralize the frequency. This seems to be
1082		 * needed to compensate the SCODE table adjustments made by
1083		 * newer firmwares
1084		 */
1085
1086		/*
1087		 * The proper adjustment would be to do it at s-code table.
1088		 * However, this didn't work, as reported by
1089		 * Robert Lowery <rglowery@exemail.com.au>
1090		 */
1091
1092#if 0
1093		/*
1094		 * Still need tests for XC3028L (firmware 3.2 or upper)
1095		 * So, for now, let's just comment the per-firmware
1096		 * version of this change. Reports with xc3028l working
1097		 * with and without the lines bellow are welcome
1098		 */
1099
1100		if (priv->firm_version < 0x0302) {
1101			if (priv->cur_fw.type & DTV7)
1102				offset += 500000;
1103		} else {
1104			if (priv->cur_fw.type & DTV7)
1105				offset -= 300000;
1106			else if (type != ATSC) /* DVB @6MHz, DTV 8 and DTV 7/8 */
1107				offset += 200000;
1108		}
1109#endif
1110		break;
1111	default:
1112		tuner_err("Unsupported tuner type %d.\n", new_type);
1113		break;
1114	}
1115
1116	div = (freq - offset + DIV / 2) / DIV;
1117
1118	/* CMD= Set frequency */
1119	if (priv->firm_version < 0x0202)
1120		rc = send_seq(priv, {0x00, XREG_RF_FREQ, 0x00, 0x00});
1121	else
1122		rc = send_seq(priv, {0x80, XREG_RF_FREQ, 0x00, 0x00});
1123	if (rc < 0)
1124		goto ret;
1125
1126	/* Return code shouldn't be checked.
1127	   The reset CLK is needed only with tm6000.
1128	   Driver should work fine even if this fails.
1129	 */
1130	if (priv->ctrl.msleep)
1131		msleep(priv->ctrl.msleep);
1132	do_tuner_callback(fe, XC2028_RESET_CLK, 1);
1133
1134	msleep(10);
1135
1136	buf[0] = 0xff & (div >> 24);
1137	buf[1] = 0xff & (div >> 16);
1138	buf[2] = 0xff & (div >> 8);
1139	buf[3] = 0xff & (div);
1140
1141	rc = i2c_send(priv, buf, sizeof(buf));
1142	if (rc < 0)
1143		goto ret;
1144	msleep(100);
1145
1146	priv->frequency = freq;
1147
1148	tuner_dbg("divisor= %*ph (freq=%d.%03d)\n", 4, buf,
1149	       freq / 1000000, (freq % 1000000) / 1000);
1150
1151	rc = 0;
1152
1153ret:
1154	mutex_unlock(&priv->lock);
1155
1156	return rc;
1157}
1158
1159static int xc2028_set_analog_freq(struct dvb_frontend *fe,
1160			      struct analog_parameters *p)
1161{
1162	struct xc2028_data *priv = fe->tuner_priv;
1163	unsigned int       type=0;
1164
1165	tuner_dbg("%s called\n", __func__);
1166
1167	if (p->mode == V4L2_TUNER_RADIO) {
1168		type |= FM;
1169		if (priv->ctrl.input1)
1170			type |= INPUT1;
1171		return generic_set_freq(fe, (625l * p->frequency) / 10,
1172				V4L2_TUNER_RADIO, type, 0, 0);
1173	}
1174
1175	/* if std is not defined, choose one */
1176	if (!p->std)
1177		p->std = V4L2_STD_MN;
1178
1179	/* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */
1180	if (!(p->std & V4L2_STD_MN))
1181		type |= F8MHZ;
1182
1183	/* Add audio hack to std mask */
1184	p->std |= parse_audio_std_option();
1185
1186	return generic_set_freq(fe, 62500l * p->frequency,
1187				V4L2_TUNER_ANALOG_TV, type, p->std, 0);
1188}
1189
1190static int xc2028_set_params(struct dvb_frontend *fe)
1191{
1192	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1193	u32 delsys = c->delivery_system;
1194	u32 bw = c->bandwidth_hz;
1195	struct xc2028_data *priv = fe->tuner_priv;
1196	int rc;
1197	unsigned int       type = 0;
1198	u16                demod = 0;
1199
1200	tuner_dbg("%s called\n", __func__);
1201
1202	rc = check_device_status(priv);
1203	if (rc < 0)
1204		return rc;
1205
1206	switch (delsys) {
1207	case SYS_DVBT:
1208	case SYS_DVBT2:
1209		/*
1210		 * The only countries with 6MHz seem to be Taiwan/Uruguay.
1211		 * Both seem to require QAM firmware for OFDM decoding
1212		 * Tested in Taiwan by Terry Wu <terrywu2009@gmail.com>
1213		 */
1214		if (bw <= 6000000)
1215			type |= QAM;
1216
1217		switch (priv->ctrl.type) {
1218		case XC2028_D2633:
1219			type |= D2633;
1220			break;
1221		case XC2028_D2620:
1222			type |= D2620;
1223			break;
1224		case XC2028_AUTO:
1225		default:
1226			/* Zarlink seems to need D2633 */
1227			if (priv->ctrl.demod == XC3028_FE_ZARLINK456)
1228				type |= D2633;
1229			else
1230				type |= D2620;
1231		}
1232		break;
1233	case SYS_ATSC:
1234		/* The only ATSC firmware (at least on v2.7) is D2633 */
1235		type |= ATSC | D2633;
1236		break;
1237	/* DVB-S and pure QAM (FE_QAM) are not supported */
1238	default:
1239		return -EINVAL;
1240	}
1241
1242	if (bw <= 6000000) {
1243		type |= DTV6;
1244		priv->ctrl.vhfbw7 = 0;
1245		priv->ctrl.uhfbw8 = 0;
1246	} else if (bw <= 7000000) {
1247		if (c->frequency < 470000000)
1248			priv->ctrl.vhfbw7 = 1;
1249		else
1250			priv->ctrl.uhfbw8 = 0;
1251		type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7;
1252		type |= F8MHZ;
1253	} else {
1254		if (c->frequency < 470000000)
1255			priv->ctrl.vhfbw7 = 0;
1256		else
1257			priv->ctrl.uhfbw8 = 1;
1258		type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8;
1259		type |= F8MHZ;
1260	}
1261
1262	/* All S-code tables need a 200kHz shift */
1263	if (priv->ctrl.demod) {
1264		demod = priv->ctrl.demod;
1265
1266		/*
1267		 * Newer firmwares require a 200 kHz offset only for ATSC
1268		 */
1269		if (type == ATSC || priv->firm_version < 0x0302)
1270			demod += 200;
1271		/*
1272		 * The DTV7 S-code table needs a 700 kHz shift.
1273		 *
1274		 * DTV7 is only used in Australia.  Germany or Italy may also
1275		 * use this firmware after initialization, but a tune to a UHF
1276		 * channel should then cause DTV78 to be used.
1277		 *
1278		 * Unfortunately, on real-field tests, the s-code offset
1279		 * didn't work as expected, as reported by
1280		 * Robert Lowery <rglowery@exemail.com.au>
1281		 */
1282	}
1283
1284	return generic_set_freq(fe, c->frequency,
1285				V4L2_TUNER_DIGITAL_TV, type, 0, demod);
1286}
1287
1288static int xc2028_sleep(struct dvb_frontend *fe)
1289{
1290	struct xc2028_data *priv = fe->tuner_priv;
1291	int rc;
1292
1293	rc = check_device_status(priv);
1294	if (rc < 0)
1295		return rc;
1296
1297	/* Device is already in sleep mode */
1298	if (!rc)
1299		return 0;
1300
1301	/* Avoid firmware reload on slow devices or if PM disabled */
1302	if (no_poweroff || priv->ctrl.disable_power_mgmt)
1303		return 0;
1304
1305	tuner_dbg("Putting xc2028/3028 into poweroff mode.\n");
1306	if (debug > 1) {
1307		tuner_dbg("Printing sleep stack trace:\n");
1308		dump_stack();
1309	}
1310
1311	mutex_lock(&priv->lock);
1312
1313	if (priv->firm_version < 0x0202)
1314		rc = send_seq(priv, {0x00, XREG_POWER_DOWN, 0x00, 0x00});
1315	else
1316		rc = send_seq(priv, {0x80, XREG_POWER_DOWN, 0x00, 0x00});
1317
1318	if (rc >= 0)
1319		priv->state = XC2028_SLEEP;
1320
1321	mutex_unlock(&priv->lock);
1322
1323	return rc;
1324}
1325
1326static int xc2028_dvb_release(struct dvb_frontend *fe)
1327{
1328	struct xc2028_data *priv = fe->tuner_priv;
1329
1330	tuner_dbg("%s called\n", __func__);
1331
1332	mutex_lock(&xc2028_list_mutex);
1333
1334	/* only perform final cleanup if this is the last instance */
1335	if (hybrid_tuner_report_instance_count(priv) == 1) {
1336		free_firmware(priv);
1337		kfree(priv->ctrl.fname);
1338		priv->ctrl.fname = NULL;
1339	}
1340
1341	if (priv)
1342		hybrid_tuner_release_state(priv);
1343
1344	mutex_unlock(&xc2028_list_mutex);
1345
1346	fe->tuner_priv = NULL;
1347
1348	return 0;
1349}
1350
1351static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
1352{
1353	struct xc2028_data *priv = fe->tuner_priv;
1354	int rc;
1355
1356	tuner_dbg("%s called\n", __func__);
1357
1358	rc = check_device_status(priv);
1359	if (rc < 0)
1360		return rc;
1361
1362	*frequency = priv->frequency;
1363
1364	return 0;
1365}
1366
1367static void load_firmware_cb(const struct firmware *fw,
1368			     void *context)
1369{
1370	struct dvb_frontend *fe = context;
1371	struct xc2028_data *priv = fe->tuner_priv;
1372	int rc;
1373
1374	tuner_dbg("request_firmware_nowait(): %s\n", fw ? "OK" : "error");
1375	if (!fw) {
1376		tuner_err("Could not load firmware %s.\n", priv->fname);
1377		priv->state = XC2028_NODEV;
1378		return;
1379	}
1380
1381	rc = load_all_firmwares(fe, fw);
1382
1383	release_firmware(fw);
1384
1385	if (rc < 0)
1386		return;
1387	priv->state = XC2028_ACTIVE;
1388}
1389
1390static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
1391{
1392	struct xc2028_data *priv = fe->tuner_priv;
1393	struct xc2028_ctrl *p    = priv_cfg;
1394	int                 rc   = 0;
1395
1396	tuner_dbg("%s called\n", __func__);
1397
1398	mutex_lock(&priv->lock);
1399
1400	/*
1401	 * Copy the config data.
1402	 * For the firmware name, keep a local copy of the string,
1403	 * in order to avoid troubles during device release.
1404	 */
1405	kfree(priv->ctrl.fname);
1406	memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
1407	if (p->fname) {
1408		priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
1409		if (priv->ctrl.fname == NULL)
1410			rc = -ENOMEM;
1411	}
1412
1413	/*
1414	 * If firmware name changed, frees firmware. As free_firmware will
1415	 * reset the status to NO_FIRMWARE, this forces a new request_firmware
1416	 */
1417	if (!firmware_name[0] && p->fname &&
1418	    priv->fname && strcmp(p->fname, priv->fname))
1419		free_firmware(priv);
1420
1421	if (priv->ctrl.max_len < 9)
1422		priv->ctrl.max_len = 13;
1423
1424	if (priv->state == XC2028_NO_FIRMWARE) {
1425		if (!firmware_name[0])
1426			priv->fname = priv->ctrl.fname;
1427		else
1428			priv->fname = firmware_name;
1429
1430		rc = request_firmware_nowait(THIS_MODULE, 1,
1431					     priv->fname,
1432					     priv->i2c_props.adap->dev.parent,
1433					     GFP_KERNEL,
1434					     fe, load_firmware_cb);
1435		if (rc < 0) {
1436			tuner_err("Failed to request firmware %s\n",
1437				  priv->fname);
1438			priv->state = XC2028_NODEV;
1439		} else
1440			priv->state = XC2028_WAITING_FIRMWARE;
1441	}
1442	mutex_unlock(&priv->lock);
1443
1444	return rc;
1445}
1446
1447static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
1448	.info = {
1449		 .name = "Xceive XC3028",
1450		 .frequency_min = 42000000,
1451		 .frequency_max = 864000000,
1452		 .frequency_step = 50000,
1453		 },
1454
1455	.set_config	   = xc2028_set_config,
1456	.set_analog_params = xc2028_set_analog_freq,
1457	.release           = xc2028_dvb_release,
1458	.get_frequency     = xc2028_get_frequency,
1459	.get_rf_strength   = xc2028_signal,
1460	.get_afc           = xc2028_get_afc,
1461	.set_params        = xc2028_set_params,
1462	.sleep             = xc2028_sleep,
1463};
1464
1465struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
1466				   struct xc2028_config *cfg)
1467{
1468	struct xc2028_data *priv;
1469	int instance;
1470
1471	if (debug)
1472		printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");
1473
1474	if (NULL == cfg)
1475		return NULL;
1476
1477	if (!fe) {
1478		printk(KERN_ERR "xc2028: No frontend!\n");
1479		return NULL;
1480	}
1481
1482	mutex_lock(&xc2028_list_mutex);
1483
1484	instance = hybrid_tuner_request_state(struct xc2028_data, priv,
1485					      hybrid_tuner_instance_list,
1486					      cfg->i2c_adap, cfg->i2c_addr,
1487					      "xc2028");
1488	switch (instance) {
1489	case 0:
1490		/* memory allocation failure */
1491		goto fail;
1492	case 1:
1493		/* new tuner instance */
1494		priv->ctrl.max_len = 13;
1495
1496		mutex_init(&priv->lock);
1497
1498		fe->tuner_priv = priv;
1499		break;
1500	case 2:
1501		/* existing tuner instance */
1502		fe->tuner_priv = priv;
1503		break;
1504	}
1505
1506	memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
1507	       sizeof(xc2028_dvb_tuner_ops));
1508
1509	tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
1510
1511	if (cfg->ctrl)
1512		xc2028_set_config(fe, cfg->ctrl);
1513
1514	mutex_unlock(&xc2028_list_mutex);
1515
1516	return fe;
1517fail:
1518	mutex_unlock(&xc2028_list_mutex);
1519
1520	xc2028_dvb_release(fe);
1521	return NULL;
1522}
1523
1524EXPORT_SYMBOL(xc2028_attach);
1525
1526MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
1527MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
1528MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
1529MODULE_LICENSE("GPL");
1530MODULE_FIRMWARE(XC2028_DEFAULT_FIRMWARE);
1531MODULE_FIRMWARE(XC3028L_DEFAULT_FIRMWARE);
1532