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  *
   8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  25  *
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/slab.h>
  31 #include <linux/mm.h>
  32 #include <linux/pci.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/kmod.h>
  35 #include <linux/delay.h>
  36 #include <linux/workqueue.h>
  37 #include <linux/nmi.h>
  38 #include <linux/acpi.h>
  39 #include <acpi/acpi.h>
  40 #include <asm/io.h>
  41 #include <acpi/acpi_bus.h>
  42 #include <acpi/processor.h>
  43 #include <asm/uaccess.h>
  44
  45 #include <linux/efi.h>
  46
  47 #define _COMPONENT              ACPI_OS_SERVICES
  48 ACPI_MODULE_NAME("osl");
  49 #define PREFIX          "ACPI: "
  50 struct acpi_os_dpc {
  51         acpi_osd_exec_callback function;
  52         void *context;
  53         struct work_struct work;
  54 };
  55
  56 #ifdef CONFIG_ACPI_CUSTOM_DSDT
  57 #include CONFIG_ACPI_CUSTOM_DSDT_FILE
  58 #endif
  59
  60 #ifdef ENABLE_DEBUGGER
  61 #include <linux/kdb.h>
  62
  63 /* stuff for debugger support */
  64 int acpi_in_debugger;
  65 EXPORT_SYMBOL(acpi_in_debugger);
  66
  67 extern char line_buf[80];
  68 #endif                          /*ENABLE_DEBUGGER */
  69
  70 static unsigned int acpi_irq_irq;
  71 static acpi_osd_handler acpi_irq_handler;
  72 static void *acpi_irq_context;
  73 static struct workqueue_struct *kacpid_wq;
  74
  75 static void __init acpi_request_region (struct acpi_generic_address *addr,
  76         unsigned int length, char *desc)
  77 {
  78         struct resource *res;
  79
  80         if (!addr->address || !length)
  81                 return;
  82
  83         if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
  84                 res = request_region(addr->address, length, desc);
  85         else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
  86                 res = request_mem_region(addr->address, length, desc);
  87 }
  88
  89 static int __init acpi_reserve_resources(void)
  90 {
  91         acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
  92                 "ACPI PM1a_EVT_BLK");
  93
  94         acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
  95                 "ACPI PM1b_EVT_BLK");
  96
  97         acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
  98                 "ACPI PM1a_CNT_BLK");
  99
 100         acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
 101                 "ACPI PM1b_CNT_BLK");
 102
 103         if (acpi_gbl_FADT.pm_timer_length == 4)
 104                 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
 105
 106         acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
 107                 "ACPI PM2_CNT_BLK");
 108
 109         /* Length of GPE blocks must be a non-negative multiple of 2 */
 110
 111         if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
 112                 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
 113                                acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
 114
 115         if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
 116                 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
 117                                acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
 118
 119         return 0;
 120 }
 121 device_initcall(acpi_reserve_resources);
 122
 123 acpi_status acpi_os_initialize(void)
 124 {
 125         return AE_OK;
 126 }
 127
 128 acpi_status acpi_os_initialize1(void)
 129 {
 130         /*
 131          * Initialize PCI configuration space access, as we'll need to access
 132          * it while walking the namespace (bus 0 and root bridges w/ _BBNs).
 133          */
 134         if (!raw_pci_ops) {
 135                 printk(KERN_ERR PREFIX
 136                        "Access to PCI configuration space unavailable\n");
 137                 return AE_NULL_ENTRY;
 138         }
 139         kacpid_wq = create_singlethread_workqueue("kacpid");
 140         BUG_ON(!kacpid_wq);
 141
 142         return AE_OK;
 143 }
 144
 145 acpi_status acpi_os_terminate(void)
 146 {
 147         if (acpi_irq_handler) {
 148                 acpi_os_remove_interrupt_handler(acpi_irq_irq,
 149                                                  acpi_irq_handler);
 150         }
 151
 152         destroy_workqueue(kacpid_wq);
 153
 154         return AE_OK;
 155 }
 156
 157 void acpi_os_printf(const char *fmt, ...)
 158 {
 159         va_list args;
 160         va_start(args, fmt);
 161         acpi_os_vprintf(fmt, args);
 162         va_end(args);
 163 }
 164
 165 EXPORT_SYMBOL(acpi_os_printf);
 166
 167 void acpi_os_vprintf(const char *fmt, va_list args)
 168 {
 169         static char buffer[512];
 170
 171         vsprintf(buffer, fmt, args);
 172
 173 #ifdef ENABLE_DEBUGGER
 174         if (acpi_in_debugger) {
 175                 kdb_printf("%s", buffer);
 176         } else {
 177                 printk("%s", buffer);
 178         }
 179 #else
 180         printk("%s", buffer);
 181 #endif
 182 }
 183
 184 acpi_physical_address __init acpi_os_get_root_pointer(void)
 185 {
 186         if (efi_enabled) {
 187                 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 188                         return efi.acpi20;
 189                 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 190                         return efi.acpi;
 191                 else {
 192                         printk(KERN_ERR PREFIX
 193                                "System description tables not found\n");
 194                         return 0;
 195                 }
 196         } else
 197                 return acpi_find_rsdp();
 198 }
 199
 200 void __iomem *acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
 201 {
 202         if (phys > ULONG_MAX) {
 203                 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
 204                 return NULL;
 205         }
 206         if (acpi_gbl_permanent_mmap)
 207                 /*
 208                 * ioremap checks to ensure this is in reserved space
 209                 */
 210                 return ioremap((unsigned long)phys, size);
 211         else
 212                 return __acpi_map_table((unsigned long)phys, size);
 213 }
 214 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
 215
 216 void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
 217 {
 218         if (acpi_gbl_permanent_mmap) {
 219                 iounmap(virt);
 220         }
 221 }
 222 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
 223
 224 #ifdef ACPI_FUTURE_USAGE
 225 acpi_status
 226 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
 227 {
 228         if (!phys || !virt)
 229                 return AE_BAD_PARAMETER;
 230
 231         *phys = virt_to_phys(virt);
 232
 233         return AE_OK;
 234 }
 235 #endif
 236
 237 #define ACPI_MAX_OVERRIDE_LEN 100
 238
 239 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
 240
 241 acpi_status
 242 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
 243                             acpi_string * new_val)
 244 {
 245         if (!init_val || !new_val)
 246                 return AE_BAD_PARAMETER;
 247
 248         *new_val = NULL;
 249         if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
 250                 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
 251                        acpi_os_name);
 252                 *new_val = acpi_os_name;
 253         }
 254
 255         return AE_OK;
 256 }
 257
 258 acpi_status
 259 acpi_os_table_override(struct acpi_table_header * existing_table,
 260                        struct acpi_table_header ** new_table)
 261 {
 262         if (!existing_table || !new_table)
 263                 return AE_BAD_PARAMETER;
 264
 265 #ifdef CONFIG_ACPI_CUSTOM_DSDT
 266         if (strncmp(existing_table->signature, "DSDT", 4) == 0)
 267                 *new_table = (struct acpi_table_header *)AmlCode;
 268         else
 269                 *new_table = NULL;
 270 #else
 271         *new_table = NULL;
 272 #endif
 273         return AE_OK;
 274 }
 275
 276 static irqreturn_t acpi_irq(int irq, void *dev_id)
 277 {
 278         return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
 279 }
 280
 281 acpi_status
 282 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
 283                                   void *context)
 284 {
 285         unsigned int irq;
 286
 287         /*
 288          * Ignore the GSI from the core, and use the value in our copy of the
 289          * FADT. It may not be the same if an interrupt source override exists
 290          * for the SCI.
 291          */
 292         gsi = acpi_gbl_FADT.sci_interrupt;
 293         if (acpi_gsi_to_irq(gsi, &irq) < 0) {
 294                 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
 295                        gsi);
 296                 return AE_OK;
 297         }
 298
 299         acpi_irq_handler = handler;
 300         acpi_irq_context = context;
 301         if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
 302                 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
 303                 return AE_NOT_ACQUIRED;
 304         }
 305         acpi_irq_irq = irq;
 306
 307         return AE_OK;
 308 }
 309
 310 acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
 311 {
 312         if (irq) {
 313                 free_irq(irq, acpi_irq);
 314                 acpi_irq_handler = NULL;
 315                 acpi_irq_irq = 0;
 316         }
 317
 318         return AE_OK;
 319 }
 320
 321 /*
 322  * Running in interpreter thread context, safe to sleep
 323  */
 324
 325 void acpi_os_sleep(acpi_integer ms)
 326 {
 327         schedule_timeout_interruptible(msecs_to_jiffies(ms));
 328 }
 329
 330 EXPORT_SYMBOL(acpi_os_sleep);
 331
 332 void acpi_os_stall(u32 us)
 333 {
 334         while (us) {
 335                 u32 delay = 1000;
 336
 337                 if (delay > us)
 338                         delay = us;
 339                 udelay(delay);
 340                 touch_nmi_watchdog();
 341                 us -= delay;
 342         }
 343 }
 344
 345 EXPORT_SYMBOL(acpi_os_stall);
 346
 347 /*
 348  * Support ACPI 3.0 AML Timer operand
 349  * Returns 64-bit free-running, monotonically increasing timer
 350  * with 100ns granularity
 351  */
 352 u64 acpi_os_get_timer(void)
 353 {
 354         static u64 t;
 355
 356 #ifdef  CONFIG_HPET
 357         /* TBD: use HPET if available */
 358 #endif
 359
 360 #ifdef  CONFIG_X86_PM_TIMER
 361         /* TBD: default to PM timer if HPET was not available */
 362 #endif
 363         if (!t)
 364                 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
 365
 366         return ++t;
 367 }
 368
 369 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
 370 {
 371         u32 dummy;
 372
 373         if (!value)
 374                 value = &dummy;
 375
 376         switch (width) {
 377         case 8:
 378                 *(u8 *) value = inb(port);
 379                 break;
 380         case 16:
 381                 *(u16 *) value = inw(port);
 382                 break;
 383         case 32:
 384                 *(u32 *) value = inl(port);
 385                 break;
 386         default:
 387                 BUG();
 388         }
 389
 390         return AE_OK;
 391 }
 392
 393 EXPORT_SYMBOL(acpi_os_read_port);
 394
 395 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
 396 {
 397         switch (width) {
 398         case 8:
 399                 outb(value, port);
 400                 break;
 401         case 16:
 402                 outw(value, port);
 403                 break;
 404         case 32:
 405                 outl(value, port);
 406                 break;
 407         default:
 408                 BUG();
 409         }
 410
 411         return AE_OK;
 412 }
 413
 414 EXPORT_SYMBOL(acpi_os_write_port);
 415
 416 acpi_status
 417 acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
 418 {
 419         u32 dummy;
 420         void __iomem *virt_addr;
 421
 422         virt_addr = ioremap(phys_addr, width);
 423         if (!value)
 424                 value = &dummy;
 425
 426         switch (width) {
 427         case 8:
 428                 *(u8 *) value = readb(virt_addr);
 429                 break;
 430         case 16:
 431                 *(u16 *) value = readw(virt_addr);
 432                 break;
 433         case 32:
 434                 *(u32 *) value = readl(virt_addr);
 435                 break;
 436         default:
 437                 BUG();
 438         }
 439
 440         iounmap(virt_addr);
 441
 442         return AE_OK;
 443 }
 444
 445 acpi_status
 446 acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
 447 {
 448         void __iomem *virt_addr;
 449
 450         virt_addr = ioremap(phys_addr, width);
 451
 452         switch (width) {
 453         case 8:
 454                 writeb(value, virt_addr);
 455                 break;
 456         case 16:
 457                 writew(value, virt_addr);
 458                 break;
 459         case 32:
 460                 writel(value, virt_addr);
 461                 break;
 462         default:
 463                 BUG();
 464         }
 465
 466         iounmap(virt_addr);
 467
 468         return AE_OK;
 469 }
 470
 471 acpi_status
 472 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
 473                                void *value, u32 width)
 474 {
 475         int result, size;
 476
 477         if (!value)
 478                 return AE_BAD_PARAMETER;
 479
 480         switch (width) {
 481         case 8:
 482                 size = 1;
 483                 break;
 484         case 16:
 485                 size = 2;
 486                 break;
 487         case 32:
 488                 size = 4;
 489                 break;
 490         default:
 491                 return AE_ERROR;
 492         }
 493
 494         BUG_ON(!raw_pci_ops);
 495
 496         result = raw_pci_ops->read(pci_id->segment, pci_id->bus,
 497                                    PCI_DEVFN(pci_id->device, pci_id->function),
 498                                    reg, size, value);
 499
 500         return (result ? AE_ERROR : AE_OK);
 501 }
 502
 503 EXPORT_SYMBOL(acpi_os_read_pci_configuration);
 504
 505 acpi_status
 506 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
 507                                 acpi_integer value, u32 width)
 508 {
 509         int result, size;
 510
 511         switch (width) {
 512         case 8:
 513                 size = 1;
 514                 break;
 515         case 16:
 516                 size = 2;
 517                 break;
 518         case 32:
 519                 size = 4;
 520                 break;
 521         default:
 522                 return AE_ERROR;
 523         }
 524
 525         BUG_ON(!raw_pci_ops);
 526
 527         result = raw_pci_ops->write(pci_id->segment, pci_id->bus,
 528                                     PCI_DEVFN(pci_id->device, pci_id->function),
 529                                     reg, size, value);
 530
 531         return (result ? AE_ERROR : AE_OK);
 532 }
 533
 534 /* TODO: Change code to take advantage of driver model more */
 535 static void acpi_os_derive_pci_id_2(acpi_handle rhandle,        /* upper bound  */
 536                                     acpi_handle chandle,        /* current node */
 537                                     struct acpi_pci_id **id,
 538                                     int *is_bridge, u8 * bus_number)
 539 {
 540         acpi_handle handle;
 541         struct acpi_pci_id *pci_id = *id;
 542         acpi_status status;
 543         unsigned long temp;
 544         acpi_object_type type;
 545         u8 tu8;
 546
 547         acpi_get_parent(chandle, &handle);
 548         if (handle != rhandle) {
 549                 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
 550                                         bus_number);
 551
 552                 status = acpi_get_type(handle, &type);
 553                 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
 554                         return;
 555
 556                 status =
 557                     acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
 558                                           &temp);
 559                 if (ACPI_SUCCESS(status)) {
 560                         pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
 561                         pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
 562
 563                         if (*is_bridge)
 564                                 pci_id->bus = *bus_number;
 565
 566                         /* any nicer way to get bus number of bridge ? */
 567                         status =
 568                             acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8,
 569                                                            8);
 570                         if (ACPI_SUCCESS(status)
 571                             && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
 572                                 status =
 573                                     acpi_os_read_pci_configuration(pci_id, 0x18,
 574                                                                    &tu8, 8);
 575                                 if (!ACPI_SUCCESS(status)) {
 576                                         /* Certainly broken...  FIX ME */
 577                                         return;
 578                                 }
 579                                 *is_bridge = 1;
 580                                 pci_id->bus = tu8;
 581                                 status =
 582                                     acpi_os_read_pci_configuration(pci_id, 0x19,
 583                                                                    &tu8, 8);
 584                                 if (ACPI_SUCCESS(status)) {
 585                                         *bus_number = tu8;
 586                                 }
 587                         } else
 588                                 *is_bridge = 0;
 589                 }
 590         }
 591 }
 592
 593 void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound  */
 594                            acpi_handle chandle, /* current node */
 595                            struct acpi_pci_id **id)
 596 {
 597         int is_bridge = 1;
 598         u8 bus_number = (*id)->bus;
 599
 600         acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
 601 }
 602
 603 static void acpi_os_execute_deferred(struct work_struct *work)
 604 {
 605         struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
 606
 607         if (!dpc) {
 608                 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
 609                 return;
 610         }
 611
 612         dpc->function(dpc->context);
 613
 614         kfree(dpc);
 615
 616         return;
 617 }
 618
 619 /*******************************************************************************
 620  *
 621  * FUNCTION:    acpi_os_execute
 622  *
 623  * PARAMETERS:  Type               - Type of the callback
 624  *              Function           - Function to be executed
 625  *              Context            - Function parameters
 626  *
 627  * RETURN:      Status
 628  *
 629  * DESCRIPTION: Depending on type, either queues function for deferred execution or
 630  *              immediately executes function on a separate thread.
 631  *
 632  ******************************************************************************/
 633
 634 acpi_status acpi_os_execute(acpi_execute_type type,
 635                             acpi_osd_exec_callback function, void *context)
 636 {
 637         acpi_status status = AE_OK;
 638         struct acpi_os_dpc *dpc;
 639
 640         ACPI_FUNCTION_TRACE("os_queue_for_execution");
 641
 642         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 643                           "Scheduling function [%p(%p)] for deferred execution.\n",
 644                           function, context));
 645
 646         if (!function)
 647                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 648
 649         /*
 650          * Allocate/initialize DPC structure.  Note that this memory will be
 651          * freed by the callee.  The kernel handles the work_struct list  in a
 652          * way that allows us to also free its memory inside the callee.
 653          * Because we may want to schedule several tasks with different
 654          * parameters we can't use the approach some kernel code uses of
 655          * having a static work_struct.
 656          */
 657
 658         dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
 659         if (!dpc)
 660                 return_ACPI_STATUS(AE_NO_MEMORY);
 661
 662         dpc->function = function;
 663         dpc->context = context;
 664
 665         INIT_WORK(&dpc->work, acpi_os_execute_deferred);
 666         if (!queue_work(kacpid_wq, &dpc->work)) {
 667                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 668                                   "Call to queue_work() failed.\n"));
 669                 kfree(dpc);
 670                 status = AE_ERROR;
 671         }
 672
 673         return_ACPI_STATUS(status);
 674 }
 675
 676 EXPORT_SYMBOL(acpi_os_execute);
 677
 678 void acpi_os_wait_events_complete(void *context)
 679 {
 680         flush_workqueue(kacpid_wq);
 681 }
 682
 683 EXPORT_SYMBOL(acpi_os_wait_events_complete);
 684
 685 /*
 686  * Allocate the memory for a spinlock and initialize it.
 687  */
 688 acpi_status acpi_os_create_lock(acpi_spinlock * handle)
 689 {
 690         spin_lock_init(*handle);
 691
 692         return AE_OK;
 693 }
 694
 695 /*
 696  * Deallocate the memory for a spinlock.
 697  */
 698 void acpi_os_delete_lock(acpi_spinlock handle)
 699 {
 700         return;
 701 }
 702
 703 acpi_status
 704 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 705 {
 706         struct semaphore *sem = NULL;
 707
 708
 709         sem = acpi_os_allocate(sizeof(struct semaphore));
 710         if (!sem)
 711                 return AE_NO_MEMORY;
 712         memset(sem, 0, sizeof(struct semaphore));
 713
 714         sema_init(sem, initial_units);
 715
 716         *handle = (acpi_handle *) sem;
 717
 718         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
 719                           *handle, initial_units));
 720
 721         return AE_OK;
 722 }
 723
 724 EXPORT_SYMBOL(acpi_os_create_semaphore);
 725
 726 /*
 727  * TODO: A better way to delete semaphores?  Linux doesn't have a
 728  * 'delete_semaphore()' function -- may result in an invalid
 729  * pointer dereference for non-synchronized consumers.  Should
 730  * we at least check for blocked threads and signal/cancel them?
 731  */
 732
 733 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
 734 {
 735         struct semaphore *sem = (struct semaphore *)handle;
 736
 737
 738         if (!sem)
 739                 return AE_BAD_PARAMETER;
 740
 741         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
 742
 743         kfree(sem);
 744         sem = NULL;
 745
 746         return AE_OK;
 747 }
 748
 749 EXPORT_SYMBOL(acpi_os_delete_semaphore);
 750
 751 /*
 752  * TODO: The kernel doesn't have a 'down_timeout' function -- had to
 753  * improvise.  The process is to sleep for one scheduler quantum
 754  * until the semaphore becomes available.  Downside is that this
 755  * may result in starvation for timeout-based waits when there's
 756  * lots of semaphore activity.
 757  *
 758  * TODO: Support for units > 1?
 759  */
 760 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
 761 {
 762         acpi_status status = AE_OK;
 763         struct semaphore *sem = (struct semaphore *)handle;
 764         int ret = 0;
 765
 766
 767         if (!sem || (units < 1))
 768                 return AE_BAD_PARAMETER;
 769
 770         if (units > 1)
 771                 return AE_SUPPORT;
 772
 773         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
 774                           handle, units, timeout));
 775
 776         /*
 777          * This can be called during resume with interrupts off.
 778          * Like boot-time, we should be single threaded and will
 779          * always get the lock if we try -- timeout or not.
 780          * If this doesn't succeed, then we will oops courtesy of
 781          * might_sleep() in down().
 782          */
 783         if (!down_trylock(sem))
 784                 return AE_OK;
 785
 786         switch (timeout) {
 787                 /*
 788                  * No Wait:
 789                  * --------
 790                  * A zero timeout value indicates that we shouldn't wait - just
 791                  * acquire the semaphore if available otherwise return AE_TIME
 792                  * (a.k.a. 'would block').
 793                  */
 794         case 0:
 795                 if (down_trylock(sem))
 796                         status = AE_TIME;
 797                 break;
 798
 799                 /*
 800                  * Wait Indefinitely:
 801                  * ------------------
 802                  */
 803         case ACPI_WAIT_FOREVER:
 804                 down(sem);
 805                 break;
 806
 807                 /*
 808                  * Wait w/ Timeout:
 809                  * ----------------
 810                  */
 811         default:
 812                 // TODO: A better timeout algorithm?
 813                 {
 814                         int i = 0;
 815                         static const int quantum_ms = 1000 / HZ;
 816
 817                         ret = down_trylock(sem);
 818                         for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) {
 819                                 schedule_timeout_interruptible(1);
 820                                 ret = down_trylock(sem);
 821                         }
 822
 823                         if (ret != 0)
 824                                 status = AE_TIME;
 825                 }
 826                 break;
 827         }
 828
 829         if (ACPI_FAILURE(status)) {
 830                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
 831                                   "Failed to acquire semaphore[%p|%d|%d], %s",
 832                                   handle, units, timeout,
 833                                   acpi_format_exception(status)));
 834         } else {
 835                 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
 836                                   "Acquired semaphore[%p|%d|%d]", handle,
 837                                   units, timeout));
 838         }
 839
 840         return status;
 841 }
 842
 843 EXPORT_SYMBOL(acpi_os_wait_semaphore);
 844
 845 /*
 846  * TODO: Support for units > 1?
 847  */
 848 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 849 {
 850         struct semaphore *sem = (struct semaphore *)handle;
 851
 852
 853         if (!sem || (units < 1))
 854                 return AE_BAD_PARAMETER;
 855
 856         if (units > 1)
 857                 return AE_SUPPORT;
 858
 859         ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
 860                           units));
 861
 862         up(sem);
 863
 864         return AE_OK;
 865 }
 866
 867 EXPORT_SYMBOL(acpi_os_signal_semaphore);
 868
 869 #ifdef ACPI_FUTURE_USAGE
 870 u32 acpi_os_get_line(char *buffer)
 871 {
 872
 873 #ifdef ENABLE_DEBUGGER
 874         if (acpi_in_debugger) {
 875                 u32 chars;
 876
 877                 kdb_read(buffer, sizeof(line_buf));
 878
 879                 /* remove the CR kdb includes */
 880                 chars = strlen(buffer) - 1;
 881                 buffer[chars] = '\0';
 882         }
 883 #endif
 884
 885         return 0;
 886 }
 887 #endif                          /*  ACPI_FUTURE_USAGE  */
 888
 889 acpi_status acpi_os_signal(u32 function, void *info)
 890 {
 891         switch (function) {
 892         case ACPI_SIGNAL_FATAL:
 893                 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
 894                 break;
 895         case ACPI_SIGNAL_BREAKPOINT:
 896                 /*
 897                  * AML Breakpoint
 898                  * ACPI spec. says to treat it as a NOP unless
 899                  * you are debugging.  So if/when we integrate
 900                  * AML debugger into the kernel debugger its
 901                  * hook will go here.  But until then it is
 902                  * not useful to print anything on breakpoints.
 903                  */
 904                 break;
 905         default:
 906                 break;
 907         }
 908
 909         return AE_OK;
 910 }
 911
 912 EXPORT_SYMBOL(acpi_os_signal);
 913
 914 static int __init acpi_os_name_setup(char *str)
 915 {
 916         char *p = acpi_os_name;
 917         int count = ACPI_MAX_OVERRIDE_LEN - 1;
 918
 919         if (!str || !*str)
 920                 return 0;
 921
 922         for (; count-- && str && *str; str++) {
 923                 if (isalnum(*str) || *str == ' ' || *str == ':')
 924                         *p++ = *str;
 925                 else if (*str == '\'' || *str == '"')
 926                         continue;
 927                 else
 928                         break;
 929         }
 930         *p = 0;
 931
 932         return 1;
 933
 934 }
 935
 936 __setup("acpi_os_name=", acpi_os_name_setup);
 937
 938 /*
 939  * _OSI control
 940  * empty string disables _OSI
 941  * TBD additional string adds to _OSI
 942  */
 943 static int __init acpi_osi_setup(char *str)
 944 {
 945         if (str == NULL || *str == '\0') {
 946                 printk(KERN_INFO PREFIX "_OSI method disabled\n");
 947                 acpi_gbl_create_osi_method = FALSE;
 948         } else {
 949                 /* TBD */
 950                 printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n",
 951                        str);
 952         }
 953
 954         return 1;
 955 }
 956
 957 __setup("acpi_osi=", acpi_osi_setup);
 958
 959 /* enable serialization to combat AE_ALREADY_EXISTS errors */
 960 static int __init acpi_serialize_setup(char *str)
 961 {
 962         printk(KERN_INFO PREFIX "serialize enabled\n");
 963
 964         acpi_gbl_all_methods_serialized = TRUE;
 965
 966         return 1;
 967 }
 968
 969 __setup("acpi_serialize", acpi_serialize_setup);
 970
 971 /*
 972  * Wake and Run-Time GPES are expected to be separate.
 973  * We disable wake-GPEs at run-time to prevent spurious
 974  * interrupts.
 975  *
 976  * However, if a system exists that shares Wake and
 977  * Run-time events on the same GPE this flag is available
 978  * to tell Linux to keep the wake-time GPEs enabled at run-time.
 979  */
 980 static int __init acpi_wake_gpes_always_on_setup(char *str)
 981 {
 982         printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
 983
 984         acpi_gbl_leave_wake_gpes_disabled = FALSE;
 985
 986         return 1;
 987 }
 988
 989 __setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
 990
 991 /*
 992  * max_cstate is defined in the base kernel so modules can
 993  * change it w/o depending on the state of the processor module.
 994  */
 995 unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
 996
 997 EXPORT_SYMBOL(max_cstate);
 998
 999 /*
1000  * Acquire a spinlock.
1001  *
1002  * handle is a pointer to the spinlock_t.
1003  */
1004
1005 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1006 {
1007         acpi_cpu_flags flags;
1008         spin_lock_irqsave(lockp, flags);
1009         return flags;
1010 }
1011
1012 /*
1013  * Release a spinlock. See above.
1014  */
1015
1016 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1017 {
1018         spin_unlock_irqrestore(lockp, flags);
1019 }
1020
1021 #ifndef ACPI_USE_LOCAL_CACHE
1022
1023 /*******************************************************************************
1024  *
1025  * FUNCTION:    acpi_os_create_cache
1026  *
1027  * PARAMETERS:  name      - Ascii name for the cache
1028  *              size      - Size of each cached object
1029  *              depth     - Maximum depth of the cache (in objects) <ignored>
1030  *              cache     - Where the new cache object is returned
1031  *
1032  * RETURN:      status
1033  *
1034  * DESCRIPTION: Create a cache object
1035  *
1036  ******************************************************************************/
1037
1038 acpi_status
1039 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1040 {
1041         *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
1042         if (*cache == NULL)
1043                 return AE_ERROR;
1044         else
1045                 return AE_OK;
1046 }
1047
1048 /*******************************************************************************
1049  *
1050  * FUNCTION:    acpi_os_purge_cache
1051  *
1052  * PARAMETERS:  Cache           - Handle to cache object
1053  *
1054  * RETURN:      Status
1055  *
1056  * DESCRIPTION: Free all objects within the requested cache.
1057  *
1058  ******************************************************************************/
1059
1060 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1061 {
1062         kmem_cache_shrink(cache);
1063         return (AE_OK);
1064 }
1065
1066 /*******************************************************************************
1067  *
1068  * FUNCTION:    acpi_os_delete_cache
1069  *
1070  * PARAMETERS:  Cache           - Handle to cache object
1071  *
1072  * RETURN:      Status
1073  *
1074  * DESCRIPTION: Free all objects within the requested cache and delete the
1075  *              cache object.
1076  *
1077  ******************************************************************************/
1078
1079 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1080 {
1081         kmem_cache_destroy(cache);
1082         return (AE_OK);
1083 }
1084
1085 /*******************************************************************************
1086  *
1087  * FUNCTION:    acpi_os_release_object
1088  *
1089  * PARAMETERS:  Cache       - Handle to cache object
1090  *              Object      - The object to be released
1091  *
1092  * RETURN:      None
1093  *
1094  * DESCRIPTION: Release an object to the specified cache.  If cache is full,
1095  *              the object is deleted.
1096  *
1097  ******************************************************************************/
1098
1099 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1100 {
1101         kmem_cache_free(cache, object);
1102         return (AE_OK);
1103 }
1104
1105 /******************************************************************************
1106  *
1107  * FUNCTION:    acpi_os_validate_interface
1108  *
1109  * PARAMETERS:  interface           - Requested interface to be validated
1110  *
1111  * RETURN:      AE_OK if interface is supported, AE_SUPPORT otherwise
1112  *
1113  * DESCRIPTION: Match an interface string to the interfaces supported by the
1114  *              host. Strings originate from an AML call to the _OSI method.
1115  *
1116  *****************************************************************************/
1117
1118 acpi_status
1119 acpi_os_validate_interface (char *interface)
1120 {
1121
1122     return AE_SUPPORT;
1123 }
1124
1125
1126 /******************************************************************************
1127  *
1128  * FUNCTION:    acpi_os_validate_address
1129  *
1130  * PARAMETERS:  space_id             - ACPI space ID
1131  *              address             - Physical address
1132  *              length              - Address length
1133  *
1134  * RETURN:      AE_OK if address/length is valid for the space_id. Otherwise,
1135  *              should return AE_AML_ILLEGAL_ADDRESS.
1136  *
1137  * DESCRIPTION: Validate a system address via the host OS. Used to validate
1138  *              the addresses accessed by AML operation regions.
1139  *
1140  *****************************************************************************/
1141
1142 acpi_status
1143 acpi_os_validate_address (
1144     u8                   space_id,
1145     acpi_physical_address   address,
1146     acpi_size               length)
1147 {
1148
1149     return AE_OK;
1150 }
1151
1152
1153 #endif