Rev 1627 | Rev 1633 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1498 | serge | 1 | |
1625 | serge | 2 | #include |
3 | #include |
||
4 | #include |
||
5 | #include |
||
1498 | serge | 6 | |
7 | |||
8 | #include "acpi_bus.h" |
||
1627 | serge | 9 | |
1498 | serge | 10 | |
1627 | serge | 11 | |
12 | |||
1625 | serge | 13 | #define ACPI_BUS_HID "KLBSYBUS" |
14 | #define ACPI_BUS_DEVICE_NAME "System Bus" |
||
15 | |||
16 | |||
17 | |||
18 | |||
19 | |||
20 | static LIST_HEAD(acpi_bus_id_list); |
||
21 | |||
22 | |||
1627 | serge | 23 | |
1625 | serge | 24 | { |
25 | char bus_id[15]; |
||
26 | unsigned int instance_no; |
||
27 | struct list_head node; |
||
28 | }; |
||
29 | |||
30 | |||
31 | |||
1498 | serge | 32 | #define ACPI_NS_SYSTEM_BUS "_SB_" |
33 | |||
34 | |||
35 | ACPI_IRQ_MODEL_PIC = 0, |
||
36 | ACPI_IRQ_MODEL_IOAPIC, |
||
37 | ACPI_IRQ_MODEL_IOSAPIC, |
||
38 | ACPI_IRQ_MODEL_PLATFORM, |
||
39 | ACPI_IRQ_MODEL_COUNT |
||
40 | }; |
||
41 | |||
42 | |||
1625 | serge | 43 | ACPI_BUS_REMOVAL_NORMAL = 0, |
44 | ACPI_BUS_REMOVAL_EJECT, |
||
45 | ACPI_BUS_REMOVAL_SUPRISE, |
||
46 | ACPI_BUS_REMOVAL_TYPE_COUNT |
||
47 | }; |
||
48 | |||
1498 | serge | 49 | |
1625 | serge | 50 | |
51 | #define PCI_MAX_PINS 4 |
||
52 | |||
53 | |||
54 | |||
55 | |||
56 | static ACPI_HANDLE pci_root_handle; |
||
57 | |||
58 | |||
59 | |||
1498 | serge | 60 | (addr_t)((addr_t)(addr) + (addr_t)(off)) |
61 | |||
62 | |||
63 | // (addr_t)((addr_t)(addr) + OS_BASE) |
||
64 | |||
65 | |||
66 | |||
67 | |||
1625 | serge | 68 | |
1627 | serge | 69 | |
1625 | serge | 70 | |
1627 | serge | 71 | extern struct resource ioport_resource; |
72 | |||
1625 | serge | 73 | |
1627 | serge | 74 | { |
1625 | serge | 75 | IO_PIC = 0, |
1627 | serge | 76 | IO_APIC |
77 | }; |
||
1625 | serge | 78 | |
79 | |||
1627 | serge | 80 | { |
1625 | serge | 81 | ACPI_OBJECT arg1; |
1627 | serge | 82 | ACPI_OBJECT_LIST args; |
83 | ACPI_STATUS as; |
||
84 | |||
1625 | serge | 85 | |
1627 | serge | 86 | arg1.Integer.Value = mode; |
87 | args.Count = 1; |
||
88 | args.Pointer = &arg1; |
||
89 | |||
1625 | serge | 90 | |
1627 | serge | 91 | /* |
92 | * We can silently ignore failure as it may not be implemented, ACPI should |
||
93 | * provide us with correct information anyway |
||
94 | */ |
||
95 | if (ACPI_SUCCESS(as)) |
||
96 | dbgprintf(PREFIX "machine set to %s mode\n", mode ? "APIC" : "PIC"); |
||
97 | } |
||
1625 | serge | 98 | |
99 | |||
1627 | serge | 100 | { |
1498 | serge | 101 | struct acpi_device *child; |
1627 | serge | 102 | |
1498 | serge | 103 | |
1627 | serge | 104 | |
1498 | serge | 105 | |
1627 | serge | 106 | { |
107 | print_device_tree(child); |
||
108 | }; |
||
109 | }; |
||
110 | |||
1498 | serge | 111 | |
112 | |||
1625 | serge | 113 | |
114 | |||
1627 | serge | 115 | |
1625 | serge | 116 | |
1627 | serge | 117 | |
1625 | serge | 118 | |
119 | |||
1627 | serge | 120 | |
1498 | serge | 121 | |
1627 | serge | 122 | #define ACPI_PCI_ROOT_DEVICE_NAME "PCI Root Bridge" |
123 | |||
1498 | serge | 124 | |
1627 | serge | 125 | get_root_bridge_busnr_callback(ACPI_RESOURCE *resource, void *data) |
126 | { |
||
1625 | serge | 127 | struct resource *res = data; |
1627 | serge | 128 | ACPI_RESOURCE_ADDRESS64 address; |
129 | |||
1498 | serge | 130 | |
1627 | serge | 131 | resource->Type != ACPI_RESOURCE_TYPE_ADDRESS32 && |
132 | resource->Type != ACPI_RESOURCE_TYPE_ADDRESS64) |
||
133 | return AE_OK; |
||
1625 | serge | 134 | |
1498 | serge | 135 | |
1627 | serge | 136 | if ((address.AddressLength > 0) && |
137 | (address.ResourceType == ACPI_BUS_NUMBER_RANGE)) { |
||
138 | res->start = address.Minimum; |
||
139 | res->end = address.Minimum + address.AddressLength - 1; |
||
140 | } |
||
1625 | serge | 141 | |
1627 | serge | 142 | |
143 | } |
||
1625 | serge | 144 | |
1500 | serge | 145 | |
1625 | serge | 146 | |
147 | |||
1627 | serge | 148 | struct resource *res) |
149 | { |
||
1625 | serge | 150 | ACPI_STATUS status; |
151 | |||
152 | |||
1627 | serge | 153 | status = |
154 | AcpiWalkResources(handle, METHOD_NAME__CRS, |
||
155 | get_root_bridge_busnr_callback, res); |
||
156 | if (ACPI_FAILURE(status)) |
||
1625 | serge | 157 | return status; |
1627 | serge | 158 | if (res->start == -1) |
159 | return AE_ERROR; |
||
160 | return AE_OK; |
||
161 | } |
||
162 | |||
1498 | serge | 163 | |
164 | |||
1628 | serge | 165 | { |
166 | int status; |
||
167 | struct acpi_device *child = NULL; |
||
168 | |||
169 | |||
170 | if (device->parent && device->parent->ops.bind) { |
||
171 | status = device->parent->ops.bind(device); |
||
172 | if (!status) { |
||
173 | list_for_each_entry(child, &device->children, node) |
||
174 | acpi_pci_bridge_scan(child); |
||
175 | } |
||
176 | } |
||
177 | } |
||
178 | |||
179 | |||
180 | |||
181 | |||
1627 | serge | 182 | { |
183 | struct acpi_device *bridge; |
||
184 | char *name; |
||
185 | unsigned int res_num; |
||
186 | struct resource *res; |
||
187 | struct pci_bus *bus; |
||
188 | int busnum; |
||
189 | }; |
||
190 | |||
1625 | serge | 191 | |
1498 | serge | 192 | |
1627 | serge | 193 | resource_to_addr(ACPI_RESOURCE *resource, ACPI_RESOURCE_ADDRESS64 *addr) |
194 | { |
||
1498 | serge | 195 | ACPI_STATUS status; |
1625 | serge | 196 | struct acpi_resource_memory24 *memory24; |
1627 | serge | 197 | struct acpi_resource_memory32 *memory32; |
198 | struct acpi_resource_fixed_memory32 *fixed_memory32; |
||
199 | |||
1498 | serge | 200 | |
1627 | serge | 201 | switch (resource->Type) { |
202 | case ACPI_RESOURCE_TYPE_MEMORY24: |
||
203 | memory24 = &resource->Data.Memory24; |
||
204 | addr->ResourceType = ACPI_MEMORY_RANGE; |
||
205 | addr->Minimum = memory24->Minimum; |
||
206 | addr->AddressLength = memory24->AddressLength; |
||
207 | addr->Maximum = addr->Minimum + addr->AddressLength - 1; |
||
208 | return AE_OK; |
||
209 | case ACPI_RESOURCE_TYPE_MEMORY32: |
||
210 | memory32 = &resource->Data.Memory32; |
||
211 | addr->ResourceType = ACPI_MEMORY_RANGE; |
||
212 | addr->Minimum = memory32->Minimum; |
||
213 | addr->AddressLength = memory32->AddressLength; |
||
214 | addr->Maximum = addr->Minimum + addr->AddressLength - 1; |
||
215 | return AE_OK; |
||
216 | case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: |
||
217 | fixed_memory32 = &resource->Data.FixedMemory32; |
||
218 | addr->ResourceType = ACPI_MEMORY_RANGE; |
||
219 | addr->Minimum = fixed_memory32->Address; |
||
220 | addr->AddressLength = fixed_memory32->AddressLength; |
||
221 | addr->Maximum = addr->Minimum + addr->AddressLength - 1; |
||
222 | return AE_OK; |
||
223 | case ACPI_RESOURCE_TYPE_ADDRESS16: |
||
224 | case ACPI_RESOURCE_TYPE_ADDRESS32: |
||
225 | case ACPI_RESOURCE_TYPE_ADDRESS64: |
||
226 | status = AcpiResourceToAddress64(resource, addr); |
||
227 | if (ACPI_SUCCESS(status) && |
||
228 | (addr->ResourceType == ACPI_MEMORY_RANGE || |
||
229 | addr->ResourceType == ACPI_IO_RANGE) && |
||
230 | addr->AddressLength > 0) { |
||
231 | return AE_OK; |
||
232 | } |
||
233 | break; |
||
234 | } |
||
235 | return AE_ERROR; |
||
236 | } |
||
1625 | serge | 237 | |
238 | |||
239 | |||
1627 | serge | 240 | count_resource(ACPI_RESOURCE *acpi_res, void *data) |
241 | { |
||
1625 | serge | 242 | struct pci_root_info *info = data; |
1627 | serge | 243 | ACPI_RESOURCE_ADDRESS64 addr; |
244 | ACPI_STATUS status; |
||
245 | |||
1625 | serge | 246 | |
1627 | serge | 247 | if (ACPI_SUCCESS(status)) |
248 | info->res_num++; |
||
249 | return AE_OK; |
||
250 | } |
||
1625 | serge | 251 | |
1498 | serge | 252 | |
253 | |||
1627 | serge | 254 | { |
1625 | serge | 255 | struct pci_root_info *info = data; |
1627 | serge | 256 | struct resource *res; |
257 | struct acpi_resource_address64 addr; |
||
258 | ACPI_STATUS status; |
||
259 | unsigned long flags; |
||
260 | struct resource *root, *conflict; |
||
261 | u64 start, end; |
||
262 | |||
1625 | serge | 263 | |
1627 | serge | 264 | if (!ACPI_SUCCESS(status)) |
265 | return AE_OK; |
||
266 | |||
1625 | serge | 267 | |
1627 | serge | 268 | { |
269 | root = &iomem_resource; |
||
270 | flags = IORESOURCE_MEM; |
||
271 | if (addr.Info.Mem.Caching == ACPI_PREFETCHABLE_MEMORY) |
||
272 | flags |= IORESOURCE_PREFETCH; |
||
273 | } |
||
1498 | serge | 274 | else if (addr.ResourceType == ACPI_IO_RANGE) |
1627 | serge | 275 | { |
276 | root = &ioport_resource; |
||
277 | flags = IORESOURCE_IO; |
||
278 | } else |
||
279 | return AE_OK; |
||
280 | |||
1625 | serge | 281 | |
1627 | serge | 282 | end = addr.Maximum + addr.TranslationOffset; |
283 | |||
1625 | serge | 284 | |
1627 | serge | 285 | res->name = info->name; |
286 | res->flags = flags; |
||
287 | res->start = start; |
||
288 | res->end = end; |
||
289 | res->child = NULL; |
||
290 | |||
1625 | serge | 291 | |
1627 | serge | 292 | printk("host bridge window %pR (ignored)\n", res); |
293 | return AE_OK; |
||
294 | } |
||
295 | |||
1625 | serge | 296 | |
1627 | serge | 297 | conflict = insert_resource_conflict(root, res); |
298 | if (conflict) { |
||
299 | dev_err(&info->bridge->dev, |
||
300 | "address space collision: host bridge window %pR " |
||
301 | "conflicts with %s %pR\n", |
||
302 | res, conflict->name, conflict); |
||
303 | } else { |
||
304 | pci_bus_add_resource(info->bus, res, 0); |
||
305 | info->res_num++; |
||
306 | if (addr.translation_offset) |
||
307 | dev_info(&info->bridge->dev, "host bridge window %pR " |
||
308 | "(PCI address [%#llx-%#llx])\n", |
||
309 | res, res->start - addr.translation_offset, |
||
310 | res->end - addr.translation_offset); |
||
311 | else |
||
312 | dev_info(&info->bridge->dev, |
||
313 | "host bridge window %pR\n", res); |
||
314 | } |
||
315 | return AE_OK; |
||
316 | #endif |
||
317 | } |
||
1498 | serge | 318 | |
319 | |||
320 | |||
1625 | serge | 321 | |
1627 | serge | 322 | get_current_resources(struct acpi_device *device, int busnum, |
323 | int domain, struct pci_bus *bus) |
||
324 | { |
||
1625 | serge | 325 | struct pci_root_info info; |
1627 | serge | 326 | size_t size; |
327 | |||
1625 | serge | 328 | |
1627 | serge | 329 | |
1625 | serge | 330 | |
1627 | serge | 331 | // pci_bus_remove_resources(bus); |
332 | |||
1625 | serge | 333 | |
1627 | serge | 334 | info.bus = bus; |
335 | info.res_num = 0; |
||
336 | AcpiWalkResources(device->handle, METHOD_NAME__CRS, count_resource, |
||
337 | &info); |
||
338 | if (!info.res_num) |
||
339 | return; |
||
340 | |||
1625 | serge | 341 | |
1627 | serge | 342 | info.res = kmalloc(size, GFP_KERNEL); |
343 | if (!info.res) |
||
344 | goto res_alloc_fail; |
||
345 | |||
1625 | serge | 346 | |
1627 | serge | 347 | info.name = strdup(buf); |
348 | |||
1625 | serge | 349 | |
1627 | serge | 350 | goto name_alloc_fail; |
351 | |||
1625 | serge | 352 | |
1627 | serge | 353 | AcpiWalkResources(device->handle, METHOD_NAME__CRS, setup_resource, |
354 | &info); |
||
355 | |||
1625 | serge | 356 | |
1627 | serge | 357 | |
1625 | serge | 358 | |
1627 | serge | 359 | kfree(info.res); |
360 | res_alloc_fail: |
||
361 | return; |
||
362 | } |
||
1625 | serge | 363 | |
364 | |||
365 | |||
366 | |||
367 | |||
1627 | serge | 368 | .read = NULL, |
369 | .write = NULL, |
||
370 | }; |
||
371 | |||
1625 | serge | 372 | |
373 | |||
1627 | serge | 374 | { |
1625 | serge | 375 | struct acpi_device *device = root->device; |
1627 | serge | 376 | int domain = root->segment; |
377 | int busnum = root->secondary.start; |
||
378 | struct pci_bus *bus; |
||
379 | struct pci_sysdata *sd; |
||
380 | int node = 0; |
||
381 | |||
1625 | serge | 382 | |
1627 | serge | 383 | printk(KERN_WARNING "pci_bus %04x:%02x: " |
384 | "ignored (multiple domains not supported)\n", |
||
385 | domain, busnum); |
||
386 | return NULL; |
||
387 | } |
||
1625 | serge | 388 | |
389 | |||
1627 | serge | 390 | * TODO: leak; this memory is never freed. |
391 | * It's arguable whether it's worth the trouble to care. |
||
392 | */ |
||
1625 | serge | 393 | sd = kzalloc(sizeof(*sd), GFP_KERNEL); |
1627 | serge | 394 | if (!sd) { |
395 | printk(KERN_WARNING "pci_bus %04x:%02x: " |
||
396 | "ignored (out of memory)\n", domain, busnum); |
||
397 | return NULL; |
||
398 | } |
||
1625 | serge | 399 | |
400 | |||
1627 | serge | 401 | sd->node = node; |
402 | /* |
||
1625 | serge | 403 | * Maybe the desired pci bus has been already scanned. In such case |
1627 | serge | 404 | * it is unnecessary to scan the pci bus with the given domain,busnum. |
405 | */ |
||
1625 | serge | 406 | bus = pci_find_bus(domain, busnum); |
1627 | serge | 407 | if (bus) { |
408 | /* |
||
409 | * If the desired bus exits, the content of bus->sysdata will |
||
410 | * be replaced by sd. |
||
411 | */ |
||
412 | memcpy(bus->sysdata, sd, sizeof(*sd)); |
||
413 | kfree(sd); |
||
414 | } else { |
||
415 | bus = pci_create_bus(busnum, &pci_root_ops, sd); |
||
416 | if (bus) { |
||
417 | get_current_resources(device, busnum, domain, bus); |
||
418 | bus->subordinate = pci_scan_child_bus(bus); |
||
1628 | serge | 419 | } |
1625 | serge | 420 | } |
421 | |||
422 | |||
1627 | serge | 423 | kfree(sd); |
424 | |||
1625 | serge | 425 | |
1627 | serge | 426 | printk("on NUMA node %d\n", node); |
427 | } |
||
428 | |||
1625 | serge | 429 | |
1627 | serge | 430 | } |
1625 | serge | 431 | |
432 | |||
433 | |||
434 | |||
1627 | serge | 435 | { |
1625 | serge | 436 | unsigned long long segment, bus; |
1627 | serge | 437 | ACPI_STATUS status; |
438 | int result; |
||
1625 | serge | 439 | struct acpi_pci_root *root; |
1627 | serge | 440 | ACPI_HANDLE handle; |
441 | struct acpi_device *child; |
||
442 | u32 flags, base_flags; |
||
443 | |||
1625 | serge | 444 | |
1627 | serge | 445 | if (!root) |
446 | return -ENOMEM; |
||
1625 | serge | 447 | |
1627 | serge | 448 | |
449 | status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL, |
||
450 | &segment); |
||
451 | if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { |
||
452 | printk(KERN_ERR PREFIX "can't evaluate _SEG\n"); |
||
453 | result = -ENODEV; |
||
454 | goto end; |
||
455 | } |
||
1625 | serge | 456 | |
457 | |||
1627 | serge | 458 | root->secondary.flags = IORESOURCE_BUS; |
459 | status = try_get_root_bridge_busnr(device->handle, &root->secondary); |
||
460 | if (ACPI_FAILURE(status)) |
||
461 | { |
||
462 | /* |
||
463 | * We need both the start and end of the downstream bus range |
||
464 | * to interpret _CBA (MMCONFIG base address), so it really is |
||
465 | * supposed to be in _CRS. If we don't find it there, all we |
||
466 | * can do is assume [_BBN-0xFF] or [0-0xFF]. |
||
467 | */ |
||
468 | root->secondary.end = 0xFF; |
||
469 | printk(KERN_WARNING PREFIX |
||
470 | "no secondary bus range in _CRS\n"); |
||
471 | status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL, &bus); |
||
472 | if (ACPI_SUCCESS(status)) |
||
473 | root->secondary.start = bus; |
||
474 | else if (status == AE_NOT_FOUND) |
||
475 | root->secondary.start = 0; |
||
476 | else { |
||
477 | printk(KERN_ERR PREFIX "can't evaluate _BBN\n"); |
||
478 | result = -ENODEV; |
||
479 | goto end; |
||
480 | } |
||
481 | } |
||
482 | |||
1625 | serge | 483 | |
1627 | serge | 484 | root->device = device; |
485 | root->segment = segment & 0xFFFF; |
||
486 | strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME); |
||
487 | strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS); |
||
488 | device->driver_data = root; |
||
489 | |||
1625 | serge | 490 | |
491 | * All supported architectures that use ACPI have support for |
||
1627 | serge | 492 | * PCI domains, so we indicate this in _OSC support capabilities. |
493 | */ |
||
1625 | serge | 494 | // flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT; |
1627 | serge | 495 | // acpi_pci_osc_support(root, flags); |
496 | |||
1625 | serge | 497 | |
498 | * TBD: Need PCI interface for enumeration/configuration of roots. |
||
1627 | serge | 499 | */ |
1625 | serge | 500 | |
501 | |||
1627 | serge | 502 | list_add_tail(&root->node, &acpi_pci_roots); |
503 | |||
1625 | serge | 504 | |
1627 | serge | 505 | acpi_device_name(device), acpi_device_bid(device), |
506 | root->segment, &root->secondary); |
||
507 | |||
1625 | serge | 508 | |
509 | * Scan the Root Bridge |
||
1627 | serge | 510 | * -------------------- |
511 | * Must do this prior to any attempt to bind the root device, as the |
||
512 | * PCI namespace does not get created until this call is made (and |
||
513 | * thus the root bridge's pci_dev does not exist). |
||
514 | */ |
||
1625 | serge | 515 | |
516 | |||
1627 | serge | 517 | if (!root->bus) { |
518 | printk(KERN_ERR PREFIX |
||
519 | "Bus %04x:%02x not present in PCI namespace\n", |
||
520 | root->segment, (unsigned int)root->secondary.start); |
||
521 | result = -ENODEV; |
||
522 | goto end; |
||
523 | } |
||
524 | |||
1625 | serge | 525 | |
1627 | serge | 526 | * Attach ACPI-PCI Context |
527 | * ----------------------- |
||
528 | * Thus binding the ACPI and PCI devices. |
||
529 | */ |
||
530 | result = acpi_pci_bind_root(device); |
||
1628 | serge | 531 | if (result) |
532 | goto end; |
||
533 | |||
1625 | serge | 534 | |
535 | * PCI Routing Table |
||
1627 | serge | 536 | * ----------------- |
537 | * Evaluate and parse _PRT, if exists. |
||
538 | */ |
||
1625 | serge | 539 | status = AcpiGetHandle(device->handle, METHOD_NAME__PRT, &handle); |
1627 | serge | 540 | if (ACPI_SUCCESS(status)) |
1625 | serge | 541 | result = acpi_pci_irq_add_prt(device->handle, root->bus); |
1627 | serge | 542 | |
1625 | serge | 543 | |
1627 | serge | 544 | * Scan and bind all _ADR-Based Devices |
545 | */ |
||
546 | list_for_each_entry(child, &device->children, node) |
||
1628 | serge | 547 | acpi_pci_bridge_scan(child); |
548 | |||
1625 | serge | 549 | |
1627 | serge | 550 | |
1625 | serge | 551 | |
1627 | serge | 552 | if (!list_empty(&root->node)) |
553 | list_del(&root->node); |
||
554 | kfree(root); |
||
555 | return result; |
||
556 | } |
||
1625 | serge | 557 | |
558 | |||
559 | |||
1627 | serge | 560 | { |
1625 | serge | 561 | {"PNP0A03", 0}, |
1627 | serge | 562 | {"", 0}, |
563 | }; |
||
1625 | serge | 564 | |
565 | |||
1627 | serge | 566 | { |
1625 | serge | 567 | struct acpi_device *child; |
568 | |||
569 | |||
1627 | serge | 570 | { |
571 | dbgprintf(PREFIX "PCI root %s\n", device->pnp.bus_id); |
||
572 | acpi_pci_root_add(device); |
||
573 | }; |
||
574 | |||
1625 | serge | 575 | |
576 | { |
||
577 | acpi_init_pci(child); |
||
1627 | serge | 578 | }; |
1625 | serge | 579 | |
1627 | serge | 580 | |
1625 | serge | 581 | |
582 | |||
1627 | serge | 583 | |
1498 | serge | 584 | { |
585 | u32_t retval; |
||
586 | |||
587 | |||
1500 | serge | 588 | |
589 | |||
1498 | serge | 590 | |
591 | |||
592 | return 0; |
||
593 | |||
594 | |||
1625 | serge | 595 | { |
596 | printf("Can't open /rd/1/drivers/acpi.log\nExit\n"); |
||
597 | return 0; |
||
598 | } |
||
599 | |||
600 | |||
1500 | serge | 601 | if (ACPI_FAILURE(status)) { |
602 | dbgprintf("Unable to reallocate ACPI tables\n"); |
||
603 | goto err; |
||
604 | } |
||
605 | |||
1498 | serge | 606 | |
1500 | serge | 607 | if (status != AE_OK) { |
608 | dbgprintf("AcpiInitializeSubsystem failed (%s)\n", |
||
609 | AcpiFormatException(status)); |
||
610 | goto err; |
||
611 | } |
||
612 | |||
1498 | serge | 613 | |
1500 | serge | 614 | if (status != AE_OK) { |
615 | dbgprintf("AcpiInitializeTables failed (%s)\n", |
||
616 | AcpiFormatException(status)); |
||
617 | goto err; |
||
618 | } |
||
619 | |||
1498 | serge | 620 | |
1500 | serge | 621 | if (status != AE_OK) { |
622 | dbgprintf("AcpiLoadTables failed (%s)\n", |
||
623 | AcpiFormatException(status)); |
||
624 | goto err; |
||
625 | } |
||
626 | |||
1498 | serge | 627 | |
1625 | serge | 628 | |
1498 | serge | 629 | |
1625 | serge | 630 | if (status != AE_OK) { |
1498 | serge | 631 | dbgprintf("AcpiEnableSubsystem failed (%s)\n", |
632 | AcpiFormatException(status)); |
||
633 | goto err; |
||
634 | } |
||
635 | |||
636 | |||
1625 | serge | 637 | if (ACPI_FAILURE (status)) |
1498 | serge | 638 | { |
639 | dbgprintf("AcpiInitializeObjects failed (%s)\n", |
||
640 | AcpiFormatException(status)); |
||
641 | goto err; |
||
642 | } |
||
643 | |||
644 | |||
1625 | serge | 645 | |
646 | |||
647 | |||
1627 | serge | 648 | |
1625 | serge | 649 | |
1627 | serge | 650 | |
1625 | serge | 651 | |
1627 | serge | 652 | |
1625 | serge | 653 | |
654 | ACPI_HANDLE bus_handle; |
||
655 | ACPI_HANDLE pci_root; |
||
656 | |||
657 | |||
658 | dbgprintf("system bus handle %x\n", bus_handle); |
||
659 | |||
660 | |||
661 | if (status != AE_OK) { |
||
662 | dbgprintf("AcpiGetHandle failed (%s)\n", |
||
663 | AcpiFormatException(status)); |
||
664 | goto err; |
||
665 | } |
||
666 | |||
667 | |||
668 | get_device_by_hid_callback, NULL, NULL, NULL); |
||
1498 | serge | 669 | */ |
1625 | serge | 670 | |
1498 | serge | 671 | |
672 | |||
673 | |||
1625 | serge | 674 | get_device_by_hid_callback, NULL, NULL, NULL); |
675 | |||
676 | |||
1498 | serge | 677 | ACPI_HANDLE bus_handle; |
678 | ACPI_HANDLE pci_root; |
||
679 | |||
680 | |||
681 | dbgprintf("system bus handle %x\n", bus_handle); |
||
682 | |||
683 | |||
684 | |||
685 | |||
686 | dbgprintf("AcpiGetHandle failed (%s)\n", |
||
687 | AcpiFormatException(status)); |
||
688 | goto err; |
||
689 | } |
||
690 | |||
691 | |||
692 | |||
693 | |||
694 | |||
695 | |||
696 | prt_buffer.Pointer = NULL; |
||
697 | |||
698 | |||
699 | |||
700 | |||
701 | dbgprintf("AcpiGetIrqRoutingTable failed (%s)\n", |
||
702 | AcpiFormatException(status)); |
||
703 | goto err; |
||
704 | } |
||
705 | |||
706 | |||
707 | |||
708 | |||
709 | |||
710 | ACPI_OBJECT_LIST arg_list = { 1, &arg }; |
||
711 | |||
712 | |||
713 | |||
714 | |||
715 | |||
716 | |||
717 | |||
718 | |||
719 | dbgprintf("AcpiEvaluateObject failed (%s)\n", |
||
720 | AcpiFormatException(status)); |
||
721 | // goto err; |
||
722 | } |
||
723 | |||
724 | |||
725 | |||
726 | |||
727 | |||
728 | dbgprintf("AcpiGetIrqRoutingTable failed (%s)\n", |
||
729 | AcpiFormatException(status)); |
||
730 | goto err; |
||
731 | } |
||
732 | |||
733 | |||
734 | |||
735 | |||
736 | dbgprintf("bus 0 device 31 function 1 pin %d\n", pin-1); |
||
737 | |||
738 | |||
739 | dbgprintf("bus 0 device 31 function 2 pin %d\n", pin-1); |
||
740 | |||
741 | |||
742 | dbgprintf("bus 0 device 31 function 3 pin %d\n", pin-1); |
||
743 | |||
744 | |||
745 | dbgprintf("bus 0 device 31 function 4 pin %d\n", pin-1); |
||
746 | |||
747 | |||
748 | dbgprintf("bus 0 device 31 function 5 pin %d\n", pin-1); |
||
749 | |||
750 | |||
751 | dbgprintf("bus 0 device 31 function 6 pin %d\n", pin-1); |
||
752 | |||
753 | |||
754 | dbgprintf("bus 0 device 31 function 7 pin %d\n", pin-1); |
||
755 | #endif |
||
756 | |||
757 | |||
758 | |||
759 | |||
760 | |||
761 | |||
762 | |||
763 | |||
1627 | serge | 764 | |
1625 | serge | 765 | |
766 | get_device_by_hid_callback(ACPI_HANDLE obj, u32_t depth, void* context, |
||
767 | void** retval) |
||
768 | { |
||
769 | static u32_t counter = 0; |
||
770 | static char buff[256]; |
||
771 | |||
772 | |||
773 | |||
774 | |||
775 | |||
776 | |||
777 | |||
778 | |||
779 | |||
780 | |||
781 | buffer.Pointer = buff; |
||
782 | |||
783 | |||
784 | if (status != AE_OK) { |
||
785 | return AE_CTRL_TERMINATE; |
||
786 | } |
||
787 | |||
788 | |||
789 | |||
790 | |||
791 | |||
792 | |||
793 | |||
794 | |||
795 | { |
||
796 | if (info->Valid & ACPI_VALID_HID) |
||
797 | dbgprintf (" HID: %s", info->HardwareId.String); |
||
798 | |||
799 | |||
800 | |||
801 | |||
802 | counter++; |
||
803 | |||
804 | |||
805 | } |
||
806 | |||
807 | |||
808 | { |
||
809 | ACPI_PCI_ROUTING_TABLE *entry; |
||
810 | char *prtptr; |
||
811 | |||
812 | |||
813 | if (prt == NULL || prt->Pointer == NULL) |
||
814 | return; |
||
815 | |||
816 | |||
817 | prtptr = prt->Pointer; |
||
818 | entry = (ACPI_PCI_ROUTING_TABLE *)prtptr; |
||
819 | while (entry->Length != 0) |
||
820 | { |
||
821 | |||
822 | |||
823 | (u32_t)entry->Address); |
||
824 | dbgprintf("pin: %d index: %d source: %s\n", |
||
825 | entry->Pin, |
||
826 | entry->SourceIndex, |
||
827 | entry->Source); |
||
828 | |||
829 | |||
830 | prtptr += entry->Length; |
||
831 | entry = (ACPI_PCI_ROUTING_TABLE *)prtptr; |
||
832 | } |
||
833 | } |
||
834 | |||
835 | |||
836 | |||
837 | { |
||
838 | // assert(dev < PCI_MAX_DEVICES && pin < PCI_MAX_PINS); |
||
839 | |||
840 | |||
841 | } |
||
842 | |||
843 | |||
844 | { |
||
845 | ACPI_PCI_ROUTING_TABLE *tbl = (ACPI_PCI_ROUTING_TABLE *) context; |
||
846 | |||
847 | |||
848 | { |
||
849 | ACPI_RESOURCE_IRQ *irq; |
||
850 | |||
851 | |||
852 | add_irq(tbl->Address >> 16, tbl->Pin, |
||
853 | irq->Interrupts[tbl->SourceIndex]); |
||
854 | } else if (res->Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) |
||
855 | { |
||
856 | ACPI_RESOURCE_EXTENDED_IRQ *irq; |
||
857 | |||
858 | |||
859 | irq->Interrupts[tbl->SourceIndex]); |
||
860 | } |
||
861 | |||
862 | |||
863 | } |
||
864 | |||
865 | |||
866 | |||
867 | |||
868 | { |
||
869 | ACPI_STATUS status; |
||
870 | ACPI_BUFFER abuff; |
||
871 | ACPI_PCI_ROUTING_TABLE *tbl; |
||
872 | |||
873 | |||
874 | abuff.Pointer = buff; |
||
875 | |||
876 | |||
877 | if (ACPI_FAILURE(status)) { |
||
878 | return AE_OK; |
||
879 | } |
||
880 | |||
881 | |||
882 | tbl = (ACPI_PCI_ROUTING_TABLE *) |
||
883 | ((char *)tbl + tbl->Length)) |
||
884 | { |
||
885 | ACPI_HANDLE src_handle; |
||
886 | |||
887 | |||
888 | add_irq(tbl->Address >> 16, tbl->Pin, tbl->SourceIndex); |
||
889 | continue; |
||
890 | } |
||
891 | |||
892 | |||
893 | if (ACPI_FAILURE(status)) { |
||
894 | printf("Failed AcpiGetHandle\n"); |
||
895 | continue; |
||
896 | } |
||
897 | status = AcpiWalkResources(src_handle, METHOD_NAME__CRS, |
||
898 | get_irq_resource, tbl); |
||
899 | if (ACPI_FAILURE(status)) { |
||
900 | printf("Failed IRQ resource\n"); |
||
901 | continue; |
||
902 | } |
||
903 | } |
||
904 | |||
905 | |||
906 | } |
||
907 | |||
908 | |||
909 | UINT32 level, |
||
910 | void *context, |
||
911 | void **retval) |
||
912 | { |
||
913 | int i; |
||
914 | static unsigned called; |
||
915 | |||
916 | |||
917 | dbgprintf("ACPI: Warning! Multi rooted PCI is not supported!\n"); |
||
918 | return AE_OK; |
||
919 | } |
||
920 | |||
921 | |||
922 | irqtable[i] = -1; |
||
923 | |||
924 | |||
925 | } |
||
926 | |||
927 | |||
928 | UINT32 level, |
||
929 | void *context, |
||
930 | void **retval) |
||
931 | { |
||
932 | /* skip pci root when we get to it again */ |
||
933 | if (handle == pci_root_handle) |
||
934 | return AE_OK; |
||
935 | |||
936 | |||
937 | } |
||
938 | |||
939 | |||
940 | { |
||
941 | ACPI_STATUS status; |
||
942 | |||
943 | |||
944 | status = AcpiGetDevices("PNP0A03", add_pci_root_dev, NULL, NULL); |
||
945 | if (status != AE_OK) { |
||
946 | dbgprintf("scan_devices failed (%s)\n", |
||
947 | AcpiFormatException(status)); |
||
948 | return; |
||
949 | } |
||
950 | |||
951 | |||
952 | |||
953 | |||
954 | status = AcpiGetDevices(NULL, add_pci_dev, NULL, NULL); |
||
955 | // assert(ACPI_SUCCESS(status)); |
||
956 | } |
||
957 | |||
958 | |||
959 | |||
1627 | serge | 960 | |
961 | { |
||
962 | size_t len = strlen (str) + 1; |
||
963 | char *copy = malloc(len); |
||
964 | if (copy) |
||
965 | { |
||
966 | memcpy (copy, str, len); |
||
967 | } |
||
968 | return copy; |
||
969 | }>>>3)><3)>3)><3)>3)><3)>3)><3)>3)><3)>3)><3)>3)><3)> |
||
970 |