Joshua Wise's Git repositories - netwatch.git/blob

1 /* pci.c

2 * General-purpose PCI probe routines

3 * NetWatch system management mode administration console

4 *

6 * This program is free software; you can redistribute and/or modify it under

7 * the terms found in the file LICENSE in the root of this source tree.

8 *

9 */

10

11 #include <pci.h>

12 #include <output.h>

13

14 int pci_probe(pci_probe_fn_t probe, void *data)

15 {

16 int devsfound = 0;

17 pci_dev_t pdev;

18 unsigned int bus;

19 unsigned int dev;

20 unsigned int fn;

21

22 for (bus = 0; bus < 0x100; bus++)

23 for (dev = 0; dev < 0x20; dev++)

24 {

25 if (pci_read32(bus, dev, 0, 0) == 0xFFFFFFFF)

26 continue;

27 for (fn = 0; fn < 8; fn++)

28 {

29 int bar;

30

31 if (pci_read32(bus, dev, fn, 0) == 0xFFFFFFFF)

32 continue;

33

34 if ((fn != 0) && !(pci_read8(bus, dev, 0, 0x0E) & 0x80))

35 continue;

36

37 pdev.bus = bus;

38 pdev.dev = dev;

39 pdev.fn = fn;

40 pdev.vid = pci_read16(bus, dev, fn, 0);

41 pdev.did = pci_read16(bus, dev, fn, 2);

42

43 for (bar = 0; bar < 6; bar++)

44 {

45 unsigned long bardat = pci_read32(bus, dev, fn, 0x10 + bar*4);

46 if (bardat == 0)

47 {

48 pdev.bars[bar].type = PCI_BAR_NONE;

49 continue;

50 }

51 if (bardat & 1)

52 {

53 pdev.bars[bar].type = PCI_BAR_IO;

54 pdev.bars[bar].addr = bardat & ~0x3;

55 } else {

56 pdev.bars[bar].prefetchable = (bardat >> 3) & 1;

57 switch ((bardat >> 1) & 0x3)

58 {

59 case 0:

60 pdev.bars[bar].type = PCI_BAR_MEMORY32;

61 pdev.bars[bar].addr = bardat & ~0xF;

62 break;

63 case 2:

64 pdev.bars[bar].type = PCI_BAR_MEMORY64;

65 bar++;

66 pdev.bars[bar].type = PCI_BAR_NONE;

67 break;

68 default:

69 pdev.bars[bar].type = PCI_BAR_NONE;

70 continue;

71 }

72 }

73 }

74

75 devsfound += probe(&pdev, data);

76 }

77 }

78

79 return devsfound;

80 }

81

82 static int _enumfn(pci_dev_t *pdev, void *data)

83 {

84 int bar;

85

86 outputf("Found device: %02x:%02x.%1x: %04X:%04X",

87 pdev->bus, pdev->dev, pdev->fn,

88 pdev->vid, pdev->did);

89 for (bar = 0; bar < 6; bar++)

90 {

91 switch (pdev->bars[bar].type)

92 {

93 case PCI_BAR_IO:

94 outputf(" BAR %d: I/O, Addr %04x", bar, pdev->bars[bar].addr);

95 break;

96 case PCI_BAR_MEMORY32:

97 outputf(" BAR %d: Mem32, Addr %04x", bar, pdev->bars[bar].addr);

98 break;

99 case PCI_BAR_MEMORY64:

100 outputf(" BAR %d: Mem64, Addr %04x", bar, pdev->bars[bar].addr);

101 break;

102 default:

103 break;

104 }

105 }

106 return 0;

107 }

108

109 void pci_bus_enum()

110 {

111 pci_probe(_enumfn, 0x0);

112 }

113

114 static int _probefn(pci_dev_t *dev, void *d)

115 {

116 pci_driver_t *driver = d;

117 int i;

118

119 for (i = 0; i < driver->id_count; i++)

120 if ((dev->vid == driver->ids[i].vid) && (dev->did == driver->ids[i].did))

121 {

122 outputf("Probing PCI device: %s", driver->ids[i].name ? driver->ids[i].name : driver->name);

123 return driver->probe(dev, d);

124 }

125 return 0;

126 }

127

128 int pci_probe_driver(pci_driver_t *driver)

129 {

130 return pci_probe(_probefn, driver);

131 }