tree ada3f40447eddf3c58bc843678b6a9e9b1f2e6c3
parent ef047d92a280865c9a33b631c05d78c200b3b3fe
parent a6e4a1818efa77621b27b5055cea85873b5e1f83
author Greg Kroah-Hartman <gregkh@google.com> 1648450524 +0200
committer Greg Kroah-Hartman <gregkh@google.com> 1648450524 +0200
mergetag object a6e4a1818efa77621b27b5055cea85873b5e1f83
 type commit
 tag v4.19.237
 tagger Greg Kroah-Hartman <gregkh@linuxfoundation.org> 1648449708 +0200
 
 This is the 4.19.237 stable release
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCAAdFiEEZH8oZUiU471FcZm+ONu9yGCSaT4FAmJBWKwACgkQONu9yGCS
 aT6KaBAAjAYfhUnZySCKLp/i03hJ2kT0cgScJO50jPCQuoPRvvoSsDJt80Ay0cVg
 tlLhH4Zu56GZ3Xb0tJL+w+ofz1Xh5tpuEXg12DygkS1Dwas3EPCU1zrr1YjB29VA
 JOy3ceoLlKEmJK9+PjnpXrVrzzHojxAFg4k+KxNqr393hXvSMtZDLgenAM0zfdQY
 /cHxZ295Jf5IFEWDJ7eRHcBzaqBcNOYdaqHykRGyHUZvmKQGamL9aObTjzWSXDt6
 k/dpv2Q1YVgLe/W205w4FF9DTbYAchxvC9wef+TTW/m4C2FbdNNG5TQLG2YSG/ez
 aB2Yn6M3iCiUumFcebeRhEVVLM9bxtECAeCDDevaZxPQIIdSoBr5iV4VGEVYoVXP
 BYqhillU2lX2KioNGBxwHueXTlTBrpgcNnY7NYa2POSkunI6P7qyjHu0Z/ZPumIL
 vSpRuW/emzk9wOOK+vhySOVSID2lnFzprkyeoDGlJgsWaHBC/vAnO4iKsr2eeFFq
 jbA9armXybplFk1ZppMBXxuk4ff5Wp5vZ+Jr+zSF2dywJEWqbRhlinvUKGWxmsqQ
 ENSIrSXcMpCA4tDm0IgEz5SZAHbrjcfWBPIpdkWv/VNfM0o82+D/4ll4iFX0xLTI
 BR5cB2B9SVjLrvnoV7LsKEEE8gSnvIA4WzsxwOe/yelvxYpSoC4=
 =Z9YU
 -----END PGP SIGNATURE-----

Merge 4.19.237 into android-4.19-q

Changes in 4.19.237
	nfc: st21nfca: Fix potential buffer overflows in EVT_TRANSACTION
	net: ipv6: fix skb_over_panic in __ip6_append_data
	esp: Fix possible buffer overflow in ESP transformation
	staging: fbtft: fb_st7789v: reset display before initialization
	thermal: int340x: fix memory leak in int3400_notify()
	llc: fix netdevice reference leaks in llc_ui_bind()
	ASoC: sti: Fix deadlock via snd_pcm_stop_xrun() call
	ALSA: oss: Fix PCM OSS buffer allocation overflow
	ALSA: pcm: Add stream lock during PCM reset ioctl operations
	ALSA: usb-audio: Add mute TLV for playback volumes on RODE NT-USB
	ALSA: cmipci: Restore aux vol on suspend/resume
	ALSA: pci: fix reading of swapped values from pcmreg in AC97 codec
	drivers: net: xgene: Fix regression in CRC stripping
	netfilter: nf_tables: initialize registers in nft_do_chain()
	ACPI / x86: Work around broken XSDT on Advantech DAC-BJ01 board
	ACPI: battery: Add device HID and quirk for Microsoft Surface Go 3
	ACPI: video: Force backlight native for Clevo NL5xRU and NL5xNU
	crypto: qat - disable registration of algorithms
	mac80211: fix potential double free on mesh join
	nds32: fix access_ok() checks in get/put_user
	llc: only change llc->dev when bind() succeeds
	Linux 4.19.237

Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
Change-Id: I3b04db9304ac763169559b36eb4755c11c3029e4
