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