contrib/pnpinfo/pnpinfo.c

   1 /*
   2  * Copyright (c) 1996, Sujal M. Patel
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/contrib/pnpinfo/pnpinfo.c,v 1.7 1999/09/05 17:27:05 peter Exp $
  27  * $DragonFly: src/contrib/pnpinfo/pnpinfo.c,v 1.3 2003/08/08 04:18:31 dillon Exp $
  28  */
  29
  30 #include <sys/time.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <string.h>
  37
  38 #include <machine/cpufunc.h>
  39
  40 #include <bus/isa/pnpreg.h>
  41
  42 #ifdef DEBUG
  43 #define DEB(x) x
  44 #else
  45 #define DEB(x)
  46 #endif
  47 #define DDB(x) x
  48
  49 static void pnp_write(int, u_char);
  50 static u_char pnp_read(int);
  51 static void DELAY(int i);
  52 static void send_Initiation_LFSR(void);
  53 static int get_serial(u_char *);
  54 static int get_resource_info(u_char *, int);
  55 static void report_dma_info(int)
  56 static void report_memory_info(int)
  57 static int handle_small_res(u_char *, int, int);
  58 static void handle_large_res(u_char *, int, int);
  59 static void dump_resdata(u_char *, int);
  60 static int isolation_protocol(void);
  61
  62 /* The READ_DATA port that we are using currently */
  63 static int rd_port;
  64
  65 int logdevs=0;
  66
  67 static void
  68 pnp_write(int d, u_char r)
  69 {
  70     outb (_PNP_ADDRESS, d);
  71     outb (_PNP_WRITE_DATA, r);
  72 }
  73
  74 static u_char
  75 pnp_read(int d)
  76 {
  77     outb(_PNP_ADDRESS, d);
  78     return inb( (rd_port << 2) + 3) & 0xff;
  79 }
  80
  81 /*
  82  * DELAY does accurate delaying in user-space.
  83  * This function busy-waits.
  84  */
  85 static void
  86 DELAY(int i)
  87 {
  88     struct timeval t;
  89     long start, stop;
  90
  91     i *= 4;
  92
  93     gettimeofday (&t, NULL);
  94     start = t.tv_sec * 1000000 + t.tv_usec;
  95     do {
  96         gettimeofday (&t, NULL);
  97         stop = t.tv_sec * 1000000 + t.tv_usec;
  98     } while (start + i > stop);
  99 }
 100
 101
 102 /*
 103  * Send Initiation LFSR as described in "Plug and Play ISA Specification,
 104  * Intel May 94."
 105  */
 106 static void
 107 send_Initiation_LFSR(void)
 108 {
 109     int cur, i;
 110
 111     pnp_write(PNP_CONFIG_CONTROL, 0x2);
 112
 113     /* Reset the LSFR */
 114     outb(_PNP_ADDRESS, 0);
 115     outb(_PNP_ADDRESS, 0); /* yes, we do need it twice! */
 116
 117     cur = 0x6a;
 118
 119     for (i = 0; i < 32; i++) {
 120         outb(_PNP_ADDRESS, cur);
 121         cur = (cur >> 1) | (((cur ^ (cur >> 1)) << 7) & 0xff);
 122     }
 123 }
 124
 125 /*
 126  * Get the device's serial number.  Returns 1 if the serial is valid.
 127  */
 128 static int
 129 get_serial(u_char *data)
 130 {
 131     int i, bit, valid = 0, sum = 0x6a;
 132
 133     bzero(data, sizeof(char) * 9);
 134
 135     for (i = 0; i < 72; i++) {
 136         bit = inb((rd_port << 2) | 0x3) == 0x55;
 137         DELAY(250);     /* Delay 250 usec */
 138
 139         /* Can't Short Circuit the next evaluation, so 'and' is last */
 140         bit = (inb((rd_port << 2) | 0x3) == 0xaa) && bit;
 141         DELAY(250);     /* Delay 250 usec */
 142
 143         valid = valid || bit;
 144
 145         if (i < 64)
 146             sum = (sum >> 1) |
 147                 (((sum ^ (sum >> 1) ^ bit) << 7) & 0xff);
 148
 149         data[i / 8] = (data[i / 8] >> 1) | (bit ? 0x80 : 0);
 150     }
 151
 152     valid = valid && (data[8] == sum);
 153
 154     return valid;
 155 }
 156
 157
 158 /*
 159  * Fill's the buffer with resource info from the device.
 160  * Returns 0 if the device fails to report
 161  */
 162 static int
 163 get_resource_info(u_char *buffer, int len)
 164 {
 165     int i, j;
 166
 167     for (i = 0; i < len; i++) {
 168         outb(_PNP_ADDRESS, PNP_STATUS);
 169         for (j = 0; j < 100; j++) {
 170             if ((inb((rd_port << 2) | 0x3)) & 0x1)
 171                 break;
 172             DELAY(1);
 173         }
 174         if (j == 100) {
 175             printf("PnP device failed to report resource data\n");
 176             return 0;
 177         }
 178         outb(_PNP_ADDRESS, PNP_RESOURCE_DATA);
 179         buffer[i] = inb((rd_port << 2) | 0x3);
 180         DEB(printf("--- get_resource_info: got 0x%02x\n",(unsigned)buffer[i]));
 181     }
 182     return 1;
 183 }
 184
 185 static void
 186 report_dma_info(int x)
 187 {
 188     const char *s1=NULL, *s2=NULL, *s3=NULL, *s4=NULL, *s5=NULL;
 189
 190     switch (x & 0x3) {
 191     case 0:
 192         s1="8-bit";
 193         break;
 194     case 1:
 195         s1="8/16-bit";
 196         break;
 197     case 2:
 198         s1="16-bit";
 199         break;
 200 #ifdef DIAGNOSTIC
 201     case 3:
 202         s1="Reserved";
 203         break;
 204 #endif
 205     }
 206
 207     s2 = (x & 0x4) ? "bus master" : "not a bus master";
 208
 209     s3 = (x & 0x8) ? "count by byte" : "";
 210
 211     s4 = (x & 0x10) ? "count by word" : "";
 212
 213     switch ((x & 0x60) >> 5) {
 214     case 0:
 215         s5="Compatibility mode";
 216         break;
 217     case 1:
 218         s5="Type A";
 219         break;
 220     case 2:
 221         s5="Type B";
 222         break;
 223     case 3:
 224         s5="Type F";
 225         break;
 226     }
 227     printf("\t%s, %s, %s, %s, %s\n",s1,s2,s3,s4,s5);
 228 }
 229
 230
 231 static void
 232 report_memory_info(int x)
 233 {
 234     if (x & 0x1)
 235         printf ("Memory Range: Writeable\n");
 236     else
 237         printf ("Memory Range: Not writeable (ROM)\n");
 238
 239     if (x & 0x2)
 240         printf ("Memory Range: Read-cacheable, write-through\n");
 241     else
 242         printf ("Memory Range: Non-cacheable\n");
 243
 244     if (x & 0x4)
 245         printf ("Memory Range: Decode supports high address\n");
 246     else
 247         printf ("Memory Range: Decode supports range length\n");
 248
 249     switch ((x & 0x18) >> 3) {
 250     case 0:
 251         printf ("Memory Range: 8-bit memory only\n");
 252         break;
 253     case 1:
 254         printf ("Memory Range: 16-bit memory only\n");
 255         break;
 256     case 2:
 257         printf ("Memory Range: 8-bit and 16-bit memory supported\n");
 258         break;
 259 #ifdef DIAGNOSTIC
 260     case 3:
 261         printf ("Memory Range: Reserved\n");
 262         break;
 263 #endif
 264     }
 265
 266     if (x & 0x20)
 267         printf ("Memory Range: Memory is shadowable\n");
 268     else
 269         printf ("Memory Range: Memory is not shadowable\n");
 270
 271     if (x & 0x40)
 272         printf ("Memory Range: Memory is an expansion ROM\n");
 273     else
 274         printf ("Memory Range: Memory is not an expansion ROM\n");
 275
 276 #ifdef DIAGNOSTIC
 277     if (x & 0x80)
 278         printf ("Memory Range: Reserved (Device is brain-damaged)\n");
 279 #endif
 280 }
 281
 282
 283 /*
 284  *  Small Resource Tag Handler
 285  *
 286  *  Returns 1 if checksum was valid (and an END_TAG was received).
 287  *  Returns -1 if checksum was invalid (and an END_TAG was received).
 288  *  Returns 0 for other tags.
 289  */
 290 static int
 291 handle_small_res(u_char *resinfo, int item, int len)
 292 {
 293     int i;
 294
 295     DEB(printf("*** ITEM 0x%04x len %d detected\n", item, len));
 296
 297     switch (item) {
 298     default:
 299         printf("*** ITEM 0x%02x detected\n", item);
 300         break;
 301     case PNP_TAG_VERSION:
 302         printf("PnP Version %d.%d, Vendor Version %d\n",
 303             resinfo[0] >> 4, resinfo[0] & (0xf), resinfo[1]);
 304         break;
 305     case PNP_TAG_LOGICAL_DEVICE:
 306         printf("\nLogical Device ID: %c%c%c%02x%02x 0x%08x #%d\n",
 307                 ((resinfo[0] & 0x7c) >> 2) + 64,
 308                 (((resinfo[0] & 0x03) << 3) |
 309                 ((resinfo[1] & 0xe0) >> 5)) + 64,
 310                 (resinfo[1] & 0x1f) + 64,
 311                 resinfo[2], resinfo[3], *(int *)(resinfo),
 312                 logdevs++);
 313
 314         if (resinfo[4] & 0x1)
 315             printf ("\tDevice powers up active\n"); /* XXX */
 316         if (resinfo[4] & 0x2)
 317             printf ("\tDevice supports I/O Range Check\n");
 318         if (resinfo[4] > 0x3)
 319             printf ("\tReserved register funcs %02x\n",
 320                 resinfo[4]);
 321
 322         if (len == 6)
 323             printf("\tVendor register funcs %02x\n", resinfo[5]);
 324         break;
 325     case PNP_TAG_COMPAT_DEVICE:
 326         printf("Compatible Device ID: %c%c%c%02x%02x (%08x)\n",
 327                 ((resinfo[0] & 0x7c) >> 2) + 64,
 328                 (((resinfo[0] & 0x03) << 3) |
 329                 ((resinfo[1] & 0xe0) >> 5)) + 64,
 330                 (resinfo[1] & 0x1f) + 64,
 331                 resinfo[2], resinfo[3], *(int *)resinfo);
 332         break;
 333     case PNP_TAG_IRQ_FORMAT:
 334         printf("    IRQ: ");
 335
 336         for (i = 0; i < 8; i++)
 337             if (resinfo[0] & (1<<i))
 338                 printf("%d ", i);
 339         for (i = 0; i < 8; i++)
 340             if (resinfo[1] & (1<<i))
 341                 printf("%d ", i + 8);
 342         if (len == 3) {
 343             if (resinfo[2] & 0x1)
 344                 printf("IRQ: High true edge sensitive\n");
 345             if (resinfo[2] & 0x2)
 346                 printf("IRQ: Low true edge sensitive\n");
 347             if (resinfo[2] & 0x4)
 348                 printf("IRQ: High true level sensitive\n");
 349             if (resinfo[2] & 0x8)
 350                 printf("IRQ: Low true level sensitive\n");
 351         } else {
 352             printf(" - only one type (true/edge)\n");
 353         }
 354         break;
 355     case PNP_TAG_DMA_FORMAT:
 356         printf("    DMA: channel(s) ");
 357         for (i = 0; i < 8; i++)
 358             if (resinfo[0] & (1<<i))
 359                 printf("%d ", i);
 360         printf ("\n");
 361         report_dma_info (resinfo[1]);
 362         break;
 363     case PNP_TAG_START_DEPENDANT:
 364         printf("TAG Start DF\n");
 365         if (len == 1) {
 366             switch (resinfo[0]) {
 367             case 0:
 368                 printf("Good Configuration\n");
 369                 break;
 370             case 1:
 371                 printf("Acceptable Configuration\n");
 372                 break;
 373             case 2:
 374                 printf("Sub-optimal Configuration\n");
 375                 break;
 376             }
 377         }
 378         break;
 379     case PNP_TAG_END_DEPENDANT:
 380         printf("TAG End DF\n");
 381         break;
 382     case PNP_TAG_IO_RANGE:
 383         printf("    I/O Range 0x%x .. 0x%x, alignment 0x%x, len 0x%x\n",
 384             resinfo[1] + (resinfo[2] << 8),
 385             resinfo[3] + (resinfo[4] << 8),
 386             resinfo[5], resinfo[6] );
 387         if (resinfo[0])
 388             printf("\t[16-bit addr]\n");
 389         else
 390             printf("\t[not 16-bit addr]\n");
 391         break;
 392     case PNP_TAG_IO_FIXED:
 393         printf ("    FIXED I/O base address 0x%x length 0x%x\n",
 394             resinfo[0] + ( (resinfo[1] & 3 ) << 8), /* XXX */
 395             resinfo[2]);
 396         break;
 397 #ifdef DIAGNOSTIC
 398     case PNP_TAG_RESERVED:
 399         printf("Reserved Tag Detected\n");
 400         break;
 401 #endif
 402     case PNP_TAG_VENDOR:
 403         printf("*** Small Vendor Tag Detected\n");
 404         break;
 405     case PNP_TAG_END:
 406         printf("End Tag\n\n");
 407         /* XXX Record and Verify Checksum */
 408         return 1;
 409         break;
 410     }
 411     return 0;
 412 }
 413
 414
 415 static void
 416 handle_large_res(u_char *resinfo, int item, int len)
 417 {
 418     int i;
 419
 420     DEB(printf("*** Large ITEM %d len %d found\n", item, len));
 421     switch (item) {
 422     case PNP_TAG_MEMORY_RANGE:
 423         report_memory_info(resinfo[0]);
 424         printf("Memory range minimum address: 0x%x\n",
 425                 (resinfo[1] << 8) + (resinfo[2] << 16));
 426         printf("Memory range maximum address: 0x%x\n",
 427                 (resinfo[3] << 8) + (resinfo[4] << 16));
 428         printf("Memory range base alignment: 0x%x\n",
 429                 (i = (resinfo[5] + (resinfo[6] << 8))) ? i : (1 << 16));
 430         printf("Memory range length: 0x%x\n",
 431                 (resinfo[7] + (resinfo[8] << 8)) * 256);
 432         break;
 433     case PNP_TAG_ID_ANSI:
 434         printf("Device Description: ");
 435
 436         for (i = 0; i < len; i++) {
 437             if (resinfo[i]) /* XXX */
 438                 printf("%c", resinfo[i]);
 439         }
 440         printf("\n");
 441         break;
 442     case PNP_TAG_ID_UNICODE:
 443         printf("ID String Unicode Detected (Undefined)\n");
 444         break;
 445     case PNP_TAG_LARGE_VENDOR:
 446         printf("Large Vendor Defined Detected\n");
 447         break;
 448     case PNP_TAG_MEMORY32_RANGE:
 449         printf("32bit Memory Range Desc Unimplemented\n");
 450         break;
 451     case PNP_TAG_MEMORY32_FIXED:
 452         printf("32bit Fixed Location Desc Unimplemented\n");
 453         break;
 454 #ifdef DIAGNOSTIC
 455     case PNP_TAG_LARGE_RESERVED:
 456         printf("Large Reserved Tag Detected\n");
 457         break;
 458 #endif
 459     }
 460 }
 461
 462
 463 /*
 464  * Dump all the information about configurations.
 465  */
 466 static void
 467 dump_resdata(u_char *data, int csn)
 468 {
 469     int i, large_len;
 470
 471     u_char tag, *resinfo;
 472
 473     DDB(printf("\nCard assigned CSN #%d\n", csn));
 474     printf("Vendor ID %c%c%c%02x%02x (0x%08x), Serial Number 0x%08x\n",
 475             ((data[0] & 0x7c) >> 2) + 64,
 476             (((data[0] & 0x03) << 3) | ((data[1] & 0xe0) >> 5)) + 64,
 477             (data[1] & 0x1f) + 64, data[2], data[3],
 478             *(int *)&(data[0]),
 479             *(int *)&(data[4]));
 480
 481     pnp_write(PNP_SET_CSN, csn); /* Move this out of this function XXX */
 482     outb(_PNP_ADDRESS, PNP_STATUS);
 483
 484     /* Allows up to 1kb of Resource Info,  Should be plenty */
 485     for (i = 0; i < 1024; i++) {
 486         if (!get_resource_info(&tag, 1))
 487             break;
 488
 489         if (PNP_RES_TYPE(tag) == 0) {
 490             /* Handle small resouce data types */
 491
 492             resinfo = malloc(PNP_SRES_LEN(tag));
 493             if (!get_resource_info(resinfo, PNP_SRES_LEN(tag)))
 494                 break;
 495
 496             if (handle_small_res(resinfo, PNP_SRES_NUM(tag), PNP_SRES_LEN(tag)) == 1)
 497                 break;
 498             free(resinfo);
 499         } else {
 500             /* Handle large resouce data types */
 501             u_char buf[2];
 502             if (!get_resource_info((char *)buf, 2))
 503                 break;
 504             large_len = (buf[1] << 8) + buf[0];
 505
 506             resinfo = malloc(large_len);
 507             if (!get_resource_info(resinfo, large_len))
 508                 break;
 509
 510             handle_large_res(resinfo, PNP_LRES_NUM(tag), large_len);
 511             free(resinfo);
 512         }
 513     }
 514     printf("Successfully got %d resources, %d logical fdevs\n", i,
 515             logdevs);
 516     printf("-- card select # 0x%04x\n", pnp_read(PNP_SET_CSN));
 517     printf("\nCSN %c%c%c%02x%02x (0x%08x), Serial Number 0x%08x\n",
 518             ((data[0] & 0x7c) >> 2) + 64,
 519             (((data[0] & 0x03) << 3) | ((data[1] & 0xe0) >> 5)) + 64,
 520             (data[1] & 0x1f) + 64, data[2], data[3],
 521             *(int *)&(data[0]),
 522             *(int *)&(data[4]));
 523
 524     for (i=0; i<logdevs; i++) {
 525         int j;
 526
 527         pnp_write(PNP_SET_LDN, i);
 528
 529         printf("\nLogical device #%d\n", pnp_read(PNP_SET_LDN) );
 530         printf("IO: ");
 531         for (j=0; j<8; j++)
 532             printf(" 0x%02x%02x", pnp_read(PNP_IO_BASE_HIGH(i)),
 533                 pnp_read(PNP_IO_BASE_LOW(i)));
 534         printf("\nIRQ %d %d\n",
 535             pnp_read(PNP_IRQ_LEVEL(0)), pnp_read(PNP_IRQ_LEVEL(1)) );
 536         printf("DMA %d %d\n",
 537             pnp_read(PNP_DMA_CHANNEL(0)), pnp_read(PNP_DMA_CHANNEL(1)) );
 538         printf("IO range check 0x%02x activate 0x%02x\n",
 539             pnp_read(PNP_IO_RANGE_CHECK), pnp_read(PNP_ACTIVATE) );
 540     }
 541 }
 542
 543
 544 /*
 545  * Run the isolation protocol. Use rd_port as the READ_DATA port
 546  * value (caller should try multiple READ_DATA locations before giving
 547  * up). Upon exiting, all cards are aware that they should use rd_port
 548  * as the READ_DATA port;
 549  *
 550  */
 551 static int
 552 isolation_protocol(void)
 553 {
 554     int csn;
 555     u_char data[9];
 556
 557     send_Initiation_LFSR();
 558
 559     /* Reset CSN for All Cards */
 560     pnp_write(PNP_CONFIG_CONTROL, 0x04);
 561
 562     for (csn = 1; (csn < PNP_MAX_CARDS); csn++) {
 563         /* Wake up cards without a CSN */
 564         logdevs = 0 ;
 565         pnp_write(PNP_WAKE, 0);
 566         pnp_write(PNP_SET_RD_DATA, rd_port);
 567         outb(_PNP_ADDRESS, PNP_SERIAL_ISOLATION);
 568         DELAY(1000);    /* Delay 1 msec */
 569
 570         if (get_serial(data))
 571             dump_resdata(data, csn);
 572         else
 573             break;
 574     }
 575     return csn - 1;
 576 }
 577
 578
 579 int
 580 main(void)
 581 {
 582     int num_pnp_devs;
 583
 584 #ifdef __i386__
 585     /* Hey what about a i386_iopl() call :) */
 586     if (open("/dev/io", O_RDONLY) < 0) {
 587         fprintf (stderr, "pnpinfo: Can't get I/O privilege.\n");
 588         exit (1);
 589     }
 590 #endif
 591
 592     printf("Checking for Plug-n-Play devices...\n");
 593
 594     /* Try various READ_DATA ports from 0x203-0x3ff */
 595     for (rd_port = 0x80; (rd_port < 0xff); rd_port += 0x10) {
 596         DEB(printf("Trying Read_Port at %x...\n", (rd_port << 2) | 0x3) );
 597         num_pnp_devs = isolation_protocol();
 598         if (num_pnp_devs)
 599             break;
 600     }
 601     if (!num_pnp_devs)
 602         printf("No Plug-n-Play devices were found\n");
 603     return 0;
 604 }