/* $NetBSD: maple.c,v 1.9 2001/07/22 15:46:41 wiz Exp $ */ /*- * Copyright (c) 2001 Marcus Comstedt * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Marcus Comstedt. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Internal macros, functions, and variables. */ #define MAPLE_CALLOUT_TICKS 2 #define MAPLEBUSUNIT(dev) (minor(dev)>>5) #define MAPLEPORT(dev) ((minor(dev) & 0x18) >> 3) #define MAPLESUBUNIT(dev) (minor(dev) & 0x7) /* * Function declarations. */ static int maplematch __P((struct device *, struct cfdata *, void *)); static void mapleattach __P((struct device *, struct device *, void *)); static int mapleprint __P((void *, const char *)); static int maplesubmatch __P((struct device *, struct cfdata *, void *)); static void maple_attach_dev __P((struct maple_softc *, int, int)); static void maple_begin_txbuf __P((struct maple_softc *)); static int maple_end_txbuf __P((struct maple_softc *)); static void maple_write_command __P((struct maple_softc *, int, int, int, int, void *)); static void maple_scanbus __P((struct maple_softc *)); static void maple_callout __P((void *)); static void maple_send_commands __P((struct maple_softc *)); static void maple_check_responses __P((struct maple_softc *)); int maple_alloc_dma __P((size_t, vaddr_t *, paddr_t *)); void maple_free_dma __P((paddr_t, size_t)); int mapleopen __P((dev_t, int, int, struct proc *)); int mapleclose __P((dev_t, int, int, struct proc *)); int maple_internal_ioctl __P((struct maple_softc *, int, int, u_long, caddr_t, int, struct proc *)); int mapleioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); /* * Global variables. */ int maple_polling = 0; /* Are we polling? (Debugger mode) */ /* * Driver definition. */ struct cfattach maple_ca = { sizeof(struct maple_softc), maplematch, mapleattach }; extern struct cfdriver maple_cd; static int maplematch(parent, cf, aux) struct device *parent; struct cfdata *cf; void *aux; { struct shb_attach_args *sa = aux; if (strcmp("maple", cf->cf_driver->cd_name)) return (0); sa->ia_iosize = 0 /* 0x100 */; return (1); } static void maple_attach_dev(sc, port, subunit) struct maple_softc *sc; int port; int subunit; { struct maple_attach_args ma; u_int32_t func; int f; char oldxname[16]; ma.ma_port = port; ma.ma_subunit = subunit; ma.ma_devinfo = &sc->sc_unit[port][subunit].devinfo; ma.ma_function = 1; func = ma.ma_devinfo->di_func; mapleprint(&ma, sc->sc_dev.dv_xname); printf("\n"); strcpy(oldxname, sc->sc_dev.dv_xname); sprintf(sc->sc_dev.dv_xname, "maple%c", port+'A'); if(subunit) sprintf(sc->sc_dev.dv_xname+6, "%d", subunit); for(f=0; f<32; f++, ma.ma_function<<=1) if(func & ma.ma_function) (void) config_found_sm(&sc->sc_dev, &ma, NULL, maplesubmatch); strcpy(sc->sc_dev.dv_xname, oldxname); } static void maple_begin_txbuf(sc) struct maple_softc *sc; { sc->sc_txlink = sc->sc_txpos = sc->sc_txbuf; } static int maple_end_txbuf(sc) struct maple_softc *sc; { /* if no frame have been written, we can't mark the list end, and so the DMA must not be activated */ if (sc->sc_txpos == sc->sc_txbuf) return (0); *sc->sc_txlink |= 0x80000000; return (1); } static int8_t subunit_code[] = { 0x20, 0x01, 0x02, 0x04, 0x08, 0x10 }; static void maple_write_command(sc, port, subunit, command, datalen, dataaddr) struct maple_softc *sc; int port; int subunit; int command; int datalen; void *dataaddr; { int to, from; u_int32_t *p = sc->sc_txpos; if ((port & ~(MAPLE_PORTS-1)) != 0 || subunit < 0 || subunit >= MAPLE_SUBUNITS) return; /* Compute sender and recipient address */ from = port << 6; to = from | subunit_code[subunit]; /* Max data length = 255 longs = 1020 bytes */ if(datalen > 255) datalen = 255; else if(datalen < 0) datalen = 0; sc->sc_txlink = p; /* Set length of packet and destination port (A-D) */ *p++ = datalen | (port << 16); /* Write address to receive buffer where the response frame should be put */ *p++ = sc->sc_rxbuf_phys[port][subunit]; /* Create the frame header. The fields are assembled "backwards" because of the Maple Bus big-endianness. */ *p++ = (command & 0xff) | (to << 8) | (from << 16) | (datalen << 24); /* Copy parameter data, if any */ if (datalen > 0) { u_int32_t *param = dataaddr; int i; for (i = 0; i < datalen; i++) *p++ = *param++; } sc->sc_txpos = p; } static void maple_scanbus(sc) struct maple_softc *sc; { int p, s; maple_polling = 1; maple_begin_txbuf(sc); for (p = 0; p < MAPLE_PORTS; p++) { maple_write_command(sc, p, 0, MAPLE_COMMAND_DEVINFO, 0, NULL); } if (maple_end_txbuf(sc)) { MAPLE_DMAADDR = sc->sc_txbuf_phys; MAPLE_STATE = 1; while (MAPLE_STATE != 0) ; for (p = 0; p < MAPLE_PORTS; p++) if ((sc->sc_rxbuf[p][0][0] & 0xff) == MAPLE_RESPONSE_DEVINFO) sc->sc_port_units[p] = ((sc->sc_rxbuf[p][0][0]>>15)&0x3e)|1; else sc->sc_port_units[p] = 0; maple_begin_txbuf(sc); for (p = 0; p < MAPLE_PORTS; p++) { for (s = 0; s < MAPLE_SUBUNITS; s++) { if (sc->sc_port_units[p] & (1<sc_txbuf_phys; MAPLE_STATE = 1; while (MAPLE_STATE != 0) ; for (p = 0; p < MAPLE_PORTS; p++) for (s = 0; s < MAPLE_SUBUNITS; s++) if (sc->sc_port_units[p] & (1<sc_rxbuf[p][s][0] & 0xff) == MAPLE_RESPONSE_DEVINFO) { u_int32_t *to_swap; int i; memcpy((to_swap = &sc->sc_unit[p][s].devinfo.di_func), sc->sc_rxbuf[p][s]+1, sizeof(struct maple_devinfo)); for (i = 0; i < 4; i++, to_swap++) *to_swap = ntohl(*to_swap); maple_attach_dev(sc, p, s); } else { printf("%s: no response from port %d subunit %d\n", sc->sc_dev.dv_xname, p, s); sc->sc_port_units[p] &= ~(1<maple_commands_pending || MAPLE_STATE != 0) return; maple_begin_txbuf(sc); for (p = 0; p < MAPLE_PORTS; p++) { for (s = 0; s < MAPLE_SUBUNITS; s++) { if (sc->sc_unit[p][s].getcond_callback != NULL) { u_int32_t func = ntohl(sc->sc_unit[p][s].getcond_func); maple_write_command(sc, p, s, MAPLE_COMMAND_GETCOND, 1, &func); } } } if (!maple_end_txbuf(sc)) return; MAPLE_DMAADDR = sc->sc_txbuf_phys; MAPLE_STATE = 1; sc->maple_commands_pending = 1; } static void maple_check_responses(sc) struct maple_softc *sc; { int p, s; if (!sc->maple_commands_pending || MAPLE_STATE != 0) return; for (p = 0; p < MAPLE_PORTS; p++) { for (s = 0; s < MAPLE_SUBUNITS; s++) { struct maple_unit * u = &sc->sc_unit[p][s]; if (u->getcond_callback != NULL && (sc->sc_rxbuf[p][s][0] & 0xff) == MAPLE_RESPONSE_DATATRF && (sc->sc_rxbuf[p][s][0]>>24) >= 1 && htonl(sc->sc_rxbuf[p][s][1]) == u->getcond_func) { (*u->getcond_callback)(u->getcond_data, (void *)(sc->sc_rxbuf[p][s]+2), ((sc->sc_rxbuf[p][s][0]>>22)&1020)-4); } } } sc->maple_commands_pending = 0; } void maple_run_polling(dev) struct device *dev; { struct maple_softc *sc; sc = (struct maple_softc *)dev; if (MAPLE_STATE != 0) return; maple_send_commands(sc); while (MAPLE_STATE != 0) ; maple_check_responses(sc); } void maple_set_condition_callback(dev, port, subunit, func, callback, data) struct device *dev; int port; int subunit; u_int32_t func; void (*callback)(void *, void *, int); void *data; { struct maple_softc *sc; sc = (struct maple_softc *)dev; if ((port & ~(MAPLE_PORTS-1)) != 0 || subunit < 0 || subunit >= MAPLE_SUBUNITS) return; sc->sc_unit[port][subunit].getcond_func = func; sc->sc_unit[port][subunit].getcond_callback = callback; sc->sc_unit[port][subunit].getcond_data = data; } static void maple_callout(ctx) void *ctx; { struct maple_softc *sc = ctx; if(!maple_polling) { maple_check_responses(sc); maple_send_commands(sc); } callout_reset(&sc->maple_callout_ch, MAPLE_CALLOUT_TICKS, (void *)maple_callout, sc); } int maple_alloc_dma(size, vap, pap) size_t size; vaddr_t *vap; paddr_t *pap; { extern paddr_t avail_start, avail_end; /* from pmap.c */ struct pglist mlist; struct vm_page *m; int error; size = round_page(size); TAILQ_INIT(&mlist); error = uvm_pglistalloc(size, avail_start, avail_end - PAGE_SIZE, 0, 0, &mlist, 1, 0); if (error) return (error); m = TAILQ_FIRST(&mlist); *pap = VM_PAGE_TO_PHYS(m); *vap = SH3_PHYS_TO_P2SEG(VM_PAGE_TO_PHYS(m)); return (0); } void maple_free_dma(paddr, size) paddr_t paddr; size_t size; { struct pglist mlist; struct vm_page *m; bus_addr_t addr; TAILQ_INIT(&mlist); for (addr = paddr; addr < paddr + size; addr += PAGE_SIZE) { m = PHYS_TO_VM_PAGE(addr); TAILQ_INSERT_TAIL(&mlist, m, pageq); } uvm_pglistfree(&mlist); } static void mapleattach(parent, self, aux) struct device *parent, *self; void *aux; { struct maple_softc *sc; vaddr_t dmabuffer; paddr_t dmabuffer_phys; u_int32_t *p; int i, j; sc = (struct maple_softc *)self; printf("\n"); if (maple_alloc_dma(MAPLE_DMABUF_SIZE, &dmabuffer, &dmabuffer_phys)) { printf("%s: unable to allocate DMA buffers.\n", sc->sc_dev.dv_xname); return; } p = (u_int32_t *) dmabuffer; for (i = 0; i < MAPLE_PORTS; i++) for (j = 0; j < MAPLE_SUBUNITS; j++) { sc->sc_rxbuf[i][j] = p; sc->sc_rxbuf_phys[i][j] = SH3_P2SEG_TO_PHYS(p); p += 256; } sc->sc_txbuf = p; sc->sc_txbuf_phys = SH3_P2SEG_TO_PHYS(p); sc->maple_commands_pending = 0; MAPLE_RESET = RESET_MAGIC; MAPLE_RESET2 = 0; MAPLE_SPEED = SPEED_2MBPS | TIMEOUT(50000); MAPLE_ENABLE = 1; maple_scanbus(sc); memset(&sc->maple_callout_ch, 0, sizeof(sc->maple_callout_ch)); callout_reset(&sc->maple_callout_ch, MAPLE_CALLOUT_TICKS, (void *)maple_callout, sc); } int mapleprint(aux, pnp) void *aux; const char *pnp; { struct maple_attach_args *ma = aux; if (pnp != NULL) { printf("maple%c", 'A'+ma->ma_port); if (ma->ma_subunit != 0) printf("%d", ma->ma_subunit); printf(" at %s", pnp); } printf(" port %d", ma->ma_port); if (ma->ma_subunit != 0) printf(" subunit %d", ma->ma_subunit); printf(": %.*s", (int)sizeof(ma->ma_devinfo->di_product_name), ma->ma_devinfo->di_product_name); return (0); } static int maplesubmatch(parent, match, aux) struct device *parent; struct cfdata *match; void *aux; { struct maple_attach_args *ma = aux; if (match->cf_loc[MAPLECF_PORT] != MAPLECF_PORT_DEFAULT && match->cf_loc[MAPLECF_PORT] != ma->ma_port) return (0); if (match->cf_loc[MAPLECF_SUBUNIT] != MAPLECF_SUBUNIT_DEFAULT && match->cf_loc[MAPLECF_SUBUNIT] != ma->ma_subunit) return (0); return ((*match->cf_attach->ca_match)(parent, match, aux)); } u_int32_t maple_get_function_data(devinfo, function_code) struct maple_devinfo *devinfo; u_int32_t function_code; { int i, p = 0; for (i = 31; i >= 0; --i) if (devinfo->di_func & (1U<di_function_data[p]; else if (++p >= 3) break; return (0); } /* Generic maple device interface */ int mapleopen(dev, flag, mode, p) dev_t dev; int flag, mode; struct proc *p; { struct maple_softc *sc; sc = device_lookup(&maple_cd, MAPLEBUSUNIT(dev)); if (sc == NULL) /* make sure it was attached */ return (ENXIO); if (MAPLEPORT(dev) >= MAPLE_PORTS) return (ENXIO); if (MAPLESUBUNIT(dev) >= MAPLE_SUBUNITS) return (ENXIO); if(!(sc->sc_port_units[MAPLEPORT(dev)] & (1<sc_port_units_open[MAPLEPORT(dev)] |= 1<sc_port_units_open[MAPLEPORT(dev)] &= ~(1<sc_unit[port][subunit]; if(!(sc->sc_port_units[port] & (1<devinfo, sizeof(struct maple_devinfo)); return (0); default: return (EINVAL); } } int mapleioctl(dev, cmd, data, flag, p) dev_t dev; u_long cmd; caddr_t data; int flag; struct proc *p; { struct maple_softc *sc; sc = device_lookup(&maple_cd, MAPLEBUSUNIT(dev)); return maple_internal_ioctl(sc, MAPLEPORT(dev), MAPLESUBUNIT(dev), cmd, data, flag, p); }