[dragonfly.git] / sys / platform / pc64 / acpica5 / acpi_machdep.c

/*-
 * Copyright (c) 2001 Mitsuru IWASAKI
 * 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 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 AUTHOR 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.
 *
 * $FreeBSD: src/sys/i386/acpica/acpi_machdep.c,v 1.20 2004/05/05 19:51:15 njl Exp $
 * $DragonFly: src/sys/platform/pc32/acpica5/acpi_machdep.c,v 1.14 2008/09/29 06:59:45 hasso Exp $
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/fcntl.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/uio.h>

#include "acpi.h"
#include <dev/acpica5/acpivar.h>
#include <dev/acpica5/acpiio.h>

static device_t	acpi_dev;

/*
 * APM driver emulation
 */

#include <sys/selinfo.h>

#include <machine/apm_bios.h>
#include <machine/pc/bios.h>
#include <machine_base/apm/apm.h>

uint32_t acpi_reset_video = 1;
TUNABLE_INT("hw.acpi.reset_video", &acpi_reset_video);

static int intr_model = ACPI_INTR_PIC;
static struct apm_softc	apm_softc;

static d_open_t apmopen;
static d_close_t apmclose;
static d_write_t apmwrite;
static d_ioctl_t apmioctl;
static d_poll_t apmpoll;

#define CDEV_MAJOR 39
static struct dev_ops apm_ops = {
	{ "apm", CDEV_MAJOR, 0 },
        .d_open = apmopen,
        .d_close = apmclose,
	.d_write = apmwrite,
        .d_ioctl = apmioctl,
	.d_poll = apmpoll
};

static int
acpi_capm_convert_battstate(struct  acpi_battinfo *battp)
{
	int	state;

	state = 0xff;	/* XXX unknown */

	if (battp->state & ACPI_BATT_STAT_DISCHARG) {
		if (battp->cap >= 50)
			state = 0;	/* high */
		else
			state = 1;	/* low */
	}
	if (battp->state & ACPI_BATT_STAT_CRITICAL)
		state = 2;		/* critical */
	if (battp->state & ACPI_BATT_STAT_CHARGING)
		state = 3;		/* charging */

	/* If still unknown, determine it based on the battery capacity. */
	if (state == 0xff) {
		if (battp->cap >= 50)
			state = 0;	/* high */
		else
			state = 1;	/* low */
	}

	return (state);
}

static int
acpi_capm_convert_battflags(struct  acpi_battinfo *battp)
{
	int	flags;

	flags = 0;

	if (battp->cap >= 50)
		flags |= APM_BATT_HIGH;
	else {
		if (battp->state & ACPI_BATT_STAT_CRITICAL)
			flags |= APM_BATT_CRITICAL;
		else
			flags |= APM_BATT_LOW;
	}
	if (battp->state & ACPI_BATT_STAT_CHARGING)
		flags |= APM_BATT_CHARGING;
	if (battp->state == ACPI_BATT_STAT_NOT_PRESENT)
		flags = APM_BATT_NOT_PRESENT;

	return (flags);
}

static int
acpi_capm_get_info(apm_info_t aip)
{
	int	acline;
	struct	acpi_battinfo batt;

	aip->ai_infoversion = 1;
	aip->ai_major       = 1;
	aip->ai_minor       = 2;
	aip->ai_status      = apm_softc.active;
	aip->ai_capabilities= 0xff00;	/* XXX unknown */

	if (acpi_acad_get_acline(&acline))
		aip->ai_acline = 0xff;		/* unknown */
	else
		aip->ai_acline = acline;	/* on/off */

	if (acpi_battery_get_battinfo(NULL, &batt)) {
		aip->ai_batt_stat = 0xff;	/* unknown */
		aip->ai_batt_life = 0xff;	/* unknown */
		aip->ai_batt_time = -1;		/* unknown */
		aip->ai_batteries = 0;
	} else {
		aip->ai_batt_stat = acpi_capm_convert_battstate(&batt);
		aip->ai_batt_life = batt.cap;
		aip->ai_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
		aip->ai_batteries = acpi_battery_get_units();
	}

	return (0);
}

static int
acpi_capm_get_pwstatus(apm_pwstatus_t app)
{
	device_t dev;
	int	acline, unit, error;
	struct	acpi_battinfo batt;

	if (app->ap_device != PMDV_ALLDEV &&
	    (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
		return (1);

	if (app->ap_device == PMDV_ALLDEV)
		error = acpi_battery_get_battinfo(NULL, &batt);
	else {
		unit = app->ap_device - PMDV_BATT0;
		dev = devclass_get_device(devclass_find("battery"), unit);
		if (dev != NULL)
			error = acpi_battery_get_battinfo(dev, &batt);
		else
			error = ENXIO;
	}
	if (error)
		return (1);

	app->ap_batt_stat = acpi_capm_convert_battstate(&batt);
	app->ap_batt_flag = acpi_capm_convert_battflags(&batt);
	app->ap_batt_life = batt.cap;
	app->ap_batt_time = (batt.min == -1) ? -1 : batt.min * 60;

	if (acpi_acad_get_acline(&acline))
		app->ap_acline = 0xff;		/* unknown */
	else
		app->ap_acline = acline;	/* on/off */

	return (0);
}

static int
apmopen(struct dev_open_args *ap)
{
	return (0);
}

static int
apmclose(struct dev_close_args *ap)
{
	return (0);
}

static int
apmioctl(struct dev_ioctl_args *ap)
{
	int	error = 0;
	struct	acpi_softc *acpi_sc;
	struct apm_info info;
	apm_info_old_t aiop;

	acpi_sc = device_get_softc(acpi_dev);

	switch (ap->a_cmd) {
	case APMIO_SUSPEND:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		if (apm_softc.active)
			acpi_SetSleepState(acpi_sc, acpi_sc->acpi_suspend_sx);
		else
			error = EINVAL;
		break;
	case APMIO_STANDBY:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		if (apm_softc.active)
			acpi_SetSleepState(acpi_sc, acpi_sc->acpi_standby_sx);
		else
			error = EINVAL;
		break;
	case APMIO_GETINFO_OLD:
		if (acpi_capm_get_info(&info))
			error = ENXIO;
		aiop = (apm_info_old_t)ap->a_data;
		aiop->ai_major = info.ai_major;
		aiop->ai_minor = info.ai_minor;
		aiop->ai_acline = info.ai_acline;
		aiop->ai_batt_stat = info.ai_batt_stat;
		aiop->ai_batt_life = info.ai_batt_life;
		aiop->ai_status = info.ai_status;
		break;
	case APMIO_GETINFO:
		if (acpi_capm_get_info((apm_info_t)ap->a_data))
			error = ENXIO;
		break;
	case APMIO_GETPWSTATUS:
		if (acpi_capm_get_pwstatus((apm_pwstatus_t)ap->a_data))
			error = ENXIO;
		break;
	case APMIO_ENABLE:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		apm_softc.active = 1;
		break;
	case APMIO_DISABLE:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		apm_softc.active = 0;
		break;
	case APMIO_HALTCPU:
		break;
	case APMIO_NOTHALTCPU:
		break;
	case APMIO_DISPLAY:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		break;
	case APMIO_BIOS:
		if ((ap->a_fflag & FWRITE) == 0)
			return (EPERM);
		bzero(ap->a_data, sizeof(struct apm_bios_arg));
		break;
	default:
		error = EINVAL;
		break;
	}

	return (error);
}

static int
apmwrite(struct dev_write_args *ap)
{
	return (ap->a_uio->uio_resid);
}

static int
apmpoll(struct dev_poll_args *ap)
{
	ap->a_events = 0;
	return (0);
}

static void
acpi_capm_init(struct acpi_softc *sc)
{
        make_dev(&apm_ops, 0, 0, 5, 0664, "apm");
        make_dev(&apm_ops, 8, 0, 5, 0664, "apm");
	kprintf("Warning: ACPI is disabling APM's device.  You can't run both\n");
}

int
acpi_machdep_init(device_t dev)
{
	struct	acpi_softc *sc;

	acpi_dev = dev;
	sc = device_get_softc(acpi_dev);

	/*
	 * XXX: Prevent the PnP BIOS code from interfering with
	 * our own scan of ISA devices.
	 */
#if 0
	PnPBIOStable = NULL;
#endif

	acpi_capm_init(sc);

	acpi_install_wakeup_handler(sc);

	if (intr_model == ACPI_INTR_PIC)
		BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt,
		    INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
	else
		acpi_SetIntrModel(intr_model);

	SYSCTL_ADD_UINT(&sc->acpi_sysctl_ctx,
	    SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO,
	    "reset_video", CTLFLAG_RD | CTLFLAG_RW, &acpi_reset_video, 0,
	    "Call the VESA reset BIOS vector on the resume path");

	return (0);
}

void
acpi_SetDefaultIntrModel(int model)
{

	intr_model = model;
}
Commit	Line	Data
e774ca6d MD	1	/*-
	2	* Copyright (c) 2001 Mitsuru IWASAKI
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	*
	14	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	15	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	16	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	17	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	18	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	19	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	20	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	21	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	22	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	23	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	24	* SUCH DAMAGE.
	25	*
	26	* $FreeBSD: src/sys/i386/acpica/acpi_machdep.c,v 1.20 2004/05/05 19:51:15 njl Exp $
	27	* $DragonFly: src/sys/platform/pc32/acpica5/acpi_machdep.c,v 1.14 2008/09/29 06:59:45 hasso Exp $
	28	*/
	29
	30	#include <sys/param.h>
	31	#include <sys/bus.h>
	32	#include <sys/conf.h>
	33	#include <sys/device.h>
	34	#include <sys/fcntl.h>
	35	#include <sys/kernel.h>
	36	#include <sys/sysctl.h>
	37	#include <sys/uio.h>
	38
	39	#include "acpi.h"
	40	#include <dev/acpica5/acpivar.h>
	41	#include <dev/acpica5/acpiio.h>
	42
	43	static device_t acpi_dev;
	44
	45	/*
	46	* APM driver emulation
	47	*/
	48
	49	#include <sys/selinfo.h>
	50
	51	#include <machine/apm_bios.h>
	52	#include <machine/pc/bios.h>
	53	#include <machine_base/apm/apm.h>
	54
	55	uint32_t acpi_reset_video = 1;
	56	TUNABLE_INT("hw.acpi.reset_video", &acpi_reset_video);
	57
	58	static int intr_model = ACPI_INTR_PIC;
	59	static struct apm_softc apm_softc;
	60
	61	static d_open_t apmopen;
	62	static d_close_t apmclose;
	63	static d_write_t apmwrite;
	64	static d_ioctl_t apmioctl;
65	static d_poll_t apmpoll;
66
67	#define CDEV_MAJOR 39
68	static struct dev_ops apm_ops = {
69	{ "apm", CDEV_MAJOR, 0 },
70	.d_open = apmopen,
71	.d_close = apmclose,
72	.d_write = apmwrite,
73	.d_ioctl = apmioctl,
74	.d_poll = apmpoll
75	};
76
77	static int
78	acpi_capm_convert_battstate(struct acpi_battinfo *battp)
79	{
80	int state;
81
82	state = 0xff; /* XXX unknown */
83
84	if (battp->state & ACPI_BATT_STAT_DISCHARG) {
85	if (battp->cap >= 50)
86	state = 0; /* high */
87	else
88	state = 1; /* low */
89	}
90	if (battp->state & ACPI_BATT_STAT_CRITICAL)
91	state = 2; /* critical */
92	if (battp->state & ACPI_BATT_STAT_CHARGING)
93	state = 3; /* charging */
94
95	/* If still unknown, determine it based on the battery capacity. */
96	if (state == 0xff) {
97	if (battp->cap >= 50)
98	state = 0; /* high */
99	else
100	state = 1; /* low */
101	}
102
103	return (state);
104	}
105
106	static int
107	acpi_capm_convert_battflags(struct acpi_battinfo *battp)
108	{
109	int flags;
110
111	flags = 0;
112
113	if (battp->cap >= 50)
114	flags \|= APM_BATT_HIGH;
115	else {
116	if (battp->state & ACPI_BATT_STAT_CRITICAL)
117	flags \|= APM_BATT_CRITICAL;
118	else
119	flags \|= APM_BATT_LOW;
120	}
121	if (battp->state & ACPI_BATT_STAT_CHARGING)
122	flags \|= APM_BATT_CHARGING;
123	if (battp->state == ACPI_BATT_STAT_NOT_PRESENT)
124	flags = APM_BATT_NOT_PRESENT;
125
126	return (flags);
127	}
128
129	static int
130	acpi_capm_get_info(apm_info_t aip)
131	{
132	int acline;
133	struct acpi_battinfo batt;
134
135	aip->ai_infoversion = 1;
136	aip->ai_major = 1;
137	aip->ai_minor = 2;
138	aip->ai_status = apm_softc.active;
139	aip->ai_capabilities= 0xff00; /* XXX unknown */
140
141	if (acpi_acad_get_acline(&acline))
142	aip->ai_acline = 0xff; /* unknown */
143	else
144	aip->ai_acline = acline; /* on/off */
145
146	if (acpi_battery_get_battinfo(NULL, &batt)) {
147	aip->ai_batt_stat = 0xff; /* unknown */
148	aip->ai_batt_life = 0xff; /* unknown */
149	aip->ai_batt_time = -1; /* unknown */
150	aip->ai_batteries = 0;
151	} else {
152	aip->ai_batt_stat = acpi_capm_convert_battstate(&batt);
153	aip->ai_batt_life = batt.cap;
154	aip->ai_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
155	aip->ai_batteries = acpi_battery_get_units();
156	}
157
158	return (0);
159	}
160
161	static int
162	acpi_capm_get_pwstatus(apm_pwstatus_t app)
163	{
164	device_t dev;
165	int acline, unit, error;
166	struct acpi_battinfo batt;
167
168	if (app->ap_device != PMDV_ALLDEV &&
169	(app->ap_device < PMDV_BATT0 \|\| app->ap_device > PMDV_BATT_ALL))
170	return (1);
171
172	if (app->ap_device == PMDV_ALLDEV)
173	error = acpi_battery_get_battinfo(NULL, &batt);
174	else {
175	unit = app->ap_device - PMDV_BATT0;
176	dev = devclass_get_device(devclass_find("battery"), unit);
177	if (dev != NULL)
178	error = acpi_battery_get_battinfo(dev, &batt);
179	else
180	error = ENXIO;
181	}
182	if (error)
183	return (1);
184
185	app->ap_batt_stat = acpi_capm_convert_battstate(&batt);
186	app->ap_batt_flag = acpi_capm_convert_battflags(&batt);
187	app->ap_batt_life = batt.cap;
188	app->ap_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
189
190	if (acpi_acad_get_acline(&acline))
191	app->ap_acline = 0xff; /* unknown */
192	else
193	app->ap_acline = acline; /* on/off */
194
195	return (0);
196	}
197
198	static int
199	apmopen(struct dev_open_args *ap)
200	{
201	return (0);
202	}
203
204	static int
205	apmclose(struct dev_close_args *ap)
206	{
207	return (0);
208	}
209
210	static int
211	apmioctl(struct dev_ioctl_args *ap)
212	{
213	int error = 0;
214	struct acpi_softc *acpi_sc;
215	struct apm_info info;
216	apm_info_old_t aiop;
217
218	acpi_sc = device_get_softc(acpi_dev);
219
220	switch (ap->a_cmd) {
221	case APMIO_SUSPEND:
222	if ((ap->a_fflag & FWRITE) == 0)
223	return (EPERM);
224	if (apm_softc.active)
225	acpi_SetSleepState(acpi_sc, acpi_sc->acpi_suspend_sx);
226	else
227	error = EINVAL;
228	break;
229	case APMIO_STANDBY:
230	if ((ap->a_fflag & FWRITE) == 0)
231	return (EPERM);
232	if (apm_softc.active)
233	acpi_SetSleepState(acpi_sc, acpi_sc->acpi_standby_sx);
234	else
235	error = EINVAL;
236	break;
237	case APMIO_GETINFO_OLD:
238	if (acpi_capm_get_info(&info))
239	error = ENXIO;
240	aiop = (apm_info_old_t)ap->a_data;
241	aiop->ai_major = info.ai_major;
242	aiop->ai_minor = info.ai_minor;
243	aiop->ai_acline = info.ai_acline;
244	aiop->ai_batt_stat = info.ai_batt_stat;
245	aiop->ai_batt_life = info.ai_batt_life;
246	aiop->ai_status = info.ai_status;
247	break;
248	case APMIO_GETINFO:
249	if (acpi_capm_get_info((apm_info_t)ap->a_data))
250	error = ENXIO;
251	break;
252	case APMIO_GETPWSTATUS:
253	if (acpi_capm_get_pwstatus((apm_pwstatus_t)ap->a_data))
254	error = ENXIO;
255	break;
256	case APMIO_ENABLE:
257	if ((ap->a_fflag & FWRITE) == 0)
258	return (EPERM);
259	apm_softc.active = 1;
260	break;
261	case APMIO_DISABLE:
262	if ((ap->a_fflag & FWRITE) == 0)
263	return (EPERM);
264	apm_softc.active = 0;
265	break;
266	case APMIO_HALTCPU:
267	break;
268	case APMIO_NOTHALTCPU:
269	break;
270	case APMIO_DISPLAY:
271	if ((ap->a_fflag & FWRITE) == 0)
272	return (EPERM);
273	break;
274	case APMIO_BIOS:
275	if ((ap->a_fflag & FWRITE) == 0)
276	return (EPERM);
277	bzero(ap->a_data, sizeof(struct apm_bios_arg));
278	break;
279	default:
280	error = EINVAL;
281	break;
282	}
283
284	return (error);
285	}
286
287	static int
288	apmwrite(struct dev_write_args *ap)
289	{
290	return (ap->a_uio->uio_resid);
291	}
292
293	static int
294	apmpoll(struct dev_poll_args *ap)
295	{
296	ap->a_events = 0;
297	return (0);
298	}
299
300	static void
301	acpi_capm_init(struct acpi_softc *sc)
302	{
e774ca6d MD	303	make_dev(&apm_ops, 0, 0, 5, 0664, "apm");
	304	make_dev(&apm_ops, 8, 0, 5, 0664, "apm");
	305	kprintf("Warning: ACPI is disabling APM's device. You can't run both\n");
	306	}
	307
	308	int
	309	acpi_machdep_init(device_t dev)
	310	{
	311	struct acpi_softc *sc;
	312
	313	acpi_dev = dev;
	314	sc = device_get_softc(acpi_dev);
	315
	316	/*
	317	* XXX: Prevent the PnP BIOS code from interfering with
	318	* our own scan of ISA devices.
	319	*/
	320	#if 0
	321	PnPBIOStable = NULL;
	322	#endif
	323
	324	acpi_capm_init(sc);
	325
	326	acpi_install_wakeup_handler(sc);
	327
	328	if (intr_model == ACPI_INTR_PIC)
	329	BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt,
	330	INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
	331	else
	332	acpi_SetIntrModel(intr_model);
	333
	334	SYSCTL_ADD_UINT(&sc->acpi_sysctl_ctx,
	335	SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO,
	336	"reset_video", CTLFLAG_RD \| CTLFLAG_RW, &acpi_reset_video, 0,
	337	"Call the VESA reset BIOS vector on the resume path");
	338
	339	return (0);
	340	}
	341
	342	void
	343	acpi_SetDefaultIntrModel(int model)
	344	{
	345
	346	intr_model = model;
	347	}