pcppi.c revision 1.45.22.5
1 /* $NetBSD: pcppi.c,v 1.45.22.5 2021/04/04 22:01:22 thorpej 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.45.22.5 2021/04/04 22:01:22 thorpej 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 int pcppi_rescan(device_t, const char *, const int *); 65 66 CFATTACH_DECL3_NEW(pcppi, sizeof(struct pcppi_softc), 67 pcppi_match, pcppi_isa_attach, pcppi_detach, NULL, pcppi_rescan, 68 pcppi_childdet, DVF_DETACH_SHUTDOWN); 69 70 static int pcppisearch(device_t, cfdata_t, const int *, void *); 71 static void pcppi_bell_stop(struct pcppi_softc *); 72 static void pcppi_bell_callout(void *); 73 74 #if NATTIMER > 0 75 static void pcppi_attach_speaker(device_t); 76 static void pcppi_detach_speaker(struct pcppi_softc *); 77 #endif 78 79 int 80 pcppi_match(device_t parent, cfdata_t match, void *aux) 81 { 82 struct isa_attach_args *ia = aux; 83 bus_space_handle_t ppi_ioh; 84 int have_ppi, rv; 85 u_int8_t v, nv; 86 87 if (ISA_DIRECT_CONFIG(ia)) 88 return (0); 89 90 /* If values are hardwired to something that they can't be, punt. */ 91 if (ia->ia_nio < 1 || 92 (ia->ia_io[0].ir_addr != ISA_UNKNOWN_PORT && 93 ia->ia_io[0].ir_addr != IO_PPI)) 94 return (0); 95 96 if (ia->ia_niomem > 0 && 97 (ia->ia_iomem[0].ir_addr != ISA_UNKNOWN_IOMEM)) 98 return (0); 99 100 if (ia->ia_nirq > 0 && 101 (ia->ia_irq[0].ir_irq != ISA_UNKNOWN_IRQ)) 102 return (0); 103 104 if (ia->ia_ndrq > 0 && 105 (ia->ia_drq[0].ir_drq != ISA_UNKNOWN_DRQ)) 106 return (0); 107 108 rv = 0; 109 have_ppi = 0; 110 111 if (bus_space_map(ia->ia_iot, IO_PPI, 1, 0, &ppi_ioh)) 112 goto lose; 113 have_ppi = 1; 114 115 /* 116 * Check for existence of PPI. Realistically, this is either going to 117 * be here or nothing is going to be here. 118 * 119 * We don't want to have any chance of changing speaker output (which 120 * this test might, if it crashes in the middle, or something; 121 * normally it's be to quick to produce anthing audible), but 122 * many "combo chip" mock-PPI's don't seem to support the top bit 123 * of Port B as a settable bit. The bottom bit has to be settable, 124 * since the speaker driver hardware still uses it. 125 */ 126 v = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 127 bus_space_write_1(ia->ia_iot, ppi_ioh, 0, v ^ 0x01); /* XXX */ 128 nv = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 129 if (((nv ^ v) & 0x01) == 0x01) 130 rv = 1; 131 bus_space_write_1(ia->ia_iot, ppi_ioh, 0, v); /* XXX */ 132 nv = bus_space_read_1(ia->ia_iot, ppi_ioh, 0); /* XXX */ 133 if (((nv ^ v) & 0x01) != 0x00) { 134 rv = 0; 135 goto lose; 136 } 137 138 /* 139 * We assume that the programmable interval timer is there. 140 */ 141 142 lose: 143 if (have_ppi) 144 bus_space_unmap(ia->ia_iot, ppi_ioh, 1); 145 if (rv) { 146 ia->ia_io[0].ir_addr = IO_PPI; 147 ia->ia_io[0].ir_size = 1; 148 ia->ia_nio = 1; 149 150 ia->ia_niomem = 0; 151 ia->ia_nirq = 0; 152 ia->ia_ndrq = 0; 153 } 154 return (rv); 155 } 156 157 void 158 pcppi_isa_attach(device_t parent, device_t self, void *aux) 159 { 160 struct pcppi_softc *sc = device_private(self); 161 struct isa_attach_args *ia = aux; 162 bus_space_tag_t iot; 163 164 sc->sc_dv = self; 165 sc->sc_iot = iot = ia->ia_iot; 166 167 sc->sc_size = 1; 168 if (bus_space_map(iot, IO_PPI, sc->sc_size, 0, &sc->sc_ppi_ioh)) 169 panic("pcppi_attach: couldn't map"); 170 171 aprint_naive("\n"); 172 aprint_normal("\n"); 173 pcppi_attach(sc); 174 } 175 176 void 177 pcppi_childdet(device_t self, device_t child) 178 { 179 180 /* we hold no child references, so do nothing */ 181 } 182 183 int 184 pcppi_detach(device_t self, int flags) 185 { 186 int rc; 187 struct pcppi_softc *sc = device_private(self); 188 189 #if NATTIMER > 0 190 pcppi_detach_speaker(sc); 191 #endif 192 193 if ((rc = config_detach_children(sc->sc_dv, flags)) != 0) 194 return rc; 195 196 pmf_device_deregister(self); 197 198 #if NPCKBD > 0 199 pckbd_unhook_bell(pcppi_pckbd_bell, sc); 200 #endif 201 mutex_spin_enter(&tty_lock); 202 pcppi_bell_stop(sc); 203 mutex_spin_exit(&tty_lock); 204 205 callout_halt(&sc->sc_bell_ch, NULL); 206 callout_destroy(&sc->sc_bell_ch); 207 208 cv_destroy(&sc->sc_slp); 209 210 bus_space_unmap(sc->sc_iot, sc->sc_ppi_ioh, sc->sc_size); 211 212 return 0; 213 } 214 215 void 216 pcppi_attach(struct pcppi_softc *sc) 217 { 218 device_t self = sc->sc_dv; 219 220 callout_init(&sc->sc_bell_ch, CALLOUT_MPSAFE); 221 callout_setfunc(&sc->sc_bell_ch, pcppi_bell_callout, sc); 222 cv_init(&sc->sc_slp, "bell"); 223 224 sc->sc_bellactive = sc->sc_bellpitch = 0; 225 226 #if NPCKBD > 0 227 /* Provide a beeper for the PC Keyboard, if there isn't one already. */ 228 pckbd_hookup_bell(pcppi_pckbd_bell, sc); 229 #endif 230 #if NATTIMER > 0 231 config_defer(sc->sc_dv, pcppi_attach_speaker); 232 #endif 233 if (!pmf_device_register(self, NULL, NULL)) 234 aprint_error_dev(self, "couldn't establish power handler\n"); 235 236 pcppi_rescan(self, NULL, NULL); 237 } 238 239 int 240 pcppi_rescan(device_t self, const char *ifattr, const int *locators) 241 { 242 struct pcppi_softc *sc = device_private(self); 243 struct pcppi_attach_args pa; 244 245 pa.pa_cookie = sc; 246 pa.pa_bell_func = pcppi_bell; 247 248 config_search(sc->sc_dv, &pa, 249 CFARG_SEARCH, pcppisearch, 250 CFARG_EOL); 251 252 return 0; 253 } 254 255 static int 256 pcppisearch(device_t parent, cfdata_t cf, const int *locs, void *aux) 257 { 258 259 if (config_match(parent, cf, aux)) 260 config_attach(parent, cf, aux, NULL, 261 CFARG_LOCATORS, locs, 262 CFARG_EOL); 263 264 return 0; 265 } 266 267 #if NATTIMER > 0 268 static void 269 pcppi_detach_speaker(struct pcppi_softc *sc) 270 { 271 if (sc->sc_timer != NULL) { 272 attimer_detach_speaker(sc->sc_timer); 273 sc->sc_timer = NULL; 274 } 275 } 276 277 static void 278 pcppi_attach_speaker(device_t self) 279 { 280 struct pcppi_softc *sc = device_private(self); 281 282 if ((sc->sc_timer = attimer_attach_speaker()) == NULL) 283 aprint_error_dev(self, "could not find any available timer\n"); 284 else { 285 aprint_normal_dev(sc->sc_timer, "attached to %s\n", 286 device_xname(self)); 287 } 288 } 289 #endif 290 291 void 292 pcppi_bell(pcppi_tag_t self, int pitch, int period, int slp) 293 { 294 295 mutex_spin_enter(&tty_lock); 296 pcppi_bell_locked(self, pitch, period, slp); 297 mutex_spin_exit(&tty_lock); 298 } 299 300 void 301 pcppi_bell_locked(pcppi_tag_t self, int pitch, int period, int slp) 302 { 303 struct pcppi_softc *sc = self; 304 305 if (sc->sc_bellactive) { 306 if (sc->sc_timeout) { 307 sc->sc_timeout = 0; 308 callout_stop(&sc->sc_bell_ch); 309 } 310 cv_broadcast(&sc->sc_slp); 311 } 312 if (pitch == 0 || period == 0) { 313 pcppi_bell_stop(sc); 314 sc->sc_bellpitch = 0; 315 return; 316 } 317 if (!sc->sc_bellactive || sc->sc_bellpitch != pitch) { 318 #if NATTIMER > 0 319 if (sc->sc_timer != NULL) 320 attimer_set_pitch(sc->sc_timer, pitch); 321 #endif 322 /* enable speaker */ 323 bus_space_write_1(sc->sc_iot, sc->sc_ppi_ioh, 0, 324 bus_space_read_1(sc->sc_iot, sc->sc_ppi_ioh, 0) 325 | PIT_SPKR); 326 } 327 sc->sc_bellpitch = pitch; 328 329 sc->sc_bellactive = 1; 330 if (slp & PCPPI_BELL_POLL) { 331 delay((period * 1000000) / hz); 332 pcppi_bell_stop(sc); 333 } else { 334 sc->sc_timeout = 1; 335 callout_schedule(&sc->sc_bell_ch, period); 336 if (slp & PCPPI_BELL_SLEEP) { 337 cv_wait_sig(&sc->sc_slp, &tty_lock); 338 } 339 } 340 } 341 342 static void 343 pcppi_bell_callout(void *arg) 344 { 345 struct pcppi_softc *sc = arg; 346 347 mutex_spin_enter(&tty_lock); 348 if (sc->sc_timeout != 0) { 349 pcppi_bell_stop(sc); 350 } 351 mutex_spin_exit(&tty_lock); 352 } 353 354 static void 355 pcppi_bell_stop(struct pcppi_softc *sc) 356 { 357 358 sc->sc_timeout = 0; 359 360 /* disable bell */ 361 bus_space_write_1(sc->sc_iot, sc->sc_ppi_ioh, 0, 362 bus_space_read_1(sc->sc_iot, sc->sc_ppi_ioh, 0) 363 & ~PIT_SPKR); 364 sc->sc_bellactive = 0; 365 cv_broadcast(&sc->sc_slp); 366 } 367 368 #if NPCKBD > 0 369 void 370 pcppi_pckbd_bell(void *arg, u_int pitch, u_int period, u_int volume, 371 int poll) 372 { 373 374 /* 375 * Comes in as ms, goes out at ticks; volume ignored. 376 */ 377 pcppi_bell_locked(arg, pitch, (period * hz) / 1000, 378 poll ? PCPPI_BELL_POLL : 0); 379 } 380 #endif /* NPCKBD > 0 */ 381
Indexes created Thu Oct 02 14:10:14 GMT 2025