![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to device.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 / SLOF / clients / net-snk / app / biosemu|
Return to device.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / clients / net-snk / app / biosemu |
1.1 root 1: /******************************************************************************
2: * Copyright (c) 2004, 2008 IBM Corporation
3: * All rights reserved.
4: * This program and the accompanying materials
5: * are made available under the terms of the BSD License
6: * which accompanies this distribution, and is available at
7: * http://www.opensource.org/licenses/bsd-license.php
8: *
9: * Contributors:
10: * IBM Corporation - initial implementation
11: *****************************************************************************/
12:
13:
14: #include "device.h"
15: #include "rtas.h"
16: #include <stdio.h>
17: #include <string.h>
18: #include "debug.h"
19:
20: typedef struct {
21: uint8_t info;
22: uint8_t bus;
23: uint8_t devfn;
24: uint8_t cfg_space_offset;
25: uint64_t address;
26: uint64_t size;
27: } __attribute__ ((__packed__)) assigned_address_t;
28:
29: // use translate_address_dev and get_puid from net-snk's net_support.c
30: void translate_address_dev(uint64_t *, phandle_t);
31: uint64_t get_puid(phandle_t node);
32:
33:
34: // scan all adresses assigned to the device ("assigned-addresses" and "reg")
35: // store in translate_address_array for faster translation using dev_translate_address
36: void
37: dev_get_addr_info()
38: {
39: // get bus/dev/fn from assigned-addresses
40: int32_t len;
41: //max. 6 BARs and 1 Exp.ROM plus CfgSpace and 3 legacy ranges
42: assigned_address_t buf[11];
43: len =
44: of_getprop(bios_device.phandle, "assigned-addresses", buf,
45: sizeof(buf));
46: bios_device.bus = buf[0].bus;
47: bios_device.devfn = buf[0].devfn;
48: DEBUG_PRINTF("bus: %x, devfn: %x\n", bios_device.bus,
49: bios_device.devfn);
50: //store address translations for all assigned-addresses and regs in
51: //translate_address_array for faster translation later on...
52: int i = 0;
53: // index to insert data into translate_address_array
54: int taa_index = 0;
55: uint64_t address_offset;
56: for (i = 0; i < (len / sizeof(assigned_address_t)); i++, taa_index++) {
57: //copy all info stored in assigned-addresses
58: translate_address_array[taa_index].info = buf[i].info;
59: translate_address_array[taa_index].bus = buf[i].bus;
60: translate_address_array[taa_index].devfn = buf[i].devfn;
61: translate_address_array[taa_index].cfg_space_offset =
62: buf[i].cfg_space_offset;
63: translate_address_array[taa_index].address = buf[i].address;
64: translate_address_array[taa_index].size = buf[i].size;
65: // translate first address and store it as address_offset
66: address_offset = buf[i].address;
67: translate_address_dev(&address_offset, bios_device.phandle);
68: translate_address_array[taa_index].address_offset =
69: address_offset - buf[i].address;
70: }
71: //get "reg" property
72: len = of_getprop(bios_device.phandle, "reg", buf, sizeof(buf));
73: for (i = 0; i < (len / sizeof(assigned_address_t)); i++) {
74: if ((buf[i].size == 0) || (buf[i].cfg_space_offset != 0)) {
75: // we dont care for ranges with size 0 and
76: // BARs and Expansion ROM must be in assigned-addresses... so in reg
77: // we only look for those without config space offset set...
78: // i.e. the legacy ranges
79: continue;
80: }
81: //copy all info stored in assigned-addresses
82: translate_address_array[taa_index].info = buf[i].info;
83: translate_address_array[taa_index].bus = buf[i].bus;
84: translate_address_array[taa_index].devfn = buf[i].devfn;
85: translate_address_array[taa_index].cfg_space_offset =
86: buf[i].cfg_space_offset;
87: translate_address_array[taa_index].address = buf[i].address;
88: translate_address_array[taa_index].size = buf[i].size;
89: // translate first address and store it as address_offset
90: address_offset = buf[i].address;
91: translate_address_dev(&address_offset, bios_device.phandle);
92: translate_address_array[taa_index].address_offset =
93: address_offset - buf[i].address;
94: taa_index++;
95: }
96: // store last entry index of translate_address_array
97: taa_last_entry = taa_index - 1;
98: #ifdef DEBUG
99: //dump translate_address_array
100: printf("translate_address_array: \n");
101: translate_address_t ta;
102: for (i = 0; i <= taa_last_entry; i++) {
103: ta = translate_address_array[i];
104: printf
105: ("%d: %02x%02x%02x%02x\n\taddr: %016llx\n\toffs: %016llx\n\tsize: %016llx\n",
106: i, ta.info, ta.bus, ta.devfn, ta.cfg_space_offset,
107: ta.address, ta.address_offset, ta.size);
108: }
109: #endif
110: }
111:
112: // to simulate accesses to legacy VGA Memory (0xA0000-0xBFFFF)
113: // we look for the first prefetchable memory BAR, if no prefetchable BAR found,
114: // we use the first memory BAR
115: // dev_translate_addr will translate accesses to the legacy VGA Memory into the found vmem BAR
116: void
117: dev_find_vmem_addr()
118: {
119: int i = 0;
120: translate_address_t ta;
121: int8_t tai_np = -1, tai_p = -1; // translate_address_array index for non-prefetchable and prefetchable memory
122: //search backwards to find first entry
123: for (i = taa_last_entry; i >= 0; i--) {
124: ta = translate_address_array[i];
125: if ((ta.cfg_space_offset >= 0x10)
126: && (ta.cfg_space_offset <= 0x24)) {
127: //only BARs
128: if ((ta.info & 0x03) >= 0x02) {
129: //32/64bit memory
130: tai_np = i;
131: if ((ta.info & 0x40) != 0) {
132: // prefetchable
133: tai_p = i;
134: }
135: }
136: }
137: }
138: if (tai_p != -1) {
139: ta = translate_address_array[tai_p];
140: bios_device.vmem_addr = ta.address;
141: bios_device.vmem_size = ta.size;
142: DEBUG_PRINTF
143: ("%s: Found prefetchable Virtual Legacy Memory BAR: %llx, size: %llx\n",
144: __FUNCTION__, bios_device.vmem_addr,
145: bios_device.vmem_size);
146: } else if (tai_np != -1) {
147: ta = translate_address_array[tai_np];
148: bios_device.vmem_addr = ta.address;
149: bios_device.vmem_size = ta.size;
150: DEBUG_PRINTF
151: ("%s: Found non-prefetchable Virtual Legacy Memory BAR: %llx, size: %llx",
152: __FUNCTION__, bios_device.vmem_addr,
153: bios_device.vmem_size);
154: }
155: // disable vmem
156: //bios_device.vmem_size = 0;
157: }
158:
159: void
160: dev_get_puid()
161: {
162: // get puid
163: bios_device.puid = get_puid(bios_device.phandle);
164: DEBUG_PRINTF("puid: 0x%llx\n", bios_device.puid);
165: }
166:
167: void
168: dev_get_device_vendor_id()
169: {
170: uint32_t pci_config_0 =
171: rtas_pci_config_read(bios_device.puid, 4, bios_device.bus,
172: bios_device.devfn, 0x0);
173: bios_device.pci_device_id =
174: (uint16_t) ((pci_config_0 & 0xFFFF0000) >> 16);
175: bios_device.pci_vendor_id = (uint16_t) (pci_config_0 & 0x0000FFFF);
176: DEBUG_PRINTF("PCI Device ID: %04x, PCI Vendor ID: %x\n",
177: bios_device.pci_device_id, bios_device.pci_vendor_id);
178: }
179:
180: /* check, wether the device has a valid Expansion ROM, also search the PCI Data Structure and
181: * any Expansion ROM Header (using dev_scan_exp_header()) for needed information */
182: uint8_t
183: dev_check_exprom()
184: {
185: int i = 0;
186: translate_address_t ta;
187: uint64_t rom_base_addr = 0;
188: uint16_t pci_ds_offset;
189: pci_data_struct_t pci_ds;
190: // check for ExpROM Address (Offset 30) in taa
191: for (i = 0; i <= taa_last_entry; i++) {
192: ta = translate_address_array[i];
193: if (ta.cfg_space_offset == 0x30) {
194: rom_base_addr = ta.address + ta.address_offset; //translated address
195: break;
196: }
197: }
198: // in the ROM there could be multiple Expansion ROM Images... start searching
199: // them for a x86 image
200: do {
201: if (rom_base_addr == 0) {
202: printf("Error: no Expansion ROM address found!\n");
203: return -1;
204: }
205: set_ci();
206: uint16_t rom_signature = *((uint16_t *) rom_base_addr);
207: clr_ci();
208: if (rom_signature != 0x55aa) {
209: printf
210: ("Error: invalid Expansion ROM signature: %02x!\n",
211: *((uint16_t *) rom_base_addr));
212: return -1;
213: }
214: set_ci();
215: // at offset 0x18 is the (16bit little-endian) pointer to the PCI Data Structure
216: pci_ds_offset = in16le((void *) (rom_base_addr + 0x18));
217: //copy the PCI Data Structure
218: memcpy(&pci_ds, (void *) (rom_base_addr + pci_ds_offset),
219: sizeof(pci_ds));
220: clr_ci();
221: #ifdef DEBUG
222: DEBUG_PRINTF("PCI Data Structure @%llx:\n",
223: rom_base_addr + pci_ds_offset);
224: dump((void *) &pci_ds, sizeof(pci_ds));
225: #endif
226: if (strncmp((const char *) pci_ds.signature, "PCIR", 4) != 0) {
227: printf("Invalid PCI Data Structure found!\n");
228: break;
229: }
230: //little-endian conversion
231: pci_ds.vendor_id = in16le(&pci_ds.vendor_id);
232: pci_ds.device_id = in16le(&pci_ds.device_id);
233: pci_ds.img_length = in16le(&pci_ds.img_length);
234: pci_ds.pci_ds_length = in16le(&pci_ds.pci_ds_length);
235: if (pci_ds.vendor_id != bios_device.pci_vendor_id) {
236: printf
237: ("Image has invalid Vendor ID: %04x, expected: %04x\n",
238: pci_ds.vendor_id, bios_device.pci_vendor_id);
239: break;
240: }
241: if (pci_ds.device_id != bios_device.pci_device_id) {
242: printf
243: ("Image has invalid Device ID: %04x, expected: %04x\n",
244: pci_ds.device_id, bios_device.pci_device_id);
245: break;
246: }
247: //DEBUG_PRINTF("Image Length: %d\n", pci_ds.img_length * 512);
248: //DEBUG_PRINTF("Image Code Type: %d\n", pci_ds.code_type);
249: if (pci_ds.code_type == 0) {
250: //x86 image
251: //store image address and image length in bios_device struct
252: bios_device.img_addr = rom_base_addr;
253: bios_device.img_size = pci_ds.img_length * 512;
254: // we found the image, exit the loop
255: break;
256: } else {
257: // no x86 image, check next image (if any)
258: rom_base_addr += pci_ds.img_length * 512;
259: }
260: if ((pci_ds.indicator & 0x80) == 0x80) {
261: //last image found, exit the loop
262: DEBUG_PRINTF("Last PCI Expansion ROM Image found.\n");
263: break;
264: }
265: }
266: while (bios_device.img_addr == 0);
267: // in case we did not find a valid x86 Expansion ROM Image
268: if (bios_device.img_addr == 0) {
269: printf("Error: no valid x86 Expansion ROM Image found!\n");
270: return -1;
271: }
272: return 0;
273: }
274:
275: uint8_t
276: dev_init(char *device_name)
277: {
278: uint8_t rval = 0;
279: //init bios_device struct
280: DEBUG_PRINTF("%s(%s)\n", __FUNCTION__, device_name);
281: memset(&bios_device, 0, sizeof(bios_device));
282: bios_device.ihandle = of_open(device_name);
283: if (bios_device.ihandle == 0) {
284: DEBUG_PRINTF("%s is no valid device!\n", device_name);
285: return -1;
286: }
287: bios_device.phandle = of_finddevice(device_name);
288: dev_get_addr_info();
289: dev_find_vmem_addr();
290: dev_get_puid();
291: dev_get_device_vendor_id();
292: return rval;
293: }
294:
295: // translate address function using translate_address_array assembled
296: // by dev_get_addr_info... MUCH faster than calling translate_address_dev
297: // and accessing client interface for every translation...
298: // returns: 0 if addr not found in translate_address_array, 1 if found.
299: uint8_t
300: dev_translate_address(uint64_t * addr)
301: {
302: int i = 0;
303: translate_address_t ta;
304: //check if it is an access to legacy VGA Mem... if it is, map the address
305: //to the vmem BAR and then translate it...
306: // (translation info provided by Ben Herrenschmidt)
307: // NOTE: the translation seems to only work for NVIDIA cards... but it is needed
308: // to make some NVIDIA cards work at all...
309: if ((bios_device.vmem_size > 0)
310: && ((*addr >= 0xA0000) && (*addr < 0xB8000))) {
311: *addr = (*addr - 0xA0000) * 4 + 2 + bios_device.vmem_addr;
312: }
313: if ((bios_device.vmem_size > 0)
314: && ((*addr >= 0xB8000) && (*addr < 0xC0000))) {
315: uint8_t shift = *addr & 1;
316: *addr &= 0xfffffffe;
317: *addr = (*addr - 0xB8000) * 4 + shift + bios_device.vmem_addr;
318: }
319: for (i = 0; i <= taa_last_entry; i++) {
320: ta = translate_address_array[i];
321: if ((*addr >= ta.address) && (*addr <= (ta.address + ta.size))) {
322: *addr += ta.address_offset;
323: return 1;
324: }
325: }
326: return 0;
327: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.