From: miod Date: Sat, 19 Jul 2008 18:13:04 +0000 (+0000) Subject: Add code to walk the eisa configuration, from NetBSD. This configuration X-Git-Url: http://artulab.com/gitweb/?a=commitdiff_plain;h=22e73efa5c46d06ff003e82a55f00f069f2a99a4;p=openbsd Add code to walk the eisa configuration, from NetBSD. This configuration is not used yet, but this seems to ``warm up'' the eisa chips so that accesses to the eisa bus later do not cause machine checks. --- diff --git a/sys/arch/alpha/conf/files.alpha b/sys/arch/alpha/conf/files.alpha index 05011b8f1bb..277b0cea08f 100644 --- a/sys/arch/alpha/conf/files.alpha +++ b/sys/arch/alpha/conf/files.alpha @@ -1,4 +1,4 @@ -# $OpenBSD: files.alpha,v 1.86 2008/05/20 08:03:53 kettenis Exp $ +# $OpenBSD: files.alpha,v 1.87 2008/07/19 18:13:04 miod Exp $ # $NetBSD: files.alpha,v 1.32 1996/11/25 04:03:21 cgd Exp $ # # alpha-specific configuration info @@ -164,6 +164,8 @@ major {fd = 4} include "dev/eisa/files.eisa" +file arch/alpha/eisa/eisa_machdep.c eisa + # # PCI Bus support diff --git a/sys/arch/alpha/eisa/eisa_machdep.c b/sys/arch/alpha/eisa/eisa_machdep.c new file mode 100644 index 00000000000..a4d66651c36 --- /dev/null +++ b/sys/arch/alpha/eisa/eisa_machdep.c @@ -0,0 +1,576 @@ +/* $OpenBSD: eisa_machdep.c,v 1.1 2008/07/19 18:13:06 miod Exp $ */ +/* $NetBSD: eisa_machdep.c,v 1.1 2000/07/29 23:18:47 thorpej Exp $ */ + +/*- + * Copyright (c) 2000 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Jason R. Thorpe. + * + * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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. + */ + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#define EISA_SLOT_HEADER_SIZE 31 +#define EISA_SLOT_INFO_OFFSET 20 + +#define EISA_FUNC_INFO_OFFSET 34 +#define EISA_CONFIG_BLOCK_SIZE 320 + +#define ECUF_TYPE_STRING 0x01 +#define ECUF_MEM_ENTRY 0x02 +#define ECUF_IRQ_ENTRY 0x04 +#define ECUF_DMA_ENTRY 0x08 +#define ECUF_IO_ENTRY 0x10 +#define ECUF_INIT_ENTRY 0x20 +#define ECUF_DISABLED 0x80 + +#define ECUF_SELECTIONS_SIZE 26 +#define ECUF_TYPE_STRING_SIZE 80 +#define ECUF_MEM_ENTRY_SIZE 7 +#define ECUF_IRQ_ENTRY_SIZE 2 +#define ECUF_DMA_ENTRY_SIZE 2 +#define ECUF_IO_ENTRY_SIZE 3 +#define ECUF_INIT_ENTRY_SIZE 60 + +#define ECUF_MEM_ENTRY_CNT 9 +#define ECUF_IRQ_ENTRY_CNT 7 +#define ECUF_DMA_ENTRY_CNT 4 +#define ECUF_IO_ENTRY_CNT 20 + +#define CBUFSIZE 512 + +/* + * EISA configuration space, as set up by the ECU, may be sparse. + */ +bus_size_t eisa_config_stride; +paddr_t eisa_config_addr; /* defaults to 0 */ +paddr_t eisa_config_header_addr; + +struct ecu_mem { + SIMPLEQ_ENTRY(ecu_mem) ecum_list; + bus_addr_t ecum_addr; + bus_size_t ecum_size; + int ecum_isram; + int ecum_decode; + int ecum_unitsize; +}; + +struct ecu_irq { + SIMPLEQ_ENTRY(ecu_irq) ecui_list; + int ecui_irq; + int ecui_ist; + int ecui_shared; +}; + +struct ecu_dma { + SIMPLEQ_ENTRY(ecu_dma) ecud_list; + int ecud_drq; + int ecud_shared; + int ecud_size; +#define ECUD_SIZE_8BIT 0 +#define ECUD_SIZE_16BIT 1 +#define ECUD_SIZE_32BIT 2 +#define ECUD_SIZE_RESERVED 3 + int ecud_timing; +#define ECUD_TIMING_ISA 0 +#define ECUD_TIMING_TYPEA 1 +#define ECUD_TIMING_TYPEB 2 +#define ECUD_TIMING_TYPEC 3 +}; + +struct ecu_io { + SIMPLEQ_ENTRY(ecu_io) ecuio_list; + bus_addr_t ecuio_addr; + bus_size_t ecuio_size; + int ecuio_shared; +}; + +struct ecu_func { + SIMPLEQ_ENTRY(ecu_func) ecuf_list; + int ecuf_funcno; + u_int32_t ecuf_id; + u_int16_t ecuf_slot_info; + u_int16_t ecuf_cfg_ext; + u_int8_t ecuf_selections[ECUF_SELECTIONS_SIZE]; + u_int8_t ecuf_func_info; + u_int8_t ecuf_type_string[ECUF_TYPE_STRING_SIZE]; + u_int8_t ecuf_init[ECUF_INIT_ENTRY_SIZE]; + SIMPLEQ_HEAD(, ecu_mem) ecuf_mem; + SIMPLEQ_HEAD(, ecu_irq) ecuf_irq; + SIMPLEQ_HEAD(, ecu_dma) ecuf_dma; + SIMPLEQ_HEAD(, ecu_io) ecuf_io; +}; + +struct ecu_data { + SIMPLEQ_ENTRY(ecu_data) ecud_list; + int ecud_slot; + u_int8_t ecud_eisaid[EISA_IDSTRINGLEN]; + u_int32_t ecud_offset; + + /* General slot info. */ + u_int8_t ecud_slot_info; + u_int16_t ecud_ecu_major_rev; + u_int16_t ecud_ecu_minor_rev; + u_int16_t ecud_cksum; + u_int16_t ecud_ndevfuncs; + u_int8_t ecud_funcinfo; + u_int32_t ecud_comp_id; + + /* The functions */ + SIMPLEQ_HEAD(, ecu_func) ecud_funcs; +}; + +SIMPLEQ_HEAD(, ecu_data) ecu_data_list = + SIMPLEQ_HEAD_INITIALIZER(ecu_data_list); + +static void +ecuf_init(struct ecu_func *ecuf) +{ + + memset(ecuf, 0, sizeof(*ecuf)); + SIMPLEQ_INIT(&ecuf->ecuf_mem); + SIMPLEQ_INIT(&ecuf->ecuf_irq); + SIMPLEQ_INIT(&ecuf->ecuf_dma); + SIMPLEQ_INIT(&ecuf->ecuf_io); +} + +static void +eisa_parse_mem(struct ecu_func *ecuf, u_int8_t *dp) +{ + struct ecu_mem *ecum; + int i; + + for (i = 0; i < ECUF_MEM_ENTRY_CNT; i++) { + ecum = malloc(sizeof(*ecum), M_DEVBUF, M_ZERO|M_WAITOK); + if (ecum == NULL) + panic("%s: can't allocate memory for ecum", __func__); + + ecum->ecum_isram = dp[0] & 0x1; + ecum->ecum_unitsize = dp[1] & 0x3; + ecum->ecum_decode = (dp[1] >> 2) & 0x3; + ecum->ecum_addr = (dp[2] | (dp[3] << 8) | (dp[4] << 16)) << 8; + ecum->ecum_size = (dp[5] | (dp[6] << 8)) << 10; + if (ecum->ecum_size == 0) + ecum->ecum_size = (1 << 26); + SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_mem, ecum, ecum_list); + +#ifdef EISA_DEBUG + printf("MEM 0x%lx 0x%lx %d %d %d\n", + ecum->ecum_addr, ecum->ecum_size, + ecum->ecum_isram, ecum->ecum_unitsize, + ecum->ecum_decode); +#endif + + if ((dp[0] & 0x80) == 0) + break; + dp += ECUF_MEM_ENTRY_SIZE; + } +} + +static void +eisa_parse_irq(struct ecu_func *ecuf, u_int8_t *dp) +{ + struct ecu_irq *ecui; + int i; + + for (i = 0; i < ECUF_IRQ_ENTRY_CNT; i++) { + ecui = malloc(sizeof(*ecui), M_DEVBUF, M_ZERO|M_WAITOK); + if (ecui == NULL) + panic("%s: can't allocate memory for ecui", __func__); + + ecui->ecui_irq = dp[0] & 0xf; + ecui->ecui_ist = (dp[0] & 0x20) ? IST_LEVEL : IST_EDGE; + ecui->ecui_shared = (dp[0] & 0x40) ? 1 : 0; + SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_irq, ecui, ecui_list); + +#ifdef EISA_DEBUG + printf("IRQ %d %s%s\n", ecui->ecui_irq, + ecui->ecui_ist == IST_LEVEL ? "level" : "edge", + ecui->ecui_shared ? " shared" : ""); +#endif + + if ((dp[0] & 0x80) == 0) + break; + dp += ECUF_IRQ_ENTRY_SIZE; + } +} + +static void +eisa_parse_dma(struct ecu_func *ecuf, u_int8_t *dp) +{ + struct ecu_dma *ecud; + int i; + + for (i = 0; i < ECUF_DMA_ENTRY_CNT; i++) { + ecud = malloc(sizeof(*ecud), M_DEVBUF, M_ZERO|M_WAITOK); + if (ecud == NULL) + panic("%s: can't allocate memory for ecud", __func__); + + ecud->ecud_drq = dp[0] & 0x7; + ecud->ecud_shared = dp[0] & 0x40; + ecud->ecud_size = (dp[1] >> 2) & 0x3; + ecud->ecud_timing = (dp[1] >> 4) & 0x3; + SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_dma, ecud, ecud_list); + +#ifdef EISA_DEBUG + printf("DRQ %d%s %d %d\n", ecud->ecud_drq, + ecud->ecud_shared ? " shared" : "", + ecud->ecud_size, ecud->ecud_timing); +#endif + + if ((dp[0] & 0x80) == 0) + break; + dp += ECUF_DMA_ENTRY_SIZE; + } +} + +static void +eisa_parse_io(struct ecu_func *ecuf, u_int8_t *dp) +{ + struct ecu_io *ecuio; + int i; + + for (i = 0; i < ECUF_IO_ENTRY_CNT; i++) { + ecuio = malloc(sizeof(*ecuio), M_DEVBUF, M_ZERO|M_WAITOK); + if (ecuio == NULL) + panic("%s: can't allocate memory for ecuio", __func__); + + ecuio->ecuio_addr = dp[1] | (dp[2] << 8); + ecuio->ecuio_size = (dp[0] & 0x1f) + 1; + ecuio->ecuio_shared = (dp[0] & 0x40) ? 1 : 0; + +#ifdef EISA_DEBUG + printf("IO 0x%lx 0x%lx%s\n", ecuio->ecuio_addr, + ecuio->ecuio_size, + ecuio->ecuio_shared ? " shared" : ""); +#endif + + if ((dp[0] & 0x80) == 0) + break; + dp += ECUF_IO_ENTRY_SIZE; + } +} + +static void +eisa_read_config_bytes(paddr_t addr, void *buf, size_t count) +{ + const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr); + u_int8_t *dst = buf; + + for (; count != 0; count--) { + *dst++ = *src; + src += eisa_config_stride; + } +} + +static void +eisa_read_config_word(paddr_t addr, u_int32_t *valp) +{ + const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr); + u_int32_t val = 0; + int i; + + for (i = 0; i < sizeof(val); i++) { + val |= (u_int32_t)*src << (i * 8); + src += eisa_config_stride; + } + + *valp = val; +} + +static size_t +eisa_uncompress(void *cbufp, void *ucbufp, size_t count) +{ + const u_int8_t *cbuf = cbufp; + u_int8_t *ucbuf = ucbufp; + u_int zeros = 0; + + while (count--) { + if (zeros) { + zeros--; + *ucbuf++ = '\0'; + } else if (*cbuf == '\0') { + *ucbuf++ = *cbuf++; + zeros = *cbuf++ - 1; + } else + *ucbuf++ = *cbuf++; + } + + return ((size_t)cbuf - (size_t)cbufp); +} + +void +eisa_init(eisa_chipset_tag_t ec) +{ + struct ecu_data *ecud; + paddr_t cfgaddr; + u_int32_t offset; + u_int8_t eisaid[EISA_IDSTRINGLEN]; + u_int8_t *cdata, *data; + u_int8_t *cdp, *dp; + struct ecu_func *ecuf; + int i, func; + + /* + * Locate EISA configuration space. + */ + if (hwrpb->rpb_condat_off == 0UL || + (hwrpb->rpb_condat_off >> 63) != 0) { + printf(": WARNING: no EISA configuration space"); + return; + } + + if (eisa_config_header_addr) { + printf("\n"); + panic("eisa_init: EISA config space already initialized"); + } + + eisa_config_header_addr = hwrpb->rpb_condat_off; + if (eisa_config_stride == 0) + eisa_config_stride = 1; + +#ifdef EISA_DEBUG + printf("\nEISA config header at 0x%lx\n", eisa_config_header_addr); + printf("EISA config at %p\n", eisa_config_addr); + printf("EISA config stride: %ld\n", eisa_config_stride); +#endif + + /* + * Read the slot headers, and allocate config structures for + * valid slots. + */ + for (cfgaddr = eisa_config_header_addr, i = 0; + i < eisa_maxslots(ec); i++) { + eisa_read_config_bytes(cfgaddr, eisaid, sizeof(eisaid)); + eisaid[EISA_IDSTRINGLEN - 1] = '\0'; /* sanity */ + cfgaddr += sizeof(eisaid) * eisa_config_stride; + eisa_read_config_word(cfgaddr, &offset); + cfgaddr += sizeof(offset) * eisa_config_stride; + + if (offset != 0 && offset != 0xffffffff) { +#ifdef EISA_DEBUG + printf("SLOT %d: offset 0x%08x eisaid %s\n", + i, offset, eisaid); +#endif + ecud = malloc(sizeof(*ecud), M_DEVBUF, M_ZERO|M_WAITOK); + if (ecud == NULL) + panic("%s: can't allocate memory for ecud", + __func__); + + SIMPLEQ_INIT(&ecud->ecud_funcs); + + ecud->ecud_slot = i; + memcpy(ecud->ecud_eisaid, eisaid, sizeof(eisaid)); + ecud->ecud_offset = offset; + SIMPLEQ_INSERT_TAIL(&ecu_data_list, ecud, ecud_list); + } + } + + /* + * Now traverse the valid slots and read the info. + */ + + cdata = malloc(CBUFSIZE, M_TEMP, M_ZERO|M_WAITOK); + if (cdata == NULL) + panic("%s: can't allocate memory for cdata", __func__); + data = malloc(CBUFSIZE, M_TEMP, M_ZERO|M_WAITOK); + if (data == NULL) + panic("%s: can't allocate memory for data", __func__); + + SIMPLEQ_FOREACH(ecud, &ecu_data_list, ecud_list) { + cfgaddr = eisa_config_addr + ecud->ecud_offset; +#ifdef EISA_DEBUG + printf("Checking SLOT %d\n", ecud->ecud_slot); + printf("Reading config bytes at %p to cdata[0]\n", cfgaddr); +#endif + eisa_read_config_bytes(cfgaddr, &cdata[0], 1); + cfgaddr += eisa_config_stride; + + for (i = 1; i < CBUFSIZE; cfgaddr += eisa_config_stride, i++) { +#ifdef EISA_DEBUG + printf("Reading config bytes at %p to cdata[%d]\n", + cfgaddr, i); +#endif + eisa_read_config_bytes(cfgaddr, &cdata[i], 1); + if (cdata[i - 1] == 0 && cdata[i] == 0) + break; + } + if (i == CBUFSIZE) { + /* assume this compressed data invalid */ +#ifdef EISA_DEBUG + printf("SLOT %d has invalid config\n", ecud->ecud_slot); +#endif + continue; + } + + i++; /* index -> length */ + +#ifdef EISA_DEBUG + printf("SLOT %d compressed data length %d:", + ecud->ecud_slot, i); + { + int j; + + for (j = 0; j < i; j++) { + if ((j % 16) == 0) + printf("\n"); + printf("0x%02x ", cdata[j]); + } + printf("\n"); + } +#endif + + cdp = cdata; + dp = data; + + /* Uncompress the slot header. */ + cdp += eisa_uncompress(cdp, dp, EISA_SLOT_HEADER_SIZE); +#ifdef EISA_DEBUG + printf("SLOT %d uncompressed header data:", + ecud->ecud_slot); + { + int j; + + for (j = 0; j < EISA_SLOT_HEADER_SIZE; j++) { + if ((j % 16) == 0) + printf("\n"); + printf("0x%02x ", dp[j]); + } + printf("\n"); + } +#endif + + dp = &data[EISA_SLOT_INFO_OFFSET]; + ecud->ecud_slot_info = *dp++; + ecud->ecud_ecu_major_rev = *dp++; + ecud->ecud_ecu_minor_rev = *dp++; + memcpy(&ecud->ecud_cksum, dp, sizeof(ecud->ecud_cksum)); + dp += sizeof(ecud->ecud_cksum); + ecud->ecud_ndevfuncs = *dp++; + ecud->ecud_funcinfo = *dp++; + memcpy(&ecud->ecud_comp_id, dp, sizeof(ecud->ecud_comp_id)); + dp += sizeof(ecud->ecud_comp_id); + +#ifdef EISA_DEBUG + printf("SLOT %d: ndevfuncs %d\n", ecud->ecud_slot, + ecud->ecud_ndevfuncs); +#endif + + for (func = 0; func < ecud->ecud_ndevfuncs; func++) { + dp = data; + cdp += eisa_uncompress(cdp, dp, EISA_CONFIG_BLOCK_SIZE); +#ifdef EISA_DEBUG + printf("SLOT %d:%d uncompressed data:", + ecud->ecud_slot, func); + { + int j; + + for (j = 0; i < EISA_CONFIG_BLOCK_SIZE; j++) { + if ((j % 16) == 0) + printf("\n"); + printf("0x%02x ", dp[j]); + } + printf("\n"); + } +#endif + + /* Skip disabled functions. */ + if (dp[EISA_FUNC_INFO_OFFSET] & ECUF_DISABLED) { +#ifdef EISA_DEBUG + printf("SLOT %d:%d disabled\n", + ecud->ecud_slot, func); +#endif + continue; + } + + ecuf = malloc(sizeof(*ecuf), M_DEVBUF, M_WAITOK); + if (ecuf == NULL) + panic("%s: can't allocate memory for ecuf", + __func__); + ecuf_init(ecuf); + ecuf->ecuf_funcno = func; + SIMPLEQ_INSERT_TAIL(&ecud->ecud_funcs, ecuf, + ecuf_list); + + memcpy(&ecuf->ecuf_id, dp, sizeof(ecuf->ecuf_id)); + dp += sizeof(ecuf->ecuf_id); + + memcpy(&ecuf->ecuf_slot_info, dp, + sizeof(ecuf->ecuf_slot_info)); + dp += sizeof(ecuf->ecuf_slot_info); + + memcpy(&ecuf->ecuf_cfg_ext, dp, + sizeof(ecuf->ecuf_cfg_ext)); + dp += sizeof(ecuf->ecuf_cfg_ext); + + memcpy(&ecuf->ecuf_selections, dp, + sizeof(ecuf->ecuf_selections)); + dp += sizeof(ecuf->ecuf_selections); + + memcpy(&ecuf->ecuf_func_info, dp, + sizeof(ecuf->ecuf_func_info)); + dp += sizeof(ecuf->ecuf_func_info); + + if (ecuf->ecuf_func_info & ECUF_TYPE_STRING) + memcpy(ecuf->ecuf_type_string, dp, + sizeof(ecuf->ecuf_type_string)); + dp += sizeof(ecuf->ecuf_type_string); + + if (ecuf->ecuf_func_info & ECUF_MEM_ENTRY) + eisa_parse_mem(ecuf, dp); + dp += ECUF_MEM_ENTRY_SIZE * ECUF_MEM_ENTRY_CNT; + + if (ecuf->ecuf_func_info & ECUF_IRQ_ENTRY) + eisa_parse_irq(ecuf, dp); + dp += ECUF_IRQ_ENTRY_SIZE * ECUF_IRQ_ENTRY_CNT; + + if (ecuf->ecuf_func_info & ECUF_DMA_ENTRY) + eisa_parse_dma(ecuf, dp); + dp += ECUF_DMA_ENTRY_SIZE * ECUF_DMA_ENTRY_CNT; + + if (ecuf->ecuf_func_info & ECUF_IO_ENTRY) + eisa_parse_io(ecuf, dp); + dp += ECUF_IO_ENTRY_SIZE * ECUF_IO_ENTRY_CNT; + + if (ecuf->ecuf_func_info & ECUF_INIT_ENTRY) + memcpy(ecuf->ecuf_init, dp, + sizeof(ecuf->ecuf_init)); + dp += sizeof(ecuf->ecuf_init); + } + } + + free(cdata, M_TEMP); + free(data, M_TEMP); +} diff --git a/sys/arch/alpha/eisa/eisa_machdep.h b/sys/arch/alpha/eisa/eisa_machdep.h index 96b8165a4a1..7b904063e5d 100644 --- a/sys/arch/alpha/eisa/eisa_machdep.h +++ b/sys/arch/alpha/eisa/eisa_machdep.h @@ -1,4 +1,4 @@ -/* $OpenBSD: eisa_machdep.h,v 1.5 2002/03/14 03:15:50 millert Exp $ */ +/* $OpenBSD: eisa_machdep.h,v 1.6 2008/07/19 18:13:06 miod Exp $ */ /* $NetBSD: eisa_machdep.h,v 1.1 1996/04/12 05:39:51 cgd Exp $ */ /* @@ -63,3 +63,9 @@ struct alpha_eisa_chipset { (*(c)->ec_intr_establish)((c)->ec_v, (h), (t), (l), (f), (a), (nm)) #define eisa_intr_disestablish(c, h) \ (*(c)->ec_intr_disestablish)((c)->ec_v, (h)) + +/* + * Internal functions, NOT TO BE USED BY MACHINE-INDEPENDENT CODE! + */ + +void eisa_init(eisa_chipset_tag_t); diff --git a/sys/arch/alpha/pci/sio.c b/sys/arch/alpha/pci/sio.c index ab38f434d9b..f1d0bd9ace4 100644 --- a/sys/arch/alpha/pci/sio.c +++ b/sys/arch/alpha/pci/sio.c @@ -1,4 +1,4 @@ -/* $OpenBSD: sio.c,v 1.31 2006/01/02 05:21:26 brad Exp $ */ +/* $OpenBSD: sio.c,v 1.32 2008/07/19 18:13:06 miod Exp $ */ /* $NetBSD: sio.c,v 1.15 1996/12/05 01:39:36 cgd Exp $ */ /* @@ -45,6 +45,7 @@ #include +#include "eisa.h" #include "isadma.h" struct sio_softc { @@ -224,8 +225,9 @@ sio_eisa_attach_hook(parent, self, eba) struct device *parent, *self; struct eisabus_attach_args *eba; { - - /* Nothing to do. */ +#if NEISA > 0 + eisa_init(eba->eba_ec); +#endif } int