1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// MIT License, Copyright (c) 2021 Marvin Borner
#include <cpu.h>
#include <ide.h>
#include <log.h>
#include <pci.h>
// Generate device ID
#define PCI_DEVICE(bus, slot, func) ((u32)((bus << 16) | (slot << 8) | func))
// Extract data from device ID
#define PCI_BUS(device) ((u8)(device >> 16))
#define PCI_SLOT(device) ((u8)(device >> 8))
#define PCI_FUNC(device) ((u8)(device))
// Calculate address
#define PCI_ADDR(device, field) \
(0x80000000 | (u32)(PCI_BUS(device) << 16) | (u32)(PCI_SLOT(device) << 11) | \
(u32)(PCI_FUNC(device) << 8) | ((field)&0xfc))
// Read pci device type
#define PCI_TYPE(device) \
((u32)((pci_read(device, PCI_CLASS, 1) << 16) | (pci_read(device, PCI_SUBCLASS, 1) << 8) | \
pci_read(device, PCI_PROG_IF, 1)))
static u32 pci_read(u32 device, u8 field, u32 size)
{
outl(PCI_ADDR_PORT, PCI_ADDR(device, field));
if (size == 4) {
u32 t = inl(PCI_VALUE_PORT);
return t;
} else if (size == 2) {
u16 t = inw((u16)(PCI_VALUE_PORT + (field & 2)));
return t;
} else if (size == 1) {
u8 t = inb((u16)(PCI_VALUE_PORT + (field & 3)));
return t;
}
return PCI_NONE;
}
/**
* PCI scanning
*/
static void pci_print(u16 vendor_id, u16 device_id, u32 type_id)
{
const char *vendor = "unknown";
const char *device = "unknown";
const char *class = "unknown";
for (u16 i = 0; i < COUNT(pci_vendors); i++)
if (pci_vendors[i].id == vendor_id)
vendor = pci_vendors[i].name;
for (u16 i = 0; i < COUNT(pci_devices); i++)
if (pci_devices[i].vendor_id == vendor_id && pci_devices[i].device_id == device_id)
device = pci_devices[i].name;
for (u16 i = 0; i < COUNT(pci_types); i++)
if (pci_types[i].id == type_id)
class = pci_types[i].name;
log("[PCI] %s: %s - %s\n", vendor, device, class);
}
static void pci_probe_bus(u8 bus);
static void pci_probe_func(u8 bus, u8 slot, u8 func)
{
u32 device = PCI_DEVICE(bus, slot, func);
u16 vendor_id = pci_read(device, PCI_VENDOR_ID, 2);
u16 device_id = pci_read(device, PCI_DEVICE_ID, 2);
u32 type_id = PCI_TYPE(device);
pci_print(vendor_id, device_id, type_id);
if (PCI_TYPE(device) == PCI_TYPE_BRIDGE)
pci_probe_bus(pci_read(device, PCI_SECONDARY_BUS, 1));
if (PCI_IDE(vendor_id, device_id))
ata_install();
}
static void pci_probe_slot(u8 bus, u8 slot)
{
u32 device = PCI_DEVICE(bus, slot, 0);
if (pci_read(device, PCI_VENDOR_ID, 2) == PCI_NONE)
return;
// Scan first func
pci_probe_func(bus, slot, 0);
if (!pci_read(device, PCI_HEADER_TYPE, 1))
return;
// Scan rest
for (u8 func = 1; func < 8; func++) {
device = PCI_DEVICE(bus, slot, func);
if (pci_read(device, PCI_VENDOR_ID, 2) != PCI_NONE)
pci_probe_func(bus, slot, func);
}
}
static void pci_probe_bus(u8 bus)
{
for (u8 slot = 0; slot < 32; slot++)
pci_probe_slot(bus, slot);
}
void pci_probe(void)
{
for (u8 func = 0; func < 8; func++) {
u32 device = PCI_DEVICE(0, 0, func);
if (pci_read(device, PCI_VENDOR_ID, 2) != PCI_NONE)
pci_probe_bus(func);
}
}
|
