retval = sdw_stream_add_slave(rt1316->sdw_slave, &stream_config,
                                &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
        if (rt1316->bq_params_cnt) {
                rt1316->bq_params = devm_kzalloc(dev, rt1316->bq_params_cnt, GFP_KERNEL);
                if (!rt1316->bq_params) {
-                       dev_err(dev, "Could not allocate bq_params memory\n");
+                       dev_err(dev, "%s: Could not allocate bq_params memory\n", __func__);
                        ret = -ENOMEM;
                } else {
                        ret = device_property_read_u8_array(dev, "realtek,bq-params", rt1316->bq_params, rt1316->bq_params_cnt);
                        if (ret < 0)
-                               dev_err(dev, "Could not read list of realtek,bq-params\n");
+                               dev_err(dev, "%s: Could not read list of realtek,bq-params\n", __func__);
                }
        }
 
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT1316_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
        retval = sdw_stream_add_slave(rt1318->sdw_slave, &stream_config,
                                &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
                sampling_rate = RT1318_SDCA_RATE_192000HZ;
                break;
        default:
-               dev_err(component->dev, "Rate %d is not supported\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Rate %d is not supported\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT1318_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                return -ETIMEDOUT;
        }
 
 
        retval = sdw_stream_add_slave(rt5682->slave, &stream_config,
                                      &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
                                          &rt5682_sdw_indirect_regmap);
        if (IS_ERR(rt5682->regmap)) {
                ret = PTR_ERR(rt5682->regmap);
-               dev_err(dev, "Failed to allocate register map: %d\n",
-                       ret);
+               dev_err(dev, "%s: Failed to allocate register map: %d\n",
+                       __func__, ret);
                return ret;
        }
 
        }
 
        if (val != DEVICE_ID) {
-               dev_err(dev, "Device with ID register %x is not rt5682\n", val);
+               dev_err(dev, "%s: Device with ID register %x is not rt5682\n", __func__, val);
                ret = -ENODEV;
                goto err_nodev;
        }
 
        ret = rt5682_clock_config(&slave->dev);
        if (ret < 0)
-               dev_err(&slave->dev, "Invalid clk config");
+               dev_err(&slave->dev, "%s: Invalid clk config", __func__);
 
        return ret;
 }
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT5682_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+               pr_err("%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                      __func__, addr, value, ret);
 
        return ret;
 }
        *value = 0;
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+               pr_err("%s: Failed to get private value: %06x => %04x ret=%d\n",
+                      __func__, addr, *value, ret);
 
        return ret;
 }
                port_config.num += 2;
                break;
        default:
-               dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
+               dev_err(component->dev, "%s: Invalid DAI id %d\n", __func__, dai->id);
                return -EINVAL;
        }
 
        retval = sdw_stream_add_slave(rt700->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
                /* bit 3:0 Number of Channel */
                val |= (params_channels(params) - 1);
        } else {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
 
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT711_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt711->slave->dev,
-                       "Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+                       "%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                       __func__, addr, value, ret);
 
        return ret;
 }
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt711->slave->dev,
-                       "Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+                       "%s: Failed to get private value: %06x => %04x ret=%d\n",
+                       __func__, addr, *value, ret);
 
        return ret;
 }
        retval = sdw_stream_add_slave(rt711->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
        if (params_channels(params) > 16) {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
                sampling_rate = RT711_SDCA_RATE_192000HZ;
                break;
        default:
-               dev_err(component->dev, "Rate %d is not supported\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Rate %d is not supported\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
 
 
        ret = rt711_clock_config(&slave->dev);
        if (ret < 0)
-               dev_err(&slave->dev, "Invalid clk config");
+               dev_err(&slave->dev, "%s: Invalid clk config", __func__);
 
        return ret;
 }
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT711_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                return -ETIMEDOUT;
        }
 
 
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+               pr_err("%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                      __func__, addr, value, ret);
 
        return ret;
 }
        *value = 0;
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+               pr_err("%s: Failed to get private value: %06x => %04x ret=%d\n",
+                      __func__, addr, *value, ret);
 
        return ret;
 }
                                RT711_HP_JD_FINAL_RESULT_CTL_JD12);
                        break;
                default:
-                       dev_warn(rt711->component->dev, "Wrong JD source\n");
+                       dev_warn(rt711->component->dev, "%s: Wrong JD source\n", __func__);
                        break;
                }
 
        retval = sdw_stream_add_slave(rt711->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
                /* bit 3:0 Number of Channel */
                val |= (params_channels(params) - 1);
        } else {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt712->slave->dev,
-                       "Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+                       "%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                       __func__, addr, value, ret);
 
        return ret;
 }
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt712->slave->dev,
-                       "Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+                       "%s: Failed to get private value: %06x => %04x ret=%d\n",
+                       __func__, addr, *value, ret);
 
        return ret;
 }
        for (i = 0; i < p->count; i++) {
                err = regmap_write(rt712->mbq_regmap, p->reg_base + i, gain_val[i]);
                if (err < 0)
-                       dev_err(&rt712->slave->dev, "0x%08x can't be set\n", p->reg_base + i);
+                       dev_err(&rt712->slave->dev, "%s: 0x%08x can't be set\n",
+                               __func__, p->reg_base + i);
        }
 
        return changed;
        retval = sdw_stream_add_slave(rt712->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
        if (params_channels(params) > 4) {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
                sampling_rate = RT712_SDCA_RATE_192000HZ;
                break;
        default:
-               dev_err(component->dev, "Rate %d is not supported\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Rate %d is not supported\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT712_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n",
+                       __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                msecs_to_jiffies(RT712_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt712->slave->dev,
-                       "Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+                       "%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                       __func__, addr, value, ret);
 
        return ret;
 }
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt712->slave->dev,
-                       "Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+                       "%s: Failed to get private value: %06x => %04x ret=%d\n",
+                       __func__, addr, *value, ret);
 
        return ret;
 }
        retval = sdw_stream_add_slave(rt712->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
        if (params_channels(params) > 16) {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
                sampling_rate = RT712_SDCA_RATE_192000HZ;
                break;
        default:
-               dev_err(component->dev, "Rate %d is not supported\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Rate %d is not supported\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
                        sampling_rate);
                break;
        default:
-               dev_err(component->dev, "Wrong DAI id\n");
+               dev_err(component->dev, "%s: Wrong DAI id\n", __func__);
                return -EINVAL;
        }
 
 
        time = wait_for_completion_timeout(&slave->enumeration_complete,
                                           msecs_to_jiffies(RT715_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Enumeration not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Enumeration not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt715->slave->dev,
-                       "Failed to set private value: %08x <= %04x %d\n",
-                       addr, value, ret);
+                       "%s: Failed to set private value: %08x <= %04x %d\n",
+                       __func__, addr, value, ret);
 
        return ret;
 }
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt715->slave->dev,
-                               "Failed to get private value: %06x => %04x ret=%d\n",
-                               addr, *value, ret);
+                       "%s: Failed to get private value: %06x => %04x ret=%d\n",
+                       __func__, addr, *value, ret);
 
        return ret;
 }
                                mc->shift);
                ret = regmap_write(rt715->mbq_regmap, mc->reg + i, gain_val);
                if (ret != 0) {
-                       dev_err(component->dev, "Failed to write 0x%x=0x%x\n",
-                               mc->reg + i, gain_val);
+                       dev_err(component->dev, "%s: Failed to write 0x%x=0x%x\n",
+                               __func__, mc->reg + i, gain_val);
                        return ret;
                }
        }
                ret = regmap_write(rt715->mbq_regmap, reg_base + i,
                                gain_val);
                if (ret != 0) {
-                       dev_err(component->dev, "Failed to write 0x%x=0x%x\n",
-                               reg_base + i, gain_val);
+                       dev_err(component->dev, "%s: Failed to write 0x%x=0x%x\n",
+                               __func__, reg_base + i, gain_val);
                        return ret;
                }
        }
                reg = i < 7 ? reg_base + i : (reg_base - 1) | BIT(15);
                ret = regmap_write(rt715->mbq_regmap, reg, gain_val);
                if (ret != 0) {
-                       dev_err(component->dev, "Failed to write 0x%x=0x%x\n",
-                               reg, gain_val);
+                       dev_err(component->dev, "%s: Failed to write 0x%x=0x%x\n",
+                               __func__, reg, gain_val);
                        return ret;
                }
        }
        for (i = 0; i < 2; i++) {
                ret = regmap_read(rt715->mbq_regmap, mc->reg + i, &val);
                if (ret < 0) {
-                       dev_err(component->dev, "Failed to read 0x%x, ret=%d\n",
-                               mc->reg + i, ret);
+                       dev_err(component->dev, "%s: Failed to read 0x%x, ret=%d\n",
+                               __func__, mc->reg + i, ret);
                        return ret;
                }
                ucontrol->value.integer.value[i] = rt715_sdca_get_gain(val, mc->shift);
        for (i = 0; i < 4; i++) {
                ret = regmap_read(rt715->mbq_regmap, reg_base + i, &val);
                if (ret < 0) {
-                       dev_err(component->dev, "Failed to read 0x%x, ret=%d\n",
-                               reg_base + i, ret);
+                       dev_err(component->dev, "%s: Failed to read 0x%x, ret=%d\n",
+                               __func__, reg_base + i, ret);
                        return ret;
                }
                ucontrol->value.integer.value[i] = rt715_sdca_get_gain(val, gain_sft);
        for (i = 0; i < 8; i += 2) {
                ret = regmap_read(rt715->mbq_regmap, reg_base + i, &val_l);
                if (ret < 0) {
-                       dev_err(component->dev, "Failed to read 0x%x, ret=%d\n",
-                                       reg_base + i, ret);
+                       dev_err(component->dev, "%s: Failed to read 0x%x, ret=%d\n",
+                               __func__, reg_base + i, ret);
                        return ret;
                }
                ucontrol->value.integer.value[i] = (val_l >> gain_sft) / 10;
                reg = (i == 6) ? (reg_base - 1) | BIT(15) : reg_base + 1 + i;
                ret = regmap_read(rt715->mbq_regmap, reg, &val_r);
                if (ret < 0) {
-                       dev_err(component->dev, "Failed to read 0x%x, ret=%d\n",
-                                       reg, ret);
+                       dev_err(component->dev, "%s: Failed to read 0x%x, ret=%d\n",
+                               __func__, reg, ret);
                        return ret;
                }
                ucontrol->value.integer.value[i + 1] = (val_r >> gain_sft) / 10;
                        0xaf00);
                break;
        default:
-               dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
+               dev_err(component->dev, "%s: Invalid DAI id %d\n", __func__, dai->id);
                return -EINVAL;
        }
 
        retval = sdw_stream_add_slave(rt715->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(component->dev, "Unable to configure port, retval:%d\n",
-                       retval);
+               dev_err(component->dev, "%s: Unable to configure port, retval:%d\n",
+                       __func__, retval);
                return retval;
        }
 
                val = 0xf;
                break;
        default:
-               dev_err(component->dev, "Unsupported sample rate %d\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Unsupported sample rate %d\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
 
 
        ret = rt715_clock_config(&slave->dev);
        if (ret < 0)
-               dev_err(&slave->dev, "Invalid clk config");
+               dev_err(&slave->dev, "%s: Invalid clk config", __func__);
 
        return 0;
 }
        time = wait_for_completion_timeout(&slave->initialization_complete,
                                           msecs_to_jiffies(RT715_PROBE_TIMEOUT));
        if (!time) {
-               dev_err(&slave->dev, "Initialization not complete, timed out\n");
+               dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
                sdw_show_ping_status(slave->bus, true);
 
                return -ETIMEDOUT;
 
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0) {
-               pr_err("Failed to set private value: %08x <= %04x %d\n",
-                      addr, value, ret);
+               pr_err("%s: Failed to set private value: %08x <= %04x %d\n",
+                      __func__, addr, value, ret);
        }
 
        return ret;
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+               pr_err("%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                      __func__, addr, value, ret);
 
        return ret;
 }
        *value = 0;
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
-               pr_err("Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+               pr_err("%s: Failed to get private value: %06x => %04x ret=%d\n",
+                      __func__, addr, *value, ret);
 
        return ret;
 }
                rt715_index_write(rt715->regmap, RT715_SDW_INPUT_SEL, 0xa000);
                break;
        default:
-               dev_err(component->dev, "Invalid DAI id %d\n", dai->id);
+               dev_err(component->dev, "%s: Invalid DAI id %d\n", __func__, dai->id);
                return -EINVAL;
        }
 
        retval = sdw_stream_add_slave(rt715->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
                val |= 0x0 << 8;
                break;
        default:
-               dev_err(component->dev, "Unsupported sample rate %d\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Unsupported sample rate %d\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }
 
                /* bit 3:0 Number of Channel */
                val |= (params_channels(params) - 1);
        } else {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
 
        ret = regmap_write(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt722->slave->dev,
-                       "Failed to set private value: %06x <= %04x ret=%d\n",
-                       addr, value, ret);
+                       "%s: Failed to set private value: %06x <= %04x ret=%d\n",
+                       __func__, addr, value, ret);
 
        return ret;
 }
        ret = regmap_read(regmap, addr, value);
        if (ret < 0)
                dev_err(&rt722->slave->dev,
-                       "Failed to get private value: %06x => %04x ret=%d\n",
-                       addr, *value, ret);
+                       "%s: Failed to get private value: %06x => %04x ret=%d\n",
+                       __func__, addr, *value, ret);
 
        return ret;
 }
        for (i = 0; i < p->count; i++) {
                err = regmap_write(rt722->mbq_regmap, p->reg_base + i, gain_val[i]);
                if (err < 0)
-                       dev_err(&rt722->slave->dev, "%#08x can't be set\n", p->reg_base + i);
+                       dev_err(&rt722->slave->dev, "%s: %#08x can't be set\n",
+                               __func__, p->reg_base + i);
        }
 
        return changed;
        retval = sdw_stream_add_slave(rt722->slave, &stream_config,
                                        &port_config, 1, sdw_stream);
        if (retval) {
-               dev_err(dai->dev, "Unable to configure port\n");
+               dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
                return retval;
        }
 
        if (params_channels(params) > 16) {
-               dev_err(component->dev, "Unsupported channels %d\n",
-                       params_channels(params));
+               dev_err(component->dev, "%s: Unsupported channels %d\n",
+                       __func__, params_channels(params));
                return -EINVAL;
        }
 
                sampling_rate = RT722_SDCA_RATE_192000HZ;
                break;
        default:
-               dev_err(component->dev, "Rate %d is not supported\n",
-                       params_rate(params));
+               dev_err(component->dev, "%s: Rate %d is not supported\n",
+                       __func__, params_rate(params));
                return -EINVAL;
        }