1 /* $NetBSD: mpu.c,v 1.3 1999/10/05 03:29:22 itohy Exp $ */ 2 3 /* 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (augustss@netbsd.org). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/errno.h> 42 #include <sys/ioctl.h> 43 #include <sys/syslog.h> 44 #include <sys/device.h> 45 #include <sys/proc.h> 46 #include <sys/buf.h> 47 #include <vm/vm.h> 48 49 #include <machine/cpu.h> 50 #include <machine/intr.h> 51 #include <machine/bus.h> 52 53 #include <dev/midi_if.h> 54 55 #include <dev/ic/mpuvar.h> 56 57 #ifdef AUDIO_DEBUG 58 #define DPRINTF(x) if (mpudebug) printf x 59 #define DPRINTFN(n,x) if (mpudebug >= (n)) printf x 60 int mpudebug = 0; 61 #else 62 #define DPRINTF(x) 63 #define DPRINTFN(n,x) 64 #endif 65 66 #define MPU_DATA 0 67 #define MPU_COMMAND 1 68 #define MPU_RESET 0xff 69 #define MPU_UART_MODE 0x3f 70 #define MPU_ACK 0xfe 71 #define MPU_STATUS 1 72 #define MPU_OUTPUT_BUSY 0x40 73 #define MPU_INPUT_EMPTY 0x80 74 75 #define MPU_MAXWAIT 10000 /* usec/10 to wait */ 76 77 #define MPU_GETSTATUS(iot, ioh) (bus_space_read_1(iot, ioh, MPU_STATUS)) 78 79 int mpu_reset(struct mpu_softc *); 80 static __inline int mpu_waitready(struct mpu_softc *); 81 void mpu_readinput(struct mpu_softc *); 82 83 int mpu_open __P((void *, int, 84 void (*iintr)__P((void *, int)), 85 void (*ointr)__P((void *)), void *arg)); 86 void mpu_close __P((void *)); 87 int mpu_output __P((void *, int)); 88 void mpu_getinfo __P((void *, struct midi_info *)); 89 90 struct midi_hw_if mpu_midi_hw_if = { 91 mpu_open, 92 mpu_close, 93 mpu_output, 94 mpu_getinfo, 95 0, /* ioctl */ 96 }; 97 98 int 99 mpu_find(sc) 100 struct mpu_softc *sc; 101 { 102 if (MPU_GETSTATUS(sc->iot, sc->ioh) == 0xff) { 103 DPRINTF(("mpu_find: No status\n")); 104 goto bad; 105 } 106 sc->open = 0; 107 sc->intr = 0; 108 if (mpu_reset(sc) == 0) 109 return 1; 110 bad: 111 return 0; 112 } 113 114 void 115 mpu_attach(sc) 116 struct mpu_softc *sc; 117 { 118 printf("\n"); 119 120 midi_attach_mi(&mpu_midi_hw_if, sc, &sc->sc_dev); 121 } 122 123 static __inline int 124 mpu_waitready(sc) 125 struct mpu_softc *sc; 126 { 127 int i; 128 129 for(i = 0; i < MPU_MAXWAIT; i++) { 130 if (!(MPU_GETSTATUS(sc->iot, sc->ioh) & MPU_OUTPUT_BUSY)) 131 return 0; 132 delay(10); 133 } 134 return 1; 135 } 136 137 int 138 mpu_reset(sc) 139 struct mpu_softc *sc; 140 { 141 bus_space_tag_t iot = sc->iot; 142 bus_space_handle_t ioh = sc->ioh; 143 int i; 144 int s; 145 146 if (mpu_waitready(sc)) { 147 DPRINTF(("mpu_reset: not ready\n")); 148 return EIO; 149 } 150 s = splaudio(); /* Don't let the interrupt get our ACK. */ 151 bus_space_write_1(iot, ioh, MPU_COMMAND, MPU_RESET); 152 for(i = 0; i < 2*MPU_MAXWAIT; i++) { 153 if (!(MPU_GETSTATUS(iot, ioh) & MPU_INPUT_EMPTY) && 154 bus_space_read_1(iot, ioh, MPU_DATA) == MPU_ACK) { 155 splx(s); 156 return 0; 157 } 158 } 159 splx(s); 160 DPRINTF(("mpu_reset: No ACK\n")); 161 return EIO; 162 } 163 164 int 165 mpu_open(addr, flags, iintr, ointr, arg) 166 void *addr; 167 int flags; 168 void (*iintr)__P((void *, int)); 169 void (*ointr)__P((void *)); 170 void *arg; 171 { 172 struct mpu_softc *sc = addr; 173 174 DPRINTF(("mpu_open: sc=%p\n", sc)); 175 176 if (sc->open) 177 return EBUSY; 178 #ifndef AUDIO_NO_POWER_CTL 179 if (sc->powerctl) 180 sc->powerctl(sc->powerarg, 1); 181 #endif 182 if (mpu_reset(sc) != 0) { 183 #ifndef AUDIO_NO_POWER_CTL 184 if (sc->powerctl) 185 sc->powerctl(sc->powerarg, 0); 186 #endif 187 return EIO; 188 } 189 190 bus_space_write_1(sc->iot, sc->ioh, MPU_COMMAND, MPU_UART_MODE); 191 sc->open = 1; 192 sc->intr = iintr; 193 sc->arg = arg; 194 return 0; 195 } 196 197 void 198 mpu_close(addr) 199 void *addr; 200 { 201 struct mpu_softc *sc = addr; 202 203 DPRINTF(("mpu_close: sc=%p\n", sc)); 204 205 sc->open = 0; 206 sc->intr = 0; 207 mpu_reset(sc); /* exit UART mode */ 208 209 #ifndef AUDIO_NO_POWER_CTL 210 if (sc->powerctl) 211 sc->powerctl(sc->powerarg, 0); 212 #endif 213 } 214 215 void 216 mpu_readinput(sc) 217 struct mpu_softc *sc; 218 { 219 bus_space_tag_t iot = sc->iot; 220 bus_space_handle_t ioh = sc->ioh; 221 int data; 222 223 while(!(MPU_GETSTATUS(iot, ioh) & MPU_INPUT_EMPTY)) { 224 data = bus_space_read_1(iot, ioh, MPU_DATA); 225 DPRINTFN(3, ("mpu_rea: sc=%p 0x%02x\n", sc, data)); 226 if (sc->intr) 227 sc->intr(sc->arg, data); 228 } 229 } 230 231 int 232 mpu_output(addr, d) 233 void *addr; 234 int d; 235 { 236 struct mpu_softc *sc = addr; 237 int s; 238 239 DPRINTFN(3, ("mpu_output: sc=%p 0x%02x\n", sc, d)); 240 if (!(MPU_GETSTATUS(sc->iot, sc->ioh) & MPU_INPUT_EMPTY)) { 241 s = splaudio(); 242 mpu_readinput(sc); 243 splx(s); 244 } 245 if (mpu_waitready(sc)) { 246 DPRINTF(("mpu_output: not ready\n")); 247 return EIO; 248 } 249 bus_space_write_1(sc->iot, sc->ioh, MPU_DATA, d); 250 return 0; 251 } 252 253 void 254 mpu_getinfo(addr, mi) 255 void *addr; 256 struct midi_info *mi; 257 { 258 struct mpu_softc *sc = addr; 259 260 mi->name = sc->model; 261 mi->props = 0; 262 } 263 264 int 265 mpu_intr(addr) 266 void *addr; 267 { 268 struct mpu_softc *sc = addr; 269 270 if (MPU_GETSTATUS(sc->iot, sc->ioh) & MPU_INPUT_EMPTY) { 271 DPRINTF(("mpu_intr: no data\n")); 272 return (0); 273 } else { 274 mpu_readinput(sc); 275 return (1); 276 } 277 } 278