freebsd-dev/sys/dev/acpica/acpi_isa.c

/*-
 * Copyright (c) 2000 Michael Smith
 * Copyright (c) 2000 BSDi
 * 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$
 */

/*
 * ISA bus enumerator using PnP HIDs from ACPI space.
 */

#include "opt_acpi.h"
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bus.h>

#include <isa/isavar.h>

#include "acpi.h"

#include <dev/acpica/acpivar.h>

#define PNP_HEXTONUM(c) ((c) >= 'a'		\
			 ? (c) - 'a' + 10	\
			 : ((c) >= 'A'		\
			    ? (c) - 'A' + 10	\
			    : (c) - '0'))
#define PNP_EISAID(s)				\
	((((s[0] - '@') & 0x1f) << 2)		\
	 | (((s[1] - '@') & 0x18) >> 3)		\
	 | (((s[1] - '@') & 0x07) << 13)	\
	 | (((s[2] - '@') & 0x1f) << 8)		\
	 | (PNP_HEXTONUM(s[4]) << 16)		\
	 | (PNP_HEXTONUM(s[3]) << 20)		\
	 | (PNP_HEXTONUM(s[6]) << 24)		\
	 | (PNP_HEXTONUM(s[5]) << 28))

static void	acpi_isa_set_init(device_t dev, void **context);
static void	acpi_isa_set_done(device_t dev, void *context);
static void	acpi_isa_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void	acpi_isa_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high, 
				     u_int32_t length, u_int32_t align);
static void	acpi_isa_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length);
static void	acpi_isa_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high, 
					 u_int32_t length, u_int32_t align);
static void	acpi_isa_set_irq(device_t dev, void *context, u_int32_t irq);
static void	acpi_isa_set_drq(device_t dev, void *context, u_int32_t drq);
static void	acpi_isa_set_start_dependant(device_t dev, void *context, int preference);
static void	acpi_isa_set_end_dependant(device_t dev, void *context);

static struct acpi_parse_resource_set acpi_isa_parse_set = {
    acpi_isa_set_init,
    acpi_isa_set_done,
    acpi_isa_set_ioport,
    acpi_isa_set_iorange,
    acpi_isa_set_memory,
    acpi_isa_set_memoryrange,
    acpi_isa_set_irq,
    acpi_isa_set_drq,
    acpi_isa_set_start_dependant,
    acpi_isa_set_end_dependant
};

#define MAXDEP	8

struct acpi_isa_context {
    int			ai_config;
    int			ai_nconfigs;
    struct isa_config	ai_configs[MAXDEP + 1];
    int			ai_priorities[MAXDEP + 1];
};

static void		acpi_isa_set_config(void *arg, struct isa_config *config, int enable);
static void		acpi_isa_identify(driver_t *driver, device_t bus);
static ACPI_STATUS	acpi_isa_identify_child(ACPI_HANDLE handle, UINT32 level, 
						void *context, void **status);

static device_method_t acpi_isa_methods[] = {
    DEVMETHOD(device_identify,	acpi_isa_identify),
    {0, 0}
};

static driver_t acpi_isa_driver = {
    "acpi_isa",
    acpi_isa_methods,
    1,
};

static devclass_t acpi_isa_devclass;
DRIVER_MODULE(acpi_isa, isa, acpi_isa_driver, acpi_isa_devclass, 0, 0);

/*
 * This function is called to make the selected configuration 
 * active.
 */
static void
acpi_isa_set_config(void *arg, struct isa_config *config, int enable)
{
}

/*
 * Interrogate ACPI for devices which might be attatched to an ISA
 * bus.
 *
 * Note that it is difficult to determine whether a device in the ACPI
 * namespace is or is not visible to the ISA bus, and thus we are a 
 * little too generous here and just export everything with _HID
 * and _CRS.
 */
static void
acpi_isa_identify(driver_t *driver, device_t bus)
{
    ACPI_HANDLE		parent;
    ACPI_STATUS		status;

    /*If this driver is loaded from userland ,just ignore*/
    if(!cold){
	    return;
    }

    /*
     * Look for the _SB_ scope, which will contain all the devices
     * we are likely to support.
     */
    if ((status = AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &parent)) != AE_OK) {
	device_printf(bus, "no ACPI _SB_ scope - %s\n", acpi_strerror(status));
	return;
    }

    if ((status = AcpiWalkNamespace(ACPI_TYPE_DEVICE, parent, 100, acpi_isa_identify_child, bus, NULL)) != AE_OK) {
	device_printf(bus, "AcpiWalkNamespace on _SB_ failed - %s\n", acpi_strerror(status));
	return;
    }
}

/*
 * Check a device to see whether it makes sense to try attaching it to an
 * ISA bus, and if so, do so.
 *
 * Note that we *must* always return AE_OK, or the namespace walk will terminate.
 *
 * XXX Note also that this is picking up a *lot* of things that are not ISA devices.
 *     Should we consider lazy-binding this so that only the ID is saved and resources
 *     are not parsed until the device is claimed by a driver?
 */
static ACPI_STATUS
acpi_isa_identify_child(ACPI_HANDLE handle, UINT32 level, void *context, void **status)
{
    ACPI_DEVICE_INFO	devinfo;
    ACPI_BUFFER		buf;
    device_t		child, bus = (device_t)context;
    u_int32_t		devid;

    /*
     * Try to get information about the device
     */
    if (AcpiGetObjectInfo(handle, &devinfo) != AE_OK)
	return(AE_OK);

    /*
     * Reformat the _HID value into 32 bits.
     */
    if (!(devinfo.Valid & ACPI_VALID_HID))
	return(AE_OK);

    /*
     * XXX Try to avoid passing stuff to ISA that it just isn't interested
     *     in.  This is the *wrong* solution, and what needs to be done
     *     involves just sending ISA the PnP ID and a handle, and then
     *     lazy-parsing the resources if and only if a driver attaches.
     *     With the way that ISA currently works (using bus_probe_and_attach)
     *     this is very difficult.  Maybe we need a device_configure method?
     */
    if (!(strncmp(devinfo.HardwareId, "PNP0C", 5)))
	return(AE_OK);

    devid = PNP_EISAID(devinfo.HardwareId);

    /* XXX check _STA here? */
    if (devinfo.Valid & ACPI_VALID_STA) {
    }

    /*
     * Fetch our current settings.
     *
     * XXX Note that we may want to support alternate settings at some
     *     point as well.
     */
    if (acpi_GetIntoBuffer(handle, AcpiGetCurrentResources, &buf) != AE_OK)
	return(AE_OK);

    /*
     * Add the device and parse our resources
     */
    child = BUS_ADD_CHILD(bus, ISA_ORDER_PNP, NULL, -1);
    isa_set_vendorid(child, devid);
    isa_set_logicalid(child, devid);
    ISA_SET_CONFIG_CALLBACK(bus, child, acpi_isa_set_config, 0);
    acpi_parse_resources(child, handle, &acpi_isa_parse_set);
    AcpiOsFree(buf.Pointer);

    if (!device_get_desc(child))
	device_set_desc_copy(child, devinfo.HardwareId);

    /*
     * XXX Parse configuration data and _CID list to find compatible IDs
     */
    return(AE_OK);
}

static void
acpi_isa_set_init(device_t dev, void **context)
{
    struct acpi_isa_context	*cp;

    cp = malloc(sizeof(*cp), M_DEVBUF, M_NOWAIT);
    bzero(cp, sizeof(*cp));
    cp->ai_nconfigs = 1;
    *context = cp;
}

static void
acpi_isa_set_done(device_t dev, void *context)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*config, *configs;
    device_t			parent;
    int				i, j;

    if (cp == NULL)
	return;
    parent = device_get_parent(dev);
    
    /* simple config without dependants */
    if (cp->ai_nconfigs == 1) {
	ISA_ADD_CONFIG(parent, dev, cp->ai_priorities[0], &cp->ai_configs[0]);
	goto done;
    }

    /* Cycle through dependant configs merging primary details */
    configs = &cp->ai_configs[0];
    for(i = 1; i < cp->ai_nconfigs; i++) {
	config = &configs[i];
	for(j = 0; j < configs[0].ic_nmem; j++) {
	    if (config->ic_nmem == ISA_NMEM) {
		device_printf(parent, "too many memory ranges\n");
		free(configs, M_DEVBUF);
		return;
	    }
	    config->ic_mem[config->ic_nmem] = configs[0].ic_mem[j];
	    config->ic_nmem++;
	}
	for(j = 0; j < configs[0].ic_nport; j++) {
	    if (config->ic_nport == ISA_NPORT) {
		device_printf(parent, "too many port ranges\n");
		free(configs, M_DEVBUF);
		return;
	    }
	    config->ic_port[config->ic_nport] = configs[0].ic_port[j];
	    config->ic_nport++;
	}
	for(j = 0; j < configs[0].ic_nirq; j++) {
	    if (config->ic_nirq == ISA_NIRQ) {
		device_printf(parent, "too many irq ranges\n");
		free(configs, M_DEVBUF);
		return;
	    }
	    config->ic_irqmask[config->ic_nirq] = configs[0].ic_irqmask[j];
	    config->ic_nirq++;
	}
	for(j = 0; j < configs[0].ic_ndrq; j++) {
	    if (config->ic_ndrq == ISA_NDRQ) {
		device_printf(parent, "too many drq ranges\n");
		free(configs, M_DEVBUF);
		return;
	    }
	    config->ic_drqmask[config->ic_ndrq] = configs[0].ic_drqmask[j];
	    config->ic_ndrq++;
	}
	(void)ISA_ADD_CONFIG(parent, dev, cp->ai_priorities[i], &configs[i]);
    }

done:
    free(cp, M_DEVBUF);
}

static void
acpi_isa_set_ioport(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nport == ISA_NPORT) {
	printf("too many ports\n");
	return;
    }
    ic->ic_port[ic->ic_nport].ir_start = base;
    ic->ic_port[ic->ic_nport].ir_end = base + length - 1;
    ic->ic_port[ic->ic_nport].ir_size = length;
    ic->ic_port[ic->ic_nport].ir_align = 1;
    ic->ic_nport++;
}

static void
acpi_isa_set_iorange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nport == ISA_NPORT) {
	printf("too many ports\n");
	return;
    }
    ic->ic_port[ic->ic_nport].ir_start = low;
    ic->ic_port[ic->ic_nport].ir_end = high + length - 1;
    ic->ic_port[ic->ic_nport].ir_size = length;
    ic->ic_port[ic->ic_nport].ir_align = imin(1, align);
    ic->ic_nport++;
}

static void
acpi_isa_set_memory(device_t dev, void *context, u_int32_t base, u_int32_t length)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nmem == ISA_NMEM) {
	printf("too many memory ranges\n");
	return;
    }
    ic->ic_mem[ic->ic_nmem].ir_start = base;
    ic->ic_mem[ic->ic_nmem].ir_end = base + length - 1;
    ic->ic_mem[ic->ic_nmem].ir_size = length;
    ic->ic_mem[ic->ic_nmem].ir_align = 1;
    ic->ic_nmem++;
}

static void
acpi_isa_set_memoryrange(device_t dev, void *context, u_int32_t low, u_int32_t high, u_int32_t length, u_int32_t align)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nmem == ISA_NMEM) {
	printf("too many memory ranges\n");
	return;
    }
    ic->ic_mem[ic->ic_nmem].ir_start = low;
    ic->ic_mem[ic->ic_nmem].ir_end = high + length - 1;
    ic->ic_mem[ic->ic_nmem].ir_size = length;
    ic->ic_mem[ic->ic_nmem].ir_align = imin(1, align);
    ic->ic_nmem++;
}

static void
acpi_isa_set_irq(device_t dev, void *context, u_int32_t irq)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nirq == ISA_NIRQ) {
	printf("too many IRQs\n");
	return;
    }
    ic->ic_irqmask[ic->ic_nirq] = 1 << irq;
    ic->ic_nirq++;
}

static void
acpi_isa_set_drq(device_t dev, void *context, u_int32_t drq)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;
    struct isa_config		*ic = &cp->ai_configs[cp->ai_config];

    if (cp == NULL)
	return;
    if (ic->ic_nirq == ISA_NDRQ) {
	printf("too many DRQs\n");
	return;
    }
    ic->ic_drqmask[ic->ic_ndrq] = drq;
    ic->ic_ndrq++;
}

/*
 * XXX the "too many dependant configs" logic here is wrong, and
 * will spam the last dependant config.
 */
static void
acpi_isa_set_start_dependant(device_t dev, void *context, int preference)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;

    if (cp == NULL)
	return;

    if (cp->ai_nconfigs > MAXDEP) {
	printf("too many dependant configs\n");
	return;
    }
    cp->ai_config = cp->ai_nconfigs;
    cp->ai_priorities[cp->ai_config] = preference;
    cp->ai_nconfigs++;
}

static void
acpi_isa_set_end_dependant(device_t dev, void *context)
{
    struct acpi_isa_context	*cp = (struct acpi_isa_context *)context;

    if (cp == NULL)
	return;
    cp->ai_config = 0;
}