net: usb: usbnet: adhere to style · tjh.dev/kernel@de9c416

+120 -113

1 changed file

expand all

drivers

net

usb

usbnet.c

+120 -113

drivers/net/usb/usbnet.c

··· 142 142 143 143 if (alt->desc.bAlternateSetting != 0 || 144 144 !(dev->driver_info->flags & FLAG_NO_SETINT)) { 145 - tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber, 146 - alt->desc.bAlternateSetting); 145 + tmp = usb_set_interface(dev->udev, alt->desc.bInterfaceNumber, 146 + alt->desc.bAlternateSetting); 147 147 if (tmp < 0) 148 148 return tmp; 149 149 } 150 150 151 - dev->in = usb_rcvbulkpipe (dev->udev, 152 - in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 153 - dev->out = usb_sndbulkpipe (dev->udev, 154 - out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 151 + dev->in = usb_rcvbulkpipe(dev->udev, 152 + in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 153 + dev->out = usb_sndbulkpipe(dev->udev, 154 + out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); 155 155 dev->status = status; 156 156 return 0; 157 157 } ··· 163 163 int tmp = -1, ret; 164 164 unsigned char buf [13]; 165 165 166 - ret = usb_string(dev->udev, iMACAddress, buf, sizeof buf); 166 + ret = usb_string(dev->udev, iMACAddress, buf, sizeof(buf)); 167 167 if (ret == 12) 168 168 tmp = hex2bin(addr, buf, 6); 169 169 if (tmp < 0) { ··· 215 215 break; 216 216 } 217 217 218 - status = usb_submit_urb (urb, GFP_ATOMIC); 218 + status = usb_submit_urb(urb, GFP_ATOMIC); 219 219 if (status != 0) 220 220 netif_err(dev, timer, dev->net, 221 221 "intr resubmit --> %d\n", status); ··· 231 231 if (!dev->driver_info->status) 232 232 return 0; 233 233 234 - pipe = usb_rcvintpipe (dev->udev, 235 - dev->status->desc.bEndpointAddress 236 - & USB_ENDPOINT_NUMBER_MASK); 234 + pipe = usb_rcvintpipe(dev->udev, 235 + dev->status->desc.bEndpointAddress 236 + & USB_ENDPOINT_NUMBER_MASK); 237 237 maxp = usb_maxpacket(dev->udev, pipe); 238 238 239 239 /* avoid 1 msec chatter: min 8 msec poll rate */ 240 240 period = max ((int) dev->status->desc.bInterval, 241 241 (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3); 242 242 243 - buf = kmalloc (maxp, GFP_KERNEL); 243 + buf = kmalloc(maxp, GFP_KERNEL); 244 244 if (buf) { 245 - dev->interrupt = usb_alloc_urb (0, GFP_KERNEL); 245 + dev->interrupt = usb_alloc_urb(0, GFP_KERNEL); 246 246 if (!dev->interrupt) { 247 - kfree (buf); 247 + kfree(buf); 248 248 return -ENOMEM; 249 249 } else { 250 250 usb_fill_int_urb(dev->interrupt, dev->udev, pipe, 251 - buf, maxp, intr_complete, dev, period); 251 + buf, maxp, intr_complete, dev, period); 252 252 dev->interrupt->transfer_flags |= URB_FREE_BUFFER; 253 253 dev_dbg(&intf->dev, 254 254 "status ep%din, %d bytes period %d\n", ··· 339 339 340 340 /* only update if unset to allow minidriver rx_fixup override */ 341 341 if (skb->protocol == 0) 342 - skb->protocol = eth_type_trans (skb, dev->net); 342 + skb->protocol = eth_type_trans(skb, dev->net); 343 343 344 344 flags = u64_stats_update_begin_irqsave(&stats64->syncp); 345 345 u64_stats_inc(&stats64->rx_packets); ··· 347 347 u64_stats_update_end_irqrestore(&stats64->syncp, flags); 348 348 349 349 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n", 350 - skb->len + sizeof (struct ethhdr), skb->protocol); 351 - memset (skb->cb, 0, sizeof (struct skb_data)); 350 + skb->len + sizeof(struct ethhdr), skb->protocol); 351 + memset(skb->cb, 0, sizeof(struct skb_data)); 352 352 353 353 if (skb_defer_rx_timestamp(skb)) 354 354 return; ··· 511 511 skb = __netdev_alloc_skb_ip_align(dev->net, size, flags); 512 512 if (!skb) { 513 513 netif_dbg(dev, rx_err, dev->net, "no rx skb\n"); 514 - usbnet_defer_kevent (dev, EVENT_RX_MEMORY); 515 - usb_free_urb (urb); 514 + usbnet_defer_kevent(dev, EVENT_RX_MEMORY); 515 + usb_free_urb(urb); 516 516 return -ENOMEM; 517 517 } 518 518 ··· 521 521 entry->dev = dev; 522 522 entry->length = 0; 523 523 524 - usb_fill_bulk_urb (urb, dev->udev, dev->in, 525 - skb->data, size, rx_complete, skb); 524 + usb_fill_bulk_urb(urb, dev->udev, dev->in, 525 + skb->data, size, rx_complete, skb); 526 526 527 - spin_lock_irqsave (&dev->rxq.lock, lockflags); 527 + spin_lock_irqsave(&dev->rxq.lock, lockflags); 528 528 529 - if (netif_running (dev->net) && 530 - netif_device_present (dev->net) && 529 + if (netif_running(dev->net) && 530 + netif_device_present(dev->net) && 531 531 test_bit(EVENT_DEV_OPEN, &dev->flags) && 532 - !test_bit (EVENT_RX_HALT, &dev->flags) && 533 - !test_bit (EVENT_DEV_ASLEEP, &dev->flags) && 532 + !test_bit(EVENT_RX_HALT, &dev->flags) && 533 + !test_bit(EVENT_DEV_ASLEEP, &dev->flags) && 534 534 !usbnet_going_away(dev)) { 535 - switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) { 535 + switch (retval = usb_submit_urb(urb, GFP_ATOMIC)) { 536 536 case -EPIPE: 537 - usbnet_defer_kevent (dev, EVENT_RX_HALT); 537 + usbnet_defer_kevent(dev, EVENT_RX_HALT); 538 538 break; 539 539 case -ENOMEM: 540 - usbnet_defer_kevent (dev, EVENT_RX_MEMORY); 540 + usbnet_defer_kevent(dev, EVENT_RX_MEMORY); 541 541 break; 542 542 case -ENODEV: 543 543 netif_dbg(dev, ifdown, dev->net, "device gone\n"); 544 - netif_device_detach (dev->net); 544 + netif_device_detach(dev->net); 545 545 break; 546 546 case -EHOSTUNREACH: 547 547 retval = -ENOLINK; ··· 558 558 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n"); 559 559 retval = -ENOLINK; 560 560 } 561 - spin_unlock_irqrestore (&dev->rxq.lock, lockflags); 561 + spin_unlock_irqrestore(&dev->rxq.lock, lockflags); 562 562 if (retval) { 563 - dev_kfree_skb_any (skb); 564 - usb_free_urb (urb); 563 + dev_kfree_skb_any(skb); 564 + usb_free_urb(urb); 565 565 } 566 566 return retval; 567 567 } ··· 572 572 static inline int rx_process(struct usbnet *dev, struct sk_buff *skb) 573 573 { 574 574 if (dev->driver_info->rx_fixup && 575 - !dev->driver_info->rx_fixup (dev, skb)) { 575 + !dev->driver_info->rx_fixup(dev, skb)) { 576 576 /* With RX_ASSEMBLE, rx_fixup() must update counters */ 577 577 if (!(dev->driver_info->flags & FLAG_RX_ASSEMBLE)) 578 578 dev->net->stats.rx_errors++; ··· 605 605 int urb_status = urb->status; 606 606 enum skb_state state; 607 607 608 - skb_put (skb, urb->actual_length); 608 + skb_put(skb, urb->actual_length); 609 609 state = rx_done; 610 610 entry->urb = NULL; 611 611 ··· 621 621 */ 622 622 case -EPIPE: 623 623 dev->net->stats.rx_errors++; 624 - usbnet_defer_kevent (dev, EVENT_RX_HALT); 624 + usbnet_defer_kevent(dev, EVENT_RX_HALT); 625 625 fallthrough; 626 626 627 627 /* software-driven interface shutdown */ ··· 639 639 case -ETIME: 640 640 case -EILSEQ: 641 641 dev->net->stats.rx_errors++; 642 - if (!timer_pending (&dev->delay)) { 643 - mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES); 642 + if (!timer_pending(&dev->delay)) { 643 + mod_timer(&dev->delay, jiffies + THROTTLE_JIFFIES); 644 644 netif_dbg(dev, link, dev->net, 645 645 "rx throttle %d\n", urb_status); 646 646 } ··· 676 676 state = defer_bh(dev, skb, &dev->rxq, state); 677 677 678 678 if (urb) { 679 - if (netif_running (dev->net) && 680 - !test_bit (EVENT_RX_HALT, &dev->flags) && 679 + if (netif_running(dev->net) && 680 + !test_bit(EVENT_RX_HALT, &dev->flags) && 681 681 state != unlink_start) { 682 - rx_submit (dev, urb, GFP_ATOMIC); 682 + rx_submit(dev, urb, GFP_ATOMIC); 683 683 usb_mark_last_busy(dev->udev); 684 684 return; 685 685 } 686 - usb_free_urb (urb); 686 + usb_free_urb(urb); 687 687 } 688 688 netif_dbg(dev, rx_err, dev->net, "no read resubmitted\n"); 689 689 } ··· 761 761 spin_unlock_irqrestore(&q->lock, flags); 762 762 // during some PM-driven resume scenarios, 763 763 // these (async) unlinks complete immediately 764 - retval = usb_unlink_urb (urb); 764 + retval = usb_unlink_urb(urb); 765 765 if (retval != -EINPROGRESS && retval != 0) 766 766 netdev_dbg(dev->net, "unlink urb err, %d\n", retval); 767 767 else ··· 769 769 usb_put_urb(urb); 770 770 spin_lock_irqsave(&q->lock, flags); 771 771 } 772 - spin_unlock_irqrestore (&q->lock, flags); 772 + spin_unlock_irqrestore(&q->lock, flags); 773 773 return count; 774 774 } 775 775 ··· 830 830 int retval, pm, mpn; 831 831 832 832 clear_bit(EVENT_DEV_OPEN, &dev->flags); 833 - netif_stop_queue (net); 833 + netif_stop_queue(net); 834 834 netdev_reset_queue(net); 835 835 836 836 netif_info(dev, ifdown, dev->net, ··· 910 910 } 911 911 912 912 // put into "known safe" state 913 - if (info->reset && (retval = info->reset (dev)) < 0) { 914 - netif_info(dev, ifup, dev->net, 915 - "open reset fail (%d) usbnet usb-%s-%s, %s\n", 916 - retval, 917 - dev->udev->bus->bus_name, 918 - dev->udev->devpath, 919 - info->description); 920 - goto done; 913 + if (info->reset) { 914 + retval = info->reset(dev); 915 + if (retval < 0) { 916 + netif_info(dev, ifup, dev->net, 917 + "open reset fail (%d) usbnet usb-%s-%s, %s\n", 918 + retval, 919 + dev->udev->bus->bus_name, 920 + dev->udev->devpath, 921 + info->description); 922 + goto done; 923 + } 921 924 } 922 925 923 926 /* hard_mtu or rx_urb_size may change in reset() */ 924 927 usbnet_update_max_qlen(dev); 925 928 926 929 // insist peer be connected 927 - if (info->check_connect && (retval = info->check_connect (dev)) < 0) { 928 - netif_err(dev, ifup, dev->net, "can't open; %d\n", retval); 929 - goto done; 930 + if (info->check_connect) { 931 + retval = info->check_connect(dev); 932 + if (retval < 0) { 933 + netif_err(dev, ifup, dev->net, "can't open; %d\n", retval); 934 + goto done; 935 + } 930 936 } 931 937 932 938 /* start any status interrupt transfer */ ··· 1062 1056 1063 1057 /* If a check_connect is defined, return its result */ 1064 1058 if (dev->driver_info->check_connect) 1065 - return dev->driver_info->check_connect (dev) == 0; 1059 + return dev->driver_info->check_connect(dev) == 0; 1066 1060 1067 1061 /* if the device has mii operations, use those */ 1068 1062 if (dev->mii.mdio_read) ··· 1091 1085 strscpy(info->driver, dev->driver_name, sizeof(info->driver)); 1092 1086 strscpy(info->fw_version, dev->driver_info->description, 1093 1087 sizeof(info->fw_version)); 1094 - usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info); 1088 + usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info)); 1095 1089 } 1096 1090 EXPORT_SYMBOL_GPL(usbnet_get_drvinfo); 1097 1091 ··· 1181 1175 int status; 1182 1176 1183 1177 /* usb_clear_halt() needs a thread context */ 1184 - if (test_bit (EVENT_TX_HALT, &dev->flags)) { 1185 - unlink_urbs (dev, &dev->txq); 1178 + if (test_bit(EVENT_TX_HALT, &dev->flags)) { 1179 + unlink_urbs(dev, &dev->txq); 1186 1180 status = usb_autopm_get_interface(dev->intf); 1187 1181 if (status < 0) 1188 1182 goto fail_pipe; 1189 - status = usb_clear_halt (dev->udev, dev->out); 1183 + status = usb_clear_halt(dev->udev, dev->out); 1190 1184 usb_autopm_put_interface(dev->intf); 1191 1185 if (status < 0 && 1192 1186 status != -EPIPE && 1193 1187 status != -ESHUTDOWN) { 1194 - if (netif_msg_tx_err (dev)) 1188 + if (netif_msg_tx_err(dev)) 1195 1189 fail_pipe: 1196 1190 netdev_err(dev->net, "can't clear tx halt, status %d\n", 1197 1191 status); 1198 1192 } else { 1199 - clear_bit (EVENT_TX_HALT, &dev->flags); 1193 + clear_bit(EVENT_TX_HALT, &dev->flags); 1200 1194 if (status != -ESHUTDOWN) 1201 - netif_wake_queue (dev->net); 1195 + netif_wake_queue(dev->net); 1202 1196 } 1203 1197 } 1204 - if (test_bit (EVENT_RX_HALT, &dev->flags)) { 1205 - unlink_urbs (dev, &dev->rxq); 1198 + if (test_bit(EVENT_RX_HALT, &dev->flags)) { 1199 + unlink_urbs(dev, &dev->rxq); 1206 1200 status = usb_autopm_get_interface(dev->intf); 1207 1201 if (status < 0) 1208 1202 goto fail_halt; 1209 - status = usb_clear_halt (dev->udev, dev->in); 1203 + status = usb_clear_halt(dev->udev, dev->in); 1210 1204 usb_autopm_put_interface(dev->intf); 1211 1205 if (status < 0 && 1212 1206 status != -EPIPE && 1213 1207 status != -ESHUTDOWN) { 1214 - if (netif_msg_rx_err (dev)) 1208 + if (netif_msg_rx_err(dev)) 1215 1209 fail_halt: 1216 1210 netdev_err(dev->net, "can't clear rx halt, status %d\n", 1217 1211 status); 1218 1212 } else { 1219 - clear_bit (EVENT_RX_HALT, &dev->flags); 1213 + clear_bit(EVENT_RX_HALT, &dev->flags); 1220 1214 if (!usbnet_going_away(dev)) 1221 1215 queue_work(system_bh_wq, &dev->bh_work); 1222 1216 } 1223 1217 } 1224 1218 1225 1219 /* work could resubmit itself forever if memory is tight */ 1226 - if (test_bit (EVENT_RX_MEMORY, &dev->flags)) { 1220 + if (test_bit(EVENT_RX_MEMORY, &dev->flags)) { 1227 1221 struct urb *urb = NULL; 1228 1222 int resched = 1; 1229 1223 1230 - if (netif_running (dev->net)) 1231 - urb = usb_alloc_urb (0, GFP_KERNEL); 1224 + if (netif_running(dev->net)) 1225 + urb = usb_alloc_urb(0, GFP_KERNEL); 1232 1226 else 1233 - clear_bit (EVENT_RX_MEMORY, &dev->flags); 1227 + clear_bit(EVENT_RX_MEMORY, &dev->flags); 1234 1228 if (urb != NULL) { 1235 - clear_bit (EVENT_RX_MEMORY, &dev->flags); 1229 + clear_bit(EVENT_RX_MEMORY, &dev->flags); 1236 1230 status = usb_autopm_get_interface(dev->intf); 1237 1231 if (status < 0) { 1238 1232 usb_free_urb(urb); 1239 1233 goto fail_lowmem; 1240 1234 } 1241 - if (rx_submit (dev, urb, GFP_KERNEL) == -ENOLINK) 1235 + if (rx_submit(dev, urb, GFP_KERNEL) == -ENOLINK) 1242 1236 resched = 0; 1243 1237 usb_autopm_put_interface(dev->intf); 1244 1238 fail_lowmem: ··· 1252 1246 const struct driver_info *info = dev->driver_info; 1253 1247 int retval = 0; 1254 1248 1255 - clear_bit (EVENT_LINK_RESET, &dev->flags); 1249 + clear_bit(EVENT_LINK_RESET, &dev->flags); 1256 1250 status = usb_autopm_get_interface(dev->intf); 1257 1251 if (status < 0) 1258 1252 goto skip_reset; ··· 1272 1266 __handle_link_change(dev); 1273 1267 } 1274 1268 1275 - if (test_bit (EVENT_LINK_CHANGE, &dev->flags)) 1269 + if (test_bit(EVENT_LINK_CHANGE, &dev->flags)) 1276 1270 __handle_link_change(dev); 1277 1271 1278 - if (test_bit (EVENT_SET_RX_MODE, &dev->flags)) 1272 + if (test_bit(EVENT_SET_RX_MODE, &dev->flags)) 1279 1273 __handle_set_rx_mode(dev); 1280 1274 1281 1275 ··· 1304 1298 1305 1299 switch (urb->status) { 1306 1300 case -EPIPE: 1307 - usbnet_defer_kevent (dev, EVENT_TX_HALT); 1301 + usbnet_defer_kevent(dev, EVENT_TX_HALT); 1308 1302 break; 1309 1303 1310 1304 /* software-driven interface shutdown */ ··· 1319 1313 case -ETIME: 1320 1314 case -EILSEQ: 1321 1315 usb_mark_last_busy(dev->udev); 1322 - if (!timer_pending (&dev->delay)) { 1323 - mod_timer (&dev->delay, 1324 - jiffies + THROTTLE_JIFFIES); 1316 + if (!timer_pending(&dev->delay)) { 1317 + mod_timer(&dev->delay, 1318 + jiffies + THROTTLE_JIFFIES); 1325 1319 netif_dbg(dev, link, dev->net, 1326 1320 "tx throttle %d\n", urb->status); 1327 1321 } 1328 - netif_stop_queue (dev->net); 1322 + netif_stop_queue(dev->net); 1329 1323 break; 1330 1324 default: 1331 1325 netif_dbg(dev, tx_err, dev->net, ··· 1344 1338 { 1345 1339 struct usbnet *dev = netdev_priv(net); 1346 1340 1347 - unlink_urbs (dev, &dev->txq); 1341 + unlink_urbs(dev, &dev->txq); 1348 1342 queue_work(system_bh_wq, &dev->bh_work); 1349 1343 /* this needs to be handled individually because the generic layer 1350 1344 * doesn't know what is sufficient and could not restore private ··· 1406 1400 // some devices want funky USB-level framing, for 1407 1401 // win32 driver (usually) and/or hardware quirks 1408 1402 if (info->tx_fixup) { 1409 - skb = info->tx_fixup (dev, skb, GFP_ATOMIC); 1403 + skb = info->tx_fixup(dev, skb, GFP_ATOMIC); 1410 1404 if (!skb) { 1411 1405 /* packet collected; minidriver waiting for more */ 1412 1406 if (info->flags & FLAG_MULTI_PACKET) ··· 1416 1410 } 1417 1411 } 1418 1412 1419 - if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) { 1413 + urb = usb_alloc_urb(0, GFP_ATOMIC); 1414 + if (!urb) { 1420 1415 netif_dbg(dev, tx_err, dev->net, "no urb\n"); 1421 1416 goto drop; 1422 1417 } ··· 1426 1419 entry->urb = urb; 1427 1420 entry->dev = dev; 1428 1421 1429 - usb_fill_bulk_urb (urb, dev->udev, dev->out, 1430 - skb->data, skb->len, tx_complete, skb); 1422 + usb_fill_bulk_urb(urb, dev->udev, dev->out, 1423 + skb->data, skb->len, tx_complete, skb); 1431 1424 if (dev->can_dma_sg) { 1432 1425 if (build_dma_sg(skb, urb) < 0) 1433 1426 goto drop; ··· 1497 1490 1498 1491 switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) { 1499 1492 case -EPIPE: 1500 - netif_stop_queue (net); 1501 - usbnet_defer_kevent (dev, EVENT_TX_HALT); 1493 + netif_stop_queue(net); 1494 + usbnet_defer_kevent(dev, EVENT_TX_HALT); 1502 1495 usb_autopm_put_interface_async(dev->intf); 1503 1496 break; 1504 1497 default: ··· 1513 1506 if (dev->txq.qlen >= TX_QLEN (dev)) 1514 1507 netif_stop_queue (net); 1515 1508 } 1516 - spin_unlock_irqrestore (&dev->txq.lock, flags); 1509 + spin_unlock_irqrestore(&dev->txq.lock, flags); 1517 1510 1518 1511 if (retval) { 1519 1512 netif_dbg(dev, tx_err, dev->net, "drop, code %d\n", retval); ··· 1521 1514 dev->net->stats.tx_dropped++; 1522 1515 not_drop: 1523 1516 if (skb) 1524 - dev_kfree_skb_any (skb); 1517 + dev_kfree_skb_any(skb); 1525 1518 if (urb) { 1526 1519 kfree(urb->sg); 1527 1520 usb_free_urb(urb); ··· 1632 1625 queue_work(system_bh_wq, &dev->bh_work); 1633 1626 } 1634 1627 if (dev->txq.qlen < TX_QLEN (dev)) 1635 - netif_wake_queue (dev->net); 1628 + netif_wake_queue(dev->net); 1636 1629 } 1637 1630 } 1638 1631 ··· 1665 1658 return; 1666 1659 usbnet_mark_going_away(dev); 1667 1660 1668 - xdev = interface_to_usbdev (intf); 1661 + xdev = interface_to_usbdev(intf); 1669 1662 1670 1663 netif_info(dev, probe, dev->net, "unregister '%s' usb-%s-%s, %s\n", 1671 1664 intf->dev.driver->name, ··· 1673 1666 dev->driver_info->description); 1674 1667 1675 1668 net = dev->net; 1676 - unregister_netdev (net); 1669 + unregister_netdev(net); 1677 1670 1678 1671 cancel_work_sync(&dev->kevent); 1679 1672 ··· 1744 1737 dev_dbg (&udev->dev, "blacklisted by %s\n", name); 1745 1738 return -ENODEV; 1746 1739 } 1747 - xdev = interface_to_usbdev (udev); 1740 + xdev = interface_to_usbdev(udev); 1748 1741 interface = udev->cur_altsetting; 1749 1742 1750 1743 status = -ENOMEM; ··· 1774 1767 skb_queue_head_init(&dev->rxq_pause); 1775 1768 spin_lock_init(&dev->bql_spinlock); 1776 1769 INIT_WORK(&dev->bh_work, usbnet_bh_work); 1777 - INIT_WORK (&dev->kevent, usbnet_deferred_kevent); 1770 + INIT_WORK(&dev->kevent, usbnet_deferred_kevent); 1778 1771 init_usb_anchor(&dev->deferred); 1779 1772 timer_setup(&dev->delay, usbnet_bh, 0); 1780 - mutex_init (&dev->phy_mutex); 1773 + mutex_init(&dev->phy_mutex); 1781 1774 mutex_init(&dev->interrupt_mutex); 1782 1775 dev->interrupt_count = 0; 1783 1776 ··· 1799 1792 // allow device-specific bind/init procedures 1800 1793 // NOTE net->name still not usable ... 1801 1794 if (info->bind) { 1802 - status = info->bind (dev, udev); 1795 + status = info->bind(dev, udev); 1803 1796 if (status < 0) 1804 1797 goto out1; 1805 1798 ··· 1824 1817 if (net->mtu > (dev->hard_mtu - net->hard_header_len)) 1825 1818 net->mtu = dev->hard_mtu - net->hard_header_len; 1826 1819 } else if (!info->in || !info->out) 1827 - status = usbnet_get_endpoints (dev, udev); 1820 + status = usbnet_get_endpoints(dev, udev); 1828 1821 else { 1829 1822 u8 ep_addrs[3] = { 1830 1823 info->in + USB_DIR_IN, info->out + USB_DIR_OUT, 0 1831 1824 }; 1832 1825 1833 - dev->in = usb_rcvbulkpipe (xdev, info->in); 1834 - dev->out = usb_sndbulkpipe (xdev, info->out); 1826 + dev->in = usb_rcvbulkpipe(xdev, info->in); 1827 + dev->out = usb_sndbulkpipe(xdev, info->out); 1835 1828 if (!(info->flags & FLAG_NO_SETINT)) 1836 - status = usb_set_interface (xdev, 1837 - interface->desc.bInterfaceNumber, 1838 - interface->desc.bAlternateSetting); 1829 + status = usb_set_interface(xdev, 1830 + interface->desc.bInterfaceNumber, 1831 + interface->desc.bAlternateSetting); 1839 1832 else 1840 1833 status = 0; 1841 1834 ··· 1843 1836 status = -EINVAL; 1844 1837 } 1845 1838 if (status >= 0 && dev->status) 1846 - status = init_status (dev, udev); 1839 + status = init_status(dev, udev); 1847 1840 if (status < 0) 1848 1841 goto out3; 1849 1842 ··· 1877 1870 } 1878 1871 } 1879 1872 1880 - status = register_netdev (net); 1873 + status = register_netdev(net); 1881 1874 if (status) 1882 1875 goto out5; 1883 1876 netif_info(dev, probe, dev->net, ··· 1888 1881 net->dev_addr); 1889 1882 1890 1883 // ok, it's ready to go. 1891 - usb_set_intfdata (udev, dev); 1884 + usb_set_intfdata(udev, dev); 1892 1885 1893 - netif_device_attach (net); 1886 + netif_device_attach(net); 1894 1887 1895 1888 if (dev->driver_info->flags & FLAG_LINK_INTR) 1896 1889 usbnet_link_change(dev, 0, 0); ··· 1903 1896 usb_free_urb(dev->interrupt); 1904 1897 out3: 1905 1898 if (info->unbind) 1906 - info->unbind (dev, udev); 1899 + info->unbind(dev, udev); 1907 1900 out1: 1908 1901 /* subdrivers must undo all they did in bind() if they 1909 1902 * fail it, but we may fail later and a deferred kevent ··· 1945 1938 * accelerate emptying of the rx and queues, to avoid 1946 1939 * having everything error out. 1947 1940 */ 1948 - netif_device_detach (dev->net); 1941 + netif_device_detach(dev->net); 1949 1942 usbnet_terminate_urbs(dev); 1950 1943 __usbnet_status_stop_force(dev); 1951 1944 ··· 1953 1946 * reattach so runtime management can use and 1954 1947 * wake the device 1955 1948 */ 1956 - netif_device_attach (dev->net); 1949 + netif_device_attach(dev->net); 1957 1950 } 1958 1951 return 0; 1959 1952 }

Configure Feed

Configure Feed