[kernel] r17822 - in dists/squeeze/linux-2.6/debian: . patches/bugfix/all/stable patches/features/all/openvz patches/features/all/xen patches/series
Ben Hutchings
benh at alioth.debian.org
Fri Jul 8 04:32:26 UTC 2011
Author: benh
Date: Fri Jul 8 04:32:21 2011
New Revision: 17822
Log:
Add longterm release 2.6.32.42
Drop two patches included in it.
Fix context in a couple of places in openvz.patch.
Drop changes in xen/pvops.patch that are effectively included in it.
Added:
dists/squeeze/linux-2.6/debian/patches/bugfix/all/stable/2.6.32.42.patch
Modified:
dists/squeeze/linux-2.6/debian/changelog
dists/squeeze/linux-2.6/debian/patches/features/all/openvz/openvz.patch
dists/squeeze/linux-2.6/debian/patches/features/all/xen/pvops.patch
dists/squeeze/linux-2.6/debian/patches/series/36
Modified: dists/squeeze/linux-2.6/debian/changelog
==============================================================================
--- dists/squeeze/linux-2.6/debian/changelog Fri Jul 8 01:14:25 2011 (r17821)
+++ dists/squeeze/linux-2.6/debian/changelog Fri Jul 8 04:32:21 2011 (r17822)
@@ -5,6 +5,28 @@
- drm/radeon/kms: fix bad shift in atom iio table parser
* [opvenz] ptrace: Don't allow to trace a process without memory map.
+ [ Ben Hutchings ]
+ * Add longterm release 2.6.32.42, including:
+ - ftrace: Only update the function code on write to filter files
+ - kmemleak: Do not return a pointer to an object that kmemleak did not get
+ - ext3: Fix fs corruption when make_indexed_dir() fails
+ - jbd: fix fsync() tid wraparound bug
+ - loop: handle on-demand devices correctly
+ - xhci: Fix full speed bInterval encoding; fix interval calculation for
+ FS isoc endpoints (regressions in 2.6.32-34)
+ - OHCI: fix regression caused by nVidia shutdown workaround
+ (regression in 2.6.32-31)
+ - brd: handle on-demand devices correctly
+ - xen mmu: fix a race window causing leave_mm BUG()
+ - SCSI: Fix oops caused by queue refcounting failure
+ - nl80211: fix check for valid SSID size in scan operations
+ - fat: Fix corrupt inode flags when remove ATTR_SYS flag
+ - pata_cm64x: fix boot crash on parisc (Closes: #622745, #622997)
+ - Revert "iwlagn: Support new 5000 microcode." (Closes: #632778)
+ For the complete list of changes, see:
+ http://www.kernel.org/pub/linux/kernel/v2.6/longterm/v2.6.32/ChangeLog-2.6.32.42
+ and the bug report which this closes: #631465.
+
-- maximilian attems <maks at debian.org> Sat, 25 Jun 2011 10:22:27 +0200
linux-2.6 (2.6.32-35) stable; urgency=high
Added: dists/squeeze/linux-2.6/debian/patches/bugfix/all/stable/2.6.32.42.patch
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ dists/squeeze/linux-2.6/debian/patches/bugfix/all/stable/2.6.32.42.patch Fri Jul 8 04:32:21 2011 (r17822)
@@ -0,0 +1,2564 @@
+diff --git a/Makefile b/Makefile
+index 46e401f..fbd73d1 100644
+diff --git a/arch/powerpc/kernel/misc_64.S b/arch/powerpc/kernel/misc_64.S
+index 499a133..9161338 100644
+--- a/arch/powerpc/kernel/misc_64.S
++++ b/arch/powerpc/kernel/misc_64.S
+@@ -463,7 +463,8 @@ _GLOBAL(disable_kernel_fp)
+ * wait for the flag to change, indicating this kernel is going away but
+ * the slave code for the next one is at addresses 0 to 100.
+ *
+- * This is used by all slaves.
++ * This is used by all slaves, even those that did not find a matching
++ * paca in the secondary startup code.
+ *
+ * Physical (hardware) cpu id should be in r3.
+ */
+@@ -472,10 +473,6 @@ _GLOBAL(kexec_wait)
+ 1: mflr r5
+ addi r5,r5,kexec_flag-1b
+
+- li r4,KEXEC_STATE_REAL_MODE
+- stb r4,PACAKEXECSTATE(r13)
+- SYNC
+-
+ 99: HMT_LOW
+ #ifdef CONFIG_KEXEC /* use no memory without kexec */
+ lwz r4,0(r5)
+@@ -500,11 +497,17 @@ kexec_flag:
+ *
+ * get phys id from paca
+ * switch to real mode
++ * mark the paca as no longer used
+ * join other cpus in kexec_wait(phys_id)
+ */
+ _GLOBAL(kexec_smp_wait)
+ lhz r3,PACAHWCPUID(r13)
+ bl real_mode
++
++ li r4,KEXEC_STATE_REAL_MODE
++ stb r4,PACAKEXECSTATE(r13)
++ SYNC
++
+ b .kexec_wait
+
+ /*
+diff --git a/arch/powerpc/oprofile/op_model_power4.c b/arch/powerpc/oprofile/op_model_power4.c
+index 8077409..93636ca 100644
+--- a/arch/powerpc/oprofile/op_model_power4.c
++++ b/arch/powerpc/oprofile/op_model_power4.c
+@@ -261,6 +261,28 @@ static int get_kernel(unsigned long pc, unsigned long mmcra)
+ return is_kernel;
+ }
+
++static bool pmc_overflow(unsigned long val)
++{
++ if ((int)val < 0)
++ return true;
++
++ /*
++ * Events on POWER7 can roll back if a speculative event doesn't
++ * eventually complete. Unfortunately in some rare cases they will
++ * raise a performance monitor exception. We need to catch this to
++ * ensure we reset the PMC. In all cases the PMC will be 256 or less
++ * cycles from overflow.
++ *
++ * We only do this if the first pass fails to find any overflowing
++ * PMCs because a user might set a period of less than 256 and we
++ * don't want to mistakenly reset them.
++ */
++ if (__is_processor(PV_POWER7) && ((0x80000000 - val) <= 256))
++ return true;
++
++ return false;
++}
++
+ static void power4_handle_interrupt(struct pt_regs *regs,
+ struct op_counter_config *ctr)
+ {
+@@ -281,7 +303,7 @@ static void power4_handle_interrupt(struct pt_regs *regs,
+
+ for (i = 0; i < cur_cpu_spec->num_pmcs; ++i) {
+ val = classic_ctr_read(i);
+- if (val < 0) {
++ if (pmc_overflow(val)) {
+ if (oprofile_running && ctr[i].enabled) {
+ oprofile_add_ext_sample(pc, regs, i, is_kernel);
+ classic_ctr_write(i, reset_value[i]);
+diff --git a/arch/x86/include/asm/uaccess.h b/arch/x86/include/asm/uaccess.h
+index d2c6c93..61c5874 100644
+--- a/arch/x86/include/asm/uaccess.h
++++ b/arch/x86/include/asm/uaccess.h
+@@ -42,7 +42,7 @@
+ * Returns 0 if the range is valid, nonzero otherwise.
+ *
+ * This is equivalent to the following test:
+- * (u33)addr + (u33)size >= (u33)current->addr_limit.seg (u65 for x86_64)
++ * (u33)addr + (u33)size > (u33)current->addr_limit.seg (u65 for x86_64)
+ *
+ * This needs 33-bit (65-bit for x86_64) arithmetic. We have a carry...
+ */
+diff --git a/arch/x86/kernel/amd_iommu_init.c b/arch/x86/kernel/amd_iommu_init.c
+index 400be99..fc5d470 100644
+--- a/arch/x86/kernel/amd_iommu_init.c
++++ b/arch/x86/kernel/amd_iommu_init.c
+@@ -640,8 +640,8 @@ static void __init init_iommu_from_acpi(struct amd_iommu *iommu,
+ {
+ u8 *p = (u8 *)h;
+ u8 *end = p, flags = 0;
+- u16 dev_i, devid = 0, devid_start = 0, devid_to = 0;
+- u32 ext_flags = 0;
++ u16 devid = 0, devid_start = 0, devid_to = 0;
++ u32 dev_i, ext_flags = 0;
+ bool alias = false;
+ struct ivhd_entry *e;
+
+@@ -796,7 +796,7 @@ static void __init init_iommu_from_acpi(struct amd_iommu *iommu,
+ /* Initializes the device->iommu mapping for the driver */
+ static int __init init_iommu_devices(struct amd_iommu *iommu)
+ {
+- u16 i;
++ u32 i;
+
+ for (i = iommu->first_device; i <= iommu->last_device; ++i)
+ set_iommu_for_device(iommu, i);
+@@ -1068,7 +1068,7 @@ static int __init init_memory_definitions(struct acpi_table_header *table)
+ */
+ static void init_device_table(void)
+ {
+- u16 devid;
++ u32 devid;
+
+ for (devid = 0; devid <= amd_iommu_last_bdf; ++devid) {
+ set_dev_entry_bit(devid, DEV_ENTRY_VALID);
+diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
+index 396c693..6e082dc 100644
+--- a/arch/x86/kernel/cpu/amd.c
++++ b/arch/x86/kernel/cpu/amd.c
+@@ -567,8 +567,11 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
+ }
+ #endif
+
+- /* As a rule processors have APIC timer running in deep C states */
+- if (c->x86 > 0xf && !cpu_has_amd_erratum(amd_erratum_400))
++ /*
++ * Family 0x12 and above processors have APIC timer
++ * running in deep C states.
++ */
++ if (c->x86 > 0x11)
+ set_cpu_cap(c, X86_FEATURE_ARAT);
+
+ /*
+@@ -584,10 +587,13 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
+ * Fixes: https://bugzilla.kernel.org/show_bug.cgi?id=33012
+ */
+ u64 mask;
++ int err;
+
+- rdmsrl(MSR_AMD64_MCx_MASK(4), mask);
+- mask |= (1 << 10);
+- wrmsrl(MSR_AMD64_MCx_MASK(4), mask);
++ err = rdmsrl_safe(MSR_AMD64_MCx_MASK(4), &mask);
++ if (err == 0) {
++ mask |= (1 << 10);
++ checking_wrmsrl(MSR_AMD64_MCx_MASK(4), mask);
++ }
+ }
+ }
+
+diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
+index 4cf7956..c40c432 100644
+--- a/arch/x86/kernel/process_32.c
++++ b/arch/x86/kernel/process_32.c
+@@ -298,7 +298,6 @@ start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
+ {
+ set_user_gs(regs, 0);
+ regs->fs = 0;
+- set_fs(USER_DS);
+ regs->ds = __USER_DS;
+ regs->es = __USER_DS;
+ regs->ss = __USER_DS;
+diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
+index 868fdb4..39493bc 100644
+--- a/arch/x86/kernel/process_64.c
++++ b/arch/x86/kernel/process_64.c
+@@ -356,7 +356,6 @@ start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
+ regs->cs = __USER_CS;
+ regs->ss = __USER_DS;
+ regs->flags = 0x200;
+- set_fs(USER_DS);
+ /*
+ * Free the old FP and other extended state
+ */
+diff --git a/arch/x86/lib/copy_user_64.S b/arch/x86/lib/copy_user_64.S
+index 6ba0f7b..af8debd 100644
+--- a/arch/x86/lib/copy_user_64.S
++++ b/arch/x86/lib/copy_user_64.S
+@@ -72,7 +72,7 @@ ENTRY(copy_to_user)
+ addq %rdx,%rcx
+ jc bad_to_user
+ cmpq TI_addr_limit(%rax),%rcx
+- jae bad_to_user
++ ja bad_to_user
+ ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,copy_user_generic_unrolled,copy_user_generic_string
+ CFI_ENDPROC
+ ENDPROC(copy_to_user)
+@@ -85,7 +85,7 @@ ENTRY(copy_from_user)
+ addq %rdx,%rcx
+ jc bad_from_user
+ cmpq TI_addr_limit(%rax),%rcx
+- jae bad_from_user
++ ja bad_from_user
+ ALTERNATIVE_JUMP X86_FEATURE_REP_GOOD,copy_user_generic_unrolled,copy_user_generic_string
+ CFI_ENDPROC
+ ENDPROC(copy_from_user)
+diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
+index 6ec047d..356a799 100644
+--- a/arch/x86/xen/mmu.c
++++ b/arch/x86/xen/mmu.c
+@@ -1141,7 +1141,7 @@ static void drop_other_mm_ref(void *info)
+
+ active_mm = percpu_read(cpu_tlbstate.active_mm);
+
+- if (active_mm == mm)
++ if (active_mm == mm && percpu_read(cpu_tlbstate.state) != TLBSTATE_OK)
+ leave_mm(smp_processor_id());
+
+ /* If this cpu still has a stale cr3 reference, then make sure
+diff --git a/arch/x86/xen/multicalls.c b/arch/x86/xen/multicalls.c
+index 8bff7e7..1b2b73f 100644
+--- a/arch/x86/xen/multicalls.c
++++ b/arch/x86/xen/multicalls.c
+@@ -189,10 +189,10 @@ struct multicall_space __xen_mc_entry(size_t args)
+ unsigned argidx = roundup(b->argidx, sizeof(u64));
+
+ BUG_ON(preemptible());
+- BUG_ON(b->argidx > MC_ARGS);
++ BUG_ON(b->argidx >= MC_ARGS);
+
+ if (b->mcidx == MC_BATCH ||
+- (argidx + args) > MC_ARGS) {
++ (argidx + args) >= MC_ARGS) {
+ mc_stats_flush(b->mcidx == MC_BATCH ? FL_SLOTS : FL_ARGS);
+ xen_mc_flush();
+ argidx = roundup(b->argidx, sizeof(u64));
+@@ -206,7 +206,7 @@ struct multicall_space __xen_mc_entry(size_t args)
+ ret.args = &b->args[argidx];
+ b->argidx = argidx + args;
+
+- BUG_ON(b->argidx > MC_ARGS);
++ BUG_ON(b->argidx >= MC_ARGS);
+ return ret;
+ }
+
+@@ -216,7 +216,7 @@ struct multicall_space xen_mc_extend_args(unsigned long op, size_t size)
+ struct multicall_space ret = { NULL, NULL };
+
+ BUG_ON(preemptible());
+- BUG_ON(b->argidx > MC_ARGS);
++ BUG_ON(b->argidx >= MC_ARGS);
+
+ if (b->mcidx == 0)
+ return ret;
+@@ -224,14 +224,14 @@ struct multicall_space xen_mc_extend_args(unsigned long op, size_t size)
+ if (b->entries[b->mcidx - 1].op != op)
+ return ret;
+
+- if ((b->argidx + size) > MC_ARGS)
++ if ((b->argidx + size) >= MC_ARGS)
+ return ret;
+
+ ret.mc = &b->entries[b->mcidx - 1];
+ ret.args = &b->args[b->argidx];
+ b->argidx += size;
+
+- BUG_ON(b->argidx > MC_ARGS);
++ BUG_ON(b->argidx >= MC_ARGS);
+ return ret;
+ }
+
+diff --git a/block/blk-core.c b/block/blk-core.c
+index 71da511..cffd737 100644
+--- a/block/blk-core.c
++++ b/block/blk-core.c
+@@ -310,6 +310,7 @@ void blk_unplug_timeout(unsigned long data)
+ trace_block_unplug_timer(q);
+ kblockd_schedule_work(q, &q->unplug_work);
+ }
++EXPORT_SYMBOL(blk_put_queue);
+
+ void blk_unplug(struct request_queue *q)
+ {
+@@ -612,6 +613,7 @@ int blk_get_queue(struct request_queue *q)
+
+ return 1;
+ }
++EXPORT_SYMBOL(blk_get_queue);
+
+ static inline void blk_free_request(struct request_queue *q, struct request *rq)
+ {
+diff --git a/block/blk.h b/block/blk.h
+index 5ee3d7e..1414836 100644
+--- a/block/blk.h
++++ b/block/blk.h
+@@ -62,7 +62,8 @@ static inline struct request *__elv_next_request(struct request_queue *q)
+ return rq;
+ }
+
+- if (!q->elevator->ops->elevator_dispatch_fn(q, 0))
++ if (test_bit(QUEUE_FLAG_DEAD, &q->queue_flags) ||
++ !q->elevator->ops->elevator_dispatch_fn(q, 0))
+ return NULL;
+ }
+ }
+diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
+index 0b09703..d71d2c0 100644
+--- a/drivers/acpi/scan.c
++++ b/drivers/acpi/scan.c
+@@ -1026,12 +1026,6 @@ static void acpi_device_set_id(struct acpi_device *device)
+ if (ACPI_IS_ROOT_DEVICE(device)) {
+ acpi_add_id(device, ACPI_SYSTEM_HID);
+ break;
+- } else if (ACPI_IS_ROOT_DEVICE(device->parent)) {
+- /* \_SB_, the only root-level namespace device */
+- acpi_add_id(device, ACPI_BUS_HID);
+- strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
+- strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
+- break;
+ }
+
+ status = acpi_get_object_info(device->handle, &info);
+@@ -1064,6 +1058,12 @@ static void acpi_device_set_id(struct acpi_device *device)
+ acpi_add_id(device, ACPI_BAY_HID);
+ else if (ACPI_SUCCESS(acpi_dock_match(device)))
+ acpi_add_id(device, ACPI_DOCK_HID);
++ else if (!acpi_device_hid(device) &&
++ ACPI_IS_ROOT_DEVICE(device->parent)) {
++ acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
++ strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
++ strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
++ }
+
+ break;
+ case ACPI_BUS_TYPE_POWER:
+diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
+index f0bad9b..ccd2694 100644
+--- a/drivers/ata/pata_cmd64x.c
++++ b/drivers/ata/pata_cmd64x.c
+@@ -2,6 +2,7 @@
+ * pata_cmd64x.c - CMD64x PATA for new ATA layer
+ * (C) 2005 Red Hat Inc
+ * Alan Cox <alan at lxorguk.ukuu.org.uk>
++ * (C) 2009-2010 Bartlomiej Zolnierkiewicz
+ *
+ * Based upon
+ * linux/drivers/ide/pci/cmd64x.c Version 1.30 Sept 10, 2002
+@@ -39,11 +40,10 @@
+
+ enum {
+ CFR = 0x50,
+- CFR_INTR_CH0 = 0x02,
+- CNTRL = 0x51,
+- CNTRL_DIS_RA0 = 0x40,
+- CNTRL_DIS_RA1 = 0x80,
+- CNTRL_ENA_2ND = 0x08,
++ CFR_INTR_CH0 = 0x04,
++ CNTRL = 0x51,
++ CNTRL_CH0 = 0x04,
++ CNTRL_CH1 = 0x08,
+ CMDTIM = 0x52,
+ ARTTIM0 = 0x53,
+ DRWTIM0 = 0x54,
+@@ -53,9 +53,6 @@ enum {
+ ARTTIM23_DIS_RA2 = 0x04,
+ ARTTIM23_DIS_RA3 = 0x08,
+ ARTTIM23_INTR_CH1 = 0x10,
+- ARTTIM2 = 0x57,
+- ARTTIM3 = 0x57,
+- DRWTIM23 = 0x58,
+ DRWTIM2 = 0x58,
+ BRST = 0x59,
+ DRWTIM3 = 0x5b,
+@@ -63,14 +60,11 @@ enum {
+ MRDMODE = 0x71,
+ MRDMODE_INTR_CH0 = 0x04,
+ MRDMODE_INTR_CH1 = 0x08,
+- MRDMODE_BLK_CH0 = 0x10,
+- MRDMODE_BLK_CH1 = 0x20,
+ BMIDESR0 = 0x72,
+ UDIDETCR0 = 0x73,
+ DTPR0 = 0x74,
+ BMIDECR1 = 0x78,
+ BMIDECSR = 0x79,
+- BMIDESR1 = 0x7A,
+ UDIDETCR1 = 0x7B,
+ DTPR1 = 0x7C
+ };
+@@ -147,7 +141,9 @@ static void cmd64x_set_timing(struct ata_port *ap, struct ata_device *adev, u8 m
+ /* Now convert the clocks into values we can actually stuff into
+ the chip */
+
+- if (t.recover > 1)
++ if (t.recover == 16)
++ t.recover = 0;
++ else if (t.recover > 1)
+ t.recover--;
+ else
+ t.recover = 15;
+@@ -245,7 +241,7 @@ static void cmd648_bmdma_stop(struct ata_queued_cmd *qc)
+ struct pci_dev *pdev = to_pci_dev(ap->host->dev);
+ u8 dma_intr;
+ int dma_mask = ap->port_no ? ARTTIM23_INTR_CH1 : CFR_INTR_CH0;
+- int dma_reg = ap->port_no ? ARTTIM2 : CFR;
++ int dma_reg = ap->port_no ? ARTTIM23 : CFR;
+
+ ata_bmdma_stop(qc);
+
+@@ -294,8 +290,6 @@ static struct ata_port_operations cmd648_port_ops = {
+
+ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+ {
+- u32 class_rev;
+-
+ static const struct ata_port_info cmd_info[6] = {
+ { /* CMD 643 - no UDMA */
+ .flags = ATA_FLAG_SLAVE_POSS,
+@@ -337,27 +331,41 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+ .port_ops = &cmd648_port_ops
+ }
+ };
+- const struct ata_port_info *ppi[] = { &cmd_info[id->driver_data], NULL };
+- u8 mrdmode;
++ const struct ata_port_info *ppi[] = {
++ &cmd_info[id->driver_data],
++ &cmd_info[id->driver_data],
++ NULL
++ };
++ u8 mrdmode, reg;
+ int rc;
++ struct pci_dev *bridge = pdev->bus->self;
++ /* mobility split bridges don't report enabled ports correctly */
++ int port_ok = !(bridge && bridge->vendor ==
++ PCI_VENDOR_ID_MOBILITY_ELECTRONICS);
++ /* all (with exceptions below) apart from 643 have CNTRL_CH0 bit */
++ int cntrl_ch0_ok = (id->driver_data != 0);
+
+ rc = pcim_enable_device(pdev);
+ if (rc)
+ return rc;
+
+- pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
+- class_rev &= 0xFF;
+-
+ if (id->driver_data == 0) /* 643 */
+ ata_pci_bmdma_clear_simplex(pdev);
+
+ if (pdev->device == PCI_DEVICE_ID_CMD_646) {
+ /* Does UDMA work ? */
+- if (class_rev > 4)
++ if (pdev->revision > 4) {
+ ppi[0] = &cmd_info[2];
++ ppi[1] = &cmd_info[2];
++ }
+ /* Early rev with other problems ? */
+- else if (class_rev == 1)
++ else if (pdev->revision == 1) {
+ ppi[0] = &cmd_info[3];
++ ppi[1] = &cmd_info[3];
++ }
++ /* revs 1,2 have no CNTRL_CH0 */
++ if (pdev->revision < 3)
++ cntrl_ch0_ok = 0;
+ }
+
+ pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 64);
+@@ -366,6 +374,20 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
+ mrdmode |= 0x02; /* Memory read line enable */
+ pci_write_config_byte(pdev, MRDMODE, mrdmode);
+
++ /* check for enabled ports */
++ pci_read_config_byte(pdev, CNTRL, ®);
++ if (!port_ok)
++ dev_printk(KERN_NOTICE, &pdev->dev, "Mobility Bridge detected, ignoring CNTRL port enable/disable\n");
++ if (port_ok && cntrl_ch0_ok && !(reg & CNTRL_CH0)) {
++ dev_printk(KERN_NOTICE, &pdev->dev, "Primary port is disabled\n");
++ ppi[0] = &ata_dummy_port_info;
++
++ }
++ if (port_ok && !(reg & CNTRL_CH1)) {
++ dev_printk(KERN_NOTICE, &pdev->dev, "Secondary port is disabled\n");
++ ppi[1] = &ata_dummy_port_info;
++ }
++
+ /* Force PIO 0 here.. */
+
+ /* PPC specific fixup copied from old driver */
+diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
+index d7f2da1..b9d8836 100644
+--- a/drivers/ata/pata_hpt366.c
++++ b/drivers/ata/pata_hpt366.c
+@@ -344,7 +344,6 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ const struct ata_port_info *ppi[] = { &info_hpt366, NULL };
+
+ void *hpriv = NULL;
+- u32 class_rev;
+ u32 reg1;
+ int rc;
+
+@@ -352,13 +351,10 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ if (rc)
+ return rc;
+
+- pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
+- class_rev &= 0xFF;
+-
+ /* May be a later chip in disguise. Check */
+ /* Newer chips are not in the HPT36x driver. Ignore them */
+- if (class_rev > 2)
+- return -ENODEV;
++ if (dev->revision > 2)
++ return -ENODEV;
+
+ hpt36x_init_chipset(dev);
+
+diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
+index ec07c53..5af7f19 100644
+--- a/drivers/ata/pata_hpt37x.c
++++ b/drivers/ata/pata_hpt37x.c
+@@ -789,9 +789,8 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ static const int MHz[4] = { 33, 40, 50, 66 };
+ void *private_data = NULL;
+ const struct ata_port_info *ppi[] = { NULL, NULL };
+-
++ u8 rev = dev->revision;
+ u8 irqmask;
+- u32 class_rev;
+ u8 mcr1;
+ u32 freq;
+ int prefer_dpll = 1;
+@@ -806,19 +805,16 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ if (rc)
+ return rc;
+
+- pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
+- class_rev &= 0xFF;
+-
+ if (dev->device == PCI_DEVICE_ID_TTI_HPT366) {
+ /* May be a later chip in disguise. Check */
+ /* Older chips are in the HPT366 driver. Ignore them */
+- if (class_rev < 3)
++ if (rev < 3)
+ return -ENODEV;
+ /* N series chips have their own driver. Ignore */
+- if (class_rev == 6)
++ if (rev == 6)
+ return -ENODEV;
+
+- switch(class_rev) {
++ switch(rev) {
+ case 3:
+ ppi[0] = &info_hpt370;
+ chip_table = &hpt370;
+@@ -834,28 +830,29 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ chip_table = &hpt372;
+ break;
+ default:
+- printk(KERN_ERR "pata_hpt37x: Unknown HPT366 subtype please report (%d).\n", class_rev);
++ printk(KERN_ERR "pata_hpt37x: Unknown HPT366 "
++ "subtype, please report (%d).\n", rev);
+ return -ENODEV;
+ }
+ } else {
+ switch(dev->device) {
+ case PCI_DEVICE_ID_TTI_HPT372:
+ /* 372N if rev >= 2*/
+- if (class_rev >= 2)
++ if (rev >= 2)
+ return -ENODEV;
+ ppi[0] = &info_hpt372;
+ chip_table = &hpt372a;
+ break;
+ case PCI_DEVICE_ID_TTI_HPT302:
+ /* 302N if rev > 1 */
+- if (class_rev > 1)
++ if (rev > 1)
+ return -ENODEV;
+ ppi[0] = &info_hpt372;
+ /* Check this */
+ chip_table = &hpt302;
+ break;
+ case PCI_DEVICE_ID_TTI_HPT371:
+- if (class_rev > 1)
++ if (rev > 1)
+ return -ENODEV;
+ ppi[0] = &info_hpt372;
+ chip_table = &hpt371;
+diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
+index d9f2913..100f227 100644
+--- a/drivers/ata/pata_hpt3x2n.c
++++ b/drivers/ata/pata_hpt3x2n.c
+@@ -452,10 +452,8 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ .port_ops = &hpt3x2n_port_ops
+ };
+ const struct ata_port_info *ppi[] = { &info, NULL };
+-
++ u8 rev = dev->revision;
+ u8 irqmask;
+- u32 class_rev;
+-
+ unsigned int pci_mhz;
+ unsigned int f_low, f_high;
+ int adjust;
+@@ -467,26 +465,23 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+ if (rc)
+ return rc;
+
+- pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
+- class_rev &= 0xFF;
+-
+ switch(dev->device) {
+ case PCI_DEVICE_ID_TTI_HPT366:
+- if (class_rev < 6)
++ if (rev < 6)
+ return -ENODEV;
+ break;
+ case PCI_DEVICE_ID_TTI_HPT371:
+- if (class_rev < 2)
++ if (rev < 2)
+ return -ENODEV;
+ /* 371N if rev > 1 */
+ break;
+ case PCI_DEVICE_ID_TTI_HPT372:
+ /* 372N if rev >= 2*/
+- if (class_rev < 2)
++ if (rev < 2)
+ return -ENODEV;
+ break;
+ case PCI_DEVICE_ID_TTI_HPT302:
+- if (class_rev < 2)
++ if (rev < 2)
+ return -ENODEV;
+ break;
+ case PCI_DEVICE_ID_TTI_HPT372N:
+diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
+index 4cb649d..a2ace48 100644
+--- a/drivers/ata/pata_sil680.c
++++ b/drivers/ata/pata_sil680.c
+@@ -212,13 +212,11 @@ static struct ata_port_operations sil680_port_ops = {
+
+ static u8 sil680_init_chip(struct pci_dev *pdev, int *try_mmio)
+ {
+- u32 class_rev = 0;
+ u8 tmpbyte = 0;
+
+- pci_read_config_dword(pdev, PCI_CLASS_REVISION, &class_rev);
+- class_rev &= 0xff;
+ /* FIXME: double check */
+- pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, (class_rev) ? 1 : 255);
++ pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
++ pdev->revision ? 1 : 255);
+
+ pci_write_config_byte(pdev, 0x80, 0x00);
+ pci_write_config_byte(pdev, 0x84, 0x00);
+diff --git a/drivers/block/brd.c b/drivers/block/brd.c
+index 4f68843..2ef55c4 100644
+--- a/drivers/block/brd.c
++++ b/drivers/block/brd.c
+@@ -498,7 +498,7 @@ static struct kobject *brd_probe(dev_t dev, int *part, void *data)
+ struct kobject *kobj;
+
+ mutex_lock(&brd_devices_mutex);
+- brd = brd_init_one(dev & MINORMASK);
++ brd = brd_init_one(MINOR(dev) >> part_shift);
+ kobj = brd ? get_disk(brd->brd_disk) : ERR_PTR(-ENOMEM);
+ mutex_unlock(&brd_devices_mutex);
+
+@@ -531,15 +531,18 @@ static int __init brd_init(void)
+ if (max_part > 0)
+ part_shift = fls(max_part);
+
++ if ((1UL << part_shift) > DISK_MAX_PARTS)
++ return -EINVAL;
++
+ if (rd_nr > 1UL << (MINORBITS - part_shift))
+ return -EINVAL;
+
+ if (rd_nr) {
+ nr = rd_nr;
+- range = rd_nr;
++ range = rd_nr << part_shift;
+ } else {
+ nr = CONFIG_BLK_DEV_RAM_COUNT;
+- range = 1UL << (MINORBITS - part_shift);
++ range = 1UL << MINORBITS;
+ }
+
+ if (register_blkdev(RAMDISK_MAJOR, "ramdisk"))
+@@ -578,7 +581,7 @@ static void __exit brd_exit(void)
+ unsigned long range;
+ struct brd_device *brd, *next;
+
+- range = rd_nr ? rd_nr : 1UL << (MINORBITS - part_shift);
++ range = rd_nr ? rd_nr << part_shift : 1UL << MINORBITS;
+
+ list_for_each_entry_safe(brd, next, &brd_devices, brd_list)
+ brd_del_one(brd);
+diff --git a/drivers/block/loop.c b/drivers/block/loop.c
+index 1c21a3f..8ec2d70 100644
+--- a/drivers/block/loop.c
++++ b/drivers/block/loop.c
+@@ -1572,7 +1572,7 @@ static struct kobject *loop_probe(dev_t dev, int *part, void *data)
+ struct kobject *kobj;
+
+ mutex_lock(&loop_devices_mutex);
+- lo = loop_init_one(dev & MINORMASK);
++ lo = loop_init_one(MINOR(dev) >> part_shift);
+ kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM);
+ mutex_unlock(&loop_devices_mutex);
+
+@@ -1605,15 +1605,18 @@ static int __init loop_init(void)
+ if (max_part > 0)
+ part_shift = fls(max_part);
+
++ if ((1UL << part_shift) > DISK_MAX_PARTS)
++ return -EINVAL;
++
+ if (max_loop > 1UL << (MINORBITS - part_shift))
+ return -EINVAL;
+
+ if (max_loop) {
+ nr = max_loop;
+- range = max_loop;
++ range = max_loop << part_shift;
+ } else {
+ nr = 8;
+- range = 1UL << (MINORBITS - part_shift);
++ range = 1UL << MINORBITS;
+ }
+
+ if (register_blkdev(LOOP_MAJOR, "loop"))
+@@ -1652,7 +1655,7 @@ static void __exit loop_exit(void)
+ unsigned long range;
+ struct loop_device *lo, *next;
+
+- range = max_loop ? max_loop : 1UL << (MINORBITS - part_shift);
++ range = max_loop ? max_loop << part_shift : 1UL << MINORBITS;
+
+ list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
+ loop_del_one(lo);
+diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
+index cc923a5..26ada47 100644
+--- a/drivers/block/nbd.c
++++ b/drivers/block/nbd.c
+@@ -754,6 +754,12 @@ static int __init nbd_init(void)
+ if (max_part > 0)
+ part_shift = fls(max_part);
+
++ if ((1UL << part_shift) > DISK_MAX_PARTS)
++ return -EINVAL;
++
++ if (nbds_max > 1UL << (MINORBITS - part_shift))
++ return -EINVAL;
++
+ for (i = 0; i < nbds_max; i++) {
+ struct gendisk *disk = alloc_disk(1 << part_shift);
+ if (!disk)
+diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c
+index 4365717..1e116ac 100644
+--- a/drivers/char/i8k.c
++++ b/drivers/char/i8k.c
+@@ -138,8 +138,8 @@ static int i8k_smm(struct smm_regs *regs)
+ "movl %%edi,20(%%rax)\n\t"
+ "popq %%rdx\n\t"
+ "movl %%edx,0(%%rax)\n\t"
+- "lahf\n\t"
+- "shrl $8,%%eax\n\t"
++ "pushfq\n\t"
++ "popq %%rax\n\t"
+ "andl $1,%%eax\n"
+ :"=a"(rc)
+ : "a"(regs)
+diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
+index c18e65e..c7ae026 100644
+--- a/drivers/cpufreq/cpufreq.c
++++ b/drivers/cpufreq/cpufreq.c
+@@ -1183,12 +1183,28 @@ static int __cpufreq_remove_dev(struct sys_device *sys_dev)
+
+ unlock_policy_rwsem_write(cpu);
+
++ cpufreq_debug_enable_ratelimit();
++
++#ifdef CONFIG_HOTPLUG_CPU
++ /* when the CPU which is the parent of the kobj is hotplugged
++ * offline, check for siblings, and create cpufreq sysfs interface
++ * and symlinks
++ */
++ if (unlikely(cpumask_weight(data->cpus) > 1)) {
++ /* first sibling now owns the new sysfs dir */
++ cpumask_clear_cpu(cpu, data->cpus);
++ cpufreq_add_dev(get_cpu_sysdev(cpumask_first(data->cpus)));
++
++ /* finally remove our own symlink */
++ lock_policy_rwsem_write(cpu);
++ __cpufreq_remove_dev(sys_dev);
++ }
++#endif
++
+ free_cpumask_var(data->related_cpus);
+ free_cpumask_var(data->cpus);
+ kfree(data);
+- per_cpu(cpufreq_cpu_data, cpu) = NULL;
+
+- cpufreq_debug_enable_ratelimit();
+ return 0;
+ }
+
+diff --git a/drivers/cpufreq/cpufreq_stats.c b/drivers/cpufreq/cpufreq_stats.c
+index 5a62d67..6bbc164 100644
+--- a/drivers/cpufreq/cpufreq_stats.c
++++ b/drivers/cpufreq/cpufreq_stats.c
+@@ -164,17 +164,27 @@ static int freq_table_get_index(struct cpufreq_stats *stat, unsigned int freq)
+ return -1;
+ }
+
++/* should be called late in the CPU removal sequence so that the stats
++ * memory is still available in case someone tries to use it.
++ */
+ static void cpufreq_stats_free_table(unsigned int cpu)
+ {
+ struct cpufreq_stats *stat = per_cpu(cpufreq_stats_table, cpu);
+- struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+- if (policy && policy->cpu == cpu)
+- sysfs_remove_group(&policy->kobj, &stats_attr_group);
+ if (stat) {
+ kfree(stat->time_in_state);
+ kfree(stat);
+ }
+ per_cpu(cpufreq_stats_table, cpu) = NULL;
++}
++
++/* must be called early in the CPU removal sequence (before
++ * cpufreq_remove_dev) so that policy is still valid.
++ */
++static void cpufreq_stats_free_sysfs(unsigned int cpu)
++{
++ struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
++ if (policy && policy->cpu == cpu)
++ sysfs_remove_group(&policy->kobj, &stats_attr_group);
+ if (policy)
+ cpufreq_cpu_put(policy);
+ }
+@@ -315,6 +325,9 @@ static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb,
+ case CPU_ONLINE_FROZEN:
+ cpufreq_update_policy(cpu);
+ break;
++ case CPU_DOWN_PREPARE:
++ cpufreq_stats_free_sysfs(cpu);
++ break;
+ case CPU_DEAD:
+ case CPU_DEAD_FROZEN:
+ cpufreq_stats_free_table(cpu);
+@@ -323,9 +336,11 @@ static int __cpuinit cpufreq_stat_cpu_callback(struct notifier_block *nfb,
+ return NOTIFY_OK;
+ }
+
++/* priority=1 so this will get called before cpufreq_remove_dev */
+ static struct notifier_block cpufreq_stat_cpu_notifier __refdata =
+ {
+ .notifier_call = cpufreq_stat_cpu_callback,
++ .priority = 1,
+ };
+
+ static struct notifier_block notifier_policy_block = {
+@@ -372,6 +387,7 @@ static void __exit cpufreq_stats_exit(void)
+ unregister_hotcpu_notifier(&cpufreq_stat_cpu_notifier);
+ for_each_online_cpu(cpu) {
+ cpufreq_stats_free_table(cpu);
++ cpufreq_stats_free_sysfs(cpu);
+ }
+ }
+
+diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
+index f8e57c6..0537437 100644
+--- a/drivers/cpuidle/governors/menu.c
++++ b/drivers/cpuidle/governors/menu.c
+@@ -185,6 +185,7 @@ static int menu_select(struct cpuidle_device *dev)
+ int latency_req = pm_qos_requirement(PM_QOS_CPU_DMA_LATENCY);
+ int i;
+ int multiplier;
++ struct timespec t;
+
+ if (data->needs_update) {
+ menu_update(dev);
+@@ -199,8 +200,9 @@ static int menu_select(struct cpuidle_device *dev)
+ return 0;
+
+ /* determine the expected residency time, round up */
++ t = ktime_to_timespec(tick_nohz_get_sleep_length());
+ data->expected_us =
+- DIV_ROUND_UP((u32)ktime_to_ns(tick_nohz_get_sleep_length()), 1000);
++ t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC;
+
+
+ data->bucket = which_bucket(data->expected_us);
+diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
+index 44626bc..96b39fc 100644
+diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
+index 41bb76f..3db54e9 100644
+diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
+index 57f32f0..03345bb 100644
+--- a/drivers/md/dm-table.c
++++ b/drivers/md/dm-table.c
+@@ -348,6 +348,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
+ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
+ sector_t start, sector_t len, void *data)
+ {
++ struct request_queue *q;
+ struct queue_limits *limits = data;
+ struct block_device *bdev = dev->bdev;
+ sector_t dev_size =
+@@ -356,6 +357,22 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
+ limits->logical_block_size >> SECTOR_SHIFT;
+ char b[BDEVNAME_SIZE];
+
++ /*
++ * Some devices exist without request functions,
++ * such as loop devices not yet bound to backing files.
++ * Forbid the use of such devices.
++ */
++ q = bdev_get_queue(bdev);
++ if (!q || !q->make_request_fn) {
++ DMWARN("%s: %s is not yet initialised: "
++ "start=%llu, len=%llu, dev_size=%llu",
++ dm_device_name(ti->table->md), bdevname(bdev, b),
++ (unsigned long long)start,
++ (unsigned long long)len,
++ (unsigned long long)dev_size);
++ return 1;
++ }
++
+ if (!dev_size)
+ return 0;
+
+diff --git a/drivers/md/md.c b/drivers/md/md.c
+index 697a2c7..7c5129f 100644
+--- a/drivers/md/md.c
++++ b/drivers/md/md.c
+@@ -2262,7 +2262,7 @@ slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
+ if (rdev->raid_disk == -1)
+ return -EEXIST;
+ /* personality does all needed checks */
+- if (rdev->mddev->pers->hot_add_disk == NULL)
++ if (rdev->mddev->pers->hot_remove_disk == NULL)
+ return -EINVAL;
+ err = rdev->mddev->pers->
+ hot_remove_disk(rdev->mddev, rdev->raid_disk);
+diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
+index 2394973..cf59d64 100644
+--- a/drivers/md/raid5.c
++++ b/drivers/md/raid5.c
+@@ -127,7 +127,7 @@ static inline int raid5_dec_bi_hw_segments(struct bio *bio)
+
+ static inline void raid5_set_bi_hw_segments(struct bio *bio, unsigned int cnt)
+ {
+- bio->bi_phys_segments = raid5_bi_phys_segments(bio) || (cnt << 16);
++ bio->bi_phys_segments = raid5_bi_phys_segments(bio) | (cnt << 16);
+ }
+
+ /* Find first data disk in a raid6 stripe */
+@@ -446,7 +446,7 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
+ bi = &sh->dev[i].req;
+
+ bi->bi_rw = rw;
+- if (rw == WRITE)
++ if (rw & WRITE)
+ bi->bi_end_io = raid5_end_write_request;
+ else
+ bi->bi_end_io = raid5_end_read_request;
+@@ -480,13 +480,13 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
+ bi->bi_io_vec[0].bv_offset = 0;
+ bi->bi_size = STRIPE_SIZE;
+ bi->bi_next = NULL;
+- if (rw == WRITE &&
++ if ((rw & WRITE) &&
+ test_bit(R5_ReWrite, &sh->dev[i].flags))
+ atomic_add(STRIPE_SECTORS,
+ &rdev->corrected_errors);
+ generic_make_request(bi);
+ } else {
+- if (rw == WRITE)
++ if (rw & WRITE)
+ set_bit(STRIPE_DEGRADED, &sh->state);
+ pr_debug("skip op %ld on disc %d for sector %llu\n",
+ bi->bi_rw, i, (unsigned long long)sh->sector);
+diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
+index db6de74..b140257 100644
+--- a/drivers/mtd/mtdconcat.c
++++ b/drivers/mtd/mtdconcat.c
+@@ -306,7 +306,7 @@ concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
+ if (!(mtd->flags & MTD_WRITEABLE))
+ return -EROFS;
+
+- ops->retlen = 0;
++ ops->retlen = ops->oobretlen = 0;
+
+ for (i = 0; i < concat->num_subdev; i++) {
+ struct mtd_info *subdev = concat->subdev[i];
+@@ -321,7 +321,7 @@ concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
+ devops.len = subdev->size - to;
+
+ err = subdev->write_oob(subdev, to, &devops);
+- ops->retlen += devops.retlen;
++ ops->retlen += devops.oobretlen;
+ if (err)
+ return err;
+
+diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
+index dbceac7..1f423f2 100644
+--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
++++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
+@@ -47,7 +47,7 @@
+ #include "iwl-6000-hw.h"
+
+ /* Highest firmware API version supported */
+-#define IWL5000_UCODE_API_MAX 5
++#define IWL5000_UCODE_API_MAX 2
+ #define IWL5150_UCODE_API_MAX 2
+
+ /* Lowest firmware API version supported */
+diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
+index 54c3a9d..cb74ac6 100644
+--- a/drivers/net/wireless/p54/p54usb.c
++++ b/drivers/net/wireless/p54/p54usb.c
+@@ -80,6 +80,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
+ {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
+ {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
+ {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
++ {USB_DEVICE(0x083a, 0xc501)}, /* Zoom Wireless-G 4410 */
+ {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
+ {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
+ {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
+diff --git a/drivers/pci/hotplug/pcihp_slot.c b/drivers/pci/hotplug/pcihp_slot.c
+index cc8ec3a..1fd6c5f 100644
+--- a/drivers/pci/hotplug/pcihp_slot.c
++++ b/drivers/pci/hotplug/pcihp_slot.c
+@@ -158,6 +158,47 @@ static void program_hpp_type2(struct pci_dev *dev, struct hpp_type2 *hpp)
+ */
+ }
+
++/* Program PCIE MaxPayload setting on device: ensure parent maxpayload <= device */
++static int pci_set_payload(struct pci_dev *dev)
++{
++ int pos, ppos;
++ u16 pctl, psz;
++ u16 dctl, dsz, dcap, dmax;
++ struct pci_dev *parent;
++
++ parent = dev->bus->self;
++ pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
++ if (!pos)
++ return 0;
++
++ /* Read Device MaxPayload capability and setting */
++ pci_read_config_word(dev, pos + PCI_EXP_DEVCTL, &dctl);
++ pci_read_config_word(dev, pos + PCI_EXP_DEVCAP, &dcap);
++ dsz = (dctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
++ dmax = (dcap & PCI_EXP_DEVCAP_PAYLOAD);
++
++ /* Read Parent MaxPayload setting */
++ ppos = pci_find_capability(parent, PCI_CAP_ID_EXP);
++ if (!ppos)
++ return 0;
++ pci_read_config_word(parent, ppos + PCI_EXP_DEVCTL, &pctl);
++ psz = (pctl & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
++
++ /* If parent payload > device max payload -> error
++ * If parent payload > device payload -> set speed
++ * If parent payload <= device payload -> do nothing
++ */
++ if (psz > dmax)
++ return -1;
++ else if (psz > dsz) {
++ dev_info(&dev->dev, "Setting MaxPayload to %d\n", 128 << psz);
++ pci_write_config_word(dev, pos + PCI_EXP_DEVCTL,
++ (dctl & ~PCI_EXP_DEVCTL_PAYLOAD) +
++ (psz << 5));
++ }
++ return 0;
++}
++
+ void pci_configure_slot(struct pci_dev *dev)
+ {
+ struct pci_dev *cdev;
+@@ -169,6 +210,10 @@ void pci_configure_slot(struct pci_dev *dev)
+ (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)))
+ return;
+
++ ret = pci_set_payload(dev);
++ if (ret)
++ dev_warn(&dev->dev, "could not set device max payload\n");
++
+ memset(&hpp, 0, sizeof(hpp));
+ ret = pci_get_hp_params(dev, &hpp);
+ if (ret)
+diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
+index 812d4ac..0d3326d 100644
+--- a/drivers/pci/pci.c
++++ b/drivers/pci/pci.c
+@@ -373,8 +373,12 @@ pci_find_parent_resource(const struct pci_dev *dev, struct resource *res)
+ continue; /* Wrong type */
+ if (!((res->flags ^ r->flags) & IORESOURCE_PREFETCH))
+ return r; /* Exact match */
+- if ((res->flags & IORESOURCE_PREFETCH) && !(r->flags & IORESOURCE_PREFETCH))
+- best = r; /* Approximating prefetchable by non-prefetchable */
++ /* We can't insert a non-prefetch resource inside a prefetchable parent .. */
++ if (r->flags & IORESOURCE_PREFETCH)
++ continue;
++ /* .. but we can put a prefetchable resource inside a non-prefetchable one */
++ if (!best)
++ best = r;
+ }
+ return best;
+ }
+diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
+index c8ece44..1e42381 100644
+--- a/drivers/pci/quirks.c
++++ b/drivers/pci/quirks.c
+@@ -2540,6 +2540,16 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, 0x4375,
+
+ #endif /* CONFIG_PCI_MSI */
+
++static void __devinit fixup_ti816x_class(struct pci_dev* dev)
++{
++ /* TI 816x devices do not have class code set when in PCIe boot mode */
++ if (dev->class == PCI_CLASS_NOT_DEFINED) {
++ dev_info(&dev->dev, "Setting PCI class for 816x PCIe device\n");
++ dev->class = PCI_CLASS_MULTIMEDIA_VIDEO;
++ }
++}
++DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_TI, 0xb800, fixup_ti816x_class);
++
+ static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
+ struct pci_fixup *end)
+ {
+diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
+index 47291bc..04830e8 100644
+--- a/drivers/scsi/scsi_scan.c
++++ b/drivers/scsi/scsi_scan.c
+@@ -293,7 +293,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
+ kfree(sdev);
+ goto out;
+ }
+-
++ blk_get_queue(sdev->request_queue);
+ sdev->request_queue->queuedata = sdev;
+ scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+
+@@ -1336,8 +1336,10 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
+ sdev = scsi_alloc_sdev(starget, 0, NULL);
+ if (!sdev)
+ return 0;
+- if (scsi_device_get(sdev))
++ if (scsi_device_get(sdev)) {
++ __scsi_remove_device(sdev);
+ return 0;
++ }
+ }
+
+ sprintf(devname, "host %d channel %d id %d",
+@@ -1904,10 +1906,9 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
+ goto out;
+
+ sdev = scsi_alloc_sdev(starget, 0, NULL);
+- if (sdev) {
+- sdev->sdev_gendev.parent = get_device(&starget->dev);
++ if (sdev)
+ sdev->borken = 0;
+- } else
++ else
+ scsi_target_reap(starget);
+ put_device(&starget->dev);
+ out:
+diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
+index ab6ac95..91a93e0 100644
+--- a/drivers/scsi/scsi_sysfs.c
++++ b/drivers/scsi/scsi_sysfs.c
+@@ -318,6 +318,7 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work)
+ kfree(evt);
+ }
+
++ blk_put_queue(sdev->request_queue);
+ /* NULL queue means the device can't be used */
+ sdev->request_queue = NULL;
+
+@@ -838,7 +839,8 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
+ struct request_queue *rq = sdev->request_queue;
+ struct scsi_target *starget = sdev->sdev_target;
+
+- if ((error = scsi_device_set_state(sdev, SDEV_RUNNING)) != 0)
++ error = scsi_device_set_state(sdev, SDEV_RUNNING);
++ if (error)
+ return error;
+
+ error = scsi_target_add(starget);
+@@ -849,13 +851,13 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
+ error = device_add(&sdev->sdev_gendev);
+ if (error) {
+ printk(KERN_INFO "error 1\n");
+- goto out_remove;
++ return error;
+ }
+ error = device_add(&sdev->sdev_dev);
+ if (error) {
+ printk(KERN_INFO "error 2\n");
+ device_del(&sdev->sdev_gendev);
+- goto out_remove;
++ return error;
+ }
+ transport_add_device(&sdev->sdev_gendev);
+ sdev->is_visible = 1;
+@@ -866,14 +868,14 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
+ else
+ error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
+ if (error)
+- goto out_remove;
++ return error;
+
+ if (sdev->host->hostt->change_queue_type)
+ error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
+ else
+ error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
+ if (error)
+- goto out_remove;
++ return error;
+
+ error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
+
+@@ -889,16 +891,11 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
+ error = device_create_file(&sdev->sdev_gendev,
+ sdev->host->hostt->sdev_attrs[i]);
+ if (error)
+- goto out_remove;
++ return error;
+ }
+ }
+
+- return 0;
+-
+- out_remove:
+- __scsi_remove_device(sdev);
+ return error;
+-
+ }
+
+ void __scsi_remove_device(struct scsi_device *sdev)
+diff --git a/drivers/scsi/ultrastor.c b/drivers/scsi/ultrastor.c
+index 27aa40f..7f0eda2 100644
+--- a/drivers/scsi/ultrastor.c
++++ b/drivers/scsi/ultrastor.c
+@@ -306,7 +306,7 @@ static inline int find_and_clear_bit_16(unsigned long *field)
+ "0: bsfw %1,%w0\n\t"
+ "btr %0,%1\n\t"
+ "jnc 0b"
+- : "=&r" (rv), "=m" (*field) :);
++ : "=&r" (rv), "+m" (*field) :);
+
+ return rv;
+ }
+diff --git a/drivers/staging/usbip/usbip_common.c b/drivers/staging/usbip/usbip_common.c
+index 719e0c1..3c5c62de 100644
+--- a/drivers/staging/usbip/usbip_common.c
++++ b/drivers/staging/usbip/usbip_common.c
+@@ -770,7 +770,7 @@ static void correct_endian_ret_submit(struct usbip_header_ret_submit *pdu,
+ be32_to_cpus(&pdu->status);
+ be32_to_cpus(&pdu->actual_length);
+ be32_to_cpus(&pdu->start_frame);
+- cpu_to_be32s(&pdu->number_of_packets);
++ be32_to_cpus(&pdu->number_of_packets);
+ be32_to_cpus(&pdu->error_count);
+ }
+ }
+diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
+index 4e32da6..2fc5dd3 100644
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -1602,6 +1602,8 @@ static struct usb_device_id acm_ids[] = {
+ { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
+ { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
+ { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
++ { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
++ { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
+ { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
+
+ /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
+diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
+index 283f019..03eed28 100644
+--- a/drivers/usb/core/hub.c
++++ b/drivers/usb/core/hub.c
+@@ -326,7 +326,8 @@ static int get_hub_status(struct usb_device *hdev,
+ {
+ int i, status = -ETIMEDOUT;
+
+- for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
++ for (i = 0; i < USB_STS_RETRIES &&
++ (status == -ETIMEDOUT || status == -EPIPE); i++) {
+ status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
+ USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
+ data, sizeof(*data), USB_STS_TIMEOUT);
+@@ -342,7 +343,8 @@ static int get_port_status(struct usb_device *hdev, int port1,
+ {
+ int i, status = -ETIMEDOUT;
+
+- for (i = 0; i < USB_STS_RETRIES && status == -ETIMEDOUT; i++) {
++ for (i = 0; i < USB_STS_RETRIES &&
++ (status == -ETIMEDOUT || status == -EPIPE); i++) {
+ status = usb_control_msg(hdev, usb_rcvctrlpipe(hdev, 0),
+ USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port1,
+ data, sizeof(*data), USB_STS_TIMEOUT);
+diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
+index 66450a1..e3170ca 100644
+--- a/drivers/usb/gadget/at91_udc.c
++++ b/drivers/usb/gadget/at91_udc.c
+@@ -1687,7 +1687,7 @@ static int __init at91udc_probe(struct platform_device *pdev)
+ }
+
+ /* newer chips have more FIFO memory than rm9200 */
+- if (cpu_is_at91sam9260()) {
++ if (cpu_is_at91sam9260() || cpu_is_at91sam9g20()) {
+ udc->ep[0].maxpacket = 64;
+ udc->ep[3].maxpacket = 64;
+ udc->ep[4].maxpacket = 512;
+diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
+index c9966cc..5201374 100644
+--- a/drivers/usb/gadget/f_rndis.c
++++ b/drivers/usb/gadget/f_rndis.c
+@@ -400,8 +400,7 @@ rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+ */
+ case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+ | USB_CDC_SEND_ENCAPSULATED_COMMAND:
+- if (w_length > req->length || w_value
+- || w_index != rndis->ctrl_id)
++ if (w_value || w_index != rndis->ctrl_id)
+ goto invalid;
+ /* read the request; process it later */
+ value = w_length;
+diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
+index 948a353..67f83e5 100644
+--- a/drivers/usb/host/ohci-pci.c
++++ b/drivers/usb/host/ohci-pci.c
+@@ -207,10 +207,18 @@ static int ohci_quirk_amd700(struct usb_hcd *hcd)
+ */
+ static int ohci_quirk_nvidia_shutdown(struct usb_hcd *hcd)
+ {
++ struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
+ struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+
+- ohci->flags |= OHCI_QUIRK_SHUTDOWN;
+- ohci_dbg(ohci, "enabled nVidia shutdown quirk\n");
++ /* Evidently nVidia fixed their later hardware; this is a guess at
++ * the changeover point.
++ */
++#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB 0x026d
++
++ if (pdev->device < PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_USB) {
++ ohci->flags |= OHCI_QUIRK_SHUTDOWN;
++ ohci_dbg(ohci, "enabled nVidia shutdown quirk\n");
++ }
+
+ return 0;
+ }
+diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
+index 64cb409..fce7b5e 100644
+--- a/drivers/usb/host/xhci-mem.c
++++ b/drivers/usb/host/xhci-mem.c
+@@ -452,9 +452,19 @@ static unsigned int xhci_parse_exponent_interval(struct usb_device *udev,
+ interval = clamp_val(ep->desc.bInterval, 1, 16) - 1;
+ if (interval != ep->desc.bInterval - 1)
+ dev_warn(&udev->dev,
+- "ep %#x - rounding interval to %d microframes\n",
++ "ep %#x - rounding interval to %d %sframes\n",
+ ep->desc.bEndpointAddress,
+- 1 << interval);
++ 1 << interval,
++ udev->speed == USB_SPEED_FULL ? "" : "micro");
++
++ if (udev->speed == USB_SPEED_FULL) {
++ /*
++ * Full speed isoc endpoints specify interval in frames,
++ * not microframes. We are using microframes everywhere,
++ * so adjust accordingly.
++ */
++ interval += 3; /* 1 frame = 2^3 uframes */
++ }
+
+ return interval;
+ }
+@@ -511,12 +521,12 @@ static inline unsigned int xhci_get_endpoint_interval(struct usb_device *udev,
+ break;
+
+ case USB_SPEED_FULL:
+- if (usb_endpoint_xfer_int(&ep->desc)) {
++ if (usb_endpoint_xfer_isoc(&ep->desc)) {
+ interval = xhci_parse_exponent_interval(udev, ep);
+ break;
+ }
+ /*
+- * Fall through for isochronous endpoint interval decoding
++ * Fall through for interrupt endpoint interval decoding
+ * since it uses the same rules as low speed interrupt
+ * endpoints.
+ */
+diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
+index 05afb5c..f77908b 100644
+--- a/drivers/usb/serial/cp210x.c
++++ b/drivers/usb/serial/cp210x.c
+@@ -114,6 +114,10 @@ static struct usb_device_id id_table [] = {
+ { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
+ { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
+ { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
++ { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
++ { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
++ { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
++ { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
+ { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
+ { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
+ { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
+diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
+index 5171f22..afc4bd3 100644
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -570,6 +570,7 @@ static struct usb_device_id id_table_combined [] = {
+ { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
++ { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
+ /*
+ * ELV devices:
+ */
+@@ -650,6 +651,7 @@ static struct usb_device_id id_table_combined [] = {
+ { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
+ { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
+ { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
++ { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
+ { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
+ { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
+ { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
+diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
+index eca754b..40ac7c7 100644
+--- a/drivers/usb/serial/ftdi_sio_ids.h
++++ b/drivers/usb/serial/ftdi_sio_ids.h
+@@ -351,6 +351,7 @@
+ */
+ #define FTDI_4N_GALAXY_DE_1_PID 0xF3C0
+ #define FTDI_4N_GALAXY_DE_2_PID 0xF3C1
++#define FTDI_4N_GALAXY_DE_3_PID 0xF3C2
+
+ /*
+ * Linx Technologies product ids
+@@ -491,6 +492,11 @@
+ /* www.canusb.com Lawicel CANUSB device (FTDI_VID) */
+ #define FTDI_CANUSB_PID 0xFFA8 /* Product Id */
+
++/*
++ * TavIR AVR product ids (FTDI_VID)
++ */
++#define FTDI_TAVIR_STK500_PID 0xFA33 /* STK500 AVR programmer */
++
+
+
+ /********************************/
+diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
+index 5ac900e..867d97b 100644
+--- a/drivers/usb/serial/garmin_gps.c
++++ b/drivers/usb/serial/garmin_gps.c
+@@ -1,7 +1,7 @@
+ /*
+ * Garmin GPS driver
+ *
+- * Copyright (C) 2006-2009 Hermann Kneissel herkne at users.sourceforge.net
++ * Copyright (C) 2006-2011 Hermann Kneissel herkne at gmx.de
+ *
+ * The latest version of the driver can be found at
+ * http://sourceforge.net/projects/garmin-gps/
+@@ -51,7 +51,7 @@ static int debug;
+ */
+
+ #define VERSION_MAJOR 0
+-#define VERSION_MINOR 33
++#define VERSION_MINOR 36
+
+ #define _STR(s) #s
+ #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
+@@ -411,6 +411,7 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
+ */
+ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
+ {
++ unsigned long flags;
+ const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
+ __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
+
+@@ -459,7 +460,9 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
+ /* if this was an abort-transfer command, flush all
+ queued data. */
+ if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
++ spin_lock_irqsave(&garmin_data_p->lock, flags);
+ garmin_data_p->flags |= FLAGS_DROP_DATA;
++ spin_unlock_irqrestore(&garmin_data_p->lock, flags);
+ pkt_clear(garmin_data_p);
+ }
+
+@@ -944,7 +947,7 @@ static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
+ spin_lock_irqsave(&garmin_data_p->lock, flags);
+ garmin_data_p->mode = initial_mode;
+ garmin_data_p->count = 0;
+- garmin_data_p->flags = 0;
++ garmin_data_p->flags &= FLAGS_SESSION_REPLY1_SEEN;
+ spin_unlock_irqrestore(&garmin_data_p->lock, flags);
+
+ /* shutdown any bulk reads that might be going on */
+@@ -1179,7 +1182,8 @@ static int garmin_write_room(struct tty_struct *tty)
+
+
+ static void garmin_read_process(struct garmin_data *garmin_data_p,
+- unsigned char *data, unsigned data_length)
++ unsigned char *data, unsigned data_length,
++ int bulk_data)
+ {
+ unsigned long flags;
+
+@@ -1194,7 +1198,8 @@ static void garmin_read_process(struct garmin_data *garmin_data_p,
+ send it directly to the tty port */
+ if (garmin_data_p->flags & FLAGS_QUEUING) {
+ pkt_add(garmin_data_p, data, data_length);
+- } else if (getLayerId(data) == GARMIN_LAYERID_APPL) {
++ } else if (bulk_data ||
++ getLayerId(data) == GARMIN_LAYERID_APPL) {
+
+ spin_lock_irqsave(&garmin_data_p->lock, flags);
+ garmin_data_p->flags |= APP_RESP_SEEN;
+@@ -1238,7 +1243,7 @@ static void garmin_read_bulk_callback(struct urb *urb)
+ usb_serial_debug_data(debug, &port->dev,
+ __func__, urb->actual_length, data);
+
+- garmin_read_process(garmin_data_p, data, urb->actual_length);
++ garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
+
+ if (urb->actual_length == 0 &&
+ 0 != (garmin_data_p->flags & FLAGS_BULK_IN_RESTART)) {
+@@ -1348,7 +1353,7 @@ static void garmin_read_int_callback(struct urb *urb)
+ __func__, garmin_data_p->serial_num);
+ }
+
+- garmin_read_process(garmin_data_p, data, urb->actual_length);
++ garmin_read_process(garmin_data_p, data, urb->actual_length, 0);
+
+ port->interrupt_in_urb->dev = port->serial->dev;
+ retval = usb_submit_urb(urb, GFP_ATOMIC);
+@@ -1463,6 +1468,7 @@ static int garmin_attach(struct usb_serial *serial)
+ garmin_data_p->timer.function = timeout_handler;
+ garmin_data_p->port = port;
+ garmin_data_p->state = 0;
++ garmin_data_p->flags = 0;
+ garmin_data_p->count = 0;
+ usb_set_serial_port_data(port, garmin_data_p);
+
+diff --git a/drivers/usb/serial/moto_modem.c b/drivers/usb/serial/moto_modem.c
+index 99bd00f5..c53a8a5 100644
+--- a/drivers/usb/serial/moto_modem.c
++++ b/drivers/usb/serial/moto_modem.c
+@@ -25,6 +25,7 @@ static struct usb_device_id id_table [] = {
+ { USB_DEVICE(0x05c6, 0x3197) }, /* unknown Motorola phone */
+ { USB_DEVICE(0x0c44, 0x0022) }, /* unknown Mororola phone */
+ { USB_DEVICE(0x22b8, 0x2a64) }, /* Motorola KRZR K1m */
++ { USB_DEVICE(0x22b8, 0x2c84) }, /* Motorola VE240 phone */
+ { USB_DEVICE(0x22b8, 0x2c64) }, /* Motorola V950 phone */
+ { },
+ };
+diff --git a/drivers/xen/events.c b/drivers/xen/events.c
+index 1417015..009ca4e 100644
+--- a/drivers/xen/events.c
++++ b/drivers/xen/events.c
+@@ -536,7 +536,7 @@ int bind_ipi_to_irqhandler(enum ipi_vector ipi,
+ if (irq < 0)
+ return irq;
+
+- irqflags |= IRQF_NO_SUSPEND;
++ irqflags |= IRQF_NO_SUSPEND | IRQF_FORCE_RESUME;
+ retval = request_irq(irq, handler, irqflags, devname, dev_id);
+ if (retval != 0) {
+ unbind_from_irq(irq);
+@@ -814,9 +814,6 @@ static void restore_cpu_virqs(unsigned int cpu)
+ evtchn_to_irq[evtchn] = irq;
+ irq_info[irq] = mk_virq_info(evtchn, virq);
+ bind_evtchn_to_cpu(evtchn, cpu);
+-
+- /* Ready for use. */
+- unmask_evtchn(evtchn);
+ }
+ }
+
+@@ -842,10 +839,6 @@ static void restore_cpu_ipis(unsigned int cpu)
+ evtchn_to_irq[evtchn] = irq;
+ irq_info[irq] = mk_ipi_info(evtchn, ipi);
+ bind_evtchn_to_cpu(evtchn, cpu);
+-
+- /* Ready for use. */
+- unmask_evtchn(evtchn);
+-
+ }
+ }
+
+diff --git a/fs/block_dev.c b/fs/block_dev.c
+index e65efa2..16cea86 100644
+--- a/fs/block_dev.c
++++ b/fs/block_dev.c
+@@ -1203,6 +1203,7 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
+ if (!bdev->bd_part)
+ goto out_clear;
+
++ ret = 0;
+ if (disk->fops->open) {
+ ret = disk->fops->open(bdev, mode);
+ if (ret == -ERESTARTSYS) {
+@@ -1218,9 +1219,18 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
+ mutex_unlock(&bdev->bd_mutex);
+ goto restart;
+ }
+- if (ret)
+- goto out_clear;
+ }
++ /*
++ * If the device is invalidated, rescan partition
++ * if open succeeded or failed with -ENOMEDIUM.
++ * The latter is necessary to prevent ghost
++ * partitions on a removed medium.
++ */
++ if (bdev->bd_invalidated && (!ret || ret == -ENOMEDIUM))
++ rescan_partitions(disk, bdev);
++ if (ret)
++ goto out_clear;
++
+ if (!bdev->bd_openers) {
+ bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
+ bdi = blk_get_backing_dev_info(bdev);
+@@ -1228,8 +1238,6 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
+ bdi = &default_backing_dev_info;
+ bdev->bd_inode->i_data.backing_dev_info = bdi;
+ }
+- if (bdev->bd_invalidated)
+- rescan_partitions(disk, bdev);
+ } else {
+ struct block_device *whole;
+ whole = bdget_disk(disk, 0);
+@@ -1256,13 +1264,14 @@ static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
+ put_disk(disk);
+ disk = NULL;
+ if (bdev->bd_contains == bdev) {
+- if (bdev->bd_disk->fops->open) {
++ ret = 0;
++ if (bdev->bd_disk->fops->open)
+ ret = bdev->bd_disk->fops->open(bdev, mode);
+- if (ret)
+- goto out_unlock_bdev;
+- }
+- if (bdev->bd_invalidated)
++ /* the same as first opener case, read comment there */
++ if (bdev->bd_invalidated && (!ret || ret == -ENOMEDIUM))
+ rescan_partitions(bdev->bd_disk, bdev);
++ if (ret)
++ goto out_unlock_bdev;
+ }
+ }
+ bdev->bd_openers++;
+diff --git a/fs/dcookies.c b/fs/dcookies.c
+index a21cabd..dda0dc7 100644
+--- a/fs/dcookies.c
++++ b/fs/dcookies.c
+@@ -178,6 +178,8 @@ SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
+ /* FIXME: (deleted) ? */
+ path = d_path(&dcs->path, kbuf, PAGE_SIZE);
+
++ mutex_unlock(&dcookie_mutex);
++
+ if (IS_ERR(path)) {
+ err = PTR_ERR(path);
+ goto out_free;
+@@ -194,6 +196,7 @@ SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
+
+ out_free:
+ kfree(kbuf);
++ return err;
+ out:
+ mutex_unlock(&dcookie_mutex);
+ return err;
+diff --git a/fs/ecryptfs/keystore.c b/fs/ecryptfs/keystore.c
+index aa2480a..8f1a525 100644
+--- a/fs/ecryptfs/keystore.c
++++ b/fs/ecryptfs/keystore.c
+@@ -481,8 +481,8 @@ struct ecryptfs_write_tag_70_packet_silly_stack {
+ struct mutex *tfm_mutex;
+ char *block_aligned_filename;
+ struct ecryptfs_auth_tok *auth_tok;
+- struct scatterlist src_sg;
+- struct scatterlist dst_sg;
++ struct scatterlist src_sg[2];
++ struct scatterlist dst_sg[2];
+ struct blkcipher_desc desc;
+ char iv[ECRYPTFS_MAX_IV_BYTES];
+ char hash[ECRYPTFS_TAG_70_DIGEST_SIZE];
+@@ -695,23 +695,21 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
+ memcpy(&s->block_aligned_filename[s->num_rand_bytes], filename,
+ filename_size);
+ rc = virt_to_scatterlist(s->block_aligned_filename,
+- s->block_aligned_filename_size, &s->src_sg, 1);
+- if (rc != 1) {
++ s->block_aligned_filename_size, s->src_sg, 2);
++ if (rc < 1) {
+ printk(KERN_ERR "%s: Internal error whilst attempting to "
+- "convert filename memory to scatterlist; "
+- "expected rc = 1; got rc = [%d]. "
++ "convert filename memory to scatterlist; rc = [%d]. "
+ "block_aligned_filename_size = [%zd]\n", __func__, rc,
+ s->block_aligned_filename_size);
+ goto out_release_free_unlock;
+ }
+ rc = virt_to_scatterlist(&dest[s->i], s->block_aligned_filename_size,
+- &s->dst_sg, 1);
+- if (rc != 1) {
++ s->dst_sg, 2);
++ if (rc < 1) {
+ printk(KERN_ERR "%s: Internal error whilst attempting to "
+ "convert encrypted filename memory to scatterlist; "
+- "expected rc = 1; got rc = [%d]. "
+- "block_aligned_filename_size = [%zd]\n", __func__, rc,
+- s->block_aligned_filename_size);
++ "rc = [%d]. block_aligned_filename_size = [%zd]\n",
++ __func__, rc, s->block_aligned_filename_size);
+ goto out_release_free_unlock;
+ }
+ /* The characters in the first block effectively do the job
+@@ -734,7 +732,7 @@ ecryptfs_write_tag_70_packet(char *dest, size_t *remaining_bytes,
+ mount_crypt_stat->global_default_fn_cipher_key_bytes);
+ goto out_release_free_unlock;
+ }
+- rc = crypto_blkcipher_encrypt_iv(&s->desc, &s->dst_sg, &s->src_sg,
++ rc = crypto_blkcipher_encrypt_iv(&s->desc, s->dst_sg, s->src_sg,
+ s->block_aligned_filename_size);
+ if (rc) {
+ printk(KERN_ERR "%s: Error attempting to encrypt filename; "
+@@ -766,8 +764,8 @@ struct ecryptfs_parse_tag_70_packet_silly_stack {
+ struct mutex *tfm_mutex;
+ char *decrypted_filename;
+ struct ecryptfs_auth_tok *auth_tok;
+- struct scatterlist src_sg;
+- struct scatterlist dst_sg;
++ struct scatterlist src_sg[2];
++ struct scatterlist dst_sg[2];
+ struct blkcipher_desc desc;
+ char fnek_sig_hex[ECRYPTFS_SIG_SIZE_HEX + 1];
+ char iv[ECRYPTFS_MAX_IV_BYTES];
+@@ -872,13 +870,12 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
+ }
+ mutex_lock(s->tfm_mutex);
+ rc = virt_to_scatterlist(&data[(*packet_size)],
+- s->block_aligned_filename_size, &s->src_sg, 1);
+- if (rc != 1) {
++ s->block_aligned_filename_size, s->src_sg, 2);
++ if (rc < 1) {
+ printk(KERN_ERR "%s: Internal error whilst attempting to "
+ "convert encrypted filename memory to scatterlist; "
+- "expected rc = 1; got rc = [%d]. "
+- "block_aligned_filename_size = [%zd]\n", __func__, rc,
+- s->block_aligned_filename_size);
++ "rc = [%d]. block_aligned_filename_size = [%zd]\n",
++ __func__, rc, s->block_aligned_filename_size);
+ goto out_unlock;
+ }
+ (*packet_size) += s->block_aligned_filename_size;
+@@ -892,13 +889,12 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
+ goto out_unlock;
+ }
+ rc = virt_to_scatterlist(s->decrypted_filename,
+- s->block_aligned_filename_size, &s->dst_sg, 1);
+- if (rc != 1) {
++ s->block_aligned_filename_size, s->dst_sg, 2);
++ if (rc < 1) {
+ printk(KERN_ERR "%s: Internal error whilst attempting to "
+ "convert decrypted filename memory to scatterlist; "
+- "expected rc = 1; got rc = [%d]. "
+- "block_aligned_filename_size = [%zd]\n", __func__, rc,
+- s->block_aligned_filename_size);
++ "rc = [%d]. block_aligned_filename_size = [%zd]\n",
++ __func__, rc, s->block_aligned_filename_size);
+ goto out_free_unlock;
+ }
+ /* The characters in the first block effectively do the job of
+@@ -937,7 +933,7 @@ ecryptfs_parse_tag_70_packet(char **filename, size_t *filename_size,
+ mount_crypt_stat->global_default_fn_cipher_key_bytes);
+ goto out_free_unlock;
+ }
+- rc = crypto_blkcipher_decrypt_iv(&s->desc, &s->dst_sg, &s->src_sg,
++ rc = crypto_blkcipher_decrypt_iv(&s->desc, s->dst_sg, s->src_sg,
+ s->block_aligned_filename_size);
+ if (rc) {
+ printk(KERN_ERR "%s: Error attempting to decrypt filename; "
+diff --git a/fs/exec.c b/fs/exec.c
+index 0cf881d..86fafc6 100644
+--- a/fs/exec.c
++++ b/fs/exec.c
+@@ -1009,6 +1009,7 @@ int flush_old_exec(struct linux_binprm * bprm)
+
+ bprm->mm = NULL; /* We're using it now */
+
++ set_fs(USER_DS);
+ current->flags &= ~PF_RANDOMIZE;
+ flush_thread();
+ current->personality &= ~bprm->per_clear;
+@@ -1276,10 +1277,6 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
+ if (retval)
+ return retval;
+
+- /* kernel module loader fixup */
+- /* so we don't try to load run modprobe in kernel space. */
+- set_fs(USER_DS);
+-
+ retval = audit_bprm(bprm);
+ if (retval)
+ return retval;
+diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
+index a168780..6397b52 100644
+--- a/fs/ext3/namei.c
++++ b/fs/ext3/namei.c
+@@ -1425,10 +1425,19 @@ static int make_indexed_dir(handle_t *handle, struct dentry *dentry,
+ frame->at = entries;
+ frame->bh = bh;
+ bh = bh2;
++ /*
++ * Mark buffers dirty here so that if do_split() fails we write a
++ * consistent set of buffers to disk.
++ */
++ ext3_journal_dirty_metadata(handle, frame->bh);
++ ext3_journal_dirty_metadata(handle, bh);
+ de = do_split(handle,dir, &bh, frame, &hinfo, &retval);
+- dx_release (frames);
+- if (!(de))
++ if (!de) {
++ ext3_mark_inode_dirty(handle, dir);
++ dx_release(frames);
+ return retval;
++ }
++ dx_release(frames);
+
+ return add_dirent_to_buf(handle, dentry, inode, de, bh);
+ }
+diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
+index 04e07e2..42bac1b 100644
+--- a/fs/ext4/mballoc.c
++++ b/fs/ext4/mballoc.c
+@@ -1173,6 +1173,8 @@ repeat_load_buddy:
+ return 0;
+
+ err:
++ if (page)
++ page_cache_release(page);
+ if (e4b->bd_bitmap_page)
+ page_cache_release(e4b->bd_bitmap_page);
+ if (e4b->bd_buddy_page)
+diff --git a/fs/fat/file.c b/fs/fat/file.c
+index e8c159d..279937b 100644
+--- a/fs/fat/file.c
++++ b/fs/fat/file.c
+@@ -101,7 +101,7 @@ static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
+ if (attr & ATTR_SYS)
+ inode->i_flags |= S_IMMUTABLE;
+ else
+- inode->i_flags &= S_IMMUTABLE;
++ inode->i_flags &= ~S_IMMUTABLE;
+ }
+
+ fat_save_attrs(inode, attr);
+diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
+index 4bd8825..17d29a8 100644
+--- a/fs/jbd/commit.c
++++ b/fs/jbd/commit.c
+@@ -746,8 +746,13 @@ wait_for_iobuf:
+ required. */
+ JBUFFER_TRACE(jh, "file as BJ_Forget");
+ journal_file_buffer(jh, commit_transaction, BJ_Forget);
+- /* Wake up any transactions which were waiting for this
+- IO to complete */
++ /*
++ * Wake up any transactions which were waiting for this
++ * IO to complete. The barrier must be here so that changes
++ * by journal_file_buffer() take effect before wake_up_bit()
++ * does the waitqueue check.
++ */
++ smp_mb();
+ wake_up_bit(&bh->b_state, BH_Unshadow);
+ JBUFFER_TRACE(jh, "brelse shadowed buffer");
+ __brelse(bh);
+diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
+index bd224ee..45905ff 100644
+--- a/fs/jbd/journal.c
++++ b/fs/jbd/journal.c
+@@ -435,9 +435,12 @@ int __log_space_left(journal_t *journal)
+ int __log_start_commit(journal_t *journal, tid_t target)
+ {
+ /*
+- * Are we already doing a recent enough commit?
++ * The only transaction we can possibly wait upon is the
++ * currently running transaction (if it exists). Otherwise,
++ * the target tid must be an old one.
+ */
+- if (!tid_geq(journal->j_commit_request, target)) {
++ if (journal->j_running_transaction &&
++ journal->j_running_transaction->t_tid == target) {
+ /*
+ * We want a new commit: OK, mark the request and wakup the
+ * commit thread. We do _not_ do the commit ourselves.
+@@ -449,7 +452,14 @@ int __log_start_commit(journal_t *journal, tid_t target)
+ journal->j_commit_sequence);
+ wake_up(&journal->j_wait_commit);
+ return 1;
+- }
++ } else if (!tid_geq(journal->j_commit_request, target))
++ /* This should never happen, but if it does, preserve
++ the evidence before kjournald goes into a loop and
++ increments j_commit_sequence beyond all recognition. */
++ WARN_ONCE(1, "jbd: bad log_start_commit: %u %u %u %u\n",
++ journal->j_commit_request, journal->j_commit_sequence,
++ target, journal->j_running_transaction ?
++ journal->j_running_transaction->t_tid : 0);
+ return 0;
+ }
+
+diff --git a/fs/partitions/ldm.c b/fs/partitions/ldm.c
+index a2a14cd..dd6efdb 100644
+--- a/fs/partitions/ldm.c
++++ b/fs/partitions/ldm.c
+@@ -1335,6 +1335,11 @@ static bool ldm_frag_add (const u8 *data, int size, struct list_head *frags)
+
+ list_add_tail (&f->list, frags);
+ found:
++ if (rec >= f->num) {
++ ldm_error("REC value (%d) exceeds NUM value (%d)", rec, f->num);
++ return false;
++ }
++
+ if (f->map & (1 << rec)) {
+ ldm_error ("Duplicate VBLK, part %d.", rec);
+ f->map &= 0x7F; /* Mark the group as broken */
+diff --git a/fs/ubifs/journal.c b/fs/ubifs/journal.c
+index d321bae..841f77c 100644
+--- a/fs/ubifs/journal.c
++++ b/fs/ubifs/journal.c
+@@ -665,6 +665,7 @@ out_free:
+
+ out_release:
+ release_head(c, BASEHD);
++ kfree(dent);
+ out_ro:
+ ubifs_ro_mode(c, err);
+ if (last_reference)
+diff --git a/fs/ubifs/sb.c b/fs/ubifs/sb.c
+index 57085e4..238ad15 100644
+--- a/fs/ubifs/sb.c
++++ b/fs/ubifs/sb.c
+@@ -474,7 +474,8 @@ failed:
+ * @c: UBIFS file-system description object
+ *
+ * This function returns a pointer to the superblock node or a negative error
+- * code.
++ * code. Note, the user of this function is responsible of kfree()'ing the
++ * returned superblock buffer.
+ */
+ struct ubifs_sb_node *ubifs_read_sb_node(struct ubifs_info *c)
+ {
+diff --git a/fs/ubifs/shrinker.c b/fs/ubifs/shrinker.c
+index 02feb59..aec6689 100644
+--- a/fs/ubifs/shrinker.c
++++ b/fs/ubifs/shrinker.c
+@@ -283,7 +283,11 @@ int ubifs_shrinker(int nr, gfp_t gfp_mask)
+ long clean_zn_cnt = atomic_long_read(&ubifs_clean_zn_cnt);
+
+ if (nr == 0)
+- return clean_zn_cnt;
++ /*
++ * Due to the way UBIFS updates the clean znode counter it may
++ * temporarily be negative.
++ */
++ return clean_zn_cnt >= 0 ? clean_zn_cnt : 1;
+
+ if (!clean_zn_cnt) {
+ /*
+diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
+index 333e181..8440ba8 100644
+--- a/fs/ubifs/super.c
++++ b/fs/ubifs/super.c
+@@ -1550,6 +1550,7 @@ static int ubifs_remount_rw(struct ubifs_info *c)
+ }
+ sup->leb_cnt = cpu_to_le32(c->leb_cnt);
+ err = ubifs_write_sb_node(c, sup);
++ kfree(sup);
+ if (err)
+ goto out;
+ }
+diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
+index c82683a..71c14dd 100644
+--- a/fs/xfs/linux-2.6/xfs_sync.c
++++ b/fs/xfs/linux-2.6/xfs_sync.c
+@@ -711,16 +711,24 @@ xfs_inode_set_reclaim_tag(
+ }
+
+ void
+-__xfs_inode_clear_reclaim_tag(
+- xfs_mount_t *mp,
++__xfs_inode_clear_reclaim(
+ xfs_perag_t *pag,
+ xfs_inode_t *ip)
+ {
+- radix_tree_tag_clear(&pag->pag_ici_root,
+- XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
+ pag->pag_ici_reclaimable--;
+ }
+
++void
++__xfs_inode_clear_reclaim_tag(
++ xfs_mount_t *mp,
++ xfs_perag_t *pag,
++ xfs_inode_t *ip)
++{
++ radix_tree_tag_clear(&pag->pag_ici_root,
++ XFS_INO_TO_AGINO(mp, ip->i_ino), XFS_ICI_RECLAIM_TAG);
++ __xfs_inode_clear_reclaim(pag, ip);
++}
++
+ STATIC int
+ xfs_reclaim_inode(
+ struct xfs_inode *ip,
+diff --git a/fs/xfs/linux-2.6/xfs_sync.h b/fs/xfs/linux-2.6/xfs_sync.h
+index 0b28c13..81dd3bc 100644
+--- a/fs/xfs/linux-2.6/xfs_sync.h
++++ b/fs/xfs/linux-2.6/xfs_sync.h
+@@ -48,6 +48,7 @@ int xfs_reclaim_inodes(struct xfs_mount *mp, int mode);
+
+ void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
+ void __xfs_inode_set_reclaim_tag(struct xfs_perag *pag, struct xfs_inode *ip);
++void __xfs_inode_clear_reclaim(struct xfs_perag *pag, struct xfs_inode *ip);
+ void __xfs_inode_clear_reclaim_tag(struct xfs_mount *mp, struct xfs_perag *pag,
+ struct xfs_inode *ip);
+
+diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
+index 16b6a33..320b79d 100644
+--- a/fs/xfs/xfs_iget.c
++++ b/fs/xfs/xfs_iget.c
+@@ -529,6 +529,7 @@ xfs_ireclaim(
+ write_lock(&pag->pag_ici_lock);
+ if (!radix_tree_delete(&pag->pag_ici_root, agino))
+ ASSERT(0);
++ __xfs_inode_clear_reclaim(pag, ip);
+ write_unlock(&pag->pag_ici_lock);
+ xfs_put_perag(mp, pag);
+
+diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
+index c49d6f5..4528f29 100644
+--- a/include/linux/interrupt.h
++++ b/include/linux/interrupt.h
+@@ -53,7 +53,7 @@
+ * Used by threaded interrupts which need to keep the
+ * irq line disabled until the threaded handler has been run.
+ * IRQF_NO_SUSPEND - Do not disable this IRQ during suspend
+- *
++ * IRQF_FORCE_RESUME - Force enable it on resume even if IRQF_NO_SUSPEND is set
+ */
+ #define IRQF_DISABLED 0x00000020
+ #define IRQF_SAMPLE_RANDOM 0x00000040
+@@ -65,6 +65,7 @@
+ #define IRQF_IRQPOLL 0x00001000
+ #define IRQF_ONESHOT 0x00002000
+ #define IRQF_NO_SUSPEND 0x00004000
++#define IRQF_FORCE_RESUME 0x00008000
+
+ #define IRQF_TIMER (__IRQF_TIMER | IRQF_NO_SUSPEND)
+
+diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
+index fe2f4ee..a339386 100644
+--- a/include/linux/pci_ids.h
++++ b/include/linux/pci_ids.h
+@@ -605,6 +605,8 @@
+ #define PCI_DEVICE_ID_MATROX_G550 0x2527
+ #define PCI_DEVICE_ID_MATROX_VIA 0x4536
+
++#define PCI_VENDOR_ID_MOBILITY_ELECTRONICS 0x14f2
++
+ #define PCI_VENDOR_ID_CT 0x102c
+ #define PCI_DEVICE_ID_CT_69000 0x00c0
+ #define PCI_DEVICE_ID_CT_65545 0x00d8
+diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
+index 632205c..4c3257d 100644
+--- a/include/linux/seqlock.h
++++ b/include/linux/seqlock.h
+@@ -88,12 +88,12 @@ static __always_inline unsigned read_seqbegin(const seqlock_t *sl)
+ unsigned ret;
+
+ repeat:
+- ret = sl->sequence;
+- smp_rmb();
++ ret = ACCESS_ONCE(sl->sequence);
+ if (unlikely(ret & 1)) {
+ cpu_relax();
+ goto repeat;
+ }
++ smp_rmb();
+
+ return ret;
+ }
+diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
+index 5fad88b..d40ecd5 100644
+--- a/kernel/irq/manage.c
++++ b/kernel/irq/manage.c
+@@ -265,8 +265,17 @@ EXPORT_SYMBOL(disable_irq);
+
+ void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
+ {
+- if (resume)
++ if (resume) {
++ if (!(desc->status & IRQ_SUSPENDED)) {
++ if (!desc->action)
++ return;
++ if (!(desc->action->flags & IRQF_FORCE_RESUME))
++ return;
++ /* Pretend that it got disabled ! */
++ desc->depth++;
++ }
+ desc->status &= ~IRQ_SUSPENDED;
++ }
+
+ switch (desc->depth) {
+ case 0:
+diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
+index a0bb09e..0067abb 100644
+--- a/kernel/irq/pm.c
++++ b/kernel/irq/pm.c
+@@ -53,9 +53,6 @@ void resume_device_irqs(void)
+ for_each_irq_desc(irq, desc) {
+ unsigned long flags;
+
+- if (!(desc->status & IRQ_SUSPENDED))
+- continue;
+-
+ spin_lock_irqsave(&desc->lock, flags);
+ __enable_irq(desc, irq, true);
+ spin_unlock_irqrestore(&desc->lock, flags);
+diff --git a/kernel/lockdep.c b/kernel/lockdep.c
+index 9af5672..d86fe89 100644
+--- a/kernel/lockdep.c
++++ b/kernel/lockdep.c
+@@ -3243,7 +3243,7 @@ int lock_is_held(struct lockdep_map *lock)
+ int ret = 0;
+
+ if (unlikely(current->lockdep_recursion))
+- return ret;
++ return 1; /* avoid false negative lockdep_assert_held() */
+
+ raw_local_irq_save(flags);
+ check_flags(flags);
+diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
+index f5e362f..1d1206a 100644
+--- a/kernel/time/timekeeping.c
++++ b/kernel/time/timekeeping.c
+@@ -32,6 +32,8 @@ struct timekeeper {
+ cycle_t cycle_interval;
+ /* Number of clock shifted nano seconds in one NTP interval. */
+ u64 xtime_interval;
++ /* shifted nano seconds left over when rounding cycle_interval */
++ s64 xtime_remainder;
+ /* Raw nano seconds accumulated per NTP interval. */
+ u32 raw_interval;
+
+@@ -62,7 +64,7 @@ struct timekeeper timekeeper;
+ static void timekeeper_setup_internals(struct clocksource *clock)
+ {
+ cycle_t interval;
+- u64 tmp;
++ u64 tmp, ntpinterval;
+
+ timekeeper.clock = clock;
+ clock->cycle_last = clock->read(clock);
+@@ -70,6 +72,7 @@ static void timekeeper_setup_internals(struct clocksource *clock)
+ /* Do the ns -> cycle conversion first, using original mult */
+ tmp = NTP_INTERVAL_LENGTH;
+ tmp <<= clock->shift;
++ ntpinterval = tmp;
+ tmp += clock->mult/2;
+ do_div(tmp, clock->mult);
+ if (tmp == 0)
+@@ -80,6 +83,7 @@ static void timekeeper_setup_internals(struct clocksource *clock)
+
+ /* Go back from cycles -> shifted ns */
+ timekeeper.xtime_interval = (u64) interval * clock->mult;
++ timekeeper.xtime_remainder = ntpinterval - timekeeper.xtime_interval;
+ timekeeper.raw_interval =
+ ((u64) interval * clock->mult) >> clock->shift;
+
+@@ -788,7 +792,8 @@ void update_wall_time(void)
+
+ /* accumulate error between NTP and clock interval */
+ timekeeper.ntp_error += tick_length;
+- timekeeper.ntp_error -= timekeeper.xtime_interval <<
++ timekeeper.ntp_error -=
++ (timekeeper.xtime_interval + timekeeper.xtime_remainder) <<
+ timekeeper.ntp_error_shift;
+ }
+
+diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
+index 0afddc2..4872937 100644
+--- a/kernel/trace/ftrace.c
++++ b/kernel/trace/ftrace.c
+@@ -2360,14 +2360,16 @@ ftrace_regex_release(struct inode *inode, struct file *file, int enable)
+ ftrace_match_records(parser->buffer, parser->idx, enable);
+ }
+
+- mutex_lock(&ftrace_lock);
+- if (ftrace_start_up && ftrace_enabled)
+- ftrace_run_update_code(FTRACE_ENABLE_CALLS);
+- mutex_unlock(&ftrace_lock);
+-
+ trace_parser_put(parser);
+ kfree(iter);
+
++ if (file->f_mode & FMODE_WRITE) {
++ mutex_lock(&ftrace_lock);
++ if (ftrace_start_up && ftrace_enabled)
++ ftrace_run_update_code(FTRACE_ENABLE_CALLS);
++ mutex_unlock(&ftrace_lock);
++ }
++
+ mutex_unlock(&ftrace_regex_lock);
+ return 0;
+ }
+diff --git a/lib/locking-selftest.c b/lib/locking-selftest.c
+index 619313e..507a22f 100644
+--- a/lib/locking-selftest.c
++++ b/lib/locking-selftest.c
+@@ -144,7 +144,7 @@ static void init_shared_classes(void)
+
+ #define HARDIRQ_ENTER() \
+ local_irq_disable(); \
+- irq_enter(); \
++ __irq_enter(); \
+ WARN_ON(!in_irq());
+
+ #define HARDIRQ_EXIT() \
+diff --git a/mm/hugetlb.c b/mm/hugetlb.c
+index f5a106e..0cf9863 100644
+--- a/mm/hugetlb.c
++++ b/mm/hugetlb.c
+@@ -995,10 +995,10 @@ static struct page *alloc_huge_page(struct vm_area_struct *vma,
+ */
+ chg = vma_needs_reservation(h, vma, addr);
+ if (chg < 0)
+- return ERR_PTR(chg);
++ return ERR_PTR(-VM_FAULT_OOM);
+ if (chg)
+ if (hugetlb_get_quota(inode->i_mapping, chg))
+- return ERR_PTR(-ENOSPC);
++ return ERR_PTR(-VM_FAULT_SIGBUS);
+
+ spin_lock(&hugetlb_lock);
+ page = dequeue_huge_page_vma(h, vma, addr, avoid_reserve);
+diff --git a/mm/kmemleak.c b/mm/kmemleak.c
+index 8bf765c..c346660 100644
+--- a/mm/kmemleak.c
++++ b/mm/kmemleak.c
+@@ -1354,9 +1354,12 @@ static void *kmemleak_seq_next(struct seq_file *seq, void *v, loff_t *pos)
+ ++(*pos);
+
+ list_for_each_continue_rcu(n, &object_list) {
+- next_obj = list_entry(n, struct kmemleak_object, object_list);
+- if (get_object(next_obj))
++ struct kmemleak_object *obj =
++ list_entry(n, struct kmemleak_object, object_list);
++ if (get_object(obj)) {
++ next_obj = obj;
+ break;
++ }
+ }
+
+ put_object(prev_obj);
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index 902e5fc..3ecab7e 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -1841,6 +1841,7 @@ restart:
+ */
+ alloc_flags = gfp_to_alloc_flags(gfp_mask);
+
++rebalance:
+ /* This is the last chance, in general, before the goto nopage. */
+ page = get_page_from_freelist(gfp_mask, nodemask, order, zonelist,
+ high_zoneidx, alloc_flags & ~ALLOC_NO_WATERMARKS,
+@@ -1848,7 +1849,6 @@ restart:
+ if (page)
+ goto got_pg;
+
+-rebalance:
+ /* Allocate without watermarks if the context allows */
+ if (alloc_flags & ALLOC_NO_WATERMARKS) {
+ page = __alloc_pages_high_priority(gfp_mask, order,
+diff --git a/net/atm/atm_sysfs.c b/net/atm/atm_sysfs.c
+index b5674dc..7bbe81e 100644
+--- a/net/atm/atm_sysfs.c
++++ b/net/atm/atm_sysfs.c
+@@ -57,6 +57,14 @@ static ssize_t show_atmaddress(struct device *cdev,
+ return pos - buf;
+ }
+
++static ssize_t show_atmindex(struct device *cdev,
++ struct device_attribute *attr, char *buf)
++{
++ struct atm_dev *adev = to_atm_dev(cdev);
++
++ return sprintf(buf, "%d\n", adev->number);
++}
++
+ static ssize_t show_carrier(struct device *cdev,
+ struct device_attribute *attr, char *buf)
+ {
+@@ -97,6 +105,7 @@ static ssize_t show_link_rate(struct device *cdev,
+
+ static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
+ static DEVICE_ATTR(atmaddress, S_IRUGO, show_atmaddress, NULL);
++static DEVICE_ATTR(atmindex, S_IRUGO, show_atmindex, NULL);
+ static DEVICE_ATTR(carrier, S_IRUGO, show_carrier, NULL);
+ static DEVICE_ATTR(type, S_IRUGO, show_type, NULL);
+ static DEVICE_ATTR(link_rate, S_IRUGO, show_link_rate, NULL);
+@@ -104,6 +113,7 @@ static DEVICE_ATTR(link_rate, S_IRUGO, show_link_rate, NULL);
+ static struct device_attribute *atm_attrs[] = {
+ &dev_attr_atmaddress,
+ &dev_attr_address,
++ &dev_attr_atmindex,
+ &dev_attr_carrier,
+ &dev_attr_type,
+ &dev_attr_link_rate,
+diff --git a/net/ipv6/netfilter/ip6t_REJECT.c b/net/ipv6/netfilter/ip6t_REJECT.c
+index 1264ad0..58679f8 100644
+--- a/net/ipv6/netfilter/ip6t_REJECT.c
++++ b/net/ipv6/netfilter/ip6t_REJECT.c
+@@ -43,6 +43,8 @@ static void send_reset(struct net *net, struct sk_buff *oldskb)
+ int tcphoff, needs_ack;
+ const struct ipv6hdr *oip6h = ipv6_hdr(oldskb);
+ struct ipv6hdr *ip6h;
++#define DEFAULT_TOS_VALUE 0x0U
++ const __u8 tclass = DEFAULT_TOS_VALUE;
+ struct dst_entry *dst = NULL;
+ u8 proto;
+ struct flowi fl;
+@@ -121,7 +123,7 @@ static void send_reset(struct net *net, struct sk_buff *oldskb)
+ skb_put(nskb, sizeof(struct ipv6hdr));
+ skb_reset_network_header(nskb);
+ ip6h = ipv6_hdr(nskb);
+- ip6h->version = 6;
++ *(__be32 *)ip6h = htonl(0x60000000 | (tclass << 20));
+ ip6h->hop_limit = dst_metric(dst, RTAX_HOPLIMIT);
+ ip6h->nexthdr = IPPROTO_TCP;
+ ipv6_addr_copy(&ip6h->saddr, &oip6h->daddr);
+diff --git a/net/ipv6/netfilter/nf_conntrack_reasm.c b/net/ipv6/netfilter/nf_conntrack_reasm.c
+index bfc8737..e5590a9 100644
+--- a/net/ipv6/netfilter/nf_conntrack_reasm.c
++++ b/net/ipv6/netfilter/nf_conntrack_reasm.c
+@@ -474,7 +474,7 @@ nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev)
+
+ /* all original skbs are linked into the NFCT_FRAG6_CB(head).orig */
+ fp = skb_shinfo(head)->frag_list;
+- if (NFCT_FRAG6_CB(fp)->orig == NULL)
++ if (fp && NFCT_FRAG6_CB(fp)->orig == NULL)
+ /* at above code, head skb is divided into two skbs. */
+ fp = fp->next;
+
+@@ -600,12 +600,6 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb, u32 user)
+ hdr = ipv6_hdr(clone);
+ fhdr = (struct frag_hdr *)skb_transport_header(clone);
+
+- if (!(fhdr->frag_off & htons(0xFFF9))) {
+- pr_debug("Invalid fragment offset\n");
+- /* It is not a fragmented frame */
+- goto ret_orig;
+- }
+-
+ if (atomic_read(&nf_init_frags.mem) > nf_init_frags.high_thresh)
+ nf_ct_frag6_evictor();
+
+diff --git a/net/netfilter/xt_DSCP.c b/net/netfilter/xt_DSCP.c
+index 74ce892..5ec6374 100644
+--- a/net/netfilter/xt_DSCP.c
++++ b/net/netfilter/xt_DSCP.c
+@@ -99,7 +99,7 @@ tos_tg6(struct sk_buff *skb, const struct xt_target_param *par)
+ u_int8_t orig, nv;
+
+ orig = ipv6_get_dsfield(iph);
+- nv = (orig & info->tos_mask) ^ info->tos_value;
++ nv = (orig & ~info->tos_mask) ^ info->tos_value;
+
+ if (orig != nv) {
+ if (!skb_make_writable(skb, sizeof(struct iphdr)))
+diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
+index 1d61c33..79194ad 100644
+--- a/net/sunrpc/xprtsock.c
++++ b/net/sunrpc/xprtsock.c
+@@ -1381,7 +1381,6 @@ static void xs_tcp_state_change(struct sock *sk)
+ case TCP_CLOSE_WAIT:
+ /* The server initiated a shutdown of the socket */
+ xprt_force_disconnect(xprt);
+- case TCP_SYN_SENT:
+ xprt->connect_cookie++;
+ case TCP_CLOSING:
+ /*
+@@ -1843,6 +1842,7 @@ static void xs_tcp_reuse_connection(struct rpc_xprt *xprt, struct sock_xprt *tra
+ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
+ {
+ struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
++ int ret = -ENOTCONN;
+
+ if (!transport->inet) {
+ struct sock *sk = sock->sk;
+@@ -1874,12 +1874,22 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock)
+ }
+
+ if (!xprt_bound(xprt))
+- return -ENOTCONN;
++ goto out;
+
+ /* Tell the socket layer to start connecting... */
+ xprt->stat.connect_count++;
+ xprt->stat.connect_start = jiffies;
+- return kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
++ ret = kernel_connect(sock, xs_addr(xprt), xprt->addrlen, O_NONBLOCK);
++ switch (ret) {
++ case 0:
++ case -EINPROGRESS:
++ /* SYN_SENT! */
++ xprt->connect_cookie++;
++ if (xprt->reestablish_timeout < XS_TCP_INIT_REEST_TO)
++ xprt->reestablish_timeout = XS_TCP_INIT_REEST_TO;
++ }
++out:
++ return ret;
+ }
+
+ /**
+diff --git a/net/wireless/nl80211.c b/net/wireless/nl80211.c
+index b75e718..f0341e4 100644
+--- a/net/wireless/nl80211.c
++++ b/net/wireless/nl80211.c
+@@ -2995,12 +2995,12 @@ static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
+ i = 0;
+ if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
+ nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
++ request->ssids[i].ssid_len = nla_len(attr);
+ if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
+ err = -EINVAL;
+ goto out_free;
+ }
+ memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
+- request->ssids[i].ssid_len = nla_len(attr);
+ i++;
+ }
+ }
+diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
+index ed550e4..083b777 100644
+--- a/sound/pci/hda/patch_realtek.c
++++ b/sound/pci/hda/patch_realtek.c
+@@ -12662,6 +12662,7 @@ static struct snd_pci_quirk alc268_cfg_tbl[] = {
+ SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
+ ALC268_ACER_ASPIRE_ONE),
+ SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
++ SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron 910", ALC268_AUTO),
+ SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
+ "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
+ /* almost compatible with toshiba but with optional digital outs;
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index 7e59c34..01da10b 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -1600,7 +1600,7 @@ static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
+ SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
+ "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
+ SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
+- "Dell Studio 1558", STAC_DELL_M6_BOTH),
++ "Dell Studio 1558", STAC_DELL_M6_DMIC),
+ {} /* terminator */
+ };
+
+diff --git a/sound/soc/codecs/wm_hubs.c b/sound/soc/codecs/wm_hubs.c
+index a80f1ad..12506dc 100644
+--- a/sound/soc/codecs/wm_hubs.c
++++ b/sound/soc/codecs/wm_hubs.c
+@@ -639,17 +639,17 @@ static const struct snd_soc_dapm_route analogue_routes[] = {
+ static const struct snd_soc_dapm_route lineout1_diff_routes[] = {
+ { "LINEOUT1 Mixer", "IN1L Switch", "IN1L PGA" },
+ { "LINEOUT1 Mixer", "IN1R Switch", "IN1R PGA" },
+- { "LINEOUT1 Mixer", "Output Switch", "Left Output Mixer" },
++ { "LINEOUT1 Mixer", "Output Switch", "Left Output PGA" },
+
+ { "LINEOUT1N Driver", NULL, "LINEOUT1 Mixer" },
+ { "LINEOUT1P Driver", NULL, "LINEOUT1 Mixer" },
+ };
+
+ static const struct snd_soc_dapm_route lineout1_se_routes[] = {
+- { "LINEOUT1N Mixer", "Left Output Switch", "Left Output Mixer" },
+- { "LINEOUT1N Mixer", "Right Output Switch", "Left Output Mixer" },
++ { "LINEOUT1N Mixer", "Left Output Switch", "Left Output PGA" },
++ { "LINEOUT1N Mixer", "Right Output Switch", "Right Output PGA" },
+
+- { "LINEOUT1P Mixer", "Left Output Switch", "Left Output Mixer" },
++ { "LINEOUT1P Mixer", "Left Output Switch", "Left Output PGA" },
+
+ { "LINEOUT1N Driver", NULL, "LINEOUT1N Mixer" },
+ { "LINEOUT1P Driver", NULL, "LINEOUT1P Mixer" },
+@@ -658,17 +658,17 @@ static const struct snd_soc_dapm_route lineout1_se_routes[] = {
+ static const struct snd_soc_dapm_route lineout2_diff_routes[] = {
+ { "LINEOUT2 Mixer", "IN2L Switch", "IN2L PGA" },
+ { "LINEOUT2 Mixer", "IN2R Switch", "IN2R PGA" },
+- { "LINEOUT2 Mixer", "Output Switch", "Right Output Mixer" },
++ { "LINEOUT2 Mixer", "Output Switch", "Right Output PGA" },
+
+ { "LINEOUT2N Driver", NULL, "LINEOUT2 Mixer" },
+ { "LINEOUT2P Driver", NULL, "LINEOUT2 Mixer" },
+ };
+
+ static const struct snd_soc_dapm_route lineout2_se_routes[] = {
+- { "LINEOUT2N Mixer", "Left Output Switch", "Left Output Mixer" },
+- { "LINEOUT2N Mixer", "Right Output Switch", "Left Output Mixer" },
++ { "LINEOUT2N Mixer", "Left Output Switch", "Left Output PGA" },
++ { "LINEOUT2N Mixer", "Right Output Switch", "Right Output PGA" },
+
+- { "LINEOUT2P Mixer", "Right Output Switch", "Right Output Mixer" },
++ { "LINEOUT2P Mixer", "Right Output Switch", "Right Output PGA" },
+
+ { "LINEOUT2N Driver", NULL, "LINEOUT2N Mixer" },
+ { "LINEOUT2P Driver", NULL, "LINEOUT2P Mixer" },
+@@ -686,17 +686,21 @@ int wm_hubs_add_analogue_controls(struct snd_soc_codec *codec)
+ snd_soc_update_bits(codec, WM8993_RIGHT_LINE_INPUT_3_4_VOLUME,
+ WM8993_IN2_VU, WM8993_IN2_VU);
+
++ snd_soc_update_bits(codec, WM8993_SPEAKER_VOLUME_LEFT,
++ WM8993_SPKOUT_VU, WM8993_SPKOUT_VU);
+ snd_soc_update_bits(codec, WM8993_SPEAKER_VOLUME_RIGHT,
+ WM8993_SPKOUT_VU, WM8993_SPKOUT_VU);
+
+ snd_soc_update_bits(codec, WM8993_LEFT_OUTPUT_VOLUME,
+- WM8993_HPOUT1L_ZC, WM8993_HPOUT1L_ZC);
++ WM8993_HPOUT1_VU | WM8993_HPOUT1L_ZC,
++ WM8993_HPOUT1_VU | WM8993_HPOUT1L_ZC);
+ snd_soc_update_bits(codec, WM8993_RIGHT_OUTPUT_VOLUME,
+ WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC,
+ WM8993_HPOUT1_VU | WM8993_HPOUT1R_ZC);
+
+ snd_soc_update_bits(codec, WM8993_LEFT_OPGA_VOLUME,
+- WM8993_MIXOUTL_ZC, WM8993_MIXOUTL_ZC);
++ WM8993_MIXOUTL_ZC | WM8993_MIXOUT_VU,
++ WM8993_MIXOUTL_ZC | WM8993_MIXOUT_VU);
+ snd_soc_update_bits(codec, WM8993_RIGHT_OPGA_VOLUME,
+ WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU,
+ WM8993_MIXOUTR_ZC | WM8993_MIXOUT_VU);
Modified: dists/squeeze/linux-2.6/debian/patches/features/all/openvz/openvz.patch
==============================================================================
--- dists/squeeze/linux-2.6/debian/patches/features/all/openvz/openvz.patch Fri Jul 8 01:14:25 2011 (r17821)
+++ dists/squeeze/linux-2.6/debian/patches/features/all/openvz/openvz.patch Fri Jul 8 04:32:21 2011 (r17822)
@@ -6535,6 +6535,8 @@
[bwh: Fix conflict with bugfix/all/af_unix-limit-recursion-level.patch]
[bwh: Fix conflict with change to xs_reset_transport() in 2.6.32.36]
+[bwh: Fix context for changes to flush_old_exec() and nf_ct_frag6_gather()
+ after 2.6.32.42]
diff --git a/COPYING.Parallels b/COPYING.Parallels
new file mode 100644
@@ -16887,9 +16889,9 @@
- bprm->mm = NULL; /* We're using it now */
-
+ set_fs(USER_DS);
current->flags &= ~PF_RANDOMIZE;
flush_thread();
- current->personality &= ~bprm->per_clear;
@@ -1334,6 +1364,10 @@ int do_execve(char * filename,
bool clear_in_exec;
int retval;
@@ -87498,8 +87500,8 @@
struct sk_buff *clone;
struct net_device *dev = skb->dev;
@@ -606,10 +609,11 @@ struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb, u32 user)
- goto ret_orig;
- }
+ hdr = ipv6_hdr(clone);
+ fhdr = (struct frag_hdr *)skb_transport_header(clone);
- if (atomic_read(&nf_init_frags.mem) > nf_init_frags.high_thresh)
- nf_ct_frag6_evictor();
Modified: dists/squeeze/linux-2.6/debian/patches/features/all/xen/pvops.patch
==============================================================================
--- dists/squeeze/linux-2.6/debian/patches/features/all/xen/pvops.patch Fri Jul 8 01:14:25 2011 (r17821)
+++ dists/squeeze/linux-2.6/debian/patches/features/all/xen/pvops.patch Fri Jul 8 04:32:21 2011 (r17822)
@@ -16,6 +16,7 @@
$ git diff debian-base..debian-pvops
[bwh: Fix context in arch/x86/xen/mmu.c following 2.6.32.36]
+[bwh: Drop redundant changes to block/blk-core.c following 2.6.32.42]
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 9ec8558..3e30e60 100644
@@ -5477,26 +5478,6 @@
+extern int xen_panic_handler_init(void);
+
#endif /* XEN_OPS_H */
-diff --git a/block/blk-core.c b/block/blk-core.c
-index 71da511..32d305c 100644
---- a/block/blk-core.c
-+++ b/block/blk-core.c
-@@ -439,6 +439,7 @@ void blk_put_queue(struct request_queue *q)
- {
- kobject_put(&q->kobj);
- }
-+EXPORT_SYMBOL_GPL(blk_put_queue);
-
- void blk_cleanup_queue(struct request_queue *q)
- {
-@@ -612,6 +613,7 @@ int blk_get_queue(struct request_queue *q)
-
- return 1;
- }
-+EXPORT_SYMBOL_GPL(blk_get_queue);
-
- static inline void blk_free_request(struct request_queue *q, struct request *rq)
- {
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 7702118..1be123c 100644
--- a/drivers/acpi/Makefile
Modified: dists/squeeze/linux-2.6/debian/patches/series/36
==============================================================================
--- dists/squeeze/linux-2.6/debian/patches/series/36 Fri Jul 8 01:14:25 2011 (r17821)
+++ dists/squeeze/linux-2.6/debian/patches/series/36 Fri Jul 8 04:32:21 2011 (r17822)
@@ -1 +1,4 @@
+ bugfix/all/drm-radeon-kms-fix-bad-shift-atom-iio-parser.patch
+- bugfix/all/fix-for-buffer-overflow-in-ldm_frag_add-not-sufficient.patch
+- bugfix/x86/x86-amd-do-not-enable-arat-feature-on-amd-processors-below.patch
++ bugfix/all/stable/2.6.32.42.patch
More information about the Kernel-svn-changes
mailing list