lkml.org 
[lkml]   [2012]   [Apr]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    SubjectRe: Linux 3.3.2
    diff --git a/Makefile b/Makefile
    index 026a227..ddcb70a 100644
    --- a/Makefile
    +++ b/Makefile
    @@ -1,6 +1,6 @@
    VERSION = 3
    PATCHLEVEL = 3
    -SUBLEVEL = 1
    +SUBLEVEL = 2
    EXTRAVERSION =
    NAME = Saber-toothed Squirrel

    diff --git a/arch/arm/mach-at91/at91sam9263_devices.c b/arch/arm/mach-at91/at91sam9263_devices.c
    index 366a776..026ae37 100644
    --- a/arch/arm/mach-at91/at91sam9263_devices.c
    +++ b/arch/arm/mach-at91/at91sam9263_devices.c
    @@ -71,7 +71,8 @@ void __init at91_add_device_usbh(struct at91_usbh_data *data)
    /* Enable VBus control for UHP ports */
    for (i = 0; i < data->ports; i++) {
    if (gpio_is_valid(data->vbus_pin[i]))
    - at91_set_gpio_output(data->vbus_pin[i], 0);
    + at91_set_gpio_output(data->vbus_pin[i],
    + data->vbus_pin_active_low[i]);
    }

    /* Enable overcurrent notification */
    diff --git a/arch/arm/mach-at91/at91sam9g45_devices.c b/arch/arm/mach-at91/at91sam9g45_devices.c
    index 96e2adc..a8c48be 100644
    --- a/arch/arm/mach-at91/at91sam9g45_devices.c
    +++ b/arch/arm/mach-at91/at91sam9g45_devices.c
    @@ -122,7 +122,8 @@ void __init at91_add_device_usbh_ohci(struct at91_usbh_data *data)
    /* Enable VBus control for UHP ports */
    for (i = 0; i < data->ports; i++) {
    if (gpio_is_valid(data->vbus_pin[i]))
    - at91_set_gpio_output(data->vbus_pin[i], 0);
    + at91_set_gpio_output(data->vbus_pin[i],
    + data->vbus_pin_active_low[i]);
    }

    /* Enable overcurrent notification */
    @@ -183,7 +184,8 @@ void __init at91_add_device_usbh_ehci(struct at91_usbh_data *data)
    /* Enable VBus control for UHP ports */
    for (i = 0; i < data->ports; i++) {
    if (gpio_is_valid(data->vbus_pin[i]))
    - at91_set_gpio_output(data->vbus_pin[i], 0);
    + at91_set_gpio_output(data->vbus_pin[i],
    + data->vbus_pin_active_low[i]);
    }

    usbh_ehci_data = *data;
    diff --git a/arch/arm/mach-at91/board-sam9263ek.c b/arch/arm/mach-at91/board-sam9263ek.c
    index 29f6605..39a8f79 100644
    --- a/arch/arm/mach-at91/board-sam9263ek.c
    +++ b/arch/arm/mach-at91/board-sam9263ek.c
    @@ -74,6 +74,7 @@ static void __init ek_init_early(void)
    static struct at91_usbh_data __initdata ek_usbh_data = {
    .ports = 2,
    .vbus_pin = { AT91_PIN_PA24, AT91_PIN_PA21 },
    + .vbus_pin_active_low = {1, 1},
    .overcurrent_pin= {-EINVAL, -EINVAL},
    };

    diff --git a/arch/arm/mach-at91/board-sam9m10g45ek.c b/arch/arm/mach-at91/board-sam9m10g45ek.c
    index ea0d1b9..1d2b1d1 100644
    --- a/arch/arm/mach-at91/board-sam9m10g45ek.c
    +++ b/arch/arm/mach-at91/board-sam9m10g45ek.c
    @@ -69,6 +69,7 @@ static void __init ek_init_early(void)
    static struct at91_usbh_data __initdata ek_usbh_hs_data = {
    .ports = 2,
    .vbus_pin = {AT91_PIN_PD1, AT91_PIN_PD3},
    + .vbus_pin_active_low = {1, 1},
    .overcurrent_pin= {-EINVAL, -EINVAL},
    };

    diff --git a/arch/m68k/mac/config.c b/arch/m68k/mac/config.c
    index f60ff5f..da3b8d8 100644
    --- a/arch/m68k/mac/config.c
    +++ b/arch/m68k/mac/config.c
    @@ -981,6 +981,9 @@ int __init mac_platform_init(void)
    {
    u8 *swim_base;

    + if (!MACH_IS_MAC)
    + return -ENODEV;
    +
    /*
    * Serial devices
    */
    diff --git a/arch/x86/include/asm/timer.h b/arch/x86/include/asm/timer.h
    index 431793e..34baa0e 100644
    --- a/arch/x86/include/asm/timer.h
    +++ b/arch/x86/include/asm/timer.h
    @@ -57,14 +57,10 @@ DECLARE_PER_CPU(unsigned long long, cyc2ns_offset);

    static inline unsigned long long __cycles_2_ns(unsigned long long cyc)
    {
    - unsigned long long quot;
    - unsigned long long rem;
    int cpu = smp_processor_id();
    unsigned long long ns = per_cpu(cyc2ns_offset, cpu);
    - quot = (cyc >> CYC2NS_SCALE_FACTOR);
    - rem = cyc & ((1ULL << CYC2NS_SCALE_FACTOR) - 1);
    - ns += quot * per_cpu(cyc2ns, cpu) +
    - ((rem * per_cpu(cyc2ns, cpu)) >> CYC2NS_SCALE_FACTOR);
    + ns += mult_frac(cyc, per_cpu(cyc2ns, cpu),
    + (1UL << CYC2NS_SCALE_FACTOR));
    return ns;
    }

    diff --git a/arch/x86/kernel/apic/io_apic.c b/arch/x86/kernel/apic/io_apic.c
    index 6d10a66..fb07275 100644
    --- a/arch/x86/kernel/apic/io_apic.c
    +++ b/arch/x86/kernel/apic/io_apic.c
    @@ -3967,36 +3967,18 @@ int mp_find_ioapic_pin(int ioapic, u32 gsi)
    static __init int bad_ioapic(unsigned long address)
    {
    if (nr_ioapics >= MAX_IO_APICS) {
    - pr_warn("WARNING: Max # of I/O APICs (%d) exceeded (found %d), skipping\n",
    - MAX_IO_APICS, nr_ioapics);
    + printk(KERN_WARNING "WARNING: Max # of I/O APICs (%d) exceeded "
    + "(found %d), skipping\n", MAX_IO_APICS, nr_ioapics);
    return 1;
    }
    if (!address) {
    - pr_warn("WARNING: Bogus (zero) I/O APIC address found in table, skipping!\n");
    + printk(KERN_WARNING "WARNING: Bogus (zero) I/O APIC address"
    + " found in table, skipping!\n");
    return 1;
    }
    return 0;
    }

    -static __init int bad_ioapic_register(int idx)
    -{
    - union IO_APIC_reg_00 reg_00;
    - union IO_APIC_reg_01 reg_01;
    - union IO_APIC_reg_02 reg_02;
    -
    - reg_00.raw = io_apic_read(idx, 0);
    - reg_01.raw = io_apic_read(idx, 1);
    - reg_02.raw = io_apic_read(idx, 2);
    -
    - if (reg_00.raw == -1 && reg_01.raw == -1 && reg_02.raw == -1) {
    - pr_warn("I/O APIC 0x%x registers return all ones, skipping!\n",
    - mpc_ioapic_addr(idx));
    - return 1;
    - }
    -
    - return 0;
    -}
    -
    void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
    {
    int idx = 0;
    @@ -4013,12 +3995,6 @@ void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
    ioapics[idx].mp_config.apicaddr = address;

    set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
    -
    - if (bad_ioapic_register(idx)) {
    - clear_fixmap(FIX_IO_APIC_BASE_0 + idx);
    - return;
    - }
    -
    ioapics[idx].mp_config.apicid = io_apic_unique_id(id);
    ioapics[idx].mp_config.apicver = io_apic_get_version(idx);

    @@ -4039,10 +4015,10 @@ void __init mp_register_ioapic(int id, u32 address, u32 gsi_base)
    if (gsi_cfg->gsi_end >= gsi_top)
    gsi_top = gsi_cfg->gsi_end + 1;

    - pr_info("IOAPIC[%d]: apic_id %d, version %d, address 0x%x, GSI %d-%d\n",
    - idx, mpc_ioapic_id(idx),
    - mpc_ioapic_ver(idx), mpc_ioapic_addr(idx),
    - gsi_cfg->gsi_base, gsi_cfg->gsi_end);
    + printk(KERN_INFO "IOAPIC[%d]: apic_id %d, version %d, address 0x%x, "
    + "GSI %d-%d\n", idx, mpc_ioapic_id(idx),
    + mpc_ioapic_ver(idx), mpc_ioapic_addr(idx),
    + gsi_cfg->gsi_base, gsi_cfg->gsi_end);

    nr_ioapics++;
    }
    diff --git a/arch/x86/kernel/kgdb.c b/arch/x86/kernel/kgdb.c
    index faba577..2f45c4c 100644
    --- a/arch/x86/kernel/kgdb.c
    +++ b/arch/x86/kernel/kgdb.c
    @@ -43,6 +43,8 @@
    #include <linux/smp.h>
    #include <linux/nmi.h>
    #include <linux/hw_breakpoint.h>
    +#include <linux/uaccess.h>
    +#include <linux/memory.h>

    #include <asm/debugreg.h>
    #include <asm/apicdef.h>
    @@ -740,6 +742,64 @@ void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long ip)
    regs->ip = ip;
    }

    +int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
    +{
    + int err;
    + char opc[BREAK_INSTR_SIZE];
    +
    + bpt->type = BP_BREAKPOINT;
    + err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
    + BREAK_INSTR_SIZE);
    + if (err)
    + return err;
    + err = probe_kernel_write((char *)bpt->bpt_addr,
    + arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
    +#ifdef CONFIG_DEBUG_RODATA
    + if (!err)
    + return err;
    + /*
    + * It is safe to call text_poke() because normal kernel execution
    + * is stopped on all cores, so long as the text_mutex is not locked.
    + */
    + if (mutex_is_locked(&text_mutex))
    + return -EBUSY;
    + text_poke((void *)bpt->bpt_addr, arch_kgdb_ops.gdb_bpt_instr,
    + BREAK_INSTR_SIZE);
    + err = probe_kernel_read(opc, (char *)bpt->bpt_addr, BREAK_INSTR_SIZE);
    + if (err)
    + return err;
    + if (memcmp(opc, arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE))
    + return -EINVAL;
    + bpt->type = BP_POKE_BREAKPOINT;
    +#endif /* CONFIG_DEBUG_RODATA */
    + return err;
    +}
    +
    +int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
    +{
    +#ifdef CONFIG_DEBUG_RODATA
    + int err;
    + char opc[BREAK_INSTR_SIZE];
    +
    + if (bpt->type != BP_POKE_BREAKPOINT)
    + goto knl_write;
    + /*
    + * It is safe to call text_poke() because normal kernel execution
    + * is stopped on all cores, so long as the text_mutex is not locked.
    + */
    + if (mutex_is_locked(&text_mutex))
    + goto knl_write;
    + text_poke((void *)bpt->bpt_addr, bpt->saved_instr, BREAK_INSTR_SIZE);
    + err = probe_kernel_read(opc, (char *)bpt->bpt_addr, BREAK_INSTR_SIZE);
    + if (err || memcmp(opc, bpt->saved_instr, BREAK_INSTR_SIZE))
    + goto knl_write;
    + return err;
    +knl_write:
    +#endif /* CONFIG_DEBUG_RODATA */
    + return probe_kernel_write((char *)bpt->bpt_addr,
    + (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
    +}
    +
    struct kgdb_arch arch_kgdb_ops = {
    /* Breakpoint instruction: */
    .gdb_bpt_instr = { 0xcc },
    diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
    index 6fcfcb3..c0b6611 100644
    --- a/arch/x86/kernel/tsc.c
    +++ b/arch/x86/kernel/tsc.c
    @@ -620,7 +620,8 @@ static void set_cyc2ns_scale(unsigned long cpu_khz, int cpu)

    if (cpu_khz) {
    *scale = (NSEC_PER_MSEC << CYC2NS_SCALE_FACTOR)/cpu_khz;
    - *offset = ns_now - (tsc_now * *scale >> CYC2NS_SCALE_FACTOR);
    + *offset = ns_now - mult_frac(tsc_now, *scale,
    + (1UL << CYC2NS_SCALE_FACTOR));
    }

    sched_clock_idle_wakeup_event(0);
    diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
    index 5671752..5a5b6e4 100644
    --- a/arch/x86/net/bpf_jit_comp.c
    +++ b/arch/x86/net/bpf_jit_comp.c
    @@ -289,7 +289,7 @@ void bpf_jit_compile(struct sk_filter *fp)
    EMIT2(0x24, K & 0xFF); /* and imm8,%al */
    } else if (K >= 0xFFFF0000) {
    EMIT2(0x66, 0x25); /* and imm16,%ax */
    - EMIT2(K, 2);
    + EMIT(K, 2);
    } else {
    EMIT1_off32(0x25, K); /* and imm32,%eax */
    }
    diff --git a/drivers/acpi/acpica/tbfadt.c b/drivers/acpi/acpica/tbfadt.c
    index c5d8704..4c9c760 100644
    --- a/drivers/acpi/acpica/tbfadt.c
    +++ b/drivers/acpi/acpica/tbfadt.c
    @@ -363,10 +363,6 @@ static void acpi_tb_convert_fadt(void)
    u32 address32;
    u32 i;

    - /* Update the local FADT table header length */
    -
    - acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
    -
    /*
    * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary.
    * Later code will always use the X 64-bit field. Also, check for an
    @@ -408,6 +404,10 @@ static void acpi_tb_convert_fadt(void)
    acpi_gbl_FADT.boot_flags = 0;
    }

    + /* Update the local FADT table header length */
    +
    + acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
    +
    /*
    * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"
    * generic address structures as necessary. Later code will always use
    diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
    index 3b599ab..641b545 100644
    --- a/drivers/acpi/processor_thermal.c
    +++ b/drivers/acpi/processor_thermal.c
    @@ -57,6 +57,27 @@ ACPI_MODULE_NAME("processor_thermal");
    static DEFINE_PER_CPU(unsigned int, cpufreq_thermal_reduction_pctg);
    static unsigned int acpi_thermal_cpufreq_is_init = 0;

    +#define reduction_pctg(cpu) \
    + per_cpu(cpufreq_thermal_reduction_pctg, phys_package_first_cpu(cpu))
    +
    +/*
    + * Emulate "per package data" using per cpu data (which should really be
    + * provided elsewhere)
    + *
    + * Note we can lose a CPU on cpu hotunplug, in this case we forget the state
    + * temporarily. Fortunately that's not a big issue here (I hope)
    + */
    +static int phys_package_first_cpu(int cpu)
    +{
    + int i;
    + int id = topology_physical_package_id(cpu);
    +
    + for_each_online_cpu(i)
    + if (topology_physical_package_id(i) == id)
    + return i;
    + return 0;
    +}
    +
    static int cpu_has_cpufreq(unsigned int cpu)
    {
    struct cpufreq_policy policy;
    @@ -76,7 +97,7 @@ static int acpi_thermal_cpufreq_notifier(struct notifier_block *nb,

    max_freq = (
    policy->cpuinfo.max_freq *
    - (100 - per_cpu(cpufreq_thermal_reduction_pctg, policy->cpu) * 20)
    + (100 - reduction_pctg(policy->cpu) * 20)
    ) / 100;

    cpufreq_verify_within_limits(policy, 0, max_freq);
    @@ -102,16 +123,28 @@ static int cpufreq_get_cur_state(unsigned int cpu)
    if (!cpu_has_cpufreq(cpu))
    return 0;

    - return per_cpu(cpufreq_thermal_reduction_pctg, cpu);
    + return reduction_pctg(cpu);
    }

    static int cpufreq_set_cur_state(unsigned int cpu, int state)
    {
    + int i;
    +
    if (!cpu_has_cpufreq(cpu))
    return 0;

    - per_cpu(cpufreq_thermal_reduction_pctg, cpu) = state;
    - cpufreq_update_policy(cpu);
    + reduction_pctg(cpu) = state;
    +
    + /*
    + * Update all the CPUs in the same package because they all
    + * contribute to the temperature and often share the same
    + * frequency.
    + */
    + for_each_online_cpu(i) {
    + if (topology_physical_package_id(i) ==
    + topology_physical_package_id(cpu))
    + cpufreq_update_policy(i);
    + }
    return 0;
    }

    @@ -119,10 +152,6 @@ void acpi_thermal_cpufreq_init(void)
    {
    int i;

    - for (i = 0; i < nr_cpu_ids; i++)
    - if (cpu_present(i))
    - per_cpu(cpufreq_thermal_reduction_pctg, i) = 0;
    -
    i = cpufreq_register_notifier(&acpi_thermal_cpufreq_notifier_block,
    CPUFREQ_POLICY_NOTIFIER);
    if (!i)
    diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
    index 6c9387d..72c644b 100644
    --- a/drivers/base/firmware_class.c
    +++ b/drivers/base/firmware_class.c
    @@ -81,6 +81,11 @@ enum {

    static int loading_timeout = 60; /* In seconds */

    +static inline long firmware_loading_timeout(void)
    +{
    + return loading_timeout > 0 ? loading_timeout * HZ : MAX_SCHEDULE_TIMEOUT;
    +}
    +
    /* fw_lock could be moved to 'struct firmware_priv' but since it is just
    * guarding for corner cases a global lock should be OK */
    static DEFINE_MUTEX(fw_lock);
    @@ -435,7 +440,7 @@ static void firmware_class_timeout(u_long data)
    }

    static struct firmware_priv *
    -fw_create_instance(struct firmware *firmware, const char *fw_name,
    +fw_create_instance(const struct firmware *firmware, const char *fw_name,
    struct device *device, bool uevent, bool nowait)
    {
    struct firmware_priv *fw_priv;
    @@ -449,7 +454,7 @@ fw_create_instance(struct firmware *firmware, const char *fw_name,
    goto err_out;
    }

    - fw_priv->fw = firmware;
    + fw_priv->fw = (struct firmware *)firmware;
    fw_priv->nowait = nowait;
    strcpy(fw_priv->fw_id, fw_name);
    init_completion(&fw_priv->completion);
    @@ -510,13 +515,10 @@ static void fw_destroy_instance(struct firmware_priv *fw_priv)
    device_unregister(f_dev);
    }

    -static int _request_firmware(const struct firmware **firmware_p,
    - const char *name, struct device *device,
    - bool uevent, bool nowait)
    +static int _request_firmware_prepare(const struct firmware **firmware_p,
    + const char *name, struct device *device)
    {
    - struct firmware_priv *fw_priv;
    struct firmware *firmware;
    - int retval = 0;

    if (!firmware_p)
    return -EINVAL;
    @@ -533,28 +535,33 @@ static int _request_firmware(const struct firmware **firmware_p,
    return 0;
    }

    - read_lock_usermodehelper();
    + return 1;
    +}

    - if (WARN_ON(usermodehelper_is_disabled())) {
    - dev_err(device, "firmware: %s will not be loaded\n", name);
    - retval = -EBUSY;
    - goto out;
    - }
    +static void _request_firmware_cleanup(const struct firmware **firmware_p)
    +{
    + release_firmware(*firmware_p);
    + *firmware_p = NULL;
    +}
    +
    +static int _request_firmware(const struct firmware *firmware,
    + const char *name, struct device *device,
    + bool uevent, bool nowait, long timeout)
    +{
    + struct firmware_priv *fw_priv;
    + int retval = 0;

    if (uevent)
    dev_dbg(device, "firmware: requesting %s\n", name);

    fw_priv = fw_create_instance(firmware, name, device, uevent, nowait);
    - if (IS_ERR(fw_priv)) {
    - retval = PTR_ERR(fw_priv);
    - goto out;
    - }
    + if (IS_ERR(fw_priv))
    + return PTR_ERR(fw_priv);

    if (uevent) {
    - if (loading_timeout > 0)
    + if (timeout != MAX_SCHEDULE_TIMEOUT)
    mod_timer(&fw_priv->timeout,
    - round_jiffies_up(jiffies +
    - loading_timeout * HZ));
    + round_jiffies_up(jiffies + timeout));

    kobject_uevent(&fw_priv->dev.kobj, KOBJ_ADD);
    }
    @@ -571,15 +578,6 @@ static int _request_firmware(const struct firmware **firmware_p,
    mutex_unlock(&fw_lock);

    fw_destroy_instance(fw_priv);
    -
    -out:
    - read_unlock_usermodehelper();
    -
    - if (retval) {
    - release_firmware(firmware);
    - *firmware_p = NULL;
    - }
    -
    return retval;
    }

    @@ -602,7 +600,24 @@ int
    request_firmware(const struct firmware **firmware_p, const char *name,
    struct device *device)
    {
    - return _request_firmware(firmware_p, name, device, true, false);
    + int ret;
    +
    + ret = _request_firmware_prepare(firmware_p, name, device);
    + if (ret <= 0)
    + return ret;
    +
    + ret = usermodehelper_read_trylock();
    + if (WARN_ON(ret)) {
    + dev_err(device, "firmware: %s will not be loaded\n", name);
    + } else {
    + ret = _request_firmware(*firmware_p, name, device, true, false,
    + firmware_loading_timeout());
    + usermodehelper_read_unlock();
    + }
    + if (ret)
    + _request_firmware_cleanup(firmware_p);
    +
    + return ret;
    }

    /**
    @@ -633,6 +648,7 @@ static int request_firmware_work_func(void *arg)
    {
    struct firmware_work *fw_work = arg;
    const struct firmware *fw;
    + long timeout;
    int ret;

    if (!arg) {
    @@ -640,8 +656,24 @@ static int request_firmware_work_func(void *arg)
    return 0;
    }

    - ret = _request_firmware(&fw, fw_work->name, fw_work->device,
    - fw_work->uevent, true);
    + ret = _request_firmware_prepare(&fw, fw_work->name, fw_work->device);
    + if (ret <= 0)
    + goto out;
    +
    + timeout = usermodehelper_read_lock_wait(firmware_loading_timeout());
    + if (timeout) {
    + ret = _request_firmware(fw, fw_work->name, fw_work->device,
    + fw_work->uevent, true, timeout);
    + usermodehelper_read_unlock();
    + } else {
    + dev_dbg(fw_work->device, "firmware: %s loading timed out\n",
    + fw_work->name);
    + ret = -EAGAIN;
    + }
    + if (ret)
    + _request_firmware_cleanup(&fw);
    +
    + out:
    fw_work->cont(fw, fw_work->context);

    module_put(fw_work->module);
    diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
    index 541f821..bd0f394 100644
    --- a/drivers/base/power/runtime.c
    +++ b/drivers/base/power/runtime.c
    @@ -532,6 +532,8 @@ static int rpm_suspend(struct device *dev, int rpmflags)
    dev->power.suspend_time = ktime_set(0, 0);
    dev->power.max_time_suspended_ns = -1;
    dev->power.deferred_resume = false;
    + wake_up_all(&dev->power.wait_queue);
    +
    if (retval == -EAGAIN || retval == -EBUSY) {
    dev->power.runtime_error = 0;

    @@ -547,7 +549,6 @@ static int rpm_suspend(struct device *dev, int rpmflags)
    } else {
    pm_runtime_cancel_pending(dev);
    }
    - wake_up_all(&dev->power.wait_queue);
    goto out;
    }

    diff --git a/drivers/base/regmap/regcache-rbtree.c b/drivers/base/regmap/regcache-rbtree.c
    index 32620c4..d1179fd 100644
    --- a/drivers/base/regmap/regcache-rbtree.c
    +++ b/drivers/base/regmap/regcache-rbtree.c
    @@ -137,6 +137,7 @@ static int rbtree_show(struct seq_file *s, void *ignored)
    unsigned int base, top;
    int nodes = 0;
    int registers = 0;
    + int average;

    mutex_lock(&map->lock);

    @@ -151,8 +152,13 @@ static int rbtree_show(struct seq_file *s, void *ignored)
    registers += top - base + 1;
    }

    + if (nodes)
    + average = registers / nodes;
    + else
    + average = 0;
    +
    seq_printf(s, "%d nodes, %d registers, average %d registers\n",
    - nodes, registers, registers / nodes);
    + nodes, registers, average);

    mutex_unlock(&map->lock);

    diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c
    index a4d6cb0..6595180 100644
    --- a/drivers/dma/ioat/dma.c
    +++ b/drivers/dma/ioat/dma.c
    @@ -548,9 +548,9 @@ void ioat_dma_unmap(struct ioat_chan_common *chan, enum dma_ctrl_flags flags,
    PCI_DMA_TODEVICE, flags, 0);
    }

    -unsigned long ioat_get_current_completion(struct ioat_chan_common *chan)
    +dma_addr_t ioat_get_current_completion(struct ioat_chan_common *chan)
    {
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;
    u64 completion;

    completion = *chan->completion;
    @@ -571,7 +571,7 @@ unsigned long ioat_get_current_completion(struct ioat_chan_common *chan)
    }

    bool ioat_cleanup_preamble(struct ioat_chan_common *chan,
    - unsigned long *phys_complete)
    + dma_addr_t *phys_complete)
    {
    *phys_complete = ioat_get_current_completion(chan);
    if (*phys_complete == chan->last_completion)
    @@ -582,14 +582,14 @@ bool ioat_cleanup_preamble(struct ioat_chan_common *chan,
    return true;
    }

    -static void __cleanup(struct ioat_dma_chan *ioat, unsigned long phys_complete)
    +static void __cleanup(struct ioat_dma_chan *ioat, dma_addr_t phys_complete)
    {
    struct ioat_chan_common *chan = &ioat->base;
    struct list_head *_desc, *n;
    struct dma_async_tx_descriptor *tx;

    - dev_dbg(to_dev(chan), "%s: phys_complete: %lx\n",
    - __func__, phys_complete);
    + dev_dbg(to_dev(chan), "%s: phys_complete: %llx\n",
    + __func__, (unsigned long long) phys_complete);
    list_for_each_safe(_desc, n, &ioat->used_desc) {
    struct ioat_desc_sw *desc;

    @@ -655,7 +655,7 @@ static void __cleanup(struct ioat_dma_chan *ioat, unsigned long phys_complete)
    static void ioat1_cleanup(struct ioat_dma_chan *ioat)
    {
    struct ioat_chan_common *chan = &ioat->base;
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    prefetch(chan->completion);

    @@ -701,7 +701,7 @@ static void ioat1_timer_event(unsigned long data)
    mod_timer(&chan->timer, jiffies + COMPLETION_TIMEOUT);
    spin_unlock_bh(&ioat->desc_lock);
    } else if (test_bit(IOAT_COMPLETION_PENDING, &chan->state)) {
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    spin_lock_bh(&ioat->desc_lock);
    /* if we haven't made progress and we have already
    diff --git a/drivers/dma/ioat/dma.h b/drivers/dma/ioat/dma.h
    index 5216c8a..8bebddd 100644
    --- a/drivers/dma/ioat/dma.h
    +++ b/drivers/dma/ioat/dma.h
    @@ -88,7 +88,7 @@ struct ioatdma_device {
    struct ioat_chan_common {
    struct dma_chan common;
    void __iomem *reg_base;
    - unsigned long last_completion;
    + dma_addr_t last_completion;
    spinlock_t cleanup_lock;
    dma_cookie_t completed_cookie;
    unsigned long state;
    @@ -333,7 +333,7 @@ int __devinit ioat_dma_self_test(struct ioatdma_device *device);
    void __devexit ioat_dma_remove(struct ioatdma_device *device);
    struct dca_provider * __devinit ioat_dca_init(struct pci_dev *pdev,
    void __iomem *iobase);
    -unsigned long ioat_get_current_completion(struct ioat_chan_common *chan);
    +dma_addr_t ioat_get_current_completion(struct ioat_chan_common *chan);
    void ioat_init_channel(struct ioatdma_device *device,
    struct ioat_chan_common *chan, int idx);
    enum dma_status ioat_dma_tx_status(struct dma_chan *c, dma_cookie_t cookie,
    @@ -341,7 +341,7 @@ enum dma_status ioat_dma_tx_status(struct dma_chan *c, dma_cookie_t cookie,
    void ioat_dma_unmap(struct ioat_chan_common *chan, enum dma_ctrl_flags flags,
    size_t len, struct ioat_dma_descriptor *hw);
    bool ioat_cleanup_preamble(struct ioat_chan_common *chan,
    - unsigned long *phys_complete);
    + dma_addr_t *phys_complete);
    void ioat_kobject_add(struct ioatdma_device *device, struct kobj_type *type);
    void ioat_kobject_del(struct ioatdma_device *device);
    extern const struct sysfs_ops ioat_sysfs_ops;
    diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
    index 5d65f83..cb8864d 100644
    --- a/drivers/dma/ioat/dma_v2.c
    +++ b/drivers/dma/ioat/dma_v2.c
    @@ -126,7 +126,7 @@ static void ioat2_start_null_desc(struct ioat2_dma_chan *ioat)
    spin_unlock_bh(&ioat->prep_lock);
    }

    -static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
    +static void __cleanup(struct ioat2_dma_chan *ioat, dma_addr_t phys_complete)
    {
    struct ioat_chan_common *chan = &ioat->base;
    struct dma_async_tx_descriptor *tx;
    @@ -178,7 +178,7 @@ static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
    static void ioat2_cleanup(struct ioat2_dma_chan *ioat)
    {
    struct ioat_chan_common *chan = &ioat->base;
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    spin_lock_bh(&chan->cleanup_lock);
    if (ioat_cleanup_preamble(chan, &phys_complete))
    @@ -259,7 +259,7 @@ int ioat2_reset_sync(struct ioat_chan_common *chan, unsigned long tmo)
    static void ioat2_restart_channel(struct ioat2_dma_chan *ioat)
    {
    struct ioat_chan_common *chan = &ioat->base;
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    ioat2_quiesce(chan, 0);
    if (ioat_cleanup_preamble(chan, &phys_complete))
    @@ -274,7 +274,7 @@ void ioat2_timer_event(unsigned long data)
    struct ioat_chan_common *chan = &ioat->base;

    if (test_bit(IOAT_COMPLETION_PENDING, &chan->state)) {
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;
    u64 status;

    status = ioat_chansts(chan);
    diff --git a/drivers/dma/ioat/dma_v3.c b/drivers/dma/ioat/dma_v3.c
    index f519c93..2dbf32b 100644
    --- a/drivers/dma/ioat/dma_v3.c
    +++ b/drivers/dma/ioat/dma_v3.c
    @@ -256,7 +256,7 @@ static bool desc_has_ext(struct ioat_ring_ent *desc)
    * The difference from the dma_v2.c __cleanup() is that this routine
    * handles extended descriptors and dma-unmapping raid operations.
    */
    -static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
    +static void __cleanup(struct ioat2_dma_chan *ioat, dma_addr_t phys_complete)
    {
    struct ioat_chan_common *chan = &ioat->base;
    struct ioat_ring_ent *desc;
    @@ -314,7 +314,7 @@ static void __cleanup(struct ioat2_dma_chan *ioat, unsigned long phys_complete)
    static void ioat3_cleanup(struct ioat2_dma_chan *ioat)
    {
    struct ioat_chan_common *chan = &ioat->base;
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    spin_lock_bh(&chan->cleanup_lock);
    if (ioat_cleanup_preamble(chan, &phys_complete))
    @@ -333,7 +333,7 @@ static void ioat3_cleanup_event(unsigned long data)
    static void ioat3_restart_channel(struct ioat2_dma_chan *ioat)
    {
    struct ioat_chan_common *chan = &ioat->base;
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;

    ioat2_quiesce(chan, 0);
    if (ioat_cleanup_preamble(chan, &phys_complete))
    @@ -348,7 +348,7 @@ static void ioat3_timer_event(unsigned long data)
    struct ioat_chan_common *chan = &ioat->base;

    if (test_bit(IOAT_COMPLETION_PENDING, &chan->state)) {
    - unsigned long phys_complete;
    + dma_addr_t phys_complete;
    u64 status;

    status = ioat_chansts(chan);
    diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
    index aada26f..7432e72 100644
    --- a/drivers/gpu/drm/drm_fb_helper.c
    +++ b/drivers/gpu/drm/drm_fb_helper.c
    @@ -617,9 +617,13 @@ int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
    return -EINVAL;

    /* Need to resize the fb object !!! */
    - if (var->bits_per_pixel > fb->bits_per_pixel || var->xres > fb->width || var->yres > fb->height) {
    + if (var->bits_per_pixel > fb->bits_per_pixel ||
    + var->xres > fb->width || var->yres > fb->height ||
    + var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
    DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
    - "object %dx%d-%d > %dx%d-%d\n", var->xres, var->yres, var->bits_per_pixel,
    + "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
    + var->xres, var->yres, var->bits_per_pixel,
    + var->xres_virtual, var->yres_virtual,
    fb->width, fb->height, fb->bits_per_pixel);
    return -EINVAL;
    }
    diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
    index c1043e5..5ee318c 100644
    --- a/drivers/gpu/drm/i915/i915_drv.c
    +++ b/drivers/gpu/drm/i915/i915_drv.c
    @@ -508,7 +508,9 @@ static int i915_drm_thaw(struct drm_device *dev)
    drm_irq_install(dev);

    /* Resume the modeset for every activated CRTC */
    + mutex_lock(&dev->mode_config.mutex);
    drm_helper_resume_force_mode(dev);
    + mutex_unlock(&dev->mode_config.mutex);

    if (IS_IRONLAKE_M(dev))
    ironlake_enable_rc6(dev);
    diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
    index 558ac71..3e6429a 100644
    --- a/drivers/gpu/drm/i915/i915_reg.h
    +++ b/drivers/gpu/drm/i915/i915_reg.h
    @@ -2313,6 +2313,7 @@
    #define PIPECONF_DISABLE 0
    #define PIPECONF_DOUBLE_WIDE (1<<30)
    #define I965_PIPECONF_ACTIVE (1<<30)
    +#define PIPECONF_FRAME_START_DELAY_MASK (3<<27)
    #define PIPECONF_SINGLE_WIDE 0
    #define PIPECONF_PIPE_UNLOCKED 0
    #define PIPECONF_PIPE_LOCKED (1<<25)
    diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c
    index 63880e2..22efb08 100644
    --- a/drivers/gpu/drm/i915/intel_bios.c
    +++ b/drivers/gpu/drm/i915/intel_bios.c
    @@ -24,6 +24,7 @@
    * Eric Anholt <eric@anholt.net>
    *
    */
    +#include <linux/dmi.h>
    #include <drm/drm_dp_helper.h>
    #include "drmP.h"
    #include "drm.h"
    @@ -621,6 +622,26 @@ init_vbt_defaults(struct drm_i915_private *dev_priv)
    dev_priv->edp.bpp = 18;
    }

    +static int __init intel_no_opregion_vbt_callback(const struct dmi_system_id *id)
    +{
    + DRM_DEBUG_KMS("Falling back to manually reading VBT from "
    + "VBIOS ROM for %s\n",
    + id->ident);
    + return 1;
    +}
    +
    +static const struct dmi_system_id intel_no_opregion_vbt[] = {
    + {
    + .callback = intel_no_opregion_vbt_callback,
    + .ident = "ThinkCentre A57",
    + .matches = {
    + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
    + DMI_MATCH(DMI_PRODUCT_NAME, "97027RG"),
    + },
    + },
    + { }
    +};
    +
    /**
    * intel_parse_bios - find VBT and initialize settings from the BIOS
    * @dev: DRM device
    @@ -641,7 +662,7 @@ intel_parse_bios(struct drm_device *dev)
    init_vbt_defaults(dev_priv);

    /* XXX Should this validation be moved to intel_opregion.c? */
    - if (dev_priv->opregion.vbt) {
    + if (!dmi_check_system(intel_no_opregion_vbt) && dev_priv->opregion.vbt) {
    struct vbt_header *vbt = dev_priv->opregion.vbt;
    if (memcmp(vbt->signature, "$VBT", 4) == 0) {
    DRM_DEBUG_KMS("Using VBT from OpRegion: %20s\n",
    diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
    index 397087c..2163818 100644
    --- a/drivers/gpu/drm/i915/intel_display.c
    +++ b/drivers/gpu/drm/i915/intel_display.c
    @@ -7497,6 +7497,12 @@ static void intel_sanitize_modesetting(struct drm_device *dev,
    struct drm_i915_private *dev_priv = dev->dev_private;
    u32 reg, val;

    + /* Clear any frame start delays used for debugging left by the BIOS */
    + for_each_pipe(pipe) {
    + reg = PIPECONF(pipe);
    + I915_WRITE(reg, I915_READ(reg) & ~PIPECONF_FRAME_START_DELAY_MASK);
    + }
    +
    if (HAS_PCH_SPLIT(dev))
    return;

    diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
    index aa84832..8b42354 100644
    --- a/drivers/gpu/drm/i915/intel_lvds.c
    +++ b/drivers/gpu/drm/i915/intel_lvds.c
    @@ -739,6 +739,14 @@ static const struct dmi_system_id intel_no_lvds[] = {
    DMI_MATCH(DMI_BOARD_NAME, "AT5NM10T-I"),
    },
    },
    + {
    + .callback = intel_no_lvds_dmi_callback,
    + .ident = "MSI Wind Box DC500",
    + .matches = {
    + DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
    + DMI_MATCH(DMI_BOARD_NAME, "MS-7469"),
    + },
    + },

    { } /* terminating entry */
    };
    diff --git a/drivers/gpu/drm/i915/intel_sprite.c b/drivers/gpu/drm/i915/intel_sprite.c
    index a083504..a82b097 100644
    --- a/drivers/gpu/drm/i915/intel_sprite.c
    +++ b/drivers/gpu/drm/i915/intel_sprite.c
    @@ -411,6 +411,9 @@ intel_update_plane(struct drm_plane *plane, struct drm_crtc *crtc,

    old_obj = intel_plane->obj;

    + src_w = src_w >> 16;
    + src_h = src_h >> 16;
    +
    /* Pipe must be running... */
    if (!(I915_READ(PIPECONF(pipe)) & PIPECONF_ENABLE))
    return -EINVAL;
    diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
    index d1bd239..5ce9bf5 100644
    --- a/drivers/gpu/drm/radeon/atom.c
    +++ b/drivers/gpu/drm/radeon/atom.c
    @@ -1306,8 +1306,11 @@ struct atom_context *atom_parse(struct card_info *card, void *bios)

    int atom_asic_init(struct atom_context *ctx)
    {
    + struct radeon_device *rdev = ctx->card->dev->dev_private;
    int hwi = CU16(ctx->data_table + ATOM_DATA_FWI_PTR);
    uint32_t ps[16];
    + int ret;
    +
    memset(ps, 0, 64);

    ps[0] = cpu_to_le32(CU32(hwi + ATOM_FWI_DEFSCLK_PTR));
    @@ -1317,7 +1320,17 @@ int atom_asic_init(struct atom_context *ctx)

    if (!CU16(ctx->cmd_table + 4 + 2 * ATOM_CMD_INIT))
    return 1;
    - return atom_execute_table(ctx, ATOM_CMD_INIT, ps);
    + ret = atom_execute_table(ctx, ATOM_CMD_INIT, ps);
    + if (ret)
    + return ret;
    +
    + memset(ps, 0, 64);
    +
    + if (rdev->family < CHIP_R600) {
    + if (CU16(ctx->cmd_table + 4 + 2 * ATOM_CMD_SPDFANCNTL))
    + atom_execute_table(ctx, ATOM_CMD_SPDFANCNTL, ps);
    + }
    + return ret;
    }

    void atom_destroy(struct atom_context *ctx)
    diff --git a/drivers/gpu/drm/radeon/atom.h b/drivers/gpu/drm/radeon/atom.h
    index 93cfe20..25fea63 100644
    --- a/drivers/gpu/drm/radeon/atom.h
    +++ b/drivers/gpu/drm/radeon/atom.h
    @@ -44,6 +44,7 @@
    #define ATOM_CMD_SETSCLK 0x0A
    #define ATOM_CMD_SETMCLK 0x0B
    #define ATOM_CMD_SETPCLK 0x0C
    +#define ATOM_CMD_SPDFANCNTL 0x39

    #define ATOM_DATA_FWI_PTR 0xC
    #define ATOM_DATA_IIO_PTR 0x32
    diff --git a/drivers/media/dvb/dvb-core/dvb_frontend.c b/drivers/media/dvb/dvb-core/dvb_frontend.c
    index fbbe545..e721975 100644
    --- a/drivers/media/dvb/dvb-core/dvb_frontend.c
    +++ b/drivers/media/dvb/dvb-core/dvb_frontend.c
    @@ -143,6 +143,8 @@ struct dvb_frontend_private {
    static void dvb_frontend_wakeup(struct dvb_frontend *fe);
    static int dtv_get_frontend(struct dvb_frontend *fe,
    struct dvb_frontend_parameters *p_out);
    +static int dtv_property_legacy_params_sync(struct dvb_frontend *fe,
    + struct dvb_frontend_parameters *p);

    static bool has_get_frontend(struct dvb_frontend *fe)
    {
    @@ -655,6 +657,8 @@ restart:
    dprintk("%s: Retune requested, FESTATE_RETUNE\n", __func__);
    re_tune = true;
    fepriv->state = FESTATE_TUNED;
    + } else {
    + re_tune = false;
    }

    if (fe->ops.tune)
    @@ -695,6 +699,7 @@ restart:
    fepriv->algo_status |= DVBFE_ALGO_SEARCH_AGAIN;
    fepriv->delay = HZ / 2;
    }
    + dtv_property_legacy_params_sync(fe, &fepriv->parameters_out);
    fe->ops.read_status(fe, &s);
    if (s != fepriv->status) {
    dvb_frontend_add_event(fe, s); /* update event list */
    @@ -1831,6 +1836,13 @@ static int dtv_set_frontend(struct dvb_frontend *fe)
    return -EINVAL;

    /*
    + * Initialize output parameters to match the values given by
    + * the user. FE_SET_FRONTEND triggers an initial frontend event
    + * with status = 0, which copies output parameters to userspace.
    + */
    + dtv_property_legacy_params_sync(fe, &fepriv->parameters_out);
    +
    + /*
    * Be sure that the bandwidth will be filled for all
    * non-satellite systems, as tuners need to know what
    * low pass/Nyquist half filter should be applied, in
    diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
    index 4a44f9a..b76b0ac 100644
    --- a/drivers/media/video/uvc/uvc_video.c
    +++ b/drivers/media/video/uvc/uvc_video.c
    @@ -468,22 +468,30 @@ uvc_video_clock_decode(struct uvc_streaming *stream, struct uvc_buffer *buf,
    spin_unlock_irqrestore(&stream->clock.lock, flags);
    }

    -static int uvc_video_clock_init(struct uvc_streaming *stream)
    +static void uvc_video_clock_reset(struct uvc_streaming *stream)
    {
    struct uvc_clock *clock = &stream->clock;

    - spin_lock_init(&clock->lock);
    clock->head = 0;
    clock->count = 0;
    - clock->size = 32;
    clock->last_sof = -1;
    clock->sof_offset = -1;
    +}
    +
    +static int uvc_video_clock_init(struct uvc_streaming *stream)
    +{
    + struct uvc_clock *clock = &stream->clock;
    +
    + spin_lock_init(&clock->lock);
    + clock->size = 32;

    clock->samples = kmalloc(clock->size * sizeof(*clock->samples),
    GFP_KERNEL);
    if (clock->samples == NULL)
    return -ENOMEM;

    + uvc_video_clock_reset(stream);
    +
    return 0;
    }

    @@ -1424,8 +1432,6 @@ static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)

    if (free_buffers)
    uvc_free_urb_buffers(stream);
    -
    - uvc_video_clock_cleanup(stream);
    }

    /*
    @@ -1555,10 +1561,6 @@ static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)

    uvc_video_stats_start(stream);

    - ret = uvc_video_clock_init(stream);
    - if (ret < 0)
    - return ret;
    -
    if (intf->num_altsetting > 1) {
    struct usb_host_endpoint *best_ep = NULL;
    unsigned int best_psize = 3 * 1024;
    @@ -1683,6 +1685,8 @@ int uvc_video_resume(struct uvc_streaming *stream, int reset)

    stream->frozen = 0;

    + uvc_video_clock_reset(stream);
    +
    ret = uvc_commit_video(stream, &stream->ctrl);
    if (ret < 0) {
    uvc_queue_enable(&stream->queue, 0);
    @@ -1819,25 +1823,35 @@ int uvc_video_enable(struct uvc_streaming *stream, int enable)
    uvc_uninit_video(stream, 1);
    usb_set_interface(stream->dev->udev, stream->intfnum, 0);
    uvc_queue_enable(&stream->queue, 0);
    + uvc_video_clock_cleanup(stream);
    return 0;
    }

    - ret = uvc_queue_enable(&stream->queue, 1);
    + ret = uvc_video_clock_init(stream);
    if (ret < 0)
    return ret;

    + ret = uvc_queue_enable(&stream->queue, 1);
    + if (ret < 0)
    + goto error_queue;
    +
    /* Commit the streaming parameters. */
    ret = uvc_commit_video(stream, &stream->ctrl);
    - if (ret < 0) {
    - uvc_queue_enable(&stream->queue, 0);
    - return ret;
    - }
    + if (ret < 0)
    + goto error_commit;

    ret = uvc_init_video(stream, GFP_KERNEL);
    - if (ret < 0) {
    - usb_set_interface(stream->dev->udev, stream->intfnum, 0);
    - uvc_queue_enable(&stream->queue, 0);
    - }
    + if (ret < 0)
    + goto error_video;
    +
    + return 0;
    +
    +error_video:
    + usb_set_interface(stream->dev->udev, stream->intfnum, 0);
    +error_commit:
    + uvc_queue_enable(&stream->queue, 0);
    +error_queue:
    + uvc_video_clock_cleanup(stream);

    return ret;
    }
    diff --git a/drivers/mfd/da9052-spi.c b/drivers/mfd/da9052-spi.c
    index cdbc7ca..2693c87 100644
    --- a/drivers/mfd/da9052-spi.c
    +++ b/drivers/mfd/da9052-spi.c
    @@ -21,7 +21,7 @@

    #include <linux/mfd/da9052/da9052.h>

    -static int da9052_spi_probe(struct spi_device *spi)
    +static int __devinit da9052_spi_probe(struct spi_device *spi)
    {
    int ret;
    const struct spi_device_id *id = spi_get_device_id(spi);
    @@ -61,7 +61,7 @@ err:
    return ret;
    }

    -static int da9052_spi_remove(struct spi_device *spi)
    +static int __devexit da9052_spi_remove(struct spi_device *spi)
    {
    struct da9052 *da9052 = dev_get_drvdata(&spi->dev);

    diff --git a/drivers/mfd/twl6030-irq.c b/drivers/mfd/twl6030-irq.c
    index c6b456a..aa367a2 100644
    --- a/drivers/mfd/twl6030-irq.c
    +++ b/drivers/mfd/twl6030-irq.c
    @@ -185,8 +185,17 @@ static int twl6030_irq_thread(void *data)
    }
    local_irq_enable();
    }
    - ret = twl_i2c_write(TWL_MODULE_PIH, sts.bytes,
    - REG_INT_STS_A, 3); /* clear INT_STS_A */
    +
    + /*
    + * NOTE:
    + * Simulation confirms that documentation is wrong w.r.t the
    + * interrupt status clear operation. A single *byte* write to
    + * any one of STS_A to STS_C register results in all three
    + * STS registers being reset. Since it does not matter which
    + * value is written, all three registers are cleared on a
    + * single byte write, so we just use 0x0 to clear.
    + */
    + ret = twl_i2c_write_u8(TWL_MODULE_PIH, 0x00, REG_INT_STS_A);
    if (ret)
    pr_warning("twl6030: I2C error in clearing PIH ISR\n");

    diff --git a/drivers/misc/kgdbts.c b/drivers/misc/kgdbts.c
    index 3f7ad83..3aa9a96 100644
    --- a/drivers/misc/kgdbts.c
    +++ b/drivers/misc/kgdbts.c
    @@ -134,12 +134,17 @@ static int force_hwbrks;
    static int hwbreaks_ok;
    static int hw_break_val;
    static int hw_break_val2;
    +static int cont_instead_of_sstep;
    +static unsigned long cont_thread_id;
    +static unsigned long sstep_thread_id;
    #if defined(CONFIG_ARM) || defined(CONFIG_MIPS) || defined(CONFIG_SPARC)
    static int arch_needs_sstep_emulation = 1;
    #else
    static int arch_needs_sstep_emulation;
    #endif
    +static unsigned long cont_addr;
    static unsigned long sstep_addr;
    +static int restart_from_top_after_write;
    static int sstep_state;

    /* Storage for the registers, in GDB format. */
    @@ -187,7 +192,8 @@ static int kgdbts_unreg_thread(void *ptr)
    */
    while (!final_ack)
    msleep_interruptible(1500);
    -
    + /* Pause for any other threads to exit after final ack. */
    + msleep_interruptible(1000);
    if (configured)
    kgdb_unregister_io_module(&kgdbts_io_ops);
    configured = 0;
    @@ -211,7 +217,7 @@ static unsigned long lookup_addr(char *arg)
    if (!strcmp(arg, "kgdbts_break_test"))
    addr = (unsigned long)kgdbts_break_test;
    else if (!strcmp(arg, "sys_open"))
    - addr = (unsigned long)sys_open;
    + addr = (unsigned long)do_sys_open;
    else if (!strcmp(arg, "do_fork"))
    addr = (unsigned long)do_fork;
    else if (!strcmp(arg, "hw_break_val"))
    @@ -283,6 +289,16 @@ static void hw_break_val_write(void)
    hw_break_val++;
    }

    +static int get_thread_id_continue(char *put_str, char *arg)
    +{
    + char *ptr = &put_str[11];
    +
    + if (put_str[1] != 'T' || put_str[2] != '0')
    + return 1;
    + kgdb_hex2long(&ptr, &cont_thread_id);
    + return 0;
    +}
    +
    static int check_and_rewind_pc(char *put_str, char *arg)
    {
    unsigned long addr = lookup_addr(arg);
    @@ -299,13 +315,21 @@ static int check_and_rewind_pc(char *put_str, char *arg)
    if (addr + BREAK_INSTR_SIZE == ip)
    offset = -BREAK_INSTR_SIZE;
    #endif
    - if (strcmp(arg, "silent") && ip + offset != addr) {
    +
    + if (arch_needs_sstep_emulation && sstep_addr &&
    + ip + offset == sstep_addr &&
    + ((!strcmp(arg, "sys_open") || !strcmp(arg, "do_fork")))) {
    + /* This is special case for emulated single step */
    + v2printk("Emul: rewind hit single step bp\n");
    + restart_from_top_after_write = 1;
    + } else if (strcmp(arg, "silent") && ip + offset != addr) {
    eprintk("kgdbts: BP mismatch %lx expected %lx\n",
    ip + offset, addr);
    return 1;
    }
    /* Readjust the instruction pointer if needed */
    ip += offset;
    + cont_addr = ip;
    #ifdef GDB_ADJUSTS_BREAK_OFFSET
    instruction_pointer_set(&kgdbts_regs, ip);
    #endif
    @@ -315,6 +339,8 @@ static int check_and_rewind_pc(char *put_str, char *arg)
    static int check_single_step(char *put_str, char *arg)
    {
    unsigned long addr = lookup_addr(arg);
    + static int matched_id;
    +
    /*
    * From an arch indepent point of view the instruction pointer
    * should be on a different instruction
    @@ -324,6 +350,29 @@ static int check_single_step(char *put_str, char *arg)
    gdb_regs_to_pt_regs(kgdbts_gdb_regs, &kgdbts_regs);
    v2printk("Singlestep stopped at IP: %lx\n",
    instruction_pointer(&kgdbts_regs));
    +
    + if (sstep_thread_id != cont_thread_id) {
    + /*
    + * Ensure we stopped in the same thread id as before, else the
    + * debugger should continue until the original thread that was
    + * single stepped is scheduled again, emulating gdb's behavior.
    + */
    + v2printk("ThrID does not match: %lx\n", cont_thread_id);
    + if (arch_needs_sstep_emulation) {
    + if (matched_id &&
    + instruction_pointer(&kgdbts_regs) != addr)
    + goto continue_test;
    + matched_id++;
    + ts.idx -= 2;
    + sstep_state = 0;
    + return 0;
    + }
    + cont_instead_of_sstep = 1;
    + ts.idx -= 4;
    + return 0;
    + }
    +continue_test:
    + matched_id = 0;
    if (instruction_pointer(&kgdbts_regs) == addr) {
    eprintk("kgdbts: SingleStep failed at %lx\n",
    instruction_pointer(&kgdbts_regs));
    @@ -365,10 +414,40 @@ static int got_break(char *put_str, char *arg)
    return 1;
    }

    +static void get_cont_catch(char *arg)
    +{
    + /* Always send detach because the test is completed at this point */
    + fill_get_buf("D");
    +}
    +
    +static int put_cont_catch(char *put_str, char *arg)
    +{
    + /* This is at the end of the test and we catch any and all input */
    + v2printk("kgdbts: cleanup task: %lx\n", sstep_thread_id);
    + ts.idx--;
    + return 0;
    +}
    +
    +static int emul_reset(char *put_str, char *arg)
    +{
    + if (strncmp(put_str, "$OK", 3))
    + return 1;
    + if (restart_from_top_after_write) {
    + restart_from_top_after_write = 0;
    + ts.idx = -1;
    + }
    + return 0;
    +}
    +
    static void emul_sstep_get(char *arg)
    {
    if (!arch_needs_sstep_emulation) {
    - fill_get_buf(arg);
    + if (cont_instead_of_sstep) {
    + cont_instead_of_sstep = 0;
    + fill_get_buf("c");
    + } else {
    + fill_get_buf(arg);
    + }
    return;
    }
    switch (sstep_state) {
    @@ -398,9 +477,11 @@ static void emul_sstep_get(char *arg)
    static int emul_sstep_put(char *put_str, char *arg)
    {
    if (!arch_needs_sstep_emulation) {
    - if (!strncmp(put_str+1, arg, 2))
    - return 0;
    - return 1;
    + char *ptr = &put_str[11];
    + if (put_str[1] != 'T' || put_str[2] != '0')
    + return 1;
    + kgdb_hex2long(&ptr, &sstep_thread_id);
    + return 0;
    }
    switch (sstep_state) {
    case 1:
    @@ -411,8 +492,7 @@ static int emul_sstep_put(char *put_str, char *arg)
    v2printk("Stopped at IP: %lx\n",
    instruction_pointer(&kgdbts_regs));
    /* Want to stop at IP + break instruction size by default */
    - sstep_addr = instruction_pointer(&kgdbts_regs) +
    - BREAK_INSTR_SIZE;
    + sstep_addr = cont_addr + BREAK_INSTR_SIZE;
    break;
    case 2:
    if (strncmp(put_str, "$OK", 3)) {
    @@ -424,6 +504,9 @@ static int emul_sstep_put(char *put_str, char *arg)
    if (strncmp(put_str, "$T0", 3)) {
    eprintk("kgdbts: failed continue sstep\n");
    return 1;
    + } else {
    + char *ptr = &put_str[11];
    + kgdb_hex2long(&ptr, &sstep_thread_id);
    }
    break;
    case 4:
    @@ -502,10 +585,10 @@ static struct test_struct bad_read_test[] = {
    static struct test_struct singlestep_break_test[] = {
    { "?", "S0*" }, /* Clear break points */
    { "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
    - { "c", "T0*", }, /* Continue */
    + { "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
    + { "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
    { "g", "kgdbts_break_test", NULL, check_and_rewind_pc },
    { "write", "OK", write_regs }, /* Write registers */
    - { "kgdbts_break_test", "OK", sw_rem_break }, /*remove breakpoint */
    { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
    { "g", "kgdbts_break_test", NULL, check_single_step },
    { "kgdbts_break_test", "OK", sw_break, }, /* set sw breakpoint */
    @@ -523,16 +606,16 @@ static struct test_struct singlestep_break_test[] = {
    static struct test_struct do_fork_test[] = {
    { "?", "S0*" }, /* Clear break points */
    { "do_fork", "OK", sw_break, }, /* set sw breakpoint */
    - { "c", "T0*", }, /* Continue */
    - { "g", "do_fork", NULL, check_and_rewind_pc }, /* check location */
    - { "write", "OK", write_regs }, /* Write registers */
    + { "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
    { "do_fork", "OK", sw_rem_break }, /*remove breakpoint */
    + { "g", "do_fork", NULL, check_and_rewind_pc }, /* check location */
    + { "write", "OK", write_regs, emul_reset }, /* Write registers */
    { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
    { "g", "do_fork", NULL, check_single_step },
    { "do_fork", "OK", sw_break, }, /* set sw breakpoint */
    { "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
    { "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
    - { "", "" },
    + { "", "", get_cont_catch, put_cont_catch },
    };

    /* Test for hitting a breakpoint at sys_open for what ever the number
    @@ -541,16 +624,16 @@ static struct test_struct do_fork_test[] = {
    static struct test_struct sys_open_test[] = {
    { "?", "S0*" }, /* Clear break points */
    { "sys_open", "OK", sw_break, }, /* set sw breakpoint */
    - { "c", "T0*", }, /* Continue */
    - { "g", "sys_open", NULL, check_and_rewind_pc }, /* check location */
    - { "write", "OK", write_regs }, /* Write registers */
    + { "c", "T0*", NULL, get_thread_id_continue }, /* Continue */
    { "sys_open", "OK", sw_rem_break }, /*remove breakpoint */
    + { "g", "sys_open", NULL, check_and_rewind_pc }, /* check location */
    + { "write", "OK", write_regs, emul_reset }, /* Write registers */
    { "s", "T0*", emul_sstep_get, emul_sstep_put }, /* Single step */
    { "g", "sys_open", NULL, check_single_step },
    { "sys_open", "OK", sw_break, }, /* set sw breakpoint */
    { "7", "T0*", skip_back_repeat_test }, /* Loop based on repeat_test */
    { "D", "OK", NULL, final_ack_set }, /* detach and unregister I/O */
    - { "", "" },
    + { "", "", get_cont_catch, put_cont_catch },
    };

    /*
    @@ -693,8 +776,8 @@ static int run_simple_test(int is_get_char, int chr)
    /* This callback is a put char which is when kgdb sends data to
    * this I/O module.
    */
    - if (ts.tst[ts.idx].get[0] == '\0' &&
    - ts.tst[ts.idx].put[0] == '\0') {
    + if (ts.tst[ts.idx].get[0] == '\0' && ts.tst[ts.idx].put[0] == '\0' &&
    + !ts.tst[ts.idx].get_handler) {
    eprintk("kgdbts: ERROR: beyond end of test on"
    " '%s' line %i\n", ts.name, ts.idx);
    return 0;
    @@ -907,6 +990,17 @@ static void kgdbts_run_tests(void)
    if (ptr)
    sstep_test = simple_strtol(ptr+1, NULL, 10);

    + /* All HW break point tests */
    + if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) {
    + hwbreaks_ok = 1;
    + v1printk("kgdbts:RUN hw breakpoint test\n");
    + run_breakpoint_test(1);
    + v1printk("kgdbts:RUN hw write breakpoint test\n");
    + run_hw_break_test(1);
    + v1printk("kgdbts:RUN access write breakpoint test\n");
    + run_hw_break_test(0);
    + }
    +
    /* required internal KGDB tests */
    v1printk("kgdbts:RUN plant and detach test\n");
    run_plant_and_detach_test(0);
    @@ -924,35 +1018,11 @@ static void kgdbts_run_tests(void)

    /* ===Optional tests=== */

    - /* All HW break point tests */
    - if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT) {
    - hwbreaks_ok = 1;
    - v1printk("kgdbts:RUN hw breakpoint test\n");
    - run_breakpoint_test(1);
    - v1printk("kgdbts:RUN hw write breakpoint test\n");
    - run_hw_break_test(1);
    - v1printk("kgdbts:RUN access write breakpoint test\n");
    - run_hw_break_test(0);
    - }
    -
    if (nmi_sleep) {
    v1printk("kgdbts:RUN NMI sleep %i seconds test\n", nmi_sleep);
    run_nmi_sleep_test(nmi_sleep);
    }

    -#ifdef CONFIG_DEBUG_RODATA
    - /* Until there is an api to write to read-only text segments, use
    - * HW breakpoints for the remainder of any tests, else print a
    - * failure message if hw breakpoints do not work.
    - */
    - if (!(arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT && hwbreaks_ok)) {
    - eprintk("kgdbts: HW breakpoints do not work,"
    - "skipping remaining tests\n");
    - return;
    - }
    - force_hwbrks = 1;
    -#endif /* CONFIG_DEBUG_RODATA */
    -
    /* If the do_fork test is run it will be the last test that is
    * executed because a kernel thread will be spawned at the very
    * end to unregister the debug hooks.
    diff --git a/drivers/mmc/core/sdio_bus.c b/drivers/mmc/core/sdio_bus.c
    index 40989e6..236842e 100644
    --- a/drivers/mmc/core/sdio_bus.c
    +++ b/drivers/mmc/core/sdio_bus.c
    @@ -192,9 +192,15 @@ static int sdio_bus_remove(struct device *dev)
    return ret;
    }

    -#ifdef CONFIG_PM_RUNTIME
    +#ifdef CONFIG_PM
    +
    +static int pm_no_operation(struct device *dev)
    +{
    + return 0;
    +}

    static const struct dev_pm_ops sdio_bus_pm_ops = {
    + SET_SYSTEM_SLEEP_PM_OPS(pm_no_operation, pm_no_operation)
    SET_RUNTIME_PM_OPS(
    pm_generic_runtime_suspend,
    pm_generic_runtime_resume,
    @@ -204,11 +210,11 @@ static const struct dev_pm_ops sdio_bus_pm_ops = {

    #define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops)

    -#else /* !CONFIG_PM_RUNTIME */
    +#else /* !CONFIG_PM */

    #define SDIO_PM_OPS_PTR NULL

    -#endif /* !CONFIG_PM_RUNTIME */
    +#endif /* !CONFIG_PM */

    static struct bus_type sdio_bus_type = {
    .name = "sdio",
    diff --git a/drivers/mmc/host/atmel-mci.c b/drivers/mmc/host/atmel-mci.c
    index e4449a5..3a57964 100644
    --- a/drivers/mmc/host/atmel-mci.c
    +++ b/drivers/mmc/host/atmel-mci.c
    @@ -480,7 +480,14 @@ err:
    static inline unsigned int atmci_ns_to_clocks(struct atmel_mci *host,
    unsigned int ns)
    {
    - return (ns * (host->bus_hz / 1000000) + 999) / 1000;
    + /*
    + * It is easier here to use us instead of ns for the timeout,
    + * it prevents from overflows during calculation.
    + */
    + unsigned int us = DIV_ROUND_UP(ns, 1000);
    +
    + /* Maximum clock frequency is host->bus_hz/2 */
    + return us * (DIV_ROUND_UP(host->bus_hz, 2000000));
    }

    static void atmci_set_timeout(struct atmel_mci *host,
    diff --git a/drivers/mmc/host/sdhci-dove.c b/drivers/mmc/host/sdhci-dove.c
    index 46fd1fd..177f697 100644
    --- a/drivers/mmc/host/sdhci-dove.c
    +++ b/drivers/mmc/host/sdhci-dove.c
    @@ -20,6 +20,7 @@
    */

    #include <linux/io.h>
    +#include <linux/module.h>
    #include <linux/mmc/host.h>

    #include "sdhci-pltfm.h"
    diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
    index e7e46d1..17f5517 100644
    --- a/drivers/mtd/devices/block2mtd.c
    +++ b/drivers/mtd/devices/block2mtd.c
    @@ -283,6 +283,7 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
    dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
    dev->mtd.erasesize = erase_size;
    dev->mtd.writesize = 1;
    + dev->mtd.writebufsize = PAGE_SIZE;
    dev->mtd.type = MTD_RAM;
    dev->mtd.flags = MTD_CAP_RAM;
    dev->mtd.erase = block2mtd_erase;
    diff --git a/drivers/mtd/devices/doc2000.c b/drivers/mtd/devices/doc2000.c
    index b1cdf64..87a431c 100644
    --- a/drivers/mtd/devices/doc2000.c
    +++ b/drivers/mtd/devices/doc2000.c
    @@ -562,7 +562,7 @@ void DoC2k_init(struct mtd_info *mtd)

    mtd->type = MTD_NANDFLASH;
    mtd->flags = MTD_CAP_NANDFLASH;
    - mtd->writesize = 512;
    + mtd->writebufsize = mtd->writesize = 512;
    mtd->oobsize = 16;
    mtd->owner = THIS_MODULE;
    mtd->erase = doc_erase;
    diff --git a/drivers/mtd/devices/doc2001.c b/drivers/mtd/devices/doc2001.c
    index 7543b98..9eacf67 100644
    --- a/drivers/mtd/devices/doc2001.c
    +++ b/drivers/mtd/devices/doc2001.c
    @@ -346,7 +346,7 @@ void DoCMil_init(struct mtd_info *mtd)

    /* FIXME: erase size is not always 8KiB */
    mtd->erasesize = 0x2000;
    - mtd->writesize = 512;
    + mtd->writebufsize = mtd->writesize = 512;
    mtd->oobsize = 16;
    mtd->owner = THIS_MODULE;
    mtd->erase = doc_erase;
    diff --git a/drivers/mtd/devices/doc2001plus.c b/drivers/mtd/devices/doc2001plus.c
    index 177510d..69fb598 100644
    --- a/drivers/mtd/devices/doc2001plus.c
    +++ b/drivers/mtd/devices/doc2001plus.c
    @@ -467,7 +467,7 @@ void DoCMilPlus_init(struct mtd_info *mtd)

    mtd->type = MTD_NANDFLASH;
    mtd->flags = MTD_CAP_NANDFLASH;
    - mtd->writesize = 512;
    + mtd->writebufsize = mtd->writesize = 512;
    mtd->oobsize = 16;
    mtd->owner = THIS_MODULE;
    mtd->erase = doc_erase;
    diff --git a/drivers/mtd/devices/docg3.c b/drivers/mtd/devices/docg3.c
    index ad11ef0a..690198f 100644
    --- a/drivers/mtd/devices/docg3.c
    +++ b/drivers/mtd/devices/docg3.c
    @@ -1817,7 +1817,7 @@ static void __init doc_set_driver_info(int chip_id, struct mtd_info *mtd)
    mtd->erasesize = DOC_LAYOUT_BLOCK_SIZE * DOC_LAYOUT_NBPLANES;
    if (docg3->reliable == 2)
    mtd->erasesize /= 2;
    - mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
    + mtd->writebufsize = mtd->writesize = DOC_LAYOUT_PAGE_SIZE;
    mtd->oobsize = DOC_LAYOUT_OOB_SIZE;
    mtd->owner = THIS_MODULE;
    mtd->erase = doc_erase;
    diff --git a/drivers/mtd/devices/lart.c b/drivers/mtd/devices/lart.c
    index 3a11ea6..5f12668 100644
    --- a/drivers/mtd/devices/lart.c
    +++ b/drivers/mtd/devices/lart.c
    @@ -630,6 +630,7 @@ static int __init lart_flash_init (void)
    mtd.name = module_name;
    mtd.type = MTD_NORFLASH;
    mtd.writesize = 1;
    + mtd.writebufsize = 4;
    mtd.flags = MTD_CAP_NORFLASH;
    mtd.size = FLASH_BLOCKSIZE_PARAM * FLASH_NUMBLOCKS_16m_PARAM + FLASH_BLOCKSIZE_MAIN * FLASH_NUMBLOCKS_16m_MAIN;
    mtd.erasesize = FLASH_BLOCKSIZE_MAIN;
    diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
    index 7c60ddd..94eef7d 100644
    --- a/drivers/mtd/devices/m25p80.c
    +++ b/drivers/mtd/devices/m25p80.c
    @@ -932,6 +932,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
    ppdata.of_node = spi->dev.of_node;
    flash->mtd.dev.parent = &spi->dev;
    flash->page_size = info->page_size;
    + flash->mtd.writebufsize = flash->page_size;

    if (info->addr_width)
    flash->addr_width = info->addr_width;
    diff --git a/drivers/mtd/devices/sst25l.c b/drivers/mtd/devices/sst25l.c
    index 5fc1983..aa10d08 100644
    --- a/drivers/mtd/devices/sst25l.c
    +++ b/drivers/mtd/devices/sst25l.c
    @@ -402,6 +402,7 @@ static int __devinit sst25l_probe(struct spi_device *spi)
    flash->mtd.flags = MTD_CAP_NORFLASH;
    flash->mtd.erasesize = flash_info->erase_size;
    flash->mtd.writesize = flash_info->page_size;
    + flash->mtd.writebufsize = flash_info->page_size;
    flash->mtd.size = flash_info->page_size * flash_info->nr_pages;
    flash->mtd.erase = sst25l_erase;
    flash->mtd.read = sst25l_read;
    diff --git a/drivers/mtd/maps/ixp4xx.c b/drivers/mtd/maps/ixp4xx.c
    index 8b54101..e864fc6 100644
    --- a/drivers/mtd/maps/ixp4xx.c
    +++ b/drivers/mtd/maps/ixp4xx.c
    @@ -182,6 +182,9 @@ static int ixp4xx_flash_probe(struct platform_device *dev)
    {
    struct flash_platform_data *plat = dev->dev.platform_data;
    struct ixp4xx_flash_info *info;
    + struct mtd_part_parser_data ppdata = {
    + .origin = dev->resource->start,
    + };
    int err = -1;

    if (!plat)
    @@ -247,7 +250,7 @@ static int ixp4xx_flash_probe(struct platform_device *dev)
    /* Use the fast version */
    info->map.write = ixp4xx_write16;

    - err = mtd_device_parse_register(info->mtd, probes, dev->resource->start,
    + err = mtd_device_parse_register(info->mtd, probes, &ppdata,
    plat->parts, plat->nr_parts);
    if (err) {
    printk(KERN_ERR "Could not parse partitions\n");
    diff --git a/drivers/mtd/maps/lantiq-flash.c b/drivers/mtd/maps/lantiq-flash.c
    index 7b889de..cf7a3cd 100644
    --- a/drivers/mtd/maps/lantiq-flash.c
    +++ b/drivers/mtd/maps/lantiq-flash.c
    @@ -45,6 +45,7 @@ struct ltq_mtd {
    };

    static char ltq_map_name[] = "ltq_nor";
    +static const char *ltq_probe_types[] __devinitconst = { "cmdlinepart", NULL };

    static map_word
    ltq_read16(struct map_info *map, unsigned long adr)
    @@ -168,7 +169,7 @@ ltq_mtd_probe(struct platform_device *pdev)
    cfi->addr_unlock1 ^= 1;
    cfi->addr_unlock2 ^= 1;

    - err = mtd_device_parse_register(ltq_mtd->mtd, NULL, 0,
    + err = mtd_device_parse_register(ltq_mtd->mtd, ltq_probe_types, 0,
    ltq_mtd_data->parts, ltq_mtd_data->nr_parts);
    if (err) {
    dev_err(&pdev->dev, "failed to add partitions\n");
    diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
    index 493ec2f..f39f83e 100644
    --- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
    +++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
    @@ -1124,7 +1124,7 @@ static int gpmi_block_markbad(struct mtd_info *mtd, loff_t ofs)
    chip->bbt[block >> 2] |= 0x01 << ((block & 0x03) << 1);

    /* Do we have a flash based bad block table ? */
    - if (chip->options & NAND_BBT_USE_FLASH)
    + if (chip->bbt_options & NAND_BBT_USE_FLASH)
    ret = nand_update_bbt(mtd, ofs);
    else {
    chipnr = (int)(ofs >> chip->chip_shift);
    diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
    index 35c2a20..83047783 100644
    --- a/drivers/net/ethernet/broadcom/tg3.c
    +++ b/drivers/net/ethernet/broadcom/tg3.c
    @@ -2771,7 +2771,9 @@ static void tg3_power_down_phy(struct tg3 *tp, bool do_low_power)
    if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5700 ||
    GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5704 ||
    (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5780 &&
    - (tp->phy_flags & TG3_PHYFLG_MII_SERDES)))
    + (tp->phy_flags & TG3_PHYFLG_MII_SERDES)) ||
    + (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5717 &&
    + !tp->pci_fn))
    return;

    if (GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5784_AX ||
    diff --git a/drivers/net/ethernet/freescale/fsl_pq_mdio.c b/drivers/net/ethernet/freescale/fsl_pq_mdio.c
    index 9eb8159..f7f0bf5 100644
    --- a/drivers/net/ethernet/freescale/fsl_pq_mdio.c
    +++ b/drivers/net/ethernet/freescale/fsl_pq_mdio.c
    @@ -356,13 +356,13 @@ static int fsl_pq_mdio_probe(struct platform_device *ofdev)

    if (prop)
    tbiaddr = *prop;
    - }

    - if (tbiaddr == -1) {
    - err = -EBUSY;
    - goto err_free_irqs;
    - } else {
    - out_be32(tbipa, tbiaddr);
    + if (tbiaddr == -1) {
    + err = -EBUSY;
    + goto err_free_irqs;
    + } else {
    + out_be32(tbipa, tbiaddr);
    + }
    }

    err = of_mdiobus_register(new_bus, np);
    diff --git a/drivers/net/ethernet/marvell/sky2.c b/drivers/net/ethernet/marvell/sky2.c
    index b4a208e..ec6136f 100644
    --- a/drivers/net/ethernet/marvell/sky2.c
    +++ b/drivers/net/ethernet/marvell/sky2.c
    @@ -1767,13 +1767,14 @@ static int sky2_open(struct net_device *dev)

    sky2_hw_up(sky2);

    + /* Enable interrupts from phy/mac for port */
    + imask = sky2_read32(hw, B0_IMSK);
    +
    if (hw->chip_id == CHIP_ID_YUKON_OPT ||
    hw->chip_id == CHIP_ID_YUKON_PRM ||
    hw->chip_id == CHIP_ID_YUKON_OP_2)
    imask |= Y2_IS_PHY_QLNK; /* enable PHY Quick Link */

    - /* Enable interrupts from phy/mac for port */
    - imask = sky2_read32(hw, B0_IMSK);
    imask |= portirq_msk[port];
    sky2_write32(hw, B0_IMSK, imask);
    sky2_read32(hw, B0_IMSK);
    diff --git a/drivers/net/ethernet/via/via-rhine.c b/drivers/net/ethernet/via/via-rhine.c
    index 10b18eb..6764d0d 100644
    --- a/drivers/net/ethernet/via/via-rhine.c
    +++ b/drivers/net/ethernet/via/via-rhine.c
    @@ -503,30 +503,32 @@ static int rhine_vlan_rx_add_vid(struct net_device *dev, unsigned short vid);
    static int rhine_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid);
    static void rhine_restart_tx(struct net_device *dev);

    -static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool high)
    +static void rhine_wait_bit(struct rhine_private *rp, u8 reg, u8 mask, bool low)
    {
    void __iomem *ioaddr = rp->base;
    int i;

    for (i = 0; i < 1024; i++) {
    - if (high ^ !!(ioread8(ioaddr + reg) & mask))
    + bool has_mask_bits = !!(ioread8(ioaddr + reg) & mask);
    +
    + if (low ^ has_mask_bits)
    break;
    udelay(10);
    }
    if (i > 64) {
    netif_dbg(rp, hw, rp->dev, "%s bit wait (%02x/%02x) cycle "
    - "count: %04d\n", high ? "high" : "low", reg, mask, i);
    + "count: %04d\n", low ? "low" : "high", reg, mask, i);
    }
    }

    static void rhine_wait_bit_high(struct rhine_private *rp, u8 reg, u8 mask)
    {
    - rhine_wait_bit(rp, reg, mask, true);
    + rhine_wait_bit(rp, reg, mask, false);
    }

    static void rhine_wait_bit_low(struct rhine_private *rp, u8 reg, u8 mask)
    {
    - rhine_wait_bit(rp, reg, mask, false);
    + rhine_wait_bit(rp, reg, mask, true);
    }

    static u32 rhine_get_events(struct rhine_private *rp)
    diff --git a/drivers/net/usb/cdc_eem.c b/drivers/net/usb/cdc_eem.c
    index 439690b..685a4e2 100644
    --- a/drivers/net/usb/cdc_eem.c
    +++ b/drivers/net/usb/cdc_eem.c
    @@ -93,6 +93,7 @@ static int eem_bind(struct usbnet *dev, struct usb_interface *intf)
    /* no jumbogram (16K) support for now */

    dev->net->hard_header_len += EEM_HEAD + ETH_FCS_LEN;
    + dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;

    return 0;
    }
    diff --git a/drivers/net/usb/zaurus.c b/drivers/net/usb/zaurus.c
    index c3197ce..34db195 100644
    --- a/drivers/net/usb/zaurus.c
    +++ b/drivers/net/usb/zaurus.c
    @@ -337,6 +337,11 @@ static const struct usb_device_id products [] = {
    .driver_info = ZAURUS_PXA_INFO,
    },
    {
    + /* Motorola Rokr E6 */
    + USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6027, USB_CLASS_COMM,
    + USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
    + .driver_info = (unsigned long) &bogus_mdlm_info,
    +}, {
    /* Motorola MOTOMAGX phones */
    USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6425, USB_CLASS_COMM,
    USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
    diff --git a/drivers/net/wireless/ath/ath9k/calib.c b/drivers/net/wireless/ath/ath9k/calib.c
    index 2f4b48e..e5cceb0 100644
    --- a/drivers/net/wireless/ath/ath9k/calib.c
    +++ b/drivers/net/wireless/ath/ath9k/calib.c
    @@ -20,7 +20,6 @@

    /* Common calibration code */

    -#define ATH9K_NF_TOO_HIGH -60

    static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer)
    {
    @@ -346,10 +345,10 @@ static void ath9k_hw_nf_sanitize(struct ath_hw *ah, s16 *nf)
    "NF calibrated [%s] [chain %d] is %d\n",
    (i >= 3 ? "ext" : "ctl"), i % 3, nf[i]);

    - if (nf[i] > ATH9K_NF_TOO_HIGH) {
    + if (nf[i] > limit->max) {
    ath_dbg(common, CALIBRATE,
    "NF[%d] (%d) > MAX (%d), correcting to MAX\n",
    - i, nf[i], ATH9K_NF_TOO_HIGH);
    + i, nf[i], limit->max);
    nf[i] = limit->max;
    } else if (nf[i] < limit->min) {
    ath_dbg(common, CALIBRATE,
    diff --git a/drivers/net/wireless/ath/ath9k/main.c b/drivers/net/wireless/ath/ath9k/main.c
    index a09abc2..4a00806 100644
    --- a/drivers/net/wireless/ath/ath9k/main.c
    +++ b/drivers/net/wireless/ath/ath9k/main.c
    @@ -118,15 +118,13 @@ void ath9k_ps_restore(struct ath_softc *sc)
    if (--sc->ps_usecount != 0)
    goto unlock;

    - if (sc->ps_flags & PS_WAIT_FOR_TX_ACK)
    - goto unlock;
    -
    - if (sc->ps_idle)
    + if (sc->ps_idle && (sc->ps_flags & PS_WAIT_FOR_TX_ACK))
    mode = ATH9K_PM_FULL_SLEEP;
    else if (sc->ps_enabled &&
    !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
    PS_WAIT_FOR_CAB |
    - PS_WAIT_FOR_PSPOLL_DATA)))
    + PS_WAIT_FOR_PSPOLL_DATA |
    + PS_WAIT_FOR_TX_ACK)))
    mode = ATH9K_PM_NETWORK_SLEEP;
    else
    goto unlock;
    diff --git a/drivers/net/wireless/iwlegacy/3945-mac.c b/drivers/net/wireless/iwlegacy/3945-mac.c
    index a7dfba8..a2ec369 100644
    --- a/drivers/net/wireless/iwlegacy/3945-mac.c
    +++ b/drivers/net/wireless/iwlegacy/3945-mac.c
    @@ -2684,7 +2684,6 @@ il3945_bg_restart(struct work_struct *data)

    if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
    mutex_lock(&il->mutex);
    - il->ctx.vif = NULL;
    il->is_open = 0;
    mutex_unlock(&il->mutex);
    il3945_down(il);
    diff --git a/drivers/net/wireless/iwlegacy/4965-mac.c b/drivers/net/wireless/iwlegacy/4965-mac.c
    index 1667232..b00712c 100644
    --- a/drivers/net/wireless/iwlegacy/4965-mac.c
    +++ b/drivers/net/wireless/iwlegacy/4965-mac.c
    @@ -5381,7 +5381,6 @@ il4965_bg_restart(struct work_struct *data)

    if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
    mutex_lock(&il->mutex);
    - il->ctx.vif = NULL;
    il->is_open = 0;

    __il4965_down(il);
    diff --git a/drivers/net/wireless/iwlegacy/common.c b/drivers/net/wireless/iwlegacy/common.c
    index 36454d0..a608bc7 100644
    --- a/drivers/net/wireless/iwlegacy/common.c
    +++ b/drivers/net/wireless/iwlegacy/common.c
    @@ -4575,6 +4575,7 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
    struct il_priv *il = hw->priv;
    struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
    int err;
    + bool reset;
    u32 modes;

    D_MAC80211("enter: type %d, addr %pM\n", vif->type, vif->addr);
    @@ -4594,6 +4595,16 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
    goto out;
    }

    + /*
    + * We do not support multiple virtual interfaces, but on hardware reset
    + * we have to add the same interface again.
    + */
    + reset = (il->ctx.vif == vif);
    + if (il->ctx.vif && !reset) {
    + err = -EOPNOTSUPP;
    + goto out;
    + }
    +
    modes = il->ctx.interface_modes | il->ctx.exclusive_interface_modes;
    if (!(modes & BIT(vif->type))) {
    err = -EOPNOTSUPP;
    @@ -4605,8 +4616,11 @@ il_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)

    err = il_setup_interface(il, &il->ctx);
    if (err) {
    - il->ctx.vif = NULL;
    - il->iw_mode = NL80211_IFTYPE_STATION;
    + IL_WARN("Fail to set mode %d\n", vif->type);
    + if (!reset) {
    + il->ctx.vif = NULL;
    + il->iw_mode = NL80211_IFTYPE_STATION;
    + }
    }

    out:
    diff --git a/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c b/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
    index 1f07558..f20678a 100644
    --- a/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
    +++ b/drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
    @@ -1968,7 +1968,7 @@ void rtl92c_phy_set_io(struct ieee80211_hw *hw)
    break;
    case IO_CMD_PAUSE_DM_BY_SCAN:
    rtlphy->initgain_backup.xaagccore1 = dm_digtable.cur_igvalue;
    - dm_digtable.cur_igvalue = 0x17;
    + dm_digtable.cur_igvalue = 0x37;
    rtl92c_dm_write_dig(hw);
    break;
    default:
    diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
    index 0883349..2cf4c5f 100644
    --- a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
    +++ b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
    @@ -3192,7 +3192,7 @@ static void rtl92d_phy_set_io(struct ieee80211_hw *hw)
    break;
    case IO_CMD_PAUSE_DM_BY_SCAN:
    rtlphy->initgain_backup.xaagccore1 = de_digtable.cur_igvalue;
    - de_digtable.cur_igvalue = 0x17;
    + de_digtable.cur_igvalue = 0x37;
    rtl92d_dm_write_dig(hw);
    break;
    default:
    diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
    index 1e5290b..110e4af 100644
    --- a/drivers/platform/x86/acer-wmi.c
    +++ b/drivers/platform/x86/acer-wmi.c
    @@ -692,6 +692,7 @@ static const struct acpi_device_id norfkill_ids[] = {
    { "VPC2004", 0},
    { "IBM0068", 0},
    { "LEN0068", 0},
    + { "SNY5001", 0}, /* sony-laptop in charge */
    { "", 0},
    };

    diff --git a/drivers/pnp/pnpacpi/core.c b/drivers/pnp/pnpacpi/core.c
    index b00c176..d21e8f5 100644
    --- a/drivers/pnp/pnpacpi/core.c
    +++ b/drivers/pnp/pnpacpi/core.c
    @@ -321,9 +321,14 @@ static int __init acpi_pnp_match(struct device *dev, void *_pnp)
    {
    struct acpi_device *acpi = to_acpi_device(dev);
    struct pnp_dev *pnp = _pnp;
    + struct device *physical_device;
    +
    + physical_device = acpi_get_physical_device(acpi->handle);
    + if (physical_device)
    + put_device(physical_device);

    /* true means it matched */
    - return !acpi_get_physical_device(acpi->handle)
    + return !physical_device
    && compare_pnp_id(pnp->id, acpi_device_hid(acpi));
    }

    diff --git a/drivers/staging/android/lowmemorykiller.c b/drivers/staging/android/lowmemorykiller.c
    index 5cd2309..4c26bcd 100644
    --- a/drivers/staging/android/lowmemorykiller.c
    +++ b/drivers/staging/android/lowmemorykiller.c
    @@ -53,7 +53,6 @@ static size_t lowmem_minfree[6] = {
    };
    static int lowmem_minfree_size = 4;

    -static struct task_struct *lowmem_deathpending;
    static unsigned long lowmem_deathpending_timeout;

    #define lowmem_print(level, x...) \
    @@ -62,24 +61,6 @@ static unsigned long lowmem_deathpending_timeout;
    printk(x); \
    } while (0)

    -static int
    -task_notify_func(struct notifier_block *self, unsigned long val, void *data);
    -
    -static struct notifier_block task_nb = {
    - .notifier_call = task_notify_func,
    -};
    -
    -static int
    -task_notify_func(struct notifier_block *self, unsigned long val, void *data)
    -{
    - struct task_struct *task = data;
    -
    - if (task == lowmem_deathpending)
    - lowmem_deathpending = NULL;
    -
    - return NOTIFY_OK;
    -}
    -
    static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
    {
    struct task_struct *p;
    @@ -95,19 +76,6 @@ static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
    int other_file = global_page_state(NR_FILE_PAGES) -
    global_page_state(NR_SHMEM);

    - /*
    - * If we already have a death outstanding, then
    - * bail out right away; indicating to vmscan
    - * that we have nothing further to offer on
    - * this pass.
    - *
    - * Note: Currently you need CONFIG_PROFILING
    - * for this to work correctly.
    - */
    - if (lowmem_deathpending &&
    - time_before_eq(jiffies, lowmem_deathpending_timeout))
    - return 0;
    -
    if (lowmem_adj_size < array_size)
    array_size = lowmem_adj_size;
    if (lowmem_minfree_size < array_size)
    @@ -140,6 +108,11 @@ static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
    struct signal_struct *sig;
    int oom_adj;

    + if (test_tsk_thread_flag(p, TIF_MEMDIE) &&
    + time_before_eq(jiffies, lowmem_deathpending_timeout)) {
    + read_unlock(&tasklist_lock);
    + return 0;
    + }
    task_lock(p);
    mm = p->mm;
    sig = p->signal;
    @@ -173,15 +146,9 @@ static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
    lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
    selected->pid, selected->comm,
    selected_oom_adj, selected_tasksize);
    - /*
    - * If CONFIG_PROFILING is off, then we don't want to stall
    - * the killer by setting lowmem_deathpending.
    - */
    -#ifdef CONFIG_PROFILING
    - lowmem_deathpending = selected;
    lowmem_deathpending_timeout = jiffies + HZ;
    -#endif
    force_sig(SIGKILL, selected);
    + set_tsk_thread_flag(selected, TIF_MEMDIE);
    rem -= selected_tasksize;
    }
    lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
    @@ -197,7 +164,6 @@ static struct shrinker lowmem_shrinker = {

    static int __init lowmem_init(void)
    {
    - task_handoff_register(&task_nb);
    register_shrinker(&lowmem_shrinker);
    return 0;
    }
    @@ -205,7 +171,6 @@ static int __init lowmem_init(void)
    static void __exit lowmem_exit(void)
    {
    unregister_shrinker(&lowmem_shrinker);
    - task_handoff_unregister(&task_nb);
    }

    module_param_named(cost, lowmem_shrinker.seeks, int, S_IRUGO | S_IWUSR);
    diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
    index e05c551..be7ed12 100644
    --- a/drivers/target/tcm_fc/tcm_fc.h
    +++ b/drivers/target/tcm_fc/tcm_fc.h
    @@ -124,6 +124,7 @@ struct ft_cmd {
    /* Local sense buffer */
    unsigned char ft_sense_buffer[TRANSPORT_SENSE_BUFFER];
    u32 was_ddp_setup:1; /* Set only if ddp is setup */
    + u32 aborted:1; /* Set if aborted by reset or timeout */
    struct scatterlist *sg; /* Set only if DDP is setup */
    u32 sg_cnt; /* No. of item in scatterlist */
    };
    diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
    index ced9e8a..fd10f72 100644
    --- a/drivers/target/tcm_fc/tfc_cmd.c
    +++ b/drivers/target/tcm_fc/tfc_cmd.c
    @@ -126,6 +126,8 @@ int ft_queue_status(struct se_cmd *se_cmd)
    struct fc_exch *ep;
    size_t len;

    + if (cmd->aborted)
    + return 0;
    ft_dump_cmd(cmd, __func__);
    ep = fc_seq_exch(cmd->seq);
    lport = ep->lp;
    @@ -192,6 +194,8 @@ int ft_write_pending(struct se_cmd *se_cmd)

    ft_dump_cmd(cmd, __func__);

    + if (cmd->aborted)
    + return 0;
    ep = fc_seq_exch(cmd->seq);
    lport = ep->lp;
    fp = fc_frame_alloc(lport, sizeof(*txrdy));
    @@ -262,10 +266,10 @@ static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
    struct ft_cmd *cmd = arg;
    struct fc_frame_header *fh;

    - if (IS_ERR(fp)) {
    + if (unlikely(IS_ERR(fp))) {
    /* XXX need to find cmd if queued */
    cmd->seq = NULL;
    - transport_generic_free_cmd(&cmd->se_cmd, 0);
    + cmd->aborted = true;
    return;
    }

    @@ -447,6 +451,8 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
    struct se_tmr_req *tmr = se_cmd->se_tmr_req;
    enum fcp_resp_rsp_codes code;

    + if (cmd->aborted)
    + return 0;
    switch (tmr->response) {
    case TMR_FUNCTION_COMPLETE:
    code = FCP_TMF_CMPL;
    diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
    index 73852fb..0a92795 100644
    --- a/drivers/target/tcm_fc/tfc_conf.c
    +++ b/drivers/target/tcm_fc/tfc_conf.c
    @@ -300,6 +300,7 @@ static struct se_portal_group *ft_add_tpg(
    {
    struct ft_lport_acl *lacl;
    struct ft_tpg *tpg;
    + struct workqueue_struct *wq;
    unsigned long index;
    int ret;

    @@ -321,18 +322,20 @@ static struct se_portal_group *ft_add_tpg(
    tpg->lport_acl = lacl;
    INIT_LIST_HEAD(&tpg->lun_list);

    - ret = core_tpg_register(&ft_configfs->tf_ops, wwn, &tpg->se_tpg,
    - tpg, TRANSPORT_TPG_TYPE_NORMAL);
    - if (ret < 0) {
    + wq = alloc_workqueue("tcm_fc", 0, 1);
    + if (!wq) {
    kfree(tpg);
    return NULL;
    }

    - tpg->workqueue = alloc_workqueue("tcm_fc", 0, 1);
    - if (!tpg->workqueue) {
    + ret = core_tpg_register(&ft_configfs->tf_ops, wwn, &tpg->se_tpg,
    + tpg, TRANSPORT_TPG_TYPE_NORMAL);
    + if (ret < 0) {
    + destroy_workqueue(wq);
    kfree(tpg);
    return NULL;
    }
    + tpg->workqueue = wq;

    mutex_lock(&ft_lport_lock);
    list_add_tail(&tpg->list, &lacl->tpg_list);
    diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
    index d8cabc2..7b34f9b 100644
    --- a/drivers/target/tcm_fc/tfc_io.c
    +++ b/drivers/target/tcm_fc/tfc_io.c
    @@ -81,6 +81,8 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
    void *from;
    void *to = NULL;

    + if (cmd->aborted)
    + return 0;
    ep = fc_seq_exch(cmd->seq);
    lport = ep->lp;
    cmd->seq = lport->tt.seq_start_next(cmd->seq);
    diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
    index 77afabc..70b96ec 100644
    --- a/drivers/usb/host/ohci-at91.c
    +++ b/drivers/usb/host/ohci-at91.c
    @@ -245,7 +245,7 @@ static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int
    return;

    gpio_set_value(pdata->vbus_pin[port],
    - !pdata->vbus_pin_active_low[port] ^ enable);
    + pdata->vbus_pin_active_low[port] ^ enable);
    }

    static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
    @@ -257,7 +257,7 @@ static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
    return -EINVAL;

    return gpio_get_value(pdata->vbus_pin[port]) ^
    - !pdata->vbus_pin_active_low[port];
    + pdata->vbus_pin_active_low[port];
    }

    /*
    diff --git a/fs/cifs/file.c b/fs/cifs/file.c
    index 159fcc5..0f7dc22 100644
    --- a/fs/cifs/file.c
    +++ b/fs/cifs/file.c
    @@ -835,13 +835,21 @@ cifs_posix_lock_set(struct file *file, struct file_lock *flock)
    if ((flock->fl_flags & FL_POSIX) == 0)
    return rc;

    +try_again:
    mutex_lock(&cinode->lock_mutex);
    if (!cinode->can_cache_brlcks) {
    mutex_unlock(&cinode->lock_mutex);
    return rc;
    }
    - rc = posix_lock_file_wait(file, flock);
    +
    + rc = posix_lock_file(file, flock, NULL);
    mutex_unlock(&cinode->lock_mutex);
    + if (rc == FILE_LOCK_DEFERRED) {
    + rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
    + if (!rc)
    + goto try_again;
    + locks_delete_block(flock);
    + }
    return rc;
    }

    diff --git a/fs/locks.c b/fs/locks.c
    index 637694b..0d68f1f 100644
    --- a/fs/locks.c
    +++ b/fs/locks.c
    @@ -510,12 +510,13 @@ static void __locks_delete_block(struct file_lock *waiter)

    /*
    */
    -static void locks_delete_block(struct file_lock *waiter)
    +void locks_delete_block(struct file_lock *waiter)
    {
    lock_flocks();
    __locks_delete_block(waiter);
    unlock_flocks();
    }
    +EXPORT_SYMBOL(locks_delete_block);

    /* Insert waiter into blocker's block list.
    * We use a circular list so that processes can be easily woken up in
    diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
    index 0cb7163..9a54c9e 100644
    --- a/fs/nfs/nfs4proc.c
    +++ b/fs/nfs/nfs4proc.c
    @@ -3625,7 +3625,7 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
    if (acl_len > buflen)
    goto out_free;
    _copy_from_pages(buf, pages, res.acl_data_offset,
    - res.acl_len);
    + acl_len);
    }
    ret = acl_len;
    out_free:
    diff --git a/include/linux/fs.h b/include/linux/fs.h
    index 69cd5bb..f4b6e06 100644
    --- a/include/linux/fs.h
    +++ b/include/linux/fs.h
    @@ -1210,6 +1210,7 @@ extern int vfs_setlease(struct file *, long, struct file_lock **);
    extern int lease_modify(struct file_lock **, int);
    extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
    extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
    +extern void locks_delete_block(struct file_lock *waiter);
    extern void lock_flocks(void);
    extern void unlock_flocks(void);
    #else /* !CONFIG_FILE_LOCKING */
    @@ -1354,6 +1355,10 @@ static inline int lock_may_write(struct inode *inode, loff_t start,
    return 1;
    }

    +static inline void locks_delete_block(struct file_lock *waiter)
    +{
    +}
    +
    static inline void lock_flocks(void)
    {
    }
    diff --git a/include/linux/kernel.h b/include/linux/kernel.h
    index e834342..d801acb 100644
    --- a/include/linux/kernel.h
    +++ b/include/linux/kernel.h
    @@ -85,6 +85,19 @@
    } \
    )

    +/*
    + * Multiplies an integer by a fraction, while avoiding unnecessary
    + * overflow or loss of precision.
    + */
    +#define mult_frac(x, numer, denom)( \
    +{ \
    + typeof(x) quot = (x) / (denom); \
    + typeof(x) rem = (x) % (denom); \
    + (quot * (numer)) + ((rem * (numer)) / (denom)); \
    +} \
    +)
    +
    +
    #define _RET_IP_ (unsigned long)__builtin_return_address(0)
    #define _THIS_IP_ ({ __label__ __here; __here: (unsigned long)&&__here; })

    diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
    index fa39183..c4d2fc1 100644
    --- a/include/linux/kgdb.h
    +++ b/include/linux/kgdb.h
    @@ -63,7 +63,8 @@ enum kgdb_bptype {
    BP_HARDWARE_BREAKPOINT,
    BP_WRITE_WATCHPOINT,
    BP_READ_WATCHPOINT,
    - BP_ACCESS_WATCHPOINT
    + BP_ACCESS_WATCHPOINT,
    + BP_POKE_BREAKPOINT,
    };

    enum kgdb_bpstate {
    @@ -207,8 +208,8 @@ extern void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc);

    /* Optional functions. */
    extern int kgdb_validate_break_address(unsigned long addr);
    -extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
    -extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);
    +extern int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt);
    +extern int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt);

    /**
    * kgdb_arch_late - Perform any architecture specific initalization.
    diff --git a/include/linux/kmod.h b/include/linux/kmod.h
    index 722f477..0fb48ef 100644
    --- a/include/linux/kmod.h
    +++ b/include/linux/kmod.h
    @@ -112,12 +112,29 @@ call_usermodehelper(char *path, char **argv, char **envp, enum umh_wait wait)

    extern struct ctl_table usermodehelper_table[];

    +enum umh_disable_depth {
    + UMH_ENABLED = 0,
    + UMH_FREEZING,
    + UMH_DISABLED,
    +};
    +
    extern void usermodehelper_init(void);

    -extern int usermodehelper_disable(void);
    -extern void usermodehelper_enable(void);
    -extern bool usermodehelper_is_disabled(void);
    -extern void read_lock_usermodehelper(void);
    -extern void read_unlock_usermodehelper(void);
    +extern int __usermodehelper_disable(enum umh_disable_depth depth);
    +extern void __usermodehelper_set_disable_depth(enum umh_disable_depth depth);
    +
    +static inline int usermodehelper_disable(void)
    +{
    + return __usermodehelper_disable(UMH_DISABLED);
    +}
    +
    +static inline void usermodehelper_enable(void)
    +{
    + __usermodehelper_set_disable_depth(UMH_ENABLED);
    +}
    +
    +extern int usermodehelper_read_trylock(void);
    +extern long usermodehelper_read_lock_wait(long timeout);
    +extern void usermodehelper_read_unlock(void);

    #endif /* __LINUX_KMOD_H__ */
    diff --git a/kernel/cred.c b/kernel/cred.c
    index 5791612..48c6fd3 100644
    --- a/kernel/cred.c
    +++ b/kernel/cred.c
    @@ -385,6 +385,8 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)
    struct cred *new;
    int ret;

    + p->replacement_session_keyring = NULL;
    +
    if (
    #ifdef CONFIG_KEYS
    !p->cred->thread_keyring &&
    diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c
    index 0d7c087..7fda904 100644
    --- a/kernel/debug/debug_core.c
    +++ b/kernel/debug/debug_core.c
    @@ -157,37 +157,39 @@ early_param("nokgdbroundup", opt_nokgdbroundup);
    * Weak aliases for breakpoint management,
    * can be overriden by architectures when needed:
    */
    -int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
    +int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
    {
    int err;

    - err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
    + err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
    + BREAK_INSTR_SIZE);
    if (err)
    return err;
    -
    - return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
    - BREAK_INSTR_SIZE);
    + err = probe_kernel_write((char *)bpt->bpt_addr,
    + arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
    + return err;
    }

    -int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
    +int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
    {
    - return probe_kernel_write((char *)addr,
    - (char *)bundle, BREAK_INSTR_SIZE);
    + return probe_kernel_write((char *)bpt->bpt_addr,
    + (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
    }

    int __weak kgdb_validate_break_address(unsigned long addr)
    {
    - char tmp_variable[BREAK_INSTR_SIZE];
    + struct kgdb_bkpt tmp;
    int err;
    - /* Validate setting the breakpoint and then removing it. In the
    + /* Validate setting the breakpoint and then removing it. If the
    * remove fails, the kernel needs to emit a bad message because we
    * are deep trouble not being able to put things back the way we
    * found them.
    */
    - err = kgdb_arch_set_breakpoint(addr, tmp_variable);
    + tmp.bpt_addr = addr;
    + err = kgdb_arch_set_breakpoint(&tmp);
    if (err)
    return err;
    - err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
    + err = kgdb_arch_remove_breakpoint(&tmp);
    if (err)
    printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
    "memory destroyed at: %lx", addr);
    @@ -231,7 +233,6 @@ static void kgdb_flush_swbreak_addr(unsigned long addr)
    */
    int dbg_activate_sw_breakpoints(void)
    {
    - unsigned long addr;
    int error;
    int ret = 0;
    int i;
    @@ -240,16 +241,15 @@ int dbg_activate_sw_breakpoints(void)
    if (kgdb_break[i].state != BP_SET)
    continue;

    - addr = kgdb_break[i].bpt_addr;
    - error = kgdb_arch_set_breakpoint(addr,
    - kgdb_break[i].saved_instr);
    + error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
    if (error) {
    ret = error;
    - printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
    + printk(KERN_INFO "KGDB: BP install failed: %lx",
    + kgdb_break[i].bpt_addr);
    continue;
    }

    - kgdb_flush_swbreak_addr(addr);
    + kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
    kgdb_break[i].state = BP_ACTIVE;
    }
    return ret;
    @@ -298,7 +298,6 @@ int dbg_set_sw_break(unsigned long addr)

    int dbg_deactivate_sw_breakpoints(void)
    {
    - unsigned long addr;
    int error;
    int ret = 0;
    int i;
    @@ -306,15 +305,14 @@ int dbg_deactivate_sw_breakpoints(void)
    for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
    if (kgdb_break[i].state != BP_ACTIVE)
    continue;
    - addr = kgdb_break[i].bpt_addr;
    - error = kgdb_arch_remove_breakpoint(addr,
    - kgdb_break[i].saved_instr);
    + error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
    if (error) {
    - printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
    + printk(KERN_INFO "KGDB: BP remove failed: %lx\n",
    + kgdb_break[i].bpt_addr);
    ret = error;
    }

    - kgdb_flush_swbreak_addr(addr);
    + kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
    kgdb_break[i].state = BP_SET;
    }
    return ret;
    @@ -348,7 +346,6 @@ int kgdb_isremovedbreak(unsigned long addr)

    int dbg_remove_all_break(void)
    {
    - unsigned long addr;
    int error;
    int i;

    @@ -356,12 +353,10 @@ int dbg_remove_all_break(void)
    for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
    if (kgdb_break[i].state != BP_ACTIVE)
    goto setundefined;
    - addr = kgdb_break[i].bpt_addr;
    - error = kgdb_arch_remove_breakpoint(addr,
    - kgdb_break[i].saved_instr);
    + error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
    if (error)
    printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
    - addr);
    + kgdb_break[i].bpt_addr);
    setundefined:
    kgdb_break[i].state = BP_UNDEFINED;
    }
    diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
    index 4742090..c3c8975 100644
    --- a/kernel/irq/migration.c
    +++ b/kernel/irq/migration.c
    @@ -43,12 +43,16 @@ void irq_move_masked_irq(struct irq_data *idata)
    * masking the irqs.
    */
    if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
    - < nr_cpu_ids))
    - if (!chip->irq_set_affinity(&desc->irq_data,
    - desc->pending_mask, false)) {
    + < nr_cpu_ids)) {
    + int ret = chip->irq_set_affinity(&desc->irq_data,
    + desc->pending_mask, false);
    + switch (ret) {
    + case IRQ_SET_MASK_OK:
    cpumask_copy(desc->irq_data.affinity, desc->pending_mask);
    + case IRQ_SET_MASK_OK_NOCOPY:
    irq_set_thread_affinity(desc);
    }
    + }

    cpumask_clear(desc->pending_mask);
    }
    diff --git a/kernel/kmod.c b/kernel/kmod.c
    index a0a8854..a3a46cb 100644
    --- a/kernel/kmod.c
    +++ b/kernel/kmod.c
    @@ -279,7 +279,7 @@ static void __call_usermodehelper(struct work_struct *work)
    * land has been frozen during a system-wide hibernation or suspend operation).
    * Should always be manipulated under umhelper_sem acquired for write.
    */
    -static int usermodehelper_disabled = 1;
    +static enum umh_disable_depth usermodehelper_disabled = UMH_DISABLED;

    /* Number of helpers running */
    static atomic_t running_helpers = ATOMIC_INIT(0);
    @@ -291,32 +291,110 @@ static atomic_t running_helpers = ATOMIC_INIT(0);
    static DECLARE_WAIT_QUEUE_HEAD(running_helpers_waitq);

    /*
    + * Used by usermodehelper_read_lock_wait() to wait for usermodehelper_disabled
    + * to become 'false'.
    + */
    +static DECLARE_WAIT_QUEUE_HEAD(usermodehelper_disabled_waitq);
    +
    +/*
    * Time to wait for running_helpers to become zero before the setting of
    * usermodehelper_disabled in usermodehelper_disable() fails
    */
    #define RUNNING_HELPERS_TIMEOUT (5 * HZ)

    -void read_lock_usermodehelper(void)
    +int usermodehelper_read_trylock(void)
    {
    + DEFINE_WAIT(wait);
    + int ret = 0;
    +
    down_read(&umhelper_sem);
    + for (;;) {
    + prepare_to_wait(&usermodehelper_disabled_waitq, &wait,
    + TASK_INTERRUPTIBLE);
    + if (!usermodehelper_disabled)
    + break;
    +
    + if (usermodehelper_disabled == UMH_DISABLED)
    + ret = -EAGAIN;
    +
    + up_read(&umhelper_sem);
    +
    + if (ret)
    + break;
    +
    + schedule();
    + try_to_freeze();
    +
    + down_read(&umhelper_sem);
    + }
    + finish_wait(&usermodehelper_disabled_waitq, &wait);
    + return ret;
    +}
    +EXPORT_SYMBOL_GPL(usermodehelper_read_trylock);
    +
    +long usermodehelper_read_lock_wait(long timeout)
    +{
    + DEFINE_WAIT(wait);
    +
    + if (timeout < 0)
    + return -EINVAL;
    +
    + down_read(&umhelper_sem);
    + for (;;) {
    + prepare_to_wait(&usermodehelper_disabled_waitq, &wait,
    + TASK_UNINTERRUPTIBLE);
    + if (!usermodehelper_disabled)
    + break;
    +
    + up_read(&umhelper_sem);
    +
    + timeout = schedule_timeout(timeout);
    + if (!timeout)
    + break;
    +
    + down_read(&umhelper_sem);
    + }
    + finish_wait(&usermodehelper_disabled_waitq, &wait);
    + return timeout;
    }
    -EXPORT_SYMBOL_GPL(read_lock_usermodehelper);
    +EXPORT_SYMBOL_GPL(usermodehelper_read_lock_wait);

    -void read_unlock_usermodehelper(void)
    +void usermodehelper_read_unlock(void)
    {
    up_read(&umhelper_sem);
    }
    -EXPORT_SYMBOL_GPL(read_unlock_usermodehelper);
    +EXPORT_SYMBOL_GPL(usermodehelper_read_unlock);

    /**
    - * usermodehelper_disable - prevent new helpers from being started
    + * __usermodehelper_set_disable_depth - Modify usermodehelper_disabled.
    + * depth: New value to assign to usermodehelper_disabled.
    + *
    + * Change the value of usermodehelper_disabled (under umhelper_sem locked for
    + * writing) and wakeup tasks waiting for it to change.
    */
    -int usermodehelper_disable(void)
    +void __usermodehelper_set_disable_depth(enum umh_disable_depth depth)
    +{
    + down_write(&umhelper_sem);
    + usermodehelper_disabled = depth;
    + wake_up(&usermodehelper_disabled_waitq);
    + up_write(&umhelper_sem);
    +}
    +
    +/**
    + * __usermodehelper_disable - Prevent new helpers from being started.
    + * @depth: New value to assign to usermodehelper_disabled.
    + *
    + * Set usermodehelper_disabled to @depth and wait for running helpers to exit.
    + */
    +int __usermodehelper_disable(enum umh_disable_depth depth)
    {
    long retval;

    + if (!depth)
    + return -EINVAL;
    +
    down_write(&umhelper_sem);
    - usermodehelper_disabled = 1;
    + usermodehelper_disabled = depth;
    up_write(&umhelper_sem);

    /*
    @@ -331,31 +409,10 @@ int usermodehelper_disable(void)
    if (retval)
    return 0;

    - down_write(&umhelper_sem);
    - usermodehelper_disabled = 0;
    - up_write(&umhelper_sem);
    + __usermodehelper_set_disable_depth(UMH_ENABLED);
    return -EAGAIN;
    }

    -/**
    - * usermodehelper_enable - allow new helpers to be started again
    - */
    -void usermodehelper_enable(void)
    -{
    - down_write(&umhelper_sem);
    - usermodehelper_disabled = 0;
    - up_write(&umhelper_sem);
    -}
    -
    -/**
    - * usermodehelper_is_disabled - check if new helpers are allowed to be started
    - */
    -bool usermodehelper_is_disabled(void)
    -{
    - return usermodehelper_disabled;
    -}
    -EXPORT_SYMBOL_GPL(usermodehelper_is_disabled);
    -
    static void helper_lock(void)
    {
    atomic_inc(&running_helpers);
    diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
    index 7bef755..a364144 100644
    --- a/kernel/power/hibernate.c
    +++ b/kernel/power/hibernate.c
    @@ -16,7 +16,6 @@
    #include <linux/string.h>
    #include <linux/device.h>
    #include <linux/async.h>
    -#include <linux/kmod.h>
    #include <linux/delay.h>
    #include <linux/fs.h>
    #include <linux/mount.h>
    @@ -609,14 +608,10 @@ int hibernate(void)
    if (error)
    goto Exit;

    - error = usermodehelper_disable();
    - if (error)
    - goto Exit;
    -
    /* Allocate memory management structures */
    error = create_basic_memory_bitmaps();
    if (error)
    - goto Enable_umh;
    + goto Exit;

    printk(KERN_INFO "PM: Syncing filesystems ... ");
    sys_sync();
    @@ -659,8 +654,6 @@ int hibernate(void)
    thaw_processes();
    Free_bitmaps:
    free_basic_memory_bitmaps();
    - Enable_umh:
    - usermodehelper_enable();
    Exit:
    pm_notifier_call_chain(PM_POST_HIBERNATION);
    pm_restore_console();
    @@ -775,15 +768,9 @@ static int software_resume(void)
    if (error)
    goto close_finish;

    - error = usermodehelper_disable();
    - if (error)
    - goto close_finish;
    -
    error = create_basic_memory_bitmaps();
    - if (error) {
    - usermodehelper_enable();
    + if (error)
    goto close_finish;
    - }

    pr_debug("PM: Preparing processes for restore.\n");
    error = freeze_processes();
    @@ -804,7 +791,6 @@ static int software_resume(void)
    thaw_processes();
    Done:
    free_basic_memory_bitmaps();
    - usermodehelper_enable();
    Finish:
    pm_notifier_call_chain(PM_POST_RESTORE);
    pm_restore_console();
    diff --git a/kernel/power/process.c b/kernel/power/process.c
    index 7e42645..7aac07a 100644
    --- a/kernel/power/process.c
    +++ b/kernel/power/process.c
    @@ -16,6 +16,7 @@
    #include <linux/freezer.h>
    #include <linux/delay.h>
    #include <linux/workqueue.h>
    +#include <linux/kmod.h>

    /*
    * Timeout for stopping processes
    @@ -122,6 +123,10 @@ int freeze_processes(void)
    {
    int error;

    + error = __usermodehelper_disable(UMH_FREEZING);
    + if (error)
    + return error;
    +
    if (!pm_freezing)
    atomic_inc(&system_freezing_cnt);

    @@ -130,6 +135,7 @@ int freeze_processes(void)
    error = try_to_freeze_tasks(true);
    if (!error) {
    printk("done.");
    + __usermodehelper_set_disable_depth(UMH_DISABLED);
    oom_killer_disable();
    }
    printk("\n");
    @@ -187,6 +193,8 @@ void thaw_processes(void)
    } while_each_thread(g, p);
    read_unlock(&tasklist_lock);

    + usermodehelper_enable();
    +
    schedule();
    printk("done.\n");
    }
    diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
    index 4fd51be..038d72b 100644
    --- a/kernel/power/suspend.c
    +++ b/kernel/power/suspend.c
    @@ -12,7 +12,6 @@
    #include <linux/delay.h>
    #include <linux/errno.h>
    #include <linux/init.h>
    -#include <linux/kmod.h>
    #include <linux/console.h>
    #include <linux/cpu.h>
    #include <linux/syscalls.h>
    @@ -101,17 +100,12 @@ static int suspend_prepare(void)
    if (error)
    goto Finish;

    - error = usermodehelper_disable();
    - if (error)
    - goto Finish;
    -
    error = suspend_freeze_processes();
    if (!error)
    return 0;

    suspend_stats.failed_freeze++;
    dpm_save_failed_step(SUSPEND_FREEZE);
    - usermodehelper_enable();
    Finish:
    pm_notifier_call_chain(PM_POST_SUSPEND);
    pm_restore_console();
    @@ -259,7 +253,6 @@ int suspend_devices_and_enter(suspend_state_t state)
    static void suspend_finish(void)
    {
    suspend_thaw_processes();
    - usermodehelper_enable();
    pm_notifier_call_chain(PM_POST_SUSPEND);
    pm_restore_console();
    }
    diff --git a/kernel/power/user.c b/kernel/power/user.c
    index 3e10007..89dc7e4 100644
    --- a/kernel/power/user.c
    +++ b/kernel/power/user.c
    @@ -12,7 +12,6 @@
    #include <linux/suspend.h>
    #include <linux/syscalls.h>
    #include <linux/reboot.h>
    -#include <linux/kmod.h>
    #include <linux/string.h>
    #include <linux/device.h>
    #include <linux/miscdevice.h>
    @@ -222,14 +221,8 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
    sys_sync();
    printk("done.\n");

    - error = usermodehelper_disable();
    - if (error)
    - break;
    -
    error = freeze_processes();
    - if (error)
    - usermodehelper_enable();
    - else
    + if (!error)
    data->frozen = 1;
    break;

    @@ -238,7 +231,6 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
    break;
    pm_restore_gfp_mask();
    thaw_processes();
    - usermodehelper_enable();
    data->frozen = 0;
    break;

    diff --git a/kernel/sysctl.c b/kernel/sysctl.c
    index f487f25..f03a6ef 100644
    --- a/kernel/sysctl.c
    +++ b/kernel/sysctl.c
    @@ -166,7 +166,7 @@ static int proc_taint(struct ctl_table *table, int write,
    #endif

    #ifdef CONFIG_PRINTK
    -static int proc_dmesg_restrict(struct ctl_table *table, int write,
    +static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
    void __user *buffer, size_t *lenp, loff_t *ppos);
    #endif

    @@ -713,7 +713,7 @@ static struct ctl_table kern_table[] = {
    .data = &dmesg_restrict,
    .maxlen = sizeof(int),
    .mode = 0644,
    - .proc_handler = proc_dointvec_minmax,
    + .proc_handler = proc_dointvec_minmax_sysadmin,
    .extra1 = &zero,
    .extra2 = &one,
    },
    @@ -722,7 +722,7 @@ static struct ctl_table kern_table[] = {
    .data = &kptr_restrict,
    .maxlen = sizeof(int),
    .mode = 0644,
    - .proc_handler = proc_dmesg_restrict,
    + .proc_handler = proc_dointvec_minmax_sysadmin,
    .extra1 = &zero,
    .extra2 = &two,
    },
    @@ -2431,7 +2431,7 @@ static int proc_taint(struct ctl_table *table, int write,
    }

    #ifdef CONFIG_PRINTK
    -static int proc_dmesg_restrict(struct ctl_table *table, int write,
    +static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
    void __user *buffer, size_t *lenp, loff_t *ppos)
    {
    if (write && !capable(CAP_SYS_ADMIN))
    diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
    index a3f1bc5..c4579f1 100644
    --- a/kernel/trace/trace.c
    +++ b/kernel/trace/trace.c
    @@ -1644,6 +1644,7 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu,
    int cpu_file = iter->cpu_file;
    u64 next_ts = 0, ts;
    int next_cpu = -1;
    + int next_size = 0;
    int cpu;

    /*
    @@ -1675,9 +1676,12 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu,
    next_cpu = cpu;
    next_ts = ts;
    next_lost = lost_events;
    + next_size = iter->ent_size;
    }
    }

    + iter->ent_size = next_size;
    +
    if (ent_cpu)
    *ent_cpu = next_cpu;

    diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h
    index 9336590..205dcac 100644
    --- a/kernel/trace/trace_entries.h
    +++ b/kernel/trace/trace_entries.h
    @@ -156,6 +156,12 @@ FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,

    #define FTRACE_STACK_ENTRIES 8

    +#ifndef CONFIG_64BIT
    +# define IP_FMT "%08lx"
    +#else
    +# define IP_FMT "%016lx"
    +#endif
    +
    FTRACE_ENTRY(kernel_stack, stack_entry,

    TRACE_STACK,
    @@ -165,8 +171,9 @@ FTRACE_ENTRY(kernel_stack, stack_entry,
    __dynamic_array(unsigned long, caller )
    ),

    - F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
    - "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
    + F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
    + "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
    + "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
    __entry->caller[0], __entry->caller[1], __entry->caller[2],
    __entry->caller[3], __entry->caller[4], __entry->caller[5],
    __entry->caller[6], __entry->caller[7])
    @@ -181,8 +188,9 @@ FTRACE_ENTRY(user_stack, userstack_entry,
    __array( unsigned long, caller, FTRACE_STACK_ENTRIES )
    ),

    - F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n"
    - "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n",
    + F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
    + "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
    + "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
    __entry->caller[0], __entry->caller[1], __entry->caller[2],
    __entry->caller[3], __entry->caller[4], __entry->caller[5],
    __entry->caller[6], __entry->caller[7])
    diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
    index bbeec31..ad4000c 100644
    --- a/kernel/trace/trace_export.c
    +++ b/kernel/trace/trace_export.c
    @@ -150,7 +150,7 @@ ftrace_define_fields_##name(struct ftrace_event_call *event_call) \
    #define __dynamic_array(type, item)

    #undef F_printk
    -#define F_printk(fmt, args...) #fmt ", " __stringify(args)
    +#define F_printk(fmt, args...) __stringify(fmt) ", " __stringify(args)

    #undef FTRACE_ENTRY
    #define FTRACE_ENTRY(call, struct_name, etype, tstruct, print) \
    diff --git a/net/mac80211/agg-rx.c b/net/mac80211/agg-rx.c
    index 1068f66..64d3ce5 100644
    --- a/net/mac80211/agg-rx.c
    +++ b/net/mac80211/agg-rx.c
    @@ -49,6 +49,8 @@ static void ieee80211_free_tid_rx(struct rcu_head *h)
    container_of(h, struct tid_ampdu_rx, rcu_head);
    int i;

    + del_timer_sync(&tid_rx->reorder_timer);
    +
    for (i = 0; i < tid_rx->buf_size; i++)
    dev_kfree_skb(tid_rx->reorder_buf[i]);
    kfree(tid_rx->reorder_buf);
    @@ -91,7 +93,6 @@ void ___ieee80211_stop_rx_ba_session(struct sta_info *sta, u16 tid,
    tid, WLAN_BACK_RECIPIENT, reason);

    del_timer_sync(&tid_rx->session_timer);
    - del_timer_sync(&tid_rx->reorder_timer);

    call_rcu(&tid_rx->rcu_head, ieee80211_free_tid_rx);
    }
    diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
    index 178ff4f..2679507 100644
    --- a/net/rose/rose_dev.c
    +++ b/net/rose/rose_dev.c
    @@ -96,11 +96,11 @@ static int rose_set_mac_address(struct net_device *dev, void *addr)
    struct sockaddr *sa = addr;
    int err;

    - if (!memcpy(dev->dev_addr, sa->sa_data, dev->addr_len))
    + if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
    return 0;

    if (dev->flags & IFF_UP) {
    - err = rose_add_loopback_node((rose_address *)dev->dev_addr);
    + err = rose_add_loopback_node((rose_address *)sa->sa_data);
    if (err)
    return err;

    diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
    index 9adb667..c4e7d15 100644
    --- a/scripts/mod/modpost.c
    +++ b/scripts/mod/modpost.c
    @@ -132,8 +132,10 @@ static struct module *new_module(char *modname)
    /* strip trailing .o */
    s = strrchr(p, '.');
    if (s != NULL)
    - if (strcmp(s, ".o") == 0)
    + if (strcmp(s, ".o") == 0) {
    *s = '\0';
    + mod->is_dot_o = 1;
    + }

    /* add to list */
    mod->name = p;
    @@ -587,7 +589,8 @@ static void handle_modversions(struct module *mod, struct elf_info *info,
    unsigned int crc;
    enum export export;

    - if (!is_vmlinux(mod->name) && strncmp(symname, "__ksymtab", 9) == 0)
    + if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
    + strncmp(symname, "__ksymtab", 9) == 0)
    export = export_from_secname(info, get_secindex(info, sym));
    else
    export = export_from_sec(info, get_secindex(info, sym));
    @@ -849,7 +852,7 @@ static void check_section(const char *modname, struct elf_info *elf,

    #define ALL_INIT_DATA_SECTIONS \
    ".init.setup$", ".init.rodata$", \
    - ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$" \
    + ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$", \
    ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$"
    #define ALL_EXIT_DATA_SECTIONS \
    ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$"
    diff --git a/scripts/mod/modpost.h b/scripts/mod/modpost.h
    index 2031119..51207e4 100644
    --- a/scripts/mod/modpost.h
    +++ b/scripts/mod/modpost.h
    @@ -113,6 +113,7 @@ struct module {
    int has_cleanup;
    struct buffer dev_table_buf;
    char srcversion[25];
    + int is_dot_o;
    };

    struct elf_info {
    diff --git a/security/tomoyo/mount.c b/security/tomoyo/mount.c
    index bee09d0..fe00cdf 100644
    --- a/security/tomoyo/mount.c
    +++ b/security/tomoyo/mount.c
    @@ -199,30 +199,32 @@ int tomoyo_mount_permission(char *dev_name, struct path *path,
    if (flags & MS_REMOUNT) {
    type = tomoyo_mounts[TOMOYO_MOUNT_REMOUNT];
    flags &= ~MS_REMOUNT;
    - }
    - if (flags & MS_MOVE) {
    - type = tomoyo_mounts[TOMOYO_MOUNT_MOVE];
    - flags &= ~MS_MOVE;
    - }
    - if (flags & MS_BIND) {
    + } else if (flags & MS_BIND) {
    type = tomoyo_mounts[TOMOYO_MOUNT_BIND];
    flags &= ~MS_BIND;
    - }
    - if (flags & MS_UNBINDABLE) {
    - type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE];
    - flags &= ~MS_UNBINDABLE;
    - }
    - if (flags & MS_PRIVATE) {
    + } else if (flags & MS_SHARED) {
    + if (flags & (MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
    + return -EINVAL;
    + type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED];
    + flags &= ~MS_SHARED;
    + } else if (flags & MS_PRIVATE) {
    + if (flags & (MS_SHARED | MS_SLAVE | MS_UNBINDABLE))
    + return -EINVAL;
    type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE];
    flags &= ~MS_PRIVATE;
    - }
    - if (flags & MS_SLAVE) {
    + } else if (flags & MS_SLAVE) {
    + if (flags & (MS_SHARED | MS_PRIVATE | MS_UNBINDABLE))
    + return -EINVAL;
    type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE];
    flags &= ~MS_SLAVE;
    - }
    - if (flags & MS_SHARED) {
    - type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED];
    - flags &= ~MS_SHARED;
    + } else if (flags & MS_UNBINDABLE) {
    + if (flags & (MS_SHARED | MS_PRIVATE | MS_SLAVE))
    + return -EINVAL;
    + type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE];
    + flags &= ~MS_UNBINDABLE;
    + } else if (flags & MS_MOVE) {
    + type = tomoyo_mounts[TOMOYO_MOUNT_MOVE];
    + flags &= ~MS_MOVE;
    }
    if (!type)
    type = "<NULL>";
    diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
    index 22c73b7..602aae9 100644
    --- a/sound/pci/hda/patch_realtek.c
    +++ b/sound/pci/hda/patch_realtek.c
    @@ -2709,9 +2709,6 @@ static int alc_auto_fill_adc_caps(struct hda_codec *codec)
    int max_nums = ARRAY_SIZE(spec->private_adc_nids);
    int i, nums = 0;

    - if (spec->shared_mic_hp)
    - max_nums = 1; /* no multi streams with the shared HP/mic */
    -
    nid = codec->start_nid;
    for (i = 0; i < codec->num_nodes; i++, nid++) {
    hda_nid_t src;
    @@ -3723,6 +3720,7 @@ static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
    if (spec->dyn_adc_switch)
    return;

    + again:
    nums = 0;
    for (n = 0; n < spec->num_adc_nids; n++) {
    hda_nid_t cap = spec->private_capsrc_nids[n];
    @@ -3743,6 +3741,11 @@ static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
    if (!nums) {
    /* check whether ADC-switch is possible */
    if (!alc_check_dyn_adc_switch(codec)) {
    + if (spec->shared_mic_hp) {
    + spec->shared_mic_hp = 0;
    + spec->private_imux[0].num_items = 1;
    + goto again;
    + }
    printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
    " using fallback 0x%x\n",
    codec->chip_name, spec->private_adc_nids[0]);
    @@ -3760,7 +3763,7 @@ static void alc_remove_invalid_adc_nids(struct hda_codec *codec)

    if (spec->auto_mic)
    alc_auto_mic_check_imux(codec); /* check auto-mic setups */
    - else if (spec->input_mux->num_items == 1)
    + else if (spec->input_mux->num_items == 1 || spec->shared_mic_hp)
    spec->num_adc_nids = 1; /* reduce to a single ADC */
    }

    diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c
    index 278c0a0..45a087b 100644
    --- a/sound/soc/codecs/ak4642.c
    +++ b/sound/soc/codecs/ak4642.c
    @@ -140,7 +140,7 @@
    * min : 0xFE : -115.0 dB
    * mute: 0xFF
    */
    -static const DECLARE_TLV_DB_SCALE(out_tlv, -11500, 50, 1);
    +static const DECLARE_TLV_DB_SCALE(out_tlv, -11550, 50, 1);

    static const struct snd_kcontrol_new ak4642_snd_controls[] = {

    diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c
    index ec69a6c..900c91b 100644
    --- a/sound/soc/codecs/wm8994.c
    +++ b/sound/soc/codecs/wm8994.c
    @@ -3427,7 +3427,7 @@ static int wm8994_codec_probe(struct snd_soc_codec *codec)
    case 2:
    case 3:
    wm8994->hubs.dcs_codes_l = -9;
    - wm8994->hubs.dcs_codes_r = -5;
    + wm8994->hubs.dcs_codes_r = -7;
    break;
    default:
    break;
    diff --git a/sound/soc/tegra/tegra_i2s.c b/sound/soc/tegra/tegra_i2s.c
    index 33509de..c7f34f9 100644
    --- a/sound/soc/tegra/tegra_i2s.c
    +++ b/sound/soc/tegra/tegra_i2s.c
    @@ -112,7 +112,7 @@ static void tegra_i2s_debug_remove(struct tegra_i2s *i2s)
    debugfs_remove(i2s->debug);
    }
    #else
    -static inline void tegra_i2s_debug_add(struct tegra_i2s *i2s, int id)
    +static inline void tegra_i2s_debug_add(struct tegra_i2s *i2s)
    {
    }


    \
     
     \ /
      Last update: 2012-04-13 18:53    [W:0.212 / U:30.624 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site