ax88172a.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412
  1. /*
  2. * ASIX AX88172A based USB 2.0 Ethernet Devices
  3. * Copyright (C) 2012 OMICRON electronics GmbH
  4. *
  5. * Supports external PHYs via phylib. Based on the driver for the
  6. * AX88772. Original copyrights follow:
  7. *
  8. * Copyright (C) 2003-2006 David Hollis <dhollis@davehollis.com>
  9. * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
  10. * Copyright (C) 2006 James Painter <jamie.painter@iname.com>
  11. * Copyright (c) 2002-2003 TiVo Inc.
  12. *
  13. * This program is free software; you can redistribute it and/or modify
  14. * it under the terms of the GNU General Public License as published by
  15. * the Free Software Foundation; either version 2 of the License, or
  16. * (at your option) any later version.
  17. *
  18. * This program is distributed in the hope that it will be useful,
  19. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21. * GNU General Public License for more details.
  22. *
  23. * You should have received a copy of the GNU General Public License
  24. * along with this program; if not, see <http://www.gnu.org/licenses/>.
  25. */
  26. #include "asix.h"
  27. #include <linux/phy.h>
  28. struct ax88172a_private {
  29. struct mii_bus *mdio;
  30. struct phy_device *phydev;
  31. char phy_name[20];
  32. u16 phy_addr;
  33. u16 oldmode;
  34. int use_embdphy;
  35. struct asix_rx_fixup_info rx_fixup_info;
  36. };
  37. /* MDIO read and write wrappers for phylib */
  38. static int asix_mdio_bus_read(struct mii_bus *bus, int phy_id, int regnum)
  39. {
  40. return asix_mdio_read(((struct usbnet *)bus->priv)->net, phy_id,
  41. regnum);
  42. }
  43. static int asix_mdio_bus_write(struct mii_bus *bus, int phy_id, int regnum,
  44. u16 val)
  45. {
  46. asix_mdio_write(((struct usbnet *)bus->priv)->net, phy_id, regnum, val);
  47. return 0;
  48. }
  49. static int ax88172a_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
  50. {
  51. if (!netif_running(net))
  52. return -EINVAL;
  53. if (!net->phydev)
  54. return -ENODEV;
  55. return phy_mii_ioctl(net->phydev, rq, cmd);
  56. }
  57. /* set MAC link settings according to information from phylib */
  58. static void ax88172a_adjust_link(struct net_device *netdev)
  59. {
  60. struct phy_device *phydev = netdev->phydev;
  61. struct usbnet *dev = netdev_priv(netdev);
  62. struct ax88172a_private *priv = dev->driver_priv;
  63. u16 mode = 0;
  64. if (phydev->link) {
  65. mode = AX88772_MEDIUM_DEFAULT;
  66. if (phydev->duplex == DUPLEX_HALF)
  67. mode &= ~AX_MEDIUM_FD;
  68. if (phydev->speed != SPEED_100)
  69. mode &= ~AX_MEDIUM_PS;
  70. }
  71. if (mode != priv->oldmode) {
  72. asix_write_medium_mode(dev, mode);
  73. priv->oldmode = mode;
  74. netdev_dbg(netdev, "speed %u duplex %d, setting mode to 0x%04x\n",
  75. phydev->speed, phydev->duplex, mode);
  76. phy_print_status(phydev);
  77. }
  78. }
  79. static void ax88172a_status(struct usbnet *dev, struct urb *urb)
  80. {
  81. /* link changes are detected by polling the phy */
  82. }
  83. /* use phylib infrastructure */
  84. static int ax88172a_init_mdio(struct usbnet *dev)
  85. {
  86. struct ax88172a_private *priv = dev->driver_priv;
  87. int ret;
  88. priv->mdio = mdiobus_alloc();
  89. if (!priv->mdio) {
  90. netdev_err(dev->net, "Could not allocate MDIO bus\n");
  91. return -ENOMEM;
  92. }
  93. priv->mdio->priv = (void *)dev;
  94. priv->mdio->read = &asix_mdio_bus_read;
  95. priv->mdio->write = &asix_mdio_bus_write;
  96. priv->mdio->name = "Asix MDIO Bus";
  97. /* mii bus name is usb-<usb bus number>-<usb device number> */
  98. snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
  99. dev->udev->bus->busnum, dev->udev->devnum);
  100. ret = mdiobus_register(priv->mdio);
  101. if (ret) {
  102. netdev_err(dev->net, "Could not register MDIO bus\n");
  103. goto mfree;
  104. }
  105. netdev_info(dev->net, "registered mdio bus %s\n", priv->mdio->id);
  106. return 0;
  107. mfree:
  108. mdiobus_free(priv->mdio);
  109. return ret;
  110. }
  111. static void ax88172a_remove_mdio(struct usbnet *dev)
  112. {
  113. struct ax88172a_private *priv = dev->driver_priv;
  114. netdev_info(dev->net, "deregistering mdio bus %s\n", priv->mdio->id);
  115. mdiobus_unregister(priv->mdio);
  116. kfree(priv->mdio->irq);
  117. mdiobus_free(priv->mdio);
  118. }
  119. static const struct net_device_ops ax88172a_netdev_ops = {
  120. .ndo_open = usbnet_open,
  121. .ndo_stop = usbnet_stop,
  122. .ndo_start_xmit = usbnet_start_xmit,
  123. .ndo_tx_timeout = usbnet_tx_timeout,
  124. .ndo_change_mtu = usbnet_change_mtu,
  125. .ndo_set_mac_address = asix_set_mac_address,
  126. .ndo_validate_addr = eth_validate_addr,
  127. .ndo_do_ioctl = ax88172a_ioctl,
  128. .ndo_set_rx_mode = asix_set_multicast,
  129. };
  130. static int ax88172a_get_settings(struct net_device *net,
  131. struct ethtool_cmd *cmd)
  132. {
  133. if (!net->phydev)
  134. return -ENODEV;
  135. return phy_ethtool_gset(net->phydev, cmd);
  136. }
  137. static int ax88172a_set_settings(struct net_device *net,
  138. struct ethtool_cmd *cmd)
  139. {
  140. if (!net->phydev)
  141. return -ENODEV;
  142. return phy_ethtool_sset(net->phydev, cmd);
  143. }
  144. static int ax88172a_nway_reset(struct net_device *net)
  145. {
  146. if (!net->phydev)
  147. return -ENODEV;
  148. return phy_start_aneg(net->phydev);
  149. }
  150. static const struct ethtool_ops ax88172a_ethtool_ops = {
  151. .get_drvinfo = asix_get_drvinfo,
  152. .get_link = usbnet_get_link,
  153. .get_msglevel = usbnet_get_msglevel,
  154. .set_msglevel = usbnet_set_msglevel,
  155. .get_wol = asix_get_wol,
  156. .set_wol = asix_set_wol,
  157. .get_eeprom_len = asix_get_eeprom_len,
  158. .get_eeprom = asix_get_eeprom,
  159. .set_eeprom = asix_set_eeprom,
  160. .get_settings = ax88172a_get_settings,
  161. .set_settings = ax88172a_set_settings,
  162. .nway_reset = ax88172a_nway_reset,
  163. };
  164. static int ax88172a_reset_phy(struct usbnet *dev, int embd_phy)
  165. {
  166. int ret;
  167. ret = asix_sw_reset(dev, AX_SWRESET_IPPD);
  168. if (ret < 0)
  169. goto err;
  170. msleep(150);
  171. ret = asix_sw_reset(dev, AX_SWRESET_CLEAR);
  172. if (ret < 0)
  173. goto err;
  174. msleep(150);
  175. ret = asix_sw_reset(dev, embd_phy ? AX_SWRESET_IPRL : AX_SWRESET_IPPD);
  176. if (ret < 0)
  177. goto err;
  178. return 0;
  179. err:
  180. return ret;
  181. }
  182. static int ax88172a_bind(struct usbnet *dev, struct usb_interface *intf)
  183. {
  184. int ret;
  185. u8 buf[ETH_ALEN];
  186. struct ax88172a_private *priv;
  187. usbnet_get_endpoints(dev, intf);
  188. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  189. if (!priv)
  190. return -ENOMEM;
  191. dev->driver_priv = priv;
  192. /* Get the MAC address */
  193. ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf);
  194. if (ret < 0) {
  195. netdev_err(dev->net, "Failed to read MAC address: %d\n", ret);
  196. goto free;
  197. }
  198. memcpy(dev->net->dev_addr, buf, ETH_ALEN);
  199. dev->net->netdev_ops = &ax88172a_netdev_ops;
  200. dev->net->ethtool_ops = &ax88172a_ethtool_ops;
  201. /* are we using the internal or the external phy? */
  202. ret = asix_read_cmd(dev, AX_CMD_SW_PHY_STATUS, 0, 0, 1, buf);
  203. if (ret < 0) {
  204. netdev_err(dev->net, "Failed to read software interface selection register: %d\n",
  205. ret);
  206. goto free;
  207. }
  208. netdev_dbg(dev->net, "AX_CMD_SW_PHY_STATUS = 0x%02x\n", buf[0]);
  209. switch (buf[0] & AX_PHY_SELECT_MASK) {
  210. case AX_PHY_SELECT_INTERNAL:
  211. netdev_dbg(dev->net, "use internal phy\n");
  212. priv->use_embdphy = 1;
  213. break;
  214. case AX_PHY_SELECT_EXTERNAL:
  215. netdev_dbg(dev->net, "use external phy\n");
  216. priv->use_embdphy = 0;
  217. break;
  218. default:
  219. netdev_err(dev->net, "Interface mode not supported by driver\n");
  220. ret = -ENOTSUPP;
  221. goto free;
  222. }
  223. priv->phy_addr = asix_read_phy_addr(dev, priv->use_embdphy);
  224. ax88172a_reset_phy(dev, priv->use_embdphy);
  225. /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
  226. if (dev->driver_info->flags & FLAG_FRAMING_AX) {
  227. /* hard_mtu is still the default - the device does not support
  228. jumbo eth frames */
  229. dev->rx_urb_size = 2048;
  230. }
  231. /* init MDIO bus */
  232. ret = ax88172a_init_mdio(dev);
  233. if (ret)
  234. goto free;
  235. return 0;
  236. free:
  237. kfree(priv);
  238. return ret;
  239. }
  240. static int ax88172a_stop(struct usbnet *dev)
  241. {
  242. struct ax88172a_private *priv = dev->driver_priv;
  243. netdev_dbg(dev->net, "Stopping interface\n");
  244. if (priv->phydev) {
  245. netdev_info(dev->net, "Disconnecting from phy %s\n",
  246. priv->phy_name);
  247. phy_stop(priv->phydev);
  248. phy_disconnect(priv->phydev);
  249. }
  250. return 0;
  251. }
  252. static void ax88172a_unbind(struct usbnet *dev, struct usb_interface *intf)
  253. {
  254. struct ax88172a_private *priv = dev->driver_priv;
  255. ax88172a_remove_mdio(dev);
  256. kfree(priv);
  257. }
  258. static int ax88172a_reset(struct usbnet *dev)
  259. {
  260. struct asix_data *data = (struct asix_data *)&dev->data;
  261. struct ax88172a_private *priv = dev->driver_priv;
  262. int ret;
  263. u16 rx_ctl;
  264. ax88172a_reset_phy(dev, priv->use_embdphy);
  265. msleep(150);
  266. rx_ctl = asix_read_rx_ctl(dev);
  267. netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl);
  268. ret = asix_write_rx_ctl(dev, 0x0000);
  269. if (ret < 0)
  270. goto out;
  271. rx_ctl = asix_read_rx_ctl(dev);
  272. netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
  273. msleep(150);
  274. ret = asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
  275. AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
  276. AX88772_IPG2_DEFAULT, 0, NULL);
  277. if (ret < 0) {
  278. netdev_err(dev->net, "Write IPG,IPG1,IPG2 failed: %d\n", ret);
  279. goto out;
  280. }
  281. /* Rewrite MAC address */
  282. memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN);
  283. ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN,
  284. data->mac_addr);
  285. if (ret < 0)
  286. goto out;
  287. /* Set RX_CTL to default values with 2k buffer, and enable cactus */
  288. ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL);
  289. if (ret < 0)
  290. goto out;
  291. rx_ctl = asix_read_rx_ctl(dev);
  292. netdev_dbg(dev->net, "RX_CTL is 0x%04x after all initializations\n",
  293. rx_ctl);
  294. rx_ctl = asix_read_medium_status(dev);
  295. netdev_dbg(dev->net, "Medium Status is 0x%04x after all initializations\n",
  296. rx_ctl);
  297. /* Connect to PHY */
  298. snprintf(priv->phy_name, 20, PHY_ID_FMT,
  299. priv->mdio->id, priv->phy_addr);
  300. priv->phydev = phy_connect(dev->net, priv->phy_name,
  301. &ax88172a_adjust_link,
  302. PHY_INTERFACE_MODE_MII);
  303. if (IS_ERR(priv->phydev)) {
  304. netdev_err(dev->net, "Could not connect to PHY device %s\n",
  305. priv->phy_name);
  306. ret = PTR_ERR(priv->phydev);
  307. goto out;
  308. }
  309. netdev_info(dev->net, "Connected to phy %s\n", priv->phy_name);
  310. /* During power-up, the AX88172A set the power down (BMCR_PDOWN)
  311. * bit of the PHY. Bring the PHY up again.
  312. */
  313. genphy_resume(priv->phydev);
  314. phy_start(priv->phydev);
  315. return 0;
  316. out:
  317. return ret;
  318. }
  319. static int ax88172a_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
  320. {
  321. struct ax88172a_private *dp = dev->driver_priv;
  322. struct asix_rx_fixup_info *rx = &dp->rx_fixup_info;
  323. return asix_rx_fixup_internal(dev, skb, rx);
  324. }
  325. const struct driver_info ax88172a_info = {
  326. .description = "ASIX AX88172A USB 2.0 Ethernet",
  327. .bind = ax88172a_bind,
  328. .reset = ax88172a_reset,
  329. .stop = ax88172a_stop,
  330. .unbind = ax88172a_unbind,
  331. .status = ax88172a_status,
  332. .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR |
  333. FLAG_MULTI_PACKET,
  334. .rx_fixup = ax88172a_rx_fixup,
  335. .tx_fixup = asix_tx_fixup,
  336. };