/*      $NetBSD: power.c,v 1.3 2019/04/15 20:40:37 skrll Exp $  */

/*
* Copyright (c) 2004 Jochen Kunz.
* 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.
* 3. The name of Jochen Kunz may not be used to endorse or promote
*    products derived from this software without specific prior
*    written permission.
*
* THIS SOFTWARE IS PROVIDED BY JOCHEN KUNZ
* ``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 JOCHEN KUNZ
* 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.
*/

/*      $OpenBSD: power.c,v 1.5 2004/06/11 12:53:09 mickey Exp $        */

/*
* Copyright (c) 2003 Michael Shalayeff
* 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 AUTHOR ``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 AUTHOR OR HIS RELATIVES 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 MIND, 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/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/reboot.h>
#include <sys/device.h>
#include <sys/sysctl.h>
#include <sys/kmem.h>

#include <machine/reg.h>
#include <machine/pdc.h>
#include <machine/autoconf.h>

#include <hppa/dev/cpudevs.h>

#include <dev/sysmon/sysmon_taskq.h>
#include <dev/sysmon/sysmonvar.h>

/* Enable / disable control over the power switch. */
#define PWR_SW_CTRL_DISABLE     0
#define PWR_SW_CTRL_ENABLE      1
#define PWR_SW_CTRL_LOCK        2
#define PWR_SW_CTRL_MAX         PWR_SW_CTRL_LOCK

struct power_softc {
       device_t sc_dev;
       bus_space_tag_t sc_bst;
       bus_space_handle_t sc_bsh;

       void (*sc_kicker)(void *);

       struct callout sc_callout;
       int sc_timeout;

       int sc_dr_cnt;
};

int     powermatch(device_t, cfdata_t, void *);
void    powerattach(device_t, device_t, void *);

CFATTACH_DECL_NEW(power, sizeof(struct power_softc),
   powermatch, powerattach, NULL, NULL);

static struct pdc_power_info pdc_power_info;
static bool pswitch_on;                 /* power switch */
static int pwr_sw_control;
static const char *pwr_sw_control_str[] = {"disabled", "enabled", "locked"};
static struct sysmon_pswitch *pwr_sw_sysmon;

static int pwr_sw_sysctl_state(SYSCTLFN_PROTO);
static int pwr_sw_sysctl_ctrl(SYSCTLFN_PROTO);
static void pwr_sw_sysmon_cb(void *);
static void pwr_sw_ctrl(int);
static int pwr_sw_init(struct power_softc *);

void power_thread_dr(void *v);
void power_thread_reg(void *v);
void power_cold_hook_reg(int);

int
powermatch(device_t parent, cfdata_t cf, void *aux)
{
       struct confargs *ca = aux;

       if (cf->cf_unit > 0 && !strcmp(ca->ca_name, "power"))
               return (0);

       return (1);
}

void
powerattach(device_t parent, device_t self, void *aux)
{
       struct power_softc *sc = device_private(self);
       struct confargs *ca = aux;
       int err;

       sc->sc_dev = self;
       sc->sc_kicker = NULL;

       err = pdcproc_soft_power_info(&pdc_power_info);

       if (!err)
               ca->ca_hpa = pdc_power_info.addr;

       switch (cpu_modelno) {
       case HPPA_BOARD_HP712_60:
       case HPPA_BOARD_HP712_80:
       case HPPA_BOARD_HP712_100:
       case HPPA_BOARD_HP712_120:
               sc->sc_kicker = power_thread_dr;

               /* Diag Reg. needs software dampening, poll at 0.2 Hz.*/
               sc->sc_timeout = hz / 5;

               aprint_normal(": DR25\n");
               break;

       default:
               if (ca->ca_hpa) {
                       sc->sc_bst = ca->ca_iot;
                       if (bus_space_map(sc->sc_bst, ca->ca_hpa, 4, 0,
                           &sc->sc_bsh) != 0)
                               aprint_error_dev(self,
                                   "Can't map power switch status reg.\n");

                       cold_hook = power_cold_hook_reg;
                       sc->sc_kicker = power_thread_reg;

                       /* Power Reg. is hardware dampened, poll at 1 Hz. */
                       sc->sc_timeout = hz;

                       aprint_normal("\n");
               } else
                       aprint_normal(": not available\n");
               break;
       }

       if (sc->sc_kicker) {
               if (pwr_sw_init(sc))
                       return;

               pswitch_on = true;
               pwr_sw_control = PWR_SW_CTRL_ENABLE;
       }
}

/*
* If the power switch is turned off we schedule a sysmon task
* to register that event for this power switch device.
*/
static void
check_pwr_state(struct power_softc *sc)
{
       if (pswitch_on == false && pwr_sw_control != PWR_SW_CTRL_LOCK)
               sysmon_task_queue_sched(0, pwr_sw_sysmon_cb, NULL);
       else
               callout_reset(&sc->sc_callout, sc->sc_timeout,
                   sc->sc_kicker, sc);
}

void
power_thread_dr(void *v)
{
       struct power_softc *sc = v;
       uint32_t r;

       /* Get Power Fail status from CPU Diagnose Register 25 */
       mfcpu(25, r);

       /*
        * On power failure, the hardware clears bit DR25_PCXL_POWFAIL
        * in CPU Diagnose Register 25.
        */
       if (r & (1 << DR25_PCXL_POWFAIL))
               sc->sc_dr_cnt = 0;
       else
               sc->sc_dr_cnt++;

       /*
        * the bit is undampened straight wire from the power
        * switch and thus we have do dampen it ourselves.
        */
       if (sc->sc_dr_cnt == sc->sc_timeout)
               pswitch_on = false;
       else
               pswitch_on = true;

       check_pwr_state(sc);
}

void
power_thread_reg(void *v)
{
       struct power_softc *sc = v;
       uint32_t r;

       r = bus_space_read_4(sc->sc_bst, sc->sc_bsh, 0);

       if (!(r & 1))
               pswitch_on = false;
       else
               pswitch_on = true;

       check_pwr_state(sc);
}

void
power_cold_hook_reg(int on)
{
       int error;

       error = pdcproc_soft_power_enable(on == HPPA_COLD_HOT);
       if (error)
               aprint_error("PDC_SOFT_POWER_ENABLE failed (%d)\n", error);
}

static int
pwr_sw_init(struct power_softc *sc)
{
       struct sysctllog *sysctl_log = NULL;
       const struct sysctlnode *pwr_sw_node;
       const char *errmsg;
       int error = EINVAL;

       /*
        * Ensure that we are on a PCX-L / PA7100LC CPU if it is a
        * 712 style machine.
        */
       if (pdc_power_info.addr == 0 && hppa_cpu_info->hci_cputype != hpcxl) {
               aprint_error_dev(sc->sc_dev, "No soft power available.\n");
               return error;
       }

       errmsg = "Can't create sysctl machdep.power_switch (or children)\n";
       error = sysctl_createv(&sysctl_log, 0, NULL, NULL, 0,
           CTLTYPE_NODE, "machdep", NULL, NULL, 0, NULL, 0,
           CTL_MACHDEP, CTL_EOL);

       if (error)
               goto err_sysctl;

       error = sysctl_createv(&sysctl_log, 0, NULL, &pwr_sw_node, 0,
           CTLTYPE_NODE, "power_switch", NULL, NULL, 0, NULL, 0,
           CTL_MACHDEP, CTL_CREATE, CTL_EOL);

       if (error)
               goto err_sysctl;

       error = sysctl_createv(&sysctl_log, 0, NULL, NULL,
           CTLFLAG_READONLY, CTLTYPE_STRING, "state", NULL,
           pwr_sw_sysctl_state, 0, NULL, 16,
           CTL_MACHDEP, pwr_sw_node->sysctl_num, CTL_CREATE, CTL_EOL);

       if (error)
               goto err_sysctl;

       error = sysctl_createv(&sysctl_log, 0, NULL, NULL,
           CTLFLAG_READWRITE, CTLTYPE_STRING, "control", NULL,
           pwr_sw_sysctl_ctrl, 0, NULL, 16,
           CTL_MACHDEP, pwr_sw_node->sysctl_num, CTL_CREATE, CTL_EOL);

       if (error)
               goto err_sysctl;

       errmsg = "Can't alloc sysmon power switch.\n";
       pwr_sw_sysmon = kmem_zalloc(sizeof(*pwr_sw_sysmon), KM_SLEEP);
       errmsg = "Can't register power switch with sysmon.\n";
       sysmon_task_queue_init();
       pwr_sw_sysmon->smpsw_name = "power switch";
       pwr_sw_sysmon->smpsw_type = PSWITCH_TYPE_POWER;
       error = sysmon_pswitch_register(pwr_sw_sysmon);

       if (error)
               goto err_sysmon;

       callout_init(&sc->sc_callout, 0);
       callout_reset(&sc->sc_callout, sc->sc_timeout, sc->sc_kicker, sc);

       return error;

err_sysmon:
       kmem_free(pwr_sw_sysmon, sizeof(*pwr_sw_sysmon));

err_sysctl:
       sysctl_teardown(&sysctl_log);

       aprint_error_dev(sc->sc_dev, errmsg);

       return error;
}

static void
pwr_sw_sysmon_cb(void *not_used)
{
       sysmon_pswitch_event(pwr_sw_sysmon, PSWITCH_EVENT_PRESSED);
}

static void
pwr_sw_ctrl(int enable)
{
       int on;

#ifdef DEBUG
       printf("pwr_sw_control=%d enable=%d\n", pwr_sw_control, enable);
#endif /* DEBUG */

       if (cold_hook == NULL)
               return;

       switch(enable) {
       case PWR_SW_CTRL_DISABLE:
               on = HPPA_COLD_OFF;
               break;
       case PWR_SW_CTRL_ENABLE:
       case PWR_SW_CTRL_LOCK:
               on = HPPA_COLD_HOT;
               break;
       default:
               panic("invalid power state in pwr_sw_control: %d", enable);
       }

       pwr_sw_control = enable;

       if (cold_hook)
               (*cold_hook)(on);
}

int
pwr_sw_sysctl_state(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       const char *status;

       if (pswitch_on == true)
               status = "on";
       else
               status = "off";

       node = *rnode;
       node.sysctl_data = __UNCONST(status);
       return sysctl_lookup(SYSCTLFN_CALL(&node));
}

int
pwr_sw_sysctl_ctrl(SYSCTLFN_ARGS)
{
       struct sysctlnode node;
       int i, error;
       char val[16];

       node = *rnode;
       strcpy(val, pwr_sw_control_str[pwr_sw_control]);

       node.sysctl_data = val;

       error = sysctl_lookup(SYSCTLFN_CALL(&node));

       if (error || newp == NULL)
               return error;

       for (i = 0; i <= PWR_SW_CTRL_MAX; i++)
               if (strcmp(val, pwr_sw_control_str[i]) == 0) {
                       pwr_sw_ctrl(i);
                       return 0;
               }

       return EINVAL;
}

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.