sys/dev/netif/sln/if_sln.c

   1 /*
   2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  * 3. Neither the name of The DragonFly Project nor the names of its
  15  *    contributors may be used to endorse or promote products derived
  16  *    from this software without specific, prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD-4.7: /usr/src/sys/pci/silan.c,v 1.0 2003/01/10 gaoyonghong $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/endian.h>
  37 #include <sys/kernel.h>
  38 #include <sys/interrupt.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/resource.h>
  42 #include <sys/rman.h>
  43 #include <sys/socket.h>
  44 #include <sys/sockio.h>
  45 #include <sys/systm.h>
  46
  47 #include <bus/pci/pcidevs.h>
  48 #include <bus/pci/pcireg.h>
  49 #include <bus/pci/pcivar.h>
  50
  51 #include <machine/clock.h>
  52
  53 #include <net/bpf.h>
  54 #include <net/ethernet.h>
  55 #include <net/ifq_var.h>
  56 #include <net/if.h>
  57 #include <net/if_arp.h>
  58 #include <net/if_dl.h>
  59 #include <net/if_media.h>
  60 #include <net/if_var.h>
  61
  62 #include <vm/pmap.h>
  63 #include <vm/vm.h>
  64
  65 #include "if_slnreg.h"
  66 #include "if_slnvar.h"
  67
  68 /* Default to using PIO access for netcard driver */
  69 #define SL_USEIOSPACE
  70
  71 #ifdef SLN_DEBUG
  72 #define PDEBUG(fmt, args...)    kprintf("%s: " fmt "\n" , __func__ , ## args)
  73 #else
  74 #define PDEBUG(fmt, args...)
  75 #endif
  76
  77 static const struct sln_dev {
  78         uint16_t vid;
  79         uint16_t did;
  80         const char *desc;
  81 } sln_devs[] = {
  82         {PCI_VENDOR_SILAN, PCI_PRODUCT_SILAN_SC92031,
  83          "Silan SC92031 Fast Ethernet" },
  84         {PCI_VENDOR_SILAN, PCI_PRODUCT_SILAN_8139D,
  85          "Silan Rsltek 8139D Fast Ethernet" },
  86         {0, 0, NULL}
  87 };
  88
  89 static int      sln_probe(device_t);
  90 static int      sln_attach(device_t);
  91 static int      sln_detach(device_t);
  92 static int      sln_shutdown(device_t);
  93 static int      sln_suspend(device_t);
  94 static int      sln_resume(device_t);
  95
  96 static void     sln_reset(struct sln_softc *);
  97 static void     sln_init(void *);
  98
  99 static void     sln_tx(struct ifnet *, struct ifaltq_subque *);
 100 static void     sln_rx(struct sln_softc *);
 101 static void     sln_tx_intr(struct sln_softc *);
 102 static void     sln_media_intr(struct sln_softc *);
 103 static void     sln_interrupt(void *);
 104 static int      sln_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 105 static void     sln_stop(struct sln_softc *);
 106 static void     sln_watchdog(struct ifnet *);
 107
 108 static int      sln_media_upd(struct ifnet *);
 109
 110 static void     sln_media_stat(struct ifnet *, struct ifmediareq *);
 111 static void     sln_mii_cmd(struct sln_softc *, uint32_t, u_long *);
 112 static void     sln_media_cfg(struct sln_softc *);
 113 static void     sln_mac_cfg(struct sln_softc *);
 114 static uint32_t sln_ether_crc32(caddr_t);
 115 static void     sln_set_multi(struct sln_softc *);
 116 static void     sln_init_tx(struct sln_softc *);
 117 static void     sln_tick(void *);
 118
 119 #ifdef SL_USEIOSPACE
 120 #define SL_RID  SL_PCI_IOAD
 121 #define SL_RES  SYS_RES_IOPORT
 122 #else
 123 #define SL_RID  SL_PCI_MEMAD
 124 #define SL_RES  SYS_RES_MEMORY
 125 #endif
 126
 127 static device_method_t sln_methods[] = {
 128         DEVMETHOD(device_probe,         sln_probe),
 129         DEVMETHOD(device_attach,        sln_attach),
 130         DEVMETHOD(device_detach,        sln_detach),
 131         DEVMETHOD(device_shutdown,      sln_shutdown),
 132         DEVMETHOD(device_suspend,       sln_suspend),
 133         DEVMETHOD(device_resume,        sln_resume),
 134
 135         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 136         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 137
 138         {0, 0}
 139 };
 140
 141 static driver_t sln_driver = {
 142         "sln",
 143         sln_methods,
 144         sizeof(struct sln_softc)
 145 };
 146
 147 static devclass_t sln_devclass;
 148
 149 DRIVER_MODULE(sln, pci, sln_driver, sln_devclass, NULL, NULL);
 150
 151 static int
 152 sln_probe(struct device *dev)
 153 {
 154         const struct sln_dev *d;
 155         uint16_t did, vid;
 156
 157         vid = pci_get_vendor(dev);
 158         did = pci_get_device(dev);
 159
 160         for (d = sln_devs; d->desc != NULL; d++) {
 161                 if (vid == d->vid && did == d->did) {
 162                         device_set_desc(dev, d->desc);
 163                         return 0;
 164                 }
 165         }
 166         return ENXIO;
 167 }
 168
 169 /* the chip reset */
 170 static void
 171 sln_reset(struct sln_softc *sc)
 172 {
 173         SLN_WRITE_4(sc, SL_CFG0, SL_SOFT_RESET);
 174         DELAY(200000);
 175         SLN_WRITE_4(sc, SL_CFG0, 0x0);
 176         DELAY(10000);
 177 }
 178
 179 /* Attach the interface. Allocate softc structures */
 180 static int
 181 sln_attach(device_t dev)
 182 {
 183         struct sln_softc *sc = device_get_softc(dev);
 184         struct ifnet *ifp = &sc->arpcom.ac_if;
 185         unsigned char eaddr[ETHER_ADDR_LEN];
 186         int rid;
 187         int error = 0;
 188
 189         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 190
 191         /* TODO: power state change */
 192
 193         pci_enable_busmaster(dev);
 194
 195         rid = SL_RID;
 196         sc->sln_res = bus_alloc_resource_any(dev, SL_RES, &rid, RF_ACTIVE);
 197         if (sc->sln_res == NULL) {
 198                 device_printf(dev, "couldn't map ports/memory\n");
 199                 error = ENXIO;
 200                 goto fail;
 201         }
 202         sc->sln_bustag = rman_get_bustag(sc->sln_res);
 203         sc->sln_bushandle = rman_get_bushandle(sc->sln_res);
 204
 205         /* alloc pci irq */
 206         rid = 0;
 207         sc->sln_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 208             RF_SHAREABLE | RF_ACTIVE);
 209         if (sc->sln_irq == NULL) {
 210                 device_printf(dev, "couldn't map interrupt\n");
 211                 bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
 212                 error = ENXIO;
 213                 goto fail;
 214         }
 215
 216         /* Get MAC address */
 217         ((uint32_t *)(&eaddr))[0] = be32toh(SLN_READ_4(sc, SL_MAC_ADDR0));
 218         ((uint16_t *)(&eaddr))[2] = be16toh(SLN_READ_4(sc, SL_MAC_ADDR1));
 219
 220         /* alloc rx buffer space */
 221         sc->sln_bufdata.sln_rx_buf = contigmalloc(SL_RX_BUFLEN,
 222             M_DEVBUF, M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);
 223         if (sc->sln_bufdata.sln_rx_buf == NULL) {
 224                 device_printf(dev, "no memory for rx buffers!\n");
 225                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sln_irq);
 226                 bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
 227                 error = ENXIO;
 228                 goto fail;
 229         }
 230         callout_init(&sc->sln_state);
 231
 232         ifp->if_softc = sc;
 233         ifp->if_mtu = ETHERMTU;
 234         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 235         ifp->if_init = sln_init;
 236         ifp->if_start = sln_tx;
 237         ifp->if_ioctl = sln_ioctl;
 238         ifp->if_watchdog = sln_watchdog;
 239         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 240         ifq_set_ready(&ifp->if_snd);
 241
 242         /* initial media */
 243         ifmedia_init(&sc->ifmedia, 0, sln_media_upd, sln_media_stat);
 244
 245         /* supported media types */
 246         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL);
 247         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T, 0, NULL);
 248         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_HDX, 0, NULL);
 249         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
 250         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX, 0, NULL);
 251         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_HDX, 0, NULL);
 252         ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
 253
 254         /* Choose a default media. */
 255         ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_AUTO);
 256
 257         ether_ifattach(ifp, eaddr, NULL);
 258
 259         error = bus_setup_intr(dev, sc->sln_irq, INTR_MPSAFE, sln_interrupt, sc,
 260                                &sc->sln_intrhand, ifp->if_serializer);
 261         if (error) {
 262                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sln_irq);
 263                 bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
 264                 ether_ifdetach(ifp);
 265                 device_printf(dev, "couldn't set up irq\n");
 266                 goto fail;
 267         }
 268
 269         ifq_set_cpuid(&ifp->if_snd, rman_get_cpuid(sc->sln_irq));
 270
 271         return 0;
 272 fail:
 273         return error;
 274 }
 275
 276 /* Stop the adapter and free any mbufs allocated to the RX and TX buffers */
 277 static void
 278 sln_stop(struct sln_softc *sc)
 279 {
 280         struct ifnet *ifp = &sc->arpcom.ac_if;
 281         uint32_t intr_status;
 282         int i;
 283
 284         ASSERT_SERIALIZED(ifp->if_serializer);
 285
 286         ifp->if_timer = 0;
 287         callout_stop(&sc->sln_state);
 288
 289         /* disable Tx/Rx */
 290         sc->txcfg &= ~SL_TXCFG_EN;
 291         sc->rxcfg &= ~SL_RXCFG_EN;
 292         SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
 293         SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
 294
 295         /* Clear interrupt */
 296         SLN_WRITE_4(sc, SL_INT_MASK, 0);
 297         intr_status = SLN_READ_4(sc, SL_INT_STATUS);
 298
 299         /* Free the TX list buffers */
 300         for (i = 0; i < SL_TXD_CNT; i++) {
 301                 if (sc->sln_bufdata.sln_tx_buf[i] != NULL) {
 302                         m_freem(sc->sln_bufdata.sln_tx_buf[i]);
 303                         sc->sln_bufdata.sln_tx_buf[i] = NULL;
 304                         SLN_WRITE_4(sc, SL_TSAD0 + i * 4, 0);
 305                 }
 306         }
 307
 308         ifp->if_flags &= ~IFF_RUNNING;
 309         ifq_clr_oactive(&ifp->if_snd);
 310 }
 311
 312 static int
 313 sln_detach(device_t dev)
 314 {
 315         struct sln_softc *sc = device_get_softc(dev);
 316         struct ifnet *ifp = &sc->arpcom.ac_if;
 317
 318         lwkt_serialize_enter(ifp->if_serializer);
 319         sln_stop(sc);
 320         bus_teardown_intr(dev, sc->sln_irq, sc->sln_intrhand);
 321         lwkt_serialize_exit(ifp->if_serializer);
 322
 323         ether_ifdetach(ifp);
 324
 325         bus_generic_detach(dev);
 326
 327         bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sln_irq);
 328         bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
 329
 330         contigfree(sc->sln_bufdata.sln_rx_buf, SL_RX_BUFLEN, M_DEVBUF);
 331
 332         return 0;
 333 }
 334
 335 static int
 336 sln_media_upd(struct ifnet *ifp)
 337 {
 338         struct sln_softc *sc = ifp->if_softc;
 339         struct ifmedia *ifm = &sc->ifmedia;
 340
 341         if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
 342                 return EINVAL;
 343
 344         if (ifp->if_flags & IFF_UP)
 345                 sln_init(sc);
 346
 347         return 0;
 348 }
 349
 350 static void
 351 sln_media_stat(struct ifnet *ifp, struct ifmediareq *ifmr)
 352 {
 353         struct sln_softc *sc = ifp->if_softc;
 354         u_long phys[2];
 355         uint32_t temp;
 356
 357         ifmr->ifm_status = IFM_AVALID;
 358         ifmr->ifm_active = IFM_ETHER;
 359
 360         phys[0] = SL_MII_STAT;
 361         sln_mii_cmd(sc, SL_MII0_READ, phys);
 362
 363         if (phys[1] & SL_MIISTAT_LINK)
 364                 ifmr->ifm_status |= IFM_ACTIVE;
 365
 366         temp = SLN_READ_4(sc, SL_PHY_CTRL);
 367
 368         if ((temp & (SL_PHYCTL_DUX | SL_PHYCTL_SPD100 | SL_PHYCTL_SPD10)) == 0x60800000)
 369                 ifmr->ifm_active |= IFM_AUTO;
 370         else if ((temp & (SL_PHYCTL_DUX | SL_PHYCTL_SPD100)) == 0x40800000)
 371                 ifmr->ifm_active |= IFM_100_TX | IFM_FDX;
 372         else if ((temp & SL_PHYCTL_SPD100) == 0x40000000)
 373                 ifmr->ifm_active |= IFM_100_TX | IFM_HDX;
 374         else if ((temp & (SL_PHYCTL_DUX | SL_PHYCTL_SPD10)) == 0x20800000)
 375                 ifmr->ifm_active |= IFM_10_T | IFM_FDX;
 376         else if ((temp & SL_PHYCTL_SPD10) == 0x20000000)
 377                 ifmr->ifm_active |= IFM_10_T | IFM_HDX;
 378
 379         sln_mii_cmd(sc, SL_MII0_SCAN, phys);
 380 }
 381
 382 /* command selected in MII command register  */
 383 static void
 384 sln_mii_cmd(struct sln_softc *sc, uint32_t cmd, u_long *phys)
 385 {
 386         uint32_t mii_status;
 387
 388         SLN_WRITE_4(sc, SL_MII_CMD0, SL_MII0_DIVEDER);
 389
 390         do {
 391                 mii_status = 0;
 392                 DELAY(10);
 393                 mii_status = SLN_READ_4(sc, SL_MII_STATUS);
 394         } while (mii_status & SL_MIISTAT_BUSY);
 395
 396         switch (cmd) {
 397         case SL_MII0_SCAN:
 398                 SLN_WRITE_4(sc, SL_MII_CMD1, 0x1 << 6);
 399                 SLN_WRITE_4(sc, SL_MII_CMD0, SL_MII0_DIVEDER | SL_MII0_SCAN);
 400                 break;
 401
 402         case SL_MII0_READ:
 403                 SLN_WRITE_4(sc, SL_MII_CMD1, phys[0] << 6);
 404                 SLN_WRITE_4(sc, SL_MII_CMD0, SL_MII0_DIVEDER | SL_MII0_READ);
 405                 break;
 406
 407         default:                /* WRITE */
 408                 SLN_WRITE_4(sc, SL_MII_CMD1, phys[0] << 6 | phys[1] << 11);
 409                 SLN_WRITE_4(sc, SL_MII_CMD0, SL_MII0_DIVEDER | SL_MII0_WRITE);
 410                 break;
 411         }
 412
 413         do {
 414                 DELAY(10);
 415                 mii_status = SLN_READ_4(sc, SL_MII_STATUS);
 416         } while (mii_status & SL_MIISTAT_BUSY);
 417
 418         if (SL_MII0_READ == cmd)
 419                 phys[1] = (mii_status >> 13) & 0xffff;
 420 }
 421
 422 /* Set media speed and duplex mode */
 423 static void
 424 sln_media_cfg(struct sln_softc *sc)
 425 {
 426         u_long phys[2];
 427         uint32_t mediatype;
 428         uint32_t temp;
 429
 430         mediatype = (&sc->ifmedia)->ifm_cur->ifm_media;
 431
 432         temp = SLN_READ_4(sc, SL_PHY_CTRL);
 433         temp &= ~(SL_PHYCTL_DUX | SL_PHYCTL_SPD100 | SL_PHYCTL_SPD10);
 434         temp |= (SL_PHYCTL_ANE | SL_PHYCTL_RESET);
 435
 436         /************************************************/
 437         /* currently set media word by selected media   */
 438         /*                                              */
 439         /* IFM_ETHER = 0x00000020                       */
 440         /* IFM_AUTO=0, IFM_10_T=3,  IFM_100_TX=6        */
 441         /* IFM_FDX=0x00100000    IFM_HDX=0x00200000     */
 442         /************************************************/
 443         switch (mediatype) {
 444         case 0x00000020:
 445                 PDEBUG(" autoselet supported\n");
 446                 temp |= (SL_PHYCTL_DUX | SL_PHYCTL_SPD100 | SL_PHYCTL_SPD10);
 447                 sc->ifmedia.ifm_media = IFM_ETHER | IFM_AUTO;
 448                 ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_AUTO);
 449                 break;
 450         case 0x23:
 451         case 0x00200023:
 452                 PDEBUG(" 10Mbps half_duplex supported\n");
 453                 temp |= SL_PHYCTL_SPD10;
 454                 sc->ifmedia.ifm_media = IFM_ETHER | IFM_10_T | IFM_HDX;
 455                 ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_HDX);
 456                 break;
 457
 458         case 0x00100023:
 459                 PDEBUG("10Mbps full_duplex supported\n");
 460                 temp |= (SL_PHYCTL_SPD10 | SL_PHYCTL_DUX);
 461                 sc->ifmedia.ifm_media = IFM_ETHER | IFM_10_T | IFM_FDX;
 462                 ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_FDX);
 463                 break;
 464
 465         case 0x26:
 466         case 0x00200026:
 467                 PDEBUG("100Mbps half_duplex supported\n");
 468                 temp |= SL_PHYCTL_SPD100;
 469                 sc->ifmedia.ifm_media = IFM_ETHER | IFM_100_TX | IFM_HDX;
 470                 ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_HDX);
 471                 break;
 472
 473         case 0x00100026:
 474                 PDEBUG("100Mbps full_duplex supported\n");
 475                 temp |= (SL_PHYCTL_SPD100 | SL_PHYCTL_DUX);
 476                 sc->ifmedia.ifm_media = IFM_ETHER | IFM_100_TX | IFM_FDX;
 477                 ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX);
 478                 break;
 479
 480         default:
 481                 break;
 482         }
 483
 484         SLN_WRITE_4(sc, SL_PHY_CTRL, temp);
 485
 486         DELAY(10000);
 487         temp &= ~SL_PHYCTL_RESET;
 488         SLN_WRITE_4(sc, SL_PHY_CTRL, temp);
 489
 490         DELAY(1000);
 491         phys[0] = SL_MII_JAB;
 492         phys[1] = SL_PHY_16_JAB_ENB | SL_PHY_16_PORT_ENB;
 493         sln_mii_cmd(sc, SL_MII0_WRITE, phys);
 494
 495         sc->connect = 0;
 496         sln_mii_cmd(sc, SL_MII0_SCAN, phys);
 497 }
 498
 499 static void
 500 sln_mac_cfg(struct sln_softc *sc)
 501 {
 502         struct ifnet *ifp = &sc->arpcom.ac_if;
 503         u_long flowcfg = 0;
 504
 505         /* Set the initial TX/RX/Flow Control configuration */
 506         sc->rxcfg = SL_RXCFG_LOW_THRESHOLD | SL_RXCFG_HIGH_THRESHOLD;
 507         sc->txcfg = TX_CFG_DEFAULT;
 508
 509         if (sc->txenablepad)
 510                 sc->txcfg |= 0x20000000;
 511
 512         if (sc->media_speed == IFM_10_T)
 513                 sc->txcfg |= SL_TXCFG_DATARATE;
 514
 515         if (sc->media_duplex == IFM_FDX) {
 516                 sc->rxcfg |= SL_RXCFG_FULLDX;
 517                 sc->txcfg |= SL_TXCFG_FULLDX;
 518                 flowcfg = SL_FLOWCTL_FULLDX | SL_FLOWCTL_EN;
 519         } else {
 520                 sc->rxcfg &= ~SL_RXCFG_FULLDX;
 521                 sc->txcfg &= ~SL_TXCFG_FULLDX;
 522         }
 523
 524         /* if promiscuous mode, set the allframes bit. */
 525         if (ifp->if_flags & IFF_PROMISC)
 526                 sc->rxcfg |= (SL_RXCFG_EN | SL_RXCFG_RCV_SMALL | SL_RXCFG_RCV_HUGE | SL_RXCFG_RCV_ERR | SL_RXCFG_RCV_BROAD | SL_RXCFG_RCV_MULTI | SL_RXCFG_RCV_ALL);
 527         else
 528                 sc->rxcfg &= ~(SL_RXCFG_EN | SL_RXCFG_RCV_SMALL | SL_RXCFG_RCV_HUGE | SL_RXCFG_RCV_ERR | SL_RXCFG_RCV_BROAD | SL_RXCFG_RCV_MULTI | SL_RXCFG_RCV_ALL);
 529
 530         /* Set capture broadcast bit to capture broadcast frames */
 531         if (ifp->if_flags & IFF_BROADCAST)
 532                 sc->rxcfg |= SL_RXCFG_EN | SL_RXCFG_RCV_BROAD;
 533         else
 534                 sc->rxcfg &= ~(SL_RXCFG_EN | SL_RXCFG_RCV_BROAD);
 535
 536         /* Program the multicast filter, if necessary */
 537         sln_set_multi(sc);
 538
 539         SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
 540         SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
 541         SLN_WRITE_4(sc, SL_FLOW_CTRL, flowcfg);
 542 }
 543
 544 static u_char shade_map[] = { 0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
 545                               0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf };
 546
 547 /* Calculate CRC32 of a multicast group address */
 548 static uint32_t
 549 sln_ether_crc32(caddr_t addr)
 550 {
 551         uint32_t crc, crcr;
 552         int i, j;
 553         unsigned char data = 0;
 554         /* Compute CRC for the address value. */
 555
 556         crc = 0xFFFFFFFF;       /* initial value */
 557
 558         for (i = ETHER_ADDR_LEN; i > 0; i--) {
 559                 data = *addr++;
 560
 561                 for (j = 0; j < 8; j++) {
 562                         if (((data & 0x1) ^ (crc & 0x1)) != 0) {
 563                                 crc >>= 1;
 564                                 crc ^= 0xEDB88320;
 565                         } else {
 566                                 crc >>= 1;
 567                         }
 568                         data >>= 1;
 569                 }
 570         }
 571
 572         crcr = shade_map[crc >> 28];
 573         crcr |= (shade_map[(crc >> 24) & 0xf] << 4);
 574         crcr |= (shade_map[(crc >> 20) & 0xf] << 8);
 575         crcr |= (shade_map[(crc >> 16) & 0xf] << 12);
 576         crcr |= (shade_map[(crc >> 12) & 0xf] << 16);
 577         crcr |= (shade_map[(crc >> 8) & 0xf] << 20);
 578         crcr |= (shade_map[(crc >> 4) & 0xf] << 24);
 579         crcr |= (shade_map[crc & 0xf] << 28);
 580
 581         return crcr;
 582 }
 583
 584 /* Program the 64-bit multicast hash filter */
 585 static void
 586 sln_set_multi(struct sln_softc *sc)
 587 {
 588         struct ifnet *ifp = &sc->arpcom.ac_if;
 589         uint32_t crc = 0;
 590         uint32_t mc_g[2] = {0, 0};
 591         struct ifmultiaddr *ifma;
 592         int j;
 593
 594         if (ifp->if_flags & IFF_PROMISC) {
 595                 kprintf("Promisc mode is enabled\n");
 596                 sc->rxcfg |= SL_RXCFG_EN | SL_RXCFG_RCV_MULTI;
 597                 mc_g[0] = mc_g[1] = 0xFFFFFFFF;
 598         } else if (ifp->if_flags & IFF_ALLMULTI) {
 599                 kprintf("Allmulti mode is enabled\n");
 600                 sc->rxcfg |= SL_RXCFG_EN | SL_RXCFG_RCV_MULTI;
 601                 mc_g[0] = mc_g[1] = 0xFFFFFFFF;
 602         } else if (ifp->if_flags & IFF_MULTICAST) {
 603                 kprintf("Multicast mode is enabled\n");
 604                 sc->rxcfg |= SL_RXCFG_EN | SL_RXCFG_RCV_MULTI;
 605
 606                 /* first, zero all the existing hash bits */
 607                 mc_g[0] = mc_g[1] = 0;
 608
 609                 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
 610                         j = 0;
 611
 612                         if ((ifma->ifma_addr->sa_family) != AF_LINK)
 613                                 continue;
 614
 615                         crc = ~sln_ether_crc32(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
 616                         crc >>= 24;
 617
 618                         if (crc & 0x1)
 619                                 j |= 0x2;
 620                         if (crc & 0x2)
 621                                 j |= 0x1;
 622                         if (crc & 0x10)
 623                                 j |= 0x20;
 624                         if (crc & 0x20)
 625                                 j |= 0x10;
 626                         if (crc & 0x40)
 627                                 j |= 0x8;
 628                         if (crc & 0x80)
 629                                 j |= 0x4;
 630
 631                         if (j > 31)
 632                                 mc_g[0] |= (0x1 << (j - 32));
 633                         else
 634                                 mc_g[1] |= (0x1 << j);
 635                 }
 636         } else {
 637                 sc->rxcfg &= ~(SL_RXCFG_EN | SL_RXCFG_RCV_MULTI);
 638         }
 639
 640         SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
 641         SLN_WRITE_4(sc, SL_MULTI_GROUP0, mc_g[0]);
 642         SLN_WRITE_4(sc, SL_MULTI_GROUP1, mc_g[1]);
 643 }
 644
 645 /* Initialize the TX/Rx descriptors */
 646 static void
 647 sln_init_tx(struct sln_softc *sc)
 648 {
 649         int i;
 650
 651         sc->sln_bufdata.cur_tx = 0;
 652         sc->sln_bufdata.dirty_tx = 0;
 653
 654         for (i = 0; i < SL_TXD_CNT; i++) {
 655                 sc->sln_bufdata.sln_tx_buf[i] = NULL;
 656                 SLN_WRITE_4(sc, SL_TSAD0 + (i * 4), 0);
 657         }
 658 }
 659
 660 /* Software & Hardware Initialize */
 661 static void
 662 sln_init(void *x)
 663 {
 664         struct sln_softc *sc = x;
 665         struct ifnet *ifp = &sc->arpcom.ac_if;
 666
 667         PDEBUG("sln_init\n");
 668
 669         ASSERT_SERIALIZED(ifp->if_serializer);
 670
 671         sln_stop(sc);
 672
 673         /* soft reset the chip */
 674         sln_reset(sc);
 675
 676         /* disable interrupt */
 677         SLN_WRITE_4(sc, SL_INT_MASK, 0);
 678
 679         /* SLN_WRITE_4(sc, SL_MII_CMD0, SL_MII0_DIVEDER); */
 680
 681         /* clear multicast address */
 682         SLN_WRITE_4(sc, SL_MULTI_GROUP0, 0);
 683         SLN_WRITE_4(sc, SL_MULTI_GROUP1, 0);
 684
 685         /* Init the RX buffer start address register. */
 686         SLN_WRITE_4(sc, SL_RBSA, vtophys(sc->sln_bufdata.sln_rx_buf));
 687         sc->sln_bufdata.dirty_rx = vtophys(sc->sln_bufdata.sln_rx_buf);
 688
 689         /* Init TX descriptors. */
 690         sln_init_tx(sc);
 691
 692         /* configure RX buffer size */
 693         if (sc->tx_early_ctrl && sc->rx_early_ctrl)
 694                 SLN_WRITE_4(sc, SL_CFG1, SL_EARLY_RX | SL_EARLY_TX | SL_RXBUF_64 | SL_RXFIFO_1024BYTES);
 695         else if (sc->tx_early_ctrl)
 696                 SLN_WRITE_4(sc, SL_CFG1, SL_EARLY_TX | SL_RXBUF_64);
 697         else if (sc->rx_early_ctrl)
 698                 SLN_WRITE_4(sc, SL_CFG1, SL_EARLY_RX | SL_RXBUF_64 | SL_RXFIFO_1024BYTES);
 699         else
 700                 SLN_WRITE_4(sc, SL_CFG1, SL_RXBUF_64);
 701
 702         /* MII media configuration */
 703         sln_media_cfg(sc);
 704
 705         if (sc->connect) {
 706                 /* Enable transmit and receive */
 707                 sc->rxcfg |= SL_RXCFG_EN;
 708                 sc->txcfg |= SL_TXCFG_EN;
 709         } else {
 710                 sc->rxcfg &= ~SL_RXCFG_EN;
 711                 sc->txcfg &= ~SL_TXCFG_EN;
 712         }
 713
 714         SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
 715         SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
 716
 717         /* Enable interrupts */
 718         SLN_WRITE_4(sc, SL_INT_MASK, SL_INRTS);
 719
 720         sc->suspended = 0;
 721
 722         ifp->if_flags |= IFF_RUNNING;
 723         ifq_clr_oactive(&ifp->if_snd);
 724
 725         callout_reset(&sc->sln_state, hz, sln_tick, sc);
 726 }
 727
 728 /* Transmit Packet */
 729 static void
 730 sln_tx(struct ifnet *ifp, struct ifaltq_subque *ifsq)
 731 {
 732         struct sln_softc *sc = ifp->if_softc;
 733         struct mbuf *m_head = NULL;
 734         struct mbuf *m_new = NULL;
 735         int entry;
 736
 737         ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq);
 738         ASSERT_SERIALIZED(ifp->if_serializer);
 739
 740         if (!sc->connect) {
 741                 ifq_purge(&ifp->if_snd);
 742                 return;
 743         }
 744
 745         if ((ifp->if_flags & IFF_RUNNING) == 0 || ifq_is_oactive(&ifp->if_snd))
 746                 return;
 747
 748         while (SL_CUR_TXBUF(sc) == NULL) {      /* SL_CUR_TXBUF(x) = x->sln_bufdata.sln_tx_buf[x->sln_bufdata.cur_tx] */
 749                 entry = sc->sln_bufdata.cur_tx;
 750
 751                 m_head = ifq_dequeue(&ifp->if_snd, NULL);
 752                 if (m_head == NULL)
 753                         break;
 754
 755                 MGETHDR(m_new, MB_DONTWAIT, MT_DATA);
 756                 if (m_new == NULL) {
 757                         if_printf(ifp, "no memory for tx descriptor");
 758                         m_freem(m_head);
 759                         break;
 760                 }
 761                 if ((m_head->m_pkthdr.len > MHLEN) || (60 > MHLEN)) {
 762                         MCLGET(m_new, MB_DONTWAIT);
 763                         if (!(m_new->m_flags & M_EXT)) {
 764                                 m_freem(m_new);
 765                                 m_freem(m_head);
 766                                 if_printf(ifp, "no memory for tx descriptor");
 767                                 break;
 768                         }
 769                 }
 770                 m_copydata(m_head, 0, m_head->m_pkthdr.len, mtod(m_new, caddr_t));
 771                 m_new->m_pkthdr.len = m_new->m_len = m_head->m_pkthdr.len;
 772                 m_freem(m_head);
 773                 m_head = m_new;
 774                 SL_CUR_TXBUF(sc) = m_head;
 775
 776                 /*
 777                  * if there's a BPF listener, bounce a copy of this frame to
 778                  * him
 779                  */
 780                 BPF_MTAP(ifp, SL_CUR_TXBUF(sc));
 781
 782                 /* Transmit the frame */
 783                 SLN_WRITE_4(sc, ((entry * 4) + SL_TSAD0),
 784                     vtophys(mtod(SL_CUR_TXBUF(sc), caddr_t)));
 785
 786                 /* calculate length of the frame */
 787                 if ((SL_CUR_TXBUF(sc)->m_pkthdr.len < 60) && (!sc->txenablepad)) {
 788                         memset(mtod(m_head, char *)+m_head->m_pkthdr.len, 0x20, 60 - m_head->m_pkthdr.len);
 789                         SLN_WRITE_4(sc, (entry * 4) + SL_TSD0, 60);
 790                 } else if (SL_CUR_TXBUF(sc)->m_pkthdr.len < 100)
 791                         SLN_WRITE_4(sc, (entry * 4) + SL_TSD0, SL_CUR_TXBUF(sc)->m_pkthdr.len);
 792                 else if (SL_CUR_TXBUF(sc)->m_pkthdr.len < 300)
 793                         SLN_WRITE_4(sc, (entry * 4) + SL_TSD0, 0x30000 | SL_CUR_TXBUF(sc)->m_pkthdr.len);
 794                 else
 795                         SLN_WRITE_4(sc, (entry * 4) + SL_TSD0, 0x50000 | SL_CUR_TXBUF(sc)->m_pkthdr.len);
 796                 sc->sln_bufdata.cur_tx = (entry + 1) % SL_TXD_CNT;
 797
 798                 PDEBUG("Queue tx packet size %d to tx-descriptor %d.\n", m_head->m_pkthdr.len, entry);
 799         }
 800
 801         /* Tx buffer chain full */
 802         if (SL_CUR_TXBUF(sc) != NULL)
 803                 ifq_set_oactive(&ifp->if_snd);
 804
 805         /* Set a timeout in case the chip goes out to lunch */
 806         ifp->if_timer = 5;
 807 }
 808
 809 /* Receive Data handler */
 810 static void
 811 sln_rx(struct sln_softc *sc)
 812 {
 813         struct mbuf *m;
 814         struct ifnet *ifp = &sc->arpcom.ac_if;
 815         uint32_t rxstat = 0;
 816         uint32_t rx_offset;
 817         caddr_t rx_bufpos = NULL;
 818         uint32_t cur_rx = 0;
 819         uint32_t dirty_rx;
 820         long rx_len;
 821         u_long rx_space;
 822         u_long rx_size = 0;
 823         u_long rx_size_align = 0;
 824         u_long pkt_size = 0;
 825
 826         cur_rx = SLN_READ_4(sc, SL_RBW_PTR);
 827         dirty_rx = sc->sln_bufdata.dirty_rx;
 828
 829         /*
 830          * cur_rx is only 17 bits in the RxBufWPtr register. if cur_rx can be
 831          * used in physical space, we need to change it to 32 bits physical
 832          * address
 833          */
 834         cur_rx |= vtophys(sc->sln_bufdata.sln_rx_buf) & (~(u_long) (SL_RX_BUFLEN - 1));
 835
 836         if (cur_rx < vtophys(sc->sln_bufdata.sln_rx_buf))
 837                 cur_rx += SL_RX_BUFLEN;
 838
 839         if (cur_rx >= dirty_rx)
 840                 rx_len = (long)(cur_rx - dirty_rx);
 841         else
 842                 rx_len = SL_RX_BUFLEN - (long)(dirty_rx - cur_rx);
 843
 844         if ((rx_len > SL_RX_BUFLEN) || (rx_len < 0)) {
 845                 if_printf(ifp, "rx len is fail\n");
 846                 return;
 847         }
 848         if (rx_len == 0)
 849                 return;
 850
 851         rx_offset = (dirty_rx - vtophys(sc->sln_bufdata.sln_rx_buf)) & (u_long) (SL_RX_BUFLEN - 1);
 852
 853         while (rx_len > 0) {
 854                 rx_bufpos = sc->sln_bufdata.sln_rx_buf + rx_offset;
 855                 rxstat = *(uint32_t *) rx_bufpos;
 856                 rx_size = (rxstat >> 20) & 0x0FFF;
 857                 rx_size_align = (rx_size + 3) & ~3;     /* for 4 bytes aligned */
 858                 pkt_size = rx_size - ETHER_CRC_LEN;     /* Omit the four octet
 859                                                          * CRC from the length. */
 860
 861                 PDEBUG("rx len: %ld  rx frame size:%ld  rx state:0x%x\n", rx_len, rx_size, rxstat);
 862
 863                 /* errors receive packets caculatation */
 864                 if (rxstat == 0 || rx_size < 16 || !(rxstat & SL_RXSTAT_RXOK)) {
 865                         ifp->if_ierrors++;
 866
 867                         if (!(rxstat & SL_RXSTAT_RXOK))
 868                                 if_printf(ifp, "receiver ok error\n");
 869
 870                         if (!(rxstat & SL_RXSTAT_CRCOK))
 871                                 if_printf(ifp, "crc error\n");
 872
 873                         if (rxstat & SL_RXSTAT_ALIGNERR)
 874                                 if_printf(ifp, "frame alignment error\n");
 875
 876                         if (rxstat & (SL_RXSTAT_HUGEFRM | SL_RXSTAT_SMALLFRM))
 877                                 if_printf(ifp, "received frame length is error\n");
 878
 879                         break;
 880                 }
 881                 rx_len -= (long)(rx_size_align + 4);    /* 4 bytes for receive
 882                                                          * frame head */
 883
 884                 if (rx_len < 0) {
 885                         kprintf("rx packets len is too small\n");
 886                         break;
 887                 }
 888 #ifdef SLN_PDEBUG
 889                 caddr_t p = NULL;
 890
 891                 if_printf(ifp, "rx frame content\n");
 892                 p = rx_bufpos;
 893                 for (i = 0; i < 30; i++, p++) {
 894                         if (i % 10 == 0)
 895                                 kprintf("\n");
 896                         if_printf(ifp, "%x  ", (u_char)*p);
 897                 }
 898                 if_printf(ifp, "\n");
 899 #endif
 900                 /* No errors; receive the packet. */
 901                 if (rx_bufpos == (sc->sln_bufdata.sln_rx_buf + SL_RX_BUFLEN))
 902                         rx_bufpos = sc->sln_bufdata.sln_rx_buf;
 903
 904                 rx_bufpos = rx_bufpos + 4;      /* 4 bytes for receive frame
 905                                                  * header */
 906                 rx_space = (u_long)((sc->sln_bufdata.sln_rx_buf + SL_RX_BUFLEN) - rx_bufpos);
 907
 908                 if (pkt_size > rx_space) {
 909                         m = m_devget(rx_bufpos - 2, pkt_size + 2, 0, ifp, NULL);        /* 2 for etherer head
 910                                                                                          * align */
 911
 912                         if (m == NULL) {
 913                                 ifp->if_ierrors++;
 914                                 if_printf(ifp,
 915                                     "out of mbufs, tried to copy %ld bytes\n",
 916                                     rx_space);
 917                         } else {
 918                                 m_adj(m, 2);
 919                                 m_copyback(m, rx_space, pkt_size - rx_space, sc->sln_bufdata.sln_rx_buf);
 920                         }
 921                 } else {
 922                         m = m_devget(rx_bufpos - 2, pkt_size + 2, 0, ifp, NULL);
 923
 924                         if (m == NULL) {
 925                                 ifp->if_ierrors++;
 926                                 if_printf(ifp,
 927                                     "out of mbufs, tried to copy %ld bytes\n",
 928                                     pkt_size);
 929                                 if_printf(ifp, "ierrors = %ld\n", ifp->if_ierrors);
 930
 931                         } else {
 932                                 m_adj(m, 2);
 933                         }
 934                 }
 935
 936                 ifp->if_ipackets++;
 937                 PDEBUG("ipackets = %ld\n", ifp->if_ipackets);
 938
 939                 ifp->if_input(ifp, m);
 940
 941                 rx_offset = (rx_offset + rx_size + 4) & (u_long) (SL_RX_BUFLEN - 1);    /* 4 bytes for receive
 942                                                                                          * frame head */
 943         }
 944
 945         sc->sln_bufdata.dirty_rx = cur_rx;
 946
 947         SLN_WRITE_4(sc, SL_RBR_PTR, cur_rx);
 948 }
 949
 950 /* Transmit OK/ERR handler */
 951 static void
 952 sln_tx_intr(struct sln_softc *sc)
 953 {
 954         struct ifnet *ifp = &sc->arpcom.ac_if;
 955         uint32_t txstat;
 956         int entry;
 957
 958         do {
 959                 entry = sc->sln_bufdata.dirty_tx;
 960                 txstat = SLN_READ_4(sc, SL_TSD0 + entry * 4);
 961
 962                 if (!(txstat & (SL_TXSD_TOK | SL_TXSD_TUN | SL_TXSD_TABT)))
 963                         break;  /* It still hasn't been sent */
 964
 965                 if (SL_DIRTY_TXBUF(sc) != NULL) {       /* SL_DIRTY_TXBUF(x) =
 966                                                          * x->sln_bufdata.sln_tx_
 967                                                          * buf[x->sln_bufdata.dir
 968                                                          * ty_tx] */
 969                         m_freem(SL_DIRTY_TXBUF(sc));
 970                         SL_DIRTY_TXBUF(sc) = NULL;
 971                 }
 972                 if (txstat & SL_TXSD_TOK) {
 973                         ifp->if_opackets++;
 974                         ifp->if_obytes += txstat & SL_TXSD_LENMASK;
 975                         PDEBUG("opackets = %ld\n", ifp->if_opackets);
 976                         ifp->if_collisions += (txstat & SL_TXSD_NCC) >> 22;
 977                 } else {
 978                         ifp->if_oerrors++;
 979                         if ((txstat & (SL_TXSD_TABT | SL_TXSD_OWC))) {
 980                                 sc->txcfg = TX_CFG_DEFAULT;
 981
 982                                 if (sc->txenablepad)
 983                                         sc->txcfg |= 0x20000000;
 984
 985                                 SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
 986                         }
 987                 }
 988                 PDEBUG("tx done descriprtor %x\n", entry);
 989                 sc->sln_bufdata.dirty_tx = (entry + 1) % SL_TXD_CNT;
 990
 991                 ifq_clr_oactive(&ifp->if_snd);
 992         } while (sc->sln_bufdata.dirty_tx != sc->sln_bufdata.cur_tx);
 993
 994         if (sc->sln_bufdata.dirty_tx == sc->sln_bufdata.cur_tx)
 995                 ifp->if_timer = 0;
 996         else
 997                 ifp->if_timer = 5;
 998 }
 999
1000 static void
1001 sln_media_intr(struct sln_softc *sc)
1002 {
1003         u_long phys[2];
1004         struct ifnet *ifp = &sc->arpcom.ac_if;
1005
1006         phys[0] = SL_MII_STAT;
1007         sln_mii_cmd(sc, SL_MII0_READ, phys);
1008
1009         PDEBUG("mii_stat:0x%lx\n", phys[1]);
1010
1011         if (0 == (phys[1] & SL_MIISTAT_LINK)) {
1012                 kprintf("media is unconnect,linked down,or uncompatible\n");
1013                 sc->connect = 0;
1014                 sln_mii_cmd(sc, SL_MII0_SCAN, phys);
1015                 /* disable tx/rx */
1016                 sc->txcfg &= ~SL_TXCFG_EN;
1017                 sc->rxcfg &= ~SL_RXCFG_EN;
1018                 SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
1019                 SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
1020
1021                 return;
1022         }
1023         /* Link is good. Report modes and set duplex mode. */
1024         PDEBUG("media is connecting---> ");
1025         sc->connect = 1;
1026
1027         phys[0] = SL_MII_STAT_OUTPUT;
1028         sln_mii_cmd(sc, SL_MII0_READ, phys);
1029         sc->media_duplex = ((phys[1] & 0x0004) == 0) ? IFM_HDX : IFM_FDX;
1030         sc->media_speed = ((phys[1] & 0x0002) == 0) ? IFM_10_T : IFM_100_TX;
1031
1032         if_printf(ifp, "media option:%dM %s-duplex\n",
1033             sc->media_speed == 0x6 ? 100 : 10,
1034             sc->media_duplex == 0x100000 ? "full" : "half");
1035
1036         sln_mii_cmd(sc, SL_MII0_SCAN, phys);
1037
1038         sln_mac_cfg(sc);
1039
1040         /* Enable tx/rx */
1041         sc->rxcfg |= SL_RXCFG_EN;
1042         sc->txcfg |= SL_TXCFG_EN;
1043         SLN_WRITE_4(sc, SL_TX_CONFIG, sc->txcfg);
1044         SLN_WRITE_4(sc, SL_RX_CONFIG, sc->rxcfg);
1045 }
1046
1047 /* Interrupt Handler */
1048 static void
1049 sln_interrupt(void *arg)
1050 {
1051         struct sln_softc *sc = arg;
1052         struct ifnet *ifp = &sc->arpcom.ac_if;
1053         uint32_t int_status;
1054
1055         ASSERT_SERIALIZED(ifp->if_serializer);
1056
1057         if (sc->suspended || (ifp->if_flags & IFF_RUNNING) == 0)
1058                 return;
1059
1060         /* Disable interrupts. */
1061         SLN_WRITE_4(sc, SL_INT_MASK, 0);
1062
1063         int_status = SLN_READ_4(sc, SL_INT_STATUS);
1064
1065         if ((int_status == 0xffffffff) || (int_status & SL_INRTS) == 0)
1066                 goto back;
1067
1068         int_status = int_status & SL_INRTS;
1069         PDEBUG("int_status = 0x%x\n", int_status);
1070
1071         while (0 != int_status) {
1072                 if (int_status & SL_INT_ROK)
1073                         sln_rx(sc);
1074
1075                 if (int_status & SL_INT_TOK)
1076                         sln_tx_intr(sc);
1077
1078                 if (int_status & SL_INT_RBO) {
1079                         ifp->if_ierrors++;
1080                         PDEBUG("rx buffer is overflow\n");
1081                 }
1082
1083                 if (int_status & (SL_INT_LINKFAIL | SL_INT_LINKOK))
1084                         sln_media_intr(sc);
1085
1086                 int_status = SLN_READ_4(sc, SL_INT_STATUS);
1087         }
1088
1089         /* Data in Tx buffer waiting for transimission */
1090         if (!ifq_is_empty(&ifp->if_snd))
1091                 if_devstart(ifp);
1092 back:
1093         /* Re-enable interrupts. */
1094         SLN_WRITE_4(sc, SL_INT_MASK, SL_INRTS);
1095 }
1096
1097 static void
1098 sln_tick(void *x)
1099 {
1100         struct sln_softc *sc = x;
1101
1102         callout_reset(&sc->sln_state, hz, sln_tick, sc);
1103 }
1104
1105 static int
1106 sln_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
1107 {
1108         struct sln_softc *sc = ifp->if_softc;
1109         struct ifreq *ifr = (struct ifreq *)data;
1110         int error = 0;
1111
1112         ASSERT_SERIALIZED(ifp->if_serializer);
1113
1114         switch (cmd) {
1115         case SIOCSIFFLAGS:
1116                 if (ifp->if_flags & IFF_UP) {
1117                         if ((ifp->if_flags & IFF_RUNNING) == 0)
1118                                 sln_init(sc);
1119                 } else {
1120                         if (ifp->if_flags & IFF_RUNNING)
1121                                 sln_stop(sc);
1122                 }
1123                 break;
1124         case SIOCADDMULTI:
1125         case SIOCDELMULTI:
1126                 sln_set_multi(sc);
1127                 break;
1128         case SIOCGIFMEDIA:
1129         case SIOCSIFMEDIA:
1130                 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, cmd);
1131                 break;
1132         default:
1133                 error = ether_ioctl(ifp, cmd, data);
1134                 break;
1135         }
1136         return error;
1137 }
1138
1139 static void
1140 sln_watchdog(struct ifnet *ifp)
1141 {
1142         struct sln_softc *sc = ifp->if_softc;
1143
1144         ASSERT_SERIALIZED(ifp->if_serializer);
1145
1146         if_printf(ifp, "watchdog timeout!\n");
1147         ifp->if_oerrors++;
1148
1149         sln_tx_intr(sc);
1150         sln_rx(sc);
1151         sln_init(sc);
1152
1153         if (!ifq_is_empty(&ifp->if_snd))
1154                 if_devstart(ifp);
1155 }
1156
1157 /* Stop all chip I/O */
1158 static int
1159 sln_shutdown(device_t dev)
1160 {
1161         struct sln_softc *sc = device_get_softc(dev);
1162         struct ifnet *ifp = &sc->arpcom.ac_if;
1163
1164         lwkt_serialize_enter(ifp->if_serializer);
1165         sln_stop(sc);
1166         lwkt_serialize_exit(ifp->if_serializer);
1167
1168         return 0;
1169 }
1170
1171 /* device suspend routine */
1172 static int
1173 sln_suspend(device_t dev)
1174 {
1175         struct sln_softc *sc = device_get_softc(dev);
1176         struct ifnet *ifp = &sc->arpcom.ac_if;
1177
1178         lwkt_serialize_enter(ifp->if_serializer);
1179         sln_stop(sc);
1180         sc->suspended = 1;
1181         lwkt_serialize_exit(ifp->if_serializer);
1182
1183         return 0;
1184 }
1185
1186 /* device resume routine */
1187 static int
1188 sln_resume(device_t dev)
1189 {
1190         struct sln_softc *sc = device_get_softc(dev);
1191         struct ifnet *ifp = &sc->arpcom.ac_if;
1192
1193         lwkt_serialize_enter(ifp->if_serializer);
1194         if (ifp->if_flags & IFF_UP)
1195                 sln_init(sc);
1196         sc->suspended = 0;
1197         lwkt_serialize_exit(ifp->if_serializer);
1198
1199         return 0;
1200 }