sys/mips/atheros/ar531x/if_are.c

   1 /*-
   2  * Copyright (c) 2016 Hiroki Mori. All rights reserved.
   3  * Copyright (C) 2007
   4  *      Oleksandr Tymoshenko <gonzo@freebsd.org>. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  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.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
  19  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21  * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  23  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  24  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  25  * THE POSSIBILITY OF SUCH DAMAGE.
  26  *
  27  * $Id: $
  28  *
  29  */
  30
  31 #include "opt_platform.h"
  32 #include "opt_ar531x.h"
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 /*
  38  * AR531x Ethernet interface driver
  39  * copy from mips/idt/if_kr.c and netbsd code
  40  */
  41 #include <sys/param.h>
  42 #include <sys/endian.h>
  43 #include <sys/systm.h>
  44 #include <sys/sockio.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/malloc.h>
  47 #include <sys/kernel.h>
  48 #include <sys/lock.h>
  49 #include <sys/module.h>
  50 #include <sys/mutex.h>
  51 #include <sys/socket.h>
  52 #include <sys/taskqueue.h>
  53 #include <sys/kdb.h>
  54
  55 #include <net/if.h>
  56 #include <net/if_arp.h>
  57 #include <net/ethernet.h>
  58 #include <net/if_dl.h>
  59 #include <net/if_media.h>
  60 #include <net/if_types.h>
  61 #include <net/if_var.h>
  62
  63 #include <net/bpf.h>
  64
  65 #include <machine/bus.h>
  66 #include <machine/resource.h>
  67 #include <sys/bus.h>
  68 #include <sys/rman.h>
  69
  70 #ifdef INTRNG
  71 #include <machine/intr.h>
  72 #endif
  73
  74 #include <dev/mii/mii.h>
  75 #include <dev/mii/miivar.h>
  76
  77 #ifdef ARE_MDIO
  78 #include <dev/mdio/mdio.h>
  79 #include <dev/etherswitch/miiproxy.h>
  80 #include "mdio_if.h"
  81 #endif
  82
  83 MODULE_DEPEND(are, ether, 1, 1, 1);
  84 MODULE_DEPEND(are, miibus, 1, 1, 1);
  85
  86 #include "miibus_if.h"
  87
  88 #include <mips/atheros/ar531x/ar5315reg.h>
  89 #include <mips/atheros/ar531x/ar5312reg.h>
  90 #include <mips/atheros/ar531x/ar5315_setup.h>
  91 #include <mips/atheros/ar531x/if_arereg.h>
  92
  93 #ifdef ARE_DEBUG
  94 void dump_txdesc(struct are_softc *, int);
  95 void dump_status_reg(struct are_softc *);
  96 #endif
  97
  98 static int are_attach(device_t);
  99 static int are_detach(device_t);
 100 static int are_ifmedia_upd(struct ifnet *);
 101 static void are_ifmedia_sts(struct ifnet *, struct ifmediareq *);
 102 static int are_ioctl(struct ifnet *, u_long, caddr_t);
 103 static void are_init(void *);
 104 static void are_init_locked(struct are_softc *);
 105 static void are_link_task(void *, int);
 106 static int are_miibus_readreg(device_t, int, int);
 107 static void are_miibus_statchg(device_t);
 108 static int are_miibus_writereg(device_t, int, int, int);
 109 static int are_probe(device_t);
 110 static void are_reset(struct are_softc *);
 111 static int are_resume(device_t);
 112 static int are_rx_ring_init(struct are_softc *);
 113 static int are_tx_ring_init(struct are_softc *);
 114 static int are_shutdown(device_t);
 115 static void are_start(struct ifnet *);
 116 static void are_start_locked(struct ifnet *);
 117 static void are_stop(struct are_softc *);
 118 static int are_suspend(device_t);
 119
 120 static void are_rx(struct are_softc *);
 121 static void are_tx(struct are_softc *);
 122 static void are_intr(void *);
 123 static void are_tick(void *);
 124
 125 static void are_dmamap_cb(void *, bus_dma_segment_t *, int, int);
 126 static int are_dma_alloc(struct are_softc *);
 127 static void are_dma_free(struct are_softc *);
 128 static int are_newbuf(struct are_softc *, int);
 129 static __inline void are_fixup_rx(struct mbuf *);
 130
 131 static void are_hinted_child(device_t bus, const char *dname, int dunit);
 132
 133 static device_method_t are_methods[] = {
 134         /* Device interface */
 135         DEVMETHOD(device_probe,         are_probe),
 136         DEVMETHOD(device_attach,        are_attach),
 137         DEVMETHOD(device_detach,        are_detach),
 138         DEVMETHOD(device_suspend,       are_suspend),
 139         DEVMETHOD(device_resume,        are_resume),
 140         DEVMETHOD(device_shutdown,      are_shutdown),
 141
 142         /* MII interface */
 143         DEVMETHOD(miibus_readreg,       are_miibus_readreg),
 144         DEVMETHOD(miibus_writereg,      are_miibus_writereg),
 145         DEVMETHOD(miibus_statchg,       are_miibus_statchg),
 146
 147         /* bus interface */
 148         DEVMETHOD(bus_add_child,        device_add_child_ordered),
 149         DEVMETHOD(bus_hinted_child,     are_hinted_child),
 150
 151         DEVMETHOD_END
 152 };
 153
 154 static driver_t are_driver = {
 155         "are",
 156         are_methods,
 157         sizeof(struct are_softc)
 158 };
 159
 160 static devclass_t are_devclass;
 161
 162 DRIVER_MODULE(are, nexus, are_driver, are_devclass, 0, 0);
 163 #ifdef ARE_MII
 164 DRIVER_MODULE(miibus, are, miibus_driver, miibus_devclass, 0, 0);
 165 #endif
 166
 167 #ifdef ARE_MDIO
 168 static int aremdio_probe(device_t);
 169 static int aremdio_attach(device_t);
 170 static int aremdio_detach(device_t);
 171
 172 /*
 173  * Declare an additional, separate driver for accessing the MDIO bus.
 174  */
 175 static device_method_t aremdio_methods[] = {
 176         /* Device interface */
 177         DEVMETHOD(device_probe,         aremdio_probe),
 178         DEVMETHOD(device_attach,        aremdio_attach),
 179         DEVMETHOD(device_detach,        aremdio_detach),
 180
 181         /* bus interface */
 182         DEVMETHOD(bus_add_child,        device_add_child_ordered),
 183
 184         /* MDIO access */
 185         DEVMETHOD(mdio_readreg,         are_miibus_readreg),
 186         DEVMETHOD(mdio_writereg,        are_miibus_writereg),
 187 };
 188
 189 DEFINE_CLASS_0(aremdio, aremdio_driver, aremdio_methods,
 190     sizeof(struct are_softc));
 191 static devclass_t aremdio_devclass;
 192
 193 DRIVER_MODULE(miiproxy, are, miiproxy_driver, miiproxy_devclass, 0, 0);
 194 DRIVER_MODULE(aremdio, nexus, aremdio_driver, aremdio_devclass, 0, 0);
 195 DRIVER_MODULE(mdio, aremdio, mdio_driver, mdio_devclass, 0, 0);
 196 #endif
 197
 198
 199 static int
 200 are_probe(device_t dev)
 201 {
 202
 203         device_set_desc(dev, "AR531x Ethernet interface");
 204         return (0);
 205 }
 206
 207 static int
 208 are_attach(device_t dev)
 209 {
 210         struct ifnet            *ifp;
 211         struct are_softc                *sc;
 212         int                     error = 0;
 213 #ifdef INTRNG
 214         int                     enetirq;
 215 #else
 216         int                     rid;
 217 #endif
 218         int                     unit;
 219         char *                  local_macstr;
 220         int                     count;
 221         int                     i;
 222
 223         sc = device_get_softc(dev);
 224         unit = device_get_unit(dev);
 225         sc->are_dev = dev;
 226
 227         /* hardcode macaddress */
 228         sc->are_eaddr[0] = 0x00;
 229         sc->are_eaddr[1] = 0x0C;
 230         sc->are_eaddr[2] = 0x42;
 231         sc->are_eaddr[3] = 0x09;
 232         sc->are_eaddr[4] = 0x5E;
 233         sc->are_eaddr[5] = 0x6B;
 234
 235         /* try to get from hints */
 236         if (!resource_string_value(device_get_name(dev),
 237                 device_get_unit(dev), "macaddr", (const char **)&local_macstr)) {
 238                 uint32_t tmpmac[ETHER_ADDR_LEN];
 239
 240                 /* Have a MAC address; should use it */
 241                 device_printf(dev, "Overriding MAC address from environment: '%s'\n",
 242                     local_macstr);
 243
 244                 /* Extract out the MAC address */
 245                 /* XXX this should all be a generic method */
 246                 count = sscanf(local_macstr, "%x%*c%x%*c%x%*c%x%*c%x%*c%x",
 247                     &tmpmac[0], &tmpmac[1],
 248                     &tmpmac[2], &tmpmac[3],
 249                     &tmpmac[4], &tmpmac[5]);
 250                 if (count == 6) {
 251                         /* Valid! */
 252                         for (i = 0; i < ETHER_ADDR_LEN; i++)
 253                                 sc->are_eaddr[i] = tmpmac[i];
 254                 }
 255         }
 256
 257         mtx_init(&sc->are_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
 258             MTX_DEF);
 259         callout_init_mtx(&sc->are_stat_callout, &sc->are_mtx, 0);
 260         TASK_INIT(&sc->are_link_task, 0, are_link_task, sc);
 261
 262         /* Map control/status registers. */
 263         sc->are_rid = 0;
 264         sc->are_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->are_rid,
 265             RF_ACTIVE | RF_SHAREABLE);
 266
 267         if (sc->are_res == NULL) {
 268                 device_printf(dev, "couldn't map memory\n");
 269                 error = ENXIO;
 270                 goto fail;
 271         }
 272
 273         sc->are_btag = rman_get_bustag(sc->are_res);
 274         sc->are_bhandle = rman_get_bushandle(sc->are_res);
 275
 276 #ifndef INTRNG
 277         /* Allocate interrupts */
 278         rid = 0;
 279         sc->are_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 280             RF_SHAREABLE | RF_ACTIVE);
 281
 282         if (sc->are_irq == NULL) {
 283                 device_printf(dev, "couldn't map interrupt\n");
 284                 error = ENXIO;
 285                 goto fail;
 286         }
 287 #endif
 288
 289         /* Allocate ifnet structure. */
 290         ifp = sc->are_ifp = if_alloc(IFT_ETHER);
 291
 292         if (ifp == NULL) {
 293                 device_printf(dev, "couldn't allocate ifnet structure\n");
 294                 error = ENOSPC;
 295                 goto fail;
 296         }
 297         ifp->if_softc = sc;
 298         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 299         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 300         ifp->if_ioctl = are_ioctl;
 301         ifp->if_start = are_start;
 302         ifp->if_init = are_init;
 303         sc->are_if_flags = ifp->if_flags;
 304
 305         /* XXX: add real size */
 306         IFQ_SET_MAXLEN(&ifp->if_snd, 9);
 307         ifp->if_snd.ifq_maxlen = 9;
 308         IFQ_SET_READY(&ifp->if_snd);
 309
 310         /* Tell the upper layer(s) we support long frames. */
 311         ifp->if_capabilities |= IFCAP_VLAN_MTU;
 312
 313         ifp->if_capenable = ifp->if_capabilities;
 314
 315         if (are_dma_alloc(sc) != 0) {
 316                 error = ENXIO;
 317                 goto fail;
 318         }
 319
 320         CSR_WRITE_4(sc, CSR_BUSMODE, BUSMODE_SWR);
 321         DELAY(1000);
 322
 323 #ifdef ARE_MDIO
 324         sc->are_miiproxy = mii_attach_proxy(sc->are_dev);
 325 #endif
 326
 327 #ifdef ARE_MII
 328         /* Do MII setup. */
 329         error = mii_attach(dev, &sc->are_miibus, ifp, are_ifmedia_upd,
 330             are_ifmedia_sts, BMSR_DEFCAPMASK, MII_PHY_ANY, MII_OFFSET_ANY, 0);
 331         if (error != 0) {
 332                 device_printf(dev, "attaching PHYs failed\n");
 333                 goto fail;
 334         }
 335 #else
 336         ifmedia_init(&sc->are_ifmedia, 0, are_ifmedia_upd, are_ifmedia_sts);
 337
 338         ifmedia_add(&sc->are_ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL);
 339         ifmedia_set(&sc->are_ifmedia, IFM_ETHER | IFM_AUTO);
 340 #endif
 341
 342         /* Call MI attach routine. */
 343         ether_ifattach(ifp, sc->are_eaddr);
 344
 345 #ifdef INTRNG
 346         char *name;
 347         if (ar531x_soc >= AR531X_SOC_AR5315) {
 348                 enetirq = AR5315_CPU_IRQ_ENET;
 349                 name = "enet";
 350         } else {
 351                 if (device_get_unit(dev) == 0) {
 352                         enetirq = AR5312_IRQ_ENET0;
 353                         name = "enet0";
 354                 } else {
 355                         enetirq = AR5312_IRQ_ENET1;
 356                         name = "enet1";
 357                 }
 358         }
 359         cpu_establish_hardintr(name, NULL, are_intr, sc, enetirq,
 360             INTR_TYPE_NET, NULL);
 361 #else
 362         /* Hook interrupt last to avoid having to lock softc */
 363         error = bus_setup_intr(dev, sc->are_irq, INTR_TYPE_NET | INTR_MPSAFE,
 364             NULL, are_intr, sc, &sc->are_intrhand);
 365
 366         if (error) {
 367                 device_printf(dev, "couldn't set up irq\n");
 368                 ether_ifdetach(ifp);
 369                 goto fail;
 370         }
 371 #endif
 372
 373 fail:
 374         if (error)
 375                 are_detach(dev);
 376
 377         return (error);
 378 }
 379
 380 static int
 381 are_detach(device_t dev)
 382 {
 383         struct are_softc                *sc = device_get_softc(dev);
 384         struct ifnet            *ifp = sc->are_ifp;
 385
 386         KASSERT(mtx_initialized(&sc->are_mtx), ("vr mutex not initialized"));
 387
 388         /* These should only be active if attach succeeded */
 389         if (device_is_attached(dev)) {
 390                 ARE_LOCK(sc);
 391                 sc->are_detach = 1;
 392                 are_stop(sc);
 393                 ARE_UNLOCK(sc);
 394                 taskqueue_drain(taskqueue_swi, &sc->are_link_task);
 395                 ether_ifdetach(ifp);
 396         }
 397 #ifdef ARE_MII
 398         if (sc->are_miibus)
 399                 device_delete_child(dev, sc->are_miibus);
 400 #endif
 401         bus_generic_detach(dev);
 402
 403         if (sc->are_intrhand)
 404                 bus_teardown_intr(dev, sc->are_irq, sc->are_intrhand);
 405         if (sc->are_irq)
 406                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->are_irq);
 407
 408         if (sc->are_res)
 409                 bus_release_resource(dev, SYS_RES_MEMORY, sc->are_rid,
 410                     sc->are_res);
 411
 412         if (ifp)
 413                 if_free(ifp);
 414
 415         are_dma_free(sc);
 416
 417         mtx_destroy(&sc->are_mtx);
 418
 419         return (0);
 420
 421 }
 422
 423 static int
 424 are_suspend(device_t dev)
 425 {
 426
 427         panic("%s", __func__);
 428         return 0;
 429 }
 430
 431 static int
 432 are_resume(device_t dev)
 433 {
 434
 435         panic("%s", __func__);
 436         return 0;
 437 }
 438
 439 static int
 440 are_shutdown(device_t dev)
 441 {
 442         struct are_softc        *sc;
 443
 444         sc = device_get_softc(dev);
 445
 446         ARE_LOCK(sc);
 447         are_stop(sc);
 448         ARE_UNLOCK(sc);
 449
 450         return (0);
 451 }
 452
 453 static int
 454 are_miibus_readreg(device_t dev, int phy, int reg)
 455 {
 456         struct are_softc * sc = device_get_softc(dev);
 457         uint32_t        addr;
 458         int             i;
 459
 460         addr = (phy << MIIADDR_PHY_SHIFT) | (reg << MIIADDR_REG_SHIFT);
 461         CSR_WRITE_4(sc, CSR_MIIADDR, addr);
 462         for (i = 0; i < 100000000; i++) {
 463                 if ((CSR_READ_4(sc, CSR_MIIADDR) & MIIADDR_BUSY) == 0)
 464                         break;
 465         }
 466
 467         return (CSR_READ_4(sc, CSR_MIIDATA) & 0xffff);
 468 }
 469
 470 static int
 471 are_miibus_writereg(device_t dev, int phy, int reg, int data)
 472 {
 473         struct are_softc * sc = device_get_softc(dev);
 474         uint32_t        addr;
 475         int             i;
 476
 477         /* write the data register */
 478         CSR_WRITE_4(sc, CSR_MIIDATA, data);
 479
 480         /* write the address to latch it in */
 481         addr = (phy << MIIADDR_PHY_SHIFT) | (reg << MIIADDR_REG_SHIFT) |
 482             MIIADDR_WRITE;
 483         CSR_WRITE_4(sc, CSR_MIIADDR, addr);
 484
 485         for (i = 0; i < 100000000; i++) {
 486                 if ((CSR_READ_4(sc, CSR_MIIADDR) & MIIADDR_BUSY) == 0)
 487                         break;
 488         }
 489
 490         return (0);
 491 }
 492
 493 static void
 494 are_miibus_statchg(device_t dev)
 495 {
 496         struct are_softc                *sc;
 497
 498         sc = device_get_softc(dev);
 499         taskqueue_enqueue(taskqueue_swi, &sc->are_link_task);
 500 }
 501
 502 static void
 503 are_link_task(void *arg, int pending)
 504 {
 505 #ifdef ARE_MII
 506         struct are_softc                *sc;
 507         struct mii_data         *mii;
 508         struct ifnet            *ifp;
 509         /* int                  lfdx, mfdx; */
 510
 511         sc = (struct are_softc *)arg;
 512
 513         ARE_LOCK(sc);
 514         mii = device_get_softc(sc->are_miibus);
 515         ifp = sc->are_ifp;
 516         if (mii == NULL || ifp == NULL ||
 517             (ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
 518                 ARE_UNLOCK(sc);
 519                 return;
 520         }
 521
 522         if (mii->mii_media_status & IFM_ACTIVE) {
 523                 if (IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE)
 524                         sc->are_link_status = 1;
 525         } else
 526                 sc->are_link_status = 0;
 527
 528         ARE_UNLOCK(sc);
 529 #endif
 530 }
 531
 532 static void
 533 are_reset(struct are_softc *sc)
 534 {
 535         int             i;
 536
 537         CSR_WRITE_4(sc, CSR_BUSMODE, BUSMODE_SWR);
 538
 539         /*
 540          * The chip doesn't take itself out of reset automatically.
 541          * We need to do so after 2us.
 542          */
 543         DELAY(10);
 544         CSR_WRITE_4(sc, CSR_BUSMODE, 0);
 545
 546         for (i = 0; i < 1000; i++) {
 547                 /*
 548                  * Wait a bit for the reset to complete before peeking
 549                  * at the chip again.
 550                  */
 551                 DELAY(10);
 552                 if ((CSR_READ_4(sc, CSR_BUSMODE) & BUSMODE_SWR) == 0)
 553                         break;
 554         }
 555
 556         if (CSR_READ_4(sc, CSR_BUSMODE) & BUSMODE_SWR)
 557                 device_printf(sc->are_dev, "reset time out\n");
 558
 559         DELAY(1000);
 560 }
 561
 562 static void
 563 are_init(void *xsc)
 564 {
 565         struct are_softc         *sc = xsc;
 566
 567         ARE_LOCK(sc);
 568         are_init_locked(sc);
 569         ARE_UNLOCK(sc);
 570 }
 571
 572 static void
 573 are_init_locked(struct are_softc *sc)
 574 {
 575         struct ifnet            *ifp = sc->are_ifp;
 576 #ifdef ARE_MII
 577         struct mii_data         *mii;
 578 #endif
 579
 580         ARE_LOCK_ASSERT(sc);
 581
 582 #ifdef ARE_MII
 583         mii = device_get_softc(sc->are_miibus);
 584 #endif
 585
 586         are_stop(sc);
 587         are_reset(sc);
 588
 589         /* Init circular RX list. */
 590         if (are_rx_ring_init(sc) != 0) {
 591                 device_printf(sc->are_dev,
 592                     "initialization failed: no memory for rx buffers\n");
 593                 are_stop(sc);
 594                 return;
 595         }
 596
 597         /* Init tx descriptors. */
 598         are_tx_ring_init(sc);
 599
 600         /*
 601          * Initialize the BUSMODE register.
 602          */
 603         CSR_WRITE_4(sc, CSR_BUSMODE,
 604             /* XXX: not sure if this is a good thing or not... */
 605             BUSMODE_BAR | BUSMODE_BLE | BUSMODE_PBL_4LW);
 606
 607         /*
 608          * Initialize the interrupt mask and enable interrupts.
 609          */
 610         /* normal interrupts */
 611         sc->sc_inten =  STATUS_TI | STATUS_TU | STATUS_RI | STATUS_NIS;
 612
 613         /* abnormal interrupts */
 614         sc->sc_inten |= STATUS_TPS | STATUS_TJT | STATUS_UNF |
 615             STATUS_RU | STATUS_RPS | STATUS_SE | STATUS_AIS;
 616
 617         sc->sc_rxint_mask = STATUS_RI|STATUS_RU;
 618         sc->sc_txint_mask = STATUS_TI|STATUS_UNF|STATUS_TJT;
 619
 620         sc->sc_rxint_mask &= sc->sc_inten;
 621         sc->sc_txint_mask &= sc->sc_inten;
 622
 623         CSR_WRITE_4(sc, CSR_INTEN, sc->sc_inten);
 624         CSR_WRITE_4(sc, CSR_STATUS, 0xffffffff);
 625
 626         /*
 627          * Give the transmit and receive rings to the chip.
 628          */
 629         CSR_WRITE_4(sc, CSR_TXLIST, ARE_TX_RING_ADDR(sc, 0));
 630         CSR_WRITE_4(sc, CSR_RXLIST, ARE_RX_RING_ADDR(sc, 0));
 631
 632         /*
 633          * Set the station address.
 634          */
 635         CSR_WRITE_4(sc, CSR_MACHI, sc->are_eaddr[5] << 16 | sc->are_eaddr[4]);
 636         CSR_WRITE_4(sc, CSR_MACLO, sc->are_eaddr[3] << 24 |
 637             sc->are_eaddr[2] << 16 | sc->are_eaddr[1] << 8 | sc->are_eaddr[0]);
 638
 639         /*
 640          * Start the mac.
 641          */
 642         CSR_WRITE_4(sc, CSR_FLOWC, FLOWC_FCE);
 643         CSR_WRITE_4(sc, CSR_MACCTL, MACCTL_RE | MACCTL_TE |
 644             MACCTL_PM | MACCTL_FDX | MACCTL_HBD | MACCTL_RA);
 645
 646         /*
 647          * Write out the opmode.
 648          */
 649         CSR_WRITE_4(sc, CSR_OPMODE, OPMODE_SR | OPMODE_ST | OPMODE_SF |
 650             OPMODE_TR_64);
 651
 652         /*
 653          * Start the receive process.
 654          */
 655         CSR_WRITE_4(sc, CSR_RXPOLL, RXPOLL_RPD);
 656
 657         sc->are_link_status = 1;
 658 #ifdef ARE_MII
 659         mii_mediachg(mii);
 660 #endif
 661
 662         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 663         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 664
 665         callout_reset(&sc->are_stat_callout, hz, are_tick, sc);
 666 }
 667
 668 static void
 669 are_start(struct ifnet *ifp)
 670 {
 671         struct are_softc         *sc;
 672
 673         sc = ifp->if_softc;
 674
 675         ARE_LOCK(sc);
 676         are_start_locked(ifp);
 677         ARE_UNLOCK(sc);
 678 }
 679
 680 /*
 681  * Encapsulate an mbuf chain in a descriptor by coupling the mbuf data
 682  * pointers to the fragment pointers.
 683  */
 684 static int
 685 are_encap(struct are_softc *sc, struct mbuf **m_head)
 686 {
 687         struct are_txdesc       *txd;
 688         struct are_desc         *desc, *prev_desc;
 689         bus_dma_segment_t       txsegs[ARE_MAXFRAGS];
 690         uint32_t                link_addr;
 691         int                     error, i, nsegs, prod, si, prev_prod;
 692         int                     txstat;
 693
 694         ARE_LOCK_ASSERT(sc);
 695
 696         prod = sc->are_cdata.are_tx_prod;
 697         txd = &sc->are_cdata.are_txdesc[prod];
 698         error = bus_dmamap_load_mbuf_sg(sc->are_cdata.are_tx_tag, txd->tx_dmamap,
 699             *m_head, txsegs, &nsegs, BUS_DMA_NOWAIT);
 700         if (error == EFBIG) {
 701                 panic("EFBIG");
 702         } else if (error != 0)
 703                 return (error);
 704         if (nsegs == 0) {
 705                 m_freem(*m_head);
 706                 *m_head = NULL;
 707                 return (EIO);
 708         }
 709
 710         /* Check number of available descriptors. */
 711         if (sc->are_cdata.are_tx_cnt + nsegs >= (ARE_TX_RING_CNT - 1)) {
 712                 bus_dmamap_unload(sc->are_cdata.are_tx_tag, txd->tx_dmamap);
 713                 return (ENOBUFS);
 714         }
 715
 716         txd->tx_m = *m_head;
 717         bus_dmamap_sync(sc->are_cdata.are_tx_tag, txd->tx_dmamap,
 718             BUS_DMASYNC_PREWRITE);
 719
 720         si = prod;
 721
 722         /*
 723          * Make a list of descriptors for this packet. DMA controller will
 724          * walk through it while are_link is not zero. The last one should
 725          * have COF flag set, to pickup next chain from NDPTR
 726          */
 727         prev_prod = prod;
 728         desc = prev_desc = NULL;
 729         for (i = 0; i < nsegs; i++) {
 730                 desc = &sc->are_rdata.are_tx_ring[prod];
 731                 desc->are_stat = ADSTAT_OWN;
 732                 desc->are_devcs = ARE_DMASIZE(txsegs[i].ds_len) | ADCTL_CH;
 733                 if (i == 0)
 734                         desc->are_devcs |= ADCTL_Tx_FS;
 735                 desc->are_addr = txsegs[i].ds_addr;
 736                 /* link with previous descriptor */
 737                 if (prev_desc)
 738                         prev_desc->are_link = ARE_TX_RING_ADDR(sc, prod);
 739
 740                 sc->are_cdata.are_tx_cnt++;
 741                 prev_desc = desc;
 742                 ARE_INC(prod, ARE_TX_RING_CNT);
 743         }
 744
 745         /*
 746          * Set mark last fragment with LD flag
 747          */
 748         if (desc) {
 749                 desc->are_devcs |= ADCTL_Tx_IC;
 750                 desc->are_devcs |= ADCTL_Tx_LS;
 751         }
 752
 753         /* Update producer index. */
 754         sc->are_cdata.are_tx_prod = prod;
 755
 756         /* Sync descriptors. */
 757         bus_dmamap_sync(sc->are_cdata.are_tx_ring_tag,
 758             sc->are_cdata.are_tx_ring_map,
 759             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 760
 761         /* Start transmitting */
 762         /* Check if new list is queued in NDPTR */
 763         txstat = (CSR_READ_4(sc, CSR_STATUS) >> 20) & 7;
 764         if (txstat == 0 || txstat == 6) {
 765                 /* Transmit Process Stat is stop or suspended */
 766                 CSR_WRITE_4(sc, CSR_TXPOLL, TXPOLL_TPD);
 767         }
 768         else {
 769                 link_addr = ARE_TX_RING_ADDR(sc, si);
 770                 /* Get previous descriptor */
 771                 si = (si + ARE_TX_RING_CNT - 1) % ARE_TX_RING_CNT;
 772                 desc = &sc->are_rdata.are_tx_ring[si];
 773                 desc->are_link = link_addr;
 774         }
 775
 776         return (0);
 777 }
 778
 779 static void
 780 are_start_locked(struct ifnet *ifp)
 781 {
 782         struct are_softc                *sc;
 783         struct mbuf             *m_head;
 784         int                     enq;
 785
 786         sc = ifp->if_softc;
 787
 788         ARE_LOCK_ASSERT(sc);
 789
 790         if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
 791             IFF_DRV_RUNNING || sc->are_link_status == 0 )
 792                 return;
 793
 794         for (enq = 0; !IFQ_DRV_IS_EMPTY(&ifp->if_snd) &&
 795             sc->are_cdata.are_tx_cnt < ARE_TX_RING_CNT - 2; ) {
 796                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head);
 797                 if (m_head == NULL)
 798                         break;
 799                 /*
 800                  * Pack the data into the transmit ring. If we
 801                  * don't have room, set the OACTIVE flag and wait
 802                  * for the NIC to drain the ring.
 803                  */
 804                 if (are_encap(sc, &m_head)) {
 805                         if (m_head == NULL)
 806                                 break;
 807                         IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
 808                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 809                         break;
 810                 }
 811
 812                 enq++;
 813                 /*
 814                  * If there's a BPF listener, bounce a copy of this frame
 815                  * to him.
 816                  */
 817                 ETHER_BPF_MTAP(ifp, m_head);
 818         }
 819 }
 820
 821 static void
 822 are_stop(struct are_softc *sc)
 823 {
 824         struct ifnet        *ifp;
 825
 826         ARE_LOCK_ASSERT(sc);
 827
 828         ifp = sc->are_ifp;
 829         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 830         callout_stop(&sc->are_stat_callout);
 831
 832         /* Disable interrupts. */
 833         CSR_WRITE_4(sc, CSR_INTEN, 0);
 834
 835         /* Stop the transmit and receive processes. */
 836         CSR_WRITE_4(sc, CSR_OPMODE, 0);
 837         CSR_WRITE_4(sc, CSR_RXLIST, 0);
 838         CSR_WRITE_4(sc, CSR_TXLIST, 0);
 839         CSR_WRITE_4(sc, CSR_MACCTL,
 840             CSR_READ_4(sc, CSR_MACCTL) & ~(MACCTL_TE | MACCTL_RE));
 841
 842 }
 843
 844 static int
 845 are_set_filter(struct are_softc *sc)
 846 {
 847         struct ifnet        *ifp;
 848         int mchash[2];
 849         int macctl;
 850
 851         ifp = sc->are_ifp;
 852
 853         macctl = CSR_READ_4(sc, CSR_MACCTL);
 854         macctl &= ~(MACCTL_PR | MACCTL_PM);
 855         macctl |= MACCTL_HBD;
 856
 857         if (ifp->if_flags & IFF_PROMISC)
 858                 macctl |= MACCTL_PR;
 859
 860         /* Todo: hash table set.
 861          * But I don't know how to use multicast hash table at this soc.
 862          */
 863
 864         /* this is allmulti */
 865         mchash[0] = mchash[1] = 0xffffffff;
 866         macctl |= MACCTL_PM;
 867
 868         CSR_WRITE_4(sc, CSR_HTLO, mchash[0]);
 869         CSR_WRITE_4(sc, CSR_HTHI, mchash[1]);
 870         CSR_WRITE_4(sc, CSR_MACCTL, macctl);
 871
 872         return 0;
 873 }
 874
 875 static int
 876 are_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
 877 {
 878         struct are_softc                *sc = ifp->if_softc;
 879         struct ifreq            *ifr = (struct ifreq *) data;
 880 #ifdef ARE_MII
 881         struct mii_data         *mii;
 882 #endif
 883         int                     error;
 884
 885         switch (command) {
 886         case SIOCSIFFLAGS:
 887                 ARE_LOCK(sc);
 888                 if (ifp->if_flags & IFF_UP) {
 889                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
 890                                 if ((ifp->if_flags ^ sc->are_if_flags) &
 891                                     (IFF_PROMISC | IFF_ALLMULTI))
 892                                         are_set_filter(sc);
 893                         } else {
 894                                 if (sc->are_detach == 0)
 895                                         are_init_locked(sc);
 896                         }
 897                 } else {
 898                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 899                                 are_stop(sc);
 900                 }
 901                 sc->are_if_flags = ifp->if_flags;
 902                 ARE_UNLOCK(sc);
 903                 error = 0;
 904                 break;
 905         case SIOCADDMULTI:
 906         case SIOCDELMULTI:
 907                 ARE_LOCK(sc);
 908                 are_set_filter(sc);
 909                 ARE_UNLOCK(sc);
 910                 error = 0;
 911                 break;
 912         case SIOCGIFMEDIA:
 913         case SIOCSIFMEDIA:
 914 #ifdef ARE_MII
 915                 mii = device_get_softc(sc->are_miibus);
 916                 error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
 917 #else
 918                 error = ifmedia_ioctl(ifp, ifr, &sc->are_ifmedia, command);
 919 #endif
 920                 break;
 921         case SIOCSIFCAP:
 922                 error = 0;
 923                 break;
 924         default:
 925                 error = ether_ioctl(ifp, command, data);
 926                 break;
 927         }
 928
 929         return (error);
 930 }
 931
 932 /*
 933  * Set media options.
 934  */
 935 static int
 936 are_ifmedia_upd(struct ifnet *ifp)
 937 {
 938 #ifdef ARE_MII
 939         struct are_softc                *sc;
 940         struct mii_data         *mii;
 941         struct mii_softc        *miisc;
 942         int                     error;
 943
 944         sc = ifp->if_softc;
 945         ARE_LOCK(sc);
 946         mii = device_get_softc(sc->are_miibus);
 947         LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
 948                 PHY_RESET(miisc);
 949         error = mii_mediachg(mii);
 950         ARE_UNLOCK(sc);
 951
 952         return (error);
 953 #else
 954         return (0);
 955 #endif
 956 }
 957
 958 /*
 959  * Report current media status.
 960  */
 961 static void
 962 are_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 963 {
 964 #ifdef ARE_MII
 965         struct are_softc                *sc = ifp->if_softc;
 966         struct mii_data         *mii;
 967
 968         mii = device_get_softc(sc->are_miibus);
 969         ARE_LOCK(sc);
 970         mii_pollstat(mii);
 971         ifmr->ifm_active = mii->mii_media_active;
 972         ifmr->ifm_status = mii->mii_media_status;
 973         ARE_UNLOCK(sc);
 974 #else
 975         ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
 976 #endif
 977 }
 978
 979 struct are_dmamap_arg {
 980         bus_addr_t      are_busaddr;
 981 };
 982
 983 static void
 984 are_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 985 {
 986         struct are_dmamap_arg   *ctx;
 987
 988         if (error != 0)
 989                 return;
 990         ctx = arg;
 991         ctx->are_busaddr = segs[0].ds_addr;
 992 }
 993
 994 static int
 995 are_dma_alloc(struct are_softc *sc)
 996 {
 997         struct are_dmamap_arg   ctx;
 998         struct are_txdesc       *txd;
 999         struct are_rxdesc       *rxd;
1000         int                     error, i;
1001
1002         /* Create parent DMA tag. */
1003         error = bus_dma_tag_create(
1004             bus_get_dma_tag(sc->are_dev),       /* parent */
1005             1, 0,                       /* alignment, boundary */
1006             BUS_SPACE_MAXADDR_32BIT,    /* lowaddr */
1007             BUS_SPACE_MAXADDR,          /* highaddr */
1008             NULL, NULL,                 /* filter, filterarg */
1009             BUS_SPACE_MAXSIZE_32BIT,    /* maxsize */
1010             0,                          /* nsegments */
1011             BUS_SPACE_MAXSIZE_32BIT,    /* maxsegsize */
1012             0,                          /* flags */
1013             NULL, NULL,                 /* lockfunc, lockarg */
1014             &sc->are_cdata.are_parent_tag);
1015         if (error != 0) {
1016                 device_printf(sc->are_dev, "failed to create parent DMA tag\n");
1017                 goto fail;
1018         }
1019         /* Create tag for Tx ring. */
1020         error = bus_dma_tag_create(
1021             sc->are_cdata.are_parent_tag,       /* parent */
1022             ARE_RING_ALIGN, 0,          /* alignment, boundary */
1023             BUS_SPACE_MAXADDR,          /* lowaddr */
1024             BUS_SPACE_MAXADDR,          /* highaddr */
1025             NULL, NULL,                 /* filter, filterarg */
1026             ARE_TX_RING_SIZE,           /* maxsize */
1027             1,                          /* nsegments */
1028             ARE_TX_RING_SIZE,           /* maxsegsize */
1029             0,                          /* flags */
1030             NULL, NULL,                 /* lockfunc, lockarg */
1031             &sc->are_cdata.are_tx_ring_tag);
1032         if (error != 0) {
1033                 device_printf(sc->are_dev, "failed to create Tx ring DMA tag\n");
1034                 goto fail;
1035         }
1036
1037         /* Create tag for Rx ring. */
1038         error = bus_dma_tag_create(
1039             sc->are_cdata.are_parent_tag,       /* parent */
1040             ARE_RING_ALIGN, 0,          /* alignment, boundary */
1041             BUS_SPACE_MAXADDR,          /* lowaddr */
1042             BUS_SPACE_MAXADDR,          /* highaddr */
1043             NULL, NULL,                 /* filter, filterarg */
1044             ARE_RX_RING_SIZE,           /* maxsize */
1045             1,                          /* nsegments */
1046             ARE_RX_RING_SIZE,           /* maxsegsize */
1047             0,                          /* flags */
1048             NULL, NULL,                 /* lockfunc, lockarg */
1049             &sc->are_cdata.are_rx_ring_tag);
1050         if (error != 0) {
1051                 device_printf(sc->are_dev, "failed to create Rx ring DMA tag\n");
1052                 goto fail;
1053         }
1054
1055         /* Create tag for Tx buffers. */
1056         error = bus_dma_tag_create(
1057             sc->are_cdata.are_parent_tag,       /* parent */
1058             sizeof(uint32_t), 0,        /* alignment, boundary */
1059             BUS_SPACE_MAXADDR,          /* lowaddr */
1060             BUS_SPACE_MAXADDR,          /* highaddr */
1061             NULL, NULL,                 /* filter, filterarg */
1062             MCLBYTES * ARE_MAXFRAGS,    /* maxsize */
1063             ARE_MAXFRAGS,               /* nsegments */
1064             MCLBYTES,                   /* maxsegsize */
1065             0,                          /* flags */
1066             NULL, NULL,                 /* lockfunc, lockarg */
1067             &sc->are_cdata.are_tx_tag);
1068         if (error != 0) {
1069                 device_printf(sc->are_dev, "failed to create Tx DMA tag\n");
1070                 goto fail;
1071         }
1072
1073         /* Create tag for Rx buffers. */
1074         error = bus_dma_tag_create(
1075             sc->are_cdata.are_parent_tag,       /* parent */
1076             ARE_RX_ALIGN, 0,            /* alignment, boundary */
1077             BUS_SPACE_MAXADDR,          /* lowaddr */
1078             BUS_SPACE_MAXADDR,          /* highaddr */
1079             NULL, NULL,                 /* filter, filterarg */
1080             MCLBYTES,                   /* maxsize */
1081             1,                          /* nsegments */
1082             MCLBYTES,                   /* maxsegsize */
1083             0,                          /* flags */
1084             NULL, NULL,                 /* lockfunc, lockarg */
1085             &sc->are_cdata.are_rx_tag);
1086         if (error != 0) {
1087                 device_printf(sc->are_dev, "failed to create Rx DMA tag\n");
1088                 goto fail;
1089         }
1090
1091         /* Allocate DMA'able memory and load the DMA map for Tx ring. */
1092         error = bus_dmamem_alloc(sc->are_cdata.are_tx_ring_tag,
1093             (void **)&sc->are_rdata.are_tx_ring, BUS_DMA_WAITOK |
1094             BUS_DMA_COHERENT | BUS_DMA_ZERO, &sc->are_cdata.are_tx_ring_map);
1095         if (error != 0) {
1096                 device_printf(sc->are_dev,
1097                     "failed to allocate DMA'able memory for Tx ring\n");
1098                 goto fail;
1099         }
1100
1101         ctx.are_busaddr = 0;
1102         error = bus_dmamap_load(sc->are_cdata.are_tx_ring_tag,
1103             sc->are_cdata.are_tx_ring_map, sc->are_rdata.are_tx_ring,
1104             ARE_TX_RING_SIZE, are_dmamap_cb, &ctx, 0);
1105         if (error != 0 || ctx.are_busaddr == 0) {
1106                 device_printf(sc->are_dev,
1107                     "failed to load DMA'able memory for Tx ring\n");
1108                 goto fail;
1109         }
1110         sc->are_rdata.are_tx_ring_paddr = ctx.are_busaddr;
1111
1112         /* Allocate DMA'able memory and load the DMA map for Rx ring. */
1113         error = bus_dmamem_alloc(sc->are_cdata.are_rx_ring_tag,
1114             (void **)&sc->are_rdata.are_rx_ring, BUS_DMA_WAITOK |
1115             BUS_DMA_COHERENT | BUS_DMA_ZERO, &sc->are_cdata.are_rx_ring_map);
1116         if (error != 0) {
1117                 device_printf(sc->are_dev,
1118                     "failed to allocate DMA'able memory for Rx ring\n");
1119                 goto fail;
1120         }
1121
1122         ctx.are_busaddr = 0;
1123         error = bus_dmamap_load(sc->are_cdata.are_rx_ring_tag,
1124             sc->are_cdata.are_rx_ring_map, sc->are_rdata.are_rx_ring,
1125             ARE_RX_RING_SIZE, are_dmamap_cb, &ctx, 0);
1126         if (error != 0 || ctx.are_busaddr == 0) {
1127                 device_printf(sc->are_dev,
1128                     "failed to load DMA'able memory for Rx ring\n");
1129                 goto fail;
1130         }
1131         sc->are_rdata.are_rx_ring_paddr = ctx.are_busaddr;
1132
1133         /* Create DMA maps for Tx buffers. */
1134         for (i = 0; i < ARE_TX_RING_CNT; i++) {
1135                 txd = &sc->are_cdata.are_txdesc[i];
1136                 txd->tx_m = NULL;
1137                 txd->tx_dmamap = NULL;
1138                 error = bus_dmamap_create(sc->are_cdata.are_tx_tag, 0,
1139                     &txd->tx_dmamap);
1140                 if (error != 0) {
1141                         device_printf(sc->are_dev,
1142                             "failed to create Tx dmamap\n");
1143                         goto fail;
1144                 }
1145         }
1146         /* Create DMA maps for Rx buffers. */
1147         if ((error = bus_dmamap_create(sc->are_cdata.are_rx_tag, 0,
1148             &sc->are_cdata.are_rx_sparemap)) != 0) {
1149                 device_printf(sc->are_dev,
1150                     "failed to create spare Rx dmamap\n");
1151                 goto fail;
1152         }
1153         for (i = 0; i < ARE_RX_RING_CNT; i++) {
1154                 rxd = &sc->are_cdata.are_rxdesc[i];
1155                 rxd->rx_m = NULL;
1156                 rxd->rx_dmamap = NULL;
1157                 error = bus_dmamap_create(sc->are_cdata.are_rx_tag, 0,
1158                     &rxd->rx_dmamap);
1159                 if (error != 0) {
1160                         device_printf(sc->are_dev,
1161                             "failed to create Rx dmamap\n");
1162                         goto fail;
1163                 }
1164         }
1165
1166 fail:
1167         return (error);
1168 }
1169
1170 static void
1171 are_dma_free(struct are_softc *sc)
1172 {
1173         struct are_txdesc       *txd;
1174         struct are_rxdesc       *rxd;
1175         int                     i;
1176
1177         /* Tx ring. */
1178         if (sc->are_cdata.are_tx_ring_tag) {
1179                 if (sc->are_rdata.are_tx_ring_paddr)
1180                         bus_dmamap_unload(sc->are_cdata.are_tx_ring_tag,
1181                             sc->are_cdata.are_tx_ring_map);
1182                 if (sc->are_rdata.are_tx_ring)
1183                         bus_dmamem_free(sc->are_cdata.are_tx_ring_tag,
1184                             sc->are_rdata.are_tx_ring,
1185                             sc->are_cdata.are_tx_ring_map);
1186                 sc->are_rdata.are_tx_ring = NULL;
1187                 sc->are_rdata.are_tx_ring_paddr = 0;
1188                 bus_dma_tag_destroy(sc->are_cdata.are_tx_ring_tag);
1189                 sc->are_cdata.are_tx_ring_tag = NULL;
1190         }
1191         /* Rx ring. */
1192         if (sc->are_cdata.are_rx_ring_tag) {
1193                 if (sc->are_rdata.are_rx_ring_paddr)
1194                         bus_dmamap_unload(sc->are_cdata.are_rx_ring_tag,
1195                             sc->are_cdata.are_rx_ring_map);
1196                 if (sc->are_rdata.are_rx_ring)
1197                         bus_dmamem_free(sc->are_cdata.are_rx_ring_tag,
1198                             sc->are_rdata.are_rx_ring,
1199                             sc->are_cdata.are_rx_ring_map);
1200                 sc->are_rdata.are_rx_ring = NULL;
1201                 sc->are_rdata.are_rx_ring_paddr = 0;
1202                 bus_dma_tag_destroy(sc->are_cdata.are_rx_ring_tag);
1203                 sc->are_cdata.are_rx_ring_tag = NULL;
1204         }
1205         /* Tx buffers. */
1206         if (sc->are_cdata.are_tx_tag) {
1207                 for (i = 0; i < ARE_TX_RING_CNT; i++) {
1208                         txd = &sc->are_cdata.are_txdesc[i];
1209                         if (txd->tx_dmamap) {
1210                                 bus_dmamap_destroy(sc->are_cdata.are_tx_tag,
1211                                     txd->tx_dmamap);
1212                                 txd->tx_dmamap = NULL;
1213                         }
1214                 }
1215                 bus_dma_tag_destroy(sc->are_cdata.are_tx_tag);
1216                 sc->are_cdata.are_tx_tag = NULL;
1217         }
1218         /* Rx buffers. */
1219         if (sc->are_cdata.are_rx_tag) {
1220                 for (i = 0; i < ARE_RX_RING_CNT; i++) {
1221                         rxd = &sc->are_cdata.are_rxdesc[i];
1222                         if (rxd->rx_dmamap) {
1223                                 bus_dmamap_destroy(sc->are_cdata.are_rx_tag,
1224                                     rxd->rx_dmamap);
1225                                 rxd->rx_dmamap = NULL;
1226                         }
1227                 }
1228                 if (sc->are_cdata.are_rx_sparemap) {
1229                         bus_dmamap_destroy(sc->are_cdata.are_rx_tag,
1230                             sc->are_cdata.are_rx_sparemap);
1231                         sc->are_cdata.are_rx_sparemap = 0;
1232                 }
1233                 bus_dma_tag_destroy(sc->are_cdata.are_rx_tag);
1234                 sc->are_cdata.are_rx_tag = NULL;
1235         }
1236
1237         if (sc->are_cdata.are_parent_tag) {
1238                 bus_dma_tag_destroy(sc->are_cdata.are_parent_tag);
1239                 sc->are_cdata.are_parent_tag = NULL;
1240         }
1241 }
1242
1243 /*
1244  * Initialize the transmit descriptors.
1245  */
1246 static int
1247 are_tx_ring_init(struct are_softc *sc)
1248 {
1249         struct are_ring_data    *rd;
1250         struct are_txdesc       *txd;
1251         bus_addr_t              addr;
1252         int                     i;
1253
1254         sc->are_cdata.are_tx_prod = 0;
1255         sc->are_cdata.are_tx_cons = 0;
1256         sc->are_cdata.are_tx_cnt = 0;
1257         sc->are_cdata.are_tx_pkts = 0;
1258
1259         rd = &sc->are_rdata;
1260         bzero(rd->are_tx_ring, ARE_TX_RING_SIZE);
1261         for (i = 0; i < ARE_TX_RING_CNT; i++) {
1262                 if (i == ARE_TX_RING_CNT - 1)
1263                         addr = ARE_TX_RING_ADDR(sc, 0);
1264                 else
1265                         addr = ARE_TX_RING_ADDR(sc, i + 1);
1266                 rd->are_tx_ring[i].are_stat = 0;
1267                 rd->are_tx_ring[i].are_devcs = 0;
1268                 rd->are_tx_ring[i].are_addr = 0;
1269                 rd->are_tx_ring[i].are_link = addr;
1270                 txd = &sc->are_cdata.are_txdesc[i];
1271                 txd->tx_m = NULL;
1272         }
1273
1274         bus_dmamap_sync(sc->are_cdata.are_tx_ring_tag,
1275             sc->are_cdata.are_tx_ring_map,
1276             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1277
1278         return (0);
1279 }
1280
1281 /*
1282  * Initialize the RX descriptors and allocate mbufs for them. Note that
1283  * we arrange the descriptors in a closed ring, so that the last descriptor
1284  * points back to the first.
1285  */
1286 static int
1287 are_rx_ring_init(struct are_softc *sc)
1288 {
1289         struct are_ring_data    *rd;
1290         struct are_rxdesc       *rxd;
1291         bus_addr_t              addr;
1292         int                     i;
1293
1294         sc->are_cdata.are_rx_cons = 0;
1295
1296         rd = &sc->are_rdata;
1297         bzero(rd->are_rx_ring, ARE_RX_RING_SIZE);
1298         for (i = 0; i < ARE_RX_RING_CNT; i++) {
1299                 rxd = &sc->are_cdata.are_rxdesc[i];
1300                 rxd->rx_m = NULL;
1301                 rxd->desc = &rd->are_rx_ring[i];
1302                 if (i == ARE_RX_RING_CNT - 1)
1303                         addr = ARE_RX_RING_ADDR(sc, 0);
1304                 else
1305                         addr = ARE_RX_RING_ADDR(sc, i + 1);
1306                 rd->are_rx_ring[i].are_stat = ADSTAT_OWN;
1307                 rd->are_rx_ring[i].are_devcs = ADCTL_CH;
1308                 if (i == ARE_RX_RING_CNT - 1)
1309                         rd->are_rx_ring[i].are_devcs |= ADCTL_ER;
1310                 rd->are_rx_ring[i].are_addr = 0;
1311                 rd->are_rx_ring[i].are_link = addr;
1312                 if (are_newbuf(sc, i) != 0)
1313                         return (ENOBUFS);
1314         }
1315
1316         bus_dmamap_sync(sc->are_cdata.are_rx_ring_tag,
1317             sc->are_cdata.are_rx_ring_map,
1318             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1319
1320         return (0);
1321 }
1322
1323 /*
1324  * Initialize an RX descriptor and attach an MBUF cluster.
1325  */
1326 static int
1327 are_newbuf(struct are_softc *sc, int idx)
1328 {
1329         struct are_desc         *desc;
1330         struct are_rxdesc       *rxd;
1331         struct mbuf             *m;
1332         bus_dma_segment_t       segs[1];
1333         bus_dmamap_t            map;
1334         int                     nsegs;
1335
1336         m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1337         if (m == NULL)
1338                 return (ENOBUFS);
1339         m->m_len = m->m_pkthdr.len = MCLBYTES;
1340
1341         /* tcp header boundary margin */
1342         m_adj(m, 4);
1343
1344         if (bus_dmamap_load_mbuf_sg(sc->are_cdata.are_rx_tag,
1345             sc->are_cdata.are_rx_sparemap, m, segs, &nsegs, 0) != 0) {
1346                 m_freem(m);
1347                 return (ENOBUFS);
1348         }
1349         KASSERT(nsegs == 1, ("%s: %d segments returned!", __func__, nsegs));
1350
1351         rxd = &sc->are_cdata.are_rxdesc[idx];
1352         if (rxd->rx_m != NULL) {
1353                 /*
1354                  * THis is if_kr.c original code but make bug. Make scranble on buffer data.
1355                  * bus_dmamap_sync(sc->are_cdata.are_rx_tag, rxd->rx_dmamap,
1356                  *    BUS_DMASYNC_POSTREAD);
1357                  */
1358                 bus_dmamap_unload(sc->are_cdata.are_rx_tag, rxd->rx_dmamap);
1359         }
1360         map = rxd->rx_dmamap;
1361         rxd->rx_dmamap = sc->are_cdata.are_rx_sparemap;
1362         sc->are_cdata.are_rx_sparemap = map;
1363         bus_dmamap_sync(sc->are_cdata.are_rx_tag, rxd->rx_dmamap,
1364             BUS_DMASYNC_PREREAD);
1365         rxd->rx_m = m;
1366         desc = rxd->desc;
1367         desc->are_addr = segs[0].ds_addr;
1368         desc->are_devcs |= ARE_DMASIZE(segs[0].ds_len);
1369         rxd->saved_ca = desc->are_addr ;
1370         rxd->saved_ctl = desc->are_stat ;
1371
1372         return (0);
1373 }
1374
1375 static __inline void
1376 are_fixup_rx(struct mbuf *m)
1377 {
1378         int             i;
1379         uint16_t        *src, *dst;
1380
1381         src = mtod(m, uint16_t *);
1382         dst = src - 1;
1383
1384         for (i = 0; i < m->m_len / sizeof(uint16_t); i++) {
1385                 *dst++ = *src++;
1386         }
1387
1388         if (m->m_len % sizeof(uint16_t))
1389                 *(uint8_t *)dst = *(uint8_t *)src;
1390
1391         m->m_data -= ETHER_ALIGN;
1392 }
1393
1394
1395 static void
1396 are_tx(struct are_softc *sc)
1397 {
1398         struct are_txdesc       *txd;
1399         struct are_desc         *cur_tx;
1400         struct ifnet            *ifp;
1401         uint32_t                ctl, devcs;
1402         int                     cons, prod;
1403
1404         ARE_LOCK_ASSERT(sc);
1405
1406         cons = sc->are_cdata.are_tx_cons;
1407         prod = sc->are_cdata.are_tx_prod;
1408         if (cons == prod)
1409                 return;
1410
1411         bus_dmamap_sync(sc->are_cdata.are_tx_ring_tag,
1412             sc->are_cdata.are_tx_ring_map,
1413             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1414
1415         ifp = sc->are_ifp;
1416         /*
1417          * Go through our tx list and free mbufs for those
1418          * frames that have been transmitted.
1419          */
1420         for (; cons != prod; ARE_INC(cons, ARE_TX_RING_CNT)) {
1421                 cur_tx = &sc->are_rdata.are_tx_ring[cons];
1422                 ctl = cur_tx->are_stat;
1423                 devcs = cur_tx->are_devcs;
1424                 /* Check if descriptor has "finished" flag */
1425                 if (ARE_DMASIZE(devcs) == 0)
1426                         break;
1427
1428                 sc->are_cdata.are_tx_cnt--;
1429                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1430
1431                 txd = &sc->are_cdata.are_txdesc[cons];
1432
1433                 if ((ctl & ADSTAT_Tx_ES) == 0)
1434                         if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
1435                 else {
1436                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
1437                 }
1438
1439                 bus_dmamap_sync(sc->are_cdata.are_tx_tag, txd->tx_dmamap,
1440                     BUS_DMASYNC_POSTWRITE);
1441                 bus_dmamap_unload(sc->are_cdata.are_tx_tag, txd->tx_dmamap);
1442
1443                 /* Free only if it's first descriptor in list */
1444                 if (txd->tx_m)
1445                         m_freem(txd->tx_m);
1446                 txd->tx_m = NULL;
1447
1448                 /* reset descriptor */
1449                 cur_tx->are_stat = 0;
1450                 cur_tx->are_devcs = 0;
1451                 cur_tx->are_addr = 0;
1452         }
1453
1454         sc->are_cdata.are_tx_cons = cons;
1455
1456         bus_dmamap_sync(sc->are_cdata.are_tx_ring_tag,
1457             sc->are_cdata.are_tx_ring_map, BUS_DMASYNC_PREWRITE);
1458 }
1459
1460
1461 static void
1462 are_rx(struct are_softc *sc)
1463 {
1464         struct are_rxdesc       *rxd;
1465         struct ifnet            *ifp = sc->are_ifp;
1466         int                     cons, prog, packet_len, error;
1467         struct are_desc         *cur_rx;
1468         struct mbuf             *m;
1469
1470         ARE_LOCK_ASSERT(sc);
1471
1472         cons = sc->are_cdata.are_rx_cons;
1473
1474         bus_dmamap_sync(sc->are_cdata.are_rx_ring_tag,
1475             sc->are_cdata.are_rx_ring_map,
1476             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1477
1478         for (prog = 0; prog < ARE_RX_RING_CNT; ARE_INC(cons, ARE_RX_RING_CNT)) {
1479                 cur_rx = &sc->are_rdata.are_rx_ring[cons];
1480                 rxd = &sc->are_cdata.are_rxdesc[cons];
1481                 m = rxd->rx_m;
1482
1483                 if ((cur_rx->are_stat & ADSTAT_OWN) == ADSTAT_OWN)
1484                        break;
1485
1486                 prog++;
1487
1488                 packet_len = ADSTAT_Rx_LENGTH(cur_rx->are_stat);
1489                 /* Assume it's error */
1490                 error = 1;
1491
1492                 if (packet_len < 64)
1493                         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
1494                 else if ((cur_rx->are_stat & ADSTAT_Rx_DE) == 0) {
1495                         error = 0;
1496                         bus_dmamap_sync(sc->are_cdata.are_rx_tag, rxd->rx_dmamap,
1497                             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1498                         m = rxd->rx_m;
1499                         /* Skip 4 bytes of CRC */
1500                         m->m_pkthdr.len = m->m_len = packet_len - ETHER_CRC_LEN;
1501                         are_fixup_rx(m);
1502                         m->m_pkthdr.rcvif = ifp;
1503                         if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
1504
1505                         ARE_UNLOCK(sc);
1506                         (*ifp->if_input)(ifp, m);
1507                         ARE_LOCK(sc);
1508                 }
1509
1510                 if (error) {
1511                         /* Restore CONTROL and CA values, reset DEVCS */
1512                         cur_rx->are_stat = rxd->saved_ctl;
1513                         cur_rx->are_addr = rxd->saved_ca;
1514                         cur_rx->are_devcs = 0;
1515                 }
1516                 else {
1517                         /* Reinit descriptor */
1518                         cur_rx->are_stat = ADSTAT_OWN;
1519                         cur_rx->are_devcs = 0;
1520                         if (cons == ARE_RX_RING_CNT - 1)
1521                                 cur_rx->are_devcs |= ADCTL_ER;
1522                         cur_rx->are_addr = 0;
1523                         if (are_newbuf(sc, cons) != 0) {
1524                                 device_printf(sc->are_dev,
1525                                     "Failed to allocate buffer\n");
1526                                 break;
1527                         }
1528                 }
1529
1530                 bus_dmamap_sync(sc->are_cdata.are_rx_ring_tag,
1531                     sc->are_cdata.are_rx_ring_map,
1532                     BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1533
1534         }
1535
1536         if (prog > 0) {
1537                 sc->are_cdata.are_rx_cons = cons;
1538
1539                 bus_dmamap_sync(sc->are_cdata.are_rx_ring_tag,
1540                     sc->are_cdata.are_rx_ring_map,
1541                     BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1542         }
1543 }
1544
1545 static void
1546 are_intr(void *arg)
1547 {
1548         struct are_softc                *sc = arg;
1549         uint32_t                status;
1550         struct ifnet            *ifp = sc->are_ifp;
1551
1552         ARE_LOCK(sc);
1553
1554         /* mask out interrupts */
1555
1556         status = CSR_READ_4(sc, CSR_STATUS);
1557         if (status) {
1558                 CSR_WRITE_4(sc, CSR_STATUS, status);
1559         }
1560         if (status & sc->sc_rxint_mask) {
1561                 are_rx(sc);
1562         }
1563         if (status & sc->sc_txint_mask) {
1564                 are_tx(sc);
1565         }
1566
1567         /* Try to get more packets going. */
1568         are_start(ifp);
1569
1570         ARE_UNLOCK(sc);
1571 }
1572
1573 static void
1574 are_tick(void *xsc)
1575 {
1576 #ifdef ARE_MII
1577         struct are_softc                *sc = xsc;
1578         struct mii_data         *mii;
1579
1580         ARE_LOCK_ASSERT(sc);
1581
1582         mii = device_get_softc(sc->are_miibus);
1583         mii_tick(mii);
1584         callout_reset(&sc->are_stat_callout, hz, are_tick, sc);
1585 #endif
1586 }
1587
1588 static void
1589 are_hinted_child(device_t bus, const char *dname, int dunit)
1590 {
1591         BUS_ADD_CHILD(bus, 0, dname, dunit);
1592         device_printf(bus, "hinted child %s%d\n", dname, dunit);
1593 }
1594
1595 #ifdef ARE_MDIO
1596 static int
1597 aremdio_probe(device_t dev)
1598 {
1599         device_set_desc(dev, "Atheros AR531x built-in ethernet interface, MDIO controller");
1600         return(0);
1601 }
1602
1603 static int
1604 aremdio_attach(device_t dev)
1605 {
1606         struct are_softc        *sc;
1607         int                     error = 0;
1608
1609         sc = device_get_softc(dev);
1610         sc->are_dev = dev;
1611         sc->are_rid = 0;
1612         sc->are_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
1613             &sc->are_rid, RF_ACTIVE | RF_SHAREABLE);
1614         if (sc->are_res == NULL) {
1615                 device_printf(dev, "couldn't map memory\n");
1616                 error = ENXIO;
1617                 goto fail;
1618         }
1619
1620         sc->are_btag = rman_get_bustag(sc->are_res);
1621         sc->are_bhandle = rman_get_bushandle(sc->are_res);
1622
1623         bus_generic_probe(dev);
1624         bus_enumerate_hinted_children(dev);
1625         error = bus_generic_attach(dev);
1626 fail:
1627         return (error);
1628 }
1629
1630 static int
1631 aremdio_detach(device_t dev)
1632 {
1633         return(0);
1634 }
1635 #endif
1636
1637 #ifdef ARE_DEBUG
1638 void
1639 dump_txdesc(struct are_softc *sc, int pos)
1640 {
1641         struct are_desc         *desc;
1642
1643         desc = &sc->are_rdata.are_tx_ring[pos];
1644         device_printf(sc->are_dev, "CSR_TXLIST %08x\n", CSR_READ_4(sc, CSR_TXLIST));
1645         device_printf(sc->are_dev, "CSR_HTBA %08x\n", CSR_READ_4(sc, CSR_HTBA));
1646         device_printf(sc->are_dev, "%d TDES0:%08x TDES1:%08x TDES2:%08x TDES3:%08x\n",
1647             pos, desc->are_stat, desc->are_devcs, desc->are_addr, desc->are_link);
1648 }
1649
1650 void
1651 dump_status_reg(struct are_softc *sc)
1652 {
1653         uint32_t                status;
1654
1655         /* mask out interrupts */
1656
1657         device_printf(sc->are_dev, "CSR_HTBA %08x\n", CSR_READ_4(sc, CSR_HTBA));
1658         status = CSR_READ_4(sc, CSR_STATUS);
1659         device_printf(sc->are_dev, "CSR5 Status Register EB:%d TS:%d RS:%d NIS:%d AIS:%d ER:%d SE:%d LNF:%d TM:%d RWT:%d RPS:%d RU:%d RI:%d UNF:%d LNP/ANC:%d TJT:%d TU:%d TPS:%d TI:%d\n",
1660             (status >> 23 ) & 7,
1661             (status >> 20 ) & 7,
1662             (status >> 17 ) & 7,
1663             (status >> 16 ) & 1,
1664             (status >> 15 ) & 1,
1665             (status >> 14 ) & 1,
1666             (status >> 13 ) & 1,
1667             (status >> 12 ) & 1,
1668             (status >> 11 ) & 1,
1669             (status >> 9 ) & 1,
1670             (status >> 8 ) & 1,
1671             (status >> 7 ) & 1,
1672             (status >> 6 ) & 1,
1673             (status >> 5 ) & 1,
1674             (status >> 4 ) & 1,
1675             (status >> 3 ) & 1,
1676             (status >> 2 ) & 1,
1677             (status >> 1 ) & 1,
1678             (status >> 0 ) & 1);
1679
1680 }
1681 #endif