sys/dev/pdq/pdq_ifsubr.c

   1 /*      $NetBSD: pdq_ifsubr.c,v 1.38 2001/12/21 23:21:47 matt Exp $     */
   2
   3 /*-
   4  * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
   5  * All rights reserved.
   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. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $NetBSD: pdq_ifsubr.c,v 1.12 1997/06/05 01:56:35 thomas Exp$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  * DEC PDQ FDDI Controller; code for BSD derived operating systems
  34  *
  35  *      This module provide bus independent BSD specific O/S functions.
  36  *      (ie. it provides an ifnet interface to the rest of the system)
  37  */
  38
  39
  40 #define PDQ_OSSUPPORT
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/lock.h>
  46 #include <sys/mutex.h>
  47 #include <sys/malloc.h>
  48 #include <sys/socket.h>
  49 #include <sys/sockio.h>
  50
  51 #include <sys/module.h>
  52 #include <sys/bus.h>
  53
  54 #include <machine/bus.h>
  55 #include <machine/resource.h>
  56 #include <sys/rman.h>
  57
  58 #include <net/if.h>
  59 #include <net/if_var.h>
  60 #include <net/if_arp.h>
  61 #include <net/if_dl.h>
  62 #include <net/if_media.h>
  63 #include <net/if_types.h>
  64 #include <net/fddi.h>
  65
  66 #include <net/bpf.h>
  67
  68 #include <dev/pdq/pdq_freebsd.h>
  69 #include <dev/pdq/pdqreg.h>
  70
  71 devclass_t pdq_devclass;
  72
  73 static void     pdq_watchdog(void *);
  74
  75 static void
  76 pdq_ifstop(pdq_softc_t *sc)
  77 {
  78
  79     PDQ_IFNET(sc)->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
  80     sc->sc_pdq->pdq_flags &= ~PDQ_RUNNING;
  81     pdq_stop(sc->sc_pdq);
  82     callout_stop(&sc->watchdog);
  83 }
  84
  85 static void
  86 pdq_ifinit_locked(pdq_softc_t *sc)
  87 {
  88
  89     PDQ_LOCK_ASSERT(sc);
  90     if (PDQ_IFNET(sc)->if_flags & IFF_UP) {
  91         PDQ_IFNET(sc)->if_drv_flags |= IFF_DRV_RUNNING;
  92         if (PDQ_IFNET(sc)->if_flags & IFF_PROMISC) {
  93             sc->sc_pdq->pdq_flags |= PDQ_PROMISC;
  94         } else {
  95             sc->sc_pdq->pdq_flags &= ~PDQ_PROMISC;
  96         }
  97         if (PDQ_IFNET(sc)->if_flags & IFF_LINK1) {
  98             sc->sc_pdq->pdq_flags |= PDQ_PASS_SMT;
  99         } else {
 100             sc->sc_pdq->pdq_flags &= ~PDQ_PASS_SMT;
 101         }
 102         sc->sc_pdq->pdq_flags |= PDQ_RUNNING;
 103         pdq_run(sc->sc_pdq);
 104         callout_reset(&sc->watchdog, hz, pdq_watchdog, sc);
 105     } else
 106         pdq_ifstop(sc);
 107 }
 108
 109 static void
 110 pdq_ifinit(void *arg)
 111 {
 112     pdq_softc_t *sc;
 113
 114     sc = arg;
 115     PDQ_LOCK(sc);
 116     pdq_ifinit_locked(sc);
 117     PDQ_UNLOCK(sc);
 118 }
 119 \f
 120 static void
 121 pdq_watchdog(void *arg)
 122 {
 123     pdq_softc_t *sc;
 124     struct ifnet *ifp;
 125
 126     sc = arg;
 127     PDQ_LOCK_ASSERT(sc);
 128     callout_reset(&sc->watchdog, hz, pdq_watchdog, sc);
 129     if (sc->timer == 0 || --sc->timer > 0)
 130         return;
 131
 132     /*
 133      * No progress was made on the transmit queue for PDQ_OS_TX_TRANSMIT
 134      * seconds.  Remove all queued packets.
 135      */
 136     ifp = PDQ_IFNET(sc);
 137     ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 138     for (;;) {
 139         struct mbuf *m;
 140         IFQ_DEQUEUE(&ifp->if_snd, m);
 141         if (m == NULL)
 142             return;
 143         PDQ_OS_DATABUF_FREE(PDQ_OS_IFP_TO_SOFTC(ifp)->sc_pdq, m);
 144     }
 145 }
 146
 147 static void
 148 pdq_ifstart_locked(struct ifnet *ifp)
 149 {
 150     pdq_softc_t * const sc = PDQ_OS_IFP_TO_SOFTC(ifp);
 151     struct mbuf *m;
 152     int tx = 0;
 153
 154     PDQ_LOCK_ASSERT(sc);
 155     if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
 156         return;
 157
 158     if (sc->timer == 0)
 159         sc->timer = PDQ_OS_TX_TIMEOUT;
 160
 161     if ((sc->sc_pdq->pdq_flags & PDQ_TXOK) == 0) {
 162         PDQ_IFNET(sc)->if_drv_flags |= IFF_DRV_OACTIVE;
 163         return;
 164     }
 165     sc->sc_flags |= PDQIF_DOWNCALL;
 166     for (;; tx = 1) {
 167         IF_DEQUEUE(&ifp->if_snd, m);
 168         if (m == NULL)
 169             break;
 170 #if defined(PDQ_BUS_DMA) && !defined(PDQ_BUS_DMA_NOTX)
 171         if ((m->m_flags & M_HASTXDMAMAP) == 0) {
 172             bus_dmamap_t map;
 173             if (PDQ_OS_HDR_OFFSET != PDQ_RX_FC_OFFSET) {
 174                 m->m_data[0] = PDQ_FDDI_PH0;
 175                 m->m_data[1] = PDQ_FDDI_PH1;
 176                 m->m_data[2] = PDQ_FDDI_PH2;
 177             }
 178             if (!bus_dmamap_create(sc->sc_dmatag, m->m_pkthdr.len, 255,
 179                                    m->m_pkthdr.len, 0, BUS_DMA_NOWAIT, &map)) {
 180                 if (!bus_dmamap_load_mbuf(sc->sc_dmatag, map, m,
 181                                           BUS_DMA_WRITE|BUS_DMA_NOWAIT)) {
 182                     bus_dmamap_sync(sc->sc_dmatag, map, 0, m->m_pkthdr.len,
 183                                     BUS_DMASYNC_PREWRITE);
 184                     M_SETCTX(m, map);
 185                     m->m_flags |= M_HASTXDMAMAP;
 186                 }
 187             }
 188             if ((m->m_flags & M_HASTXDMAMAP) == 0)
 189                 break;
 190         }
 191 #else
 192         if (PDQ_OS_HDR_OFFSET != PDQ_RX_FC_OFFSET) {
 193             m->m_data[0] = PDQ_FDDI_PH0;
 194             m->m_data[1] = PDQ_FDDI_PH1;
 195             m->m_data[2] = PDQ_FDDI_PH2;
 196         }
 197 #endif
 198
 199         if (pdq_queue_transmit_data(sc->sc_pdq, m) == PDQ_FALSE)
 200             break;
 201     }
 202     if (m != NULL) {
 203         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 204         IF_PREPEND(&ifp->if_snd, m);
 205     }
 206     if (tx)
 207         PDQ_DO_TYPE2_PRODUCER(sc->sc_pdq);
 208     sc->sc_flags &= ~PDQIF_DOWNCALL;
 209 }
 210
 211 static void
 212 pdq_ifstart(struct ifnet *ifp)
 213 {
 214     pdq_softc_t * const sc = PDQ_OS_IFP_TO_SOFTC(ifp);
 215
 216     PDQ_LOCK(sc);
 217     pdq_ifstart_locked(ifp);
 218     PDQ_UNLOCK(sc);
 219 }
 220 \f
 221 void
 222 pdq_os_receive_pdu(
 223     pdq_t *pdq,
 224     struct mbuf *m,
 225     size_t pktlen,
 226     int drop)
 227 {
 228     pdq_softc_t *sc = pdq->pdq_os_ctx;
 229     struct ifnet *ifp = PDQ_IFNET(sc);
 230     struct fddi_header *fh;
 231
 232     if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1);
 233 #if defined(PDQ_BUS_DMA)
 234     {
 235         /*
 236          * Even though the first mbuf start at the first fddi header octet,
 237          * the dmamap starts PDQ_OS_HDR_OFFSET octets earlier.  Any additional
 238          * mbufs will start normally.
 239          */
 240         int offset = PDQ_OS_HDR_OFFSET;
 241         struct mbuf *m0;
 242         for (m0 = m; m0 != NULL; m0 = m0->m_next, offset = 0) {
 243             pdq_os_databuf_sync(sc, m0, offset, m0->m_len, BUS_DMASYNC_POSTREAD);
 244             bus_dmamap_unload(sc->sc_dmatag, M_GETCTX(m0, bus_dmamap_t));
 245             bus_dmamap_destroy(sc->sc_dmatag, M_GETCTX(m0, bus_dmamap_t));
 246             m0->m_flags &= ~M_HASRXDMAMAP;
 247             M_SETCTX(m0, NULL);
 248         }
 249     }
 250 #endif
 251     m->m_pkthdr.len = pktlen;
 252     fh = mtod(m, struct fddi_header *);
 253     if (drop || (fh->fddi_fc & (FDDIFC_L|FDDIFC_F)) != FDDIFC_LLC_ASYNC) {
 254         if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1);
 255         if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
 256         PDQ_OS_DATABUF_FREE(pdq, m);
 257         return;
 258     }
 259
 260     m->m_pkthdr.rcvif = ifp;
 261     PDQ_UNLOCK(sc);
 262     (*ifp->if_input)(ifp, m);
 263     PDQ_LOCK(sc);
 264 }
 265
 266 void
 267 pdq_os_restart_transmitter(
 268     pdq_t *pdq)
 269 {
 270     pdq_softc_t *sc = pdq->pdq_os_ctx;
 271     PDQ_IFNET(sc)->if_drv_flags &= ~IFF_DRV_OACTIVE;
 272     if (IFQ_IS_EMPTY(&PDQ_IFNET(sc)->if_snd) == 0) {
 273         sc->timer = PDQ_OS_TX_TIMEOUT;
 274         if ((sc->sc_flags & PDQIF_DOWNCALL) == 0)
 275             pdq_ifstart_locked(PDQ_IFNET(sc));
 276     } else {
 277         sc->timer = 0;
 278     }
 279 }
 280
 281 void
 282 pdq_os_transmit_done(
 283     pdq_t *pdq,
 284     struct mbuf *m)
 285 {
 286     pdq_softc_t *sc = pdq->pdq_os_ctx;
 287 #if defined(NBPFILTER) && NBPFILTER > 0
 288     if (PQD_IFNET(sc)->if_bpf != NULL)
 289         PDQ_BPF_MTAP(sc, m);
 290 #endif
 291     PDQ_OS_DATABUF_FREE(pdq, m);
 292     if_inc_counter(PDQ_IFNET(sc), IFCOUNTER_OPACKETS, 1);
 293 }
 294 \f
 295 void
 296 pdq_os_addr_fill(
 297     pdq_t *pdq,
 298     pdq_lanaddr_t *addr,
 299     size_t num_addrs)
 300 {
 301     pdq_softc_t *sc = pdq->pdq_os_ctx;
 302     struct ifnet *ifp;
 303     struct ifmultiaddr *ifma;
 304
 305     ifp = sc->ifp;
 306
 307     /*
 308      * ADDR_FILTER_SET is always issued before FILTER_SET so
 309      * we can play with PDQ_ALLMULTI and not worry about
 310      * queueing a FILTER_SET ourselves.
 311      */
 312
 313     pdq->pdq_flags &= ~PDQ_ALLMULTI;
 314 #if defined(IFF_ALLMULTI)
 315     PDQ_IFNET(sc)->if_flags &= ~IFF_ALLMULTI;
 316 #endif
 317
 318     if_maddr_rlock(PDQ_IFNET(sc));
 319     for (ifma = TAILQ_FIRST(&PDQ_IFNET(sc)->if_multiaddrs); ifma && num_addrs > 0;
 320          ifma = TAILQ_NEXT(ifma, ifma_link)) {
 321             char *mcaddr;
 322             if (ifma->ifma_addr->sa_family != AF_LINK)
 323                     continue;
 324             mcaddr = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
 325             ((u_short *) addr->lanaddr_bytes)[0] = ((u_short *) mcaddr)[0];
 326             ((u_short *) addr->lanaddr_bytes)[1] = ((u_short *) mcaddr)[1];
 327             ((u_short *) addr->lanaddr_bytes)[2] = ((u_short *) mcaddr)[2];
 328             addr++;
 329             num_addrs--;
 330     }
 331     if_maddr_runlock(PDQ_IFNET(sc));
 332     /*
 333      * If not all the address fit into the CAM, turn on all-multicast mode.
 334      */
 335     if (ifma != NULL) {
 336         pdq->pdq_flags |= PDQ_ALLMULTI;
 337 #if defined(IFF_ALLMULTI)
 338         PDQ_IFNET(sc)->if_flags |= IFF_ALLMULTI;
 339 #endif
 340     }
 341 }
 342 \f
 343 #if defined(IFM_FDDI)
 344 static int
 345 pdq_ifmedia_change(
 346     struct ifnet *ifp)
 347 {
 348     pdq_softc_t * const sc = PDQ_OS_IFP_TO_SOFTC(ifp);
 349
 350     PDQ_LOCK(sc);
 351     if (sc->sc_ifmedia.ifm_media & IFM_FDX) {
 352         if ((sc->sc_pdq->pdq_flags & PDQ_WANT_FDX) == 0) {
 353             sc->sc_pdq->pdq_flags |= PDQ_WANT_FDX;
 354             if (sc->sc_pdq->pdq_flags & PDQ_RUNNING)
 355                 pdq_run(sc->sc_pdq);
 356         }
 357     } else if (sc->sc_pdq->pdq_flags & PDQ_WANT_FDX) {
 358         sc->sc_pdq->pdq_flags &= ~PDQ_WANT_FDX;
 359         if (sc->sc_pdq->pdq_flags & PDQ_RUNNING)
 360             pdq_run(sc->sc_pdq);
 361     }
 362     PDQ_UNLOCK(sc);
 363
 364     return 0;
 365 }
 366
 367 static void
 368 pdq_ifmedia_status(
 369     struct ifnet *ifp,
 370     struct ifmediareq *ifmr)
 371 {
 372     pdq_softc_t * const sc = PDQ_OS_IFP_TO_SOFTC(ifp);
 373
 374     PDQ_LOCK(sc);
 375     ifmr->ifm_status = IFM_AVALID;
 376     if (sc->sc_pdq->pdq_flags & PDQ_IS_ONRING)
 377         ifmr->ifm_status |= IFM_ACTIVE;
 378
 379     ifmr->ifm_active = (ifmr->ifm_current & ~IFM_FDX);
 380     if (sc->sc_pdq->pdq_flags & PDQ_IS_FDX)
 381         ifmr->ifm_active |= IFM_FDX;
 382     PDQ_UNLOCK(sc);
 383 }
 384
 385 void
 386 pdq_os_update_status(
 387     pdq_t *pdq,
 388     const void *arg)
 389 {
 390     pdq_softc_t * const sc = pdq->pdq_os_ctx;
 391     const pdq_response_status_chars_get_t *rsp = arg;
 392     int media = 0;
 393
 394     switch (rsp->status_chars_get.pmd_type[0]) {
 395         case PDQ_PMD_TYPE_ANSI_MUTLI_MODE:         media = IFM_FDDI_MMF; break;
 396         case PDQ_PMD_TYPE_ANSI_SINGLE_MODE_TYPE_1: media = IFM_FDDI_SMF; break;
 397         case PDQ_PMD_TYPE_ANSI_SIGNLE_MODE_TYPE_2: media = IFM_FDDI_SMF; break;
 398         case PDQ_PMD_TYPE_UNSHIELDED_TWISTED_PAIR: media = IFM_FDDI_UTP; break;
 399         default: media |= IFM_MANUAL;
 400     }
 401
 402     if (rsp->status_chars_get.station_type == PDQ_STATION_TYPE_DAS)
 403         media |= IFM_FDDI_DA;
 404
 405     sc->sc_ifmedia.ifm_media = media | IFM_FDDI;
 406 }
 407 #endif /* defined(IFM_FDDI) */
 408 \f
 409 static int
 410 pdq_ifioctl(
 411     struct ifnet *ifp,
 412     u_long cmd,
 413     caddr_t data)
 414 {
 415     pdq_softc_t *sc = PDQ_OS_IFP_TO_SOFTC(ifp);
 416     int error = 0;
 417
 418     switch (cmd) {
 419         case SIOCSIFFLAGS: {
 420             pdq_ifinit(sc);
 421             break;
 422         }
 423
 424         case SIOCADDMULTI:
 425         case SIOCDELMULTI: {
 426             PDQ_LOCK(sc);
 427             if (PDQ_IFNET(sc)->if_drv_flags & IFF_DRV_RUNNING) {
 428                     pdq_run(sc->sc_pdq);
 429                 error = 0;
 430             }
 431             PDQ_UNLOCK(sc);
 432             break;
 433         }
 434
 435 #if defined(IFM_FDDI) && defined(SIOCSIFMEDIA)
 436         case SIOCSIFMEDIA:
 437         case SIOCGIFMEDIA: {
 438             struct ifreq *ifr = (struct ifreq *)data;
 439             error = ifmedia_ioctl(ifp, ifr, &sc->sc_ifmedia, cmd);
 440             break;
 441         }
 442 #endif
 443
 444         default: {
 445             error = fddi_ioctl(ifp, cmd, data);
 446             break;
 447         }
 448     }
 449
 450     return error;
 451 }
 452 \f
 453 #ifndef IFF_NOTRAILERS
 454 #define IFF_NOTRAILERS  0
 455 #endif
 456
 457 int
 458 pdq_ifattach(pdq_softc_t *sc, const pdq_uint8_t *llc, pdq_type_t type)
 459 {
 460     struct ifnet *ifp;
 461
 462     KASSERT(type == PDQ_DEFPA, ("We only support PCI attachment."));
 463
 464     ifp = PDQ_IFNET(sc) = if_alloc(IFT_FDDI);
 465     if (ifp == NULL) {
 466         device_printf(sc->dev, "can not if_alloc()\n");
 467         return (ENOSPC);
 468     }
 469
 470     mtx_init(&sc->mtx, device_get_nameunit(sc->dev), MTX_NETWORK_LOCK,
 471         MTX_DEF);
 472     callout_init_mtx(&sc->watchdog, &sc->mtx, 0);
 473
 474     if_initname(ifp, device_get_name(sc->dev), device_get_unit(sc->dev));
 475     ifp->if_softc = sc;
 476     ifp->if_init = pdq_ifinit;
 477     ifp->if_snd.ifq_maxlen = ifqmaxlen;
 478     ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_NOTRAILERS|IFF_MULTICAST;
 479
 480     ifp->if_ioctl = pdq_ifioctl;
 481     ifp->if_start = pdq_ifstart;
 482
 483 #if defined(IFM_FDDI)
 484     {
 485         const int media = sc->sc_ifmedia.ifm_media;
 486         ifmedia_init(&sc->sc_ifmedia, IFM_FDX,
 487                      pdq_ifmedia_change, pdq_ifmedia_status);
 488         ifmedia_add(&sc->sc_ifmedia, media, 0, 0);
 489         ifmedia_set(&sc->sc_ifmedia, media);
 490     }
 491 #endif
 492
 493     sc->sc_pdq = pdq_initialize(sc->mem_bst, sc->mem_bsh, ifp->if_xname, -1,
 494         sc, type);
 495     if (sc->sc_pdq == NULL) {
 496         device_printf(sc->dev, "Initialization failed.\n");
 497         return (ENXIO);
 498     }
 499
 500     fddi_ifattach(ifp, llc, FDDI_BPF_SUPPORTED);
 501     return (0);
 502 }
 503
 504 void
 505 pdq_ifdetach (pdq_softc_t *sc)
 506 {
 507     struct ifnet *ifp;
 508
 509     ifp = sc->ifp;
 510
 511     fddi_ifdetach(ifp, FDDI_BPF_SUPPORTED);
 512     PDQ_LOCK(sc);
 513     pdq_ifstop(sc);
 514     PDQ_UNLOCK(sc);
 515     callout_drain(&sc->watchdog);
 516     pdq_free(sc->dev);
 517
 518     return;
 519 }
 520
 521 void
 522 pdq_free (device_t dev)
 523 {
 524         pdq_softc_t *sc;
 525
 526         sc = device_get_softc(dev);
 527
 528         if (sc->io)
 529                 bus_release_resource(dev, sc->io_type, sc->io_rid, sc->io);
 530         if (sc->mem)
 531                 bus_release_resource(dev, sc->mem_type, sc->mem_rid, sc->mem);
 532         if (sc->irq_ih)
 533                 bus_teardown_intr(dev, sc->irq, sc->irq_ih);
 534         if (sc->irq)
 535                 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
 536         if (sc->ifp)
 537                 if_free(sc->ifp);
 538
 539         /*
 540          * Destroy the mutex.
 541          */
 542         if (mtx_initialized(&sc->mtx) != 0) {
 543                 mtx_destroy(&sc->mtx);
 544         }
 545
 546         return;
 547 }
 548
 549 #if defined(PDQ_BUS_DMA)
 550 int
 551 pdq_os_memalloc_contig(
 552     pdq_t *pdq)
 553 {
 554     pdq_softc_t * const sc = pdq->pdq_os_ctx;
 555     bus_dma_segment_t db_segs[1], ui_segs[1], cb_segs[1];
 556     int db_nsegs = 0, ui_nsegs = 0;
 557     int steps = 0;
 558     int not_ok;
 559
 560     not_ok = bus_dmamem_alloc(sc->sc_dmatag,
 561                          sizeof(*pdq->pdq_dbp), sizeof(*pdq->pdq_dbp),
 562                          sizeof(*pdq->pdq_dbp), db_segs, 1, &db_nsegs,
 563                          BUS_DMA_NOWAIT);
 564     if (!not_ok) {
 565         steps = 1;
 566         not_ok = bus_dmamem_map(sc->sc_dmatag, db_segs, db_nsegs,
 567                                 sizeof(*pdq->pdq_dbp), (caddr_t *) &pdq->pdq_dbp,
 568                                 BUS_DMA_NOWAIT);
 569     }
 570     if (!not_ok) {
 571         steps = 2;
 572         not_ok = bus_dmamap_create(sc->sc_dmatag, db_segs[0].ds_len, 1,
 573                                    0x2000, 0, BUS_DMA_NOWAIT, &sc->sc_dbmap);
 574     }
 575     if (!not_ok) {
 576         steps = 3;
 577         not_ok = bus_dmamap_load(sc->sc_dmatag, sc->sc_dbmap,
 578                                  pdq->pdq_dbp, sizeof(*pdq->pdq_dbp),
 579                                  NULL, BUS_DMA_NOWAIT);
 580     }
 581     if (!not_ok) {
 582         steps = 4;
 583         pdq->pdq_pa_descriptor_block = sc->sc_dbmap->dm_segs[0].ds_addr;
 584         not_ok = bus_dmamem_alloc(sc->sc_dmatag,
 585                          PDQ_OS_PAGESIZE, PDQ_OS_PAGESIZE, PDQ_OS_PAGESIZE,
 586                          ui_segs, 1, &ui_nsegs, BUS_DMA_NOWAIT);
 587     }
 588     if (!not_ok) {
 589         steps = 5;
 590         not_ok = bus_dmamem_map(sc->sc_dmatag, ui_segs, ui_nsegs,
 591                             PDQ_OS_PAGESIZE,
 592                             (caddr_t *) &pdq->pdq_unsolicited_info.ui_events,
 593                             BUS_DMA_NOWAIT);
 594     }
 595     if (!not_ok) {
 596         steps = 6;
 597         not_ok = bus_dmamap_create(sc->sc_dmatag, ui_segs[0].ds_len, 1,
 598                                    PDQ_OS_PAGESIZE, 0, BUS_DMA_NOWAIT,
 599                                    &sc->sc_uimap);
 600     }
 601     if (!not_ok) {
 602         steps = 7;
 603         not_ok = bus_dmamap_load(sc->sc_dmatag, sc->sc_uimap,
 604                                  pdq->pdq_unsolicited_info.ui_events,
 605                                  PDQ_OS_PAGESIZE, NULL, BUS_DMA_NOWAIT);
 606     }
 607     if (!not_ok) {
 608         steps = 8;
 609         pdq->pdq_unsolicited_info.ui_pa_bufstart = sc->sc_uimap->dm_segs[0].ds_addr;
 610         cb_segs[0] = db_segs[0];
 611         cb_segs[0].ds_addr += offsetof(pdq_descriptor_block_t, pdqdb_consumer);
 612         cb_segs[0].ds_len = sizeof(pdq_consumer_block_t);
 613         not_ok = bus_dmamem_map(sc->sc_dmatag, cb_segs, 1,
 614                                 sizeof(*pdq->pdq_cbp), (caddr_t *) &pdq->pdq_cbp,
 615                                 BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
 616     }
 617     if (!not_ok) {
 618         steps = 9;
 619         not_ok = bus_dmamap_create(sc->sc_dmatag, cb_segs[0].ds_len, 1,
 620                                    0x2000, 0, BUS_DMA_NOWAIT, &sc->sc_cbmap);
 621     }
 622     if (!not_ok) {
 623         steps = 10;
 624         not_ok = bus_dmamap_load(sc->sc_dmatag, sc->sc_cbmap,
 625                                  (caddr_t) pdq->pdq_cbp, sizeof(*pdq->pdq_cbp),
 626                                  NULL, BUS_DMA_NOWAIT);
 627     }
 628     if (!not_ok) {
 629         pdq->pdq_pa_consumer_block = sc->sc_cbmap->dm_segs[0].ds_addr;
 630         return not_ok;
 631     }
 632
 633     switch (steps) {
 634         case 11: {
 635             bus_dmamap_unload(sc->sc_dmatag, sc->sc_cbmap);
 636             /* FALL THROUGH */
 637         }
 638         case 10: {
 639             bus_dmamap_destroy(sc->sc_dmatag, sc->sc_cbmap);
 640             /* FALL THROUGH */
 641         }
 642         case 9: {
 643             bus_dmamem_unmap(sc->sc_dmatag,
 644                              (caddr_t) pdq->pdq_cbp, sizeof(*pdq->pdq_cbp));
 645             /* FALL THROUGH */
 646         }
 647         case 8: {
 648             bus_dmamap_unload(sc->sc_dmatag, sc->sc_uimap);
 649             /* FALL THROUGH */
 650         }
 651         case 7: {
 652             bus_dmamap_destroy(sc->sc_dmatag, sc->sc_uimap);
 653             /* FALL THROUGH */
 654         }
 655         case 6: {
 656             bus_dmamem_unmap(sc->sc_dmatag,
 657                              (caddr_t) pdq->pdq_unsolicited_info.ui_events,
 658                              PDQ_OS_PAGESIZE);
 659             /* FALL THROUGH */
 660         }
 661         case 5: {
 662             bus_dmamem_free(sc->sc_dmatag, ui_segs, ui_nsegs);
 663             /* FALL THROUGH */
 664         }
 665         case 4: {
 666             bus_dmamap_unload(sc->sc_dmatag, sc->sc_dbmap);
 667             /* FALL THROUGH */
 668         }
 669         case 3: {
 670             bus_dmamap_destroy(sc->sc_dmatag, sc->sc_dbmap);
 671             /* FALL THROUGH */
 672         }
 673         case 2: {
 674             bus_dmamem_unmap(sc->sc_dmatag,
 675                              (caddr_t) pdq->pdq_dbp,
 676                              sizeof(*pdq->pdq_dbp));
 677             /* FALL THROUGH */
 678         }
 679         case 1: {
 680             bus_dmamem_free(sc->sc_dmatag, db_segs, db_nsegs);
 681             /* FALL THROUGH */
 682         }
 683     }
 684
 685     return not_ok;
 686 }
 687
 688 extern void
 689 pdq_os_descriptor_block_sync(
 690     pdq_os_ctx_t *sc,
 691     size_t offset,
 692     size_t length,
 693     int ops)
 694 {
 695     bus_dmamap_sync(sc->sc_dmatag, sc->sc_dbmap, offset, length, ops);
 696 }
 697
 698 extern void
 699 pdq_os_consumer_block_sync(
 700     pdq_os_ctx_t *sc,
 701     int ops)
 702 {
 703     bus_dmamap_sync(sc->sc_dmatag, sc->sc_cbmap, 0, sizeof(pdq_consumer_block_t), ops);
 704 }
 705
 706 extern void
 707 pdq_os_unsolicited_event_sync(
 708     pdq_os_ctx_t *sc,
 709     size_t offset,
 710     size_t length,
 711     int ops)
 712 {
 713     bus_dmamap_sync(sc->sc_dmatag, sc->sc_uimap, offset, length, ops);
 714 }
 715
 716 extern void
 717 pdq_os_databuf_sync(
 718     pdq_os_ctx_t *sc,
 719     struct mbuf *m,
 720     size_t offset,
 721     size_t length,
 722     int ops)
 723 {
 724     bus_dmamap_sync(sc->sc_dmatag, M_GETCTX(m, bus_dmamap_t), offset, length, ops);
 725 }
 726
 727 extern void
 728 pdq_os_databuf_free(
 729     pdq_os_ctx_t *sc,
 730     struct mbuf *m)
 731 {
 732     if (m->m_flags & (M_HASRXDMAMAP|M_HASTXDMAMAP)) {
 733         bus_dmamap_t map = M_GETCTX(m, bus_dmamap_t);
 734         bus_dmamap_unload(sc->sc_dmatag, map);
 735         bus_dmamap_destroy(sc->sc_dmatag, map);
 736         m->m_flags &= ~(M_HASRXDMAMAP|M_HASTXDMAMAP);
 737     }
 738     m_freem(m);
 739 }
 740
 741 extern struct mbuf *
 742 pdq_os_databuf_alloc(
 743     pdq_os_ctx_t *sc)
 744 {
 745     struct mbuf *m;
 746     bus_dmamap_t map;
 747
 748     MGETHDR(m, M_NOWAIT, MT_DATA);
 749     if (m == NULL) {
 750         printf("%s: can't alloc small buf\n", sc->sc_dev.dv_xname);
 751         return NULL;
 752     }
 753     if (!(MCLGET(m, M_NOWAIT))) {
 754         printf("%s: can't alloc cluster\n", sc->sc_dev.dv_xname);
 755         m_free(m);
 756         return NULL;
 757     }
 758     m->m_pkthdr.len = m->m_len = PDQ_OS_DATABUF_SIZE;
 759
 760     if (bus_dmamap_create(sc->sc_dmatag, PDQ_OS_DATABUF_SIZE,
 761                            1, PDQ_OS_DATABUF_SIZE, 0, BUS_DMA_NOWAIT, &map)) {
 762         printf("%s: can't create dmamap\n", sc->sc_dev.dv_xname);
 763         m_free(m);
 764         return NULL;
 765     }
 766     if (bus_dmamap_load_mbuf(sc->sc_dmatag, map, m,
 767                              BUS_DMA_READ|BUS_DMA_NOWAIT)) {
 768         printf("%s: can't load dmamap\n", sc->sc_dev.dv_xname);
 769         bus_dmamap_destroy(sc->sc_dmatag, map);
 770         m_free(m);
 771         return NULL;
 772     }
 773     m->m_flags |= M_HASRXDMAMAP;
 774     M_SETCTX(m, map);
 775     return m;
 776 }
 777 #endif