Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix dmamap leakages. fix transmit bug. fix receive bugs. fix mips 

coherency problems.
This commit is contained in:
matt 1998-05-24 21:40:05 +00:00
parent 1ce82f8f84
commit 144c41e986
3 changed files with 93 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
sys/dev/ic/pdq.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: pdq.c,v 1.13 1998/05/21 20:44:02 matt Exp $ */
/* $NetBSD: pdq.c,v 1.14 1998/05/24 21:40:06 matt Exp $ */
/*-
* Copyright (c) 1995,1996 Matt Thomas <matt@3am-software.com>
@ -607,6 +607,7 @@ pdq_process_command_responses(
PDQ_ASSERT(cbp->pdqcb_command_request != ci->ci_request_completion);
PDQ_OS_CMDRSP_POSTSYNC(pdq, PDQ_SIZE_COMMAND_RESPONSE);
rspgen = (const pdq_response_generic_t *) ci->ci_response_bufstart;
PDQ_ASSERT(rspgen->generic_status == PDQR_SUCCESS);
PDQ_PRINTF(("PDQ Process Command Response: %s completed (status=%d)\n",
@ -903,7 +904,7 @@ pdq_queue_transmit_data(
#if defined(PDQ_BUS_DMA)
map = M_GETCTX(pdu, bus_dmamap_t);
if ((freecnt = tx->tx_free - 1) > map->dm_nsegs) {
if ((freecnt = tx->tx_free - 1) >= map->dm_nsegs) {
int idx;
for (idx = 0; idx < map->dm_nsegs; idx++) {
/*
@ -1021,6 +1022,7 @@ pdq_flush_transmitter(
tx->tx_free = PDQ_RING_MASK(pdq->pdq_dbp->pdqdb_transmits);
cbp->pdqcb_transmits = tx->tx_completion = tx->tx_producer;
PDQ_OS_CONSUMER_PRESYNC(pdq);
PDQ_DO_TYPE2_PRODUCER(pdq);
}
@ -1151,6 +1153,7 @@ pdq_stop(
pdq->pdq_cbp->pdqcb_unsolicited_event = 0;
pdq->pdq_cbp->pdqcb_command_response = 0;
pdq->pdq_cbp->pdqcb_command_request = 0;
PDQ_OS_CONSUMER_PRESYNC(pdq);
/*
* Reset the producer and completion indexes to 0.
@ -1248,6 +1251,7 @@ pdq_stop(
* Now wait (up to 100ms) for the command(s) to finish.
*/
for (cnt = 0; cnt < 1000; cnt++) {
PDQ_OS_CONSUMER_POSTSYNC(pdq);
pdq_process_command_responses(pdq);
if (pdq->pdq_command_info.ci_response_producer == pdq->pdq_command_info.ci_response_completion)
break;
@ -1458,6 +1462,7 @@ pdq_initialize(
{
pdq_t *pdq;
pdq_state_t state;
pdq_descriptor_block_t *dbp;
#if !defined(PDQ_BUS_DMA)
const pdq_uint32_t contig_bytes = (sizeof(pdq_descriptor_block_t) * 2) - PDQ_OS_PAGESIZE;
pdq_uint8_t *p;
@ -1548,21 +1553,22 @@ pdq_initialize(
PDQ_OS_MEMFREE(pdq, sizeof(pdq_t));
return NULL;
}
dbp = pdq->pdq_dbp;
pdq->pdq_cbp = (volatile pdq_consumer_block_t *) &pdq->pdq_dbp->pdqdb_consumer;
pdq->pdq_cbp = (volatile pdq_consumer_block_t *) &dbp->pdqdb_consumer;
pdq->pdq_pa_consumer_block = PDQ_DB_BUSPA(pdq, pdq->pdq_cbp);
pdq->pdq_command_info.ci_request_bufstart = (pdq_uint8_t *) pdq->pdq_dbp->pdqdb_command_pool;
pdq->pdq_command_info.ci_response_bufstart = (pdq_uint8_t *) pdq->pdq_dbp->pdqdb_command_pool + sizeof(pdq->pdq_dbp->pdqdb_command_pool) - PDQ_SIZE_COMMAND_RESPONSE;
pdq->pdq_rx_info.rx_buffers = (void *) pdq->pdq_dbp->pdqdb_receive_buffers;
pdq->pdq_command_info.ci_request_bufstart = (pdq_uint8_t *) dbp->pdqdb_command_pool;
pdq->pdq_command_info.ci_response_bufstart = (pdq_uint8_t *) dbp->pdqdb_command_pool + sizeof(dbp->pdqdb_command_pool) - PDQ_SIZE_COMMAND_RESPONSE;
pdq->pdq_rx_info.rx_buffers = (void *) dbp->pdqdb_receive_buffers;
pdq->pdq_host_smt_info.rx_buffers = (void *) pdq->pdq_dbp->pdqdb_host_smt_buffers;
pdq->pdq_host_smt_info.rx_buffers = (void *) dbp->pdqdb_host_smt_buffers;
PDQ_PRINTF(("\nPDQ Descriptor Block = " PDQ_OS_PTR_FMT " (PA = 0x%x)\n", pdq->pdq_dbp, pdq->pdq_pa_descriptor_block));
PDQ_PRINTF((" Recieve Queue = " PDQ_OS_PTR_FMT "\n", pdq->pdq_dbp->pdqdb_receives));
PDQ_PRINTF((" Transmit Queue = " PDQ_OS_PTR_FMT "\n", pdq->pdq_dbp->pdqdb_transmits));
PDQ_PRINTF((" Host SMT Queue = " PDQ_OS_PTR_FMT "\n", pdq->pdq_dbp->pdqdb_host_smt));
PDQ_PRINTF((" Command Response Queue = " PDQ_OS_PTR_FMT "\n", pdq->pdq_dbp->pdqdb_command_responses));
PDQ_PRINTF((" Command Request Queue = " PDQ_OS_PTR_FMT "\n", pdq->pdq_dbp->pdqdb_command_requests));
PDQ_PRINTF(("\nPDQ Descriptor Block = " PDQ_OS_PTR_FMT " (PA = 0x%x)\n", dbp, pdq->pdq_pa_descriptor_block));
PDQ_PRINTF((" Recieve Queue = " PDQ_OS_PTR_FMT "\n", dbp->pdqdb_receives));
PDQ_PRINTF((" Transmit Queue = " PDQ_OS_PTR_FMT "\n", dbp->pdqdb_transmits));
PDQ_PRINTF((" Host SMT Queue = " PDQ_OS_PTR_FMT "\n", dbp->pdqdb_host_smt));
PDQ_PRINTF((" Command Response Queue = " PDQ_OS_PTR_FMT "\n", dbp->pdqdb_command_responses));
PDQ_PRINTF((" Command Request Queue = " PDQ_OS_PTR_FMT "\n", dbp->pdqdb_command_requests));
PDQ_PRINTF(("PDQ Consumer Block = " PDQ_OS_PTR_FMT "\n", pdq->pdq_cbp));
/*
@ -1571,7 +1577,7 @@ pdq_initialize(
* block, command pool, and buffer pointers for the receive
* host_smt rings.
*/
PDQ_OS_MEMZERO(pdq->pdq_dbp, sizeof(*pdq->pdq_dbp));
PDQ_OS_MEMZERO(dbp, sizeof(*dbp));
/*
* Initialize the CSR references.
@ -1613,12 +1619,12 @@ pdq_initialize(
* Initialize the command information block
*/
pdq->pdq_command_info.ci_pa_request_bufstart = PDQ_DB_BUSPA(pdq, pdq->pdq_command_info.ci_request_bufstart);
pdq->pdq_command_info.ci_pa_request_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_command_requests);
pdq->pdq_command_info.ci_pa_request_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_command_requests);
PDQ_PRINTF(("PDQ Command Buffer = " PDQ_OS_PTR_FMT " (PA=0x%x)\n",
pdq->pdq_command_info.ci_request_bufstart,
pdq->pdq_command_info.ci_pa_request_bufstart));
for (idx = 0; idx < sizeof(pdq->pdq_dbp->pdqdb_command_requests)/sizeof(pdq->pdq_dbp->pdqdb_command_requests[0]); idx++) {
pdq_txdesc_t *txd = &pdq->pdq_dbp->pdqdb_command_requests[idx];
for (idx = 0; idx < sizeof(dbp->pdqdb_command_requests)/sizeof(dbp->pdqdb_command_requests[0]); idx++) {
pdq_txdesc_t *txd = &dbp->pdqdb_command_requests[idx];
txd->txd_pa_lo = pdq->pdq_command_info.ci_pa_request_bufstart;
txd->txd_eop = txd->txd_sop = 1;
@ -1626,9 +1632,9 @@ pdq_initialize(
}
pdq->pdq_command_info.ci_pa_response_bufstart = PDQ_DB_BUSPA(pdq, pdq->pdq_command_info.ci_response_bufstart);
pdq->pdq_command_info.ci_pa_response_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_command_responses);
for (idx = 0; idx < sizeof(pdq->pdq_dbp->pdqdb_command_responses)/sizeof(pdq->pdq_dbp->pdqdb_command_responses[0]); idx++) {
pdq_rxdesc_t *rxd = &pdq->pdq_dbp->pdqdb_command_responses[idx];
pdq->pdq_command_info.ci_pa_response_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_command_responses);
for (idx = 0; idx < sizeof(dbp->pdqdb_command_responses)/sizeof(dbp->pdqdb_command_responses[0]); idx++) {
pdq_rxdesc_t *rxd = &dbp->pdqdb_command_responses[idx];
rxd->rxd_pa_lo = pdq->pdq_command_info.ci_pa_response_bufstart;
rxd->rxd_sop = 1;
@ -1636,19 +1642,19 @@ pdq_initialize(
rxd->rxd_seg_len_lo = 0;
rxd->rxd_seg_len_hi = PDQ_SIZE_COMMAND_RESPONSE / 16;
}
PDQ_OS_DESC_PRESYNC(pdq, pdq->pdq_dbp->pdqdb_command_responses,
sizeof(pdq->pdq_dbp->pdqdb_command_responses));
PDQ_OS_DESC_PRESYNC(pdq, dbp->pdqdb_command_responses,
sizeof(dbp->pdqdb_command_responses));
/*
* Initialize the unsolicited event information block
*/
pdq->pdq_unsolicited_info.ui_free = PDQ_NUM_UNSOLICITED_EVENTS;
pdq->pdq_unsolicited_info.ui_pa_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_unsolicited_events);
pdq->pdq_unsolicited_info.ui_pa_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_unsolicited_events);
PDQ_PRINTF(("PDQ Unsolicit Event Buffer = " PDQ_OS_PTR_FMT " (PA=0x%x)\n",
pdq->pdq_unsolicited_info.ui_events,
pdq->pdq_unsolicited_info.ui_pa_bufstart));
for (idx = 0; idx < sizeof(pdq->pdq_dbp->pdqdb_unsolicited_events)/sizeof(pdq->pdq_dbp->pdqdb_unsolicited_events[0]); idx++) {
pdq_rxdesc_t *rxd = &pdq->pdq_dbp->pdqdb_unsolicited_events[idx];
for (idx = 0; idx < sizeof(dbp->pdqdb_unsolicited_events)/sizeof(dbp->pdqdb_unsolicited_events[0]); idx++) {
pdq_rxdesc_t *rxd = &dbp->pdqdb_unsolicited_events[idx];
pdq_unsolicited_event_t *event = &pdq->pdq_unsolicited_info.ui_events[idx & (PDQ_NUM_UNSOLICITED_EVENTS-1)];
rxd->rxd_sop = 1;
@ -1659,31 +1665,31 @@ pdq_initialize(
rxd->rxd_pa_hi = 0;
PDQ_OS_UNSOL_EVENT_PRESYNC(pdq, event);
}
PDQ_OS_DESC_PRESYNC(pdq, pdq->pdq_dbp->pdqdb_unsolicited_events,
sizeof(pdq->pdq_dbp->pdqdb_unsolicited_events));
PDQ_OS_DESC_PRESYNC(pdq, dbp->pdqdb_unsolicited_events,
sizeof(dbp->pdqdb_unsolicited_events));
/*
* Initialize the receive information blocks (normal and SMT).
*/
pdq->pdq_rx_info.rx_free = PDQ_RING_MASK(pdq->pdq_dbp->pdqdb_receives);
pdq->pdq_rx_info.rx_free = PDQ_RING_MASK(dbp->pdqdb_receives);
pdq->pdq_rx_info.rx_target = pdq->pdq_rx_info.rx_free - PDQ_RX_SEGCNT * 8;
pdq->pdq_rx_info.rx_pa_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_receives);
pdq->pdq_rx_info.rx_pa_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_receives);
pdq->pdq_host_smt_info.rx_free = PDQ_RING_MASK(pdq->pdq_dbp->pdqdb_host_smt);
pdq->pdq_host_smt_info.rx_free = PDQ_RING_MASK(dbp->pdqdb_host_smt);
pdq->pdq_host_smt_info.rx_target = pdq->pdq_host_smt_info.rx_free - PDQ_RX_SEGCNT * 3;
pdq->pdq_host_smt_info.rx_pa_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_host_smt);
pdq->pdq_host_smt_info.rx_pa_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_host_smt);
/*
* Initialize the transmit information block.
*/
pdq->pdq_dbp->pdqdb_tx_hdr[0] = PDQ_FDDI_PH0;
pdq->pdq_dbp->pdqdb_tx_hdr[1] = PDQ_FDDI_PH1;
pdq->pdq_dbp->pdqdb_tx_hdr[2] = PDQ_FDDI_PH2;
pdq->pdq_tx_info.tx_free = PDQ_RING_MASK(pdq->pdq_dbp->pdqdb_transmits);
pdq->pdq_tx_info.tx_hdrdesc.txd_seg_len = sizeof(pdq->pdq_dbp->pdqdb_tx_hdr);
dbp->pdqdb_tx_hdr[0] = PDQ_FDDI_PH0;
dbp->pdqdb_tx_hdr[1] = PDQ_FDDI_PH1;
dbp->pdqdb_tx_hdr[2] = PDQ_FDDI_PH2;
pdq->pdq_tx_info.tx_free = PDQ_RING_MASK(dbp->pdqdb_transmits);
pdq->pdq_tx_info.tx_hdrdesc.txd_seg_len = 3;
pdq->pdq_tx_info.tx_hdrdesc.txd_sop = 1;
pdq->pdq_tx_info.tx_hdrdesc.txd_pa_lo = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_tx_hdr);
pdq->pdq_tx_info.tx_pa_descriptors = PDQ_DB_BUSPA(pdq, pdq->pdq_dbp->pdqdb_transmits);
pdq->pdq_tx_info.tx_hdrdesc.txd_pa_lo = PDQ_DB_BUSPA(pdq, dbp->pdqdb_tx_hdr);
pdq->pdq_tx_info.tx_pa_descriptors = PDQ_DB_BUSPA(pdq, dbp->pdqdb_transmits);
state = PDQ_PSTS_ADAPTER_STATE(PDQ_CSR_READ(&pdq->pdq_csrs, csr_port_status));
PDQ_PRINTF(("PDQ Adapter State = %s\n", pdq_adapter_states[state]));

82
sys/dev/ic/pdq_ifsubr.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: pdq_ifsubr.c,v 1.13 1998/05/21 20:44:02 matt Exp $ */
/* $NetBSD: pdq_ifsubr.c,v 1.14 1998/05/24 21:40:06 matt Exp $ */
/*-
* Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
@ -185,37 +185,32 @@ pdq_ifstart(
return;
}
for (;; tx = 1) {
#if defined(PDQ_BUS_DMA) && !defined(PDQ_BUS_DMA_NOTX)
bus_dmamap_t map;
#endif
IF_DEQUEUE(ifq, m);
if (m == NULL)
break;
#if defined(PDQ_BUS_DMA) && !defined(PDQ_BUS_DMA_NOTX)
if (m->m_flags & M_HASDMAMAP) {
map = M_GETCTX(m, bus_dmamap_t);
} else {
map = NULL;
if (!bus_dmamap_create(sc->sc_dmatag, 0x1FFF, 255, 0x1FFF, 0, BUS_DMA_NOWAIT, &map)) {
if ((m->m_flags & M_HASTXDMAMAP) == 0) {
bus_dmamap_t map;
if (!bus_dmamap_create(sc->sc_dmatag, m->m_pkthdr.len, 255,
m->m_pkthdr.len, 0, BUS_DMA_NOWAIT, &map)) {
if (!bus_dmamap_load_mbuf(sc->sc_dmatag, map, m, BUS_DMA_NOWAIT)) {
bus_dmamap_sync(sc->sc_dmatag, map, 0, m->m_pkthdr.len, BUS_DMASYNC_PREWRITE);
bus_dmamap_sync(sc->sc_dmatag, map, 0, m->m_pkthdr.len,
BUS_DMASYNC_PREWRITE);
M_SETCTX(m, map);
m->m_flags |= M_HASDMAMAP;
m->m_flags |= M_HASTXDMAMAP;
}
}
if ((m->m_flags & M_HASDMAMAP) == 0) {
ifp->if_flags |= IFF_OACTIVE;
IF_PREPEND(ifq, m);
if ((m->m_flags & M_HASTXDMAMAP) == 0)
break;
}
}
#endif
if (pdq_queue_transmit_data(sc->sc_pdq, m) == PDQ_FALSE) {
ifp->if_flags |= IFF_OACTIVE;
IF_PREPEND(ifq, m);
if (pdq_queue_transmit_data(sc->sc_pdq, m) == PDQ_FALSE)
break;
}
}
if (m != NULL) {
ifp->if_flags |= IFF_OACTIVE;
IF_PREPEND(ifq, m);
}
if (tx)
PDQ_DO_TYPE2_PRODUCER(sc->sc_pdq);
@ -232,13 +227,25 @@ pdq_os_receive_pdu(
struct fddi_header *fh = mtod(m, struct fddi_header *);
sc->sc_if.if_ipackets++;
#if NBPFILTER > 0
#if defined(PDQ_BUS_MAP)
pdq_os_databuf_sync(sc, m, 0, pktlen, BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(sc->sc_dmatag, M_GETCTX(m, bus_dmamap_t));
bus_dmamap_destroy(sc->sc_dmatag, M_GETCTX(m, bus_dmamap_t));
m->m_flags &= ~M_HASDMAMAP;
#if defined(PDQ_BUS_DMA)
{
/*
* Even though the first mbuf start at the frame control octet,
* the dmamap PDQ_RX_FC_OFFSET octets earlier. Any additional
* mbufs will start normally.
*/
int offset = PDQ_RX_FC_OFFSET;
struct mbuf *m0;
for (m0 = m; m0 != NULL; m0 = m0->m_next, offset = 0) {
pdq_os_databuf_sync(sc, m0, offset, m0->m_len, BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(sc->sc_dmatag, M_GETCTX(m0, bus_dmamap_t));
bus_dmamap_destroy(sc->sc_dmatag, M_GETCTX(m0, bus_dmamap_t));
m0->m_flags &= ~M_HASRXDMAMAP;
M_SETCTX(m0, NULL);
}
}
#endif
#if NBPFILTER > 0
if (sc->sc_bpf != NULL)
PDQ_BPF_MTAP(sc, m);
#endif
@ -246,12 +253,6 @@ pdq_os_receive_pdu(
PDQ_OS_DATABUF_FREE(pdq, m);
return;
}
#if NBPFILTER == 0 && defined(PDQ_BUS_MAP)
pdq_os_databuf_sync(sc, m, 0, pktlen, BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(sc->sc_dmatag, M_GETCTX(m, bus_dmamap_t));
bus_dmamap_destroy(sc->sc_dmatag, M_GETCTX(m, bus_dmamap_t));
m->m_flags &= ~M_HASDMAMAP;
#endif
m->m_data += sizeof(struct fddi_header);
m->m_len -= sizeof(struct fddi_header);
@ -704,11 +705,11 @@ pdq_os_databuf_free(
pdq_os_ctx_t *sc,
struct mbuf *m)
{
if (m->m_flags & M_HASDMAMAP) {
if (m->m_flags & (M_HASRXDMAMAP|M_HASTXDMAMAP)) {
bus_dmamap_t map = M_GETCTX(m, bus_dmamap_t);
bus_dmamap_unload(sc->sc_dmatag, map);
bus_dmamap_destroy(sc->sc_dmatag, map);
m->m_flags ^= M_HASDMAMAP;
m->m_flags &= ~(M_HASRXDMAMAP|M_HASTXDMAMAP);
}
m_freem(m);
}
@ -721,26 +722,31 @@ pdq_os_databuf_alloc(
bus_dmamap_t map;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == NULL)
if (m == NULL) {
printf("%s: can't alloc small buf\n", sc->sc_dev.dv_xname);
return NULL;
}
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
printf("%s: can't alloc cluster\n", sc->sc_dev.dv_xname);
m_free(m);
return NULL;
}
m->m_len = PDQ_OS_DATABUF_SIZE;
m->m_pkthdr.len = m->m_len = PDQ_OS_DATABUF_SIZE;
if (!bus_dmamap_create(sc->sc_dmatag, PDQ_OS_DATABUF_SIZE,
if (bus_dmamap_create(sc->sc_dmatag, PDQ_OS_DATABUF_SIZE,
1, PDQ_OS_DATABUF_SIZE, 0, BUS_DMA_NOWAIT, &map)) {
printf("%s: can't create dmamap\n", sc->sc_dev.dv_xname);
m_free(m);
return NULL;
}
if (!bus_dmamap_load_mbuf(sc->sc_dmatag, map, m, BUS_DMA_NOWAIT)) {
if (bus_dmamap_load_mbuf(sc->sc_dmatag, map, m, BUS_DMA_NOWAIT)) {
printf("%s: can't load dmamap\n", sc->sc_dev.dv_xname);
bus_dmamap_destroy(sc->sc_dmatag, map);
m_free(m);
return NULL;
}
m->m_flags |= M_HASDMAMAP;
m->m_flags |= M_HASRXDMAMAP;
M_SETCTX(m, map);
return m;
}

8
sys/dev/ic/pdqvar.h
View File

@ -1,4 +1,4 @@
/* $NetBSD: pdqvar.h,v 1.17 1998/05/21 20:44:02 matt Exp $ */
/* $NetBSD: pdqvar.h,v 1.18 1998/05/24 21:40:05 matt Exp $ */
/*-
* Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
@ -217,7 +217,7 @@ typedef bus_addr_t pdq_bus_memoffset_t;
pdq_os_databuf_sync((pdq)->pdq_os_ctx, (b), (o), (l), \
BUS_DMASYNC_POSTREAD)
#define PDQ_OS_DATABUF_ALLOC(pdq, b) ((void)((b) = pdq_os_databuf_alloc((pdq)->pdq_os_ctx)))
#define PDQ_OS_DATABUF_FREE(pdq, b) pdq_os_databuf_free((pdq)->pdq_os_ctx, b)
#define PDQ_OS_DATABUF_FREE(pdq, b) pdq_os_databuf_free((pdq)->pdq_os_ctx, (b))
#define PDQ_OS_DATABUF_BUSPA(pdq, b) (M_GETCTX((b), bus_dmamap_t)->dm_segs[0].ds_addr + 0)
struct _pdq_os_ctx_t;
extern void pdq_os_descriptor_block_sync(struct _pdq_os_ctx_t *osctx, size_t offset,
@ -228,7 +228,8 @@ extern struct mbuf *pdq_os_databuf_alloc(struct _pdq_os_ctx_t *osctx);
extern void pdq_os_databuf_sync(struct _pdq_os_ctx_t *osctx, struct mbuf *b,
size_t offset, size_t length, int ops);
extern void pdq_os_databuf_free(struct _pdq_os_ctx_t *osctx, struct mbuf *m);
#define M_HASDMAMAP M_LINK2
#define M_HASTXDMAMAP M_LINK1
#define M_HASRXDMAMAP M_LINK2
#endif
#define PDQ_CSR_WRITE(csr, name, data) PDQ_OS_IOWR_32((csr)->csr_bus, (csr)->csr_base, (csr)->name, data)
@ -339,6 +340,7 @@ typedef struct _pdq_os_ctx_t {
#endif
bus_dmamap_t sc_dbmap; /* DMA map for descriptor block */
bus_dmamap_t sc_uimap; /* DMA map for unsolicited events */
bus_dmamap_t sc_cbmap; /* DMA map for consumer block */
#endif
} pdq_softc_t;