开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
residual.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：26k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

residual.c：源码内容
  1. /*
  2.  * BK Id: SCCS/s.residual.c 1.15 02/05/02 18:08:35 trini
  3.  */
  4. /*
  5.  * Code to deal with the PReP residual data.
  6.  *
  7.  * Written by: Cort Dougan (cort@cs.nmt.edu)
  8.  * Improved _greatly_ and rewritten by Gabriel Paubert (paubert@iram.es)
  9.  *
  10.  *  This file is based on the following documentation:
  11.  *
  12.  * IBM Power Personal Systems Architecture
  13.  * Residual Data
  14.  *  Document Number: PPS-AR-FW0001
  15.  *
  16.  *  This file is subject to the terms and conditions of the GNU General Public
  17.  *  License.  See the file COPYING in the main directory of this archive
  18.  *  for more details.
  19.  *
  20.  */
  22. #include <linux/string.h>
  23. #include <asm/residual.h>
  24. #include <asm/pnp.h>
  25. #include <asm/byteorder.h>
  27. #include <linux/errno.h>
  28. #include <linux/sched.h>
  29. #include <linux/kernel.h>
  30. #include <linux/mm.h>
  31. #include <linux/stddef.h>
  32. #include <linux/unistd.h>
  33. #include <linux/ptrace.h>
  34. #include <linux/slab.h>
  35. #include <linux/user.h>
  36. #include <linux/a.out.h>
  37. #include <linux/tty.h>
  38. #include <linux/major.h>
  39. #include <linux/interrupt.h>
  40. #include <linux/reboot.h>
  41. #include <linux/init.h>
  42. #include <linux/blk.h>
  43. #include <linux/ioport.h>
  44. #include <linux/pci.h>
  45. #include <linux/ide.h>
  47. #include <asm/sections.h>
  48. #include <asm/mmu.h>
  49. #include <asm/processor.h>
  50. #include <asm/io.h>
  51. #include <asm/pgtable.h>
  52. #include <asm/ide.h>
  55. unsigned char __res[sizeof(RESIDUAL)] __prepdata = {0,};
  56. RESIDUAL *res = (RESIDUAL *)&__res;
  58. char * PnP_BASE_TYPES[] __initdata = {
  59.   "Reserved",
  60.   "MassStorageDevice",
  61.   "NetworkInterfaceController",
  62.   "DisplayController",
  63.   "MultimediaController",
  64.   "MemoryController",
  65.   "BridgeController",
  66.   "CommunicationsDevice",
  67.   "SystemPeripheral",
  68.   "InputDevice",
  69.   "ServiceProcessor"
  70.   };
  72. /* Device Sub Type Codes */
  74. unsigned char * PnP_SUB_TYPES[] __initdata = {
  75.   "0100SCSIController",
  76.   "0101IDEController",
  77.   "0102FloppyController",
  78.   "0103IPIController",
  79.   "01200OtherMassStorageController",
  80.   "0200EthernetController",
  81.   "0201TokenRingController",
  82.   "0202FDDIController",
  83.   "02x80OtherNetworkController",
  84.   "0300VGAController",
  85.   "0301SVGAController",
  86.   "0302XGAController",
  87.   "03200OtherDisplayController",
  88.   "0400VideoController",
  89.   "0401AudioController",
  90.   "04200OtherMultimediaController",
  91.   "0500RAM",
  92.   "0501FLASH",
  93.   "05200OtherMemoryDevice",
  94.   "0600HostProcessorBridge",
  95.   "0601ISABridge",
  96.   "0602EISABridge",
  97.   "0603MicroChannelBridge",
  98.   "0604PCIBridge",
  99.   "0605PCMCIABridge",
  100.   "0606VMEBridge",
  101.   "06200OtherBridgeDevice",
  102.   "0700RS232Device",
  103.   "0701ATCompatibleParallelPort",
  104.   "07200OtherCommunicationsDevice",
  105.   "1000ProgrammableInterruptController",
  106.   "1001DMAController",
  107.   "1002SystemTimer",
  108.   "1003RealTimeClock",
  109.   "1004L2Cache",
  110.   "1005NVRAM",
  111.   "1006PowerManagement",
  112.   "1007CMOS",
  113.   "1010OperatorPanel",
  114.   "1011ServiceProcessorClass1",
  115.   "1012ServiceProcessorClass2",
  116.   "1013ServiceProcessorClass3",
  117.   "1014GraphicAssist",
  118.   "1017SystemPlanar",
  119.   "10200OtherSystemPeripheral",
  120.   "1100KeyboardController",
  121.   "1101Digitizer",
  122.   "1102MouseController",
  123.   "1103TabletController",
  124.   "11x80OtherInputController",
  125.   "1200GeneralMemoryController",
  126.   NULL
  127. };
  129. /* Device Interface Type Codes */
  131. unsigned char * PnP_INTERFACES[] __initdata = {
  132.   "000000General",
  133.   "010000GeneralSCSI",
  134.   "010100GeneralIDE",
  135.   "010101ATACompatible",
  137.   "010200GeneralFloppy",
  138.   "010201Compatible765",
  139.   "010202NS398_Floppy",         /* NS Super I/O wired to use index
  140.                                          register at port 398 and data
  141.                                          register at port 399               */
  142.   "010203NS26E_Floppy",         /* Ports 26E and 26F                  */
  143.   "010204NS15C_Floppy",         /* Ports 15C and 15D                  */
  144.   "010205NS2E_Floppy",          /* Ports 2E and 2F                    */
  145.   "010206CHRP_Floppy",          /* CHRP Floppy in PR*P system         */
  147.   "010300GeneralIPI",
  148.   
  149.   "020000GeneralEther",
  150.   "020100GeneralToken",
  151.   "020200GeneralFDDI",
  152.   
  153.   "030000GeneralVGA",
  154.   "030100GeneralSVGA",
  155.   "030200GeneralXGA",
  156.   
  157.   "040000GeneralVideo",
  158.   "040100GeneralAudio",
  159.   "040101CS4232Audio",            /* CS 4232 Plug 'n Play Configured    */
  161.   "050000GeneralRAM",
  162.   /* This one is obviously wrong ! */
  163.   "050000PCIMemoryController",    /* PCI Config Method                  */
  164.   "050001RS6KMemoryController",   /* RS6K Config Method                 */
  165.   "050100GeneralFLASH",
  166.   
  167.   "060000GeneralHostBridge",
  168.   "060100GeneralISABridge",
  169.   "060200GeneralEISABridge",
  170.   "060300GeneralMCABridge",
  171.   /* GeneralPCIBridge = 0, */
  172.   "060400PCIBridgeDirect",
  173.   "060401PCIBridgeIndirect",
  174.   "060402PCIBridgeRS6K",
  175.   "060500GeneralPCMCIABridge",
  176.   "060600GeneralVMEBridge",
  177.   
  178.   "070000GeneralRS232",
  179.   "070001COMx",
  180.   "070002Compatible16450",
  181.   "070003Compatible16550",
  182.   "070004NS398SerPort",         /* NS Super I/O wired to use index
  183.                                          register at port 398 and data
  184.                                          register at port 399               */
  185.   "070005NS26ESerPort",         /* Ports 26E and 26F                  */
  186.   "070006NS15CSerPort",         /* Ports 15C and 15D                  */
  187.   "070007NS2ESerPort",          /* Ports 2E and 2F                    */
  189.   "070100GeneralParPort",
  190.   "070101LPTx",
  191.   "070102NS398ParPort",         /* NS Super I/O wired to use index
  192.                                          register at port 398 and data
  193.                                          register at port 399               */
  194.   "070103NS26EParPort",         /* Ports 26E and 26F                  */
  195.   "070104NS15CParPort",         /* Ports 15C and 15D                  */
  196.   "070105NS2EParPort",          /* Ports 2E and 2F                    */
  197.   
  198.   "100000GeneralPIC",
  199.   "100001ISA_PIC",
  200.   "100002EISA_PIC",
  201.   "100003MPIC",
  202.   "100004RS6K_PIC",
  204.   "100100GeneralDMA",
  205.   "100101ISA_DMA",
  206.   "100102EISA_DMA",
  208.   "100200GeneralTimer",
  209.   "100201ISA_Timer",
  210.   "100202EISA_Timer",
  211.   "100300GeneralRTC",
  212.   "100301ISA_RTC",
  213.   
  214.   "100401StoreThruOnly",
  215.   "100402StoreInEnabled",
  216.   "100403RS6KL2Cache",
  218.   "100500IndirectNVRAM",        /* Indirectly addressed               */
  219.   "100501DirectNVRAM",          /* Memory Mapped                      */
  220.   "100502IndirectNVRAM24",      /* Indirectly addressed - 24 bit      */
  222.   "100600GeneralPowerManagement",
  223.   "100601EPOWPowerManagement",
  224.   "100602PowerControl",         // d1378
  225.   
  226.   "100700GeneralCMOS",
  228.   "101000GeneralOPPanel",
  229.   "101001HarddiskLight",
  230.   "101002CDROMLight",
  231.   "101003PowerLight",
  232.   "101004KeyLock",
  233.   "101005ANDisplay",            /* AlphaNumeric Display               */
  234.   "101006SystemStatusLED",      /* 3 digit 7 segment LED              */
  235.   "101007CHRP_SystemStatusLED", /* CHRP LEDs in PR*P system           */
  237.   "101100GeneralServiceProcessor",
  238.   "101200GeneralServiceProcessor",
  239.   "101300GeneralServiceProcessor",
  240.   
  241.   "101401TransferData",
  242.   "101402IGMC32",
  243.   "101403IGMC64",
  244.   
  245.   "101700GeneralSystemPlanar",   /* 10/5/95                            */
  246.   NULL
  247.   };
  249. static const unsigned char __init *PnP_SUB_TYPE_STR(unsigned char BaseType, 
  250.      unsigned char SubType) {
  251. unsigned char ** s=PnP_SUB_TYPES;
  252. while (*s && !((*s)[0]==BaseType 
  253.        && (*s)[1]==SubType)) s++;
  254. if (*s) return *s+2;
  255. else return("Unknown !");
  256. };
  258. static const unsigned char __init *PnP_INTERFACE_STR(unsigned char BaseType, 
  259.       unsigned char SubType,
  260.       unsigned char Interface) {
  261. unsigned char ** s=PnP_INTERFACES;
  262. while (*s && !((*s)[0]==BaseType 
  263.        && (*s)[1]==SubType 
  264.        && (*s)[2]==Interface)) s++;
  265. if (*s) return *s+3;
  266. else return NULL;
  267. };
  269. static void __init printsmallvendor(PnP_TAG_PACKET *pkt, int size) {
  270. int i, c;
  271. char decomp[4];
  272. #define p pkt->S14_Pack.S14_Data.S14_PPCPack
  273. switch(p.Type) {
  274. case 1:
  275.   /* Decompress first 3 chars */
  276.   c = *(unsigned short *)p.PPCData;
  277.   decomp[0]='A'-1+((c>>10)&0x1F);
  278.   decomp[1]='A'-1+((c>>5)&0x1F);
  279.   decomp[2]='A'-1+(c&0x1F);
  280.   decomp[3]=0;
  281.   printk("    Chip identification: %s%4.4Xn",
  282.  decomp, ld_le16((unsigned short *)(p.PPCData+2)));
  283.   break;
  284. default:
  285.   printk("    Small vendor item type 0x%2.2x, data (hex): ",
  286.  p.Type);
  287.   for(i=0; i<size-2; i++) printk("%2.2x ", p.PPCData[i]);
  288.   printk("n");
  289.   break;
  290. }
  291. #undef p
  292. }
  294. static void __init printsmallpacket(PnP_TAG_PACKET * pkt, int size) {
  295. static const unsigned char * intlevel[] = {"high", "low"};
  296. static const unsigned char * intsense[] = {"edge", "level"};
  298. switch (tag_small_item_name(pkt->S1_Pack.Tag)) {
  299. case PnPVersion:
  300.   printk("    PnPversion 0x%x.%xn", 
  301.  pkt->S1_Pack.Version[0], /* How to interpret version ? */
  302.  pkt->S1_Pack.Version[1]);
  303.   break;
  304. // case Logicaldevice:
  305.   break;
  306. // case CompatibleDevice:
  307.   break;
  308. case IRQFormat:
  309. #define p pkt->S4_Pack
  310.   printk("    IRQ Mask 0x%4.4x, %s %s sensitiven", 
  311.  ld_le16((unsigned short *)p.IRQMask),
  312.  intlevel[(size>3) ? !(p.IRQInfo&0x05) : 0],
  313.  intsense[(size>3) ? !(p.IRQInfo&0x03) : 0]);
  314. #undef p
  315.   break;
  316. case DMAFormat:
  317. #define p pkt->S5_Pack
  318.   printk("    DMA channel mask 0x%2.2x, info 0x%2.2xn",
  319.  p.DMAMask, p.DMAInfo);
  320. #undef p
  321.   break;
  322. case StartDepFunc:
  323.   printk("Start dependent function:n");
  324.   break;
  325. case EndDepFunc:
  326.   printk("End dependent functionn");
  327.   break;
  328. case IOPort:
  329. #define p pkt->S8_Pack
  330.   printk("    Variable (%d decoded bits) I/O portn"
  331.  "      from 0x%4.4x to 0x%4.4x, alignment %d, %d portsn",
  332.  p.IOInfo&ISAAddr16bit?16:10,
  333.  ld_le16((unsigned short *)p.RangeMin),
  334.    ld_le16((unsigned short *)p.RangeMax),
  335.  p.IOAlign, p.IONum); 
  336. #undef p
  337.   break;
  338. case FixedIOPort:
  339. #define p pkt->S9_Pack
  340.   printk("    Fixed (10 decoded bits) I/O port from %3.3x to %3.3xn",
  341.  (p.Range[1]<<8)|p.Range[0],
  342.  ((p.Range[1]<<8)|p.Range[0])+p.IONum-1);
  343. #undef p  
  344.   break;
  345. case Res1:
  346. case Res2:
  347. case Res3:
  348.   printk("    Undefined packet type %d!n", 
  349.  tag_small_item_name(pkt->S1_Pack.Tag));
  350.   break;
  351. case SmallVendorItem:
  352.   printsmallvendor(pkt,size);
  353.   break;
  354. default:
  355.   printk("    Type 0x2.2x%d, size=%dn", 
  356.  pkt->S1_Pack.Tag, size);    
  357.   break;
  358. }
  359. }
  361. static void __init printlargevendor(PnP_TAG_PACKET * pkt, int size) {
  362. static const unsigned char * addrtype[] = {"I/O", "Memory", "System"};
  363. static const unsigned char * inttype[] = {"8259", "MPIC", "RS6k BUID %d"};
  364. static const unsigned char * convtype[] = {"Bus Memory", "Bus I/O", "DMA"};
  365. static const unsigned char * transtype[] = {"direct", "mapped", "direct-store segment"};
  366. static const unsigned char * L2type[] = {"WriteThru", "CopyBack"};
  367. static const unsigned char * L2assoc[] = {"DirectMapped", "2-way set"};
  369. int i;
  370. char tmpstr[30], *t;
  371. #define p pkt->L4_Pack.L4_Data.L4_PPCPack
  372. switch(p.Type) {
  373. case 2:
  374.   printk("    %d K %s %s L2 cache, %d/%d bytes line/sector sizen",
  375.  ld_le32((unsigned int *)p.PPCData),
  376.  L2type[p.PPCData[10]-1],
  377.  L2assoc[p.PPCData[4]-1],
  378.  ld_le16((unsigned short *)p.PPCData+3),
  379.  ld_le16((unsigned short *)p.PPCData+4));
  380.   break;
  381. case 3:
  382.   printk("    PCI Bridge parametersn"
  383.  "      ConfigBaseAddress %0xn"
  384.  "      ConfigBaseData %0xn"
  385.  "      Bus number %dn",
  386.  ld_le32((unsigned int *)p.PPCData),
  387.  ld_le32((unsigned int *)(p.PPCData+8)),
  388.  p.PPCData[16]);
  389.   for(i=20; i<size-4; i+=12) {
  390.    int j, first;
  391.    if(p.PPCData[i]) printk("      PCI Slot %d", p.PPCData[i]);
  392. else printk ("      Integrated PCI device");
  393. for(j=0, first=1, t=tmpstr; j<4; j++) {
  394. int line=ld_le16((unsigned short *)(p.PPCData+i+4)+j);
  395. if(line!=0xffff){
  396.         if(first) first=0; else *t++='/';
  397. *t++='A'+j;
  398. }
  399. }
  400. *t='';
  401. printk(" DevFunc 0x%x interrupt line(s) %s routed to",
  402.        p.PPCData[i+1],tmpstr);
  403. sprintf(tmpstr,
  404. inttype[p.PPCData[i+2]-1],
  405. p.PPCData[i+3]);
  406. printk(" %s line(s) ",
  407.        tmpstr);
  408. for(j=0, first=1, t=tmpstr; j<4; j++) {
  409. int line=ld_le16((unsigned short *)(p.PPCData+i+4)+j);
  410. if(line!=0xffff){
  411. if(first) first=0; else *t++='/';
  412. t+=sprintf(t,"%d(%c)",
  413.    line&0x7fff,
  414.    line&0x8000?'E':'L');
  415. }
  416. }
  417. printk("%sn",tmpstr);
  418.   }
  419.   break;
  420. case 5:
  421.   printk("    Bridge address translation, %s decoding:n"
  422.  "      Processor  Bus        Size       Conversion Translationn"
  423.  "      0x%8.8x 0x%8.8x 0x%8.8x %s %sn",
  424.  p.PPCData[0]&1 ? "positive" : "subtractive",
  425.  ld_le32((unsigned int *)p.PPCData+1),
  426.  ld_le32((unsigned int *)p.PPCData+3),
  427.  ld_le32((unsigned int *)p.PPCData+5),
  428.  convtype[p.PPCData[2]-1],
  429.  transtype[p.PPCData[1]-1]);
  430.   break;
  431. case 6:
  432.   printk("    Bus speed %d Hz, %d slot(s)n",
  433.  ld_le32((unsigned int *)p.PPCData),
  434.  p.PPCData[4]);
  435.   break;
  436. case 7:
  437.   printk("    SCSI buses: %d, id(s):", p.PPCData[0]);
  438.   for(i=1; i<=p.PPCData[0]; i++) 
  439.     printk(" %d%c", p.PPCData[i], i==p.PPCData[0] ? 'n' : ',');
  440.   break;
  441. case 9:
  442.   printk("    %s address (%d bits), at 0x%x size 0x%x bytesn",
  443.  addrtype[p.PPCData[0]-1],
  444.  p.PPCData[1],
  445.  ld_le32((unsigned int *)(p.PPCData+4)),
  446.  ld_le32((unsigned int *)(p.PPCData+12)));
  447.   break;
  448. case 10:
  449.   sprintf(tmpstr,
  450.   inttype[p.PPCData[0]-1],
  451.   p.PPCData[1]);
  453.   printk("    ISA interrupts routed to %sn"
  454.  "      lines", 
  455.  tmpstr);
  456.   for(i=0; i<16; i++) {
  457.    int line=ld_le16((unsigned short *)p.PPCData+i+1);
  458. if (line!=0xffff) printk(" %d(IRQ%d)", line, i); 
  459.   }
  460.   printk("n");
  461.   break;
  462. default:
  463.   printk("    Large vendor item type 0x%2.2xn      Data (hex):",
  464.  p.Type);
  465.   for(i=0; i<size-4; i++) printk(" %2.2x", p.PPCData[i]);
  466.   printk("n");
  467. #undef p
  468. }
  469. }
  471. static void __init printlargepacket(PnP_TAG_PACKET * pkt, int size) {
  472. switch (tag_large_item_name(pkt->S1_Pack.Tag)) {
  473. case LargeVendorItem:
  474.   printlargevendor(pkt, size);
  475.   break;
  476. default:
  477.   printk("    Type 0x2.2x%d, size=%dn", 
  478.  pkt->S1_Pack.Tag, size);    
  479.   break;
  480. }
  481. }
  482. static void __init printpackets(PnP_TAG_PACKET * pkt, const char * cat) {
  483. if (pkt->S1_Pack.Tag== END_TAG) {
  484. printk("  No packets describing %s resources.n", cat);
  485. return;
  486. }
  487. printk(  "  Packets describing %s resources:n",cat);
  488. do {
  489. int size;
  490. if (tag_type(pkt->S1_Pack.Tag)) {
  491.    size= 3 +
  492.   pkt->L1_Pack.Count0 + 
  493.   pkt->L1_Pack.Count1*256;
  494. printlargepacket(pkt, size);
  495. } else {
  496. size=tag_small_count(pkt->S1_Pack.Tag)+1;
  497. printsmallpacket(pkt, size);
  498. }
  499. (unsigned char *) pkt+=size;
  500. } while (pkt->S1_Pack.Tag != END_TAG);
  501. }
  503. void __init print_residual_device_info(void)
  504. {
  505. int i;
  506. PPC_DEVICE *dev;
  507. #define did dev->DeviceId
  509. /* make sure we have residual data first */
  510. if ( res->ResidualLength == 0 )
  511. return;
  513. printk("Residual: %ld devicesn", res->ActualNumDevices);
  514. for ( i = 0;
  515.       i < res->ActualNumDevices ;
  516.       i++)
  517. {
  518.    char decomp[4], sn[20];
  519. const char * s;
  520. dev = &res->Devices[i];
  521. s = PnP_INTERFACE_STR(did.BaseType, did.SubType, 
  522.       did.Interface);
  523. if(!s) {
  524. sprintf(sn, "interface %d", did.Interface);
  525. s=sn;
  526. }
  527. if ( did.BusId & PCIDEVICE ) 
  528.   printk("PCI Device, Bus %d, DevFunc 0x%x:",
  529.  dev->BusAccess.PCIAccess.BusNumber,
  530.  dev->BusAccess.PCIAccess.DevFuncNumber);
  531.         if ( did.BusId & PNPISADEVICE ) printk("PNPISA Device:");
  532. if ( did.BusId & ISADEVICE ) 
  533.   printk("ISA Device, Slot %d, LogicalDev %d:",
  534.  dev->BusAccess.ISAAccess.SlotNumber,
  535.  dev->BusAccess.ISAAccess.LogicalDevNumber);
  536. if ( did.BusId & EISADEVICE ) printk("EISA Device:");
  537. if ( did.BusId & PROCESSORDEVICE ) 
  538.   printk("ProcBus Device, Bus %d, BUID %d: ",
  539.  dev->BusAccess.ProcBusAccess.BusNumber,
  540.  dev->BusAccess.ProcBusAccess.BUID);
  541. if ( did.BusId & PCMCIADEVICE ) printk("PCMCIA ");
  542. if ( did.BusId & VMEDEVICE ) printk("VME ");
  543. if ( did.BusId & MCADEVICE ) printk("MCA ");
  544. if ( did.BusId & MXDEVICE ) printk("MX ");
  545. /* Decompress first 3 chars */
  546. decomp[0]='A'-1+((did.DevId>>26)&0x1F);
  547. decomp[1]='A'-1+((did.DevId>>21)&0x1F);
  548. decomp[2]='A'-1+((did.DevId>>16)&0x1F);
  549. decomp[3]=0;
  550. printk(" %s%4.4lX, %s, %s, %sn", 
  551.        decomp, did.DevId&0xffff,
  552.        PnP_BASE_TYPES[did.BaseType],
  553.        PnP_SUB_TYPE_STR(did.BaseType,did.SubType),
  554.        s);
  555. if ( dev->AllocatedOffset )
  556. printpackets( (union _PnP_TAG_PACKET *)
  557.       &res->DevicePnPHeap[dev->AllocatedOffset],
  558.       "allocated");
  559. if ( dev->PossibleOffset )
  560. printpackets( (union _PnP_TAG_PACKET *)
  561.       &res->DevicePnPHeap[dev->PossibleOffset],
  562.       "possible");
  563. if ( dev->CompatibleOffset )
  564. printpackets( (union _PnP_TAG_PACKET *)
  565.       &res->DevicePnPHeap[dev->CompatibleOffset],
  566.       "compatible");
  567. }
  568. }
  571. #if 0
  572. static void __init printVPD(void) {
  573. #define vpd res->VitalProductData
  574. int ps=vpd.PageSize, i, j;
  575. static const char* Usage[]={
  576.   "FirmwareStack",  "FirmwareHeap",  "FirmwareCode", "BootImage",
  577.   "Free", "Unpopulated", "ISAAddr", "PCIConfig",
  578.   "IOMemory", "SystemIO", "SystemRegs", "PCIAddr", 
  579.   "UnPopSystemRom", "SystemROM", "ResumeBlock", "Other" 
  580. };
  581. static const unsigned char *FWMan[]={
  582.   "IBM", "Motorola", "FirmWorks", "Bull"
  583. };
  584. static const unsigned char *FWFlags[]={
  585.   "Conventional", "OpenFirmware", "Diagnostics", "LowDebug",
  586.   "MultiBoot", "LowClient", "Hex41", "FAT", 
  587.   "ISO9660", "SCSI_ID_Override", "Tape_Boot", "FW_Boot_Path"
  588. };
  589. static const unsigned char *ESM[]={
  590.   "Port92", "PCIConfigA8", "FF001030", "????????"
  591. };
  592. static const unsigned char *SIOM[]={
  593.   "Port850", "????????", "PCIConfigA8", "????????"
  594. };
  596. printk("Model: %sn",vpd.PrintableModel);
  597. printk("Serial: %sn", vpd.Serial);
  598. printk("FirmwareSupplier: %sn", FWMan[vpd.FirmwareSupplier]);
  599. printk("FirmwareFlags:");
  600. for(j=0; j<12; j++) {
  601.    if (vpd.FirmwareSupports & (1<<j)) {
  602. printk(" %s%c", FWFlags[j], 
  603.        vpd.FirmwareSupports&(-2<<j) ? ',' : 'n');
  604. }
  605. }
  606. printk("NVRamSize: %ldn", vpd.NvramSize);
  607. printk("SIMMslots: %ldn", vpd.NumSIMMSlots);
  608. printk("EndianSwitchMethod: %sn", 
  609.        ESM[vpd.EndianSwitchMethod>2 ? 2 : vpd.EndianSwitchMethod]);
  610. printk("SpreadIOMethod: %sn", 
  611.        SIOM[vpd.SpreadIOMethod>3 ? 3 : vpd.SpreadIOMethod]);
  612. printk("Processor/Bus frequencies (Hz): %ld/%ldn",
  613.        vpd.ProcessorHz, vpd.ProcessorBusHz);
  614. printk("Time Base Divisor: %ldn", vpd.TimeBaseDivisor);
  615. printk("WordWidth, PageSize: %ld, %dn", vpd.WordWidth, ps);
  616. printk("Cache sector size, Lock granularity: %ld, %ldn",
  617.        vpd.CoherenceBlockSize, vpd.GranuleSize);
  618. for (i=0; i<res->ActualNumMemSegs; i++) {
  619. int mask=res->Segs[i].Usage, first, j;
  620. printk("%8.8lx-%8.8lx ", 
  621.        res->Segs[i].BasePage*ps,
  622.        (res->Segs[i].PageCount+res->Segs[i].BasePage)*ps-1);
  623. for(j=15, first=1; j>=0; j--) {
  624. if (mask&(1<<j)) {
  625. if (first) first=0;
  626. else printk(", ");
  627. printk("%s", Usage[j]);
  628. }
  629. }
  630. printk("n");
  631. }
  632. }
  634. /*
  635.  * Spit out some info about residual data
  636.  */
  637. void print_residual_device_info(void)
  638. {
  639. int i;
  640. union _PnP_TAG_PACKET *pkt;
  641. PPC_DEVICE *dev;
  642. #define did dev->DeviceId
  644. /* make sure we have residual data first */
  645. if ( res->ResidualLength == 0 )
  646. return;
  647. printk("Residual: %ld devicesn", res->ActualNumDevices);
  648. for ( i = 0;
  649.       i < res->ActualNumDevices ;
  650.       i++)
  651. {
  652. dev = &res->Devices[i];
  653. /*
  654.  * pci devices
  655.  */
  656. if ( did.BusId & PCIDEVICE )
  657. {
  658. printk("PCI Device:");
  659. /* unknown vendor */
  660. if ( !strncmp( "Unknown", pci_strvendor(did.DevId>>16), 7) )
  661. printk(" id %08lx types %d/%d", did.DevId,
  662.        did.BaseType, did.SubType);
  663. /* known vendor */
  664. else
  665. printk(" %s %s",
  666.        pci_strvendor(did.DevId>>16),
  667.        pci_strdev(did.DevId>>16,
  668.   did.DevId&0xffff)
  669. );
  671. if ( did.BusId & PNPISADEVICE )
  672. {
  673. printk(" pnp:");
  674. /* get pnp info on the device */
  675. pkt = (union _PnP_TAG_PACKET *)
  676. &res->DevicePnPHeap[dev->AllocatedOffset];
  677. for (; pkt->S1_Pack.Tag != DF_END_TAG;
  678.      pkt++ )
  679. {
  680. if ( (pkt->S1_Pack.Tag == S4_Packet) ||
  681.      (pkt->S1_Pack.Tag == S4_Packet_flags) )
  682. printk(" irq %02x%02x",
  683.        pkt->S4_Pack.IRQMask[0],
  684.        pkt->S4_Pack.IRQMask[1]);
  685. }
  686. }
  687. printk("n");
  688. continue;
  689. }
  690. /*
  691.  * isa devices
  692.  */
  693. if ( did.BusId & ISADEVICE )
  694. {
  695. printk("ISA Device: basetype: %d subtype: %d",
  696.        did.BaseType, did.SubType);
  697. printk("n");
  698. continue;
  699. }
  700. /*
  701.  * eisa devices
  702.  */
  703. if ( did.BusId & EISADEVICE )
  704. {
  705. printk("EISA Device: basetype: %d subtype: %d",
  706.        did.BaseType, did.SubType);
  707. printk("n");
  708. continue;
  709. }
  710. /*
  711.  * proc bus devices
  712.  */
  713. if ( did.BusId & PROCESSORDEVICE )
  714. {
  715. printk("ProcBus Device: basetype: %d subtype: %d",
  716.        did.BaseType, did.SubType);
  717. printk("n");
  718. continue;
  719. }
  720. /*
  721.  * pcmcia devices
  722.  */
  723. if ( did.BusId & PCMCIADEVICE )
  724. {
  725. printk("PCMCIA Device: basetype: %d subtype: %d",
  726.        did.BaseType, did.SubType);
  727. printk("n");
  728. continue;
  729. }
  730. printk("Unknown bus access device: busid %lxn",
  731.        did.BusId);
  732. }
  733. }
  734. #endif
  736. /* Returns the device index in the residual data, 
  737.    any of the search items may be set as -1 for wildcard,
  738.    DevID number field (second halfword) is big endian ! 
  740.    Examples:
  741.    - search for the Interrupt controller (8259 type), 2 methods:
  742.      1) i8259 = residual_find_device(~0, 
  743.                                      NULL, 
  744.      SystemPeripheral, 
  745.      ProgrammableInterruptController, 
  746.      ISA_PIC, 
  747.      0);
  748.      2) i8259 = residual_find_device(~0, "PNP0000", -1, -1, -1, 0) 
  750.    - search for the first two serial devices, whatever their type)
  751.      iserial1 = residual_find_device(~0,NULL,
  752.                                      CommunicationsDevice,
  753.      RS232Device,
  754.      -1, 0)
  755.      iserial2 = residual_find_device(~0,NULL,
  756.                                      CommunicationsDevice,
  757.      RS232Device,
  758.      -1, 1)
  759.    - but search for typical COM1 and COM2 is not easy due to the
  760.      fact that the interface may be anything and the name "PNP0500" or 
  761.      "PNP0501". Quite bad. 
  763. */
  765. /* devid are easier to uncompress than to compress, so to minimize bloat
  766. in this rarely used area we unencode and compare */
  768. /* in residual data number is big endian in the device table and
  769. little endian in the heap, so we use two parameters to avoid writing
  770. two very similar functions */
  772. static int __init same_DevID(unsigned short vendor,
  773.        unsigned short Number,
  774.        char * str) 
  775. {
  776. static unsigned const char hexdigit[]="0123456789ABCDEF";
  777. if (strlen(str)!=7) return 0;
  778. if ( ( ((vendor>>10)&0x1f)+'A'-1 == str[0])  &&
  779.      ( ((vendor>>5)&0x1f)+'A'-1 == str[1])   &&
  780.      ( (vendor&0x1f)+'A'-1 == str[2])        &&
  781.      (hexdigit[(Number>>12)&0x0f] == str[3]) &&
  782.      (hexdigit[(Number>>8)&0x0f] == str[4])  &&
  783.      (hexdigit[(Number>>4)&0x0f] == str[5])  &&
  784.      (hexdigit[Number&0x0f] == str[6]) ) return 1;
  785. return 0;
  786. }
  788. PPC_DEVICE __init *residual_find_device(unsigned long BusMask,
  789.  unsigned char * DevID,
  790.  int BaseType,
  791.  int SubType,
  792.  int Interface,
  793.  int n)
  794. {
  795. int i;
  796. if ( !res->ResidualLength ) return NULL;
  797. for (i=0; i<res->ActualNumDevices; i++) {
  798. #define Dev res->Devices[i].DeviceId
  799. if ( (Dev.BusId&BusMask)                                  &&
  800.      (BaseType==-1 || Dev.BaseType==BaseType)             &&
  801.      (SubType==-1 || Dev.SubType==SubType)                &&
  802.      (Interface==-1 || Dev.Interface==Interface)          &&
  803.      (DevID==NULL || same_DevID((Dev.DevId>>16)&0xffff,
  804. Dev.DevId&0xffff, DevID)) &&
  805.      !(n--) ) return res->Devices+i;
  806. #undef Dev
  807. }
  808. return 0;
  809. }
  811. PPC_DEVICE __init *residual_find_device_id(unsigned long BusMask,
  812.  unsigned short DevID,
  813.  int BaseType,
  814.  int SubType,
  815.  int Interface,
  816.  int n)
  817. {
  818. int i;
  819. if ( !res->ResidualLength ) return NULL;
  820. for (i=0; i<res->ActualNumDevices; i++) {
  821. #define Dev res->Devices[i].DeviceId
  822. if ( (Dev.BusId&BusMask)                                  &&
  823.      (BaseType==-1 || Dev.BaseType==BaseType)             &&
  824.      (SubType==-1 || Dev.SubType==SubType)                &&
  825.      (Interface==-1 || Dev.Interface==Interface)          &&
  826.      (DevID==0xffff || (Dev.DevId&0xffff) == DevID)   &&
  827.      !(n--) ) return res->Devices+i;
  828. #undef Dev
  829. }
  830. return 0;
  831. }
  833. PnP_TAG_PACKET *PnP_find_packet(unsigned char *p,
  834. unsigned packet_tag,
  835. int n)
  836. {
  837. unsigned mask, masked_tag, size;
  838. if(!p) return 0;
  839. if (tag_type(packet_tag)) mask=0xff; else mask=0xF8;
  840. masked_tag = packet_tag&mask;
  841. for(; *p != END_TAG; p+=size) {
  842. if ((*p & mask) == masked_tag && !(n--)) 
  843. return (PnP_TAG_PACKET *) p;
  844. if (tag_type(*p))
  845. size=ld_le16((unsigned short *)(p+1))+3;
  846. else 
  847. size=tag_small_count(*p)+1;
  848. }
  849. return 0; /* not found */
  850. }
  852. PnP_TAG_PACKET __init *PnP_find_small_vendor_packet(unsigned char *p,
  853.      unsigned packet_type,
  854.      int n)
  855. {
  856. int next=0;
  857. while (p) {
  858. p = (unsigned char *) PnP_find_packet(p, 0x70, next);
  859. if (p && p[1]==packet_type && !(n--)) 
  860. return (PnP_TAG_PACKET *) p;
  861. next = 1;
  862. };
  863. return 0; /* not found */
  864. }
  866. PnP_TAG_PACKET __init *PnP_find_large_vendor_packet(unsigned char *p,
  867.    unsigned packet_type,
  868.    int n)
  869. {
  870. int next=0;
  871. while (p) {
  872. p = (unsigned char *) PnP_find_packet(p, 0x84, next);
  873. if (p && p[3]==packet_type && !(n--)) 
  874. return (PnP_TAG_PACKET *) p;
  875. next = 1;
  876. };
  877. return 0; /* not found */
  878. }
  880. #ifdef CONFIG_PROC_PREPRESIDUAL
  881. static int proc_prep_residual_read(char * buf, char ** start, off_t off,
  882. int count, int *eof, void *data)
  883. {
  884. int n;
  886. n = res->ResidualLength - off;
  887. if (n < 0) {
  888. *eof = 1;
  889. n = 0;
  890. }
  891. else {
  892. if (n > count)
  893. n = count;
  894. else
  895. *eof = 1;
  897. memcpy(buf, (char *)res + off, n);
  898. *start = buf;
  899. }
  901. return n;
  902. }
  904. void __init
  905. proc_prep_residual_init(void)
  906. {
  907. if (res->ResidualLength)
  908. create_proc_read_entry("residual", S_IRUGO, NULL,
  909. proc_prep_residual_read, NULL);
  910. }
  912. __initcall(proc_prep_residual_init);
  913. #endif