?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / arch / alpha / eisa / eisa_machdep.c
blob54f5197c674ffc8f75ec244cad4b9269e15ba02d
1 /* $NetBSD: eisa_machdep.c,v 1.7 2007/10/17 19:52:57 garbled Exp $ */
2
3 /*-
4 * Copyright (c) 2000 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33
34 __KERNEL_RCSID(0, "$NetBSD: eisa_machdep.c,v 1.7 2007/10/17 19:52:57 garbled Exp $");
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/device.h>
39 #include <sys/malloc.h>
40 #include <sys/queue.h>
41
42 #include <machine/intr.h>
43 #include <machine/rpb.h>
44
45 #include <dev/eisa/eisareg.h>
46 #include <dev/eisa/eisavar.h>
47
48 #define EISA_SLOT_HEADER_SIZE 31
49 #define EISA_SLOT_INFO_OFFSET 20
50
51 #define EISA_FUNC_INFO_OFFSET 34
52 #define EISA_CONFIG_BLOCK_SIZE 320
53
54 #define ECUF_TYPE_STRING 0x01
55 #define ECUF_MEM_ENTRY 0x02
56 #define ECUF_IRQ_ENTRY 0x04
57 #define ECUF_DMA_ENTRY 0x08
58 #define ECUF_IO_ENTRY 0x10
59 #define ECUF_INIT_ENTRY 0x20
60 #define ECUF_DISABLED 0x80
61
62 #define ECUF_SELECTIONS_SIZE 26
63 #define ECUF_TYPE_STRING_SIZE 80
64 #define ECUF_MEM_ENTRY_SIZE 7
65 #define ECUF_IRQ_ENTRY_SIZE 2
66 #define ECUF_DMA_ENTRY_SIZE 2
67 #define ECUF_IO_ENTRY_SIZE 3
68 #define ECUF_INIT_ENTRY_SIZE 60
69
70 #define ECUF_MEM_ENTRY_CNT 9
71 #define ECUF_IRQ_ENTRY_CNT 7
72 #define ECUF_DMA_ENTRY_CNT 4
73 #define ECUF_IO_ENTRY_CNT 20
74
75 #define CBUFSIZE 512
76
77 /*
78 * EISA configuration space, as set up by the ECU, may be sparse.
79 */
80 bus_size_t eisa_config_stride;
81 paddr_t eisa_config_addr; /* defaults to 0 */
82 paddr_t eisa_config_header_addr;
83
84 struct ecu_mem {
85 SIMPLEQ_ENTRY(ecu_mem) ecum_list;
86 struct eisa_cfg_mem ecum_mem;
87 };
88
89 struct ecu_irq {
90 SIMPLEQ_ENTRY(ecu_irq) ecui_list;
91 struct eisa_cfg_irq ecui_irq;
92 };
93
94 struct ecu_dma {
95 SIMPLEQ_ENTRY(ecu_dma) ecud_list;
96 struct eisa_cfg_dma ecud_dma;
97 };
98
99 struct ecu_io {
100 SIMPLEQ_ENTRY(ecu_io) ecuio_list;
101 struct eisa_cfg_io ecuio_io;
102 };
103
104 struct ecu_func {
105 SIMPLEQ_ENTRY(ecu_func) ecuf_list;
106 int ecuf_funcno;
107 u_int32_t ecuf_id;
108 u_int16_t ecuf_slot_info;
109 u_int16_t ecuf_cfg_ext;
110 u_int8_t ecuf_selections[ECUF_SELECTIONS_SIZE];
111 u_int8_t ecuf_func_info;
112 u_int8_t ecuf_type_string[ECUF_TYPE_STRING_SIZE];
113 u_int8_t ecuf_init[ECUF_INIT_ENTRY_SIZE];
114 SIMPLEQ_HEAD(, ecu_mem) ecuf_mem;
115 SIMPLEQ_HEAD(, ecu_irq) ecuf_irq;
116 SIMPLEQ_HEAD(, ecu_dma) ecuf_dma;
117 SIMPLEQ_HEAD(, ecu_io) ecuf_io;
118 };
119
120 struct ecu_data {
121 SIMPLEQ_ENTRY(ecu_data) ecud_list;
122 int ecud_slot;
123 u_int8_t ecud_eisaid[EISA_IDSTRINGLEN];
124 u_int32_t ecud_offset;
125
126 /* General slot info. */
127 u_int8_t ecud_slot_info;
128 u_int16_t ecud_ecu_major_rev;
129 u_int16_t ecud_ecu_minor_rev;
130 u_int16_t ecud_cksum;
131 u_int16_t ecud_ndevfuncs;
132 u_int8_t ecud_funcinfo;
133 u_int32_t ecud_comp_id;
134
135 /* The functions */
136 SIMPLEQ_HEAD(, ecu_func) ecud_funcs;
137 };
138
139 SIMPLEQ_HEAD(, ecu_data) ecu_data_list =
140 SIMPLEQ_HEAD_INITIALIZER(ecu_data_list);
141
142 static void
143 ecuf_init(struct ecu_func *ecuf)
144 {
145
146 memset(ecuf, 0, sizeof(*ecuf));
147 SIMPLEQ_INIT(&ecuf->ecuf_mem);
148 SIMPLEQ_INIT(&ecuf->ecuf_irq);
149 SIMPLEQ_INIT(&ecuf->ecuf_dma);
150 SIMPLEQ_INIT(&ecuf->ecuf_io);
151 }
152
153 static void
154 eisa_parse_mem(struct ecu_func *ecuf, u_int8_t *dp)
155 {
156 struct ecu_mem *ecum;
157 int i;
158
159 for (i = 0; i < ECUF_MEM_ENTRY_CNT; i++) {
160 ecum = malloc(sizeof(*ecum), M_DEVBUF, M_ZERO|M_WAITOK);
161 if (ecum == NULL)
162 panic("%s: can't allocate memory for ecum", __func__);
163
164 ecum->ecum_mem.ecm_isram = dp[0] & 0x1;
165 ecum->ecum_mem.ecm_unitsize = dp[1] & 0x3;
166 ecum->ecum_mem.ecm_decode = (dp[1] >> 2) & 0x3;
167 ecum->ecum_mem.ecm_addr =
168 (dp[2] | (dp[3] << 8) | (dp[4] << 16)) << 8;
169 ecum->ecum_mem.ecm_size = (dp[5] | (dp[6] << 8)) << 10;
170 if (ecum->ecum_mem.ecm_size == 0)
171 ecum->ecum_mem.ecm_size = (1 << 26);
172 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_mem, ecum, ecum_list);
173
174 #ifdef EISA_DEBUG
175 printf("MEM 0x%lx 0x%lx %d %d %d\n",
176 ecum->ecum_mem.ecm_addr, ecum->ecum_mem.ecm_size,
177 ecum->ecum_mem.ecm_isram, ecum->ecum_mem.ecm_unitsize,
178 ecum->ecum_mem.ecm_decode);
179 #endif
180
181 if ((dp[0] & 0x80) == 0)
182 break;
183 dp += ECUF_MEM_ENTRY_SIZE;
184 }
185 }
186
187 static void
188 eisa_parse_irq(struct ecu_func *ecuf, u_int8_t *dp)
189 {
190 struct ecu_irq *ecui;
191 int i;
192
193 for (i = 0; i < ECUF_IRQ_ENTRY_CNT; i++) {
194 ecui = malloc(sizeof(*ecui), M_DEVBUF, M_ZERO|M_WAITOK);
195 if (ecui == NULL)
196 panic("%s: can't allocate memory for ecui", __func__);
197
198 ecui->ecui_irq.eci_irq = dp[0] & 0xf;
199 ecui->ecui_irq.eci_ist = (dp[0] & 0x20) ? IST_LEVEL : IST_EDGE;
200 ecui->ecui_irq.eci_shared = (dp[0] & 0x40) ? 1 : 0;
201 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_irq, ecui, ecui_list);
202
203 #ifdef EISA_DEBUG
204 printf("IRQ %d %s%s\n", ecui->ecui_irq.eci_irq,
205 ecui->ecui_irq.eci_ist == IST_LEVEL ? "level" : "edge",
206 ecui->ecui_irq.eci_shared ? " shared" : "");
207 #endif
208
209 if ((dp[0] & 0x80) == 0)
210 break;
211 dp += ECUF_IRQ_ENTRY_SIZE;
212 }
213 }
214
215 static void
216 eisa_parse_dma(struct ecu_func *ecuf, u_int8_t *dp)
217 {
218 struct ecu_dma *ecud;
219 int i;
220
221 for (i = 0; i < ECUF_DMA_ENTRY_CNT; i++) {
222 ecud = malloc(sizeof(*ecud), M_DEVBUF, M_ZERO|M_WAITOK);
223 if (ecud == NULL)
224 panic("%s: can't allocate memory for ecud", __func__);
225
226 ecud->ecud_dma.ecd_drq = dp[0] & 0x7;
227 ecud->ecud_dma.ecd_shared = dp[0] & 0x40;
228 ecud->ecud_dma.ecd_size = (dp[1] >> 2) & 0x3;
229 ecud->ecud_dma.ecd_timing = (dp[1] >> 4) & 0x3;
230 SIMPLEQ_INSERT_TAIL(&ecuf->ecuf_dma, ecud, ecud_list);
231
232 #ifdef EISA_DEBUG
233 printf("DRQ %d%s %d %d\n", ecud->ecud_dma.ecd_drq,
234 ecud->ecud_dma.ecd_shared ? " shared" : "",
235 ecud->ecud_dma.ecd_size, ecud->ecud_dma.ecd_timing);
236 #endif
237
238 if ((dp[0] & 0x80) == 0)
239 break;
240 dp += ECUF_DMA_ENTRY_SIZE;
241 }
242 }
243
244 static void
245 eisa_parse_io(struct ecu_func *ecuf, u_int8_t *dp)
246 {
247 struct ecu_io *ecuio;
248 int i;
249
250 for (i = 0; i < ECUF_IO_ENTRY_CNT; i++) {
251 ecuio = malloc(sizeof(*ecuio), M_DEVBUF, M_ZERO|M_WAITOK);
252 if (ecuio == NULL)
253 panic("%s: can't allocate memory for ecuio", __func__);
254
255 ecuio->ecuio_io.ecio_addr = dp[1] | (dp[2] << 8);
256 ecuio->ecuio_io.ecio_size = (dp[0] & 0x1f) + 1;
257 ecuio->ecuio_io.ecio_shared = (dp[0] & 0x40) ? 1 : 0;
258
259 #ifdef EISA_DEBUG
260 printf("IO 0x%lx 0x%lx%s\n", ecuio->ecuio_io.ecio_addr,
261 ecuio->ecuio_io.ecio_size,
262 ecuio->ecuio_io.ecio_shared ? " shared" : "");
263 #endif
264
265 if ((dp[0] & 0x80) == 0)
266 break;
267 dp += ECUF_IO_ENTRY_SIZE;
268 }
269 }
270
271 static void
272 eisa_read_config_bytes(paddr_t addr, void *buf, size_t count)
273 {
274 const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr);
275 u_int8_t *dst = buf;
276
277 for (; count != 0; count--) {
278 *dst++ = *src;
279 src += eisa_config_stride;
280 }
281 }
282
283 static void
284 eisa_read_config_word(paddr_t addr, u_int32_t *valp)
285 {
286 const u_int8_t *src = (const u_int8_t *)ALPHA_PHYS_TO_K0SEG(addr);
287 u_int32_t val = 0;
288 int i;
289
290 for (i = 0; i < sizeof(val); i++) {
291 val |= (uint32_t)*src << (i * 8);
292 src += eisa_config_stride;
293 }
294
295 *valp = val;
296 }
297
298 static size_t
299 eisa_uncompress(void *cbufp, void *ucbufp, size_t count)
300 {
301 const u_int8_t *cbuf = cbufp;
302 u_int8_t *ucbuf = ucbufp;
303 u_int zeros = 0;
304
305 while (count--) {
306 if (zeros) {
307 zeros--;
308 *ucbuf++ = '\0';
309 } else if (*cbuf == '\0') {
310 *ucbuf++ = *cbuf++;
311 zeros = *cbuf++ - 1;
312 } else
313 *ucbuf++ = *cbuf++;
314 }
315
316 return ((size_t)cbuf - (size_t)cbufp);
317 }
318
319 void
320 eisa_init(eisa_chipset_tag_t ec)
321 {
322 struct ecu_data *ecud;
323 paddr_t cfgaddr;
324 u_int32_t offset;
325 u_int8_t eisaid[EISA_IDSTRINGLEN];
326 u_int8_t *cdata, *data;
327 u_int8_t *cdp, *dp;
328 struct ecu_func *ecuf;
329 int i, func;
330
331 /*
332 * Locate EISA configuration space.
333 */
334 if (hwrpb->rpb_condat_off == 0UL ||
335 (hwrpb->rpb_condat_off >> 63) != 0) {
336 printf(": WARNING: no EISA configuration space");
337 return;
338 }
339
340 if (eisa_config_header_addr) {
341 printf("\n");
342 panic("eisa_init: EISA config space already initialized");
343 }
344
345 eisa_config_header_addr = hwrpb->rpb_condat_off;
346 if (eisa_config_stride == 0)
347 eisa_config_stride = 1;
348
349 #ifdef EISA_DEBUG
350 printf("\nEISA config header at 0x%lx\n", eisa_config_header_addr);
351 printf("EISA config at 0x%lx\n", eisa_config_addr);
352 printf("EISA config stride: %ld\n", eisa_config_stride);
353 #endif
354
355 /*
356 * Read the slot headers, and allocate config structures for
357 * valid slots.
358 */
359 for (cfgaddr = eisa_config_header_addr, i = 0;
360 i < eisa_maxslots(ec); i++) {
361 eisa_read_config_bytes(cfgaddr, eisaid, sizeof(eisaid));
362 eisaid[EISA_IDSTRINGLEN - 1] = '\0'; /* sanity */
363 cfgaddr += sizeof(eisaid) * eisa_config_stride;
364 eisa_read_config_word(cfgaddr, &offset);
365 cfgaddr += sizeof(offset) * eisa_config_stride;
366
367 if (offset != 0 && offset != 0xffffffff) {
368 #ifdef EISA_DEBUG
369 printf("SLOT %d: offset 0x%08x eisaid %s\n",
370 i, offset, eisaid);
371 #endif
372 ecud = malloc(sizeof(*ecud), M_DEVBUF, M_ZERO|M_WAITOK);
373 if (ecud == NULL)
374 panic("%s: can't allocate memory for ecud",
375 __func__);
376
377 SIMPLEQ_INIT(&ecud->ecud_funcs);
378
379 ecud->ecud_slot = i;
380 memcpy(ecud->ecud_eisaid, eisaid, sizeof(eisaid));
381 ecud->ecud_offset = offset;
382 SIMPLEQ_INSERT_TAIL(&ecu_data_list, ecud, ecud_list);
383 }
384 }
385
386 /*
387 * Now traverse the valid slots and read the info.
388 */
389
390 cdata = malloc(CBUFSIZE, M_TEMP, M_ZERO|M_WAITOK);
391 if (cdata == NULL)
392 panic("%s: can't allocate memory for cdata", __func__);
393 data = malloc(CBUFSIZE, M_TEMP, M_ZERO|M_WAITOK);
394 if (data == NULL)
395 panic("%s: can't allocate memory for data", __func__);
396
397 SIMPLEQ_FOREACH(ecud, &ecu_data_list, ecud_list) {
398 cfgaddr = eisa_config_addr + ecud->ecud_offset;
399 #ifdef EISA_DEBUG
400 printf("Checking SLOT %d\n", ecud->ecud_slot);
401 printf("Reading config bytes at 0x%lx to cdata[0]\n", cfgaddr);
402 #endif
403 eisa_read_config_bytes(cfgaddr, &cdata[0], 1);
404 cfgaddr += eisa_config_stride;
405
406 for (i = 1; i < CBUFSIZE; cfgaddr += eisa_config_stride, i++) {
407 #ifdef EISA_DEBUG
408 printf("Reading config bytes at 0x%lx to cdata[%d]\n",
409 cfgaddr, i);
410 #endif
411 eisa_read_config_bytes(cfgaddr, &cdata[i], 1);
412 if (cdata[i - 1] == 0 && cdata[i] == 0)
413 break;
414 }
415 if (i == CBUFSIZE) {
416 /* assume this compressed data invalid */
417 #ifdef EISA_DEBUG
418 printf("SLOT %d has invalid config\n", ecud->ecud_slot);
419 #endif
420 continue;
421 }
422
423 i++; /* index -> length */
424
425 #ifdef EISA_DEBUG
426 printf("SLOT %d compressed data length %d:",
427 ecud->ecud_slot, i);
428 {
429 int j;
430
431 for (j = 0; j < i; j++) {
432 if ((j % 16) == 0)
433 printf("\n");
434 printf("0x%02x ", cdata[j]);
435 }
436 printf("\n");
437 }
438 #endif
439
440 cdp = cdata;
441 dp = data;
442
443 /* Uncompress the slot header. */
444 cdp += eisa_uncompress(cdp, dp, EISA_SLOT_HEADER_SIZE);
445 #ifdef EISA_DEBUG
446 printf("SLOT %d uncompressed header data:",
447 ecud->ecud_slot);
448 {
449 int j;
450
451 for (j = 0; j < EISA_SLOT_HEADER_SIZE; j++) {
452 if ((j % 16) == 0)
453 printf("\n");
454 printf("0x%02x ", dp[j]);
455 }
456 printf("\n");
457 }
458 #endif
459
460 dp = &data[EISA_SLOT_INFO_OFFSET];
461 ecud->ecud_slot_info = *dp++;
462 ecud->ecud_ecu_major_rev = *dp++;
463 ecud->ecud_ecu_minor_rev = *dp++;
464 memcpy(&ecud->ecud_cksum, dp, sizeof(ecud->ecud_cksum));
465 dp += sizeof(ecud->ecud_cksum);
466 ecud->ecud_ndevfuncs = *dp++;
467 ecud->ecud_funcinfo = *dp++;
468 memcpy(&ecud->ecud_comp_id, dp, sizeof(ecud->ecud_comp_id));
469 dp += sizeof(ecud->ecud_comp_id);
470
471 #ifdef EISA_DEBUG
472 printf("SLOT %d: ndevfuncs %d\n", ecud->ecud_slot,
473 ecud->ecud_ndevfuncs);
474 #endif
475
476 for (func = 0; func < ecud->ecud_ndevfuncs; func++) {
477 dp = data;
478 cdp += eisa_uncompress(cdp, dp, EISA_CONFIG_BLOCK_SIZE);
479 #ifdef EISA_DEBUG
480 printf("SLOT %d:%d uncompressed data:",
481 ecud->ecud_slot, func);
482 {
483 int j;
484
485 for (j = 0; i < EISA_CONFIG_BLOCK_SIZE; j++) {
486 if ((j % 16) == 0)
487 printf("\n");
488 printf("0x%02x ", dp[j]);
489 }
490 printf("\n");
491 }
492 #endif
493
494 /* Skip disabled functions. */
495 if (dp[EISA_FUNC_INFO_OFFSET] & ECUF_DISABLED) {
496 #ifdef EISA_DEBUG
497 printf("SLOT %d:%d disabled\n",
498 ecud->ecud_slot, func);
499 #endif
500 continue;
501 }
502
503 ecuf = malloc(sizeof(*ecuf), M_DEVBUF, M_WAITOK);
504 if (ecuf == NULL)
505 panic("%s: can't allocate memory for ecuf",
506 __func__);
507 ecuf_init(ecuf);
508 ecuf->ecuf_funcno = func;
509 SIMPLEQ_INSERT_TAIL(&ecud->ecud_funcs, ecuf,
510 ecuf_list);
511
512 memcpy(&ecuf->ecuf_id, dp, sizeof(ecuf->ecuf_id));
513 dp += sizeof(ecuf->ecuf_id);
514
515 memcpy(&ecuf->ecuf_slot_info, dp,
516 sizeof(ecuf->ecuf_slot_info));
517 dp += sizeof(ecuf->ecuf_slot_info);
518
519 memcpy(&ecuf->ecuf_cfg_ext, dp,
520 sizeof(ecuf->ecuf_cfg_ext));
521 dp += sizeof(ecuf->ecuf_cfg_ext);
522
523 memcpy(&ecuf->ecuf_selections, dp,
524 sizeof(ecuf->ecuf_selections));
525 dp += sizeof(ecuf->ecuf_selections);
526
527 memcpy(&ecuf->ecuf_func_info, dp,
528 sizeof(ecuf->ecuf_func_info));
529 dp += sizeof(ecuf->ecuf_func_info);
530
531 if (ecuf->ecuf_func_info & ECUF_TYPE_STRING)
532 memcpy(ecuf->ecuf_type_string, dp,
533 sizeof(ecuf->ecuf_type_string));
534 dp += sizeof(ecuf->ecuf_type_string);
535
536 if (ecuf->ecuf_func_info & ECUF_MEM_ENTRY)
537 eisa_parse_mem(ecuf, dp);
538 dp += ECUF_MEM_ENTRY_SIZE * ECUF_MEM_ENTRY_CNT;
539
540 if (ecuf->ecuf_func_info & ECUF_IRQ_ENTRY)
541 eisa_parse_irq(ecuf, dp);
542 dp += ECUF_IRQ_ENTRY_SIZE * ECUF_IRQ_ENTRY_CNT;
543
544 if (ecuf->ecuf_func_info & ECUF_DMA_ENTRY)
545 eisa_parse_dma(ecuf, dp);
546 dp += ECUF_DMA_ENTRY_SIZE * ECUF_DMA_ENTRY_CNT;
547
548 if (ecuf->ecuf_func_info & ECUF_IO_ENTRY)
549 eisa_parse_io(ecuf, dp);
550 dp += ECUF_IO_ENTRY_SIZE * ECUF_IO_ENTRY_CNT;
551
552 if (ecuf->ecuf_func_info & ECUF_INIT_ENTRY)
553 memcpy(ecuf->ecuf_init, dp,
554 sizeof(ecuf->ecuf_init));
555 dp += sizeof(ecuf->ecuf_init);
556 }
557 }
558
559 free(cdata, M_TEMP);
560 free(data, M_TEMP);
561 }
562
563 static struct ecu_data *
564 eisa_lookup_data(int slot)
565 {
566 struct ecu_data *ecud;
567
568 SIMPLEQ_FOREACH(ecud, &ecu_data_list, ecud_list) {
569 if (ecud->ecud_slot == slot)
570 return (ecud);
571 }
572 return (NULL);
573 }
574
575 static struct ecu_func *
576 eisa_lookup_func(int slot, int func)
577 {
578 struct ecu_data *ecud;
579 struct ecu_func *ecuf;
580
581 ecud = eisa_lookup_data(slot);
582 if (ecud == NULL)
583 return (NULL);
584
585 SIMPLEQ_FOREACH(ecuf, &ecud->ecud_funcs, ecuf_list) {
586 if (ecuf->ecuf_funcno == func)
587 return (ecuf);
588 }
589 return (NULL);
590 }
591
592 int
593 eisa_conf_read_mem(eisa_chipset_tag_t ec, int slot, int func, int entry,
594 struct eisa_cfg_mem *dp)
595 {
596 struct ecu_func *ecuf;
597 struct ecu_mem *ecum;
598
599 ecuf = eisa_lookup_func(slot, func);
600 if (ecuf == NULL)
601 return (ENOENT);
602
603 SIMPLEQ_FOREACH(ecum, &ecuf->ecuf_mem, ecum_list) {
604 if (entry-- == 0)
605 break;
606 }
607 if (ecum == NULL)
608 return (ENOENT);
609
610 *dp = ecum->ecum_mem;
611 return (0);
612 }
613
614 int
615 eisa_conf_read_irq(eisa_chipset_tag_t ec, int slot, int func, int entry,
616 struct eisa_cfg_irq *dp)
617 {
618 struct ecu_func *ecuf;
619 struct ecu_irq *ecui;
620
621 ecuf = eisa_lookup_func(slot, func);
622 if (ecuf == NULL)
623 return (ENOENT);
624
625 SIMPLEQ_FOREACH(ecui, &ecuf->ecuf_irq, ecui_list) {
626 if (entry-- == 0)
627 break;
628 }
629 if (ecui == NULL)
630 return (ENOENT);
631
632 *dp = ecui->ecui_irq;
633 return (0);
634 }
635
636 int
637 eisa_conf_read_dma(eisa_chipset_tag_t ec, int slot, int func, int entry,
638 struct eisa_cfg_dma *dp)
639 {
640 struct ecu_func *ecuf;
641 struct ecu_dma *ecud;
642
643 ecuf = eisa_lookup_func(slot, func);
644 if (ecuf == NULL)
645 return (ENOENT);
646
647 SIMPLEQ_FOREACH(ecud, &ecuf->ecuf_dma, ecud_list) {
648 if (entry-- == 0)
649 break;
650 }
651 if (ecud == NULL)
652 return (ENOENT);
653
654 *dp = ecud->ecud_dma;
655 return (0);
656 }
657
658 int
659 eisa_conf_read_io(eisa_chipset_tag_t ec, int slot, int func, int entry,
660 struct eisa_cfg_io *dp)
661 {
662 struct ecu_func *ecuf;
663 struct ecu_io *ecuio;
664
665 ecuf = eisa_lookup_func(slot, func);
666 if (ecuf == NULL)
667 return (ENOENT);
668
669 SIMPLEQ_FOREACH(ecuio, &ecuf->ecuf_io, ecuio_list) {
670 if (entry-- == 0)
671 break;
672 }
673 if (ecuio == NULL)
674 return (ENOENT);
675
676 *dp = ecuio->ecuio_io;
677 return (0);
678 }
NetBSD on the FriendlyARM MINI2440