drivers/acpi/osl.c

   1 /*
   2  *  acpi_osl.c - OS-dependent functions ($Revision: 83 $)
   3  *
   4  *  Copyright (C) 2000       Andrew Henroid
   5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   7  *  Copyright (c) 2008 Intel Corporation
   8  *   Author: Matthew Wilcox <willy@linux.intel.com>
   9  *
  10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  *
  26  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  27  *
  28  */
  29
  30 #include <linux/module.h>
  31 #include <linux/kernel.h>
  32 #include <linux/slab.h>
  33 #include <linux/mm.h>
  34 #include <linux/pci.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/kmod.h>
  37 #include <linux/delay.h>
  38 #include <linux/workqueue.h>
  39 #include <linux/nmi.h>
  40 #include <linux/acpi.h>
  41 #include <linux/efi.h>
  42 #include <linux/ioport.h>
  43 #include <linux/list.h>
  44 #include <linux/jiffies.h>
  45 #include <linux/semaphore.h>
  46
  47 #include <asm/io.h>
  48 #include <asm/uaccess.h>
  49
  50 #include <acpi/acpi.h>
  51 #include <acpi/acpi_bus.h>
  52 #include <acpi/processor.h>
  53
  54 #define _COMPONENT              ACPI_OS_SERVICES
  55 ACPI_MODULE_NAME("osl");
  56 #define PREFIX          "ACPI: "
  57 struct acpi_os_dpc {
  58         acpi_osd_exec_callback function;
  59         void *context;
  60         struct work_struct work;
  61 };
  62
  63 #ifdef CONFIG_ACPI_CUSTOM_DSDT
  64 #include CONFIG_ACPI_CUSTOM_DSDT_FILE
  65 #endif
  66
  67 #ifdef ENABLE_DEBUGGER
  68 #include <linux/kdb.h>
  69
  70 /* stuff for debugger support */
  71 int acpi_in_debugger;
  72 EXPORT_SYMBOL(acpi_in_debugger);
  73
  74 extern char line_buf[80];
  75 #endif                          /*ENABLE_DEBUGGER */
  76
  77 static unsigned int acpi_irq_irq;
  78 static acpi_osd_handler acpi_irq_handler;
  79 static void *acpi_irq_context;
  80 static struct workqueue_struct *kacpid_wq;
  81 static struct workqueue_struct *kacpi_notify_wq;
  82 static struct workqueue_struct *kacpi_hotplug_wq;
  83
  84 struct acpi_res_list {
  85         resource_size_t start;
  86         resource_size_t end;
  87         acpi_adr_space_type resource_type; /* IO port, System memory, ...*/
  88         char name[5];   /* only can have a length of 4 chars, make use of this
  89                            one instead of res->name, no need to kalloc then */
  90         struct list_head resource_list;
  91 };
  92
  93 static LIST_HEAD(resource_list_head);
  94 static DEFINE_SPINLOCK(acpi_res_lock);
  95
  96 #define OSI_STRING_LENGTH_MAX 64        /* arbitrary */
  97 static char osi_additional_string[OSI_STRING_LENGTH_MAX];
  98
  99 /*
 100  * The story of _OSI(Linux)
 101  *
 102  * From pre-history through Linux-2.6.22,
 103  * Linux responded TRUE upon a BIOS OSI(Linux) query.
 104  *
 105  * Unfortunately, reference BIOS writers got wind of this
 106  * and put OSI(Linux) in their example code, quickly exposing
 107  * this string as ill-conceived and opening the door to
 108  * an un-bounded number of BIOS incompatibilities.
 109  *
 110  * For example, OSI(Linux) was used on resume to re-POST a
 111  * video card on one system, because Linux at that time
 112  * could not do a speedy restore in its native driver.
 113  * But then upon gaining quick native restore capability,
 114  * Linux has no way to tell the BIOS to skip the time-consuming
 115  * POST -- putting Linux at a permanent performance disadvantage.
 116  * On another system, the BIOS writer used OSI(Linux)
 117  * to infer native OS support for IPMI!  On other systems,
 118  * OSI(Linux) simply got in the way of Linux claiming to
 119  * be compatible with other operating systems, exposing
 120  * BIOS issues such as skipped device initialization.
 121  *
 122  * So "Linux" turned out to be a really poor chose of
 123  * OSI string, and from Linux-2.6.23 onward we respond FALSE.
 124  *
 125  * BIOS writers should NOT query _OSI(Linux) on future systems.
 126  * Linux will complain on the console when it sees it, and return FALSE.
 127  * To get Linux to return TRUE for your system  will require
 128  * a kernel source update to add a DMI entry,
 129  * or boot with "acpi_osi=Linux"
 130  */
 131
 132 static struct osi_linux {
 133         unsigned int    enable:1;
 134         unsigned int    dmi:1;
 135         unsigned int    cmdline:1;
 136         unsigned int    known:1;
 137 } osi_linux = { 0, 0, 0, 0};
 138
 139 static void __init acpi_request_region (struct acpi_generic_address *addr,
 140         unsigned int length, char *desc)
 141 {
 142         struct resource *res;
 143
 144         if (!addr->address || !length)
 145                 return;
 146
 147         if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
 148                 res = request_region(addr->address, length, desc);
 149         else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
 150                 res = request_mem_region(addr->address, length, desc);
 151 }
 152
 153 static int __init acpi_reserve_resources(void)
 154 {
 155         acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
 156                 "ACPI PM1a_EVT_BLK");
 157
 158         acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
 159                 "ACPI PM1b_EVT_BLK");
 160
 161         acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
 162                 "ACPI PM1a_CNT_BLK");
 163
 164         acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
 165                 "ACPI PM1b_CNT_BLK");
 166
 167         if (acpi_gbl_FADT.pm_timer_length == 4)
 168                 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
 169
 170         acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
 171                 "ACPI PM2_CNT_BLK");
 172
 173         /* Length of GPE blocks must be a non-negative multiple of 2 */
 174
 175         if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
 176                 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
 177                                acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
 178
 179         if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
 180                 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
 181                                acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
 182
 183         return 0;
 184 }
 185 device_initcall(acpi_reserve_resources);
 186
 187 acpi_status __init acpi_os_initialize(void)
 188 {
 189         return AE_OK;
 190 }
 191
 192 static void bind_to_cpu0(struct work_struct *work)
 193 {
 194         set_cpus_allowed(current, cpumask_of_cpu(0));
 195         kfree(work);
 196 }
 197
 198 static void bind_workqueue(struct workqueue_struct *wq)
 199 {
 200         struct work_struct *work;
 201
 202         work = kzalloc(sizeof(struct work_struct), GFP_KERNEL);
 203         INIT_WORK(work, bind_to_cpu0);
 204         queue_work(wq, work);
 205 }
 206
 207 acpi_status acpi_os_initialize1(void)
 208 {
 209         /*
 210          * On some machines, a software-initiated SMI causes corruption unless
 211          * the SMI runs on CPU 0.  An SMI can be initiated by any AML, but
 212          * typically it's done in GPE-related methods that are run via
 213          * workqueues, so we can avoid the known corruption cases by binding
 214          * the workqueues to CPU 0.
 215          */
 216         kacpid_wq = create_singlethread_workqueue("kacpid");
 217         bind_workqueue(kacpid_wq);
 218         kacpi_notify_wq = create_singlethread_workqueue("kacpi_notify");
 219         bind_workqueue(kacpi_notify_wq);
 220         kacpi_hotplug_wq = create_singlethread_workqueue("kacpi_hotplug");
 221         bind_workqueue(kacpi_hotplug_wq);
 222         BUG_ON(!kacpid_wq);
 223         BUG_ON(!kacpi_notify_wq);
 224         BUG_ON(!kacpi_hotplug_wq);
 225         return AE_OK;
 226 }
 227
 228 acpi_status acpi_os_terminate(void)
 229 {
 230         if (acpi_irq_handler) {
 231                 acpi_os_remove_interrupt_handler(acpi_irq_irq,
 232                                                  acpi_irq_handler);
 233         }
 234
 235         destroy_workqueue(kacpid_wq);
 236         destroy_workqueue(kacpi_notify_wq);
 237         destroy_workqueue(kacpi_hotplug_wq);
 238
 239         return AE_OK;
 240 }
 241
 242 void acpi_os_printf(const char *fmt, ...)
 243 {
 244         va_list args;
 245         va_start(args, fmt);
 246         acpi_os_vprintf(fmt, args);
 247         va_end(args);
 248 }
 249
 250 void acpi_os_vprintf(const char *fmt, va_list args)
 251 {
 252         static char buffer[512];
 253
 254         vsprintf(buffer, fmt, args);
 255
 256 #ifdef ENABLE_DEBUGGER
 257         if (acpi_in_debugger) {
 258                 kdb_printf("%s", buffer);
 259         } else {
 260                 printk(KERN_CONT "%s", buffer);
 261         }
 262 #else
 263         printk(KERN_CONT "%s", buffer);
 264 #endif
 265 }
 266
 267 acpi_physical_address __init acpi_os_get_root_pointer(void)
 268 {
 269         if (efi_enabled) {
 270                 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 271                         return efi.acpi20;
 272                 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 273                         return efi.acpi;
 274                 else {
 275                         printk(KERN_ERR PREFIX
 276                                "System description tables not found\n");
 277                         return 0;
 278                 }
 279         } else {
 280                 acpi_physical_address pa = 0;
 281
 282                 acpi_find_root_pointer(&pa);
 283                 return pa;
 284         }
 285 }
 286
 287 void __iomem *__init_refok
 288 acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
 289 {
 290         if (phys > ULONG_MAX) {
 291                 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
 292                 return NULL;
 293         }
 294         if (acpi_gbl_permanent_mmap)
 295                 /*
 296                 * ioremap checks to ensure this is in reserved space
 297                 */
 298                 return ioremap((unsigned long)phys, size);
 299         else
 300                 return __acpi_map_table((unsigned long)phys, size);
 301 }
 302 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
 303
 304 void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
 305 {
 306         if (acpi_gbl_permanent_mmap)
 307                 iounmap(virt);
 308         else
 309                 __acpi_unmap_table(virt, size);
 310 }
 311 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
 312
 313 void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
 314 {
 315         if (!acpi_gbl_permanent_mmap)
 316                 __acpi_unmap_table(virt, size);
 317 }
 318
 319 #ifdef ACPI_FUTURE_USAGE
 320 acpi_status
 321 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
 322 {
 323         if (!phys || !virt)
 324                 return AE_BAD_PARAMETER;
 325
 326         *phys = virt_to_phys(virt);
 327
 328         return AE_OK;
 329 }
 330 #endif
 331
 332 #define ACPI_MAX_OVERRIDE_LEN 100
 333
 334 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
 335
 336 acpi_status
 337 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
 338                             acpi_string * new_val)
 339 {
 340         if (!init_val || !new_val)
 341                 return AE_BAD_PARAMETER;
 342
 343         *new_val = NULL;
 344         if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
 345                 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
 346                        acpi_os_name);
 347                 *new_val = acpi_os_name;
 348         }
 349
 350         return AE_OK;
 351 }
 352
 353 acpi_status
 354 acpi_os_table_override(struct acpi_table_header * existing_table,
 355                        struct acpi_table_header ** new_table)
 356 {
 357         if (!existing_table || !new_table)
 358                 return AE_BAD_PARAMETER;
 359
 360         *new_table = NULL;
 361
 362 #ifdef CONFIG_ACPI_CUSTOM_DSDT
 363         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
 364                 *new_table = (struct acpi_table_header *)AmlCode;
 365 #endif
 366         if (*new_table != NULL) {
 367                 printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
 368                            "this is unsafe: tainting kernel\n",
 369                        existing_table->signature,
 370                        existing_table->oem_table_id);
 371                 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
 372         }
 373         return AE_OK;
 374 }
 375
 376 static irqreturn_t acpi_irq(int irq, void *dev_id)
 377 {
 378         u32 handled;
 379
 380         handled = (*acpi_irq_handler) (acpi_irq_context);
 381
 382         if (handled) {
 383                 acpi_irq_handled++;
 384                 return IRQ_HANDLED;
 385         } else {
 386                 acpi_irq_not_handled++;
 387                 return IRQ_NONE;
 388         }
 389 }
 390
 391 acpi_status
 392 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
 393                                   void *context)
 394 {
 395         unsigned int irq;
 396
 397         acpi_irq_stats_init();
 398
 399         /*
 400          * Ignore the GSI from the core, and use the value in our copy of the
 401          * FADT. It may not be the same if an interrupt source override exists
 402          * for the SCI.
 403          */
 404         gsi = acpi_gbl_FADT.sci_interrupt;
 405         if (acpi_gsi_to_irq(gsi, &irq) < 0) {
 406                 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
 407                        gsi);
 408                 return AE_OK;
 409         }
 410
 411         acpi_irq_handler = handler;
 412         acpi_irq_context = context;
 413         if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
 414                 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
 415                 return AE_NOT_ACQUIRED;
 416         }
 417         acpi_irq_irq = irq;
 418
 419         return AE_OK;
 420 }
 421
 422 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
 423 {
 424         if (irq) {
 425                 free_irq(irq, acpi_irq);
 426                 acpi_irq_handler = NULL;
 427                 acpi_irq_irq = 0;
 428         }
 429
 430         return AE_OK;
 431 }
 432
 433 /*
 434  * Running in interpreter thread context, safe to sleep
 435  */
 436
 437 void acpi_os_sleep(acpi_integer ms)
 438 {
 439         schedule_timeout_interruptible(msecs_to_jiffies(ms));
 440 }
 441
 442 void acpi_os_stall(u32 us)
 443 {
 444         while (us) {
 445                 u32 delay = 1000;
 446
 447                 if (delay > us)
 448                         delay = us;
 449                 udelay(delay);
 450                 touch_nmi_watchdog();
 451                 us -= delay;
 452         }
 453 }
 454
 455 /*
 456  * Support ACPI 3.0 AML Timer operand
 457  * Returns 64-bit free-running, monotonically increasing timer
 458  * with 100ns granularity
 459  */
 460 u64 acpi_os_get_timer(void)
 461 {
 462         static u64 t;
 463
 464 #ifdef  CONFIG_HPET
 465         /* TBD: use HPET if available */
 466 #endif
 467
 468 #ifdef  CONFIG_X86_PM_TIMER
 469         /* TBD: default to PM timer if HPET was not available */
 470 #endif
 471         if (!t)
 472                 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
 473
 474         return ++t;
 475 }
 476
 477 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
 478 {
 479         u32 dummy;
 480
 481         if (!value)
 482                 value = &dummy;
 483
 484         *value = 0;
 485         if (width <= 8) {
 486                 *(u8 *) value = inb(port);
 487         } else if (width <= 16) {
 488                 *(u16 *) value = inw(port);
 489         } else if (width <= 32) {
 490                 *(u32 *) value = inl(port);
 491         } else {
 492                 BUG();
 493         }
 494
 495         return AE_OK;
 496 }
 497
 498 EXPORT_SYMBOL(acpi_os_read_port);
 499
 500 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
 501 {
 502         if (width <= 8) {
 503                 outb(value, port);
 504         } else if (width <= 16) {
 505                 outw(value, port);
 506         } else if (width <= 32) {
 507                 outl(value, port);
 508         } else {
 509                 BUG();
 510         }
 511
 512         return AE_OK;
 513 }
 514
 515 EXPORT_SYMBOL(acpi_os_write_port);
 516
 517 acpi_status
 518 acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
 519 {
 520         u32 dummy;
 521         void __iomem *virt_addr;
 522
 523         virt_addr = ioremap(phys_addr, width);
 524         if (!value)
 525                 value = &dummy;
 526
 527         switch (width) {
 528         case 8:
 529                 *(u8 *) value = readb(virt_addr);
 530                 break;
 531         case 16:
 532                 *(u16 *) value = readw(virt_addr);
 533                 break;
 534         case 32:
 535                 *(u32 *) value = readl(virt_addr);
 536                 break;
 537         default:
 538                 BUG();
 539         }
 540
 541         iounmap(virt_addr);
 542
 543         return AE_OK;
 544 }
 545
 546 acpi_status
 547 acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
 548 {
 549         void __iomem *virt_addr;
 550
 551         virt_addr = ioremap(phys_addr, width);
 552
 553         switch (width) {
 554         case 8:
 555                 writeb(value, virt_addr);
 556                 break;
 557         case 16:
 558                 writew(value, virt_addr);
 559                 break;
 560         case 32:
 561                 writel(value, virt_addr);
 562                 break;
 563         default:
 564                 BUG();
 565         }
 566
 567         iounmap(virt_addr);
 568
 569         return AE_OK;
 570 }
 571
 572 acpi_status
 573 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
 574                                u32 *value, u32 width)
 575 {
 576         int result, size;
 577
 578         if (!value)
 579                 return AE_BAD_PARAMETER;
 580
 581         switch (width) {
 582         case 8:
 583                 size = 1;
 584                 break;
 585         case 16:
 586                 size = 2;
 587                 break;
 588         case 32:
 589                 size = 4;
 590                 break;
 591         default:
 592                 return AE_ERROR;
 593         }
 594
 595         result = raw_pci_read(pci_id->segment, pci_id->bus,
 596                                 PCI_DEVFN(pci_id->device, pci_id->function),
 597                                 reg, size, value);
 598
 599         return (result ? AE_ERROR : AE_OK);
 600 }
 601
 602 acpi_status
 603 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
 604                                 acpi_integer value, u32 width)
 605 {
 606         int result, size;
 607
 608         switch (width) {
 609         case 8:
 610                 size = 1;
 611                 break;
 612         case 16:
 613                 size = 2;
 614                 break;
 615         case 32:
 616                 size = 4;
 617                 break;
 618         default:
 619                 return AE_ERROR;
 620         }
 621
 622         result = raw_pci_write(pci_id->segment, pci_id->bus,
 623                                 PCI_DEVFN(pci_id->device, pci_id->function),
 624                                 reg, size, value);
 625
 626         return (result ? AE_ERROR : AE_OK);
 627 }
 628
 629 /* TODO: Change code to take advantage of driver model more */
 630 static void acpi_os_derive_pci_id_2(acpi_handle rhandle,        /* upper bound  */
 631                                     acpi_handle chandle,        /* current node */
 632                                     struct acpi_pci_id **id,
 633                                     int *is_bridge, u8 * bus_number)
 634 {
 635         acpi_handle handle;
 636         struct acpi_pci_id *pci_id = *id;
 637         acpi_status status;
 638         unsigned long long temp;
 639         acpi_object_type type;
 640
 641         acpi_get_parent(chandle, &handle);
 642         if (handle != rhandle) {
 643                 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
 644                                         bus_number);
 645
 646                 status = acpi_get_type(handle, &type);
 647                 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
 648                         return;
 649
 650                 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
 651                                           &temp);
 652                 if (ACPI_SUCCESS(status)) {
 653                         u32 val;
 654                         pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
 655                         pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
 656
 657                         if (*is_bridge)
 658                                 pci_id->bus = *bus_number;
 659
 660                         /* any nicer way to get bus number of bridge ? */
 661                         status =
 662                             acpi_os_read_pci_configuration(pci_id, 0x0e, &val,
 663                                                            8);
 664                         if (ACPI_SUCCESS(status)
 665                             && ((val & 0x7f) == 1 || (val & 0x7f) == 2)) {
 666                                 status =
 667                                     acpi_os_read_pci_configuration(pci_id, 0x18,
 668                                                                    &val, 8);
 669                                 if (!ACPI_SUCCESS(status)) {
 670                                         /* Certainly broken...  FIX ME */
 671                                         return;
 672                                 }
 673                                 *is_bridge = 1;
 674                                 pci_id->bus = val;
 675                                 status =
 676                                     acpi_os_read_pci_configuration(pci_id, 0x19,
 677                                                                    &val, 8);
 678                                 if (ACPI_SUCCESS(status)) {
 679                                         *bus_number = val;
 680                                 }
 681                         } else
 682                                 *is_bridge = 0;
 683                 }
 684         }
 685 }
 686
 687 void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound  */
 688                            acpi_handle chandle, /* current node */
 689                            struct acpi_pci_id **id)
 690 {
 691         int is_bridge = 1;
 692         u8 bus_number = (*id)->bus;
 693
 694         acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
 695 }
 696
 697 static void acpi_os_execute_deferred(struct work_struct *work)
 698 {
 699         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
 700         if (!dpc) {
 701                 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
 702                 return;
 703         }
 704
 705         dpc->function(dpc->context);
 706         kfree(dpc);
 707
 708         return;
 709 }
 710
 711 static void acpi_os_execute_hp_deferred(struct work_struct *work)
 712 {
 713         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
 714         if (!dpc) {
 715                 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
 716                 return;
 717         }
 718
 719         acpi_os_wait_events_complete(NULL);
 720
 721         dpc->function(dpc->context);
 722         kfree(dpc);
 723
 724         return;
 725 }
 726
 727 /*******************************************************************************
 728  *
 729  * FUNCTION:    acpi_os_execute
 730  *
 731  * PARAMETERS:  Type               - Type of the callback
 732  *              Function           - Function to be executed
 733  *              Context            - Function parameters
 734  *
 735  * RETURN:      Status
 736  *
 737  * DESCRIPTION: Depending on type, either queues function for deferred execution or
 738  *              immediately executes function on a separate thread.
 739  *
 740  ******************************************************************************/
 741
 742 static acpi_status __acpi_os_execute(acpi_execute_type type,
 743         acpi_osd_exec_callback function, void *context, int hp)
 744 {
 745         acpi_status status = AE_OK;
 746         struct acpi_os_dpc *dpc;
 747         struct workqueue_struct *queue;
 748         work_func_t func;
 749         int ret;
 750         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 751                           "Scheduling function [%p(%p)] for deferred execution.\n",
 752                           function, context));
 753
 754         if (!function)
 755                 return AE_BAD_PARAMETER;
 756
 757         /*
 758          * Allocate/initialize DPC structure.  Note that this memory will be
 759          * freed by the callee.  The kernel handles the work_struct list  in a
 760          * way that allows us to also free its memory inside the callee.
 761          * Because we may want to schedule several tasks with different
 762          * parameters we can't use the approach some kernel code uses of
 763          * having a static work_struct.
 764          */
 765
 766         dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
 767         if (!dpc)
 768                 return AE_NO_MEMORY;
 769
 770         dpc->function = function;
 771         dpc->context = context;
 772
 773         /*
 774          * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
 775          * because the hotplug code may call driver .remove() functions,
 776          * which invoke flush_scheduled_work/acpi_os_wait_events_complete
 777          * to flush these workqueues.
 778          */
 779         queue = hp ? kacpi_hotplug_wq :
 780                 (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
 781         func = hp ? acpi_os_execute_hp_deferred : acpi_os_execute_deferred;
 782         INIT_WORK(&dpc->work, func);
 783         ret = queue_work(queue, &dpc->work);
 784
 785         if (!ret) {
 786                 printk(KERN_ERR PREFIX
 787                           "Call to queue_work() failed.\n");
 788                 status = AE_ERROR;
 789                 kfree(dpc);
 790         }
 791         return status;
 792 }
 793
 794 acpi_status acpi_os_execute(acpi_execute_type type,
 795                             acpi_osd_exec_callback function, void *context)
 796 {
 797         return __acpi_os_execute(type, function, context, 0);
 798 }
 799 EXPORT_SYMBOL(acpi_os_execute);
 800
 801 acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
 802         void *context)
 803 {
 804         return __acpi_os_execute(0, function, context, 1);
 805 }
 806
 807 void acpi_os_wait_events_complete(void *context)
 808 {
 809         flush_workqueue(kacpid_wq);
 810         flush_workqueue(kacpi_notify_wq);
 811 }
 812
 813 EXPORT_SYMBOL(acpi_os_wait_events_complete);
 814
 815 /*
 816  * Allocate the memory for a spinlock and initialize it.
 817  */
 818 acpi_status acpi_os_create_lock(acpi_spinlock * handle)
 819 {
 820         spin_lock_init(*handle);
 821
 822         return AE_OK;
 823 }
 824
 825 /*
 826  * Deallocate the memory for a spinlock.
 827  */
 828 void acpi_os_delete_lock(acpi_spinlock handle)
 829 {
 830         return;
 831 }
 832
 833 acpi_status
 834 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 835 {
 836         struct semaphore *sem = NULL;
 837
 838         sem = acpi_os_allocate(sizeof(struct semaphore));
 839         if (!sem)
 840                 return AE_NO_MEMORY;
 841         memset(sem, 0, sizeof(struct semaphore));
 842
 843         sema_init(sem, initial_units);
 844
 845         *handle = (acpi_handle *) sem;
 846
 847         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
 848                           *handle, initial_units));
 849
 850         return AE_OK;
 851 }
 852
 853 /*
 854  * TODO: A better way to delete semaphores?  Linux doesn't have a
 855  * 'delete_semaphore()' function -- may result in an invalid
 856  * pointer dereference for non-synchronized consumers.  Should
 857  * we at least check for blocked threads and signal/cancel them?
 858  */
 859
 860 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 861 {
 862         struct semaphore *sem = (struct semaphore *)handle;
 863
 864         if (!sem)
 865                 return AE_BAD_PARAMETER;
 866
 867         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
 868
 869         BUG_ON(!list_empty(&sem->wait_list));
 870         kfree(sem);
 871         sem = NULL;
 872
 873         return AE_OK;
 874 }
 875
 876 /*
 877  * TODO: Support for units > 1?
 878  */
 879 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
 880 {
 881         acpi_status status = AE_OK;
 882         struct semaphore *sem = (struct semaphore *)handle;
 883         long jiffies;
 884         int ret = 0;
 885
 886         if (!sem || (units < 1))
 887                 return AE_BAD_PARAMETER;
 888
 889         if (units > 1)
 890                 return AE_SUPPORT;
 891
 892         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
 893                           handle, units, timeout));
 894
 895         if (timeout == ACPI_WAIT_FOREVER)
 896                 jiffies = MAX_SCHEDULE_TIMEOUT;
 897         else
 898                 jiffies = msecs_to_jiffies(timeout);
 899
 900         ret = down_timeout(sem, jiffies);
 901         if (ret)
 902                 status = AE_TIME;
 903
 904         if (ACPI_FAILURE(status)) {
 905                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
 906                                   "Failed to acquire semaphore[%p|%d|%d], %s",
 907                                   handle, units, timeout,
 908                                   acpi_format_exception(status)));
 909         } else {
 910                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
 911                                   "Acquired semaphore[%p|%d|%d]", handle,
 912                                   units, timeout));
 913         }
 914
 915         return status;
 916 }
 917
 918 /*
 919  * TODO: Support for units > 1?
 920  */
 921 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 922 {
 923         struct semaphore *sem = (struct semaphore *)handle;
 924
 925         if (!sem || (units < 1))
 926                 return AE_BAD_PARAMETER;
 927
 928         if (units > 1)
 929                 return AE_SUPPORT;
 930
 931         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
 932                           units));
 933
 934         up(sem);
 935
 936         return AE_OK;
 937 }
 938
 939 #ifdef ACPI_FUTURE_USAGE
 940 u32 acpi_os_get_line(char *buffer)
 941 {
 942
 943 #ifdef ENABLE_DEBUGGER
 944         if (acpi_in_debugger) {
 945                 u32 chars;
 946
 947                 kdb_read(buffer, sizeof(line_buf));
 948
 949                 /* remove the CR kdb includes */
 950                 chars = strlen(buffer) - 1;
 951                 buffer[chars] = '\0';
 952         }
 953 #endif
 954
 955         return 0;
 956 }
 957 #endif                          /*  ACPI_FUTURE_USAGE  */
 958
 959 acpi_status acpi_os_signal(u32 function, void *info)
 960 {
 961         switch (function) {
 962         case ACPI_SIGNAL_FATAL:
 963                 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
 964                 break;
 965         case ACPI_SIGNAL_BREAKPOINT:
 966                 /*
 967                  * AML Breakpoint
 968                  * ACPI spec. says to treat it as a NOP unless
 969                  * you are debugging.  So if/when we integrate
 970                  * AML debugger into the kernel debugger its
 971                  * hook will go here.  But until then it is
 972                  * not useful to print anything on breakpoints.
 973                  */
 974                 break;
 975         default:
 976                 break;
 977         }
 978
 979         return AE_OK;
 980 }
 981
 982 static int __init acpi_os_name_setup(char *str)
 983 {
 984         char *p = acpi_os_name;
 985         int count = ACPI_MAX_OVERRIDE_LEN - 1;
 986
 987         if (!str || !*str)
 988                 return 0;
 989
 990         for (; count-- && str && *str; str++) {
 991                 if (isalnum(*str) || *str == ' ' || *str == ':')
 992                         *p++ = *str;
 993                 else if (*str == '\'' || *str == '"')
 994                         continue;
 995                 else
 996                         break;
 997         }
 998         *p = 0;
 999
1000         return 1;
1001
1002 }
1003
1004 __setup("acpi_os_name=", acpi_os_name_setup);
1005
1006 static void __init set_osi_linux(unsigned int enable)
1007 {
1008         if (osi_linux.enable != enable) {
1009                 osi_linux.enable = enable;
1010                 printk(KERN_NOTICE PREFIX "%sed _OSI(Linux)\n",
1011                         enable ? "Add": "Delet");
1012         }
1013         return;
1014 }
1015
1016 static void __init acpi_cmdline_osi_linux(unsigned int enable)
1017 {
1018         osi_linux.cmdline = 1;  /* cmdline set the default */
1019         set_osi_linux(enable);
1020
1021         return;
1022 }
1023
1024 void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1025 {
1026         osi_linux.dmi = 1;      /* DMI knows that this box asks OSI(Linux) */
1027
1028         printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1029
1030         if (enable == -1)
1031                 return;
1032
1033         osi_linux.known = 1;    /* DMI knows which OSI(Linux) default needed */
1034
1035         set_osi_linux(enable);
1036
1037         return;
1038 }
1039
1040 /*
1041  * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1042  *
1043  * empty string disables _OSI
1044  * string starting with '!' disables that string
1045  * otherwise string is added to list, augmenting built-in strings
1046  */
1047 int __init acpi_osi_setup(char *str)
1048 {
1049         if (str == NULL || *str == '\0') {
1050                 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1051                 acpi_gbl_create_osi_method = FALSE;
1052         } else if (!strcmp("!Linux", str)) {
1053                 acpi_cmdline_osi_linux(0);      /* !enable */
1054         } else if (*str == '!') {
1055                 if (acpi_osi_invalidate(++str) == AE_OK)
1056                         printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1057         } else if (!strcmp("Linux", str)) {
1058                 acpi_cmdline_osi_linux(1);      /* enable */
1059         } else if (*osi_additional_string == '\0') {
1060                 strncpy(osi_additional_string, str, OSI_STRING_LENGTH_MAX);
1061                 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1062         }
1063
1064         return 1;
1065 }
1066
1067 __setup("acpi_osi=", acpi_osi_setup);
1068
1069 /* enable serialization to combat AE_ALREADY_EXISTS errors */
1070 static int __init acpi_serialize_setup(char *str)
1071 {
1072         printk(KERN_INFO PREFIX "serialize enabled\n");
1073
1074         acpi_gbl_all_methods_serialized = TRUE;
1075
1076         return 1;
1077 }
1078
1079 __setup("acpi_serialize", acpi_serialize_setup);
1080
1081 /*
1082  * Wake and Run-Time GPES are expected to be separate.
1083  * We disable wake-GPEs at run-time to prevent spurious
1084  * interrupts.
1085  *
1086  * However, if a system exists that shares Wake and
1087  * Run-time events on the same GPE this flag is available
1088  * to tell Linux to keep the wake-time GPEs enabled at run-time.
1089  */
1090 static int __init acpi_wake_gpes_always_on_setup(char *str)
1091 {
1092         printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
1093
1094         acpi_gbl_leave_wake_gpes_disabled = FALSE;
1095
1096         return 1;
1097 }
1098
1099 __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
1100
1101 /* Check of resource interference between native drivers and ACPI
1102  * OperationRegions (SystemIO and System Memory only).
1103  * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1104  * in arbitrary AML code and can interfere with legacy drivers.
1105  * acpi_enforce_resources= can be set to:
1106  *
1107  *   - strict (default) (2)
1108  *     -> further driver trying to access the resources will not load
1109  *   - lax              (1)
1110  *     -> further driver trying to access the resources will load, but you
1111  *     get a system message that something might go wrong...
1112  *
1113  *   - no               (0)
1114  *     -> ACPI Operation Region resources will not be registered
1115  *
1116  */
1117 #define ENFORCE_RESOURCES_STRICT 2
1118 #define ENFORCE_RESOURCES_LAX    1
1119 #define ENFORCE_RESOURCES_NO     0
1120
1121 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1122
1123 static int __init acpi_enforce_resources_setup(char *str)
1124 {
1125         if (str == NULL || *str == '\0')
1126                 return 0;
1127
1128         if (!strcmp("strict", str))
1129                 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1130         else if (!strcmp("lax", str))
1131                 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1132         else if (!strcmp("no", str))
1133                 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1134
1135         return 1;
1136 }
1137
1138 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1139
1140 /* Check for resource conflicts between ACPI OperationRegions and native
1141  * drivers */
1142 int acpi_check_resource_conflict(struct resource *res)
1143 {
1144         struct acpi_res_list *res_list_elem;
1145         int ioport;
1146         int clash = 0;
1147
1148         if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1149                 return 0;
1150         if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1151                 return 0;
1152
1153         ioport = res->flags & IORESOURCE_IO;
1154
1155         spin_lock(&acpi_res_lock);
1156         list_for_each_entry(res_list_elem, &resource_list_head,
1157                             resource_list) {
1158                 if (ioport && (res_list_elem->resource_type
1159                                != ACPI_ADR_SPACE_SYSTEM_IO))
1160                         continue;
1161                 if (!ioport && (res_list_elem->resource_type
1162                                 != ACPI_ADR_SPACE_SYSTEM_MEMORY))
1163                         continue;
1164
1165                 if (res->end < res_list_elem->start
1166                     || res_list_elem->end < res->start)
1167                         continue;
1168                 clash = 1;
1169                 break;
1170         }
1171         spin_unlock(&acpi_res_lock);
1172
1173         if (clash) {
1174                 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1175                         printk("%sACPI: %s resource %s [0x%llx-0x%llx]"
1176                                " conflicts with ACPI region %s"
1177                                " [0x%llx-0x%llx]\n",
1178                                acpi_enforce_resources == ENFORCE_RESOURCES_LAX
1179                                ? KERN_WARNING : KERN_ERR,
1180                                ioport ? "I/O" : "Memory", res->name,
1181                                (long long) res->start, (long long) res->end,
1182                                res_list_elem->name,
1183                                (long long) res_list_elem->start,
1184                                (long long) res_list_elem->end);
1185                         printk(KERN_INFO "ACPI: Device needs an ACPI driver\n");
1186                 }
1187                 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1188                         return -EBUSY;
1189         }
1190         return 0;
1191 }
1192 EXPORT_SYMBOL(acpi_check_resource_conflict);
1193
1194 int acpi_check_region(resource_size_t start, resource_size_t n,
1195                       const char *name)
1196 {
1197         struct resource res = {
1198                 .start = start,
1199                 .end   = start + n - 1,
1200                 .name  = name,
1201                 .flags = IORESOURCE_IO,
1202         };
1203
1204         return acpi_check_resource_conflict(&res);
1205 }
1206 EXPORT_SYMBOL(acpi_check_region);
1207
1208 int acpi_check_mem_region(resource_size_t start, resource_size_t n,
1209                       const char *name)
1210 {
1211         struct resource res = {
1212                 .start = start,
1213                 .end   = start + n - 1,
1214                 .name  = name,
1215                 .flags = IORESOURCE_MEM,
1216         };
1217
1218         return acpi_check_resource_conflict(&res);
1219
1220 }
1221 EXPORT_SYMBOL(acpi_check_mem_region);
1222
1223 /*
1224  * Acquire a spinlock.
1225  *
1226  * handle is a pointer to the spinlock_t.
1227  */
1228
1229 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1230 {
1231         acpi_cpu_flags flags;
1232         spin_lock_irqsave(lockp, flags);
1233         return flags;
1234 }
1235
1236 /*
1237  * Release a spinlock. See above.
1238  */
1239
1240 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1241 {
1242         spin_unlock_irqrestore(lockp, flags);
1243 }
1244
1245 #ifndef ACPI_USE_LOCAL_CACHE
1246
1247 /*******************************************************************************
1248  *
1249  * FUNCTION:    acpi_os_create_cache
1250  *
1251  * PARAMETERS:  name      - Ascii name for the cache
1252  *              size      - Size of each cached object
1253  *              depth     - Maximum depth of the cache (in objects) <ignored>
1254  *              cache     - Where the new cache object is returned
1255  *
1256  * RETURN:      status
1257  *
1258  * DESCRIPTION: Create a cache object
1259  *
1260  ******************************************************************************/
1261
1262 acpi_status
1263 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1264 {
1265         *cache = kmem_cache_create(name, size, 0, 0, NULL);
1266         if (*cache == NULL)
1267                 return AE_ERROR;
1268         else
1269                 return AE_OK;
1270 }
1271
1272 /*******************************************************************************
1273  *
1274  * FUNCTION:    acpi_os_purge_cache
1275  *
1276  * PARAMETERS:  Cache           - Handle to cache object
1277  *
1278  * RETURN:      Status
1279  *
1280  * DESCRIPTION: Free all objects within the requested cache.
1281  *
1282  ******************************************************************************/
1283
1284 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1285 {
1286         kmem_cache_shrink(cache);
1287         return (AE_OK);
1288 }
1289
1290 /*******************************************************************************
1291  *
1292  * FUNCTION:    acpi_os_delete_cache
1293  *
1294  * PARAMETERS:  Cache           - Handle to cache object
1295  *
1296  * RETURN:      Status
1297  *
1298  * DESCRIPTION: Free all objects within the requested cache and delete the
1299  *              cache object.
1300  *
1301  ******************************************************************************/
1302
1303 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1304 {
1305         kmem_cache_destroy(cache);
1306         return (AE_OK);
1307 }
1308
1309 /*******************************************************************************
1310  *
1311  * FUNCTION:    acpi_os_release_object
1312  *
1313  * PARAMETERS:  Cache       - Handle to cache object
1314  *              Object      - The object to be released
1315  *
1316  * RETURN:      None
1317  *
1318  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1319  *              the object is deleted.
1320  *
1321  ******************************************************************************/
1322
1323 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1324 {
1325         kmem_cache_free(cache, object);
1326         return (AE_OK);
1327 }
1328
1329 /******************************************************************************
1330  *
1331  * FUNCTION:    acpi_os_validate_interface
1332  *
1333  * PARAMETERS:  interface           - Requested interface to be validated
1334  *
1335  * RETURN:      AE_OK if interface is supported, AE_SUPPORT otherwise
1336  *
1337  * DESCRIPTION: Match an interface string to the interfaces supported by the
1338  *              host. Strings originate from an AML call to the _OSI method.
1339  *
1340  *****************************************************************************/
1341
1342 acpi_status
1343 acpi_os_validate_interface (char *interface)
1344 {
1345         if (!strncmp(osi_additional_string, interface, OSI_STRING_LENGTH_MAX))
1346                 return AE_OK;
1347         if (!strcmp("Linux", interface)) {
1348
1349                 printk(KERN_NOTICE PREFIX
1350                         "BIOS _OSI(Linux) query %s%s\n",
1351                         osi_linux.enable ? "honored" : "ignored",
1352                         osi_linux.cmdline ? " via cmdline" :
1353                         osi_linux.dmi ? " via DMI" : "");
1354
1355                 if (osi_linux.enable)
1356                         return AE_OK;
1357         }
1358         return AE_SUPPORT;
1359 }
1360
1361 /******************************************************************************
1362  *
1363  * FUNCTION:    acpi_os_validate_address
1364  *
1365  * PARAMETERS:  space_id             - ACPI space ID
1366  *              address             - Physical address
1367  *              length              - Address length
1368  *
1369  * RETURN:      AE_OK if address/length is valid for the space_id. Otherwise,
1370  *              should return AE_AML_ILLEGAL_ADDRESS.
1371  *
1372  * DESCRIPTION: Validate a system address via the host OS. Used to validate
1373  *              the addresses accessed by AML operation regions.
1374  *
1375  *****************************************************************************/
1376
1377 acpi_status
1378 acpi_os_validate_address (
1379     u8                   space_id,
1380     acpi_physical_address   address,
1381     acpi_size               length,
1382     char *name)
1383 {
1384         struct acpi_res_list *res;
1385         if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1386                 return AE_OK;
1387
1388         switch (space_id) {
1389         case ACPI_ADR_SPACE_SYSTEM_IO:
1390         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
1391                 /* Only interference checks against SystemIO and SytemMemory
1392                    are needed */
1393                 res = kzalloc(sizeof(struct acpi_res_list), GFP_KERNEL);
1394                 if (!res)
1395                         return AE_OK;
1396                 /* ACPI names are fixed to 4 bytes, still better use strlcpy */
1397                 strlcpy(res->name, name, 5);
1398                 res->start = address;
1399                 res->end = address + length - 1;
1400                 res->resource_type = space_id;
1401                 spin_lock(&acpi_res_lock);
1402                 list_add(&res->resource_list, &resource_list_head);
1403                 spin_unlock(&acpi_res_lock);
1404                 pr_debug("Added %s resource: start: 0x%llx, end: 0x%llx, "
1405                          "name: %s\n", (space_id == ACPI_ADR_SPACE_SYSTEM_IO)
1406                          ? "SystemIO" : "System Memory",
1407                          (unsigned long long)res->start,
1408                          (unsigned long long)res->end,
1409                          res->name);
1410                 break;
1411         case ACPI_ADR_SPACE_PCI_CONFIG:
1412         case ACPI_ADR_SPACE_EC:
1413         case ACPI_ADR_SPACE_SMBUS:
1414         case ACPI_ADR_SPACE_CMOS:
1415         case ACPI_ADR_SPACE_PCI_BAR_TARGET:
1416         case ACPI_ADR_SPACE_DATA_TABLE:
1417         case ACPI_ADR_SPACE_FIXED_HARDWARE:
1418                 break;
1419         }
1420         return AE_OK;
1421 }
1422
1423 #endif