static int usb_acpi_find_device(struct device *dev, acpi_handle *handle)
{
struct usb_device *udev;
struct device *parent;
acpi_handle *parent_handle;
if (!is_usb_device(dev))
return -ENODEV;
udev = to_usb_device(dev);
parent = dev->parent;
parent_handle = DEVICE_ACPI_HANDLE(parent);
if (!parent_handle)
return -ENODEV;
*handle = acpi_get_child(parent_handle, udev->portnum);
if (!*handle)
return -ENODEV;
/*
* PLD will tell us whether a port is removable to the user or
* not. If we don't get an answer from PLD (it's not present
* or it's malformed) then try to infer it from UPC. If a
* device isn't connectable then it's probably not removable.
*/
if (usb_acpi_check_pld(udev, *handle) != 0)
usb_acpi_check_upc(udev, *handle);
return 0;
}
static int add_power_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev))
rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
return rc;
}
/*
* Connect to JTAG adapter.
*/
target_t *target_open(const char *port_name, int baud_rate)
{
target_t *t;
t = calloc(1, sizeof(target_t));
if (! t) {
fprintf(stderr, _("Out of memory\n"));
exit(-1);
}
t->cpu_name = "Unknown";
/* Update pic2_tab[] array from the pic32prog.conf file. */
target_configure();
/* Find adapter. */
if (is_usb_device(port_name)) {
t->adapter = open_usb_adapter(port_name);
} else {
t->adapter = open_serial_adapter(port_name, baud_rate);
}
if (! t->adapter) {
fprintf(stderr, "\n");
fprintf(stderr, _("No target found.\n"));
exit(-1);
}
/* Check CPU identifier. */
t->cpuid = t->adapter->get_idcode(t->adapter);
if (t->cpuid == 0) {
/* Device not responding. */
fprintf(stderr, _("Unknown CPUID=%08x.\n"), t->cpuid);
t->adapter->close(t->adapter, 0);
exit(1);
}
unsigned i;
for (i=0; (t->cpuid ^ pic32_tab[i].devid) & 0x0fffffff; i++) {
if (pic32_tab[i].devid == 0) {
/* Device not detected. */
fprintf(stderr, _("Unknown CPUID=%08x.\n"), t->cpuid);
t->adapter->close(t->adapter, 0);
exit(1);
}
}
t->family = pic32_tab[i].family;
t->cpu_name = pic32_tab[i].name;
t->flash_addr = 0x1d000000;
t->flash_bytes = pic32_tab[i].flash_kbytes * 1024;
if (! t->flash_bytes) {
t->flash_addr = t->adapter->user_start;
t->flash_bytes = t->adapter->user_nbytes;
t->boot_bytes = t->adapter->boot_nbytes;
}
t->adapter->family_name = t->family->name;
return t;
}
static int add_power_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev))
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_autosuspend.attr,
power_group);
return rc;
}
static int __each_dev(struct device *dev, void *data)
{
struct each_dev_arg *arg = (struct each_dev_arg *)data;
/* There are struct usb_interface on the same bus, filter them out */
if (!is_usb_device(dev))
return 0;
return arg->fn(to_usb_device(dev), arg->data);
}
static int allusbip(void)
{
DIR *dir;
dir = opendir("/sys/bus/usb/devices/");
if (!dir)
g_error("opendir: %s", strerror(errno));
for (;;) {
struct dirent *dirent;
char *busid;
dirent = readdir(dir);
if (!dirent)
break;
busid = dirent->d_name;
if (!is_usb_device(busid))
continue;
{
char name[PATH_MAX];
int conf, ninf = 0;
int i;
int be_local = 0;
conf = read_bConfigurationValue(busid);
ninf = read_bNumInterfaces(busid);
getdevicename(busid, name, sizeof(name));
for (i = 0; i < ninf; i++) {
char driver[PATH_MAX];
getdriver(busid, conf, i, driver, sizeof(driver));
#if 0
if (strncmp(driver, "usbhid", 6) == 0 || strncmp(driver, "usb-storage", 11) == 0) {
be_local = 1;
break;
}
#endif
}
if (be_local == 0)
use_device_by_usbip(busid);
}
}
closedir(dir);
return 0;
}
static int add_power_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
if (udev->usb2_hw_lpm_capable == 1)
rc = sysfs_merge_group(&dev->kobj,
&usb2_hardware_lpm_attr_group);
}
return rc;
}
static int add_persist_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_persist.attr,
power_group_name);
}
return rc;
}
static int show_devices_script(void)
{
DIR *dir;
dir = opendir("/sys/bus/usb/devices/");
if (!dir)
g_error("opendir: %s", strerror(errno));
for (;;) {
struct dirent *dirent;
char *busid;
dirent = readdir(dir);
if (!dirent)
break;
busid = dirent->d_name;
if (is_usb_device(busid)) {
char name[100] = {'\0'};
char driver[100] = {'\0'};
int conf, ninf = 0;
int i;
int islocal = 0;
conf = read_bConfigurationValue(busid);
ninf = read_bNumInterfaces(busid);
getdevicename(busid, name, sizeof(name));
for (i = 0; i < ninf; i++) {
getdriver(busid, conf, i, driver, sizeof(driver));
if (strncmp(driver, "usbhid", 6) == 0 || strncmp(driver, "usb-storage", 11) == 0) {
islocal = 1;
break;
}
}
if (islocal == 0)
printf("%s|%s|%s\n", busid, driver, name);
}
}
closedir(dir);
return 0;
}
static int __find_interface(struct device *dev, void *data)
{
struct find_interface_arg *arg = data;
struct usb_interface *intf;
/* can't look at usb devices, only interfaces */
if (is_usb_device(dev))
return 0;
intf = to_usb_interface(dev);
if (intf->minor != -1 && intf->minor == arg->minor) {
arg->interface = intf;
return 1;
}
return 0;
}
static int add_persist_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
/* Hubs are automatically enabled for USB_PERSIST,
* no point in creating the attribute file.
*/
if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_persist.attr,
power_group);
}
return rc;
}
static int show_devices(void)
{
DIR *dir;
dir = opendir("/sys/bus/usb/devices/");
if (!dir)
g_error("opendir: %s", strerror(errno));
printf("List USB devices\n");
for (;;) {
struct dirent *dirent;
char *busid;
dirent = readdir(dir);
if (!dirent)
break;
busid = dirent->d_name;
if (is_usb_device(busid)) {
char name[100] = {'\0'};
char driver[100] = {'\0'};
int conf, ninf = 0;
int i;
conf = read_bConfigurationValue(busid);
ninf = read_bNumInterfaces(busid);
getdevicename(busid, name, sizeof(name));
printf(" - busid %s (%s)\n", busid, name);
for (i = 0; i < ninf; i++) {
getdriver(busid, conf, i, driver, sizeof(driver));
printf(" %s:%d.%d -> %s\n", busid, conf, i, driver);
}
printf("\n");
}
}
closedir(dir);
return 0;
}
static int add_power_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev)) {
struct usb_device *udev = to_usb_device(dev);
rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
if (udev->usb2_hw_lpm_capable == 1)
rc = sysfs_merge_group(&dev->kobj,
&usb2_hardware_lpm_attr_group);
if ((udev->speed == USB_SPEED_SUPER ||
udev->speed == USB_SPEED_SUPER_PLUS) &&
udev->lpm_capable == 1)
rc = sysfs_merge_group(&dev->kobj,
&usb3_hardware_lpm_attr_group);
}
return rc;
}
static int add_power_attributes(struct device *dev)
{
int rc = 0;
if (is_usb_device(dev)) {
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_autosuspend.attr,
power_group);
if (rc == 0)
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_level.attr,
power_group);
if (rc == 0)
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_connected_duration.attr,
power_group);
if (rc == 0)
rc = sysfs_add_file_to_group(&dev->kobj,
&dev_attr_active_duration.attr,
power_group);
}
return rc;
}
static struct acpi_device *usb_acpi_find_companion(struct device *dev)
{
int port1;
struct usb_device *udev;
acpi_handle *parent_handle;
/*
* In the ACPI DSDT table, only usb root hub and usb ports are
* acpi device nodes. The hierarchy like following.
* Device (EHC1)
* Device (HUBN)
* Device (PR01)
* Device (PR11)
* Device (PR12)
* Device (PR13)
* ...
* So all binding process is divided into two parts. binding
* root hub and usb ports.
*/
if (is_usb_device(dev)) {
udev = to_usb_device(dev);
port1 = udev->portnum;
if (udev->parent) {
struct usb_hub *hub;
hub = usb_hub_to_struct_hub(udev->parent);
/*
* According usb port's connect type to set usb device's
* removability.
*/
switch (hub->ports[port1 - 1]->connect_type) {
case USB_PORT_CONNECT_TYPE_HOT_PLUG:
udev->removable = USB_DEVICE_REMOVABLE;
break;
case USB_PORT_CONNECT_TYPE_HARD_WIRED:
udev->removable = USB_DEVICE_FIXED;
break;
default:
udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
break;
}
return NULL;
}
/* root hub's parent is the usb hcd. */
return acpi_find_child_device(ACPI_COMPANION(dev->parent),
port1, false);
} else if (is_usb_port(dev)) {
struct usb_port *port_dev = to_usb_port(dev);
struct acpi_device *adev = NULL;
/* Get the struct usb_device point of port's hub */
udev = to_usb_device(dev->parent->parent);
port1 = port_dev->portnum;
/*
* The root hub ports' parent is the root hub. The non-root-hub
* ports' parent is the parent hub port which the hub is
* connected to.
*/
if (!udev->parent) {
struct usb_hcd *hcd = bus_to_hcd(udev->bus);
int raw;
raw = usb_hcd_find_raw_port_number(hcd, port1);
adev = acpi_find_child_device(ACPI_COMPANION(&udev->dev),
raw, false);
if (!adev)
return NULL;
} else {
parent_handle =
usb_get_hub_port_acpi_handle(udev->parent,
udev->portnum);
if (!parent_handle)
return NULL;
acpi_bus_get_device(parent_handle, &adev);
adev = acpi_find_child_device(adev, port1, false);
if (!adev)
return NULL;
}
usb_acpi_check_port_connect_type(udev, adev->handle, port1);
return adev;
}
return NULL;
}
static int usb_acpi_find_device(struct device *dev, acpi_handle *handle)
{
struct usb_device *udev;
acpi_handle *parent_handle;
int port_num;
/*
* In the ACPI DSDT table, only usb root hub and usb ports are
* acpi device nodes. The hierarchy like following.
* Device (EHC1)
* Device (HUBN)
* Device (PR01)
* Device (PR11)
* Device (PR12)
* Device (PR13)
* ...
* So all binding process is divided into two parts. binding
* root hub and usb ports.
*/
if (is_usb_device(dev)) {
udev = to_usb_device(dev);
if (udev->parent) {
enum usb_port_connect_type type;
/*
* According usb port's connect type to set usb device's
* removability.
*/
type = usb_get_hub_port_connect_type(udev->parent,
udev->portnum);
switch (type) {
case USB_PORT_CONNECT_TYPE_HOT_PLUG:
udev->removable = USB_DEVICE_REMOVABLE;
break;
case USB_PORT_CONNECT_TYPE_HARD_WIRED:
udev->removable = USB_DEVICE_FIXED;
break;
default:
udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
break;
}
return -ENODEV;
}
/* root hub's parent is the usb hcd. */
parent_handle = DEVICE_ACPI_HANDLE(dev->parent);
*handle = acpi_get_child(parent_handle, udev->portnum);
if (!*handle)
return -ENODEV;
return 0;
} else if (is_usb_port(dev)) {
sscanf(dev_name(dev), "port%d", &port_num);
/* Get the struct usb_device point of port's hub */
udev = to_usb_device(dev->parent->parent);
/*
* The root hub ports' parent is the root hub. The non-root-hub
* ports' parent is the parent hub port which the hub is
* connected to.
*/
if (!udev->parent) {
*handle = acpi_get_child(DEVICE_ACPI_HANDLE(&udev->dev),
port_num);
if (!*handle)
return -ENODEV;
} else {
parent_handle =
usb_get_hub_port_acpi_handle(udev->parent,
udev->portnum);
if (!parent_handle)
return -ENODEV;
*handle = acpi_get_child(parent_handle, port_num);
if (!*handle)
return -ENODEV;
}
usb_acpi_check_port_connect_type(udev, *handle, port_num);
} else
return -ENODEV;
return 0;
}
static bool usb_acpi_bus_match(struct device *dev)
{
return is_usb_device(dev) || is_usb_port(dev);
}
