rpmsg: adi: reduce amount of changes

Author: artursartamonovsadi

drivers/remoteproc/adi_remoteproc.c

@@ -138,10 +138,10 @@ static struct adi_sharc_resource_table _rsc_table_template = {
 	},
 };
 
-enum adi_rproc_rproc_state {
-	ADI_REMOTEPROC_SYNCED = 0,
-	ADI_REMOTEPROC_WAITING = 1,
-	ADI_REMOTEPROC_TIMED_OUT = 2,
+enum adi_rproc_rpmsg_state {
+	ADI_RP_RPMSG_SYNCED = 0,
+	ADI_RP_RPMSG_WAITING = 1,
+	ADI_RP_RPMSG_TIMED_OUT = 2,
 };
 
 struct adi_rproc_data {
@@ -162,7 +162,7 @@ struct adi_rproc_data {
 	void __iomem *L1_shared_base;
 	void __iomem *L2_shared_base;
 	struct workqueue_struct *core_workqueue;
-	enum adi_rproc_rproc_state rproc_state;
+	enum adi_rproc_rpmsg_state rpmsg_state;
 	u64 l1_da_range[2];
 	u64 l2_da_range[2];
 	u32 verify;
@@ -176,21 +176,15 @@ struct adi_rproc_data {
 static int adi_core_set_svect(struct adi_rproc_data *rproc_data,
 					unsigned long svect)
 {
-	uint32_t core_id = !!svect * rproc_data->core_id;
-
-	switch (core_id) {
-	case 1:
-		adi_rcu_writel(svect, rproc_data->rcu,
-				ADI_RCU_REG_SVECT1);
-		break;
-	case 2:
-		adi_rcu_writel(svect, rproc_data->rcu,
-				ADI_RCU_REG_SVECT2);
-		break;
-	default:
-		dev_err(rproc_data->dev,
-			"%s, invalid svect:0x%lx, cord_id:%d\n",
-			__func__, svect, core_id);
+	int coreid = rproc_data->core_id;
+
+	if (svect && (coreid == 1))
+		adi_rcu_writel(svect, rproc_data->rcu, ADI_RCU_REG_SVECT1);
+	else if (svect && (coreid == 2))
+		adi_rcu_writel(svect, rproc_data->rcu, ADI_RCU_REG_SVECT2);
+	else {
+		dev_err(rproc_data->dev, "%s, invalid svect:0x%lx, cord_id:%d\n",
+						__func__, svect, coreid);
 		return -EINVAL;
 	}
 
@@ -203,19 +197,19 @@ static int adi_core_start(struct adi_rproc_data *rproc_data)
 {
 	int ret = 0;
 
-	if (!rproc_data->adi_rsc_table) {
-		dev_err(rproc_data->dev,
-				"Could not start core, no resource table\n");
+	if (rproc_data->adi_rsc_table != NULL) {
+		rproc_data->rpmsg_state = ADI_RP_RPMSG_WAITING;
+		ret = devm_request_threaded_irq(rproc_data->dev,
+						rproc_data->icc_irq, NULL,
+						sharc_virtio_irq_threaded_handler,
+						rproc_data->icc_irq_flags,
+						"ICC virtio IRQ", rproc_data);
+	}
+	if (ret) {
+		dev_err(rproc_data->dev, "Fail to request ICC IRQ\n");
 		return -ENOENT;
 	}
 
-	rproc_data->rproc_state = ADI_REMOTEPROC_WAITING;
-	ret = devm_request_threaded_irq(rproc_data->dev,
-					rproc_data->icc_irq, NULL,
-					sharc_virtio_irq_threaded_handler,
-					rproc_data->icc_irq_flags,
-					"ICC virtio IRQ", rproc_data);
-
 	return adi_rcu_start_core(rproc_data->rcu, rproc_data->core_id);
 }
 
@@ -227,11 +221,10 @@ static int adi_core_reset(struct adi_rproc_data *rproc_data)
 static int adi_core_stop(struct adi_rproc_data *rproc_data)
 {
 	/* After time out the irq is already released */
-	if (rproc_data->rproc_state == ADI_REMOTEPROC_TIMED_OUT)
-		goto adi_stop_ret;
-
-	devm_free_irq(rproc_data->dev, rproc_data->icc_irq, rproc_data);
-adi_stop_ret:
+	if (rproc_data->adi_rsc_table != NULL) {
+		if (rproc_data->rpmsg_state != ADI_RP_RPMSG_TIMED_OUT)
+			devm_free_irq(rproc_data->dev, rproc_data->icc_irq, rproc_data);
+	}
 	return adi_rcu_stop_core(rproc_data->rcu,
 				 rproc_data->core_id, rproc_data->core_irq);
 }
@@ -258,15 +251,14 @@ static void load_callback(void *p)
 	complete(cmp);
 }
 
- /*
-  * We validate if the current and next header checksum are valid based
-  * on the current header block. This way we validate the current block
-  * header integrity and validity of the block size with respect to the stream.
-  *
-  * In case of Direct Code Execution and Single block boot streams it is possible
-  * to verify the block header via an xor checksum of the bcode_flag field.
-  */
-
+/*
+ * We validate if the current and next header checksum are valid based
+ * on the current header block. This way we validate the current block
+ * header integrity and validity of the block size with respect to the stream.
+ *
+ * In case of Direct Code Execution and Single block boot streams it is possible
+ * to verify the block header via an xor checksum of the bcode_flag field.
+ */
 static int adi_verify_ldr_hdr(struct adi_rproc_data *rproc_data,
 		struct ldr_hdr *block_hdr)
 {
@@ -317,7 +309,6 @@ static int adi_verify_ldr_hdr(struct adi_rproc_data *rproc_data,
 					curr_hdr_xor_checksum);
 			return -EINVAL;
 		}
-
 	}
 
 	/* Check if size offset leads to next header, unless final (should have
@@ -442,14 +433,12 @@ static int ldr_load(struct adi_rproc_data *rproc_data)
 			if (rproc_data->verify)
 				dev_info(rproc_data->dev,
 						"Verified and loaded ldr\n");
-
 			return 0;
 		}
 
 	}
 
 	return 0;
-
 }
 
 static int adi_valid_firmware(struct rproc *rproc, const struct firmware *fw)
@@ -488,7 +477,7 @@ static int adi_ldr_load(struct adi_rproc_data *rproc_data,
 						const struct firmware *fw)
 {
 	rproc_data->fw_size = fw->size;
-	if (!rproc_data->mem_virt) {
+	if (rproc_data->mem_virt == NULL) {
 		rproc_data->mem_virt = dma_alloc_coherent(rproc_data->dev,
 							  fw->size * MEMORY_COUNT,
 							  &rproc_data->mem_handle,
@@ -830,43 +819,30 @@ static irqreturn_t sharc_virtio_irq_threaded_handler(int irq, void *p)
 /* kick a virtqueue */
 static void adi_rproc_kick(struct rproc *rproc, int vqid)
 {
-	struct adi_rproc_data *rproc_data;
-	struct adi_resource_table_hdr *hdr;
-	uint32_t core_init = 0;
+	struct adi_rproc_data *rproc_data = (struct adi_rproc_data *)rproc->priv;
 	int wait_time;
 
-	rproc_data = (struct adi_rproc_data *)rproc->priv;
 	/* On first kick check if remote core has done its initialization */
-	if (rproc_data->rproc_state != ADI_REMOTEPROC_WAITING) {
-		if (rproc_data->rproc_state == ADI_REMOTEPROC_SYNCED)
-			adi_tru_trigger_device(rproc_data->tru, rproc_data->dev);
-
-		return;
-	}
-
-	hdr = &rproc_data->adi_rsc_table->adi_table_hdr;
-	core_init = hdr->initialized;
-	for (wait_time = 0; wait_time < CORE_INIT_TIMEOUT_MS; wait_time += 20) {
-		core_init = hdr->initialized;
-		if (core_init == ADI_RSC_TABLE_INIT_MAGIC) {
-			rproc_data->rproc_state = ADI_REMOTEPROC_SYNCED;
-			break;
+	if (rproc_data->rpmsg_state == ADI_RP_RPMSG_WAITING) {
+		for (wait_time = 0; wait_time < CORE_INIT_TIMEOUT_MS; wait_time += 20) {
+			if (rproc_data->adi_rsc_table->adi_table_hdr.initialized ==
+			    ADI_RSC_TABLE_INIT_MAGIC) {
+				rproc_data->rpmsg_state = ADI_RP_RPMSG_SYNCED;
+				break;
+			}
+			msleep(20);
+		}
+		if (rproc_data->rpmsg_state != ADI_RP_RPMSG_SYNCED) {
+			rproc_data->rpmsg_state = ADI_RP_RPMSG_TIMED_OUT;
+			devm_free_irq(rproc_data->dev, rproc_data->icc_irq, rproc_data);
+			dev_info(rproc_data->dev,
+					 "Core%d rpmsg init timeout, probably not supported.\n",
+					 rproc_data->core_id);
 		}
-
-		msleep(20);
 	}
 
-	if (rproc_data->rproc_state == ADI_REMOTEPROC_SYNCED) {
+	if (rproc_data->rpmsg_state == ADI_RP_RPMSG_SYNCED)
 		adi_tru_trigger_device(rproc_data->tru, rproc_data->dev);
-		return;
-	}
-
-	rproc_data->rproc_state = ADI_REMOTEPROC_TIMED_OUT;
-	devm_free_irq(rproc_data->dev, rproc_data->icc_irq,
-			rproc_data);
-	dev_info(rproc_data->dev,
-			 "Core%d rpmsg init timeout, probably not supported.\n",
-			 rproc_data->core_id);
 }
 
 static int adi_rproc_sanity_check(struct rproc *rproc, const struct firmware *fw)
@@ -1014,8 +990,6 @@ static int adi_remoteproc_probe(struct platform_device *pdev)
 	/* Get ADI resource table address */
 	node = of_parse_phandle(np, "adi,rsc-table", 0);
 	if (node) {
-		u32 irq_flags = 0;
-
 		dev_info(&pdev->dev, "Resource table set, enable rpmsg\n");
 		rmem = of_reserved_mem_lookup(node);
 		of_node_put(node);
@@ -1042,8 +1016,7 @@ static int adi_remoteproc_probe(struct platform_device *pdev)
 			goto free_adi_rcu;
 		}
 
-		irq_flags = IRQF_PERCPU | IRQF_SHARED | IRQF_ONESHOT;
-		rproc_data->icc_irq_flags = irq_flags;
+		rproc_data->icc_irq_flags = IRQF_PERCPU | IRQF_SHARED | IRQF_ONESHOT;
 	} else {
 		rproc_data->adi_rsc_table = NULL;
 	}
@@ -1106,7 +1079,7 @@ static int adi_remoteproc_probe(struct platform_device *pdev)
 	rproc_data->mem_virt = NULL;
 	rproc_data->fw_size = 0;
 	rproc_data->ldr_load_addr = SHARC_IDLE_ADDR; //start core as idle
-	rproc_data->rproc_state = ADI_REMOTEPROC_TIMED_OUT;
+	rproc_data->rpmsg_state = ADI_RP_RPMSG_TIMED_OUT;
 
 	ret = rproc_add(rproc);
 	if (ret) {