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