xref: /freebsd/sys/arm/allwinner/if_awg.c (revision 1403e695b732cb6a1814b4780e7093bcdd674e8e)
1d3810ff9SJared McNeill /*-
2d3810ff9SJared McNeill  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
3d3810ff9SJared McNeill  * All rights reserved.
4d3810ff9SJared McNeill  *
5d3810ff9SJared McNeill  * Redistribution and use in source and binary forms, with or without
6d3810ff9SJared McNeill  * modification, are permitted provided that the following conditions
7d3810ff9SJared McNeill  * are met:
8d3810ff9SJared McNeill  * 1. Redistributions of source code must retain the above copyright
9d3810ff9SJared McNeill  *    notice, this list of conditions and the following disclaimer.
10d3810ff9SJared McNeill  * 2. Redistributions in binary form must reproduce the above copyright
11d3810ff9SJared McNeill  *    notice, this list of conditions and the following disclaimer in the
12d3810ff9SJared McNeill  *    documentation and/or other materials provided with the distribution.
13d3810ff9SJared McNeill  *
14d3810ff9SJared McNeill  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15d3810ff9SJared McNeill  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16d3810ff9SJared McNeill  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17d3810ff9SJared McNeill  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18d3810ff9SJared McNeill  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
19d3810ff9SJared McNeill  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20d3810ff9SJared McNeill  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
21d3810ff9SJared McNeill  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22d3810ff9SJared McNeill  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23d3810ff9SJared McNeill  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24d3810ff9SJared McNeill  * SUCH DAMAGE.
25d3810ff9SJared McNeill  *
26d3810ff9SJared McNeill  * $FreeBSD$
27d3810ff9SJared McNeill  */
28d3810ff9SJared McNeill 
29d3810ff9SJared McNeill /*
30d3810ff9SJared McNeill  * Allwinner Gigabit Ethernet MAC (EMAC) controller
31d3810ff9SJared McNeill  */
32d3810ff9SJared McNeill 
3316928528SJared McNeill #include "opt_device_polling.h"
3416928528SJared McNeill 
35d3810ff9SJared McNeill #include <sys/cdefs.h>
36d3810ff9SJared McNeill __FBSDID("$FreeBSD$");
37d3810ff9SJared McNeill 
38d3810ff9SJared McNeill #include <sys/param.h>
39d3810ff9SJared McNeill #include <sys/systm.h>
40d3810ff9SJared McNeill #include <sys/bus.h>
41d3810ff9SJared McNeill #include <sys/rman.h>
42d3810ff9SJared McNeill #include <sys/kernel.h>
43d3810ff9SJared McNeill #include <sys/endian.h>
44d3810ff9SJared McNeill #include <sys/mbuf.h>
45d3810ff9SJared McNeill #include <sys/socket.h>
46d3810ff9SJared McNeill #include <sys/sockio.h>
47d3810ff9SJared McNeill #include <sys/module.h>
48d3810ff9SJared McNeill #include <sys/taskqueue.h>
4901a469b8SJared McNeill #include <sys/gpio.h>
50d3810ff9SJared McNeill 
51d3810ff9SJared McNeill #include <net/bpf.h>
52d3810ff9SJared McNeill #include <net/if.h>
53d3810ff9SJared McNeill #include <net/ethernet.h>
54d3810ff9SJared McNeill #include <net/if_dl.h>
55d3810ff9SJared McNeill #include <net/if_media.h>
56d3810ff9SJared McNeill #include <net/if_types.h>
57d3810ff9SJared McNeill #include <net/if_var.h>
58d3810ff9SJared McNeill 
59d3810ff9SJared McNeill #include <machine/bus.h>
60d3810ff9SJared McNeill 
61d3810ff9SJared McNeill #include <dev/ofw/ofw_bus.h>
62d3810ff9SJared McNeill #include <dev/ofw/ofw_bus_subr.h>
63d3810ff9SJared McNeill 
64d3810ff9SJared McNeill #include <arm/allwinner/if_awgreg.h>
65*1403e695SJared McNeill #include <arm/allwinner/aw_sid.h>
66d3810ff9SJared McNeill #include <dev/mii/mii.h>
67d3810ff9SJared McNeill #include <dev/mii/miivar.h>
68d3810ff9SJared McNeill 
69d3810ff9SJared McNeill #include <dev/extres/clk/clk.h>
70d3810ff9SJared McNeill #include <dev/extres/hwreset/hwreset.h>
71d3810ff9SJared McNeill #include <dev/extres/regulator/regulator.h>
72d3810ff9SJared McNeill 
73d3810ff9SJared McNeill #include "miibus_if.h"
7401a469b8SJared McNeill #include "gpio_if.h"
75d3810ff9SJared McNeill 
7601a469b8SJared McNeill #define	RD4(sc, reg)		bus_read_4((sc)->res[_RES_EMAC], (reg))
7701a469b8SJared McNeill #define	WR4(sc, reg, val)	bus_write_4((sc)->res[_RES_EMAC], (reg), (val))
78d3810ff9SJared McNeill 
79d3810ff9SJared McNeill #define	AWG_LOCK(sc)		mtx_lock(&(sc)->mtx)
80d3810ff9SJared McNeill #define	AWG_UNLOCK(sc)		mtx_unlock(&(sc)->mtx);
81d3810ff9SJared McNeill #define	AWG_ASSERT_LOCKED(sc)	mtx_assert(&(sc)->mtx, MA_OWNED)
82d3810ff9SJared McNeill #define	AWG_ASSERT_UNLOCKED(sc)	mtx_assert(&(sc)->mtx, MA_NOTOWNED)
83d3810ff9SJared McNeill 
84d3810ff9SJared McNeill #define	DESC_ALIGN		4
8516928528SJared McNeill #define	TX_DESC_COUNT		1024
86d3810ff9SJared McNeill #define	TX_DESC_SIZE		(sizeof(struct emac_desc) * TX_DESC_COUNT)
87d3810ff9SJared McNeill #define	RX_DESC_COUNT		256
88d3810ff9SJared McNeill #define	RX_DESC_SIZE		(sizeof(struct emac_desc) * RX_DESC_COUNT)
89d3810ff9SJared McNeill 
90d3810ff9SJared McNeill #define	DESC_OFF(n)		((n) * sizeof(struct emac_desc))
91d3810ff9SJared McNeill #define	TX_NEXT(n)		(((n) + 1) & (TX_DESC_COUNT - 1))
92d3810ff9SJared McNeill #define	TX_SKIP(n, o)		(((n) + (o)) & (TX_DESC_COUNT - 1))
93d3810ff9SJared McNeill #define	RX_NEXT(n)		(((n) + 1) & (RX_DESC_COUNT - 1))
94d3810ff9SJared McNeill 
95d3810ff9SJared McNeill #define	TX_MAX_SEGS		10
96d3810ff9SJared McNeill 
97d3810ff9SJared McNeill #define	SOFT_RST_RETRY		1000
98d3810ff9SJared McNeill #define	MII_BUSY_RETRY		1000
99d3810ff9SJared McNeill #define	MDIO_FREQ		2500000
100d3810ff9SJared McNeill 
101d3810ff9SJared McNeill #define	BURST_LEN_DEFAULT	8
102d3810ff9SJared McNeill #define	RX_TX_PRI_DEFAULT	0
103d3810ff9SJared McNeill #define	PAUSE_TIME_DEFAULT	0x400
104d3810ff9SJared McNeill #define	TX_INTERVAL_DEFAULT	64
10516928528SJared McNeill #define	RX_BATCH_DEFAULT	64
106d3810ff9SJared McNeill 
10701a469b8SJared McNeill /* syscon EMAC clock register */
10801a469b8SJared McNeill #define	EMAC_CLK_EPHY_ADDR	(0x1f << 20)	/* H3 */
10901a469b8SJared McNeill #define	EMAC_CLK_EPHY_ADDR_SHIFT 20
11001a469b8SJared McNeill #define	EMAC_CLK_EPHY_LED_POL	(1 << 17)	/* H3 */
11101a469b8SJared McNeill #define	EMAC_CLK_EPHY_SHUTDOWN	(1 << 16)	/* H3 */
11201a469b8SJared McNeill #define	EMAC_CLK_EPHY_SELECT	(1 << 15)	/* H3 */
11301a469b8SJared McNeill #define	EMAC_CLK_RMII_EN	(1 << 13)
11401a469b8SJared McNeill #define	EMAC_CLK_ETXDC		(0x7 << 10)
11501a469b8SJared McNeill #define	EMAC_CLK_ETXDC_SHIFT	10
11601a469b8SJared McNeill #define	EMAC_CLK_ERXDC		(0x1f << 5)
11701a469b8SJared McNeill #define	EMAC_CLK_ERXDC_SHIFT	5
11801a469b8SJared McNeill #define	EMAC_CLK_PIT		(0x1 << 2)
11901a469b8SJared McNeill #define	 EMAC_CLK_PIT_MII	(0 << 2)
12001a469b8SJared McNeill #define	 EMAC_CLK_PIT_RGMII	(1 << 2)
12101a469b8SJared McNeill #define	EMAC_CLK_SRC		(0x3 << 0)
12201a469b8SJared McNeill #define	 EMAC_CLK_SRC_MII	(0 << 0)
12301a469b8SJared McNeill #define	 EMAC_CLK_SRC_EXT_RGMII	(1 << 0)
12401a469b8SJared McNeill #define	 EMAC_CLK_SRC_RGMII	(2 << 0)
12501a469b8SJared McNeill 
126d3810ff9SJared McNeill /* Burst length of RX and TX DMA transfers */
127d3810ff9SJared McNeill static int awg_burst_len = BURST_LEN_DEFAULT;
128d3810ff9SJared McNeill TUNABLE_INT("hw.awg.burst_len", &awg_burst_len);
129d3810ff9SJared McNeill 
130d3810ff9SJared McNeill /* RX / TX DMA priority. If 1, RX DMA has priority over TX DMA. */
131d3810ff9SJared McNeill static int awg_rx_tx_pri = RX_TX_PRI_DEFAULT;
132d3810ff9SJared McNeill TUNABLE_INT("hw.awg.rx_tx_pri", &awg_rx_tx_pri);
133d3810ff9SJared McNeill 
134d3810ff9SJared McNeill /* Pause time field in the transmitted control frame */
135d3810ff9SJared McNeill static int awg_pause_time = PAUSE_TIME_DEFAULT;
136d3810ff9SJared McNeill TUNABLE_INT("hw.awg.pause_time", &awg_pause_time);
137d3810ff9SJared McNeill 
138d3810ff9SJared McNeill /* Request a TX interrupt every <n> descriptors */
139d3810ff9SJared McNeill static int awg_tx_interval = TX_INTERVAL_DEFAULT;
140d3810ff9SJared McNeill TUNABLE_INT("hw.awg.tx_interval", &awg_tx_interval);
141d3810ff9SJared McNeill 
14216928528SJared McNeill /* Maximum number of mbufs to send to if_input */
14316928528SJared McNeill static int awg_rx_batch = RX_BATCH_DEFAULT;
14416928528SJared McNeill TUNABLE_INT("hw.awg.rx_batch", &awg_rx_batch);
14516928528SJared McNeill 
14601a469b8SJared McNeill enum awg_type {
14701a469b8SJared McNeill 	EMAC_A83T = 1,
14801a469b8SJared McNeill 	EMAC_H3,
14901a469b8SJared McNeill };
15001a469b8SJared McNeill 
151d3810ff9SJared McNeill static struct ofw_compat_data compat_data[] = {
15201a469b8SJared McNeill 	{ "allwinner,sun8i-a83t-emac",		EMAC_A83T },
15301a469b8SJared McNeill 	{ "allwinner,sun8i-h3-emac",		EMAC_H3 },
154d3810ff9SJared McNeill 	{ NULL,					0 }
155d3810ff9SJared McNeill };
156d3810ff9SJared McNeill 
157d3810ff9SJared McNeill struct awg_bufmap {
158d3810ff9SJared McNeill 	bus_dmamap_t		map;
159d3810ff9SJared McNeill 	struct mbuf		*mbuf;
160d3810ff9SJared McNeill };
161d3810ff9SJared McNeill 
162d3810ff9SJared McNeill struct awg_txring {
163d3810ff9SJared McNeill 	bus_dma_tag_t		desc_tag;
164d3810ff9SJared McNeill 	bus_dmamap_t		desc_map;
165d3810ff9SJared McNeill 	struct emac_desc	*desc_ring;
166d3810ff9SJared McNeill 	bus_addr_t		desc_ring_paddr;
167d3810ff9SJared McNeill 	bus_dma_tag_t		buf_tag;
168d3810ff9SJared McNeill 	struct awg_bufmap	buf_map[TX_DESC_COUNT];
169d3810ff9SJared McNeill 	u_int			cur, next, queued;
170d3810ff9SJared McNeill };
171d3810ff9SJared McNeill 
172d3810ff9SJared McNeill struct awg_rxring {
173d3810ff9SJared McNeill 	bus_dma_tag_t		desc_tag;
174d3810ff9SJared McNeill 	bus_dmamap_t		desc_map;
175d3810ff9SJared McNeill 	struct emac_desc	*desc_ring;
176d3810ff9SJared McNeill 	bus_addr_t		desc_ring_paddr;
177d3810ff9SJared McNeill 	bus_dma_tag_t		buf_tag;
178d3810ff9SJared McNeill 	struct awg_bufmap	buf_map[RX_DESC_COUNT];
179d3810ff9SJared McNeill 	u_int			cur;
180d3810ff9SJared McNeill };
181d3810ff9SJared McNeill 
18201a469b8SJared McNeill enum {
18301a469b8SJared McNeill 	_RES_EMAC,
18401a469b8SJared McNeill 	_RES_IRQ,
18501a469b8SJared McNeill 	_RES_SYSCON,
18601a469b8SJared McNeill 	_RES_NITEMS
18701a469b8SJared McNeill };
18801a469b8SJared McNeill 
189d3810ff9SJared McNeill struct awg_softc {
19001a469b8SJared McNeill 	struct resource		*res[_RES_NITEMS];
191d3810ff9SJared McNeill 	struct mtx		mtx;
192d3810ff9SJared McNeill 	if_t			ifp;
193d3810ff9SJared McNeill 	device_t		miibus;
194d3810ff9SJared McNeill 	struct callout		stat_ch;
195d3810ff9SJared McNeill 	struct task		link_task;
196d3810ff9SJared McNeill 	void			*ih;
197d3810ff9SJared McNeill 	u_int			mdc_div_ratio_m;
198d3810ff9SJared McNeill 	int			link;
199d3810ff9SJared McNeill 	int			if_flags;
20001a469b8SJared McNeill 	enum awg_type		type;
201d3810ff9SJared McNeill 
202d3810ff9SJared McNeill 	struct awg_txring	tx;
203d3810ff9SJared McNeill 	struct awg_rxring	rx;
204d3810ff9SJared McNeill };
205d3810ff9SJared McNeill 
206d3810ff9SJared McNeill static struct resource_spec awg_spec[] = {
207d3810ff9SJared McNeill 	{ SYS_RES_MEMORY,	0,	RF_ACTIVE },
208d3810ff9SJared McNeill 	{ SYS_RES_IRQ,		0,	RF_ACTIVE },
20901a469b8SJared McNeill 	{ SYS_RES_MEMORY,	1,	RF_ACTIVE | RF_OPTIONAL },
210d3810ff9SJared McNeill 	{ -1, 0 }
211d3810ff9SJared McNeill };
212d3810ff9SJared McNeill 
213d3810ff9SJared McNeill static int
214d3810ff9SJared McNeill awg_miibus_readreg(device_t dev, int phy, int reg)
215d3810ff9SJared McNeill {
216d3810ff9SJared McNeill 	struct awg_softc *sc;
217d3810ff9SJared McNeill 	int retry, val;
218d3810ff9SJared McNeill 
219d3810ff9SJared McNeill 	sc = device_get_softc(dev);
220d3810ff9SJared McNeill 	val = 0;
221d3810ff9SJared McNeill 
222d3810ff9SJared McNeill 	WR4(sc, EMAC_MII_CMD,
223d3810ff9SJared McNeill 	    (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) |
224d3810ff9SJared McNeill 	    (phy << PHY_ADDR_SHIFT) |
225d3810ff9SJared McNeill 	    (reg << PHY_REG_ADDR_SHIFT) |
226d3810ff9SJared McNeill 	    MII_BUSY);
227d3810ff9SJared McNeill 	for (retry = MII_BUSY_RETRY; retry > 0; retry--) {
228d3810ff9SJared McNeill 		if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0) {
229d3810ff9SJared McNeill 			val = RD4(sc, EMAC_MII_DATA);
230d3810ff9SJared McNeill 			break;
231d3810ff9SJared McNeill 		}
232d3810ff9SJared McNeill 		DELAY(10);
233d3810ff9SJared McNeill 	}
234d3810ff9SJared McNeill 
235d3810ff9SJared McNeill 	if (retry == 0)
236d3810ff9SJared McNeill 		device_printf(dev, "phy read timeout, phy=%d reg=%d\n",
237d3810ff9SJared McNeill 		    phy, reg);
238d3810ff9SJared McNeill 
239d3810ff9SJared McNeill 	return (val);
240d3810ff9SJared McNeill }
241d3810ff9SJared McNeill 
242d3810ff9SJared McNeill static int
243d3810ff9SJared McNeill awg_miibus_writereg(device_t dev, int phy, int reg, int val)
244d3810ff9SJared McNeill {
245d3810ff9SJared McNeill 	struct awg_softc *sc;
246d3810ff9SJared McNeill 	int retry;
247d3810ff9SJared McNeill 
248d3810ff9SJared McNeill 	sc = device_get_softc(dev);
249d3810ff9SJared McNeill 
250d3810ff9SJared McNeill 	WR4(sc, EMAC_MII_DATA, val);
251d3810ff9SJared McNeill 	WR4(sc, EMAC_MII_CMD,
252d3810ff9SJared McNeill 	    (sc->mdc_div_ratio_m << MDC_DIV_RATIO_M_SHIFT) |
253d3810ff9SJared McNeill 	    (phy << PHY_ADDR_SHIFT) |
254d3810ff9SJared McNeill 	    (reg << PHY_REG_ADDR_SHIFT) |
255d3810ff9SJared McNeill 	    MII_WR | MII_BUSY);
256d3810ff9SJared McNeill 	for (retry = MII_BUSY_RETRY; retry > 0; retry--) {
257d3810ff9SJared McNeill 		if ((RD4(sc, EMAC_MII_CMD) & MII_BUSY) == 0)
258d3810ff9SJared McNeill 			break;
259d3810ff9SJared McNeill 		DELAY(10);
260d3810ff9SJared McNeill 	}
261d3810ff9SJared McNeill 
262d3810ff9SJared McNeill 	if (retry == 0)
263d3810ff9SJared McNeill 		device_printf(dev, "phy write timeout, phy=%d reg=%d\n",
264d3810ff9SJared McNeill 		    phy, reg);
265d3810ff9SJared McNeill 
266d3810ff9SJared McNeill 	return (0);
267d3810ff9SJared McNeill }
268d3810ff9SJared McNeill 
269d3810ff9SJared McNeill static void
270d3810ff9SJared McNeill awg_update_link_locked(struct awg_softc *sc)
271d3810ff9SJared McNeill {
272d3810ff9SJared McNeill 	struct mii_data *mii;
273d3810ff9SJared McNeill 	uint32_t val;
274d3810ff9SJared McNeill 
275d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
276d3810ff9SJared McNeill 
277d3810ff9SJared McNeill 	if ((if_getdrvflags(sc->ifp) & IFF_DRV_RUNNING) == 0)
278d3810ff9SJared McNeill 		return;
279d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
280d3810ff9SJared McNeill 
281d3810ff9SJared McNeill 	if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
282d3810ff9SJared McNeill 	    (IFM_ACTIVE | IFM_AVALID)) {
283d3810ff9SJared McNeill 		switch (IFM_SUBTYPE(mii->mii_media_active)) {
284d3810ff9SJared McNeill 		case IFM_1000_T:
285d3810ff9SJared McNeill 		case IFM_1000_SX:
286d3810ff9SJared McNeill 		case IFM_100_TX:
287d3810ff9SJared McNeill 		case IFM_10_T:
288d3810ff9SJared McNeill 			sc->link = 1;
289d3810ff9SJared McNeill 			break;
290d3810ff9SJared McNeill 		default:
291d3810ff9SJared McNeill 			sc->link = 0;
292d3810ff9SJared McNeill 			break;
293d3810ff9SJared McNeill 		}
294d3810ff9SJared McNeill 	} else
295d3810ff9SJared McNeill 		sc->link = 0;
296d3810ff9SJared McNeill 
297d3810ff9SJared McNeill 	if (sc->link == 0)
298d3810ff9SJared McNeill 		return;
299d3810ff9SJared McNeill 
300d3810ff9SJared McNeill 	val = RD4(sc, EMAC_BASIC_CTL_0);
301d3810ff9SJared McNeill 	val &= ~(BASIC_CTL_SPEED | BASIC_CTL_DUPLEX);
302d3810ff9SJared McNeill 
303d3810ff9SJared McNeill 	if (IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_T ||
304d3810ff9SJared McNeill 	    IFM_SUBTYPE(mii->mii_media_active) == IFM_1000_SX)
305d3810ff9SJared McNeill 		val |= BASIC_CTL_SPEED_1000 << BASIC_CTL_SPEED_SHIFT;
306d3810ff9SJared McNeill 	else if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX)
307d3810ff9SJared McNeill 		val |= BASIC_CTL_SPEED_100 << BASIC_CTL_SPEED_SHIFT;
308d3810ff9SJared McNeill 	else
309d3810ff9SJared McNeill 		val |= BASIC_CTL_SPEED_10 << BASIC_CTL_SPEED_SHIFT;
310d3810ff9SJared McNeill 
311d3810ff9SJared McNeill 	if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
312d3810ff9SJared McNeill 		val |= BASIC_CTL_DUPLEX;
313d3810ff9SJared McNeill 
314d3810ff9SJared McNeill 	WR4(sc, EMAC_BASIC_CTL_0, val);
315d3810ff9SJared McNeill 
316d3810ff9SJared McNeill 	val = RD4(sc, EMAC_RX_CTL_0);
317d3810ff9SJared McNeill 	val &= ~RX_FLOW_CTL_EN;
318d3810ff9SJared McNeill 	if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_RXPAUSE) != 0)
319d3810ff9SJared McNeill 		val |= RX_FLOW_CTL_EN;
320d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_CTL_0, val);
321d3810ff9SJared McNeill 
322d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_FLOW_CTL);
323d3810ff9SJared McNeill 	val &= ~(PAUSE_TIME|TX_FLOW_CTL_EN);
324d3810ff9SJared McNeill 	if ((IFM_OPTIONS(mii->mii_media_active) & IFM_ETH_TXPAUSE) != 0)
325d3810ff9SJared McNeill 		val |= TX_FLOW_CTL_EN;
326d3810ff9SJared McNeill 	if ((IFM_OPTIONS(mii->mii_media_active) & IFM_FDX) != 0)
327d3810ff9SJared McNeill 		val |= awg_pause_time << PAUSE_TIME_SHIFT;
328d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_FLOW_CTL, val);
329d3810ff9SJared McNeill }
330d3810ff9SJared McNeill 
331d3810ff9SJared McNeill static void
332d3810ff9SJared McNeill awg_link_task(void *arg, int pending)
333d3810ff9SJared McNeill {
334d3810ff9SJared McNeill 	struct awg_softc *sc;
335d3810ff9SJared McNeill 
336d3810ff9SJared McNeill 	sc = arg;
337d3810ff9SJared McNeill 
338d3810ff9SJared McNeill 	AWG_LOCK(sc);
339d3810ff9SJared McNeill 	awg_update_link_locked(sc);
340d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
341d3810ff9SJared McNeill }
342d3810ff9SJared McNeill 
343d3810ff9SJared McNeill static void
344d3810ff9SJared McNeill awg_miibus_statchg(device_t dev)
345d3810ff9SJared McNeill {
346d3810ff9SJared McNeill 	struct awg_softc *sc;
347d3810ff9SJared McNeill 
348d3810ff9SJared McNeill 	sc = device_get_softc(dev);
349d3810ff9SJared McNeill 
350d3810ff9SJared McNeill 	taskqueue_enqueue(taskqueue_swi, &sc->link_task);
351d3810ff9SJared McNeill }
352d3810ff9SJared McNeill 
353d3810ff9SJared McNeill static void
354d3810ff9SJared McNeill awg_media_status(if_t ifp, struct ifmediareq *ifmr)
355d3810ff9SJared McNeill {
356d3810ff9SJared McNeill 	struct awg_softc *sc;
357d3810ff9SJared McNeill 	struct mii_data *mii;
358d3810ff9SJared McNeill 
359d3810ff9SJared McNeill 	sc = if_getsoftc(ifp);
360d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
361d3810ff9SJared McNeill 
362d3810ff9SJared McNeill 	AWG_LOCK(sc);
363d3810ff9SJared McNeill 	mii_pollstat(mii);
364d3810ff9SJared McNeill 	ifmr->ifm_active = mii->mii_media_active;
365d3810ff9SJared McNeill 	ifmr->ifm_status = mii->mii_media_status;
366d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
367d3810ff9SJared McNeill }
368d3810ff9SJared McNeill 
369d3810ff9SJared McNeill static int
370d3810ff9SJared McNeill awg_media_change(if_t ifp)
371d3810ff9SJared McNeill {
372d3810ff9SJared McNeill 	struct awg_softc *sc;
373d3810ff9SJared McNeill 	struct mii_data *mii;
374d3810ff9SJared McNeill 	int error;
375d3810ff9SJared McNeill 
376d3810ff9SJared McNeill 	sc = if_getsoftc(ifp);
377d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
378d3810ff9SJared McNeill 
379d3810ff9SJared McNeill 	AWG_LOCK(sc);
380d3810ff9SJared McNeill 	error = mii_mediachg(mii);
381d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
382d3810ff9SJared McNeill 
383d3810ff9SJared McNeill 	return (error);
384d3810ff9SJared McNeill }
385d3810ff9SJared McNeill 
386d3810ff9SJared McNeill static void
387d3810ff9SJared McNeill awg_setup_txdesc(struct awg_softc *sc, int index, int flags, bus_addr_t paddr,
388d3810ff9SJared McNeill     u_int len)
389d3810ff9SJared McNeill {
390d3810ff9SJared McNeill 	uint32_t status, size;
391d3810ff9SJared McNeill 
392d3810ff9SJared McNeill 	if (paddr == 0 || len == 0) {
393d3810ff9SJared McNeill 		status = 0;
394d3810ff9SJared McNeill 		size = 0;
395d3810ff9SJared McNeill 		--sc->tx.queued;
396d3810ff9SJared McNeill 	} else {
397d3810ff9SJared McNeill 		status = TX_DESC_CTL;
398d3810ff9SJared McNeill 		size = flags | len;
399d3810ff9SJared McNeill 		if ((index & (awg_tx_interval - 1)) == 0)
40016928528SJared McNeill 			size |= TX_INT_CTL;
401d3810ff9SJared McNeill 		++sc->tx.queued;
402d3810ff9SJared McNeill 	}
403d3810ff9SJared McNeill 
404d3810ff9SJared McNeill 	sc->tx.desc_ring[index].addr = htole32((uint32_t)paddr);
405d3810ff9SJared McNeill 	sc->tx.desc_ring[index].size = htole32(size);
406d3810ff9SJared McNeill 	sc->tx.desc_ring[index].status = htole32(status);
407d3810ff9SJared McNeill }
408d3810ff9SJared McNeill 
409d3810ff9SJared McNeill static int
410d3810ff9SJared McNeill awg_setup_txbuf(struct awg_softc *sc, int index, struct mbuf **mp)
411d3810ff9SJared McNeill {
412d3810ff9SJared McNeill 	bus_dma_segment_t segs[TX_MAX_SEGS];
413d3810ff9SJared McNeill 	int error, nsegs, cur, i, flags;
414d3810ff9SJared McNeill 	u_int csum_flags;
415d3810ff9SJared McNeill 	struct mbuf *m;
416d3810ff9SJared McNeill 
417d3810ff9SJared McNeill 	m = *mp;
418d3810ff9SJared McNeill 	error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag,
419d3810ff9SJared McNeill 	    sc->tx.buf_map[index].map, m, segs, &nsegs, BUS_DMA_NOWAIT);
420d3810ff9SJared McNeill 	if (error == EFBIG) {
421d3810ff9SJared McNeill 		m = m_collapse(m, M_NOWAIT, TX_MAX_SEGS);
422d3810ff9SJared McNeill 		if (m == NULL)
423d3810ff9SJared McNeill 			return (0);
424d3810ff9SJared McNeill 		*mp = m;
425d3810ff9SJared McNeill 		error = bus_dmamap_load_mbuf_sg(sc->tx.buf_tag,
426d3810ff9SJared McNeill 		    sc->tx.buf_map[index].map, m, segs, &nsegs, BUS_DMA_NOWAIT);
427d3810ff9SJared McNeill 	}
428d3810ff9SJared McNeill 	if (error != 0)
429d3810ff9SJared McNeill 		return (0);
430d3810ff9SJared McNeill 
431d3810ff9SJared McNeill 	bus_dmamap_sync(sc->tx.buf_tag, sc->tx.buf_map[index].map,
432d3810ff9SJared McNeill 	    BUS_DMASYNC_PREWRITE);
433d3810ff9SJared McNeill 
434d3810ff9SJared McNeill 	flags = TX_FIR_DESC;
435d3810ff9SJared McNeill 	if ((m->m_pkthdr.csum_flags & CSUM_IP) != 0) {
436d3810ff9SJared McNeill 		if ((m->m_pkthdr.csum_flags & (CSUM_TCP|CSUM_UDP)) != 0)
437d3810ff9SJared McNeill 			csum_flags = TX_CHECKSUM_CTL_FULL;
438d3810ff9SJared McNeill 		else
439d3810ff9SJared McNeill 			csum_flags = TX_CHECKSUM_CTL_IP;
440d3810ff9SJared McNeill 		flags |= (csum_flags << TX_CHECKSUM_CTL_SHIFT);
441d3810ff9SJared McNeill 	}
442d3810ff9SJared McNeill 
443d3810ff9SJared McNeill 	for (cur = index, i = 0; i < nsegs; i++) {
444d3810ff9SJared McNeill 		sc->tx.buf_map[cur].mbuf = (i == 0 ? m : NULL);
445d3810ff9SJared McNeill 		if (i == nsegs - 1)
446d3810ff9SJared McNeill 			flags |= TX_LAST_DESC;
447d3810ff9SJared McNeill 		awg_setup_txdesc(sc, cur, flags, segs[i].ds_addr,
448d3810ff9SJared McNeill 		    segs[i].ds_len);
449d3810ff9SJared McNeill 		flags &= ~TX_FIR_DESC;
450d3810ff9SJared McNeill 		cur = TX_NEXT(cur);
451d3810ff9SJared McNeill 	}
452d3810ff9SJared McNeill 
453d3810ff9SJared McNeill 	return (nsegs);
454d3810ff9SJared McNeill }
455d3810ff9SJared McNeill 
456d3810ff9SJared McNeill static void
457d3810ff9SJared McNeill awg_setup_rxdesc(struct awg_softc *sc, int index, bus_addr_t paddr)
458d3810ff9SJared McNeill {
459d3810ff9SJared McNeill 	uint32_t status, size;
460d3810ff9SJared McNeill 
461d3810ff9SJared McNeill 	status = RX_DESC_CTL;
462d3810ff9SJared McNeill 	size = MCLBYTES - 1;
463d3810ff9SJared McNeill 
464d3810ff9SJared McNeill 	sc->rx.desc_ring[index].addr = htole32((uint32_t)paddr);
465d3810ff9SJared McNeill 	sc->rx.desc_ring[index].size = htole32(size);
466d3810ff9SJared McNeill 	sc->rx.desc_ring[index].next =
467d3810ff9SJared McNeill 	    htole32(sc->rx.desc_ring_paddr + DESC_OFF(RX_NEXT(index)));
468d3810ff9SJared McNeill 	sc->rx.desc_ring[index].status = htole32(status);
469d3810ff9SJared McNeill }
470d3810ff9SJared McNeill 
471d3810ff9SJared McNeill static int
472d3810ff9SJared McNeill awg_setup_rxbuf(struct awg_softc *sc, int index, struct mbuf *m)
473d3810ff9SJared McNeill {
474d3810ff9SJared McNeill 	bus_dma_segment_t seg;
475d3810ff9SJared McNeill 	int error, nsegs;
476d3810ff9SJared McNeill 
477d3810ff9SJared McNeill 	m_adj(m, ETHER_ALIGN);
478d3810ff9SJared McNeill 
479d3810ff9SJared McNeill 	error = bus_dmamap_load_mbuf_sg(sc->rx.buf_tag,
480d3810ff9SJared McNeill 	    sc->rx.buf_map[index].map, m, &seg, &nsegs, 0);
481d3810ff9SJared McNeill 	if (error != 0)
482d3810ff9SJared McNeill 		return (error);
483d3810ff9SJared McNeill 
484d3810ff9SJared McNeill 	bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map,
485d3810ff9SJared McNeill 	    BUS_DMASYNC_PREREAD);
486d3810ff9SJared McNeill 
487d3810ff9SJared McNeill 	sc->rx.buf_map[index].mbuf = m;
488d3810ff9SJared McNeill 	awg_setup_rxdesc(sc, index, seg.ds_addr);
489d3810ff9SJared McNeill 
490d3810ff9SJared McNeill 	return (0);
491d3810ff9SJared McNeill }
492d3810ff9SJared McNeill 
493d3810ff9SJared McNeill static struct mbuf *
494d3810ff9SJared McNeill awg_alloc_mbufcl(struct awg_softc *sc)
495d3810ff9SJared McNeill {
496d3810ff9SJared McNeill 	struct mbuf *m;
497d3810ff9SJared McNeill 
498d3810ff9SJared McNeill 	m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
499d3810ff9SJared McNeill 	if (m != NULL)
500d3810ff9SJared McNeill 		m->m_pkthdr.len = m->m_len = m->m_ext.ext_size;
501d3810ff9SJared McNeill 
502d3810ff9SJared McNeill 	return (m);
503d3810ff9SJared McNeill }
504d3810ff9SJared McNeill 
505d3810ff9SJared McNeill static void
506d3810ff9SJared McNeill awg_start_locked(struct awg_softc *sc)
507d3810ff9SJared McNeill {
508d3810ff9SJared McNeill 	struct mbuf *m;
509d3810ff9SJared McNeill 	uint32_t val;
510d3810ff9SJared McNeill 	if_t ifp;
511d3810ff9SJared McNeill 	int cnt, nsegs;
512d3810ff9SJared McNeill 
513d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
514d3810ff9SJared McNeill 
515d3810ff9SJared McNeill 	if (!sc->link)
516d3810ff9SJared McNeill 		return;
517d3810ff9SJared McNeill 
518d3810ff9SJared McNeill 	ifp = sc->ifp;
519d3810ff9SJared McNeill 
520d3810ff9SJared McNeill 	if ((if_getdrvflags(ifp) & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) !=
521d3810ff9SJared McNeill 	    IFF_DRV_RUNNING)
522d3810ff9SJared McNeill 		return;
523d3810ff9SJared McNeill 
524d3810ff9SJared McNeill 	for (cnt = 0; ; cnt++) {
525d3810ff9SJared McNeill 		if (sc->tx.queued >= TX_DESC_COUNT - TX_MAX_SEGS) {
526d3810ff9SJared McNeill 			if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);
527d3810ff9SJared McNeill 			break;
528d3810ff9SJared McNeill 		}
529d3810ff9SJared McNeill 
530d3810ff9SJared McNeill 		m = if_dequeue(ifp);
531d3810ff9SJared McNeill 		if (m == NULL)
532d3810ff9SJared McNeill 			break;
533d3810ff9SJared McNeill 
534d3810ff9SJared McNeill 		nsegs = awg_setup_txbuf(sc, sc->tx.cur, &m);
535d3810ff9SJared McNeill 		if (nsegs == 0) {
536d3810ff9SJared McNeill 			if_sendq_prepend(ifp, m);
537d3810ff9SJared McNeill 			break;
538d3810ff9SJared McNeill 		}
539d3810ff9SJared McNeill 		if_bpfmtap(ifp, m);
540d3810ff9SJared McNeill 		sc->tx.cur = TX_SKIP(sc->tx.cur, nsegs);
541d3810ff9SJared McNeill 	}
542d3810ff9SJared McNeill 
543d3810ff9SJared McNeill 	if (cnt != 0) {
544d3810ff9SJared McNeill 		bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
545d3810ff9SJared McNeill 		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
546d3810ff9SJared McNeill 
547d3810ff9SJared McNeill 		/* Start and run TX DMA */
548d3810ff9SJared McNeill 		val = RD4(sc, EMAC_TX_CTL_1);
549d3810ff9SJared McNeill 		WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_START);
550d3810ff9SJared McNeill 	}
551d3810ff9SJared McNeill }
552d3810ff9SJared McNeill 
553d3810ff9SJared McNeill static void
554d3810ff9SJared McNeill awg_start(if_t ifp)
555d3810ff9SJared McNeill {
556d3810ff9SJared McNeill 	struct awg_softc *sc;
557d3810ff9SJared McNeill 
558d3810ff9SJared McNeill 	sc = if_getsoftc(ifp);
559d3810ff9SJared McNeill 
560d3810ff9SJared McNeill 	AWG_LOCK(sc);
561d3810ff9SJared McNeill 	awg_start_locked(sc);
562d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
563d3810ff9SJared McNeill }
564d3810ff9SJared McNeill 
565d3810ff9SJared McNeill static void
566d3810ff9SJared McNeill awg_tick(void *softc)
567d3810ff9SJared McNeill {
568d3810ff9SJared McNeill 	struct awg_softc *sc;
569d3810ff9SJared McNeill 	struct mii_data *mii;
570d3810ff9SJared McNeill 	if_t ifp;
571d3810ff9SJared McNeill 	int link;
572d3810ff9SJared McNeill 
573d3810ff9SJared McNeill 	sc = softc;
574d3810ff9SJared McNeill 	ifp = sc->ifp;
575d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
576d3810ff9SJared McNeill 
577d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
578d3810ff9SJared McNeill 
579d3810ff9SJared McNeill 	if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0)
580d3810ff9SJared McNeill 		return;
581d3810ff9SJared McNeill 
582d3810ff9SJared McNeill 	link = sc->link;
583d3810ff9SJared McNeill 	mii_tick(mii);
584d3810ff9SJared McNeill 	if (sc->link && !link)
585d3810ff9SJared McNeill 		awg_start_locked(sc);
586d3810ff9SJared McNeill 
587d3810ff9SJared McNeill 	callout_reset(&sc->stat_ch, hz, awg_tick, sc);
588d3810ff9SJared McNeill }
589d3810ff9SJared McNeill 
590d3810ff9SJared McNeill /* Bit Reversal - http://aggregate.org/MAGIC/#Bit%20Reversal */
591d3810ff9SJared McNeill static uint32_t
592d3810ff9SJared McNeill bitrev32(uint32_t x)
593d3810ff9SJared McNeill {
594d3810ff9SJared McNeill 	x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
595d3810ff9SJared McNeill 	x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
596d3810ff9SJared McNeill 	x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
597d3810ff9SJared McNeill 	x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
598d3810ff9SJared McNeill 
599d3810ff9SJared McNeill 	return (x >> 16) | (x << 16);
600d3810ff9SJared McNeill }
601d3810ff9SJared McNeill 
602d3810ff9SJared McNeill static void
603d3810ff9SJared McNeill awg_setup_rxfilter(struct awg_softc *sc)
604d3810ff9SJared McNeill {
605d3810ff9SJared McNeill 	uint32_t val, crc, hashreg, hashbit, hash[2], machi, maclo;
606d3810ff9SJared McNeill 	int mc_count, mcnt, i;
607d3810ff9SJared McNeill 	uint8_t *eaddr, *mta;
608d3810ff9SJared McNeill 	if_t ifp;
609d3810ff9SJared McNeill 
610d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
611d3810ff9SJared McNeill 
612d3810ff9SJared McNeill 	ifp = sc->ifp;
613d3810ff9SJared McNeill 	val = 0;
614d3810ff9SJared McNeill 	hash[0] = hash[1] = 0;
615d3810ff9SJared McNeill 
616d3810ff9SJared McNeill 	mc_count = if_multiaddr_count(ifp, -1);
617d3810ff9SJared McNeill 
618d3810ff9SJared McNeill 	if (if_getflags(ifp) & IFF_PROMISC)
619d3810ff9SJared McNeill 		val |= DIS_ADDR_FILTER;
620d3810ff9SJared McNeill 	else if (if_getflags(ifp) & IFF_ALLMULTI) {
621d3810ff9SJared McNeill 		val |= RX_ALL_MULTICAST;
622d3810ff9SJared McNeill 		hash[0] = hash[1] = ~0;
623d3810ff9SJared McNeill 	} else if (mc_count > 0) {
624d3810ff9SJared McNeill 		val |= HASH_MULTICAST;
625d3810ff9SJared McNeill 
626d3810ff9SJared McNeill 		mta = malloc(sizeof(unsigned char) * ETHER_ADDR_LEN * mc_count,
627d3810ff9SJared McNeill 		    M_DEVBUF, M_NOWAIT);
628d3810ff9SJared McNeill 		if (mta == NULL) {
629d3810ff9SJared McNeill 			if_printf(ifp,
630d3810ff9SJared McNeill 			    "failed to allocate temporary multicast list\n");
631d3810ff9SJared McNeill 			return;
632d3810ff9SJared McNeill 		}
633d3810ff9SJared McNeill 
634d3810ff9SJared McNeill 		if_multiaddr_array(ifp, mta, &mcnt, mc_count);
635d3810ff9SJared McNeill 		for (i = 0; i < mcnt; i++) {
636d3810ff9SJared McNeill 			crc = ether_crc32_le(mta + (i * ETHER_ADDR_LEN),
637d3810ff9SJared McNeill 			    ETHER_ADDR_LEN) & 0x7f;
638d3810ff9SJared McNeill 			crc = bitrev32(~crc) >> 26;
639d3810ff9SJared McNeill 			hashreg = (crc >> 5);
640d3810ff9SJared McNeill 			hashbit = (crc & 0x1f);
641d3810ff9SJared McNeill 			hash[hashreg] |= (1 << hashbit);
642d3810ff9SJared McNeill 		}
643d3810ff9SJared McNeill 
644d3810ff9SJared McNeill 		free(mta, M_DEVBUF);
645d3810ff9SJared McNeill 	}
646d3810ff9SJared McNeill 
647d3810ff9SJared McNeill 	/* Write our unicast address */
648d3810ff9SJared McNeill 	eaddr = IF_LLADDR(ifp);
649d3810ff9SJared McNeill 	machi = (eaddr[5] << 8) | eaddr[4];
650d3810ff9SJared McNeill 	maclo = (eaddr[3] << 24) | (eaddr[2] << 16) | (eaddr[1] << 8) |
651d3810ff9SJared McNeill 	   (eaddr[0] << 0);
652d3810ff9SJared McNeill 	WR4(sc, EMAC_ADDR_HIGH(0), machi);
653d3810ff9SJared McNeill 	WR4(sc, EMAC_ADDR_LOW(0), maclo);
654d3810ff9SJared McNeill 
655d3810ff9SJared McNeill 	/* Multicast hash filters */
656d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_HASH_0, hash[1]);
657d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_HASH_1, hash[0]);
658d3810ff9SJared McNeill 
659d3810ff9SJared McNeill 	/* RX frame filter config */
660d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_FRM_FLT, val);
661d3810ff9SJared McNeill }
662d3810ff9SJared McNeill 
663d3810ff9SJared McNeill static void
66416928528SJared McNeill awg_enable_intr(struct awg_softc *sc)
66516928528SJared McNeill {
66616928528SJared McNeill 	/* Enable interrupts */
66716928528SJared McNeill 	WR4(sc, EMAC_INT_EN, RX_INT_EN | TX_INT_EN | TX_BUF_UA_INT_EN);
66816928528SJared McNeill }
66916928528SJared McNeill 
67016928528SJared McNeill static void
67116928528SJared McNeill awg_disable_intr(struct awg_softc *sc)
67216928528SJared McNeill {
67316928528SJared McNeill 	/* Disable interrupts */
67416928528SJared McNeill 	WR4(sc, EMAC_INT_EN, 0);
67516928528SJared McNeill }
67616928528SJared McNeill 
67716928528SJared McNeill static void
678d3810ff9SJared McNeill awg_init_locked(struct awg_softc *sc)
679d3810ff9SJared McNeill {
680d3810ff9SJared McNeill 	struct mii_data *mii;
681d3810ff9SJared McNeill 	uint32_t val;
682d3810ff9SJared McNeill 	if_t ifp;
683d3810ff9SJared McNeill 
684d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
685d3810ff9SJared McNeill 	ifp = sc->ifp;
686d3810ff9SJared McNeill 
687d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
688d3810ff9SJared McNeill 
689d3810ff9SJared McNeill 	if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
690d3810ff9SJared McNeill 		return;
691d3810ff9SJared McNeill 
692d3810ff9SJared McNeill 	awg_setup_rxfilter(sc);
693d3810ff9SJared McNeill 
694d3810ff9SJared McNeill 	/* Configure DMA burst length and priorities */
695d3810ff9SJared McNeill 	val = awg_burst_len << BASIC_CTL_BURST_LEN_SHIFT;
696d3810ff9SJared McNeill 	if (awg_rx_tx_pri)
697d3810ff9SJared McNeill 		val |= BASIC_CTL_RX_TX_PRI;
698d3810ff9SJared McNeill 	WR4(sc, EMAC_BASIC_CTL_1, val);
699d3810ff9SJared McNeill 
700d3810ff9SJared McNeill 	/* Enable interrupts */
70116928528SJared McNeill #ifdef DEVICE_POLLING
70216928528SJared McNeill 	if ((if_getcapenable(ifp) & IFCAP_POLLING) == 0)
70316928528SJared McNeill 		awg_enable_intr(sc);
70416928528SJared McNeill 	else
70516928528SJared McNeill 		awg_disable_intr(sc);
70616928528SJared McNeill #else
70716928528SJared McNeill 	awg_enable_intr(sc);
70816928528SJared McNeill #endif
709d3810ff9SJared McNeill 
710d3810ff9SJared McNeill 	/* Enable transmit DMA */
711d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_CTL_1);
71216928528SJared McNeill 	WR4(sc, EMAC_TX_CTL_1, val | TX_DMA_EN | TX_MD | TX_NEXT_FRAME);
713d3810ff9SJared McNeill 
714d3810ff9SJared McNeill 	/* Enable receive DMA */
715d3810ff9SJared McNeill 	val = RD4(sc, EMAC_RX_CTL_1);
716d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_CTL_1, val | RX_DMA_EN | RX_MD);
717d3810ff9SJared McNeill 
718d3810ff9SJared McNeill 	/* Enable transmitter */
719d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_CTL_0);
720d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_CTL_0, val | TX_EN);
721d3810ff9SJared McNeill 
722d3810ff9SJared McNeill 	/* Enable receiver */
723d3810ff9SJared McNeill 	val = RD4(sc, EMAC_RX_CTL_0);
724d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_CTL_0, val | RX_EN | CHECK_CRC);
725d3810ff9SJared McNeill 
726d3810ff9SJared McNeill 	if_setdrvflagbits(ifp, IFF_DRV_RUNNING, IFF_DRV_OACTIVE);
727d3810ff9SJared McNeill 
728d3810ff9SJared McNeill 	mii_mediachg(mii);
729d3810ff9SJared McNeill 	callout_reset(&sc->stat_ch, hz, awg_tick, sc);
730d3810ff9SJared McNeill }
731d3810ff9SJared McNeill 
732d3810ff9SJared McNeill static void
733d3810ff9SJared McNeill awg_init(void *softc)
734d3810ff9SJared McNeill {
735d3810ff9SJared McNeill 	struct awg_softc *sc;
736d3810ff9SJared McNeill 
737d3810ff9SJared McNeill 	sc = softc;
738d3810ff9SJared McNeill 
739d3810ff9SJared McNeill 	AWG_LOCK(sc);
740d3810ff9SJared McNeill 	awg_init_locked(sc);
741d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
742d3810ff9SJared McNeill }
743d3810ff9SJared McNeill 
744d3810ff9SJared McNeill static void
745d3810ff9SJared McNeill awg_stop(struct awg_softc *sc)
746d3810ff9SJared McNeill {
747d3810ff9SJared McNeill 	if_t ifp;
748d3810ff9SJared McNeill 	uint32_t val;
749d3810ff9SJared McNeill 
750d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
751d3810ff9SJared McNeill 
752d3810ff9SJared McNeill 	ifp = sc->ifp;
753d3810ff9SJared McNeill 
754d3810ff9SJared McNeill 	callout_stop(&sc->stat_ch);
755d3810ff9SJared McNeill 
756d3810ff9SJared McNeill 	/* Stop transmit DMA and flush data in the TX FIFO */
757d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_CTL_1);
758d3810ff9SJared McNeill 	val &= ~TX_DMA_EN;
759d3810ff9SJared McNeill 	val |= FLUSH_TX_FIFO;
760d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_CTL_1, val);
761d3810ff9SJared McNeill 
762d3810ff9SJared McNeill 	/* Disable transmitter */
763d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_CTL_0);
764d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_CTL_0, val & ~TX_EN);
765d3810ff9SJared McNeill 
766d3810ff9SJared McNeill 	/* Disable receiver */
767d3810ff9SJared McNeill 	val = RD4(sc, EMAC_RX_CTL_0);
768d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_CTL_0, val & ~RX_EN);
769d3810ff9SJared McNeill 
770d3810ff9SJared McNeill 	/* Disable interrupts */
77116928528SJared McNeill 	awg_disable_intr(sc);
772d3810ff9SJared McNeill 
773d3810ff9SJared McNeill 	/* Disable transmit DMA */
774d3810ff9SJared McNeill 	val = RD4(sc, EMAC_TX_CTL_1);
775d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_CTL_1, val & ~TX_DMA_EN);
776d3810ff9SJared McNeill 
777d3810ff9SJared McNeill 	/* Disable receive DMA */
778d3810ff9SJared McNeill 	val = RD4(sc, EMAC_RX_CTL_1);
779d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_CTL_1, val & ~RX_DMA_EN);
780d3810ff9SJared McNeill 
781d3810ff9SJared McNeill 	sc->link = 0;
782d3810ff9SJared McNeill 
783d3810ff9SJared McNeill 	if_setdrvflagbits(ifp, 0, IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
784d3810ff9SJared McNeill }
785d3810ff9SJared McNeill 
78616928528SJared McNeill static int
787d3810ff9SJared McNeill awg_rxintr(struct awg_softc *sc)
788d3810ff9SJared McNeill {
789d3810ff9SJared McNeill 	if_t ifp;
79016928528SJared McNeill 	struct mbuf *m, *m0, *mh, *mt;
79116928528SJared McNeill 	int error, index, len, cnt, npkt;
792d3810ff9SJared McNeill 	uint32_t status;
793d3810ff9SJared McNeill 
794d3810ff9SJared McNeill 	ifp = sc->ifp;
79516928528SJared McNeill 	mh = mt = NULL;
79616928528SJared McNeill 	cnt = 0;
79716928528SJared McNeill 	npkt = 0;
798d3810ff9SJared McNeill 
799d3810ff9SJared McNeill 	bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
800d3810ff9SJared McNeill 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
801d3810ff9SJared McNeill 
802d3810ff9SJared McNeill 	for (index = sc->rx.cur; ; index = RX_NEXT(index)) {
803d3810ff9SJared McNeill 		status = le32toh(sc->rx.desc_ring[index].status);
804d3810ff9SJared McNeill 		if ((status & RX_DESC_CTL) != 0)
805d3810ff9SJared McNeill 			break;
806d3810ff9SJared McNeill 
807d3810ff9SJared McNeill 		bus_dmamap_sync(sc->rx.buf_tag, sc->rx.buf_map[index].map,
808d3810ff9SJared McNeill 		    BUS_DMASYNC_POSTREAD);
809d3810ff9SJared McNeill 		bus_dmamap_unload(sc->rx.buf_tag, sc->rx.buf_map[index].map);
810d3810ff9SJared McNeill 
811d3810ff9SJared McNeill 		len = (status & RX_FRM_LEN) >> RX_FRM_LEN_SHIFT;
812d3810ff9SJared McNeill 		if (len != 0) {
813d3810ff9SJared McNeill 			m = sc->rx.buf_map[index].mbuf;
814d3810ff9SJared McNeill 			m->m_pkthdr.rcvif = ifp;
815d3810ff9SJared McNeill 			m->m_pkthdr.len = len;
816d3810ff9SJared McNeill 			m->m_len = len;
817d3810ff9SJared McNeill 			if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
818d3810ff9SJared McNeill 
819d3810ff9SJared McNeill 			if ((if_getcapenable(ifp) & IFCAP_RXCSUM) != 0 &&
820d3810ff9SJared McNeill 			    (status & RX_FRM_TYPE) != 0) {
821d3810ff9SJared McNeill 				m->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
822d3810ff9SJared McNeill 				if ((status & RX_HEADER_ERR) == 0)
823d3810ff9SJared McNeill 					m->m_pkthdr.csum_flags |= CSUM_IP_VALID;
824d3810ff9SJared McNeill 				if ((status & RX_PAYLOAD_ERR) == 0) {
825d3810ff9SJared McNeill 					m->m_pkthdr.csum_flags |=
826d3810ff9SJared McNeill 					    CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
827d3810ff9SJared McNeill 					m->m_pkthdr.csum_data = 0xffff;
828d3810ff9SJared McNeill 				}
829d3810ff9SJared McNeill 			}
830d3810ff9SJared McNeill 
83116928528SJared McNeill 			m->m_nextpkt = NULL;
83216928528SJared McNeill 			if (mh == NULL)
83316928528SJared McNeill 				mh = m;
83416928528SJared McNeill 			else
83516928528SJared McNeill 				mt->m_nextpkt = m;
83616928528SJared McNeill 			mt = m;
83716928528SJared McNeill 			++cnt;
83816928528SJared McNeill 			++npkt;
83916928528SJared McNeill 
84016928528SJared McNeill 			if (cnt == awg_rx_batch) {
841d3810ff9SJared McNeill 				AWG_UNLOCK(sc);
84216928528SJared McNeill 				if_input(ifp, mh);
843d3810ff9SJared McNeill 				AWG_LOCK(sc);
84416928528SJared McNeill 				mh = mt = NULL;
84516928528SJared McNeill 				cnt = 0;
84616928528SJared McNeill 			}
84716928528SJared McNeill 
848d3810ff9SJared McNeill 		}
849d3810ff9SJared McNeill 
850d3810ff9SJared McNeill 		if ((m0 = awg_alloc_mbufcl(sc)) != NULL) {
851d3810ff9SJared McNeill 			error = awg_setup_rxbuf(sc, index, m0);
852d3810ff9SJared McNeill 			if (error != 0) {
853d3810ff9SJared McNeill 				/* XXX hole in RX ring */
854d3810ff9SJared McNeill 			}
855d3810ff9SJared McNeill 		} else
856d3810ff9SJared McNeill 			if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
857d3810ff9SJared McNeill 	}
858d3810ff9SJared McNeill 
859d3810ff9SJared McNeill 	if (index != sc->rx.cur) {
860d3810ff9SJared McNeill 		bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
861d3810ff9SJared McNeill 		    BUS_DMASYNC_PREWRITE);
862d3810ff9SJared McNeill 	}
863d3810ff9SJared McNeill 
86416928528SJared McNeill 	if (mh != NULL) {
86516928528SJared McNeill 		AWG_UNLOCK(sc);
86616928528SJared McNeill 		if_input(ifp, mh);
86716928528SJared McNeill 		AWG_LOCK(sc);
86816928528SJared McNeill 	}
86916928528SJared McNeill 
870d3810ff9SJared McNeill 	sc->rx.cur = index;
87116928528SJared McNeill 
87216928528SJared McNeill 	return (npkt);
873d3810ff9SJared McNeill }
874d3810ff9SJared McNeill 
875d3810ff9SJared McNeill static void
876d3810ff9SJared McNeill awg_txintr(struct awg_softc *sc)
877d3810ff9SJared McNeill {
878d3810ff9SJared McNeill 	struct awg_bufmap *bmap;
879d3810ff9SJared McNeill 	struct emac_desc *desc;
880d3810ff9SJared McNeill 	uint32_t status;
881d3810ff9SJared McNeill 	if_t ifp;
882d3810ff9SJared McNeill 	int i;
883d3810ff9SJared McNeill 
884d3810ff9SJared McNeill 	AWG_ASSERT_LOCKED(sc);
885d3810ff9SJared McNeill 
886d3810ff9SJared McNeill 	bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
887d3810ff9SJared McNeill 	    BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
888d3810ff9SJared McNeill 
889d3810ff9SJared McNeill 	ifp = sc->ifp;
890d3810ff9SJared McNeill 	for (i = sc->tx.next; sc->tx.queued > 0; i = TX_NEXT(i)) {
891d3810ff9SJared McNeill 		desc = &sc->tx.desc_ring[i];
892d3810ff9SJared McNeill 		status = le32toh(desc->status);
893d3810ff9SJared McNeill 		if ((status & TX_DESC_CTL) != 0)
894d3810ff9SJared McNeill 			break;
895d3810ff9SJared McNeill 		bmap = &sc->tx.buf_map[i];
896d3810ff9SJared McNeill 		if (bmap->mbuf != NULL) {
897d3810ff9SJared McNeill 			bus_dmamap_sync(sc->tx.buf_tag, bmap->map,
898d3810ff9SJared McNeill 			    BUS_DMASYNC_POSTWRITE);
899d3810ff9SJared McNeill 			bus_dmamap_unload(sc->tx.buf_tag, bmap->map);
900d3810ff9SJared McNeill 			m_freem(bmap->mbuf);
901d3810ff9SJared McNeill 			bmap->mbuf = NULL;
902d3810ff9SJared McNeill 		}
903d3810ff9SJared McNeill 		awg_setup_txdesc(sc, i, 0, 0, 0);
904d3810ff9SJared McNeill 		if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
905d3810ff9SJared McNeill 		if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
906d3810ff9SJared McNeill 	}
907d3810ff9SJared McNeill 
908d3810ff9SJared McNeill 	sc->tx.next = i;
909d3810ff9SJared McNeill 
910d3810ff9SJared McNeill 	bus_dmamap_sync(sc->tx.desc_tag, sc->tx.desc_map,
911d3810ff9SJared McNeill 	    BUS_DMASYNC_PREWRITE);
912d3810ff9SJared McNeill }
913d3810ff9SJared McNeill 
914d3810ff9SJared McNeill static void
915d3810ff9SJared McNeill awg_intr(void *arg)
916d3810ff9SJared McNeill {
917d3810ff9SJared McNeill 	struct awg_softc *sc;
918d3810ff9SJared McNeill 	uint32_t val;
919d3810ff9SJared McNeill 
920d3810ff9SJared McNeill 	sc = arg;
921d3810ff9SJared McNeill 
922d3810ff9SJared McNeill 	AWG_LOCK(sc);
923d3810ff9SJared McNeill 	val = RD4(sc, EMAC_INT_STA);
924d3810ff9SJared McNeill 	WR4(sc, EMAC_INT_STA, val);
925d3810ff9SJared McNeill 
926d3810ff9SJared McNeill 	if (val & RX_INT)
927d3810ff9SJared McNeill 		awg_rxintr(sc);
928d3810ff9SJared McNeill 
929d3810ff9SJared McNeill 	if (val & (TX_INT|TX_BUF_UA_INT)) {
930d3810ff9SJared McNeill 		awg_txintr(sc);
931d3810ff9SJared McNeill 		if (!if_sendq_empty(sc->ifp))
932d3810ff9SJared McNeill 			awg_start_locked(sc);
933d3810ff9SJared McNeill 	}
934d3810ff9SJared McNeill 
935d3810ff9SJared McNeill 	AWG_UNLOCK(sc);
936d3810ff9SJared McNeill }
937d3810ff9SJared McNeill 
93816928528SJared McNeill #ifdef DEVICE_POLLING
93916928528SJared McNeill static int
94016928528SJared McNeill awg_poll(if_t ifp, enum poll_cmd cmd, int count)
94116928528SJared McNeill {
94216928528SJared McNeill 	struct awg_softc *sc;
94316928528SJared McNeill 	uint32_t val;
94416928528SJared McNeill 	int rx_npkts;
94516928528SJared McNeill 
94616928528SJared McNeill 	sc = if_getsoftc(ifp);
94716928528SJared McNeill 	rx_npkts = 0;
94816928528SJared McNeill 
94916928528SJared McNeill 	AWG_LOCK(sc);
95016928528SJared McNeill 
95116928528SJared McNeill 	if ((if_getdrvflags(ifp) & IFF_DRV_RUNNING) == 0) {
95216928528SJared McNeill 		AWG_UNLOCK(sc);
95316928528SJared McNeill 		return (0);
95416928528SJared McNeill 	}
95516928528SJared McNeill 
95616928528SJared McNeill 	rx_npkts = awg_rxintr(sc);
95716928528SJared McNeill 	awg_txintr(sc);
95816928528SJared McNeill 	if (!if_sendq_empty(ifp))
95916928528SJared McNeill 		awg_start_locked(sc);
96016928528SJared McNeill 
96116928528SJared McNeill 	if (cmd == POLL_AND_CHECK_STATUS) {
96216928528SJared McNeill 		val = RD4(sc, EMAC_INT_STA);
96316928528SJared McNeill 		if (val != 0)
96416928528SJared McNeill 			WR4(sc, EMAC_INT_STA, val);
96516928528SJared McNeill 	}
96616928528SJared McNeill 
96716928528SJared McNeill 	AWG_UNLOCK(sc);
96816928528SJared McNeill 
96916928528SJared McNeill 	return (rx_npkts);
97016928528SJared McNeill }
97116928528SJared McNeill #endif
97216928528SJared McNeill 
973d3810ff9SJared McNeill static int
974d3810ff9SJared McNeill awg_ioctl(if_t ifp, u_long cmd, caddr_t data)
975d3810ff9SJared McNeill {
976d3810ff9SJared McNeill 	struct awg_softc *sc;
977d3810ff9SJared McNeill 	struct mii_data *mii;
978d3810ff9SJared McNeill 	struct ifreq *ifr;
979d3810ff9SJared McNeill 	int flags, mask, error;
980d3810ff9SJared McNeill 
981d3810ff9SJared McNeill 	sc = if_getsoftc(ifp);
982d3810ff9SJared McNeill 	mii = device_get_softc(sc->miibus);
983d3810ff9SJared McNeill 	ifr = (struct ifreq *)data;
984d3810ff9SJared McNeill 	error = 0;
985d3810ff9SJared McNeill 
986d3810ff9SJared McNeill 	switch (cmd) {
987d3810ff9SJared McNeill 	case SIOCSIFFLAGS:
988d3810ff9SJared McNeill 		AWG_LOCK(sc);
989d3810ff9SJared McNeill 		if (if_getflags(ifp) & IFF_UP) {
990d3810ff9SJared McNeill 			if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
991d3810ff9SJared McNeill 				flags = if_getflags(ifp) ^ sc->if_flags;
992d3810ff9SJared McNeill 				if ((flags & (IFF_PROMISC|IFF_ALLMULTI)) != 0)
993d3810ff9SJared McNeill 					awg_setup_rxfilter(sc);
994d3810ff9SJared McNeill 			} else
995d3810ff9SJared McNeill 				awg_init_locked(sc);
996d3810ff9SJared McNeill 		} else {
997d3810ff9SJared McNeill 			if (if_getdrvflags(ifp) & IFF_DRV_RUNNING)
998d3810ff9SJared McNeill 				awg_stop(sc);
999d3810ff9SJared McNeill 		}
1000d3810ff9SJared McNeill 		sc->if_flags = if_getflags(ifp);
1001d3810ff9SJared McNeill 		AWG_UNLOCK(sc);
1002d3810ff9SJared McNeill 		break;
1003d3810ff9SJared McNeill 	case SIOCADDMULTI:
1004d3810ff9SJared McNeill 	case SIOCDELMULTI:
1005d3810ff9SJared McNeill 		if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
1006d3810ff9SJared McNeill 			AWG_LOCK(sc);
1007d3810ff9SJared McNeill 			awg_setup_rxfilter(sc);
1008d3810ff9SJared McNeill 			AWG_UNLOCK(sc);
1009d3810ff9SJared McNeill 		}
1010d3810ff9SJared McNeill 		break;
1011d3810ff9SJared McNeill 	case SIOCSIFMEDIA:
1012d3810ff9SJared McNeill 	case SIOCGIFMEDIA:
1013d3810ff9SJared McNeill 		error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1014d3810ff9SJared McNeill 		break;
1015d3810ff9SJared McNeill 	case SIOCSIFCAP:
1016d3810ff9SJared McNeill 		mask = ifr->ifr_reqcap ^ if_getcapenable(ifp);
101716928528SJared McNeill #ifdef DEVICE_POLLING
101816928528SJared McNeill 		if (mask & IFCAP_POLLING) {
101916928528SJared McNeill 			if ((ifr->ifr_reqcap & IFCAP_POLLING) != 0) {
102016928528SJared McNeill 				error = ether_poll_register(awg_poll, ifp);
102116928528SJared McNeill 				if (error != 0)
102216928528SJared McNeill 					break;
102316928528SJared McNeill 				AWG_LOCK(sc);
102416928528SJared McNeill 				awg_disable_intr(sc);
102516928528SJared McNeill 				if_setcapenablebit(ifp, IFCAP_POLLING, 0);
102616928528SJared McNeill 				AWG_UNLOCK(sc);
102716928528SJared McNeill 			} else {
102816928528SJared McNeill 				error = ether_poll_deregister(ifp);
102916928528SJared McNeill 				AWG_LOCK(sc);
103016928528SJared McNeill 				awg_enable_intr(sc);
103116928528SJared McNeill 				if_setcapenablebit(ifp, 0, IFCAP_POLLING);
103216928528SJared McNeill 				AWG_UNLOCK(sc);
103316928528SJared McNeill 			}
103416928528SJared McNeill 		}
103516928528SJared McNeill #endif
1036d3810ff9SJared McNeill 		if (mask & IFCAP_VLAN_MTU)
1037d3810ff9SJared McNeill 			if_togglecapenable(ifp, IFCAP_VLAN_MTU);
1038d3810ff9SJared McNeill 		if (mask & IFCAP_RXCSUM)
1039d3810ff9SJared McNeill 			if_togglecapenable(ifp, IFCAP_RXCSUM);
1040d3810ff9SJared McNeill 		if (mask & IFCAP_TXCSUM)
1041d3810ff9SJared McNeill 			if_togglecapenable(ifp, IFCAP_TXCSUM);
1042d3810ff9SJared McNeill 		if ((if_getcapenable(ifp) & (IFCAP_RXCSUM|IFCAP_TXCSUM)) != 0)
1043d3810ff9SJared McNeill 			if_sethwassistbits(ifp, CSUM_IP, 0);
1044d3810ff9SJared McNeill 		else
1045d3810ff9SJared McNeill 			if_sethwassistbits(ifp, 0, CSUM_IP);
1046d3810ff9SJared McNeill 		break;
1047d3810ff9SJared McNeill 	default:
1048d3810ff9SJared McNeill 		error = ether_ioctl(ifp, cmd, data);
1049d3810ff9SJared McNeill 		break;
1050d3810ff9SJared McNeill 	}
1051d3810ff9SJared McNeill 
1052d3810ff9SJared McNeill 	return (error);
1053d3810ff9SJared McNeill }
1054d3810ff9SJared McNeill 
1055d3810ff9SJared McNeill static int
105601a469b8SJared McNeill awg_setup_phy(device_t dev)
1057d3810ff9SJared McNeill {
1058d3810ff9SJared McNeill 	struct awg_softc *sc;
105901a469b8SJared McNeill 	clk_t clk_tx, clk_tx_parent;
1060d3810ff9SJared McNeill 	const char *tx_parent_name;
1061d3810ff9SJared McNeill 	char *phy_type;
1062d3810ff9SJared McNeill 	phandle_t node;
106301a469b8SJared McNeill 	uint32_t reg, tx_delay, rx_delay;
106401a469b8SJared McNeill 	int error;
1065d3810ff9SJared McNeill 
1066d3810ff9SJared McNeill 	sc = device_get_softc(dev);
1067d3810ff9SJared McNeill 	node = ofw_bus_get_node(dev);
1068d3810ff9SJared McNeill 
106901a469b8SJared McNeill 	if (OF_getprop_alloc(node, "phy-mode", 1, (void **)&phy_type) == 0)
107001a469b8SJared McNeill 		return (0);
1071d3810ff9SJared McNeill 
1072d3810ff9SJared McNeill 	if (bootverbose)
107301a469b8SJared McNeill 		device_printf(dev, "PHY type: %s, conf mode: %s\n", phy_type,
107401a469b8SJared McNeill 		    sc->res[_RES_SYSCON] != NULL ? "reg" : "clk");
1075d3810ff9SJared McNeill 
107601a469b8SJared McNeill 	if (sc->res[_RES_SYSCON] != NULL) {
107701a469b8SJared McNeill 		reg = bus_read_4(sc->res[_RES_SYSCON], 0);
107801a469b8SJared McNeill 		reg &= ~(EMAC_CLK_PIT | EMAC_CLK_SRC | EMAC_CLK_RMII_EN);
107901a469b8SJared McNeill 		if (strcmp(phy_type, "rgmii") == 0)
108001a469b8SJared McNeill 			reg |= EMAC_CLK_PIT_RGMII | EMAC_CLK_SRC_RGMII;
108101a469b8SJared McNeill 		else if (strcmp(phy_type, "rmii") == 0)
108201a469b8SJared McNeill 			reg |= EMAC_CLK_RMII_EN;
108301a469b8SJared McNeill 		else
108401a469b8SJared McNeill 			reg |= EMAC_CLK_PIT_MII | EMAC_CLK_SRC_MII;
108501a469b8SJared McNeill 
108601a469b8SJared McNeill 		if (OF_getencprop(node, "tx-delay", &tx_delay,
108701a469b8SJared McNeill 		    sizeof(tx_delay)) > 0) {
108801a469b8SJared McNeill 			reg &= ~EMAC_CLK_ETXDC;
108901a469b8SJared McNeill 			reg |= (tx_delay << EMAC_CLK_ETXDC_SHIFT);
109001a469b8SJared McNeill 		}
109101a469b8SJared McNeill 		if (OF_getencprop(node, "rx-delay", &rx_delay,
109201a469b8SJared McNeill 		    sizeof(rx_delay)) > 0) {
109301a469b8SJared McNeill 			reg &= ~EMAC_CLK_ERXDC;
109401a469b8SJared McNeill 			reg |= (rx_delay << EMAC_CLK_ERXDC_SHIFT);
109501a469b8SJared McNeill 		}
109601a469b8SJared McNeill 
109701a469b8SJared McNeill 		if (sc->type == EMAC_H3) {
109801a469b8SJared McNeill 			if (OF_hasprop(node, "allwinner,use-internal-phy")) {
109901a469b8SJared McNeill 				reg |= EMAC_CLK_EPHY_SELECT;
110001a469b8SJared McNeill 				reg &= ~EMAC_CLK_EPHY_SHUTDOWN;
110101a469b8SJared McNeill 				if (OF_hasprop(node,
110201a469b8SJared McNeill 				    "allwinner,leds-active-low"))
110301a469b8SJared McNeill 					reg |= EMAC_CLK_EPHY_LED_POL;
110401a469b8SJared McNeill 				else
110501a469b8SJared McNeill 					reg &= ~EMAC_CLK_EPHY_LED_POL;
110601a469b8SJared McNeill 
110701a469b8SJared McNeill 				/* Set internal PHY addr to 1 */
110801a469b8SJared McNeill 				reg &= ~EMAC_CLK_EPHY_ADDR;
110901a469b8SJared McNeill 				reg |= (1 << EMAC_CLK_EPHY_ADDR_SHIFT);
111001a469b8SJared McNeill 			} else {
111101a469b8SJared McNeill 				reg &= ~EMAC_CLK_EPHY_SELECT;
111201a469b8SJared McNeill 			}
111301a469b8SJared McNeill 		}
111401a469b8SJared McNeill 
111501a469b8SJared McNeill 		if (bootverbose)
111601a469b8SJared McNeill 			device_printf(dev, "EMAC clock: 0x%08x\n", reg);
111701a469b8SJared McNeill 		bus_write_4(sc->res[_RES_SYSCON], 0, reg);
111801a469b8SJared McNeill 	} else {
1119d3810ff9SJared McNeill 		if (strcmp(phy_type, "rgmii") == 0)
1120d3810ff9SJared McNeill 			tx_parent_name = "emac_int_tx";
1121d3810ff9SJared McNeill 		else
1122d3810ff9SJared McNeill 			tx_parent_name = "mii_phy_tx";
1123d3810ff9SJared McNeill 
1124d3810ff9SJared McNeill 		/* Get the TX clock */
1125dac93553SMichal Meloun 		error = clk_get_by_ofw_name(dev, 0, "tx", &clk_tx);
1126d3810ff9SJared McNeill 		if (error != 0) {
1127d3810ff9SJared McNeill 			device_printf(dev, "cannot get tx clock\n");
1128d3810ff9SJared McNeill 			goto fail;
1129d3810ff9SJared McNeill 		}
1130d3810ff9SJared McNeill 
1131d3810ff9SJared McNeill 		/* Find the desired parent clock based on phy-mode property */
1132d3810ff9SJared McNeill 		error = clk_get_by_name(dev, tx_parent_name, &clk_tx_parent);
1133d3810ff9SJared McNeill 		if (error != 0) {
1134d3810ff9SJared McNeill 			device_printf(dev, "cannot get clock '%s'\n",
1135d3810ff9SJared McNeill 			    tx_parent_name);
1136d3810ff9SJared McNeill 			goto fail;
1137d3810ff9SJared McNeill 		}
1138d3810ff9SJared McNeill 
1139d3810ff9SJared McNeill 		/* Set TX clock parent */
1140d3810ff9SJared McNeill 		error = clk_set_parent_by_clk(clk_tx, clk_tx_parent);
1141d3810ff9SJared McNeill 		if (error != 0) {
1142d3810ff9SJared McNeill 			device_printf(dev, "cannot set tx clock parent\n");
1143d3810ff9SJared McNeill 			goto fail;
1144d3810ff9SJared McNeill 		}
1145d3810ff9SJared McNeill 
1146d3810ff9SJared McNeill 		/* Enable TX clock */
1147d3810ff9SJared McNeill 		error = clk_enable(clk_tx);
1148d3810ff9SJared McNeill 		if (error != 0) {
1149d3810ff9SJared McNeill 			device_printf(dev, "cannot enable tx clock\n");
1150d3810ff9SJared McNeill 			goto fail;
1151d3810ff9SJared McNeill 		}
1152d3810ff9SJared McNeill 	}
1153d3810ff9SJared McNeill 
115401a469b8SJared McNeill 	error = 0;
115501a469b8SJared McNeill 
115601a469b8SJared McNeill fail:
115701a469b8SJared McNeill 	OF_prop_free(phy_type);
115801a469b8SJared McNeill 	return (error);
115901a469b8SJared McNeill }
116001a469b8SJared McNeill 
116101a469b8SJared McNeill static int
116201a469b8SJared McNeill awg_setup_extres(device_t dev)
116301a469b8SJared McNeill {
116401a469b8SJared McNeill 	struct awg_softc *sc;
116501a469b8SJared McNeill 	hwreset_t rst_ahb, rst_ephy;
116601a469b8SJared McNeill 	clk_t clk_ahb, clk_ephy;
116701a469b8SJared McNeill 	regulator_t reg;
116801a469b8SJared McNeill 	phandle_t node;
116901a469b8SJared McNeill 	uint64_t freq;
117001a469b8SJared McNeill 	int error, div;
117101a469b8SJared McNeill 
117201a469b8SJared McNeill 	sc = device_get_softc(dev);
117301a469b8SJared McNeill 	node = ofw_bus_get_node(dev);
117401a469b8SJared McNeill 	rst_ahb = rst_ephy = NULL;
117501a469b8SJared McNeill 	clk_ahb = clk_ephy = NULL;
117601a469b8SJared McNeill 	reg = NULL;
117701a469b8SJared McNeill 
117801a469b8SJared McNeill 	/* Get AHB clock and reset resources */
117901a469b8SJared McNeill 	error = hwreset_get_by_ofw_name(dev, 0, "ahb", &rst_ahb);
118001a469b8SJared McNeill 	if (error != 0) {
118101a469b8SJared McNeill 		device_printf(dev, "cannot get ahb reset\n");
118201a469b8SJared McNeill 		goto fail;
118301a469b8SJared McNeill 	}
118401a469b8SJared McNeill 	if (hwreset_get_by_ofw_name(dev, 0, "ephy", &rst_ephy) != 0)
118501a469b8SJared McNeill 		rst_ephy = NULL;
118601a469b8SJared McNeill 	error = clk_get_by_ofw_name(dev, 0, "ahb", &clk_ahb);
118701a469b8SJared McNeill 	if (error != 0) {
118801a469b8SJared McNeill 		device_printf(dev, "cannot get ahb clock\n");
118901a469b8SJared McNeill 		goto fail;
119001a469b8SJared McNeill 	}
119101a469b8SJared McNeill 	if (clk_get_by_ofw_name(dev, 0, "ephy", &clk_ephy) != 0)
119201a469b8SJared McNeill 		clk_ephy = NULL;
119301a469b8SJared McNeill 
119401a469b8SJared McNeill 	/* Configure PHY for MII or RGMII mode */
119501a469b8SJared McNeill 	if (awg_setup_phy(dev) != 0)
119601a469b8SJared McNeill 		goto fail;
119701a469b8SJared McNeill 
119801a469b8SJared McNeill 	/* Enable clocks */
1199d3810ff9SJared McNeill 	error = clk_enable(clk_ahb);
1200d3810ff9SJared McNeill 	if (error != 0) {
1201d3810ff9SJared McNeill 		device_printf(dev, "cannot enable ahb clock\n");
1202d3810ff9SJared McNeill 		goto fail;
1203d3810ff9SJared McNeill 	}
120401a469b8SJared McNeill 	if (clk_ephy != NULL) {
120501a469b8SJared McNeill 		error = clk_enable(clk_ephy);
120601a469b8SJared McNeill 		if (error != 0) {
120701a469b8SJared McNeill 			device_printf(dev, "cannot enable ephy clock\n");
120801a469b8SJared McNeill 			goto fail;
120901a469b8SJared McNeill 		}
121001a469b8SJared McNeill 	}
1211d3810ff9SJared McNeill 
1212d3810ff9SJared McNeill 	/* De-assert reset */
1213d3810ff9SJared McNeill 	error = hwreset_deassert(rst_ahb);
1214d3810ff9SJared McNeill 	if (error != 0) {
1215d3810ff9SJared McNeill 		device_printf(dev, "cannot de-assert ahb reset\n");
1216d3810ff9SJared McNeill 		goto fail;
1217d3810ff9SJared McNeill 	}
121801a469b8SJared McNeill 	if (rst_ephy != NULL) {
121901a469b8SJared McNeill 		error = hwreset_deassert(rst_ephy);
122001a469b8SJared McNeill 		if (error != 0) {
122101a469b8SJared McNeill 			device_printf(dev, "cannot de-assert ephy reset\n");
122201a469b8SJared McNeill 			goto fail;
122301a469b8SJared McNeill 		}
122401a469b8SJared McNeill 	}
1225d3810ff9SJared McNeill 
1226d3810ff9SJared McNeill 	/* Enable PHY regulator if applicable */
1227dac93553SMichal Meloun 	if (regulator_get_by_ofw_property(dev, 0, "phy-supply", &reg) == 0) {
1228d3810ff9SJared McNeill 		error = regulator_enable(reg);
1229d3810ff9SJared McNeill 		if (error != 0) {
1230d3810ff9SJared McNeill 			device_printf(dev, "cannot enable PHY regulator\n");
1231d3810ff9SJared McNeill 			goto fail;
1232d3810ff9SJared McNeill 		}
1233d3810ff9SJared McNeill 	}
1234d3810ff9SJared McNeill 
1235d3810ff9SJared McNeill 	/* Determine MDC clock divide ratio based on AHB clock */
1236d3810ff9SJared McNeill 	error = clk_get_freq(clk_ahb, &freq);
1237d3810ff9SJared McNeill 	if (error != 0) {
1238d3810ff9SJared McNeill 		device_printf(dev, "cannot get AHB clock frequency\n");
1239d3810ff9SJared McNeill 		goto fail;
1240d3810ff9SJared McNeill 	}
1241d3810ff9SJared McNeill 	div = freq / MDIO_FREQ;
1242d3810ff9SJared McNeill 	if (div <= 16)
1243d3810ff9SJared McNeill 		sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_16;
1244d3810ff9SJared McNeill 	else if (div <= 32)
1245d3810ff9SJared McNeill 		sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_32;
1246d3810ff9SJared McNeill 	else if (div <= 64)
1247d3810ff9SJared McNeill 		sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_64;
1248d3810ff9SJared McNeill 	else if (div <= 128)
1249d3810ff9SJared McNeill 		sc->mdc_div_ratio_m = MDC_DIV_RATIO_M_128;
1250d3810ff9SJared McNeill 	else {
1251d3810ff9SJared McNeill 		device_printf(dev, "cannot determine MDC clock divide ratio\n");
1252d3810ff9SJared McNeill 		error = ENXIO;
1253d3810ff9SJared McNeill 		goto fail;
1254d3810ff9SJared McNeill 	}
1255d3810ff9SJared McNeill 
1256d3810ff9SJared McNeill 	if (bootverbose)
125701a469b8SJared McNeill 		device_printf(dev, "AHB frequency %ju Hz, MDC div: 0x%x\n",
125801a469b8SJared McNeill 		    (uintmax_t)freq, sc->mdc_div_ratio_m);
1259d3810ff9SJared McNeill 
1260d3810ff9SJared McNeill 	return (0);
1261d3810ff9SJared McNeill 
1262d3810ff9SJared McNeill fail:
1263d3810ff9SJared McNeill 	if (reg != NULL)
1264d3810ff9SJared McNeill 		regulator_release(reg);
126501a469b8SJared McNeill 	if (clk_ephy != NULL)
126601a469b8SJared McNeill 		clk_release(clk_ephy);
1267d3810ff9SJared McNeill 	if (clk_ahb != NULL)
1268d3810ff9SJared McNeill 		clk_release(clk_ahb);
126901a469b8SJared McNeill 	if (rst_ephy != NULL)
127001a469b8SJared McNeill 		hwreset_release(rst_ephy);
1271d3810ff9SJared McNeill 	if (rst_ahb != NULL)
1272d3810ff9SJared McNeill 		hwreset_release(rst_ahb);
1273d3810ff9SJared McNeill 	return (error);
1274d3810ff9SJared McNeill }
1275d3810ff9SJared McNeill 
1276d3810ff9SJared McNeill static void
1277d3810ff9SJared McNeill awg_get_eaddr(device_t dev, uint8_t *eaddr)
1278d3810ff9SJared McNeill {
1279d3810ff9SJared McNeill 	struct awg_softc *sc;
1280d3810ff9SJared McNeill 	uint32_t maclo, machi, rnd;
1281*1403e695SJared McNeill 	u_char rootkey[16];
1282d3810ff9SJared McNeill 
1283d3810ff9SJared McNeill 	sc = device_get_softc(dev);
1284d3810ff9SJared McNeill 
1285d3810ff9SJared McNeill 	machi = RD4(sc, EMAC_ADDR_HIGH(0)) & 0xffff;
1286d3810ff9SJared McNeill 	maclo = RD4(sc, EMAC_ADDR_LOW(0));
1287d3810ff9SJared McNeill 
1288d3810ff9SJared McNeill 	if (maclo == 0xffffffff && machi == 0xffff) {
1289d3810ff9SJared McNeill 		/* MAC address in hardware is invalid, create one */
1290*1403e695SJared McNeill 		if (aw_sid_get_rootkey(rootkey) == 0 &&
1291*1403e695SJared McNeill 		    (rootkey[3] | rootkey[12] | rootkey[13] | rootkey[14] |
1292*1403e695SJared McNeill 		     rootkey[15]) != 0) {
1293*1403e695SJared McNeill 			/* MAC address is derived from the root key in SID */
1294*1403e695SJared McNeill 			maclo = (rootkey[13] << 24) | (rootkey[12] << 16) |
1295*1403e695SJared McNeill 				(rootkey[3] << 8) | 0x02;
1296*1403e695SJared McNeill 			machi = (rootkey[15] << 8) | rootkey[14];
1297*1403e695SJared McNeill 		} else {
1298*1403e695SJared McNeill 			/* Create one */
1299d3810ff9SJared McNeill 			rnd = arc4random();
1300d3810ff9SJared McNeill 			maclo = 0x00f2 | (rnd & 0xffff0000);
1301d3810ff9SJared McNeill 			machi = rnd & 0xffff;
1302d3810ff9SJared McNeill 		}
1303*1403e695SJared McNeill 	}
1304d3810ff9SJared McNeill 
1305d3810ff9SJared McNeill 	eaddr[0] = maclo & 0xff;
1306d3810ff9SJared McNeill 	eaddr[1] = (maclo >> 8) & 0xff;
1307d3810ff9SJared McNeill 	eaddr[2] = (maclo >> 16) & 0xff;
1308d3810ff9SJared McNeill 	eaddr[3] = (maclo >> 24) & 0xff;
1309d3810ff9SJared McNeill 	eaddr[4] = machi & 0xff;
1310d3810ff9SJared McNeill 	eaddr[5] = (machi >> 8) & 0xff;
1311d3810ff9SJared McNeill }
1312d3810ff9SJared McNeill 
1313d3810ff9SJared McNeill #ifdef AWG_DEBUG
1314d3810ff9SJared McNeill static void
1315d3810ff9SJared McNeill awg_dump_regs(device_t dev)
1316d3810ff9SJared McNeill {
1317d3810ff9SJared McNeill 	static const struct {
1318d3810ff9SJared McNeill 		const char *name;
1319d3810ff9SJared McNeill 		u_int reg;
1320d3810ff9SJared McNeill 	} regs[] = {
1321d3810ff9SJared McNeill 		{ "BASIC_CTL_0", EMAC_BASIC_CTL_0 },
1322d3810ff9SJared McNeill 		{ "BASIC_CTL_1", EMAC_BASIC_CTL_1 },
1323d3810ff9SJared McNeill 		{ "INT_STA", EMAC_INT_STA },
1324d3810ff9SJared McNeill 		{ "INT_EN", EMAC_INT_EN },
1325d3810ff9SJared McNeill 		{ "TX_CTL_0", EMAC_TX_CTL_0 },
1326d3810ff9SJared McNeill 		{ "TX_CTL_1", EMAC_TX_CTL_1 },
1327d3810ff9SJared McNeill 		{ "TX_FLOW_CTL", EMAC_TX_FLOW_CTL },
1328d3810ff9SJared McNeill 		{ "TX_DMA_LIST", EMAC_TX_DMA_LIST },
1329d3810ff9SJared McNeill 		{ "RX_CTL_0", EMAC_RX_CTL_0 },
1330d3810ff9SJared McNeill 		{ "RX_CTL_1", EMAC_RX_CTL_1 },
1331d3810ff9SJared McNeill 		{ "RX_DMA_LIST", EMAC_RX_DMA_LIST },
1332d3810ff9SJared McNeill 		{ "RX_FRM_FLT", EMAC_RX_FRM_FLT },
1333d3810ff9SJared McNeill 		{ "RX_HASH_0", EMAC_RX_HASH_0 },
1334d3810ff9SJared McNeill 		{ "RX_HASH_1", EMAC_RX_HASH_1 },
1335d3810ff9SJared McNeill 		{ "MII_CMD", EMAC_MII_CMD },
1336d3810ff9SJared McNeill 		{ "ADDR_HIGH0", EMAC_ADDR_HIGH(0) },
1337d3810ff9SJared McNeill 		{ "ADDR_LOW0", EMAC_ADDR_LOW(0) },
1338d3810ff9SJared McNeill 		{ "TX_DMA_STA", EMAC_TX_DMA_STA },
1339d3810ff9SJared McNeill 		{ "TX_DMA_CUR_DESC", EMAC_TX_DMA_CUR_DESC },
1340d3810ff9SJared McNeill 		{ "TX_DMA_CUR_BUF", EMAC_TX_DMA_CUR_BUF },
1341d3810ff9SJared McNeill 		{ "RX_DMA_STA", EMAC_RX_DMA_STA },
1342d3810ff9SJared McNeill 		{ "RX_DMA_CUR_DESC", EMAC_RX_DMA_CUR_DESC },
1343d3810ff9SJared McNeill 		{ "RX_DMA_CUR_BUF", EMAC_RX_DMA_CUR_BUF },
1344d3810ff9SJared McNeill 		{ "RGMII_STA", EMAC_RGMII_STA },
1345d3810ff9SJared McNeill 	};
1346d3810ff9SJared McNeill 	struct awg_softc *sc;
1347d3810ff9SJared McNeill 	unsigned int n;
1348d3810ff9SJared McNeill 
1349d3810ff9SJared McNeill 	sc = device_get_softc(dev);
1350d3810ff9SJared McNeill 
1351d3810ff9SJared McNeill 	for (n = 0; n < nitems(regs); n++)
1352d3810ff9SJared McNeill 		device_printf(dev, "  %-20s %08x\n", regs[n].name,
1353d3810ff9SJared McNeill 		    RD4(sc, regs[n].reg));
1354d3810ff9SJared McNeill }
1355d3810ff9SJared McNeill #endif
1356d3810ff9SJared McNeill 
135701a469b8SJared McNeill #define	GPIO_ACTIVE_LOW		1
135801a469b8SJared McNeill 
135901a469b8SJared McNeill static int
136001a469b8SJared McNeill awg_phy_reset(device_t dev)
136101a469b8SJared McNeill {
136201a469b8SJared McNeill 	pcell_t gpio_prop[4], delay_prop[3];
136301a469b8SJared McNeill 	phandle_t node, gpio_node;
136401a469b8SJared McNeill 	device_t gpio;
136501a469b8SJared McNeill 	uint32_t pin, flags;
136601a469b8SJared McNeill 	uint32_t pin_value;
136701a469b8SJared McNeill 
136801a469b8SJared McNeill 	node = ofw_bus_get_node(dev);
136901a469b8SJared McNeill 	if (OF_getencprop(node, "allwinner,reset-gpio", gpio_prop,
137001a469b8SJared McNeill 	    sizeof(gpio_prop)) <= 0)
137101a469b8SJared McNeill 		return (0);
137201a469b8SJared McNeill 
137301a469b8SJared McNeill 	if (OF_getencprop(node, "allwinner,reset-delays-us", delay_prop,
137401a469b8SJared McNeill 	    sizeof(delay_prop)) <= 0)
137501a469b8SJared McNeill 		return (ENXIO);
137601a469b8SJared McNeill 
137701a469b8SJared McNeill 	gpio_node = OF_node_from_xref(gpio_prop[0]);
137801a469b8SJared McNeill 	if ((gpio = OF_device_from_xref(gpio_prop[0])) == NULL)
137901a469b8SJared McNeill 		return (ENXIO);
138001a469b8SJared McNeill 
138101a469b8SJared McNeill 	if (GPIO_MAP_GPIOS(gpio, node, gpio_node, nitems(gpio_prop) - 1,
138201a469b8SJared McNeill 	    gpio_prop + 1, &pin, &flags) != 0)
138301a469b8SJared McNeill 		return (ENXIO);
138401a469b8SJared McNeill 
138501a469b8SJared McNeill 	pin_value = GPIO_PIN_LOW;
138601a469b8SJared McNeill 	if (OF_hasprop(node, "allwinner,reset-active-low"))
138701a469b8SJared McNeill 		pin_value = GPIO_PIN_HIGH;
138801a469b8SJared McNeill 
138901a469b8SJared McNeill 	if (flags & GPIO_ACTIVE_LOW)
139001a469b8SJared McNeill 		pin_value = !pin_value;
139101a469b8SJared McNeill 
139201a469b8SJared McNeill 	GPIO_PIN_SETFLAGS(gpio, pin, GPIO_PIN_OUTPUT);
139301a469b8SJared McNeill 	GPIO_PIN_SET(gpio, pin, pin_value);
139401a469b8SJared McNeill 	DELAY(delay_prop[0]);
139501a469b8SJared McNeill 	GPIO_PIN_SET(gpio, pin, !pin_value);
139601a469b8SJared McNeill 	DELAY(delay_prop[1]);
139701a469b8SJared McNeill 	GPIO_PIN_SET(gpio, pin, pin_value);
139801a469b8SJared McNeill 	DELAY(delay_prop[2]);
139901a469b8SJared McNeill 
140001a469b8SJared McNeill 	return (0);
140101a469b8SJared McNeill }
140201a469b8SJared McNeill 
1403d3810ff9SJared McNeill static int
1404d3810ff9SJared McNeill awg_reset(device_t dev)
1405d3810ff9SJared McNeill {
1406d3810ff9SJared McNeill 	struct awg_softc *sc;
1407d3810ff9SJared McNeill 	int retry;
1408d3810ff9SJared McNeill 
1409d3810ff9SJared McNeill 	sc = device_get_softc(dev);
1410d3810ff9SJared McNeill 
141101a469b8SJared McNeill 	/* Reset PHY if necessary */
141201a469b8SJared McNeill 	if (awg_phy_reset(dev) != 0) {
141301a469b8SJared McNeill 		device_printf(dev, "failed to reset PHY\n");
141401a469b8SJared McNeill 		return (ENXIO);
141501a469b8SJared McNeill 	}
141601a469b8SJared McNeill 
1417d3810ff9SJared McNeill 	/* Soft reset all registers and logic */
1418d3810ff9SJared McNeill 	WR4(sc, EMAC_BASIC_CTL_1, BASIC_CTL_SOFT_RST);
1419d3810ff9SJared McNeill 
1420d3810ff9SJared McNeill 	/* Wait for soft reset bit to self-clear */
1421d3810ff9SJared McNeill 	for (retry = SOFT_RST_RETRY; retry > 0; retry--) {
1422d3810ff9SJared McNeill 		if ((RD4(sc, EMAC_BASIC_CTL_1) & BASIC_CTL_SOFT_RST) == 0)
1423d3810ff9SJared McNeill 			break;
1424d3810ff9SJared McNeill 		DELAY(10);
1425d3810ff9SJared McNeill 	}
1426d3810ff9SJared McNeill 	if (retry == 0) {
1427d3810ff9SJared McNeill 		device_printf(dev, "soft reset timed out\n");
1428d3810ff9SJared McNeill #ifdef AWG_DEBUG
1429d3810ff9SJared McNeill 		awg_dump_regs(dev);
1430d3810ff9SJared McNeill #endif
1431d3810ff9SJared McNeill 		return (ETIMEDOUT);
1432d3810ff9SJared McNeill 	}
1433d3810ff9SJared McNeill 
1434d3810ff9SJared McNeill 	return (0);
1435d3810ff9SJared McNeill }
1436d3810ff9SJared McNeill 
1437d3810ff9SJared McNeill static void
1438d3810ff9SJared McNeill awg_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1439d3810ff9SJared McNeill {
1440d3810ff9SJared McNeill 	if (error != 0)
1441d3810ff9SJared McNeill 		return;
1442d3810ff9SJared McNeill 	*(bus_addr_t *)arg = segs[0].ds_addr;
1443d3810ff9SJared McNeill }
1444d3810ff9SJared McNeill 
1445d3810ff9SJared McNeill static int
1446d3810ff9SJared McNeill awg_setup_dma(device_t dev)
1447d3810ff9SJared McNeill {
1448d3810ff9SJared McNeill 	struct awg_softc *sc;
1449d3810ff9SJared McNeill 	struct mbuf *m;
1450d3810ff9SJared McNeill 	int error, i;
1451d3810ff9SJared McNeill 
1452d3810ff9SJared McNeill 	sc = device_get_softc(dev);
1453d3810ff9SJared McNeill 
1454d3810ff9SJared McNeill 	/* Setup TX ring */
1455d3810ff9SJared McNeill 	error = bus_dma_tag_create(
1456d3810ff9SJared McNeill 	    bus_get_dma_tag(dev),	/* Parent tag */
1457d3810ff9SJared McNeill 	    DESC_ALIGN, 0,		/* alignment, boundary */
1458d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1459d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR,		/* highaddr */
1460d3810ff9SJared McNeill 	    NULL, NULL,			/* filter, filterarg */
1461d3810ff9SJared McNeill 	    TX_DESC_SIZE, 1,		/* maxsize, nsegs */
1462d3810ff9SJared McNeill 	    TX_DESC_SIZE,		/* maxsegsize */
1463d3810ff9SJared McNeill 	    0,				/* flags */
1464d3810ff9SJared McNeill 	    NULL, NULL,			/* lockfunc, lockarg */
1465d3810ff9SJared McNeill 	    &sc->tx.desc_tag);
1466d3810ff9SJared McNeill 	if (error != 0) {
1467d3810ff9SJared McNeill 		device_printf(dev, "cannot create TX descriptor ring tag\n");
1468d3810ff9SJared McNeill 		return (error);
1469d3810ff9SJared McNeill 	}
1470d3810ff9SJared McNeill 
1471d3810ff9SJared McNeill 	error = bus_dmamem_alloc(sc->tx.desc_tag, (void **)&sc->tx.desc_ring,
1472d3810ff9SJared McNeill 	    BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->tx.desc_map);
1473d3810ff9SJared McNeill 	if (error != 0) {
1474d3810ff9SJared McNeill 		device_printf(dev, "cannot allocate TX descriptor ring\n");
1475d3810ff9SJared McNeill 		return (error);
1476d3810ff9SJared McNeill 	}
1477d3810ff9SJared McNeill 
1478d3810ff9SJared McNeill 	error = bus_dmamap_load(sc->tx.desc_tag, sc->tx.desc_map,
1479d3810ff9SJared McNeill 	    sc->tx.desc_ring, TX_DESC_SIZE, awg_dmamap_cb,
1480d3810ff9SJared McNeill 	    &sc->tx.desc_ring_paddr, 0);
1481d3810ff9SJared McNeill 	if (error != 0) {
1482d3810ff9SJared McNeill 		device_printf(dev, "cannot load TX descriptor ring\n");
1483d3810ff9SJared McNeill 		return (error);
1484d3810ff9SJared McNeill 	}
1485d3810ff9SJared McNeill 
1486d3810ff9SJared McNeill 	for (i = 0; i < TX_DESC_COUNT; i++)
1487d3810ff9SJared McNeill 		sc->tx.desc_ring[i].next =
1488d3810ff9SJared McNeill 		    htole32(sc->tx.desc_ring_paddr + DESC_OFF(TX_NEXT(i)));
1489d3810ff9SJared McNeill 
1490d3810ff9SJared McNeill 	error = bus_dma_tag_create(
1491d3810ff9SJared McNeill 	    bus_get_dma_tag(dev),	/* Parent tag */
1492d3810ff9SJared McNeill 	    1, 0,			/* alignment, boundary */
1493d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1494d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR,		/* highaddr */
1495d3810ff9SJared McNeill 	    NULL, NULL,			/* filter, filterarg */
1496d3810ff9SJared McNeill 	    MCLBYTES, TX_MAX_SEGS,	/* maxsize, nsegs */
1497d3810ff9SJared McNeill 	    MCLBYTES,			/* maxsegsize */
1498d3810ff9SJared McNeill 	    0,				/* flags */
1499d3810ff9SJared McNeill 	    NULL, NULL,			/* lockfunc, lockarg */
1500d3810ff9SJared McNeill 	    &sc->tx.buf_tag);
1501d3810ff9SJared McNeill 	if (error != 0) {
1502d3810ff9SJared McNeill 		device_printf(dev, "cannot create TX buffer tag\n");
1503d3810ff9SJared McNeill 		return (error);
1504d3810ff9SJared McNeill 	}
1505d3810ff9SJared McNeill 
1506d3810ff9SJared McNeill 	sc->tx.queued = TX_DESC_COUNT;
1507d3810ff9SJared McNeill 	for (i = 0; i < TX_DESC_COUNT; i++) {
1508d3810ff9SJared McNeill 		error = bus_dmamap_create(sc->tx.buf_tag, 0,
1509d3810ff9SJared McNeill 		    &sc->tx.buf_map[i].map);
1510d3810ff9SJared McNeill 		if (error != 0) {
1511d3810ff9SJared McNeill 			device_printf(dev, "cannot create TX buffer map\n");
1512d3810ff9SJared McNeill 			return (error);
1513d3810ff9SJared McNeill 		}
1514d3810ff9SJared McNeill 		awg_setup_txdesc(sc, i, 0, 0, 0);
1515d3810ff9SJared McNeill 	}
1516d3810ff9SJared McNeill 
1517d3810ff9SJared McNeill 	/* Setup RX ring */
1518d3810ff9SJared McNeill 	error = bus_dma_tag_create(
1519d3810ff9SJared McNeill 	    bus_get_dma_tag(dev),	/* Parent tag */
1520d3810ff9SJared McNeill 	    DESC_ALIGN, 0,		/* alignment, boundary */
1521d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1522d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR,		/* highaddr */
1523d3810ff9SJared McNeill 	    NULL, NULL,			/* filter, filterarg */
1524d3810ff9SJared McNeill 	    RX_DESC_SIZE, 1,		/* maxsize, nsegs */
1525d3810ff9SJared McNeill 	    RX_DESC_SIZE,		/* maxsegsize */
1526d3810ff9SJared McNeill 	    0,				/* flags */
1527d3810ff9SJared McNeill 	    NULL, NULL,			/* lockfunc, lockarg */
1528d3810ff9SJared McNeill 	    &sc->rx.desc_tag);
1529d3810ff9SJared McNeill 	if (error != 0) {
1530d3810ff9SJared McNeill 		device_printf(dev, "cannot create RX descriptor ring tag\n");
1531d3810ff9SJared McNeill 		return (error);
1532d3810ff9SJared McNeill 	}
1533d3810ff9SJared McNeill 
1534d3810ff9SJared McNeill 	error = bus_dmamem_alloc(sc->rx.desc_tag, (void **)&sc->rx.desc_ring,
1535d3810ff9SJared McNeill 	    BUS_DMA_COHERENT | BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->rx.desc_map);
1536d3810ff9SJared McNeill 	if (error != 0) {
1537d3810ff9SJared McNeill 		device_printf(dev, "cannot allocate RX descriptor ring\n");
1538d3810ff9SJared McNeill 		return (error);
1539d3810ff9SJared McNeill 	}
1540d3810ff9SJared McNeill 
1541d3810ff9SJared McNeill 	error = bus_dmamap_load(sc->rx.desc_tag, sc->rx.desc_map,
1542d3810ff9SJared McNeill 	    sc->rx.desc_ring, RX_DESC_SIZE, awg_dmamap_cb,
1543d3810ff9SJared McNeill 	    &sc->rx.desc_ring_paddr, 0);
1544d3810ff9SJared McNeill 	if (error != 0) {
1545d3810ff9SJared McNeill 		device_printf(dev, "cannot load RX descriptor ring\n");
1546d3810ff9SJared McNeill 		return (error);
1547d3810ff9SJared McNeill 	}
1548d3810ff9SJared McNeill 
1549d3810ff9SJared McNeill 	error = bus_dma_tag_create(
1550d3810ff9SJared McNeill 	    bus_get_dma_tag(dev),	/* Parent tag */
1551d3810ff9SJared McNeill 	    1, 0,			/* alignment, boundary */
1552d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR_32BIT,	/* lowaddr */
1553d3810ff9SJared McNeill 	    BUS_SPACE_MAXADDR,		/* highaddr */
1554d3810ff9SJared McNeill 	    NULL, NULL,			/* filter, filterarg */
1555d3810ff9SJared McNeill 	    MCLBYTES, 1,		/* maxsize, nsegs */
1556d3810ff9SJared McNeill 	    MCLBYTES,			/* maxsegsize */
1557d3810ff9SJared McNeill 	    0,				/* flags */
1558d3810ff9SJared McNeill 	    NULL, NULL,			/* lockfunc, lockarg */
1559d3810ff9SJared McNeill 	    &sc->rx.buf_tag);
1560d3810ff9SJared McNeill 	if (error != 0) {
1561d3810ff9SJared McNeill 		device_printf(dev, "cannot create RX buffer tag\n");
1562d3810ff9SJared McNeill 		return (error);
1563d3810ff9SJared McNeill 	}
1564d3810ff9SJared McNeill 
1565d3810ff9SJared McNeill 	for (i = 0; i < RX_DESC_COUNT; i++) {
1566d3810ff9SJared McNeill 		error = bus_dmamap_create(sc->rx.buf_tag, 0,
1567d3810ff9SJared McNeill 		    &sc->rx.buf_map[i].map);
1568d3810ff9SJared McNeill 		if (error != 0) {
1569d3810ff9SJared McNeill 			device_printf(dev, "cannot create RX buffer map\n");
1570d3810ff9SJared McNeill 			return (error);
1571d3810ff9SJared McNeill 		}
1572d3810ff9SJared McNeill 		if ((m = awg_alloc_mbufcl(sc)) == NULL) {
1573d3810ff9SJared McNeill 			device_printf(dev, "cannot allocate RX mbuf\n");
1574d3810ff9SJared McNeill 			return (ENOMEM);
1575d3810ff9SJared McNeill 		}
1576d3810ff9SJared McNeill 		error = awg_setup_rxbuf(sc, i, m);
1577d3810ff9SJared McNeill 		if (error != 0) {
1578d3810ff9SJared McNeill 			device_printf(dev, "cannot create RX buffer\n");
1579d3810ff9SJared McNeill 			return (error);
1580d3810ff9SJared McNeill 		}
1581d3810ff9SJared McNeill 	}
1582d3810ff9SJared McNeill 	bus_dmamap_sync(sc->rx.desc_tag, sc->rx.desc_map,
1583d3810ff9SJared McNeill 	    BUS_DMASYNC_PREWRITE);
1584d3810ff9SJared McNeill 
1585d3810ff9SJared McNeill 	/* Write transmit and receive descriptor base address registers */
1586d3810ff9SJared McNeill 	WR4(sc, EMAC_TX_DMA_LIST, sc->tx.desc_ring_paddr);
1587d3810ff9SJared McNeill 	WR4(sc, EMAC_RX_DMA_LIST, sc->rx.desc_ring_paddr);
1588d3810ff9SJared McNeill 
1589d3810ff9SJared McNeill 	return (0);
1590d3810ff9SJared McNeill }
1591d3810ff9SJared McNeill 
1592d3810ff9SJared McNeill static int
1593d3810ff9SJared McNeill awg_probe(device_t dev)
1594d3810ff9SJared McNeill {
1595d3810ff9SJared McNeill 	if (!ofw_bus_status_okay(dev))
1596d3810ff9SJared McNeill 		return (ENXIO);
1597d3810ff9SJared McNeill 
1598d3810ff9SJared McNeill 	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
1599d3810ff9SJared McNeill 		return (ENXIO);
1600d3810ff9SJared McNeill 
1601d3810ff9SJared McNeill 	device_set_desc(dev, "Allwinner Gigabit Ethernet");
1602d3810ff9SJared McNeill 	return (BUS_PROBE_DEFAULT);
1603d3810ff9SJared McNeill }
1604d3810ff9SJared McNeill 
1605d3810ff9SJared McNeill static int
1606d3810ff9SJared McNeill awg_attach(device_t dev)
1607d3810ff9SJared McNeill {
1608d3810ff9SJared McNeill 	uint8_t eaddr[ETHER_ADDR_LEN];
1609d3810ff9SJared McNeill 	struct awg_softc *sc;
1610d3810ff9SJared McNeill 	phandle_t node;
1611d3810ff9SJared McNeill 	int error;
1612d3810ff9SJared McNeill 
1613d3810ff9SJared McNeill 	sc = device_get_softc(dev);
161401a469b8SJared McNeill 	sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
1615d3810ff9SJared McNeill 	node = ofw_bus_get_node(dev);
1616d3810ff9SJared McNeill 
1617d3810ff9SJared McNeill 	if (bus_alloc_resources(dev, awg_spec, sc->res) != 0) {
1618d3810ff9SJared McNeill 		device_printf(dev, "cannot allocate resources for device\n");
1619d3810ff9SJared McNeill 		return (ENXIO);
1620d3810ff9SJared McNeill 	}
1621d3810ff9SJared McNeill 
1622d3810ff9SJared McNeill 	mtx_init(&sc->mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, MTX_DEF);
1623d3810ff9SJared McNeill 	callout_init_mtx(&sc->stat_ch, &sc->mtx, 0);
1624d3810ff9SJared McNeill 	TASK_INIT(&sc->link_task, 0, awg_link_task, sc);
1625d3810ff9SJared McNeill 
1626d3810ff9SJared McNeill 	/* Setup clocks and regulators */
1627d3810ff9SJared McNeill 	error = awg_setup_extres(dev);
1628d3810ff9SJared McNeill 	if (error != 0)
1629d3810ff9SJared McNeill 		return (error);
1630d3810ff9SJared McNeill 
1631d3810ff9SJared McNeill 	/* Read MAC address before resetting the chip */
1632d3810ff9SJared McNeill 	awg_get_eaddr(dev, eaddr);
1633d3810ff9SJared McNeill 
1634d3810ff9SJared McNeill 	/* Soft reset EMAC core */
1635d3810ff9SJared McNeill 	error = awg_reset(dev);
1636d3810ff9SJared McNeill 	if (error != 0)
1637d3810ff9SJared McNeill 		return (error);
1638d3810ff9SJared McNeill 
1639d3810ff9SJared McNeill 	/* Setup DMA descriptors */
1640d3810ff9SJared McNeill 	error = awg_setup_dma(dev);
1641d3810ff9SJared McNeill 	if (error != 0)
1642d3810ff9SJared McNeill 		return (error);
1643d3810ff9SJared McNeill 
1644d3810ff9SJared McNeill 	/* Install interrupt handler */
164501a469b8SJared McNeill 	error = bus_setup_intr(dev, sc->res[_RES_IRQ],
164601a469b8SJared McNeill 	    INTR_TYPE_NET | INTR_MPSAFE, NULL, awg_intr, sc, &sc->ih);
1647d3810ff9SJared McNeill 	if (error != 0) {
1648d3810ff9SJared McNeill 		device_printf(dev, "cannot setup interrupt handler\n");
1649d3810ff9SJared McNeill 		return (error);
1650d3810ff9SJared McNeill 	}
1651d3810ff9SJared McNeill 
1652d3810ff9SJared McNeill 	/* Setup ethernet interface */
1653d3810ff9SJared McNeill 	sc->ifp = if_alloc(IFT_ETHER);
1654d3810ff9SJared McNeill 	if_setsoftc(sc->ifp, sc);
1655d3810ff9SJared McNeill 	if_initname(sc->ifp, device_get_name(dev), device_get_unit(dev));
1656d3810ff9SJared McNeill 	if_setflags(sc->ifp, IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
1657d3810ff9SJared McNeill 	if_setstartfn(sc->ifp, awg_start);
1658d3810ff9SJared McNeill 	if_setioctlfn(sc->ifp, awg_ioctl);
1659d3810ff9SJared McNeill 	if_setinitfn(sc->ifp, awg_init);
1660d3810ff9SJared McNeill 	if_setsendqlen(sc->ifp, TX_DESC_COUNT - 1);
1661d3810ff9SJared McNeill 	if_setsendqready(sc->ifp);
1662d3810ff9SJared McNeill 	if_sethwassist(sc->ifp, CSUM_IP | CSUM_UDP | CSUM_TCP);
1663d3810ff9SJared McNeill 	if_setcapabilities(sc->ifp, IFCAP_VLAN_MTU | IFCAP_HWCSUM);
1664d3810ff9SJared McNeill 	if_setcapenable(sc->ifp, if_getcapabilities(sc->ifp));
166516928528SJared McNeill #ifdef DEVICE_POLLING
166616928528SJared McNeill 	if_setcapabilitiesbit(sc->ifp, IFCAP_POLLING, 0);
166716928528SJared McNeill #endif
1668d3810ff9SJared McNeill 
1669d3810ff9SJared McNeill 	/* Attach MII driver */
1670d3810ff9SJared McNeill 	error = mii_attach(dev, &sc->miibus, sc->ifp, awg_media_change,
1671d3810ff9SJared McNeill 	    awg_media_status, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY,
1672d3810ff9SJared McNeill 	    MIIF_DOPAUSE);
1673d3810ff9SJared McNeill 	if (error != 0) {
1674d3810ff9SJared McNeill 		device_printf(dev, "cannot attach PHY\n");
1675d3810ff9SJared McNeill 		return (error);
1676d3810ff9SJared McNeill 	}
1677d3810ff9SJared McNeill 
1678d3810ff9SJared McNeill 	/* Attach ethernet interface */
1679d3810ff9SJared McNeill 	ether_ifattach(sc->ifp, eaddr);
1680d3810ff9SJared McNeill 
1681d3810ff9SJared McNeill 	return (0);
1682d3810ff9SJared McNeill }
1683d3810ff9SJared McNeill 
1684d3810ff9SJared McNeill static device_method_t awg_methods[] = {
1685d3810ff9SJared McNeill 	/* Device interface */
1686d3810ff9SJared McNeill 	DEVMETHOD(device_probe,		awg_probe),
1687d3810ff9SJared McNeill 	DEVMETHOD(device_attach,	awg_attach),
1688d3810ff9SJared McNeill 
1689d3810ff9SJared McNeill 	/* MII interface */
1690d3810ff9SJared McNeill 	DEVMETHOD(miibus_readreg,	awg_miibus_readreg),
1691d3810ff9SJared McNeill 	DEVMETHOD(miibus_writereg,	awg_miibus_writereg),
1692d3810ff9SJared McNeill 	DEVMETHOD(miibus_statchg,	awg_miibus_statchg),
1693d3810ff9SJared McNeill 
1694d3810ff9SJared McNeill 	DEVMETHOD_END
1695d3810ff9SJared McNeill };
1696d3810ff9SJared McNeill 
1697d3810ff9SJared McNeill static driver_t awg_driver = {
1698d3810ff9SJared McNeill 	"awg",
1699d3810ff9SJared McNeill 	awg_methods,
1700d3810ff9SJared McNeill 	sizeof(struct awg_softc),
1701d3810ff9SJared McNeill };
1702d3810ff9SJared McNeill 
1703d3810ff9SJared McNeill static devclass_t awg_devclass;
1704d3810ff9SJared McNeill 
1705d3810ff9SJared McNeill DRIVER_MODULE(awg, simplebus, awg_driver, awg_devclass, 0, 0);
1706d3810ff9SJared McNeill DRIVER_MODULE(miibus, awg, miibus_driver, miibus_devclass, 0, 0);
1707d3810ff9SJared McNeill 
1708d3810ff9SJared McNeill MODULE_DEPEND(awg, ether, 1, 1, 1);
1709d3810ff9SJared McNeill MODULE_DEPEND(awg, miibus, 1, 1, 1);
1710