/* $(CROSS_COMPILE)gcc -Wall -O3 -g -lusb-1.0 -o cleware cleware.c */

/**

 * cleware.c - Cleware USB-Controlled Power Switch

 *

 * Copyright (C) 2010 Felipe Balbi <felipe.balbi@nokia.com>

 *

 * This file is part of the USB Verification Tools Project

 *

 * USB Tools is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public Liicense as published by

 * the Free Software Foundation, either version 3 of the license, or

 * (at your option) any later version.

 *

 * USB Tools 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 USB Tools. If not, see <http://www.gnu.org/licenses/>.

 */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdint.h>

#include <unistd.h>

#include <errno.h>

#include <getopt.h>

#include <libusb-1.0/libusb.h>

/*

 * this application is known to work with the following

 * device:

 *

 * http://www.cleware.de/produkte/p-usbswitch-E.html

 */

#define CLEWARE_VENDOR_ID	0x0d50

#define CLEWARE_USB_SWITCH	0x0008

#define CLEWARE_USB_SWITCH8	0x0030

#define CLEWARE_TYPE_SWITCH	0x00

#define CLEWARE_TYPE_CONTACT	0x03

struct usb_device_id {

	unsigned		idVendor;

	unsigned		idProduct;

	unsigned		num_ports;

	unsigned		type;

};

#define USB_DEVICE(v, p, n, t)		\

{					\

	.idVendor		= v,	\

	.idProduct		= p,	\

	.num_ports		= n,	\

	.type			= t	\

}

static struct usb_device_id cleware_id[] = {

	USB_DEVICE(CLEWARE_VENDOR_ID, CLEWARE_USB_SWITCH, 4,

			CLEWARE_TYPE_SWITCH),

	USB_DEVICE(CLEWARE_VENDOR_ID, CLEWARE_USB_SWITCH8, 8,

			CLEWARE_TYPE_CONTACT),

};

static int num_ports;

static unsigned type;

static int debug;

#define DBG(fmt, args...)			\

	if (debug)				\

		fprintf(stdout, fmt, ## args)

#define TIMEOUT			1000	/* ms */

#define ARRAY_SIZE(x)	(sizeof(x) / sizeof((x)[0]))

static int match_device_id(libusb_device *udev)

{

	struct libusb_device_descriptor	desc;

	int				match = 0;

	int				ret;

	int				i;

	ret = libusb_get_device_descriptor(udev, &desc);

	if (ret < 0) {

		DBG("%s: failed to get device descriptor\n", __func__);

		return ret;

	}

	DBG("%s: got device desc for %04x:%04x\n", __func__,

			desc.idVendor, desc.idProduct);

	for (i = 0; i < ARRAY_SIZE(cleware_id); i++) {

		if ((desc.idVendor == cleware_id[i].idVendor) &&

				(desc.idProduct == cleware_id[i].idProduct)) {

			match = 1;

			num_ports = cleware_id[i].num_ports;

			type = cleware_id[i].type;

			DBG("%s: matched device %04x:%04x num_ports %d\n",__func__,

					desc.idVendor, desc.idProduct, num_ports);

		}

	}

	return match;

}

static int match_device_serial_number(libusb_device *udev, unsigned iSerial)

{

	struct libusb_device_descriptor	desc;

	libusb_device_handle		*tmp;

	unsigned int			serialnumber;

	unsigned char			serial[256];

	int				ret;

	ret = libusb_get_device_descriptor(udev, &desc);

	if (ret < 0) {

		DBG("%s: failed to get device descriptor\n", __func__);

		goto out0;

	}

	ret = libusb_open(udev, &tmp);

	if (ret < 0 || !tmp) {

		DBG("%s: couldn't open device\n", __func__);

		goto out0;

	}

	if (libusb_kernel_driver_active(tmp, 0)) {

		ret = libusb_detach_kernel_driver(tmp, 0);

		if (ret < 0) {

			DBG("%s: couldn't detach kernel driver\n", __func__);

			goto out1;

		}

	}

	ret = libusb_get_string_descriptor_ascii(tmp, desc.iSerialNumber,

			serial, sizeof(serial));

	if (ret < 0) {

		DBG("%s: failed to get string descriptor\n", __func__);

		goto out1;

	}

	ret = strtoul((const char *) &serial, NULL, 16);

	if (ret < 0) {

		DBG("%s: failed to get serial number\n", __func__);

		goto out2;

	}

	serialnumber = ret;

	if (serialnumber != iSerial) {

		DBG("%s: not the serial number we want\n", __func__);

		goto out2;

	}

out2:

	libusb_attach_kernel_driver(tmp, 0);

out1:

	libusb_close(tmp);

out0:

	return ret;

}

static void print_device_attributes(libusb_device *udev)

{

	struct libusb_device_descriptor	desc;

	libusb_device_handle		*tmp;

	int				ret;

	unsigned char			product[256] = { };

	ret = libusb_get_device_descriptor(udev, &desc);

	if (ret < 0) {

		DBG("%s: failed to get device descriptor\n", __func__);

		return;

	}

	ret = libusb_open(udev, &tmp);

	if (ret < 0 || !tmp) {

		DBG("%s: couldn't open device\n", __func__);

		return;

	}

	if (libusb_kernel_driver_active(tmp, 0)) {

		ret = libusb_detach_kernel_driver(tmp, 0);

		if (ret < 0) {

			DBG("%s: couldn't detach kernel driver\n", __func__);

			libusb_close(tmp);

			return;

		}

	}

	if (desc.iProduct) {

		ret = libusb_get_string_descriptor_ascii(tmp, desc.iProduct,

				product, sizeof(product));

		if (ret < 0) {

			DBG("%s: failed to get product name\n", __func__);

			libusb_attach_kernel_driver(tmp, 0);

			libusb_close(tmp);

			return;

		}

	}

	fprintf(stdout, "%04x:%04x\t%s\n", desc.idVendor, desc.idProduct,

			product);

	libusb_attach_kernel_driver(tmp, 0);

}

static void list_devices(libusb_device **list, ssize_t count)

{

	int				i;

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

		libusb_device *udev = list[i];

		if (match_device_id(udev))

			print_device_attributes(udev);

	}

}

static libusb_device_handle *find_and_open_device(libusb_device **list,

		ssize_t count, unsigned iSerial)

{

	libusb_device_handle		*udevh = NULL;

	libusb_device			*found = NULL;

	int				ret;

	int				i;

	DBG("%s: iterating over %zd devices\n", __func__, count);

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

		libusb_device *udev = list[i];

		ret = match_device_id(udev);

		if (ret <= 0) {

			DBG("%s: couldn't match device id\n", __func__);

			continue;

		}

		if (iSerial) {

			ret = match_device_serial_number(udev, iSerial);

			if (ret < 0) {

				DBG("%s: couldn't match serial number\n", __func__);

				found = NULL;

				break;

			}

		}

		found = udev;

		break;

	}

	if (found) {

		ret = libusb_open(found, &udevh);

		if (ret < 0 || !found) {

			DBG("%s: couldn't open device\n", __func__);

			goto out;

		}

	}

out:

	return udevh;

}

static int find_and_claim_interface(libusb_device_handle *udevh)

{

	int			ret;

	if (libusb_kernel_driver_active(udevh, 0)) {

		ret = libusb_detach_kernel_driver(udevh, 0);

		if (ret < 0) {

			DBG("%s: couldn't detach kernel driver\n", __func__);

			goto out0;

		}

	}

	ret = libusb_set_configuration(udevh, 1);

	if (ret < 0) {

		DBG("%s: couldn't set configuration 1\n", __func__);

		goto out0;

	}

	ret = libusb_claim_interface(udevh, 0);

	if (ret < 0) {

		DBG("%s: couldn't claim interface 0\n", __func__);

		goto out0;

	}

	ret = libusb_set_interface_alt_setting(udevh, 0, 0);

	if (ret < 0) {

		DBG("%s: couldn't set alternate setting 0\n", __func__);

		goto out1;

	}

	return 0;

out1:

	libusb_release_interface(udevh, 0);

out0:

	return ret;

}

static void release_interface(libusb_device_handle *udevh)

{

	libusb_release_interface(udevh, 0);

}

static int set_led(libusb_device_handle *udevh, unsigned led, unsigned on)

{

	unsigned char		data[3];

	data[0] = 0x00;

	data[1] = led;

	data[2] = on ? 0x00 : 0x0f;

	return libusb_control_transfer(udevh, 0x21, 0x09, 0x200, 0x00,

			data, sizeof(data), TIMEOUT);

}

static inline int set_switch8(libusb_device_handle *udevh, unsigned port, unsigned on)

{

	unsigned char		data[5];

	data[0] = type;

	data[1] = 0x00;

	data[2] = on ? (1 << port) : 0x00;

	data[3] = 0x00;

	data[4] = (1 << port);

	return libusb_control_transfer(udevh, 0x21, 0x09, 0x200, 0x00,

			data, sizeof(data), TIMEOUT);

}

static inline int set_switch4(libusb_device_handle *udevh, unsigned port, unsigned on)

{

	unsigned char		data[3];

	data[0] = type;

	data[1] = port + 0x10;

	data[2] = on & 0x01;

	return libusb_control_transfer(udevh, 0x21, 0x09, 0x200, 0x00,

			data, 3, TIMEOUT);

}

static int set_switch(libusb_device_handle *udevh, unsigned port, unsigned on)

{

	if (type == CLEWARE_TYPE_SWITCH) {

		return set_switch4(udevh, port, on);

	} else if (type == CLEWARE_TYPE_CONTACT) {

		return set_switch8(udevh, port, on);

	} else {

		DBG("%s: unsupported type\n", __func__);

		return -EINVAL;

	}

}

static int set_power(libusb_device_handle *udevh, unsigned port, unsigned on)

{

	int			ret;

	if (port > num_ports) {

		DBG("%s: this device doesn't have that many ports\n", __func__);

		return -EINVAL;

	}

	ret = set_switch(udevh, port - 1, on);

	if (ret < 0) {

		DBG("%s: failed to toggle switch %d\n", __func__, port);

		return ret;

	}

	if (port == 1) {

		ret = set_led(udevh, port - 1, on);

		if (ret < 0) {

			DBG("%s: couldn't toggle led %d\n", __func__, port);

			return ret;

		}

		ret = set_led(udevh, port, !on);

		if (ret < 0) {

			DBG("%s: couldn't toggle led %d\n", __func__, port + 1);

			return ret;

		}

	}

	return 0;

}

static void usage(char *name)

{

	fprintf(stdout, "usage: %s [-0 | -1] [-s SerialNumber] [-d] [-h]\n\

			-0, --off		Switch it off\n\

			-1, --on		Switch it on\n\

			-s, --serial-number	Device's serial number\n\

			-p, --port		port number\n\

			-d, --debug		Enable debugging\n\

			-h, --help		Print this\n", name);

}

#define OPTION(n, h, v)		\

{				\

	.name		= #n,	\

	.has_arg	= h,	\

	.val		= v,	\

}

static struct option cleware_opts[] = {

	OPTION("on",		0,	'0'),

	OPTION("off",		0,	'1'),

	OPTION("serial-number",	1,	's'),

	OPTION("port",		1,	'p'),

	OPTION("list",		0,	'l'),

	OPTION("debug",		0,	'd'),

	OPTION("help",		0,	'h'),

	{  }	/* Terminating entry */

};

int main(int argc, char *argv[])

{

	libusb_context		*context;

	libusb_device_handle	*udevh;

	libusb_device		**list;

	unsigned		port = 1;

	unsigned		iSerial = 0;

	unsigned		list_devs = 0;

	ssize_t			count;

	int			ret = 0;

	int			on = 0;

	while (ARRAY_SIZE(cleware_opts)) {

		int		optidx = 0;

		int		opt;

		opt = getopt_long(argc, argv, "l01p:s:dh", cleware_opts, &optidx);

		if (opt < 0)

			break;

		switch (opt) {

		case 'l':

			list_devs = 1;

			break;

		case '0':

			on = 0;

			break;

		case '1':

			on = 1;

			break;

		case 'p':

			port = atoi(optarg);

			break;

		case 's':

			iSerial = strtoul(optarg, NULL, 16);

			break;

		case 'd':

			debug = 1;

			break;

		case 'h': /* FALLTHROUGH */

		default:

			usage(argv[0]);

			return 0;

		}

	}

	/* initialize libusb */

	libusb_init(&context);

	/* get rid of debug messages */

	libusb_set_debug(context, 0);

	count = libusb_get_device_list(context, &list);

	if (count < 0) {

		DBG("%s: couldn't get device list\n", __func__);

		ret = count;

		goto out1;

	}

	if (list_devs) {

		list_devices(list, count);

		goto out1;

	}

	udevh = find_and_open_device(list, count, iSerial);

	if (!udevh) {

		DBG("%s: couldn't find a suitable device\n", __func__);

		goto out2;

	}

	ret = find_and_claim_interface(udevh);

	if (ret < 0) {

		DBG("%s: couldn't claim interface\n", __func__);

		goto out2;

	}

	ret = set_power(udevh, port, on);

	if (ret < 0) {

		DBG("%s: couldn't switch power %s\n", __func__,

				on ? "on" : "off");

		goto out3;

	}

out3:

	release_interface(udevh);

out2:

	libusb_close(udevh);

	libusb_free_device_list(list, 1);

out1:

	libusb_exit(context);

	return ret;

}