/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved.

 */

/*

 * This library can either be used stand-alone or as plugin

 * to the libusb wrapper library.

 * The libusb API 0.1.0.10 has been implemented using all original code

 * which was not derived from opensource.

 *

 * XXX issues:

 *	- timeout thru signal

 *	- usb_interrupt/bulk_write/read should have common code

 */

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <string.h>

#include <fcntl.h>

#include <sys/time.h>

#include <dirent.h>

#include <stdarg.h>

#include <strings.h>

#include <sys/stat.h>

#include <regex.h>

#include <sys/usb/clients/ugen/usb_ugen.h>

#include "usb.h"

#include "libusbugen_impl.h"

/* global variables */

usb_bus_t *usb_busses = NULL;

const char *libusb_version = "1.1";

/* error handling */

static	char usb_error_string[1024];

static	int usb_error_errno;

static	usb_error_type_t usb_error_type = USB_ERROR_TYPE_NONE;

/* debugging */

static	int libusb_debug = DEBUG_NONE;

/* api binding */

static	int libusb_api = API_RELAXED;

/* internal function prototypes */

static	void usb_error_str(int x, char *format, ...);

static	int usb_error(int x);

static	void usb_dprintf(int level, char *format, ...);

static	void usb_dump_data(char *data, int size);

static	int usb_open_ep0(usb_dev_handle_impl_t *hdl);

static	void usb_close_ep0(usb_dev_handle_impl_t *hdl);

static	int usb_check_access(usb_dev_handle *dev);

static	int usb_search_dev_usb(usb_device_t **new_devices);

static	int usb_do_io(int fd, int stat_fd, char *data, size_t size, int flag);

static	int usb_send_msg(int fd, int stat_fd, int requesttype, int request,

	int value, int index, char *data, int size);

static	int usb_check_device_and_status_open(usb_dev_handle *dev,

	int ep, int ep_type, int mode);

static	int usb_get_status(int fd);

static	void usb_set_ep_iface_alts(usb_dev_handle_impl_t *hdl,

	usb_dev_handle_info_t *info, int index, int interface, int alternate);

static	int usb_setup_all_configs(usb_dev_handle_impl_t *hdl);

static	void usb_free_all_configs(usb_device_t *device);

static	int usb_parse_config(usb_dev_handle_impl_t *hdl, uint_t index);

static	void usb_free_config(usb_device_t *device, uint_t index);

static	int usb_parse_interface(usb_dev_handle_impl_t *hdl, uint_t index,

	uint_t iface, char *cloud);

static	void usb_free_interface(usb_device_t *device, uint_t index,

	uint_t iface);

static	int usb_parse_alternate(usb_dev_handle_impl_t *hdl, uint_t index,

	uint_t iface, uint_t alt, char *cloud);

static	void usb_free_alternate(usb_device_t *device, uint_t index,

	uint_t iface, uint_t alt);

static	int usb_parse_endpoint(usb_dev_handle_impl_t *hdl, int index,

	int iface, int alt, int ep, char *cloud);

static	void usb_find_extra(uchar_t *buf, size_t buflen,

	unsigned char **extra, int *extralen);

static	void usb_close_all_eps(usb_dev_handle_impl_t *hdl);

static	void usb_add_device(usb_device_t **list, usb_device_t *dev);

static	void usb_remove_device(usb_device_t **list, usb_device_t *dev);

static	int usb_check_device_in_list(usb_device_t *list, usb_device_t *dev);

static	void usb_free_dev(usb_device_t *dev);

static	void usb_free_bus(usb_bus_t *bus);

static size_t usb_parse_dev_descr(uchar_t *buf, size_t buflen,

	struct usb_device_descriptor *ret_descr, size_t	ret_buf_len);

static size_t usb_parse_cfg_descr(uchar_t *buf, size_t buflen,

	usb_cfg_descr_t	*ret_descr, size_t ret_buf_len,

	unsigned char **extra, int *extralen);

static size_t usb_parse_if_descr(uchar_t *buf, size_t buflen,

	uint_t if_number, uint_t alt_if_setting,

	usb_if_descr_t *ret_descr, size_t ret_buf_len,

	unsigned char **extra, int *extralen);

static size_t usb_parse_ep_descr(uchar_t *buf, size_t buflen,

	uint_t if_number, uint_t alt_if_setting, uint_t ep_index,

	usb_ep_descr_t *ret_descr, size_t ret_buf_len,

	unsigned char **extra, int *extralen);

static uchar_t usb_ep_index(uint8_t ep_addr);

/*

 * libusb_init:

 *

 * Returns: 0 or ENOSUP if we cannot support any bus

 */

int

libusb_init(void)

{

	return (0);

}

/*

 * libusb_fini:

 *

 * Returns: always returns 0

 */

int

libusb_fini(void)

{

	return (0);

}

/*

 * Entry points:

 *

 * usb_set_debug:

 *	sets debug level for tracing

 */

void

usb_set_debug(int level)

{

	if (getenv("SUN_LIBUSBUGEN_DEBUG")) {

		level =	atoi(getenv("SUN_LIBUSBUGEN_DEBUG"));

	} else if (getenv("SUN_LIBUSB_DEBUG")) {

		level = atoi(getenv("SUN_LIBUSB_DEBUG"));

	}

	if (level < 0)

		return;

	libusb_debug = level;

	usb_dprintf(DEBUG_FUNCTIONS, "usb_set_debug(): "

	    "Setting debugging level to %d (%s)\n",

	    level, level ? "on" : "off");

}

/*

 * usb_init:

 *	not much to initialize. just set debug level

 */

void

usb_init(void)

{

	if (getenv("LIBUSB_API_STRICT")) {

		libusb_api = API_STRICT;

	}

	usb_set_debug(libusb_debug);

	usb_dprintf(DEBUG_FUNCTIONS, "usb_init(): "

	    "libusb version=%s\n", libusb_version);

}

/*

 * usb_get_busses:

 * Returns: usb_busses pointer

 */

usb_bus_t *

usb_get_busses(void)

{

	return (usb_busses);

}

/*

 * usb_find_busses:

 *	finds all busses in the system. On solaris we have

 *	only one flat name space, /dev/usb

 *

 * Returns: change in number of busses or negative errno

 */

int

usb_find_busses(void)

{

	usb_bus_t *bus;

	/* we only have one name space for all USB busses */

	if (usb_busses == NULL) {

		/* never freed */

		if ((bus = calloc(sizeof (*bus), 1)) == NULL) {

			return (usb_error(ENOMEM));

		}

		(void) strncpy(bus->dirname, "/dev/usb",

		    sizeof (bus->dirname));

		usb_dprintf(DEBUG_FUNCTIONS, "usb_find_busses(): "

		    "found %s\n", bus->dirname);

		usb_busses = bus;

		return (1);

	}

	return (0);

}

/*

 * usb_find_devices:

 *	finds all devices that have appeared and removes devices

 *	from the list that are no longer there

 *

 * Returns: change in number of devices or a negative errno

 */

int

usb_find_devices(void)

{

	int i, rval, found;

	int changes = 0;

	usb_device_t *new_devices;

	usb_device_t *dev, *next_dev, *new, *next_new;

	new_devices = NULL;

	rval = usb_search_dev_usb(&new_devices);

	if (rval != 0) {

		return (usb_error(rval));

	}

	/* is any of devices on the new list also on the old list? */

	for (dev = usb_busses->devices; dev != NULL; dev = next_dev) {

		next_dev = dev->next;

		found = 0;

		for (new = new_devices; new != NULL; new = next_new) {

			next_new = new->next;

			if (strncmp(dev->filename, new->filename,

			    sizeof (dev->filename)) == 0) {

				usb_remove_device(&new_devices, new);

				usb_free_dev(new);

				found++;

				break;

			}

		}

		/* the device must have been hot removed */

		if (!found) {

			usb_remove_device(&usb_busses->devices, dev);

			usb_free_dev(dev);

		}

	}

	/* add all new_devices to the old_devices list */

	usb_dprintf(DEBUG_DETAILED, "moving new to old\n");

	for (new = new_devices; new != NULL; new = next_new) {

		next_new = new->next;

		usb_remove_device(&new_devices, new);

		usb_add_device(&usb_busses->devices, new);

		(void) usb_close(usb_open(new));

		changes++;

	}

	usb_dprintf(DEBUG_DETAILED, "usb_devices list:\n");

	for (i = 0, dev = usb_busses->devices; dev != NULL;

	    i++, dev = next_dev) {

		next_dev = dev->next;

		usb_dprintf(DEBUG_DETAILED, "%d: %s\n", i, dev->filename);

	}

	return (changes);

}

/*

 * usb_device:

 *	 included because sane uses this

 * Returns: usb_device structure associated with handle

 */

struct usb_device *

usb_device(usb_dev_handle *dev)

{

	usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;

	return ((hdl != NULL) ? hdl->device : NULL);

}

/*

 * usb_open:

 *	opens the device for access

 *

 * Returns: a usb device handle or NULL

 */

usb_dev_handle *

usb_open(usb_device_t *dev)

{

	usb_dev_handle_impl_t	*hdl;

	usb_dev_handle_info_t	*info;

	int			i, rval;

	usb_dprintf(DEBUG_FUNCTIONS, "usb_open():\n");

	if (usb_check_device_in_list(usb_busses->devices,

	    dev) == 0) {

		usb_dprintf(DEBUG_ERRORS, "usb_open(): "

		    "illegal usb_device pointer\n");

		return (NULL);

	}

	/* create a handle and info structure */

	if ((hdl = calloc(sizeof (*hdl), 1)) == NULL) {

		return (NULL);

	}

	hdl->device = dev;

	if ((info = calloc(sizeof (*info), 1)) == NULL) {

		free(hdl);

		return (NULL);

	}

	hdl->info = info;

	/* set all file descriptors to "closed" */

	for (i = 0; i < USB_MAXENDPOINTS; i++) {

		hdl->info->ep_fd[i] = -1;

		hdl->info->ep_status_fd[i] = -1;

		if (i > 0) {

			hdl->info->ep_interface[i] = -1;

		}

	}

	/* open default control ep and keep it open */

	if ((rval = usb_open_ep0(hdl)) != 0) {

		usb_dprintf(DEBUG_ERRORS, "usb_open_ep0 failed: %d\n", rval);

		free(info);

		free(hdl);

		return (NULL);

	}

	/*

	 * setup config info: trees of configs, interfaces, alternates

	 * and endpoints structures

	 */

	if (usb_setup_all_configs(hdl) != 0) {

		usb_free_all_configs(hdl->device);

		usb_close_ep0(hdl);

		free(info);

		free(hdl);

		return (NULL);

	}

	/* set when the app claims an interface */

	info->configuration_value =

	    info->claimed_interface = info->alternate = -1;

	usb_dprintf(DEBUG_FUNCTIONS, "usb_open(): hdl=0x%x\n", (int)hdl);

	return ((usb_dev_handle *)hdl);

}

/*

 * usb_close:

 *	closes the device and free resources

 *

 * Returns: 0

 */

int

usb_close(usb_dev_handle *dev)

{

	usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;

	usb_dev_handle_info_t *info;

	usb_dprintf(DEBUG_FUNCTIONS, "usb_close(): hdl=0x%x\n", hdl);

	if (hdl) {

		info = hdl->info;

		usb_dprintf(DEBUG_DETAILED,

		    "usb_close(): claimed %d\n",

		    info->claimed_interface);

		if (info->claimed_interface != -1) {

			(void) usb_release_interface(dev,

			    info->claimed_interface);

		}

		usb_close_all_eps(hdl);

		usb_close_ep0(hdl);

		free(info);

		free(hdl);

		return (0);

	}

	return (usb_error(EINVAL));

}

/*

 * usb_control_msg:

 *	sends a control message

 *

 * Returns: actual number of data bytes transferred or

 *	    a negative errno

 */

/*ARGSUSED*/

int

usb_control_msg(usb_dev_handle *dev, int requesttype, int request,

    int value, int index, char *data, int size, int timeout)

{

	usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;

	usb_dev_handle_info_t *info;

	int additional;

	int rval;

	usb_dprintf(DEBUG_FUNCTIONS, "usb_control_msg():\n");

	if ((hdl == NULL) || (size < 0)) {

		return (usb_error(EINVAL));

	}

	info = hdl->info;

	/*

	 * no need to do validation since ep0 is always open and

	 * we do not need to claim an interface first

	 *

	 * usb_send_msg returns #bytes xferred or negative errno

	 */

	rval = usb_send_msg(info->ep_fd[0], info->ep_status_fd[0],

	    requesttype, request, value, index, data, size);

	/* less than setup bytes transferred? */

	if (rval < 8) {

		usb_error_str(errno,

		    "error sending control message: %d", rval);

		return ((rval >= 0) ?

		    usb_error(EIO) : usb_error(-rval));

	}

	rval -= 8; /* substract setup length */

	/* for IN requests, now transfer the remaining bytes */

	if ((size) && (requesttype & USB_DEV_REQ_DEV_TO_HOST)) {

		additional = usb_do_io(info->ep_fd[0],

		    info->ep_status_fd[0], data, size, READ);

	} else {

		additional = rval;

	}

	usb_dprintf(DEBUG_FUNCTIONS,

	    "usb_control_msg(): additional 0x%x bytes\n", additional);

	return (additional);

}

/*

 * usb_bulk_write:

 *	writes to a bulk endpoint

 *

 * Returns: actual number of data bytes transferred or negative errno

 */

/* ARGSUSED */

int

usb_bulk_write(usb_dev_handle *dev, int ep, char *data, int size,

    int timeout)

{

	usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;

	usb_dev_handle_info_t *info;

	int sent, rval;

	int ep_index = usb_ep_index(ep);

	usb_dprintf(DEBUG_FUNCTIONS, "usb_bulk_write(): ep=0x%x\n", ep);

	if ((hdl == NULL) || (data == NULL) || (size <= 0)) {

		usb_dprintf(DEBUG_ERRORS,

		    "usb_bulk_write(): NULL handle or data\n");

		return (usb_error(EINVAL));

	}

	info = hdl->info;

	/* do some validation first */

	if ((rval = usb_check_device_and_status_open(dev, ep,

	    USB_ENDPOINT_TYPE_BULK, O_WRONLY)) != 0) {

		usb_dprintf(DEBUG_ERRORS,

		    "usb_check_device_and_status_open() failed\n");

		return (usb_error(rval));

	}

	/* now write out the bytes */

	sent = usb_do_io(info->ep_fd[ep_index], info->ep_status_fd[ep_index],

	    data, size, WRITE);

	return (sent);