xref: /netbsd-src/sys/arch/x68k/dev/powsw.c (revision 98910815bb537ed17502a125b300c736caa9bce7)

/*	$NetBSD: powsw.c,v 1.4 2022/07/16 04:55:35 isaki Exp $	*/

/*
 * Copyright (c) 2011 Tetsuya Isaki. 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 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.
 */

/*
 * Power switch monitor
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: powsw.c,v 1.4 2022/07/16 04:55:35 isaki Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/intr.h>
#include <sys/callout.h>

#include <machine/bus.h>
#include <machine/cpu.h>

#include <arch/x68k/dev/intiovar.h>
#include <arch/x68k/dev/mfp.h>

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

#include "ioconf.h"

//#define POWSW_DEBUG

#if defined(POWSW_DEBUG)
#define DPRINTF(fmt...)		printf(fmt)
#define DEBUG_LOG_ADD(c)	sc->sc_log[sc->sc_loglen++] = (c)
#define DEBUG_LOG_PRINT()	do {	\
	sc->sc_log[sc->sc_loglen] = '\0';	\
	printf("%s", sc->sc_log);	\
} while (0)
#else
#define DPRINTF(fmt...)
#define DEBUG_LOG_ADD(c)
#define DEBUG_LOG_PRINT()
#endif

/* mask */
#define POWSW_ALARM		(0x01)
#define POWSW_EXTERNAL		(0x02)
#define POWSW_FRONT		(0x04)

/* parameter */
#define POWSW_MAX_TICK		(30)
#define POWSW_THRESHOLD		(10)

struct powsw_softc {
	device_t sc_dev;
	struct sysmon_pswitch sc_smpsw;
	callout_t sc_callout;
	int sc_mask;
	int sc_prev;
	int sc_last_sw;
	int sc_tick;
	int sc_count;
#if defined(POWSW_DEBUG)
	char sc_log[100];
	int sc_loglen;
#endif
};

static int  powsw_match(device_t, cfdata_t, void *);
static void powsw_attach(device_t, device_t, void *);
static int  powsw_intr(void *);
static void powsw_softintr(void *);
static void powsw_pswitch_event(void *);
static void powsw_reset_counter(struct powsw_softc *);
static void powsw_set_aer(struct powsw_softc *, int);

CFATTACH_DECL_NEW(powsw, sizeof(struct powsw_softc),
    powsw_match, powsw_attach, NULL, NULL);


typedef const struct {
	int vector;			/* interrupt vector */
	int mask;			/* mask bit for MFP GPIP */
	const char *name;
} powsw_desc_t;

static powsw_desc_t powsw_desc[2] = {
	{ 66, POWSW_FRONT,	"Front Switch", },
	{ 65, POWSW_EXTERNAL,	"External Power Switch", },
	/* XXX I'm not sure about alarm bit */
};


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

	return 1;
}

static void
powsw_attach(device_t parent, device_t self, void *aux)
{
	struct powsw_softc *sc = device_private(self);
	powsw_desc_t *desc;
	const char *xname;
	int unit;
	int sw;

	unit = device_unit(self);
	xname = device_xname(self);
	desc = &powsw_desc[unit];

	memset(sc, 0, sizeof(*sc));
	sc->sc_dev = self;
	sc->sc_mask = desc->mask;
	sc->sc_prev = -1;
	powsw_reset_counter(sc);

	sysmon_task_queue_init();
	sc->sc_smpsw.smpsw_name = xname;
	sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_POWER;
	if (sysmon_pswitch_register(&sc->sc_smpsw) != 0)
		panic("can't register with sysmon");

	callout_init(&sc->sc_callout, 0);
	callout_setfunc(&sc->sc_callout, powsw_softintr, sc);

	if (intio_intr_establish(desc->vector, xname, powsw_intr, sc) < 0)
		panic("%s: can't establish interrupt", xname);

	/* Set AER and enable interrupt */
	sw = (mfp_get_gpip() & sc->sc_mask);
	powsw_set_aer(sc, sw ? 0 : 1);
	mfp_bit_set_ierb(sc->sc_mask);

	aprint_normal(": %s\n", desc->name);
}

static int
powsw_intr(void *arg)
{
	struct powsw_softc *sc = arg;

	if (sc->sc_tick == 0) {
		mfp_bit_clear_ierb(sc->sc_mask);
		sc->sc_tick++;
		DEBUG_LOG_ADD('i');
		/*
		 * The button state seems unstable for few ticks,
		 * so wait a bit to settle.
		 */
		callout_schedule(&sc->sc_callout, 1);
	} else {
		DEBUG_LOG_ADD('x');
	}
	return 0;
}

void
powsw_softintr(void *arg)
{
	struct powsw_softc *sc = arg;
	int sw;
	int s;

	s = spl6();

	if (sc->sc_tick++ >= POWSW_MAX_TICK) {
		/* tick is over, broken switch? */
		printf("%s: unstable power switch?, ignored\n",
		    device_xname(sc->sc_dev));
		powsw_reset_counter(sc);

		mfp_bit_set_ierb(sc->sc_mask);
		splx(s);
		return;
	}

	sw = (mfp_get_gpip() & sc->sc_mask) ? 1 : 0;
	DEBUG_LOG_ADD('0' + sw);

	if (sw == sc->sc_last_sw) {
		sc->sc_count++;
	} else {
		sc->sc_last_sw = sw;
		sc->sc_count = 1;
	}

	if (sc->sc_count < POWSW_THRESHOLD) {
		callout_schedule(&sc->sc_callout, 1);
	} else {
		/* switch seems stable */
		DEBUG_LOG_PRINT();

		if (sc->sc_last_sw == sc->sc_prev) {
			/* switch state is not changed, it was a noise */
			DPRINTF(" ignore(sw=%d,prev=%d)\n",
			    sc->sc_last_sw, sc->sc_prev);
		} else {
			/* switch state has been changed */
			sc->sc_prev = sc->sc_last_sw;
			powsw_set_aer(sc, 1 - sc->sc_prev);
			sysmon_task_queue_sched(0, powsw_pswitch_event, sc);
		}
		powsw_reset_counter(sc);
		/* enable interrupt */
		mfp_bit_set_ierb(sc->sc_mask);
	}

	splx(s);
}

static void
powsw_pswitch_event(void *arg)
{
	struct powsw_softc *sc = arg;
	int poweroff;

	poweroff = sc->sc_prev;

	DPRINTF(" %s is %s\n", device_xname(sc->sc_dev),
	    poweroff ? "off(PRESS)" : "on(RELEASE)");

	sysmon_pswitch_event(&sc->sc_smpsw,
	    poweroff ? PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
}

static void
powsw_reset_counter(struct powsw_softc *sc)
{

	sc->sc_last_sw = -1;
	sc->sc_tick = 0;
	sc->sc_count = 0;
#if defined(POWSW_DEBUG)
	sc->sc_loglen = 0;
#endif
}

static void
powsw_set_aer(struct powsw_softc *sc, int aer)
{

	KASSERT(aer == 0 || aer == 1);

	if (aer == 0) {
		mfp_bit_clear_aer(sc->sc_mask);
	} else {
		mfp_bit_set_aer(sc->sc_mask);
	}
	DPRINTF(" SetAER=%d", aer);
}