Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/pci/pci_subr.c

953 lines
27 KiB
C
Raw Normal View History

use a symbolic definition for the PCI subsystem ID
1998-12-21 23:56:06 +03:00
/* $NetBSD: pci_subr.c,v 1.31 1998/12/21 20:56:06 drochner Exp $ */
new RCS ID format.
1994-10-27 07:14:23 +03:00
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
/*
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
* Copyright (c) 1997 Zubin D. Dittia. All rights reserved.
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
* Copyright (c) 1995, 1996, 1998
* Christopher G. Demetriou. All rights reserved.
Make copyright notices with my name consistent.
1998-08-15 07:02:31 +04:00
* Copyright (c) 1994 Charles M. Hannum. All rights reserved.
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
Make copyright notices with my name consistent.
1998-08-15 07:02:31 +04:00
* This product includes software developed by Charles M. Hannum.
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
* PCI autoconfiguration support functions.
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
*/
Declare PCIVERBOSE by defopt in files.pci. Include opt_pciverbose.h in pci_subr.c.
1997-09-13 12:49:50 +04:00
#include "opt_pciverbose.h"
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
#include <sys/param.h>
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
#include <sys/systm.h>
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
#include <sys/device.h>
Properly compute the region sizes in pci_conf_print(). Bug pointed out by Chris Demetriou.
1998-05-03 23:41:33 +04:00
#include <machine/intr.h>
include files from the correct places.
1995-01-27 08:44:29 +03:00
#include <dev/pci/pcireg.h>
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
#include <dev/pci/pcivar.h>
#ifdef PCIVERBOSE
#include <dev/pci/pcidevs.h>
#endif
Add PCI autoconfiguration support.
1994-08-09 04:47:46 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
static void pci_conf_print_common __P((pci_chipset_tag_t, pcitag_t,
const pcireg_t *regs));
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
static void pci_conf_print_bar __P((pci_chipset_tag_t, pcitag_t,
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
const pcireg_t *regs, int, const char *));
static void pci_conf_print_regs __P((const pcireg_t *regs, int first,
int pastlast));
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
static void pci_conf_print_type0 __P((pci_chipset_tag_t, pcitag_t,
const pcireg_t *regs));
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
static void pci_conf_print_type1 __P((pci_chipset_tag_t, pcitag_t,
const pcireg_t *regs));
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
static void pci_conf_print_type2 __P((pci_chipset_tag_t, pcitag_t,
const pcireg_t *regs));
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
/*
* Descriptions of known PCI classes and subclasses.
*
* Subclasses are described in the same way as classes, but have a
* NULL subclass pointer.
*/
struct pci_class {
char *name;
int val; /* as wide as pci_{,sub}class_t */
struct pci_class *subclasses;
};
struct pci_class pci_subclass_prehistoric[] = {
{ "miscellaneous", PCI_SUBCLASS_PREHISTORIC_MISC, },
{ "VGA", PCI_SUBCLASS_PREHISTORIC_VGA, },
{ 0 }
};
struct pci_class pci_subclass_mass_storage[] = {
{ "SCSI", PCI_SUBCLASS_MASS_STORAGE_SCSI, },
{ "IDE", PCI_SUBCLASS_MASS_STORAGE_IDE, },
{ "floppy", PCI_SUBCLASS_MASS_STORAGE_FLOPPY, },
{ "IPI", PCI_SUBCLASS_MASS_STORAGE_IPI, },
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
{ "RAID", PCI_SUBCLASS_MASS_STORAGE_RAID, },
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
{ "miscellaneous", PCI_SUBCLASS_MASS_STORAGE_MISC, },
{ 0 },
};
struct pci_class pci_subclass_network[] = {
{ "ethernet", PCI_SUBCLASS_NETWORK_ETHERNET, },
{ "token ring", PCI_SUBCLASS_NETWORK_TOKENRING, },
{ "FDDI", PCI_SUBCLASS_NETWORK_FDDI, },
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
{ "ATM", PCI_SUBCLASS_NETWORK_ATM, },
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
{ "miscellaneous", PCI_SUBCLASS_NETWORK_MISC, },
{ 0 },
};
struct pci_class pci_subclass_display[] = {
{ "VGA", PCI_SUBCLASS_DISPLAY_VGA, },
{ "XGA", PCI_SUBCLASS_DISPLAY_XGA, },
{ "miscellaneous", PCI_SUBCLASS_DISPLAY_MISC, },
{ 0 },
};
struct pci_class pci_subclass_multimedia[] = {
{ "video", PCI_SUBCLASS_MULTIMEDIA_VIDEO, },
{ "audio", PCI_SUBCLASS_MULTIMEDIA_AUDIO, },
{ "miscellaneous", PCI_SUBCLASS_MULTIMEDIA_MISC, },
{ 0 },
};
struct pci_class pci_subclass_memory[] = {
{ "RAM", PCI_SUBCLASS_MEMORY_RAM, },
{ "flash", PCI_SUBCLASS_MEMORY_FLASH, },
{ "miscellaneous", PCI_SUBCLASS_MEMORY_MISC, },
{ 0 },
};
struct pci_class pci_subclass_bridge[] = {
{ "host", PCI_SUBCLASS_BRIDGE_HOST, },
{ "ISA", PCI_SUBCLASS_BRIDGE_ISA, },
{ "EISA", PCI_SUBCLASS_BRIDGE_EISA, },
{ "MicroChannel", PCI_SUBCLASS_BRIDGE_MC, },
{ "PCI", PCI_SUBCLASS_BRIDGE_PCI, },
{ "PCMCIA", PCI_SUBCLASS_BRIDGE_PCMCIA, },
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
{ "NuBus", PCI_SUBCLASS_BRIDGE_NUBUS, },
{ "CardBus", PCI_SUBCLASS_BRIDGE_CARDBUS, },
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
{ "miscellaneous", PCI_SUBCLASS_BRIDGE_MISC, },
{ 0 },
};
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
struct pci_class pci_subclass_communications[] = {
{ "serial", PCI_SUBCLASS_COMMUNICATIONS_SERIAL, },
{ "parallel", PCI_SUBCLASS_COMMUNICATIONS_PARALLEL, },
{ "miscellaneous", PCI_SUBCLASS_COMMUNICATIONS_MISC, },
{ 0 },
};
struct pci_class pci_subclass_system[] = {
{ "8259 PIC", PCI_SUBCLASS_SYSTEM_PIC, },
{ "8237 DMA", PCI_SUBCLASS_SYSTEM_DMA, },
{ "8254 timer", PCI_SUBCLASS_SYSTEM_TIMER, },
{ "RTC", PCI_SUBCLASS_SYSTEM_RTC, },
{ "miscellaneous", PCI_SUBCLASS_SYSTEM_MISC, },
{ 0 },
};
struct pci_class pci_subclass_input[] = {
{ "keyboard", PCI_SUBCLASS_INPUT_KEYBOARD, },
{ "digitizer", PCI_SUBCLASS_INPUT_DIGITIZER, },
{ "mouse", PCI_SUBCLASS_INPUT_MOUSE, },
{ "miscellaneous", PCI_SUBCLASS_INPUT_MISC, },
{ 0 },
};
struct pci_class pci_subclass_dock[] = {
{ "generic", PCI_SUBCLASS_DOCK_GENERIC, },
{ "miscellaneous", PCI_SUBCLASS_DOCK_MISC, },
{ 0 },
};
struct pci_class pci_subclass_processor[] = {
{ "386", PCI_SUBCLASS_PROCESSOR_386, },
{ "486", PCI_SUBCLASS_PROCESSOR_486, },
{ "Pentium", PCI_SUBCLASS_PROCESSOR_PENTIUM, },
{ "Alpha", PCI_SUBCLASS_PROCESSOR_ALPHA, },
{ "PowerPC", PCI_SUBCLASS_PROCESSOR_POWERPC, },
{ "Co-processor", PCI_SUBCLASS_PROCESSOR_COPROC, },
{ 0 },
};
struct pci_class pci_subclass_serialbus[] = {
{ "Firewire", PCI_SUBCLASS_SERIALBUS_FIREWIRE, },
{ "ACCESS.bus", PCI_SUBCLASS_SERIALBUS_ACCESS, },
{ "SSA", PCI_SUBCLASS_SERIALBUS_SSA, },
{ "USB", PCI_SUBCLASS_SERIALBUS_USB, },
{ "Fiber Channel", PCI_SUBCLASS_SERIALBUS_FIBER, },
{ 0 },
};
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
struct pci_class pci_class[] = {
{ "prehistoric", PCI_CLASS_PREHISTORIC,
pci_subclass_prehistoric, },
{ "mass storage", PCI_CLASS_MASS_STORAGE,
pci_subclass_mass_storage, },
{ "network", PCI_CLASS_NETWORK,
pci_subclass_network, },
{ "display", PCI_CLASS_DISPLAY,
fix reference to incorrect struct (paste-o)
1995-06-21 07:56:09 +04:00
pci_subclass_display, },
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
{ "multimedia", PCI_CLASS_MULTIMEDIA,
pci_subclass_multimedia, },
{ "memory", PCI_CLASS_MEMORY,
pci_subclass_memory, },
{ "bridge", PCI_CLASS_BRIDGE,
pci_subclass_bridge, },
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
{ "communications", PCI_CLASS_COMMUNICATIONS,
pci_subclass_communications, },
{ "system", PCI_CLASS_SYSTEM,
pci_subclass_system, },
{ "input", PCI_CLASS_INPUT,
pci_subclass_input, },
{ "dock", PCI_CLASS_DOCK,
pci_subclass_dock, },
{ "processor", PCI_CLASS_PROCESSOR,
pci_subclass_processor, },
{ "serial bus", PCI_CLASS_SERIALBUS,
pci_subclass_serialbus, },
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
{ "undefined", PCI_CLASS_UNDEFINED,
0, },
{ 0 },
};
#ifdef PCIVERBOSE
/*
* Descriptions of of known vendors and devices ("products").
*/
struct pci_knowndev {
pci_vendor_id_t vendor;
pci_product_id_t product;
int flags;
char *vendorname, *productname;
};
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
#define PCI_KNOWNDEV_NOPROD 0x01 /* match on vendor only */
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
#include <dev/pci/pcidevs_data.h>
#endif /* PCIVERBOSE */
Add USB support. Supported so far: * UHCI and OHCI host controllers on PCI * Hubs * HID devices withe special drivers for mouse and keyboard * Printers
1998-07-12 23:51:55 +04:00
char *
pci_findvendor(id_reg)
pcireg_t id_reg;
{
#ifdef PCIVERBOSE
pci_vendor_id_t vendor = PCI_VENDOR(id_reg);
struct pci_knowndev *kdp;
kdp = pci_knowndevs;
while (kdp->vendorname != NULL) { /* all have vendor name */
if (kdp->vendor == vendor)
break;
kdp++;
}
return (kdp->vendorname);
#else
return (NULL);
#endif
}
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
void
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
pci_devinfo(id_reg, class_reg, showclass, cp)
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
pcireg_t id_reg, class_reg;
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
int showclass;
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
char *cp;
{
pci_vendor_id_t vendor;
pci_product_id_t product;
pci_class_t class;
pci_subclass_t subclass;
pci_interface_t interface;
pci_revision_t revision;
char *vendor_namep, *product_namep;
struct pci_class *classp, *subclassp;
#ifdef PCIVERBOSE
struct pci_knowndev *kdp;
oops; spaces -> tabs
1996-03-02 04:09:13 +03:00
const char *unmatched = "unknown ";
if not PCIVERBOSE, don't say that vendor/product is "unknown," just say what it is.
1996-03-02 04:07:47 +03:00
#else
oops; spaces -> tabs
1996-03-02 04:09:13 +03:00
const char *unmatched = "";
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
#endif
vendor = PCI_VENDOR(id_reg);
product = PCI_PRODUCT(id_reg);
class = PCI_CLASS(class_reg);
subclass = PCI_SUBCLASS(class_reg);
interface = PCI_INTERFACE(class_reg);
revision = PCI_REVISION(class_reg);
#ifdef PCIVERBOSE
kdp = pci_knowndevs;
while (kdp->vendorname != NULL) { /* all have vendor name */
if (kdp->vendor == vendor && (kdp->product == product ||
(kdp->flags & PCI_KNOWNDEV_NOPROD) != 0))
break;
kdp++;
}
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
if (kdp->vendorname == NULL)
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
vendor_namep = product_namep = NULL;
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
else {
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
vendor_namep = kdp->vendorname;
product_namep = (kdp->flags & PCI_KNOWNDEV_NOPROD) == 0 ?
kdp->productname : NULL;
}
#else /* PCIVERBOSE */
vendor_namep = product_namep = NULL;
#endif /* PCIVERBOSE */
classp = pci_class;
while (classp->name != NULL) {
if (class == classp->val)
break;
classp++;
}
subclassp = (classp->name != NULL) ? classp->subclasses : NULL;
while (subclassp && subclassp->name != NULL) {
if (subclass == subclassp->val)
break;
subclassp++;
}
if (vendor_namep == NULL)
backout kprintf changes
1996-10-13 05:37:04 +04:00
cp += sprintf(cp, "%svendor 0x%04x product 0x%04x",
if not PCIVERBOSE, don't say that vendor/product is "unknown," just say what it is.
1996-03-02 04:07:47 +03:00
unmatched, vendor, product);
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
else if (product_namep != NULL)
backout kprintf changes
1996-10-13 05:37:04 +04:00
cp += sprintf(cp, "%s %s", vendor_namep, product_namep);
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
else
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
cp += sprintf(cp, "%s product 0x%04x",
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
vendor_namep, product);
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
if (showclass) {
backout kprintf changes
1996-10-13 05:37:04 +04:00
cp += sprintf(cp, " (");
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
if (classp->name == NULL)
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
cp += sprintf(cp, "class 0x%02x, subclass 0x%02x",
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
class, subclass);
else {
if (subclassp == NULL || subclassp->name == NULL)
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
cp += sprintf(cp,
"%s subclass 0x%02x",
classp->name, subclass);
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
else
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
cp += sprintf(cp, "%s %s",
subclassp->name, classp->name);
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
}
fix multi-function device support, add new known classes/subclasses, and clean up class/subclass printing. From brb@brig.com via PR 3359.
1997-03-19 22:38:46 +03:00
if (interface != 0)
cp += sprintf(cp, ", interface 0x%02x", interface);
if (revision != 0)
cp += sprintf(cp, ", revision 0x%02x", revision);
cp += sprintf(cp, ")");
update PCIVERBOSE code in various ways: (1) remove the 'UNSUPP' keyword from the device list, because it can't be reasonably used (becuase different devices may be supported on different machines, for good reason). (2) enhance pci_devinfo so that class/subclass information is optional (so pci_devinfo can be used by drivers that match classes of devices, and want to look up the devices' names easily). (3) more known vendors and devices.
1996-01-23 00:08:09 +03:00
}
define and call "pci_devinfo()", which creates a string from the vendor & product IDs and class information, which is printed if device isn't found. Optionally (via "PCIVERBOSE" option) does table lookup to try to see if it knows what the device really is (informational only...).
1995-06-18 05:28:23 +04:00
}
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
/*
* Print out most of the PCI configuration registers. Typically used
* in a device attach routine like this:
*
* #ifdef MYDEV_DEBUG
* printf("%s: ", sc->sc_dev.dv_xname);
* pci_conf_print(pa->pa_pc, pa->pa_tag);
* #endif
*/
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
#define i2o(i) ((i) * 4)
#define o2i(o) ((o) / 4)
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
#define onoff(str, bit) \
printf(" %s: %s\n", (str), (rval & (bit)) ? "on" : "off");
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
static void
pci_conf_print_common(pc, tag, regs)
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
pci_chipset_tag_t pc;
pcitag_t tag;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
const pcireg_t *regs;
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
{
#ifdef PCIVERBOSE
struct pci_knowndev *kdp;
#endif
struct pci_class *classp, *subclassp;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
pcireg_t rval;
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
rval = regs[o2i(PCI_ID_REG)];
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
#ifndef PCIVERBOSE
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Vendor ID: 0x%04x\n", PCI_VENDOR(rval));
printf(" Device ID: 0x%04x\n", PCI_PRODUCT(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
#else
for (kdp = pci_knowndevs; kdp->vendorname != NULL; kdp++) {
if (kdp->vendor == PCI_VENDOR(rval) &&
(kdp->product == PCI_PRODUCT(rval) ||
(kdp->flags & PCI_KNOWNDEV_NOPROD) != 0)) {
break;
}
}
if (kdp->vendorname != NULL)
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Vendor Name: %s (0x%04x)\n", kdp->vendorname,
PCI_VENDOR(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
else
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Vendor ID: 0x%04x\n", PCI_VENDOR(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
if (kdp->productname != NULL && (kdp->flags & PCI_KNOWNDEV_NOPROD) == 0)
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Device Name: %s (0x%04x)\n", kdp->productname,
PCI_PRODUCT(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
else
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Device ID: 0x%04x\n", PCI_PRODUCT(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
#endif /* PCIVERBOSE */
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
rval = regs[o2i(PCI_COMMAND_STATUS_REG)];
printf(" Command register: 0x%04x\n", rval & 0xffff);
onoff("I/O space accesses", PCI_COMMAND_IO_ENABLE);
onoff("Memory space accesses", PCI_COMMAND_MEM_ENABLE);
onoff("Bus mastering", PCI_COMMAND_MASTER_ENABLE);
onoff("Special cycles", PCI_COMMAND_SPECIAL_ENABLE);
onoff("MWI transactions", PCI_COMMAND_INVALIDATE_ENABLE);
onoff("Palette snooping", PCI_COMMAND_PALETTE_ENABLE);
onoff("Parity error checking", PCI_COMMAND_PARITY_ENABLE);
onoff("Address/data stepping", PCI_COMMAND_STEPPING_ENABLE);
onoff("System error (SERR)", PCI_COMMAND_SERR_ENABLE);
onoff("Fast back-to-back transactions", PCI_COMMAND_BACKTOBACK_ENABLE);
printf(" Status register: 0x%04x\n", (rval >> 16) & 0xffff);
onoff("66 MHz capable", PCI_STATUS_66MHZ_SUPPORT);
onoff("User Definable Features (UDF) support", PCI_STATUS_UDF_SUPPORT);
onoff("Fast back-to-back capable", PCI_STATUS_BACKTOBACK_SUPPORT);
onoff("Data parity error detected", PCI_STATUS_PARITY_ERROR);
printf(" DEVSEL timing: ");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
switch (rval & PCI_STATUS_DEVSEL_MASK) {
case PCI_STATUS_DEVSEL_FAST:
printf("fast");
break;
case PCI_STATUS_DEVSEL_MEDIUM:
printf("medium");
break;
case PCI_STATUS_DEVSEL_SLOW:
printf("slow");
break;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
default:
printf("unknown/reserved"); /* XXX */
break;
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
}
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" (0x%x)\n", (rval & PCI_STATUS_DEVSEL_MASK) >> 25);
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
onoff("Slave signaled Target Abort", PCI_STATUS_TARGET_TARGET_ABORT);
onoff("Master received Target Abort", PCI_STATUS_MASTER_TARGET_ABORT);
onoff("Master received Master Abort", PCI_STATUS_MASTER_ABORT);
onoff("Asserted System Error (SERR)", PCI_STATUS_SPECIAL_ERROR);
onoff("Parity error detected", PCI_STATUS_PARITY_DETECT);
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
rval = regs[o2i(PCI_CLASS_REG)];
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
for (classp = pci_class; classp->name != NULL; classp++) {
if (PCI_CLASS(rval) == classp->val)
break;
}
subclassp = (classp->name != NULL) ? classp->subclasses : NULL;
while (subclassp && subclassp->name != NULL) {
if (PCI_SUBCLASS(rval) == subclassp->val)
break;
subclassp++;
}
if (classp->name != NULL) {
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Class Name: %s (0x%02x)\n", classp->name,
PCI_CLASS(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
if (subclassp != NULL && subclassp->name != NULL)
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Subclass Name: %s (0x%02x)\n",
subclassp->name, PCI_SUBCLASS(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
else
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Subclass ID: 0x%02x\n", PCI_SUBCLASS(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
} else {
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Class ID: 0x%02x\n", PCI_CLASS(rval));
printf(" Subclass ID: 0x%02x\n", PCI_SUBCLASS(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
}
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Interface: 0x%02x\n", PCI_INTERFACE(rval));
printf(" Revision ID: 0x%02x\n", PCI_REVISION(rval));
rval = regs[o2i(PCI_BHLC_REG)];
printf(" BIST: 0x%02x\n", PCI_BIST(rval));
printf(" Header Type: 0x%02x%s (0x%02x)\n", PCI_HDRTYPE_TYPE(rval),
PCI_HDRTYPE_MULTIFN(rval) ? "+multifunction" : "",
PCI_HDRTYPE(rval));
printf(" Latency Timer: 0x%02x\n", PCI_LATTIMER(rval));
printf(" Cache Line Size: 0x%02x\n", PCI_CACHELINE(rval));
}
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
static void
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_bar(pc, tag, regs, reg, name)
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
pci_chipset_tag_t pc;
pcitag_t tag;
const pcireg_t *regs;
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
int reg;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
const char *name;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
{
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
int s;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
pcireg_t mask, rval;
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
/*
* Section 6.2.5.1, `Address Maps', tells us that:
*
* 1) The builtin software should have already mapped the
* device in a reasonable way.
*
* 2) A device which wants 2^n bytes of memory will hardwire
* the bottom n bits of the address to 0. As recommended,
* we write all 1s and see what we get back.
*/
rval = regs[o2i(reg)];
if (rval != 0) {
Properly compute the region sizes in pci_conf_print(). Bug pointed out by Chris Demetriou.
1998-05-03 23:41:33 +04:00
/*
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
* The following sequence seems to make some devices
* (e.g. host bus bridges, which don't normally
* have their space mapped) very unhappy, to
* the point of crashing the system.
Properly compute the region sizes in pci_conf_print(). Bug pointed out by Chris Demetriou.
1998-05-03 23:41:33 +04:00
*
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
* Therefore, if the mapping register is zero to
* start out with, don't bother trying.
Properly compute the region sizes in pci_conf_print(). Bug pointed out by Chris Demetriou.
1998-05-03 23:41:33 +04:00
*/
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
s = splhigh();
pci_conf_write(pc, tag, reg, 0xffffffff);
mask = pci_conf_read(pc, tag, reg);
pci_conf_write(pc, tag, reg, rval);
splx(s);
} else
mask = 0;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
printf(" Base address register at 0x%02x", reg);
if (name)
printf(" (%s)", name);
printf("\n ");
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
if (rval == 0) {
printf("not implemented(?)\n");
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
return;
}
printf("type: ");
if (PCI_MAPREG_TYPE(rval) == PCI_MAPREG_TYPE_MEM) {
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
const char *type, *cache;
switch (PCI_MAPREG_MEM_TYPE(rval)) {
case PCI_MAPREG_MEM_TYPE_32BIT:
type = "32-bit";
break;
case PCI_MAPREG_MEM_TYPE_32BIT_1M:
type = "32-bit-1M";
break;
case PCI_MAPREG_MEM_TYPE_64BIT:
type = "64-bit";
break;
default:
type = "unknown (XXX)";
break;
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
}
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
if (PCI_MAPREG_MEM_CACHEABLE(rval))
cache = "";
else
cache = "non";
printf("%s %scacheable memory\n", type, cache);
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
printf(" base: 0x%08x, size: 0x%08x\n",
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
PCI_MAPREG_MEM_ADDR(rval),
PCI_MAPREG_MEM_SIZE(mask));
} else {
printf("i/o\n");
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
printf(" base: 0x%08x, size: 0x%08x\n",
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
PCI_MAPREG_IO_ADDR(rval),
PCI_MAPREG_IO_SIZE(mask));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
}
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
}
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
static void
pci_conf_print_regs(regs, first, pastlast)
const pcireg_t *regs;
int first, pastlast;
{
int off, needaddr, neednl;
needaddr = 1;
neednl = 0;
for (off = first; off < pastlast; off += 4) {
if ((off % 16) == 0 || needaddr) {
printf(" 0x%02x:", off);
needaddr = 0;
}
printf(" 0x%08x", regs[o2i(off)]);
neednl = 1;
if ((off % 16) == 12) {
printf("\n");
neednl = 0;
}
}
if (neednl)
printf("\n");
}
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
static void
pci_conf_print_type0(pc, tag, regs)
pci_chipset_tag_t pc;
pcitag_t tag;
const pcireg_t *regs;
{
int off;
pcireg_t rval;
for (off = PCI_MAPREG_START; off < PCI_MAPREG_END; off += 4)
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_bar(pc, tag, regs, off, NULL);
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Cardbus CIS Pointer: 0x%08x\n", regs[o2i(0x28)]);
use a symbolic definition for the PCI subsystem ID
1998-12-21 23:56:06 +03:00
rval = regs[o2i(PCI_SUBSYS_ID_REG)];
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Subsystem vendor ID: 0x%04x\n", PCI_VENDOR(rval));
printf(" Subsystem ID: 0x%04x\n", PCI_PRODUCT(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
/* XXX */
printf(" Expansion ROM Base Address: 0x%08x\n", regs[o2i(0x30)]);
printf(" Reserved @ 0x34: 0x%08x\n", regs[o2i(0x34)]);
printf(" Reserved @ 0x38: 0x%08x\n", regs[o2i(0x38)]);
rval = regs[o2i(PCI_INTERRUPT_REG)];
printf(" Maximum Latency: 0x%02x\n", (rval >> 24) & 0xff);
printf(" Minimum Grant: 0x%02x\n", (rval >> 16) & 0xff);
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf(" Interrupt pin: 0x%02x ", PCI_INTERRUPT_PIN(rval));
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
switch (PCI_INTERRUPT_PIN(rval)) {
case PCI_INTERRUPT_PIN_NONE:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("(none)");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
break;
case PCI_INTERRUPT_PIN_A:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("(pin A)");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
break;
case PCI_INTERRUPT_PIN_B:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("(pin B)");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
break;
case PCI_INTERRUPT_PIN_C:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("(pin C)");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
break;
case PCI_INTERRUPT_PIN_D:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("(pin D)");
break;
default:
printf("(???)");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
break;
}
printf("\n");
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf(" Interrupt line: 0x%02x\n", PCI_INTERRUPT_LINE(rval));
}
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
static void
pci_conf_print_type1(pc, tag, regs)
pci_chipset_tag_t pc;
pcitag_t tag;
const pcireg_t *regs;
{
int off;
pcireg_t rval;
/*
* XXX these need to be printed in more detail, need to be
* XXX checked against specs/docs, etc.
*
* This layout was cribbed from the TI PCI2030 PCI-to-PCI
* Bridge chip documentation, and may not be correct with
* respect to various standards. (XXX)
*/
for (off = 0x10; off < 0x18; off += 4)
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_bar(pc, tag, regs, off, NULL);
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf(" Primary bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 0) & 0xff);
printf(" Secondary bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 8) & 0xff);
printf(" Subordinate bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 16) & 0xff);
printf(" Secondary bus latency timer: 0x%02x\n",
(regs[o2i(0x18)] >> 24) & 0xff);
rval = (regs[o2i(0x1c)] >> 16) & 0xffff;
printf(" Secondary status register: 0x%04x\n", rval); /* XXX bits */
onoff("66 MHz capable", 0x0020);
onoff("User Definable Features (UDF) support", 0x0040);
onoff("Fast back-to-back capable", 0x0080);
onoff("Data parity error detected", 0x0100);
printf(" DEVSEL timing: ");
switch (rval & 0x0600) {
case 0x0000:
printf("fast");
break;
case 0x0200:
printf("medium");
break;
case 0x0400:
printf("slow");
break;
default:
printf("unknown/reserved"); /* XXX */
break;
}
printf(" (0x%x)\n", (rval & 0x0600) >> 9);
onoff("Signaled Target Abort", 0x0800);
onoff("Received Target Abort", 0x1000);
onoff("Received Master Abort", 0x2000);
onoff("System Error", 0x4000);
onoff("Parity Error", 0x8000);
/* XXX Print more prettily */
printf(" I/O region:\n");
printf(" base register: 0x%02x\n", (regs[o2i(0x1c)] >> 0) & 0xff);
printf(" limit register: 0x%02x\n", (regs[o2i(0x1c)] >> 8) & 0xff);
printf(" base upper 16 bits register: 0x%04x\n",
(regs[o2i(0x30)] >> 0) & 0xffff);
printf(" limit upper 16 bits register: 0x%04x\n",
(regs[o2i(0x30)] >> 16) & 0xffff);
/* XXX Print more prettily */
printf(" Memory region:\n");
printf(" base register: 0x%04x\n",
(regs[o2i(0x20)] >> 0) & 0xffff);
printf(" limit register: 0x%04x\n",
(regs[o2i(0x20)] >> 16) & 0xffff);
/* XXX Print more prettily */
printf(" Prefetchable memory region:\n");
printf(" base register: 0x%04x\n",
(regs[o2i(0x24)] >> 0) & 0xffff);
printf(" limit register: 0x%04x\n",
(regs[o2i(0x24)] >> 16) & 0xffff);
printf(" base upper 32 bits register: 0x%08x\n", regs[o2i(0x28)]);
printf(" limit upper 32 bits register: 0x%08x\n", regs[o2i(0x2c)]);
printf(" Reserved @ 0x34: 0x%08x\n", regs[o2i(0x34)]);
/* XXX */
printf(" Expansion ROM Base Address: 0x%08x\n", regs[o2i(0x38)]);
printf(" Interrupt line: 0x%02x\n",
(regs[o2i(0x3c)] >> 0) & 0xff);
printf(" Interrupt pin: 0x%02x ",
(regs[o2i(0x3c)] >> 8) & 0xff);
switch ((regs[o2i(0x3c)] >> 8) & 0xff) {
case PCI_INTERRUPT_PIN_NONE:
printf("(none)");
break;
case PCI_INTERRUPT_PIN_A:
printf("(pin A)");
break;
case PCI_INTERRUPT_PIN_B:
printf("(pin B)");
break;
case PCI_INTERRUPT_PIN_C:
printf("(pin C)");
break;
case PCI_INTERRUPT_PIN_D:
printf("(pin D)");
break;
default:
printf("(???)");
break;
}
printf("\n");
rval = (regs[o2i(0x3c)] >> 16) & 0xffff;
printf(" Bridge control register: 0x%04x\n", rval); /* XXX bits */
onoff("Parity error response", 0x0001);
onoff("Secondary SERR forwarding", 0x0002);
onoff("ISA enable", 0x0004);
onoff("VGA enable", 0x0008);
onoff("Master abort reporting", 0x0020);
onoff("Secondary bus reset", 0x0040);
onoff("Fast back-to-back capable", 0x0080);
}
static void
pci_conf_print_type2(pc, tag, regs)
pci_chipset_tag_t pc;
pcitag_t tag;
const pcireg_t *regs;
{
pcireg_t rval;
/*
* XXX these need to be printed in more detail, need to be
* XXX checked against specs/docs, etc.
*
* This layout was cribbed from the TI PCI1130 PCI-to-CardBus
* controller chip documentation, and may not be correct with
* respect to various standards. (XXX)
*/
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_bar(pc, tag, regs, 0x10,
"CardBus socket/ExCA registers");
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf(" Reserved @ 0x14: 0x%04x\n",
(regs[o2i(0x14)] >> 0) & 0xffff);
rval = (regs[o2i(0x14)] >> 16) & 0xffff;
printf(" Secondary status register: 0x%04x\n", rval);
onoff("66 MHz capable", 0x0020);
onoff("User Definable Features (UDF) support", 0x0040);
onoff("Fast back-to-back capable", 0x0080);
onoff("Data parity error detection", 0x0100);
printf(" DEVSEL timing: ");
switch (rval & 0x0600) {
case 0x0000:
printf("fast");
break;
case 0x0200:
printf("medium");
break;
case 0x0400:
printf("slow");
break;
default:
printf("unknown/reserved"); /* XXX */
break;
}
printf(" (0x%x)\n", (rval & 0x0600) >> 9);
onoff("PCI target aborts terminate CardBus bus master transactions",
0x0800);
onoff("CardBus target aborts terminate PCI bus master transactions",
0x1000);
onoff("Bus initiator aborts terminate initiator transactions",
0x2000);
onoff("System error", 0x4000);
onoff("Parity error", 0x8000);
printf(" PCI bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 0) & 0xff);
printf(" CardBus bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 8) & 0xff);
printf(" Subordinate bus number: 0x%02x\n",
(regs[o2i(0x18)] >> 16) & 0xff);
printf(" CardBus latency timer: 0x%02x\n",
(regs[o2i(0x18)] >> 24) & 0xff);
/* XXX Print more prettily */
printf(" CardBus memory region 0:\n");
printf(" base register: 0x%08x\n", regs[o2i(0x1c)]);
printf(" limit register: 0x%08x\n", regs[o2i(0x20)]);
printf(" CardBus memory region 1:\n");
printf(" base register: 0x%08x\n", regs[o2i(0x24)]);
printf(" limit register: 0x%08x\n", regs[o2i(0x28)]);
printf(" CardBus I/O region 0:\n");
printf(" base register: 0x%08x\n", regs[o2i(0x2c)]);
printf(" limit register: 0x%08x\n", regs[o2i(0x30)]);
printf(" CardBus I/O region 1:\n");
printf(" base register: 0x%08x\n", regs[o2i(0x34)]);
printf(" limit register: 0x%08x\n", regs[o2i(0x38)]);
printf(" Interrupt line: 0x%02x\n",
(regs[o2i(0x3c)] >> 0) & 0xff);
printf(" Interrupt pin: 0x%02x ",
(regs[o2i(0x3c)] >> 8) & 0xff);
switch ((regs[o2i(0x3c)] >> 8) & 0xff) {
case PCI_INTERRUPT_PIN_NONE:
printf("(none)");
break;
case PCI_INTERRUPT_PIN_A:
printf("(pin A)");
break;
case PCI_INTERRUPT_PIN_B:
printf("(pin B)");
break;
case PCI_INTERRUPT_PIN_C:
printf("(pin C)");
break;
case PCI_INTERRUPT_PIN_D:
printf("(pin D)");
break;
default:
printf("(???)");
break;
}
printf("\n");
rval = (regs[o2i(0x3c)] >> 16) & 0xffff;
printf(" Bridge control register: 0x%04x\n", rval);
onoff("Parity error response", 0x0001);
onoff("CardBus SERR forwarding", 0x0002);
onoff("ISA enable", 0x0004);
onoff("VGA enable", 0x0008);
onoff("CardBus master abort reporting", 0x0020);
onoff("CardBus reset", 0x0040);
onoff("Functional interrupts routed by ExCA registers", 0x0080);
onoff("Memory window 0 prefetchable", 0x0100);
onoff("Memory window 1 prefetchable", 0x0200);
onoff("Write posting enable", 0x0400);
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
rval = regs[o2i(0x40)];
printf(" Subsystem vendor ID: 0x%04x\n", PCI_VENDOR(rval));
printf(" Subsystem ID: 0x%04x\n", PCI_PRODUCT(rval));
pci_conf_print_bar(pc, tag, regs, 0x44, "legacy-mode registers");
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
}
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
void
pci_conf_print(pc, tag, printfn)
pci_chipset_tag_t pc;
pcitag_t tag;
void (*printfn)(pci_chipset_tag_t, pcitag_t, const pcireg_t *);
{
pcireg_t regs[o2i(256)];
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
int off, endoff, hdrtype;
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
const char *typename;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
void (*typeprintfn)(pci_chipset_tag_t, pcitag_t, const pcireg_t *);
printf("PCI configuration registers:\n");
for (off = 0; off < 256; off += 4)
regs[o2i(off)] = pci_conf_read(pc, tag, off);
/* common header */
printf(" Common header:\n");
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_regs(regs, 0, 16);
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf("\n");
pci_conf_print_common(pc, tag, regs);
printf("\n");
/* type-dependent header */
hdrtype = PCI_HDRTYPE_TYPE(regs[o2i(PCI_BHLC_REG)]);
switch (hdrtype) { /* XXX make a table, eventually */
case 0:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
/* Standard device header */
typename = "\"normal\" device";
typeprintfn = &pci_conf_print_type0;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
endoff = 64;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
break;
case 1:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
/* PCI-PCI bridge header */
typename = "PCI-PCI bridge";
typeprintfn = &pci_conf_print_type1;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
endoff = 64;
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
break;
case 2:
/* PCI-CardBus bridge header */
typename = "PCI-CardBus bridge";
typeprintfn = &pci_conf_print_type2;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
endoff = 72;
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
break;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
default:
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
typename = NULL;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
typeprintfn = 0;
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
endoff = 64;
break;
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
}
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf(" Type %d ", hdrtype);
if (typename != NULL)
printf("(%s) ", typename);
printf("header:\n");
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_regs(regs, 16, endoff);
Clean up slightly, abstract pci_conf_print family's base address register printing into a function, add a bit more pretty-printing of existing stuff. Implement pretty-printers for type 1 and type 2 headers. (Right now, these are just quick stabs based on some on-line bridge docs that I have handy on my laptop. Mmmm, meetings. I'll check the bits when I get back within reach of my official docs.)
1998-05-28 06:26:00 +04:00
printf("\n");
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
if (typeprintfn)
(*typeprintfn)(pc, tag, regs);
else
printf(" Don't know how to pretty-print type %d header.\n",
hdrtype);
printf("\n");
/* device-dependent header */
printf(" Device-dependent header:\n");
factor out some common code, and enhance functionality slightly: allow the BAR-printing function to print a name for the register, factor out a common register-bits function which can handle the fact that type 2 headers have a different size than is usual, and actually do something useful with the rest of the bits in the type 2 header.
1998-06-26 21:53:09 +04:00
pci_conf_print_regs(regs, endoff, 256);
largely reimplement pci_conf_print(): * print all configuration space registers. Then, where possible, interpret them. (That is, PRESENT ALL THE DATA, then interpret it -- don't hide data behind interpretation. Also, when interpreting fields, try to print out the specific value that's being interpreted.) * handle different header types. * allow caller to specify a function which can interpret the device-dependent header and is responsible for pretty-printing it. It spews (use 'options MSGBUFSIZE=...' 8-), but when you want the data, you really want _all_ of it. Still needs some cleanup and additional code (e.g. interepretation of PCI-PCI (type 1) and PCI-Cardbus (type 2(?)) bridge headers).
1998-05-18 21:25:17 +04:00
printf("\n");
if (printfn)
(*printfn)(pc, tag, regs);
else
printf(" Don't know how to pretty-print device-dependent header.\n");
printf("\n");
Add pci_conf_print(), a function to dump the PCI configuration space, useful in driver debugging. From Zubin D. Dittia <zubin@clouseau.arl.wustl.edu>, PR #4249.
1998-04-15 01:24:50 +04:00
}