[usb-driver] / xpcu.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <usb.h>
#include <errno.h>
#include <pthread.h>
#include "usb-driver.h"
#include "xpcu.h"

static struct usb_bus *busses = NULL;
static pthread_mutex_t dummy_interrupt = PTHREAD_MUTEX_INITIALIZER;

int xpcu_deviceinfo(struct xpcu_s *xpcu, struct usb_get_device_data *ugdd) {
	int i,j,k,l;
	int len = 0;
	unsigned char *buf = NULL;
	WDU_CONFIGURATION **pConfigs, **pActiveConfig;
	WDU_INTERFACE **pActiveInterface;

	if (ugdd->dwUniqueID != (unsigned long)xpcu)
		return -ENODEV;
	
	if (!xpcu)
		return -ENODEV;

	if (ugdd->dwBytes)
		buf = ugdd->pBuf;

	if (buf) {
		struct usb_device_info *udi = (struct usb_device_info*)(buf+len);

		udi->Descriptor.bLength = sizeof(WDU_DEVICE_DESCRIPTOR);
		udi->Descriptor.bDescriptorType = xpcu->dev->descriptor.bDescriptorType;
		udi->Descriptor.bcdUSB = xpcu->dev->descriptor.bcdUSB;
		udi->Descriptor.bDeviceClass = xpcu->dev->descriptor.bDeviceClass;
		udi->Descriptor.bDeviceSubClass = xpcu->dev->descriptor.bDeviceSubClass;
		udi->Descriptor.bDeviceProtocol = xpcu->dev->descriptor.bDeviceProtocol;
		udi->Descriptor.bMaxPacketSize0 = xpcu->dev->descriptor.bMaxPacketSize0;
		udi->Descriptor.idVendor = xpcu->dev->descriptor.idVendor;
		udi->Descriptor.idProduct = xpcu->dev->descriptor.idProduct;
		udi->Descriptor.bcdDevice = xpcu->dev->descriptor.bcdDevice;
		udi->Descriptor.iManufacturer = xpcu->dev->descriptor.iManufacturer;
		udi->Descriptor.iProduct = xpcu->dev->descriptor.iProduct;
		udi->Descriptor.iSerialNumber = xpcu->dev->descriptor.iSerialNumber;
		udi->Descriptor.bNumConfigurations = xpcu->dev->descriptor.bNumConfigurations;

		/* TODO: Fix Pipe0! */
		udi->Pipe0.dwNumber = 0x00;
		udi->Pipe0.dwMaximumPacketSize = xpcu->dev->descriptor.bMaxPacketSize0;
		udi->Pipe0.type = 0;
		udi->Pipe0.direction = WDU_DIR_IN_OUT;
		udi->Pipe0.dwInterval = 0;

		pConfigs = &(udi->pConfigs);
		pActiveConfig = &(udi->pActiveConfig);
		pActiveInterface = &(udi->pActiveInterface[0]);
	}

	len = sizeof(struct usb_device_info);

	for (i=0; i<xpcu->dev->descriptor.bNumConfigurations; i++)
	{
		struct usb_config_descriptor *conf_desc = &xpcu->dev->config[i];
		WDU_INTERFACE **pInterfaces;
		WDU_ALTERNATE_SETTING **pAlternateSettings[conf_desc->bNumInterfaces];
		WDU_ALTERNATE_SETTING **pActiveAltSetting[conf_desc->bNumInterfaces];

		if (buf) {
			WDU_CONFIGURATION *cfg = (WDU_CONFIGURATION*)(buf+len);

			*pConfigs = cfg;
			*pActiveConfig = cfg;

			cfg->Descriptor.bLength = conf_desc->bLength;
			cfg->Descriptor.bDescriptorType = conf_desc->bDescriptorType;
			cfg->Descriptor.wTotalLength = conf_desc->wTotalLength;
			cfg->Descriptor.bNumInterfaces = conf_desc->bNumInterfaces;
			cfg->Descriptor.bConfigurationValue = conf_desc->bConfigurationValue;
			cfg->Descriptor.iConfiguration = conf_desc->iConfiguration;
			cfg->Descriptor.bmAttributes = conf_desc->bmAttributes;
			cfg->Descriptor.MaxPower = conf_desc->MaxPower;

			cfg->dwNumInterfaces = conf_desc->bNumInterfaces;

			pInterfaces = &(cfg->pInterfaces);
		}
		len += sizeof(WDU_CONFIGURATION);

		if (buf) {
			*pInterfaces = (WDU_INTERFACE*)(buf+len);
			for (j=0; j<conf_desc->bNumInterfaces; j++) {
				WDU_INTERFACE *iface = (WDU_INTERFACE*)(buf+len);

				pActiveInterface[j] = iface;

				pAlternateSettings[j] = &(iface->pAlternateSettings);
				iface->dwNumAltSettings = xpcu->dev->config[i].interface[j].num_altsetting;
				pActiveAltSetting[j] = &(iface->pActiveAltSetting);

				len += sizeof(WDU_INTERFACE);
			}
		} else {
			len += sizeof(WDU_INTERFACE) * conf_desc->bNumInterfaces;
		}

		for (j=0; j<conf_desc->bNumInterfaces; j++)
		{
			struct usb_interface *interface = &xpcu->dev->config[i].interface[j];

			if (buf) {
				*pAlternateSettings[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
				/* FIXME: */
				*pActiveAltSetting[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
			}

			for(k=0; k<interface->num_altsetting; k++)
			{
				unsigned char bNumEndpoints = interface->altsetting[k].bNumEndpoints;
				WDU_ENDPOINT_DESCRIPTOR **pEndpointDescriptors;
				WDU_PIPE_INFO **pPipes;

				if (buf) {
					WDU_ALTERNATE_SETTING *altset = (WDU_ALTERNATE_SETTING*)(buf+len);

					altset->Descriptor.bLength = interface->altsetting[k].bLength;
					altset->Descriptor.bDescriptorType = interface->altsetting[k].bDescriptorType;
					altset->Descriptor.bInterfaceNumber = interface->altsetting[k].bInterfaceNumber;
					altset->Descriptor.bAlternateSetting = interface->altsetting[k].bAlternateSetting;
					altset->Descriptor.bNumEndpoints = interface->altsetting[k].bNumEndpoints;
					altset->Descriptor.bInterfaceClass = interface->altsetting[k].bInterfaceClass;
					altset->Descriptor.bInterfaceSubClass = interface->altsetting[k].bInterfaceSubClass;
					altset->Descriptor.bInterfaceProtocol = interface->altsetting[k].bInterfaceProtocol;
					altset->Descriptor.iInterface = interface->altsetting[k].iInterface;
					pEndpointDescriptors = &(altset->pEndpointDescriptors);
					pPipes = &(altset->pPipes);

				}
				len +=sizeof(WDU_ALTERNATE_SETTING);

				if (buf) {
					*pEndpointDescriptors = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);
					for (l = 0; l < bNumEndpoints; l++) {
						WDU_ENDPOINT_DESCRIPTOR *ed = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);

						ed->bLength = interface->altsetting[k].endpoint[l].bLength;
						ed->bDescriptorType = interface->altsetting[k].endpoint[l].bDescriptorType;
						ed->bEndpointAddress = interface->altsetting[k].endpoint[l].bEndpointAddress;
						ed->bmAttributes = interface->altsetting[k].endpoint[l].bmAttributes;
						ed->wMaxPacketSize = interface->altsetting[k].endpoint[l].wMaxPacketSize;
						ed->bInterval = interface->altsetting[k].endpoint[l].bInterval;

						len += sizeof(WDU_ENDPOINT_DESCRIPTOR);
					}
						
					*pPipes = (WDU_PIPE_INFO*)(buf+len);
					for (l = 0; l < bNumEndpoints; l++) {
						WDU_PIPE_INFO *pi = (WDU_PIPE_INFO*)(buf+len);

						pi->dwNumber = interface->altsetting[k].endpoint[l].bEndpointAddress;
						pi->dwMaximumPacketSize = WDU_GET_MAX_PACKET_SIZE(interface->altsetting[k].endpoint[l].wMaxPacketSize);
						pi->type = interface->altsetting[k].endpoint[l].bmAttributes & USB_ENDPOINT_TYPE_MASK;
						if (pi->type == PIPE_TYPE_CONTROL)
							pi->direction = WDU_DIR_IN_OUT;
						else
						{
							pi->direction = interface->altsetting[k].endpoint[l].bEndpointAddress & USB_ENDPOINT_DIR_MASK ?  WDU_DIR_IN : WDU_DIR_OUT;
						}

						pi->dwInterval = interface->altsetting[k].endpoint[l].bInterval;

						len += sizeof(WDU_PIPE_INFO);
					}
				} else {
					len +=(sizeof(WDU_ENDPOINT_DESCRIPTOR)+sizeof(WDU_PIPE_INFO))*bNumEndpoints;
				}
			}
		}
	}

	ugdd->dwBytes = len;

	return 0;
}

static int xpcu_claim(struct xpcu_s *xpcu, int claim) {
	int ret = 0;
	static int claimed = 0;

	if (xpcu->interface < 0)
		return -1;
	
	if (claim == XPCU_CLAIM) {
		if (claimed)
			return 0;

		ret = usb_claim_interface(xpcu->handle, xpcu->interface);
		if (!ret) {
			claimed = 1;
			ret = usb_set_altinterface(xpcu->handle, xpcu->alternate);
			if (ret)
				fprintf(stderr, "usb_set_altinterface: %d\n", ret);
		} else {
			fprintf(stderr, "usb_claim_interface: %d -> %d (%s)\n",
					xpcu->interface, ret, usb_strerror());
		}
	} else {
		if (!claimed)
			return 0;

		ret = usb_release_interface(xpcu->handle, xpcu->interface);
		if (!ret)
			claimed = 0;
	}

	return ret;
}

int xpcu_transfer(struct xpcu_s *xpcu, struct usb_transfer *ut) {
	int ret = 0;

	if (ut->dwUniqueID != (unsigned long)xpcu)
		return -ENODEV;
	
	if (!xpcu)
		return -ENODEV;

	xpcu_claim(xpcu, XPCU_CLAIM);
	/* http://www.jungo.com/support/documentation/windriver/802/wdusb_man_mhtml/node55.html#SECTION001213000000000000000 */
	if (ut->dwPipeNum == 0) { /* control pipe */
		int requesttype, request, value, index, size;
		requesttype = ut->SetupPacket[0];
		request = ut->SetupPacket[1];
		value = ut->SetupPacket[2] | (ut->SetupPacket[3] << 8);
		index = ut->SetupPacket[4] | (ut->SetupPacket[5] << 8);
		size = ut->SetupPacket[6] | (ut->SetupPacket[7] << 8);
		DPRINTF("-> requesttype: %x, request: %x, value: %u, index: %u, size: %u\n", requesttype, request, value, index, size);
		ret = usb_control_msg(xpcu->handle, requesttype, request, value, index, ut->pBuffer, size, ut->dwTimeout);
	} else {
		if (ut->fRead) {
			ret = usb_bulk_read(xpcu->handle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
		} else {
			ret = usb_bulk_write(xpcu->handle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
		}
		xpcu_claim(xpcu, XPCU_RELEASE);
	}

	if (ret < 0) {
		fprintf(stderr, "usb_transfer: %d (%s)\n", ret, usb_strerror());
	} else {
		ut->dwBytesTransferred = ret;
		ret = 0;
	}

	return ret;
}

int xpcu_set_interface(struct xpcu_s *xpcu, struct usb_set_interface *usi) {
	if (usi->dwUniqueID != (unsigned long)xpcu)
		return -ENODEV;
	
	if (!xpcu)
		return -ENODEV;

	if (xpcu->dev) {
		if (!xpcu->handle) {
			xpcu->handle = usb_open(xpcu->dev);
#ifndef NO_USB_RESET
			if (xpcu->handle) {
				usb_reset(xpcu->handle);
				xpcu->handle = usb_open(xpcu->dev);
			}
#endif
		}

		xpcu->interface = xpcu->dev->config[0].interface[usi->dwInterfaceNum].altsetting[usi->dwAlternateSetting].bInterfaceNumber;
		xpcu->alternate = usi->dwAlternateSetting;
	}

	return 0;
}

static void xpcu_init(void) {
	if (busses)
		return;

	usb_init();
	usb_find_busses();
	usb_find_devices();

	busses = usb_get_busses();
}


struct xpcu_s *xpcu_find(struct event *e) {
	static struct xpcu_s xpcu;
	char* devpos;
	struct usb_bus *bus;
	int busnum = -1, devnum = -1;
	int i;

	bzero(&xpcu, sizeof(xpcu));
	xpcu_init();

	devpos = getenv("XILINX_USB_DEV");
	if (devpos != NULL) {
		int j;
		char *devstr = NULL, *remainder;

		DPRINTF("XILINX_USB_DEV=%s\n", devpos);

		for (j = 0; j < strlen(devpos) && devpos[j] != 0; j++) {
			if (devpos[j] == ':') {
				devpos[j] = 0;
				devstr = &(devpos[j+1]);
			}
		}

		if (devstr && strlen(devstr) > 0) {
			busnum = strtol(devpos, &remainder, 10);
			if (devpos == remainder) {
				busnum = -1;
			} else {
				devnum = strtol(devstr, &remainder, 10);
				if (devstr == remainder) {
					busnum = -1;
					devnum = -1;
				} else {
					fprintf(stderr,"Using XILINX platform cable USB at %03d:%03d\n",
							busnum, devnum);
				}
			}
		}
	}

	for (i = 0; i < e->dwNumMatchTables; i++) {

		DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
				e->matchTables[i].VendorId,
				e->matchTables[i].ProductId,
				e->matchTables[i].bDeviceClass,
				e->matchTables[i].bDeviceSubClass,
				e->matchTables[i].bInterfaceClass,
				e->matchTables[i].bInterfaceSubClass,
				e->matchTables[i].bInterfaceProtocol);

		for (bus = busses; bus; bus = bus->next) {
			struct usb_device *dev;

			if ((devnum != -1) && (strtol(bus->dirname, NULL, 10) != busnum))
				continue;

			for (dev = bus->devices; dev; dev = dev->next) {
				struct usb_device_descriptor *desc = &(dev->descriptor);

				if((desc->idVendor == e->matchTables[i].VendorId) &&
						(desc->idProduct == e->matchTables[i].ProductId) &&
						(desc->bDeviceClass == e->matchTables[i].bDeviceClass) &&
						(desc->bDeviceSubClass == e->matchTables[i].bDeviceSubClass) &&
						((devnum == -1) || (strtol(dev->filename, NULL, 10) == devnum)) ) {
					int ac;
					for (ac = 0; ac < desc->bNumConfigurations; ac++) {
						struct usb_interface *interface = dev->config[ac].interface;
						int ai;

						for (ai = 0; ai < interface->num_altsetting; ai++) {

							DPRINTF("intclass: %x, intsubclass: %x, intproto: %x\n",
									interface->altsetting[i].bInterfaceClass,
									interface->altsetting[i].bInterfaceSubClass,
									interface->altsetting[i].bInterfaceProtocol);

							if ((interface->altsetting[ai].bInterfaceSubClass == e->matchTables[i].bInterfaceSubClass) &&
									(interface->altsetting[ai].bInterfaceProtocol == e->matchTables[i].bInterfaceProtocol)){
								/* TODO: check interfaceClass! */
								DPRINTF("found device with libusb\n");

								xpcu.interface = -1;
								xpcu.alternate = -1;
								xpcu.dev = dev;
								xpcu.card_type = e->dwCardType;
								pthread_mutex_init(&xpcu.interrupt, NULL);
								e->handle = (unsigned long)&xpcu;
							}
						}
					}
				}
			}
		}
	}

	if (!xpcu.dev) {
		e->handle = 0;
		return NULL;
	}

	return &xpcu;
}

int xpcu_found(struct xpcu_s *xpcu, struct event *e) {
	if (e->handle && e->handle == (unsigned long)xpcu && xpcu->dev) {
		struct usb_interface *interface = xpcu->dev->config->interface;

		e->dwCardType = xpcu->card_type;
		e->dwAction = 1;
		e->dwEventId = 1;
		e->u.Usb.dwUniqueID = e->handle;
		e->matchTables[0].VendorId = xpcu->dev->descriptor.idVendor;
		e->matchTables[0].ProductId = xpcu->dev->descriptor.idProduct;
		e->matchTables[0].bDeviceClass = xpcu->dev->descriptor.bDeviceClass;
		e->matchTables[0].bDeviceSubClass = xpcu->dev->descriptor.bDeviceSubClass;
		e->matchTables[0].bInterfaceClass = interface->altsetting[0].bInterfaceClass;
		e->matchTables[0].bInterfaceSubClass = interface->altsetting[0].bInterfaceSubClass;
		e->matchTables[0].bInterfaceProtocol = interface->altsetting[0].bInterfaceProtocol;
	}

	return 0;
}

int xpcu_close(struct xpcu_s *xpcu, struct event *e) {
	if (e->handle != (unsigned long)xpcu)
		return -ENODEV;
	
	if (!xpcu)
		return -ENODEV;

	if(xpcu) {
		if (xpcu->handle) {
			xpcu_claim(xpcu, XPCU_RELEASE);
			usb_close(xpcu->handle);
		}

		xpcu->handle = NULL;
		xpcu->interface = -1;
		xpcu->alternate = -1;
		busses = NULL;
	}

	return 0;
}

int xpcu_int_state(struct xpcu_s *xpcu, struct interrupt *it, int enable) {
	static pthread_mutex_t *interrupt = &dummy_interrupt;

	if (it->hInterrupt != (unsigned long)xpcu)
		return -ENODEV;
	
	if (xpcu)
		interrupt = &xpcu->interrupt;
	
	if (enable == ENABLE_INTERRUPT) {
		it->fEnableOk = 1;
		it->fStopped = 0;
		pthread_mutex_trylock(interrupt);
	} else {
		it->dwCounter = 0;
		it->fStopped = 1;
		if (pthread_mutex_trylock(interrupt) == EBUSY)
			pthread_mutex_unlock(interrupt);
	}

	return 0;
}

int xpcu_int_wait(struct xpcu_s *xpcu, struct interrupt *it) {
	if (it->hInterrupt != (unsigned long)xpcu)
		return -ENODEV;
	
	if (xpcu) {
		if (it->dwCounter == 0) {
			it->dwCounter = 1;
		} else {
			pthread_mutex_lock(&xpcu->interrupt);
			pthread_mutex_unlock(&xpcu->interrupt);
		}
	} else {
		pthread_mutex_lock(&dummy_interrupt);
		pthread_mutex_unlock(&dummy_interrupt);
	}

	return 0;
}
Commit	Line	Data
cbfa0ac6 MG	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <unistd.h>
f92c0fbc	4	#include <string.h>
cbfa0ac6 MG	5	#include <strings.h>
cbfa0ac6 MG	6	#include <usb.h>
f92c0fbc	7	#include <errno.h>
501f1c21	8	#include <pthread.h>
cbfa0ac6	9	#include "usb-driver.h"
6c235d59	10	#include "xpcu.h"
cbfa0ac6	11
f92c0fbc	12	static struct usb_bus *busses = NULL;
501f1c21	13	static pthread_mutex_t dummy_interrupt = PTHREAD_MUTEX_INITIALIZER;
f92c0fbc MG	14
f92c0fbc MG	15	int xpcu_deviceinfo(struct xpcu_s xpcu, struct usb_get_device_data ugdd) {
cbfa0ac6 MG	16	int i,j,k,l;
cbfa0ac6 MG	17	int len = 0;
f92c0fbc	18	unsigned char *buf = NULL;
cbfa0ac6 MG	19	WDU_CONFIGURATION pConfigs, pActiveConfig;
	20	WDU_INTERFACE **pActiveInterface;
	21
f92c0fbc MG	22	if (ugdd->dwUniqueID != (unsigned long)xpcu)
f92c0fbc MG	23	return -ENODEV;
8af4d910 MG	24
	25	if (!xpcu)
	26	return -ENODEV;
f92c0fbc MG	27
	28	if (ugdd->dwBytes)
	29	buf = ugdd->pBuf;
	30
cbfa0ac6 MG	31	if (buf) {
	32	struct usb_device_info udi = (struct usb_device_info)(buf+len);
	33
	34	udi->Descriptor.bLength = sizeof(WDU_DEVICE_DESCRIPTOR);
	35	udi->Descriptor.bDescriptorType = xpcu->dev->descriptor.bDescriptorType;
	36	udi->Descriptor.bcdUSB = xpcu->dev->descriptor.bcdUSB;
	37	udi->Descriptor.bDeviceClass = xpcu->dev->descriptor.bDeviceClass;
	38	udi->Descriptor.bDeviceSubClass = xpcu->dev->descriptor.bDeviceSubClass;
	39	udi->Descriptor.bDeviceProtocol = xpcu->dev->descriptor.bDeviceProtocol;
	40	udi->Descriptor.bMaxPacketSize0 = xpcu->dev->descriptor.bMaxPacketSize0;
	41	udi->Descriptor.idVendor = xpcu->dev->descriptor.idVendor;
	42	udi->Descriptor.idProduct = xpcu->dev->descriptor.idProduct;
	43	udi->Descriptor.bcdDevice = xpcu->dev->descriptor.bcdDevice;
	44	udi->Descriptor.iManufacturer = xpcu->dev->descriptor.iManufacturer;
	45	udi->Descriptor.iProduct = xpcu->dev->descriptor.iProduct;
	46	udi->Descriptor.iSerialNumber = xpcu->dev->descriptor.iSerialNumber;
	47	udi->Descriptor.bNumConfigurations = xpcu->dev->descriptor.bNumConfigurations;
	48
	49	/* TODO: Fix Pipe0! */
	50	udi->Pipe0.dwNumber = 0x00;
	51	udi->Pipe0.dwMaximumPacketSize = xpcu->dev->descriptor.bMaxPacketSize0;
	52	udi->Pipe0.type = 0;
	53	udi->Pipe0.direction = WDU_DIR_IN_OUT;
	54	udi->Pipe0.dwInterval = 0;
	55
	56	pConfigs = &(udi->pConfigs);
	57	pActiveConfig = &(udi->pActiveConfig);
	58	pActiveInterface = &(udi->pActiveInterface[0]);
	59	}
	60
	61	len = sizeof(struct usb_device_info);
	62
	63	for (i=0; i<xpcu->dev->descriptor.bNumConfigurations; i++)
	64	{
	65	struct usb_config_descriptor *conf_desc = &xpcu->dev->config[i];
	66	WDU_INTERFACE **pInterfaces;
	67	WDU_ALTERNATE_SETTING **pAlternateSettings[conf_desc->bNumInterfaces];
	68	WDU_ALTERNATE_SETTING **pActiveAltSetting[conf_desc->bNumInterfaces];
	69
	70	if (buf) {
	71	WDU_CONFIGURATION cfg = (WDU_CONFIGURATION)(buf+len);
	72
	73	*pConfigs = cfg;
	74	*pActiveConfig = cfg;
	75
	76	cfg->Descriptor.bLength = conf_desc->bLength;
	77	cfg->Descriptor.bDescriptorType = conf_desc->bDescriptorType;
	78	cfg->Descriptor.wTotalLength = conf_desc->wTotalLength;
	79	cfg->Descriptor.bNumInterfaces = conf_desc->bNumInterfaces;
	80	cfg->Descriptor.bConfigurationValue = conf_desc->bConfigurationValue;
	81	cfg->Descriptor.iConfiguration = conf_desc->iConfiguration;
	82	cfg->Descriptor.bmAttributes = conf_desc->bmAttributes;
	83	cfg->Descriptor.MaxPower = conf_desc->MaxPower;
	84
	85	cfg->dwNumInterfaces = conf_desc->bNumInterfaces;
	86
	87	pInterfaces = &(cfg->pInterfaces);
	88	}
	89	len += sizeof(WDU_CONFIGURATION);
	90
	91	if (buf) {
	92	pInterfaces = (WDU_INTERFACE)(buf+len);
	93	for (j=0; j<conf_desc->bNumInterfaces; j++) {
	94	WDU_INTERFACE iface = (WDU_INTERFACE)(buf+len);
95
96	pActiveInterface[j] = iface;
97
98	pAlternateSettings[j] = &(iface->pAlternateSettings);
99	iface->dwNumAltSettings = xpcu->dev->config[i].interface[j].num_altsetting;
100	pActiveAltSetting[j] = &(iface->pActiveAltSetting);
101
102	len += sizeof(WDU_INTERFACE);
103	}
104	} else {
105	len += sizeof(WDU_INTERFACE) * conf_desc->bNumInterfaces;
106	}
107
108	for (j=0; j<conf_desc->bNumInterfaces; j++)
109	{
110	struct usb_interface *interface = &xpcu->dev->config[i].interface[j];
111
112	if (buf) {
113	pAlternateSettings[j] = (WDU_ALTERNATE_SETTING)(buf+len);
114	/* FIXME: */
115	pActiveAltSetting[j] = (WDU_ALTERNATE_SETTING)(buf+len);
116	}
117
118	for(k=0; k<interface->num_altsetting; k++)
119	{
120	unsigned char bNumEndpoints = interface->altsetting[k].bNumEndpoints;
121	WDU_ENDPOINT_DESCRIPTOR **pEndpointDescriptors;
122	WDU_PIPE_INFO **pPipes;
123
124	if (buf) {
125	WDU_ALTERNATE_SETTING altset = (WDU_ALTERNATE_SETTING)(buf+len);
126
127	altset->Descriptor.bLength = interface->altsetting[k].bLength;
128	altset->Descriptor.bDescriptorType = interface->altsetting[k].bDescriptorType;
129	altset->Descriptor.bInterfaceNumber = interface->altsetting[k].bInterfaceNumber;
130	altset->Descriptor.bAlternateSetting = interface->altsetting[k].bAlternateSetting;
131	altset->Descriptor.bNumEndpoints = interface->altsetting[k].bNumEndpoints;
132	altset->Descriptor.bInterfaceClass = interface->altsetting[k].bInterfaceClass;
133	altset->Descriptor.bInterfaceSubClass = interface->altsetting[k].bInterfaceSubClass;
134	altset->Descriptor.bInterfaceProtocol = interface->altsetting[k].bInterfaceProtocol;
135	altset->Descriptor.iInterface = interface->altsetting[k].iInterface;
136	pEndpointDescriptors = &(altset->pEndpointDescriptors);
137	pPipes = &(altset->pPipes);
138
139	}
140	len +=sizeof(WDU_ALTERNATE_SETTING);
141
142	if (buf) {
143	pEndpointDescriptors = (WDU_ENDPOINT_DESCRIPTOR)(buf+len);
144	for (l = 0; l < bNumEndpoints; l++) {
145	WDU_ENDPOINT_DESCRIPTOR ed = (WDU_ENDPOINT_DESCRIPTOR)(buf+len);
146
147	ed->bLength = interface->altsetting[k].endpoint[l].bLength;
148	ed->bDescriptorType = interface->altsetting[k].endpoint[l].bDescriptorType;
149	ed->bEndpointAddress = interface->altsetting[k].endpoint[l].bEndpointAddress;
150	ed->bmAttributes = interface->altsetting[k].endpoint[l].bmAttributes;
151	ed->wMaxPacketSize = interface->altsetting[k].endpoint[l].wMaxPacketSize;
152	ed->bInterval = interface->altsetting[k].endpoint[l].bInterval;
153
154	len += sizeof(WDU_ENDPOINT_DESCRIPTOR);
155	}
156
157	pPipes = (WDU_PIPE_INFO)(buf+len);
158	for (l = 0; l < bNumEndpoints; l++) {
159	WDU_PIPE_INFO pi = (WDU_PIPE_INFO)(buf+len);
160
161	pi->dwNumber = interface->altsetting[k].endpoint[l].bEndpointAddress;
162	pi->dwMaximumPacketSize = WDU_GET_MAX_PACKET_SIZE(interface->altsetting[k].endpoint[l].wMaxPacketSize);
163	pi->type = interface->altsetting[k].endpoint[l].bmAttributes & USB_ENDPOINT_TYPE_MASK;
164	if (pi->type == PIPE_TYPE_CONTROL)
165	pi->direction = WDU_DIR_IN_OUT;
166	else
167	{
168	pi->direction = interface->altsetting[k].endpoint[l].bEndpointAddress & USB_ENDPOINT_DIR_MASK ? WDU_DIR_IN : WDU_DIR_OUT;
169	}
170
171	pi->dwInterval = interface->altsetting[k].endpoint[l].bInterval;
172
173	len += sizeof(WDU_PIPE_INFO);
174	}
175	} else {
176	len +=(sizeof(WDU_ENDPOINT_DESCRIPTOR)+sizeof(WDU_PIPE_INFO))*bNumEndpoints;
177	}
178	}
179	}
180	}
181
8af4d910 MG	182	ugdd->dwBytes = len;
	183
	184	return 0;
cbfa0ac6 MG	185	}
cbfa0ac6 MG	186
6234190b	187	static int xpcu_claim(struct xpcu_s *xpcu, int claim) {
cbfa0ac6 MG	188	int ret = 0;
	189	static int claimed = 0;
	190
	191	if (xpcu->interface < 0)
	192	return -1;
	193
	194	if (claim == XPCU_CLAIM) {
	195	if (claimed)
	196	return 0;
	197
	198	ret = usb_claim_interface(xpcu->handle, xpcu->interface);
	199	if (!ret) {
	200	claimed = 1;
	201	ret = usb_set_altinterface(xpcu->handle, xpcu->alternate);
	202	if (ret)
	203	fprintf(stderr, "usb_set_altinterface: %d\n", ret);
	204	} else {
	205	fprintf(stderr, "usb_claim_interface: %d -> %d (%s)\n",
	206	xpcu->interface, ret, usb_strerror());
	207	}
	208	} else {
	209	if (!claimed)
	210	return 0;
	211
	212	ret = usb_release_interface(xpcu->handle, xpcu->interface);
	213	if (!ret)
	214	claimed = 0;
	215	}
	216
	217	return ret;
	218	}
	219
6c235d59 MG	220	int xpcu_transfer(struct xpcu_s xpcu, struct usb_transfer ut) {
	221	int ret = 0;
	222
f92c0fbc MG	223	if (ut->dwUniqueID != (unsigned long)xpcu)
f92c0fbc MG	224	return -ENODEV;
8af4d910 MG	225
	226	if (!xpcu)
	227	return -ENODEV;
f92c0fbc	228
6c235d59 MG	229	xpcu_claim(xpcu, XPCU_CLAIM);
	230	/* http://www.jungo.com/support/documentation/windriver/802/wdusb_man_mhtml/node55.html#SECTION001213000000000000000 */
	231	if (ut->dwPipeNum == 0) { /* control pipe */
	232	int requesttype, request, value, index, size;
	233	requesttype = ut->SetupPacket[0];
	234	request = ut->SetupPacket[1];
	235	value = ut->SetupPacket[2] \| (ut->SetupPacket[3] << 8);
	236	index = ut->SetupPacket[4] \| (ut->SetupPacket[5] << 8);
	237	size = ut->SetupPacket[6] \| (ut->SetupPacket[7] << 8);
501f1c21	238	DPRINTF("-> requesttype: %x, request: %x, value: %u, index: %u, size: %u\n", requesttype, request, value, index, size);
6c235d59 MG	239	ret = usb_control_msg(xpcu->handle, requesttype, request, value, index, ut->pBuffer, size, ut->dwTimeout);
	240	} else {
	241	if (ut->fRead) {
	242	ret = usb_bulk_read(xpcu->handle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
	243	} else {
	244	ret = usb_bulk_write(xpcu->handle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
	245	}
	246	xpcu_claim(xpcu, XPCU_RELEASE);
	247	}
	248
	249	if (ret < 0) {
	250	fprintf(stderr, "usb_transfer: %d (%s)\n", ret, usb_strerror());
	251	} else {
	252	ut->dwBytesTransferred = ret;
	253	ret = 0;
	254	}
	255
	256	return ret;
	257	}
	258
8af4d910	259	int xpcu_set_interface(struct xpcu_s xpcu, struct usb_set_interface usi) {
f92c0fbc	260	if (usi->dwUniqueID != (unsigned long)xpcu)
8af4d910 MG	261	return -ENODEV;
	262
	263	if (!xpcu)
	264	return -ENODEV;
f92c0fbc	265
0c2db148 MG	266	if (xpcu->dev) {
	267	if (!xpcu->handle) {
	268	xpcu->handle = usb_open(xpcu->dev);
	269	#ifndef NO_USB_RESET
	270	if (xpcu->handle) {
	271	usb_reset(xpcu->handle);
	272	xpcu->handle = usb_open(xpcu->dev);
	273	}
	274	#endif
	275	}
	276
	277	xpcu->interface = xpcu->dev->config[0].interface[usi->dwInterfaceNum].altsetting[usi->dwAlternateSetting].bInterfaceNumber;
	278	xpcu->alternate = usi->dwAlternateSetting;
	279	}
8af4d910 MG	280
8af4d910 MG	281	return 0;
0c2db148 MG	282	}
0c2db148 MG	283
f92c0fbc MG	284	static void xpcu_init(void) {
	285	if (busses)
	286	return;
	287
	288	usb_init();
	289	usb_find_busses();
	290	usb_find_devices();
	291
	292	busses = usb_get_busses();
	293	}
	294
	295
	296	struct xpcu_s xpcu_find(struct event e) {
cbfa0ac6	297	static struct xpcu_s xpcu;
f92c0fbc MG	298	char* devpos;
	299	struct usb_bus *bus;
	300	int busnum = -1, devnum = -1;
	301	int i;
cbfa0ac6 MG	302
cbfa0ac6 MG	303	bzero(&xpcu, sizeof(xpcu));
f92c0fbc MG	304	xpcu_init();
	305
	306	devpos = getenv("XILINX_USB_DEV");
	307	if (devpos != NULL) {
	308	int j;
	309	char devstr = NULL, remainder;
	310
	311	DPRINTF("XILINX_USB_DEV=%s\n", devpos);
	312
	313	for (j = 0; j < strlen(devpos) && devpos[j] != 0; j++) {
	314	if (devpos[j] == ':') {
	315	devpos[j] = 0;
	316	devstr = &(devpos[j+1]);
	317	}
	318	}
	319
	320	if (devstr && strlen(devstr) > 0) {
	321	busnum = strtol(devpos, &remainder, 10);
	322	if (devpos == remainder) {
	323	busnum = -1;
	324	} else {
	325	devnum = strtol(devstr, &remainder, 10);
	326	if (devstr == remainder) {
	327	busnum = -1;
	328	devnum = -1;
	329	} else {
	330	fprintf(stderr,"Using XILINX platform cable USB at %03d:%03d\n",
	331	busnum, devnum);
	332	}
	333	}
	334	}
	335	}
	336
	337	for (i = 0; i < e->dwNumMatchTables; i++) {
	338
	339	DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
	340	e->matchTables[i].VendorId,
	341	e->matchTables[i].ProductId,
	342	e->matchTables[i].bDeviceClass,
	343	e->matchTables[i].bDeviceSubClass,
	344	e->matchTables[i].bInterfaceClass,
	345	e->matchTables[i].bInterfaceSubClass,
	346	e->matchTables[i].bInterfaceProtocol);
	347
	348	for (bus = busses; bus; bus = bus->next) {
	349	struct usb_device *dev;
	350
	351	if ((devnum != -1) && (strtol(bus->dirname, NULL, 10) != busnum))
	352	continue;
	353
	354	for (dev = bus->devices; dev; dev = dev->next) {
	355	struct usb_device_descriptor *desc = &(dev->descriptor);
	356
	357	if((desc->idVendor == e->matchTables[i].VendorId) &&
	358	(desc->idProduct == e->matchTables[i].ProductId) &&
	359	(desc->bDeviceClass == e->matchTables[i].bDeviceClass) &&
	360	(desc->bDeviceSubClass == e->matchTables[i].bDeviceSubClass) &&
	361	((devnum == -1) \|\| (strtol(dev->filename, NULL, 10) == devnum)) ) {
	362	int ac;
	363	for (ac = 0; ac < desc->bNumConfigurations; ac++) {
	364	struct usb_interface *interface = dev->config[ac].interface;
	365	int ai;
	366
	367	for (ai = 0; ai < interface->num_altsetting; ai++) {
368
369	DPRINTF("intclass: %x, intsubclass: %x, intproto: %x\n",
370	interface->altsetting[i].bInterfaceClass,
371	interface->altsetting[i].bInterfaceSubClass,
372	interface->altsetting[i].bInterfaceProtocol);
373
374	if ((interface->altsetting[ai].bInterfaceSubClass == e->matchTables[i].bInterfaceSubClass) &&
375	(interface->altsetting[ai].bInterfaceProtocol == e->matchTables[i].bInterfaceProtocol)){
376	/* TODO: check interfaceClass! */
377	DPRINTF("found device with libusb\n");
501f1c21 MG	378
	379	xpcu.interface = -1;
	380	xpcu.alternate = -1;
f92c0fbc MG	381	xpcu.dev = dev;
f92c0fbc MG	382	xpcu.card_type = e->dwCardType;
501f1c21 MG	383	pthread_mutex_init(&xpcu.interrupt, NULL);
501f1c21 MG	384	e->handle = (unsigned long)&xpcu;
f92c0fbc MG	385	}
	386	}
	387	}
	388	}
	389	}
	390	}
	391	}
cbfa0ac6	392
501f1c21 MG	393	if (!xpcu.dev) {
501f1c21 MG	394	e->handle = 0;
f92c0fbc	395	return NULL;
501f1c21	396	}
cbfa0ac6 MG	397
	398	return &xpcu;
	399	}
6234190b	400
8af4d910	401	int xpcu_found(struct xpcu_s xpcu, struct event e) {
f92c0fbc MG	402	if (e->handle && e->handle == (unsigned long)xpcu && xpcu->dev) {
	403	struct usb_interface *interface = xpcu->dev->config->interface;
	404
	405	e->dwCardType = xpcu->card_type;
	406	e->dwAction = 1;
	407	e->dwEventId = 1;
	408	e->u.Usb.dwUniqueID = e->handle;
	409	e->matchTables[0].VendorId = xpcu->dev->descriptor.idVendor;
	410	e->matchTables[0].ProductId = xpcu->dev->descriptor.idProduct;
	411	e->matchTables[0].bDeviceClass = xpcu->dev->descriptor.bDeviceClass;
	412	e->matchTables[0].bDeviceSubClass = xpcu->dev->descriptor.bDeviceSubClass;
	413	e->matchTables[0].bInterfaceClass = interface->altsetting[0].bInterfaceClass;
	414	e->matchTables[0].bInterfaceSubClass = interface->altsetting[0].bInterfaceSubClass;
	415	e->matchTables[0].bInterfaceProtocol = interface->altsetting[0].bInterfaceProtocol;
6234190b	416	}
8af4d910 MG	417
8af4d910 MG	418	return 0;
f92c0fbc MG	419	}
f92c0fbc MG	420
8af4d910	421	int xpcu_close(struct xpcu_s xpcu, struct event e) {
f92c0fbc	422	if (e->handle != (unsigned long)xpcu)
8af4d910 MG	423	return -ENODEV;
	424
	425	if (!xpcu)
	426	return -ENODEV;
6234190b	427
f92c0fbc MG	428	if(xpcu) {
	429	if (xpcu->handle) {
	430	xpcu_claim(xpcu, XPCU_RELEASE);
	431	usb_close(xpcu->handle);
	432	}
	433
	434	xpcu->handle = NULL;
	435	xpcu->interface = -1;
	436	xpcu->alternate = -1;
	437	busses = NULL;
	438	}
8af4d910 MG	439
8af4d910 MG	440	return 0;
6234190b	441	}
501f1c21	442
8af4d910	443	int xpcu_int_state(struct xpcu_s xpcu, struct interrupt it, int enable) {
501f1c21 MG	444	static pthread_mutex_t *interrupt = &dummy_interrupt;
	445
	446	if (it->hInterrupt != (unsigned long)xpcu)
8af4d910	447	return -ENODEV;
501f1c21 MG	448
	449	if (xpcu)
	450	interrupt = &xpcu->interrupt;
	451
	452	if (enable == ENABLE_INTERRUPT) {
	453	it->fEnableOk = 1;
	454	it->fStopped = 0;
	455	pthread_mutex_trylock(interrupt);
	456	} else {
	457	it->dwCounter = 0;
	458	it->fStopped = 1;
	459	if (pthread_mutex_trylock(interrupt) == EBUSY)
	460	pthread_mutex_unlock(interrupt);
	461	}
8af4d910 MG	462
8af4d910 MG	463	return 0;
501f1c21 MG	464	}
501f1c21 MG	465
8af4d910	466	int xpcu_int_wait(struct xpcu_s xpcu, struct interrupt it) {
501f1c21	467	if (it->hInterrupt != (unsigned long)xpcu)
8af4d910	468	return -ENODEV;
501f1c21 MG	469
	470	if (xpcu) {
	471	if (it->dwCounter == 0) {
	472	it->dwCounter = 1;
	473	} else {
	474	pthread_mutex_lock(&xpcu->interrupt);
	475	pthread_mutex_unlock(&xpcu->interrupt);
	476	}
	477	} else {
	478	pthread_mutex_lock(&dummy_interrupt);
	479	pthread_mutex_unlock(&dummy_interrupt);
	480	}
8af4d910 MG	481
8af4d910 MG	482	return 0;
501f1c21	483	}