forked from Imagelibrary/rtems
275 lines
7.2 KiB
C
275 lines
7.2 KiB
C
/**
|
|
* @file
|
|
*
|
|
* This file implements a BSP independent version of pci_find_device().
|
|
*/
|
|
|
|
/*
|
|
* The software in this file was based upon the pci_find_device()
|
|
* implementation provided by Till Straumann under the following terms.
|
|
* That implementation had been copied to multiple BSPs. This implementation
|
|
* is BSP independent and follows RTEMS Project coding guidelines.
|
|
*
|
|
* COPYRIGHT (c) 2016.
|
|
* On-Line Applications Research Corporation (OAR).
|
|
*
|
|
* Authorship
|
|
* ----------
|
|
* This software was created by
|
|
* Till Straumann <strauman@slac.stanford.edu>, 2001,
|
|
* Stanford Linear Accelerator Center, Stanford University.
|
|
*
|
|
* Acknowledgement of sponsorship
|
|
* ------------------------------
|
|
* This software was produced by
|
|
* the Stanford Linear Accelerator Center, Stanford University,
|
|
* under Contract DE-AC03-76SFO0515 with the Department of Energy.
|
|
*
|
|
* Government disclaimer of liability
|
|
* ----------------------------------
|
|
* Neither the United States nor the United States Department of Energy,
|
|
* nor any of their employees, makes any warranty, express or implied, or
|
|
* assumes any legal liability or responsibility for the accuracy,
|
|
* completeness, or usefulness of any data, apparatus, product, or process
|
|
* disclosed, or represents that its use would not infringe privately owned
|
|
* rights.
|
|
*
|
|
* Stanford disclaimer of liability
|
|
* --------------------------------
|
|
* Stanford University makes no representations or warranties, express or
|
|
* implied, nor assumes any liability for the use of this software.
|
|
*
|
|
* Stanford disclaimer of copyright
|
|
* --------------------------------
|
|
* Stanford University, owner of the copyright, hereby disclaims its
|
|
* copyright and all other rights in this software. Hence, anyone may
|
|
* freely use it for any purpose without restriction.
|
|
*
|
|
* Maintenance of notices
|
|
* ----------------------
|
|
* In the interest of clarity regarding the origin and status of this
|
|
* SLAC software, this and all the preceding Stanford University notices
|
|
* are to remain affixed to any copy or derivative of this software made
|
|
* or distributed by the recipient and are to be affixed to any copy of
|
|
* software made or distributed by the recipient that contains a copy or
|
|
* derivative of this software.
|
|
*
|
|
* ------------------ SLAC Software Notices, Set 4 OTT.002a, 2004 FEB 03
|
|
*/
|
|
|
|
|
|
#include <rtems/pci.h>
|
|
#include <rtems/bspIo.h>
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
|
|
/*
|
|
* Public methods from this file
|
|
*/
|
|
void pci_dump(FILE *f);
|
|
|
|
/*
|
|
* These are used to construct the handle returned by pci_find_device()
|
|
* but the caller does not need to know how to decode them.
|
|
*/
|
|
#define PCIB_DEVSIG_BUS(x) (((x)>>8) &0xff)
|
|
#define PCIB_DEVSIG_DEV(x) (((x)>>3) & 0x1f)
|
|
#define PCIB_DEVSIG_FUNC(x) ((x) & 0x7)
|
|
#define PCIB_DEVSIG_MAKE(b,d,f) ((b<<8)|(d<<3)|(f))
|
|
|
|
/*
|
|
* Function pointer to helper function called during bus iteration.
|
|
*/
|
|
typedef int (*pci_scan_helper_t)(
|
|
int bus,
|
|
int dev,
|
|
int fun,
|
|
void *uarg
|
|
);
|
|
|
|
/*
|
|
*
|
|
*/
|
|
static uint32_t pci_scan(
|
|
uint32_t handle,
|
|
pci_scan_helper_t helper,
|
|
void *uarg
|
|
);
|
|
|
|
typedef struct {
|
|
uint16_t vendor_id;
|
|
uint16_t device_id;
|
|
int instance;
|
|
uint8_t bus;
|
|
uint8_t device;
|
|
uint8_t function;
|
|
} pci_scan_arg_t;
|
|
|
|
static int find_dev_helper(
|
|
int bus,
|
|
int device,
|
|
int function,
|
|
void *uarg
|
|
)
|
|
{
|
|
pci_scan_arg_t *scan = uarg;
|
|
uint16_t vendor_tmp;
|
|
uint16_t device_tmp;
|
|
|
|
pci_read_config_word(bus, device, function, PCI_VENDOR_ID, &vendor_tmp);
|
|
if (scan->vendor_id == vendor_tmp) {
|
|
pci_read_config_word(bus, device, function, PCI_DEVICE_ID, &device_tmp);
|
|
if (scan->device_id == device_tmp && scan->instance-- == 0) {
|
|
scan->bus = bus;
|
|
scan->device = device;
|
|
scan->function = function;
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int pci_find_device(
|
|
uint16_t vendorid,
|
|
uint16_t deviceid,
|
|
int instance,
|
|
int *bus,
|
|
int *device,
|
|
int *function
|
|
)
|
|
{
|
|
pci_scan_arg_t scan;
|
|
|
|
scan.instance = instance;
|
|
scan.vendor_id = vendorid;
|
|
scan.device_id = deviceid;
|
|
|
|
if ( pci_scan(0, find_dev_helper, (void*)&scan) != 0 ) {
|
|
*bus = scan.bus;
|
|
*device = scan.device;
|
|
*function = scan.function;
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int dump_dev_helper(
|
|
int bus,
|
|
int device,
|
|
int function,
|
|
void *arg
|
|
)
|
|
{
|
|
uint16_t vendor_id;
|
|
uint16_t device_id;
|
|
uint16_t cmd;
|
|
uint16_t status;
|
|
uint32_t base0;
|
|
uint32_t base1;
|
|
uint8_t irq_pin;
|
|
uint8_t int_line;
|
|
FILE *fp = arg;
|
|
|
|
pci_read_config_word (bus, device, function, PCI_VENDOR_ID, &vendor_id);
|
|
pci_read_config_word (bus, device, function, PCI_DEVICE_ID, &device_id);
|
|
pci_read_config_word (bus, device, function, PCI_COMMAND, &cmd);
|
|
pci_read_config_word (bus, device, function, PCI_STATUS, &status);
|
|
pci_read_config_dword(bus, device, function, PCI_BASE_ADDRESS_0, &base0);
|
|
pci_read_config_dword(bus, device, function, PCI_BASE_ADDRESS_1, &base1);
|
|
pci_read_config_byte (bus, device, function, PCI_INTERRUPT_PIN, &irq_pin);
|
|
pci_read_config_byte (bus, device, function, PCI_INTERRUPT_LINE, &int_line);
|
|
|
|
fprintf(
|
|
fp,
|
|
"%3d:0x%02x:%d 0x%04x:0x%04x 0x%04x 0x%04x 0x%08" PRIx32 " 0x%08" PRIx32 " %d %3d(0x%02x)\n",
|
|
bus,
|
|
device,
|
|
function,
|
|
vendor_id,
|
|
device_id,
|
|
cmd,
|
|
status,
|
|
base0,
|
|
base1,
|
|
irq_pin,
|
|
int_line,
|
|
int_line
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
void pci_dump(
|
|
FILE *fp
|
|
)
|
|
{
|
|
if ( !fp )
|
|
fp = stdout;
|
|
fprintf(
|
|
fp,
|
|
"BUS:SLOT:FUN VENDOR:DEV_ID CMD STAT BASE_ADDR0 BASE_ADDR1 INTn IRQ_LINE\n"
|
|
);
|
|
pci_scan(0, dump_dev_helper, fp);
|
|
}
|
|
|
|
static uint32_t pci_scan(
|
|
uint32_t handle,
|
|
pci_scan_helper_t helper,
|
|
void *arg
|
|
)
|
|
{
|
|
uint32_t vendor;
|
|
uint8_t bus;
|
|
uint8_t dev;
|
|
uint8_t fun;
|
|
uint8_t hd;
|
|
|
|
bus = PCIB_DEVSIG_BUS( (unsigned long)handle );
|
|
dev = PCIB_DEVSIG_DEV( (unsigned long)handle );
|
|
fun = PCIB_DEVSIG_FUNC( (unsigned long)handle );
|
|
|
|
hd = fun > 0 ? PCI_MAX_FUNCTIONS : 1;
|
|
|
|
for (; bus<pci_bus_count(); bus++, dev=0) {
|
|
for (; dev<PCI_MAX_DEVICES; dev++, fun=0) {
|
|
for (; fun<hd; fun++) {
|
|
/*
|
|
* The last devfn id/slot is special; must skip it
|
|
*/
|
|
if ((PCI_MAX_DEVICES-1 == dev) && (PCI_MAX_FUNCTIONS-1 == fun) )
|
|
break;
|
|
|
|
(void)pci_read_config_dword(bus, dev, 0, PCI_VENDOR_ID, &vendor);
|
|
if (PCI_INVALID_VENDORDEVICEID == vendor)
|
|
continue;
|
|
|
|
if ( fun == 0 ) {
|
|
pci_read_config_byte(bus,dev, 0, PCI_HEADER_TYPE, &hd);
|
|
hd = (hd & PCI_HEADER_TYPE_MULTI_FUNCTION ? PCI_MAX_FUNCTIONS : 1);
|
|
}
|
|
|
|
(void)pci_read_config_dword(bus, dev, fun, PCI_VENDOR_ID, &vendor);
|
|
if (PCI_INVALID_VENDORDEVICEID == vendor)
|
|
continue;
|
|
#ifdef PCI_DEBUG
|
|
fprintf(
|
|
stderr,
|
|
"pci_scan: found 0x%08" PRIx32 " at %d/x%02x/%d\n", vendor, bus, dev, fun
|
|
);
|
|
#endif
|
|
if ( (*helper)(bus, dev, fun, arg) > 0 ) {
|
|
if ( ++fun >= hd ) {
|
|
fun = 0;
|
|
if ( ++dev >= PCI_MAX_DEVICES ) {
|
|
dev = 0;
|
|
bus++;
|
|
}
|
|
}
|
|
return PCIB_DEVSIG_MAKE(bus,dev,fun);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|