/* * Code to deal with the PReP residual data. * * Written by: Cort Dougan (cort@cs.nmt.edu) * Improved _greatly_ and rewritten by Gabriel Paubert (paubert@iram.es) * * This file is based on the following documentation: * * IBM Power Personal Systems Architecture * Residual Data * Document Number: PPS-AR-FW0001 * * This file is subject to the terms and conditions of the GNU General Public * License. See the file COPYING in the main directory of this archive * for more details. * */ #include <linux/string.h> #include <asm/residual.h> #include <asm/pnp.h> #include <asm/byteorder.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/stddef.h> #include <linux/unistd.h> #include <linux/ptrace.h> #include <linux/slab.h> #include <linux/user.h> #include <linux/a.out.h> #include <linux/tty.h> #include <linux/major.h> #include <linux/interrupt.h> #include <linux/reboot.h> #include <linux/init.h> #include <linux/ioport.h> #include <linux/pci.h> #include <linux/ide.h> #include <asm/sections.h> #include <asm/mmu.h> #include <asm/io.h> #include <asm/pgtable.h> #include <asm/ide.h> unsigned char __res[sizeof(RESIDUAL)] = {0,}; RESIDUAL *res = (RESIDUAL *)&__res; char * PnP_BASE_TYPES[] __initdata = { "Reserved", "MassStorageDevice", "NetworkInterfaceController", "DisplayController", "MultimediaController", "MemoryController", "BridgeController", "CommunicationsDevice", "SystemPeripheral", "InputDevice", "ServiceProcessor" }; /* Device Sub Type Codes */ unsigned char * PnP_SUB_TYPES[] __initdata = { "\001\000SCSIController", "\001\001IDEController", "\001\002FloppyController", "\001\003IPIController", "\001\200OtherMassStorageController", "\002\000EthernetController", "\002\001TokenRingController", "\002\002FDDIController", "\002\0x80OtherNetworkController", "\003\000VGAController", "\003\001SVGAController", "\003\002XGAController", "\003\200OtherDisplayController", "\004\000VideoController", "\004\001AudioController", "\004\200OtherMultimediaController", "\005\000RAM", "\005\001FLASH", "\005\200OtherMemoryDevice", "\006\000HostProcessorBridge", "\006\001ISABridge", "\006\002EISABridge", "\006\003MicroChannelBridge", "\006\004PCIBridge", "\006\005PCMCIABridge", "\006\006VMEBridge", "\006\200OtherBridgeDevice", "\007\000RS232Device", "\007\001ATCompatibleParallelPort", "\007\200OtherCommunicationsDevice", "\010\000ProgrammableInterruptController", "\010\001DMAController", "\010\002SystemTimer", "\010\003RealTimeClock", "\010\004L2Cache", "\010\005NVRAM", "\010\006PowerManagement", "\010\007CMOS", "\010\010OperatorPanel", "\010\011ServiceProcessorClass1", "\010\012ServiceProcessorClass2", "\010\013ServiceProcessorClass3", "\010\014GraphicAssist", "\010\017SystemPlanar", "\010\200OtherSystemPeripheral", "\011\000KeyboardController", "\011\001Digitizer", "\011\002MouseController", "\011\003TabletController", "\011\0x80OtherInputController", "\012\000GeneralMemoryController", NULL }; /* Device Interface Type Codes */ unsigned char * PnP_INTERFACES[] __initdata = { "\000\000\000General", "\001\000\000GeneralSCSI", "\001\001\000GeneralIDE", "\001\001\001ATACompatible", "\001\002\000GeneralFloppy", "\001\002\001Compatible765", "\001\002\002NS398_Floppy", /* NS Super I/O wired to use index register at port 398 and data register at port 399 */ "\001\002\003NS26E_Floppy", /* Ports 26E and 26F */ "\001\002\004NS15C_Floppy", /* Ports 15C and 15D */ "\001\002\005NS2E_Floppy", /* Ports 2E and 2F */ "\001\002\006CHRP_Floppy", /* CHRP Floppy in PR*P system */ "\001\003\000GeneralIPI", "\002\000\000GeneralEther", "\002\001\000GeneralToken", "\002\002\000GeneralFDDI", "\003\000\000GeneralVGA", "\003\001\000GeneralSVGA", "\003\002\000GeneralXGA", "\004\000\000GeneralVideo", "\004\001\000GeneralAudio", "\004\001\001CS4232Audio", /* CS 4232 Plug 'n Play Configured */ "\005\000\000GeneralRAM", /* This one is obviously wrong ! */ "\005\000\000PCIMemoryController", /* PCI Config Method */ "\005\000\001RS6KMemoryController", /* RS6K Config Method */ "\005\001\000GeneralFLASH", "\006\000\000GeneralHostBridge", "\006\001\000GeneralISABridge", "\006\002\000GeneralEISABridge", "\006\003\000GeneralMCABridge", /* GeneralPCIBridge = 0, */ "\006\004\000PCIBridgeDirect", "\006\004\001PCIBridgeIndirect", "\006\004\002PCIBridgeRS6K", "\006\005\000GeneralPCMCIABridge", "\006\006\000GeneralVMEBridge", "\007\000\000GeneralRS232", "\007\000\001COMx", "\007\000\002Compatible16450", "\007\000\003Compatible16550", "\007\000\004NS398SerPort", /* NS Super I/O wired to use index register at port 398 and data register at port 399 */ "\007\000\005NS26ESerPort", /* Ports 26E and 26F */ "\007\000\006NS15CSerPort", /* Ports 15C and 15D */ "\007\000\007NS2ESerPort", /* Ports 2E and 2F */ "\007\001\000GeneralParPort", "\007\001\001LPTx", "\007\001\002NS398ParPort", /* NS Super I/O wired to use index register at port 398 and data register at port 399 */ "\007\001\003NS26EParPort", /* Ports 26E and 26F */ "\007\001\004NS15CParPort", /* Ports 15C and 15D */ "\007\001\005NS2EParPort", /* Ports 2E and 2F */ "\010\000\000GeneralPIC", "\010\000\001ISA_PIC", "\010\000\002EISA_PIC", "\010\000\003MPIC", "\010\000\004RS6K_PIC", "\010\001\000GeneralDMA", "\010\001\001ISA_DMA", "\010\001\002EISA_DMA", "\010\002\000GeneralTimer", "\010\002\001ISA_Timer", "\010\002\002EISA_Timer", "\010\003\000GeneralRTC", "\010\003\001ISA_RTC", "\010\004\001StoreThruOnly", "\010\004\002StoreInEnabled", "\010\004\003RS6KL2Cache", "\010\005\000IndirectNVRAM", /* Indirectly addressed */ "\010\005\001DirectNVRAM", /* Memory Mapped */ "\010\005\002IndirectNVRAM24", /* Indirectly addressed - 24 bit */ "\010\006\000GeneralPowerManagement", "\010\006\001EPOWPowerManagement", "\010\006\002PowerControl", // d1378 "\010\007\000GeneralCMOS", "\010\010\000GeneralOPPanel", "\010\010\001HarddiskLight", "\010\010\002CDROMLight", "\010\010\003PowerLight", "\010\010\004KeyLock", "\010\010\005ANDisplay", /* AlphaNumeric Display */ "\010\010\006SystemStatusLED", /* 3 digit 7 segment LED */ "\010\010\007CHRP_SystemStatusLED", /* CHRP LEDs in PR*P system */ "\010\011\000GeneralServiceProcessor", "\010\012\000GeneralServiceProcessor", "\010\013\000GeneralServiceProcessor", "\010\014\001TransferData", "\010\014\002IGMC32", "\010\014\003IGMC64", "\010\017\000GeneralSystemPlanar", /* 10/5/95 */ NULL }; static const unsigned char __init *PnP_SUB_TYPE_STR(unsigned char BaseType, unsigned char SubType) { unsigned char ** s=PnP_SUB_TYPES; while (*s && !((*s)[0]==BaseType && (*s)[1]==SubType)) s++; if (*s) return *s+2; else return("Unknown !"); }; static const unsigned char __init *PnP_INTERFACE_STR(unsigned char BaseType, unsigned char SubType, unsigned char Interface) { unsigned char ** s=PnP_INTERFACES; while (*s && !((*s)[0]==BaseType && (*s)[1]==SubType && (*s)[2]==Interface)) s++; if (*s) return *s+3; else return NULL; }; static void __init printsmallvendor(PnP_TAG_PACKET *pkt, int size) { int i, c; char decomp[4]; #define p pkt->S14_Pack.S14_Data.S14_PPCPack switch(p.Type) { case 1: /* Decompress first 3 chars */ c = *(unsigned short *)p.PPCData; decomp[0]='A'-1+((c>>10)&0x1F); decomp[1]='A'-1+((c>>5)&0x1F); decomp[2]='A'-1+(c&0x1F); decomp[3]=0; printk(" Chip identification: %s%4.4X\n", decomp, ld_le16((unsigned short *)(p.PPCData+2))); break; default: printk(" Small vendor item type 0x%2.2x, data (hex): ", p.Type); for(i=0; i<size-2; i++) printk("%2.2x ", p.PPCData[i]); printk("\n"); break; } #undef p } static void __init printsmallpacket(PnP_TAG_PACKET * pkt, int size) { static const unsigned char * intlevel[] = {"high", "low"}; static const unsigned char * intsense[] = {"edge", "level"}; switch (tag_small_item_name(pkt->S1_Pack.Tag)) { case PnPVersion: printk(" PnPversion 0x%x.%x\n", pkt->S1_Pack.Version[0], /* How to interpret version ? */ pkt->S1_Pack.Version[1]); break; // case Logicaldevice: break; // case CompatibleDevice: break; case IRQFormat: #define p pkt->S4_Pack printk(" IRQ Mask 0x%4.4x, %s %s sensitive\n", ld_le16((unsigned short *)p.IRQMask), intlevel[(size>3) ? !(p.IRQInfo&0x05) : 0], intsense[(size>3) ? !(p.IRQInfo&0x03) : 0]); #undef p break; case DMAFormat: #define p pkt->S5_Pack printk(" DMA channel mask 0x%2.2x, info 0x%2.2x\n", p.DMAMask, p.DMAInfo); #undef p break; case StartDepFunc: printk("Start dependent function:\n"); break; case EndDepFunc: printk("End dependent function\n"); break; case IOPort: #define p pkt->S8_Pack printk(" Variable (%d decoded bits) I/O port\n" " from 0x%4.4x to 0x%4.4x, alignment %d, %d ports\n", p.IOInfo&ISAAddr16bit?16:10, ld_le16((unsigned short *)p.RangeMin), ld_le16((unsigned short *)p.RangeMax), p.IOAlign, p.IONum); #undef p break; case FixedIOPort: #define p pkt->S9_Pack printk(" Fixed (10 decoded bits) I/O port from %3.3x to %3.3x\n", (p.Range[1]<<8)|p.Range[0], ((p.Range[1]<<8)|p.Range[0])+p.IONum-1); #undef p break; case Res1: case Res2: case Res3: printk(" Undefined packet type %d!\n", tag_small_item_name(pkt->S1_Pack.Tag)); break; case SmallVendorItem: printsmallvendor(pkt,size); break; default: printk(" Type 0x2.2x%d, size=%d\n", pkt->S1_Pack.Tag, size); break; } } static void __init printlargevendor(PnP_TAG_PACKET * pkt, int size) { static const unsigned char * addrtype[] = {"I/O", "Memory", "System"}; static const unsigned char * inttype[] = {"8259", "MPIC", "RS6k BUID %d"}; static const unsigned char * convtype[] = {"Bus Memory", "Bus I/O", "DMA"}; static const unsigned char * transtype[] = {"direct", "mapped", "direct-store segment"}; static const unsigned char * L2type[] = {"WriteThru", "CopyBack"}; static const unsigned char * L2assoc[] = {"DirectMapped", "2-way set"}; int i; char tmpstr[30], *t; #define p pkt->L4_Pack.L4_Data.L4_PPCPack switch(p.Type) { case 2: printk(" %d K %s %s L2 cache, %d/%d bytes line/sector size\n", ld_le32((unsigned int *)p.PPCData), L2type[p.PPCData[10]-1], L2assoc[p.PPCData[4]-1], ld_le16((unsigned short *)p.PPCData+3), ld_le16((unsigned short *)p.PPCData+4)); break; case 3: printk(" PCI Bridge parameters\n" " ConfigBaseAddress %0x\n" " ConfigBaseData %0x\n" " Bus number %d\n", ld_le32((unsigned int *)p.PPCData), ld_le32((unsigned int *)(p.PPCData+8)), p.PPCData[16]); for(i=20; i<size-4; i+=12) { int j, first; if(p.PPCData[i]) printk(" PCI Slot %d", p.PPCData[i]); else printk (" Integrated PCI device"); for(j=0, first=1, t=tmpstr; j<4; j++) { int line=ld_le16((unsigned short *)(p.PPCData+i+4)+j); if(line!=0xffff){ if(first) first=0; else *t++='/'; *t++='A'+j; } } *t='\0'; printk(" DevFunc 0x%x interrupt line(s) %s routed to", p.PPCData[i+1],tmpstr); sprintf(tmpstr, inttype[p.PPCData[i+2]-1], p.PPCData[i+3]); printk(" %s line(s) ", tmpstr); for(j=0, first=1, t=tmpstr; j<4; j++) { int line=ld_le16((unsigned short *)(p.PPCData+i+4)+j); if(line!=0xffff){ if(first) first=0; else *t++='/'; t+=sprintf(t,"%d(%c)", line&0x7fff, line&0x8000?'E':'L'); } } printk("%s\n",tmpstr); } break; case 5: printk(" Bridge address translation, %s decoding:\n" " Processor Bus Size Conversion Translation\n" " 0x%8.8x 0x%8.8x 0x%8.8x %s %s\n", p.PPCData[0]&1 ? "positive" : "subtractive", ld_le32((unsigned int *)p.PPCData+1), ld_le32((unsigned int *)p.PPCData+3), ld_le32((unsigned int *)p.PPCData+5), convtype[p.PPCData[2]-1], transtype[p.PPCData[1]-1]); break; case 6: printk(" Bus speed %d Hz, %d slot(s)\n", ld_le32((unsigned int *)p.PPCData), p.PPCData[4]); break; case 7: printk(" SCSI buses: %d, id(s):", p.PPCData[0]); for(i=1; i<=p.PPCData[0]; i++) printk(" %d%c", p.PPCData[i], i==p.PPCData[0] ? '\n' : ','); break; case 9: printk(" %s address (%d bits), at 0x%x size 0x%x bytes\n", addrtype[p.PPCData[0]-1], p.PPCData[1], ld_le32((unsigned int *)(p.PPCData+4)), ld_le32((unsigned int *)(p.PPCData+12))); break; case 10: sprintf(tmpstr, inttype[p.PPCData[0]-1], p.PPCData[1]); printk(" ISA interrupts routed to %s\n" " lines", tmpstr); for(i=0; i<16; i++) { int line=ld_le16((unsigned short *)p.PPCData+i+1); if (line!=0xffff) printk(" %d(IRQ%d)", line, i); } printk("\n"); break; default: printk(" Large vendor item type 0x%2.2x\n Data (hex):", p.Type); for(i=0; i<size-4; i++) printk(" %2.2x", p.PPCData[i]); printk("\n"); #undef p } } static void __init printlargepacket(PnP_TAG_PACKET * pkt, int size) { switch (tag_large_item_name(pkt->S1_Pack.Tag)) { case LargeVendorItem: printlargevendor(pkt, size); break; default: printk(" Type 0x2.2x%d, size=%d\n", pkt->S1_Pack.Tag, size); break; } } static void __init printpackets(PnP_TAG_PACKET * pkt, const char * cat) { if (pkt->S1_Pack.Tag== END_TAG) { printk(" No packets describing %s resources.\n", cat); return; } printk( " Packets describing %s resources:\n",cat); do { int size; if (tag_type(pkt->S1_Pack.Tag)) { size= 3 + pkt->L1_Pack.Count0 + pkt->L1_Pack.Count1*256; printlargepacket(pkt, size); } else { size=tag_small_count(pkt->S1_Pack.Tag)+1; printsmallpacket(pkt, size); } pkt = (PnP_TAG_PACKET *)((unsigned char *) pkt + size); } while (pkt->S1_Pack.Tag != END_TAG); } void __init print_residual_device_info(void) { int i; PPC_DEVICE *dev; #define did dev->DeviceId /* make sure we have residual data first */ if (!have_residual_data) return; printk("Residual: %ld devices\n", res->ActualNumDevices); for ( i = 0; i < res->ActualNumDevices ; i++) { char decomp[4], sn[20]; const char * s; dev = &res->Devices[i]; s = PnP_INTERFACE_STR(did.BaseType, did.SubType, did.Interface); if(!s) { sprintf(sn, "interface %d", did.Interface); s=sn; } if ( did.BusId & PCIDEVICE ) printk("PCI Device, Bus %d, DevFunc 0x%x:", dev->BusAccess.PCIAccess.BusNumber, dev->BusAccess.PCIAccess.DevFuncNumber); if ( did.BusId & PNPISADEVICE ) printk("PNPISA Device:"); if ( did.BusId & ISADEVICE ) printk("ISA Device, Slot %d, LogicalDev %d:", dev->BusAccess.ISAAccess.SlotNumber, dev->BusAccess.ISAAccess.LogicalDevNumber); if ( did.BusId & EISADEVICE ) printk("EISA Device:"); if ( did.BusId & PROCESSORDEVICE ) printk("ProcBus Device, Bus %d, BUID %d: ", dev->BusAccess.ProcBusAccess.BusNumber, dev->BusAccess.ProcBusAccess.BUID); if ( did.BusId & PCMCIADEVICE ) printk("PCMCIA "); if ( did.BusId & VMEDEVICE ) printk("VME "); if ( did.BusId & MCADEVICE ) printk("MCA "); if ( did.BusId & MXDEVICE ) printk("MX "); /* Decompress first 3 chars */ decomp[0]='A'-1+((did.DevId>>26)&0x1F); decomp[1]='A'-1+((did.DevId>>21)&0x1F); decomp[2]='A'-1+((did.DevId>>16)&0x1F); decomp[3]=0; printk(" %s%4.4lX, %s, %s, %s\n", decomp, did.DevId&0xffff, PnP_BASE_TYPES[did.BaseType], PnP_SUB_TYPE_STR(did.BaseType,did.SubType), s); if ( dev->AllocatedOffset ) printpackets( (union _PnP_TAG_PACKET *) &res->DevicePnPHeap[dev->AllocatedOffset], "allocated"); if ( dev->PossibleOffset ) printpackets( (union _PnP_TAG_PACKET *) &res->DevicePnPHeap[dev->PossibleOffset], "possible"); if ( dev->CompatibleOffset ) printpackets( (union _PnP_TAG_PACKET *) &res->DevicePnPHeap[dev->CompatibleOffset], "compatible"); } } #if 0 static void __init printVPD(void) { #define vpd res->VitalProductData int ps=vpd.PageSize, i, j; static const char* Usage[]={ "FirmwareStack", "FirmwareHeap", "FirmwareCode", "BootImage", "Free", "Unpopulated", "ISAAddr", "PCIConfig", "IOMemory", "SystemIO", "SystemRegs", "PCIAddr", "UnPopSystemRom", "SystemROM", "ResumeBlock", "Other" }; static const unsigned char *FWMan[]={ "IBM", "Motorola", "FirmWorks", "Bull" }; static const unsigned char *FWFlags[]={ "Conventional", "OpenFirmware", "Diagnostics", "LowDebug", "MultiBoot", "LowClient", "Hex41", "FAT", "ISO9660", "SCSI_ID_Override", "Tape_Boot", "FW_Boot_Path" }; static const unsigned char *ESM[]={ "Port92", "PCIConfigA8", "FF001030", "????????" }; static const unsigned char *SIOM[]={ "Port850", "????????", "PCIConfigA8", "????????" }; printk("Model: %s\n",vpd.PrintableModel); printk("Serial: %s\n", vpd.Serial); printk("FirmwareSupplier: %s\n", FWMan[vpd.FirmwareSupplier]); printk("FirmwareFlags:"); for(j=0; j<12; j++) { if (vpd.FirmwareSupports & (1<<j)) { printk(" %s%c", FWFlags[j], vpd.FirmwareSupports&(-2<<j) ? ',' : '\n'); } } printk("NVRamSize: %ld\n", vpd.NvramSize); printk("SIMMslots: %ld\n", vpd.NumSIMMSlots); printk("EndianSwitchMethod: %s\n", ESM[vpd.EndianSwitchMethod>2 ? 2 : vpd.EndianSwitchMethod]); printk("SpreadIOMethod: %s\n", SIOM[vpd.SpreadIOMethod>3 ? 3 : vpd.SpreadIOMethod]); printk("Processor/Bus frequencies (Hz): %ld/%ld\n", vpd.ProcessorHz, vpd.ProcessorBusHz); printk("Time Base Divisor: %ld\n", vpd.TimeBaseDivisor); printk("WordWidth, PageSize: %ld, %d\n", vpd.WordWidth, ps); printk("Cache sector size, Lock granularity: %ld, %ld\n", vpd.CoherenceBlockSize, vpd.GranuleSize); for (i=0; i<res->ActualNumMemSegs; i++) { int mask=res->Segs[i].Usage, first, j; printk("%8.8lx-%8.8lx ", res->Segs[i].BasePage*ps, (res->Segs[i].PageCount+res->Segs[i].BasePage)*ps-1); for(j=15, first=1; j>=0; j--) { if (mask&(1<<j)) { if (first) first=0; else printk(", "); printk("%s", Usage[j]); } } printk("\n"); } } /* * Spit out some info about residual data */ void print_residual_device_info(void) { int i; union _PnP_TAG_PACKET *pkt; PPC_DEVICE *dev; #define did dev->DeviceId /* make sure we have residual data first */ if (!have_residual_data) return; printk("Residual: %ld devices\n", res->ActualNumDevices); for ( i = 0; i < res->ActualNumDevices ; i++) { dev = &res->Devices[i]; /* * pci devices */ if ( did.BusId & PCIDEVICE ) { printk("PCI Device:"); /* unknown vendor */ if ( !strncmp( "Unknown", pci_strvendor(did.DevId>>16), 7) ) printk(" id %08lx types %d/%d", did.DevId, did.BaseType, did.SubType); /* known vendor */ else printk(" %s %s", pci_strvendor(did.DevId>>16), pci_strdev(did.DevId>>16, did.DevId&0xffff) ); if ( did.BusId & PNPISADEVICE ) { printk(" pnp:"); /* get pnp info on the device */ pkt = (union _PnP_TAG_PACKET *) &res->DevicePnPHeap[dev->AllocatedOffset]; for (; pkt->S1_Pack.Tag != DF_END_TAG; pkt++ ) { if ( (pkt->S1_Pack.Tag == S4_Packet) || (pkt->S1_Pack.Tag == S4_Packet_flags) ) printk(" irq %02x%02x", pkt->S4_Pack.IRQMask[0], pkt->S4_Pack.IRQMask[1]); } } printk("\n"); continue; } /* * isa devices */ if ( did.BusId & ISADEVICE ) { printk("ISA Device: basetype: %d subtype: %d", did.BaseType, did.SubType); printk("\n"); continue; } /* * eisa devices */ if ( did.BusId & EISADEVICE ) { printk("EISA Device: basetype: %d subtype: %d", did.BaseType, did.SubType); printk("\n"); continue; } /* * proc bus devices */ if ( did.BusId & PROCESSORDEVICE ) { printk("ProcBus Device: basetype: %d subtype: %d", did.BaseType, did.SubType); printk("\n"); continue; } /* * pcmcia devices */ if ( did.BusId & PCMCIADEVICE ) { printk("PCMCIA Device: basetype: %d subtype: %d", did.BaseType, did.SubType); printk("\n"); continue; } printk("Unknown bus access device: busid %lx\n", did.BusId); } } #endif /* Returns the device index in the residual data, any of the search items may be set as -1 for wildcard, DevID number field (second halfword) is big endian ! Examples: - search for the Interrupt controller (8259 type), 2 methods: 1) i8259 = residual_find_device(~0, NULL, SystemPeripheral, ProgrammableInterruptController, ISA_PIC, 0); 2) i8259 = residual_find_device(~0, "PNP0000", -1, -1, -1, 0) - search for the first two serial devices, whatever their type) iserial1 = residual_find_device(~0,NULL, CommunicationsDevice, RS232Device, -1, 0) iserial2 = residual_find_device(~0,NULL, CommunicationsDevice, RS232Device, -1, 1) - but search for typical COM1 and COM2 is not easy due to the fact that the interface may be anything and the name "PNP0500" or "PNP0501". Quite bad. */ /* devid are easier to uncompress than to compress, so to minimize bloat in this rarely used area we unencode and compare */ /* in residual data number is big endian in the device table and little endian in the heap, so we use two parameters to avoid writing two very similar functions */ static int __init same_DevID(unsigned short vendor, unsigned short Number, char * str) { static unsigned const char hexdigit[]="0123456789ABCDEF"; if (strlen(str)!=7) return 0; if ( ( ((vendor>>10)&0x1f)+'A'-1 == str[0]) && ( ((vendor>>5)&0x1f)+'A'-1 == str[1]) && ( (vendor&0x1f)+'A'-1 == str[2]) && (hexdigit[(Number>>12)&0x0f] == str[3]) && (hexdigit[(Number>>8)&0x0f] == str[4]) && (hexdigit[(Number>>4)&0x0f] == str[5]) && (hexdigit[Number&0x0f] == str[6]) ) return 1; return 0; } PPC_DEVICE __init *residual_find_device(unsigned long BusMask, unsigned char * DevID, int BaseType, int SubType, int Interface, int n) { int i; if (!have_residual_data) return NULL; for (i=0; i<res->ActualNumDevices; i++) { #define Dev res->Devices[i].DeviceId if ( (Dev.BusId&BusMask) && (BaseType==-1 || Dev.BaseType==BaseType) && (SubType==-1 || Dev.SubType==SubType) && (Interface==-1 || Dev.Interface==Interface) && (DevID==NULL || same_DevID((Dev.DevId>>16)&0xffff, Dev.DevId&0xffff, DevID)) && !(n--) ) return res->Devices+i; #undef Dev } return NULL; } PPC_DEVICE __init *residual_find_device_id(unsigned long BusMask, unsigned short DevID, int BaseType, int SubType, int Interface, int n) { int i; if (!have_residual_data) return NULL; for (i=0; i<res->ActualNumDevices; i++) { #define Dev res->Devices[i].DeviceId if ( (Dev.BusId&BusMask) && (BaseType==-1 || Dev.BaseType==BaseType) && (SubType==-1 || Dev.SubType==SubType) && (Interface==-1 || Dev.Interface==Interface) && (DevID==0xffff || (Dev.DevId&0xffff) == DevID) && !(n--) ) return res->Devices+i; #undef Dev } return NULL; } static int __init residual_scan_pcibridge(PnP_TAG_PACKET * pkt, struct pci_dev *dev) { int irq = -1; #define data pkt->L4_Pack.L4_Data.L4_PPCPack.PPCData if (dev->bus->number == data[16]) { int i, size; size = 3 + ld_le16((u_short *) (&pkt->L4_Pack.Count0)); for (i = 20; i < size - 4; i += 12) { unsigned char pin; int line_irq; if (dev->devfn != data[i + 1]) continue; pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); if (pin) { line_irq = ld_le16((unsigned short *) (&data[i + 4 + 2 * (pin - 1)])); irq = (line_irq == 0xffff) ? 0 : line_irq & 0x7fff; } else irq = 0; break; } } #undef data return irq; } int __init residual_pcidev_irq(struct pci_dev *dev) { int i = 0; int irq = -1; PPC_DEVICE *bridge; while ((bridge = residual_find_device (-1, NULL, BridgeController, PCIBridge, -1, i++))) { PnP_TAG_PACKET *pkt; if (bridge->AllocatedOffset) { pkt = PnP_find_large_vendor_packet(res->DevicePnPHeap + bridge->AllocatedOffset, 3, 0); if (!pkt) continue; irq = residual_scan_pcibridge(pkt, dev); if (irq != -1) break; } } return (irq < 0) ? 0 : irq; } void __init residual_irq_mask(char *irq_edge_mask_lo, char *irq_edge_mask_hi) { PPC_DEVICE *dev; int i = 0; unsigned short irq_mask = 0x000; /* default to edge */ while ((dev = residual_find_device(-1, NULL, -1, -1, -1, i++))) { PnP_TAG_PACKET *pkt; unsigned short mask; int size; int offset = dev->AllocatedOffset; if (!offset) continue; pkt = PnP_find_packet(res->DevicePnPHeap + offset, IRQFormat, 0); if (!pkt) continue; size = tag_small_count(pkt->S1_Pack.Tag) + 1; mask = ld_le16((unsigned short *)pkt->S4_Pack.IRQMask); if (size > 3 && (pkt->S4_Pack.IRQInfo & 0x0c)) irq_mask |= mask; } *irq_edge_mask_lo = irq_mask & 0xff; *irq_edge_mask_hi = irq_mask >> 8; } unsigned int __init residual_isapic_addr(void) { PPC_DEVICE *isapic; PnP_TAG_PACKET *pkt; unsigned int addr; isapic = residual_find_device(~0, NULL, SystemPeripheral, ProgrammableInterruptController, ISA_PIC, 0); if (!isapic) goto unknown; pkt = PnP_find_large_vendor_packet(res->DevicePnPHeap + isapic->AllocatedOffset, 9, 0); if (!pkt) goto unknown; #define p pkt->L4_Pack.L4_Data.L4_PPCPack /* Must be 32-bit system address */ if (!((p.PPCData[0] == 3) && (p.PPCData[1] == 32))) goto unknown; /* It doesn't seem to work where length != 1 (what can I say? :-/ ) */ if (ld_le32((unsigned int *)(p.PPCData + 12)) != 1) goto unknown; addr = ld_le32((unsigned int *) (p.PPCData + 4)); #undef p return addr; unknown: return 0; } PnP_TAG_PACKET *PnP_find_packet(unsigned char *p, unsigned packet_tag, int n) { unsigned mask, masked_tag, size; if(!p) return NULL; if (tag_type(packet_tag)) mask=0xff; else mask=0xF8; masked_tag = packet_tag&mask; for(; *p != END_TAG; p+=size) { if ((*p & mask) == masked_tag && !(n--)) return (PnP_TAG_PACKET *) p; if (tag_type(*p)) size=ld_le16((unsigned short *)(p+1))+3; else size=tag_small_count(*p)+1; } return NULL; /* not found */ } PnP_TAG_PACKET __init *PnP_find_small_vendor_packet(unsigned char *p, unsigned packet_type, int n) { int next=0; while (p) { p = (unsigned char *) PnP_find_packet(p, 0x70, next); if (p && p[1]==packet_type && !(n--)) return (PnP_TAG_PACKET *) p; next = 1; }; return NULL; /* not found */ } PnP_TAG_PACKET __init *PnP_find_large_vendor_packet(unsigned char *p, unsigned packet_type, int n) { int next=0; while (p) { p = (unsigned char *) PnP_find_packet(p, 0x84, next); if (p && p[3]==packet_type && !(n--)) return (PnP_TAG_PACKET *) p; next = 1; }; return NULL; /* not found */ } #ifdef CONFIG_PROC_PREPRESIDUAL static int proc_prep_residual_read(char * buf, char ** start, off_t off, int count, int *eof, void *data) { int n; n = res->ResidualLength - off; if (n < 0) { *eof = 1; n = 0; } else { if (n > count) n = count; else *eof = 1; memcpy(buf, (char *)res + off, n); *start = buf; } return n; } int __init proc_prep_residual_init(void) { if (have_residual_data) create_proc_read_entry("residual", S_IRUGO, NULL, proc_prep_residual_read, NULL); return 0; } __initcall(proc_prep_residual_init); #endif