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; 772 773 if (!pegasus) 774 return; 775 776 net = pegasus->net; 777 778 if (!netif_device_present(net) || !netif_running(net)) 779 return; 780 781 switch (urb->status) { 782 case -EPIPE: 783 /* FIXME schedule_work() to clear the tx halt */ 784 netif_stop_queue(net); 785 if (netif_msg_tx_err(pegasus)) 786 printk(KERN_WARNING "%s: no tx stall recovery\n", 787 net->name); 788 return; 789 case -ENOENT: 790 case -ECONNRESET: 791 case -ESHUTDOWN: 792 if (netif_msg_ifdown(pegasus)) 793 pr_debug("%s: tx unlink, %d\n", net->name, urb->status); 794 return; 795 default: 796 if (netif_msg_tx_err(pegasus)) 797 pr_info("%s: TX status %d\n", net->name, urb->status); 798 /* FALL THROUGH */ 799 case 0: 800 break; 801 } 802 803 net->trans_start = jiffies; 804 netif_wake_queue(net); 805 } 806 807 static void intr_callback(struct urb *urb) 808 { 809 pegasus_t *pegasus = urb->context; 810 struct net_device *net; 811 int status; 812 813 if (!pegasus) 814 return; 815 net = pegasus->net; 816 817 switch (urb->status) { 818 case 0: 819 break; 820 case -ECONNRESET: /* unlink */ 821 case -ENOENT: 822 case -ESHUTDOWN: 823 return; 824 default: 825 /* some Pegasus-I products report LOTS of data 826 * toggle errors... avoid log spamming 827 */ 828 if (netif_msg_timer(pegasus)) 829 pr_debug("%s: intr status %d\n", net->name, 830 urb->status); 831 } 832 833 if (urb->actual_length >= 6) { 834 u8 * d = urb->transfer_buffer; 835 836 /* byte 0 == tx_status1, reg 2B */ 837 if (d[0] & (TX_UNDERRUN|EXCESSIVE_COL 838 |LATE_COL|JABBER_TIMEOUT)) { 839 pegasus->stats.tx_errors++; 840 if (d[0] & TX_UNDERRUN) 841 pegasus->stats.tx_fifo_errors++; 842 if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT)) 843 pegasus->stats.tx_aborted_errors++; 844 if (d[0] & LATE_COL) 845 pegasus->stats.tx_window_errors++; 846 } 847 848 /* d[5].LINK_STATUS lies on some adapters. 849 * d[0].NO_CARRIER kicks in only with failed TX. 850 * ... so monitoring with MII may be safest. 851 */ 852 853 /* bytes 3-4 == rx_lostpkt, reg 2E/2F */ 854 pegasus->stats.rx_missed_errors += ((d[3] & 0x7f) << 8) | d[4]; 855 } 856 857 status = usb_submit_urb(urb, GFP_ATOMIC); 858 if (status == -ENODEV) 859 netif_device_detach(pegasus->net); 860 if (status && netif_msg_timer(pegasus)) 861 printk(KERN_ERR "%s: can't resubmit interrupt urb, %d\n", 862 net->name, status); 863 } 864 865 static void pegasus_tx_timeout(struct net_device *net) 866 { 867 pegasus_t *pegasus = netdev_priv(net); 868 if (netif_msg_timer(pegasus)) 869 printk(KERN_WARNING "%s: tx timeout\n", net->name); 870 usb_unlink_urb(pegasus->tx_urb); 871 pegasus->stats.tx_errors++; 872 } 873 874 static int pegasus_start_xmit(struct sk_buff *skb, struct net_device *net) 875 { 876 pegasus_t *pegasus = netdev_priv(net); 877 int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3; 878 int res; 879 __u16 l16 = skb->len; 880 881 netif_stop_queue(net); 882 883 ((__le16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16); 884 skb_copy_from_linear_data(skb, pegasus->tx_buff + 2, skb->len); 885 usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb, 886 usb_sndbulkpipe(pegasus->usb, 2), 887 pegasus->tx_buff, count, 888 write_bulk_callback, pegasus); 889 if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) { 890 if (netif_msg_tx_err(pegasus)) 891 printk(KERN_WARNING "%s: fail tx, %d\n", 892 net->name, res); 893 switch (res) { 894 case -EPIPE: /* stall, or disconnect from TT */ 895 /* cleanup should already have been scheduled */ 896 break; 897 case -ENODEV: /* disconnect() upcoming */ 898 netif_device_detach(pegasus->net); 899 break; 900 default: 901 pegasus->stats.tx_errors++; 902 netif_start_queue(net); 903 } 904 } else { 905 pegasus->stats.tx_packets++; 906 pegasus->stats.tx_bytes += skb->len; 907 net->trans_start = jiffies; 908 } 909 dev_kfree_skb(skb); 910 911 return 0; 912 } 913 914 static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev) 915 { 916 return &((pegasus_t *) netdev_priv(dev))->stats; 917 } 918 919 static inline void disable_net_traffic(pegasus_t * pegasus) 920 { 921 int tmp = 0; 922 923 set_registers(pegasus, EthCtrl0, 2, &tmp); 924 } 925 926 static inline void get_interrupt_interval(pegasus_t * pegasus) 927 { 928 __u8 data[2]; 929 930 read_eprom_word(pegasus, 4, (__u16 *) data); 931 if (pegasus->usb->speed != USB_SPEED_HIGH) { 932 if (data[1] < 0x80) { 933 if (netif_msg_timer(pegasus)) 934 dev_info(&pegasus->intf->dev, "intr interval " 935 "changed from %ums to %ums\n", 936 data[1], 0x80); 937 data[1] = 0x80; 938 #ifdef PEGASUS_WRITE_EEPROM 939 write_eprom_word(pegasus, 4, *(__u16 *) data); 940 #endif 941 } 942 } 943 pegasus->intr_interval = data[1]; 944 } 945 946 static void set_carrier(struct net_device *net) 947 { 948 pegasus_t *pegasus = netdev_priv(net); 949 u16 tmp; 950 951 if (read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp)) 952 return; 953 954 if (tmp & BMSR_LSTATUS) 955 netif_carrier_on(net); 956 else 957 netif_carrier_off(net); 958 } 959 960 static void free_all_urbs(pegasus_t * pegasus) 961 { 962 usb_free_urb(pegasus->intr_urb); 963 usb_free_urb(pegasus->tx_urb); 964 usb_free_urb(pegasus->rx_urb); 965 usb_free_urb(pegasus->ctrl_urb); 966 } 967 968 static void unlink_all_urbs(pegasus_t * pegasus) 969 { 970 usb_kill_urb(pegasus->intr_urb); 971 usb_kill_urb(pegasus->tx_urb); 972 usb_kill_urb(pegasus->rx_urb); 973 usb_kill_urb(pegasus->ctrl_urb); 974 } 975 976 static int alloc_urbs(pegasus_t * pegasus) 977 { 978 pegasus->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL); 979 if (!pegasus->ctrl_urb) { 980 return 0; 981 } 982 pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 983 if (!pegasus->rx_urb) { 984 usb_free_urb(pegasus->ctrl_urb); 985 return 0; 986 } 987 pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL); 988 if (!pegasus->tx_urb) { 989 usb_free_urb(pegasus->rx_urb); 990 usb_free_urb(pegasus->ctrl_urb); 991 return 0; 992 } 993 pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL); 994 if (!pegasus->intr_urb) { 995 usb_free_urb(pegasus->tx_urb); 996 usb_free_urb(pegasus->rx_urb); 997 usb_free_urb(pegasus->ctrl_urb); 998 return 0; 999 } 1000 1001 return 1; 1002 } 1003 1004 static int pegasus_open(struct net_device *net) 1005 { 1006 pegasus_t *pegasus = netdev_priv(net); 1007 int res; 1008 1009 if (pegasus->rx_skb == NULL) 1010 pegasus->rx_skb = pull_skb(pegasus); 1011 /* 1012 ** Note: no point to free the pool. it is empty :-) 1013 */ 1014 if (!pegasus->rx_skb) 1015 return -ENOMEM; 1016 1017 res = set_registers(pegasus, EthID, 6, net->dev_addr); 1018 1019 usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb, 1020 usb_rcvbulkpipe(pegasus->usb, 1), 1021 pegasus->rx_skb->data, PEGASUS_MTU + 8, 1022 read_bulk_callback, pegasus); 1023 if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) { 1024 if (res == -ENODEV) 1025 netif_device_detach(pegasus->net); 1026 if (netif_msg_ifup(pegasus)) 1027 pr_debug("%s: failed rx_urb, %d", net->name, res); 1028 goto exit; 1029 } 1030 1031 usb_fill_int_urb(pegasus->intr_urb, pegasus->usb, 1032 usb_rcvintpipe(pegasus->usb, 3), 1033 pegasus->intr_buff, sizeof (pegasus->intr_buff), 1034 intr_callback, pegasus, pegasus->intr_interval); 1035 if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL))) { 1036 if (res == -ENODEV) 1037 netif_device_detach(pegasus->net); 1038 if (netif_msg_ifup(pegasus)) 1039 pr_debug("%s: failed intr_urb, %d\n", net->name, res); 1040 usb_kill_urb(pegasus->rx_urb); 1041 goto exit; 1042 } 1043 if ((res = enable_net_traffic(net, pegasus->usb))) { 1044 if (netif_msg_ifup(pegasus)) 1045 pr_debug("%s: can't enable_net_traffic() - %d\n", 1046 net->name, res); 1047 res = -EIO; 1048 usb_kill_urb(pegasus->rx_urb); 1049 usb_kill_urb(pegasus->intr_urb); 1050 free_skb_pool(pegasus); 1051 goto exit; 1052 } 1053 set_carrier(net); 1054 netif_start_queue(net); 1055 if (netif_msg_ifup(pegasus)) 1056 pr_debug("%s: open\n", net->name); 1057 res = 0; 1058 exit: 1059 return res; 1060 } 1061 1062 static int pegasus_close(struct net_device *net) 1063 { 1064 pegasus_t *pegasus = netdev_priv(net); 1065 1066 netif_stop_queue(net); 1067 if (!(pegasus->flags & PEGASUS_UNPLUG)) 1068 disable_net_traffic(pegasus); 1069 tasklet_kill(&pegasus->rx_tl); 1070 unlink_all_urbs(pegasus); 1071 1072 return 0; 1073 } 1074 1075 static void pegasus_get_drvinfo(struct net_device *dev, 1076 struct ethtool_drvinfo *info) 1077 { 1078 pegasus_t *pegasus = netdev_priv(dev); 1079 strncpy(info->driver, driver_name, sizeof (info->driver) - 1); 1080 strncpy(info->version, DRIVER_VERSION, sizeof (info->version) - 1); 1081 usb_make_path(pegasus->usb, info->bus_info, sizeof (info->bus_info)); 1082 } 1083 1084 /* also handles three patterns of some kind in hardware */ 1085 #define WOL_SUPPORTED (WAKE_MAGIC|WAKE_PHY) 1086 1087 static void 1088 pegasus_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1089 { 1090 pegasus_t *pegasus = netdev_priv(dev); 1091 1092 wol->supported = WAKE_MAGIC | WAKE_PHY; 1093 wol->wolopts = pegasus->wolopts; 1094 } 1095 1096 static int 1097 pegasus_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 1098 { 1099 pegasus_t *pegasus = netdev_priv(dev); 1100 u8 reg78 = 0x04; 1101 1102 if (wol->wolopts & ~WOL_SUPPORTED) 1103 return -EINVAL; 1104 1105 if (wol->wolopts & WAKE_MAGIC) 1106 reg78 |= 0x80; 1107 if (wol->wolopts & WAKE_PHY) 1108 reg78 |= 0x40; 1109 /* FIXME this 0x10 bit still needs to get set in the chip... */ 1110 if (wol->wolopts) 1111 pegasus->eth_regs[0] |= 0x10; 1112 else 1113 pegasus->eth_regs[0] &= ~0x10; 1114 pegasus->wolopts = wol->wolopts; 1115 return set_register(pegasus, WakeupControl, reg78); 1116 } 1117 1118 static inline void pegasus_reset_wol(struct net_device *dev) 1119 { 1120 struct ethtool_wolinfo wol; 1121 1122 memset(&wol, 0, sizeof wol); 1123 (void) pegasus_set_wol(dev, &wol); 1124 } 1125 1126 static int 1127 pegasus_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 1128 { 1129 pegasus_t *pegasus; 1130 1131 pegasus = netdev_priv(dev); 1132 mii_ethtool_gset(&pegasus->mii, ecmd); 1133 return 0; 1134 } 1135 1136 static int 1137 pegasus_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd) 1138 { 1139 pegasus_t *pegasus = netdev_priv(dev); 1140 return mii_ethtool_sset(&pegasus->mii, ecmd); 1141 } 1142 1143 static int pegasus_nway_reset(struct net_device *dev) 1144 { 1145 pegasus_t *pegasus = netdev_priv(dev); 1146 return mii_nway_restart(&pegasus->mii); 1147 } 1148 1149 static u32 pegasus_get_link(struct net_device *dev) 1150 { 1151 pegasus_t *pegasus = netdev_priv(dev); 1152 return mii_link_ok(&pegasus->mii); 1153 } 1154 1155 static u32 pegasus_get_msglevel(struct net_device *dev) 1156 { 1157 pegasus_t *pegasus = netdev_priv(dev); 1158 return pegasus->msg_enable; 1159 } 1160 1161 static void pegasus_set_msglevel(struct net_device *dev, u32 v) 1162 { 1163 pegasus_t *pegasus = netdev_priv(dev); 1164 pegasus->msg_enable = v; 1165 } 1166 1167 static struct ethtool_ops ops = { 1168 .get_drvinfo = pegasus_get_drvinfo, 1169 .get_settings = pegasus_get_settings, 1170 .set_settings = pegasus_set_settings, 1171 .nway_reset = pegasus_nway_reset, 1172 .get_link = pegasus_get_link, 1173 .get_msglevel = pegasus_get_msglevel, 1174 .set_msglevel = pegasus_set_msglevel, 1175 .get_wol = pegasus_get_wol, 1176 .set_wol = pegasus_set_wol, 1177 }; 1178 1179 static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd) 1180 { 1181 __u16 *data = (__u16 *) & rq->ifr_ifru; 1182 pegasus_t *pegasus = netdev_priv(net); 1183 int res; 1184 1185 switch (cmd) { 1186 case SIOCDEVPRIVATE: 1187 data[0] = pegasus->phy; 1188 case SIOCDEVPRIVATE + 1: 1189 read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]); 1190 res = 0; 1191 break; 1192 case SIOCDEVPRIVATE + 2: 1193 if (!capable(CAP_NET_ADMIN)) 1194 return -EPERM; 1195 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]); 1196 res = 0; 1197 break; 1198 default: 1199 res = -EOPNOTSUPP; 1200 } 1201 return res; 1202 } 1203 1204 static void pegasus_set_multicast(struct net_device *net) 1205 { 1206 pegasus_t *pegasus = netdev_priv(net); 1207 1208 if (net->flags & IFF_PROMISC) { 1209 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS; 1210 if (netif_msg_link(pegasus)) 1211 pr_info("%s: Promiscuous mode enabled.\n", net->name); 1212 } else if (net->mc_count || 1213 (net->flags & IFF_ALLMULTI)) { 1214 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST; 1215 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS; 1216 if (netif_msg_link(pegasus)) 1217 pr_info("%s: set allmulti\n", net->name); 1218 } else { 1219 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST; 1220 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS; 1221 } 1222 1223 pegasus->flags |= ETH_REGS_CHANGE; 1224 ctrl_callback(pegasus->ctrl_urb); 1225 } 1226 1227 static __u8 mii_phy_probe(pegasus_t * pegasus) 1228 { 1229 int i; 1230 __u16 tmp; 1231 1232 for (i = 0; i < 32; i++) { 1233 read_mii_word(pegasus, i, MII_BMSR, &tmp); 1234 if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0) 1235 continue; 1236 else 1237 return i; 1238 } 1239 1240 return 0xff; 1241 } 1242 1243 static inline void setup_pegasus_II(pegasus_t * pegasus) 1244 { 1245 __u8 data = 0xa5; 1246 1247 set_register(pegasus, Reg1d, 0); 1248 set_register(pegasus, Reg7b, 1); 1249 mdelay(100); 1250 if ((pegasus->features & HAS_HOME_PNA) && mii_mode) 1251 set_register(pegasus, Reg7b, 0); 1252 else 1253 set_register(pegasus, Reg7b, 2); 1254 1255 set_register(pegasus, 0x83, data); 1256 get_registers(pegasus, 0x83, 1, &data); 1257 1258 if (data == 0xa5) { 1259 pegasus->chip = 0x8513; 1260 } else { 1261 pegasus->chip = 0; 1262 } 1263 1264 set_register(pegasus, 0x80, 0xc0); 1265 set_register(pegasus, 0x83, 0xff); 1266 set_register(pegasus, 0x84, 0x01); 1267 1268 if (pegasus->features & HAS_HOME_PNA && mii_mode) 1269 set_register(pegasus, Reg81, 6); 1270 else 1271 set_register(pegasus, Reg81, 2); 1272 } 1273 1274 1275 static struct workqueue_struct *pegasus_workqueue = NULL; 1276 #define CARRIER_CHECK_DELAY (2 * HZ) 1277 1278 static void check_carrier(struct work_struct *work) 1279 { 1280 pegasus_t *pegasus = container_of(work, pegasus_t, carrier_check.work); 1281 set_carrier(pegasus->net); 1282 if (!(pegasus->flags & PEGASUS_UNPLUG)) { 1283 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check, 1284 CARRIER_CHECK_DELAY); 1285 } 1286 } 1287 1288 static int pegasus_probe(struct usb_interface *intf, 1289 const struct usb_device_id *id) 1290 { 1291 struct usb_device *dev = interface_to_usbdev(intf); 1292 struct net_device *net; 1293 pegasus_t *pegasus; 1294 int dev_index = id - pegasus_ids; 1295 int res = -ENOMEM; 1296 DECLARE_MAC_BUF(mac); 1297 1298 usb_get_dev(dev); 1299 net = alloc_etherdev(sizeof(struct pegasus)); 1300 if (!net) { 1301 dev_err(&intf->dev, "can't allocate %s\n", "device"); 1302 goto out; 1303 } 1304 1305 pegasus = netdev_priv(net); 1306 pegasus->dev_index = dev_index; 1307 init_waitqueue_head(&pegasus->ctrl_wait); 1308 1309 if (!alloc_urbs(pegasus)) { 1310 dev_err(&intf->dev, "can't allocate %s\n", "urbs"); 1311 goto out1; 1312 } 1313 1314 tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus); 1315 1316 INIT_DELAYED_WORK(&pegasus->carrier_check, check_carrier); 1317 1318 pegasus->intf = intf; 1319 pegasus->usb = dev; 1320 pegasus->net = net; 1321 net->open = pegasus_open; 1322 net->stop = pegasus_close; 1323 net->watchdog_timeo = PEGASUS_TX_TIMEOUT; 1324 net->tx_timeout = pegasus_tx_timeout; 1325 net->do_ioctl = pegasus_ioctl; 1326 net->hard_start_xmit = pegasus_start_xmit; 1327 net->set_multicast_list = pegasus_set_multicast; 1328 net->get_stats = pegasus_netdev_stats; 1329 SET_ETHTOOL_OPS(net, &ops); 1330 pegasus->mii.dev = net; 1331 pegasus->mii.mdio_read = mdio_read; 1332 pegasus->mii.mdio_write = mdio_write; 1333 pegasus->mii.phy_id_mask = 0x1f; 1334 pegasus->mii.reg_num_mask = 0x1f; 1335 spin_lock_init(&pegasus->rx_pool_lock); 1336 pegasus->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV 1337 | NETIF_MSG_PROBE | NETIF_MSG_LINK); 1338 1339 pegasus->features = usb_dev_id[dev_index].private; 1340 get_interrupt_interval(pegasus); 1341 if (reset_mac(pegasus)) { 1342 dev_err(&intf->dev, "can't reset MAC\n"); 1343 res = -EIO; 1344 goto out2; 1345 } 1346 set_ethernet_addr(pegasus); 1347 fill_skb_pool(pegasus); 1348 if (pegasus->features & PEGASUS_II) { 1349 dev_info(&intf->dev, "setup Pegasus II specific registers\n"); 1350 setup_pegasus_II(pegasus); 1351 } 1352 pegasus->phy = mii_phy_probe(pegasus); 1353 if (pegasus->phy == 0xff) { 1354 dev_warn(&intf->dev, "can't locate MII phy, using default\n"); 1355 pegasus->phy = 1; 1356 } 1357 pegasus->mii.phy_id = pegasus->phy; 1358 usb_set_intfdata(intf, pegasus); 1359 SET_NETDEV_DEV(net, &intf->dev); 1360 pegasus_reset_wol(net); 1361 res = register_netdev(net); 1362 if (res) 1363 goto out3; 1364 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check, 1365 CARRIER_CHECK_DELAY); 1366 1367 dev_info(&intf->dev, "%s, %s, %s\n", 1368 net->name, 1369 usb_dev_id[dev_index].name, 1370 print_mac(mac, net->dev_addr)); 1371 return 0; 1372 1373 out3: 1374 usb_set_intfdata(intf, NULL); 1375 free_skb_pool(pegasus); 1376 out2: 1377 free_all_urbs(pegasus); 1378 out1: 1379 free_netdev(net); 1380 out: 1381 usb_put_dev(dev); 1382 return res; 1383 } 1384 1385 static void pegasus_disconnect(struct usb_interface *intf) 1386 { 1387 struct pegasus *pegasus = usb_get_intfdata(intf); 1388 1389 usb_set_intfdata(intf, NULL); 1390 if (!pegasus) { 1391 dev_dbg(&intf->dev, "unregistering non-bound device?\n"); 1392 return; 1393 } 1394 1395 pegasus->flags |= PEGASUS_UNPLUG; 1396 cancel_delayed_work(&pegasus->carrier_check); 1397 unregister_netdev(pegasus->net); 1398 usb_put_dev(interface_to_usbdev(intf)); 1399 unlink_all_urbs(pegasus); 1400 free_all_urbs(pegasus); 1401 free_skb_pool(pegasus); 1402 if (pegasus->rx_skb != NULL) { 1403 dev_kfree_skb(pegasus->rx_skb); 1404 pegasus->rx_skb = NULL; 1405 } 1406 free_netdev(pegasus->net); 1407 } 1408 1409 static int pegasus_suspend (struct usb_interface *intf, pm_message_t message) 1410 { 1411 struct pegasus *pegasus = usb_get_intfdata(intf); 1412 1413 netif_device_detach (pegasus->net); 1414 cancel_delayed_work(&pegasus->carrier_check); 1415 if (netif_running(pegasus->net)) { 1416 usb_kill_urb(pegasus->rx_urb); 1417 usb_kill_urb(pegasus->intr_urb); 1418 } 1419 return 0; 1420 } 1421 1422 static int pegasus_resume (struct usb_interface *intf) 1423 { 1424 struct pegasus *pegasus = usb_get_intfdata(intf); 1425 1426 netif_device_attach (pegasus->net); 1427 if (netif_running(pegasus->net)) { 1428 pegasus->rx_urb->status = 0; 1429 pegasus->rx_urb->actual_length = 0; 1430 read_bulk_callback(pegasus->rx_urb); 1431 1432 pegasus->intr_urb->status = 0; 1433 pegasus->intr_urb->actual_length = 0; 1434 intr_callback(pegasus->intr_urb); 1435 } 1436 queue_delayed_work(pegasus_workqueue, &pegasus->carrier_check, 1437 CARRIER_CHECK_DELAY); 1438 return 0; 1439 } 1440 1441 static struct usb_driver pegasus_driver = { 1442 .name = driver_name, 1443 .probe = pegasus_probe, 1444 .disconnect = pegasus_disconnect, 1445 .id_table = pegasus_ids, 1446 .suspend = pegasus_suspend, 1447 .resume = pegasus_resume, 1448 }; 1449 1450 static void parse_id(char *id) 1451 { 1452 unsigned int vendor_id=0, device_id=0, flags=0, i=0; 1453 char *token, *name=NULL; 1454 1455 if ((token = strsep(&id, ":")) != NULL) 1456 name = token; 1457 /* name now points to a null terminated string*/ 1458 if ((token = strsep(&id, ":")) != NULL) 1459 vendor_id = simple_strtoul(token, NULL, 16); 1460 if ((token = strsep(&id, ":")) != NULL) 1461 device_id = simple_strtoul(token, NULL, 16); 1462 flags = simple_strtoul(id, NULL, 16); 1463 pr_info("%s: new device %s, vendor ID 0x%04x, device ID 0x%04x, flags: 0x%x\n", 1464 driver_name, name, vendor_id, device_id, flags); 1465 1466 if (vendor_id > 0x10000 || vendor_id == 0) 1467 return; 1468 if (device_id > 0x10000 || device_id == 0) 1469 return; 1470 1471 for (i=0; usb_dev_id[i].name; i++); 1472 usb_dev_id[i].name = name; 1473 usb_dev_id[i].vendor = vendor_id; 1474 usb_dev_id[i].device = device_id; 1475 usb_dev_id[i].private = flags; 1476 pegasus_ids[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE; 1477 pegasus_ids[i].idVendor = vendor_id; 1478 pegasus_ids[i].idProduct = device_id; 1479 } 1480 1481 static int __init pegasus_init(void) 1482 { 1483 pr_info("%s: %s, " DRIVER_DESC "\n", driver_name, DRIVER_VERSION); 1484 if (devid) 1485 parse_id(devid); 1486 pegasus_workqueue = create_singlethread_workqueue("pegasus"); 1487 if (!pegasus_workqueue) 1488 return -ENOMEM; 1489 return usb_register(&pegasus_driver); 1490 } 1491 1492 static void __exit pegasus_exit(void) 1493 { 1494 destroy_workqueue(pegasus_workqueue); 1495 usb_deregister(&pegasus_driver); 1496 } 1497 1498 module_init(pegasus_init); 1499 module_exit(pegasus_exit); 1500