diff --git a/debian/changelog b/debian/changelog index 54fe7c55f..be6dc9faa 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,17 +1,6 @@ linux-2.6 (2.6.32-6) UNRELEASED; urgency=low [ Ben Hutchings ] - * be2net: Add device ids for ServerEngines BladeEngine3 - * mpt2sas: Add device ids for LSI SAS2208 - * ar9170: Add device id for D-Link DWA 160 A2 - * powerpc/fsl: Add device ids for new QoirQ chips - * arm/dm646x: Add hardware id for DM6467 rev 3.x - * hda: Add device ids for Nvidia G2xx series - * smsusb: Add device ids for new Hauppauge devices - * mos7850: Add device ids for new B&B Electronics devices - * ftdi_sio: Add device ids for new B&B Electronics devices - * saa7134: Add device id and description for Asus Europa DVB-T card - * x86/iTCO-wdt: Add device ids for Intel 'Ibex Peak' PCH * Documentation/3c509: document ethtool support (Closes: #564743) * Add MODULE_FIRMWARE declarations to several drivers that lacked them * [x86] Update rt2860sta/rt2870sta firmware loader patch @@ -46,13 +35,14 @@ linux-2.6 (2.6.32-6) UNRELEASED; urgency=low * Force distribution=UNRELEASED in debian/bin/test-patches so that it works in released source packages * Add stable release 2.6.32.6 - * clockevent: Don't remove broadcast device on halt or CPU hotplug - (Closes: #566547) * postinst: Enable escape sequences in debconf notes (Closes: #566539) * Add 3w-sas driver for LSI 3ware 9750 SAS controllers * aufs2: Update to snapshot from 2010-01-25 (Closes: #567391) * cdc_ether: Do not set link down initially; not all devices send link change interrupts + * Add stable release 2.6.32.7: + - clockevent: Don't remove broadcast device on halt or CPU hotplug + (Closes: #566547) [ Ian Campbell ] * xen: Enable up to 32G of guest memory on i386. diff --git a/debian/patches/bugfix/all/stable/2.6.32.7.patch b/debian/patches/bugfix/all/stable/2.6.32.7.patch new file mode 100644 index 000000000..af74f2838 --- /dev/null +++ b/debian/patches/bugfix/all/stable/2.6.32.7.patch @@ -0,0 +1,4403 @@ +diff --git a/Documentation/DocBook/Makefile b/Documentation/DocBook/Makefile +index ab8300f..50075df 100644 +--- a/Documentation/DocBook/Makefile ++++ b/Documentation/DocBook/Makefile +@@ -32,10 +32,10 @@ PS_METHOD = $(prefer-db2x) + + ### + # The targets that may be used. +-PHONY += xmldocs sgmldocs psdocs pdfdocs htmldocs mandocs installmandocs cleandocs media ++PHONY += xmldocs sgmldocs psdocs pdfdocs htmldocs mandocs installmandocs cleandocs xmldoclinks + + BOOKS := $(addprefix $(obj)/,$(DOCBOOKS)) +-xmldocs: $(BOOKS) ++xmldocs: $(BOOKS) xmldoclinks + sgmldocs: xmldocs + + PS := $(patsubst %.xml, %.ps, $(BOOKS)) +@@ -45,15 +45,24 @@ PDF := $(patsubst %.xml, %.pdf, $(BOOKS)) + pdfdocs: $(PDF) + + HTML := $(sort $(patsubst %.xml, %.html, $(BOOKS))) +-htmldocs: media $(HTML) ++htmldocs: $(HTML) + $(call build_main_index) ++ $(call build_images) + + MAN := $(patsubst %.xml, %.9, $(BOOKS)) + mandocs: $(MAN) + +-media: +- mkdir -p $(srctree)/Documentation/DocBook/media/ +- cp $(srctree)/Documentation/DocBook/dvb/*.png $(srctree)/Documentation/DocBook/v4l/*.gif $(srctree)/Documentation/DocBook/media/ ++build_images = mkdir -p $(objtree)/Documentation/DocBook/media/ && \ ++ cp $(srctree)/Documentation/DocBook/dvb/*.png $(srctree)/Documentation/DocBook/v4l/*.gif $(objtree)/Documentation/DocBook/media/ ++ ++xmldoclinks: ++ifneq ($(objtree),$(srctree)) ++ for dep in dvb media-entities.tmpl media-indices.tmpl v4l; do \ ++ rm -f $(objtree)/Documentation/DocBook/$$dep \ ++ && ln -s $(srctree)/Documentation/DocBook/$$dep $(objtree)/Documentation/DocBook/ \ ++ || exit; \ ++ done ++endif + + installmandocs: mandocs + mkdir -p /usr/local/man/man9/ +diff --git a/Documentation/video4linux/CARDLIST.saa7134 b/Documentation/video4linux/CARDLIST.saa7134 +index 2620d60..94e255a 100644 +--- a/Documentation/video4linux/CARDLIST.saa7134 ++++ b/Documentation/video4linux/CARDLIST.saa7134 +@@ -172,3 +172,4 @@ + 171 -> Beholder BeholdTV X7 [5ace:7595] + 172 -> RoverMedia TV Link Pro FM [19d1:0138] + 173 -> Zolid Hybrid TV Tuner PCI [1131:2004] ++174 -> Asus Europa Hybrid OEM [1043:4847] +diff --git a/Makefile b/Makefile +index 20da312..07d3c6a 100644 +diff --git a/arch/arm/mach-davinci/dm646x.c b/arch/arm/mach-davinci/dm646x.c +index 0976049..36e4fb4 100644 +--- a/arch/arm/mach-davinci/dm646x.c ++++ b/arch/arm/mach-davinci/dm646x.c +@@ -789,7 +789,14 @@ static struct davinci_id dm646x_ids[] = { + .part_no = 0xb770, + .manufacturer = 0x017, + .cpu_id = DAVINCI_CPU_ID_DM6467, +- .name = "dm6467", ++ .name = "dm6467_rev1.x", ++ }, ++ { ++ .variant = 0x1, ++ .part_no = 0xb770, ++ .manufacturer = 0x017, ++ .cpu_id = DAVINCI_CPU_ID_DM6467, ++ .name = "dm6467_rev3.x", + }, + }; + +diff --git a/arch/powerpc/sysdev/fsl_pci.c b/arch/powerpc/sysdev/fsl_pci.c +index ae88b14..e82749b 100644 +--- a/arch/powerpc/sysdev/fsl_pci.c ++++ b/arch/powerpc/sysdev/fsl_pci.c +@@ -392,8 +392,22 @@ DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_MPC8536, quirk_fsl_pcie_header); + DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_MPC8641, quirk_fsl_pcie_header); + DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_MPC8641D, quirk_fsl_pcie_header); + DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_MPC8610, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1011E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1011, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1013E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1013, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1020E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1020, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1022E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P1022, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P2010E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P2010, quirk_fsl_pcie_header); + DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P2020E, quirk_fsl_pcie_header); + DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P2020, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P4040E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P4040, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P4080E, quirk_fsl_pcie_header); ++DECLARE_PCI_FIXUP_HEADER(0x1957, PCI_DEVICE_ID_P4080, quirk_fsl_pcie_header); + #endif /* CONFIG_PPC_85xx || CONFIG_PPC_86xx */ + + #if defined(CONFIG_PPC_83xx) || defined(CONFIG_PPC_MPC512x) +diff --git a/arch/s390/kvm/intercept.c b/arch/s390/kvm/intercept.c +index ba9d8a7..b400964 100644 +--- a/arch/s390/kvm/intercept.c ++++ b/arch/s390/kvm/intercept.c +@@ -213,7 +213,7 @@ static int handle_instruction_and_prog(struct kvm_vcpu *vcpu) + return rc2; + } + +-static const intercept_handler_t intercept_funcs[0x48 >> 2] = { ++static const intercept_handler_t intercept_funcs[] = { + [0x00 >> 2] = handle_noop, + [0x04 >> 2] = handle_instruction, + [0x08 >> 2] = handle_prog, +@@ -230,7 +230,7 @@ int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu) + intercept_handler_t func; + u8 code = vcpu->arch.sie_block->icptcode; + +- if (code & 3 || code > 0x48) ++ if (code & 3 || (code >> 2) >= ARRAY_SIZE(intercept_funcs)) + return -ENOTSUPP; + func = intercept_funcs[code >> 2]; + if (func) +diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c +index 40e1835..a2a03cf 100644 +--- a/arch/x86/kernel/cpu/intel.c ++++ b/arch/x86/kernel/cpu/intel.c +@@ -70,7 +70,6 @@ static void __cpuinit early_init_intel(struct cpuinfo_x86 *c) + if (c->x86_power & (1 << 8)) { + set_cpu_cap(c, X86_FEATURE_CONSTANT_TSC); + set_cpu_cap(c, X86_FEATURE_NONSTOP_TSC); +- set_cpu_cap(c, X86_FEATURE_TSC_RELIABLE); + sched_clock_stable = 1; + } + +diff --git a/arch/x86/kernel/cpuid.c b/arch/x86/kernel/cpuid.c +index f8590c5..0c91110 100644 +--- a/arch/x86/kernel/cpuid.c ++++ b/arch/x86/kernel/cpuid.c +@@ -234,7 +234,7 @@ static void __exit cpuid_exit(void) + for_each_online_cpu(cpu) + cpuid_device_destroy(cpu); + class_destroy(cpuid_class); +- unregister_chrdev(CPUID_MAJOR, "cpu/cpuid"); ++ __unregister_chrdev(CPUID_MAJOR, 0, NR_CPUS, "cpu/cpuid"); + unregister_hotcpu_notifier(&cpuid_class_cpu_notifier); + } + +diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c +index b42e63b..5eaeb5e 100644 +--- a/arch/x86/kernel/msr.c ++++ b/arch/x86/kernel/msr.c +@@ -290,7 +290,7 @@ static void __exit msr_exit(void) + for_each_online_cpu(cpu) + msr_device_destroy(cpu); + class_destroy(msr_class); +- unregister_chrdev(MSR_MAJOR, "cpu/msr"); ++ __unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr"); + unregister_hotcpu_notifier(&msr_class_cpu_notifier); + } + +diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c +index cd982f4..597683a 100644 +--- a/arch/x86/kernel/tsc.c ++++ b/arch/x86/kernel/tsc.c +@@ -763,6 +763,7 @@ void mark_tsc_unstable(char *reason) + { + if (!tsc_unstable) { + tsc_unstable = 1; ++ sched_clock_stable = 0; + printk(KERN_INFO "Marking TSC unstable due to %s\n", reason); + /* Change only the rating, when not registered */ + if (clocksource_tsc.mult) +diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c +index 41659fb..8dfeaaa 100644 +--- a/arch/x86/kvm/lapic.c ++++ b/arch/x86/kvm/lapic.c +@@ -374,6 +374,12 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode, + if (unlikely(!apic_enabled(apic))) + break; + ++ if (trig_mode) { ++ apic_debug("level trig mode for vector %d", vector); ++ apic_set_vector(vector, apic->regs + APIC_TMR); ++ } else ++ apic_clear_vector(vector, apic->regs + APIC_TMR); ++ + result = !apic_test_and_set_irr(vector, apic); + trace_kvm_apic_accept_irq(vcpu->vcpu_id, delivery_mode, + trig_mode, vector, !result); +@@ -384,11 +390,6 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode, + break; + } + +- if (trig_mode) { +- apic_debug("level trig mode for vector %d", vector); +- apic_set_vector(vector, apic->regs + APIC_TMR); +- } else +- apic_clear_vector(vector, apic->regs + APIC_TMR); + kvm_vcpu_kick(vcpu); + break; + +diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c +index 818b92a..3a01519 100644 +--- a/arch/x86/kvm/mmu.c ++++ b/arch/x86/kvm/mmu.c +@@ -477,7 +477,7 @@ static int host_mapping_level(struct kvm *kvm, gfn_t gfn) + + addr = gfn_to_hva(kvm, gfn); + if (kvm_is_error_hva(addr)) +- return page_size; ++ return PT_PAGE_TABLE_LEVEL; + + down_read(¤t->mm->mmap_sem); + vma = find_vma(current->mm, addr); +@@ -515,11 +515,9 @@ static int mapping_level(struct kvm_vcpu *vcpu, gfn_t large_gfn) + if (host_level == PT_PAGE_TABLE_LEVEL) + return host_level; + +- for (level = PT_DIRECTORY_LEVEL; level <= host_level; ++level) { +- ++ for (level = PT_DIRECTORY_LEVEL; level <= host_level; ++level) + if (has_wrprotected_page(vcpu->kvm, large_gfn, level)) + break; +- } + + return level - 1; + } +diff --git a/arch/x86/kvm/paging_tmpl.h b/arch/x86/kvm/paging_tmpl.h +index 85e12cd..5fa3325 100644 +--- a/arch/x86/kvm/paging_tmpl.h ++++ b/arch/x86/kvm/paging_tmpl.h +@@ -150,7 +150,9 @@ walk: + walker->table_gfn[walker->level - 1] = table_gfn; + walker->pte_gpa[walker->level - 1] = pte_gpa; + +- kvm_read_guest(vcpu->kvm, pte_gpa, &pte, sizeof(pte)); ++ if (kvm_read_guest(vcpu->kvm, pte_gpa, &pte, sizeof(pte))) ++ goto not_present; ++ + trace_kvm_mmu_paging_element(pte, walker->level); + + if (!is_present_gpte(pte)) +diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c +index 97b31fa..6378e07 100644 +--- a/arch/x86/kvm/x86.c ++++ b/arch/x86/kvm/x86.c +@@ -4766,12 +4766,13 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) + GFP_KERNEL); + if (!vcpu->arch.mce_banks) { + r = -ENOMEM; +- goto fail_mmu_destroy; ++ goto fail_free_lapic; + } + vcpu->arch.mcg_cap = KVM_MAX_MCE_BANKS; + + return 0; +- ++fail_free_lapic: ++ kvm_free_lapic(vcpu); + fail_mmu_destroy: + kvm_mmu_destroy(vcpu); + fail_free_pio_data: +@@ -4782,6 +4783,7 @@ fail: + + void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) + { ++ kfree(vcpu->arch.mce_banks); + kvm_free_lapic(vcpu); + down_read(&vcpu->kvm->slots_lock); + kvm_mmu_destroy(vcpu); +diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c +index bbd066e..a8f3ca6 100644 +--- a/drivers/acpi/processor_idle.c ++++ b/drivers/acpi/processor_idle.c +@@ -299,6 +299,17 @@ static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr) + pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.C2latency; + pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.C3latency; + ++ /* ++ * FADT specified C2 latency must be less than or equal to ++ * 100 microseconds. ++ */ ++ if (acpi_gbl_FADT.C2latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { ++ ACPI_DEBUG_PRINT((ACPI_DB_INFO, ++ "C2 latency too large [%d]\n", acpi_gbl_FADT.C2latency)); ++ /* invalidate C2 */ ++ pr->power.states[ACPI_STATE_C2].address = 0; ++ } ++ + ACPI_DEBUG_PRINT((ACPI_DB_INFO, + "lvl2[0x%08x] lvl3[0x%08x]\n", + pr->power.states[ACPI_STATE_C2].address, +@@ -495,16 +506,6 @@ static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx) + return; + + /* +- * C2 latency must be less than or equal to 100 +- * microseconds. +- */ +- else if (cx->latency > ACPI_PROCESSOR_MAX_C2_LATENCY) { +- ACPI_DEBUG_PRINT((ACPI_DB_INFO, +- "latency too large [%d]\n", cx->latency)); +- return; +- } +- +- /* + * Otherwise we've met all of our C2 requirements. + * Normalize the C2 latency to expidite policy + */ +diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c +index a3241a1..9519c77 100644 +--- a/drivers/ata/ahci.c ++++ b/drivers/ata/ahci.c +@@ -113,6 +113,7 @@ enum { + board_ahci_mcp65 = 6, + board_ahci_nopmp = 7, + board_ahci_yesncq = 8, ++ board_ahci_nosntf = 9, + + /* global controller registers */ + HOST_CAP = 0x00, /* host capabilities */ +@@ -235,6 +236,7 @@ enum { + AHCI_HFLAG_NO_SUSPEND = (1 << 10), /* don't suspend */ + AHCI_HFLAG_SRST_TOUT_IS_OFFLINE = (1 << 11), /* treat SRST timeout as + link offline */ ++ AHCI_HFLAG_NO_SNTF = (1 << 12), /* no sntf */ + + /* ap->flags bits */ + +@@ -508,7 +510,7 @@ static const struct ata_port_info ahci_port_info[] = { + .udma_mask = ATA_UDMA6, + .port_ops = &ahci_ops, + }, +- /* board_ahci_yesncq */ ++ [board_ahci_yesncq] = + { + AHCI_HFLAGS (AHCI_HFLAG_YES_NCQ), + .flags = AHCI_FLAG_COMMON, +@@ -516,6 +518,14 @@ static const struct ata_port_info ahci_port_info[] = { + .udma_mask = ATA_UDMA6, + .port_ops = &ahci_ops, + }, ++ [board_ahci_nosntf] = ++ { ++ AHCI_HFLAGS (AHCI_HFLAG_NO_SNTF), ++ .flags = AHCI_FLAG_COMMON, ++ .pio_mask = ATA_PIO4, ++ .udma_mask = ATA_UDMA6, ++ .port_ops = &ahci_ops, ++ }, + }; + + static const struct pci_device_id ahci_pci_tbl[] = { +@@ -531,7 +541,7 @@ static const struct pci_device_id ahci_pci_tbl[] = { + { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */ + { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */ + { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */ +- { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */ ++ { PCI_VDEVICE(INTEL, 0x2822), board_ahci_nosntf }, /* ICH8 */ + { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */ + { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */ + { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */ +@@ -849,6 +859,12 @@ static void ahci_save_initial_config(struct pci_dev *pdev, + cap &= ~HOST_CAP_PMP; + } + ++ if ((cap & HOST_CAP_SNTF) && (hpriv->flags & AHCI_HFLAG_NO_SNTF)) { ++ dev_printk(KERN_INFO, &pdev->dev, ++ "controller can't do SNTF, turning off CAP_SNTF\n"); ++ cap &= ~HOST_CAP_SNTF; ++ } ++ + if (pdev->vendor == PCI_VENDOR_ID_JMICRON && pdev->device == 0x2361 && + port_map != 1) { + dev_printk(KERN_INFO, &pdev->dev, +diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c +index 9ac4e37..0c6155f 100644 +--- a/drivers/ata/ata_piix.c ++++ b/drivers/ata/ata_piix.c +@@ -869,10 +869,10 @@ static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, in + (timings[pio][1] << 8); + } + +- if (ap->udma_mask) { ++ if (ap->udma_mask) + udma_enable &= ~(1 << devid); +- pci_write_config_word(dev, master_port, master_data); +- } ++ ++ pci_write_config_word(dev, master_port, master_data); + } + /* Don't scribble on 0x48 if the controller does not support UDMA */ + if (ap->udma_mask) +diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c +index a1cb5af..33faaa2 100644 +--- a/drivers/base/devtmpfs.c ++++ b/drivers/base/devtmpfs.c +@@ -353,6 +353,7 @@ int __init devtmpfs_init(void) + { + int err; + struct vfsmount *mnt; ++ char options[] = "mode=0755"; + + err = register_filesystem(&dev_fs_type); + if (err) { +@@ -361,7 +362,7 @@ int __init devtmpfs_init(void) + return err; + } + +- mnt = kern_mount(&dev_fs_type); ++ mnt = kern_mount_data(&dev_fs_type, options); + if (IS_ERR(mnt)) { + err = PTR_ERR(mnt); + printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err); +diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c +index 938100f..3a2ccb0 100644 +--- a/drivers/firmware/dmi_scan.c ++++ b/drivers/firmware/dmi_scan.c +@@ -429,7 +429,7 @@ static bool dmi_matches(const struct dmi_system_id *dmi) + for (i = 0; i < ARRAY_SIZE(dmi->matches); i++) { + int s = dmi->matches[i].slot; + if (s == DMI_NONE) +- continue; ++ break; + if (dmi_ident[s] + && strstr(dmi_ident[s], dmi->matches[i].substr)) + continue; +@@ -440,6 +440,15 @@ static bool dmi_matches(const struct dmi_system_id *dmi) + } + + /** ++ * dmi_is_end_of_table - check for end-of-table marker ++ * @dmi: pointer to the dmi_system_id structure to check ++ */ ++static bool dmi_is_end_of_table(const struct dmi_system_id *dmi) ++{ ++ return dmi->matches[0].slot == DMI_NONE; ++} ++ ++/** + * dmi_check_system - check system DMI data + * @list: array of dmi_system_id structures to match against + * All non-null elements of the list must match +@@ -457,7 +466,7 @@ int dmi_check_system(const struct dmi_system_id *list) + int count = 0; + const struct dmi_system_id *d; + +- for (d = list; d->ident; d++) ++ for (d = list; !dmi_is_end_of_table(d); d++) + if (dmi_matches(d)) { + count++; + if (d->callback && d->callback(d)) +@@ -484,7 +493,7 @@ const struct dmi_system_id *dmi_first_match(const struct dmi_system_id *list) + { + const struct dmi_system_id *d; + +- for (d = list; d->ident; d++) ++ for (d = list; !dmi_is_end_of_table(d); d++) + if (dmi_matches(d)) + return d; + +diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c +index 03bd703..5d901f6 100644 +--- a/drivers/hid/usbhid/hid-core.c ++++ b/drivers/hid/usbhid/hid-core.c +@@ -998,7 +998,8 @@ static int usbhid_start(struct hid_device *hid) + usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma; + usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP); + +- usbhid_init_reports(hid); ++ if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS)) ++ usbhid_init_reports(hid); + + set_bit(HID_STARTED, &usbhid->iofl); + +diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c +index 0d9045a..5713b93 100644 +--- a/drivers/hid/usbhid/hid-quirks.c ++++ b/drivers/hid/usbhid/hid-quirks.c +@@ -280,7 +280,7 @@ u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct) + if (idVendor == USB_VENDOR_ID_NCR && + idProduct >= USB_DEVICE_ID_NCR_FIRST && + idProduct <= USB_DEVICE_ID_NCR_LAST) +- return HID_QUIRK_NOGET; ++ return HID_QUIRK_NO_INIT_REPORTS; + + down_read(&dquirks_rwsem); + bl_entry = usbhid_exists_dquirk(idVendor, idProduct); +diff --git a/drivers/hwmon/fschmd.c b/drivers/hwmon/fschmd.c +index da1b1f9..f600813 100644 +--- a/drivers/hwmon/fschmd.c ++++ b/drivers/hwmon/fschmd.c +@@ -767,6 +767,7 @@ leave: + static int watchdog_open(struct inode *inode, struct file *filp) + { + struct fschmd_data *pos, *data = NULL; ++ int watchdog_is_open; + + /* We get called from drivers/char/misc.c with misc_mtx hold, and we + call misc_register() from fschmd_probe() with watchdog_data_mutex +@@ -781,10 +782,12 @@ static int watchdog_open(struct inode *inode, struct file *filp) + } + } + /* Note we can never not have found data, so we don't check for this */ +- kref_get(&data->kref); ++ watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open); ++ if (!watchdog_is_open) ++ kref_get(&data->kref); + mutex_unlock(&watchdog_data_mutex); + +- if (test_and_set_bit(0, &data->watchdog_is_open)) ++ if (watchdog_is_open) + return -EBUSY; + + /* Start the watchdog */ +diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c +index 2bf5116..df3eb8c 100644 +--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c ++++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c +@@ -884,6 +884,7 @@ struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neighbour, + + neigh->neighbour = neighbour; + neigh->dev = dev; ++ memset(&neigh->dgid.raw, 0, sizeof (union ib_gid)); + *to_ipoib_neigh(neighbour) = neigh; + skb_queue_head_init(&neigh->queue); + ipoib_cm_set(neigh, NULL); +diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c +index f361106..fc8823b 100644 +--- a/drivers/input/mouse/alps.c ++++ b/drivers/input/mouse/alps.c +@@ -5,6 +5,7 @@ + * Copyright (c) 2003-2005 Peter Osterlund + * Copyright (c) 2004 Dmitry Torokhov + * Copyright (c) 2005 Vojtech Pavlik ++ * Copyright (c) 2009 Sebastian Kapfer + * + * ALPS detection, tap switching and status querying info is taken from + * tpconfig utility (by C. Scott Ananian and Bruce Kall). +@@ -35,6 +36,8 @@ + #define ALPS_OLDPROTO 0x10 + #define ALPS_PASS 0x20 + #define ALPS_FW_BK_2 0x40 ++#define ALPS_PS2_INTERLEAVED 0x80 /* 3-byte PS/2 packet interleaved with ++ 6-byte ALPS packet */ + + static const struct alps_model_info alps_model_data[] = { + { { 0x32, 0x02, 0x14 }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* Toshiba Salellite Pro M10 */ +@@ -55,7 +58,9 @@ static const struct alps_model_info alps_model_data[] = { + { { 0x20, 0x02, 0x0e }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, /* XXX */ + { { 0x22, 0x02, 0x0a }, 0xf8, 0xf8, ALPS_PASS | ALPS_DUALPOINT }, + { { 0x22, 0x02, 0x14 }, 0xff, 0xff, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude D600 */ +- { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, ALPS_PASS | ALPS_DUALPOINT }, /* Dell Latitude E6500 */ ++ /* Dell Latitude E5500, E6400, E6500, Precision M4400 */ ++ { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, ++ ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED }, + { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FW_BK_1 }, /* Dell Vostro 1400 */ + }; + +@@ -66,20 +71,88 @@ static const struct alps_model_info alps_model_data[] = { + */ + + /* +- * ALPS abolute Mode - new format ++ * PS/2 packet format ++ * ++ * byte 0: 0 0 YSGN XSGN 1 M R L ++ * byte 1: X7 X6 X5 X4 X3 X2 X1 X0 ++ * byte 2: Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 ++ * ++ * Note that the device never signals overflow condition. ++ * ++ * ALPS absolute Mode - new format + * + * byte 0: 1 ? ? ? 1 ? ? ? + * byte 1: 0 x6 x5 x4 x3 x2 x1 x0 +- * byte 2: 0 x10 x9 x8 x7 ? fin ges ++ * byte 2: 0 x10 x9 x8 x7 ? fin ges + * byte 3: 0 y9 y8 y7 1 M R L + * byte 4: 0 y6 y5 y4 y3 y2 y1 y0 + * byte 5: 0 z6 z5 z4 z3 z2 z1 z0 + * ++ * Dualpoint device -- interleaved packet format ++ * ++ * byte 0: 1 1 0 0 1 1 1 1 ++ * byte 1: 0 x6 x5 x4 x3 x2 x1 x0 ++ * byte 2: 0 x10 x9 x8 x7 0 fin ges ++ * byte 3: 0 0 YSGN XSGN 1 1 1 1 ++ * byte 4: X7 X6 X5 X4 X3 X2 X1 X0 ++ * byte 5: Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 ++ * byte 6: 0 y9 y8 y7 1 m r l ++ * byte 7: 0 y6 y5 y4 y3 y2 y1 y0 ++ * byte 8: 0 z6 z5 z4 z3 z2 z1 z0 ++ * ++ * CAPITALS = stick, miniscules = touchpad ++ * + * ?'s can have different meanings on different models, + * such as wheel rotation, extra buttons, stick buttons + * on a dualpoint, etc. + */ + ++static bool alps_is_valid_first_byte(const struct alps_model_info *model, ++ unsigned char data) ++{ ++ return (data & model->mask0) == model->byte0; ++} ++ ++static void alps_report_buttons(struct psmouse *psmouse, ++ struct input_dev *dev1, struct input_dev *dev2, ++ int left, int right, int middle) ++{ ++ struct alps_data *priv = psmouse->private; ++ const struct alps_model_info *model = priv->i; ++ ++ if (model->flags & ALPS_PS2_INTERLEAVED) { ++ struct input_dev *dev; ++ ++ /* ++ * If shared button has already been reported on the ++ * other device (dev2) then this event should be also ++ * sent through that device. ++ */ ++ dev = test_bit(BTN_LEFT, dev2->key) ? dev2 : dev1; ++ input_report_key(dev, BTN_LEFT, left); ++ ++ dev = test_bit(BTN_RIGHT, dev2->key) ? dev2 : dev1; ++ input_report_key(dev, BTN_RIGHT, right); ++ ++ dev = test_bit(BTN_MIDDLE, dev2->key) ? dev2 : dev1; ++ input_report_key(dev, BTN_MIDDLE, middle); ++ ++ /* ++ * Sync the _other_ device now, we'll do the first ++ * device later once we report the rest of the events. ++ */ ++ input_sync(dev2); ++ } else { ++ /* ++ * For devices with non-interleaved packets we know what ++ * device buttons belong to so we can simply report them. ++ */ ++ input_report_key(dev1, BTN_LEFT, left); ++ input_report_key(dev1, BTN_RIGHT, right); ++ input_report_key(dev1, BTN_MIDDLE, middle); ++ } ++} ++ + static void alps_process_packet(struct psmouse *psmouse) + { + struct alps_data *priv = psmouse->private; +@@ -89,18 +162,6 @@ static void alps_process_packet(struct psmouse *psmouse) + int x, y, z, ges, fin, left, right, middle; + int back = 0, forward = 0; + +- if ((packet[0] & 0xc8) == 0x08) { /* 3-byte PS/2 packet */ +- input_report_key(dev2, BTN_LEFT, packet[0] & 1); +- input_report_key(dev2, BTN_RIGHT, packet[0] & 2); +- input_report_key(dev2, BTN_MIDDLE, packet[0] & 4); +- input_report_rel(dev2, REL_X, +- packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0); +- input_report_rel(dev2, REL_Y, +- packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0); +- input_sync(dev2); +- return; +- } +- + if (priv->i->flags & ALPS_OLDPROTO) { + left = packet[2] & 0x10; + right = packet[2] & 0x08; +@@ -136,18 +197,13 @@ static void alps_process_packet(struct psmouse *psmouse) + input_report_rel(dev2, REL_X, (x > 383 ? (x - 768) : x)); + input_report_rel(dev2, REL_Y, -(y > 255 ? (y - 512) : y)); + +- input_report_key(dev2, BTN_LEFT, left); +- input_report_key(dev2, BTN_RIGHT, right); +- input_report_key(dev2, BTN_MIDDLE, middle); ++ alps_report_buttons(psmouse, dev2, dev, left, right, middle); + +- input_sync(dev); + input_sync(dev2); + return; + } + +- input_report_key(dev, BTN_LEFT, left); +- input_report_key(dev, BTN_RIGHT, right); +- input_report_key(dev, BTN_MIDDLE, middle); ++ alps_report_buttons(psmouse, dev, dev2, left, right, middle); + + /* Convert hardware tap to a reasonable Z value */ + if (ges && !fin) z = 40; +@@ -188,25 +244,168 @@ static void alps_process_packet(struct psmouse *psmouse) + input_sync(dev); + } + ++static void alps_report_bare_ps2_packet(struct psmouse *psmouse, ++ unsigned char packet[], ++ bool report_buttons) ++{ ++ struct alps_data *priv = psmouse->private; ++ struct input_dev *dev2 = priv->dev2; ++ ++ if (report_buttons) ++ alps_report_buttons(psmouse, dev2, psmouse->dev, ++ packet[0] & 1, packet[0] & 2, packet[0] & 4); ++ ++ input_report_rel(dev2, REL_X, ++ packet[1] ? packet[1] - ((packet[0] << 4) & 0x100) : 0); ++ input_report_rel(dev2, REL_Y, ++ packet[2] ? ((packet[0] << 3) & 0x100) - packet[2] : 0); ++ ++ input_sync(dev2); ++} ++ ++static psmouse_ret_t alps_handle_interleaved_ps2(struct psmouse *psmouse) ++{ ++ struct alps_data *priv = psmouse->private; ++ ++ if (psmouse->pktcnt < 6) ++ return PSMOUSE_GOOD_DATA; ++ ++ if (psmouse->pktcnt == 6) { ++ /* ++ * Start a timer to flush the packet if it ends up last ++ * 6-byte packet in the stream. Timer needs to fire ++ * psmouse core times out itself. 20 ms should be enough ++ * to decide if we are getting more data or not. ++ */ ++ mod_timer(&priv->timer, jiffies + msecs_to_jiffies(20)); ++ return PSMOUSE_GOOD_DATA; ++ } ++ ++ del_timer(&priv->timer); ++ ++ if (psmouse->packet[6] & 0x80) { ++ ++ /* ++ * Highest bit is set - that means we either had ++ * complete ALPS packet and this is start of the ++ * next packet or we got garbage. ++ */ ++ ++ if (((psmouse->packet[3] | ++ psmouse->packet[4] | ++ psmouse->packet[5]) & 0x80) || ++ (!alps_is_valid_first_byte(priv->i, psmouse->packet[6]))) { ++ dbg("refusing packet %x %x %x %x " ++ "(suspected interleaved ps/2)\n", ++ psmouse->packet[3], psmouse->packet[4], ++ psmouse->packet[5], psmouse->packet[6]); ++ return PSMOUSE_BAD_DATA; ++ } ++ ++ alps_process_packet(psmouse); ++ ++ /* Continue with the next packet */ ++ psmouse->packet[0] = psmouse->packet[6]; ++ psmouse->pktcnt = 1; ++ ++ } else { ++ ++ /* ++ * High bit is 0 - that means that we indeed got a PS/2 ++ * packet in the middle of ALPS packet. ++ * ++ * There is also possibility that we got 6-byte ALPS ++ * packet followed by 3-byte packet from trackpoint. We ++ * can not distinguish between these 2 scenarios but ++ * becase the latter is unlikely to happen in course of ++ * normal operation (user would need to press all ++ * buttons on the pad and start moving trackpoint ++ * without touching the pad surface) we assume former. ++ * Even if we are wrong the wost thing that would happen ++ * the cursor would jump but we should not get protocol ++ * desynchronization. ++ */ ++ ++ alps_report_bare_ps2_packet(psmouse, &psmouse->packet[3], ++ false); ++ ++ /* ++ * Continue with the standard ALPS protocol handling, ++ * but make sure we won't process it as an interleaved ++ * packet again, which may happen if all buttons are ++ * pressed. To avoid this let's reset the 4th bit which ++ * is normally 1. ++ */ ++ psmouse->packet[3] = psmouse->packet[6] & 0xf7; ++ psmouse->pktcnt = 4; ++ } ++ ++ return PSMOUSE_GOOD_DATA; ++} ++ ++static void alps_flush_packet(unsigned long data) ++{ ++ struct psmouse *psmouse = (struct psmouse *)data; ++ ++ serio_pause_rx(psmouse->ps2dev.serio); ++ ++ if (psmouse->pktcnt == 6) { ++ ++ /* ++ * We did not any more data in reasonable amount of time. ++ * Validate the last 3 bytes and process as a standard ++ * ALPS packet. ++ */ ++ if ((psmouse->packet[3] | ++ psmouse->packet[4] | ++ psmouse->packet[5]) & 0x80) { ++ dbg("refusing packet %x %x %x " ++ "(suspected interleaved ps/2)\n", ++ psmouse->packet[3], psmouse->packet[4], ++ psmouse->packet[5]); ++ } else { ++ alps_process_packet(psmouse); ++ } ++ psmouse->pktcnt = 0; ++ } ++ ++ serio_continue_rx(psmouse->ps2dev.serio); ++} ++ + static psmouse_ret_t alps_process_byte(struct psmouse *psmouse) + { + struct alps_data *priv = psmouse->private; ++ const struct alps_model_info *model = priv->i; + + if ((psmouse->packet[0] & 0xc8) == 0x08) { /* PS/2 packet */ + if (psmouse->pktcnt == 3) { +- alps_process_packet(psmouse); ++ alps_report_bare_ps2_packet(psmouse, psmouse->packet, ++ true); + return PSMOUSE_FULL_PACKET; + } + return PSMOUSE_GOOD_DATA; + } + +- if ((psmouse->packet[0] & priv->i->mask0) != priv->i->byte0) ++ /* Check for PS/2 packet stuffed in the middle of ALPS packet. */ ++ ++ if ((model->flags & ALPS_PS2_INTERLEAVED) && ++ psmouse->pktcnt >= 4 && (psmouse->packet[3] & 0x0f) == 0x0f) { ++ return alps_handle_interleaved_ps2(psmouse); ++ } ++ ++ if (!alps_is_valid_first_byte(model, psmouse->packet[0])) { ++ dbg("refusing packet[0] = %x (mask0 = %x, byte0 = %x)\n", ++ psmouse->packet[0], model->mask0, model->byte0); + return PSMOUSE_BAD_DATA; ++ } + + /* Bytes 2 - 6 should have 0 in the highest bit */ + if (psmouse->pktcnt >= 2 && psmouse->pktcnt <= 6 && +- (psmouse->packet[psmouse->pktcnt - 1] & 0x80)) ++ (psmouse->packet[psmouse->pktcnt - 1] & 0x80)) { ++ dbg("refusing packet[%i] = %x\n", ++ psmouse->pktcnt - 1, psmouse->packet[psmouse->pktcnt - 1]); + return PSMOUSE_BAD_DATA; ++ } + + if (psmouse->pktcnt == 6) { + alps_process_packet(psmouse); +@@ -445,6 +644,7 @@ static void alps_disconnect(struct psmouse *psmouse) + struct alps_data *priv = psmouse->private; + + psmouse_reset(psmouse); ++ del_timer_sync(&priv->timer); + input_unregister_device(priv->dev2); + kfree(priv); + } +@@ -461,6 +661,8 @@ int alps_init(struct psmouse *psmouse) + goto init_fail; + + priv->dev2 = dev2; ++ setup_timer(&priv->timer, alps_flush_packet, (unsigned long)psmouse); ++ + psmouse->private = priv; + + if (alps_hw_init(psmouse, &version)) +diff --git a/drivers/input/mouse/alps.h b/drivers/input/mouse/alps.h +index bc87936..904ed8b 100644 +--- a/drivers/input/mouse/alps.h ++++ b/drivers/input/mouse/alps.h +@@ -23,6 +23,7 @@ struct alps_data { + char phys[32]; /* Phys */ + const struct alps_model_info *i;/* Info */ + int prev_fin; /* Finger bit from previous packet */ ++ struct timer_list timer; + }; + + #ifdef CONFIG_MOUSE_PS2_ALPS +diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h +index 2bcf1ac..2a5982e 100644 +--- a/drivers/input/serio/i8042-x86ia64io.h ++++ b/drivers/input/serio/i8042-x86ia64io.h +@@ -67,10 +67,12 @@ static inline void i8042_write_command(int val) + + #include + +-static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_noloop_table[] = { + { +- /* AUX LOOP command does not raise AUX IRQ */ +- .ident = "Arima-Rioworks HDAMB", ++ /* ++ * Arima-Rioworks HDAMB - ++ * AUX LOOP command does not raise AUX IRQ ++ */ + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "RIOWORKS"), + DMI_MATCH(DMI_BOARD_NAME, "HDAMB"), +@@ -78,7 +80,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "ASUS G1S", ++ /* ASUS G1S */ + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."), + DMI_MATCH(DMI_BOARD_NAME, "G1S"), +@@ -86,8 +88,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- /* AUX LOOP command does not raise AUX IRQ */ +- .ident = "ASUS P65UP5", ++ /* ASUS P65UP5 - AUX LOOP command does not raise AUX IRQ */ + .matches = { + DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), + DMI_MATCH(DMI_BOARD_NAME, "P/I-P65UP5"), +@@ -95,7 +96,6 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Compaq Proliant 8500", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Compaq"), + DMI_MATCH(DMI_PRODUCT_NAME , "ProLiant"), +@@ -103,7 +103,6 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Compaq Proliant DL760", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Compaq"), + DMI_MATCH(DMI_PRODUCT_NAME , "ProLiant"), +@@ -111,7 +110,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "OQO Model 01", ++ /* OQO Model 01 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "OQO"), + DMI_MATCH(DMI_PRODUCT_NAME, "ZEPTO"), +@@ -119,8 +118,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- /* AUX LOOP does not work properly */ +- .ident = "ULI EV4873", ++ /* ULI EV4873 - AUX LOOP does not work properly */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "ULI"), + DMI_MATCH(DMI_PRODUCT_NAME, "EV4873"), +@@ -128,7 +126,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Microsoft Virtual Machine", ++ /* Microsoft Virtual Machine */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"), + DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"), +@@ -136,7 +134,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Medion MAM 2070", ++ /* Medion MAM 2070 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Notebook"), + DMI_MATCH(DMI_PRODUCT_NAME, "MAM 2070"), +@@ -144,7 +142,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Blue FB5601", ++ /* Blue FB5601 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "blue"), + DMI_MATCH(DMI_PRODUCT_NAME, "FB5601"), +@@ -152,7 +150,7 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "Gigabyte M912", ++ /* Gigabyte M912 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"), + DMI_MATCH(DMI_PRODUCT_NAME, "M912"), +@@ -160,7 +158,14 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + }, + }, + { +- .ident = "HP DV9700", ++ /* Gigabyte M1022M netbook */ ++ .matches = { ++ DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co.,Ltd."), ++ DMI_MATCH(DMI_BOARD_NAME, "M1022E"), ++ DMI_MATCH(DMI_BOARD_VERSION, "1.02"), ++ }, ++ }, ++ { + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), + DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion dv9700"), +@@ -177,72 +182,72 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { + * ... apparently some Toshibas don't like MUX mode either and + * die horrible death on reboot. + */ +-static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = { + { +- .ident = "Fujitsu Lifebook P7010/P7010D", ++ /* Fujitsu Lifebook P7010/P7010D */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), + DMI_MATCH(DMI_PRODUCT_NAME, "P7010"), + }, + }, + { +- .ident = "Fujitsu Lifebook P7010", ++ /* Fujitsu Lifebook P7010 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), + DMI_MATCH(DMI_PRODUCT_NAME, "0000000000"), + }, + }, + { +- .ident = "Fujitsu Lifebook P5020D", ++ /* Fujitsu Lifebook P5020D */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), + DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook P Series"), + }, + }, + { +- .ident = "Fujitsu Lifebook S2000", ++ /* Fujitsu Lifebook S2000 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), + DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S Series"), + }, + }, + { +- .ident = "Fujitsu Lifebook S6230", ++ /* Fujitsu Lifebook S6230 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), + DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S6230"), + }, + }, + { +- .ident = "Fujitsu T70H", ++ /* Fujitsu T70H */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"), + DMI_MATCH(DMI_PRODUCT_NAME, "FMVLT70H"), + }, + }, + { +- .ident = "Fujitsu-Siemens Lifebook T3010", ++ /* Fujitsu-Siemens Lifebook T3010 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), + DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK T3010"), + }, + }, + { +- .ident = "Fujitsu-Siemens Lifebook E4010", ++ /* Fujitsu-Siemens Lifebook E4010 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), + DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E4010"), + }, + }, + { +- .ident = "Fujitsu-Siemens Amilo Pro 2010", ++ /* Fujitsu-Siemens Amilo Pro 2010 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), + DMI_MATCH(DMI_PRODUCT_NAME, "AMILO Pro V2010"), + }, + }, + { +- .ident = "Fujitsu-Siemens Amilo Pro 2030", ++ /* Fujitsu-Siemens Amilo Pro 2030 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU SIEMENS"), + DMI_MATCH(DMI_PRODUCT_NAME, "AMILO PRO V2030"), +@@ -253,7 +258,7 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + * No data is coming from the touchscreen unless KBC + * is in legacy mode. + */ +- .ident = "Panasonic CF-29", ++ /* Panasonic CF-29 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Matsushita"), + DMI_MATCH(DMI_PRODUCT_NAME, "CF-29"), +@@ -261,10 +266,10 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + }, + { + /* +- * Errors on MUX ports are reported without raising AUXDATA ++ * HP Pavilion DV4017EA - ++ * errors on MUX ports are reported without raising AUXDATA + * causing "spurious NAK" messages. + */ +- .ident = "HP Pavilion DV4017EA", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), + DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion dv4000 (EA032EA#ABF)"), +@@ -272,9 +277,9 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + }, + { + /* +- * Like DV4017EA does not raise AUXERR for errors on MUX ports. ++ * HP Pavilion ZT1000 - ++ * like DV4017EA does not raise AUXERR for errors on MUX ports. + */ +- .ident = "HP Pavilion ZT1000", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), + DMI_MATCH(DMI_PRODUCT_NAME, "HP Pavilion Notebook PC"), +@@ -283,44 +288,41 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + }, + { + /* +- * Like DV4017EA does not raise AUXERR for errors on MUX ports. ++ * HP Pavilion DV4270ca - ++ * like DV4017EA does not raise AUXERR for errors on MUX ports. + */ +- .ident = "HP Pavilion DV4270ca", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), + DMI_MATCH(DMI_PRODUCT_NAME, "Pavilion dv4000 (EH476UA#ABL)"), + }, + }, + { +- .ident = "Toshiba P10", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), + DMI_MATCH(DMI_PRODUCT_NAME, "Satellite P10"), + }, + }, + { +- .ident = "Toshiba Equium A110", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), + DMI_MATCH(DMI_PRODUCT_NAME, "EQUIUM A110"), + }, + }, + { +- .ident = "Alienware Sentia", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "ALIENWARE"), + DMI_MATCH(DMI_PRODUCT_NAME, "Sentia"), + }, + }, + { +- .ident = "Sharp Actius MM20", ++ /* Sharp Actius MM20 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "SHARP"), + DMI_MATCH(DMI_PRODUCT_NAME, "PC-MM20 Series"), + }, + }, + { +- .ident = "Sony Vaio FS-115b", ++ /* Sony Vaio FS-115b */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), + DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FS115B"), +@@ -328,73 +330,72 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + }, + { + /* +- * Reset and GET ID commands issued via KBD port are ++ * Sony Vaio FZ-240E - ++ * reset and GET ID commands issued via KBD port are + * sometimes being delivered to AUX3. + */ +- .ident = "Sony Vaio FZ-240E", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), + DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FZ240E"), + }, + }, + { +- .ident = "Amoi M636/A737", ++ /* Amoi M636/A737 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Amoi Electronics CO.,LTD."), + DMI_MATCH(DMI_PRODUCT_NAME, "M636/A737 platform"), + }, + }, + { +- .ident = "Lenovo 3000 n100", ++ /* Lenovo 3000 n100 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), + DMI_MATCH(DMI_PRODUCT_NAME, "076804U"), + }, + }, + { +- .ident = "Acer Aspire 1360", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 1360"), + }, + }, + { +- .ident = "Gericom Bellagio", ++ /* Gericom Bellagio */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Gericom"), + DMI_MATCH(DMI_PRODUCT_NAME, "N34AS6"), + }, + }, + { +- .ident = "IBM 2656", ++ /* IBM 2656 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "IBM"), + DMI_MATCH(DMI_PRODUCT_NAME, "2656"), + }, + }, + { +- .ident = "Dell XPS M1530", ++ /* Dell XPS M1530 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "XPS M1530"), + }, + }, + { +- .ident = "Compal HEL80I", ++ /* Compal HEL80I */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "COMPAL"), + DMI_MATCH(DMI_PRODUCT_NAME, "HEL80I"), + }, + }, + { +- .ident = "Dell Vostro 1510", ++ /* Dell Vostro 1510 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro1510"), + }, + }, + { +- .ident = "Acer Aspire 5536", ++ /* Acer Aspire 5536 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5536"), +@@ -404,65 +405,65 @@ static struct dmi_system_id __initdata i8042_dmi_nomux_table[] = { + { } + }; + +-static struct dmi_system_id __initdata i8042_dmi_reset_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_reset_table[] = { + { +- .ident = "MSI Wind U-100", ++ /* MSI Wind U-100 */ + .matches = { + DMI_MATCH(DMI_BOARD_NAME, "U-100"), + DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"), + }, + }, + { +- .ident = "LG Electronics X110", ++ /* LG Electronics X110 */ + .matches = { + DMI_MATCH(DMI_BOARD_NAME, "X110"), + DMI_MATCH(DMI_BOARD_VENDOR, "LG Electronics Inc."), + }, + }, + { +- .ident = "Acer Aspire One 150", ++ /* Acer Aspire One 150 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "AOA150"), + }, + }, + { +- .ident = "Advent 4211", ++ /* Advent 4211 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "DIXONSXP"), + DMI_MATCH(DMI_PRODUCT_NAME, "Advent 4211"), + }, + }, + { +- .ident = "Medion Akoya Mini E1210", ++ /* Medion Akoya Mini E1210 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "MEDION"), + DMI_MATCH(DMI_PRODUCT_NAME, "E1210"), + }, + }, + { +- .ident = "Mivvy M310", ++ /* Mivvy M310 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "VIOOO"), + DMI_MATCH(DMI_PRODUCT_NAME, "N10"), + }, + }, + { +- .ident = "Dell Vostro 1320", ++ /* Dell Vostro 1320 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1320"), + }, + }, + { +- .ident = "Dell Vostro 1520", ++ /* Dell Vostro 1520 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1520"), + }, + }, + { +- .ident = "Dell Vostro 1720", ++ /* Dell Vostro 1720 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), + DMI_MATCH(DMI_PRODUCT_NAME, "Vostro 1720"), +@@ -472,16 +473,16 @@ static struct dmi_system_id __initdata i8042_dmi_reset_table[] = { + }; + + #ifdef CONFIG_PNP +-static struct dmi_system_id __initdata i8042_dmi_nopnp_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_nopnp_table[] = { + { +- .ident = "Intel MBO Desktop D845PESV", ++ /* Intel MBO Desktop D845PESV */ + .matches = { + DMI_MATCH(DMI_BOARD_NAME, "D845PESV"), + DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"), + }, + }, + { +- .ident = "MSI Wind U-100", ++ /* MSI Wind U-100 */ + .matches = { + DMI_MATCH(DMI_BOARD_NAME, "U-100"), + DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"), +@@ -490,27 +491,23 @@ static struct dmi_system_id __initdata i8042_dmi_nopnp_table[] = { + { } + }; + +-static struct dmi_system_id __initdata i8042_dmi_laptop_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_laptop_table[] = { + { +- .ident = "Portable", + .matches = { + DMI_MATCH(DMI_CHASSIS_TYPE, "8"), /* Portable */ + }, + }, + { +- .ident = "Laptop", + .matches = { + DMI_MATCH(DMI_CHASSIS_TYPE, "9"), /* Laptop */ + }, + }, + { +- .ident = "Notebook", + .matches = { + DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */ + }, + }, + { +- .ident = "Sub-Notebook", + .matches = { + DMI_MATCH(DMI_CHASSIS_TYPE, "14"), /* Sub-Notebook */ + }, +@@ -525,58 +522,65 @@ static struct dmi_system_id __initdata i8042_dmi_laptop_table[] = { + * Originally, this was just confined to older laptops, but a few Acer laptops + * have turned up in 2007 that also need this again. + */ +-static struct dmi_system_id __initdata i8042_dmi_dritek_table[] = { ++static const struct dmi_system_id __initconst i8042_dmi_dritek_table[] = { ++ { ++ /* Acer Aspire 5610 */ ++ .matches = { ++ DMI_MATCH(DMI_SYS_VENDOR, "Acer"), ++ DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5610"), ++ }, ++ }, + { +- .ident = "Acer Aspire 5630", ++ /* Acer Aspire 5630 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5630"), + }, + }, + { +- .ident = "Acer Aspire 5650", ++ /* Acer Aspire 5650 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5650"), + }, + }, + { +- .ident = "Acer Aspire 5680", ++ /* Acer Aspire 5680 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5680"), + }, + }, + { +- .ident = "Acer Aspire 5720", ++ /* Acer Aspire 5720 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5720"), + }, + }, + { +- .ident = "Acer Aspire 9110", ++ /* Acer Aspire 9110 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 9110"), + }, + }, + { +- .ident = "Acer TravelMate 660", ++ /* Acer TravelMate 660 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 660"), + }, + }, + { +- .ident = "Acer TravelMate 2490", ++ /* Acer TravelMate 2490 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 2490"), + }, + }, + { +- .ident = "Acer TravelMate 4280", ++ /* Acer TravelMate 4280 */ + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Acer"), + DMI_MATCH(DMI_PRODUCT_NAME, "TravelMate 4280"), +diff --git a/drivers/md/md.c b/drivers/md/md.c +index c6a6685..08f7471 100644 +--- a/drivers/md/md.c ++++ b/drivers/md/md.c +@@ -4173,7 +4173,7 @@ static int do_md_run(mddev_t * mddev) + mddev->barriers_work = 1; + mddev->ok_start_degraded = start_dirty_degraded; + +- if (start_readonly) ++ if (start_readonly && mddev->ro == 0) + mddev->ro = 2; /* read-only, but switch on first write */ + + err = mddev->pers->run(mddev); +diff --git a/drivers/media/dvb/siano/smsusb.c b/drivers/media/dvb/siano/smsusb.c +index 8f88a58..6b03dbf 100644 +--- a/drivers/media/dvb/siano/smsusb.c ++++ b/drivers/media/dvb/siano/smsusb.c +@@ -533,8 +533,18 @@ struct usb_device_id smsusb_id_table[] = { + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, + { USB_DEVICE(0x2040, 0xb910), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, ++ { USB_DEVICE(0x2040, 0xb980), ++ .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, ++ { USB_DEVICE(0x2040, 0xb990), ++ .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, + { USB_DEVICE(0x2040, 0xc000), + .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, ++ { USB_DEVICE(0x2040, 0xc010), ++ .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, ++ { USB_DEVICE(0x2040, 0xc080), ++ .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, ++ { USB_DEVICE(0x2040, 0xc090), ++ .driver_info = SMS1XXX_BOARD_HAUPPAUGE_WINDHAM }, + { } /* Terminating entry */ + }; + +diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c +index 0901322..6781a07 100644 +--- a/drivers/media/video/saa7134/saa7134-cards.c ++++ b/drivers/media/video/saa7134/saa7134-cards.c +@@ -5279,6 +5279,30 @@ struct saa7134_board saa7134_boards[] = { + .amux = TV, + }, + }, ++ [SAA7134_BOARD_ASUS_EUROPA_HYBRID] = { ++ .name = "Asus Europa Hybrid OEM", ++ .audio_clock = 0x00187de7, ++ .tuner_type = TUNER_PHILIPS_TD1316, ++ .radio_type = UNSET, ++ .tuner_addr = 0x61, ++ .radio_addr = ADDR_UNSET, ++ .tda9887_conf = TDA9887_PRESENT | TDA9887_PORT1_ACTIVE, ++ .mpeg = SAA7134_MPEG_DVB, ++ .inputs = { { ++ .name = name_tv, ++ .vmux = 3, ++ .amux = TV, ++ .tv = 1, ++ }, { ++ .name = name_comp1, ++ .vmux = 4, ++ .amux = LINE2, ++ }, { ++ .name = name_svideo, ++ .vmux = 8, ++ .amux = LINE2, ++ } }, ++ }, + + }; + +@@ -6418,6 +6442,12 @@ struct pci_device_id saa7134_pci_tbl[] = { + .subdevice = 0x2004, + .driver_data = SAA7134_BOARD_ZOLID_HYBRID_PCI, + }, { ++ .vendor = PCI_VENDOR_ID_PHILIPS, ++ .device = PCI_DEVICE_ID_PHILIPS_SAA7134, ++ .subvendor = 0x1043, ++ .subdevice = 0x4847, ++ .driver_data = SAA7134_BOARD_ASUS_EUROPA_HYBRID, ++ }, { + /* --- boards without eeprom + subsystem ID --- */ + .vendor = PCI_VENDOR_ID_PHILIPS, + .device = PCI_DEVICE_ID_PHILIPS_SAA7134, +@@ -7079,6 +7109,7 @@ int saa7134_board_init2(struct saa7134_dev *dev) + /* break intentionally omitted */ + case SAA7134_BOARD_VIDEOMATE_DVBT_300: + case SAA7134_BOARD_ASUS_EUROPA2_HYBRID: ++ case SAA7134_BOARD_ASUS_EUROPA_HYBRID: + { + + /* The Philips EUROPA based hybrid boards have the tuner +diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c +index a26e997..b8a805c 100644 +--- a/drivers/media/video/saa7134/saa7134-dvb.c ++++ b/drivers/media/video/saa7134/saa7134-dvb.c +@@ -1116,6 +1116,7 @@ static int dvb_init(struct saa7134_dev *dev) + break; + case SAA7134_BOARD_PHILIPS_EUROPA: + case SAA7134_BOARD_VIDEOMATE_DVBT_300: ++ case SAA7134_BOARD_ASUS_EUROPA_HYBRID: + fe0->dvb.frontend = dvb_attach(tda10046_attach, + &philips_europa_config, + &dev->i2c_adap); +diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h +index f8697d4..94e1a3b 100644 +--- a/drivers/media/video/saa7134/saa7134.h ++++ b/drivers/media/video/saa7134/saa7134.h +@@ -297,6 +297,7 @@ struct saa7134_format { + #define SAA7134_BOARD_BEHOLD_X7 171 + #define SAA7134_BOARD_ROVERMEDIA_LINK_PRO_FM 172 + #define SAA7134_BOARD_ZOLID_HYBRID_PCI 173 ++#define SAA7134_BOARD_ASUS_EUROPA_HYBRID 174 + + #define SAA7134_MAXBOARDS 32 + #define SAA7134_INPUT_MAX 8 +diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c +index 1b89735..4a293b4 100644 +--- a/drivers/media/video/uvc/uvc_ctrl.c ++++ b/drivers/media/video/uvc/uvc_ctrl.c +@@ -1405,7 +1405,7 @@ uvc_ctrl_prune_entity(struct uvc_device *dev, struct uvc_entity *entity) + size = entity->processing.bControlSize; + + for (i = 0; i < ARRAY_SIZE(blacklist); ++i) { +- if (!usb_match_id(dev->intf, &blacklist[i].id)) ++ if (!usb_match_one_id(dev->intf, &blacklist[i].id)) + continue; + + if (blacklist[i].index >= 8 * size || +diff --git a/drivers/mtd/ubi/upd.c b/drivers/mtd/ubi/upd.c +index c1d7b88..425bf5a 100644 +--- a/drivers/mtd/ubi/upd.c ++++ b/drivers/mtd/ubi/upd.c +@@ -155,6 +155,7 @@ int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol, + if (err) + return err; + vol->updating = 0; ++ return 0; + } + + vol->upd_buf = vmalloc(ubi->leb_size); +diff --git a/drivers/mtd/ubi/vtbl.c b/drivers/mtd/ubi/vtbl.c +index 1afc61e..4004402 100644 +--- a/drivers/mtd/ubi/vtbl.c ++++ b/drivers/mtd/ubi/vtbl.c +@@ -566,6 +566,7 @@ static int init_volumes(struct ubi_device *ubi, const struct ubi_scan_info *si, + vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs); + vol->alignment = be32_to_cpu(vtbl[i].alignment); + vol->data_pad = be32_to_cpu(vtbl[i].data_pad); ++ vol->upd_marker = vtbl[i].upd_marker; + vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ? + UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME; + vol->name_len = be16_to_cpu(vtbl[i].name_len); +diff --git a/drivers/net/atl1c/atl1c.h b/drivers/net/atl1c/atl1c.h +index 2a1120a..790e55b 100644 +--- a/drivers/net/atl1c/atl1c.h ++++ b/drivers/net/atl1c/atl1c.h +@@ -534,6 +534,9 @@ struct atl1c_adapter { + #define __AT_TESTING 0x0001 + #define __AT_RESETTING 0x0002 + #define __AT_DOWN 0x0003 ++ u8 work_event; ++#define ATL1C_WORK_EVENT_RESET 0x01 ++#define ATL1C_WORK_EVENT_LINK_CHANGE 0x02 + u32 msg_enable; + + bool have_msi; +@@ -545,8 +548,7 @@ struct atl1c_adapter { + spinlock_t tx_lock; + atomic_t irq_sem; + +- struct work_struct reset_task; +- struct work_struct link_chg_task; ++ struct work_struct common_task; + struct timer_list watchdog_timer; + struct timer_list phy_config_timer; + +diff --git a/drivers/net/atl1c/atl1c_main.c b/drivers/net/atl1c/atl1c_main.c +index 1372e9a..be00ee9 100644 +--- a/drivers/net/atl1c/atl1c_main.c ++++ b/drivers/net/atl1c/atl1c_main.c +@@ -198,27 +198,12 @@ static void atl1c_phy_config(unsigned long data) + + void atl1c_reinit_locked(struct atl1c_adapter *adapter) + { +- + WARN_ON(in_interrupt()); + atl1c_down(adapter); + atl1c_up(adapter); + clear_bit(__AT_RESETTING, &adapter->flags); + } + +-static void atl1c_reset_task(struct work_struct *work) +-{ +- struct atl1c_adapter *adapter; +- struct net_device *netdev; +- +- adapter = container_of(work, struct atl1c_adapter, reset_task); +- netdev = adapter->netdev; +- +- netif_device_detach(netdev); +- atl1c_down(adapter); +- atl1c_up(adapter); +- netif_device_attach(netdev); +-} +- + static void atl1c_check_link_status(struct atl1c_adapter *adapter) + { + struct atl1c_hw *hw = &adapter->hw; +@@ -275,18 +260,6 @@ static void atl1c_check_link_status(struct atl1c_adapter *adapter) + } + } + +-/* +- * atl1c_link_chg_task - deal with link change event Out of interrupt context +- * @netdev: network interface device structure +- */ +-static void atl1c_link_chg_task(struct work_struct *work) +-{ +- struct atl1c_adapter *adapter; +- +- adapter = container_of(work, struct atl1c_adapter, link_chg_task); +- atl1c_check_link_status(adapter); +-} +- + static void atl1c_link_chg_event(struct atl1c_adapter *adapter) + { + struct net_device *netdev = adapter->netdev; +@@ -311,20 +284,40 @@ static void atl1c_link_chg_event(struct atl1c_adapter *adapter) + adapter->link_speed = SPEED_0; + } + } +- schedule_work(&adapter->link_chg_task); ++ ++ adapter->work_event |= ATL1C_WORK_EVENT_LINK_CHANGE; ++ schedule_work(&adapter->common_task); + } + +-static void atl1c_del_timer(struct atl1c_adapter *adapter) ++static void atl1c_common_task(struct work_struct *work) + { +- del_timer_sync(&adapter->phy_config_timer); ++ struct atl1c_adapter *adapter; ++ struct net_device *netdev; ++ ++ adapter = container_of(work, struct atl1c_adapter, common_task); ++ netdev = adapter->netdev; ++ ++ if (adapter->work_event & ATL1C_WORK_EVENT_RESET) { ++ netif_device_detach(netdev); ++ atl1c_down(adapter); ++ atl1c_up(adapter); ++ netif_device_attach(netdev); ++ return; ++ } ++ ++ if (adapter->work_event & ATL1C_WORK_EVENT_LINK_CHANGE) ++ atl1c_check_link_status(adapter); ++ ++ return; + } + +-static void atl1c_cancel_work(struct atl1c_adapter *adapter) ++ ++static void atl1c_del_timer(struct atl1c_adapter *adapter) + { +- cancel_work_sync(&adapter->reset_task); +- cancel_work_sync(&adapter->link_chg_task); ++ del_timer_sync(&adapter->phy_config_timer); + } + ++ + /* + * atl1c_tx_timeout - Respond to a Tx Hang + * @netdev: network interface device structure +@@ -334,7 +327,8 @@ static void atl1c_tx_timeout(struct net_device *netdev) + struct atl1c_adapter *adapter = netdev_priv(netdev); + + /* Do the reset outside of interrupt context */ +- schedule_work(&adapter->reset_task); ++ adapter->work_event |= ATL1C_WORK_EVENT_RESET; ++ schedule_work(&adapter->common_task); + } + + /* +@@ -1536,7 +1530,8 @@ static irqreturn_t atl1c_intr(int irq, void *data) + /* reset MAC */ + hw->intr_mask &= ~ISR_ERROR; + AT_WRITE_REG(hw, REG_IMR, hw->intr_mask); +- schedule_work(&adapter->reset_task); ++ adapter->work_event |= ATL1C_WORK_EVENT_RESET; ++ schedule_work(&adapter->common_task); + break; + } + +@@ -2200,8 +2195,7 @@ void atl1c_down(struct atl1c_adapter *adapter) + struct net_device *netdev = adapter->netdev; + + atl1c_del_timer(adapter); +- atl1c_cancel_work(adapter); +- ++ adapter->work_event = 0; /* clear all event */ + /* signal that we're down so the interrupt handler does not + * reschedule our watchdog timer */ + set_bit(__AT_DOWN, &adapter->flags); +@@ -2601,8 +2595,8 @@ static int __devinit atl1c_probe(struct pci_dev *pdev, + adapter->hw.mac_addr[4], adapter->hw.mac_addr[5]); + + atl1c_hw_set_mac_addr(&adapter->hw); +- INIT_WORK(&adapter->reset_task, atl1c_reset_task); +- INIT_WORK(&adapter->link_chg_task, atl1c_link_chg_task); ++ INIT_WORK(&adapter->common_task, atl1c_common_task); ++ adapter->work_event = 0; + err = register_netdev(netdev); + if (err) { + dev_err(&pdev->dev, "register netdevice failed\n"); +diff --git a/drivers/net/atl1e/atl1e_main.c b/drivers/net/atl1e/atl1e_main.c +index 955da73..1b5facf 100644 +--- a/drivers/net/atl1e/atl1e_main.c ++++ b/drivers/net/atl1e/atl1e_main.c +@@ -1666,41 +1666,6 @@ static int atl1e_tso_csum(struct atl1e_adapter *adapter, + } + return 0; + } +- +- if (offload_type & SKB_GSO_TCPV6) { +- real_len = (((unsigned char *)ipv6_hdr(skb) - skb->data) +- + ntohs(ipv6_hdr(skb)->payload_len)); +- if (real_len < skb->len) +- pskb_trim(skb, real_len); +- +- /* check payload == 0 byte ? */ +- hdr_len = (skb_transport_offset(skb) + tcp_hdrlen(skb)); +- if (unlikely(skb->len == hdr_len)) { +- /* only xsum need */ +- dev_warn(&pdev->dev, +- "IPV6 tso with zero data??\n"); +- goto check_sum; +- } else { +- tcp_hdr(skb)->check = ~csum_ipv6_magic( +- &ipv6_hdr(skb)->saddr, +- &ipv6_hdr(skb)->daddr, +- 0, IPPROTO_TCP, 0); +- tpd->word3 |= 1 << TPD_IP_VERSION_SHIFT; +- hdr_len >>= 1; +- tpd->word3 |= (hdr_len & TPD_V6_IPHLLO_MASK) << +- TPD_V6_IPHLLO_SHIFT; +- tpd->word3 |= ((hdr_len >> 3) & +- TPD_V6_IPHLHI_MASK) << +- TPD_V6_IPHLHI_SHIFT; +- tpd->word3 |= (tcp_hdrlen(skb) >> 2 & +- TPD_TCPHDRLEN_MASK) << +- TPD_TCPHDRLEN_SHIFT; +- tpd->word3 |= ((skb_shinfo(skb)->gso_size) & +- TPD_MSS_MASK) << TPD_MSS_SHIFT; +- tpd->word3 |= 1 << TPD_SEGMENT_EN_SHIFT; +- } +- } +- return 0; + } + + check_sum: +@@ -2289,7 +2254,6 @@ static int atl1e_init_netdev(struct net_device *netdev, struct pci_dev *pdev) + NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX; + netdev->features |= NETIF_F_LLTX; + netdev->features |= NETIF_F_TSO; +- netdev->features |= NETIF_F_TSO6; + + return 0; + } +diff --git a/drivers/net/benet/be.h b/drivers/net/benet/be.h +index 3b79a22..a84f1c5 100644 +--- a/drivers/net/benet/be.h ++++ b/drivers/net/benet/be.h +@@ -35,20 +35,31 @@ + #define DRV_VER "2.101.205" + #define DRV_NAME "be2net" + #define BE_NAME "ServerEngines BladeEngine2 10Gbps NIC" ++#define BE3_NAME "ServerEngines BladeEngine3 10Gbps NIC" + #define OC_NAME "Emulex OneConnect 10Gbps NIC" ++#define OC_NAME1 "Emulex OneConnect 10Gbps NIC (be3)" + #define DRV_DESC BE_NAME "Driver" + + #define BE_VENDOR_ID 0x19a2 + #define BE_DEVICE_ID1 0x211 ++#define BE_DEVICE_ID2 0x221 + #define OC_DEVICE_ID1 0x700 + #define OC_DEVICE_ID2 0x701 ++#define OC_DEVICE_ID3 0x710 + + static inline char *nic_name(struct pci_dev *pdev) + { +- if (pdev->device == OC_DEVICE_ID1 || pdev->device == OC_DEVICE_ID2) ++ switch (pdev->device) { ++ case OC_DEVICE_ID1: ++ case OC_DEVICE_ID2: + return OC_NAME; +- else ++ case OC_DEVICE_ID3: ++ return OC_NAME1; ++ case BE_DEVICE_ID2: ++ return BE3_NAME; ++ default: + return BE_NAME; ++ } + } + + /* Number of bytes of an RX frame that are copied to skb->data */ +diff --git a/drivers/net/benet/be_main.c b/drivers/net/benet/be_main.c +index 876b357..3749bb1 100644 +--- a/drivers/net/benet/be_main.c ++++ b/drivers/net/benet/be_main.c +@@ -31,8 +31,10 @@ MODULE_PARM_DESC(rx_frag_size, "Size of a fragment that holds rcvd data."); + + static DEFINE_PCI_DEVICE_TABLE(be_dev_ids) = { + { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) }, ++ { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) }, + { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) }, + { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) }, ++ { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID3) }, + { 0 } + }; + MODULE_DEVICE_TABLE(pci, be_dev_ids); +diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c +index a2fc70a..35d896b 100644 +--- a/drivers/net/qlge/qlge_main.c ++++ b/drivers/net/qlge/qlge_main.c +@@ -3310,10 +3310,8 @@ static int ql_adapter_initialize(struct ql_adapter *qdev) + + /* Initialize the port and set the max framesize. */ + status = qdev->nic_ops->port_initialize(qdev); +- if (status) { +- QPRINTK(qdev, IFUP, ERR, "Failed to start port.\n"); +- return status; +- } ++ if (status) ++ QPRINTK(qdev, IFUP, ERR, "Failed to start port.\n"); + + /* Set up the MAC address and frame routing filter. */ + status = ql_cam_route_initialize(qdev); +@@ -3714,9 +3712,6 @@ static int qlge_set_mac_address(struct net_device *ndev, void *p) + struct sockaddr *addr = p; + int status; + +- if (netif_running(ndev)) +- return -EBUSY; +- + if (!is_valid_ether_addr(addr->sa_data)) + return -EADDRNOTAVAIL; + memcpy(ndev->dev_addr, addr->sa_data, ndev->addr_len); +@@ -3868,8 +3863,7 @@ static int __devinit ql_init_device(struct pci_dev *pdev, + struct net_device *ndev, int cards_found) + { + struct ql_adapter *qdev = netdev_priv(ndev); +- int pos, err = 0; +- u16 val16; ++ int err = 0; + + memset((void *)qdev, 0, sizeof(*qdev)); + err = pci_enable_device(pdev); +@@ -3881,18 +3875,12 @@ static int __devinit ql_init_device(struct pci_dev *pdev, + qdev->ndev = ndev; + qdev->pdev = pdev; + pci_set_drvdata(pdev, ndev); +- pos = pci_find_capability(pdev, PCI_CAP_ID_EXP); +- if (pos <= 0) { +- dev_err(&pdev->dev, PFX "Cannot find PCI Express capability, " +- "aborting.\n"); +- return pos; +- } else { +- pci_read_config_word(pdev, pos + PCI_EXP_DEVCTL, &val16); +- val16 &= ~PCI_EXP_DEVCTL_NOSNOOP_EN; +- val16 |= (PCI_EXP_DEVCTL_CERE | +- PCI_EXP_DEVCTL_NFERE | +- PCI_EXP_DEVCTL_FERE | PCI_EXP_DEVCTL_URRE); +- pci_write_config_word(pdev, pos + PCI_EXP_DEVCTL, val16); ++ ++ /* Set PCIe read request size */ ++ err = pcie_set_readrq(pdev, 4096); ++ if (err) { ++ dev_err(&pdev->dev, "Set readrq failed.\n"); ++ goto err_out; + } + + err = pci_request_regions(pdev, DRV_NAME); +diff --git a/drivers/net/qlge/qlge_mpi.c b/drivers/net/qlge/qlge_mpi.c +index aec05f2..32b1e1f 100644 +--- a/drivers/net/qlge/qlge_mpi.c ++++ b/drivers/net/qlge/qlge_mpi.c +@@ -446,6 +446,9 @@ static int ql_mpi_handler(struct ql_adapter *qdev, struct mbox_params *mbcp) + ql_aen_lost(qdev, mbcp); + break; + ++ case AEN_DCBX_CHG: ++ /* Need to support AEN 8110 */ ++ break; + default: + QPRINTK(qdev, DRV, ERR, + "Unsupported AE %.08x.\n", mbcp->mbox_out[0]); +diff --git a/drivers/net/sfc/tx.c b/drivers/net/sfc/tx.c +index 489c4de..d443ad7 100644 +--- a/drivers/net/sfc/tx.c ++++ b/drivers/net/sfc/tx.c +@@ -821,8 +821,6 @@ static void efx_enqueue_unwind(struct efx_tx_queue *tx_queue) + tx_queue->efx->type->txd_ring_mask]; + efx_tsoh_free(tx_queue, buffer); + EFX_BUG_ON_PARANOID(buffer->skb); +- buffer->len = 0; +- buffer->continuation = true; + if (buffer->unmap_len) { + unmap_addr = (buffer->dma_addr + buffer->len - + buffer->unmap_len); +@@ -836,6 +834,8 @@ static void efx_enqueue_unwind(struct efx_tx_queue *tx_queue) + PCI_DMA_TODEVICE); + buffer->unmap_len = 0; + } ++ buffer->len = 0; ++ buffer->continuation = true; + } + } + +diff --git a/drivers/net/wireless/ath/ar9170/usb.c b/drivers/net/wireless/ath/ar9170/usb.c +index e974e58..f141a4f 100644 +--- a/drivers/net/wireless/ath/ar9170/usb.c ++++ b/drivers/net/wireless/ath/ar9170/usb.c +@@ -68,8 +68,10 @@ static struct usb_device_id ar9170_usb_ids[] = { + { USB_DEVICE(0x0cf3, 0x1002) }, + /* Cace Airpcap NX */ + { USB_DEVICE(0xcace, 0x0300) }, +- /* D-Link DWA 160A */ ++ /* D-Link DWA 160 A1 */ + { USB_DEVICE(0x07d1, 0x3c10) }, ++ /* D-Link DWA 160 A2 */ ++ { USB_DEVICE(0x07d1, 0x3a09) }, + /* Netgear WNDA3100 */ + { USB_DEVICE(0x0846, 0x9010) }, + /* Netgear WN111 v2 */ +diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c +index 94a1225..133df70 100644 +--- a/drivers/net/wireless/iwlwifi/iwl-5000.c ++++ b/drivers/net/wireless/iwlwifi/iwl-5000.c +@@ -1666,6 +1666,7 @@ struct iwl_cfg iwl5300_agn_cfg = { + .valid_rx_ant = ANT_ABC, + .need_pll_cfg = true, + .ht_greenfield_support = true, ++ .use_rts_for_ht = true, /* use rts/cts protection */ + }; + + struct iwl_cfg iwl5100_bg_cfg = { +@@ -1717,6 +1718,7 @@ struct iwl_cfg iwl5100_agn_cfg = { + .valid_rx_ant = ANT_AB, + .need_pll_cfg = true, + .ht_greenfield_support = true, ++ .use_rts_for_ht = true, /* use rts/cts protection */ + }; + + struct iwl_cfg iwl5350_agn_cfg = { +@@ -1734,6 +1736,7 @@ struct iwl_cfg iwl5350_agn_cfg = { + .valid_rx_ant = ANT_ABC, + .need_pll_cfg = true, + .ht_greenfield_support = true, ++ .use_rts_for_ht = true, /* use rts/cts protection */ + }; + + struct iwl_cfg iwl5150_agn_cfg = { +@@ -1751,6 +1754,7 @@ struct iwl_cfg iwl5150_agn_cfg = { + .valid_rx_ant = ANT_AB, + .need_pll_cfg = true, + .ht_greenfield_support = true, ++ .use_rts_for_ht = true, /* use rts/cts protection */ + }; + + MODULE_FIRMWARE(IWL5000_MODULE_FIRMWARE(IWL5000_UCODE_API_MAX)); +diff --git a/drivers/pci/pcie/aer/aer_inject.c b/drivers/pci/pcie/aer/aer_inject.c +index 62d15f6..0d91a8a 100644 +--- a/drivers/pci/pcie/aer/aer_inject.c ++++ b/drivers/pci/pcie/aer/aer_inject.c +@@ -392,8 +392,14 @@ static int aer_inject(struct aer_error_inj *einj) + if (ret) + goto out_put; + +- if (find_aer_device(rpdev, &edev)) ++ if (find_aer_device(rpdev, &edev)) { ++ if (!get_service_data(edev)) { ++ printk(KERN_WARNING "AER service is not initialized\n"); ++ ret = -EINVAL; ++ goto out_put; ++ } + aer_irq(-1, edev); ++ } + else + ret = -EINVAL; + out_put: +diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c +index cb1a027..dd58c6a 100644 +--- a/drivers/pci/setup-bus.c ++++ b/drivers/pci/setup-bus.c +@@ -142,7 +142,6 @@ static void pci_setup_bridge(struct pci_bus *bus) + struct pci_dev *bridge = bus->self; + struct pci_bus_region region; + u32 l, bu, lu, io_upper16; +- int pref_mem64; + + if (pci_is_enabled(bridge)) + return; +@@ -198,7 +197,6 @@ static void pci_setup_bridge(struct pci_bus *bus) + pci_write_config_dword(bridge, PCI_PREF_LIMIT_UPPER32, 0); + + /* Set up PREF base/limit. */ +- pref_mem64 = 0; + bu = lu = 0; + pcibios_resource_to_bus(bridge, ®ion, bus->resource[2]); + if (bus->resource[2]->flags & IORESOURCE_PREFETCH) { +@@ -206,7 +204,6 @@ static void pci_setup_bridge(struct pci_bus *bus) + l = (region.start >> 16) & 0xfff0; + l |= region.end & 0xfff00000; + if (bus->resource[2]->flags & IORESOURCE_MEM_64) { +- pref_mem64 = 1; + bu = upper_32_bits(region.start); + lu = upper_32_bits(region.end); + width = 16; +@@ -221,11 +218,9 @@ static void pci_setup_bridge(struct pci_bus *bus) + } + pci_write_config_dword(bridge, PCI_PREF_MEMORY_BASE, l); + +- if (pref_mem64) { +- /* Set the upper 32 bits of PREF base & limit. */ +- pci_write_config_dword(bridge, PCI_PREF_BASE_UPPER32, bu); +- pci_write_config_dword(bridge, PCI_PREF_LIMIT_UPPER32, lu); +- } ++ /* Set the upper 32 bits of PREF base & limit. */ ++ pci_write_config_dword(bridge, PCI_PREF_BASE_UPPER32, bu); ++ pci_write_config_dword(bridge, PCI_PREF_LIMIT_UPPER32, lu); + + pci_write_config_word(bridge, PCI_BRIDGE_CONTROL, bus->bridge_ctl); + } +diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c +index 2490b74..55f9973 100644 +--- a/drivers/s390/cio/device.c ++++ b/drivers/s390/cio/device.c +@@ -1292,7 +1292,7 @@ static int io_subchannel_probe(struct subchannel *sch) + sch->private = kzalloc(sizeof(struct io_subchannel_private), + GFP_KERNEL | GFP_DMA); + if (!sch->private) +- goto out_err; ++ goto out_schedule; + /* + * First check if a fitting device may be found amongst the + * disconnected devices or in the orphanage. +@@ -1317,7 +1317,7 @@ static int io_subchannel_probe(struct subchannel *sch) + } + cdev = io_subchannel_create_ccwdev(sch); + if (IS_ERR(cdev)) +- goto out_err; ++ goto out_schedule; + rc = io_subchannel_recog(cdev, sch); + if (rc) { + spin_lock_irqsave(sch->lock, flags); +@@ -1325,9 +1325,7 @@ static int io_subchannel_probe(struct subchannel *sch) + spin_unlock_irqrestore(sch->lock, flags); + } + return 0; +-out_err: +- kfree(sch->private); +- sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group); ++ + out_schedule: + io_subchannel_schedule_removal(sch); + return 0; +@@ -1341,13 +1339,14 @@ io_subchannel_remove (struct subchannel *sch) + + cdev = sch_get_cdev(sch); + if (!cdev) +- return 0; ++ goto out_free; + /* Set ccw device to not operational and drop reference. */ + spin_lock_irqsave(cdev->ccwlock, flags); + sch_set_cdev(sch, NULL); + cdev->private->state = DEV_STATE_NOT_OPER; + spin_unlock_irqrestore(cdev->ccwlock, flags); + ccw_device_unregister(cdev); ++out_free: + kfree(sch->private); + sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group); + return 0; +diff --git a/drivers/s390/cio/device_fsm.c b/drivers/s390/cio/device_fsm.c +index b9613d7..13b703a 100644 +--- a/drivers/s390/cio/device_fsm.c ++++ b/drivers/s390/cio/device_fsm.c +@@ -1080,14 +1080,14 @@ void ccw_device_trigger_reprobe(struct ccw_device *cdev) + ccw_device_start_id(cdev, 0); + } + +-static void +-ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event) ++static void ccw_device_disabled_irq(struct ccw_device *cdev, ++ enum dev_event dev_event) + { + struct subchannel *sch; + + sch = to_subchannel(cdev->dev.parent); + /* +- * An interrupt in state offline means a previous disable was not ++ * An interrupt in a disabled state means a previous disable was not + * successful - should not happen, but we try to disable again. + */ + cio_disable_subchannel(sch); +@@ -1150,25 +1150,12 @@ ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event) + } + + /* +- * Bug operation action. +- */ +-static void +-ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event) +-{ +- CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device " +- "0.%x.%04x\n", cdev->private->state, dev_event, +- cdev->private->dev_id.ssid, +- cdev->private->dev_id.devno); +- BUG(); +-} +- +-/* + * device statemachine + */ + fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = { + [DEV_STATE_NOT_OPER] = { + [DEV_EVENT_NOTOPER] = ccw_device_nop, +- [DEV_EVENT_INTERRUPT] = ccw_device_bug, ++ [DEV_EVENT_INTERRUPT] = ccw_device_disabled_irq, + [DEV_EVENT_TIMEOUT] = ccw_device_nop, + [DEV_EVENT_VERIFY] = ccw_device_nop, + }, +@@ -1186,7 +1173,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = { + }, + [DEV_STATE_OFFLINE] = { + [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper, +- [DEV_EVENT_INTERRUPT] = ccw_device_offline_irq, ++ [DEV_EVENT_INTERRUPT] = ccw_device_disabled_irq, + [DEV_EVENT_TIMEOUT] = ccw_device_nop, + [DEV_EVENT_VERIFY] = ccw_device_offline_verify, + }, +@@ -1243,7 +1230,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = { + [DEV_STATE_DISCONNECTED] = { + [DEV_EVENT_NOTOPER] = ccw_device_nop, + [DEV_EVENT_INTERRUPT] = ccw_device_start_id, +- [DEV_EVENT_TIMEOUT] = ccw_device_bug, ++ [DEV_EVENT_TIMEOUT] = ccw_device_nop, + [DEV_EVENT_VERIFY] = ccw_device_start_id, + }, + [DEV_STATE_DISCONNECTED_SENSE_ID] = { +diff --git a/drivers/s390/net/netiucv.c b/drivers/s390/net/netiucv.c +index c84eadd..395c04c 100644 +--- a/drivers/s390/net/netiucv.c ++++ b/drivers/s390/net/netiucv.c +@@ -741,13 +741,13 @@ static void conn_action_txdone(fsm_instance *fi, int event, void *arg) + if (single_flag) { + if ((skb = skb_dequeue(&conn->commit_queue))) { + atomic_dec(&skb->users); +- dev_kfree_skb_any(skb); + if (privptr) { + privptr->stats.tx_packets++; + privptr->stats.tx_bytes += + (skb->len - NETIUCV_HDRLEN +- - NETIUCV_HDRLEN); ++ - NETIUCV_HDRLEN); + } ++ dev_kfree_skb_any(skb); + } + } + conn->tx_buff->data = conn->tx_buff->head; +diff --git a/drivers/scsi/device_handler/scsi_dh.c b/drivers/scsi/device_handler/scsi_dh.c +index 3ee1cbc..bfec4fa 100644 +--- a/drivers/scsi/device_handler/scsi_dh.c ++++ b/drivers/scsi/device_handler/scsi_dh.c +@@ -304,18 +304,15 @@ static int scsi_dh_notifier(struct notifier_block *nb, + sdev = to_scsi_device(dev); + + if (action == BUS_NOTIFY_ADD_DEVICE) { ++ err = device_create_file(dev, &scsi_dh_state_attr); ++ /* don't care about err */ + devinfo = device_handler_match(NULL, sdev); +- if (!devinfo) +- goto out; +- +- err = scsi_dh_handler_attach(sdev, devinfo); +- if (!err) +- err = device_create_file(dev, &scsi_dh_state_attr); ++ if (devinfo) ++ err = scsi_dh_handler_attach(sdev, devinfo); + } else if (action == BUS_NOTIFY_DEL_DEVICE) { + device_remove_file(dev, &scsi_dh_state_attr); + scsi_dh_handler_detach(sdev, NULL); + } +-out: + return err; + } + +diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c +index 704b8e0..70ab5d0 100644 +--- a/drivers/scsi/fcoe/fcoe.c ++++ b/drivers/scsi/fcoe/fcoe.c +@@ -137,7 +137,7 @@ static struct scsi_host_template fcoe_shost_template = { + .change_queue_depth = fc_change_queue_depth, + .change_queue_type = fc_change_queue_type, + .this_id = -1, +- .cmd_per_lun = 32, ++ .cmd_per_lun = 3, + .can_queue = FCOE_MAX_OUTSTANDING_COMMANDS, + .use_clustering = ENABLE_CLUSTERING, + .sg_tablesize = SG_ALL, +@@ -160,6 +160,7 @@ static int fcoe_interface_setup(struct fcoe_interface *fcoe, + { + struct fcoe_ctlr *fip = &fcoe->ctlr; + struct netdev_hw_addr *ha; ++ struct net_device *real_dev; + u8 flogi_maddr[ETH_ALEN]; + + fcoe->netdev = netdev; +@@ -173,10 +174,12 @@ static int fcoe_interface_setup(struct fcoe_interface *fcoe, + + /* look for SAN MAC address, if multiple SAN MACs exist, only + * use the first one for SPMA */ ++ real_dev = (netdev->priv_flags & IFF_802_1Q_VLAN) ? ++ vlan_dev_real_dev(netdev) : netdev; + rcu_read_lock(); +- for_each_dev_addr(netdev, ha) { ++ for_each_dev_addr(real_dev, ha) { + if ((ha->type == NETDEV_HW_ADDR_T_SAN) && +- (is_valid_ether_addr(fip->ctl_src_addr))) { ++ (is_valid_ether_addr(ha->addr))) { + memcpy(fip->ctl_src_addr, ha->addr, ETH_ALEN); + fip->spma = 1; + break; +@@ -664,7 +667,7 @@ static int fcoe_ddp_setup(struct fc_lport *lp, u16 xid, + { + struct net_device *n = fcoe_netdev(lp); + +- if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_setup) ++ if (n->netdev_ops->ndo_fcoe_ddp_setup) + return n->netdev_ops->ndo_fcoe_ddp_setup(n, xid, sgl, sgc); + + return 0; +@@ -681,7 +684,7 @@ static int fcoe_ddp_done(struct fc_lport *lp, u16 xid) + { + struct net_device *n = fcoe_netdev(lp); + +- if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_done) ++ if (n->netdev_ops->ndo_fcoe_ddp_done) + return n->netdev_ops->ndo_fcoe_ddp_done(n, xid); + return 0; + } +@@ -1631,7 +1634,7 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp) + { + struct fcoe_interface *fcoe; + struct net_device *netdev; +- int rc; ++ int rc = 0; + + mutex_lock(&fcoe_config_mutex); + #ifdef CONFIG_FCOE_MODULE +diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c +index c48799e..d4cb3f9 100644 +--- a/drivers/scsi/libfc/fc_disc.c ++++ b/drivers/scsi/libfc/fc_disc.c +@@ -371,7 +371,7 @@ static void fc_disc_gpn_ft_req(struct fc_disc *disc) + disc, lport->e_d_tov)) + return; + err: +- fc_disc_error(disc, fp); ++ fc_disc_error(disc, NULL); + } + + /** +diff --git a/drivers/scsi/libfc/fc_elsct.c b/drivers/scsi/libfc/fc_elsct.c +index 5cfa687..9298458 100644 +--- a/drivers/scsi/libfc/fc_elsct.c ++++ b/drivers/scsi/libfc/fc_elsct.c +@@ -53,8 +53,10 @@ static struct fc_seq *fc_elsct_send(struct fc_lport *lport, + did = FC_FID_DIR_SERV; + } + +- if (rc) ++ if (rc) { ++ fc_frame_free(fp); + return NULL; ++ } + + fc_fill_fc_hdr(fp, r_ctl, did, fc_host_port_id(lport->host), fh_type, + FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); +diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c +index 59a4408..7a14402 100644 +--- a/drivers/scsi/libfc/fc_fcp.c ++++ b/drivers/scsi/libfc/fc_fcp.c +@@ -302,10 +302,13 @@ static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp) + if (!fsp) + return; + ++ if (fsp->xfer_ddp == FC_XID_UNKNOWN) ++ return; ++ + lp = fsp->lp; +- if (fsp->xfer_ddp && lp->tt.ddp_done) { ++ if (lp->tt.ddp_done) { + fsp->xfer_len = lp->tt.ddp_done(lp, fsp->xfer_ddp); +- fsp->xfer_ddp = 0; ++ fsp->xfer_ddp = FC_XID_UNKNOWN; + } + } + +@@ -572,7 +575,8 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq, + tlen -= sg_bytes; + remaining -= sg_bytes; + +- if (tlen) ++ if ((skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN) && ++ (tlen)) + continue; + + /* +@@ -1048,7 +1052,6 @@ static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp, + + seq = lp->tt.exch_seq_send(lp, fp, resp, fc_fcp_pkt_destroy, fsp, 0); + if (!seq) { +- fc_frame_free(fp); + rc = -1; + goto unlock; + } +@@ -1313,7 +1316,6 @@ static void fc_fcp_rec(struct fc_fcp_pkt *fsp) + fc_fcp_pkt_hold(fsp); /* hold while REC outstanding */ + return; + } +- fc_frame_free(fp); + retry: + if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY) + fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV); +@@ -1561,10 +1563,9 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset) + + seq = lp->tt.exch_seq_send(lp, fp, fc_fcp_srr_resp, NULL, + fsp, jiffies_to_msecs(FC_SCSI_REC_TOV)); +- if (!seq) { +- fc_frame_free(fp); ++ if (!seq) + goto retry; +- } ++ + fsp->recov_seq = seq; + fsp->xfer_len = offset; + fsp->xfer_contig_end = offset; +@@ -1708,6 +1709,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *)) + fsp->cmd = sc_cmd; /* save the cmd */ + fsp->lp = lp; /* save the softc ptr */ + fsp->rport = rport; /* set the remote port ptr */ ++ fsp->xfer_ddp = FC_XID_UNKNOWN; + sc_cmd->scsi_done = done; + + /* +@@ -1846,7 +1848,8 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp) + * scsi status is good but transport level + * underrun. + */ +- sc_cmd->result = DID_OK << 16; ++ sc_cmd->result = (fsp->state & FC_SRB_RCV_STATUS ? ++ DID_OK : DID_ERROR) << 16; + } else { + /* + * scsi got underrun, this is an error +@@ -2046,18 +2049,16 @@ EXPORT_SYMBOL(fc_eh_host_reset); + int fc_slave_alloc(struct scsi_device *sdev) + { + struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); +- int queue_depth; + + if (!rport || fc_remote_port_chkready(rport)) + return -ENXIO; + +- if (sdev->tagged_supported) { +- if (sdev->host->hostt->cmd_per_lun) +- queue_depth = sdev->host->hostt->cmd_per_lun; +- else +- queue_depth = FC_FCP_DFLT_QUEUE_DEPTH; +- scsi_activate_tcq(sdev, queue_depth); +- } ++ if (sdev->tagged_supported) ++ scsi_activate_tcq(sdev, FC_FCP_DFLT_QUEUE_DEPTH); ++ else ++ scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), ++ FC_FCP_DFLT_QUEUE_DEPTH); ++ + return 0; + } + EXPORT_SYMBOL(fc_slave_alloc); +diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c +index bd2f771..536492a 100644 +--- a/drivers/scsi/libfc/fc_lport.c ++++ b/drivers/scsi/libfc/fc_lport.c +@@ -329,7 +329,7 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type) + * @sp: current sequence in the RLIR exchange + * @fp: RLIR request frame + * +- * Locking Note: The lport lock is exected to be held before calling ++ * Locking Note: The lport lock is expected to be held before calling + * this function. + */ + static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp, +@@ -348,7 +348,7 @@ static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp, + * @sp: current sequence in the ECHO exchange + * @fp: ECHO request frame + * +- * Locking Note: The lport lock is exected to be held before calling ++ * Locking Note: The lport lock is expected to be held before calling + * this function. + */ + static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp, +@@ -361,7 +361,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp, + void *dp; + u32 f_ctl; + +- FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n", ++ FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n", + fc_lport_state(lport)); + + len = fr_len(in_fp) - sizeof(struct fc_frame_header); +@@ -374,7 +374,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp, + if (fp) { + dp = fc_frame_payload_get(fp, len); + memcpy(dp, pp, len); +- *((u32 *)dp) = htonl(ELS_LS_ACC << 24); ++ *((__be32 *)dp) = htonl(ELS_LS_ACC << 24); + sp = lport->tt.seq_start_next(sp); + f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ; + fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid, +@@ -385,12 +385,12 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp, + } + + /** +- * fc_lport_recv_echo_req() - Handle received Request Node ID data request +- * @lport: Fibre Channel local port recieving the RNID +- * @sp: current sequence in the RNID exchange +- * @fp: RNID request frame ++ * fc_lport_recv_rnid_req() - Handle received Request Node ID data request ++ * @sp: The sequence in the RNID exchange ++ * @fp: The RNID request frame ++ * @lport: The local port recieving the RNID + * +- * Locking Note: The lport lock is exected to be held before calling ++ * Locking Note: The lport lock is expected to be held before calling + * this function. + */ + static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp, +@@ -667,7 +667,7 @@ static void fc_lport_enter_ready(struct fc_lport *lport) + * Accept it with the common service parameters indicating our N port. + * Set up to do a PLOGI if we have the higher-number WWPN. + * +- * Locking Note: The lport lock is exected to be held before calling ++ * Locking Note: The lport lock is expected to be held before calling + * this function. + */ + static void fc_lport_recv_flogi_req(struct fc_seq *sp_in, +@@ -1115,7 +1115,7 @@ static void fc_lport_enter_scr(struct fc_lport *lport) + + if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR, + fc_lport_scr_resp, lport, lport->e_d_tov)) +- fc_lport_error(lport, fp); ++ fc_lport_error(lport, NULL); + } + + /** +@@ -1186,7 +1186,7 @@ static void fc_lport_enter_rpn_id(struct fc_lport *lport) + if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RPN_ID, + fc_lport_rpn_id_resp, + lport, lport->e_d_tov)) +- fc_lport_error(lport, fp); ++ fc_lport_error(lport, NULL); + } + + static struct fc_rport_operations fc_lport_rport_ops = { +@@ -1237,10 +1237,13 @@ static void fc_lport_timeout(struct work_struct *work) + + switch (lport->state) { + case LPORT_ST_DISABLED: ++ WARN_ON(1); ++ break; + case LPORT_ST_READY: +- case LPORT_ST_RESET: + WARN_ON(1); + break; ++ case LPORT_ST_RESET: ++ break; + case LPORT_ST_FLOGI: + fc_lport_enter_flogi(lport); + break; +@@ -1337,7 +1340,7 @@ static void fc_lport_enter_logo(struct fc_lport *lport) + + if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO, + fc_lport_logo_resp, lport, lport->e_d_tov)) +- fc_lport_error(lport, fp); ++ fc_lport_error(lport, NULL); + } + + /** +@@ -1453,7 +1456,7 @@ void fc_lport_enter_flogi(struct fc_lport *lport) + + if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_FLOGI, + fc_lport_flogi_resp, lport, lport->e_d_tov)) +- fc_lport_error(lport, fp); ++ fc_lport_error(lport, NULL); + } + + /* Configure a fc_lport */ +diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c +index 03ea674..ff558a6 100644 +--- a/drivers/scsi/libfc/fc_rport.c ++++ b/drivers/scsi/libfc/fc_rport.c +@@ -86,6 +86,7 @@ static const char *fc_rport_state_names[] = { + [RPORT_ST_LOGO] = "LOGO", + [RPORT_ST_ADISC] = "ADISC", + [RPORT_ST_DELETE] = "Delete", ++ [RPORT_ST_RESTART] = "Restart", + }; + + /** +@@ -99,8 +100,7 @@ static struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport, + struct fc_rport_priv *rdata; + + list_for_each_entry(rdata, &lport->disc.rports, peers) +- if (rdata->ids.port_id == port_id && +- rdata->rp_state != RPORT_ST_DELETE) ++ if (rdata->ids.port_id == port_id) + return rdata; + return NULL; + } +@@ -235,6 +235,7 @@ static void fc_rport_work(struct work_struct *work) + struct fc_rport_operations *rport_ops; + struct fc_rport_identifiers ids; + struct fc_rport *rport; ++ int restart = 0; + + mutex_lock(&rdata->rp_mutex); + event = rdata->event; +@@ -287,8 +288,20 @@ static void fc_rport_work(struct work_struct *work) + mutex_unlock(&rdata->rp_mutex); + + if (port_id != FC_FID_DIR_SERV) { ++ /* ++ * We must drop rp_mutex before taking disc_mutex. ++ * Re-evaluate state to allow for restart. ++ * A transition to RESTART state must only happen ++ * while disc_mutex is held and rdata is on the list. ++ */ + mutex_lock(&lport->disc.disc_mutex); +- list_del(&rdata->peers); ++ mutex_lock(&rdata->rp_mutex); ++ if (rdata->rp_state == RPORT_ST_RESTART) ++ restart = 1; ++ else ++ list_del(&rdata->peers); ++ rdata->event = RPORT_EV_NONE; ++ mutex_unlock(&rdata->rp_mutex); + mutex_unlock(&lport->disc.disc_mutex); + } + +@@ -312,7 +325,13 @@ static void fc_rport_work(struct work_struct *work) + mutex_unlock(&rdata->rp_mutex); + fc_remote_port_delete(rport); + } +- kref_put(&rdata->kref, lport->tt.rport_destroy); ++ if (restart) { ++ mutex_lock(&rdata->rp_mutex); ++ FC_RPORT_DBG(rdata, "work restart\n"); ++ fc_rport_enter_plogi(rdata); ++ mutex_unlock(&rdata->rp_mutex); ++ } else ++ kref_put(&rdata->kref, lport->tt.rport_destroy); + break; + + default: +@@ -342,6 +361,12 @@ int fc_rport_login(struct fc_rport_priv *rdata) + FC_RPORT_DBG(rdata, "ADISC port\n"); + fc_rport_enter_adisc(rdata); + break; ++ case RPORT_ST_RESTART: ++ break; ++ case RPORT_ST_DELETE: ++ FC_RPORT_DBG(rdata, "Restart deleted port\n"); ++ fc_rport_state_enter(rdata, RPORT_ST_RESTART); ++ break; + default: + FC_RPORT_DBG(rdata, "Login to port\n"); + fc_rport_enter_plogi(rdata); +@@ -397,20 +422,21 @@ int fc_rport_logoff(struct fc_rport_priv *rdata) + + if (rdata->rp_state == RPORT_ST_DELETE) { + FC_RPORT_DBG(rdata, "Port in Delete state, not removing\n"); +- mutex_unlock(&rdata->rp_mutex); + goto out; + } + +- fc_rport_enter_logo(rdata); ++ if (rdata->rp_state == RPORT_ST_RESTART) ++ FC_RPORT_DBG(rdata, "Port in Restart state, deleting\n"); ++ else ++ fc_rport_enter_logo(rdata); + + /* + * Change the state to Delete so that we discard + * the response. + */ + fc_rport_enter_delete(rdata, RPORT_EV_STOP); +- mutex_unlock(&rdata->rp_mutex); +- + out: ++ mutex_unlock(&rdata->rp_mutex); + return 0; + } + +@@ -466,6 +492,7 @@ static void fc_rport_timeout(struct work_struct *work) + case RPORT_ST_READY: + case RPORT_ST_INIT: + case RPORT_ST_DELETE: ++ case RPORT_ST_RESTART: + break; + } + +@@ -499,6 +526,7 @@ static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp) + fc_rport_enter_logo(rdata); + break; + case RPORT_ST_DELETE: ++ case RPORT_ST_RESTART: + case RPORT_ST_READY: + case RPORT_ST_INIT: + break; +@@ -632,7 +660,7 @@ static void fc_rport_enter_plogi(struct fc_rport_priv *rdata) + + if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PLOGI, + fc_rport_plogi_resp, rdata, lport->e_d_tov)) +- fc_rport_error_retry(rdata, fp); ++ fc_rport_error_retry(rdata, NULL); + else + kref_get(&rdata->kref); + } +@@ -793,7 +821,7 @@ static void fc_rport_enter_prli(struct fc_rport_priv *rdata) + + if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PRLI, + fc_rport_prli_resp, rdata, lport->e_d_tov)) +- fc_rport_error_retry(rdata, fp); ++ fc_rport_error_retry(rdata, NULL); + else + kref_get(&rdata->kref); + } +@@ -889,7 +917,7 @@ static void fc_rport_enter_rtv(struct fc_rport_priv *rdata) + + if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_RTV, + fc_rport_rtv_resp, rdata, lport->e_d_tov)) +- fc_rport_error_retry(rdata, fp); ++ fc_rport_error_retry(rdata, NULL); + else + kref_get(&rdata->kref); + } +@@ -919,7 +947,7 @@ static void fc_rport_enter_logo(struct fc_rport_priv *rdata) + + if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_LOGO, + fc_rport_logo_resp, rdata, lport->e_d_tov)) +- fc_rport_error_retry(rdata, fp); ++ fc_rport_error_retry(rdata, NULL); + else + kref_get(&rdata->kref); + } +@@ -1006,7 +1034,7 @@ static void fc_rport_enter_adisc(struct fc_rport_priv *rdata) + } + if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_ADISC, + fc_rport_adisc_resp, rdata, lport->e_d_tov)) +- fc_rport_error_retry(rdata, fp); ++ fc_rport_error_retry(rdata, NULL); + else + kref_get(&rdata->kref); + } +@@ -1248,6 +1276,7 @@ static void fc_rport_recv_plogi_req(struct fc_lport *lport, + } + break; + case RPORT_ST_PRLI: ++ case RPORT_ST_RTV: + case RPORT_ST_READY: + case RPORT_ST_ADISC: + FC_RPORT_DBG(rdata, "Received PLOGI in logged-in state %d " +@@ -1255,11 +1284,14 @@ static void fc_rport_recv_plogi_req(struct fc_lport *lport, + /* XXX TBD - should reset */ + break; + case RPORT_ST_DELETE: +- default: +- FC_RPORT_DBG(rdata, "Received PLOGI in unexpected state %d\n", +- rdata->rp_state); +- fc_frame_free(rx_fp); +- goto out; ++ case RPORT_ST_LOGO: ++ case RPORT_ST_RESTART: ++ FC_RPORT_DBG(rdata, "Received PLOGI in state %s - send busy\n", ++ fc_rport_state(rdata)); ++ mutex_unlock(&rdata->rp_mutex); ++ rjt_data.reason = ELS_RJT_BUSY; ++ rjt_data.explan = ELS_EXPL_NONE; ++ goto reject; + } + + /* +@@ -1402,7 +1434,7 @@ static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata, + break; + case FC_TYPE_FCP: + fcp_parm = ntohl(rspp->spp_params); +- if (fcp_parm * FCP_SPPF_RETRY) ++ if (fcp_parm & FCP_SPPF_RETRY) + rdata->flags |= FC_RP_FLAGS_RETRY; + rdata->supported_classes = FC_COS_CLASS3; + if (fcp_parm & FCP_SPPF_INIT_FCN) +@@ -1510,14 +1542,14 @@ static void fc_rport_recv_logo_req(struct fc_lport *lport, + FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n", + fc_rport_state(rdata)); + ++ fc_rport_enter_delete(rdata, RPORT_EV_LOGO); ++ + /* +- * If the remote port was created due to discovery, +- * log back in. It may have seen a stale RSCN about us. ++ * If the remote port was created due to discovery, set state ++ * to log back in. It may have seen a stale RSCN about us. + */ +- if (rdata->rp_state != RPORT_ST_DELETE && rdata->disc_id) +- fc_rport_enter_plogi(rdata); +- else +- fc_rport_enter_delete(rdata, RPORT_EV_LOGO); ++ if (rdata->disc_id) ++ fc_rport_state_enter(rdata, RPORT_ST_RESTART); + mutex_unlock(&rdata->rp_mutex); + } else + FC_RPORT_ID_DBG(lport, sid, +diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c +index f913f1e..549bc7d 100644 +--- a/drivers/scsi/lpfc/lpfc_init.c ++++ b/drivers/scsi/lpfc/lpfc_init.c +@@ -4384,9 +4384,13 @@ lpfc_sli_pci_mem_setup(struct lpfc_hba *phba) + pdev = phba->pcidev; + + /* Set the device DMA mask size */ +- if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) +- if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) ++ if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0 ++ || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) { ++ if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0 ++ || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) { + return error; ++ } ++ } + + /* Get the bus address of Bar0 and Bar2 and the number of bytes + * required by each mapping. +@@ -5940,9 +5944,13 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba) + pdev = phba->pcidev; + + /* Set the device DMA mask size */ +- if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) +- if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) ++ if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0 ++ || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) { ++ if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0 ++ || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) { + return error; ++ } ++ } + + /* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the + * number of bytes required by each mapping. They are actually +diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h +index ab47c46..5af66db 100644 +--- a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h ++++ b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h +@@ -348,6 +348,14 @@ typedef struct _MPI2_CONFIG_REPLY + #define MPI2_MFGPAGE_DEVID_SAS2108_3 (0x0077) + #define MPI2_MFGPAGE_DEVID_SAS2116_1 (0x0064) + #define MPI2_MFGPAGE_DEVID_SAS2116_2 (0x0065) ++#define MPI2_MFGPAGE_DEVID_SAS2208_1 (0x0080) ++#define MPI2_MFGPAGE_DEVID_SAS2208_2 (0x0081) ++#define MPI2_MFGPAGE_DEVID_SAS2208_3 (0x0082) ++#define MPI2_MFGPAGE_DEVID_SAS2208_4 (0x0083) ++#define MPI2_MFGPAGE_DEVID_SAS2208_5 (0x0084) ++#define MPI2_MFGPAGE_DEVID_SAS2208_6 (0x0085) ++#define MPI2_MFGPAGE_DEVID_SAS2208_7 (0x0086) ++#define MPI2_MFGPAGE_DEVID_SAS2208_8 (0x0087) + + + /* Manufacturing Page 0 */ +diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c +index 86ab32d..1743640 100644 +--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c ++++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c +@@ -196,10 +196,28 @@ static struct pci_device_id scsih_pci_table[] = { + PCI_ANY_ID, PCI_ANY_ID }, + { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3, + PCI_ANY_ID, PCI_ANY_ID }, ++ /* Meteor ~ 2116 */ + { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1, + PCI_ANY_ID, PCI_ANY_ID }, + { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2, + PCI_ANY_ID, PCI_ANY_ID }, ++ /* Thunderbolt ~ 2208 */ ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_7, ++ PCI_ANY_ID, PCI_ANY_ID }, ++ { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_8, ++ PCI_ANY_ID, PCI_ANY_ID }, + {0} /* Terminating entry */ + }; + MODULE_DEVICE_TABLE(pci, scsih_pci_table); +diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c +index 93c2622..802e91c 100644 +--- a/drivers/scsi/scsi_devinfo.c ++++ b/drivers/scsi/scsi_devinfo.c +@@ -168,11 +168,10 @@ static struct { + {"Generic", "USB SD Reader", "1.00", BLIST_FORCELUN | BLIST_INQUIRY_36}, + {"Generic", "USB Storage-SMC", "0180", BLIST_FORCELUN | BLIST_INQUIRY_36}, + {"Generic", "USB Storage-SMC", "0207", BLIST_FORCELUN | BLIST_INQUIRY_36}, +- {"HITACHI", "DF400", "*", BLIST_SPARSELUN}, +- {"HITACHI", "DF500", "*", BLIST_SPARSELUN}, +- {"HITACHI", "DF600", "*", BLIST_SPARSELUN}, +- {"HITACHI", "DISK-SUBSYSTEM", "*", BLIST_ATTACH_PQ3 | BLIST_SPARSELUN | BLIST_LARGELUN}, +- {"HITACHI", "OPEN-E", "*", BLIST_ATTACH_PQ3 | BLIST_SPARSELUN | BLIST_LARGELUN}, ++ {"HITACHI", "DF400", "*", BLIST_REPORTLUN2}, ++ {"HITACHI", "DF500", "*", BLIST_REPORTLUN2}, ++ {"HITACHI", "DISK-SUBSYSTEM", "*", BLIST_REPORTLUN2}, ++ {"HITACHI", "OPEN-", "*", BLIST_REPORTLUN2}, + {"HITACHI", "OP-C-", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, + {"HITACHI", "3380-", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, + {"HITACHI", "3390-", "*", BLIST_SPARSELUN | BLIST_LARGELUN}, +diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c +index 45be82f..bf52dec 100644 +--- a/drivers/scsi/scsi_transport_fc.c ++++ b/drivers/scsi/scsi_transport_fc.c +@@ -2395,6 +2395,7 @@ fc_rport_final_delete(struct work_struct *work) + struct Scsi_Host *shost = rport_to_shost(rport); + struct fc_internal *i = to_fc_internal(shost->transportt); + unsigned long flags; ++ int do_callback = 0; + + /* + * if a scan is pending, flush the SCSI Host work_q so that +@@ -2433,8 +2434,15 @@ fc_rport_final_delete(struct work_struct *work) + * Avoid this call if we already called it when we preserved the + * rport for the binding. + */ ++ spin_lock_irqsave(shost->host_lock, flags); + if (!(rport->flags & FC_RPORT_DEVLOSS_CALLBK_DONE) && +- (i->f->dev_loss_tmo_callbk)) ++ (i->f->dev_loss_tmo_callbk)) { ++ rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE; ++ do_callback = 1; ++ } ++ spin_unlock_irqrestore(shost->host_lock, flags); ++ ++ if (do_callback) + i->f->dev_loss_tmo_callbk(rport); + + fc_bsg_remove(rport->rqst_q); +@@ -2981,6 +2989,7 @@ fc_timeout_deleted_rport(struct work_struct *work) + struct fc_internal *i = to_fc_internal(shost->transportt); + struct fc_host_attrs *fc_host = shost_to_fc_host(shost); + unsigned long flags; ++ int do_callback = 0; + + spin_lock_irqsave(shost->host_lock, flags); + +@@ -3046,7 +3055,6 @@ fc_timeout_deleted_rport(struct work_struct *work) + rport->roles = FC_PORT_ROLE_UNKNOWN; + rport->port_state = FC_PORTSTATE_NOTPRESENT; + rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT; +- rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE; + + /* + * Pre-emptively kill I/O rather than waiting for the work queue +@@ -3056,32 +3064,40 @@ fc_timeout_deleted_rport(struct work_struct *work) + spin_unlock_irqrestore(shost->host_lock, flags); + fc_terminate_rport_io(rport); + +- BUG_ON(rport->port_state != FC_PORTSTATE_NOTPRESENT); ++ spin_lock_irqsave(shost->host_lock, flags); + +- /* remove the identifiers that aren't used in the consisting binding */ +- switch (fc_host->tgtid_bind_type) { +- case FC_TGTID_BIND_BY_WWPN: +- rport->node_name = -1; +- rport->port_id = -1; +- break; +- case FC_TGTID_BIND_BY_WWNN: +- rport->port_name = -1; +- rport->port_id = -1; +- break; +- case FC_TGTID_BIND_BY_ID: +- rport->node_name = -1; +- rport->port_name = -1; +- break; +- case FC_TGTID_BIND_NONE: /* to keep compiler happy */ +- break; ++ if (rport->port_state == FC_PORTSTATE_NOTPRESENT) { /* still missing */ ++ ++ /* remove the identifiers that aren't used in the consisting binding */ ++ switch (fc_host->tgtid_bind_type) { ++ case FC_TGTID_BIND_BY_WWPN: ++ rport->node_name = -1; ++ rport->port_id = -1; ++ break; ++ case FC_TGTID_BIND_BY_WWNN: ++ rport->port_name = -1; ++ rport->port_id = -1; ++ break; ++ case FC_TGTID_BIND_BY_ID: ++ rport->node_name = -1; ++ rport->port_name = -1; ++ break; ++ case FC_TGTID_BIND_NONE: /* to keep compiler happy */ ++ break; ++ } ++ ++ /* ++ * As this only occurs if the remote port (scsi target) ++ * went away and didn't come back - we'll remove ++ * all attached scsi devices. ++ */ ++ rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE; ++ fc_queue_work(shost, &rport->stgt_delete_work); ++ ++ do_callback = 1; + } + +- /* +- * As this only occurs if the remote port (scsi target) +- * went away and didn't come back - we'll remove +- * all attached scsi devices. +- */ +- fc_queue_work(shost, &rport->stgt_delete_work); ++ spin_unlock_irqrestore(shost->host_lock, flags); + + /* + * Notify the driver that the rport is now dead. The LLDD will +@@ -3089,7 +3105,7 @@ fc_timeout_deleted_rport(struct work_struct *work) + * + * Note: we set the CALLBK_DONE flag above to correspond + */ +- if (i->f->dev_loss_tmo_callbk) ++ if (do_callback && i->f->dev_loss_tmo_callbk) + i->f->dev_loss_tmo_callbk(rport); + } + +diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c +index ad897df..de2f8c4 100644 +--- a/drivers/scsi/scsi_transport_iscsi.c ++++ b/drivers/scsi/scsi_transport_iscsi.c +@@ -627,8 +627,10 @@ static void __iscsi_block_session(struct work_struct *work) + spin_unlock_irqrestore(&session->lock, flags); + scsi_target_block(&session->dev); + ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n"); +- queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work, +- session->recovery_tmo * HZ); ++ if (session->recovery_tmo >= 0) ++ queue_delayed_work(iscsi_eh_timer_workq, ++ &session->recovery_work, ++ session->recovery_tmo * HZ); + } + + void iscsi_block_session(struct iscsi_cls_session *session) +@@ -1348,8 +1350,7 @@ iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev) + switch (ev->u.set_param.param) { + case ISCSI_PARAM_SESS_RECOVERY_TMO: + sscanf(data, "%d", &value); +- if (value != 0) +- session->recovery_tmo = value; ++ session->recovery_tmo = value; + break; + default: + err = transport->set_param(conn, ev->u.set_param.param, +diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c +index ebcc6d0..13a1b39 100644 +--- a/drivers/usb/serial/ftdi_sio.c ++++ b/drivers/usb/serial/ftdi_sio.c +@@ -598,6 +598,20 @@ static struct usb_device_id id_table_combined [] = { + { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) }, + { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) }, + { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) }, ++ { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) }, + { 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) }, +diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h +index 6f31e0d..4586a24 100644 +--- a/drivers/usb/serial/ftdi_sio.h ++++ b/drivers/usb/serial/ftdi_sio.h +@@ -662,6 +662,20 @@ + #define BANDB_USOTL4_PID 0xAC01 /* USOTL4 Isolated RS-485 Converter */ + #define BANDB_USTL4_PID 0xAC02 /* USTL4 RS-485 Converter */ + #define BANDB_USO9ML2_PID 0xAC03 /* USO9ML2 Isolated RS-232 Converter */ ++#define BANDB_USOPTL4_PID 0xAC11 ++#define BANDB_USPTL4_PID 0xAC12 ++#define BANDB_USO9ML2DR_2_PID 0xAC16 ++#define BANDB_USO9ML2DR_PID 0xAC17 ++#define BANDB_USOPTL4DR2_PID 0xAC18 /* USOPTL4R-2 2-port Isolated RS-232 Converter */ ++#define BANDB_USOPTL4DR_PID 0xAC19 ++#define BANDB_485USB9F_2W_PID 0xAC25 ++#define BANDB_485USB9F_4W_PID 0xAC26 ++#define BANDB_232USB9M_PID 0xAC27 ++#define BANDB_485USBTB_2W_PID 0xAC33 ++#define BANDB_485USBTB_4W_PID 0xAC34 ++#define BANDB_TTL5USB9M_PID 0xAC49 ++#define BANDB_TTL3USB9M_PID 0xAC50 ++#define BANDB_ZZ_PROG1_USB_PID 0xBA02 + + /* + * RM Michaelides CANview USB (http://www.rmcan.com) +diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c +index f11abf5..485fa9c 100644 +--- a/drivers/usb/serial/mos7840.c ++++ b/drivers/usb/serial/mos7840.c +@@ -121,8 +121,14 @@ + * moschip_id_table_combined + */ + #define USB_VENDOR_ID_BANDB 0x0856 +-#define BANDB_DEVICE_ID_USOPTL4_4 0xAC44 ++#define BANDB_DEVICE_ID_USO9ML2_2 0xAC22 ++#define BANDB_DEVICE_ID_USO9ML2_4 0xAC24 ++#define BANDB_DEVICE_ID_US9ML2_2 0xAC29 ++#define BANDB_DEVICE_ID_US9ML2_4 0xAC30 ++#define BANDB_DEVICE_ID_USPTL4_2 0xAC31 ++#define BANDB_DEVICE_ID_USPTL4_4 0xAC32 + #define BANDB_DEVICE_ID_USOPTL4_2 0xAC42 ++#define BANDB_DEVICE_ID_USOPTL4_4 0xAC44 + + /* This driver also supports + * ATEN UC2324 device using Moschip MCS7840 +@@ -177,8 +183,14 @@ + static struct usb_device_id moschip_port_id_table[] = { + {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)}, + {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)}, +- {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)}, + {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)}, + {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)}, + {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)}, + {} /* terminating entry */ +@@ -187,8 +199,14 @@ static struct usb_device_id moschip_port_id_table[] = { + static __devinitdata struct usb_device_id moschip_id_table_combined[] = { + {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7840)}, + {USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7820)}, +- {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USO9ML2_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_US9ML2_4)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USPTL4_4)}, + {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_2)}, ++ {USB_DEVICE(USB_VENDOR_ID_BANDB, BANDB_DEVICE_ID_USOPTL4_4)}, + {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2324)}, + {USB_DEVICE(USB_VENDOR_ID_ATENINTL, ATENINTL_DEVICE_ID_UC2322)}, + {} /* terminating entry */ +diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c +index 6a51edd..4bdb7f1 100644 +--- a/drivers/watchdog/iTCO_wdt.c ++++ b/drivers/watchdog/iTCO_wdt.c +@@ -1,5 +1,5 @@ + /* +- * intel TCO Watchdog Driver (Used in i82801 and i63xxESB chipsets) ++ * intel TCO Watchdog Driver + * + * (c) Copyright 2006-2009 Wim Van Sebroeck . + * +@@ -14,47 +14,24 @@ + * + * The TCO watchdog is implemented in the following I/O controller hubs: + * (See the intel documentation on http://developer.intel.com.) +- * 82801AA (ICH) : document number 290655-003, 290677-014, +- * 82801AB (ICHO) : document number 290655-003, 290677-014, +- * 82801BA (ICH2) : document number 290687-002, 298242-027, +- * 82801BAM (ICH2-M) : document number 290687-002, 298242-027, +- * 82801CA (ICH3-S) : document number 290733-003, 290739-013, +- * 82801CAM (ICH3-M) : document number 290716-001, 290718-007, +- * 82801DB (ICH4) : document number 290744-001, 290745-025, +- * 82801DBM (ICH4-M) : document number 252337-001, 252663-008, +- * 82801E (C-ICH) : document number 273599-001, 273645-002, +- * 82801EB (ICH5) : document number 252516-001, 252517-028, +- * 82801ER (ICH5R) : document number 252516-001, 252517-028, +- * 6300ESB (6300ESB) : document number 300641-004, 300884-013, +- * 82801FB (ICH6) : document number 301473-002, 301474-026, +- * 82801FR (ICH6R) : document number 301473-002, 301474-026, +- * 82801FBM (ICH6-M) : document number 301473-002, 301474-026, +- * 82801FW (ICH6W) : document number 301473-001, 301474-026, +- * 82801FRW (ICH6RW) : document number 301473-001, 301474-026, +- * 631xESB (631xESB) : document number 313082-001, 313075-006, +- * 632xESB (632xESB) : document number 313082-001, 313075-006, +- * 82801GB (ICH7) : document number 307013-003, 307014-024, +- * 82801GR (ICH7R) : document number 307013-003, 307014-024, +- * 82801GDH (ICH7DH) : document number 307013-003, 307014-024, +- * 82801GBM (ICH7-M) : document number 307013-003, 307014-024, +- * 82801GHM (ICH7-M DH) : document number 307013-003, 307014-024, +- * 82801GU (ICH7-U) : document number 307013-003, 307014-024, +- * 82801HB (ICH8) : document number 313056-003, 313057-017, +- * 82801HR (ICH8R) : document number 313056-003, 313057-017, +- * 82801HBM (ICH8M) : document number 313056-003, 313057-017, +- * 82801HH (ICH8DH) : document number 313056-003, 313057-017, +- * 82801HO (ICH8DO) : document number 313056-003, 313057-017, +- * 82801HEM (ICH8M-E) : document number 313056-003, 313057-017, +- * 82801IB (ICH9) : document number 316972-004, 316973-012, +- * 82801IR (ICH9R) : document number 316972-004, 316973-012, +- * 82801IH (ICH9DH) : document number 316972-004, 316973-012, +- * 82801IO (ICH9DO) : document number 316972-004, 316973-012, +- * 82801IBM (ICH9M) : document number 316972-004, 316973-012, +- * 82801IEM (ICH9M-E) : document number 316972-004, 316973-012, +- * 82801JIB (ICH10) : document number 319973-002, 319974-002, +- * 82801JIR (ICH10R) : document number 319973-002, 319974-002, +- * 82801JD (ICH10D) : document number 319973-002, 319974-002, +- * 82801JDO (ICH10DO) : document number 319973-002, 319974-002 ++ * document number 290655-003, 290677-014: 82801AA (ICH), 82801AB (ICHO) ++ * document number 290687-002, 298242-027: 82801BA (ICH2) ++ * document number 290733-003, 290739-013: 82801CA (ICH3-S) ++ * document number 290716-001, 290718-007: 82801CAM (ICH3-M) ++ * document number 290744-001, 290745-025: 82801DB (ICH4) ++ * document number 252337-001, 252663-008: 82801DBM (ICH4-M) ++ * document number 273599-001, 273645-002: 82801E (C-ICH) ++ * document number 252516-001, 252517-028: 82801EB (ICH5), 82801ER (ICH5R) ++ * document number 300641-004, 300884-013: 6300ESB ++ * document number 301473-002, 301474-026: 82801F (ICH6) ++ * document number 313082-001, 313075-006: 631xESB, 632xESB ++ * document number 307013-003, 307014-024: 82801G (ICH7) ++ * document number 313056-003, 313057-017: 82801H (ICH8) ++ * document number 316972-004, 316973-012: 82801I (ICH9) ++ * document number 319973-002, 319974-002: 82801J (ICH10) ++ * document number 322169-001, 322170-003: 5 Series, 3400 Series (PCH) ++ * document number 320066-003, 320257-008: EP80597 (IICH) ++ * document number TBD : Cougar Point (CPT) + */ + + /* +@@ -122,6 +99,24 @@ enum iTCO_chipsets { + TCO_ICH10R, /* ICH10R */ + TCO_ICH10D, /* ICH10D */ + TCO_ICH10DO, /* ICH10DO */ ++ TCO_PCH, /* PCH Desktop Full Featured */ ++ TCO_PCHM, /* PCH Mobile Full Featured */ ++ TCO_P55, /* P55 */ ++ TCO_PM55, /* PM55 */ ++ TCO_H55, /* H55 */ ++ TCO_QM57, /* QM57 */ ++ TCO_H57, /* H57 */ ++ TCO_HM55, /* HM55 */ ++ TCO_Q57, /* Q57 */ ++ TCO_HM57, /* HM57 */ ++ TCO_PCHMSFF, /* PCH Mobile SFF Full Featured */ ++ TCO_QS57, /* QS57 */ ++ TCO_3400, /* 3400 */ ++ TCO_3420, /* 3420 */ ++ TCO_3450, /* 3450 */ ++ TCO_EP80579, /* EP80579 */ ++ TCO_CPTD, /* CPT Desktop */ ++ TCO_CPTM, /* CPT Mobile */ + }; + + static struct { +@@ -162,6 +157,24 @@ static struct { + {"ICH10R", 2}, + {"ICH10D", 2}, + {"ICH10DO", 2}, ++ {"PCH Desktop Full Featured", 2}, ++ {"PCH Mobile Full Featured", 2}, ++ {"P55", 2}, ++ {"PM55", 2}, ++ {"H55", 2}, ++ {"QM57", 2}, ++ {"H57", 2}, ++ {"HM55", 2}, ++ {"Q57", 2}, ++ {"HM57", 2}, ++ {"PCH Mobile SFF Full Featured", 2}, ++ {"QS57", 2}, ++ {"3400", 2}, ++ {"3420", 2}, ++ {"3450", 2}, ++ {"EP80579", 2}, ++ {"CPT Desktop", 2}, ++ {"CPT Mobile", 2}, + {NULL, 0} + }; + +@@ -230,6 +243,24 @@ static struct pci_device_id iTCO_wdt_pci_tbl[] = { + { ITCO_PCI_DEVICE(0x3a16, TCO_ICH10R)}, + { ITCO_PCI_DEVICE(0x3a1a, TCO_ICH10D)}, + { ITCO_PCI_DEVICE(0x3a14, TCO_ICH10DO)}, ++ { ITCO_PCI_DEVICE(0x3b00, TCO_PCH)}, ++ { ITCO_PCI_DEVICE(0x3b01, TCO_PCHM)}, ++ { ITCO_PCI_DEVICE(0x3b02, TCO_P55)}, ++ { ITCO_PCI_DEVICE(0x3b03, TCO_PM55)}, ++ { ITCO_PCI_DEVICE(0x3b06, TCO_H55)}, ++ { ITCO_PCI_DEVICE(0x3b07, TCO_QM57)}, ++ { ITCO_PCI_DEVICE(0x3b08, TCO_H57)}, ++ { ITCO_PCI_DEVICE(0x3b09, TCO_HM55)}, ++ { ITCO_PCI_DEVICE(0x3b0a, TCO_Q57)}, ++ { ITCO_PCI_DEVICE(0x3b0b, TCO_HM57)}, ++ { ITCO_PCI_DEVICE(0x3b0d, TCO_PCHMSFF)}, ++ { ITCO_PCI_DEVICE(0x3b0f, TCO_QS57)}, ++ { ITCO_PCI_DEVICE(0x3b12, TCO_3400)}, ++ { ITCO_PCI_DEVICE(0x3b14, TCO_3420)}, ++ { ITCO_PCI_DEVICE(0x3b16, TCO_3450)}, ++ { ITCO_PCI_DEVICE(0x5031, TCO_EP80579)}, ++ { ITCO_PCI_DEVICE(0x1c42, TCO_CPTD)}, ++ { ITCO_PCI_DEVICE(0x1c43, TCO_CPTM)}, + { 0, }, /* End of list */ + }; + MODULE_DEVICE_TABLE(pci, iTCO_wdt_pci_tbl); +diff --git a/fs/fcntl.c b/fs/fcntl.c +index 97e01dc..5ef953e 100644 +--- a/fs/fcntl.c ++++ b/fs/fcntl.c +@@ -199,7 +199,9 @@ static int setfl(int fd, struct file * filp, unsigned long arg) + static void f_modown(struct file *filp, struct pid *pid, enum pid_type type, + int force) + { +- write_lock_irq(&filp->f_owner.lock); ++ unsigned long flags; ++ ++ write_lock_irqsave(&filp->f_owner.lock, flags); + if (force || !filp->f_owner.pid) { + put_pid(filp->f_owner.pid); + filp->f_owner.pid = get_pid(pid); +@@ -211,7 +213,7 @@ static void f_modown(struct file *filp, struct pid *pid, enum pid_type type, + filp->f_owner.euid = cred->euid; + } + } +- write_unlock_irq(&filp->f_owner.lock); ++ write_unlock_irqrestore(&filp->f_owner.lock, flags); + } + + int __f_setown(struct file *filp, struct pid *pid, enum pid_type type, +diff --git a/fs/nfs/super.c b/fs/nfs/super.c +index 90be551..e71f0fd 100644 +--- a/fs/nfs/super.c ++++ b/fs/nfs/super.c +@@ -734,8 +734,6 @@ static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(unsigned int ve + + data = kzalloc(sizeof(*data), GFP_KERNEL); + if (data) { +- data->rsize = NFS_MAX_FILE_IO_SIZE; +- data->wsize = NFS_MAX_FILE_IO_SIZE; + data->acregmin = NFS_DEF_ACREGMIN; + data->acregmax = NFS_DEF_ACREGMAX; + data->acdirmin = NFS_DEF_ACDIRMIN; +diff --git a/fs/nfsd/nfs4acl.c b/fs/nfsd/nfs4acl.c +index 725d02f..6d9c6aa 100644 +--- a/fs/nfsd/nfs4acl.c ++++ b/fs/nfsd/nfs4acl.c +@@ -389,7 +389,7 @@ sort_pacl(struct posix_acl *pacl) + sort_pacl_range(pacl, 1, i-1); + + BUG_ON(pacl->a_entries[i].e_tag != ACL_GROUP_OBJ); +- j = i++; ++ j = ++i; + while (pacl->a_entries[j].e_tag == ACL_GROUP) + j++; + sort_pacl_range(pacl, i, j-1); +diff --git a/fs/partitions/efi.c b/fs/partitions/efi.c +index 038a602..49cfd5f 100644 +--- a/fs/partitions/efi.c ++++ b/fs/partitions/efi.c +@@ -1,7 +1,9 @@ + /************************************************************ + * EFI GUID Partition Table handling +- * Per Intel EFI Specification v1.02 +- * http://developer.intel.com/technology/efi/efi.htm ++ * ++ * http://www.uefi.org/specs/ ++ * http://www.intel.com/technology/efi/ ++ * + * efi.[ch] by Matt Domsch + * Copyright 2000,2001,2002,2004 Dell Inc. + * +@@ -92,6 +94,7 @@ + * + ************************************************************/ + #include ++#include + #include "check.h" + #include "efi.h" + +@@ -141,7 +144,8 @@ last_lba(struct block_device *bdev) + { + if (!bdev || !bdev->bd_inode) + return 0; +- return (bdev->bd_inode->i_size >> 9) - 1ULL; ++ return div_u64(bdev->bd_inode->i_size, ++ bdev_logical_block_size(bdev)) - 1ULL; + } + + static inline int +@@ -188,6 +192,7 @@ static size_t + read_lba(struct block_device *bdev, u64 lba, u8 * buffer, size_t count) + { + size_t totalreadcount = 0; ++ sector_t n = lba * (bdev_logical_block_size(bdev) / 512); + + if (!bdev || !buffer || lba > last_lba(bdev)) + return 0; +@@ -195,7 +200,7 @@ read_lba(struct block_device *bdev, u64 lba, u8 * buffer, size_t count) + while (count) { + int copied = 512; + Sector sect; +- unsigned char *data = read_dev_sector(bdev, lba++, §); ++ unsigned char *data = read_dev_sector(bdev, n++, §); + if (!data) + break; + if (copied > count) +@@ -257,15 +262,16 @@ static gpt_header * + alloc_read_gpt_header(struct block_device *bdev, u64 lba) + { + gpt_header *gpt; ++ unsigned ssz = bdev_logical_block_size(bdev); ++ + if (!bdev) + return NULL; + +- gpt = kzalloc(sizeof (gpt_header), GFP_KERNEL); ++ gpt = kzalloc(ssz, GFP_KERNEL); + if (!gpt) + return NULL; + +- if (read_lba(bdev, lba, (u8 *) gpt, +- sizeof (gpt_header)) < sizeof (gpt_header)) { ++ if (read_lba(bdev, lba, (u8 *) gpt, ssz) < ssz) { + kfree(gpt); + gpt=NULL; + return NULL; +@@ -601,6 +607,7 @@ efi_partition(struct parsed_partitions *state, struct block_device *bdev) + gpt_header *gpt = NULL; + gpt_entry *ptes = NULL; + u32 i; ++ unsigned ssz = bdev_logical_block_size(bdev) / 512; + + if (!find_valid_gpt(bdev, &gpt, &ptes) || !gpt || !ptes) { + kfree(gpt); +@@ -611,13 +618,14 @@ efi_partition(struct parsed_partitions *state, struct block_device *bdev) + pr_debug("GUID Partition Table is valid! Yea!\n"); + + for (i = 0; i < le32_to_cpu(gpt->num_partition_entries) && i < state->limit-1; i++) { ++ u64 start = le64_to_cpu(ptes[i].starting_lba); ++ u64 size = le64_to_cpu(ptes[i].ending_lba) - ++ le64_to_cpu(ptes[i].starting_lba) + 1ULL; ++ + if (!is_pte_valid(&ptes[i], last_lba(bdev))) + continue; + +- put_partition(state, i+1, le64_to_cpu(ptes[i].starting_lba), +- (le64_to_cpu(ptes[i].ending_lba) - +- le64_to_cpu(ptes[i].starting_lba) + +- 1ULL)); ++ put_partition(state, i+1, start * ssz, size * ssz); + + /* If this is a RAID volume, tell md */ + if (!efi_guidcmp(ptes[i].partition_type_guid, +diff --git a/fs/partitions/efi.h b/fs/partitions/efi.h +index 2cc89d0..6998b58 100644 +--- a/fs/partitions/efi.h ++++ b/fs/partitions/efi.h +@@ -37,7 +37,6 @@ + #define EFI_PMBR_OSTYPE_EFI 0xEF + #define EFI_PMBR_OSTYPE_EFI_GPT 0xEE + +-#define GPT_BLOCK_SIZE 512 + #define GPT_HEADER_SIGNATURE 0x5452415020494645ULL + #define GPT_HEADER_REVISION_V1 0x00010000 + #define GPT_PRIMARY_PARTITION_TABLE_LBA 1 +@@ -79,7 +78,12 @@ typedef struct _gpt_header { + __le32 num_partition_entries; + __le32 sizeof_partition_entry; + __le32 partition_entry_array_crc32; +- u8 reserved2[GPT_BLOCK_SIZE - 92]; ++ ++ /* The rest of the logical block is reserved by UEFI and must be zero. ++ * EFI standard handles this by: ++ * ++ * uint8_t reserved2[ BlockSize - 92 ]; ++ */ + } __attribute__ ((packed)) gpt_header; + + typedef struct _gpt_entry_attributes { +diff --git a/fs/super.c b/fs/super.c +index 19eb70b..aff046b 100644 +--- a/fs/super.c ++++ b/fs/super.c +@@ -901,8 +901,9 @@ int get_sb_single(struct file_system_type *fs_type, + return error; + } + s->s_flags |= MS_ACTIVE; ++ } else { ++ do_remount_sb(s, flags, data, 0); + } +- do_remount_sb(s, flags, data, 0); + simple_set_mnt(mnt, s); + return 0; + } +diff --git a/include/acpi/platform/aclinux.h b/include/acpi/platform/aclinux.h +index 9d7febd..0946997 100644 +--- a/include/acpi/platform/aclinux.h ++++ b/include/acpi/platform/aclinux.h +@@ -152,7 +152,7 @@ static inline void *acpi_os_acquire_object(acpi_cache_t * cache) + #include + #define ACPI_PREEMPTION_POINT() \ + do { \ +- if (!in_atomic_preempt_off()) \ ++ if (!in_atomic_preempt_off() && !irqs_disabled()) \ + cond_resched(); \ + } while (0) + +diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h +index 83d2fbd..64b1a4c 100644 +--- a/include/linux/clocksource.h ++++ b/include/linux/clocksource.h +@@ -151,6 +151,7 @@ extern u64 timecounter_cyc2time(struct timecounter *tc, + * subtraction of non 64 bit counters + * @mult: cycle to nanosecond multiplier + * @shift: cycle to nanosecond divisor (power of two) ++ * @max_idle_ns: max idle time permitted by the clocksource (nsecs) + * @flags: flags describing special properties + * @vread: vsyscall based read + * @resume: resume function for the clocksource, if necessary +@@ -168,6 +169,7 @@ struct clocksource { + cycle_t mask; + u32 mult; + u32 shift; ++ u64 max_idle_ns; + unsigned long flags; + cycle_t (*vread)(void); + void (*resume)(void); +diff --git a/include/linux/hid.h b/include/linux/hid.h +index 10f6284..8709365 100644 +--- a/include/linux/hid.h ++++ b/include/linux/hid.h +@@ -312,6 +312,7 @@ struct hid_item { + #define HID_QUIRK_MULTI_INPUT 0x00000040 + #define HID_QUIRK_SKIP_OUTPUT_REPORTS 0x00010000 + #define HID_QUIRK_FULLSPEED_INTERVAL 0x10000000 ++#define HID_QUIRK_NO_INIT_REPORTS 0x20000000 + + /* + * This is the global environment of the parser. This information is +diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h +index 84cf1f3..1b7f2a7 100644 +--- a/include/linux/pci_ids.h ++++ b/include/linux/pci_ids.h +@@ -2290,6 +2290,20 @@ + #define PCI_DEVICE_ID_MPC8536 0x0051 + #define PCI_DEVICE_ID_P2020E 0x0070 + #define PCI_DEVICE_ID_P2020 0x0071 ++#define PCI_DEVICE_ID_P2010E 0x0078 ++#define PCI_DEVICE_ID_P2010 0x0079 ++#define PCI_DEVICE_ID_P1020E 0x0100 ++#define PCI_DEVICE_ID_P1020 0x0101 ++#define PCI_DEVICE_ID_P1011E 0x0108 ++#define PCI_DEVICE_ID_P1011 0x0109 ++#define PCI_DEVICE_ID_P1022E 0x0110 ++#define PCI_DEVICE_ID_P1022 0x0111 ++#define PCI_DEVICE_ID_P1013E 0x0118 ++#define PCI_DEVICE_ID_P1013 0x0119 ++#define PCI_DEVICE_ID_P4080E 0x0400 ++#define PCI_DEVICE_ID_P4080 0x0401 ++#define PCI_DEVICE_ID_P4040E 0x0408 ++#define PCI_DEVICE_ID_P4040 0x0409 + #define PCI_DEVICE_ID_MPC8641 0x7010 + #define PCI_DEVICE_ID_MPC8641D 0x7011 + #define PCI_DEVICE_ID_MPC8610 0x7018 +diff --git a/include/linux/time.h b/include/linux/time.h +index fe04e5e..6e026e4 100644 +--- a/include/linux/time.h ++++ b/include/linux/time.h +@@ -148,6 +148,7 @@ extern void monotonic_to_bootbased(struct timespec *ts); + + extern struct timespec timespec_trunc(struct timespec t, unsigned gran); + extern int timekeeping_valid_for_hres(void); ++extern u64 timekeeping_max_deferment(void); + extern void update_wall_time(void); + extern void update_xtime_cache(u64 nsec); + extern void timekeeping_leap_insert(int leapsecond); +diff --git a/include/scsi/fc_frame.h b/include/scsi/fc_frame.h +index c35d238..148126d 100644 +--- a/include/scsi/fc_frame.h ++++ b/include/scsi/fc_frame.h +@@ -37,6 +37,9 @@ + #define FC_FRAME_HEADROOM 32 /* headroom for VLAN + FCoE headers */ + #define FC_FRAME_TAILROOM 8 /* trailer space for FCoE */ + ++/* Max number of skb frags allowed, reserving one for fcoe_crc_eof page */ ++#define FC_FRAME_SG_LEN (MAX_SKB_FRAGS - 1) ++ + #define fp_skb(fp) (&((fp)->skb)) + #define fr_hdr(fp) ((fp)->skb.data) + #define fr_len(fp) ((fp)->skb.len) +diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h +index 65dc9aa..09a124b 100644 +--- a/include/scsi/libfc.h ++++ b/include/scsi/libfc.h +@@ -145,6 +145,7 @@ enum fc_rport_state { + RPORT_ST_LOGO, /* port logout sent */ + RPORT_ST_ADISC, /* Discover Address sent */ + RPORT_ST_DELETE, /* port being deleted */ ++ RPORT_ST_RESTART, /* remote port being deleted and will restart */ + }; + + /** +diff --git a/init/calibrate.c b/init/calibrate.c +index a379c90..6eb48e5 100644 +--- a/init/calibrate.c ++++ b/init/calibrate.c +@@ -123,23 +123,26 @@ void __cpuinit calibrate_delay(void) + { + unsigned long ticks, loopbit; + int lps_precision = LPS_PREC; ++ static bool printed; + + if (preset_lpj) { + loops_per_jiffy = preset_lpj; +- printk(KERN_INFO +- "Calibrating delay loop (skipped) preset value.. "); +- } else if ((smp_processor_id() == 0) && lpj_fine) { ++ if (!printed) ++ pr_info("Calibrating delay loop (skipped) " ++ "preset value.. "); ++ } else if ((!printed) && lpj_fine) { + loops_per_jiffy = lpj_fine; +- printk(KERN_INFO +- "Calibrating delay loop (skipped), " ++ pr_info("Calibrating delay loop (skipped), " + "value calculated using timer frequency.. "); + } else if ((loops_per_jiffy = calibrate_delay_direct()) != 0) { +- printk(KERN_INFO +- "Calibrating delay using timer specific routine.. "); ++ if (!printed) ++ pr_info("Calibrating delay using timer " ++ "specific routine.. "); + } else { + loops_per_jiffy = (1<<12); + +- printk(KERN_INFO "Calibrating delay loop... "); ++ if (!printed) ++ pr_info("Calibrating delay loop... "); + while ((loops_per_jiffy <<= 1) != 0) { + /* wait for "start of" clock tick */ + ticks = jiffies; +@@ -170,7 +173,10 @@ void __cpuinit calibrate_delay(void) + loops_per_jiffy &= ~loopbit; + } + } +- printk(KERN_CONT "%lu.%02lu BogoMIPS (lpj=%lu)\n", ++ if (!printed) ++ pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n", + loops_per_jiffy/(500000/HZ), + (loops_per_jiffy/(5000/HZ)) % 100, loops_per_jiffy); ++ ++ printed = true; + } +diff --git a/ipc/msg.c b/ipc/msg.c +index 2ceab7f..779f762 100644 +--- a/ipc/msg.c ++++ b/ipc/msg.c +@@ -125,6 +125,7 @@ void msg_init_ns(struct ipc_namespace *ns) + void msg_exit_ns(struct ipc_namespace *ns) + { + free_ipcs(ns, &msg_ids(ns), freeque); ++ idr_destroy(&ns->ids[IPC_MSG_IDS].ipcs_idr); + } + #endif + +diff --git a/ipc/sem.c b/ipc/sem.c +index 87c2b64..2f2a479 100644 +--- a/ipc/sem.c ++++ b/ipc/sem.c +@@ -129,6 +129,7 @@ void sem_init_ns(struct ipc_namespace *ns) + void sem_exit_ns(struct ipc_namespace *ns) + { + free_ipcs(ns, &sem_ids(ns), freeary); ++ idr_destroy(&ns->ids[IPC_SEM_IDS].ipcs_idr); + } + #endif + +diff --git a/ipc/shm.c b/ipc/shm.c +index 11bec62..e9b039f 100644 +--- a/ipc/shm.c ++++ b/ipc/shm.c +@@ -101,6 +101,7 @@ static void do_shm_rmid(struct ipc_namespace *ns, struct kern_ipc_perm *ipcp) + void shm_exit_ns(struct ipc_namespace *ns) + { + free_ipcs(ns, &shm_ids(ns), do_shm_rmid); ++ idr_destroy(&ns->ids[IPC_SHM_IDS].ipcs_idr); + } + #endif + +diff --git a/kernel/cpu.c b/kernel/cpu.c +index b216886..291ac58 100644 +--- a/kernel/cpu.c ++++ b/kernel/cpu.c +@@ -400,10 +400,9 @@ int disable_nonboot_cpus(void) + if (cpu == first_cpu) + continue; + error = _cpu_down(cpu, 1); +- if (!error) { ++ if (!error) + cpumask_set_cpu(cpu, frozen_cpus); +- printk("CPU%d is down\n", cpu); +- } else { ++ else { + printk(KERN_ERR "Error taking CPU%d down: %d\n", + cpu, error); + break; +diff --git a/kernel/sched.c b/kernel/sched.c +index bf841d8..60d74cc 100644 +--- a/kernel/sched.c ++++ b/kernel/sched.c +@@ -816,6 +816,7 @@ const_debug unsigned int sysctl_sched_nr_migrate = 32; + * default: 0.25ms + */ + unsigned int sysctl_sched_shares_ratelimit = 250000; ++unsigned int normalized_sysctl_sched_shares_ratelimit = 250000; + + /* + * Inject some fuzzyness into changing the per-cpu group shares +@@ -1812,6 +1813,7 @@ static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares) + #endif + + static void calc_load_account_active(struct rq *this_rq); ++static void update_sysctl(void); + + #include "sched_stats.h" + #include "sched_idletask.c" +@@ -7018,22 +7020,23 @@ cpumask_var_t nohz_cpu_mask; + * + * This idea comes from the SD scheduler of Con Kolivas: + */ +-static inline void sched_init_granularity(void) ++static void update_sysctl(void) + { +- unsigned int factor = 1 + ilog2(num_online_cpus()); +- const unsigned long limit = 200000000; +- +- sysctl_sched_min_granularity *= factor; +- if (sysctl_sched_min_granularity > limit) +- sysctl_sched_min_granularity = limit; +- +- sysctl_sched_latency *= factor; +- if (sysctl_sched_latency > limit) +- sysctl_sched_latency = limit; ++ unsigned int cpus = min(num_online_cpus(), 8U); ++ unsigned int factor = 1 + ilog2(cpus); + +- sysctl_sched_wakeup_granularity *= factor; ++#define SET_SYSCTL(name) \ ++ (sysctl_##name = (factor) * normalized_sysctl_##name) ++ SET_SYSCTL(sched_min_granularity); ++ SET_SYSCTL(sched_latency); ++ SET_SYSCTL(sched_wakeup_granularity); ++ SET_SYSCTL(sched_shares_ratelimit); ++#undef SET_SYSCTL ++} + +- sysctl_sched_shares_ratelimit *= factor; ++static inline void sched_init_granularity(void) ++{ ++ update_sysctl(); + } + + #ifdef CONFIG_SMP +@@ -8061,6 +8064,7 @@ static cpumask_var_t cpu_isolated_map; + /* Setup the mask of cpus configured for isolated domains */ + static int __init isolated_cpu_setup(char *str) + { ++ alloc_bootmem_cpumask_var(&cpu_isolated_map); + cpulist_parse(str, cpu_isolated_map); + return 1; + } +@@ -9591,7 +9595,9 @@ void __init sched_init(void) + zalloc_cpumask_var(&nohz.cpu_mask, GFP_NOWAIT); + alloc_cpumask_var(&nohz.ilb_grp_nohz_mask, GFP_NOWAIT); + #endif +- zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT); ++ /* May be allocated at isolcpus cmdline parse time */ ++ if (cpu_isolated_map == NULL) ++ zalloc_cpumask_var(&cpu_isolated_map, GFP_NOWAIT); + #endif /* SMP */ + + perf_event_init(); +diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c +index 199228b..d80812d 100644 +--- a/kernel/sched_fair.c ++++ b/kernel/sched_fair.c +@@ -35,12 +35,14 @@ + * run vmstat and monitor the context-switches (cs) field) + */ + unsigned int sysctl_sched_latency = 5000000ULL; ++unsigned int normalized_sysctl_sched_latency = 5000000ULL; + + /* + * Minimal preemption granularity for CPU-bound tasks: + * (default: 1 msec * (1 + ilog(ncpus)), units: nanoseconds) + */ + unsigned int sysctl_sched_min_granularity = 1000000ULL; ++unsigned int normalized_sysctl_sched_min_granularity = 1000000ULL; + + /* + * is kept at sysctl_sched_latency / sysctl_sched_min_granularity +@@ -70,6 +72,7 @@ unsigned int __read_mostly sysctl_sched_compat_yield; + * have immediate wakeup/sleep latencies. + */ + unsigned int sysctl_sched_wakeup_granularity = 1000000UL; ++unsigned int normalized_sysctl_sched_wakeup_granularity = 1000000UL; + + const_debug unsigned int sysctl_sched_migration_cost = 500000UL; + +@@ -1880,6 +1883,17 @@ move_one_task_fair(struct rq *this_rq, int this_cpu, struct rq *busiest, + + return 0; + } ++ ++static void rq_online_fair(struct rq *rq) ++{ ++ update_sysctl(); ++} ++ ++static void rq_offline_fair(struct rq *rq) ++{ ++ update_sysctl(); ++} ++ + #endif /* CONFIG_SMP */ + + /* +@@ -2027,6 +2041,8 @@ static const struct sched_class fair_sched_class = { + + .load_balance = load_balance_fair, + .move_one_task = move_one_task_fair, ++ .rq_online = rq_online_fair, ++ .rq_offline = rq_offline_fair, + #endif + + .set_curr_task = set_curr_task_fair, +diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c +index 9484be4..0d809ae 100644 +--- a/kernel/time/clockevents.c ++++ b/kernel/time/clockevents.c +@@ -20,6 +20,8 @@ + #include + #include + ++#include "tick-internal.h" ++ + /* The registered clock event devices */ + static LIST_HEAD(clockevent_devices); + static LIST_HEAD(clockevents_released); +@@ -258,7 +260,8 @@ void clockevents_notify(unsigned long reason, void *arg) + cpu = *((int *)arg); + list_for_each_entry_safe(dev, tmp, &clockevent_devices, list) { + if (cpumask_test_cpu(cpu, dev->cpumask) && +- cpumask_weight(dev->cpumask) == 1) { ++ cpumask_weight(dev->cpumask) == 1 && ++ !tick_is_broadcast_device(dev)) { + BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED); + list_del(&dev->list); + } +diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c +index 5e18c6a..5155dc3 100644 +--- a/kernel/time/clocksource.c ++++ b/kernel/time/clocksource.c +@@ -416,6 +416,47 @@ void clocksource_touch_watchdog(void) + #ifdef CONFIG_GENERIC_TIME + + /** ++ * clocksource_max_deferment - Returns max time the clocksource can be deferred ++ * @cs: Pointer to clocksource ++ * ++ */ ++static u64 clocksource_max_deferment(struct clocksource *cs) ++{ ++ u64 max_nsecs, max_cycles; ++ ++ /* ++ * Calculate the maximum number of cycles that we can pass to the ++ * cyc2ns function without overflowing a 64-bit signed result. The ++ * maximum number of cycles is equal to ULLONG_MAX/cs->mult which ++ * is equivalent to the below. ++ * max_cycles < (2^63)/cs->mult ++ * max_cycles < 2^(log2((2^63)/cs->mult)) ++ * max_cycles < 2^(log2(2^63) - log2(cs->mult)) ++ * max_cycles < 2^(63 - log2(cs->mult)) ++ * max_cycles < 1 << (63 - log2(cs->mult)) ++ * Please note that we add 1 to the result of the log2 to account for ++ * any rounding errors, ensure the above inequality is satisfied and ++ * no overflow will occur. ++ */ ++ max_cycles = 1ULL << (63 - (ilog2(cs->mult) + 1)); ++ ++ /* ++ * The actual maximum number of cycles we can defer the clocksource is ++ * determined by the minimum of max_cycles and cs->mask. ++ */ ++ max_cycles = min_t(u64, max_cycles, (u64) cs->mask); ++ max_nsecs = clocksource_cyc2ns(max_cycles, cs->mult, cs->shift); ++ ++ /* ++ * To ensure that the clocksource does not wrap whilst we are idle, ++ * limit the time the clocksource can be deferred by 12.5%. Please ++ * note a margin of 12.5% is used because this can be computed with ++ * a shift, versus say 10% which would require division. ++ */ ++ return max_nsecs - (max_nsecs >> 5); ++} ++ ++/** + * clocksource_select - Select the best clocksource available + * + * Private function. Must hold clocksource_mutex when called. +@@ -511,6 +552,9 @@ static void clocksource_enqueue(struct clocksource *cs) + */ + int clocksource_register(struct clocksource *cs) + { ++ /* calculate max idle time permitted for this clocksource */ ++ cs->max_idle_ns = clocksource_max_deferment(cs); ++ + mutex_lock(&clocksource_mutex); + clocksource_enqueue(cs); + clocksource_select(); +diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c +index 89aed59..44320b1 100644 +--- a/kernel/time/tick-sched.c ++++ b/kernel/time/tick-sched.c +@@ -216,6 +216,7 @@ void tick_nohz_stop_sched_tick(int inidle) + struct tick_sched *ts; + ktime_t last_update, expires, now; + struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev; ++ u64 time_delta; + int cpu; + + local_irq_save(flags); +@@ -275,6 +276,17 @@ void tick_nohz_stop_sched_tick(int inidle) + seq = read_seqbegin(&xtime_lock); + last_update = last_jiffies_update; + last_jiffies = jiffies; ++ ++ /* ++ * On SMP we really should only care for the CPU which ++ * has the do_timer duty assigned. All other CPUs can ++ * sleep as long as they want. ++ */ ++ if (cpu == tick_do_timer_cpu || ++ tick_do_timer_cpu == TICK_DO_TIMER_NONE) ++ time_delta = timekeeping_max_deferment(); ++ else ++ time_delta = KTIME_MAX; + } while (read_seqretry(&xtime_lock, seq)); + + /* Get the next timer wheel timer */ +@@ -294,11 +306,26 @@ void tick_nohz_stop_sched_tick(int inidle) + if ((long)delta_jiffies >= 1) { + + /* +- * calculate the expiry time for the next timer wheel +- * timer +- */ +- expires = ktime_add_ns(last_update, tick_period.tv64 * +- delta_jiffies); ++ * calculate the expiry time for the next timer wheel ++ * timer. delta_jiffies >= NEXT_TIMER_MAX_DELTA signals ++ * that there is no timer pending or at least extremely ++ * far into the future (12 days for HZ=1000). In this ++ * case we set the expiry to the end of time. ++ */ ++ if (likely(delta_jiffies < NEXT_TIMER_MAX_DELTA)) { ++ /* ++ * Calculate the time delta for the next timer event. ++ * If the time delta exceeds the maximum time delta ++ * permitted by the current clocksource then adjust ++ * the time delta accordingly to ensure the ++ * clocksource does not wrap. ++ */ ++ time_delta = min_t(u64, time_delta, ++ tick_period.tv64 * delta_jiffies); ++ expires = ktime_add_ns(last_update, time_delta); ++ } else { ++ expires.tv64 = KTIME_MAX; ++ } + + /* + * If this cpu is the one which updates jiffies, then +@@ -342,22 +369,19 @@ void tick_nohz_stop_sched_tick(int inidle) + + ts->idle_sleeps++; + ++ /* Mark expires */ ++ ts->idle_expires = expires; ++ + /* +- * delta_jiffies >= NEXT_TIMER_MAX_DELTA signals that +- * there is no timer pending or at least extremly far +- * into the future (12 days for HZ=1000). In this case +- * we simply stop the tick timer: ++ * If the expiration time == KTIME_MAX, then ++ * in this case we simply stop the tick timer. + */ +- if (unlikely(delta_jiffies >= NEXT_TIMER_MAX_DELTA)) { +- ts->idle_expires.tv64 = KTIME_MAX; ++ if (unlikely(expires.tv64 == KTIME_MAX)) { + if (ts->nohz_mode == NOHZ_MODE_HIGHRES) + hrtimer_cancel(&ts->sched_timer); + goto out; + } + +- /* Mark expiries */ +- ts->idle_expires = expires; +- + if (ts->nohz_mode == NOHZ_MODE_HIGHRES) { + hrtimer_start(&ts->sched_timer, expires, + HRTIMER_MODE_ABS_PINNED); +diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c +index c3a4e29..66d090e 100644 +--- a/kernel/time/timekeeping.c ++++ b/kernel/time/timekeeping.c +@@ -488,6 +488,17 @@ int timekeeping_valid_for_hres(void) + } + + /** ++ * timekeeping_max_deferment - Returns max time the clocksource can be deferred ++ * ++ * Caller must observe xtime_lock via read_seqbegin/read_seqretry to ++ * ensure that the clocksource does not change! ++ */ ++u64 timekeeping_max_deferment(void) ++{ ++ return timekeeper.clock->max_idle_ns; ++} ++ ++/** + * read_persistent_clock - Return time from the persistent clock. + * + * Weak dummy function for arches that do not yet support it. +diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c +index cca675e..fe2d3f8 100644 +--- a/net/mac80211/cfg.c ++++ b/net/mac80211/cfg.c +@@ -1306,6 +1306,9 @@ static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev, + struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); + struct ieee80211_conf *conf = &local->hw.conf; + ++ if (sdata->vif.type != NL80211_IFTYPE_STATION) ++ return -EOPNOTSUPP; ++ + if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) + return -EOPNOTSUPP; + +diff --git a/net/netfilter/xt_conntrack.c b/net/netfilter/xt_conntrack.c +index 6dc4652..ae66305 100644 +--- a/net/netfilter/xt_conntrack.c ++++ b/net/netfilter/xt_conntrack.c +@@ -113,7 +113,8 @@ ct_proto_port_check(const struct xt_conntrack_mtinfo2 *info, + } + + static bool +-conntrack_mt(const struct sk_buff *skb, const struct xt_match_param *par) ++conntrack_mt(const struct sk_buff *skb, const struct xt_match_param *par, ++ u16 state_mask, u16 status_mask) + { + const struct xt_conntrack_mtinfo2 *info = par->matchinfo; + enum ip_conntrack_info ctinfo; +@@ -136,7 +137,7 @@ conntrack_mt(const struct sk_buff *skb, const struct xt_match_param *par) + if (test_bit(IPS_DST_NAT_BIT, &ct->status)) + statebit |= XT_CONNTRACK_STATE_DNAT; + } +- if (!!(info->state_mask & statebit) ^ ++ if (!!(state_mask & statebit) ^ + !(info->invert_flags & XT_CONNTRACK_STATE)) + return false; + } +@@ -172,7 +173,7 @@ conntrack_mt(const struct sk_buff *skb, const struct xt_match_param *par) + return false; + + if ((info->match_flags & XT_CONNTRACK_STATUS) && +- (!!(info->status_mask & ct->status) ^ ++ (!!(status_mask & ct->status) ^ + !(info->invert_flags & XT_CONNTRACK_STATUS))) + return false; + +@@ -192,11 +193,17 @@ conntrack_mt(const struct sk_buff *skb, const struct xt_match_param *par) + static bool + conntrack_mt_v1(const struct sk_buff *skb, const struct xt_match_param *par) + { +- const struct xt_conntrack_mtinfo2 *const *info = par->matchinfo; +- struct xt_match_param newpar = *par; ++ const struct xt_conntrack_mtinfo1 *info = par->matchinfo; + +- newpar.matchinfo = *info; +- return conntrack_mt(skb, &newpar); ++ return conntrack_mt(skb, par, info->state_mask, info->status_mask); ++} ++ ++static bool ++conntrack_mt_v2(const struct sk_buff *skb, const struct xt_match_param *par) ++{ ++ const struct xt_conntrack_mtinfo2 *info = par->matchinfo; ++ ++ return conntrack_mt(skb, par, info->state_mask, info->status_mask); + } + + static bool conntrack_mt_check(const struct xt_mtchk_param *par) +@@ -209,45 +216,11 @@ static bool conntrack_mt_check(const struct xt_mtchk_param *par) + return true; + } + +-static bool conntrack_mt_check_v1(const struct xt_mtchk_param *par) +-{ +- struct xt_conntrack_mtinfo1 *info = par->matchinfo; +- struct xt_conntrack_mtinfo2 *up; +- int ret = conntrack_mt_check(par); +- +- if (ret < 0) +- return ret; +- +- up = kmalloc(sizeof(*up), GFP_KERNEL); +- if (up == NULL) { +- nf_ct_l3proto_module_put(par->family); +- return -ENOMEM; +- } +- +- /* +- * The strategy here is to minimize the overhead of v1 matching, +- * by prebuilding a v2 struct and putting the pointer into the +- * v1 dataspace. +- */ +- memcpy(up, info, offsetof(typeof(*info), state_mask)); +- up->state_mask = info->state_mask; +- up->status_mask = info->status_mask; +- *(void **)info = up; +- return true; +-} +- + static void conntrack_mt_destroy(const struct xt_mtdtor_param *par) + { + nf_ct_l3proto_module_put(par->family); + } + +-static void conntrack_mt_destroy_v1(const struct xt_mtdtor_param *par) +-{ +- struct xt_conntrack_mtinfo2 **info = par->matchinfo; +- kfree(*info); +- conntrack_mt_destroy(par); +-} +- + static struct xt_match conntrack_mt_reg[] __read_mostly = { + { + .name = "conntrack", +@@ -255,8 +228,8 @@ static struct xt_match conntrack_mt_reg[] __read_mostly = { + .family = NFPROTO_UNSPEC, + .matchsize = sizeof(struct xt_conntrack_mtinfo1), + .match = conntrack_mt_v1, +- .checkentry = conntrack_mt_check_v1, +- .destroy = conntrack_mt_destroy_v1, ++ .checkentry = conntrack_mt_check, ++ .destroy = conntrack_mt_destroy, + .me = THIS_MODULE, + }, + { +@@ -264,7 +237,7 @@ static struct xt_match conntrack_mt_reg[] __read_mostly = { + .revision = 2, + .family = NFPROTO_UNSPEC, + .matchsize = sizeof(struct xt_conntrack_mtinfo2), +- .match = conntrack_mt, ++ .match = conntrack_mt_v2, + .checkentry = conntrack_mt_check, + .destroy = conntrack_mt_destroy, + .me = THIS_MODULE, +diff --git a/net/wireless/sme.c b/net/wireless/sme.c +index 9f0b280..b2930e3 100644 +--- a/net/wireless/sme.c ++++ b/net/wireless/sme.c +@@ -655,6 +655,7 @@ void __cfg80211_disconnected(struct net_device *dev, const u8 *ie, + memset(&wrqu, 0, sizeof(wrqu)); + wrqu.ap_addr.sa_family = ARPHRD_ETHER; + wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL); ++ wdev->wext.connect.ssid_len = 0; + #endif + } + +diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c +index 7e4ee4e..03784da 100644 +--- a/sound/pci/hda/hda_intel.c ++++ b/sound/pci/hda/hda_intel.c +@@ -2694,6 +2694,9 @@ static struct pci_device_id azx_ids[] = { + { PCI_DEVICE(0x10de, 0x0ac1), .driver_data = AZX_DRIVER_NVIDIA }, + { PCI_DEVICE(0x10de, 0x0ac2), .driver_data = AZX_DRIVER_NVIDIA }, + { PCI_DEVICE(0x10de, 0x0ac3), .driver_data = AZX_DRIVER_NVIDIA }, ++ { PCI_DEVICE(0x10de, 0x0be2), .driver_data = AZX_DRIVER_NVIDIA }, ++ { PCI_DEVICE(0x10de, 0x0be3), .driver_data = AZX_DRIVER_NVIDIA }, ++ { PCI_DEVICE(0x10de, 0x0be4), .driver_data = AZX_DRIVER_NVIDIA }, + { PCI_DEVICE(0x10de, 0x0d94), .driver_data = AZX_DRIVER_NVIDIA }, + { PCI_DEVICE(0x10de, 0x0d95), .driver_data = AZX_DRIVER_NVIDIA }, + { PCI_DEVICE(0x10de, 0x0d96), .driver_data = AZX_DRIVER_NVIDIA }, +diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c +index 01a18ed..7c23016 100644 +--- a/sound/pci/hda/patch_intelhdmi.c ++++ b/sound/pci/hda/patch_intelhdmi.c +@@ -684,7 +684,7 @@ static struct hda_codec_preset snd_hda_preset_intelhdmi[] = { + { .id = 0x80862801, .name = "G45 DEVBLC", .patch = patch_intel_hdmi }, + { .id = 0x80862802, .name = "G45 DEVCTG", .patch = patch_intel_hdmi }, + { .id = 0x80862803, .name = "G45 DEVELK", .patch = patch_intel_hdmi }, +- { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi }, ++ { .id = 0x80862804, .name = "G45 DEVIBX", .patch = patch_intel_hdmi_ibexpeak }, + { .id = 0x80860054, .name = "Q57 DEVIBX", .patch = patch_intel_hdmi_ibexpeak }, + { .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_intel_hdmi }, + {} /* terminator */ +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 075c3a6..c2e9370 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -2401,6 +2401,8 @@ static const char *alc_slave_sws[] = { + "Speaker Playback Switch", + "Mono Playback Switch", + "IEC958 Playback Switch", ++ "Line-Out Playback Switch", ++ "PCM Playback Switch", + NULL, + }; + +@@ -8839,7 +8841,7 @@ static struct snd_pci_quirk alc882_cfg_tbl[] = { + SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG), + SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG), + SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8 */ +- SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG), ++ SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO), + SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG), + SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG), + SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG), +@@ -10152,7 +10154,7 @@ static void alc262_hp_t5735_setup(struct hda_codec *codec) + struct alc_spec *spec = codec->spec; + + spec->autocfg.hp_pins[0] = 0x15; +- spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */ ++ spec->autocfg.speaker_pins[0] = 0x14; + } + + static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = { +@@ -11586,9 +11588,9 @@ static struct alc_config_preset alc262_presets[] = { + .num_channel_mode = ARRAY_SIZE(alc262_modes), + .channel_mode = alc262_modes, + .input_mux = &alc262_capture_source, +- .unsol_event = alc_automute_amp_unsol_event, ++ .unsol_event = alc_sku_unsol_event, + .setup = alc262_hp_t5735_setup, +- .init_hook = alc_automute_amp, ++ .init_hook = alc_inithook, + }, + [ALC262_HP_RP5700] = { + .mixers = { alc262_hp_rp5700_mixer }, +diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c +index fd948bf..f5020ad 100644 +--- a/sound/pci/ice1712/juli.c ++++ b/sound/pci/ice1712/juli.c +@@ -504,6 +504,31 @@ static int __devinit juli_add_controls(struct snd_ice1712 *ice) + } + + /* ++ * suspend/resume ++ * */ ++ ++#ifdef CONFIG_PM ++static int juli_resume(struct snd_ice1712 *ice) ++{ ++ struct snd_akm4xxx *ak = ice->akm; ++ struct juli_spec *spec = ice->spec; ++ /* akm4358 un-reset, un-mute */ ++ snd_akm4xxx_reset(ak, 0); ++ /* reinit ak4114 */ ++ snd_ak4114_reinit(spec->ak4114); ++ return 0; ++} ++ ++static int juli_suspend(struct snd_ice1712 *ice) ++{ ++ struct snd_akm4xxx *ak = ice->akm; ++ /* akm4358 reset and soft-mute */ ++ snd_akm4xxx_reset(ak, 1); ++ return 0; ++} ++#endif ++ ++/* + * initialize the chip + */ + +@@ -646,6 +671,13 @@ static int __devinit juli_init(struct snd_ice1712 *ice) + ice->set_spdif_clock = juli_set_spdif_clock; + + ice->spdif.ops.open = juli_spdif_in_open; ++ ++#ifdef CONFIG_PM ++ ice->pm_resume = juli_resume; ++ ice->pm_suspend = juli_suspend; ++ ice->pm_suspend_enabled = 1; ++#endif ++ + return 0; + } + +diff --git a/sound/soc/codecs/wm8903.c b/sound/soc/codecs/wm8903.c +index fe1307b..eedf33c 100644 +--- a/sound/soc/codecs/wm8903.c ++++ b/sound/soc/codecs/wm8903.c +@@ -1506,7 +1506,7 @@ static int wm8903_resume(struct platform_device *pdev) + struct i2c_client *i2c = codec->control_data; + int i; + u16 *reg_cache = codec->reg_cache; +- u16 *tmp_cache = kmemdup(codec->reg_cache, sizeof(wm8903_reg_defaults), ++ u16 *tmp_cache = kmemdup(reg_cache, sizeof(wm8903_reg_defaults), + GFP_KERNEL); + + /* Bring the codec back up to standby first to minimise pop/clicks */ +@@ -1518,6 +1518,7 @@ static int wm8903_resume(struct platform_device *pdev) + for (i = 2; i < ARRAY_SIZE(wm8903_reg_defaults); i++) + if (tmp_cache[i] != reg_cache[i]) + snd_soc_write(codec, i, tmp_cache[i]); ++ kfree(tmp_cache); + } else { + dev_err(&i2c->dev, "Failed to allocate temporary cache\n"); + } +diff --git a/virt/kvm/eventfd.c b/virt/kvm/eventfd.c +index bb4ebd8..251282c 100644 +--- a/virt/kvm/eventfd.c ++++ b/virt/kvm/eventfd.c +@@ -168,7 +168,7 @@ irqfd_ptable_queue_proc(struct file *file, wait_queue_head_t *wqh, + static int + kvm_irqfd_assign(struct kvm *kvm, int fd, int gsi) + { +- struct _irqfd *irqfd; ++ struct _irqfd *irqfd, *tmp; + struct file *file = NULL; + struct eventfd_ctx *eventfd = NULL; + int ret; +@@ -205,9 +205,20 @@ kvm_irqfd_assign(struct kvm *kvm, int fd, int gsi) + init_waitqueue_func_entry(&irqfd->wait, irqfd_wakeup); + init_poll_funcptr(&irqfd->pt, irqfd_ptable_queue_proc); + ++ spin_lock_irq(&kvm->irqfds.lock); ++ ++ ret = 0; ++ list_for_each_entry(tmp, &kvm->irqfds.items, list) { ++ if (irqfd->eventfd != tmp->eventfd) ++ continue; ++ /* This fd is used for another irq already. */ ++ ret = -EBUSY; ++ spin_unlock_irq(&kvm->irqfds.lock); ++ goto fail; ++ } ++ + events = file->f_op->poll(file, &irqfd->pt); + +- spin_lock_irq(&kvm->irqfds.lock); + list_add_tail(&irqfd->list, &kvm->irqfds.items); + spin_unlock_irq(&kvm->irqfds.lock); + +diff --git a/virt/kvm/irq_comm.c b/virt/kvm/irq_comm.c +index 03e5b21..5288885 100644 +--- a/virt/kvm/irq_comm.c ++++ b/virt/kvm/irq_comm.c +@@ -209,11 +209,13 @@ int kvm_request_irq_source_id(struct kvm *kvm) + + if (irq_source_id >= BITS_PER_LONG) { + printk(KERN_WARNING "kvm: exhaust allocatable IRQ sources!\n"); +- return -EFAULT; ++ irq_source_id = -EFAULT; ++ goto unlock; + } + + ASSERT(irq_source_id != KVM_USERSPACE_IRQ_SOURCE_ID); + set_bit(irq_source_id, bitmap); ++unlock: + mutex_unlock(&kvm->irq_lock); + + return irq_source_id; +@@ -229,11 +231,15 @@ void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id) + if (irq_source_id < 0 || + irq_source_id >= BITS_PER_LONG) { + printk(KERN_ERR "kvm: IRQ source ID out of range!\n"); +- return; ++ goto unlock; + } ++ clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap); ++ if (!irqchip_in_kernel(kvm)) ++ goto unlock; ++ + for (i = 0; i < KVM_IOAPIC_NUM_PINS; i++) + clear_bit(irq_source_id, &kvm->arch.irq_states[i]); +- clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap); ++unlock: + mutex_unlock(&kvm->irq_lock); + } + diff --git a/debian/patches/debian/sched-fix-conflict-between-2.6.32.7-and-vserver.patch b/debian/patches/debian/sched-fix-conflict-between-2.6.32.7-and-vserver.patch new file mode 100644 index 000000000..107c3865e --- /dev/null +++ b/debian/patches/debian/sched-fix-conflict-between-2.6.32.7-and-vserver.patch @@ -0,0 +1,19 @@ +From: Ben Hutchings +Subject: [PATCH] sched: Fix conflict between 2.6.32.7 and vserver + +Make some cosmetic changes to sched.c on top of 2.6.32.7 so that +the vserver patch will still apply. + +--- a/kernel/sched.c ++++ b/kernel/sched.c +@@ -1812,8 +1813,9 @@ + } + #endif + ++static void update_sysctl(void); ++ + static void calc_load_account_active(struct rq *this_rq); +-static void update_sysctl(void); + + #include "sched_stats.h" + #include "sched_idletask.c" diff --git a/debian/patches/features/all/input-alps-add-support-for-touchpads-with-4-directional-button-2.patch b/debian/patches/features/all/input-alps-add-support-for-touchpads-with-4-directional-button-2.patch new file mode 100644 index 000000000..e4df29ab2 --- /dev/null +++ b/debian/patches/features/all/input-alps-add-support-for-touchpads-with-4-directional-button-2.patch @@ -0,0 +1,59 @@ +Based on: + +commit 71bb21b677e89a2b438b804231f92b779beda5d7 +Author: Maxim Levitsky +Date: Mon Nov 16 22:12:22 2009 -0800 + + Input: ALPS - add support for touchpads with 4-directional button + + The touchpad on Acer Aspire 5720, 5520 and some other Aspire models + (signature 0x73, 0x02, 0x50) has a button that can be rocked in 4 + different directions. Make the driver to generate BTN_0..BTN_3 events + in response. The Synaptics driver by default maps BTN_0 and BTN_1 to + up and down, so there should be no visible changes with the old setup + that generated BTN_FORWARD and BTN_BACK (also mapped to up and down). + + Signed-off-by: Maxim Levitsky + Signed-off-by: Dmitry Torokhov + +diff --git a/drivers/input/mouse/alps.c b/drivers/input/mouse/alps.c +index f361106..a3f492a 100644 +--- a/drivers/input/mouse/alps.c ++++ b/drivers/input/mouse/alps.c +@@ -61,7 +61,7 @@ static const struct alps_model_info alps_model_data[] = { + /* Dell Latitude E5500, E6400, E6500, Precision M4400 */ + { { 0x62, 0x02, 0x14 }, 0xcf, 0xcf, + ALPS_PASS | ALPS_DUALPOINT | ALPS_PS2_INTERLEAVED }, +- { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_FW_BK_1 }, /* Dell Vostro 1400 */ ++ { { 0x73, 0x02, 0x50 }, 0xcf, 0xcf, ALPS_4BTN }, /* Dell Vostro 1400 */ + }; + + /* +@@ -241,6 +241,13 @@ static void alps_process_packet(struct psmouse *psmouse) + input_report_key(dev, BTN_BACK, back); + } + ++ if (priv->i->flags & ALPS_4BTN) { ++ input_report_key(dev, BTN_0, packet[2] & 4); ++ input_report_key(dev, BTN_1, packet[0] & 0x10); ++ input_report_key(dev, BTN_2, packet[3] & 4); ++ input_report_key(dev, BTN_3, packet[0] & 0x20); ++ } ++ + input_sync(dev); + } + +@@ -689,6 +696,13 @@ int alps_init(struct psmouse *psmouse) + dev1->keybit[BIT_WORD(BTN_BACK)] |= BIT_MASK(BTN_BACK); + } + ++ if (priv->i->flags & ALPS_4BTN) { ++ dev1->keybit[BIT_WORD(BTN_0)] |= BIT_MASK(BTN_0); ++ dev1->keybit[BIT_WORD(BTN_1)] |= BIT_MASK(BTN_1); ++ dev1->keybit[BIT_WORD(BTN_2)] |= BIT_MASK(BTN_2); ++ dev1->keybit[BIT_WORD(BTN_3)] |= BIT_MASK(BTN_3); ++ } ++ + snprintf(priv->phys, sizeof(priv->phys), "%s/input1", psmouse->ps2dev.serio->phys); + dev2->phys = priv->phys; + dev2->name = (priv->i->flags & ALPS_DUALPOINT) ? "DualPoint Stick" : "PS/2 Mouse"; diff --git a/debian/patches/series/6 b/debian/patches/series/6 index 0a100c4e1..2ddd5eb17 100644 --- a/debian/patches/series/6 +++ b/debian/patches/series/6 @@ -1,15 +1,3 @@ -+ features/all/be2net-Add-support-for-next-generation-of-BladeEngine.patch -+ features/all/be2net-Add-the-new-PCI-IDs-to-PCI_DEVICE_TABLE.patch -+ features/all/SCSI-mpt2sas-New-device-SAS2208-support-is-added.patch -+ features/all/ar9170-Add-support-for-D-Link-DWA-160-A2.patch -+ features/powerpc/fsl-Add-PCI-device-ids-for-new-QoirQ-chips.patch -+ features/arm/davinci-dm646x-Add-support-for-3.x-silicon-revision.patch -+ features/all/hda-Add-PCI-IDs-for-Nvidia-G2xx-series.patch -+ features/all/smsusb-add-5-Hauppauge-USB-IDs.patch -+ features/all/mos7840-add-device-IDs-for-B-B-electronics-devices.patch -+ features/all/ftdi_sio-add-USB-device-ID-s-for-B-B-Electronics.patch -+ features/all/saa7134-Add-support-for-Asus-Europa-Hybrid-DVB.patch -+ features/x86/iTCO_wdt-Add-support-for-Intel-Ibex-Peak.patch + bugfix/all/Documentation-3c509-document-ethtool-support.patch + bugfix/all/drm-i915-disable-powersave.patch + features/all/module-firmware/0025-tty-declare-MODULE_FIRMWARE-in-various-drivers.patch @@ -30,8 +18,17 @@ + bugfix/all/e1000e-enhance-fragment-detection.patch + bugfix/all/stable/2.6.32.5.patch + bugfix/all/stable/2.6.32.6.patch -+ bugfix/all/clockevents-Dont-remove-broadcast-device.patch -+ bugfix/all/clockevents-Add-missing-include.patch + features/all/SCSI-3w-sas-Add-new-driver-for-LSI-3ware-9750.patch + features/all/aufs2/aufs2-20100125.patch + bugfix/all/cdc_ether-Partially-revert-usbnet-Set-link-down-init.patch +- bugfix/all/DocBook-media-create-links-for-included-sources.patch +- bugfix/all/DocBook-media-copy-images-after-building-HTML.patch +- bugfix/all/atl1c-use-common_task-instead-of-reset_task-and-link.patch +- bugfix/all/atl1e-remove-broken-tsov6.patch +- bugfix/all/netfilter-xtables-fix-conntrack-match-v1-ipt-save-output.patch +- features/all/input-alps-add-interleaved-protocol-support.patch +- bugfix/all/sfc-Fix-DMA-mapping-cleanup-on-error-in-TSO.patch +- features/all/input-alps-add-support-for-touchpads-with-4-directional-button.patch ++ bugfix/all/stable/2.6.32.7.patch ++ features/all/input-alps-add-support-for-touchpads-with-4-directional-button-2.patch ++ debian/sched-fix-conflict-between-2.6.32.7-and-vserver.patch