[mirror_ubuntu-bionic-kernel.git] / drivers / usb / misc / isight_firmware.c

/*
 * Driver for loading USB isight firmware
 *
 * Copyright (C) 2008 Matthew Garrett <mjg@redhat.com>
 *
 * 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.
 *
 * The USB isight cameras in recent Apples are roughly compatible with the USB
 * video class specification, and can be driven by uvcvideo. However, they
 * need firmware to be loaded beforehand. After firmware loading, the device
 * detaches from the USB bus and reattaches with a new device ID. It can then
 * be claimed by the uvc driver.
 *
 * The firmware is non-free and must be extracted by the user. Tools to do this
 * are available at http://bersace03.free.fr/ift/
 *
 * The isight firmware loading was reverse engineered by Johannes Berg
 * <johannes@sipsolutions.de>, and this driver is based on code by Ronald
 * Bultje <rbultje@ronald.bitfreak.net>
 */

#include <linux/usb.h>
#include <linux/firmware.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/slab.h>

static const struct usb_device_id id_table[] = {
	{USB_DEVICE(0x05ac, 0x8300)},
	{},
};

MODULE_DEVICE_TABLE(usb, id_table);

static int isight_firmware_load(struct usb_interface *intf,
				const struct usb_device_id *id)
{
	struct usb_device *dev = interface_to_usbdev(intf);
	int llen, len, req, ret = 0;
	const struct firmware *firmware;
	unsigned char *buf = kmalloc(50, GFP_KERNEL);
	unsigned char data[4];
	const u8 *ptr;

	if (!buf)
		return -ENOMEM;

	if (request_firmware(&firmware, "isight.fw", &dev->dev) != 0) {
		printk(KERN_ERR "Unable to load isight firmware\n");
		ret = -ENODEV;
		goto out;
	}

	ptr = firmware->data;

	if (usb_control_msg
	    (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\1", 1,
	     300) != 1) {
		printk(KERN_ERR
		       "Failed to initialise isight firmware loader\n");
		ret = -ENODEV;
		goto out;
	}

	while (ptr+4 <= firmware->data+firmware->size) {
		memcpy(data, ptr, 4);
		len = (data[0] << 8 | data[1]);
		req = (data[2] << 8 | data[3]);
		ptr += 4;

		if (len == 0x8001)
			break;	/* success */
		else if (len == 0)
			continue;

		for (; len > 0; req += 50) {
			llen = min(len, 50);
			len -= llen;
			if (ptr+llen > firmware->data+firmware->size) {
				printk(KERN_ERR
				       "Malformed isight firmware");
				ret = -ENODEV;
				goto out;
			}
			memcpy(buf, ptr, llen);

			ptr += llen;

			if (usb_control_msg
			    (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, req, 0,
			     buf, llen, 300) != llen) {
				printk(KERN_ERR
				       "Failed to load isight firmware\n");
				ret = -ENODEV;
				goto out;
			}

		}
	}

	if (usb_control_msg
	    (dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\0", 1,
	     300) != 1) {
		printk(KERN_ERR "isight firmware loading completion failed\n");
		ret = -ENODEV;
	}

out:
	kfree(buf);
	release_firmware(firmware);
	return ret;
}

MODULE_FIRMWARE("isight.fw");

static void isight_firmware_disconnect(struct usb_interface *intf)
{
}

static struct usb_driver isight_firmware_driver = {
	.name = "isight_firmware",
	.probe = isight_firmware_load,
	.disconnect = isight_firmware_disconnect,
	.id_table = id_table,
};

static int __init isight_firmware_init(void)
{
	return usb_register(&isight_firmware_driver);
}

static void __exit isight_firmware_exit(void)
{
	usb_deregister(&isight_firmware_driver);
}

module_init(isight_firmware_init);
module_exit(isight_firmware_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
Commit	Line	Data
62d104d0 MG	1	/*
	2	* Driver for loading USB isight firmware
	3	*
	4	* Copyright (C) 2008 Matthew Garrett <mjg@redhat.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation, version 2.
	9	*
	10	* The USB isight cameras in recent Apples are roughly compatible with the USB
	11	* video class specification, and can be driven by uvcvideo. However, they
	12	* need firmware to be loaded beforehand. After firmware loading, the device
	13	* detaches from the USB bus and reattaches with a new device ID. It can then
	14	* be claimed by the uvc driver.
	15	*
	16	* The firmware is non-free and must be extracted by the user. Tools to do this
	17	* are available at http://bersace03.free.fr/ift/
	18	*
	19	* The isight firmware loading was reverse engineered by Johannes Berg
	20	* <johannes@sipsolutions.de>, and this driver is based on code by Ronald
	21	* Bultje <rbultje@ronald.bitfreak.net>
	22	*/
	23
	24	#include <linux/usb.h>
	25	#include <linux/firmware.h>
	26	#include <linux/errno.h>
	27	#include <linux/module.h>
5a0e3ad6	28	#include <linux/slab.h>
62d104d0	29
33b9e162	30	static const struct usb_device_id id_table[] = {
62d104d0 MG	31	{USB_DEVICE(0x05ac, 0x8300)},
	32	{},
	33	};
	34
	35	MODULE_DEVICE_TABLE(usb, id_table);
	36
	37	static int isight_firmware_load(struct usb_interface *intf,
	38	const struct usb_device_id *id)
	39	{
	40	struct usb_device *dev = interface_to_usbdev(intf);
	41	int llen, len, req, ret = 0;
	42	const struct firmware *firmware;
62b58848	43	unsigned char *buf = kmalloc(50, GFP_KERNEL);
62d104d0	44	unsigned char data[4];
ed5a2825	45	const u8 *ptr;
62b58848 MG	46
	47	if (!buf)
	48	return -ENOMEM;
62d104d0 MG	49
	50	if (request_firmware(&firmware, "isight.fw", &dev->dev) != 0) {
	51	printk(KERN_ERR "Unable to load isight firmware\n");
ff1a4a7b PW	52	ret = -ENODEV;
ff1a4a7b PW	53	goto out;
62d104d0 MG	54	}
	55
	56	ptr = firmware->data;
	57
	58	if (usb_control_msg
	59	(dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\1", 1,
	60	300) != 1) {
	61	printk(KERN_ERR
	62	"Failed to initialise isight firmware loader\n");
	63	ret = -ENODEV;
	64	goto out;
	65	}
	66
62b58848	67	while (ptr+4 <= firmware->data+firmware->size) {
62d104d0 MG	68	memcpy(data, ptr, 4);
	69	len = (data[0] << 8 \| data[1]);
	70	req = (data[2] << 8 \| data[3]);
	71	ptr += 4;
	72
	73	if (len == 0x8001)
	74	break; /* success */
	75	else if (len == 0)
	76	continue;
	77
	78	for (; len > 0; req += 50) {
62b58848	79	llen = min(len, 50);
62d104d0	80	len -= llen;
62b58848 MG	81	if (ptr+llen > firmware->data+firmware->size) {
	82	printk(KERN_ERR
	83	"Malformed isight firmware");
	84	ret = -ENODEV;
	85	goto out;
	86	}
62d104d0 MG	87	memcpy(buf, ptr, llen);
	88
	89	ptr += llen;
	90
	91	if (usb_control_msg
	92	(dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, req, 0,
	93	buf, llen, 300) != llen) {
	94	printk(KERN_ERR
	95	"Failed to load isight firmware\n");
62d104d0 MG	96	ret = -ENODEV;
	97	goto out;
	98	}
	99
62d104d0 MG	100	}
62d104d0 MG	101	}
62b58848	102
62d104d0 MG	103	if (usb_control_msg
	104	(dev, usb_sndctrlpipe(dev, 0), 0xa0, 0x40, 0xe600, 0, "\0", 1,
	105	300) != 1) {
	106	printk(KERN_ERR "isight firmware loading completion failed\n");
	107	ret = -ENODEV;
	108	}
62b58848	109
62d104d0	110	out:
62b58848	111	kfree(buf);
62d104d0 MG	112	release_firmware(firmware);
	113	return ret;
	114	}
	115
4e0961d5 BH	116	MODULE_FIRMWARE("isight.fw");
4e0961d5 BH	117
62d104d0 MG	118	static void isight_firmware_disconnect(struct usb_interface *intf)
	119	{
	120	}
	121
	122	static struct usb_driver isight_firmware_driver = {
	123	.name = "isight_firmware",
	124	.probe = isight_firmware_load,
	125	.disconnect = isight_firmware_disconnect,
	126	.id_table = id_table,
	127	};
	128
	129	static int __init isight_firmware_init(void)
	130	{
	131	return usb_register(&isight_firmware_driver);
	132	}
	133
	134	static void __exit isight_firmware_exit(void)
	135	{
	136	usb_deregister(&isight_firmware_driver);
	137	}
	138
	139	module_init(isight_firmware_init);
	140	module_exit(isight_firmware_exit);
	141
	142	MODULE_LICENSE("GPL");
	143	MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");