[mirror_ubuntu-artful-kernel.git] / drivers / media / usb / au0828 / au0828-core.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 "au8522.h"

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/videodev2.h>
#include <media/v4l2-common.h>
#include <linux/mutex.h>

/* Due to enum tuner_pad_index */
#include <media/tuner.h>

/*
 * 1 = General debug messages
 * 2 = USB handling
 * 4 = I2C related
 * 8 = Bridge related
 * 16 = IR related
 */
int au0828_debug;
module_param_named(debug, au0828_debug, int, 0644);
MODULE_PARM_DESC(debug,
		 "set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");

static unsigned int disable_usb_speed_check;
module_param(disable_usb_speed_check, int, 0444);
MODULE_PARM_DESC(disable_usb_speed_check,
		 "override min bandwidth requirement of 480M bps");

#define _AU0828_BULKPIPE 0x03
#define _BULKPIPESIZE 0xffff

static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
			    u16 index);
static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
	u16 index, unsigned char *cp, u16 size);

/* USB Direction */
#define CMD_REQUEST_IN		0x00
#define CMD_REQUEST_OUT		0x01

u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
{
	u8 result = 0;

	recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
	dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);

	return result;
}

u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
{
	dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
	return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
}

static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
	u16 index)
{
	int status = -ENODEV;

	if (dev->usbdev) {

		/* cp must be memory that has been allocated by kmalloc */
		status = usb_control_msg(dev->usbdev,
				usb_sndctrlpipe(dev->usbdev, 0),
				request,
				USB_DIR_OUT | USB_TYPE_VENDOR |
					USB_RECIP_DEVICE,
				value, index, NULL, 0, 1000);

		status = min(status, 0);

		if (status < 0) {
			pr_err("%s() Failed sending control message, error %d.\n",
				__func__, status);
		}

	}

	return status;
}

static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
	u16 index, unsigned char *cp, u16 size)
{
	int status = -ENODEV;
	mutex_lock(&dev->mutex);
	if (dev->usbdev) {
		status = usb_control_msg(dev->usbdev,
				usb_rcvctrlpipe(dev->usbdev, 0),
				request,
				USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
				value, index,
				dev->ctrlmsg, size, 1000);

		status = min(status, 0);

		if (status < 0) {
			pr_err("%s() Failed receiving control message, error %d.\n",
				__func__, status);
		}

		/* the host controller requires heap allocated memory, which
		   is why we didn't just pass "cp" into usb_control_msg */
		memcpy(cp, dev->ctrlmsg, size);
	}
	mutex_unlock(&dev->mutex);
	return status;
}

static void au0828_unregister_media_device(struct au0828_dev *dev)
{

#ifdef CONFIG_MEDIA_CONTROLLER
	if (dev->media_dev &&
		media_devnode_is_registered(&dev->media_dev->devnode)) {
		media_device_unregister(dev->media_dev);
		media_device_cleanup(dev->media_dev);
		dev->media_dev = NULL;
	}
#endif
}

void au0828_usb_release(struct au0828_dev *dev)
{
	au0828_unregister_media_device(dev);

	/* I2C */
	au0828_i2c_unregister(dev);

	kfree(dev);
}

static void au0828_usb_disconnect(struct usb_interface *interface)
{
	struct au0828_dev *dev = usb_get_intfdata(interface);

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

	/* there is a small window after disconnect, before
	   dev->usbdev is NULL, for poll (e.g: IR) try to access
	   the device and fill the dmesg with error messages.
	   Set the status so poll routines can check and avoid
	   access after disconnect.
	*/
	dev->dev_state = DEV_DISCONNECTED;

	au0828_rc_unregister(dev);
	/* Digital TV */
	au0828_dvb_unregister(dev);

	usb_set_intfdata(interface, NULL);
	mutex_lock(&dev->mutex);
	dev->usbdev = NULL;
	mutex_unlock(&dev->mutex);
	if (au0828_analog_unregister(dev)) {
		/*
		 * No need to call au0828_usb_release() if V4L2 is enabled,
		 * as this is already called via au0828_usb_v4l2_release()
		 */
		return;
	}
	au0828_usb_release(dev);
}

static int au0828_media_device_init(struct au0828_dev *dev,
				    struct usb_device *udev)
{
#ifdef CONFIG_MEDIA_CONTROLLER
	struct media_device *mdev;

	mdev = media_device_get_devres(&udev->dev);
	if (!mdev)
		return -ENOMEM;

	/* check if media device is already initialized */
	if (!mdev->dev)
		media_device_usb_init(mdev, udev, udev->product);

	dev->media_dev = mdev;
#endif
	return 0;
}

static void au0828_media_graph_notify(struct media_entity *new,
				      void *notify_data)
{
#ifdef CONFIG_MEDIA_CONTROLLER
	struct au0828_dev *dev = (struct au0828_dev *) notify_data;
	int ret;

	if (!dev->decoder)
		return;

	switch (new->function) {
	case MEDIA_ENT_F_AUDIO_MIXER:
		ret = media_create_pad_link(dev->decoder,
					    AU8522_PAD_AUDIO_OUT,
					    new, 0,
					    MEDIA_LNK_FL_ENABLED);
		if (ret)
			dev_err(&dev->usbdev->dev,
				"Mixer Pad Link Create Error: %d\n",
				ret);
		break;
	default:
		break;
	}
#endif
}

static int au0828_media_device_register(struct au0828_dev *dev,
					struct usb_device *udev)
{
#ifdef CONFIG_MEDIA_CONTROLLER
	int ret;

	if (!dev->media_dev)
		return 0;

	if (!media_devnode_is_registered(&dev->media_dev->devnode)) {

		/* register media device */
		ret = media_device_register(dev->media_dev);
		if (ret) {
			dev_err(&udev->dev,
				"Media Device Register Error: %d\n", ret);
			return ret;
		}
	}
	/* register entity_notify callback */
	dev->entity_notify.notify_data = (void *) dev;
	dev->entity_notify.notify = (void *) au0828_media_graph_notify;
	ret = media_device_register_entity_notify(dev->media_dev,
						  &dev->entity_notify);
	if (ret) {
		dev_err(&udev->dev,
			"Media Device register entity_notify Error: %d\n",
			ret);
		return ret;
	}
#endif
	return 0;
}

static int au0828_usb_probe(struct usb_interface *interface,
	const struct usb_device_id *id)
{
	int ifnum;
	int retval = 0;

	struct au0828_dev *dev;
	struct usb_device *usbdev = interface_to_usbdev(interface);

	ifnum = interface->altsetting->desc.bInterfaceNumber;

	if (ifnum != 0)
		return -ENODEV;

	dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
		le16_to_cpu(usbdev->descriptor.idVendor),
		le16_to_cpu(usbdev->descriptor.idProduct),
		ifnum);

	/*
	 * Make sure we have 480 Mbps of bandwidth, otherwise things like
	 * video stream wouldn't likely work, since 12 Mbps is generally
	 * not enough even for most Digital TV streams.
	 */
	if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
		pr_err("au0828: Device initialization failed.\n");
		pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
		return -ENODEV;
	}

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (dev == NULL) {
		pr_err("%s() Unable to allocate memory\n", __func__);
		return -ENOMEM;
	}

	mutex_init(&dev->lock);
	mutex_lock(&dev->lock);
	mutex_init(&dev->mutex);
	mutex_init(&dev->dvb.lock);
	dev->usbdev = usbdev;
	dev->boardnr = id->driver_info;
	dev->board = au0828_boards[dev->boardnr];

	/* Initialize the media controller */
	retval = au0828_media_device_init(dev, usbdev);
	if (retval) {
		pr_err("%s() au0828_media_device_init failed\n",
		       __func__);
		mutex_unlock(&dev->lock);
		kfree(dev);
		return retval;
	}

	retval = au0828_v4l2_device_register(interface, dev);
	if (retval) {
		au0828_usb_v4l2_media_release(dev);
		mutex_unlock(&dev->lock);
		kfree(dev);
		return retval;
	}

	/* Power Up the bridge */
	au0828_write(dev, REG_600, 1 << 4);

	/* Bring up the GPIO's and supporting devices */
	au0828_gpio_setup(dev);

	/* I2C */
	au0828_i2c_register(dev);

	/* Setup */
	au0828_card_setup(dev);

	/* Analog TV */
	retval = au0828_analog_register(dev, interface);
	if (retval) {
		pr_err("%s() au0282_dev_register failed to register on V4L2\n",
			__func__);
		goto done;
	}

	/* Digital TV */
	retval = au0828_dvb_register(dev);
	if (retval)
		pr_err("%s() au0282_dev_register failed\n",
		       __func__);

	/* Remote controller */
	au0828_rc_register(dev);

	/*
	 * Store the pointer to the au0828_dev so it can be accessed in
	 * au0828_usb_disconnect
	 */
	usb_set_intfdata(interface, dev);

	pr_info("Registered device AU0828 [%s]\n",
		dev->board.name == NULL ? "Unset" : dev->board.name);

	mutex_unlock(&dev->lock);

	retval = au0828_media_device_register(dev, usbdev);

done:
	if (retval < 0)
		au0828_usb_disconnect(interface);

	return retval;
}

static int au0828_suspend(struct usb_interface *interface,
				pm_message_t message)
{
	struct au0828_dev *dev = usb_get_intfdata(interface);

	if (!dev)
		return 0;

	pr_info("Suspend\n");

	au0828_rc_suspend(dev);
	au0828_v4l2_suspend(dev);
	au0828_dvb_suspend(dev);

	/* FIXME: should suspend also ATV/DTV */

	return 0;
}

static int au0828_resume(struct usb_interface *interface)
{
	struct au0828_dev *dev = usb_get_intfdata(interface);
	if (!dev)
		return 0;

	pr_info("Resume\n");

	/* Power Up the bridge */
	au0828_write(dev, REG_600, 1 << 4);

	/* Bring up the GPIO's and supporting devices */
	au0828_gpio_setup(dev);

	au0828_rc_resume(dev);
	au0828_v4l2_resume(dev);
	au0828_dvb_resume(dev);

	/* FIXME: should resume also ATV/DTV */

	return 0;
}

static struct usb_driver au0828_usb_driver = {
	.name		= KBUILD_MODNAME,
	.probe		= au0828_usb_probe,
	.disconnect	= au0828_usb_disconnect,
	.id_table	= au0828_usb_id_table,
	.suspend	= au0828_suspend,
	.resume		= au0828_resume,
	.reset_resume	= au0828_resume,
};

static int __init au0828_init(void)
{
	int ret;

	if (au0828_debug & 1)
		pr_info("%s() Debugging is enabled\n", __func__);

	if (au0828_debug & 2)
		pr_info("%s() USB Debugging is enabled\n", __func__);

	if (au0828_debug & 4)
		pr_info("%s() I2C Debugging is enabled\n", __func__);

	if (au0828_debug & 8)
		pr_info("%s() Bridge Debugging is enabled\n",
		       __func__);

	if (au0828_debug & 16)
		pr_info("%s() IR Debugging is enabled\n",
		       __func__);

	pr_info("au0828 driver loaded\n");

	ret = usb_register(&au0828_usb_driver);
	if (ret)
		pr_err("usb_register failed, error = %d\n", ret);

	return ret;
}

static void __exit au0828_exit(void)
{
	usb_deregister(&au0828_usb_driver);
}

module_init(au0828_init);
module_exit(au0828_exit);

MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
MODULE_LICENSE("GPL");
MODULE_VERSION("0.0.3");
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
83afb32a	22	#include "au0828.h"
f90c5d79	23	#include "au8522.h"
83afb32a	24
265a6510	25	#include <linux/module.h>
5a0e3ad6	26	#include <linux/slab.h>
265a6510 ST	27	#include <linux/videodev2.h>
	28	#include <media/v4l2-common.h>
	29	#include <linux/mutex.h>
	30
188d2d55 MCC	31	/* Due to enum tuner_pad_index */
	32	#include <media/tuner.h>
	33
bc3c613c ST	34	/*
	35	* 1 = General debug messages
	36	* 2 = USB handling
	37	* 4 = I2C related
	38	* 8 = Bridge related
2fcfd317	39	* 16 = IR related
bc3c613c	40	*/
b33d24c4 AB	41	int au0828_debug;
b33d24c4 AB	42	module_param_named(debug, au0828_debug, int, 0644);
2fcfd317 MCC	43	MODULE_PARM_DESC(debug,
2fcfd317 MCC	44	"set debug bitmask: 1=general, 2=USB, 4=I2C, 8=bridge, 16=IR");
265a6510	45
d6a9a430 DH	46	static unsigned int disable_usb_speed_check;
	47	module_param(disable_usb_speed_check, int, 0444);
	48	MODULE_PARM_DESC(disable_usb_speed_check,
	49	"override min bandwidth requirement of 480M bps");
	50
265a6510 ST	51	#define _AU0828_BULKPIPE 0x03
	52	#define _BULKPIPESIZE 0xffff
	53
	54	static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
8ff63de6	55	u16 index);
265a6510 ST	56	static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
	57	u16 index, unsigned char *cp, u16 size);
	58
	59	/* USB Direction */
	60	#define CMD_REQUEST_IN 0x00
	61	#define CMD_REQUEST_OUT 0x01
	62
	63	u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
	64	{
77fc2863 DH	65	u8 result = 0;
	66
	67	recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, &result, 1);
	68	dprintk(8, "%s(0x%04x) = 0x%02x\n", __func__, reg, result);
	69
	70	return result;
265a6510 ST	71	}
	72
	73	u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
	74	{
b80f770a	75	dprintk(8, "%s(0x%04x, 0x%02x)\n", __func__, reg, val);
8ff63de6	76	return send_control_msg(dev, CMD_REQUEST_OUT, val, reg);
265a6510 ST	77	}
265a6510 ST	78
265a6510	79	static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
8ff63de6	80	u16 index)
265a6510 ST	81	{
265a6510 ST	82	int status = -ENODEV;
8ff63de6	83
265a6510 ST	84	if (dev->usbdev) {
	85
	86	/* cp must be memory that has been allocated by kmalloc */
	87	status = usb_control_msg(dev->usbdev,
	88	usb_sndctrlpipe(dev->usbdev, 0),
	89	request,
a8eb912c ST	90	USB_DIR_OUT \| USB_TYPE_VENDOR \|
a8eb912c ST	91	USB_RECIP_DEVICE,
8ff63de6	92	value, index, NULL, 0, 1000);
265a6510 ST	93
	94	status = min(status, 0);
	95
	96	if (status < 0) {
83afb32a	97	pr_err("%s() Failed sending control message, error %d.\n",
f07e8e4b	98	__func__, status);
265a6510 ST	99	}
	100
	101	}
8ff63de6	102
265a6510 ST	103	return status;
	104	}
	105
	106	static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
	107	u16 index, unsigned char *cp, u16 size)
	108	{
	109	int status = -ENODEV;
	110	mutex_lock(&dev->mutex);
	111	if (dev->usbdev) {
265a6510 ST	112	status = usb_control_msg(dev->usbdev,
	113	usb_rcvctrlpipe(dev->usbdev, 0),
	114	request,
	115	USB_DIR_IN \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	116	value, index,
77fc2863	117	dev->ctrlmsg, size, 1000);
265a6510 ST	118
	119	status = min(status, 0);
	120
	121	if (status < 0) {
83afb32a	122	pr_err("%s() Failed receiving control message, error %d.\n",
f07e8e4b	123	__func__, status);
77fc2863 DH	124	}
	125
	126	/* the host controller requires heap allocated memory, which
	127	is why we didn't just pass "cp" into usb_control_msg */
	128	memcpy(cp, dev->ctrlmsg, size);
265a6510 ST	129	}
	130	mutex_unlock(&dev->mutex);
	131	return status;
	132	}
a9c36aad	133
bed69196 RLLC	134	static void au0828_unregister_media_device(struct au0828_dev *dev)
	135	{
	136
	137	#ifdef CONFIG_MEDIA_CONTROLLER
182dde7c SK	138	if (dev->media_dev &&
182dde7c SK	139	media_devnode_is_registered(&dev->media_dev->devnode)) {
bed69196	140	media_device_unregister(dev->media_dev);
9832e155	141	media_device_cleanup(dev->media_dev);
bed69196 RLLC	142	dev->media_dev = NULL;
	143	}
	144	#endif
	145	}
	146
7b606ffd	147	void au0828_usb_release(struct au0828_dev *dev)
265a6510	148	{
bed69196 RLLC	149	au0828_unregister_media_device(dev);
bed69196 RLLC	150
265a6510 ST	151	/* I2C */
	152	au0828_i2c_unregister(dev);
	153
823beb7e HV	154	kfree(dev);
	155	}
	156
823beb7e HV	157	static void au0828_usb_disconnect(struct usb_interface *interface)
	158	{
	159	struct au0828_dev *dev = usb_get_intfdata(interface);
	160
	161	dprintk(1, "%s()\n", __func__);
	162
eb336eab SK	163	/* there is a small window after disconnect, before
	164	dev->usbdev is NULL, for poll (e.g: IR) try to access
	165	the device and fill the dmesg with error messages.
	166	Set the status so poll routines can check and avoid
	167	access after disconnect.
	168	*/
	169	dev->dev_state = DEV_DISCONNECTED;
	170
2fcfd317	171	au0828_rc_unregister(dev);
823beb7e HV	172	/* Digital TV */
823beb7e HV	173	au0828_dvb_unregister(dev);
265a6510	174
823beb7e	175	usb_set_intfdata(interface, NULL);
265a6510 ST	176	mutex_lock(&dev->mutex);
	177	dev->usbdev = NULL;
	178	mutex_unlock(&dev->mutex);
7b606ffd	179	if (au0828_analog_unregister(dev)) {
7e9a8ad5 MCC	180	/*
	181	* No need to call au0828_usb_release() if V4L2 is enabled,
	182	* as this is already called via au0828_usb_v4l2_release()
	183	*/
823beb7e HV	184	return;
823beb7e HV	185	}
823beb7e	186	au0828_usb_release(dev);
265a6510 ST	187	}
265a6510 ST	188
9f806795 MCC	189	static int au0828_media_device_init(struct au0828_dev *dev,
9f806795 MCC	190	struct usb_device *udev)
bed69196 RLLC	191	{
	192	#ifdef CONFIG_MEDIA_CONTROLLER
	193	struct media_device *mdev;
bed69196	194
182dde7c	195	mdev = media_device_get_devres(&udev->dev);
67873d4e MCC	196	if (!mdev)
67873d4e MCC	197	return -ENOMEM;
bed69196	198
7b12adf6 SK	199	/* check if media device is already initialized */
	200	if (!mdev->dev)
	201	media_device_usb_init(mdev, udev, udev->product);
6cf5dad1	202
bed69196 RLLC	203	dev->media_dev = mdev;
bed69196 RLLC	204	#endif
9f806795	205	return 0;
bed69196 RLLC	206	}
bed69196 RLLC	207
f90c5d79 SK	208	static void au0828_media_graph_notify(struct media_entity *new,
	209	void *notify_data)
	210	{
	211	#ifdef CONFIG_MEDIA_CONTROLLER
	212	struct au0828_dev dev = (struct au0828_dev ) notify_data;
	213	int ret;
	214
	215	if (!dev->decoder)
	216	return;
	217
	218	switch (new->function) {
	219	case MEDIA_ENT_F_AUDIO_MIXER:
	220	ret = media_create_pad_link(dev->decoder,
	221	AU8522_PAD_AUDIO_OUT,
	222	new, 0,
	223	MEDIA_LNK_FL_ENABLED);
	224	if (ret)
	225	dev_err(&dev->usbdev->dev,
	226	"Mixer Pad Link Create Error: %d\n",
	227	ret);
	228	break;
	229	default:
	230	break;
	231	}
	232	#endif
	233	}
	234
7b12adf6 SK	235	static int au0828_media_device_register(struct au0828_dev *dev,
	236	struct usb_device *udev)
	237	{
	238	#ifdef CONFIG_MEDIA_CONTROLLER
	239	int ret;
	240
f90c5d79 SK	241	if (!dev->media_dev)
	242	return 0;
	243
	244	if (!media_devnode_is_registered(&dev->media_dev->devnode)) {
7b12adf6 SK	245
	246	/* register media device */
	247	ret = media_device_register(dev->media_dev);
	248	if (ret) {
	249	dev_err(&udev->dev,
	250	"Media Device Register Error: %d\n", ret);
	251	return ret;
	252	}
	253	}
f90c5d79 SK	254	/* register entity_notify callback */
	255	dev->entity_notify.notify_data = (void *) dev;
	256	dev->entity_notify.notify = (void *) au0828_media_graph_notify;
	257	ret = media_device_register_entity_notify(dev->media_dev,
	258	&dev->entity_notify);
	259	if (ret) {
	260	dev_err(&udev->dev,
	261	"Media Device register entity_notify Error: %d\n",
	262	ret);
	263	return ret;
	264	}
7b12adf6 SK	265	#endif
	266	return 0;
	267	}
bed69196	268
18d73c58	269	static int au0828_usb_probe(struct usb_interface *interface,
265a6510 ST	270	const struct usb_device_id *id)
265a6510 ST	271	{
8a4e7866	272	int ifnum;
f251b3e7 TM	273	int retval = 0;
f251b3e7 TM	274
265a6510 ST	275	struct au0828_dev *dev;
	276	struct usb_device *usbdev = interface_to_usbdev(interface);
	277
	278	ifnum = interface->altsetting->desc.bInterfaceNumber;
	279
	280	if (ifnum != 0)
	281	return -ENODEV;
	282
a9c36aad	283	dprintk(1, "%s() vendor id 0x%x device id 0x%x ifnum:%d\n", __func__,
265a6510 ST	284	le16_to_cpu(usbdev->descriptor.idVendor),
	285	le16_to_cpu(usbdev->descriptor.idProduct),
	286	ifnum);
	287
ee3436b8 DH	288	/*
	289	* Make sure we have 480 Mbps of bandwidth, otherwise things like
	290	* video stream wouldn't likely work, since 12 Mbps is generally
	291	* not enough even for most Digital TV streams.
	292	*/
d6a9a430	293	if (usbdev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
83afb32a MCC	294	pr_err("au0828: Device initialization failed.\n");
83afb32a MCC	295	pr_err("au0828: Device must be connected to a high-speed USB 2.0 port.\n");
ee3436b8 DH	296	return -ENODEV;
	297	}
	298
265a6510 ST	299	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
265a6510 ST	300	if (dev == NULL) {
83afb32a	301	pr_err("%s() Unable to allocate memory\n", __func__);
265a6510 ST	302	return -ENOMEM;
	303	}
	304
549ee4df DH	305	mutex_init(&dev->lock);
549ee4df DH	306	mutex_lock(&dev->lock);
265a6510 ST	307	mutex_init(&dev->mutex);
	308	mutex_init(&dev->dvb.lock);
	309	dev->usbdev = usbdev;
f1add5b5	310	dev->boardnr = id->driver_info;
e42c8c6e RLLC	311	dev->board = au0828_boards[dev->boardnr];
e42c8c6e RLLC	312
9832e155	313	/* Initialize the media controller */
9f806795 MCC	314	retval = au0828_media_device_init(dev, usbdev);
	315	if (retval) {
	316	pr_err("%s() au0828_media_device_init failed\n",
	317	__func__);
	318	mutex_unlock(&dev->lock);
	319	kfree(dev);
	320	return retval;
	321	}
265a6510	322
7b606ffd	323	retval = au0828_v4l2_device_register(interface, dev);
b14667f3	324	if (retval) {
7b606ffd	325	au0828_usb_v4l2_media_release(dev);
549ee4df	326	mutex_unlock(&dev->lock);
b14667f3	327	kfree(dev);
e8c26f45	328	return retval;
b14667f3 DH	329	}
b14667f3 DH	330
265a6510 ST	331	/* Power Up the bridge */
	332	au0828_write(dev, REG_600, 1 << 4);
	333
	334	/* Bring up the GPIO's and supporting devices */
	335	au0828_gpio_setup(dev);
	336
	337	/* I2C */
	338	au0828_i2c_register(dev);
	339
28930fa9 ST	340	/* Setup */
	341	au0828_card_setup(dev);
	342
8b2f0795	343	/* Analog TV */
7b606ffd MCC	344	retval = au0828_analog_register(dev, interface);
	345	if (retval) {
	346	pr_err("%s() au0282_dev_register failed to register on V4L2\n",
	347	__func__);
	348	goto done;
82e92f4c	349	}
8b2f0795	350
265a6510	351	/* Digital TV */
f251b3e7 TM	352	retval = au0828_dvb_register(dev);
	353	if (retval)
	354	pr_err("%s() au0282_dev_register failed\n",
	355	__func__);
	356
2fcfd317 MCC	357	/* Remote controller */
2fcfd317 MCC	358	au0828_rc_register(dev);
265a6510	359
2fcfd317 MCC	360	/*
	361	* Store the pointer to the au0828_dev so it can be accessed in
	362	* au0828_usb_disconnect
	363	*/
fe78a49c DH	364	usb_set_intfdata(interface, dev);
fe78a49c DH	365
83afb32a	366	pr_info("Registered device AU0828 [%s]\n",
f1add5b5	367	dev->board.name == NULL ? "Unset" : dev->board.name);
265a6510	368
549ee4df DH	369	mutex_unlock(&dev->lock);
549ee4df DH	370
7b12adf6	371	retval = au0828_media_device_register(dev, usbdev);
9832e155 JMC	372
	373	done:
	374	if (retval < 0)
	375	au0828_usb_disconnect(interface);
	376
f251b3e7	377	return retval;
265a6510 ST	378	}
265a6510 ST	379
aaeac199 MCC	380	static int au0828_suspend(struct usb_interface *interface,
	381	pm_message_t message)
	382	{
	383	struct au0828_dev *dev = usb_get_intfdata(interface);
	384
	385	if (!dev)
	386	return 0;
	387
81187240 MCC	388	pr_info("Suspend\n");
81187240 MCC	389
aaeac199	390	au0828_rc_suspend(dev);
1a1ba95e	391	au0828_v4l2_suspend(dev);
b799de75	392	au0828_dvb_suspend(dev);
aaeac199 MCC	393
	394	/* FIXME: should suspend also ATV/DTV */
	395
	396	return 0;
	397	}
	398
	399	static int au0828_resume(struct usb_interface *interface)
	400	{
	401	struct au0828_dev *dev = usb_get_intfdata(interface);
	402	if (!dev)
	403	return 0;
	404
81187240 MCC	405	pr_info("Resume\n");
81187240 MCC	406
fa500461 MCC	407	/* Power Up the bridge */
	408	au0828_write(dev, REG_600, 1 << 4);
	409
	410	/* Bring up the GPIO's and supporting devices */
	411	au0828_gpio_setup(dev);
	412
aaeac199	413	au0828_rc_resume(dev);
1a1ba95e	414	au0828_v4l2_resume(dev);
b799de75	415	au0828_dvb_resume(dev);
aaeac199 MCC	416
	417	/* FIXME: should resume also ATV/DTV */
	418
	419	return 0;
	420	}
	421
265a6510	422	static struct usb_driver au0828_usb_driver = {
83afb32a	423	.name = KBUILD_MODNAME,
265a6510 ST	424	.probe = au0828_usb_probe,
	425	.disconnect = au0828_usb_disconnect,
	426	.id_table = au0828_usb_id_table,
aaeac199 MCC	427	.suspend = au0828_suspend,
	428	.resume = au0828_resume,
	429	.reset_resume = au0828_resume,
265a6510 ST	430	};
	431
	432	static int __init au0828_init(void)
	433	{
	434	int ret;
	435
b33d24c4	436	if (au0828_debug & 1)
83afb32a	437	pr_info("%s() Debugging is enabled\n", __func__);
bc3c613c	438
b33d24c4	439	if (au0828_debug & 2)
83afb32a	440	pr_info("%s() USB Debugging is enabled\n", __func__);
bc3c613c	441
b33d24c4	442	if (au0828_debug & 4)
83afb32a	443	pr_info("%s() I2C Debugging is enabled\n", __func__);
bc3c613c	444
b33d24c4	445	if (au0828_debug & 8)
83afb32a	446	pr_info("%s() Bridge Debugging is enabled\n",
f07e8e4b	447	__func__);
bc3c613c	448
2fcfd317	449	if (au0828_debug & 16)
83afb32a	450	pr_info("%s() IR Debugging is enabled\n",
2fcfd317 MCC	451	__func__);
2fcfd317 MCC	452
83afb32a	453	pr_info("au0828 driver loaded\n");
265a6510 ST	454
	455	ret = usb_register(&au0828_usb_driver);
	456	if (ret)
83afb32a	457	pr_err("usb_register failed, error = %d\n", ret);
265a6510 ST	458
	459	return ret;
	460	}
	461
	462	static void __exit au0828_exit(void)
	463	{
	464	usb_deregister(&au0828_usb_driver);
	465	}
	466
	467	module_init(au0828_init);
	468	module_exit(au0828_exit);
	469
	470	MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
6d897616	471	MODULE_AUTHOR("Steven Toth <stoth@linuxtv.org>");
265a6510	472	MODULE_LICENSE("GPL");
2fcfd317	473	MODULE_VERSION("0.0.3");