1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 1999-2013 Petko Manolov (petkan@nucleusys.com) 4 * 5 * ChangeLog: 6 * .... Most of the time spent on reading sources & docs. 7 * v0.2.x First official release for the Linux kernel. 8 * v0.3.0 Beutified and structured, some bugs fixed. 9 * v0.3.x URBifying bulk requests and bugfixing. First relatively 10 * stable release. Still can touch device's registers only 11 * from top-halves. 12 * v0.4.0 Control messages remained unurbified are now URBs. 13 * Now we can touch the HW at any time. 14 * v0.4.9 Control urbs again use process context to wait. Argh... 15 * Some long standing bugs (enable_net_traffic) fixed. 16 * Also nasty trick about resubmiting control urb from 17 * interrupt context used. Please let me know how it 18 * behaves. Pegasus II support added since this version. 19 * TODO: suppressing HCD warnings spewage on disconnect. 20 * v0.4.13 Ethernet address is now set at probe(), not at open() 21 * time as this seems to break dhcpd. 22 * v0.5.0 branch to 2.5.x kernels 23 * v0.5.1 ethtool support added 24 * v0.5.5 rx socket buffers are in a pool and the their allocation 25 * is out of the interrupt routine. 26 * ... 27 * v0.9.3 simplified [get|set]_register(s), async update registers 28 * logic revisited, receive skb_pool removed. 29 */ 30 31 #include <linux/sched.h> 32 #include <linux/slab.h> 33 #include <linux/init.h> 34 #include <linux/delay.h> 35 #include <linux/netdevice.h> 36 #include <linux/etherdevice.h> 37 #include <linux/ethtool.h> 38 #include <linux/mii.h> 39 #include <linux/usb.h> 40 #include <linux/module.h> 41 #include <asm/byteorder.h> 42 #include <linux/uaccess.h> 43 #include "pegasus.h" 44 45 /* 46 * Version Information 47 */ 48 #define DRIVER_VERSION "v0.9.3 (2013/04/25)" 49 #define DRIVER_AUTHOR "Petko Manolov <petkan@nucleusys.com>" 50 #define DRIVER_DESC "Pegasus/Pegasus II USB Ethernet driver" 51 52 static const char driver_name[] = "pegasus"; 53 54 #undef PEGASUS_WRITE_EEPROM 55 #define BMSR_MEDIA (BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | \ 56 BMSR_100FULL | BMSR_ANEGCAPABLE) 57 #define CARRIER_CHECK_DELAY (2 * HZ) 58 59 static bool loopback; 60 static bool mii_mode; 61 static char *devid; 62 63 static struct usb_eth_dev usb_dev_id[] = { 64 #define PEGASUS_DEV(pn, vid, pid, flags) \ 65 {.name = pn, .vendor = vid, .device = pid, .private = flags}, 66 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \ 67 PEGASUS_DEV(pn, vid, pid, flags) 68 #include "pegasus.h" 69 #undef PEGASUS_DEV 70 #undef PEGASUS_DEV_CLASS 71 {NULL, 0, 0, 0}, 72 {NULL, 0, 0, 0} 73 }; 74 75 static struct usb_device_id pegasus_ids[] = { 76 #define PEGASUS_DEV(pn, vid, pid, flags) \ 77 {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid}, 78 /* 79 * The Belkin F8T012xx1 bluetooth adaptor has the same vendor and product 80 * IDs as the Belkin F5D5050, so we need to teach the pegasus driver to 81 * ignore adaptors belonging to the "Wireless" class 0xE0. For this one 82 * case anyway, seeing as the pegasus is for "Wired" adaptors. 83 */ 84 #define PEGASUS_DEV_CLASS(pn, vid, pid, dclass, flags) \ 85 {.match_flags = (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS), \ 86 .idVendor = vid, .idProduct = pid, .bDeviceClass = dclass}, 87 #include "pegasus.h" 88 #undef PEGASUS_DEV 89 #undef PEGASUS_DEV_CLASS 90 {}, 91 {} 92 }; 93 94 MODULE_AUTHOR(DRIVER_AUTHOR); 95 MODULE_DESCRIPTION(DRIVER_DESC); 96 MODULE_LICENSE("GPL"); 97 module_param(loopback, bool, 0); 98 module_param(mii_mode, bool, 0); 99 module_param(devid, charp, 0); 100 MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)"); 101 MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0"); 102 MODULE_PARM_DESC(devid, "The format is: 'DEV_name:VendorID:DeviceID:Flags'"); 103 104 /* use ethtool to change the level for any given device */ 105 static int msg_level = -1; 106 module_param(msg_level, int, 0); 107 MODULE_PARM_DESC(msg_level, "Override default message level"); 108 109 MODULE_DEVICE_TABLE(usb, pegasus_ids); 110 static const struct net_device_ops pegasus_netdev_ops; 111 112 /*****/ 113 114 static void async_ctrl_callback(struct urb *urb) 115 { 116 struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context; 117 int status = urb->status; 118 119 if (status < 0) 120 dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status); 121 kfree(req); 122 usb_free_urb(urb); 123 } 124 125 static int get_registers(pegasus_t *pegasus, __u16 indx, __u16 size, void *data) 126 { 127 return usb_control_msg_recv(pegasus->usb, 0, PEGASUS_REQ_GET_REGS, 128 PEGASUS_REQT_READ, 0, indx, data, size, 129 1000, GFP_NOIO); 130 } 131 132 static int set_registers(pegasus_t *pegasus, __u16 indx, __u16 size, 133 const void *data) 134 { 135 return usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REGS, 136 PEGASUS_REQT_WRITE, 0, indx, data, size, 137 1000, GFP_NOIO); 138 } 139 140 /* 141 * There is only one way to write to a single ADM8511 register and this is via 142 * specific control request. 'data' is ignored by the device, but it is here to 143 * not break the API. 144 */ 145 static int set_register(pegasus_t *pegasus, __u16 indx, __u8 data) 146 { 147 void *buf = &data; 148 149 return usb_control_msg_send(pegasus->usb, 0, PEGASUS_REQ_SET_REG, 150 PEGASUS_REQT_WRITE, data, indx, buf, 1, 151 1000, GFP_NOIO); 152 } 153 154 static int update_eth_regs_async(pegasus_t *pegasus) 155 { 156 int ret = -ENOMEM; 157 struct urb *async_urb; 158 struct usb_ctrlrequest *req; 159 160 req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC); 161 if (req == NULL) 162 return ret; 163 164 async_urb = usb_alloc_urb(0, GFP_ATOMIC); 165 if (async_urb == NULL) { 166 kfree(req); 167 return ret; 168 } 169 req->bRequestType = PEGASUS_REQT_WRITE; 170 req->bRequest = PEGASUS_REQ_SET_REGS; 171 req->wValue = cpu_to_le16(0); 172 req->wIndex = cpu_to_le16(EthCtrl0); 173 req->wLength = cpu_to_le16(3); 174 175 usb_fill_control_urb(async_urb, pegasus->usb, 176 usb_sndctrlpipe(pegasus->usb, 0), (void *)req, 177 pegasus->eth_regs, 3, async_ctrl_callback, req); 178 179 ret = usb_submit_urb(async_urb, GFP_ATOMIC); 180 if (ret) { 181 if (ret == -ENODEV) 182 netif_device_detach(pegasus->net); 183 netif_err(pegasus, drv, pegasus->net, 184 "%s returned %d\n", __func__, ret); 185 } 186 return ret; 187 } 188 189 static int __mii_op(pegasus_t *p, __u8 phy, __u8 indx, __u16 *regd, __u8 cmd) 190 { 191 int i; 192 __u8 data[4] = { phy, 0, 0, indx }; 193 __le16 regdi; 194 int ret = -ETIMEDOUT; 195 196 if (cmd & PHY_WRITE) { 197 __le16 *t = (__le16 *) & data[1]; 198 *t = cpu_to_le16(*regd); 199 } 200 set_register(p, PhyCtrl, 0); 201 set_registers(p, PhyAddr, sizeof(data), data); 202 set_register(p, PhyCtrl, (indx | cmd)); 203 for (i = 0; i < REG_TIMEOUT; i++) { 204 ret = get_registers(p, PhyCtrl, 1, data); 205 if (ret < 0) 206 goto fail; 207 if (data[0] & PHY_DONE) 208 break; 209 } 210 if (i >= REG_TIMEOUT) 211 goto fail; 212 if (cmd & PHY_READ) { 213 ret = get_registers(p, PhyData, 2, ®di); 214 *regd = le16_to_cpu(regdi); 215 return ret; 216 } 217 return 0; 218 fail: 219 netif_dbg(p, drv, p->net, "%s failed\n", __func__); 220 return ret; 221 } 222 223 /* Returns non-negative int on success, error on failure */ 224 static int read_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd) 225 { 226 return __mii_op(pegasus, phy, indx, regd, PHY_READ); 227 } 228 229 /* Returns zero on success, error on failure */ 230 static int write_mii_word(pegasus_t *pegasus, __u8 phy, __u8 indx, __u16 *regd) 231 { 232 return __mii_op(pegasus, phy, indx, regd, PHY_WRITE); 233 } 234 235 static int mdio_read(struct net_device *dev, int phy_id, int loc) 236 { 237 pegasus_t *pegasus = netdev_priv(dev); 238 u16 res; 239 240 read_mii_word(pegasus, phy_id, loc, &res); 241 return (int)res; 242 } 243 244 static void mdio_write(struct net_device *dev, int phy_id, int loc, int val) 245 { 246 pegasus_t *pegasus = netdev_priv(dev); 247 u16 data = val; 248 249 write_mii_word(pegasus, phy_id, loc, &data); 250 } 251 252 static int read_eprom_word(pegasus_t *pegasus, __u8 index, __u16 *retdata) 253 { 254 int i; 255 __u8 tmp = 0; 256 __le16 retdatai; 257 int ret; 258 259 set_register(pegasus, EpromCtrl, 0); 260 set_register(pegasus, EpromOffset, index); 261 set_register(pegasus, EpromCtrl, EPROM_READ); 262 263 for (i = 0; i < REG_TIMEOUT; i++) { 264 ret = get_registers(pegasus, EpromCtrl, 1, &tmp); 265 if (tmp & EPROM_DONE) 266 break; 267 if (ret == -ESHUTDOWN) 268 goto fail; 269 } 270 if (i >= REG_TIMEOUT) 271 goto fail; 272 273 ret = get_registers(pegasus, EpromData, 2, &retdatai); 274 *retdata = le16_to_cpu(retdatai); 275 return ret; 276 277 fail: 278 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__); 279 return -ETIMEDOUT; 280 } 281 282 #ifdef PEGASUS_WRITE_EEPROM 283 static inline void enable_eprom_write(pegasus_t *pegasus) 284 { 285 __u8 tmp; 286 287 get_registers(pegasus, EthCtrl2, 1, &tmp); 288 set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE); 289 } 290 291 static inline void disable_eprom_write(pegasus_t *pegasus) 292 { 293 __u8 tmp; 294 295 get_registers(pegasus, EthCtrl2, 1, &tmp); 296 set_register(pegasus, EpromCtrl, 0); 297 set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE); 298 } 299 300 static int write_eprom_word(pegasus_t *pegasus, __u8 index, __u16 data) 301 { 302 int i; 303 __u8 tmp, d[4] = { 0x3f, 0, 0, EPROM_WRITE }; 304 int ret; 305 __le16 le_data = cpu_to_le16(data); 306 307 set_registers(pegasus, EpromOffset, 4, d); 308 enable_eprom_write(pegasus); 309 set_register(pegasus, EpromOffset, index); 310 set_registers(pegasus, EpromData, 2, &le_data); 311 set_register(pegasus, EpromCtrl, EPROM_WRITE); 312 313 for (i = 0; i < REG_TIMEOUT; i++) { 314 ret = get_registers(pegasus, EpromCtrl, 1, &tmp); 315 if (ret == -ESHUTDOWN) 316 goto fail; 317 if (tmp & EPROM_DONE) 318 break; 319 } 320 disable_eprom_write(pegasus); 321 if (i >= REG_TIMEOUT) 322 goto fail; 323 324 return ret; 325 326 fail: 327 netif_warn(pegasus, drv, pegasus->net, "%s failed\n", __func__); 328 return -ETIMEDOUT; 329 } 330 #endif /* PEGASUS_WRITE_EEPROM */ 331 332 static inline void get_node_id(pegasus_t *pegasus, __u8 *id) 333 { 334 int i; 335 __u16 w16; 336 337 for (i = 0; i < 3; i++) { 338 read_eprom_word(pegasus, i, &w16); 339 ((__le16 *) id)[i] = cpu_to_le16(w16); 340 } 341 } 342 343 static void set_ethernet_addr(pegasus_t *pegasus) 344 { 345 __u8 node_id[6]; 346 347 if (pegasus->features & PEGASUS_II) { 348 get_registers(pegasus, 0x10, sizeof(node_id), node_id); 349 } else { 350 get_node_id(pegasus, node_id); 351 set_registers(pegasus, EthID, sizeof(node_id), node_id); 352 } 353 memcpy(pegasus->net->dev_addr, node_id, sizeof(node_id)); 354 } 355 356 static inline int reset_mac(pegasus_t *pegasus) 357 { 358 __u8 data = 0x8; 359 int i; 360 361 set_register(pegasus, EthCtrl1, data); 362 for (i = 0; i < REG_TIMEOUT; i++) { 363 get_registers(pegasus, EthCtrl1, 1, &data); 364 if (~data & 0x08) { 365 if (loopback) 366 break; 367 if (mii_mode && (pegasus->features & HAS_HOME_PNA)) 368 set_register(pegasus, Gpio1, 0x34); 369 else 370 set_register(pegasus, Gpio1, 0x26); 371 set_register(pegasus, Gpio0, pegasus->features); 372 set_register(pegasus, Gpio0, DEFAULT_GPIO_SET); 373 break; 374 } 375 } 376 if (i == REG_TIMEOUT) 377 return -ETIMEDOUT; 378 379 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS || 380 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) { 381 set_register(pegasus, Gpio0, 0x24); 382 set_register(pegasus, Gpio0, 0x26); 383 } 384 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) { 385 __u16 auxmode; 386 read_mii_word(pegasus, 3, 0x1b, &auxmode); 387 auxmode |= 4; 388 write_mii_word(pegasus, 3, 0x1b, &auxmode); 389 } 390 391 return 0; 392 } 393 394 static int enable_net_traffic(struct net_device *dev, struct usb_device *usb) 395 { 396 __u16 linkpart; 397 __u8 data[4]; 398 pegasus_t *pegasus = netdev_priv(dev); 399 int ret; 400 401 read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart); 402 data[0] = 0xc8; /* TX & RX enable, append status, no CRC */ 403 data[1] = 0; 404 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL)) 405 data[1] |= 0x20; /* set full duplex */ 406 if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF)) 407 data[1] |= 0x10; /* set 100 Mbps */ 408 if (mii_mode) 409 data[1] = 0; 410 data[2] = loopback ? 0x09 : 0x01; 411 412 memcpy(pegasus->eth_regs, data, sizeof(data)); 413 ret = set_registers(pegasus, EthCtrl0, 3, data); 414 415 if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS || 416 usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS2 || 417 usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) { 418 u16 auxmode; 419 read_mii_word(pegasus, 0, 0x1b, &auxmode); 420 auxmode |= 4; 421 write_mii_word(pegasus, 0, 0x1b, &auxmode); 422 } 423 424 return ret; 425 } 426 427 static void read_bulk_callback(struct urb *urb) 428 { 429 pegasus_t *pegasus = urb->context; 430 struct net_device *net; 431 int rx_status, count = urb->actual_length; 432 int status = urb->status; 433 u8 *buf = urb->transfer_buffer; 434 __u16 pkt_len; 435 436 if (!pegasus) 437 return; 438 439 net = pegasus->net; 440 if (!netif_device_present(net) || !netif_running(net)) 441 return; 442 443 switch (status) { 444 case 0: 445 break; 446 case -ETIME: 447 netif_dbg(pegasus, rx_err, net, "reset MAC\n"); 448 pegasus->flags &= ~PEGASUS_RX_BUSY; 449 break; 450 case -EPIPE: /* stall, or disconnect from TT */ 451 /* FIXME schedule work to clear the halt */ 452 netif_warn(pegasus, rx_err, net, "no rx stall recovery\n"); 453 return; 454 case -ENOENT: 455 case -ECONNRESET: 456 case -ESHUTDOWN: 457 netif_dbg(pegasus, ifdown, net, "rx unlink, %d\n", status); 458 return; 459 default: 460 netif_dbg(pegasus, rx_err, net, "RX status %d\n", status); 461 goto goon; 462 } 463 464 if (count < 4) 465 goto goon; 466 467 rx_status = buf[count - 2]; 468 if (rx_status & 0x1e) { 469 netif_dbg(pegasus, rx_err, net, 470 "RX packet error %x\n", rx_status); 471 net->stats.rx_errors++; 472 if (rx_status & 0x06) /* long or runt */ 473 net->stats.rx_length_errors++; 474 if (rx_status & 0x08) 475 net->stats.rx_crc_errors++; 476 if (rx_status & 0x10) /* extra bits */ 477 net->stats.rx_frame_errors++; 478 goto goon; 479 } 480 if (pegasus->chip == 0x8513) { 481 pkt_len = le32_to_cpu(*(__le32 *)urb->transfer_buffer); 482 pkt_len &= 0x0fff; 483 pegasus->rx_skb->data += 2; 484 } else { 485 pkt_len = buf[count - 3] << 8; 486 pkt_len += buf[count - 4]; 487 pkt_len &= 0xfff; 488 pkt_len -= 4; 489 } 490 491 /* 492 * If the packet is unreasonably long, quietly drop it rather than 493 * kernel panicing by calling skb_put. 494 */ 495 if (pkt_len > PEGASUS_MTU) 496 goto goon; 497 498 /* 499 * at this point we are sure pegasus->rx_skb != NULL 500 * so we go ahead and pass up the packet. 501 */ 502 skb_put(pegasus->rx_skb, pkt_len); 503 pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net); 504 netif_rx(pegasus->rx_skb); 505 net->stats.rx_packets++; 506 net->stats.rx_bytes += pkt_len; 507 508 if (pegasus->flags & PEGASUS_UNPLUG) 509 return; 510 511 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, PEGASUS_MTU, 512 GFP_ATOMIC); 513 514 if (pegasus->rx_skb == NULL) 515 goto tl_sched; 516 goon: 517 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb, 518 usb_rcvbulkpipe(pegasus->usb, 1), 519 pegasus->rx_skb->data, PEGASUS_MTU, 520 read_bulk_callback, pegasus); 521 rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC); 522 if (rx_status == -ENODEV) 523 netif_device_detach(pegasus->net); 524 else if (rx_status) { 525 pegasus->flags |= PEGASUS_RX_URB_FAIL; 526 goto tl_sched; 527 } else { 528 pegasus->flags &= ~PEGASUS_RX_URB_FAIL; 529 } 530 531 return; 532 533 tl_sched: 534 tasklet_schedule(&pegasus->rx_tl); 535 } 536 537 static void rx_fixup(unsigned long data) 538 { 539 pegasus_t *pegasus; 540 int status; 541 542 pegasus = (pegasus_t *) data; 543 if (pegasus->flags & PEGASUS_UNPLUG) 544 return; 545 546 if (pegasus->flags & PEGASUS_RX_URB_FAIL) 547 if (pegasus->rx_skb) 548 goto try_again; 549 if (pegasus->rx_skb == NULL) 550 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, 551 PEGASUS_MTU, 552 GFP_ATOMIC); 553 if (pegasus->rx_skb == NULL) { 554 netif_warn(pegasus, rx_err, pegasus->net, "low on memory\n"); 555 tasklet_schedule(&pegasus->rx_tl); 556 return; 557 } 558 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb, 559 usb_rcvbulkpipe(pegasus->usb, 1), 560 pegasus->rx_skb->data, PEGASUS_MTU, 561 read_bulk_callback, pegasus); 562 try_again: 563 status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC); 564 if (status == -ENODEV) 565 netif_device_detach(pegasus->net); 566 else if (status) { 567 pegasus->flags |= PEGASUS_RX_URB_FAIL; 568 tasklet_schedule(&pegasus->rx_tl); 569 } else { 570 pegasus->flags &= ~PEGASUS_RX_URB_FAIL; 571 } 572 } 573 574 static void write_bulk_callback(struct urb *urb) 575 { 576 pegasus_t *pegasus = urb->context; 577 struct net_device *net; 578 int status = urb->status; 579 580 if (!pegasus) 581 return; 582 583 net = pegasus->net; 584 585 if (!netif_device_present(net) || !netif_running(net)) 586 return; 587 588 switch (status) { 589 case -EPIPE: 590 /* FIXME schedule_work() to clear the tx halt */ 591 netif_stop_queue(net); 592 netif_warn(pegasus, tx_err, net, "no tx stall recovery\n"); 593 return; 594 case -ENOENT: 595 case -ECONNRESET: 596 case -ESHUTDOWN: 597 netif_dbg(pegasus, ifdown, net, "tx unlink, %d\n", status); 598 return; 599 default: 600 netif_info(pegasus, tx_err, net, "TX status %d\n", status); 601 fallthrough; 602 case 0: 603 break; 604 } 605 606 netif_trans_update(net); /* prevent tx timeout */ 607 netif_wake_queue(net); 608 } 609 610 static void intr_callback(struct urb *urb) 611 { 612 pegasus_t *pegasus = urb->context; 613 struct net_device *net; 614 int res, status = urb->status; 615 616 if (!pegasus) 617 return; 618 net = pegasus->net; 619 620 switch (status) { 621 case 0: 622 break; 623 case -ECONNRESET: /* unlink */ 624 case -ENOENT: 625 case -ESHUTDOWN: 626 return; 627 default: 628 /* some Pegasus-I products report LOTS of data 629 * toggle errors... avoid log spamming 630 */ 631 netif_dbg(pegasus, timer, net, "intr status %d\n", status); 632 } 633 634 if (urb->actual_length >= 6) { 635 u8 *d = urb->transfer_buffer; 636 637 /* byte 0 == tx_status1, reg 2B */ 638 if (d[0] & (TX_UNDERRUN|EXCESSIVE_COL 639 |LATE_COL|JABBER_TIMEOUT)) { 640 net->stats.tx_errors++; 641 if (d[0] & TX_UNDERRUN) 642 net->stats.tx_fifo_errors++; 643 if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT)) 644 net->stats.tx_aborted_errors++; 645 if (d[0] & LATE_COL) 646 net->stats.tx_window_errors++; 647 } 648 649 /* d[5].LINK_STATUS lies on some adapters. 650 * d[0].NO_CARRIER kicks in only with failed TX. 651 * ... so monitoring with MII may be safest. 652 */ 653 654 /* bytes 3-4 == rx_lostpkt, reg 2E/2F */ 655 net->stats.rx_missed_errors += ((d[3] & 0x7f) << 8) | d[4]; 656 } 657 658 res = usb_submit_urb(urb, GFP_ATOMIC); 659 if (res == -ENODEV) 660 netif_device_detach(pegasus->net); 661 if (res) 662 netif_err(pegasus, timer, net, 663 "can't resubmit interrupt urb, %d\n", res); 664 } 665 666 static void pegasus_tx_timeout(struct net_device *net, unsigned int txqueue) 667 { 668 pegasus_t *pegasus = netdev_priv(net); 669 netif_warn(pegasus, timer, net, "tx timeout\n"); 670 usb_unlink_urb(pegasus->tx_urb); 671 net->stats.tx_errors++; 672 } 673 674 static netdev_tx_t pegasus_start_xmit(struct sk_buff *skb, 675 struct net_device *net) 676 { 677 pegasus_t *pegasus = netdev_priv(net); 678 int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3; 679 int res; 680 __u16 l16 = skb->len; 681 682 netif_stop_queue(net); 683 684 ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16); 685 skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len); 686 usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb, 687 usb_sndbulkpipe(pegasus->usb, 2), 688 pegasus->tx_buff, count, 689 write_bulk_callback, pegasus); 690 if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) { 691 netif_warn(pegasus, tx_err, net, "fail tx, %d\n", res); 692 switch (res) { 693 case -EPIPE: /* stall, or disconnect from TT */ 694 /* cleanup should already have been scheduled */ 695 break; 696 case -ENODEV: /* disconnect() upcoming */ 697 case -EPERM: 698 netif_device_detach(pegasus->net); 699 break; 700 default: 701 net->stats.tx_errors++; 702 netif_start_queue(net); 703 } 704 } else { 705 net->stats.tx_packets++; 706 net->stats.tx_bytes += skb->len; 707 } 708 dev_kfree_skb(skb); 709 710 return NETDEV_TX_OK; 711 } 712 713 static inline void disable_net_traffic(pegasus_t *pegasus) 714 { 715 __le16 tmp = cpu_to_le16(0); 716 717 set_registers(pegasus, EthCtrl0, sizeof(tmp), &tmp); 718 } 719 720 static inline void get_interrupt_interval(pegasus_t *pegasus) 721 { 722 u16 data; 723 u8 interval; 724 725 read_eprom_word(pegasus, 4, &data); 726 interval = data >> 8; 727 if (pegasus->usb->speed != USB_SPEED_HIGH) { 728 if (interval < 0x80) { 729 netif_info(pegasus, timer, pegasus->net, 730 "intr interval changed from %ums to %ums\n", 731 interval, 0x80); 732 interval = 0x80; 733 data = (data & 0x00FF) | ((u16)interval << 8); 734 #ifdef PEGASUS_WRITE_EEPROM 735 write_eprom_word(pegasus, 4, data); 736 #endif 737 } 738 } 739 pegasus->intr_interval = interval; 740 } 741 742 static void set_carrier(struct net_device *net) 743 { 744 pegasus_t *pegasus = netdev_priv(net); 745 u16 tmp; 746 747 if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp)) 748 return; 749 750 if (tmp & BMSR_LSTATUS) 751 netif_carrier_on(net); 752 else 753 netif_carrier_off(net); 754 } 755 756 static void free_all_urbs(pegasus_t *pegasus) 757 { 758 usb_free_urb(pegasus->intr_urb); 759 usb_free_urb(pegasus->tx_urb); 760 usb_free_urb(pegasus->rx_urb); 761 } 762 763 static void unlink_all_urbs(pegasus_t *pegasus) 764 { 765 usb_kill_urb(pegasus->intr_urb); 766 usb_kill_urb(pegasus->tx_urb); 767 usb_kill_urb(pegasus->rx_urb); 768 } 769 770 static int alloc_urbs(pegasus_t *pegasus) 771 { 772 int res = -ENOMEM; 773 774 pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 775 if (!pegasus->rx_urb) { 776 return res; 777 } 778 pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 779 if (!pegasus->tx_urb) { 780 usb_free_urb(pegasus->rx_urb); 781 return res; 782 } 783 pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL); 784 if (!pegasus->intr_urb) { 785 usb_free_urb(pegasus->tx_urb); 786 usb_free_urb(pegasus->rx_urb); 787 return res; 788 } 789 790 return 0; 791 } 792 793 static int pegasus_open(struct net_device *net) 794 { 795 pegasus_t *pegasus = netdev_priv(net); 796 int res=-ENOMEM; 797 798 if (pegasus->rx_skb == NULL) 799 pegasus->rx_skb = __netdev_alloc_skb_ip_align(pegasus->net, 800 PEGASUS_MTU, 801 GFP_KERNEL); 802 if (!pegasus->rx_skb) 803 goto exit; 804 805 res = set_registers(pegasus, EthID, 6, net->dev_addr); 806 807 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb, 808 usb_rcvbulkpipe(pegasus->usb, 1), 809 pegasus->rx_skb->data, PEGASUS_MTU, 810 read_bulk_callback, pegasus); 811 if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) { 812 if (res == -ENODEV) 813 netif_device_detach(pegasus->net); 814 netif_dbg(pegasus, ifup, net, "failed rx_urb, %d\n", res); 815 goto exit; 816 } 817 818 usb_fill_int_urb(pegasus->intr_urb, pegasus->usb, 819 usb_rcvintpipe(pegasus->usb, 3), 820 pegasus->intr_buff, sizeof(pegasus->intr_buff), 821 intr_callback, pegasus, pegasus->intr_interval); 822 if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) { 823 if (res == -ENODEV) 824 netif_device_detach(pegasus->net); 825 netif_dbg(pegasus, ifup, net, "failed intr_urb, %d\n", res); 826 usb_kill_urb(pegasus->rx_urb); 827 goto exit; 828 } 829 res = enable_net_traffic(net, pegasus->usb); 830 if (res < 0) { 831 netif_dbg(pegasus, ifup, net, 832 "can't enable_net_traffic() - %d\n", res); 833 res = -EIO; 834 usb_kill_urb(pegasus->rx_urb); 835 usb_kill_urb(pegasus->intr_urb); 836 goto exit; 837 } 838 set_carrier(net); 839 netif_start_queue(net); 840 netif_dbg(pegasus, ifup, net, "open\n"); 841 res = 0; 842 exit: 843 return res; 844 } 845 846 static int pegasus_close(struct net_device *net) 847 { 848 pegasus_t *pegasus = netdev_priv(net); 849 850 netif_stop_queue(net); 851 if (!(pegasus->flags & PEGASUS_UNPLUG)) 852 disable_net_traffic(pegasus); 853 tasklet_kill(&pegasus->rx_tl); 854 unlink_all_urbs(pegasus); 855 856 return 0; 857 } 858 859 static void pegasus_get_drvinfo(struct net_device *dev, 860 struct ethtool_drvinfo *info) 861 { 862 pegasus_t *pegasus = netdev_priv(dev); 863 864 strlcpy(info->driver, driver_name, sizeof(info->driver)); 865 strlcpy(info->version, DRIVER_VERSION, sizeof(info->version)); 866 usb_make_path(pegasus->usb, info->bus_info, sizeof(info->bus_info)); 867 } 868 869 /* also handles three patterns of some kind in hardware */ 870 #define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY) 871 872 static void 873 pegasus_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 874 { 875 pegasus_t *pegasus = netdev_priv(dev); 876 877 wol->supported = WAKE_MAGIC | WAKE_PHY; 878 wol->wolopts = pegasus->wolopts; 879 } 880 881 static int 882 pegasus_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 883 { 884 pegasus_t *pegasus = netdev_priv(dev); 885 u8 reg78 = 0x04; 886 int ret; 887 888 if (wol->wolopts & ~WOL_SUPPORTED) 889 return -EINVAL; 890 891 if (wol->wolopts & WAKE_MAGIC) 892 reg78 |= 0x80; 893 if (wol->wolopts & WAKE_PHY) 894 reg78 |= 0x40; 895 /* FIXME this 0x10 bit still needs to get set in the chip... */ 896 if (wol->wolopts) 897 pegasus->eth_regs[0] |= 0x10; 898 else 899 pegasus->eth_regs[0] &= ~0x10; 900 pegasus->wolopts = wol->wolopts; 901 902 ret = set_register(pegasus, WakeupControl, reg78); 903 if (!ret) 904 ret = device_set_wakeup_enable(&pegasus->usb->dev, 905 wol->wolopts); 906 return ret; 907 } 908 909 static inline void pegasus_reset_wol(struct net_device *dev) 910 { 911 struct ethtool_wolinfo wol; 912 913 memset(&wol, 0, sizeof wol); 914 (void) pegasus_set_wol(dev, &wol); 915 } 916 917 static int 918 pegasus_get_link_ksettings(struct net_device *dev, 919 struct ethtool_link_ksettings *ecmd) 920 { 921 pegasus_t *pegasus; 922 923 pegasus = netdev_priv(dev); 924 mii_ethtool_get_link_ksettings(&pegasus->mii, ecmd); 925 return 0; 926 } 927 928 static int 929 pegasus_set_link_ksettings(struct net_device *dev, 930 const struct ethtool_link_ksettings *ecmd) 931 { 932 pegasus_t *pegasus = netdev_priv(dev); 933 return mii_ethtool_set_link_ksettings(&pegasus->mii, ecmd); 934 } 935 936 static int pegasus_nway_reset(struct net_device *dev) 937 { 938 pegasus_t *pegasus = netdev_priv(dev); 939 return mii_nway_restart(&pegasus->mii); 940 } 941 942 static u32 pegasus_get_link(struct net_device *dev) 943 { 944 pegasus_t *pegasus = netdev_priv(dev); 945 return mii_link_ok(&pegasus->mii); 946 } 947 948 static u32 pegasus_get_msglevel(struct net_device *dev) 949 { 950 pegasus_t *pegasus = netdev_priv(dev); 951 return pegasus->msg_enable; 952 } 953 954 static void pegasus_set_msglevel(struct net_device *dev, u32 v) 955 { 956 pegasus_t *pegasus = netdev_priv(dev); 957 pegasus->msg_enable = v; 958 } 959 960 static const struct ethtool_ops ops = { 961 .get_drvinfo = pegasus_get_drvinfo, 962 .nway_reset = pegasus_nway_reset, 963 .get_link = pegasus_get_link, 964 .get_msglevel = pegasus_get_msglevel, 965 .set_msglevel = pegasus_set_msglevel, 966 .get_wol = pegasus_get_wol, 967 .set_wol = pegasus_set_wol, 968 .get_link_ksettings = pegasus_get_link_ksettings, 969 .set_link_ksettings = pegasus_set_link_ksettings, 970 }; 971 972 static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd) 973 { 974 __u16 *data = (__u16 *) &rq->ifr_ifru; 975 pegasus_t *pegasus = netdev_priv(net); 976 int res; 977 978 switch (cmd) { 979 case SIOCDEVPRIVATE: 980 data[0] = pegasus->phy; 981 fallthrough; 982 case SIOCDEVPRIVATE + 1: 983 read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]); 984 res = 0; 985 break; 986 case SIOCDEVPRIVATE + 2: 987 if (!capable(CAP_NET_ADMIN)) 988 return -EPERM; 989 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, &data[2]); 990 res = 0; 991 break; 992 default: 993 res = -EOPNOTSUPP; 994 } 995 return res; 996 } 997 998 static void pegasus_set_multicast(struct net_device *net) 999 { 1000 pegasus_t *pegasus = netdev_priv(net); 1001 1002 if (net->flags & IFF_PROMISC) { 1003 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS; 1004 netif_info(pegasus, link, net, "Promiscuous mode enabled\n"); 1005 } else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) { 1006 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST; 1007 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS; 1008 netif_dbg(pegasus, link, net, "set allmulti\n"); 1009 } else { 1010 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST; 1011 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS; 1012 } 1013 update_eth_regs_async(pegasus); 1014 } 1015 1016 static __u8 mii_phy_probe(pegasus_t *pegasus) 1017 { 1018 int i; 1019 __u16 tmp; 1020 1021 for (i = 0; i < 32; i++) { 1022 read_mii_word(pegasus, i, MII_BMSR, &tmp); 1023 if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0) 1024 continue; 1025 else 1026 return i; 1027 } 1028 1029 return 0xff; 1030 } 1031 1032 static inline void setup_pegasus_II(pegasus_t *pegasus) 1033 { 1034 __u8 data = 0xa5; 1035 1036 set_register(pegasus, Reg1d, 0); 1037 set_register(pegasus, Reg7b, 1); 1038 msleep(100); 1039 if ((pegasus->features & HAS_HOME_PNA) && mii_mode) 1040 set_register(pegasus, Reg7b, 0); 1041 else 1042 set_register(pegasus, Reg7b, 2); 1043 1044 set_register(pegasus, 0x83, data); 1045 get_registers(pegasus, 0x83, 1, &data); 1046 1047 if (data == 0xa5) 1048 pegasus->chip = 0x8513; 1049 else 1050 pegasus->chip = 0; 1051 1052 set_register(pegasus, 0x80, 0xc0); 1053 set_register(pegasus, 0x83, 0xff); 1054 set_register(pegasus, 0x84, 0x01); 1055 1056 if (pegasus->features & HAS_HOME_PNA && mii_mode) 1057 set_register(pegasus, Reg81, 6); 1058 else 1059 set_register(pegasus, Reg81, 2); 1060 } 1061 1062 static void check_carrier(struct work_struct *work) 1063 { 1064 pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work); 1065 set_carrier(pegasus->net); 1066 if (!(pegasus->flags & PEGASUS_UNPLUG)) { 1067 queue_delayed_work(system_long_wq, &pegasus->carrier_check, 1068 CARRIER_CHECK_DELAY); 1069 } 1070 } 1071 1072 static int pegasus_blacklisted(struct usb_device *udev) 1073 { 1074 struct usb_device_descriptor *udd = &udev->descriptor; 1075 1076 /* Special quirk to keep the driver from handling the Belkin Bluetooth 1077 * dongle which happens to have the same ID. 1078 */ 1079 if ((udd->idVendor == cpu_to_le16(VENDOR_BELKIN)) && 1080 (udd->idProduct == cpu_to_le16(0x0121)) && 1081 (udd->bDeviceClass == USB_CLASS_WIRELESS_CONTROLLER) && 1082 (udd->bDeviceProtocol == 1)) 1083 return 1; 1084 1085 return 0; 1086 } 1087 1088 static int pegasus_probe(struct usb_interface *intf, 1089 const struct usb_device_id *id) 1090 { 1091 struct usb_device *dev = interface_to_usbdev(intf); 1092 struct net_device *net; 1093 pegasus_t *pegasus; 1094 int dev_index = id - pegasus_ids; 1095 int res = -ENOMEM; 1096 1097 if (pegasus_blacklisted(dev)) 1098 return -ENODEV; 1099 1100 net = alloc_etherdev(sizeof(struct pegasus)); 1101 if (!net) 1102 goto out; 1103 1104 pegasus = netdev_priv(net); 1105 pegasus->dev_index = dev_index; 1106 1107 res = alloc_urbs(pegasus); 1108 if (res < 0) { 1109 dev_err(&intf->dev, "can't allocate %s\n", "urbs"); 1110 goto out1; 1111 } 1112 1113 tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus); 1114 1115 INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier); 1116 1117 pegasus->intf = intf; 1118 pegasus->usb = dev; 1119 pegasus->net = net; 1120 1121 1122 net->watchdog_timeo = PEGASUS_TX_TIMEOUT; 1123 net->netdev_ops = &pegasus_netdev_ops; 1124 net->ethtool_ops = &ops; 1125 pegasus->mii.dev = net; 1126 pegasus->mii.mdio_read = mdio_read; 1127 pegasus->mii.mdio_write = mdio_write; 1128 pegasus->mii.phy_id_mask = 0x1f; 1129 pegasus->mii.reg_num_mask = 0x1f; 1130 pegasus->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV 1131 | NETIF_MSG_PROBE | NETIF_MSG_LINK); 1132 1133 pegasus->features = usb_dev_id[dev_index].private; 1134 get_interrupt_interval(pegasus); 1135 if (reset_mac(pegasus)) { 1136 dev_err(&intf->dev, "can't reset MAC\n"); 1137 res = -EIO; 1138 goto out2; 1139 } 1140 set_ethernet_addr(pegasus); 1141 if (pegasus->features & PEGASUS_II) { 1142 dev_info(&intf->dev, "setup Pegasus II specific registers\n"); 1143 setup_pegasus_II(pegasus); 1144 } 1145 pegasus->phy = mii_phy_probe(pegasus); 1146 if (pegasus->phy == 0xff) { 1147 dev_warn(&intf->dev, "can't locate MII phy, using default\n"); 1148 pegasus->phy = 1; 1149 } 1150 pegasus->mii.phy_id = pegasus->phy; 1151 usb_set_intfdata(intf, pegasus); 1152 SET_NETDEV_DEV(net, &intf->dev); 1153 pegasus_reset_wol(net); 1154 res = register_netdev(net); 1155 if (res) 1156 goto out3; 1157 queue_delayed_work(system_long_wq, &pegasus->carrier_check, 1158 CARRIER_CHECK_DELAY); 1159 dev_info(&intf->dev, "%s, %s, %pM\n", net->name, 1160 usb_dev_id[dev_index].name, net->dev_addr); 1161 return 0; 1162 1163 out3: 1164 usb_set_intfdata(intf, NULL); 1165 out2: 1166 free_all_urbs(pegasus); 1167 out1: 1168 free_netdev(net); 1169 out: 1170 return res; 1171 } 1172 1173 static void pegasus_disconnect(struct usb_interface *intf) 1174 { 1175 struct pegasus *pegasus = usb_get_intfdata(intf); 1176 1177 usb_set_intfdata(intf, NULL); 1178 if (!pegasus) { 1179 dev_dbg(&intf->dev, "unregistering non-bound device?\n"); 1180 return; 1181 } 1182 1183 pegasus->flags |= PEGASUS_UNPLUG; 1184 cancel_delayed_work_sync(&pegasus->carrier_check); 1185 unregister_netdev(pegasus->net); 1186 unlink_all_urbs(pegasus); 1187 free_all_urbs(pegasus); 1188 if (pegasus->rx_skb != NULL) { 1189 dev_kfree_skb(pegasus->rx_skb); 1190 pegasus->rx_skb = NULL; 1191 } 1192 free_netdev(pegasus->net); 1193 } 1194 1195 static int pegasus_suspend(struct usb_interface *intf, pm_message_t message) 1196 { 1197 struct pegasus *pegasus = usb_get_intfdata(intf); 1198 1199 netif_device_detach(pegasus->net); 1200 cancel_delayed_work_sync(&pegasus->carrier_check); 1201 if (netif_running(pegasus->net)) { 1202 usb_kill_urb(pegasus->rx_urb); 1203 usb_kill_urb(pegasus->intr_urb); 1204 } 1205 return 0; 1206 } 1207 1208 static int pegasus_resume(struct usb_interface *intf) 1209 { 1210 struct pegasus *pegasus = usb_get_intfdata(intf); 1211 1212 netif_device_attach(pegasus->net); 1213 if (netif_running(pegasus->net)) { 1214 pegasus->rx_urb->status = 0; 1215 pegasus->rx_urb->actual_length = 0; 1216 read_bulk_callback(pegasus->rx_urb); 1217 1218 pegasus->intr_urb->status = 0; 1219 pegasus->intr_urb->actual_length = 0; 1220 intr_callback(pegasus->intr_urb); 1221 } 1222 queue_delayed_work(system_long_wq, &pegasus->carrier_check, 1223 CARRIER_CHECK_DELAY); 1224 return 0; 1225 } 1226 1227 static const struct net_device_ops pegasus_netdev_ops = { 1228 .ndo_open = pegasus_open, 1229 .ndo_stop = pegasus_close, 1230 .ndo_do_ioctl = pegasus_ioctl, 1231 .ndo_start_xmit = pegasus_start_xmit, 1232 .ndo_set_rx_mode = pegasus_set_multicast, 1233 .ndo_tx_timeout = pegasus_tx_timeout, 1234 .ndo_set_mac_address = eth_mac_addr, 1235 .ndo_validate_addr = eth_validate_addr, 1236 }; 1237 1238 static struct usb_driver pegasus_driver = { 1239 .name = driver_name, 1240 .probe = pegasus_probe, 1241 .disconnect = pegasus_disconnect, 1242 .id_table = pegasus_ids, 1243 .suspend = pegasus_suspend, 1244 .resume = pegasus_resume, 1245 .disable_hub_initiated_lpm = 1, 1246 }; 1247 1248 static void __init parse_id(char *id) 1249 { 1250 unsigned int vendor_id = 0, device_id = 0, flags = 0, i = 0; 1251 char *token, *name = NULL; 1252 1253 if ((token = strsep(&id, ":")) != NULL) 1254 name = token; 1255 /* name now points to a null terminated string*/ 1256 if ((token = strsep(&id, ":")) != NULL) 1257 vendor_id = simple_strtoul(token, NULL, 16); 1258 if ((token = strsep(&id, ":")) != NULL) 1259 device_id = simple_strtoul(token, NULL, 16); 1260 flags = simple_strtoul(id, NULL, 16); 1261 pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n", 1262 driver_name, name, vendor_id, device_id, flags); 1263 1264 if (vendor_id > 0x10000 || vendor_id == 0) 1265 return; 1266 if (device_id > 0x10000 || device_id == 0) 1267 return; 1268 1269 for (i = 0; usb_dev_id[i].name; i++); 1270 usb_dev_id[i].name = name; 1271 usb_dev_id[i].vendor = vendor_id; 1272 usb_dev_id[i].device = device_id; 1273 usb_dev_id[i].private = flags; 1274 pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE; 1275 pegasus_ids[i].idVendor = vendor_id; 1276 pegasus_ids[i].idProduct = device_id; 1277 } 1278 1279 static int __init pegasus_init(void) 1280 { 1281 pr_info("%s: %s, " DRIVER_DESC "\n", driver_name, DRIVER_VERSION); 1282 if (devid) 1283 parse_id(devid); 1284 return usb_register(&pegasus_driver); 1285 } 1286 1287 static void __exit pegasus_exit(void) 1288 { 1289 usb_deregister(&pegasus_driver); 1290 } 1291 1292 module_init(pegasus_init); 1293 module_exit(pegasus_exit); 1294