pcppi.c revision 1.41.2.1
1 /* $NetBSD: pcppi.c,v 1.41.2.1 2012/04/29 23:04:51 mrg Exp $ */ 2 3 /* 4 * Copyright (c) 1996 Carnegie-Mellon University. 5 * All rights reserved. 6 * 7 * Author: Chris G. Demetriou 8 * 9 * Permission to use, copy, modify and distribute this software and 10 * its documentation is hereby granted, provided that both the copyright 11 * notice and this permission notice appear in all copies of the 12 * software, derivative works or modified versions, and any portions 13 * thereof, and that both notices appear in supporting documentation. 14 * 15 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 16 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 17 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 18 * 19 * Carnegie Mellon requests users of this software to return to 20 * 21 * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU 22 * School of Computer Science 23 * Carnegie Mellon University 24 * Pittsburgh PA 15213-3890 25 * 26 * any improvements or extensions that they make and grant Carnegie the 27 * rights to redistribute these changes. 28 */ 29 30 #include <sys/cdefs.h> 31 __KERNEL_RCSID(0, "$NetBSD: pcppi.c,v 1.41.2.1 2012/04/29 23:04:51 mrg Exp $"); 32 33 #include "attimer.h" 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/callout.h> 38 #include <sys/kernel.h> 39 #include <sys/proc.h> 40 #include <sys/device.h> 41 #include <sys/errno.h> 42 #include <sys/bus.h> 43 #include <sys/mutex.h> 44 #include <sys/condvar.h> 45 #include <sys/tty.h> 46 47 #include <dev/ic/attimervar.h> 48 49 #include <dev/isa/isareg.h> 50 #include <dev/isa/isavar.h> 51 #include <dev/isa/pcppireg.h> 52 #include <dev/isa/pcppivar.h> 53 54 #include "pckbd.h" 55 #if NPCKBD > 0 56 #include <dev/pckbport/pckbdvar.h> 57 58 void pcppi_pckbd_bell(void *, u_int, u_int, u_int, int); 59 #endif 60 61 int pcppi_match(device_t, cfdata_t, void *); 62 void pcppi_isa_attach(device_t, device_t, void *); 63 void pcppi_childdet(device_t, device_t); 64 65 CFATTACH_DECL3_NEW(pcppi, sizeof(struct pcppi_softc), 66 pcppi_match, pcppi_isa_attach, pcppi_detach, NULL, NULL, pcppi_childdet, 67 DVF_DETACH_SHUTDOWN); 68 69 static int pcppisearch(device_t, cfdata_t, const int *, void *); 70 static void pcppi_bell_stop(struct pcppi_softc *); 71 static void pcppi_bell_callout(void *); 72 73 #if NATTIMER > 0 74 static void pcppi_attach_speaker(device_t); 75 static void pcppi_detach_speaker(struct pcppi_softc *); 76 #endif 77 78 int 79 pcppi_match(device_t parent, cfdata_t match, void *aux) 80 { 81 struct isa_attach_args *ia = aux; 82 bus_space_handle_t ppi_ioh; 83 int have_ppi, rv; 84 u_int8_t v, nv; 85 86 if (ISA_DIRECT_CONFIG(ia)) 87 return (0); 88 89 /* If values are hardwired to something that they can't be, punt. */ 90 if (ia->ia_nio < 1 || 91 (ia->ia_io[0].ir_addr != ISA_UNKNOWN_PORT && 92 ia->ia_io[0].ir_addr != IO_PPI)) 93 return (0); 94 95 if (ia->ia_niomem > 0 && 96 (ia->ia_iomem[0].ir_addr != ISA_UNKNOWN_IOMEM)) 97 return (0); 98 99 if (ia->ia_nirq > 0 && 100 (ia->ia_irq[0].ir_irq != ISA_UNKNOWN_IRQ)) 101 return (0); 102 103 if (ia->ia_ndrq > 0 && 104 (ia->ia_drq[0].ir_drq != ISA_UNKNOWN_DRQ)) 105 return (0); 106 107 rv = 0; 108 have_ppi = 0; 109 110 if (bus_space_map(ia->ia_iot, IO_PPI, 1, 0, &ppi_ioh)) 111 goto lose; 112 have_ppi = 1; 113 114 /* 115 * Check for existence of PPI. Realistically, this is either going to 116 * be here or nothing is going to be here. 117 * 118 * We don't want to have any chance of changing speaker output (which 119 * this test might, if it crashes in the middle, or something; 120 * normally it's be to quick to produce anthing audible), but 121 * many "combo chip" mock-PPI's don't seem to support the top bit 122 * of Port B as a settable bit. The bottom bit has to be settable, 123 * since the speaker driver hardware still uses it. 124 */ 125 v = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 126 bus_space_write_1(ia->ia_iot, ppi_ioh, 0, v ^ 0x01); /* XXX */ 127 nv = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 128 if (((nv ^ v) & 0x01) == 0x01) 129 rv = 1; 130 bus_space_write_1(ia->ia_iot, ppi_ioh, 0, v); /* XXX */ 131 nv = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 132 if (((nv ^ v) & 0x01) != 0x00) { 133 rv = 0; 134 goto lose; 135 } 136 137 /* 138 * We assume that the programmable interval timer is there. 139 */ 140 141 lose: 142 if (have_ppi) 143 bus_space_unmap(ia->ia_iot, ppi_ioh, 1); 144 if (rv) { 145 ia->ia_io[0].ir_addr = IO_PPI; 146 ia->ia_io[0].ir_size = 1; 147 ia->ia_nio = 1; 148 149 ia->ia_niomem = 0; 150 ia->ia_nirq = 0; 151 ia->ia_ndrq = 0; 152 } 153 return (rv); 154 } 155 156 void 157 pcppi_isa_attach(device_t parent, device_t self, void *aux) 158 { 159 struct pcppi_softc *sc = device_private(self); 160 struct isa_attach_args *ia = aux; 161 bus_space_tag_t iot; 162 163 sc->sc_dv = self; 164 sc->sc_iot = iot = ia->ia_iot; 165 166 sc->sc_size = 1; 167 if (bus_space_map(iot, IO_PPI, sc->sc_size, 0, &sc->sc_ppi_ioh)) 168 panic("pcppi_attach: couldn't map"); 169 170 aprint_normal("\n"); 171 pcppi_attach(sc); 172 } 173 174 void 175 pcppi_childdet(device_t self, device_t child) 176 { 177 178 /* we hold no child references, so do nothing */ 179 } 180 181 int 182 pcppi_detach(device_t self, int flags) 183 { 184 int rc; 185 struct pcppi_softc *sc = device_private(self); 186 187 #if NATTIMER > 0 188 pcppi_detach_speaker(sc); 189 #endif 190 191 if ((rc = config_detach_children(sc->sc_dv, flags)) != 0) 192 return rc; 193 194 pmf_device_deregister(self); 195 196 #if NPCKBD > 0 197 pckbd_unhook_bell(pcppi_pckbd_bell, sc); 198 #endif 199 mutex_spin_enter(&tty_lock); 200 pcppi_bell_stop(sc); 201 mutex_spin_exit(&tty_lock); 202 203 callout_halt(&sc->sc_bell_ch, NULL); 204 callout_destroy(&sc->sc_bell_ch); 205 206 cv_destroy(&sc->sc_slp); 207 208 bus_space_unmap(sc->sc_iot, sc->sc_ppi_ioh, sc->sc_size); 209 210 return 0; 211 } 212 213 void 214 pcppi_attach(struct pcppi_softc *sc) 215 { 216 struct pcppi_attach_args pa; 217 device_t self = sc->sc_dv; 218 219 callout_init(&sc->sc_bell_ch, CALLOUT_MPSAFE); 220 callout_setfunc(&sc->sc_bell_ch, pcppi_bell_callout, sc); 221 cv_init(&sc->sc_slp, "bell"); 222 223 sc->sc_bellactive = sc->sc_bellpitch = 0; 224 225 #if NPCKBD > 0 226 /* Provide a beeper for the PC Keyboard, if there isn't one already. */ 227 pckbd_hookup_bell(pcppi_pckbd_bell, sc); 228 #endif 229 #if NATTIMER > 0 230 config_defer(sc->sc_dv, pcppi_attach_speaker); 231 #endif 232 if (!pmf_device_register(self, NULL, NULL)) 233 aprint_error_dev(self, "couldn't establish power handler\n"); 234 235 pa.pa_cookie = sc; 236 config_search_loc(pcppisearch, sc->sc_dv, "pcppi", NULL, &pa); 237 } 238 239 static int 240 pcppisearch(device_t parent, cfdata_t cf, const int *locs, void *aux) 241 { 242 243 if (config_match(parent, cf, aux)) 244 config_attach_loc(parent, cf, locs, aux, NULL); 245 246 return 0; 247 } 248 249 #if NATTIMER > 0 250 static void 251 pcppi_detach_speaker(struct pcppi_softc *sc) 252 { 253 if (sc->sc_timer != NULL) { 254 attimer_detach_speaker(sc->sc_timer); 255 sc->sc_timer = NULL; 256 } 257 } 258 259 static void 260 pcppi_attach_speaker(device_t self) 261 { 262 struct pcppi_softc *sc = device_private(self); 263 264 if ((sc->sc_timer = attimer_attach_speaker()) == NULL) 265 aprint_error_dev(self, "could not find any available timer\n"); 266 else { 267 aprint_normal_dev(sc->sc_timer, "attached to %s\n", 268 device_xname(self)); 269 } 270 } 271 #endif 272 273 void 274 pcppi_bell(pcppi_tag_t self, int pitch, int period, int slp) 275 { 276 277 mutex_spin_enter(&tty_lock); 278 pcppi_bell_locked(self, pitch, period, slp); 279 mutex_spin_exit(&tty_lock); 280 } 281 282 void 283 pcppi_bell_locked(pcppi_tag_t self, int pitch, int period, int slp) 284 { 285 struct pcppi_softc *sc = self; 286 287 if (sc->sc_bellactive) { 288 if (sc->sc_timeout) { 289 sc->sc_timeout = 0; 290 callout_stop(&sc->sc_bell_ch); 291 } 292 cv_broadcast(&sc->sc_slp); 293 } 294 if (pitch == 0 || period == 0) { 295 pcppi_bell_stop(sc); 296 sc->sc_bellpitch = 0; 297 return; 298 } 299 if (!sc->sc_bellactive || sc->sc_bellpitch != pitch) { 300 #if NATTIMER > 0 301 if (sc->sc_timer != NULL) 302 attimer_set_pitch(sc->sc_timer, pitch); 303 #endif 304 /* enable speaker */ 305 bus_space_write_1(sc->sc_iot, sc->sc_ppi_ioh, 0, 306 bus_space_read_1(sc->sc_iot, sc->sc_ppi_ioh, 0) 307 | PIT_SPKR); 308 } 309 sc->sc_bellpitch = pitch; 310 311 sc->sc_bellactive = 1; 312 if (slp & PCPPI_BELL_POLL) { 313 delay((period * 1000000) / hz); 314 pcppi_bell_stop(sc); 315 } else { 316 sc->sc_timeout = 1; 317 callout_schedule(&sc->sc_bell_ch, period); 318 if (slp & PCPPI_BELL_SLEEP) { 319 cv_wait_sig(&sc->sc_slp, &tty_lock); 320 } 321 } 322 } 323 324 static void 325 pcppi_bell_callout(void *arg) 326 { 327 struct pcppi_softc *sc = arg; 328 329 mutex_spin_enter(&tty_lock); 330 if (sc->sc_timeout != 0) { 331 pcppi_bell_stop(sc); 332 } 333 mutex_spin_exit(&tty_lock); 334 } 335 336 static void 337 pcppi_bell_stop(struct pcppi_softc *sc) 338 { 339 340 sc->sc_timeout = 0; 341 342 /* disable bell */ 343 bus_space_write_1(sc->sc_iot, sc->sc_ppi_ioh, 0, 344 bus_space_read_1(sc->sc_iot, sc->sc_ppi_ioh, 0) 345 & ~PIT_SPKR); 346 sc->sc_bellactive = 0; 347 cv_broadcast(&sc->sc_slp); 348 } 349 350 #if NPCKBD > 0 351 void 352 pcppi_pckbd_bell(void *arg, u_int pitch, u_int period, u_int volume, 353 int poll) 354 { 355 356 /* 357 * Comes in as ms, goes out at ticks; volume ignored. 358 */ 359 pcppi_bell_locked(arg, pitch, (period * hz) / 1000, 360 poll ? PCPPI_BELL_POLL : 0); 361 } 362 #endif /* NPCKBD > 0 */ 363
Indexes created Fri Oct 03 02:09:57 GMT 2025