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