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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
23 *
24 */
25
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/mm.h>
30 #include <linux/highmem.h>
31 #include <linux/pci.h>
32 #include <linux/interrupt.h>
33 #include <linux/kmod.h>
34 #include <linux/delay.h>
35 #include <linux/workqueue.h>
36 #include <linux/nmi.h>
37 #include <linux/acpi.h>
38 #include <linux/efi.h>
39 #include <linux/ioport.h>
40 #include <linux/list.h>
41 #include <linux/jiffies.h>
42 #include <linux/semaphore.h>
43
44 #include <asm/io.h>
45 #include <linux/uaccess.h>
46 #include <linux/io-64-nonatomic-lo-hi.h>
47
48 #include "acpica/accommon.h"
49 #include "acpica/acnamesp.h"
50 #include "internal.h"
51
52 #define _COMPONENT ACPI_OS_SERVICES
53 ACPI_MODULE_NAME("osl");
54
55 struct acpi_os_dpc {
56 acpi_osd_exec_callback function;
57 void *context;
58 struct work_struct work;
59 };
60
61 #ifdef ENABLE_DEBUGGER
62 #include <linux/kdb.h>
63
64 /* stuff for debugger support */
65 int acpi_in_debugger;
66 EXPORT_SYMBOL(acpi_in_debugger);
67 #endif /*ENABLE_DEBUGGER */
68
69 static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
70 u32 pm1b_ctrl);
71 static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
72 u32 val_b);
73
74 static acpi_osd_handler acpi_irq_handler;
75 static void *acpi_irq_context;
76 static struct workqueue_struct *kacpid_wq;
77 static struct workqueue_struct *kacpi_notify_wq;
78 static struct workqueue_struct *kacpi_hotplug_wq;
79 static bool acpi_os_initialized;
80 unsigned int acpi_sci_irq = INVALID_ACPI_IRQ;
81 bool acpi_permanent_mmap = false;
82
83 /*
84 * This list of permanent mappings is for memory that may be accessed from
85 * interrupt context, where we can't do the ioremap().
86 */
87 struct acpi_ioremap {
88 struct list_head list;
89 void __iomem *virt;
90 acpi_physical_address phys;
91 acpi_size size;
92 unsigned long refcount;
93 };
94
95 static LIST_HEAD(acpi_ioremaps);
96 static DEFINE_MUTEX(acpi_ioremap_lock);
97
acpi_request_region(struct acpi_generic_address * gas,unsigned int length,char * desc)98 static void __init acpi_request_region (struct acpi_generic_address *gas,
99 unsigned int length, char *desc)
100 {
101 u64 addr;
102
103 /* Handle possible alignment issues */
104 memcpy(&addr, &gas->address, sizeof(addr));
105 if (!addr || !length)
106 return;
107
108 /* Resources are never freed */
109 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
110 request_region(addr, length, desc);
111 else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
112 request_mem_region(addr, length, desc);
113 }
114
acpi_reserve_resources(void)115 static int __init acpi_reserve_resources(void)
116 {
117 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
118 "ACPI PM1a_EVT_BLK");
119
120 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
121 "ACPI PM1b_EVT_BLK");
122
123 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
124 "ACPI PM1a_CNT_BLK");
125
126 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
127 "ACPI PM1b_CNT_BLK");
128
129 if (acpi_gbl_FADT.pm_timer_length == 4)
130 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
131
132 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
133 "ACPI PM2_CNT_BLK");
134
135 /* Length of GPE blocks must be a non-negative multiple of 2 */
136
137 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
138 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
139 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
140
141 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
142 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
143 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
144
145 return 0;
146 }
147 fs_initcall_sync(acpi_reserve_resources);
148
acpi_os_printf(const char * fmt,...)149 void acpi_os_printf(const char *fmt, ...)
150 {
151 va_list args;
152 va_start(args, fmt);
153 acpi_os_vprintf(fmt, args);
154 va_end(args);
155 }
156 EXPORT_SYMBOL(acpi_os_printf);
157
acpi_os_vprintf(const char * fmt,va_list args)158 void acpi_os_vprintf(const char *fmt, va_list args)
159 {
160 static char buffer[512];
161
162 vsprintf(buffer, fmt, args);
163
164 #ifdef ENABLE_DEBUGGER
165 if (acpi_in_debugger) {
166 kdb_printf("%s", buffer);
167 } else {
168 if (printk_get_level(buffer))
169 printk("%s", buffer);
170 else
171 printk(KERN_CONT "%s", buffer);
172 }
173 #else
174 if (acpi_debugger_write_log(buffer) < 0) {
175 if (printk_get_level(buffer))
176 printk("%s", buffer);
177 else
178 printk(KERN_CONT "%s", buffer);
179 }
180 #endif
181 }
182
183 #ifdef CONFIG_KEXEC
184 static unsigned long acpi_rsdp;
setup_acpi_rsdp(char * arg)185 static int __init setup_acpi_rsdp(char *arg)
186 {
187 return kstrtoul(arg, 16, &acpi_rsdp);
188 }
189 early_param("acpi_rsdp", setup_acpi_rsdp);
190 #endif
191
acpi_os_get_root_pointer(void)192 acpi_physical_address __init acpi_os_get_root_pointer(void)
193 {
194 acpi_physical_address pa;
195
196 #ifdef CONFIG_KEXEC
197 if (acpi_rsdp)
198 return acpi_rsdp;
199 #endif
200 pa = acpi_arch_get_root_pointer();
201 if (pa)
202 return pa;
203
204 if (efi_enabled(EFI_CONFIG_TABLES)) {
205 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
206 return efi.acpi20;
207 if (efi.acpi != EFI_INVALID_TABLE_ADDR)
208 return efi.acpi;
209 pr_err(PREFIX "System description tables not found\n");
210 } else if (IS_ENABLED(CONFIG_ACPI_LEGACY_TABLES_LOOKUP)) {
211 acpi_find_root_pointer(&pa);
212 }
213
214 return pa;
215 }
216
217 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
218 static struct acpi_ioremap *
acpi_map_lookup(acpi_physical_address phys,acpi_size size)219 acpi_map_lookup(acpi_physical_address phys, acpi_size size)
220 {
221 struct acpi_ioremap *map;
222
223 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
224 if (map->phys <= phys &&
225 phys + size <= map->phys + map->size)
226 return map;
227
228 return NULL;
229 }
230
231 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
232 static void __iomem *
acpi_map_vaddr_lookup(acpi_physical_address phys,unsigned int size)233 acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
234 {
235 struct acpi_ioremap *map;
236
237 map = acpi_map_lookup(phys, size);
238 if (map)
239 return map->virt + (phys - map->phys);
240
241 return NULL;
242 }
243
acpi_os_get_iomem(acpi_physical_address phys,unsigned int size)244 void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
245 {
246 struct acpi_ioremap *map;
247 void __iomem *virt = NULL;
248
249 mutex_lock(&acpi_ioremap_lock);
250 map = acpi_map_lookup(phys, size);
251 if (map) {
252 virt = map->virt + (phys - map->phys);
253 map->refcount++;
254 }
255 mutex_unlock(&acpi_ioremap_lock);
256 return virt;
257 }
258 EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
259
260 /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
261 static struct acpi_ioremap *
acpi_map_lookup_virt(void __iomem * virt,acpi_size size)262 acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
263 {
264 struct acpi_ioremap *map;
265
266 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
267 if (map->virt <= virt &&
268 virt + size <= map->virt + map->size)
269 return map;
270
271 return NULL;
272 }
273
274 #if defined(CONFIG_IA64) || defined(CONFIG_ARM64)
275 /* ioremap will take care of cache attributes */
276 #define should_use_kmap(pfn) 0
277 #else
278 #define should_use_kmap(pfn) page_is_ram(pfn)
279 #endif
280
acpi_map(acpi_physical_address pg_off,unsigned long pg_sz)281 static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
282 {
283 unsigned long pfn;
284
285 pfn = pg_off >> PAGE_SHIFT;
286 if (should_use_kmap(pfn)) {
287 if (pg_sz > PAGE_SIZE)
288 return NULL;
289 return (void __iomem __force *)kmap(pfn_to_page(pfn));
290 } else
291 return acpi_os_ioremap(pg_off, pg_sz);
292 }
293
acpi_unmap(acpi_physical_address pg_off,void __iomem * vaddr)294 static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
295 {
296 unsigned long pfn;
297
298 pfn = pg_off >> PAGE_SHIFT;
299 if (should_use_kmap(pfn))
300 kunmap(pfn_to_page(pfn));
301 else
302 iounmap(vaddr);
303 }
304
305 /**
306 * acpi_os_map_iomem - Get a virtual address for a given physical address range.
307 * @phys: Start of the physical address range to map.
308 * @size: Size of the physical address range to map.
309 *
310 * Look up the given physical address range in the list of existing ACPI memory
311 * mappings. If found, get a reference to it and return a pointer to it (its
312 * virtual address). If not found, map it, add it to that list and return a
313 * pointer to it.
314 *
315 * During early init (when acpi_permanent_mmap has not been set yet) this
316 * routine simply calls __acpi_map_table() to get the job done.
317 */
318 void __iomem *__ref
acpi_os_map_iomem(acpi_physical_address phys,acpi_size size)319 acpi_os_map_iomem(acpi_physical_address phys, acpi_size size)
320 {
321 struct acpi_ioremap *map;
322 void __iomem *virt;
323 acpi_physical_address pg_off;
324 acpi_size pg_sz;
325
326 if (phys > ULONG_MAX) {
327 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
328 return NULL;
329 }
330
331 if (!acpi_permanent_mmap)
332 return __acpi_map_table((unsigned long)phys, size);
333
334 mutex_lock(&acpi_ioremap_lock);
335 /* Check if there's a suitable mapping already. */
336 map = acpi_map_lookup(phys, size);
337 if (map) {
338 map->refcount++;
339 goto out;
340 }
341
342 map = kzalloc(sizeof(*map), GFP_KERNEL);
343 if (!map) {
344 mutex_unlock(&acpi_ioremap_lock);
345 return NULL;
346 }
347
348 pg_off = round_down(phys, PAGE_SIZE);
349 pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
350 virt = acpi_map(pg_off, pg_sz);
351 if (!virt) {
352 mutex_unlock(&acpi_ioremap_lock);
353 kfree(map);
354 return NULL;
355 }
356
357 INIT_LIST_HEAD(&map->list);
358 map->virt = virt;
359 map->phys = pg_off;
360 map->size = pg_sz;
361 map->refcount = 1;
362
363 list_add_tail_rcu(&map->list, &acpi_ioremaps);
364
365 out:
366 mutex_unlock(&acpi_ioremap_lock);
367 return map->virt + (phys - map->phys);
368 }
369 EXPORT_SYMBOL_GPL(acpi_os_map_iomem);
370
acpi_os_map_memory(acpi_physical_address phys,acpi_size size)371 void *__ref acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
372 {
373 return (void *)acpi_os_map_iomem(phys, size);
374 }
375 EXPORT_SYMBOL_GPL(acpi_os_map_memory);
376
377 /* Must be called with mutex_lock(&acpi_ioremap_lock) */
acpi_os_drop_map_ref(struct acpi_ioremap * map)378 static unsigned long acpi_os_drop_map_ref(struct acpi_ioremap *map)
379 {
380 unsigned long refcount = --map->refcount;
381
382 if (!refcount)
383 list_del_rcu(&map->list);
384 return refcount;
385 }
386
acpi_os_map_cleanup(struct acpi_ioremap * map)387 static void acpi_os_map_cleanup(struct acpi_ioremap *map)
388 {
389 synchronize_rcu_expedited();
390 acpi_unmap(map->phys, map->virt);
391 kfree(map);
392 }
393
394 /**
395 * acpi_os_unmap_iomem - Drop a memory mapping reference.
396 * @virt: Start of the address range to drop a reference to.
397 * @size: Size of the address range to drop a reference to.
398 *
399 * Look up the given virtual address range in the list of existing ACPI memory
400 * mappings, drop a reference to it and unmap it if there are no more active
401 * references to it.
402 *
403 * During early init (when acpi_permanent_mmap has not been set yet) this
404 * routine simply calls __acpi_unmap_table() to get the job done. Since
405 * __acpi_unmap_table() is an __init function, the __ref annotation is needed
406 * here.
407 */
acpi_os_unmap_iomem(void __iomem * virt,acpi_size size)408 void __ref acpi_os_unmap_iomem(void __iomem *virt, acpi_size size)
409 {
410 struct acpi_ioremap *map;
411 unsigned long refcount;
412
413 if (!acpi_permanent_mmap) {
414 __acpi_unmap_table(virt, size);
415 return;
416 }
417
418 mutex_lock(&acpi_ioremap_lock);
419 map = acpi_map_lookup_virt(virt, size);
420 if (!map) {
421 mutex_unlock(&acpi_ioremap_lock);
422 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
423 return;
424 }
425 refcount = acpi_os_drop_map_ref(map);
426 mutex_unlock(&acpi_ioremap_lock);
427
428 if (!refcount)
429 acpi_os_map_cleanup(map);
430 }
431 EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem);
432
acpi_os_unmap_memory(void * virt,acpi_size size)433 void __ref acpi_os_unmap_memory(void *virt, acpi_size size)
434 {
435 return acpi_os_unmap_iomem((void __iomem *)virt, size);
436 }
437 EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
438
acpi_os_map_generic_address(struct acpi_generic_address * gas)439 int acpi_os_map_generic_address(struct acpi_generic_address *gas)
440 {
441 u64 addr;
442 void __iomem *virt;
443
444 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
445 return 0;
446
447 /* Handle possible alignment issues */
448 memcpy(&addr, &gas->address, sizeof(addr));
449 if (!addr || !gas->bit_width)
450 return -EINVAL;
451
452 virt = acpi_os_map_iomem(addr, gas->bit_width / 8);
453 if (!virt)
454 return -EIO;
455
456 return 0;
457 }
458 EXPORT_SYMBOL(acpi_os_map_generic_address);
459
acpi_os_unmap_generic_address(struct acpi_generic_address * gas)460 void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
461 {
462 u64 addr;
463 struct acpi_ioremap *map;
464 unsigned long refcount;
465
466 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
467 return;
468
469 /* Handle possible alignment issues */
470 memcpy(&addr, &gas->address, sizeof(addr));
471 if (!addr || !gas->bit_width)
472 return;
473
474 mutex_lock(&acpi_ioremap_lock);
475 map = acpi_map_lookup(addr, gas->bit_width / 8);
476 if (!map) {
477 mutex_unlock(&acpi_ioremap_lock);
478 return;
479 }
480 refcount = acpi_os_drop_map_ref(map);
481 mutex_unlock(&acpi_ioremap_lock);
482
483 if (!refcount)
484 acpi_os_map_cleanup(map);
485 }
486 EXPORT_SYMBOL(acpi_os_unmap_generic_address);
487
488 #ifdef ACPI_FUTURE_USAGE
489 acpi_status
acpi_os_get_physical_address(void * virt,acpi_physical_address * phys)490 acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
491 {
492 if (!phys || !virt)
493 return AE_BAD_PARAMETER;
494
495 *phys = virt_to_phys(virt);
496
497 return AE_OK;
498 }
499 #endif
500
501 #ifdef CONFIG_ACPI_REV_OVERRIDE_POSSIBLE
502 static bool acpi_rev_override;
503
acpi_rev_override_setup(char * str)504 int __init acpi_rev_override_setup(char *str)
505 {
506 acpi_rev_override = true;
507 return 1;
508 }
509 __setup("acpi_rev_override", acpi_rev_override_setup);
510 #else
511 #define acpi_rev_override false
512 #endif
513
514 #define ACPI_MAX_OVERRIDE_LEN 100
515
516 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
517
518 acpi_status
acpi_os_predefined_override(const struct acpi_predefined_names * init_val,acpi_string * new_val)519 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
520 acpi_string *new_val)
521 {
522 if (!init_val || !new_val)
523 return AE_BAD_PARAMETER;
524
525 *new_val = NULL;
526 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
527 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
528 acpi_os_name);
529 *new_val = acpi_os_name;
530 }
531
532 if (!memcmp(init_val->name, "_REV", 4) && acpi_rev_override) {
533 printk(KERN_INFO PREFIX "Overriding _REV return value to 5\n");
534 *new_val = (char *)5;
535 }
536
537 return AE_OK;
538 }
539
acpi_irq(int irq,void * dev_id)540 static irqreturn_t acpi_irq(int irq, void *dev_id)
541 {
542 u32 handled;
543
544 handled = (*acpi_irq_handler) (acpi_irq_context);
545
546 if (handled) {
547 acpi_irq_handled++;
548 return IRQ_HANDLED;
549 } else {
550 acpi_irq_not_handled++;
551 return IRQ_NONE;
552 }
553 }
554
555 acpi_status
acpi_os_install_interrupt_handler(u32 gsi,acpi_osd_handler handler,void * context)556 acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
557 void *context)
558 {
559 unsigned int irq;
560
561 acpi_irq_stats_init();
562
563 /*
564 * ACPI interrupts different from the SCI in our copy of the FADT are
565 * not supported.
566 */
567 if (gsi != acpi_gbl_FADT.sci_interrupt)
568 return AE_BAD_PARAMETER;
569
570 if (acpi_irq_handler)
571 return AE_ALREADY_ACQUIRED;
572
573 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
574 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
575 gsi);
576 return AE_OK;
577 }
578
579 acpi_irq_handler = handler;
580 acpi_irq_context = context;
581 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
582 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
583 acpi_irq_handler = NULL;
584 return AE_NOT_ACQUIRED;
585 }
586 acpi_sci_irq = irq;
587
588 return AE_OK;
589 }
590
acpi_os_remove_interrupt_handler(u32 gsi,acpi_osd_handler handler)591 acpi_status acpi_os_remove_interrupt_handler(u32 gsi, acpi_osd_handler handler)
592 {
593 if (gsi != acpi_gbl_FADT.sci_interrupt || !acpi_sci_irq_valid())
594 return AE_BAD_PARAMETER;
595
596 free_irq(acpi_sci_irq, acpi_irq);
597 acpi_irq_handler = NULL;
598 acpi_sci_irq = INVALID_ACPI_IRQ;
599
600 return AE_OK;
601 }
602
603 /*
604 * Running in interpreter thread context, safe to sleep
605 */
606
acpi_os_sleep(u64 ms)607 void acpi_os_sleep(u64 ms)
608 {
609 msleep(ms);
610 }
611
acpi_os_stall(u32 us)612 void acpi_os_stall(u32 us)
613 {
614 while (us) {
615 u32 delay = 1000;
616
617 if (delay > us)
618 delay = us;
619 udelay(delay);
620 touch_nmi_watchdog();
621 us -= delay;
622 }
623 }
624
625 /*
626 * Support ACPI 3.0 AML Timer operand. Returns a 64-bit free-running,
627 * monotonically increasing timer with 100ns granularity. Do not use
628 * ktime_get() to implement this function because this function may get
629 * called after timekeeping has been suspended. Note: calling this function
630 * after timekeeping has been suspended may lead to unexpected results
631 * because when timekeeping is suspended the jiffies counter is not
632 * incremented. See also timekeeping_suspend().
633 */
acpi_os_get_timer(void)634 u64 acpi_os_get_timer(void)
635 {
636 return (get_jiffies_64() - INITIAL_JIFFIES) *
637 (ACPI_100NSEC_PER_SEC / HZ);
638 }
639
acpi_os_read_port(acpi_io_address port,u32 * value,u32 width)640 acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
641 {
642 u32 dummy;
643
644 if (!value)
645 value = &dummy;
646
647 *value = 0;
648 if (width <= 8) {
649 *(u8 *) value = inb(port);
650 } else if (width <= 16) {
651 *(u16 *) value = inw(port);
652 } else if (width <= 32) {
653 *(u32 *) value = inl(port);
654 } else {
655 BUG();
656 }
657
658 return AE_OK;
659 }
660
661 EXPORT_SYMBOL(acpi_os_read_port);
662
acpi_os_write_port(acpi_io_address port,u32 value,u32 width)663 acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
664 {
665 if (width <= 8) {
666 outb(value, port);
667 } else if (width <= 16) {
668 outw(value, port);
669 } else if (width <= 32) {
670 outl(value, port);
671 } else {
672 BUG();
673 }
674
675 return AE_OK;
676 }
677
678 EXPORT_SYMBOL(acpi_os_write_port);
679
acpi_os_read_iomem(void __iomem * virt_addr,u64 * value,u32 width)680 int acpi_os_read_iomem(void __iomem *virt_addr, u64 *value, u32 width)
681 {
682
683 switch (width) {
684 case 8:
685 *(u8 *) value = readb(virt_addr);
686 break;
687 case 16:
688 *(u16 *) value = readw(virt_addr);
689 break;
690 case 32:
691 *(u32 *) value = readl(virt_addr);
692 break;
693 case 64:
694 *(u64 *) value = readq(virt_addr);
695 break;
696 default:
697 return -EINVAL;
698 }
699
700 return 0;
701 }
702
703 acpi_status
acpi_os_read_memory(acpi_physical_address phys_addr,u64 * value,u32 width)704 acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
705 {
706 void __iomem *virt_addr;
707 unsigned int size = width / 8;
708 bool unmap = false;
709 u64 dummy;
710 int error;
711
712 rcu_read_lock();
713 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
714 if (!virt_addr) {
715 rcu_read_unlock();
716 virt_addr = acpi_os_ioremap(phys_addr, size);
717 if (!virt_addr)
718 return AE_BAD_ADDRESS;
719 unmap = true;
720 }
721
722 if (!value)
723 value = &dummy;
724
725 error = acpi_os_read_iomem(virt_addr, value, width);
726 BUG_ON(error);
727
728 if (unmap)
729 iounmap(virt_addr);
730 else
731 rcu_read_unlock();
732
733 return AE_OK;
734 }
735
736 acpi_status
acpi_os_write_memory(acpi_physical_address phys_addr,u64 value,u32 width)737 acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
738 {
739 void __iomem *virt_addr;
740 unsigned int size = width / 8;
741 bool unmap = false;
742
743 rcu_read_lock();
744 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
745 if (!virt_addr) {
746 rcu_read_unlock();
747 virt_addr = acpi_os_ioremap(phys_addr, size);
748 if (!virt_addr)
749 return AE_BAD_ADDRESS;
750 unmap = true;
751 }
752
753 switch (width) {
754 case 8:
755 writeb(value, virt_addr);
756 break;
757 case 16:
758 writew(value, virt_addr);
759 break;
760 case 32:
761 writel(value, virt_addr);
762 break;
763 case 64:
764 writeq(value, virt_addr);
765 break;
766 default:
767 BUG();
768 }
769
770 if (unmap)
771 iounmap(virt_addr);
772 else
773 rcu_read_unlock();
774
775 return AE_OK;
776 }
777
778 acpi_status
acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id,u32 reg,u64 * value,u32 width)779 acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
780 u64 *value, u32 width)
781 {
782 int result, size;
783 u32 value32;
784
785 if (!value)
786 return AE_BAD_PARAMETER;
787
788 switch (width) {
789 case 8:
790 size = 1;
791 break;
792 case 16:
793 size = 2;
794 break;
795 case 32:
796 size = 4;
797 break;
798 default:
799 return AE_ERROR;
800 }
801
802 result = raw_pci_read(pci_id->segment, pci_id->bus,
803 PCI_DEVFN(pci_id->device, pci_id->function),
804 reg, size, &value32);
805 *value = value32;
806
807 return (result ? AE_ERROR : AE_OK);
808 }
809
810 acpi_status
acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id,u32 reg,u64 value,u32 width)811 acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
812 u64 value, u32 width)
813 {
814 int result, size;
815
816 switch (width) {
817 case 8:
818 size = 1;
819 break;
820 case 16:
821 size = 2;
822 break;
823 case 32:
824 size = 4;
825 break;
826 default:
827 return AE_ERROR;
828 }
829
830 result = raw_pci_write(pci_id->segment, pci_id->bus,
831 PCI_DEVFN(pci_id->device, pci_id->function),
832 reg, size, value);
833
834 return (result ? AE_ERROR : AE_OK);
835 }
836
acpi_os_execute_deferred(struct work_struct * work)837 static void acpi_os_execute_deferred(struct work_struct *work)
838 {
839 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
840
841 dpc->function(dpc->context);
842 kfree(dpc);
843 }
844
845 #ifdef CONFIG_ACPI_DEBUGGER
846 static struct acpi_debugger acpi_debugger;
847 static bool acpi_debugger_initialized;
848
acpi_register_debugger(struct module * owner,const struct acpi_debugger_ops * ops)849 int acpi_register_debugger(struct module *owner,
850 const struct acpi_debugger_ops *ops)
851 {
852 int ret = 0;
853
854 mutex_lock(&acpi_debugger.lock);
855 if (acpi_debugger.ops) {
856 ret = -EBUSY;
857 goto err_lock;
858 }
859
860 acpi_debugger.owner = owner;
861 acpi_debugger.ops = ops;
862
863 err_lock:
864 mutex_unlock(&acpi_debugger.lock);
865 return ret;
866 }
867 EXPORT_SYMBOL(acpi_register_debugger);
868
acpi_unregister_debugger(const struct acpi_debugger_ops * ops)869 void acpi_unregister_debugger(const struct acpi_debugger_ops *ops)
870 {
871 mutex_lock(&acpi_debugger.lock);
872 if (ops == acpi_debugger.ops) {
873 acpi_debugger.ops = NULL;
874 acpi_debugger.owner = NULL;
875 }
876 mutex_unlock(&acpi_debugger.lock);
877 }
878 EXPORT_SYMBOL(acpi_unregister_debugger);
879
acpi_debugger_create_thread(acpi_osd_exec_callback function,void * context)880 int acpi_debugger_create_thread(acpi_osd_exec_callback function, void *context)
881 {
882 int ret;
883 int (*func)(acpi_osd_exec_callback, void *);
884 struct module *owner;
885
886 if (!acpi_debugger_initialized)
887 return -ENODEV;
888 mutex_lock(&acpi_debugger.lock);
889 if (!acpi_debugger.ops) {
890 ret = -ENODEV;
891 goto err_lock;
892 }
893 if (!try_module_get(acpi_debugger.owner)) {
894 ret = -ENODEV;
895 goto err_lock;
896 }
897 func = acpi_debugger.ops->create_thread;
898 owner = acpi_debugger.owner;
899 mutex_unlock(&acpi_debugger.lock);
900
901 ret = func(function, context);
902
903 mutex_lock(&acpi_debugger.lock);
904 module_put(owner);
905 err_lock:
906 mutex_unlock(&acpi_debugger.lock);
907 return ret;
908 }
909
acpi_debugger_write_log(const char * msg)910 ssize_t acpi_debugger_write_log(const char *msg)
911 {
912 ssize_t ret;
913 ssize_t (*func)(const char *);
914 struct module *owner;
915
916 if (!acpi_debugger_initialized)
917 return -ENODEV;
918 mutex_lock(&acpi_debugger.lock);
919 if (!acpi_debugger.ops) {
920 ret = -ENODEV;
921 goto err_lock;
922 }
923 if (!try_module_get(acpi_debugger.owner)) {
924 ret = -ENODEV;
925 goto err_lock;
926 }
927 func = acpi_debugger.ops->write_log;
928 owner = acpi_debugger.owner;
929 mutex_unlock(&acpi_debugger.lock);
930
931 ret = func(msg);
932
933 mutex_lock(&acpi_debugger.lock);
934 module_put(owner);
935 err_lock:
936 mutex_unlock(&acpi_debugger.lock);
937 return ret;
938 }
939
acpi_debugger_read_cmd(char * buffer,size_t buffer_length)940 ssize_t acpi_debugger_read_cmd(char *buffer, size_t buffer_length)
941 {
942 ssize_t ret;
943 ssize_t (*func)(char *, size_t);
944 struct module *owner;
945
946 if (!acpi_debugger_initialized)
947 return -ENODEV;
948 mutex_lock(&acpi_debugger.lock);
949 if (!acpi_debugger.ops) {
950 ret = -ENODEV;
951 goto err_lock;
952 }
953 if (!try_module_get(acpi_debugger.owner)) {
954 ret = -ENODEV;
955 goto err_lock;
956 }
957 func = acpi_debugger.ops->read_cmd;
958 owner = acpi_debugger.owner;
959 mutex_unlock(&acpi_debugger.lock);
960
961 ret = func(buffer, buffer_length);
962
963 mutex_lock(&acpi_debugger.lock);
964 module_put(owner);
965 err_lock:
966 mutex_unlock(&acpi_debugger.lock);
967 return ret;
968 }
969
acpi_debugger_wait_command_ready(void)970 int acpi_debugger_wait_command_ready(void)
971 {
972 int ret;
973 int (*func)(bool, char *, size_t);
974 struct module *owner;
975
976 if (!acpi_debugger_initialized)
977 return -ENODEV;
978 mutex_lock(&acpi_debugger.lock);
979 if (!acpi_debugger.ops) {
980 ret = -ENODEV;
981 goto err_lock;
982 }
983 if (!try_module_get(acpi_debugger.owner)) {
984 ret = -ENODEV;
985 goto err_lock;
986 }
987 func = acpi_debugger.ops->wait_command_ready;
988 owner = acpi_debugger.owner;
989 mutex_unlock(&acpi_debugger.lock);
990
991 ret = func(acpi_gbl_method_executing,
992 acpi_gbl_db_line_buf, ACPI_DB_LINE_BUFFER_SIZE);
993
994 mutex_lock(&acpi_debugger.lock);
995 module_put(owner);
996 err_lock:
997 mutex_unlock(&acpi_debugger.lock);
998 return ret;
999 }
1000
acpi_debugger_notify_command_complete(void)1001 int acpi_debugger_notify_command_complete(void)
1002 {
1003 int ret;
1004 int (*func)(void);
1005 struct module *owner;
1006
1007 if (!acpi_debugger_initialized)
1008 return -ENODEV;
1009 mutex_lock(&acpi_debugger.lock);
1010 if (!acpi_debugger.ops) {
1011 ret = -ENODEV;
1012 goto err_lock;
1013 }
1014 if (!try_module_get(acpi_debugger.owner)) {
1015 ret = -ENODEV;
1016 goto err_lock;
1017 }
1018 func = acpi_debugger.ops->notify_command_complete;
1019 owner = acpi_debugger.owner;
1020 mutex_unlock(&acpi_debugger.lock);
1021
1022 ret = func();
1023
1024 mutex_lock(&acpi_debugger.lock);
1025 module_put(owner);
1026 err_lock:
1027 mutex_unlock(&acpi_debugger.lock);
1028 return ret;
1029 }
1030
acpi_debugger_init(void)1031 int __init acpi_debugger_init(void)
1032 {
1033 mutex_init(&acpi_debugger.lock);
1034 acpi_debugger_initialized = true;
1035 return 0;
1036 }
1037 #endif
1038
1039 /*******************************************************************************
1040 *
1041 * FUNCTION: acpi_os_execute
1042 *
1043 * PARAMETERS: Type - Type of the callback
1044 * Function - Function to be executed
1045 * Context - Function parameters
1046 *
1047 * RETURN: Status
1048 *
1049 * DESCRIPTION: Depending on type, either queues function for deferred execution or
1050 * immediately executes function on a separate thread.
1051 *
1052 ******************************************************************************/
1053
acpi_os_execute(acpi_execute_type type,acpi_osd_exec_callback function,void * context)1054 acpi_status acpi_os_execute(acpi_execute_type type,
1055 acpi_osd_exec_callback function, void *context)
1056 {
1057 acpi_status status = AE_OK;
1058 struct acpi_os_dpc *dpc;
1059 struct workqueue_struct *queue;
1060 int ret;
1061 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1062 "Scheduling function [%p(%p)] for deferred execution.\n",
1063 function, context));
1064
1065 if (type == OSL_DEBUGGER_MAIN_THREAD) {
1066 ret = acpi_debugger_create_thread(function, context);
1067 if (ret) {
1068 pr_err("Call to kthread_create() failed.\n");
1069 status = AE_ERROR;
1070 }
1071 goto out_thread;
1072 }
1073
1074 /*
1075 * Allocate/initialize DPC structure. Note that this memory will be
1076 * freed by the callee. The kernel handles the work_struct list in a
1077 * way that allows us to also free its memory inside the callee.
1078 * Because we may want to schedule several tasks with different
1079 * parameters we can't use the approach some kernel code uses of
1080 * having a static work_struct.
1081 */
1082
1083 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
1084 if (!dpc)
1085 return AE_NO_MEMORY;
1086
1087 dpc->function = function;
1088 dpc->context = context;
1089
1090 /*
1091 * To prevent lockdep from complaining unnecessarily, make sure that
1092 * there is a different static lockdep key for each workqueue by using
1093 * INIT_WORK() for each of them separately.
1094 */
1095 if (type == OSL_NOTIFY_HANDLER) {
1096 queue = kacpi_notify_wq;
1097 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1098 } else if (type == OSL_GPE_HANDLER) {
1099 queue = kacpid_wq;
1100 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
1101 } else {
1102 pr_err("Unsupported os_execute type %d.\n", type);
1103 status = AE_ERROR;
1104 }
1105
1106 if (ACPI_FAILURE(status))
1107 goto err_workqueue;
1108
1109 /*
1110 * On some machines, a software-initiated SMI causes corruption unless
1111 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
1112 * typically it's done in GPE-related methods that are run via
1113 * workqueues, so we can avoid the known corruption cases by always
1114 * queueing on CPU 0.
1115 */
1116 ret = queue_work_on(0, queue, &dpc->work);
1117 if (!ret) {
1118 printk(KERN_ERR PREFIX
1119 "Call to queue_work() failed.\n");
1120 status = AE_ERROR;
1121 }
1122 err_workqueue:
1123 if (ACPI_FAILURE(status))
1124 kfree(dpc);
1125 out_thread:
1126 return status;
1127 }
1128 EXPORT_SYMBOL(acpi_os_execute);
1129
acpi_os_wait_events_complete(void)1130 void acpi_os_wait_events_complete(void)
1131 {
1132 /*
1133 * Make sure the GPE handler or the fixed event handler is not used
1134 * on another CPU after removal.
1135 */
1136 if (acpi_sci_irq_valid())
1137 synchronize_hardirq(acpi_sci_irq);
1138 flush_workqueue(kacpid_wq);
1139 flush_workqueue(kacpi_notify_wq);
1140 }
1141 EXPORT_SYMBOL(acpi_os_wait_events_complete);
1142
1143 struct acpi_hp_work {
1144 struct work_struct work;
1145 struct acpi_device *adev;
1146 u32 src;
1147 };
1148
acpi_hotplug_work_fn(struct work_struct * work)1149 static void acpi_hotplug_work_fn(struct work_struct *work)
1150 {
1151 struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
1152
1153 acpi_os_wait_events_complete();
1154 acpi_device_hotplug(hpw->adev, hpw->src);
1155 kfree(hpw);
1156 }
1157
acpi_hotplug_schedule(struct acpi_device * adev,u32 src)1158 acpi_status acpi_hotplug_schedule(struct acpi_device *adev, u32 src)
1159 {
1160 struct acpi_hp_work *hpw;
1161
1162 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1163 "Scheduling hotplug event (%p, %u) for deferred execution.\n",
1164 adev, src));
1165
1166 hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
1167 if (!hpw)
1168 return AE_NO_MEMORY;
1169
1170 INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
1171 hpw->adev = adev;
1172 hpw->src = src;
1173 /*
1174 * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because
1175 * the hotplug code may call driver .remove() functions, which may
1176 * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush
1177 * these workqueues.
1178 */
1179 if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
1180 kfree(hpw);
1181 return AE_ERROR;
1182 }
1183 return AE_OK;
1184 }
1185
acpi_queue_hotplug_work(struct work_struct * work)1186 bool acpi_queue_hotplug_work(struct work_struct *work)
1187 {
1188 return queue_work(kacpi_hotplug_wq, work);
1189 }
1190
1191 acpi_status
acpi_os_create_semaphore(u32 max_units,u32 initial_units,acpi_handle * handle)1192 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
1193 {
1194 struct semaphore *sem = NULL;
1195
1196 sem = acpi_os_allocate_zeroed(sizeof(struct semaphore));
1197 if (!sem)
1198 return AE_NO_MEMORY;
1199
1200 sema_init(sem, initial_units);
1201
1202 *handle = (acpi_handle *) sem;
1203
1204 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1205 *handle, initial_units));
1206
1207 return AE_OK;
1208 }
1209
1210 /*
1211 * TODO: A better way to delete semaphores? Linux doesn't have a
1212 * 'delete_semaphore()' function -- may result in an invalid
1213 * pointer dereference for non-synchronized consumers. Should
1214 * we at least check for blocked threads and signal/cancel them?
1215 */
1216
acpi_os_delete_semaphore(acpi_handle handle)1217 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1218 {
1219 struct semaphore *sem = (struct semaphore *)handle;
1220
1221 if (!sem)
1222 return AE_BAD_PARAMETER;
1223
1224 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1225
1226 BUG_ON(!list_empty(&sem->wait_list));
1227 kfree(sem);
1228 sem = NULL;
1229
1230 return AE_OK;
1231 }
1232
1233 /*
1234 * TODO: Support for units > 1?
1235 */
acpi_os_wait_semaphore(acpi_handle handle,u32 units,u16 timeout)1236 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1237 {
1238 acpi_status status = AE_OK;
1239 struct semaphore *sem = (struct semaphore *)handle;
1240 long jiffies;
1241 int ret = 0;
1242
1243 if (!acpi_os_initialized)
1244 return AE_OK;
1245
1246 if (!sem || (units < 1))
1247 return AE_BAD_PARAMETER;
1248
1249 if (units > 1)
1250 return AE_SUPPORT;
1251
1252 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1253 handle, units, timeout));
1254
1255 if (timeout == ACPI_WAIT_FOREVER)
1256 jiffies = MAX_SCHEDULE_TIMEOUT;
1257 else
1258 jiffies = msecs_to_jiffies(timeout);
1259
1260 ret = down_timeout(sem, jiffies);
1261 if (ret)
1262 status = AE_TIME;
1263
1264 if (ACPI_FAILURE(status)) {
1265 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1266 "Failed to acquire semaphore[%p|%d|%d], %s",
1267 handle, units, timeout,
1268 acpi_format_exception(status)));
1269 } else {
1270 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
1271 "Acquired semaphore[%p|%d|%d]", handle,
1272 units, timeout));
1273 }
1274
1275 return status;
1276 }
1277
1278 /*
1279 * TODO: Support for units > 1?
1280 */
acpi_os_signal_semaphore(acpi_handle handle,u32 units)1281 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1282 {
1283 struct semaphore *sem = (struct semaphore *)handle;
1284
1285 if (!acpi_os_initialized)
1286 return AE_OK;
1287
1288 if (!sem || (units < 1))
1289 return AE_BAD_PARAMETER;
1290
1291 if (units > 1)
1292 return AE_SUPPORT;
1293
1294 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1295 units));
1296
1297 up(sem);
1298
1299 return AE_OK;
1300 }
1301
acpi_os_get_line(char * buffer,u32 buffer_length,u32 * bytes_read)1302 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read)
1303 {
1304 #ifdef ENABLE_DEBUGGER
1305 if (acpi_in_debugger) {
1306 u32 chars;
1307
1308 kdb_read(buffer, buffer_length);
1309
1310 /* remove the CR kdb includes */
1311 chars = strlen(buffer) - 1;
1312 buffer[chars] = '\0';
1313 }
1314 #else
1315 int ret;
1316
1317 ret = acpi_debugger_read_cmd(buffer, buffer_length);
1318 if (ret < 0)
1319 return AE_ERROR;
1320 if (bytes_read)
1321 *bytes_read = ret;
1322 #endif
1323
1324 return AE_OK;
1325 }
1326 EXPORT_SYMBOL(acpi_os_get_line);
1327
acpi_os_wait_command_ready(void)1328 acpi_status acpi_os_wait_command_ready(void)
1329 {
1330 int ret;
1331
1332 ret = acpi_debugger_wait_command_ready();
1333 if (ret < 0)
1334 return AE_ERROR;
1335 return AE_OK;
1336 }
1337
acpi_os_notify_command_complete(void)1338 acpi_status acpi_os_notify_command_complete(void)
1339 {
1340 int ret;
1341
1342 ret = acpi_debugger_notify_command_complete();
1343 if (ret < 0)
1344 return AE_ERROR;
1345 return AE_OK;
1346 }
1347
acpi_os_signal(u32 function,void * info)1348 acpi_status acpi_os_signal(u32 function, void *info)
1349 {
1350 switch (function) {
1351 case ACPI_SIGNAL_FATAL:
1352 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1353 break;
1354 case ACPI_SIGNAL_BREAKPOINT:
1355 /*
1356 * AML Breakpoint
1357 * ACPI spec. says to treat it as a NOP unless
1358 * you are debugging. So if/when we integrate
1359 * AML debugger into the kernel debugger its
1360 * hook will go here. But until then it is
1361 * not useful to print anything on breakpoints.
1362 */
1363 break;
1364 default:
1365 break;
1366 }
1367
1368 return AE_OK;
1369 }
1370
acpi_os_name_setup(char * str)1371 static int __init acpi_os_name_setup(char *str)
1372 {
1373 char *p = acpi_os_name;
1374 int count = ACPI_MAX_OVERRIDE_LEN - 1;
1375
1376 if (!str || !*str)
1377 return 0;
1378
1379 for (; count-- && *str; str++) {
1380 if (isalnum(*str) || *str == ' ' || *str == ':')
1381 *p++ = *str;
1382 else if (*str == '\'' || *str == '"')
1383 continue;
1384 else
1385 break;
1386 }
1387 *p = 0;
1388
1389 return 1;
1390
1391 }
1392
1393 __setup("acpi_os_name=", acpi_os_name_setup);
1394
1395 /*
1396 * Disable the auto-serialization of named objects creation methods.
1397 *
1398 * This feature is enabled by default. It marks the AML control methods
1399 * that contain the opcodes to create named objects as "Serialized".
1400 */
acpi_no_auto_serialize_setup(char * str)1401 static int __init acpi_no_auto_serialize_setup(char *str)
1402 {
1403 acpi_gbl_auto_serialize_methods = FALSE;
1404 pr_info("ACPI: auto-serialization disabled\n");
1405
1406 return 1;
1407 }
1408
1409 __setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup);
1410
1411 /* Check of resource interference between native drivers and ACPI
1412 * OperationRegions (SystemIO and System Memory only).
1413 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1414 * in arbitrary AML code and can interfere with legacy drivers.
1415 * acpi_enforce_resources= can be set to:
1416 *
1417 * - strict (default) (2)
1418 * -> further driver trying to access the resources will not load
1419 * - lax (1)
1420 * -> further driver trying to access the resources will load, but you
1421 * get a system message that something might go wrong...
1422 *
1423 * - no (0)
1424 * -> ACPI Operation Region resources will not be registered
1425 *
1426 */
1427 #define ENFORCE_RESOURCES_STRICT 2
1428 #define ENFORCE_RESOURCES_LAX 1
1429 #define ENFORCE_RESOURCES_NO 0
1430
1431 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1432
acpi_enforce_resources_setup(char * str)1433 static int __init acpi_enforce_resources_setup(char *str)
1434 {
1435 if (str == NULL || *str == '\0')
1436 return 0;
1437
1438 if (!strcmp("strict", str))
1439 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1440 else if (!strcmp("lax", str))
1441 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1442 else if (!strcmp("no", str))
1443 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1444
1445 return 1;
1446 }
1447
1448 __setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1449
1450 /* Check for resource conflicts between ACPI OperationRegions and native
1451 * drivers */
acpi_check_resource_conflict(const struct resource * res)1452 int acpi_check_resource_conflict(const struct resource *res)
1453 {
1454 acpi_adr_space_type space_id;
1455 acpi_size length;
1456 u8 warn = 0;
1457 int clash = 0;
1458
1459 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1460 return 0;
1461 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1462 return 0;
1463
1464 if (res->flags & IORESOURCE_IO)
1465 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1466 else
1467 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
1468
1469 length = resource_size(res);
1470 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1471 warn = 1;
1472 clash = acpi_check_address_range(space_id, res->start, length, warn);
1473
1474 if (clash) {
1475 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
1476 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1477 printk(KERN_NOTICE "ACPI: This conflict may"
1478 " cause random problems and system"
1479 " instability\n");
1480 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1481 " for this device, you should use it instead of"
1482 " the native driver\n");
1483 }
1484 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1485 return -EBUSY;
1486 }
1487 return 0;
1488 }
1489 EXPORT_SYMBOL(acpi_check_resource_conflict);
1490
acpi_check_region(resource_size_t start,resource_size_t n,const char * name)1491 int acpi_check_region(resource_size_t start, resource_size_t n,
1492 const char *name)
1493 {
1494 struct resource res = {
1495 .start = start,
1496 .end = start + n - 1,
1497 .name = name,
1498 .flags = IORESOURCE_IO,
1499 };
1500
1501 return acpi_check_resource_conflict(&res);
1502 }
1503 EXPORT_SYMBOL(acpi_check_region);
1504
acpi_deactivate_mem_region(acpi_handle handle,u32 level,void * _res,void ** return_value)1505 static acpi_status acpi_deactivate_mem_region(acpi_handle handle, u32 level,
1506 void *_res, void **return_value)
1507 {
1508 struct acpi_mem_space_context **mem_ctx;
1509 union acpi_operand_object *handler_obj;
1510 union acpi_operand_object *region_obj2;
1511 union acpi_operand_object *region_obj;
1512 struct resource *res = _res;
1513 acpi_status status;
1514
1515 region_obj = acpi_ns_get_attached_object(handle);
1516 if (!region_obj)
1517 return AE_OK;
1518
1519 handler_obj = region_obj->region.handler;
1520 if (!handler_obj)
1521 return AE_OK;
1522
1523 if (region_obj->region.space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
1524 return AE_OK;
1525
1526 if (!(region_obj->region.flags & AOPOBJ_SETUP_COMPLETE))
1527 return AE_OK;
1528
1529 region_obj2 = acpi_ns_get_secondary_object(region_obj);
1530 if (!region_obj2)
1531 return AE_OK;
1532
1533 mem_ctx = (void *)®ion_obj2->extra.region_context;
1534
1535 if (!(mem_ctx[0]->address >= res->start &&
1536 mem_ctx[0]->address < res->end))
1537 return AE_OK;
1538
1539 status = handler_obj->address_space.setup(region_obj,
1540 ACPI_REGION_DEACTIVATE,
1541 NULL, (void **)mem_ctx);
1542 if (ACPI_SUCCESS(status))
1543 region_obj->region.flags &= ~(AOPOBJ_SETUP_COMPLETE);
1544
1545 return status;
1546 }
1547
1548 /**
1549 * acpi_release_memory - Release any mappings done to a memory region
1550 * @handle: Handle to namespace node
1551 * @res: Memory resource
1552 * @level: A level that terminates the search
1553 *
1554 * Walks through @handle and unmaps all SystemMemory Operation Regions that
1555 * overlap with @res and that have already been activated (mapped).
1556 *
1557 * This is a helper that allows drivers to place special requirements on memory
1558 * region that may overlap with operation regions, primarily allowing them to
1559 * safely map the region as non-cached memory.
1560 *
1561 * The unmapped Operation Regions will be automatically remapped next time they
1562 * are called, so the drivers do not need to do anything else.
1563 */
acpi_release_memory(acpi_handle handle,struct resource * res,u32 level)1564 acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
1565 u32 level)
1566 {
1567 if (!(res->flags & IORESOURCE_MEM))
1568 return AE_TYPE;
1569
1570 return acpi_walk_namespace(ACPI_TYPE_REGION, handle, level,
1571 acpi_deactivate_mem_region, NULL, res, NULL);
1572 }
1573 EXPORT_SYMBOL_GPL(acpi_release_memory);
1574
1575 /*
1576 * Let drivers know whether the resource checks are effective
1577 */
acpi_resources_are_enforced(void)1578 int acpi_resources_are_enforced(void)
1579 {
1580 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1581 }
1582 EXPORT_SYMBOL(acpi_resources_are_enforced);
1583
1584 /*
1585 * Deallocate the memory for a spinlock.
1586 */
acpi_os_delete_lock(acpi_spinlock handle)1587 void acpi_os_delete_lock(acpi_spinlock handle)
1588 {
1589 ACPI_FREE(handle);
1590 }
1591
1592 /*
1593 * Acquire a spinlock.
1594 *
1595 * handle is a pointer to the spinlock_t.
1596 */
1597
acpi_os_acquire_lock(acpi_spinlock lockp)1598 acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
1599 {
1600 acpi_cpu_flags flags;
1601 spin_lock_irqsave(lockp, flags);
1602 return flags;
1603 }
1604
1605 /*
1606 * Release a spinlock. See above.
1607 */
1608
acpi_os_release_lock(acpi_spinlock lockp,acpi_cpu_flags flags)1609 void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
1610 {
1611 spin_unlock_irqrestore(lockp, flags);
1612 }
1613
1614 #ifndef ACPI_USE_LOCAL_CACHE
1615
1616 /*******************************************************************************
1617 *
1618 * FUNCTION: acpi_os_create_cache
1619 *
1620 * PARAMETERS: name - Ascii name for the cache
1621 * size - Size of each cached object
1622 * depth - Maximum depth of the cache (in objects) <ignored>
1623 * cache - Where the new cache object is returned
1624 *
1625 * RETURN: status
1626 *
1627 * DESCRIPTION: Create a cache object
1628 *
1629 ******************************************************************************/
1630
1631 acpi_status
acpi_os_create_cache(char * name,u16 size,u16 depth,acpi_cache_t ** cache)1632 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
1633 {
1634 *cache = kmem_cache_create(name, size, 0, 0, NULL);
1635 if (*cache == NULL)
1636 return AE_ERROR;
1637 else
1638 return AE_OK;
1639 }
1640
1641 /*******************************************************************************
1642 *
1643 * FUNCTION: acpi_os_purge_cache
1644 *
1645 * PARAMETERS: Cache - Handle to cache object
1646 *
1647 * RETURN: Status
1648 *
1649 * DESCRIPTION: Free all objects within the requested cache.
1650 *
1651 ******************************************************************************/
1652
acpi_os_purge_cache(acpi_cache_t * cache)1653 acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
1654 {
1655 kmem_cache_shrink(cache);
1656 return (AE_OK);
1657 }
1658
1659 /*******************************************************************************
1660 *
1661 * FUNCTION: acpi_os_delete_cache
1662 *
1663 * PARAMETERS: Cache - Handle to cache object
1664 *
1665 * RETURN: Status
1666 *
1667 * DESCRIPTION: Free all objects within the requested cache and delete the
1668 * cache object.
1669 *
1670 ******************************************************************************/
1671
acpi_os_delete_cache(acpi_cache_t * cache)1672 acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
1673 {
1674 kmem_cache_destroy(cache);
1675 return (AE_OK);
1676 }
1677
1678 /*******************************************************************************
1679 *
1680 * FUNCTION: acpi_os_release_object
1681 *
1682 * PARAMETERS: Cache - Handle to cache object
1683 * Object - The object to be released
1684 *
1685 * RETURN: None
1686 *
1687 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1688 * the object is deleted.
1689 *
1690 ******************************************************************************/
1691
acpi_os_release_object(acpi_cache_t * cache,void * object)1692 acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
1693 {
1694 kmem_cache_free(cache, object);
1695 return (AE_OK);
1696 }
1697 #endif
1698
acpi_no_static_ssdt_setup(char * s)1699 static int __init acpi_no_static_ssdt_setup(char *s)
1700 {
1701 acpi_gbl_disable_ssdt_table_install = TRUE;
1702 pr_info("ACPI: static SSDT installation disabled\n");
1703
1704 return 0;
1705 }
1706
1707 early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup);
1708
acpi_disable_return_repair(char * s)1709 static int __init acpi_disable_return_repair(char *s)
1710 {
1711 printk(KERN_NOTICE PREFIX
1712 "ACPI: Predefined validation mechanism disabled\n");
1713 acpi_gbl_disable_auto_repair = TRUE;
1714
1715 return 1;
1716 }
1717
1718 __setup("acpica_no_return_repair", acpi_disable_return_repair);
1719
acpi_os_initialize(void)1720 acpi_status __init acpi_os_initialize(void)
1721 {
1722 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1723 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1724 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1725 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1726 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) {
1727 /*
1728 * Use acpi_os_map_generic_address to pre-map the reset
1729 * register if it's in system memory.
1730 */
1731 int rv;
1732
1733 rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register);
1734 pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv);
1735 }
1736 acpi_os_initialized = true;
1737
1738 return AE_OK;
1739 }
1740
acpi_os_initialize1(void)1741 acpi_status __init acpi_os_initialize1(void)
1742 {
1743 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1744 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1745 kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
1746 BUG_ON(!kacpid_wq);
1747 BUG_ON(!kacpi_notify_wq);
1748 BUG_ON(!kacpi_hotplug_wq);
1749 acpi_osi_init();
1750 return AE_OK;
1751 }
1752
acpi_os_terminate(void)1753 acpi_status acpi_os_terminate(void)
1754 {
1755 if (acpi_irq_handler) {
1756 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
1757 acpi_irq_handler);
1758 }
1759
1760 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1761 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1762 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1763 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1764 if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER)
1765 acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register);
1766
1767 destroy_workqueue(kacpid_wq);
1768 destroy_workqueue(kacpi_notify_wq);
1769 destroy_workqueue(kacpi_hotplug_wq);
1770
1771 return AE_OK;
1772 }
1773
acpi_os_prepare_sleep(u8 sleep_state,u32 pm1a_control,u32 pm1b_control)1774 acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1775 u32 pm1b_control)
1776 {
1777 int rc = 0;
1778 if (__acpi_os_prepare_sleep)
1779 rc = __acpi_os_prepare_sleep(sleep_state,
1780 pm1a_control, pm1b_control);
1781 if (rc < 0)
1782 return AE_ERROR;
1783 else if (rc > 0)
1784 return AE_CTRL_TERMINATE;
1785
1786 return AE_OK;
1787 }
1788
acpi_os_set_prepare_sleep(int (* func)(u8 sleep_state,u32 pm1a_ctrl,u32 pm1b_ctrl))1789 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1790 u32 pm1a_ctrl, u32 pm1b_ctrl))
1791 {
1792 __acpi_os_prepare_sleep = func;
1793 }
1794
1795 #if (ACPI_REDUCED_HARDWARE)
acpi_os_prepare_extended_sleep(u8 sleep_state,u32 val_a,u32 val_b)1796 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1797 u32 val_b)
1798 {
1799 int rc = 0;
1800 if (__acpi_os_prepare_extended_sleep)
1801 rc = __acpi_os_prepare_extended_sleep(sleep_state,
1802 val_a, val_b);
1803 if (rc < 0)
1804 return AE_ERROR;
1805 else if (rc > 0)
1806 return AE_CTRL_TERMINATE;
1807
1808 return AE_OK;
1809 }
1810 #else
acpi_os_prepare_extended_sleep(u8 sleep_state,u32 val_a,u32 val_b)1811 acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1812 u32 val_b)
1813 {
1814 return AE_OK;
1815 }
1816 #endif
1817
acpi_os_set_prepare_extended_sleep(int (* func)(u8 sleep_state,u32 val_a,u32 val_b))1818 void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1819 u32 val_a, u32 val_b))
1820 {
1821 __acpi_os_prepare_extended_sleep = func;
1822 }
1823
acpi_os_enter_sleep(u8 sleep_state,u32 reg_a_value,u32 reg_b_value)1824 acpi_status acpi_os_enter_sleep(u8 sleep_state,
1825 u32 reg_a_value, u32 reg_b_value)
1826 {
1827 acpi_status status;
1828
1829 if (acpi_gbl_reduced_hardware)
1830 status = acpi_os_prepare_extended_sleep(sleep_state,
1831 reg_a_value,
1832 reg_b_value);
1833 else
1834 status = acpi_os_prepare_sleep(sleep_state,
1835 reg_a_value, reg_b_value);
1836 return status;
1837 }
1838