/*- * 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 #include #include #include #include #include "acpi.h" #include #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; }