usbcore: trivial whitespace fixes · tjh.dev/kernel@9251644

+49 -49

drivers/usb/core/sysfs.c

··· 16 16 17 17 /* Active configuration fields */ 18 18 #define usb_actconfig_show(field, multiplier, format_string) \ 19 - static ssize_t show_##field (struct device *dev, \ 19 + static ssize_t show_##field(struct device *dev, \ 20 20 struct device_attribute *attr, char *buf) \ 21 21 { \ 22 22 struct usb_device *udev; \ 23 23 struct usb_host_config *actconfig; \ 24 24 \ 25 - udev = to_usb_device (dev); \ 25 + udev = to_usb_device(dev); \ 26 26 actconfig = udev->actconfig; \ 27 27 if (actconfig) \ 28 - return sprintf (buf, format_string, \ 28 + return sprintf(buf, format_string, \ 29 29 actconfig->desc.field * multiplier); \ 30 30 else \ 31 31 return 0; \ ··· 35 35 usb_actconfig_show(field, multiplier, format_string) \ 36 36 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 37 37 38 - usb_actconfig_attr (bNumInterfaces, 1, "%2d\n") 39 - usb_actconfig_attr (bmAttributes, 1, "%2x\n") 40 - usb_actconfig_attr (bMaxPower, 2, "%3dmA\n") 38 + usb_actconfig_attr(bNumInterfaces, 1, "%2d\n") 39 + usb_actconfig_attr(bmAttributes, 1, "%2x\n") 40 + usb_actconfig_attr(bMaxPower, 2, "%3dmA\n") 41 41 42 42 static ssize_t show_configuration_string(struct device *dev, 43 43 struct device_attribute *attr, char *buf) ··· 45 45 struct usb_device *udev; 46 46 struct usb_host_config *actconfig; 47 47 48 - udev = to_usb_device (dev); 48 + udev = to_usb_device(dev); 49 49 actconfig = udev->actconfig; 50 50 if ((!actconfig) || (!actconfig->string)) 51 51 return 0; ··· 57 57 usb_actconfig_show(bConfigurationValue, 1, "%u\n"); 58 58 59 59 static ssize_t 60 - set_bConfigurationValue (struct device *dev, struct device_attribute *attr, 60 + set_bConfigurationValue(struct device *dev, struct device_attribute *attr, 61 61 const char *buf, size_t count) 62 62 { 63 - struct usb_device *udev = to_usb_device (dev); 63 + struct usb_device *udev = to_usb_device(dev); 64 64 int config, value; 65 65 66 - if (sscanf (buf, "%u", &config) != 1 || config > 255) 66 + if (sscanf(buf, "%u", &config) != 1 || config > 255) 67 67 return -EINVAL; 68 68 usb_lock_device(udev); 69 - value = usb_set_configuration (udev, config); 69 + value = usb_set_configuration(udev, config); 70 70 usb_unlock_device(udev); 71 71 return (value < 0) ? value : count; 72 72 } ··· 81 81 { \ 82 82 struct usb_device *udev; \ 83 83 \ 84 - udev = to_usb_device (dev); \ 84 + udev = to_usb_device(dev); \ 85 85 return sprintf(buf, "%s\n", udev->name); \ 86 86 } \ 87 87 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL); ··· 91 91 usb_string_attr(serial); 92 92 93 93 static ssize_t 94 - show_speed (struct device *dev, struct device_attribute *attr, char *buf) 94 + show_speed(struct device *dev, struct device_attribute *attr, char *buf) 95 95 { 96 96 struct usb_device *udev; 97 97 char *speed; 98 98 99 - udev = to_usb_device (dev); 99 + udev = to_usb_device(dev); 100 100 101 101 switch (udev->speed) { 102 102 case USB_SPEED_LOW: ··· 112 112 default: 113 113 speed = "unknown"; 114 114 } 115 - return sprintf (buf, "%s\n", speed); 115 + return sprintf(buf, "%s\n", speed); 116 116 } 117 117 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL); 118 118 119 119 static ssize_t 120 - show_devnum (struct device *dev, struct device_attribute *attr, char *buf) 120 + show_devnum(struct device *dev, struct device_attribute *attr, char *buf) 121 121 { 122 122 struct usb_device *udev; 123 123 124 - udev = to_usb_device (dev); 125 - return sprintf (buf, "%d\n", udev->devnum); 124 + udev = to_usb_device(dev); 125 + return sprintf(buf, "%d\n", udev->devnum); 126 126 } 127 127 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL); 128 128 129 129 static ssize_t 130 - show_version (struct device *dev, struct device_attribute *attr, char *buf) 130 + show_version(struct device *dev, struct device_attribute *attr, char *buf) 131 131 { 132 132 struct usb_device *udev; 133 133 u16 bcdUSB; ··· 139 139 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL); 140 140 141 141 static ssize_t 142 - show_maxchild (struct device *dev, struct device_attribute *attr, char *buf) 142 + show_maxchild(struct device *dev, struct device_attribute *attr, char *buf) 143 143 { 144 144 struct usb_device *udev; 145 145 146 - udev = to_usb_device (dev); 147 - return sprintf (buf, "%d\n", udev->maxchild); 146 + udev = to_usb_device(dev); 147 + return sprintf(buf, "%d\n", udev->maxchild); 148 148 } 149 149 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL); 150 150 151 151 /* Descriptor fields */ 152 152 #define usb_descriptor_attr_le16(field, format_string) \ 153 153 static ssize_t \ 154 - show_##field (struct device *dev, struct device_attribute *attr, \ 154 + show_##field(struct device *dev, struct device_attribute *attr, \ 155 155 char *buf) \ 156 156 { \ 157 157 struct usb_device *udev; \ 158 158 \ 159 - udev = to_usb_device (dev); \ 160 - return sprintf (buf, format_string, \ 159 + udev = to_usb_device(dev); \ 160 + return sprintf(buf, format_string, \ 161 161 le16_to_cpu(udev->descriptor.field)); \ 162 162 } \ 163 163 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); ··· 168 168 169 169 #define usb_descriptor_attr(field, format_string) \ 170 170 static ssize_t \ 171 - show_##field (struct device *dev, struct device_attribute *attr, \ 171 + show_##field(struct device *dev, struct device_attribute *attr, \ 172 172 char *buf) \ 173 173 { \ 174 174 struct usb_device *udev; \ 175 175 \ 176 - udev = to_usb_device (dev); \ 177 - return sprintf (buf, format_string, udev->descriptor.field); \ 176 + udev = to_usb_device(dev); \ 177 + return sprintf(buf, format_string, udev->descriptor.field); \ 178 178 } \ 179 179 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 180 180 181 - usb_descriptor_attr (bDeviceClass, "%02x\n") 182 - usb_descriptor_attr (bDeviceSubClass, "%02x\n") 183 - usb_descriptor_attr (bDeviceProtocol, "%02x\n") 184 - usb_descriptor_attr (bNumConfigurations, "%d\n") 185 - usb_descriptor_attr (bMaxPacketSize0, "%d\n") 181 + usb_descriptor_attr(bDeviceClass, "%02x\n") 182 + usb_descriptor_attr(bDeviceSubClass, "%02x\n") 183 + usb_descriptor_attr(bDeviceProtocol, "%02x\n") 184 + usb_descriptor_attr(bNumConfigurations, "%d\n") 185 + usb_descriptor_attr(bMaxPacketSize0, "%d\n") 186 186 187 187 static struct attribute *dev_attrs[] = { 188 188 /* current configuration's attributes */ ··· 220 220 return retval; 221 221 222 222 if (udev->manufacturer) { 223 - retval = device_create_file (dev, &dev_attr_manufacturer); 223 + retval = device_create_file(dev, &dev_attr_manufacturer); 224 224 if (retval) 225 225 goto error; 226 226 } 227 227 if (udev->product) { 228 - retval = device_create_file (dev, &dev_attr_product); 228 + retval = device_create_file(dev, &dev_attr_product); 229 229 if (retval) 230 230 goto error; 231 231 } 232 232 if (udev->serial) { 233 - retval = device_create_file (dev, &dev_attr_serial); 233 + retval = device_create_file(dev, &dev_attr_serial); 234 234 if (retval) 235 235 goto error; 236 236 } ··· 246 246 return retval; 247 247 } 248 248 249 - void usb_remove_sysfs_dev_files (struct usb_device *udev) 249 + void usb_remove_sysfs_dev_files(struct usb_device *udev) 250 250 { 251 251 struct device *dev = &udev->dev; 252 252 ··· 264 264 /* Interface fields */ 265 265 #define usb_intf_attr(field, format_string) \ 266 266 static ssize_t \ 267 - show_##field (struct device *dev, struct device_attribute *attr, \ 267 + show_##field(struct device *dev, struct device_attribute *attr, \ 268 268 char *buf) \ 269 269 { \ 270 - struct usb_interface *intf = to_usb_interface (dev); \ 270 + struct usb_interface *intf = to_usb_interface(dev); \ 271 271 \ 272 - return sprintf (buf, format_string, \ 272 + return sprintf(buf, format_string, \ 273 273 intf->cur_altsetting->desc.field); \ 274 274 } \ 275 275 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 276 276 277 - usb_intf_attr (bInterfaceNumber, "%02x\n") 278 - usb_intf_attr (bAlternateSetting, "%2d\n") 279 - usb_intf_attr (bNumEndpoints, "%02x\n") 280 - usb_intf_attr (bInterfaceClass, "%02x\n") 281 - usb_intf_attr (bInterfaceSubClass, "%02x\n") 282 - usb_intf_attr (bInterfaceProtocol, "%02x\n") 277 + usb_intf_attr(bInterfaceNumber, "%02x\n") 278 + usb_intf_attr(bAlternateSetting, "%2d\n") 279 + usb_intf_attr(bNumEndpoints, "%02x\n") 280 + usb_intf_attr(bInterfaceClass, "%02x\n") 281 + usb_intf_attr(bInterfaceSubClass, "%02x\n") 282 + usb_intf_attr(bInterfaceProtocol, "%02x\n") 283 283 284 284 static ssize_t show_interface_string(struct device *dev, 285 285 struct device_attribute *attr, char *buf) ··· 288 288 struct usb_device *udev; 289 289 int len; 290 290 291 - intf = to_usb_interface (dev); 292 - udev = interface_to_usbdev (intf); 291 + intf = to_usb_interface(dev); 292 + udev = interface_to_usbdev(intf); 293 293 len = snprintf(buf, 256, "%s", intf->cur_altsetting->string); 294 294 if (len < 0) 295 295 return 0; ··· 384 384 return retval; 385 385 } 386 386 387 - void usb_remove_sysfs_intf_files (struct usb_interface *intf) 387 + void usb_remove_sysfs_intf_files(struct usb_interface *intf) 388 388 { 389 389 usb_remove_intf_ep_files(intf); 390 390 sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);

+10 -10

drivers/usb/core/urb.c

··· 240 240 * and don't need to duplicate tests 241 241 */ 242 242 pipe = urb->pipe; 243 - temp = usb_pipetype (pipe); 244 - is_out = usb_pipeout (pipe); 243 + temp = usb_pipetype(pipe); 244 + is_out = usb_pipeout(pipe); 245 245 246 - if (!usb_pipecontrol (pipe) && dev->state < USB_STATE_CONFIGURED) 246 + if (!usb_pipecontrol(pipe) && dev->state < USB_STATE_CONFIGURED) 247 247 return -ENODEV; 248 248 249 249 /* FIXME there should be a sharable lock protecting us against ··· 252 252 * checks get made.) 253 253 */ 254 254 255 - max = usb_maxpacket (dev, pipe, is_out); 255 + max = usb_maxpacket(dev, pipe, is_out); 256 256 if (max <= 0) { 257 257 dev_dbg(&dev->dev, 258 258 "bogus endpoint ep%d%s in %s (bad maxpacket %d)\n", 259 - usb_pipeendpoint (pipe), is_out ? "out" : "in", 259 + usb_pipeendpoint(pipe), is_out ? "out" : "in", 260 260 __FUNCTION__, max); 261 261 return -EMSGSIZE; 262 262 } ··· 278 278 if (urb->number_of_packets <= 0) 279 279 return -EINVAL; 280 280 for (n = 0; n < urb->number_of_packets; n++) { 281 - len = urb->iso_frame_desc [n].length; 281 + len = urb->iso_frame_desc[n].length; 282 282 if (len < 0 || len > max) 283 283 return -EMSGSIZE; 284 - urb->iso_frame_desc [n].status = -EXDEV; 285 - urb->iso_frame_desc [n].actual_length = 0; 284 + urb->iso_frame_desc[n].status = -EXDEV; 285 + urb->iso_frame_desc[n].actual_length = 0; 286 286 } 287 287 } 288 288 ··· 321 321 322 322 /* fail if submitter gave bogus flags */ 323 323 if (urb->transfer_flags != orig_flags) { 324 - err ("BOGUS urb flags, %x --> %x", 324 + err("BOGUS urb flags, %x --> %x", 325 325 orig_flags, urb->transfer_flags); 326 326 return -EINVAL; 327 327 } ··· 372 372 urb->interval = temp; 373 373 } 374 374 375 - return usb_hcd_submit_urb (urb, mem_flags); 375 + return usb_hcd_submit_urb(urb, mem_flags); 376 376 } 377 377 378 378 /*-------------------------------------------------------------------*/

+48 -48

drivers/usb/core/usb.c

··· 233 233 * @parent: hub to which device is connected; null to allocate a root hub 234 234 * @bus: bus used to access the device 235 235 * @port1: one-based index of port; ignored for root hubs 236 - * Context: !in_interrupt () 236 + * Context: !in_interrupt() 237 237 * 238 238 * Only hub drivers (including virtual root hub drivers for host 239 239 * controllers) should ever call this. ··· 277 277 * as stable: bus->busnum changes easily from modprobe order, 278 278 * cardbus or pci hotplugging, and so on. 279 279 */ 280 - if (unlikely (!parent)) { 281 - dev->devpath [0] = '0'; 280 + if (unlikely(!parent)) { 281 + dev->devpath[0] = '0'; 282 282 283 283 dev->dev.parent = bus->controller; 284 - sprintf (&dev->dev.bus_id[0], "usb%d", bus->busnum); 284 + sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum); 285 285 } else { 286 286 /* match any labeling on the hubs; it's one-based */ 287 - if (parent->devpath [0] == '0') 288 - snprintf (dev->devpath, sizeof dev->devpath, 287 + if (parent->devpath[0] == '0') 288 + snprintf(dev->devpath, sizeof dev->devpath, 289 289 "%d", port1); 290 290 else 291 - snprintf (dev->devpath, sizeof dev->devpath, 291 + snprintf(dev->devpath, sizeof dev->devpath, 292 292 "%s.%d", parent->devpath, port1); 293 293 294 294 dev->dev.parent = &parent->dev; 295 - sprintf (&dev->dev.bus_id[0], "%d-%s", 295 + sprintf(&dev->dev.bus_id[0], "%d-%s", 296 296 bus->busnum, dev->devpath); 297 297 298 298 /* hub driver sets up TT records */ ··· 463 463 /* see if this device matches */ 464 464 if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) && 465 465 (product_id == le16_to_cpu(dev->descriptor.idProduct))) { 466 - dev_dbg (&dev->dev, "matched this device!\n"); 466 + dev_dbg(&dev->dev, "matched this device!\n"); 467 467 ret_dev = usb_get_dev(dev); 468 468 goto exit; 469 469 } ··· 535 535 */ 536 536 int usb_get_current_frame_number(struct usb_device *dev) 537 537 { 538 - return usb_hcd_get_frame_number (dev); 538 + return usb_hcd_get_frame_number(dev); 539 539 } 540 540 541 541 /*-------------------------------------------------------------------*/ ··· 593 593 * 594 594 * When the buffer is no longer used, free it with usb_buffer_free(). 595 595 */ 596 - void *usb_buffer_alloc ( 596 + void *usb_buffer_alloc( 597 597 struct usb_device *dev, 598 598 size_t size, 599 599 gfp_t mem_flags, ··· 602 602 { 603 603 if (!dev || !dev->bus) 604 604 return NULL; 605 - return hcd_buffer_alloc (dev->bus, size, mem_flags, dma); 605 + return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 606 606 } 607 607 608 608 /** ··· 616 616 * been allocated using usb_buffer_alloc(), and the parameters must match 617 617 * those provided in that allocation request. 618 618 */ 619 - void usb_buffer_free ( 619 + void usb_buffer_free( 620 620 struct usb_device *dev, 621 621 size_t size, 622 622 void *addr, ··· 627 627 return; 628 628 if (!addr) 629 629 return; 630 - hcd_buffer_free (dev->bus, size, addr, dma); 630 + hcd_buffer_free(dev->bus, size, addr, dma); 631 631 } 632 632 633 633 /** ··· 647 647 * Reverse the effect of this call with usb_buffer_unmap(). 648 648 */ 649 649 #if 0 650 - struct urb *usb_buffer_map (struct urb *urb) 650 + struct urb *usb_buffer_map(struct urb *urb) 651 651 { 652 652 struct usb_bus *bus; 653 653 struct device *controller; ··· 659 659 return NULL; 660 660 661 661 if (controller->dma_mask) { 662 - urb->transfer_dma = dma_map_single (controller, 662 + urb->transfer_dma = dma_map_single(controller, 663 663 urb->transfer_buffer, urb->transfer_buffer_length, 664 - usb_pipein (urb->pipe) 664 + usb_pipein(urb->pipe) 665 665 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 666 - if (usb_pipecontrol (urb->pipe)) 667 - urb->setup_dma = dma_map_single (controller, 666 + if (usb_pipecontrol(urb->pipe)) 667 + urb->setup_dma = dma_map_single(controller, 668 668 urb->setup_packet, 669 - sizeof (struct usb_ctrlrequest), 669 + sizeof(struct usb_ctrlrequest), 670 670 DMA_TO_DEVICE); 671 671 // FIXME generic api broken like pci, can't report errors 672 672 // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; ··· 689 689 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s) 690 690 * @urb: urb whose transfer_buffer/setup_packet will be synchronized 691 691 */ 692 - void usb_buffer_dmasync (struct urb *urb) 692 + void usb_buffer_dmasync(struct urb *urb) 693 693 { 694 694 struct usb_bus *bus; 695 695 struct device *controller; ··· 702 702 return; 703 703 704 704 if (controller->dma_mask) { 705 - dma_sync_single (controller, 705 + dma_sync_single(controller, 706 706 urb->transfer_dma, urb->transfer_buffer_length, 707 - usb_pipein (urb->pipe) 707 + usb_pipein(urb->pipe) 708 708 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 709 - if (usb_pipecontrol (urb->pipe)) 710 - dma_sync_single (controller, 709 + if (usb_pipecontrol(urb->pipe)) 710 + dma_sync_single(controller, 711 711 urb->setup_dma, 712 - sizeof (struct usb_ctrlrequest), 712 + sizeof(struct usb_ctrlrequest), 713 713 DMA_TO_DEVICE); 714 714 } 715 715 } ··· 722 722 * Reverses the effect of usb_buffer_map(). 723 723 */ 724 724 #if 0 725 - void usb_buffer_unmap (struct urb *urb) 725 + void usb_buffer_unmap(struct urb *urb) 726 726 { 727 727 struct usb_bus *bus; 728 728 struct device *controller; ··· 735 735 return; 736 736 737 737 if (controller->dma_mask) { 738 - dma_unmap_single (controller, 738 + dma_unmap_single(controller, 739 739 urb->transfer_dma, urb->transfer_buffer_length, 740 - usb_pipein (urb->pipe) 740 + usb_pipein(urb->pipe) 741 741 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 742 - if (usb_pipecontrol (urb->pipe)) 743 - dma_unmap_single (controller, 742 + if (usb_pipecontrol(urb->pipe)) 743 + dma_unmap_single(controller, 744 744 urb->setup_dma, 745 - sizeof (struct usb_ctrlrequest), 745 + sizeof(struct usb_ctrlrequest), 746 746 DMA_TO_DEVICE); 747 747 } 748 748 urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP ··· 783 783 struct device *controller; 784 784 785 785 if (!dev 786 - || usb_pipecontrol (pipe) 786 + || usb_pipecontrol(pipe) 787 787 || !(bus = dev->bus) 788 788 || !(controller = bus->controller) 789 789 || !controller->dma_mask) 790 790 return -1; 791 791 792 792 // FIXME generic api broken like pci, can't report errors 793 - return dma_map_sg (controller, sg, nents, 794 - usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 793 + return dma_map_sg(controller, sg, nents, 794 + usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 795 795 } 796 796 797 797 /* XXX DISABLED, no users currently. If you wish to re-enable this ··· 823 823 || !controller->dma_mask) 824 824 return; 825 825 826 - dma_sync_sg (controller, sg, n_hw_ents, 827 - usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 826 + dma_sync_sg(controller, sg, n_hw_ents, 827 + usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 828 828 } 829 829 #endif 830 830 ··· 849 849 || !controller->dma_mask) 850 850 return; 851 851 852 - dma_unmap_sg (controller, sg, n_hw_ents, 853 - usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 852 + dma_unmap_sg(controller, sg, n_hw_ents, 853 + usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 854 854 } 855 855 856 856 /* format to disable USB on kernel command line is: nousb */ ··· 871 871 { 872 872 int retval; 873 873 if (nousb) { 874 - pr_info ("%s: USB support disabled\n", usbcore_name); 874 + pr_info("%s: USB support disabled\n", usbcore_name); 875 875 return 0; 876 876 } 877 877 ··· 971 971 EXPORT_SYMBOL(usb_find_device); 972 972 EXPORT_SYMBOL(usb_get_current_frame_number); 973 973 974 - EXPORT_SYMBOL (usb_buffer_alloc); 975 - EXPORT_SYMBOL (usb_buffer_free); 974 + EXPORT_SYMBOL(usb_buffer_alloc); 975 + EXPORT_SYMBOL(usb_buffer_free); 976 976 977 977 #if 0 978 - EXPORT_SYMBOL (usb_buffer_map); 979 - EXPORT_SYMBOL (usb_buffer_dmasync); 980 - EXPORT_SYMBOL (usb_buffer_unmap); 978 + EXPORT_SYMBOL(usb_buffer_map); 979 + EXPORT_SYMBOL(usb_buffer_dmasync); 980 + EXPORT_SYMBOL(usb_buffer_unmap); 981 981 #endif 982 982 983 - EXPORT_SYMBOL (usb_buffer_map_sg); 983 + EXPORT_SYMBOL(usb_buffer_map_sg); 984 984 #if 0 985 - EXPORT_SYMBOL (usb_buffer_dmasync_sg); 985 + EXPORT_SYMBOL(usb_buffer_dmasync_sg); 986 986 #endif 987 - EXPORT_SYMBOL (usb_buffer_unmap_sg); 987 + EXPORT_SYMBOL(usb_buffer_unmap_sg); 988 988 989 989 MODULE_LICENSE("GPL");