The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/pdqvar.h

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: pdqvar.h,v 1.34 2003/07/08 10:06:31 itojun 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  * Id: pdqvar.h,v 1.21 1997/03/21 21:16:04 thomas Exp
   27  *
   28  */
   29 
   30 /*
   31  * DEC PDQ FDDI Controller; PDQ O/S dependent definitions
   32  *
   33  * Written by Matt Thomas
   34  *
   35  */
   36 
   37 #ifndef _PDQ_OS_H
   38 #define _PDQ_OS_H
   39 
   40 #define PDQ_OS_TX_TIMEOUT               5       /* seconds */
   41 
   42 typedef struct _pdq_t pdq_t;
   43 typedef struct _pdq_csrs_t pdq_csrs_t;
   44 typedef struct _pdq_pci_csrs_t pdq_pci_csrs_t;
   45 typedef struct _pdq_lanaddr_t pdq_lanaddr_t;
   46 typedef unsigned int pdq_uint32_t;
   47 typedef unsigned short pdq_uint16_t;
   48 typedef unsigned char pdq_uint8_t;
   49 typedef enum _pdq_boolean_t pdq_boolean_t;
   50 typedef enum _pdq_type_t pdq_type_t;
   51 typedef enum _pdq_state_t pdq_state_t;
   52 
   53 enum _pdq_type_t {
   54     PDQ_DEFPA,          /* PCI-bus */
   55     PDQ_DEFEA,          /* EISA-bus */
   56     PDQ_DEFTA,          /* TurboChannel */
   57     PDQ_DEFAA,          /* FutureBus+ */
   58     PDQ_DEFQA           /* Q-bus */
   59 };
   60 
   61 #if defined(PDQTEST)
   62 #include <pdq_os_test.h>
   63 #elif defined(__FreeBSD__) || defined(__bsdi__) || defined(__NetBSD__)
   64 
   65 #include <sys/param.h>
   66 #include <sys/systm.h>
   67 #ifndef M_MCAST
   68 #include <sys/mbuf.h>
   69 #endif /* M_CAST */
   70 #include <sys/malloc.h>
   71 
   72 #include <uvm/uvm_extern.h>
   73 
   74 #define PDQ_USE_MBUFS
   75 #if defined(__NetBSD__)
   76 #define PDQ_OS_PREFIX                   "%s: "
   77 #define PDQ_OS_PREFIX_ARGS              pdq->pdq_os_name
   78 #else
   79 #define PDQ_OS_PREFIX                   "%s%d: "
   80 #define PDQ_OS_PREFIX_ARGS              pdq->pdq_os_name, pdq->pdq_unit
   81 #endif
   82 #if (defined(__FreeBSD__) && BSD >= 199506) || defined(__NetBSD__)
   83 #define PDQ_OS_PAGESIZE                 PAGE_SIZE
   84 #else
   85 #define PDQ_OS_PAGESIZE                 NBPG
   86 #endif
   87 #define PDQ_OS_USEC_DELAY(n)            DELAY(n)
   88 #define PDQ_OS_MEMZERO(p, n)            memset((caddr_t)(p), 0, (n))
   89 #if defined(__NetBSD__) && !defined(PDQ_NO_BUS_DMA)
   90 #define PDQ_BUS_DMA
   91 #endif
   92 #if !defined(PDQ_BUS_DMA)
   93 #define PDQ_OS_VA_TO_BUSPA(pdq, p)              vtophys(p)
   94 #endif
   95 #define PDQ_OS_MEMALLOC(n)              malloc(n, M_DEVBUF, M_NOWAIT)
   96 #define PDQ_OS_MEMFREE(p, n)            free((void *) p, M_DEVBUF)
   97 #ifdef __FreeBSD__
   98 #define PDQ_OS_MEMALLOC_CONTIG(n)       vm_page_alloc_contig(n, 0, 0xffffffff, PAGE_SIZE)
   99 #define PDQ_OS_MEMFREE_CONTIG(p, n)     kmem_free(kernel_map, (vaddr_t) p, n)
  100 #else
  101 #if !defined(PDQ_BUS_DMA)
  102 #define PDQ_OS_MEMALLOC_CONTIG(n)       uvm_km_alloc(kernel_map, round_page(n))
  103 #define PDQ_OS_MEMFREE_CONTIG(p, n)     uvm_km_free(kernel_map, (vaddr_t) p, n)
  104 #endif
  105 #endif /* __FreeBSD__ */
  106 
  107 #if defined(__FreeBSD__)
  108 #include <vm/pmap.h>
  109 #include <vm/vm_extern.h>
  110 #include <machine/cpufunc.h>
  111 #include <machine/clock.h>
  112 #define ifnet_ret_t void
  113 typedef int ioctl_cmd_t;
  114 typedef enum { PDQ_BUS_EISA, PDQ_BUS_PCI } pdq_bus_t;
  115 typedef u_int16_t pdq_bus_ioport_t;
  116 typedef volatile pdq_uint32_t *pdq_bus_memaddr_t;
  117 typedef pdq_bus_memaddr_t pdq_bus_memoffset_t;
  118 #if BSD >= 199506       /* __FreeBSD__ */
  119 #define PDQ_BPF_MTAP(sc, m)     bpf_mtap(&(sc)->sc_if, m)
  120 #define PDQ_BPFATTACH(sc, t, s) bpfattach(&(sc)->sc_if, t, s)
  121 #endif
  122 
  123 #define pdq_os_update_status(a, b)      ((void) 0)
  124 
  125 #elif defined(__bsdi__)
  126 #if !defined(PDQ_HWSUPPORT) && (_BSDI_VERSION >= 199701)
  127 #include <net/if_media.h>
  128 #endif
  129 #include <machine/inline.h>
  130 #define ifnet_ret_t int
  131 typedef int ioctl_cmd_t;
  132 typedef enum { PDQ_BUS_EISA, PDQ_BUS_PCI } pdq_bus_t;
  133 typedef u_int16_t pdq_bus_ioport_t;
  134 typedef volatile pdq_uint32_t *pdq_bus_memaddr_t;
  135 typedef pdq_bus_memaddr_t pdq_bus_memoffset_t;
  136 
  137 
  138 #elif defined(__NetBSD__)
  139 #if !defined(PDQ_HWSUPPORT)
  140 #include <net/if_media.h>
  141 #endif
  142 #include <machine/bus.h>
  143 #include <machine/intr.h>
  144 #define PDQ_OS_HDR_OFFSET       (PDQ_RX_FC_OFFSET-3)
  145 #define PDQ_OS_PTR_FMT          "%p"
  146 #define PDQ_OS_CSR_FMT          "0x%lx"
  147 #define ifnet_ret_t void
  148 typedef u_long ioctl_cmd_t;
  149 typedef bus_space_tag_t pdq_bus_t;
  150 typedef bus_space_handle_t pdq_bus_ioport_t;
  151 typedef bus_space_handle_t pdq_bus_memaddr_t;
  152 typedef bus_addr_t pdq_bus_memoffset_t;
  153 #define PDQ_OS_SPL_RAISE()      splnet()
  154 #define PDQ_OS_IOMEM
  155 #define PDQ_OS_IORD_32(t, base, offset)         bus_space_read_4  (t, base, offset)
  156 #define PDQ_OS_IOWR_32(t, base, offset, data)   bus_space_write_4 (t, base, offset, data)
  157 #define PDQ_OS_IORD_8(t, base, offset)          bus_space_read_1  (t, base, offset)
  158 #define PDQ_OS_IOWR_8(t, base, offset, data)    bus_space_write_1 (t, base, offset, data)
  159 #define PDQ_CSR_OFFSET(base, offset)            (0 + (offset)*sizeof(pdq_uint32_t))
  160 
  161 #ifdef PDQ_BUS_DMA
  162 #define PDQ_OS_UNSOL_EVENT_PRESYNC(pdq, event) \
  163         pdq_os_unsolicited_event_sync((pdq)->pdq_os_ctx, \
  164                         (u_int8_t *) (event) - \
  165                                 (u_int8_t *) (pdq)->pdq_unsolicited_info.ui_events, \
  166                         sizeof(*event), BUS_DMASYNC_PREREAD)
  167 #define PDQ_OS_UNSOL_EVENT_POSTSYNC(pdq, event) \
  168         pdq_os_unsolicited_event_sync((pdq)->pdq_os_ctx, \
  169                         (u_int8_t *) (event) - \
  170                                 (u_int8_t *) (pdq)->pdq_unsolicited_info.ui_events, \
  171                         sizeof(*event), BUS_DMASYNC_POSTREAD)
  172 #define PDQ_OS_DESCBLOCK_SYNC(pdq, what, length, why) \
  173         pdq_os_descriptor_block_sync((pdq)->pdq_os_ctx, \
  174                         (u_int8_t *) (what) - (u_int8_t *) (pdq)->pdq_dbp, \
  175                         (length), (why))
  176 #define PDQ_OS_CONSUMER_PRESYNC(pdq) \
  177         pdq_os_consumer_block_sync((pdq)->pdq_os_ctx, \
  178                               BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE)
  179 #define PDQ_OS_CONSUMER_POSTSYNC(pdq) \
  180         pdq_os_consumer_block_sync((pdq)->pdq_os_ctx, \
  181                               BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE)
  182 #define PDQ_OS_DESC_PRESYNC(pdq, d, s) \
  183         PDQ_OS_DESCBLOCK_SYNC((pdq), (d), (s), BUS_DMASYNC_PREWRITE)
  184 #define PDQ_OS_DESC_POSTSYNC(pdq, d, s) \
  185         PDQ_OS_DESCBLOCK_SYNC((pdq), (d), (s), BUS_DMASYNC_POSTWRITE)
  186 #define PDQ_OS_CMDRQST_PRESYNC(pdq, s) \
  187         PDQ_OS_DESCBLOCK_SYNC((pdq), \
  188                               (pdq)->pdq_command_info.ci_request_bufstart, \
  189                               (s), BUS_DMASYNC_PREWRITE)
  190 #define PDQ_OS_CMDRSP_PRESYNC(pdq, s) \
  191         PDQ_OS_DESCBLOCK_SYNC((pdq), \
  192                               (pdq)->pdq_command_info.ci_response_bufstart, \
  193                               (s), BUS_DMASYNC_PREREAD)
  194 #define PDQ_OS_CMDRQST_POSTSYNC(pdq, s) \
  195         PDQ_OS_DESCBLOCK_SYNC((pdq), \
  196                               (pdq)->pdq_command_info.ci_request_bufstart, \
  197                               (s), BUS_DMASYNC_POSTWRITE)
  198 #define PDQ_OS_CMDRSP_POSTSYNC(pdq, s) \
  199         PDQ_OS_DESCBLOCK_SYNC((pdq), \
  200                               (pdq)->pdq_command_info.ci_response_bufstart, \
  201                               (s), BUS_DMASYNC_POSTREAD)
  202 #define PDQ_OS_RXPDU_PRESYNC(pdq, b, o, l) \
  203         pdq_os_databuf_sync((pdq)->pdq_os_ctx, (b), (o), (l), \
  204                             BUS_DMASYNC_PREREAD)
  205 #define PDQ_OS_RXPDU_POSTSYNC(pdq, b, o, l) \
  206         pdq_os_databuf_sync((pdq)->pdq_os_ctx, (b), (o), (l), \
  207                             BUS_DMASYNC_POSTREAD)
  208 #define PDQ_OS_DATABUF_ALLOC(pdq, b)    ((void)((b) = pdq_os_databuf_alloc((pdq)->pdq_os_ctx)))
  209 #define PDQ_OS_DATABUF_FREE(pdq, b)     pdq_os_databuf_free((pdq)->pdq_os_ctx, (b))
  210 #define PDQ_OS_DATABUF_BUSPA(pdq, b)    (M_GETCTX((b), bus_dmamap_t)->dm_segs[0].ds_addr + 0)
  211 struct _pdq_os_ctx_t;
  212 extern void pdq_os_descriptor_block_sync(struct _pdq_os_ctx_t *, size_t,
  213                                          size_t, int);
  214 extern void pdq_os_consumer_block_sync(struct _pdq_os_ctx_t *, int);
  215 extern void pdq_os_unsolicited_event_sync(struct _pdq_os_ctx_t *, size_t,
  216                                           size_t, int);
  217 extern struct mbuf *pdq_os_databuf_alloc(struct _pdq_os_ctx_t *);
  218 extern void pdq_os_databuf_sync(struct _pdq_os_ctx_t *, struct mbuf *,
  219                                 size_t, size_t, int);
  220 extern void pdq_os_databuf_free(struct _pdq_os_ctx_t *, struct mbuf *);
  221 #define M_HASTXDMAMAP           M_LINK1
  222 #define M_HASRXDMAMAP           M_LINK2
  223 #endif
  224 
  225 #define PDQ_CSR_WRITE(csr, name, data)          PDQ_OS_IOWR_32((csr)->csr_bus, (csr)->csr_base, (csr)->name, data)
  226 #define PDQ_CSR_READ(csr, name)                 PDQ_OS_IORD_32((csr)->csr_bus, (csr)->csr_base, (csr)->name)
  227 
  228 #define PDQ_OS_IFP_TO_SOFTC(ifp)                ((pdq_softc_t *) (ifp)->if_softc)
  229 #define PDQ_ARP_IFINIT(sc, ifa)                 arp_ifinit(&(sc)->sc_if, (ifa))
  230 #define PDQ_FDDICOM(sc)                         (&(sc)->sc_ec)
  231 #define PDQ_LANADDR(sc)                         LLADDR((sc)->sc_if.if_sadl)
  232 #define PDQ_LANADDR_SIZE(sc)                    ((sc)->sc_if.if_sadl->sdl_alen)
  233 #endif
  234 
  235 #if !defined(PDQ_BPF_MTAP)
  236 #define PDQ_BPF_MTAP(sc, m)     bpf_mtap((sc)->sc_bpf, m)
  237 #endif
  238 
  239 #if !defined(PDQ_BPFATTACH)
  240 #define PDQ_BPFATTACH(sc, t, s) bpfattach(&(sc)->sc_bpf, &(sc)->sc_if, t, s)
  241 #endif
  242 
  243 #if !defined(PDQ_OS_SPL_RAISE)
  244 #define PDQ_OS_SPL_RAISE()      splimp()
  245 #endif
  246 
  247 #if !defined(PDQ_OS_SPL_LOWER)
  248 #define PDQ_OS_SPL_LOWER(s)     splx(s)
  249 #endif
  250 
  251 #if !defined(PDQ_FDDICOM)
  252 #define PDQ_FDDICOM(sc)         (&(sc)->sc_ac)
  253 #endif
  254 
  255 #if !defined(PDQ_ARP_IFINIT)
  256 #define PDQ_ARP_IFINIT(sc, ifa) arp_ifinit(&(sc)->sc_ac, (ifa))
  257 #endif
  258 
  259 #if !defined(PDQ_OS_PTR_FMT)
  260 #define PDQ_OS_PTR_FMT  "0x%x"
  261 #endif
  262 
  263 #if !defined(PDQ_OS_CSR_FMT)
  264 #define PDQ_OS_CSR_FMT  "0x%x"
  265 #endif
  266 
  267 #if !defined(PDQ_LANADDR)
  268 #define PDQ_LANADDR(sc)         ((sc)->sc_ac.ac_enaddr)
  269 #define PDQ_LANADDR_SIZE(sc)    (sizeof((sc)->sc_ac.ac_enaddr))
  270 #endif
  271 
  272 #if !defined(PDQ_OS_IOMEM)
  273 #define PDQ_OS_IORD_32(t, base, offset)         inl((base) + (offset))
  274 #define PDQ_OS_IOWR_32(t, base, offset, data)   outl((base) + (offset), data)
  275 #define PDQ_OS_IORD_8(t, base, offset)          inb((base) + (offset))
  276 #define PDQ_OS_IOWR_8(t, base, offset, data)    outb((base) + (offset), data)
  277 #define PDQ_OS_MEMRD_32(t, base, offset)        (0 + *((base) + (offset)))
  278 #define PDQ_OS_MEMWR_32(t, base, offset, data)  do *((base) + (offset)) = (data); while (0)
  279 #endif
  280 #ifndef PDQ_CSR_OFFSET
  281 #define PDQ_CSR_OFFSET(base, offset)            (0 + (base) + (offset))
  282 #endif
  283 
  284 #ifndef PDQ_CSR_WRITE
  285 #define PDQ_CSR_WRITE(csr, name, data)          PDQ_OS_MEMWR_32((csr)->csr_bus, (csr)->name, 0, data)
  286 #define PDQ_CSR_READ(csr, name)                 PDQ_OS_MEMRD_32((csr)->csr_bus, (csr)->name, 0)
  287 #endif
  288 
  289 #ifndef PDQ_OS_IFP_TO_SOFTC
  290 #define PDQ_OS_IFP_TO_SOFTC(ifp)        ((pdq_softc_t *) ((caddr_t) ifp - offsetof(pdq_softc_t, sc_ac.ac_if)))
  291 #endif
  292 
  293 
  294 #if !defined(PDQ_HWSUPPORT)
  295 
  296 typedef struct _pdq_os_ctx_t {
  297 #if defined(__bsdi__)
  298     struct device sc_dev;               /* base device */
  299     struct isadev sc_id;                /* ISA device */
  300     struct intrhand sc_ih;              /* interrupt vectoring */
  301     struct atshutdown sc_ats;           /* shutdown routine */
  302     struct arpcom sc_ac;
  303 #define sc_if           sc_ac.ac_if
  304 #elif defined(__NetBSD__)
  305     struct device sc_dev;               /* base device */
  306     void *sc_ih;                        /* interrupt vectoring */
  307     void *sc_ats;                       /* shutdown hook */
  308     struct ethercom sc_ec;
  309     bus_dma_tag_t sc_dmatag;
  310 #define sc_if           sc_ec.ec_if
  311 #elif defined(__FreeBSD__)
  312     struct kern_devconf *sc_kdc;        /* freebsd cruft */
  313     struct arpcom sc_ac;
  314 #define sc_if           sc_ac.ac_if
  315 #endif
  316 #if defined(IFM_FDDI)
  317     struct ifmedia sc_ifmedia;
  318 #endif
  319     int sc_flags;
  320 #define PDQIF_DOWNCALL          0x0001  /* active calling from if to pdq */
  321     pdq_t *sc_pdq;
  322 #if defined(__alpha__) || defined(__i386__)
  323     pdq_bus_ioport_t sc_iobase;
  324 #endif
  325 #if defined(PDQ_IOMAPPED) && !defined(__NetBSD__)
  326 #define sc_membase      sc_iobase
  327 #else
  328     pdq_bus_memaddr_t sc_membase;
  329 #endif
  330     pdq_bus_t sc_iotag;
  331     pdq_bus_t sc_csrtag;
  332 #if !defined(__bsdi__) || _BSDI_VERSION >= 199401
  333 #define sc_bpf          sc_if.if_bpf
  334 #else
  335     caddr_t sc_bpf;
  336 #endif
  337 #if defined(PDQ_BUS_DMA)
  338 #if !defined(__NetBSD__)
  339      bus_dma_tag_t sc_dmatag;
  340 #endif
  341      bus_dmamap_t sc_dbmap;             /* DMA map for descriptor block */
  342      bus_dmamap_t sc_uimap;             /* DMA map for unsolicited events */
  343      bus_dmamap_t sc_cbmap;             /* DMA map for consumer block */
  344 #endif
  345 } pdq_softc_t;
  346 
  347 
  348 extern void pdq_ifreset(pdq_softc_t *);
  349 extern void pdq_ifinit(pdq_softc_t *);
  350 extern void pdq_ifwatchdog(struct ifnet *);
  351 extern ifnet_ret_t pdq_ifstart(struct ifnet *);
  352 extern int pdq_ifioctl(struct ifnet *, ioctl_cmd_t, caddr_t);
  353 extern void pdq_ifattach(pdq_softc_t *, ifnet_ret_t (*ifwatchdog)(int));
  354 #endif /* !PDQ_HWSUPPORT */
  355 
  356 
  357 #elif defined(DLPI_PDQ)
  358 #include <sys/param.h>
  359 #include <sys/kmem.h>
  360 #include <sys/ddi.h>
  361 #include <sys/stream.h>
  362 
  363 #define PDQ_USE_STREAMS
  364 #define PDQ_OS_PREFIX                   "%s board %d "
  365 #define PDQ_OS_PREFIX_ARGS              pdq->pdq_os_name, pdq->pdq_unit
  366 
  367 #define PDQ_OS_PAGESIZE                 PAGESIZE
  368 #define PDQ_OS_USEC_DELAY(n)            drv_usecwait(n)
  369 #define PDQ_OS_MEMZERO(p, n)            bzero((caddr_t)(p), (n))
  370 #define PDQ_OS_VA_TO_BUSPA(pdq, p)              vtop((caddr_t)p, NULL)
  371 #define PDQ_OS_MEMALLOC(n)              kmem_zalloc(n, KM_NOSLEEP)
  372 #define PDQ_OS_MEMFREE(p, n)            kmem_free((caddr_t) p, n)
  373 #define PDQ_OS_MEMALLOC_CONTIG(n)       kmem_zalloc_physreq(n, decfddiphysreq_db, KM_NOSLEEP)
  374 #define PDQ_OS_MEMFREE_CONTIG(p, n)     PDQ_OS_MEMFREE(p, n)
  375 
  376 extern physreq_t *decfddiphysreq_db;
  377 extern physreq_t *decfddiphysreq_mblk;
  378 
  379 #define PDQ_OS_DATABUF_ALLOC(pdq, b)            ((void) (((b) = allocb_physreq(PDQ_OS_DATABUF_SIZE, BPRI_MED, decfddiphysreq_mblk)) && ((b)->b_wptr = (b)->b_rptr + PDQ_OS_DATABUF_SIZE)))
  380 
  381 #define PDQ_OS_IORD_8(port)             inb(port)
  382 #define PDQ_OS_IOWR_8(port, data)       outb(port, data)
  383 #endif
  384 
  385 
  386 #ifdef PDQ_USE_MBUFS
  387 #define PDQ_OS_DATABUF_SIZE                     (MCLBYTES)
  388 #ifndef PDQ_OS_DATABUF_FREE
  389 #define PDQ_OS_DATABUF_FREE(pdq, b)             (m_freem(b))
  390 #endif
  391 #define PDQ_OS_DATABUF_NEXT(b)                  ((b)->m_next)
  392 #define PDQ_OS_DATABUF_NEXT_SET(b, b1)          ((b)->m_next = (b1))
  393 #define PDQ_OS_DATABUF_NEXTPKT(b)               ((b)->m_nextpkt)
  394 #define PDQ_OS_DATABUF_NEXTPKT_SET(b, b1)       ((b)->m_nextpkt = (b1))
  395 #define PDQ_OS_DATABUF_LEN(b)                   ((b)->m_len)
  396 #define PDQ_OS_DATABUF_LEN_SET(b, n)            ((b)->m_len = (n))
  397 /* #define      PDQ_OS_DATABUF_LEN_ADJ(b, n)            ((b)->m_len += (n)) */
  398 #define PDQ_OS_DATABUF_PTR(b)                   (mtod((b), pdq_uint8_t *))
  399 #define PDQ_OS_DATABUF_ADJ(b, n)                ((b)->m_data += (n), (b)->m_len -= (n))
  400 typedef struct mbuf PDQ_OS_DATABUF_T;
  401 
  402 #ifndef PDQ_OS_DATABUF_ALLOC
  403 #define PDQ_OS_DATABUF_ALLOC(pdq, b) do { \
  404     PDQ_OS_DATABUF_T *x_m0; \
  405     MGETHDR(x_m0, M_DONTWAIT, MT_DATA); \
  406     if (x_m0 != NULL) { \
  407         MCLGET(x_m0, M_DONTWAIT);       \
  408         if ((x_m0->m_flags & M_EXT) == 0) { \
  409             m_free(x_m0); \
  410             (b) = NULL; \
  411         } else { \
  412             (b) = x_m0; \
  413             x_m0->m_len = PDQ_OS_DATABUF_SIZE; \
  414         } \
  415     } else { \
  416         (b) = NULL; \
  417     } \
  418 } while (0)
  419 #endif
  420 #define PDQ_OS_DATABUF_RESET(b) ((b)->m_data = (b)->m_ext.ext_buf, (b)->m_len = MCLBYTES)
  421 #endif /* PDQ_USE_MBUFS */
  422 
  423 #ifdef PDQ_USE_STREAMS
  424 #define PDQ_OS_DATABUF_SIZE                     (2048)
  425 #define PDQ_OS_DATABUF_FREE(pdq, b)             (freemsg(b))
  426 #define PDQ_OS_DATABUF_NEXT(b)                  ((b)->b_cont)
  427 #define PDQ_OS_DATABUF_NEXT_SET(b, b1)          ((b)->b_cont = (b1))
  428 #define PDQ_OS_DATABUF_NEXTPKT(b)               ((b)->b_next)
  429 #define PDQ_OS_DATABUF_NEXTPKT_SET(b, b1)       ((b)->b_next = (b1))
  430 #define PDQ_OS_DATABUF_LEN(b)                   ((b)->b_wptr - (b)->b_rptr)
  431 #define PDQ_OS_DATABUF_LEN_SET(b, n)            ((b)->b_wptr = (b)->b_rptr + (n))
  432 /*#define       PDQ_OS_DATABUF_LEN_ADJ(b, n)            ((b)->b_wptr += (n))*/
  433 #define PDQ_OS_DATABUF_PTR(b)                   ((pdq_uint8_t *) (b)->b_rptr)
  434 #define PDQ_OS_DATABUF_ADJ(b, n)                ((b)->b_rptr += (n))
  435 typedef mblk_t PDQ_OS_DATABUF_T;
  436 
  437 #ifndef PDQ_OS_DATABUF_ALLOC
  438 #define PDQ_OS_DATABUF_ALLOC(pdq, b)                    ((void) (((b) = allocb(PDQ_OS_DATABUF_SIZE, BPRI_MED)) && ((b)->b_wptr = (b)->b_rptr + PDQ_OS_DATABUF_SIZE)))
  439 #endif /* PDQ_OS_DATABUF_ALLOC */
  440 #endif /* PDQ_USE_STREAMS */
  441 
  442 #define PDQ_OS_TX_TRANSMIT              5
  443 
  444 #define PDQ_OS_DATABUF_ENQUEUE(q, b)    do { \
  445     PDQ_OS_DATABUF_NEXTPKT_SET(b, NULL); \
  446     if ((q)->q_tail == NULL) \
  447         (q)->q_head = (b); \
  448     else \
  449         PDQ_OS_DATABUF_NEXTPKT_SET(((PDQ_OS_DATABUF_T *)(q)->q_tail), b); \
  450     (q)->q_tail = (b); \
  451 } while (0)
  452 
  453 #define PDQ_OS_DATABUF_DEQUEUE(q, b)    do { \
  454     if (((b) = (PDQ_OS_DATABUF_T *) (q)->q_head) != NULL) { \
  455         if (((q)->q_head = PDQ_OS_DATABUF_NEXTPKT(b)) == NULL) \
  456             (q)->q_tail = NULL; \
  457         PDQ_OS_DATABUF_NEXTPKT_SET(b, NULL); \
  458     } \
  459 } while (0)
  460 
  461 #if !defined(PDQ_OS_CONSUMER_PRESYNC)
  462 #define PDQ_OS_CONSUMER_PRESYNC(pdq)            do { } while(0)
  463 #define PDQ_OS_CONSUMER_POSTSYNC(pdq)           do { } while(0)
  464 #define PDQ_OS_DESC_PRESYNC(pdq, d, s)          do { } while(0)
  465 #define PDQ_OS_DESC_POSTSYNC(pdq, d, s)         do { } while(0)
  466 #define PDQ_OS_CMDRQST_PRESYNC(pdq, s)          do { } while(0)
  467 #define PDQ_OS_CMDRQST_POSTSYNC(pdq, s)         do { } while(0)
  468 #define PDQ_OS_CMDRSP_PRESYNC(pdq, s)           do { } while(0)
  469 #define PDQ_OS_CMDRSP_POSTSYNC(pdq, s)          do { } while(0)
  470 #define PDQ_OS_RXPDU_PRESYNC(pdq, b, o, l)      do { } while(0)
  471 #define PDQ_OS_RXPDU_POSTSYNC(pdq, b, o, l)     do { } while(0)
  472 #define PDQ_OS_UNSOL_EVENT_PRESYNC(pdq, e)      do { } while(0)
  473 #define PDQ_OS_UNSOL_EVENT_POSTSYNC(pdq, e)     do { } while(0)
  474 #endif
  475 
  476 #ifndef PDQ_OS_DATABUF_BUSPA
  477 #define PDQ_OS_DATABUF_BUSPA(pdq, b)    PDQ_OS_VA_TO_BUSPA(pdq, PDQ_OS_DATABUF_PTR(b))
  478 #endif
  479 
  480 #ifndef PDQ_OS_HDR_OFFSET
  481 #define PDQ_OS_HDR_OFFSET       PDQ_RX_FC_OFFSET
  482 #endif
  483 
  484 extern void pdq_os_addr_fill(pdq_t *, pdq_lanaddr_t *, size_t);
  485 extern void pdq_os_receive_pdu(pdq_t *, PDQ_OS_DATABUF_T *, size_t, int);
  486 extern void pdq_os_restart_transmitter(pdq_t *);
  487 extern void pdq_os_transmit_done(pdq_t *, PDQ_OS_DATABUF_T *);
  488 #if !defined(pdq_os_update_status)
  489 extern void pdq_os_update_status(pdq_t *, const void *);
  490 #endif
  491 #if !defined(PDQ_OS_MEMALLOC_CONTIG)
  492 extern int pdq_os_memalloc_contig(pdq_t *);
  493 #endif
  494 extern pdq_boolean_t pdq_queue_transmit_data(pdq_t *, PDQ_OS_DATABUF_T *);
  495 extern void pdq_flush_transmitter(pdq_t *);
  496 
  497 extern void pdq_run(pdq_t *);
  498 extern pdq_state_t pdq_stop(pdq_t *);
  499 extern void pdq_hwreset(pdq_t *);
  500 
  501 extern int pdq_interrupt(pdq_t *);
  502 extern pdq_t *pdq_initialize(pdq_bus_t, pdq_bus_memaddr_t, const char *, int,
  503                              void *, pdq_type_t);
  504 #endif /* _PDQ_OS_H */

Cache object: 36c757bd0da17e0e23d21b873edb8693


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.