/*
 * Copyright (C) 2008 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/ioctl.h>
#include <sys/types.h>
#include <dirent.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <ctype.h>

#include <linux/usbdevice_fs.h>
#include <linux/usbdevice_fs.h>
#include <linux/version.h>
#include <linux/usb/ch9.h>
#include <asm/byteorder.h>

#include "usb.h"

#define MAX_RETRIES 2

#ifdef TRACE_USB
#define DBG1(x...) fprintf(stderr, x)
#define DBG(x...) fprintf(stderr, x)
#else
#define DBG(x...)
#define DBG1(x...)
#endif

struct usb_handle {
	char fname[64];
	int desc;
	unsigned char ep_in;
	unsigned char ep_out;
};

static inline int badname(const char *name)
{
	while (*name) {
		if (!isdigit(*name++))
			return 1;
	}
	return 0;
}

static int check(void *_desc, int len, unsigned type, int size)
{
	unsigned char *desc = _desc;

	if (len < size)
		return -1;
	if (desc[0] < size)
		return -1;
	if (desc[0] > len)
		return -1;
	if (desc[1] != type)
		return -1;

	return 0;
}

static int filter_usb_device(int fd, char *ptr, int len, int writable,
	ifc_match_func callback, int *ept_in_id, int *ept_out_id, int *ifc_id)
{
	struct usb_device_descriptor *dev;
	struct usb_config_descriptor *cfg;
	struct usb_interface_descriptor *ifc;
	struct usb_endpoint_descriptor *ept;
	struct usb_ifc_info info;

	int in, out;
	unsigned i;
	unsigned e;

	if (check(ptr, len, USB_DT_DEVICE, USB_DT_DEVICE_SIZE))
		return -1;
	dev = (void *) ptr;
	len -= dev->bLength;
	ptr += dev->bLength;

	if (check(ptr, len, USB_DT_CONFIG, USB_DT_CONFIG_SIZE))
		return -1;
	cfg = (void *) ptr;
	len -= cfg->bLength;
	ptr += cfg->bLength;

	info.dev_vendor = dev->idVendor;
	info.dev_product = dev->idProduct;
	info.dev_class = dev->bDeviceClass;
	info.dev_subclass = dev->bDeviceSubClass;
	info.dev_protocol = dev->bDeviceProtocol;
	info.writable = writable;

	/* read device serial number (if there is one) */
	info.serial_number[0] = 0;
	if (dev->iSerialNumber) {
		struct usbdevfs_ctrltransfer  ctrl;
		__u16 buffer[128];
		int result;

		memset(buffer, 0, sizeof(buffer));

		ctrl.bRequestType = USB_DIR_IN|
			USB_TYPE_STANDARD|USB_RECIP_DEVICE;
		ctrl.bRequest = USB_REQ_GET_DESCRIPTOR;
		ctrl.wValue = (USB_DT_STRING << 8) | dev->iSerialNumber;
		ctrl.wIndex = 0;
		ctrl.wLength = sizeof(buffer);
		ctrl.data = buffer;
		ctrl.timeout = 50;

		result = ioctl(fd, USBDEVFS_CONTROL, &ctrl);
		if (result > 0) {
			int i;
			/* skip first word, and copy the rest to the serial
			string, changing shorts to bytes. */
			result /= 2;
			for (i = 1; i < result; i++)
				info.serial_number[i - 1] = buffer[i];
			info.serial_number[i - 1] = 0;
		}
	}

	for (i = 0; i < cfg->bNumInterfaces; i++) {
		if (check(ptr, len, USB_DT_INTERFACE, USB_DT_INTERFACE_SIZE))
			return -1;
		ifc = (void *) ptr;
		len -= ifc->bLength;
		ptr += ifc->bLength;

		in = -1;
		out = -1;
		info.ifc_class = ifc->bInterfaceClass;
		info.ifc_subclass = ifc->bInterfaceSubClass;
		info.ifc_protocol = ifc->bInterfaceProtocol;

		for (e = 0; e < ifc->bNumEndpoints; e++) {
			if (check(ptr, len, USB_DT_ENDPOINT,
				USB_DT_ENDPOINT_SIZE)
			)
				return -1;
			ept = (void *) ptr;
			len -= ept->bLength;
			ptr += ept->bLength;

			if ((ept->bmAttributes & 0x03) != 0x02)
				continue;

			if (ept->bEndpointAddress & 0x80)
				in = ept->bEndpointAddress;
			else
				out = ept->bEndpointAddress;
		}

		info.has_bulk_in = (in != -1);
		info.has_bulk_out = (out != -1);

		if (callback(&info) == 0) {
			*ept_in_id = in;
			*ept_out_id = out;
			*ifc_id = ifc->bInterfaceNumber;
			return 0;
		}
	}

	return -1;
}

static struct usb_handle *find_usb_device(
	const char *base, ifc_match_func callback)
{
	struct usb_handle *usb = 0;
	char busname[64], devname[64];
	char desc[1024];
	int n, in, out, ifc;

	DIR *busdir, *devdir;
	struct dirent *de;
	int fd;
	int writable;

	busdir = opendir(base);
	if (busdir == 0)
		return 0;

	while ((de = readdir(busdir)) && (usb == 0)) {
		if (badname(de->d_name))
			continue;

		sprintf(busname, "%s/%s", base, de->d_name);
		devdir = opendir(busname);
		if (devdir == 0)
			continue;

		/* DBG("[ scanning %s ]\n", busname); */
		while ((de = readdir(devdir)) && (usb == 0)) {

			if (badname(de->d_name))
				continue;
			sprintf(devname, "%s/%s", busname, de->d_name);

			/* DBG("[ scanning %s ]\n", devname); */
			writable = 1;
			fd = open(devname, O_RDWR);
			if (fd < 0) {
				/* Check if we have read-only access,
				so we can give a helpful diagnostic
				like "adb devices" does. */
				writable = 0;
				fd = open(devname, O_RDONLY);
				if (fd < 0)
					continue;
			}

			n = read(fd, desc, sizeof(desc));

			if (filter_usb_device(fd, desc, n, writable,
				callback, &in, &out, &ifc) == 0
			) {
				usb = calloc(1, sizeof(struct usb_handle));
				strcpy(usb->fname, devname);
				usb->ep_in = in;
				usb->ep_out = out;
				usb->desc = fd;

				n = ioctl(fd, USBDEVFS_CLAIMINTERFACE, &ifc);
				if (n != 0) {
					close(fd);
					free(usb);
					usb = 0;
					continue;
				}
			} else
				close(fd);
		}
		closedir(devdir);
	}
	closedir(busdir);

	return usb;
}

int usb_write(struct usb_handle *h, const void *_data, int len)
{
	unsigned char *data = (unsigned char *) _data;
	unsigned count = 0;
	struct usbdevfs_bulktransfer bulk;
	int n;

	if (h->ep_out == 0)
		return -1;

	if (len == 0) {
		bulk.ep = h->ep_out;
		bulk.len = 0;
		bulk.data = data;
		bulk.timeout = 0;

		n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
		if (n != 0) {
			fprintf(stderr, "ERROR: n = %d, errno = %d (%s)\n",
			n, errno, strerror(errno));
			return -1;
		}
		return 0;
	}

	while (len > 0) {
		int xfer;
		xfer = (len > 4096) ? 4096 : len;

		bulk.ep = h->ep_out;
		bulk.len = xfer;
		bulk.data = data;
		bulk.timeout = 0;

		n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
		if (n != xfer) {
			DBG("ERROR: n = %d, errno = %d (%s)\n",
				n, errno, strerror(errno));
			return -1;
		}

		count += xfer;
		len -= xfer;
		data += xfer;
	}

	return count;
}

int usb_read(struct usb_handle *h, void *_data, int len)
{
	unsigned char *data = (unsigned char *) _data;
	unsigned count = 0;
	struct usbdevfs_bulktransfer bulk;
	int n, retry;

	if (h->ep_in == 0)
		return -1;

	while (len > 0) {
		int xfer = (len > 4096) ? 4096 : len;

		bulk.ep = h->ep_in;
		bulk.len = xfer;
		bulk.data = data;
		bulk.timeout = 0;
		retry = 0;

		do {
			DBG("[ usb read %d fd = %d], fname=%s\n",
				xfer, h->desc, h->fname);
			n = ioctl(h->desc, USBDEVFS_BULK, &bulk);
			DBG("[ usb read %d ] = %d, fname=%s, Retry %d\n",
			xfer, n, h->fname, retry);

			if (n < 0) {
				DBG1("ERROR: n = %d, errno = %d (%s)\n",
				n, errno, strerror(errno));
				if (++retry > MAX_RETRIES)
					return -1;
				usleep(10000);
			}
		} while (n < 0);

		count += n;
		len -= n;
		data += n;

		if (n < xfer)
			break;
	}

	return count;
}

void usb_kick(struct usb_handle *h)
{
	int fd;

	fd = h->desc;
	h->desc = -1;
	if (fd >= 0) {
		close(fd);
		DBG("[ usb closed %d ]\n", fd);
	}
}

int usb_close(struct usb_handle *h)
{
	int fd;

	fd = h->desc;
	h->desc = -1;
	if (fd >= 0) {
		close(fd);
		DBG("[ usb closed %d ]\n", fd);
	}

	return 0;
}

struct usb_handle *usb_open(ifc_match_func callback)
{
	return find_usb_device("/dev/bus/usb", callback);
}
