lsusb-t.c

   1 #include <sys/types.h>
   2 #include <sys/stat.h>
   3 #include <fcntl.h>
   4 #include <dirent.h>
   5 #include <string.h>
   6 #include <ctype.h>
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <unistd.h>
  10 #include <stddef.h>
  11
  12 #include "list.h"
  13
  14 #define MY_SYSFS_FILENAME_LEN 255
  15 #define MY_PATH_MAX 4096
  16
  17 struct usbinterface {
  18         struct list_head list;
  19         struct usbinterface *next;
  20         struct usbdevice *parent;
  21         unsigned int configuration;
  22         unsigned int ifnum;
  23
  24         unsigned int bAlternateSetting;
  25         unsigned int bInterfaceClass;
  26         unsigned int bInterfaceNumber;
  27         unsigned int bInterfaceProtocol;
  28         unsigned int bInterfaceSubClass;
  29         unsigned int bNumEndpoints;
  30
  31         char name[MY_SYSFS_FILENAME_LEN];
  32         char driver[MY_SYSFS_FILENAME_LEN];
  33 };
  34
  35 struct usbdevice {
  36         struct list_head list;  /* connect devices independant of the bus */
  37         struct usbdevice *next; /* next port on this hub */
  38         struct usbinterface *first_interface;   /* list of interfaces */
  39         struct usbdevice *first_child;  /* connect devices on this port */
  40         struct usbdevice *parent;       /* hub this device is connected to */
  41         unsigned int busnum;
  42         unsigned int parent_portnum;
  43         unsigned int portnum;
  44
  45         unsigned int bConfigurationValue;
  46         unsigned int bDeviceClass;
  47         unsigned int bDeviceProtocol;
  48         unsigned int bDeviceSubClass;
  49         unsigned int bMaxPacketSize0;
  50         char bMaxPower[64];
  51         unsigned int bNumConfigurations;
  52         unsigned int bNumInterfaces;
  53         unsigned int bcdDevice;
  54         unsigned int bmAttributes;
  55         unsigned int configuration;
  56         unsigned int devnum;
  57         unsigned int idProduct;
  58         unsigned int idVendor;
  59         unsigned int maxchild;
  60         char manufacturer[64];
  61         char product[64];
  62         char serial[64];
  63         char version[64];
  64         char speed[4 + 1];      /* '1.5','12','480' + '\n' */
  65
  66         char name[MY_SYSFS_FILENAME_LEN];
  67         char driver[MY_SYSFS_FILENAME_LEN];
  68 };
  69
  70 struct usbbusnode {
  71         struct usbbusnode *next;
  72         struct usbinterface *first_interface;   /* list of interfaces */
  73         struct usbdevice *first_child;  /* connect childs belonging to this bus */
  74         unsigned int busnum;
  75
  76         unsigned int bDeviceClass;
  77         unsigned int devnum;
  78         unsigned int maxchild;
  79         char speed[4 + 1];      /* '1.5','12','480' + '\n' */
  80
  81         char driver[MY_SYSFS_FILENAME_LEN];
  82 };
  83
  84 #define SYSFS_INTu(de,tgt, name) do { tgt->name = read_sysfs_file_int(de,#name,10); } while(0)
  85 #define SYSFS_INTx(de,tgt, name) do { tgt->name = read_sysfs_file_int(de,#name,16); } while(0)
  86 #define SYSFS_STR(de,tgt, name) do { read_sysfs_file_string(de, #name, tgt->name, MY_SYSFS_FILENAME_LEN); } while(0)
  87
  88 LIST_HEAD(interfacelist);
  89 LIST_HEAD(usbdevlist);
  90 static struct usbbusnode *usbbuslist;
  91
  92 static const char sys_bus_usb_devices[] = "/sys/bus/usb/devices";
  93 static int indent;
  94
  95 #if 0
  96 static void dump_usbbusnode(struct usbbusnode *b)
  97 {
  98         printf(" B %p:'%u': n %p fi %p fc %p driver '%s'\n", b, b->busnum, b->next, b->first_interface, b->first_child, b->driver);
  99 }
 100
 101 static void dump_usbdevice(struct usbdevice *d)
 102 {
 103         printf
 104             (" D %p:'%s': n %p fi %p fc %p bn %u ppn %u pn %u p %p bCV %u bDC %02x bDP %02x bDSC %02x bMPS %02x bMP '%s' bNC %u bNI %u bcdD %02x bmA %02x c %u dn %u idP %04x idV %04x mc %u m '%s' p '%s' s '%s' v '%s' sp '%s' driver '%s'\n",
 105              d, d->name, d->next, d->first_interface, d->first_child, d->busnum, d->parent_portnum, d->portnum, d->parent, d->bConfigurationValue, d->bDeviceClass,
 106              d->bDeviceProtocol, d->bDeviceSubClass, d->bMaxPacketSize0, d->bMaxPower, d->bNumConfigurations, d->bNumInterfaces, d->bcdDevice, d->bmAttributes,
 107              d->configuration, d->devnum, d->idProduct, d->idVendor, d->maxchild, d->manufacturer, d->product, d->serial, d->version, d->speed, d->driver);
 108 }
 109
 110 static void dump_usbinterface(struct usbinterface *i)
 111 {
 112         printf(" I %p:'%s': n %p c %u if %u bAS %u bIC %02x bIN %02x bIP %02x bISC %02x bNE %u d '%s'\n", i, i->name, i->next, i->configuration, i->ifnum,
 113                i->bAlternateSetting, i->bInterfaceClass, i->bInterfaceNumber, i->bInterfaceProtocol, i->bInterfaceSubClass, i->bNumEndpoints, i->driver);
 114 }
 115 #endif
 116
 117 static char tmp_str[128];
 118 static const char *bInterfaceClass_to_str(unsigned int dc)
 119 {
 120         const char *s;
 121         switch (dc) {
 122         case 0:
 123                 s = ">ifc";
 124                 break;
 125         case 1:
 126                 s = "audio";
 127                 break;
 128         case 2:
 129                 s = "comm.";
 130                 break;
 131         case 3:
 132                 s = "HID";
 133                 break;
 134         case 5:
 135                 s = "PID";
 136                 break;
 137         case 6:
 138                 s = "still";
 139                 break;
 140         case 7:
 141                 s = "print";
 142                 break;
 143         case 8:
 144                 s = "stor.";
 145                 break;
 146         case 9:
 147                 s = "hub";
 148                 break;
 149         case 10:
 150                 s = "data";
 151                 break;
 152         case 11:
 153                 s = "scard";
 154                 break;
 155         case 13:
 156                 s = "c-sec";
 157                 break;
 158         case 254:
 159                 s = "app.";
 160                 break;
 161         case 255:
 162                 s = "vend.";
 163                 break;
 164         default:
 165                 snprintf(tmp_str, 128, "'bInterfaceClass 0x%02x not yet handled'", dc);;
 166                 s = tmp_str;
 167         }
 168         return s;
 169 }
 170 static const char *bDeviceClass_to_str(unsigned int dc)
 171 {
 172         const char *s;
 173         switch (dc) {
 174         case 9:
 175                 s = "root_hub";
 176                 break;
 177         default:
 178                 snprintf(tmp_str, 128, "'bDeviceClass 0x%02x not yet handled'", dc);;
 179                 s = tmp_str;
 180         }
 181         return s;
 182 }
 183 static void print_usbbusnode(struct usbbusnode *b)
 184 {
 185         printf("/:  Bus %02u.Port %u: Dev %u, Class=%s, Driver=%s/%up, %sM\n", b->busnum, 1,
 186                b->devnum, bDeviceClass_to_str(b->bDeviceClass), b->driver, b->maxchild, b->speed);
 187 }
 188
 189 static void print_usbdevice(struct usbdevice *d, struct usbinterface *i)
 190 {
 191         if (i->bInterfaceClass == 9)
 192                 printf("Port %u: Dev %u, If %u, Class=%s, Driver=%s/%up, %sM\n", d->portnum, d->devnum, i->ifnum, bInterfaceClass_to_str(i->bInterfaceClass),
 193                        i->driver, d->maxchild, d->speed);
 194         else
 195                 printf("Port %u: Dev %u, If %u, Class=%s, Driver=%s, %sM\n", d->portnum, d->devnum, i->ifnum, bInterfaceClass_to_str(i->bInterfaceClass), i->driver,
 196                        d->speed);
 197 }
 198
 199 static unsigned int read_sysfs_file_int(const char *d_name, const char *file, int base)
 200 {
 201         char buf[12], path[MY_PATH_MAX];
 202         int fd;
 203         ssize_t r;
 204         unsigned long ret;
 205         snprintf(path, MY_PATH_MAX, "%s/%s/%s", sys_bus_usb_devices, d_name, file);
 206         path[MY_PATH_MAX - 1] = '\0';
 207         fd = open(path, O_RDONLY);
 208         if (fd < 0)
 209                 goto error;
 210         memset(buf, 0, sizeof(buf));
 211         r = read(fd, buf, sizeof(buf) - 1);
 212         close(fd);
 213         if (r < 0)
 214                 goto error;
 215         buf[sizeof(buf) - 1] = '\0';
 216         ret = strtoul(buf, NULL, base);
 217         return (unsigned int)ret;
 218
 219       error:
 220         perror(path);
 221         return 0;
 222 }
 223
 224 static void read_sysfs_file_string(const char *d_name, const char *file, char *buf, int len)
 225 {
 226         char path[MY_PATH_MAX];
 227         int fd;
 228         ssize_t r;
 229         fd = snprintf(path, MY_PATH_MAX, "%s/%s/%s", sys_bus_usb_devices, d_name, file);
 230         if (fd < 0 || fd >= MY_PATH_MAX)
 231                 goto error;
 232         path[fd] = '\0';
 233         fd = open(path, O_RDONLY);
 234         if (fd < 0)
 235                 goto error;
 236         r = read(fd, buf, len);
 237         close(fd);
 238         if (r >= 0 && r < len) {
 239                 buf[r] = '\0';
 240                 r--;
 241                 while (buf[r] == '\n') {
 242                         buf[r] = '\0';
 243                         r--;
 244                 }
 245                 while (r) {
 246                         if (buf[r] == '\n')
 247                                 buf[r] = ' ';
 248                         r--;
 249                 }
 250                 return;
 251         }
 252       error:
 253         buf[0] = '\0';
 254 }
 255
 256 static void append_dev_interface(struct usbinterface *i, struct usbinterface *new)
 257 {
 258         while (i->next)
 259                 i = i->next;
 260         i->next = new;
 261 }
 262
 263 static void append_dev_sibling(struct usbdevice *d, struct usbdevice *new)
 264 {
 265         while (d->next)
 266                 d = d->next;
 267         d->next = new;
 268 }
 269
 270 static void append_businterface(unsigned int busnum, struct usbinterface *new)
 271 {
 272         struct usbbusnode *b = usbbuslist;
 273         struct usbinterface *i;
 274         while (b) {
 275                 if (b->busnum == busnum) {
 276                         i = b->first_interface;
 277                         if (i) {
 278                                 while (i->next)
 279                                         i = i->next;
 280                                 i->next = new;
 281                         } else
 282                                 b->first_interface = new;
 283                         break;
 284                 }
 285                 b = b->next;
 286         }
 287 }
 288
 289 static void append_busnode(struct usbbusnode *new)
 290 {
 291         struct usbbusnode *b = usbbuslist;
 292         if (b) {
 293                 while (b->next)
 294                         b = b->next;
 295                 b->next = new;
 296         } else
 297                 usbbuslist = new;
 298 }
 299
 300 static void add_usb_interface(const char *d_name)
 301 {
 302         struct usbinterface *e;
 303         const char *p;
 304         char *pn, link[MY_PATH_MAX];
 305         unsigned long i;
 306         int l;
 307         p = strchr(d_name, ':');
 308         p++;
 309         i = strtoul(p, &pn, 10);
 310         if (!pn || p == pn)
 311                 return;
 312         e = malloc(sizeof(struct usbinterface));
 313         if (!e)
 314                 return;
 315         memset(e, 0, sizeof(struct usbinterface));
 316         e->configuration = i;
 317         p = pn + 1;
 318         i = strtoul(p, &pn, 10);
 319         if (!pn || p == pn)
 320                 return;
 321         e->ifnum = i;
 322         if (snprintf(e->name, MY_SYSFS_FILENAME_LEN, "%s", d_name) >= MY_SYSFS_FILENAME_LEN)
 323                 printf("warning: '%s' truncated to '%s'\n", e->name, d_name);
 324         SYSFS_INTu(d_name, e, bAlternateSetting);
 325         SYSFS_INTx(d_name, e, bInterfaceClass);
 326         SYSFS_INTx(d_name, e, bInterfaceNumber);
 327         SYSFS_INTx(d_name, e, bInterfaceProtocol);
 328         SYSFS_INTx(d_name, e, bInterfaceSubClass);
 329         SYSFS_INTx(d_name, e, bNumEndpoints);
 330         l = snprintf(link, MY_PATH_MAX, "%s/%s/driver", sys_bus_usb_devices, d_name);
 331         if (l > 0 && l < MY_PATH_MAX) {
 332                 l = readlink(link, link, MY_PATH_MAX);
 333                 if (l < 0)
 334                         perror(d_name);
 335                 else {
 336                         if (l < MY_PATH_MAX - 1)
 337                                 link[l] = '\0';
 338                         else
 339                                 link[0] = '\0';
 340                         p = strrchr(link, '/');
 341                         if (p)
 342                                 snprintf(e->driver, sizeof(e->driver), "%s", p + 1);
 343                 }
 344         } else
 345                 printf("Can not read driver link for '%s': %d\n", d_name, l);
 346         list_add_tail(&e->list, &interfacelist);
 347 }
 348
 349 static void add_usb_device(const char *d_name)
 350 {
 351         struct usbdevice *d;
 352         const char *p;
 353         char *pn, link[MY_PATH_MAX];
 354         unsigned long i;
 355         int l;
 356         p = d_name;
 357         i = strtoul(p, &pn, 10);
 358         if (!pn || p == pn)
 359                 return;
 360         d = malloc(sizeof(struct usbdevice));
 361         if (!d)
 362                 return;
 363         memset(d, 0, sizeof(struct usbdevice));
 364         d->busnum = i;
 365         while (pn) {
 366                 p = pn + 1;
 367                 i = strtoul(p, &pn, 10);
 368                 if (p == pn)
 369                         break;
 370                 d->parent_portnum = d->portnum;
 371                 d->portnum = i;
 372         }
 373         if (snprintf(d->name, MY_SYSFS_FILENAME_LEN, "%s", d_name) >= MY_SYSFS_FILENAME_LEN)
 374                 printf("warning: '%s' truncated to '%s'\n", d->name, d_name);
 375         SYSFS_INTu(d_name, d, bConfigurationValue);
 376         SYSFS_INTx(d_name, d, bDeviceClass);
 377         SYSFS_INTx(d_name, d, bDeviceProtocol);
 378         SYSFS_INTx(d_name, d, bDeviceSubClass);
 379         SYSFS_INTx(d_name, d, bMaxPacketSize0);
 380         SYSFS_STR(d_name, d, bMaxPower);
 381         SYSFS_INTu(d_name, d, bNumConfigurations);
 382         SYSFS_INTx(d_name, d, bNumInterfaces);
 383         SYSFS_INTx(d_name, d, bcdDevice);
 384         SYSFS_INTx(d_name, d, bmAttributes);
 385         SYSFS_INTu(d_name, d, configuration);
 386         SYSFS_INTu(d_name, d, devnum);
 387         SYSFS_INTx(d_name, d, idProduct);
 388         SYSFS_INTx(d_name, d, idVendor);
 389         SYSFS_INTu(d_name, d, maxchild);
 390         SYSFS_STR(d_name, d, manufacturer);
 391         SYSFS_STR(d_name, d, product);
 392         SYSFS_STR(d_name, d, serial);
 393         SYSFS_STR(d_name, d, version);
 394         SYSFS_STR(d_name, d, speed);
 395         l = snprintf(link, MY_PATH_MAX, "%s/%s/driver", sys_bus_usb_devices, d_name);
 396         if (l > 0 && l < MY_PATH_MAX) {
 397                 l = readlink(link, link, MY_PATH_MAX);
 398                 if (l < 0)
 399                         perror(d_name);
 400                 else {
 401                         if (l < MY_PATH_MAX - 1)
 402                                 link[l] = '\0';
 403                         else
 404                                 link[0] = '\0';
 405                         p = strrchr(link, '/');
 406                         if (p)
 407                                 snprintf(d->driver, sizeof(d->driver), "%s", p + 1);
 408                 }
 409         } else
 410                 printf("Can not read driver link for '%s': %d\n", d_name, l);
 411         list_add_tail(&d->list, &usbdevlist);
 412 }
 413
 414 static void get_roothub_driver(struct usbbusnode *b, const char *d_name)
 415 {
 416         char *p, path[MY_PATH_MAX];
 417         int l;
 418         l = snprintf(path, MY_PATH_MAX, "%s/%s/../driver", sys_bus_usb_devices, d_name);
 419         if (l > 0 && l < MY_PATH_MAX) {
 420                 l = readlink(path, path, MY_PATH_MAX);
 421                 if (l < 0)
 422                         perror(d_name);
 423                 else {
 424                         if (l < MY_PATH_MAX - 1)
 425                                 path[l] = '\0';
 426                         else
 427                                 path[0] = '\0';
 428                         p = strrchr(path, '/');
 429                         if (p)
 430                                 snprintf(b->driver, sizeof(b->driver), "%s", p + 1);
 431                 }
 432         } else
 433                 printf("Can not read driver link for '%s': %d\n", d_name, l);
 434 }
 435
 436 static void add_usb_bus(const char *d_name)
 437 {
 438         struct usbbusnode *bus;
 439         bus = malloc(sizeof(struct usbbusnode));
 440         if (bus) {
 441                 memset(bus, 0, sizeof(struct usbbusnode));
 442                 bus->busnum = strtoul(d_name + 3, NULL, 10);
 443                 SYSFS_INTu(d_name, bus, devnum);
 444                 SYSFS_INTx(d_name, bus, bDeviceClass);
 445                 SYSFS_INTu(d_name, bus, maxchild);
 446                 SYSFS_STR(d_name, bus, speed);
 447                 append_busnode(bus);
 448                 get_roothub_driver(bus, d_name);
 449         }
 450 }
 451
 452 static void inspect_bus_entry(const char *d_name)
 453 {
 454         if (d_name[0] == '.' && (!d_name[1] || (d_name[1] == '.' && !d_name[2])))
 455                 return;
 456         if (d_name[0] == 'u' && d_name[1] == 's' && d_name[2] == 'b' && isdigit(d_name[3])) {
 457                 add_usb_bus(d_name);
 458         } else if (isdigit(d_name[0])) {
 459                 if (strchr(d_name, ':'))
 460                         add_usb_interface(d_name);
 461                 else
 462                         add_usb_device(d_name);
 463         } else
 464                 fprintf(stderr, "ignoring '%s'\n", d_name);
 465 }
 466
 467 static void walk_usb_devices(DIR * sbud)
 468 {
 469         struct dirent *de;
 470         while ((de = readdir(sbud)))
 471                 inspect_bus_entry(de->d_name);
 472 }
 473
 474 static void assign_dev_to_bus(struct usbdevice *d)
 475 {
 476         struct usbbusnode *b = usbbuslist;
 477         while (b) {
 478                 if (b->busnum == d->busnum) {
 479                         if (b->first_child)
 480                                 append_dev_sibling(b->first_child, d);
 481                         else
 482                                 b->first_child = d;
 483                 }
 484                 b = b->next;
 485         }
 486 }
 487
 488 static void assign_dev_to_parent(struct usbdevice *d)
 489 {
 490         struct list_head *l;
 491         struct usbdevice *pd;
 492         char n[MY_SYSFS_FILENAME_LEN], *p;
 493         for (l = usbdevlist.next; l != &usbdevlist; l = l->next) {
 494                 pd = list_entry(l, struct usbdevice, list);
 495                 if (pd == d)
 496                         continue;
 497                 if (pd->busnum == d->busnum && pd->portnum == d->parent_portnum) {
 498                         strcpy(n, d->name);
 499                         p = strrchr(n, '.');
 500                         if (p) {
 501                                 *p = '\0';
 502                                 if (strcmp(n, pd->name)) {
 503                                         continue;
 504                                 }
 505                                 d->parent = pd;
 506                                 if (pd->first_child)
 507                                         append_dev_sibling(pd->first_child, d);
 508                                 else
 509                                         pd->first_child = d;
 510                                 break;
 511                         }
 512                 }
 513         }
 514 }
 515
 516 static void assign_interface_to_parent(struct usbdevice *d, struct usbinterface *i)
 517 {
 518         const char *p;
 519         char *pn, name[MY_SYSFS_FILENAME_LEN];
 520         ptrdiff_t l;
 521         unsigned int busnum;
 522
 523         p = strchr(i->name, ':');
 524         if (p) {
 525                 l = p - i->name;
 526                 if (l < MY_SYSFS_FILENAME_LEN) {
 527                         memcpy(name, i->name, l);
 528                         name[l] = '\0';
 529                 } else
 530                         name[0] = '\0';
 531                 if (strcmp(d->name, name) == 0) {
 532                         i->parent = d;
 533                         if (d->first_interface)
 534                                 append_dev_interface(d->first_interface, i);
 535                         else
 536                                 d->first_interface = i;
 537                 } else {
 538                         busnum = strtoul(name, &pn, 10);
 539                         if (pn && pn != name) {
 540                                 if (p[1] == '0')
 541                                         append_businterface(busnum, i);
 542                         }
 543                 }
 544         }
 545 }
 546
 547 static void connect_devices(void)
 548 {
 549         struct list_head *ld, *li;
 550         struct usbdevice *d;
 551         struct usbinterface *e;
 552         for (ld = usbdevlist.next; ld != &usbdevlist; ld = ld->next) {
 553                 d = list_entry(ld, struct usbdevice, list);
 554                 if (d->parent_portnum)
 555                         assign_dev_to_parent(d);
 556                 else
 557                         assign_dev_to_bus(d);
 558                 for (li = interfacelist.next; li != &interfacelist; li = li->next) {
 559                         e = list_entry(li, struct usbinterface, list);
 560                         if (!e->parent)
 561                                 assign_interface_to_parent(d, e);
 562                 }
 563         }
 564         for (li = interfacelist.next; li != &interfacelist; li = li->next) {
 565                 e = list_entry(li, struct usbinterface, list);
 566         }
 567 }
 568
 569 static void sort_dev_interfaces(struct usbinterface **i)
 570 {
 571         struct usbinterface *t, *p, **pp;
 572         int swapped;
 573         p = *i;
 574         pp = i;
 575         do {
 576                 p = *i;
 577                 pp = i;
 578                 swapped = 0;
 579                 while (p->next) {
 580                         if (p->configuration > p->next->configuration) {
 581                                 t = p->next;
 582                                 p->next = t->next;
 583                                 t->next = p;
 584                                 *pp = t;
 585                                 swapped = 1;
 586                                 p = t;
 587                         }
 588                         if (p->ifnum > p->next->ifnum) {
 589                                 t = p->next;
 590                                 p->next = t->next;
 591                                 t->next = p;
 592                                 *pp = t;
 593                                 swapped = 1;
 594                                 p = t;
 595                         }
 596                         pp = &p->next;
 597                         p = p->next;
 598                 }
 599         } while (swapped);
 600 }
 601
 602 static void sort_dev_siblings(struct usbdevice **d)
 603 {
 604         struct usbdevice *t, *p, **pp;
 605         int swapped;
 606         p = *d;
 607         pp = d;
 608         if (p->first_child)
 609                 sort_dev_siblings(&p->first_child);
 610         if (p->first_interface)
 611                 sort_dev_interfaces(&p->first_interface);
 612         do {
 613                 p = *d;
 614                 pp = d;
 615                 swapped = 0;
 616                 while (p->next) {
 617                         if (p->portnum > p->next->portnum) {
 618                                 t = p->next;
 619                                 p->next = t->next;
 620                                 t->next = p;
 621                                 *pp = t;
 622                                 swapped = 1;
 623                                 p = t;
 624                         }
 625                         pp = &p->next;
 626                         p = p->next;
 627                 }
 628         } while (swapped);
 629 }
 630
 631 static void sort_devices(void)
 632 {
 633         struct usbbusnode *b = usbbuslist;
 634         while (b) {
 635                 if (b->first_child)
 636                         sort_dev_siblings(&b->first_child);
 637                 b = b->next;
 638         }
 639 }
 640
 641 static void sort_busses(void)
 642 {
 643         /* need to reverse sort bus numbers */
 644         struct usbbusnode *t, *p, **pp;
 645         int swapped;
 646         do {
 647                 p = usbbuslist;
 648                 pp = &usbbuslist;
 649                 swapped = 0;
 650                 while (p->next) {
 651                         if (p->busnum < p->next->busnum) {
 652                                 t = p->next;
 653                                 p->next = t->next;
 654                                 t->next = p;
 655                                 *pp = t;
 656                                 swapped = 1;
 657                                 p = t;
 658                         }
 659                         pp = &p->next;
 660                         p = p->next;
 661                 }
 662         } while (swapped);
 663 }
 664
 665 static void print_tree_dev_interface(struct usbdevice *d, struct usbinterface *i)
 666 {
 667         indent += 3;
 668         while (i) {
 669                 printf(" %*s", indent, "|__ ");
 670                 print_usbdevice(d, i);
 671                 i = i->next;
 672         }
 673         indent -= 3;
 674 }
 675 static void print_tree_dev_children(struct usbdevice *d)
 676 {
 677         indent += 4;
 678         while (d) {
 679                 print_tree_dev_interface(d, d->first_interface);
 680                 print_tree_dev_children(d->first_child);
 681                 d = d->next;
 682         }
 683         indent -= 4;
 684 }
 685
 686 static void print_tree(void)
 687 {
 688         struct usbbusnode *b = usbbuslist;
 689         while (b) {
 690                 print_usbbusnode(b);
 691                 if (b->first_child)
 692                         print_tree_dev_children(b->first_child);
 693                 b = b->next;
 694         }
 695 }
 696
 697 int lsusb_t(void)
 698 {
 699         DIR *sbud = opendir(sys_bus_usb_devices);
 700         if (sbud) {
 701                 walk_usb_devices(sbud);
 702                 closedir(sbud);
 703                 connect_devices();
 704                 sort_devices();
 705                 sort_busses();
 706                 print_tree();
 707         } else
 708                 perror(sys_bus_usb_devices);
 709         return sbud == NULL;
 710 }