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

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

commit:     0f23b605fb69e470f285ce960cb4fd7e0492050e
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Sun Aug  6 19:34:27 2017 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Sun Aug  6 19:34:27 2017 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=0f23b605

Linux patch 4.12.5

 0000_README             |   4 +
 1004_linux-4.12.5.patch | 997 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1001 insertions(+)

diff --git a/0000_README b/0000_README
index 09d6e6c..29e1ca2 100644
--- a/0000_README
+++ b/0000_README
@@ -59,6 +59,10 @@ Patch:  1003_linux-4.12.4.patch
 From:   http://www.kernel.org
 Desc:   Linux 4.12.4
 
+Patch:  1004_linux-4.12.5.patch
+From:   http://www.kernel.org
+Desc:   Linux 4.12.5
+
 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/1004_linux-4.12.5.patch b/1004_linux-4.12.5.patch
new file mode 100644
index 0000000..0b6a672
--- /dev/null
+++ b/1004_linux-4.12.5.patch
@@ -0,0 +1,997 @@
+diff --git a/Makefile b/Makefile
+index bfdc92c2e47a..382e967b0792 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 4
+ PATCHLEVEL = 12
+-SUBLEVEL = 4
++SUBLEVEL = 5
+ EXTRAVERSION =
+ NAME = Fearless Coyote
+ 
+diff --git a/arch/parisc/kernel/cache.c b/arch/parisc/kernel/cache.c
+index c32a09095216..85a92db70afc 100644
+--- a/arch/parisc/kernel/cache.c
++++ b/arch/parisc/kernel/cache.c
+@@ -453,8 +453,8 @@ void copy_user_page(void *vto, void *vfrom, unsigned long vaddr,
+ 	  before it can be accessed through the kernel mapping. */
+ 	preempt_disable();
+ 	flush_dcache_page_asm(__pa(vfrom), vaddr);
+-	preempt_enable();
+ 	copy_page_asm(vto, vfrom);
++	preempt_enable();
+ }
+ EXPORT_SYMBOL(copy_user_page);
+ 
+@@ -539,6 +539,10 @@ void flush_cache_mm(struct mm_struct *mm)
+ 	struct vm_area_struct *vma;
+ 	pgd_t *pgd;
+ 
++	/* Flush the TLB to avoid speculation if coherency is required. */
++	if (parisc_requires_coherency())
++		flush_tlb_all();
++
+ 	/* Flushing the whole cache on each cpu takes forever on
+ 	   rp3440, etc.  So, avoid it if the mm isn't too big.  */
+ 	if (mm_total_size(mm) >= parisc_cache_flush_threshold) {
+@@ -577,33 +581,22 @@ void flush_cache_mm(struct mm_struct *mm)
+ void flush_cache_range(struct vm_area_struct *vma,
+ 		unsigned long start, unsigned long end)
+ {
+-	unsigned long addr;
+-	pgd_t *pgd;
+-
+ 	BUG_ON(!vma->vm_mm->context);
+ 
++	/* Flush the TLB to avoid speculation if coherency is required. */
++	if (parisc_requires_coherency())
++		flush_tlb_range(vma, start, end);
++
+ 	if ((end - start) >= parisc_cache_flush_threshold) {
+ 		flush_cache_all();
+ 		return;
+ 	}
+ 
+-	if (vma->vm_mm->context == mfsp(3)) {
+-		flush_user_dcache_range_asm(start, end);
+-		if (vma->vm_flags & VM_EXEC)
+-			flush_user_icache_range_asm(start, end);
+-		return;
+-	}
++	BUG_ON(vma->vm_mm->context != mfsp(3));
+ 
+-	pgd = vma->vm_mm->pgd;
+-	for (addr = start & PAGE_MASK; addr < end; addr += PAGE_SIZE) {
+-		unsigned long pfn;
+-		pte_t *ptep = get_ptep(pgd, addr);
+-		if (!ptep)
+-			continue;
+-		pfn = pte_pfn(*ptep);
+-		if (pfn_valid(pfn))
+-			__flush_cache_page(vma, addr, PFN_PHYS(pfn));
+-	}
++	flush_user_dcache_range_asm(start, end);
++	if (vma->vm_flags & VM_EXEC)
++		flush_user_icache_range_asm(start, end);
+ }
+ 
+ void
+@@ -612,7 +605,8 @@ flush_cache_page(struct vm_area_struct *vma, unsigned long vmaddr, unsigned long
+ 	BUG_ON(!vma->vm_mm->context);
+ 
+ 	if (pfn_valid(pfn)) {
+-		flush_tlb_page(vma, vmaddr);
++		if (parisc_requires_coherency())
++			flush_tlb_page(vma, vmaddr);
+ 		__flush_cache_page(vma, vmaddr, PFN_PHYS(pfn));
+ 	}
+ }
+diff --git a/arch/parisc/kernel/process.c b/arch/parisc/kernel/process.c
+index b64d7d21646e..a45a67d526f8 100644
+--- a/arch/parisc/kernel/process.c
++++ b/arch/parisc/kernel/process.c
+@@ -53,6 +53,7 @@
+ #include <linux/uaccess.h>
+ #include <linux/rcupdate.h>
+ #include <linux/random.h>
++#include <linux/nmi.h>
+ 
+ #include <asm/io.h>
+ #include <asm/asm-offsets.h>
+@@ -145,6 +146,7 @@ void machine_power_off(void)
+ 
+ 	/* prevent soft lockup/stalled CPU messages for endless loop. */
+ 	rcu_sysrq_start();
++	lockup_detector_suspend();
+ 	for (;;);
+ }
+ 
+diff --git a/arch/powerpc/kvm/book3s_64_mmu_hv.c b/arch/powerpc/kvm/book3s_64_mmu_hv.c
+index 710e491206ed..1c10e26cebbb 100644
+--- a/arch/powerpc/kvm/book3s_64_mmu_hv.c
++++ b/arch/powerpc/kvm/book3s_64_mmu_hv.c
+@@ -164,8 +164,10 @@ long kvmppc_alloc_reset_hpt(struct kvm *kvm, int order)
+ 		goto out;
+ 	}
+ 
+-	if (kvm->arch.hpt.virt)
++	if (kvm->arch.hpt.virt) {
+ 		kvmppc_free_hpt(&kvm->arch.hpt);
++		kvmppc_rmap_reset(kvm);
++	}
+ 
+ 	err = kvmppc_allocate_hpt(&info, order);
+ 	if (err < 0)
+diff --git a/arch/powerpc/kvm/book3s_hv.c b/arch/powerpc/kvm/book3s_hv.c
+index 8d1a365b8edc..1d3602f7ec22 100644
+--- a/arch/powerpc/kvm/book3s_hv.c
++++ b/arch/powerpc/kvm/book3s_hv.c
+@@ -2938,6 +2938,8 @@ static int kvmppc_vcpu_run_hv(struct kvm_run *run, struct kvm_vcpu *vcpu)
+ 			run->fail_entry.hardware_entry_failure_reason = 0;
+ 			return -EINVAL;
+ 		}
++		/* Enable TM so we can read the TM SPRs */
++		mtmsr(mfmsr() | MSR_TM);
+ 		current->thread.tm_tfhar = mfspr(SPRN_TFHAR);
+ 		current->thread.tm_tfiar = mfspr(SPRN_TFIAR);
+ 		current->thread.tm_texasr = mfspr(SPRN_TEXASR);
+diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
+index e5bf1e84047f..011ef2180fe6 100644
+--- a/arch/powerpc/platforms/pseries/reconfig.c
++++ b/arch/powerpc/platforms/pseries/reconfig.c
+@@ -82,7 +82,6 @@ static int pSeries_reconfig_remove_node(struct device_node *np)
+ 
+ 	of_detach_node(np);
+ 	of_node_put(parent);
+-	of_node_put(np); /* Must decrement the refcount */
+ 	return 0;
+ }
+ 
+diff --git a/crypto/authencesn.c b/crypto/authencesn.c
+index 6f8f6b86bfe2..0cf5fefdb859 100644
+--- a/crypto/authencesn.c
++++ b/crypto/authencesn.c
+@@ -248,6 +248,9 @@ static int crypto_authenc_esn_decrypt_tail(struct aead_request *req,
+ 	u8 *ihash = ohash + crypto_ahash_digestsize(auth);
+ 	u32 tmp[2];
+ 
++	if (!authsize)
++		goto decrypt;
++
+ 	/* Move high-order bits of sequence number back. */
+ 	scatterwalk_map_and_copy(tmp, dst, 4, 4, 0);
+ 	scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 0);
+@@ -256,6 +259,8 @@ static int crypto_authenc_esn_decrypt_tail(struct aead_request *req,
+ 	if (crypto_memneq(ihash, ohash, authsize))
+ 		return -EBADMSG;
+ 
++decrypt:
++
+ 	sg_init_table(areq_ctx->dst, 2);
+ 	dst = scatterwalk_ffwd(areq_ctx->dst, dst, assoclen);
+ 
+diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
+index d165af8abe36..4161d9961a24 100644
+--- a/drivers/char/ipmi/ipmi_watchdog.c
++++ b/drivers/char/ipmi/ipmi_watchdog.c
+@@ -1163,10 +1163,11 @@ static int wdog_reboot_handler(struct notifier_block *this,
+ 			ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
+ 			ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
+ 		} else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
+-			/* Set a long timer to let the reboot happens, but
+-			   reboot if it hangs, but only if the watchdog
++			/* Set a long timer to let the reboot happen or
++			   reset if it hangs, but only if the watchdog
+ 			   timer was already running. */
+-			timeout = 120;
++			if (timeout < 120)
++				timeout = 120;
+ 			pretimeout = 0;
+ 			ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
+ 			ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
+diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
+index fb1e60f5002e..778fc1bcccee 100644
+--- a/drivers/crypto/Kconfig
++++ b/drivers/crypto/Kconfig
+@@ -629,7 +629,7 @@ source "drivers/crypto/virtio/Kconfig"
+ config CRYPTO_DEV_BCM_SPU
+ 	tristate "Broadcom symmetric crypto/hash acceleration support"
+ 	depends on ARCH_BCM_IPROC
+-	depends on BCM_PDC_MBOX
++	depends on MAILBOX
+ 	default m
+ 	select CRYPTO_DES
+ 	select CRYPTO_MD5
+diff --git a/drivers/crypto/bcm/spu2.c b/drivers/crypto/bcm/spu2.c
+index ef04c9748317..bf7ac621c591 100644
+--- a/drivers/crypto/bcm/spu2.c
++++ b/drivers/crypto/bcm/spu2.c
+@@ -302,6 +302,7 @@ spu2_hash_xlate(enum hash_alg hash_alg, enum hash_mode hash_mode,
+ 		break;
+ 	case HASH_ALG_SHA3_512:
+ 		*spu2_type = SPU2_HASH_TYPE_SHA3_512;
++		break;
+ 	case HASH_ALG_LAST:
+ 	default:
+ 		err = -EINVAL;
+diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
+index 9106ea32b048..881df8843e66 100644
+--- a/drivers/gpu/drm/i915/intel_display.c
++++ b/drivers/gpu/drm/i915/intel_display.c
+@@ -9085,6 +9085,13 @@ static bool haswell_get_pipe_config(struct intel_crtc *crtc,
+ 	u64 power_domain_mask;
+ 	bool active;
+ 
++	if (INTEL_GEN(dev_priv) >= 9) {
++		intel_crtc_init_scalers(crtc, pipe_config);
++
++		pipe_config->scaler_state.scaler_id = -1;
++		pipe_config->scaler_state.scaler_users &= ~(1 << SKL_CRTC_INDEX);
++	}
++
+ 	power_domain = POWER_DOMAIN_PIPE(crtc->pipe);
+ 	if (!intel_display_power_get_if_enabled(dev_priv, power_domain))
+ 		return false;
+@@ -9113,13 +9120,6 @@ static bool haswell_get_pipe_config(struct intel_crtc *crtc,
+ 	pipe_config->gamma_mode =
+ 		I915_READ(GAMMA_MODE(crtc->pipe)) & GAMMA_MODE_MODE_MASK;
+ 
+-	if (INTEL_GEN(dev_priv) >= 9) {
+-		intel_crtc_init_scalers(crtc, pipe_config);
+-
+-		pipe_config->scaler_state.scaler_id = -1;
+-		pipe_config->scaler_state.scaler_users &= ~(1 << SKL_CRTC_INDEX);
+-	}
+-
+ 	power_domain = POWER_DOMAIN_PIPE_PANEL_FITTER(crtc->pipe);
+ 	if (intel_display_power_get_if_enabled(dev_priv, power_domain)) {
+ 		power_domain_mask |= BIT_ULL(power_domain);
+diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.h b/drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.h
+index 1e1de6bfe85a..5893be9788d3 100644
+--- a/drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.h
++++ b/drivers/gpu/drm/nouveau/nvkm/engine/disp/nv50.h
+@@ -27,7 +27,7 @@ struct nv50_disp {
+ 		u8 type[3];
+ 	} pior;
+ 
+-	struct nv50_disp_chan *chan[17];
++	struct nv50_disp_chan *chan[21];
+ };
+ 
+ int nv50_disp_root_scanoutpos(NV50_DISP_MTHD_V0);
+diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c
+index c794b2c2d21e..6d8f21290aa2 100644
+--- a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c
++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c
+@@ -129,7 +129,7 @@ gf100_bar_init(struct nvkm_bar *base)
+ 
+ 	if (bar->bar[0].mem) {
+ 		addr = nvkm_memory_addr(bar->bar[0].mem) >> 12;
+-		nvkm_wr32(device, 0x001714, 0xc0000000 | addr);
++		nvkm_wr32(device, 0x001714, 0x80000000 | addr);
+ 	}
+ 
+ 	return 0;
+diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+index c7b53d987f06..fefb9d995d2c 100644
+--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+@@ -519,7 +519,7 @@ static int vmw_cmd_invalid(struct vmw_private *dev_priv,
+ 			   struct vmw_sw_context *sw_context,
+ 			   SVGA3dCmdHeader *header)
+ {
+-	return capable(CAP_SYS_ADMIN) ? : -EINVAL;
++	return -EINVAL;
+ }
+ 
+ static int vmw_cmd_ok(struct vmw_private *dev_priv,
+diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
+index 50be1f034f9e..5284e8d2f7ba 100644
+--- a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
++++ b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c
+@@ -1640,8 +1640,8 @@ int vmw_kms_stdu_init_display(struct vmw_private *dev_priv)
+ 		 * something arbitrarily large and we will reject any layout
+ 		 * that doesn't fit prim_bb_mem later
+ 		 */
+-		dev->mode_config.max_width = 16384;
+-		dev->mode_config.max_height = 16384;
++		dev->mode_config.max_width = 8192;
++		dev->mode_config.max_height = 8192;
+ 	}
+ 
+ 	vmw_kms_create_implicit_placement_property(dev_priv, false);
+diff --git a/drivers/isdn/i4l/isdn_common.c b/drivers/isdn/i4l/isdn_common.c
+index 9b856e1890d1..e4c43a17b333 100644
+--- a/drivers/isdn/i4l/isdn_common.c
++++ b/drivers/isdn/i4l/isdn_common.c
+@@ -1379,6 +1379,7 @@ isdn_ioctl(struct file *file, uint cmd, ulong arg)
+ 			if (arg) {
+ 				if (copy_from_user(bname, argp, sizeof(bname) - 1))
+ 					return -EFAULT;
++				bname[sizeof(bname)-1] = 0;
+ 			} else
+ 				return -EINVAL;
+ 			ret = mutex_lock_interruptible(&dev->mtx);
+diff --git a/drivers/isdn/i4l/isdn_net.c b/drivers/isdn/i4l/isdn_net.c
+index c151c6daa67e..f63a110b7bcb 100644
+--- a/drivers/isdn/i4l/isdn_net.c
++++ b/drivers/isdn/i4l/isdn_net.c
+@@ -2611,10 +2611,9 @@ isdn_net_newslave(char *parm)
+ 	char newname[10];
+ 
+ 	if (p) {
+-		/* Slave-Name MUST not be empty */
+-		if (!strlen(p + 1))
++		/* Slave-Name MUST not be empty or overflow 'newname' */
++		if (strscpy(newname, p + 1, sizeof(newname)) <= 0)
+ 			return NULL;
+-		strcpy(newname, p + 1);
+ 		*p = 0;
+ 		/* Master must already exist */
+ 		if (!(n = isdn_net_findif(parm)))
+diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
+index 93b181088168..b68e21c25a17 100644
+--- a/drivers/md/dm-integrity.c
++++ b/drivers/md/dm-integrity.c
+@@ -1587,16 +1587,18 @@ static void dm_integrity_map_continue(struct dm_integrity_io *dio, bool from_map
+ 	if (likely(ic->mode == 'J')) {
+ 		if (dio->write) {
+ 			unsigned next_entry, i, pos;
+-			unsigned ws, we;
++			unsigned ws, we, range_sectors;
+ 
+-			dio->range.n_sectors = min(dio->range.n_sectors, ic->free_sectors);
++			dio->range.n_sectors = min(dio->range.n_sectors,
++						   ic->free_sectors << ic->sb->log2_sectors_per_block);
+ 			if (unlikely(!dio->range.n_sectors))
+ 				goto sleep;
+-			ic->free_sectors -= dio->range.n_sectors;
++			range_sectors = dio->range.n_sectors >> ic->sb->log2_sectors_per_block;
++			ic->free_sectors -= range_sectors;
+ 			journal_section = ic->free_section;
+ 			journal_entry = ic->free_section_entry;
+ 
+-			next_entry = ic->free_section_entry + dio->range.n_sectors;
++			next_entry = ic->free_section_entry + range_sectors;
+ 			ic->free_section_entry = next_entry % ic->journal_section_entries;
+ 			ic->free_section += next_entry / ic->journal_section_entries;
+ 			ic->n_uncommitted_sections += next_entry / ic->journal_section_entries;
+@@ -3019,6 +3021,11 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned argc, char **argv)
+ 		ti->error = "Block size doesn't match the information in superblock";
+ 		goto bad;
+ 	}
++	if (!le32_to_cpu(ic->sb->journal_sections)) {
++		r = -EINVAL;
++		ti->error = "Corrupted superblock, journal_sections is 0";
++		goto bad;
++	}
+ 	/* make sure that ti->max_io_len doesn't overflow */
+ 	if (ic->sb->log2_interleave_sectors < MIN_LOG2_INTERLEAVE_SECTORS ||
+ 	    ic->sb->log2_interleave_sectors > MAX_LOG2_INTERLEAVE_SECTORS) {
+diff --git a/drivers/md/md.h b/drivers/md/md.h
+index 63d342d560b8..33611a91b1d9 100644
+--- a/drivers/md/md.h
++++ b/drivers/md/md.h
+@@ -733,7 +733,6 @@ static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio
+ 
+ /* for managing resync I/O pages */
+ struct resync_pages {
+-	unsigned	idx;	/* for get/put page from the pool */
+ 	void		*raid_bio;
+ 	struct page	*pages[RESYNC_PAGES];
+ };
+diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
+index 7866563338fa..5de4b3d04eb5 100644
+--- a/drivers/md/raid1.c
++++ b/drivers/md/raid1.c
+@@ -170,7 +170,6 @@ static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data)
+ 			resync_get_all_pages(rp);
+ 		}
+ 
+-		rp->idx = 0;
+ 		rp->raid_bio = r1_bio;
+ 		bio->bi_private = rp;
+ 	}
+@@ -492,10 +491,6 @@ static void raid1_end_write_request(struct bio *bio)
+ 	}
+ 
+ 	if (behind) {
+-		/* we release behind master bio when all write are done */
+-		if (r1_bio->behind_master_bio == bio)
+-			to_put = NULL;
+-
+ 		if (test_bit(WriteMostly, &rdev->flags))
+ 			atomic_dec(&r1_bio->behind_remaining);
+ 
+@@ -1088,7 +1083,7 @@ static void unfreeze_array(struct r1conf *conf)
+ 	wake_up(&conf->wait_barrier);
+ }
+ 
+-static struct bio *alloc_behind_master_bio(struct r1bio *r1_bio,
++static void alloc_behind_master_bio(struct r1bio *r1_bio,
+ 					   struct bio *bio)
+ {
+ 	int size = bio->bi_iter.bi_size;
+@@ -1098,11 +1093,13 @@ static struct bio *alloc_behind_master_bio(struct r1bio *r1_bio,
+ 
+ 	behind_bio = bio_alloc_mddev(GFP_NOIO, vcnt, r1_bio->mddev);
+ 	if (!behind_bio)
+-		goto fail;
++		return;
+ 
+ 	/* discard op, we don't support writezero/writesame yet */
+-	if (!bio_has_data(bio))
++	if (!bio_has_data(bio)) {
++		behind_bio->bi_iter.bi_size = size;
+ 		goto skip_copy;
++	}
+ 
+ 	while (i < vcnt && size) {
+ 		struct page *page;
+@@ -1123,14 +1120,13 @@ static struct bio *alloc_behind_master_bio(struct r1bio *r1_bio,
+ 	r1_bio->behind_master_bio = behind_bio;;
+ 	set_bit(R1BIO_BehindIO, &r1_bio->state);
+ 
+-	return behind_bio;
++	return;
+ 
+ free_pages:
+ 	pr_debug("%dB behind alloc failed, doing sync I/O\n",
+ 		 bio->bi_iter.bi_size);
+ 	bio_free_pages(behind_bio);
+-fail:
+-	return behind_bio;
++	bio_put(behind_bio);
+ }
+ 
+ struct raid1_plug_cb {
+@@ -1483,7 +1479,7 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
+ 			    (atomic_read(&bitmap->behind_writes)
+ 			     < mddev->bitmap_info.max_write_behind) &&
+ 			    !waitqueue_active(&bitmap->behind_wait)) {
+-				mbio = alloc_behind_master_bio(r1_bio, bio);
++				alloc_behind_master_bio(r1_bio, bio);
+ 			}
+ 
+ 			bitmap_startwrite(bitmap, r1_bio->sector,
+@@ -1493,14 +1489,11 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
+ 			first_clone = 0;
+ 		}
+ 
+-		if (!mbio) {
+-			if (r1_bio->behind_master_bio)
+-				mbio = bio_clone_fast(r1_bio->behind_master_bio,
+-						      GFP_NOIO,
+-						      mddev->bio_set);
+-			else
+-				mbio = bio_clone_fast(bio, GFP_NOIO, mddev->bio_set);
+-		}
++		if (r1_bio->behind_master_bio)
++			mbio = bio_clone_fast(r1_bio->behind_master_bio,
++					      GFP_NOIO, mddev->bio_set);
++		else
++			mbio = bio_clone_fast(bio, GFP_NOIO, mddev->bio_set);
+ 
+ 		if (r1_bio->behind_master_bio) {
+ 			if (test_bit(WriteMostly, &conf->mirrors[i].rdev->flags))
+@@ -2368,8 +2361,6 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
+ 			wbio = bio_clone_fast(r1_bio->behind_master_bio,
+ 					      GFP_NOIO,
+ 					      mddev->bio_set);
+-			/* We really need a _all clone */
+-			wbio->bi_iter = (struct bvec_iter){ 0 };
+ 		} else {
+ 			wbio = bio_clone_fast(r1_bio->master_bio, GFP_NOIO,
+ 					      mddev->bio_set);
+@@ -2621,6 +2612,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 	int good_sectors = RESYNC_SECTORS;
+ 	int min_bad = 0; /* number of sectors that are bad in all devices */
+ 	int idx = sector_to_idx(sector_nr);
++	int page_idx = 0;
+ 
+ 	if (!conf->r1buf_pool)
+ 		if (init_resync(conf))
+@@ -2848,7 +2840,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 			bio = r1_bio->bios[i];
+ 			rp = get_resync_pages(bio);
+ 			if (bio->bi_end_io) {
+-				page = resync_fetch_page(rp, rp->idx++);
++				page = resync_fetch_page(rp, page_idx);
+ 
+ 				/*
+ 				 * won't fail because the vec table is big
+@@ -2860,7 +2852,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 		nr_sectors += len>>9;
+ 		sector_nr += len>>9;
+ 		sync_blocks -= (len>>9);
+-	} while (get_resync_pages(r1_bio->bios[disk]->bi_private)->idx < RESYNC_PAGES);
++	} while (++page_idx < RESYNC_PAGES);
+ 
+ 	r1_bio->sectors = nr_sectors;
+ 
+diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
+index 52acffa7a06a..bfc6db236348 100644
+--- a/drivers/md/raid10.c
++++ b/drivers/md/raid10.c
+@@ -221,7 +221,6 @@ static void * r10buf_pool_alloc(gfp_t gfp_flags, void *data)
+ 			resync_get_all_pages(rp);
+ 		}
+ 
+-		rp->idx = 0;
+ 		rp->raid_bio = r10_bio;
+ 		bio->bi_private = rp;
+ 		if (rbio) {
+@@ -2853,6 +2852,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 	sector_t sectors_skipped = 0;
+ 	int chunks_skipped = 0;
+ 	sector_t chunk_mask = conf->geo.chunk_mask;
++	int page_idx = 0;
+ 
+ 	if (!conf->r10buf_pool)
+ 		if (init_resync(conf))
+@@ -3355,7 +3355,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 			break;
+ 		for (bio= biolist ; bio ; bio=bio->bi_next) {
+ 			struct resync_pages *rp = get_resync_pages(bio);
+-			page = resync_fetch_page(rp, rp->idx++);
++			page = resync_fetch_page(rp, page_idx);
+ 			/*
+ 			 * won't fail because the vec table is big enough
+ 			 * to hold all these pages
+@@ -3364,7 +3364,7 @@ static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,
+ 		}
+ 		nr_sectors += len>>9;
+ 		sector_nr += len>>9;
+-	} while (get_resync_pages(biolist)->idx < RESYNC_PAGES);
++	} while (++page_idx < RESYNC_PAGES);
+ 	r10_bio->sectors = nr_sectors;
+ 
+ 	while (biolist) {
+diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
+index d524daddc630..e92dd2dc4b5a 100644
+--- a/drivers/md/raid5.c
++++ b/drivers/md/raid5.c
+@@ -6237,6 +6237,8 @@ static void raid5_do_work(struct work_struct *work)
+ 	pr_debug("%d stripes handled\n", handled);
+ 
+ 	spin_unlock_irq(&conf->device_lock);
++
++	async_tx_issue_pending_all();
+ 	blk_finish_plug(&plug);
+ 
+ 	pr_debug("--- raid5worker inactive\n");
+diff --git a/drivers/mmc/host/sunxi-mmc.c b/drivers/mmc/host/sunxi-mmc.c
+index d6fa2214aaae..0fb4e4c119e1 100644
+--- a/drivers/mmc/host/sunxi-mmc.c
++++ b/drivers/mmc/host/sunxi-mmc.c
+@@ -793,8 +793,12 @@ static int sunxi_mmc_clk_set_rate(struct sunxi_mmc_host *host,
+ 	}
+ 	mmc_writel(host, REG_CLKCR, rval);
+ 
+-	if (host->cfg->needs_new_timings)
+-		mmc_writel(host, REG_SD_NTSR, SDXC_2X_TIMING_MODE);
++	if (host->cfg->needs_new_timings) {
++		/* Don't touch the delay bits */
++		rval = mmc_readl(host, REG_SD_NTSR);
++		rval |= SDXC_2X_TIMING_MODE;
++		mmc_writel(host, REG_SD_NTSR, rval);
++	}
+ 
+ 	ret = sunxi_mmc_clk_set_phase(host, ios, rate);
+ 	if (ret)
+diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
+index a2d92f10501b..a3d20e39e5b5 100644
+--- a/drivers/mmc/host/tmio_mmc_pio.c
++++ b/drivers/mmc/host/tmio_mmc_pio.c
+@@ -404,30 +404,29 @@ static void tmio_mmc_transfer_data(struct tmio_mmc_host *host,
+ 	 * Transfer the data
+ 	 */
+ 	if (host->pdata->flags & TMIO_MMC_32BIT_DATA_PORT) {
+-		u8 data[4] = { };
++		u32 data = 0;
++		u32 *buf32 = (u32 *)buf;
+ 
+ 		if (is_read)
+-			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT, (u32 *)buf,
++			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT, buf32,
+ 					   count >> 2);
+ 		else
+-			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT, (u32 *)buf,
++			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT, buf32,
+ 					    count >> 2);
+ 
+ 		/* if count was multiple of 4 */
+ 		if (!(count & 0x3))
+ 			return;
+ 
+-		buf8 = (u8 *)(buf + (count >> 2));
++		buf32 += count >> 2;
+ 		count %= 4;
+ 
+ 		if (is_read) {
+-			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT,
+-					   (u32 *)data, 1);
+-			memcpy(buf8, data, count);
++			sd_ctrl_read32_rep(host, CTL_SD_DATA_PORT, &data, 1);
++			memcpy(buf32, &data, count);
+ 		} else {
+-			memcpy(data, buf8, count);
+-			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT,
+-					    (u32 *)data, 1);
++			memcpy(&data, buf32, count);
++			sd_ctrl_write32_rep(host, CTL_SD_DATA_PORT, &data, 1);
+ 		}
+ 
+ 		return;
+diff --git a/fs/dcache.c b/fs/dcache.c
+index 1161390f4935..736754c5ab63 100644
+--- a/fs/dcache.c
++++ b/fs/dcache.c
+@@ -277,6 +277,33 @@ static inline int dname_external(const struct dentry *dentry)
+ 	return dentry->d_name.name != dentry->d_iname;
+ }
+ 
++void take_dentry_name_snapshot(struct name_snapshot *name, struct dentry *dentry)
++{
++	spin_lock(&dentry->d_lock);
++	if (unlikely(dname_external(dentry))) {
++		struct external_name *p = external_name(dentry);
++		atomic_inc(&p->u.count);
++		spin_unlock(&dentry->d_lock);
++		name->name = p->name;
++	} else {
++		memcpy(name->inline_name, dentry->d_iname, DNAME_INLINE_LEN);
++		spin_unlock(&dentry->d_lock);
++		name->name = name->inline_name;
++	}
++}
++EXPORT_SYMBOL(take_dentry_name_snapshot);
++
++void release_dentry_name_snapshot(struct name_snapshot *name)
++{
++	if (unlikely(name->name != name->inline_name)) {
++		struct external_name *p;
++		p = container_of(name->name, struct external_name, name[0]);
++		if (unlikely(atomic_dec_and_test(&p->u.count)))
++			kfree_rcu(p, u.head);
++	}
++}
++EXPORT_SYMBOL(release_dentry_name_snapshot);
++
+ static inline void __d_set_inode_and_type(struct dentry *dentry,
+ 					  struct inode *inode,
+ 					  unsigned type_flags)
+diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
+index e892ae7d89f8..acd3be2cc691 100644
+--- a/fs/debugfs/inode.c
++++ b/fs/debugfs/inode.c
+@@ -766,7 +766,7 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+ {
+ 	int error;
+ 	struct dentry *dentry = NULL, *trap;
+-	const char *old_name;
++	struct name_snapshot old_name;
+ 
+ 	trap = lock_rename(new_dir, old_dir);
+ 	/* Source or destination directories don't exist? */
+@@ -781,19 +781,19 @@ struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+ 	if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
+ 		goto exit;
+ 
+-	old_name = fsnotify_oldname_init(old_dentry->d_name.name);
++	take_dentry_name_snapshot(&old_name, old_dentry);
+ 
+ 	error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
+ 			      dentry, 0);
+ 	if (error) {
+-		fsnotify_oldname_free(old_name);
++		release_dentry_name_snapshot(&old_name);
+ 		goto exit;
+ 	}
+ 	d_move(old_dentry, dentry);
+-	fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name,
++	fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name,
+ 		d_is_dir(old_dentry),
+ 		NULL, old_dentry);
+-	fsnotify_oldname_free(old_name);
++	release_dentry_name_snapshot(&old_name);
+ 	unlock_rename(new_dir, old_dir);
+ 	dput(dentry);
+ 	return old_dentry;
+diff --git a/fs/jfs/acl.c b/fs/jfs/acl.c
+index 7bc186f4ed4d..1be45c8d460d 100644
+--- a/fs/jfs/acl.c
++++ b/fs/jfs/acl.c
+@@ -77,13 +77,6 @@ static int __jfs_set_acl(tid_t tid, struct inode *inode, int type,
+ 	switch (type) {
+ 	case ACL_TYPE_ACCESS:
+ 		ea_name = XATTR_NAME_POSIX_ACL_ACCESS;
+-		if (acl) {
+-			rc = posix_acl_update_mode(inode, &inode->i_mode, &acl);
+-			if (rc)
+-				return rc;
+-			inode->i_ctime = current_time(inode);
+-			mark_inode_dirty(inode);
+-		}
+ 		break;
+ 	case ACL_TYPE_DEFAULT:
+ 		ea_name = XATTR_NAME_POSIX_ACL_DEFAULT;
+@@ -118,9 +111,17 @@ int jfs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
+ 
+ 	tid = txBegin(inode->i_sb, 0);
+ 	mutex_lock(&JFS_IP(inode)->commit_mutex);
++	if (type == ACL_TYPE_ACCESS && acl) {
++		rc = posix_acl_update_mode(inode, &inode->i_mode, &acl);
++		if (rc)
++			goto end_tx;
++		inode->i_ctime = current_time(inode);
++		mark_inode_dirty(inode);
++	}
+ 	rc = __jfs_set_acl(tid, inode, type, acl);
+ 	if (!rc)
+ 		rc = txCommit(tid, 1, &inode, 0);
++end_tx:
+ 	txEnd(tid);
+ 	mutex_unlock(&JFS_IP(inode)->commit_mutex);
+ 	return rc;
+diff --git a/fs/namei.c b/fs/namei.c
+index 6571a5f5112e..281c1f7fa983 100644
+--- a/fs/namei.c
++++ b/fs/namei.c
+@@ -4362,11 +4362,11 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ {
+ 	int error;
+ 	bool is_dir = d_is_dir(old_dentry);
+-	const unsigned char *old_name;
+ 	struct inode *source = old_dentry->d_inode;
+ 	struct inode *target = new_dentry->d_inode;
+ 	bool new_is_dir = false;
+ 	unsigned max_links = new_dir->i_sb->s_max_links;
++	struct name_snapshot old_name;
+ 
+ 	if (source == target)
+ 		return 0;
+@@ -4413,7 +4413,7 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 	if (error)
+ 		return error;
+ 
+-	old_name = fsnotify_oldname_init(old_dentry->d_name.name);
++	take_dentry_name_snapshot(&old_name, old_dentry);
+ 	dget(new_dentry);
+ 	if (!is_dir || (flags & RENAME_EXCHANGE))
+ 		lock_two_nondirectories(source, target);
+@@ -4468,14 +4468,14 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
+ 		inode_unlock(target);
+ 	dput(new_dentry);
+ 	if (!error) {
+-		fsnotify_move(old_dir, new_dir, old_name, is_dir,
++		fsnotify_move(old_dir, new_dir, old_name.name, is_dir,
+ 			      !(flags & RENAME_EXCHANGE) ? target : NULL, old_dentry);
+ 		if (flags & RENAME_EXCHANGE) {
+ 			fsnotify_move(new_dir, old_dir, old_dentry->d_name.name,
+ 				      new_is_dir, NULL, new_dentry);
+ 		}
+ 	}
+-	fsnotify_oldname_free(old_name);
++	release_dentry_name_snapshot(&old_name);
+ 
+ 	return error;
+ }
+diff --git a/fs/nfs/file.c b/fs/nfs/file.c
+index 5713eb32a45e..d264363559db 100644
+--- a/fs/nfs/file.c
++++ b/fs/nfs/file.c
+@@ -750,7 +750,7 @@ do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
+ 	 */
+ 	nfs_sync_mapping(filp->f_mapping);
+ 	if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
+-		nfs_zap_mapping(inode, filp->f_mapping);
++		nfs_zap_caches(inode);
+ out:
+ 	return status;
+ }
+diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
+index dbfa18900e25..f5a7faac39a7 100644
+--- a/fs/nfs/nfs4proc.c
++++ b/fs/nfs/nfs4proc.c
+@@ -6441,7 +6441,7 @@ nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
+ 		set_current_state(TASK_INTERRUPTIBLE);
+ 		spin_unlock_irqrestore(&q->lock, flags);
+ 
+-		freezable_schedule_timeout_interruptible(NFS4_LOCK_MAXTIMEOUT);
++		freezable_schedule_timeout(NFS4_LOCK_MAXTIMEOUT);
+ 	}
+ 
+ 	finish_wait(q, &wait);
+diff --git a/fs/notify/fsnotify.c b/fs/notify/fsnotify.c
+index 01a9f0f007d4..0c4583b61717 100644
+--- a/fs/notify/fsnotify.c
++++ b/fs/notify/fsnotify.c
+@@ -161,16 +161,20 @@ int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask
+ 	if (unlikely(!fsnotify_inode_watches_children(p_inode)))
+ 		__fsnotify_update_child_dentry_flags(p_inode);
+ 	else if (p_inode->i_fsnotify_mask & mask) {
++		struct name_snapshot name;
++
+ 		/* we are notifying a parent so come up with the new mask which
+ 		 * specifies these are events which came from a child. */
+ 		mask |= FS_EVENT_ON_CHILD;
+ 
++		take_dentry_name_snapshot(&name, dentry);
+ 		if (path)
+ 			ret = fsnotify(p_inode, mask, path, FSNOTIFY_EVENT_PATH,
+-				       dentry->d_name.name, 0);
++				       name.name, 0);
+ 		else
+ 			ret = fsnotify(p_inode, mask, dentry->d_inode, FSNOTIFY_EVENT_INODE,
+-				       dentry->d_name.name, 0);
++				       name.name, 0);
++		release_dentry_name_snapshot(&name);
+ 	}
+ 
+ 	dput(parent);
+diff --git a/include/linux/dcache.h b/include/linux/dcache.h
+index d2e38dc6172c..025727bf6797 100644
+--- a/include/linux/dcache.h
++++ b/include/linux/dcache.h
+@@ -591,5 +591,11 @@ static inline struct inode *d_real_inode(const struct dentry *dentry)
+ 	return d_backing_inode(d_real((struct dentry *) dentry, NULL, 0));
+ }
+ 
++struct name_snapshot {
++	const char *name;
++	char inline_name[DNAME_INLINE_LEN];
++};
++void take_dentry_name_snapshot(struct name_snapshot *, struct dentry *);
++void release_dentry_name_snapshot(struct name_snapshot *);
+ 
+ #endif	/* __LINUX_DCACHE_H */
+diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
+index b43d3f5bd9ea..b78aa7ac77ce 100644
+--- a/include/linux/fsnotify.h
++++ b/include/linux/fsnotify.h
+@@ -293,35 +293,4 @@ static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
+ 	}
+ }
+ 
+-#if defined(CONFIG_FSNOTIFY)	/* notify helpers */
+-
+-/*
+- * fsnotify_oldname_init - save off the old filename before we change it
+- */
+-static inline const unsigned char *fsnotify_oldname_init(const unsigned char *name)
+-{
+-	return kstrdup(name, GFP_KERNEL);
+-}
+-
+-/*
+- * fsnotify_oldname_free - free the name we got from fsnotify_oldname_init
+- */
+-static inline void fsnotify_oldname_free(const unsigned char *old_name)
+-{
+-	kfree(old_name);
+-}
+-
+-#else	/* CONFIG_FSNOTIFY */
+-
+-static inline const char *fsnotify_oldname_init(const unsigned char *name)
+-{
+-	return NULL;
+-}
+-
+-static inline void fsnotify_oldname_free(const unsigned char *old_name)
+-{
+-}
+-
+-#endif	/*  CONFIG_FSNOTIFY */
+-
+ #endif	/* _LINUX_FS_NOTIFY_H */
+diff --git a/scripts/dtc/dtx_diff b/scripts/dtc/dtx_diff
+index ec47f95991a3..586cccea46ce 100755
+--- a/scripts/dtc/dtx_diff
++++ b/scripts/dtc/dtx_diff
+@@ -321,7 +321,7 @@ fi
+ cpp_flags="\
+ 	-nostdinc                                  \
+ 	-I${srctree}/arch/${ARCH}/boot/dts         \
+-	-I${srctree}/arch/${ARCH}/boot/dts/include \
++	-I${srctree}/scripts/dtc/include-prefixes  \
+ 	-I${srctree}/drivers/of/testcase-data      \
+ 	-undef -D__DTS__"
+ 
+diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
+index c47287d79306..a178e0d03088 100644
+--- a/sound/pci/fm801.c
++++ b/sound/pci/fm801.c
+@@ -1235,8 +1235,6 @@ static int snd_fm801_create(struct snd_card *card,
+ 		}
+ 	}
+ 
+-	snd_fm801_chip_init(chip);
+-
+ 	if ((chip->tea575x_tuner & TUNER_ONLY) == 0) {
+ 		if (devm_request_irq(&pci->dev, pci->irq, snd_fm801_interrupt,
+ 				IRQF_SHARED, KBUILD_MODNAME, chip)) {
+@@ -1248,6 +1246,8 @@ static int snd_fm801_create(struct snd_card *card,
+ 		pci_set_master(pci);
+ 	}
+ 
++	snd_fm801_chip_init(chip);
++
+ 	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
+ 		snd_fm801_free(chip);
+ 		return err;
+diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
+index 63bc894ddf5e..8c1289963c80 100644
+--- a/sound/pci/hda/patch_conexant.c
++++ b/sound/pci/hda/patch_conexant.c
+@@ -933,6 +933,7 @@ static const struct snd_pci_quirk cxt5066_fixups[] = {
+ 	SND_PCI_QUIRK(0x103c, 0x8174, "HP Spectre x360", CXT_FIXUP_HP_SPECTRE),
+ 	SND_PCI_QUIRK(0x103c, 0x8115, "HP Z1 Gen3", CXT_FIXUP_HP_GATE_MIC),
+ 	SND_PCI_QUIRK(0x103c, 0x814f, "HP ZBook 15u G3", CXT_FIXUP_MUTE_LED_GPIO),
++	SND_PCI_QUIRK(0x103c, 0x822e, "HP ProBook 440 G4", CXT_FIXUP_MUTE_LED_GPIO),
+ 	SND_PCI_QUIRK(0x1043, 0x138d, "Asus", CXT_FIXUP_HEADPHONE_MIC_PIN),
+ 	SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT_FIXUP_OLPC_XO),
+ 	SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400", CXT_PINCFG_LENOVO_TP410),
+diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
+index 90e4ff87445e..c87ff8e5d1d5 100644
+--- a/sound/pci/hda/patch_hdmi.c
++++ b/sound/pci/hda/patch_hdmi.c
+@@ -3757,11 +3757,15 @@ HDA_CODEC_ENTRY(0x1002aa01, "R6xx HDMI",	patch_atihdmi),
+ HDA_CODEC_ENTRY(0x10951390, "SiI1390 HDMI",	patch_generic_hdmi),
+ HDA_CODEC_ENTRY(0x10951392, "SiI1392 HDMI",	patch_generic_hdmi),
+ HDA_CODEC_ENTRY(0x17e80047, "Chrontel HDMI",	patch_generic_hdmi),
++HDA_CODEC_ENTRY(0x10de0001, "MCP73 HDMI",	patch_nvhdmi_2ch),
+ HDA_CODEC_ENTRY(0x10de0002, "MCP77/78 HDMI",	patch_nvhdmi_8ch_7x),
+ HDA_CODEC_ENTRY(0x10de0003, "MCP77/78 HDMI",	patch_nvhdmi_8ch_7x),
++HDA_CODEC_ENTRY(0x10de0004, "GPU 04 HDMI",	patch_nvhdmi_8ch_7x),
+ HDA_CODEC_ENTRY(0x10de0005, "MCP77/78 HDMI",	patch_nvhdmi_8ch_7x),
+ HDA_CODEC_ENTRY(0x10de0006, "MCP77/78 HDMI",	patch_nvhdmi_8ch_7x),
+ HDA_CODEC_ENTRY(0x10de0007, "MCP79/7A HDMI",	patch_nvhdmi_8ch_7x),
++HDA_CODEC_ENTRY(0x10de0008, "GPU 08 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0009, "GPU 09 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de000a, "GPU 0a HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de000b, "GPU 0b HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de000c, "MCP89 HDMI",	patch_nvhdmi),
+@@ -3788,17 +3792,40 @@ HDA_CODEC_ENTRY(0x10de0041, "GPU 41 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0042, "GPU 42 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0043, "GPU 43 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0044, "GPU 44 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0045, "GPU 45 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0050, "GPU 50 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0051, "GPU 51 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0052, "GPU 52 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0060, "GPU 60 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0061, "GPU 61 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0062, "GPU 62 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0067, "MCP67 HDMI",	patch_nvhdmi_2ch),
+ HDA_CODEC_ENTRY(0x10de0070, "GPU 70 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0071, "GPU 71 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0072, "GPU 72 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0073, "GPU 73 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0074, "GPU 74 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0076, "GPU 76 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de007b, "GPU 7b HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de007c, "GPU 7c HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de007d, "GPU 7d HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de007e, "GPU 7e HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0080, "GPU 80 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0081, "GPU 81 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0082, "GPU 82 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de0083, "GPU 83 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0084, "GPU 84 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0090, "GPU 90 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0091, "GPU 91 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0092, "GPU 92 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0093, "GPU 93 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0094, "GPU 94 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0095, "GPU 95 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0097, "GPU 97 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0098, "GPU 98 HDMI/DP",	patch_nvhdmi),
++HDA_CODEC_ENTRY(0x10de0099, "GPU 99 HDMI/DP",	patch_nvhdmi),
+ HDA_CODEC_ENTRY(0x10de8001, "MCP73 HDMI",	patch_nvhdmi_2ch),
++HDA_CODEC_ENTRY(0x10de8067, "MCP67/68 HDMI",	patch_nvhdmi_2ch),
+ HDA_CODEC_ENTRY(0x11069f80, "VX900 HDMI/DP",	patch_via_hdmi),
+ HDA_CODEC_ENTRY(0x11069f81, "VX900 HDMI/DP",	patch_via_hdmi),
+ HDA_CODEC_ENTRY(0x11069f84, "VX11 HDMI/DP",	patch_generic_hdmi),