xref: /src/sys/arch/macppc/dev/pm_direct.c

/*	$NetBSD: pm_direct.c,v 1.23 2005/02/01 02:46:00 briggs Exp $	*/

/*
 * Copyright (C) 1997 Takashi Hamada
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *  This product includes software developed by Takashi Hamada
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * 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.
 */
/* From: pm_direct.c 1.3 03/18/98 Takashi Hamada */

/*
 * TODO : Check bounds on PMData in pmgrop
 *		callers should specify how much room for data is in the buffer
 *		and that should be respected by the pmgrop
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: pm_direct.c,v 1.23 2005/02/01 02:46:00 briggs Exp $");

#ifdef DEBUG
#ifndef ADB_DEBUG
#define ADB_DEBUG
#endif
#endif

/* #define	PM_GRAB_SI	1 */

#include <sys/param.h>
#include <sys/cdefs.h>
#include <sys/device.h>
#include <sys/systm.h>

#include <machine/adbsys.h>
#include <machine/autoconf.h>
#include <machine/cpu.h>

#include <dev/ofw/openfirm.h>

#include <macppc/dev/adbvar.h>
#include <macppc/dev/pm_direct.h>
#include <macppc/dev/viareg.h>

extern int adb_polling;		/* Are we polling?  (Debugger mode) */

/* hardware dependent values */
#define ADBDelay 100		/* XXX */
#define HwCfgFlags3 0x20000	/* XXX */

/* define the types of the Power Manager */
#define PM_HW_UNKNOWN		0x00	/* don't know */
#define PM_HW_PB1XX		0x01	/* PowerBook 1XX series */
#define	PM_HW_PB5XX		0x02	/* PowerBook Duo and 5XX series */

/* useful macros */
#define PM_SR()			read_via_reg(VIA1, vSR)
#define PM_VIA_INTR_ENABLE()	write_via_reg(VIA1, vIER, 0x90)
#define PM_VIA_INTR_DISABLE()	write_via_reg(VIA1, vIER, 0x10)
#define PM_VIA_CLR_INTR()	write_via_reg(VIA1, vIFR, 0x90)
#if 0
#define PM_SET_STATE_ACKON()	via_reg_or(VIA2, vBufB, 0x04)
#define PM_SET_STATE_ACKOFF()	via_reg_and(VIA2, vBufB, ~0x04)
#define PM_IS_ON		(0x02 == (read_via_reg(VIA2, vBufB) & 0x02))
#define PM_IS_OFF		(0x00 == (read_via_reg(VIA2, vBufB) & 0x02))
#else
#define PM_SET_STATE_ACKON()	via_reg_or(VIA2, vBufB, 0x10)
#define PM_SET_STATE_ACKOFF()	via_reg_and(VIA2, vBufB, ~0x10)
#define PM_IS_ON		(0x08 == (read_via_reg(VIA2, vBufB) & 0x08))
#define PM_IS_OFF		(0x00 == (read_via_reg(VIA2, vBufB) & 0x08))
#endif

/*
 * Variables for internal use
 */
int	pmHardware = PM_HW_UNKNOWN;
u_short	pm_existent_ADB_devices = 0x0;	/* each bit expresses the existent ADB device */
u_int	pm_LCD_brightness = 0x0;
u_int	pm_LCD_contrast = 0x0;
u_int	pm_counter = 0;			/* clock count */

static enum batt_type { BATT_COMET, BATT_HOOPER, BATT_SMART } pmu_batt_type;
static int	pmu_nbatt;
static int	strinlist(char *, char *, int);
static enum pmu_type { PMU_UNKNOWN, PMU_OHARE, PMU_G3, PMU_KEYLARGO } pmu_type;

/* these values shows that number of data returned after 'send' cmd is sent */
signed char pm_send_cmd_type[] = {
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00,   -1,   -1,   -1,   -1,   -1, 0x00,
	  -1, 0x00, 0x02, 0x01, 0x01,   -1,   -1,   -1,
	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x04, 0x14,   -1, 0x03,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x02, 0x02,   -1,   -1,   -1,   -1,
	0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00,   -1,   -1, 0x01,   -1,   -1,   -1,
	0x01, 0x00, 0x02, 0x02,   -1, 0x01, 0x03, 0x01,
	0x00, 0x01, 0x00, 0x00, 0x00,   -1,   -1,   -1,
	0x02,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   -1,   -1,
	0x01, 0x01, 0x01,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00,   -1,   -1,   -1,   -1, 0x04, 0x04,
	0x04,   -1, 0x00,   -1,   -1,   -1,   -1,   -1,
	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x01, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00,   -1,   -1,   -1,   -1,   -1,   -1,
	0x02, 0x02, 0x02, 0x04,   -1, 0x00,   -1,   -1,
	0x01, 0x01, 0x03, 0x02,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x01, 0x01,   -1,   -1, 0x00, 0x00,   -1,   -1,
	  -1, 0x04, 0x00,   -1,   -1,   -1,   -1,   -1,
	0x03,   -1, 0x00,   -1, 0x00,   -1,   -1, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1
};

/* these values shows that number of data returned after 'receive' cmd is sent */
signed char pm_receive_cmd_type[] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x02,   -1,   -1,   -1,   -1,   -1, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x05, 0x15,   -1, 0x02,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x00, 0x03, 0x03,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x04, 0x04, 0x03, 0x09,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1, 0x01, 0x01,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x06,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x00, 0x00, 0x00,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x02, 0x02,   -1,   -1, 0x02,   -1,   -1,   -1,
	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1, 0x02,   -1,   -1,   -1,   -1, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
};


/*
 * Define the private functions
 */

/* for debugging */
#ifdef ADB_DEBUG
void	pm_printerr __P((char *, int, int, char *));
#endif

int	pm_wait_busy __P((int));
int	pm_wait_free __P((int));

/* these functions are for the PB1XX series */
int	pm_receive_pm1 __P((u_char *));
int	pm_send_pm1 __P((u_char,int));
int	pm_pmgrop_pm1 __P((PMData *));
void	pm_intr_pm1 __P((void));

/* these functions are for the PB Duo series and the PB 5XX series */
int	pm_receive_pm2 __P((u_char *));
int	pm_send_pm2 __P((u_char));
int	pm_pmgrop_pm2 __P((PMData *));
void	pm_intr_pm2 __P((void));

/* these functions are called from adb_direct.c */
void	pm_setup_adb __P((void));
void	pm_check_adb_devices __P((int));
void	pm_intr __P((void));
int	pm_adb_op __P((u_char *, void *, void *, int));

/* these functions also use the variables of adb_direct.c */
void	pm_adb_get_TALK_result __P((PMData *));
void	pm_adb_get_ADB_data __P((PMData *));
void	pm_adb_poll_next_device_pm1 __P((PMData *));


/*
 * These variables are in adb_direct.c.
 */
extern u_char	*adbBuffer;	/* pointer to user data area */
extern void	*adbCompRout;	/* pointer to the completion routine */
extern void	*adbCompData;	/* pointer to the completion routine data */
extern int	adbWaiting;	/* waiting for return data from the device */
extern int	adbWaitingCmd;	/* ADB command we are waiting for */
extern int	adbStarting;	/* doing ADB reinit, so do "polling" differently */

#define	ADB_MAX_MSG_LENGTH	16
#define	ADB_MAX_HDR_LENGTH	8
struct adbCommand {
	u_char	header[ADB_MAX_HDR_LENGTH];	/* not used yet */
	u_char	data[ADB_MAX_MSG_LENGTH];	/* packet data only */
	u_char	*saveBuf;	/* where to save result */
	u_char	*compRout;	/* completion routine pointer */
	u_char	*compData;	/* completion routine data pointer */
	u_int	cmd;		/* the original command for this data */
	u_int	unsol;		/* 1 if packet was unsolicited */
	u_int	ack_only;	/* 1 for no special processing */
};
extern	void	adb_pass_up __P((struct adbCommand *));

#if 0
/*
 * Define the external functions
 */
extern int	zshard __P((int));		/* from zs.c */
#endif

#ifdef ADB_DEBUG
/*
 * This function dumps contents of the PMData
 */
void
pm_printerr(ttl, rval, num, data)
	char *ttl;
	int rval;
	int num;
	char *data;
{
	int i;

	printf("pm: %s:%04x %02x ", ttl, rval, num);
	for (i = 0; i < num; i++)
		printf("%02x ", data[i]);
	printf("\n");
}
#endif



/*
 * Check the hardware type of the Power Manager
 */
void
pm_setup_adb()
{
	pmHardware = PM_HW_PB5XX;	/* XXX */
}

static int
strinlist(char *targ, char *list, int listlen)
{
	char	*str;
	int	sl;

	str = list;
	while (listlen > 0) {
		sl = strlen(str);
		if (strncmp(targ, str, sl) == 0)
			return 1;
		str += sl+1;
		listlen -= sl+1;
	}
	return 0;
}

/*
 * Check the hardware type of the Power Manager
 */
void
pm_init(void)
{
	uint32_t	regs[10];
	PMData		pmdata;
	char		compat[128];
	int		clen, node, imask;

	node = OF_peer(0);
	if (node == -1) {
		printf("pmu: Failed to get root");
		return;
	}
	clen = OF_getprop(node, "compatible", compat, sizeof(compat));
	if (clen <= 0) {
		printf("pmu: failed to read root compatible data %d\n", clen);
		return;
	}

	imask = PMU_INT_PCEJECT | PMU_INT_SNDBRT | PMU_INT_ADB | PMU_INT_TICK;

	if (strinlist("AAPL,3500", compat, clen) ||
	    strinlist("AAPL,3400/2400", compat, clen)) {
		/* How to distinguish BATT_COMET? */
		pmu_nbatt = 1;
		pmu_batt_type = BATT_HOOPER;
		pmu_type = PMU_OHARE;
	} else if (strinlist("AAPL,PowerBook1998", compat, clen) ||
		   strinlist("PowerBook1,1", compat, clen)) {
		pmu_nbatt = 2;
		pmu_batt_type = BATT_SMART;
		pmu_type = PMU_G3;
	} else {
		pmu_nbatt = 1;
		pmu_batt_type = BATT_SMART;
		pmu_type = PMU_KEYLARGO;
		node = getnodebyname(0, "power-mgt");
		if (node == -1) {
			printf("pmu: can't find power-mgt\n");
			return;
		}
		clen = OF_getprop(node, "prim-info", regs, sizeof(regs));
		if (clen < 24) {
			printf("pmu: failed to read prim-info\n");
			return;
		}
		pmu_nbatt = regs[6] >> 16;
	}

	pmdata.command = PMU_SET_IMASK;
	pmdata.num_data = 1;
	pmdata.s_buf = pmdata.data;
	pmdata.r_buf = pmdata.data;
	pmdata.data[0] = imask;
	pmgrop(&pmdata);
}


/*
 * Check the existent ADB devices
 */
void
pm_check_adb_devices(id)
	int id;
{
	u_short ed = 0x1;

	ed <<= id;
	pm_existent_ADB_devices |= ed;
}


/*
 * Wait until PM IC is busy
 */
int
pm_wait_busy(delay)
	int delay;
{
	while (PM_IS_ON) {
#ifdef PM_GRAB_SI
#if 0
		zshard(0);		/* grab any serial interrupts */
#else
		(void)intr_dispatch(0x70);
#endif
#endif
		if ((--delay) < 0)
			return 1;	/* timeout */
	}
	return 0;
}


/*
 * Wait until PM IC is free
 */
int
pm_wait_free(delay)
	int delay;
{
	while (PM_IS_OFF) {
#ifdef PM_GRAB_SI
#if 0
		zshard(0);		/* grab any serial interrupts */
#else
		(void)intr_dispatch(0x70);
#endif
#endif
		if ((--delay) < 0)
			return 0;	/* timeout */
	}
	return 1;
}



/*
 * Functions for the PB1XX series
 */

/*
 * Receive data from PM for the PB1XX series
 */
int
pm_receive_pm1(data)
	u_char *data;
{
#if 0
	int rval = 0xffffcd34;

	via_reg(VIA2, vDirA) = 0x00;

	switch (1) {
	default:
		if (pm_wait_busy(0x40) != 0)
			break;			/* timeout */

		PM_SET_STATE_ACKOFF();
		*data = via_reg(VIA2, 0x200);

		rval = 0xffffcd33;
		if (pm_wait_free(0x40) == 0)
			break;			/* timeout */

		rval = 0x00;
		break;
	}

	PM_SET_STATE_ACKON();
	via_reg(VIA2, vDirA) = 0x00;

	return rval;
#else
	panic("pm_receive_pm1");
#endif
}



/*
 * Send data to PM for the PB1XX series
 */
int
pm_send_pm1(data, delay)
	u_char data;
	int delay;
{
#if 0
	int rval;

	via_reg(VIA2, vDirA) = 0xff;
	via_reg(VIA2, 0x200) = data;

	PM_SET_STATE_ACKOFF();
	if (pm_wait_busy(0x400) != 0) {
		PM_SET_STATE_ACKON();
		via_reg(VIA2, vDirA) = 0x00;

		return 0xffffcd36;
	}

	rval = 0x0;
	PM_SET_STATE_ACKON();
	if (pm_wait_free(0x40) == 0)
		rval = 0xffffcd35;

	PM_SET_STATE_ACKON();
	via_reg(VIA2, vDirA) = 0x00;

	return rval;
#else
	panic("pm_send_pm1");
#endif
}


/*
 * My PMgrOp routine for the PB1XX series
 */
int
pm_pmgrop_pm1(pmdata)
	PMData *pmdata;
{
#if 0
	int i;
	int s = 0x81815963;
	u_char via1_vIER, via1_vDirA;
	int rval = 0;
	int num_pm_data = 0;
	u_char pm_cmd;
	u_char pm_data;
	u_char *pm_buf;

	/* disable all inetrrupts but PM */
	via1_vIER = via_reg(VIA1, vIER);
	PM_VIA_INTR_DISABLE();

	via1_vDirA = via_reg(VIA1, vDirA);

	switch (pmdata->command) {
	default:
		for (i = 0; i < 7; i++) {
			via_reg(VIA2, vDirA) = 0x00;

			/* wait until PM is free */
			if (pm_wait_free(ADBDelay) == 0) {	/* timeout */
				via_reg(VIA2, vDirA) = 0x00;
				/* restore formar value */
				via_reg(VIA1, vDirA) = via1_vDirA;
				via_reg(VIA1, vIER) = via1_vIER;
				return 0xffffcd38;
			}

			switch (mac68k_machine.machineid) {
				case MACH_MACPB160:
				case MACH_MACPB165:
				case MACH_MACPB165C:
				case MACH_MACPB180:
				case MACH_MACPB180C:
					{
						int delay = ADBDelay * 16;

						via_reg(VIA2, vDirA) = 0x00;
						while ((via_reg(VIA2, 0x200) == 0x7f) && (delay >= 0))
							delay--;

						if (delay < 0) {	/* timeout */
							via_reg(VIA2, vDirA) = 0x00;
							/* restore formar value */
							via_reg(VIA1, vIER) = via1_vIER;
							return 0xffffcd38;
						}
					}
			} /* end switch */

			s = splhigh();

			via1_vDirA = via_reg(VIA1, vDirA);
			via_reg(VIA1, vDirA) &= 0x7f;

			pm_cmd = (u_char)(pmdata->command & 0xff);
			if ((rval = pm_send_pm1(pm_cmd, ADBDelay * 8)) == 0)
				break;	/* send command succeeded */

			via_reg(VIA1, vDirA) = via1_vDirA;
			splx(s);
		} /* end for */

		/* failed to send a command */
		if (i == 7) {
			via_reg(VIA2, vDirA) = 0x00;
			/* restore formar value */
			via_reg(VIA1, vDirA) = via1_vDirA;
			via_reg(VIA1, vIER) = via1_vIER;
			if (s != 0x81815963)
				splx(s);
			return 0xffffcd38;
		}

		/* send # of PM data */
		num_pm_data = pmdata->num_data;
		if ((rval = pm_send_pm1((u_char)(num_pm_data & 0xff), ADBDelay * 8)) != 0)
			break;			/* timeout */

		/* send PM data */
		pm_buf = (u_char *)pmdata->s_buf;
		for (i = 0; i < num_pm_data; i++)
			if ((rval = pm_send_pm1(pm_buf[i], ADBDelay * 8)) != 0)
				break;		/* timeout */
		if ((i != num_pm_data) && (num_pm_data != 0))
			break;			/* timeout */

		/* Will PM IC return data? */
		if ((pm_cmd & 0x08) == 0) {
			rval = 0;
			break;			/* no returned data */
		}

		rval = 0xffffcd37;
		if (pm_wait_busy(ADBDelay) != 0)
			break;			/* timeout */

		/* receive PM command */
		if ((rval = pm_receive_pm1(&pm_data)) != 0)
			break;

		pmdata->command = pm_data;

		/* receive number of PM data */
		if ((rval = pm_receive_pm1(&pm_data)) != 0)
			break;			/* timeout */
		num_pm_data = pm_data;
		pmdata->num_data = num_pm_data;

		/* receive PM data */
		pm_buf = (u_char *)pmdata->r_buf;
		for (i = 0; i < num_pm_data; i++) {
			if ((rval = pm_receive_pm1(&pm_data)) != 0)
				break;		/* timeout */
			pm_buf[i] = pm_data;
		}

		rval = 0;
	}

	via_reg(VIA2, vDirA) = 0x00;

	/* restore formar value */
	via_reg(VIA1, vDirA) = via1_vDirA;
	via_reg(VIA1, vIER) = via1_vIER;
	if (s != 0x81815963)
		splx(s);

	return rval;
#else
	panic("pm_pmgrop_pm1");
#endif
}


/*
 * My PM interrupt routine for PB1XX series
 */
void
pm_intr_pm1()
{
#if 0
	int s;
	int rval;
	PMData pmdata;

	s = splhigh();

	PM_VIA_CLR_INTR();				/* clear VIA1 interrupt */

	/* ask PM what happend */
	pmdata.command = PMU_INT_ACK;
	pmdata.num_data = 0;
	pmdata.data[0] = pmdata.data[1] = 0;
	pmdata.s_buf = &pmdata.data[2];
	pmdata.r_buf = &pmdata.data[2];
	rval = pm_pmgrop_pm1(&pmdata);
	if (rval != 0) {
#ifdef ADB_DEBUG
		if (adb_debug)
			printf("pm: PM is not ready. error code=%08x\n", rval);
#endif
		splx(s);
	}

	if ((pmdata.data[2] & 0x10) == 0x10) {
		if ((pmdata.data[2] & 0x0f) == 0) {
			/* ADB data that were requested by TALK command */
			pm_adb_get_TALK_result(&pmdata);
		} else if ((pmdata.data[2] & 0x08) == 0x8) {
			/* PM is requesting to poll  */
			pm_adb_poll_next_device_pm1(&pmdata);
		} else if ((pmdata.data[2] & 0x04) == 0x4) {
			/* ADB device event */
			pm_adb_get_ADB_data(&pmdata);
		}
	} else {
#ifdef ADB_DEBUG
		if (adb_debug)
			pm_printerr("driver does not support this event.",
			    rval, pmdata.num_data, pmdata.data);
#endif
	}

	splx(s);
#else
	panic("pm_intr_pm1");
#endif
}



/*
 * Functions for the PB Duo series and the PB 5XX series
 */

/*
 * Receive data from PM for the PB Duo series and the PB 5XX series
 */
int
pm_receive_pm2(data)
	u_char *data;
{
	int i;
	int rval;

	rval = 0xffffcd34;

	switch (1) {
	default:
		/* set VIA SR to input mode */
		via_reg_or(VIA1, vACR, 0x0c);
		via_reg_and(VIA1, vACR, ~0x10);
		i = PM_SR();

		PM_SET_STATE_ACKOFF();
		if (pm_wait_busy((int)ADBDelay*32) != 0)
			break;		/* timeout */

		PM_SET_STATE_ACKON();
		rval = 0xffffcd33;
		if (pm_wait_free((int)ADBDelay*32) == 0)
			break;		/* timeout */

		*data = PM_SR();
		rval = 0;

		break;
	}

	PM_SET_STATE_ACKON();
	via_reg_or(VIA1, vACR, 0x1c);

	return rval;
}



/*
 * Send data to PM for the PB Duo series and the PB 5XX series
 */
int
pm_send_pm2(data)
	u_char data;
{
	int rval;

	via_reg_or(VIA1, vACR, 0x1c);
	write_via_reg(VIA1, vSR, data);	/* PM_SR() = data; */

	PM_SET_STATE_ACKOFF();
	rval = 0xffffcd36;
	if (pm_wait_busy((int)ADBDelay*32) != 0) {
		PM_SET_STATE_ACKON();

		via_reg_or(VIA1, vACR, 0x1c);

		return rval;
	}

	PM_SET_STATE_ACKON();
	rval = 0xffffcd35;
	if (pm_wait_free((int)ADBDelay*32) != 0)
		rval = 0;

	PM_SET_STATE_ACKON();
	via_reg_or(VIA1, vACR, 0x1c);

	return rval;
}



/*
 * My PMgrOp routine for the PB Duo series and the PB 5XX series
 */
int
pm_pmgrop_pm2(pmdata)
	PMData *pmdata;
{
	int i;
	int s;
	u_char via1_vIER;
	int rval = 0;
	int num_pm_data = 0;
	u_char pm_cmd;
	short pm_num_rx_data;
	u_char pm_data;
	u_char *pm_buf;

	s = splhigh();

	/* disable all inetrrupts but PM */
	via1_vIER = 0x10;
	via1_vIER &= read_via_reg(VIA1, vIER);
	write_via_reg(VIA1, vIER, via1_vIER);
	if (via1_vIER != 0x0)
		via1_vIER |= 0x80;

	switch (pmdata->command) {
	default:
		/* wait until PM is free */
		pm_cmd = (u_char)(pmdata->command & 0xff);
		rval = 0xcd38;
		if (pm_wait_free(ADBDelay * 4) == 0)
			break;			/* timeout */

		if (HwCfgFlags3 & 0x00200000) {
			/* PB 160, PB 165(c), PB 180(c)? */
			int delay = ADBDelay * 16;

			write_via_reg(VIA2, vDirA, 0x00);
			while ((read_via_reg(VIA2, 0x200) == 0x07) &&
			    (delay >= 0))
				delay--;

			if (delay < 0) {
				rval = 0xffffcd38;
				break;		/* timeout */
			}
		}

		/* send PM command */
		if ((rval = pm_send_pm2((u_char)(pm_cmd & 0xff))))
			break;				/* timeout */

		/* send number of PM data */
		num_pm_data = pmdata->num_data;
		if (HwCfgFlags3 & 0x00020000) {		/* PB Duo, PB 5XX */
			if (pm_send_cmd_type[pm_cmd] < 0) {
				if ((rval = pm_send_pm2((u_char)(num_pm_data & 0xff))) != 0)
					break;		/* timeout */
				pmdata->command = 0;
			}
		} else {				/* PB 1XX series ? */
			if ((rval = pm_send_pm2((u_char)(num_pm_data & 0xff))) != 0)
				break;			/* timeout */
		}
		/* send PM data */
		pm_buf = (u_char *)pmdata->s_buf;
		for (i = 0 ; i < num_pm_data; i++)
			if ((rval = pm_send_pm2(pm_buf[i])) != 0)
				break;			/* timeout */
		if (i != num_pm_data)
			break;				/* timeout */


		/* check if PM will send me data  */
		pm_num_rx_data = pm_receive_cmd_type[pm_cmd];
		pmdata->num_data = pm_num_rx_data;
		if (pm_num_rx_data == 0) {
			rval = 0;
			break;				/* no return data */
		}

		/* receive PM command */
		pm_data = pmdata->command;
		if (HwCfgFlags3 & 0x00020000) {		/* PB Duo, PB 5XX */
			pm_num_rx_data--;
			if (pm_num_rx_data == 0)
				if ((rval = pm_receive_pm2(&pm_data)) != 0) {
					rval = 0xffffcd37;
					break;
				}
			pmdata->command = pm_data;
		} else {				/* PB 1XX series ? */
			if ((rval = pm_receive_pm2(&pm_data)) != 0) {
				rval = 0xffffcd37;
				break;
			}
			pmdata->command = pm_data;
		}

		/* receive number of PM data */
		if (HwCfgFlags3 & 0x00020000) {		/* PB Duo, PB 5XX */
			if (pm_num_rx_data < 0) {
				if ((rval = pm_receive_pm2(&pm_data)) != 0)
					break;		/* timeout */
				num_pm_data = pm_data;
			} else
				num_pm_data = pm_num_rx_data;
			pmdata->num_data = num_pm_data;
		} else {				/* PB 1XX serias ? */
			if ((rval = pm_receive_pm2(&pm_data)) != 0)
				break;			/* timeout */
			num_pm_data = pm_data;
			pmdata->num_data = num_pm_data;
		}

		/* receive PM data */
		pm_buf = (u_char *)pmdata->r_buf;
		for (i = 0; i < num_pm_data; i++) {
			if ((rval = pm_receive_pm2(&pm_data)) != 0)
				break;			/* timeout */
			pm_buf[i] = pm_data;
		}

		rval = 0;
	}

	/* restore former value */
	write_via_reg(VIA1, vIER, via1_vIER);
	splx(s);

	return rval;
}


/*
 * My PM interrupt routine for the PB Duo series and the PB 5XX series
 */
void
pm_intr_pm2()
{
	int s;
	int rval;
	PMData pmdata;

	s = splhigh();

	PM_VIA_CLR_INTR();			/* clear VIA1 interrupt */
						/* ask PM what happend */
	pmdata.command = PMU_INT_ACK;
	pmdata.num_data = 0;
	pmdata.s_buf = &pmdata.data[2];
	pmdata.r_buf = &pmdata.data[2];
	rval = pm_pmgrop_pm2(&pmdata);
	if (rval != 0) {
#ifdef ADB_DEBUG
		if (adb_debug)
			printf("pm: PM is not ready. error code: %08x\n", rval);
#endif
		splx(s);
		return;
	}

	switch ((u_int)(pmdata.data[2] & 0xff)) {
	case 0x00:		/* no event pending? */
		break;
	case 0x80:		/* 1 sec interrupt? */
		pm_counter++;
		break;
	case 0x08:		/* Brightness/Contrast button on LCD panel */
		/* get brightness and contrast of the LCD */
		pm_LCD_brightness = (u_int)pmdata.data[3] & 0xff;
		pm_LCD_contrast = (u_int)pmdata.data[4] & 0xff;
/*
		pm_printerr("#08", rval, pmdata.num_data, pmdata.data);
		pmdata.command = 0x33;
		pmdata.num_data = 1;
		pmdata.s_buf = pmdata.data;
		pmdata.r_buf = pmdata.data;
		pmdata.data[0] = pm_LCD_contrast;
		rval = pm_pmgrop_pm2(&pmdata);
		pm_printerr("#33", rval, pmdata.num_data, pmdata.data);
*/
		/* this is an experimental code */
		pmdata.command = PMU_SET_BRIGHTNESS;
		pmdata.num_data = 1;
		pmdata.s_buf = pmdata.data;
		pmdata.r_buf = pmdata.data;
		pm_LCD_brightness = 0x7f - pm_LCD_brightness / 2;
		if (pm_LCD_brightness < 0x08)
			pm_LCD_brightness = 0x08;
		if (pm_LCD_brightness > 0x78)
			pm_LCD_brightness = 0x78;
		pmdata.data[0] = pm_LCD_brightness;
		rval = pm_pmgrop_pm2(&pmdata);
		break;
	case 0x10:		/* ADB data requested by TALK command */
	case 0x14:
		pm_adb_get_TALK_result(&pmdata);
		break;
	case 0x16:		/* ADB device event */
	case 0x18:
	case 0x1e:
		pm_adb_get_ADB_data(&pmdata);
		break;
	default:
#ifdef ADB_DEBUG
		if (adb_debug)
			pm_printerr("driver does not support this event.",
			    pmdata.data[2], pmdata.num_data,
			    pmdata.data);
#endif
		break;
	}

	splx(s);
}


/*
 * My PMgrOp routine
 */
int
pmgrop(pmdata)
	PMData *pmdata;
{
	switch (pmHardware) {
	case PM_HW_PB1XX:
		return (pm_pmgrop_pm1(pmdata));
		break;
	case PM_HW_PB5XX:
		return (pm_pmgrop_pm2(pmdata));
		break;
	default:
		/* return (pmgrop_mrg(pmdata)); */
		return 1;
	}
}


/*
 * My PM interrupt routine
 */
void
pm_intr()
{
	switch (pmHardware) {
	case PM_HW_PB1XX:
		pm_intr_pm1();
		break;
	case PM_HW_PB5XX:
		pm_intr_pm2();
		break;
	default:
		break;
	}
}



/*
 * Synchronous ADBOp routine for the Power Manager
 */
int
pm_adb_op(buffer, compRout, data, command)
	u_char *buffer;
	void *compRout;
	void *data;
	int command;
{
	int i;
	int s;
	int rval;
	int timo;
	PMData pmdata;
	struct adbCommand packet;

	if (adbWaiting == 1)
		return 1;

	s = splhigh();
	write_via_reg(VIA1, vIER, 0x10);

 	adbBuffer = buffer;
	adbCompRout = compRout;
	adbCompData = data;

	pmdata.command = PMU_ADB_CMD;
	pmdata.s_buf = pmdata.data;
	pmdata.r_buf = pmdata.data;

	/* if the command is LISTEN, add number of ADB data to number of PM data */
	if ((command & 0xc) == 0x8) {
		if (buffer != (u_char *)0)
			pmdata.num_data = buffer[0] + 3;
	} else {
		pmdata.num_data = 3;
	}

	pmdata.data[0] = (u_char)(command & 0xff);
	pmdata.data[1] = 0;
	if ((command & 0xc) == 0x8) {		/* if the command is LISTEN, copy ADB data to PM buffer */
		if ((buffer != (u_char *)0) && (buffer[0] <= 24)) {
			pmdata.data[2] = buffer[0];		/* number of data */
			for (i = 0; i < buffer[0]; i++)
				pmdata.data[3 + i] = buffer[1 + i];
		} else
			pmdata.data[2] = 0;
	} else
		pmdata.data[2] = 0;

	if ((command & 0xc) != 0xc) {		/* if the command is not TALK */
		/* set up stuff for adb_pass_up */
		packet.data[0] = 1 + pmdata.data[2];
		packet.data[1] = command;
		for (i = 0; i < pmdata.data[2]; i++)
			packet.data[i+2] = pmdata.data[i+3];
		packet.saveBuf = adbBuffer;
		packet.compRout = adbCompRout;
		packet.compData = adbCompData;
		packet.cmd = command;
		packet.unsol = 0;
		packet.ack_only = 1;
		adb_polling = 1;
		adb_pass_up(&packet);
		adb_polling = 0;
	}

	rval = pmgrop(&pmdata);
	if (rval != 0) {
		splx(s);
		return 1;
	}

	delay(10000);

	adbWaiting = 1;
	adbWaitingCmd = command;

	PM_VIA_INTR_ENABLE();

	/* wait until the PM interrupt has occurred */
	timo = 0x80000;
	while (adbWaiting == 1) {
		if (read_via_reg(VIA1, vIFR) & 0x14)
			pm_intr();
#ifdef PM_GRAB_SI
#if 0
			zshard(0);		/* grab any serial interrupts */
#else
			(void)intr_dispatch(0x70);
#endif
#endif
		if ((--timo) < 0) {
			/* Try to take an interrupt anyway, just in case.
			 * This has been observed to happen on my ibook
			 * when i press a key after boot and before adb
			 * is attached;  For example, when booting with -d.
			 */
			pm_intr();
			if (adbWaiting) {
				printf("pm_adb_op: timeout. command = 0x%x\n",command);
				splx(s);
				return 1;
			}
#ifdef ADB_DEBUG
			else {
				printf("pm_adb_op: missed interrupt. cmd=0x%x\n",command);
			}
#endif
		}
	}

	/* this command enables the interrupt by operating ADB devices */
	if (HwCfgFlags3 & 0x00020000) {		/* PB Duo series, PB 5XX series */
		pmdata.command = PMU_ADB_CMD;
		pmdata.num_data = 4;
		pmdata.s_buf = pmdata.data;
		pmdata.r_buf = pmdata.data;
		pmdata.data[0] = 0x00;
		pmdata.data[1] = 0x86;	/* magic spell for awaking the PM */
		pmdata.data[2] = 0x00;
		pmdata.data[3] = 0x0c;	/* each bit may express the existent ADB device */
	} else {				/* PB 1XX series */
		pmdata.command = PMU_ADB_CMD;
		pmdata.num_data = 3;
		pmdata.s_buf = pmdata.data;
		pmdata.r_buf = pmdata.data;
		pmdata.data[0] = (u_char)(command & 0xf0) | 0xc;
		pmdata.data[1] = 0x04;
		pmdata.data[2] = 0x00;
	}
	rval = pmgrop(&pmdata);

	splx(s);
	return rval;
}


void
pm_adb_get_TALK_result(pmdata)
	PMData *pmdata;
{
	int i;
	struct adbCommand packet;

	/* set up data for adb_pass_up */
	packet.data[0] = pmdata->num_data-1;
	packet.data[1] = pmdata->data[3];
	for (i = 0; i <packet.data[0]-1; i++)
		packet.data[i+2] = pmdata->data[i+4];

	packet.saveBuf = adbBuffer;
	packet.compRout = adbCompRout;
	packet.compData = adbCompData;
	packet.unsol = 0;
	packet.ack_only = 0;
	adb_polling = 1;
	adb_pass_up(&packet);
	adb_polling = 0;

	adbWaiting = 0;
	adbBuffer = (long)0;
	adbCompRout = (long)0;
	adbCompData = (long)0;
}


void
pm_adb_get_ADB_data(pmdata)
	PMData *pmdata;
{
	int i;
	struct adbCommand packet;

	if (pmu_type == PMU_OHARE && pmdata->num_data == 4 &&
	    pmdata->data[1] == 0x2c && pmdata->data[3] == 0xff &&
	    ((pmdata->data[2] & ~1) == 0xf4)) {
		if (pmdata->data[2] == 0xf4) {
			pm_eject_pcmcia(0);
		} else {
			pm_eject_pcmcia(1);
		}
		return;
	}
	/* set up data for adb_pass_up */
	packet.data[0] = pmdata->num_data-1;	/* number of raw data */
	packet.data[1] = pmdata->data[3];	/* ADB command */
	for (i = 0; i <packet.data[0]-1; i++)
		packet.data[i+2] = pmdata->data[i+4];
	packet.unsol = 1;
	packet.ack_only = 0;
	adb_pass_up(&packet);
}


void
pm_adb_poll_next_device_pm1(pmdata)
	PMData *pmdata;
{
	int i;
	int ndid;
	u_short bendid = 0x1;
	int rval;
	PMData tmp_pmdata;

	/* find another existent ADB device to poll */
	for (i = 1; i < 16; i++) {
		ndid = (ADB_CMDADDR(pmdata->data[3]) + i) & 0xf;
		bendid <<= ndid;
		if ((pm_existent_ADB_devices & bendid) != 0)
			break;
	}

	/* poll the other device */
	tmp_pmdata.command = PMU_ADB_CMD;
	tmp_pmdata.num_data = 3;
	tmp_pmdata.s_buf = tmp_pmdata.data;
	tmp_pmdata.r_buf = tmp_pmdata.data;
	tmp_pmdata.data[0] = (u_char)(ndid << 4) | 0xc;
	tmp_pmdata.data[1] = 0x04;	/* magic spell for awaking the PM */
	tmp_pmdata.data[2] = 0x00;
	rval = pmgrop(&tmp_pmdata);
}

void
pm_adb_restart()
{
	PMData p;

	p.command = PMU_RESET_CPU;
	p.num_data = 0;
	p.s_buf = p.data;
	p.r_buf = p.data;
	pmgrop(&p);
}

void
pm_adb_poweroff()
{
	PMData p;

	p.command = PMU_POWER_OFF;
	p.num_data = 4;
	p.s_buf = p.data;
	p.r_buf = p.data;
	strcpy(p.data, "MATT");
	pmgrop(&p);
}

void
pm_read_date_time(time)
	u_long *time;
{
	PMData p;

	p.command = PMU_READ_RTC;
	p.num_data = 0;
	p.s_buf = p.data;
	p.r_buf = p.data;
	pmgrop(&p);

	memcpy(time, p.data, 4);
}

void
pm_set_date_time(time)
	u_long time;
{
	PMData p;

	p.command = PMU_SET_RTC;
	p.num_data = 4;
	p.s_buf = p.r_buf = p.data;
	memcpy(p.data, &time, 4);
	pmgrop(&p);
}

int
pm_read_brightness()
{
	PMData p;

	p.command = PMU_READ_BRIGHTNESS;
	p.num_data = 1;		/* XXX why 1? */
	p.s_buf = p.r_buf = p.data;
	p.data[0] = 0;
	pmgrop(&p);

	return p.data[0];
}

void
pm_set_brightness(val)
	int val;
{
	PMData p;

	val = 0x7f - val / 2;
	if (val < 0x08)
		val = 0x08;
	if (val > 0x78)
		val = 0x78;

	p.command = PMU_SET_BRIGHTNESS;
	p.num_data = 1;
	p.s_buf = p.r_buf = p.data;
	p.data[0] = val;
	pmgrop(&p);
}

void
pm_init_brightness()
{
	int val;

	val = pm_read_brightness();
	pm_set_brightness(val);
}

void
pm_eject_pcmcia(slot)
	int slot;
{
	PMData p;

	if (slot != 0 && slot != 1)
		return;

	p.command = PMU_EJECT_PCMCIA;
	p.num_data = 1;
	p.s_buf = p.r_buf = p.data;
	p.data[0] = 5 + slot;	/* XXX */
	pmgrop(&p);
}

/*
 * Thanks to Paul Mackerras and Fabio Riccardi's Linux implementation
 * for a clear description of the PMU results.
 */
static int
pm_battery_info_smart(int battery, struct pmu_battery_info *info)
{
	PMData p;

	p.command = PMU_SMART_BATTERY_STATE;
	p.num_data = 1;
	p.s_buf = p.r_buf = p.data;
	p.data[0] = battery + 1;
	pmgrop(&p);

	info->flags = p.data[1];

	info->secs_remaining = 0;
	switch (p.data[0]) {
	case 3:
	case 4:
		info->cur_charge = p.data[2];
		info->max_charge = p.data[3];
		info->draw = *((signed char *)&p.data[4]);
		info->voltage = p.data[5];
		break;
	case 5:
		info->cur_charge = ((p.data[2] << 8) | (p.data[3]));
		info->max_charge = ((p.data[4] << 8) | (p.data[5]));
		info->draw = *((signed short *)&p.data[6]);
		info->voltage = ((p.data[8] << 8) | (p.data[7]));
		break;
	default:
		/* XXX - Error condition */
		info->cur_charge = 0;
		info->max_charge = 0;
		info->draw = 0;
		info->voltage = 0;
		break;
	}
	if (info->draw) {
		if (info->flags & PMU_PWR_AC_PRESENT && info->draw > 0) {
			info->secs_remaining =
				((info->max_charge - info->cur_charge) * 3600)
				/ info->draw;
		} else {
			info->secs_remaining =
				(info->cur_charge * 3600) / -info->draw;
		}
	}

	return 1;
}

static int
pm_battery_info_legacy(int battery, struct pmu_battery_info *info, int ty)
{
	PMData p;
	long pcharge=0, charge, vb, vmax, lmax;
	long vmax_charging, vmax_charged, amperage, voltage;

	p.command = PMU_BATTERY_STATE;
	p.num_data = 0;
	p.s_buf = p.r_buf = p.data;
	pmgrop(&p);

	info->flags = p.data[0];

	if (info->flags & PMU_PWR_BATT_PRESENT) {
		if (ty == BATT_COMET) {
			vmax_charging = 213;
			vmax_charged = 189;
			lmax = 6500;
		} else {
			/* Experimental values */
			vmax_charging = 365;
			vmax_charged = 365;
			lmax = 6500;
		}
		vmax = vmax_charged;
		vb = (p.data[1] << 8) | p.data[2];
		voltage = (vb * 256 + 72665) / 10;
		amperage = (unsigned char) p.data[5];
		if ((info->flags & PMU_PWR_AC_PRESENT) == 0) {
			if (amperage > 200)
				vb += ((amperage - 200) * 15)/100;
		} else if (info->flags & PMU_PWR_BATT_CHARGING) {
			vb = (vb * 97) / 100;
			vmax = vmax_charging;
		}
		charge = (100 * vb) / vmax;
		if (info->flags & PMU_PWR_PCHARGE_RESET) {
			pcharge = (p.data[6] << 8) | p.data[7];
			if (pcharge > lmax)
				pcharge = lmax;
			pcharge *= 100;
			pcharge = 100 - pcharge / lmax;
			if (pcharge < charge)
				charge = pcharge;
		}
		info->cur_charge = charge;
		info->max_charge = 100;
		info->draw = -amperage;
		info->voltage = voltage;
		if (amperage > 0)
			info->secs_remaining = (charge * 16440) / amperage;
		else
			info->secs_remaining = 0;
	} else {
		info->cur_charge = 0;
		info->max_charge = 0;
		info->draw = 0;
		info->voltage = 0;
		info->secs_remaining = 0;
	}

	return 1;
}

int
pm_battery_info(int battery, struct pmu_battery_info *info)
{

	if (battery > pmu_nbatt)
		return 0;

	switch (pmu_batt_type) {
	case BATT_COMET:
	case BATT_HOOPER:
		return pm_battery_info_legacy(battery, info, pmu_batt_type);

	case BATT_SMART:
		return pm_battery_info_smart(battery, info);
	}

	return 0;
}

int
pm_read_nvram(addr)
	int addr;
{
	PMData p;

	p.command = PMU_READ_NVRAM;
	p.num_data = 2;
	p.s_buf = p.r_buf = p.data;
	p.data[0] = addr >> 8;
	p.data[1] = addr;
	pmgrop(&p);

	return p.data[0];
}

void
pm_write_nvram(addr, val)
	int addr, val;
{
	PMData p;

	p.command = PMU_WRITE_NVRAM;
	p.num_data = 3;
	p.s_buf = p.r_buf = p.data;
	p.data[0] = addr >> 8;
	p.data[1] = addr;
	p.data[2] = val;
	pmgrop(&p);
}