sys/arch/hpcmips/vr/vrpmu.c

   1 /*      $NetBSD: vrpmu.c,v 1.16.6.3 2004/09/21 13:16:15 skrll Exp $     */
   2
   3 /*
   4  * Copyright (c) 1999 M. Warner Losh.  All rights reserved.
   5  * Copyright (c) 2000 SATO Kazumi. All rights reserved.
   6  * Copyright (c) 1999,2000 PocketBSD Project. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __KERNEL_RCSID(0, "$NetBSD: vrpmu.c,v 1.16.6.3 2004/09/21 13:16:15 skrll Exp $");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/device.h>
  36
  37 #include <machine/bus.h>
  38 #include <machine/config_hook.h>
  39 #include <machine/debug.h>
  40
  41 #include <hpcmips/vr/vripif.h>
  42 #include <hpcmips/vr/vrpmuvar.h>
  43 #include <hpcmips/vr/vrpmureg.h>
  44
  45 #include "vrbcu.h"
  46 #if NVRBCU > 0
  47 #include <hpcmips/vr/bcuvar.h>
  48 #include <hpcmips/vr/bcureg.h>
  49 #endif
  50
  51 #ifdef VRPMUDEBUG
  52 #define DEBUG_BOOT      0x1     /* boot time */
  53 #define DEBUG_INTR      0x2     /* intr */
  54 #define DEBUG_IO        0x4     /* I/O */
  55 #ifndef VRPMUDEBUG_CONF
  56 #define VRPMUDEBUG_CONF 0
  57 #endif /* VRPMUDEBUG_CONF */
  58 int vrpmudebug = VRPMUDEBUG_CONF;
  59 #define DPRINTF(flag, arg) if (vrpmudebug&flag) printf arg;
  60 #define DDUMP_INTR2(flag, arg1, arg2)                                   \
  61         if (vrpmudebug&flag) vrpmu_dump_intr2(arg1,arg2);
  62 #define DDUMP_REGS(flag, arg) if (vrpmudebug&flag) vrpmu_dump_regs(arg);
  63 #else /* VRPMUDEBUG */
  64 #define DPRINTF(flag, arg)
  65 #define DDUMP_INTR2(flag, arg1, arg2)
  66 #define DDUMP_REGS(flag, arg)
  67 #endif /* VRPMUDEBUG */
  68
  69 static int vrpmumatch(struct device *, struct cfdata *, void *);
  70 static void vrpmuattach(struct device *, struct device *, void *);
  71
  72 static void vrpmu_write(struct vrpmu_softc *, int, unsigned short);
  73 static unsigned short vrpmu_read(struct vrpmu_softc *, int);
  74
  75 int vrpmu_intr(void *);
  76 void vrpmu_dump_intr(void *);
  77 void vrpmu_dump_intr2(unsigned int, unsigned int);
  78 void vrpmu_dump_regs(void *);
  79
  80 CFATTACH_DECL(vrpmu, sizeof(struct vrpmu_softc),
  81     vrpmumatch, vrpmuattach, NULL, NULL);
  82
  83 struct vrpmu_softc *this_pmu;
  84
  85 static inline void
  86 vrpmu_write(struct vrpmu_softc *sc, int port, unsigned short val)
  87 {
  88
  89         bus_space_write_2(sc->sc_iot, sc->sc_ioh, port, val);
  90 }
  91
  92 static inline unsigned short
  93 vrpmu_read(struct vrpmu_softc *sc, int port)
  94 {
  95
  96         return (bus_space_read_2(sc->sc_iot, sc->sc_ioh, port));
  97 }
  98
  99 static int
 100 vrpmumatch(struct device *parent, struct cfdata *cf, void *aux)
 101 {
 102
 103         return (1);
 104 }
 105
 106 static void
 107 vrpmuattach(struct device *parent, struct device *self, void *aux)
 108 {
 109         struct vrpmu_softc *sc = (struct vrpmu_softc *)self;
 110         struct vrip_attach_args *va = aux;
 111 #if NVRBCU > 0
 112         int cpuid;
 113 #endif /* NVRBCU > 0 */
 114
 115         bus_space_tag_t iot = va->va_iot;
 116         bus_space_handle_t ioh;
 117
 118         if (bus_space_map(iot, va->va_addr, 1, 0, &ioh)) {
 119                 printf(": can't map bus space\n");
 120                 return;
 121         }
 122
 123         sc->sc_iot = iot;
 124         sc->sc_ioh = ioh;
 125
 126         if (!(sc->sc_handler =
 127             vrip_intr_establish(va->va_vc, va->va_unit, 0, IPL_TTY,
 128                 vrpmu_intr, sc))) {
 129                 printf (": can't map interrupt line.\n");
 130                 return;
 131         }
 132         if (!vrip_intr_establish(va->va_vc, va->va_unit, 1, IPL_TTY,
 133             vrpmu_intr, sc)) {
 134                 printf (": can't map interrupt line.\n");
 135                 return;
 136         }
 137
 138         printf("\n");
 139         /* dump current intrrupt states */
 140         vrpmu_dump_intr(sc);
 141         DDUMP_REGS(DEBUG_BOOT, sc);
 142         /* clear interrupt status */
 143         vrpmu_write(sc, PMUINT_REG_W, PMUINT_ALL);
 144         vrpmu_write(sc, PMUINT2_REG_W, PMUINT2_ALL);
 145 #if NVRBCU > 0
 146         cpuid = vrbcu_vrip_getcpuid();
 147         if (cpuid >= BCUREVID_RID_4111){
 148                 vrpmu_write(sc, PMUWAIT_REG_W, PMUWAIT_DEFAULT);
 149         }
 150 #endif /* NVRBCU */
 151
 152         this_pmu = sc;
 153 }
 154
 155 /*
 156  * dump PMU intr status regs
 157  *
 158  */
 159 void
 160 vrpmu_dump_intr(void *arg)
 161 {
 162         struct vrpmu_softc *sc = arg;
 163         unsigned int intstat1;
 164         unsigned int intstat2;
 165
 166         intstat1 = vrpmu_read(sc, PMUINT_REG_W);
 167         intstat2 = vrpmu_read(sc, PMUINT2_REG_W);
 168         vrpmu_dump_intr2(intstat1, intstat2);
 169 }
 170
 171 /*
 172  * dump PMU intr status regs
 173  */
 174 void
 175 vrpmu_dump_intr2(unsigned int intstat1, unsigned int intstat2)
 176 {
 177         if (intstat1 & PMUINT_GPIO3)
 178                 printf("vrpmu: GPIO[3] activation\n");
 179         if (intstat1 & PMUINT_GPIO2)
 180                 printf("vrpmu: GPIO[2] activation\n");
 181         if (intstat1 & PMUINT_GPIO1)
 182                 printf("vrpmu: GPIO[1] activation\n");
 183         if (intstat1 & PMUINT_GPIO0)
 184                 printf("vrpmu: GPIO[0] activation\n");
 185
 186         if (intstat1 & PMUINT_RTC)
 187                 printf("vrpmu: RTC alarm detected\n");
 188         if (intstat1 & PMUINT_BATT)
 189                 printf("vrpmu: Battery low during activation\n");
 190
 191         if (intstat1 & PMUINT_TIMOUTRST)
 192                 printf("vrpmu: HAL timer reset\n");
 193         if (intstat1 & PMUINT_RTCRST)
 194                 printf("vrpmu: RTC reset detected\n");
 195         if (intstat1 & PMUINT_RSTSWRST)
 196                 printf("vrpmu: RESET switch detected\n");
 197         if (intstat1 & PMUINT_DMSWRST)
 198                 printf("vrpmu: Deadman's switch detected\n");
 199         if (intstat1 & PMUINT_BATTINTR)
 200                 printf("vrpmu: Battery low during normal ops\n");
 201         if (intstat1 & PMUINT_POWERSW)
 202                 printf("vrpmu: POWER switch detected\n");
 203
 204         if (intstat2 & PMUINT_GPIO12)
 205                 printf("vrpmu: GPIO[12] activation\n");
 206         if (intstat2 & PMUINT_GPIO11)
 207                 printf("vrpmu: GPIO[11] activation\n");
 208         if (intstat2 & PMUINT_GPIO10)
 209                 printf("vrpmu: GPIO[10] activation\n");
 210         if (intstat2 & PMUINT_GPIO9)
 211                 printf("vrpmu: GPIO[9] activation\n");
 212 }
 213
 214 /*
 215  * dump PMU registers
 216  *
 217  */
 218 void
 219 vrpmu_dump_regs(void *arg)
 220 {
 221         struct vrpmu_softc *sc = arg;
 222         unsigned int intstat1;
 223         unsigned int intstat2;
 224         unsigned int reg;
 225 #if NVRBCU > 0
 226         int cpuid;
 227 #endif
 228         intstat1 = vrpmu_read(sc, PMUINT_REG_W);
 229         intstat2 = vrpmu_read(sc, PMUINT2_REG_W);
 230
 231         /* others? XXXX */
 232         reg = vrpmu_read(sc, PMUCNT_REG_W);
 233         printf("vrpmu: cnt 0x%x: ", reg);
 234         dbg_bit_print(reg);
 235         reg = vrpmu_read(sc, PMUCNT2_REG_W);
 236         printf("vrpmu: cnt2 0x%x: ", reg);
 237         dbg_bit_print(reg);
 238 #if NVRBCU > 0
 239         cpuid = vrbcu_vrip_getcpuid();
 240         if (cpuid >= BCUREVID_RID_4111){
 241                 reg = vrpmu_read(sc, PMUWAIT_REG_W);
 242                 printf("vrpmu: wait 0x%x", reg);
 243         }
 244         if (cpuid >= BCUREVID_RID_4121){
 245                 reg = vrpmu_read(sc, PMUDIV_REG_W);
 246                 printf(" div 0x%x", reg);
 247         }
 248         printf("\n");
 249 #endif /*  NVRBCU > 0 */
 250 }
 251
 252 /*
 253  * PMU interrupt handler.
 254  * XXX
 255  *
 256  * In the following interrupt routine we should actually DO something
 257  * with the knowledge that we've gained.  For now we just report it.
 258  */
 259 int
 260 vrpmu_intr(void *arg)
 261 {
 262         struct vrpmu_softc *sc = arg;
 263         unsigned int intstat1;
 264         unsigned int intstat2;
 265
 266         intstat1 = vrpmu_read(sc, PMUINT_REG_W);
 267         /* clear interrupt status */
 268         vrpmu_write(sc, PMUINT_REG_W, intstat1);
 269
 270
 271         intstat2 = vrpmu_read(sc, PMUINT2_REG_W);
 272         /* clear interrupt status */
 273         vrpmu_write(sc, PMUINT2_REG_W, intstat2);
 274
 275         DDUMP_INTR2(DEBUG_INTR, intstat1, intstat2);
 276
 277         if (intstat1 & PMUINT_GPIO3)
 278                 ;
 279         if (intstat1 & PMUINT_GPIO2)
 280                 ;
 281         if (intstat1 & PMUINT_GPIO1)
 282                 ;
 283         if (intstat1 & PMUINT_GPIO0)
 284                 ;
 285
 286         if (intstat1 & PMUINT_RTC)
 287                 ;
 288         if (intstat1 & PMUINT_BATT)
 289                 config_hook_call(CONFIG_HOOK_PMEVENT,
 290                     CONFIG_HOOK_PMEVENT_SUSPENDREQ, NULL);
 291         if (intstat1 & PMUINT_TIMOUTRST)
 292                 ;
 293         if (intstat1 & PMUINT_RTCRST)
 294                 ;
 295         if (intstat1 & PMUINT_RSTSWRST)
 296                 ;
 297         if (intstat1 & PMUINT_DMSWRST)
 298                 ;
 299         if (intstat1 & PMUINT_BATTINTR)
 300                 config_hook_call(CONFIG_HOOK_PMEVENT,
 301                     CONFIG_HOOK_PMEVENT_SUSPENDREQ, NULL);
 302         if (intstat1 & PMUINT_POWERSW) {
 303                 /*
 304                  * you can't detect when the button is released
 305                  */
 306                 config_hook_call(CONFIG_HOOK_BUTTONEVENT,
 307                     CONFIG_HOOK_BUTTONEVENT_POWER,
 308                     (void*)1 /* on */);
 309                 config_hook_call(CONFIG_HOOK_BUTTONEVENT,
 310                     CONFIG_HOOK_BUTTONEVENT_POWER,
 311                     (void*)0 /* off */);
 312         }
 313
 314         if (intstat2 & PMUINT_GPIO12)
 315                 ;
 316         if (intstat2 & PMUINT_GPIO11)
 317                 ;
 318         if (intstat2 & PMUINT_GPIO10)
 319                 ;
 320         if (intstat2 & PMUINT_GPIO9)
 321                 ;
 322
 323         return (0);
 324 }