treewide: replace with error() with pr_err()
authorMasahiro Yamada <yamada.masahiro@socionext.com>
Sat, 16 Sep 2017 05:10:41 +0000 (14:10 +0900)
committerTom Rini <trini@konsulko.com>
Wed, 4 Oct 2017 15:59:44 +0000 (11:59 -0400)
U-Boot widely uses error() as a bit noisier variant of printf().

This macro causes name conflict with the following line in
include/linux/compiler-gcc.h:

  # define __compiletime_error(message) __attribute__((error(message)))

This prevents us from using __compiletime_error(), and makes it
difficult to fully sync BUILD_BUG macros with Linux.  (Notice
Linux's BUILD_BUG_ON_MSG is implemented by using compiletime_assert().)

Let's convert error() into now treewide-available pr_err().

Done with the help of Coccinelle, excluing tools/ directory.

The semantic patch I used is as follows:

// <smpl>
@@@@
-error
+pr_err
 (...)
// </smpl>

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
[trini: Re-run Coccinelle]
Signed-off-by: Tom Rini <trini@konsulko.com>
128 files changed:
arch/arm/mach-omap2/am33xx/board.c
arch/arm/mach-omap2/utils.c
arch/arm/mach-rockchip/rk3188-board-spl.c
arch/arm/mach-rockchip/rk3188-board.c
arch/arm/mach-rockchip/rk3368-board-spl.c
arch/arm/mach-socfpga/reset_manager_arria10.c
arch/arm/mach-tegra/ivc.c
arch/arm/mach-tegra/tegra124/xusb-padctl.c
arch/arm/mach-tegra/tegra186/nvtboot_mem.c
arch/arm/mach-tegra/tegra20/clock.c
arch/arm/mach-tegra/tegra210/xusb-padctl.c
arch/arm/mach-tegra/tegra30/clock.c
arch/arm/mach-tegra/xusb-padctl-common.c
arch/x86/cpu/tangier/sdram.c
board/nvidia/jetson-tk1/jetson-tk1.c
board/samsung/common/exynos5-dt.c
board/samsung/common/misc.c
board/samsung/goni/goni.c
board/samsung/odroid/odroid.c
cmd/fastboot.c
cmd/nvedit.c
cmd/regulator.c
cmd/thordown.c
cmd/tpm_test.c
cmd/usb_gadget_sdp.c
cmd/usb_mass_storage.c
common/dfu.c
common/fb_mmc.c
common/fb_nand.c
common/spl/spl_dfu.c
common/spl/spl_sdp.c
common/update.c
disk/part_efi.c
drivers/adc/adc-uclass.c
drivers/adc/exynos-adc.c
drivers/adc/rockchip-saradc.c
drivers/adc/sandbox.c
drivers/ata/dwc_ahci.c
drivers/clk/clk_boston.c
drivers/clk/clk_stm32f7.c
drivers/clk/clk_stm32h7.c
drivers/clk/rockchip/clk_rk3368.c
drivers/clk/rockchip/clk_rk3399.c
drivers/clk/rockchip/clk_rv1108.c
drivers/dfu/dfu.c
drivers/dfu/dfu_mmc.c
drivers/dfu/dfu_ram.c
drivers/dfu/dfu_tftp.c
drivers/dma/dma-uclass.c
drivers/dma/lpc32xx_dma.c
drivers/dma/ti-edma3.c
drivers/i2c/i2c-gpio.c
drivers/i2c/omap24xx_i2c.c
drivers/i2c/stm32f7_i2c.c
drivers/i2c/tegra_i2c.c
drivers/misc/tegra186_bpmp.c
drivers/mmc/exynos_dw_mmc.c
drivers/mmc/hi6220_dw_mmc.c
drivers/mmc/sti_sdhci.c
drivers/mmc/stm32_sdmmc2.c
drivers/mmc/xenon_sdhci.c
drivers/mtd/nand/lpc32xx_nand_mlc.c
drivers/mtd/nand/pxa3xx_nand.c
drivers/net/bcm-sf2-eth-gmac.c
drivers/net/bcm-sf2-eth.c
drivers/net/cpsw-common.c
drivers/net/cpsw.c
drivers/net/dwc_eth_qos.c
drivers/net/ep93xx_eth.c
drivers/net/keystone_net.c
drivers/pci/pci_tegra.c
drivers/pci/pcie_xilinx.c
drivers/phy/marvell/comphy_cp110.c
drivers/phy/sti_usb_phy.c
drivers/phy/ti-pipe3-phy.c
drivers/pinctrl/mvebu/pinctrl-armada-37xx.c
drivers/pinctrl/pinctrl-sti.c
drivers/pinctrl/pinctrl_stm32.c
drivers/power/pmic/as3722.c
drivers/power/pmic/as3722_gpio.c
drivers/power/pmic/i2c_pmic_emul.c
drivers/power/pmic/lp873x.c
drivers/power/pmic/lp87565.c
drivers/power/pmic/max77686.c
drivers/power/pmic/max8997.c
drivers/power/pmic/max8998.c
drivers/power/pmic/palmas.c
drivers/power/pmic/pfuze100.c
drivers/power/pmic/s2mps11.c
drivers/power/pmic/s5m8767.c
drivers/power/pmic/sandbox.c
drivers/power/pmic/tps65090.c
drivers/power/regulator/fixed.c
drivers/power/regulator/gpio-regulator.c
drivers/power/regulator/max77686.c
drivers/power/regulator/pbias_regulator.c
drivers/power/regulator/sandbox.c
drivers/ram/rockchip/dmc-rk3368.c
drivers/ram/rockchip/sdram_rk3399.c
drivers/ram/stm32_sdram.c
drivers/reset/sti-reset.c
drivers/spi/atmel_spi.c
drivers/spi/lpc32xx_ssp.c
drivers/sysreset/sysreset_sti.c
drivers/sysreset/sysreset_syscon.c
drivers/sysreset/sysreset_watchdog.c
drivers/tpm/tpm_tis_infineon.c
drivers/usb/common/common.c
drivers/usb/eth/mcs7830.c
drivers/usb/gadget/at91_udc.c
drivers/usb/gadget/atmel_usba_udc.c
drivers/usb/gadget/dwc2_udc_otg.c
drivers/usb/gadget/ether.c
drivers/usb/gadget/f_fastboot.c
drivers/usb/gadget/f_sdp.c
drivers/usb/gadget/f_thor.c
drivers/usb/host/dwc2.c
drivers/usb/host/dwc3-sti-glue.c
drivers/usb/host/ehci-generic.c
drivers/usb/host/ohci-generic.c
drivers/usb/host/xhci-dwc3.c
drivers/usb/host/xhci-rockchip.c
drivers/usb/musb-new/ti-musb.c
drivers/video/am335x-fb.c
env/common.c
env/sf.c
fs/jffs2/jffs2_nand_1pass.c
fs/yaffs2/yaffs_uboot_glue.c

index 913a44ad64b4f0ece107a4c88ad17e13cc431504..ae86b69b9c71ff555989132826cac832bdbde95e 100644 (file)
@@ -241,7 +241,7 @@ int arch_misc_init(void)
 #if defined(CONFIG_DM_ETH) && defined(CONFIG_USB_ETHER)
        ret = usb_ether_init();
        if (ret) {
-               error("USB ether init failed\n");
+               pr_err("USB ether init failed\n");
                return ret;
        }
 #endif
index 0b0bf1837c9cb89ac074356f9c3e081b858a63ff..f2fafae2a1602fee5a3ff90a7a7ae4e1fe9bb1ce 100644 (file)
@@ -87,13 +87,13 @@ static u32 omap_mmc_get_part_size(const char *part)
 
        dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
        if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
-               error("invalid mmc device\n");
+               pr_err("invalid mmc device\n");
                return 0;
        }
 
        res = part_get_info_by_name(dev_desc, part, &info);
        if (res < 0) {
-               error("cannot find partition: '%s'\n", part);
+               pr_err("cannot find partition: '%s'\n", part);
                return 0;
        }
 
index d3866bf029a53c993efeaf78416abab659ab07b4..406207ed21ce63f7aa718a12f1c61e36fab8a169 100644 (file)
@@ -151,7 +151,7 @@ void board_init_f(ulong dummy)
         */
        pmu = syscon_get_first_range(ROCKCHIP_SYSCON_PMU);
        if (IS_ERR(pmu))
-               error("pmu syscon returned %ld\n", PTR_ERR(pmu));
+               pr_err("pmu syscon returned %ld\n", PTR_ERR(pmu));
        SAVE_SP_ADDR = readl(&pmu->sys_reg[2]);
 
        ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
index 622e046dc0a754444aea5441b52a20e33e059162..96859a5b4bc7f37ce263aa724ab9dec553625588 100644 (file)
@@ -26,7 +26,7 @@ int board_late_init(void)
 
        grf = syscon_get_first_range(ROCKCHIP_SYSCON_GRF);
        if (IS_ERR(grf)) {
-               error("grf syscon returned %ld\n", PTR_ERR(grf));
+               pr_err("grf syscon returned %ld\n", PTR_ERR(grf));
        } else {
                /* enable noc remap to mimic legacy loaders */
                rk_clrsetreg(&grf->soc_con0,
index cabf34448643ef232288833321a0bbe218a803f6..72d2c97d36367a8df193feb4a9f01344a095501d 100644 (file)
@@ -38,13 +38,13 @@ void board_init_f(ulong dummy)
        /* Set up our preloader console */
        ret = uclass_get_device(UCLASS_PINCTRL, 0, &pinctrl);
        if (ret) {
-               error("%s: pinctrl init failed: %d\n", __func__, ret);
+               pr_err("%s: pinctrl init failed: %d\n", __func__, ret);
                hang();
        }
 
        ret = pinctrl_request_noflags(pinctrl, PERIPH_ID_UART0);
        if (ret) {
-               error("%s: failed to set up console UART\n", __func__);
+               pr_err("%s: failed to set up console UART\n", __func__);
                hang();
        }
 
index 66f1ec21f132eee1f5d9c57fdb1bd916e0af3830..ae16897494bdcb6429abd1085bac32a2b7c26af7 100644 (file)
@@ -174,7 +174,7 @@ void socfpga_emac_manage_reset(ulong emacbase, u32 state)
                emacmask = ALT_RSTMGR_PER0MODRST_EMAC2_SET_MSK;
                break;
        default:
-               error("emac base address unexpected! %lx", emacbase);
+               pr_err("emac base address unexpected! %lx", emacbase);
                hang();
                break;
        }
index cf6626fb12c7d60983ca8600d9d7e865c8a123f9..dec7d90c5d3b833ef304e19e42056a60f4f376c6 100644 (file)
@@ -493,7 +493,7 @@ static int check_ivc_params(ulong qbase1, ulong qbase2, uint32_t nframes,
               (TEGRA_IVC_ALIGN - 1));
 
        if ((uint64_t)nframes * (uint64_t)frame_size >= 0x100000000) {
-               error("tegra_ivc: nframes * frame_size overflows\n");
+               pr_err("tegra_ivc: nframes * frame_size overflows\n");
                return -EINVAL;
        }
 
@@ -503,12 +503,12 @@ static int check_ivc_params(ulong qbase1, ulong qbase2, uint32_t nframes,
         */
        if ((qbase1 & (TEGRA_IVC_ALIGN - 1)) ||
            (qbase2 & (TEGRA_IVC_ALIGN - 1))) {
-               error("tegra_ivc: channel start not aligned\n");
+               pr_err("tegra_ivc: channel start not aligned\n");
                return -EINVAL;
        }
 
        if (frame_size & (TEGRA_IVC_ALIGN - 1)) {
-               error("tegra_ivc: frame size not adequately aligned\n");
+               pr_err("tegra_ivc: frame size not adequately aligned\n");
                return -EINVAL;
        }
 
@@ -521,7 +521,7 @@ static int check_ivc_params(ulong qbase1, ulong qbase2, uint32_t nframes,
        }
 
        if (ret) {
-               error("tegra_ivc: queue regions overlap\n");
+               pr_err("tegra_ivc: queue regions overlap\n");
                return ret;
        }
 
index d326a6ae570191e6b8aaa11f57f0b90290188495..bfc0ab8f102ab5ba07cf13d1239d82bfdbc32163 100644 (file)
@@ -137,7 +137,7 @@ static int tegra_xusb_padctl_disable(struct tegra_xusb_padctl *padctl)
        u32 value;
 
        if (padctl->enable == 0) {
-               error("unbalanced enable/disable");
+               pr_err("unbalanced enable/disable");
                return 0;
        }
 
index 966cf9f1c46029bdccfb08758c1edfa1ec6d30ec..5224ef641cd8f9610a86548dff12dc8a13b57084 100644 (file)
@@ -45,12 +45,12 @@ int dram_init(void)
 
        node = fdt_path_offset(nvtboot_blob, "/memory");
        if (node < 0) {
-               error("Can't find /memory node in nvtboot DTB");
+               pr_err("Can't find /memory node in nvtboot DTB");
                hang();
        }
        prop = fdt_getprop(nvtboot_blob, node, "reg", &len);
        if (!prop) {
-               error("Can't find /memory/reg property in nvtboot DTB");
+               pr_err("Can't find /memory/reg property in nvtboot DTB");
                hang();
        }
 
index ec04cf5261f7ad574f41b61d9f4457e0106b41b8..81fb1d840f28af2eea7d69133b4d3a54b47bbea9 100644 (file)
@@ -667,7 +667,7 @@ static int tegra_plle_train(void)
        } while (--timeout);
 
        if (timeout == 0) {
-               error("timeout waiting for PLLE to become ready");
+               pr_err("timeout waiting for PLLE to become ready");
                return -ETIMEDOUT;
        }
 
@@ -697,7 +697,7 @@ int tegra_plle_enable(void)
        if ((value & PLLE_MISC_PLL_READY) == 0) {
                err = tegra_plle_train();
                if (err < 0) {
-                       error("failed to train PLLE: %d", err);
+                       pr_err("failed to train PLLE: %d", err);
                        return err;
                }
        }
@@ -726,7 +726,7 @@ int tegra_plle_enable(void)
        } while (--timeout);
 
        if (timeout == 0) {
-               error("timeout waiting for PLLE to lock");
+               pr_err("timeout waiting for PLLE to lock");
                return -ETIMEDOUT;
        }
 
index bf85e075de2f648bfe2c3ebac3e87d0195e5e6ac..a3e3e378e18079390ca7df6030477047ec5155f0 100644 (file)
@@ -125,7 +125,7 @@ static int tegra_xusb_padctl_disable(struct tegra_xusb_padctl *padctl)
        u32 value;
 
        if (padctl->enable == 0) {
-               error("unbalanced enable/disable");
+               pr_err("unbalanced enable/disable");
                return 0;
        }
 
index 4fd8b8a3b1fb69a15157ee80c88283d6455d9cd8..282f34fb89471b766e271245b5816bc258ee8401 100644 (file)
@@ -696,7 +696,7 @@ static int tegra_plle_train(void)
        } while (--timeout);
 
        if (timeout == 0) {
-               error("timeout waiting for PLLE to become ready");
+               pr_err("timeout waiting for PLLE to become ready");
                return -ETIMEDOUT;
        }
 
@@ -726,7 +726,7 @@ int tegra_plle_enable(void)
        if ((value & PLLE_MISC_PLL_READY) == 0) {
                err = tegra_plle_train();
                if (err < 0) {
-                       error("failed to train PLLE: %d", err);
+                       pr_err("failed to train PLLE: %d", err);
                        return err;
                }
        }
@@ -772,7 +772,7 @@ int tegra_plle_enable(void)
        } while (--timeout);
 
        if (timeout == 0) {
-               error("timeout waiting for PLLE to lock");
+               pr_err("timeout waiting for PLLE to lock");
                return -ETIMEDOUT;
        }
 
index abc18c03a5ebb65e7f1fedf028d9c0f58fb5a994..c8a468a034c31550b14734b0e1eb139c600bf991 100644 (file)
@@ -84,7 +84,7 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
 
        len = ofnode_read_string_count(node, "nvidia,lanes");
        if (len < 0) {
-               error("failed to parse \"nvidia,lanes\" property");
+               pr_err("failed to parse \"nvidia,lanes\" property");
                return -EINVAL;
        }
 
@@ -94,7 +94,7 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
                ret = ofnode_read_string_index(node, "nvidia,lanes", i,
                                               &group->pins[i]);
                if (ret) {
-                       error("failed to read string from \"nvidia,lanes\" property");
+                       pr_err("failed to read string from \"nvidia,lanes\" property");
                        return -EINVAL;
                }
        }
@@ -104,7 +104,7 @@ tegra_xusb_padctl_group_parse_dt(struct tegra_xusb_padctl *padctl,
        ret = ofnode_read_string_index(node, "nvidia,function", 0,
                                       &group->func);
        if (ret) {
-               error("failed to parse \"nvidia,func\" property");
+               pr_err("failed to parse \"nvidia,func\" property");
                return -EINVAL;
        }
 
@@ -157,14 +157,14 @@ tegra_xusb_padctl_group_apply(struct tegra_xusb_padctl *padctl,
 
                lane = tegra_xusb_padctl_find_lane(padctl, group->pins[i]);
                if (!lane) {
-                       error("no lane for pin %s", group->pins[i]);
+                       pr_err("no lane for pin %s", group->pins[i]);
                        continue;
                }
 
                func = tegra_xusb_padctl_lane_find_function(padctl, lane,
                                                            group->func);
                if (func < 0) {
-                       error("function %s invalid for lane %s: %d",
+                       pr_err("function %s invalid for lane %s: %d",
                              group->func, lane->name, func);
                        continue;
                }
@@ -206,7 +206,7 @@ tegra_xusb_padctl_config_apply(struct tegra_xusb_padctl *padctl,
 
                err = tegra_xusb_padctl_group_apply(padctl, group);
                if (err < 0) {
-                       error("failed to apply group %s: %d",
+                       pr_err("failed to apply group %s: %d",
                              group->name, err);
                        continue;
                }
@@ -232,7 +232,7 @@ tegra_xusb_padctl_config_parse_dt(struct tegra_xusb_padctl *padctl,
 
                err = tegra_xusb_padctl_group_parse_dt(padctl, group, subnode);
                if (err < 0) {
-                       error("failed to parse group %s", group->name);
+                       pr_err("failed to parse group %s", group->name);
                        return err;
                }
 
@@ -250,7 +250,7 @@ static int tegra_xusb_padctl_parse_dt(struct tegra_xusb_padctl *padctl,
 
        err = ofnode_read_resource(node, 0, &padctl->regs);
        if (err < 0) {
-               error("registers not found");
+               pr_err("registers not found");
                return err;
        }
 
@@ -261,7 +261,7 @@ static int tegra_xusb_padctl_parse_dt(struct tegra_xusb_padctl *padctl,
                err = tegra_xusb_padctl_config_parse_dt(padctl, config,
                                                        subnode);
                if (err < 0) {
-                       error("failed to parse entry %s: %d",
+                       pr_err("failed to parse entry %s: %d",
                              config->name, err);
                        continue;
                }
@@ -289,7 +289,7 @@ int tegra_xusb_process_nodes(ofnode nodes[], unsigned int count,
 
                err = tegra_xusb_padctl_parse_dt(&padctl, nodes[i]);
                if (err < 0) {
-                       error("failed to parse DT: %d", err);
+                       pr_err("failed to parse DT: %d", err);
                        continue;
                }
 
@@ -298,7 +298,7 @@ int tegra_xusb_process_nodes(ofnode nodes[], unsigned int count,
 
                err = tegra_xusb_padctl_config_apply(&padctl, &padctl.config);
                if (err < 0) {
-                       error("failed to apply pinmux: %d", err);
+                       pr_err("failed to apply pinmux: %d", err);
                        continue;
                }
 
index 5743077431d3da6b46b48bcadfbb41f8526f0f07..eae8d785df9ed431e1cb59b1cad528ff9b5875d8 100644 (file)
@@ -39,7 +39,7 @@ static int sfi_table_check(struct sfi_table_header *sbh)
                chksum += *pos++;
 
        if (chksum)
-               error("sfi: Invalid checksum\n");
+               pr_err("sfi: Invalid checksum\n");
 
        /* Checksum is OK if zero */
        return chksum ? -EILSEQ : 0;
@@ -76,7 +76,7 @@ static struct sfi_table_simple *sfi_search_mmap(void)
        /* Find SYST table */
        sb = sfi_get_table_by_sig(SFI_BASE_ADDR, SFI_SIG_SYST);
        if (!sb) {
-               error("sfi: failed to locate SYST table\n");
+               pr_err("sfi: failed to locate SYST table\n");
                return NULL;
        }
 
@@ -90,7 +90,7 @@ static struct sfi_table_simple *sfi_search_mmap(void)
                        return (struct sfi_table_simple *)sbh;
        }
 
-       error("sfi: failed to locate SFI MMAP table\n");
+       pr_err("sfi: failed to locate SFI MMAP table\n");
        return NULL;
 }
 
index bd08a2eed4255a2422b0184d1661e015c0f4ce89..c20da29a98adc6572d271634f6036fd9829a8b6e 100644 (file)
@@ -49,7 +49,7 @@ static int as3722_sd_enable(struct udevice *pmic, unsigned int sd)
 
        err = pmic_clrsetbits(pmic, AS3722_SD_CONTROL, 0, 1 << sd);
        if (err) {
-               error("failed to update SD control register: %d", err);
+               pr_err("failed to update SD control register: %d", err);
                return err;
        }
 
@@ -70,13 +70,13 @@ int tegra_pcie_board_init(void)
 
        ret = as3722_sd_enable(dev, 4);
        if (ret < 0) {
-               error("failed to enable SD4: %d\n", ret);
+               pr_err("failed to enable SD4: %d\n", ret);
                return ret;
        }
 
        ret = as3722_sd_set_voltage(dev, 4, 0x24);
        if (ret < 0) {
-               error("failed to set SD4 voltage: %d\n", ret);
+               pr_err("failed to set SD4 voltage: %d\n", ret);
                return ret;
        }
 
index ae2a6e6bfa637a82d8aa80b2de3b6b56edf97cdf..0d17f30712cdf2b3c33903c07f0ee4be52d2ffde 100644 (file)
@@ -161,7 +161,7 @@ int board_usb_init(int index, enum usb_init_type init)
                samsung_get_base_usb3_phy();
 
        if (!phy) {
-               error("usb3 phy not supported");
+               pr_err("usb3 phy not supported");
                return -ENODEV;
        }
 
index 4157349d028b0c0eb488c1e6d364b3b36acfc742..eba25b7b980ae3e12c84bcf0e5151e3075c6f417 100644 (file)
@@ -457,7 +457,7 @@ void draw_logo(void)
 
        addr = panel_info.logo_addr;
        if (!addr) {
-               error("There is no logo data.");
+               pr_err("There is no logo data.");
                return;
        }
 
index d0247ac2571ae864254975110d59712197b6bb68..debc4c57ffa068c14b3f2f2b7047942895b10f63 100644 (file)
@@ -102,7 +102,7 @@ int board_mmc_init(bd_t *bis)
 
        ret = s5p_mmc_init(0, 4);
        if (ret)
-               error("MMC: Failed to init MMC:0.\n");
+               pr_err("MMC: Failed to init MMC:0.\n");
 
        /*
         * SD card (T_FLASH) detect and init
@@ -127,7 +127,7 @@ int board_mmc_init(bd_t *bis)
 
                ret_sd = s5p_mmc_init(2, 4);
                if (ret_sd)
-                       error("MMC: Failed to init SD card (MMC:2).\n");
+                       pr_err("MMC: Failed to init SD card (MMC:2).\n");
        }
 
        return ret & ret_sd;
index e40a2f6e3a6909663ad45d57ebe4f69ebb5841f4..0df96c1a3daf060f2d6211c577c36b8cdd968222 100644 (file)
@@ -429,7 +429,7 @@ int exynos_power_init(void)
        };
 
        if (regulator_list_autoset(mmc_regulators, NULL, true))
-               error("Unable to init all mmc regulators");
+               pr_err("Unable to init all mmc regulators");
 
        return 0;
 }
@@ -442,7 +442,7 @@ static int s5pc210_phy_control(int on)
 
        ret = regulator_get_by_platname("VDD_UOTG_3.0V", &dev);
        if (ret) {
-               error("Regulator get error: %d", ret);
+               pr_err("Regulator get error: %d", ret);
                return ret;
        }
 
@@ -487,25 +487,25 @@ int board_usb_init(int index, enum usb_init_type init)
 
        ret = regulator_get_by_platname("VCC_P3V3_2.85V", &dev);
        if (ret) {
-               error("Regulator get error: %d", ret);
+               pr_err("Regulator get error: %d", ret);
                return ret;
        }
 
        ret = regulator_set_enable(dev, true);
        if (ret) {
-               error("Regulator %s enable setting error: %d", dev->name, ret);
+               pr_err("Regulator %s enable setting error: %d", dev->name, ret);
                return ret;
        }
 
        ret = regulator_set_value(dev, 750000);
        if (ret) {
-               error("Regulator %s value setting error: %d", dev->name, ret);
+               pr_err("Regulator %s value setting error: %d", dev->name, ret);
                return ret;
        }
 
        ret = regulator_set_value(dev, 3300000);
        if (ret) {
-               error("Regulator %s value setting error: %d", dev->name, ret);
+               pr_err("Regulator %s value setting error: %d", dev->name, ret);
                return ret;
        }
 #endif
index 488822a2eed512f68360ed5838e2aa26d65ba546..8adcca592d586aa9cbfabe14caab3e99f77a4d73 100644 (file)
@@ -27,7 +27,7 @@ static int do_fastboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 
        ret = board_usb_init(controller_index, USB_INIT_DEVICE);
        if (ret) {
-               error("USB init failed: %d", ret);
+               pr_err("USB init failed: %d", ret);
                return CMD_RET_FAILURE;
        }
 
index 4033d90c8e2dd043384b93ba005fd15e1e93447c..228e904e1d51dd2a41d180b1ffe6a7b8f476a3aa 100644 (file)
@@ -927,7 +927,7 @@ NXTARG:             ;
                                H_MATCH_KEY | H_MATCH_IDENT,
                                &ptr, size, argc, argv);
                if (len < 0) {
-                       error("Cannot export environment: errno = %d\n", errno);
+                       pr_err("Cannot export environment: errno = %d\n", errno);
                        return 1;
                }
                sprintf(buf, "%zX", (size_t)len);
@@ -947,7 +947,7 @@ NXTARG:             ;
                        H_MATCH_KEY | H_MATCH_IDENT,
                        &res, ENV_SIZE, argc, argv);
        if (len < 0) {
-               error("Cannot export environment: errno = %d\n", errno);
+               pr_err("Cannot export environment: errno = %d\n", errno);
                return 1;
        }
 
@@ -1082,7 +1082,7 @@ static int do_env_import(cmd_tbl_t *cmdtp, int flag,
 
        if (himport_r(&env_htab, ptr, size, sep, del ? 0 : H_NOCLEAR,
                        crlf_is_lf, 0, NULL) == 0) {
-               error("Environment import failed: errno = %d\n", errno);
+               pr_err("Environment import failed: errno = %d\n", errno);
                return 1;
        }
        gd->flags |= GD_FLG_ENV_READY;
index 2ef5bc9a828967f913b3d13a16f62f05342ff839..b605255180d573a8b4746ebf34b5f1d84392973b 100644 (file)
@@ -71,7 +71,7 @@ static int curr_dev_and_platdata(struct udevice **devp,
 
        *uc_pdata = dev_get_uclass_platdata(*devp);
        if (!*uc_pdata) {
-               error("Regulator: %s - missing platform data!", currdev->name);
+               pr_err("Regulator: %s - missing platform data!", currdev->name);
                return CMD_RET_FAILURE;
        }
 
index 436b7f56315eb5985016d4d597c6c8ba94959885..1bb5fc2ec23b91d152098f5cfd54a65ab2a6856c 100644 (file)
@@ -33,7 +33,7 @@ int do_thor_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        int controller_index = simple_strtoul(usb_controller, NULL, 0);
        ret = board_usb_init(controller_index, USB_INIT_DEVICE);
        if (ret) {
-               error("USB init failed: %d", ret);
+               pr_err("USB init failed: %d", ret);
                ret = CMD_RET_FAILURE;
                goto exit;
        }
@@ -42,14 +42,14 @@ int do_thor_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        ret = thor_init();
        if (ret) {
-               error("THOR DOWNLOAD failed: %d", ret);
+               pr_err("THOR DOWNLOAD failed: %d", ret);
                ret = CMD_RET_FAILURE;
                goto exit;
        }
 
        ret = thor_handle();
        if (ret) {
-               error("THOR failed: %d", ret);
+               pr_err("THOR failed: %d", ret);
                ret = CMD_RET_FAILURE;
                goto exit;
        }
index 330640594879d138a2d4b279f77d07c016d03b00..37ad2ff33d6598d4eb600155ababeefcf81ab2aa 100644 (file)
@@ -303,12 +303,12 @@ static int test_readonly(void)
        index_0 += 1;
        if (tpm_nv_write_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0) !=
                TPM_SUCCESS)) {
-               error("\tcould not write index 0\n");
+               pr_err("\tcould not write index 0\n");
        }
        tpm_nv_write_value_lock(INDEX0);
        if (tpm_nv_write_value(INDEX0, (uint8_t *)&index_0, sizeof(index_0)) ==
                        TPM_SUCCESS)
-               error("\tindex 0 is not locked\n");
+               pr_err("\tindex 0 is not locked\n");
 
        printf("\tdone\n");
        return 0;
@@ -471,7 +471,7 @@ static int test_write_limit(void)
                case TPM_MAXNVWRITES:
                        assert(i >= TPM_MAX_NV_WRITES_NOOWNER);
                default:
-                       error("\tunexpected error code %d (0x%x)\n",
+                       pr_err("\tunexpected error code %d (0x%x)\n",
                              result, result);
                }
        }
index b1d8b2858e199a5132902130851d364a6bf79a36..ae4d73c1250d02eb082d65ea687c2d6ad663412e 100644 (file)
@@ -28,13 +28,13 @@ static int do_sdp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        ret = sdp_init(controller_index);
        if (ret) {
-               error("SDP init failed: %d", ret);
+               pr_err("SDP init failed: %d", ret);
                goto exit;
        }
 
        /* This command typically does not return but jumps to an image */
        sdp_handle(controller_index);
-       error("SDP ended");
+       pr_err("SDP ended");
 
 exit:
        g_dnl_unregister();
index 3353f95c74505bd44decca9f253105221c265d84..cfeecb7068a6c7ed5170297ae6eceaceba477dd5 100644 (file)
@@ -162,21 +162,21 @@ static int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
        controller_index = (unsigned int)(simple_strtoul(
                                usb_controller, NULL, 0));
        if (board_usb_init(controller_index, USB_INIT_DEVICE)) {
-               error("Couldn't init USB controller.");
+               pr_err("Couldn't init USB controller.");
                rc = CMD_RET_FAILURE;
                goto cleanup_ums_init;
        }
 
        rc = fsg_init(ums, ums_count);
        if (rc) {
-               error("fsg_init failed");
+               pr_err("fsg_init failed");
                rc = CMD_RET_FAILURE;
                goto cleanup_board;
        }
 
        rc = g_dnl_register("usb_dnl_ums");
        if (rc) {
-               error("g_dnl_register failed");
+               pr_err("g_dnl_register failed");
                rc = CMD_RET_FAILURE;
                goto cleanup_board;
        }
index 546a1ab9b4c0db72963ab7f14a24d86c6b6f47c6..07dff317a6c2708bb7f0deff133bae7f3bd8e11c 100644 (file)
@@ -26,13 +26,13 @@ int run_usb_dnl_gadget(int usbctrl_index, char *usb_dnl_gadget)
 
        ret = board_usb_init(usbctrl_index, USB_INIT_DEVICE);
        if (ret) {
-               error("board usb init failed\n");
+               pr_err("board usb init failed\n");
                return CMD_RET_FAILURE;
        }
        g_dnl_clear_detach();
        ret = g_dnl_register(usb_dnl_gadget);
        if (ret) {
-               error("g_dnl_register failed");
+               pr_err("g_dnl_register failed");
                return CMD_RET_FAILURE;
        }
 
@@ -75,7 +75,7 @@ int run_usb_dnl_gadget(int usbctrl_index, char *usb_dnl_gadget)
                        ret = dfu_flush(dfu_get_defer_flush(), NULL, 0, 0);
                        dfu_set_defer_flush(NULL);
                        if (ret) {
-                               error("Deferred dfu_flush() failed!");
+                               pr_err("Deferred dfu_flush() failed!");
                                goto exit;
                        }
                }
index 26d60b88d0cad12e5fa6bf8f0753be757f8c75f6..cf5b77ca287eee2ce446910f6f8b6c3580b1bd4a 100644 (file)
@@ -84,7 +84,7 @@ static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
        blkcnt = lldiv(blkcnt, info->blksz);
 
        if (blkcnt > info->size) {
-               error("too large for partition: '%s'\n", part_name);
+               pr_err("too large for partition: '%s'\n", part_name);
                fastboot_fail("too large for partition");
                return;
        }
@@ -93,7 +93,7 @@ static void write_raw_image(struct blk_desc *dev_desc, disk_partition_t *info,
 
        blks = blk_dwrite(dev_desc, info->start, blkcnt, buffer);
        if (blks != blkcnt) {
-               error("failed writing to device %d\n", dev_desc->devnum);
+               pr_err("failed writing to device %d\n", dev_desc->devnum);
                fastboot_fail("failed writing to device");
                return;
        }
@@ -125,7 +125,7 @@ static lbaint_t fb_mmc_get_boot_header(struct blk_desc *dev_desc,
        sector_size = info->blksz;
        hdr_sectors = DIV_ROUND_UP(sizeof(struct andr_img_hdr), sector_size);
        if (hdr_sectors == 0) {
-               error("invalid number of boot sectors: 0");
+               pr_err("invalid number of boot sectors: 0");
                fastboot_fail("invalid number of boot sectors: 0");
                return 0;
        }
@@ -133,7 +133,7 @@ static lbaint_t fb_mmc_get_boot_header(struct blk_desc *dev_desc,
        /* Read the boot image header */
        res = blk_dread(dev_desc, info->start, hdr_sectors, (void *)hdr);
        if (res != hdr_sectors) {
-               error("cannot read header from boot partition");
+               pr_err("cannot read header from boot partition");
                fastboot_fail("cannot read header from boot partition");
                return 0;
        }
@@ -141,7 +141,7 @@ static lbaint_t fb_mmc_get_boot_header(struct blk_desc *dev_desc,
        /* Check boot header magic string */
        res = android_image_check_header(hdr);
        if (res != 0) {
-               error("bad boot image magic");
+               pr_err("bad boot image magic");
                fastboot_fail("boot partition not initialized");
                return 0;
        }
@@ -179,7 +179,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        /* Get boot partition info */
        res = part_get_info_by_name(dev_desc, BOOT_PARTITION_NAME, &info);
        if (res < 0) {
-               error("cannot find boot partition");
+               pr_err("cannot find boot partition");
                fastboot_fail("cannot find boot partition");
                return -1;
        }
@@ -191,14 +191,14 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        /* Read boot image header */
        hdr_sectors = fb_mmc_get_boot_header(dev_desc, &info, hdr);
        if (hdr_sectors == 0) {
-               error("unable to read boot image header");
+               pr_err("unable to read boot image header");
                fastboot_fail("unable to read boot image header");
                return -1;
        }
 
        /* Check if boot image has second stage in it (we don't support it) */
        if (hdr->second_size > 0) {
-               error("moving second stage is not supported yet");
+               pr_err("moving second stage is not supported yet");
                fastboot_fail("moving second stage is not supported yet");
                return -1;
        }
@@ -216,7 +216,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        res = blk_dread(dev_desc, ramdisk_sector_start, ramdisk_sectors,
                        ramdisk_buffer);
        if (res != ramdisk_sectors) {
-               error("cannot read ramdisk from boot partition");
+               pr_err("cannot read ramdisk from boot partition");
                fastboot_fail("cannot read ramdisk from boot partition");
                return -1;
        }
@@ -225,7 +225,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        hdr->kernel_size = download_bytes;
        res = blk_dwrite(dev_desc, info.start, hdr_sectors, (void *)hdr);
        if (res == 0) {
-               error("cannot writeback boot image header");
+               pr_err("cannot writeback boot image header");
                fastboot_fail("cannot write back boot image header");
                return -1;
        }
@@ -237,7 +237,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        res = blk_dwrite(dev_desc, kernel_sector_start, kernel_sectors,
                         download_buffer);
        if (res == 0) {
-               error("cannot write new kernel");
+               pr_err("cannot write new kernel");
                fastboot_fail("cannot write new kernel");
                return -1;
        }
@@ -249,7 +249,7 @@ static int fb_mmc_update_zimage(struct blk_desc *dev_desc,
        res = blk_dwrite(dev_desc, ramdisk_sector_start, ramdisk_sectors,
                         ramdisk_buffer);
        if (res == 0) {
-               error("cannot write back original ramdisk");
+               pr_err("cannot write back original ramdisk");
                fastboot_fail("cannot write back original ramdisk");
                return -1;
        }
@@ -268,7 +268,7 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
 
        dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
        if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
-               error("invalid mmc device\n");
+               pr_err("invalid mmc device\n");
                fastboot_fail("invalid mmc device");
                return;
        }
@@ -322,7 +322,7 @@ void fb_mmc_flash_write(const char *cmd, void *download_buffer,
 #endif
 
        if (part_get_info_by_name_or_alias(dev_desc, cmd, &info) < 0) {
-               error("cannot find partition: '%s'\n", cmd);
+               pr_err("cannot find partition: '%s'\n", cmd);
                fastboot_fail("cannot find partition");
                return;
        }
@@ -360,21 +360,21 @@ void fb_mmc_erase(const char *cmd)
        struct mmc *mmc = find_mmc_device(CONFIG_FASTBOOT_FLASH_MMC_DEV);
 
        if (mmc == NULL) {
-               error("invalid mmc device");
+               pr_err("invalid mmc device");
                fastboot_fail("invalid mmc device");
                return;
        }
 
        dev_desc = blk_get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
        if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
-               error("invalid mmc device");
+               pr_err("invalid mmc device");
                fastboot_fail("invalid mmc device");
                return;
        }
 
        ret = part_get_info_by_name_or_alias(dev_desc, cmd, &info);
        if (ret < 0) {
-               error("cannot find partition: '%s'", cmd);
+               pr_err("cannot find partition: '%s'", cmd);
                fastboot_fail("cannot find partition");
                return;
        }
@@ -393,7 +393,7 @@ void fb_mmc_erase(const char *cmd)
 
        blks = blk_derase(dev_desc, blks_start, blks_size);
        if (blks != blks_size) {
-               error("failed erasing from device %d", dev_desc->devnum);
+               pr_err("failed erasing from device %d", dev_desc->devnum);
                fastboot_fail("failed erasing from device");
                return;
        }
index 3d027d43755486dcf53cdc31dbc728ba4191f33c..aa28046cbd83050b94f76306f6f448e97e5101fc 100644 (file)
@@ -40,20 +40,20 @@ static int fb_nand_lookup(const char *partname,
 
        ret = mtdparts_init();
        if (ret) {
-               error("Cannot initialize MTD partitions\n");
+               pr_err("Cannot initialize MTD partitions\n");
                fastboot_fail("cannot init mtdparts");
                return ret;
        }
 
        ret = find_dev_and_part(partname, &dev, &pnum, part);
        if (ret) {
-               error("cannot find partition: '%s'", partname);
+               pr_err("cannot find partition: '%s'", partname);
                fastboot_fail("cannot find partition");
                return ret;
        }
 
        if (dev->id->type != MTD_DEV_TYPE_NAND) {
-               error("partition '%s' is not stored on a NAND device",
+               pr_err("partition '%s' is not stored on a NAND device",
                      partname);
                fastboot_fail("not a NAND device");
                return -EINVAL;
@@ -154,7 +154,7 @@ void fb_nand_flash_write(const char *cmd, void *download_buffer,
 
        ret = fb_nand_lookup(cmd, &mtd, &part);
        if (ret) {
-               error("invalid NAND device");
+               pr_err("invalid NAND device");
                fastboot_fail("invalid NAND device");
                return;
        }
@@ -209,7 +209,7 @@ void fb_nand_erase(const char *cmd)
 
        ret = fb_nand_lookup(cmd, &mtd, &part);
        if (ret) {
-               error("invalid NAND device");
+               pr_err("invalid NAND device");
                fastboot_fail("invalid NAND device");
                return;
        }
@@ -220,7 +220,7 @@ void fb_nand_erase(const char *cmd)
 
        ret = _fb_nand_erase(mtd, part);
        if (ret) {
-               error("failed erasing from device %s", mtd->name);
+               pr_err("failed erasing from device %s", mtd->name);
                fastboot_fail("failed erasing from device");
                return;
        }
index 2c974735b11a8daf4eccdd3289307a488ffaaeba..05bb21035df2781fb975057515af9135dd55e89c 100644 (file)
@@ -42,13 +42,13 @@ int spl_dfu_cmd(int usbctrl, char *dfu_alt_info, char *interface, char *devstr)
        set_default_env(0);
        str_env = env_get(dfu_alt_info);
        if (!str_env) {
-               error("\"dfu_alt_info\" env variable not defined!\n");
+               pr_err("\"dfu_alt_info\" env variable not defined!\n");
                return -EINVAL;
        }
 
        ret = env_set("dfu_alt_info", str_env);
        if (ret) {
-               error("unable to set env variable \"dfu_alt_info\"!\n");
+               pr_err("unable to set env variable \"dfu_alt_info\"!\n");
                return -EINVAL;
        }
 
index 350bcdb056956d0ca6c61a3d4f11581730b7dce0..333d518f4d6e777aa603c024c985082db180b485 100644 (file)
@@ -24,13 +24,13 @@ static int spl_sdp_load_image(struct spl_image_info *spl_image,
 
        ret = sdp_init(controller_index);
        if (ret) {
-               error("SDP init failed: %d", ret);
+               pr_err("SDP init failed: %d", ret);
                return -ENODEV;
        }
 
        /* This command typically does not return but jumps to an image */
        sdp_handle(controller_index);
-       error("SDP ended");
+       pr_err("SDP ended");
 
        return -EINVAL;
 }
index 974f4655e7ef1d492b9c589cdfe02738a9fd1134..33bffaa89eca52014e88fdab626912be8f55bbdf 100644 (file)
@@ -242,7 +242,7 @@ int update_tftp(ulong addr, char *interface, char *devstring)
        } else if (interface && devstring) {
                update_tftp_dfu = true;
        } else {
-               error("Interface: %s and devstring: %s not supported!\n",
+               pr_err("Interface: %s and devstring: %s not supported!\n",
                      interface, devstring);
                return -EINVAL;
        }
index 208bb14ee88e2e5115134070b41feac72dce1b02..0abf48733d5d8fd731407ffb3a2db6c2d01adee1 100644 (file)
@@ -360,7 +360,7 @@ static int set_protective_mbr(struct blk_desc *dev_desc)
 
        /* Read MBR to backup boot code if it exists */
        if (blk_dread(dev_desc, 0, 1, p_mbr) != 1) {
-               error("** Can't read from device %d **\n", dev_desc->devnum);
+               pr_err("** Can't read from device %d **\n", dev_desc->devnum);
                return -1;
        }
 
@@ -716,7 +716,7 @@ int gpt_verify_partitions(struct blk_desc *dev_desc,
 
        for (i = 0; i < parts; i++) {
                if (i == gpt_head->num_partition_entries) {
-                       error("More partitions than allowed!\n");
+                       pr_err("More partitions than allowed!\n");
                        return -1;
                }
 
@@ -729,7 +729,7 @@ int gpt_verify_partitions(struct blk_desc *dev_desc,
 
                if (strncmp(efi_str, (char *)partitions[i].name,
                            sizeof(partitions->name))) {
-                       error("Partition name: %s does not match %s!\n",
+                       pr_err("Partition name: %s does not match %s!\n",
                              efi_str, (char *)partitions[i].name);
                        return -1;
                }
@@ -746,7 +746,7 @@ int gpt_verify_partitions(struct blk_desc *dev_desc,
                        if ((i == parts - 1) && (partitions[i].size == 0))
                                continue;
 
-                       error("Partition %s size: %llu does not match %llu!\n",
+                       pr_err("Partition %s size: %llu does not match %llu!\n",
                              efi_str, (unsigned long long)gpt_part_size,
                              (unsigned long long)partitions[i].size);
                        return -1;
@@ -767,7 +767,7 @@ int gpt_verify_partitions(struct blk_desc *dev_desc,
                      (unsigned long long)partitions[i].start);
 
                if (le64_to_cpu(gpt_e[i].starting_lba) != partitions[i].start) {
-                       error("Partition %s start: %llu does not match %llu!\n",
+                       pr_err("Partition %s start: %llu does not match %llu!\n",
                              efi_str, le64_to_cpu(gpt_e[i].starting_lba),
                              (unsigned long long)partitions[i].start);
                        return -1;
index a5ef722d2137d7e089ee69f727035f4df8d6f89f..a4c20f4d3520d3901a8d68e02c50492ec7d23b85 100644 (file)
@@ -64,7 +64,7 @@ static int adc_supply_enable(struct udevice *dev)
        }
 
        if (ret)
-               error("%s: can't enable %s-supply!", dev->name, supply_type);
+               pr_err("%s: can't enable %s-supply!", dev->name, supply_type);
 
        return ret;
 }
@@ -389,12 +389,12 @@ static int adc_pre_probe(struct udevice *dev)
        /* Set ADC VDD platdata: polarity, uV, regulator (phandle). */
        ret = adc_vdd_platdata_set(dev);
        if (ret)
-               error("%s: Can't update Vdd. Error: %d", dev->name, ret);
+               pr_err("%s: Can't update Vdd. Error: %d", dev->name, ret);
 
        /* Set ADC VSS platdata: polarity, uV, regulator (phandle). */
        ret = adc_vss_platdata_set(dev);
        if (ret)
-               error("%s: Can't update Vss. Error: %d", dev->name, ret);
+               pr_err("%s: Can't update Vss. Error: %d", dev->name, ret);
 
        return 0;
 }
index 324d72f3a95980c1124bdbe3a35f4a8694bf3ca8..3bb065d2155cd78cfb2504331a5e7d3757b75a05 100644 (file)
@@ -22,7 +22,7 @@ int exynos_adc_channel_data(struct udevice *dev, int channel,
        struct exynos_adc_v2 *regs = priv->regs;
 
        if (channel != priv->active_channel) {
-               error("Requested channel is not active!");
+               pr_err("Requested channel is not active!");
                return -EINVAL;
        }
 
@@ -80,7 +80,7 @@ int exynos_adc_probe(struct udevice *dev)
 
        /* Check HW version */
        if (readl(&regs->version) != ADC_V2_VERSION) {
-               error("This driver supports only ADC v2!");
+               pr_err("This driver supports only ADC v2!");
                return -ENXIO;
        }
 
@@ -109,7 +109,7 @@ int exynos_adc_ofdata_to_platdata(struct udevice *dev)
 
        priv->regs = (struct exynos_adc_v2 *)devfdt_get_addr(dev);
        if (priv->regs == (struct exynos_adc_v2 *)FDT_ADDR_T_NONE) {
-               error("Dev: %s - can't get address!", dev->name);
+               pr_err("Dev: %s - can't get address!", dev->name);
                return -ENODATA;
        }
 
index 0e6271d097ab9033c8b8becb689026339932270f..a2856db497dd0b896b6368080b350fbd09aa9b1d 100644 (file)
@@ -46,7 +46,7 @@ int rockchip_saradc_channel_data(struct udevice *dev, int channel,
        struct adc_uclass_platdata *uc_pdata = dev_get_uclass_platdata(dev);
 
        if (channel != priv->active_channel) {
-               error("Requested channel is not active!");
+               pr_err("Requested channel is not active!");
                return -EINVAL;
        }
 
@@ -69,7 +69,7 @@ int rockchip_saradc_start_channel(struct udevice *dev, int channel)
        struct rockchip_saradc_priv *priv = dev_get_priv(dev);
 
        if (channel < 0 || channel >= priv->data->num_channels) {
-               error("Requested channel is invalid!");
+               pr_err("Requested channel is invalid!");
                return -EINVAL;
        }
 
@@ -125,7 +125,7 @@ int rockchip_saradc_ofdata_to_platdata(struct udevice *dev)
        data = (struct rockchip_saradc_data *)dev_get_driver_data(dev);
        priv->regs = (struct rockchip_saradc_regs *)dev_read_addr(dev);
        if (priv->regs == (struct rockchip_saradc_regs *)FDT_ADDR_T_NONE) {
-               error("Dev: %s - can't get address!", dev->name);
+               pr_err("Dev: %s - can't get address!", dev->name);
                return -ENODATA;
        }
 
index 371892237aa429d293d31133c3e4e6a67543d4d9..80e8e3701a3453b41395ba839ef6bb0cf9b116eb 100644 (file)
@@ -61,7 +61,7 @@ int sandbox_adc_channel_data(struct udevice *dev, int channel,
        /* For single-channel conversion mode, check if channel was selected */
        if ((priv->conversion_mode == SANDBOX_ADC_MODE_SINGLE_CHANNEL) &&
            !(priv->active_channel_mask & (1 << channel))) {
-               error("Request for an inactive channel!");
+               pr_err("Request for an inactive channel!");
                return -EINVAL;
        }
 
@@ -82,12 +82,12 @@ int sandbox_adc_channels_data(struct udevice *dev, unsigned int channel_mask,
 
        /* Return error for single-channel conversion mode */
        if (priv->conversion_mode == SANDBOX_ADC_MODE_SINGLE_CHANNEL) {
-               error("ADC in single-channel mode!");
+               pr_err("ADC in single-channel mode!");
                return -EPERM;
        }
        /* Check channel selection */
        if (!(priv->active_channel_mask & channel_mask)) {
-               error("Request for an inactive channel!");
+               pr_err("Request for an inactive channel!");
                return -EINVAL;
        }
        /* The conversion must be started before reading the data */
index f6147989b1c811b01d474c325d6f735428297bbe..b16304baedbdf3dbc518f34f22b102c458fdab02 100644 (file)
@@ -58,19 +58,19 @@ static int dwc_ahci_probe(struct udevice *dev)
 
        ret = generic_phy_get_by_name(dev, "sata-phy", &phy);
        if (ret) {
-               error("can't get the phy from DT\n");
+               pr_err("can't get the phy from DT\n");
                return ret;
        }
 
        ret = generic_phy_init(&phy);
        if (ret) {
-               error("unable to initialize the sata phy\n");
+               pr_err("unable to initialize the sata phy\n");
                return ret;
        }
 
        ret = generic_phy_power_on(&phy);
        if (ret) {
-               error("unable to power on the sata phy\n");
+               pr_err("unable to power on the sata phy\n");
                return ret;
        }
 
index 78f1b759d838388a8fd293c333a856d01658f4e5..5c05e3d78d5b011ade36b4f1e6362c90f1e79efd 100644 (file)
@@ -67,13 +67,13 @@ static int clk_boston_ofdata_to_platdata(struct udevice *dev)
        err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
                                           "regmap", &syscon);
        if (err) {
-               error("unable to find syscon device\n");
+               pr_err("unable to find syscon device\n");
                return err;
        }
 
        state->regmap = syscon_get_regmap(syscon);
        if (!state->regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
index 68d6ba0461d7bfbd8d06c88e95112e05ad4f2246..96a06b8f8cb11525a18cde1ba218c08cddc54e71 100644 (file)
@@ -224,7 +224,7 @@ static unsigned long stm32_clk_get_rate(struct clk *clk)
                return sysclk >>= shift;
                break;
        default:
-               error("clock index %ld out of range\n", clk->id);
+               pr_err("clock index %ld out of range\n", clk->id);
                return -EINVAL;
                break;
        }
index fd0e3ab1005301b5936ba62f7984c8dfd821bef7..931e5ef904ec8de4ca213cd40690d7160c8137a3 100644 (file)
@@ -472,13 +472,13 @@ static ulong stm32_get_rate(struct stm32_rcc_regs *regs, enum pllsrc pllsrc)
        clk.id = 0;
        ret = uclass_get_device_by_name(UCLASS_CLK, name, &fixed_clock_dev);
        if (ret) {
-               error("Can't find clk %s (%d)", name, ret);
+               pr_err("Can't find clk %s (%d)", name, ret);
                return 0;
        }
 
        ret = clk_request(fixed_clock_dev, &clk);
        if (ret) {
-               error("Can't request %s clk (%d)", name, ret);
+               pr_err("Can't request %s clk (%d)", name, ret);
                return 0;
        }
 
@@ -518,7 +518,7 @@ static u32 stm32_get_PLL1_rate(struct stm32_rcc_regs *regs,
                break;
        case RCC_PLLCKSELR_PLLSRC_NO_CLK:
                /* shouldn't happen */
-               error("wrong value for RCC_PLLCKSELR register\n");
+               pr_err("wrong value for RCC_PLLCKSELR register\n");
                pllsrc = 0;
                break;
        }
@@ -695,7 +695,7 @@ static ulong stm32_clk_get_rate(struct clk *clk)
                break;
 
        default:
-               error("unexpected gate_offset value (0x%x)\n", gate_offset);
+               pr_err("unexpected gate_offset value (0x%x)\n", gate_offset);
                return -EINVAL;
                break;
        }
@@ -739,13 +739,13 @@ static int stm32_clk_probe(struct udevice *dev)
                                           "st,syscfg", &syscon);
 
        if (err) {
-               error("unable to find syscon device\n");
+               pr_err("unable to find syscon device\n");
                return err;
        }
 
        priv->pwr_regmap = syscon_get_regmap(syscon);
        if (!priv->pwr_regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
index 3a12be77282b18910368f2849c94a8b28f486735..3661769748f20532fec6e1719b3770a995828ad4 100644 (file)
@@ -302,7 +302,7 @@ static ulong rk3368_ddr_set_clk(struct rk3368_cru *cru, ulong set_rate)
                dpll_cfg = &dpll_1600;
                break;
        default:
-               error("Unsupported SDRAM frequency!,%ld\n", set_rate);
+               pr_err("Unsupported SDRAM frequency!,%ld\n", set_rate);
        }
        rkclk_set_pll(cru, DPLL, dpll_cfg);
 
@@ -360,7 +360,7 @@ static ulong rk3368_spi_get_clk(struct rk3368_cru *cru, ulong clk_id)
                break;
 
        default:
-               error("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
+               pr_err("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
                return -EINVAL;
        }
 
@@ -385,7 +385,7 @@ static ulong rk3368_spi_set_clk(struct rk3368_cru *cru, ulong clk_id, uint hz)
                break;
 
        default:
-               error("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
+               pr_err("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
                return -EINVAL;
        }
 
@@ -530,7 +530,7 @@ static int rk3368_clk_bind(struct udevice *dev)
        /* The reset driver does not have a device node, so bind it here */
        ret = device_bind_driver(gd->dm_root, "rk3368_sysreset", "reset", &dev);
        if (ret)
-               error("bind RK3368 reset driver failed: ret=%d\n", ret);
+               pr_err("bind RK3368 reset driver failed: ret=%d\n", ret);
 
        return ret;
 }
index 50faf5d193563a05a693cd866e80e6f50f75dc91..f45bba44f13ec46804501ff6cb71cf7312e34e3e 100644 (file)
@@ -663,7 +663,7 @@ static ulong rk3399_spi_get_clk(struct rk3399_cru *cru, ulong clk_id)
                break;
 
        default:
-               error("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
+               pr_err("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
                return -EINVAL;
        }
 
@@ -687,7 +687,7 @@ static ulong rk3399_spi_set_clk(struct rk3399_cru *cru, ulong clk_id, uint hz)
                break;
 
        default:
-               error("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
+               pr_err("%s: SPI clk-id %ld not supported\n", __func__, clk_id);
                return -EINVAL;
        }
 
@@ -856,7 +856,7 @@ static ulong rk3399_ddr_set_clk(struct rk3399_cru *cru,
                {.refdiv = 1, .fbdiv = 116, .postdiv1 = 3, .postdiv2 = 1};
                break;
        default:
-               error("Unsupported SDRAM frequency!,%ld\n", set_rate);
+               pr_err("Unsupported SDRAM frequency!,%ld\n", set_rate);
        }
        rkclk_set_pll(&cru->dpll_con[0], &dpll_cfg);
 
index 86e73e414cf971bfe138b58919665ae2d28c5d48..55741c3a1e23ccde8770fa1c31d07b4d2e12fc51 100644 (file)
@@ -227,7 +227,7 @@ static int rv1108_clk_bind(struct udevice *dev)
        /* The reset driver does not have a device node, so bind it here */
        ret = device_bind_driver(gd->dm_root, "rv1108_sysreset", "reset", &dev);
        if (ret)
-               error("No Rv1108 reset driver: ret=%d\n", ret);
+               pr_err("No Rv1108 reset driver: ret=%d\n", ret);
 
        return 0;
 }
index ff732ac309fe2aa1604652fbd43a4a2a3caffb0d..2c22b625b8bdff3eeecc4d932570a711e8936b16 100644 (file)
@@ -64,14 +64,14 @@ int dfu_init_env_entities(char *interface, char *devstr)
 #endif
        str_env = env_get("dfu_alt_info");
        if (!str_env) {
-               error("\"dfu_alt_info\" env variable not defined!\n");
+               pr_err("\"dfu_alt_info\" env variable not defined!\n");
                return -EINVAL;
        }
 
        env_bkp = strdup(str_env);
        ret = dfu_config_entities(env_bkp, interface, devstr);
        if (ret) {
-               error("DFU entities configuration failed!\n");
+               pr_err("DFU entities configuration failed!\n");
                return ret;
        }
 
@@ -132,7 +132,7 @@ static char *dfu_get_hash_algo(void)
                return s;
        }
 
-       error("DFU hash method: %s not supported!\n", s);
+       pr_err("DFU hash method: %s not supported!\n", s);
        return NULL;
 }
 
@@ -273,7 +273,7 @@ int dfu_write(struct dfu_entity *dfu, void *buf, int size, int blk_seq_num)
 
        /* we should be in buffer now (if not then size too large) */
        if ((dfu->i_buf + size) > dfu->i_buf_end) {
-               error("Buffer overflow! (0x%p + 0x%x > 0x%p)\n", dfu->i_buf,
+               pr_err("Buffer overflow! (0x%p + 0x%x > 0x%p)\n", dfu->i_buf,
                      size, dfu->i_buf_end);
                dfu_transaction_cleanup(dfu);
                return -1;
@@ -451,7 +451,7 @@ int dfu_config_entities(char *env, char *interface, char *devstr)
        if (s) {
                ret = hash_lookup_algo(s, &dfu_hash_algo);
                if (ret)
-                       error("Hash algorithm %s not supported\n", s);
+                       pr_err("Hash algorithm %s not supported\n", s);
        }
 
        dfu = calloc(sizeof(*dfu), dfu_alt_num);
@@ -576,7 +576,7 @@ int dfu_write_from_mem_addr(struct dfu_entity *dfu, void *buf, int size)
                      dp, left, write);
                ret = dfu_write(dfu, dp, write, i);
                if (ret) {
-                       error("DFU write failed\n");
+                       pr_err("DFU write failed\n");
                        return ret;
                }
 
@@ -586,7 +586,7 @@ int dfu_write_from_mem_addr(struct dfu_entity *dfu, void *buf, int size)
 
        ret = dfu_flush(dfu, NULL, 0, i);
        if (ret)
-               error("DFU flush failed!");
+               pr_err("DFU flush failed!");
 
        return ret;
 }
index 39e10b1a5a67ea209af02245c7e5b2437af4905c..47948d369d950b6b131d92aeb9e8e091ad35322a 100644 (file)
@@ -29,7 +29,7 @@ static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
 
        mmc = find_mmc_device(dfu->data.mmc.dev_num);
        if (!mmc) {
-               error("Device MMC %d - not found!", dfu->data.mmc.dev_num);
+               pr_err("Device MMC %d - not found!", dfu->data.mmc.dev_num);
                return -ENODEV;
        }
 
@@ -69,11 +69,11 @@ static int mmc_block_op(enum dfu_op op, struct dfu_entity *dfu,
                               buf);
                break;
        default:
-               error("Operation not supported\n");
+               pr_err("Operation not supported\n");
        }
 
        if (n != blk_count) {
-               error("MMC operation failed");
+               pr_err("MMC operation failed");
                if (dfu->data.mmc.hw_partition >= 0)
                        blk_select_hwpart_devnum(IF_TYPE_MMC,
                                                 dfu->data.mmc.dev_num,
@@ -312,7 +312,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
        for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
                *parg = strsep(&s, " ");
                if (*parg == NULL) {
-                       error("Invalid number of arguments.\n");
+                       pr_err("Invalid number of arguments.\n");
                        return -ENODEV;
                }
        }
@@ -327,13 +327,13 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
 
        mmc = find_mmc_device(dfu->data.mmc.dev_num);
        if (mmc == NULL) {
-               error("Couldn't find MMC device no. %d.\n",
+               pr_err("Couldn't find MMC device no. %d.\n",
                      dfu->data.mmc.dev_num);
                return -ENODEV;
        }
 
        if (mmc_init(mmc)) {
-               error("Couldn't init MMC device.\n");
+               pr_err("Couldn't init MMC device.\n");
                return -ENODEV;
        }
 
@@ -360,7 +360,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
                int mmcpart = third_arg;
 
                if (part_get_info(blk_dev, mmcpart, &partinfo) != 0) {
-                       error("Couldn't find part #%d on mmc device #%d\n",
+                       pr_err("Couldn't find part #%d on mmc device #%d\n",
                              mmcpart, mmcdev);
                        return -ENODEV;
                }
@@ -374,7 +374,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
        } else if (!strcmp(entity_type, "ext4")) {
                dfu->layout = DFU_FS_EXT4;
        } else {
-               error("Memory layout (%s) not supported!\n", entity_type);
+               pr_err("Memory layout (%s) not supported!\n", entity_type);
                return -ENODEV;
        }
 
@@ -397,7 +397,7 @@ int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *devstr, char *s)
                dfu_file_buf = memalign(CONFIG_SYS_CACHELINE_SIZE,
                                        CONFIG_SYS_DFU_MAX_FILE_SIZE);
                if (!dfu_file_buf) {
-                       error("Could not memalign 0x%x bytes",
+                       pr_err("Could not memalign 0x%x bytes",
                              CONFIG_SYS_DFU_MAX_FILE_SIZE);
                        return -ENOMEM;
                }
index 6e3f5316f5ada793bcbcf02be408167a3cca2c37..2b5e05a913eeda5f4ed1b4a8ae501de78ee0d263 100644 (file)
@@ -18,12 +18,12 @@ static int dfu_transfer_medium_ram(enum dfu_op op, struct dfu_entity *dfu,
                                   u64 offset, void *buf, long *len)
 {
        if (dfu->layout != DFU_RAM_ADDR) {
-               error("unsupported layout: %s\n", dfu_get_layout(dfu->layout));
+               pr_err("unsupported layout: %s\n", dfu_get_layout(dfu->layout));
                return  -EINVAL;
        }
 
        if (offset > dfu->data.ram.size) {
-               error("request exceeds allowed area\n");
+               pr_err("request exceeds allowed area\n");
                return -EINVAL;
        }
 
@@ -62,14 +62,14 @@ int dfu_fill_entity_ram(struct dfu_entity *dfu, char *devstr, char *s)
        for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
                *parg = strsep(&s, " ");
                if (*parg == NULL) {
-                       error("Invalid number of arguments.\n");
+                       pr_err("Invalid number of arguments.\n");
                        return -ENODEV;
                }
        }
 
        dfu->dev_type = DFU_DEV_RAM;
        if (strcmp(argv[0], "ram")) {
-               error("unsupported device: %s\n", argv[0]);
+               pr_err("unsupported device: %s\n", argv[0]);
                return -ENODEV;
        }
 
index cd71708231f57744fd895d16ddbc478746db01a7..62bf797dac9f11d26f5c325b457e03ce96565a8f 100644 (file)
@@ -43,7 +43,7 @@ int dfu_tftp_write(char *dfu_entity_name, unsigned int addr, unsigned int len,
        alt_setting_num = dfu_get_alt(sb);
        free(sb);
        if (alt_setting_num < 0) {
-               error("Alt setting [%d] to write not found!",
+               pr_err("Alt setting [%d] to write not found!",
                      alt_setting_num);
                ret = -ENODEV;
                goto done;
@@ -51,7 +51,7 @@ int dfu_tftp_write(char *dfu_entity_name, unsigned int addr, unsigned int len,
 
        dfu = dfu_get_entity(alt_setting_num);
        if (!dfu) {
-               error("DFU entity for alt: %d not found!", alt_setting_num);
+               pr_err("DFU entity for alt: %d not found!", alt_setting_num);
                ret = -ENODEV;
                goto done;
        }
index ea21fd9c6febdc0b08064419cbc178805ea09250..3d0ce22fbc2186c0caab158a00394081663b5a21 100644 (file)
@@ -33,7 +33,7 @@ int dma_get_device(u32 transfer_type, struct udevice **devp)
        }
 
        if (!dev) {
-               error("No DMA device found that supports %x type\n",
+               pr_err("No DMA device found that supports %x type\n",
                      transfer_type);
                return -EPROTONOSUPPORT;
        }
index 955adfeccda1e565c14eeee9cbcd7b785520a924..63a8a2f34080f96af695c2274c3b637cac48fdb3 100644 (file)
@@ -96,7 +96,7 @@ int lpc32xx_dma_start_xfer(unsigned int channel,
 {
        if (unlikely(((BIT_MASK(channel) & alloc_ch) == 0) ||
                     (channel >= DMA_NO_OF_CHANNELS))) {
-               error("Request for xfer on unallocated channel %d", channel);
+               pr_err("Request for xfer on unallocated channel %d", channel);
                return -1;
        }
        writel(BIT_MASK(channel), &dma->int_tc_clear);
@@ -117,7 +117,7 @@ int lpc32xx_dma_wait_status(unsigned int channel)
 
        /* Check if given channel is valid */
        if (unlikely(channel >= DMA_NO_OF_CHANNELS)) {
-               error("Request for status on unallocated channel %d", channel);
+               pr_err("Request for status on unallocated channel %d", channel);
                return -1;
        }
 
@@ -129,7 +129,7 @@ int lpc32xx_dma_wait_status(unsigned int channel)
                        break;
 
                if (get_timer(start) > CONFIG_SYS_HZ) {
-                       error("DMA status timeout channel %d\n", channel);
+                       pr_err("DMA status timeout channel %d\n", channel);
                        return -ETIMEDOUT;
                }
                udelay(1);
@@ -138,7 +138,7 @@ int lpc32xx_dma_wait_status(unsigned int channel)
        if (unlikely(readl(&dma->raw_err_stat) & BIT_MASK(channel))) {
                setbits_le32(&dma->int_err_clear, BIT_MASK(channel));
                setbits_le32(&dma->raw_err_stat, BIT_MASK(channel));
-               error("DMA error on channel %d\n", channel);
+               pr_err("DMA error on channel %d\n", channel);
                return -1;
        }
        setbits_le32(&dma->int_tc_clear, BIT_MASK(channel));
index 39e97930135a18576cae6b9dc4b94776f01b2189..635eb7876d5526965a1fcf3584bdfb5dd2c3bd89 100644 (file)
@@ -491,7 +491,7 @@ static int ti_edma3_transfer(struct udevice *dev, int direction, void *dst,
                __edma3_transfer(priv->base, 1, dst, src, len);
                break;
        default:
-               error("Transfer type not implemented in DMA driver\n");
+               pr_err("Transfer type not implemented in DMA driver\n");
                break;
        }
 
index aeeb304a876f13a44cbac1d0ccbecc1523b9b9a0..4e8fa214739a4bee0faa963bac3717f5090a9aae 100644 (file)
@@ -322,7 +322,7 @@ static int i2c_gpio_ofdata_to_platdata(struct udevice *dev)
 
        return 0;
 error:
-       error("Can't get %s gpios! Error: %d", dev->name, ret);
+       pr_err("Can't get %s gpios! Error: %d", dev->name, ret);
        return ret;
 }
 
index c98c6276ddb48aab605e567cee21c99ed9299645..5d33815146216910f66a6a4cf91cd5b2447a06dd 100644 (file)
@@ -755,7 +755,7 @@ static uint omap24_i2c_setspeed(struct i2c_adapter *adap, uint speed)
 
        ret = __omap24_i2c_setspeed(i2c_base, speed, &adap->waitdelay);
        if (ret) {
-               error("%s: set i2c speed failed\n", __func__);
+               pr_err("%s: set i2c speed failed\n", __func__);
                return ret;
        }
 
index bf5fefab7bfb72cb4acb1d5c48c1999819119ed1..196f2365ea5fad60140256b1dc89eed48ea4a5d2 100644 (file)
@@ -549,7 +549,7 @@ static int stm32_i2c_compute_solutions(struct stm32_i2c_setup *setup,
        }
 
        if (list_empty(solutions)) {
-               error("%s: no Prescaler solution\n", __func__);
+               pr_err("%s: no Prescaler solution\n", __func__);
                ret = -EPERM;
        }
 
@@ -627,7 +627,7 @@ static int stm32_i2c_choose_solution(struct stm32_i2c_setup *setup,
        }
 
        if (!s) {
-               error("%s: no solution at all\n", __func__);
+               pr_err("%s: no solution at all\n", __func__);
                ret = -EPERM;
        }
 
@@ -643,14 +643,14 @@ static int stm32_i2c_compute_timing(struct stm32_i2c_priv *i2c_priv,
        int ret;
 
        if (setup->speed >= STM32_I2C_SPEED_END) {
-               error("%s: speed out of bound {%d/%d}\n", __func__,
+               pr_err("%s: speed out of bound {%d/%d}\n", __func__,
                      setup->speed, STM32_I2C_SPEED_END - 1);
                return -EINVAL;
        }
 
        if ((setup->rise_time > i2c_specs[setup->speed].rise_max) ||
            (setup->fall_time > i2c_specs[setup->speed].fall_max)) {
-               error("%s :timings out of bound Rise{%d>%d}/Fall{%d>%d}\n",
+               pr_err("%s :timings out of bound Rise{%d>%d}/Fall{%d>%d}\n",
                      __func__,
                      setup->rise_time, i2c_specs[setup->speed].rise_max,
                      setup->fall_time, i2c_specs[setup->speed].fall_max);
@@ -658,13 +658,13 @@ static int stm32_i2c_compute_timing(struct stm32_i2c_priv *i2c_priv,
        }
 
        if (setup->dnf > STM32_I2C_DNF_MAX) {
-               error("%s: DNF out of bound %d/%d\n", __func__,
+               pr_err("%s: DNF out of bound %d/%d\n", __func__,
                      setup->dnf, STM32_I2C_DNF_MAX);
                return -EINVAL;
        }
 
        if (setup->speed_freq > i2c_specs[setup->speed].rate) {
-               error("%s: Freq {%d/%d}\n", __func__,
+               pr_err("%s: Freq {%d/%d}\n", __func__,
                      setup->speed_freq, i2c_specs[setup->speed].rate);
                return -EINVAL;
        }
@@ -711,7 +711,7 @@ static int stm32_i2c_setup_timing(struct stm32_i2c_priv *i2c_priv,
        setup->clock_src = clk_get_rate(&i2c_priv->clk);
 
        if (!setup->clock_src) {
-               error("%s: clock rate is 0\n", __func__);
+               pr_err("%s: clock rate is 0\n", __func__);
                return -EINVAL;
        }
 
@@ -734,7 +734,7 @@ static int stm32_i2c_setup_timing(struct stm32_i2c_priv *i2c_priv,
        } while (ret);
 
        if (ret) {
-               error("%s: impossible to compute I2C timings.\n", __func__);
+               pr_err("%s: impossible to compute I2C timings.\n", __func__);
                return ret;
        }
 
index 3255e8ed37090f201b1b70845214576f9bdde8ae..7d23e51b69d2158ac7942cd936c045eb1a269060 100644 (file)
@@ -372,12 +372,12 @@ static int tegra_i2c_probe(struct udevice *dev)
 
        ret = reset_get_by_name(dev, "i2c", &i2c_bus->reset_ctl);
        if (ret) {
-               error("reset_get_by_name() failed: %d\n", ret);
+               pr_err("reset_get_by_name() failed: %d\n", ret);
                return ret;
        }
        ret = clk_get_by_name(dev, "div-clk", &i2c_bus->clk);
        if (ret) {
-               error("clk_get_by_name() failed: %d\n", ret);
+               pr_err("clk_get_by_name() failed: %d\n", ret);
                return ret;
        }
 
index d61bacfc44f2fbcc8dba608e76d499d08524d2c9..1fdf8efff3b9eb9b44b92156d243f2ec2be33ad4 100644 (file)
@@ -44,7 +44,7 @@ static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
 
        ret = tegra_ivc_write_get_next_frame(&priv->ivc, &ivc_frame);
        if (ret) {
-               error("tegra_ivc_write_get_next_frame() failed: %d\n", ret);
+               pr_err("tegra_ivc_write_get_next_frame() failed: %d\n", ret);
                return ret;
        }
 
@@ -55,7 +55,7 @@ static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
 
        ret = tegra_ivc_write_advance(&priv->ivc);
        if (ret) {
-               error("tegra_ivc_write_advance() failed: %d\n", ret);
+               pr_err("tegra_ivc_write_advance() failed: %d\n", ret);
                return ret;
        }
 
@@ -63,7 +63,7 @@ static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
        for (;;) {
                ret = tegra_ivc_channel_notified(&priv->ivc);
                if (ret) {
-                       error("tegra_ivc_channel_notified() failed: %d\n", ret);
+                       pr_err("tegra_ivc_channel_notified() failed: %d\n", ret);
                        return ret;
                }
 
@@ -73,7 +73,7 @@ static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
 
                /* Timeout 20ms; roughly 10x current max observed duration */
                if ((timer_get_us() - start_time) > 20 * 1000) {
-                       error("tegra_ivc_read_get_next_frame() timed out (%d)\n",
+                       pr_err("tegra_ivc_read_get_next_frame() timed out (%d)\n",
                              ret);
                        return -ETIMEDOUT;
                }
@@ -86,12 +86,12 @@ static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
 
        ret = tegra_ivc_read_advance(&priv->ivc);
        if (ret) {
-               error("tegra_ivc_write_advance() failed: %d\n", ret);
+               pr_err("tegra_ivc_write_advance() failed: %d\n", ret);
                return ret;
        }
 
        if (err) {
-               error("BPMP responded with error %d\n", err);
+               pr_err("BPMP responded with error %d\n", err);
                /* err isn't a U-Boot error code, so don't that */
                return -EIO;
        }
@@ -144,14 +144,14 @@ static ulong tegra186_bpmp_get_shmem(struct udevice *dev, int index)
        ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev_of_offset(dev),
                                              "shmem", NULL, 0, index, &args);
        if (ret < 0) {
-               error("fdtdec_parse_phandle_with_args() failed: %d\n", ret);
+               pr_err("fdtdec_parse_phandle_with_args() failed: %d\n", ret);
                return ret;
        }
 
        reg = fdtdec_get_addr_size_auto_noparent(gd->fdt_blob, args.node,
                                                 "reg", 0, NULL, true);
        if (reg == FDT_ADDR_T_NONE) {
-               error("fdtdec_get_addr_size_auto_noparent() failed\n");
+               pr_err("fdtdec_get_addr_size_auto_noparent() failed\n");
                return -ENODEV;
        }
 
@@ -166,7 +166,7 @@ static void tegra186_bpmp_ivc_notify(struct tegra_ivc *ivc)
 
        ret = mbox_send(&priv->mbox, NULL);
        if (ret)
-               error("mbox_send() failed: %d\n", ret);
+               pr_err("mbox_send() failed: %d\n", ret);
 }
 
 static int tegra186_bpmp_probe(struct udevice *dev)
@@ -179,18 +179,18 @@ static int tegra186_bpmp_probe(struct udevice *dev)
 
        ret = mbox_get_by_index(dev, 0, &priv->mbox);
        if (ret) {
-               error("mbox_get_by_index() failed: %d\n", ret);
+               pr_err("mbox_get_by_index() failed: %d\n", ret);
                return ret;
        }
 
        tx_base = tegra186_bpmp_get_shmem(dev, 0);
        if (IS_ERR_VALUE(tx_base)) {
-               error("tegra186_bpmp_get_shmem failed for tx_base\n");
+               pr_err("tegra186_bpmp_get_shmem failed for tx_base\n");
                return tx_base;
        }
        rx_base = tegra186_bpmp_get_shmem(dev, 1);
        if (IS_ERR_VALUE(rx_base)) {
-               error("tegra186_bpmp_get_shmem failed for rx_base\n");
+               pr_err("tegra186_bpmp_get_shmem failed for rx_base\n");
                return rx_base;
        }
        debug("shmem: rx=%lx, tx=%lx\n", rx_base, tx_base);
@@ -198,7 +198,7 @@ static int tegra186_bpmp_probe(struct udevice *dev)
        ret = tegra_ivc_init(&priv->ivc, rx_base, tx_base, BPMP_IVC_FRAME_COUNT,
                             BPMP_IVC_FRAME_SIZE, tegra186_bpmp_ivc_notify);
        if (ret) {
-               error("tegra_ivc_init() failed: %d\n", ret);
+               pr_err("tegra_ivc_init() failed: %d\n", ret);
                return ret;
        }
 
@@ -211,7 +211,7 @@ static int tegra186_bpmp_probe(struct udevice *dev)
 
                /* Timeout 100ms */
                if ((timer_get_us() - start_time) > 100 * 1000) {
-                       error("Initial IVC reset timed out (%d)\n", ret);
+                       pr_err("Initial IVC reset timed out (%d)\n", ret);
                        ret = -ETIMEDOUT;
                        goto err_free_mbox;
                }
index 40f7892ac80b757ef95ca723a1495d56110f3a93..5edd383c68484e2096e6ca785039a90e42baee5e 100644 (file)
@@ -155,7 +155,7 @@ static int exynos_dwmci_get_config(const void *blob, int node,
 
        priv = malloc(sizeof(struct dwmci_exynos_priv_data));
        if (!priv) {
-               error("dwmci_exynos_priv_data malloc fail!\n");
+               pr_err("dwmci_exynos_priv_data malloc fail!\n");
                return -ENOMEM;
        }
 
index d795198534b7724d76bddbd506c2e81f4c20bc21..44a8ef825f32c55251d69b86c9fedb677b1f7c63 100644 (file)
@@ -44,7 +44,7 @@ int hi6220_dwmci_add_port(int index, u32 regbase, int bus_width)
 
        host = calloc(1, sizeof(struct dwmci_host));
        if (!host) {
-               error("dwmci_host calloc failed!\n");
+               pr_err("dwmci_host calloc failed!\n");
                return -ENOMEM;
        }
 
index d8b5888b7ce29860e029f9bf334c35fa7010e4f1..a98c1eba0f66eb1f54d6a234508b6f268be9ed7b 100644 (file)
@@ -43,7 +43,7 @@ static int sti_mmc_core_config(struct udevice *dev)
        if (plat->instance) {
                ret = reset_deassert(&plat->reset);
                if (ret < 0) {
-                       error("MMC1 deassert failed: %d", ret);
+                       pr_err("MMC1 deassert failed: %d", ret);
                        return ret;
                }
        }
index 0e1f40b569f0327ae2fa5b3f758a82920a5ea843..0bf7135b4ff2ffcfa33d4486565600f382ea3de2 100644 (file)
@@ -569,7 +569,7 @@ static int stm32_sdmmc2_probe(struct udevice *dev)
        case 1:
                break;
        default:
-               error("invalid \"bus-width\" property, force to 1\n");
+               pr_err("invalid \"bus-width\" property, force to 1\n");
        }
 
        upriv->mmc = &plat->mmc;
index 2b7cb7f6b66ab0fe4df9226ddc1fc80d53da0c8b..490a01f9bdb80ce3f6475c3c15adf4a5e97b8a75 100644 (file)
@@ -159,7 +159,7 @@ static int xenon_mmc_phy_init(struct sdhci_host *host)
        }
 
        if (time <= 0) {
-               error("Failed to enable MMC internal clock in time\n");
+               pr_err("Failed to enable MMC internal clock in time\n");
                return -ETIMEDOUT;
        }
 
@@ -187,7 +187,7 @@ static int xenon_mmc_phy_init(struct sdhci_host *host)
        }
 
        if (time <= 0) {
-               error("Failed to init MMC PHY in time\n");
+               pr_err("Failed to init MMC PHY in time\n");
                return -ETIMEDOUT;
        }
 
index 3af7e6dfac69e0d67ed04685386fe95ca5cffbcc..e1b36706cab3c2a673b7c0a3e11ca2b3cfb51cc2 100644 (file)
@@ -583,21 +583,21 @@ void board_nand_init(void)
        /* identify chip */
        ret = nand_scan_ident(mtd, CONFIG_SYS_MAX_NAND_CHIPS, NULL);
        if (ret) {
-               error("nand_scan_ident returned %i", ret);
+               pr_err("nand_scan_ident returned %i", ret);
                return;
        }
 
        /* finish scanning the chip */
        ret = nand_scan_tail(mtd);
        if (ret) {
-               error("nand_scan_tail returned %i", ret);
+               pr_err("nand_scan_tail returned %i", ret);
                return;
        }
 
        /* chip is good, register it */
        ret = nand_register(0, mtd);
        if (ret)
-               error("nand_register returned %i", ret);
+               pr_err("nand_register returned %i", ret);
 }
 
 #else /* defined(CONFIG_SPL_BUILD) */
index 0042a7ba11df12a82c18a372d7c495deaf169b8a..6ab3c8a25add16857e225440f42ee381395046e4 100644 (file)
@@ -1559,7 +1559,7 @@ static int pxa3xx_nand_probe_dt(struct pxa3xx_nand_info *info)
 
                pdata->num_cs = fdtdec_get_int(blob, node, "num-cs", 1);
                if (pdata->num_cs != 1) {
-                       error("pxa3xx driver supports single CS only\n");
+                       pr_err("pxa3xx driver supports single CS only\n");
                        break;
                }
 
index 9ff72fa1edc7d5d1ba19299289a81abc851621d1..a2b594ed739af7de7a577699b57648568e1c652a 100644 (file)
@@ -610,7 +610,7 @@ int gmac_miiphy_read(struct mii_dev *bus, int phyaddr, int devad, int reg)
 
        /* Busy wait timeout is 1ms */
        if (gmac_mii_busywait(1000)) {
-               error("%s: Prepare MII read: MII/MDIO busy\n", __func__);
+               pr_err("%s: Prepare MII read: MII/MDIO busy\n", __func__);
                return -1;
        }
 
@@ -622,7 +622,7 @@ int gmac_miiphy_read(struct mii_dev *bus, int phyaddr, int devad, int reg)
        writel(tmp, GMAC_MII_DATA_ADDR);
 
        if (gmac_mii_busywait(1000)) {
-               error("%s: MII read failure: MII/MDIO busy\n", __func__);
+               pr_err("%s: MII read failure: MII/MDIO busy\n", __func__);
                return -1;
        }
 
@@ -638,7 +638,7 @@ int gmac_miiphy_write(struct mii_dev *bus, int phyaddr, int devad, int reg,
 
        /* Busy wait timeout is 1ms */
        if (gmac_mii_busywait(1000)) {
-               error("%s: Prepare MII write: MII/MDIO busy\n", __func__);
+               pr_err("%s: Prepare MII write: MII/MDIO busy\n", __func__);
                return -1;
        }
 
@@ -651,7 +651,7 @@ int gmac_miiphy_write(struct mii_dev *bus, int phyaddr, int devad, int reg,
        writel(tmp, GMAC_MII_DATA_ADDR);
 
        if (gmac_mii_busywait(1000)) {
-               error("%s: MII write failure: MII/MDIO busy\n", __func__);
+               pr_err("%s: MII write failure: MII/MDIO busy\n", __func__);
                return -1;
        }
 
@@ -742,7 +742,7 @@ int gmac_set_speed(int speed, int duplex)
        } else if (speed == 10) {
                speed_cfg = 0;
        } else {
-               error("%s: Invalid GMAC speed(%d)!\n", __func__, speed);
+               pr_err("%s: Invalid GMAC speed(%d)!\n", __func__, speed);
                return -1;
        }
 
@@ -820,7 +820,7 @@ int gmac_mac_init(struct eth_device *dev)
        writel(0, GMAC0_INT_STATUS_ADDR);
 
        if (dma_init(dma) < 0) {
-               error("%s: GMAC dma_init failed\n", __func__);
+               pr_err("%s: GMAC dma_init failed\n", __func__);
                goto err_exit;
        }
 
@@ -855,7 +855,7 @@ int gmac_mac_init(struct eth_device *dev)
        writel(tmp, GMAC_MII_CTRL_ADDR);
 
        if (gmac_mii_busywait(1000)) {
-               error("%s: Configure MDIO: MII/MDIO busy\n", __func__);
+               pr_err("%s: Configure MDIO: MII/MDIO busy\n", __func__);
                goto err_exit;
        }
 
index e2747365a20b3d46389bb7384bc4c66e9de5c47c..9056f71b9aceb3732dd4a8fe9da1243d23779d21 100644 (file)
@@ -40,7 +40,7 @@ static int bcm_sf2_eth_init(struct eth_device *dev)
 
        rc = eth->mac_init(dev);
        if (rc) {
-               error("%s: Couldn't cofigure MAC!\n", __func__);
+               pr_err("%s: Couldn't cofigure MAC!\n", __func__);
                return rc;
        }
 
@@ -90,7 +90,7 @@ static int bcm_sf2_eth_send(struct eth_device *dev, void *packet, int length)
                debug(".");
                i++;
                if (i > 20) {
-                       error("%s: Tx timeout: retried 20 times\n", __func__);
+                       pr_err("%s: Tx timeout: retried 20 times\n", __func__);
                        rc = -1;
                        break;
                }
@@ -117,7 +117,7 @@ static int bcm_sf2_eth_receive(struct eth_device *dev)
                        debug("\nNO More Rx\n");
                        break;
                } else if ((rcvlen == 0) || (rcvlen > RX_BUF_SIZE)) {
-                       error("%s: Wrong Ethernet packet size (%d B), skip!\n",
+                       pr_err("%s: Wrong Ethernet packet size (%d B), skip!\n",
                              __func__, rcvlen);
                        break;
                } else {
@@ -166,9 +166,9 @@ static int bcm_sf2_eth_open(struct eth_device *dev, bd_t *bt)
         */
        for (i = 0; i < eth->port_num; i++) {
                if (phy_startup(eth->port[i])) {
-                       error("%s: PHY %d startup failed!\n", __func__, i);
+                       pr_err("%s: PHY %d startup failed!\n", __func__, i);
                        if (i == CONFIG_BCM_SF2_ETH_DEFAULT_PORT) {
-                               error("%s: No default port %d!\n", __func__, i);
+                               pr_err("%s: No default port %d!\n", __func__, i);
                                return -1;
                        }
                }
@@ -205,13 +205,13 @@ int bcm_sf2_eth_register(bd_t *bis, u8 dev_num)
 
        dev = (struct eth_device *)malloc(sizeof(struct eth_device));
        if (dev == NULL) {
-               error("%s: Not enough memory!\n", __func__);
+               pr_err("%s: Not enough memory!\n", __func__);
                return -1;
        }
 
        eth = (struct eth_info *)malloc(sizeof(struct eth_info));
        if (eth == NULL) {
-               error("%s: Not enough memory!\n", __func__);
+               pr_err("%s: Not enough memory!\n", __func__);
                return -1;
        }
 
@@ -234,7 +234,7 @@ int bcm_sf2_eth_register(bd_t *bis, u8 dev_num)
        if (gmac_add(dev)) {
                free(eth);
                free(dev);
-               error("%s: Adding GMAC failed!\n", __func__);
+               pr_err("%s: Adding GMAC failed!\n", __func__);
                return -1;
        }
 #else
@@ -263,7 +263,7 @@ int bcm_sf2_eth_register(bd_t *bis, u8 dev_num)
 
        rc = bcm_sf2_eth_init(dev);
        if (rc != 0) {
-               error("%s: configuration failed!\n", __func__);
+               pr_err("%s: configuration failed!\n", __func__);
                return -1;
        }
 
index 8970ee00af30b23caa4343cb7637258ec89723ed..0dc83ab820522bcd870e4fb30b9a83644284b59a 100644 (file)
@@ -29,14 +29,14 @@ static int davinci_emac_3517_get_macid(struct udevice *dev, u16 offset,
 
        syscon = fdtdec_lookup_phandle(fdt, node, "syscon");
        if (syscon < 0) {
-               error("Syscon offset not found\n");
+               pr_err("Syscon offset not found\n");
                return -ENOENT;
        }
 
        addr = (u32)map_physmem(fdt_translate_address(fdt, syscon, &gmii),
                                sizeof(u32), MAP_NOCACHE);
        if (addr == FDT_ADDR_T_NONE) {
-               error("Not able to get syscon address to get mac efuse address\n");
+               pr_err("Not able to get syscon address to get mac efuse address\n");
                return -ENOENT;
        }
 
@@ -69,14 +69,14 @@ static int cpsw_am33xx_cm_get_macid(struct udevice *dev, u16 offset, int slave,
 
        syscon = fdtdec_lookup_phandle(fdt, node, "syscon");
        if (syscon < 0) {
-               error("Syscon offset not found\n");
+               pr_err("Syscon offset not found\n");
                return -ENOENT;
        }
 
        addr = (u32)map_physmem(fdt_translate_address(fdt, syscon, &gmii),
                                sizeof(u32), MAP_NOCACHE);
        if (addr == FDT_ADDR_T_NONE) {
-               error("Not able to get syscon address to get mac efuse address\n");
+               pr_err("Not able to get syscon address to get mac efuse address\n");
                return -ENOENT;
        }
 
index d7db0fc432f7a93996cfbfd40439699f6de54e86..b72258f83bfec9694d42637da38620e35b1c09ed 100644 (file)
@@ -1368,7 +1368,7 @@ static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)
 
                        mdio_base = cpsw_get_addr_by_node(fdt, subnode);
                        if (mdio_base == FDT_ADDR_T_NONE) {
-                               error("Not able to get MDIO address space\n");
+                               pr_err("Not able to get MDIO address space\n");
                                return -ENOENT;
                        }
                        priv->data.mdio_base = mdio_base;
@@ -1407,7 +1407,7 @@ static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)
                                                                    subnode);
 
                        if (priv->data.gmii_sel == FDT_ADDR_T_NONE) {
-                               error("Not able to get gmii_sel reg address\n");
+                               pr_err("Not able to get gmii_sel reg address\n");
                                return -ENOENT;
                        }
 
@@ -1418,7 +1418,7 @@ static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)
                        phy_sel_compat = fdt_getprop(fdt, subnode, "compatible",
                                                     NULL);
                        if (!phy_sel_compat) {
-                               error("Not able to get gmii_sel compatible\n");
+                               pr_err("Not able to get gmii_sel compatible\n");
                                return -ENOENT;
                        }
                }
@@ -1434,7 +1434,7 @@ static int cpsw_eth_ofdata_to_platdata(struct udevice *dev)
 
        ret = ti_cm_get_macid(dev, active_slave, pdata->enetaddr);
        if (ret < 0) {
-               error("cpsw read efuse mac failed\n");
+               pr_err("cpsw read efuse mac failed\n");
                return ret;
        }
 
index 5c4315ffeaad57e340295aa19583b49a40bbb411..00076cffbed2869a96fa33cc85ae60ea38ac64bd 100644 (file)
@@ -377,7 +377,7 @@ static int eqos_mdio_read(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 
        ret = eqos_mdio_wait_idle(eqos);
        if (ret) {
-               error("MDIO not idle at entry");
+               pr_err("MDIO not idle at entry");
                return ret;
        }
 
@@ -397,7 +397,7 @@ static int eqos_mdio_read(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 
        ret = eqos_mdio_wait_idle(eqos);
        if (ret) {
-               error("MDIO read didn't complete");
+               pr_err("MDIO read didn't complete");
                return ret;
        }
 
@@ -421,7 +421,7 @@ static int eqos_mdio_write(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 
        ret = eqos_mdio_wait_idle(eqos);
        if (ret) {
-               error("MDIO not idle at entry");
+               pr_err("MDIO not idle at entry");
                return ret;
        }
 
@@ -443,7 +443,7 @@ static int eqos_mdio_write(struct mii_dev *bus, int mdio_addr, int mdio_devad,
 
        ret = eqos_mdio_wait_idle(eqos);
        if (ret) {
-               error("MDIO read didn't complete");
+               pr_err("MDIO read didn't complete");
                return ret;
        }
 
@@ -459,37 +459,37 @@ static int eqos_start_clks_tegra186(struct udevice *dev)
 
        ret = clk_enable(&eqos->clk_slave_bus);
        if (ret < 0) {
-               error("clk_enable(clk_slave_bus) failed: %d", ret);
+               pr_err("clk_enable(clk_slave_bus) failed: %d", ret);
                goto err;
        }
 
        ret = clk_enable(&eqos->clk_master_bus);
        if (ret < 0) {
-               error("clk_enable(clk_master_bus) failed: %d", ret);
+               pr_err("clk_enable(clk_master_bus) failed: %d", ret);
                goto err_disable_clk_slave_bus;
        }
 
        ret = clk_enable(&eqos->clk_rx);
        if (ret < 0) {
-               error("clk_enable(clk_rx) failed: %d", ret);
+               pr_err("clk_enable(clk_rx) failed: %d", ret);
                goto err_disable_clk_master_bus;
        }
 
        ret = clk_enable(&eqos->clk_ptp_ref);
        if (ret < 0) {
-               error("clk_enable(clk_ptp_ref) failed: %d", ret);
+               pr_err("clk_enable(clk_ptp_ref) failed: %d", ret);
                goto err_disable_clk_rx;
        }
 
        ret = clk_set_rate(&eqos->clk_ptp_ref, 125 * 1000 * 1000);
        if (ret < 0) {
-               error("clk_set_rate(clk_ptp_ref) failed: %d", ret);
+               pr_err("clk_set_rate(clk_ptp_ref) failed: %d", ret);
                goto err_disable_clk_ptp_ref;
        }
 
        ret = clk_enable(&eqos->clk_tx);
        if (ret < 0) {
-               error("clk_enable(clk_tx) failed: %d", ret);
+               pr_err("clk_enable(clk_tx) failed: %d", ret);
                goto err_disable_clk_ptp_ref;
        }
 
@@ -533,7 +533,7 @@ static int eqos_start_resets_tegra186(struct udevice *dev)
 
        ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 1);
        if (ret < 0) {
-               error("dm_gpio_set_value(phy_reset, assert) failed: %d", ret);
+               pr_err("dm_gpio_set_value(phy_reset, assert) failed: %d", ret);
                return ret;
        }
 
@@ -541,13 +541,13 @@ static int eqos_start_resets_tegra186(struct udevice *dev)
 
        ret = dm_gpio_set_value(&eqos->phy_reset_gpio, 0);
        if (ret < 0) {
-               error("dm_gpio_set_value(phy_reset, deassert) failed: %d", ret);
+               pr_err("dm_gpio_set_value(phy_reset, deassert) failed: %d", ret);
                return ret;
        }
 
        ret = reset_assert(&eqos->reset_ctl);
        if (ret < 0) {
-               error("reset_assert() failed: %d", ret);
+               pr_err("reset_assert() failed: %d", ret);
                return ret;
        }
 
@@ -555,7 +555,7 @@ static int eqos_start_resets_tegra186(struct udevice *dev)
 
        ret = reset_deassert(&eqos->reset_ctl);
        if (ret < 0) {
-               error("reset_deassert() failed: %d", ret);
+               pr_err("reset_deassert() failed: %d", ret);
                return ret;
        }
 
@@ -591,14 +591,14 @@ static int eqos_calibrate_pads_tegra186(struct udevice *dev)
        ret = wait_for_bit(__func__, &eqos->tegra186_regs->auto_cal_status,
                           EQOS_AUTO_CAL_STATUS_ACTIVE, true, 10, false);
        if (ret) {
-               error("calibrate didn't start");
+               pr_err("calibrate didn't start");
                goto failed;
        }
 
        ret = wait_for_bit(__func__, &eqos->tegra186_regs->auto_cal_status,
                           EQOS_AUTO_CAL_STATUS_ACTIVE, false, 10, false);
        if (ret) {
-               error("calibrate didn't finish");
+               pr_err("calibrate didn't finish");
                goto failed;
        }
 
@@ -713,13 +713,13 @@ static int eqos_set_tx_clk_speed_tegra186(struct udevice *dev)
                rate = 2.5 * 1000 * 1000;
                break;
        default:
-               error("invalid speed %d", eqos->phy->speed);
+               pr_err("invalid speed %d", eqos->phy->speed);
                return -EINVAL;
        }
 
        ret = clk_set_rate(&eqos->clk_tx, rate);
        if (ret < 0) {
-               error("clk_set_rate(tx_clk, %lu) failed: %d", rate, ret);
+               pr_err("clk_set_rate(tx_clk, %lu) failed: %d", rate, ret);
                return ret;
        }
 
@@ -739,7 +739,7 @@ static int eqos_adjust_link(struct udevice *dev)
        else
                ret = eqos_set_half_duplex(dev);
        if (ret < 0) {
-               error("eqos_set_*_duplex() failed: %d", ret);
+               pr_err("eqos_set_*_duplex() failed: %d", ret);
                return ret;
        }
 
@@ -757,24 +757,24 @@ static int eqos_adjust_link(struct udevice *dev)
                ret = eqos_set_mii_speed_10(dev);
                break;
        default:
-               error("invalid speed %d", eqos->phy->speed);
+               pr_err("invalid speed %d", eqos->phy->speed);
                return -EINVAL;
        }
        if (ret < 0) {
-               error("eqos_set_*mii_speed*() failed: %d", ret);
+               pr_err("eqos_set_*mii_speed*() failed: %d", ret);
                return ret;
        }
 
        if (en_calibration) {
                ret = eqos_calibrate_pads_tegra186(dev);
                if (ret < 0) {
-                       error("eqos_calibrate_pads_tegra186() failed: %d", ret);
+                       pr_err("eqos_calibrate_pads_tegra186() failed: %d", ret);
                        return ret;
                }
        } else {
                ret = eqos_disable_calibration_tegra186(dev);
                if (ret < 0) {
-                       error("eqos_disable_calibration_tegra186() failed: %d",
+                       pr_err("eqos_disable_calibration_tegra186() failed: %d",
                              ret);
                        return ret;
                }
@@ -782,7 +782,7 @@ static int eqos_adjust_link(struct udevice *dev)
 
        ret = eqos_set_tx_clk_speed_tegra186(dev);
        if (ret < 0) {
-               error("eqos_set_tx_clk_speed_tegra186() failed: %d", ret);
+               pr_err("eqos_set_tx_clk_speed_tegra186() failed: %d", ret);
                return ret;
        }
 
@@ -848,13 +848,13 @@ static int eqos_start(struct udevice *dev)
 
        ret = eqos_start_clks_tegra186(dev);
        if (ret < 0) {
-               error("eqos_start_clks_tegra186() failed: %d", ret);
+               pr_err("eqos_start_clks_tegra186() failed: %d", ret);
                goto err;
        }
 
        ret = eqos_start_resets_tegra186(dev);
        if (ret < 0) {
-               error("eqos_start_resets_tegra186() failed: %d", ret);
+               pr_err("eqos_start_resets_tegra186() failed: %d", ret);
                goto err_stop_clks;
        }
 
@@ -865,13 +865,13 @@ static int eqos_start(struct udevice *dev)
        ret = wait_for_bit(__func__, &eqos->dma_regs->mode,
                           EQOS_DMA_MODE_SWR, false, 10, false);
        if (ret) {
-               error("EQOS_DMA_MODE_SWR stuck");
+               pr_err("EQOS_DMA_MODE_SWR stuck");
                goto err_stop_resets;
        }
 
        ret = eqos_calibrate_pads_tegra186(dev);
        if (ret < 0) {
-               error("eqos_calibrate_pads_tegra186() failed: %d", ret);
+               pr_err("eqos_calibrate_pads_tegra186() failed: %d", ret);
                goto err_stop_resets;
        }
 
@@ -881,28 +881,28 @@ static int eqos_start(struct udevice *dev)
 
        eqos->phy = phy_connect(eqos->mii, 0, dev, 0);
        if (!eqos->phy) {
-               error("phy_connect() failed");
+               pr_err("phy_connect() failed");
                goto err_stop_resets;
        }
        ret = phy_config(eqos->phy);
        if (ret < 0) {
-               error("phy_config() failed: %d", ret);
+               pr_err("phy_config() failed: %d", ret);
                goto err_shutdown_phy;
        }
        ret = phy_startup(eqos->phy);
        if (ret < 0) {
-               error("phy_startup() failed: %d", ret);
+               pr_err("phy_startup() failed: %d", ret);
                goto err_shutdown_phy;
        }
 
        if (!eqos->phy->link) {
-               error("No link");
+               pr_err("No link");
                goto err_shutdown_phy;
        }
 
        ret = eqos_adjust_link(dev);
        if (ret < 0) {
-               error("eqos_adjust_link() failed: %d", ret);
+               pr_err("eqos_adjust_link() failed: %d", ret);
                goto err_shutdown_phy;
        }
 
@@ -1119,7 +1119,7 @@ err_stop_resets:
 err_stop_clks:
        eqos_stop_clks_tegra186(dev);
 err:
-       error("FAILED: %d", ret);
+       pr_err("FAILED: %d", ret);
        return ret;
 }
 
@@ -1361,7 +1361,7 @@ static int eqos_probe_resources_tegra186(struct udevice *dev)
 
        ret = reset_get_by_name(dev, "eqos", &eqos->reset_ctl);
        if (ret) {
-               error("reset_get_by_name(rst) failed: %d", ret);
+               pr_err("reset_get_by_name(rst) failed: %d", ret);
                return ret;
        }
 
@@ -1369,38 +1369,38 @@ static int eqos_probe_resources_tegra186(struct udevice *dev)
                                   &eqos->phy_reset_gpio,
                                   GPIOD_IS_OUT | GPIOD_IS_OUT_ACTIVE);
        if (ret) {
-               error("gpio_request_by_name(phy reset) failed: %d", ret);
+               pr_err("gpio_request_by_name(phy reset) failed: %d", ret);
                goto err_free_reset_eqos;
        }
 
        ret = clk_get_by_name(dev, "slave_bus", &eqos->clk_slave_bus);
        if (ret) {
-               error("clk_get_by_name(slave_bus) failed: %d", ret);
+               pr_err("clk_get_by_name(slave_bus) failed: %d", ret);
                goto err_free_gpio_phy_reset;
        }
 
        ret = clk_get_by_name(dev, "master_bus", &eqos->clk_master_bus);
        if (ret) {
-               error("clk_get_by_name(master_bus) failed: %d", ret);
+               pr_err("clk_get_by_name(master_bus) failed: %d", ret);
                goto err_free_clk_slave_bus;
        }
 
        ret = clk_get_by_name(dev, "rx", &eqos->clk_rx);
        if (ret) {
-               error("clk_get_by_name(rx) failed: %d", ret);
+               pr_err("clk_get_by_name(rx) failed: %d", ret);
                goto err_free_clk_master_bus;
        }
 
        ret = clk_get_by_name(dev, "ptp_ref", &eqos->clk_ptp_ref);
        if (ret) {
-               error("clk_get_by_name(ptp_ref) failed: %d", ret);
+               pr_err("clk_get_by_name(ptp_ref) failed: %d", ret);
                goto err_free_clk_rx;
                return ret;
        }
 
        ret = clk_get_by_name(dev, "tx", &eqos->clk_tx);
        if (ret) {
-               error("clk_get_by_name(tx) failed: %d", ret);
+               pr_err("clk_get_by_name(tx) failed: %d", ret);
                goto err_free_clk_ptp_ref;
        }
 
@@ -1454,7 +1454,7 @@ static int eqos_probe(struct udevice *dev)
 
        eqos->regs = devfdt_get_addr(dev);
        if (eqos->regs == FDT_ADDR_T_NONE) {
-               error("devfdt_get_addr() failed");
+               pr_err("devfdt_get_addr() failed");
                return -ENODEV;
        }
        eqos->mac_regs = (void *)(eqos->regs + EQOS_MAC_REGS_BASE);
@@ -1464,19 +1464,19 @@ static int eqos_probe(struct udevice *dev)
 
        ret = eqos_probe_resources_core(dev);
        if (ret < 0) {
-               error("eqos_probe_resources_core() failed: %d", ret);
+               pr_err("eqos_probe_resources_core() failed: %d", ret);
                return ret;
        }
 
        ret = eqos_probe_resources_tegra186(dev);
        if (ret < 0) {
-               error("eqos_probe_resources_tegra186() failed: %d", ret);
+               pr_err("eqos_probe_resources_tegra186() failed: %d", ret);
                goto err_remove_resources_core;
        }
 
        eqos->mii = mdio_alloc();
        if (!eqos->mii) {
-               error("mdio_alloc() failed");
+               pr_err("mdio_alloc() failed");
                goto err_remove_resources_tegra;
        }
        eqos->mii->read = eqos_mdio_read;
@@ -1486,7 +1486,7 @@ static int eqos_probe(struct udevice *dev)
 
        ret = mdio_register(eqos->mii);
        if (ret < 0) {
-               error("mdio_register() failed: %d", ret);
+               pr_err("mdio_register() failed: %d", ret);
                goto err_free_mdio;
        }
 
index a94191b9e6715e3a685f6c172f3f45d85544b919..bc4570624332c607af3e7faf2c923d3e4346fa99 100644 (file)
@@ -324,7 +324,7 @@ static int ep93xx_eth_rcv_packet(struct eth_device *dev)
                        debug("reporting %d bytes...\n", len);
                } else {
                        /* Do we have an erroneous packet? */
-                       error("packet rx error, status %08X %08X",
+                       pr_err("packet rx error, status %08X %08X",
                                priv->rx_sq.current->word1,
                                priv->rx_sq.current->word2);
                        dump_rx_descriptor_queue(dev);
@@ -401,7 +401,7 @@ static int ep93xx_eth_send_packet(struct eth_device *dev,
                ; /* noop */
 
        if (!TX_STATUS_TXWE(priv->tx_sq.current)) {
-               error("packet tx error, status %08X",
+               pr_err("packet tx error, status %08X",
                        priv->tx_sq.current->word1);
                dump_tx_descriptor_queue(dev);
                dump_tx_status_queue(dev);
@@ -452,7 +452,7 @@ int ep93xx_eth_initialize(u8 dev_num, int base_addr)
 
        priv = malloc(sizeof(*priv));
        if (!priv) {
-               error("malloc() failed");
+               pr_err("malloc() failed");
                goto eth_init_failed_0;
        }
        memset(priv, 0, sizeof(*priv));
@@ -462,34 +462,34 @@ int ep93xx_eth_initialize(u8 dev_num, int base_addr)
        priv->tx_dq.base = calloc(NUMTXDESC,
                                sizeof(struct tx_descriptor));
        if (priv->tx_dq.base == NULL) {
-               error("calloc() failed");
+               pr_err("calloc() failed");
                goto eth_init_failed_1;
        }
 
        priv->tx_sq.base = calloc(NUMTXDESC,
                                sizeof(struct tx_status));
        if (priv->tx_sq.base == NULL) {
-               error("calloc() failed");
+               pr_err("calloc() failed");
                goto eth_init_failed_2;
        }
 
        priv->rx_dq.base = calloc(NUMRXDESC,
                                sizeof(struct rx_descriptor));
        if (priv->rx_dq.base == NULL) {
-               error("calloc() failed");
+               pr_err("calloc() failed");
                goto eth_init_failed_3;
        }
 
        priv->rx_sq.base = calloc(NUMRXDESC,
                                sizeof(struct rx_status));
        if (priv->rx_sq.base == NULL) {
-               error("calloc() failed");
+               pr_err("calloc() failed");
                goto eth_init_failed_4;
        }
 
        dev = malloc(sizeof *dev);
        if (dev == NULL) {
-               error("malloc() failed");
+               pr_err("malloc() failed");
                goto eth_init_failed_5;
        }
        memset(dev, 0, sizeof *dev);
index 72ef42cca883a8853b6265fa5184f9681747302a..21ccab47ae2702b5ba81cba157d0c8036e763802 100644 (file)
@@ -757,7 +757,7 @@ static int ks2_eth_start(struct udevice *dev)
        qm_init();
 
        if (ksnav_init(priv->netcp_pktdma, &priv->net_rx_buffs)) {
-               error("ksnav_init failed\n");
+               pr_err("ksnav_init failed\n");
                goto err_knav_init;
        }
 
@@ -773,7 +773,7 @@ static int ks2_eth_start(struct udevice *dev)
 
                phy_startup(priv->phydev);
                if (priv->phydev->link == 0) {
-                       error("phy startup failed\n");
+                       pr_err("phy startup failed\n");
                        goto err_phy_start;
                }
        }
@@ -923,7 +923,7 @@ static int ks2_eth_probe(struct udevice *dev)
                 */
                mdio_bus = mdio_alloc();
                if (!mdio_bus) {
-                       error("MDIO alloc failed\n");
+                       pr_err("MDIO alloc failed\n");
                        return -ENOMEM;
                }
                priv->mdio_bus = mdio_bus;
@@ -935,7 +935,7 @@ static int ks2_eth_probe(struct udevice *dev)
 
                ret = mdio_register(mdio_bus);
                if (ret) {
-                       error("MDIO bus register failed\n");
+                       pr_err("MDIO bus register failed\n");
                        return ret;
                }
        } else {
@@ -1011,7 +1011,7 @@ static int ks2_eth_bind_slaves(struct udevice *dev, int gbe, int *gbe_0)
                                        slave_name, offset_to_ofnode(slave),
                                        &sl_dev);
                        if (ret) {
-                               error("ks2_net - not able to bind slave interfaces\n");
+                               pr_err("ks2_net - not able to bind slave interfaces\n");
                                return ret;
                        }
                }
@@ -1031,7 +1031,7 @@ static int ks2_eth_bind_slaves(struct udevice *dev, int gbe, int *gbe_0)
                ret = device_bind_driver_to_node(dev, "eth_ks2_sl", slave_name,
                                        offset_to_ofnode(slave), &sl_dev);
                if (ret) {
-                       error("ks2_net - not able to bind slave interfaces\n");
+                       pr_err("ks2_net - not able to bind slave interfaces\n");
                        return ret;
                }
        }
@@ -1074,7 +1074,7 @@ static int ks2_eth_parse_slave_interface(int netcp, int slave,
 
                mdio = fdt_parent_offset(fdt, phy);
                if (mdio < 0) {
-                       error("mdio dt not found\n");
+                       pr_err("mdio dt not found\n");
                        return -ENODEV;
                }
                priv->mdio_base = (void *)fdtdec_get_addr(fdt, mdio, "reg");
index 7d920d423d9d6169a917c18e1a2130e7b005d21c..b5bd25ec563a0e36425ec5fba70bbc702f715423 100644 (file)
@@ -369,7 +369,7 @@ static int tegra_pcie_port_parse_dt(ofnode node, struct tegra_pcie_port *port)
 
        addr = ofnode_get_property(node, "assigned-addresses", &len);
        if (!addr) {
-               error("property \"assigned-addresses\" not found");
+               pr_err("property \"assigned-addresses\" not found");
                return -FDT_ERR_NOTFOUND;
        }
 
@@ -460,7 +460,7 @@ static int tegra_pcie_parse_port_info(ofnode node, uint *index, uint *lanes)
 
        err = ofnode_read_u32_default(node, "nvidia,num-lanes", -1);
        if (err < 0) {
-               error("failed to parse \"nvidia,num-lanes\" property");
+               pr_err("failed to parse \"nvidia,num-lanes\" property");
                return err;
        }
 
@@ -468,7 +468,7 @@ static int tegra_pcie_parse_port_info(ofnode node, uint *index, uint *lanes)
 
        err = ofnode_read_pci_addr(node, 0, "reg", &addr);
        if (err < 0) {
-               error("failed to parse \"reg\" property");
+               pr_err("failed to parse \"reg\" property");
                return err;
        }
 
@@ -491,25 +491,25 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
 
        err = dev_read_resource(dev, 0, &pcie->pads);
        if (err < 0) {
-               error("resource \"pads\" not found");
+               pr_err("resource \"pads\" not found");
                return err;
        }
 
        err = dev_read_resource(dev, 1, &pcie->afi);
        if (err < 0) {
-               error("resource \"afi\" not found");
+               pr_err("resource \"afi\" not found");
                return err;
        }
 
        err = dev_read_resource(dev, 2, &pcie->cs);
        if (err < 0) {
-               error("resource \"cs\" not found");
+               pr_err("resource \"cs\" not found");
                return err;
        }
 
        err = tegra_pcie_board_init();
        if (err < 0) {
-               error("tegra_pcie_board_init() failed: err=%d", err);
+               pr_err("tegra_pcie_board_init() failed: err=%d", err);
                return err;
        }
 
@@ -518,7 +518,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
        if (pcie->phy) {
                err = tegra_xusb_phy_prepare(pcie->phy);
                if (err < 0) {
-                       error("failed to prepare PHY: %d", err);
+                       pr_err("failed to prepare PHY: %d", err);
                        return err;
                }
        }
@@ -530,7 +530,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
 
                err = tegra_pcie_parse_port_info(subnode, &index, &num_lanes);
                if (err < 0) {
-                       error("failed to obtain root port info");
+                       pr_err("failed to obtain root port info");
                        continue;
                }
 
@@ -560,7 +560,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
        err = tegra_pcie_get_xbar_config(dev_ofnode(dev), lanes, id,
                                         &pcie->xbar);
        if (err < 0) {
-               error("invalid lane configuration");
+               pr_err("invalid lane configuration");
                return err;
        }
 
@@ -574,31 +574,31 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        ret = power_domain_on(&pcie->pwrdom);
        if (ret) {
-               error("power_domain_on() failed: %d\n", ret);
+               pr_err("power_domain_on() failed: %d\n", ret);
                return ret;
        }
 
        ret = clk_enable(&pcie->clk_afi);
        if (ret) {
-               error("clk_enable(afi) failed: %d\n", ret);
+               pr_err("clk_enable(afi) failed: %d\n", ret);
                return ret;
        }
 
        ret = clk_enable(&pcie->clk_pex);
        if (ret) {
-               error("clk_enable(pex) failed: %d\n", ret);
+               pr_err("clk_enable(pex) failed: %d\n", ret);
                return ret;
        }
 
        ret = reset_deassert(&pcie->reset_afi);
        if (ret) {
-               error("reset_deassert(afi) failed: %d\n", ret);
+               pr_err("reset_deassert(afi) failed: %d\n", ret);
                return ret;
        }
 
        ret = reset_deassert(&pcie->reset_pex);
        if (ret) {
-               error("reset_deassert(pex) failed: %d\n", ret);
+               pr_err("reset_deassert(pex) failed: %d\n", ret);
                return ret;
        }
 
@@ -618,14 +618,14 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        err = tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
        if (err < 0) {
-               error("failed to power off PCIe partition: %d", err);
+               pr_err("failed to power off PCIe partition: %d", err);
                return err;
        }
 
        err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
                                                PERIPH_ID_PCIE);
        if (err < 0) {
-               error("failed to power up PCIe partition: %d", err);
+               pr_err("failed to power up PCIe partition: %d", err);
                return err;
        }
 
@@ -645,7 +645,7 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        err = tegra_plle_enable();
        if (err < 0) {
-               error("failed to enable PLLE: %d\n", err);
+               pr_err("failed to enable PLLE: %d\n", err);
                return err;
        }
 
@@ -705,7 +705,7 @@ static int tegra_pcie_phy_enable(struct tegra_pcie *pcie)
        /* wait for the PLL to lock */
        err = tegra_pcie_pll_wait(pcie, 500);
        if (err < 0) {
-               error("PLL failed to lock: %d", err);
+               pr_err("PLL failed to lock: %d", err);
                return err;
        }
 
@@ -769,7 +769,7 @@ static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
                err = tegra_pcie_phy_enable(pcie);
 
        if (err < 0) {
-               error("failed to power on PHY: %d\n", err);
+               pr_err("failed to power on PHY: %d\n", err);
                return err;
        }
 #endif
@@ -778,7 +778,7 @@ static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
 #ifdef CONFIG_TEGRA186
        err = reset_deassert(&pcie->reset_pcie_x);
        if (err) {
-               error("reset_deassert(pcie_x) failed: %d\n", err);
+               pr_err("reset_deassert(pcie_x) failed: %d\n", err);
                return err;
        }
 #else
@@ -1143,25 +1143,25 @@ static int pci_tegra_probe(struct udevice *dev)
 
        err = tegra_pcie_power_on(pcie);
        if (err < 0) {
-               error("failed to power on");
+               pr_err("failed to power on");
                return err;
        }
 
        err = tegra_pcie_enable_controller(pcie);
        if (err < 0) {
-               error("failed to enable controller");
+               pr_err("failed to enable controller");
                return err;
        }
 
        err = tegra_pcie_setup_translations(dev);
        if (err < 0) {
-               error("failed to decode ranges");
+               pr_err("failed to decode ranges");
                return err;
        }
 
        err = tegra_pcie_enable(pcie);
        if (err < 0) {
-               error("failed to enable PCIe");
+               pr_err("failed to enable PCIe");
                return err;
        }
 
index 4ba32df516996b1725eddfdb2e23f218c3538202..6425825068e90ce755d1f076bd2a47e57abde143 100644 (file)
@@ -187,7 +187,7 @@ static int pcie_xilinx_ofdata_to_platdata(struct udevice *dev)
        err = fdt_get_resource(gd->fdt_blob, dev_of_offset(dev), "reg",
                               0, &reg_res);
        if (err < 0) {
-               error("\"reg\" resource not found\n");
+               pr_err("\"reg\" resource not found\n");
                return err;
        }
 
index 3ac405a9be6ee44c87cb8139d255cf084ca028f1..37187885fa05e3248e97ff296f6c5d1e675a60bd 100644 (file)
@@ -509,7 +509,7 @@ static int comphy_pcie_power_up(u32 lane, u32 pcie_width, bool clk_src,
                                debug("Read from reg = %p - value = 0x%x\n",
                                      hpipe_addr + HPIPE_LANE_STATUS1_REG,
                                      data);
-                               error("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
+                               pr_err("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
                                ret = 0;
                        }
                }
@@ -633,7 +633,7 @@ static int comphy_usb3_power_up(u32 lane, void __iomem *hpipe_base,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      hpipe_addr + HPIPE_LANE_STATUS1_REG, data);
-               error("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
+               pr_err("HPIPE_LANE_STATUS1_PCLK_EN_MASK is 0\n");
                ret = 0;
        }
 
@@ -666,14 +666,14 @@ static int comphy_sata_power_up(u32 lane, void __iomem *hpipe_base,
                        gd->fdt_blob, sata_node, "marvell,armada-8k-ahci");
 
        if (sata_node == 0) {
-               error("SATA node not found in FDT\n");
+               pr_err("SATA node not found in FDT\n");
                return 0;
        }
 
        sata_base = (void __iomem *)fdtdec_get_addr_size_auto_noparent(
                gd->fdt_blob, sata_node, "reg", 0, NULL, true);
        if (sata_base == NULL) {
-               error("SATA address not found in FDT\n");
+               pr_err("SATA address not found in FDT\n");
                return 0;
        }
 
@@ -976,7 +976,7 @@ static int comphy_sata_power_up(u32 lane, void __iomem *hpipe_base,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      hpipe_addr + HPIPE_LANE_STATUS1_REG, data);
-               error("SD_EXTERNAL_STATUS0_PLL_TX is %d, SD_EXTERNAL_STATUS0_PLL_RX is %d\n",
+               pr_err("SD_EXTERNAL_STATUS0_PLL_TX is %d, SD_EXTERNAL_STATUS0_PLL_RX is %d\n",
                      (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK),
                      (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK));
                ret = 0;
@@ -1099,7 +1099,7 @@ static int comphy_sgmii_power_up(u32 lane, u32 sgmii_speed,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
+               pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
                      (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
                      (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
                ret = 0;
@@ -1117,7 +1117,7 @@ static int comphy_sgmii_power_up(u32 lane, u32 sgmii_speed,
        data = polling_with_timeout(addr, data, mask, 100);
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n", sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
+               pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
                ret = 0;
        }
 
@@ -1398,7 +1398,7 @@ static int comphy_sfi_power_up(u32 lane, void __iomem *hpipe_base,
        data = polling_with_timeout(addr, data, mask, 15000);
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n", sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
+               pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
                      (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
                      (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
                ret = 0;
@@ -1418,7 +1418,7 @@ static int comphy_sfi_power_up(u32 lane, void __iomem *hpipe_base,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
+               pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
                ret = 0;
        }
 
@@ -1577,7 +1577,7 @@ static int comphy_rxauii_power_up(u32 lane, void __iomem *hpipe_base,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
+               pr_err("SD_EXTERNAL_STATUS0_PLL_RX is %d, SD_EXTERNAL_STATUS0_PLL_TX is %d\n",
                      (data & SD_EXTERNAL_STATUS0_PLL_RX_MASK),
                      (data & SD_EXTERNAL_STATUS0_PLL_TX_MASK));
                ret = 0;
@@ -1596,7 +1596,7 @@ static int comphy_rxauii_power_up(u32 lane, void __iomem *hpipe_base,
        if (data != 0) {
                debug("Read from reg = %p - value = 0x%x\n",
                      sd_ip_addr + SD_EXTERNAL_STATUS0_REG, data);
-               error("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
+               pr_err("SD_EXTERNAL_STATUS0_RX_INIT is 0\n");
                ret = 0;
        }
 
@@ -1742,7 +1742,7 @@ static int comphy_utmi_power_up(u32 utmi_index, void __iomem *utmi_base_addr,
        mask = data;
        data = polling_with_timeout(addr, data, mask, 100);
        if (data != 0) {
-               error("Impedance calibration is not done\n");
+               pr_err("Impedance calibration is not done\n");
                debug("Read from reg = %p - value = 0x%x\n", addr, data);
                ret = 0;
        }
@@ -1751,7 +1751,7 @@ static int comphy_utmi_power_up(u32 utmi_index, void __iomem *utmi_base_addr,
        mask = data;
        data = polling_with_timeout(addr, data, mask, 100);
        if (data != 0) {
-               error("PLL calibration is not done\n");
+               pr_err("PLL calibration is not done\n");
                debug("Read from reg = %p - value = 0x%x\n", addr, data);
                ret = 0;
        }
@@ -1761,7 +1761,7 @@ static int comphy_utmi_power_up(u32 utmi_index, void __iomem *utmi_base_addr,
        mask = data;
        data = polling_with_timeout(addr, data, mask, 100);
        if (data != 0) {
-               error("PLL is not ready\n");
+               pr_err("PLL is not ready\n");
                debug("Read from reg = %p - value = 0x%x\n", addr, data);
                ret = 0;
        }
@@ -1818,7 +1818,7 @@ static void comphy_utmi_phy_init(u32 utmi_phy_count,
                                          cp110_utmi_data[i].usb_cfg_addr,
                                          cp110_utmi_data[i].utmi_cfg_addr,
                                          cp110_utmi_data[i].utmi_phy_port)) {
-                       error("Failed to initialize UTMI PHY %d\n", i);
+                       pr_err("Failed to initialize UTMI PHY %d\n", i);
                        continue;
                }
                printf("UTMI PHY %d initialized to ", i);
@@ -1864,7 +1864,7 @@ void comphy_dedicated_phys_init(void)
                        (void __iomem *)fdtdec_get_addr_size_auto_noparent(
                                gd->fdt_blob, node, "reg", 0, NULL, true);
                if (cp110_utmi_data[i].utmi_base_addr == NULL) {
-                       error("UTMI PHY base address is invalid\n");
+                       pr_err("UTMI PHY base address is invalid\n");
                        i++;
                        continue;
                }
@@ -1874,7 +1874,7 @@ void comphy_dedicated_phys_init(void)
                        (void __iomem *)fdtdec_get_addr_size_auto_noparent(
                                gd->fdt_blob, node, "reg", 1, NULL, true);
                if (cp110_utmi_data[i].usb_cfg_addr == NULL) {
-                       error("UTMI PHY base address is invalid\n");
+                       pr_err("UTMI PHY base address is invalid\n");
                        i++;
                        continue;
                }
@@ -1884,7 +1884,7 @@ void comphy_dedicated_phys_init(void)
                        (void __iomem *)fdtdec_get_addr_size_auto_noparent(
                                gd->fdt_blob, node, "reg", 2, NULL, true);
                if (cp110_utmi_data[i].utmi_cfg_addr == NULL) {
-                       error("UTMI PHY base address is invalid\n");
+                       pr_err("UTMI PHY base address is invalid\n");
                        i++;
                        continue;
                }
@@ -1896,7 +1896,7 @@ void comphy_dedicated_phys_init(void)
                cp110_utmi_data[i].utmi_phy_port = fdtdec_get_int(
                        gd->fdt_blob, node, "utmi-port", UTMI_PHY_INVALID);
                if (cp110_utmi_data[i].utmi_phy_port == UTMI_PHY_INVALID) {
-                       error("UTMI PHY port type is invalid\n");
+                       pr_err("UTMI PHY port type is invalid\n");
                        i++;
                        continue;
                }
@@ -2049,7 +2049,7 @@ int comphy_cp110_init(struct chip_serdes_phy_config *ptr_chip_cfg,
                         * PHY_TYPE_UNCONNECTED state.
                         */
                        ptr_comphy_map->type = PHY_TYPE_UNCONNECTED;
-                       error("PLL is not locked - Failed to initialize lane %d\n",
+                       pr_err("PLL is not locked - Failed to initialize lane %d\n",
                              lane);
                }
        }
index 0e0b1c02d2e1a102f89c5bc89c3063ac7dac26c4..88fcfbb3e5b9832c001d27babb1847f2620be343 100644 (file)
@@ -47,13 +47,13 @@ static int sti_usb_phy_deassert(struct sti_usb_phy *phy)
 
        ret = reset_deassert(&phy->global_ctl);
        if (ret < 0) {
-               error("PHY global deassert failed: %d", ret);
+               pr_err("PHY global deassert failed: %d", ret);
                return ret;
        }
 
        ret = reset_deassert(&phy->port_ctl);
        if (ret < 0)
-               error("PHY port deassert failed: %d", ret);
+               pr_err("PHY port deassert failed: %d", ret);
 
        return ret;
 }
@@ -85,13 +85,13 @@ static int sti_usb_phy_exit(struct phy *usb_phy)
 
        ret = reset_assert(&phy->port_ctl);
        if (ret < 0) {
-               error("PHY port assert failed: %d", ret);
+               pr_err("PHY port assert failed: %d", ret);
                return ret;
        }
 
        ret = reset_assert(&phy->global_ctl);
        if (ret < 0)
-               error("PHY global assert failed: %d", ret);
+               pr_err("PHY global assert failed: %d", ret);
 
        return ret;
 }
@@ -114,20 +114,20 @@ int sti_usb_phy_probe(struct udevice *dev)
                                         &syscfg_phandle);
 
        if (ret < 0) {
-               error("Can't get syscfg phandle: %d\n", ret);
+               pr_err("Can't get syscfg phandle: %d\n", ret);
                return ret;
        }
 
        ret = uclass_get_device_by_ofnode(UCLASS_SYSCON, syscfg_phandle.node,
                                          &syscon);
        if (ret) {
-               error("unable to find syscon device (%d)\n", ret);
+               pr_err("unable to find syscon device (%d)\n", ret);
                return ret;
        }
 
        priv->regmap = syscon_get_regmap(syscon);
        if (!priv->regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
@@ -137,12 +137,12 @@ int sti_usb_phy_probe(struct udevice *dev)
                                           ARRAY_SIZE(cells));
 
        if (count < 0) {
-               error("Bad PHY st,syscfg property %d\n", count);
+               pr_err("Bad PHY st,syscfg property %d\n", count);
                return -EINVAL;
        }
 
        if (count > PHYPARAM_NB) {
-               error("Unsupported PHY param count %d\n", count);
+               pr_err("Unsupported PHY param count %d\n", count);
                return -EINVAL;
        }
 
@@ -152,14 +152,14 @@ int sti_usb_phy_probe(struct udevice *dev)
        /* get global reset control */
        ret = reset_get_by_name(dev, "global", &priv->global_ctl);
        if (ret) {
-               error("can't get global reset for %s (%d)", dev->name, ret);
+               pr_err("can't get global reset for %s (%d)", dev->name, ret);
                return ret;
        }
 
        /* get port reset control */
        ret = reset_get_by_name(dev, "port", &priv->port_ctl);
        if (ret) {
-               error("can't get port reset for %s (%d)", dev->name, ret);
+               pr_err("can't get port reset for %s (%d)", dev->name, ret);
                return ret;
        }
 
index 680e32f3ea6f46fa687ef2fd247af90fd4eae26f..babf2ffe393e602e4d1a06827c8638786a801aeb 100644 (file)
@@ -261,7 +261,7 @@ static int pipe3_exit(struct phy *phy)
        } while (--timeout);
 
        if (!(val & PLL_TICOPWDN) || !(val & PLL_LDOPWDN)) {
-               error("%s: Failed to power down DPLL: PLL_STATUS 0x%x\n",
+               pr_err("%s: Failed to power down DPLL: PLL_STATUS 0x%x\n",
                      __func__, val);
                return -EBUSY;
        }
@@ -284,14 +284,14 @@ static void *get_reg(struct udevice *dev, const char *name)
        err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
                                           name, &syscon);
        if (err) {
-               error("unable to find syscon device for %s (%d)\n",
+               pr_err("unable to find syscon device for %s (%d)\n",
                      name, err);
                return NULL;
        }
 
        regmap = syscon_get_regmap(syscon);
        if (IS_ERR(regmap)) {
-               error("unable to find regmap for %s (%ld)\n",
+               pr_err("unable to find regmap for %s (%ld)\n",
                      name, PTR_ERR(regmap));
                return NULL;
        }
@@ -299,7 +299,7 @@ static void *get_reg(struct udevice *dev, const char *name)
        cell = fdt_getprop(gd->fdt_blob, dev_of_offset(dev), name,
                           &len);
        if (len < 2*sizeof(fdt32_t)) {
-               error("offset not available for %s\n", name);
+               pr_err("offset not available for %s\n", name);
                return NULL;
        }
 
@@ -318,13 +318,13 @@ static int pipe3_phy_probe(struct udevice *dev)
 
        addr = devfdt_get_addr_size_index(dev, 2, &sz);
        if (addr == FDT_ADDR_T_NONE) {
-               error("missing pll ctrl address\n");
+               pr_err("missing pll ctrl address\n");
                return -EINVAL;
        }
 
        pipe3->pll_ctrl_base = map_physmem(addr, sz, MAP_NOCACHE);
        if (!pipe3->pll_ctrl_base) {
-               error("unable to remap pll ctrl\n");
+               pr_err("unable to remap pll ctrl\n");
                return -EINVAL;
        }
 
index 27165b0007739b04785976e3d25d969076436ca9..2bf853eba13d237d3c6882daae08128fdb18e815 100644 (file)
@@ -578,7 +578,7 @@ int armada_37xx_pinctrl_probe(struct udevice *dev)
 
        info->base = (void __iomem *)devfdt_get_addr(dev);
        if (!info->base) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
index 40341b4eeb756e0ce7725484c0f867d1cfdbfe13..735e412f608e6682c1d5048f613f507a27ca4edf 100644 (file)
@@ -142,7 +142,7 @@ void sti_pin_configure(struct udevice *dev, struct sti_pin_desc *pin_desc)
                break;
 
        default:
-               error("%s invalid direction value: 0x%x\n",
+               pr_err("%s invalid direction value: 0x%x\n",
                      __func__, pin_desc->dir);
                BUG();
                break;
@@ -237,14 +237,14 @@ static int sti_pinctrl_set_state(struct udevice *dev, struct udevice *config)
                                                     prop_name, "#gpio-cells",
                                                     0, 0, &args);
                if (ret < 0) {
-                       error("Can't get the gpio bank phandle: %d\n", ret);
+                       pr_err("Can't get the gpio bank phandle: %d\n", ret);
                        return ret;
                }
 
                bank_name = fdt_getprop(blob, args.node, "st,bank-name",
                                        &count);
                if (count < 0) {
-                       error("Can't find bank-name property %d\n", count);
+                       pr_err("Can't find bank-name property %d\n", count);
                        return -EINVAL;
                }
 
@@ -254,12 +254,12 @@ static int sti_pinctrl_set_state(struct udevice *dev, struct udevice *config)
                                                   prop_name, cells,
                                                   ARRAY_SIZE(cells));
                if (count < 0) {
-                       error("Bad pin configuration array %d\n", count);
+                       pr_err("Bad pin configuration array %d\n", count);
                        return -EINVAL;
                }
 
                if (count > MAX_STI_PINCONF_ENTRIES) {
-                       error("Unsupported pinconf array count %d\n", count);
+                       pr_err("Unsupported pinconf array count %d\n", count);
                        return -EINVAL;
                }
 
@@ -284,13 +284,13 @@ static int sti_pinctrl_probe(struct udevice *dev)
        err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
                                           "st,syscfg", &syscon);
        if (err) {
-               error("unable to find syscon device\n");
+               pr_err("unable to find syscon device\n");
                return err;
        }
 
        plat->regmap = syscon_get_regmap(syscon);
        if (!plat->regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
index bf2a86c6364bc61f94f5b9bbfe2256e42f1f410e..51fdfb3851cac3c9ca6b15ce5596823a9122151d 100644 (file)
@@ -160,7 +160,7 @@ static int stm32_pinctrl_set_state_simple(struct udevice *dev,
 
                config_node = fdt_node_offset_by_phandle(fdt, phandle);
                if (config_node < 0) {
-                       error("prop pinctrl-0 index %d invalid phandle\n", i);
+                       pr_err("prop pinctrl-0 index %d invalid phandle\n", i);
                        return -EINVAL;
                }
 
index 4efe8ee183d5b292ea3a35d0e87a8826a8d5ebf4..3b0427e0b9186f464dcc9d82fc34006bfd423f04 100644 (file)
@@ -46,14 +46,14 @@ static int as3722_read_id(struct udevice *dev, uint *idp, uint *revisionp)
 
        ret = pmic_reg_read(dev, AS3722_ASIC_ID1);
        if (ret < 0) {
-               error("failed to read ID1 register: %d", ret);
+               pr_err("failed to read ID1 register: %d", ret);
                return ret;
        }
        *idp = ret;
 
        ret = pmic_reg_read(dev, AS3722_ASIC_ID2);
        if (ret < 0) {
-               error("failed to read ID2 register: %d", ret);
+               pr_err("failed to read ID2 register: %d", ret);
                return ret;
        }
        *revisionp = ret;
@@ -71,7 +71,7 @@ int as3722_sd_set_voltage(struct udevice *dev, unsigned int sd, u8 value)
 
        ret = pmic_reg_write(dev, AS3722_SD_VOLTAGE(sd), value);
        if (ret < 0) {
-               error("failed to write SD%u voltage register: %d", sd, ret);
+               pr_err("failed to write SD%u voltage register: %d", sd, ret);
                return ret;
        }
 
@@ -87,7 +87,7 @@ int as3722_ldo_set_voltage(struct udevice *dev, unsigned int ldo, u8 value)
 
        ret = pmic_reg_write(dev, AS3722_LDO_VOLTAGE(ldo), value);
        if (ret < 0) {
-               error("failed to write LDO%u voltage register: %d", ldo,
+               pr_err("failed to write LDO%u voltage register: %d", ldo,
                      ret);
                return ret;
        }
@@ -102,12 +102,12 @@ static int as3722_probe(struct udevice *dev)
 
        ret = as3722_read_id(dev, &id, &revision);
        if (ret < 0) {
-               error("failed to read ID: %d", ret);
+               pr_err("failed to read ID: %d", ret);
                return ret;
        }
 
        if (id != AS3722_DEVICE_ID) {
-               error("unknown device");
+               pr_err("unknown device");
                return -ENOENT;
        }
 
index d0b681ca4ab939559077458639ac239c5d186421..5cf4cb6b518efde6d221c08d4f2c6f6889c6f75a 100644 (file)
@@ -26,7 +26,7 @@ int as3722_gpio_configure(struct udevice *pmic, unsigned int gpio,
 
        err = pmic_reg_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
        if (err) {
-               error("failed to configure GPIO#%u: %d", gpio, err);
+               pr_err("failed to configure GPIO#%u: %d", gpio, err);
                return err;
        }
 
@@ -46,7 +46,7 @@ static int as3722_gpio_set_value(struct udevice *dev, unsigned int gpio,
 
        err = pmic_reg_read(pmic, AS3722_GPIO_SIGNAL_OUT);
        if (err < 0) {
-               error("failed to read GPIO signal out register: %d", err);
+               pr_err("failed to read GPIO signal out register: %d", err);
                return err;
        }
        value = err;
@@ -61,7 +61,7 @@ static int as3722_gpio_set_value(struct udevice *dev, unsigned int gpio,
 
        err = pmic_reg_write(pmic, AS3722_GPIO_SIGNAL_OUT, value);
        if (err) {
-               error("failed to set GPIO#%u %s: %d", gpio, l, err);
+               pr_err("failed to set GPIO#%u %s: %d", gpio, l, err);
                return err;
        }
 
@@ -84,13 +84,13 @@ int as3722_gpio_direction_output(struct udevice *dev, unsigned int gpio,
 
        err = pmic_reg_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
        if (err) {
-               error("failed to configure GPIO#%u as output: %d", gpio, err);
+               pr_err("failed to configure GPIO#%u as output: %d", gpio, err);
                return err;
        }
 
        err = as3722_gpio_set_value(pmic, gpio, value);
        if (err < 0) {
-               error("failed to set GPIO#%u high: %d", gpio, err);
+               pr_err("failed to set GPIO#%u high: %d", gpio, err);
                return err;
        }
 
index 2d35d09d454cc0dff05bca46cac343615e9a05db..38a2a04f177660da2777b8604d8317b643db6f8c 100644 (file)
@@ -31,7 +31,7 @@ static int sandbox_i2c_pmic_read_data(struct udevice *emul, uchar chip,
        struct sandbox_i2c_pmic_plat_data *plat = dev_get_platdata(emul);
 
        if (plat->rw_reg + len > SANDBOX_PMIC_REG_COUNT) {
-               error("Request exceeds PMIC register range! Max register: %#x",
+               pr_err("Request exceeds PMIC register range! Max register: %#x",
                      SANDBOX_PMIC_REG_COUNT);
                return -EFAULT;
        }
@@ -68,7 +68,7 @@ static int sandbox_i2c_pmic_write_data(struct udevice *emul, uchar chip,
        len--;
 
        if (plat->rw_reg + len > SANDBOX_PMIC_REG_COUNT) {
-               error("Request exceeds PMIC register range! Max register: %#x",
+               pr_err("Request exceeds PMIC register range! Max register: %#x",
                      SANDBOX_PMIC_REG_COUNT);
        }
 
@@ -111,7 +111,7 @@ static int sandbox_i2c_pmic_ofdata_to_platdata(struct udevice *emul)
                                             SANDBOX_PMIC_REG_COUNT);
 
        if (!reg_defaults) {
-               error("Property \"reg-defaults\" not found for device: %s!",
+               pr_err("Property \"reg-defaults\" not found for device: %s!",
                      emul->name);
                return -EINVAL;
        }
index f5054683139a0a523f15ac71800bb977ad1dccca..95c2b7e8c74ce600685a51bf78fcd4a73c573615 100644 (file)
@@ -27,7 +27,7 @@ static int lp873x_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -37,7 +37,7 @@ static int lp873x_write(struct udevice *dev, uint reg, const uint8_t *buff,
 static int lp873x_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
index 782a46c4cc31d13e8e32ca3ecca48ab222754681..506769e362673608b27aee1358a76b544e8d14b5 100644 (file)
@@ -29,7 +29,7 @@ static int lp87565_write(struct udevice *dev, uint reg, const uint8_t *buff,
 
        ret = dm_i2c_write(dev, reg, buff, len);
        if (ret)
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
 
        return ret;
 }
@@ -40,7 +40,7 @@ static int lp87565_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 
        ret = dm_i2c_read(dev, reg, buff, len);
        if (ret)
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
 
        return ret;
 }
index ceca9f96a7f3c237ecd96a8bb24029aad79a9ef9..b3ed84992ff8a21db37f6d656c5e12599f9919c4 100644 (file)
@@ -31,7 +31,7 @@ static int max77686_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -41,7 +41,7 @@ static int max77686_write(struct udevice *dev, uint reg, const uint8_t *buff,
 static int max77686_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
index f749d7debfc3314be2028739e34fd10f7c9df413..5ebeb8a316be0f1ba1c8641aa58144f8c817f015 100644 (file)
@@ -26,7 +26,7 @@ static int max8997_write(struct udevice *dev, uint reg, const uint8_t *buff,
 
        ret = dm_i2c_write(dev, reg, buff, len);
        if (ret)
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
 
        return ret;
 }
@@ -37,7 +37,7 @@ static int max8997_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 
        ret = dm_i2c_read(dev, reg, buff, len);
        if (ret)
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
 
        return ret;
 }
index 7c4773c7b3aa7309fbe08776645eb26b61e3492e..a7e04699e8ba4212b0f4ebccf6655172af6b9790 100644 (file)
@@ -26,7 +26,7 @@ static int max8998_write(struct udevice *dev, uint reg, const uint8_t *buff,
 
        ret = dm_i2c_write(dev, reg, buff, len);
        if (ret)
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
 
        return ret;
 }
@@ -37,7 +37,7 @@ static int max8998_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 
        ret = dm_i2c_read(dev, reg, buff, len);
        if (ret)
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
 
        return ret;
 }
index 804c0d13a0c98bff39d7126f4cf1609bd984bcfa..1e1ecb382e3a9e87816ae009f510f2c9bff724c3 100644 (file)
@@ -27,7 +27,7 @@ static int palmas_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -37,7 +37,7 @@ static int palmas_write(struct udevice *dev, uint reg, const uint8_t *buff,
 static int palmas_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
index 5f361c7696f442cd053930b5ad738ae99a54c0c3..a06cbc07d491884089f91dd6daf40a378ad59878 100644 (file)
@@ -33,7 +33,7 @@ static int pfuze100_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -43,7 +43,7 @@ static int pfuze100_write(struct udevice *dev, uint reg, const uint8_t *buff,
 static int pfuze100_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
index 9d83059c403ab5e8fad52ab9a800eb646ecdcd11..522105e5ff05a0e9a14b2f31c75abd47bf4f9e0f 100644 (file)
@@ -27,7 +27,7 @@ static int s2mps11_write(struct udevice *dev, uint reg, const uint8_t *buff,
 
        ret = dm_i2c_write(dev, reg, buff, len);
        if (ret)
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
 
        return ret;
 }
@@ -38,7 +38,7 @@ static int s2mps11_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 
        ret = dm_i2c_read(dev, reg, buff, len);
        if (ret)
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
 
        return ret;
 }
index f8ae5ea2dba4c643072ea898159b44174218b086..3812e240ab085340b2ee932132690dce6dbe3041 100644 (file)
@@ -30,7 +30,7 @@ static int s5m8767_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -40,7 +40,7 @@ static int s5m8767_write(struct udevice *dev, uint reg, const uint8_t *buff,
 static int s5m8767_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
index 6763303c66710a6a7eaae73cb142a22c548d7714..e8d6faca160caf27ae3aecc84c11b8d13f4b8ea6 100644 (file)
@@ -31,7 +31,7 @@ static int sandbox_pmic_write(struct udevice *dev, uint reg,
                              const uint8_t *buff, int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -42,7 +42,7 @@ static int sandbox_pmic_read(struct udevice *dev, uint reg,
                             uint8_t *buff, int len)
 {
        if (dm_i2c_read(dev, reg, buff, len)) {
-               error("read error from device: %p register: %#x!", dev, reg);
+               pr_err("read error from device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -52,7 +52,7 @@ static int sandbox_pmic_read(struct udevice *dev, uint reg,
 static int sandbox_pmic_bind(struct udevice *dev)
 {
        if (!pmic_bind_children(dev, dev_ofnode(dev), pmic_children_info))
-               error("%s:%d PMIC: %s - no child found!", __func__, __LINE__,
+               pr_err("%s:%d PMIC: %s - no child found!", __func__, __LINE__,
                                                          dev->name);
 
        /* Always return success for this device - allows for PMIC I/O */
index 4565e3b54c1baf127f5838199a291fdb73ab3642..ee5358bcedc8f82da8f70204f723d363e3fce7f2 100644 (file)
@@ -29,7 +29,7 @@ static int tps65090_write(struct udevice *dev, uint reg, const uint8_t *buff,
                          int len)
 {
        if (dm_i2c_write(dev, reg, buff, len)) {
-               error("write error to device: %p register: %#x!", dev, reg);
+               pr_err("write error to device: %p register: %#x!", dev, reg);
                return -EIO;
        }
 
@@ -42,7 +42,7 @@ static int tps65090_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
 
        ret = dm_i2c_read(dev, reg, buff, len);
        if (ret) {
-               error("read error %d from device: %p register: %#x!", ret, dev,
+               pr_err("read error %d from device: %p register: %#x!", ret, dev,
                      reg);
                return -EIO;
        }
index 35c292222b97eb8246af50dee64595a5a8620fb9..97b4a98bf0b63799ede846e15bfc0817493fe6d2 100644 (file)
@@ -117,7 +117,7 @@ static int fixed_regulator_set_enable(struct udevice *dev, bool enable)
 
        ret = dm_gpio_set_value(&dev_pdata->gpio, enable);
        if (ret) {
-               error("Can't set regulator : %s gpio to: %d\n", dev->name,
+               pr_err("Can't set regulator : %s gpio to: %d\n", dev->name,
                      enable);
                return ret;
        }
index 42391c69b4307bcf9eaf005570d56186db2469a6..1031a0362b676ff98cc92f653c6aefd2ef51c76f 100644 (file)
@@ -109,7 +109,7 @@ static int gpio_regulator_set_value(struct udevice *dev, int uV)
 
        ret = dm_gpio_set_value(&dev_pdata->gpio, enable);
        if (ret) {
-               error("Can't set regulator : %s gpio to: %d\n", dev->name,
+               pr_err("Can't set regulator : %s gpio to: %d\n", dev->name,
                      enable);
                return ret;
        }
index 8780806cff04fb810826645029d010552169549b..2212d36ed6a91a0324c93b29f9cc788c52717988 100644 (file)
@@ -98,7 +98,7 @@ static int max77686_buck_volt2hex(int buck, int uV)
        if (hex >= 0 && hex <= hex_max)
                return hex;
 
-       error("Value: %d uV is wrong for BUCK%d", uV, buck);
+       pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
        return -EINVAL;
 }
 
@@ -134,7 +134,7 @@ static int max77686_buck_hex2volt(int buck, int hex)
        return uV;
 
 bad_hex:
-       error("Value: %#x is wrong for BUCK%d", hex, buck);
+       pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
        return -EINVAL;
 }
 
@@ -160,7 +160,7 @@ static int max77686_ldo_volt2hex(int ldo, int uV)
        if (hex >= 0 && hex <= MAX77686_LDO_VOLT_MAX_HEX)
                return hex;
 
-       error("Value: %d uV is wrong for LDO%d", uV, ldo);
+       pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
        return -EINVAL;
 }
 
@@ -189,7 +189,7 @@ static int max77686_ldo_hex2volt(int ldo, int hex)
        return uV;
 
 bad_hex:
-       error("Value: %#x is wrong for ldo%d", hex, ldo);
+       pr_err("Value: %#x is wrong for ldo%d", hex, ldo);
        return -EINVAL;
 }
 
@@ -328,7 +328,7 @@ static int max77686_ldo_val(struct udevice *dev, int op, int *uV)
 
        ldo = dev->driver_data;
        if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
-               error("Wrong ldo number: %d", ldo);
+               pr_err("Wrong ldo number: %d", ldo);
                return -EINVAL;
        }
 
@@ -366,7 +366,7 @@ static int max77686_buck_val(struct udevice *dev, int op, int *uV)
 
        buck = dev->driver_data;
        if (buck < 1 || buck > MAX77686_BUCK_NUM) {
-               error("Wrong buck number: %d", buck);
+               pr_err("Wrong buck number: %d", buck);
                return -EINVAL;
        }
 
@@ -423,7 +423,7 @@ static int max77686_ldo_mode(struct udevice *dev, int op, int *opmode)
 
        ldo = dev->driver_data;
        if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
-               error("Wrong ldo number: %d", ldo);
+               pr_err("Wrong ldo number: %d", ldo);
                return -EINVAL;
        }
 
@@ -493,7 +493,7 @@ static int max77686_ldo_mode(struct udevice *dev, int op, int *opmode)
        }
 
        if (mode == 0xff) {
-               error("Wrong mode: %d for ldo%d", *opmode, ldo);
+               pr_err("Wrong mode: %d for ldo%d", *opmode, ldo);
                return -EINVAL;
        }
 
@@ -545,7 +545,7 @@ static int max77686_buck_mode(struct udevice *dev, int op, int *opmode)
 
        buck = dev->driver_data;
        if (buck < 1 || buck > MAX77686_BUCK_NUM) {
-               error("Wrong buck number: %d", buck);
+               pr_err("Wrong buck number: %d", buck);
                return -EINVAL;
        }
 
@@ -614,7 +614,7 @@ static int max77686_buck_mode(struct udevice *dev, int op, int *opmode)
        }
 
        if (mode == 0xff) {
-               error("Wrong mode: %d for buck: %d\n", *opmode, buck);
+               pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
                return -EINVAL;
        }
 
index 914500b729452fcb2e888b34fa2e337a4ad11c8f..116b7f480a796d61150179220e0af4d37b1ea55a 100644 (file)
@@ -70,14 +70,14 @@ static int pbias_ofdata_to_platdata(struct udevice *dev)
        err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
                                           "syscon", &syscon);
        if (err) {
-               error("%s: unable to find syscon device (%d)\n", __func__,
+               pr_err("%s: unable to find syscon device (%d)\n", __func__,
                      err);
                return err;
        }
 
        regmap = syscon_get_regmap(syscon);
        if (IS_ERR(regmap)) {
-               error("%s: unable to find regmap (%ld)\n", __func__,
+               pr_err("%s: unable to find regmap (%ld)\n", __func__,
                      PTR_ERR(regmap));
                return PTR_ERR(regmap);
        }
@@ -85,7 +85,7 @@ static int pbias_ofdata_to_platdata(struct udevice *dev)
 
        err = dev_read_resource(dev, 0, &res);
        if (err) {
-               error("%s: unable to find offset (%d)\n", __func__, err);
+               pr_err("%s: unable to find offset (%d)\n", __func__, err);
                return err;
        }
        priv->offset = res.start;
index 06c09fd05151ce7b7ad0f7e638a310f6f54fef13..f980a17389ebbec62be112cdd442e99cb0812697 100644 (file)
@@ -87,7 +87,7 @@ int out_get_value(struct udevice *dev, int output_count, int reg_type,
        int ret;
 
        if (dev->driver_data > output_count) {
-               error("Unknown regulator number: %lu for PMIC %s!",
+               pr_err("Unknown regulator number: %lu for PMIC %s!",
                      dev->driver_data, dev->name);
                return -EINVAL;
        }
@@ -95,7 +95,7 @@ int out_get_value(struct udevice *dev, int output_count, int reg_type,
        reg = (dev->driver_data - 1) * OUT_REG_COUNT + reg_type;
        ret = pmic_read(dev->parent, reg, &reg_val, 1);
        if (ret) {
-               error("PMIC read failed: %d\n",  ret);
+               pr_err("PMIC read failed: %d\n",  ret);
                return ret;
        }
 
@@ -115,14 +115,14 @@ static int out_set_value(struct udevice *dev, int output_count, int reg_type,
        int max_value;
 
        if (dev->driver_data > output_count) {
-               error("Unknown regulator number: %lu for PMIC %s!",
+               pr_err("Unknown regulator number: %lu for PMIC %s!",
                      dev->driver_data, dev->name);
                return -EINVAL;
        }
 
        max_value = range[dev->driver_data - 1].max;
        if (value > max_value) {
-               error("Wrong value for %s: %lu. Max is: %d.",
+               pr_err("Wrong value for %s: %lu. Max is: %d.",
                      dev->name, dev->driver_data, max_value);
                return -EINVAL;
        }
@@ -134,7 +134,7 @@ static int out_set_value(struct udevice *dev, int output_count, int reg_type,
        reg = (dev->driver_data - 1) * OUT_REG_COUNT + reg_type;
        ret = pmic_write(dev->parent, reg, &reg_val, 1);
        if (ret) {
-               error("PMIC write failed: %d\n",  ret);
+               pr_err("PMIC write failed: %d\n",  ret);
                return ret;
        }
 
@@ -154,7 +154,7 @@ static int out_get_mode(struct udevice *dev)
        reg = (dev->driver_data - 1) * OUT_REG_COUNT + OUT_REG_OM;
        ret = pmic_read(dev->parent, reg, &reg_val, 1);
        if (ret) {
-               error("PMIC read failed: %d\n",  ret);
+               pr_err("PMIC read failed: %d\n",  ret);
                return ret;
        }
 
@@ -163,7 +163,7 @@ static int out_get_mode(struct udevice *dev)
                        return uc_pdata->mode[i].id;
        }
 
-       error("Unknown operation mode for %s!", dev->name);
+       pr_err("Unknown operation mode for %s!", dev->name);
        return -EINVAL;
 }
 
@@ -188,14 +188,14 @@ static int out_set_mode(struct udevice *dev, int mode)
        }
 
        if (reg_val == -1) {
-               error("Unknown operation mode for %s!", dev->name);
+               pr_err("Unknown operation mode for %s!", dev->name);
                return -EINVAL;
        }
 
        reg = (dev->driver_data - 1) * OUT_REG_COUNT + OUT_REG_OM;
        ret = pmic_write(dev->parent, reg, (uint8_t *)&reg_val, 1);
        if (ret) {
-               error("PMIC write failed: %d\n",  ret);
+               pr_err("PMIC write failed: %d\n",  ret);
                return ret;
        }
 
index 7577ff0363d66cedba303597bbba13340f2850a1..bfcb1ddefe3d4916d287791fe9508e375f1560b2 100644 (file)
@@ -230,7 +230,7 @@ static int memory_init(struct rk3368_ddr_pctl *pctl,
        tmp = get_timer(0);
        do {
                if (get_timer(tmp) > timeout_ms) {
-                       error("%s: POWER_UP_START did not complete in %ld ms\n",
+                       pr_err("%s: POWER_UP_START did not complete in %ld ms\n",
                              __func__, timeout_ms);
                        return -ETIME;
                }
@@ -422,7 +422,7 @@ static int dfi_cfg(struct rk3368_ddr_pctl *pctl)
        tmp = get_timer(0);
        do {
                if (get_timer(tmp) > timeout_ms) {
-                       error("%s: DFI init did not complete within %ld ms\n",
+                       pr_err("%s: DFI init did not complete within %ld ms\n",
                              __func__, timeout_ms);
                        return -ETIME;
                }
@@ -457,7 +457,7 @@ static int pctl_calc_timings(struct rk3368_sdram_params *params,
        u32 tfaw_as_ps;
 
        if (params->ddr_speed_bin != DDR3_1600K) {
-               error("%s: unimplemented DDR3 speed bin %d\n",
+               pr_err("%s: unimplemented DDR3 speed bin %d\n",
                      __func__, params->ddr_speed_bin);
                return -1;
        }
@@ -585,7 +585,7 @@ static int ddrphy_data_training(struct rk3368_ddr_pctl *pctl,
        tmp = get_timer(0);
        do {
                if (get_timer(tmp) > timeout_ms) {
-                       error("%s: did not complete within %ld ms\n",
+                       pr_err("%s: did not complete within %ld ms\n",
                              __func__, timeout_ms);
                        return -ETIME;
                }
@@ -625,7 +625,7 @@ static int sdram_col_row_detect(struct udevice *dev)
        }
 
        if (col == 8) {
-               error("%s: col detect error\n", __func__);
+               pr_err("%s: col detect error\n", __func__);
                return -EINVAL;
        }
 
@@ -644,7 +644,7 @@ static int sdram_col_row_detect(struct udevice *dev)
        }
 
        if (row == 11) {
-               error("%s: row detect error\n", __func__);
+               pr_err("%s: row detect error\n", __func__);
                return -EINVAL;
        }
 
@@ -764,7 +764,7 @@ static int msch_niu_config(struct rk3368_msch *msch,
                }
        }
 
-       error("%s: ddrconf (NIU config) not found\n", __func__);
+       pr_err("%s: ddrconf (NIU config) not found\n", __func__);
        return -EINVAL;
 }
 
index 5ed4b03837d63f4b8482d914cfe786e1260b34ea..76c1fe80a7fb2c1c900f24a39496d56b91a0d068 100644 (file)
@@ -551,7 +551,7 @@ static int pctl_cfg(const struct chan_info *chan, u32 channel,
        tmp = get_timer(0);
        do {
                if (get_timer(tmp) > timeout_ms) {
-                       error("DRAM (%s): phy failed to lock within  %ld ms\n",
+                       pr_err("DRAM (%s): phy failed to lock within  %ld ms\n",
                              __func__, timeout_ms);
                        return -ETIME;
                }
index b1b0289a1b05b178c71511b791aeada31d3125ba..fdf088e783362398dcdc69d7e41ba66d73c7311a 100644 (file)
@@ -262,7 +262,7 @@ static int stm32_fmc_ofdata_to_platdata(struct udevice *dev)
                bank_name = (char *)ofnode_get_name(bank_node);
                strsep(&bank_name, "@");
                if (!bank_name) {
-                       error("missing sdram bank index");
+                       pr_err("missing sdram bank index");
                        return -EINVAL;
                }
 
@@ -271,7 +271,7 @@ static int stm32_fmc_ofdata_to_platdata(struct udevice *dev)
                               (long unsigned int *)&bank_params->target_bank);
 
                if (bank_params->target_bank >= MAX_SDRAM_BANK) {
-                       error("Found bank %d , but only bank 0 and 1 are supported",
+                       pr_err("Found bank %d , but only bank 0 and 1 are supported",
                              bank_params->target_bank);
                        return -EINVAL;
                }
@@ -285,7 +285,7 @@ static int stm32_fmc_ofdata_to_platdata(struct udevice *dev)
                                                  sizeof(struct stm32_sdram_control));
 
                if (!params->bank_params[bank].sdram_control) {
-                       error("st,sdram-control not found for %s",
+                       pr_err("st,sdram-control not found for %s",
                              ofnode_get_name(bank_node));
                        return -EINVAL;
                }
@@ -298,7 +298,7 @@ static int stm32_fmc_ofdata_to_platdata(struct udevice *dev)
                                                  sizeof(struct stm32_sdram_timing));
 
                if (!params->bank_params[bank].sdram_timing) {
-                       error("st,sdram-timing not found for %s",
+                       pr_err("st,sdram-timing not found for %s",
                              ofnode_get_name(bank_node));
                        return -EINVAL;
                }
index a79708cde2800a7169e905396afb808b15aa6767..024b996f0c16d9f506f66dd12174cd762362f71f 100644 (file)
@@ -201,20 +201,20 @@ phys_addr_t sti_reset_get_regmap(const char *compatible)
        node = fdt_node_offset_by_compatible(gd->fdt_blob, -1,
                                             compatible);
        if (node < 0) {
-               error("unable to find %s node\n", compatible);
+               pr_err("unable to find %s node\n", compatible);
                return node;
        }
 
        ret = uclass_get_device_by_of_offset(UCLASS_SYSCON, node, &syscon);
        if (ret) {
-               error("%s: uclass_get_device_by_of_offset failed: %d\n",
+               pr_err("%s: uclass_get_device_by_of_offset failed: %d\n",
                      __func__, ret);
                return ret;
        }
 
        regmap = syscon_get_regmap(syscon);
        if (!regmap) {
-               error("unable to get regmap for %s\n", syscon->name);
+               pr_err("unable to get regmap for %s\n", syscon->name);
                return -ENODEV;
        }
 
@@ -251,7 +251,7 @@ static int sti_reset_program_hw(struct reset_ctl *reset_ctl, int assert)
                        if (ch->deassert_cnt > 0)
                                return 0;
                } else
-                       error("Reset balancing error: reset_ctl=%p dev=%p id=%lu\n",
+                       pr_err("Reset balancing error: reset_ctl=%p dev=%p id=%lu\n",
                              reset_ctl, reset_ctl->dev, reset_ctl->id);
        }
 
@@ -268,7 +268,7 @@ static int sti_reset_program_hw(struct reset_ctl *reset_ctl, int assert)
        reg = (void __iomem *)base + ch->ack_offset;
        if (wait_for_bit(__func__, reg, BIT(ch->ack_bit), ctrl_val,
                         1000, false)) {
-               error("Stuck on waiting ack reset_ctl=%p dev=%p id=%lu\n",
+               pr_err("Stuck on waiting ack reset_ctl=%p dev=%p id=%lu\n",
                      reset_ctl, reset_ctl->dev, reset_ctl->id);
 
                return -ETIMEDOUT;
index e2f8342e887f1b03c0ddb124542a5cf30e1b9d12..228e714e093374a0494e8fd69cfe85330d92e5c4 100644 (file)
@@ -474,7 +474,7 @@ static int atmel_spi_probe(struct udevice *bus)
        ret = gpio_request_list_by_name(bus, "cs-gpios", priv->cs_gpios,
                                        ARRAY_SIZE(priv->cs_gpios), 0);
        if (ret < 0) {
-               error("Can't get %s gpios! Error: %d", bus->name, ret);
+               pr_err("Can't get %s gpios! Error: %d", bus->name, ret);
                return ret;
        }
 
index c5b766c0dd003cc86a38c8ba041b95cfc960b3d3..e2a593b93444e82fa06d80a4e83acc8e80a7a423 100644 (file)
@@ -66,17 +66,17 @@ struct spi_slave *spi_setup_slave(uint bus, uint cs, uint max_hz, uint mode)
        /* we only set up SSP0 for now, so ignore bus */
 
        if (mode & SPI_3WIRE) {
-               error("3-wire mode not supported");
+               pr_err("3-wire mode not supported");
                return NULL;
        }
 
        if (mode & SPI_SLAVE) {
-               error("slave mode not supported\n");
+               pr_err("slave mode not supported\n");
                return NULL;
        }
 
        if (mode & SPI_PREAMBLE) {
-               error("preamble byte skipping not supported\n");
+               pr_err("preamble byte skipping not supported\n");
                return NULL;
        }
 
index 9b58aa8e97b2a4391fdc7b61a766242091d958fd..bf698a737bd74a24db377b21d178b6b5a0fbc576 100644 (file)
@@ -39,7 +39,7 @@ static int sti_sysreset_probe(struct udevice *dev)
                                             "st,syscfg", NULL, 0, 0,
                                             &syscfg_phandle);
        if (ret < 0) {
-               error("Can't get syscfg phandle: %d\n", ret);
+               pr_err("Can't get syscfg phandle: %d\n", ret);
                return ret;
        }
 
@@ -47,14 +47,14 @@ static int sti_sysreset_probe(struct udevice *dev)
                                             syscfg_phandle.node,
                                             &syscon);
        if (ret) {
-               error("%s: uclass_get_device_by_of_offset failed: %d\n",
+               pr_err("%s: uclass_get_device_by_of_offset failed: %d\n",
                      __func__, ret);
                return ret;
        }
 
        regmap = syscon_get_regmap(syscon);
        if (!regmap) {
-               error("unable to get regmap for %s\n", syscon->name);
+               pr_err("unable to get regmap for %s\n", syscon->name);
                return -ENODEV;
        }
 
index 3818faeb462fe7761c20c8b42e2e90f3dad2167c..3abce7f678679ac838476f77773eabefea9e9802 100644 (file)
@@ -45,13 +45,13 @@ int syscon_reboot_probe(struct udevice *dev)
        err = uclass_get_device_by_phandle(UCLASS_SYSCON, dev,
                                           "regmap", &syscon);
        if (err) {
-               error("unable to find syscon device\n");
+               pr_err("unable to find syscon device\n");
                return err;
        }
 
        priv->regmap = syscon_get_regmap(syscon);
        if (!priv->regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
 
index 304ed052a2c317faed4ab3d87fd3bdc853cf9c04..ab250aea292ffa3e41dc669cf8345d563c93cd2f 100644 (file)
@@ -38,7 +38,7 @@ int wdt_reboot_probe(struct udevice *dev)
        err = uclass_get_device_by_phandle(UCLASS_WDT, dev,
                                           "wdt", &priv->wdt);
        if (err) {
-               error("unable to find wdt device\n");
+               pr_err("unable to find wdt device\n");
                return err;
        }
 
index ef3ff0dbf67eb6705bf51e444661f8963a7ca4a7..e3e20d899689af107bf1abc9b10b538bb467146a 100644 (file)
@@ -539,7 +539,7 @@ static int tpm_tis_i2c_init(struct udevice *dev)
        }
 
        if (chip->chip_type != UNKNOWN && vendor != expected_did_vid) {
-               error("Vendor id did not match! ID was %08x\n", vendor);
+               pr_err("Vendor id did not match! ID was %08x\n", vendor);
                return -ENODEV;
        }
 
index 35c2dc18d9554eb3b75f0eff4d65e0e2f8f99733..e8432bb016eb9f707e11d6fd8292c9e345366e94 100644 (file)
@@ -28,7 +28,7 @@ enum usb_dr_mode usb_get_dr_mode(int node)
 
        dr_mode = fdt_getprop(fdt, node, "dr_mode", NULL);
        if (!dr_mode) {
-               error("usb dr_mode not found\n");
+               pr_err("usb dr_mode not found\n");
                return USB_DR_MODE_UNKNOWN;
        }
 
index 4abef5d5c88ef58fa7f10f547ec7411c22558e1a..941d612a68a8e21162cd45606abadeeb560ba738 100644 (file)
@@ -418,25 +418,25 @@ static int mcs7830_basic_reset(struct usb_device *udev,
 
        rc = mcs7830_set_autoneg(udev);
        if (rc < 0) {
-               error("setting autoneg failed\n");
+               pr_err("setting autoneg failed\n");
                return rc;
        }
 
        rc = mcs7830_write_mchash(udev, priv);
        if (rc < 0) {
-               error("failed to set multicast hash\n");
+               pr_err("failed to set multicast hash\n");
                return rc;
        }
 
        rc = mcs7830_write_config(udev, priv);
        if (rc < 0) {
-               error("failed to set configuration\n");
+               pr_err("failed to set configuration\n");
                return rc;
        }
 
        rc = mcs7830_apply_fixup(udev);
        if (rc < 0) {
-               error("fixup application failed\n");
+               pr_err("fixup application failed\n");
                return rc;
        }
 
@@ -541,11 +541,11 @@ static int mcs7830_recv_common(struct ueth_data *ueth, uint8_t *buf)
        debug("%s() RX want len %d, got len %d, rc %d\n",
              __func__, wantlen, gotlen, rc);
        if (rc != 0) {
-               error("RX: failed to receive\n");
+               pr_err("RX: failed to receive\n");
                return rc;
        }
        if (gotlen > wantlen) {
-               error("RX: got too many bytes (%d)\n", gotlen);
+               pr_err("RX: got too many bytes (%d)\n", gotlen);
                return -EIO;
        }
 
index 9df6d32c65f9b76be4d48e22ae2ed0a1303cd818..ad2f606b78bc97148e6c1cb9f169151f63ae1ee9 100644 (file)
@@ -1456,7 +1456,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
        ret = driver->bind(&udc->gadget);
        if (ret) {
-               error("driver->bind() returned %d\n", ret);
+               pr_err("driver->bind() returned %d\n", ret);
                udc->driver = NULL;
        }
 
@@ -1468,7 +1468,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
        struct at91_udc *udc = controller;
 
        if (!driver || !driver->unbind || !driver->disconnect) {
-               error("bad paramter\n");
+               pr_err("bad paramter\n");
                return -EINVAL;
        }
 
index ad31703c7376d78521103d188d572b195787e0bb..c0a95a97c9f4fe6cd97c173cda0bbb7174719a9c 100644 (file)
@@ -1228,7 +1228,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
 
        ret = driver->bind(&udc->gadget);
        if (ret) {
-               error("driver->bind() returned %d\n", ret);
+               pr_err("driver->bind() returned %d\n", ret);
                udc->driver = NULL;
        }
 
@@ -1240,7 +1240,7 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
        struct usba_udc *udc = &controller;
 
        if (!driver || !driver->unbind || !driver->disconnect) {
-               error("bad paramter\n");
+               pr_err("bad paramter\n");
                return -EINVAL;
        }
 
@@ -1261,7 +1261,7 @@ static struct usba_ep *usba_udc_pdata(struct usba_platform_data *pdata,
 
        eps = malloc(sizeof(struct usba_ep) * pdata->num_ep);
        if (!eps) {
-               error("failed to alloc eps\n");
+               pr_err("failed to alloc eps\n");
                return NULL;
        }
 
index cb44374e81a615c2c4cccdc7cb526ee5b5444721..088811c191365adba3a4b9421fe84f8967ea81ba 100644 (file)
@@ -835,7 +835,7 @@ int dwc2_udc_probe(struct dwc2_plat_otg_data *pdata)
                            ROUND(sizeof(struct usb_ctrlrequest),
                                  CONFIG_SYS_CACHELINE_SIZE));
        if (!usb_ctrl) {
-               error("No memory available for UDC!\n");
+               pr_err("No memory available for UDC!\n");
                return -ENOMEM;
        }
 
index 2cf5c8d31e25acb1c8a557d8e38e2ec7e84fa1ad..2e0ff452d85f511917e680d1b108821651fd6dbe 100644 (file)
@@ -1059,7 +1059,7 @@ static int eth_set_config(struct eth_dev *dev, unsigned number,
                        && dev->config
                        && dev->tx_qlen != 0) {
                /* tx fifo is full, but we can't clear it...*/
-               error("can't change configurations");
+               pr_err("can't change configurations");
                return -ESPIPE;
        }
        eth_reset_config(dev);
@@ -1233,7 +1233,7 @@ static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
        /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
        status = rndis_msg_parser(dev->rndis_config, (u8 *) req->buf);
        if (status < 0)
-               error("%s: rndis parse error %d", __func__, status);
+               pr_err("%s: rndis parse error %d", __func__, status);
 }
 
 #endif /* RNDIS */
@@ -1554,7 +1554,7 @@ static int rx_submit(struct eth_dev *dev, struct usb_request *req,
        retval = usb_ep_queue(dev->out_ep, req, gfp_flags);
 
        if (retval)
-               error("rx submit --> %d", retval);
+               pr_err("rx submit --> %d", retval);
 
        return retval;
 }
@@ -1624,7 +1624,7 @@ static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
 fail2:
        usb_ep_free_request(dev->in_ep, dev->tx_req);
 fail1:
-       error("can't alloc requests");
+       pr_err("can't alloc requests");
        return -1;
 }
 
@@ -2060,7 +2060,7 @@ static int eth_bind(struct usb_gadget *gadget)
                 * anything less functional on CDC-capable hardware,
                 * so we fail in this case.
                 */
-               error("controller '%s' not recognized",
+               pr_err("controller '%s' not recognized",
                        gadget->name);
                return -ENODEV;
        }
@@ -2121,7 +2121,7 @@ static int eth_bind(struct usb_gadget *gadget)
        in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);
        if (!in_ep) {
 autoconf_fail:
-               error("can't autoconfigure on %s\n",
+               pr_err("can't autoconfigure on %s\n",
                        gadget->name);
                return -ENODEV;
        }
@@ -2142,7 +2142,7 @@ autoconf_fail:
                if (status_ep) {
                        status_ep->driver_data = status_ep;     /* claim */
                } else if (rndis) {
-                       error("can't run RNDIS on %s", gadget->name);
+                       pr_err("can't run RNDIS on %s", gadget->name);
                        return -ENODEV;
 #ifdef CONFIG_USB_ETH_CDC
                } else if (cdc) {
@@ -2244,7 +2244,7 @@ autoconf_fail:
        if (rndis) {
                status = rndis_init();
                if (status < 0) {
-                       error("can't init RNDIS, %d", status);
+                       pr_err("can't init RNDIS, %d", status);
                        goto fail;
                }
        }
@@ -2335,7 +2335,7 @@ fail0:
        return 0;
 
 fail:
-       error("%s failed, status = %d", __func__, status);
+       pr_err("%s failed, status = %d", __func__, status);
        eth_unbind(gadget);
        return status;
 }
@@ -2350,7 +2350,7 @@ int dm_usb_init(struct eth_dev *e_dev)
 
        ret = uclass_first_device(UCLASS_USB_DEV_GENERIC, &dev);
        if (!dev || ret) {
-               error("No USB device found\n");
+               pr_err("No USB device found\n");
                return -ENODEV;
        }
 
@@ -2369,7 +2369,7 @@ static int _usb_eth_init(struct ether_priv *priv)
 
 #ifdef CONFIG_DM_USB
        if (dm_usb_init(dev)) {
-               error("USB ether not found\n");
+               pr_err("USB ether not found\n");
                return -ENODEV;
        }
 #else
@@ -2393,11 +2393,11 @@ static int _usb_eth_init(struct ether_priv *priv)
                        sizeof(host_addr));
 
        if (!is_eth_addr_valid(dev_addr)) {
-               error("Need valid 'usbnet_devaddr' to be set");
+               pr_err("Need valid 'usbnet_devaddr' to be set");
                goto fail;
        }
        if (!is_eth_addr_valid(host_addr)) {
-               error("Need valid 'usbnet_hostaddr' to be set");
+               pr_err("Need valid 'usbnet_hostaddr' to be set");
                goto fail;
        }
 
@@ -2427,7 +2427,7 @@ static int _usb_eth_init(struct ether_priv *priv)
        while (!dev->network_started) {
                /* Handle control-c and timeouts */
                if (ctrlc() || (get_timer(ts) > timeout)) {
-                       error("The remote end did not respond in time.");
+                       pr_err("The remote end did not respond in time.");
                        goto fail;
                }
                usb_gadget_handle_interrupts(0);
@@ -2456,7 +2456,7 @@ static int _usb_eth_send(struct ether_priv *priv, void *packet, int length)
                rndis_pkt = malloc(length +
                                        sizeof(struct rndis_packet_msg_type));
                if (!rndis_pkt) {
-                       error("No memory to alloc RNDIS packet");
+                       pr_err("No memory to alloc RNDIS packet");
                        goto drop;
                }
                rndis_add_hdr(rndis_pkt, length);
@@ -2574,7 +2574,7 @@ static int usb_eth_recv(struct eth_device *netdev)
 
        ret = _usb_eth_recv(priv);
        if (ret) {
-               error("error packet receive\n");
+               pr_err("error packet receive\n");
                return ret;
        }
 
@@ -2585,7 +2585,7 @@ static int usb_eth_recv(struct eth_device *netdev)
                net_process_received_packet(net_rx_packets[0],
                                            dev->rx_req->length);
        } else {
-               error("dev->rx_req invalid");
+               pr_err("dev->rx_req invalid");
        }
        packet_received = 0;
        rx_submit(dev, dev->rx_req, 0);
@@ -2641,7 +2641,7 @@ static int usb_eth_recv(struct udevice *dev, int flags, uchar **packetp)
 
        ret = _usb_eth_recv(priv);
        if (ret) {
-               error("error packet receive\n");
+               pr_err("error packet receive\n");
                return ret;
        }
 
@@ -2650,7 +2650,7 @@ static int usb_eth_recv(struct udevice *dev, int flags, uchar **packetp)
                        *packetp = (uchar *)net_rx_packets[0];
                        return ethdev->rx_req->length;
                } else {
-                       error("dev->rx_req invalid");
+                       pr_err("dev->rx_req invalid");
                        return -EFAULT;
                }
        }
@@ -2706,13 +2706,13 @@ int usb_ether_init(void)
 
        ret = uclass_first_device(UCLASS_USB_DEV_GENERIC, &usb_dev);
        if (!usb_dev || ret) {
-               error("No USB device found\n");
+               pr_err("No USB device found\n");
                return ret;
        }
 
        ret = device_bind_driver(usb_dev, "usb_ether", "usb_ether", &dev);
        if (!dev || ret) {
-               error("usb - not able to bind usb_ether device\n");
+               pr_err("usb - not able to bind usb_ether device\n");
                return ret;
        }
 
index f3382a965bedb1128528279c245bcb8d65f6eeb3..7acffb6c87e062757f2bc820100b2896c75a0d27 100644 (file)
@@ -410,7 +410,7 @@ static void cb_getvar(struct usb_ep *ep, struct usb_request *req)
 
        strsep(&cmd, ":");
        if (!cmd) {
-               error("missing variable");
+               pr_err("missing variable");
                fastboot_tx_write_str("FAILmissing var");
                return;
        }
@@ -593,7 +593,7 @@ static void cb_flash(struct usb_ep *ep, struct usb_request *req)
 
        strsep(&cmd, ":");
        if (!cmd) {
-               error("missing partition name");
+               pr_err("missing partition name");
                fastboot_tx_write_str("FAILmissing partition name");
                return;
        }
@@ -645,7 +645,7 @@ static void cb_erase(struct usb_ep *ep, struct usb_request *req)
 
        strsep(&cmd, ":");
        if (!cmd) {
-               error("missing partition name");
+               pr_err("missing partition name");
                fastboot_tx_write_str("FAILmissing partition name");
                return;
        }
@@ -718,7 +718,7 @@ static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
        }
 
        if (!func_cb) {
-               error("unknown command: %.*s", req->actual, cmdbuf);
+               pr_err("unknown command: %.*s", req->actual, cmdbuf);
                fastboot_tx_write_str("FAILunknown command");
        } else {
                if (req->actual < req->length) {
@@ -726,7 +726,7 @@ static void rx_handler_command(struct usb_ep *ep, struct usb_request *req)
                        buf[req->actual] = 0;
                        func_cb(ep, req);
                } else {
-                       error("buffer overflow");
+                       pr_err("buffer overflow");
                        fastboot_tx_write_str("FAILbuffer overflow");
                }
        }
index 0fae66beabab06b1d884a9543bd096509119a286..fd3da922a690ed1d80908a0e4fcd9af12012cc28 100644 (file)
@@ -237,12 +237,12 @@ static void sdp_rx_command_complete(struct usb_ep *ep, struct usb_request *req)
        u8 report = data[0];
 
        if (status != 0) {
-               error("Status: %d", status);
+               pr_err("Status: %d", status);
                return;
        }
 
        if (report != 1) {
-               error("Unexpected report %d", report);
+               pr_err("Unexpected report %d", report);
                return;
        }
 
@@ -309,7 +309,7 @@ static void sdp_rx_command_complete(struct usb_ep *ep, struct usb_request *req)
                sdp->next_state = SDP_STATE_IDLE;
                break;
        default:
-               error("Unknown command: %04x\n", be16_to_cpu(cmd->cmd));
+               pr_err("Unknown command: %04x\n", be16_to_cpu(cmd->cmd));
        }
 }
 
@@ -322,12 +322,12 @@ static void sdp_rx_data_complete(struct usb_ep *ep, struct usb_request *req)
        int datalen = req->length - 1;
 
        if (status != 0) {
-               error("Status: %d", status);
+               pr_err("Status: %d", status);
                return;
        }
 
        if (report != 2) {
-               error("Unexpected report %d", report);
+               pr_err("Unexpected report %d", report);
                return;
        }
 
@@ -360,7 +360,7 @@ static void sdp_rx_data_complete(struct usb_ep *ep, struct usb_request *req)
                sdp->state = SDP_STATE_TX_SEC_CONF;
                break;
        default:
-               error("Invalid state: %d", sdp->state);
+               pr_err("Invalid state: %d", sdp->state);
        }
 }
 
@@ -370,7 +370,7 @@ static void sdp_tx_complete(struct usb_ep *ep, struct usb_request *req)
        int status = req->status;
 
        if (status != 0) {
-               error("Status: %d", status);
+               pr_err("Status: %d", status);
                return;
        }
 
@@ -393,7 +393,7 @@ static void sdp_tx_complete(struct usb_ep *ep, struct usb_request *req)
                        sdp->state = SDP_STATE_IDLE;
                break;
        default:
-               error("Wrong State: %d", sdp->state);
+               pr_err("Wrong State: %d", sdp->state);
                sdp->state = SDP_STATE_IDLE;
                break;
        }
index cd4d9e659a39bb7b205a1898531194c71901c439..18f233ab587617cfb8e5d85780d47c91cd7b7f9e 100644 (file)
@@ -174,7 +174,7 @@ static long long int download_head(unsigned long long total,
                                        transfer_buffer, THOR_STORE_UNIT_SIZE,
                                        (*cnt)++);
                        if (ret) {
-                               error("DFU write failed [%d] cnt: %d",
+                               pr_err("DFU write failed [%d] cnt: %d",
                                      ret, *cnt);
                                return ret;
                        }
@@ -218,20 +218,20 @@ static int download_tail(long long int left, int cnt)
 
        dfu_entity = dfu_get_entity(alt_setting_num);
        if (!dfu_entity) {
-               error("Alt setting: %d entity not found!\n", alt_setting_num);
+               pr_err("Alt setting: %d entity not found!\n", alt_setting_num);
                return -ENOENT;
        }
 
        transfer_buffer = dfu_get_buf(dfu_entity);
        if (!transfer_buffer) {
-               error("Transfer buffer not allocated!");
+               pr_err("Transfer buffer not allocated!");
                return -ENXIO;
        }
 
        if (left) {
                ret = dfu_write(dfu_entity, transfer_buffer, left, cnt++);
                if (ret) {
-                       error("DFU write failed [%d]: left: %llu", ret, left);
+                       pr_err("DFU write failed [%d]: left: %llu", ret, left);
                        return ret;
                }
        }
@@ -245,7 +245,7 @@ static int download_tail(long long int left, int cnt)
         */
        ret = dfu_flush(dfu_entity, transfer_buffer, 0, cnt);
        if (ret)
-               error("DFU flush failed!");
+               pr_err("DFU flush failed!");
 
        return ret;
 }
@@ -285,7 +285,7 @@ static long long int process_rqt_download(const struct rqt_box *rqt)
 
                alt_setting_num = dfu_get_alt(f_name);
                if (alt_setting_num < 0) {
-                       error("Alt setting [%d] to write not found!",
+                       pr_err("Alt setting [%d] to write not found!",
                              alt_setting_num);
                        rsp->ack = -ENODEV;
                        ret = rsp->ack;
@@ -311,7 +311,7 @@ static long long int process_rqt_download(const struct rqt_box *rqt)
                debug("DL EXIT\n");
                break;
        default:
-               error("Operation not supported: %d", rqt->rqt_data);
+               pr_err("Operation not supported: %d", rqt->rqt_data);
                ret = -ENOTSUPP;
        }
 
@@ -342,7 +342,7 @@ static int process_data(void)
                puts("RQT: UPLOAD not supported!\n");
                break;
        default:
-               error("unknown request (%d)", rqt->rqt);
+               pr_err("unknown request (%d)", rqt->rqt);
        }
 
        return ret;
@@ -541,7 +541,7 @@ static int thor_rx_data(void)
 
                status = usb_ep_queue(dev->out_ep, dev->out_req, 0);
                if (status) {
-                       error("kill %s:  resubmit %d bytes --> %d",
+                       pr_err("kill %s:  resubmit %d bytes --> %d",
                              dev->out_ep->name, dev->out_req->length, status);
                        usb_ep_set_halt(dev->out_ep);
                        return -EAGAIN;
@@ -575,7 +575,7 @@ static void thor_tx_data(unsigned char *data, int len)
 
        status = usb_ep_queue(dev->in_ep, dev->in_req, 0);
        if (status) {
-               error("kill %s:  resubmit %d bytes --> %d",
+               pr_err("kill %s:  resubmit %d bytes --> %d",
                      dev->in_ep->name, dev->in_req->length, status);
                usb_ep_set_halt(dev->in_ep);
        }
@@ -608,7 +608,7 @@ static void thor_rx_tx_complete(struct usb_ep *ep, struct usb_request *req)
        case -ESHUTDOWN:                /* disconnect from host */
        case -EREMOTEIO:                /* short read */
        case -EOVERFLOW:
-               error("ERROR:%d", status);
+               pr_err("ERROR:%d", status);
                break;
        }
 
@@ -664,7 +664,7 @@ thor_func_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
                break;
 
        default:
-               error("thor_setup: unknown request: %d", ctrl->bRequest);
+               pr_err("thor_setup: unknown request: %d", ctrl->bRequest);
        }
 
        if (value >= 0) {
@@ -973,7 +973,7 @@ static int thor_func_set_alt(struct usb_function *f,
                debug("Communication Data interface\n");
                result = thor_eps_setup(f);
                if (result)
-                       error("%s: EPs setup failed!", __func__);
+                       pr_err("%s: EPs setup failed!", __func__);
                dev->configuration_done = 1;
                break;
        }
index 0ed72d5ae71acccf68a728ee78e293f02e79ecd6..1293e18f75e74da33ccdd3dea7bc8c779af02d21 100644 (file)
@@ -179,7 +179,7 @@ static int dwc_vbus_supply_init(struct udevice *dev)
 
        ret = regulator_set_enable(vbus_supply, true);
        if (ret) {
-               error("Error enabling vbus supply\n");
+               pr_err("Error enabling vbus supply\n");
                return ret;
        }
 
index 02ad3115df431ec4f46cd1b09271788dc9dcf2b2..6dc656af89b0fb0a1d838f790d37d4642543dbbc 100644 (file)
@@ -71,7 +71,7 @@ static int sti_dwc3_glue_drd_init(struct sti_dwc3_glue_platdata *plat)
                break;
 
        default:
-               error("Unsupported mode of operation %d\n", plat->mode);
+               pr_err("Unsupported mode of operation %d\n", plat->mode);
                return -EINVAL;
        }
        writel(val, plat->syscfg_base + plat->syscfg_offset);
@@ -113,7 +113,7 @@ static int sti_dwc3_glue_ofdata_to_platdata(struct udevice *dev)
        ret = fdtdec_get_int_array(gd->fdt_blob, dev_of_offset(dev),
                                   "reg", reg, ARRAY_SIZE(reg));
        if (ret) {
-               error("unable to find st,stih407-dwc3 reg property(%d)\n", ret);
+               pr_err("unable to find st,stih407-dwc3 reg property(%d)\n", ret);
                return ret;
        }
 
@@ -124,14 +124,14 @@ static int sti_dwc3_glue_ofdata_to_platdata(struct udevice *dev)
        ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "st,syscfg",
                                           &syscon);
        if (ret) {
-               error("unable to find syscon device (%d)\n", ret);
+               pr_err("unable to find syscon device (%d)\n", ret);
                return ret;
        }
 
        /* get syscfg-reg base address */
        regmap = syscon_get_regmap(syscon);
        if (!regmap) {
-               error("unable to find regmap\n");
+               pr_err("unable to find regmap\n");
                return -ENODEV;
        }
        plat->syscfg_base = regmap->base;
@@ -139,14 +139,14 @@ static int sti_dwc3_glue_ofdata_to_platdata(struct udevice *dev)
        /* get powerdown reset */
        ret = reset_get_by_name(dev, "powerdown", &plat->powerdown_ctl);
        if (ret) {
-               error("can't get powerdown reset for %s (%d)", dev->name, ret);
+               pr_err("can't get powerdown reset for %s (%d)", dev->name, ret);
                return ret;
        }
 
        /* get softreset reset */
        ret = reset_get_by_name(dev, "softreset", &plat->softreset_ctl);
        if (ret)
-               error("can't get soft reset for %s (%d)", dev->name, ret);
+               pr_err("can't get soft reset for %s (%d)", dev->name, ret);
 
        return ret;
 };
@@ -159,14 +159,14 @@ static int sti_dwc3_glue_bind(struct udevice *dev)
        /* check if one subnode is present */
        dwc3_node = fdt_first_subnode(gd->fdt_blob, dev_of_offset(dev));
        if (dwc3_node <= 0) {
-               error("Can't find subnode for %s\n", dev->name);
+               pr_err("Can't find subnode for %s\n", dev->name);
                return -ENODEV;
        }
 
        /* check if the subnode compatible string is the dwc3 one*/
        if (fdt_node_check_compatible(gd->fdt_blob, dwc3_node,
                                      "snps,dwc3") != 0) {
-               error("Can't find dwc3 subnode for %s\n", dev->name);
+               pr_err("Can't find dwc3 subnode for %s\n", dev->name);
                return -ENODEV;
        }
 
@@ -187,13 +187,13 @@ static int sti_dwc3_glue_probe(struct udevice *dev)
        /* deassert both powerdown and softreset */
        ret = reset_deassert(&plat->powerdown_ctl);
        if (ret < 0) {
-               error("DWC3 powerdown reset deassert failed: %d", ret);
+               pr_err("DWC3 powerdown reset deassert failed: %d", ret);
                return ret;
        }
 
        ret = reset_deassert(&plat->softreset_ctl);
        if (ret < 0) {
-               error("DWC3 soft reset deassert failed: %d", ret);
+               pr_err("DWC3 soft reset deassert failed: %d", ret);
                goto softreset_err;
        }
 
@@ -208,14 +208,14 @@ static int sti_dwc3_glue_probe(struct udevice *dev)
 init_err:
        ret = reset_assert(&plat->softreset_ctl);
        if (ret < 0) {
-               error("DWC3 soft reset deassert failed: %d", ret);
+               pr_err("DWC3 soft reset deassert failed: %d", ret);
                return ret;
        }
 
 softreset_err:
        ret = reset_assert(&plat->powerdown_ctl);
        if (ret < 0)
-               error("DWC3 powerdown reset deassert failed: %d", ret);
+               pr_err("DWC3 powerdown reset deassert failed: %d", ret);
 
        return ret;
 }
@@ -228,13 +228,13 @@ static int sti_dwc3_glue_remove(struct udevice *dev)
        /* assert both powerdown and softreset */
        ret = reset_assert(&plat->powerdown_ctl);
        if (ret < 0) {
-               error("DWC3 powerdown reset deassert failed: %d", ret);
+               pr_err("DWC3 powerdown reset deassert failed: %d", ret);
                return ret;
        }
 
        ret = reset_assert(&plat->softreset_ctl);
        if (ret < 0)
-               error("DWC3 soft reset deassert failed: %d", ret);
+               pr_err("DWC3 soft reset deassert failed: %d", ret);
 
        return ret;
 }
index 18e1e0ee8852a7e15ab65cb41b90512805f34ed5..1cb92c033870887939ee40915ce8af4562f8847b 100644 (file)
@@ -51,7 +51,7 @@ static int ehci_usb_probe(struct udevice *dev)
                                break;
                        err = clk_enable(&priv->clocks[i]);
                        if (err) {
-                               error("failed to enable clock %d\n", i);
+                               pr_err("failed to enable clock %d\n", i);
                                clk_free(&priv->clocks[i]);
                                goto clk_err;
                        }
@@ -59,7 +59,7 @@ static int ehci_usb_probe(struct udevice *dev)
                }
        } else {
                if (clock_nb != -ENOENT) {
-                       error("failed to get clock phandle(%d)\n", clock_nb);
+                       pr_err("failed to get clock phandle(%d)\n", clock_nb);
                        return clock_nb;
                }
        }
@@ -80,7 +80,7 @@ static int ehci_usb_probe(struct udevice *dev)
                                break;
 
                        if (reset_deassert(&priv->resets[i])) {
-                               error("failed to deassert reset %d\n", i);
+                               pr_err("failed to deassert reset %d\n", i);
                                reset_free(&priv->resets[i]);
                                goto reset_err;
                        }
@@ -88,7 +88,7 @@ static int ehci_usb_probe(struct udevice *dev)
                }
        } else {
                if (reset_nb != -ENOENT) {
-                       error("failed to get reset phandle(%d)\n", reset_nb);
+                       pr_err("failed to get reset phandle(%d)\n", reset_nb);
                        goto clk_err;
                }
        }
@@ -96,14 +96,14 @@ static int ehci_usb_probe(struct udevice *dev)
        err = generic_phy_get_by_index(dev, 0, &priv->phy);
        if (err) {
                if (err != -ENOENT) {
-                       error("failed to get usb phy\n");
+                       pr_err("failed to get usb phy\n");
                        goto reset_err;
                }
        } else {
 
                err = generic_phy_init(&priv->phy);
                if (err) {
-                       error("failed to init usb phy\n");
+                       pr_err("failed to init usb phy\n");
                        goto reset_err;
                }
        }
@@ -122,17 +122,17 @@ phy_err:
        if (generic_phy_valid(&priv->phy)) {
                ret = generic_phy_exit(&priv->phy);
                if (ret)
-                       error("failed to release phy\n");
+                       pr_err("failed to release phy\n");
        }
 
 reset_err:
        ret = reset_release_all(priv->resets, priv->reset_count);
        if (ret)
-               error("failed to assert all resets\n");
+               pr_err("failed to assert all resets\n");
 clk_err:
        ret = clk_release_all(priv->clocks, priv->clock_count);
        if (ret)
-               error("failed to disable all clocks\n");
+               pr_err("failed to disable all clocks\n");
 
        return err;
 }
index e22ee9793914d27b7b146303881a18054eacd695..bf55a71d66c22fb09ea5bd7ac5a15664d51b5b57 100644 (file)
@@ -47,14 +47,14 @@ static int ohci_usb_probe(struct udevice *dev)
 
                        err = clk_enable(&priv->clocks[i]);
                        if (err) {
-                               error("failed to enable clock %d\n", i);
+                               pr_err("failed to enable clock %d\n", i);
                                clk_free(&priv->clocks[i]);
                                goto clk_err;
                        }
                        priv->clock_count++;
                }
        } else if (clock_nb != -ENOENT) {
-               error("failed to get clock phandle(%d)\n", clock_nb);
+               pr_err("failed to get clock phandle(%d)\n", clock_nb);
                return clock_nb;
        }
 
@@ -74,28 +74,28 @@ static int ohci_usb_probe(struct udevice *dev)
 
                        err = reset_deassert(&priv->resets[i]);
                        if (err) {
-                               error("failed to deassert reset %d\n", i);
+                               pr_err("failed to deassert reset %d\n", i);
                                reset_free(&priv->resets[i]);
                                goto reset_err;
                        }
                        priv->reset_count++;
                }
        } else if (reset_nb != -ENOENT) {
-               error("failed to get reset phandle(%d)\n", reset_nb);
+               pr_err("failed to get reset phandle(%d)\n", reset_nb);
                goto clk_err;
        }
 
        err = generic_phy_get_by_index(dev, 0, &priv->phy);
        if (err) {
                if (err != -ENOENT) {
-                       error("failed to get usb phy\n");
+                       pr_err("failed to get usb phy\n");
                        goto reset_err;
                }
        } else {
 
                err = generic_phy_init(&priv->phy);
                if (err) {
-                       error("failed to init usb phy\n");
+                       pr_err("failed to init usb phy\n");
                        goto reset_err;
                }
        }
@@ -110,17 +110,17 @@ phy_err:
        if (generic_phy_valid(&priv->phy)) {
                ret = generic_phy_exit(&priv->phy);
                if (ret)
-                       error("failed to release phy\n");
+                       pr_err("failed to release phy\n");
        }
 
 reset_err:
        ret = reset_release_all(priv->resets, priv->reset_count);
        if (ret)
-               error("failed to assert all resets\n");
+               pr_err("failed to assert all resets\n");
 clk_err:
        ret = clk_release_all(priv->clocks, priv->clock_count);
        if (ret)
-               error("failed to disable all clocks\n");
+               pr_err("failed to disable all clocks\n");
 
        return err;
 }
index 4191a894218f64141108b837b45f4d4112b11165..258d1cd00a085adaa9cf1c613947eaf43c3767aa 100644 (file)
@@ -128,13 +128,13 @@ static int xhci_dwc3_probe(struct udevice *dev)
        ret = generic_phy_get_by_index(dev, 0, &plat->usb_phy);
        if (ret) {
                if (ret != -ENOENT) {
-                       error("Failed to get USB PHY for %s\n", dev->name);
+                       pr_err("Failed to get USB PHY for %s\n", dev->name);
                        return ret;
                }
        } else {
                ret = generic_phy_init(&plat->usb_phy);
                if (ret) {
-                       error("Can't init USB PHY for %s\n", dev->name);
+                       pr_err("Can't init USB PHY for %s\n", dev->name);
                        return ret;
                }
        }
@@ -161,7 +161,7 @@ static int xhci_dwc3_remove(struct udevice *dev)
        if (generic_phy_valid(&plat->usb_phy)) {
                ret = generic_phy_exit(&plat->usb_phy);
                if (ret) {
-                       error("Can't deinit USB PHY for %s\n", dev->name);
+                       pr_err("Can't deinit USB PHY for %s\n", dev->name);
                        return ret;
                }
        }
index ca3abffba072834aa816ab79dcc226116790d408..b1f98842739735e08e086dae2d0f70752a0e7ba1 100644 (file)
@@ -46,7 +46,7 @@ static int xhci_usb_ofdata_to_platdata(struct udevice *dev)
         */
        plat->hcd_base = dev_read_addr(dev);
        if (plat->hcd_base == FDT_ADDR_T_NONE) {
-               error("Can't get the XHCI register base address\n");
+               pr_err("Can't get the XHCI register base address\n");
                return -ENXIO;
        }
 
@@ -60,7 +60,7 @@ static int xhci_usb_ofdata_to_platdata(struct udevice *dev)
        }
 
        if (plat->phy_base == FDT_ADDR_T_NONE) {
-               error("Can't get the usbphy register address\n");
+               pr_err("Can't get the usbphy register address\n");
                return -ENXIO;
        }
 
@@ -117,7 +117,7 @@ static int rockchip_xhci_core_init(struct rockchip_xhci *rkxhci,
 
        ret = dwc3_core_init(rkxhci->dwc3_reg);
        if (ret) {
-               error("failed to initialize core\n");
+               pr_err("failed to initialize core\n");
                return ret;
        }
 
@@ -149,14 +149,14 @@ static int xhci_usb_probe(struct udevice *dev)
        if (plat->vbus_supply) {
                ret = regulator_set_enable(plat->vbus_supply, true);
                if (ret) {
-                       error("XHCI: failed to set VBus supply\n");
+                       pr_err("XHCI: failed to set VBus supply\n");
                        return ret;
                }
        }
 
        ret = rockchip_xhci_core_init(ctx, dev);
        if (ret) {
-               error("XHCI: failed to initialize controller\n");
+               pr_err("XHCI: failed to initialize controller\n");
                return ret;
        }
 
@@ -179,7 +179,7 @@ static int xhci_usb_remove(struct udevice *dev)
        if (plat->vbus_supply) {
                ret = regulator_set_enable(plat->vbus_supply, false);
                if (ret)
-                       error("XHCI: failed to set VBus supply\n");
+                       pr_err("XHCI: failed to set VBus supply\n");
        }
 
        return ret;
index de101319cdaad82a9a570b4a1bfd25023934c58f..233857ad7a13ae4ee73ac08c7f965afe987eb922 100644 (file)
@@ -106,7 +106,7 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
                                                          "mentor,multipoint",
                                                          -1);
        if (platdata->musb_config.multipoint < 0) {
-               error("MUSB multipoint DT entry missing\n");
+               pr_err("MUSB multipoint DT entry missing\n");
                return -ENOENT;
        }
 
@@ -115,14 +115,14 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
        platdata->musb_config.num_eps = fdtdec_get_int(fdt, node,
                                                       "mentor,num-eps", -1);
        if (platdata->musb_config.num_eps < 0) {
-               error("MUSB num-eps DT entry missing\n");
+               pr_err("MUSB num-eps DT entry missing\n");
                return -ENOENT;
        }
 
        platdata->musb_config.ram_bits = fdtdec_get_int(fdt, node,
                                                        "mentor,ram-bits", -1);
        if (platdata->musb_config.ram_bits < 0) {
-               error("MUSB ram-bits DT entry missing\n");
+               pr_err("MUSB ram-bits DT entry missing\n");
                return -ENOENT;
        }
 
@@ -132,7 +132,7 @@ static int ti_musb_ofdata_to_platdata(struct udevice *dev)
 
        platdata->plat.power = fdtdec_get_int(fdt, node, "mentor,power", -1);
        if (platdata->plat.power < 0) {
-               error("MUSB mentor,power DT entry missing\n");
+               pr_err("MUSB mentor,power DT entry missing\n");
                return -ENOENT;
        }
 
@@ -183,7 +183,7 @@ static int ti_musb_host_ofdata_to_platdata(struct udevice *dev)
 
        ret = ti_musb_ofdata_to_platdata(dev);
        if (ret) {
-               error("platdata dt parse error\n");
+               pr_err("platdata dt parse error\n");
                return ret;
        }
 
@@ -229,7 +229,7 @@ static int ti_musb_wrapper_bind(struct udevice *parent)
                        ret = device_bind_driver_to_node(parent, "ti-musb-host",
                                        name, offset_to_ofnode(node), &dev);
                        if (ret) {
-                               error("musb - not able to bind usb host node\n");
+                               pr_err("musb - not able to bind usb host node\n");
                                return ret;
                        }
                        break;
index bb5cc9788abfa61dbe532d292eccbc64a7a44002..a8b3e747a032d8896722f0cbdfbc85b9ee65a4d3 100644 (file)
@@ -128,7 +128,7 @@ int am335xfb_init(struct am335x_lcdpanel *panel)
                raster_ctrl |= LCD_TFT_24BPP_MODE;
                break;
        default:
-               error("am335x-fb: invalid bpp value: %d\n", panel->bpp);
+               pr_err("am335x-fb: invalid bpp value: %d\n", panel->bpp);
                return -1;
        }
 
index b403bd5f6c120f572df213978ca5cf2b0a9f774a..70715bb6e7564554c233ca3b9e08b928c7bf3925 100644 (file)
@@ -84,7 +84,7 @@ void set_default_env(const char *s)
        if (himport_r(&env_htab, (char *)default_environment,
                        sizeof(default_environment), '\0', flags, 0,
                        0, NULL) == 0)
-               error("Environment import failed: errno = %d\n", errno);
+               pr_err("Environment import failed: errno = %d\n", errno);
 
        gd->flags |= GD_FLG_ENV_READY;
        gd->flags |= GD_FLG_ENV_DEFAULT;
@@ -172,7 +172,7 @@ int env_import(const char *buf, int check)
        /* Decrypt the env if desired. */
        ret = env_aes_cbc_crypt(ep, 0);
        if (ret) {
-               error("Failed to decrypt env!\n");
+               pr_err("Failed to decrypt env!\n");
                set_default_env("!import failed");
                return ret;
        }
@@ -183,7 +183,7 @@ int env_import(const char *buf, int check)
                return 1;
        }
 
-       error("Cannot import environment: errno = %d\n", errno);
+       pr_err("Cannot import environment: errno = %d\n", errno);
 
        set_default_env("!import failed");
 
@@ -247,7 +247,7 @@ int env_export(env_t *env_out)
        res = (char *)env_out->data;
        len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
        if (len < 0) {
-               error("Cannot export environment: errno = %d\n", errno);
+               pr_err("Cannot export environment: errno = %d\n", errno);
                return 1;
        }
 
index 6f74371c098203e2ba9c805227da7a9a492bae7a..e51b1ae189164f9a0247ca5f2b12b6d7c1776600 100644 (file)
--- a/env/sf.c
+++ b/env/sf.c
@@ -236,7 +236,7 @@ static int env_sf_load(void)
 
        ret = env_import((char *)ep, 0);
        if (!ret) {
-               error("Cannot import environment: errno = %d\n", errno);
+               pr_err("Cannot import environment: errno = %d\n", errno);
                set_default_env("!env_import failed");
        }
 
index 1d63fc94340ee8879e9c12814f33fbcca9b9a2f7..b16005e6045ffda2cdb6176bd856066be10b1556 100644 (file)
@@ -798,7 +798,7 @@ jffs2_1pass_build_lists(struct part_info * part)
        struct mtdids *id = part->dev->id;
        mtd = get_nand_dev_by_index(id->num);
        if (!mtd) {
-               error("\nno NAND devices available\n");
+               pr_err("\nno NAND devices available\n");
                return 0;
        }
 
index bd66d31697f5c3a4baf0441e3ca6c7585a651101..2a70e4a543e0b9e8608c6e6fd803988ac3af3a3e 100644 (file)
@@ -168,7 +168,7 @@ void cmd_yaffs_devconfig(char *_mp, int flash_dev,
 
        mtd = get_nand_dev_by_index(flash_dev);
        if (!mtd) {
-               error("\nno NAND devices available\n");
+               pr_err("\nno NAND devices available\n");
                return;
        }