commit: 08c794c0b0d8d1d28994c04d849ea380b928a60e Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Oct 26 11:24:09 2022 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Oct 26 11:24:09 2022 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=08c794c0
Linux patches 6.0.4 and 6.0.5 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 8 + 1003_linux-6.0.4.patch | 1011 ++++++++++++++++++++++++++++++++++++++++++++++++ 1004_linux-6.0.5.patch | 159 ++++++++ 3 files changed, 1178 insertions(+) diff --git a/0000_README b/0000_README index e5b9be05..85528522 100644 --- a/0000_README +++ b/0000_README @@ -55,6 +55,14 @@ Patch: 1002_linux-6.0.3.patch From: http://www.kernel.org Desc: Linux 6.0.3 +Patch: 1003_linux-6.0.4.patch +From: http://www.kernel.org +Desc: Linux 6.0.4 + +Patch: 1004_linux-6.0.5.patch +From: http://www.kernel.org +Desc: Linux 6.0.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/1003_linux-6.0.4.patch b/1003_linux-6.0.4.patch new file mode 100644 index 00000000..4b203225 --- /dev/null +++ b/1003_linux-6.0.4.patch @@ -0,0 +1,1011 @@ +diff --git a/Makefile b/Makefile +index d4297b3d0735a..f2e41dccdd89d 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 6 + PATCHLEVEL = 0 +-SUBLEVEL = 3 ++SUBLEVEL = 4 + EXTRAVERSION = + NAME = Hurr durr I'ma ninja sloth + +diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c +index e4080ad96089a..aa6d109fac08b 100644 +--- a/drivers/firmware/efi/efi.c ++++ b/drivers/firmware/efi/efi.c +@@ -269,6 +269,8 @@ static __init int efivar_ssdt_load(void) + acpi_status ret = acpi_load_table(data, NULL); + if (ret) + pr_err("failed to load table: %u\n", ret); ++ else ++ continue; + } else { + pr_err("failed to get var data: 0x%lx\n", status); + } +diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c +index dd74d2ad31840..433b615871395 100644 +--- a/drivers/firmware/efi/vars.c ++++ b/drivers/firmware/efi/vars.c +@@ -7,6 +7,7 @@ + */ + + #include <linux/types.h> ++#include <linux/sizes.h> + #include <linux/errno.h> + #include <linux/init.h> + #include <linux/module.h> +@@ -20,19 +21,19 @@ static struct efivars *__efivars; + + static DEFINE_SEMAPHORE(efivars_lock); + +-efi_status_t check_var_size(u32 attributes, unsigned long size) ++static efi_status_t check_var_size(u32 attributes, unsigned long size) + { + const struct efivar_operations *fops; + + fops = __efivars->ops; + + if (!fops->query_variable_store) +- return EFI_UNSUPPORTED; ++ return (size <= SZ_64K) ? EFI_SUCCESS : EFI_OUT_OF_RESOURCES; + + return fops->query_variable_store(attributes, size, false); + } +-EXPORT_SYMBOL_NS_GPL(check_var_size, EFIVAR); + ++static + efi_status_t check_var_size_nonblocking(u32 attributes, unsigned long size) + { + const struct efivar_operations *fops; +@@ -40,11 +41,10 @@ efi_status_t check_var_size_nonblocking(u32 attributes, unsigned long size) + fops = __efivars->ops; + + if (!fops->query_variable_store) +- return EFI_UNSUPPORTED; ++ return (size <= SZ_64K) ? EFI_SUCCESS : EFI_OUT_OF_RESOURCES; + + return fops->query_variable_store(attributes, size, true); + } +-EXPORT_SYMBOL_NS_GPL(check_var_size_nonblocking, EFIVAR); + + /** + * efivars_kobject - get the kobject for the registered efivars +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +index 25e1f5ed7ead1..91665fe44e7ca 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +@@ -2926,6 +2926,14 @@ static int amdgpu_device_ip_suspend_phase1(struct amdgpu_device *adev) + amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE); + amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE); + ++ /* ++ * Per PMFW team's suggestion, driver needs to handle gfxoff ++ * and df cstate features disablement for gpu reset(e.g. Mode1Reset) ++ * scenario. Add the missing df cstate disablement here. ++ */ ++ if (amdgpu_dpm_set_df_cstate(adev, DF_CSTATE_DISALLOW)) ++ dev_warn(adev->dev, "Failed to disallow df cstate"); ++ + for (i = adev->num_ip_blocks - 1; i >= 0; i--) { + if (!adev->ip_blocks[i].status.valid) + continue; +diff --git a/drivers/gpu/drm/amd/pm/swsmu/inc/pmfw_if/smu13_driver_if_v13_0_4.h b/drivers/gpu/drm/amd/pm/swsmu/inc/pmfw_if/smu13_driver_if_v13_0_4.h +index ae2d337158f3b..f77401709d83c 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/inc/pmfw_if/smu13_driver_if_v13_0_4.h ++++ b/drivers/gpu/drm/amd/pm/swsmu/inc/pmfw_if/smu13_driver_if_v13_0_4.h +@@ -27,7 +27,7 @@ + // *** IMPORTANT *** + // SMU TEAM: Always increment the interface version if + // any structure is changed in this file +-#define PMFW_DRIVER_IF_VERSION 5 ++#define PMFW_DRIVER_IF_VERSION 7 + + typedef struct { + int32_t value; +@@ -163,8 +163,8 @@ typedef struct { + uint16_t DclkFrequency; //[MHz] + uint16_t MemclkFrequency; //[MHz] + uint16_t spare; //[centi] +- uint16_t UvdActivity; //[centi] + uint16_t GfxActivity; //[centi] ++ uint16_t UvdActivity; //[centi] + + uint16_t Voltage[2]; //[mV] indices: VDDCR_VDD, VDDCR_SOC + uint16_t Current[2]; //[mA] indices: VDDCR_VDD, VDDCR_SOC +@@ -199,6 +199,19 @@ typedef struct { + uint16_t DeviceState; + uint16_t CurTemp; //[centi-Celsius] + uint16_t spare2; ++ ++ uint16_t AverageGfxclkFrequency; ++ uint16_t AverageFclkFrequency; ++ uint16_t AverageGfxActivity; ++ uint16_t AverageSocclkFrequency; ++ uint16_t AverageVclkFrequency; ++ uint16_t AverageVcnActivity; ++ uint16_t AverageDRAMReads; //Filtered DF Bandwidth::DRAM Reads ++ uint16_t AverageDRAMWrites; //Filtered DF Bandwidth::DRAM Writes ++ uint16_t AverageSocketPower; //Filtered value of CurrentSocketPower ++ uint16_t AverageCorePower; //Filtered of [sum of CorePower[8]]) ++ uint16_t AverageCoreC0Residency[8]; //Filtered of [average C0 residency % per core] ++ uint32_t MetricsCounter; //Counts the # of metrics table parameter reads per update to the metrics table, i.e. if the metrics table update happens every 1 second, this value could be up to 1000 if the smu collected metrics data every cycle, or as low as 0 if the smu was asleep the whole time. Reset to 0 after writing. + } SmuMetrics_t; + + typedef struct { +diff --git a/drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h b/drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h +index f442bf085a318..f75b9688f5129 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h ++++ b/drivers/gpu/drm/amd/pm/swsmu/inc/smu_v13_0.h +@@ -28,7 +28,7 @@ + #define SMU13_DRIVER_IF_VERSION_INV 0xFFFFFFFF + #define SMU13_DRIVER_IF_VERSION_YELLOW_CARP 0x04 + #define SMU13_DRIVER_IF_VERSION_ALDE 0x08 +-#define SMU13_DRIVER_IF_VERSION_SMU_V13_0_4 0x05 ++#define SMU13_DRIVER_IF_VERSION_SMU_V13_0_4 0x07 + #define SMU13_DRIVER_IF_VERSION_SMU_V13_0_5 0x04 + #define SMU13_DRIVER_IF_VERSION_SMU_V13_0_0 0x30 + #define SMU13_DRIVER_IF_VERSION_SMU_V13_0_7 0x2C +diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c +index 445005571f76f..9cd005131f566 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c ++++ b/drivers/gpu/drm/amd/pm/swsmu/smu11/arcturus_ppt.c +@@ -2242,9 +2242,17 @@ static void arcturus_get_unique_id(struct smu_context *smu) + static int arcturus_set_df_cstate(struct smu_context *smu, + enum pp_df_cstate state) + { ++ struct amdgpu_device *adev = smu->adev; + uint32_t smu_version; + int ret; + ++ /* ++ * Arcturus does not need the cstate disablement ++ * prerequisite for gpu reset. ++ */ ++ if (amdgpu_in_reset(adev) || adev->in_suspend) ++ return 0; ++ + ret = smu_cmn_get_smc_version(smu, NULL, &smu_version); + if (ret) { + dev_err(smu->adev->dev, "Failed to get smu version!\n"); +diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c +index 619aee51b1238..d30ec3005ea19 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c ++++ b/drivers/gpu/drm/amd/pm/swsmu/smu13/aldebaran_ppt.c +@@ -1640,6 +1640,15 @@ static bool aldebaran_is_baco_supported(struct smu_context *smu) + static int aldebaran_set_df_cstate(struct smu_context *smu, + enum pp_df_cstate state) + { ++ struct amdgpu_device *adev = smu->adev; ++ ++ /* ++ * Aldebaran does not need the cstate disablement ++ * prerequisite for gpu reset. ++ */ ++ if (amdgpu_in_reset(adev) || adev->in_suspend) ++ return 0; ++ + return smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_DFCstateControl, state, NULL); + } + +diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c +index 1d454485e0d91..29529328152d0 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c ++++ b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_0_ppt.c +@@ -119,6 +119,7 @@ static struct cmn2asic_msg_mapping smu_v13_0_0_message_map[SMU_MSG_MAX_COUNT] = + MSG_MAP(NotifyPowerSource, PPSMC_MSG_NotifyPowerSource, 0), + MSG_MAP(Mode1Reset, PPSMC_MSG_Mode1Reset, 0), + MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0), ++ MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0), + }; + + static struct cmn2asic_mapping smu_v13_0_0_clk_map[SMU_CLK_COUNT] = { +@@ -1753,6 +1754,15 @@ static int smu_v13_0_0_set_mp1_state(struct smu_context *smu, + return ret; + } + ++static int smu_v13_0_0_set_df_cstate(struct smu_context *smu, ++ enum pp_df_cstate state) ++{ ++ return smu_cmn_send_smc_msg_with_param(smu, ++ SMU_MSG_DFCstateControl, ++ state, ++ NULL); ++} ++ + static const struct pptable_funcs smu_v13_0_0_ppt_funcs = { + .get_allowed_feature_mask = smu_v13_0_0_get_allowed_feature_mask, + .set_default_dpm_table = smu_v13_0_0_set_default_dpm_table, +@@ -1822,6 +1832,7 @@ static const struct pptable_funcs smu_v13_0_0_ppt_funcs = { + .mode1_reset_is_support = smu_v13_0_0_is_mode1_reset_supported, + .mode1_reset = smu_v13_0_mode1_reset, + .set_mp1_state = smu_v13_0_0_set_mp1_state, ++ .set_df_cstate = smu_v13_0_0_set_df_cstate, + }; + + void smu_v13_0_0_set_ppt_funcs(struct smu_context *smu) +diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c +index c422bf8a09b1d..c4102cfb734c2 100644 +--- a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c ++++ b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_7_ppt.c +@@ -121,6 +121,7 @@ static struct cmn2asic_msg_mapping smu_v13_0_7_message_map[SMU_MSG_MAX_COUNT] = + MSG_MAP(Mode1Reset, PPSMC_MSG_Mode1Reset, 0), + MSG_MAP(PrepareMp1ForUnload, PPSMC_MSG_PrepareMp1ForUnload, 0), + MSG_MAP(SetMGpuFanBoostLimitRpm, PPSMC_MSG_SetMGpuFanBoostLimitRpm, 0), ++ MSG_MAP(DFCstateControl, PPSMC_MSG_SetExternalClientDfCstateAllow, 0), + }; + + static struct cmn2asic_mapping smu_v13_0_7_clk_map[SMU_CLK_COUNT] = { +@@ -1587,6 +1588,16 @@ static bool smu_v13_0_7_is_mode1_reset_supported(struct smu_context *smu) + + return true; + } ++ ++static int smu_v13_0_7_set_df_cstate(struct smu_context *smu, ++ enum pp_df_cstate state) ++{ ++ return smu_cmn_send_smc_msg_with_param(smu, ++ SMU_MSG_DFCstateControl, ++ state, ++ NULL); ++} ++ + static const struct pptable_funcs smu_v13_0_7_ppt_funcs = { + .get_allowed_feature_mask = smu_v13_0_7_get_allowed_feature_mask, + .set_default_dpm_table = smu_v13_0_7_set_default_dpm_table, +@@ -1649,6 +1660,7 @@ static const struct pptable_funcs smu_v13_0_7_ppt_funcs = { + .mode1_reset_is_support = smu_v13_0_7_is_mode1_reset_supported, + .mode1_reset = smu_v13_0_mode1_reset, + .set_mp1_state = smu_v13_0_7_set_mp1_state, ++ .set_df_cstate = smu_v13_0_7_set_df_cstate, + }; + + void smu_v13_0_7_set_ppt_funcs(struct smu_context *smu) +diff --git a/drivers/gpu/drm/i915/display/intel_bios.c b/drivers/gpu/drm/i915/display/intel_bios.c +index 7d6eb9ad7a026..459571e2cc575 100644 +--- a/drivers/gpu/drm/i915/display/intel_bios.c ++++ b/drivers/gpu/drm/i915/display/intel_bios.c +@@ -135,18 +135,6 @@ static u32 raw_block_offset(const void *bdb, enum bdb_block_id section_id) + return block - bdb; + } + +-/* size of the block excluding the header */ +-static u32 raw_block_size(const void *bdb, enum bdb_block_id section_id) +-{ +- const void *block; +- +- block = find_raw_section(bdb, section_id); +- if (!block) +- return 0; +- +- return get_blocksize(block); +-} +- + struct bdb_block_entry { + struct list_head node; + enum bdb_block_id section_id; +@@ -231,9 +219,14 @@ static bool validate_lfp_data_ptrs(const void *bdb, + { + int fp_timing_size, dvo_timing_size, panel_pnp_id_size, panel_name_size; + int data_block_size, lfp_data_size; ++ const void *data_block; + int i; + +- data_block_size = raw_block_size(bdb, BDB_LVDS_LFP_DATA); ++ data_block = find_raw_section(bdb, BDB_LVDS_LFP_DATA); ++ if (!data_block) ++ return false; ++ ++ data_block_size = get_blocksize(data_block); + if (data_block_size == 0) + return false; + +@@ -261,21 +254,6 @@ static bool validate_lfp_data_ptrs(const void *bdb, + if (16 * lfp_data_size > data_block_size) + return false; + +- /* +- * Except for vlv/chv machines all real VBTs seem to have 6 +- * unaccounted bytes in the fp_timing table. And it doesn't +- * appear to be a really intentional hole as the fp_timing +- * 0xffff terminator is always within those 6 missing bytes. +- */ +- if (fp_timing_size + dvo_timing_size + panel_pnp_id_size != lfp_data_size && +- fp_timing_size + 6 + dvo_timing_size + panel_pnp_id_size != lfp_data_size) +- return false; +- +- if (ptrs->ptr[0].fp_timing.offset + fp_timing_size > ptrs->ptr[0].dvo_timing.offset || +- ptrs->ptr[0].dvo_timing.offset + dvo_timing_size != ptrs->ptr[0].panel_pnp_id.offset || +- ptrs->ptr[0].panel_pnp_id.offset + panel_pnp_id_size != lfp_data_size) +- return false; +- + /* make sure the table entries have uniform size */ + for (i = 1; i < 16; i++) { + if (ptrs->ptr[i].fp_timing.table_size != fp_timing_size || +@@ -289,6 +267,23 @@ static bool validate_lfp_data_ptrs(const void *bdb, + return false; + } + ++ /* ++ * Except for vlv/chv machines all real VBTs seem to have 6 ++ * unaccounted bytes in the fp_timing table. And it doesn't ++ * appear to be a really intentional hole as the fp_timing ++ * 0xffff terminator is always within those 6 missing bytes. ++ */ ++ if (fp_timing_size + 6 + dvo_timing_size + panel_pnp_id_size == lfp_data_size) ++ fp_timing_size += 6; ++ ++ if (fp_timing_size + dvo_timing_size + panel_pnp_id_size != lfp_data_size) ++ return false; ++ ++ if (ptrs->ptr[0].fp_timing.offset + fp_timing_size != ptrs->ptr[0].dvo_timing.offset || ++ ptrs->ptr[0].dvo_timing.offset + dvo_timing_size != ptrs->ptr[0].panel_pnp_id.offset || ++ ptrs->ptr[0].panel_pnp_id.offset + panel_pnp_id_size != lfp_data_size) ++ return false; ++ + /* make sure the tables fit inside the data block */ + for (i = 0; i < 16; i++) { + if (ptrs->ptr[i].fp_timing.offset + fp_timing_size > data_block_size || +@@ -300,6 +295,15 @@ static bool validate_lfp_data_ptrs(const void *bdb, + if (ptrs->panel_name.offset + 16 * panel_name_size > data_block_size) + return false; + ++ /* make sure fp_timing terminators are present at expected locations */ ++ for (i = 0; i < 16; i++) { ++ const u16 *t = data_block + ptrs->ptr[i].fp_timing.offset + ++ fp_timing_size - 2; ++ ++ if (*t != 0xffff) ++ return false; ++ } ++ + return true; + } + +@@ -333,18 +337,6 @@ static bool fixup_lfp_data_ptrs(const void *bdb, void *ptrs_block) + return validate_lfp_data_ptrs(bdb, ptrs); + } + +-static const void *find_fp_timing_terminator(const u8 *data, int size) +-{ +- int i; +- +- for (i = 0; i < size - 1; i++) { +- if (data[i] == 0xff && data[i+1] == 0xff) +- return &data[i]; +- } +- +- return NULL; +-} +- + static int make_lfp_data_ptr(struct lvds_lfp_data_ptr_table *table, + int table_size, int total_size) + { +@@ -368,11 +360,22 @@ static void next_lfp_data_ptr(struct lvds_lfp_data_ptr_table *next, + static void *generate_lfp_data_ptrs(struct drm_i915_private *i915, + const void *bdb) + { +- int i, size, table_size, block_size, offset; +- const void *t0, *t1, *block; ++ int i, size, table_size, block_size, offset, fp_timing_size; + struct bdb_lvds_lfp_data_ptrs *ptrs; ++ const void *block; + void *ptrs_block; + ++ /* ++ * The hardcoded fp_timing_size is only valid for ++ * modernish VBTs. All older VBTs definitely should ++ * include block 41 and thus we don't need to ++ * generate one. ++ */ ++ if (i915->vbt.version < 155) ++ return NULL; ++ ++ fp_timing_size = 38; ++ + block = find_raw_section(bdb, BDB_LVDS_LFP_DATA); + if (!block) + return NULL; +@@ -381,17 +384,8 @@ static void *generate_lfp_data_ptrs(struct drm_i915_private *i915, + + block_size = get_blocksize(block); + +- size = block_size; +- t0 = find_fp_timing_terminator(block, size); +- if (!t0) +- return NULL; +- +- size -= t0 - block - 2; +- t1 = find_fp_timing_terminator(t0 + 2, size); +- if (!t1) +- return NULL; +- +- size = t1 - t0; ++ size = fp_timing_size + sizeof(struct lvds_dvo_timing) + ++ sizeof(struct lvds_pnp_id); + if (size * 16 > block_size) + return NULL; + +@@ -409,7 +403,7 @@ static void *generate_lfp_data_ptrs(struct drm_i915_private *i915, + table_size = sizeof(struct lvds_dvo_timing); + size = make_lfp_data_ptr(&ptrs->ptr[0].dvo_timing, table_size, size); + +- table_size = t0 - block + 2; ++ table_size = fp_timing_size; + size = make_lfp_data_ptr(&ptrs->ptr[0].fp_timing, table_size, size); + + if (ptrs->ptr[0].fp_timing.table_size) +@@ -424,14 +418,14 @@ static void *generate_lfp_data_ptrs(struct drm_i915_private *i915, + return NULL; + } + +- size = t1 - t0; ++ size = fp_timing_size + sizeof(struct lvds_dvo_timing) + ++ sizeof(struct lvds_pnp_id); + for (i = 1; i < 16; i++) { + next_lfp_data_ptr(&ptrs->ptr[i].fp_timing, &ptrs->ptr[i-1].fp_timing, size); + next_lfp_data_ptr(&ptrs->ptr[i].dvo_timing, &ptrs->ptr[i-1].dvo_timing, size); + next_lfp_data_ptr(&ptrs->ptr[i].panel_pnp_id, &ptrs->ptr[i-1].panel_pnp_id, size); + } + +- size = t1 - t0; + table_size = sizeof(struct lvds_lfp_panel_name); + + if (16 * (size + table_size) <= block_size) { +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 50bab12d9476f..043cf1cc87946 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -1142,6 +1142,7 @@ + #define USB_DEVICE_ID_SONY_PS4_CONTROLLER_2 0x09cc + #define USB_DEVICE_ID_SONY_PS4_CONTROLLER_DONGLE 0x0ba0 + #define USB_DEVICE_ID_SONY_PS5_CONTROLLER 0x0ce6 ++#define USB_DEVICE_ID_SONY_PS5_CONTROLLER_2 0x0df2 + #define USB_DEVICE_ID_SONY_MOTION_CONTROLLER 0x03d5 + #define USB_DEVICE_ID_SONY_NAVIGATION_CONTROLLER 0x042f + #define USB_DEVICE_ID_SONY_BUZZ_CONTROLLER 0x0002 +diff --git a/drivers/hid/hid-playstation.c b/drivers/hid/hid-playstation.c +index b1b5721b5d8f7..d21d868e29ab4 100644 +--- a/drivers/hid/hid-playstation.c ++++ b/drivers/hid/hid-playstation.c +@@ -46,6 +46,7 @@ struct ps_device { + uint32_t fw_version; + + int (*parse_report)(struct ps_device *dev, struct hid_report *report, u8 *data, int size); ++ void (*remove)(struct ps_device *dev); + }; + + /* Calibration data for playstation motion sensors. */ +@@ -174,6 +175,7 @@ struct dualsense { + struct led_classdev player_leds[5]; + + struct work_struct output_worker; ++ bool output_worker_initialized; + void *output_report_dmabuf; + uint8_t output_seq; /* Sequence number for output report. */ + }; +@@ -299,6 +301,7 @@ static const struct {int x; int y; } ps_gamepad_hat_mapping[] = { + {0, 0}, + }; + ++static inline void dualsense_schedule_work(struct dualsense *ds); + static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t green, uint8_t blue); + + /* +@@ -792,6 +795,7 @@ err_free: + return ret; + } + ++ + static int dualsense_get_firmware_info(struct dualsense *ds) + { + uint8_t *buf; +@@ -881,7 +885,7 @@ static int dualsense_player_led_set_brightness(struct led_classdev *led, enum le + ds->update_player_leds = true; + spin_unlock_irqrestore(&ds->base.lock, flags); + +- schedule_work(&ds->output_worker); ++ dualsense_schedule_work(ds); + + return 0; + } +@@ -925,6 +929,16 @@ static void dualsense_init_output_report(struct dualsense *ds, struct dualsense_ + } + } + ++static inline void dualsense_schedule_work(struct dualsense *ds) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ds->base.lock, flags); ++ if (ds->output_worker_initialized) ++ schedule_work(&ds->output_worker); ++ spin_unlock_irqrestore(&ds->base.lock, flags); ++} ++ + /* + * Helper function to send DualSense output reports. Applies a CRC at the end of a report + * for Bluetooth reports. +@@ -1085,7 +1099,7 @@ static int dualsense_parse_report(struct ps_device *ps_dev, struct hid_report *r + spin_unlock_irqrestore(&ps_dev->lock, flags); + + /* Schedule updating of microphone state at hardware level. */ +- schedule_work(&ds->output_worker); ++ dualsense_schedule_work(ds); + } + ds->last_btn_mic_state = btn_mic_state; + +@@ -1200,10 +1214,22 @@ static int dualsense_play_effect(struct input_dev *dev, void *data, struct ff_ef + ds->motor_right = effect->u.rumble.weak_magnitude / 256; + spin_unlock_irqrestore(&ds->base.lock, flags); + +- schedule_work(&ds->output_worker); ++ dualsense_schedule_work(ds); + return 0; + } + ++static void dualsense_remove(struct ps_device *ps_dev) ++{ ++ struct dualsense *ds = container_of(ps_dev, struct dualsense, base); ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ds->base.lock, flags); ++ ds->output_worker_initialized = false; ++ spin_unlock_irqrestore(&ds->base.lock, flags); ++ ++ cancel_work_sync(&ds->output_worker); ++} ++ + static int dualsense_reset_leds(struct dualsense *ds) + { + struct dualsense_output_report report; +@@ -1240,7 +1266,7 @@ static void dualsense_set_lightbar(struct dualsense *ds, uint8_t red, uint8_t gr + ds->lightbar_blue = blue; + spin_unlock_irqrestore(&ds->base.lock, flags); + +- schedule_work(&ds->output_worker); ++ dualsense_schedule_work(ds); + } + + static void dualsense_set_player_leds(struct dualsense *ds) +@@ -1263,7 +1289,7 @@ static void dualsense_set_player_leds(struct dualsense *ds) + + ds->update_player_leds = true; + ds->player_leds_state = player_ids[player_id]; +- schedule_work(&ds->output_worker); ++ dualsense_schedule_work(ds); + } + + static struct ps_device *dualsense_create(struct hid_device *hdev) +@@ -1302,7 +1328,9 @@ static struct ps_device *dualsense_create(struct hid_device *hdev) + ps_dev->battery_capacity = 100; /* initial value until parse_report. */ + ps_dev->battery_status = POWER_SUPPLY_STATUS_UNKNOWN; + ps_dev->parse_report = dualsense_parse_report; ++ ps_dev->remove = dualsense_remove; + INIT_WORK(&ds->output_worker, dualsense_output_worker); ++ ds->output_worker_initialized = true; + hid_set_drvdata(hdev, ds); + + max_output_report_size = sizeof(struct dualsense_output_report_bt); +@@ -1439,7 +1467,8 @@ static int ps_probe(struct hid_device *hdev, const struct hid_device_id *id) + goto err_stop; + } + +- if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER) { ++ if (hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER || ++ hdev->product == USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) { + dev = dualsense_create(hdev); + if (IS_ERR(dev)) { + hid_err(hdev, "Failed to create dualsense.\n"); +@@ -1470,6 +1499,9 @@ static void ps_remove(struct hid_device *hdev) + ps_devices_list_remove(dev); + ps_device_release_player_id(dev); + ++ if (dev->remove) ++ dev->remove(dev); ++ + hid_hw_close(hdev); + hid_hw_stop(hdev); + } +@@ -1477,6 +1509,8 @@ static void ps_remove(struct hid_device *hdev) + static const struct hid_device_id ps_devices[] = { + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) }, + { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER) }, ++ { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS5_CONTROLLER_2) }, + { } + }; + MODULE_DEVICE_TABLE(hid, ps_devices); +diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c +index 811b0a5379d03..2f1cc66d26412 100644 +--- a/drivers/md/dm-clone-target.c ++++ b/drivers/md/dm-clone-target.c +@@ -2035,7 +2035,7 @@ static void disable_passdown_if_not_supported(struct clone *clone) + reason = "max discard sectors smaller than a region"; + + if (reason) { +- DMWARN("Destination device (%pd) %s: Disabling discard passdown.", ++ DMWARN("Destination device (%pg) %s: Disabling discard passdown.", + dest_dev, reason); + clear_bit(DM_CLONE_DISCARD_PASSDOWN, &clone->flags); + } +diff --git a/drivers/pinctrl/pinctrl-amd.c b/drivers/pinctrl/pinctrl-amd.c +index 4691a33bc374f..2a4b3efb7e12b 100644 +--- a/drivers/pinctrl/pinctrl-amd.c ++++ b/drivers/pinctrl/pinctrl-amd.c +@@ -1051,13 +1051,13 @@ static void amd_get_iomux_res(struct amd_gpio *gpio_dev) + + index = device_property_match_string(dev, "pinctrl-resource-names", "iomux"); + if (index < 0) { +- dev_warn(dev, "failed to get iomux index\n"); ++ dev_dbg(dev, "iomux not supported\n"); + goto out_no_pinmux; + } + + gpio_dev->iomux_base = devm_platform_ioremap_resource(gpio_dev->pdev, index); + if (IS_ERR(gpio_dev->iomux_base)) { +- dev_warn(dev, "Failed to get iomux %d io resource\n", index); ++ dev_dbg(dev, "iomux not supported %d io resource\n", index); + goto out_no_pinmux; + } + +diff --git a/drivers/thermal/intel/intel_powerclamp.c b/drivers/thermal/intel/intel_powerclamp.c +index 46cd799af148d..bf3e4edeceda9 100644 +--- a/drivers/thermal/intel/intel_powerclamp.c ++++ b/drivers/thermal/intel/intel_powerclamp.c +@@ -531,11 +531,7 @@ static int start_power_clamp(void) + cpus_read_lock(); + + /* prefer BSP */ +- control_cpu = 0; +- if (!cpu_online(control_cpu)) { +- control_cpu = get_cpu(); +- put_cpu(); +- } ++ control_cpu = cpumask_first(cpu_online_mask); + + clamping = true; + schedule_delayed_work(&poll_pkg_cstate_work, 0); +diff --git a/drivers/video/aperture.c b/drivers/video/aperture.c +index d245826a9324d..101e13c2cf41c 100644 +--- a/drivers/video/aperture.c ++++ b/drivers/video/aperture.c +@@ -335,30 +335,36 @@ EXPORT_SYMBOL(aperture_remove_conflicting_devices); + */ + int aperture_remove_conflicting_pci_devices(struct pci_dev *pdev, const char *name) + { ++ bool primary = false; + resource_size_t base, size; + int bar, ret; + +- /* +- * WARNING: Apparently we must kick fbdev drivers before vgacon, +- * otherwise the vga fbdev driver falls over. +- */ +-#if IS_REACHABLE(CONFIG_FB) +- ret = remove_conflicting_pci_framebuffers(pdev, name); +- if (ret) +- return ret; ++#ifdef CONFIG_X86 ++ primary = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW; + #endif +- ret = vga_remove_vgacon(pdev); +- if (ret) +- return ret; + + for (bar = 0; bar < PCI_STD_NUM_BARS; ++bar) { + if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) + continue; ++ + base = pci_resource_start(pdev, bar); + size = pci_resource_len(pdev, bar); +- aperture_detach_devices(base, size); ++ ret = aperture_remove_conflicting_devices(base, size, primary, name); ++ if (ret) ++ break; + } + ++ if (ret) ++ return ret; ++ ++ /* ++ * WARNING: Apparently we must kick fbdev drivers before vgacon, ++ * otherwise the vga fbdev driver falls over. ++ */ ++ ret = vga_remove_vgacon(pdev); ++ if (ret) ++ return ret; ++ + return 0; + + } +diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c +index bda4d304feb68..4ed0960e6c058 100644 +--- a/drivers/video/fbdev/core/fbmem.c ++++ b/drivers/video/fbdev/core/fbmem.c +@@ -1787,54 +1787,6 @@ int remove_conflicting_framebuffers(struct apertures_struct *a, + } + EXPORT_SYMBOL(remove_conflicting_framebuffers); + +-/** +- * remove_conflicting_pci_framebuffers - remove firmware-configured framebuffers for PCI devices +- * @pdev: PCI device +- * @name: requesting driver name +- * +- * This function removes framebuffer devices (eg. initialized by firmware) +- * using memory range configured for any of @pdev's memory bars. +- * +- * The function assumes that PCI device with shadowed ROM drives a primary +- * display and so kicks out vga16fb. +- */ +-int remove_conflicting_pci_framebuffers(struct pci_dev *pdev, const char *name) +-{ +- struct apertures_struct *ap; +- bool primary = false; +- int err, idx, bar; +- +- for (idx = 0, bar = 0; bar < PCI_STD_NUM_BARS; bar++) { +- if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) +- continue; +- idx++; +- } +- +- ap = alloc_apertures(idx); +- if (!ap) +- return -ENOMEM; +- +- for (idx = 0, bar = 0; bar < PCI_STD_NUM_BARS; bar++) { +- if (!(pci_resource_flags(pdev, bar) & IORESOURCE_MEM)) +- continue; +- ap->ranges[idx].base = pci_resource_start(pdev, bar); +- ap->ranges[idx].size = pci_resource_len(pdev, bar); +- pci_dbg(pdev, "%s: bar %d: 0x%lx -> 0x%lx\n", __func__, bar, +- (unsigned long)pci_resource_start(pdev, bar), +- (unsigned long)pci_resource_end(pdev, bar)); +- idx++; +- } +- +-#ifdef CONFIG_X86 +- primary = pdev->resource[PCI_ROM_RESOURCE].flags & +- IORESOURCE_ROM_SHADOW; +-#endif +- err = remove_conflicting_framebuffers(ap, name, primary); +- kfree(ap); +- return err; +-} +-EXPORT_SYMBOL(remove_conflicting_pci_framebuffers); +- + /** + * register_framebuffer - registers a frame buffer device + * @fb_info: frame buffer info structure +diff --git a/fs/efivarfs/vars.c b/fs/efivarfs/vars.c +index a0ef63cfcecba..9e4f47808bd5a 100644 +--- a/fs/efivarfs/vars.c ++++ b/fs/efivarfs/vars.c +@@ -651,22 +651,6 @@ int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes, + if (err) + return err; + +- /* +- * Ensure that the available space hasn't shrunk below the safe level +- */ +- status = check_var_size(attributes, *size + ucs2_strsize(name, 1024)); +- if (status != EFI_SUCCESS) { +- if (status != EFI_UNSUPPORTED) { +- err = efi_status_to_err(status); +- goto out; +- } +- +- if (*size > 65536) { +- err = -ENOSPC; +- goto out; +- } +- } +- + status = efivar_set_variable_locked(name, vendor, attributes, *size, + data, false); + if (status != EFI_SUCCESS) { +diff --git a/include/linux/efi.h b/include/linux/efi.h +index d2b84c2fec39f..4459794b65db0 100644 +--- a/include/linux/efi.h ++++ b/include/linux/efi.h +@@ -1055,9 +1055,6 @@ efi_status_t efivar_set_variable_locked(efi_char16_t *name, efi_guid_t *vendor, + efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor, + u32 attr, unsigned long data_size, void *data); + +-efi_status_t check_var_size(u32 attributes, unsigned long size); +-efi_status_t check_var_size_nonblocking(u32 attributes, unsigned long size); +- + #if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER) + extern bool efi_capsule_pending(int *reset_type); + +diff --git a/include/linux/fb.h b/include/linux/fb.h +index 07fcd0e566826..b91c770165600 100644 +--- a/include/linux/fb.h ++++ b/include/linux/fb.h +@@ -615,8 +615,6 @@ extern ssize_t fb_sys_write(struct fb_info *info, const char __user *buf, + /* drivers/video/fbmem.c */ + extern int register_framebuffer(struct fb_info *fb_info); + extern void unregister_framebuffer(struct fb_info *fb_info); +-extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev, +- const char *name); + extern int remove_conflicting_framebuffers(struct apertures_struct *a, + const char *name, bool primary); + extern int fb_prepare_logo(struct fb_info *fb_info, int rotate); +diff --git a/include/linux/net.h b/include/linux/net.h +index 711c3593c3b8d..18d942bbdf6e0 100644 +--- a/include/linux/net.h ++++ b/include/linux/net.h +@@ -41,6 +41,7 @@ struct net; + #define SOCK_NOSPACE 2 + #define SOCK_PASSCRED 3 + #define SOCK_PASSSEC 4 ++#define SOCK_SUPPORT_ZC 5 + + #ifndef ARCH_HAS_SOCKET_TYPES + /** +diff --git a/io_uring/io-wq.c b/io_uring/io-wq.c +index c6536d4b2da0b..6f1d0e5df23ad 100644 +--- a/io_uring/io-wq.c ++++ b/io_uring/io-wq.c +@@ -1164,10 +1164,10 @@ struct io_wq *io_wq_create(unsigned bounded, struct io_wq_data *data) + wqe = kzalloc_node(sizeof(struct io_wqe), GFP_KERNEL, alloc_node); + if (!wqe) + goto err; ++ wq->wqes[node] = wqe; + if (!alloc_cpumask_var(&wqe->cpu_mask, GFP_KERNEL)) + goto err; + cpumask_copy(wqe->cpu_mask, cpumask_of_node(node)); +- wq->wqes[node] = wqe; + wqe->node = alloc_node; + wqe->acct[IO_WQ_ACCT_BOUND].max_workers = bounded; + wqe->acct[IO_WQ_ACCT_UNBOUND].max_workers = +diff --git a/io_uring/net.c b/io_uring/net.c +index 4878bf40f8b1c..7804ac77745b1 100644 +--- a/io_uring/net.c ++++ b/io_uring/net.c +@@ -1001,6 +1001,8 @@ int io_send_zc(struct io_kiocb *req, unsigned int issue_flags) + sock = sock_from_file(req->file); + if (unlikely(!sock)) + return -ENOTSOCK; ++ if (!test_bit(SOCK_SUPPORT_ZC, &sock->flags)) ++ return -EOPNOTSUPP; + + msg.msg_name = NULL; + msg.msg_control = NULL; +diff --git a/kernel/gcov/gcc_4_7.c b/kernel/gcov/gcc_4_7.c +index 460c12b7dfea2..7971e989e425b 100644 +--- a/kernel/gcov/gcc_4_7.c ++++ b/kernel/gcov/gcc_4_7.c +@@ -30,6 +30,13 @@ + + #define GCOV_TAG_FUNCTION_LENGTH 3 + ++/* Since GCC 12.1 sizes are in BYTES and not in WORDS (4B). */ ++#if (__GNUC__ >= 12) ++#define GCOV_UNIT_SIZE 4 ++#else ++#define GCOV_UNIT_SIZE 1 ++#endif ++ + static struct gcov_info *gcov_info_head; + + /** +@@ -383,12 +390,18 @@ size_t convert_to_gcda(char *buffer, struct gcov_info *info) + pos += store_gcov_u32(buffer, pos, info->version); + pos += store_gcov_u32(buffer, pos, info->stamp); + ++#if (__GNUC__ >= 12) ++ /* Use zero as checksum of the compilation unit. */ ++ pos += store_gcov_u32(buffer, pos, 0); ++#endif ++ + for (fi_idx = 0; fi_idx < info->n_functions; fi_idx++) { + fi_ptr = info->functions[fi_idx]; + + /* Function record. */ + pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION); +- pos += store_gcov_u32(buffer, pos, GCOV_TAG_FUNCTION_LENGTH); ++ pos += store_gcov_u32(buffer, pos, ++ GCOV_TAG_FUNCTION_LENGTH * GCOV_UNIT_SIZE); + pos += store_gcov_u32(buffer, pos, fi_ptr->ident); + pos += store_gcov_u32(buffer, pos, fi_ptr->lineno_checksum); + pos += store_gcov_u32(buffer, pos, fi_ptr->cfg_checksum); +@@ -402,7 +415,8 @@ size_t convert_to_gcda(char *buffer, struct gcov_info *info) + /* Counter record. */ + pos += store_gcov_u32(buffer, pos, + GCOV_TAG_FOR_COUNTER(ct_idx)); +- pos += store_gcov_u32(buffer, pos, ci_ptr->num * 2); ++ pos += store_gcov_u32(buffer, pos, ++ ci_ptr->num * 2 * GCOV_UNIT_SIZE); + + for (cv_idx = 0; cv_idx < ci_ptr->num; cv_idx++) { + pos += store_gcov_u64(buffer, pos, +diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c +index 5f1d84d901c71..5fbd0a5b48f7e 100644 +--- a/net/ipv4/tcp.c ++++ b/net/ipv4/tcp.c +@@ -457,6 +457,7 @@ void tcp_init_sock(struct sock *sk) + WRITE_ONCE(sk->sk_sndbuf, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_wmem[1])); + WRITE_ONCE(sk->sk_rcvbuf, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[1])); + ++ set_bit(SOCK_SUPPORT_ZC, &sk->sk_socket->flags); + sk_sockets_allocated_inc(sk); + } + EXPORT_SYMBOL(tcp_init_sock); +diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c +index 560d9eadeaa58..516b11c136daf 100644 +--- a/net/ipv4/udp.c ++++ b/net/ipv4/udp.c +@@ -1620,6 +1620,7 @@ int udp_init_sock(struct sock *sk) + { + skb_queue_head_init(&udp_sk(sk)->reader_queue); + sk->sk_destruct = udp_destruct_sock; ++ set_bit(SOCK_SUPPORT_ZC, &sk->sk_socket->flags); + return 0; + } + EXPORT_SYMBOL_GPL(udp_init_sock); +diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c +index 4ae8b9574778b..384426d7e9ddc 100644 +--- a/sound/pci/hda/hda_codec.c ++++ b/sound/pci/hda/hda_codec.c +@@ -931,28 +931,8 @@ snd_hda_codec_device_init(struct hda_bus *bus, unsigned int codec_addr, + } + + codec->bus = bus; +- codec->depop_delay = -1; +- codec->fixup_id = HDA_FIXUP_ID_NOT_SET; +- codec->core.dev.release = snd_hda_codec_dev_release; +- codec->core.exec_verb = codec_exec_verb; + codec->core.type = HDA_DEV_LEGACY; + +- mutex_init(&codec->spdif_mutex); +- mutex_init(&codec->control_mutex); +- snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32); +- snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32); +- snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); +- snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); +- snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8); +- snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16); +- snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16); +- snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8); +- INIT_LIST_HEAD(&codec->conn_list); +- INIT_LIST_HEAD(&codec->pcm_list_head); +- INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work); +- refcount_set(&codec->pcm_ref, 1); +- init_waitqueue_head(&codec->remove_sleep); +- + return codec; + } + EXPORT_SYMBOL_GPL(snd_hda_codec_device_init); +@@ -1005,8 +985,29 @@ int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card, + if (snd_BUG_ON(codec_addr > HDA_MAX_CODEC_ADDRESS)) + return -EINVAL; + ++ codec->core.dev.release = snd_hda_codec_dev_release; ++ codec->core.exec_verb = codec_exec_verb; ++ + codec->card = card; + codec->addr = codec_addr; ++ mutex_init(&codec->spdif_mutex); ++ mutex_init(&codec->control_mutex); ++ snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32); ++ snd_array_init(&codec->nids, sizeof(struct hda_nid_item), 32); ++ snd_array_init(&codec->init_pins, sizeof(struct hda_pincfg), 16); ++ snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16); ++ snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8); ++ snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16); ++ snd_array_init(&codec->jacktbl, sizeof(struct hda_jack_tbl), 16); ++ snd_array_init(&codec->verbs, sizeof(struct hda_verb *), 8); ++ INIT_LIST_HEAD(&codec->conn_list); ++ INIT_LIST_HEAD(&codec->pcm_list_head); ++ refcount_set(&codec->pcm_ref, 1); ++ init_waitqueue_head(&codec->remove_sleep); ++ ++ INIT_DELAYED_WORK(&codec->jackpoll_work, hda_jackpoll_work); ++ codec->depop_delay = -1; ++ codec->fixup_id = HDA_FIXUP_ID_NOT_SET; + + #ifdef CONFIG_PM + codec->power_jiffies = jiffies; diff --git a/1004_linux-6.0.5.patch b/1004_linux-6.0.5.patch new file mode 100644 index 00000000..e13708b0 --- /dev/null +++ b/1004_linux-6.0.5.patch @@ -0,0 +1,159 @@ +diff --git a/Makefile b/Makefile +index f2e41dccdd89d..62a7398c8d06f 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 6 + PATCHLEVEL = 0 +-SUBLEVEL = 4 ++SUBLEVEL = 5 + EXTRAVERSION = + NAME = Hurr durr I'ma ninja sloth + +diff --git a/drivers/clk/tegra/clk-tegra114.c b/drivers/clk/tegra/clk-tegra114.c +index f7405a58877e2..73303458e8866 100644 +--- a/drivers/clk/tegra/clk-tegra114.c ++++ b/drivers/clk/tegra/clk-tegra114.c +@@ -1166,6 +1166,7 @@ static struct tegra_clk_init_table init_table[] __initdata = { + { TEGRA114_CLK_I2S3_SYNC, TEGRA114_CLK_CLK_MAX, 24000000, 0 }, + { TEGRA114_CLK_I2S4_SYNC, TEGRA114_CLK_CLK_MAX, 24000000, 0 }, + { TEGRA114_CLK_VIMCLK_SYNC, TEGRA114_CLK_CLK_MAX, 24000000, 0 }, ++ { TEGRA114_CLK_PWM, TEGRA114_CLK_PLL_P, 408000000, 0 }, + /* must be the last entry */ + { TEGRA114_CLK_CLK_MAX, TEGRA114_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/drivers/clk/tegra/clk-tegra124.c b/drivers/clk/tegra/clk-tegra124.c +index 934520aab6e38..7628cc470a275 100644 +--- a/drivers/clk/tegra/clk-tegra124.c ++++ b/drivers/clk/tegra/clk-tegra124.c +@@ -1330,6 +1330,7 @@ static struct tegra_clk_init_table common_init_table[] __initdata = { + { TEGRA124_CLK_I2S3_SYNC, TEGRA124_CLK_CLK_MAX, 24576000, 0 }, + { TEGRA124_CLK_I2S4_SYNC, TEGRA124_CLK_CLK_MAX, 24576000, 0 }, + { TEGRA124_CLK_VIMCLK_SYNC, TEGRA124_CLK_CLK_MAX, 24576000, 0 }, ++ { TEGRA124_CLK_PWM, TEGRA124_CLK_PLL_P, 408000000, 0 }, + /* must be the last entry */ + { TEGRA124_CLK_CLK_MAX, TEGRA124_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/drivers/clk/tegra/clk-tegra20.c b/drivers/clk/tegra/clk-tegra20.c +index 8a4514f6d5033..422d782475532 100644 +--- a/drivers/clk/tegra/clk-tegra20.c ++++ b/drivers/clk/tegra/clk-tegra20.c +@@ -1044,6 +1044,7 @@ static struct tegra_clk_init_table init_table[] = { + { TEGRA20_CLK_GR2D, TEGRA20_CLK_PLL_C, 300000000, 0 }, + { TEGRA20_CLK_GR3D, TEGRA20_CLK_PLL_C, 300000000, 0 }, + { TEGRA20_CLK_VDE, TEGRA20_CLK_PLL_C, 300000000, 0 }, ++ { TEGRA20_CLK_PWM, TEGRA20_CLK_PLL_P, 48000000, 0 }, + /* must be the last entry */ + { TEGRA20_CLK_CLK_MAX, TEGRA20_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/drivers/clk/tegra/clk-tegra210.c b/drivers/clk/tegra/clk-tegra210.c +index 499f999e91e13..a3488aaac3f78 100644 +--- a/drivers/clk/tegra/clk-tegra210.c ++++ b/drivers/clk/tegra/clk-tegra210.c +@@ -3597,6 +3597,7 @@ static struct tegra_clk_init_table init_table[] __initdata = { + { TEGRA210_CLK_VIMCLK_SYNC, TEGRA210_CLK_CLK_MAX, 24576000, 0 }, + { TEGRA210_CLK_HDA, TEGRA210_CLK_PLL_P, 51000000, 0 }, + { TEGRA210_CLK_HDA2CODEC_2X, TEGRA210_CLK_PLL_P, 48000000, 0 }, ++ { TEGRA210_CLK_PWM, TEGRA210_CLK_PLL_P, 48000000, 0 }, + /* This MUST be the last entry. */ + { TEGRA210_CLK_CLK_MAX, TEGRA210_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/drivers/clk/tegra/clk-tegra30.c b/drivers/clk/tegra/clk-tegra30.c +index 04b4961238209..98ec1a50e8542 100644 +--- a/drivers/clk/tegra/clk-tegra30.c ++++ b/drivers/clk/tegra/clk-tegra30.c +@@ -1237,6 +1237,7 @@ static struct tegra_clk_init_table init_table[] = { + { TEGRA30_CLK_VIMCLK_SYNC, TEGRA30_CLK_CLK_MAX, 24000000, 0 }, + { TEGRA30_CLK_HDA, TEGRA30_CLK_PLL_P, 102000000, 0 }, + { TEGRA30_CLK_HDA2CODEC_2X, TEGRA30_CLK_PLL_P, 48000000, 0 }, ++ { TEGRA30_CLK_PWM, TEGRA30_CLK_PLL_P, 48000000, 0 }, + /* must be the last entry */ + { TEGRA30_CLK_CLK_MAX, TEGRA30_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c +index 015b0440df5dc..85404c62a1c27 100644 +--- a/fs/btrfs/free-space-cache.c ++++ b/fs/btrfs/free-space-cache.c +@@ -48,25 +48,6 @@ static void bitmap_clear_bits(struct btrfs_free_space_ctl *ctl, + struct btrfs_free_space *info, u64 offset, + u64 bytes, bool update_stats); + +-static void __btrfs_remove_free_space_cache_locked( +- struct btrfs_free_space_ctl *ctl) +-{ +- struct btrfs_free_space *info; +- struct rb_node *node; +- +- while ((node = rb_last(&ctl->free_space_offset)) != NULL) { +- info = rb_entry(node, struct btrfs_free_space, offset_index); +- if (!info->bitmap) { +- unlink_free_space(ctl, info, true); +- kmem_cache_free(btrfs_free_space_cachep, info); +- } else { +- free_bitmap(ctl, info); +- } +- +- cond_resched_lock(&ctl->tree_lock); +- } +-} +- + static struct inode *__lookup_free_space_inode(struct btrfs_root *root, + struct btrfs_path *path, + u64 offset) +@@ -900,14 +881,7 @@ out: + return ret; + free_cache: + io_ctl_drop_pages(&io_ctl); +- +- /* +- * We need to call the _locked variant so we don't try to update the +- * discard counters. +- */ +- spin_lock(&ctl->tree_lock); +- __btrfs_remove_free_space_cache_locked(ctl); +- spin_unlock(&ctl->tree_lock); ++ __btrfs_remove_free_space_cache(ctl); + goto out; + } + +@@ -1033,13 +1007,7 @@ int load_free_space_cache(struct btrfs_block_group *block_group) + if (ret == 0) + ret = 1; + } else { +- /* +- * We need to call the _locked variant so we don't try to update +- * the discard counters. +- */ +- spin_lock(&tmp_ctl.tree_lock); + __btrfs_remove_free_space_cache(&tmp_ctl); +- spin_unlock(&tmp_ctl.tree_lock); + btrfs_warn(fs_info, + "block group %llu has wrong amount of free space", + block_group->start); +@@ -3002,6 +2970,25 @@ static void __btrfs_return_cluster_to_free_space( + btrfs_put_block_group(block_group); + } + ++static void __btrfs_remove_free_space_cache_locked( ++ struct btrfs_free_space_ctl *ctl) ++{ ++ struct btrfs_free_space *info; ++ struct rb_node *node; ++ ++ while ((node = rb_last(&ctl->free_space_offset)) != NULL) { ++ info = rb_entry(node, struct btrfs_free_space, offset_index); ++ if (!info->bitmap) { ++ unlink_free_space(ctl, info, true); ++ kmem_cache_free(btrfs_free_space_cachep, info); ++ } else { ++ free_bitmap(ctl, info); ++ } ++ ++ cond_resched_lock(&ctl->tree_lock); ++ } ++} ++ + void __btrfs_remove_free_space_cache(struct btrfs_free_space_ctl *ctl) + { + spin_lock(&ctl->tree_lock);
