开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
rtl8150.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

rtl8150.c：源码内容
  1. /*
  2.  *  Copyright (c) 2002 Petko Manolov (petkan@users.sourceforge.net)
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License 
  6.  * version 2 as published by the Free Software Foundation.
  7.  */
  9. #include <linux/config.h>
  10. #include <linux/sched.h>
  11. #include <linux/signal.h>
  12. #include <linux/slab.h>
  13. #include <linux/module.h>
  14. #include <linux/netdevice.h>
  15. #include <linux/etherdevice.h>
  16. #include <linux/mii.h>
  17. #include <linux/ethtool.h>
  18. #include <linux/devfs_fs_kernel.h>
  19. #include <linux/usb.h>
  20. #include <linux/init.h>
  21. #include <asm/uaccess.h>
  23. /* Version Information */
  24. #define DRIVER_VERSION "v0.4.1 (2002/07/22)"
  25. #define DRIVER_AUTHOR "Petko Manolov <petkan@users.sourceforge.net>"
  26. #define DRIVER_DESC "rtl8150 based usb-ethernet driver"
  28. #define IRD 0x0120
  29. #define MAR 0x0126
  30. #define CR 0x012e
  31. #define TCR 0x012f
  32. #define RCR 0x0130
  33. #define TSR 0x0132
  34. #define RSR 0x0133
  35. #define CON0 0x0135
  36. #define CON1 0x0136
  37. #define MSR 0x0137
  38. #define PHYADD 0x0138
  39. #define PHYDAT 0x0139
  40. #define PHYCNT 0x013b
  41. #define GPPC 0x013d
  42. #define BMCR 0x0140
  43. #define BMSR 0x0142
  44. #define ANAR 0x0144
  45. #define ANLP 0x0146
  46. #define AER 0x0148
  48. #define PHY_READ 0
  49. #define PHY_WRITE 0x20
  50. #define PHY_GO 0x40
  52. #define RTL8150_REQT_READ 0xc0
  53. #define RTL8150_REQT_WRITE 0x40
  54. #define RTL8150_REQ_GET_REGS 0x05
  55. #define RTL8150_REQ_SET_REGS 0x05
  57. #define RTL8150_MTU 1500
  58. #define RTL8150_MAX_MTU 1536
  60. #define RTL8150_TX_TIMEOUT (HZ)
  62. /* rtl8150 flags */
  63. #define RTL8150_FLAG_HWCRC 0
  64. #define RX_REG_SET 1
  65. #define RTL8150_UNPLUG 2
  67. /* Define these values to match your device */
  68. #define VENDOR_ID_REALTEK 0x0bda
  69. #define VENDOR_ID_MELCO 0x0411
  71. #define PRODUCT_ID_RTL8150 0x8150
  72. #define PRODUCT_ID_LUAKTX 0x0012
  74. /* table of devices that work with this driver */
  75. static struct usb_device_id rtl8150_table[] = {
  76. {USB_DEVICE(VENDOR_ID_REALTEK, PRODUCT_ID_RTL8150)},
  77. {USB_DEVICE(VENDOR_ID_MELCO, PRODUCT_ID_LUAKTX)},
  78. {}
  79. };
  81. MODULE_DEVICE_TABLE(usb, rtl8150_table);
  83. struct rtl8150 {
  84. unsigned int flags;
  85. struct usb_device *udev;
  86. struct usb_interface *interface;
  87. struct semaphore sem;
  88. struct net_device_stats stats;
  89. struct net_device *netdev;
  90. struct urb *rx_urb, *tx_urb, *intr_urb, *ctrl_urb;
  91. struct usb_ctrlrequest dr;
  92. int intr_interval;
  93. u16 rx_creg;
  94. u8 rx_buff[RTL8150_MAX_MTU];
  95. u8 tx_buff[RTL8150_MAX_MTU];
  96. u8 intr_buff[8];
  97. u8 phy;
  98. };
  100. typedef struct rtl8150 rtl8150_t;
  102. /* the global usb devfs handle */
  103. extern devfs_handle_t usb_devfs_handle;
  104. unsigned long multicast_filter_limit = 32;
  106. static void rtl8150_disconnect(struct usb_device *dev, void *ptr);
  107. static void *rtl8150_probe(struct usb_device *dev, unsigned int ifnum,
  108.    const struct usb_device_id *id);
  110. static struct usb_driver rtl8150_driver = {
  111. name: "rtl8150",
  112. probe: rtl8150_probe,
  113. disconnect: rtl8150_disconnect,
  114. id_table: rtl8150_table,
  115. };
  117. /*
  118. **
  119. ** device related part of the code
  120. **
  121. */
  122. static int get_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
  123. {
  124. return usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
  125.        RTL8150_REQ_GET_REGS, RTL8150_REQT_READ,
  126.        indx, 0, data, size, HZ / 2);
  127. }
  129. static int set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
  130. {
  131. return usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
  132.        RTL8150_REQ_SET_REGS, RTL8150_REQT_WRITE,
  133.        indx, 0, data, size, HZ / 2);
  134. }
  136. static void ctrl_callback(struct urb *urb)
  137. {
  138. rtl8150_t *dev;
  140. switch (urb->status) {
  141. case 0:
  142. break;
  143. case -EINPROGRESS:
  144. break;
  145. case -ENOENT:
  146. break;
  147. default:
  148. warn("ctrl urb status %d", urb->status);
  149. }
  150. dev = urb->context;
  151. clear_bit(RX_REG_SET, &dev->flags);
  152. }
  154. static int async_set_registers(rtl8150_t * dev, u16 indx, u16 size, void *data)
  155. {
  156. int ret;
  158. if (test_bit(RX_REG_SET, &dev->flags))
  159. return -EAGAIN;
  161. dev->dr.bRequestType = RTL8150_REQT_WRITE;
  162. dev->dr.bRequest = RTL8150_REQ_SET_REGS;
  163. dev->dr.wValue = cpu_to_le16(indx);
  164. dev->dr.wIndex = 0;
  165. dev->dr.wLength = cpu_to_le16(2);
  166. dev->ctrl_urb->transfer_buffer_length = 2;
  167. FILL_CONTROL_URB(dev->ctrl_urb, dev->udev,
  168.  usb_sndctrlpipe(dev->udev, 0), (char *) &dev->dr,
  169.  &dev->rx_creg, 2, ctrl_callback, dev);
  170. if ((ret = usb_submit_urb(dev->ctrl_urb)))
  171. err("control request submission failed: %d", ret);
  172. else
  173. set_bit(RX_REG_SET, &dev->flags);
  175. return ret;
  176. }
  178. static int read_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 * reg)
  179. {
  180. int i;
  181. u8 data[3], tmp;
  183. data[0] = phy;
  184. data[1] = data[2] = 0;
  185. tmp = indx | PHY_READ | PHY_GO;
  186. i = 0;
  188. set_registers(dev, PHYADD, sizeof(data), data);
  189. set_registers(dev, PHYCNT, 1, &tmp);
  190. do {
  191. get_registers(dev, PHYCNT, 1, data);
  192. } while ((data[0] & PHY_GO) && (i++ < HZ));
  194. if (i < HZ) {
  195. get_registers(dev, PHYDAT, 2, data);
  196. *reg = le16_to_cpup((u16 *)data);
  197. return 0;
  198. } else
  199. return 1;
  200. }
  202. static int write_mii_word(rtl8150_t * dev, u8 phy, __u8 indx, u16 reg)
  203. {
  204. int i;
  205. u8 data[3], tmp;
  207. data[0] = phy;
  208. *(data + 1) = cpu_to_le16p(&reg);
  209. tmp = indx | PHY_WRITE | PHY_GO;
  210. i = 0;
  212. set_registers(dev, PHYADD, sizeof(data), data);
  213. set_registers(dev, PHYCNT, 1, &tmp);
  214. do {
  215. get_registers(dev, PHYCNT, 1, data);
  216. } while ((data[0] & PHY_GO) && (i++ < HZ));
  218. if (i < HZ)
  219. return 0;
  220. else
  221. return 1;
  222. }
  224. static inline void set_ethernet_addr(rtl8150_t * dev)
  225. {
  226. u8 node_id[6];
  228. get_registers(dev, IRD, sizeof(node_id), node_id);
  229. memcpy(dev->netdev->dev_addr, node_id, sizeof(node_id));
  230. }
  232. static int rtl8150_reset(rtl8150_t * dev)
  233. {
  234. u8 data = 0x10;
  235. int i = HZ;
  237. set_registers(dev, CR, 1, &data);
  238. do {
  239. get_registers(dev, CR, 1, &data);
  240. } while ((data & 0x10) && --i);
  242. return (i > 0) ? 0 : -1;
  243. }
  245. static int alloc_all_urbs(rtl8150_t * dev)
  246. {
  247. dev->rx_urb = usb_alloc_urb(0);
  248. if (!dev->rx_urb)
  249. return 0;
  250. dev->tx_urb = usb_alloc_urb(0);
  251. if (!dev->tx_urb) {
  252. usb_free_urb(dev->rx_urb);
  253. return 0;
  254. }
  255. dev->intr_urb = usb_alloc_urb(0);
  256. if (!dev->intr_urb) {
  257. usb_free_urb(dev->rx_urb);
  258. usb_free_urb(dev->tx_urb);
  259. return 0;
  260. }
  261. dev->ctrl_urb = usb_alloc_urb(0);
  262. if (!dev->ctrl_urb) {
  263. usb_free_urb(dev->rx_urb);
  264. usb_free_urb(dev->tx_urb);
  265. usb_free_urb(dev->intr_urb);
  266. return 0;
  267. }
  269. return 1;
  270. }
  272. static void free_all_urbs(rtl8150_t * dev)
  273. {
  274. usb_free_urb(dev->rx_urb);
  275. usb_free_urb(dev->tx_urb);
  276. usb_free_urb(dev->intr_urb);
  277. usb_free_urb(dev->ctrl_urb);
  278. }
  280. static void unlink_all_urbs(rtl8150_t * dev)
  281. {
  282. usb_unlink_urb(dev->rx_urb);
  283. usb_unlink_urb(dev->tx_urb);
  284. usb_unlink_urb(dev->intr_urb);
  285. usb_unlink_urb(dev->ctrl_urb);
  286. }
  288. static void read_bulk_callback(struct urb *urb)
  289. {
  290. rtl8150_t *dev;
  291. int pkt_len, res;
  292. struct sk_buff *skb;
  293. struct net_device *netdev;
  294. u16 rx_stat;
  296. dev = urb->context;
  297. if (!dev) {
  298. warn("!dev");
  299. return;
  300. }
  301. netdev = dev->netdev;
  302. if (!netif_device_present(netdev)) {
  303. warn("netdev is not present");
  304. return;
  305. }
  306. switch (urb->status) {
  307. case 0:
  308. break;
  309. case -ENOENT:
  310. return;
  311. case -ETIMEDOUT:
  312. warn("reset needed may be?..");
  313. goto goon;
  314. default:
  315. warn("Rx status %d", urb->status);
  316. goto goon;
  317. }
  319. pkt_len = urb->actual_length - 4;
  320. rx_stat = le16_to_cpu(*(u16 *) (dev->rx_buff + pkt_len));
  322. if (!(skb = dev_alloc_skb(pkt_len + 2)))
  323. goto goon;
  324. skb->dev = netdev;
  325. skb_reserve(skb, 2);
  326. eth_copy_and_sum(skb, dev->rx_buff, pkt_len, 0);
  327. skb_put(skb, pkt_len);
  328. skb->protocol = eth_type_trans(skb, netdev);
  329. netif_rx(skb);
  330. dev->stats.rx_packets++;
  331. dev->stats.rx_bytes += pkt_len;
  332. goon:
  333. FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
  334.       dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
  335. if ((res = usb_submit_urb(dev->rx_urb)))
  336. warn("%s: Rx urb submission failed %d", netdev->name, res);
  337. }
  339. static void write_bulk_callback(struct urb *urb)
  340. {
  341. rtl8150_t *dev;
  343. dev = urb->context;
  344. if (!dev)
  345. return;
  346. if (!netif_device_present(dev->netdev))
  347. return;
  348. if (urb->status)
  349. info("%s: Tx status %d", dev->netdev->name, urb->status);
  350. dev->netdev->trans_start = jiffies;
  351. netif_wake_queue(dev->netdev);
  352. }
  354. void intr_callback(struct urb *urb)
  355. {
  356. rtl8150_t *dev;
  358. dev = urb->context;
  359. if (!dev)
  360. return;
  361. switch (urb->status) {
  362. case 0:
  363. break;
  364. case -ENOENT:
  365. return;
  366. default:
  367. info("%s: intr status %d", dev->netdev->name, urb->status);
  368. }
  369. }
  371. /*
  372. **
  373. ** network related part of the code
  374. **
  375. */
  377. static int enable_net_traffic(rtl8150_t * dev)
  378. {
  379. u8 cr, tcr, rcr, msr;
  381. if (rtl8150_reset(dev)) {
  382. warn("%s - device reset failed", __FUNCTION__);
  383. }
  384. dev->rx_creg = rcr = 0x9e; /* bit7=1 attach Rx info at the end */
  385. tcr = 0xd8;
  386. cr = 0x0c;
  387. set_registers(dev, RCR, 1, &rcr);
  388. set_registers(dev, TCR, 1, &tcr);
  389. set_registers(dev, CR, 1, &cr);
  390. get_registers(dev, MSR, 1, &msr);
  392. return 0;
  393. }
  395. static void disable_net_traffic(rtl8150_t * dev)
  396. {
  397. u8 cr;
  399. get_registers(dev, CR, 1, &cr);
  400. cr &= 0xf3;
  401. set_registers(dev, CR, 1, &cr);
  402. }
  404. static struct net_device_stats *rtl8150_netdev_stats(struct net_device *dev)
  405. {
  406. return &((rtl8150_t *) dev->priv)->stats;
  407. }
  409. static void rtl8150_tx_timeout(struct net_device *netdev)
  410. {
  411. rtl8150_t *dev;
  413. dev = netdev->priv;
  414. if (!dev)
  415. return;
  416. warn("%s: Tx timeout.", netdev->name);
  417. dev->tx_urb->transfer_flags |= USB_ASYNC_UNLINK;
  418. usb_unlink_urb(dev->tx_urb);
  419. dev->stats.tx_errors++;
  420. }
  422. static void rtl8150_set_multicast(struct net_device *netdev)
  423. {
  424. rtl8150_t *dev;
  426. dev = netdev->priv;
  427. netif_stop_queue(netdev);
  428. if (netdev->flags & IFF_PROMISC) {
  429. dev->rx_creg |= 0x0001;
  430. info("%s: promiscuous mode", netdev->name);
  431. } else if ((netdev->mc_count > multicast_filter_limit) ||
  432.    (netdev->flags & IFF_ALLMULTI)) {
  433. dev->rx_creg &= 0xfffe;
  434. dev->rx_creg |= 0x0002;
  435. info("%s: allmulti set", netdev->name);
  436. } else {
  437. /* ~RX_MULTICAST, ~RX_PROMISCUOUS */
  438. dev->rx_creg &= 0x00fc;
  439. }
  440. async_set_registers(dev, RCR, 2, &dev->rx_creg);
  441. netif_wake_queue(netdev);
  442. }
  444. static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev)
  445. {
  446. rtl8150_t *dev;
  447. int count, res;
  449. netif_stop_queue(netdev);
  450. dev = netdev->priv;
  451. count = (skb->len < 60) ? 60 : skb->len;
  452. count = (count & 0x3f) ? count : count + 1;
  453. memcpy(dev->tx_buff, skb->data, skb->len);
  454. FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2),
  455.       dev->tx_buff, RTL8150_MAX_MTU, write_bulk_callback, dev);
  456. dev->tx_urb->transfer_buffer_length = count;
  458. if ((res = usb_submit_urb(dev->tx_urb))) {
  459. warn("failed tx_urb %dn", res);
  460. dev->stats.tx_errors++;
  461. netif_start_queue(netdev);
  462. } else {
  463. dev->stats.tx_packets++;
  464. dev->stats.tx_bytes += skb->len;
  465. netdev->trans_start = jiffies;
  466. }
  467. dev_kfree_skb(skb);
  469. return 0;
  470. }
  472. static int rtl8150_open(struct net_device *netdev)
  473. {
  474. rtl8150_t *dev;
  475. int res;
  477. dev = netdev->priv;
  478. if (dev == NULL) {
  479. return -ENODEV;
  480. }
  482. down(&dev->sem);
  483. FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1),
  484.       dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev);
  485. if ((res = usb_submit_urb(dev->rx_urb)))
  486. warn("%s: rx_urb submit failed: %d", __FUNCTION__, res);
  487. FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3),
  488.      dev->intr_buff, sizeof(dev->intr_buff), intr_callback,
  489.      dev, dev->intr_interval);
  490. if ((res = usb_submit_urb(dev->intr_urb)))
  491. warn("%s: intr_urb submit failed: %d", __FUNCTION__, res);
  492. netif_start_queue(netdev);
  493. enable_net_traffic(dev);
  494. up(&dev->sem);
  496. return res;
  497. }
  499. static int rtl8150_close(struct net_device *netdev)
  500. {
  501. rtl8150_t *dev;
  502. int res = 0;
  504. dev = netdev->priv;
  505. if (!dev)
  506. return -ENODEV;
  508. down(&dev->sem);
  509. if (!test_bit(RTL8150_UNPLUG, &dev->flags))
  510. disable_net_traffic(dev);
  511. unlink_all_urbs(dev);
  512. netif_stop_queue(netdev);
  513. up(&dev->sem);
  515. return res;
  516. }
  518. static int rtl8150_ethtool_ioctl(struct net_device *netdev, void *uaddr)
  519. {
  520. rtl8150_t *dev;
  521. int cmd;
  522. char tmp[128];
  524. dev = netdev->priv;
  525. if (get_user(cmd, (int *) uaddr))
  526. return -EFAULT;
  528. switch (cmd) {
  529. case ETHTOOL_GDRVINFO:{
  530. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  532. strncpy(info.driver, DRIVER_DESC, ETHTOOL_BUSINFO_LEN);
  533. strncpy(info.version, DRIVER_VERSION,
  534. ETHTOOL_BUSINFO_LEN);
  535. sprintf(tmp, "usb%d:%d", dev->udev->bus->busnum,
  536. dev->udev->devnum);
  537. strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
  538. if (copy_to_user(uaddr, &info, sizeof(info)))
  539. return -EFAULT;
  540. return 0;
  541. }
  542. case ETHTOOL_GSET:{
  543. struct ethtool_cmd ecmd;
  544. short lpa, bmcr;
  546. if (copy_from_user(&ecmd, uaddr, sizeof(ecmd)))
  547. return -EFAULT;
  548. ecmd.supported = (SUPPORTED_10baseT_Half |
  549.   SUPPORTED_10baseT_Full |
  550.   SUPPORTED_100baseT_Half |
  551.   SUPPORTED_100baseT_Full |
  552.   SUPPORTED_Autoneg |
  553.   SUPPORTED_TP | SUPPORTED_MII);
  554. ecmd.port = PORT_TP;
  555. ecmd.transceiver = XCVR_INTERNAL;
  556. ecmd.phy_address = dev->phy;
  557. get_registers(dev, BMCR, 2, &bmcr);
  558. get_registers(dev, ANLP, 2, &lpa);
  559. if (bmcr & BMCR_ANENABLE) {
  560. ecmd.autoneg = AUTONEG_ENABLE;
  561. ecmd.speed =
  562.     (lpa & (LPA_100HALF | LPA_100FULL)) ?
  563.     SPEED_100 : SPEED_10;
  564. if (ecmd.speed == SPEED_100)
  565. ecmd.duplex = (lpa & LPA_100FULL) ?
  566.     DUPLEX_FULL : DUPLEX_HALF;
  567. else
  568. ecmd.duplex = (lpa & LPA_10FULL) ?
  569.     DUPLEX_FULL : DUPLEX_HALF;
  570. } else {
  571. ecmd.autoneg = AUTONEG_DISABLE;
  572. ecmd.speed = (bmcr & BMCR_SPEED100) ?
  573.     SPEED_100 : SPEED_10;
  574. ecmd.duplex = (bmcr & BMCR_FULLDPLX) ?
  575.     DUPLEX_FULL : DUPLEX_HALF;
  576. }
  577. if (copy_to_user(uaddr, &ecmd, sizeof(ecmd)))
  578. return -EFAULT;
  579. return 0;
  580. }
  581. case ETHTOOL_SSET:
  582. return -ENOTSUPP;
  583. case ETHTOOL_GLINK:{
  584. struct ethtool_value edata = { ETHTOOL_GLINK };
  586. edata.data = netif_carrier_ok(netdev);
  587. if (copy_to_user(uaddr, &edata, sizeof(edata)))
  588. return -EFAULT;
  589. return 0;
  590. }
  591. default:
  592. return -EOPNOTSUPP;
  593. }
  594. }
  596. static int rtl8150_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
  597. {
  598. rtl8150_t *dev;
  599. u16 *data;
  600. int res;
  602. dev = netdev->priv;
  603. data = (u16 *) & rq->ifr_data;
  604. res = 0;
  606. down(&dev->sem);
  607. switch (cmd) {
  608. case SIOCETHTOOL:
  609. res = rtl8150_ethtool_ioctl(netdev, rq->ifr_data);
  610. break;
  611. case SIOCDEVPRIVATE:
  612. data[0] = dev->phy;
  613. case SIOCDEVPRIVATE + 1:
  614. read_mii_word(dev, dev->phy, (data[1] & 0x1f), &data[3]);
  615. break;
  616. case SIOCDEVPRIVATE + 2:
  617. if (!capable(CAP_NET_ADMIN)) {
  618. up(&dev->sem);
  619. return -EPERM;
  620. }
  621. write_mii_word(dev, dev->phy, (data[1] & 0x1f), data[2]);
  622. break;
  623. default:
  624. res = -EOPNOTSUPP;
  625. }
  626. up(&dev->sem);
  628. return res;
  629. }
  631. static void *rtl8150_probe(struct usb_device *udev, unsigned int ifnum,
  632.    const struct usb_device_id *id)
  633. {
  634. rtl8150_t *dev;
  635. struct net_device *netdev;
  637. udev->config[0].bConfigurationValue = 1;
  638. if (usb_set_configuration(udev, udev->config[0].bConfigurationValue)) {
  639. err("usb_set_configuration() failed");
  640. return NULL;
  641. }
  642. dev = kmalloc(sizeof(rtl8150_t), GFP_KERNEL);
  643. if (!dev) {
  644. err("Out of memory");
  645. goto exit;
  646. } else
  647. memset(dev, 0, sizeof(rtl8150_t));
  649. netdev = init_etherdev(NULL, 0);
  650. if (!netdev) {
  651. kfree(dev);
  652. err("Oh boy, out of memory again?!?");
  653. dev = NULL;
  654. goto exit;
  655. }
  657. init_MUTEX(&dev->sem);
  658. dev->udev = udev;
  659. dev->netdev = netdev;
  660. SET_MODULE_OWNER(netdev);
  661. netdev->priv = dev;
  662. netdev->open = rtl8150_open;
  663. netdev->stop = rtl8150_close;
  664. netdev->do_ioctl = rtl8150_ioctl;
  665. netdev->watchdog_timeo = RTL8150_TX_TIMEOUT;
  666. netdev->tx_timeout = rtl8150_tx_timeout;
  667. netdev->hard_start_xmit = rtl8150_start_xmit;
  668. netdev->set_multicast_list = rtl8150_set_multicast;
  669. netdev->get_stats = rtl8150_netdev_stats;
  670. netdev->mtu = RTL8150_MTU;
  671. dev->intr_interval = 100; /* 100ms */
  673. if (rtl8150_reset(dev) || !alloc_all_urbs(dev)) {
  674. err("couldn't reset the device");
  675. free_all_urbs(dev);
  676. unregister_netdev(dev->netdev);
  677. kfree(netdev);
  678. kfree(dev);
  679. dev = NULL;
  680. goto exit;
  681. }
  683. set_ethernet_addr(dev);
  684. /* let's not be very nasty :-) */
  685. info("%s: rtl8150 is detected", netdev->name);
  686. exit:
  687. return dev;
  688. }
  690. static void rtl8150_disconnect(struct usb_device *udev, void *ptr)
  691. {
  692. rtl8150_t *dev;
  694. dev = ptr;
  695. set_bit(RTL8150_UNPLUG, &dev->flags);
  696. unregister_netdev(dev->netdev);
  697. unlink_all_urbs(dev);
  698. free_all_urbs(dev);
  699. kfree(dev->netdev);
  700. kfree(dev);
  701. dev->netdev = NULL;
  702. dev = NULL;
  703. }
  705. static int __init usb_rtl8150_init(void)
  706. {
  707. info(DRIVER_DESC " " DRIVER_VERSION);
  708. return usb_register(&rtl8150_driver);
  709. }
  711. static void __exit usb_rtl8150_exit(void)
  712. {
  713. usb_deregister(&rtl8150_driver);
  714. }
  716. module_init(usb_rtl8150_init);
  717. module_exit(usb_rtl8150_exit);
  719. MODULE_AUTHOR(DRIVER_AUTHOR);
  720. MODULE_DESCRIPTION(DRIVER_DESC);
  721. MODULE_LICENSE("GPL");