Synchronize code for OnePlus CPH2573_14.0.0.232(EX01)

Based on QCOM release TAG:AU_LINUX_KERNEL.PLATFORM.3.0.R1.00.00.00.017.045

android/abi_gki_aarch64.stg

@@ -329688,6 +329688,15 @@ elf_symbol {
   type_id: 0x9bcd4ff7
   full_name: "__traceiter_android_vh_update_topology_flags_workfn"
 }
+elf_symbol {
+  id: 0x306a6019
+  name: "__traceiter_android_vh_mpam_set"
+  is_defined: true
+  symbol_type: FUNCTION
+  crc: 0xd262c40e
+  type_id: 0x9bdc9aae
+  full_name: "__traceiter_android_vh_mpam_set"
+}
 elf_symbol {
   id: 0xb0bf7fd6
   name: "__traceiter_android_vh_watchdog_timer_softlockup"
@@ -332964,6 +332973,15 @@ elf_symbol {
   type_id: 0x18ccbd2c
   full_name: "__tracepoint_android_vh_update_topology_flags_workfn"
 }
+elf_symbol {
+  id: 0x65023f2f
+  name: "__tracepoint_android_vh_mpam_set"
+  is_defined: true
+  symbol_type: OBJECT
+  crc: 0x0315217a
+  type_id: 0x18ccbd2c
+  full_name: "__tracepoint_android_vh_mpam_set"
+}
 elf_symbol {
   id: 0x42dbeb24
   name: "__tracepoint_android_vh_watchdog_timer_softlockup"

android/abi_gki_aarch64_oplus

@@ -140,6 +140,8 @@
   __traceiter_android_vh_rwsem_opt_spin_finish
   __traceiter_android_vh_rwsem_opt_spin_start
   __traceiter_android_vh_rwsem_wake_finish
+  __traceiter_android_vh_adjust_alloc_flags
+  __traceiter_android_vh_adjust_kvmalloc_flags
   __traceiter_android_vh_sched_stat_runtime_rt
   __traceiter_android_vh_shrink_node_memcgs
   __traceiter_android_vh_sync_txn_recvd
@@ -214,6 +216,8 @@
   __tracepoint_android_vh_rwsem_opt_spin_finish
   __tracepoint_android_vh_rwsem_opt_spin_start
   __tracepoint_android_vh_rwsem_wake_finish
+  __tracepoint_android_vh_adjust_alloc_flags
+  __tracepoint_android_vh_adjust_kvmalloc_flags
   __tracepoint_android_vh_sched_stat_runtime_rt
   __tracepoint_android_vh_shrink_node_memcgs
   __tracepoint_android_vh_sync_txn_recvd

android/abi_gki_aarch64_qcom

@@ -3411,6 +3411,7 @@
   __traceiter_android_vh_ufs_send_uic_command
   __traceiter_android_vh_ufs_update_sdev
   __traceiter_android_vh_update_topology_flags_workfn
+  __traceiter_android_vh_mpam_set
   __traceiter_binder_transaction_received
   __traceiter_cpu_frequency_limits
   __traceiter_cpu_idle
@@ -3556,6 +3557,7 @@
   __tracepoint_android_vh_ufs_send_uic_command
   __tracepoint_android_vh_ufs_update_sdev
   __tracepoint_android_vh_update_topology_flags_workfn
+  __tracepoint_android_vh_mpam_set
   __tracepoint_binder_transaction_received
   __tracepoint_cpu_frequency_limits
   __tracepoint_cpu_idle

arch/arm64/configs/vendor/pineapple_GKI.config

@@ -280,6 +280,7 @@ CONFIG_RPROC_SSR_NOTIF_TIMEOUT=20000
 CONFIG_RPROC_SYSMON_NOTIF_TIMEOUT=20000
 CONFIG_RTC_DRV_PM8XXX=m
 CONFIG_SCHED_WALT=m
+CONFIG_OPLUS_BENCHMARK_CPU=y
 # CONFIG_SCHED_WALT_DEBUG is not set
 CONFIG_SCSI_UFS_CRYPTO_QTI=m
 CONFIG_SCSI_UFS_QCOM=m

drivers/android/vendor_hooks.c

@@ -251,6 +251,8 @@ EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_set_readahead_gfp_mask);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_alter_mutex_list_add);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_mutex_unlock_slowpath);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_rwsem_wake_finish);
+EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_adjust_alloc_flags);
+EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_adjust_kvmalloc_flags);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_binder_looper_state_registered);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_binder_thread_read);
 EXPORT_TRACEPOINT_SYMBOL_GPL(android_vh_binder_free_proc);

drivers/clk/qcom/gdsc-regulator.c

@@ -440,22 +440,31 @@ static int gdsc_enable(struct regulator_dev *rdev)
 static int gdsc_disable(struct regulator_dev *rdev)
 {
 	struct gdsc *sc = rdev_get_drvdata(rdev);
+	struct regulator_dev *parent_rdev;
 	uint32_t regval;
-	int i, ret = 0, parent_enabled;
+	int i, ret = 0;
+	bool lock = false;
 
 	if (rdev->supply) {
-		parent_enabled = regulator_is_enabled(rdev->supply);
-		if (parent_enabled < 0) {
-			ret = parent_enabled;
-			dev_err(&rdev->dev, "%s unable to check parent enable state, ret=%d\n",
-				sc->rdesc.name, ret);
-			return ret;
-		}
+		parent_rdev = rdev->supply->rdev;
+
+		/*
+		 * At this point, it can be assumed that parent supply's mutex is always
+		 * locked by regulator framework before calling this callback but there
+		 * are code paths where it isn't locked (e.g regulator_late_cleanup()).
+		 *
+		 * If parent supply is not locked, lock the parent supply mutex before
+		 * checking it's enable count, so it won't get disabled while in the
+		 * middle of GDSC operations
+		 */
+		if (ww_mutex_trylock(&parent_rdev->mutex, NULL))
+			lock = true;
 
-		if (!parent_enabled) {
+		if (!parent_rdev->use_count) {
 			dev_err(&rdev->dev, "%s cannot disable GDSC while parent is disabled\n",
 				sc->rdesc.name);
-			return -EIO;
+			ret = -EIO;
+			goto done;
 		}
 	}
 
@@ -499,7 +508,7 @@ static int gdsc_disable(struct regulator_dev *rdev)
 		} else {
 			ret = check_gdsc_status(sc, &rdev->dev, DISABLED);
 			if (ret)
-				return ret;
+				goto done;
 		}
 
 		if (sc->domain_addr) {
@@ -512,7 +521,7 @@ static int gdsc_disable(struct regulator_dev *rdev)
 			ret = icc_set_bw(sc->paths[i], 0, 0);
 			if (ret) {
 				dev_err(&rdev->dev, "Failed to unvote BW for %d: %d\n", i, ret);
-				return ret;
+				goto done;
 			}
 		}
 	} else {
@@ -532,6 +541,10 @@ static int gdsc_disable(struct regulator_dev *rdev)
 
 	sc->is_gdsc_enabled = false;
 
+done:
+	if (rdev->supply && lock)
+		ww_mutex_unlock(&parent_rdev->mutex);
+
 	return ret;
 }
 
@@ -566,6 +579,7 @@ static unsigned int gdsc_get_mode(struct regulator_dev *rdev)
 static int gdsc_set_mode(struct regulator_dev *rdev, unsigned int mode)
 {
 	struct gdsc *sc = rdev_get_drvdata(rdev);
+	struct regulator_dev *parent_rdev;
 	uint32_t regval;
 	int ret = 0;
 
@@ -586,35 +600,35 @@ static int gdsc_set_mode(struct regulator_dev *rdev, unsigned int mode)
 	}
 
 	if (rdev->supply) {
+		parent_rdev = rdev->supply->rdev;
 		/*
 		 * Ensure that the GDSC parent supply is enabled before
 		 * continuing.  This is needed to avoid an unclocked access
 		 * of the GDSC control register for GDSCs whose register access
 		 * is gated by the parent supply enable state in hardware.
 		 */
-		ret = regulator_is_enabled(rdev->supply);
-		if (ret < 0) {
-			dev_err(&rdev->dev, "%s unable to check parent enable state, ret=%d\n",
-				sc->rdesc.name, ret);
-			return ret;
-		} else if (WARN(!ret,
+		ww_mutex_lock(&parent_rdev->mutex, NULL);
+
+		if (!parent_rdev->use_count) {
+			dev_err(&rdev->dev,
 				"%s cannot change GDSC HW/SW control mode while parent is disabled\n",
-				sc->rdesc.name)) {
-			return -EIO;
+				sc->rdesc.name);
+			ret = -EIO;
+			goto done;
 		}
 	}
 
 	ret = regmap_read(sc->regmap, REG_OFFSET, &regval);
 	if (ret < 0)
-		return ret;
+		goto done;
 
 	switch (mode) {
 	case REGULATOR_MODE_FAST:
 		/* Turn on HW trigger mode */
 		regval |= HW_CONTROL_MASK;
 		ret = regmap_write(sc->regmap, REG_OFFSET, regval);
 		if (ret < 0)
-			return ret;
+			goto done;
 		/*
 		 * There may be a race with internal HW trigger signal,
 		 * that will result in GDSC going through a power down and
@@ -633,7 +647,7 @@ static int gdsc_set_mode(struct regulator_dev *rdev, unsigned int mode)
 		regval &= ~HW_CONTROL_MASK;
 		ret = regmap_write(sc->regmap, REG_OFFSET, regval);
 		if (ret < 0)
-			return ret;
+			goto done;
 		/*
 		 * There may be a race with internal HW trigger signal,
 		 * that will result in GDSC going through a power down and
@@ -651,15 +665,20 @@ static int gdsc_set_mode(struct regulator_dev *rdev, unsigned int mode)
 		if (sc->is_gdsc_enabled) {
 			ret = check_gdsc_status(sc, &rdev->dev, ENABLED);
 			if (ret)
-				return ret;
+				goto done;
 		}
 		sc->is_gdsc_hw_ctrl_mode = false;
 		break;
 	default:
-		return -EINVAL;
+		ret = -EINVAL;
+		break;
 	}
 
-	return 0;
+done:
+	if (rdev->supply)
+		ww_mutex_unlock(&parent_rdev->mutex);
+
+	return ret;
 }
 
 static const struct regulator_ops gdsc_ops = {

drivers/dma-buf/heaps/qcom_system_heap.c

@@ -245,6 +245,9 @@ static void dynamic_page_pool_refill(struct dynamic_page_pool *pool)
 	if (!pool->order)
 		return;
 
+	if (pool->order > 4)
+		gfp_refill &= ~__GFP_RECLAIM;
+
 	while (!dynamic_pool_fillmark_reached(pool) && dynamic_pool_refill_ok(pool)) {
 		page = alloc_pages(gfp_refill, pool->order);
 		if (!page)

drivers/firmware/qcom_scm-legacy.c

@@ -16,8 +16,6 @@
 
 #include "qcom_scm.h"
 
-static DEFINE_MUTEX(qcom_scm_lock);
-
 /**
  * struct scm_legacy_command - one SCM command buffer
  * @len: total available memory for command and response
@@ -164,11 +162,11 @@ int scm_legacy_call(struct device *dev, const struct qcom_scm_desc *desc,
 	smc.args[1] = (unsigned long)&context_id;
 	smc.args[2] = cmd_phys;
 
-	mutex_lock(&qcom_scm_lock);
+        down(&qcom_scm_sem_lock);
 	__scm_legacy_do(&smc, &smc_res);
 	if (smc_res.a0)
 		ret = qcom_scm_remap_error(smc_res.a0);
-	mutex_unlock(&qcom_scm_lock);
+	up(&qcom_scm_sem_lock);
 	if (ret)
 		goto out;
 

drivers/firmware/qcom_scm-smc.c

@@ -114,7 +114,7 @@ int scm_get_wq_ctx(u32 *wq_ctx, u32 *flags, u32 *more_pending)
 }
 
 static int scm_smc_do_quirk(struct device *dev, struct arm_smccc_args *smc,
-		    struct arm_smccc_res *res, const bool multi_smc_call)
+		    struct arm_smccc_res *res)
 {
 	struct completion *wq = NULL;
 	struct qcom_scm *qscm;
@@ -141,32 +141,20 @@ static int scm_smc_do_quirk(struct device *dev, struct arm_smccc_args *smc,
 			}
 
 			if (res->a0 == QCOM_SCM_WAITQ_SLEEP) {
-				if (multi_smc_call)
-					mutex_unlock(&qcom_scm_lock);
 				wait_for_completion(wq);
-				if (multi_smc_call)
-					mutex_lock(&qcom_scm_lock);
 				fill_wq_resume_args(smc, smc_call_ctx);
-				wq = NULL;
 				continue;
 			} else {
 				fill_wq_wake_ack_args(smc, smc_call_ctx);
+                                scm_waitq_flag_handler(wq, flags);
 				continue;
 			}
 		} else if ((long)res->a0 < 0) {
 			/* Error, return to caller with original SMC call */
 			*smc = original;
 			break;
-		} else {
-			/*
-			 * Success.
-			 * wq will be set only if a prior WAKE happened.
-			 * Its value will be the one from the prior WAKE.
-			 */
-			if (wq)
-				scm_waitq_flag_handler(wq, flags);
-			break;
-		}
+		} else
+                    return 0;
 	} while (IS_WAITQ_SLEEP_OR_WAKE(res));
 
 	return 0;
@@ -186,9 +174,13 @@ static int __scm_smc_do(struct device *dev, struct arm_smccc_args *smc,
 	}
 
 	do {
-		mutex_lock(&qcom_scm_lock);
-		ret = scm_smc_do_quirk(dev, smc, res, multi_smc_call);
-		mutex_unlock(&qcom_scm_lock);
+		if (!multi_smc_call)
+                    mutex_lock(&qcom_scm_lock);
+                down(&qcom_scm_sem_lock);
+                ret = scm_smc_do_quirk(dev, smc, res);
+                up(&qcom_scm_sem_lock);
+                if (!multi_smc_call)
+                    mutex_unlock(&qcom_scm_lock);
 		if (ret)
 			return ret;
 

drivers/firmware/qcom_scm.c

@@ -71,6 +71,8 @@ struct qcom_scm {
 	u64 dload_mode_addr;
 };
 
+DEFINE_SEMAPHORE(qcom_scm_sem_lock);
+
 #define QCOM_SCM_FLAG_COLDBOOT_CPU0	0x00
 #define QCOM_SCM_FLAG_COLDBOOT_CPU1	0x01
 #define QCOM_SCM_FLAG_COLDBOOT_CPU2	0x08
@@ -83,6 +85,7 @@ struct qcom_scm {
 
 #define QCOM_SMC_WAITQ_FLAG_WAKE_ONE	BIT(0)
 #define QCOM_SMC_WAITQ_FLAG_WAKE_ALL	BIT(1)
+#define QCOM_SCM_WAITQ_FLAG_WAKE_NONE   0x0
 
 struct qcom_scm_wb_entry {
 	int flag;
@@ -2836,6 +2839,10 @@ static void scm_irq_work(struct work_struct *work)
 			return;
 		}
 
+                /* This happens if two wakeups occur in close succession */
+                if (flags == QCOM_SCM_WAITQ_FLAG_WAKE_NONE)
+                        return;
+
 		wq_to_wake = qcom_scm_lookup_wq(scm, wq_ctx);
 		if (IS_ERR_OR_NULL(wq_to_wake)) {
 			pr_err("No waitqueue found for wq_ctx %d: %d\n",
@@ -2872,15 +2879,19 @@ static int __qcom_multi_smc_init(struct qcom_scm *__scm,
 			return irq;
 		}
 
-		ret = devm_request_threaded_irq(__scm->dev, irq, NULL,
-			qcom_scm_irq_handler, IRQF_ONESHOT, "qcom-scm", __scm);
+		ret = devm_request_irq(__scm->dev, irq,
+                        qcom_scm_irq_handler,
+                        IRQF_ONESHOT, "qcom-scm", __scm);
 		if (ret < 0) {
 			dev_err(__scm->dev, "Failed to request qcom-scm irq: %d\n", ret);
 			return ret;
 		}
 
 		/* Detect Multi SMC support present or not */
-		qcom_scm_query_wq_queue_info(__scm);
+		ret = qcom_scm_query_wq_queue_info(__scm);
+                if (!ret)
+                     sema_init(&qcom_scm_sem_lock,
+                              (int)__scm->waitq.call_ctx_cnt);
 	}
 
 	return ret;