Added missing tegra files.HEADmaster

2 files changed, 591 insertions, 0 deletions

diff --git a/drivers/acpi/acpica/acconfig.h b/drivers/acpi/acpica/acconfig.h
new file mode 100644
index 00000000000..f895a244ca7
--- /dev/null
+++ b/drivers/acpi/acpica/acconfig.h
@@ -0,0 +1,226 @@
+/******************************************************************************
+ *
+ * Name: acconfig.h - Global configuration constants
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2011, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef _ACCONFIG_H
+#define _ACCONFIG_H
+
+/******************************************************************************
+ *
+ * Configuration options
+ *
+ *****************************************************************************/
+
+/*
+ * ACPI_DEBUG_OUTPUT    - This switch enables all the debug facilities of the
+ *                        ACPI subsystem.  This includes the DEBUG_PRINT output
+ *                        statements.  When disabled, all DEBUG_PRINT
+ *                        statements are compiled out.
+ *
+ * ACPI_APPLICATION     - Use this switch if the subsystem is going to be run
+ *                        at the application level.
+ *
+ */
+
+/*
+ * OS name, used for the _OS object.  The _OS object is essentially obsolete,
+ * but there is a large base of ASL/AML code in existing machines that check
+ * for the string below.  The use of this string usually guarantees that
+ * the ASL will execute down the most tested code path.  Also, there is some
+ * code that will not execute the _OSI method unless _OS matches the string
+ * below.  Therefore, change this string at your own risk.
+ */
+#define ACPI_OS_NAME                    "Microsoft Windows NT"
+
+/* Maximum objects in the various object caches */
+
+#define ACPI_MAX_STATE_CACHE_DEPTH      96      /* State objects */
+#define ACPI_MAX_PARSE_CACHE_DEPTH      96      /* Parse tree objects */
+#define ACPI_MAX_EXTPARSE_CACHE_DEPTH   96      /* Parse tree objects */
+#define ACPI_MAX_OBJECT_CACHE_DEPTH     96      /* Interpreter operand objects */
+#define ACPI_MAX_NAMESPACE_CACHE_DEPTH  96      /* Namespace objects */
+
+/*
+ * Should the subsystem abort the loading of an ACPI table if the
+ * table checksum is incorrect?
+ */
+#define ACPI_CHECKSUM_ABORT             FALSE
+
+/******************************************************************************
+ *
+ * Subsystem Constants
+ *
+ *****************************************************************************/
+
+/* Version of ACPI supported */
+
+#define ACPI_CA_SUPPORT_LEVEL           3
+
+/* Maximum count for a semaphore object */
+
+#define ACPI_MAX_SEMAPHORE_COUNT        256
+
+/* Maximum object reference count (detects object deletion issues) */
+
+#define ACPI_MAX_REFERENCE_COUNT        0x1000
+
+/* Default page size for use in mapping memory for operation regions */
+
+#define ACPI_DEFAULT_PAGE_SIZE          4096    /* Must be power of 2 */
+
+/* owner_id tracking. 8 entries allows for 255 owner_ids */
+
+#define ACPI_NUM_OWNERID_MASKS          8
+
+/* Size of the root table array is increased by this increment */
+
+#define ACPI_ROOT_TABLE_SIZE_INCREMENT  4
+
+/* Maximum number of While() loop iterations before forced abort */
+
+#define ACPI_MAX_LOOP_ITERATIONS        0xFFFF
+
+/* Maximum sleep allowed via Sleep() operator */
+
+#define ACPI_MAX_SLEEP                  2000    /* Two seconds */
+
+/******************************************************************************
+ *
+ * ACPI Specification constants (Do not change unless the specification changes)
+ *
+ *****************************************************************************/
+
+/* Number of distinct GPE register blocks and register width */
+
+#define ACPI_MAX_GPE_BLOCKS             2
+#define ACPI_GPE_REGISTER_WIDTH         8
+
+/* Method info (in WALK_STATE), containing local variables and argumetns */
+
+#define ACPI_METHOD_NUM_LOCALS          8
+#define ACPI_METHOD_MAX_LOCAL           7
+
+#define ACPI_METHOD_NUM_ARGS            7
+#define ACPI_METHOD_MAX_ARG             6
+
+/* Length of _HID, _UID, _CID, and UUID values */
+
+#define ACPI_DEVICE_ID_LENGTH           0x09
+#define ACPI_MAX_CID_LENGTH             48
+#define ACPI_UUID_LENGTH                16
+
+/*
+ * Operand Stack (in WALK_STATE), Must be large enough to contain METHOD_MAX_ARG
+ */
+#define ACPI_OBJ_NUM_OPERANDS           8
+#define ACPI_OBJ_MAX_OPERAND            7
+
+/* Number of elements in the Result Stack frame, can be an arbitrary value */
+
+#define ACPI_RESULTS_FRAME_OBJ_NUM      8
+
+/*
+ * Maximal number of elements the Result Stack can contain,
+ * it may be an arbitray value not exceeding the types of
+ * result_size and result_count (now u8).
+ */
+#define ACPI_RESULTS_OBJ_NUM_MAX        255
+
+/* Names within the namespace are 4 bytes long */
+
+#define ACPI_NAME_SIZE                  4
+#define ACPI_PATH_SEGMENT_LENGTH        5       /* 4 chars for name + 1 char for separator */
+#define ACPI_PATH_SEPARATOR             '.'
+
+/* Sizes for ACPI table headers */
+
+#define ACPI_OEM_ID_SIZE                6
+#define ACPI_OEM_TABLE_ID_SIZE          8
+
+/* Constants used in searching for the RSDP in low memory */
+
+#define ACPI_EBDA_PTR_LOCATION          0x0000040E      /* Physical Address */
+#define ACPI_EBDA_PTR_LENGTH            2
+#define ACPI_EBDA_WINDOW_SIZE           1024
+#define ACPI_HI_RSDP_WINDOW_BASE        0x000E0000      /* Physical Address */
+#define ACPI_HI_RSDP_WINDOW_SIZE        0x00020000
+#define ACPI_RSDP_SCAN_STEP             16
+
+/* Operation regions */
+
+#define ACPI_USER_REGION_BEGIN          0x80
+
+/* Maximum space_ids for Operation Regions */
+
+#define ACPI_MAX_ADDRESS_SPACE          255
+
+/* Array sizes.  Used for range checking also */
+
+#define ACPI_MAX_MATCH_OPCODE           5
+
+/* RSDP checksums */
+
+#define ACPI_RSDP_CHECKSUM_LENGTH       20
+#define ACPI_RSDP_XCHECKSUM_LENGTH      36
+
+/* SMBus and IPMI bidirectional buffer size */
+
+#define ACPI_SMBUS_BUFFER_SIZE          34
+#define ACPI_IPMI_BUFFER_SIZE           66
+
+/* _sx_d and _sx_w control methods */
+
+#define ACPI_NUM_sx_d_METHODS           4
+#define ACPI_NUM_sx_w_METHODS           5
+
+/******************************************************************************
+ *
+ * ACPI AML Debugger
+ *
+ *****************************************************************************/
+
+#define ACPI_DEBUGGER_MAX_ARGS          8       /* Must be max method args + 1 */
+
+#define ACPI_DEBUGGER_COMMAND_PROMPT    '-'
+#define ACPI_DEBUGGER_EXECUTE_PROMPT    '%'
+
+#endif                          /* _ACCONFIG_H */
diff --git a/drivers/acpi/atomicio.c b/drivers/acpi/atomicio.c
new file mode 100644
index 00000000000..f151afe61aa
--- /dev/null
+++ b/drivers/acpi/atomicio.c
@@ -0,0 +1,365 @@
+/*
+ * atomicio.c - ACPI IO memory pre-mapping/post-unmapping, then
+ * accessing in atomic context.
+ *
+ * This is used for NMI handler to access IO memory area, because
+ * ioremap/iounmap can not be used in NMI handler. The IO memory area
+ * is pre-mapped in process context and accessed in NMI handler.
+ *
+ * Copyright (C) 2009-2010, Intel Corp.
+ *      Author: Huang Ying <ying.huang@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/io.h>
+#include <linux/kref.h>
+#include <linux/rculist.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <acpi/atomicio.h>
+
+#define ACPI_PFX "ACPI: "
+
+static LIST_HEAD(acpi_iomaps);
+/*
+ * Used for mutual exclusion between writers of acpi_iomaps list, for
+ * synchronization between readers and writer, RCU is used.
+ */
+static DEFINE_SPINLOCK(acpi_iomaps_lock);
+
+struct acpi_iomap {
+        struct list_head list;
+        void __iomem *vaddr;
+        unsigned long size;
+        phys_addr_t paddr;
+        struct kref ref;
+};
+
+/* acpi_iomaps_lock or RCU read lock must be held before calling */
+static struct acpi_iomap *__acpi_find_iomap(phys_addr_t paddr,
+                                            unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        list_for_each_entry_rcu(map, &acpi_iomaps, list) {
+                if (map->paddr + map->size >= paddr + size &&
+                    map->paddr <= paddr)
+                        return map;
+        }
+        return NULL;
+}
+
+/*
+ * Atomic "ioremap" used by NMI handler, if the specified IO memory
+ * area is not pre-mapped, NULL will be returned.
+ *
+ * acpi_iomaps_lock or RCU read lock must be held before calling
+ */
+static void __iomem *__acpi_ioremap_fast(phys_addr_t paddr,
+                                         unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        map = __acpi_find_iomap(paddr, size/8);
+        if (map)
+                return map->vaddr + (paddr - map->paddr);
+        else
+                return NULL;
+}
+
+/* acpi_iomaps_lock must be held before calling */
+static void __iomem *__acpi_try_ioremap(phys_addr_t paddr,
+                                        unsigned long size)
+{
+        struct acpi_iomap *map;
+
+        map = __acpi_find_iomap(paddr, size);
+        if (map) {
+                kref_get(&map->ref);
+                return map->vaddr + (paddr - map->paddr);
+        } else
+                return NULL;
+}
+
+/*
+ * Used to pre-map the specified IO memory area. First try to find
+ * whether the area is already pre-mapped, if it is, increase the
+ * reference count (in __acpi_try_ioremap) and return; otherwise, do
+ * the real ioremap, and add the mapping into acpi_iomaps list.
+ */
+static void __iomem *acpi_pre_map(phys_addr_t paddr,
+                                  unsigned long size)
+{
+        void __iomem *vaddr;
+        struct acpi_iomap *map;
+        unsigned long pg_sz, flags;
+        phys_addr_t pg_off;
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        vaddr = __acpi_try_ioremap(paddr, size);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+        if (vaddr)
+                return vaddr;
+
+        pg_off = paddr & PAGE_MASK;
+        pg_sz = ((paddr + size + PAGE_SIZE - 1) & PAGE_MASK) - pg_off;
+        vaddr = ioremap(pg_off, pg_sz);
+        if (!vaddr)
+                return NULL;
+        map = kmalloc(sizeof(*map), GFP_KERNEL);
+        if (!map)
+                goto err_unmap;
+        INIT_LIST_HEAD(&map->list);
+        map->paddr = pg_off;
+        map->size = pg_sz;
+        map->vaddr = vaddr;
+        kref_init(&map->ref);
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        vaddr = __acpi_try_ioremap(paddr, size);
+        if (vaddr) {
+                spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+                iounmap(map->vaddr);
+                kfree(map);
+                return vaddr;
+        }
+        list_add_tail_rcu(&map->list, &acpi_iomaps);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+
+        return map->vaddr + (paddr - map->paddr);
+err_unmap:
+        iounmap(vaddr);
+        return NULL;
+}
+
+/* acpi_iomaps_lock must be held before calling */
+static void __acpi_kref_del_iomap(struct kref *ref)
+{
+        struct acpi_iomap *map;
+
+        map = container_of(ref, struct acpi_iomap, ref);
+        list_del_rcu(&map->list);
+}
+
+/*
+ * Used to post-unmap the specified IO memory area. The iounmap is
+ * done only if the reference count goes zero.
+ */
+static void acpi_post_unmap(phys_addr_t paddr, unsigned long size)
+{
+        struct acpi_iomap *map;
+        unsigned long flags;
+        int del;
+
+        spin_lock_irqsave(&acpi_iomaps_lock, flags);
+        map = __acpi_find_iomap(paddr, size);
+        BUG_ON(!map);
+        del = kref_put(&map->ref, __acpi_kref_del_iomap);
+        spin_unlock_irqrestore(&acpi_iomaps_lock, flags);
+
+        if (!del)
+                return;
+
+        synchronize_rcu();
+        iounmap(map->vaddr);
+        kfree(map);
+}
+
+/* In NMI handler, should set silent = 1 */
+static int acpi_check_gar(struct acpi_generic_address *reg,
+                          u64 *paddr, int silent)
+{
+        u32 width, space_id;
+
+        width = reg->bit_width;
+        space_id = reg->space_id;
+        /* Handle possible alignment issues */
+        memcpy(paddr, &reg->address, sizeof(*paddr));
+        if (!*paddr) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                        "Invalid physical address in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                                   "Invalid bit width in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY &&
+            space_id != ACPI_ADR_SPACE_SYSTEM_IO) {
+                if (!silent)
+                        pr_warning(FW_BUG ACPI_PFX
+                        "Invalid address space type in GAR [0x%llx/%u/%u]\n",
+                                   *paddr, width, space_id);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/* Pre-map, working on GAR */
+int acpi_pre_map_gar(struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        void __iomem *vaddr;
+        int rc;
+
+        if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                return 0;
+
+        rc = acpi_check_gar(reg, &paddr, 0);
+        if (rc)
+                return rc;
+
+        vaddr = acpi_pre_map(paddr, reg->bit_width / 8);
+        if (!vaddr)
+                return -EIO;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_pre_map_gar);
+
+/* Post-unmap, working on GAR */
+int acpi_post_unmap_gar(struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
+                return 0;
+
+        rc = acpi_check_gar(reg, &paddr, 0);
+        if (rc)
+                return rc;
+
+        acpi_post_unmap(paddr, reg->bit_width / 8);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(acpi_post_unmap_gar);
+
+/*
+ * Can be used in atomic (including NMI) or process context. RCU read
+ * lock can only be released after the IO memory area accessing.
+ */
+static int acpi_atomic_read_mem(u64 paddr, u64 *val, u32 width)
+{
+        void __iomem *addr;
+
+        rcu_read_lock();
+        addr = __acpi_ioremap_fast(paddr, width);
+        switch (width) {
+        case 8:
+                *val = readb(addr);
+                break;
+        case 16:
+                *val = readw(addr);
+                break;
+        case 32:
+                *val = readl(addr);
+                break;
+#ifdef readq
+        case 64:
+                *val = readq(addr);
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+        rcu_read_unlock();
+
+        return 0;
+}
+
+static int acpi_atomic_write_mem(u64 paddr, u64 val, u32 width)
+{
+        void __iomem *addr;
+
+        rcu_read_lock();
+        addr = __acpi_ioremap_fast(paddr, width);
+        switch (width) {
+        case 8:
+                writeb(val, addr);
+                break;
+        case 16:
+                writew(val, addr);
+                break;
+        case 32:
+                writel(val, addr);
+                break;
+#ifdef writeq
+        case 64:
+                writeq(val, addr);
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+        rcu_read_unlock();
+
+        return 0;
+}
+
+/* GAR accessing in atomic (including NMI) or process context */
+int acpi_atomic_read(u64 *val, struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        rc = acpi_check_gar(reg, &paddr, 1);
+        if (rc)
+                return rc;
+
+        *val = 0;
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                return acpi_atomic_read_mem(paddr, val, reg->bit_width);
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                return acpi_os_read_port(paddr, (u32 *)val, reg->bit_width);
+        default:
+                return -EINVAL;
+        }
+}
+EXPORT_SYMBOL_GPL(acpi_atomic_read);
+
+int acpi_atomic_write(u64 val, struct acpi_generic_address *reg)
+{
+        u64 paddr;
+        int rc;
+
+        rc = acpi_check_gar(reg, &paddr, 1);
+        if (rc)
+                return rc;
+
+        switch (reg->space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+                return acpi_atomic_write_mem(paddr, val, reg->bit_width);
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                return acpi_os_write_port(paddr, val, reg->bit_width);
+        default:
+                return -EINVAL;
+        }
+}
+EXPORT_SYMBOL_GPL(acpi_atomic_write);