diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/parisc/eisa_enumerator.c |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/parisc/eisa_enumerator.c')
-rw-r--r-- | drivers/parisc/eisa_enumerator.c | 521 |
1 files changed, 521 insertions, 0 deletions
diff --git a/drivers/parisc/eisa_enumerator.c b/drivers/parisc/eisa_enumerator.c new file mode 100644 index 000000000000..6d8aae003f6c --- /dev/null +++ b/drivers/parisc/eisa_enumerator.c | |||
@@ -0,0 +1,521 @@ | |||
1 | /* | ||
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/io.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 | /* Maybe we didn't expect a card to be here... */ | ||
442 | if (es->eisa_slot_id == 0xffffffff) | ||
443 | return -1; | ||
444 | |||
445 | /* this board is not here or it does not | ||
446 | * support readid | ||
447 | */ | ||
448 | printk(KERN_ERR "EISA slot %d a configured board was not detected (", | ||
449 | slot); | ||
450 | |||
451 | print_eisa_id(id_string, es->eisa_slot_id); | ||
452 | printk(" expected %s)\n", id_string); | ||
453 | |||
454 | return -1; | ||
455 | |||
456 | } | ||
457 | if (es->eisa_slot_id != id) { | ||
458 | print_eisa_id(id_string, id); | ||
459 | printk(KERN_ERR "EISA slot %d id mis-match: got %s", | ||
460 | slot, id_string); | ||
461 | |||
462 | print_eisa_id(id_string, es->eisa_slot_id); | ||
463 | printk(" expected %s \n", id_string); | ||
464 | |||
465 | return -1; | ||
466 | |||
467 | } | ||
468 | } | ||
469 | |||
470 | /* now: we need to enable the board if | ||
471 | * it supports enabling and run through | ||
472 | * the port init sction if present | ||
473 | * and finally record any interrupt polarity | ||
474 | */ | ||
475 | if (es->slot_features & HPEE_SLOT_FEATURES_ENABLE) { | ||
476 | /* enable board */ | ||
477 | outb(0x01| inb(SLOT2PORT(slot)+EPI+4), | ||
478 | SLOT2PORT(slot)+EPI+4); | ||
479 | } | ||
480 | |||
481 | return 0; | ||
482 | } | ||
483 | |||
484 | |||
485 | int eisa_enumerator(unsigned long eeprom_addr, | ||
486 | struct resource *io_parent, struct resource *mem_parent) | ||
487 | { | ||
488 | int i; | ||
489 | struct eeprom_header *eh; | ||
490 | static char eeprom_buf[HPEE_MAX_LENGTH]; | ||
491 | |||
492 | for (i=0; i < HPEE_MAX_LENGTH; i++) { | ||
493 | eeprom_buf[i] = gsc_readb(eeprom_addr+i); | ||
494 | } | ||
495 | |||
496 | printk(KERN_INFO "Enumerating EISA bus\n"); | ||
497 | |||
498 | eh = (struct eeprom_header*)(eeprom_buf); | ||
499 | for (i=0;i<eh->num_slots;i++) { | ||
500 | struct eeprom_eisa_slot_info *es; | ||
501 | |||
502 | es = (struct eeprom_eisa_slot_info*) | ||
503 | (&eeprom_buf[HPEE_SLOT_INFO(i)]); | ||
504 | |||
505 | if (-1==init_slot(i+1, es)) { | ||
506 | continue; | ||
507 | } | ||
508 | |||
509 | if (es->config_data_offset < HPEE_MAX_LENGTH) { | ||
510 | if (parse_slot_config(i+1, &eeprom_buf[es->config_data_offset], | ||
511 | es, io_parent, mem_parent)) { | ||
512 | return -1; | ||
513 | } | ||
514 | } else { | ||
515 | printk (KERN_WARNING "EISA EEPROM offset 0x%x out of range\n",es->config_data_offset); | ||
516 | return -1; | ||
517 | } | ||
518 | } | ||
519 | return eh->num_slots; | ||
520 | } | ||
521 | |||