URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [gsc/] [eisa_enumerator.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * eisa_enumerator.c - provide support for EISA adapters in PA-RISC machines
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * Copyright (c) 2002 Daniel Engstrom <5116@telia.com>
 *
 */
 
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <asm/gsc.h>
#include <asm/uaccess.h>
#include <asm/byteorder.h>
 
#include <asm/eisa_bus.h>
#include <asm/eisa_eeprom.h>
 
 
/*
 * Todo:
 *
 * PORT init with MASK attr and other size than byte
 * MEMORY with other decode than 20 bit
 * CRC stuff
 * FREEFORM stuff
 */
 
#define EPI 0xc80
#define NUM_SLOT 16
#define SLOT2PORT(x) (x<<12)
 
 
/* macros to handle unaligned accesses and
 * byte swapping. The data in the EEPROM is
 * little-endian on the big-endian PAROSC */
#define get_8(x) (*(u_int8_t*)(x))
 
static inline u_int16_t get_16(const unsigned char *x)
{
        return (x[1] << 8) | x[0];
}
 
static inline u_int32_t get_32(const unsigned char *x)
{
        return (x[3] << 24) | (x[2] << 16) | (x[1] << 8) | x[0];
}
 
static inline u_int32_t get_24(const unsigned char *x)
{
        return (x[2] << 24) | (x[1] << 16) | (x[0] << 8);
}
 
static void print_eisa_id(char *s, u_int32_t id)
{
        char vendor[4];
        int rev;
        int device;
 
        rev = id & 0xff;
        id >>= 8;
        device = id & 0xff;
        id >>= 8;
        vendor[3] = '\0';
        vendor[2] = '@' + (id & 0x1f);
        id >>= 5;
        vendor[1] = '@' + (id & 0x1f);
        id >>= 5;
        vendor[0] = '@' + (id & 0x1f);
        id >>= 5;
 
        sprintf(s, "%s%02X%02X", vendor, device, rev);
}
 
static int configure_memory(const unsigned char *buf,
                       struct resource *mem_parent,
                       char *name)
{
        int len;
        u_int8_t c;
        int i;
        struct resource *res;
 
        len=0;
 
        for (i=0;i<HPEE_MEMORY_MAX_ENT;i++) {
                c = get_8(buf+len);
 
                if (NULL != (res = kmalloc(sizeof(struct resource), GFP_KERNEL))) {
                        int result;
 
                        res->name = name;
                        res->start = mem_parent->start + get_24(buf+len+2);
                        res->end = res->start + get_16(buf+len+5)*1024;
                        res->flags = IORESOURCE_MEM;
                        printk("memory %lx-%lx ", res->start, res->end);
                        result = request_resource(mem_parent, res);
                        if (result < 0) {
                                printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
                                return result;
                        }
                }
 
                len+=7;
 
                if (!(c & HPEE_MEMORY_MORE)) {
                        break;
                }
        }
 
        return len;
}
 
 
static int configure_irq(const unsigned char *buf)
{
        int len;
        u_int8_t c;
        int i;
 
        len=0;
 
        for (i=0;i<HPEE_IRQ_MAX_ENT;i++) {
                c = get_8(buf+len);
 
                printk("IRQ %d ", c & HPEE_IRQ_CHANNEL_MASK);
                if (c & HPEE_IRQ_TRIG_LEVEL) {
                        eisa_make_irq_level(c & HPEE_IRQ_CHANNEL_MASK);
                } else {
                        eisa_make_irq_edge(c & HPEE_IRQ_CHANNEL_MASK);
                }
 
                len+=2;
                /* hpux seems to allow for
                 * two bytes of irq data but only defines one of
                 * them, I think */
                if  (!(c & HPEE_IRQ_MORE)) {
                        break;
                }
        }
 
        return len;
}
 
 
static int configure_dma(const unsigned char *buf)
{
        int len;
        u_int8_t c;
        int i;
 
        len=0;
 
        for (i=0;i<HPEE_DMA_MAX_ENT;i++) {
                c = get_8(buf+len);
                printk("DMA %d ", c&HPEE_DMA_CHANNEL_MASK);
                /* fixme: maybe initialize the dma channel withthe timing ? */
                len+=2;
                if (!(c & HPEE_DMA_MORE)) {
                        break;
                }
        }
 
        return len;
}
 
static int configure_port(const unsigned char *buf, struct resource *io_parent,
                     char *board)
{
        int len;
        u_int8_t c;
        int i;
        struct resource *res;
        int result;
 
        len=0;
 
        for (i=0;i<HPEE_PORT_MAX_ENT;i++) {
                c = get_8(buf+len);
 
                if (NULL != (res = kmalloc(sizeof(struct resource), GFP_KERNEL))) {
                        res->name = board;
                        res->start = get_16(buf+len+1);
                        res->end = get_16(buf+len+1)+(c&HPEE_PORT_SIZE_MASK)+1;
                        res->flags = IORESOURCE_IO;
                        printk("ioports %lx-%lx ", res->start, res->end);
                        result = request_resource(io_parent, res);
                        if (result < 0) {
                                printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");
                                return result;
                        }
                }
 
                len+=3;
                if (!(c & HPEE_PORT_MORE)) {
                        break;
                }
        }
 
        return len;
}
 
 
/* byte 1 and 2 is the port number to write
 * and at byte 3 the value to write starts.
 * I assume that there are and- and or- masks
 * here when HPEE_PORT_INIT_MASK is set but I have
 * not yet encountered this. */
static int configure_port_init(const unsigned char *buf)
{
        int len=0;
        u_int8_t c;
 
        while (len<HPEE_PORT_INIT_MAX_LEN) {
                int s=0;
                c = get_8(buf+len);
 
                switch (c & HPEE_PORT_INIT_WIDTH_MASK)  {
                 case HPEE_PORT_INIT_WIDTH_BYTE:
                        s=1;
                        if (c & HPEE_PORT_INIT_MASK) {
                                printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");
                                outb((inb(get_16(buf+len+1) &
                                          get_8(buf+len+3)) |
                                      get_8(buf+len+4)), get_16(buf+len+1));
 
                        } else {
                                outb(get_8(buf+len+3), get_16(buf+len+1));
 
                        }
                        break;
                 case HPEE_PORT_INIT_WIDTH_WORD:
                        s=2;
                        if (c & HPEE_PORT_INIT_MASK) {
                                printk(KERN_WARNING "port_init: unverified mask attribute\n");
                                       outw((inw(get_16(buf+len+1)) &
                                             get_16(buf+len+3)) |
                                            get_16(buf+len+5),
                                            get_16(buf+len+1));
                        } else {
                                outw(cpu_to_le16(get_16(buf+len+3)), get_16(buf+len+1));
                        }
                        break;
                 case HPEE_PORT_INIT_WIDTH_DWORD:
                        s=4;
                        if (c & HPEE_PORT_INIT_MASK) {
                                printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");
                                outl((inl(get_16(buf+len+1) &
                                          get_32(buf+len+3)) |
                                      get_32(buf+len+7)), get_16(buf+len+1));
                        } else {
                                outl(cpu_to_le32(get_32(buf+len+3)), get_16(buf+len+1));
                        }
 
                        break;
                 default:
                        printk("\n" KERN_ERR "Invalid port init word %02x\n", c);
                        return 0;
                }
 
                if (c & HPEE_PORT_INIT_MASK) {
                        s*=2;
                }
 
                len+=s+3;
                if (!(c & HPEE_PORT_INIT_MORE)) {
                        break;
                }
        }
 
        return len;
}
 
static int configure_choise(const unsigned char *buf, u_int8_t *info)
{
        int len;
 
        /* theis record contain the value of the functions
         * configuration choises and an info byte which
         * describes which other records to expect in this
         * function */
        len = get_8(buf);
        *info=get_8(buf+len+1);
 
        return len+2;
}
 
static int configure_type_string(const unsigned char *buf)
{
        int len;
 
        /* just skip past the type field */
        len = get_8(buf);
        if (len > 80) {
                printk("\n" KERN_ERR "eisa_enumerator: type info field too long (%d, max is 80)\n", len);
        }
 
        return 1+len;
}
 
static int configure_function(const unsigned char *buf, int *more)
{
        /* the init field seems to be a two-byte field
         * which is non-zero if there are an other function following
         * I think it is the length of the function def
         */
        *more = get_16(buf);
 
        return 2;
}
 
static int parse_slot_config(int slot,
                             const unsigned char *buf,
                             struct eeprom_eisa_slot_info *es,
                             struct resource *io_parent,
                             struct resource *mem_parent)
{
        int res=0;
        int function_len;
        unsigned int pos=0;
        unsigned int maxlen;
        int num_func=0;
        u_int8_t flags;
        int p0;
 
        char *board;
        int id_string_used=0;
 
        if (NULL == (board = kmalloc(8, GFP_KERNEL))) {
                return -1;
        }
        print_eisa_id(board, es->eisa_slot_id);
        printk(KERN_INFO "EISA slot %d: %s %s ",
               slot, board, es->flags&HPEE_FLAG_BOARD_IS_ISA ? "ISA" : "EISA");
 
        maxlen = es->config_data_length < HPEE_MAX_LENGTH ?
                         es->config_data_length : HPEE_MAX_LENGTH;
        while ((pos < maxlen) && (num_func <= es->num_functions)) {
                pos+=configure_function(buf+pos, &function_len);
 
                if (!function_len) {
                        break;
                }
                num_func++;
                p0 = pos;
                pos += configure_choise(buf+pos, &flags);
 
                if (flags & HPEE_FUNCTION_INFO_F_DISABLED) {
                        /* function disabled, skip silently */
                        pos = p0 + function_len;
                        continue;
                }
                if (flags & HPEE_FUNCTION_INFO_CFG_FREE_FORM) {
                        /* I have no idea how to handle this */
                        printk("function %d have free-form confgiuration, skipping ",
                                num_func);
                        pos = p0 + function_len;
                        continue;
                }
 
                /* the ordering of the sections need
                 * more investigation.
                 * Currently I think that memory comaed before IRQ
                 * I assume the order is LSB to MSB in the
                 * info flags
                 * eg type, memory, irq, dma, port, HPEE_PORT_init
                 */
 
                if (flags & HPEE_FUNCTION_INFO_HAVE_TYPE) {
                        pos += configure_type_string(buf+pos);
                }
 
                if (flags & HPEE_FUNCTION_INFO_HAVE_MEMORY) {
                        id_string_used=1;
                        pos += configure_memory(buf+pos, mem_parent, board);
                }
 
                if (flags & HPEE_FUNCTION_INFO_HAVE_IRQ) {
                        pos += configure_irq(buf+pos);
                }
 
                if (flags & HPEE_FUNCTION_INFO_HAVE_DMA) {
                        pos += configure_dma(buf+pos);
                }
 
                if (flags & HPEE_FUNCTION_INFO_HAVE_PORT) {
                        id_string_used=1;
                        pos += configure_port(buf+pos, io_parent, board);
                }
 
                if (flags &  HPEE_FUNCTION_INFO_HAVE_PORT_INIT) {
                        pos += configure_port_init(buf+pos);
                }
 
                if (p0 + function_len < pos) {
                        printk("\n" KERN_ERR "eisa_enumerator: function %d length mis-match "
                               "got %d, expected %d\n",
                               num_func, pos-p0, function_len);
                        res=-1;
                        break;
                }
                pos = p0 + function_len;
        }
        printk("\n");
        if (!id_string_used) {
                kfree(board);
        }
 
        if (pos != es->config_data_length) {
                printk(KERN_ERR "eisa_enumerator: config data length mis-match got %d, expected %d\n",
                        pos, es->config_data_length);
                res=-1;
        }
 
        if (num_func != es->num_functions) {
                printk(KERN_ERR "eisa_enumerator: number of functions mis-match got %d, expected %d\n",
                        num_func, es->num_functions);
                res=-2;
        }
 
        return res;
 
}
 
static int init_slot(int slot, struct eeprom_eisa_slot_info *es)
{
        unsigned int id;
 
        char id_string[8];
 
        if (!(es->slot_info&HPEE_SLOT_INFO_NO_READID)) {
                /* try to read the id of the board in the slot */
                id = le32_to_cpu(inl(SLOT2PORT(slot)+EPI));
 
                if (0xffffffff == id) {
                        /* this board is not here or it does not
                         * support readid
                         */
                        printk(KERN_ERR "EISA slot %d a configured board was not detected (",
                               slot);
 
                        print_eisa_id(id_string, es->eisa_slot_id);
                        printk(" expected %s)\n", id_string);
 
                        return -1;
 
                }
                if (es->eisa_slot_id != id) {
                        print_eisa_id(id_string, id);
                        printk(KERN_ERR "EISA slot %d id mis-match: got %s",
                               slot, id_string);
 
                        print_eisa_id(id_string, es->eisa_slot_id);
                        printk(" expected %s \n", id_string);
 
                        return -1;
 
                }
        }
 
        /* now: we need to enable the board if
         * it supports enabling and run through
         * the port init sction if present
         * and finally record any interrupt polarity
         */
        if (es->slot_features & HPEE_SLOT_FEATURES_ENABLE) {
                /* enable board */
                outb(0x01| inb(SLOT2PORT(slot)+EPI+4),
                     SLOT2PORT(slot)+EPI+4);
        }
 
        return 0;
}
 
 
int eisa_enumerator(unsigned long eeprom_addr,
                    struct resource *io_parent, struct resource *mem_parent)
{
        int i;
        struct eeprom_header *eh;
        static char eeprom_buf[HPEE_MAX_LENGTH];
 
        for (i=0; i < HPEE_MAX_LENGTH; i++) {
                eeprom_buf[i] = gsc_readb(eeprom_addr+i);
        }
 
        printk(KERN_INFO "Enumerating EISA bus\n");
 
        eh = (struct eeprom_header*)(eeprom_buf);
        for (i=0;i<eh->num_slots;i++) {
                struct eeprom_eisa_slot_info *es;
 
                es = (struct eeprom_eisa_slot_info*)
                        (&eeprom_buf[HPEE_SLOT_INFO(i)]);
 
                if (-1==init_slot(i+1, es)) {
                        return -1;
 
                }
 
                if (es->config_data_offset < HPEE_MAX_LENGTH) {
                        if (parse_slot_config(i+1, &eeprom_buf[es->config_data_offset],
                                              es, io_parent, mem_parent)) {
                                return -1;
                        }
                } else {
                        printk (KERN_WARNING "EISA EEPROM offset 0x%x out of range\n",es->config_data_offset);
                        return -1;
                }
        }
        return 0;
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [gsc/] [eisa_enumerator.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* eisa_enumerator.c - provide support for EISA adapters in PA-RISC machines`
3			`*`
4			`* This program is free software; you can redistribute it and/or`
5			`* modify it under the terms of the GNU General Public License`
6			`* as published by the Free Software Foundation; either version`
7			`* 2 of the License, or (at your option) any later version.`
8			`*`
9			`* Copyright (c) 2002 Daniel Engstrom <5116@telia.com>`
10			`*`
11			`*/`
12
13			`#include <linux/ioport.h>`
14			`#include <linux/init.h>`
15			`#include <linux/kernel.h>`
16			`#include <linux/slab.h>`
17			`#include <asm/gsc.h>`
18			`#include <asm/uaccess.h>`
19			`#include <asm/byteorder.h>`
20
21			`#include <asm/eisa_bus.h>`
22			`#include <asm/eisa_eeprom.h>`
23
24
25			`/*`
26			`* Todo:`
27			`*`
28			`* PORT init with MASK attr and other size than byte`
29			`* MEMORY with other decode than 20 bit`
30			`* CRC stuff`
31			`* FREEFORM stuff`
32			`*/`
33
34			`#define EPI 0xc80`
35			`#define NUM_SLOT 16`
36			`#define SLOT2PORT(x) (x<<12)`
37
38
39			`/* macros to handle unaligned accesses and`
40			`* byte swapping. The data in the EEPROM is`
41			`* little-endian on the big-endian PAROSC */`
42			`#define get_8(x) ((u_int8_t)(x))`
43
44			`static inline u_int16_t get_16(const unsigned char *x)`
45			`{`
46			`return (x[1] << 8) \| x[0];`
47			`}`
48
49			`static inline u_int32_t get_32(const unsigned char *x)`
50			`{`
51			`return (x[3] << 24) \| (x[2] << 16) \| (x[1] << 8) \| x[0];`
52			`}`
53
54			`static inline u_int32_t get_24(const unsigned char *x)`
55			`{`
56			`return (x[2] << 24) \| (x[1] << 16) \| (x[0] << 8);`
57			`}`
58
59			`static void print_eisa_id(char *s, u_int32_t id)`
60			`{`
61			`char vendor[4];`
62			`int rev;`
63			`int device;`
64
65			`rev = id & 0xff;`
66			`id >>= 8;`
67			`device = id & 0xff;`
68			`id >>= 8;`
69			`vendor[3] = '\0';`
70			`vendor[2] = '@' + (id & 0x1f);`
71			`id >>= 5;`
72			`vendor[1] = '@' + (id & 0x1f);`
73			`id >>= 5;`
74			`vendor[0] = '@' + (id & 0x1f);`
75			`id >>= 5;`
76
77			`sprintf(s, "%s%02X%02X", vendor, device, rev);`
78			`}`
79
80			`static int configure_memory(const unsigned char *buf,`
81			`struct resource *mem_parent,`
82			`char *name)`
83			`{`
84			`int len;`
85			`u_int8_t c;`
86			`int i;`
87			`struct resource *res;`
88
89			`len=0;`
90
91			`for (i=0;i<HPEE_MEMORY_MAX_ENT;i++) {`
92			`c = get_8(buf+len);`
93
94			`if (NULL != (res = kmalloc(sizeof(struct resource), GFP_KERNEL))) {`
95			`int result;`
96
97			`res->name = name;`
98			`res->start = mem_parent->start + get_24(buf+len+2);`
99			`res->end = res->start + get_16(buf+len+5)*1024;`
100			`res->flags = IORESOURCE_MEM;`
101			`printk("memory %lx-%lx ", res->start, res->end);`
102			`result = request_resource(mem_parent, res);`
103			`if (result < 0) {`
104			`printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");`
105			`return result;`
106			`}`
107			`}`
108
109			`len+=7;`
110
111			`if (!(c & HPEE_MEMORY_MORE)) {`
112			`break;`
113			`}`
114			`}`
115
116			`return len;`
117			`}`
118
119
120			`static int configure_irq(const unsigned char *buf)`
121			`{`
122			`int len;`
123			`u_int8_t c;`
124			`int i;`
125
126			`len=0;`
127
128			`for (i=0;i<HPEE_IRQ_MAX_ENT;i++) {`
129			`c = get_8(buf+len);`
130
131			`printk("IRQ %d ", c & HPEE_IRQ_CHANNEL_MASK);`
132			`if (c & HPEE_IRQ_TRIG_LEVEL) {`
133			`eisa_make_irq_level(c & HPEE_IRQ_CHANNEL_MASK);`
134			`} else {`
135			`eisa_make_irq_edge(c & HPEE_IRQ_CHANNEL_MASK);`
136			`}`
137
138			`len+=2;`
139			`/* hpux seems to allow for`
140			`* two bytes of irq data but only defines one of`
141			`* them, I think */`
142			`if (!(c & HPEE_IRQ_MORE)) {`
143			`break;`
144			`}`
145			`}`
146
147			`return len;`
148			`}`
149
150
151			`static int configure_dma(const unsigned char *buf)`
152			`{`
153			`int len;`
154			`u_int8_t c;`
155			`int i;`
156
157			`len=0;`
158
159			`for (i=0;i<HPEE_DMA_MAX_ENT;i++) {`
160			`c = get_8(buf+len);`
161			`printk("DMA %d ", c&HPEE_DMA_CHANNEL_MASK);`
162			`/* fixme: maybe initialize the dma channel withthe timing ? */`
163			`len+=2;`
164			`if (!(c & HPEE_DMA_MORE)) {`
165			`break;`
166			`}`
167			`}`
168
169			`return len;`
170			`}`
171
172			`static int configure_port(const unsigned char buf, struct resource io_parent,`
173			`char *board)`
174			`{`
175			`int len;`
176			`u_int8_t c;`
177			`int i;`
178			`struct resource *res;`
179			`int result;`
180
181			`len=0;`
182
183			`for (i=0;i<HPEE_PORT_MAX_ENT;i++) {`
184			`c = get_8(buf+len);`
185
186			`if (NULL != (res = kmalloc(sizeof(struct resource), GFP_KERNEL))) {`
187			`res->name = board;`
188			`res->start = get_16(buf+len+1);`
189			`res->end = get_16(buf+len+1)+(c&HPEE_PORT_SIZE_MASK)+1;`
190			`res->flags = IORESOURCE_IO;`
191			`printk("ioports %lx-%lx ", res->start, res->end);`
192			`result = request_resource(io_parent, res);`
193			`if (result < 0) {`
194			`printk("\n" KERN_ERR "EISA Enumerator: failed to claim EISA Bus address space!\n");`
195			`return result;`
196			`}`
197			`}`
198
199			`len+=3;`
200			`if (!(c & HPEE_PORT_MORE)) {`
201			`break;`
202			`}`
203			`}`
204
205			`return len;`
206			`}`
207
208
209			`/* byte 1 and 2 is the port number to write`
210			`* and at byte 3 the value to write starts.`
211			`* I assume that there are and- and or- masks`
212			`* here when HPEE_PORT_INIT_MASK is set but I have`
213			`* not yet encountered this. */`
214			`static int configure_port_init(const unsigned char *buf)`
215			`{`
216			`int len=0;`
217			`u_int8_t c;`
218
219			`while (len<HPEE_PORT_INIT_MAX_LEN) {`
220			`int s=0;`
221			`c = get_8(buf+len);`
222
223			`switch (c & HPEE_PORT_INIT_WIDTH_MASK) {`
224			`case HPEE_PORT_INIT_WIDTH_BYTE:`
225			`s=1;`
226			`if (c & HPEE_PORT_INIT_MASK) {`
227			`printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");`
228			`outb((inb(get_16(buf+len+1) &`
229			`get_8(buf+len+3)) \|`
230			`get_8(buf+len+4)), get_16(buf+len+1));`
231
232			`} else {`
233			`outb(get_8(buf+len+3), get_16(buf+len+1));`
234
235			`}`
236			`break;`
237			`case HPEE_PORT_INIT_WIDTH_WORD:`
238			`s=2;`
239			`if (c & HPEE_PORT_INIT_MASK) {`
240			`printk(KERN_WARNING "port_init: unverified mask attribute\n");`
241			`outw((inw(get_16(buf+len+1)) &`
242			`get_16(buf+len+3)) \|`
243			`get_16(buf+len+5),`
244			`get_16(buf+len+1));`
245			`} else {`
246			`outw(cpu_to_le16(get_16(buf+len+3)), get_16(buf+len+1));`
247			`}`
248			`break;`
249			`case HPEE_PORT_INIT_WIDTH_DWORD:`
250			`s=4;`
251			`if (c & HPEE_PORT_INIT_MASK) {`
252			`printk("\n" KERN_WARNING "port_init: unverified mask attribute\n");`
253			`outl((inl(get_16(buf+len+1) &`
254			`get_32(buf+len+3)) \|`
255			`get_32(buf+len+7)), get_16(buf+len+1));`
256			`} else {`
257			`outl(cpu_to_le32(get_32(buf+len+3)), get_16(buf+len+1));`
258			`}`
259
260			`break;`
261			`default:`
262			`printk("\n" KERN_ERR "Invalid port init word %02x\n", c);`
263			`return 0;`
264			`}`
265
266			`if (c & HPEE_PORT_INIT_MASK) {`
267			`s*=2;`
268			`}`
269
270			`len+=s+3;`
271			`if (!(c & HPEE_PORT_INIT_MORE)) {`
272			`break;`
273			`}`
274			`}`
275
276			`return len;`
277			`}`
278
279			`static int configure_choise(const unsigned char buf, u_int8_t info)`
280			`{`
281			`int len;`
282
283			`/* theis record contain the value of the functions`
284			`* configuration choises and an info byte which`
285			`* describes which other records to expect in this`
286			`* function */`
287			`len = get_8(buf);`
288			`*info=get_8(buf+len+1);`
289
290			`return len+2;`
291			`}`
292
293			`static int configure_type_string(const unsigned char *buf)`
294			`{`
295			`int len;`
296
297			`/* just skip past the type field */`
298			`len = get_8(buf);`
299			`if (len > 80) {`
300			`printk("\n" KERN_ERR "eisa_enumerator: type info field too long (%d, max is 80)\n", len);`
301			`}`
302
303			`return 1+len;`
304			`}`
305
306			`static int configure_function(const unsigned char buf, int more)`
307			`{`
308			`/* the init field seems to be a two-byte field`
309			`* which is non-zero if there are an other function following`
310			`* I think it is the length of the function def`
311			`*/`
312			`*more = get_16(buf);`
313
314			`return 2;`
315			`}`
316
317			`static int parse_slot_config(int slot,`
318			`const unsigned char *buf,`
319			`struct eeprom_eisa_slot_info *es,`
320			`struct resource *io_parent,`
321			`struct resource *mem_parent)`
322			`{`
323			`int res=0;`
324			`int function_len;`
325			`unsigned int pos=0;`
326			`unsigned int maxlen;`
327			`int num_func=0;`
328			`u_int8_t flags;`
329			`int p0;`
330
331			`char *board;`
332			`int id_string_used=0;`
333
334			`if (NULL == (board = kmalloc(8, GFP_KERNEL))) {`
335			`return -1;`
336			`}`
337			`print_eisa_id(board, es->eisa_slot_id);`
338			`printk(KERN_INFO "EISA slot %d: %s %s ",`
339			`slot, board, es->flags&HPEE_FLAG_BOARD_IS_ISA ? "ISA" : "EISA");`
340
341			`maxlen = es->config_data_length < HPEE_MAX_LENGTH ?`
342			`es->config_data_length : HPEE_MAX_LENGTH;`
343			`while ((pos < maxlen) && (num_func <= es->num_functions)) {`
344			`pos+=configure_function(buf+pos, &function_len);`
345
346			`if (!function_len) {`
347			`break;`
348			`}`
349			`num_func++;`
350			`p0 = pos;`
351			`pos += configure_choise(buf+pos, &flags);`
352
353			`if (flags & HPEE_FUNCTION_INFO_F_DISABLED) {`
354			`/* function disabled, skip silently */`
355			`pos = p0 + function_len;`
356			`continue;`
357			`}`
358			`if (flags & HPEE_FUNCTION_INFO_CFG_FREE_FORM) {`
359			`/* I have no idea how to handle this */`
360			`printk("function %d have free-form confgiuration, skipping ",`
361			`num_func);`
362			`pos = p0 + function_len;`
363			`continue;`
364			`}`
365
366			`/* the ordering of the sections need`
367			`* more investigation.`
368			`* Currently I think that memory comaed before IRQ`
369			`* I assume the order is LSB to MSB in the`
370			`* info flags`
371			`* eg type, memory, irq, dma, port, HPEE_PORT_init`
372			`*/`
373
374			`if (flags & HPEE_FUNCTION_INFO_HAVE_TYPE) {`
375			`pos += configure_type_string(buf+pos);`
376			`}`
377
378			`if (flags & HPEE_FUNCTION_INFO_HAVE_MEMORY) {`
379			`id_string_used=1;`
380			`pos += configure_memory(buf+pos, mem_parent, board);`
381			`}`
382
383			`if (flags & HPEE_FUNCTION_INFO_HAVE_IRQ) {`
384			`pos += configure_irq(buf+pos);`
385			`}`
386
387			`if (flags & HPEE_FUNCTION_INFO_HAVE_DMA) {`
388			`pos += configure_dma(buf+pos);`
389			`}`
390
391			`if (flags & HPEE_FUNCTION_INFO_HAVE_PORT) {`
392			`id_string_used=1;`
393			`pos += configure_port(buf+pos, io_parent, board);`
394			`}`
395
396			`if (flags & HPEE_FUNCTION_INFO_HAVE_PORT_INIT) {`
397			`pos += configure_port_init(buf+pos);`
398			`}`
399
400			`if (p0 + function_len < pos) {`
401			`printk("\n" KERN_ERR "eisa_enumerator: function %d length mis-match "`
402			`"got %d, expected %d\n",`
403			`num_func, pos-p0, function_len);`
404			`res=-1;`
405			`break;`
406			`}`
407			`pos = p0 + function_len;`
408			`}`
409			`printk("\n");`
410			`if (!id_string_used) {`
411			`kfree(board);`
412			`}`
413
414			`if (pos != es->config_data_length) {`
415			`printk(KERN_ERR "eisa_enumerator: config data length mis-match got %d, expected %d\n",`
416			`pos, es->config_data_length);`
417			`res=-1;`
418			`}`
419
420			`if (num_func != es->num_functions) {`
421			`printk(KERN_ERR "eisa_enumerator: number of functions mis-match got %d, expected %d\n",`
422			`num_func, es->num_functions);`
423			`res=-2;`
424			`}`
425
426			`return res;`
427
428			`}`
429
430			`static int init_slot(int slot, struct eeprom_eisa_slot_info *es)`
431			`{`
432			`unsigned int id;`
433
434			`char id_string[8];`
435
436			`if (!(es->slot_info&HPEE_SLOT_INFO_NO_READID)) {`
437			`/* try to read the id of the board in the slot */`
438			`id = le32_to_cpu(inl(SLOT2PORT(slot)+EPI));`
439
440			`if (0xffffffff == id) {`
441			`/* this board is not here or it does not`
442			`* support readid`
443			`*/`
444			`printk(KERN_ERR "EISA slot %d a configured board was not detected (",`
445			`slot);`
446
447			`print_eisa_id(id_string, es->eisa_slot_id);`
448			`printk(" expected %s)\n", id_string);`
449
450			`return -1;`
451
452			`}`
453			`if (es->eisa_slot_id != id) {`
454			`print_eisa_id(id_string, id);`
455			`printk(KERN_ERR "EISA slot %d id mis-match: got %s",`
456			`slot, id_string);`
457
458			`print_eisa_id(id_string, es->eisa_slot_id);`
459			`printk(" expected %s \n", id_string);`
460
461			`return -1;`
462
463			`}`
464			`}`
465
466			`/* now: we need to enable the board if`
467			`* it supports enabling and run through`
468			`* the port init sction if present`
469			`* and finally record any interrupt polarity`
470			`*/`
471			`if (es->slot_features & HPEE_SLOT_FEATURES_ENABLE) {`
472			`/* enable board */`
473			`outb(0x01\| inb(SLOT2PORT(slot)+EPI+4),`
474			`SLOT2PORT(slot)+EPI+4);`
475			`}`
476
477			`return 0;`
478			`}`
479
480
481			`int eisa_enumerator(unsigned long eeprom_addr,`
482			`struct resource io_parent, struct resource mem_parent)`
483			`{`
484			`int i;`
485			`struct eeprom_header *eh;`
486			`static char eeprom_buf[HPEE_MAX_LENGTH];`
487
488			`for (i=0; i < HPEE_MAX_LENGTH; i++) {`
489			`eeprom_buf[i] = gsc_readb(eeprom_addr+i);`
490			`}`
491
492			`printk(KERN_INFO "Enumerating EISA bus\n");`
493
494			`eh = (struct eeprom_header*)(eeprom_buf);`
495			`for (i=0;i<eh->num_slots;i++) {`
496			`struct eeprom_eisa_slot_info *es;`
497
498			`es = (struct eeprom_eisa_slot_info*)`
499			`(&eeprom_buf[HPEE_SLOT_INFO(i)]);`
500
501			`if (-1==init_slot(i+1, es)) {`
502			`return -1;`
503
504			`}`
505
506			`if (es->config_data_offset < HPEE_MAX_LENGTH) {`
507			`if (parse_slot_config(i+1, &eeprom_buf[es->config_data_offset],`
508			`es, io_parent, mem_parent)) {`
509			`return -1;`
510			`}`
511			`} else {`
512			`printk (KERN_WARNING "EISA EEPROM offset 0x%x out of range\n",es->config_data_offset);`
513			`return -1;`
514			`}`
515			`}`
516			`return 0;`
517			`}`
518