Remove function names from logging calls in src/schedule, src/math, src/init, src/idc

Co-authored-by: lyakh <1363683+lyakh@users.noreply.github.com>

Author: Copilot

src/idc/idc.c

@@ -343,7 +343,7 @@ static void idc_process_async_msg(uint32_t slot)
 #if CONFIG_AMS
 	process_incoming_message(slot);
 #else
-	tr_err(&idc_tr, "idc_cmd(): AMS not enabled");
+	tr_err(&idc_tr, "AMS not enabled");
 #endif
 }
 
@@ -430,7 +430,7 @@ void idc_cmd(struct idc_msg *msg)
 		idc_process_async_msg(IDC_HEADER_TO_AMS_SLOT_MASK(msg->header));
 		break;
 	default:
-		tr_err(&idc_tr, "idc_cmd(): invalid msg->header = %u",
+		tr_err(&idc_tr, "invalid msg->header = %u",
 		       msg->header);
 	}
 
@@ -442,7 +442,7 @@ int idc_init(void)
 {
 	struct idc **idc = idc_get();
 
-	tr_dbg(&idc_tr, "idc_init()");
+	tr_dbg(&idc_tr, "");
 
 	/* initialize idc data */
 	(*idc)->payload = platform_shared_get(static_payload, sizeof(static_payload));
@@ -469,7 +469,7 @@ int idc_restore(void)
 {
 	struct idc **idc __unused = idc_get();
 
-	tr_info(&idc_tr, "idc_restore()");
+	tr_info(&idc_tr, "");
 
 	/* idc_restore() is invoked during D0->D0ix/D0ix->D0 flow. In that
 	 * case basic core structures e.g. idc struct should be already

src/math/power.c

@@ -56,7 +56,7 @@ int32_t power_int32(int32_t b, int32_t e)
 			multiplier = (int32_t)((1LL << 50) / (int64_t)b);
 		} else {
 			multiplier = INT32_MAX;
-			tr_err(&math_power_tr, "power_int32(): Divide by zero error.");
+			tr_err(&math_power_tr, "Divide by zero error.");
 		}
 	} else {
 		multiplier = b;

src/schedule/dma_multi_chan_domain.c

@@ -86,7 +86,7 @@ static int dma_multi_chan_domain_irq_register(struct dma_domain_data *data,
 {
 	int ret;
 
-	tr_info(&ll_tr, "dma_multi_chan_domain_irq_register()");
+	tr_info(&ll_tr, "");
 
 	/* always go through dma_multi_chan_domain_irq_handler,
 	 * so we have different arg registered for every channel
@@ -125,7 +125,7 @@ static int dma_multi_chan_domain_register(struct ll_schedule_domain *domain,
 	int i;
 	int j;
 
-	tr_info(&ll_tr, "dma_multi_chan_domain_register()");
+	tr_info(&ll_tr, "");
 
 	/* check if task should be registered */
 	if (!pipe_task->registrable)
@@ -192,7 +192,7 @@ static int dma_multi_chan_domain_register(struct ll_schedule_domain *domain,
  */
 static void dma_multi_chan_domain_irq_unregister(struct dma_domain_data *data)
 {
-	tr_info(&ll_tr, "dma_multi_chan_domain_irq_unregister()");
+	tr_info(&ll_tr, "");
 
 	interrupt_disable(data->irq, data);
 
@@ -217,7 +217,7 @@ static int dma_multi_chan_domain_unregister(struct ll_schedule_domain *domain,
 	int i;
 	int j;
 
-	tr_info(&ll_tr, "dma_multi_chan_domain_unregister()");
+	tr_info(&ll_tr, "");
 
 	/* check if task should be unregistered */
 	if (!task || !pipe_task->registrable)
@@ -365,19 +365,19 @@ struct ll_schedule_domain *dma_multi_chan_domain_init(struct dma *dma_array,
 	int i;
 	int j;
 
-	tr_info(&ll_tr, "dma_multi_chan_domain_init(): num_dma %d, clk %d, aggregated_irq %d",
+	tr_info(&ll_tr, "num_dma %d, clk %d, aggregated_irq %d",
 		num_dma, clk, aggregated_irq);
 
 	domain = domain_init(SOF_SCHEDULE_LL_DMA, clk, true,
 			     &dma_multi_chan_domain_ops);
 	if (!domain) {
-		tr_err(&ll_tr, "dma_multi_chan_domain_init(): domain init failed");
+		tr_err(&ll_tr, "domain init failed");
 		return NULL;
 	}
 
 	dma_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*dma_domain));
 	if (!dma_domain) {
-		tr_err(&ll_tr, "dma_multi_chan_domain_init(): allocation failed");
+		tr_err(&ll_tr, "allocation failed");
 		rfree(domain);
 		return NULL;
 	}

src/schedule/dma_single_chan_domain.c

@@ -101,7 +101,7 @@ static struct dma_chan_data *dma_chan_min_period(struct dma_domain *dma_domain)
  */
 static void dma_domain_notify_change(struct dma_chan_data *channel)
 {
-	tr_info(&ll_tr, "dma_domain_notify_change()");
+	tr_info(&ll_tr, "");
 
 	notifier_event(channel, NOTIFIER_ID_DMA_DOMAIN_CHANGE,
 		       NOTIFIER_TARGET_CORE_ALL_MASK & ~BIT(cpu_get_id()),
@@ -124,7 +124,7 @@ static int dma_single_chan_domain_irq_register(struct dma_chan_data *channel,
 	int irq = dma_chan_irq(channel->dma, channel->index);
 	int ret;
 
-	tr_info(&ll_tr, "dma_single_chan_domain_irq_register()");
+	tr_info(&ll_tr, "");
 
 	data->irq = interrupt_get_irq(irq, dma_irq_name(channel->dma));
 	if (data->irq < 0) {
@@ -154,7 +154,7 @@ static int dma_single_chan_domain_irq_register(struct dma_chan_data *channel,
  */
 static void dma_single_chan_domain_irq_unregister(struct dma_domain_data *data)
 {
-	tr_info(&ll_tr, "dma_single_chan_domain_irq_unregister()");
+	tr_info(&ll_tr, "");
 
 	interrupt_disable(data->irq, data->arg);
 	interrupt_unregister(data->irq, data->arg);
@@ -188,7 +188,7 @@ static int dma_single_chan_domain_register(struct ll_schedule_domain *domain,
 	bool register_needed = true;
 	int ret = 0;
 
-	tr_info(&ll_tr, "dma_single_chan_domain_register()");
+	tr_info(&ll_tr, "");
 
 	/* check if task should be registered */
 	if (!pipe_task->registrable)
@@ -206,7 +206,7 @@ static int dma_single_chan_domain_register(struct ll_schedule_domain *domain,
 		if (data->channel->period == channel->period)
 			goto out;
 
-		tr_info(&ll_tr, "dma_single_chan_domain_register(): lower period detected, registering again");
+		tr_info(&ll_tr, "lower period detected, registering again");
 
 		/* unregister from current channel */
 		dma_single_chan_domain_irq_unregister(data);
@@ -221,11 +221,11 @@ static int dma_single_chan_domain_register(struct ll_schedule_domain *domain,
 
 	if (channel->period <= UINT_MAX)
 		tr_info(&ll_tr,
-			"dma_single_chan_domain_register(): registering on channel with period %u",
+			"registering on channel with period %u",
 			(unsigned int)channel->period);
 	else
 		tr_info(&ll_tr,
-			"dma_single_chan_domain_register(): registering on channel with period > %u",
+			"registering on channel with period > %u",
 			UINT_MAX);
 
 	/* register for interrupt */
@@ -308,7 +308,7 @@ static void dma_domain_unregister_owner(struct ll_schedule_domain *domain,
 	struct dma *dmas = dma_domain->dma_array;
 	struct dma_chan_data *channel;
 
-	tr_info(&ll_tr, "dma_domain_unregister_owner()");
+	tr_info(&ll_tr, "");
 
 	/* transfers still scheduled on this channel */
 	if (data->channel->status == COMP_STATE_ACTIVE)
@@ -317,7 +317,7 @@ static void dma_domain_unregister_owner(struct ll_schedule_domain *domain,
 	channel = dma_chan_min_period(dma_domain);
 	if (channel && dma_chan_is_any_running(dmas, dma_domain->num_dma)) {
 		/* another channel is running */
-		tr_info(&ll_tr, "dma_domain_unregister_owner(): domain in use, change owner");
+		tr_info(&ll_tr, "domain in use, change owner");
 
 		/* change owner */
 		dma_domain->owner = channel->core;
@@ -369,7 +369,7 @@ static int dma_single_chan_domain_unregister(struct ll_schedule_domain *domain,
 	int core = cpu_get_id();
 	struct dma_domain_data *data = &dma_domain->data[core];
 
-	tr_info(&ll_tr, "dma_single_chan_domain_unregister()");
+	tr_info(&ll_tr, "");
 
 	/* check if task should be unregistered */
 	if (!task || !pipe_task->registrable)
@@ -505,7 +505,7 @@ static void dma_domain_changed(void *arg, enum notify_id type, void *data)
 	int core = cpu_get_id();
 	struct dma_domain_data *domain_data = &dma_domain->data[core];
 
-	tr_info(&ll_tr, "dma_domain_changed()");
+	tr_info(&ll_tr, "");
 
 	/* unregister from current DMA channel */
 	dma_single_chan_domain_irq_unregister(domain_data);
@@ -538,19 +538,19 @@ struct ll_schedule_domain *dma_single_chan_domain_init(struct dma *dma_array,
 	struct ll_schedule_domain *domain;
 	struct dma_domain *dma_domain;
 
-	tr_info(&ll_tr, "dma_single_chan_domain_init(): num_dma %d, clk %d",
+	tr_info(&ll_tr, "num_dma %d, clk %d",
 		num_dma, clk);
 
 	domain = domain_init(SOF_SCHEDULE_LL_DMA, clk, false,
 			     &dma_single_chan_domain_ops);
 	if (!domain) {
-		tr_err(&ll_tr, "dma_single_chan_domain_init(): domain init failed");
+		tr_err(&ll_tr, "domain init failed");
 		return NULL;
 	}
 
 	dma_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*dma_domain));
 	if (!dma_domain) {
-		tr_err(&ll_tr, "dma_single_chan_domain_init(): allocation failed");
+		tr_err(&ll_tr, "allocation failed");
 		rfree(domain);
 		return NULL;
 	}

src/schedule/ll_schedule.c

@@ -365,7 +365,7 @@ static int schedule_ll_domain_set(struct ll_schedule_data *sch,
 
 	ret = domain_register(domain, task, &schedule_ll_tasks_run, sch);
 	if (ret < 0) {
-		tr_err(&ll_tr, "schedule_ll_domain_set: cannot register domain %d",
+		tr_err(&ll_tr, "cannot register domain %d",
 		       ret);
 		goto done;
 	}
@@ -548,7 +548,7 @@ static int schedule_ll_task_common(struct ll_schedule_data *sch, struct task *ta
 				 */
 				if (pdata->period < reg_pdata->period) {
 					tr_err(&ll_tr,
-					       "schedule_ll_task(): registrable task has a period longer than current task");
+					       "registrable task has a period longer than current task");
 					ret = -EINVAL;
 					goto out;
 				}
@@ -625,7 +625,7 @@ int schedule_task_init_ll(struct task *task,
 			   sizeof(*ll_pdata));
 
 	if (!ll_pdata) {
-		tr_err(&ll_tr, "schedule_task_init_ll(): alloc failed");
+		tr_err(&ll_tr, "alloc failed");
 		return -ENOMEM;
 	}
 
@@ -714,7 +714,7 @@ static int reschedule_ll_task(void *data, struct task *task, uint64_t start)
 		}
 	}
 
-	tr_err(&ll_tr, "reschedule_ll_task(): task not found");
+	tr_err(&ll_tr, "task not found");
 
 out:
 
@@ -783,7 +783,7 @@ int scheduler_init_ll(struct ll_schedule_domain *domain)
 	/* initialize scheduler private data */
 	sch = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*sch));
 	if (!sch) {
-		tr_err(&ll_tr, "scheduler_init_ll(): allocation failed");
+		tr_err(&ll_tr, "allocation failed");
 		return -ENOMEM;
 	}
 	list_init(&sch->tasks);

src/schedule/schedule.c

@@ -28,7 +28,7 @@ int schedule_task_init(struct task *task,
 		       void *data, uint16_t core, uint32_t flags)
 {
 	if (type >= SOF_SCHEDULE_COUNT) {
-		tr_err(&sch_tr, "schedule_task_init(): invalid task type");
+		tr_err(&sch_tr, "invalid task type");
 		return -EINVAL;
 	}
 
@@ -53,7 +53,7 @@ static void scheduler_register(struct schedule_data *scheduler)
 		*sch = rzalloc(SOF_MEM_FLAG_KERNEL,
 			       sizeof(**sch));
 		if (!*sch) {
-			tr_err(&sch_tr, "scheduler_register(): allocation failed");
+			tr_err(&sch_tr, "allocation failed");
 			return;
 		}
 		list_init(&(*sch)->list);
@@ -72,7 +72,7 @@ void scheduler_init(int type, const struct scheduler_ops *ops, void *data)
 
 	sch = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*sch));
 	if (!sch) {
-		tr_err(&sch_tr, "scheduler_init(): allocation failed");
+		tr_err(&sch_tr, "allocation failed");
 		sof_panic(SOF_IPC_PANIC_IPC);
 	}
 	list_init(&sch->list);

src/schedule/zephyr_dma_domain.c

@@ -120,15 +120,15 @@ struct ll_schedule_domain *zephyr_dma_domain_init(struct dma *dma_array,
 			     true,
 			     &zephyr_dma_domain_ops);
 	if (!domain) {
-		tr_err(&ll_tr, "zephyr_dma_domain_init(): domain init failed");
+		tr_err(&ll_tr, "domain init failed");
 		return NULL;
 	}
 
 	/* initialize domain pdata */
 	zephyr_dma_domain = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
 				    sizeof(*zephyr_dma_domain));
 	if (!zephyr_dma_domain) {
-		tr_err(&ll_tr, "zephyr_dma_domain_init(): allocation failed");
+		tr_err(&ll_tr, "allocation failed");
 		rfree(domain);
 		return NULL;
 	}
@@ -388,7 +388,7 @@ static int zephyr_dma_domain_register(struct ll_schedule_domain *domain,
 	dt = zephyr_dma_domain->domain_thread + core;
 	pipe_task = pipeline_task_get(task);
 
-	tr_info(&ll_tr, "zephyr_dma_domain_register()");
+	tr_info(&ll_tr, "");
 
 	/* don't even bother trying to register DMA IRQ for
 	 * non-registrable tasks.
@@ -561,7 +561,7 @@ static int zephyr_dma_domain_unregister(struct ll_schedule_domain *domain,
 	core = cpu_get_id();
 	dt = zephyr_dma_domain->domain_thread + core;
 
-	tr_info(&ll_tr, "zephyr_dma_domain_unregister()");
+	tr_info(&ll_tr, "");
 
 	/* unregister the DMA IRQ only for PPL tasks marked as "registrable"
 	 *

src/schedule/zephyr_domain.c

@@ -178,7 +178,7 @@ static int zephyr_domain_register(struct ll_schedule_domain *domain,
 	k_tid_t thread;
 	k_spinlock_key_t key;
 
-	tr_dbg(&ll_tr, "zephyr_domain_register()");
+	tr_dbg(&ll_tr, "");
 
 	/* domain work only needs registered once on each core */
 	if (dt->handler)
@@ -233,7 +233,7 @@ static int zephyr_domain_unregister(struct ll_schedule_domain *domain,
 	int core = cpu_get_id();
 	k_spinlock_key_t key;
 
-	tr_dbg(&ll_tr, "zephyr_domain_unregister()");
+	tr_dbg(&ll_tr, "");
 
 	/* tasks still registered on this core */
 	if (num_tasks)
@@ -307,14 +307,14 @@ struct ll_schedule_domain *zephyr_domain_init(int clk)
 	domain = domain_init(SOF_SCHEDULE_LL_TIMER, clk, false,
 			     &zephyr_domain_ops);
 	if (!domain) {
-		tr_err(&ll_tr, "zephyr_domain_init: domain init failed");
+		tr_err(&ll_tr, "domain init failed");
 		return NULL;
 	}
 
 	zephyr_domain = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT,
 				sizeof(*zephyr_domain));
 	if (!zephyr_domain) {
-		tr_err(&ll_tr, "zephyr_domain_init: domain allocation failed");
+		tr_err(&ll_tr, "domain allocation failed");
 		rfree(domain);
 		return NULL;
 	}