/*      $NetBSD: hpcapm.c,v 1.24 2021/08/07 16:19:11 thorpej Exp $      */

/*
* Copyright (c) 2000 Takemura Shin
* Copyright (c) 2000-2001 SATO Kazumi
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: hpcapm.c,v 1.24 2021/08/07 16:19:11 thorpej Exp $");

#ifdef _KERNEL_OPT
#include "opt_hpcapm.h"
#endif

#include <sys/param.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/selinfo.h> /* XXX: for apm_softc that is exposed here */

#include <dev/hpc/apm/apmvar.h>

#include <sys/bus.h>
#include <machine/config_hook.h>
#include <machine/platid.h>
#include <machine/platid_mask.h>

#include "ioconf.h"

#ifdef HPCAPMDEBUG
#ifndef HPCAPMDEBUG_CONF
#define HPCAPMDEBUG_CONF 1
#endif
int     hpcapm_debug = HPCAPMDEBUG_CONF;
#define DPRINTF(arg)     do { if (hpcapm_debug) printf arg; } while(0);
#define DPRINTFN(n, arg) do { if (hpcapm_debug > (n)) printf arg; } while (0);
#else
#define DPRINTF(arg)     do { } while (0);
#define DPRINTFN(n, arg) do { } while (0);
#endif

/* Definition of the driver for autoconfig. */
static int      hpcapm_match(device_t, cfdata_t, void *);
static void     hpcapm_attach(device_t, device_t, void *);
static int      hpcapm_hook(void *, int, long, void *);

static void     hpcapm_disconnect(void *);
static void     hpcapm_enable(void *, int);
static int      hpcapm_set_powstate(void *, u_int, u_int);
static int      hpcapm_get_powstat(void *, u_int, struct apm_power_info *);
static int      hpcapm_get_event(void *, u_int *, u_int *);
static void     hpcapm_cpu_busy(void *);
static void     hpcapm_cpu_idle(void *);
static void     hpcapm_get_capabilities(void *, u_int *, u_int *);

struct apmhpc_softc {
       void *sc_apmdev;
       volatile unsigned int events;
       volatile int power_state;
       volatile int battery_flags;
       volatile int ac_state;
       config_hook_tag sc_standby_hook;
       config_hook_tag sc_suspend_hook;
       config_hook_tag sc_battery_hook;
       config_hook_tag sc_ac_hook;
       int battery_life;
       int minutes_left;
};

CFATTACH_DECL_NEW(hpcapm, sizeof (struct apmhpc_softc),
   hpcapm_match, hpcapm_attach, NULL, NULL);

struct apm_accessops hpcapm_accessops = {
       hpcapm_disconnect,
       hpcapm_enable,
       hpcapm_set_powstate,
       hpcapm_get_powstat,
       hpcapm_get_event,
       hpcapm_cpu_busy,
       hpcapm_cpu_idle,
       hpcapm_get_capabilities,
};

static int
hpcapm_match(device_t parent, cfdata_t cf, void *aux)
{

       return 1;
}

static void
hpcapm_attach(device_t parent, device_t self, void *aux)
{
       struct apmhpc_softc *sc;
       struct apmdev_attach_args aaa;

       sc = device_private(self);
       printf(": pseudo power management module\n");

       sc->events = 0;
       sc->power_state = APM_SYS_READY;
       sc->battery_flags = APM_BATT_FLAG_UNKNOWN;
       sc->ac_state = APM_AC_UNKNOWN;
       sc->battery_life = APM_BATT_LIFE_UNKNOWN;
       sc->minutes_left = 0;
       sc->sc_standby_hook = config_hook(CONFIG_HOOK_PMEVENT,
                                         CONFIG_HOOK_PMEVENT_STANDBYREQ,
                                         CONFIG_HOOK_EXCLUSIVE,
                                         hpcapm_hook, sc);
       sc->sc_suspend_hook = config_hook(CONFIG_HOOK_PMEVENT,
                                         CONFIG_HOOK_PMEVENT_SUSPENDREQ,
                                         CONFIG_HOOK_EXCLUSIVE,
                                         hpcapm_hook, sc);

       sc->sc_battery_hook = config_hook(CONFIG_HOOK_PMEVENT,
                                         CONFIG_HOOK_PMEVENT_BATTERY,
                                         CONFIG_HOOK_SHARE,
                                         hpcapm_hook, sc);

       sc->sc_ac_hook = config_hook(CONFIG_HOOK_PMEVENT,
                                    CONFIG_HOOK_PMEVENT_AC,
                                    CONFIG_HOOK_SHARE,
                                    hpcapm_hook, sc);

       aaa.accessops = &hpcapm_accessops;
       aaa.accesscookie = sc;
       aaa.apm_detail = 0x0102;

       sc->sc_apmdev = config_found(self, &aaa, apmprint, CFARGS_NONE);

       if (!pmf_device_register(self, NULL, NULL))
               aprint_error_dev(self, "unable to establish power handler\n");
}

static int
hpcapm_hook(void *ctx, int type, long id, void *msg)
{
       struct apmhpc_softc *sc;
       int s;
       int charge;
       int message;

       sc = ctx;

       if (type != CONFIG_HOOK_PMEVENT)
               return 1;

       if (CONFIG_HOOK_VALUEP(msg))
               message = (int)msg;
       else
               message = *(int *)msg;

       s = splhigh();
       switch (id) {
       case CONFIG_HOOK_PMEVENT_STANDBYREQ:
               if (sc->power_state != APM_SYS_STANDBY) {
                       sc->events |= (1 << APM_USER_STANDBY_REQ);
               } else {
                       sc->events |= (1 << APM_NORMAL_RESUME);
               }
               break;
       case CONFIG_HOOK_PMEVENT_SUSPENDREQ:
               if (sc->power_state != APM_SYS_SUSPEND) {
                       DPRINTF(("hpcapm: suspend request\n"));
                       sc->events |= (1 << APM_USER_SUSPEND_REQ);
               } else {
                       sc->events |= (1 << APM_NORMAL_RESUME);
               }
               break;
       case CONFIG_HOOK_PMEVENT_BATTERY:
               switch (message) {
               case CONFIG_HOOK_BATT_CRITICAL:
                       DPRINTF(("hpcapm: battery state critical\n"));
                       charge = sc->battery_flags & APM_BATT_FLAG_CHARGING;
                       sc->battery_flags = APM_BATT_FLAG_CRITICAL;
                       sc->battery_flags |= charge;
                       sc->battery_life = 0;
                       break;
               case CONFIG_HOOK_BATT_LOW:
                       DPRINTF(("hpcapm: battery state low\n"));
                       charge = sc->battery_flags & APM_BATT_FLAG_CHARGING;
                       sc->battery_flags = APM_BATT_FLAG_LOW;
                       sc->battery_flags |= charge;
                       break;
               case CONFIG_HOOK_BATT_HIGH:
                       DPRINTF(("hpcapm: battery state high\n"));
                       charge = sc->battery_flags & APM_BATT_FLAG_CHARGING;
                       sc->battery_flags = APM_BATT_FLAG_HIGH;
                       sc->battery_flags |= charge;
                       break;
               case CONFIG_HOOK_BATT_10P:
                       DPRINTF(("hpcapm: battery life 10%%\n"));
                       sc->battery_life = 10;
                       break;
               case CONFIG_HOOK_BATT_20P:
                       DPRINTF(("hpcapm: battery life 20%%\n"));
                       sc->battery_life = 20;
                       break;
               case CONFIG_HOOK_BATT_30P:
                       DPRINTF(("hpcapm: battery life 30%%\n"));
                       sc->battery_life = 30;
                       break;
               case CONFIG_HOOK_BATT_40P:
                       DPRINTF(("hpcapm: battery life 40%%\n"));
                       sc->battery_life = 40;
                       break;
               case CONFIG_HOOK_BATT_50P:
                       DPRINTF(("hpcapm: battery life 50%%\n"));
                       sc->battery_life = 50;
                       break;
               case CONFIG_HOOK_BATT_60P:
                       DPRINTF(("hpcapm: battery life 60%%\n"));
                       sc->battery_life = 60;
                       break;
               case CONFIG_HOOK_BATT_70P:
                       DPRINTF(("hpcapm: battery life 70%%\n"));
                       sc->battery_life = 70;
                       break;
               case CONFIG_HOOK_BATT_80P:
                       DPRINTF(("hpcapm: battery life 80%%\n"));
                       sc->battery_life = 80;
                       break;
               case CONFIG_HOOK_BATT_90P:
                       DPRINTF(("hpcapm: battery life 90%%\n"));
                       sc->battery_life = 90;
                       break;
               case CONFIG_HOOK_BATT_100P:
                       DPRINTF(("hpcapm: battery life 100%%\n"));
                       sc->battery_life = 100;
                       break;
               case CONFIG_HOOK_BATT_UNKNOWN:
                       DPRINTF(("hpcapm: battery state unknown\n"));
                       sc->battery_flags = APM_BATT_FLAG_UNKNOWN;
                       sc->battery_life = APM_BATT_LIFE_UNKNOWN;
                       break;
               case CONFIG_HOOK_BATT_NO_SYSTEM_BATTERY:
                       DPRINTF(("hpcapm: battery state no system battery?\n"));
                       sc->battery_flags = APM_BATT_FLAG_NO_SYSTEM_BATTERY;
                       sc->battery_life = APM_BATT_LIFE_UNKNOWN;
                       break;
               }
               break;
       case CONFIG_HOOK_PMEVENT_AC:
               switch (message) {
               case CONFIG_HOOK_AC_OFF:
                       DPRINTF(("hpcapm: ac not connected\n"));
                       sc->battery_flags &= ~APM_BATT_FLAG_CHARGING;
                       sc->ac_state = APM_AC_OFF;
                       break;
               case CONFIG_HOOK_AC_ON_CHARGE:
                       DPRINTF(("hpcapm: charging\n"));
                       sc->battery_flags |= APM_BATT_FLAG_CHARGING;
                       sc->ac_state = APM_AC_ON;
                       break;
               case CONFIG_HOOK_AC_ON_NOCHARGE:
                       DPRINTF(("hpcapm: ac connected\n"));
                       sc->battery_flags &= ~APM_BATT_FLAG_CHARGING;
                       sc->ac_state = APM_AC_ON;
                       break;
               case CONFIG_HOOK_AC_UNKNOWN:
                       sc->ac_state = APM_AC_UNKNOWN;
                       break;
               }
               break;
       }
       splx(s);

       return (0);
}

static void
hpcapm_disconnect(void *scx)
{
}

static void
hpcapm_enable(void *scx, int onoff)
{
}

static int
hpcapm_set_powstate(void *scx, u_int devid, u_int powstat)
{
       struct apmhpc_softc *sc;
       int s;

       sc = scx;

       if (devid != APM_DEV_ALLDEVS)
               return APM_ERR_UNRECOG_DEV;

       switch (powstat) {
       case APM_SYS_READY:
               DPRINTF(("hpcapm: set power state READY\n"));
               sc->power_state = APM_SYS_READY;
               break;
       case APM_SYS_STANDBY:
               DPRINTF(("hpcapm: set power state STANDBY\n"));
               s = splhigh();
               config_hook_call(CONFIG_HOOK_PMEVENT,
                                CONFIG_HOOK_PMEVENT_HARDPOWER,
                                (void *)PWR_STANDBY);
               sc->power_state = APM_SYS_STANDBY;
               machine_standby();
               config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
                   CONFIG_HOOK_PMEVENT_HARDPOWER,
                   (void *)PWR_RESUME);
               DPRINTF(("hpcapm: resume\n"));
               splx(s);
               break;
       case APM_SYS_SUSPEND:
               DPRINTF(("hpcapm: set power state SUSPEND...\n"));
               s = splhigh();
               config_hook_call(CONFIG_HOOK_PMEVENT,
                   CONFIG_HOOK_PMEVENT_HARDPOWER,
                   (void *)PWR_SUSPEND);
               sc->power_state = APM_SYS_SUSPEND;
               machine_sleep();
               config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
                                CONFIG_HOOK_PMEVENT_HARDPOWER,
                                (void *)PWR_RESUME);
               DPRINTF(("hpcapm: resume\n"));
               splx(s);
               break;
       case APM_SYS_OFF:
               DPRINTF(("hpcapm: set power state OFF\n"));
               sc->power_state = APM_SYS_OFF;
               break;
       case APM_LASTREQ_INPROG:
               /*DPRINTF(("hpcapm: set power state INPROG\n"));
                */
               break;
       case APM_LASTREQ_REJECTED:
               DPRINTF(("hpcapm: set power state REJECTED\n"));
               break;
       }

       return (0);
}

static int
hpcapm_get_powstat(void *scx, u_int batteryid, struct apm_power_info *pinfo)
{
       struct apmhpc_softc *sc;
       int val;

       sc = scx;

       pinfo->nbattery = 0;
       pinfo->batteryid = 0;
       pinfo->minutes_valid = 0;
       pinfo->minutes_left = 0;
       pinfo->battery_state = APM_BATT_UNKNOWN; /* XXX: ignored */

       if (config_hook_call(CONFIG_HOOK_GET,
                            CONFIG_HOOK_ACADAPTER, &val) != -1)
               pinfo->ac_state = val;
       else
               pinfo->ac_state = sc->ac_state;

       if (config_hook_call(CONFIG_HOOK_GET,
                            CONFIG_HOOK_CHARGE, &val) != -1)
               pinfo->battery_flags = val;
       else
               pinfo->battery_flags = sc->battery_flags;

       if (config_hook_call(CONFIG_HOOK_GET,
                            CONFIG_HOOK_BATTERYVAL, &val) != -1)
               pinfo->battery_life = val;
       else
               pinfo->battery_life = sc->battery_life;

       return (0);
}

static int
hpcapm_get_event(void *scx, u_int *event_type, u_int *event_info)
{
       struct apmhpc_softc *sc;
       int s, i;

       sc = scx;
       s = splhigh();
       for (i = APM_STANDBY_REQ; i <= APM_CAP_CHANGE; i++) {
               if (sc->events & (1 << i)) {
                       sc->events &= ~(1 << i);
                       *event_type = i;
                       if (*event_type == APM_NORMAL_RESUME ||
                           *event_type == APM_CRIT_RESUME) {
                               /* pccard power off in the suspend state */
                               *event_info = 1;
                               sc->power_state = APM_SYS_READY;
                       } else
                               *event_info = 0;
                       splx(s);

                       return (0);
               }
       }
       splx(s);

       return APM_ERR_NOEVENTS;
}

static void
hpcapm_cpu_busy(void *scx)
{
}

static void
hpcapm_cpu_idle(void *scx)
{
}

static void
hpcapm_get_capabilities(void *scx, u_int *numbatts, u_int *capflags)
{
       *numbatts = 0;
       *capflags = APM_GLOBAL_STANDBY | APM_GLOBAL_SUSPEND;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.