else if (w->platform)
                return snd_soc_platform_read(w->platform, reg);
 
-       dev_err(w->dapm->dev, "no valid widget read method\n");
+       dev_err(w->dapm->dev, "ASoC: no valid widget read method\n");
        return -1;
 }
 
        else if (w->platform)
                return snd_soc_platform_write(w->platform, reg, val);
 
-       dev_err(w->dapm->dev, "no valid widget write method\n");
+       dev_err(w->dapm->dev, "ASoC: no valid widget write method\n");
        return -1;
 }
 
                        wlist = kzalloc(wlistsize, GFP_KERNEL);
                        if (wlist == NULL) {
                                dev_err(dapm->dev,
-                                       "asoc: can't allocate widget list for %s\n",
+                                       "ASoC: can't allocate widget list for %s\n",
                                        w->name);
                                return -ENOMEM;
                        }
                                                      prefix);
                        ret = snd_ctl_add(card, path->kcontrol);
                        if (ret < 0) {
-                               dev_err(dapm->dev,
-                                       "asoc: failed to add dapm kcontrol %s: %d\n",
-                                       path->long_name, ret);
+                               dev_err(dapm->dev, "ASoC: failed to add widget"
+                                       " %s dapm kcontrol %s: %d\n",
+                                       w->name, path->long_name, ret);
                                kfree(wlist);
                                kfree(path->long_name);
                                path->long_name = NULL;
 
        if (w->num_kcontrols != 1) {
                dev_err(dapm->dev,
-                       "asoc: mux %s has incorrect number of controls\n",
+                       "ASoC: mux %s has incorrect number of controls\n",
                        w->name);
                return -EINVAL;
        }
        wlist = krealloc(wlist, wlistsize, GFP_KERNEL);
        if (wlist == NULL) {
                dev_err(dapm->dev,
-                       "asoc: can't allocate widget list for %s\n", w->name);
+                       "ASoC: can't allocate widget list for %s\n", w->name);
                return -ENOMEM;
        }
        wlist->num_widgets = wlistentries;
                                        name + prefix_len, prefix);
                ret = snd_ctl_add(card, kcontrol);
                if (ret < 0) {
-                       dev_err(dapm->dev, "failed to add kcontrol %s: %d\n",
+                       dev_err(dapm->dev, "ASoC: failed to add kcontrol %s: %d\n",
                                w->name, ret);
                        kfree(wlist);
                        return ret;
 {
        if (w->num_kcontrols)
                dev_err(w->dapm->dev,
-                       "asoc: PGA controls not supported: '%s'\n", w->name);
+                       "ASoC: PGA controls not supported: '%s'\n", w->name);
 
        return 0;
 }
        case SNDRV_CTL_POWER_D3hot:
        case SNDRV_CTL_POWER_D3cold:
                if (widget->ignore_suspend)
-                       dev_dbg(widget->dapm->dev, "%s ignoring suspend\n",
+                       dev_dbg(widget->dapm->dev, "ASoC: %s ignoring suspend\n",
                                widget->name);
                return widget->ignore_suspend;
        default:
                        wlistentries * sizeof(struct snd_soc_dapm_widget *);
        *list = krealloc(wlist, wlistsize, GFP_KERNEL);
        if (*list == NULL) {
-               dev_err(w->dapm->dev, "can't allocate widget list for %s\n",
+               dev_err(w->dapm->dev, "ASoC: can't allocate widget list for %s\n",
                        w->name);
                return -ENOMEM;
        }
        wlist = *list;
 
        /* insert the widget */
-       dev_dbg(w->dapm->dev, "added %s in widget list pos %d\n",
+       dev_dbg(w->dapm->dev, "ASoC: added %s in widget list pos %d\n",
                        w->name, wlist->num_widgets);
 
        wlist->widgets[wlist->num_widgets] = w;
                                int err;
                                err = dapm_list_add_widget(list, path->sink);
                                if (err < 0) {
-                                       dev_err(widget->dapm->dev, "could not add widget %s\n",
+                                       dev_err(widget->dapm->dev,
+                                               "ASoC: could not add widget %s\n",
                                                widget->name);
                                        return con;
                                }
                                int err;
                                err = dapm_list_add_widget(list, path->source);
                                if (err < 0) {
-                                       dev_err(widget->dapm->dev, "could not add widget %s\n",
+                                       dev_err(widget->dapm->dev,
+                                               "ASoC: could not add widget %s\n",
                                                widget->name);
                                        return con;
                                }
                        ret = regulator_allow_bypass(w->regulator, true);
                        if (ret != 0)
                                dev_warn(w->dapm->dev,
-                                        "Failed to bypass %s: %d\n",
+                                        "ASoC: Failed to bypass %s: %d\n",
                                         w->name, ret);
                }
 
                        ret = regulator_allow_bypass(w->regulator, false);
                        if (ret != 0)
                                dev_warn(w->dapm->dev,
-                                        "Failed to unbypass %s: %d\n",
+                                        "ASoC: Failed to unbypass %s: %d\n",
                                         w->name, ret);
                }
 
                ret = w->event(w, NULL, event);
                trace_snd_soc_dapm_widget_event_done(w, event);
                if (ret < 0)
-                       pr_err("%s: %s event failed: %d\n",
+                       dev_err(dapm->dev, "ASoC: %s: %s event failed: %d\n",
                               ev_name, w->name, ret);
        }
 }
 
                if (ret < 0)
                        dev_err(w->dapm->dev,
-                               "Failed to apply widget power: %d\n", ret);
+                               "ASoC: Failed to apply widget power: %d\n", ret);
        }
 
        if (!list_empty(&pending))
            (w->event_flags & SND_SOC_DAPM_PRE_REG)) {
                ret = w->event(w, update->kcontrol, SND_SOC_DAPM_PRE_REG);
                if (ret != 0)
-                       pr_err("%s DAPM pre-event failed: %d\n",
+                       dev_err(dapm->dev, "ASoC: %s DAPM pre-event failed: %d\n",
                               w->name, ret);
        }
 
        ret = soc_widget_update_bits_locked(w, update->reg, update->mask,
                                  update->val);
        if (ret < 0)
-               pr_err("%s DAPM update failed: %d\n", w->name, ret);
+               dev_err(dapm->dev, "ASoC: %s DAPM update failed: %d\n",
+                       w->name, ret);
 
        if (w->event &&
            (w->event_flags & SND_SOC_DAPM_POST_REG)) {
                ret = w->event(w, update->kcontrol, SND_SOC_DAPM_POST_REG);
                if (ret != 0)
-                       pr_err("%s DAPM post-event failed: %d\n",
+                       dev_err(dapm->dev, "ASoC: %s DAPM post-event failed: %d\n",
                               w->name, ret);
        }
 }
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
                if (ret != 0)
                        dev_err(d->dev,
-                               "Failed to turn on bias: %d\n", ret);
+                               "ASoC: Failed to turn on bias: %d\n", ret);
        }
 
        /* Prepare for a STADDBY->ON or ON->STANDBY transition */
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_PREPARE);
                if (ret != 0)
                        dev_err(d->dev,
-                               "Failed to prepare bias: %d\n", ret);
+                               "ASoC: Failed to prepare bias: %d\n", ret);
        }
 }
 
             d->target_bias_level == SND_SOC_BIAS_OFF)) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_STANDBY);
                if (ret != 0)
-                       dev_err(d->dev, "Failed to apply standby bias: %d\n",
+                       dev_err(d->dev, "ASoC: Failed to apply standby bias: %d\n",
                                ret);
        }
 
            d->target_bias_level == SND_SOC_BIAS_OFF) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_OFF);
                if (ret != 0)
-                       dev_err(d->dev, "Failed to turn off bias: %d\n", ret);
+                       dev_err(d->dev, "ASoC: Failed to turn off bias: %d\n",
+                               ret);
 
                if (d->dev)
                        pm_runtime_put(d->dev);
            d->target_bias_level == SND_SOC_BIAS_ON) {
                ret = snd_soc_dapm_set_bias_level(d, SND_SOC_BIAS_ON);
                if (ret != 0)
-                       dev_err(d->dev, "Failed to apply active bias: %d\n",
+                       dev_err(d->dev, "ASoC: Failed to apply active bias: %d\n",
                                ret);
        }
 }
 
        if (!dapm->debugfs_dapm) {
                dev_warn(dapm->dev,
-                      "Failed to create DAPM debugfs directory\n");
+                      "ASoC: Failed to create DAPM debugfs directory\n");
                return;
        }
 
        struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
 
        if (!w) {
-               dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
+               dev_err(dapm->dev, "ASoC: DAPM unknown pin %s\n", pin);
                return -EINVAL;
        }
 
        if (!wsource)
                wsource = wtsource;
 
-       if (wsource == NULL || wsink == NULL)
+       if (wsource == NULL) {
+               dev_err(dapm->dev, "ASoC: no source widget found for %s\n",
+                       route->source);
                return -ENODEV;
+       }
+       if (wsink == NULL) {
+               dev_err(dapm->dev, "ASoC: no sink widget found for %s\n",
+                       route->sink);
+               return -ENODEV;
+       }
 
        path = kzalloc(sizeof(struct snd_soc_dapm_path), GFP_KERNEL);
        if (!path)
        return 0;
 
 err:
-       dev_warn(dapm->dev, "asoc: no dapm match for %s --> %s --> %s\n",
+       dev_warn(dapm->dev, "ASoC: no dapm match for %s --> %s --> %s\n",
                 source, control, sink);
        kfree(path);
        return ret;
 
        if (route->control) {
                dev_err(dapm->dev,
-                       "Removal of routes with controls not supported\n");
+                       "ASoC: Removal of routes with controls not supported\n");
                return -EINVAL;
        }
 
                list_del(&path->list_source);
                kfree(path);
        } else {
-               dev_warn(dapm->dev, "Route %s->%s does not exist\n",
+               dev_warn(dapm->dev, "ASoC: Route %s->%s does not exist\n",
                         source, sink);
        }
 
        for (i = 0; i < num; i++) {
                r = snd_soc_dapm_add_route(dapm, route);
                if (r < 0) {
-                       dev_err(dapm->dev, "Failed to add route %s->%s\n",
-                               route->source, route->sink);
+                       dev_err(dapm->dev, "ASoC: Failed to add route %s -> %s -> %s\n",
+                               route->source,
+                               route->control ? route->control : "direct",
+                               route->sink);
                        ret = r;
                }
                route++;
        int count = 0;
 
        if (!source) {
-               dev_err(dapm->dev, "Unable to find source %s for weak route\n",
+               dev_err(dapm->dev, "ASoC: Unable to find source %s for weak route\n",
                        route->source);
                return -ENODEV;
        }
 
        if (!sink) {
-               dev_err(dapm->dev, "Unable to find sink %s for weak route\n",
+               dev_err(dapm->dev, "ASoC: Unable to find sink %s for weak route\n",
                        route->sink);
                return -ENODEV;
        }
 
        if (route->control || route->connected)
-               dev_warn(dapm->dev, "Ignoring control for weak route %s->%s\n",
+               dev_warn(dapm->dev, "ASoC: Ignoring control for weak route %s->%s\n",
                         route->source, route->sink);
 
        list_for_each_entry(path, &source->sinks, list_source) {
        }
 
        if (count == 0)
-               dev_err(dapm->dev, "No path found for weak route %s->%s\n",
+               dev_err(dapm->dev, "ASoC: No path found for weak route %s->%s\n",
                        route->source, route->sink);
        if (count > 1)
-               dev_warn(dapm->dev, "%d paths found for weak route %s->%s\n",
+               dev_warn(dapm->dev, "ASoC: %d paths found for weak route %s->%s\n",
                         count, route->source, route->sink);
 
        return 0;
 
        if (snd_soc_volsw_is_stereo(mc))
                dev_warn(widget->dapm->dev,
-                        "Control '%s' is stereo, which is not supported\n",
+                        "ASoC: Control '%s' is stereo, which is not supported\n",
                         kcontrol->id.name);
 
        ucontrol->value.integer.value[0] =
 
        if (snd_soc_volsw_is_stereo(mc))
                dev_warn(widget->dapm->dev,
-                        "Control '%s' is stereo, which is not supported\n",
+                        "ASoC: Control '%s' is stereo, which is not supported\n",
                         kcontrol->id.name);
 
        val = (ucontrol->value.integer.value[0] & mask);
                w->regulator = devm_regulator_get(dapm->dev, w->name);
                if (IS_ERR(w->regulator)) {
                        ret = PTR_ERR(w->regulator);
-                       dev_err(dapm->dev, "Failed to request %s: %d\n",
+                       dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
                                w->name, ret);
                        return NULL;
                }
                w->clk = devm_clk_get(dapm->dev, w->name);
                if (IS_ERR(w->clk)) {
                        ret = PTR_ERR(w->clk);
-                       dev_err(dapm->dev, "Failed to request %s: %d\n",
+                       dev_err(dapm->dev, "ASoC: Failed to request %s: %d\n",
                                w->name, ret);
                        return NULL;
                }
        if (config->formats) {
                fmt = ffs(config->formats) - 1;
        } else {
-               dev_warn(w->dapm->dev, "Invalid format %llx specified\n",
+               dev_warn(w->dapm->dev, "ASoC: Invalid format %llx specified\n",
                         config->formats);
                fmt = 0;
        }
                                                             params, source);
                        if (ret != 0) {
                                dev_err(source->dev,
-                                       "hw_params() failed: %d\n", ret);
+                                       "ASoC: hw_params() failed: %d\n", ret);
                                goto out;
                        }
                }
                                                           sink);
                        if (ret != 0) {
                                dev_err(sink->dev,
-                                       "hw_params() failed: %d\n", ret);
+                                       "ASoC: hw_params() failed: %d\n", ret);
                                goto out;
                        }
                }
        case SND_SOC_DAPM_POST_PMU:
                ret = snd_soc_dai_digital_mute(sink, 0);
                if (ret != 0 && ret != -ENOTSUPP)
-                       dev_warn(sink->dev, "Failed to unmute: %d\n", ret);
+                       dev_warn(sink->dev, "ASoC: Failed to unmute: %d\n", ret);
                ret = 0;
                break;
 
        case SND_SOC_DAPM_PRE_PMD:
                ret = snd_soc_dai_digital_mute(sink, 1);
                if (ret != 0 && ret != -ENOTSUPP)
-                       dev_warn(sink->dev, "Failed to mute: %d\n", ret);
+                       dev_warn(sink->dev, "ASoC: Failed to mute: %d\n", ret);
                ret = 0;
                break;
 
        template.event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
                SND_SOC_DAPM_PRE_PMD;
 
-       dev_dbg(card->dev, "adding %s widget\n", link_name);
+       dev_dbg(card->dev, "ASoC: adding %s widget\n", link_name);
 
        w = snd_soc_dapm_new_control(&card->dapm, &template);
        if (!w) {
-               dev_err(card->dev, "Failed to create %s widget\n",
+               dev_err(card->dev, "ASoC: Failed to create %s widget\n",
                        link_name);
                return -ENOMEM;
        }
                template.name = dai->driver->playback.stream_name;
                template.sname = dai->driver->playback.stream_name;
 
-               dev_dbg(dai->dev, "adding %s widget\n",
+               dev_dbg(dai->dev, "ASoC: adding %s widget\n",
                        template.name);
 
                w = snd_soc_dapm_new_control(dapm, &template);
                if (!w) {
-                       dev_err(dapm->dev, "Failed to create %s widget\n",
+                       dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
                                dai->driver->playback.stream_name);
                }
 
                template.name = dai->driver->capture.stream_name;
                template.sname = dai->driver->capture.stream_name;
 
-               dev_dbg(dai->dev, "adding %s widget\n",
+               dev_dbg(dai->dev, "ASoC: adding %s widget\n",
                        template.name);
 
                w = snd_soc_dapm_new_control(dapm, &template);
                if (!w) {
-                       dev_err(dapm->dev, "Failed to create %s widget\n",
+                       dev_err(dapm->dev, "ASoC: Failed to create %s widget\n",
                                dai->driver->capture.stream_name);
                }
 
        struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, true);
 
        if (!w) {
-               dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
+               dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
                return -EINVAL;
        }
 
-       dev_dbg(w->dapm->dev, "dapm: force enable pin %s\n", pin);
+       dev_dbg(w->dapm->dev, "ASoC: force enable pin %s\n", pin);
        w->connected = 1;
        w->force = 1;
        dapm_mark_dirty(w, "force enable");
        struct snd_soc_dapm_widget *w = dapm_find_widget(dapm, pin, false);
 
        if (!w) {
-               dev_err(dapm->dev, "dapm: unknown pin %s\n", pin);
+               dev_err(dapm->dev, "ASoC: unknown pin %s\n", pin);
                return -EINVAL;
        }
 
        struct snd_soc_dapm_context *dapm = &codec->dapm;
        struct snd_soc_dapm_widget *w;
 
-       dev_dbg(codec->dev, "Auto NC: DAPMs: card:%p codec:%p\n",
+       dev_dbg(codec->dev, "ASoC: Auto NC: DAPMs: card:%p codec:%p\n",
                &card->dapm, &codec->dapm);
 
        list_for_each_entry(w, &card->widgets, list) {
                case snd_soc_dapm_input:
                case snd_soc_dapm_output:
                case snd_soc_dapm_micbias:
-                       dev_dbg(codec->dev, "Auto NC: Checking widget %s\n",
+                       dev_dbg(codec->dev, "ASoC: Auto NC: Checking widget %s\n",
                                w->name);
                        if (!snd_soc_dapm_widget_in_card_paths(card, w)) {
                                dev_dbg(codec->dev,