void msi_eq_free(bus_dma_tag_t t, struct msi_eq *meq) { bus_size_t size; size = roundup(meq->meq_nentries * sizeof(struct msi_msg), PAGE_SIZE); bus_dmamap_unload(t, meq->meq_map); bus_dmamem_unmap(t, meq->meq_va, size); bus_dmamem_free(t, &meq->meq_seg, 1); bus_dmamap_destroy(t, meq->meq_map); free(meq, M_DEVBUF, 0); }
void aha_free(struct aha_softc *aha) { switch (aha->init_level) { default: case 8: { struct sg_map_node *sg_map; while ((sg_map = SLIST_FIRST(&aha->sg_maps))!= NULL) { SLIST_REMOVE_HEAD(&aha->sg_maps, links); bus_dmamap_unload(aha->sg_dmat, sg_map->sg_dmamap); bus_dmamem_free(aha->sg_dmat, sg_map->sg_vaddr, sg_map->sg_dmamap); free(sg_map, M_DEVBUF); } bus_dma_tag_destroy(aha->sg_dmat); } case 7: bus_dmamap_unload(aha->ccb_dmat, aha->ccb_dmamap); case 6: bus_dmamem_free(aha->ccb_dmat, aha->aha_ccb_array, aha->ccb_dmamap); case 5: bus_dma_tag_destroy(aha->ccb_dmat); case 4: bus_dmamap_unload(aha->mailbox_dmat, aha->mailbox_dmamap); case 3: bus_dmamem_free(aha->mailbox_dmat, aha->in_boxes, aha->mailbox_dmamap); case 2: bus_dma_tag_destroy(aha->buffer_dmat); case 1: bus_dma_tag_destroy(aha->mailbox_dmat); case 0: break; } mtx_destroy(&aha->lock); }
/* * mrsas_unmap_request: Unmap and unload data * input: Adapter instance soft state * Pointer to command packet * * This function unmaps and unloads data from OS. */ void mrsas_unmap_request(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd) { if (cmd->data != NULL) { if (cmd->flags & MRSAS_DIR_IN) bus_dmamap_sync(sc->data_tag, cmd->data_dmamap, BUS_DMASYNC_POSTREAD); if (cmd->flags & MRSAS_DIR_OUT) bus_dmamap_sync(sc->data_tag, cmd->data_dmamap, BUS_DMASYNC_POSTWRITE); mtx_lock(&sc->io_lock); bus_dmamap_unload(sc->data_tag, cmd->data_dmamap); mtx_unlock(&sc->io_lock); } }
extern void pdq_os_databuf_free( pdq_os_ctx_t *sc, struct mbuf *m) { 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_HASRXDMAMAP|M_HASTXDMAMAP); } m_freem(m); }
static void esp_pci_dma_stop(struct ncr53c9x_softc *sc) { struct esp_pci_softc *esc = (struct esp_pci_softc *)sc; /* DMA stop */ /* XXX what should we do here ? */ WRITE_DMAREG(esc, DMA_CMD, DMACMD_ABORT | (esc->sc_datain != 0 ? DMACMD_DIR : 0)); bus_dmamap_unload(esc->sc_xferdmat, esc->sc_xferdmam); esc->sc_active = 0; }
static void s3c2440_i2s_xfer_complete(dmac_xfer_t xfer, void *cookie) { struct s3c2xx0_softc *sc = s3c2xx0_softc; /* Shortcut */ s3c2440_i2s_buf_t buf = cookie; struct s3c2440_i2s_softc *i2s = buf->i2b_parent; bus_dmamap_unload(sc->sc_dmat, buf->i2b_dmamap); mutex_spin_enter(i2s->sc_intr_lock); (buf->i2b_cb)(buf->i2b_cb_cookie); mutex_spin_exit(i2s->sc_intr_lock); }
void pcscp_dma_stop(struct ncr53c9x_softc *sc) { struct pcscp_softc *esc = (struct pcscp_softc *)sc; /* dma stop */ /* XXX What should we do here ? */ WRITE_DMAREG(esc, DMA_CMD, DMACMD_ABORT | (esc->sc_datain ? DMACMD_DIR : 0)); bus_dmamap_unload(esc->sc_dmat, esc->sc_xfermap); esc->sc_active = 0; }
/* Stop transmission on the interface */ void bce_stop(struct ifnet *ifp, int disable) { struct bce_softc *sc = ifp->if_softc; int i; u_int32_t val; /* Stop the 1 second timer */ timeout_del(&sc->bce_timeout); /* Mark the interface down and cancel the watchdog timer. */ ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); ifp->if_timer = 0; /* Down the MII. */ mii_down(&sc->bce_mii); /* Disable interrupts. */ bus_space_write_4(sc->bce_btag, sc->bce_bhandle, BCE_INT_MASK, 0); sc->bce_intmask = 0; delay(10); /* Disable emac */ bus_space_write_4(sc->bce_btag, sc->bce_bhandle, BCE_ENET_CTL, EC_ED); for (i = 0; i < 200; i++) { val = bus_space_read_4(sc->bce_btag, sc->bce_bhandle, BCE_ENET_CTL); if (!(val & EC_ED)) break; delay(10); } /* Stop the DMA */ bus_space_write_4(sc->bce_btag, sc->bce_bhandle, BCE_DMA_RXCTL, 0); bus_space_write_4(sc->bce_btag, sc->bce_bhandle, BCE_DMA_TXCTL, 0); delay(10); /* Release any queued transmit buffers. */ for (i = 0; i < BCE_NTXDESC; i++) { if (sc->bce_cdata.bce_tx_chain[i] != NULL) { bus_dmamap_unload(sc->bce_dmatag, sc->bce_cdata.bce_tx_map[i]); m_freem(sc->bce_cdata.bce_tx_chain[i]); sc->bce_cdata.bce_tx_chain[i] = NULL; } } /* drain receive queue */ if (disable) bce_rxdrain(sc); }
static int ips_send_adapter_info_cmd(ips_command_t *command) { int error = 0; ips_softc_t *sc = command->sc; ips_cmd_status_t *status = command->arg; if (bus_dma_tag_create( /* parent */ sc->adapter_dmatag, /* alignemnt */ 1, /* boundary */ 0, /* lowaddr */ BUS_SPACE_MAXADDR_32BIT, /* highaddr */ BUS_SPACE_MAXADDR, /* filter */ NULL, /* filterarg */ NULL, /* maxsize */ IPS_ADAPTER_INFO_LEN, /* numsegs */ 1, /* maxsegsize*/ IPS_ADAPTER_INFO_LEN, /* flags */ 0, &command->data_dmatag) != 0) { printf("ips: can't alloc dma tag for adapter status\n"); error = ENOMEM; goto exit; } if(bus_dmamem_alloc(command->data_dmatag, &command->data_buffer, BUS_DMA_NOWAIT, &command->data_dmamap)){ error = ENOMEM; goto exit; } command->callback = ips_wakeup_callback; asleep(status, 0, "ips", 30*hz); bus_dmamap_load(command->data_dmatag, command->data_dmamap, command->data_buffer,IPS_ADAPTER_INFO_LEN, ips_adapter_info_callback, command, BUS_DMA_NOWAIT); if (await(-1, -1)) error = ETIMEDOUT; else { bus_dmamap_sync(command->data_dmatag, command->data_dmamap, BUS_DMASYNC_POSTREAD); memcpy(&(sc->adapter_info), command->data_buffer, IPS_ADAPTER_INFO_LEN); } bus_dmamap_unload(command->data_dmatag, command->data_dmamap); exit: /* I suppose I should clean up my memory allocations */ bus_dmamem_free(command->data_dmatag, command->data_buffer, command->data_dmamap); bus_dma_tag_destroy(command->data_dmatag); ips_insert_free_cmd(sc, command); return error; }
int cas_encap(struct cas_softc *sc, struct mbuf *mhead, u_int32_t *bixp) { u_int64_t flags; u_int32_t cur, frag, i; bus_dmamap_t map; cur = frag = *bixp; map = sc->sc_txd[cur].sd_map; if (bus_dmamap_load_mbuf(sc->sc_dmatag, map, mhead, BUS_DMA_NOWAIT) != 0) { return (ENOBUFS); } if ((sc->sc_tx_cnt + map->dm_nsegs) > (CAS_NTXDESC - 2)) { bus_dmamap_unload(sc->sc_dmatag, map); return (ENOBUFS); } bus_dmamap_sync(sc->sc_dmatag, map, 0, map->dm_mapsize, BUS_DMASYNC_PREWRITE); for (i = 0; i < map->dm_nsegs; i++) { sc->sc_txdescs[frag].cd_addr = CAS_DMA_WRITE(map->dm_segs[i].ds_addr); flags = (map->dm_segs[i].ds_len & CAS_TD_BUFSIZE) | (i == 0 ? CAS_TD_START_OF_PACKET : 0) | ((i == (map->dm_nsegs - 1)) ? CAS_TD_END_OF_PACKET : 0); sc->sc_txdescs[frag].cd_flags = CAS_DMA_WRITE(flags); bus_dmamap_sync(sc->sc_dmatag, sc->sc_cddmamap, CAS_CDTXOFF(frag), sizeof(struct cas_desc), BUS_DMASYNC_PREWRITE); cur = frag; if (++frag == CAS_NTXDESC) frag = 0; } sc->sc_tx_cnt += map->dm_nsegs; sc->sc_txd[*bixp].sd_map = sc->sc_txd[cur].sd_map; sc->sc_txd[cur].sd_map = map; sc->sc_txd[cur].sd_mbuf = mhead; bus_space_write_4(sc->sc_memt, sc->sc_memh, CAS_TX_KICK, frag); *bixp = frag; /* sync descriptors */ return (0); }
void vdsk_dring_free(bus_dma_tag_t t, struct vdsk_dring *vd) { bus_size_t size; size = vd->vd_nentries * sizeof(struct vd_desc); size = roundup(size, PAGE_SIZE); bus_dmamap_unload(t, vd->vd_map); bus_dmamem_unmap(t, (caddr_t)vd->vd_desc, size); bus_dmamem_free(t, &vd->vd_seg, 1); bus_dmamap_destroy(t, vd->vd_map); free(vd, M_DEVBUF); }
/* Drain the receive queue. */ void bce_rxdrain(struct bce_softc *sc) { int i; for (i = 0; i < BCE_NRXDESC; i++) { if (sc->bce_cdata.bce_rx_chain[i] != NULL) { bus_dmamap_unload(sc->bce_dmatag, sc->bce_cdata.bce_rx_map[i]); m_freem(sc->bce_cdata.bce_rx_chain[i]); sc->bce_cdata.bce_rx_chain[i] = NULL; } } }
void iee_detach(struct iee_softc *sc, int flags) { struct ifnet *ifp = &sc->sc_ethercom.ec_if; if ((ifp->if_flags & IFF_RUNNING) != 0) iee_stop(ifp, 1); ether_ifdetach(ifp); if_detach(ifp); bus_dmamap_unload(sc->sc_dmat, sc->sc_shmem_map); bus_dmamap_destroy(sc->sc_dmat, sc->sc_shmem_map); bus_dmamem_unmap(sc->sc_dmat, sc->sc_shmem_addr, sc->sc_shmem_sz); bus_dmamem_free(sc->sc_dmat, &sc->sc_dma_segs, sc->sc_dma_rsegs); }
void rtwn_free_rx_list(struct rtwn_pci_softc *sc) { struct rtwn_rx_ring *rx_ring = &sc->rx_ring; struct rtwn_rx_data *rx_data; int i, s; s = splnet(); if (rx_ring->map) { if (rx_ring->desc) { bus_dmamap_unload(sc->sc_dmat, rx_ring->map); bus_dmamem_unmap(sc->sc_dmat, (caddr_t)rx_ring->desc, sizeof (struct r92c_rx_desc_pci) * RTWN_RX_LIST_COUNT); bus_dmamem_free(sc->sc_dmat, &rx_ring->seg, rx_ring->nsegs); rx_ring->desc = NULL; } bus_dmamap_destroy(sc->sc_dmat, rx_ring->map); rx_ring->map = NULL; } for (i = 0; i < RTWN_RX_LIST_COUNT; i++) { rx_data = &rx_ring->rx_data[i]; if (rx_data->m != NULL) { bus_dmamap_unload(sc->sc_dmat, rx_data->map); m_freem(rx_data->m); rx_data->m = NULL; } bus_dmamap_destroy(sc->sc_dmat, rx_data->map); rx_data->map = NULL; } splx(s); }
void tws_unmap_request(struct tws_softc *sc, struct tws_request *req) { if (req->data != NULL) { if ( req->flags & TWS_DIR_IN ) bus_dmamap_sync(sc->data_tag, req->dma_map, BUS_DMASYNC_POSTREAD); if ( req->flags & TWS_DIR_OUT ) bus_dmamap_sync(sc->data_tag, req->dma_map, BUS_DMASYNC_POSTWRITE); mtx_lock(&sc->io_lock); bus_dmamap_unload(sc->data_tag, req->dma_map); mtx_unlock(&sc->io_lock); } }
int lsi64854_detach(struct lsi64854_softc *sc) { if (sc->setup != NULL) { bus_dmamap_sync(sc->sc_buffer_dmat, sc->sc_dmamap, (L64854_GCSR(sc) & L64854_WRITE) != 0 ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); bus_dmamap_unload(sc->sc_buffer_dmat, sc->sc_dmamap); bus_dmamap_destroy(sc->sc_buffer_dmat, sc->sc_dmamap); bus_dma_tag_destroy(sc->sc_buffer_dmat); } return (0); }
void s3c2440_i2s_free(s3c2440_i2s_buf_t buf) { struct s3c2xx0_softc *sc = s3c2xx0_softc; /* Shortcut */ if (buf->i2b_xfer != NULL) { s3c2440_dmac_free_xfer(buf->i2b_xfer); } bus_dmamap_unload(sc->sc_dmat, buf->i2b_dmamap); bus_dmamap_destroy(sc->sc_dmat, buf->i2b_dmamap); bus_dmamem_unmap(sc->sc_dmat, &buf->i2b_addr, buf->i2b_size); bus_dmamem_free(sc->sc_dmat, buf->i2b_segs, buf->i2b_nsegs); kmem_free(buf, sizeof(struct s3c2440_i2s_buf)); }
/* * Free a TPD. If the mbuf pointer in that TPD is not zero, it is assumed, that * the DMA map of this TPD was used to load this mbuf. The map is unloaded * and the mbuf is freed. The TPD is put back onto the free list and * its used bit is cleared. */ static void hatm_free_tpd(struct hatm_softc *sc, struct tpd *tpd) { if (tpd->mbuf != NULL) { bus_dmamap_unload(sc->tx_tag, tpd->map); hatm_free_txmbuf(sc); m_freem(tpd->mbuf); tpd->mbuf = NULL; } /* insert TPD into free list */ SLIST_INSERT_HEAD(&sc->tpd_free, tpd, link); TPD_CLR_USED(sc, tpd->no); sc->tpd_nfree++; }
/** * ti_mmchs_intr_xfer_compl - called if a 'transfer complete' IRQ was received * @sc: pointer to the driver context * @cmd: the command that was sent previously * * This function is simply responsible for syncing up the DMA buffer. * * LOCKING: * Called from interrupt context * * RETURNS: * Return value indicates if the transaction is complete, not done = 0, done != 0 */ static int ti_mmchs_intr_xfer_compl(struct ti_mmchs_softc *sc, struct mmc_command *cmd) { uint32_t cmd_reg; /* Read command register to test whether this command was a read or write. */ cmd_reg = ti_mmchs_read_4(sc, MMCHS_CMD); /* Sync-up the DMA buffer so the caller can access the new memory */ if (cmd_reg & MMCHS_CMD_DDIR) { bus_dmamap_sync(sc->sc_dmatag, sc->sc_dmamap, BUS_DMASYNC_POSTREAD); bus_dmamap_unload(sc->sc_dmatag, sc->sc_dmamap); } else { bus_dmamap_sync(sc->sc_dmatag, sc->sc_dmamap, BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(sc->sc_dmatag, sc->sc_dmamap); } sc->sc_dmamapped--; /* Debugging dump of the data received */ #if 0 { int i; uint8_t *p = (uint8_t*) sc->sc_cmd_data_vaddr; for (i=0; i<sc->sc_cmd_data_len; i++) { if ((i % 16) == 0) printf("\n0x%04x : ", i); printf("%02X ", *p++); } printf("\n"); } #endif /* We are done, transfer complete */ return 1; }
/******************************************************************************** * Free a command cluster. */ static void mly_free_command_cluster(struct mly_command_cluster *mcc) { struct mly_softc *sc = mcc->mcc_command[0].mc_sc; int i; debug_called(1); for (i = 0; i < MLY_CMD_CLUSTERCOUNT; i++) bus_dmamap_destroy(sc->mly_buffer_dmat, mcc->mcc_command[i].mc_datamap); bus_dmamap_unload(sc->mly_packet_dmat, mcc->mcc_packetmap); bus_dmamem_free(sc->mly_packet_dmat, mcc->mcc_packet, mcc->mcc_packetmap); free(mcc, M_DEVBUF); }
void usb_block_real_freemem(usb_dma_block_t *p) { #ifdef DIAGNOSTIC if (!curproc) { printf("usb_block_real_freemem: in interrupt context\n"); return; } #endif bus_dmamap_unload(p->tag, p->map); bus_dmamap_destroy(p->tag, p->map); bus_dmamem_unmap(p->tag, p->kaddr, p->size); bus_dmamem_free(p->tag, p->segs, p->nsegs); free(p, M_USB); }
/* * Drain the receive queue. */ void epic_rxdrain(struct epic_softc *sc) { struct epic_descsoft *ds; int i; for (i = 0; i < EPIC_NRXDESC; i++) { ds = EPIC_DSRX(sc, i); if (ds->ds_mbuf != NULL) { bus_dmamap_unload(sc->sc_dmat, ds->ds_dmamap); m_freem(ds->ds_mbuf); ds->ds_mbuf = NULL; } } }
/* * Initialization of interface. */ void zeinit(struct ze_softc *sc) { struct ifnet *ifp = &sc->sc_if; struct ze_cdata *zc = sc->sc_zedata; int i; /* * Reset the interface. */ if (zereset(sc)) return; sc->sc_nexttx = sc->sc_inq = sc->sc_lastack = sc->sc_txcnt = 0; /* * Release and init transmit descriptors. */ for (i = 0; i < TXDESCS; i++) { if (sc->sc_xmtmap[i]->dm_nsegs > 0) bus_dmamap_unload(sc->sc_dmat, sc->sc_xmtmap[i]); if (sc->sc_txmbuf[i]) { m_freem(sc->sc_txmbuf[i]); sc->sc_txmbuf[i] = 0; } zc->zc_xmit[i].ze_tdr = 0; /* Clear valid bit */ } /* * Init receive descriptors. */ for (i = 0; i < RXDESCS; i++) zc->zc_recv[i].ze_framelen = ZE_FRAMELEN_OW; sc->sc_nextrx = 0; ZE_WCSR(ZE_CSR6, ZE_NICSR6_IE|ZE_NICSR6_BL_8|ZE_NICSR6_ST| ZE_NICSR6_SR|ZE_NICSR6_DC); ifp->if_flags |= IFF_RUNNING; ifp->if_flags &= ~IFF_OACTIVE; /* * Send a setup frame. * This will start the transmit machinery as well. */ ze_setup(sc); }
static int epe_intr(void *arg) { struct epe_softc *sc = (struct epe_softc *)arg; struct ifnet * ifp = &sc->sc_ec.ec_if; uint32_t ndq = 0, irq, *cur; irq = EPE_READ(IntStsC); begin: cur = (uint32_t *)(EPE_READ(RXStsQCurAdd) - sc->ctrlpage_dsaddr + (char*)sc->ctrlpage); CTRLPAGE_DMASYNC(TX_QLEN * 3 * sizeof(uint32_t), RX_QLEN * 4 * sizeof(uint32_t), BUS_DMASYNC_PREREAD); while (sc->RXStsQ_cur != cur) { if ((sc->RXStsQ_cur[0] & (RXStsQ_RWE|RXStsQ_RFP|RXStsQ_EOB)) == (RXStsQ_RWE|RXStsQ_RFP|RXStsQ_EOB)) { uint32_t bi = (sc->RXStsQ_cur[1] >> 16) & 0x7fff; uint32_t fl = sc->RXStsQ_cur[1] & 0xffff; struct mbuf *m; MGETHDR(m, M_DONTWAIT, MT_DATA); if (m != NULL) MCLGET(m, M_DONTWAIT); if (m != NULL && (m->m_flags & M_EXT)) { bus_dmamap_unload(sc->sc_dmat, sc->rxq[bi].m_dmamap); sc->rxq[bi].m->m_pkthdr.rcvif = ifp; sc->rxq[bi].m->m_pkthdr.len = sc->rxq[bi].m->m_len = fl; bpf_mtap(ifp, sc->rxq[bi].m); (*ifp->if_input)(ifp, sc->rxq[bi].m); sc->rxq[bi].m = m; bus_dmamap_load(sc->sc_dmat, sc->rxq[bi].m_dmamap, m->m_ext.ext_buf, MCLBYTES, NULL, BUS_DMA_NOWAIT); sc->RXDQ[bi * 2] = sc->rxq[bi].m_dmamap->dm_segs[0].ds_addr; } else { /* Drop packets until we can get replacement * empty mbufs for the RXDQ. */ if (m != NULL) { m_freem(m); } ifp->if_ierrors++; } } else {
/* * Function name: twa_free * Description: Performs clean-up at the time of going down. * * Input: sc -- ptr to per ctlr structure * Output: None * Return value: None */ static void twa_free(struct twa_softc *sc) { struct twa_request *tr; twa_dbg_dprint_enter(3, sc); /* Detach from CAM */ twa_cam_detach(sc); /* Destroy dma handles. */ bus_dmamap_unload(sc->twa_dma_tag, sc->twa_cmd_map); while ((tr = twa_dequeue_free(sc)) != NULL) bus_dmamap_destroy(sc->twa_dma_tag, tr->tr_dma_map); /* Free all memory allocated so far. */ if (sc->twa_req_buf) free(sc->twa_req_buf, TWA_MALLOC_CLASS); if (sc->twa_cmd_pkt_buf) bus_dmamem_free(sc->twa_dma_tag, sc->twa_cmd_pkt_buf, sc->twa_cmd_map); if (sc->twa_aen_queue[0]) free (sc->twa_aen_queue[0], M_DEVBUF); /* Destroy the data-transfer DMA tag. */ if (sc->twa_dma_tag) bus_dma_tag_destroy(sc->twa_dma_tag); /* Disconnect the interrupt handler. */ if (sc->twa_intr_handle) bus_teardown_intr(sc->twa_bus_dev, sc->twa_irq_res, sc->twa_intr_handle); if (sc->twa_irq_res != NULL) bus_release_resource(sc->twa_bus_dev, SYS_RES_IRQ, 0, sc->twa_irq_res); /* Release the register window mapping. */ if (sc->twa_io_res != NULL) bus_release_resource(sc->twa_bus_dev, SYS_RES_IOPORT, TWA_IO_CONFIG_REG, sc->twa_io_res); /* Destroy the control device. */ if (sc->twa_ctrl_dev != (struct cdev *)NULL) destroy_dev(sc->twa_ctrl_dev); sysctl_ctx_free(&sc->twa_sysctl_ctx); }
static void ips_ioctl_finish(ips_command_t *command) { ips_ioctl_t *ioctl_cmd = command->arg; if(ioctl_cmd->readwrite & IPS_IOCTL_READ){ bus_dmamap_sync(ioctl_cmd->dmatag, ioctl_cmd->dmamap, BUS_DMASYNC_POSTREAD); } else if(ioctl_cmd->readwrite & IPS_IOCTL_WRITE){ bus_dmamap_sync(ioctl_cmd->dmatag, ioctl_cmd->dmamap, BUS_DMASYNC_POSTWRITE); } bus_dmamap_sync(command->sc->command_dmatag, command->command_dmamap, BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(ioctl_cmd->dmatag, ioctl_cmd->dmamap); ioctl_cmd->status.value = command->status.value; ips_insert_free_cmd(command->sc, command); }
int s3c2440_i2s_halt_output(s3c2440_i2s_buf_t buf) { /*int retval;*/ struct s3c2xx0_softc *sc = s3c2xx0_softc; /* Shortcut */ DPRINTF(("Aborting DMA transfer\n")); /*do { retval =*/ s3c2440_dmac_abort_xfer(buf->i2b_xfer); /*} while(retval != 0);*/ DPRINTF(("Aborting DMA transfer: SUCCESS\n")); bus_dmamap_unload(sc->sc_dmat, buf->i2b_dmamap); return 0; }
static void asc_dma_reset(struct ncr53c9x_softc *sc) { struct asc_softc *esc = (struct asc_softc *)sc; bus_space_write_2(esc->sc_bst, esc->dm_bsh, RAMBO_BLKCNT, 0); bus_space_write_4(esc->sc_bst, esc->dm_bsh, RAMBO_MODE, RB_CLRFIFO|RB_CLRERROR); DELAY(10); bus_space_write_4(esc->sc_bst, esc->dm_bsh, RAMBO_MODE, 0); if (esc->sc_flags & DMA_MAPLOADED) bus_dmamap_unload(esc->sc_dmat, esc->sc_dmamap); esc->sc_flags = DMA_IDLE; }
void asc_vsbus_dma_stop(struct ncr53c9x_softc *sc) { struct asc_vsbus_softc *asc = (struct asc_vsbus_softc *)sc; if (asc->sc_flags & ASC_MAPLOADED) { bus_dmamap_sync(asc->sc_dmat, asc->sc_dmamap, 0, asc->sc_dmasize, asc->sc_flags & ASC_FROMMEMORY ? BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD); bus_dmamap_unload(asc->sc_dmat, asc->sc_dmamap); } asc->sc_flags &= ~(ASC_DMAACTIVE|ASC_MAPLOADED); }
static int epe_gctx(struct epe_softc *sc) { struct ifnet * ifp = &sc->sc_ec.ec_if; uint32_t *cur, ndq = 0; /* Handle transmit completions */ cur = (uint32_t *)(EPE_READ(TXStsQCurAdd) - sc->ctrlpage_dsaddr + (char*)sc->ctrlpage); if (sc->TXStsQ_cur != cur) { CTRLPAGE_DMASYNC(TX_QLEN * 2 * sizeof(uint32_t), TX_QLEN * sizeof(uint32_t), BUS_DMASYNC_PREREAD); } else { return 0; } do { uint32_t tbi = *sc->TXStsQ_cur & 0x7fff; struct mbuf *m = sc->txq[tbi].m; if ((*sc->TXStsQ_cur & TXStsQ_TxWE) == 0) { ifp->if_oerrors++; } bus_dmamap_unload(sc->sc_dmat, sc->txq[tbi].m_dmamap); m_freem(m); do { sc->txq[tbi].m = NULL; ndq++; tbi = (tbi + 1) % TX_QLEN; } while (sc->txq[tbi].m == m); ifp->if_opackets++; sc->TXStsQ_cur++; if (sc->TXStsQ_cur >= sc->TXStsQ + TX_QLEN) { sc->TXStsQ_cur = sc->TXStsQ; } } while (sc->TXStsQ_cur != cur); sc->TXDQ_avail += ndq; if (ifp->if_flags & IFF_OACTIVE) { ifp->if_flags &= ~IFF_OACTIVE; /* Disable end-of-tx-chain interrupt */ EPE_WRITE(IntEn, IntEn_REOFIE); } return ndq; }