[net-next-2.6.git] / drivers / staging / tm6000 / tm6000-cards.c

/*
   tm6000-cards.c - driver for TM5600/TM6000 USB video capture devices

   Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.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 version 2

   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 <linux/init.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/usb.h>
#include <linux/version.h>
#include <media/v4l2-common.h>
#include <media/tuner.h>
#include <media/tvaudio.h>
#include <media/i2c-addr.h>

#include "tm6000.h"
#include "tm6000-regs.h"
#include "tuner-xc2028.h"
#include "xc5000.h"

#define TM6000_BOARD_UNKNOWN			0
#define TM5600_BOARD_GENERIC			1
#define TM6000_BOARD_GENERIC			2
#define TM6010_BOARD_GENERIC			3
#define TM5600_BOARD_10MOONS_UT821		4
#define TM5600_BOARD_10MOONS_UT330		5
#define TM6000_BOARD_ADSTECH_DUAL_TV		6
#define TM6000_BOARD_FREECOM_AND_SIMILAR	7
#define TM6000_BOARD_ADSTECH_MINI_DUAL_TV	8
#define TM6010_BOARD_HAUPPAUGE_900H		9
#define TM6010_BOARD_BEHOLD_WANDER		10
#define TM6010_BOARD_BEHOLD_VOYAGER		11
#define TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE	12

#define TM6000_MAXBOARDS        16
static unsigned int card[]     = {[0 ... (TM6000_MAXBOARDS - 1)] = UNSET };

module_param_array(card,  int, NULL, 0444);

static unsigned long tm6000_devused;


struct tm6000_board {
	char            *name;

	struct tm6000_capabilities caps;

	enum		tm6000_devtype type;	/* variant of the chipset */
	int             tuner_type;     /* type of the tuner */
	int             tuner_addr;     /* tuner address */
	int             demod_addr;     /* demodulator address */
	int		gpio_addr_tun_reset;	/* GPIO used for tuner reset */
};

struct tm6000_board tm6000_boards[] = {
	[TM6000_BOARD_UNKNOWN] = {
		.name         = "Unknown tm6000 video grabber",
		.caps = {
			.has_tuner    = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_1,
	},
	[TM5600_BOARD_GENERIC] = {
		.name         = "Generic tm5600 board",
		.type         = TM5600,
		.tuner_type   = TUNER_XC2028,
		.tuner_addr   = 0xc2 >> 1,
		.caps = {
			.has_tuner	= 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_1,
	},
	[TM6000_BOARD_GENERIC] = {
		.name         = "Generic tm6000 board",
		.tuner_type   = TUNER_XC2028,
		.tuner_addr   = 0xc2 >> 1,
		.caps = {
			.has_tuner	= 1,
			.has_dvb	= 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_1,
	},
	[TM6010_BOARD_GENERIC] = {
		.name         = "Generic tm6010 board",
		.type         = TM6010,
		.tuner_type   = TUNER_XC2028,
		.tuner_addr   = 0xc2 >> 1,
		.caps = {
			.has_tuner	= 1,
			.has_dvb	= 1,
		},
		.gpio_addr_tun_reset = TM6010_GPIO_4,
	},
	[TM5600_BOARD_10MOONS_UT821] = {
		.name         = "10Moons UT 821",
		.tuner_type   = TUNER_XC2028,
		.type         = TM5600,
		.tuner_addr   = 0xc2 >> 1,
		.caps = {
			.has_tuner    = 1,
			.has_eeprom   = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_1,
	},
	[TM5600_BOARD_10MOONS_UT330] = {
		.name         = "10Moons UT 330",
		.tuner_type   = TUNER_PHILIPS_FQ1216AME_MK4,
		.tuner_addr   = 0xc8 >> 1,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 0,
			.has_zl10353  = 0,
			.has_eeprom   = 1,
		},
	},
	[TM6000_BOARD_ADSTECH_DUAL_TV] = {
		.name         = "ADSTECH Dual TV USB",
		.tuner_type   = TUNER_XC2028,
		.tuner_addr   = 0xc8 >> 1,
		.caps = {
			.has_tuner    = 1,
			.has_tda9874  = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 1,
		},
	},
	[TM6000_BOARD_FREECOM_AND_SIMILAR] = {
		.name         = "Freecom Hybrid Stick / Moka DVB-T Receiver Dual",
		.tuner_type   = TUNER_XC2028, /* has a XC3028 */
		.tuner_addr   = 0xc2 >> 1,
		.demod_addr   = 0x1e >> 1,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 0,
			.has_remote   = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_4,
	},
	[TM6000_BOARD_ADSTECH_MINI_DUAL_TV] = {
		.name         = "ADSTECH Mini Dual TV USB",
		.tuner_type   = TUNER_XC2028, /* has a XC3028 */
		.tuner_addr   = 0xc8 >> 1,
		.demod_addr   = 0x1e >> 1,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 0,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_4,
	},
	[TM6010_BOARD_HAUPPAUGE_900H] = {
		.name         = "Hauppauge HVR-900H",
		.tuner_type   = TUNER_XC2028, /* has a XC3028 */
		.tuner_addr   = 0xc2 >> 1,
		.demod_addr   = 0x1e >> 1,
		.type         = TM6010,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_2,
	},
	[TM6010_BOARD_BEHOLD_WANDER] = {
		.name         = "Beholder Wander DVB-T/TV/FM USB2.0",
		.tuner_type   = TUNER_XC5000,
		.tuner_addr   = 0xc2 >> 1,
		.demod_addr   = 0x1e >> 1,
		.type         = TM6010,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 1,
			.has_remote   = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_2,
	},
	[TM6010_BOARD_BEHOLD_VOYAGER] = {
		.name         = "Beholder Voyager TV/FM USB2.0",
		.tuner_type   = TUNER_XC5000,
		.tuner_addr   = 0xc2 >> 1,
		.type         = TM6010,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 0,
			.has_zl10353  = 0,
			.has_eeprom   = 1,
			.has_remote   = 1,
		},
		.gpio_addr_tun_reset = TM6000_GPIO_2,
	},
	[TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE] = {
		.name         = "Terratec Cinergy Hybrid XE",
		.tuner_type   = TUNER_XC2028, /* has a XC3028 */
		.tuner_addr   = 0xc2 >> 1,
		.demod_addr   = 0x1e >> 1,
		.type         = TM6010,
		.caps = {
			.has_tuner    = 1,
			.has_dvb      = 1,
			.has_zl10353  = 1,
			.has_eeprom   = 1,
			.has_remote   = 1,
		},
		.gpio_addr_tun_reset = TM6010_GPIO_2,
	}
};

/* table of devices that work with this driver */
struct usb_device_id tm6000_id_table [] = {
	{ USB_DEVICE(0x6000, 0x0001), .driver_info = TM5600_BOARD_10MOONS_UT821 },
	{ USB_DEVICE(0x6000, 0x0002), .driver_info = TM6010_BOARD_GENERIC },
	{ USB_DEVICE(0x06e1, 0xf332), .driver_info = TM6000_BOARD_ADSTECH_DUAL_TV },
	{ USB_DEVICE(0x14aa, 0x0620), .driver_info = TM6000_BOARD_FREECOM_AND_SIMILAR },
	{ USB_DEVICE(0x06e1, 0xb339), .driver_info = TM6000_BOARD_ADSTECH_MINI_DUAL_TV },
	{ USB_DEVICE(0x2040, 0x6600), .driver_info = TM6010_BOARD_HAUPPAUGE_900H },
	{ USB_DEVICE(0x6000, 0xdec0), .driver_info = TM6010_BOARD_BEHOLD_WANDER },
	{ USB_DEVICE(0x6000, 0xdec1), .driver_info = TM6010_BOARD_BEHOLD_VOYAGER },
	{ USB_DEVICE(0x0ccd, 0x0086), .driver_info = TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE },
	{ },
};

/* Tuner callback to provide the proper gpio changes needed for xc2028 */

static int tm6000_tuner_callback(void *ptr, int component, int command, int arg)
{
	int rc=0;
	struct tm6000_core *dev = ptr;

	if (dev->tuner_type!=TUNER_XC2028)
		return 0;

	switch (command) {
	case XC2028_RESET_CLK:
		tm6000_set_reg (dev, REQ_04_EN_DISABLE_MCU_INT,
					0x02, arg);
		msleep(10);
		rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
					TM6000_GPIO_CLK, 0);
		if (rc<0)
			return rc;
		msleep(10);
		rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
					TM6000_GPIO_CLK, 1);
		break;
	case XC2028_TUNER_RESET:
		/* Reset codes during load firmware */
		switch (arg) {
		case 0:
			tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
					dev->tuner_reset_gpio, 0x00);
			msleep(130);
			tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
					dev->tuner_reset_gpio, 0x01);
			msleep(130);
			break;
		case 1:
			tm6000_set_reg (dev, REQ_04_EN_DISABLE_MCU_INT,
						0x02, 0x01);
			msleep(10);
			break;

		case 2:
			rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
						TM6000_GPIO_CLK, 0);
			if (rc<0)
				return rc;
			msleep(100);
			rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
						TM6000_GPIO_CLK, 1);
			msleep(100);
			break;
		}
	}
	return (rc);
}

static void tm6000_config_tuner (struct tm6000_core *dev)
{
	struct tuner_setup           tun_setup;

	/* Load tuner module */
	v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
		"tuner", "tuner",dev->tuner_addr, NULL);

	memset(&tun_setup, 0, sizeof(tun_setup));
	tun_setup.type   = dev->tuner_type;
	tun_setup.addr   = dev->tuner_addr;
	tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
	tun_setup.tuner_callback = tm6000_tuner_callback;

	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);

	if (dev->tuner_type == TUNER_XC2028) {
		struct v4l2_priv_tun_config  xc2028_cfg;
		struct xc2028_ctrl           ctl;

		memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
		memset (&ctl,0,sizeof(ctl));

		ctl.mts   = 1;
		ctl.read_not_reliable = 1;
		ctl.msleep = 10;

		xc2028_cfg.tuner = TUNER_XC2028;
		xc2028_cfg.priv  = &ctl;

		switch(dev->model) {
		case TM6010_BOARD_HAUPPAUGE_900H:
		case TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE:
			ctl.fname = "xc3028L-v36.fw";
			break;
		default:
			if (dev->dev_type == TM6010)
				ctl.fname = "xc3028-v27.fw";
			else
				ctl.fname = "tm6000-xc3028.fw";
		}

		printk(KERN_INFO "Setting firmware parameters for xc2028\n");

		v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config,
				     &xc2028_cfg);
	}
}

static int tm6000_init_dev(struct tm6000_core *dev)
{
	struct v4l2_frequency f;
	int rc = 0;

	mutex_init(&dev->lock);

	mutex_lock(&dev->lock);

	/* Initializa board-specific data */
	dev->dev_type   = tm6000_boards[dev->model].type;
	dev->tuner_type = tm6000_boards[dev->model].tuner_type;
	dev->tuner_addr = tm6000_boards[dev->model].tuner_addr;
	dev->tuner_reset_gpio = tm6000_boards[dev->model].gpio_addr_tun_reset;

	dev->demod_addr = tm6000_boards[dev->model].demod_addr;

	dev->caps = tm6000_boards[dev->model].caps;

	/* initialize hardware */
	rc=tm6000_init (dev);
	if (rc<0)
		goto err;

	rc = v4l2_device_register(&dev->udev->dev, &dev->v4l2_dev);
	if (rc < 0)
		goto err;

	/* register i2c bus */
	rc=tm6000_i2c_register(dev);
	if (rc<0)
		goto err;

	/* register and initialize V4L2 */
	rc=tm6000_v4l2_register(dev);
	if (rc<0)
		goto err;

	/* Default values for STD and resolutions */
	dev->width = 720;
	dev->height = 480;
	dev->norm = V4L2_STD_PAL_M;

	/* Configure tuner */
	tm6000_config_tuner (dev);

	/* Set video standard */
	v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);

	/* Set tuner frequency - also loads firmware on xc2028/xc3028 */
	f.tuner = 0;
	f.type = V4L2_TUNER_ANALOG_TV;
	f.frequency = 3092;	/* 193.25 MHz */
	dev->freq = f.frequency;
	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);

	if (dev->caps.has_tda9874)
		v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
			"tvaudio", "tvaudio", I2C_ADDR_TDA9874, NULL);

	if(dev->caps.has_dvb) {
		dev->dvb = kzalloc(sizeof(*(dev->dvb)), GFP_KERNEL);
		if(!dev->dvb) {
			rc = -ENOMEM;
			goto err2;
		}
#ifdef CONFIG_VIDEO_TM6000_DVB
		rc = tm6000_dvb_register(dev);
		if(rc < 0) {
			kfree(dev->dvb);
			dev->dvb = NULL;
			goto err2;
		}
#endif
	}
	return 0;

err2:
	v4l2_device_unregister(&dev->v4l2_dev);

err:
	mutex_unlock(&dev->lock);
	return rc;
}

/* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
#define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))

static void get_max_endpoint (  struct usb_device *usbdev,
				char *msgtype,
				struct usb_host_endpoint *curr_e,
				unsigned int *maxsize,
				struct usb_host_endpoint **ep  )
{
	u16 tmp = le16_to_cpu(curr_e->desc.wMaxPacketSize);
	unsigned int size = tmp & 0x7ff;

	if (usbdev->speed == USB_SPEED_HIGH)
		size = size * hb_mult (tmp);

	if (size>*maxsize) {
		*ep = curr_e;
		*maxsize = size;
		printk("tm6000: %s endpoint: 0x%02x (max size=%u bytes)\n",
					msgtype, curr_e->desc.bEndpointAddress,
					size);
	}
}

/*
 * tm6000_usb_probe()
 * checks for supported devices
 */
static int tm6000_usb_probe(struct usb_interface *interface,
			    const struct usb_device_id *id)
{
	struct usb_device *usbdev;
	struct tm6000_core *dev = NULL;
	int i,rc=0;
	int nr=0;
	char *speed;


	usbdev=usb_get_dev(interface_to_usbdev(interface));

	/* Selects the proper interface */
	rc=usb_set_interface(usbdev,0,1);
	if (rc<0)
		goto err;

	/* Check to see next free device and mark as used */
	nr=find_first_zero_bit(&tm6000_devused,TM6000_MAXBOARDS);
	if (nr >= TM6000_MAXBOARDS) {
		printk ("tm6000: Supports only %i tm60xx boards.\n",TM6000_MAXBOARDS);
		usb_put_dev(usbdev);
		return -ENOMEM;
	}

	/* Create and initialize dev struct */
	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (dev == NULL) {
		printk ("tm6000" ": out of memory!\n");
		usb_put_dev(usbdev);
		return -ENOMEM;
	}
	spin_lock_init(&dev->slock);

	/* Increment usage count */
	tm6000_devused|=1<<nr;
	snprintf(dev->name, 29, "tm6000 #%d", nr);

	dev->model=id->driver_info;
	if ((card[nr]>=0) && (card[nr]<ARRAY_SIZE(tm6000_boards))) {
		dev->model=card[nr];
	}

	INIT_LIST_HEAD(&dev->tm6000_corelist);
	dev->udev= usbdev;
	dev->devno=nr;

	switch (usbdev->speed) {
	case USB_SPEED_LOW:
		speed = "1.5";
		break;
	case USB_SPEED_UNKNOWN:
	case USB_SPEED_FULL:
		speed = "12";
		break;
	case USB_SPEED_HIGH:
		speed = "480";
		break;
	default:
		speed = "unknown";
	}


	/* Get endpoints */
	for (i = 0; i < interface->num_altsetting; i++) {
		int ep;

		for (ep = 0; ep < interface->altsetting[i].desc.bNumEndpoints; ep++) {
			struct usb_host_endpoint	*e;
			int dir_out;

			e = &interface->altsetting[i].endpoint[ep];

			dir_out = ((e->desc.bEndpointAddress &
					USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);

			printk("tm6000: alt %d, interface %i, class %i\n",
			       i,
			       interface->altsetting[i].desc.bInterfaceNumber,
			       interface->altsetting[i].desc.bInterfaceClass);

			switch (e->desc.bmAttributes) {
			case USB_ENDPOINT_XFER_BULK:
				if (!dir_out) {
					get_max_endpoint (usbdev, "Bulk IN", e,
							&dev->max_bulk_in,
							&dev->bulk_in);
				} else {
					get_max_endpoint (usbdev, "Bulk OUT", e,
							&dev->max_bulk_out,
							&dev->bulk_out);
				}
				break;
			case USB_ENDPOINT_XFER_ISOC:
				if (!dir_out) {
					get_max_endpoint (usbdev, "ISOC IN", e,
							&dev->max_isoc_in,
							&dev->isoc_in);
				} else {
					get_max_endpoint (usbdev, "ISOC OUT", e,
							&dev->max_isoc_out,
							&dev->isoc_out);
				}
				break;
			}
		}
	}


	printk("tm6000: New video device @ %s Mbps (%04x:%04x, ifnum %d)\n",
		speed,
		le16_to_cpu(dev->udev->descriptor.idVendor),
		le16_to_cpu(dev->udev->descriptor.idProduct),
		interface->altsetting->desc.bInterfaceNumber);

/* check if the the device has the iso in endpoint at the correct place */
	if (!dev->isoc_in) {
		printk("tm6000: probing error: no IN ISOC endpoint!\n");
		rc= -ENODEV;

		goto err;
	}

	/* save our data pointer in this interface device */
	usb_set_intfdata(interface, dev);

	printk("tm6000: Found %s\n", tm6000_boards[dev->model].name);

	rc=tm6000_init_dev(dev);

	if (rc<0)
		goto err;

	return 0;

err:
	printk("tm6000: Error %d while registering\n", rc);

	tm6000_devused&=~(1<<nr);
	usb_put_dev(usbdev);

	kfree(dev);
	return rc;
}

/*
 * tm6000_usb_disconnect()
 * called when the device gets diconencted
 * video device will be unregistered on v4l2_close in case it is still open
 */
static void tm6000_usb_disconnect(struct usb_interface *interface)
{
	struct tm6000_core *dev = usb_get_intfdata(interface);
	usb_set_intfdata(interface, NULL);

	if (!dev)
		return;

	printk("tm6000: disconnecting %s\n", dev->name);

	mutex_lock(&dev->lock);

#ifdef CONFIG_VIDEO_TM6000_DVB
	if(dev->dvb) {
		tm6000_dvb_unregister(dev);
		kfree(dev->dvb);
	}
#endif

	tm6000_v4l2_unregister(dev);

	tm6000_i2c_unregister(dev);

	v4l2_device_unregister(&dev->v4l2_dev);

//	wake_up_interruptible_all(&dev->open);

	dev->state |= DEV_DISCONNECTED;

	usb_put_dev(dev->udev);

	mutex_unlock(&dev->lock);
	kfree(dev);
}

static struct usb_driver tm6000_usb_driver = {
		.name = "tm6000",
		.probe = tm6000_usb_probe,
		.disconnect = tm6000_usb_disconnect,
		.id_table = tm6000_id_table,
};

static int __init tm6000_module_init(void)
{
	int result;

	printk(KERN_INFO "tm6000" " v4l2 driver version %d.%d.%d loaded\n",
	       (TM6000_VERSION  >> 16) & 0xff,
	       (TM6000_VERSION  >> 8) & 0xff, TM6000_VERSION  & 0xff);

	/* register this driver with the USB subsystem */
	result = usb_register(&tm6000_usb_driver);
	if (result)
		printk("tm6000"
			   " usb_register failed. Error number %d.\n", result);

	return result;
}

static void __exit tm6000_module_exit(void)
{
	/* deregister at USB subsystem */
	usb_deregister(&tm6000_usb_driver);
}

module_init(tm6000_module_init);
module_exit(tm6000_module_exit);

MODULE_DESCRIPTION("Trident TVMaster TM5600/TM6000 USB2 adapter");
MODULE_AUTHOR("Mauro Carvalho Chehab");
MODULE_LICENSE("GPL");
Commit	Line	Data
9701dc94 MCC	1	/*
	2	tm6000-cards.c - driver for TM5600/TM6000 USB video capture devices
	3
	4	Copyright (C) 2006-2007 Mauro Carvalho Chehab <mchehab@infradead.org>
	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 version 2
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	18	*/
	19
	20	#include <linux/init.h>
	21	#include <linux/module.h>
	22	#include <linux/pci.h>
	23	#include <linux/delay.h>
	24	#include <linux/i2c.h>
	25	#include <linux/usb.h>
	26	#include <linux/version.h>
	27	#include <media/v4l2-common.h>
	28	#include <media/tuner.h>
427f7fac MCC	29	#include <media/tvaudio.h>
427f7fac MCC	30	#include <media/i2c-addr.h>
9701dc94 MCC	31
9701dc94 MCC	32	#include "tm6000.h"
c85cba3f	33	#include "tm6000-regs.h"
d544f2c3	34	#include "tuner-xc2028.h"
7dcc51b7	35	#include "xc5000.h"
9701dc94	36
0ec4acc6 ML	37	#define TM6000_BOARD_UNKNOWN 0
	38	#define TM5600_BOARD_GENERIC 1
	39	#define TM6000_BOARD_GENERIC 2
29c389be MCC	40	#define TM6010_BOARD_GENERIC 3
	41	#define TM5600_BOARD_10MOONS_UT821 4
	42	#define TM5600_BOARD_10MOONS_UT330 5
	43	#define TM6000_BOARD_ADSTECH_DUAL_TV 6
	44	#define TM6000_BOARD_FREECOM_AND_SIMILAR 7
	45	#define TM6000_BOARD_ADSTECH_MINI_DUAL_TV 8
df7c1d9a	46	#define TM6010_BOARD_HAUPPAUGE_900H 9
9d3aeb5f MCC	47	#define TM6010_BOARD_BEHOLD_WANDER 10
9d3aeb5f MCC	48	#define TM6010_BOARD_BEHOLD_VOYAGER 11
04574a68	49	#define TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE 12
0ec4acc6	50
9701dc94 MCC	51	#define TM6000_MAXBOARDS 16
	52	static unsigned int card[] = {[0 ... (TM6000_MAXBOARDS - 1)] = UNSET };
	53
	54	module_param_array(card, int, NULL, 0444);
	55
7f9b1412 MCC	56	static unsigned long tm6000_devused;
7f9b1412 MCC	57
c85cba3f	58
9701dc94 MCC	59	struct tm6000_board {
	60	char *name;
	61
	62	struct tm6000_capabilities caps;
	63
29c389be	64	enum tm6000_devtype type; /* variant of the chipset */
9701dc94 MCC	65	int tuner_type; /* type of the tuner */
9701dc94 MCC	66	int tuner_addr; /* tuner address */
95a83824 ML	67	int demod_addr; /* demodulator address */
95a83824 ML	68	int gpio_addr_tun_reset; /* GPIO used for tuner reset */
9701dc94 MCC	69	};
9701dc94 MCC	70
9701dc94 MCC	71	struct tm6000_board tm6000_boards[] = {
	72	[TM6000_BOARD_UNKNOWN] = {
	73	.name = "Unknown tm6000 video grabber",
	74	.caps = {
	75	.has_tuner = 1,
	76	},
c85cba3f	77	.gpio_addr_tun_reset = TM6000_GPIO_1,
9701dc94 MCC	78	},
	79	[TM5600_BOARD_GENERIC] = {
	80	.name = "Generic tm5600 board",
29c389be	81	.type = TM5600,
9701dc94	82	.tuner_type = TUNER_XC2028,
1fade8d9	83	.tuner_addr = 0xc2 >> 1,
9701dc94 MCC	84	.caps = {
	85	.has_tuner = 1,
	86	},
c85cba3f	87	.gpio_addr_tun_reset = TM6000_GPIO_1,
9701dc94 MCC	88	},
	89	[TM6000_BOARD_GENERIC] = {
	90	.name = "Generic tm6000 board",
	91	.tuner_type = TUNER_XC2028,
1fade8d9	92	.tuner_addr = 0xc2 >> 1,
9701dc94 MCC	93	.caps = {
	94	.has_tuner = 1,
	95	.has_dvb = 1,
	96	},
c85cba3f	97	.gpio_addr_tun_reset = TM6000_GPIO_1,
9701dc94	98	},
29c389be MCC	99	[TM6010_BOARD_GENERIC] = {
	100	.name = "Generic tm6010 board",
	101	.type = TM6010,
	102	.tuner_type = TUNER_XC2028,
1fade8d9	103	.tuner_addr = 0xc2 >> 1,
29c389be MCC	104	.caps = {
	105	.has_tuner = 1,
	106	.has_dvb = 1,
	107	},
	108	.gpio_addr_tun_reset = TM6010_GPIO_4,
	109	},
9701dc94 MCC	110	[TM5600_BOARD_10MOONS_UT821] = {
	111	.name = "10Moons UT 821",
	112	.tuner_type = TUNER_XC2028,
29c389be	113	.type = TM5600,
1fade8d9	114	.tuner_addr = 0xc2 >> 1,
9701dc94 MCC	115	.caps = {
	116	.has_tuner = 1,
	117	.has_eeprom = 1,
	118	},
c85cba3f	119	.gpio_addr_tun_reset = TM6000_GPIO_1,
9701dc94	120	},
95a83824	121	[TM5600_BOARD_10MOONS_UT330] = {
9701dc94	122	.name = "10Moons UT 330",
95a83824	123	.tuner_type = TUNER_PHILIPS_FQ1216AME_MK4,
1fade8d9	124	.tuner_addr = 0xc8 >> 1,
9701dc94 MCC	125	.caps = {
9701dc94 MCC	126	.has_tuner = 1,
95a83824 ML	127	.has_dvb = 0,
95a83824 ML	128	.has_zl10353 = 0,
9701dc94 MCC	129	.has_eeprom = 1,
	130	},
	131	},
	132	[TM6000_BOARD_ADSTECH_DUAL_TV] = {
	133	.name = "ADSTECH Dual TV USB",
	134	.tuner_type = TUNER_XC2028,
1fade8d9	135	.tuner_addr = 0xc8 >> 1,
9701dc94 MCC	136	.caps = {
	137	.has_tuner = 1,
	138	.has_tda9874 = 1,
	139	.has_dvb = 1,
	140	.has_zl10353 = 1,
	141	.has_eeprom = 1,
	142	},
	143	},
0ec4acc6 ML	144	[TM6000_BOARD_FREECOM_AND_SIMILAR] = {
0ec4acc6 ML	145	.name = "Freecom Hybrid Stick / Moka DVB-T Receiver Dual",
4386136d	146	.tuner_type = TUNER_XC2028, /* has a XC3028 */
1fade8d9 MCC	147	.tuner_addr = 0xc2 >> 1,
1fade8d9 MCC	148	.demod_addr = 0x1e >> 1,
4386136d ML	149	.caps = {
	150	.has_tuner = 1,
	151	.has_dvb = 1,
	152	.has_zl10353 = 1,
	153	.has_eeprom = 0,
	154	.has_remote = 1,
	155	},
	156	.gpio_addr_tun_reset = TM6000_GPIO_4,
	157	},
	158	[TM6000_BOARD_ADSTECH_MINI_DUAL_TV] = {
	159	.name = "ADSTECH Mini Dual TV USB",
	160	.tuner_type = TUNER_XC2028, /* has a XC3028 */
1fade8d9 MCC	161	.tuner_addr = 0xc8 >> 1,
1fade8d9 MCC	162	.demod_addr = 0x1e >> 1,
0ec4acc6 ML	163	.caps = {
	164	.has_tuner = 1,
	165	.has_dvb = 1,
	166	.has_zl10353 = 1,
	167	.has_eeprom = 0,
	168	},
95a83824	169	.gpio_addr_tun_reset = TM6000_GPIO_4,
0ec4acc6	170	},
df7c1d9a MCC	171	[TM6010_BOARD_HAUPPAUGE_900H] = {
	172	.name = "Hauppauge HVR-900H",
	173	.tuner_type = TUNER_XC2028, /* has a XC3028 */
1fade8d9 MCC	174	.tuner_addr = 0xc2 >> 1,
1fade8d9 MCC	175	.demod_addr = 0x1e >> 1,
df7c1d9a MCC	176	.type = TM6010,
	177	.caps = {
	178	.has_tuner = 1,
	179	.has_dvb = 1,
	180	.has_zl10353 = 1,
	181	.has_eeprom = 1,
	182	},
	183	.gpio_addr_tun_reset = TM6000_GPIO_2,
	184	},
1eefd763 DB	185	[TM6010_BOARD_BEHOLD_WANDER] = {
	186	.name = "Beholder Wander DVB-T/TV/FM USB2.0",
	187	.tuner_type = TUNER_XC5000,
	188	.tuner_addr = 0xc2 >> 1,
	189	.demod_addr = 0x1e >> 1,
	190	.type = TM6010,
	191	.caps = {
	192	.has_tuner = 1,
	193	.has_dvb = 1,
	194	.has_zl10353 = 1,
	195	.has_eeprom = 1,
	196	.has_remote = 1,
	197	},
	198	.gpio_addr_tun_reset = TM6000_GPIO_2,
	199	},
	200	[TM6010_BOARD_BEHOLD_VOYAGER] = {
	201	.name = "Beholder Voyager TV/FM USB2.0",
	202	.tuner_type = TUNER_XC5000,
	203	.tuner_addr = 0xc2 >> 1,
	204	.type = TM6010,
	205	.caps = {
	206	.has_tuner = 1,
	207	.has_dvb = 0,
	208	.has_zl10353 = 0,
	209	.has_eeprom = 1,
	210	.has_remote = 1,
	211	},
	212	.gpio_addr_tun_reset = TM6000_GPIO_2,
	213	},
04574a68 MCC	214	[TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE] = {
	215	.name = "Terratec Cinergy Hybrid XE",
	216	.tuner_type = TUNER_XC2028, /* has a XC3028 */
	217	.tuner_addr = 0xc2 >> 1,
	218	.demod_addr = 0x1e >> 1,
	219	.type = TM6010,
	220	.caps = {
	221	.has_tuner = 1,
	222	.has_dvb = 1,
	223	.has_zl10353 = 1,
	224	.has_eeprom = 1,
	225	.has_remote = 1,
	226	},
	227	.gpio_addr_tun_reset = TM6010_GPIO_2,
	228	}
9701dc94 MCC	229	};
	230
	231	/* table of devices that work with this driver */
	232	struct usb_device_id tm6000_id_table [] = {
	233	{ USB_DEVICE(0x6000, 0x0001), .driver_info = TM5600_BOARD_10MOONS_UT821 },
29c389be	234	{ USB_DEVICE(0x6000, 0x0002), .driver_info = TM6010_BOARD_GENERIC },
9701dc94	235	{ USB_DEVICE(0x06e1, 0xf332), .driver_info = TM6000_BOARD_ADSTECH_DUAL_TV },
c85cba3f	236	{ USB_DEVICE(0x14aa, 0x0620), .driver_info = TM6000_BOARD_FREECOM_AND_SIMILAR },
4386136d	237	{ USB_DEVICE(0x06e1, 0xb339), .driver_info = TM6000_BOARD_ADSTECH_MINI_DUAL_TV },
df7c1d9a	238	{ USB_DEVICE(0x2040, 0x6600), .driver_info = TM6010_BOARD_HAUPPAUGE_900H },
1eefd763 DB	239	{ USB_DEVICE(0x6000, 0xdec0), .driver_info = TM6010_BOARD_BEHOLD_WANDER },
1eefd763 DB	240	{ USB_DEVICE(0x6000, 0xdec1), .driver_info = TM6010_BOARD_BEHOLD_VOYAGER },
04574a68	241	{ USB_DEVICE(0x0ccd, 0x0086), .driver_info = TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE },
9701dc94 MCC	242	{ },
	243	};
	244
64d339d4 MCC	245	/* Tuner callback to provide the proper gpio changes needed for xc2028 */
	246
	247	static int tm6000_tuner_callback(void *ptr, int component, int command, int arg)
	248	{
	249	int rc=0;
	250	struct tm6000_core *dev = ptr;
	251
	252	if (dev->tuner_type!=TUNER_XC2028)
	253	return 0;
	254
	255	switch (command) {
	256	case XC2028_RESET_CLK:
	257	tm6000_set_reg (dev, REQ_04_EN_DISABLE_MCU_INT,
	258	0x02, arg);
	259	msleep(10);
	260	rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	261	TM6000_GPIO_CLK, 0);
	262	if (rc<0)
	263	return rc;
	264	msleep(10);
	265	rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	266	TM6000_GPIO_CLK, 1);
	267	break;
	268	case XC2028_TUNER_RESET:
	269	/* Reset codes during load firmware */
	270	switch (arg) {
	271	case 0:
	272	tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	273	dev->tuner_reset_gpio, 0x00);
	274	msleep(130);
	275	tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	276	dev->tuner_reset_gpio, 0x01);
	277	msleep(130);
	278	break;
	279	case 1:
	280	tm6000_set_reg (dev, REQ_04_EN_DISABLE_MCU_INT,
	281	0x02, 0x01);
	282	msleep(10);
	283	break;
	284
	285	case 2:
	286	rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	287	TM6000_GPIO_CLK, 0);
	288	if (rc<0)
	289	return rc;
	290	msleep(100);
	291	rc=tm6000_set_reg (dev, REQ_03_SET_GET_MCU_PIN,
	292	TM6000_GPIO_CLK, 1);
	293	msleep(100);
	294	break;
	295	}
	296	}
	297	return (rc);
	298	}
	299
d544f2c3 MCC	300	static void tm6000_config_tuner (struct tm6000_core *dev)
d544f2c3 MCC	301	{
427f7fac MCC	302	struct tuner_setup tun_setup;
	303
	304	/* Load tuner module */
	305	v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
	306	"tuner", "tuner",dev->tuner_addr, NULL);
	307
	308	memset(&tun_setup, 0, sizeof(tun_setup));
	309	tun_setup.type = dev->tuner_type;
	310	tun_setup.addr = dev->tuner_addr;
64d339d4 MCC	311	tun_setup.mode_mask = T_ANALOG_TV \| T_RADIO;
64d339d4 MCC	312	tun_setup.tuner_callback = tm6000_tuner_callback;
427f7fac MCC	313
427f7fac MCC	314	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);
cc27a8c2 MCC	315
cc27a8c2 MCC	316	if (dev->tuner_type == TUNER_XC2028) {
df7c1d9a MCC	317	struct v4l2_priv_tun_config xc2028_cfg;
	318	struct xc2028_ctrl ctl;
	319
427f7fac	320	memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
df7c1d9a	321	memset (&ctl,0,sizeof(ctl));
29c389be	322
3716ae3e	323	ctl.mts = 1;
2d5024a9	324	ctl.read_not_reliable = 1;
e381a810	325	ctl.msleep = 10;
d544f2c3	326
cc27a8c2 MCC	327	xc2028_cfg.tuner = TUNER_XC2028;
cc27a8c2 MCC	328	xc2028_cfg.priv = &ctl;
d544f2c3	329
df7c1d9a MCC	330	switch(dev->model) {
df7c1d9a MCC	331	case TM6010_BOARD_HAUPPAUGE_900H:
04574a68	332	case TM6010_BOARD_TERRATEC_CINERGY_HYBRID_XE:
df7c1d9a MCC	333	ctl.fname = "xc3028L-v36.fw";
	334	break;
	335	default:
	336	if (dev->dev_type == TM6010)
	337	ctl.fname = "xc3028-v27.fw";
	338	else
	339	ctl.fname = "tm6000-xc3028.fw";
	340	}
	341
cc27a8c2	342	printk(KERN_INFO "Setting firmware parameters for xc2028\n");
d544f2c3	343
427f7fac MCC	344	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config,
427f7fac MCC	345	&xc2028_cfg);
cc27a8c2	346	}
d544f2c3 MCC	347	}
d544f2c3 MCC	348
9701dc94 MCC	349	static int tm6000_init_dev(struct tm6000_core *dev)
	350	{
	351	struct v4l2_frequency f;
	352	int rc = 0;
	353
	354	mutex_init(&dev->lock);
	355
	356	mutex_lock(&dev->lock);
	357
	358	/* Initializa board-specific data */
29c389be	359	dev->dev_type = tm6000_boards[dev->model].type;
9701dc94 MCC	360	dev->tuner_type = tm6000_boards[dev->model].tuner_type;
9701dc94 MCC	361	dev->tuner_addr = tm6000_boards[dev->model].tuner_addr;
95a83824 ML	362	dev->tuner_reset_gpio = tm6000_boards[dev->model].gpio_addr_tun_reset;
	363
	364	dev->demod_addr = tm6000_boards[dev->model].demod_addr;
9701dc94 MCC	365
	366	dev->caps = tm6000_boards[dev->model].caps;
	367
	368	/* initialize hardware */
	369	rc=tm6000_init (dev);
	370	if (rc<0)
	371	goto err;
	372
427f7fac MCC	373	rc = v4l2_device_register(&dev->udev->dev, &dev->v4l2_dev);
	374	if (rc < 0)
	375	goto err;
	376
9701dc94 MCC	377	/* register i2c bus */
	378	rc=tm6000_i2c_register(dev);
	379	if (rc<0)
	380	goto err;
	381
	382	/* register and initialize V4L2 */
	383	rc=tm6000_v4l2_register(dev);
	384	if (rc<0)
	385	goto err;
	386
cc27a8c2 MCC	387	/* Default values for STD and resolutions */
	388	dev->width = 720;
	389	dev->height = 480;
	390	dev->norm = V4L2_STD_PAL_M;
d544f2c3	391
cc27a8c2	392	/* Configure tuner */
d544f2c3 MCC	393	tm6000_config_tuner (dev);
d544f2c3 MCC	394
cc27a8c2	395	/* Set video standard */
427f7fac	396	v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
9701dc94	397
cc27a8c2	398	/* Set tuner frequency - also loads firmware on xc2028/xc3028 */
9701dc94 MCC	399	f.tuner = 0;
	400	f.type = V4L2_TUNER_ANALOG_TV;
	401	f.frequency = 3092; /* 193.25 MHz */
	402	dev->freq = f.frequency;
427f7fac MCC	403	v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
	404
	405	if (dev->caps.has_tda9874)
	406	v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
	407	"tvaudio", "tvaudio", I2C_ADDR_TDA9874, NULL);
cc27a8c2	408
3169c9b2 ML	409	if(dev->caps.has_dvb) {
	410	dev->dvb = kzalloc(sizeof(*(dev->dvb)), GFP_KERNEL);
	411	if(!dev->dvb) {
	412	rc = -ENOMEM;
427f7fac	413	goto err2;
3169c9b2	414	}
5c0d0b21	415	#ifdef CONFIG_VIDEO_TM6000_DVB
3169c9b2 ML	416	rc = tm6000_dvb_register(dev);
	417	if(rc < 0) {
	418	kfree(dev->dvb);
	419	dev->dvb = NULL;
427f7fac	420	goto err2;
3169c9b2	421	}
5c0d0b21	422	#endif
3169c9b2	423	}
80af6bb7	424	return 0;
427f7fac MCC	425
	426	err2:
	427	v4l2_device_unregister(&dev->v4l2_dev);
	428
9701dc94 MCC	429	err:
	430	mutex_unlock(&dev->lock);
	431	return rc;
	432	}
	433
	434	/* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
	435	#define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))
	436
	437	static void get_max_endpoint ( struct usb_device *usbdev,
	438	char *msgtype,
	439	struct usb_host_endpoint *curr_e,
	440	unsigned int *maxsize,
	441	struct usb_host_endpoint **ep )
	442	{
	443	u16 tmp = le16_to_cpu(curr_e->desc.wMaxPacketSize);
	444	unsigned int size = tmp & 0x7ff;
	445
	446	if (usbdev->speed == USB_SPEED_HIGH)
	447	size = size * hb_mult (tmp);
	448
	449	if (size>*maxsize) {
	450	*ep = curr_e;
	451	*maxsize = size;
	452	printk("tm6000: %s endpoint: 0x%02x (max size=%u bytes)\n",
	453	msgtype, curr_e->desc.bEndpointAddress,
	454	size);
	455	}
	456	}
	457
	458	/*
	459	* tm6000_usb_probe()
	460	* checks for supported devices
	461	*/
	462	static int tm6000_usb_probe(struct usb_interface *interface,
	463	const struct usb_device_id *id)
	464	{
	465	struct usb_device *usbdev;
	466	struct tm6000_core *dev = NULL;
	467	int i,rc=0;
	468	int nr=0;
	469	char *speed;
	470
	471
	472	usbdev=usb_get_dev(interface_to_usbdev(interface));
	473
	474	/* Selects the proper interface */
	475	rc=usb_set_interface(usbdev,0,1);
	476	if (rc<0)
	477	goto err;
	478
	479	/* Check to see next free device and mark as used */
	480	nr=find_first_zero_bit(&tm6000_devused,TM6000_MAXBOARDS);
	481	if (nr >= TM6000_MAXBOARDS) {
7b96640e	482	printk ("tm6000: Supports only %i tm60xx boards.\n",TM6000_MAXBOARDS);
9701dc94 MCC	483	usb_put_dev(usbdev);
	484	return -ENOMEM;
	485	}
	486
	487	/* Create and initialize dev struct */
	488	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	489	if (dev == NULL) {
	490	printk ("tm6000" ": out of memory!\n");
	491	usb_put_dev(usbdev);
	492	return -ENOMEM;
	493	}
	494	spin_lock_init(&dev->slock);
	495
	496	/* Increment usage count */
	497	tm6000_devused\|=1<<nr;
2cd4fd1e ML	498	snprintf(dev->name, 29, "tm6000 #%d", nr);
	499
	500	dev->model=id->driver_info;
	501	if ((card[nr]>=0) && (card[nr]<ARRAY_SIZE(tm6000_boards))) {
	502	dev->model=card[nr];
	503	}
9701dc94	504
22927e8e	505	INIT_LIST_HEAD(&dev->tm6000_corelist);
9701dc94	506	dev->udev= usbdev;
9701dc94 MCC	507	dev->devno=nr;
	508
	509	switch (usbdev->speed) {
	510	case USB_SPEED_LOW:
	511	speed = "1.5";
	512	break;
	513	case USB_SPEED_UNKNOWN:
	514	case USB_SPEED_FULL:
	515	speed = "12";
	516	break;
	517	case USB_SPEED_HIGH:
	518	speed = "480";
	519	break;
	520	default:
	521	speed = "unknown";
	522	}
	523
	524
	525
	526	/* Get endpoints */
	527	for (i = 0; i < interface->num_altsetting; i++) {
	528	int ep;
	529
	530	for (ep = 0; ep < interface->altsetting[i].desc.bNumEndpoints; ep++) {
	531	struct usb_host_endpoint *e;
	532	int dir_out;
	533
	534	e = &interface->altsetting[i].endpoint[ep];
	535
	536	dir_out = ((e->desc.bEndpointAddress &
	537	USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
	538
	539	printk("tm6000: alt %d, interface %i, class %i\n",
	540	i,
	541	interface->altsetting[i].desc.bInterfaceNumber,
	542	interface->altsetting[i].desc.bInterfaceClass);
	543
	544	switch (e->desc.bmAttributes) {
	545	case USB_ENDPOINT_XFER_BULK:
	546	if (!dir_out) {
	547	get_max_endpoint (usbdev, "Bulk IN", e,
	548	&dev->max_bulk_in,
	549	&dev->bulk_in);
	550	} else {
	551	get_max_endpoint (usbdev, "Bulk OUT", e,
	552	&dev->max_bulk_out,
	553	&dev->bulk_out);
	554	}
	555	break;
	556	case USB_ENDPOINT_XFER_ISOC:
	557	if (!dir_out) {
	558	get_max_endpoint (usbdev, "ISOC IN", e,
	559	&dev->max_isoc_in,
	560	&dev->isoc_in);
	561	} else {
	562	get_max_endpoint (usbdev, "ISOC OUT", e,
	563	&dev->max_isoc_out,
	564	&dev->isoc_out);
	565	}
	566	break;
	567	}
	568	}
	569	}
	570
9701dc94 MCC	571
	572	printk("tm6000: New video device @ %s Mbps (%04x:%04x, ifnum %d)\n",
	573	speed,
	574	le16_to_cpu(dev->udev->descriptor.idVendor),
	575	le16_to_cpu(dev->udev->descriptor.idProduct),
	576	interface->altsetting->desc.bInterfaceNumber);
	577
	578	/* check if the the device has the iso in endpoint at the correct place */
	579	if (!dev->isoc_in) {
	580	printk("tm6000: probing error: no IN ISOC endpoint!\n");
	581	rc= -ENODEV;
	582
	583	goto err;
	584	}
	585
	586	/* save our data pointer in this interface device */
	587	usb_set_intfdata(interface, dev);
	588
	589	printk("tm6000: Found %s\n", tm6000_boards[dev->model].name);
	590
	591	rc=tm6000_init_dev(dev);
	592
	593	if (rc<0)
	594	goto err;
	595
	596	return 0;
	597
	598	err:
427f7fac MCC	599	printk("tm6000: Error %d while registering\n", rc);
427f7fac MCC	600
9701dc94 MCC	601	tm6000_devused&=~(1<<nr);
	602	usb_put_dev(usbdev);
	603
	604	kfree(dev);
	605	return rc;
	606	}
	607
	608	/*
	609	* tm6000_usb_disconnect()
	610	* called when the device gets diconencted
	611	* video device will be unregistered on v4l2_close in case it is still open
	612	*/
	613	static void tm6000_usb_disconnect(struct usb_interface *interface)
	614	{
	615	struct tm6000_core *dev = usb_get_intfdata(interface);
	616	usb_set_intfdata(interface, NULL);
	617
	618	if (!dev)
	619	return;
	620
9701dc94 MCC	621	printk("tm6000: disconnecting %s\n", dev->name);
	622
	623	mutex_lock(&dev->lock);
	624
5c0d0b21	625	#ifdef CONFIG_VIDEO_TM6000_DVB
3169c9b2 ML	626	if(dev->dvb) {
	627	tm6000_dvb_unregister(dev);
	628	kfree(dev->dvb);
	629	}
5c0d0b21	630	#endif
3169c9b2	631
9701dc94 MCC	632	tm6000_v4l2_unregister(dev);
9701dc94 MCC	633
7c3f53ec ML	634	tm6000_i2c_unregister(dev);
7c3f53ec ML	635
427f7fac MCC	636	v4l2_device_unregister(&dev->v4l2_dev);
427f7fac MCC	637
9701dc94 MCC	638	// wake_up_interruptible_all(&dev->open);
	639
	640	dev->state \|= DEV_DISCONNECTED;
	641
7c3f53ec ML	642	usb_put_dev(dev->udev);
7c3f53ec ML	643
9701dc94	644	mutex_unlock(&dev->lock);
22927e8e	645	kfree(dev);
9701dc94 MCC	646	}
	647
	648	static struct usb_driver tm6000_usb_driver = {
	649	.name = "tm6000",
	650	.probe = tm6000_usb_probe,
	651	.disconnect = tm6000_usb_disconnect,
	652	.id_table = tm6000_id_table,
	653	};
	654
	655	static int __init tm6000_module_init(void)
	656	{
	657	int result;
	658
	659	printk(KERN_INFO "tm6000" " v4l2 driver version %d.%d.%d loaded\n",
	660	(TM6000_VERSION >> 16) & 0xff,
	661	(TM6000_VERSION >> 8) & 0xff, TM6000_VERSION & 0xff);
	662
	663	/* register this driver with the USB subsystem */
	664	result = usb_register(&tm6000_usb_driver);
	665	if (result)
	666	printk("tm6000"
	667	" usb_register failed. Error number %d.\n", result);
	668
	669	return result;
	670	}
	671
	672	static void __exit tm6000_module_exit(void)
	673	{
	674	/* deregister at USB subsystem */
	675	usb_deregister(&tm6000_usb_driver);
	676	}
	677
	678	module_init(tm6000_module_init);
	679	module_exit(tm6000_module_exit);
	680
	681	MODULE_DESCRIPTION("Trident TVMaster TM5600/TM6000 USB2 adapter");
	682	MODULE_AUTHOR("Mauro Carvalho Chehab");
	683	MODULE_LICENSE("GPL");