1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
29b70e007SSimon Glass /*
39b70e007SSimon Glass * Copyright (c) 2011 The Chromium OS Authors.
49b70e007SSimon Glass *
514727120SMarcel Ziswiler * Patched for AX88772B by Antmicro Ltd <www.antmicro.com>
69b70e007SSimon Glass */
79b70e007SSimon Glass
89b70e007SSimon Glass #include <common.h>
9fbc4b8afSSimon Glass #include <dm.h>
109b70e007SSimon Glass #include <usb.h>
11fbc4b8afSSimon Glass #include <malloc.h>
12cf92e05cSSimon Glass #include <memalign.h>
139b70e007SSimon Glass #include <linux/mii.h>
149b70e007SSimon Glass #include "usb_ether.h"
159b70e007SSimon Glass
169b70e007SSimon Glass /* ASIX AX8817X based USB 2.0 Ethernet Devices */
179b70e007SSimon Glass
189b70e007SSimon Glass #define AX_CMD_SET_SW_MII 0x06
199b70e007SSimon Glass #define AX_CMD_READ_MII_REG 0x07
209b70e007SSimon Glass #define AX_CMD_WRITE_MII_REG 0x08
219b70e007SSimon Glass #define AX_CMD_SET_HW_MII 0x0a
2202c8d8ccSLucas Stach #define AX_CMD_READ_EEPROM 0x0b
239b70e007SSimon Glass #define AX_CMD_READ_RX_CTL 0x0f
249b70e007SSimon Glass #define AX_CMD_WRITE_RX_CTL 0x10
259b70e007SSimon Glass #define AX_CMD_WRITE_IPG0 0x12
269b70e007SSimon Glass #define AX_CMD_READ_NODE_ID 0x13
2758f8fab8SLucas Stach #define AX_CMD_WRITE_NODE_ID 0x14
289b70e007SSimon Glass #define AX_CMD_READ_PHY_ID 0x19
299b70e007SSimon Glass #define AX_CMD_WRITE_MEDIUM_MODE 0x1b
309b70e007SSimon Glass #define AX_CMD_WRITE_GPIOS 0x1f
319b70e007SSimon Glass #define AX_CMD_SW_RESET 0x20
329b70e007SSimon Glass #define AX_CMD_SW_PHY_SELECT 0x22
339b70e007SSimon Glass
349b70e007SSimon Glass #define AX_SWRESET_CLEAR 0x00
359b70e007SSimon Glass #define AX_SWRESET_PRTE 0x04
369b70e007SSimon Glass #define AX_SWRESET_PRL 0x08
379b70e007SSimon Glass #define AX_SWRESET_IPRL 0x20
389b70e007SSimon Glass #define AX_SWRESET_IPPD 0x40
399b70e007SSimon Glass
409b70e007SSimon Glass #define AX88772_IPG0_DEFAULT 0x15
419b70e007SSimon Glass #define AX88772_IPG1_DEFAULT 0x0c
429b70e007SSimon Glass #define AX88772_IPG2_DEFAULT 0x12
439b70e007SSimon Glass
449b70e007SSimon Glass /* AX88772 & AX88178 Medium Mode Register */
459b70e007SSimon Glass #define AX_MEDIUM_PF 0x0080
469b70e007SSimon Glass #define AX_MEDIUM_JFE 0x0040
479b70e007SSimon Glass #define AX_MEDIUM_TFC 0x0020
489b70e007SSimon Glass #define AX_MEDIUM_RFC 0x0010
499b70e007SSimon Glass #define AX_MEDIUM_ENCK 0x0008
509b70e007SSimon Glass #define AX_MEDIUM_AC 0x0004
519b70e007SSimon Glass #define AX_MEDIUM_FD 0x0002
529b70e007SSimon Glass #define AX_MEDIUM_GM 0x0001
539b70e007SSimon Glass #define AX_MEDIUM_SM 0x1000
549b70e007SSimon Glass #define AX_MEDIUM_SBP 0x0800
559b70e007SSimon Glass #define AX_MEDIUM_PS 0x0200
569b70e007SSimon Glass #define AX_MEDIUM_RE 0x0100
579b70e007SSimon Glass
589b70e007SSimon Glass #define AX88178_MEDIUM_DEFAULT \
599b70e007SSimon Glass (AX_MEDIUM_PS | AX_MEDIUM_FD | AX_MEDIUM_AC | \
609b70e007SSimon Glass AX_MEDIUM_RFC | AX_MEDIUM_TFC | AX_MEDIUM_JFE | \
619b70e007SSimon Glass AX_MEDIUM_RE)
629b70e007SSimon Glass
639b70e007SSimon Glass #define AX88772_MEDIUM_DEFAULT \
649b70e007SSimon Glass (AX_MEDIUM_FD | AX_MEDIUM_RFC | \
659b70e007SSimon Glass AX_MEDIUM_TFC | AX_MEDIUM_PS | \
669b70e007SSimon Glass AX_MEDIUM_AC | AX_MEDIUM_RE)
679b70e007SSimon Glass
689b70e007SSimon Glass /* AX88772 & AX88178 RX_CTL values */
699b70e007SSimon Glass #define AX_RX_CTL_SO 0x0080
709b70e007SSimon Glass #define AX_RX_CTL_AB 0x0008
719b70e007SSimon Glass
729b70e007SSimon Glass #define AX_DEFAULT_RX_CTL \
739b70e007SSimon Glass (AX_RX_CTL_SO | AX_RX_CTL_AB)
749b70e007SSimon Glass
759b70e007SSimon Glass /* GPIO 2 toggles */
769b70e007SSimon Glass #define AX_GPIO_GPO2EN 0x10 /* GPIO2 Output enable */
779b70e007SSimon Glass #define AX_GPIO_GPO_2 0x20 /* GPIO2 Output value */
789b70e007SSimon Glass #define AX_GPIO_RSE 0x80 /* Reload serial EEPROM */
799b70e007SSimon Glass
809b70e007SSimon Glass /* local defines */
819b70e007SSimon Glass #define ASIX_BASE_NAME "asx"
829b70e007SSimon Glass #define USB_CTRL_SET_TIMEOUT 5000
839b70e007SSimon Glass #define USB_CTRL_GET_TIMEOUT 5000
849b70e007SSimon Glass #define USB_BULK_SEND_TIMEOUT 5000
859b70e007SSimon Glass #define USB_BULK_RECV_TIMEOUT 5000
869b70e007SSimon Glass
879b70e007SSimon Glass #define AX_RX_URB_SIZE 2048
889b70e007SSimon Glass #define PHY_CONNECT_TIMEOUT 5000
899b70e007SSimon Glass
9058f8fab8SLucas Stach /* asix_flags defines */
9158f8fab8SLucas Stach #define FLAG_NONE 0
9258f8fab8SLucas Stach #define FLAG_TYPE_AX88172 (1U << 0)
9358f8fab8SLucas Stach #define FLAG_TYPE_AX88772 (1U << 1)
941dff9d0fSLucas Stach #define FLAG_TYPE_AX88772B (1U << 2)
951dff9d0fSLucas Stach #define FLAG_EEPROM_MAC (1U << 3) /* initial mac address in eeprom */
9658f8fab8SLucas Stach
979b70e007SSimon Glass
9858f8fab8SLucas Stach /* driver private */
9958f8fab8SLucas Stach struct asix_private {
10058f8fab8SLucas Stach int flags;
101fbc4b8afSSimon Glass #ifdef CONFIG_DM_ETH
102fbc4b8afSSimon Glass struct ueth_data ueth;
103fbc4b8afSSimon Glass #endif
10458f8fab8SLucas Stach };
10558f8fab8SLucas Stach
106fbc4b8afSSimon Glass #ifndef CONFIG_DM_ETH
107fbc4b8afSSimon Glass /* local vars */
108fbc4b8afSSimon Glass static int curr_eth_dev; /* index for name of next device detected */
109fbc4b8afSSimon Glass #endif
110fbc4b8afSSimon Glass
1119b70e007SSimon Glass /*
1129b70e007SSimon Glass * Asix infrastructure commands
1139b70e007SSimon Glass */
asix_write_cmd(struct ueth_data * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)1149b70e007SSimon Glass static int asix_write_cmd(struct ueth_data *dev, u8 cmd, u16 value, u16 index,
1159b70e007SSimon Glass u16 size, void *data)
1169b70e007SSimon Glass {
1179b70e007SSimon Glass int len;
1189b70e007SSimon Glass
1199b70e007SSimon Glass debug("asix_write_cmd() cmd=0x%02x value=0x%04x index=0x%04x "
1209b70e007SSimon Glass "size=%d\n", cmd, value, index, size);
1219b70e007SSimon Glass
1229b70e007SSimon Glass len = usb_control_msg(
1239b70e007SSimon Glass dev->pusb_dev,
1249b70e007SSimon Glass usb_sndctrlpipe(dev->pusb_dev, 0),
1259b70e007SSimon Glass cmd,
1269b70e007SSimon Glass USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1279b70e007SSimon Glass value,
1289b70e007SSimon Glass index,
1299b70e007SSimon Glass data,
1309b70e007SSimon Glass size,
1319b70e007SSimon Glass USB_CTRL_SET_TIMEOUT);
1329b70e007SSimon Glass
1339b70e007SSimon Glass return len == size ? 0 : -1;
1349b70e007SSimon Glass }
1359b70e007SSimon Glass
asix_read_cmd(struct ueth_data * dev,u8 cmd,u16 value,u16 index,u16 size,void * data)1369b70e007SSimon Glass static int asix_read_cmd(struct ueth_data *dev, u8 cmd, u16 value, u16 index,
1379b70e007SSimon Glass u16 size, void *data)
1389b70e007SSimon Glass {
1399b70e007SSimon Glass int len;
1409b70e007SSimon Glass
1419b70e007SSimon Glass debug("asix_read_cmd() cmd=0x%02x value=0x%04x index=0x%04x size=%d\n",
1429b70e007SSimon Glass cmd, value, index, size);
1439b70e007SSimon Glass
1449b70e007SSimon Glass len = usb_control_msg(
1459b70e007SSimon Glass dev->pusb_dev,
1469b70e007SSimon Glass usb_rcvctrlpipe(dev->pusb_dev, 0),
1479b70e007SSimon Glass cmd,
1489b70e007SSimon Glass USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1499b70e007SSimon Glass value,
1509b70e007SSimon Glass index,
1519b70e007SSimon Glass data,
1529b70e007SSimon Glass size,
1539b70e007SSimon Glass USB_CTRL_GET_TIMEOUT);
1549b70e007SSimon Glass return len == size ? 0 : -1;
1559b70e007SSimon Glass }
1569b70e007SSimon Glass
asix_set_sw_mii(struct ueth_data * dev)1579b70e007SSimon Glass static inline int asix_set_sw_mii(struct ueth_data *dev)
1589b70e007SSimon Glass {
1599b70e007SSimon Glass int ret;
1609b70e007SSimon Glass
1619b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_SET_SW_MII, 0x0000, 0, 0, NULL);
1629b70e007SSimon Glass if (ret < 0)
1639b70e007SSimon Glass debug("Failed to enable software MII access\n");
1649b70e007SSimon Glass return ret;
1659b70e007SSimon Glass }
1669b70e007SSimon Glass
asix_set_hw_mii(struct ueth_data * dev)1679b70e007SSimon Glass static inline int asix_set_hw_mii(struct ueth_data *dev)
1689b70e007SSimon Glass {
1699b70e007SSimon Glass int ret;
1709b70e007SSimon Glass
1719b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_SET_HW_MII, 0x0000, 0, 0, NULL);
1729b70e007SSimon Glass if (ret < 0)
1739b70e007SSimon Glass debug("Failed to enable hardware MII access\n");
1749b70e007SSimon Glass return ret;
1759b70e007SSimon Glass }
1769b70e007SSimon Glass
asix_mdio_read(struct ueth_data * dev,int phy_id,int loc)1779b70e007SSimon Glass static int asix_mdio_read(struct ueth_data *dev, int phy_id, int loc)
1789b70e007SSimon Glass {
179c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(__le16, res, 1);
1809b70e007SSimon Glass
1819b70e007SSimon Glass asix_set_sw_mii(dev);
182c59ab092SMarek Vasut asix_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id, (__u16)loc, 2, res);
1839b70e007SSimon Glass asix_set_hw_mii(dev);
1849b70e007SSimon Glass
1859b70e007SSimon Glass debug("asix_mdio_read() phy_id=0x%02x, loc=0x%02x, returns=0x%04x\n",
186c59ab092SMarek Vasut phy_id, loc, le16_to_cpu(*res));
1879b70e007SSimon Glass
188c59ab092SMarek Vasut return le16_to_cpu(*res);
1899b70e007SSimon Glass }
1909b70e007SSimon Glass
1919b70e007SSimon Glass static void
asix_mdio_write(struct ueth_data * dev,int phy_id,int loc,int val)1929b70e007SSimon Glass asix_mdio_write(struct ueth_data *dev, int phy_id, int loc, int val)
1939b70e007SSimon Glass {
194c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(__le16, res, 1);
195c59ab092SMarek Vasut *res = cpu_to_le16(val);
1969b70e007SSimon Glass
1979b70e007SSimon Glass debug("asix_mdio_write() phy_id=0x%02x, loc=0x%02x, val=0x%04x\n",
1989b70e007SSimon Glass phy_id, loc, val);
1999b70e007SSimon Glass asix_set_sw_mii(dev);
200c59ab092SMarek Vasut asix_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, res);
2019b70e007SSimon Glass asix_set_hw_mii(dev);
2029b70e007SSimon Glass }
2039b70e007SSimon Glass
2049b70e007SSimon Glass /*
2059b70e007SSimon Glass * Asix "high level" commands
2069b70e007SSimon Glass */
asix_sw_reset(struct ueth_data * dev,u8 flags)2079b70e007SSimon Glass static int asix_sw_reset(struct ueth_data *dev, u8 flags)
2089b70e007SSimon Glass {
2099b70e007SSimon Glass int ret;
2109b70e007SSimon Glass
2119b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_SW_RESET, flags, 0, 0, NULL);
2129b70e007SSimon Glass if (ret < 0)
2139b70e007SSimon Glass debug("Failed to send software reset: %02x\n", ret);
2149b70e007SSimon Glass else
2159b70e007SSimon Glass udelay(150 * 1000);
2169b70e007SSimon Glass
2179b70e007SSimon Glass return ret;
2189b70e007SSimon Glass }
2199b70e007SSimon Glass
asix_get_phy_addr(struct ueth_data * dev)2209b70e007SSimon Glass static inline int asix_get_phy_addr(struct ueth_data *dev)
2219b70e007SSimon Glass {
222c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(u8, buf, 2);
223c59ab092SMarek Vasut
2249b70e007SSimon Glass int ret = asix_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf);
2259b70e007SSimon Glass
2269b70e007SSimon Glass debug("asix_get_phy_addr()\n");
2279b70e007SSimon Glass
2289b70e007SSimon Glass if (ret < 0) {
2299b70e007SSimon Glass debug("Error reading PHYID register: %02x\n", ret);
2309b70e007SSimon Glass goto out;
2319b70e007SSimon Glass }
2320ed1eb6fSMarek Vasut debug("asix_get_phy_addr() returning 0x%02x%02x\n", buf[0], buf[1]);
2339b70e007SSimon Glass ret = buf[1];
2349b70e007SSimon Glass
2359b70e007SSimon Glass out:
2369b70e007SSimon Glass return ret;
2379b70e007SSimon Glass }
2389b70e007SSimon Glass
asix_write_medium_mode(struct ueth_data * dev,u16 mode)2399b70e007SSimon Glass static int asix_write_medium_mode(struct ueth_data *dev, u16 mode)
2409b70e007SSimon Glass {
2419b70e007SSimon Glass int ret;
2429b70e007SSimon Glass
2439b70e007SSimon Glass debug("asix_write_medium_mode() - mode = 0x%04x\n", mode);
2449b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode,
2459b70e007SSimon Glass 0, 0, NULL);
2469b70e007SSimon Glass if (ret < 0) {
2479b70e007SSimon Glass debug("Failed to write Medium Mode mode to 0x%04x: %02x\n",
2489b70e007SSimon Glass mode, ret);
2499b70e007SSimon Glass }
2509b70e007SSimon Glass return ret;
2519b70e007SSimon Glass }
2529b70e007SSimon Glass
asix_read_rx_ctl(struct ueth_data * dev)2539b70e007SSimon Glass static u16 asix_read_rx_ctl(struct ueth_data *dev)
2549b70e007SSimon Glass {
255c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(__le16, v, 1);
256c59ab092SMarek Vasut
257c59ab092SMarek Vasut int ret = asix_read_cmd(dev, AX_CMD_READ_RX_CTL, 0, 0, 2, v);
2589b70e007SSimon Glass
2599b70e007SSimon Glass if (ret < 0)
2609b70e007SSimon Glass debug("Error reading RX_CTL register: %02x\n", ret);
2619b70e007SSimon Glass else
262c59ab092SMarek Vasut ret = le16_to_cpu(*v);
2639b70e007SSimon Glass return ret;
2649b70e007SSimon Glass }
2659b70e007SSimon Glass
asix_write_rx_ctl(struct ueth_data * dev,u16 mode)2669b70e007SSimon Glass static int asix_write_rx_ctl(struct ueth_data *dev, u16 mode)
2679b70e007SSimon Glass {
2689b70e007SSimon Glass int ret;
2699b70e007SSimon Glass
2709b70e007SSimon Glass debug("asix_write_rx_ctl() - mode = 0x%04x\n", mode);
2719b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_WRITE_RX_CTL, mode, 0, 0, NULL);
2729b70e007SSimon Glass if (ret < 0) {
2739b70e007SSimon Glass debug("Failed to write RX_CTL mode to 0x%04x: %02x\n",
2749b70e007SSimon Glass mode, ret);
2759b70e007SSimon Glass }
2769b70e007SSimon Glass return ret;
2779b70e007SSimon Glass }
2789b70e007SSimon Glass
asix_write_gpio(struct ueth_data * dev,u16 value,int sleep)2799b70e007SSimon Glass static int asix_write_gpio(struct ueth_data *dev, u16 value, int sleep)
2809b70e007SSimon Glass {
2819b70e007SSimon Glass int ret;
2829b70e007SSimon Glass
2839b70e007SSimon Glass debug("asix_write_gpio() - value = 0x%04x\n", value);
2849b70e007SSimon Glass ret = asix_write_cmd(dev, AX_CMD_WRITE_GPIOS, value, 0, 0, NULL);
2859b70e007SSimon Glass if (ret < 0) {
2869b70e007SSimon Glass debug("Failed to write GPIO value 0x%04x: %02x\n",
2879b70e007SSimon Glass value, ret);
2889b70e007SSimon Glass }
2899b70e007SSimon Glass if (sleep)
2909b70e007SSimon Glass udelay(sleep * 1000);
2919b70e007SSimon Glass
2929b70e007SSimon Glass return ret;
2939b70e007SSimon Glass }
2949b70e007SSimon Glass
asix_write_hwaddr_common(struct ueth_data * dev,uint8_t * enetaddr)295fbc4b8afSSimon Glass static int asix_write_hwaddr_common(struct ueth_data *dev, uint8_t *enetaddr)
29658f8fab8SLucas Stach {
29758f8fab8SLucas Stach int ret;
29858f8fab8SLucas Stach ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buf, ETH_ALEN);
29958f8fab8SLucas Stach
300fbc4b8afSSimon Glass memcpy(buf, enetaddr, ETH_ALEN);
30158f8fab8SLucas Stach
30258f8fab8SLucas Stach ret = asix_write_cmd(dev, AX_CMD_WRITE_NODE_ID, 0, 0, ETH_ALEN, buf);
30358f8fab8SLucas Stach if (ret < 0)
30458f8fab8SLucas Stach debug("Failed to set MAC address: %02x\n", ret);
30558f8fab8SLucas Stach
30658f8fab8SLucas Stach return ret;
30758f8fab8SLucas Stach }
30858f8fab8SLucas Stach
3099b70e007SSimon Glass /*
3109b70e007SSimon Glass * mii commands
3119b70e007SSimon Glass */
3129b70e007SSimon Glass
3139b70e007SSimon Glass /*
3149b70e007SSimon Glass * mii_nway_restart - restart NWay (autonegotiation) for this interface
3159b70e007SSimon Glass *
3169b70e007SSimon Glass * Returns 0 on success, negative on error.
3179b70e007SSimon Glass */
mii_nway_restart(struct ueth_data * dev)3189b70e007SSimon Glass static int mii_nway_restart(struct ueth_data *dev)
3199b70e007SSimon Glass {
3209b70e007SSimon Glass int bmcr;
3219b70e007SSimon Glass int r = -1;
3229b70e007SSimon Glass
3239b70e007SSimon Glass /* if autoneg is off, it's an error */
3249b70e007SSimon Glass bmcr = asix_mdio_read(dev, dev->phy_id, MII_BMCR);
3259b70e007SSimon Glass
3269b70e007SSimon Glass if (bmcr & BMCR_ANENABLE) {
3279b70e007SSimon Glass bmcr |= BMCR_ANRESTART;
3289b70e007SSimon Glass asix_mdio_write(dev, dev->phy_id, MII_BMCR, bmcr);
3299b70e007SSimon Glass r = 0;
3309b70e007SSimon Glass }
3319b70e007SSimon Glass
3329b70e007SSimon Glass return r;
3339b70e007SSimon Glass }
3349b70e007SSimon Glass
asix_read_mac_common(struct ueth_data * dev,struct asix_private * priv,uint8_t * enetaddr)335fbc4b8afSSimon Glass static int asix_read_mac_common(struct ueth_data *dev,
336fbc4b8afSSimon Glass struct asix_private *priv, uint8_t *enetaddr)
33702c8d8ccSLucas Stach {
33802c8d8ccSLucas Stach ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buf, ETH_ALEN);
339fbc4b8afSSimon Glass int i;
34002c8d8ccSLucas Stach
34102c8d8ccSLucas Stach if (priv->flags & FLAG_EEPROM_MAC) {
34202c8d8ccSLucas Stach for (i = 0; i < (ETH_ALEN >> 1); i++) {
34302c8d8ccSLucas Stach if (asix_read_cmd(dev, AX_CMD_READ_EEPROM,
34402c8d8ccSLucas Stach 0x04 + i, 0, 2, buf) < 0) {
34502c8d8ccSLucas Stach debug("Failed to read SROM address 04h.\n");
34602c8d8ccSLucas Stach return -1;
34702c8d8ccSLucas Stach }
348fbc4b8afSSimon Glass memcpy(enetaddr + i * 2, buf, 2);
34902c8d8ccSLucas Stach }
35002c8d8ccSLucas Stach } else {
35102c8d8ccSLucas Stach if (asix_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf)
35202c8d8ccSLucas Stach < 0) {
35302c8d8ccSLucas Stach debug("Failed to read MAC address.\n");
35402c8d8ccSLucas Stach return -1;
35502c8d8ccSLucas Stach }
356fbc4b8afSSimon Glass memcpy(enetaddr, buf, ETH_ALEN);
35702c8d8ccSLucas Stach }
35802c8d8ccSLucas Stach
35902c8d8ccSLucas Stach return 0;
36002c8d8ccSLucas Stach }
36102c8d8ccSLucas Stach
asix_basic_reset(struct ueth_data * dev)3625fae53d0SLucas Stach static int asix_basic_reset(struct ueth_data *dev)
3639b70e007SSimon Glass {
3649b70e007SSimon Glass int embd_phy;
3659b70e007SSimon Glass u16 rx_ctl;
3669b70e007SSimon Glass
3679b70e007SSimon Glass if (asix_write_gpio(dev,
3689b70e007SSimon Glass AX_GPIO_RSE | AX_GPIO_GPO_2 | AX_GPIO_GPO2EN, 5) < 0)
3695fae53d0SLucas Stach return -1;
3709b70e007SSimon Glass
3719b70e007SSimon Glass /* 0x10 is the phy id of the embedded 10/100 ethernet phy */
3729b70e007SSimon Glass embd_phy = ((asix_get_phy_addr(dev) & 0x1f) == 0x10 ? 1 : 0);
3739b70e007SSimon Glass if (asix_write_cmd(dev, AX_CMD_SW_PHY_SELECT,
3749b70e007SSimon Glass embd_phy, 0, 0, NULL) < 0) {
3759b70e007SSimon Glass debug("Select PHY #1 failed\n");
3765fae53d0SLucas Stach return -1;
3779b70e007SSimon Glass }
3789b70e007SSimon Glass
3799b70e007SSimon Glass if (asix_sw_reset(dev, AX_SWRESET_IPPD | AX_SWRESET_PRL) < 0)
3805fae53d0SLucas Stach return -1;
3819b70e007SSimon Glass
3829b70e007SSimon Glass if (asix_sw_reset(dev, AX_SWRESET_CLEAR) < 0)
3835fae53d0SLucas Stach return -1;
3849b70e007SSimon Glass
3859b70e007SSimon Glass if (embd_phy) {
3869b70e007SSimon Glass if (asix_sw_reset(dev, AX_SWRESET_IPRL) < 0)
3875fae53d0SLucas Stach return -1;
3889b70e007SSimon Glass } else {
3899b70e007SSimon Glass if (asix_sw_reset(dev, AX_SWRESET_PRTE) < 0)
3905fae53d0SLucas Stach return -1;
3919b70e007SSimon Glass }
3929b70e007SSimon Glass
3939b70e007SSimon Glass rx_ctl = asix_read_rx_ctl(dev);
3949b70e007SSimon Glass debug("RX_CTL is 0x%04x after software reset\n", rx_ctl);
3959b70e007SSimon Glass if (asix_write_rx_ctl(dev, 0x0000) < 0)
3965fae53d0SLucas Stach return -1;
3979b70e007SSimon Glass
3989b70e007SSimon Glass rx_ctl = asix_read_rx_ctl(dev);
3999b70e007SSimon Glass debug("RX_CTL is 0x%04x setting to 0x0000\n", rx_ctl);
4009b70e007SSimon Glass
4014edcf0a3SJulius Werner dev->phy_id = asix_get_phy_addr(dev);
4024edcf0a3SJulius Werner if (dev->phy_id < 0)
4034edcf0a3SJulius Werner debug("Failed to read phy id\n");
4044edcf0a3SJulius Werner
4054edcf0a3SJulius Werner asix_mdio_write(dev, dev->phy_id, MII_BMCR, BMCR_RESET);
4064edcf0a3SJulius Werner asix_mdio_write(dev, dev->phy_id, MII_ADVERTISE,
4074edcf0a3SJulius Werner ADVERTISE_ALL | ADVERTISE_CSMA);
4084edcf0a3SJulius Werner mii_nway_restart(dev);
4094edcf0a3SJulius Werner
4104edcf0a3SJulius Werner if (asix_write_medium_mode(dev, AX88772_MEDIUM_DEFAULT) < 0)
4114edcf0a3SJulius Werner return -1;
4124edcf0a3SJulius Werner
4134edcf0a3SJulius Werner if (asix_write_cmd(dev, AX_CMD_WRITE_IPG0,
4144edcf0a3SJulius Werner AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
4154edcf0a3SJulius Werner AX88772_IPG2_DEFAULT, 0, NULL) < 0) {
4164edcf0a3SJulius Werner debug("Write IPG,IPG1,IPG2 failed\n");
4174edcf0a3SJulius Werner return -1;
4184edcf0a3SJulius Werner }
4194edcf0a3SJulius Werner
4205fae53d0SLucas Stach return 0;
4215fae53d0SLucas Stach }
4225fae53d0SLucas Stach
asix_init_common(struct ueth_data * dev,uint8_t * enetaddr)42314727120SMarcel Ziswiler static int asix_init_common(struct ueth_data *dev, uint8_t *enetaddr)
4245fae53d0SLucas Stach {
4255fae53d0SLucas Stach int timeout = 0;
4265fae53d0SLucas Stach #define TIMEOUT_RESOLUTION 50 /* ms */
4275fae53d0SLucas Stach int link_detected;
4285fae53d0SLucas Stach
4295fae53d0SLucas Stach debug("** %s()\n", __func__);
4305fae53d0SLucas Stach
431cea6c8ceSAlban Bedel if (asix_write_rx_ctl(dev, AX_DEFAULT_RX_CTL) < 0)
43214727120SMarcel Ziswiler goto out_err;
43314727120SMarcel Ziswiler
43414727120SMarcel Ziswiler if (asix_write_hwaddr_common(dev, enetaddr) < 0)
4359b70e007SSimon Glass goto out_err;
4369b70e007SSimon Glass
4379b70e007SSimon Glass do {
4389b70e007SSimon Glass link_detected = asix_mdio_read(dev, dev->phy_id, MII_BMSR) &
4399b70e007SSimon Glass BMSR_LSTATUS;
4409b70e007SSimon Glass if (!link_detected) {
4419b70e007SSimon Glass if (timeout == 0)
4429b70e007SSimon Glass printf("Waiting for Ethernet connection... ");
4439b70e007SSimon Glass udelay(TIMEOUT_RESOLUTION * 1000);
4449b70e007SSimon Glass timeout += TIMEOUT_RESOLUTION;
4459b70e007SSimon Glass }
4469b70e007SSimon Glass } while (!link_detected && timeout < PHY_CONNECT_TIMEOUT);
4479b70e007SSimon Glass if (link_detected) {
4489b70e007SSimon Glass if (timeout != 0)
4499b70e007SSimon Glass printf("done.\n");
4509b70e007SSimon Glass } else {
4519b70e007SSimon Glass printf("unable to connect.\n");
4529b70e007SSimon Glass goto out_err;
4539b70e007SSimon Glass }
4549b70e007SSimon Glass
45514727120SMarcel Ziswiler /*
45614727120SMarcel Ziswiler * Wait some more to avoid timeout on first transfer
45714727120SMarcel Ziswiler * (e.g. EHCI timed out on TD - token=0x8008d80)
45814727120SMarcel Ziswiler */
45914727120SMarcel Ziswiler mdelay(25);
46014727120SMarcel Ziswiler
4619b70e007SSimon Glass return 0;
4629b70e007SSimon Glass out_err:
4639b70e007SSimon Glass return -1;
4649b70e007SSimon Glass }
4659b70e007SSimon Glass
asix_send_common(struct ueth_data * dev,void * packet,int length)466fbc4b8afSSimon Glass static int asix_send_common(struct ueth_data *dev, void *packet, int length)
4679b70e007SSimon Glass {
4689b70e007SSimon Glass int err;
4699b70e007SSimon Glass u32 packet_len;
4709b70e007SSimon Glass int actual_len;
471c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(unsigned char, msg,
472c59ab092SMarek Vasut PKTSIZE + sizeof(packet_len));
4739b70e007SSimon Glass
4749b70e007SSimon Glass debug("** %s(), len %d\n", __func__, length);
4759b70e007SSimon Glass
4769b70e007SSimon Glass packet_len = (((length) ^ 0x0000ffff) << 16) + (length);
4779b70e007SSimon Glass cpu_to_le32s(&packet_len);
4789b70e007SSimon Glass
4799b70e007SSimon Glass memcpy(msg, &packet_len, sizeof(packet_len));
4809b70e007SSimon Glass memcpy(msg + sizeof(packet_len), (void *)packet, length);
4819b70e007SSimon Glass
4829b70e007SSimon Glass err = usb_bulk_msg(dev->pusb_dev,
4839b70e007SSimon Glass usb_sndbulkpipe(dev->pusb_dev, dev->ep_out),
4849b70e007SSimon Glass (void *)msg,
4859b70e007SSimon Glass length + sizeof(packet_len),
4869b70e007SSimon Glass &actual_len,
4879b70e007SSimon Glass USB_BULK_SEND_TIMEOUT);
4884c5998b7SThierry Reding debug("Tx: len = %zu, actual = %u, err = %d\n",
4899b70e007SSimon Glass length + sizeof(packet_len), actual_len, err);
4909b70e007SSimon Glass
4919b70e007SSimon Glass return err;
4929b70e007SSimon Glass }
4939b70e007SSimon Glass
494fbc4b8afSSimon Glass #ifndef CONFIG_DM_ETH
495fbc4b8afSSimon Glass /*
496fbc4b8afSSimon Glass * Asix callbacks
497fbc4b8afSSimon Glass */
asix_init(struct eth_device * eth,bd_t * bd)498fbc4b8afSSimon Glass static int asix_init(struct eth_device *eth, bd_t *bd)
499fbc4b8afSSimon Glass {
500fbc4b8afSSimon Glass struct ueth_data *dev = (struct ueth_data *)eth->priv;
501fbc4b8afSSimon Glass
50214727120SMarcel Ziswiler return asix_init_common(dev, eth->enetaddr);
503fbc4b8afSSimon Glass }
504fbc4b8afSSimon Glass
asix_send(struct eth_device * eth,void * packet,int length)505fbc4b8afSSimon Glass static int asix_send(struct eth_device *eth, void *packet, int length)
506fbc4b8afSSimon Glass {
507fbc4b8afSSimon Glass struct ueth_data *dev = (struct ueth_data *)eth->priv;
508fbc4b8afSSimon Glass
509fbc4b8afSSimon Glass return asix_send_common(dev, packet, length);
510fbc4b8afSSimon Glass }
511fbc4b8afSSimon Glass
asix_recv(struct eth_device * eth)5129b70e007SSimon Glass static int asix_recv(struct eth_device *eth)
5139b70e007SSimon Glass {
5149b70e007SSimon Glass struct ueth_data *dev = (struct ueth_data *)eth->priv;
515c59ab092SMarek Vasut ALLOC_CACHE_ALIGN_BUFFER(unsigned char, recv_buf, AX_RX_URB_SIZE);
5169b70e007SSimon Glass unsigned char *buf_ptr;
5179b70e007SSimon Glass int err;
5189b70e007SSimon Glass int actual_len;
5199b70e007SSimon Glass u32 packet_len;
5209b70e007SSimon Glass
5219b70e007SSimon Glass debug("** %s()\n", __func__);
5229b70e007SSimon Glass
5239b70e007SSimon Glass err = usb_bulk_msg(dev->pusb_dev,
5249b70e007SSimon Glass usb_rcvbulkpipe(dev->pusb_dev, dev->ep_in),
5259b70e007SSimon Glass (void *)recv_buf,
5269b70e007SSimon Glass AX_RX_URB_SIZE,
5279b70e007SSimon Glass &actual_len,
5289b70e007SSimon Glass USB_BULK_RECV_TIMEOUT);
5299b70e007SSimon Glass debug("Rx: len = %u, actual = %u, err = %d\n", AX_RX_URB_SIZE,
5309b70e007SSimon Glass actual_len, err);
5319b70e007SSimon Glass if (err != 0) {
5329b70e007SSimon Glass debug("Rx: failed to receive\n");
5339b70e007SSimon Glass return -1;
5349b70e007SSimon Glass }
5359b70e007SSimon Glass if (actual_len > AX_RX_URB_SIZE) {
5369b70e007SSimon Glass debug("Rx: received too many bytes %d\n", actual_len);
5379b70e007SSimon Glass return -1;
5389b70e007SSimon Glass }
5399b70e007SSimon Glass
5409b70e007SSimon Glass buf_ptr = recv_buf;
5419b70e007SSimon Glass while (actual_len > 0) {
5429b70e007SSimon Glass /*
5439b70e007SSimon Glass * 1st 4 bytes contain the length of the actual data as two
5449b70e007SSimon Glass * complementary 16-bit words. Extract the length of the data.
5459b70e007SSimon Glass */
5469b70e007SSimon Glass if (actual_len < sizeof(packet_len)) {
5479b70e007SSimon Glass debug("Rx: incomplete packet length\n");
5489b70e007SSimon Glass return -1;
5499b70e007SSimon Glass }
5509b70e007SSimon Glass memcpy(&packet_len, buf_ptr, sizeof(packet_len));
5519b70e007SSimon Glass le32_to_cpus(&packet_len);
5521dff9d0fSLucas Stach if (((~packet_len >> 16) & 0x7ff) != (packet_len & 0x7ff)) {
5539b70e007SSimon Glass debug("Rx: malformed packet length: %#x (%#x:%#x)\n",
5541dff9d0fSLucas Stach packet_len, (~packet_len >> 16) & 0x7ff,
5551dff9d0fSLucas Stach packet_len & 0x7ff);
5569b70e007SSimon Glass return -1;
5579b70e007SSimon Glass }
5581dff9d0fSLucas Stach packet_len = packet_len & 0x7ff;
5599b70e007SSimon Glass if (packet_len > actual_len - sizeof(packet_len)) {
5609b70e007SSimon Glass debug("Rx: too large packet: %d\n", packet_len);
5619b70e007SSimon Glass return -1;
5629b70e007SSimon Glass }
5639b70e007SSimon Glass
5649b70e007SSimon Glass /* Notify net stack */
5651fd92db8SJoe Hershberger net_process_received_packet(buf_ptr + sizeof(packet_len),
5661fd92db8SJoe Hershberger packet_len);
5679b70e007SSimon Glass
5689b70e007SSimon Glass /* Adjust for next iteration. Packets are padded to 16-bits */
5699b70e007SSimon Glass if (packet_len & 1)
5709b70e007SSimon Glass packet_len++;
5719b70e007SSimon Glass actual_len -= sizeof(packet_len) + packet_len;
5729b70e007SSimon Glass buf_ptr += sizeof(packet_len) + packet_len;
5739b70e007SSimon Glass }
5749b70e007SSimon Glass
5759b70e007SSimon Glass return err;
5769b70e007SSimon Glass }
5779b70e007SSimon Glass
asix_halt(struct eth_device * eth)5789b70e007SSimon Glass static void asix_halt(struct eth_device *eth)
5799b70e007SSimon Glass {
5809b70e007SSimon Glass debug("** %s()\n", __func__);
5819b70e007SSimon Glass }
5829b70e007SSimon Glass
asix_write_hwaddr(struct eth_device * eth)583fbc4b8afSSimon Glass static int asix_write_hwaddr(struct eth_device *eth)
584fbc4b8afSSimon Glass {
585fbc4b8afSSimon Glass struct ueth_data *dev = (struct ueth_data *)eth->priv;
586fbc4b8afSSimon Glass
587fbc4b8afSSimon Glass return asix_write_hwaddr_common(dev, eth->enetaddr);
588fbc4b8afSSimon Glass }
589fbc4b8afSSimon Glass
5909b70e007SSimon Glass /*
5919b70e007SSimon Glass * Asix probing functions
5929b70e007SSimon Glass */
asix_eth_before_probe(void)5939b70e007SSimon Glass void asix_eth_before_probe(void)
5949b70e007SSimon Glass {
5959b70e007SSimon Glass curr_eth_dev = 0;
5969b70e007SSimon Glass }
5979b70e007SSimon Glass
5989b70e007SSimon Glass struct asix_dongle {
5999b70e007SSimon Glass unsigned short vendor;
6009b70e007SSimon Glass unsigned short product;
60158f8fab8SLucas Stach int flags;
6029b70e007SSimon Glass };
6039b70e007SSimon Glass
60451afc2c6SJeroen Hofstee static const struct asix_dongle asix_dongles[] = {
60558f8fab8SLucas Stach { 0x05ac, 0x1402, FLAG_TYPE_AX88772 }, /* Apple USB Ethernet Adapter */
60658f8fab8SLucas Stach { 0x07d1, 0x3c05, FLAG_TYPE_AX88772 }, /* D-Link DUB-E100 H/W Ver B1 */
607befd3872SPierre Aubert { 0x2001, 0x1a02, FLAG_TYPE_AX88772 }, /* D-Link DUB-E100 H/W Ver C1 */
60858f8fab8SLucas Stach /* Cables-to-Go USB Ethernet Adapter */
60958f8fab8SLucas Stach { 0x0b95, 0x772a, FLAG_TYPE_AX88772 },
61058f8fab8SLucas Stach { 0x0b95, 0x7720, FLAG_TYPE_AX88772 }, /* Trendnet TU2-ET100 V3.0R */
61158f8fab8SLucas Stach { 0x0b95, 0x1720, FLAG_TYPE_AX88172 }, /* SMC */
61258f8fab8SLucas Stach { 0x0db0, 0xa877, FLAG_TYPE_AX88772 }, /* MSI - ASIX 88772a */
61358f8fab8SLucas Stach { 0x13b1, 0x0018, FLAG_TYPE_AX88172 }, /* Linksys 200M v2.1 */
61458f8fab8SLucas Stach { 0x1557, 0x7720, FLAG_TYPE_AX88772 }, /* 0Q0 cable ethernet */
61558f8fab8SLucas Stach /* DLink DUB-E100 H/W Ver B1 Alternate */
61658f8fab8SLucas Stach { 0x2001, 0x3c05, FLAG_TYPE_AX88772 },
6171dff9d0fSLucas Stach /* ASIX 88772B */
6181dff9d0fSLucas Stach { 0x0b95, 0x772b, FLAG_TYPE_AX88772B | FLAG_EEPROM_MAC },
619a7f24722SAlexandre Courbot { 0x0b95, 0x7e2b, FLAG_TYPE_AX88772B },
62058f8fab8SLucas Stach { 0x0000, 0x0000, FLAG_NONE } /* END - Do not remove */
6219b70e007SSimon Glass };
6229b70e007SSimon Glass
6239b70e007SSimon Glass /* Probe to see if a new device is actually an asix device */
asix_eth_probe(struct usb_device * dev,unsigned int ifnum,struct ueth_data * ss)6249b70e007SSimon Glass int asix_eth_probe(struct usb_device *dev, unsigned int ifnum,
6259b70e007SSimon Glass struct ueth_data *ss)
6269b70e007SSimon Glass {
6279b70e007SSimon Glass struct usb_interface *iface;
6289b70e007SSimon Glass struct usb_interface_descriptor *iface_desc;
6291dff9d0fSLucas Stach int ep_in_found = 0, ep_out_found = 0;
6309b70e007SSimon Glass int i;
6319b70e007SSimon Glass
6329b70e007SSimon Glass /* let's examine the device now */
6339b70e007SSimon Glass iface = &dev->config.if_desc[ifnum];
6349b70e007SSimon Glass iface_desc = &dev->config.if_desc[ifnum].desc;
6359b70e007SSimon Glass
6369b70e007SSimon Glass for (i = 0; asix_dongles[i].vendor != 0; i++) {
6379b70e007SSimon Glass if (dev->descriptor.idVendor == asix_dongles[i].vendor &&
6389b70e007SSimon Glass dev->descriptor.idProduct == asix_dongles[i].product)
6399b70e007SSimon Glass /* Found a supported dongle */
6409b70e007SSimon Glass break;
6419b70e007SSimon Glass }
6429b70e007SSimon Glass
6439b70e007SSimon Glass if (asix_dongles[i].vendor == 0)
6449b70e007SSimon Glass return 0;
6459b70e007SSimon Glass
6469b70e007SSimon Glass memset(ss, 0, sizeof(struct ueth_data));
6479b70e007SSimon Glass
6489b70e007SSimon Glass /* At this point, we know we've got a live one */
6499b70e007SSimon Glass debug("\n\nUSB Ethernet device detected: %#04x:%#04x\n",
6509b70e007SSimon Glass dev->descriptor.idVendor, dev->descriptor.idProduct);
6519b70e007SSimon Glass
6529b70e007SSimon Glass /* Initialize the ueth_data structure with some useful info */
6539b70e007SSimon Glass ss->ifnum = ifnum;
6549b70e007SSimon Glass ss->pusb_dev = dev;
6559b70e007SSimon Glass ss->subclass = iface_desc->bInterfaceSubClass;
6569b70e007SSimon Glass ss->protocol = iface_desc->bInterfaceProtocol;
6579b70e007SSimon Glass
65858f8fab8SLucas Stach /* alloc driver private */
65958f8fab8SLucas Stach ss->dev_priv = calloc(1, sizeof(struct asix_private));
66058f8fab8SLucas Stach if (!ss->dev_priv)
66158f8fab8SLucas Stach return 0;
66258f8fab8SLucas Stach
66358f8fab8SLucas Stach ((struct asix_private *)ss->dev_priv)->flags = asix_dongles[i].flags;
66458f8fab8SLucas Stach
6659b70e007SSimon Glass /*
6669b70e007SSimon Glass * We are expecting a minimum of 3 endpoints - in, out (bulk), and
6679b70e007SSimon Glass * int. We will ignore any others.
6689b70e007SSimon Glass */
6699b70e007SSimon Glass for (i = 0; i < iface_desc->bNumEndpoints; i++) {
6709b70e007SSimon Glass /* is it an BULK endpoint? */
6719b70e007SSimon Glass if ((iface->ep_desc[i].bmAttributes &
6729b70e007SSimon Glass USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
6731dff9d0fSLucas Stach u8 ep_addr = iface->ep_desc[i].bEndpointAddress;
6741dff9d0fSLucas Stach if (ep_addr & USB_DIR_IN) {
6751dff9d0fSLucas Stach if (!ep_in_found) {
6761dff9d0fSLucas Stach ss->ep_in = ep_addr &
6779b70e007SSimon Glass USB_ENDPOINT_NUMBER_MASK;
6781dff9d0fSLucas Stach ep_in_found = 1;
6791dff9d0fSLucas Stach }
6801dff9d0fSLucas Stach } else {
6811dff9d0fSLucas Stach if (!ep_out_found) {
6821dff9d0fSLucas Stach ss->ep_out = ep_addr &
6839b70e007SSimon Glass USB_ENDPOINT_NUMBER_MASK;
6841dff9d0fSLucas Stach ep_out_found = 1;
6851dff9d0fSLucas Stach }
6861dff9d0fSLucas Stach }
6879b70e007SSimon Glass }
6889b70e007SSimon Glass
6899b70e007SSimon Glass /* is it an interrupt endpoint? */
6909b70e007SSimon Glass if ((iface->ep_desc[i].bmAttributes &
6919b70e007SSimon Glass USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
6929b70e007SSimon Glass ss->ep_int = iface->ep_desc[i].bEndpointAddress &
6939b70e007SSimon Glass USB_ENDPOINT_NUMBER_MASK;
6949b70e007SSimon Glass ss->irqinterval = iface->ep_desc[i].bInterval;
6959b70e007SSimon Glass }
6969b70e007SSimon Glass }
6979b70e007SSimon Glass debug("Endpoints In %d Out %d Int %d\n",
6989b70e007SSimon Glass ss->ep_in, ss->ep_out, ss->ep_int);
6999b70e007SSimon Glass
7009b70e007SSimon Glass /* Do some basic sanity checks, and bail if we find a problem */
7019b70e007SSimon Glass if (usb_set_interface(dev, iface_desc->bInterfaceNumber, 0) ||
7029b70e007SSimon Glass !ss->ep_in || !ss->ep_out || !ss->ep_int) {
7039b70e007SSimon Glass debug("Problems with device\n");
7049b70e007SSimon Glass return 0;
7059b70e007SSimon Glass }
7069b70e007SSimon Glass dev->privptr = (void *)ss;
7079b70e007SSimon Glass return 1;
7089b70e007SSimon Glass }
7099b70e007SSimon Glass
asix_eth_get_info(struct usb_device * dev,struct ueth_data * ss,struct eth_device * eth)7109b70e007SSimon Glass int asix_eth_get_info(struct usb_device *dev, struct ueth_data *ss,
7119b70e007SSimon Glass struct eth_device *eth)
7129b70e007SSimon Glass {
71358f8fab8SLucas Stach struct asix_private *priv = (struct asix_private *)ss->dev_priv;
71458f8fab8SLucas Stach
7159b70e007SSimon Glass if (!eth) {
7169b70e007SSimon Glass debug("%s: missing parameter.\n", __func__);
7179b70e007SSimon Glass return 0;
7189b70e007SSimon Glass }
7199b70e007SSimon Glass sprintf(eth->name, "%s%d", ASIX_BASE_NAME, curr_eth_dev++);
7209b70e007SSimon Glass eth->init = asix_init;
7219b70e007SSimon Glass eth->send = asix_send;
7229b70e007SSimon Glass eth->recv = asix_recv;
7239b70e007SSimon Glass eth->halt = asix_halt;
72458f8fab8SLucas Stach if (!(priv->flags & FLAG_TYPE_AX88172))
72558f8fab8SLucas Stach eth->write_hwaddr = asix_write_hwaddr;
7269b70e007SSimon Glass eth->priv = ss;
7279b70e007SSimon Glass
7285fae53d0SLucas Stach if (asix_basic_reset(ss))
7295fae53d0SLucas Stach return 0;
7305fae53d0SLucas Stach
73102c8d8ccSLucas Stach /* Get the MAC address */
732fbc4b8afSSimon Glass if (asix_read_mac_common(ss, priv, eth->enetaddr))
73302c8d8ccSLucas Stach return 0;
73402c8d8ccSLucas Stach debug("MAC %pM\n", eth->enetaddr);
73502c8d8ccSLucas Stach
7369b70e007SSimon Glass return 1;
7379b70e007SSimon Glass }
738fbc4b8afSSimon Glass #endif
739fbc4b8afSSimon Glass
740fbc4b8afSSimon Glass #ifdef CONFIG_DM_ETH
asix_eth_start(struct udevice * dev)741fbc4b8afSSimon Glass static int asix_eth_start(struct udevice *dev)
742fbc4b8afSSimon Glass {
74314727120SMarcel Ziswiler struct eth_pdata *pdata = dev_get_platdata(dev);
744fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
745fbc4b8afSSimon Glass
74614727120SMarcel Ziswiler return asix_init_common(&priv->ueth, pdata->enetaddr);
747fbc4b8afSSimon Glass }
748fbc4b8afSSimon Glass
asix_eth_stop(struct udevice * dev)749fbc4b8afSSimon Glass void asix_eth_stop(struct udevice *dev)
750fbc4b8afSSimon Glass {
751fbc4b8afSSimon Glass debug("** %s()\n", __func__);
752fbc4b8afSSimon Glass }
753fbc4b8afSSimon Glass
asix_eth_send(struct udevice * dev,void * packet,int length)754fbc4b8afSSimon Glass int asix_eth_send(struct udevice *dev, void *packet, int length)
755fbc4b8afSSimon Glass {
756fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
757fbc4b8afSSimon Glass
758fbc4b8afSSimon Glass return asix_send_common(&priv->ueth, packet, length);
759fbc4b8afSSimon Glass }
760fbc4b8afSSimon Glass
asix_eth_recv(struct udevice * dev,int flags,uchar ** packetp)761fbc4b8afSSimon Glass int asix_eth_recv(struct udevice *dev, int flags, uchar **packetp)
762fbc4b8afSSimon Glass {
763fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
764fbc4b8afSSimon Glass struct ueth_data *ueth = &priv->ueth;
765fbc4b8afSSimon Glass uint8_t *ptr;
766fbc4b8afSSimon Glass int ret, len;
767fbc4b8afSSimon Glass u32 packet_len;
768fbc4b8afSSimon Glass
769fbc4b8afSSimon Glass len = usb_ether_get_rx_bytes(ueth, &ptr);
770fbc4b8afSSimon Glass debug("%s: first try, len=%d\n", __func__, len);
771fbc4b8afSSimon Glass if (!len) {
772fbc4b8afSSimon Glass if (!(flags & ETH_RECV_CHECK_DEVICE))
773fbc4b8afSSimon Glass return -EAGAIN;
774fbc4b8afSSimon Glass ret = usb_ether_receive(ueth, AX_RX_URB_SIZE);
775fbc4b8afSSimon Glass if (ret == -EAGAIN)
776fbc4b8afSSimon Glass return ret;
777fbc4b8afSSimon Glass
778fbc4b8afSSimon Glass len = usb_ether_get_rx_bytes(ueth, &ptr);
779fbc4b8afSSimon Glass debug("%s: second try, len=%d\n", __func__, len);
780fbc4b8afSSimon Glass }
781fbc4b8afSSimon Glass
782fbc4b8afSSimon Glass /*
783fbc4b8afSSimon Glass * 1st 4 bytes contain the length of the actual data as two
784fbc4b8afSSimon Glass * complementary 16-bit words. Extract the length of the data.
785fbc4b8afSSimon Glass */
786fbc4b8afSSimon Glass if (len < sizeof(packet_len)) {
787fbc4b8afSSimon Glass debug("Rx: incomplete packet length\n");
788fbc4b8afSSimon Glass goto err;
789fbc4b8afSSimon Glass }
790fbc4b8afSSimon Glass memcpy(&packet_len, ptr, sizeof(packet_len));
791fbc4b8afSSimon Glass le32_to_cpus(&packet_len);
792fbc4b8afSSimon Glass if (((~packet_len >> 16) & 0x7ff) != (packet_len & 0x7ff)) {
793fbc4b8afSSimon Glass debug("Rx: malformed packet length: %#x (%#x:%#x)\n",
794fbc4b8afSSimon Glass packet_len, (~packet_len >> 16) & 0x7ff,
795fbc4b8afSSimon Glass packet_len & 0x7ff);
796fbc4b8afSSimon Glass goto err;
797fbc4b8afSSimon Glass }
798fbc4b8afSSimon Glass packet_len = packet_len & 0x7ff;
799fbc4b8afSSimon Glass if (packet_len > len - sizeof(packet_len)) {
800fbc4b8afSSimon Glass debug("Rx: too large packet: %d\n", packet_len);
801fbc4b8afSSimon Glass goto err;
802fbc4b8afSSimon Glass }
803fbc4b8afSSimon Glass
804fbc4b8afSSimon Glass *packetp = ptr + sizeof(packet_len);
805fbc4b8afSSimon Glass return packet_len;
806fbc4b8afSSimon Glass
807fbc4b8afSSimon Glass err:
808fbc4b8afSSimon Glass usb_ether_advance_rxbuf(ueth, -1);
809fbc4b8afSSimon Glass return -EINVAL;
810fbc4b8afSSimon Glass }
811fbc4b8afSSimon Glass
asix_free_pkt(struct udevice * dev,uchar * packet,int packet_len)812fbc4b8afSSimon Glass static int asix_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
813fbc4b8afSSimon Glass {
814fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
815fbc4b8afSSimon Glass
816fbc4b8afSSimon Glass if (packet_len & 1)
817fbc4b8afSSimon Glass packet_len++;
818fbc4b8afSSimon Glass usb_ether_advance_rxbuf(&priv->ueth, sizeof(u32) + packet_len);
819fbc4b8afSSimon Glass
820fbc4b8afSSimon Glass return 0;
821fbc4b8afSSimon Glass }
822fbc4b8afSSimon Glass
asix_write_hwaddr(struct udevice * dev)823fbc4b8afSSimon Glass int asix_write_hwaddr(struct udevice *dev)
824fbc4b8afSSimon Glass {
825fbc4b8afSSimon Glass struct eth_pdata *pdata = dev_get_platdata(dev);
826fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
827fbc4b8afSSimon Glass
828fbc4b8afSSimon Glass if (priv->flags & FLAG_TYPE_AX88172)
829fbc4b8afSSimon Glass return -ENOSYS;
830fbc4b8afSSimon Glass
831fbc4b8afSSimon Glass return asix_write_hwaddr_common(&priv->ueth, pdata->enetaddr);
832fbc4b8afSSimon Glass }
833fbc4b8afSSimon Glass
asix_eth_probe(struct udevice * dev)834fbc4b8afSSimon Glass static int asix_eth_probe(struct udevice *dev)
835fbc4b8afSSimon Glass {
836fbc4b8afSSimon Glass struct eth_pdata *pdata = dev_get_platdata(dev);
837fbc4b8afSSimon Glass struct asix_private *priv = dev_get_priv(dev);
838fbc4b8afSSimon Glass struct ueth_data *ss = &priv->ueth;
839fbc4b8afSSimon Glass int ret;
840fbc4b8afSSimon Glass
841fbc4b8afSSimon Glass priv->flags = dev->driver_data;
842fbc4b8afSSimon Glass ret = usb_ether_register(dev, ss, AX_RX_URB_SIZE);
843fbc4b8afSSimon Glass if (ret)
844fbc4b8afSSimon Glass return ret;
845fbc4b8afSSimon Glass
846fbc4b8afSSimon Glass ret = asix_basic_reset(ss);
847fbc4b8afSSimon Glass if (ret)
848fbc4b8afSSimon Glass goto err;
849fbc4b8afSSimon Glass
850fbc4b8afSSimon Glass /* Get the MAC address */
851fbc4b8afSSimon Glass ret = asix_read_mac_common(ss, priv, pdata->enetaddr);
852fbc4b8afSSimon Glass if (ret)
853fbc4b8afSSimon Glass goto err;
854fbc4b8afSSimon Glass debug("MAC %pM\n", pdata->enetaddr);
855fbc4b8afSSimon Glass
856fbc4b8afSSimon Glass return 0;
857fbc4b8afSSimon Glass
858fbc4b8afSSimon Glass err:
859fbc4b8afSSimon Glass return usb_ether_deregister(ss);
860fbc4b8afSSimon Glass }
861fbc4b8afSSimon Glass
862fbc4b8afSSimon Glass static const struct eth_ops asix_eth_ops = {
863fbc4b8afSSimon Glass .start = asix_eth_start,
864fbc4b8afSSimon Glass .send = asix_eth_send,
865fbc4b8afSSimon Glass .recv = asix_eth_recv,
866fbc4b8afSSimon Glass .free_pkt = asix_free_pkt,
867fbc4b8afSSimon Glass .stop = asix_eth_stop,
868fbc4b8afSSimon Glass .write_hwaddr = asix_write_hwaddr,
869fbc4b8afSSimon Glass };
870fbc4b8afSSimon Glass
871fbc4b8afSSimon Glass U_BOOT_DRIVER(asix_eth) = {
872fbc4b8afSSimon Glass .name = "asix_eth",
873fbc4b8afSSimon Glass .id = UCLASS_ETH,
874fbc4b8afSSimon Glass .probe = asix_eth_probe,
875fbc4b8afSSimon Glass .ops = &asix_eth_ops,
876fbc4b8afSSimon Glass .priv_auto_alloc_size = sizeof(struct asix_private),
877fbc4b8afSSimon Glass .platdata_auto_alloc_size = sizeof(struct eth_pdata),
878fbc4b8afSSimon Glass };
879fbc4b8afSSimon Glass
880fbc4b8afSSimon Glass static const struct usb_device_id asix_eth_id_table[] = {
881fbc4b8afSSimon Glass /* Apple USB Ethernet Adapter */
882fbc4b8afSSimon Glass { USB_DEVICE(0x05ac, 0x1402), .driver_info = FLAG_TYPE_AX88772 },
883fbc4b8afSSimon Glass /* D-Link DUB-E100 H/W Ver B1 */
884fbc4b8afSSimon Glass { USB_DEVICE(0x07d1, 0x3c05), .driver_info = FLAG_TYPE_AX88772 },
885fbc4b8afSSimon Glass /* D-Link DUB-E100 H/W Ver C1 */
886fbc4b8afSSimon Glass { USB_DEVICE(0x2001, 0x1a02), .driver_info = FLAG_TYPE_AX88772 },
887fbc4b8afSSimon Glass /* Cables-to-Go USB Ethernet Adapter */
888fbc4b8afSSimon Glass { USB_DEVICE(0x0b95, 0x772a), .driver_info = FLAG_TYPE_AX88772 },
889fbc4b8afSSimon Glass /* Trendnet TU2-ET100 V3.0R */
890fbc4b8afSSimon Glass { USB_DEVICE(0x0b95, 0x7720), .driver_info = FLAG_TYPE_AX88772 },
891fbc4b8afSSimon Glass /* SMC */
892fbc4b8afSSimon Glass { USB_DEVICE(0x0b95, 0x1720), .driver_info = FLAG_TYPE_AX88172 },
893fbc4b8afSSimon Glass /* MSI - ASIX 88772a */
894fbc4b8afSSimon Glass { USB_DEVICE(0x0db0, 0xa877), .driver_info = FLAG_TYPE_AX88772 },
895fbc4b8afSSimon Glass /* Linksys 200M v2.1 */
896fbc4b8afSSimon Glass { USB_DEVICE(0x13b1, 0x0018), .driver_info = FLAG_TYPE_AX88172 },
897fbc4b8afSSimon Glass /* 0Q0 cable ethernet */
898fbc4b8afSSimon Glass { USB_DEVICE(0x1557, 0x7720), .driver_info = FLAG_TYPE_AX88772 },
899fbc4b8afSSimon Glass /* DLink DUB-E100 H/W Ver B1 Alternate */
900fbc4b8afSSimon Glass { USB_DEVICE(0x2001, 0x3c05), .driver_info = FLAG_TYPE_AX88772 },
901fbc4b8afSSimon Glass /* ASIX 88772B */
902fbc4b8afSSimon Glass { USB_DEVICE(0x0b95, 0x772b),
903fbc4b8afSSimon Glass .driver_info = FLAG_TYPE_AX88772B | FLAG_EEPROM_MAC },
904fbc4b8afSSimon Glass { USB_DEVICE(0x0b95, 0x7e2b), .driver_info = FLAG_TYPE_AX88772B },
905fbc4b8afSSimon Glass { } /* Terminating entry */
906fbc4b8afSSimon Glass };
907fbc4b8afSSimon Glass
908fbc4b8afSSimon Glass U_BOOT_USB_DEVICE(asix_eth, asix_eth_id_table);
909fbc4b8afSSimon Glass #endif
910