drivers/parisc/eisa_enumerator.c

   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