tree b4a309c5185bad7f046c9ce81215ba24fa8a5ea9
parent be9f643ae6aa9044c60fe80e3a2c10be8371c692
author Pavel Machek <pavel@denx.de> 1409914188 +0200
committer Marek Vasut <marex@denx.de> 1412609679 +0200

mmc: dw_mmc: cleanups

The dw_mmc driver was responding to errors with debug(). Change that
to prinf()/puts() respectively so that any errors are immediately
obvious. Also adjust english in comments.

Signed-off-by: Pavel Machek <pavel@denx.de>
Signed-off-by: Marek Vasut <marex@denx.de>
Cc: Chin Liang See <clsee@altera.com>
Cc: Dinh Nguyen <dinguyen@altera.com>
Cc: Albert Aribaud <albert.u.boot@aribaud.net>
Cc: Tom Rini <trini@ti.com>
Cc: Wolfgang Denk <wd@denx.de>
Cc: Pavel Machek <pavel@denx.de>
Cc: Pantelis Antoniou <panto@antoniou-consulting.com>
Acked-by: Chin Liang See <clsee@altera.com>
