xpcu.c

Xilinx USB下载线 Linux驱动

		ut->dwBytesTransferred = ret;
		ret = 0;
	}

	return ret;
}

int xpcu_set_interface(struct usb_set_interface *usi) {
	struct xpcu_s *xpcu = (struct xpcu_s*)usi->dwUniqueID;

	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();
}


int xpcu_find(struct event *e) {
	struct xpcu_event_s *xpcu_event = NULL;
	struct xpcu_s *xpcu = NULL;
	char* usbdev;
	struct usb_bus *bus;
	int busnum = -1, devnum = -1;
	int i;

	e->handle = (unsigned long)NULL;

	xpcu_init();

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

		devpos = strdup(usbdev);
		if (!devpos)
			return -ENOMEM;

		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);
				}
			}
		}
		free(devpos);
	}

	xpcu_event = malloc(sizeof(struct xpcu_event_s));
	if (!xpcu_event)
		return -ENOMEM;

	bzero(xpcu_event, sizeof(struct xpcu_event_s));
	xpcu_event->xpcu = NULL;
	xpcu_event->count = 0;
	xpcu_event->interrupt_count = 0;
	pthread_mutex_init(&xpcu_event->interrupt, NULL);

	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)){
								int n = xpcu_event->count;

								/* TODO: check interfaceClass! */
								DPRINTF("found device with libusb\n");

								xpcu = realloc(xpcu, sizeof(struct xpcu_s) * (++xpcu_event->count));
								if (!xpcu) {
									free(xpcu_event);
									return -ENOMEM;
								}

								bzero(&(xpcu[n]), sizeof(struct xpcu_s));
								xpcu[n].interface = -1;
								xpcu[n].alternate = -1;
								xpcu[n].dev = dev;
								xpcu[n].card_type = e->dwCardType;

								xpcu_event->xpcu = xpcu;
							}
						}
					}
				}
			}
		}
	}

	e->handle = (unsigned long)xpcu_event;

	return 0;
}

int xpcu_found(struct event *e) {
	struct xpcu_event_s *xpcu_event = (struct xpcu_event_s*)e->handle;
	struct xpcu_s *xpcu = NULL;

	if (xpcu_event && xpcu_event->count && (xpcu_event->interrupt_count <= xpcu_event->count))
		xpcu = &(xpcu_event->xpcu[xpcu_event->interrupt_count-1]);

	if (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 = (unsigned long)xpcu;
		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 event *e) {
	struct xpcu_event_s *xpcu_event = (struct xpcu_event_s*)e->handle;

	if (!xpcu_event)
		return -ENODEV;

	if(xpcu_event) {
		struct  xpcu_s *xpcu;
		int i;

		for (i = 0; i < xpcu_event->count; i++) {
			xpcu = &(xpcu_event->xpcu[i]);
			if (xpcu->handle) {
				xpcu_claim(xpcu, XPCU_RELEASE);
				usb_close(xpcu->handle);
			}
		}

		if (xpcu_event->xpcu)
			free(xpcu_event->xpcu);

		busses = NULL;
		free(xpcu_event);
	}

	return 0;
}

int xpcu_int_state(struct interrupt *it, int enable) {
	struct xpcu_event_s *xpcu_event = (struct xpcu_event_s*)it->hInterrupt;

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

	return 0;
}

int xpcu_int_wait(struct interrupt *it) {
	struct xpcu_event_s *xpcu_event = (struct xpcu_event_s*)it->hInterrupt;

	if (!xpcu_event)
		return -ENODEV;

	if (it->dwCounter < xpcu_event->count) {
		it->dwCounter++;
	} else {
		pthread_mutex_lock(&xpcu_event->interrupt);
		pthread_mutex_unlock(&xpcu_event->interrupt);
	}
	xpcu_event->interrupt_count++;

	return 0;
}