Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
0004  */
0005 
0006 #include <linux/signal.h>
0007 #include <linux/slab.h>
0008 #include <linux/module.h>
0009 #include <linux/netdevice.h>
0010 #include <linux/etherdevice.h>
0011 #include <linux/mii.h>
0012 #include <linux/ethtool.h>
0013 #include <linux/usb.h>
0014 #include <linux/uaccess.h>
0015 
0016 /* Version Information */
0017 #define DRIVER_VERSION "v0.6.2 (2004/08/27)"
0018 #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
0019 #define DRIVER_DESC "rtl8150 based usb-ethernet driver"
0020 
0021 #define IDR         0x0120
0022 #define MAR         0x0126
0023 #define CR          0x012e
0024 #define TCR         0x012f
0025 #define RCR         0x0130
0026 #define TSR         0x0132
0027 #define RSR         0x0133
0028 #define CON0            0x0135
0029 #define CON1            0x0136
0030 #define MSR         0x0137
0031 #define PHYADD          0x0138
0032 #define PHYDAT          0x0139
0033 #define PHYCNT          0x013b
0034 #define GPPC            0x013d
0035 #define BMCR            0x0140
0036 #define BMSR            0x0142
0037 #define ANAR            0x0144
0038 #define ANLP            0x0146
0039 #define AER         0x0148
0040 #define CSCR            0x014C  /* This one has the link status */
0041 #define CSCR_LINK_STATUS    (1 << 3)
0042 
0043 #define IDR_EEPROM      0x1202
0044 
0045 #define PHY_READ        0
0046 #define PHY_WRITE       0x20
0047 #define PHY_GO          0x40
0048 
0049 #define MII_TIMEOUT     10
0050 #define INTBUFSIZE      8
0051 
0052 #define RTL8150_REQT_READ   0xc0
0053 #define RTL8150_REQT_WRITE  0x40
0054 #define RTL8150_REQ_GET_REGS    0x05
0055 #define RTL8150_REQ_SET_REGS    0x05
0056 
0057 
0058 /* Transmit status register errors */
0059 #define TSR_ECOL        (1<<5)
0060 #define TSR_LCOL        (1<<4)
0061 #define TSR_LOSS_CRS        (1<<3)
0062 #define TSR_JBR         (1<<2)
0063 #define TSR_ERRORS      (TSR_ECOL | TSR_LCOL | TSR_LOSS_CRS | TSR_JBR)
0064 /* Receive status register errors */
0065 #define RSR_CRC         (1<<2)
0066 #define RSR_FAE         (1<<1)
0067 #define RSR_ERRORS      (RSR_CRC | RSR_FAE)
0068 
0069 /* Media status register definitions */
0070 #define MSR_DUPLEX      (1<<4)
0071 #define MSR_SPEED       (1<<3)
0072 #define MSR_LINK        (1<<2)
0073 
0074 /* Interrupt pipe data */
0075 #define INT_TSR         0x00
0076 #define INT_RSR         0x01
0077 #define INT_MSR         0x02
0078 #define INT_WAKSR       0x03
0079 #define INT_TXOK_CNT        0x04
0080 #define INT_RXLOST_CNT      0x05
0081 #define INT_CRERR_CNT       0x06
0082 #define INT_COL_CNT     0x07
0083 
0084 
0085 #define RTL8150_MTU     1540
0086 #define RTL8150_TX_TIMEOUT  (HZ)
0087 #define RX_SKB_POOL_SIZE    4
0088 
0089 /* rtl8150 flags */
0090 #define RTL8150_HW_CRC      0
0091 #define RX_REG_SET      1
0092 #define RTL8150_UNPLUG      2
0093 #define RX_URB_FAIL     3
0094 
0095 /* Define these values to match your device */
0096 #define VENDOR_ID_REALTEK       0x0bda
0097 #define VENDOR_ID_MELCO         0x0411
0098 #define VENDOR_ID_MICRONET      0x3980
0099 #define VENDOR_ID_LONGSHINE     0x07b8
0100 #define VENDOR_ID_OQO           0x1557
0101 #define VENDOR_ID_ZYXEL         0x0586
0102 
0103 #define PRODUCT_ID_RTL8150      0x8150
0104 #define PRODUCT_ID_LUAKTX       0x0012
0105 #define PRODUCT_ID_LCS8138TX        0x401a
0106 #define PRODUCT_ID_SP128AR      0x0003
0107 #define PRODUCT_ID_PRESTIGE     0x401a
0108 
0109 #undef  EEPROM_WRITE
0110 
0111 /* table of devices that work with this driver */
0112 static const struct usb_device_id rtl8150_table[] = {
0113     {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
0114     {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
0115     {USB_DEVICE(VENDOR_ID_MICRONET, PRODUCT_ID_SP128AR)},
0116     {USB_DEVICE(VENDOR_ID_LONGSHINE, PRODUCT_ID_LCS8138TX)},
0117     {USB_DEVICE(VENDOR_ID_OQO, PRODUCT_ID_RTL8150)},
0118     {USB_DEVICE(VENDOR_ID_ZYXEL, PRODUCT_ID_PRESTIGE)},
0119     {}
0120 };
0121 
0122 MODULE_DEVICE_TABLE(usb, rtl8150_table);
0123 
0124 struct rtl8150 {
0125     unsigned long flags;
0126     struct usb_device *udev;
0127     struct tasklet_struct tl;
0128     struct net_device *netdev;
0129     struct urb *rx_urb, *tx_urb, *intr_urb;
0130     struct sk_buff *tx_skb, *rx_skb;
0131     struct sk_buff *rx_skb_pool[RX_SKB_POOL_SIZE];
0132     spinlock_t rx_pool_lock;
0133     struct usb_ctrlrequest dr;
0134     int intr_interval;
0135     u8 *intr_buff;
0136     u8 phy;
0137 };
0138 
0139 typedef struct rtl8150 rtl8150_t;
0140 
0141 struct async_req {
0142     struct usb_ctrlrequest dr;
0143     u16 rx_creg;
0144 };
0145 
0146 static const char driver_name [] = "rtl8150";
0147 
0148 /*
0149 **
0150 **  device related part of the code
0151 **
0152 */
0153 static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
0154 {
0155     return usb_control_msg_recv(dev->udev, 0, RTL8150_REQ_GET_REGS,
0156                     RTL8150_REQT_READ, indx, 0, data, size,
0157                     1000, GFP_NOIO);
0158 }
0159 
0160 static int set_registers(rtl8150_t * dev, u16 indx, u16 size, const void *data)
0161 {
0162     return usb_control_msg_send(dev->udev, 0, RTL8150_REQ_SET_REGS,
0163                     RTL8150_REQT_WRITE, indx, 0, data, size,
0164                     1000, GFP_NOIO);
0165 }
0166 
0167 static void async_set_reg_cb(struct urb *urb)
0168 {
0169     struct async_req *req = (struct async_req *)urb->context;
0170     int status = urb->status;
0171 
0172     if (status < 0)
0173         dev_dbg(&urb->dev->dev, "%s failed with %d", __func__, status);
0174     kfree(req);
0175     usb_free_urb(urb);
0176 }
0177 
0178 static int async_set_registers(rtl8150_t *dev, u16 indx, u16 size, u16 reg)
0179 {
0180     int res = -ENOMEM;
0181     struct urb *async_urb;
0182     struct async_req *req;
0183 
0184     req = kmalloc(sizeof(struct async_req), GFP_ATOMIC);
0185     if (req == NULL)
0186         return res;
0187     async_urb = usb_alloc_urb(0, GFP_ATOMIC);
0188     if (async_urb == NULL) {
0189         kfree(req);
0190         return res;
0191     }
0192     req->rx_creg = cpu_to_le16(reg);
0193     req->dr.bRequestType = RTL8150_REQT_WRITE;
0194     req->dr.bRequest = RTL8150_REQ_SET_REGS;
0195     req->dr.wIndex = 0;
0196     req->dr.wValue = cpu_to_le16(indx);
0197     req->dr.wLength = cpu_to_le16(size);
0198     usb_fill_control_urb(async_urb, dev->udev,
0199                          usb_sndctrlpipe(dev->udev, 0), (void *)&req->dr,
0200                  &req->rx_creg, size, async_set_reg_cb, req);
0201     res = usb_submit_urb(async_urb, GFP_ATOMIC);
0202     if (res) {
0203         if (res == -ENODEV)
0204             netif_device_detach(dev->netdev);
0205         dev_err(&dev->udev->dev, "%s failed with %d\n", __func__, res);
0206     }
0207     return res;
0208 }
0209 
0210 static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
0211 {
0212     int i;
0213     u8 data[3], tmp;
0214 
0215     data[0] = phy;
0216     data[1] = data[2] = 0;
0217     tmp = indx | PHY_READ | PHY_GO;
0218     i = 0;
0219 
0220     set_registers(dev, PHYADD, sizeof(data), data);
0221     set_registers(dev, PHYCNT, 1, &tmp);
0222     do {
0223         get_registers(dev, PHYCNT, 1, data);
0224     } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
0225 
0226     if (i <= MII_TIMEOUT) {
0227         get_registers(dev, PHYDAT, 2, data);
0228         *reg = data[0] | (data[1] << 8);
0229         return 0;
0230     } else
0231         return 1;
0232 }
0233 
0234 static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
0235 {
0236     int i;
0237     u8 data[3], tmp;
0238 
0239     data[0] = phy;
0240     data[1] = reg & 0xff;
0241     data[2] = (reg >> 8) & 0xff;
0242     tmp = indx | PHY_WRITE | PHY_GO;
0243     i = 0;
0244 
0245     set_registers(dev, PHYADD, sizeof(data), data);
0246     set_registers(dev, PHYCNT, 1, &tmp);
0247     do {
0248         get_registers(dev, PHYCNT, 1, data);
0249     } while ((data[0] & PHY_GO) && (i++ < MII_TIMEOUT));
0250 
0251     if (i <= MII_TIMEOUT)
0252         return 0;
0253     else
0254         return 1;
0255 }
0256 
0257 static void set_ethernet_addr(rtl8150_t *dev)
0258 {
0259     u8 node_id[ETH_ALEN];
0260     int ret;
0261 
0262     ret = get_registers(dev, IDR, sizeof(node_id), node_id);
0263 
0264     if (!ret) {
0265         eth_hw_addr_set(dev->netdev, node_id);
0266     } else {
0267         eth_hw_addr_random(dev->netdev);
0268         netdev_notice(dev->netdev, "Assigned a random MAC address: %pM\n",
0269                   dev->netdev->dev_addr);
0270     }
0271 }
0272 
0273 static int rtl8150_set_mac_address(struct net_device *netdev, void *p)
0274 {
0275     struct sockaddr *addr = p;
0276     rtl8150_t *dev = netdev_priv(netdev);
0277 
0278     if (netif_running(netdev))
0279         return -EBUSY;
0280 
0281     eth_hw_addr_set(netdev, addr->sa_data);
0282     netdev_dbg(netdev, "Setting MAC address to %pM\n", netdev->dev_addr);
0283     /* Set the IDR registers. */
0284     set_registers(dev, IDR, netdev->addr_len, netdev->dev_addr);
0285 #ifdef EEPROM_WRITE
0286     {
0287     int i;
0288     u8 cr;
0289     /* Get the CR contents. */
0290     get_registers(dev, CR, 1, &cr);
0291     /* Set the WEPROM bit (eeprom write enable). */
0292     cr |= 0x20;
0293     set_registers(dev, CR, 1, &cr);
0294     /* Write the MAC address into eeprom. Eeprom writes must be word-sized,
0295        so we need to split them up. */
0296     for (i = 0; i * 2 < netdev->addr_len; i++) {
0297         set_registers(dev, IDR_EEPROM + (i * 2), 2,
0298         netdev->dev_addr + (i * 2));
0299     }
0300     /* Clear the WEPROM bit (preventing accidental eeprom writes). */
0301     cr &= 0xdf;
0302     set_registers(dev, CR, 1, &cr);
0303     }
0304 #endif
0305     return 0;
0306 }
0307 
0308 static int rtl8150_reset(rtl8150_t * dev)
0309 {
0310     u8 data = 0x10;
0311     int i = HZ;
0312 
0313     set_registers(dev, CR, 1, &data);
0314     do {
0315         get_registers(dev, CR, 1, &data);
0316     } while ((data & 0x10) && --i);
0317 
0318     return (i > 0) ? 1 : 0;
0319 }
0320 
0321 static int alloc_all_urbs(rtl8150_t * dev)
0322 {
0323     dev->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
0324     if (!dev->rx_urb)
0325         return 0;
0326     dev->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
0327     if (!dev->tx_urb) {
0328         usb_free_urb(dev->rx_urb);
0329         return 0;
0330     }
0331     dev->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
0332     if (!dev->intr_urb) {
0333         usb_free_urb(dev->rx_urb);
0334         usb_free_urb(dev->tx_urb);
0335         return 0;
0336     }
0337 
0338     return 1;
0339 }
0340 
0341 static void free_all_urbs(rtl8150_t * dev)
0342 {
0343     usb_free_urb(dev->rx_urb);
0344     usb_free_urb(dev->tx_urb);
0345     usb_free_urb(dev->intr_urb);
0346 }
0347 
0348 static void unlink_all_urbs(rtl8150_t * dev)
0349 {
0350     usb_kill_urb(dev->rx_urb);
0351     usb_kill_urb(dev->tx_urb);
0352     usb_kill_urb(dev->intr_urb);
0353 }
0354 
0355 static inline struct sk_buff *pull_skb(rtl8150_t *dev)
0356 {
0357     struct sk_buff *skb;
0358     int i;
0359 
0360     for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
0361         if (dev->rx_skb_pool[i]) {
0362             skb = dev->rx_skb_pool[i];
0363             dev->rx_skb_pool[i] = NULL;
0364             return skb;
0365         }
0366     }
0367     return NULL;
0368 }
0369 
0370 static void read_bulk_callback(struct urb *urb)
0371 {
0372     rtl8150_t *dev;
0373     unsigned pkt_len, res;
0374     struct sk_buff *skb;
0375     struct net_device *netdev;
0376     int status = urb->status;
0377     int result;
0378     unsigned long flags;
0379 
0380     dev = urb->context;
0381     if (!dev)
0382         return;
0383     if (test_bit(RTL8150_UNPLUG, &dev->flags))
0384         return;
0385     netdev = dev->netdev;
0386     if (!netif_device_present(netdev))
0387         return;
0388 
0389     switch (status) {
0390     case 0:
0391         break;
0392     case -ENOENT:
0393         return; /* the urb is in unlink state */
0394     case -ETIME:
0395         if (printk_ratelimit())
0396             dev_warn(&urb->dev->dev, "may be reset is needed?..\n");
0397         goto goon;
0398     default:
0399         if (printk_ratelimit())
0400             dev_warn(&urb->dev->dev, "Rx status %d\n", status);
0401         goto goon;
0402     }
0403 
0404     if (!dev->rx_skb)
0405         goto resched;
0406     /* protect against short packets (tell me why we got some?!?) */
0407     if (urb->actual_length < 4)
0408         goto goon;
0409 
0410     res = urb->actual_length;
0411     pkt_len = res - 4;
0412 
0413     skb_put(dev->rx_skb, pkt_len);
0414     dev->rx_skb->protocol = eth_type_trans(dev->rx_skb, netdev);
0415     netif_rx(dev->rx_skb);
0416     netdev->stats.rx_packets++;
0417     netdev->stats.rx_bytes += pkt_len;
0418 
0419     spin_lock_irqsave(&dev->rx_pool_lock, flags);
0420     skb = pull_skb(dev);
0421     spin_unlock_irqrestore(&dev->rx_pool_lock, flags);
0422     if (!skb)
0423         goto resched;
0424 
0425     dev->rx_skb = skb;
0426 goon:
0427     usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
0428               dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
0429     result = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
0430     if (result == -ENODEV)
0431         netif_device_detach(dev->netdev);
0432     else if (result) {
0433         set_bit(RX_URB_FAIL, &dev->flags);
0434         goto resched;
0435     } else {
0436         clear_bit(RX_URB_FAIL, &dev->flags);
0437     }
0438 
0439     return;
0440 resched:
0441     tasklet_schedule(&dev->tl);
0442 }
0443 
0444 static void write_bulk_callback(struct urb *urb)
0445 {
0446     rtl8150_t *dev;
0447     int status = urb->status;
0448 
0449     dev = urb->context;
0450     if (!dev)
0451         return;
0452     dev_kfree_skb_irq(dev->tx_skb);
0453     if (!netif_device_present(dev->netdev))
0454         return;
0455     if (status)
0456         dev_info(&urb->dev->dev, "%s: Tx status %d\n",
0457              dev->netdev->name, status);
0458     netif_trans_update(dev->netdev);
0459     netif_wake_queue(dev->netdev);
0460 }
0461 
0462 static void intr_callback(struct urb *urb)
0463 {
0464     rtl8150_t *dev;
0465     __u8 *d;
0466     int status = urb->status;
0467     int res;
0468 
0469     dev = urb->context;
0470     if (!dev)
0471         return;
0472     switch (status) {
0473     case 0:         /* success */
0474         break;
0475     case -ECONNRESET:   /* unlink */
0476     case -ENOENT:
0477     case -ESHUTDOWN:
0478         return;
0479     /* -EPIPE:  should clear the halt */
0480     default:
0481         dev_info(&urb->dev->dev, "%s: intr status %d\n",
0482              dev->netdev->name, status);
0483         goto resubmit;
0484     }
0485 
0486     d = urb->transfer_buffer;
0487     if (d[0] & TSR_ERRORS) {
0488         dev->netdev->stats.tx_errors++;
0489         if (d[INT_TSR] & (TSR_ECOL | TSR_JBR))
0490             dev->netdev->stats.tx_aborted_errors++;
0491         if (d[INT_TSR] & TSR_LCOL)
0492             dev->netdev->stats.tx_window_errors++;
0493         if (d[INT_TSR] & TSR_LOSS_CRS)
0494             dev->netdev->stats.tx_carrier_errors++;
0495     }
0496     /* Report link status changes to the network stack */
0497     if ((d[INT_MSR] & MSR_LINK) == 0) {
0498         if (netif_carrier_ok(dev->netdev)) {
0499             netif_carrier_off(dev->netdev);
0500             netdev_dbg(dev->netdev, "%s: LINK LOST\n", __func__);
0501         }
0502     } else {
0503         if (!netif_carrier_ok(dev->netdev)) {
0504             netif_carrier_on(dev->netdev);
0505             netdev_dbg(dev->netdev, "%s: LINK CAME BACK\n", __func__);
0506         }
0507     }
0508 
0509 resubmit:
0510     res = usb_submit_urb (urb, GFP_ATOMIC);
0511     if (res == -ENODEV)
0512         netif_device_detach(dev->netdev);
0513     else if (res)
0514         dev_err(&dev->udev->dev,
0515             "can't resubmit intr, %s-%s/input0, status %d\n",
0516             dev->udev->bus->bus_name, dev->udev->devpath, res);
0517 }
0518 
0519 static int rtl8150_suspend(struct usb_interface *intf, pm_message_t message)
0520 {
0521     rtl8150_t *dev = usb_get_intfdata(intf);
0522 
0523     netif_device_detach(dev->netdev);
0524 
0525     if (netif_running(dev->netdev)) {
0526         usb_kill_urb(dev->rx_urb);
0527         usb_kill_urb(dev->intr_urb);
0528     }
0529     return 0;
0530 }
0531 
0532 static int rtl8150_resume(struct usb_interface *intf)
0533 {
0534     rtl8150_t *dev = usb_get_intfdata(intf);
0535 
0536     netif_device_attach(dev->netdev);
0537     if (netif_running(dev->netdev)) {
0538         dev->rx_urb->status = 0;
0539         dev->rx_urb->actual_length = 0;
0540         read_bulk_callback(dev->rx_urb);
0541 
0542         dev->intr_urb->status = 0;
0543         dev->intr_urb->actual_length = 0;
0544         intr_callback(dev->intr_urb);
0545     }
0546     return 0;
0547 }
0548 
0549 /*
0550 **
0551 **  network related part of the code
0552 **
0553 */
0554 
0555 static void fill_skb_pool(rtl8150_t *dev)
0556 {
0557     struct sk_buff *skb;
0558     int i;
0559 
0560     for (i = 0; i < RX_SKB_POOL_SIZE; i++) {
0561         if (dev->rx_skb_pool[i])
0562             continue;
0563         skb = dev_alloc_skb(RTL8150_MTU + 2);
0564         if (!skb) {
0565             return;
0566         }
0567         skb_reserve(skb, 2);
0568         dev->rx_skb_pool[i] = skb;
0569     }
0570 }
0571 
0572 static void free_skb_pool(rtl8150_t *dev)
0573 {
0574     int i;
0575 
0576     for (i = 0; i < RX_SKB_POOL_SIZE; i++)
0577         dev_kfree_skb(dev->rx_skb_pool[i]);
0578 }
0579 
0580 static void rx_fixup(struct tasklet_struct *t)
0581 {
0582     struct rtl8150 *dev = from_tasklet(dev, t, tl);
0583     struct sk_buff *skb;
0584     int status;
0585 
0586     spin_lock_irq(&dev->rx_pool_lock);
0587     fill_skb_pool(dev);
0588     spin_unlock_irq(&dev->rx_pool_lock);
0589     if (test_bit(RX_URB_FAIL, &dev->flags))
0590         if (dev->rx_skb)
0591             goto try_again;
0592     spin_lock_irq(&dev->rx_pool_lock);
0593     skb = pull_skb(dev);
0594     spin_unlock_irq(&dev->rx_pool_lock);
0595     if (skb == NULL)
0596         goto tlsched;
0597     dev->rx_skb = skb;
0598     usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
0599               dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
0600 try_again:
0601     status = usb_submit_urb(dev->rx_urb, GFP_ATOMIC);
0602     if (status == -ENODEV) {
0603         netif_device_detach(dev->netdev);
0604     } else if (status) {
0605         set_bit(RX_URB_FAIL, &dev->flags);
0606         goto tlsched;
0607     } else {
0608         clear_bit(RX_URB_FAIL, &dev->flags);
0609     }
0610 
0611     return;
0612 tlsched:
0613     tasklet_schedule(&dev->tl);
0614 }
0615 
0616 static int enable_net_traffic(rtl8150_t * dev)
0617 {
0618     u8 cr, tcr, rcr, msr;
0619 
0620     if (!rtl8150_reset(dev)) {
0621         dev_warn(&dev->udev->dev, "device reset failed\n");
0622     }
0623     /* RCR bit7=1 attach Rx info at the end;  =0 HW CRC (which is broken) */
0624     rcr = 0x9e;
0625     tcr = 0xd8;
0626     cr = 0x0c;
0627     if (!(rcr & 0x80))
0628         set_bit(RTL8150_HW_CRC, &dev->flags);
0629     set_registers(dev, RCR, 1, &rcr);
0630     set_registers(dev, TCR, 1, &tcr);
0631     set_registers(dev, CR, 1, &cr);
0632     get_registers(dev, MSR, 1, &msr);
0633 
0634     return 0;
0635 }
0636 
0637 static void disable_net_traffic(rtl8150_t * dev)
0638 {
0639     u8 cr;
0640 
0641     get_registers(dev, CR, 1, &cr);
0642     cr &= 0xf3;
0643     set_registers(dev, CR, 1, &cr);
0644 }
0645 
0646 static void rtl8150_tx_timeout(struct net_device *netdev, unsigned int txqueue)
0647 {
0648     rtl8150_t *dev = netdev_priv(netdev);
0649     dev_warn(&netdev->dev, "Tx timeout.\n");
0650     usb_unlink_urb(dev->tx_urb);
0651     netdev->stats.tx_errors++;
0652 }
0653 
0654 static void rtl8150_set_multicast(struct net_device *netdev)
0655 {
0656     rtl8150_t *dev = netdev_priv(netdev);
0657     u16 rx_creg = 0x9e;
0658 
0659     netif_stop_queue(netdev);
0660     if (netdev->flags & IFF_PROMISC) {
0661         rx_creg |= 0x0001;
0662         dev_info(&netdev->dev, "%s: promiscuous mode\n", netdev->name);
0663     } else if (!netdev_mc_empty(netdev) ||
0664            (netdev->flags & IFF_ALLMULTI)) {
0665         rx_creg &= 0xfffe;
0666         rx_creg |= 0x0002;
0667         dev_dbg(&netdev->dev, "%s: allmulti set\n", netdev->name);
0668     } else {
0669         /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
0670         rx_creg &= 0x00fc;
0671     }
0672     async_set_registers(dev, RCR, sizeof(rx_creg), rx_creg);
0673     netif_wake_queue(netdev);
0674 }
0675 
0676 static netdev_tx_t rtl8150_start_xmit(struct sk_buff *skb,
0677                         struct net_device *netdev)
0678 {
0679     rtl8150_t *dev = netdev_priv(netdev);
0680     int count, res;
0681 
0682     netif_stop_queue(netdev);
0683     count = (skb->len < 60) ? 60 : skb->len;
0684     count = (count & 0x3f) ? count : count + 1;
0685     dev->tx_skb = skb;
0686     usb_fill_bulk_urb(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
0687               skb->data, count, write_bulk_callback, dev);
0688     if ((res = usb_submit_urb(dev->tx_urb, GFP_ATOMIC))) {
0689         /* Can we get/handle EPIPE here? */
0690         if (res == -ENODEV)
0691             netif_device_detach(dev->netdev);
0692         else {
0693             dev_warn(&netdev->dev, "failed tx_urb %d\n", res);
0694             netdev->stats.tx_errors++;
0695             netif_start_queue(netdev);
0696         }
0697     } else {
0698         netdev->stats.tx_packets++;
0699         netdev->stats.tx_bytes += skb->len;
0700         netif_trans_update(netdev);
0701     }
0702 
0703     return NETDEV_TX_OK;
0704 }
0705 
0706 
0707 static void set_carrier(struct net_device *netdev)
0708 {
0709     rtl8150_t *dev = netdev_priv(netdev);
0710     short tmp;
0711 
0712     get_registers(dev, CSCR, 2, &tmp);
0713     if (tmp & CSCR_LINK_STATUS)
0714         netif_carrier_on(netdev);
0715     else
0716         netif_carrier_off(netdev);
0717 }
0718 
0719 static int rtl8150_open(struct net_device *netdev)
0720 {
0721     rtl8150_t *dev = netdev_priv(netdev);
0722     int res;
0723 
0724     if (dev->rx_skb == NULL)
0725         dev->rx_skb = pull_skb(dev);
0726     if (!dev->rx_skb)
0727         return -ENOMEM;
0728 
0729     set_registers(dev, IDR, 6, netdev->dev_addr);
0730 
0731     usb_fill_bulk_urb(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
0732               dev->rx_skb->data, RTL8150_MTU, read_bulk_callback, dev);
0733     if ((res = usb_submit_urb(dev->rx_urb, GFP_KERNEL))) {
0734         if (res == -ENODEV)
0735             netif_device_detach(dev->netdev);
0736         dev_warn(&netdev->dev, "rx_urb submit failed: %d\n", res);
0737         return res;
0738     }
0739     usb_fill_int_urb(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
0740              dev->intr_buff, INTBUFSIZE, intr_callback,
0741              dev, dev->intr_interval);
0742     if ((res = usb_submit_urb(dev->intr_urb, GFP_KERNEL))) {
0743         if (res == -ENODEV)
0744             netif_device_detach(dev->netdev);
0745         dev_warn(&netdev->dev, "intr_urb submit failed: %d\n", res);
0746         usb_kill_urb(dev->rx_urb);
0747         return res;
0748     }
0749     enable_net_traffic(dev);
0750     set_carrier(netdev);
0751     netif_start_queue(netdev);
0752 
0753     return res;
0754 }
0755 
0756 static int rtl8150_close(struct net_device *netdev)
0757 {
0758     rtl8150_t *dev = netdev_priv(netdev);
0759 
0760     netif_stop_queue(netdev);
0761     if (!test_bit(RTL8150_UNPLUG, &dev->flags))
0762         disable_net_traffic(dev);
0763     unlink_all_urbs(dev);
0764 
0765     return 0;
0766 }
0767 
0768 static void rtl8150_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
0769 {
0770     rtl8150_t *dev = netdev_priv(netdev);
0771 
0772     strlcpy(info->driver, driver_name, sizeof(info->driver));
0773     strlcpy(info->version, DRIVER_VERSION, sizeof(info->version));
0774     usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
0775 }
0776 
0777 static int rtl8150_get_link_ksettings(struct net_device *netdev,
0778                       struct ethtool_link_ksettings *ecmd)
0779 {
0780     rtl8150_t *dev = netdev_priv(netdev);
0781     short lpa, bmcr;
0782     u32 supported;
0783 
0784     supported = (SUPPORTED_10baseT_Half |
0785               SUPPORTED_10baseT_Full |
0786               SUPPORTED_100baseT_Half |
0787               SUPPORTED_100baseT_Full |
0788               SUPPORTED_Autoneg |
0789               SUPPORTED_TP | SUPPORTED_MII);
0790     ecmd->base.port = PORT_TP;
0791     ecmd->base.phy_address = dev->phy;
0792     get_registers(dev, BMCR, 2, &bmcr);
0793     get_registers(dev, ANLP, 2, &lpa);
0794     if (bmcr & BMCR_ANENABLE) {
0795         u32 speed = ((lpa & (LPA_100HALF | LPA_100FULL)) ?
0796                  SPEED_100 : SPEED_10);
0797         ecmd->base.speed = speed;
0798         ecmd->base.autoneg = AUTONEG_ENABLE;
0799         if (speed == SPEED_100)
0800             ecmd->base.duplex = (lpa & LPA_100FULL) ?
0801                 DUPLEX_FULL : DUPLEX_HALF;
0802         else
0803             ecmd->base.duplex = (lpa & LPA_10FULL) ?
0804                 DUPLEX_FULL : DUPLEX_HALF;
0805     } else {
0806         ecmd->base.autoneg = AUTONEG_DISABLE;
0807         ecmd->base.speed = ((bmcr & BMCR_SPEED100) ?
0808                          SPEED_100 : SPEED_10);
0809         ecmd->base.duplex = (bmcr & BMCR_FULLDPLX) ?
0810             DUPLEX_FULL : DUPLEX_HALF;
0811     }
0812 
0813     ethtool_convert_legacy_u32_to_link_mode(ecmd->link_modes.supported,
0814                         supported);
0815 
0816     return 0;
0817 }
0818 
0819 static const struct ethtool_ops ops = {
0820     .get_drvinfo = rtl8150_get_drvinfo,
0821     .get_link = ethtool_op_get_link,
0822     .get_link_ksettings = rtl8150_get_link_ksettings,
0823 };
0824 
0825 static int rtl8150_siocdevprivate(struct net_device *netdev, struct ifreq *rq,
0826                   void __user *udata, int cmd)
0827 {
0828     rtl8150_t *dev = netdev_priv(netdev);
0829     u16 *data = (u16 *) & rq->ifr_ifru;
0830     int res = 0;
0831 
0832     switch (cmd) {
0833     case SIOCDEVPRIVATE:
0834         data[0] = dev->phy;
0835         fallthrough;
0836     case SIOCDEVPRIVATE + 1:
0837         read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
0838         break;
0839     case SIOCDEVPRIVATE + 2:
0840         if (!capable(CAP_NET_ADMIN))
0841             return -EPERM;
0842         write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
0843         break;
0844     default:
0845         res = -EOPNOTSUPP;
0846     }
0847 
0848     return res;
0849 }
0850 
0851 static const struct net_device_ops rtl8150_netdev_ops = {
0852     .ndo_open       = rtl8150_open,
0853     .ndo_stop       = rtl8150_close,
0854     .ndo_siocdevprivate = rtl8150_siocdevprivate,
0855     .ndo_start_xmit     = rtl8150_start_xmit,
0856     .ndo_tx_timeout     = rtl8150_tx_timeout,
0857     .ndo_set_rx_mode    = rtl8150_set_multicast,
0858     .ndo_set_mac_address    = rtl8150_set_mac_address,
0859 
0860     .ndo_validate_addr  = eth_validate_addr,
0861 };
0862 
0863 static int rtl8150_probe(struct usb_interface *intf,
0864              const struct usb_device_id *id)
0865 {
0866     struct usb_device *udev = interface_to_usbdev(intf);
0867     rtl8150_t *dev;
0868     struct net_device *netdev;
0869 
0870     netdev = alloc_etherdev(sizeof(rtl8150_t));
0871     if (!netdev)
0872         return -ENOMEM;
0873 
0874     dev = netdev_priv(netdev);
0875 
0876     dev->intr_buff = kmalloc(INTBUFSIZE, GFP_KERNEL);
0877     if (!dev->intr_buff) {
0878         free_netdev(netdev);
0879         return -ENOMEM;
0880     }
0881 
0882     tasklet_setup(&dev->tl, rx_fixup);
0883     spin_lock_init(&dev->rx_pool_lock);
0884 
0885     dev->udev = udev;
0886     dev->netdev = netdev;
0887     netdev->netdev_ops = &rtl8150_netdev_ops;
0888     netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
0889     netdev->ethtool_ops = &ops;
0890     dev->intr_interval = 100;   /* 100ms */
0891 
0892     if (!alloc_all_urbs(dev)) {
0893         dev_err(&intf->dev, "out of memory\n");
0894         goto out;
0895     }
0896     if (!rtl8150_reset(dev)) {
0897         dev_err(&intf->dev, "couldn't reset the device\n");
0898         goto out1;
0899     }
0900     fill_skb_pool(dev);
0901     set_ethernet_addr(dev);
0902 
0903     usb_set_intfdata(intf, dev);
0904     SET_NETDEV_DEV(netdev, &intf->dev);
0905     if (register_netdev(netdev) != 0) {
0906         dev_err(&intf->dev, "couldn't register the device\n");
0907         goto out2;
0908     }
0909 
0910     dev_info(&intf->dev, "%s: rtl8150 is detected\n", netdev->name);
0911 
0912     return 0;
0913 
0914 out2:
0915     usb_set_intfdata(intf, NULL);
0916     free_skb_pool(dev);
0917 out1:
0918     free_all_urbs(dev);
0919 out:
0920     kfree(dev->intr_buff);
0921     free_netdev(netdev);
0922     return -EIO;
0923 }
0924 
0925 static void rtl8150_disconnect(struct usb_interface *intf)
0926 {
0927     rtl8150_t *dev = usb_get_intfdata(intf);
0928 
0929     usb_set_intfdata(intf, NULL);
0930     if (dev) {
0931         set_bit(RTL8150_UNPLUG, &dev->flags);
0932         tasklet_kill(&dev->tl);
0933         unregister_netdev(dev->netdev);
0934         unlink_all_urbs(dev);
0935         free_all_urbs(dev);
0936         free_skb_pool(dev);
0937         dev_kfree_skb(dev->rx_skb);
0938         kfree(dev->intr_buff);
0939         free_netdev(dev->netdev);
0940     }
0941 }
0942 
0943 static struct usb_driver rtl8150_driver = {
0944     .name       = driver_name,
0945     .probe      = rtl8150_probe,
0946     .disconnect = rtl8150_disconnect,
0947     .id_table   = rtl8150_table,
0948     .suspend    = rtl8150_suspend,
0949     .resume     = rtl8150_resume,
0950     .disable_hub_initiated_lpm = 1,
0951 };
0952 
0953 module_usb_driver(rtl8150_driver);
0954 
0955 MODULE_AUTHOR(DRIVER_AUTHOR);
0956 MODULE_DESCRIPTION(DRIVER_DESC);
0957 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!