From 9b4beec14520a491e35789432236e09e41fc902f Mon Sep 17 00:00:00 2001 From: Jason Wright Date: Tue, 12 Aug 2003 23:08:47 +0000 Subject: - Don't need the bus_dma callback cruft as we have everything necessary in the map structure. - pull in some of sam's debugging stuff so that #define SAFE_DEBUG will compile - set the dst <- src when uio && nicealign && uniform --- sys/dev/pci/safe.c | 169 ++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 130 insertions(+), 39 deletions(-) (limited to 'sys/dev/pci/safe.c') diff --git a/sys/dev/pci/safe.c b/sys/dev/pci/safe.c index a01ff52af2f..69d7a9eb173 100644 --- a/sys/dev/pci/safe.c +++ b/sys/dev/pci/safe.c @@ -1,4 +1,4 @@ -/* $OpenBSD: safe.c,v 1.2 2003/08/12 20:40:19 jason Exp $ */ +/* $OpenBSD: safe.c,v 1.3 2003/08/12 23:08:46 jason Exp $ */ /*- * Copyright (c) 2003 Sam Leffler, Errno Consulting @@ -107,19 +107,17 @@ void safe_totalreset(struct safe_softc *); __inline u_int32_t safe_rng_read(struct safe_softc *); int safe_free_entry(struct safe_softc *, struct safe_ringentry *); -void safe_op_cb(void *, bus_dma_segment_t *, int, bus_size_t, int); #ifdef SAFE_DEBUG +int safe_debug; +#define DPRINTF(_x) if (safe_debug) printf _x + void safe_dump_dmastatus(struct safe_softc *, const char *); -void safe_dump_ringstate(struct safe_softc *, const char *); void safe_dump_intrstate(struct safe_softc *, const char *); +void safe_dump_ringstate(struct safe_softc *, const char *); void safe_dump_request(struct safe_softc *, const char *, - struct safe_ringentry *); - -int safe_debug = 0; -SYSCTL_INT(_hw_safe, OID_AUTO, debug, CTLFLAG_RW, &safe_debug, - 0, "control debugging msgs"); -#define DPRINTF(_x) if (safe_debug) printf _x + struct safe_ringentry *); +void safe_dump_ring(struct safe_softc *sc, const char *tag); #else #define DPRINTF(_x) #endif @@ -663,14 +661,12 @@ safe_process(struct cryptop *crp) goto errout; } } - safe_op_cb(&re->re_src, re->re_src_map->dm_segs, - re->re_src_map->dm_nsegs, re->re_src_map->dm_mapsize, 0); nicealign = safe_dmamap_aligned(&re->re_src); uniform = safe_dmamap_uniform(&re->re_src); DPRINTF(("src nicealign %u uniform %u nsegs %u\n", - nicealign, uniform, re->re_src.nsegs)); - if (re->re_src.nsegs > 1) { + nicealign, uniform, re->re_src_nsegs)); + if (re->re_src_nsegs > 1) { re->re_desc.d_src = sc->sc_spalloc.dma_paddr + ((caddr_t) sc->sc_spfree - (caddr_t) sc->sc_spring); for (i = 0; i < re->re_src_nsegs; i++) { @@ -751,7 +747,8 @@ safe_process(struct cryptop *crp) err = EINVAL; goto errout; } - } + } else + re->re_dst = re->re_src; } else if (crp->crp_flags & CRYPTO_F_IMBUF) { if (nicealign && uniform == 1) { /* @@ -906,9 +903,7 @@ safe_process(struct cryptop *crp) goto errout; } - safe_op_cb(&re->re_dst, re->re_dst_map->dm_segs, - re->re_dst_map->dm_nsegs, re->re_dst_map->dm_mapsize, 0); - if (re->re_dst.nsegs > 1) { + if (re->re_dst_nsegs > 1) { re->re_desc.d_dst = sc->sc_dpalloc.dma_paddr + ((caddr_t) sc->sc_dpfree - (caddr_t) sc->sc_dpring); for (i = 0; i < re->re_dst_nsegs; i++) { @@ -995,17 +990,18 @@ void safe_reset_board(struct safe_softc *sc) { u_int32_t v; + /* * Reset the device. The manual says no delay * is needed between marking and clearing reset. */ - v = READ_REG(sc, SAFE_PE_DMACFG) &~ - (SAFE_PE_DMACFG_PERESET | SAFE_PE_DMACFG_PDRRESET | - SAFE_PE_DMACFG_SGRESET); + v = READ_REG(sc, SAFE_PE_DMACFG) & + ~(SAFE_PE_DMACFG_PERESET | SAFE_PE_DMACFG_PDRRESET | + SAFE_PE_DMACFG_SGRESET); WRITE_REG(sc, SAFE_PE_DMACFG, v - | SAFE_PE_DMACFG_PERESET - | SAFE_PE_DMACFG_PDRRESET - | SAFE_PE_DMACFG_SGRESET); + | SAFE_PE_DMACFG_PERESET + | SAFE_PE_DMACFG_PDRRESET + | SAFE_PE_DMACFG_SGRESET); WRITE_REG(sc, SAFE_PE_DMACFG, v); } @@ -1475,10 +1471,11 @@ safe_dmamap_aligned(const struct safe_operand *op) { int i; - for (i = 0; i < op->nsegs; i++) { - if (op->segs[i].ds_addr & 3) + for (i = 0; i < op->map->dm_nsegs; i++) { + if (op->map->dm_segs[i].ds_addr & 3) return (0); - if (i != (op->nsegs - 1) && (op->segs[i].ds_len & 3)) + if (i != (op->map->dm_nsegs - 1) && + (op->map->dm_segs[i].ds_len & 3)) return (0); } return (1); @@ -1574,13 +1571,13 @@ safe_dmamap_uniform(const struct safe_operand *op) { int result = 1; - if (op->nsegs > 0) { + if (op->map->dm_nsegs > 0) { int i; - for (i = 0; i < op->nsegs-1; i++) { - if (op->segs[i].ds_len % SAFE_MAX_DSIZE) + for (i = 0; i < op->map->dm_nsegs-1; i++) { + if (op->map->dm_segs[i].ds_len % SAFE_MAX_DSIZE) return (0); - if (op->segs[i].ds_len != SAFE_MAX_DSIZE) + if (op->map->dm_segs[i].ds_len != SAFE_MAX_DSIZE) result = 2; } } @@ -1795,17 +1792,111 @@ safe_intr(void *arg) return (1); } +#ifdef SAFE_DEBUG + void -safe_op_cb(void *arg, bus_dma_segment_t *seg, int nsegs, - bus_size_t mapsize, int error) +safe_dump_dmastatus(struct safe_softc *sc, const char *tag) { - struct safe_operand *op = arg; + printf("%s: ENDIAN 0x%x SRC 0x%x DST 0x%x STAT 0x%x\n", tag, + READ_REG(sc, SAFE_DMA_ENDIAN), READ_REG(sc, SAFE_DMA_SRCADDR), + READ_REG(sc, SAFE_DMA_DSTADDR), READ_REG(sc, SAFE_DMA_STAT)); +} - DPRINTF(("%s: mapsize %u nsegs %d error %d\n", __func__, - (u_int) mapsize, nsegs, error)); - if (error != 0) - return; - op->nsegs = nsegs; - bcopy(seg, op->segs, nsegs * sizeof (seg[0])); +void +safe_dump_intrstate(struct safe_softc *sc, const char *tag) +{ + printf("%s: HI_CFG 0x%x HI_MASK 0x%x HI_DESC_CNT 0x%x HU_STAT 0x%x HM_STAT 0x%x\n", + tag, READ_REG(sc, SAFE_HI_CFG), READ_REG(sc, SAFE_HI_MASK), + READ_REG(sc, SAFE_HI_DESC_CNT), READ_REG(sc, SAFE_HU_STAT), + READ_REG(sc, SAFE_HM_STAT)); +} + +void +safe_dump_ringstate(struct safe_softc *sc, const char *tag) +{ + u_int32_t estat = READ_REG(sc, SAFE_PE_ERNGSTAT); + + /* NB: assume caller has lock on ring */ + printf("%s: ERNGSTAT %x (next %u) back %u front %u\n", + tag, estat, (estat >> SAFE_PE_ERNGSTAT_NEXT_S), + sc->sc_back - sc->sc_ring, sc->sc_front - sc->sc_ring); +} + +void +safe_dump_request(struct safe_softc *sc, const char* tag, struct safe_ringentry *re) +{ + int ix, nsegs; + + ix = re - sc->sc_ring; + printf("%s: %p (%u): csr %x src %x dst %x sa %x len %x\n", tag, + re, ix, re->re_desc.d_csr, re->re_desc.d_src, re->re_desc.d_dst, + re->re_desc.d_sa, re->re_desc.d_len); + if (re->re_src_nsegs > 1) { + ix = (re->re_desc.d_src - sc->sc_spalloc.dma_paddr) / + sizeof(struct safe_pdesc); + for (nsegs = re->re_src_nsegs; nsegs; nsegs--) { + printf(" spd[%u] %p: %p size %u flags %x", ix, + &sc->sc_spring[ix], + (caddr_t)sc->sc_spring[ix].pd_addr, + sc->sc_spring[ix].pd_size, + sc->sc_spring[ix].pd_flags); + if (sc->sc_spring[ix].pd_size == 0) + printf(" (zero!)"); + printf("\n"); + if (++ix == SAFE_TOTAL_SPART) + ix = 0; + } + } + if (re->re_dst_nsegs > 1) { + ix = (re->re_desc.d_dst - sc->sc_dpalloc.dma_paddr) / + sizeof(struct safe_pdesc); + for (nsegs = re->re_dst_nsegs; nsegs; nsegs--) { + printf(" dpd[%u] %p: %p flags %x\n", ix, + &sc->sc_dpring[ix], + (caddr_t) sc->sc_dpring[ix].pd_addr, + sc->sc_dpring[ix].pd_flags); + if (++ix == SAFE_TOTAL_DPART) + ix = 0; + } + } + printf("sa: cmd0 %08x cmd1 %08x staterec %x\n", + re->re_sa.sa_cmd0, re->re_sa.sa_cmd1, re->re_sa.sa_staterec); + printf("sa: key %x %x %x %x %x %x %x %x\n", re->re_sa.sa_key[0], + re->re_sa.sa_key[1], re->re_sa.sa_key[2], re->re_sa.sa_key[3], + re->re_sa.sa_key[4], re->re_sa.sa_key[5], re->re_sa.sa_key[6], + re->re_sa.sa_key[7]); + printf("sa: indigest %x %x %x %x %x\n", re->re_sa.sa_indigest[0], + re->re_sa.sa_indigest[1], re->re_sa.sa_indigest[2], + re->re_sa.sa_indigest[3], re->re_sa.sa_indigest[4]); + printf("sa: outdigest %x %x %x %x %x\n", re->re_sa.sa_outdigest[0], + re->re_sa.sa_outdigest[1], re->re_sa.sa_outdigest[2], + re->re_sa.sa_outdigest[3], re->re_sa.sa_outdigest[4]); + printf("sr: iv %x %x %x %x\n", + re->re_sastate.sa_saved_iv[0], re->re_sastate.sa_saved_iv[1], + re->re_sastate.sa_saved_iv[2], re->re_sastate.sa_saved_iv[3]); + printf("sr: hashbc %u indigest %x %x %x %x %x\n", + re->re_sastate.sa_saved_hashbc, + re->re_sastate.sa_saved_indigest[0], + re->re_sastate.sa_saved_indigest[1], + re->re_sastate.sa_saved_indigest[2], + re->re_sastate.sa_saved_indigest[3], + re->re_sastate.sa_saved_indigest[4]); } +void +safe_dump_ring(struct safe_softc *sc, const char *tag) +{ + printf("\nSafeNet Ring State:\n"); + safe_dump_intrstate(sc, tag); + safe_dump_dmastatus(sc, tag); + safe_dump_ringstate(sc, tag); + if (sc->sc_nqchip) { + struct safe_ringentry *re = sc->sc_back; + do { + safe_dump_request(sc, tag, re); + if (++re == sc->sc_ringtop) + re = sc->sc_ring; + } while (re != sc->sc_front); + } +} +#endif /* SAFE_DEBUG */ -- cgit v1.2.3