/*
* The PCI Library -- Generic Direct Access Functions
*
* Copyright (c) 1997--2000 Martin Mares <mj@ucw.cz>
*
* May 8, 2006 - Modified and ported to HelenOS by Jakub Jermar.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include <string.h>
#include "internal.h"
void pci_generic_scan_bus(struct pci_access *a, byte * busmap, int bus)
{
int dev, multi, ht;
struct pci_dev *t;
a->debug("Scanning bus %02x for devices...\n", bus);
if (busmap[bus]) {
a->warning("Bus %02x seen twice (firmware bug). Ignored.",
bus);
return;
}
busmap[bus] = 1;
t = pci_alloc_dev(a);
t->bus = bus;
for (dev = 0; dev < 32; dev++) {
t->dev = dev;
multi = 0;
for (t->func = 0; !t->func || multi && t->func < 8;
t->func++) {
u32 vd = pci_read_long(t, PCI_VENDOR_ID);
struct pci_dev *d;
if (!vd || vd == 0xffffffff)
continue;
ht = pci_read_byte(t, PCI_HEADER_TYPE);
if (!t->func)
multi = ht & 0x80;
ht &= 0x7f;
d = pci_alloc_dev(a);
d->bus = t->bus;
d->dev = t->dev;
d->func = t->func;
d->vendor_id = vd & 0xffff;
d->device_id = vd >> 16U;
d->known_fields = PCI_FILL_IDENT;
d->hdrtype = ht;
pci_link_dev(a, d);
switch (ht) {
case PCI_HEADER_TYPE_NORMAL:
break;
case PCI_HEADER_TYPE_BRIDGE:
case PCI_HEADER_TYPE_CARDBUS:
pci_generic_scan_bus(a, busmap,
pci_read_byte(t,
PCI_SECONDARY_BUS));
break;
default:
a->debug
("Device %04x:%02x:%02x.%d has unknown header type %02x.\n",
d->domain, d->bus, d->dev, d->func,
ht);
}
}
}
pci_free_dev(t);
}
void pci_generic_scan(struct pci_access *a)
{
byte busmap[256];
bzero(busmap, sizeof(busmap));
pci_generic_scan_bus(a, busmap, 0);
}
int pci_generic_fill_info(struct pci_dev *d, int flags)
{
struct pci_access *a = d->access;
if ((flags & (PCI_FILL_BASES | PCI_FILL_ROM_BASE))
&& d->hdrtype < 0)
d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE) & 0x7f;
if (flags & PCI_FILL_IDENT) {
d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);
d->device_id = pci_read_word(d, PCI_DEVICE_ID);
}
if (flags & PCI_FILL_IRQ)
d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);
if (flags & PCI_FILL_BASES) {
int cnt = 0, i;
bzero(d->base_addr, sizeof(d->base_addr));
switch (d->hdrtype) {
case PCI_HEADER_TYPE_NORMAL:
cnt = 6;
break;
case PCI_HEADER_TYPE_BRIDGE:
cnt = 2;
break;
case PCI_HEADER_TYPE_CARDBUS:
cnt = 1;
break;
}
if (cnt) {
for (i = 0; i < cnt; i++) {
u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i * 4);
if (!x || x == (u32) ~ 0)
continue;
if ((x & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
d->base_addr[i] = x;
else {
if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != PCI_BASE_ADDRESS_MEM_TYPE_64)
d->base_addr[i] = x;
else if (i >= cnt - 1)
a->warning("%04x:%02x:%02x.%d: Invalid 64-bit address seen for BAR %d.",
d->domain, d->bus,
d->dev, d->func, i);
else {
u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i) * 4);
#ifdef PCI_HAVE_64BIT_ADDRESS
d->base_addr[i - 1] = x | (((pciaddr_t) y) << 32);
#else
if (y)
a->warning("%04x:%02x:%02x.%d 64-bit device address ignored.",
d->domain,
d->bus,
d->dev,
d->func);
else
d->base_addr[i - 1] = x;
#endif
}
}
}
}
}
if (flags & PCI_FILL_ROM_BASE) {
int reg = 0;
d->rom_base_addr = 0;
switch (d->hdrtype) {
case PCI_HEADER_TYPE_NORMAL:
reg = PCI_ROM_ADDRESS;
break;
case PCI_HEADER_TYPE_BRIDGE:
reg = PCI_ROM_ADDRESS1;
break;
}
if (reg) {
u32 u = pci_read_long(d, reg);
if (u != 0xffffffff)
d->rom_base_addr = u;
}
}
return flags & ~PCI_FILL_SIZES;
}
static int
pci_generic_block_op(struct pci_dev *d, int pos, byte * buf, int len,
int (*r) (struct pci_dev * d, int pos, byte * buf,
int len))
{
if ((pos & 1) && len >= 1) {
if (!r(d, pos, buf, 1))
return 0;
pos++;
buf++;
len--;
}
if ((pos & 3) && len >= 2) {
if (!r(d, pos, buf, 2))
return 0;
pos += 2;
buf += 2;
len -= 2;
}
while (len >= 4) {
if (!r(d, pos, buf, 4))
return 0;
pos += 4;
buf += 4;
len -= 4;
}
if (len >= 2) {
if (!r(d, pos, buf, 2))
return 0;
pos += 2;
buf += 2;
len -= 2;
}
if (len && !r(d, pos, buf, 1))
return 0;
return 1;
}
int pci_generic_block_read(struct pci_dev *d, int pos, byte * buf, int len)
{
return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);
}
int pci_generic_block_write(struct pci_dev *d, int pos, byte * buf, int len)
{
return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);
}