[gentoo-commits] proj/linux-patches:4.4 commit in: /

["Mike Pagano" <mpagano@gentoo.org>]

commit:     ff8f1dc40d8c978f9eafa7b97ff2e44a017a9af5
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Sat Nov 19 11:03:15 2016 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Sat Nov 19 11:03:15 2016 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=ff8f1dc4

Linux patch 4.4.33

 0000_README             |    4 +
 1032_linux-4.4.33.patch | 1230 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1234 insertions(+)

diff --git a/0000_README b/0000_README
index fd829db..1789a94 100644
--- a/0000_README
+++ b/0000_README
@@ -171,6 +171,10 @@ Patch:  1031_linux-4.4.32.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.4.32
 
+Patch:  1032_linux-4.4.33.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.4.33
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1032_linux-4.4.33.patch b/1032_linux-4.4.33.patch
new file mode 100644
index 0000000..4a02c80
--- /dev/null
+++ b/1032_linux-4.4.33.patch
@@ -0,0 +1,1230 @@
+diff --git a/Makefile b/Makefile
+index fba9b09a1330..a513c045c8de 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 4
+ PATCHLEVEL = 4
+-SUBLEVEL = 32
++SUBLEVEL = 33
+ EXTRAVERSION =
+ NAME = Blurry Fish Butt
+ 
+diff --git a/arch/arc/kernel/time.c b/arch/arc/kernel/time.c
+index dfad287f1db1..dbedc576e4ca 100644
+--- a/arch/arc/kernel/time.c
++++ b/arch/arc/kernel/time.c
+@@ -130,14 +130,17 @@ static cycle_t arc_counter_read(struct clocksource *cs)
+ 		cycle_t  full;
+ 	} stamp;
+ 
+-
+-	__asm__ __volatile(
+-	"1:						\n"
+-	"	lr		%0, [AUX_RTC_LOW]	\n"
+-	"	lr		%1, [AUX_RTC_HIGH]	\n"
+-	"	lr		%2, [AUX_RTC_CTRL]	\n"
+-	"	bbit0.nt	%2, 31, 1b		\n"
+-	: "=r" (stamp.low), "=r" (stamp.high), "=r" (status));
++	/*
++	 * hardware has an internal state machine which tracks readout of
++	 * low/high and updates the CTRL.status if
++	 *  - interrupt/exception taken between the two reads
++	 *  - high increments after low has been read
++	 */
++	do {
++		stamp.low = read_aux_reg(AUX_RTC_LOW);
++		stamp.high = read_aux_reg(AUX_RTC_HIGH);
++		status = read_aux_reg(AUX_RTC_CTRL);
++	} while (!(status & _BITUL(31)));
+ 
+ 	return stamp.full;
+ }
+diff --git a/arch/mips/include/asm/kvm_host.h b/arch/mips/include/asm/kvm_host.h
+index dd7cee795709..c8c04a1f1c9f 100644
+--- a/arch/mips/include/asm/kvm_host.h
++++ b/arch/mips/include/asm/kvm_host.h
+@@ -400,7 +400,10 @@ struct kvm_vcpu_arch {
+ 	/* Host KSEG0 address of the EI/DI offset */
+ 	void *kseg0_commpage;
+ 
+-	u32 io_gpr;		/* GPR used as IO source/target */
++	/* Resume PC after MMIO completion */
++	unsigned long io_pc;
++	/* GPR used as IO source/target */
++	u32 io_gpr;
+ 
+ 	struct hrtimer comparecount_timer;
+ 	/* Count timer control KVM register */
+@@ -422,8 +425,6 @@ struct kvm_vcpu_arch {
+ 	/* Bitmask of pending exceptions to be cleared */
+ 	unsigned long pending_exceptions_clr;
+ 
+-	unsigned long pending_load_cause;
+-
+ 	/* Save/Restore the entryhi register when are are preempted/scheduled back in */
+ 	unsigned long preempt_entryhi;
+ 
+diff --git a/arch/mips/kvm/emulate.c b/arch/mips/kvm/emulate.c
+index 4298aeb1e20f..4c85ab808f99 100644
+--- a/arch/mips/kvm/emulate.c
++++ b/arch/mips/kvm/emulate.c
+@@ -1473,6 +1473,7 @@ enum emulation_result kvm_mips_emulate_load(uint32_t inst, uint32_t cause,
+ 					    struct kvm_vcpu *vcpu)
+ {
+ 	enum emulation_result er = EMULATE_DO_MMIO;
++	unsigned long curr_pc;
+ 	int32_t op, base, rt, offset;
+ 	uint32_t bytes;
+ 
+@@ -1481,7 +1482,18 @@ enum emulation_result kvm_mips_emulate_load(uint32_t inst, uint32_t cause,
+ 	offset = inst & 0xffff;
+ 	op = (inst >> 26) & 0x3f;
+ 
+-	vcpu->arch.pending_load_cause = cause;
++	/*
++	 * Find the resume PC now while we have safe and easy access to the
++	 * prior branch instruction, and save it for
++	 * kvm_mips_complete_mmio_load() to restore later.
++	 */
++	curr_pc = vcpu->arch.pc;
++	er = update_pc(vcpu, cause);
++	if (er == EMULATE_FAIL)
++		return er;
++	vcpu->arch.io_pc = vcpu->arch.pc;
++	vcpu->arch.pc = curr_pc;
++
+ 	vcpu->arch.io_gpr = rt;
+ 
+ 	switch (op) {
+@@ -2461,9 +2473,8 @@ enum emulation_result kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu,
+ 		goto done;
+ 	}
+ 
+-	er = update_pc(vcpu, vcpu->arch.pending_load_cause);
+-	if (er == EMULATE_FAIL)
+-		return er;
++	/* Restore saved resume PC */
++	vcpu->arch.pc = vcpu->arch.io_pc;
+ 
+ 	switch (run->mmio.len) {
+ 	case 4:
+@@ -2485,11 +2496,6 @@ enum emulation_result kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu,
+ 		break;
+ 	}
+ 
+-	if (vcpu->arch.pending_load_cause & CAUSEF_BD)
+-		kvm_debug("[%#lx] Completing %d byte BD Load to gpr %d (0x%08lx) type %d\n",
+-			  vcpu->arch.pc, run->mmio.len, vcpu->arch.io_gpr, *gpr,
+-			  vcpu->mmio_needed);
+-
+ done:
+ 	return er;
+ }
+diff --git a/arch/s390/hypfs/hypfs_diag.c b/arch/s390/hypfs/hypfs_diag.c
+index 045035796ca7..b63b9a42af70 100644
+--- a/arch/s390/hypfs/hypfs_diag.c
++++ b/arch/s390/hypfs/hypfs_diag.c
+@@ -525,11 +525,11 @@ static int diag224(void *ptr)
+ static int diag224_get_name_table(void)
+ {
+ 	/* memory must be below 2GB */
+-	diag224_cpu_names = kmalloc(PAGE_SIZE, GFP_KERNEL | GFP_DMA);
++	diag224_cpu_names = (char *) __get_free_page(GFP_KERNEL | GFP_DMA);
+ 	if (!diag224_cpu_names)
+ 		return -ENOMEM;
+ 	if (diag224(diag224_cpu_names)) {
+-		kfree(diag224_cpu_names);
++		free_page((unsigned long) diag224_cpu_names);
+ 		return -EOPNOTSUPP;
+ 	}
+ 	EBCASC(diag224_cpu_names + 16, (*diag224_cpu_names + 1) * 16);
+@@ -538,7 +538,7 @@ static int diag224_get_name_table(void)
+ 
+ static void diag224_delete_name_table(void)
+ {
+-	kfree(diag224_cpu_names);
++	free_page((unsigned long) diag224_cpu_names);
+ }
+ 
+ static int diag224_idx2name(int index, char *name)
+diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c
+index 3dd9c462d22a..8f8da9f92090 100644
+--- a/drivers/acpi/apei/ghes.c
++++ b/drivers/acpi/apei/ghes.c
+@@ -657,7 +657,7 @@ static int ghes_proc(struct ghes *ghes)
+ 	ghes_do_proc(ghes, ghes->estatus);
+ out:
+ 	ghes_clear_estatus(ghes);
+-	return 0;
++	return rc;
+ }
+ 
+ static void ghes_add_timer(struct ghes *ghes)
+diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
+index 74d97f4bac34..1d58854c4a9f 100644
+--- a/drivers/block/drbd/drbd_main.c
++++ b/drivers/block/drbd/drbd_main.c
+@@ -1802,7 +1802,7 @@ int drbd_send(struct drbd_connection *connection, struct socket *sock,
+  * do we need to block DRBD_SIG if sock == &meta.socket ??
+  * otherwise wake_asender() might interrupt some send_*Ack !
+  */
+-		rv = kernel_sendmsg(sock, &msg, &iov, 1, size);
++		rv = kernel_sendmsg(sock, &msg, &iov, 1, iov.iov_len);
+ 		if (rv == -EAGAIN) {
+ 			if (we_should_drop_the_connection(connection, sock))
+ 				break;
+diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c
+index 6f497aa1b276..cf25020576fa 100644
+--- a/drivers/char/hw_random/core.c
++++ b/drivers/char/hw_random/core.c
+@@ -84,14 +84,14 @@ static size_t rng_buffer_size(void)
+ 
+ static void add_early_randomness(struct hwrng *rng)
+ {
+-	unsigned char bytes[16];
+ 	int bytes_read;
++	size_t size = min_t(size_t, 16, rng_buffer_size());
+ 
+ 	mutex_lock(&reading_mutex);
+-	bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
++	bytes_read = rng_get_data(rng, rng_buffer, size, 1);
+ 	mutex_unlock(&reading_mutex);
+ 	if (bytes_read > 0)
+-		add_device_randomness(bytes, bytes_read);
++		add_device_randomness(rng_buffer, bytes_read);
+ }
+ 
+ static inline void cleanup_rng(struct kref *kref)
+diff --git a/drivers/clk/clk-qoriq.c b/drivers/clk/clk-qoriq.c
+index 8b77abb6bc22..a5070f9cb0d4 100644
+--- a/drivers/clk/clk-qoriq.c
++++ b/drivers/clk/clk-qoriq.c
+@@ -700,6 +700,7 @@ static struct clk * __init create_mux_common(struct clockgen *cg,
+ 					     struct mux_hwclock *hwc,
+ 					     const struct clk_ops *ops,
+ 					     unsigned long min_rate,
++					     unsigned long max_rate,
+ 					     unsigned long pct80_rate,
+ 					     const char *fmt, int idx)
+ {
+@@ -728,6 +729,8 @@ static struct clk * __init create_mux_common(struct clockgen *cg,
+ 			continue;
+ 		if (rate < min_rate)
+ 			continue;
++		if (rate > max_rate)
++			continue;
+ 
+ 		parent_names[j] = div->name;
+ 		hwc->parent_to_clksel[j] = i;
+@@ -759,7 +762,7 @@ static struct clk * __init create_one_cmux(struct clockgen *cg, int idx)
+ 	struct mux_hwclock *hwc;
+ 	const struct clockgen_pll_div *div;
+ 	unsigned long plat_rate, min_rate;
+-	u64 pct80_rate;
++	u64 max_rate, pct80_rate;
+ 	u32 clksel;
+ 
+ 	hwc = kzalloc(sizeof(*hwc), GFP_KERNEL);
+@@ -787,8 +790,8 @@ static struct clk * __init create_one_cmux(struct clockgen *cg, int idx)
+ 		return NULL;
+ 	}
+ 
+-	pct80_rate = clk_get_rate(div->clk);
+-	pct80_rate *= 8;
++	max_rate = clk_get_rate(div->clk);
++	pct80_rate = max_rate * 8;
+ 	do_div(pct80_rate, 10);
+ 
+ 	plat_rate = clk_get_rate(cg->pll[PLATFORM_PLL].div[PLL_DIV1].clk);
+@@ -798,7 +801,7 @@ static struct clk * __init create_one_cmux(struct clockgen *cg, int idx)
+ 	else
+ 		min_rate = plat_rate / 2;
+ 
+-	return create_mux_common(cg, hwc, &cmux_ops, min_rate,
++	return create_mux_common(cg, hwc, &cmux_ops, min_rate, max_rate,
+ 				 pct80_rate, "cg-cmux%d", idx);
+ }
+ 
+@@ -813,7 +816,7 @@ static struct clk * __init create_one_hwaccel(struct clockgen *cg, int idx)
+ 	hwc->reg = cg->regs + 0x20 * idx + 0x10;
+ 	hwc->info = cg->info.hwaccel[idx];
+ 
+-	return create_mux_common(cg, hwc, &hwaccel_ops, 0, 0,
++	return create_mux_common(cg, hwc, &hwaccel_ops, 0, ULONG_MAX, 0,
+ 				 "cg-hwaccel%d", idx);
+ }
+ 
+diff --git a/drivers/dma/at_xdmac.c b/drivers/dma/at_xdmac.c
+index 9d05d7dbcfa9..66c073fc8afc 100644
+--- a/drivers/dma/at_xdmac.c
++++ b/drivers/dma/at_xdmac.c
+@@ -864,8 +864,12 @@ at_xdmac_interleaved_queue_desc(struct dma_chan *chan,
+ 	 * access. Hopefully we can access DDR through both ports (at least on
+ 	 * SAMA5D4x), so we can use the same interface for source and dest,
+ 	 * that solves the fact we don't know the direction.
++	 * ERRATA: Even if useless for memory transfers, the PERID has to not
++	 * match the one of another channel. If not, it could lead to spurious
++	 * flag status.
+ 	 */
+-	u32			chan_cc = AT_XDMAC_CC_DIF(0)
++	u32			chan_cc = AT_XDMAC_CC_PERID(0x3f)
++					| AT_XDMAC_CC_DIF(0)
+ 					| AT_XDMAC_CC_SIF(0)
+ 					| AT_XDMAC_CC_MBSIZE_SIXTEEN
+ 					| AT_XDMAC_CC_TYPE_MEM_TRAN;
+@@ -1042,8 +1046,12 @@ at_xdmac_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
+ 	 * access DDR through both ports (at least on SAMA5D4x), so we can use
+ 	 * the same interface for source and dest, that solves the fact we
+ 	 * don't know the direction.
++	 * ERRATA: Even if useless for memory transfers, the PERID has to not
++	 * match the one of another channel. If not, it could lead to spurious
++	 * flag status.
+ 	 */
+-	u32			chan_cc = AT_XDMAC_CC_DAM_INCREMENTED_AM
++	u32			chan_cc = AT_XDMAC_CC_PERID(0x3f)
++					| AT_XDMAC_CC_DAM_INCREMENTED_AM
+ 					| AT_XDMAC_CC_SAM_INCREMENTED_AM
+ 					| AT_XDMAC_CC_DIF(0)
+ 					| AT_XDMAC_CC_SIF(0)
+@@ -1144,8 +1152,12 @@ static struct at_xdmac_desc *at_xdmac_memset_create_desc(struct dma_chan *chan,
+ 	 * access. Hopefully we can access DDR through both ports (at least on
+ 	 * SAMA5D4x), so we can use the same interface for source and dest,
+ 	 * that solves the fact we don't know the direction.
++	 * ERRATA: Even if useless for memory transfers, the PERID has to not
++	 * match the one of another channel. If not, it could lead to spurious
++	 * flag status.
+ 	 */
+-	u32			chan_cc = AT_XDMAC_CC_DAM_UBS_AM
++	u32			chan_cc = AT_XDMAC_CC_PERID(0x3f)
++					| AT_XDMAC_CC_DAM_UBS_AM
+ 					| AT_XDMAC_CC_SAM_INCREMENTED_AM
+ 					| AT_XDMAC_CC_DIF(0)
+ 					| AT_XDMAC_CC_SIF(0)
+diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
+index 3b92cad8bef2..1ea8532f5ab2 100644
+--- a/drivers/gpu/drm/i915/intel_hdmi.c
++++ b/drivers/gpu/drm/i915/intel_hdmi.c
+@@ -1997,6 +1997,50 @@ intel_hdmi_add_properties(struct intel_hdmi *intel_hdmi, struct drm_connector *c
+ 	intel_hdmi->aspect_ratio = HDMI_PICTURE_ASPECT_NONE;
+ }
+ 
++static u8 intel_hdmi_ddc_pin(struct drm_i915_private *dev_priv,
++			     enum port port)
++{
++	const struct ddi_vbt_port_info *info =
++		&dev_priv->vbt.ddi_port_info[port];
++	u8 ddc_pin;
++
++	if (info->alternate_ddc_pin) {
++		DRM_DEBUG_KMS("Using DDC pin 0x%x for port %c (VBT)\n",
++			      info->alternate_ddc_pin, port_name(port));
++		return info->alternate_ddc_pin;
++	}
++
++	switch (port) {
++	case PORT_B:
++		if (IS_BROXTON(dev_priv))
++			ddc_pin = GMBUS_PIN_1_BXT;
++		else
++			ddc_pin = GMBUS_PIN_DPB;
++		break;
++	case PORT_C:
++		if (IS_BROXTON(dev_priv))
++			ddc_pin = GMBUS_PIN_2_BXT;
++		else
++			ddc_pin = GMBUS_PIN_DPC;
++		break;
++	case PORT_D:
++		if (IS_CHERRYVIEW(dev_priv))
++			ddc_pin = GMBUS_PIN_DPD_CHV;
++		else
++			ddc_pin = GMBUS_PIN_DPD;
++		break;
++	default:
++		MISSING_CASE(port);
++		ddc_pin = GMBUS_PIN_DPB;
++		break;
++	}
++
++	DRM_DEBUG_KMS("Using DDC pin 0x%x for port %c (platform default)\n",
++		      ddc_pin, port_name(port));
++
++	return ddc_pin;
++}
++
+ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
+ 			       struct intel_connector *intel_connector)
+ {
+@@ -2006,7 +2050,6 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
+ 	struct drm_device *dev = intel_encoder->base.dev;
+ 	struct drm_i915_private *dev_priv = dev->dev_private;
+ 	enum port port = intel_dig_port->port;
+-	uint8_t alternate_ddc_pin;
+ 
+ 	DRM_DEBUG_KMS("Adding HDMI connector on port %c\n",
+ 		      port_name(port));
+@@ -2019,12 +2062,10 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
+ 	connector->doublescan_allowed = 0;
+ 	connector->stereo_allowed = 1;
+ 
++	intel_hdmi->ddc_bus = intel_hdmi_ddc_pin(dev_priv, port);
++
+ 	switch (port) {
+ 	case PORT_B:
+-		if (IS_BROXTON(dev_priv))
+-			intel_hdmi->ddc_bus = GMBUS_PIN_1_BXT;
+-		else
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPB;
+ 		/*
+ 		 * On BXT A0/A1, sw needs to activate DDIA HPD logic and
+ 		 * interrupts to check the external panel connection.
+@@ -2035,46 +2076,17 @@ void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port,
+ 			intel_encoder->hpd_pin = HPD_PORT_B;
+ 		break;
+ 	case PORT_C:
+-		if (IS_BROXTON(dev_priv))
+-			intel_hdmi->ddc_bus = GMBUS_PIN_2_BXT;
+-		else
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPC;
+ 		intel_encoder->hpd_pin = HPD_PORT_C;
+ 		break;
+ 	case PORT_D:
+-		if (WARN_ON(IS_BROXTON(dev_priv)))
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DISABLED;
+-		else if (IS_CHERRYVIEW(dev_priv))
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPD_CHV;
+-		else
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPD;
+ 		intel_encoder->hpd_pin = HPD_PORT_D;
+ 		break;
+ 	case PORT_E:
+-		/* On SKL PORT E doesn't have seperate GMBUS pin
+-		 *  We rely on VBT to set a proper alternate GMBUS pin. */
+-		alternate_ddc_pin =
+-			dev_priv->vbt.ddi_port_info[PORT_E].alternate_ddc_pin;
+-		switch (alternate_ddc_pin) {
+-		case DDC_PIN_B:
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPB;
+-			break;
+-		case DDC_PIN_C:
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPC;
+-			break;
+-		case DDC_PIN_D:
+-			intel_hdmi->ddc_bus = GMBUS_PIN_DPD;
+-			break;
+-		default:
+-			MISSING_CASE(alternate_ddc_pin);
+-		}
+ 		intel_encoder->hpd_pin = HPD_PORT_E;
+ 		break;
+-	case PORT_A:
+-		intel_encoder->hpd_pin = HPD_PORT_A;
+-		/* Internal port only for eDP. */
+ 	default:
+-		BUG();
++		MISSING_CASE(port);
++		return;
+ 	}
+ 
+ 	if (IS_VALLEYVIEW(dev)) {
+diff --git a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
+index dc33c1dd5191..b5beea53d6f6 100644
+--- a/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
++++ b/drivers/iio/common/hid-sensors/hid-sensor-attributes.c
+@@ -30,26 +30,26 @@ static struct {
+ 	u32 usage_id;
+ 	int unit; /* 0 for default others from HID sensor spec */
+ 	int scale_val0; /* scale, whole number */
+-	int scale_val1; /* scale, fraction in micros */
++	int scale_val1; /* scale, fraction in nanos */
+ } unit_conversion[] = {
+-	{HID_USAGE_SENSOR_ACCEL_3D, 0, 9, 806650},
++	{HID_USAGE_SENSOR_ACCEL_3D, 0, 9, 806650000},
+ 	{HID_USAGE_SENSOR_ACCEL_3D,
+ 		HID_USAGE_SENSOR_UNITS_METERS_PER_SEC_SQRD, 1, 0},
+ 	{HID_USAGE_SENSOR_ACCEL_3D,
+-		HID_USAGE_SENSOR_UNITS_G, 9, 806650},
++		HID_USAGE_SENSOR_UNITS_G, 9, 806650000},
+ 
+-	{HID_USAGE_SENSOR_GYRO_3D, 0, 0, 17453},
++	{HID_USAGE_SENSOR_GYRO_3D, 0, 0, 17453293},
+ 	{HID_USAGE_SENSOR_GYRO_3D,
+ 		HID_USAGE_SENSOR_UNITS_RADIANS_PER_SECOND, 1, 0},
+ 	{HID_USAGE_SENSOR_GYRO_3D,
+-		HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND, 0, 17453},
++		HID_USAGE_SENSOR_UNITS_DEGREES_PER_SECOND, 0, 17453293},
+ 
+-	{HID_USAGE_SENSOR_COMPASS_3D, 0, 0, 1000},
++	{HID_USAGE_SENSOR_COMPASS_3D, 0, 0, 1000000},
+ 	{HID_USAGE_SENSOR_COMPASS_3D, HID_USAGE_SENSOR_UNITS_GAUSS, 1, 0},
+ 
+-	{HID_USAGE_SENSOR_INCLINOMETER_3D, 0, 0, 17453},
++	{HID_USAGE_SENSOR_INCLINOMETER_3D, 0, 0, 17453293},
+ 	{HID_USAGE_SENSOR_INCLINOMETER_3D,
+-		HID_USAGE_SENSOR_UNITS_DEGREES, 0, 17453},
++		HID_USAGE_SENSOR_UNITS_DEGREES, 0, 17453293},
+ 	{HID_USAGE_SENSOR_INCLINOMETER_3D,
+ 		HID_USAGE_SENSOR_UNITS_RADIANS, 1, 0},
+ 
+@@ -57,7 +57,7 @@ static struct {
+ 	{HID_USAGE_SENSOR_ALS, HID_USAGE_SENSOR_UNITS_LUX, 1, 0},
+ 
+ 	{HID_USAGE_SENSOR_PRESSURE, 0, 100, 0},
+-	{HID_USAGE_SENSOR_PRESSURE, HID_USAGE_SENSOR_UNITS_PASCAL, 0, 1000},
++	{HID_USAGE_SENSOR_PRESSURE, HID_USAGE_SENSOR_UNITS_PASCAL, 0, 1000000},
+ };
+ 
+ static int pow_10(unsigned power)
+@@ -266,15 +266,15 @@ EXPORT_SYMBOL(hid_sensor_write_raw_hyst_value);
+ /*
+  * This fuction applies the unit exponent to the scale.
+  * For example:
+- * 9.806650 ->exp:2-> val0[980]val1[665000]
+- * 9.000806 ->exp:2-> val0[900]val1[80600]
+- * 0.174535 ->exp:2-> val0[17]val1[453500]
+- * 1.001745 ->exp:0-> val0[1]val1[1745]
+- * 1.001745 ->exp:2-> val0[100]val1[174500]
+- * 1.001745 ->exp:4-> val0[10017]val1[450000]
+- * 9.806650 ->exp:-2-> val0[0]val1[98066]
++ * 9.806650000 ->exp:2-> val0[980]val1[665000000]
++ * 9.000806000 ->exp:2-> val0[900]val1[80600000]
++ * 0.174535293 ->exp:2-> val0[17]val1[453529300]
++ * 1.001745329 ->exp:0-> val0[1]val1[1745329]
++ * 1.001745329 ->exp:2-> val0[100]val1[174532900]
++ * 1.001745329 ->exp:4-> val0[10017]val1[453290000]
++ * 9.806650000 ->exp:-2-> val0[0]val1[98066500]
+  */
+-static void adjust_exponent_micro(int *val0, int *val1, int scale0,
++static void adjust_exponent_nano(int *val0, int *val1, int scale0,
+ 				  int scale1, int exp)
+ {
+ 	int i;
+@@ -285,32 +285,32 @@ static void adjust_exponent_micro(int *val0, int *val1, int scale0,
+ 	if (exp > 0) {
+ 		*val0 = scale0 * pow_10(exp);
+ 		res = 0;
+-		if (exp > 6) {
++		if (exp > 9) {
+ 			*val1 = 0;
+ 			return;
+ 		}
+ 		for (i = 0; i < exp; ++i) {
+-			x = scale1 / pow_10(5 - i);
++			x = scale1 / pow_10(8 - i);
+ 			res += (pow_10(exp - 1 - i) * x);
+-			scale1 = scale1 % pow_10(5 - i);
++			scale1 = scale1 % pow_10(8 - i);
+ 		}
+ 		*val0 += res;
+ 			*val1 = scale1 * pow_10(exp);
+ 	} else if (exp < 0) {
+ 		exp = abs(exp);
+-		if (exp > 6) {
++		if (exp > 9) {
+ 			*val0 = *val1 = 0;
+ 			return;
+ 		}
+ 		*val0 = scale0 / pow_10(exp);
+ 		rem = scale0 % pow_10(exp);
+ 		res = 0;
+-		for (i = 0; i < (6 - exp); ++i) {
+-			x = scale1 / pow_10(5 - i);
+-			res += (pow_10(5 - exp - i) * x);
+-			scale1 = scale1 % pow_10(5 - i);
++		for (i = 0; i < (9 - exp); ++i) {
++			x = scale1 / pow_10(8 - i);
++			res += (pow_10(8 - exp - i) * x);
++			scale1 = scale1 % pow_10(8 - i);
+ 		}
+-		*val1 = rem * pow_10(6 - exp) + res;
++		*val1 = rem * pow_10(9 - exp) + res;
+ 	} else {
+ 		*val0 = scale0;
+ 		*val1 = scale1;
+@@ -332,14 +332,14 @@ int hid_sensor_format_scale(u32 usage_id,
+ 			unit_conversion[i].unit == attr_info->units) {
+ 			exp  = hid_sensor_convert_exponent(
+ 						attr_info->unit_expo);
+-			adjust_exponent_micro(val0, val1,
++			adjust_exponent_nano(val0, val1,
+ 					unit_conversion[i].scale_val0,
+ 					unit_conversion[i].scale_val1, exp);
+ 			break;
+ 		}
+ 	}
+ 
+-	return IIO_VAL_INT_PLUS_MICRO;
++	return IIO_VAL_INT_PLUS_NANO;
+ }
+ EXPORT_SYMBOL(hid_sensor_format_scale);
+ 
+diff --git a/drivers/iio/orientation/hid-sensor-rotation.c b/drivers/iio/orientation/hid-sensor-rotation.c
+index b98b9d94d184..a97e802ca523 100644
+--- a/drivers/iio/orientation/hid-sensor-rotation.c
++++ b/drivers/iio/orientation/hid-sensor-rotation.c
+@@ -335,6 +335,7 @@ static struct platform_driver hid_dev_rot_platform_driver = {
+ 	.id_table = hid_dev_rot_ids,
+ 	.driver = {
+ 		.name	= KBUILD_MODNAME,
++		.pm     = &hid_sensor_pm_ops,
+ 	},
+ 	.probe		= hid_dev_rot_probe,
+ 	.remove		= hid_dev_rot_remove,
+diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
+index 0397985a2601..5975d76ce755 100644
+--- a/drivers/iommu/amd_iommu.c
++++ b/drivers/iommu/amd_iommu.c
+@@ -1833,6 +1833,9 @@ static void dma_ops_domain_free(struct dma_ops_domain *dom)
+ 		kfree(dom->aperture[i]);
+ 	}
+ 
++	if (dom->domain.id)
++		domain_id_free(dom->domain.id);
++
+ 	kfree(dom);
+ }
+ 
+diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
+index b7f852d824a3..5baa830ce49f 100644
+--- a/drivers/iommu/intel-iommu.c
++++ b/drivers/iommu/intel-iommu.c
+@@ -1672,6 +1672,7 @@ static void disable_dmar_iommu(struct intel_iommu *iommu)
+ 	if (!iommu->domains || !iommu->domain_ids)
+ 		return;
+ 
++again:
+ 	spin_lock_irqsave(&device_domain_lock, flags);
+ 	list_for_each_entry_safe(info, tmp, &device_domain_list, global) {
+ 		struct dmar_domain *domain;
+@@ -1684,10 +1685,19 @@ static void disable_dmar_iommu(struct intel_iommu *iommu)
+ 
+ 		domain = info->domain;
+ 
+-		dmar_remove_one_dev_info(domain, info->dev);
++		__dmar_remove_one_dev_info(info);
+ 
+-		if (!domain_type_is_vm_or_si(domain))
++		if (!domain_type_is_vm_or_si(domain)) {
++			/*
++			 * The domain_exit() function  can't be called under
++			 * device_domain_lock, as it takes this lock itself.
++			 * So release the lock here and re-run the loop
++			 * afterwards.
++			 */
++			spin_unlock_irqrestore(&device_domain_lock, flags);
+ 			domain_exit(domain);
++			goto again;
++		}
+ 	}
+ 	spin_unlock_irqrestore(&device_domain_lock, flags);
+ 
+diff --git a/drivers/media/usb/dvb-usb/dib0700_core.c b/drivers/media/usb/dvb-usb/dib0700_core.c
+index 0d248ce02a9b..ab58f0b9da5c 100644
+--- a/drivers/media/usb/dvb-usb/dib0700_core.c
++++ b/drivers/media/usb/dvb-usb/dib0700_core.c
+@@ -677,7 +677,7 @@ static void dib0700_rc_urb_completion(struct urb *purb)
+ 	struct dvb_usb_device *d = purb->context;
+ 	struct dib0700_rc_response *poll_reply;
+ 	enum rc_type protocol;
+-	u32 uninitialized_var(keycode);
++	u32 keycode;
+ 	u8 toggle;
+ 
+ 	deb_info("%s()\n", __func__);
+@@ -719,7 +719,8 @@ static void dib0700_rc_urb_completion(struct urb *purb)
+ 		    poll_reply->nec.data       == 0x00 &&
+ 		    poll_reply->nec.not_data   == 0xff) {
+ 			poll_reply->data_state = 2;
+-			break;
++			rc_repeat(d->rc_dev);
++			goto resubmit;
+ 		}
+ 
+ 		if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) {
+diff --git a/drivers/misc/mei/bus-fixup.c b/drivers/misc/mei/bus-fixup.c
+index 020de5919c21..bdc7fcd80eca 100644
+--- a/drivers/misc/mei/bus-fixup.c
++++ b/drivers/misc/mei/bus-fixup.c
+@@ -151,7 +151,7 @@ static int mei_nfc_if_version(struct mei_cl *cl,
+ 
+ 	ret = 0;
+ 	bytes_recv = __mei_cl_recv(cl, (u8 *)reply, if_version_length);
+-	if (bytes_recv < 0 || bytes_recv < sizeof(struct mei_nfc_reply)) {
++	if (bytes_recv < if_version_length) {
+ 		dev_err(bus->dev, "Could not read IF version\n");
+ 		ret = -EIO;
+ 		goto err;
+diff --git a/drivers/mmc/host/mxs-mmc.c b/drivers/mmc/host/mxs-mmc.c
+index d839147e591d..44ecebd1ea8c 100644
+--- a/drivers/mmc/host/mxs-mmc.c
++++ b/drivers/mmc/host/mxs-mmc.c
+@@ -661,13 +661,13 @@ static int mxs_mmc_probe(struct platform_device *pdev)
+ 
+ 	platform_set_drvdata(pdev, mmc);
+ 
++	spin_lock_init(&host->lock);
++
+ 	ret = devm_request_irq(&pdev->dev, irq_err, mxs_mmc_irq_handler, 0,
+ 			       dev_name(&pdev->dev), host);
+ 	if (ret)
+ 		goto out_free_dma;
+ 
+-	spin_lock_init(&host->lock);
+-
+ 	ret = mmc_add_host(mmc);
+ 	if (ret)
+ 		goto out_free_dma;
+diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
+index 979cc024bca7..4edbab6ca7ef 100644
+--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
+@@ -8595,7 +8595,7 @@ static int i40e_ndo_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
+ 		return 0;
+ 
+ 	return ndo_dflt_bridge_getlink(skb, pid, seq, dev, veb->bridge_mode,
+-				       nlflags, 0, 0, filter_mask, NULL);
++				       0, 0, nlflags, filter_mask, NULL);
+ }
+ 
+ #define I40E_MAX_TUNNEL_HDR_LEN 80
+diff --git a/drivers/nfc/mei_phy.c b/drivers/nfc/mei_phy.c
+index 83deda4bb4d6..6f9563a96488 100644
+--- a/drivers/nfc/mei_phy.c
++++ b/drivers/nfc/mei_phy.c
+@@ -133,7 +133,7 @@ static int mei_nfc_if_version(struct nfc_mei_phy *phy)
+ 		return -ENOMEM;
+ 
+ 	bytes_recv = mei_cldev_recv(phy->cldev, (u8 *)reply, if_version_length);
+-	if (bytes_recv < 0 || bytes_recv < sizeof(struct mei_nfc_reply)) {
++	if (bytes_recv < 0 || bytes_recv < if_version_length) {
+ 		pr_err("Could not read IF version\n");
+ 		r = -EIO;
+ 		goto err;
+diff --git a/drivers/pinctrl/intel/pinctrl-cherryview.c b/drivers/pinctrl/intel/pinctrl-cherryview.c
+index 4e377599d266..a009ae34c5ef 100644
+--- a/drivers/pinctrl/intel/pinctrl-cherryview.c
++++ b/drivers/pinctrl/intel/pinctrl-cherryview.c
+@@ -1564,12 +1564,15 @@ static int chv_pinctrl_remove(struct platform_device *pdev)
+ }
+ 
+ #ifdef CONFIG_PM_SLEEP
+-static int chv_pinctrl_suspend(struct device *dev)
++static int chv_pinctrl_suspend_noirq(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct chv_pinctrl *pctrl = platform_get_drvdata(pdev);
++	unsigned long flags;
+ 	int i;
+ 
++	raw_spin_lock_irqsave(&chv_lock, flags);
++
+ 	pctrl->saved_intmask = readl(pctrl->regs + CHV_INTMASK);
+ 
+ 	for (i = 0; i < pctrl->community->npins; i++) {
+@@ -1590,15 +1593,20 @@ static int chv_pinctrl_suspend(struct device *dev)
+ 		ctx->padctrl1 = readl(reg);
+ 	}
+ 
++	raw_spin_unlock_irqrestore(&chv_lock, flags);
++
+ 	return 0;
+ }
+ 
+-static int chv_pinctrl_resume(struct device *dev)
++static int chv_pinctrl_resume_noirq(struct device *dev)
+ {
+ 	struct platform_device *pdev = to_platform_device(dev);
+ 	struct chv_pinctrl *pctrl = platform_get_drvdata(pdev);
++	unsigned long flags;
+ 	int i;
+ 
++	raw_spin_lock_irqsave(&chv_lock, flags);
++
+ 	/*
+ 	 * Mask all interrupts before restoring per-pin configuration
+ 	 * registers because we don't know in which state BIOS left them
+@@ -1643,12 +1651,15 @@ static int chv_pinctrl_resume(struct device *dev)
+ 	chv_writel(0xffff, pctrl->regs + CHV_INTSTAT);
+ 	chv_writel(pctrl->saved_intmask, pctrl->regs + CHV_INTMASK);
+ 
++	raw_spin_unlock_irqrestore(&chv_lock, flags);
++
+ 	return 0;
+ }
+ #endif
+ 
+ static const struct dev_pm_ops chv_pinctrl_pm_ops = {
+-	SET_LATE_SYSTEM_SLEEP_PM_OPS(chv_pinctrl_suspend, chv_pinctrl_resume)
++	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(chv_pinctrl_suspend_noirq,
++				      chv_pinctrl_resume_noirq)
+ };
+ 
+ static const struct acpi_device_id chv_pinctrl_acpi_match[] = {
+diff --git a/drivers/platform/x86/toshiba-wmi.c b/drivers/platform/x86/toshiba-wmi.c
+index feac4576b837..2df07ee8f3c3 100644
+--- a/drivers/platform/x86/toshiba-wmi.c
++++ b/drivers/platform/x86/toshiba-wmi.c
+@@ -24,14 +24,15 @@
+ #include <linux/acpi.h>
+ #include <linux/input.h>
+ #include <linux/input/sparse-keymap.h>
++#include <linux/dmi.h>
+ 
+ MODULE_AUTHOR("Azael Avalos");
+ MODULE_DESCRIPTION("Toshiba WMI Hotkey Driver");
+ MODULE_LICENSE("GPL");
+ 
+-#define TOSHIBA_WMI_EVENT_GUID	"59142400-C6A3-40FA-BADB-8A2652834100"
++#define WMI_EVENT_GUID	"59142400-C6A3-40FA-BADB-8A2652834100"
+ 
+-MODULE_ALIAS("wmi:"TOSHIBA_WMI_EVENT_GUID);
++MODULE_ALIAS("wmi:"WMI_EVENT_GUID);
+ 
+ static struct input_dev *toshiba_wmi_input_dev;
+ 
+@@ -63,6 +64,16 @@ static void toshiba_wmi_notify(u32 value, void *context)
+ 	kfree(response.pointer);
+ }
+ 
++static struct dmi_system_id toshiba_wmi_dmi_table[] __initdata = {
++	{
++		.ident = "Toshiba laptop",
++		.matches = {
++			DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
++		},
++	},
++	{}
++};
++
+ static int __init toshiba_wmi_input_setup(void)
+ {
+ 	acpi_status status;
+@@ -81,7 +92,7 @@ static int __init toshiba_wmi_input_setup(void)
+ 	if (err)
+ 		goto err_free_dev;
+ 
+-	status = wmi_install_notify_handler(TOSHIBA_WMI_EVENT_GUID,
++	status = wmi_install_notify_handler(WMI_EVENT_GUID,
+ 					    toshiba_wmi_notify, NULL);
+ 	if (ACPI_FAILURE(status)) {
+ 		err = -EIO;
+@@ -95,7 +106,7 @@ static int __init toshiba_wmi_input_setup(void)
+ 	return 0;
+ 
+  err_remove_notifier:
+-	wmi_remove_notify_handler(TOSHIBA_WMI_EVENT_GUID);
++	wmi_remove_notify_handler(WMI_EVENT_GUID);
+  err_free_keymap:
+ 	sparse_keymap_free(toshiba_wmi_input_dev);
+  err_free_dev:
+@@ -105,7 +116,7 @@ static int __init toshiba_wmi_input_setup(void)
+ 
+ static void toshiba_wmi_input_destroy(void)
+ {
+-	wmi_remove_notify_handler(TOSHIBA_WMI_EVENT_GUID);
++	wmi_remove_notify_handler(WMI_EVENT_GUID);
+ 	sparse_keymap_free(toshiba_wmi_input_dev);
+ 	input_unregister_device(toshiba_wmi_input_dev);
+ }
+@@ -114,7 +125,8 @@ static int __init toshiba_wmi_init(void)
+ {
+ 	int ret;
+ 
+-	if (!wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
++	if (!wmi_has_guid(WMI_EVENT_GUID) ||
++	    !dmi_check_system(toshiba_wmi_dmi_table))
+ 		return -ENODEV;
+ 
+ 	ret = toshiba_wmi_input_setup();
+@@ -130,7 +142,7 @@ static int __init toshiba_wmi_init(void)
+ 
+ static void __exit toshiba_wmi_exit(void)
+ {
+-	if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
++	if (wmi_has_guid(WMI_EVENT_GUID))
+ 		toshiba_wmi_input_destroy();
+ }
+ 
+diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+index 0969cea1089a..2d867c5bfd9f 100644
+--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
++++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+@@ -1275,9 +1275,9 @@ scsih_target_alloc(struct scsi_target *starget)
+ 			sas_target_priv_data->handle = raid_device->handle;
+ 			sas_target_priv_data->sas_address = raid_device->wwid;
+ 			sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
+-			sas_target_priv_data->raid_device = raid_device;
+ 			if (ioc->is_warpdrive)
+-				raid_device->starget = starget;
++				sas_target_priv_data->raid_device = raid_device;
++			raid_device->starget = starget;
+ 		}
+ 		spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+ 		return 0;
+diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
+index fc6674db4f2d..c44cbf46221c 100644
+--- a/drivers/scsi/qla2xxx/qla_os.c
++++ b/drivers/scsi/qla2xxx/qla_os.c
+@@ -2257,6 +2257,8 @@ qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time)
+ {
+ 	scsi_qla_host_t *vha = shost_priv(shost);
+ 
++	if (test_bit(UNLOADING, &vha->dpc_flags))
++		return 1;
+ 	if (!vha->host)
+ 		return 1;
+ 	if (time > vha->hw->loop_reset_delay * HZ)
+diff --git a/drivers/staging/iio/impedance-analyzer/ad5933.c b/drivers/staging/iio/impedance-analyzer/ad5933.c
+index 10c43dda0f5a..196da09e20a1 100644
+--- a/drivers/staging/iio/impedance-analyzer/ad5933.c
++++ b/drivers/staging/iio/impedance-analyzer/ad5933.c
+@@ -647,6 +647,7 @@ static void ad5933_work(struct work_struct *work)
+ 	__be16 buf[2];
+ 	int val[2];
+ 	unsigned char status;
++	int ret;
+ 
+ 	mutex_lock(&indio_dev->mlock);
+ 	if (st->state == AD5933_CTRL_INIT_START_FREQ) {
+@@ -654,19 +655,22 @@ static void ad5933_work(struct work_struct *work)
+ 		ad5933_cmd(st, AD5933_CTRL_START_SWEEP);
+ 		st->state = AD5933_CTRL_START_SWEEP;
+ 		schedule_delayed_work(&st->work, st->poll_time_jiffies);
+-		mutex_unlock(&indio_dev->mlock);
+-		return;
++		goto out;
+ 	}
+ 
+-	ad5933_i2c_read(st->client, AD5933_REG_STATUS, 1, &status);
++	ret = ad5933_i2c_read(st->client, AD5933_REG_STATUS, 1, &status);
++	if (ret)
++		goto out;
+ 
+ 	if (status & AD5933_STAT_DATA_VALID) {
+ 		int scan_count = bitmap_weight(indio_dev->active_scan_mask,
+ 					       indio_dev->masklength);
+-		ad5933_i2c_read(st->client,
++		ret = ad5933_i2c_read(st->client,
+ 				test_bit(1, indio_dev->active_scan_mask) ?
+ 				AD5933_REG_REAL_DATA : AD5933_REG_IMAG_DATA,
+ 				scan_count * 2, (u8 *)buf);
++		if (ret)
++			goto out;
+ 
+ 		if (scan_count == 2) {
+ 			val[0] = be16_to_cpu(buf[0]);
+@@ -678,8 +682,7 @@ static void ad5933_work(struct work_struct *work)
+ 	} else {
+ 		/* no data available - try again later */
+ 		schedule_delayed_work(&st->work, st->poll_time_jiffies);
+-		mutex_unlock(&indio_dev->mlock);
+-		return;
++		goto out;
+ 	}
+ 
+ 	if (status & AD5933_STAT_SWEEP_DONE) {
+@@ -691,7 +694,7 @@ static void ad5933_work(struct work_struct *work)
+ 		ad5933_cmd(st, AD5933_CTRL_INC_FREQ);
+ 		schedule_delayed_work(&st->work, st->poll_time_jiffies);
+ 	}
+-
++out:
+ 	mutex_unlock(&indio_dev->mlock);
+ }
+ 
+diff --git a/drivers/staging/nvec/nvec_ps2.c b/drivers/staging/nvec/nvec_ps2.c
+index 0922dd3a08d3..196f6b0a288f 100644
+--- a/drivers/staging/nvec/nvec_ps2.c
++++ b/drivers/staging/nvec/nvec_ps2.c
+@@ -106,13 +106,12 @@ static int nvec_mouse_probe(struct platform_device *pdev)
+ {
+ 	struct nvec_chip *nvec = dev_get_drvdata(pdev->dev.parent);
+ 	struct serio *ser_dev;
+-	char mouse_reset[] = { NVEC_PS2, SEND_COMMAND, PSMOUSE_RST, 3 };
+ 
+-	ser_dev = devm_kzalloc(&pdev->dev, sizeof(struct serio), GFP_KERNEL);
++	ser_dev = kzalloc(sizeof(struct serio), GFP_KERNEL);
+ 	if (!ser_dev)
+ 		return -ENOMEM;
+ 
+-	ser_dev->id.type = SERIO_PS_PSTHRU;
++	ser_dev->id.type = SERIO_8042;
+ 	ser_dev->write = ps2_sendcommand;
+ 	ser_dev->start = ps2_startstreaming;
+ 	ser_dev->stop = ps2_stopstreaming;
+@@ -127,9 +126,6 @@ static int nvec_mouse_probe(struct platform_device *pdev)
+ 
+ 	serio_register_port(ser_dev);
+ 
+-	/* mouse reset */
+-	nvec_write_async(nvec, mouse_reset, sizeof(mouse_reset));
+-
+ 	return 0;
+ }
+ 
+diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
+index 7b5462eb8388..e0b89b961e1b 100644
+--- a/drivers/tty/serial/atmel_serial.c
++++ b/drivers/tty/serial/atmel_serial.c
+@@ -2075,6 +2075,7 @@ static void atmel_serial_pm(struct uart_port *port, unsigned int state,
+ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
+ 			      struct ktermios *old)
+ {
++	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
+ 	unsigned long flags;
+ 	unsigned int old_mode, mode, imr, quot, baud;
+ 
+@@ -2178,11 +2179,29 @@ static void atmel_set_termios(struct uart_port *port, struct ktermios *termios,
+ 		mode |= ATMEL_US_USMODE_RS485;
+ 	} else if (termios->c_cflag & CRTSCTS) {
+ 		/* RS232 with hardware handshake (RTS/CTS) */
+-		if (atmel_use_dma_rx(port) && !atmel_use_fifo(port)) {
+-			dev_info(port->dev, "not enabling hardware flow control because DMA is used");
+-			termios->c_cflag &= ~CRTSCTS;
+-		} else {
++		if (atmel_use_fifo(port) &&
++		    !mctrl_gpio_to_gpiod(atmel_port->gpios, UART_GPIO_CTS)) {
++			/*
++			 * with ATMEL_US_USMODE_HWHS set, the controller will
++			 * be able to drive the RTS pin high/low when the RX
++			 * FIFO is above RXFTHRES/below RXFTHRES2.
++			 * It will also disable the transmitter when the CTS
++			 * pin is high.
++			 * This mode is not activated if CTS pin is a GPIO
++			 * because in this case, the transmitter is always
++			 * disabled (there must be an internal pull-up
++			 * responsible for this behaviour).
++			 * If the RTS pin is a GPIO, the controller won't be
++			 * able to drive it according to the FIFO thresholds,
++			 * but it will be handled by the driver.
++			 */
+ 			mode |= ATMEL_US_USMODE_HWHS;
++		} else {
++			/*
++			 * For platforms without FIFO, the flow control is
++			 * handled by the driver.
++			 */
++			mode |= ATMEL_US_USMODE_NORMAL;
+ 		}
+ 	} else {
+ 		/* RS232 without hadware handshake */
+diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
+index 7f374369e539..4d77745f439f 100644
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -877,8 +877,6 @@ static int wait_serial_change(struct acm *acm, unsigned long arg)
+ 	DECLARE_WAITQUEUE(wait, current);
+ 	struct async_icount old, new;
+ 
+-	if (arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD ))
+-		return -EINVAL;
+ 	do {
+ 		spin_lock_irq(&acm->read_lock);
+ 		old = acm->oldcount;
+diff --git a/drivers/usb/gadget/function/u_ether.c b/drivers/usb/gadget/function/u_ether.c
+index b644248f4b8e..7413f89660f7 100644
+--- a/drivers/usb/gadget/function/u_ether.c
++++ b/drivers/usb/gadget/function/u_ether.c
+@@ -594,14 +594,6 @@ static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
+ 
+ 	req->length = length;
+ 
+-	/* throttle high/super speed IRQ rate back slightly */
+-	if (gadget_is_dualspeed(dev->gadget))
+-		req->no_interrupt = (((dev->gadget->speed == USB_SPEED_HIGH ||
+-				       dev->gadget->speed == USB_SPEED_SUPER)) &&
+-					!list_empty(&dev->tx_reqs))
+-			? ((atomic_read(&dev->tx_qlen) % dev->qmult) != 0)
+-			: 0;
+-
+ 	retval = usb_ep_queue(in, req, GFP_ATOMIC);
+ 	switch (retval) {
+ 	default:
+diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
+index 4bc9dbf29a73..3cff6523f27d 100644
+--- a/fs/btrfs/inode.c
++++ b/fs/btrfs/inode.c
+@@ -8691,9 +8691,14 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
+ 	 *    So even we call qgroup_free_data(), it won't decrease reserved
+ 	 *    space.
+ 	 * 2) Not written to disk
+-	 *    This means the reserved space should be freed here.
++	 *    This means the reserved space should be freed here. However,
++	 *    if a truncate invalidates the page (by clearing PageDirty)
++	 *    and the page is accounted for while allocating extent
++	 *    in btrfs_check_data_free_space() we let delayed_ref to
++	 *    free the entire extent.
+ 	 */
+-	btrfs_qgroup_free_data(inode, page_start, PAGE_CACHE_SIZE);
++	if (PageDirty(page))
++		btrfs_qgroup_free_data(inode, page_start, PAGE_SIZE);
+ 	if (!inode_evicting) {
+ 		clear_extent_bit(tree, page_start, page_end,
+ 				 EXTENT_LOCKED | EXTENT_DIRTY |
+diff --git a/fs/coredump.c b/fs/coredump.c
+index dfc87c5f5a54..5d15c4975ba1 100644
+--- a/fs/coredump.c
++++ b/fs/coredump.c
+@@ -1,6 +1,7 @@
+ #include <linux/slab.h>
+ #include <linux/file.h>
+ #include <linux/fdtable.h>
++#include <linux/freezer.h>
+ #include <linux/mm.h>
+ #include <linux/stat.h>
+ #include <linux/fcntl.h>
+@@ -399,7 +400,9 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
+ 	if (core_waiters > 0) {
+ 		struct core_thread *ptr;
+ 
++		freezer_do_not_count();
+ 		wait_for_completion(&core_state->startup);
++		freezer_count();
+ 		/*
+ 		 * Wait for all the threads to become inactive, so that
+ 		 * all the thread context (extended register state, like
+diff --git a/lib/genalloc.c b/lib/genalloc.c
+index 116a166b096f..27aa9c629d13 100644
+--- a/lib/genalloc.c
++++ b/lib/genalloc.c
+@@ -273,7 +273,7 @@ unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
+ 	struct gen_pool_chunk *chunk;
+ 	unsigned long addr = 0;
+ 	int order = pool->min_alloc_order;
+-	int nbits, start_bit = 0, end_bit, remain;
++	int nbits, start_bit, end_bit, remain;
+ 
+ #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+ 	BUG_ON(in_nmi());
+@@ -288,6 +288,7 @@ unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size)
+ 		if (size > atomic_read(&chunk->avail))
+ 			continue;
+ 
++		start_bit = 0;
+ 		end_bit = chunk_size(chunk) >> order;
+ retry:
+ 		start_bit = pool->algo(chunk->bits, end_bit, start_bit, nbits,
+diff --git a/mm/swapfile.c b/mm/swapfile.c
+index 58877312cf6b..c1a0f3dea8b5 100644
+--- a/mm/swapfile.c
++++ b/mm/swapfile.c
+@@ -2225,6 +2225,8 @@ static unsigned long read_swap_header(struct swap_info_struct *p,
+ 		swab32s(&swap_header->info.version);
+ 		swab32s(&swap_header->info.last_page);
+ 		swab32s(&swap_header->info.nr_badpages);
++		if (swap_header->info.nr_badpages > MAX_SWAP_BADPAGES)
++			return 0;
+ 		for (i = 0; i < swap_header->info.nr_badpages; i++)
+ 			swab32s(&swap_header->info.badpages[i]);
+ 	}
+diff --git a/net/netfilter/nf_log.c b/net/netfilter/nf_log.c
+index a5d41dfa9f05..2c89f90cd7bc 100644
+--- a/net/netfilter/nf_log.c
++++ b/net/netfilter/nf_log.c
+@@ -401,7 +401,7 @@ static int nf_log_proc_dostring(struct ctl_table *table, int write,
+ 	size_t size = *lenp;
+ 	int r = 0;
+ 	int tindex = (unsigned long)table->extra1;
+-	struct net *net = current->nsproxy->net_ns;
++	struct net *net = table->extra2;
+ 
+ 	if (write) {
+ 		if (size > sizeof(buf))
+@@ -453,7 +453,6 @@ static int netfilter_log_sysctl_init(struct net *net)
+ 				 3, "%d", i);
+ 			nf_log_sysctl_table[i].procname	=
+ 				nf_log_sysctl_fnames[i];
+-			nf_log_sysctl_table[i].data = NULL;
+ 			nf_log_sysctl_table[i].maxlen = NFLOGGER_NAME_LEN;
+ 			nf_log_sysctl_table[i].mode = 0644;
+ 			nf_log_sysctl_table[i].proc_handler =
+@@ -463,6 +462,9 @@ static int netfilter_log_sysctl_init(struct net *net)
+ 		}
+ 	}
+ 
++	for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++)
++		table[i].extra2 = net;
++
+ 	net->nf.nf_log_dir_header = register_net_sysctl(net,
+ 						"net/netfilter/nf_log",
+ 						table);
+diff --git a/sound/core/info.c b/sound/core/info.c
+index 895362a696c9..8ab72e0f5932 100644
+--- a/sound/core/info.c
++++ b/sound/core/info.c
+@@ -325,10 +325,15 @@ static ssize_t snd_info_text_entry_write(struct file *file,
+ 	size_t next;
+ 	int err = 0;
+ 
++	if (!entry->c.text.write)
++		return -EIO;
+ 	pos = *offset;
+ 	if (!valid_pos(pos, count))
+ 		return -EIO;
+ 	next = pos + count;
++	/* don't handle too large text inputs */
++	if (next > 16 * 1024)
++		return -EIO;
+ 	mutex_lock(&entry->access);
+ 	buf = data->wbuffer;
+ 	if (!buf) {
+@@ -366,7 +371,9 @@ static int snd_info_seq_show(struct seq_file *seq, void *p)
+ 	struct snd_info_private_data *data = seq->private;
+ 	struct snd_info_entry *entry = data->entry;
+ 
+-	if (entry->c.text.read) {
++	if (!entry->c.text.read) {
++		return -EIO;
++	} else {
+ 		data->rbuffer->buffer = (char *)seq; /* XXX hack! */
+ 		entry->c.text.read(entry, data->rbuffer);
+ 	}
+diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c
+index e07807d96b68..3670086b9227 100644
+--- a/sound/soc/codecs/cs4270.c
++++ b/sound/soc/codecs/cs4270.c
+@@ -148,11 +148,11 @@ SND_SOC_DAPM_OUTPUT("AOUTR"),
+ };
+ 
+ static const struct snd_soc_dapm_route cs4270_dapm_routes[] = {
+-	{ "Capture", NULL, "AINA" },
+-	{ "Capture", NULL, "AINB" },
++	{ "Capture", NULL, "AINL" },
++	{ "Capture", NULL, "AINR" },
+ 
+-	{ "AOUTA", NULL, "Playback" },
+-	{ "AOUTB", NULL, "Playback" },
++	{ "AOUTL", NULL, "Playback" },
++	{ "AOUTR", NULL, "Playback" },
+ };
+ 
+ /**
+diff --git a/sound/soc/sunxi/sun4i-codec.c b/sound/soc/sunxi/sun4i-codec.c
+index 1bb896d78d09..1a4999f9d56f 100644
+--- a/sound/soc/sunxi/sun4i-codec.c
++++ b/sound/soc/sunxi/sun4i-codec.c
+@@ -575,11 +575,11 @@ static struct snd_soc_card *sun4i_codec_create_card(struct device *dev)
+ 
+ 	card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
+ 	if (!card)
+-		return NULL;
++		return ERR_PTR(-ENOMEM);
+ 
+ 	card->dai_link = sun4i_codec_create_link(dev, &card->num_links);
+ 	if (!card->dai_link)
+-		return NULL;
++		return ERR_PTR(-ENOMEM);
+ 
+ 	card->dev		= dev;
+ 	card->name		= "sun4i-codec";
+@@ -661,7 +661,8 @@ static int sun4i_codec_probe(struct platform_device *pdev)
+ 	}
+ 
+ 	card = sun4i_codec_create_card(&pdev->dev);
+-	if (!card) {
++	if (IS_ERR(card)) {
++		ret = PTR_ERR(card);
+ 		dev_err(&pdev->dev, "Failed to create our card\n");
+ 		goto err_unregister_codec;
+ 	}