Annotation of sys/arch/sparc/dev/qec.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: qec.c,v 1.17 2006/06/02 20:00:54 miod Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1998 Theo de Raadt and Jason L. Wright.
! 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. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 19: * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! 20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 26: */
! 27:
! 28: #include <sys/types.h>
! 29: #include <sys/param.h>
! 30: #include <sys/systm.h>
! 31: #include <sys/kernel.h>
! 32: #include <sys/errno.h>
! 33: #include <sys/ioctl.h>
! 34: #include <sys/device.h>
! 35: #include <sys/malloc.h>
! 36: #include <sys/buf.h>
! 37: #include <sys/proc.h>
! 38: #include <sys/user.h>
! 39: #include <sys/mbuf.h>
! 40: #include <sys/socket.h>
! 41:
! 42: #include <net/if.h>
! 43: #include <net/if_dl.h>
! 44: #include <net/if_types.h>
! 45: #include <net/netisr.h>
! 46: #include <net/if_media.h>
! 47:
! 48: #ifdef INET
! 49: #include <netinet/in.h>
! 50: #include <netinet/in_systm.h>
! 51: #include <netinet/in_var.h>
! 52: #include <netinet/ip.h>
! 53: #include <netinet/if_ether.h>
! 54: #endif
! 55:
! 56: #include <sparc/autoconf.h>
! 57: #include <sparc/cpu.h>
! 58:
! 59: #include <sparc/dev/sbusvar.h>
! 60: #include <sparc/dev/dmareg.h>
! 61: #include <sparc/dev/qecreg.h>
! 62: #include <sparc/dev/qecvar.h>
! 63:
! 64: int qecprint(void *, const char *);
! 65: int qecmatch(struct device *, void *, void *);
! 66: void qecattach(struct device *, struct device *, void *);
! 67: void qec_fix_range(struct qec_softc *, struct sbus_softc *);
! 68: void qec_translate(struct qec_softc *, struct confargs *);
! 69:
! 70: struct cfattach qec_ca = {
! 71: sizeof(struct qec_softc), qecmatch, qecattach
! 72: };
! 73:
! 74: struct cfdriver qec_cd = {
! 75: NULL, "qec", DV_DULL
! 76: };
! 77:
! 78: int
! 79: qecprint(aux, name)
! 80: void *aux;
! 81: const char *name;
! 82: {
! 83: register struct confargs *ca = aux;
! 84:
! 85: if (name)
! 86: printf("%s at %s", ca->ca_ra.ra_name, name);
! 87: printf(" offset 0x%x", ca->ca_offset);
! 88: return (UNCONF);
! 89: }
! 90:
! 91: /*
! 92: * match a QEC device in a slot capable of DMA
! 93: */
! 94: int
! 95: qecmatch(parent, vcf, aux)
! 96: struct device *parent;
! 97: void *vcf, *aux;
! 98: {
! 99: struct cfdata *cf = vcf;
! 100: struct confargs *ca = aux;
! 101: struct romaux *ra = &ca->ca_ra;
! 102:
! 103: if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
! 104: return (0);
! 105:
! 106: if (!sbus_testdma((struct sbus_softc *)parent, ca))
! 107: return (0);
! 108:
! 109: return (1);
! 110: }
! 111:
! 112: /*
! 113: * Attach all the sub-devices we can find
! 114: */
! 115: void
! 116: qecattach(parent, self, aux)
! 117: struct device *parent, *self;
! 118: void *aux;
! 119: {
! 120: register struct confargs *ca = aux;
! 121: struct qec_softc *sc = (void *)self;
! 122: int node;
! 123: struct confargs oca;
! 124: char *name;
! 125: int sbusburst;
! 126:
! 127: /*
! 128: * The first i/o space is the qec global registers, and
! 129: * the second is a buffer used by the qec channels internally.
! 130: * (It's not necessary to map the second i/o space, but knowing
! 131: * its size is necessary).
! 132: */
! 133: sc->sc_regs = mapiodev(&ca->ca_ra.ra_reg[0], 0,
! 134: sizeof(struct qecregs));
! 135: sc->sc_bufsiz = ca->ca_ra.ra_reg[1].rr_len;
! 136: sc->sc_paddr = ca->ca_ra.ra_reg[0].rr_paddr;
! 137:
! 138: /*
! 139: * On qec+qe, the qec has the interrupt priority, but we
! 140: * need to pass that down so that the qe's can handle them.
! 141: */
! 142: if (ca->ca_ra.ra_nintr == 1)
! 143: sc->sc_pri = ca->ca_ra.ra_intr[0].int_pri;
! 144:
! 145: node = sc->sc_node = ca->ca_ra.ra_node;
! 146:
! 147: qec_fix_range(sc, (struct sbus_softc *)parent);
! 148:
! 149: /*
! 150: * Get transfer burst size from PROM
! 151: */
! 152: sbusburst = ((struct sbus_softc *)parent)->sc_burst;
! 153: if (sbusburst == 0)
! 154: sbusburst = SBUS_BURST_32 - 1; /* 1->16 */
! 155:
! 156: sc->sc_nchannels = getpropint(ca->ca_ra.ra_node, "#channels", -1);
! 157: if (sc->sc_nchannels == -1) {
! 158: printf(": no channels\n");
! 159: return;
! 160: }
! 161: else if (sc->sc_nchannels < 1 || sc->sc_nchannels > 4) {
! 162: printf(": invalid number of channels: %d\n", sc->sc_nchannels);
! 163: return;
! 164: }
! 165:
! 166: sc->sc_burst = getpropint(ca->ca_ra.ra_node, "burst-sizes", -1);
! 167: if (sc->sc_burst == -1)
! 168: /* take SBus burst sizes */
! 169: sc->sc_burst = sbusburst;
! 170:
! 171: /* Clamp at parent's burst sizes */
! 172: sc->sc_burst &= sbusburst;
! 173:
! 174: printf(": %dK memory %d channel%s",
! 175: sc->sc_bufsiz / 1024, sc->sc_nchannels,
! 176: (sc->sc_nchannels == 1) ? "" : "s");
! 177:
! 178: node = sc->sc_node = ca->ca_ra.ra_node;
! 179:
! 180: /* Propagate bootpath */
! 181: if (ca->ca_ra.ra_bp != NULL)
! 182: oca.ca_ra.ra_bp = ca->ca_ra.ra_bp + 1;
! 183: else
! 184: oca.ca_ra.ra_bp = NULL;
! 185:
! 186: printf("\n");
! 187:
! 188: qec_reset(sc);
! 189:
! 190: /* search through children */
! 191: for (node = firstchild(node); node; node = nextsibling(node)) {
! 192: name = getpropstring(node, "name");
! 193: if (!romprop(&oca.ca_ra, name, node))
! 194: continue;
! 195:
! 196: qec_translate(sc, &oca);
! 197: oca.ca_bustype = BUS_SBUS;
! 198: (void) config_found(&sc->sc_dev, (void *)&oca, qecprint);
! 199: }
! 200: }
! 201:
! 202: void
! 203: qec_fix_range(sc, sbp)
! 204: struct qec_softc *sc;
! 205: struct sbus_softc *sbp;
! 206: {
! 207: int rlen, i, j;
! 208:
! 209: rlen = getproplen(sc->sc_node, "ranges");
! 210: sc->sc_range =
! 211: (struct rom_range *)malloc(rlen, M_DEVBUF, M_NOWAIT);
! 212: if (sc->sc_range == NULL) {
! 213: printf("%s: PROM ranges too large: %d\n",
! 214: sc->sc_dev.dv_xname, rlen);
! 215: return;
! 216: }
! 217: sc->sc_nrange = rlen / sizeof(struct rom_range);
! 218: (void)getprop(sc->sc_node, "ranges", sc->sc_range, rlen);
! 219:
! 220: for (i = 0; i < sc->sc_nrange; i++) {
! 221: for (j = 0; j < sbp->sc_nrange; j++) {
! 222: if (sc->sc_range[i].pspace == sbp->sc_range[j].cspace) {
! 223: sc->sc_range[i].poffset +=
! 224: sbp->sc_range[j].poffset;
! 225: sc->sc_range[i].pspace =
! 226: sbp->sc_range[j].pspace;
! 227: break;
! 228: }
! 229: }
! 230: }
! 231: }
! 232:
! 233: /*
! 234: * Translate the register addresses of our children
! 235: */
! 236: void
! 237: qec_translate(sc, ca)
! 238: struct qec_softc *sc;
! 239: struct confargs *ca;
! 240: {
! 241: register int i;
! 242:
! 243: ca->ca_slot = ca->ca_ra.ra_iospace;
! 244: ca->ca_offset = sc->sc_range[ca->ca_slot].poffset - (long)sc->sc_paddr;
! 245:
! 246: /* Translate into parent address spaces */
! 247: for (i = 0; i < ca->ca_ra.ra_nreg; i++) {
! 248: int j, cspace = ca->ca_ra.ra_reg[i].rr_iospace;
! 249:
! 250: for (j = 0; j < sc->sc_nrange; j++) {
! 251: if (sc->sc_range[j].cspace == cspace) {
! 252: (int)ca->ca_ra.ra_reg[i].rr_paddr +=
! 253: sc->sc_range[j].poffset;
! 254: (int)ca->ca_ra.ra_reg[i].rr_iospace =
! 255: sc->sc_range[j].pspace;
! 256: break;
! 257: }
! 258: }
! 259: }
! 260: }
! 261:
! 262: /*
! 263: * Reset the QEC and initialize its global registers.
! 264: */
! 265: void
! 266: qec_reset(sc)
! 267: struct qec_softc *sc;
! 268: {
! 269: struct qecregs *qr = sc->sc_regs;
! 270: int i = 200;
! 271:
! 272: qr->ctrl = QEC_CTRL_RESET;
! 273: while (--i) {
! 274: if ((qr->ctrl & QEC_CTRL_RESET) == 0)
! 275: break;
! 276: DELAY(20);
! 277: }
! 278: if (i == 0) {
! 279: printf("%s: reset failed.\n", sc->sc_dev.dv_xname);
! 280: return;
! 281: }
! 282:
! 283: qr->msize = sc->sc_bufsiz / sc->sc_nchannels;
! 284: sc->sc_msize = qr->msize;
! 285:
! 286: qr->rsize = sc->sc_bufsiz / (sc->sc_nchannels * 2);
! 287: sc->sc_rsize = qr->rsize;
! 288:
! 289: qr->tsize = sc->sc_bufsiz / (sc->sc_nchannels * 2);
! 290:
! 291: qr->psize = QEC_PSIZE_2048;
! 292:
! 293: if (sc->sc_burst & SBUS_BURST_64)
! 294: i = QEC_CTRL_B64;
! 295: else if (sc->sc_burst & SBUS_BURST_32)
! 296: i = QEC_CTRL_B32;
! 297: else
! 298: i = QEC_CTRL_B16;
! 299:
! 300: qr->ctrl = (qr->ctrl & QEC_CTRL_MODEMASK) | i;
! 301: }
! 302:
! 303: /*
! 304: * Routine to copy from mbuf chain to transmit buffer in
! 305: * network buffer memory.
! 306: */
! 307: int
! 308: qec_put(buf, m0)
! 309: u_int8_t *buf;
! 310: struct mbuf *m0;
! 311: {
! 312: struct mbuf *m;
! 313: int len, tlen = 0;
! 314:
! 315: for (m = m0; m != NULL; m = m->m_next) {
! 316: len = m->m_len;
! 317: bcopy(mtod(m, caddr_t), buf, len);
! 318: buf += len;
! 319: tlen += len;
! 320: }
! 321: m_freem(m0);
! 322: return (tlen);
! 323: }
! 324:
! 325: /*
! 326: * Pull data off an interface.
! 327: * Len is the length of data, with local net header stripped.
! 328: * We copy the data into mbufs. When full cluster sized units are present,
! 329: * we copy into clusters.
! 330: */
! 331: struct mbuf *
! 332: qec_get(ifp, buf, totlen)
! 333: struct ifnet *ifp;
! 334: u_int8_t *buf;
! 335: int totlen;
! 336: {
! 337: struct mbuf *m, *top, **mp;
! 338: int len, pad;
! 339:
! 340: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 341: if (m == NULL)
! 342: return (NULL);
! 343: m->m_pkthdr.rcvif = ifp;
! 344: m->m_pkthdr.len = totlen;
! 345: pad = ALIGN(sizeof(struct ether_header)) - sizeof(struct ether_header);
! 346: len = MHLEN;
! 347: if (totlen >= MINCLSIZE) {
! 348: MCLGET(m, M_DONTWAIT);
! 349: if (m->m_flags & M_EXT)
! 350: len = MCLBYTES;
! 351: }
! 352: m->m_data += pad;
! 353: len -= pad;
! 354: top = NULL;
! 355: mp = ⊤
! 356:
! 357: while (totlen > 0) {
! 358: if (top) {
! 359: MGET(m, M_DONTWAIT, MT_DATA);
! 360: if (m == NULL) {
! 361: m_freem(top);
! 362: return NULL;
! 363: }
! 364: len = MLEN;
! 365: }
! 366: if (top && totlen >= MINCLSIZE) {
! 367: MCLGET(m, M_DONTWAIT);
! 368: if (m->m_flags & M_EXT)
! 369: len = MCLBYTES;
! 370: }
! 371: m->m_len = len = min(totlen, len);
! 372: bcopy(buf, mtod(m, caddr_t), len);
! 373: buf += len;
! 374: totlen -= len;
! 375: *mp = m;
! 376: mp = &m->m_next;
! 377: }
! 378:
! 379: return (top);
! 380: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to qec.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / dev