unknown changes from android-tegra-nv-3.4
Dan Willemsen [Sat, 8 Sep 2012 06:07:53 +0000 (23:07 -0700)]
Rebase-Id: R940fad74c7e91ef3d1d3d589a48064ccb7335541

79 files changed:
arch/arm/mach-tegra/Makefile
arch/arm/mach-tegra/board-info.c
arch/arm/mach-tegra/board-touch-raydium_spi.c
arch/arm/mach-tegra/board.h
arch/arm/mach-tegra/clock.c
arch/arm/mach-tegra/clock.h
arch/arm/mach-tegra/common.c
arch/arm/mach-tegra/cpuidle-t2.c
arch/arm/mach-tegra/cpuidle-t3.c
arch/arm/mach-tegra/cpuidle.c
arch/arm/mach-tegra/devices.c
arch/arm/mach-tegra/devices.h
arch/arm/mach-tegra/edp.c
arch/arm/mach-tegra/flowctrl.c
arch/arm/mach-tegra/flowctrl.h
arch/arm/mach-tegra/headsmp.S
arch/arm/mach-tegra/include/mach/gpio-tegra.h
arch/arm/mach-tegra/include/mach/hardware.h
arch/arm/mach-tegra/include/mach/irqs.h
arch/arm/mach-tegra/include/mach/powergate.h
arch/arm/mach-tegra/include/mach/uncompress.h
arch/arm/mach-tegra/io.c
arch/arm/mach-tegra/iomap.h
arch/arm/mach-tegra/irq.c
arch/arm/mach-tegra/pinmux-tegra20-tables.c
arch/arm/mach-tegra/platsmp.c
arch/arm/mach-tegra/pm-t3.c
arch/arm/mach-tegra/pm.c
arch/arm/mach-tegra/pm.h
arch/arm/mach-tegra/powerdetect.c
arch/arm/mach-tegra/powergate.c
arch/arm/mach-tegra/reset.c
arch/arm/mach-tegra/reset.h
arch/arm/mach-tegra/sleep-t20.S
arch/arm/mach-tegra/sleep-t30.S
arch/arm/mach-tegra/sleep.S
arch/arm/mach-tegra/sleep.h
arch/arm/mach-tegra/tegra2_emc.c
arch/arm/mach-tegra/tegra2_emc.h
arch/arm/mach-tegra/tegra3_emc.c
arch/arm/mach-tegra/tegra3_emc.h
arch/arm/mach-tegra/tegra3_thermal.c
arch/arm/mach-tegra/timer-t2.c
arch/arm/mach-tegra/timer-t3.c
arch/arm/mach-tegra/timer.c
arch/arm/mach-tegra/timer.h
arch/arm/mach-tegra/timerinfo.c
arch/arm/mm/cache-l2x0.c
arch/arm/mm/proc-v7.S
arch/x86/kernel/process.c
drivers/base/power/wakeup.c
drivers/bluetooth/hci_ldisc.c
drivers/gpio/gpio-tegra.c
drivers/hid/hid-sony.c
drivers/iio/magnetometer/ak8975.c
drivers/mfd/Makefile
drivers/mfd/max8907c.c
drivers/misc/tegra-cryptodev.c
drivers/misc/tegra-cryptodev.h
drivers/mmc/core/sdio.c
drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
drivers/net/ppp/Makefile
drivers/net/usb/raw_ip_net.c
drivers/net/wireless/ath/ath9k/ar9003_phy.c
drivers/tty/serial/8250/8250_core.c
drivers/usb/class/cdc-acm.c
drivers/usb/host/Kconfig
drivers/usb/host/ehci.h
include/linux/input/tegra_kbc.h
include/linux/mfd/tps65910.h
include/linux/platform_data/tegra30_emc.h [deleted file]
include/linux/platform_data/tegra_emc.h
include/linux/platform_data/tegra_usb.h
include/linux/pm_qos.h
kernel/power/Kconfig
kernel/time/timekeeping.c
net/Kconfig
net/ipv4/netfilter/Kconfig
sound/pci/hda/hda_intel.c

index 0704064..290d29e 100644 (file)
@@ -19,9 +19,6 @@ obj-y                                   += timer-t2.o
 else
 ifeq ($(CONFIG_ARCH_TEGRA_3x_SOC),y)
 obj-y                                   += timer-t3.o
-else
-obj-y                                   += tegra11_clocks.o
-endif
 endif
 obj-y                                   += pinmux.o
 obj-y                                   += delay.o
@@ -29,29 +26,14 @@ obj-y                                   += pm.o
 obj-$(CONFIG_TEGRA_WDT_RECOVERY)        += wdt-recovery.o
 obj-$(CONFIG_PM_SLEEP)                  += pm-irq.o
 obj-y                                   += gic.o
+obj-$(CONFIG_ARCH_TEGRA_2x_SOC)         += sleep-t2.o
 obj-y                                   += tegra_fuse.o
 obj-y                                   += kfuse.o
 obj-y                                   += csi.o
 obj-$(CONFIG_TEGRA_SILICON_PLATFORM)    += tegra_odm_fuses.o
-obj-y                                   += pmc.o
-obj-y                                   += flowctrl.o
 obj-y                                   += powergate.o
 obj-y                                   += apbio.o
-ifeq ($(CONFIG_CPU_IDLE),y)
-obj-y                                   += cpuidle.o
-ifeq ($(CONFIG_PM_SLEEP),y)
-obj-$(CONFIG_ARCH_TEGRA_2x_SOC)         += cpuidle-t2.o
-obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += cpuidle-t3.o
-endif
-endif
-ifeq ($(CONFIG_TEGRA_THERMAL_THROTTLE),y)
-obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += tegra3_throttle.o
-endif
-obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += tegra3_thermal.o
-obj-y                                   += sleep.o
-obj-$(CONFIG_ARCH_TEGRA_2x_SOC)         += sleep-t2.o
 obj-y                                   += mc.o
-obj-$(CONFIG_USB_SUPPORT)               += usb_phy.o
 obj-$(CONFIG_USB_SUPPORT)               += tegra3_usb_phy.o
 obj-$(CONFIG_USB_SUPPORT)               += tegra2_usb_phy.o
 obj-$(CONFIG_FIQ)                       += fiq.o
@@ -80,15 +62,30 @@ obj-$(CONFIG_ARCH_TEGRA_11x_SOC)        += pinmux-t11-tables.o
 obj-$(CONFIG_ARCH_TEGRA_2x_SOC)                += tegra20_speedo.o
 obj-$(CONFIG_ARCH_TEGRA_3x_SOC)                += tegra30_speedo.o
 obj-$(CONFIG_ARCH_TEGRA_3x_SOC)                += sleep-t30.o
+obj-$(CONFIG_HOTPLUG_CPU)               += hotplug.o
+obj-y                                  += pmc.o
+obj-y                                  += flowctrl.o
+obj-$(CONFIG_CPU_IDLE)                 += cpuidle.o
+obj-$(CONFIG_CPU_IDLE)                 += sleep.o
+obj-$(CONFIG_ARCH_TEGRA_11x_SOC)        += tegra11_clocks.o
 obj-$(CONFIG_SMP)                       += platsmp.o
 obj-y                                   += reset.o
 obj-y                                   += headsmp.o
-obj-$(CONFIG_HOTPLUG_CPU)               += hotplug.o
 obj-$(CONFIG_CPU_FREQ)                  += cpu-tegra.o
 ifeq ($(CONFIG_TEGRA_AUTO_HOTPLUG),y)
 obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += cpu-tegra3.o
 endif
 obj-$(CONFIG_TEGRA_PCI)                 += pcie.o
+ifeq ($(CONFIG_CPU_IDLE),y)
+ifeq ($(CONFIG_PM_SLEEP),y)
+obj-$(CONFIG_ARCH_TEGRA_2x_SOC)         += cpuidle-t2.o
+obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += cpuidle-t3.o
+endif
+endif
+ifeq ($(CONFIG_TEGRA_THERMAL_THROTTLE),y)
+obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += tegra3_throttle.o
+endif
+obj-$(CONFIG_ARCH_TEGRA_3x_SOC)         += tegra3_thermal.o
 obj-$(CONFIG_DEBUG_ICEDCC)              += sysfs-dcc.o
 obj-$(CONFIG_TEGRA_CLUSTER_CONTROL)     += sysfs-cluster.o
 obj-$(CONFIG_SENSORS_TEGRA_TSENSOR)     += tegra3_tsensor.o
index 31d584f..5909d29 100644 (file)
@@ -22,9 +22,6 @@
 
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-
-#include <asm/system_info.h>
-
 #include "board.h"
 
 /* skuinfo is 18 character long xxx-xxxxx-xxxx-xxx
@@ -39,6 +36,9 @@
 /* prodver is 2 character long XX so buffer size is set to 2+1 */
 #define PRODVER_BUF_SIZE 3
 
+extern unsigned int system_serial_low;
+extern unsigned int system_serial_high;
+
 static unsigned int board_serial_low;
 static unsigned int board_serial_high;
 static char prodinfo_buffer[PRODINFO_BUF_SIZE];
index 3250c7f..6fd9f0f 100644 (file)
@@ -222,15 +222,15 @@ int __init touch_init_raydium(int irq_gpio, int reset_gpio, int platform)
        switch (platform) {
        case 0:
                pr_info("Raydium Kai PCB based touch init\n");
-               rm31080ts_data.config = rm31080_config_kai_pcb;
+               rm31080ts_data.config = (char *) rm31080_config_kai_pcb;
                break;
        case 1:
                pr_info("Raydium Kai On-Board touch init\n");
-               rm31080ts_data.config = rm31080_config_kai_mainboard;
+               rm31080ts_data.config = (char *) rm31080_config_kai_mainboard;
                break;
        case 2:
                pr_info("Raydium cardhu touch init\n");
-               rm31080ts_data.config = rm31080_config_cardhu;
+               rm31080ts_data.config = (char *) rm31080_config_cardhu;
                break;
        default:
                pr_err("touch_id error, no touch\n");
index 8b2a51a..ab6ca53 100644 (file)
@@ -24,6 +24,7 @@
 
 #include <linux/types.h>
 #include <linux/power_supply.h>
+#include <linux/memory.h>
 
 #define ADD_FIXED_VOLTAGE_REG(_name)   (&_name##_fixed_voltage_device)
 
index c73546e..e8668ed 100644 (file)
@@ -657,28 +657,6 @@ void tegra_periph_reset_assert(struct clk *c)
 }
 EXPORT_SYMBOL(tegra_periph_reset_assert);
 
-/* Several extended clock configuration bits (e.g., clock routing, clock
- * phase control) are included in PLL and peripheral clock source
- * registers. */
-int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
-{
-       int ret = 0;
-       unsigned long flags;
-
-       spin_lock_irqsave(&c->spinlock, flags);
-
-       if (!c->ops || !c->ops->clk_cfg_ex) {
-               ret = -ENOSYS;
-               goto out;
-       }
-       ret = c->ops->clk_cfg_ex(c, p, setting);
-
-out:
-       spin_unlock_irqrestore(&c->spinlock, flags);
-
-       return ret;
-}
-
 int tegra_is_clk_enabled(struct clk *c)
 {
        return c->refcnt;
@@ -802,6 +780,27 @@ static int __init tegra_init_disable_boot_clocks(void)
 }
 late_initcall(tegra_init_disable_boot_clocks);
 
+/* Several extended clock configuration bits (e.g., clock routing, clock
+ * phase control) are included in PLL and peripheral clock source
+ * registers. */
+int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
+{
+       int ret = 0;
+       unsigned long flags;
+
+       spin_lock_irqsave(&c->spinlock, flags);
+
+       if (!c->ops || !c->ops->clk_cfg_ex) {
+               ret = -ENOSYS;
+               goto out;
+       }
+       ret = c->ops->clk_cfg_ex(c, p, setting);
+
+out:
+       spin_unlock_irqrestore(&c->spinlock, flags);
+       return ret;
+}
+
 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb)
 {
        int ret;
index 4687b45..92b03ea 100644 (file)
 #ifndef __MACH_TEGRA_CLOCK_H
 #define __MACH_TEGRA_CLOCK_H
 
+#ifndef __ASSEMBLY__
+
+#include <linux/clk-provider.h>
+#include <linux/clkdev.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/clk/tegra.h>
+#include <asm/cputime.h>
+
+#define MAX_SAME_LIMIT_SKU_IDS 16
+
+struct clk;
+
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
 #define USE_PLL_LOCK_BITS 0    /* Never use lock bits on Tegra2 */
 #else
@@ -31,8 +45,6 @@
 #define PLL_POST_LOCK_DELAY 50 /* Safety delay after lock is detected */
 #endif
 
-#include <linux/clk/tegra.h>
-
 #define DIV_BUS                        (1 << 0)
 #define DIV_U71                        (1 << 1)
 #define DIV_U71_FIXED          (1 << 2)
 #define PERIPH_MANUAL_RESET    (1 << 12)
 #define PLL_ALT_MISC_REG       (1 << 13)
 #define PLLU                   (1 << 14)
-#define PLLX                    (1 << 15)
-#define MUX_PWM                 (1 << 16)
-#define MUX8                    (1 << 17)
-#define DIV_U151_UART           (1 << 18)
-#define MUX_CLK_OUT             (1 << 19)
-#define PLLM                    (1 << 20)
-#define DIV_U71_INT             (1 << 21)
-#define DIV_U71_IDLE            (1 << 22)
+#define PLLX                   (1 << 15)
+#define MUX_PWM                        (1 << 16)
+#define MUX8                   (1 << 17)
+#define DIV_U151_UART          (1 << 18)
+#define MUX_CLK_OUT            (1 << 19)
+#define PLLM                   (1 << 20)
+#define DIV_U71_INT            (1 << 21)
+#define DIV_U71_IDLE           (1 << 22)
 #define DIV_U151               (1 << 23)
 #define ENABLE_ON_INIT         (1 << 28)
-#define PERIPH_ON_APB           (1 << 29)
+#define PERIPH_ON_APB          (1 << 29)
 #define PERIPH_ON_CBUS         (1 << 30)
 
-#ifndef __ASSEMBLY__
-
-#include <linux/clk-provider.h>
-#include <linux/clkdev.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/spinlock.h>
-#include <asm/cputime.h>
-
-#define MAX_SAME_LIMIT_SKU_IDS 16
-
-struct clk;
-
 #ifdef CONFIG_COMMON_CLK
 struct clk_tegra;
 #define to_clk_tegra(_hw) container_of(_hw, struct clk_tegra, hw)
@@ -108,9 +107,9 @@ struct clk_ops {
        int             (*set_rate)(struct clk *, unsigned long);
        long            (*round_rate)(struct clk *, unsigned long);
        void            (*reset)(struct clk *, bool);
+       int             (*shared_bus_update)(struct clk *);
        int             (*clk_cfg_ex)(struct clk *,
                                enum tegra_clk_ex_param, u32);
-       int             (*shared_bus_update)(struct clk *);
 };
 
 struct clk_stats {
index 8267529..da34569 100644 (file)
@@ -19,6 +19,7 @@
  */
 
 #include <linux/platform_device.h>
+#include <linux/console.h>
 #include <linux/init.h>
 #include <linux/io.h>
 #include <linux/clk.h>
 #include <linux/sched.h>
 
 #include <asm/hardware/cache-l2x0.h>
-#include <asm/system_info.h>
+#include <asm/system.h>
 
+#include <mach/hardware.h>
 #include <mach/powergate.h>
 #include <mach/tegra_smmu.h>
+#include <mach/gpio-tegra.h>
 
+#include "apbio.h"
 #include "board.h"
 #include "common.h"
 #include "dvfs.h"
 #include "fuse.h"
 #include "iomap.h"
 #include "pm.h"
-#include "pmc.h"
-#include "apbio.h"
 #include "sleep.h"
 #include "reset.h"
 #include "devices.h"
+#include "pmc.h"
 
 #define MC_SECURITY_CFG2       0x7c
 
@@ -167,7 +170,7 @@ void tegra_assert_system_reset(char mode, const char *cmd)
 #endif
 }
 static int modem_id;
-int tegra_sku_override;
+static int sku_override;
 static int debug_uart_port_id;
 static enum audio_codec_type audio_codec_name;
 static enum image_type board_image_type = system_image;
@@ -248,10 +251,13 @@ static void tegra_l2x0_disable(void)
 void tegra_init_cache(bool init)
 {
        void __iomem *p = IO_ADDRESS(TEGRA_ARM_PERIF_BASE) + 0x3000;
-       u32 aux_ctrl, cache_type;
+       u32 aux_ctrl;
+#ifndef CONFIG_TRUSTED_FOUNDATIONS
+       u32 cache_type;
        u32 tag_latency, data_latency;
        u32 speedo;
        u32 tmp;
+#endif
 
 #ifdef CONFIG_TRUSTED_FOUNDATIONS
        /* issue the SMC to enable the L2 */
@@ -274,8 +280,10 @@ void tegra_init_cache(bool init)
                tag_latency = 0x221;
                data_latency = 0x221;
        } else {
+               u32 speedo;
+
                /* relax l2-cache latency for speedos 4,5,6 (T33's chips) */
-               speedo = tegra_cpu_speedo_id;
+               speedo = tegra_cpu_speedo_id();
                if (speedo == 4 || speedo == 5 || speedo == 6 ||
                    speedo == 12 || speedo == 13) {
                        tag_latency = 0x442;
@@ -297,7 +305,7 @@ void tegra_init_cache(bool init)
 #ifndef CONFIG_TEGRA_FPGA_PLATFORM
        writel(7, p + L2X0_PREFETCH_CTRL);
        writel(2, p + L2X0_POWER_CTRL);
-#endif 
+#endif
 #endif
 
        writel(0x3, p + L2X0_POWER_CTRL);
@@ -307,6 +315,8 @@ void tegra_init_cache(bool init)
        if (init) {
                l2x0_init(p, aux_ctrl, 0x8200c3fe);
        } else {
+               u32 tmp;
+
                tmp = aux_ctrl;
                aux_ctrl = readl(p + L2X0_AUX_CTRL);
                aux_ctrl &= 0x8200c3fe;
@@ -401,6 +411,7 @@ void __init tegra20_init_early(void)
        tegra_init_power();
        tegra_init_ahb_gizmo_settings();
        tegra_init_debug_uart_rate();
+       tegra_gpio_resume_init();
 }
 #endif
 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
@@ -421,6 +432,7 @@ void __init tegra30_init_early(void)
        tegra_init_power();
        tegra_init_ahb_gizmo_settings();
        tegra_init_debug_uart_rate();
+       tegra_gpio_resume_init();
 }
 #endif
 
@@ -455,15 +467,20 @@ static int __init tegra_bootloader_fb_arg(char *options)
 }
 early_param("tegra_fbmem", tegra_bootloader_fb_arg);
 
-static int __init tegra_init_sku_override(char *id)
+static int __init tegra_sku_override(char *id)
 {
        char *p = id;
 
-       tegra_sku_override = memparse(p, &p);
+       sku_override = memparse(p, &p);
 
        return 0;
 }
-early_param("sku_override", tegra_init_sku_override);
+early_param("sku_override", tegra_sku_override);
+
+int tegra_get_sku_override(void)
+{
+       return sku_override;
+}
 
 static int __init tegra_vpr_arg(char *options)
 {
index f76dcfe..73ab9ff 100644 (file)
@@ -46,7 +46,6 @@
 #include <mach/irqs.h>
 
 #include "cpuidle.h"
-#include "flowctrl.h"
 #include "gic.h"
 #include "pm.h"
 #include "sleep.h"
@@ -121,7 +120,7 @@ static void tegra2_wake_reset_cpu(int cpu)
               CLK_RST_CONTROLLER_RST_CPU_CMPLX_CLR);
 
        /* unhalt the cpu */
-       flowctrl_write_cpu_halt(1, 0);
+       flowctrl_writel(0, FLOW_CTRL_HALT_CPU(1));
 
        tegra_pen_unlock();
 }
index 2cfa129..723564e 100644 (file)
@@ -37,9 +37,9 @@
 #include <linux/smp.h>
 #include <linux/suspend.h>
 #include <linux/tick.h>
-#include <linux/cpu_pm.h>
 #include <linux/clk.h>
-#include <linux/moduleparam.h>
+#include <linux/cpu_pm.h>
+#include <linux/module.h>
 
 #include <asm/cacheflush.h>
 #include <asm/hardware/gic.h>
@@ -49,6 +49,7 @@
 
 #include <mach/iomap.h>
 #include <mach/irqs.h>
+#include <mach/hardware.h>
 
 #include <trace/events/power.h>
 
@@ -61,6 +62,7 @@
 #include "reset.h"
 #include "sleep.h"
 #include "timer.h"
+#include "fuse.h"
 
 #define CLK_RST_CONTROLLER_CPU_CMPLX_STATUS \
        (IO_ADDRESS(TEGRA_CLK_RESET_BASE) + 0x470)
@@ -346,6 +348,7 @@ static bool tegra3_idle_enter_lp2_cpu_n(struct cpuidle_device *dev,
        struct tegra_twd_context twd_context;
        bool sleep_completed = false;
        struct tick_sched *ts = tick_get_tick_sched(dev->cpu);
+       void __iomem *twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
 
        if (!tegra_twd_get_state(&twd_context)) {
                unsigned long twd_rate = clk_get_rate(twd_clk);
index c59e6c9..3a19041 100644 (file)
@@ -22,7 +22,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/cpu.h>
 #include <linux/cpuidle.h>
 #include <linux/debugfs.h>
@@ -37,6 +36,9 @@
 #include <linux/smp.h>
 #include <linux/suspend.h>
 #include <linux/tick.h>
+#include <linux/cpu_pm.h>
+#include <linux/module.h>
+#include <linux/hrtimer.h>
 
 #include <asm/proc-fns.h>
 
 #include "pm.h"
 #include "sleep.h"
 
-static int tegra_idle_enter_lp3(struct cpuidle_device *dev, int index);
-#ifdef CONFIG_PM_SLEEP
-static int tegra_idle_enter_lp2(struct cpuidle_device *dev, int index);
-#endif
-
 int tegra_lp2_exit_latency;
 static int tegra_lp2_power_off_time;
 static unsigned int tegra_lp2_min_residency;
 
+static int tegra_idle_enter_lp3(struct cpuidle_device *dev,
+                               int index);
+
 struct cpuidle_driver tegra_idle_driver = {
        .name = "tegra_idle",
        .owner = THIS_MODULE,
 };
 
-static struct cpuidle_state tegra_cpuidle_states[] = {
-       [0] = {
-               .enter                  = tegra_idle_enter_lp3,
-               .exit_latency           = 10,
-               .target_residency       = 10,
-               .power_usage            = 600,
-               .flags                  = CPUIDLE_FLAG_TIME_VALID,
-               .name                   = "LP3",
-               .desc                   = "CPU flow-controlled",
-       },
-#ifdef CONFIG_PM_SLEEP
-       [1] = {
-               .enter                  = tegra_idle_enter_lp2,
-               .power_usage            = 0,
-               .flags                  = CPUIDLE_FLAG_TIME_VALID,
-               .name                   = "LP2",
-               .desc                   = "CPU power-gate",
-       },
-#endif
-};
-
-static DEFINE_PER_CPU(struct cpuidle_device, tegra_idle_device);
+static DEFINE_PER_CPU(struct cpuidle_device *, tegra_idle_device);
 
 static int tegra_idle_enter_lp3(struct cpuidle_device *dev,
        int index)
@@ -107,7 +86,6 @@ static int tegra_idle_enter_lp3(struct cpuidle_device *dev,
        local_irq_enable();
 
        dev->last_residency = us;
-
        return index;
 }
 
@@ -173,12 +151,59 @@ static int tegra_idle_enter_lp2(struct cpuidle_device *dev,
        }
        tegra_cpu_idle_stats_lp2_time(dev->cpu, us);
 
-       dev->last_residency = us;
-
-       return index;
+       dev->last_residency = (int)us;
+       return (entered_lp2) ? index : 0;
 }
 #endif
 
+static int tegra_cpuidle_register_device(unsigned int cpu)
+{
+       struct cpuidle_device *dev;
+       struct cpuidle_state *state;
+
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+       if (!dev)
+               return -ENOMEM;
+
+       dev->state_count = 0;
+       dev->cpu = cpu;
+
+       state = &dev->states[0];
+       snprintf(state->name, CPUIDLE_NAME_LEN, "LP3");
+       snprintf(state->desc, CPUIDLE_DESC_LEN, "CPU flow-controlled");
+       state->exit_latency = 10;
+       state->target_residency = 10;
+       state->power_usage = 600;
+       state->flags = CPUIDLE_FLAG_TIME_VALID;
+       state->enter = tegra_idle_enter_lp3;
+       dev->safe_state_index = 0;
+       dev->state_count++;
+
+#ifdef CONFIG_PM_SLEEP
+       state = &dev->states[1];
+       snprintf(state->name, CPUIDLE_NAME_LEN, "LP2");
+       snprintf(state->desc, CPUIDLE_DESC_LEN, "CPU power-gate");
+       state->exit_latency = tegra_cpu_power_good_time();
+       state->target_residency = tegra_cpu_power_off_time() +
+               tegra_cpu_power_good_time();
+       if (state->target_residency < tegra_lp2_min_residency)
+               state->target_residency = tegra_lp2_min_residency;
+       state->power_usage = 0;
+       state->flags = CPUIDLE_FLAG_TIME_VALID;
+       state->enter = tegra_idle_enter_lp2;
+       dev->power_specified = 1;
+       dev->state_count++;
+#endif
+
+       if (cpuidle_register_device(dev)) {
+               pr_err("CPU%u: failed to register idle device\n", cpu);
+               kfree(dev);
+               return -EIO;
+       }
+       per_cpu(tegra_idle_device, cpu) = dev;
+       return 0;
+}
+
 static int tegra_cpuidle_pm_notify(struct notifier_block *nb,
        unsigned long event, void *dummy)
 {
@@ -198,10 +223,14 @@ static struct notifier_block tegra_cpuidle_pm_notifier = {
 
 static int __init tegra_cpuidle_init(void)
 {
-       int ret;
        unsigned int cpu;
-       struct cpuidle_device *dev;
-       struct cpuidle_driver *drv = &tegra_idle_driver;
+       int ret;
+
+       ret = cpuidle_register_driver(&tegra_idle_driver);
+       if (ret) {
+               pr_err("CPUidle driver registration failed\n");
+               return ret;
+       }
 
 #ifdef CONFIG_PM_SLEEP
        tegra_lp2_min_residency = tegra_cpu_lp2_min_residency();
@@ -211,44 +240,29 @@ static int __init tegra_cpuidle_init(void)
        ret = tegra_cpudile_init_soc();
        if (ret)
                return ret;
-
-       tegra_cpuidle_states[1].exit_latency = tegra_cpu_power_good_time();
-       tegra_cpuidle_states[1].target_residency = tegra_cpu_power_off_time() +
-               tegra_cpu_power_good_time();
-       if (tegra_cpuidle_states[1].target_residency < tegra_lp2_min_residency)
-               tegra_cpuidle_states[1].target_residency = tegra_lp2_min_residency;
 #endif
-       
-       ret = cpuidle_register_driver(&tegra_idle_driver);
-       if (ret) {
-               pr_err("CPUidle driver registration failed\n");
-               return ret;
-       }
 
        for_each_possible_cpu(cpu) {
-               dev = &per_cpu(tegra_idle_device, cpu);
-               dev->cpu = cpu;
-
-               memcpy(&dev->states, tegra_cpuidle_states,
-                       ARRAY_SIZE(tegra_cpuidle_states) *
-                          sizeof(*tegra_cpuidle_states));
-
-               dev->state_count = ARRAY_SIZE(tegra_cpuidle_states);
-               dev->safe_state_index = 0;
-               dev->power_specified = 1;
-               ret = cpuidle_register_device(dev);
+               ret = tegra_cpuidle_register_device(cpu);
                if (ret) {
                        pr_err("CPU%u: CPUidle device registration failed\n",
                                cpu);
                        return ret;
                }
        }
-       register_pm_notifier(&tegra_cpuidle_pm_notifier);
 
+       register_pm_notifier(&tegra_cpuidle_pm_notifier);
        return 0;
 }
 device_initcall(tegra_cpuidle_init);
 
+static void __exit tegra_cpuidle_exit(void)
+{
+       unregister_pm_notifier(&tegra_cpuidle_pm_notifier);
+       cpuidle_unregister_driver(&tegra_idle_driver);
+}
+module_exit(tegra_cpuidle_exit);
+
 static int lp2_in_idle_set(const char *arg, const struct kernel_param *kp)
 {
 #ifdef CONFIG_PM_SLEEP
index ae56db5..f38e168 100644 (file)
@@ -24,6 +24,7 @@
 #include <linux/fsl_devices.h>
 #include <linux/serial_8250.h>
 #include <linux/i2c-tegra.h>
+#include <linux/platform_data/tegra_usb.h>
 #include <linux/tegra_avp.h>
 #include <linux/nvhost.h>
 #include <linux/clk.h>
 #define TEGRA_DMA_REQ_SEL_SPI                  11
 #define TEGRA_DMA_REQ_SEL_DTV                  TEGRA_DMA_REQ_SEL_SPI
 
+static struct resource emc_resource[] = {
+       [0] = {
+               .start  = TEGRA_EMC_BASE,
+               .end    = TEGRA_EMC_BASE + TEGRA_EMC_SIZE-1,
+               .flags  = IORESOURCE_MEM,
+       }
+};
+
+struct platform_device tegra_emc_device = {
+       .name           = "tegra-emc",
+       .id             = -1,
+       .resource       = emc_resource,
+       .num_resources  = ARRAY_SIZE(emc_resource),
+};
+
 static struct resource gpio_resource[] = {
        [0] = {
                .start  = TEGRA_GPIO_BASE,
@@ -1727,28 +1743,6 @@ struct platform_device tegra_nvmap_device = {
        .id     = -1,
 };
 
-static struct resource tegra30_emc_resources[] = {
-       {
-               .name   = "emcregs",
-               .start  = TEGRA_EMC_BASE,
-               .end    = TEGRA_EMC_BASE + TEGRA_EMC_SIZE-1,
-               .flags  = IORESOURCE_MEM,
-       },
-       {
-               .name   = "mcregs",
-               .start  = TEGRA_MC_BASE,
-               .end    = TEGRA_MC_BASE + TEGRA_MC_SIZE-1,
-               .flags  = IORESOURCE_MEM,
-       },
-};
-
-struct platform_device tegra30_emc_device = {
-       .name           = "tegra30-emc",
-       .id             = -1,
-       .resource       = tegra30_emc_resources,
-       .num_resources  = ARRAY_SIZE(tegra30_emc_resources),
-};
-
 void __init tegra_init_debug_uart_rate(void)
 {
        unsigned int uartclk;
index 47360a4..42e2c9e 100644 (file)
@@ -23,7 +23,9 @@
 
 #include <linux/platform_device.h>
 #include <linux/nvhost.h>
+#include <linux/platform_data/tegra_usb.h>
 
+extern struct platform_device tegra_emc_device;
 extern struct platform_device tegra_gpio_device;
 extern struct platform_device tegra_pinmux_device;
 extern struct platform_device tegra_sdhci_device1;
@@ -125,7 +127,6 @@ extern struct platform_device debug_uarte_device;
 
 extern struct nvhost_device tegra_disp1_device;
 extern struct platform_device tegra_nvmap_device;
-extern struct platform_device tegra30_emc_device;
 
 void __init tegra_init_debug_uart_rate(void);
 
index 52fb678..a4be48f 100644 (file)
@@ -322,7 +322,7 @@ static struct tegra_edp_limits edp_default_limits[] = {
  */
 void __init tegra_init_cpu_edp_limits(unsigned int regulator_mA)
 {
-       int cpu_speedo_id = tegra_cpu_speedo_id;
+       int cpu_speedo_id = tegra_cpu_speedo_id();
        int i, j;
        struct tegra_edp_limits *e;
        struct tegra_edp_entry *t = (struct tegra_edp_entry *)tegra_edp_map;
@@ -377,7 +377,7 @@ void __init tegra_init_cpu_edp_limits(unsigned int regulator_mA)
 
 void __init tegra_init_system_edp_limits(unsigned int power_limit_mW)
 {
-       int cpu_speedo_id = tegra_cpu_speedo_id;
+       int cpu_speedo_id = tegra_cpu_speedo_id();
        int i;
        unsigned int *e;
        struct system_edp_entry *t =
index d27a43e..ffaa286 100644 (file)
@@ -50,26 +50,11 @@ static void flowctrl_update(u8 offset, u32 value)
        readl_relaxed(addr);
 }
 
-static u32 flowctrl_readl(u8 offset)
-{
-       return readl(IO_ADDRESS(TEGRA_FLOW_CTRL_BASE) + offset);
-}
-
-u32 flowctrl_read_cpu_csr(unsigned int cpuid)
-{
-       return flowctrl_readl(flowctrl_offset_cpu_csr[cpuid]);
-}
-
 void flowctrl_write_cpu_csr(unsigned int cpuid, u32 value)
 {
        return flowctrl_update(flowctrl_offset_cpu_csr[cpuid], value);
 }
 
-u32 flowctrl_read_cpu_halt(unsigned int cpuid)
-{
-       return flowctrl_readl(flowctrl_offset_halt_cpu[cpuid]);
-}
-
 void flowctrl_write_cpu_halt(unsigned int cpuid, u32 value)
 {
        return flowctrl_update(flowctrl_offset_halt_cpu[cpuid], value);
index cc15333..1942817 100644 (file)
 #define __MACH_TEGRA_FLOWCTRL_H
 
 #define FLOW_CTRL_HALT_CPU0_EVENTS     0x0
-#define   FLOW_CTRL_WAITEVENT          (2 << 29)
-#define   FLOW_CTRL_WAIT_FOR_INTERRUPT (4 << 29)
-#define   FLOW_CTRL_JTAG_RESUME                (1 << 28)
-#define   FLOW_CTRL_HALT_CPU_IRQ       (1 << 10)
-#define          FLOW_CTRL_HALT_CPU_FIQ        (1 << 8)
+#define FLOW_CTRL_WAITEVENT            (2 << 29)
+#define FLOW_CTRL_WAIT_FOR_INTERRUPT   (4 << 29)
+#define FLOW_CTRL_JTAG_RESUME          (1 << 28)
+#define FLOW_CTRL_HALT_CPU_IRQ         (1 << 10)
+#define        FLOW_CTRL_HALT_CPU_FIQ          (1 << 8)
 #define FLOW_CTRL_CPU0_CSR             0x8
-#define          FLOW_CTRL_CSR_INTR_FLAG       (1 << 15)
-#define   FLOW_CTRL_CSR_EVENT_FLAG     (1 << 14)
-#define   FLOW_CTRL_CSR_IMMEDIATE_WAKE (1 << 3)
-#define   FLOW_CTRL_CSR_SWITCH_CLUSTER (1 << 2)
-#define   FLOW_CTRL_CSR_ENABLE         (1 << 0)
+#define        FLOW_CTRL_CSR_INTR_FLAG         (1 << 15)
+#define FLOW_CTRL_CSR_EVENT_FLAG       (1 << 14)
+#define FLOW_CTRL_CSR_ENABLE           (1 << 0)
 #define FLOW_CTRL_HALT_CPU1_EVENTS     0x14
 #define FLOW_CTRL_CPU1_CSR             0x18
 
-#ifdef CONFIG_ARCH_TEGRA_2x_SOC
-#define FLOW_CTRL_CSR_WFE_CPU0         (1 << 4)
-#define FLOW_CTRL_CSR_WFE_BITMAP       (3 << 4)
-#define FLOW_CTRL_CSR_WFI_BITMAP       0
-#else
-#define FLOW_CTRL_CSR_WFE_BITMAP       (0xF << 4)
-#define FLOW_CTRL_CSR_WFI_CPU0         (1 << 8)
-#define FLOW_CTRL_CSR_WFI_BITMAP       (0xF << 8)
-#endif
-
 #ifndef __ASSEMBLY__
-u32 flowctrl_read_cpu_csr(unsigned int cpuid);
 void flowctrl_write_cpu_csr(unsigned int cpuid, u32 value);
-u32 flowctrl_read_cpu_halt(unsigned int cpuid);
 void flowctrl_write_cpu_halt(unsigned int cpuid, u32 value);
 #endif
 
index dadc579..ad82faa 100644 (file)
 #include <linux/linkage.h>
 #include <linux/init.h>
 
+#include <asm/assembler.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 
 #include "flowctrl.h"
 #include "iomap.h"
-#include "reset.h"
 #include "sleep.h"
-
-#define DEBUG_CPU_RESET_HANDLER        0       /* Non-zero enables debug code */
+#include "reset.h"
 
 #define APB_MISC_GP_HIDREV     0x804
 #define PMC_SCRATCH41  0x140
 
+#define DEBUG_CPU_RESET_HANDLER        0       /* Non-zero enables debug code */
+
 #define RESET_DATA(x)  ((TEGRA_RESET_##x)*4)
 
         .section ".text.head", "ax"
        __CPUINIT
 
-/*
- *     __invalidate_cpu_state
- *
- *       Invalidates volatile CPU state (SCU tags, caches, branch address
- *       arrays, exclusive monitor, etc.) so that they can be safely enabled
- *       instruction caching and branch predicition enabled
- */
-__invalidate_cpu_state:
-       clrex
-       mov     r0, #0
-       mcr     p15, 0, r0, c1, c0, 1   @ disable SMP, prefetch, broadcast
-       isb
-       mcr     p15, 0, r0, c7, c5, 0   @ invalidate BTAC, i-cache
-       mcr     p15, 0, r0, c7, c5, 6   @ invalidate branch pred array
-       mcr     p15, 0, r0, c8, c7, 0   @ invalidate unified TLB
-       dsb
-       isb
-
-       cpu_id  r0
-       cmp     r0, #0
-       mov32   r1, (TEGRA_ARM_PERIF_BASE + 0xC)
-       movne   r0, r0, lsl #2
-       movne   r2, #0xf
-       movne   r2, r2, lsl r0
-       strne   r2, [r1]                @ invalidate SCU tags for CPU
-
-       dsb
-       mov     r0, #0x1800
-       mcr     p15, 0, r0, c1, c0, 0   @ enable branch prediction, i-cache
-       isb
-       /* fall through */
-
-/*
- *   The secondary kernel init calls v7_flush_dcache_all before it enables
- *   the L1; however, the L1 comes out of reset in an undefined state, so
- *   the clean + invalidate performed by v7_flush_dcache_all causes a bunch
- *   of cache lines with uninitialized data and uninitialized tags to get
- *   written out to memory, which does really unpleasant things to the main
- *   processor.  We fix this by performing an invalidate, rather than a
- *   clean + invalidate, before jumping into the kernel.
- */
-ENTRY(v7_invalidate_l1)
-        mov     r0, #0
-        mcr     p15, 2, r0, c0, c0, 0
-        mrc     p15, 1, r0, c0, c0, 0
-
-        ldr     r1, =0x7fff
-        and     r2, r1, r0, lsr #13
-
-        ldr     r1, =0x3ff
-
-        and     r3, r1, r0, lsr #3  @ NumWays - 1
-        add     r2, r2, #1          @ NumSets
-
-        and     r0, r0, #0x7
-        add     r0, r0, #4          @ SetShift
-
-        clz     r1, r3              @ WayShift
-        add     r4, r3, #1          @ NumWays
-1:      sub     r2, r2, #1          @ NumSets--
-        mov     r3, r4              @ Temp = NumWays
-2:      subs    r3, r3, #1          @ Temp--
-        mov     r5, r3, lsl r1
-        mov     r6, r2, lsl r0
-        orr     r5, r5, r6          @ Reg = (Temp<<WayShift)|(NumSets<<SetShift)
-        mcr     p15, 0, r5, c7, c6, 2
-        bgt     2b
-        cmp     r2, #0
-        bgt     1b
-        dsb
-        isb
-        mov     pc, lr
-ENDPROC(v7_invalidate_l1)
-
-
 #ifdef CONFIG_SMP
-/* 
+/*
  *     tegra_secondary_startup
  *
  *      Initial secondary processor boot vector; jumps to kernel's
@@ -125,7 +51,7 @@ ENDPROC(v7_invalidate_l1)
        __CPUINIT
 ENTRY(tegra_secondary_startup)
        bl      __invalidate_cpu_state
-        b       secondary_startup
+       b       secondary_startup
 ENDPROC(tegra_secondary_startup)
        .previous
 #endif
@@ -175,6 +101,84 @@ ENTRY(tegra_resume)
 ENDPROC(tegra_resume)
 #endif
 
+/*
+ *     __invalidate_cpu_state
+ *
+ *       Invalidates volatile CPU state (SCU tags, caches, branch address
+ *       arrays, exclusive monitor, etc.) so that they can be safely enabled
+ *       instruction caching and branch predicition enabled
+ */
+__invalidate_cpu_state:
+       clrex
+       mov     r0, #0
+       mcr     p15, 0, r0, c1, c0, 1   @ disable SMP, prefetch, broadcast
+       isb
+       mcr     p15, 0, r0, c7, c5, 0   @ invalidate BTAC, i-cache
+       mcr     p15, 0, r0, c7, c5, 6   @ invalidate branch pred array
+       mcr     p15, 0, r0, c8, c7, 0   @ invalidate unified TLB
+       dsb
+       isb
+
+       cpu_id  r0
+       cmp     r0, #0
+       mov32   r1, (TEGRA_ARM_PERIF_BASE + 0xC)
+       movne   r0, r0, lsl #2
+       movne   r2, #0xf
+       movne   r2, r2, lsl r0
+       strne   r2, [r1]                @ invalidate SCU tags for CPU
+
+       dsb
+       mov     r0, #0x1800
+       mcr     p15, 0, r0, c1, c0, 0   @ enable branch prediction, i-cache
+       isb
+       /* fall through */
+
+/*
+ *     tegra_invalidate_l1
+ *
+ *       Invalidates the L1 data cache (no clean) during initial boot of a cpu
+ *
+ *       Corrupted registers: r0-r6
+ */
+tegra_invalidate_l1:
+       mov     r0, #0
+       mcr     p15, 2, r0, c0, c0, 0
+       mrc     p15, 1, r0, c0, c0, 0
+
+       movw    r1, #0x7fff
+       and     r2, r1, r0, lsr #13
+
+       movw    r1, #0x3ff
+
+       and     r3, r1, r0, lsr #3      @ NumWays - 1
+       add     r2, r2, #1      @ NumSets
+
+       and     r0, r0, #0x7
+       add     r0, r0, #4      @ SetShift
+
+       clz     r1, r3          @ WayShift
+       add     r4, r3, #1      @ NumWays
+1:     sub     r2, r2, #1      @ NumSets--
+       mov     r3, r4          @ Temp = NumWays
+2:     subs    r3, r3, #1      @ Temp--
+       mov     r5, r3, lsl r1
+       mov     r6, r2, lsl r0
+       orr     r5, r5, r6      @ Reg = (Temp<<WayShift)|(NumSets<<SetShift)
+       mcr     p15, 0, r5, c7, c6, 2
+       bgt     2b
+       cmp     r2, #0
+       bgt     1b
+       dsb
+       isb
+       mov     pc, lr
+
+/*
+ * __tegra_cpu_reset_handler_halt_failed:
+ *
+ * Alternate entry point for reset handler for cases where the
+ * WFI halt failed to take effect.
+ *
+ */
        .align L1_CACHE_SHIFT
 ENTRY(__tegra_cpu_reset_handler_start)
 
@@ -233,18 +237,11 @@ ENTRY(__tegra_cpu_reset_handler)
 #endif
 
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
-       /* Are we on Tegra20? */
-       mov32   r6, TEGRA_APB_MISC_BASE
-       ldr     r0, [r6, #APB_MISC_GP_HIDREV]
-       and     r0, r0, #0xff00
-       cmp     r0, #(0x20 << 8)
-       bne     1f
-       /* If not CPU0, don't let CPU0 reset CPU1 now that CPU1 is coming up. */
+       /* If CPU1, don't let CPU0 reset CPU1 now that CPU1 is coming up. */
        mov32   r6, TEGRA_PMC_BASE
        mov     r0, #0
        cmp     r10, #0
        strne   r0, [r6, #PMC_SCRATCH41]
-1:
 #endif
 
 #ifdef CONFIG_PM_SLEEP
@@ -271,11 +268,10 @@ __is_not_lp1:
        bx      lr
 
 __is_not_lp2:
+
 #ifdef CONFIG_SMP
-       /*
-        * Can only be secondary boot (initial or hotplug) but CPU 0
-        * cannot be here.
-        */
+       /* Can only be secondary boot (initial or hotplug) but CPU 0
+          cannot be here. */
        cmp     r10, #0
        bleq    __die                           @ CPU0 cannot be here
        ldr     lr, [r12, #RESET_DATA(STARTUP_SECONDARY)]
@@ -352,6 +348,6 @@ __tegra_cpu_reset_handler_data:
        .rept   TEGRA_RESET_DATA_SIZE
        .long   0
        .endr
+       .size   __tegra_cpu_reset_handler_data, . - __tegra_cpu_reset_handler_data
        .align L1_CACHE_SHIFT
-
 ENTRY(__tegra_cpu_reset_handler_end)
index 4ff659e..9ebaea0 100644 (file)
@@ -35,5 +35,6 @@ struct gpio_init_pin_info {
 
 void tegra_gpio_init_configure(unsigned gpio, bool is_input, int value);
 void tegra_gpio_set_tristate(int gpio, enum tegra_tristate ts);
+int tegra_gpio_resume_init(void);
 
 #endif
index f939737..9b17d6a 100644 (file)
 #ifndef MACH_TEGRA_HARDWARE_H
 #define MACH_TEGRA_HARDWARE_H
 
+#if defined(CONFIG_ARCH_TEGRA_2x_SOC)
+#define pcibios_assign_all_busses()            1
+
+#else
+
+#define pcibios_assign_all_busses()            0
+#endif
+
+enum tegra_chipid {
+       TEGRA_CHIPID_UNKNOWN = 0,
+       TEGRA_CHIPID_TEGRA2 = 0x20,
+       TEGRA_CHIPID_TEGRA3 = 0x30,
+       TEGRA_CHIPID_TEGRA11 = 0x35,
+};
+
 enum tegra_revision {
        TEGRA_REVISION_UNKNOWN = 0,
        TEGRA_REVISION_A01,
@@ -31,12 +46,8 @@ enum tegra_revision {
        TEGRA_REVISION_MAX,
 };
 
-#define TEGRA20                0x20
-#define TEGRA30                0x30
-#define TEGRA11                0x35
-
-extern int tegra_chip_id;
 extern enum tegra_revision tegra_revision;
+enum tegra_chipid tegra_get_chipid(void);
 
 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
 void tegra_get_netlist_revision(u32 *netlist, u32* patchid);
index 05306d7..665b596 100644 (file)
 
 #define INT_GIC_NR                     (INT_QUINT_BASE + 32)
 
-/* Tegra30 has 5 banks of 32 IRQs */
-#define INT_MAIN_NR                    (32 * 5)
+#define INT_MAIN_NR                    (INT_GIC_NR - INT_PRI_BASE)
 
-#define INT_SYNCPT_THRESH_BASE         (INT_PRI_BASE + INT_MAIN_NR)
+#define INT_SYNCPT_THRESH_BASE         (INT_QUINT_BASE + 32)
 #define INT_SYNCPT_THRESH_NR           32
 
 #define INT_GPIO_BASE                  (INT_SYNCPT_THRESH_BASE + \
 
 #define INT_PCI_MSI_BASE               (INT_GPIO_BASE + \
                                         INT_GPIO_NR)
-#define INT_PCI_MSI_NR                 (0)
+#define INT_PCI_MSI_NR                 (32 * 8)
 
 #define FIQ_START                      INT_GIC_BASE
 
index 69fb0ef..8d0db3c 100644 (file)
 #ifndef _MACH_TEGRA_POWERGATE_H_
 #define _MACH_TEGRA_POWERGATE_H_
 
-#include <linux/init.h>
-
 #define TEGRA_POWERGATE_CPU    0
+#define TEGRA_POWERGATE_CPU0   TEGRA_POWERGATE_CPU
 #define TEGRA_POWERGATE_3D     1
+#define TEGRA_POWERGATE_3D0    TEGRA_POWERGATE_3D
 #define TEGRA_POWERGATE_VENC   2
 #define TEGRA_POWERGATE_PCIE   3
 #define TEGRA_POWERGATE_VDEC   4
 #define TEGRA_POWERGATE_CELP   12
 #define TEGRA_POWERGATE_3D1    13
 
-#define TEGRA_POWERGATE_CPU0   TEGRA_POWERGATE_CPU
-#define TEGRA_POWERGATE_3D0    TEGRA_POWERGATE_3D
+#if defined(CONFIG_ARCH_TEGRA_2x_SOC)
+#define TEGRA_NUM_POWERGATE    7
+#define TEGRA_CPU_POWERGATE_ID(cpu)    (TEGRA_POWERGATE_CPU)
+#define TEGRA_IS_CPU_POWERGATE_ID(id)  ((id) == TEGRA_POWERGATE_CPU)
+#else
+#define TEGRA_NUM_POWERGATE    14
+#define TEGRA_CPU_POWERGATE_ID(cpu)    ((cpu == 0) ? TEGRA_POWERGATE_CPU0 : \
+                                               (cpu + TEGRA_POWERGATE_CPU1 - 1))
+#define TEGRA_IS_CPU_POWERGATE_ID(id)  (((id) == TEGRA_POWERGATE_CPU0) || \
+                                       ((id) == TEGRA_POWERGATE_CPU1) || \
+                                       ((id) == TEGRA_POWERGATE_CPU2) || \
+                                       ((id) == TEGRA_POWERGATE_CPU3))
+#endif
 
 int  __init tegra_powergate_init(void);
 
 int tegra_cpu_powergate_id(int cpuid);
-int tegra_powergate_is_powered(int id);
+bool tegra_powergate_is_powered(int id);
+int tegra_powergate_power_on(int id);
+int tegra_powergate_power_off(int id);
 int tegra_powergate_mc_disable(int id);
 int tegra_powergate_mc_enable(int id);
 int tegra_powergate_mc_flush(int id);
index 6dc6bfc..873e984 100644 (file)
@@ -101,6 +101,15 @@ static inline void flush(void)
 {
 }
 
+static inline void konk_delay(int delay)
+{
+       int i;
+
+       for (i = 0; i < (1000 * delay); i++) {
+               barrier();
+       }
+}
+
 static const struct {
        u32 base;
        u32 reset_reg;
@@ -184,9 +193,8 @@ int auto_odmdata(void)
 static inline void arch_decomp_setup(void)
 {
        int uart_id;
-       volatile u32 *apb_misc = (volatile u32 *)TEGRA_APB_MISC_BASE;
        volatile u32 *addr;
-       u32 div = DEBUG_UART_DLL_216;
+       u32 uart_dll = DEBUG_UART_DLL_216;
        u32 val;
 
 #if defined(CONFIG_TEGRA_DEBUG_UART_AUTO_ODMDATA)
@@ -212,6 +220,22 @@ static inline void arch_decomp_setup(void)
        if (uart == NULL)
                return;
 
+       /* Debug UART clock source is PLLP_OUT0. */
+       addr = (volatile u32 *)DEBUG_UART_CLK_SRC;
+       *addr = 0;
+
+       /* Enable clock to debug UART. */
+       addr = (volatile u32 *)DEBUG_UART_CLK_ENB_SET_REG;
+       *addr = DEBUG_UART_CLK_ENB_SET_BIT;
+
+       konk_delay(5);
+
+       /* Deassert reset to debug UART. */
+       addr = (volatile u32 *)DEBUG_UART_RST_CLR_REG;
+       *addr = DEBUG_UART_RST_CLR_BIT;
+
+       konk_delay(5);
+
        /*
         * On Tegra2 platforms PLLP always run at 216MHz
         * On Tegra3 platforms PLLP can run at 216MHz, 204MHz, or 408MHz
@@ -227,11 +251,11 @@ static inline void arch_decomp_setup(void)
                switch (val) {
                case 170:
                case 204:
-                       div = DEBUG_UART_DLL_204;
+                       uart_dll = DEBUG_UART_DLL_204;
                        break;
                case 340:
                case 408:
-                       div = DEBUG_UART_DLL_408;
+                       uart_dll = DEBUG_UART_DLL_408;
                        break;
                case 180:
                case 216:
@@ -240,9 +264,10 @@ static inline void arch_decomp_setup(void)
                }
        }
 
+       /* Set up debug UART. */
        uart[UART_LCR << DEBUG_UART_SHIFT] |= UART_LCR_DLAB;
-       uart[UART_DLL << DEBUG_UART_SHIFT] = div & 0xff;
-       uart[UART_DLM << DEBUG_UART_SHIFT] = div >> 8;
+       uart[UART_DLL << DEBUG_UART_SHIFT] = uart_dll;
+       uart[UART_DLM << DEBUG_UART_SHIFT] = 0x0;
        uart[UART_LCR << DEBUG_UART_SHIFT] = 3;
 }
 
index 16783e3..1e70dec 100644 (file)
@@ -76,13 +76,13 @@ static struct map_desc tegra_io_desc[] __initdata = {
                .type = MT_DEVICE,
        },
        {
-               .virtual = (unsigned long)IO_PPCS_VIRT,
+               .virtual = IO_PPCS_VIRT,
                .pfn = __phys_to_pfn(IO_PPCS_PHYS),
                .length = IO_PPCS_SIZE,
                .type = MT_DEVICE,
        },
        {
-               .virtual = (unsigned long)IO_PCIE_VIRT,
+               .virtual = IO_PCIE_VIRT,
                .pfn = __phys_to_pfn(IO_PCIE_PHYS),
                .length = IO_PCIE_SIZE,
                .type = MT_DEVICE,
index ed08dc3..f3ac111 100644 (file)
  *
  */
 
-#define IO_IRAM_PHYS   0x40000000
-#define IO_IRAM_VIRT   IOMEM(0xFE400000)
-#define IO_IRAM_SIZE   SZ_256K
+#define IO_VIRT_BASE   0xFB000000
+
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+#define IO_PCIE_PHYS   0x80000000
+#else
+#define IO_PCIE_PHYS   0x00000000
+#endif
+#define IO_PCIE_VIRT   IOMEM(IO_VIRT_BASE)
+#define IO_PCIE_SIZE   (SZ_16M * 3)
 
 #define IO_CPU_PHYS    0x50000000
-#define IO_CPU_VIRT    IOMEM(0xFE000000)
+#define IO_CPU_VIRT    IOMEM(IO_PCIE_VIRT + IO_PCIE_SIZE)
 #define IO_CPU_SIZE    SZ_1M
 
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+#define IO_PPCS_PHYS   0xC4000000
+#else
+#define IO_PPCS_PHYS   0x7C000000
+#endif
+#define IO_PPCS_VIRT   IOMEM(IO_CPU_VIRT + IO_CPU_SIZE)
+#define IO_PPCS_SIZE   SZ_1M
+
 #define IO_PPSB_PHYS   0x60000000
-#define IO_PPSB_VIRT   IOMEM(0xFE200000)
+#define IO_PPSB_VIRT   IOMEM(IO_PPCS_VIRT + IO_PPCS_SIZE)
 #define IO_PPSB_SIZE   SZ_1M
 
 #define IO_APB_PHYS    0x70000000
-#define IO_APB_VIRT    IOMEM(0xFE300000)
+#define IO_APB_VIRT    IOMEM(IO_PPSB_VIRT + IO_PPSB_SIZE)
 #define IO_APB_SIZE    SZ_1M
 
+#define IO_IRAM_PHYS   0x40000000
+#define IO_IRAM_VIRT   IOMEM(IO_APB_VIRT + IO_APB_SIZE)
+#define IO_IRAM_SIZE   SZ_256K
+
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
 #define IO_USB_PHYS    0xC5000000
 #else
 #define IO_USB_PHYS    0x7D000000
 #endif
-#define IO_USB_VIRT    IOMEM(0xFE500000)
+#define IO_USB_VIRT    IOMEM(IO_IRAM_VIRT + IO_IRAM_SIZE)
 #define IO_USB_SIZE    SZ_1M
 
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
 #else
 #define IO_SDMMC_PHYS  0x78000000
 #endif
-#define IO_SDMMC_VIRT  IOMEM(0xFE600000)
+#define IO_SDMMC_VIRT  IOMEM(IO_USB_VIRT + IO_USB_SIZE)
 #define IO_SDMMC_SIZE  SZ_1M
 
 #define IO_HOST1X_PHYS 0x54000000
-#define IO_HOST1X_VIRT IOMEM(0xFE700000)
+#define IO_HOST1X_VIRT IOMEM(IO_SDMMC_VIRT + IO_SDMMC_SIZE)
 #define IO_HOST1X_SIZE SZ_8M
 
-#ifdef CONFIG_ARCH_TEGRA_2x_SOC
-#define IO_PPCS_PHYS   0xC4000000
-#else
-#define IO_PPCS_PHYS   0x7C000000
-#endif
-#define IO_PPCS_VIRT   IOMEM(0xFE100000)
-#define IO_PPCS_SIZE   SZ_1M
-
-#ifdef CONFIG_ARCH_TEGRA_2x_SOC
-#define IO_PCIE_PHYS   0x80000000
-#else
-#define IO_PCIE_PHYS   0x00000000
-#endif
-#define IO_PCIE_VIRT   IOMEM(0xFB0000000)
-#define IO_PCIE_SIZE   (SZ_16M * 3)
-
 #define IO_TO_VIRT_BETWEEN(p, st, sz)  ((p) >= (st) && (p) < ((st) + (sz)))
 #define IO_TO_VIRT_XLATE(p, pst, vst)  (((p) - (pst) + (vst)))
 
index f05fd07..d54e6c2 100644 (file)
 #define ICTLR_COP_IER_CLR      0x38
 #define ICTLR_COP_IEP_CLASS    0x3c
 
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+#define NUM_ICTLRS 4
+#else
+#define NUM_ICTLRS 5
+#endif
+
 #define FIRST_LEGACY_IRQ 32
 
 static int num_ictlrs;
@@ -56,13 +62,15 @@ static void __iomem *ictlr_reg_base[] = {
        IO_ADDRESS(TEGRA_SECONDARY_ICTLR_BASE),
        IO_ADDRESS(TEGRA_TERTIARY_ICTLR_BASE),
        IO_ADDRESS(TEGRA_QUATERNARY_ICTLR_BASE),
+#if (NUM_ICTLRS > 4)
        IO_ADDRESS(TEGRA_QUINARY_ICTLR_BASE),
+#endif
 };
 
 #ifdef CONFIG_PM_SLEEP
-static u32 cop_ier[ARRAY_SIZE(ictlr_reg_base)];
-static u32 cpu_ier[ARRAY_SIZE(ictlr_reg_base)];
-static u32 cpu_iep[ARRAY_SIZE(ictlr_reg_base)];
+static u32 cop_ier[NUM_ICTLRS];
+static u32 cpu_ier[NUM_ICTLRS];
+static u32 cpu_iep[NUM_ICTLRS];
 #endif
 
 static inline void tegra_irq_write_mask(unsigned int irq, unsigned long reg)
@@ -143,7 +151,7 @@ static int tegra_legacy_irq_suspend(void)
        int i;
 
        local_irq_save(flags);
-       for (i = 0; i < num_ictlrs; i++) {
+       for (i = 0; i < NUM_ICTLRS; i++) {
                void __iomem *ictlr = ictlr_reg_base[i];
                cpu_ier[i] = readl(ictlr + ICTLR_CPU_IER);
                cpu_iep[i] = readl(ictlr + ICTLR_CPU_IEP_CLASS);
@@ -161,7 +169,7 @@ static void tegra_legacy_irq_resume(void)
        int i;
 
        local_irq_save(flags);
-       for (i = 0; i < num_ictlrs; i++) {
+       for (i = 0; i < NUM_ICTLRS; i++) {
                void __iomem *ictlr = ictlr_reg_base[i];
                writel(cpu_iep[i], ictlr + ICTLR_CPU_IEP_CLASS);
                writel(~0ul, ictlr + ICTLR_CPU_IER_CLR);
@@ -224,14 +232,15 @@ void __init tegra_init_irq(void)
         * initialized elsewhere under DT.
         */
        if (!of_have_populated_dt())
-               tegra_gic_init();
+               gic_init(0, 29, distbase,
+                       IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x100));
 }
 
 void tegra_init_legacy_irq_cop(void)
 {
        int i;
 
-       for (i = 0; i < num_ictlrs; i++) {
+       for (i = 0; i < NUM_ICTLRS; i++) {
                void __iomem *ictlr = ictlr_reg_base[i];
                writel(~0, ictlr + ICTLR_COP_IER_CLR);
                writel(0, ictlr + ICTLR_COP_IEP_CLASS);
index be329e5..39d5ce9 100644 (file)
@@ -27,6 +27,7 @@
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/syscore_ops.h>
+#include <linux/bug.h>
 
 #include <mach/pinmux.h>
 #include <mach/pinmux-tegra20.h>
index 0c6a2f0..7a1fb16 100644 (file)
  * published by the Free Software Foundation.
  */
 
+#include <linux/kernel.h>
 #include <linux/init.h>
-#include <linux/errno.h>
-#include <linux/delay.h>
-#include <linux/device.h>
-#include <linux/jiffies.h>
-#include <linux/smp.h>
 #include <linux/io.h>
+#include <linux/smp.h>
+#include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/clk/tegra.h>
 #include <linux/cpumask.h>
@@ -34,6 +32,7 @@
 #include "reset.h"
 #include "pm.h"
 #include "clock.h"
+#include "sleep.h"
 
 #include "common.h"
 #include "iomap.h"
@@ -94,6 +93,14 @@ static int is_g_cluster_available(unsigned int cpu)
 #endif
 }
 
+static bool is_cpu_powered(unsigned int cpu)
+{
+       if (is_lp_cluster())
+               return true;
+       else
+               return tegra_powergate_is_powered(TEGRA_CPU_POWERGATE_ID(cpu));
+}
+
 static void __cpuinit tegra_secondary_init(unsigned int cpu)
 {
        cpumask_set_cpu(cpu, to_cpumask(tegra_cpu_init_bits));
@@ -104,7 +111,6 @@ static void __cpuinit tegra_secondary_init(unsigned int cpu)
 
 static int tegra20_power_up_cpu(unsigned int cpu)
 {
-       int status;
 
        /* Enable the CPU clock. */
        tegra_enable_cpu_clock(cpu);
@@ -117,15 +123,12 @@ static int tegra20_power_up_cpu(unsigned int cpu)
 
 static int tegra30_power_up_cpu(unsigned int cpu)
 {
-       int ret, pwrgateid;
+       int ret;
        unsigned long timeout;
 
+       BUG_ON(cpu == smp_processor_id());
        BUG_ON(is_lp_cluster());
 
-       pwrgateid = tegra_cpu_powergate_id(cpu);
-       if (pwrgateid < 0)
-               return pwrgateid;
-
        /* If this cpu has booted this function is entered after
         * CPU has been already un-gated by flow controller. Wait
         * for confirmation that cpu is powered and remove clamps.
@@ -134,25 +137,29 @@ static int tegra30_power_up_cpu(unsigned int cpu)
        if (cpu_isset(cpu, tegra_cpu_init_map)) {
                timeout = jiffies + 5;
                do {
-                       if (tegra_powergate_is_powered(pwrgateid))
+                       if (is_cpu_powered(cpu))
                                goto remove_clamps;
                        udelay(10);
                } while (time_before(jiffies, timeout));
        }
 
-       /* If this is the first boot, toggle powergates directly. */
-       if (!tegra_powergate_is_powered(pwrgateid)) {
-               ret = tegra_unpowergate_partition(pwrgateid);
+       /* First boot or Flow controller did not work as expected. Try to
+          directly toggle power gates. Error if direct power on also fails. */
+       if (!is_cpu_powered(cpu)) {
+               ret = tegra_unpowergate_partition(TEGRA_CPU_POWERGATE_ID(cpu));
                if (ret)
-                       return ret;
+                       goto fail;
 
                /* Wait for the power to come up. */
                timeout = jiffies + 10*HZ;
-               while (tegra_powergate_is_powered(pwrgateid)) {
-                       if (time_after(jiffies, timeout))
-                               return -ETIMEDOUT;
+
+               do {
+                       if (is_cpu_powered(cpu))
+                               goto remove_clamps;
                        udelay(10);
-               }
+               } while (time_before(jiffies, timeout));
+               ret = -ETIMEDOUT;
+               goto fail;
        }
 
 remove_clamps:
@@ -161,11 +168,12 @@ remove_clamps:
        udelay(10);
 
        /* Remove I/O clamps. */
-       ret = tegra_powergate_remove_clamping(pwrgateid);
+       ret = tegra_powergate_remove_clamping(TEGRA_CPU_POWERGATE_ID(cpu));
        if (ret)
                return ret;
 
        udelay(10);
+fail:
 
        /* Clear flow controller CSR. */
        flowctrl_write_cpu_csr(cpu, 0);
@@ -177,13 +185,35 @@ static int __cpuinit tegra_boot_secondary(unsigned int cpu, struct task_struct *
 {
        int status;
 
-       BUG_ON(cpu == smp_processor_id());
-
        /* Avoid timer calibration on slave cpus. Use the value calibrated
         * on master cpu. This reduces the bringup time for each slave cpu
         * by around 260ms.
         */
        preset_lpj = loops_per_jiffy;
+       if (is_lp_cluster()) {
+               struct clk *cpu_clk, *cpu_g_clk;
+
+               /* The G CPU may not be available for a variety of reasons. */
+               status = is_g_cluster_available(cpu);
+               if (status)
+                       goto done;
+
+               cpu_clk = tegra_get_clock_by_name("cpu");
+               cpu_g_clk = tegra_get_clock_by_name("cpu_g");
+
+               /* Switch to G CPU before continuing. */
+               if (!cpu_clk || !cpu_g_clk) {
+                       /* Early boot, clock infrastructure is not initialized
+                          - CPU mode switch is not allowed */
+                       status = -EINVAL;
+               } else
+                       status = clk_set_parent(cpu_clk, cpu_g_clk);
+
+               if (status)
+                       goto done;
+       }
+
+       smp_wmb();
 
        /*
         * Force the CPU into reset. The CPU must remain in reset when the
@@ -254,7 +284,6 @@ static void __init tegra_smp_init_cpus(void)
 
 static void __init tegra_smp_prepare_cpus(unsigned int max_cpus)
 {
-
        /* Always mark the boot CPU as initialized. */
        cpumask_set_cpu(0, to_cpumask(tegra_cpu_init_bits));
 
index 77737ac..595e405 100644 (file)
 #include <linux/smp.h>
 #include <linux/interrupt.h>
 #include <linux/clk.h>
-#include <linux/cpu_pm.h>
 #include <linux/delay.h>
 #include <linux/irq.h>
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/clockchips.h>
+#include <linux/cpu_pm.h>
 
 #include <mach/gpio.h>
 #include <mach/irqs.h>
@@ -38,7 +38,6 @@
 
 #include "clock.h"
 #include "cpuidle.h"
-#include "flowctrl.h"
 #include "iomap.h"
 #include "pm.h"
 #include "sleep.h"
@@ -200,13 +199,13 @@ void tegra_cluster_switch_prolog(unsigned int flags)
        /* Read the flow controler CSR register and clear the CPU switch
           and immediate flags. If an actual CPU switch is to be performed,
           re-write the CSR register with the desired values. */
-       reg = flowctrl_read_cpu_csr(0);
-       reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
-                FLOW_CTRL_CSR_SWITCH_CLUSTER);
+       reg = readl(FLOW_CTRL_CPU_CSR(0));
+       reg &= ~(FLOW_CTRL_CPU_CSR_IMMEDIATE_WAKE |
+                FLOW_CTRL_CPU_CSR_SWITCH_CLUSTER);
 
        /* Program flow controller for immediate wake if requested */
        if (flags & TEGRA_POWER_CLUSTER_IMMEDIATE)
-               reg |= FLOW_CTRL_CSR_IMMEDIATE_WAKE;
+               reg |= FLOW_CTRL_CPU_CSR_IMMEDIATE_WAKE;
 
        /* Do nothing if no switch actions requested */
        if (!target_cluster)
@@ -222,12 +221,12 @@ void tegra_cluster_switch_prolog(unsigned int flags)
                        }
 
                        /* Set up the flow controller to switch CPUs. */
-                       reg |= FLOW_CTRL_CSR_SWITCH_CLUSTER;
+                       reg |= FLOW_CTRL_CPU_CSR_SWITCH_CLUSTER;
                }
        }
 
 done:
-       flowctrl_write_cpu_csr(0, reg);
+       writel(reg, FLOW_CTRL_CPU_CSR(0));
 }
 
 
@@ -294,10 +293,10 @@ void tegra_cluster_switch_epilog(unsigned int flags)
        /* Make sure the switch and immediate flags are cleared in
           the flow controller to prevent undesirable side-effects
           for future users of the flow controller. */
-       reg = flowctrl_read_cpu_csr(0);
-       reg &= ~(FLOW_CTRL_CSR_IMMEDIATE_WAKE |
-                FLOW_CTRL_CSR_SWITCH_CLUSTER);
-       flowctrl_write_cpu_csr(0, reg);
+       reg = readl(FLOW_CTRL_CPU_CSR(0));
+       reg &= ~(FLOW_CTRL_CPU_CSR_IMMEDIATE_WAKE |
+                FLOW_CTRL_CPU_CSR_SWITCH_CLUSTER);
+       writel(reg, FLOW_CTRL_CPU_CSR(0));
 
        /* Perform post-switch LP=>G clean-up */
        if (!is_lp_cluster()) {
index e2bdb79..58b9ca8 100644 (file)
 
 #include <mach/irqs.h>
 #include <mach/powergate.h>
+#include <mach/hardware.h>
 
 #include "board.h"
 #include "clock.h"
 #include "cpuidle.h"
-#include "flowctrl.h"
 #include "fuse.h"
 #include "gic.h"
 #include "iomap.h"
@@ -361,13 +361,13 @@ static void restore_cpu_complex(u32 mode)
        writel(tegra_sctx.clk_csite_src, clk_rst + CLK_RESET_SOURCE_CSITE);
 
        /* Do not power-gate CPU 0 when flow controlled */
-       reg = flowctrl_read_cpu_csr(cpu);
+       reg = readl(FLOW_CTRL_CPU_CSR(cpu));
        reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
        reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
        reg &= ~FLOW_CTRL_CSR_ENABLE;           /* clear enable */
        reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr */
        reg |= FLOW_CTRL_CSR_EVENT_FLAG;        /* clear event */
-       flowctrl_write_cpu_csr(cpu, reg);
+       flowctrl_writel(reg, FLOW_CTRL_CPU_CSR(cpu));
 
        /* If an immedidate cluster switch is being perfomed, restore the
           local timer registers. For calls resulting from CPU LP2 in
@@ -411,7 +411,7 @@ static void suspend_cpu_complex(u32 mode)
 
        tegra_twd_suspend(&tegra_sctx.twd);
 
-       reg = flowctrl_read_cpu_csr(cpu);
+       reg = readl(FLOW_CTRL_CPU_CSR(cpu));
        reg &= ~FLOW_CTRL_CSR_WFE_BITMAP;       /* clear wfe bitmap */
        reg &= ~FLOW_CTRL_CSR_WFI_BITMAP;       /* clear wfi bitmap */
        reg |= FLOW_CTRL_CSR_INTR_FLAG;         /* clear intr flag */
@@ -422,15 +422,15 @@ static void suspend_cpu_complex(u32 mode)
        reg |= FLOW_CTRL_CSR_WFI_CPU0 << cpu;   /* enable power gating on wfi */
 #endif
        reg |= FLOW_CTRL_CSR_ENABLE;            /* enable power gating */
-       flowctrl_write_cpu_csr(cpu, reg);
+       flowctrl_writel(reg, FLOW_CTRL_CPU_CSR(cpu));
 
        for (i = 0; i < num_possible_cpus(); i++) {
                if (i == cpu)
                        continue;
-               reg = flowctrl_read_cpu_csr(i);
+               reg = readl(FLOW_CTRL_CPU_CSR(i));
                reg |= FLOW_CTRL_CSR_EVENT_FLAG;
                reg |= FLOW_CTRL_CSR_INTR_FLAG;
-               flowctrl_write_cpu_csr(i, reg);
+               flowctrl_writel(reg, FLOW_CTRL_CPU_CSR(i));
        }
 
        tegra_gic_cpu_disable();
@@ -783,10 +783,11 @@ static void tegra_suspend_check_pwr_stats(void)
 
        int partid;
 
-       for_each_set_bit(partid, &pwrgate_partid_mask, BITS_PER_LONG)
-               if (tegra_powergate_is_powered(partid) == 1)
-                       pr_warning("partition %s is left on before suspend\n",
-                               tegra_powergate_get_name(partid));
+       for (partid = 0; partid < TEGRA_NUM_POWERGATE; partid++)
+               if ((1 << partid) & pwrgate_partid_mask)
+                       if (tegra_powergate_is_powered(partid))
+                               pr_warning("partition %s is left on before suspend\n",
+                                       tegra_powergate_get_name(partid));
 
        return;
 }
@@ -1042,7 +1043,7 @@ void __init tegra_init_suspend(struct tegra_suspend_platform_data *plat)
                goto fail;
        }
 
-       if ((tegra_chip_id == TEGRA30) &&
+       if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA3) &&
            (tegra_revision == TEGRA_REVISION_A01) &&
            (plat->suspend_mode == TEGRA_SUSPEND_LP0)) {
                /* Tegra 3 A01 supports only LP1 */
index ae2276a..421b21a 100644 (file)
@@ -84,6 +84,8 @@ int tegra_suspend_dram(enum tegra_suspend_mode mode, unsigned int flags);
 
 #define FLOW_CTRL_CLUSTER_CONTROL \
        (IO_ADDRESS(TEGRA_FLOW_CTRL_BASE) + 0x2c)
+#define FLOW_CTRL_CPU_CSR_IMMEDIATE_WAKE       (1<<3)
+#define FLOW_CTRL_CPU_CSR_SWITCH_CLUSTER       (1<<2)
 
 #define FUSE_SKU_DIRECT_CONFIG \
        (IO_ADDRESS(TEGRA_FUSE_BASE) + 0x1F4)
index a726da1..27c8d92 100644 (file)
 #include <linux/err.h>
 #include <linux/notifier.h>
 #include <linux/regulator/consumer.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 
 #include <mach/iomap.h>
 
+#include "board.h"
 #include "fuse.h"
 
 #define PMC_PWR_IO_DISABLE     0x44
@@ -299,7 +300,7 @@ int __init tegra_pwr_detect_cell_init(void)
        unsigned long flags;
        bool rails_found = true;
 
-       i = tegra_package_id;
+       i = tegra_package_id();
        if ((i != -1) && (i & (~0x1F))) {
                pr_err("tegra: not supported package id %d - io power detection"
                       " is left always on\n", i);
index 3c0ff51..54d5570 100644 (file)
 
 #define PWRGATE_STATUS         0x38
 
-static int tegra_num_powerdomains;
-static int tegra_num_cpu_domains;
-static u8 *tegra_cpu_domains;
-static u8 tegra20_cpu_domains[] = {
-       TEGRA_POWERGATE_CPU,
-};
-static u8 tegra30_cpu_domains[] = {
-       TEGRA_POWERGATE_CPU0,
-       TEGRA_POWERGATE_CPU1,
-       TEGRA_POWERGATE_CPU2,
-       TEGRA_POWERGATE_CPU3,
-};
-
 #if !defined(CONFIG_ARCH_TEGRA_2x_SOC)
 enum mc_client {
        MC_CLIENT_AFI           = 0,
@@ -103,6 +90,16 @@ enum mc_client {
 
 #define MAX_CLK_EN_NUM                 4
 
+static int tegra_num_powerdomains;
+static int tegra_num_cpu_domains;
+static u8 *tegra_cpu_domains;
+static u8 tegra30_cpu_domains[] = {
+       TEGRA_POWERGATE_CPU0,
+       TEGRA_POWERGATE_CPU1,
+       TEGRA_POWERGATE_CPU2,
+       TEGRA_POWERGATE_CPU3,
+};
+
 static DEFINE_SPINLOCK(tegra_powergate_lock);
 
 #define MAX_HOTRESET_CLIENT_NUM                4
@@ -126,7 +123,7 @@ struct powergate_partition {
        struct partition_clk_info clk_info[MAX_CLK_EN_NUM];
 };
 
-static struct powergate_partition powergate_partition_info[] = {
+static struct powergate_partition powergate_partition_info[TEGRA_NUM_POWERGATE] = {
        [TEGRA_POWERGATE_CPU]   = { "cpu0",     {MC_CLIENT_LAST}, },
        [TEGRA_POWERGATE_L2]    = { "l2",       {MC_CLIENT_LAST}, },
        [TEGRA_POWERGATE_3D]    = { "3d0",
@@ -156,6 +153,7 @@ static struct powergate_partition powergate_partition_info[] = {
                                                {{"isp", CLK_AND_RST},
                                                {"vi", CLK_AND_RST},
                                                {"csi", CLK_AND_RST} }, },
+#if !defined(CONFIG_ARCH_TEGRA_2x_SOC)
        [TEGRA_POWERGATE_CPU1]  = { "cpu1",     {MC_CLIENT_LAST}, },
        [TEGRA_POWERGATE_CPU2]  = { "cpu2",     {MC_CLIENT_LAST}, },
        [TEGRA_POWERGATE_CPU3]  = { "cpu3",     {MC_CLIENT_LAST}, },
@@ -176,6 +174,7 @@ static struct powergate_partition powergate_partition_info[] = {
                                                {"epp", CLK_AND_RST},
                                                {"host1x", CLK_AND_RST},
                                                {"3d", RST_ONLY} }, },
+#endif
 };
 
 static void __iomem *pmc = IO_ADDRESS(TEGRA_PMC_BASE);
@@ -213,7 +212,7 @@ static void mc_flush(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_HOTRESET_CLIENT_NUM; idx++) {
                mcClientBit = powergate_partition_info[id].hot_reset_clients[idx];
@@ -240,7 +239,7 @@ static void mc_flush_done(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_HOTRESET_CLIENT_NUM; idx++) {
                mcClientBit = powergate_partition_info[id].hot_reset_clients[idx];
@@ -261,7 +260,7 @@ static void mc_flush_done(int id)
 
 int tegra_powergate_mc_flush(int id)
 {
-       if (id < 0 || id >= tegra_num_powerdomains)
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE)
                return -EINVAL;
        mc_flush(id);
        return 0;
@@ -269,7 +268,7 @@ int tegra_powergate_mc_flush(int id)
 
 int tegra_powergate_mc_flush_done(int id)
 {
-       if (id < 0 || id >= tegra_num_powerdomains)
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE)
                return -EINVAL;
        mc_flush_done(id);
        return 0;
@@ -297,7 +296,7 @@ int tegra_powergate_mc_disable(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       if (id < 0 || id >= tegra_num_powerdomains) {
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE) {
                WARN_ON(1);
                return -EINVAL;
        }
@@ -334,7 +333,7 @@ int tegra_powergate_mc_flush(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       if (id < 0 || id >= tegra_num_powerdomains) {
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE) {
                WARN_ON(1);
                return -EINVAL;
        }
@@ -366,7 +365,7 @@ int tegra_powergate_mc_flush_done(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       if (id < 0 || id >= tegra_num_powerdomains) {
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE) {
                WARN_ON(1);
                return -EINVAL;
        }
@@ -398,7 +397,7 @@ int tegra_powergate_mc_enable(int id)
        enum mc_client mcClientBit;
        unsigned long flags;
 
-       if (id < 0 || id >= tegra_num_powerdomains) {
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE) {
                WARN_ON(1);
                return -EINVAL;
        }
@@ -428,17 +427,6 @@ static void mc_flush(int id) {}
 static void mc_flush_done(int id) {}
 #endif
 
-static bool tegra_is_cpu_powergate_id(int id)
-{
-       int i;
-
-       for (i = 0; i < tegra_num_cpu_domains; i++)
-               if (tegra_cpu_domains[i] == id)
-                       return true;
-
-       return false;
-}
-
 static int tegra_powergate_set(int id, bool new_state)
 {
        bool status;
@@ -458,7 +446,7 @@ static int tegra_powergate_set(int id, bool new_state)
                return 0;
        }
 
-       if (tegra_is_cpu_powergate_id(id)) {
+       if (TEGRA_IS_CPU_POWERGATE_ID(id)) {
                /* CPU ungated in s/w only during boot/resume with outer
                   waiting loop and no contention from other CPUs */
                pmc_write(PWRGATE_TOGGLE_START | id, PWRGATE_TOGGLE);
@@ -507,7 +495,7 @@ static int powergate_module(int id)
        return tegra_powergate_set(id, false);
 }
 
-int tegra_powergate_is_powered(int id)
+bool tegra_powergate_is_powered(int id)
 {
        u32 status;
 
@@ -522,6 +510,7 @@ EXPORT_SYMBOL(tegra_powergate_is_powered);
 int tegra_powergate_remove_clamping(int id)
 {
        u32 mask;
+
        if (id < 0 || id >= tegra_num_powerdomains)
                return -EINVAL;
 
@@ -562,7 +551,7 @@ static int partition_clk_enable(int id)
        struct clk *clk;
        struct partition_clk_info *clk_info;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_CLK_EN_NUM; idx++) {
                clk_info = &powergate_partition_info[id].clk_info[idx];
@@ -597,7 +586,7 @@ static int is_partition_clk_disabled(int id)
        struct partition_clk_info *clk_info;
        int ret = 0;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_CLK_EN_NUM; idx++) {
                clk_info = &powergate_partition_info[id].clk_info[idx];
@@ -622,7 +611,7 @@ static void partition_clk_disable(int id)
        struct clk *clk;
        struct partition_clk_info *clk_info;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_CLK_EN_NUM; idx++) {
                clk_info = &powergate_partition_info[id].clk_info[idx];
@@ -641,7 +630,7 @@ static void powergate_partition_assert_reset(int id)
        struct clk *clk_ptr;
        struct partition_clk_info *clk_info;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_CLK_EN_NUM; idx++) {
                clk_info = &powergate_partition_info[id].clk_info[idx];
@@ -659,7 +648,7 @@ static void powergate_partition_deassert_reset(int id)
        struct clk *clk_ptr;
        struct partition_clk_info *clk_info;
 
-       BUG_ON(id < 0 || id >= tegra_num_powerdomains);
+       BUG_ON(id < 0 || id >= TEGRA_NUM_POWERGATE);
 
        for (idx = 0; idx < MAX_CLK_EN_NUM; idx++) {
                clk_info = &powergate_partition_info[id].clk_info[idx];
@@ -745,6 +734,34 @@ err_power:
        return ret;
 }
 
+int tegra_cpu_powergate_id(int cpuid)
+{
+       if (cpuid > 0 && cpuid < tegra_num_cpu_domains)
+               return tegra_cpu_domains[cpuid];
+
+       return -EINVAL;
+}
+
+int __init tegra_powergate_init(void)
+{
+       switch (tegra_chip_id) {
+       case TEGRA20:
+               tegra_num_powerdomains = 7;
+               break;
+       case TEGRA30:
+               tegra_num_powerdomains = 14;
+               tegra_num_cpu_domains = 4;
+               tegra_cpu_domains = tegra30_cpu_domains;
+               break;
+       default:
+               /* Unknown Tegra variant. Disable powergating */
+               tegra_num_powerdomains = 0;
+               break;
+       }
+
+       return 0;
+}
+
 /*
  * Must be called with clk disabled, and returns with clk enabled
  * Unpowergates the partition and enables all required clks.
@@ -842,39 +859,9 @@ err_powergating:
        return ret;
 }
 
-int tegra_cpu_powergate_id(int cpuid)
-{
-       if (cpuid > 0 && cpuid < tegra_num_cpu_domains)
-               return tegra_cpu_domains[cpuid];
-
-       return -EINVAL;
-}
-
-int __init tegra_powergate_init(void)
-{
-       switch (tegra_chip_id) {
-       case TEGRA20:
-               tegra_num_powerdomains = 7;
-               tegra_num_cpu_domains = 1;
-               tegra_cpu_domains = tegra20_cpu_domains;
-               break;
-       case TEGRA30:
-               tegra_num_powerdomains = 14;
-               tegra_num_cpu_domains = 4;
-               tegra_cpu_domains = tegra30_cpu_domains;
-               break;
-       default:
-               /* Unknown Tegra variant. Disable powergating */
-               tegra_num_powerdomains = 0;
-               break;
-       }
-
-       return 0;
-}
-
 const char *tegra_powergate_get_name(int id)
 {
-       if (id < 0 || id >= tegra_num_powerdomains)
+       if (id < 0 || id >= TEGRA_NUM_POWERGATE)
                return "invalid";
 
        return powergate_partition_info[id].name;
@@ -882,6 +869,16 @@ const char *tegra_powergate_get_name(int id)
 
 #ifdef CONFIG_DEBUG_FS
 
+static const char * const powergate_name[] = {
+       [TEGRA_POWERGATE_CPU]   = "cpu",
+       [TEGRA_POWERGATE_3D]    = "3d",
+       [TEGRA_POWERGATE_VENC]  = "venc",
+       [TEGRA_POWERGATE_VDEC]  = "vdec",
+       [TEGRA_POWERGATE_PCIE]  = "pcie",
+       [TEGRA_POWERGATE_L2]    = "l2",
+       [TEGRA_POWERGATE_MPE]   = "mpe",
+};
+
 static int powergate_show(struct seq_file *s, void *data)
 {
        int i;
@@ -890,7 +887,7 @@ static int powergate_show(struct seq_file *s, void *data)
        seq_printf(s, "------------------\n");
 
        for (i = 0; i < tegra_num_powerdomains; i++)
-               seq_printf(s, " %9s %7s\n", powergate_partition_info[i].name,
+               seq_printf(s, " %9s %7s\n", powergate_name[i],
                        tegra_powergate_is_powered(i) ? "yes" : "no");
        return 0;
 }
index 942013d..ae4cf84 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * arch/arm/mach-tegra/reset.c
  *
- * Copyright (C) 2011,2012 NVIDIA Corporation.
+ * Copyright (C) 2011-2012 NVIDIA Corporation.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
 #include <linux/bitops.h>
 
 #include <asm/cacheflush.h>
+#include <asm/hardware/cache-l2x0.h>
 
 #include "iomap.h"
 #include "irammap.h"
 #include "reset.h"
-#include "fuse.h"
-#include "pm.h"
 #include "sleep.h"
+#include "pm.h"
+#include "fuse.h"
 
 #define TEGRA_IRAM_RESET_BASE (TEGRA_IRAM_BASE + \
                                TEGRA_IRAM_RESET_HANDLER_OFFSET)
@@ -35,30 +36,27 @@ static bool is_enabled;
 
 static void __init tegra_cpu_reset_handler_enable(void)
 {
-       void __iomem *iram_base = IO_ADDRESS(TEGRA_IRAM_RESET_BASE);
+       void __iomem *iram_base = IO_ADDRESS(TEGRA_IRAM_BASE);
 #ifndef CONFIG_TRUSTED_FOUNDATIONS
        void __iomem *evp_cpu_reset =
                IO_ADDRESS(TEGRA_EXCEPTION_VECTORS_BASE + 0x100);
        void __iomem *sb_ctrl = IO_ADDRESS(TEGRA_SB_BASE);
-       u32 reg;
+       unsigned long reg;
 #endif
-
        BUG_ON(is_enabled);
-       BUG_ON(tegra_cpu_reset_handler_size > TEGRA_IRAM_RESET_HANDLER_SIZE);
+       BUG_ON(tegra_cpu_reset_handler_size > TEGRA_RESET_HANDLER_SIZE);
 
        memcpy(iram_base, (void *)__tegra_cpu_reset_handler_start,
-                       tegra_cpu_reset_handler_size);
+               tegra_cpu_reset_handler_size);
 
 #ifdef CONFIG_TRUSTED_FOUNDATIONS
        tegra_generic_smc(0xFFFFF200,
-               TEGRA_IRAM_RESET_BASE + tegra_cpu_reset_handler_offset, 0);
+               TEGRA_RESET_HANDLER_BASE + tegra_cpu_reset_handler_offset, 0);
 #else
-       /*
-        * NOTE: This must be the one and only write to the EVP CPU reset
-        *       vector in the entire system.
-        */
-       writel(TEGRA_IRAM_RESET_BASE + tegra_cpu_reset_handler_offset,
-                       evp_cpu_reset);
+       /* NOTE: This must be the one and only write to the EVP CPU reset
+                vector in the entire system. */
+       writel(TEGRA_RESET_HANDLER_BASE + tegra_cpu_reset_handler_offset,
+               evp_cpu_reset);
        wmb();
        reg = readl(evp_cpu_reset);
 
@@ -73,7 +71,6 @@ static void __init tegra_cpu_reset_handler_enable(void)
                wmb();
        }
 #endif
-
        is_enabled = true;
 }
 
@@ -108,6 +105,7 @@ void __init tegra_cpu_reset_handler_init(void)
        __tegra_cpu_reset_handler_data[TEGRA_RESET_STARTUP_SECONDARY] =
                virt_to_phys((void *)tegra_secondary_startup);
 #endif
+
 #ifdef CONFIG_PM_SLEEP
        __tegra_cpu_reset_handler_data[TEGRA_RESET_STARTUP_LP1] =
                TEGRA_IRAM_CODE_AREA;
index 58ddea4..44a6711 100644 (file)
@@ -38,14 +38,6 @@ void __tegra_cpu_reset_handler(void);
 void __tegra_cpu_reset_handler_end(void);
 void tegra_secondary_startup(void);
 
-#define tegra_cpu_reset_handler_offset \
-               ((u32)__tegra_cpu_reset_handler - \
-                (u32)__tegra_cpu_reset_handler_start)
-
-#define tegra_cpu_reset_handler_size \
-               (__tegra_cpu_reset_handler_end - \
-                __tegra_cpu_reset_handler_start)
-
 #ifdef CONFIG_PM_SLEEP
 #define tegra_cpu_lp1_mask ((unsigned long *)(IO_ADDRESS(TEGRA_RESET_HANDLER_BASE + \
                ((u32)&__tegra_cpu_reset_handler_data[TEGRA_RESET_MASK_LP1] - \
@@ -60,6 +52,14 @@ void tegra_secondary_startup(void);
                 (u32)__tegra_cpu_reset_handler_start))))
 #endif
 
+#define tegra_cpu_reset_handler_offset \
+               ((u32)__tegra_cpu_reset_handler - \
+                (u32)__tegra_cpu_reset_handler_start)
+
+#define tegra_cpu_reset_handler_size \
+               (__tegra_cpu_reset_handler_end - \
+                __tegra_cpu_reset_handler_start)
+
 void __init tegra_cpu_reset_handler_init(void);
 
 #ifdef CONFIG_PM_SLEEP
index f2a3338..23474e2 100644 (file)
@@ -31,7 +31,6 @@
 #include <asm/asm-offsets.h>
 #include <asm/glue-cache.h>
 #include <asm/glue-proc.h>
-#include <asm/system.h>
 
 #include "sleep.h"
 #include "flowctrl.h"
index 33b7be3..6831c61 100644 (file)
@@ -30,7 +30,6 @@
 #include <asm/cp15.h>
 
 #include "sleep.h"
-#include "flowctrl.h"
 #include "clock.h"
 
 #define EMC_CFG                                0xc
index 5a5467a..56006d7 100644 (file)
@@ -28,7 +28,6 @@
 
 #include <asm/assembler.h>
 #include <asm/cache.h>
-#include <asm/cp15.h>
 #include <asm/domain.h>
 #include <asm/memory.h>
 #include <asm/page.h>
 #include <asm/asm-offsets.h>
 #include <asm/glue-cache.h>
 #include <asm/glue-proc.h>
-#include <asm/barrier.h>
+#include <asm/cp15.h>
 
 #include "iomap.h"
 
-#include "flowctrl.h"
 #include "sleep.h"
+#include "flowctrl.h"
 
 #define CLK_RESET_CCLK_BURST           0x20
 #define CLK_RESET_CCLK_DIVIDER         0x24
 
 #define TEGRA_PMC_VIRT         (TEGRA_PMC_BASE - IO_APB_PHYS + IO_APB_VIRT)
 
+#define TEGRA_FLOW_CTRL_VIRT (TEGRA_FLOW_CTRL_BASE - IO_PPSB_PHYS \
+                                       + IO_PPSB_VIRT)
+
 /*
  * tegra_pen_lock
  *
@@ -102,6 +104,7 @@ ENTRY(tegra_pen_unlock)
        mov     pc, lr
 ENDPROC(tegra_pen_unlock)
 
+
 /*
  * tegra_cpu_exit_coherency
  *
index ed28e21..e3f7ca9 100644 (file)
 #define CPU_NOT_RESETTABLE             0
 #endif
 
+#define FLOW_CTRL_HALT_CPU0_EVENTS     0x0
+#define   FLOW_CTRL_WAITEVENT          (2 << 29)
+#define   FLOW_CTRL_WAIT_FOR_INTERRUPT (4 << 29)
+#define   FLOW_CTRL_JTAG_RESUME                (1 << 28)
+#define   FLOW_CTRL_HALT_CPU_IRQ       (1 << 10)
+#define   FLOW_CTRL_HALT_CPU_FIQ       (1 << 8)
+#define FLOW_CTRL_CPU0_CSR             0x8
+#define   FLOW_CTRL_CSR_INTR_FLAG      (1 << 15)
+#define   FLOW_CTRL_CSR_EVENT_FLAG     (1 << 14)
+#define   FLOW_CTRL_CSR_ENABLE         (1 << 0)
+#define FLOW_CTRL_HALT_CPU1_EVENTS     0x14
+#define FLOW_CTRL_CPU1_CSR             0x18
+
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+#define FLOW_CTRL_CSR_WFE_CPU0         (1 << 4)
+#define FLOW_CTRL_CSR_WFE_BITMAP       (3 << 4)
+#define FLOW_CTRL_CSR_WFI_BITMAP       0
+#else
+#define FLOW_CTRL_CSR_WFE_BITMAP       (0xF << 4)
+#define FLOW_CTRL_CSR_WFI_CPU0         (1 << 8)
+#define FLOW_CTRL_CSR_WFI_BITMAP       (0xF << 8)
+#endif
+
 #define TEGRA_PL310_VIRT (TEGRA_ARM_PL310_BASE - IO_CPU_PHYS + IO_CPU_VIRT)
 #define TEGRA_ARM_PERIF_VIRT (TEGRA_ARM_PERIF_BASE - IO_CPU_PHYS \
                                        + IO_CPU_VIRT)
 
 #else  /* !defined(__ASSEMBLY__) */
 
+#include <linux/io.h>
+
 #ifdef CONFIG_HOTPLUG_CPU
 void tegra20_hotplug_init(void);
 void tegra30_hotplug_init(void);
@@ -156,6 +181,23 @@ static inline void tegra20_hotplug_init(void) {}
 static inline void tegra30_hotplug_init(void) {}
 #endif
 
+#define FLOW_CTRL_HALT_CPU(cpu)        (IO_ADDRESS(TEGRA_FLOW_CTRL_BASE) +     \
+       ((cpu) ? (FLOW_CTRL_HALT_CPU1_EVENTS + 8 * ((cpu) - 1)) :       \
+        FLOW_CTRL_HALT_CPU0_EVENTS))
+
+#define FLOW_CTRL_CPU_CSR(cpu) (IO_ADDRESS(TEGRA_FLOW_CTRL_BASE) +     \
+       ((cpu) ? (FLOW_CTRL_CPU1_CSR + 8 * ((cpu) - 1)) :       \
+        FLOW_CTRL_CPU0_CSR))
+
+static inline void flowctrl_writel(unsigned long val, void __iomem *addr)
+{
+       writel(val, addr);
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+       wmb();
+#endif
+       (void)__raw_readl(addr);
+}
+
 void tegra_pen_lock(void);
 void tegra_pen_unlock(void);
 void tegra_cpu_wfi(void);
index c093502..1d904a7 100644 (file)
@@ -42,6 +42,8 @@ module_param(emc_enable, bool, 0644);
 
 static struct platform_device *emc_pdev;
 static void __iomem *emc_regbase;
+static const struct tegra_emc_table *tegra_emc_table;
+static int tegra_emc_table_size;
 
 static unsigned long tegra_emc_max_bus_rate;  /* 2 * 1000 * maximum emc_clock rate */
 static unsigned long tegra_emc_min_bus_rate;  /* 2 * 1000 * minimum emc_clock rate */
@@ -137,7 +139,7 @@ static const unsigned long emc_reg_addr[TEGRA_EMC_NUM_REGS] = {
 /* Select the closest EMC rate that is higher than the requested rate */
 long tegra_emc_round_rate(unsigned long rate)
 {
-       struct tegra_emc_chip *pdata;
+       struct tegra_emc_pdata *pdata;
        int i;
        int best = -1;
        unsigned long distance = ULONG_MAX;
@@ -148,7 +150,7 @@ long tegra_emc_round_rate(unsigned long rate)
        pdata = emc_pdev->dev.platform_data;
 
        if (rate >= tegra_emc_max_bus_rate) {
-               best = pdata->num_tables - 1;
+               best = tegra_emc_table_size - 1;
                goto round_out;
        } else if (rate <= tegra_emc_min_bus_rate) {
                best = 0;
@@ -190,7 +192,7 @@ round_out:
  */
 int tegra_emc_set_rate(unsigned long rate)
 {
-       struct tegra_emc_chip *pdata;
+       struct tegra_emc_pdata *pdata;
        int i;
        int j;
 
@@ -205,11 +207,11 @@ int tegra_emc_set_rate(unsigned long rate)
         */
        rate = rate / 2 / 1000;
 
-       for (i = pdata->num_tables - 1; i >= 0; i--)
+       for (i = 0; i < pdata->num_tables; i++)
                if (pdata->tables[i].rate == rate)
                        break;
 
-       if (i < 0)
+       if (i >= pdata->num_tables)
                return -EINVAL;
 
        pr_debug("%s: setting to %lu\n", __func__, rate);
@@ -222,50 +224,56 @@ int tegra_emc_set_rate(unsigned long rate)
        return 0;
 }
 
-static struct tegra_emc_chip *tegra_emc_choose_chip(
-               struct platform_device *pdev)
+static void tegra_emc_match_chip_data(struct platform_device *pdev)
 {
-       struct tegra_emc_pdata *pdata = pdev->dev.platform_data;
        int i;
        int vid;
        int rev_id1;
        int rev_id2;
        int pid;
-       int chip_matched = -1;
+       struct tegra_emc_pdata *pchips = pdev->dev.platform_data;
+       int chips_size = pchips->num_tables;
 
        vid = tegra_emc_read_mrr(5);
        rev_id1 = tegra_emc_read_mrr(6);
        rev_id2 = tegra_emc_read_mrr(7);
        pid = tegra_emc_read_mrr(8);
 
-       for (i = 0; i < pdata->num_chips; i++) {
-               if (pdata->chips[i].mem_manufacturer_id >= 0) {
-                       if (pdata->chips[i].mem_manufacturer_id != vid)
+       for (i = 0; i < chips_size; i++) {
+               if (pchips[i].mem_manufacturer_id >= 0) {
+                       if (pchips[i].mem_manufacturer_id != vid)
                                continue;
                }
-               if (pdata->chips[i].mem_revision_id1 >= 0) {
-                       if (pdata->chips[i].mem_revision_id1 != rev_id1)
+               if (pchips[i].mem_revision_id1 >= 0) {
+                       if (pchips[i].mem_revision_id1 != rev_id1)
                                continue;
                }
-               if (pdata->chips[i].mem_revision_id2 >= 0) {
-                       if (pdata->chips[i].mem_revision_id2 != rev_id2)
+               if (pchips[i].mem_revision_id2 >= 0) {
+                       if (pchips[i].mem_revision_id2 != rev_id2)
                                continue;
                }
-               if (pdata->chips[i].mem_pid >= 0) {
-                       if (pdata->chips[i].mem_pid != pid)
+               if (pchips[i].mem_pid >= 0) {
+                       if (pchips[i].mem_pid != pid)
                                continue;
                }
 
-               chip_matched = i;
-               break;
-       }
-
-       if (chip_matched >= 0) {
                pr_info("%s: %s memory found\n", __func__,
-                       pdata->chips[chip_matched].description);
-               return &pdata->chips[chip_matched];
+                       pchips[i].description);
+               tegra_emc_table = pchips[i].tables;
+               tegra_emc_table_size = pchips[i].num_tables;
+
+               tegra_emc_min_bus_rate = tegra_emc_table[0].rate * 2 * 1000;
+               tegra_emc_max_bus_rate = tegra_emc_table[tegra_emc_table_size - 1].rate * 2 * 1000;
+               goto out;
        }
-       return NULL;
+
+       pr_err("%s: Memory not recognized, memory scaling disabled\n",
+               __func__);
+out:
+       pr_info("%s: Memory vid     = 0x%04x", __func__, vid);
+       pr_info("%s: Memory rev_id1 = 0x%04x", __func__, rev_id1);
+       pr_info("%s: Memory rev_id2 = 0x%04x", __func__, rev_id2);
+       pr_info("%s: Memory pid     = 0x%04x", __func__, pid);
 }
 
 #ifdef CONFIG_OF
@@ -284,12 +292,12 @@ static struct device_node *tegra_emc_ramcode_devnode(struct device_node *np)
        return NULL;
 }
 
-static struct tegra_emc_chip *tegra_emc_dt_parse_pdata(
+static struct tegra_emc_pdata *tegra_emc_dt_parse_pdata(
                struct platform_device *pdev)
 {
        struct device_node *np = pdev->dev.of_node;
        struct device_node *tnp, *iter;
-       struct tegra_emc_chip *pdata;
+       struct tegra_emc_pdata *pdata;
        int ret, i, num_tables;
 
        if (!np)
@@ -353,17 +361,17 @@ out:
        return pdata;
 }
 #else
-static struct tegra_emc_chip *tegra_emc_dt_parse_pdata(
+static struct tegra_emc_pdata *tegra_emc_dt_parse_pdata(
                struct platform_device *pdev)
 {
        return NULL;
 }
 #endif
 
-static struct tegra_emc_chip *tegra_emc_fill_pdata(struct platform_device *pdev)
+static struct tegra_emc_pdata *tegra_emc_fill_pdata(struct platform_device *pdev)
 {
        struct clk *c = clk_get_sys(NULL, "emc");
-       struct tegra_emc_chip *pdata;
+       struct tegra_emc_pdata *pdata;
        unsigned long khz;
        int i;
 
@@ -390,7 +398,7 @@ static struct tegra_emc_chip *tegra_emc_fill_pdata(struct platform_device *pdev)
 
 static int tegra_emc_probe(struct platform_device *pdev)
 {
-       struct tegra_emc_chip *pdata;
+       struct tegra_emc_pdata *pdata;
        struct resource *res;
 
        if (!emc_enable) {
@@ -410,8 +418,10 @@ static int tegra_emc_probe(struct platform_device *pdev)
                return -ENOMEM;
        }
 
-       if (pdev->dev.platform_data)
-               pdata = tegra_emc_choose_chip(pdev);
+       pdata = pdev->dev.platform_data;
+
+       if (pdata)
+               tegra_emc_match_chip_data(pdev);
 
        if (!pdata)
                pdata = tegra_emc_dt_parse_pdata(pdev);
@@ -419,9 +429,6 @@ static int tegra_emc_probe(struct platform_device *pdev)
        if (!pdata)
                pdata = tegra_emc_fill_pdata(pdev);
 
-       tegra_emc_min_bus_rate = pdata->tables[0].rate * 2 * 1000;
-       tegra_emc_max_bus_rate = pdata->tables[pdata->num_tables - 1].rate * 2 * 1000;
-
        pdev->dev.platform_data = pdata;
 
        emc_pdev = pdev;
@@ -443,8 +450,7 @@ static struct platform_driver tegra_emc_driver = {
        .probe          = tegra_emc_probe,
 };
 
-static int __init tegra_emc_init(void)
+int __init tegra_emc_init(void)
 {
        return platform_driver_register(&tegra_emc_driver);
 }
-device_initcall(tegra_emc_init);
index 767f996..e93ccca 100644 (file)
@@ -18,4 +18,8 @@
 #ifndef __MACH_TEGRA_TEGRA2_EMC_H_
 #define __MACH_TEGRA_TEGRA2_EMC_H
 
+int __init tegra_emc_init(void);
+int tegra_emc_set_rate(unsigned long rate);
+long tegra_emc_round_rate(unsigned long rate);
+
 #endif
index 5361c1a..35c92b8 100644 (file)
@@ -25,8 +25,6 @@
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/platform_data/tegra30_emc.h>
 #include <linux/suspend.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -47,12 +45,9 @@ static bool emc_enable;
 #endif
 module_param(emc_enable, bool, 0644);
 
-static struct platform_device *emc_pdev;
-static void __iomem *emc_regbases[2];
-
 u8 tegra_emc_bw_efficiency = 35;
 
-#define EMC_MIN_RATE_DDR3              50000000
+#define EMC_MIN_RATE_DDR3              25500000
 #define EMC_STATUS_UPDATE_TIMEOUT      100
 #define TEGRA_EMC_TABLE_MAX_SIZE       16
 
@@ -195,11 +190,13 @@ enum {
 static int emc_num_burst_regs;
 
 static struct clk_mux_sel tegra_emc_clk_sel[TEGRA_EMC_TABLE_MAX_SIZE];
-static struct tegra30_emc_table start_timing;
-static const struct tegra30_emc_table *emc_timing;
+static struct tegra_emc_table start_timing;
+static const struct tegra_emc_table *emc_timing;
 static unsigned long dram_over_temp_state = DRAM_OVER_TEMP_NONE;
 
 static const u32 *dram_to_soc_bit_map;
+static const struct tegra_emc_table *tegra_emc_table;
+static int tegra_emc_table_size;
 
 static u32 dram_dev_num;
 static u32 emc_cfg_saved;
@@ -218,25 +215,27 @@ static struct {
 
 static DEFINE_SPINLOCK(emc_access_lock);
 
+static void __iomem *emc_base = IO_ADDRESS(TEGRA_EMC_BASE);
+static void __iomem *mc_base = IO_ADDRESS(TEGRA_MC_BASE);
 static void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
 
 static inline void emc_writel(u32 val, unsigned long addr)
 {
-       writel(val, emc_regbases[0] + addr);
+       writel(val, emc_base + addr);
        barrier();
 }
 static inline u32 emc_readl(unsigned long addr)
 {
-       return readl(emc_regbases[0] + addr);
+       return readl(emc_base + addr);
 }
 static inline void mc_writel(u32 val, unsigned long addr)
 {
-       writel(val, emc_regbases[1] + addr);
+       writel(val, mc_base + addr);
        barrier();
 }
 static inline u32 mc_readl(unsigned long addr)
 {
-       return readl(emc_regbases[1] + addr);
+       return readl(mc_base + addr);
 }
 
 static void emc_last_stats_update(int last_sel)
@@ -247,8 +246,8 @@ static void emc_last_stats_update(int last_sel)
        spin_lock_irqsave(&emc_stats.spinlock, flags);
 
        if (emc_stats.last_sel < TEGRA_EMC_TABLE_MAX_SIZE)
-               emc_stats.time_at_clock[emc_stats.last_sel] =
-                       emc_stats.time_at_clock[emc_stats.last_sel] +
+               emc_stats.time_at_clock[emc_stats.last_sel] = 
+                       emc_stats.time_at_clock[emc_stats.last_sel] + 
                        (cur_jiffies - emc_stats.last_update);
 
        emc_stats.last_update = cur_jiffies;
@@ -298,7 +297,7 @@ static inline void auto_cal_disable(void)
 }
 
 static inline void set_over_temp_timing(
-       const struct tegra30_emc_table *next_timing, unsigned long state)
+       const struct tegra_emc_table *next_timing, unsigned long state)
 {
 #define REFRESH_SPEEDUP(val)                                                 \
        do {                                                                  \
@@ -359,8 +358,8 @@ static inline void enable_early_ack(u32 mc_override)
                        MC_EMEM_ARB_OVERRIDE);
 }
 
-static inline bool dqs_preset(const struct tegra30_emc_table *next_timing,
-                             const struct tegra30_emc_table *last_timing)
+static inline bool dqs_preset(const struct tegra_emc_table *next_timing,
+                             const struct tegra_emc_table *last_timing)
 {
        bool ret = false;
 
@@ -384,7 +383,7 @@ static inline bool dqs_preset(const struct tegra30_emc_table *next_timing,
 }
 
 static inline void overwrite_mrs_wait_cnt(
-       const struct tegra30_emc_table *next_timing,
+       const struct tegra_emc_table *next_timing,
        bool zcal_long)
 {
        u32 reg;
@@ -411,8 +410,8 @@ static inline void overwrite_mrs_wait_cnt(
        emc_writel(reg, EMC_MRS_WAIT_CNT);
 }
 
-static inline bool need_qrst(const struct tegra30_emc_table *next_timing,
-                            const struct tegra30_emc_table *last_timing,
+static inline bool need_qrst(const struct tegra_emc_table *next_timing,
+                            const struct tegra_emc_table *last_timing,
                             u32 emc_dpd_reg)
 {
        u32 last_mode = (last_timing->burst_regs[EMC_FBIO_CFG5_INDEX] &
@@ -446,8 +445,8 @@ static inline void periodic_qrst_enable(u32 emc_cfg_reg, u32 emc_dbg_reg)
        emc_writel(emc_dbg_reg, EMC_DBG);
 }
 
-static inline int get_dll_change(const struct tegra30_emc_table *next_timing,
-                                const struct tegra30_emc_table *last_timing)
+static inline int get_dll_change(const struct tegra_emc_table *next_timing,
+                                const struct tegra_emc_table *last_timing)
 {
        bool next_dll_enabled = !(next_timing->emc_mode_1 & 0x1);
        bool last_dll_enabled = !(last_timing->emc_mode_1 & 0x1);
@@ -460,8 +459,8 @@ static inline int get_dll_change(const struct tegra30_emc_table *next_timing,
                return DLL_CHANGE_OFF;
 }
 
-static inline void set_dram_mode(const struct tegra30_emc_table *next_timing,
-                                const struct tegra30_emc_table *last_timing,
+static inline void set_dram_mode(const struct tegra_emc_table *next_timing,
+                                const struct tegra_emc_table *last_timing,
                                 int dll_change)
 {
        if (dram_type == DRAM_TYPE_DDR3) {
@@ -507,8 +506,8 @@ static inline void do_clock_change(u32 clk_setting)
        }
 }
 
-static noinline void emc_set_clock(const struct tegra30_emc_table *next_timing,
-                                  const struct tegra30_emc_table *last_timing,
+static noinline void emc_set_clock(const struct tegra_emc_table *next_timing,
+                                  const struct tegra_emc_table *last_timing,
                                   u32 clk_setting)
 {
        int i, dll_change, pre_wait;
@@ -668,7 +667,7 @@ static noinline void emc_set_clock(const struct tegra30_emc_table *next_timing,
        mc_writel(mc_override, MC_EMEM_ARB_OVERRIDE);
 }
 
-static inline void emc_get_timing(struct tegra30_emc_table *timing)
+static inline void emc_get_timing(struct tegra_emc_table *timing)
 {
        int i;
 
@@ -692,13 +691,10 @@ static inline void emc_get_timing(struct tegra30_emc_table *timing)
  */
 static inline void emc_cfg_power_restore(void)
 {
-       struct tegra30_emc_pdata *pdata;
        u32 reg = emc_readl(EMC_CFG);
        u32 pwr_mask = EMC_CFG_PWR_MASK;
 
-       pdata = emc_pdev->dev.platform_data;
-
-       if (pdata->tables[0].rev >= 0x32)
+       if (tegra_emc_table[0].rev >= 0x32)
                pwr_mask &= ~EMC_CFG_DYN_SREF_ENABLE;
 
        if ((reg ^ emc_cfg_saved) & pwr_mask) {
@@ -718,27 +714,24 @@ int tegra_emc_set_rate(unsigned long rate)
 {
        int i;
        u32 clk_setting;
-       struct tegra30_emc_pdata *pdata;
-       const struct tegra30_emc_table *last_timing;
+       const struct tegra_emc_table *last_timing;
        unsigned long flags;
 
-       if (!emc_pdev)
+       if (!tegra_emc_table)
                return -EINVAL;
 
-       pdata = emc_pdev->dev.platform_data;
-
        /* Table entries specify rate in kHz */
        rate = rate / 1000;
 
-       for (i = 0; i < pdata->num_tables; i++) {
+       for (i = 0; i < tegra_emc_table_size; i++) {
                if (tegra_emc_clk_sel[i].input == NULL)
                        continue;       /* invalid entry */
 
-               if (pdata->tables[i].rate == rate)
+               if (tegra_emc_table[i].rate == rate)
                        break;
        }
 
-       if (i >= pdata->num_tables)
+       if (i >= tegra_emc_table_size)
                return -EINVAL;
 
        if (!emc_timing) {
@@ -753,10 +746,10 @@ int tegra_emc_set_rate(unsigned long rate)
        clk_setting = tegra_emc_clk_sel[i].value;
 
        spin_lock_irqsave(&emc_access_lock, flags);
-       emc_set_clock(&pdata->tables[i], last_timing, clk_setting);
+       emc_set_clock(&tegra_emc_table[i], last_timing, clk_setting);
        if (!emc_timing)
                emc_cfg_power_restore();
-       emc_timing = &pdata->tables[i];
+       emc_timing = &tegra_emc_table[i];
        spin_unlock_irqrestore(&emc_access_lock, flags);
 
        emc_last_stats_update(i);
@@ -769,31 +762,28 @@ int tegra_emc_set_rate(unsigned long rate)
 /* Select the closest EMC rate that is higher than the requested rate */
 long tegra_emc_round_rate(unsigned long rate)
 {
-       struct tegra30_emc_pdata *pdata;
        int i;
        int best = -1;
        unsigned long distance = ULONG_MAX;
 
-       if (!emc_pdev)
+       if (!tegra_emc_table)
                return clk_get_rate_locked(emc); /* no table - no rate change */
 
        if (!emc_enable)
                return -EINVAL;
 
-       pdata = emc_pdev->dev.platform_data;
-
        pr_debug("%s: %lu\n", __func__, rate);
 
        /* Table entries specify rate in kHz */
        rate = rate / 1000;
 
-       for (i = 0; i < pdata->num_tables; i++) {
+       for (i = 0; i < tegra_emc_table_size; i++) {
                if (tegra_emc_clk_sel[i].input == NULL)
                        continue;       /* invalid entry */
 
-               if (pdata->tables[i].rate >= rate &&
-                   (pdata->tables[i].rate - rate) < distance) {
-                       distance = pdata->tables[i].rate - rate;
+               if (tegra_emc_table[i].rate >= rate &&
+                   (tegra_emc_table[i].rate - rate) < distance) {
+                       distance = tegra_emc_table[i].rate - rate;
                        best = i;
                }
        }
@@ -801,28 +791,25 @@ long tegra_emc_round_rate(unsigned long rate)
        if (best < 0)
                return -EINVAL;
 
-       pr_debug("%s: using %lu\n", __func__, pdata->tables[best].rate);
+       pr_debug("%s: using %lu\n", __func__, tegra_emc_table[best].rate);
 
-       return pdata->tables[best].rate * 1000;
+       return tegra_emc_table[best].rate * 1000;
 }
 
 struct clk *tegra_emc_predict_parent(unsigned long rate, u32 *div_value)
 {
-       struct tegra30_emc_pdata *pdata;
        int i;
 
-       if (!emc_pdev)
+       if (!tegra_emc_table)
                return NULL;
 
-       pdata = emc_pdev->dev.platform_data;
-
        pr_debug("%s: %lu\n", __func__, rate);
 
        /* Table entries specify rate in kHz */
        rate = rate / 1000;
 
-       for (i = 0; i < pdata->num_tables; i++) {
-               if (pdata->tables[i].rate == rate) {
+       for (i = 0; i < tegra_emc_table_size; i++) {
+               if (tegra_emc_table[i].rate == rate) {
                        *div_value = (tegra_emc_clk_sel[i].value &
                                EMC_CLK_DIV_MASK) >> EMC_CLK_DIV_SHIFT;
                        return tegra_emc_clk_sel[i].input;
@@ -852,7 +839,7 @@ static const struct clk_mux_sel *find_matching_input(
        return NULL;
 }
 
-static void adjust_emc_dvfs_table(const struct tegra30_emc_table *table,
+static void adjust_emc_dvfs_table(const struct tegra_emc_table *table,
                                  int table_size)
 {
        int i, j;
@@ -950,93 +937,40 @@ static struct notifier_block tegra_emc_resume_nb = {
        .priority = -1,
 };
 
-void tegra_emc_set_clk(struct clk *c)
-{
-       emc = c;
-}
-
-static int tegra_emc_probe(struct platform_device *pdev)
+void tegra_init_emc(const struct tegra_emc_table *table, int table_size)
 {
-       struct tegra30_emc_pdata *pdata = NULL;
-       struct resource *res;
        int i, mv;
        u32 reg, div_value;
        bool max_entry = false;
        unsigned long boot_rate, max_rate;
        const struct clk_mux_sel *sel;
-       struct clk *min_clk;
 
        emc_stats.clkchange_count = 0;
        spin_lock_init(&emc_stats.spinlock);
        emc_stats.last_update = get_jiffies_64();
        emc_stats.last_sel = TEGRA_EMC_TABLE_MAX_SIZE;
 
-       min_clk = clk_get(&pdev->dev, NULL);
-       if (IS_ERR(min_clk)) {
-               dev_err(&pdev->dev, "failed to get clock\n");
-               return -EINVAL;
-       }
-
-       dram_type = (emc_readl(EMC_FBIO_CFG5) &
-                    EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
-       if (dram_type == DRAM_TYPE_DDR3)
-               clk_set_rate(min_clk, EMC_MIN_RATE_DDR3);
-
-       dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
-       emc_cfg_saved = emc_readl(EMC_CFG);
-
        boot_rate = clk_get_rate(emc) / 1000;
        max_rate = clk_get_max_rate(emc) / 1000;
 
        if ((dram_type != DRAM_TYPE_DDR3) && (dram_type != DRAM_TYPE_LPDDR2)) {
                pr_err("tegra: not supported DRAM type %u\n", dram_type);
-               return -EINVAL;
+               return;
        }
 
        if (emc->parent != tegra_get_clock_by_name("pll_m")) {
                pr_err("tegra: boot parent %s is not supported by EMC DFS\n",
                        emc->parent->name);
-               return -EINVAL;
-       }
-
-       if (!emc_enable) {
-               dev_err(&pdev->dev, "disabled per module parameter\n");
-               return -ENODEV;
-       }
-
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       if (!res) {
-               dev_err(&pdev->dev, "missing register base\n");
-               return -ENOMEM;
-       }
-
-       emc_regbases[0] = devm_request_and_ioremap(&pdev->dev, res);
-       if (!emc_regbases[0]) {
-               dev_err(&pdev->dev, "failed to remap registers\n");
-               return -ENOMEM;
-       }
-
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-       if (!res) {
-               dev_err(&pdev->dev, "missing MC register base\n");
-               return -ENOMEM;
-       }
-
-       emc_regbases[1] = devm_request_and_ioremap(&pdev->dev, res);
-       if (!emc_regbases[1]) {
-               dev_err(&pdev->dev, "failed to remap MC registers\n");
-               return -ENOMEM;
+               return;
        }
 
-       pdev->dev.platform_data = pdata;
-
-       if (!pdata->tables || !pdata->num_tables) {
+       if (!table || !table_size) {
                pr_err("tegra: EMC DFS table is empty\n");
-               return -EINVAL;
+               return;
        }
 
-       pdata->num_tables = min(pdata->num_tables, TEGRA_EMC_TABLE_MAX_SIZE);
-       switch (pdata->tables[0].rev) {
+       tegra_emc_table_size = min(table_size, TEGRA_EMC_TABLE_MAX_SIZE);
+       switch (table[0].rev) {
        case 0x30:
                emc_num_burst_regs = 105;
                break;
@@ -1047,17 +981,17 @@ static int tegra_emc_probe(struct platform_device *pdev)
                break;
        default:
                pr_err("tegra: invalid EMC DFS table: unknown rev 0x%x\n",
-                       pdata->tables[0].rev);
-               return -EINVAL;
+                       table[0].rev);
+               return;
        }
 
        /* Match EMC source/divider settings with table entries */
-       for (i = 0; i < pdata->num_tables; i++) {
-               unsigned long table_rate = pdata->tables[i].rate;
+       for (i = 0; i < tegra_emc_table_size; i++) {
+               unsigned long table_rate = table[i].rate;
                if (!table_rate)
                        continue;
 
-               BUG_ON(pdata->tables[i].rev != pdata->tables[0].rev);
+               BUG_ON(table[i].rev != table[0].rev);
 
                sel = find_matching_input(table_rate, &div_value);
                if (!sel)
@@ -1080,7 +1014,7 @@ static int tegra_emc_probe(struct platform_device *pdev)
                        tegra_emc_clk_sel[i].value |= EMC_CLK_LOW_JITTER_ENABLE;
                }
 
-               if (pdata->tables[i].burst_regs[MC_EMEM_ARB_MISC0_INDEX] &
+               if (table[i].burst_regs[MC_EMEM_ARB_MISC0_INDEX] &
                    MC_EMEM_ARB_MISC0_EMC_SAME_FREQ)
                        tegra_emc_clk_sel[i].value |= EMC_CLK_MC_SAME_FREQ;
        }
@@ -1089,21 +1023,25 @@ static int tegra_emc_probe(struct platform_device *pdev)
        if (!max_entry) {
                pr_err("tegra: invalid EMC DFS table: entry for max rate"
                       " %lu kHz is not found\n", max_rate);
-               return -EINVAL;
+               return;
        }
 
-       adjust_emc_dvfs_table(pdata->tables, pdata->num_tables);
+       tegra_emc_table = table;
+
+       adjust_emc_dvfs_table(tegra_emc_table, tegra_emc_table_size);
        mv = tegra_dvfs_predict_millivolts(emc, max_rate * 1000);
        if ((mv <= 0) || (mv > emc->dvfs->max_millivolts)) {
+               tegra_emc_table = NULL;
                pr_err("tegra: invalid EMC DFS table: maximum rate %lu kHz does"
                       " not match nominal voltage %d\n",
                       max_rate, emc->dvfs->max_millivolts);
-               return -EINVAL;
+               return;
        }
 
        if (!is_emc_bridge()) {
+               tegra_emc_table = NULL;
                pr_err("tegra: invalid EMC DFS table: emc bridge not found");
-               return -EINVAL;
+               return;
        }
        pr_info("tegra: validated EMC DFS table\n");
 
@@ -1113,28 +1051,10 @@ static int tegra_emc_probe(struct platform_device *pdev)
                EMC_CFG_2_SREF_MODE) << EMC_CFG_2_MODE_SHIFT;
        emc_writel(reg, EMC_CFG_2);
 
-       emc_pdev = pdev;
-
        register_pm_notifier(&tegra_emc_suspend_nb);
        register_pm_notifier(&tegra_emc_resume_nb);
-
-       return 0;
 }
 
-static struct platform_driver tegra_emc_driver = {
-       .driver         = {
-               .name   = "tegra30-emc",
-               .owner  = THIS_MODULE,
-       },
-       .probe          = tegra_emc_probe,
-};
-
-static int __init tegra_emc_init(void)
-{
-       return platform_driver_register(&tegra_emc_driver);
-}
-device_initcall(tegra_emc_init);
-
 void tegra_emc_timing_invalidate(void)
 {
        emc_timing = NULL;
@@ -1146,6 +1066,19 @@ void tegra_init_dram_bit_map(const u32 *bit_map, int map_size)
        dram_to_soc_bit_map = bit_map;
 }
 
+void tegra_emc_dram_type_init(struct clk *c)
+{
+       emc = c;
+
+       dram_type = (emc_readl(EMC_FBIO_CFG5) &
+                    EMC_CFG5_TYPE_MASK) >> EMC_CFG5_TYPE_SHIFT;
+       if (dram_type == DRAM_TYPE_DDR3)
+               emc->min_rate = EMC_MIN_RATE_DDR3;
+
+       dram_dev_num = (mc_readl(MC_EMEM_ADR_CFG) & 0x1) + 1; /* 2 dev max */
+       emc_cfg_saved = emc_readl(EMC_CFG);
+}
+
 int tegra_emc_get_dram_type(void)
 {
        return dram_type;
@@ -1262,19 +1195,16 @@ static struct dentry *emc_debugfs_root;
 
 static int emc_stats_show(struct seq_file *s, void *data)
 {
-       struct tegra30_emc_pdata *pdata;
        int i;
 
-       pdata = emc_pdev->dev.platform_data;
-
        emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE);
 
        seq_printf(s, "%-10s %-10s \n", "rate kHz", "time");
-       for (i = 0; i < pdata->num_tables; i++) {
+       for (i = 0; i < tegra_emc_table_size; i++) {
                if (tegra_emc_clk_sel[i].input == NULL)
                        continue;       /* invalid entry */
 
-               seq_printf(s, "%-10lu %-10llu \n", pdata->tables[i].rate,
+               seq_printf(s, "%-10lu %-10llu \n", tegra_emc_table[i].rate,
                           cputime64_to_clock_t(emc_stats.time_at_clock[i]));
        }
        seq_printf(s, "%-15s %llu\n", "transitions:",
@@ -1357,7 +1287,7 @@ DEFINE_SIMPLE_ATTRIBUTE(efficiency_fops, efficiency_get,
 
 static int __init tegra_emc_debug_init(void)
 {
-       if (!emc_pdev)
+       if (!tegra_emc_table)
                return 0;
 
        emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL);
index 0e7026c..185d777 100644 (file)
 #ifndef _MACH_TEGRA_TEGRA3_EMC_H
 #define _MACH_TEGRA_TEGRA3_EMC_H
 
+#define TEGRA_EMC_NUM_REGS     110
+
 #define TEGRA_EMC_BRIDGE_RATE_MIN      300000000
 #define TEGRA_EMC_BRIDGE_MVOLTS_MIN    1200
 
 extern u8 tegra_emc_bw_efficiency;
 
+struct tegra_emc_table {
+       u8 rev;
+       unsigned long rate;
+
+       /* unconditionally updated in one burst shot */
+       u32 burst_regs[TEGRA_EMC_NUM_REGS];
+
+       /* updated separately under some conditions */
+       u32 emc_zcal_cnt_long;
+       u32 emc_acal_interval;
+       u32 emc_periodic_qrst;
+       u32 emc_mode_reset;
+       u32 emc_mode_1;
+       u32 emc_mode_2;
+       u32 emc_dsr;
+       int emc_min_mv;
+};
+
 enum {
        DRAM_OVER_TEMP_NONE = 0,
        DRAM_OVER_TEMP_REFRESH,
@@ -34,8 +54,10 @@ enum {
 
 struct clk;
 
+void tegra_init_emc(const struct tegra_emc_table *table, int table_size);
+
 void tegra_init_dram_bit_map(const u32 *bit_map, int map_size);
-void tegra_emc_set_clk(struct clk *c);
+void tegra_emc_dram_type_init(struct clk *c);
 int tegra_emc_get_dram_type(void);
 int tegra_emc_get_dram_temperature(void);
 int tegra_emc_set_over_temp_state(unsigned long state);
index 2057fbd..0268b82 100644 (file)
@@ -102,7 +102,7 @@ static int tegra_thermal_zone_unbind(struct thermal_zone_device *thermal,
 }
 
 static int tegra_thermal_zone_get_temp(struct thermal_zone_device *thz,
-                                               long *temp)
+                                       unsigned long *temp)
 {
        struct tegra_thermal *thermal = thz->devdata;
        thermal->device->get_temp(thermal->device->data, temp);
@@ -125,8 +125,8 @@ static int tegra_thermal_zone_get_trip_type(
 }
 
 static int tegra_thermal_zone_get_trip_temp(struct thermal_zone_device *thz,
-                                               int trip,
-                                               long *temp) {
+                                       int trip,
+                                       unsigned long *temp) {
        struct tegra_thermal *thermal = thz->devdata;
 
        /* Support only Thermal Throttling (1 trip) for now */
index b210161..45f12ec 100644 (file)
@@ -31,7 +31,7 @@
 #include <linux/export.h>
 
 #include <asm/mach/time.h>
-#include <asm/smp_twd.h>
+#include <asm/localtimer.h>
 #include <asm/sched_clock.h>
 
 #include <mach/irqs.h>
@@ -59,6 +59,7 @@
 #define timer_readl(reg) \
        __raw_readl(timer_reg_base + (reg))
 
+
 static void __iomem *timer_reg_base = IO_ADDRESS(TEGRA_TMR1_BASE);
 
 #ifdef CONFIG_PM_SLEEP
@@ -92,27 +93,10 @@ unsigned long tegra2_lp2_timer_remain(void)
 }
 #endif
 
-void __init tegra2_init_timer(u32 *offset, int *irq, unsigned long rate)
+void __init tegra20_init_timer(void)
 {
        int ret;
 
-       switch (rate) {
-       case 12000000:
-               timer_writel(0x000b, TIMERUS_USEC_CFG);
-               break;
-       case 13000000:
-               timer_writel(0x000c, TIMERUS_USEC_CFG);
-               break;
-       case 19200000:
-               timer_writel(0x045f, TIMERUS_USEC_CFG);
-               break;
-       case 26000000:
-               timer_writel(0x0019, TIMERUS_USEC_CFG);
-               break;
-       default:
-               WARN(1, "Unknown clock rate");
-       }
-
 #ifdef CONFIG_PM_SLEEP
        ret = setup_irq(tegra_lp2wake_irq.irq, &tegra_lp2wake_irq);
        if (ret) {
@@ -120,7 +104,4 @@ void __init tegra2_init_timer(u32 *offset, int *irq, unsigned long rate)
                BUG();
        }
 #endif
-
-       *offset = TIMER3_OFFSET;
-       *irq = INT_TMR3;
 }
index 05a881f..52c8c44 100644 (file)
 #include <asm/localtimer.h>
 #include <asm/sched_clock.h>
 
-#include <mach/hardware.h>
 #include <mach/iomap.h>
 #include <mach/irqs.h>
+#include <mach/hardware.h>
 
 #include "board.h"
 #include "clock.h"
 #include "cpuidle.h"
 #include "timer.h"
+#include "fuse.h"
 
 #define TEST_LP2_WAKE_TIMERS   0
 
@@ -258,47 +259,18 @@ void tegra3_lp2_timer_cancel_secondary(void)
 }
 #endif
 
-void __init tegra3_init_timer(u32 *offset, int *irq, unsigned long rate)
+void __init tegra30_init_timer(void)
 {
-       switch (rate) {
-       case 12000000:
-               timer_writel(0x000b, TIMERUS_USEC_CFG);
-               break;
-       case 13000000:
-               timer_writel(0x000c, TIMERUS_USEC_CFG);
-               break;
-       case 19200000:
-               timer_writel(0x045f, TIMERUS_USEC_CFG);
-               break;
-       case 26000000:
-               timer_writel(0x0019, TIMERUS_USEC_CFG);
-               break;
-       case 16800000:
-               timer_writel(0x0453, TIMERUS_USEC_CFG);
-               break;
-       case 38400000:
-               timer_writel(0x04BF, TIMERUS_USEC_CFG);
-               break;
-       case 48000000:
-               timer_writel(0x002F, TIMERUS_USEC_CFG);
-               break;
-       default:
-               WARN(1, "Unknown clock rate");
-       }
-
 #ifdef CONFIG_PM_SLEEP
 #ifdef CONFIG_SMP
        /* For T30.A01 use INT_TMR_SHARED instead of INT_TMR6 for CPU3. */
-       if ((tegra_chip_id == TEGRA30) &&
+       if ((tegra_get_chipid() == TEGRA_CHIPID_TEGRA3) &&
                (tegra_revision == TEGRA_REVISION_A01))
                        tegra_lp2wake_irq[3].irq = INT_TMR_SHARED;
 #endif
 
        tegra3_register_wake_timer(0);
 #endif
-
-       *offset = TIMER1_OFFSET;
-       *irq = INT_TMR1;
 }
 
 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_HOTPLUG_CPU)
index 9e0a1d0..4b3d251 100644 (file)
@@ -7,7 +7,7 @@
  * Author:
  *     Colin Cross <ccross@google.com>
  *
- * Copyright (C) 2010-2011 NVIDIA Corporation.
+ * Copyright (C) 2010-2012 NVIDIA Corporation.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
@@ -33,7 +33,6 @@
 
 #include <asm/mach/time.h>
 #include <asm/delay.h>
-#include <asm/localtimer.h>
 #include <asm/smp_twd.h>
 #include <asm/sched_clock.h>
 
@@ -53,7 +52,11 @@ static u32 usec_config;
 static u32 usec_offset;
 static bool usec_suspended;
 
-static u32 system_timer;
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+static u32 system_timer = (TEGRA_TMR3_BASE - TEGRA_TMR1_BASE);
+#else
+static u32 system_timer = 0;
+#endif
 
 #define timer_writel(value, reg) \
        __raw_writel(value, timer_reg_base + (reg))
@@ -162,6 +165,11 @@ static struct irqaction tegra_timer_irq = {
        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_TRIGGER_HIGH,
        .handler        = tegra_timer_interrupt,
        .dev_id         = &tegra_clockevent,
+#ifdef CONFIG_ARCH_TEGRA_2x_SOC
+       .irq            = INT_TMR3,
+#else
+       .irq            = INT_TMR1,
+#endif
 };
 
 static int tegra_timer_suspend(void)
@@ -191,6 +199,7 @@ static struct syscore_ops tegra_timer_syscore_ops = {
 static DEFINE_TWD_LOCAL_TIMER(twd_local_timer,
                              TEGRA_ARM_PERIF_BASE + 0x600,
                              IRQ_LOCALTIMER);
+static void __iomem *tegra_twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
 
 static void __init tegra_twd_init(void)
 {
@@ -201,17 +210,17 @@ static void __init tegra_twd_init(void)
 
 int tegra_twd_get_state(struct tegra_twd_context *context)
 {
-       context->twd_ctrl = readl(twd_base + TWD_TIMER_CONTROL);
-       context->twd_load = readl(twd_base + TWD_TIMER_LOAD);
-       context->twd_cnt = readl(twd_base + TWD_TIMER_COUNTER);
+       context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
+       context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
+       context->twd_cnt = readl(tegra_twd_base + TWD_TIMER_COUNTER);
 
        return 0;
 }
 
 void tegra_twd_suspend(struct tegra_twd_context *context)
 {
-       context->twd_ctrl = readl(twd_base + TWD_TIMER_CONTROL);
-       context->twd_load = readl(twd_base + TWD_TIMER_LOAD);
+       context->twd_ctrl = readl(tegra_twd_base + TWD_TIMER_CONTROL);
+       context->twd_load = readl(tegra_twd_base + TWD_TIMER_LOAD);
        if ((context->twd_load == 0) &&
            (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
            (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
@@ -219,7 +228,7 @@ void tegra_twd_suspend(struct tegra_twd_context *context)
                WARN("%s: TWD enabled but counter was 0\n", __func__);
                context->twd_load = 1;
        }
-       __raw_writel(0, twd_base + TWD_TIMER_CONTROL);
+       __raw_writel(0, tegra_twd_base + TWD_TIMER_CONTROL);
 }
 
 void tegra_twd_resume(struct tegra_twd_context *context)
@@ -228,11 +237,14 @@ void tegra_twd_resume(struct tegra_twd_context *context)
               (context->twd_ctrl & TWD_TIMER_CONTROL_PERIODIC) &&
               (context->twd_ctrl & (TWD_TIMER_CONTROL_ENABLE |
                                     TWD_TIMER_CONTROL_IT_ENABLE)));
-       writel(context->twd_load, twd_base + TWD_TIMER_LOAD);
-       writel(context->twd_ctrl, twd_base + TWD_TIMER_CONTROL);
+       writel(context->twd_load, tegra_twd_base + TWD_TIMER_LOAD);
+       writel(context->twd_ctrl, tegra_twd_base + TWD_TIMER_CONTROL);
 }
 #else
 #define tegra_twd_init()       do {} while(0)
+#define tegra_twd_get_state    do {} while(0)
+#define tegra_twd_suspend      do {} while(0)
+#define tegra_twd_resume       do {} while(0)
 #endif
 
 extern void __tegra_delay(unsigned long cycles);
@@ -264,10 +276,38 @@ void __init tegra_init_timer(void)
        else
                clk_prepare_enable(clk);
 
+       switch (rate) {
+       case 12000000:
+               timer_writel(0x000b, TIMERUS_USEC_CFG);
+               break;
+       case 13000000:
+               timer_writel(0x000c, TIMERUS_USEC_CFG);
+               break;
+       case 19200000:
+               timer_writel(0x045f, TIMERUS_USEC_CFG);
+               break;
+       case 26000000:
+               timer_writel(0x0019, TIMERUS_USEC_CFG);
+               break;
+#ifndef CONFIG_ARCH_TEGRA_2x_SOC
+       case 16800000:
+               timer_writel(0x0453, TIMERUS_USEC_CFG);
+               break;
+       case 38400000:
+               timer_writel(0x04BF, TIMERUS_USEC_CFG);
+               break;
+       case 48000000:
+               timer_writel(0x002F, TIMERUS_USEC_CFG);
+               break;
+#endif
+       default:
+               WARN(1, "Unknown clock rate");
+       }
+
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
-       tegra2_init_timer(&system_timer, &tegra_timer_irq.irq, rate);
+       tegra20_init_timer();
 #else
-       tegra3_init_timer(&system_timer, &tegra_timer_irq.irq, rate);
+       tegra30_init_timer();
 #endif
 
        setup_sched_clock(tegra_read_sched_clock, 32, 1000000);
@@ -293,8 +333,8 @@ void __init tegra_init_timer(void)
        tegra_clockevent.irq = tegra_timer_irq.irq;
        clockevents_register_device(&tegra_clockevent);
 
-       tegra_twd_init();
        register_syscore_ops(&tegra_timer_syscore_ops);
+       tegra_twd_init();
 
        register_persistent_clock(NULL, tegra_read_persistent_clock);
 
index ee87164..250a99a 100644 (file)
 #ifndef _MACH_TEGRA_TIMER_H_
 #define _MACH_TEGRA_TIMER_H_
 
-#include <linux/io.h>
-
 #define RTC_SECONDS            0x08
 #define RTC_SHADOW_SECONDS     0x0c
 #define RTC_MILLISECONDS       0x10
 
-#define TIMER_PTV              0x0
-#define TIMER_PCR              0x4
-
 #define TIMERUS_CNTR_1US       0x10
 #define TIMERUS_USEC_CFG       0x14
 #define TIMERUS_CNTR_FREEZE    0x4c
 
+#define TIMER1_BASE            0x0
+#define TIMER2_BASE            0x8
+#define TIMER3_BASE            0x50
+#define TIMER4_BASE            0x58
+
+#define TIMER_PTV              0x0
+#define TIMER_PCR              0x4
+
+void __init tegra_init_timer(void);
 
 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
-void __init tegra2_init_timer(u32 *offset, int *irq, unsigned long rate);
+void __init tegra20_init_timer(void);
 #else
-void __init tegra3_init_timer(u32 *offset, int *irq, unsigned long rate);
+void __init tegra30_init_timer(void);
 #endif
 
 struct tegra_twd_context {
@@ -44,7 +48,6 @@ struct tegra_twd_context {
 };
 
 #ifdef CONFIG_HAVE_ARM_TWD
-static void __iomem *twd_base = IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x600);
 int tegra_twd_get_state(struct tegra_twd_context *context);
 void tegra_twd_suspend(struct tegra_twd_context *context);
 void tegra_twd_resume(struct tegra_twd_context *context);
index abaf231..7d5489e 100644 (file)
@@ -24,7 +24,9 @@
 #include <linux/mm.h>
 #include <linux/platform_device.h>
 #include <linux/miscdevice.h>
+#include <linux/export.h>
 #include <linux/module.h>
+
 #include <mach/iomap.h>
 
 #include "timer.h"
index 27c3e03..2f2470b 100644 (file)
@@ -689,7 +689,8 @@ static void l2x0_resume(void)
 {
        if (!(readl_relaxed(l2x0_base + L2X0_CTRL) & L2X0_CTRL_EN)) {
                /* restore aux ctrl and enable l2 */
-               l2x0_unlock(readl_relaxed(l2x0_base + L2X0_CACHE_ID));
+               l2x0_unlock(readl_relaxed(l2x0_base + L2X0_CACHE_ID) &
+                       L2X0_CACHE_ID_PART_MASK);
 
                writel_relaxed(l2x0_saved_regs.aux_ctrl, l2x0_base +
                        L2X0_AUX_CTRL);
index 010b5a4..349336e 100644 (file)
@@ -133,7 +133,7 @@ ENDPROC(cpu_v7_dcache_clean_area)
 .equ   cpu_v7_suspend_size, (4 * 9) + cpu_v7_debug_suspend_size
 #ifdef CONFIG_ARM_CPU_SUSPEND
 ENTRY(cpu_v7_do_suspend)
-       stmfd   sp!, {r4 - r10, lr}
+       stmfd   sp!, {r3 - r10, lr}
        mrc     p15, 0, r4, c13, c0, 0  @ FCSE/PID
        mrc     p15, 0, r5, c13, c0, 3  @ User r/o thread ID
        mrc     p15, 0, r6, c15, c0, 1  @ diag
@@ -169,7 +169,7 @@ ENTRY(cpu_v7_do_suspend)
 
        mrc     p14, 0, r8, c0, c0, 0   @ read IDR
        mov     r3, r8, lsr #24
-       and     r3, r3, #0xf            @ r3 has the number of brkpt
+       and     r3, r3, #0xf            @ r3 has the number of brkpt
        rsb     r3, r3, #0xf
 
        /* r3 = (15 - #of brkpt) ;
@@ -196,7 +196,7 @@ ENTRY(cpu_v7_do_suspend)
        save_brkpt      c1
        save_brkpt      c0
 
-       mov     r3, r8, lsr #28         @ r3 has the number of wpt
+       mov     r3, r8, lsr #28         @ r3 has the number of wpt
        rsb     r3, r3, #0xf
 
        /* r3 = (15 - #of wpt) ;
@@ -223,7 +223,7 @@ ENTRY(cpu_v7_do_suspend)
        save_wpt        c1
        save_wpt        c0
 #endif
-       ldmfd   sp!, {r4 - r10, pc}
+       ldmfd   sp!, {r3 - r10, pc}
 ENDPROC(cpu_v7_do_suspend)
 
 ENTRY(cpu_v7_do_resume)
@@ -258,6 +258,7 @@ ENTRY(cpu_v7_do_resume)
 
 #ifdef CONFIG_ARM_SAVE_DEBUG_CONTEXT
        /* Restore CP14 debug controller context */
+
        ldmia   r0!, {r2 - r5}
        mcr     p14, 0, r3, c0, c6, 0   @ DBGWFAR
        mcr     p14, 0, r4, c0, c7, 0   @ DBGVCR
@@ -275,15 +276,14 @@ ENTRY(cpu_v7_do_resume)
        ldrne   r4, [r0], #4
        mcrne   p14, 0, r4, c0, c0, 2   @ DBGDTRRXext
 
-       mrc     p14, 0, r6, c0, c0, 0   @ read IDR
-       mov     r3, r6, lsr #24
-       and     r3, r3, #0xf            @ r3 has the number of brkpt
+       mrc     p14, 0, r5, c0, c0, 0   @ read IDR
+       mov     r3, r5, lsr #24
+       and     r3, r3, #0xf            @ r3 has the number of brkpt
        rsb     r3, r3, #0xf
 
-       /*
-        * r3 = (15 - # of wpt) ;
-        * switch offset = r3*12 - 4 = (r3*3 - 1)<<2
-        */
+       /* r3 = (15 - #of wpt) ;
+          switch offset = r3*12 - 4 = (r3*3 - 1)<<2
+       */
        add     r3, r3, r3, lsl #1
        sub     r3, r3, #1
        add     pc, pc, r3, lsl #2
@@ -305,7 +305,7 @@ ENTRY(cpu_v7_do_resume)
        restore_brkpt   c1
        restore_brkpt   c0
 
-       mov     r3, r6, lsr #28         @ r3 has the number of wpt
+       mov     r3, r5, lsr #28         @ r3 has the number of wpt
        rsb     r3, r3, #0xf
 
        /* r3 = (15 - #of wpt) ;
index 1ce8966..81a5f5e 100644 (file)
@@ -40,6 +40,19 @@ DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, init_tss) = INIT_TSS;
 
 #ifdef CONFIG_X86_64
 static DEFINE_PER_CPU(unsigned char, is_idle);
+static ATOMIC_NOTIFIER_HEAD(idle_notifier);
+
+void idle_notifier_register(struct notifier_block *n)
+{
+       atomic_notifier_chain_register(&idle_notifier, n);
+}
+EXPORT_SYMBOL_GPL(idle_notifier_register);
+
+void idle_notifier_unregister(struct notifier_block *n)
+{
+       atomic_notifier_chain_unregister(&idle_notifier, n);
+}
+EXPORT_SYMBOL_GPL(idle_notifier_unregister);
 #endif
 
 struct kmem_cache *task_xstate_cachep;
@@ -244,14 +257,14 @@ static inline void play_dead(void)
 void enter_idle(void)
 {
        this_cpu_write(is_idle, 1);
-       idle_notifier_call_chain(IDLE_START);
+       atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
 }
 
 static void __exit_idle(void)
 {
        if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
                return;
-       idle_notifier_call_chain(IDLE_END);
+       atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
 }
 
 /* Called from interrupts to signify idle end */
index 79715e7..f3ceabe 100644 (file)
@@ -696,14 +696,22 @@ bool pm_wakeup_pending(void)
 {
        unsigned long flags;
        bool ret = false;
+       unsigned int cnt, inpr;
 
+       /**
+        * HACK: return true if event is in progress even though
+        * check is not enabled. This causes suspend to abort
+        * if wake_lock is acquired before starting suspend
+        * process and user has not enabled check. This HACK is for
+        * android wake locks to work.
+        */
        spin_lock_irqsave(&events_lock, flags);
+       split_counters(&cnt, &inpr);
        if (events_check_enabled) {
-               unsigned int cnt, inpr;
-
-               split_counters(&cnt, &inpr);
                ret = (cnt != saved_count || inpr > 0);
                events_check_enabled = !ret;
+       } else if (inpr > 0) {
+               ret = true;
        }
        spin_unlock_irqrestore(&events_lock, flags);
 
index bc68a44..f7f7106 100644 (file)
@@ -327,12 +327,12 @@ static void hci_uart_tty_close(struct tty_struct *tty)
                hci_uart_close(hdev);
 
        if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
+               hu->proto->close(hu);
                if (hdev) {
                        if (test_bit(HCI_UART_REGISTERED, &hu->flags))
                                hci_unregister_dev(hdev);
                        hci_free_dev(hdev);
                }
-               hu->proto->close(hu);
        }
 
        kfree(hu);
index b3d7efd..508dbaa 100644 (file)
@@ -6,6 +6,8 @@
  * Author:
  *     Erik Gilling <konkers@google.com>
  *
+ * Copyright (c) 2011 NVIDIA Corporation.
+ *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
@@ -79,6 +81,7 @@ struct tegra_gpio_bank {
 
 static struct irq_domain *irq_domain;
 static void __iomem *regs;
+
 static u32 tegra_gpio_bank_count;
 static u32 tegra_gpio_bank_stride;
 static u32 tegra_gpio_upper_offset;
@@ -587,6 +590,7 @@ static int dbg_gpio_show(struct seq_file *s, void *unused)
        int i;
        int j;
 
+       seq_printf(s, "Bank:Port CNF OE OUT IN INT_STA INT_ENB INT_LVL\n");
        for (i = 0; i < tegra_gpio_bank_count; i++) {
                for (j = 0; j < 4; j++) {
                        int gpio = tegra_gpio_compose(i, j, 0);
index 312098e..01dc3a2 100644 (file)
@@ -192,6 +192,26 @@ static int sixaxis_set_operational_bt(struct hid_device *hdev)
        return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
 }
 
+static void sixaxis_set_led_bt(struct hid_device *hdev)
+{
+       hid_info(hdev, "set LED BT\n");
+       /* set first LED on BT connection */
+       unsigned char led_data[] = {
+                       0x01,
+                       /* rumble values */
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                       /* LED settings 0x02=LED1 .. 0x10=LED4 */
+                       0x02,
+                       0xff, 0x27, 0x10, 0x00, 0x32,   /* LED 4 */
+                       0xff, 0x27, 0x10, 0x00, 0x32,   /* LED 3 */
+                       0xff, 0x27, 0x10, 0x00, 0x32,   /* LED 2 */
+                       0xff, 0x27, 0x10, 0x00, 0x32,   /* LED 1 */
+                       0x00, 0x00, 0x00, 0x00, 0x00
+               };
+       hdev->hid_output_raw_report(hdev, led_data, sizeof(led_data),
+                                       HID_OUTPUT_REPORT);
+}
+
 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
        int ret;
@@ -224,8 +244,11 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
                hdev->hid_output_raw_report = sixaxis_usb_output_raw_report;
                ret = sixaxis_set_operational_usb(hdev);
        }
-       else if (sc->quirks & SIXAXIS_CONTROLLER_BT)
+       else if (sc->quirks & SIXAXIS_CONTROLLER_BT) {
                ret = sixaxis_set_operational_bt(hdev);
+               if (ret >= 0)
+                       sixaxis_set_led_bt(hdev);
+       }
        else
                ret = 0;
 
index af6c320..21c8f48 100644 (file)
@@ -409,12 +409,6 @@ static int ak8975_probe(struct i2c_client *client,
        }
        data = iio_priv(indio_dev);
        i2c_set_clientdata(client, indio_dev);
-       /* Perform some basic start-of-day setup of the device. */
-       err = ak8975_setup(client);
-       if (err < 0) {
-               dev_err(&client->dev, "AK8975 initialization fails\n");
-               goto exit_free_iio;
-       }
 
        data->client = client;
        mutex_init(&data->lock);
@@ -425,6 +419,13 @@ static int ak8975_probe(struct i2c_client *client,
        indio_dev->info = &ak8975_info;
        indio_dev->modes = INDIO_DIRECT_MODE;
 
+       /* Perform some basic start-of-day setup of the device. */
+       err = ak8975_setup(client);
+       if (err < 0) {
+               dev_err(&client->dev, "AK8975 initialization fails\n");
+               goto exit_free_iio;
+       }
+
        err = iio_device_register(indio_dev);
        if (err < 0)
                goto exit_free_iio;
index 4396fa6..88497db 100644 (file)
@@ -161,3 +161,4 @@ obj-$(CONFIG_MFD_MAX8907C)  += max8907c.o
 obj-$(CONFIG_MFD_MAX8907C)     += max8907c-irq.o
 obj-$(CONFIG_MFD_MAX77663)     += max77663-core.o
 obj-$(CONFIG_MFD_RICOH583)     += ricoh583.o
+obj-$(CONFIG_MFD_RC5T583)      += rc5t583.o rc5t583-irq.o
index ba85a00..f8964cb 100644 (file)
@@ -275,6 +275,7 @@ static int max8907c_i2c_probe(struct i2c_client *i2c,
        struct max8907c_platform_data *pdata = i2c->dev.platform_data;
        int ret;
        int i;
+       u8 tmp;
 
        max8907c = kzalloc(sizeof(struct max8907c), GFP_KERNEL);
        if (max8907c == NULL)
@@ -298,7 +299,7 @@ static int max8907c_i2c_probe(struct i2c_client *i2c,
        ret = mfd_add_devices(max8907c->dev, -1, cells, ARRAY_SIZE(cells),
                              NULL, 0);
        if (ret != 0) {
-               i2c_unregister_device(max8907c->i2c_rtc);
+               i2c_unregister_device(max8907c->i2c_rtc);
                kfree(max8907c);
                pr_debug("max8907c: failed to add MFD devices   %X\n", ret);
                return ret;
@@ -313,6 +314,18 @@ static int max8907c_i2c_probe(struct i2c_client *i2c,
        if (pdata->use_power_off && !pm_power_off)
                pm_power_off = max8907c_power_off;
 
+       ret = max8907c_i2c_read(i2c, MAX8907C_REG_SYSENSEL, 1, &tmp);
+       /*Mask HARD RESET, if enabled */
+       if (ret == 0) {
+               tmp &= ~(BIT(7));
+               ret = max8907c_i2c_write(i2c, MAX8907C_REG_SYSENSEL, 1, &tmp);
+       }
+
+       if (ret != 0) {
+               pr_err("Failed to write max8907c I2C driver: %d\n", ret);
+               return ret;
+       }
+
        if (pdata->max8907c_setup)
                return pdata->max8907c_setup();
 
index d5ed6a2..d767ea0 100644 (file)
 #include <linux/scatterlist.h>
 #include <linux/uaccess.h>
 #include <crypto/rng.h>
+#include <crypto/hash.h>
+#include <mach/hardware.h>
 
 #include "tegra-cryptodev.h"
 
 #define NBUFS 2
+#define XBUFSIZE 8
 
 struct tegra_crypto_ctx {
        struct crypto_ablkcipher *ecb_tfm;
        struct crypto_ablkcipher *cbc_tfm;
+       struct crypto_ablkcipher *ofb_tfm;
+       struct crypto_ablkcipher *ctr_tfm;
+       struct crypto_ablkcipher *cmac_tfm;
        struct crypto_rng *rng;
        u8 seed[TEGRA_CRYPTO_RNG_SEED_SIZE];
        int use_ssk;
@@ -105,6 +111,26 @@ static int tegra_crypto_dev_open(struct inode *inode, struct file *filp)
                goto fail_cbc;
        }
 
+       if (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2) {
+               ctx->ofb_tfm = crypto_alloc_ablkcipher("ofb-aes-tegra",
+                       CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 0);
+               if (IS_ERR(ctx->ofb_tfm)) {
+                       pr_err("Failed to load transform for ofb-aes-tegra: %ld\n",
+                               PTR_ERR(ctx->ofb_tfm));
+                       ret = PTR_ERR(ctx->ofb_tfm);
+                       goto fail_ofb;
+               }
+
+               ctx->ctr_tfm = crypto_alloc_ablkcipher("ctr-aes-tegra",
+                       CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC, 0);
+               if (IS_ERR(ctx->ctr_tfm)) {
+                       pr_err("Failed to load transform for ctr-aes-tegra: %ld\n",
+                               PTR_ERR(ctx->ctr_tfm));
+                       ret = PTR_ERR(ctx->ctr_tfm);
+                       goto fail_ctr;
+               }
+       }
+
        ctx->rng = crypto_alloc_rng("rng-aes-tegra", CRYPTO_ALG_TYPE_RNG, 0);
        if (IS_ERR(ctx->rng)) {
                pr_err("Failed to load transform for tegra rng: %ld\n",
@@ -117,6 +143,12 @@ static int tegra_crypto_dev_open(struct inode *inode, struct file *filp)
        return ret;
 
 fail_rng:
+       if (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2)
+               crypto_free_ablkcipher(ctx->ctr_tfm);
+fail_ctr:
+       if (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2)
+               crypto_free_ablkcipher(ctx->ofb_tfm);
+fail_ofb:
        crypto_free_ablkcipher(ctx->cbc_tfm);
 
 fail_cbc:
@@ -133,6 +165,12 @@ static int tegra_crypto_dev_release(struct inode *inode, struct file *filp)
 
        crypto_free_ablkcipher(ctx->ecb_tfm);
        crypto_free_ablkcipher(ctx->cbc_tfm);
+
+       if (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2) {
+               crypto_free_ablkcipher(ctx->ofb_tfm);
+               crypto_free_ablkcipher(ctx->ctr_tfm);
+       }
+
        crypto_free_rng(ctx->rng);
        kfree(ctx);
        filp->private_data = NULL;
@@ -158,16 +196,27 @@ static int process_crypt_req(struct tegra_crypto_ctx *ctx, struct tegra_crypt_re
        unsigned long *xbuf[NBUFS];
        int ret = 0, size = 0;
        unsigned long total = 0;
-       struct tegra_crypto_completion tcrypt_complete;
        const u8 *key = NULL;
+       struct tegra_crypto_completion tcrypt_complete;
 
        if (crypt_req->op & TEGRA_CRYPTO_ECB) {
                req = ablkcipher_request_alloc(ctx->ecb_tfm, GFP_KERNEL);
                tfm = ctx->ecb_tfm;
-       } else {
+       } else if (crypt_req->op & TEGRA_CRYPTO_CBC) {
                req = ablkcipher_request_alloc(ctx->cbc_tfm, GFP_KERNEL);
                tfm = ctx->cbc_tfm;
+       } else if ((crypt_req->op & TEGRA_CRYPTO_OFB) &&
+                       (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2)) {
+
+               req = ablkcipher_request_alloc(ctx->ofb_tfm, GFP_KERNEL);
+               tfm = ctx->ofb_tfm;
+       } else if ((crypt_req->op & TEGRA_CRYPTO_CTR) &&
+                       (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2)) {
+
+               req = ablkcipher_request_alloc(ctx->ctr_tfm, GFP_KERNEL);
+               tfm = ctx->ctr_tfm;
        }
+
        if (!req) {
                pr_err("%s: Failed to allocate request\n", __func__);
                return -ENOMEM;
@@ -254,12 +303,121 @@ process_req_out:
        return ret;
 }
 
+static int sha_async_hash_op(struct ahash_request *req,
+                               struct tegra_crypto_completion *tr,
+                               int ret)
+{
+       if (ret == -EINPROGRESS || ret == -EBUSY) {
+               ret = wait_for_completion_interruptible(&tr->restart);
+               if (!ret)
+                       ret = tr->req_err;
+               INIT_COMPLETION(tr->restart);
+       }
+       return ret;
+}
+
+static int tegra_crypto_sha(struct tegra_sha_req *sha_req)
+{
+
+       struct crypto_ahash *tfm;
+       struct scatterlist sg[1];
+       char result[64];
+       struct ahash_request *req;
+       struct tegra_crypto_completion sha_complete;
+       void *hash_buff;
+       unsigned long *xbuf[XBUFSIZE];
+       int ret = -ENOMEM;
+
+       tfm = crypto_alloc_ahash(sha_req->algo, 0, 0);
+       if (IS_ERR(tfm)) {
+               printk(KERN_ERR "alg: hash: Failed to load transform for %s: "
+                      "%ld\n", sha_req->algo, PTR_ERR(tfm));
+               goto out_alloc;
+       }
+
+       req = ahash_request_alloc(tfm, GFP_KERNEL);
+       if (!req) {
+               printk(KERN_ERR "alg: hash: Failed to allocate request for "
+                      "%s\n", sha_req->algo);
+               goto out_noreq;
+       }
+
+       ret = alloc_bufs(xbuf);
+       if (ret < 0) {
+               pr_err("alloc_bufs failed");
+               goto out_buf;
+       }
+
+       init_completion(&sha_complete.restart);
+
+       memset(result, 0, 64);
+
+       hash_buff = xbuf[0];
+
+       memcpy(hash_buff, sha_req->plaintext, sha_req->plaintext_sz);
+       sg_init_one(&sg[0], hash_buff, sha_req->plaintext_sz);
+
+       if (sha_req->keylen) {
+               crypto_ahash_clear_flags(tfm, ~0);
+               ret = crypto_ahash_setkey(tfm, sha_req->key,
+                                         sha_req->keylen);
+               if (ret) {
+                       printk(KERN_ERR "alg: hash: setkey failed on "
+                              " %s: ret=%d\n", sha_req->algo,
+                              -ret);
+                       goto out;
+               }
+       }
+
+       ahash_request_set_crypt(req, sg, result, sha_req->plaintext_sz);
+
+       ret = sha_async_hash_op(req, &sha_complete, crypto_ahash_init(req));
+       if (ret) {
+               pr_err("alg: hash: init failed on "
+                      "for %s: ret=%d\n", sha_req->algo, -ret);
+               goto out;
+       }
+
+       ret = sha_async_hash_op(req, &sha_complete, crypto_ahash_update(req));
+       if (ret) {
+               pr_err("alg: hash: update failed on "
+                      "for %s: ret=%d\n", sha_req->algo, -ret);
+               goto out;
+       }
+
+       ret = sha_async_hash_op(req, &sha_complete, crypto_ahash_final(req));
+       if (ret) {
+               pr_err("alg: hash: final failed on "
+                      "for %s: ret=%d\n", sha_req->algo, -ret);
+               goto out;
+       }
+
+       ret = copy_to_user((void __user *)sha_req->result,
+               (const void *)result, crypto_ahash_digestsize(tfm));
+       if (ret < 0)
+               goto out;
+
+out:
+       free_bufs(xbuf);
+
+out_buf:
+       ahash_request_free(req);
+
+out_noreq:
+       crypto_free_ahash(tfm);
+
+out_alloc:
+       return ret;
+
+}
+
 static long tegra_crypto_dev_ioctl(struct file *filp,
        unsigned int ioctl_num, unsigned long arg)
 {
        struct tegra_crypto_ctx *ctx = filp->private_data;
        struct tegra_crypt_req crypt_req;
        struct tegra_rng_req rng_req;
+       struct tegra_sha_req sha_req;
        char *rng;
        int ret = 0;
 
@@ -316,6 +474,17 @@ rng_out:
                        kfree(rng);
                break;
 
+       case TEGRA_CRYPTO_IOCTL_GET_SHA:
+               if (tegra_get_chipid() != TEGRA_CHIPID_TEGRA2) {
+                       if (copy_from_user(&sha_req, (void __user *)arg,
+                               sizeof(sha_req)))
+                               return -EFAULT;
+                       ret = tegra_crypto_sha(&sha_req);
+               } else {
+                       ret = -EINVAL;
+               }
+               break;
+
        default:
                pr_debug("invalid ioctl code(%d)", ioctl_num);
                ret = -EINVAL;
index ed62a52..34ec9c1 100644 (file)
@@ -28,6 +28,7 @@
 #define TEGRA_CRYPTO_IOCTL_PROCESS_REQ _IOWR(0x98, 101, int*)
 #define TEGRA_CRYPTO_IOCTL_SET_SEED    _IOWR(0x98, 102, int*)
 #define TEGRA_CRYPTO_IOCTL_GET_RANDOM  _IOWR(0x98, 103, int*)
+#define TEGRA_CRYPTO_IOCTL_GET_SHA     _IOWR(0x98, 104, int*)
 
 #define TEGRA_CRYPTO_MAX_KEY_SIZE      AES_MAX_KEY_SIZE
 #define TEGRA_CRYPTO_IV_SIZE   AES_BLOCK_SIZE
 /* encrypt/decrypt operations */
 #define TEGRA_CRYPTO_ECB       BIT(0)
 #define TEGRA_CRYPTO_CBC       BIT(1)
-#define TEGRA_CRYPTO_RNG       BIT(2)
+#define TEGRA_CRYPTO_OFB       BIT(2)
+#define TEGRA_CRYPTO_CTR       BIT(3)
+#define TEGRA_CRYPTO_CMAC      BIT(4)
+#define TEGRA_CRYPTO_RNG       BIT(5)
 
 /* a pointer to this struct needs to be passed to:
  * TEGRA_CRYPTO_IOCTL_PROCESS_REQ
@@ -67,4 +71,13 @@ struct tegra_rng_req {
        int nbytes; /* random data length */
 };
 
+struct tegra_sha_req {
+       char key[TEGRA_CRYPTO_MAX_KEY_SIZE];
+       int keylen;
+       unsigned char *algo;
+       unsigned char *plaintext;
+       int plaintext_sz;
+       unsigned char *result;
+};
+
 #endif
index 92adbf3..ad24ad9 100644 (file)
@@ -1261,6 +1261,7 @@ int sdio_reset_comm(struct mmc_card *card)
        int err;
 
        printk("%s():\n", __func__);
+
        mmc_claim_host(host);
 
        mmc_go_idle(host);
index b1d7657..12a7b2b 100644 (file)
@@ -94,9 +94,8 @@
 
 #define MLX4_EN_WATCHDOG_TIMEOUT       (15 * HZ)
 
-/* Use the maximum between 16384 and a single page */
-#define MLX4_EN_ALLOC_SIZE     PAGE_ALIGN(16384)
-#define MLX4_EN_ALLOC_ORDER    get_order(MLX4_EN_ALLOC_SIZE)
+#define MLX4_EN_ALLOC_ORDER    2
+#define MLX4_EN_ALLOC_SIZE     (PAGE_SIZE << MLX4_EN_ALLOC_ORDER)
 
 /* Receive fragment sizes; we use at most 4 fragments (for 9600 byte MTU
  * and 4K allocations) */
index d283d03..e1a1eea 100644 (file)
@@ -12,4 +12,6 @@ obj-$(CONFIG_PPPOE) += pppox.o pppoe.o
 obj-$(CONFIG_PPPOL2TP) += pppox.o
 obj-$(CONFIG_PPTP) += pppox.o pptp.o
 obj-$(CONFIG_PPPOLAC) += pppox.o pppolac.o
+
 obj-$(CONFIG_PPPOPNS) += pppox.o pppopns.o
+
index 35b6969..1b3b89b 100644 (file)
@@ -67,8 +67,13 @@ module_param(usb_net_raw_ip_tx_debug, ulong, 0644);
 MODULE_PARM_DESC(usb_net_raw_ip_tx_debug, "usb net (raw-ip) - tx debug");
 
 struct baseband_usb {
+       /* semaphore between disconnect/suspend/resume */
+       struct semaphore sem;
+       /* instance */
        int baseband_index;
+       /* network statistics */
        struct net_device_stats stats;
+       /* usb context */
        struct {
                struct usb_driver *driver;
                struct usb_device *device;
@@ -87,8 +92,11 @@ struct baseband_usb {
                struct workqueue_struct *tx_workqueue;
                struct work_struct tx_work;
        } usb;
+       /* re-usable rx urb */
        struct urb *urb_r;
        void *buff;
+       /* suspend count */
+       int susp_count;
 };
 
 static struct baseband_usb *baseband_usb_net[MAX_INTFS] = { 0, 0, 0};
@@ -158,6 +166,11 @@ static void baseband_usb_driver_disconnect(struct usb_interface *intf)
                                baseband_usb_net[i]->usb.interface, intf);
                        continue;
                }
+               /* acquire semaphore */
+               if (down_interruptible(&baseband_usb_net[i]->sem)) {
+                       pr_err("%s: cannot acquire semaphore\n", __func__);
+                       continue;
+               }
                /* kill usb tx */
                while ((urb = usb_get_from_anchor(&baseband_usb_net[i]->
                        usb.tx_urb_deferred)) != (struct urb *) 0) {
@@ -192,6 +205,8 @@ static void baseband_usb_driver_disconnect(struct usb_interface *intf)
                /* mark interface as disconnected */
                baseband_usb_net[i]->usb.interface
                        = (struct usb_interface *) 0;
+               /* release semaphore */
+               up(&baseband_usb_net[i]->sem);
        }
 
 }
@@ -200,10 +215,14 @@ static void baseband_usb_driver_disconnect(struct usb_interface *intf)
 static int baseband_usb_driver_suspend(struct usb_interface *intf,
        pm_message_t message)
 {
-       int i;
+       int i, susp_count;
 
        pr_debug("%s intf %p\n", __func__, intf);
 
+       pr_debug("%s: cnt %d intf=%p &intf->dev=%p kobj=%s\n",
+                       __func__, atomic_read(&intf->dev.power.usage_count),
+                       intf, &intf->dev, kobject_name(&intf->dev.kobj));
+
        for (i = 0; i < max_intfs; i++) {
                pr_debug("[%d]\n", i);
                if (!baseband_usb_net[i])
@@ -213,13 +232,47 @@ static int baseband_usb_driver_suspend(struct usb_interface *intf,
                                baseband_usb_net[i]->usb.interface, intf);
                        continue;
                }
+               /* increment suspend count */
+               susp_count = (baseband_usb_net[i]->susp_count)++;
+               if (susp_count > 0) {
+                       pr_debug("%s: susp_count %d > 0 (already suspended)\n",
+                               __func__, susp_count);
+                       continue;
+               }
+               if (susp_count < 0) {
+                       pr_debug("%s: susp_count %d < 0 (ILLEGAL VALUE)\n",
+                               __func__, susp_count);
+                       baseband_usb_net[i]->susp_count = 0;
+                       continue;
+               }
+               pr_debug("%s: susp_count = %d (suspending...)\n",
+                       __func__, susp_count);
+               /* acquire semaphore */
+               if (down_interruptible(&baseband_usb_net[i]->sem)) {
+                       pr_err("%s: cannot acquire semaphore\n", __func__);
+                       continue;
+               }
                /* kill usb rx */
                if (!baseband_usb_net[i]->usb.rx_urb) {
                        pr_debug("rx_usb already killed\n");
+                       up(&baseband_usb_net[i]->sem);
                        continue;
                }
+               pr_debug("%s: kill rx_urb {\n",__func__);
                usb_kill_urb(baseband_usb_net[i]->usb.rx_urb);
+               pr_debug("%s: kill rx_urb }\n",__func__);
                baseband_usb_net[i]->usb.rx_urb = (struct urb *) 0;
+               /* cancel tx urb work (will restart after resume) */
+               if (!baseband_usb_net[i]->usb.tx_workqueue) {
+                       pr_err("%s: !tx_workqueue\n", __func__);
+                       up(&baseband_usb_net[i]->sem);
+                       continue;
+               }
+               pr_debug("%s: cancel_work_sync {\n",__func__);
+               cancel_work_sync(&baseband_usb_net[i]->usb.tx_work);
+               pr_debug("%s: cancel_work_sync }\n",__func__);
+               /* release semaphore */
+               up(&baseband_usb_net[i]->sem);
        }
 
        return 0;
@@ -227,10 +280,14 @@ static int baseband_usb_driver_suspend(struct usb_interface *intf,
 
 static int baseband_usb_driver_resume(struct usb_interface *intf)
 {
-       int i, err;
+       int i, err, susp_count;
 
        pr_debug("%s intf %p\n", __func__, intf);
 
+       pr_debug("%s: cnt %d intf=%p &intf->dev=%p kobj=%s\n",
+                       __func__, atomic_read(&intf->dev.power.usage_count),
+                       intf, &intf->dev, kobject_name(&intf->dev.kobj));
+
        for (i = 0; i < max_intfs; i++) {
                pr_debug("[%d]\n", i);
                if (!baseband_usb_net[i])
@@ -240,16 +297,48 @@ static int baseband_usb_driver_resume(struct usb_interface *intf)
                                baseband_usb_net[i]->usb.interface, intf);
                        continue;
                }
+               /* decrement suspend count */
+               susp_count = --(baseband_usb_net[i]->susp_count);
+               if (susp_count > 0) {
+                       pr_debug("%s: susp_count %d > 0 (not resuming yet)\n",
+                               __func__, susp_count);
+                       continue;
+               }
+               if (susp_count < 0) {
+                       pr_debug("%s: susp_count %d < 0 (ILLEGAL VALUE)\n",
+                               __func__, susp_count);
+                       baseband_usb_net[i]->susp_count = 0;
+                       continue;
+               }
+               pr_debug("%s: susp_count = %d (resuming...)\n",
+                       __func__, susp_count);
+               /* acquire semaphore */
+               if (down_interruptible(&baseband_usb_net[i]->sem)) {
+                       pr_err("%s: cannot acquire semaphore\n", __func__);
+                       continue;
+               }
                /* start usb rx */
                if (baseband_usb_net[i]->usb.rx_urb) {
                        pr_debug("rx_usb already exists\n");
+                       up(&baseband_usb_net[i]->sem);
                        continue;
                }
                err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);
                if (err < 0) {
                        pr_err("submit rx failed - err %d\n", err);
+                       up(&baseband_usb_net[i]->sem);
+                       continue;
+               }
+               /* restart tx urb work (cancelled in suspend) */
+               if (!baseband_usb_net[i]->usb.tx_workqueue) {
+                       pr_err("%s: !tx_workqueue\n", __func__);
+                       up(&baseband_usb_net[i]->sem);
                        continue;
                }
+               queue_work(baseband_usb_net[i]->usb.tx_workqueue,
+                       &baseband_usb_net[i]->usb.tx_work);
+               /* release semaphore */
+               up(&baseband_usb_net[i]->sem);
        }
 
        return 0;
@@ -361,6 +450,9 @@ struct baseband_usb *baseband_usb_open(int index,
        if (!usb)
                return (struct baseband_usb *) 0;
 
+       /* create semaphores */
+       sema_init(&usb->sem, 1);
+
        /* open usb driver */
        sprintf(baseband_usb_driver_name[index],
                "baseband_usb_%x_%x_%x",
@@ -424,6 +516,9 @@ void baseband_usb_close(struct baseband_usb *usb)
                pr_debug("close usb driver }\n");
        }
 
+       /* destroy semaphores */
+       memset(&usb->sem, 0, sizeof(usb->sem));
+
        /* free baseband usb structure */
        kfree(usb);
 
@@ -485,10 +580,21 @@ static netdev_tx_t baseband_usb_netdev_start_xmit(
        }
        usb = baseband_usb_net[i];
 
+       /* autoresume if suspended */
+       if (usb->usb.interface) {
+               usb_autopm_get_interface_async(usb->usb.interface);
+       } else {
+               pr_err("%s: tx get interface error\n", __func__);
+               netif_stop_queue(dev);
+               usb->stats.tx_errors++;
+               return NETDEV_TX_BUSY;
+       }
+
        /* submit tx urb */
        err = usb_net_raw_ip_tx_urb_submit(usb, skb);
        if (err < 0) {
-               pr_err("tx urb submit error\n");
+               pr_err("%s: tx urb submit error\n", __func__);
+               netif_stop_queue(dev);
                usb->stats.tx_errors++;
                return NETDEV_TX_BUSY;
        }
@@ -570,8 +676,8 @@ static int usb_net_raw_ip_rx_urb_submit(struct baseband_usb *usb)
 
 static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
 {
-       struct baseband_usb *usb = (struct baseband_usb *) urb->context;
-       int i = usb->baseband_index;
+       struct baseband_usb *usb;
+       int i;
        struct sk_buff *skb;
        unsigned char *dst;
        unsigned char ethernet_header[14] = {
@@ -594,17 +700,20 @@ static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
                pr_err("no urb\n");
                return;
        }
+       usb = (struct baseband_usb *)urb->context;
+       i = usb->baseband_index;
        switch (urb->status) {
        case 0:
                break;
-       case -ENOENT:
-               /* fall through */
        case -ESHUTDOWN:
                /* fall through */
-       case -EPROTO:
                pr_info("%s: rx urb %p - link shutdown %d\n",
                        __func__, urb, urb->status);
                goto err_exit;
+       case -EPROTO:
+               pr_info("%s: rx urb %p - link shutdown %d EPROTO\n",
+                       __func__, urb, urb->status);
+               goto err_exit;
        default:
                pr_info("%s: rx urb %p - status %d\n",
                        __func__, urb, urb->status);
@@ -612,7 +721,7 @@ static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
        }
 
        /* put rx urb data in rx buffer */
-       if (urb->actual_length) {
+       if (urb->actual_length > 0) {
                pr_debug("usb_net_raw_ip_rx_urb_comp - "
                        "urb->actual_length %d\n", urb->actual_length);
                /* allocate skb with space for
@@ -661,6 +770,10 @@ static void usb_net_raw_ip_rx_urb_comp(struct urb *urb)
        /* mark rx urb complete */
        usb->usb.rx_urb = (struct urb *) 0;
 
+       /* do not submit urb if interface is suspending */
+       if (urb->status == -ENOENT)
+               return;
+
        /* submit next rx urb */
        usb_net_raw_ip_rx_urb_submit(usb);
        return;
@@ -742,13 +855,13 @@ static int usb_net_raw_ip_tx_urb_submit(struct baseband_usb *usb,
                pr_err("%s: !usb\n", __func__);
                return -EINVAL;
        }
-       if (!skb) {
-               pr_err("%s: !skb\n", __func__);
-               return -EINVAL;
-       }
        if (!usb->usb.interface) {
                pr_err("usb interface disconnected - not submitting tx urb\n");
-               kfree_skb(skb);
+               return -EINVAL;
+       }
+       if (!skb) {
+               pr_err("%s: !skb\n", __func__);
+               usb_autopm_put_interface_async(usb->usb.interface);
                return -EINVAL;
        }
 
@@ -756,14 +869,14 @@ static int usb_net_raw_ip_tx_urb_submit(struct baseband_usb *usb,
        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb) {
                pr_err("usb_alloc_urb() failed\n");
-               kfree_skb(skb);
+               usb_autopm_put_interface_async(usb->usb.interface);
                return -ENOMEM;
        }
        buf = kzalloc(skb->len - 14, GFP_ATOMIC);
        if (!buf) {
                pr_err("usb buffer kzalloc() failed\n");
                usb_free_urb(urb);
-               kfree_skb(skb);
+               usb_autopm_put_interface_async(usb->usb.interface);
                return -ENOMEM;
        }
        err = skb_copy_bits(skb, 14, buf, skb->len - 14);
@@ -771,7 +884,7 @@ static int usb_net_raw_ip_tx_urb_submit(struct baseband_usb *usb,
                pr_err("skb_copy_bits() failed - %d\n", err);
                kfree(buf);
                usb_free_urb(urb);
-               kfree_skb(skb);
+               usb_autopm_put_interface_async(usb->usb.interface);
                return err;
        }
        usb_fill_bulk_urb(urb, usb->usb.device, usb->usb.pipe.bulk.out,
@@ -801,11 +914,27 @@ static void usb_net_raw_ip_tx_urb_work(struct work_struct *work)
        pr_debug("usb_net_raw_ip_tx_urb_work {\n");
 
        /* check if tx urb(s) queued */
-       if (!usb->usb.tx_urb && usb_anchor_empty(&usb->usb.tx_urb_deferred)) {
+       if (usb == NULL ||
+               (!usb->usb.tx_urb &&
+               usb_anchor_empty(&usb->usb.tx_urb_deferred))) {
                pr_debug("%s: nothing to do!\n", __func__);
                return;
        }
 
+       /* check if usb interface disconnected */
+       if (!usb->usb.interface) {
+               pr_err("%s: not submitting tx urb %p -interface disconnected\n",
+                       __func__, urb);
+               return;
+       }
+
+       /* check if suspended */
+       if (usb->susp_count > 0) {
+               pr_info("%s: usb->susp_count %d > 0 (suspended)\n",
+                       __func__, usb->susp_count);
+               return;
+       }
+
        /* submit queued tx urb(s) */
        while ((urb = usb_get_from_anchor(&usb->usb.tx_urb_deferred))
                != (struct urb *) 0) {
@@ -821,33 +950,23 @@ static void usb_net_raw_ip_tx_urb_work(struct work_struct *work)
                                urb->transfer_buffer = (void *) 0;
                        }
                        usb_free_urb(urb);
+                       usb->stats.tx_errors++;
                        continue;
                }
                /* autoresume before tx */
                usb_mark_last_busy(usb->usb.device);
-               err = usb_autopm_get_interface(usb->usb.interface);
-               if (err < 0) {
-                       pr_err("%s: usb_autopm_get_interface(%p) failed %d\n",
-                               __func__, usb->usb.interface, err);
-                       if (urb->transfer_buffer) {
-                               kfree(urb->transfer_buffer);
-                               urb->transfer_buffer = (void *) 0;
-                       }
-                       usb_free_urb(urb);
-                       usb->stats.tx_errors++;
-                       continue;
-               }
                /* submit tx urb */
                err = usb_submit_urb(urb, GFP_ATOMIC);
                if (err < 0) {
                        pr_err("%s: usb_submit_urb(%p) failed - err %d\n",
                                __func__, urb, err);
-                       usb_autopm_put_interface(usb->usb.interface);
+                       usb_autopm_put_interface_async(usb->usb.interface);
                        if (urb->transfer_buffer) {
                                kfree(urb->transfer_buffer);
                                urb->transfer_buffer = (void *) 0;
                        }
                        usb_free_urb(urb);
+                       usb->stats.tx_errors++;
                        continue;
                }
                /* free tx urb
@@ -865,7 +984,7 @@ static void usb_net_raw_ip_tx_urb_work(struct work_struct *work)
 
 static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
 {
-       struct baseband_usb *usb = (struct baseband_usb *) urb->context;
+       struct baseband_usb *usb;
 
        pr_debug("usb_net_raw_ip_tx_urb_comp {\n");
 
@@ -874,6 +993,7 @@ static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
                pr_err("no urb\n");
                return;
        }
+       usb = (struct baseband_usb *)urb->context;
        switch (urb->status) {
        case 0:
                break;
@@ -884,6 +1004,7 @@ static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
        case -EPROTO:
                pr_info("%s: tx urb %p - link shutdown %d\n",
                        __func__, urb, urb->status);
+               usb_autopm_put_interface_async(usb->usb.interface);
                goto err_exit;
        default:
                pr_info("%s: tx urb %p - status %d\n",
@@ -896,6 +1017,7 @@ static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
                usb->stats.tx_packets++;
                usb->stats.tx_bytes += urb->transfer_buffer_length;
        }
+
        /* autosuspend after tx completed */
        if (!usb->usb.interface) {
                pr_err("%s: usb interface disconnected"
@@ -903,7 +1025,7 @@ static void usb_net_raw_ip_tx_urb_comp(struct urb *urb)
                        __func__);
                goto err_exit;
        }
-       usb_autopm_put_interface(usb->usb.interface);
+       usb_autopm_put_interface_async(usb->usb.interface);
 
 err_exit:
        /* free tx urb transfer buffer */
@@ -911,7 +1033,6 @@ err_exit:
                kfree(urb->transfer_buffer);
                urb->transfer_buffer = (void *) 0;
        }
-
        pr_debug("usb_net_raw_ip_tx_urb_comp }\n");
 }
 
@@ -934,6 +1055,7 @@ static int usb_net_raw_ip_init(void)
                        err = -1;
                        goto error_exit;
                }
+               init_usb_anchor(&baseband_usb_net[i]->usb.tx_urb_deferred);
                /* register network device */
                usb_net_raw_ip_dev[i] = alloc_netdev(0,
                        BASEBAND_USB_NET_DEV_NAME,
@@ -966,7 +1088,6 @@ static int usb_net_raw_ip_init(void)
                        goto error_exit;
                }
                /* start usb tx */
-               init_usb_anchor(&baseband_usb_net[i]->usb.tx_urb_deferred);
                sprintf(name, "raw_ip_tx_wq-%d",
                        baseband_usb_net[i]->baseband_index);
                baseband_usb_net[i]->usb.tx_workqueue
index e1714d7..941a32d 100644 (file)
@@ -419,7 +419,7 @@ static void ar9003_hw_spur_ofdm_work(struct ath_hw *ah,
                        else
                                spur_subchannel_sd = 0;
 
-                       spur_freq_sd = ((freq_offset + 10) << 9) / 11;
+                       spur_freq_sd = (freq_offset << 9) / 11;
 
                } else {
                        if (REG_READ_FIELD(ah, AR_PHY_GEN_CTRL,
@@ -428,7 +428,7 @@ static void ar9003_hw_spur_ofdm_work(struct ath_hw *ah,
                        else
                                spur_subchannel_sd = 1;
 
-                       spur_freq_sd = ((freq_offset - 10) << 9) / 11;
+                       spur_freq_sd = (freq_offset << 9) / 11;
 
                }
 
index 4a93eb6..ece5300 100644 (file)
@@ -828,7 +828,7 @@ static int broken_efr(struct uart_8250_port *up)
        /*
         * Exar ST16C2550 "A2" devices incorrectly detect as
         * having an EFR, and report an ID of 0x0201.  See
-        * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html 
+        * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html
         */
        if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
                return 1;
@@ -3398,7 +3398,6 @@ out:
        return ret;
 }
 
-#ifdef MODULE
 static void __exit serial8250_exit(void)
 {
        struct platform_device *isa_dev = serial8250_isa_devs;
@@ -3424,9 +3423,6 @@ static void __exit serial8250_exit(void)
 
 module_init(serial8250_init);
 module_exit(serial8250_exit);
-#else
-postcore_initcall(serial8250_init);
-#endif
 
 EXPORT_SYMBOL(serial8250_suspend_port);
 EXPORT_SYMBOL(serial8250_resume_port);
index fee048b..ab29815 100644 (file)
@@ -254,6 +254,8 @@ static int acm_write_start(struct acm *acm, int wbn)
        usb_mark_last_busy(acm->dev);
 #ifdef CONFIG_PM
        while ((res = usb_get_from_anchor(&acm->deferred))) {
+               /* decrement ref count*/
+               usb_put_urb(res);
                rc = usb_submit_urb(res, GFP_ATOMIC);
                if (rc < 0) {
                        dbg("usb_submit_urb(pending request) failed: %d", rc);
@@ -554,6 +556,9 @@ static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
        set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
        acm->control->needs_remote_wakeup = 0;
 
+       if (acm_submit_read_urbs(acm, GFP_KERNEL))
+               goto error_submit_urb;
+
        acm->ctrlurb->dev = acm->dev;
        if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
                dev_err(&acm->control->dev,
@@ -1409,6 +1414,7 @@ static void acm_disconnect(struct usb_interface *intf)
        struct acm *acm = usb_get_intfdata(intf);
        struct usb_device *usb_dev = interface_to_usbdev(intf);
        struct tty_struct *tty;
+       struct urb *res;
        int i;
 
        dev_dbg(&intf->dev, "%s\n", __func__);
@@ -1440,7 +1446,9 @@ static void acm_disconnect(struct usb_interface *intf)
 
        tty_unregister_device(acm_tty_driver, acm->minor);
 
-       usb_kill_anchored_urbs(&acm->deferred);
+       /* decrement ref count of anchored urbs */
+       while ((res = usb_get_from_anchor(&acm->deferred)))
+               usb_put_urb(res);
        usb_free_urb(acm->ctrlurb);
        for (i = 0; i < ACM_NW; i++)
                usb_free_urb(acm->wb[i].urb);
@@ -1527,6 +1535,8 @@ static int acm_resume(struct usb_interface *intf)
                spin_lock_irq(&acm->write_lock);
 #ifdef CONFIG_PM
                while ((res = usb_get_from_anchor(&acm->deferred))) {
+                       /* decrement ref count*/
+                       usb_put_urb(res);
                        rv = usb_submit_urb(res, GFP_ATOMIC);
                        if (rv < 0) {
                                dbg("usb_submit_urb(pending request)"
index c8ebf7a..3a8cd20 100644 (file)
@@ -588,7 +588,7 @@ config USB_SL811_HCD
        help
          The SL811HS is a single-port USB controller that supports either
          host side or peripheral side roles.  Enable this option if your
-         board has this chip, and you want to use it as a host controller. 
+         board has this chip, and you want to use it as a host controller.
          If unsure, say N.
 
          To compile this driver as a module, choose M here: the
index 2fda920..b45e1a3 100644 (file)
@@ -229,6 +229,11 @@ struct ehci_hcd {                  /* one per controller */
        struct dentry           *debug_dir;
 #endif
 
+       /*
+        * OTG controllers and transceivers need software interaction
+        */
+       struct usb_phy  *transceiver;
+
        /* platform-specific data -- must come last */
        unsigned long           priv[0] __aligned(sizeof(s64));
 };
index 7ee422c..3672b11 100644 (file)
 #define KBC_MAX_COL    8
 #define KBC_MAX_KEY    (KBC_MAX_ROW * KBC_MAX_COL)
 
+#define KBC_PIN_GPIO_0         0
+#define KBC_PIN_GPIO_1         1
+#define KBC_PIN_GPIO_2         2
+#define KBC_PIN_GPIO_3         3
+#define KBC_PIN_GPIO_4         4
+#define KBC_PIN_GPIO_5         5
+#define KBC_PIN_GPIO_6         6
+#define KBC_PIN_GPIO_7         7
+#define KBC_PIN_GPIO_8         8
+#define KBC_PIN_GPIO_9         9
+#define KBC_PIN_GPIO_10                10
+#define KBC_PIN_GPIO_11                11
+#define KBC_PIN_GPIO_12                12
+#define KBC_PIN_GPIO_13                13
+#define KBC_PIN_GPIO_14                14
+#define KBC_PIN_GPIO_15                15
+#define KBC_PIN_GPIO_16                16
+#define KBC_PIN_GPIO_17                17
+#define KBC_PIN_GPIO_18                18
+#define KBC_PIN_GPIO_19                19
+#define KBC_PIN_GPIO_20                20
+#define KBC_PIN_GPIO_21                21
+#define KBC_PIN_GPIO_22                22
+#define KBC_PIN_GPIO_23                23
+
 enum tegra_pin_type {
        PIN_CFG_IGNORE,
        PIN_CFG_COL,
index 20e433e..455dac3 100644 (file)
 #define LDO_ST_MASK                                    0x03
 #define LDO_ST_SHIFT                                   0
 #define LDO_ST_ON_BIT                                  0x01
-#define LDO_ST_MODE_BIT                                        0x02    
+#define LDO_ST_MODE_BIT                                        0x02
 
 
 /* Registers LDO1 to LDO8 in tps65910 */
diff --git a/include/linux/platform_data/tegra30_emc.h b/include/linux/platform_data/tegra30_emc.h
deleted file mode 100644 (file)
index f005755..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) 2011 Google, Inc.
- * Copyright (C) 2011 NVIDIA Corporation
- *
- * Author:
- *     Colin Cross <ccross@android.com>
- *     Olof Johansson <olof@lixom.net>
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- *
- */
-
-#ifndef __TEGRA_EMC_H_
-#define __TEGRA_EMC_H_
-
-#define TEGRA_EMC_NUM_REGS     110
-
-struct tegra30_emc_table {
-       u8 rev;
-       unsigned long rate;
-
-       /* unconditionally updated in one burst shot */
-       u32 burst_regs[TEGRA_EMC_NUM_REGS];
-
-       /* updated separately under some conditions */
-       u32 emc_zcal_cnt_long;
-       u32 emc_acal_interval;
-       u32 emc_periodic_qrst;
-       u32 emc_mode_reset;
-       u32 emc_mode_1;
-       u32 emc_mode_2;
-       u32 emc_dsr;
-       int emc_min_mv;
-};
-
-struct tegra30_emc_pdata {
-       int num_tables;
-       const struct tegra30_emc_table *tables;
-};
-
-#endif
index aaf8ac3..067582e 100644 (file)
@@ -26,20 +26,14 @@ struct tegra_emc_table {
        u32 regs[TEGRA_EMC_NUM_REGS];
 };
 
-struct tegra_emc_chip {
+struct tegra_emc_pdata {
        const char *description;
        int mem_manufacturer_id; /* LPDDR2 MR5 or -1 to ignore */
        int mem_revision_id1;    /* LPDDR2 MR6 or -1 to ignore */
        int mem_revision_id2;    /* LPDDR2 MR7 or -1 to ignore */
        int mem_pid;             /* LPDDR2 MR8 or -1 to ignore */
-
        int num_tables;
        struct tegra_emc_table *tables;
 };
 
-struct tegra_emc_pdata {
-       int num_chips;
-       struct tegra_emc_chip *chips;
-};
-
 #endif
index f075b9c..9747271 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) 2010 Google, Inc.
- * Copyright (C) 2011 NVIDIA Corporation.
+ * Copyright (C) 2010-2011 NVIDIA Corporation
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
index fa11e56..c3bdcc9 100644 (file)
@@ -21,6 +21,7 @@ enum {
        PM_QOS_CPU_FREQ_MAX,
 
        /* insert new class ID */
+
        PM_QOS_NUM_CLASSES,
 };
 
index f8cc6c4..5dd99f7 100644 (file)
@@ -83,20 +83,20 @@ config PM_STD_PARTITION
        default ""
        ---help---
          The default resume partition is the partition that the suspend-
-         to-disk implementation will look for a suspended disk image. 
+         to-disk implementation will look for a suspended disk image.
 
-         The partition specified here will be different for almost every user. 
+         The partition specified here will be different for almost every user.
          It should be a valid swap partition (at least for now) that is turned
-         on before suspending. 
+         on before suspending.
 
          The partition specified can be overridden by specifying:
 
-               resume=/dev/<other device> 
+               resume=/dev/<other device>
 
-         which will set the resume partition to the device specified. 
+         which will set the resume partition to the device specified.
 
          Note there is currently not a way to specify which device to save the
-         suspended image to. It will simply pick the first available swap 
+         suspended image to. It will simply pick the first available swap
          device.
 
 config PM_SLEEP
index baeeb5c..c1aae6a 100644 (file)
@@ -1640,6 +1640,7 @@ ktime_t ktime_get_monotonic_offset(void)
 }
 EXPORT_SYMBOL_GPL(ktime_get_monotonic_offset);
 
+
 /**
  * do_adjtimex() - Accessor function to NTP __do_adjtimex function
  */
index c5e34cf..87fbda3 100644 (file)
@@ -10,7 +10,7 @@ menuconfig NET
          The reason is that some programs need kernel networking support even
          when running on a stand-alone machine that isn't connected to any
          other computer.
-         
+
          If you are upgrading from an older kernel, you
          should consider updating your networking tools too because changes
          in the kernel and the tools often go hand in hand. The tools are
@@ -301,7 +301,7 @@ config NET_TCPPROBE
 
        Documentation on how to use TCP connection probing can be found
        at:
-       
+
          http://www.linuxfoundation.org/collaborate/workgroups/networking/tcpprobe
 
        To compile this code as a module, choose M here: the
index 23dfd4a..00c2a3d 100644 (file)
@@ -249,7 +249,7 @@ config IP_NF_TARGET_CLUSTERIP
          The CLUSTERIP target allows you to build load-balancing clusters of
          network servers without having a dedicated load-balancing
          router/server/switch.
-       
+
          To compile it as a module, choose M here.  If unsure, say N.
 
 config IP_NF_TARGET_ECN
@@ -258,7 +258,7 @@ config IP_NF_TARGET_ECN
        depends on NETFILTER_ADVANCED
        ---help---
          This option adds a `ECN' target, which can be used in the iptables mangle
-         table.  
+         table.
 
          You can use this target to remove the ECN bits from the IPv4 header of
          an IP packet.  This is particularly useful, if you need to work around
@@ -283,7 +283,7 @@ config IP_NF_RAW
          This option adds a `raw' table to iptables. This table is the very
          first in the netfilter framework and hooks in at the PREROUTING
          and OUTPUT chains.
-       
+
          If you want to compile it as a module, say M here and read
          <file:Documentation/kbuild/modules.txt>.  If unsure, say `N'.
 
@@ -295,7 +295,7 @@ config IP_NF_SECURITY
        help
          This option adds a `security' table to iptables, for use
          with Mandatory Access Control (MAC) policy.
-        
+
          If unsure, say N.
 
 endif # IP_NF_IPTABLES
index c9f9dff..cc75632 100644 (file)
@@ -31,7 +31,7 @@
  *  CHANGES:
  *
  *  2004.12.01 Major rewrite by tiwai, merged the work of pshou
- * 
+ *
  */
 
 #include <linux/delay.h>
@@ -1262,7 +1262,7 @@ static int azx_reset(struct azx *chip, int full_reset)
 
 /*
  * Lowlevel interface
- */  
+ */
 
 /* enable interrupts */
 static void azx_int_enable(struct azx *chip)
@@ -1552,7 +1552,7 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
                spin_unlock(&chip->reg_lock);
                return IRQ_NONE;
        }
-       
+
        for (i = 0; i < chip->num_streams; i++) {
                azx_dev = &chip->azx_dev[i];
                if (status & azx_dev->sd_int_sta_mask) {
@@ -1594,7 +1594,7 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id)
                azx_writeb(chip, STATESTS, 0x04);
 #endif
        spin_unlock(&chip->reg_lock);
-       
+
        return IRQ_HANDLED;
 }