[DO NOT MERGE ANYWHERE] Revert "slc_acpm: Replace mutex with spinlock"

Revert submission 2720133-gpu-slcv2

Reason for revert: Prebuild did not land before cutoff

Reverted changes: /q/submissionid:2720133-gpu-slcv2

Bug: 329447972
Change-Id: If016c876453ed97fbe8e6a1be414f2c7784fe6ce

1 files changed, 56 insertions, 75 deletions

diff --git a/drivers/soc/google/pt/pt.c b/drivers/soc/google/pt/pt.c
index 4dffd341e..c32d6e133 100644
--- a/drivers/soc/google/pt/pt.c
+++ b/drivers/soc/google/pt/pt.c
@@ -60,7 +60,7 @@ struct pt_properties {
  */
 
 struct pt_handle { /* one per client */
-	spinlock_t lock; /* serialize write access to the handle */
+	struct mutex mt; /* serialize write access to the handle */
 	struct list_head list;
 	pt_resize_callback_t resize_callback;
 	int id_cnt;
@@ -76,7 +76,7 @@ struct pt_driver { /* one per driver */
 	struct pt_properties *properties;
 	struct list_head list;
 	const struct pt_ops *ops;
-	spinlock_t lock; /* serialize access to the driver */
+	struct mutex mt; /* serialize access to the driver */
 	int ref;
 	int ioctl_ret; /* return of last successful ops->ioctl() */
 	struct device_node *node; /* driver node */
@@ -238,7 +238,7 @@ static void pt_resize_list_enable(struct pt_pts *pts)
 
 /*
  * Thread calling the resize callback.
- * This thread doesn't hold any lock, so the callback can
+ * This thread doesn't hold any mutex, so the callback can
  * call pt_client_*()
  */
 static int pt_resize_thread(void *data)
@@ -310,16 +310,15 @@ static bool pt_driver_alloc(struct pt_handle *handle, int id)
 	struct pt_driver *driver = handle->pts[id].driver;
 	void *data = driver->data;
 	int property_index = handle->pts[id].property_index;
-	unsigned long flags;
 
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	ptid = driver->ops->alloc(data,
 				  property_index,
 				  &handle->pts[id],
 				  pt_resize_internal);
 	if (ptid != PT_PTID_INVALID)
 		handle->pts[id].ptid = ptid;
-	spin_unlock_irqrestore(&driver->lock, flags);
+	mutex_unlock(&handle->pts[id].driver->mt);
 	return ptid != PT_PTID_INVALID;
 }
 
@@ -328,11 +327,10 @@ static void pt_driver_enable(struct pt_handle *handle, int id)
 	ptid_t ptid = handle->pts[id].ptid;
 	struct pt_driver *driver = handle->pts[id].driver;
 	void *data = driver->data;
-	unsigned long flags;
 
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	driver->ops->enable(data, ptid);
-	spin_unlock_irqrestore(&driver->lock, flags);
+	mutex_unlock(&driver->mt);
 }
 
 static void pt_driver_disable(struct pt_handle *handle, int id)
@@ -340,11 +338,10 @@ static void pt_driver_disable(struct pt_handle *handle, int id)
 	ptid_t ptid = handle->pts[id].ptid;
 	struct pt_driver *driver = handle->pts[id].driver;
 	void *data = driver->data;
-	unsigned long flags;
 
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	driver->ops->disable(data, ptid);
-	spin_unlock_irqrestore(&handle->pts[id].driver->lock, flags);
+	mutex_unlock(&handle->pts[id].driver->mt);
 }
 
 static void pt_driver_free(struct pt_handle *handle, int id)
@@ -352,12 +349,11 @@ static void pt_driver_free(struct pt_handle *handle, int id)
 	ptid_t ptid = handle->pts[id].ptid;
 	struct pt_driver *driver = handle->pts[id].driver;
 	void *data = driver->data;
-	unsigned long flags;
 
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	driver->ops->free(data, ptid);
 	handle->pts[id].ptid = PT_PTID_INVALID;
-	spin_unlock_irqrestore(&handle->pts[id].driver->lock, flags);
+	mutex_unlock(&handle->pts[id].driver->mt);
 }
 
 static int pt_driver_mutate(struct pt_handle *handle, int old_id, int new_id)
@@ -367,9 +363,8 @@ static int pt_driver_mutate(struct pt_handle *handle, int old_id, int new_id)
 	struct pt_driver *driver = handle->pts[old_id].driver;
 	void *data = driver->data;
 	int new_property_index = handle->pts[new_id].property_index;
-	unsigned long flags;
 
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	new_ptid = driver->ops->mutate(data, old_ptid,
 					&handle->pts[new_id],
 					new_property_index);
@@ -380,7 +375,7 @@ static int pt_driver_mutate(struct pt_handle *handle, int old_id, int new_id)
 		handle->pts[old_id].enabled = false;
 		handle->pts[new_id].enabled = true;
 	}
-	spin_unlock_irqrestore(&driver->lock, flags);
+	mutex_unlock(&driver->mt);
 	return new_ptid;
 }
 
@@ -449,18 +444,17 @@ static int pt_driver_ioctl3(struct pt_driver *driver, int arg0,
 {
 	int ret;
 	int args[3];
-	unsigned long flags;
 
 	if (!driver->ops->ioctl)
 		return -EINVAL;
-	spin_lock_irqsave(&driver->lock, flags);
+	mutex_lock(&driver->mt);
 	args[0] = arg0;
 	args[1] = arg1;
 	args[2] = arg2;
 	ret = driver->ops->ioctl(driver->data, 3, args);
 	if (ret >= 0)
 		driver->ioctl_ret = args[0];
-	spin_unlock_irqrestore(&driver->lock, flags);
+	mutex_unlock(&driver->mt);
 	return ret;
 }
 
@@ -544,62 +538,56 @@ void pt_global_disable(struct pt_global *global)
 {
 	void *data;
 	int property_index;
-	unsigned long flags;
 
 	if (!global->driver)
 		return;
-
-	spin_lock_irqsave(&global->driver->lock, flags);
-
-	if (global->ptid == PT_PTID_INVALID)
-		goto out_unlock;
-
+	mutex_lock(&global->driver->mt);
+	if (global->ptid == PT_PTID_INVALID) {
+		mutex_unlock(&global->driver->mt);
+		return;
+	}
 	data = global->driver->data;
 	property_index = global->property_index;
 	global->ptid = global->driver->ops->alloc(data,
 						  property_index,
 						  NULL,
 						  pt_resize_internal_nop);
-	if (global->ptid == PT_PTID_INVALID)
-		goto out_unlock;
-
+	if (global->ptid == PT_PTID_INVALID) {
+		mutex_unlock(&global->driver->mt);
+		return;
+	}
 	global->driver->ops->disable(data, global->ptid);
 	global->driver->ops->free(data, global->ptid);
 	global->ptid = PT_PTID_INVALID;
 	global->pbha = PT_PTID_INVALID;
-
-out_unlock:
-	spin_unlock_irqrestore(&global->driver->lock, flags);
+	mutex_unlock(&global->driver->mt);
 }
 
 static void pt_global_enable(struct pt_global *global)
 {
 	void *data;
 	int property_index;
-	unsigned long flags;
 
 	if (!global->driver)
 		return;
-
-	spin_lock_irqsave(&global->driver->lock, flags);
-
-	if (global->ptid != PT_PTID_INVALID)
-		goto out_unlock;
-
+	mutex_lock(&global->driver->mt);
+	if (global->ptid != PT_PTID_INVALID) {
+		mutex_unlock(&global->driver->mt);
+		return;
+	}
 	data = global->driver->data;
 	property_index = global->property_index;
 	global->ptid = global->driver->ops->alloc(data,
 						  property_index,
 						  NULL,
 						  pt_resize_internal_nop);
-	if (global->ptid == PT_PTID_INVALID)
-		goto out_unlock;
-
+	if (global->ptid == PT_PTID_INVALID) {
+		mutex_unlock(&global->driver->mt);
+		return;
+	}
 	global->driver->ops->enable(data, global->ptid);
 	global->pbha = global->driver->ops->pbha(data, global->ptid);
-
-out_unlock:
-	spin_unlock_irqrestore(&global->driver->lock, flags);
+	mutex_unlock(&global->driver->mt);
 }
 
 ptpbha_t pt_pbha(struct device_node *node, int id)
@@ -614,14 +602,14 @@ ptpbha_t pt_pbha(struct device_node *node, int id)
 	spin_unlock_irqrestore(&pt_internal_data.sl, flags);
 	if (!handle || id >= handle->id_cnt)
 		return PT_PBHA_INVALID;
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	ptid = handle->pts[id].ptid;
 	if (ptid != PT_PTID_INVALID) {
 		pbha = handle->pts[id].driver->ops->pbha(
 				handle->pts[id].driver->data,
 				ptid);
 	}
-	spin_unlock_irqrestore(&handle->lock, flags);
+	mutex_unlock(&handle->mt);
 	return pbha;
 }
 
@@ -668,16 +656,15 @@ ptid_t pt_client_mutate_size(struct pt_handle *handle, int old_id, int new_id, s
 {
 	ptid_t ptid;
 	struct pt_driver *driver;
-	unsigned long flags;
 
 	driver = handle->pts[old_id].driver;
 	if (driver != handle->pts[new_id].driver)
 		return PT_PTID_INVALID;
 	pt_handle_check(handle, old_id);
 	pt_handle_check(handle, new_id);
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	if ((!handle->pts[old_id].enabled) || (handle->pts[new_id].enabled)) {
-		spin_unlock_irqrestore(&handle->lock, flags);
+		mutex_unlock(&handle->mt);
 		return PT_PTID_INVALID;
 	}
 	ptid = pt_driver_mutate(handle, old_id, new_id);
@@ -685,37 +672,35 @@ ptid_t pt_client_mutate_size(struct pt_handle *handle, int old_id, int new_id, s
 	pt_trace(handle, new_id, true);
 	/* Update by driver callback */
 	*size = handle->pts[new_id].size;
-	spin_unlock_irqrestore(&handle->lock, flags);
+	mutex_unlock(&handle->mt);
 	return ptid;
 
 }
 
 void pt_client_disable_no_free(struct pt_handle *handle, int id)
 {
-	unsigned long flags;
 	pt_handle_check(handle, id);
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	if (!pt_resize_list_disable(&handle->pts[id])) {
-		spin_unlock_irqrestore(&handle->lock, flags);
+		mutex_unlock(&handle->mt);
 		return;
 	}
 	pt_driver_disable(handle, id);
 	pt_trace(handle, id, false);
-	spin_unlock_irqrestore(&handle->lock, flags);
+	mutex_unlock(&handle->mt);
 }
 
 void pt_client_free(struct pt_handle *handle, int id)
 {
-	unsigned long flags;
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	pt_handle_check(handle, id);
 	if (handle->pts[id].enabled) {
-		spin_unlock_irqrestore(&handle->lock, flags);
+		mutex_unlock(&handle->mt);
 		return;
 	}
 	if (handle->pts[id].ptid != PT_PTID_INVALID)
 		pt_driver_free(handle, id);
-	spin_unlock_irqrestore(&handle->lock, flags);
+	mutex_unlock(&handle->mt);
 }
 
 void pt_client_disable(struct pt_handle *handle, int id)
@@ -726,12 +711,11 @@ void pt_client_disable(struct pt_handle *handle, int id)
 
 ptid_t pt_client_enable_size(struct pt_handle *handle, int id, size_t *size)
 {
-	unsigned long flags;
 	ptid_t ptid;
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	pt_handle_check(handle, id);
 	if (handle->pts[id].enabled) {
-		spin_unlock_irqrestore(&handle->lock, flags);
+		mutex_unlock(&handle->mt);
 		return -EINVAL;
 	}
 	ptid = handle->pts[id].ptid;
@@ -746,7 +730,7 @@ ptid_t pt_client_enable_size(struct pt_handle *handle, int id, size_t *size)
 	}
 	/* Update by driver callback */
 	*size = handle->pts[id].size;
-	spin_unlock_irqrestore(&handle->lock, flags);
+	mutex_unlock(&handle->mt);
 	if (ptid != PT_PTID_INVALID)
 		pt_resize_list_enable(&handle->pts[id]);
 	return ptid;
@@ -764,17 +748,17 @@ void pt_client_unregister(struct pt_handle *handle)
 	int id;
 	unsigned long flags;
 
-	spin_lock_irqsave(&handle->lock, flags);
+	mutex_lock(&handle->mt);
 	for (id = 0; id < handle->id_cnt; id++) {
 		if (handle->pts[id].ptid != PT_PTID_INVALID)
 			panic("%s %s %d enabled\n", __func__,
 				handle->node->name, id);
 		pt_driver_put(handle->pts[id].driver);
 	}
-	spin_lock(&pt_internal_data.sl);
+	spin_lock_irqsave(&pt_internal_data.sl, flags);
 	pt_internal_data.timestamp++;
 	list_del(&handle->list);
-	spin_unlock(&pt_internal_data.sl);
+	spin_unlock_irqrestore(&pt_internal_data.sl, flags);
 	pt_handle_sysctl_unregister(handle);
 
 	for (id = 0; id < handle->id_cnt; id++) {
@@ -782,14 +766,11 @@ void pt_client_unregister(struct pt_handle *handle)
 
 		if (ptid == PT_PTID_INVALID)
 			continue;
-		spin_lock(&handle->pts[id].driver->lock);
+		mutex_lock(&handle->pts[id].driver->mt);
 		handle->pts[id].driver->ops->free(
 			handle->pts[id].driver->data, ptid);
-		spin_unlock(&handle->pts[id].driver->lock);
+		mutex_unlock(&handle->pts[id].driver->mt);
 	}
-
-	spin_unlock_irqrestore(&handle->lock, flags);
-
 	kfree(handle);
 }
 
@@ -815,7 +796,7 @@ struct pt_handle *pt_client_register(struct device_node *node, void *data,
 	handle->node = node;
 	handle->resize_callback = resize_callback;
 	handle->pts = (struct pt_pts *)(handle + 1);
-	spin_lock_init(&handle->lock);
+	mutex_init(&handle->mt);
 
 	// Check/Extract pts from property
 	for (id = 0; id < handle->id_cnt; id++) {
@@ -878,7 +859,7 @@ struct pt_driver *pt_driver_register(struct device_node *node,
 	if (driver == NULL)
 		return NULL;
 	memset(driver, 0, size);
-	spin_lock_init(&driver->lock);
+	mutex_init(&driver->mt);
 	driver->ops = ops;
 	driver->node = node;
 	driver->data = data;