drivers/net/usb/pegasus.c

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