diff --git a/src/idc/idc.c b/src/idc/idc.c index eeb52f19b1c5..522232576bec 100644 --- a/src/idc/idc.c +++ b/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 diff --git a/src/math/power.c b/src/math/power.c index ba8071373721..fd120271d160 100644 --- a/src/math/power.c +++ b/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; diff --git a/src/schedule/dma_multi_chan_domain.c b/src/schedule/dma_multi_chan_domain.c index cf6049571f55..94321bfeffa2 100644 --- a/src/schedule/dma_multi_chan_domain.c +++ 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; } diff --git a/src/schedule/dma_single_chan_domain.c b/src/schedule/dma_single_chan_domain.c index 132930cb1a58..8218a24d78e2 100644 --- a/src/schedule/dma_single_chan_domain.c +++ b/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; } diff --git a/src/schedule/ll_schedule.c b/src/schedule/ll_schedule.c index cadf46d7ef0c..10615045d4d2 100644 --- a/src/schedule/ll_schedule.c +++ b/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); diff --git a/src/schedule/schedule.c b/src/schedule/schedule.c index 48beb889ec61..5e56b6c490e0 100644 --- a/src/schedule/schedule.c +++ b/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); diff --git a/src/schedule/zephyr_dma_domain.c b/src/schedule/zephyr_dma_domain.c index 1e05833c157f..6a9e0acaf2b6 100644 --- a/src/schedule/zephyr_dma_domain.c +++ b/src/schedule/zephyr_dma_domain.c @@ -120,7 +120,7 @@ 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; } @@ -128,7 +128,7 @@ struct ll_schedule_domain *zephyr_dma_domain_init(struct dma *dma_array, 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" * diff --git a/src/schedule/zephyr_domain.c b/src/schedule/zephyr_domain.c index 04351a35b4cc..890301e9ba44 100644 --- a/src/schedule/zephyr_domain.c +++ b/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; } diff --git a/src/schedule/zephyr_dp_schedule.c b/src/schedule/zephyr_dp_schedule.c index d8b66786d34c..cbb36391b310 100644 --- a/src/schedule/zephyr_dp_schedule.c +++ b/src/schedule/zephyr_dp_schedule.c @@ -399,7 +399,7 @@ static int scheduler_dp_task_shedule(void *data, struct task *task, uint64_t sta /* pin the thread to specific core */ ret = k_thread_cpu_pin(pdata->thread_id, task->core); if (ret < 0) { - tr_err(&dp_tr, "zephyr_dp_task_init(): zephyr task pin to core failed"); + tr_err(&dp_tr, "zephyr task pin to core failed"); goto err; } @@ -499,7 +499,7 @@ int scheduler_dp_task_init(struct task **task, task_memory = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*task_memory)); if (!task_memory) { - tr_err(&dp_tr, "zephyr_dp_task_init(): memory alloc failed"); + tr_err(&dp_tr, "memory alloc failed"); return -ENOMEM; } @@ -508,7 +508,7 @@ int scheduler_dp_task_init(struct task **task, p_stack = (__sparse_force void __sparse_cache *) rballoc_align(SOF_MEM_FLAG_KERNEL, stack_size, Z_KERNEL_STACK_OBJ_ALIGN); if (!p_stack) { - tr_err(&dp_tr, "zephyr_dp_task_init(): stack alloc failed"); + tr_err(&dp_tr, "stack alloc failed"); ret = -ENOMEM; goto err; } @@ -517,7 +517,7 @@ int scheduler_dp_task_init(struct task **task, ret = schedule_task_init(&task_memory->task, uid, SOF_SCHEDULE_DP, 0, ops->run, mod, core, 0); if (ret < 0) { - tr_err(&dp_tr, "zephyr_dp_task_init(): schedule_task_init failed"); + tr_err(&dp_tr, "schedule_task_init failed"); goto err; } diff --git a/src/schedule/zephyr_ll.c b/src/schedule/zephyr_ll.c index a0c3643eae84..851fd9a96a98 100644 --- a/src/schedule/zephyr_ll.c +++ b/src/schedule/zephyr_ll.c @@ -342,7 +342,7 @@ static int zephyr_ll_task_schedule_common(struct zephyr_ll *sch, struct task *ta ret = domain_register(sch->ll_domain, task, &schedule_ll_callback, sch); if (ret < 0) - tr_err(&ll_tr, "zephyr_ll_task_schedule: cannot register domain %d", + tr_err(&ll_tr, "cannot register domain %d", ret); return 0; @@ -386,8 +386,7 @@ static int zephyr_ll_task_free(void *data, struct task *task) zephyr_ll_assert_core(sch); if (k_is_in_isr()) { - tr_err(&ll_tr, - "zephyr_ll_task_free: cannot free tasks from interrupt context!"); + tr_err(&ll_tr, "cannot free tasks from interrupt context!"); return -EDEADLK; } @@ -481,7 +480,7 @@ static void zephyr_ll_scheduler_free(void *data, uint32_t flags) zephyr_ll_assert_core(sch); if (sch->n_tasks) - tr_err(&ll_tr, "zephyr_ll_scheduler_free: %u tasks are still active!", + tr_err(&ll_tr, "%u tasks are still active!", sch->n_tasks); } @@ -513,7 +512,7 @@ int zephyr_ll_task_init(struct task *task, pdata = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*pdata)); if (!pdata) { - tr_err(&ll_tr, "zephyr_ll_task_init(): alloc failed"); + tr_err(&ll_tr, "alloc failed"); return -ENOMEM; } @@ -534,7 +533,7 @@ int zephyr_ll_scheduler_init(struct ll_schedule_domain *domain) /* initialize per-core scheduler private data */ sch = rzalloc(SOF_MEM_FLAG_KERNEL, sizeof(*sch)); if (!sch) { - tr_err(&ll_tr, "zephyr_ll_scheduler_init(): allocation failed"); + tr_err(&ll_tr, "allocation failed"); return -ENOMEM; } list_init(&sch->tasks); diff --git a/src/schedule/zephyr_twb_schedule.c b/src/schedule/zephyr_twb_schedule.c index 011c0df1091b..8ba28595cfa3 100644 --- a/src/schedule/zephyr_twb_schedule.c +++ b/src/schedule/zephyr_twb_schedule.c @@ -395,7 +395,7 @@ int scheduler_twb_task_init(struct task **task, twb_sch = scheduler_get_data(SOF_SCHEDULE_TWB); if (!twb_sch) { - tr_err(&twb_tr, "scheduler_twb_task_init(): TWB not initialized"); + tr_err(&twb_tr, "TWB not initialized"); return -EINVAL; } @@ -403,7 +403,7 @@ int scheduler_twb_task_init(struct task **task, assert(cpu_get_id() == core); if (thread_priority < 0) { - tr_err(&twb_tr, "scheduler_twb_task_init(): non preemptible priority"); + tr_err(&twb_tr, "non preemptible priority"); return -EINVAL; } @@ -417,7 +417,7 @@ int scheduler_twb_task_init(struct task **task, task_memory = rzalloc(SOF_MEM_FLAG_KERNEL | SOF_MEM_FLAG_COHERENT, sizeof(*task_memory)); if (!task_memory) { - tr_err(&twb_tr, "scheduler_twb_task_init(): memory alloc failed"); + tr_err(&twb_tr, "memory alloc failed"); return -ENOMEM; } @@ -426,7 +426,7 @@ int scheduler_twb_task_init(struct task **task, p_stack = (__sparse_force void __sparse_cache *) rballoc_align(SOF_MEM_FLAG_KERNEL, stack_size, Z_KERNEL_STACK_OBJ_ALIGN); if (!p_stack) { - tr_err(&twb_tr, "scheduler_twb_task_init(): stack alloc failed"); + tr_err(&twb_tr, "stack alloc failed"); ret = -ENOMEM; goto err; } @@ -437,7 +437,7 @@ int scheduler_twb_task_init(struct task **task, thread_priority, K_USER, K_FOREVER); if (!thread_id) { ret = -EFAULT; - tr_err(&twb_tr, "scheduler_twb_task_init(): zephyr thread create failed"); + tr_err(&twb_tr, "zephyr thread create failed"); goto err; } @@ -445,7 +445,7 @@ int scheduler_twb_task_init(struct task **task, ret = k_thread_cpu_pin(thread_id, core); if (ret < 0) { ret = -EFAULT; - tr_err(&twb_tr, "scheduler_twb_task_init(): zephyr task pin to core %d failed", core); + tr_err(&twb_tr, "zephyr task pin to core %d failed", core); goto err; } @@ -453,14 +453,14 @@ int scheduler_twb_task_init(struct task **task, if (name) { ret = k_thread_name_set(thread_id, name); if (ret < 0) - tr_warn(&twb_tr, "scheduler_twb_task_init(): failed to set thread name"); + tr_warn(&twb_tr, "failed to set thread name"); } /* internal SOF task init */ ret = schedule_task_init(&task_memory->task, uid, SOF_SCHEDULE_TWB, thread_priority, ops->run, data, core, 0); if (ret < 0) { - tr_err(&twb_tr, "scheduler_twb_task_init(): schedule_task_init failed"); + tr_err(&twb_tr, "schedule_task_init failed"); goto err; }