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