sys/dev/auxio/auxio.c

   1 /*-
   2  * Copyright (c) 2004 Pyun YongHyeon
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 /*      $NetBSD: auxio.c,v 1.11 2003/07/15 03:36:04 lukem Exp $ */
  29
  30 /*-
  31  * Copyright (c) 2000, 2001 Matthew R. Green
  32  * All rights reserved.
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted provided that the following conditions
  36  * are met:
  37  * 1. Redistributions of source code must retain the above copyright
  38  *    notice, this list of conditions and the following disclaimer.
  39  * 2. Redistributions in binary form must reproduce the above copyright
  40  *    notice, this list of conditions and the following disclaimer in the
  41  *    documentation and/or other materials provided with the distribution.
  42  * 3. The name of the author may not be used to endorse or promote products
  43  *    derived from this software without specific prior written permission.
  44  *
  45  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  46  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  47  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  48  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  49  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  50  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  51  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  52  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  53  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  54  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  55  * SUCH DAMAGE.
  56  */
  57
  58 /*
  59  * AUXIO registers support on the SBus & EBus2, used for the floppy driver
  60  * and to control the system LED, for the BLINK option.
  61  */
  62
  63 #include <sys/cdefs.h>
  64 __FBSDID("$FreeBSD$");
  65
  66 #include <sys/param.h>
  67 #include <sys/systm.h>
  68 #include <sys/bus.h>
  69 #include <sys/kernel.h>
  70 #include <sys/lock.h>
  71 #include <sys/module.h>
  72 #include <sys/mutex.h>
  73 #include <sys/resource.h>
  74 #include <sys/rman.h>
  75
  76 #include <dev/led/led.h>
  77 #include <dev/ofw/ofw_bus.h>
  78 #include <dev/ofw/openfirm.h>
  79
  80 #include <machine/bus.h>
  81 #include <machine/ofw_machdep.h>
  82 #include <machine/resource.h>
  83
  84 #include <sparc64/sbus/sbusvar.h>
  85 #include <dev/auxio/auxioreg.h>
  86
  87 /*
  88  * On sun4u, auxio exists with one register (LED) on the SBus, and 5
  89  * registers on the EBus2 (pci) (LED, PCIMODE, FREQUENCY, SCSI
  90  * OSCILLATOR, and TEMP SENSE.
  91  */
  92
  93 #define AUXIO_PCIO_LED  0
  94 #define AUXIO_PCIO_PCI  1
  95 #define AUXIO_PCIO_FREQ 2
  96 #define AUXIO_PCIO_OSC  3
  97 #define AUXIO_PCIO_TEMP 4
  98 #define AUXIO_PCIO_NREG 5
  99
 100 struct auxio_softc {
 101         struct device           *sc_dev;
 102
 103         int                     sc_nauxio;
 104         struct resource         *sc_res[AUXIO_PCIO_NREG];
 105         int                     sc_rid[AUXIO_PCIO_NREG];
 106         bus_space_tag_t         sc_regt[AUXIO_PCIO_NREG];
 107         bus_space_handle_t      sc_regh[AUXIO_PCIO_NREG];
 108         struct cdev             *sc_led_dev;
 109         u_int32_t               sc_led_stat;
 110
 111         int                     sc_flags;
 112 #define AUXIO_LEDONLY           0x1
 113 #define AUXIO_EBUS              0x2
 114 #define AUXIO_SBUS              0x4
 115
 116         struct mtx              sc_lock;
 117 };
 118
 119 static void     auxio_led_func(void *arg, int onoff);
 120 static int      auxio_attach_common(struct auxio_softc *);
 121 static int      auxio_bus_probe(device_t);
 122 static int      auxio_sbus_attach(device_t);
 123 static int      auxio_ebus_attach(device_t);
 124 static int      auxio_bus_detach(device_t);
 125 static void     auxio_free_resource(struct auxio_softc *);
 126 static __inline u_int32_t auxio_led_read(struct auxio_softc *);
 127 static __inline void auxio_led_write(struct auxio_softc *, u_int32_t);
 128
 129 /* SBus */
 130 static device_method_t auxio_sbus_methods[] = {
 131         DEVMETHOD(device_probe,         auxio_bus_probe),
 132         DEVMETHOD(device_attach,        auxio_sbus_attach),
 133         DEVMETHOD(device_detach,        auxio_bus_detach),
 134
 135         DEVMETHOD_END
 136 };
 137
 138 static driver_t auxio_sbus_driver = {
 139         "auxio",
 140         auxio_sbus_methods,
 141         sizeof(struct auxio_softc)
 142 };
 143
 144 static devclass_t       auxio_devclass;
 145 /* The probe order is handled by sbus(4). */
 146 EARLY_DRIVER_MODULE(auxio, sbus, auxio_sbus_driver, auxio_devclass, 0, 0,
 147     BUS_PASS_DEFAULT);
 148 MODULE_DEPEND(auxio, sbus, 1, 1, 1);
 149
 150 /* EBus */
 151 static device_method_t auxio_ebus_methods[] = {
 152         DEVMETHOD(device_probe,         auxio_bus_probe),
 153         DEVMETHOD(device_attach,        auxio_ebus_attach),
 154         DEVMETHOD(device_detach,        auxio_bus_detach),
 155
 156         DEVMETHOD_END
 157 };
 158
 159 static driver_t auxio_ebus_driver = {
 160         "auxio",
 161         auxio_ebus_methods,
 162         sizeof(struct auxio_softc)
 163 };
 164
 165 EARLY_DRIVER_MODULE(auxio, ebus, auxio_ebus_driver, auxio_devclass, 0, 0,
 166     BUS_PASS_DEFAULT);
 167 MODULE_DEPEND(auxio, ebus, 1, 1, 1);
 168 MODULE_VERSION(auxio, 1);
 169
 170 #define AUXIO_LOCK_INIT(sc)     \
 171         mtx_init(&sc->sc_lock, "auxio mtx", NULL, MTX_DEF)
 172 #define AUXIO_LOCK(sc)          mtx_lock(&sc->sc_lock)
 173 #define AUXIO_UNLOCK(sc)        mtx_unlock(&sc->sc_lock)
 174 #define AUXIO_LOCK_DESTROY(sc)  mtx_destroy(&sc->sc_lock)
 175
 176 static __inline void
 177 auxio_led_write(struct auxio_softc *sc, u_int32_t v)
 178 {
 179         if (sc->sc_flags & AUXIO_EBUS)
 180                 bus_space_write_4(sc->sc_regt[AUXIO_PCIO_LED],
 181                     sc->sc_regh[AUXIO_PCIO_LED], 0, v);
 182         else
 183                 bus_space_write_1(sc->sc_regt[AUXIO_PCIO_LED],
 184                     sc->sc_regh[AUXIO_PCIO_LED], 0, v);
 185 }
 186
 187 static __inline u_int32_t
 188 auxio_led_read(struct auxio_softc *sc)
 189 {
 190         u_int32_t led;
 191
 192         if (sc->sc_flags & AUXIO_EBUS)
 193                 led = bus_space_read_4(sc->sc_regt[AUXIO_PCIO_LED],
 194                     sc->sc_regh[AUXIO_PCIO_LED], 0);
 195         else
 196                 led = bus_space_read_1(sc->sc_regt[AUXIO_PCIO_LED],
 197                     sc->sc_regh[AUXIO_PCIO_LED], 0);
 198
 199         return (led);
 200 }
 201
 202 static void
 203 auxio_led_func(void *arg, int onoff)
 204 {
 205         struct auxio_softc *sc;
 206         u_int32_t led;
 207
 208         sc = (struct auxio_softc *)arg;
 209
 210         AUXIO_LOCK(sc);
 211         /*
 212          * NB: We must not touch the other bits of the SBus AUXIO reg.
 213          */
 214         led = auxio_led_read(sc);
 215         if (onoff)
 216                 led |= AUXIO_LED_LED;
 217         else
 218                 led &= ~AUXIO_LED_LED;
 219         auxio_led_write(sc, led);
 220         AUXIO_UNLOCK(sc);
 221 }
 222
 223 static int
 224 auxio_bus_probe(device_t dev)
 225 {
 226         const char *name;
 227
 228         name = ofw_bus_get_name(dev);
 229         if (strcmp("auxio", name) == 0) {
 230                 device_set_desc(dev, "Sun Auxiliary I/O");
 231                 return (0);
 232         }
 233
 234         return (ENXIO);
 235 }
 236
 237 static int
 238 auxio_ebus_attach(device_t dev)
 239 {
 240         struct auxio_softc *sc;
 241
 242         sc = device_get_softc(dev);
 243         sc->sc_dev = dev;
 244
 245         AUXIO_LOCK_INIT(sc);
 246         sc->sc_nauxio = AUXIO_PCIO_NREG;
 247         sc->sc_flags = AUXIO_LEDONLY | AUXIO_EBUS;
 248
 249         return(auxio_attach_common(sc));
 250 }
 251
 252 static int
 253 auxio_attach_common(struct auxio_softc *sc)
 254 {
 255         struct resource *res;
 256         int i;
 257
 258         for (i = 0; i < sc->sc_nauxio; i++) {
 259                 sc->sc_rid[i] = i;
 260                 res = bus_alloc_resource_any(sc->sc_dev, SYS_RES_MEMORY,
 261                     &sc->sc_rid[i], RF_ACTIVE);
 262                 if (res == NULL) {
 263                         device_printf(sc->sc_dev,
 264                             "could not allocate resources\n");
 265                         goto attach_fail;
 266                 }
 267                 sc->sc_res[i] = res;
 268                 sc->sc_regt[i] = rman_get_bustag(res);
 269                 sc->sc_regh[i] = rman_get_bushandle(res);
 270         }
 271
 272         sc->sc_led_stat = auxio_led_read(sc) & AUXIO_LED_LED;
 273         sc->sc_led_dev = led_create(auxio_led_func, sc, "auxioled");
 274         /* turn on the LED */
 275         auxio_led_func(sc, 1);
 276
 277         return (0);
 278
 279 attach_fail:
 280         auxio_free_resource(sc);
 281
 282         return (ENXIO);
 283 }
 284
 285 static int
 286 auxio_bus_detach(device_t dev)
 287 {
 288         struct auxio_softc *sc;
 289
 290         sc = device_get_softc(dev);
 291         led_destroy(sc->sc_led_dev);
 292         auxio_led_func(sc, sc->sc_led_stat);
 293         auxio_free_resource(sc);
 294
 295         return (0);
 296 }
 297
 298 static void
 299 auxio_free_resource(struct auxio_softc *sc)
 300 {
 301         int i;
 302
 303         for (i = 0; i < sc->sc_nauxio; i++)
 304                 if (sc->sc_res[i])
 305                         bus_release_resource(sc->sc_dev, SYS_RES_MEMORY,
 306                             sc->sc_rid[i], sc->sc_res[i]);
 307         AUXIO_LOCK_DESTROY(sc);
 308 }
 309
 310 static int
 311 auxio_sbus_attach(device_t dev)
 312 {
 313         struct auxio_softc *sc;
 314
 315         sc = device_get_softc(dev);
 316         sc->sc_dev = dev;
 317
 318         AUXIO_LOCK_INIT(sc);
 319         sc->sc_nauxio = 1;
 320         sc->sc_flags = AUXIO_LEDONLY | AUXIO_SBUS;
 321
 322         return (auxio_attach_common(sc));
 323 }