[deliverable/linux.git] / drivers / media / usb / 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_20KHZ,
		.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_20KHZ,
		.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 72101: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
	case 72201: /* WinTV-HVR950q (OEM, 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 72261: /* WinTV-HVR950q (OEM, 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(0x05e1, 0x0480),
		.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
	{ USB_DEVICE(0x2040, 0x8200),
		.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
	{ USB_DEVICE(0x2040, 0x7260),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ USB_DEVICE(0x2040, 0x7213),
		.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	{ },
};

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,
21dc61d3	49	.i2c_clk_divider = AU0828_I2C_CLK_20KHZ,
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 */
21dc61d3	80	.i2c_clk_divider = AU0828_I2C_CLK_20KHZ,
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	164	case 72001: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
6b536a6c MK	165	case 72101: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
6b536a6c MK	166	case 72201: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
62899a28 DH	167	case 72211: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	168	case 72221: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	169	case 72231: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
	170	case 72241: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM and analog video */
	171	case 72251: /* WinTV-HVR950q (Retail, IR, ATSC/QAM and analog video */
6b536a6c	172	case 72261: /* WinTV-HVR950q (OEM, IR, ATSC/QAM and analog video */
62899a28	173	case 72301: /* WinTV-HVR850 (Retail, IR, ATSC and analog video */
104fe9a2	174	case 72500: /* WinTV-HVR950q (OEM, No IR, ATSC/QAM */
28930fa9 ST	175	break;
28930fa9 ST	176	default:
f07e8e4b MK	177	printk(KERN_WARNING "%s: warning: "
f07e8e4b MK	178	"unknown hauppauge model #%d\n", __func__, tv.model);
28930fa9 ST	179	break;
	180	}
	181
f07e8e4b MK	182	printk(KERN_INFO "%s: hauppauge eeprom: model=%d\n",
f07e8e4b MK	183	__func__, tv.model);
28930fa9 ST	184	}
28930fa9 ST	185
28930fa9 ST	186	void au0828_card_setup(struct au0828_dev *dev)
28930fa9 ST	187	{
28930fa9	188	static u8 eeprom[256];
f1add5b5	189	struct tuner_setup tun_setup;
b14667f3	190	struct v4l2_subdev *sd;
ad020dc2	191	unsigned int mode_mask = T_ANALOG_TV;
28930fa9	192
f07e8e4b	193	dprintk(1, "%s()\n", __func__);
bc3c613c	194
f1add5b5 DH	195	memcpy(&dev->board, &au0828_boards[dev->boardnr], sizeof(dev->board));
f1add5b5 DH	196
28930fa9 ST	197	if (dev->i2c_rc == 0) {
	198	dev->i2c_client.addr = 0xa0 >> 1;
	199	tveeprom_read(&dev->i2c_client, eeprom, sizeof(eeprom));
	200	}
	201
f1add5b5	202	switch (dev->boardnr) {
28930fa9 ST	203	case AU0828_BOARD_HAUPPAUGE_HVR850:
28930fa9 ST	204	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
59d27521	205	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
8e8bd229	206	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
28930fa9 ST	207	if (dev->i2c_rc == 0)
	208	hauppauge_eeprom(dev, eeprom+0xa0);
	209	break;
	210	}
f1add5b5	211
220be77c	212	if (AUVI_INPUT(0).type != AU0828_VMUX_UNDEFINED) {
f1add5b5 DH	213	/* Load the analog demodulator driver (note this would need to
	214	be abstracted out if we ever need to support a different
	215	demod) */
e6574f2f	216	sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
9a1f8b34	217	"au8522", 0x8e >> 1, NULL);
62899a28 DH	218	if (sd == NULL)
62899a28 DH	219	printk(KERN_ERR "analog subdev registration failed\n");
f1add5b5 DH	220	}
	221
	222	/* Setup tuners */
	223	if (dev->board.tuner_type != TUNER_ABSENT) {
	224	/* Load the tuner module, which does the attach */
e6574f2f	225	sd = v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
9a1f8b34	226	"tuner", dev->board.tuner_addr, NULL);
62899a28 DH	227	if (sd == NULL)
62899a28 DH	228	printk(KERN_ERR "tuner subdev registration fail\n");
f1add5b5 DH	229
	230	tun_setup.mode_mask = mode_mask;
	231	tun_setup.type = dev->board.tuner_type;
	232	tun_setup.addr = dev->board.tuner_addr;
	233	tun_setup.tuner_callback = au0828_tuner_callback;
2689d3dc DH	234	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr,
2689d3dc DH	235	&tun_setup);
f1add5b5	236	}
28930fa9 ST	237	}
28930fa9 ST	238
265a6510 ST	239	/*
	240	* The bridge has between 8 and 12 gpios.
	241	* Regs 1 and 0 deal with output enables.
a9c36aad	242	* Regs 3 and 2 deal with direction.
265a6510 ST	243	*/
	244	void au0828_gpio_setup(struct au0828_dev *dev)
	245	{
f07e8e4b	246	dprintk(1, "%s()\n", __func__);
bc3c613c	247
f1add5b5	248	switch (dev->boardnr) {
265a6510 ST	249	case AU0828_BOARD_HAUPPAUGE_HVR850:
265a6510 ST	250	case AU0828_BOARD_HAUPPAUGE_HVR950Q:
59d27521	251	case AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL:
8e8bd229	252	case AU0828_BOARD_HAUPPAUGE_WOODBURY:
265a6510 ST	253	/* GPIO's
	254	* 4 - CS5340
	255	* 5 - AU8522 Demodulator
	256	* 6 - eeprom W/P
8b2f0795	257	* 7 - power supply
265a6510 ST	258	* 9 - XC5000 Tuner
	259	*/
	260
	261	/* Into reset */
	262	au0828_write(dev, REG_003, 0x02);
8b2f0795	263	au0828_write(dev, REG_002, 0x80 \| 0x20 \| 0x10);
265a6510 ST	264	au0828_write(dev, REG_001, 0x0);
	265	au0828_write(dev, REG_000, 0x0);
	266	msleep(100);
	267
8b2f0795	268	/* Out of reset (leave the cs5340 in reset until needed) */
265a6510 ST	269	au0828_write(dev, REG_003, 0x02);
265a6510 ST	270	au0828_write(dev, REG_001, 0x02);
8b2f0795 DH	271	au0828_write(dev, REG_002, 0x80 \| 0x20 \| 0x10);
	272	au0828_write(dev, REG_000, 0x80 \| 0x40 \| 0x20);
	273
265a6510 ST	274	msleep(250);
	275	break;
	276	case AU0828_BOARD_DVICO_FUSIONHDTV7:
	277	/* GPIO's
	278	* 6 - ?
	279	* 8 - AU8522 Demodulator
	280	* 9 - XC5000 Tuner
	281	*/
	282
	283	/* Into reset */
	284	au0828_write(dev, REG_003, 0x02);
	285	au0828_write(dev, REG_002, 0xa0);
	286	au0828_write(dev, REG_001, 0x0);
	287	au0828_write(dev, REG_000, 0x0);
	288	msleep(100);
	289
	290	/* Out of reset */
	291	au0828_write(dev, REG_003, 0x02);
	292	au0828_write(dev, REG_002, 0xa0);
	293	au0828_write(dev, REG_001, 0x02);
	294	au0828_write(dev, REG_000, 0xa0);
	295	msleep(250);
	296	break;
	297	}
	298	}
	299
	300	/* table of devices that work with this driver */
a8eb912c	301	struct usb_device_id au0828_usb_id_table[] = {
265a6510 ST	302	{ USB_DEVICE(0x2040, 0x7200),
	303	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	304	{ USB_DEVICE(0x2040, 0x7240),
	305	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR850 },
	306	{ USB_DEVICE(0x0fe9, 0xd620),
	307	.driver_info = AU0828_BOARD_DVICO_FUSIONHDTV7 },
104fe9a2 MK	308	{ USB_DEVICE(0x2040, 0x7210),
	309	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	310	{ USB_DEVICE(0x2040, 0x7217),
	311	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	312	{ USB_DEVICE(0x2040, 0x721b),
	313	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
a636da6b MK	314	{ USB_DEVICE(0x2040, 0x721e),
a636da6b MK	315	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
104fe9a2 MK	316	{ USB_DEVICE(0x2040, 0x721f),
	317	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	318	{ USB_DEVICE(0x2040, 0x7280),
	319	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
	320	{ USB_DEVICE(0x0fd9, 0x0008),
	321	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
59d27521 MK	322	{ USB_DEVICE(0x2040, 0x7201),
	323	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	324	{ USB_DEVICE(0x2040, 0x7211),
	325	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
	326	{ USB_DEVICE(0x2040, 0x7281),
	327	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q_MXL },
e2b710bf IL	328	{ USB_DEVICE(0x05e1, 0x0480),
e2b710bf IL	329	.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
8e8bd229 MK	330	{ USB_DEVICE(0x2040, 0x8200),
8e8bd229 MK	331	.driver_info = AU0828_BOARD_HAUPPAUGE_WOODBURY },
23bbba34 MK	332	{ USB_DEVICE(0x2040, 0x7260),
23bbba34 MK	333	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
64a6b6cb MK	334	{ USB_DEVICE(0x2040, 0x7213),
64a6b6cb MK	335	.driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
265a6510 ST	336	{ },
	337	};
	338
	339	MODULE_DEVICE_TABLE(usb, au0828_usb_id_table);