/**
* usb_release_dev - free a usb device structure when all users of it are finished.
* @dev: device that's been disconnected
*
* Will be called only by the device core when all users of this usb device are
* done.
*/
static void usb_release_dev(struct device *dev)
{
struct usb_device *udev;
udev = to_usb_device(dev);
usb_destroy_configuration(udev);
usb_put_hcd(bus_to_hcd(udev->bus));
kfree(udev->product);
kfree(udev->manufacturer);
kfree(udev->serial);
kfree(udev);
}
void
usb_fetch_and_parse_descriptors(usb_dev_handle * udev)
{
struct usb_device *dev;
struct libusb20_device *pdev;
uint8_t *ptr;
int error;
uint32_t size;
uint16_t len;
uint8_t x;
if (udev == NULL) {
/* be NULL safe */
return;
}
dev = usb_device(udev);
pdev = (void *)udev;
if (dev->descriptor.bNumConfigurations == 0) {
/* invalid device */
return;
}
size = dev->descriptor.bNumConfigurations *
sizeof(struct usb_config_descriptor);
dev->config = malloc(size);
if (dev->config == NULL) {
/* out of memory */
return;
}
memset(dev->config, 0, size);
for (x = 0; x != dev->descriptor.bNumConfigurations; x++) {
error = (pdev->methods->get_config_desc_full) (
pdev, &ptr, &len, x);
if (error) {
usb_destroy_configuration(dev);
return;
}
usb_parse_configuration(dev->config + x, ptr);
/* free config buffer */
free(ptr);
}
return;
}
/**
* usb_release_dev - free a usb device structure when all users of it are finished.
* @dev: device that's been disconnected
*
* Will be called only by the device core when all users of this usb device are
* done.
*/
static void usb_release_dev(struct device *dev)
{
struct usb_device *udev;
struct usb_hcd *hcd;
udev = to_usb_device(dev);
hcd = bus_to_hcd(udev->bus);
usb_destroy_configuration(udev);
usb_release_bos_descriptor(udev);
usb_put_hcd(hcd);
kfree(udev->product);
kfree(udev->manufacturer);
kfree(udev->serial);
kfree(udev);
}
static void usb_release_dev(struct device *dev)
{
struct usb_device *udev;
struct usb_hcd *hcd;
udev = to_usb_device(dev);
hcd = bus_to_hcd(udev->bus);
usb_destroy_configuration(udev);
if (hcd->driver->free_dev && udev->parent)
hcd->driver->free_dev(hcd, udev);
usb_put_hcd(hcd);
kfree(udev->product);
kfree(udev->manufacturer);
kfree(udev->serial);
kfree(udev);
}
/**
* usb_release_dev - free a usb device structure when all users of it are finished.
* @dev: device that's been disconnected
*
* Will be called only by the device core when all users of this usb device are
* done.
*/
static void usb_release_dev(struct device *dev)
{
struct usb_device *udev;
struct usb_hcd *hcd;
udev = to_usb_device(dev);
hcd = bus_to_hcd(udev->bus);
usb_destroy_configuration(udev);
/* Root hubs aren't real devices, so don't free HCD resources */
if (hcd->driver->free_dev && udev->parent)
hcd->driver->free_dev(hcd, udev);
usb_put_hcd(hcd);
kfree(udev->product);
kfree(udev->manufacturer);
kfree(udev->serial);
kfree(udev);
}
void session_teardown() {
// Unhook global variable
debug_msg("unhooking virtual bus ...");
usb_busses = __orig_bus;
// Free global packet
debug_msg("deallocating shared packet ...");
if(pkt_shared() != NULL)
pkt_free(pkt_shared());
// Free busses
debug_msg("freeing busses ...");
struct usb_bus* cur = NULL;
while(__remote_bus != NULL) {
// Shift bus ptr
cur = __remote_bus;
__remote_bus = cur->next;
// Free bus devices
struct usb_device* dev = NULL;
while(cur->devices != NULL) {
dev = cur->devices;
cur->devices = dev->next;
// Destroy configuration and free device
usb_destroy_configuration(dev);
if(dev->children != NULL)
free(dev->children);
free(dev);
}
// Free bus
free(cur);
}
}
/*
* WARNING - If a driver calls usb_reset_device, you should simulate a
* disconnect() and probe() for other interfaces you doesn't claim. This
* is left up to the driver writer right now. This insures other drivers
* have a chance to re-setup their interface.
*
* Take a look at proc_resetdevice in devio.c for some sample code to
* do this.
*/
int usb_reset_device(struct usb_device *dev)
{
struct usb_device *parent = dev->parent;
struct usb_device_descriptor descriptor;
int i, ret, port = -1;
DBG_HOST_HUB("### >>> Enter hub.c file --> usb_reset_device function \n");
if (!parent) {
err("attempting to reset root hub!");
return -EINVAL;
}
for (i = 0; i < parent->maxchild; i++)
if (parent->children[i] == dev) {
port = i;
break;
}
if (port < 0)
return -ENOENT;
down(&usb_address0_sem);
/* Send a reset to the device */
if (usb_hub_port_reset(parent, port, dev, HUB_SHORT_RESET_TIME)) {
usb_hub_port_disable(parent, port);
up(&usb_address0_sem);
return(-ENODEV);
}
/* Reprogram the Address */
ret = usb_set_address(dev);
if (ret < 0) {
err("USB device not accepting new address (error=%d)", ret);
usb_hub_port_disable(parent, port);
up(&usb_address0_sem);
return ret;
}
/* Let the SET_ADDRESS settle */
wait_ms(10);
up(&usb_address0_sem);
/*
* Now we fetch the configuration descriptors for the device and
* see if anything has changed. If it has, we dump the current
* parsed descriptors and reparse from scratch. Then we leave
* the device alone for the caller to finish setting up.
*
* If nothing changed, we reprogram the configuration and then
* the alternate settings.
*/
ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &descriptor,
sizeof(descriptor));
if (ret < 0)
return ret;
le16_to_cpus(&descriptor.bcdUSB);
le16_to_cpus(&descriptor.idVendor);
le16_to_cpus(&descriptor.idProduct);
le16_to_cpus(&descriptor.bcdDevice);
if (memcmp(&dev->descriptor, &descriptor, sizeof(descriptor))) {
usb_destroy_configuration(dev);
ret = usb_get_device_descriptor(dev);
if (ret < sizeof(dev->descriptor)) {
if (ret < 0)
err("unable to get device descriptor (error=%d)", ret);
else
err("USB device descriptor short read (expected %Zi, got %i)", sizeof(dev->descriptor), ret);
clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
dev->devnum = -1;
return -EIO;
}
ret = usb_get_configuration(dev);
if (ret < 0) {
err("unable to get configuration (error=%d)", ret);
usb_destroy_configuration(dev);
clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
dev->devnum = -1;
return 1;
}
dev->actconfig = dev->config;
usb_set_maxpacket(dev);
return 1;
}
ret = usb_set_configuration(dev, dev->actconfig->bConfigurationValue);
if (ret < 0) {
err("failed to set active configuration (error=%d)", ret);
return ret;
}
for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
struct usb_interface *intf = &dev->actconfig->interface[i];
struct usb_interface_descriptor *as = &intf->altsetting[intf->act_altsetting];
ret = usb_set_interface(dev, as->bInterfaceNumber, as->bAlternateSetting);
if (ret < 0) {
err("failed to set active alternate setting for interface %d (error=%d)", i, ret);
return ret;
}
}
return 0;
}
void usb_free_dev(struct usb_device *dev)
{
usb_destroy_configuration(dev);
free(dev->children);
free(dev);
}
void usb_free_dev( usb_device *dev)
{
usb_destroy_configuration(dev);
free(dev);
}
