Merge commit 'v3.4.9' into android-t114-3.4
Varun Wadekar [Thu, 23 Aug 2012 09:37:36 +0000 (14:37 +0530)]
Linux v3.4.9

Conflicts:
arch/arm/kernel/smp.c
arch/arm/vfp/entry.S

Change-Id: I731e815ed35ba9280374a5a3e5a6a8b6b805d695
Signed-off-by: Varun Wadekar <vwadekar@nvidia.com>

1  2 
Makefile
arch/arm/include/asm/cacheflush.h
arch/arm/kernel/process.c
arch/arm/kernel/smp.c
arch/arm/kernel/traps.c
arch/arm/vfp/entry.S
drivers/hid/hid-multitouch.c
drivers/net/tun.c
sound/pci/hda/patch_conexant.c

diff --combined Makefile
+++ b/Makefile
@@@ -1,6 -1,6 +1,6 @@@
  VERSION = 3
  PATCHLEVEL = 4
- SUBLEVEL = 8
+ SUBLEVEL = 9
  EXTRAVERSION =
  NAME = Saber-toothed Squirrel
  
@@@ -561,16 -561,8 +561,16 @@@ all: vmlinu
  ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE
  KBUILD_CFLAGS += -Os
  else
 +ifdef CONFIG_LESS_GCC_OPT
 +KBUILD_CFLAGS += -O1
 +else
  KBUILD_CFLAGS += -O2
  endif
 +endif
 +
 +# conserve stack if available
 +# do this early so that an architecture can override it.
 +KBUILD_CFLAGS   += $(call cc-option,-fconserve-stack)
  
  include $(srctree)/arch/$(SRCARCH)/Makefile
  
@@@ -637,6 -629,9 +637,6 @@@ KBUILD_CFLAGS += $(call cc-disable-warn
  # disable invalid "can't wrap" optimizations for signed / pointers
  KBUILD_CFLAGS += $(call cc-option,-fno-strict-overflow)
  
 -# conserve stack if available
 -KBUILD_CFLAGS   += $(call cc-option,-fconserve-stack)
 -
  # use the deterministic mode of AR if available
  KBUILD_ARFLAGS := $(call ar-option,D)
  
@@@ -16,7 -16,6 +16,7 @@@
  #include <asm/shmparam.h>
  #include <asm/cachetype.h>
  #include <asm/outercache.h>
 +#include <asm/rodata.h>
  
  #define CACHE_COLOUR(vaddr)   ((vaddr & (SHMLBA - 1)) >> PAGE_SHIFT)
  
@@@ -102,7 -101,7 +102,7 @@@ struct cpu_cache_fns 
        void (*flush_user_range)(unsigned long, unsigned long, unsigned int);
  
        void (*coherent_kern_range)(unsigned long, unsigned long);
 -      void (*coherent_user_range)(unsigned long, unsigned long);
 +      int  (*coherent_user_range)(unsigned long, unsigned long);
        void (*flush_kern_dcache_area)(void *, size_t);
  
        void (*dma_map_area)(const void *, size_t, int);
@@@ -143,7 -142,7 +143,7 @@@ extern void __cpuc_flush_kern_all(void)
  extern void __cpuc_flush_user_all(void);
  extern void __cpuc_flush_user_range(unsigned long, unsigned long, unsigned int);
  extern void __cpuc_coherent_kern_range(unsigned long, unsigned long);
 -extern void __cpuc_coherent_user_range(unsigned long, unsigned long);
 +extern int  __cpuc_coherent_user_range(unsigned long, unsigned long);
  extern void __cpuc_flush_dcache_area(void *, size_t);
  
  /*
@@@ -216,7 -215,9 +216,9 @@@ static inline void vivt_flush_cache_mm(
  static inline void
  vivt_flush_cache_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
  {
-       if (cpumask_test_cpu(smp_processor_id(), mm_cpumask(vma->vm_mm)))
+       struct mm_struct *mm = vma->vm_mm;
+       if (!mm || cpumask_test_cpu(smp_processor_id(), mm_cpumask(mm)))
                __cpuc_flush_user_range(start & PAGE_MASK, PAGE_ALIGN(end),
                                        vma->vm_flags);
  }
  static inline void
  vivt_flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr, unsigned long pfn)
  {
-       if (cpumask_test_cpu(smp_processor_id(), mm_cpumask(vma->vm_mm))) {
+       struct mm_struct *mm = vma->vm_mm;
+       if (!mm || cpumask_test_cpu(smp_processor_id(), mm_cpumask(mm))) {
                unsigned long addr = user_addr & PAGE_MASK;
                __cpuc_flush_user_range(addr, addr + PAGE_SIZE, vma->vm_flags);
        }
@@@ -345,53 -348,4 +349,53 @@@ static inline void flush_cache_vunmap(u
                flush_cache_all();
  }
  
 +/*
 + * The set_memory_* API can be used to change various attributes of a virtual
 + * address range. The attributes include:
 + * Cachability   : UnCached, WriteCombining, WriteBack
 + * Executability : eXeutable, NoteXecutable
 + * Read/Write    : ReadOnly, ReadWrite
 + * Presence      : NotPresent
 + *
 + * Within a catagory, the attributes are mutually exclusive.
 + *
 + * The implementation of this API will take care of various aspects that
 + * are associated with changing such attributes, such as:
 + * - Flushing TLBs
 + * - Flushing CPU caches
 + * - Making sure aliases of the memory behind the mapping don't violate
 + *   coherency rules as defined by the CPU in the system.
 + *
 + * What this API does not do:
 + * - Provide exclusion between various callers - including callers that
 + *   operation on other mappings of the same physical page
 + * - Restore default attributes when a page is freed
 + * - Guarantee that mappings other than the requested one are
 + *   in any state, other than that these do not violate rules for
 + *   the CPU you have. Do not depend on any effects on other mappings,
 + *   CPUs other than the one you have may have more relaxed rules.
 + * The caller is required to take care of these.
 + */
 +
 +int set_memory_uc(unsigned long addr, int numpages);
 +int set_memory_wc(unsigned long addr, int numpages);
 +int set_memory_wb(unsigned long addr, int numpages);
 +int set_memory_iwb(unsigned long addr, int numpages);
 +int set_memory_x(unsigned long addr, int numpages);
 +int set_memory_nx(unsigned long addr, int numpages);
 +int set_memory_ro(unsigned long addr, int numpages);
 +int set_memory_rw(unsigned long addr, int numpages);
 +int set_memory_np(unsigned long addr, int numpages);
 +int set_memory_4k(unsigned long addr, int numpages);
 +
 +int set_memory_array_uc(unsigned long *addr, int addrinarray);
 +int set_memory_array_wc(unsigned long *addr, int addrinarray);
 +int set_memory_array_wb(unsigned long *addr, int addrinarray);
 +int set_memory_array_iwb(unsigned long *addr, int addrinarray);
 +
 +int set_pages_array_uc(struct page **pages, int addrinarray);
 +int set_pages_array_wc(struct page **pages, int addrinarray);
 +int set_pages_array_wb(struct page **pages, int addrinarray);
 +int set_pages_array_iwb(struct page **pages, int addrinarray);
 +
  #endif
  #include <linux/random.h>
  #include <linux/hw_breakpoint.h>
  #include <linux/cpuidle.h>
 +#include <linux/console.h>
  
  #include <asm/cacheflush.h>
 +#include <asm/idmap.h>
  #include <asm/leds.h>
  #include <asm/processor.h>
  #include <asm/thread_notify.h>
@@@ -58,20 -56,10 +58,20 @@@ static const char *isa_modes[] = 
    "ARM" , "Thumb" , "Jazelle", "ThumbEE"
  };
  
 -extern void setup_mm_for_reboot(void);
 -
  static volatile int hlt_counter;
  
 +#ifdef CONFIG_SMP
 +void arch_trigger_all_cpu_backtrace(void)
 +{
 +      smp_send_all_cpu_backtrace();
 +}
 +#else
 +void arch_trigger_all_cpu_backtrace(void)
 +{
 +      dump_stack();
 +}
 +#endif
 +
  void disable_hlt(void)
  {
        hlt_counter++;
@@@ -104,31 -92,6 +104,31 @@@ __setup("hlt", hlt_setup)
  extern void call_with_stack(void (*fn)(void *), void *arg, void *sp);
  typedef void (*phys_reset_t)(unsigned long);
  
 +#ifdef CONFIG_ARM_FLUSH_CONSOLE_ON_RESTART
 +void arm_machine_flush_console(void)
 +{
 +      printk("\n");
 +      pr_emerg("Restarting %s\n", linux_banner);
 +      if (console_trylock()) {
 +              console_unlock();
 +              return;
 +      }
 +
 +      mdelay(50);
 +
 +      local_irq_disable();
 +      if (!console_trylock())
 +              pr_emerg("arm_restart: Console was locked! Busting\n");
 +      else
 +              pr_emerg("arm_restart: Console was locked!\n");
 +      console_unlock();
 +}
 +#else
 +void arm_machine_flush_console(void)
 +{
 +}
 +#endif
 +
  /*
   * A temporary stack to use for CPU reset. This is static so that we
   * don't clobber it with the identity mapping. When running with this
@@@ -244,9 -207,9 +244,9 @@@ void cpu_idle(void
  
        /* endless idle loop with no priority at all */
        while (1) {
 +              idle_notifier_call_chain(IDLE_START);
                tick_nohz_idle_enter();
                rcu_idle_enter();
 -              leds_event(led_idle_start);
                while (!need_resched()) {
  #ifdef CONFIG_HOTPLUG_CPU
                        if (cpu_is_offline(smp_processor_id()))
                        } else
                                local_irq_enable();
                }
 -              leds_event(led_idle_end);
                rcu_idle_exit();
                tick_nohz_idle_exit();
 +              idle_notifier_call_chain(IDLE_END);
                schedule_preempt_disabled();
        }
  }
@@@ -304,6 -267,7 +304,7 @@@ void machine_shutdown(void
  void machine_halt(void)
  {
        machine_shutdown();
+       local_irq_disable();
        while (1);
  }
  
@@@ -316,20 -280,8 +317,20 @@@ void machine_power_off(void
  
  void machine_restart(char *cmd)
  {
 +      /* Flush the console to make sure all the relevant messages make it
 +       * out to the console drivers */
 +      arm_machine_flush_console();
 +
 +      /* Disable interrupts first */
 +      local_irq_disable();
 +      local_fiq_disable();
 +
        machine_shutdown();
  
 +      /* Flush the console to make sure all the relevant messages make it
 +       * out to the console drivers */
 +      arm_machine_flush_console();
 +
        arm_pm_restart(reboot_mode, cmd);
  
        /* Give a grace period for failure to restart of 1s */
  
        /* Whoops - the platform was unable to reboot. Tell the user! */
        printk("Reboot failed -- System halted\n");
+       local_irq_disable();
        while (1);
  }
  
 +/*
 + * dump a block of kernel memory from around the given address
 + */
 +static void show_data(unsigned long addr, int nbytes, const char *name)
 +{
 +      int     i, j;
 +      int     nlines;
 +      u32     *p;
 +
 +      /*
 +       * don't attempt to dump non-kernel addresses or
 +       * values that are probably just small negative numbers
 +       */
 +      if (addr < PAGE_OFFSET || addr > -256UL)
 +              return;
 +
 +      printk("\n%s: %#lx:\n", name, addr);
 +
 +      /*
 +       * round address down to a 32 bit boundary
 +       * and always dump a multiple of 32 bytes
 +       */
 +      p = (u32 *)(addr & ~(sizeof(u32) - 1));
 +      nbytes += (addr & (sizeof(u32) - 1));
 +      nlines = (nbytes + 31) / 32;
 +
 +
 +      for (i = 0; i < nlines; i++) {
 +              /*
 +               * just display low 16 bits of address to keep
 +               * each line of the dump < 80 characters
 +               */
 +              printk("%04lx ", (unsigned long)p & 0xffff);
 +              for (j = 0; j < 8; j++) {
 +                      u32     data;
 +                      if (probe_kernel_address(p, data)) {
 +                              printk(" ********");
 +                      } else {
 +                              printk(" %08x", data);
 +                      }
 +                      ++p;
 +              }
 +              printk("\n");
 +      }
 +}
 +
 +static void show_extra_register_data(struct pt_regs *regs, int nbytes)
 +{
 +      mm_segment_t fs;
 +
 +      fs = get_fs();
 +      set_fs(KERNEL_DS);
 +      show_data(regs->ARM_pc - nbytes, nbytes * 2, "PC");
 +      show_data(regs->ARM_lr - nbytes, nbytes * 2, "LR");
 +      show_data(regs->ARM_sp - nbytes, nbytes * 2, "SP");
 +      show_data(regs->ARM_ip - nbytes, nbytes * 2, "IP");
 +      show_data(regs->ARM_fp - nbytes, nbytes * 2, "FP");
 +      show_data(regs->ARM_r0 - nbytes, nbytes * 2, "R0");
 +      show_data(regs->ARM_r1 - nbytes, nbytes * 2, "R1");
 +      show_data(regs->ARM_r2 - nbytes, nbytes * 2, "R2");
 +      show_data(regs->ARM_r3 - nbytes, nbytes * 2, "R3");
 +      show_data(regs->ARM_r4 - nbytes, nbytes * 2, "R4");
 +      show_data(regs->ARM_r5 - nbytes, nbytes * 2, "R5");
 +      show_data(regs->ARM_r6 - nbytes, nbytes * 2, "R6");
 +      show_data(regs->ARM_r7 - nbytes, nbytes * 2, "R7");
 +      show_data(regs->ARM_r8 - nbytes, nbytes * 2, "R8");
 +      show_data(regs->ARM_r9 - nbytes, nbytes * 2, "R9");
 +      show_data(regs->ARM_r10 - nbytes, nbytes * 2, "R10");
 +      set_fs(fs);
 +}
 +
  void __show_regs(struct pt_regs *regs)
  {
        unsigned long flags;
                printk("Control: %08x%s\n", ctrl, buf);
        }
  #endif
 +
 +      show_extra_register_data(regs, 128);
  }
  
  void show_regs(struct pt_regs * regs)
diff --combined arch/arm/kernel/smp.c
@@@ -27,7 -27,6 +27,7 @@@
  #include <linux/completion.h>
  
  #include <linux/atomic.h>
 +#include <asm/soc.h>
  #include <asm/cacheflush.h>
  #include <asm/cpu.h>
  #include <asm/cputype.h>
@@@ -42,7 -41,6 +42,7 @@@
  #include <asm/tlbflush.h>
  #include <asm/ptrace.h>
  #include <asm/localtimer.h>
 +#include <asm/idmap.h>
  #include <asm/smp_plat.h>
  
  /*
@@@ -58,7 -56,6 +58,7 @@@ enum ipi_msg_type 
        IPI_CALL_FUNC,
        IPI_CALL_FUNC_SINGLE,
        IPI_CPU_STOP,
 +      IPI_CPU_BACKTRACE,
  };
  
  static DECLARE_COMPLETION(cpu_running);
@@@ -124,95 -121,13 +124,95 @@@ int __cpuinit __cpu_up(unsigned int cpu
        return ret;
  }
  
 +/* SoC helpers */
 +static const struct arm_soc_smp_init_ops *soc_smp_init_ops  __initdata;
 +static const struct arm_soc_smp_ops *soc_smp_ops;
 +static struct arm_soc_smp_ops __soc_smp_ops;
 +
 +void __init soc_smp_ops_register(struct arm_soc_smp_init_ops *smp_init_ops,
 +                               struct arm_soc_smp_ops *smp_ops)
 +{
 +      if (smp_init_ops)
 +              soc_smp_init_ops = smp_init_ops;
 +
 +      /*
 +       * Warning: we're copying an __initdata structure into a
 +       * __cpuinitdata structure. We *know* it is valid because only
 +       * __cpuinit (or more persistant) functions should be pointed
 +       * to by soc_smp_ops. Still, this is borderline ugly.
 +       */
 +      if (smp_ops) {
 +              __soc_smp_ops = *smp_ops;
 +              soc_smp_ops = &__soc_smp_ops;
 +      }
 +}
 +
 +void __init smp_init_cpus(void)
 +{
 +      if (soc_smp_init_ops && soc_smp_init_ops->smp_init_cpus)
 +              soc_smp_init_ops->smp_init_cpus();
 +}
 +
 +static void __init platform_smp_prepare_cpus(unsigned int max_cpus)
 +{
 +      if (soc_smp_ops && soc_smp_init_ops->smp_prepare_cpus)
 +              soc_smp_init_ops->smp_prepare_cpus(max_cpus);
 +}
 +
 +static void __cpuinit platform_secondary_init(unsigned int cpu)
 +{
 +      if (soc_smp_ops && soc_smp_ops->smp_secondary_init)
 +              soc_smp_ops->smp_secondary_init(cpu);
 +}
 +
 +int __cpuinit boot_secondary(unsigned int cpu, struct task_struct *idle)
 +{
 +      if (soc_smp_ops && soc_smp_ops->smp_boot_secondary)
 +              return soc_smp_ops->smp_boot_secondary(cpu, idle);
 +      return -ENOSYS;
 +}
 +
  #ifdef CONFIG_HOTPLUG_CPU
  static void percpu_timer_stop(void);
  
 +int dummy_cpu_kill(unsigned int cpu)
 +{
 +      return 1;
 +}
 +
 +int dummy_cpu_disable(unsigned int cpu)
 +{
 +      /*
 +       * we don't allow CPU 0 to be shutdown (it is still too special
 +       * e.g. clock tick interrupts)
 +       */
 +      return cpu == 0 ? -EPERM : 0;
 +}
 +
 +static int platform_cpu_kill(unsigned int cpu)
 +{
 +      if (soc_smp_ops && soc_smp_ops->cpu_kill)
 +              return soc_smp_ops->cpu_kill(cpu);
 +      return 0;
 +}
 +
 +static void __cpuinit platform_cpu_die(unsigned int cpu)
 +{
 +      if (soc_smp_ops && soc_smp_ops->cpu_die)
 +              soc_smp_ops->cpu_die(cpu);
 +}
 +
 +static int __cpuinit platform_cpu_disable(unsigned int cpu)
 +{
 +      if (soc_smp_ops && soc_smp_ops->cpu_disable)
 +              return soc_smp_ops->cpu_disable(cpu);
 +      return -EPERM;
 +}
 +
  /*
   * __cpu_disable runs on the processor to be shutdown.
   */
 -int __cpu_disable(void)
 +int __cpuinit __cpu_disable(void)
  {
        unsigned int cpu = smp_processor_id();
        struct task_struct *p;
@@@ -261,7 -176,7 +261,7 @@@ static DECLARE_COMPLETION(cpu_died)
   * called on the thread which is asking for a CPU to be shutdown -
   * waits until shutdown has completed, or it is timed out.
   */
 -void __cpu_die(unsigned int cpu)
 +void __cpuinit __cpu_die(unsigned int cpu)
  {
        if (!wait_for_completion_timeout(&cpu_died, msecs_to_jiffies(5000))) {
                pr_err("CPU%u: cpu didn't die\n", cpu);
@@@ -347,6 -262,8 +347,6 @@@ asmlinkage void __cpuinit secondary_sta
        enter_lazy_tlb(mm, current);
        local_flush_tlb_all();
  
 -      printk("CPU%u: Booted secondary processor\n", cpu);
 -
        cpu_init();
        preempt_disable();
        trace_hardirqs_off();
         */
        set_cpu_online(cpu, true);
        complete(&cpu_running);
 +      printk("CPU%u: Booted secondary processor\n", cpu);
  
        /*
         * Setup the percpu timer for this CPU.
@@@ -467,7 -383,6 +467,7 @@@ static const char *ipi_types[NR_IPI] = 
        S(IPI_CALL_FUNC, "Function call interrupts"),
        S(IPI_CALL_FUNC_SINGLE, "Single function call interrupts"),
        S(IPI_CPU_STOP, "CPU stop interrupts"),
 +      S(IPI_CPU_BACKTRACE, "CPU backtrace"),
  };
  
  void show_ipi_list(struct seq_file *p, int prec)
@@@ -504,9 -419,7 +504,9 @@@ static DEFINE_PER_CPU(struct clock_even
  static void ipi_timer(void)
  {
        struct clock_event_device *evt = &__get_cpu_var(percpu_clockevent);
 +      irq_enter();
        evt->event_handler(evt);
 +      irq_exit();
  }
  
  #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
@@@ -541,9 -454,6 +541,9 @@@ static struct local_timer_ops *lt_ops
  #ifdef CONFIG_LOCAL_TIMERS
  int local_timer_register(struct local_timer_ops *ops)
  {
 +      if (!is_smp() || !setup_max_cpus)
 +              return -ENXIO;
 +
        if (lt_ops)
                return -EBUSY;
  
@@@ -600,66 -510,10 +600,66 @@@ static void ipi_cpu_stop(unsigned int c
        local_fiq_disable();
        local_irq_disable();
  
 +#ifdef CONFIG_HOTPLUG_CPU
 +      platform_cpu_kill(cpu);
 +#endif
 +
        while (1)
                cpu_relax();
  }
  
 +static cpumask_t backtrace_mask;
 +static DEFINE_RAW_SPINLOCK(backtrace_lock);
 +
 +/* "in progress" flag of arch_trigger_all_cpu_backtrace */
 +static unsigned long backtrace_flag;
 +
 +void smp_send_all_cpu_backtrace(void)
 +{
 +      unsigned int this_cpu = smp_processor_id();
 +      int i;
 +
 +      if (test_and_set_bit(0, &backtrace_flag))
 +              /*
 +               * If there is already a trigger_all_cpu_backtrace() in progress
 +               * (backtrace_flag == 1), don't output double cpu dump infos.
 +               */
 +              return;
 +
 +      cpumask_copy(&backtrace_mask, cpu_online_mask);
 +      cpu_clear(this_cpu, backtrace_mask);
 +
 +      pr_info("Backtrace for cpu %d (current):\n", this_cpu);
 +      dump_stack();
 +
 +      pr_info("\nsending IPI to all other CPUs:\n");
 +      smp_cross_call(&backtrace_mask, IPI_CPU_BACKTRACE);
 +
 +      /* Wait for up to 10 seconds for all other CPUs to do the backtrace */
 +      for (i = 0; i < 10 * 1000; i++) {
 +              if (cpumask_empty(&backtrace_mask))
 +                      break;
 +              mdelay(1);
 +      }
 +
 +      clear_bit(0, &backtrace_flag);
 +      smp_mb__after_clear_bit();
 +}
 +
 +/*
 + * ipi_cpu_backtrace - handle IPI from smp_send_all_cpu_backtrace()
 + */
 +static void ipi_cpu_backtrace(unsigned int cpu, struct pt_regs *regs)
 +{
 +      if (cpu_isset(cpu, backtrace_mask)) {
 +              raw_spin_lock(&backtrace_lock);
 +              pr_warning("IPI backtrace for cpu %d\n", cpu);
 +              show_regs(regs);
 +              raw_spin_unlock(&backtrace_lock);
 +              cpu_clear(cpu, backtrace_mask);
 +      }
 +}
 +
  /*
   * Main handler for inter-processor interrupts
   */
@@@ -678,7 -532,9 +678,7 @@@ void handle_IPI(int ipinr, struct pt_re
  
        switch (ipinr) {
        case IPI_TIMER:
 -              irq_enter();
                ipi_timer();
 -              irq_exit();
                break;
  
        case IPI_RESCHEDULE:
                irq_exit();
                break;
  
 +      case IPI_CPU_BACKTRACE:
 +              ipi_cpu_backtrace(cpu, regs);
 +              break;
 +
        default:
                printk(KERN_CRIT "CPU%u: Unknown IPI message 0x%x\n",
                       cpu, ipinr);
@@@ -720,17 -572,26 +720,18 @@@ void smp_send_reschedule(int cpu
        smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);
  }
  
  void smp_send_stop(void)
  {
        unsigned long timeout;
 -      struct cpumask mask;
  
 -      cpumask_copy(&mask, cpu_online_mask);
 -      cpumask_clear_cpu(smp_processor_id(), &mask);
 -      if (!cpumask_empty(&mask))
 -              smp_cross_call(&mask, IPI_CPU_STOP);
 +      if (num_online_cpus() > 1) {
 +              struct cpumask mask;
 +              cpumask_copy(&mask, cpu_online_mask);
 +              cpumask_clear_cpu(smp_processor_id(), &mask);
 +
-               smp_cross_call(&mask, IPI_CPU_STOP);
++              if (!cpumask_empty(&mask))
++                      smp_cross_call(&mask, IPI_CPU_STOP);
 +      }
  
        /* Wait up to one second for other CPUs to stop */
        timeout = USEC_PER_SEC;
  
        if (num_online_cpus() > 1)
                pr_warning("SMP: failed to stop secondary CPUs\n");
 -
 -      smp_kill_cpus(&mask);
  }
  
  /*
diff --combined arch/arm/kernel/traps.c
@@@ -370,18 -370,10 +370,10 @@@ static int call_undef_hook(struct pt_re
  
  asmlinkage void __exception do_undefinstr(struct pt_regs *regs)
  {
-       unsigned int correction = thumb_mode(regs) ? 2 : 4;
        unsigned int instr;
        siginfo_t info;
        void __user *pc;
  
-       /*
-        * According to the ARM ARM, PC is 2 or 4 bytes ahead,
-        * depending whether we're in Thumb mode or not.
-        * Correct this offset.
-        */
-       regs->ARM_pc -= correction;
        pc = (void __user *)instruction_pointer(regs);
  
        if (processor_mode(regs) == SVC_MODE) {
@@@ -479,14 -471,14 +471,14 @@@ static int bad_syscall(int n, struct pt
        return regs->ARM_r0;
  }
  
 -static inline void
 +static inline int
  do_cache_op(unsigned long start, unsigned long end, int flags)
  {
        struct mm_struct *mm = current->active_mm;
        struct vm_area_struct *vma;
  
        if (end < start || flags)
 -              return;
 +              return -EINVAL;
  
        down_read(&mm->mmap_sem);
        vma = find_vma(mm, start);
                        end = vma->vm_end;
  
                up_read(&mm->mmap_sem);
 -              flush_cache_user_range(start, end);
 -              return;
 +              return flush_cache_user_range(start, end);
        }
        up_read(&mm->mmap_sem);
 +      return -EINVAL;
  }
  
  /*
@@@ -546,7 -538,8 +538,7 @@@ asmlinkage int arm_syscall(int no, stru
         * the specified region).
         */
        case NR(cacheflush):
 -              do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2);
 -              return 0;
 +              return do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2);
  
        case NR(usr26):
                if (!(elf_hwcap & HWCAP_26BIT))
diff --combined arch/arm/vfp/entry.S
@@@ -7,18 -7,20 +7,20 @@@
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
-  *
-  * Basic entry code, called from the kernel's undefined instruction trap.
-  *  r0  = faulted instruction
-  *  r2  = faulted PC+4
-  *  r9  = successful return
-  *  r10 = thread_info structure
-  *  lr  = failure return
   */
  #include <asm/thread_info.h>
  #include <asm/vfpmacros.h>
  #include "../kernel/entry-header.S"
  
+ @ VFP entry point.
+ @
+ @  r0  = instruction opcode (32-bit ARM or two 16-bit Thumb)
+ @  r2  = PC value to resume execution after successful emulation
+ @  r9  = normal "successful" return address
+ @  r10 = this threads thread_info structure
+ @  lr  = unrecognised instruction return address
+ @  IRQs disabled.
+ @
  ENTRY(do_vfp)
  #ifdef CONFIG_PREEMPT
        ldr     r4, [r10, #TI_PREEMPT]  @ get preempt count
@@@ -26,7 -28,6 +28,7 @@@
        str     r11, [r10, #TI_PREEMPT]
  #endif
        enable_irq
 +      str     r2, [sp, #S_PC]         @ update regs->ARM_pc for Thumb 2 case
        ldr     r4, .LCvfp
        ldr     r11, [r10, #TI_CPU]     @ CPU number
        add     r10, r10, #TI_VFPSTATE  @ r10 = workspace
@@@ -330,16 -330,6 +330,16 @@@ static int mt_input_mapping(struct hid_
        if (field->physical == HID_DG_STYLUS)
                return -1;
  
 +      /* Only map fields from TouchScreen or TouchPad collections.
 +         * We need to ignore fields that belong to other collections
 +         * such as Mouse that might have the same GenericDesktop usages. */
 +      if (field->application == HID_DG_TOUCHSCREEN)
 +              set_bit(INPUT_PROP_DIRECT, hi->input->propbit);
 +      else if (field->application == HID_DG_TOUCHPAD)
 +              set_bit(INPUT_PROP_POINTER, hi->input->propbit);
 +      else
 +              return 0;
 +
        switch (usage->hid & HID_USAGE_PAGE) {
  
        case HID_UP_GENDESK:
@@@ -950,6 -940,11 +950,11 @@@ static const struct hid_device_id mt_de
                HID_USB_DEVICE(USB_VENDOR_ID_PANASONIC,
                        USB_DEVICE_ID_PANABOARD_UBT880) },
  
+       /* Novatek Panel */
+       { .driver_data = MT_CLS_DEFAULT,
+               HID_USB_DEVICE(USB_VENDOR_ID_NOVATEK,
+                       USB_DEVICE_ID_NOVATEK_PCT) },
        /* PenMount panels */
        { .driver_data = MT_CLS_CONFIDENCE,
                HID_USB_DEVICE(USB_VENDOR_ID_PENMOUNT,
diff --combined drivers/net/tun.c
@@@ -185,7 -185,6 +185,6 @@@ static void __tun_detach(struct tun_str
        netif_tx_lock_bh(tun->dev);
        netif_carrier_off(tun->dev);
        tun->tfile = NULL;
-       tun->socket.file = NULL;
        netif_tx_unlock_bh(tun->dev);
  
        /* Drop read queue */
@@@ -1255,12 -1254,6 +1254,12 @@@ static long __tun_chr_ioctl(struct fil
        int vnet_hdr_sz;
        int ret;
  
 +#ifdef CONFIG_ANDROID_PARANOID_NETWORK
 +      if (cmd != TUNGETIFF && !capable(CAP_NET_ADMIN)) {
 +              return -EPERM;
 +      }
 +#endif
 +
        if (cmd == TUNSETIFF || _IOC_TYPE(cmd) == 0x89) {
                if (copy_from_user(&ifr, argp, ifreq_len))
                        return -EFAULT;
@@@ -2975,7 -2975,6 +2975,6 @@@ static const struct snd_pci_quirk cxt50
        SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO),
        SND_PCI_QUIRK(0x1028, 0x02f5, "Dell Vostro 320", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x1028, 0x0401, "Dell Vostro 1014", CXT5066_DELL_VOSTRO),
-       SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTRO),
        SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x1028, 0x050f, "Dell Inspiron", CXT5066_IDEAPAD),
        SND_PCI_QUIRK(0x1028, 0x0510, "Dell Vostro", CXT5066_IDEAPAD),
@@@ -4470,6 -4469,7 +4469,6 @@@ static int patch_conexant_auto(struct h
                break;
        case 0x14f15051:
                add_cx5051_fake_mutes(codec);
 -              codec->pin_amp_workaround = 1;
                apply_pin_fixup(codec, cxt5051_fixups, cxt_pincfg_tbl);
                break;
        default:
                apply_pin_fixup(codec, cxt5066_fixups, cxt_pincfg_tbl);
        }
  
 -      /* Show mute-led control only on HP laptops
 -       * This is a sort of white-list: on HP laptops, EAPD corresponds
 -       * only to the mute-LED without actualy amp function.  Meanwhile,
 -       * others may use EAPD really as an amp switch, so it might be
 -       * not good to expose it blindly.
 -       */
 -      switch (codec->subsystem_id >> 16) {
 -      case 0x103c:
 -              spec->vmaster_mute_led = 1;
 -              break;
 -      }
 -
        err = cx_auto_search_adcs(codec);
        if (err < 0)
                return err;