qcacld-3.0: Synchronize country set driver command and idle shutdown

Currently there is no synchronization between country set command
and idle shutdown which leads to undefined behavior in the host
driver.

In the current issue, host driver gets the country change command
and it sends the command to FW, by the time FW sends the response
of the country change command, host driver triggers the idle
shutdown and idle shutdown starts the psoc transition,
in the path to process the regulatory event, host driver tries to
start the psoc operation in hdd country change work handle. Since,
hdd transition is in progress, hdd work handle does not get the
psoc operation and driver reschedules the work until it gets the
psoc operstion. Once the idle shutdown is complete, hdd country
change work handle get the psoc operation object, since idle
shutdown changes the memory domain from active to init domain
and psoc operation gets allocated in init domain. Now by the time
hdd country change work handle executes, host driver got the
interface up and as part of the hdd_open host driver changes the
memory domain from init to active domain. Now, when the hdd country
change work completes, it tries to release the memory of psoc operation,
this gives the issue of incorrect memory domain on mem free because
memory was allocated in init domain and getting released in active
domain.

To fix this issue, take the psoc operation in the host driver when it
receives the country change command so that when idle shutdown is
triggered, it waits for this operation to complete before proceeding
with the psoc transition.
Also, add wait for completion of the country change event in
hdd reg set country API so that psoc operation for country set
gets completed only after the hdd country change work handle is
completed. So that idle shutdown does not proceed and change the
memory domain.
Also, add wait for completion of the country change event in
hdd psoc idle shutdown, so that it does not take the psoc
transition and when kernel schedules hdd country change work,
it get the psoc operation and completes the work.
Since, there are multiple places where host driver is waiting
for country change event in different threads, there is a
possibility that these waits happens in parallel threads.
To complete these all waits, use qdf_event_set_all API instead
of qdf_event_set API to complete the work.

Change-Id: I94c980712f771a4113b83f4a4781072620f68fd1
CRs-Fixed: 3577595

core/hdd/src/wlan_hdd_ioctl.c

@@ -2646,11 +2646,11 @@ static int drv_cmd_set_wmmps(struct wlan_hdd_link_info *link_info,
 	return hdd_wmmps_helper(link_info->adapter, command);
 }
 
-static inline int drv_cmd_country(struct wlan_hdd_link_info *link_info,
-				  struct hdd_context *hdd_ctx,
-				  uint8_t *command,
-				  uint8_t command_len,
-				  struct hdd_priv_data *priv_data)
+static inline int __drv_cmd_country(struct wlan_hdd_link_info *link_info,
+				    struct hdd_context *hdd_ctx,
+				    uint8_t *command,
+				    uint8_t command_len,
+				    struct hdd_priv_data *priv_data)
 {
 	char *country_code;
 
@@ -2677,6 +2677,26 @@ static inline int drv_cmd_country(struct wlan_hdd_link_info *link_info,
 	return hdd_reg_set_country(hdd_ctx, country_code);
 }
 
+static inline int drv_cmd_country(struct wlan_hdd_link_info *link_info,
+				  struct hdd_context *hdd_ctx,
+				  uint8_t *command,
+				  uint8_t command_len,
+				  struct hdd_priv_data *priv_data)
+{
+	struct osif_psoc_sync *psoc_sync;
+	int errno;
+
+	errno = osif_psoc_sync_op_start(wiphy_dev(hdd_ctx->wiphy), &psoc_sync);
+	if (errno)
+		return errno;
+	errno = __drv_cmd_country(link_info, hdd_ctx, command, command_len,
+				  priv_data);
+
+	osif_psoc_sync_op_stop(psoc_sync);
+
+	return errno;
+}
+
 /**
  * drv_cmd_get_country() - Helper function to get current county code
  * @link_info: Link info pointer in HDD adapter

core/hdd/src/wlan_hdd_main.c

@@ -13640,6 +13640,8 @@ static int __hdd_psoc_idle_shutdown(struct hdd_context *hdd_ctx)
 
 	hdd_enter();
 
+	hdd_reg_wait_for_country_change(hdd_ctx);
+
 	errno = osif_psoc_sync_trans_start(hdd_ctx->parent_dev, &psoc_sync);
 	if (errno) {
 		hdd_info("psoc busy, abort idle shutdown; errno:%d", errno);

core/hdd/src/wlan_hdd_regulatory.c

@@ -896,6 +896,8 @@ int hdd_reg_set_country(struct hdd_context *hdd_ctx, char *country_code)
 		qdf_mutex_release(&hdd_ctx->regulatory_status_lock);
 	}
 
+	hdd_reg_wait_for_country_change(hdd_ctx);
+
 	return qdf_status_to_os_return(status);
 }
 
@@ -1861,7 +1863,7 @@ static void __hdd_country_change_work_handle(struct hdd_context *hdd_ctx)
 	sme_generic_change_country_code(hdd_ctx->mac_handle,
 					hdd_ctx->reg.alpha2);
 
-	qdf_event_set(&hdd_ctx->regulatory_update_event);
+	qdf_event_set_all(&hdd_ctx->regulatory_update_event);
 	qdf_mutex_acquire(&hdd_ctx->regulatory_status_lock);
 	hdd_ctx->is_regulatory_update_in_progress = false;
 	qdf_mutex_release(&hdd_ctx->regulatory_status_lock);