sys/dev/mge/if_mge.c

   1 /*-
   2  * Copyright (C) 2008 MARVELL INTERNATIONAL LTD.
   3  * All rights reserved.
   4  *
   5  * Developed by Semihalf.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of MARVELL nor the names of contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #ifdef HAVE_KERNEL_OPTION_HEADERS
  33 #include "opt_device_polling.h"
  34 #endif
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/endian.h>
  42 #include <sys/mbuf.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/kernel.h>
  46 #include <sys/module.h>
  47 #include <sys/socket.h>
  48 #include <sys/sysctl.h>
  49
  50 #include <net/ethernet.h>
  51 #include <net/bpf.h>
  52 #include <net/if.h>
  53 #include <net/if_arp.h>
  54 #include <net/if_dl.h>
  55 #include <net/if_media.h>
  56 #include <net/if_types.h>
  57 #include <net/if_vlan_var.h>
  58
  59 #include <netinet/in_systm.h>
  60 #include <netinet/in.h>
  61 #include <netinet/ip.h>
  62
  63 #include <sys/sockio.h>
  64 #include <sys/bus.h>
  65 #include <machine/bus.h>
  66 #include <sys/rman.h>
  67 #include <machine/resource.h>
  68
  69 #include <dev/mii/mii.h>
  70 #include <dev/mii/miivar.h>
  71
  72 #define MV_PHY_ADDR_BASE        8
  73
  74 #include <dev/mge/if_mgevar.h>
  75 #include <arm/mv/mvreg.h>
  76 #include <arm/mv/mvvar.h>
  77
  78 #include "miibus_if.h"
  79
  80 /* PHY registers are in the address space of the first mge unit */
  81 static struct mge_softc *sc_mge0 = NULL;
  82
  83 static int mge_probe(device_t dev);
  84 static int mge_attach(device_t dev);
  85 static int mge_detach(device_t dev);
  86 static int mge_shutdown(device_t dev);
  87 static int mge_suspend(device_t dev);
  88 static int mge_resume(device_t dev);
  89
  90 static int mge_miibus_readreg(device_t dev, int phy, int reg);
  91 static int mge_miibus_writereg(device_t dev, int phy, int reg, int value);
  92
  93 static int mge_ifmedia_upd(struct ifnet *ifp);
  94 static void mge_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr);
  95
  96 static void mge_init(void *arg);
  97 static void mge_init_locked(void *arg);
  98 static void mge_start(struct ifnet *ifp);
  99 static void mge_start_locked(struct ifnet *ifp);
 100 static void mge_watchdog(struct mge_softc *sc);
 101 static int mge_ioctl(struct ifnet *ifp, u_long command, caddr_t data);
 102
 103 static uint32_t mge_tfut_ipg(uint32_t val, int ver);
 104 static uint32_t mge_rx_ipg(uint32_t val, int ver);
 105 static void mge_ver_params(struct mge_softc *sc);
 106
 107 static void mge_intrs_ctrl(struct mge_softc *sc, int enable);
 108 static void mge_intr_rx(void *arg);
 109 static int mge_intr_rx_locked(struct mge_softc *sc, int count);
 110 static void mge_intr_tx(void *arg);
 111 static void mge_intr_tx_locked(struct mge_softc *sc);
 112 static void mge_intr_misc(void *arg);
 113 static void mge_intr_sum(void *arg);
 114 static void mge_intr_err(void *arg);
 115 static void mge_stop(struct mge_softc *sc);
 116 static void mge_tick(void *msc);
 117 static uint32_t mge_set_port_serial_control(uint32_t media);
 118 static void mge_get_mac_address(struct mge_softc *sc, uint8_t *addr);
 119 static void mge_set_mac_address(struct mge_softc *sc);
 120 static void mge_set_ucast_address(struct mge_softc *sc, uint8_t last_byte,
 121     uint8_t queue);
 122 static void mge_set_prom_mode(struct mge_softc *sc, uint8_t queue);
 123 static int mge_allocate_dma(struct mge_softc *sc);
 124 static int mge_alloc_desc_dma(struct mge_softc *sc,
 125     struct mge_desc_wrapper* desc_tab, uint32_t size, bus_dma_tag_t *buffer_tag);
 126 static int mge_new_rxbuf(bus_dma_tag_t tag, bus_dmamap_t map,
 127     struct mbuf **mbufp, bus_addr_t *paddr);
 128 static void mge_get_dma_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error);
 129 static void mge_free_dma(struct mge_softc *sc);
 130 static void mge_free_desc(struct mge_softc *sc, struct mge_desc_wrapper* tab, uint32_t size,
 131     bus_dma_tag_t buffer_tag, uint8_t free_mbufs);
 132 static void mge_offload_process_frame(struct ifnet *ifp, struct mbuf *frame,
 133     uint32_t status, uint16_t bufsize);
 134 static void mge_offload_setup_descriptor(struct mge_softc *sc,
 135     struct mge_desc_wrapper *dw);
 136 static uint8_t mge_crc8(uint8_t *data, int size);
 137 static void mge_setup_multicast(struct mge_softc *sc);
 138 static void mge_set_rxic(struct mge_softc *sc);
 139 static void mge_set_txic(struct mge_softc *sc);
 140 static void mge_add_sysctls(struct mge_softc *sc);
 141 static int mge_sysctl_ic(SYSCTL_HANDLER_ARGS);
 142
 143 static device_method_t mge_methods[] = {
 144         /* Device interface */
 145         DEVMETHOD(device_probe,         mge_probe),
 146         DEVMETHOD(device_attach,        mge_attach),
 147         DEVMETHOD(device_detach,        mge_detach),
 148         DEVMETHOD(device_shutdown,      mge_shutdown),
 149         DEVMETHOD(device_suspend,       mge_suspend),
 150         DEVMETHOD(device_resume,        mge_resume),
 151         /* MII interface */
 152         DEVMETHOD(miibus_readreg,       mge_miibus_readreg),
 153         DEVMETHOD(miibus_writereg,      mge_miibus_writereg),
 154         { 0, 0 }
 155 };
 156
 157 static driver_t mge_driver = {
 158         "mge",
 159         mge_methods,
 160         sizeof(struct mge_softc),
 161 };
 162
 163 static devclass_t mge_devclass;
 164
 165 DRIVER_MODULE(mge, mbus, mge_driver, mge_devclass, 0, 0);
 166 DRIVER_MODULE(miibus, mge, miibus_driver, miibus_devclass, 0, 0);
 167 MODULE_DEPEND(mge, ether, 1, 1, 1);
 168 MODULE_DEPEND(mge, miibus, 1, 1, 1);
 169
 170 static struct resource_spec res_spec[] = {
 171         { SYS_RES_MEMORY, 0, RF_ACTIVE },
 172         { SYS_RES_IRQ, 0, RF_ACTIVE | RF_SHAREABLE },
 173         { SYS_RES_IRQ, 1, RF_ACTIVE | RF_SHAREABLE },
 174         { SYS_RES_IRQ, 2, RF_ACTIVE | RF_SHAREABLE },
 175         { SYS_RES_IRQ, 3, RF_ACTIVE | RF_SHAREABLE },
 176         { SYS_RES_IRQ, 4, RF_ACTIVE | RF_SHAREABLE },
 177         { -1, 0 }
 178 };
 179
 180 static struct {
 181         driver_intr_t *handler;
 182         char * description;
 183 } mge_intrs[MGE_INTR_COUNT] = {
 184         { mge_intr_rx,  "GbE receive interrupt" },
 185         { mge_intr_tx,  "GbE transmit interrupt" },
 186         { mge_intr_misc,"GbE misc interrupt" },
 187         { mge_intr_sum, "GbE summary interrupt" },
 188         { mge_intr_err, "GbE error interrupt" },
 189 };
 190
 191 static void
 192 mge_get_mac_address(struct mge_softc *sc, uint8_t *addr)
 193 {
 194         uint32_t mac_l, mac_h;
 195
 196         /* XXX use currently programmed MAC address; eventually this info will
 197          * be provided by the loader */
 198
 199         mac_l = MGE_READ(sc, MGE_MAC_ADDR_L);
 200         mac_h = MGE_READ(sc, MGE_MAC_ADDR_H);
 201
 202         addr[0] = (mac_h & 0xff000000) >> 24;
 203         addr[1] = (mac_h & 0x00ff0000) >> 16;
 204         addr[2] = (mac_h & 0x0000ff00) >> 8;
 205         addr[3] = (mac_h & 0x000000ff);
 206         addr[4] = (mac_l & 0x0000ff00) >> 8;
 207         addr[5] = (mac_l & 0x000000ff);
 208 }
 209
 210 static uint32_t
 211 mge_tfut_ipg(uint32_t val, int ver)
 212 {
 213
 214         switch (ver) {
 215         case 1:
 216                 return ((val & 0x3fff) << 4);
 217         case 2:
 218         default:
 219                 return ((val & 0xffff) << 4);
 220         }
 221 }
 222
 223 static uint32_t
 224 mge_rx_ipg(uint32_t val, int ver)
 225 {
 226
 227         switch (ver) {
 228         case 1:
 229                 return ((val & 0x3fff) << 8);
 230         case 2:
 231         default:
 232                 return (((val & 0x8000) << 10) | ((val & 0x7fff) << 7));
 233         }
 234 }
 235
 236 static void
 237 mge_ver_params(struct mge_softc *sc)
 238 {
 239         uint32_t d, r;
 240
 241         soc_id(&d, &r);
 242         if (d == MV_DEV_88F6281 || d == MV_DEV_MV78100 ||
 243             d == MV_DEV_MV78100_Z0) {
 244                 sc->mge_ver = 2;
 245                 sc->mge_mtu = 0x4e8;
 246                 sc->mge_tfut_ipg_max = 0xFFFF;
 247                 sc->mge_rx_ipg_max = 0xFFFF;
 248                 sc->mge_tx_arb_cfg = 0xFC0000FF;
 249                 sc->mge_tx_tok_cfg = 0xFFFF7FFF;
 250                 sc->mge_tx_tok_cnt = 0x3FFFFFFF;
 251         } else {
 252                 sc->mge_ver = 1;
 253                 sc->mge_mtu = 0x458;
 254                 sc->mge_tfut_ipg_max = 0x3FFF;
 255                 sc->mge_rx_ipg_max = 0x3FFF;
 256                 sc->mge_tx_arb_cfg = 0x000000FF;
 257                 sc->mge_tx_tok_cfg = 0x3FFFFFFF;
 258                 sc->mge_tx_tok_cnt = 0x3FFFFFFF;
 259         }
 260 }
 261
 262 static void
 263 mge_set_mac_address(struct mge_softc *sc)
 264 {
 265         char *if_mac;
 266         uint32_t mac_l, mac_h;
 267
 268         MGE_GLOBAL_LOCK_ASSERT(sc);
 269
 270         if_mac = (char *)IF_LLADDR(sc->ifp);
 271
 272         mac_l = (if_mac[4] << 8) | (if_mac[5]);
 273         mac_h = (if_mac[0] << 24)| (if_mac[1] << 16) |
 274             (if_mac[2] << 8) | (if_mac[3] << 0);
 275
 276         MGE_WRITE(sc, MGE_MAC_ADDR_L, mac_l);
 277         MGE_WRITE(sc, MGE_MAC_ADDR_H, mac_h);
 278
 279         mge_set_ucast_address(sc, if_mac[5], MGE_RX_DEFAULT_QUEUE);
 280 }
 281
 282 static void
 283 mge_set_ucast_address(struct mge_softc *sc, uint8_t last_byte, uint8_t queue)
 284 {
 285         uint32_t reg_idx, reg_off, reg_val, i;
 286
 287         last_byte &= 0xf;
 288         reg_idx = last_byte / MGE_UCAST_REG_NUMBER;
 289         reg_off = (last_byte % MGE_UCAST_REG_NUMBER) * 8;
 290         reg_val = (1 | (queue << 1)) << reg_off;
 291
 292         for (i = 0; i < MGE_UCAST_REG_NUMBER; i++) {
 293                 if ( i == reg_idx)
 294                         MGE_WRITE(sc, MGE_DA_FILTER_UCAST(i), reg_val);
 295                 else
 296                         MGE_WRITE(sc, MGE_DA_FILTER_UCAST(i), 0);
 297         }
 298 }
 299
 300 static void
 301 mge_set_prom_mode(struct mge_softc *sc, uint8_t queue)
 302 {
 303         uint32_t port_config;
 304         uint32_t reg_val, i;
 305
 306         /* Enable or disable promiscuous mode as needed */
 307         if (sc->ifp->if_flags & IFF_PROMISC) {
 308                 port_config = MGE_READ(sc, MGE_PORT_CONFIG);
 309                 port_config |= PORT_CONFIG_UPM;
 310                 MGE_WRITE(sc, MGE_PORT_CONFIG, port_config);
 311
 312                 reg_val = ((1 | (queue << 1)) | (1 | (queue << 1)) << 8 |
 313                    (1 | (queue << 1)) << 16 | (1 | (queue << 1)) << 24);
 314
 315                 for (i = 0; i < MGE_MCAST_REG_NUMBER; i++) {
 316                         MGE_WRITE(sc, MGE_DA_FILTER_SPEC_MCAST(i), reg_val);
 317                         MGE_WRITE(sc, MGE_DA_FILTER_OTH_MCAST(i), reg_val);
 318                 }
 319
 320                 for (i = 0; i < MGE_UCAST_REG_NUMBER; i++)
 321                         MGE_WRITE(sc, MGE_DA_FILTER_UCAST(i), reg_val);
 322
 323         } else {
 324                 port_config = MGE_READ(sc, MGE_PORT_CONFIG);
 325                 port_config &= ~PORT_CONFIG_UPM;
 326                 MGE_WRITE(sc, MGE_PORT_CONFIG, port_config);
 327
 328                 for (i = 0; i < MGE_MCAST_REG_NUMBER; i++) {
 329                         MGE_WRITE(sc, MGE_DA_FILTER_SPEC_MCAST(i), 0);
 330                         MGE_WRITE(sc, MGE_DA_FILTER_OTH_MCAST(i), 0);
 331                 }
 332
 333                 mge_set_mac_address(sc);
 334         }
 335 }
 336
 337 static void
 338 mge_get_dma_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 339 {
 340         u_int32_t *paddr;
 341
 342         KASSERT(nseg == 1, ("wrong number of segments, should be 1"));
 343         paddr = arg;
 344
 345         *paddr = segs->ds_addr;
 346 }
 347
 348 static int
 349 mge_new_rxbuf(bus_dma_tag_t tag, bus_dmamap_t map, struct mbuf **mbufp,
 350     bus_addr_t *paddr)
 351 {
 352         struct mbuf *new_mbuf;
 353         bus_dma_segment_t seg[1];
 354         int error;
 355         int nsegs;
 356
 357         KASSERT(mbufp != NULL, ("NULL mbuf pointer!"));
 358
 359         new_mbuf = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
 360         if (new_mbuf == NULL)
 361                 return (ENOBUFS);
 362         new_mbuf->m_len = new_mbuf->m_pkthdr.len = new_mbuf->m_ext.ext_size;
 363
 364         if (*mbufp) {
 365                 bus_dmamap_sync(tag, map, BUS_DMASYNC_POSTREAD);
 366                 bus_dmamap_unload(tag, map);
 367         }
 368
 369         error = bus_dmamap_load_mbuf_sg(tag, map, new_mbuf, seg, &nsegs,
 370             BUS_DMA_NOWAIT);
 371         KASSERT(nsegs == 1, ("Too many segments returned!"));
 372         if (nsegs != 1 || error)
 373                 panic("mge_new_rxbuf(): nsegs(%d), error(%d)", nsegs, error);
 374
 375         bus_dmamap_sync(tag, map, BUS_DMASYNC_PREREAD);
 376
 377         (*mbufp) = new_mbuf;
 378         (*paddr) = seg->ds_addr;
 379         return (0);
 380 }
 381
 382 static int
 383 mge_alloc_desc_dma(struct mge_softc *sc, struct mge_desc_wrapper* tab,
 384     uint32_t size, bus_dma_tag_t *buffer_tag)
 385 {
 386         struct mge_desc_wrapper *dw;
 387         bus_addr_t desc_paddr;
 388         int i, error;
 389
 390         desc_paddr = 0;
 391         for (i = size - 1; i >= 0; i--) {
 392                 dw = &(tab[i]);
 393                 error = bus_dmamem_alloc(sc->mge_desc_dtag,
 394                     (void**)&(dw->mge_desc),
 395                     BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT,
 396                     &(dw->desc_dmap));
 397
 398                 if (error) {
 399                         if_printf(sc->ifp, "failed to allocate DMA memory\n");
 400                         dw->mge_desc = NULL;
 401                         return (ENXIO);
 402                 }
 403
 404                 error = bus_dmamap_load(sc->mge_desc_dtag, dw->desc_dmap,
 405                     dw->mge_desc, sizeof(struct mge_desc), mge_get_dma_addr,
 406                     &(dw->mge_desc_paddr), BUS_DMA_NOWAIT);
 407
 408                 if (error) {
 409                         if_printf(sc->ifp, "can't load descriptor\n");
 410                         bus_dmamem_free(sc->mge_desc_dtag, dw->mge_desc,
 411                             dw->desc_dmap);
 412                         dw->mge_desc = NULL;
 413                         return (ENXIO);
 414                 }
 415
 416                 /* Chain descriptors */
 417                 dw->mge_desc->next_desc = desc_paddr;
 418                 desc_paddr = dw->mge_desc_paddr;
 419         }
 420         tab[size - 1].mge_desc->next_desc = desc_paddr;
 421
 422         /* Allocate a busdma tag for mbufs. */
 423         error = bus_dma_tag_create(NULL,        /* parent */
 424             8, 0,                               /* alignment, boundary */
 425             BUS_SPACE_MAXADDR_32BIT,            /* lowaddr */
 426             BUS_SPACE_MAXADDR,                  /* highaddr */
 427             NULL, NULL,                         /* filtfunc, filtfuncarg */
 428             MCLBYTES, 1,                        /* maxsize, nsegments */
 429             MCLBYTES, 0,                        /* maxsegsz, flags */
 430             NULL, NULL,                         /* lockfunc, lockfuncarg */
 431             buffer_tag);                        /* dmat */
 432         if (error) {
 433                 if_printf(sc->ifp, "failed to create busdma tag for mbufs\n");
 434                 return (ENXIO);
 435         }
 436
 437         /* Create TX busdma maps */
 438         for (i = 0; i < size; i++) {
 439                 dw = &(tab[i]);
 440                 error = bus_dmamap_create(*buffer_tag, 0, &dw->buffer_dmap);
 441                 if (error) {
 442                         if_printf(sc->ifp, "failed to create map for mbuf\n");
 443                         return (ENXIO);
 444                 }
 445
 446                 dw->buffer = (struct mbuf*)NULL;
 447                 dw->mge_desc->buffer = (bus_addr_t)NULL;
 448         }
 449
 450         return (0);
 451 }
 452
 453 static int
 454 mge_allocate_dma(struct mge_softc *sc)
 455 {
 456         int error;
 457         struct mge_desc_wrapper *dw;
 458         int num, i;
 459
 460
 461         num = MGE_TX_DESC_NUM + MGE_RX_DESC_NUM;
 462
 463         /* Allocate a busdma tag and DMA safe memory for TX/RX descriptors. */
 464         error = bus_dma_tag_create(NULL,        /* parent */
 465             16, 0,                              /* alignment, boundary */
 466             BUS_SPACE_MAXADDR_32BIT,            /* lowaddr */
 467             BUS_SPACE_MAXADDR,                  /* highaddr */
 468             NULL, NULL,                         /* filtfunc, filtfuncarg */
 469             sizeof(struct mge_desc), 1,         /* maxsize, nsegments */
 470             sizeof(struct mge_desc), 0,         /* maxsegsz, flags */
 471             NULL, NULL,                         /* lockfunc, lockfuncarg */
 472             &sc->mge_desc_dtag);                /* dmat */
 473
 474
 475         mge_alloc_desc_dma(sc, sc->mge_tx_desc, MGE_TX_DESC_NUM,
 476             &sc->mge_tx_dtag);
 477         mge_alloc_desc_dma(sc, sc->mge_rx_desc, MGE_RX_DESC_NUM,
 478             &sc->mge_rx_dtag);
 479
 480         for (i = 0; i < MGE_RX_DESC_NUM; i++) {
 481                 dw = &(sc->mge_rx_desc[i]);
 482                 mge_new_rxbuf(sc->mge_rx_dtag, dw->buffer_dmap, &dw->buffer,
 483                     &dw->mge_desc->buffer);
 484         }
 485
 486         sc->tx_desc_start = sc->mge_tx_desc[0].mge_desc_paddr;
 487         sc->rx_desc_start = sc->mge_rx_desc[0].mge_desc_paddr;
 488
 489         return (0);
 490 }
 491
 492 static void
 493 mge_free_desc(struct mge_softc *sc, struct mge_desc_wrapper* tab,
 494     uint32_t size, bus_dma_tag_t buffer_tag, uint8_t free_mbufs)
 495 {
 496         struct mge_desc_wrapper *dw;
 497         int i;
 498
 499         for (i = 0; i < size; i++) {
 500                 /* Free RX mbuf */
 501                 dw = &(tab[i]);
 502
 503                 if (dw->buffer_dmap) {
 504                         if (free_mbufs) {
 505                                 bus_dmamap_sync(buffer_tag, dw->buffer_dmap,
 506                                     BUS_DMASYNC_POSTREAD);
 507                                 bus_dmamap_unload(buffer_tag, dw->buffer_dmap);
 508                         }
 509                         bus_dmamap_destroy(buffer_tag, dw->buffer_dmap);
 510                         if (free_mbufs)
 511                                 m_freem(dw->buffer);
 512                 }
 513                 /* Free RX descriptors */
 514                 if (dw->desc_dmap) {
 515                         bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
 516                             BUS_DMASYNC_POSTREAD);
 517                         bus_dmamap_unload(sc->mge_desc_dtag, dw->desc_dmap);
 518                         bus_dmamem_free(sc->mge_desc_dtag, dw->mge_desc,
 519                             dw->desc_dmap);
 520                 }
 521         }
 522 }
 523
 524 static void
 525 mge_free_dma(struct mge_softc *sc)
 526 {
 527         /* Free desciptors and mbufs */
 528         mge_free_desc(sc, sc->mge_rx_desc, MGE_RX_DESC_NUM, sc->mge_rx_dtag, 1);
 529         mge_free_desc(sc, sc->mge_tx_desc, MGE_TX_DESC_NUM, sc->mge_tx_dtag, 0);
 530
 531         /* Destroy mbuf dma tag */
 532         bus_dma_tag_destroy(sc->mge_tx_dtag);
 533         bus_dma_tag_destroy(sc->mge_rx_dtag);
 534         /* Destroy descriptors tag */
 535         bus_dma_tag_destroy(sc->mge_desc_dtag);
 536 }
 537
 538 static void
 539 mge_reinit_rx(struct mge_softc *sc)
 540 {
 541         struct mge_desc_wrapper *dw;
 542         int i;
 543
 544         MGE_RECEIVE_LOCK(sc);
 545
 546         mge_free_desc(sc, sc->mge_rx_desc, MGE_RX_DESC_NUM, sc->mge_rx_dtag, 1);
 547
 548         mge_alloc_desc_dma(sc, sc->mge_rx_desc, MGE_RX_DESC_NUM,
 549             &sc->mge_rx_dtag);
 550
 551         for (i = 0; i < MGE_RX_DESC_NUM; i++) {
 552                 dw = &(sc->mge_rx_desc[i]);
 553                 mge_new_rxbuf(sc->mge_rx_dtag, dw->buffer_dmap, &dw->buffer,
 554                 &dw->mge_desc->buffer);
 555         }
 556
 557         sc->rx_desc_start = sc->mge_rx_desc[0].mge_desc_paddr;
 558         sc->rx_desc_curr = 0;
 559
 560         MGE_WRITE(sc, MGE_RX_CUR_DESC_PTR(MGE_RX_DEFAULT_QUEUE),
 561             sc->rx_desc_start);
 562
 563         /* Enable RX queue */
 564         MGE_WRITE(sc, MGE_RX_QUEUE_CMD, MGE_ENABLE_RXQ(MGE_RX_DEFAULT_QUEUE));
 565
 566         MGE_RECEIVE_UNLOCK(sc);
 567 }
 568
 569 #ifdef DEVICE_POLLING
 570 static poll_handler_t mge_poll;
 571
 572 static int
 573 mge_poll(struct ifnet *ifp, enum poll_cmd cmd, int count)
 574 {
 575         struct mge_softc *sc = ifp->if_softc;
 576         uint32_t int_cause, int_cause_ext;
 577         int rx_npkts = 0;
 578
 579         MGE_GLOBAL_LOCK(sc);
 580
 581         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 582                 MGE_GLOBAL_UNLOCK(sc);
 583                 return (rx_npkts);
 584         }
 585
 586         if (cmd == POLL_AND_CHECK_STATUS) {
 587                 int_cause = MGE_READ(sc, MGE_PORT_INT_CAUSE);
 588                 int_cause_ext = MGE_READ(sc, MGE_PORT_INT_CAUSE_EXT);
 589
 590                 /* Check for resource error */
 591                 if (int_cause & MGE_PORT_INT_RXERRQ0)
 592                         mge_reinit_rx(sc);
 593
 594                 if (int_cause || int_cause_ext) {
 595                         MGE_WRITE(sc, MGE_PORT_INT_CAUSE, ~int_cause);
 596                         MGE_WRITE(sc, MGE_PORT_INT_CAUSE_EXT, ~int_cause_ext);
 597                 }
 598         }
 599
 600         mge_intr_tx_locked(sc);
 601         rx_npkts = mge_intr_rx_locked(sc, count);
 602
 603         MGE_GLOBAL_UNLOCK(sc);
 604         return (rx_npkts);
 605 }
 606 #endif /* DEVICE_POLLING */
 607
 608 static int
 609 mge_attach(device_t dev)
 610 {
 611         struct mge_softc *sc;
 612         struct ifnet *ifp;
 613         uint8_t hwaddr[ETHER_ADDR_LEN];
 614         int i, error ;
 615
 616         sc = device_get_softc(dev);
 617         sc->dev = dev;
 618
 619         if (device_get_unit(dev) == 0)
 620                 sc_mge0 = sc;
 621
 622         /* Set chip version-dependent parameters */
 623         mge_ver_params(sc);
 624
 625         /* Initialize mutexes */
 626         mtx_init(&sc->transmit_lock, device_get_nameunit(dev), "mge TX lock", MTX_DEF);
 627         mtx_init(&sc->receive_lock, device_get_nameunit(dev), "mge RX lock", MTX_DEF);
 628
 629         /* Allocate IO and IRQ resources */
 630         error = bus_alloc_resources(dev, res_spec, sc->res);
 631         if (error) {
 632                 device_printf(dev, "could not allocate resources\n");
 633                 mge_detach(dev);
 634                 return (ENXIO);
 635         }
 636
 637         /* Allocate DMA, buffers, buffer descriptors */
 638         error = mge_allocate_dma(sc);
 639         if (error) {
 640                 mge_detach(dev);
 641                 return (ENXIO);
 642         }
 643
 644         sc->tx_desc_curr = 0;
 645         sc->rx_desc_curr = 0;
 646         sc->tx_desc_used_idx = 0;
 647         sc->tx_desc_used_count = 0;
 648
 649         /* Configure defaults for interrupts coalescing */
 650         sc->rx_ic_time = 768;
 651         sc->tx_ic_time = 768;
 652         mge_add_sysctls(sc);
 653
 654         /* Allocate network interface */
 655         ifp = sc->ifp = if_alloc(IFT_ETHER);
 656         if (ifp == NULL) {
 657                 device_printf(dev, "if_alloc() failed\n");
 658                 mge_detach(dev);
 659                 return (ENOMEM);
 660         }
 661
 662         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 663         ifp->if_softc = sc;
 664         ifp->if_flags = IFF_SIMPLEX | IFF_MULTICAST | IFF_BROADCAST;
 665         ifp->if_capabilities = IFCAP_HWCSUM | IFCAP_VLAN_MTU;
 666         ifp->if_capenable = ifp->if_capabilities;
 667         ifp->if_hwassist = MGE_CHECKSUM_FEATURES;
 668
 669 #ifdef DEVICE_POLLING
 670         /* Advertise that polling is supported */
 671         ifp->if_capabilities |= IFCAP_POLLING;
 672 #endif
 673
 674         ifp->if_init = mge_init;
 675         ifp->if_start = mge_start;
 676         ifp->if_ioctl = mge_ioctl;
 677
 678         ifp->if_snd.ifq_drv_maxlen = MGE_TX_DESC_NUM - 1;
 679         IFQ_SET_MAXLEN(&ifp->if_snd, ifp->if_snd.ifq_drv_maxlen);
 680         IFQ_SET_READY(&ifp->if_snd);
 681
 682         mge_get_mac_address(sc, hwaddr);
 683         ether_ifattach(ifp, hwaddr);
 684         callout_init(&sc->wd_callout, 0);
 685
 686         /* Probe PHY(s) */
 687         error = mii_phy_probe(dev, &sc->miibus, mge_ifmedia_upd, mge_ifmedia_sts);
 688         if (error) {
 689                 device_printf(dev, "MII failed to find PHY\n");
 690                 if_free(ifp);
 691                 sc->ifp = NULL;
 692                 mge_detach(dev);
 693                 return (error);
 694         }
 695         sc->mii = device_get_softc(sc->miibus);
 696
 697         /* Attach interrupt handlers */
 698         for (i = 0; i < 2; ++i) {
 699                 error = bus_setup_intr(dev, sc->res[1 + i],
 700                     INTR_TYPE_NET | INTR_MPSAFE, NULL, *mge_intrs[i].handler,
 701                     sc, &sc->ih_cookie[i]);
 702                 if (error) {
 703                         device_printf(dev, "could not setup %s\n",
 704                             mge_intrs[i].description);
 705                         ether_ifdetach(sc->ifp);
 706                         return (error);
 707                 }
 708         }
 709
 710         return (0);
 711 }
 712
 713 static int
 714 mge_detach(device_t dev)
 715 {
 716         struct mge_softc *sc;
 717         int error,i;
 718
 719         sc = device_get_softc(dev);
 720
 721         /* Stop controller and free TX queue */
 722         if (sc->ifp)
 723                 mge_shutdown(dev);
 724
 725         /* Wait for stopping ticks */
 726         callout_drain(&sc->wd_callout);
 727
 728         /* Stop and release all interrupts */
 729         for (i = 0; i < 2; ++i) {
 730                 error = bus_teardown_intr(dev, sc->res[1 + i], sc->ih_cookie[i]);
 731                 if (error)
 732                         device_printf(dev, "could not release %s\n",
 733                             mge_intrs[i].description);
 734         }
 735
 736         /* Detach network interface */
 737         if (sc->ifp) {
 738                 ether_ifdetach(sc->ifp);
 739                 if_free(sc->ifp);
 740         }
 741
 742         /* Free DMA resources */
 743         mge_free_dma(sc);
 744
 745         /* Free IO memory handler */
 746         bus_release_resources(dev, res_spec, sc->res);
 747
 748         /* Destroy mutexes */
 749         mtx_destroy(&sc->receive_lock);
 750         mtx_destroy(&sc->transmit_lock);
 751
 752         return (0);
 753 }
 754
 755 static void
 756 mge_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
 757 {
 758         struct mge_softc *sc = ifp->if_softc;
 759         struct mii_data *mii;
 760
 761         MGE_TRANSMIT_LOCK(sc);
 762
 763         mii = sc->mii;
 764         mii_pollstat(mii);
 765
 766         ifmr->ifm_active = mii->mii_media_active;
 767         ifmr->ifm_status = mii->mii_media_status;
 768
 769         MGE_TRANSMIT_UNLOCK(sc);
 770 }
 771
 772 static uint32_t
 773 mge_set_port_serial_control(uint32_t media)
 774 {
 775         uint32_t port_config;
 776
 777         port_config = PORT_SERIAL_RES_BIT9 | PORT_SERIAL_FORCE_LINK_FAIL |
 778             PORT_SERIAL_MRU(PORT_SERIAL_MRU_1552);
 779
 780         if (IFM_TYPE(media) == IFM_ETHER) {
 781                 switch(IFM_SUBTYPE(media)) {
 782                         case IFM_AUTO:
 783                                 break;
 784                         case IFM_1000_T:
 785                                 port_config  |= (PORT_SERIAL_GMII_SPEED_1000 |
 786                                     PORT_SERIAL_AUTONEG | PORT_SERIAL_AUTONEG_FC |
 787                                     PORT_SERIAL_SPEED_AUTONEG);
 788                                 break;
 789                         case IFM_100_TX:
 790                                 port_config  |= (PORT_SERIAL_MII_SPEED_100 |
 791                                     PORT_SERIAL_AUTONEG | PORT_SERIAL_AUTONEG_FC |
 792                                     PORT_SERIAL_SPEED_AUTONEG);
 793                                 break;
 794                         case IFM_10_T:
 795                                 port_config  |= (PORT_SERIAL_AUTONEG |
 796                                     PORT_SERIAL_AUTONEG_FC |
 797                                     PORT_SERIAL_SPEED_AUTONEG);
 798                                 break;
 799                 }
 800                 if (media & IFM_FDX)
 801                         port_config |= PORT_SERIAL_FULL_DUPLEX;
 802         }
 803         return (port_config);
 804 }
 805
 806 static int
 807 mge_ifmedia_upd(struct ifnet *ifp)
 808 {
 809         struct mge_softc *sc = ifp->if_softc;
 810
 811         if (ifp->if_flags & IFF_UP) {
 812                 MGE_GLOBAL_LOCK(sc);
 813
 814                 sc->mge_media_status = sc->mii->mii_media.ifm_media;
 815                 mii_mediachg(sc->mii);
 816                 mge_init_locked(sc);
 817
 818                 MGE_GLOBAL_UNLOCK(sc);
 819         }
 820
 821         return (0);
 822 }
 823
 824 static void
 825 mge_init(void *arg)
 826 {
 827         struct mge_softc *sc = arg;
 828
 829         MGE_GLOBAL_LOCK(sc);
 830
 831         mge_init_locked(arg);
 832
 833         MGE_GLOBAL_UNLOCK(sc);
 834 }
 835
 836 static void
 837 mge_init_locked(void *arg)
 838 {
 839         struct mge_softc *sc = arg;
 840         struct mge_desc_wrapper *dw;
 841         volatile uint32_t reg_val;
 842         int i, count;
 843
 844
 845         MGE_GLOBAL_LOCK_ASSERT(sc);
 846
 847         /* Stop interface */
 848         mge_stop(sc);
 849
 850         /* Disable interrupts */
 851         mge_intrs_ctrl(sc, 0);
 852
 853         /* Set MAC address */
 854         mge_set_mac_address(sc);
 855
 856         /* Setup multicast filters */
 857         mge_setup_multicast(sc);
 858
 859         if (sc->mge_ver == 2) {
 860                 MGE_WRITE(sc, MGE_PORT_SERIAL_CTRL1, MGE_RGMII_EN);
 861                 MGE_WRITE(sc, MGE_FIXED_PRIO_CONF, MGE_FIXED_PRIO_EN(0));
 862         }
 863
 864         /* Initialize TX queue configuration registers */
 865         MGE_WRITE(sc, MGE_TX_TOKEN_COUNT(0), sc->mge_tx_tok_cnt);
 866         MGE_WRITE(sc, MGE_TX_TOKEN_CONF(0), sc->mge_tx_tok_cfg);
 867         MGE_WRITE(sc, MGE_TX_ARBITER_CONF(0), sc->mge_tx_arb_cfg);
 868
 869         /* Clear TX queue configuration registers for unused queues */
 870         for (i = 1; i < 7; i++) {
 871                 MGE_WRITE(sc, MGE_TX_TOKEN_COUNT(i), 0);
 872                 MGE_WRITE(sc, MGE_TX_TOKEN_CONF(i), 0);
 873                 MGE_WRITE(sc, MGE_TX_ARBITER_CONF(i), 0);
 874         }
 875
 876         /* Set default MTU */
 877         MGE_WRITE(sc, sc->mge_mtu, 0);
 878
 879         /* Port configuration */
 880         MGE_WRITE(sc, MGE_PORT_CONFIG,
 881             PORT_CONFIG_RXCS | PORT_CONFIG_DFLT_RXQ(0) |
 882             PORT_CONFIG_ARO_RXQ(0));
 883         MGE_WRITE(sc, MGE_PORT_EXT_CONFIG , 0x0);
 884
 885         /* Setup port configuration */
 886         reg_val = mge_set_port_serial_control(sc->mge_media_status);
 887         MGE_WRITE(sc, MGE_PORT_SERIAL_CTRL, reg_val);
 888
 889         /* Setup SDMA configuration */
 890         MGE_WRITE(sc, MGE_SDMA_CONFIG , MGE_SDMA_RX_BYTE_SWAP |
 891             MGE_SDMA_TX_BYTE_SWAP |
 892             MGE_SDMA_RX_BURST_SIZE(MGE_SDMA_BURST_16_WORD) |
 893             MGE_SDMA_TX_BURST_SIZE(MGE_SDMA_BURST_16_WORD));
 894
 895         MGE_WRITE(sc, MGE_TX_FIFO_URGENT_TRSH, 0x0);
 896
 897         MGE_WRITE(sc, MGE_TX_CUR_DESC_PTR, sc->tx_desc_start);
 898         MGE_WRITE(sc, MGE_RX_CUR_DESC_PTR(MGE_RX_DEFAULT_QUEUE),
 899             sc->rx_desc_start);
 900
 901         /* Reset descriptor indexes */
 902         sc->tx_desc_curr = 0;
 903         sc->rx_desc_curr = 0;
 904         sc->tx_desc_used_idx = 0;
 905         sc->tx_desc_used_count = 0;
 906
 907         /* Enable RX descriptors */
 908         for (i = 0; i < MGE_RX_DESC_NUM; i++) {
 909                 dw = &sc->mge_rx_desc[i];
 910                 dw->mge_desc->cmd_status = MGE_RX_ENABLE_INT | MGE_DMA_OWNED;
 911                 dw->mge_desc->buff_size = MCLBYTES;
 912                 bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
 913                     BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 914         }
 915
 916         /* Enable RX queue */
 917         MGE_WRITE(sc, MGE_RX_QUEUE_CMD, MGE_ENABLE_RXQ(MGE_RX_DEFAULT_QUEUE));
 918
 919         /* Enable port */
 920         reg_val = MGE_READ(sc, MGE_PORT_SERIAL_CTRL);
 921         reg_val |= PORT_SERIAL_ENABLE;
 922         MGE_WRITE(sc, MGE_PORT_SERIAL_CTRL, reg_val);
 923         count = 0x100000;
 924         for (;;) {
 925                 reg_val = MGE_READ(sc, MGE_PORT_STATUS);
 926                 if (reg_val & MGE_STATUS_LINKUP)
 927                         break;
 928                 DELAY(100);
 929                 if (--count == 0) {
 930                         if_printf(sc->ifp, "Timeout on link-up\n");
 931                         break;
 932                 }
 933         }
 934
 935         /* Setup interrupts coalescing */
 936         mge_set_rxic(sc);
 937         mge_set_txic(sc);
 938
 939         /* Enable interrupts */
 940 #ifdef DEVICE_POLLING
 941         /*
 942          * * ...only if polling is not turned on. Disable interrupts explicitly
 943          * if polling is enabled.
 944          */
 945         if (sc->ifp->if_capenable & IFCAP_POLLING)
 946                 mge_intrs_ctrl(sc, 0);
 947         else
 948 #endif /* DEVICE_POLLING */
 949         mge_intrs_ctrl(sc, 1);
 950
 951         /* Activate network interface */
 952         sc->ifp->if_drv_flags |= IFF_DRV_RUNNING;
 953         sc->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 954         sc->wd_timer = 0;
 955
 956         /* Schedule watchdog timeout */
 957         callout_reset(&sc->wd_callout, hz, mge_tick, sc);
 958 }
 959
 960 static void
 961 mge_intr_err(void *arg)
 962 {
 963         struct mge_softc *sc = arg;
 964         struct ifnet *ifp;
 965
 966         ifp = sc->ifp;
 967         if_printf(ifp, "%s\n", __FUNCTION__);
 968 }
 969
 970 static void
 971 mge_intr_misc(void *arg)
 972 {
 973         struct mge_softc *sc = arg;
 974         struct ifnet *ifp;
 975
 976         ifp = sc->ifp;
 977         if_printf(ifp, "%s\n", __FUNCTION__);
 978 }
 979
 980 static void
 981 mge_intr_rx(void *arg) {
 982         struct mge_softc *sc = arg;
 983         uint32_t int_cause, int_cause_ext;
 984
 985         MGE_RECEIVE_LOCK(sc);
 986
 987 #ifdef DEVICE_POLLING
 988         if (sc->ifp->if_capenable & IFCAP_POLLING) {
 989                 MGE_RECEIVE_UNLOCK(sc);
 990                 return;
 991         }
 992 #endif
 993
 994         /* Get interrupt cause */
 995         int_cause = MGE_READ(sc, MGE_PORT_INT_CAUSE);
 996         int_cause_ext = MGE_READ(sc, MGE_PORT_INT_CAUSE_EXT);
 997
 998         /* Check for resource error */
 999         if (int_cause & MGE_PORT_INT_RXERRQ0) {
1000                 mge_reinit_rx(sc);
1001                 MGE_WRITE(sc, MGE_PORT_INT_CAUSE,
1002                     int_cause & ~MGE_PORT_INT_RXERRQ0);
1003         }
1004
1005         int_cause &= MGE_PORT_INT_RXQ0;
1006         int_cause_ext &= MGE_PORT_INT_EXT_RXOR;
1007
1008         if (int_cause || int_cause_ext) {
1009                 MGE_WRITE(sc, MGE_PORT_INT_CAUSE, ~int_cause);
1010                 MGE_WRITE(sc, MGE_PORT_INT_CAUSE_EXT, ~int_cause_ext);
1011                 mge_intr_rx_locked(sc, -1);
1012         }
1013
1014         MGE_RECEIVE_UNLOCK(sc);
1015 }
1016
1017
1018 static int
1019 mge_intr_rx_locked(struct mge_softc *sc, int count)
1020 {
1021         struct ifnet *ifp = sc->ifp;
1022         uint32_t status;
1023         uint16_t bufsize;
1024         struct mge_desc_wrapper* dw;
1025         struct mbuf *mb;
1026         int rx_npkts = 0;
1027
1028         MGE_RECEIVE_LOCK_ASSERT(sc);
1029
1030         while (count != 0) {
1031                 dw = &sc->mge_rx_desc[sc->rx_desc_curr];
1032                 bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
1033                     BUS_DMASYNC_POSTREAD);
1034
1035                 /* Get status */
1036                 status = dw->mge_desc->cmd_status;
1037                 bufsize = dw->mge_desc->buff_size;
1038                 if ((status & MGE_DMA_OWNED) != 0)
1039                         break;
1040
1041                 if (dw->mge_desc->byte_count &&
1042                     ~(status & MGE_ERR_SUMMARY)) {
1043
1044                         bus_dmamap_sync(sc->mge_rx_dtag, dw->buffer_dmap,
1045                             BUS_DMASYNC_POSTREAD);
1046
1047                         mb = m_devget(dw->buffer->m_data,
1048                             dw->mge_desc->byte_count - ETHER_CRC_LEN,
1049                             0, ifp, NULL);
1050
1051                         if (mb == NULL)
1052                                 /* Give up if no mbufs */
1053                                 break;
1054
1055                         mb->m_len -= 2;
1056                         mb->m_pkthdr.len -= 2;
1057                         mb->m_data += 2;
1058
1059                         mge_offload_process_frame(ifp, mb, status,
1060                             bufsize);
1061
1062                         MGE_RECEIVE_UNLOCK(sc);
1063                         (*ifp->if_input)(ifp, mb);
1064                         MGE_RECEIVE_LOCK(sc);
1065                         rx_npkts++;
1066                 }
1067
1068                 dw->mge_desc->byte_count = 0;
1069                 dw->mge_desc->cmd_status = MGE_RX_ENABLE_INT | MGE_DMA_OWNED;
1070                 sc->rx_desc_curr = (++sc->rx_desc_curr % MGE_RX_DESC_NUM);
1071                 bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
1072                     BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1073
1074                 if (count > 0)
1075                         count -= 1;
1076         }
1077
1078         return (rx_npkts);
1079 }
1080
1081 static void
1082 mge_intr_sum(void *arg)
1083 {
1084         struct mge_softc *sc = arg;
1085         struct ifnet *ifp;
1086
1087         ifp = sc->ifp;
1088         if_printf(ifp, "%s\n", __FUNCTION__);
1089 }
1090
1091 static void
1092 mge_intr_tx(void *arg)
1093 {
1094         struct mge_softc *sc = arg;
1095         uint32_t int_cause_ext;
1096
1097         MGE_TRANSMIT_LOCK(sc);
1098
1099 #ifdef DEVICE_POLLING
1100         if (sc->ifp->if_capenable & IFCAP_POLLING) {
1101                 MGE_TRANSMIT_UNLOCK(sc);
1102                 return;
1103         }
1104 #endif
1105
1106         /* Ack the interrupt */
1107         int_cause_ext = MGE_READ(sc, MGE_PORT_INT_CAUSE_EXT);
1108         MGE_WRITE(sc, MGE_PORT_INT_CAUSE_EXT,
1109             int_cause_ext & ~MGE_PORT_INT_EXT_TXBUF0);
1110
1111         mge_intr_tx_locked(sc);
1112
1113         MGE_TRANSMIT_UNLOCK(sc);
1114 }
1115
1116
1117 static void
1118 mge_intr_tx_locked(struct mge_softc *sc)
1119 {
1120         struct ifnet *ifp = sc->ifp;
1121         struct mge_desc_wrapper *dw;
1122         struct mge_desc *desc;
1123         uint32_t status;
1124         int send = 0;
1125
1126         MGE_TRANSMIT_LOCK_ASSERT(sc);
1127
1128         /* Disable watchdog */
1129         sc->wd_timer = 0;
1130
1131         while (sc->tx_desc_used_count) {
1132                 /* Get the descriptor */
1133                 dw = &sc->mge_tx_desc[sc->tx_desc_used_idx];
1134                 desc = dw->mge_desc;
1135                 bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
1136                     BUS_DMASYNC_POSTREAD);
1137
1138                 /* Get descriptor status */
1139                 status = desc->cmd_status;
1140
1141                 if (status & MGE_DMA_OWNED)
1142                         break;
1143
1144                 sc->tx_desc_used_idx =
1145                         (++sc->tx_desc_used_idx) % MGE_TX_DESC_NUM;;
1146                 sc->tx_desc_used_count--;
1147
1148                 /* Update collision statistics */
1149                 if (status & MGE_ERR_SUMMARY) {
1150                         if ((status & MGE_ERR_MASK) == MGE_TX_ERROR_LC)
1151                                 ifp->if_collisions++;
1152                         if ((status & MGE_ERR_MASK) == MGE_TX_ERROR_RL)
1153                                 ifp->if_collisions += 16;
1154                 }
1155
1156                 bus_dmamap_sync(sc->mge_tx_dtag, dw->buffer_dmap,
1157                     BUS_DMASYNC_POSTWRITE);
1158                 bus_dmamap_unload(sc->mge_tx_dtag, dw->buffer_dmap);
1159                 m_freem(dw->buffer);
1160                 dw->buffer = (struct mbuf*)NULL;
1161                 send++;
1162
1163                 ifp->if_opackets++;
1164         }
1165
1166         if (send) {
1167                 /* Now send anything that was pending */
1168                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1169                 mge_start_locked(ifp);
1170         }
1171 }
1172
1173 static int
1174 mge_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1175 {
1176         struct mge_softc *sc = ifp->if_softc;
1177         struct ifreq *ifr = (struct ifreq *)data;
1178         int mask, error;
1179         uint32_t flags;
1180
1181         error = 0;
1182
1183         switch (command) {
1184         case SIOCSIFFLAGS:
1185                 MGE_GLOBAL_LOCK(sc);
1186
1187                 if (ifp->if_flags & IFF_UP) {
1188                         if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1189                                 flags = ifp->if_flags ^ sc->mge_if_flags;
1190                                 if (flags & IFF_PROMISC)
1191                                         mge_set_prom_mode(sc,
1192                                             MGE_RX_DEFAULT_QUEUE);
1193
1194                                 if (flags & IFF_ALLMULTI)
1195                                         mge_setup_multicast(sc);
1196                         } else
1197                                 mge_init_locked(sc);
1198                 }
1199                 else if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1200                         mge_stop(sc);
1201
1202                 sc->mge_if_flags = ifp->if_flags;
1203                 MGE_GLOBAL_UNLOCK(sc);
1204                 break;
1205         case SIOCADDMULTI:
1206         case SIOCDELMULTI:
1207                 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1208                         MGE_GLOBAL_LOCK(sc);
1209                         mge_setup_multicast(sc);
1210                         MGE_GLOBAL_UNLOCK(sc);
1211                 }
1212                 break;
1213         case SIOCSIFCAP:
1214                 mask = ifp->if_capenable ^ ifr->ifr_reqcap;
1215                 if (mask & IFCAP_HWCSUM) {
1216                         ifp->if_capenable &= ~IFCAP_HWCSUM;
1217                         ifp->if_capenable |= IFCAP_HWCSUM & ifr->ifr_reqcap;
1218                         if (ifp->if_capenable & IFCAP_TXCSUM)
1219                                 ifp->if_hwassist = MGE_CHECKSUM_FEATURES;
1220                         else
1221                                 ifp->if_hwassist = 0;
1222                 }
1223 #ifdef DEVICE_POLLING
1224                 if (mask & IFCAP_POLLING) {
1225                         if (ifr->ifr_reqcap & IFCAP_POLLING) {
1226                                 error = ether_poll_register(mge_poll, ifp);
1227                                 if (error)
1228                                         return(error);
1229
1230                                 MGE_GLOBAL_LOCK(sc);
1231                                 mge_intrs_ctrl(sc, 0);
1232                                 ifp->if_capenable |= IFCAP_POLLING;
1233                                 MGE_GLOBAL_UNLOCK(sc);
1234                         } else {
1235                                 error = ether_poll_deregister(ifp);
1236                                 MGE_GLOBAL_LOCK(sc);
1237                                 mge_intrs_ctrl(sc, 1);
1238                                 ifp->if_capenable &= ~IFCAP_POLLING;
1239                                 MGE_GLOBAL_UNLOCK(sc);
1240                         }
1241                 }
1242 #endif
1243                 break;
1244         case SIOCGIFMEDIA: /* fall through */
1245         case SIOCSIFMEDIA:
1246                 if (IFM_SUBTYPE(ifr->ifr_media) == IFM_1000_T
1247                     && !(ifr->ifr_media & IFM_FDX)) {
1248                         device_printf(sc->dev,
1249                             "1000baseTX half-duplex unsupported\n");
1250                         return 0;
1251                 }
1252                 error = ifmedia_ioctl(ifp, ifr, &sc->mii->mii_media, command);
1253                 break;
1254         default:
1255                 error = ether_ioctl(ifp, command, data);
1256         }
1257         return (error);
1258 }
1259
1260 static int
1261 mge_miibus_readreg(device_t dev, int phy, int reg)
1262 {
1263         uint32_t retries;
1264
1265         /*
1266          * We assume static PHY address <=> device unit mapping:
1267          * PHY Address = MV_PHY_ADDR_BASE + devce unit.
1268          * This is true for most Marvell boards.
1269          *
1270          * Code below grants proper PHY detection on each device
1271          * unit.
1272          */
1273
1274         if ((MV_PHY_ADDR_BASE + device_get_unit(dev)) != phy)
1275                 return (0);
1276
1277         MGE_WRITE(sc_mge0, MGE_REG_SMI, 0x1fffffff &
1278             (MGE_SMI_READ | (reg << 21) | (phy << 16)));
1279
1280         retries = MGE_SMI_READ_RETRIES;
1281         while (--retries && !(MGE_READ(sc_mge0, MGE_REG_SMI) & MGE_SMI_READVALID))
1282                 DELAY(MGE_SMI_READ_DELAY);
1283
1284         if (retries == 0)
1285                 device_printf(dev, "Timeout while reading from PHY\n");
1286
1287         return (MGE_READ(sc_mge0, MGE_REG_SMI) & 0xffff);
1288 }
1289
1290 static int
1291 mge_miibus_writereg(device_t dev, int phy, int reg, int value)
1292 {
1293         uint32_t retries;
1294
1295         if ((MV_PHY_ADDR_BASE + device_get_unit(dev)) != phy)
1296                 return (0);
1297
1298         MGE_WRITE(sc_mge0, MGE_REG_SMI, 0x1fffffff &
1299             (MGE_SMI_WRITE | (reg << 21) | (phy << 16) | (value & 0xffff)));
1300
1301         retries = MGE_SMI_WRITE_RETRIES;
1302         while (--retries && MGE_READ(sc_mge0, MGE_REG_SMI) & MGE_SMI_BUSY)
1303                 DELAY(MGE_SMI_WRITE_DELAY);
1304
1305         if (retries == 0)
1306                 device_printf(dev, "Timeout while writing to PHY\n");
1307         return (0);
1308 }
1309
1310 static int
1311 mge_probe(device_t dev)
1312 {
1313
1314         device_set_desc(dev, "Marvell Gigabit Ethernet controller");
1315         return (BUS_PROBE_DEFAULT);
1316 }
1317
1318 static int
1319 mge_resume(device_t dev)
1320 {
1321
1322         device_printf(dev, "%s\n", __FUNCTION__);
1323         return (0);
1324 }
1325
1326 static int
1327 mge_shutdown(device_t dev)
1328 {
1329         struct mge_softc *sc = device_get_softc(dev);
1330
1331         MGE_GLOBAL_LOCK(sc);
1332
1333 #ifdef DEVICE_POLLING
1334         if (sc->ifp->if_capenable & IFCAP_POLLING)
1335                 ether_poll_deregister(sc->ifp);
1336 #endif
1337
1338         mge_stop(sc);
1339
1340         MGE_GLOBAL_UNLOCK(sc);
1341
1342         return (0);
1343 }
1344
1345 static int
1346 mge_encap(struct mge_softc *sc, struct mbuf *m0)
1347 {
1348         struct mge_desc_wrapper *dw = NULL;
1349         struct ifnet *ifp;
1350         bus_dma_segment_t segs[MGE_TX_DESC_NUM];
1351         bus_dmamap_t mapp;
1352         int error;
1353         int seg, nsegs;
1354         int desc_no;
1355
1356         ifp = sc->ifp;
1357
1358         /* Check for free descriptors */
1359         if (sc->tx_desc_used_count + 1 >= MGE_TX_DESC_NUM) {
1360                 /* No free descriptors */
1361                 return (-1);
1362         }
1363
1364         /* Fetch unused map */
1365         desc_no = sc->tx_desc_curr;
1366         dw = &sc->mge_tx_desc[desc_no];
1367         mapp = dw->buffer_dmap;
1368
1369         bus_dmamap_sync(sc->mge_desc_dtag, mapp,
1370             BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
1371
1372         /* Create mapping in DMA memory */
1373         error = bus_dmamap_load_mbuf_sg(sc->mge_tx_dtag, mapp, m0, segs, &nsegs,
1374             BUS_DMA_NOWAIT);
1375         if (error != 0 || nsegs != 1 ) {
1376                 bus_dmamap_unload(sc->mge_tx_dtag, mapp);
1377                 return ((error != 0) ? error : -1);
1378         }
1379
1380         bus_dmamap_sync(sc->mge_tx_dtag, mapp, BUS_DMASYNC_PREWRITE);
1381
1382         /* Everything is ok, now we can send buffers */
1383         for (seg = 0; seg < nsegs; seg++) {
1384                 dw->mge_desc->byte_count = segs[seg].ds_len;
1385                 dw->mge_desc->buffer = segs[seg].ds_addr;
1386                 dw->buffer = m0;
1387                 dw->mge_desc->cmd_status = MGE_TX_LAST | MGE_TX_FIRST |
1388                     MGE_TX_ETH_CRC | MGE_TX_EN_INT | MGE_TX_PADDING |
1389                     MGE_DMA_OWNED;
1390
1391                 if (seg == 0)
1392                         mge_offload_setup_descriptor(sc, dw);
1393         }
1394
1395         bus_dmamap_sync(sc->mge_desc_dtag, mapp,
1396             BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
1397
1398         sc->tx_desc_curr = (++sc->tx_desc_curr) % MGE_TX_DESC_NUM;
1399         sc->tx_desc_used_count++;
1400         return (0);
1401 }
1402
1403 static void
1404 mge_tick(void *msc)
1405 {
1406         struct mge_softc *sc = msc;
1407
1408         /* Check for TX timeout */
1409         mge_watchdog(sc);
1410
1411         mii_tick(sc->mii);
1412
1413         /* Check for media type change */
1414         if(sc->mge_media_status != sc->mii->mii_media.ifm_media)
1415                 mge_ifmedia_upd(sc->ifp);
1416
1417         /* Schedule another timeout one second from now */
1418         callout_reset(&sc->wd_callout, hz, mge_tick, sc);
1419 }
1420
1421 static void
1422 mge_watchdog(struct mge_softc *sc)
1423 {
1424         struct ifnet *ifp;
1425
1426         ifp = sc->ifp;
1427
1428         MGE_GLOBAL_LOCK(sc);
1429
1430         if (sc->wd_timer == 0 || --sc->wd_timer) {
1431                 MGE_GLOBAL_UNLOCK(sc);
1432                 return;
1433         }
1434
1435         ifp->if_oerrors++;
1436         if_printf(ifp, "watchdog timeout\n");
1437
1438         mge_stop(sc);
1439         mge_init_locked(sc);
1440
1441         MGE_GLOBAL_UNLOCK(sc);
1442 }
1443
1444 static void
1445 mge_start(struct ifnet *ifp)
1446 {
1447         struct mge_softc *sc = ifp->if_softc;
1448
1449         MGE_TRANSMIT_LOCK(sc);
1450
1451         mge_start_locked(ifp);
1452
1453         MGE_TRANSMIT_UNLOCK(sc);
1454 }
1455
1456 static void
1457 mge_start_locked(struct ifnet *ifp)
1458 {
1459         struct mge_softc *sc;
1460         struct mbuf *m0, *mtmp;
1461         uint32_t reg_val, queued = 0;
1462
1463         sc = ifp->if_softc;
1464
1465         MGE_TRANSMIT_LOCK_ASSERT(sc);
1466
1467         if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) !=
1468             IFF_DRV_RUNNING)
1469                 return;
1470
1471         for (;;) {
1472                 /* Get packet from the queue */
1473                 IF_DEQUEUE(&ifp->if_snd, m0);
1474                 if (m0 == NULL)
1475                         break;
1476
1477                 mtmp = m_defrag(m0, M_DONTWAIT);
1478                 if (mtmp)
1479                         m0 = mtmp;
1480
1481                 if (mge_encap(sc, m0)) {
1482                         IF_PREPEND(&ifp->if_snd, m0);
1483                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1484                         break;
1485                 }
1486                 queued++;
1487                 BPF_MTAP(ifp, m0);
1488         }
1489
1490         if (queued) {
1491                 /* Enable transmitter and watchdog timer */
1492                 reg_val = MGE_READ(sc, MGE_TX_QUEUE_CMD);
1493                 MGE_WRITE(sc, MGE_TX_QUEUE_CMD, reg_val | MGE_ENABLE_TXQ);
1494                 sc->wd_timer = 5;
1495         }
1496 }
1497
1498 static void
1499 mge_stop(struct mge_softc *sc)
1500 {
1501         struct ifnet *ifp;
1502         volatile uint32_t reg_val, status;
1503         struct mge_desc_wrapper *dw;
1504         struct mge_desc *desc;
1505         int count;
1506
1507         ifp = sc->ifp;
1508
1509         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1510                 return;
1511
1512         /* Stop tick engine */
1513         callout_stop(&sc->wd_callout);
1514
1515         /* Disable interface */
1516         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1517         sc->wd_timer = 0;
1518
1519         /* Disable interrupts */
1520         mge_intrs_ctrl(sc, 0);
1521
1522         /* Disable Rx and Tx */
1523         reg_val = MGE_READ(sc, MGE_TX_QUEUE_CMD);
1524         MGE_WRITE(sc, MGE_TX_QUEUE_CMD, reg_val | MGE_DISABLE_TXQ);
1525         MGE_WRITE(sc, MGE_RX_QUEUE_CMD, MGE_DISABLE_RXQ_ALL);
1526
1527         /* Remove pending data from TX queue */
1528         while (sc->tx_desc_used_idx != sc->tx_desc_curr &&
1529             sc->tx_desc_used_count) {
1530                 /* Get the descriptor */
1531                 dw = &sc->mge_tx_desc[sc->tx_desc_used_idx];
1532                 desc = dw->mge_desc;
1533                 bus_dmamap_sync(sc->mge_desc_dtag, dw->desc_dmap,
1534                     BUS_DMASYNC_POSTREAD);
1535
1536                 /* Get descriptor status */
1537                 status = desc->cmd_status;
1538
1539                 if (status & MGE_DMA_OWNED)
1540                         break;
1541
1542                 sc->tx_desc_used_idx = (++sc->tx_desc_used_idx) %
1543                     MGE_TX_DESC_NUM;
1544                 sc->tx_desc_used_count--;
1545
1546                 bus_dmamap_sync(sc->mge_tx_dtag, dw->buffer_dmap,
1547                     BUS_DMASYNC_POSTWRITE);
1548                 bus_dmamap_unload(sc->mge_tx_dtag, dw->buffer_dmap);
1549
1550                 m_freem(dw->buffer);
1551                 dw->buffer = (struct mbuf*)NULL;
1552         }
1553
1554         /* Wait for end of transmission */
1555         count = 0x100000;
1556         while (count--) {
1557                 reg_val = MGE_READ(sc, MGE_PORT_STATUS);
1558                 if ( !(reg_val & MGE_STATUS_TX_IN_PROG) &&
1559                     (reg_val & MGE_STATUS_TX_FIFO_EMPTY))
1560                         break;
1561                 DELAY(100);
1562         }
1563
1564         if(!count)
1565                 if_printf(ifp, "%s: timeout while waiting for end of transmission\n",
1566                     __FUNCTION__);
1567
1568         reg_val = MGE_READ(sc, MGE_PORT_SERIAL_CTRL);
1569         reg_val &= ~(PORT_SERIAL_ENABLE);
1570         MGE_WRITE(sc, MGE_PORT_SERIAL_CTRL ,reg_val);
1571 }
1572
1573 static int
1574 mge_suspend(device_t dev)
1575 {
1576
1577         device_printf(dev, "%s\n", __FUNCTION__);
1578         return (0);
1579 }
1580
1581 static void
1582 mge_offload_process_frame(struct ifnet *ifp, struct mbuf *frame,
1583     uint32_t status, uint16_t bufsize)
1584 {
1585         int csum_flags = 0;
1586
1587         if (ifp->if_capenable & IFCAP_RXCSUM) {
1588                 if ((status & MGE_RX_L3_IS_IP) && (status & MGE_RX_IP_OK))
1589                         csum_flags |= CSUM_IP_CHECKED | CSUM_IP_VALID;
1590
1591                 if ((bufsize & MGE_RX_IP_FRAGMENT) == 0 &&
1592                     (MGE_RX_L4_IS_TCP(status) || MGE_RX_L4_IS_UDP(status)) &&
1593                     (status & MGE_RX_L4_CSUM_OK)) {
1594                         csum_flags |= CSUM_DATA_VALID | CSUM_PSEUDO_HDR;
1595                         frame->m_pkthdr.csum_data = 0xFFFF;
1596                 }
1597
1598                 frame->m_pkthdr.csum_flags = csum_flags;
1599         }
1600 }
1601
1602 static void
1603 mge_offload_setup_descriptor(struct mge_softc *sc, struct mge_desc_wrapper *dw)
1604 {
1605         struct mbuf *m0 = dw->buffer;
1606         struct ether_vlan_header *eh = mtod(m0, struct ether_vlan_header *);
1607         int csum_flags = m0->m_pkthdr.csum_flags;
1608         int cmd_status = 0;
1609         struct ip *ip;
1610         int ehlen, etype;
1611
1612         if (csum_flags) {
1613                 if (eh->evl_encap_proto == htons(ETHERTYPE_VLAN)) {
1614                         etype = ntohs(eh->evl_proto);
1615                         ehlen = ETHER_HDR_LEN + ETHER_VLAN_ENCAP_LEN;
1616                         csum_flags |= MGE_TX_VLAN_TAGGED;
1617                 } else {
1618                         etype = ntohs(eh->evl_encap_proto);
1619                         ehlen = ETHER_HDR_LEN;
1620                 }
1621
1622                 if (etype != ETHERTYPE_IP) {
1623                         if_printf(sc->ifp,
1624                             "TCP/IP Offload enabled for unsupported "
1625                             "protocol!\n");
1626                         return;
1627                 }
1628
1629                 ip = (struct ip *)(m0->m_data + ehlen);
1630                 cmd_status |= MGE_TX_IP_HDR_SIZE(ip->ip_hl);
1631
1632                 if ((m0->m_flags & M_FRAG) == 0)
1633                         cmd_status |= MGE_TX_NOT_FRAGMENT;
1634         }
1635
1636         if (csum_flags & CSUM_IP)
1637                 cmd_status |= MGE_TX_GEN_IP_CSUM;
1638
1639         if (csum_flags & CSUM_TCP)
1640                 cmd_status |= MGE_TX_GEN_L4_CSUM;
1641
1642         if (csum_flags & CSUM_UDP)
1643                 cmd_status |= MGE_TX_GEN_L4_CSUM | MGE_TX_UDP;
1644
1645         dw->mge_desc->cmd_status |= cmd_status;
1646 }
1647
1648 static void
1649 mge_intrs_ctrl(struct mge_softc *sc, int enable)
1650 {
1651
1652         if (enable) {
1653                 MGE_WRITE(sc, MGE_PORT_INT_MASK , MGE_PORT_INT_RXQ0 |
1654                     MGE_PORT_INT_EXTEND | MGE_PORT_INT_RXERRQ0);
1655                 MGE_WRITE(sc, MGE_PORT_INT_MASK_EXT , MGE_PORT_INT_EXT_TXERR0 |
1656                     MGE_PORT_INT_EXT_RXOR | MGE_PORT_INT_EXT_TXUR |
1657                     MGE_PORT_INT_EXT_TXBUF0);
1658         } else {
1659                 MGE_WRITE(sc, MGE_INT_CAUSE, 0x0);
1660                 MGE_WRITE(sc, MGE_INT_MASK, 0x0);
1661
1662                 MGE_WRITE(sc, MGE_PORT_INT_CAUSE, 0x0);
1663                 MGE_WRITE(sc, MGE_PORT_INT_CAUSE_EXT, 0x0);
1664
1665                 MGE_WRITE(sc, MGE_PORT_INT_MASK, 0x0);
1666                 MGE_WRITE(sc, MGE_PORT_INT_MASK_EXT, 0x0);
1667         }
1668 }
1669
1670 static uint8_t
1671 mge_crc8(uint8_t *data, int size)
1672 {
1673         uint8_t crc = 0;
1674         static const uint8_t ct[256] = {
1675                 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
1676                 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
1677                 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
1678                 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
1679                 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
1680                 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
1681                 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
1682                 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
1683                 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
1684                 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
1685                 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
1686                 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
1687                 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
1688                 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
1689                 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
1690                 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
1691                 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
1692                 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
1693                 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
1694                 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
1695                 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
1696                 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
1697                 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
1698                 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
1699                 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
1700                 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
1701                 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
1702                 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
1703                 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
1704                 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
1705                 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
1706                 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
1707         };
1708
1709         while(size--)
1710                 crc = ct[crc ^ *(data++)];
1711
1712         return(crc);
1713 }
1714
1715 static void
1716 mge_setup_multicast(struct mge_softc *sc)
1717 {
1718         uint8_t special[5] = { 0x01, 0x00, 0x5E, 0x00, 0x00 };
1719         uint8_t v = (MGE_RX_DEFAULT_QUEUE << 1) | 1;
1720         uint32_t smt[MGE_MCAST_REG_NUMBER];
1721         uint32_t omt[MGE_MCAST_REG_NUMBER];
1722         struct ifnet *ifp = sc->ifp;
1723         struct ifmultiaddr *ifma;
1724         uint8_t *mac;
1725         int i;
1726
1727         if (ifp->if_flags & IFF_ALLMULTI) {
1728                 for (i = 0; i < MGE_MCAST_REG_NUMBER; i++)
1729                         smt[i] = omt[i] = (v << 24) | (v << 16) | (v << 8) | v;
1730         } else {
1731                 memset(smt, 0, sizeof(smt));
1732                 memset(omt, 0, sizeof(omt));
1733
1734                 if_maddr_rlock(ifp);
1735                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1736                         if (ifma->ifma_addr->sa_family != AF_LINK)
1737                                 continue;
1738
1739                         mac = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
1740                         if (memcmp(mac, special, sizeof(special)) == 0) {
1741                                 i = mac[5];
1742                                 smt[i >> 2] |= v << ((i & 0x03) << 3);
1743                         } else {
1744                                 i = mge_crc8(mac, ETHER_ADDR_LEN);
1745                                 omt[i >> 2] |= v << ((i & 0x03) << 3);
1746                         }
1747                 }
1748                 if_maddr_runlock(ifp);
1749         }
1750
1751         for (i = 0; i < MGE_MCAST_REG_NUMBER; i++) {
1752                 MGE_WRITE(sc, MGE_DA_FILTER_SPEC_MCAST(i), smt[i]);
1753                 MGE_WRITE(sc, MGE_DA_FILTER_OTH_MCAST(i), omt[i]);
1754         }
1755 }
1756
1757 static void
1758 mge_set_rxic(struct mge_softc *sc)
1759 {
1760         uint32_t reg;
1761
1762         if (sc->rx_ic_time > sc->mge_rx_ipg_max)
1763                 sc->rx_ic_time = sc->mge_rx_ipg_max;
1764
1765         reg = MGE_READ(sc, MGE_SDMA_CONFIG);
1766         reg &= ~mge_rx_ipg(sc->mge_rx_ipg_max, sc->mge_ver);
1767         reg |= mge_rx_ipg(sc->rx_ic_time, sc->mge_ver);
1768         MGE_WRITE(sc, MGE_SDMA_CONFIG, reg);
1769 }
1770
1771 static void
1772 mge_set_txic(struct mge_softc *sc)
1773 {
1774         uint32_t reg;
1775
1776         if (sc->tx_ic_time > sc->mge_tfut_ipg_max)
1777                 sc->tx_ic_time = sc->mge_tfut_ipg_max;
1778
1779         reg = MGE_READ(sc, MGE_TX_FIFO_URGENT_TRSH);
1780         reg &= ~mge_tfut_ipg(sc->mge_tfut_ipg_max, sc->mge_ver);
1781         reg |= mge_tfut_ipg(sc->tx_ic_time, sc->mge_ver);
1782         MGE_WRITE(sc, MGE_TX_FIFO_URGENT_TRSH, reg);
1783 }
1784
1785 static int
1786 mge_sysctl_ic(SYSCTL_HANDLER_ARGS)
1787 {
1788         struct mge_softc *sc = (struct mge_softc *)arg1;
1789         uint32_t time;
1790         int error;
1791
1792         time = (arg2 == MGE_IC_RX) ? sc->rx_ic_time : sc->tx_ic_time;
1793         error = sysctl_handle_int(oidp, &time, 0, req);
1794         if (error != 0)
1795                 return(error);
1796
1797         MGE_GLOBAL_LOCK(sc);
1798         if (arg2 == MGE_IC_RX) {
1799                 sc->rx_ic_time = time;
1800                 mge_set_rxic(sc);
1801         } else {
1802                 sc->tx_ic_time = time;
1803                 mge_set_txic(sc);
1804         }
1805         MGE_GLOBAL_UNLOCK(sc);
1806
1807         return(0);
1808 }
1809
1810 static void
1811 mge_add_sysctls(struct mge_softc *sc)
1812 {
1813         struct sysctl_ctx_list *ctx;
1814         struct sysctl_oid_list *children;
1815         struct sysctl_oid *tree;
1816
1817         ctx = device_get_sysctl_ctx(sc->dev);
1818         children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
1819         tree = SYSCTL_ADD_NODE(ctx, children, OID_AUTO, "int_coal",
1820             CTLFLAG_RD, 0, "MGE Interrupts coalescing");
1821         children = SYSCTL_CHILDREN(tree);
1822
1823         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "rx_time",
1824             CTLTYPE_UINT | CTLFLAG_RW, sc, MGE_IC_RX, mge_sysctl_ic,
1825             "I", "IC RX time threshold");
1826         SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "tx_time",
1827             CTLTYPE_UINT | CTLFLAG_RW, sc, MGE_IC_TX, mge_sysctl_ic,
1828             "I", "IC TX time threshold");
1829 }