[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / video / au0828 / au0828-cards.c

/*
 *  Driver for the Auvitek USB bridge
 *
 *  Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "au0828.h"
#include "au0828-cards.h"
#include "au8522.h"
#include "media/tuner.h"
#include "media/v4l2-common.h"

void hvr950q_cs5340_audio(void *priv, int enable)
{
	/* Because the HVR-950q shares an i2s bus between the cs5340 and the
	   au8522, we need to hold cs5340 in reset when using the au8522 */
	struct au0828_dev *dev = priv;
	if (enable == 1)
		au0828_set(dev, REG_000, 0x10);
	else
		au0828_clear(dev, REG_000, 0x10);
}

struct au0828_board au0828_boards[] = {
	[AU0828_BOARD_UNKNOWN] = {
		.name	= "Unknown board",
		.tuner_type = UNSET,
		.tuner_addr = ADDR_UNSET,
	},
	[AU0828_BOARD_HAUPPAUGE_HVR850] = {
		.name	= "Hauppauge HVR850",
		.tuner_type = TUNER_XC5000,
		.tuner_addr = 0x61,
		.i2c_clk_divider = AU0828_I2C_CLK_30KHZ,
		.input = {
			{
				.type = AU0828_VMUX_TELEVISION,
				.vmux = AU8522_COMPOSITE_CH4_SIF,
				.amux = AU8522_AUDIO_SIF,
			},
			{
				.type = AU0828_VMUX_COMPOSITE,
				.vmux = AU8522_COMPOSITE_CH1,
				.amux = AU8522_AUDIO_NONE,
				.audio_setup = hvr950q_cs5340_audio,
			},
			{
				.type = AU0828_VMUX_SVIDEO,
				.vmux = AU8522_SVIDEO_CH13,
				.amux = AU8522_AUDIO_NONE,
				.audio_setup = hvr950q_cs5340_audio,
			},
		},
	},
	[AU0828_BOARD_HAUPPAUGE_HVR950Q] = {
		.name	= "Hauppauge HVR950Q",
		.tuner_type = TUNER_XC5000,
		.tuner_addr = 0x61,
		/* The au0828 hardware i2c implementation does not properly
		   support the xc5000's i2c clock stretching.  So we need to
		   lower the clock frequency enough where the 15us clock
		   stretch fits inside of a normal clock cycle, or else the
		   au0828 fails to set the STOP bit.  A 30 KHz clock puts the
		   clock pulse width at 18us */
		.i2c_clk_divider = AU0828_I2C_CLK_30KHZ,
		.input = {
			{
				.type = AU0828_VMUX_TELEVISION,
				.vmux = AU8522_COMPOSITE_CH4_SIF,
				.amux = AU8522_AUDIO_SIF,
			},
			{
				.type = AU0828_VMUX_COMPOSITE,
				.vmux = AU8522_COMPOSITE_CH1,
				.amux = AU8522_AUDIO_NONE,
				.audio_setup = hvr950q_cs5340_audio,
			},
			{
				.type = AU0828_VMUX_SVIDEO,
				.vmux = AU8522_SVIDEO_CH13,
				.amux = AU8522_AUDIO_NONE,
				.audio_setup = hvr950q_cs5340_audio,
			},
		},
	},
	[AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL] = {
		.name	= "Hauppauge HVR950Q rev xxF8",
		.tuner_type = UNSET,
		.tuner_addr = ADDR_UNSET,
		.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
	},
	[AU0828_BOARD_DVICO_FUSIONHDTV7] = {
		.name	= "DViCO FusionHDTV USB",
		.tuner_type = UNSET,
		.tuner_addr = ADDR_UNSET,
		.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
	},
	[AU0828_BOARD_HAUPPAUGE_WOODBURY] = {
		.name = "Hauppauge Woodbury",
		.tuner_type = UNSET,
		.tuner_addr = ADDR_UNSET,
		.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
	},
};

/* Tuner callback function for au0828 boards. Currently only needed
 * for HVR1500Q, which has an xc5000 tuner.
 */
int au0828_tuner_callback(void *priv, int component, int command, int arg)
{
	struct au0828_dev *dev = priv;

	dprintk(1, "%s()\n", __func__);

	switch (dev->boardnr) {
	case AU0828_BOARD_HAUPPAUGE_HVR850:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
	case AU0828_BOARD_DVICO_FUSIONHDTV7:
		if (command == 0) {
			/* Tuner Reset Command from xc5000 */
			/* Drive the tuner into reset and out */
			au0828_clear(dev, REG_001, 2);
			mdelay(10);
			au0828_set(dev, REG_001, 2);
			mdelay(10);
			return 0;
		} else {
			printk(KERN_ERR
				"%s(): Unknown command.\n", __func__);
			return -EINVAL;
		}
		break;
	}

	return 0; /* Should never be here */
}

static void hauppauge_eeprom(struct au0828_dev *dev, u8 *eeprom_data)
{
	struct tveeprom tv;

	tveeprom_hauppauge_analog(&dev->i2c_client, &tv, eeprom_data);
	dev->board.tuner_type = tv.tuner_type;

	/* Make sure we support the board model */
	switch (tv.model) {
	case 72000: /* WinTV-HVR950q (Retail, IR, ATSC/QAM */
	case 72001: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
	case 72211: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	case 72221: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	case 72231: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	case 72241: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
	case 72251: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
	case 72301: /* WinTV-HVR850 (Retail, IR, ATSC and analog video */
	case 72500: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM */
		break;
	default:
		printk(KERN_WARNING "%s: warning: "
		       "unknown hauppauge model #%d\n", __func__, tv.model);
		break;
	}

	printk(KERN_INFO "%s: hauppauge eeprom: model=%d\n",
	       __func__, tv.model);
}

void au0828_card_setup(struct au0828_dev *dev)
{
	static u8 eeprom[256];
	struct tuner_setup tun_setup;
	struct v4l2_subdev *sd;
	unsigned int mode_mask = T_ANALOG_TV;

	dprintk(1, "%s()\n", __func__);

	memcpy(&dev->board, &au0828_boards[dev->boardnr], sizeof(dev->board));

	if (dev->i2c_rc == 0) {
		dev->i2c_client.addr = 0xa0 >> 1;
		tveeprom_read(&dev->i2c_client, eeprom, sizeof(eeprom));
	}

	switch (dev->boardnr) {
	case AU0828_BOARD_HAUPPAUGE_HVR850:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
		if (dev->i2c_rc == 0)
			hauppauge_eeprom(dev, eeprom+0xa0);
		break;
	}

	if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED) {
		/* Load the analog demodulator driver (note this would need to
		   be abstracted out if we ever need to support a different
		   demod) */
		sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
				"au8522", 0x8e >> 1, NULL);
		if (sd == NULL)
			printk(KERN_ERR "analog subdev registration failed\n");
	}

	/* Setup tuners */
	if (dev->board.tuner_type != TUNER_ABSENT) {
		/* Load the tuner module, which does the attach */
		sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
				"tuner", dev->board.tuner_addr, NULL);
		if (sd == NULL)
			printk(KERN_ERR "tuner subdev registration fail\n");

		tun_setup.mode_mask      = mode_mask;
		tun_setup.type           = dev->board.tuner_type;
		tun_setup.addr           = dev->board.tuner_addr;
		tun_setup.tuner_callback = au0828_tuner_callback;
		v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr,
				     &tun_setup);
	}
}

/*
 * The bridge has between 8 and 12 gpios.
 * Regs 1 and 0 deal with output enables.
 * Regs 3 and 2 deal with direction.
 */
void au0828_gpio_setup(struct au0828_dev *dev)
{
	dprintk(1, "%s()\n", __func__);

	switch (dev->boardnr) {
	case AU0828_BOARD_HAUPPAUGE_HVR850:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
		/* GPIO's
		 * 4 - CS5340
		 * 5 - AU8522 Demodulator
		 * 6 - eeprom W/P
		 * 7 - power supply
		 * 9 - XC5000 Tuner
		 */

		/* Into reset */
		au0828_write(dev, REG_003, 0x02);
		au0828_write(dev, REG_002, 0x80 | 0x20 | 0x10);
		au0828_write(dev, REG_001, 0x0);
		au0828_write(dev, REG_000, 0x0);
		msleep(100);

		/* Out of reset (leave the cs5340 in reset until needed) */
		au0828_write(dev, REG_003, 0x02);
		au0828_write(dev, REG_001, 0x02);
		au0828_write(dev, REG_002, 0x80 | 0x20 | 0x10);
		au0828_write(dev, REG_000, 0x80 | 0x40 | 0x20);

		msleep(250);
		break;
	case AU0828_BOARD_DVICO_FUSIONHDTV7:
		/* GPIO's
		 * 6 - ?
		 * 8 - AU8522 Demodulator
		 * 9 - XC5000 Tuner
		 */

		/* Into reset */
		au0828_write(dev, REG_003, 0x02);
		au0828_write(dev, REG_002, 0xa0);
		au0828_write(dev, REG_001, 0x0);
		au0828_write(dev, REG_000, 0x0);
		msleep(100);

		/* Out of reset */
		au0828_write(dev, REG_003, 0x02);
		au0828_write(dev, REG_002, 0xa0);
		au0828_write(dev, REG_001, 0x02);
		au0828_write(dev, REG_000, 0xa0);
		msleep(250);
		break;
	}
}

/* table of devices that work with this driver */
struct usb_device_id au0828_usb_id_table[] = {
	{ USB_DEVICE(0x2040, 0x7200),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x7240),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR850 },
	{ USB_DEVICE(0x0fe9, 0xd620),
		.driver_info = AU0828_BOARD_DVICO_FUSIONHDTV7 },
	{ USB_DEVICE(0x2040, 0x7210),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x7217),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x721b),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x721e),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x721f),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x7280),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x0fd9, 0x0008),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x7201),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	{ USB_DEVICE(0x2040, 0x7211),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	{ USB_DEVICE(0x2040, 0x7281),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	{ USB_DEVICE(0x2040, 0x8200),
		.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
	{ },
};

MODULE_DEVICE_TABLE(usb, au0828_usb_id_table);
Commit	Line	Data
265a6510 ST	1	/*
	2	* Driver for the Auvitek USB bridge
	3	*
6d897616	4	* Copyright (c) 2008 Steven Toth <stoth@linuxtv.org>
265a6510 ST	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	*
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
	22	#include "au0828.h"
	23	#include "au0828-cards.h"
8b2f0795	24	#include "au8522.h"
f1add5b5 DH	25	#include "media/tuner.h"
f1add5b5 DH	26	#include "media/v4l2-common.h"
8b2f0795 DH	27
	28	void hvr950q_cs5340_audio(void *priv, int enable)
	29	{
	30	/* Because the HVR-950q shares an i2s bus between the cs5340 and the
	31	au8522, we need to hold cs5340 in reset when using the au8522 */
	32	struct au0828_dev *dev = priv;
	33	if (enable == 1)
	34	au0828_set(dev, REG_000, 0x10);
	35	else
	36	au0828_clear(dev, REG_000, 0x10);
	37	}
265a6510	38
265a6510 ST	39	struct au0828_board au0828_boards[] = {
	40	[AU0828_BOARD_UNKNOWN] = {
	41	.name = "Unknown board",
f1add5b5 DH	42	.tuner_type = UNSET,
f1add5b5 DH	43	.tuner_addr = ADDR_UNSET,
265a6510 ST	44	},
	45	[AU0828_BOARD_HAUPPAUGE_HVR850] = {
	46	.name = "Hauppauge HVR850",
f1add5b5 DH	47	.tuner_type = TUNER_XC5000,
f1add5b5 DH	48	.tuner_addr = 0x61,
16af6f5a	49	.i2c_clk_divider = AU0828_I2C_CLK_30KHZ,
7fdd7c72 DH	50	.input = {
	51	{
	52	.type = AU0828_VMUX_TELEVISION,
	53	.vmux = AU8522_COMPOSITE_CH4_SIF,
	54	.amux = AU8522_AUDIO_SIF,
	55	},
	56	{
	57	.type = AU0828_VMUX_COMPOSITE,
	58	.vmux = AU8522_COMPOSITE_CH1,
	59	.amux = AU8522_AUDIO_NONE,
	60	.audio_setup = hvr950q_cs5340_audio,
	61	},
	62	{
	63	.type = AU0828_VMUX_SVIDEO,
	64	.vmux = AU8522_SVIDEO_CH13,
	65	.amux = AU8522_AUDIO_NONE,
	66	.audio_setup = hvr950q_cs5340_audio,
	67	},
	68	},
265a6510 ST	69	},
	70	[AU0828_BOARD_HAUPPAUGE_HVR950Q] = {
	71	.name = "Hauppauge HVR950Q",
f1add5b5 DH	72	.tuner_type = TUNER_XC5000,
f1add5b5 DH	73	.tuner_addr = 0x61,
16af6f5a DH	74	/* The au0828 hardware i2c implementation does not properly
	75	support the xc5000's i2c clock stretching. So we need to
	76	lower the clock frequency enough where the 15us clock
	77	stretch fits inside of a normal clock cycle, or else the
	78	au0828 fails to set the STOP bit. A 30 KHz clock puts the
	79	clock pulse width at 18us */
	80	.i2c_clk_divider = AU0828_I2C_CLK_30KHZ,
8b2f0795 DH	81	.input = {
	82	{
	83	.type = AU0828_VMUX_TELEVISION,
	84	.vmux = AU8522_COMPOSITE_CH4_SIF,
	85	.amux = AU8522_AUDIO_SIF,
	86	},
	87	{
	88	.type = AU0828_VMUX_COMPOSITE,
	89	.vmux = AU8522_COMPOSITE_CH1,
	90	.amux = AU8522_AUDIO_NONE,
	91	.audio_setup = hvr950q_cs5340_audio,
	92	},
	93	{
	94	.type = AU0828_VMUX_SVIDEO,
	95	.vmux = AU8522_SVIDEO_CH13,
	96	.amux = AU8522_AUDIO_NONE,
	97	.audio_setup = hvr950q_cs5340_audio,
	98	},
	99	},
265a6510	100	},
59d27521 MK	101	[AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL] = {
59d27521 MK	102	.name = "Hauppauge HVR950Q rev xxF8",
f1add5b5 DH	103	.tuner_type = UNSET,
f1add5b5 DH	104	.tuner_addr = ADDR_UNSET,
16af6f5a	105	.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
59d27521	106	},
265a6510 ST	107	[AU0828_BOARD_DVICO_FUSIONHDTV7] = {
265a6510 ST	108	.name = "DViCO FusionHDTV USB",
f1add5b5 DH	109	.tuner_type = UNSET,
f1add5b5 DH	110	.tuner_addr = ADDR_UNSET,
16af6f5a	111	.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
265a6510	112	},
8e8bd229 MK	113	[AU0828_BOARD_HAUPPAUGE_WOODBURY] = {
8e8bd229 MK	114	.name = "Hauppauge Woodbury",
f1add5b5 DH	115	.tuner_type = UNSET,
f1add5b5 DH	116	.tuner_addr = ADDR_UNSET,
16af6f5a	117	.i2c_clk_divider = AU0828_I2C_CLK_250KHZ,
8e8bd229	118	},
265a6510	119	};
265a6510 ST	120
	121	/* Tuner callback function for au0828 boards. Currently only needed
	122	* for HVR1500Q, which has an xc5000 tuner.
	123	*/
d7cba043	124	int au0828_tuner_callback(void *priv, int component, int command, int arg)
265a6510 ST	125	{
	126	struct au0828_dev *dev = priv;
	127
f07e8e4b	128	dprintk(1, "%s()\n", __func__);
bc3c613c	129
f1add5b5	130	switch (dev->boardnr) {
265a6510 ST	131	case AU0828_BOARD_HAUPPAUGE_HVR850:
265a6510 ST	132	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
59d27521	133	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
265a6510	134	case AU0828_BOARD_DVICO_FUSIONHDTV7:
a9c36aad	135	if (command == 0) {
265a6510 ST	136	/* Tuner Reset Command from xc5000 */
	137	/* Drive the tuner into reset and out */
	138	au0828_clear(dev, REG_001, 2);
b25ed9c5	139	mdelay(10);
265a6510	140	au0828_set(dev, REG_001, 2);
b25ed9c5	141	mdelay(10);
265a6510	142	return 0;
18d73c58	143	} else {
265a6510	144	printk(KERN_ERR
f07e8e4b	145	"%s(): Unknown command.\n", __func__);
265a6510 ST	146	return -EINVAL;
	147	}
	148	break;
	149	}
	150
	151	return 0; /* Should never be here */
	152	}
	153
28930fa9 ST	154	static void hauppauge_eeprom(struct au0828_dev dev, u8 eeprom_data)
	155	{
	156	struct tveeprom tv;
	157
	158	tveeprom_hauppauge_analog(&dev->i2c_client, &tv, eeprom_data);
f1add5b5	159	dev->board.tuner_type = tv.tuner_type;
28930fa9 ST	160
28930fa9 ST	161	/* Make sure we support the board model */
a9c36aad	162	switch (tv.model) {
104fe9a2	163	case 72000: /* WinTV-HVR950q (Retail, IR, ATSC/QAM */
62899a28 DH	164	case 72001: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
	165	case 72211: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	166	case 72221: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	167	case 72231: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	168	case 72241: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
	169	case 72251: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
	170	case 72301: /* WinTV-HVR850 (Retail, IR, ATSC and analog video */
104fe9a2	171	case 72500: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM */
28930fa9 ST	172	break;
28930fa9 ST	173	default:
f07e8e4b MK	174	printk(KERN_WARNING "%s: warning: "
f07e8e4b MK	175	"unknown hauppauge model #%d\n", __func__, tv.model);
28930fa9 ST	176	break;
	177	}
	178
f07e8e4b MK	179	printk(KERN_INFO "%s: hauppauge eeprom: model=%d\n",
f07e8e4b MK	180	__func__, tv.model);
28930fa9 ST	181	}
28930fa9 ST	182
28930fa9 ST	183	void au0828_card_setup(struct au0828_dev *dev)
28930fa9 ST	184	{
28930fa9	185	static u8 eeprom[256];
f1add5b5	186	struct tuner_setup tun_setup;
b14667f3	187	struct v4l2_subdev *sd;
ad020dc2	188	unsigned int mode_mask = T_ANALOG_TV;
28930fa9	189
f07e8e4b	190	dprintk(1, "%s()\n", __func__);
bc3c613c	191
f1add5b5 DH	192	memcpy(&dev->board, &au0828_boards[dev->boardnr], sizeof(dev->board));
f1add5b5 DH	193
28930fa9 ST	194	if (dev->i2c_rc == 0) {
	195	dev->i2c_client.addr = 0xa0 >> 1;
	196	tveeprom_read(&dev->i2c_client, eeprom, sizeof(eeprom));
	197	}
	198
f1add5b5	199	switch (dev->boardnr) {
28930fa9 ST	200	case AU0828_BOARD_HAUPPAUGE_HVR850:
28930fa9 ST	201	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
59d27521	202	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
8e8bd229	203	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
28930fa9 ST	204	if (dev->i2c_rc == 0)
	205	hauppauge_eeprom(dev, eeprom+0xa0);
	206	break;
	207	}
f1add5b5	208
220be77c	209	if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED) {
f1add5b5 DH	210	/* Load the analog demodulator driver (note this would need to
	211	be abstracted out if we ever need to support a different
	212	demod) */
e6574f2f	213	sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
9a1f8b34	214	"au8522", 0x8e >> 1, NULL);
62899a28 DH	215	if (sd == NULL)
62899a28 DH	216	printk(KERN_ERR "analog subdev registration failed\n");
f1add5b5 DH	217	}
	218
	219	/* Setup tuners */
	220	if (dev->board.tuner_type != TUNER_ABSENT) {
	221	/* Load the tuner module, which does the attach */
e6574f2f	222	sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
9a1f8b34	223	"tuner", dev->board.tuner_addr, NULL);
62899a28 DH	224	if (sd == NULL)
62899a28 DH	225	printk(KERN_ERR "tuner subdev registration fail\n");
f1add5b5 DH	226
	227	tun_setup.mode_mask = mode_mask;
	228	tun_setup.type = dev->board.tuner_type;
	229	tun_setup.addr = dev->board.tuner_addr;
	230	tun_setup.tuner_callback = au0828_tuner_callback;
2689d3dc DH	231	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr,
2689d3dc DH	232	&tun_setup);
f1add5b5	233	}
28930fa9 ST	234	}
28930fa9 ST	235
265a6510 ST	236	/*
	237	* The bridge has between 8 and 12 gpios.
	238	* Regs 1 and 0 deal with output enables.
a9c36aad	239	* Regs 3 and 2 deal with direction.
265a6510 ST	240	*/
	241	void au0828_gpio_setup(struct au0828_dev *dev)
	242	{
f07e8e4b	243	dprintk(1, "%s()\n", __func__);
bc3c613c	244
f1add5b5	245	switch (dev->boardnr) {
265a6510 ST	246	case AU0828_BOARD_HAUPPAUGE_HVR850:
265a6510 ST	247	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
59d27521	248	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
8e8bd229	249	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
265a6510 ST	250	/* GPIO's
	251	* 4 - CS5340
	252	* 5 - AU8522 Demodulator
	253	* 6 - eeprom W/P
8b2f0795	254	* 7 - power supply
265a6510 ST	255	* 9 - XC5000 Tuner
	256	*/
	257
	258	/* Into reset */
	259	au0828_write(dev, REG_003, 0x02);
8b2f0795	260	au0828_write(dev, REG_002, 0x80 \| 0x20 \| 0x10);
265a6510 ST	261	au0828_write(dev, REG_001, 0x0);
	262	au0828_write(dev, REG_000, 0x0);
	263	msleep(100);
	264
8b2f0795	265	/* Out of reset (leave the cs5340 in reset until needed) */
265a6510 ST	266	au0828_write(dev, REG_003, 0x02);
265a6510 ST	267	au0828_write(dev, REG_001, 0x02);
8b2f0795 DH	268	au0828_write(dev, REG_002, 0x80 \| 0x20 \| 0x10);
	269	au0828_write(dev, REG_000, 0x80 \| 0x40 \| 0x20);
	270
265a6510 ST	271	msleep(250);
	272	break;
	273	case AU0828_BOARD_DVICO_FUSIONHDTV7:
	274	/* GPIO's
	275	* 6 - ?
	276	* 8 - AU8522 Demodulator
	277	* 9 - XC5000 Tuner
	278	*/
	279
	280	/* Into reset */
	281	au0828_write(dev, REG_003, 0x02);
	282	au0828_write(dev, REG_002, 0xa0);
	283	au0828_write(dev, REG_001, 0x0);
	284	au0828_write(dev, REG_000, 0x0);
	285	msleep(100);
	286
	287	/* Out of reset */
	288	au0828_write(dev, REG_003, 0x02);
	289	au0828_write(dev, REG_002, 0xa0);
	290	au0828_write(dev, REG_001, 0x02);
	291	au0828_write(dev, REG_000, 0xa0);
	292	msleep(250);
	293	break;
	294	}
	295	}
	296
	297	/* table of devices that work with this driver */
a8eb912c	298	struct usb_device_id au0828_usb_id_table[] = {
265a6510 ST	299	{ USB_DEVICE(0x2040, 0x7200),
	300	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	301	{ USB_DEVICE(0x2040, 0x7240),
	302	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR850 },
	303	{ USB_DEVICE(0x0fe9, 0xd620),
	304	.driver_info = AU0828_BOARD_DVICO_FUSIONHDTV7 },
104fe9a2 MK	305	{ USB_DEVICE(0x2040, 0x7210),
	306	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	307	{ USB_DEVICE(0x2040, 0x7217),
	308	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	309	{ USB_DEVICE(0x2040, 0x721b),
	310	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
a636da6b MK	311	{ USB_DEVICE(0x2040, 0x721e),
a636da6b MK	312	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
104fe9a2 MK	313	{ USB_DEVICE(0x2040, 0x721f),
	314	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	315	{ USB_DEVICE(0x2040, 0x7280),
	316	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	317	{ USB_DEVICE(0x0fd9, 0x0008),
	318	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
59d27521 MK	319	{ USB_DEVICE(0x2040, 0x7201),
	320	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	321	{ USB_DEVICE(0x2040, 0x7211),
	322	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	323	{ USB_DEVICE(0x2040, 0x7281),
	324	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
8e8bd229 MK	325	{ USB_DEVICE(0x2040, 0x8200),
8e8bd229 MK	326	.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
265a6510 ST	327	{ },
	328	};
	329
	330	MODULE_DEVICE_TABLE(usb, au0828_usb_id_table);