drivers/usb/net/pegasus.c

   1 /*
   2  *  Copyright (c) 1999-2003 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.5.12 (2003/06/06)"
  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 int multicast_filter_limit = 32;
  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 };
  69
  70 static struct usb_device_id pegasus_ids[] = {
  71 #define PEGASUS_DEV(pn, vid, pid, flags) \
  72         {.match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = vid, .idProduct = pid},
  73 #include "pegasus.h"
  74 #undef  PEGASUS_DEV
  75         {}
  76 };
  77
  78 MODULE_AUTHOR(DRIVER_AUTHOR);
  79 MODULE_DESCRIPTION(DRIVER_DESC);
  80 MODULE_LICENSE("GPL");
  81 MODULE_PARM(loopback, "i");
  82 MODULE_PARM(mii_mode, "i");
  83 MODULE_PARM_DESC(loopback, "Enable MAC loopback mode (bit 0)");
  84 MODULE_PARM_DESC(mii_mode, "Enable HomePNA mode (bit 0),default=MII mode = 0");
  85
  86 MODULE_DEVICE_TABLE(usb, pegasus_ids);
  87
  88 static int update_eth_regs_async(pegasus_t *);
  89 /* Aargh!!! I _really_ hate such tweaks */
  90 static void ctrl_callback(struct urb *urb, struct pt_regs *regs)
  91 {
  92         pegasus_t *pegasus = urb->context;
  93
  94         if (!pegasus)
  95                 return;
  96
  97         switch (urb->status) {
  98         case 0:
  99                 if (pegasus->flags & ETH_REGS_CHANGE) {
 100                         pegasus->flags &= ~ETH_REGS_CHANGE;
 101                         pegasus->flags |= ETH_REGS_CHANGED;
 102                         update_eth_regs_async(pegasus);
 103                         return;
 104                 }
 105                 break;
 106         case -EINPROGRESS:
 107                 return;
 108         case -ENOENT:
 109                 break;
 110         default:
 111                 warn("%s: status %d", __FUNCTION__, urb->status);
 112         }
 113         pegasus->flags &= ~ETH_REGS_CHANGED;
 114         wake_up(&pegasus->ctrl_wait);
 115 }
 116
 117 static int get_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
 118                          void *data)
 119 {
 120         int ret;
 121         char *buffer;
 122         DECLARE_WAITQUEUE(wait, current);
 123
 124         buffer = kmalloc(size, GFP_KERNEL);
 125         if (!buffer) {
 126                 warn("%s: looks like we're out of memory", __FUNCTION__);
 127                 return -ENOMEM;
 128         }
 129         add_wait_queue(&pegasus->ctrl_wait, &wait);
 130         set_current_state(TASK_UNINTERRUPTIBLE);
 131         while (pegasus->flags & ETH_REGS_CHANGED)
 132                 schedule();
 133         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 134         set_current_state(TASK_RUNNING);
 135
 136         pegasus->dr.bRequestType = PEGASUS_REQT_READ;
 137         pegasus->dr.bRequest = PEGASUS_REQ_GET_REGS;
 138         pegasus->dr.wValue = cpu_to_le16(0);
 139         pegasus->dr.wIndex = cpu_to_le16p(&indx);
 140         pegasus->dr.wLength = cpu_to_le16p(&size);
 141         pegasus->ctrl_urb->transfer_buffer_length = size;
 142
 143         usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 144                              usb_rcvctrlpipe(pegasus->usb, 0),
 145                              (char *) &pegasus->dr,
 146                              buffer, size, ctrl_callback, pegasus);
 147
 148         add_wait_queue(&pegasus->ctrl_wait, &wait);
 149         set_current_state(TASK_UNINTERRUPTIBLE);
 150
 151         /* using ATOMIC, we'd never wake up if we slept */
 152         if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
 153                 err("%s: BAD CTRLs %d", __FUNCTION__, ret);
 154                 goto out;
 155         }
 156
 157         schedule();
 158 out:
 159         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 160         memcpy(data, buffer, size);
 161         kfree(buffer);
 162
 163         return ret;
 164 }
 165
 166 static int set_registers(pegasus_t * pegasus, __u16 indx, __u16 size,
 167                          void *data)
 168 {
 169         int ret;
 170         char *buffer;
 171         DECLARE_WAITQUEUE(wait, current);
 172
 173         buffer = kmalloc(size, GFP_KERNEL);
 174         if (!buffer) {
 175                 warn("%s: looks like we're out of memory", __FUNCTION__);
 176                 return -ENOMEM;
 177         }
 178         memcpy(buffer, data, size);
 179
 180         add_wait_queue(&pegasus->ctrl_wait, &wait);
 181         set_current_state(TASK_UNINTERRUPTIBLE);
 182         while (pegasus->flags & ETH_REGS_CHANGED)
 183                 schedule();
 184         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 185         set_current_state(TASK_RUNNING);
 186
 187         pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
 188         pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
 189         pegasus->dr.wValue = cpu_to_le16(0);
 190         pegasus->dr.wIndex = cpu_to_le16p(&indx);
 191         pegasus->dr.wLength = cpu_to_le16p(&size);
 192         pegasus->ctrl_urb->transfer_buffer_length = size;
 193
 194         usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 195                              usb_sndctrlpipe(pegasus->usb, 0),
 196                              (char *) &pegasus->dr,
 197                              buffer, size, ctrl_callback, pegasus);
 198
 199         add_wait_queue(&pegasus->ctrl_wait, &wait);
 200         set_current_state(TASK_UNINTERRUPTIBLE);
 201
 202         if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
 203                 err("%s: BAD CTRL %d", __FUNCTION__, ret);
 204                 goto out;
 205         }
 206
 207         schedule();
 208 out:
 209         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 210         kfree(buffer);
 211
 212         return ret;
 213 }
 214
 215 static int set_register(pegasus_t * pegasus, __u16 indx, __u8 data)
 216 {
 217         int ret;
 218         char *tmp;
 219         DECLARE_WAITQUEUE(wait, current);
 220
 221         tmp = kmalloc(1, GFP_KERNEL);
 222         if (!tmp) {
 223                 warn("%s: looks like we're out of memory", __FUNCTION__);
 224                 return -ENOMEM;
 225         }
 226         memcpy(tmp, &data, 1);
 227         add_wait_queue(&pegasus->ctrl_wait, &wait);
 228         set_current_state(TASK_UNINTERRUPTIBLE);
 229         while (pegasus->flags & ETH_REGS_CHANGED)
 230                 schedule();
 231         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 232         set_current_state(TASK_RUNNING);
 233
 234         pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
 235         pegasus->dr.bRequest = PEGASUS_REQ_SET_REG;
 236         pegasus->dr.wValue = cpu_to_le16(data);
 237         pegasus->dr.wIndex = cpu_to_le16p(&indx);
 238         pegasus->dr.wLength = cpu_to_le16(1);
 239         pegasus->ctrl_urb->transfer_buffer_length = 1;
 240
 241         usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 242                              usb_sndctrlpipe(pegasus->usb, 0),
 243                              (char *) &pegasus->dr,
 244                              &tmp, 1, ctrl_callback, pegasus);
 245
 246         add_wait_queue(&pegasus->ctrl_wait, &wait);
 247         set_current_state(TASK_UNINTERRUPTIBLE);
 248
 249         if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC))) {
 250                 err("%s: BAD CTRL %d", __FUNCTION__, ret);
 251                 goto out;
 252         }
 253
 254         schedule();
 255 out:
 256         remove_wait_queue(&pegasus->ctrl_wait, &wait);
 257         kfree(tmp);
 258
 259         return ret;
 260 }
 261
 262 static int update_eth_regs_async(pegasus_t * pegasus)
 263 {
 264         int ret;
 265
 266         pegasus->dr.bRequestType = PEGASUS_REQT_WRITE;
 267         pegasus->dr.bRequest = PEGASUS_REQ_SET_REGS;
 268         pegasus->dr.wValue = 0;
 269         pegasus->dr.wIndex = cpu_to_le16(EthCtrl0);
 270         pegasus->dr.wLength = cpu_to_le16(3);
 271         pegasus->ctrl_urb->transfer_buffer_length = 3;
 272
 273         usb_fill_control_urb(pegasus->ctrl_urb, pegasus->usb,
 274                              usb_sndctrlpipe(pegasus->usb, 0),
 275                              (char *) &pegasus->dr,
 276                              pegasus->eth_regs, 3, ctrl_callback, pegasus);
 277
 278         if ((ret = usb_submit_urb(pegasus->ctrl_urb, GFP_ATOMIC)))
 279                 err("%s: BAD CTRL %d, flgs %x", __FUNCTION__, ret,
 280                     pegasus->flags);
 281
 282         return ret;
 283 }
 284
 285 static int read_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 * regd)
 286 {
 287         int i;
 288         __u8 data[4] = { phy, 0, 0, indx };
 289         __u16 regdi;
 290
 291         set_register(pegasus, PhyCtrl, 0);
 292         set_registers(pegasus, PhyAddr, sizeof (data), data);
 293         set_register(pegasus, PhyCtrl, (indx | PHY_READ));
 294         for (i = 0; i < REG_TIMEOUT; i++) {
 295                 get_registers(pegasus, PhyCtrl, 1, data);
 296                 if (data[0] & PHY_DONE)
 297                         break;
 298         }
 299         if (i < REG_TIMEOUT) {
 300                 get_registers(pegasus, PhyData, 2, &regdi);
 301                 *regd = le16_to_cpu(regdi);
 302                 return 0;
 303         }
 304         warn("%s: failed", __FUNCTION__);
 305
 306         return 1;
 307 }
 308
 309 static int mdio_read(struct net_device *dev, int phy_id, int loc)
 310 {
 311         pegasus_t *pegasus = (pegasus_t *) dev->priv;
 312         int res;
 313
 314         read_mii_word(pegasus, phy_id, loc, (u16 *) & res);
 315         return res & 0xffff;
 316 }
 317
 318 static int write_mii_word(pegasus_t * pegasus, __u8 phy, __u8 indx, __u16 regd)
 319 {
 320         int i;
 321         __u8 data[4] = { phy, 0, 0, indx };
 322
 323         *(data + 1) = cpu_to_le16p(&regd);
 324         set_register(pegasus, PhyCtrl, 0);
 325         set_registers(pegasus, PhyAddr, 4, data);
 326         set_register(pegasus, PhyCtrl, (indx | PHY_WRITE));
 327         for (i = 0; i < REG_TIMEOUT; i++) {
 328                 get_registers(pegasus, PhyCtrl, 1, data);
 329                 if (data[0] & PHY_DONE)
 330                         break;
 331         }
 332         if (i < REG_TIMEOUT)
 333                 return 0;
 334         warn("%s: failed", __FUNCTION__);
 335
 336         return 1;
 337 }
 338
 339 static void mdio_write(struct net_device *dev, int phy_id, int loc, int val)
 340 {
 341         pegasus_t *pegasus = (pegasus_t *) dev->priv;
 342
 343         write_mii_word(pegasus, phy_id, loc, val);
 344 }
 345
 346 static int read_eprom_word(pegasus_t * pegasus, __u8 index, __u16 * retdata)
 347 {
 348         int i;
 349         __u8 tmp;
 350         __u16 retdatai;
 351
 352         set_register(pegasus, EpromCtrl, 0);
 353         set_register(pegasus, EpromOffset, index);
 354         set_register(pegasus, EpromCtrl, EPROM_READ);
 355
 356         for (i = 0; i < REG_TIMEOUT; i++) {
 357                 get_registers(pegasus, EpromCtrl, 1, &tmp);
 358                 if (tmp & EPROM_DONE)
 359                         break;
 360         }
 361         if (i < REG_TIMEOUT) {
 362                 get_registers(pegasus, EpromData, 2, &retdatai);
 363                 *retdata = le16_to_cpu(retdatai);
 364                 return 0;
 365         }
 366         warn("%s: failed", __FUNCTION__);
 367
 368         return -1;
 369 }
 370
 371 #ifdef  PEGASUS_WRITE_EEPROM
 372 static inline void enable_eprom_write(pegasus_t * pegasus)
 373 {
 374         __u8 tmp;
 375
 376         get_registers(pegasus, EthCtrl2, 1, &tmp);
 377         set_register(pegasus, EthCtrl2, tmp | EPROM_WR_ENABLE);
 378 }
 379
 380 static inline void disable_eprom_write(pegasus_t * pegasus)
 381 {
 382         __u8 tmp;
 383
 384         get_registers(pegasus, EthCtrl2, 1, &tmp);
 385         set_register(pegasus, EpromCtrl, 0);
 386         set_register(pegasus, EthCtrl2, tmp & ~EPROM_WR_ENABLE);
 387 }
 388
 389 static int write_eprom_word(pegasus_t * pegasus, __u8 index, __u16 data)
 390 {
 391         int i, tmp;
 392         __u8 d[4] = { 0x3f, 0, 0, EPROM_WRITE };
 393
 394         set_registers(pegasus, EpromOffset, 4, d);
 395         enable_eprom_write(pegasus);
 396         set_register(pegasus, EpromOffset, index);
 397         set_registers(pegasus, EpromData, 2, &data);
 398         set_register(pegasus, EpromCtrl, EPROM_WRITE);
 399
 400         for (i = 0; i < REG_TIMEOUT; i++) {
 401                 get_registers(pegasus, EpromCtrl, 1, &tmp);
 402                 if (tmp & EPROM_DONE)
 403                         break;
 404         }
 405         disable_eprom_write(pegasus);
 406         if (i < REG_TIMEOUT)
 407                 return 0;
 408         warn("%s: failed", __FUNCTION__);
 409         return -1;
 410 }
 411 #endif                          /* PEGASUS_WRITE_EEPROM */
 412
 413 static inline void get_node_id(pegasus_t * pegasus, __u8 * id)
 414 {
 415         int i;
 416         __u16 w16;
 417
 418         for (i = 0; i < 3; i++) {
 419                 read_eprom_word(pegasus, i, &w16);
 420                 ((__u16 *) id)[i] = cpu_to_le16p(&w16);
 421         }
 422 }
 423
 424 static void set_ethernet_addr(pegasus_t * pegasus)
 425 {
 426         __u8 node_id[6];
 427
 428         get_node_id(pegasus, node_id);
 429         set_registers(pegasus, EthID, sizeof (node_id), node_id);
 430         memcpy(pegasus->net->dev_addr, node_id, sizeof (node_id));
 431 }
 432
 433 static inline int reset_mac(pegasus_t * pegasus)
 434 {
 435         __u8 data = 0x8;
 436         int i;
 437
 438         set_register(pegasus, EthCtrl1, data);
 439         for (i = 0; i < REG_TIMEOUT; i++) {
 440                 get_registers(pegasus, EthCtrl1, 1, &data);
 441                 if (~data & 0x08) {
 442                         if (loopback & 1)
 443                                 break;
 444                         if (mii_mode && (pegasus->features & HAS_HOME_PNA))
 445                                 set_register(pegasus, Gpio1, 0x34);
 446                         else
 447                                 set_register(pegasus, Gpio1, 0x26);
 448                         set_register(pegasus, Gpio0, pegasus->features);
 449                         set_register(pegasus, Gpio0, DEFAULT_GPIO_SET);
 450                         break;
 451                 }
 452         }
 453         if (i == REG_TIMEOUT)
 454                 return 1;
 455
 456         if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
 457             usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
 458                 set_register(pegasus, Gpio0, 0x24);
 459                 set_register(pegasus, Gpio0, 0x26);
 460         }
 461         if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_ELCON) {
 462                 __u16 auxmode;
 463                 read_mii_word(pegasus, 3, 0x1b, &auxmode);
 464                 write_mii_word(pegasus, 3, 0x1b, auxmode | 4);
 465         }
 466
 467         return 0;
 468 }
 469
 470 static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
 471 {
 472         __u16 linkpart;
 473         __u8 data[4];
 474         pegasus_t *pegasus = dev->priv;
 475
 476         read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
 477         data[0] = 0xc9;
 478         data[1] = 0;
 479         if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
 480                 data[1] |= 0x20;        /* set full duplex */
 481         if (linkpart & (ADVERTISE_100FULL | ADVERTISE_100HALF))
 482                 data[1] |= 0x10;        /* set 100 Mbps */
 483         if (mii_mode)
 484                 data[1] = 0;
 485         data[2] = (loopback & 1) ? 0x09 : 0x01;
 486
 487         memcpy(pegasus->eth_regs, data, sizeof (data));
 488         set_registers(pegasus, EthCtrl0, 3, data);
 489
 490         if (usb_dev_id[pegasus->dev_index].vendor == VENDOR_LINKSYS ||
 491             usb_dev_id[pegasus->dev_index].vendor == VENDOR_DLINK) {
 492                 u16 auxmode;
 493                 read_mii_word(pegasus, 0, 0x1b, &auxmode);
 494                 write_mii_word(pegasus, 0, 0x1b, auxmode | 4);
 495         }
 496
 497         return 0;
 498 }
 499
 500 static void fill_skb_pool(pegasus_t * pegasus)
 501 {
 502         int i;
 503
 504         for (i = 0; i < RX_SKBS; i++) {
 505                 if (pegasus->rx_pool[i])
 506                         continue;
 507                 pegasus->rx_pool[i] = dev_alloc_skb(PEGASUS_MTU + 2);
 508                 /*
 509                  ** we give up if the allocation fail. the tasklet will be
 510                  ** rescheduled again anyway...
 511                  */
 512                 if (pegasus->rx_pool[i] == NULL)
 513                         return;
 514                 pegasus->rx_pool[i]->dev = pegasus->net;
 515                 skb_reserve(pegasus->rx_pool[i], 2);
 516         }
 517 }
 518
 519 static void free_skb_pool(pegasus_t * pegasus)
 520 {
 521         int i;
 522
 523         for (i = 0; i < RX_SKBS; i++) {
 524                 if (pegasus->rx_pool[i]) {
 525                         dev_kfree_skb(pegasus->rx_pool[i]);
 526                         pegasus->rx_pool[i] = NULL;
 527                 }
 528         }
 529 }
 530
 531 static inline struct sk_buff *pull_skb(pegasus_t * pegasus)
 532 {
 533         int i;
 534         struct sk_buff *skb;
 535
 536         for (i = 0; i < RX_SKBS; i++) {
 537                 if (likely(pegasus->rx_pool[i] != NULL)) {
 538                         skb = pegasus->rx_pool[i];
 539                         pegasus->rx_pool[i] = NULL;
 540                         return skb;
 541                 }
 542         }
 543         return NULL;
 544 }
 545
 546 static void read_bulk_callback(struct urb *urb, struct pt_regs *regs)
 547 {
 548         pegasus_t *pegasus = urb->context;
 549         struct net_device *net;
 550         int rx_status, count = urb->actual_length;
 551         __u16 pkt_len;
 552
 553         if (!pegasus || !(pegasus->flags & PEGASUS_RUNNING))
 554                 return;
 555
 556         net = pegasus->net;
 557         if (!netif_device_present(net))
 558                 return;
 559
 560         switch (urb->status) {
 561         case 0:
 562                 break;
 563         case -ETIMEDOUT:
 564                 dbg("%s: reset MAC", net->name);
 565                 pegasus->flags &= ~PEGASUS_RX_BUSY;
 566                 break;
 567         case -EPIPE:            /* stall, or disconnect from TT */
 568                 /* FIXME schedule work to clear the halt */
 569                 warn("%s: no rx stall recovery", net->name);
 570                 return;
 571         case -ENOENT:
 572         case -ECONNRESET:
 573         case -ESHUTDOWN:
 574                 dbg("%s: rx unlink, %d", net->name, urb->status);
 575                 return;
 576         default:
 577                 dbg("%s: RX status %d", net->name, urb->status);
 578                 goto goon;
 579         }
 580
 581         if (!count)
 582                 goto goon;
 583
 584         rx_status = le32_to_cpu(*(int *) (urb->transfer_buffer + count - 4));
 585         if (rx_status & 0x000e0000) {
 586                 dbg("%s: RX packet error %x", net->name, rx_status & 0xe0000);
 587                 pegasus->stats.rx_errors++;
 588                 if (rx_status & 0x060000)
 589                         pegasus->stats.rx_length_errors++;
 590                 if (rx_status & 0x080000)
 591                         pegasus->stats.rx_crc_errors++;
 592                 if (rx_status & 0x100000)
 593                         pegasus->stats.rx_frame_errors++;
 594                 goto goon;
 595         }
 596         if (pegasus->chip == 0x8513) {
 597                 pkt_len = le32_to_cpu(*(int *)urb->transfer_buffer);
 598                 pkt_len &= 0x0fff;
 599                 pegasus->rx_skb->data += 2;
 600         } else {
 601                 pkt_len = (rx_status & 0xfff) - 8;
 602         }
 603
 604         /*
 605          * at this point we are sure pegasus->rx_skb != NULL
 606          * so we go ahead and pass up the packet.
 607          */
 608         skb_put(pegasus->rx_skb, pkt_len);
 609         pegasus->rx_skb->protocol = eth_type_trans(pegasus->rx_skb, net);
 610         netif_rx(pegasus->rx_skb);
 611         pegasus->stats.rx_packets++;
 612         pegasus->stats.rx_bytes += pkt_len;
 613
 614         if (pegasus->flags & PEGASUS_UNPLUG)
 615                 return;
 616
 617         spin_lock(&pegasus->rx_pool_lock);
 618         pegasus->rx_skb = pull_skb(pegasus);
 619         spin_unlock(&pegasus->rx_pool_lock);
 620
 621         if (pegasus->rx_skb == NULL)
 622                 goto tl_sched;
 623 goon:
 624         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
 625                           usb_rcvbulkpipe(pegasus->usb, 1),
 626                           pegasus->rx_skb->data, PEGASUS_MTU + 8,
 627                           read_bulk_callback, pegasus);
 628         if (usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC)) {
 629                 pegasus->flags |= PEGASUS_RX_URB_FAIL;
 630                 goto tl_sched;
 631         } else {
 632                 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
 633         }
 634
 635         return;
 636
 637       tl_sched:
 638         tasklet_schedule(&pegasus->rx_tl);
 639 }
 640
 641 static void rx_fixup(unsigned long data)
 642 {
 643         pegasus_t *pegasus;
 644         unsigned long flags;
 645
 646         pegasus = (pegasus_t *) data;
 647         if (pegasus->flags & PEGASUS_UNPLUG)
 648                 return;
 649
 650         spin_lock_irqsave(&pegasus->rx_pool_lock, flags);
 651         fill_skb_pool(pegasus);
 652         if (pegasus->flags & PEGASUS_RX_URB_FAIL)
 653                 if (pegasus->rx_skb)
 654                         goto try_again;
 655         if (pegasus->rx_skb == NULL) {
 656                 pegasus->rx_skb = pull_skb(pegasus);
 657         }
 658         if (pegasus->rx_skb == NULL) {
 659                 warn("wow, low on memory");
 660                 tasklet_schedule(&pegasus->rx_tl);
 661                 goto done;
 662         }
 663         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
 664                           usb_rcvbulkpipe(pegasus->usb, 1),
 665                           pegasus->rx_skb->data, PEGASUS_MTU + 8,
 666                           read_bulk_callback, pegasus);
 667 try_again:
 668         if (usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC)) {
 669                 pegasus->flags |= PEGASUS_RX_URB_FAIL;
 670                 tasklet_schedule(&pegasus->rx_tl);
 671         } else {
 672                 pegasus->flags &= ~PEGASUS_RX_URB_FAIL;
 673         }
 674 done:
 675         spin_unlock_irqrestore(&pegasus->rx_pool_lock, flags);
 676 }
 677
 678 static void write_bulk_callback(struct urb *urb, struct pt_regs *regs)
 679 {
 680         pegasus_t *pegasus = urb->context;
 681         struct net_device *net = pegasus->net;
 682
 683         if (!pegasus || !(pegasus->flags & PEGASUS_RUNNING))
 684                 return;
 685
 686         if (!netif_device_present(net))
 687                 return;
 688
 689         switch (urb->status) {
 690         case -EPIPE:
 691                 /* FIXME schedule_work() to clear the tx halt */
 692                 netif_stop_queue(net);
 693                 warn("%s: no tx stall recovery", net->name);
 694                 return;
 695         case -ENOENT:
 696         case -ECONNRESET:
 697         case -ESHUTDOWN:
 698                 dbg("%s: tx unlink, %d", net->name, urb->status);
 699                 return;
 700         default:
 701                 info("%s: TX status %d", net->name, urb->status);
 702                 /* FALL THROUGH */
 703         case 0:
 704                 break;
 705         }
 706
 707         net->trans_start = jiffies;
 708         netif_wake_queue(net);
 709 }
 710
 711 static void intr_callback(struct urb *urb, struct pt_regs *regs)
 712 {
 713         pegasus_t *pegasus = urb->context;
 714         struct net_device *net;
 715         __u8 *d;
 716         int status;
 717
 718         if (!pegasus)
 719                 return;
 720
 721         switch (urb->status) {
 722         case 0:
 723                 break;
 724         case -ECONNRESET:       /* unlink */
 725         case -ENOENT:
 726         case -ESHUTDOWN:
 727                 return;
 728         default:
 729                 info("intr status %d", urb->status);
 730         }
 731
 732         d = urb->transfer_buffer;
 733         net = pegasus->net;
 734         if (d[0] & 0xfc) {
 735                 pegasus->stats.tx_errors++;
 736                 if (d[0] & TX_UNDERRUN)
 737                         pegasus->stats.tx_fifo_errors++;
 738                 if (d[0] & (EXCESSIVE_COL | JABBER_TIMEOUT))
 739                         pegasus->stats.tx_aborted_errors++;
 740                 if (d[0] & LATE_COL)
 741                         pegasus->stats.tx_window_errors++;
 742                 if (d[5] & LINK_STATUS) {
 743                         netif_carrier_on(net);
 744                 } else {
 745                         pegasus->stats.tx_carrier_errors++;
 746                         netif_carrier_off(net);
 747                 }
 748         }
 749
 750         status = usb_submit_urb(urb, SLAB_ATOMIC);
 751         if (status)
 752                 err("%s: can't resubmit interrupt urb, %d", net->name, status);
 753 }
 754
 755 static void pegasus_tx_timeout(struct net_device *net)
 756 {
 757         pegasus_t *pegasus = net->priv;
 758
 759         if (!pegasus)
 760                 return;
 761
 762         warn("%s: Tx timed out.", net->name);
 763         pegasus->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 764         usb_unlink_urb(pegasus->tx_urb);
 765         pegasus->stats.tx_errors++;
 766 }
 767
 768 static int pegasus_start_xmit(struct sk_buff *skb, struct net_device *net)
 769 {
 770         pegasus_t *pegasus = net->priv;
 771         int count = ((skb->len + 2) & 0x3f) ? skb->len + 2 : skb->len + 3;
 772         int res;
 773         __u16 l16 = skb->len;
 774
 775         netif_stop_queue(net);
 776
 777         ((__u16 *) pegasus->tx_buff)[0] = cpu_to_le16(l16);
 778         memcpy(pegasus->tx_buff + 2, skb->data, skb->len);
 779         usb_fill_bulk_urb(pegasus->tx_urb, pegasus->usb,
 780                           usb_sndbulkpipe(pegasus->usb, 2),
 781                           pegasus->tx_buff, count,
 782                           write_bulk_callback, pegasus);
 783         if ((res = usb_submit_urb(pegasus->tx_urb, GFP_ATOMIC))) {
 784                 warn("failed tx_urb %d", res);
 785                 switch (res) {
 786                 case -EPIPE:            /* stall, or disconnect from TT */
 787                         /* cleanup should already have been scheduled */
 788                         break;
 789                 case -ENODEV:           /* disconnect() upcoming */
 790                         break;
 791                 default:
 792                         pegasus->stats.tx_errors++;
 793                         netif_start_queue(net);
 794                 }
 795         } else {
 796                 pegasus->stats.tx_packets++;
 797                 pegasus->stats.tx_bytes += skb->len;
 798                 net->trans_start = jiffies;
 799         }
 800         dev_kfree_skb(skb);
 801
 802         return 0;
 803 }
 804
 805 static struct net_device_stats *pegasus_netdev_stats(struct net_device *dev)
 806 {
 807         return &((pegasus_t *) dev->priv)->stats;
 808 }
 809
 810 static inline void disable_net_traffic(pegasus_t * pegasus)
 811 {
 812         int tmp = 0;
 813
 814         set_registers(pegasus, EthCtrl0, 2, &tmp);
 815 }
 816
 817 static inline void get_interrupt_interval(pegasus_t * pegasus)
 818 {
 819         __u8 data[2];
 820
 821         read_eprom_word(pegasus, 4, (__u16 *) data);
 822         if (data[1] < 0x80) {
 823                 info("intr interval will be changed from %ums to %ums",
 824                      data[1], 0x80);
 825                 data[1] = 0x80;
 826 #ifdef  PEGASUS_WRITE_EEPROM
 827                 write_eprom_word(pegasus, 4, *(__u16 *) data);
 828 #endif
 829         }
 830         pegasus->intr_interval = data[1];
 831 }
 832
 833 static void set_carrier(struct net_device *net)
 834 {
 835         pegasus_t *pegasus;
 836         short tmp;
 837
 838         pegasus = net->priv;
 839         read_mii_word(pegasus, pegasus->phy, MII_BMSR, &tmp);
 840         if (tmp & BMSR_LSTATUS)
 841                 netif_carrier_on(net);
 842         else
 843                 netif_carrier_off(net);
 844
 845 }
 846
 847 static void free_all_urbs(pegasus_t * pegasus)
 848 {
 849         usb_free_urb(pegasus->intr_urb);
 850         usb_free_urb(pegasus->tx_urb);
 851         usb_free_urb(pegasus->rx_urb);
 852         usb_free_urb(pegasus->ctrl_urb);
 853 }
 854
 855 static void unlink_all_urbs(pegasus_t * pegasus)
 856 {
 857         usb_unlink_urb(pegasus->intr_urb);
 858         usb_unlink_urb(pegasus->tx_urb);
 859         usb_unlink_urb(pegasus->rx_urb);
 860         usb_unlink_urb(pegasus->ctrl_urb);
 861 }
 862
 863 static int alloc_urbs(pegasus_t * pegasus)
 864 {
 865         pegasus->ctrl_urb = usb_alloc_urb(0, GFP_KERNEL);
 866         if (!pegasus->ctrl_urb) {
 867                 return 0;
 868         }
 869         pegasus->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 870         if (!pegasus->rx_urb) {
 871                 usb_free_urb(pegasus->ctrl_urb);
 872                 return 0;
 873         }
 874         pegasus->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
 875         if (!pegasus->tx_urb) {
 876                 usb_free_urb(pegasus->rx_urb);
 877                 usb_free_urb(pegasus->ctrl_urb);
 878                 return 0;
 879         }
 880         pegasus->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
 881         if (!pegasus->intr_urb) {
 882                 usb_free_urb(pegasus->tx_urb);
 883                 usb_free_urb(pegasus->rx_urb);
 884                 usb_free_urb(pegasus->ctrl_urb);
 885                 return 0;
 886         }
 887
 888         return 1;
 889 }
 890
 891 static int pegasus_open(struct net_device *net)
 892 {
 893         pegasus_t *pegasus = (pegasus_t *) net->priv;
 894         int res;
 895
 896         if (pegasus->rx_skb == NULL)
 897                 pegasus->rx_skb = pull_skb(pegasus);
 898         /*
 899          ** Note: no point to free the pool.  it is empty :-)
 900          */
 901         if (!pegasus->rx_skb)
 902                 return -ENOMEM;
 903
 904         set_registers(pegasus, EthID, 6, net->dev_addr);
 905
 906         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
 907                           usb_rcvbulkpipe(pegasus->usb, 1),
 908                           pegasus->rx_skb->data, PEGASUS_MTU + 8,
 909                           read_bulk_callback, pegasus);
 910         if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL)))
 911                 warn("%s: failed rx_urb %d", __FUNCTION__, res);
 912         usb_fill_int_urb(pegasus->intr_urb, pegasus->usb,
 913                          usb_rcvintpipe(pegasus->usb, 3),
 914                          pegasus->intr_buff, sizeof (pegasus->intr_buff),
 915                          intr_callback, pegasus, pegasus->intr_interval);
 916         if ((res = usb_submit_urb(pegasus->intr_urb, GFP_KERNEL)))
 917                 warn("%s: failed intr_urb %d", __FUNCTION__, res);
 918         netif_start_queue(net);
 919         pegasus->flags |= PEGASUS_RUNNING;
 920         if ((res = enable_net_traffic(net, pegasus->usb))) {
 921                 err("can't enable_net_traffic() - %d", res);
 922                 res = -EIO;
 923                 usb_unlink_urb(pegasus->rx_urb);
 924                 usb_unlink_urb(pegasus->intr_urb);
 925                 free_skb_pool(pegasus);
 926                 goto exit;
 927         }
 928         set_carrier(net);
 929         res = 0;
 930 exit:
 931         return res;
 932 }
 933
 934 static int pegasus_close(struct net_device *net)
 935 {
 936         pegasus_t *pegasus = net->priv;
 937
 938         pegasus->flags &= ~PEGASUS_RUNNING;
 939         netif_stop_queue(net);
 940         if (!(pegasus->flags & PEGASUS_UNPLUG))
 941                 disable_net_traffic(pegasus);
 942         tasklet_kill(&pegasus->rx_tl);
 943         unlink_all_urbs(pegasus);
 944
 945         return 0;
 946 }
 947 #ifdef  CONFIG_MII
 948 static int pegasus_ethtool_ioctl(struct net_device *dev, void __user *useraddr)
 949 {
 950
 951         u32 ethcmd;
 952         pegasus_t *pegasus = dev->priv;
 953
 954         if (copy_from_user(&ethcmd, useraddr, sizeof (ethcmd)))
 955                 return -EFAULT;
 956
 957         switch (ethcmd) {
 958         /* get driver-specific version/etc. info */
 959         case ETHTOOL_GDRVINFO:{
 960                         struct ethtool_drvinfo info;
 961                         memset (&info, 0, sizeof (info));
 962                         info.cmd = ETHTOOL_GDRVINFO;
 963                         strncpy(info.driver, driver_name,
 964                                 sizeof (info.driver) - 1);
 965                         strncpy(info.version, DRIVER_VERSION,
 966                                 sizeof (info.version) - 1);
 967                         usb_make_path(pegasus->usb, info.bus_info,
 968                                       sizeof (info.bus_info));
 969                         if (copy_to_user(useraddr, &info, sizeof (info)))
 970                                 return -EFAULT;
 971                         return 0;
 972                 }
 973
 974         /* get settings */
 975         case ETHTOOL_GSET:{
 976                         struct ethtool_cmd ecmd = { ETHTOOL_GSET };
 977                         mii_ethtool_gset(&pegasus->mii, &ecmd);
 978                         if (copy_to_user(useraddr, &ecmd, sizeof (ecmd)))
 979                                 return -EFAULT;
 980                         return 0;
 981                 }
 982         /* set settings */
 983         case ETHTOOL_SSET:{
 984                         int r;
 985                         struct ethtool_cmd ecmd;
 986                         if (copy_from_user(&ecmd, useraddr, sizeof (ecmd)))
 987                                 return -EFAULT;
 988                         r = mii_ethtool_sset(&pegasus->mii, &ecmd);
 989                         return r;
 990                 }
 991         /* restart autonegotiation */
 992         case ETHTOOL_NWAY_RST:{
 993                         return mii_nway_restart(&pegasus->mii);
 994                 }
 995
 996         /* get link status */
 997         case ETHTOOL_GLINK:{
 998                         struct ethtool_value edata = { ETHTOOL_GLINK };
 999                         edata.data = mii_link_ok(&pegasus->mii);
1000                         if (copy_to_user(useraddr, &edata, sizeof (edata)))
1001                                 return -EFAULT;
1002                         return 0;
1003                 }
1004         /* get message-level */
1005         case ETHTOOL_GMSGLVL:{
1006                         struct ethtool_value edata = { ETHTOOL_GMSGLVL };
1007                         /* edata.data = pegasus->msg_enable; FIXME */
1008                         if (copy_to_user(useraddr, &edata, sizeof (edata)))
1009                                 return -EFAULT;
1010                         return 0;
1011                 }
1012         /* set message-level */
1013         case ETHTOOL_SMSGLVL:{
1014                         struct ethtool_value edata;
1015                         if (copy_from_user(&edata, useraddr, sizeof (edata)))
1016                                 return -EFAULT;
1017                         /* sp->msg_enable = edata.data; FIXME */
1018                         return 0;
1019                 }
1020
1021         }
1022
1023         return -EOPNOTSUPP;
1024
1025 }
1026 #else
1027 static int pegasus_ethtool_ioctl(struct net_device *net, void __user *uaddr)
1028 {
1029         pegasus_t *pegasus;
1030         int cmd;
1031
1032         pegasus = net->priv;
1033         if (get_user(cmd, (int __user *) uaddr))
1034                 return -EFAULT;
1035         switch (cmd) {
1036         case ETHTOOL_GDRVINFO:{
1037                         struct ethtool_drvinfo info;
1038                         memset (&info, 0, sizeof (info));
1039                         info.cmd = ETHTOOL_GDRVINFO;
1040                         strncpy(info.driver, driver_name,
1041                                 sizeof (info.driver) - 1);
1042                         strncpy(info.version, DRIVER_VERSION,
1043                                 sizeof (info.version) - 1);
1044                         usb_make_path(pegasus->usb, info.bus_info,
1045                                       sizeof (info.bus_info));
1046                         if (copy_to_user(uaddr, &info, sizeof (info)))
1047                                 return -EFAULT;
1048                         return 0;
1049                 }
1050         case ETHTOOL_GSET:{
1051                         struct ethtool_cmd ecmd;
1052                         short lpa, bmcr;
1053                         u8 port;
1054
1055                         memset(&ecmd, 0, sizeof (ecmd));
1056                         ecmd.supported = (SUPPORTED_10baseT_Half |
1057                                           SUPPORTED_10baseT_Full |
1058                                           SUPPORTED_100baseT_Half |
1059                                           SUPPORTED_100baseT_Full |
1060                                           SUPPORTED_Autoneg |
1061                                           SUPPORTED_TP | SUPPORTED_MII);
1062                         get_registers(pegasus, Reg7b, 1, &port);
1063                         if (port == 0)
1064                                 ecmd.port = PORT_MII;
1065                         else
1066                                 ecmd.port = PORT_TP;
1067                         ecmd.transceiver = XCVR_INTERNAL;
1068                         ecmd.phy_address = pegasus->phy;
1069                         read_mii_word(pegasus, pegasus->phy, MII_BMCR, &bmcr);
1070                         read_mii_word(pegasus, pegasus->phy, MII_LPA, &lpa);
1071                         if (bmcr & BMCR_ANENABLE) {
1072                                 ecmd.autoneg = AUTONEG_ENABLE;
1073                                 ecmd.speed = lpa & (LPA_100HALF | LPA_100FULL) ?
1074                                     SPEED_100 : SPEED_10;
1075                                 if (ecmd.speed == SPEED_100)
1076                                         ecmd.duplex = lpa & LPA_100FULL ?
1077                                             DUPLEX_FULL : DUPLEX_HALF;
1078                                 else
1079                                         ecmd.duplex = lpa & LPA_10FULL ?
1080                                             DUPLEX_FULL : DUPLEX_HALF;
1081                         } else {
1082                                 ecmd.autoneg = AUTONEG_DISABLE;
1083                                 ecmd.speed = bmcr & BMCR_SPEED100 ?
1084                                     SPEED_100 : SPEED_10;
1085                                 ecmd.duplex = bmcr & BMCR_FULLDPLX ?
1086                                     DUPLEX_FULL : DUPLEX_HALF;
1087                         }
1088                         if (copy_to_user(uaddr, &ecmd, sizeof (ecmd)))
1089                                 return -EFAULT;
1090
1091                         return 0;
1092                 }
1093         case ETHTOOL_SSET:{
1094                         return -EOPNOTSUPP;
1095                 }
1096         case ETHTOOL_GLINK:{
1097                         struct ethtool_value edata = { ETHTOOL_GLINK };
1098                         edata.data = netif_carrier_ok(net);
1099                         if (copy_to_user(uaddr, &edata, sizeof (edata)))
1100                                 return -EFAULT;
1101                         return 0;
1102                 }
1103         default:
1104                 return -EOPNOTSUPP;
1105         }
1106 }
1107 #endif
1108 static int pegasus_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
1109 {
1110         __u16 *data = (__u16 *) & rq->ifr_ifru;
1111         pegasus_t *pegasus = net->priv;
1112         int res;
1113
1114         switch (cmd) {
1115         case SIOCETHTOOL:
1116                 res = pegasus_ethtool_ioctl(net, rq->ifr_data);
1117                 break;
1118         case SIOCDEVPRIVATE:
1119                 data[0] = pegasus->phy;
1120         case SIOCDEVPRIVATE + 1:
1121                 read_mii_word(pegasus, data[0], data[1] & 0x1f, &data[3]);
1122                 res = 0;
1123                 break;
1124         case SIOCDEVPRIVATE + 2:
1125                 if (!capable(CAP_NET_ADMIN))
1126                         return -EPERM;
1127                 write_mii_word(pegasus, pegasus->phy, data[1] & 0x1f, data[2]);
1128                 res = 0;
1129                 break;
1130         default:
1131                 res = -EOPNOTSUPP;
1132         }
1133         return res;
1134 }
1135
1136 static void pegasus_set_multicast(struct net_device *net)
1137 {
1138         pegasus_t *pegasus = net->priv;
1139
1140         netif_stop_queue(net);
1141
1142         if (net->flags & IFF_PROMISC) {
1143                 pegasus->eth_regs[EthCtrl2] |= RX_PROMISCUOUS;
1144                 info("%s: Promiscuous mode enabled", net->name);
1145         } else if ((net->mc_count > multicast_filter_limit) ||
1146                    (net->flags & IFF_ALLMULTI)) {
1147                 pegasus->eth_regs[EthCtrl0] |= RX_MULTICAST;
1148                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1149                 info("%s set allmulti", net->name);
1150         } else {
1151                 pegasus->eth_regs[EthCtrl0] &= ~RX_MULTICAST;
1152                 pegasus->eth_regs[EthCtrl2] &= ~RX_PROMISCUOUS;
1153         }
1154
1155         pegasus->flags |= ETH_REGS_CHANGE;
1156         ctrl_callback(pegasus->ctrl_urb, NULL);
1157
1158         netif_wake_queue(net);
1159 }
1160
1161 static __u8 mii_phy_probe(pegasus_t * pegasus)
1162 {
1163         int i;
1164         __u16 tmp;
1165
1166         for (i = 0; i < 32; i++) {
1167                 read_mii_word(pegasus, i, MII_BMSR, &tmp);
1168                 if (tmp == 0 || tmp == 0xffff || (tmp & BMSR_MEDIA) == 0)
1169                         continue;
1170                 else
1171                         return i;
1172         }
1173
1174         return 0xff;
1175 }
1176
1177 static inline void setup_pegasus_II(pegasus_t * pegasus)
1178 {
1179         u16 data = 0xa5;
1180
1181         set_register(pegasus, Reg1d, 0);
1182         set_register(pegasus, Reg7b, 1);
1183         mdelay(100);
1184         if ((pegasus->features & HAS_HOME_PNA) && mii_mode)
1185                 set_register(pegasus, Reg7b, 0);
1186         else
1187                 set_register(pegasus, Reg7b, 2);
1188
1189         set_register(pegasus, 0x83, data);
1190         get_registers(pegasus, 0x83, 1, &data);
1191
1192         if (data == 0xa5) {
1193                 pegasus->chip = 0x8513;
1194         } else {
1195                 pegasus->chip = 0;
1196         }
1197
1198         set_register(pegasus, 0x80, 0xc0);
1199         set_register(pegasus, 0x83, 0xff);
1200         set_register(pegasus, 0x84, 0x01);
1201
1202         if (pegasus->features & HAS_HOME_PNA && mii_mode)
1203                 set_register(pegasus, Reg81, 6);
1204         else
1205                 set_register(pegasus, Reg81, 2);
1206 }
1207
1208 static int pegasus_probe(struct usb_interface *intf,
1209                          const struct usb_device_id *id)
1210 {
1211         struct usb_device *dev = interface_to_usbdev(intf);
1212         struct net_device *net;
1213         pegasus_t *pegasus;
1214         int dev_index = id - pegasus_ids;
1215         int res = -ENOMEM;
1216
1217         usb_get_dev(dev);
1218         if (!(pegasus = kmalloc(sizeof (struct pegasus), GFP_KERNEL))) {
1219                 err("out of memory allocating device structure");
1220                 goto out;
1221         }
1222
1223         memset(pegasus, 0, sizeof (struct pegasus));
1224         pegasus->dev_index = dev_index;
1225         init_waitqueue_head(&pegasus->ctrl_wait);
1226
1227         if (!alloc_urbs(pegasus))
1228                 goto out1;
1229
1230         net = alloc_etherdev(0);
1231         if (!net)
1232                 goto out2;
1233
1234         tasklet_init(&pegasus->rx_tl, rx_fixup, (unsigned long) pegasus);
1235
1236         pegasus->usb = dev;
1237         pegasus->net = net;
1238         SET_MODULE_OWNER(net);
1239         net->priv = pegasus;
1240         net->open = pegasus_open;
1241         net->stop = pegasus_close;
1242         net->watchdog_timeo = PEGASUS_TX_TIMEOUT;
1243         net->tx_timeout = pegasus_tx_timeout;
1244         net->do_ioctl = pegasus_ioctl;
1245         net->hard_start_xmit = pegasus_start_xmit;
1246         net->set_multicast_list = pegasus_set_multicast;
1247         net->get_stats = pegasus_netdev_stats;
1248         net->mtu = PEGASUS_MTU;
1249         pegasus->mii.dev = net;
1250         pegasus->mii.mdio_read = mdio_read;
1251         pegasus->mii.mdio_write = mdio_write;
1252         pegasus->mii.phy_id_mask = 0x1f;
1253         pegasus->mii.reg_num_mask = 0x1f;
1254         spin_lock_init(&pegasus->rx_pool_lock);
1255
1256         pegasus->features = usb_dev_id[dev_index].private;
1257         get_interrupt_interval(pegasus);
1258         if (reset_mac(pegasus)) {
1259                 err("can't reset MAC");
1260                 res = -EIO;
1261                 goto out3;
1262         }
1263         set_ethernet_addr(pegasus);
1264         fill_skb_pool(pegasus);
1265         if (pegasus->features & PEGASUS_II) {
1266                 info("setup Pegasus II specific registers");
1267                 setup_pegasus_II(pegasus);
1268         }
1269         pegasus->phy = mii_phy_probe(pegasus);
1270         if (pegasus->phy == 0xff) {
1271                 warn("can't locate MII phy, using default");
1272                 pegasus->phy = 1;
1273         }
1274         usb_set_intfdata(intf, pegasus);
1275         SET_NETDEV_DEV(net, &intf->dev);
1276         res = register_netdev(net);
1277         if (res)
1278                 goto out4;
1279         printk("%s: %s\n", net->name, usb_dev_id[dev_index].name);
1280         return 0;
1281
1282 out4:
1283         usb_set_intfdata(intf, NULL);
1284         free_skb_pool(pegasus);
1285 out3:
1286         free_netdev(net);
1287 out2:
1288         free_all_urbs(pegasus);
1289 out1:
1290         kfree(pegasus);
1291 out:
1292         usb_put_dev(dev);
1293         return res;
1294 }
1295
1296 static void pegasus_disconnect(struct usb_interface *intf)
1297 {
1298         struct pegasus *pegasus = usb_get_intfdata(intf);
1299
1300         usb_set_intfdata(intf, NULL);
1301         if (!pegasus) {
1302                 warn("unregistering non-existant device");
1303                 return;
1304         }
1305
1306         pegasus->flags |= PEGASUS_UNPLUG;
1307         unregister_netdev(pegasus->net);
1308         usb_put_dev(interface_to_usbdev(intf));
1309         free_all_urbs(pegasus);
1310         free_skb_pool(pegasus);
1311         if (pegasus->rx_skb)
1312                 dev_kfree_skb(pegasus->rx_skb);
1313         free_netdev(pegasus->net);
1314         kfree(pegasus);
1315 }
1316
1317 static struct usb_driver pegasus_driver = {
1318         .name = driver_name,
1319         .probe = pegasus_probe,
1320         .disconnect = pegasus_disconnect,
1321         .id_table = pegasus_ids,
1322 };
1323
1324 static int __init pegasus_init(void)
1325 {
1326         info(DRIVER_VERSION ":" DRIVER_DESC);
1327         return usb_register(&pegasus_driver);
1328 }
1329
1330 static void __exit pegasus_exit(void)
1331 {
1332         usb_deregister(&pegasus_driver);
1333 }
1334
1335 module_init(pegasus_init);
1336 module_exit(pegasus_exit);