sys/dev/isa/pcppi.c

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