2 * Copyright (c) 2009, Oleksandr Tymoshenko
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice unmodified, this list of conditions, and the following
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
32 * AR71XX gigabit ethernet driver
34 #ifdef HAVE_KERNEL_OPTION_HEADERS
35 #include "opt_device_polling.h"
40 #include <sys/param.h>
41 #include <sys/endian.h>
42 #include <sys/systm.h>
43 #include <sys/sockio.h>
45 #include <sys/malloc.h>
46 #include <sys/kernel.h>
47 #include <sys/module.h>
48 #include <sys/socket.h>
49 #include <sys/taskqueue.h>
50 #include <sys/sysctl.h>
53 #include <net/if_arp.h>
54 #include <net/ethernet.h>
55 #include <net/if_dl.h>
56 #include <net/if_media.h>
57 #include <net/if_types.h>
61 #include <machine/bus.h>
62 #include <machine/cache.h>
63 #include <machine/resource.h>
64 #include <vm/vm_param.h>
67 #include <machine/pmap.h>
71 #include <dev/mii/mii.h>
72 #include <dev/mii/miivar.h>
74 #include <dev/pci/pcireg.h>
75 #include <dev/pci/pcivar.h>
79 #if defined(ARGE_MDIO)
80 #include <dev/etherswitch/mdio.h>
81 #include <dev/etherswitch/miiproxy.h>
86 MODULE_DEPEND(arge, ether, 1, 1, 1);
87 MODULE_DEPEND(arge, miibus, 1, 1, 1);
88 MODULE_VERSION(arge, 1);
90 #include "miibus_if.h"
92 #include <mips/atheros/ar71xxreg.h>
93 #include <mips/atheros/if_argevar.h>
94 #include <mips/atheros/ar71xx_setup.h>
95 #include <mips/atheros/ar71xx_cpudef.h>
98 ARGE_DBG_MII = 0x00000001,
99 ARGE_DBG_INTR = 0x00000002,
100 ARGE_DBG_TX = 0x00000004,
101 ARGE_DBG_RX = 0x00000008,
102 ARGE_DBG_ERR = 0x00000010,
103 ARGE_DBG_RESET = 0x00000020,
104 ARGE_DBG_PLL = 0x00000040,
107 static const char * arge_miicfg_str[] = {
116 #define ARGEDEBUG(_sc, _m, ...) \
118 if ((_m) & (_sc)->arge_debug) \
119 device_printf((_sc)->arge_dev, __VA_ARGS__); \
122 #define ARGEDEBUG(_sc, _m, ...)
125 static int arge_attach(device_t);
126 static int arge_detach(device_t);
127 static void arge_flush_ddr(struct arge_softc *);
128 static int arge_ifmedia_upd(struct ifnet *);
129 static void arge_ifmedia_sts(struct ifnet *, struct ifmediareq *);
130 static int arge_ioctl(struct ifnet *, u_long, caddr_t);
131 static void arge_init(void *);
132 static void arge_init_locked(struct arge_softc *);
133 static void arge_link_task(void *, int);
134 static void arge_update_link_locked(struct arge_softc *sc);
135 static void arge_set_pll(struct arge_softc *, int, int);
136 static int arge_miibus_readreg(device_t, int, int);
137 static void arge_miibus_statchg(device_t);
138 static int arge_miibus_writereg(device_t, int, int, int);
139 static int arge_probe(device_t);
140 static void arge_reset_dma(struct arge_softc *);
141 static int arge_resume(device_t);
142 static int arge_rx_ring_init(struct arge_softc *);
143 static void arge_rx_ring_free(struct arge_softc *sc);
144 static int arge_tx_ring_init(struct arge_softc *);
145 static void arge_tx_ring_free(struct arge_softc *);
146 #ifdef DEVICE_POLLING
147 static int arge_poll(struct ifnet *, enum poll_cmd, int);
149 static int arge_shutdown(device_t);
150 static void arge_start(struct ifnet *);
151 static void arge_start_locked(struct ifnet *);
152 static void arge_stop(struct arge_softc *);
153 static int arge_suspend(device_t);
155 static int arge_rx_locked(struct arge_softc *);
156 static void arge_tx_locked(struct arge_softc *);
157 static void arge_intr(void *);
158 static int arge_intr_filter(void *);
159 static void arge_tick(void *);
161 static void arge_hinted_child(device_t bus, const char *dname, int dunit);
164 * ifmedia callbacks for multiPHY MAC
166 void arge_multiphy_mediastatus(struct ifnet *, struct ifmediareq *);
167 int arge_multiphy_mediachange(struct ifnet *);
169 static void arge_dmamap_cb(void *, bus_dma_segment_t *, int, int);
170 static int arge_dma_alloc(struct arge_softc *);
171 static void arge_dma_free(struct arge_softc *);
172 static int arge_newbuf(struct arge_softc *, int);
173 static __inline void arge_fixup_rx(struct mbuf *);
175 static device_method_t arge_methods[] = {
176 /* Device interface */
177 DEVMETHOD(device_probe, arge_probe),
178 DEVMETHOD(device_attach, arge_attach),
179 DEVMETHOD(device_detach, arge_detach),
180 DEVMETHOD(device_suspend, arge_suspend),
181 DEVMETHOD(device_resume, arge_resume),
182 DEVMETHOD(device_shutdown, arge_shutdown),
185 DEVMETHOD(miibus_readreg, arge_miibus_readreg),
186 DEVMETHOD(miibus_writereg, arge_miibus_writereg),
187 DEVMETHOD(miibus_statchg, arge_miibus_statchg),
190 DEVMETHOD(bus_add_child, device_add_child_ordered),
191 DEVMETHOD(bus_hinted_child, arge_hinted_child),
196 static driver_t arge_driver = {
199 sizeof(struct arge_softc)
202 static devclass_t arge_devclass;
204 DRIVER_MODULE(arge, nexus, arge_driver, arge_devclass, 0, 0);
205 DRIVER_MODULE(miibus, arge, miibus_driver, miibus_devclass, 0, 0);
207 #if defined(ARGE_MDIO)
208 static int argemdio_probe(device_t);
209 static int argemdio_attach(device_t);
210 static int argemdio_detach(device_t);
213 * Declare an additional, separate driver for accessing the MDIO bus.
215 static device_method_t argemdio_methods[] = {
216 /* Device interface */
217 DEVMETHOD(device_probe, argemdio_probe),
218 DEVMETHOD(device_attach, argemdio_attach),
219 DEVMETHOD(device_detach, argemdio_detach),
222 DEVMETHOD(bus_add_child, device_add_child_ordered),
225 DEVMETHOD(mdio_readreg, arge_miibus_readreg),
226 DEVMETHOD(mdio_writereg, arge_miibus_writereg),
229 DEFINE_CLASS_0(argemdio, argemdio_driver, argemdio_methods,
230 sizeof(struct arge_softc));
231 static devclass_t argemdio_devclass;
233 DRIVER_MODULE(miiproxy, arge, miiproxy_driver, miiproxy_devclass, 0, 0);
234 DRIVER_MODULE(argemdio, nexus, argemdio_driver, argemdio_devclass, 0, 0);
235 DRIVER_MODULE(mdio, argemdio, mdio_driver, mdio_devclass, 0, 0);
239 * RedBoot passes MAC address to entry point as environment
240 * variable. platfrom_start parses it and stores in this variable
242 extern uint32_t ar711_base_mac[ETHER_ADDR_LEN];
244 static struct mtx miibus_mtx;
246 MTX_SYSINIT(miibus_mtx, &miibus_mtx, "arge mii lock", MTX_DEF);
252 arge_flush_ddr(struct arge_softc *sc)
255 ar71xx_device_flush_ddr_ge(sc->arge_mac_unit);
259 arge_probe(device_t dev)
262 device_set_desc(dev, "Atheros AR71xx built-in ethernet interface");
267 arge_attach_sysctl(device_t dev)
269 struct arge_softc *sc = device_get_softc(dev);
270 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
271 struct sysctl_oid *tree = device_get_sysctl_tree(dev);
274 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
275 "debug", CTLFLAG_RW, &sc->arge_debug, 0,
276 "arge interface debugging flags");
279 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
280 "tx_pkts_aligned", CTLFLAG_RW, &sc->stats.tx_pkts_aligned, 0,
281 "number of TX aligned packets");
283 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
284 "tx_pkts_unaligned", CTLFLAG_RW, &sc->stats.tx_pkts_unaligned,
285 0, "number of TX unaligned packets");
288 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tx_prod",
289 CTLFLAG_RW, &sc->arge_cdata.arge_tx_prod, 0, "");
290 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tx_cons",
291 CTLFLAG_RW, &sc->arge_cdata.arge_tx_cons, 0, "");
292 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tx_cnt",
293 CTLFLAG_RW, &sc->arge_cdata.arge_tx_cnt, 0, "");
298 arge_reset_mac(struct arge_softc *sc)
302 /* Step 1. Soft-reset MAC */
303 ARGE_SET_BITS(sc, AR71XX_MAC_CFG1, MAC_CFG1_SOFT_RESET);
306 /* Step 2. Punt the MAC core from the central reset register */
307 ar71xx_device_stop(sc->arge_mac_unit == 0 ? RST_RESET_GE0_MAC :
310 ar71xx_device_start(sc->arge_mac_unit == 0 ? RST_RESET_GE0_MAC :
313 /* Step 3. Reconfigure MAC block */
314 ARGE_WRITE(sc, AR71XX_MAC_CFG1,
315 MAC_CFG1_SYNC_RX | MAC_CFG1_RX_ENABLE |
316 MAC_CFG1_SYNC_TX | MAC_CFG1_TX_ENABLE);
318 reg = ARGE_READ(sc, AR71XX_MAC_CFG2);
319 reg |= MAC_CFG2_ENABLE_PADCRC | MAC_CFG2_LENGTH_FIELD ;
320 ARGE_WRITE(sc, AR71XX_MAC_CFG2, reg);
322 ARGE_WRITE(sc, AR71XX_MAC_MAX_FRAME_LEN, 1536);
326 arge_reset_miibus(struct arge_softc *sc)
330 ARGE_WRITE(sc, AR71XX_MAC_MII_CFG, MAC_MII_CFG_RESET);
332 ARGE_WRITE(sc, AR71XX_MAC_MII_CFG, MAC_MII_CFG_CLOCK_DIV_28);
337 arge_fetch_pll_config(struct arge_softc *sc)
341 if (resource_long_value(device_get_name(sc->arge_dev),
342 device_get_unit(sc->arge_dev),
343 "pll_10", &val) == 0) {
344 sc->arge_pllcfg.pll_10 = val;
345 device_printf(sc->arge_dev, "%s: pll_10 = 0x%x\n",
346 __func__, (int) val);
348 if (resource_long_value(device_get_name(sc->arge_dev),
349 device_get_unit(sc->arge_dev),
350 "pll_100", &val) == 0) {
351 sc->arge_pllcfg.pll_100 = val;
352 device_printf(sc->arge_dev, "%s: pll_100 = 0x%x\n",
353 __func__, (int) val);
355 if (resource_long_value(device_get_name(sc->arge_dev),
356 device_get_unit(sc->arge_dev),
357 "pll_1000", &val) == 0) {
358 sc->arge_pllcfg.pll_1000 = val;
359 device_printf(sc->arge_dev, "%s: pll_1000 = 0x%x\n",
360 __func__, (int) val);
365 arge_attach(device_t dev)
368 struct arge_softc *sc;
371 int is_base_mac_empty, i;
373 long eeprom_mac_addr = 0;
377 sc = device_get_softc(dev);
379 sc->arge_mac_unit = device_get_unit(dev);
382 * Some units (eg the TP-Link WR-1043ND) do not have a convenient
383 * EEPROM location to read the ethernet MAC address from.
384 * OpenWRT simply snaffles it from a fixed location.
386 * Since multiple units seem to use this feature, include
387 * a method of setting the MAC address based on an flash location
388 * in CPU address space.
390 * Some vendors have decided to store the mac address as a literal
391 * string of 18 characters in xx:xx:xx:xx:xx:xx format instead of
392 * an array of numbers. Expose a hint to turn on this conversion
393 * feature via strtol()
395 if (resource_long_value(device_get_name(dev), device_get_unit(dev),
396 "eeprommac", &eeprom_mac_addr) == 0) {
399 (const char *) MIPS_PHYS_TO_KSEG1(eeprom_mac_addr);
400 device_printf(dev, "Overriding MAC from EEPROM\n");
401 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
402 "readascii", &readascii) == 0) {
403 device_printf(dev, "Vendor stores MAC in ASCII format\n");
404 for (i = 0; i < 6; i++) {
405 ar711_base_mac[i] = strtol(&(mac[i*3]), NULL, 16);
408 for (i = 0; i < 6; i++) {
409 ar711_base_mac[i] = mac[i];
414 KASSERT(((sc->arge_mac_unit == 0) || (sc->arge_mac_unit == 1)),
415 ("if_arge: Only MAC0 and MAC1 supported"));
418 * Fetch the PLL configuration.
420 arge_fetch_pll_config(sc);
423 * Get the MII configuration, if applicable.
425 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
426 "miimode", &miicfg) == 0) {
427 /* XXX bounds check? */
428 device_printf(dev, "%s: overriding MII mode to '%s'\n",
429 __func__, arge_miicfg_str[miicfg]);
430 sc->arge_miicfg = miicfg;
434 * Get which PHY of 5 available we should use for this unit
436 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
437 "phymask", &sc->arge_phymask) != 0) {
439 * Use port 4 (WAN) for GE0. For any other port use
440 * its PHY the same as its unit number
442 if (sc->arge_mac_unit == 0)
443 sc->arge_phymask = (1 << 4);
445 /* Use all phys up to 4 */
446 sc->arge_phymask = (1 << 4) - 1;
448 device_printf(dev, "No PHY specified, using mask %d\n", sc->arge_phymask);
452 * Get default media & duplex mode, by default its Base100T
455 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
456 "media", &hint) != 0)
460 sc->arge_media_type = IFM_1000_T;
462 sc->arge_media_type = IFM_100_TX;
464 if (resource_int_value(device_get_name(dev), device_get_unit(dev),
465 "fduplex", &hint) != 0)
469 sc->arge_duplex_mode = IFM_FDX;
471 sc->arge_duplex_mode = 0;
473 mtx_init(&sc->arge_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
475 callout_init_mtx(&sc->arge_stat_callout, &sc->arge_mtx, 0);
476 TASK_INIT(&sc->arge_link_task, 0, arge_link_task, sc);
478 /* Map control/status registers. */
480 sc->arge_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
481 &sc->arge_rid, RF_ACTIVE | RF_SHAREABLE);
483 if (sc->arge_res == NULL) {
484 device_printf(dev, "couldn't map memory\n");
489 /* Allocate interrupts */
491 sc->arge_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
492 RF_SHAREABLE | RF_ACTIVE);
494 if (sc->arge_irq == NULL) {
495 device_printf(dev, "couldn't map interrupt\n");
500 /* Allocate ifnet structure. */
501 ifp = sc->arge_ifp = if_alloc(IFT_ETHER);
504 device_printf(dev, "couldn't allocate ifnet structure\n");
510 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
511 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
512 ifp->if_ioctl = arge_ioctl;
513 ifp->if_start = arge_start;
514 ifp->if_init = arge_init;
515 sc->arge_if_flags = ifp->if_flags;
517 /* XXX: add real size */
518 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
519 ifp->if_snd.ifq_maxlen = ifqmaxlen;
520 IFQ_SET_READY(&ifp->if_snd);
522 ifp->if_capenable = ifp->if_capabilities;
523 #ifdef DEVICE_POLLING
524 ifp->if_capabilities |= IFCAP_POLLING;
527 is_base_mac_empty = 1;
528 for (i = 0; i < ETHER_ADDR_LEN; i++) {
529 sc->arge_eaddr[i] = ar711_base_mac[i] & 0xff;
530 if (sc->arge_eaddr[i] != 0)
531 is_base_mac_empty = 0;
534 if (is_base_mac_empty) {
536 * No MAC address configured. Generate the random one.
540 "Generating random ethernet address.\n");
543 sc->arge_eaddr[0] = 'b';
544 sc->arge_eaddr[1] = 's';
545 sc->arge_eaddr[2] = 'd';
546 sc->arge_eaddr[3] = (rnd >> 24) & 0xff;
547 sc->arge_eaddr[4] = (rnd >> 16) & 0xff;
548 sc->arge_eaddr[5] = (rnd >> 8) & 0xff;
550 if (sc->arge_mac_unit != 0)
551 sc->arge_eaddr[5] += sc->arge_mac_unit;
553 if (arge_dma_alloc(sc) != 0) {
559 * Don't do this for the MDIO bus case - it's already done
560 * as part of the MDIO bus attachment.
562 #if !defined(ARGE_MDIO)
563 /* Initialize the MAC block */
565 arge_reset_miibus(sc);
568 /* Configure MII mode, just for convienence */
569 if (sc->arge_miicfg != 0)
570 ar71xx_device_set_mii_if(sc->arge_mac_unit, sc->arge_miicfg);
573 * Set all Ethernet address registers to the same initial values
574 * set all four addresses to 66-88-aa-cc-dd-ee
576 ARGE_WRITE(sc, AR71XX_MAC_STA_ADDR1, (sc->arge_eaddr[2] << 24)
577 | (sc->arge_eaddr[3] << 16) | (sc->arge_eaddr[4] << 8)
578 | sc->arge_eaddr[5]);
579 ARGE_WRITE(sc, AR71XX_MAC_STA_ADDR2, (sc->arge_eaddr[0] << 8)
580 | sc->arge_eaddr[1]);
582 ARGE_WRITE(sc, AR71XX_MAC_FIFO_CFG0,
583 FIFO_CFG0_ALL << FIFO_CFG0_ENABLE_SHIFT);
585 switch (ar71xx_soc) {
586 case AR71XX_SOC_AR7240:
587 case AR71XX_SOC_AR7241:
588 case AR71XX_SOC_AR7242:
589 case AR71XX_SOC_AR9330:
590 case AR71XX_SOC_AR9331:
591 ARGE_WRITE(sc, AR71XX_MAC_FIFO_CFG1, 0x0010ffff);
592 ARGE_WRITE(sc, AR71XX_MAC_FIFO_CFG2, 0x015500aa);
595 ARGE_WRITE(sc, AR71XX_MAC_FIFO_CFG1, 0x0fff0000);
596 ARGE_WRITE(sc, AR71XX_MAC_FIFO_CFG2, 0x00001fff);
599 ARGE_WRITE(sc, AR71XX_MAC_FIFO_RX_FILTMATCH,
600 FIFO_RX_FILTMATCH_DEFAULT);
602 ARGE_WRITE(sc, AR71XX_MAC_FIFO_RX_FILTMASK,
603 FIFO_RX_FILTMASK_DEFAULT);
605 #if defined(ARGE_MDIO)
606 sc->arge_miiproxy = mii_attach_proxy(sc->arge_dev);
609 device_printf(sc->arge_dev, "finishing attachment, phymask %04x"
610 ", proxy %s \n", sc->arge_phymask, sc->arge_miiproxy == NULL ?
612 for (i = 0; i < ARGE_NPHY; i++) {
613 if (((1 << i) & sc->arge_phymask) != 0) {
614 error = mii_attach(sc->arge_miiproxy != NULL ?
615 sc->arge_miiproxy : sc->arge_dev,
616 &sc->arge_miibus, sc->arge_ifp,
617 arge_ifmedia_upd, arge_ifmedia_sts,
618 BMSR_DEFCAPMASK, i, MII_OFFSET_ANY, 0);
620 device_printf(sc->arge_dev, "unable to attach"
621 " PHY %d: %d\n", i, error);
626 if (sc->arge_miibus == NULL) {
627 /* no PHY, so use hard-coded values */
628 ifmedia_init(&sc->arge_ifmedia, 0,
629 arge_multiphy_mediachange,
630 arge_multiphy_mediastatus);
631 ifmedia_add(&sc->arge_ifmedia,
632 IFM_ETHER | sc->arge_media_type | sc->arge_duplex_mode,
634 ifmedia_set(&sc->arge_ifmedia,
635 IFM_ETHER | sc->arge_media_type | sc->arge_duplex_mode);
636 arge_set_pll(sc, sc->arge_media_type, sc->arge_duplex_mode);
639 /* Call MI attach routine. */
640 ether_ifattach(sc->arge_ifp, sc->arge_eaddr);
642 /* Hook interrupt last to avoid having to lock softc */
643 error = bus_setup_intr(sc->arge_dev, sc->arge_irq, INTR_TYPE_NET | INTR_MPSAFE,
644 arge_intr_filter, arge_intr, sc, &sc->arge_intrhand);
647 device_printf(sc->arge_dev, "couldn't set up irq\n");
648 ether_ifdetach(sc->arge_ifp);
652 /* setup sysctl variables */
653 arge_attach_sysctl(sc->arge_dev);
663 arge_detach(device_t dev)
665 struct arge_softc *sc = device_get_softc(dev);
666 struct ifnet *ifp = sc->arge_ifp;
668 KASSERT(mtx_initialized(&sc->arge_mtx),
669 ("arge mutex not initialized"));
671 /* These should only be active if attach succeeded */
672 if (device_is_attached(dev)) {
675 #ifdef DEVICE_POLLING
676 if (ifp->if_capenable & IFCAP_POLLING)
677 ether_poll_deregister(ifp);
682 taskqueue_drain(taskqueue_swi, &sc->arge_link_task);
687 device_delete_child(dev, sc->arge_miibus);
689 if (sc->arge_miiproxy)
690 device_delete_child(dev, sc->arge_miiproxy);
692 bus_generic_detach(dev);
694 if (sc->arge_intrhand)
695 bus_teardown_intr(dev, sc->arge_irq, sc->arge_intrhand);
698 bus_release_resource(dev, SYS_RES_MEMORY, sc->arge_rid,
706 mtx_destroy(&sc->arge_mtx);
713 arge_suspend(device_t dev)
716 panic("%s", __func__);
721 arge_resume(device_t dev)
724 panic("%s", __func__);
729 arge_shutdown(device_t dev)
731 struct arge_softc *sc;
733 sc = device_get_softc(dev);
743 arge_hinted_child(device_t bus, const char *dname, int dunit)
745 BUS_ADD_CHILD(bus, 0, dname, dunit);
746 device_printf(bus, "hinted child %s%d\n", dname, dunit);
750 arge_miibus_readreg(device_t dev, int phy, int reg)
752 struct arge_softc * sc = device_get_softc(dev);
754 uint32_t addr = (phy << MAC_MII_PHY_ADDR_SHIFT)
755 | (reg & MAC_MII_REG_MASK);
757 mtx_lock(&miibus_mtx);
758 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_CMD, MAC_MII_CMD_WRITE);
759 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_ADDR, addr);
760 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_CMD, MAC_MII_CMD_READ);
762 i = ARGE_MII_TIMEOUT;
763 while ((ARGE_MDIO_READ(sc, AR71XX_MAC_MII_INDICATOR) &
764 MAC_MII_INDICATOR_BUSY) && (i--))
768 mtx_unlock(&miibus_mtx);
769 ARGEDEBUG(sc, ARGE_DBG_MII, "%s timedout\n", __func__);
770 /* XXX: return ERRNO istead? */
774 result = ARGE_MDIO_READ(sc, AR71XX_MAC_MII_STATUS) & MAC_MII_STATUS_MASK;
775 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_CMD, MAC_MII_CMD_WRITE);
776 mtx_unlock(&miibus_mtx);
778 ARGEDEBUG(sc, ARGE_DBG_MII,
779 "%s: phy=%d, reg=%02x, value[%08x]=%04x\n",
780 __func__, phy, reg, addr, result);
786 arge_miibus_writereg(device_t dev, int phy, int reg, int data)
788 struct arge_softc * sc = device_get_softc(dev);
791 (phy << MAC_MII_PHY_ADDR_SHIFT) | (reg & MAC_MII_REG_MASK);
793 ARGEDEBUG(sc, ARGE_DBG_MII, "%s: phy=%d, reg=%02x, value=%04x\n", __func__,
796 mtx_lock(&miibus_mtx);
797 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_ADDR, addr);
798 ARGE_MDIO_WRITE(sc, AR71XX_MAC_MII_CONTROL, data);
800 i = ARGE_MII_TIMEOUT;
801 while ((ARGE_MDIO_READ(sc, AR71XX_MAC_MII_INDICATOR) &
802 MAC_MII_INDICATOR_BUSY) && (i--))
805 mtx_unlock(&miibus_mtx);
808 ARGEDEBUG(sc, ARGE_DBG_MII, "%s timedout\n", __func__);
809 /* XXX: return ERRNO istead? */
817 arge_miibus_statchg(device_t dev)
819 struct arge_softc *sc;
821 sc = device_get_softc(dev);
822 taskqueue_enqueue(taskqueue_swi, &sc->arge_link_task);
826 arge_link_task(void *arg, int pending)
828 struct arge_softc *sc;
829 sc = (struct arge_softc *)arg;
832 arge_update_link_locked(sc);
837 arge_update_link_locked(struct arge_softc *sc)
839 struct mii_data *mii;
841 uint32_t media, duplex;
843 mii = device_get_softc(sc->arge_miibus);
845 if (mii == NULL || ifp == NULL ||
846 (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
850 if (mii->mii_media_status & IFM_ACTIVE) {
852 media = IFM_SUBTYPE(mii->mii_media_active);
853 if (media != IFM_NONE) {
854 sc->arge_link_status = 1;
855 duplex = mii->mii_media_active & IFM_GMASK;
856 ARGEDEBUG(sc, ARGE_DBG_MII, "%s: media=%d, duplex=%d\n",
860 arge_set_pll(sc, media, duplex);
863 sc->arge_link_status = 0;
868 arge_set_pll(struct arge_softc *sc, int media, int duplex)
870 uint32_t cfg, ifcontrol, rx_filtmask;
871 uint32_t fifo_tx, pll;
874 ARGEDEBUG(sc, ARGE_DBG_PLL, "set_pll(%04x, %s)\n", media,
875 duplex == IFM_FDX ? "full" : "half");
876 cfg = ARGE_READ(sc, AR71XX_MAC_CFG2);
877 cfg &= ~(MAC_CFG2_IFACE_MODE_1000
878 | MAC_CFG2_IFACE_MODE_10_100
879 | MAC_CFG2_FULL_DUPLEX);
881 if (duplex == IFM_FDX)
882 cfg |= MAC_CFG2_FULL_DUPLEX;
884 ifcontrol = ARGE_READ(sc, AR71XX_MAC_IFCONTROL);
885 ifcontrol &= ~MAC_IFCONTROL_SPEED;
887 ARGE_READ(sc, AR71XX_MAC_FIFO_RX_FILTMASK);
888 rx_filtmask &= ~FIFO_RX_MASK_BYTE_MODE;
892 cfg |= MAC_CFG2_IFACE_MODE_10_100;
896 cfg |= MAC_CFG2_IFACE_MODE_10_100;
897 ifcontrol |= MAC_IFCONTROL_SPEED;
902 cfg |= MAC_CFG2_IFACE_MODE_1000;
903 rx_filtmask |= FIFO_RX_MASK_BYTE_MODE;
908 device_printf(sc->arge_dev,
909 "Unknown media %d\n", media);
912 ARGEDEBUG(sc, ARGE_DBG_PLL, "%s: if_speed=%d\n", __func__, if_speed);
914 switch (ar71xx_soc) {
915 case AR71XX_SOC_AR7240:
916 case AR71XX_SOC_AR7241:
917 case AR71XX_SOC_AR7242:
918 case AR71XX_SOC_AR9330:
919 case AR71XX_SOC_AR9331:
920 fifo_tx = 0x01f00140;
922 case AR71XX_SOC_AR9130:
923 case AR71XX_SOC_AR9132:
924 fifo_tx = 0x00780fff;
927 fifo_tx = 0x008001ff;
930 ARGE_WRITE(sc, AR71XX_MAC_CFG2, cfg);
931 ARGE_WRITE(sc, AR71XX_MAC_IFCONTROL, ifcontrol);
932 ARGE_WRITE(sc, AR71XX_MAC_FIFO_RX_FILTMASK,
934 ARGE_WRITE(sc, AR71XX_MAC_FIFO_TX_THRESHOLD, fifo_tx);
936 /* fetch PLL registers */
937 pll = ar71xx_device_get_eth_pll(sc->arge_mac_unit, if_speed);
938 ARGEDEBUG(sc, ARGE_DBG_PLL, "%s: pll=0x%x\n", __func__, pll);
940 /* Override if required by platform data */
941 if (if_speed == 10 && sc->arge_pllcfg.pll_10 != 0)
942 pll = sc->arge_pllcfg.pll_10;
943 else if (if_speed == 100 && sc->arge_pllcfg.pll_100 != 0)
944 pll = sc->arge_pllcfg.pll_100;
945 else if (if_speed == 1000 && sc->arge_pllcfg.pll_1000 != 0)
946 pll = sc->arge_pllcfg.pll_1000;
947 ARGEDEBUG(sc, ARGE_DBG_PLL, "%s: final pll=0x%x\n", __func__, pll);
949 /* XXX ensure pll != 0 */
950 ar71xx_device_set_pll_ge(sc->arge_mac_unit, if_speed, pll);
952 /* set MII registers */
954 * This was introduced to match what the Linux ag71xx ethernet
955 * driver does. For the AR71xx case, it does set the port
956 * MII speed. However, if this is done, non-gigabit speeds
957 * are not at all reliable when speaking via RGMII through
958 * 'bridge' PHY port that's pretending to be a local PHY.
960 * Until that gets root caused, and until an AR71xx + normal
961 * PHY board is tested, leave this disabled.
964 ar71xx_device_set_mii_speed(sc->arge_mac_unit, if_speed);
970 arge_reset_dma(struct arge_softc *sc)
972 ARGE_WRITE(sc, AR71XX_DMA_RX_CONTROL, 0);
973 ARGE_WRITE(sc, AR71XX_DMA_TX_CONTROL, 0);
975 ARGE_WRITE(sc, AR71XX_DMA_RX_DESC, 0);
976 ARGE_WRITE(sc, AR71XX_DMA_TX_DESC, 0);
978 /* Clear all possible RX interrupts */
979 while(ARGE_READ(sc, AR71XX_DMA_RX_STATUS) & DMA_RX_STATUS_PKT_RECVD)
980 ARGE_WRITE(sc, AR71XX_DMA_RX_STATUS, DMA_RX_STATUS_PKT_RECVD);
983 * Clear all possible TX interrupts
985 while(ARGE_READ(sc, AR71XX_DMA_TX_STATUS) & DMA_TX_STATUS_PKT_SENT)
986 ARGE_WRITE(sc, AR71XX_DMA_TX_STATUS, DMA_TX_STATUS_PKT_SENT);
991 ARGE_WRITE(sc, AR71XX_DMA_RX_STATUS,
992 DMA_RX_STATUS_BUS_ERROR | DMA_RX_STATUS_OVERFLOW);
993 ARGE_WRITE(sc, AR71XX_DMA_TX_STATUS,
994 DMA_TX_STATUS_BUS_ERROR | DMA_TX_STATUS_UNDERRUN);
997 * Force a DDR flush so any pending data is properly
998 * flushed to RAM before underlying buffers are freed.
1006 arge_init(void *xsc)
1008 struct arge_softc *sc = xsc;
1011 arge_init_locked(sc);
1016 arge_init_locked(struct arge_softc *sc)
1018 struct ifnet *ifp = sc->arge_ifp;
1019 struct mii_data *mii;
1021 ARGE_LOCK_ASSERT(sc);
1023 if ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING))
1026 /* Init circular RX list. */
1027 if (arge_rx_ring_init(sc) != 0) {
1028 device_printf(sc->arge_dev,
1029 "initialization failed: no memory for rx buffers\n");
1034 /* Init tx descriptors. */
1035 arge_tx_ring_init(sc);
1039 if (sc->arge_miibus) {
1040 mii = device_get_softc(sc->arge_miibus);
1045 * Sun always shines over multiPHY interface
1047 sc->arge_link_status = 1;
1050 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1051 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1053 if (sc->arge_miibus) {
1054 callout_reset(&sc->arge_stat_callout, hz, arge_tick, sc);
1055 arge_update_link_locked(sc);
1058 ARGE_WRITE(sc, AR71XX_DMA_TX_DESC, ARGE_TX_RING_ADDR(sc, 0));
1059 ARGE_WRITE(sc, AR71XX_DMA_RX_DESC, ARGE_RX_RING_ADDR(sc, 0));
1061 /* Start listening */
1062 ARGE_WRITE(sc, AR71XX_DMA_RX_CONTROL, DMA_RX_CONTROL_EN);
1064 /* Enable interrupts */
1065 ARGE_WRITE(sc, AR71XX_DMA_INTR, DMA_INTR_ALL);
1069 * Return whether the mbuf chain is correctly aligned
1070 * for the arge TX engine.
1072 * The TX engine requires each fragment to be aligned to a
1073 * 4 byte boundary and the size of each fragment except
1074 * the last to be a multiple of 4 bytes.
1077 arge_mbuf_chain_is_tx_aligned(struct mbuf *m0)
1081 for (m = m0; m != NULL; m = m->m_next) {
1082 if((mtod(m, intptr_t) & 3) != 0)
1084 if ((m->m_next != NULL) && ((m->m_len & 0x03) != 0))
1091 * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
1092 * pointers to the fragment pointers.
1095 arge_encap(struct arge_softc *sc, struct mbuf **m_head)
1097 struct arge_txdesc *txd;
1098 struct arge_desc *desc, *prev_desc;
1099 bus_dma_segment_t txsegs[ARGE_MAXFRAGS];
1100 int error, i, nsegs, prod, prev_prod;
1103 ARGE_LOCK_ASSERT(sc);
1106 * Fix mbuf chain, all fragments should be 4 bytes aligned and
1110 if (! arge_mbuf_chain_is_tx_aligned(m)) {
1111 sc->stats.tx_pkts_unaligned++;
1112 m = m_defrag(*m_head, M_NOWAIT);
1119 sc->stats.tx_pkts_aligned++;
1121 prod = sc->arge_cdata.arge_tx_prod;
1122 txd = &sc->arge_cdata.arge_txdesc[prod];
1123 error = bus_dmamap_load_mbuf_sg(sc->arge_cdata.arge_tx_tag,
1124 txd->tx_dmamap, *m_head, txsegs, &nsegs, BUS_DMA_NOWAIT);
1126 if (error == EFBIG) {
1128 } else if (error != 0)
1137 /* Check number of available descriptors. */
1138 if (sc->arge_cdata.arge_tx_cnt + nsegs >= (ARGE_TX_RING_COUNT - 1)) {
1139 bus_dmamap_unload(sc->arge_cdata.arge_tx_tag, txd->tx_dmamap);
1143 txd->tx_m = *m_head;
1144 bus_dmamap_sync(sc->arge_cdata.arge_tx_tag, txd->tx_dmamap,
1145 BUS_DMASYNC_PREWRITE);
1148 * Make a list of descriptors for this packet. DMA controller will
1149 * walk through it while arge_link is not zero.
1152 desc = prev_desc = NULL;
1153 for (i = 0; i < nsegs; i++) {
1154 desc = &sc->arge_rdata.arge_tx_ring[prod];
1155 desc->packet_ctrl = ARGE_DMASIZE(txsegs[i].ds_len);
1157 if (txsegs[i].ds_addr & 3)
1158 panic("TX packet address unaligned\n");
1160 desc->packet_addr = txsegs[i].ds_addr;
1162 /* link with previous descriptor */
1164 prev_desc->packet_ctrl |= ARGE_DESC_MORE;
1166 sc->arge_cdata.arge_tx_cnt++;
1168 ARGE_INC(prod, ARGE_TX_RING_COUNT);
1171 /* Update producer index. */
1172 sc->arge_cdata.arge_tx_prod = prod;
1174 /* Sync descriptors. */
1175 bus_dmamap_sync(sc->arge_cdata.arge_tx_ring_tag,
1176 sc->arge_cdata.arge_tx_ring_map,
1177 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1179 /* Start transmitting */
1180 ARGEDEBUG(sc, ARGE_DBG_TX, "%s: setting DMA_TX_CONTROL_EN\n",
1182 ARGE_WRITE(sc, AR71XX_DMA_TX_CONTROL, DMA_TX_CONTROL_EN);
1187 arge_start(struct ifnet *ifp)
1189 struct arge_softc *sc;
1194 arge_start_locked(ifp);
1199 arge_start_locked(struct ifnet *ifp)
1201 struct arge_softc *sc;
1202 struct mbuf *m_head;
1207 ARGE_LOCK_ASSERT(sc);
1209 ARGEDEBUG(sc, ARGE_DBG_TX, "%s: beginning\n", __func__);
1211 if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
1212 IFF_DRV_RUNNING || sc->arge_link_status == 0 )
1216 * Before we go any further, check whether we're already full.
1217 * The below check errors out immediately if the ring is full
1218 * and never gets a chance to set this flag. Although it's
1219 * likely never needed, this at least avoids an unexpected
1222 if (sc->arge_cdata.arge_tx_cnt >= ARGE_TX_RING_COUNT - 2) {
1223 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1224 ARGEDEBUG(sc, ARGE_DBG_ERR,
1225 "%s: tx_cnt %d >= max %d; setting IFF_DRV_OACTIVE\n",
1226 __func__, sc->arge_cdata.arge_tx_cnt,
1227 ARGE_TX_RING_COUNT - 2);
1233 for (enq = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd) &&
1234 sc->arge_cdata.arge_tx_cnt < ARGE_TX_RING_COUNT - 2; ) {
1235 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
1241 * Pack the data into the transmit ring.
1243 if (arge_encap(sc, &m_head)) {
1246 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
1247 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1253 * If there's a BPF listener, bounce a copy of this frame
1256 ETHER_BPF_MTAP(ifp, m_head);
1258 ARGEDEBUG(sc, ARGE_DBG_TX, "%s: finished; queued %d packets\n",
1263 arge_stop(struct arge_softc *sc)
1267 ARGE_LOCK_ASSERT(sc);
1270 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1271 if (sc->arge_miibus)
1272 callout_stop(&sc->arge_stat_callout);
1274 /* mask out interrupts */
1275 ARGE_WRITE(sc, AR71XX_DMA_INTR, 0);
1279 /* Flush FIFO and free any existing mbufs */
1281 arge_rx_ring_free(sc);
1282 arge_tx_ring_free(sc);
1287 arge_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1289 struct arge_softc *sc = ifp->if_softc;
1290 struct ifreq *ifr = (struct ifreq *) data;
1291 struct mii_data *mii;
1293 #ifdef DEVICE_POLLING
1300 if ((ifp->if_flags & IFF_UP) != 0) {
1301 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
1302 if (((ifp->if_flags ^ sc->arge_if_flags)
1303 & (IFF_PROMISC | IFF_ALLMULTI)) != 0) {
1304 /* XXX: handle promisc & multi flags */
1308 if (!sc->arge_detach)
1309 arge_init_locked(sc);
1311 } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) {
1312 ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1315 sc->arge_if_flags = ifp->if_flags;
1321 /* XXX: implement SIOCDELMULTI */
1326 if (sc->arge_miibus) {
1327 mii = device_get_softc(sc->arge_miibus);
1328 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media,
1332 error = ifmedia_ioctl(ifp, ifr, &sc->arge_ifmedia,
1336 /* XXX: Check other capabilities */
1337 #ifdef DEVICE_POLLING
1338 mask = ifp->if_capenable ^ ifr->ifr_reqcap;
1339 if (mask & IFCAP_POLLING) {
1340 if (ifr->ifr_reqcap & IFCAP_POLLING) {
1341 ARGE_WRITE(sc, AR71XX_DMA_INTR, 0);
1342 error = ether_poll_register(arge_poll, ifp);
1346 ifp->if_capenable |= IFCAP_POLLING;
1349 ARGE_WRITE(sc, AR71XX_DMA_INTR, DMA_INTR_ALL);
1350 error = ether_poll_deregister(ifp);
1352 ifp->if_capenable &= ~IFCAP_POLLING;
1360 error = ether_ioctl(ifp, command, data);
1368 * Set media options.
1371 arge_ifmedia_upd(struct ifnet *ifp)
1373 struct arge_softc *sc;
1374 struct mii_data *mii;
1375 struct mii_softc *miisc;
1380 mii = device_get_softc(sc->arge_miibus);
1381 LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
1383 error = mii_mediachg(mii);
1390 * Report current media status.
1393 arge_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1395 struct arge_softc *sc = ifp->if_softc;
1396 struct mii_data *mii;
1398 mii = device_get_softc(sc->arge_miibus);
1401 ifmr->ifm_active = mii->mii_media_active;
1402 ifmr->ifm_status = mii->mii_media_status;
1406 struct arge_dmamap_arg {
1407 bus_addr_t arge_busaddr;
1411 arge_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1413 struct arge_dmamap_arg *ctx;
1418 ctx->arge_busaddr = segs[0].ds_addr;
1422 arge_dma_alloc(struct arge_softc *sc)
1424 struct arge_dmamap_arg ctx;
1425 struct arge_txdesc *txd;
1426 struct arge_rxdesc *rxd;
1429 /* Create parent DMA tag. */
1430 error = bus_dma_tag_create(
1431 bus_get_dma_tag(sc->arge_dev), /* parent */
1432 1, 0, /* alignment, boundary */
1433 BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
1434 BUS_SPACE_MAXADDR, /* highaddr */
1435 NULL, NULL, /* filter, filterarg */
1436 BUS_SPACE_MAXSIZE_32BIT, /* maxsize */
1438 BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
1440 NULL, NULL, /* lockfunc, lockarg */
1441 &sc->arge_cdata.arge_parent_tag);
1443 device_printf(sc->arge_dev,
1444 "failed to create parent DMA tag\n");
1447 /* Create tag for Tx ring. */
1448 error = bus_dma_tag_create(
1449 sc->arge_cdata.arge_parent_tag, /* parent */
1450 ARGE_RING_ALIGN, 0, /* alignment, boundary */
1451 BUS_SPACE_MAXADDR, /* lowaddr */
1452 BUS_SPACE_MAXADDR, /* highaddr */
1453 NULL, NULL, /* filter, filterarg */
1454 ARGE_TX_DMA_SIZE, /* maxsize */
1456 ARGE_TX_DMA_SIZE, /* maxsegsize */
1458 NULL, NULL, /* lockfunc, lockarg */
1459 &sc->arge_cdata.arge_tx_ring_tag);
1461 device_printf(sc->arge_dev,
1462 "failed to create Tx ring DMA tag\n");
1466 /* Create tag for Rx ring. */
1467 error = bus_dma_tag_create(
1468 sc->arge_cdata.arge_parent_tag, /* parent */
1469 ARGE_RING_ALIGN, 0, /* alignment, boundary */
1470 BUS_SPACE_MAXADDR, /* lowaddr */
1471 BUS_SPACE_MAXADDR, /* highaddr */
1472 NULL, NULL, /* filter, filterarg */
1473 ARGE_RX_DMA_SIZE, /* maxsize */
1475 ARGE_RX_DMA_SIZE, /* maxsegsize */
1477 NULL, NULL, /* lockfunc, lockarg */
1478 &sc->arge_cdata.arge_rx_ring_tag);
1480 device_printf(sc->arge_dev,
1481 "failed to create Rx ring DMA tag\n");
1485 /* Create tag for Tx buffers. */
1486 error = bus_dma_tag_create(
1487 sc->arge_cdata.arge_parent_tag, /* parent */
1488 sizeof(uint32_t), 0, /* alignment, boundary */
1489 BUS_SPACE_MAXADDR, /* lowaddr */
1490 BUS_SPACE_MAXADDR, /* highaddr */
1491 NULL, NULL, /* filter, filterarg */
1492 MCLBYTES * ARGE_MAXFRAGS, /* maxsize */
1493 ARGE_MAXFRAGS, /* nsegments */
1494 MCLBYTES, /* maxsegsize */
1496 NULL, NULL, /* lockfunc, lockarg */
1497 &sc->arge_cdata.arge_tx_tag);
1499 device_printf(sc->arge_dev, "failed to create Tx DMA tag\n");
1503 /* Create tag for Rx buffers. */
1504 error = bus_dma_tag_create(
1505 sc->arge_cdata.arge_parent_tag, /* parent */
1506 ARGE_RX_ALIGN, 0, /* alignment, boundary */
1507 BUS_SPACE_MAXADDR, /* lowaddr */
1508 BUS_SPACE_MAXADDR, /* highaddr */
1509 NULL, NULL, /* filter, filterarg */
1510 MCLBYTES, /* maxsize */
1511 ARGE_MAXFRAGS, /* nsegments */
1512 MCLBYTES, /* maxsegsize */
1514 NULL, NULL, /* lockfunc, lockarg */
1515 &sc->arge_cdata.arge_rx_tag);
1517 device_printf(sc->arge_dev, "failed to create Rx DMA tag\n");
1521 /* Allocate DMA'able memory and load the DMA map for Tx ring. */
1522 error = bus_dmamem_alloc(sc->arge_cdata.arge_tx_ring_tag,
1523 (void **)&sc->arge_rdata.arge_tx_ring, BUS_DMA_WAITOK |
1524 BUS_DMA_COHERENT | BUS_DMA_ZERO,
1525 &sc->arge_cdata.arge_tx_ring_map);
1527 device_printf(sc->arge_dev,
1528 "failed to allocate DMA'able memory for Tx ring\n");
1532 ctx.arge_busaddr = 0;
1533 error = bus_dmamap_load(sc->arge_cdata.arge_tx_ring_tag,
1534 sc->arge_cdata.arge_tx_ring_map, sc->arge_rdata.arge_tx_ring,
1535 ARGE_TX_DMA_SIZE, arge_dmamap_cb, &ctx, 0);
1536 if (error != 0 || ctx.arge_busaddr == 0) {
1537 device_printf(sc->arge_dev,
1538 "failed to load DMA'able memory for Tx ring\n");
1541 sc->arge_rdata.arge_tx_ring_paddr = ctx.arge_busaddr;
1543 /* Allocate DMA'able memory and load the DMA map for Rx ring. */
1544 error = bus_dmamem_alloc(sc->arge_cdata.arge_rx_ring_tag,
1545 (void **)&sc->arge_rdata.arge_rx_ring, BUS_DMA_WAITOK |
1546 BUS_DMA_COHERENT | BUS_DMA_ZERO,
1547 &sc->arge_cdata.arge_rx_ring_map);
1549 device_printf(sc->arge_dev,
1550 "failed to allocate DMA'able memory for Rx ring\n");
1554 ctx.arge_busaddr = 0;
1555 error = bus_dmamap_load(sc->arge_cdata.arge_rx_ring_tag,
1556 sc->arge_cdata.arge_rx_ring_map, sc->arge_rdata.arge_rx_ring,
1557 ARGE_RX_DMA_SIZE, arge_dmamap_cb, &ctx, 0);
1558 if (error != 0 || ctx.arge_busaddr == 0) {
1559 device_printf(sc->arge_dev,
1560 "failed to load DMA'able memory for Rx ring\n");
1563 sc->arge_rdata.arge_rx_ring_paddr = ctx.arge_busaddr;
1565 /* Create DMA maps for Tx buffers. */
1566 for (i = 0; i < ARGE_TX_RING_COUNT; i++) {
1567 txd = &sc->arge_cdata.arge_txdesc[i];
1569 txd->tx_dmamap = NULL;
1570 error = bus_dmamap_create(sc->arge_cdata.arge_tx_tag, 0,
1573 device_printf(sc->arge_dev,
1574 "failed to create Tx dmamap\n");
1578 /* Create DMA maps for Rx buffers. */
1579 if ((error = bus_dmamap_create(sc->arge_cdata.arge_rx_tag, 0,
1580 &sc->arge_cdata.arge_rx_sparemap)) != 0) {
1581 device_printf(sc->arge_dev,
1582 "failed to create spare Rx dmamap\n");
1585 for (i = 0; i < ARGE_RX_RING_COUNT; i++) {
1586 rxd = &sc->arge_cdata.arge_rxdesc[i];
1588 rxd->rx_dmamap = NULL;
1589 error = bus_dmamap_create(sc->arge_cdata.arge_rx_tag, 0,
1592 device_printf(sc->arge_dev,
1593 "failed to create Rx dmamap\n");
1603 arge_dma_free(struct arge_softc *sc)
1605 struct arge_txdesc *txd;
1606 struct arge_rxdesc *rxd;
1610 if (sc->arge_cdata.arge_tx_ring_tag) {
1611 if (sc->arge_cdata.arge_tx_ring_map)
1612 bus_dmamap_unload(sc->arge_cdata.arge_tx_ring_tag,
1613 sc->arge_cdata.arge_tx_ring_map);
1614 if (sc->arge_cdata.arge_tx_ring_map &&
1615 sc->arge_rdata.arge_tx_ring)
1616 bus_dmamem_free(sc->arge_cdata.arge_tx_ring_tag,
1617 sc->arge_rdata.arge_tx_ring,
1618 sc->arge_cdata.arge_tx_ring_map);
1619 sc->arge_rdata.arge_tx_ring = NULL;
1620 sc->arge_cdata.arge_tx_ring_map = NULL;
1621 bus_dma_tag_destroy(sc->arge_cdata.arge_tx_ring_tag);
1622 sc->arge_cdata.arge_tx_ring_tag = NULL;
1625 if (sc->arge_cdata.arge_rx_ring_tag) {
1626 if (sc->arge_cdata.arge_rx_ring_map)
1627 bus_dmamap_unload(sc->arge_cdata.arge_rx_ring_tag,
1628 sc->arge_cdata.arge_rx_ring_map);
1629 if (sc->arge_cdata.arge_rx_ring_map &&
1630 sc->arge_rdata.arge_rx_ring)
1631 bus_dmamem_free(sc->arge_cdata.arge_rx_ring_tag,
1632 sc->arge_rdata.arge_rx_ring,
1633 sc->arge_cdata.arge_rx_ring_map);
1634 sc->arge_rdata.arge_rx_ring = NULL;
1635 sc->arge_cdata.arge_rx_ring_map = NULL;
1636 bus_dma_tag_destroy(sc->arge_cdata.arge_rx_ring_tag);
1637 sc->arge_cdata.arge_rx_ring_tag = NULL;
1640 if (sc->arge_cdata.arge_tx_tag) {
1641 for (i = 0; i < ARGE_TX_RING_COUNT; i++) {
1642 txd = &sc->arge_cdata.arge_txdesc[i];
1643 if (txd->tx_dmamap) {
1644 bus_dmamap_destroy(sc->arge_cdata.arge_tx_tag,
1646 txd->tx_dmamap = NULL;
1649 bus_dma_tag_destroy(sc->arge_cdata.arge_tx_tag);
1650 sc->arge_cdata.arge_tx_tag = NULL;
1653 if (sc->arge_cdata.arge_rx_tag) {
1654 for (i = 0; i < ARGE_RX_RING_COUNT; i++) {
1655 rxd = &sc->arge_cdata.arge_rxdesc[i];
1656 if (rxd->rx_dmamap) {
1657 bus_dmamap_destroy(sc->arge_cdata.arge_rx_tag,
1659 rxd->rx_dmamap = NULL;
1662 if (sc->arge_cdata.arge_rx_sparemap) {
1663 bus_dmamap_destroy(sc->arge_cdata.arge_rx_tag,
1664 sc->arge_cdata.arge_rx_sparemap);
1665 sc->arge_cdata.arge_rx_sparemap = 0;
1667 bus_dma_tag_destroy(sc->arge_cdata.arge_rx_tag);
1668 sc->arge_cdata.arge_rx_tag = NULL;
1671 if (sc->arge_cdata.arge_parent_tag) {
1672 bus_dma_tag_destroy(sc->arge_cdata.arge_parent_tag);
1673 sc->arge_cdata.arge_parent_tag = NULL;
1678 * Initialize the transmit descriptors.
1681 arge_tx_ring_init(struct arge_softc *sc)
1683 struct arge_ring_data *rd;
1684 struct arge_txdesc *txd;
1688 sc->arge_cdata.arge_tx_prod = 0;
1689 sc->arge_cdata.arge_tx_cons = 0;
1690 sc->arge_cdata.arge_tx_cnt = 0;
1692 rd = &sc->arge_rdata;
1693 bzero(rd->arge_tx_ring, sizeof(rd->arge_tx_ring));
1694 for (i = 0; i < ARGE_TX_RING_COUNT; i++) {
1695 if (i == ARGE_TX_RING_COUNT - 1)
1696 addr = ARGE_TX_RING_ADDR(sc, 0);
1698 addr = ARGE_TX_RING_ADDR(sc, i + 1);
1699 rd->arge_tx_ring[i].packet_ctrl = ARGE_DESC_EMPTY;
1700 rd->arge_tx_ring[i].next_desc = addr;
1701 txd = &sc->arge_cdata.arge_txdesc[i];
1705 bus_dmamap_sync(sc->arge_cdata.arge_tx_ring_tag,
1706 sc->arge_cdata.arge_tx_ring_map,
1707 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1713 * Free the Tx ring, unload any pending dma transaction and free the mbuf.
1716 arge_tx_ring_free(struct arge_softc *sc)
1718 struct arge_txdesc *txd;
1721 /* Free the Tx buffers. */
1722 for (i = 0; i < ARGE_TX_RING_COUNT; i++) {
1723 txd = &sc->arge_cdata.arge_txdesc[i];
1724 if (txd->tx_dmamap) {
1725 bus_dmamap_sync(sc->arge_cdata.arge_tx_tag,
1726 txd->tx_dmamap, BUS_DMASYNC_POSTWRITE);
1727 bus_dmamap_unload(sc->arge_cdata.arge_tx_tag,
1737 * Initialize the RX descriptors and allocate mbufs for them. Note that
1738 * we arrange the descriptors in a closed ring, so that the last descriptor
1739 * points back to the first.
1742 arge_rx_ring_init(struct arge_softc *sc)
1744 struct arge_ring_data *rd;
1745 struct arge_rxdesc *rxd;
1749 sc->arge_cdata.arge_rx_cons = 0;
1751 rd = &sc->arge_rdata;
1752 bzero(rd->arge_rx_ring, sizeof(rd->arge_rx_ring));
1753 for (i = 0; i < ARGE_RX_RING_COUNT; i++) {
1754 rxd = &sc->arge_cdata.arge_rxdesc[i];
1755 if (rxd->rx_m != NULL) {
1756 device_printf(sc->arge_dev,
1757 "%s: ring[%d] rx_m wasn't free?\n",
1762 rxd->desc = &rd->arge_rx_ring[i];
1763 if (i == ARGE_RX_RING_COUNT - 1)
1764 addr = ARGE_RX_RING_ADDR(sc, 0);
1766 addr = ARGE_RX_RING_ADDR(sc, i + 1);
1767 rd->arge_rx_ring[i].next_desc = addr;
1768 if (arge_newbuf(sc, i) != 0) {
1773 bus_dmamap_sync(sc->arge_cdata.arge_rx_ring_tag,
1774 sc->arge_cdata.arge_rx_ring_map,
1775 BUS_DMASYNC_PREWRITE);
1781 * Free all the buffers in the RX ring.
1783 * TODO: ensure that DMA is disabled and no pending DMA
1784 * is lurking in the FIFO.
1787 arge_rx_ring_free(struct arge_softc *sc)
1790 struct arge_rxdesc *rxd;
1792 ARGE_LOCK_ASSERT(sc);
1794 for (i = 0; i < ARGE_RX_RING_COUNT; i++) {
1795 rxd = &sc->arge_cdata.arge_rxdesc[i];
1796 /* Unmap the mbuf */
1797 if (rxd->rx_m != NULL) {
1798 bus_dmamap_unload(sc->arge_cdata.arge_rx_tag,
1807 * Initialize an RX descriptor and attach an MBUF cluster.
1810 arge_newbuf(struct arge_softc *sc, int idx)
1812 struct arge_desc *desc;
1813 struct arge_rxdesc *rxd;
1815 bus_dma_segment_t segs[1];
1819 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1822 m->m_len = m->m_pkthdr.len = MCLBYTES;
1823 m_adj(m, sizeof(uint64_t));
1825 if (bus_dmamap_load_mbuf_sg(sc->arge_cdata.arge_rx_tag,
1826 sc->arge_cdata.arge_rx_sparemap, m, segs, &nsegs, 0) != 0) {
1830 KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
1832 rxd = &sc->arge_cdata.arge_rxdesc[idx];
1833 if (rxd->rx_m != NULL) {
1834 bus_dmamap_unload(sc->arge_cdata.arge_rx_tag, rxd->rx_dmamap);
1836 map = rxd->rx_dmamap;
1837 rxd->rx_dmamap = sc->arge_cdata.arge_rx_sparemap;
1838 sc->arge_cdata.arge_rx_sparemap = map;
1841 if (segs[0].ds_addr & 3)
1842 panic("RX packet address unaligned");
1843 desc->packet_addr = segs[0].ds_addr;
1844 desc->packet_ctrl = ARGE_DESC_EMPTY | ARGE_DMASIZE(segs[0].ds_len);
1846 bus_dmamap_sync(sc->arge_cdata.arge_rx_ring_tag,
1847 sc->arge_cdata.arge_rx_ring_map,
1848 BUS_DMASYNC_PREWRITE);
1853 static __inline void
1854 arge_fixup_rx(struct mbuf *m)
1857 uint16_t *src, *dst;
1859 src = mtod(m, uint16_t *);
1862 for (i = 0; i < m->m_len / sizeof(uint16_t); i++) {
1866 if (m->m_len % sizeof(uint16_t))
1867 *(uint8_t *)dst = *(uint8_t *)src;
1869 m->m_data -= ETHER_ALIGN;
1872 #ifdef DEVICE_POLLING
1874 arge_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
1876 struct arge_softc *sc = ifp->if_softc;
1879 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1882 rx_npkts = arge_rx_locked(sc);
1888 #endif /* DEVICE_POLLING */
1892 arge_tx_locked(struct arge_softc *sc)
1894 struct arge_txdesc *txd;
1895 struct arge_desc *cur_tx;
1900 ARGE_LOCK_ASSERT(sc);
1902 cons = sc->arge_cdata.arge_tx_cons;
1903 prod = sc->arge_cdata.arge_tx_prod;
1905 ARGEDEBUG(sc, ARGE_DBG_TX, "%s: cons=%d, prod=%d\n", __func__, cons,
1911 bus_dmamap_sync(sc->arge_cdata.arge_tx_ring_tag,
1912 sc->arge_cdata.arge_tx_ring_map,
1913 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1917 * Go through our tx list and free mbufs for those
1918 * frames that have been transmitted.
1920 for (; cons != prod; ARGE_INC(cons, ARGE_TX_RING_COUNT)) {
1921 cur_tx = &sc->arge_rdata.arge_tx_ring[cons];
1922 ctrl = cur_tx->packet_ctrl;
1923 /* Check if descriptor has "finished" flag */
1924 if ((ctrl & ARGE_DESC_EMPTY) == 0)
1927 ARGE_WRITE(sc, AR71XX_DMA_TX_STATUS, DMA_TX_STATUS_PKT_SENT);
1929 sc->arge_cdata.arge_tx_cnt--;
1930 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1932 txd = &sc->arge_cdata.arge_txdesc[cons];
1936 bus_dmamap_sync(sc->arge_cdata.arge_tx_tag, txd->tx_dmamap,
1937 BUS_DMASYNC_POSTWRITE);
1938 bus_dmamap_unload(sc->arge_cdata.arge_tx_tag, txd->tx_dmamap);
1940 /* Free only if it's first descriptor in list */
1945 /* reset descriptor */
1946 cur_tx->packet_addr = 0;
1949 sc->arge_cdata.arge_tx_cons = cons;
1951 bus_dmamap_sync(sc->arge_cdata.arge_tx_ring_tag,
1952 sc->arge_cdata.arge_tx_ring_map, BUS_DMASYNC_PREWRITE);
1957 arge_rx_locked(struct arge_softc *sc)
1959 struct arge_rxdesc *rxd;
1960 struct ifnet *ifp = sc->arge_ifp;
1961 int cons, prog, packet_len, i;
1962 struct arge_desc *cur_rx;
1966 ARGE_LOCK_ASSERT(sc);
1968 cons = sc->arge_cdata.arge_rx_cons;
1970 bus_dmamap_sync(sc->arge_cdata.arge_rx_ring_tag,
1971 sc->arge_cdata.arge_rx_ring_map,
1972 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1974 for (prog = 0; prog < ARGE_RX_RING_COUNT;
1975 ARGE_INC(cons, ARGE_RX_RING_COUNT)) {
1976 cur_rx = &sc->arge_rdata.arge_rx_ring[cons];
1977 rxd = &sc->arge_cdata.arge_rxdesc[cons];
1980 if ((cur_rx->packet_ctrl & ARGE_DESC_EMPTY) != 0)
1983 ARGE_WRITE(sc, AR71XX_DMA_RX_STATUS, DMA_RX_STATUS_PKT_RECVD);
1987 packet_len = ARGE_DMASIZE(cur_rx->packet_ctrl);
1988 bus_dmamap_sync(sc->arge_cdata.arge_rx_tag, rxd->rx_dmamap,
1989 BUS_DMASYNC_POSTREAD);
1993 m->m_pkthdr.rcvif = ifp;
1994 /* Skip 4 bytes of CRC */
1995 m->m_pkthdr.len = m->m_len = packet_len - ETHER_CRC_LEN;
2000 (*ifp->if_input)(ifp, m);
2002 cur_rx->packet_addr = 0;
2007 i = sc->arge_cdata.arge_rx_cons;
2008 for (; prog > 0 ; prog--) {
2009 if (arge_newbuf(sc, i) != 0) {
2010 device_printf(sc->arge_dev,
2011 "Failed to allocate buffer\n");
2014 ARGE_INC(i, ARGE_RX_RING_COUNT);
2017 bus_dmamap_sync(sc->arge_cdata.arge_rx_ring_tag,
2018 sc->arge_cdata.arge_rx_ring_map,
2019 BUS_DMASYNC_PREWRITE);
2021 sc->arge_cdata.arge_rx_cons = cons;
2028 arge_intr_filter(void *arg)
2030 struct arge_softc *sc = arg;
2031 uint32_t status, ints;
2033 status = ARGE_READ(sc, AR71XX_DMA_INTR_STATUS);
2034 ints = ARGE_READ(sc, AR71XX_DMA_INTR);
2036 ARGEDEBUG(sc, ARGE_DBG_INTR, "int mask(filter) = %b\n", ints,
2037 "\20\10RX_BUS_ERROR\7RX_OVERFLOW\5RX_PKT_RCVD"
2038 "\4TX_BUS_ERROR\2TX_UNDERRUN\1TX_PKT_SENT");
2039 ARGEDEBUG(sc, ARGE_DBG_INTR, "status(filter) = %b\n", status,
2040 "\20\10RX_BUS_ERROR\7RX_OVERFLOW\5RX_PKT_RCVD"
2041 "\4TX_BUS_ERROR\2TX_UNDERRUN\1TX_PKT_SENT");
2043 if (status & DMA_INTR_ALL) {
2044 sc->arge_intr_status |= status;
2045 ARGE_WRITE(sc, AR71XX_DMA_INTR, 0);
2046 return (FILTER_SCHEDULE_THREAD);
2049 sc->arge_intr_status = 0;
2050 return (FILTER_STRAY);
2054 arge_intr(void *arg)
2056 struct arge_softc *sc = arg;
2058 struct ifnet *ifp = sc->arge_ifp;
2060 status = ARGE_READ(sc, AR71XX_DMA_INTR_STATUS);
2061 status |= sc->arge_intr_status;
2063 ARGEDEBUG(sc, ARGE_DBG_INTR, "int status(intr) = %b\n", status,
2064 "\20\10\7RX_OVERFLOW\5RX_PKT_RCVD"
2065 "\4TX_BUS_ERROR\2TX_UNDERRUN\1TX_PKT_SENT");
2068 * Is it our interrupt at all?
2073 if (status & DMA_INTR_RX_BUS_ERROR) {
2074 ARGE_WRITE(sc, AR71XX_DMA_RX_STATUS, DMA_RX_STATUS_BUS_ERROR);
2075 device_printf(sc->arge_dev, "RX bus error");
2079 if (status & DMA_INTR_TX_BUS_ERROR) {
2080 ARGE_WRITE(sc, AR71XX_DMA_TX_STATUS, DMA_TX_STATUS_BUS_ERROR);
2081 device_printf(sc->arge_dev, "TX bus error");
2087 if (status & DMA_INTR_RX_PKT_RCVD)
2091 * RX overrun disables the receiver.
2092 * Clear indication and re-enable rx.
2094 if ( status & DMA_INTR_RX_OVERFLOW) {
2095 ARGE_WRITE(sc, AR71XX_DMA_RX_STATUS, DMA_RX_STATUS_OVERFLOW);
2096 ARGE_WRITE(sc, AR71XX_DMA_RX_CONTROL, DMA_RX_CONTROL_EN);
2097 sc->stats.rx_overflow++;
2100 if (status & DMA_INTR_TX_PKT_SENT)
2103 * Underrun turns off TX. Clear underrun indication.
2104 * If there's anything left in the ring, reactivate the tx.
2106 if (status & DMA_INTR_TX_UNDERRUN) {
2107 ARGE_WRITE(sc, AR71XX_DMA_TX_STATUS, DMA_TX_STATUS_UNDERRUN);
2108 sc->stats.tx_underflow++;
2109 ARGEDEBUG(sc, ARGE_DBG_TX, "%s: TX underrun; tx_cnt=%d\n",
2110 __func__, sc->arge_cdata.arge_tx_cnt);
2111 if (sc->arge_cdata.arge_tx_cnt > 0 ) {
2112 ARGE_WRITE(sc, AR71XX_DMA_TX_CONTROL,
2118 * If we've finished TXing and there's space for more packets
2119 * to be queued for TX, do so. Otherwise we may end up in a
2120 * situation where the interface send queue was filled
2121 * whilst the hardware queue was full, then the hardware
2122 * queue was drained by the interface send queue wasn't,
2123 * and thus if_start() is never called to kick-start
2124 * the send process (and all subsequent packets are simply
2127 * XXX TODO: make sure that the hardware deals nicely
2128 * with the possibility of the queue being enabled above
2129 * after a TX underrun, then having the hardware queue added
2132 if (status & (DMA_INTR_TX_PKT_SENT | DMA_INTR_TX_UNDERRUN) &&
2133 (ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0) {
2134 if (!IFQ_IS_EMPTY(&ifp->if_snd))
2135 arge_start_locked(ifp);
2139 * We handled all bits, clear status
2141 sc->arge_intr_status = 0;
2144 * re-enable all interrupts
2146 ARGE_WRITE(sc, AR71XX_DMA_INTR, DMA_INTR_ALL);
2151 arge_tick(void *xsc)
2153 struct arge_softc *sc = xsc;
2154 struct mii_data *mii;
2156 ARGE_LOCK_ASSERT(sc);
2158 if (sc->arge_miibus) {
2159 mii = device_get_softc(sc->arge_miibus);
2161 callout_reset(&sc->arge_stat_callout, hz, arge_tick, sc);
2166 arge_multiphy_mediachange(struct ifnet *ifp)
2168 struct arge_softc *sc = ifp->if_softc;
2169 struct ifmedia *ifm = &sc->arge_ifmedia;
2170 struct ifmedia_entry *ife = ifm->ifm_cur;
2172 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
2175 if (IFM_SUBTYPE(ife->ifm_media) == IFM_AUTO) {
2176 device_printf(sc->arge_dev,
2177 "AUTO is not supported for multiphy MAC");
2188 arge_multiphy_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
2190 struct arge_softc *sc = ifp->if_softc;
2192 ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
2193 ifmr->ifm_active = IFM_ETHER | sc->arge_media_type |
2194 sc->arge_duplex_mode;
2197 #if defined(ARGE_MDIO)
2199 argemdio_probe(device_t dev)
2201 device_set_desc(dev, "Atheros AR71xx built-in ethernet interface, MDIO controller");
2206 argemdio_attach(device_t dev)
2208 struct arge_softc *sc;
2211 sc = device_get_softc(dev);
2213 sc->arge_mac_unit = device_get_unit(dev);
2215 sc->arge_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
2216 &sc->arge_rid, RF_ACTIVE | RF_SHAREABLE);
2217 if (sc->arge_res == NULL) {
2218 device_printf(dev, "couldn't map memory\n");
2223 /* Reset MAC - required for AR71xx MDIO to successfully occur */
2226 arge_reset_miibus(sc);
2228 bus_generic_probe(dev);
2229 bus_enumerate_hinted_children(dev);
2230 error = bus_generic_attach(dev);
2236 argemdio_detach(device_t dev)