![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pci.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus|
Return to pci.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus |
1.1 root 1: /*
2: * Copyright (C) 2006 Michael Brown <[email protected]>.
3: *
4: * Based in part on pci.c from Etherboot 5.4, by Ken Yap and David
5: * Munro, in turn based on the Linux kernel's PCI implementation.
6: *
7: * This program is free software; you can redistribute it and/or
8: * modify it under the terms of the GNU General Public License as
9: * published by the Free Software Foundation; either version 2 of the
10: * License, or any later version.
11: *
12: * This program is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with this program; if not, write to the Free Software
19: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: FILE_LICENCE ( GPL2_OR_LATER );
23:
24: #include <stdint.h>
25: #include <stdlib.h>
26: #include <stdio.h>
27: #include <string.h>
28: #include <errno.h>
29: #include <ipxe/tables.h>
30: #include <ipxe/device.h>
31: #include <ipxe/pci.h>
32:
33: /** @file
34: *
35: * PCI bus
36: *
37: */
38:
39: static void pcibus_remove ( struct root_device *rootdev );
40:
41: /**
42: * Read PCI BAR
43: *
44: * @v pci PCI device
45: * @v reg PCI register number
46: * @ret bar Base address register
47: *
48: * Reads the specified PCI base address register, including the flags
49: * portion. 64-bit BARs will be handled automatically. If the value
50: * of the 64-bit BAR exceeds the size of an unsigned long (i.e. if the
51: * high dword is non-zero on a 32-bit platform), then the value
52: * returned will be zero plus the flags for a 64-bit BAR. Unreachable
53: * 64-bit BARs are therefore returned as uninitialised 64-bit BARs.
54: */
55: static unsigned long pci_bar ( struct pci_device *pci, unsigned int reg ) {
56: uint32_t low;
57: uint32_t high;
58:
59: pci_read_config_dword ( pci, reg, &low );
60: if ( ( low & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK) )
61: == (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64) ){
62: pci_read_config_dword ( pci, reg + 4, &high );
63: if ( high ) {
64: if ( sizeof ( unsigned long ) > sizeof ( uint32_t ) ) {
65: return ( ( ( uint64_t ) high << 32 ) | low );
66: } else {
67: DBGC ( pci, PCI_FMT " unhandled 64-bit BAR "
68: "%08x%08x\n",
69: PCI_ARGS ( pci ), high, low );
70: return PCI_BASE_ADDRESS_MEM_TYPE_64;
71: }
72: }
73: }
74: return low;
75: }
76:
77: /**
78: * Find the start of a PCI BAR
79: *
80: * @v pci PCI device
81: * @v reg PCI register number
82: * @ret start BAR start address
83: *
84: * Reads the specified PCI base address register, and returns the
85: * address portion of the BAR (i.e. without the flags).
86: *
87: * If the address exceeds the size of an unsigned long (i.e. if a
88: * 64-bit BAR has a non-zero high dword on a 32-bit machine), the
89: * return value will be zero.
90: */
91: unsigned long pci_bar_start ( struct pci_device *pci, unsigned int reg ) {
92: unsigned long bar;
93:
94: bar = pci_bar ( pci, reg );
95: if ( (bar & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_MEMORY ){
96: return ( bar & PCI_BASE_ADDRESS_MEM_MASK );
97: } else {
98: return ( bar & PCI_BASE_ADDRESS_IO_MASK );
99: }
100: }
101:
102: /**
103: * Read membase and ioaddr for a PCI device
104: *
105: * @v pci PCI device
106: *
107: * This scans through all PCI BARs on the specified device. The first
108: * valid memory BAR is recorded as pci_device::membase, and the first
109: * valid IO BAR is recorded as pci_device::ioaddr.
110: *
111: * 64-bit BARs are handled automatically. On a 32-bit platform, if a
112: * 64-bit BAR has a non-zero high dword, it will be regarded as
113: * invalid.
114: */
115: static void pci_read_bases ( struct pci_device *pci ) {
116: unsigned long bar;
117: int reg;
118:
119: for ( reg = PCI_BASE_ADDRESS_0; reg <= PCI_BASE_ADDRESS_5; reg += 4 ) {
120: bar = pci_bar ( pci, reg );
121: if ( bar & PCI_BASE_ADDRESS_SPACE_IO ) {
122: if ( ! pci->ioaddr )
123: pci->ioaddr =
124: ( bar & PCI_BASE_ADDRESS_IO_MASK );
125: } else {
126: if ( ! pci->membase )
127: pci->membase =
128: ( bar & PCI_BASE_ADDRESS_MEM_MASK );
129: /* Skip next BAR if 64-bit */
130: if ( bar & PCI_BASE_ADDRESS_MEM_TYPE_64 )
131: reg += 4;
132: }
133: }
134: }
135:
136: /**
137: * Enable PCI device
138: *
139: * @v pci PCI device
140: *
141: * Set device to be a busmaster in case BIOS neglected to do so. Also
142: * adjust PCI latency timer to a reasonable value, 32.
143: */
144: void adjust_pci_device ( struct pci_device *pci ) {
145: unsigned short new_command, pci_command;
146: unsigned char pci_latency;
147:
148: pci_read_config_word ( pci, PCI_COMMAND, &pci_command );
149: new_command = ( pci_command | PCI_COMMAND_MASTER |
150: PCI_COMMAND_MEM | PCI_COMMAND_IO );
151: if ( pci_command != new_command ) {
152: DBGC ( pci, PCI_FMT " device not enabled by BIOS! Updating "
153: "PCI command %04x->%04x\n",
154: PCI_ARGS ( pci ), pci_command, new_command );
155: pci_write_config_word ( pci, PCI_COMMAND, new_command );
156: }
157:
158: pci_read_config_byte ( pci, PCI_LATENCY_TIMER, &pci_latency);
159: if ( pci_latency < 32 ) {
160: DBGC ( pci, PCI_FMT " latency timer is unreasonably low at "
161: "%d. Setting to 32.\n", PCI_ARGS ( pci ), pci_latency );
162: pci_write_config_byte ( pci, PCI_LATENCY_TIMER, 32);
163: }
164: }
165:
166: /**
167: * Read PCI device configuration
168: *
169: * @v pci PCI device
170: * @ret rc Return status code
171: */
172: int pci_read_config ( struct pci_device *pci ) {
173: uint32_t tmp;
174:
175: /* Check for physical device presence */
176: pci_read_config_dword ( pci, PCI_VENDOR_ID, &tmp );
177: if ( ( tmp == 0xffffffff ) || ( tmp == 0 ) )
178: return -ENODEV;
179:
180: /* Populate struct pci_device */
181: pci->vendor = ( tmp & 0xffff );
182: pci->device = ( tmp >> 16 );
183: pci_read_config_dword ( pci, PCI_REVISION, &tmp );
184: pci->class = ( tmp >> 8 );
185: pci_read_config_byte ( pci, PCI_INTERRUPT_LINE, &pci->irq );
186: pci_read_bases ( pci );
187:
188: /* Initialise generic device component */
189: snprintf ( pci->dev.name, sizeof ( pci->dev.name ),
190: "PCI%02x:%02x.%x", PCI_BUS ( pci->busdevfn ),
191: PCI_SLOT ( pci->busdevfn ), PCI_FUNC ( pci->busdevfn ) );
192: pci->dev.desc.bus_type = BUS_TYPE_PCI;
193: pci->dev.desc.location = pci->busdevfn;
194: pci->dev.desc.vendor = pci->vendor;
195: pci->dev.desc.device = pci->device;
196: pci->dev.desc.class = pci->class;
197: pci->dev.desc.ioaddr = pci->ioaddr;
198: pci->dev.desc.irq = pci->irq;
199: INIT_LIST_HEAD ( &pci->dev.siblings );
200: INIT_LIST_HEAD ( &pci->dev.children );
201:
202: return 0;
203: }
204:
205: /**
206: * Find driver for PCI device
207: *
208: * @v pci PCI device
209: * @ret rc Return status code
210: */
211: int pci_find_driver ( struct pci_device *pci ) {
212: struct pci_driver *driver;
213: struct pci_device_id *id;
214: unsigned int i;
215:
216: for_each_table_entry ( driver, PCI_DRIVERS ) {
217: for ( i = 0 ; i < driver->id_count ; i++ ) {
218: id = &driver->ids[i];
219: if ( ( id->vendor != PCI_ANY_ID ) &&
220: ( id->vendor != pci->vendor ) )
221: continue;
222: if ( ( id->device != PCI_ANY_ID ) &&
223: ( id->device != pci->device ) )
224: continue;
225: pci_set_driver ( pci, driver, id );
226: return 0;
227: }
228: }
229: return -ENOENT;
230: }
231:
232: /**
233: * Probe a PCI device
234: *
235: * @v pci PCI device
236: * @ret rc Return status code
237: *
238: * Searches for a driver for the PCI device. If a driver is found,
239: * its probe() routine is called.
240: */
241: int pci_probe ( struct pci_device *pci ) {
242: int rc;
243:
244: DBGC ( pci, PCI_FMT " (%04x:%04x) has driver \"%s\"\n",
245: PCI_ARGS ( pci ), pci->vendor, pci->device, pci->id->name );
246: DBGC ( pci, PCI_FMT " has mem %lx io %lx irq %d\n",
247: PCI_ARGS ( pci ), pci->membase, pci->ioaddr, pci->irq );
248:
249: if ( ( rc = pci->driver->probe ( pci ) ) != 0 ) {
250: DBGC ( pci, PCI_FMT " probe failed: %s\n",
251: PCI_ARGS ( pci ), strerror ( rc ) );
252: return rc;
253: }
254:
255: return 0;
256: }
257:
258: /**
259: * Remove a PCI device
260: *
261: * @v pci PCI device
262: */
263: void pci_remove ( struct pci_device *pci ) {
264: pci->driver->remove ( pci );
265: DBGC ( pci, PCI_FMT " removed\n", PCI_ARGS ( pci ) );
266: }
267:
268: /**
269: * Probe PCI root bus
270: *
271: * @v rootdev PCI bus root device
272: *
273: * Scans the PCI bus for devices and registers all devices it can
274: * find.
275: */
276: static int pcibus_probe ( struct root_device *rootdev ) {
277: struct pci_device *pci = NULL;
278: unsigned int num_bus;
279: unsigned int busdevfn;
280: uint8_t hdrtype = 0;
281: int rc;
282:
283: num_bus = pci_num_bus();
284: for ( busdevfn = 0 ; busdevfn < PCI_BUSDEVFN ( num_bus, 0, 0 ) ;
285: busdevfn++ ) {
286:
287: /* Allocate struct pci_device */
288: if ( ! pci )
289: pci = malloc ( sizeof ( *pci ) );
290: if ( ! pci ) {
291: rc = -ENOMEM;
292: goto err;
293: }
294: memset ( pci, 0, sizeof ( *pci ) );
295: pci_init ( pci, busdevfn );
296:
297: /* Skip all but the first function on
298: * non-multifunction cards
299: */
300: if ( PCI_FUNC ( busdevfn ) == 0 ) {
301: pci_read_config_byte ( pci, PCI_HEADER_TYPE,
302: &hdrtype );
303: } else if ( ! ( hdrtype & 0x80 ) ) {
304: continue;
305: }
306:
307: /* Read device configuration */
308: if ( ( rc = pci_read_config ( pci ) ) != 0 )
309: continue;
310:
311: /* Look for a driver */
312: if ( ( rc = pci_find_driver ( pci ) ) != 0 ) {
313: DBGC ( pci, PCI_FMT " (%04x:%04x) has no driver\n",
314: PCI_ARGS ( pci ), pci->vendor, pci->device );
315: continue;
316: }
317:
318: /* Add to device hierarchy */
319: pci->dev.parent = &rootdev->dev;
320: list_add ( &pci->dev.siblings, &rootdev->dev.children);
321:
322: /* Look for a driver */
323: if ( ( rc = pci_probe ( pci ) ) == 0 ) {
324: /* pcidev registered, we can drop our ref */
325: pci = NULL;
326: } else {
327: /* Not registered; re-use struct pci_device */
328: list_del ( &pci->dev.siblings );
329: }
330: }
331:
332: free ( pci );
333: return 0;
334:
335: err:
336: free ( pci );
337: pcibus_remove ( rootdev );
338: return rc;
339: }
340:
341: /**
342: * Remove PCI root bus
343: *
344: * @v rootdev PCI bus root device
345: */
346: static void pcibus_remove ( struct root_device *rootdev ) {
347: struct pci_device *pci;
348: struct pci_device *tmp;
349:
350: list_for_each_entry_safe ( pci, tmp, &rootdev->dev.children,
351: dev.siblings ) {
352: pci_remove ( pci );
353: list_del ( &pci->dev.siblings );
354: free ( pci );
355: }
356: }
357:
358: /** PCI bus root device driver */
359: static struct root_driver pci_root_driver = {
360: .probe = pcibus_probe,
361: .remove = pcibus_remove,
362: };
363:
364: /** PCI bus root device */
365: struct root_device pci_root_device __root_device = {
366: .dev = { .name = "PCI" },
367: .driver = &pci_root_driver,
368: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.