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