Commit | Line | Data |
---|---|---|
16626b0c CR |
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 | |
9cb00073 | 24 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
16626b0c CR |
25 | */ |
26 | ||
27 | #include "asix.h" | |
28 | #include <linux/phy.h> | |
29 | ||
30 | struct ax88172a_private { | |
31 | struct mii_bus *mdio; | |
32 | struct phy_device *phydev; | |
33 | char phy_name[20]; | |
34 | u16 phy_addr; | |
35 | u16 oldmode; | |
36 | int use_embdphy; | |
8b5b6f54 | 37 | struct asix_rx_fixup_info rx_fixup_info; |
16626b0c CR |
38 | }; |
39 | ||
40 | /* MDIO read and write wrappers for phylib */ | |
41 | static int asix_mdio_bus_read(struct mii_bus *bus, int phy_id, int regnum) | |
42 | { | |
43 | return asix_mdio_read(((struct usbnet *)bus->priv)->net, phy_id, | |
44 | regnum); | |
45 | } | |
46 | ||
47 | static int asix_mdio_bus_write(struct mii_bus *bus, int phy_id, int regnum, | |
48 | u16 val) | |
49 | { | |
50 | asix_mdio_write(((struct usbnet *)bus->priv)->net, phy_id, regnum, val); | |
51 | return 0; | |
52 | } | |
53 | ||
54 | static int ax88172a_ioctl(struct net_device *net, struct ifreq *rq, int cmd) | |
55 | { | |
56 | if (!netif_running(net)) | |
57 | return -EINVAL; | |
58 | ||
59 | if (!net->phydev) | |
60 | return -ENODEV; | |
61 | ||
62 | return phy_mii_ioctl(net->phydev, rq, cmd); | |
63 | } | |
64 | ||
65 | /* set MAC link settings according to information from phylib */ | |
66 | static void ax88172a_adjust_link(struct net_device *netdev) | |
67 | { | |
68 | struct phy_device *phydev = netdev->phydev; | |
69 | struct usbnet *dev = netdev_priv(netdev); | |
70 | struct ax88172a_private *priv = dev->driver_priv; | |
71 | u16 mode = 0; | |
72 | ||
73 | if (phydev->link) { | |
74 | mode = AX88772_MEDIUM_DEFAULT; | |
75 | ||
76 | if (phydev->duplex == DUPLEX_HALF) | |
77 | mode &= ~AX_MEDIUM_FD; | |
78 | ||
79 | if (phydev->speed != SPEED_100) | |
80 | mode &= ~AX_MEDIUM_PS; | |
81 | } | |
82 | ||
83 | if (mode != priv->oldmode) { | |
d9fe64e5 | 84 | asix_write_medium_mode(dev, mode, 0); |
16626b0c CR |
85 | priv->oldmode = mode; |
86 | netdev_dbg(netdev, "speed %u duplex %d, setting mode to 0x%04x\n", | |
87 | phydev->speed, phydev->duplex, mode); | |
88 | phy_print_status(phydev); | |
89 | } | |
90 | } | |
91 | ||
92 | static void ax88172a_status(struct usbnet *dev, struct urb *urb) | |
93 | { | |
94 | /* link changes are detected by polling the phy */ | |
95 | } | |
96 | ||
97 | /* use phylib infrastructure */ | |
98 | static int ax88172a_init_mdio(struct usbnet *dev) | |
99 | { | |
100 | struct ax88172a_private *priv = dev->driver_priv; | |
e7f4dc35 | 101 | int ret; |
16626b0c CR |
102 | |
103 | priv->mdio = mdiobus_alloc(); | |
104 | if (!priv->mdio) { | |
105 | netdev_err(dev->net, "Could not allocate MDIO bus\n"); | |
106 | return -ENOMEM; | |
107 | } | |
108 | ||
109 | priv->mdio->priv = (void *)dev; | |
110 | priv->mdio->read = &asix_mdio_bus_read; | |
111 | priv->mdio->write = &asix_mdio_bus_write; | |
112 | priv->mdio->name = "Asix MDIO Bus"; | |
113 | /* mii bus name is usb-<usb bus number>-<usb device number> */ | |
114 | snprintf(priv->mdio->id, MII_BUS_ID_SIZE, "usb-%03d:%03d", | |
115 | dev->udev->bus->busnum, dev->udev->devnum); | |
116 | ||
16626b0c CR |
117 | ret = mdiobus_register(priv->mdio); |
118 | if (ret) { | |
119 | netdev_err(dev->net, "Could not register MDIO bus\n"); | |
e7f4dc35 | 120 | goto mfree; |
16626b0c CR |
121 | } |
122 | ||
123 | netdev_info(dev->net, "registered mdio bus %s\n", priv->mdio->id); | |
124 | return 0; | |
125 | ||
16626b0c CR |
126 | mfree: |
127 | mdiobus_free(priv->mdio); | |
128 | return ret; | |
129 | } | |
130 | ||
131 | static void ax88172a_remove_mdio(struct usbnet *dev) | |
132 | { | |
133 | struct ax88172a_private *priv = dev->driver_priv; | |
134 | ||
135 | netdev_info(dev->net, "deregistering mdio bus %s\n", priv->mdio->id); | |
136 | mdiobus_unregister(priv->mdio); | |
16626b0c CR |
137 | mdiobus_free(priv->mdio); |
138 | } | |
139 | ||
140 | static const struct net_device_ops ax88172a_netdev_ops = { | |
141 | .ndo_open = usbnet_open, | |
142 | .ndo_stop = usbnet_stop, | |
143 | .ndo_start_xmit = usbnet_start_xmit, | |
144 | .ndo_tx_timeout = usbnet_tx_timeout, | |
145 | .ndo_change_mtu = usbnet_change_mtu, | |
146 | .ndo_set_mac_address = asix_set_mac_address, | |
147 | .ndo_validate_addr = eth_validate_addr, | |
148 | .ndo_do_ioctl = ax88172a_ioctl, | |
149 | .ndo_set_rx_mode = asix_set_multicast, | |
150 | }; | |
151 | ||
16626b0c CR |
152 | static const struct ethtool_ops ax88172a_ethtool_ops = { |
153 | .get_drvinfo = asix_get_drvinfo, | |
154 | .get_link = usbnet_get_link, | |
155 | .get_msglevel = usbnet_get_msglevel, | |
156 | .set_msglevel = usbnet_set_msglevel, | |
157 | .get_wol = asix_get_wol, | |
158 | .set_wol = asix_set_wol, | |
159 | .get_eeprom_len = asix_get_eeprom_len, | |
160 | .get_eeprom = asix_get_eeprom, | |
cb7b24cd | 161 | .set_eeprom = asix_set_eeprom, |
eea16da8 | 162 | .nway_reset = phy_ethtool_nway_reset, |
b3f2cf8f PR |
163 | .get_link_ksettings = phy_ethtool_get_link_ksettings, |
164 | .set_link_ksettings = phy_ethtool_set_link_ksettings, | |
16626b0c CR |
165 | }; |
166 | ||
167 | static int ax88172a_reset_phy(struct usbnet *dev, int embd_phy) | |
168 | { | |
169 | int ret; | |
170 | ||
d9fe64e5 | 171 | ret = asix_sw_reset(dev, AX_SWRESET_IPPD, 0); |
16626b0c CR |
172 | if (ret < 0) |
173 | goto err; | |
174 | ||
175 | msleep(150); | |
d9fe64e5 | 176 | ret = asix_sw_reset(dev, AX_SWRESET_CLEAR, 0); |
16626b0c CR |
177 | if (ret < 0) |
178 | goto err; | |
179 | ||
180 | msleep(150); | |
181 | ||
d9fe64e5 RF |
182 | ret = asix_sw_reset(dev, embd_phy ? AX_SWRESET_IPRL : AX_SWRESET_IPPD, |
183 | 0); | |
16626b0c CR |
184 | if (ret < 0) |
185 | goto err; | |
186 | ||
187 | return 0; | |
188 | ||
189 | err: | |
190 | return ret; | |
191 | } | |
192 | ||
193 | ||
194 | static int ax88172a_bind(struct usbnet *dev, struct usb_interface *intf) | |
195 | { | |
196 | int ret; | |
16626b0c CR |
197 | u8 buf[ETH_ALEN]; |
198 | struct ax88172a_private *priv; | |
199 | ||
16626b0c CR |
200 | usbnet_get_endpoints(dev, intf); |
201 | ||
202 | priv = kzalloc(sizeof(*priv), GFP_KERNEL); | |
38673c82 | 203 | if (!priv) |
16626b0c | 204 | return -ENOMEM; |
38673c82 | 205 | |
16626b0c CR |
206 | dev->driver_priv = priv; |
207 | ||
208 | /* Get the MAC address */ | |
d9fe64e5 | 209 | ret = asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf, 0); |
16626b0c CR |
210 | if (ret < 0) { |
211 | netdev_err(dev->net, "Failed to read MAC address: %d\n", ret); | |
212 | goto free; | |
213 | } | |
214 | memcpy(dev->net->dev_addr, buf, ETH_ALEN); | |
215 | ||
216 | dev->net->netdev_ops = &ax88172a_netdev_ops; | |
217 | dev->net->ethtool_ops = &ax88172a_ethtool_ops; | |
218 | ||
219 | /* are we using the internal or the external phy? */ | |
d9fe64e5 | 220 | ret = asix_read_cmd(dev, AX_CMD_SW_PHY_STATUS, 0, 0, 1, buf, 0); |
16626b0c CR |
221 | if (ret < 0) { |
222 | netdev_err(dev->net, "Failed to read software interface selection register: %d\n", | |
223 | ret); | |
224 | goto free; | |
225 | } | |
226 | ||
227 | netdev_dbg(dev->net, "AX_CMD_SW_PHY_STATUS = 0x%02x\n", buf[0]); | |
228 | switch (buf[0] & AX_PHY_SELECT_MASK) { | |
229 | case AX_PHY_SELECT_INTERNAL: | |
230 | netdev_dbg(dev->net, "use internal phy\n"); | |
231 | priv->use_embdphy = 1; | |
232 | break; | |
233 | case AX_PHY_SELECT_EXTERNAL: | |
234 | netdev_dbg(dev->net, "use external phy\n"); | |
235 | priv->use_embdphy = 0; | |
236 | break; | |
237 | default: | |
238 | netdev_err(dev->net, "Interface mode not supported by driver\n"); | |
fcc24db5 | 239 | ret = -ENOTSUPP; |
16626b0c CR |
240 | goto free; |
241 | } | |
242 | ||
243 | priv->phy_addr = asix_read_phy_addr(dev, priv->use_embdphy); | |
244 | ax88172a_reset_phy(dev, priv->use_embdphy); | |
245 | ||
246 | /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */ | |
247 | if (dev->driver_info->flags & FLAG_FRAMING_AX) { | |
248 | /* hard_mtu is still the default - the device does not support | |
249 | jumbo eth frames */ | |
250 | dev->rx_urb_size = 2048; | |
251 | } | |
252 | ||
253 | /* init MDIO bus */ | |
254 | ret = ax88172a_init_mdio(dev); | |
255 | if (ret) | |
256 | goto free; | |
257 | ||
258 | return 0; | |
259 | ||
260 | free: | |
261 | kfree(priv); | |
262 | return ret; | |
263 | } | |
264 | ||
265 | static int ax88172a_stop(struct usbnet *dev) | |
266 | { | |
267 | struct ax88172a_private *priv = dev->driver_priv; | |
268 | ||
269 | netdev_dbg(dev->net, "Stopping interface\n"); | |
270 | ||
271 | if (priv->phydev) { | |
272 | netdev_info(dev->net, "Disconnecting from phy %s\n", | |
273 | priv->phy_name); | |
274 | phy_stop(priv->phydev); | |
275 | phy_disconnect(priv->phydev); | |
276 | } | |
277 | ||
278 | return 0; | |
279 | } | |
280 | ||
281 | static void ax88172a_unbind(struct usbnet *dev, struct usb_interface *intf) | |
282 | { | |
283 | struct ax88172a_private *priv = dev->driver_priv; | |
284 | ||
285 | ax88172a_remove_mdio(dev); | |
286 | kfree(priv); | |
287 | } | |
288 | ||
289 | static int ax88172a_reset(struct usbnet *dev) | |
290 | { | |
291 | struct asix_data *data = (struct asix_data *)&dev->data; | |
292 | struct ax88172a_private *priv = dev->driver_priv; | |
293 | int ret; | |
294 | u16 rx_ctl; | |
295 | ||
296 | ax88172a_reset_phy(dev, priv->use_embdphy); | |
297 | ||
298 | msleep(150); | |
d9fe64e5 | 299 | rx_ctl = asix_read_rx_ctl(dev, 0); |
16626b0c | 300 | netdev_dbg(dev->net, "RX_CTL is 0x%04x after software reset\n", rx_ctl); |
d9fe64e5 | 301 | ret = asix_write_rx_ctl(dev, 0x0000, 0); |
16626b0c CR |
302 | if (ret < 0) |
303 | goto out; | |
304 | ||
d9fe64e5 | 305 | rx_ctl = asix_read_rx_ctl(dev, 0); |
16626b0c CR |
306 | netdev_dbg(dev->net, "RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl); |
307 | ||
308 | msleep(150); | |
309 | ||
310 | ret = asix_write_cmd(dev, AX_CMD_WRITE_IPG0, | |
311 | AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT, | |
d9fe64e5 | 312 | AX88772_IPG2_DEFAULT, 0, NULL, 0); |
16626b0c CR |
313 | if (ret < 0) { |
314 | netdev_err(dev->net, "Write IPG,IPG1,IPG2 failed: %d\n", ret); | |
315 | goto out; | |
316 | } | |
317 | ||
318 | /* Rewrite MAC address */ | |
319 | memcpy(data->mac_addr, dev->net->dev_addr, ETH_ALEN); | |
320 | ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN, | |
d9fe64e5 | 321 | data->mac_addr, 0); |
16626b0c CR |
322 | if (ret < 0) |
323 | goto out; | |
324 | ||
325 | /* Set RX_CTL to default values with 2k buffer, and enable cactus */ | |
d9fe64e5 | 326 | ret = asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL, 0); |
16626b0c CR |
327 | if (ret < 0) |
328 | goto out; | |
329 | ||
d9fe64e5 | 330 | rx_ctl = asix_read_rx_ctl(dev, 0); |
16626b0c CR |
331 | netdev_dbg(dev->net, "RX_CTL is 0x%04x after all initializations\n", |
332 | rx_ctl); | |
333 | ||
d9fe64e5 | 334 | rx_ctl = asix_read_medium_status(dev, 0); |
16626b0c CR |
335 | netdev_dbg(dev->net, "Medium Status is 0x%04x after all initializations\n", |
336 | rx_ctl); | |
337 | ||
338 | /* Connect to PHY */ | |
339 | snprintf(priv->phy_name, 20, PHY_ID_FMT, | |
340 | priv->mdio->id, priv->phy_addr); | |
341 | ||
342 | priv->phydev = phy_connect(dev->net, priv->phy_name, | |
343 | &ax88172a_adjust_link, | |
f9a8f83b | 344 | PHY_INTERFACE_MODE_MII); |
16626b0c CR |
345 | if (IS_ERR(priv->phydev)) { |
346 | netdev_err(dev->net, "Could not connect to PHY device %s\n", | |
347 | priv->phy_name); | |
348 | ret = PTR_ERR(priv->phydev); | |
349 | goto out; | |
350 | } | |
351 | ||
352 | netdev_info(dev->net, "Connected to phy %s\n", priv->phy_name); | |
353 | ||
354 | /* During power-up, the AX88172A set the power down (BMCR_PDOWN) | |
355 | * bit of the PHY. Bring the PHY up again. | |
356 | */ | |
357 | genphy_resume(priv->phydev); | |
358 | phy_start(priv->phydev); | |
359 | ||
360 | return 0; | |
361 | ||
362 | out: | |
363 | return ret; | |
364 | ||
365 | } | |
366 | ||
8b5b6f54 LS |
367 | static int ax88172a_rx_fixup(struct usbnet *dev, struct sk_buff *skb) |
368 | { | |
369 | struct ax88172a_private *dp = dev->driver_priv; | |
370 | struct asix_rx_fixup_info *rx = &dp->rx_fixup_info; | |
371 | ||
372 | return asix_rx_fixup_internal(dev, skb, rx); | |
373 | } | |
374 | ||
16626b0c CR |
375 | const struct driver_info ax88172a_info = { |
376 | .description = "ASIX AX88172A USB 2.0 Ethernet", | |
377 | .bind = ax88172a_bind, | |
378 | .reset = ax88172a_reset, | |
379 | .stop = ax88172a_stop, | |
380 | .unbind = ax88172a_unbind, | |
381 | .status = ax88172a_status, | |
382 | .flags = FLAG_ETHER | FLAG_FRAMING_AX | FLAG_LINK_INTR | | |
383 | FLAG_MULTI_PACKET, | |
8b5b6f54 | 384 | .rx_fixup = ax88172a_rx_fixup, |
16626b0c CR |
385 | .tx_fixup = asix_tx_fixup, |
386 | }; |