--- /dev/null
+/* $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 <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+#include <sys/malloc.h>
+#include <sys/queue.h>
+
+#include <machine/intr.h>
+#include <machine/rpb.h>
+
+#include <dev/eisa/eisareg.h>
+#include <dev/eisa/eisavar.h>
+
+#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);
+}
projects / openbsd / commitdiff