API tools faq
paste
Advertisement
Guest User

ax88179_178a MOD for PVE to work with opnsense 19.x as Linux

a guest
Nov 28th, 2019
819
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 61.33 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * ASIX AX88179 based USB 3.0 Ethernet Devices
  3.  * Copyright (C) 2003-2005 David Hollis <[email protected]>
  4.  * Copyright (C) 2005 Phil Chang <[email protected]>
  5.  * Copyright (c) 2002-2003 TiVo Inc.
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License as published by
  9.  * the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program; if not, write to the Free Software
  19.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20.  */
  21.  
  22. /* debug messages, extra info */
  23. /* #define  DEBUG */
  24.  
  25. #include <linux/version.h>
  26. /*#include <linux/config.h>*/
  27. #ifdef  CONFIG_USB_DEBUG
  28. #define DEBUG
  29. #endif
  30. #include <linux/module.h>
  31. #include <linux/kmod.h>
  32. #include <linux/sched.h>
  33. #include <linux/init.h>
  34. #include <linux/netdevice.h>
  35. #include <linux/etherdevice.h>
  36. #include <linux/ethtool.h>
  37. #include <linux/workqueue.h>
  38. #include <linux/mii.h>
  39. #include <linux/usb.h>
  40. #include <linux/crc32.h>
  41. #include <linux/if_vlan.h>
  42.  
  43. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
  44. #include <linux/usb/usbnet.h>
  45. #else
  46. #include <../drivers/usb/net/usbnet.h>
  47. #endif
  48.  
  49. #include "ax88179_178a.h"
  50.  
  51. #define DRV_VERSION "1.19.0"
  52.  
  53. static char version[] =
  54. KERN_INFO "ASIX USB Ethernet Adapter:v" DRV_VERSION
  55. //  " " __TIME__ " " __DATE__ "\n"
  56. "       http://www.asix.com.tw\n";
  57.  
  58. static int msg_enable;
  59. module_param(msg_enable, int, 0);
  60. MODULE_PARM_DESC(msg_enable, "usbnet msg_enable");
  61.  
  62. static int bsize = -1;
  63. module_param(bsize, int, 0);
  64. MODULE_PARM_DESC(bsize, "RX Bulk IN Queue Size");
  65.  
  66. static int ifg = -1;
  67. module_param(ifg, int, 0);
  68. MODULE_PARM_DESC(ifg, "RX Bulk IN Inter Frame Gap");
  69.  
  70.  
  71. /* EEE advertisement is disabled in default setting */
  72. static int bEEE = 0;
  73. module_param(bEEE, int, 0);
  74. MODULE_PARM_DESC(bEEE, "EEE advertisement configuration");
  75.  
  76. /* Green ethernet advertisement is disabled in default setting */
  77. static int bGETH = 0;
  78. module_param(bGETH, int, 0);
  79. MODULE_PARM_DESC(bGETH, "Green ethernet configuration");
  80. /* ASIX AX88179/178A based USB 3.0/2.0 Gigabit Ethernet Devices */
  81.  
  82. static int __ax88179_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
  83.                   u16 size, void *data, int in_pm)
  84. {
  85.     int ret;
  86. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
  87.     int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
  88.  
  89.     BUG_ON(!dev);
  90.  
  91.     if (!in_pm)
  92.         fn = usbnet_read_cmd;
  93.     else
  94.         fn = usbnet_read_cmd_nopm;
  95.  
  96.     ret = fn(dev, cmd, USB_DIR_IN | USB_TYPE_VENDOR |
  97.          USB_RECIP_DEVICE, value, index, data, size);
  98.  
  99.     if (unlikely(ret < 0))
  100.         netdev_warn(dev->net, "Failed to read reg index 0x%04x: %d\n",
  101.                 index, ret);
  102. #else
  103.     ret = usb_control_msg(
  104.         dev->udev,
  105.         usb_rcvctrlpipe(dev->udev, 0),
  106.         cmd,
  107.         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  108.         value,
  109.         index,
  110.         data,
  111.         size,
  112.         USB_CTRL_GET_TIMEOUT);
  113. #endif
  114.     return ret;
  115. }
  116.  
  117. static int __ax88179_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
  118.                    u16 size, void *data, int in_pm)
  119. {
  120.     int ret;
  121. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
  122.     int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
  123.  
  124.     BUG_ON(!dev);
  125.  
  126.     if (!in_pm)
  127.         fn = usbnet_write_cmd;
  128.     else
  129.         fn = usbnet_write_cmd_nopm;
  130.  
  131.     ret = fn(dev, cmd, USB_DIR_OUT | USB_TYPE_VENDOR |
  132.          USB_RECIP_DEVICE, value, index, data, size);
  133.  
  134.     if (unlikely(ret < 0))
  135.         netdev_warn(dev->net, "Failed to write reg index 0x%04x: %d\n",
  136.                 index, ret);
  137. #else
  138.     ret = usb_control_msg(
  139.         dev->udev,
  140.         usb_sndctrlpipe(dev->udev, 0),
  141.         cmd,
  142.         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  143.         value,
  144.         index,
  145.         data,
  146.         size,
  147.         USB_CTRL_SET_TIMEOUT);
  148.  
  149. #endif
  150.     return ret;
  151. }
  152.  
  153. static int ax88179_read_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
  154.                  u16 index, u16 size, void *data, int eflag)
  155. {
  156.     int ret;
  157.  
  158.     if (eflag && (2 == size)) {
  159.         u16 buf = 0;
  160.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 1);
  161.         le16_to_cpus(&buf);
  162.         *((u16 *)data) = buf;
  163.     } else if (eflag && (4 == size)) {
  164.         u32 buf = 0;
  165.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 1);
  166.         le32_to_cpus(&buf);
  167.         *((u32 *)data) = buf;
  168.     } else {
  169.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, data, 1);
  170.     }
  171.  
  172.     return ret;
  173. }
  174.  
  175. static int ax88179_write_cmd_nopm(struct usbnet *dev, u8 cmd, u16 value,
  176.                   u16 index, u16 size, void *data)
  177. {
  178.     int ret;
  179.  
  180.     if (2 == size) {
  181.         u16 buf = 0;
  182.         buf = *((u16 *)data);
  183.         cpu_to_le16s(&buf);
  184.         ret = __ax88179_write_cmd(dev, cmd, value, index,
  185.                       size, &buf, 1);
  186.     } else {
  187.         ret = __ax88179_write_cmd(dev, cmd, value, index,
  188.                       size, data, 1);
  189.     }
  190.  
  191.     return ret;
  192. }
  193.  
  194. static int ax88179_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
  195.                 u16 size, void *data, int eflag)
  196. {
  197.  
  198.     int ret;
  199.  
  200.     if (eflag && (2 == size)) {
  201.         u16 buf = 0;
  202.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 0);
  203.         le16_to_cpus(&buf);
  204.         *((u16 *)data) = buf;
  205.     } else if (eflag && (4 == size)) {
  206.         u32 buf = 0;
  207.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, &buf, 0);
  208.         le32_to_cpus(&buf);
  209.         *((u32 *)data) = buf;
  210.     } else {
  211.         ret = __ax88179_read_cmd(dev, cmd, value, index, size, data, 0);
  212.     }
  213.  
  214.     return ret;
  215. }
  216.  
  217. static int ax88179_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
  218.                  u16 size, void *data)
  219. {
  220.     int ret;
  221.  
  222.     if (2 == size) {
  223.         u16 buf = 0;
  224.         buf = *((u16 *)data);
  225.         cpu_to_le16s(&buf);
  226.         ret = __ax88179_write_cmd(dev, cmd, value, index,
  227.                       size, &buf, 0);
  228.     } else {
  229.         ret = __ax88179_write_cmd(dev, cmd, value, index,
  230.                       size, data, 0);
  231.     }
  232.  
  233.     return ret;
  234. }
  235.  
  236. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
  237. static void ax88179_async_cmd_callback(struct urb *urb, struct pt_regs *regs)
  238. #else
  239. static void ax88179_async_cmd_callback(struct urb *urb)
  240. #endif
  241. {
  242.     struct ax88179_async_handle *asyncdata = (struct ax88179_async_handle *)urb->context;
  243.  
  244.     if (urb->status < 0)
  245.         printk(KERN_ERR "ax88179_async_cmd_callback() failed with %d",
  246.                urb->status);
  247.  
  248.     kfree(asyncdata->req);
  249.     kfree(asyncdata);  
  250.     usb_free_urb(urb);
  251.    
  252. }
  253.  
  254. static void
  255. ax88179_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
  256.                     u16 size, void *data)
  257. {
  258.     struct usb_ctrlrequest *req = NULL;
  259.     int status = 0;
  260.     struct urb *urb = NULL;
  261.     void *buf = NULL;
  262.     struct ax88179_async_handle *asyncdata = NULL;
  263.  
  264.     urb = usb_alloc_urb(0, GFP_ATOMIC);
  265.     if (urb == NULL) {
  266. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  267.         netdev_err(dev->net, "Error allocating URB in write_cmd_async!");
  268. #else
  269.         deverr(dev, "Error allocating URB in write_cmd_async!");
  270. #endif
  271.         return;
  272.     }
  273.  
  274.     req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
  275.     if (req == NULL) {
  276. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  277.         netdev_err(dev->net, "Failed to allocate memory for control request");
  278. #else
  279.         deverr(dev, "Failed to allocate memory for control request");
  280. #endif
  281.         usb_free_urb(urb);
  282.         return;
  283.     }
  284.  
  285.     asyncdata = (struct ax88179_async_handle*)
  286.             kmalloc(sizeof(struct ax88179_async_handle), GFP_ATOMIC);
  287.     if (asyncdata == NULL) {
  288. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  289.         netdev_err(dev->net, "Failed to allocate memory for async data");
  290. #else
  291.         deverr(dev, "Failed to allocate memory for async data");
  292. #endif
  293.         kfree(req);
  294.         usb_free_urb(urb);
  295.         return;
  296.     }
  297.  
  298.     asyncdata->req = req;
  299.    
  300.     if (size == 2) {
  301.         asyncdata->rxctl = *((u16 *)data);
  302.         cpu_to_le16s(&asyncdata->rxctl);
  303.         buf = &asyncdata->rxctl;
  304.     } else {
  305.         memcpy(asyncdata->m_filter, data, size);
  306.         buf = asyncdata->m_filter;
  307.     }
  308.  
  309.     req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
  310.     req->bRequest = cmd;
  311.     req->wValue = cpu_to_le16(value);
  312.     req->wIndex = cpu_to_le16(index);
  313.     req->wLength = cpu_to_le16(size);
  314.  
  315.     usb_fill_control_urb(urb, dev->udev,
  316.                  usb_sndctrlpipe(dev->udev, 0),
  317.                  (void *)req, buf, size,
  318.                  ax88179_async_cmd_callback, asyncdata);
  319.  
  320.     status = usb_submit_urb(urb, GFP_ATOMIC);
  321.     if (status < 0) {
  322. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  323.         netdev_err(dev->net, "Error submitting the control message: status=%d",
  324.                status);
  325. #else
  326.         deverr(dev, "Error submitting the control message: status=%d",
  327.                status);
  328. #endif
  329.         kfree(req);
  330.         kfree(asyncdata);
  331.         usb_free_urb(urb);
  332.     }
  333. }
  334.  
  335. static void ax88179_status(struct usbnet *dev, struct urb *urb)
  336. {
  337.     struct ax88179_int_data *event = NULL;
  338.     int link = 0;
  339.  
  340.     if (urb->actual_length < 8)
  341.         return;
  342.  
  343.     event = urb->transfer_buffer;
  344.     link = event->link & AX_INT_PPLS_LINK;
  345.  
  346.     if (netif_carrier_ok(dev->net) != link) {
  347.         if (link)
  348.             usbnet_defer_kevent(dev, EVENT_LINK_RESET);
  349.         else
  350.             netif_carrier_off(dev->net);
  351. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  352.         netdev_info(dev->net, "ax88179_178a - Link status is: %d\n",
  353.                 link);
  354. #else
  355.         devinfo(dev, "ax88179_178a - Link status is: %d\n", link);
  356. #endif
  357.     }
  358. }
  359.  
  360. static int ax88179_mdio_read(struct net_device *netdev, int phy_id, int loc)
  361. {
  362.     struct usbnet *dev = netdev_priv(netdev);
  363.     u16 res;
  364.     u16 *tmp16;
  365.  
  366.     tmp16 = kmalloc(2, GFP_KERNEL);
  367.     if (!tmp16)
  368.         return -ENOMEM;
  369.  
  370.     ax88179_read_cmd(dev, AX_ACCESS_PHY, phy_id, (__u16)loc, 2, tmp16, 1);
  371.  
  372.     res = *tmp16;
  373.     kfree(tmp16);
  374.  
  375.     return res;
  376. }
  377.  
  378. static void ax88179_mdio_write(struct net_device *netdev, int phy_id, int loc,
  379.                    int val)
  380. {
  381.     struct usbnet *dev = netdev_priv(netdev);
  382.     u16 *res;
  383.     res = kmalloc(2, GFP_KERNEL);
  384.     if (!res)
  385.         return;
  386.     *res = (u16)val;
  387.  
  388.     ax88179_write_cmd(dev, AX_ACCESS_PHY, phy_id, (__u16)loc, 2, res);
  389.  
  390.     kfree(res);
  391. }
  392.  
  393. static int ax88179_suspend(struct usb_interface *intf,
  394. #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 10)
  395.                pm_message_t message)
  396. #else
  397.                u32 message)
  398. #endif
  399. {
  400.     struct usbnet *dev = usb_get_intfdata(intf);
  401.     u16 *tmp16;
  402.     u8 *tmp8;  
  403.     usbnet_suspend(intf, message);
  404.  
  405.     tmp16 = kmalloc(3, GFP_KERNEL);
  406.     if (!tmp16)
  407.         return -ENOMEM;
  408.     tmp8 = (u8*)(&tmp16[2]);
  409.  
  410.     /* Disable RX path */
  411.     ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  412.                   2, 2, tmp16, 1);
  413.     *tmp16 &= ~AX_MEDIUM_RECEIVE_EN;
  414.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC,  AX_MEDIUM_STATUS_MODE,
  415.                    2, 2, tmp16);
  416.  
  417.     /* Force bz */
  418.     ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
  419.                   2, 2, tmp16, 1);
  420.     *tmp16 |= AX_PHYPWR_RSTCTL_BZ | AX_PHYPWR_RSTCTL_IPRL;
  421.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
  422.                    2, 2, tmp16);
  423.  
  424.     /* change clock */ 
  425.     *tmp8 = 0;
  426.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp8);
  427.  
  428.     /* Configure RX control register => stop operation */
  429.     *tmp16 = AX_RX_CTL_STOP;
  430.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
  431.  
  432.     kfree(tmp16);
  433.  
  434.     return 0;
  435. }
  436.  
  437.  
  438. static void ax88179_EEE_setting(struct usbnet *dev)
  439. {
  440.     u16 *tmp16;
  441.     tmp16 = kmalloc(2, GFP_KERNEL);
  442.     if (!tmp16)
  443.         return;
  444.    
  445.     if (bEEE) {
  446.         // Enable EEE
  447.         *tmp16 = 0x07;
  448.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  449.                   GMII_PHY_MACR, 2, tmp16);
  450.  
  451.         *tmp16 = 0x3c;
  452.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  453.                   GMII_PHY_MAADR, 2, tmp16);
  454.  
  455.         *tmp16 = 0x4007;
  456.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  457.                   GMII_PHY_MACR, 2, tmp16);
  458.  
  459.         *tmp16 = 0x06;
  460.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  461.                   GMII_PHY_MAADR, 2, tmp16);
  462.     } else {
  463.         // Disable EEE
  464.         *tmp16 = 0x07;
  465.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  466.                   GMII_PHY_MACR, 2, tmp16);
  467.  
  468.         *tmp16 = 0x3c;
  469.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  470.                   GMII_PHY_MAADR, 2, tmp16);
  471.  
  472.         *tmp16 = 0x4007;
  473.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  474.                   GMII_PHY_MACR, 2, tmp16);
  475.  
  476.         *tmp16 = 0x00;
  477.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  478.                   GMII_PHY_MAADR, 2, tmp16);
  479.     }
  480.  
  481.     kfree(tmp16);
  482. }
  483.  
  484. static void ax88179_Gether_setting(struct usbnet *dev)
  485. {
  486.     u16 *tmp16;
  487.     tmp16 = kmalloc(2, GFP_KERNEL);
  488.     if (!tmp16)
  489.         return;
  490.  
  491.     if (bGETH) {
  492.         // Enable Green Ethernet
  493.         *tmp16 = 0x03;
  494.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  495.                   31, 2, tmp16);
  496.  
  497.         *tmp16 = 0x3247;
  498.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  499.                   25, 2, tmp16);
  500.  
  501.         *tmp16 = 0x05;
  502.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  503.                   31, 2, tmp16);
  504.  
  505.         *tmp16 = 0x0680;
  506.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  507.                   1, 2, tmp16);
  508.  
  509.         *tmp16 = 0;
  510.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  511.                   31, 2, tmp16);
  512.     } else {
  513.         // Disable Green Ethernet
  514.         *tmp16 = 0x03;
  515.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  516.                   31, 2, tmp16);
  517.  
  518.         *tmp16 = 0x3246;
  519.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  520.                   25, 2, tmp16);
  521.  
  522.         *tmp16 = 0;
  523.         ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  524.                   31, 2, tmp16);
  525.     }
  526.  
  527.     kfree(tmp16);
  528. }
  529.  
  530. static int ax88179_resume(struct usb_interface *intf)
  531. {
  532.     struct usbnet *dev = usb_get_intfdata(intf);
  533.     u16 *tmp16;
  534.     u8 *tmp8;
  535.  
  536.     netif_carrier_off(dev->net);
  537.  
  538.     tmp16 = kmalloc(3, GFP_KERNEL);
  539.     if (!tmp16)
  540.         return -ENOMEM;
  541.     tmp8 = (u8*)(&tmp16[2]);
  542.  
  543.     /* Power up ethernet PHY */
  544.     *tmp16 = 0;
  545.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
  546.                    2, 2, tmp16);
  547. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
  548.     usleep_range(1000, 2000);
  549. #else
  550.     msleep(1);
  551. #endif
  552.     *tmp16 = AX_PHYPWR_RSTCTL_IPRL;
  553.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
  554.                    2, 2, tmp16);
  555.     msleep(200);
  556.  
  557.     /* Ethernet PHY Auto Detach*/
  558.     ax88179_AutoDetach(dev, 1);
  559.  
  560.     /* change clock */ 
  561.     ax88179_read_cmd_nopm(dev, AX_ACCESS_MAC,  AX_CLK_SELECT,
  562.                   1, 1, tmp8, 0);
  563.     *tmp8 |= AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
  564.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp8);
  565.     msleep(100);
  566.  
  567.     /* Configure RX control register => start operation */
  568.     *tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_START | AX_RX_CTL_AP |
  569.          AX_RX_CTL_AMALL | AX_RX_CTL_AB;
  570.     if (NET_IP_ALIGN == 0)
  571.         *tmp16 |= AX_RX_CTL_IPE;
  572.     ax88179_write_cmd_nopm(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
  573.  
  574.     kfree(tmp16);
  575.  
  576.     return usbnet_resume(intf);
  577. }
  578.  
  579. static void
  580. ax88179_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
  581. {
  582.  
  583.     struct usbnet *dev = netdev_priv(net);
  584.     u8 *opt = NULL;
  585.  
  586.     opt = kmalloc(1, GFP_KERNEL);
  587.     if (!opt)
  588.         return;
  589.  
  590.     if (ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE,
  591.                  1, 1, opt, 0) < 0) {
  592.         wolinfo->supported = 0;
  593.         wolinfo->wolopts = 0;
  594.         kfree(opt);
  595.         return;
  596.     }
  597.  
  598.     wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
  599.  
  600.     if (*opt & AX_MONITOR_MODE_RWLC)
  601.         wolinfo->wolopts |= WAKE_PHY;
  602.     if (*opt & AX_MONITOR_MODE_RWMP)
  603.         wolinfo->wolopts |= WAKE_MAGIC;
  604.  
  605.     kfree(opt);
  606. }
  607.  
  608. static int
  609. ax88179_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
  610. {
  611.     struct usbnet *dev = netdev_priv(net);
  612.     u8 *opt = NULL;
  613.  
  614.     opt = kmalloc(1, GFP_KERNEL);
  615.     if (!opt)
  616.         return -ENOMEM;
  617.  
  618.     *opt = 0;
  619.  
  620.     if (wolinfo->wolopts & WAKE_PHY)
  621.         *opt |= AX_MONITOR_MODE_RWLC;
  622.     else
  623.         *opt &= ~AX_MONITOR_MODE_RWLC;
  624.  
  625.     if (wolinfo->wolopts & WAKE_MAGIC)
  626.         *opt |= AX_MONITOR_MODE_RWMP;
  627.     else
  628.         *opt &= ~AX_MONITOR_MODE_RWMP;
  629.  
  630.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE, 1, 1, opt);
  631.  
  632.     kfree(opt);
  633.  
  634.     return 0;
  635. }
  636.  
  637. static int ax88179_get_eeprom_len(struct net_device *net)
  638. {
  639.     return 0;
  640.     /*return AX_EEPROM_LEN;*/
  641. }
  642.  
  643. static int
  644. ax88179_get_eeprom(struct net_device *net, struct ethtool_eeprom *eeprom,
  645.            u8 *data)
  646. {
  647.     struct usbnet *dev = netdev_priv(net);
  648.     u16 *eeprom_buff = NULL;
  649.     int first_word = 0, last_word = 0;
  650.     int i = 0;
  651.  
  652.     if (eeprom->len == 0)
  653.         return -EINVAL;
  654.  
  655.     eeprom->magic = AX88179_EEPROM_MAGIC;
  656.  
  657.     first_word = eeprom->offset >> 1;
  658.     last_word = (eeprom->offset + eeprom->len - 1) >> 1;
  659.     eeprom_buff = kmalloc(sizeof(u16) * (last_word - first_word + 1),
  660.                   GFP_KERNEL);
  661.     if (!eeprom_buff)
  662.         return -ENOMEM;
  663.  
  664.     /* ax88179/178A returns 2 bytes from eeprom on read */
  665.     for (i = first_word; i <= last_word; i++) {
  666.         if (ax88179_read_cmd(dev, AX_ACCESS_EEPROM, i, 1, 2,
  667.                      &(eeprom_buff[i - first_word]), 0) < 0) {
  668.             kfree(eeprom_buff);
  669.             return -EIO;
  670.         }
  671.     }
  672.  
  673.     memcpy(data, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);
  674.     kfree(eeprom_buff);
  675.     return 0;
  676. }
  677.  
  678. static void ax88179_get_drvinfo(struct net_device *net,
  679.                 struct ethtool_drvinfo *info)
  680. {
  681.     /* Inherit standard device info */
  682.     usbnet_get_drvinfo(net, info);
  683.     info->eedump_len = 0x3e;
  684. }
  685.  
  686. static int ax88179_get_link_ksettings(struct net_device *net, struct ethtool_link_ksettings *cmd)
  687. {
  688.     struct usbnet *dev = netdev_priv(net);
  689.     mii_ethtool_get_link_ksettings(&dev->mii, cmd);
  690.     return 0;
  691. }
  692.  
  693. static int ax88179_set_link_ksettings(struct net_device *net, const struct ethtool_link_ksettings *cmd)
  694. {
  695.     struct usbnet *dev = netdev_priv(net);
  696.     return mii_ethtool_set_link_ksettings(&dev->mii, cmd);
  697. }
  698.  
  699. static int ax88179_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
  700. {
  701.     struct usbnet *dev = netdev_priv(net);
  702.     return  generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
  703. }
  704.  
  705. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 28)
  706. static int ax88179_netdev_stop(struct net_device *net)
  707. {
  708.     struct usbnet *dev = netdev_priv(net);
  709.     u16 *tmp16;
  710.  
  711.     tmp16 = kmalloc(2, GFP_KERNEL);
  712.     if (!tmp16)
  713.         return -ENOMEM;
  714.  
  715.     ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  716.              2, 2, tmp16, 1);
  717.     *tmp16 &= ~AX_MEDIUM_RECEIVE_EN;
  718.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  719.               2, 2, tmp16);
  720.  
  721.     kfree(tmp16);  
  722.  
  723.     return 0;
  724. }
  725. #endif
  726.  
  727.  
  728. #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
  729. static int ax88179_set_csums(struct usbnet *dev)
  730. {
  731.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  732.     u8* checksum = 0;
  733.  
  734.     checksum = kmalloc(1, GFP_KERNEL);
  735.     if (!checksum)
  736.         return -ENOMEM;
  737.  
  738.     if (ax179_data->checksum & AX_RX_CHECKSUM)
  739.         *checksum = AX_RXCOE_DEF_CSUM;
  740.     else
  741.         *checksum = 0;
  742.  
  743.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, checksum);
  744.  
  745.     if (ax179_data->checksum & AX_TX_CHECKSUM)
  746.         *checksum = AX_TXCOE_DEF_CSUM;
  747.     else
  748.         *checksum = 0;
  749.  
  750.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, checksum);
  751.  
  752.     kfree(checksum);
  753.  
  754.     return 0;
  755. }
  756.  
  757. static u32 ax88179_get_tx_csum(struct net_device *netdev)
  758. {
  759.     struct usbnet *dev = netdev_priv(netdev);
  760.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  761.     return ax179_data->checksum & AX_TX_CHECKSUM;
  762. }
  763.  
  764. static u32 ax88179_get_rx_csum(struct net_device *netdev)
  765. {
  766.     struct usbnet *dev = netdev_priv(netdev);
  767.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  768.     return ax179_data->checksum & AX_RX_CHECKSUM;
  769. }
  770.  
  771. static int ax88179_set_rx_csum(struct net_device *netdev, u32 val)
  772. {
  773.     struct usbnet *dev = netdev_priv(netdev);
  774.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  775.  
  776.     if (val)
  777.         ax179_data->checksum |= AX_RX_CHECKSUM;
  778.     else
  779.         ax179_data->checksum &= ~AX_RX_CHECKSUM;
  780.     return ax88179_set_csums(dev);
  781. }
  782.  
  783. static int ax88179_set_tx_csum(struct net_device *netdev, u32 val)
  784. {
  785.     struct usbnet *dev = netdev_priv(netdev);
  786.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  787.  
  788.     if (val)
  789.         ax179_data->checksum |= AX_TX_CHECKSUM;
  790.     else
  791.         ax179_data->checksum &= ~AX_TX_CHECKSUM;
  792.  
  793.     ethtool_op_set_tx_csum(netdev, val);
  794.  
  795.     return ax88179_set_csums(dev);
  796. }
  797.  
  798. static int ax88179_set_tso(struct net_device *netdev, u32 data)
  799. {
  800.     if (data)
  801.         netdev->features |= NETIF_F_TSO;
  802.     else
  803.         netdev->features &= ~NETIF_F_TSO;
  804.  
  805.     return 0;
  806. }
  807. #endif
  808.  
  809. static struct ethtool_ops ax88179_ethtool_ops = {
  810.     .get_drvinfo        = ax88179_get_drvinfo,
  811.     .get_link       = ethtool_op_get_link,
  812.     .get_msglevel       = usbnet_get_msglevel,
  813.     .set_msglevel       = usbnet_set_msglevel,
  814.     .get_wol        = ax88179_get_wol,
  815.     .set_wol        = ax88179_set_wol,
  816.     .get_eeprom_len     = ax88179_get_eeprom_len,
  817.     .get_eeprom     = ax88179_get_eeprom,
  818.     .get_link_ksettings = ax88179_get_link_ksettings,
  819.     .set_link_ksettings = ax88179_set_link_ksettings,
  820.     .nway_reset         = usbnet_nway_reset
  821. /*#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
  822.     .set_tx_csum        = ax88179_set_tx_csum,
  823.     .get_tx_csum        = ax88179_get_tx_csum,
  824.     .get_rx_csum        = ax88179_get_rx_csum,
  825.     .set_rx_csum        = ax88179_set_rx_csum,
  826.     .get_tso        = ethtool_op_get_tso,
  827.     .set_tso        = ax88179_set_tso,
  828.     .get_sg         = ethtool_op_get_sg,
  829.     .set_sg         = ethtool_op_set_sg
  830. #endif*/
  831. };
  832.  
  833. static void ax88179_set_multicast(struct net_device *net)
  834. {
  835.     struct usbnet *dev = netdev_priv(net);
  836.     struct ax88179_data *data = (struct ax88179_data *)&dev->data;
  837.     u8 *m_filter = ((u8 *)dev->data) + 12;
  838.     int mc_count = 0;
  839.  
  840. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
  841.     mc_count = net->mc_count;
  842. #else
  843.     mc_count = netdev_mc_count(net);
  844. #endif
  845.  
  846.     data->rxctl = (AX_RX_CTL_START | AX_RX_CTL_AB);
  847.     if (NET_IP_ALIGN == 0)
  848.         data->rxctl |= AX_RX_CTL_IPE;
  849.  
  850.     if (net->flags & IFF_PROMISC) {
  851.         data->rxctl |= AX_RX_CTL_PRO;
  852.     } else if (net->flags & IFF_ALLMULTI
  853.            || mc_count > AX_MAX_MCAST) {
  854.         data->rxctl |= AX_RX_CTL_AMALL;
  855.     } else if (mc_count == 0) {
  856.         /* just broadcast and directed */
  857.     } else {
  858.         /* We use the 20 byte dev->data
  859.          * for our 8 byte filter buffer
  860.          * to avoid allocating memory that
  861.          * is tricky to free later */
  862.         u32 crc_bits = 0;
  863.  
  864. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
  865.         struct dev_mc_list *mc_list = net->mc_list;
  866.         int i = 0;
  867.  
  868.         memset(m_filter, 0, AX_MCAST_FILTER_SIZE);
  869.  
  870.         /* Build the multicast hash filter. */
  871.         for (i = 0; i < net->mc_count; i++) {
  872.             crc_bits =
  873.                 ether_crc(ETH_ALEN,
  874.                       mc_list->dmi_addr) >> 26;
  875.             *(m_filter + (crc_bits >> 3)) |=
  876.                 1 << (crc_bits & 7);
  877.             mc_list = mc_list->next;
  878.         }
  879. #else
  880.         struct netdev_hw_addr *ha = NULL;
  881.         memset(m_filter, 0, AX_MCAST_FILTER_SIZE);
  882.         netdev_for_each_mc_addr(ha, net) {
  883.             crc_bits = ether_crc(ETH_ALEN, ha->addr) >> 26;
  884.             *(m_filter + (crc_bits >> 3)) |=
  885.                 1 << (crc_bits & 7);
  886.         }
  887. #endif
  888.         ax88179_write_cmd_async(dev, AX_ACCESS_MAC,
  889.                     AX_MULTI_FILTER_ARRY,
  890.                     AX_MCAST_FILTER_SIZE,
  891.                     AX_MCAST_FILTER_SIZE, m_filter);
  892.  
  893.         data->rxctl |= AX_RX_CTL_AM;
  894.     }
  895.  
  896.     ax88179_write_cmd_async(dev, AX_ACCESS_MAC, AX_RX_CTL,
  897.                 2, 2, &data->rxctl);
  898. }
  899.  
  900. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
  901. static int
  902. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)
  903. ax88179_set_features(struct net_device *net, netdev_features_t features)
  904. #else
  905. ax88179_set_features(struct net_device *net, u32 features)
  906. #endif
  907.  
  908. {
  909.     u8 *tmp8;
  910.     struct usbnet *dev = netdev_priv(net); 
  911.  
  912. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0)
  913.     netdev_features_t changed = net->features ^ features;
  914. #else
  915.     u32 changed = net->features ^ features;
  916. #endif
  917.  
  918.     tmp8 = kmalloc(1, GFP_KERNEL);
  919.     if (!tmp8)
  920.         return -ENOMEM;
  921.  
  922.     if (changed & NETIF_F_IP_CSUM) {
  923.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL,
  924.                  1, 1, tmp8, 0);
  925.         *tmp8 ^= AX_TXCOE_TCP | AX_TXCOE_UDP;
  926.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp8);
  927.     }
  928.  
  929.     if (changed & NETIF_F_IPV6_CSUM) {
  930.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL,
  931.                  1, 1, tmp8, 0);
  932.         *tmp8 ^= AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
  933.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp8);
  934.     }
  935.  
  936.     if (changed & NETIF_F_RXCSUM) {
  937.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL,
  938.                  1, 1, tmp8, 0);
  939.         *tmp8 ^= AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
  940.                AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
  941.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, tmp8);
  942.     }
  943.  
  944.     kfree(tmp8);
  945.  
  946.     return 0;
  947. }
  948. #endif
  949.  
  950. static int ax88179_change_mtu(struct net_device *net, int new_mtu)
  951. {
  952.     struct usbnet *dev = netdev_priv(net);
  953.     u16 *tmp16;
  954.  
  955.     if (new_mtu <= 0 || new_mtu > 4088)
  956.         return -EINVAL;
  957.  
  958.     net->mtu = new_mtu;
  959.     dev->hard_mtu = net->mtu + net->hard_header_len;
  960.  
  961.     tmp16 = kmalloc(2, GFP_KERNEL);
  962.     if (!tmp16)
  963.         return -ENOMEM;
  964.  
  965.     if (net->mtu > 1500) {
  966.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  967.                  2, 2, tmp16, 1);
  968.         *tmp16 |= AX_MEDIUM_JUMBO_EN;
  969.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  970.                   2, 2, tmp16);
  971.     } else {
  972.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  973.                  2, 2, tmp16, 1);
  974.         *tmp16 &= ~AX_MEDIUM_JUMBO_EN;
  975.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  976.                   2, 2, tmp16);
  977.     }
  978.  
  979.     kfree(tmp16);
  980.  
  981.     return 0;
  982. }
  983.  
  984. static int ax88179_set_mac_addr(struct net_device *net, void *p)
  985. {
  986.     struct usbnet *dev = netdev_priv(net);
  987.     struct sockaddr *addr = p;
  988.  
  989.     if (netif_running(net))
  990.         return -EBUSY;
  991.     if (!is_valid_ether_addr(addr->sa_data))
  992.         return -EADDRNOTAVAIL;
  993.  
  994.     memcpy(net->dev_addr, addr->sa_data, ETH_ALEN);
  995.  
  996.     /* Set the MAC address */
  997.     return ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN,
  998.                  ETH_ALEN, net->dev_addr);
  999.  
  1000. }
  1001.  
  1002. #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 29)
  1003. static const struct net_device_ops ax88179_netdev_ops = {
  1004.     .ndo_open       = usbnet_open,
  1005.     .ndo_stop       = usbnet_stop,
  1006.     .ndo_start_xmit     = usbnet_start_xmit,
  1007.     .ndo_tx_timeout     = usbnet_tx_timeout,
  1008.     .ndo_change_mtu     = ax88179_change_mtu,
  1009.     .ndo_do_ioctl       = ax88179_ioctl,
  1010.     .ndo_set_mac_address    = ax88179_set_mac_addr,
  1011.     .ndo_validate_addr  = eth_validate_addr,
  1012. #if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 2, 0)
  1013.     .ndo_set_multicast_list = ax88179_set_multicast,
  1014. #else
  1015.     .ndo_set_rx_mode    = ax88179_set_multicast,
  1016. #endif
  1017. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
  1018.     .ndo_set_features   = ax88179_set_features,
  1019. #endif
  1020. };
  1021. #endif
  1022.  
  1023. static int ax88179_check_eeprom(struct usbnet *dev)
  1024. {
  1025.     u8 i = 0;
  1026.     u8 *buf;
  1027.     u8 *eeprom;
  1028.     u16 csum = 0, delay = HZ / 10;
  1029.     unsigned long jtimeout = 0;
  1030.  
  1031.     eeprom = kmalloc(22, GFP_KERNEL);
  1032.     if (!eeprom)
  1033.         return -ENOMEM;
  1034.     buf = &eeprom[20];
  1035.  
  1036.     /* Read EEPROM content */
  1037.     for (i = 0 ; i < 6; i++) {
  1038.         buf[0] = i;
  1039.         if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_ADDR,
  1040.                       1, 1, buf) < 0) {
  1041.             kfree(eeprom);
  1042.             return -EINVAL;
  1043.         }
  1044.  
  1045.         buf[0] = EEP_RD;
  1046.         if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
  1047.                       1, 1, buf) < 0) {
  1048.             kfree(eeprom);
  1049.             return -EINVAL;
  1050.         }
  1051.  
  1052.         jtimeout = jiffies + delay;
  1053.         do {
  1054.             ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
  1055.                      1, 1, buf, 0);
  1056.  
  1057.             if (time_after(jiffies, jtimeout)) {
  1058.                 kfree(eeprom);
  1059.                 return -EINVAL;
  1060.             }
  1061.         } while (buf[0] & EEP_BUSY);
  1062.  
  1063.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_LOW,
  1064.                  2, 2, &eeprom[i * 2], 0);
  1065.  
  1066.         if ((i == 0) && (eeprom[0] == 0xFF)) {
  1067.             kfree(eeprom);
  1068.             return -EINVAL;
  1069.         }
  1070.     }
  1071.  
  1072.     csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9];
  1073.     csum = (csum >> 8) + (csum & 0xff);
  1074.  
  1075.     if ((csum + eeprom[10]) == 0xff) {
  1076.         kfree(eeprom);
  1077.         return AX_EEP_EFUSE_CORRECT;
  1078.     } else {
  1079.         kfree(eeprom);
  1080.         return -EINVAL;
  1081.     }
  1082. }
  1083.  
  1084. static int ax88179_check_efuse(struct usbnet *dev, void *ledmode)
  1085. {
  1086.     u8  i = 0; 
  1087.     u16 csum = 0;
  1088.     u8  *efuse;
  1089.  
  1090.     efuse = kmalloc(64, GFP_KERNEL);
  1091.     if (!efuse)
  1092.         return -ENOMEM;
  1093.  
  1094.     if (ax88179_read_cmd(dev, AX_ACCESS_EFUSE, 0, 64, 64, efuse, 0) < 0) {
  1095.         kfree(efuse);
  1096.         return -EINVAL;
  1097.     }
  1098.  
  1099.     if (efuse[0] == 0xFF) {
  1100.         kfree(efuse);
  1101.         return -EINVAL;
  1102.     }
  1103.  
  1104.     for (i = 0; i < 64; i++)
  1105.         csum = csum + efuse[i];
  1106.  
  1107.     while (csum > 255)
  1108.         csum = (csum & 0x00FF) + ((csum >> 8) & 0x00FF);
  1109.  
  1110.     if (csum == 0xFF) {
  1111.         memcpy((u8 *)ledmode, &efuse[51], 2);
  1112.         kfree(efuse);
  1113.         return AX_EEP_EFUSE_CORRECT;
  1114.     } else {
  1115.         kfree(efuse);
  1116.         return -EINVAL;
  1117.     }
  1118. }
  1119.  
  1120. static int ax88179_convert_old_led(struct usbnet *dev, u8 efuse, void *ledvalue)
  1121. {
  1122.     u8 ledmode = 0;
  1123.     u16 *tmp16;
  1124.     u16 led = 0;
  1125.  
  1126.     tmp16 = kmalloc(2, GFP_KERNEL);
  1127.     if (!tmp16)
  1128.         return -ENOMEM;
  1129.  
  1130.     /* loaded the old eFuse LED Mode */
  1131.     if (efuse) {
  1132.         if (ax88179_read_cmd(dev, AX_ACCESS_EFUSE, 0x18,
  1133.                      1, 2, tmp16, 1) < 0) {
  1134.             kfree(tmp16);
  1135.             return -EINVAL;
  1136.     }
  1137.         ledmode = (u8)(*tmp16 & 0xFF);
  1138.     } else { /* loaded the old EEprom LED Mode */
  1139.         if (ax88179_read_cmd(dev, AX_ACCESS_EEPROM, 0x3C,
  1140.                      1, 2, tmp16, 1) < 0) {
  1141.             kfree(tmp16);
  1142.             return -EINVAL;
  1143.         }
  1144.         ledmode = (u8) (*tmp16 >> 8);
  1145.     }
  1146. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1147.     netdev_dbg(dev->net, "Old LED Mode = %02X\n", ledmode);
  1148. #else
  1149.     devdbg(dev, "Old LED Mode = %02X\n", ledmode);
  1150. #endif
  1151.     switch (ledmode) {
  1152.     case 0xFF:
  1153.         led = LED0_ACTIVE | LED1_LINK_10 | LED1_LINK_100 |
  1154.               LED1_LINK_1000 | LED2_ACTIVE | LED2_LINK_10 |
  1155.               LED2_LINK_100 | LED2_LINK_1000 | LED_VALID;
  1156.         break;
  1157.     case 0xFE:
  1158.         led = LED0_ACTIVE | LED1_LINK_1000 | LED2_LINK_100 | LED_VALID;
  1159.         break;
  1160.     case 0xFD:
  1161.         led = LED0_ACTIVE | LED1_LINK_1000 | LED2_LINK_100 |
  1162.               LED2_LINK_10 | LED_VALID;
  1163.         break;
  1164.     case 0xFC:
  1165.         led = LED0_ACTIVE | LED1_ACTIVE | LED1_LINK_1000 | LED2_ACTIVE |
  1166.               LED2_LINK_100 | LED2_LINK_10 | LED_VALID;
  1167.         break;
  1168.     default:
  1169.         led = LED0_ACTIVE | LED1_LINK_10 | LED1_LINK_100 |
  1170.               LED1_LINK_1000 | LED2_ACTIVE | LED2_LINK_10 |
  1171.               LED2_LINK_100 | LED2_LINK_1000 | LED_VALID;
  1172.         break;
  1173.     }
  1174.  
  1175.     memcpy((u8 *)ledvalue, &led, 2);
  1176.     kfree(tmp16);
  1177.  
  1178.     return 0;
  1179. }
  1180.  
  1181. static int ax88179_led_setting(struct usbnet *dev)
  1182. {
  1183.    
  1184.     u16 ledvalue = 0, delay = HZ / 10;
  1185.     u16 *ledact, *ledlink;
  1186.     u16 *tmp16;
  1187.     u8 *value;
  1188.     u8 *tmp;
  1189.     unsigned long jtimeout = 0;
  1190.  
  1191.     tmp = kmalloc(6, GFP_KERNEL);
  1192.     if (!tmp)
  1193.         return -ENOMEM;
  1194.  
  1195.     value = (u8*)tmp;
  1196.     tmp16 = (u16*)tmp;
  1197.     ledact = (u16*)(&tmp[2]);
  1198.     ledlink = (u16*)(&tmp[4]);
  1199.  
  1200.     /* Check AX88179 version. UA1 or UA2 */
  1201.     ax88179_read_cmd(dev, AX_ACCESS_MAC, GENERAL_STATUS, 1, 1, value, 0);
  1202.  
  1203.     /* UA1 */
  1204.     if (!(*value & AX_SECLD)) {
  1205.         *value = AX_GPIO_CTRL_GPIO3EN | AX_GPIO_CTRL_GPIO2EN |
  1206.             AX_GPIO_CTRL_GPIO1EN;
  1207.         if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_GPIO_CTRL,
  1208.                       1, 1, value) < 0) {
  1209.             kfree(tmp);
  1210.             return -EINVAL;
  1211.         }
  1212.     }
  1213.  
  1214.     /* check EEprom */
  1215.     if (ax88179_check_eeprom(dev) == AX_EEP_EFUSE_CORRECT) {
  1216.         *value = 0x42;
  1217.         if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_ADDR,
  1218.                       1, 1, value) < 0) {
  1219.             kfree(tmp);
  1220.             return -EINVAL;
  1221.         }
  1222.  
  1223.         *value = EEP_RD;
  1224.         if (ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
  1225.                       1, 1, value) < 0) {
  1226.             kfree(tmp);
  1227.             return -EINVAL;
  1228.         }
  1229.  
  1230.         jtimeout = jiffies + delay;
  1231.         do {
  1232.             ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
  1233.                      1, 1, value, 0);
  1234.  
  1235.             ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_CMD,
  1236.                      1, 1, value, 0);
  1237.  
  1238.             if (time_after(jiffies, jtimeout))
  1239.                 return -EINVAL;
  1240.         } while (*value & EEP_BUSY);
  1241.  
  1242.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_HIGH,
  1243.                  1, 1, value, 0);
  1244.         ledvalue = (*value << 8);
  1245.         ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_SROM_DATA_LOW,
  1246.                  1, 1, value, 0);
  1247.         ledvalue |= *value;
  1248.  
  1249.         /* load internal ROM for defaule setting */
  1250.         if ((ledvalue == 0xFFFF) || ((ledvalue & LED_VALID) == 0))
  1251.             ax88179_convert_old_led(dev, 0, &ledvalue);
  1252.  
  1253.     } else if (ax88179_check_efuse(dev, &ledvalue) ==
  1254.                        AX_EEP_EFUSE_CORRECT) { /* check efuse */
  1255.         if ((ledvalue == 0xFFFF) || ((ledvalue & LED_VALID) == 0))
  1256.             ax88179_convert_old_led(dev, 0, &ledvalue);
  1257.     } else {
  1258.         ax88179_convert_old_led(dev, 0, &ledvalue);
  1259.     }
  1260.  
  1261.     *tmp16 = GMII_PHY_PAGE_SELECT_EXT;
  1262.     ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1263.               GMII_PHY_PAGE_SELECT, 2, tmp16);
  1264.  
  1265.     *tmp16 = 0x2c;
  1266.     ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1267.               GMII_PHYPAGE, 2, tmp16);
  1268.  
  1269.     ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1270.              GMII_LED_ACTIVE, 2, ledact, 1);
  1271.  
  1272.     ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1273.              GMII_LED_LINK, 2, ledlink, 1);
  1274.  
  1275.     *ledact &= GMII_LED_ACTIVE_MASK;
  1276.     *ledlink &= GMII_LED_LINK_MASK;
  1277.  
  1278.     if (ledvalue & LED0_ACTIVE)
  1279.         *ledact |= GMII_LED0_ACTIVE;
  1280.     if (ledvalue & LED1_ACTIVE)
  1281.         *ledact |= GMII_LED1_ACTIVE;
  1282.     if (ledvalue & LED2_ACTIVE)
  1283.         *ledact |= GMII_LED2_ACTIVE;
  1284.  
  1285.     if (ledvalue & LED0_LINK_10)
  1286.         *ledlink |= GMII_LED0_LINK_10;
  1287.     if (ledvalue & LED1_LINK_10)
  1288.         *ledlink |= GMII_LED1_LINK_10;
  1289.     if (ledvalue & LED2_LINK_10)
  1290.         *ledlink |= GMII_LED2_LINK_10;
  1291.  
  1292.     if (ledvalue & LED0_LINK_100)
  1293.         *ledlink |= GMII_LED0_LINK_100;
  1294.     if (ledvalue & LED1_LINK_100)
  1295.         *ledlink |= GMII_LED1_LINK_100;
  1296.     if (ledvalue & LED2_LINK_100)
  1297.         *ledlink |= GMII_LED2_LINK_100;
  1298.  
  1299.     if (ledvalue & LED0_LINK_1000)
  1300.         *ledlink |= GMII_LED0_LINK_1000;
  1301.     if (ledvalue & LED1_LINK_1000)
  1302.         *ledlink |= GMII_LED1_LINK_1000;
  1303.     if (ledvalue & LED2_LINK_1000)
  1304.         *ledlink |= GMII_LED2_LINK_1000;
  1305.    
  1306.     ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1307.               GMII_LED_ACTIVE, 2, ledact);
  1308.  
  1309.     ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1310.               GMII_LED_LINK, 2, ledlink);
  1311.  
  1312.     *tmp16 = GMII_PHY_PAGE_SELECT_PAGE0;
  1313.     ax88179_write_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID,
  1314.               GMII_PHY_PAGE_SELECT, 2, tmp16);
  1315.  
  1316.     /* LED full duplex setting */
  1317.     *tmp16 = 0;
  1318.     if (ledvalue & LED0_FD)
  1319.         *tmp16 |= 0x01;
  1320.     else if ((ledvalue & LED0_USB3_MASK) == 0)
  1321.         *tmp16 |= 0x02;
  1322.  
  1323.  
  1324.     if (ledvalue & LED1_FD)
  1325.         *tmp16 |= 0x04;
  1326.     else if ((ledvalue & LED1_USB3_MASK) == 0)
  1327.         *tmp16 |= 0x08;
  1328.  
  1329.     if (ledvalue & LED2_FD) /* LED2_FD */
  1330.         *tmp16 |= 0x10;
  1331.     else if ((ledvalue & LED2_USB3_MASK) == 0) /* LED2_USB3 */
  1332.         *tmp16 |= 0x20;
  1333.  
  1334.     ax88179_write_cmd(dev, AX_ACCESS_MAC, 0x73, 1, 1, tmp16);
  1335.  
  1336.     kfree(tmp);
  1337.  
  1338.     return 0;
  1339. }
  1340.  
  1341. static int ax88179_AutoDetach(struct usbnet *dev, int in_pm)
  1342. {
  1343.     u16 *tmp16;
  1344.     u8 *tmp8;
  1345.     int (*fnr)(struct usbnet *, u8, u16, u16, u16, void *, int);
  1346.     int (*fnw)(struct usbnet *, u8, u16, u16, u16, void *);
  1347.  
  1348.     if (!in_pm) {
  1349.         fnr = ax88179_read_cmd;
  1350.         fnw = ax88179_write_cmd;
  1351.     } else {
  1352.         fnr = ax88179_read_cmd_nopm;
  1353.         fnw = ax88179_write_cmd_nopm;
  1354.     }
  1355.  
  1356.     tmp16 = kmalloc(3, GFP_KERNEL);
  1357.     if (!tmp16)
  1358.         return -ENOMEM;
  1359.  
  1360.     tmp8 = (u8*)(&tmp16[2]);
  1361.  
  1362.     if (fnr(dev, AX_ACCESS_EEPROM, 0x43, 1, 2, tmp16, 1) < 0) {
  1363.         kfree(tmp16);
  1364.         return 0;
  1365.     }
  1366.  
  1367.     if ((*tmp16 == 0xFFFF) || (!(*tmp16 & 0x0100))) {
  1368.         kfree(tmp16);
  1369.         return 0;
  1370.     }
  1371.  
  1372.     /* Enable Auto Detach bit */   
  1373.     *tmp8 = 0;
  1374.     fnr(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp8, 0);
  1375.     *tmp8 |= AX_CLK_SELECT_ULR;
  1376.     fnw(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp8);
  1377.  
  1378.     fnr(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16, 1);
  1379.     *tmp16 |= AX_PHYPWR_RSTCTL_AUTODETACH;
  1380.     fnw(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
  1381.  
  1382.     kfree(tmp16);
  1383.  
  1384.     return 0;
  1385. }
  1386.  
  1387. static int access_eeprom_mac(struct usbnet *dev, u8 *buf, u8 offset, int wflag)
  1388. {
  1389.     int ret = 0, i;
  1390.     u16* tmp = (u16*)buf;
  1391.     u16* tmp16;
  1392.     tmp16 = kmalloc(2, GFP_KERNEL);
  1393.     if (!tmp16)
  1394.         return -ENOMEM;
  1395.  
  1396.     for (i = 0; i < (ETH_ALEN >> 1); i++) {
  1397.         if (wflag) {           
  1398.             *tmp16 = cpu_to_le16(*(tmp + i));
  1399.             ret = ax88179_write_cmd(dev, AX_ACCESS_EEPROM,
  1400.                         offset + i, 1, 2, tmp16);
  1401.             if (ret < 0)
  1402.                 break;
  1403.  
  1404.             mdelay(15);
  1405.         }
  1406.         else {
  1407.             ret = ax88179_read_cmd(dev, AX_ACCESS_EEPROM,
  1408.                         offset + i, 1, 2, tmp + i, 0);
  1409.             if (ret < 0)
  1410.                 break;
  1411.         }
  1412.     }
  1413.  
  1414.     if (!wflag) {
  1415.         if (ret < 0) {
  1416.             #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1417.                 netdev_dbg(dev->net, "Failed to read MAC address from EEPROM: %d\n", ret);
  1418.             #else
  1419.                 devdbg(dev, "Failed to read MAC address from EEPROM: %d\n", ret);
  1420.             #endif
  1421.             kfree(tmp16);
  1422.             return ret;
  1423.         }
  1424.         memcpy(dev->net->dev_addr, buf, ETH_ALEN);
  1425.     }
  1426.     else {
  1427.         /* reload eeprom data */
  1428.         ret = ax88179_write_cmd(dev, AX_RELOAD_EEPROM_EFUSE, 0, 0, 0, 0);
  1429.         if (ret < 0) {
  1430.             kfree(tmp16);
  1431.             return ret;
  1432.         }
  1433.     }
  1434.  
  1435.     kfree(tmp16);
  1436.     return 0;
  1437. }
  1438.  
  1439. static int ax88179_check_ether_addr(struct usbnet *dev)
  1440. {
  1441.     unsigned char *tmp = (unsigned char*)dev->net->dev_addr;
  1442.     u8 default_mac[6] = {0, 0x0e, 0xc6, 0x81, 0x79, 0x01};
  1443.     u8 default_mac_178a[6] = {0, 0x0e, 0xc6, 0x81, 0x78, 0x01};
  1444.  
  1445.     if (((*((u8*)tmp) == 0) && (*((u8*)tmp + 1) == 0) && (*((u8*)tmp + 2) == 0)) ||
  1446.         !is_valid_ether_addr((u8*)tmp) ||
  1447.         !memcmp(dev->net->dev_addr, default_mac, ETH_ALEN) ||
  1448.         !memcmp(dev->net->dev_addr, default_mac_178a, ETH_ALEN)) {
  1449.         int i;
  1450.  
  1451.         printk("Found invalid EEPROM MAC address value ");
  1452.  
  1453.         for (i = 0; i < ETH_ALEN; i++) {
  1454.             printk("%02X", *((u8*)tmp + i));
  1455.             if (i != 5)
  1456.                 printk("-");
  1457.         }
  1458.         printk("\n");
  1459. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
  1460.         eth_hw_addr_random(dev->net);
  1461. #else
  1462. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)
  1463.         dev->net->addr_assign_type |= NET_ADDR_RANDOM;
  1464. #endif
  1465.         random_ether_addr(dev->net->dev_addr);
  1466. #endif
  1467.         *tmp = 0;
  1468.         *(tmp + 1) = 0x0E;
  1469.         *(tmp + 2) = 0xC6;
  1470.         *(tmp + 3) = 0x8E;
  1471.  
  1472.         return -EADDRNOTAVAIL; 
  1473.     }
  1474.     return 0;
  1475. }
  1476.  
  1477. static int ax88179_get_mac(struct usbnet *dev, u8* buf)
  1478. {
  1479.     int ret, i;
  1480.  
  1481.     ret = access_eeprom_mac(dev, buf, 0x0, 0);
  1482.     if (ret < 0)
  1483.         goto out;
  1484.  
  1485.     if (ax88179_check_ether_addr(dev)) {
  1486.         ret = access_eeprom_mac(dev, dev->net->dev_addr, 0x0, 1);
  1487.         if (ret < 0) {
  1488. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1489.         netdev_err(dev->net, "Failed to write MAC to EEPROM: %d", ret);
  1490. #else
  1491.         deverr(dev, "Failed to write MAC to EEPROM: %d", ret);
  1492. #endif
  1493.             goto out;
  1494.         }
  1495.  
  1496.         msleep(5);
  1497.  
  1498.         ret = ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID,
  1499.                        ETH_ALEN, ETH_ALEN, buf, 0);
  1500.         if (ret < 0) {
  1501. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1502.         netdev_err(dev->net, "Failed to read MAC address: %d", ret);
  1503. #else
  1504.         deverr(dev, "Failed to read MAC address: %d", ret);
  1505. #endif
  1506.             goto out;
  1507.         }
  1508.  
  1509.         for (i = 0; i < ETH_ALEN; i++)
  1510.             if (*(dev->net->dev_addr + i) != *((u8*)buf + i)) {
  1511. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1512.         netdev_warn(dev->net, "Found invalid EEPROM part or non-EEPROM");
  1513. #else
  1514.         devwarn(dev, "Found invalid EEPROM part or non-EEPROM");
  1515. #endif
  1516.                 break;
  1517.             }
  1518.     }
  1519.  
  1520.     memcpy(dev->net->perm_addr, dev->net->dev_addr, ETH_ALEN);
  1521.  
  1522.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN,
  1523.               ETH_ALEN, dev->net->dev_addr);
  1524.    
  1525.     if (ret < 0) {
  1526. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1527.         netdev_err(dev->net, "Failed to write MAC address: %d", ret);
  1528. #else
  1529.         deverr(dev, "Failed to write MAC address: %d", ret);
  1530. #endif
  1531.         goto out;
  1532.     }
  1533.  
  1534.     return 0;
  1535. out:
  1536.     return ret;
  1537. }
  1538.  
  1539. static int ax88179_bind(struct usbnet *dev, struct usb_interface *intf)
  1540. {
  1541.     void *buf = NULL;
  1542.     u16 *tmp16 = NULL;
  1543.     u8 *tmp = NULL;
  1544.     int ret;
  1545.  
  1546.     struct ax88179_data *ax179_data = (struct ax88179_data *)dev->data;
  1547.  
  1548.     usbnet_get_endpoints(dev, intf);
  1549.  
  1550.     if (msg_enable != 0)
  1551.         dev->msg_enable = msg_enable;
  1552.  
  1553.     buf = kmalloc(6, GFP_KERNEL);
  1554.     if (!buf) {
  1555. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1556.         netdev_err(dev->net, "Cannot allocate memory for buffer");
  1557. #else
  1558.         deverr(dev, "Cannot allocate memory for buffer");
  1559. #endif
  1560.         return -ENOMEM;
  1561.     }
  1562.     tmp16 = (u16 *)buf;
  1563.     tmp = (u8 *)buf;
  1564.  
  1565.     memset(ax179_data, 0, sizeof(*ax179_data));
  1566.  
  1567.     /* Power up ethernet PHY */
  1568.     *tmp16 = 0;
  1569.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
  1570.     *tmp16 = AX_PHYPWR_RSTCTL_IPRL;
  1571.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
  1572.     msleep(200);
  1573.  
  1574.     *tmp = AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
  1575.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp);
  1576.     msleep(100);
  1577.  
  1578.     /* Get the MAC address */
  1579.     memset(buf, 0, ETH_ALEN);
  1580.     ret = ax88179_get_mac(dev, buf);
  1581.     if (ret)
  1582.         goto out;
  1583.  
  1584. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1585.         netdev_dbg(dev->net, "MAC [%02x-%02x-%02x-%02x-%02x-%02x]\n",
  1586.                dev->net->dev_addr[0], dev->net->dev_addr[1],
  1587.                dev->net->dev_addr[2], dev->net->dev_addr[3],
  1588.                dev->net->dev_addr[4], dev->net->dev_addr[5]);
  1589. #else
  1590.         devdbg(dev, "MAC [%02x-%02x-%02x-%02x-%02x-%02x]\n",
  1591.                dev->net->dev_addr[0], dev->net->dev_addr[1],
  1592.                dev->net->dev_addr[2], dev->net->dev_addr[3],
  1593.                dev->net->dev_addr[4], dev->net->dev_addr[5]);
  1594. #endif
  1595.  
  1596.     /* RX bulk configuration, default for USB3.0 to Giga*/
  1597.     memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
  1598.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
  1599.  
  1600.     dev->rx_urb_size = 1024 * 20;
  1601.  
  1602.     tmp[0] = 0x34;
  1603.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_LOW, 1, 1, tmp);
  1604.  
  1605.     tmp[0] = 0x52;
  1606.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH,
  1607.               1, 1, tmp);
  1608.  
  1609.     /* Disable auto-power-OFF GigaPHY after ethx down*/
  1610.     ax88179_write_cmd(dev, 0x91, 0, 0, 0, NULL);
  1611.  
  1612. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)
  1613.     dev->net->do_ioctl = ax88179_ioctl;
  1614.     dev->net->set_multicast_list = ax88179_set_multicast;
  1615.     dev->net->set_mac_address = ax88179_set_mac_addr;
  1616.     dev->net->change_mtu = ax88179_change_mtu;
  1617. #if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 28)
  1618.     dev->net->stop = ax88179_netdev_stop;
  1619. #endif
  1620. #else
  1621.     dev->net->netdev_ops = &ax88179_netdev_ops;
  1622. #endif
  1623.  
  1624.     dev->net->ethtool_ops = &ax88179_ethtool_ops;
  1625. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 30)
  1626.     dev->net->needed_headroom = 8;
  1627. #endif
  1628.  
  1629.     /* Initialize MII structure */
  1630.     dev->mii.dev = dev->net;
  1631.     dev->mii.mdio_read = ax88179_mdio_read;
  1632.     dev->mii.mdio_write = ax88179_mdio_write;
  1633.     dev->mii.phy_id_mask = 0xff;
  1634.     dev->mii.reg_num_mask = 0xff;
  1635.     dev->mii.phy_id = 0x03;
  1636.     dev->mii.supports_gmii = 1;
  1637.  
  1638.     dev->net->features |= NETIF_F_IP_CSUM;
  1639. #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
  1640.     dev->net->features |= NETIF_F_IPV6_CSUM;
  1641. #endif
  1642. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0)
  1643.     if (usb_device_no_sg_constraint(dev->udev))
  1644.         dev->can_dma_sg = 1;
  1645.     dev->net->features |= NETIF_F_SG | NETIF_F_TSO;
  1646. #endif
  1647.  
  1648. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
  1649.     dev->net->hw_features |= NETIF_F_IP_CSUM;
  1650.     dev->net->hw_features |= NETIF_F_IPV6_CSUM;
  1651.     dev->net->hw_features |= NETIF_F_SG | NETIF_F_TSO;
  1652. #endif
  1653.  
  1654.     /* Enable checksum offload */
  1655.     *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
  1656.            AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
  1657.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, tmp);
  1658.  
  1659.     *tmp = AX_TXCOE_IP | AX_TXCOE_TCP | AX_TXCOE_UDP |
  1660.            AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
  1661.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp);
  1662.  
  1663.     ax179_data->checksum |= AX_RX_CHECKSUM | AX_TX_CHECKSUM;
  1664.  
  1665.     /* Configure RX control register => start operation */
  1666.     *tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_START | AX_RX_CTL_AP |
  1667.          AX_RX_CTL_AMALL | AX_RX_CTL_AB;
  1668.     if (NET_IP_ALIGN == 0)
  1669.         *tmp16 |= AX_RX_CTL_IPE;
  1670.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
  1671.  
  1672.     *tmp = AX_MONITOR_MODE_PMETYPE | AX_MONITOR_MODE_PMEPOL |
  1673.                         AX_MONITOR_MODE_RWMP;
  1674.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE, 1, 1, tmp);
  1675.  
  1676.     ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE, 1, 1, tmp, 0);
  1677. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1678.         netdev_dbg(dev->net, "Monitor mode = 0x%02x\n", *tmp);
  1679. #else
  1680.         devdbg(dev, "Monitor mode = 0x%02x\n", *tmp);
  1681. #endif
  1682.     /* Configure default medium type => giga */
  1683.     *tmp16 = AX_MEDIUM_RECEIVE_EN    | AX_MEDIUM_TXFLOW_CTRLEN |
  1684.          AX_MEDIUM_RXFLOW_CTRLEN | AX_MEDIUM_FULL_DUPLEX   |
  1685.          AX_MEDIUM_GIGAMODE;
  1686.  
  1687.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  1688.               2, 2, tmp16);
  1689.  
  1690.     ax88179_led_setting(dev);
  1691.  
  1692.     ax88179_EEE_setting(dev);
  1693.  
  1694.     ax88179_Gether_setting(dev);
  1695.  
  1696.     /* Restart autoneg */
  1697.     mii_nway_restart(&dev->mii);
  1698.  
  1699.     netif_carrier_off(dev->net);
  1700.  
  1701.     kfree(buf);
  1702.     printk(version);
  1703. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  1704.         netdev_info(dev->net, "mtu %d\n", dev->net->mtu);
  1705. #else
  1706.         devinfo(dev, "mtu %d\n", dev->net->mtu);
  1707. #endif
  1708.     return 0;
  1709.  
  1710. out:
  1711.     kfree(buf);
  1712.     return ret;
  1713.  
  1714. }
  1715.  
  1716. static void ax88179_unbind(struct usbnet *dev, struct usb_interface *intf)
  1717. {
  1718.     u16 *tmp16;
  1719.     u8 *tmp8;
  1720.     struct ax88179_data *ax179_data = (struct ax88179_data *) dev->data;
  1721.  
  1722.     tmp16 = kmalloc(3, GFP_KERNEL);
  1723.     if (!tmp16)
  1724.         return;
  1725.     tmp8 = (u8*)(&tmp16[2]);
  1726.  
  1727.     if (ax179_data) {
  1728.         /* Configure RX control register => stop operation */
  1729.         *tmp16 = AX_RX_CTL_STOP;
  1730.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
  1731.  
  1732.         *tmp8 = 0x0;
  1733.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT,
  1734.                   1, 1, tmp8);
  1735.  
  1736.         /* Power down ethernet PHY */
  1737.         *tmp16 = AX_PHYPWR_RSTCTL_BZ | AX_PHYPWR_RSTCTL_IPRL;
  1738.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL,
  1739.                   2, 2, tmp16);
  1740.         msleep(200);
  1741.     }
  1742.  
  1743.     kfree(tmp16);
  1744. }
  1745.  
  1746. static void
  1747. ax88179_rx_checksum(struct sk_buff *skb, u32 *pkt_hdr)
  1748. {
  1749.     skb->ip_summed = CHECKSUM_NONE;
  1750.  
  1751.     /* checksum error bit is set */
  1752.     if ((*pkt_hdr & AX_RXHDR_L3CSUM_ERR) ||
  1753.         (*pkt_hdr & AX_RXHDR_L4CSUM_ERR))
  1754.         return;
  1755.  
  1756.     /* It must be a TCP or UDP packet with a valid checksum */
  1757.     if (((*pkt_hdr & AX_RXHDR_L4_TYPE_MASK) == AX_RXHDR_L4_TYPE_TCP) ||
  1758.         ((*pkt_hdr & AX_RXHDR_L4_TYPE_MASK) == AX_RXHDR_L4_TYPE_UDP))
  1759.         skb->ip_summed = CHECKSUM_UNNECESSARY;
  1760. }
  1761.  
  1762. static int ax88179_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
  1763. {
  1764.     struct sk_buff *ax_skb = NULL;
  1765.     int pkt_cnt = 0;
  1766.     u32 rx_hdr = 0;
  1767.     u16 hdr_off = 0;
  1768.     u32 *pkt_hdr = NULL;
  1769.  
  1770.     skb_trim(skb, skb->len - 4);
  1771. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 22)
  1772.     memcpy(&rx_hdr, skb_tail_pointer(skb), sizeof(rx_hdr));
  1773. #else
  1774.     memcpy(&rx_hdr, skb->tail, sizeof(rx_hdr));
  1775. #endif
  1776.     le32_to_cpus(&rx_hdr);
  1777.  
  1778.     pkt_cnt = (u16)rx_hdr;
  1779.     hdr_off = (u16)(rx_hdr >> 16);
  1780.     pkt_hdr = (u32 *)(skb->data + hdr_off);
  1781.  
  1782.  
  1783.     while (pkt_cnt--) {
  1784.         u16 pkt_len;
  1785.  
  1786.         le32_to_cpus(pkt_hdr);
  1787.         pkt_len = (*pkt_hdr >> 16) & 0x1fff;
  1788.  
  1789.         /* Check CRC or runt packet */
  1790.         if ((*pkt_hdr & AX_RXHDR_CRC_ERR) ||
  1791.             (*pkt_hdr & AX_RXHDR_DROP_ERR)) {
  1792.             skb_pull(skb, (pkt_len + 7) & 0xFFF8);
  1793.             pkt_hdr++;
  1794.             continue;
  1795.         }
  1796.  
  1797.         if (pkt_cnt == 0) {        
  1798.             skb->len = pkt_len;
  1799.  
  1800.             /* Skip IP alignment psudo header */
  1801.             if (NET_IP_ALIGN == 0)
  1802.                 skb_pull(skb, 2);
  1803.  
  1804. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
  1805.             skb->tail = skb->data + skb->len;
  1806. #else
  1807.             skb_set_tail_pointer(skb, skb->len);
  1808. #endif
  1809.             skb->truesize = skb->len + sizeof(struct sk_buff);
  1810.             ax88179_rx_checksum(skb, pkt_hdr);
  1811.  
  1812.             return 1;
  1813.         }
  1814.  
  1815. #ifndef RX_SKB_COPY
  1816.         ax_skb = skb_clone(skb, GFP_ATOMIC);
  1817. #else
  1818.         ax_skb = alloc_skb(pkt_len + NET_IP_ALIGN, GFP_ATOMIC);
  1819.         skb_reserve(ax_skb, NET_IP_ALIGN);
  1820. #endif
  1821.  
  1822.         if (ax_skb) {
  1823. #ifndef RX_SKB_COPY
  1824.             ax_skb->len = pkt_len;
  1825.    
  1826.             /* Skip IP alignment psudo header */
  1827.             if (NET_IP_ALIGN == 0)
  1828.                 skb_pull(ax_skb, 2);
  1829.  
  1830. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
  1831.             ax_skb->tail = ax_skb->data + ax_skb->len;
  1832. #else
  1833.             skb_set_tail_pointer(ax_skb, ax_skb->len);
  1834. #endif
  1835.  
  1836. #else
  1837.             skb_put(ax_skb, pkt_len);
  1838.             memcpy(ax_skb->data, skb->data, pkt_len);
  1839.  
  1840.             if (NET_IP_ALIGN == 0)
  1841.                 skb_pull(ax_skb, 2);
  1842. #endif
  1843.             ax_skb->truesize = ax_skb->len + sizeof(struct sk_buff);
  1844.             ax88179_rx_checksum(ax_skb, pkt_hdr);
  1845.             usbnet_skb_return(dev, ax_skb);
  1846.         } else {
  1847.             return 0;
  1848.         }
  1849.  
  1850.         skb_pull(skb, (pkt_len + 7) & 0xFFF8);
  1851.         pkt_hdr++;
  1852.     }
  1853.     return 1;
  1854. }
  1855.  
  1856. static struct sk_buff *
  1857. ax88179_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
  1858. {
  1859.     u32 tx_hdr1 = 0, tx_hdr2 = 0;
  1860.     int frame_size = dev->maxpacket;
  1861. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
  1862.     int mss = skb_shinfo(skb)->gso_size;
  1863. #else
  1864.     int mss = 0;
  1865. #endif
  1866.     int headroom = 0;
  1867.     int tailroom = 0;
  1868.  
  1869.     tx_hdr1 = skb->len;
  1870.     tx_hdr2 = mss;
  1871.     if (((skb->len + 8) % frame_size) == 0)
  1872.         tx_hdr2 |= 0x80008000;  /* Enable padding */
  1873.  
  1874. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0)
  1875.     if (!dev->can_dma_sg && (dev->net->features & NETIF_F_SG) &&
  1876.         skb_linearize(skb))
  1877.         return NULL;
  1878. #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
  1879.     if ((dev->net->features & NETIF_F_SG) && skb_linearize(skb))
  1880.         return NULL;
  1881. #endif
  1882.  
  1883.     headroom = skb_headroom(skb);
  1884.     tailroom = skb_tailroom(skb);
  1885.  
  1886.     if ((headroom + tailroom) >= 8) {
  1887.         if (headroom < 8) {
  1888.             skb->data = memmove(skb->head + 8, skb->data, skb->len);
  1889. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
  1890.             skb->tail = skb->data + skb->len;
  1891. #else
  1892.             skb_set_tail_pointer(skb, skb->len);
  1893. #endif
  1894.         }
  1895.     } else {
  1896.         struct sk_buff *skb2 = NULL;
  1897.         skb2 = skb_copy_expand(skb, 8, 0, flags);
  1898.         dev_kfree_skb_any(skb);
  1899.         skb = skb2;
  1900.         if (!skb)
  1901.             return NULL;
  1902.     }
  1903.  
  1904.     skb_push(skb, 4);
  1905.     cpu_to_le32s(&tx_hdr2);
  1906. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
  1907.     memcpy(skb->data, &tx_hdr2, 4);
  1908. #else
  1909.     skb_copy_to_linear_data(skb, &tx_hdr2, 4);
  1910. #endif
  1911.  
  1912.     skb_push(skb, 4);
  1913.     cpu_to_le32s(&tx_hdr1);
  1914. #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
  1915.     memcpy(skb->data, &tx_hdr1, 4);
  1916. #else
  1917.     skb_copy_to_linear_data(skb, &tx_hdr1, 4);
  1918. #endif
  1919.  
  1920.     return skb;
  1921. }
  1922.  
  1923. static int ax88179_link_reset(struct usbnet *dev)
  1924. {
  1925.     struct ax88179_data *data = (struct ax88179_data *)&dev->data;
  1926.     u8 *tmp, *link_sts, *tmp_16;
  1927.     u16 *mode, *tmp16, delay = 10 * HZ;
  1928.     u32 *tmp32;
  1929.     unsigned long jtimeout = 0;
  1930.  
  1931.     tmp_16 = kmalloc(16, GFP_KERNEL);
  1932.     if (!tmp_16)
  1933.         return -ENOMEM;
  1934.     tmp = (u8*)tmp_16;
  1935.     link_sts = (u8*)(&tmp_16[5]);
  1936.     mode = (u16*)(&tmp_16[6]);
  1937.     tmp16 = (u16*)(&tmp_16[8]);
  1938.     tmp32 = (u32*)(&tmp_16[10]);
  1939.  
  1940.     *mode = AX_MEDIUM_TXFLOW_CTRLEN | AX_MEDIUM_RXFLOW_CTRLEN;
  1941.  
  1942.     ax88179_read_cmd(dev, AX_ACCESS_MAC, PHYSICAL_LINK_STATUS,
  1943.              1, 1, link_sts, 0);
  1944.  
  1945.     jtimeout = jiffies + delay;
  1946.     while(time_before(jiffies, jtimeout)) {
  1947.  
  1948.         ax88179_read_cmd(dev, AX_ACCESS_PHY, AX88179_PHY_ID, GMII_PHY_PHYSR, 2, tmp16, 1);
  1949.  
  1950.         if (*tmp16 & GMII_PHY_PHYSR_LINK) {
  1951.             break;
  1952.         }
  1953.     }
  1954.  
  1955.     if (!(*tmp16 & GMII_PHY_PHYSR_LINK))
  1956.         return 0;
  1957.     else if (GMII_PHY_PHYSR_GIGA == (*tmp16 & GMII_PHY_PHYSR_SMASK)) {
  1958.         *mode |= AX_MEDIUM_GIGAMODE;
  1959.         if (dev->net->mtu > 1500)
  1960.             *mode |= AX_MEDIUM_JUMBO_EN;
  1961.  
  1962.         if (*link_sts & AX_USB_SS)
  1963.             memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
  1964.         else if (*link_sts & AX_USB_HS)
  1965.             memcpy(tmp, &AX88179_BULKIN_SIZE[1], 5);
  1966.         else
  1967.             memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
  1968.     } else if (GMII_PHY_PHYSR_100 == (*tmp16 & GMII_PHY_PHYSR_SMASK)) {
  1969.         *mode |= AX_MEDIUM_PS;  /* Bit 9 : PS */
  1970.         if (*link_sts & (AX_USB_SS | AX_USB_HS))
  1971.             memcpy(tmp, &AX88179_BULKIN_SIZE[2], 5);
  1972.         else
  1973.             memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
  1974.     } else
  1975.         memcpy(tmp, &AX88179_BULKIN_SIZE[3], 5);
  1976.  
  1977.     if (bsize != -1) {
  1978.         if (bsize > 24)
  1979.             bsize = 24;
  1980.  
  1981.         else if (bsize == 0) {
  1982.             tmp[1] = 0;
  1983.             tmp[2] = 0;
  1984.         }
  1985.  
  1986.         tmp[3] = (u8)bsize;
  1987.     }
  1988.  
  1989.     if (ifg != -1) {
  1990.         if (ifg > 255)
  1991.             ifg = 255;
  1992.         tmp[4] = (u8)ifg;
  1993.     }
  1994.  
  1995.     /* RX bulk configuration */
  1996.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
  1997.  
  1998.     if (*tmp16 & GMII_PHY_PHYSR_FULL)
  1999.         *mode |= AX_MEDIUM_FULL_DUPLEX; /* Bit 1 : FD */
  2000.  
  2001.     dev->rx_urb_size = (1024 * (tmp[3] + 2));
  2002.  
  2003. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  2004.         netdev_info(dev->net, "Write medium type: 0x%04x\n", *mode);
  2005. #else
  2006.         devinfo(dev, "Write medium type: 0x%04x\n", *mode);
  2007. #endif
  2008.    
  2009.     ax88179_read_cmd(dev, 0x81, 0x8c, 0, 4, tmp32, 1);
  2010.     delay = HZ / 2;
  2011.     if (*tmp32 & 0x40000000) {
  2012.  
  2013.         u16 *tmp1 = (u16*)(&tmp_16[14]);
  2014.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp1);
  2015.  
  2016.         /* Configure default medium type => giga */
  2017.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  2018.                   2, 2, mode);
  2019.  
  2020.         jtimeout = jiffies + delay;
  2021.  
  2022.         while (time_before(jiffies, jtimeout)) {
  2023.            
  2024.             ax88179_read_cmd(dev, 0x81, 0x8c, 0, 4, tmp32, 1);
  2025.        
  2026.             if (!(*tmp32 & 0x40000000))
  2027.                 break;
  2028.  
  2029.             *tmp32 = 0x80000000;
  2030.             ax88179_write_cmd(dev, 0x81, 0x8c, 0, 4, tmp32);
  2031.         }
  2032.  
  2033.         ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL,
  2034.                   2, 2, &data->rxctl);
  2035.     }
  2036.  
  2037.     *mode |= AX_MEDIUM_RECEIVE_EN;
  2038.  
  2039.     /* Configure default medium type => giga */
  2040.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  2041.               2, 2, mode);
  2042.     mii_check_media(&dev->mii, 1, 1);
  2043. #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)   
  2044.     if (dev->mii.force_media)
  2045.         netif_carrier_on(dev->net);
  2046. #endif
  2047.     kfree(tmp_16);
  2048.  
  2049.     return 0;
  2050. }
  2051.  
  2052. static int ax88179_reset(struct usbnet *dev)
  2053. {
  2054.     void *buf = NULL;
  2055.     u16 *tmp16 = NULL;
  2056.     u8 *tmp = NULL;
  2057.     struct ax88179_data *ax179_data = (struct ax88179_data *) dev->data;
  2058.     buf = kmalloc(6, GFP_KERNEL);
  2059.  
  2060.     if (!buf) {
  2061. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  2062.         netdev_err(dev->net, "Cannot allocate memory for buffer");
  2063. #else
  2064.         deverr(dev, "Cannot allocate memory for buffer");
  2065. #endif
  2066.         return -ENOMEM;
  2067.     }
  2068.  
  2069.     tmp16 = (u16 *)buf;
  2070.     tmp = (u8 *)buf;
  2071.  
  2072.     /* Power up ethernet PHY */
  2073.     *tmp16 = 0;
  2074.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
  2075.     *tmp16 = AX_PHYPWR_RSTCTL_IPRL;
  2076.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PHYPWR_RSTCTL, 2, 2, tmp16);
  2077.     msleep(200);
  2078.  
  2079.     *tmp = AX_CLK_SELECT_ACS | AX_CLK_SELECT_BCS;
  2080.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_CLK_SELECT, 1, 1, tmp);
  2081.     msleep(100);
  2082.  
  2083.     /* Ethernet PHY Auto Detach*/
  2084.     ax88179_AutoDetach(dev, 0);
  2085.  
  2086.     /* Set the MAC address */
  2087.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_NODE_ID, ETH_ALEN,
  2088.               ETH_ALEN, dev->net->dev_addr);
  2089.  
  2090. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  2091.     netdev_dbg(dev->net, "MAC [%02x-%02x-%02x-%02x-%02x-%02x]\n",
  2092.     dev->net->dev_addr[0], dev->net->dev_addr[1],
  2093.     dev->net->dev_addr[2], dev->net->dev_addr[3],
  2094.     dev->net->dev_addr[4], dev->net->dev_addr[5]);
  2095. #else
  2096.     devdbg(dev, "MAC [%02x-%02x-%02x-%02x-%02x-%02x]\n",
  2097.     dev->net->dev_addr[0], dev->net->dev_addr[1],
  2098.     dev->net->dev_addr[2], dev->net->dev_addr[3],
  2099.     dev->net->dev_addr[4], dev->net->dev_addr[5]);
  2100. #endif
  2101.  
  2102.     /* RX bulk configuration */
  2103.     memcpy(tmp, &AX88179_BULKIN_SIZE[0], 5);
  2104.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_BULKIN_QCTRL, 5, 5, tmp);
  2105.  
  2106.     dev->rx_urb_size = 1024 * 20;
  2107.  
  2108.     tmp[0] = 0x34;
  2109.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_LOW, 1, 1, tmp);
  2110.  
  2111.     tmp[0] = 0x52;
  2112.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_PAUSE_WATERLVL_HIGH,
  2113.               1, 1, tmp);
  2114.  
  2115.     dev->net->features |= NETIF_F_IP_CSUM;
  2116. #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
  2117.     dev->net->features |= NETIF_F_IPV6_CSUM;
  2118. #endif
  2119. #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0)
  2120.     if (usb_device_no_sg_constraint(dev->udev))
  2121.         dev->can_dma_sg = 1;
  2122.     dev->net->features |= NETIF_F_SG | NETIF_F_TSO;
  2123. #endif
  2124.  
  2125. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
  2126.     dev->net->hw_features |= NETIF_F_IP_CSUM;
  2127.     dev->net->hw_features |= NETIF_F_IPV6_CSUM;
  2128.     dev->net->hw_features |= NETIF_F_SG | NETIF_F_TSO;
  2129. #endif
  2130.  
  2131.     /* Enable checksum offload */
  2132.     *tmp = AX_RXCOE_IP | AX_RXCOE_TCP | AX_RXCOE_UDP |
  2133.            AX_RXCOE_TCPV6 | AX_RXCOE_UDPV6;
  2134.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RXCOE_CTL, 1, 1, tmp);
  2135.  
  2136.     *tmp = AX_TXCOE_IP | AX_TXCOE_TCP | AX_TXCOE_UDP |
  2137.            AX_TXCOE_TCPV6 | AX_TXCOE_UDPV6;
  2138.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_TXCOE_CTL, 1, 1, tmp);
  2139.  
  2140.     ax179_data->checksum |= AX_RX_CHECKSUM | AX_TX_CHECKSUM;
  2141.  
  2142.     /* Configure RX control register => start operation */
  2143.     *tmp16 = AX_RX_CTL_DROPCRCERR | AX_RX_CTL_START | AX_RX_CTL_AP |
  2144.          AX_RX_CTL_AMALL | AX_RX_CTL_AB;
  2145.     if (NET_IP_ALIGN == 0)
  2146.         *tmp16 |= AX_RX_CTL_IPE;
  2147.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_RX_CTL, 2, 2, tmp16);
  2148.  
  2149.     *tmp = AX_MONITOR_MODE_PMETYPE | AX_MONITOR_MODE_PMEPOL |
  2150.                         AX_MONITOR_MODE_RWMP;
  2151.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE, 1, 1, tmp);
  2152.  
  2153.     ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MONITOR_MODE, 1, 1, tmp, 0);
  2154. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  2155.     netdev_dbg(dev->net, "Monitor mode = 0x%02x\n", *tmp);
  2156. #else
  2157.     devdbg(dev, "Monitor mode = 0x%02x\n", *tmp);
  2158. #endif
  2159.  
  2160.     /* Configure default medium type => giga */
  2161.     *tmp16 = AX_MEDIUM_TXFLOW_CTRLEN | AX_MEDIUM_RXFLOW_CTRLEN |
  2162.          AX_MEDIUM_FULL_DUPLEX | AX_MEDIUM_GIGAMODE;
  2163.  
  2164.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  2165.               2, 2, tmp16);
  2166.  
  2167.     ax88179_led_setting(dev);
  2168.  
  2169.     ax88179_EEE_setting(dev);
  2170.  
  2171.     ax88179_Gether_setting(dev);
  2172.  
  2173.     /* Restart autoneg */
  2174.     mii_nway_restart(&dev->mii);
  2175.  
  2176.     netif_carrier_off(dev->net);
  2177.  
  2178.     kfree(buf);
  2179. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 34)
  2180.     netdev_dbg(dev->net, "mtu %d\n", dev->net->mtu);
  2181. #else
  2182.     devdbg(dev, "mtu %d\n", dev->net->mtu);
  2183. #endif
  2184.  
  2185.     return 0;
  2186.  
  2187. }
  2188.  
  2189. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2190. static int ax88179_stop(struct usbnet *dev)
  2191. {
  2192.     u16 *tmp16;
  2193.     tmp16 = kmalloc(2, GFP_KERNEL);
  2194.     if (!tmp16)
  2195.         return -ENOMEM;
  2196.  
  2197.     ax88179_read_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  2198.              2, 2, tmp16, 1);
  2199.     *tmp16 &= ~AX_MEDIUM_RECEIVE_EN;
  2200.     ax88179_write_cmd(dev, AX_ACCESS_MAC, AX_MEDIUM_STATUS_MODE,
  2201.               2, 2, tmp16);
  2202.  
  2203.     kfree(tmp16);
  2204.     return 0;
  2205. }
  2206. #endif
  2207.  
  2208. static const struct driver_info ax88179_info = {
  2209.     .description = "ASIX AX88179 USB 3.0 Gigabit Ethernet",
  2210.     .bind   = ax88179_bind,
  2211.     .unbind = ax88179_unbind,
  2212.     .status = ax88179_status,
  2213.     .link_reset = ax88179_link_reset,
  2214.     .reset  = ax88179_reset,
  2215. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2216.     .stop   = ax88179_stop,
  2217.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2218. #else
  2219.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2220. #endif
  2221.     .rx_fixup = ax88179_rx_fixup,
  2222.     .tx_fixup = ax88179_tx_fixup,
  2223. };
  2224.  
  2225.  
  2226. static const struct driver_info ax88178a_info = {
  2227.     .description = "ASIX AX88178A USB 2.0 Gigabit Ethernet",
  2228.     .bind   = ax88179_bind,
  2229.     .unbind = ax88179_unbind,
  2230.     .status = ax88179_status,
  2231.     .link_reset = ax88179_link_reset,
  2232.     .reset  = ax88179_reset,
  2233. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2234.     .stop   = ax88179_stop,
  2235.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2236. #else
  2237.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2238. #endif
  2239.     .rx_fixup = ax88179_rx_fixup,
  2240.     .tx_fixup = ax88179_tx_fixup,
  2241. };
  2242.  
  2243. static const struct driver_info sitecom_info = {
  2244.     .description = "Sitecom USB 3.0 to Gigabit Adapter",
  2245.     .bind   = ax88179_bind,
  2246.     .unbind = ax88179_unbind,
  2247.     .status = ax88179_status,
  2248.     .link_reset = ax88179_link_reset,
  2249.     .reset  = ax88179_reset,
  2250. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2251.     .stop   = ax88179_stop,
  2252.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2253. #else
  2254.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2255. #endif
  2256.     .rx_fixup = ax88179_rx_fixup,
  2257.     .tx_fixup = ax88179_tx_fixup,
  2258. };
  2259.  
  2260. static const struct driver_info lenovo_info = {
  2261.     .description = "ThinkPad OneLinkDock USB GigaLAN",
  2262.     .bind   = ax88179_bind,
  2263.     .unbind = ax88179_unbind,
  2264.     .status = ax88179_status,
  2265.     .link_reset = ax88179_link_reset,
  2266.     .reset  = ax88179_reset,
  2267. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2268.     .stop   = ax88179_stop,
  2269.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2270. #else
  2271.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2272. #endif
  2273.     .rx_fixup = ax88179_rx_fixup,
  2274.     .tx_fixup = ax88179_tx_fixup,
  2275. };
  2276.  
  2277. static const struct driver_info toshiba_info = {
  2278.     .description = "Toshiba USB 3.0 to Gigabit LAN Adapter",
  2279.     .bind   = ax88179_bind,
  2280.     .unbind = ax88179_unbind,
  2281.     .status = ax88179_status,
  2282.     .link_reset = ax88179_link_reset,
  2283.     .reset  = ax88179_reset,
  2284. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2285.     .stop   = ax88179_stop,
  2286.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2287. #else
  2288.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2289. #endif
  2290.     .rx_fixup = ax88179_rx_fixup,
  2291.     .tx_fixup = ax88179_tx_fixup,
  2292. };
  2293.  
  2294. static const struct driver_info samsung_info = {
  2295.     .description = "Samsung USB Ethernet Adapter",
  2296.     .bind   = ax88179_bind,
  2297.     .unbind = ax88179_unbind,
  2298.     .status = ax88179_status,
  2299.     .link_reset = ax88179_link_reset,
  2300.     .reset  = ax88179_reset,
  2301. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2302.     .stop   = ax88179_stop,
  2303.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2304. #else
  2305.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2306. #endif
  2307.     .rx_fixup = ax88179_rx_fixup,
  2308.     .tx_fixup = ax88179_tx_fixup,
  2309. };
  2310.  
  2311. static const struct driver_info dlink_info = {
  2312.     .description = "DUB-1312/1332 USB3.0 to Gigabit Ethernet Adapter",
  2313.     .bind   = ax88179_bind,
  2314.     .unbind = ax88179_unbind,
  2315.     .status = ax88179_status,
  2316.     .link_reset = ax88179_link_reset,
  2317.     .reset  = ax88179_reset,
  2318. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2319.     .stop   = ax88179_stop,
  2320.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2321. #else
  2322.     .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2323. #endif
  2324.     .rx_fixup = ax88179_rx_fixup,
  2325.     .tx_fixup = ax88179_tx_fixup,
  2326. };
  2327.  
  2328. static const struct driver_info mct_info = {
  2329.         .description = "USB 3.0 to Gigabit Ethernet Adapter",
  2330.         .bind   = ax88179_bind,
  2331.         .unbind = ax88179_unbind,
  2332.         .status = ax88179_status,
  2333.         .link_reset = ax88179_link_reset,
  2334.         .reset  = ax88179_reset,
  2335. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32)
  2336.         .stop   = ax88179_stop,
  2337.         .flags  = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_AVOID_UNLINK_URBS,
  2338. #else
  2339.         .flags  = FLAG_ETHER | FLAG_FRAMING_AX,
  2340. #endif
  2341.         .rx_fixup = ax88179_rx_fixup,
  2342.         .tx_fixup = ax88179_tx_fixup,
  2343. };
  2344.  
  2345. static const struct usb_device_id   products[] = {
  2346. {
  2347.     /* ASIX AX88179 10/100/1000 */
  2348.     USB_DEVICE(0x0b95, 0x1790),
  2349.     .driver_info = (unsigned long) &ax88179_info,
  2350. }, {
  2351.     /* ASIX AX88178A 10/100/1000 */
  2352.     USB_DEVICE(0x0b95, 0x178a),
  2353.     .driver_info = (unsigned long) &ax88178a_info,
  2354. }, {
  2355.     /* Sitecom USB 3.0 to Gigabit Adapter */
  2356.     USB_DEVICE(0x0df6, 0x0072),
  2357.     .driver_info = (unsigned long) &sitecom_info,
  2358. }, {
  2359.     /* ThinkPad OneLinkDock USB GigaLAN */
  2360.     USB_DEVICE(0x17ef, 0x304b),
  2361.     .driver_info = (unsigned long) &lenovo_info,
  2362. }, {
  2363.     /* Toshiba USB3.0 to Gigabit LAN Adapter */
  2364.     USB_DEVICE(0x0930, 0x0a13),
  2365.     .driver_info = (unsigned long) &toshiba_info,
  2366. }, {
  2367.     /* Samsung USB Ethernet Adapter */
  2368.     USB_DEVICE(0x04e8, 0xa100),
  2369.     .driver_info = (unsigned long) &samsung_info,
  2370. }, {
  2371.     /* D-Link DUB-13x2 Ethernet Adapter */
  2372.     USB_DEVICE(0x2001, 0x4a00),
  2373.     .driver_info = (unsigned long) &dlink_info,
  2374. }, {
  2375.     /* MCT USB 3.0 to Gigabit Ethernet Adapter */
  2376.     USB_DEVICE(0x0711, 0x0179),
  2377.     .driver_info = (unsigned long) &mct_info,
  2378. },
  2379.     { },        /* END */
  2380. };
  2381. MODULE_DEVICE_TABLE(usb, products);
  2382.  
  2383. static struct usb_driver asix_driver = {
  2384.     .name =     "ax88179_178a",
  2385.     .id_table = products,
  2386.     .probe =    usbnet_probe,
  2387.     .suspend =  ax88179_suspend,
  2388.     .resume =   ax88179_resume,
  2389.     .disconnect =   usbnet_disconnect,
  2390. };
  2391.  
  2392.  
  2393. static int __init asix_init(void)
  2394. {
  2395.     return usb_register(&asix_driver);
  2396. }
  2397. module_init(asix_init);
  2398.  
  2399. static void __exit asix_exit(void)
  2400. {
  2401.     usb_deregister(&asix_driver);
  2402. }
  2403. module_exit(asix_exit);
  2404.  
  2405. MODULE_AUTHOR("David Hollis - PVE Mod by Pascal Steinberg");
  2406. MODULE_DESCRIPTION("ASIX AX88179_178A based USB 2.0/3.0 Gigabit Ethernet Devices");
  2407. MODULE_LICENSE("GPL");
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!