brain-hackers_pepepper-mirror/u-boot-brain
1
0
Fork 0
mirror of https://github.com/brain-hackers/u-boot-brain synced 2024-07-05 10:46:15 +09:00
Code Issues Projects Releases Wiki Activity

Merge branch '2020-09-29-dev_xxx-print-improvement' into next

Browse Source 
- Improve our dev_xxx(..) wrappers to be generally used and available
  rather than discarded at link/compile time.
This commit is contained in:
Tom Rini 2020-09-30 09:07:06 -04:00
commit 527fad0b24
48 changed files with 486 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/core/syscon-uclass.c
View File

@ -70,7 +70,7 @@ static int syscon_probe_by_ofnode(ofnode node, struct udevice **devp)
/* found node with "syscon" compatible, not bounded to SYSCON UCLASS */
if (!ofnode_device_is_compatible(node, "syscon")) {
dev_dbg(dev, "invalid compatible for syscon device\n");
log_debug("invalid compatible for syscon device\n");
return -EINVAL;
}

23
drivers/firmware/ti_sci.c
View File

@ -619,7 +619,7 @@ static int ti_sci_get_device_state(const struct ti_sci_handle *handle,
ret = ti_sci_do_xfer(info, xfer);
if (ret) {
dev_err(dev, "Mbox send fail %d\n", ret);
dev_err(info->dev, "Mbox send fail %d\n", ret);
return ret;
}
@ -1591,7 +1591,7 @@ static int ti_sci_cmd_core_reboot(const struct ti_sci_handle *handle)
ret = ti_sci_do_xfer(info, xfer);
if (ret) {
dev_err(dev, "Mbox send fail %d\n", ret);
dev_err(info->dev, "Mbox send fail %d\n", ret);
return ret;
}
@ -1639,7 +1639,7 @@ static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,
(u32 *)&req, sizeof(req), sizeof(*resp));
if (IS_ERR(xfer)) {
ret = PTR_ERR(xfer);
dev_err(dev, "Message alloc failed(%d)\n", ret);
dev_err(info->dev, "Message alloc failed(%d)\n", ret);
return ret;
}
@ -1649,7 +1649,7 @@ static int ti_sci_get_resource_range(const struct ti_sci_handle *handle,
ret = ti_sci_do_xfer(info, xfer);
if (ret) {
dev_err(dev, "Mbox send fail %d\n", ret);
dev_err(info->dev, "Mbox send fail %d\n", ret);
goto fail;
}
@ -1745,7 +1745,7 @@ static int ti_sci_cmd_query_msmc(const struct ti_sci_handle *handle,
ret = ti_sci_do_xfer(info, xfer);
if (ret) {
dev_err(dev, "Mbox send fail %d\n", ret);
dev_err(info->dev, "Mbox send fail %d\n", ret);
return ret;
}
@ -2229,6 +2229,14 @@ static int ti_sci_cmd_proc_shutdown_no_wait(const struct ti_sci_handle *handle,
u8 proc_id)
{
int ret;
struct ti_sci_info *info;
if (IS_ERR(handle))
return PTR_ERR(handle);
if (!handle)
return -EINVAL;
info = handle_to_ti_sci_info(handle);
/*
* Send the core boot status wait message waiting for either WFE or
@ -2554,7 +2562,8 @@ static int ti_sci_cmd_rm_udmap_rx_flow_cfg(
(u32 *)&req, sizeof(req), sizeof(*resp));
if (IS_ERR(xfer)) {
ret = PTR_ERR(xfer);
dev_err(dev, "RX_FL_CFG: Message alloc failed(%d)\n", ret);
dev_err(info->dev, "RX_FL_CFG: Message alloc failed(%d)\n",
ret);
return ret;
}
@ -2583,7 +2592,7 @@ static int ti_sci_cmd_rm_udmap_rx_flow_cfg(
ret = ti_sci_do_xfer(info, xfer);
if (ret) {
dev_err(dev, "RX_FL_CFG: Mbox send fail %d\n", ret);
dev_err(info->dev, "RX_FL_CFG: Mbox send fail %d\n", ret);
goto fail;
}

7
drivers/i2c/mxc_i2c.c
View File

@ -941,7 +941,8 @@ static int mxc_i2c_probe(struct udevice *bus)
*/
ret = fdt_stringlist_search(fdt, node, "pinctrl-names", "gpio");
if (ret < 0) {
debug("i2c bus %d at 0x%2lx, no gpio pinctrl state.\n", bus->seq, i2c_bus->base);
debug("i2c bus %d at 0x%2lx, no gpio pinctrl state.\n",
bus->seq, i2c_bus->base);
} else {
ret = gpio_request_by_name_nodev(offset_to_ofnode(node),
"scl-gpios", 0, &i2c_bus->scl_gpio,
@ -952,7 +953,9 @@ static int mxc_i2c_probe(struct udevice *bus)
if (!dm_gpio_is_valid(&i2c_bus->sda_gpio) ||
!dm_gpio_is_valid(&i2c_bus->scl_gpio) ||
ret || ret2) {
dev_err(dev, "i2c bus %d at %lu, fail to request scl/sda gpio\n", bus->seq, i2c_bus->base);
dev_err(bus,
"i2c bus %d at %lu, fail to request scl/sda gpio\n",
bus->seq, i2c_bus->base);
return -EINVAL;
}
}

6
drivers/mailbox/k3-sec-proxy.c
View File

@ -212,14 +212,16 @@ static int k3_sec_proxy_send(struct mbox_chan *chan, const void *data)
ret = k3_sec_proxy_verify_thread(spt, THREAD_IS_TX);
if (ret) {
dev_err(dev, "%s: Thread%d verification failed. ret = %d\n",
dev_err(chan->dev,
"%s: Thread%d verification failed. ret = %d\n",
__func__, spt->id, ret);
return ret;
}
/* Check the message size. */
if (msg->len > spm->desc->max_msg_size) {
printf("%s: Thread %ld message length %zu > max msg size %d\n",
dev_err(chan->dev,
"%s: Thread %ld message length %zu > max msg size %d\n",
__func__, chan->id, msg->len, spm->desc->max_msg_size);
return -EINVAL;
}

34
drivers/mmc/bcm2835_sdhost.c
View File

@ -185,22 +185,22 @@ struct bcm2835_host {
static void bcm2835_dumpregs(struct bcm2835_host *host)
{
dev_dbg(dev, "=========== REGISTER DUMP ===========\n");
dev_dbg(dev, "SDCMD 0x%08x\n", readl(host->ioaddr + SDCMD));
dev_dbg(dev, "SDARG 0x%08x\n", readl(host->ioaddr + SDARG));
dev_dbg(dev, "SDTOUT 0x%08x\n", readl(host->ioaddr + SDTOUT));
dev_dbg(dev, "SDCDIV 0x%08x\n", readl(host->ioaddr + SDCDIV));
dev_dbg(dev, "SDRSP0 0x%08x\n", readl(host->ioaddr + SDRSP0));
dev_dbg(dev, "SDRSP1 0x%08x\n", readl(host->ioaddr + SDRSP1));
dev_dbg(dev, "SDRSP2 0x%08x\n", readl(host->ioaddr + SDRSP2));
dev_dbg(dev, "SDRSP3 0x%08x\n", readl(host->ioaddr + SDRSP3));
dev_dbg(dev, "SDHSTS 0x%08x\n", readl(host->ioaddr + SDHSTS));
dev_dbg(dev, "SDVDD 0x%08x\n", readl(host->ioaddr + SDVDD));
dev_dbg(dev, "SDEDM 0x%08x\n", readl(host->ioaddr + SDEDM));
dev_dbg(dev, "SDHCFG 0x%08x\n", readl(host->ioaddr + SDHCFG));
dev_dbg(dev, "SDHBCT 0x%08x\n", readl(host->ioaddr + SDHBCT));
dev_dbg(dev, "SDHBLC 0x%08x\n", readl(host->ioaddr + SDHBLC));
dev_dbg(dev, "===========================================\n");
dev_dbg(host->dev, "=========== REGISTER DUMP ===========\n");
dev_dbg(host->dev, "SDCMD 0x%08x\n", readl(host->ioaddr + SDCMD));
dev_dbg(host->dev, "SDARG 0x%08x\n", readl(host->ioaddr + SDARG));
dev_dbg(host->dev, "SDTOUT 0x%08x\n", readl(host->ioaddr + SDTOUT));
dev_dbg(host->dev, "SDCDIV 0x%08x\n", readl(host->ioaddr + SDCDIV));
dev_dbg(host->dev, "SDRSP0 0x%08x\n", readl(host->ioaddr + SDRSP0));
dev_dbg(host->dev, "SDRSP1 0x%08x\n", readl(host->ioaddr + SDRSP1));
dev_dbg(host->dev, "SDRSP2 0x%08x\n", readl(host->ioaddr + SDRSP2));
dev_dbg(host->dev, "SDRSP3 0x%08x\n", readl(host->ioaddr + SDRSP3));
dev_dbg(host->dev, "SDHSTS 0x%08x\n", readl(host->ioaddr + SDHSTS));
dev_dbg(host->dev, "SDVDD 0x%08x\n", readl(host->ioaddr + SDVDD));
dev_dbg(host->dev, "SDEDM 0x%08x\n", readl(host->ioaddr + SDEDM));
dev_dbg(host->dev, "SDHCFG 0x%08x\n", readl(host->ioaddr + SDHCFG));
dev_dbg(host->dev, "SDHBCT 0x%08x\n", readl(host->ioaddr + SDHBCT));
dev_dbg(host->dev, "SDHBLC 0x%08x\n", readl(host->ioaddr + SDHBLC));
dev_dbg(host->dev, "===========================================\n");
}
static void bcm2835_reset_internal(struct bcm2835_host *host)
@ -738,7 +738,7 @@ static void bcm2835_add_host(struct bcm2835_host *host)
cfg->f_min = host->max_clk / SDCDIV_MAX_CDIV;
cfg->b_max = 65535;
dev_dbg(dev, "f_max %d, f_min %d\n",
dev_dbg(host->dev, "f_max %d, f_min %d\n",
cfg->f_max, cfg->f_min);
/* host controller capabilities */

24
drivers/mmc/mtk-sd.c
View File

@ -774,7 +774,8 @@ static void msdc_set_buswidth(struct msdc_host *host, u32 width)
writel(val, &host->base->sdc_cfg);
}
static void msdc_set_mclk(struct msdc_host *host, enum bus_mode timing, u32 hz)
static void msdc_set_mclk(struct udevice *dev,
struct msdc_host *host, enum bus_mode timing, u32 hz)
{
u32 mode;
u32 div;
@ -897,7 +898,7 @@ static int msdc_ops_set_ios(struct udevice *dev)
clock = mmc->cfg->f_min;
if (host->mclk != clock || host->timing != mmc->selected_mode)
msdc_set_mclk(host, mmc->selected_mode, clock);
msdc_set_mclk(dev, host, mmc->selected_mode, clock);
return 0;
}
@ -957,7 +958,8 @@ static int get_delay_len(u32 delay, u32 start_bit)
return PAD_DELAY_MAX - start_bit;
}
static struct msdc_delay_phase get_best_delay(struct msdc_host *host, u32 delay)
static struct msdc_delay_phase get_best_delay(struct udevice *dev,
struct msdc_host *host, u32 delay)
{
int start = 0, len = 0;
int start_final = 0, len_final = 0;
@ -1067,7 +1069,7 @@ static int hs400_tune_response(struct udevice *dev, u32 opcode)
}
}
final_cmd_delay = get_best_delay(host, cmd_delay);
final_cmd_delay = get_best_delay(dev, host, cmd_delay);
clrsetbits_le32(tune_reg, PAD_CMD_TUNE_RX_DLY3,
final_cmd_delay.final_phase <<
PAD_CMD_TUNE_RX_DLY3_S);
@ -1117,7 +1119,7 @@ static int msdc_tune_response(struct udevice *dev, u32 opcode)
}
}
final_rise_delay = get_best_delay(host, rise_delay);
final_rise_delay = get_best_delay(dev, host, rise_delay);
/* if rising edge has enough margin, do not scan falling edge */
if (final_rise_delay.maxlen >= 12 ||
(final_rise_delay.start == 0 && final_rise_delay.maxlen >= 4))
@ -1139,7 +1141,7 @@ static int msdc_tune_response(struct udevice *dev, u32 opcode)
}
}
final_fall_delay = get_best_delay(host, fall_delay);
final_fall_delay = get_best_delay(dev, host, fall_delay);
skip_fall:
final_maxlen = max(final_rise_delay.maxlen, final_fall_delay.maxlen);
@ -1171,7 +1173,7 @@ skip_fall:
dev_err(dev, "Final internal delay: 0x%x\n", internal_delay);
internal_delay_phase = get_best_delay(host, internal_delay);
internal_delay_phase = get_best_delay(dev, host, internal_delay);
clrsetbits_le32(tune_reg, MSDC_PAD_TUNE_CMDRRDLY_M,
internal_delay_phase.final_phase <<
MSDC_PAD_TUNE_CMDRRDLY_S);
@ -1214,7 +1216,7 @@ static int msdc_tune_data(struct udevice *dev, u32 opcode)
}
}
final_rise_delay = get_best_delay(host, rise_delay);
final_rise_delay = get_best_delay(dev, host, rise_delay);
if (final_rise_delay.maxlen >= 12 ||
(final_rise_delay.start == 0 && final_rise_delay.maxlen >= 4))
goto skip_fall;
@ -1237,7 +1239,7 @@ static int msdc_tune_data(struct udevice *dev, u32 opcode)
}
}
final_fall_delay = get_best_delay(host, fall_delay);
final_fall_delay = get_best_delay(dev, host, fall_delay);
skip_fall:
final_maxlen = max(final_rise_delay.maxlen, final_fall_delay.maxlen);
@ -1293,7 +1295,7 @@ static int msdc_tune_together(struct udevice *dev, u32 opcode)
rise_delay |= (1 << i);
}
final_rise_delay = get_best_delay(host, rise_delay);
final_rise_delay = get_best_delay(dev, host, rise_delay);
if (final_rise_delay.maxlen >= 12 ||
(final_rise_delay.start == 0 && final_rise_delay.maxlen >= 4))
goto skip_fall;
@ -1309,7 +1311,7 @@ static int msdc_tune_together(struct udevice *dev, u32 opcode)
fall_delay |= (1 << i);
}
final_fall_delay = get_best_delay(host, fall_delay);
final_fall_delay = get_best_delay(dev, host, fall_delay);
skip_fall:
final_maxlen = max(final_rise_delay.maxlen, final_fall_delay.maxlen);

69
drivers/mtd/nand/raw/atmel_nand.c
View File

@ -424,7 +424,8 @@ static int pmecc_err_location(struct mtd_info *mtd)
}
if (!timeout) {
dev_err(host->dev, "atmel_nand : Timeout to calculate PMECC error location\n");
dev_err(mtd->dev,
"Timeout to calculate PMECC error location\n");
return -1;
}
@ -464,7 +465,8 @@ static void pmecc_correct_data(struct mtd_info *mtd, uint8_t *buf, uint8_t *ecc,
*(buf + byte_pos) ^= (1 << bit_pos);
pos = sector_num * host->pmecc_sector_size + byte_pos;
dev_dbg(host->dev, "Bit flip in data area, byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
dev_dbg(mtd->dev,
"Bit flip in data area, byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
pos, bit_pos, err_byte, *(buf + byte_pos));
} else {
/* Bit flip in OOB area */
@ -474,7 +476,8 @@ static void pmecc_correct_data(struct mtd_info *mtd, uint8_t *buf, uint8_t *ecc,
ecc[tmp] ^= (1 << bit_pos);
pos = tmp + nand_chip->ecc.layout->eccpos[0];
dev_dbg(host->dev, "Bit flip in OOB, oob_byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
dev_dbg(mtd->dev,
"Bit flip in OOB, oob_byte_pos: %d, bit_pos: %d, 0x%02x -> 0x%02x\n",
pos, bit_pos, err_byte, ecc[tmp]);
}
@ -516,7 +519,7 @@ normal_check:
err_nbr = pmecc_err_location(mtd);
if (err_nbr == -1) {
dev_err(host->dev, "PMECC: Too many errors\n");
dev_err(mtd->dev, "PMECC: Too many errors\n");
mtd->ecc_stats.failed++;
return -EBADMSG;
} else {
@ -560,7 +563,7 @@ static int atmel_nand_pmecc_read_page(struct mtd_info *mtd,
}
if (!timeout) {
dev_err(host->dev, "atmel_nand : Timeout to read PMECC page\n");
dev_err(mtd->dev, "Timeout to read PMECC page\n");
return -1;
}
@ -600,7 +603,8 @@ static int atmel_nand_pmecc_write_page(struct mtd_info *mtd,
}
if (!timeout) {
dev_err(host->dev, "atmel_nand : Timeout to read PMECC status, fail to write PMECC in oob\n");
dev_err(mtd->dev,
"Timeout to read PMECC status, fail to write PMECC in oob\n");
goto out;
}
@ -713,7 +717,8 @@ static int pmecc_choose_ecc(struct atmel_nand_host *host,
if (*cap == 0 && *sector_size == 0) {
/* Non-ONFI compliant */
dev_info(host->dev, "NAND chip is not ONFI compliant, assume ecc_bits is 2 in 512 bytes\n");
dev_info(chip->mtd.dev,
"NAND chip is not ONFI compliant, assume ecc_bits is 2 in 512 bytes\n");
*cap = 2;
*sector_size = 512;
}
@ -835,17 +840,20 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
* from ONFI.
*/
if (pmecc_choose_ecc(host, nand, &cap, &sector_size)) {
dev_err(host->dev, "Required ECC %d bits in %d bytes not supported!\n",
dev_err(mtd->dev,
"Required ECC %d bits in %d bytes not supported!\n",
cap, sector_size);
return -EINVAL;
}
if (cap > host->pmecc_corr_cap)
dev_info(host->dev, "WARNING: Using different ecc correct bits(%d bit) from Nand ONFI ECC reqirement (%d bit).\n",
host->pmecc_corr_cap, cap);
dev_info(mtd->dev,
"WARNING: Using different ecc correct bits(%d bit) from Nand ONFI ECC reqirement (%d bit).\n",
host->pmecc_corr_cap, cap);
if (sector_size < host->pmecc_sector_size)
dev_info(host->dev, "WARNING: Using different ecc correct sector size (%d bytes) from Nand ONFI ECC reqirement (%d bytes).\n",
host->pmecc_sector_size, sector_size);
dev_info(mtd->dev,
"WARNING: Using different ecc correct sector size (%d bytes) from Nand ONFI ECC reqirement (%d bytes).\n",
host->pmecc_sector_size, sector_size);
#else /* CONFIG_SYS_NAND_ONFI_DETECTION */
host->pmecc_corr_cap = CONFIG_PMECC_CAP;
host->pmecc_sector_size = CONFIG_PMECC_SECTOR_SIZE;
@ -877,7 +885,7 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
#if defined(NO_GALOIS_TABLE_IN_ROM)
pmecc_galois_table = create_lookup_table(host->pmecc_sector_size);
if (!pmecc_galois_table) {
dev_err(host->dev, "out of memory\n");
dev_err(mtd->dev, "out of memory\n");
return -ENOMEM;
}
@ -909,13 +917,14 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
host->pmecc_sector_number;
if (nand->ecc.bytes > MTD_MAX_ECCPOS_ENTRIES_LARGE) {
dev_err(host->dev, "too large eccpos entries. max support ecc.bytes is %d\n",
MTD_MAX_ECCPOS_ENTRIES_LARGE);
dev_err(mtd->dev,
"too large eccpos entries. max support ecc.bytes is %d\n",
MTD_MAX_ECCPOS_ENTRIES_LARGE);
return -EINVAL;
}
if (nand->ecc.bytes > mtd->oobsize - PMECC_OOB_RESERVED_BYTES) {
dev_err(host->dev, "No room for ECC bytes\n");
dev_err(mtd->dev, "No room for ECC bytes\n");
return -EINVAL;
}
pmecc_config_ecc_layout(&atmel_pmecc_oobinfo,
@ -926,7 +935,8 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
case 512:
case 1024:
/* TODO */
dev_err(host->dev, "Unsupported page size for PMECC, use Software ECC\n");
dev_err(mtd->dev,
"Unsupported page size for PMECC, use Software ECC\n");
default:
/* page size not handled by HW ECC */
/* switching back to soft ECC */
@ -940,7 +950,8 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
/* Allocate data for PMECC computation */
if (pmecc_data_alloc(host)) {
dev_err(host->dev, "Cannot allocate memory for PMECC computation!\n");
dev_err(mtd->dev,
"Cannot allocate memory for PMECC computation!\n");
return -ENOMEM;
}
@ -951,7 +962,7 @@ static int atmel_pmecc_nand_init_params(struct nand_chip *nand,
/* Check the PMECC ip version */
host->pmecc_version = pmecc_readl(host->pmerrloc, version);
dev_dbg(host->dev, "PMECC IP version is: %x\n", host->pmecc_version);
dev_dbg(mtd->dev, "PMECC IP version is: %x\n", host->pmecc_version);
atmel_pmecc_core_init(mtd);
@ -1114,8 +1125,8 @@ static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat,
/* it doesn't seems to be a freshly
* erased block.
* We can't correct so many errors */
dev_warn(host->dev, "atmel_nand : multiple errors detected."
" Unable to correct.\n");
dev_warn(mtd->dev,
"multiple errors detected. Unable to correct.\n");
return -EBADMSG;
}
@ -1124,15 +1135,14 @@ static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat,
/* there's nothing much to do here.
* the bit error is on the ECC itself.
*/
dev_warn(host->dev, "atmel_nand : one bit error on ECC code."
" Nothing to correct\n");
dev_warn(mtd->dev,
"one bit error on ECC code. Nothing to correct\n");
return 0;
}
dev_warn(host->dev, "atmel_nand : one bit error on data."
" (word offset in the page :"
" 0x%x bit offset : 0x%x)\n",
ecc_word, ecc_bit);
dev_warn(mtd->dev,
"one bit error on data. (word offset in the page : 0x%x bit offset : 0x%x)\n",
ecc_word, ecc_bit);
/* correct the error */
if (nand_chip->options & NAND_BUSWIDTH_16) {
/* 16 bits words */
@ -1141,7 +1151,7 @@ static int atmel_nand_correct(struct mtd_info *mtd, u_char *dat,
/* 8 bits words */
dat[ecc_word] ^= (1 << ecc_bit);
}
dev_warn(host->dev, "atmel_nand : error corrected\n");
dev_warn(mtd->dev, "error corrected\n");
return 1;
}
@ -1511,7 +1521,6 @@ void board_nand_init(void)
int i;
for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++)
if (atmel_nand_chip_init(i, base_addr[i]))
dev_err(host->dev, "atmel_nand: Fail to initialize #%d chip",
i);
log_err("atmel_nand: Fail to initialize #%d chip", i);
}
#endif /* CONFIG_SPL_BUILD */

20
drivers/mtd/nand/raw/brcmnand/brcmnand.c
View File

@ -956,7 +956,7 @@ static struct nand_ecclayout *brcmnand_create_layout(int ecc_level,
*/
req = DIV_ROUND_UP(ecc_level * 14, 8);
if (req >= sas) {
dev_err(&host->pdev->dev,
dev_err(host->pdev,
"error: ECC too large for OOB (ECC bytes %d, spare sector %d)\n",
req, sas);
return NULL;
@ -1012,8 +1012,8 @@ static struct nand_ecclayout *brcmstb_choose_ecc_layout(
layout = brcmnand_create_layout(ecc_level, host);
if (!layout) {
dev_err(&host->pdev->dev,
"no proper ecc_layout for this NAND cfg\n");
dev_err(host->pdev,
"no proper ecc_layout for this NAND cfg\n");
return NULL;
}
@ -1056,17 +1056,9 @@ static void brcmnand_wp(struct mtd_info *mtd, int wp)
NAND_CTRL_RDY |
NAND_STATUS_READY |
(wp ? 0 : NAND_STATUS_WP), 0);
#ifndef __UBOOT__
if (ret)
dev_err_ratelimited(&host->pdev->dev,
"nand #WP expected %s\n",
wp ? "on" : "off");
#else
if (ret)
dev_err(&host->pdev->dev,
"nand #WP expected %s\n",
wp ? "on" : "off");
#endif /* __UBOOT__ */
dev_err(host->pdev, "nand #WP expected %s\n",
wp ? "on" : "off");
}
}
@ -2257,7 +2249,7 @@ static int brcmnand_init_cs(struct brcmnand_host *host, ofnode dn)
ret = ofnode_read_s32(dn, "reg", &host->cs);
#endif
if (ret) {
dev_err(&pdev->dev, "can't get chip-select\n");
dev_err(pdev, "can't get chip-select\n");
return -ENXIO;
}

30
drivers/mtd/nand/raw/pxa3xx_nand.c
View File

@ -512,7 +512,7 @@ static int pxa3xx_nand_init_timings(struct pxa3xx_nand_host *host)
}
if (i == ntypes) {
dev_err(&info->pdev->dev, "Error: timings not found\n");
dev_err(mtd->dev, "Error: timings not found\n");
return -EINVAL;
}
@ -603,7 +603,7 @@ static void drain_fifo(struct pxa3xx_nand_info *info, void *data, int len)
ts = get_timer(0);
while (!(nand_readl(info, NDSR) & NDSR_RDDREQ)) {
if (get_timer(ts) > TIMEOUT_DRAIN_FIFO) {
dev_err(&info->pdev->dev,
dev_err(info->controller.active->mtd.dev,
"Timeout on RDDREQ while draining the FIFO\n");
return;
}
@ -656,8 +656,8 @@ static void handle_data_pio(struct pxa3xx_nand_info *info)
DIV_ROUND_UP(info->step_spare_size, 4));
break;
default:
dev_err(&info->pdev->dev, "%s: invalid state %d\n", __func__,
info->state);
dev_err(info->controller.active->mtd.dev,
"%s: invalid state %d\n", __func__, info->state);
BUG();
}
@ -1027,7 +1027,7 @@ static int prepare_set_command(struct pxa3xx_nand_info *info, int command,
default:
exec_cmd = 0;
dev_err(&info->pdev->dev, "non-supported command %x\n",
dev_err(mtd->dev, "non-supported command %x\n",
command);
break;
}
@ -1087,7 +1087,7 @@ static void nand_cmdfunc(struct mtd_info *mtd, unsigned command,
break;
if (get_timer(ts) > CHIP_DELAY_TIMEOUT) {
dev_err(&info->pdev->dev, "Wait timeout!!!\n");
dev_err(mtd->dev, "Wait timeout!!!\n");
return;
}
}
@ -1180,7 +1180,7 @@ static void nand_cmdfunc_extended(struct mtd_info *mtd,
break;
if (get_timer(ts) > CHIP_DELAY_TIMEOUT) {
dev_err(&info->pdev->dev, "Wait timeout!!!\n");
dev_err(mtd->dev, "Wait timeout!!!\n");
return;
}
}
@ -1426,7 +1426,7 @@ static int pxa3xx_nand_waitfunc(struct mtd_info *mtd, struct nand_chip *this)
break;
if (get_timer(ts) > CHIP_DELAY_TIMEOUT) {
dev_err(&info->pdev->dev, "Ready timeout!!!\n");
dev_err(mtd->dev, "Ready timeout!!!\n");
return NAND_STATUS_FAIL;
}
}
@ -1633,7 +1633,7 @@ static int pxa_ecc_init(struct pxa3xx_nand_info *info,
ecc->strength = 16;
} else {
dev_err(&info->pdev->dev,
dev_err(info->controller.active->mtd.dev,
"ECC strength %d at page size %d is not supported\n",
strength, page_size);
return -ENODEV;
@ -1659,8 +1659,7 @@ static int pxa3xx_nand_scan(struct mtd_info *mtd)
return ret;
ret = pxa3xx_nand_sensing(host);
if (ret) {
dev_info(&info->pdev->dev,
"There is no chip on cs %d!\n",
dev_info(mtd->dev, "There is no chip on cs %d!\n",
info->cs);
return ret;
}
@ -1676,7 +1675,7 @@ static int pxa3xx_nand_scan(struct mtd_info *mtd)
if (!pdata->keep_config) {
ret = pxa3xx_nand_init_timings(host);
if (ret) {
dev_err(&info->pdev->dev,
dev_err(mtd->dev,
"Failed to set timings: %d\n", ret);
return ret;
}
@ -1720,7 +1719,7 @@ static int pxa3xx_nand_scan(struct mtd_info *mtd)
if (info->variant == PXA3XX_NAND_VARIANT_ARMADA370) {
chip->cmdfunc = nand_cmdfunc_extended;
} else {
dev_err(&info->pdev->dev,
dev_err(mtd->dev,
"unsupported page size on this variant\n");
return -ENODEV;
}
@ -1873,6 +1872,7 @@ static int pxa3xx_nand_probe_dt(struct pxa3xx_nand_info *info)
static int pxa3xx_nand_probe(struct pxa3xx_nand_info *info)
{
struct mtd_info *mtd = &info->controller.active->mtd;
struct pxa3xx_nand_platform_data *pdata;
int ret, cs, probe_success;
@ -1884,7 +1884,7 @@ static int pxa3xx_nand_probe(struct pxa3xx_nand_info *info)
ret = alloc_nand_resource(info);
if (ret) {
dev_err(&pdev->dev, "alloc nand resource failed\n");
dev_err(mtd->dev, "alloc nand resource failed\n");
return ret;
}
@ -1901,7 +1901,7 @@ static int pxa3xx_nand_probe(struct pxa3xx_nand_info *info)
info->cs = cs;
ret = pxa3xx_nand_scan(mtd);
if (ret) {
dev_info(&pdev->dev, "failed to scan nand at cs %d\n",
dev_info(mtd->dev, "failed to scan nand at cs %d\n",
cs);
continue;
}

45
drivers/mtd/nand/raw/sunxi_nand.c
View File

@ -1226,7 +1226,8 @@ static int _sunxi_nand_lookup_timing(const s32 *lut, int lut_size, u32 duration,
#define sunxi_nand_lookup_timing(l, p, c) \
_sunxi_nand_lookup_timing(l, ARRAY_SIZE(l), p, c)
static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip *chip,
static int sunxi_nand_chip_set_timings(struct sunxi_nfc *nfc,
struct sunxi_nand_chip *chip,
const struct nand_sdr_timings *timings)
{
u32 min_clk_period = 0;
@ -1349,7 +1350,8 @@ static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip *chip,
return 0;
}
static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip *chip)
static int sunxi_nand_chip_init_timings(struct sunxi_nfc *nfc,
struct sunxi_nand_chip *chip)
{
struct mtd_info *mtd = nand_to_mtd(&chip->nand);
const struct nand_sdr_timings *timings;
@ -1384,7 +1386,7 @@ static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip *chip)
if (IS_ERR(timings))
return PTR_ERR(timings);
return sunxi_nand_chip_set_timings(chip, timings);
return sunxi_nand_chip_set_timings(nfc, chip, timings);
}
static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd,
@ -1423,7 +1425,7 @@ static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd,
}
if (i >= ARRAY_SIZE(strengths)) {
dev_err(nfc->dev, "unsupported strength\n");
dev_err(mtd->dev, "unsupported strength\n");
ret = -ENOTSUPP;
goto err;
}
@ -1619,7 +1621,7 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
nsels /= sizeof(u32);
if (!nsels || nsels > 8) {
dev_err(dev, "invalid reg property size\n");
dev_err(nfc->dev, "invalid reg property size\n");
return -EINVAL;
}
@ -1627,7 +1629,7 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
(nsels * sizeof(struct sunxi_nand_chip_sel)),
GFP_KERNEL);
if (!chip) {
dev_err(dev, "could not allocate chip\n");
dev_err(nfc->dev, "could not allocate chip\n");
return -ENOMEM;
}
@ -1641,14 +1643,14 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
ret = fdtdec_get_int_array(gd->fdt_blob, node, "reg", cs, nsels);
if (ret) {
dev_err(dev, "could not retrieve reg property: %d\n", ret);
dev_err(nfc->dev, "could not retrieve reg property: %d\n", ret);
return ret;
}
ret = fdtdec_get_int_array(gd->fdt_blob, node, "allwinner,rb", rb,
nsels);
if (ret) {
dev_err(dev, "could not retrieve reg property: %d\n", ret);
dev_err(nfc->dev, "could not retrieve reg property: %d\n", ret);
return ret;
}
@ -1656,14 +1658,13 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
int tmp = cs[i];
if (tmp > NFC_MAX_CS) {
dev_err(dev,
"invalid reg value: %u (max CS = 7)\n",
tmp);
dev_err(nfc->dev,
"invalid reg value: %u (max CS = 7)\n", tmp);
return -EINVAL;
}
if (test_and_set_bit(tmp, &nfc->assigned_cs)) {
dev_err(dev, "CS %d already assigned\n", tmp);
dev_err(nfc->dev, "CS %d already assigned\n", tmp);
return -EINVAL;
}
@ -1688,15 +1689,15 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
timings = onfi_async_timing_mode_to_sdr_timings(0);
if (IS_ERR(timings)) {
ret = PTR_ERR(timings);
dev_err(dev,
dev_err(nfc->dev,
"could not retrieve timings for ONFI mode 0: %d\n",
ret);
return ret;
}
ret = sunxi_nand_chip_set_timings(chip, timings);
ret = sunxi_nand_chip_set_timings(nfc, chip, timings);
if (ret) {
dev_err(dev, "could not configure chip timings: %d\n", ret);
dev_err(nfc->dev, "could not configure chip timings: %d\n", ret);
return ret;
}
@ -1729,27 +1730,27 @@ static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
nand->options |= NAND_SUBPAGE_READ;
ret = sunxi_nand_chip_init_timings(chip);
ret = sunxi_nand_chip_init_timings(nfc, chip);
if (ret) {
dev_err(dev, "could not configure chip timings: %d\n", ret);
dev_err(nfc->dev, "could not configure chip timings: %d\n", ret);
return ret;
}
ret = sunxi_nand_ecc_init(mtd, &nand->ecc);
if (ret) {
dev_err(dev, "ECC init failed: %d\n", ret);
dev_err(nfc->dev, "ECC init failed: %d\n", ret);
return ret;
}
ret = nand_scan_tail(mtd);
if (ret) {
dev_err(dev, "nand_scan_tail failed: %d\n", ret);
dev_err(nfc->dev, "nand_scan_tail failed: %d\n", ret);
return ret;
}
ret = nand_register(devnum, mtd);
if (ret) {
dev_err(dev, "failed to register mtd device: %d\n", ret);
dev_err(nfc->dev, "failed to register mtd device: %d\n", ret);
return ret;
}
@ -1769,7 +1770,7 @@ static int sunxi_nand_chips_init(int node, struct sunxi_nfc *nfc)
i++;
if (i > 8) {
dev_err(dev, "too many NAND chips: %d (max = 8)\n", i);
dev_err(nfc->dev, "too many NAND chips: %d (max = 8)\n", i);
return -EINVAL;
}
@ -1841,7 +1842,7 @@ void sunxi_nand_init(void)
ret = sunxi_nand_chips_init(node, nfc);
if (ret) {
dev_err(dev, "failed to init nand chips\n");
dev_err(nfc->dev, "failed to init nand chips\n");
goto err;
}

38
drivers/mtd/nand/raw/vf610_nfc.c
View File

@ -152,6 +152,8 @@ enum vf610_nfc_alt_buf {
struct vf610_nfc {
struct nand_chip chip;
/* NULL without CONFIG_NAND_VF610_NFC_DT */
struct udevice *dev;
void __iomem *regs;
uint buf_offset;
int write_sz;
@ -631,11 +633,10 @@ struct vf610_nfc_config {
int flash_bbt;
};
static int vf610_nfc_nand_init(int devnum, void __iomem *addr)
static int vf610_nfc_nand_init(struct vf610_nfc *nfc, int devnum)
{
struct mtd_info *mtd;
struct nand_chip *chip;
struct vf610_nfc *nfc;
struct nand_chip *chip = &nfc->chip;
struct mtd_info *mtd = nand_to_mtd(chip);
int err = 0;
struct vf610_nfc_config cfg = {
.hardware_ecc = 1,
@ -647,16 +648,6 @@ static int vf610_nfc_nand_init(int devnum, void __iomem *addr)
.flash_bbt = 1,
};
nfc = calloc(1, sizeof(*nfc));
if (!nfc) {
printf(KERN_ERR "%s: Memory exhausted!\n", __func__);
return -ENOMEM;
}
chip = &nfc->chip;
nfc->regs = addr;
mtd = nand_to_mtd(chip);
nand_set_controller_data(chip, nfc);
if (cfg.width == 16)
@ -777,20 +768,23 @@ static const struct udevice_id vf610_nfc_dt_ids[] = {
static int vf610_nfc_dt_probe(struct udevice *dev)
{
struct resource res;
struct vf610_nfc *nfc = dev_get_priv(dev);
int ret;
ret = dev_read_resource(dev, 0, &res);
if (ret)
return ret;
return vf610_nfc_nand_init(0, devm_ioremap(dev, res.start,
resource_size(&res)));
nfc->regs = devm_ioremap(dev, res.start, resource_size(&res));
nfc->dev = dev;
return vf610_nfc_nand_init(nfc, 0);
}
U_BOOT_DRIVER(vf610_nfc_dt) = {
.name = "vf610-nfc-dt",
.id = UCLASS_MTD,
.of_match = vf610_nfc_dt_ids,
.priv_auto_alloc_size = sizeof(struct vf610_nfc),
.probe = vf610_nfc_dt_probe,
};
@ -809,7 +803,17 @@ void board_nand_init(void)
#else
void board_nand_init(void)
{
int err = vf610_nfc_nand_init(0, (void __iomem *)CONFIG_SYS_NAND_BASE);
int err;
struct vf610_nfc *nfc;
nfc = calloc(1, sizeof(*nfc));
if (!nfc) {
printf("%s: Out of memory\n", __func__);
return;
}
nfc->regs = (void __iomem *)CONFIG_SYS_NAND_BASE;
err = vf610_nfc_nand_init(nfc, 0);
if (err)
printf("VF610 NAND init failed (err %d)\n", err);
}

8
drivers/mtd/nand/spi/core.c
View File

@ -984,13 +984,13 @@ static int spinand_detect(struct spinand_device *spinand)
ret = spinand_manufacturer_detect(spinand);
if (ret) {
dev_err(dev, "unknown raw ID %*phN\n", SPINAND_MAX_ID_LEN,
spinand->id.data);
dev_err(spinand->slave->dev, "unknown raw ID %*phN\n",
SPINAND_MAX_ID_LEN, spinand->id.data);
return ret;
}
if (nand->memorg.ntargets > 1 && !spinand->select_target) {
dev_err(dev,
dev_err(spinand->slave->dev,
"SPI NANDs with more than one die must implement ->select_target()\n");
return -EINVAL;
}
@ -1076,7 +1076,7 @@ static int spinand_init(struct spinand_device *spinand)
ret = spinand_manufacturer_init(spinand);
if (ret) {
dev_err(dev,
dev_err(spinand->slave->dev,
"Failed to initialize the SPI NAND chip (err = %d)\n",
ret);
goto err_free_bufs;

1
drivers/mtd/spi/spi-nor-core.c
View File

@ -11,6 +11,7 @@
#include <common.h>
#include <log.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/bitops.h>

21
drivers/mtd/spi/spi-nor-tiny.c
View File

@ -55,9 +55,19 @@ static int spi_nor_read_reg(struct spi_nor *nor, u8 code, u8 *val, int len)
int ret;
ret = spi_nor_read_write_reg(nor, &op, val);
if (ret < 0)
dev_dbg(&flash->spimem->spi->dev, "error %d reading %x\n", ret,
if (ret < 0) {
/*
* spi_slave does not have a struct udevice member without DM,
* so use the bus and cs instead.
*/
#if CONFIG_IS_ENABLED(DM_SPI)
dev_dbg(nor->spi->dev, "error %d reading %x\n", ret,
code);
#else
log_debug("spi%u.%u: error %d reading %x\n",
nor->spi->bus, nor->spi->cs, ret, code);
#endif
}
return ret;
}
@ -512,7 +522,8 @@ static int spansion_read_cr_quad_enable(struct spi_nor *nor)
/* Check current Quad Enable bit value. */
ret = read_cr(nor);
if (ret < 0) {
dev_dbg(dev, "error while reading configuration register\n");
dev_dbg(nor->dev,
"error while reading configuration register\n");
return -EINVAL;
}
@ -524,7 +535,7 @@ static int spansion_read_cr_quad_enable(struct spi_nor *nor)
/* Keep the current value of the Status Register. */
ret = read_sr(nor);
if (ret < 0) {
dev_dbg(dev, "error while reading status register\n");
dev_dbg(nor->dev, "error while reading status register\n");
return -EINVAL;
}
sr_cr[0] = ret;
@ -785,7 +796,7 @@ int spi_nor_scan(struct spi_nor *nor)
}
if (nor->addr_width > SPI_NOR_MAX_ADDR_WIDTH) {
dev_dbg(dev, "address width is too large: %u\n",
dev_dbg(nor->dev, "address width is too large: %u\n",
nor->addr_width);
return -EINVAL;
}

3
drivers/net/bcm6368-eth.c
View File

@ -249,8 +249,7 @@ static int bcm6368_eth_adjust_link(struct udevice *dev)
/* link changed */
if (!up) {
dev_info(&priv->pdev->dev, "link DOWN on %s\n",
port->name);
dev_info(dev, "link DOWN on %s\n", port->name);
writeb_be(ETH_PORTOV_ENABLE_MASK,
priv->base + ETH_PORTOV_REG(i));
writeb_be(ETH_PTCTRL_RXDIS_MASK |

56
drivers/net/mvneta.c
View File

@ -625,9 +625,9 @@ static void mvneta_port_down(struct mvneta_port *pp)
count = 0;
do {
if (count++ >= MVNETA_RX_DISABLE_TIMEOUT_MSEC) {
netdev_warn(pp->dev,
"TIMEOUT for RX stopped ! rx_queue_cmd: 0x08%x\n",
val);
dev_warn(pp->phydev->dev,
"TIMEOUT for RX stopped ! rx_queue_cmd: 0x08%x\n",
val);
break;
}
mdelay(1);
@ -648,9 +648,9 @@ static void mvneta_port_down(struct mvneta_port *pp)
count = 0;
do {
if (count++ >= MVNETA_TX_DISABLE_TIMEOUT_MSEC) {
netdev_warn(pp->dev,
"TIMEOUT for TX stopped status=0x%08x\n",
val);
dev_warn(pp->phydev->dev,
"TIMEOUT for TX stopped status=0x%08x\n",
val);
break;
}
mdelay(1);
@ -664,9 +664,9 @@ static void mvneta_port_down(struct mvneta_port *pp)
count = 0;
do {
if (count++ >= MVNETA_TX_FIFO_EMPTY_TIMEOUT) {
netdev_warn(pp->dev,
"TX FIFO empty timeout status=0x08%x\n",
val);
dev_warn(pp->phydev->dev,
"TX FIFO empty timeout status=0x08%x\n",
val);
break;
}
mdelay(1);
@ -949,28 +949,32 @@ static void mvneta_rx_error(struct mvneta_port *pp,
u32 status = rx_desc->status;
if (!mvneta_rxq_desc_is_first_last(status)) {
netdev_err(pp->dev,
"bad rx status %08x (buffer oversize), size=%d\n",
status, rx_desc->data_size);
dev_err(pp->phydev->dev,
"bad rx status %08x (buffer oversize), size=%d\n",
status, rx_desc->data_size);
return;
}
switch (status & MVNETA_RXD_ERR_CODE_MASK) {
case MVNETA_RXD_ERR_CRC:
netdev_err(pp->dev, "bad rx status %08x (crc error), size=%d\n",
status, rx_desc->data_size);
dev_err(pp->phydev->dev,
"bad rx status %08x (crc error), size=%d\n", status,
rx_desc->data_size);
break;
case MVNETA_RXD_ERR_OVERRUN:
netdev_err(pp->dev, "bad rx status %08x (overrun error), size=%d\n",
status, rx_desc->data_size);
dev_err(pp->phydev->dev,
"bad rx status %08x (overrun error), size=%d\n", status,
rx_desc->data_size);
break;
case MVNETA_RXD_ERR_LEN:
netdev_err(pp->dev, "bad rx status %08x (max frame length error), size=%d\n",
status, rx_desc->data_size);
dev_err(pp->phydev->dev,
"bad rx status %08x (max frame length error), size=%d\n",
status, rx_desc->data_size);
break;
case MVNETA_RXD_ERR_RESOURCE:
netdev_err(pp->dev, "bad rx status %08x (resource error), size=%d\n",
status, rx_desc->data_size);
dev_err(pp->phydev->dev,
"bad rx status %08x (resource error), size=%d\n",
status, rx_desc->data_size);
break;
}
}
@ -1127,8 +1131,8 @@ static int mvneta_setup_rxqs(struct mvneta_port *pp)
for (queue = 0; queue < rxq_number; queue++) {
int err = mvneta_rxq_init(pp, &pp->rxqs[queue]);
if (err) {
netdev_err(pp->dev, "%s: can't create rxq=%d\n",
__func__, queue);
dev_err(pp->phydev->dev, "%s: can't create rxq=%d\n",
__func__, queue);
mvneta_cleanup_rxqs(pp);
return err;
}
@ -1145,8 +1149,8 @@ static int mvneta_setup_txqs(struct mvneta_port *pp)
for (queue = 0; queue < txq_number; queue++) {
int err = mvneta_txq_init(pp, &pp->txqs[queue]);
if (err) {
netdev_err(pp->dev, "%s: can't create txq=%d\n",
__func__, queue);
dev_err(pp->phydev->dev, "%s: can't create txq=%d\n",
__func__, queue);
mvneta_cleanup_txqs(pp);
return err;
}
@ -1402,7 +1406,7 @@ static int mvneta_init(struct udevice *dev)
err = mvneta_init2(pp);
if (err < 0) {
dev_err(&pdev->dev, "can't init eth hal\n");
dev_err(dev, "can't init eth hal\n");
return err;
}
@ -1410,7 +1414,7 @@ static int mvneta_init(struct udevice *dev)
err = mvneta_port_power_up(pp, pp->phy_interface);
if (err < 0) {
dev_err(&pdev->dev, "can't power up port\n");
dev_err(dev, "can't power up port\n");
return err;
}

87
drivers/net/mvpp2.c
View File

@ -2568,7 +2568,7 @@ static int mvpp2_bm_pool_create(struct udevice *dev,
if (!IS_ALIGNED((unsigned long)bm_pool->virt_addr,
MVPP2_BM_POOL_PTR_ALIGN)) {
dev_err(&pdev->dev, "BM pool %d is not %d bytes aligned\n",
dev_err(dev, "BM pool %d is not %d bytes aligned\n",
bm_pool->id, MVPP2_BM_POOL_PTR_ALIGN);
return -ENOMEM;
}
@ -2659,7 +2659,7 @@ static int mvpp2_bm_pools_init(struct udevice *dev,
return 0;
err_unroll_pools:
dev_err(&pdev->dev, "failed to create BM pool %d, size %d\n", i, size);
dev_err(dev, "failed to create BM pool %d, size %d\n", i, size);
for (i = i - 1; i >= 0; i--)
mvpp2_bm_pool_destroy(dev, priv, &priv->bm_pools[i]);
return err;
@ -2773,9 +2773,9 @@ static int mvpp2_bm_bufs_add(struct mvpp2_port *port,
if (buf_num < 0 ||
(buf_num + bm_pool->buf_num > bm_pool->size)) {
netdev_err(port->dev,
"cannot allocate %d buffers for pool %d\n",
buf_num, bm_pool->id);
dev_err(port->phy_dev->dev,
"cannot allocate %d buffers for pool %d\n", buf_num,
bm_pool->id);
return 0;
}
@ -2803,7 +2803,7 @@ mvpp2_bm_pool_use(struct mvpp2_port *port, int pool, enum mvpp2_bm_type type,
int num;
if (new_pool->type != MVPP2_BM_FREE && new_pool->type != type) {
netdev_err(port->dev, "mixing pool types is forbidden\n");
dev_err(port->phy_dev->dev, "mixing pool types is forbidden\n");
return NULL;
}
@ -2834,8 +2834,9 @@ mvpp2_bm_pool_use(struct mvpp2_port *port, int pool, enum mvpp2_bm_type type,
/* Allocate buffers for this pool */
num = mvpp2_bm_bufs_add(port, new_pool, pkts_num);
if (num != pkts_num) {
dev_err(dev, "pool %d: %d of %d allocated\n",
new_pool->id, num, pkts_num);
dev_err(port->phy_dev->dev,
"pool %d: %d of %d allocated\n", new_pool->id,
num, pkts_num);
return NULL;
}
}
@ -3344,8 +3345,7 @@ static int gop_port_init(struct mvpp2_port *port)
int num_of_act_lanes;
if (mac_num >= MVPP22_GOP_MAC_NUM) {
netdev_err(NULL, "%s: illegal port number %d", __func__,
mac_num);
log_err("illegal port number %d", mac_num);
return -1;
}
@ -3399,8 +3399,8 @@ static int gop_port_init(struct mvpp2_port *port)
break;
default:
netdev_err(NULL, "%s: Requested port mode (%d) not supported\n",
__func__, port->phy_interface);
log_err("Requested port mode (%d) not supported\n",
port->phy_interface);
return -1;
}
@ -3440,8 +3440,8 @@ static void gop_port_enable(struct mvpp2_port *port, int enable)
break;
default:
netdev_err(NULL, "%s: Wrong port mode (%d)\n", __func__,
port->phy_interface);
log_err("%s: Wrong port mode (%d)\n", __func__,
port->phy_interface);
return;
}
}
@ -3811,9 +3811,9 @@ static void mvpp2_egress_disable(struct mvpp2_port *port)
delay = 0;
do {
if (delay >= MVPP2_TX_DISABLE_TIMEOUT_MSEC) {
netdev_warn(port->dev,
"Tx stop timed out, status=0x%08x\n",
reg_data);
dev_warn(port->phy_dev->dev,
"Tx stop timed out, status=0x%08x\n",
reg_data);
break;
}
mdelay(1);
@ -4261,9 +4261,9 @@ static void mvpp2_txq_clean(struct mvpp2_port *port, struct mvpp2_tx_queue *txq)
delay = 0;
do {
if (delay >= MVPP2_TX_PENDING_TIMEOUT_MSEC) {
netdev_warn(port->dev,
"port %d: cleaning queue %d timed out\n",
port->id, txq->log_id);
dev_warn(port->phy_dev->dev,
"port %d: cleaning queue %d timed out\n",
port->id, txq->log_id);
break;
}
mdelay(1);
@ -4430,16 +4430,19 @@ static void mvpp2_rx_error(struct mvpp2_port *port,
switch (status & MVPP2_RXD_ERR_CODE_MASK) {
case MVPP2_RXD_ERR_CRC:
netdev_err(port->dev, "bad rx status %08x (crc error), size=%zu\n",
status, sz);
dev_err(port->phy_dev->dev,
"bad rx status %08x (crc error), size=%zu\n", status,
sz);
break;
case MVPP2_RXD_ERR_OVERRUN:
netdev_err(port->dev, "bad rx status %08x (overrun error), size=%zu\n",
status, sz);
dev_err(port->phy_dev->dev,
"bad rx status %08x (overrun error), size=%zu\n",
status, sz);
break;
case MVPP2_RXD_ERR_RESOURCE:
netdev_err(port->dev, "bad rx status %08x (resource error), size=%zu\n",
status, sz);
dev_err(port->phy_dev->dev,
"bad rx status %08x (resource error), size=%zu\n",
status, sz);
break;
}
}
@ -4507,8 +4510,8 @@ static void mvpp2_phy_connect(struct udevice *dev, struct mvpp2_port *port)
*/
if (phy_dev &&
phy_dev->drv->uid == 0xffffffff) {/* Generic phy */
netdev_warn(port->dev,
"Marking phy as invalid, link will not be checked\n");
dev_warn(port->phy_dev->dev,
"Marking phy as invalid, link will not be checked\n");
/* set phy_addr to invalid value */
port->phyaddr = PHY_MAX_ADDR;
mvpp2_egress_enable(port);
@ -4519,7 +4522,7 @@ static void mvpp2_phy_connect(struct udevice *dev, struct mvpp2_port *port)
port->phy_dev = phy_dev;
if (!phy_dev) {
netdev_err(port->dev, "cannot connect to phy\n");
dev_err(port->phy_dev->dev, "cannot connect to phy\n");
return;
}
phy_dev->supported &= PHY_GBIT_FEATURES;
@ -4550,31 +4553,31 @@ static int mvpp2_open(struct udevice *dev, struct mvpp2_port *port)
err = mvpp2_prs_mac_da_accept(port->priv, port->id, mac_bcast, true);
if (err) {
netdev_err(dev, "mvpp2_prs_mac_da_accept BC failed\n");
dev_err(dev, "mvpp2_prs_mac_da_accept BC failed\n");
return err;
}
err = mvpp2_prs_mac_da_accept(port->priv, port->id,
port->dev_addr, true);
if (err) {
netdev_err(dev, "mvpp2_prs_mac_da_accept MC failed\n");
dev_err(dev, "mvpp2_prs_mac_da_accept MC failed\n");
return err;
}
err = mvpp2_prs_def_flow(port);
if (err) {
netdev_err(dev, "mvpp2_prs_def_flow failed\n");
dev_err(dev, "mvpp2_prs_def_flow failed\n");
return err;
}
/* Allocate the Rx/Tx queues */
err = mvpp2_setup_rxqs(port);
if (err) {
netdev_err(port->dev, "cannot allocate Rx queues\n");
dev_err(port->phy_dev->dev, "cannot allocate Rx queues\n");
return err;
}
err = mvpp2_setup_txqs(port);
if (err) {
netdev_err(port->dev, "cannot allocate Tx queues\n");
dev_err(port->phy_dev->dev, "cannot allocate Tx queues\n");
return err;
}
@ -4725,7 +4728,7 @@ static int phy_info_parse(struct udevice *dev, struct mvpp2_port *port)
int parent;
phyaddr = fdtdec_get_int(gd->fdt_blob, phy_node, "reg", 0);
if (phyaddr < 0) {
dev_err(&pdev->dev, "could not find phy address\n");
dev_err(dev, "could not find phy address\n");
return -1;
}
parent = fdt_parent_offset(gd->fdt_blob, phy_node);
@ -4742,13 +4745,13 @@ static int phy_info_parse(struct udevice *dev, struct mvpp2_port *port)
if (phy_mode_str)
phy_mode = phy_get_interface_by_name(phy_mode_str);
if (phy_mode == -1) {
dev_err(&pdev->dev, "incorrect phy mode\n");
dev_err(dev, "incorrect phy mode\n");
return -EINVAL;
}
id = fdtdec_get_int(gd->fdt_blob, port_node, "port-id", -1);
if (id == -1) {
dev_err(&pdev->dev, "missing port-id value\n");
dev_err(dev, "missing port-id value\n");
return -EINVAL;
}
@ -4807,7 +4810,7 @@ static int mvpp2_port_probe(struct udevice *dev,
err = mvpp2_port_init(dev, port);
if (err < 0) {
dev_err(&pdev->dev, "failed to init port %d\n", port->id);
dev_err(dev, "failed to init port %d\n", port->id);
return err;
}
mvpp2_port_power_up(port);
@ -4978,7 +4981,7 @@ static int mvpp2_init(struct udevice *dev, struct mvpp2 *priv)
/* Checks for hardware constraints (U-Boot uses only one rxq) */
if ((rxq_number > priv->max_port_rxqs) ||
(txq_number > MVPP2_MAX_TXQ)) {
dev_err(&pdev->dev, "invalid queue size parameter\n");
dev_err(dev, "invalid queue size parameter\n");
return -EINVAL;
}
@ -5099,7 +5102,7 @@ static int mvpp2_recv(struct udevice *dev, int flags, uchar **packetp)
err = mvpp2_rx_refill(port, bm_pool, bm, dma_addr);
if (err) {
netdev_err(port->dev, "failed to refill BM pools\n");
dev_err(port->phy_dev->dev, "failed to refill BM pools\n");
return 0;
}
@ -5345,7 +5348,7 @@ static int mvpp2_probe(struct udevice *dev)
port->gop_id = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
"gop-port-id", -1);
if (port->id == -1) {
dev_err(&pdev->dev, "missing gop-port-id value\n");
dev_err(dev, "missing gop-port-id value\n");
return -EINVAL;
}
@ -5364,7 +5367,7 @@ static int mvpp2_probe(struct udevice *dev)
/* Initialize network controller */
err = mvpp2_init(dev, priv);
if (err < 0) {
dev_err(&pdev->dev, "failed to initialize controller\n");
dev_err(dev, "failed to initialize controller\n");
return err;
}
priv->num_ports = 0;

9
drivers/net/sun8i_emac.c
View File

@ -663,7 +663,8 @@ static int sun8i_eth_write_hwaddr(struct udevice *dev)
return _sun8i_write_hwaddr(priv, pdata->enetaddr);
}
static int sun8i_emac_board_setup(struct emac_eth_dev *priv)
static int sun8i_emac_board_setup(struct udevice *dev,
struct emac_eth_dev *priv)
{
int ret;
@ -833,7 +834,7 @@ static int sun8i_emac_eth_probe(struct udevice *dev)
priv->mac_reg = (void *)pdata->iobase;
ret = sun8i_emac_board_setup(priv);
ret = sun8i_emac_board_setup(dev, priv);
if (ret)
return ret;
@ -854,7 +855,7 @@ static const struct eth_ops sun8i_emac_eth_ops = {
.stop = sun8i_emac_eth_stop,
};
static int sun8i_get_ephy_nodes(struct emac_eth_dev *priv)
static int sun8i_get_ephy_nodes(struct udevice *dev, struct emac_eth_dev *priv)
{
int emac_node, ephy_node, ret, ephy_handle;
@ -986,7 +987,7 @@ static int sun8i_emac_eth_ofdata_to_platdata(struct udevice *dev)
}
if (priv->variant == H3_EMAC) {
ret = sun8i_get_ephy_nodes(priv);
ret = sun8i_get_ephy_nodes(dev, priv);
if (ret)
return ret;
}

5
drivers/net/sunxi_emac.c
View File

@ -505,7 +505,8 @@ static int _sunxi_emac_eth_send(struct emac_eth_dev *priv, void *packet,
return 0;
}
static int sunxi_emac_board_setup(struct emac_eth_dev *priv)
static int sunxi_emac_board_setup(struct udevice *dev,
struct emac_eth_dev *priv)
{
struct sunxi_sramc_regs *sram =
(struct sunxi_sramc_regs *)SUNXI_SRAMC_BASE;
@ -576,7 +577,7 @@ static int sunxi_emac_eth_probe(struct udevice *dev)
return ret;
}
ret = sunxi_emac_board_setup(priv);
ret = sunxi_emac_board_setup(dev, priv);
if (ret)
return ret;

6
drivers/net/ti/cpsw.c
View File

@ -856,8 +856,14 @@ static int cpsw_phy_init(struct cpsw_priv *priv, struct cpsw_slave *slave)
ret = phy_set_supported(phydev, slave->data->max_speed);
if (ret)
return ret;
#if CONFIG_IS_ENABLED(DM_ETH)
dev_dbg(priv->dev, "Port %u speed forced to %uMbit\n",
slave->slave_num + 1, slave->data->max_speed);
#else
log_debug("%s: Port %u speed forced to %uMbit\n",
priv->dev->name, slave->slave_num + 1,
slave->data->max_speed);
#endif
}
phydev->advertising = phydev->supported;

12
drivers/phy/allwinner/phy-sun4i-usb.c
View File

@ -272,13 +272,15 @@ static int sun4i_usb_phy_init(struct phy *phy)
ret = clk_enable(&usb_phy->clocks);
if (ret) {
dev_err(dev, "failed to enable usb_%ldphy clock\n", phy->id);
dev_err(phy->dev, "failed to enable usb_%ldphy clock\n",
phy->id);
return ret;
}
ret = reset_deassert(&usb_phy->resets);
if (ret) {
dev_err(dev, "failed to deassert usb_%ldreset reset\n", phy->id);
dev_err(phy->dev, "failed to deassert usb_%ldreset reset\n",
phy->id);
return ret;
}
@ -338,13 +340,15 @@ static int sun4i_usb_phy_exit(struct phy *phy)
ret = clk_disable(&usb_phy->clocks);
if (ret) {
dev_err(dev, "failed to disable usb_%ldphy clock\n", phy->id);
dev_err(phy->dev, "failed to disable usb_%ldphy clock\n",
phy->id);
return ret;
}
ret = reset_assert(&usb_phy->resets);
if (ret) {
dev_err(dev, "failed to assert usb_%ldreset reset\n", phy->id);
dev_err(phy->dev, "failed to assert usb_%ldreset reset\n",
phy->id);
return ret;
}

6
drivers/phy/marvell/comphy_core.c
View File

@ -98,14 +98,14 @@ static int comphy_probe(struct udevice *dev)
chip_cfg->comphy_lanes_count = fdtdec_get_int(blob, node,
"max-lanes", 0);
if (chip_cfg->comphy_lanes_count <= 0) {
dev_err(&dev->dev, "comphy max lanes is wrong\n");
dev_err(dev, "comphy max lanes is wrong\n");
return -EINVAL;
}
chip_cfg->comphy_mux_bitcount = fdtdec_get_int(blob, node,
"mux-bitcount", 0);
if (chip_cfg->comphy_mux_bitcount <= 0) {
dev_err(&dev->dev, "comphy mux bit count is wrong\n");
dev_err(dev, "comphy mux bit count is wrong\n");
return -EINVAL;
}
@ -124,7 +124,7 @@ static int comphy_probe(struct udevice *dev)
* compatible node is found
*/
if (!chip_cfg->ptr_comphy_chip_init) {
dev_err(&dev->dev, "comphy: No compatible DT node found\n");
dev_err(dev, "comphy: No compatible DT node found\n");
return -ENODEV;
}

2
drivers/phy/phy-stm32-usbphyc.c
View File

@ -311,7 +311,7 @@ static int stm32_usbphyc_of_xlate(struct phy *phy,
if ((phy->id == 0 && args->args_count != 1) ||
(phy->id == 1 && args->args_count != 2)) {
dev_err(dev, "invalid number of cells for phy port%ld\n",
dev_err(phy->dev, "invalid number of cells for phy port%ld\n",
phy->id);
return -EINVAL;
}

4
drivers/phy/phy-ti-am654.c
View File

@ -318,13 +318,13 @@ static int serdes_am654_of_xlate(struct phy *x,
struct serdes_am654 *phy = dev_get_priv(x->dev);
if (args->args_count != 2) {
dev_err(phy->dev, "Invalid DT PHY argument count: %d\n",
dev_err(x->dev, "Invalid DT PHY argument count: %d\n",
args->args_count);
return -EINVAL;
}
if (args->args[0] != PHY_TYPE_PCIE) {
dev_err(phy->dev, "Unrecognized PHY type: %d\n",
dev_err(x->dev, "Unrecognized PHY type: %d\n",
args->args[0]);
return -EINVAL;
}

14
drivers/phy/rockchip/phy-rockchip-pcie.c
View File

@ -98,7 +98,7 @@ static int rockchip_pcie_phy_power_on(struct phy *phy)
ret = reset_deassert(&priv->phy_rst);
if (ret) {
dev_err(dev, "failed to assert phy reset\n");
dev_err(phy->dev, "failed to assert phy reset\n");
return ret;
}
@ -119,7 +119,7 @@ static int rockchip_pcie_phy_power_on(struct phy *phy)
20 * 1000,
50);
if (ret) {
dev_err(&priv->dev, "pll lock timeout!\n");
dev_err(phy->dev, "pll lock timeout!\n");
goto err_pll_lock;
}
@ -133,7 +133,7 @@ static int rockchip_pcie_phy_power_on(struct phy *phy)
20 * 1000,
50);
if (ret) {
dev_err(&priv->dev, "pll output enable timeout!\n");
dev_err(phy->dev, "pll output enable timeout!\n");
goto err_pll_lock;
}
@ -149,7 +149,7 @@ static int rockchip_pcie_phy_power_on(struct phy *phy)
20 * 1000,
50);
if (ret) {
dev_err(&priv->dev, "pll relock timeout!\n");
dev_err(phy->dev, "pll relock timeout!\n");
goto err_pll_lock;
}
@ -173,7 +173,7 @@ static int rockchip_pcie_phy_power_off(struct phy *phy)
ret = reset_assert(&priv->phy_rst);
if (ret) {
dev_err(dev, "failed to assert phy reset\n");
dev_err(phy->dev, "failed to assert phy reset\n");
return ret;
}
@ -187,13 +187,13 @@ static int rockchip_pcie_phy_init(struct phy *phy)
ret = clk_enable(&priv->refclk);
if (ret) {
dev_err(dev, "failed to enable refclk clock\n");
dev_err(phy->dev, "failed to enable refclk clock\n");
return ret;
}
ret = reset_assert(&priv->phy_rst);
if (ret) {
dev_err(dev, "failed to assert phy reset\n");
dev_err(phy->dev, "failed to assert phy reset\n");
goto err_reset;
}

6
drivers/phy/rockchip/phy-rockchip-typec.c
View File

@ -448,7 +448,7 @@ static void rockchip_tcphy_rx_usb3_cfg_lane(struct rockchip_tcphy *priv,
writel(0xfb, priv->reg_base + XCVR_DIAG_BIDI_CTRL(lane));
}
static int rockchip_tcphy_init(struct rockchip_tcphy *priv)
static int rockchip_tcphy_init(struct phy *phy, struct rockchip_tcphy *priv)
{
const struct rockchip_usb3phy_port_cfg *cfg = priv->port_cfgs;
u32 val;
@ -559,9 +559,9 @@ static int rockchip_usb3_phy_power_on(struct phy *phy)
return 0;
if (priv->mode == MODE_DISCONNECT) {
ret = rockchip_tcphy_init(priv);
ret = rockchip_tcphy_init(phy, priv);
if (ret) {
dev_err(dev, "failed to init tcphy (ret=%d)\n", ret);
dev_err(phy->dev, "failed to init tcphy (ret=%d)\n", ret);
return ret;
}
}

9
drivers/remoteproc/k3_system_controller.c
View File

@ -100,7 +100,7 @@ void k3_sysctrler_load_msg_setup(struct k3_sysctrler_load_msg *fw,
fw->buffer_size = size;
}
static int k3_sysctrler_load_response(u32 *buf)
static int k3_sysctrler_load_response(struct udevice *dev, u32 *buf)
{
struct k3_sysctrler_load_msg *fw;
@ -129,7 +129,8 @@ static int k3_sysctrler_load_response(u32 *buf)
return 0;
}
static int k3_sysctrler_boot_notification_response(u32 *buf)
static int k3_sysctrler_boot_notification_response(struct udevice *dev,
u32 *buf)
{
struct k3_sysctrler_boot_notification_msg *boot;
@ -193,7 +194,7 @@ static int k3_sysctrler_load(struct udevice *dev, ulong addr, ulong size)
}
/* Process the response */
ret = k3_sysctrler_load_response(msg.buf);
ret = k3_sysctrler_load_response(dev, msg.buf);
if (ret)
return ret;
@ -230,7 +231,7 @@ static int k3_sysctrler_start(struct udevice *dev)
}
/* Process the response */
ret = k3_sysctrler_boot_notification_response(msg.buf);
ret = k3_sysctrler_boot_notification_response(dev, msg.buf);
if (ret)
return ret;

16
drivers/remoteproc/rproc-elf-loader.c
View File

@ -158,22 +158,6 @@ int rproc_elf64_sanity_check(ulong addr, ulong size)
return 0;
}
/* Basic function to verify ELF image format */
int rproc_elf_sanity_check(ulong addr, ulong size)
{
Elf32_Ehdr *ehdr = (Elf32_Ehdr *)addr;
if (!addr) {
dev_err(dev, "Invalid firmware address\n");
return -EFAULT;
}
if (ehdr->e_ident[EI_CLASS] == ELFCLASS64)
return rproc_elf64_sanity_check(addr, size);
else
return rproc_elf32_sanity_check(addr, size);
}
int rproc_elf32_load_image(struct udevice *dev, unsigned long addr, ulong size)
{
Elf32_Ehdr *ehdr; /* Elf header structure pointer */

24
drivers/remoteproc/ti_k3_r5f_rproc.c
View File

@ -165,7 +165,7 @@ static int k3_r5f_lockstep_release(struct k3_r5f_cluster *cluster)
{
int ret, c;
dev_dbg(dev, "%s\n", __func__);
debug("%s\n", __func__);
for (c = NR_CORES - 1; c >= 0; c--) {
ret = ti_sci_proc_power_domain_on(&cluster->cores[c]->tsp);
@ -201,7 +201,7 @@ static int k3_r5f_split_release(struct k3_r5f_core *core)
{
int ret;
dev_dbg(dev, "%s\n", __func__);
dev_dbg(core->dev, "%s\n", __func__);
ret = ti_sci_proc_power_domain_on(&core->tsp);
if (ret) {
@ -246,25 +246,29 @@ static int k3_r5f_core_sanity_check(struct k3_r5f_core *core)
struct k3_r5f_cluster *cluster = core->cluster;
if (core->in_use) {
dev_err(dev, "Invalid op: Trying to load/start on already running core %d\n",
dev_err(core->dev,
"Invalid op: Trying to load/start on already running core %d\n",
core->tsp.proc_id);
return -EINVAL;
}
if (cluster->mode == CLUSTER_MODE_LOCKSTEP && !cluster->cores[1]) {
printf("Secondary core is not probed in this cluster\n");
dev_err(core->dev,
"Secondary core is not probed in this cluster\n");
return -EAGAIN;
}
if (cluster->mode == CLUSTER_MODE_LOCKSTEP && !is_primary_core(core)) {
dev_err(dev, "Invalid op: Trying to start secondary core %d in lockstep mode\n",
dev_err(core->dev,
"Invalid op: Trying to start secondary core %d in lockstep mode\n",
core->tsp.proc_id);
return -EINVAL;
}
if (cluster->mode == CLUSTER_MODE_SPLIT && !is_primary_core(core)) {
if (!core->cluster->cores[0]->in_use) {
dev_err(dev, "Invalid seq: Enable primary core before loading secondary core\n");
dev_err(core->dev,
"Invalid seq: Enable primary core before loading secondary core\n");
return -EINVAL;
}
}
@ -432,7 +436,7 @@ static int k3_r5f_split_reset(struct k3_r5f_core *core)
{
int ret;
dev_dbg(dev, "%s\n", __func__);
dev_dbg(core->dev, "%s\n", __func__);
if (reset_assert(&core->reset))
ret = -EINVAL;
@ -447,7 +451,7 @@ static int k3_r5f_lockstep_reset(struct k3_r5f_cluster *cluster)
{
int ret = 0, c;
dev_dbg(dev, "%s\n", __func__);
debug("%s\n", __func__);
for (c = 0; c < NR_CORES; c++)
if (reset_assert(&cluster->cores[c]->reset))
@ -579,7 +583,7 @@ static int k3_r5f_rproc_configure(struct k3_r5f_core *core)
u64 boot_vec = 0;
int ret;
dev_dbg(dev, "%s\n", __func__);
dev_dbg(core->dev, "%s\n", __func__);
ret = ti_sci_proc_request(&core->tsp);
if (ret < 0)
@ -672,7 +676,7 @@ static int k3_r5f_of_to_priv(struct k3_r5f_core *core)
{
int ret;
dev_dbg(dev, "%s\n", __func__);
dev_dbg(core->dev, "%s\n", __func__);
core->atcm_enable = dev_read_u32_default(core->dev, "atcm-enable", 0);
core->btcm_enable = dev_read_u32_default(core->dev, "btcm-enable", 1);

2
drivers/smem/msm_smem.c
View File

@ -879,7 +879,7 @@ static int qcom_smem_probe(struct udevice *dev)
header = smem->regions[0].virt_base;
if (le32_to_cpu(header->initialized) != 1 ||
le32_to_cpu(header->reserved)) {
dev_err(&pdev->dev, "SMEM is not initialized by SBL\n");
dev_err(dev, "SMEM is not initialized by SBL\n");
return -EINVAL;
}

6
drivers/spi/spi-sunxi.c
View File

@ -489,19 +489,19 @@ static int sun4i_spi_probe(struct udevice *bus)
ret = clk_get_by_name(bus, "ahb", &priv->clk_ahb);
if (ret) {
dev_err(dev, "failed to get ahb clock\n");
dev_err(bus, "failed to get ahb clock\n");
return ret;
}
ret = clk_get_by_name(bus, "mod", &priv->clk_mod);
if (ret) {
dev_err(dev, "failed to get mod clock\n");
dev_err(bus, "failed to get mod clock\n");
return ret;
}
ret = reset_get_by_index(bus, 0, &priv->reset);
if (ret && ret != -ENOENT) {
dev_err(dev, "failed to get reset\n");
dev_err(bus, "failed to get reset\n");
return ret;
}

6
drivers/spi/zynqmp_gqspi.c
View File

@ -346,20 +346,20 @@ static int zynqmp_qspi_probe(struct udevice *bus)
ret = clk_get_by_index(bus, 0, &clk);
if (ret < 0) {
dev_err(dev, "failed to get clock\n");
dev_err(bus, "failed to get clock\n");
return ret;
}
clock = clk_get_rate(&clk);
if (IS_ERR_VALUE(clock)) {
dev_err(dev, "failed to get rate\n");
dev_err(bus, "failed to get rate\n");
return clock;
}
debug("%s: CLK %ld\n", __func__, clock);
ret = clk_enable(&clk);
if (ret && ret != -ENOSYS) {
dev_err(dev, "failed to enable clock\n");
dev_err(bus, "failed to enable clock\n");
return ret;
}
plat->frequency = clock;

3
drivers/sysreset/sysreset-ti-sci.c
View File

@ -51,8 +51,7 @@ static int ti_sci_sysreset_request(struct udevice *dev, enum sysreset_t type)
ret = cops->reboot_device(sci);
if (ret)
dev_err(rst->dev, "%s: reboot_device failed (%d)\n",
__func__, ret);
dev_err(dev, "%s: reboot_device failed (%d)\n", __func__, ret);
return ret;
}

5
drivers/usb/cdns3/ep0.c
View File

@ -11,8 +11,9 @@
*/
#include <cpu_func.h>
#include <asm/cache.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <asm/cache.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <linux/usb/composite.h>
@ -810,7 +811,7 @@ int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
{
struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
dev_dbg(priv_dev->dev, "Wedge for %s\n", ep->name);
dev_dbg(priv_ep->cdns3_dev->dev, "Wedge for %s\n", ep->name);
cdns3_gadget_ep_set_halt(ep, 1);
priv_ep->flags |= EP_WEDGE;

3
drivers/usb/cdns3/gadget.c
View File

@ -2399,8 +2399,7 @@ static void cdns3_gadget_udc_set_speed(struct usb_gadget *gadget,
case USB_SPEED_SUPER:
break;
default:
dev_err(cdns->dev, "invalid speed parameter %d\n",
speed);
dev_err(priv_dev->dev, "invalid speed parameter %d\n", speed);
}
priv_dev->gadget.speed = speed;

15
drivers/usb/dwc3/core.c
View File

@ -592,7 +592,7 @@ static int dwc3_core_init_mode(struct dwc3 *dwc)
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
ret = dwc3_gadget_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize gadget\n");
dev_err(dwc->dev, "failed to initialize gadget\n");
return ret;
}
break;
@ -600,7 +600,7 @@ static int dwc3_core_init_mode(struct dwc3 *dwc)
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
ret = dwc3_host_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize host\n");
dev_err(dwc->dev, "failed to initialize host\n");
return ret;
}
break;
@ -608,18 +608,19 @@ static int dwc3_core_init_mode(struct dwc3 *dwc)
dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
ret = dwc3_host_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize host\n");
dev_err(dwc->dev, "failed to initialize host\n");
return ret;
}
ret = dwc3_gadget_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize gadget\n");
dev_err(dwc->dev, "failed to initialize gadget\n");
return ret;
}
break;
default:
dev_err(dev, "Unsupported mode of operation %d\n", dwc->dr_mode);
dev_err(dwc->dev,
"Unsupported mode of operation %d\n", dwc->dr_mode);
return -EINVAL;
}
@ -768,7 +769,7 @@ int dwc3_uboot_init(struct dwc3_device *dwc3_dev)
ret = dwc3_core_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize core\n");
dev_err(dwc->dev, "failed to initialize core\n");
goto err0;
}
@ -974,7 +975,7 @@ int dwc3_init(struct dwc3 *dwc)
ret = dwc3_core_init(dwc);
if (ret) {
dev_err(dev, "failed to initialize core\n");
dev_err(dwc->dev, "failed to initialize core\n");
goto core_fail;
}

1
drivers/usb/dwc3/dwc3-generic.c
View File

@ -10,7 +10,6 @@
#include <common.h>
#include <cpu_func.h>
#include <log.h>
#include <asm-generic/io.h>
#include <dm.h>
#include <dm/device-internal.h>
#include <dm/lists.h>

1
drivers/usb/dwc3/ep0.c
View File

@ -14,6 +14,7 @@
*/
#include <common.h>
#include <cpu_func.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <linux/bug.h>
#include <linux/kernel.h>

23
drivers/usb/dwc3/gadget.c
View File

@ -17,6 +17,7 @@
#include <cpu_func.h>
#include <log.h>
#include <malloc.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/bug.h>
@ -633,7 +634,7 @@ static int dwc3_gadget_ep_enable(struct usb_ep *ep,
strlcat(dep->name, "-int", sizeof(dep->name));
break;
default:
dev_err(dwc->dev, "invalid endpoint transfer type\n");
dev_err(dep->dwc->dev, "invalid endpoint transfer type\n");
}
spin_lock_irqsave(&dwc->lock, flags);
@ -708,10 +709,9 @@ static void dwc3_prepare_one_trb(struct dwc3_ep *dep,
{
struct dwc3_trb *trb;
dev_vdbg(dwc->dev, "%s: req %p dma %08llx length %d%s%s\n",
dep->name, req, (unsigned long long) dma,
length, last ? " last" : "",
chain ? " chain" : "");
dev_vdbg(dep->dwc->dev, "%s: req %p dma %08llx length %d%s%s\n",
dep->name, req, (unsigned long long)dma,
length, last ? " last" : "", chain ? " chain" : "");
trb = &dep->trb_pool[dep->free_slot & DWC3_TRB_MASK];
@ -1074,21 +1074,22 @@ static int dwc3_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request,
spin_lock_irqsave(&dwc->lock, flags);
if (!dep->endpoint.desc) {
dev_dbg(dwc->dev, "trying to queue request %p to disabled %s\n",
request, ep->name);
dev_dbg(dep->dwc->dev,
"trying to queue request %p to disabled %s\n", request,
ep->name);
ret = -ESHUTDOWN;
goto out;
}
if (req->dep != dep) {
WARN(true, "request %p belongs to '%s'\n",
request, req->dep->name);
WARN(true, "request %p belongs to '%s'\n", request,
req->dep->name);
ret = -EINVAL;
goto out;
}
dev_vdbg(dwc->dev, "queing request %p to %s length %d\n",
request, ep->name, request->length);
dev_vdbg(dep->dwc->dev, "queing request %p to %s length %d\n",
request, ep->name, request->length);
ret = __dwc3_gadget_ep_queue(dep, req);

4
drivers/usb/dwc3/ti_usb_phy.c
View File

@ -129,7 +129,7 @@ static struct usb3_dpll_params *ti_usb3_get_dpll_params(struct ti_usb_phy *phy)
return &dpll_map->params;
}
dev_err(phy->dev, "No DPLL configuration for %lu Hz SYS CLK\n", rate);
log_err("No DPLL configuration for %lu Hz SYS CLK\n", rate);
return NULL;
}
@ -269,7 +269,7 @@ int ti_usb_phy_uboot_init(struct ti_usb_phy_device *dev)
phy = devm_kzalloc(NULL, sizeof(*phy), GFP_KERNEL);
if (!phy) {
dev_err(NULL, "unable to alloc mem for TI USB3 PHY\n");
log_err("unable to alloc mem for TI USB3 PHY\n");
return -ENOMEM;
}

39
drivers/usb/host/dwc2.c
View File

@ -114,7 +114,8 @@ static void init_fslspclksel(struct dwc2_core_regs *regs)
* @param regs Programming view of DWC_otg controller.
* @param num Tx FIFO to flush.
*/
static void dwc_otg_flush_tx_fifo(struct dwc2_core_regs *regs, const int num)
static void dwc_otg_flush_tx_fifo(struct udevice *dev,
struct dwc2_core_regs *regs, const int num)
{
int ret;
@ -134,7 +135,8 @@ static void dwc_otg_flush_tx_fifo(struct dwc2_core_regs *regs, const int num)
*
* @param regs Programming view of DWC_otg controller.
*/
static void dwc_otg_flush_rx_fifo(struct dwc2_core_regs *regs)
static void dwc_otg_flush_rx_fifo(struct udevice *dev,
struct dwc2_core_regs *regs)
{
int ret;
@ -152,7 +154,8 @@ static void dwc_otg_flush_rx_fifo(struct dwc2_core_regs *regs)
* Do core a soft reset of the core. Be careful with this because it
* resets all the internal state machines of the core.
*/
static void dwc_otg_core_reset(struct dwc2_core_regs *regs)
static void dwc_otg_core_reset(struct udevice *dev,
struct dwc2_core_regs *regs)
{
int ret;
@ -284,8 +287,8 @@ static void dwc_otg_core_host_init(struct udevice *dev,
clrbits_le32(&regs->gotgctl, DWC2_GOTGCTL_HSTSETHNPEN);
/* Make sure the FIFOs are flushed. */
dwc_otg_flush_tx_fifo(regs, 0x10); /* All Tx FIFOs */
dwc_otg_flush_rx_fifo(regs);
dwc_otg_flush_tx_fifo(dev, regs, 0x10); /* All Tx FIFOs */
dwc_otg_flush_rx_fifo(dev, regs);
/* Flush out any leftover queued requests. */
num_channels = readl(&regs->ghwcfg2);
@ -306,7 +309,7 @@ static void dwc_otg_core_host_init(struct udevice *dev,
ret = wait_for_bit_le32(&regs->hc_regs[i].hcchar,
DWC2_HCCHAR_CHEN, false, 1000, false);
if (ret)
dev_info("%s: Timeout!\n", __func__);
dev_info(dev, "%s: Timeout!\n", __func__);
}
/* Turn on the vbus power. */
@ -330,8 +333,9 @@ static void dwc_otg_core_host_init(struct udevice *dev,
*
* @param regs Programming view of the DWC_otg controller
*/
static void dwc_otg_core_init(struct dwc2_priv *priv)
static void dwc_otg_core_init(struct udevice *dev)
{
struct dwc2_priv *priv = dev_get_priv(dev);
struct dwc2_core_regs *regs = priv->regs;
uint32_t ahbcfg = 0;
uint32_t usbcfg = 0;
@ -360,7 +364,7 @@ static void dwc_otg_core_init(struct dwc2_priv *priv)
writel(usbcfg, &regs->gusbcfg);
/* Reset the Controller */
dwc_otg_core_reset(regs);
dwc_otg_core_reset(dev, regs);
/*
* This programming sequence needs to happen in FS mode before
@ -372,7 +376,7 @@ static void dwc_otg_core_init(struct dwc2_priv *priv)
setbits_le32(&regs->gusbcfg, DWC2_GUSBCFG_PHYSEL);
/* Reset after a PHY select */
dwc_otg_core_reset(regs);
dwc_otg_core_reset(dev, regs);
/*
* Program DCFG.DevSpd or HCFG.FSLSPclkSel to 48Mhz in FS.
@ -419,7 +423,7 @@ static void dwc_otg_core_init(struct dwc2_priv *priv)
writel(usbcfg, &regs->gusbcfg);
/* Reset after setting the PHY parameters */
dwc_otg_core_reset(regs);
dwc_otg_core_reset(dev, regs);
#endif
usbcfg = readl(&regs->gusbcfg);
@ -1128,7 +1132,12 @@ int _submit_int_msg(struct dwc2_priv *priv, struct usb_device *dev,
timeout = get_timer(0) + USB_TIMEOUT_MS(pipe);
for (;;) {
if (get_timer(0) > timeout) {
dev_err(dev, "Timeout poll on interrupt endpoint\n");
#if CONFIG_IS_ENABLED(DM_USB)
dev_err(dev->dev,
"Timeout poll on interrupt endpoint\n");
#else
log_err("Timeout poll on interrupt endpoint\n");
#endif
return -ETIMEDOUT;
}
ret = _submit_bulk_msg(priv, dev, pipe, buffer, len);
@ -1194,7 +1203,7 @@ static int dwc2_init_common(struct udevice *dev, struct dwc2_priv *priv)
priv->ext_vbus = 0;
#endif
dwc_otg_core_init(priv);
dwc_otg_core_init(dev);
dwc_otg_core_host_init(dev, regs);
clrsetbits_le32(&regs->hprt0, DWC2_HPRT0_PRTENA |
@ -1320,12 +1329,10 @@ static int dwc2_submit_int_msg(struct udevice *dev, struct usb_device *udev,
static int dwc2_usb_ofdata_to_platdata(struct udevice *dev)
{
struct dwc2_priv *priv = dev_get_priv(dev);
fdt_addr_t addr;
addr = dev_read_addr(dev);
if (addr == FDT_ADDR_T_NONE)
priv->regs = dev_read_addr_ptr(dev);
if (!priv->regs)
return -EINVAL;
priv->regs = (struct dwc2_core_regs *)addr;
priv->oc_disable = dev_read_bool(dev, "disable-over-current");
priv->hnp_srp_disable = dev_read_bool(dev, "hnp-srp-disable");

9
drivers/usb/musb-new/sunxi.c
View File

@ -301,21 +301,21 @@ static int sunxi_musb_init(struct musb *musb)
ret = clk_enable(&glue->clk);
if (ret) {
dev_err(dev, "failed to enable clock\n");
dev_err(musb->controller, "failed to enable clock\n");
return ret;
}
if (reset_valid(&glue->rst)) {
ret = reset_deassert(&glue->rst);
if (ret) {
dev_err(dev, "failed to deassert reset\n");
dev_err(musb->controller, "failed to deassert reset\n");
goto err_clk;
}
}
ret = generic_phy_init(&glue->phy);
if (ret) {
dev_dbg(dev, "failed to init USB PHY\n");
dev_dbg(musb->controller, "failed to init USB PHY\n");
goto err_rst;
}
@ -352,7 +352,8 @@ static int sunxi_musb_exit(struct musb *musb)
if (generic_phy_valid(&glue->phy)) {
ret = generic_phy_exit(&glue->phy);
if (ret) {
dev_dbg(dev, "failed to power off usb phy\n");
dev_dbg(musb->controller,
"failed to power off usb phy\n");
return ret;
}
}

24
drivers/video/dw_mipi_dsi.c
View File

@ -314,7 +314,8 @@ static int dw_mipi_dsi_gen_pkt_hdr_write(struct dw_mipi_dsi *dsi, u32 hdr_val)
val, !(val & GEN_CMD_FULL),
CMD_PKT_STATUS_TIMEOUT_US);
if (ret) {
dev_err(dsi->dev, "failed to get available command FIFO\n");
dev_err(dsi->dsi_host.dev,
"failed to get available command FIFO\n");
return ret;
}
@ -325,7 +326,7 @@ static int dw_mipi_dsi_gen_pkt_hdr_write(struct dw_mipi_dsi *dsi, u32 hdr_val)
val, (val & mask) == mask,
CMD_PKT_STATUS_TIMEOUT_US);
if (ret) {
dev_err(dsi->dev, "failed to write command FIFO\n");
dev_err(dsi->dsi_host.dev, "failed to write command FIFO\n");
return ret;
}
@ -357,7 +358,7 @@ static int dw_mipi_dsi_write(struct dw_mipi_dsi *dsi,
val, !(val & GEN_PLD_W_FULL),
CMD_PKT_STATUS_TIMEOUT_US);
if (ret) {
dev_err(dsi->dev,
dev_err(dsi->dsi_host.dev,
"failed to get available write payload FIFO\n");
return ret;
}
@ -380,7 +381,7 @@ static int dw_mipi_dsi_read(struct dw_mipi_dsi *dsi,
val, !(val & GEN_RD_CMD_BUSY),
CMD_PKT_STATUS_TIMEOUT_US);
if (ret) {
dev_err(dsi->dev, "Timeout during read operation\n");
dev_err(dsi->dsi_host.dev, "Timeout during read operation\n");
return ret;
}
@ -390,7 +391,8 @@ static int dw_mipi_dsi_read(struct dw_mipi_dsi *dsi,
val, !(val & GEN_PLD_R_EMPTY),
CMD_PKT_STATUS_TIMEOUT_US);
if (ret) {
dev_err(dsi->dev, "Read payload FIFO is empty\n");
dev_err(dsi->dsi_host.dev,
"Read payload FIFO is empty\n");
return ret;
}
@ -411,7 +413,7 @@ static ssize_t dw_mipi_dsi_host_transfer(struct mipi_dsi_host *host,
ret = mipi_dsi_create_packet(&packet, msg);
if (ret) {
dev_err(dsi->dev, "failed to create packet: %d\n", ret);
dev_err(host->dev, "failed to create packet: %d\n", ret);
return ret;
}
@ -702,13 +704,15 @@ static void dw_mipi_dsi_dphy_enable(struct dw_mipi_dsi *dsi)
ret = readl_poll_timeout(dsi->base + DSI_PHY_STATUS, val,
val & PHY_LOCK, PHY_STATUS_TIMEOUT_US);
if (ret)
dev_warn(dsi->dev, "failed to wait phy lock state\n");
dev_warn(dsi->dsi_host.dev,
"failed to wait phy lock state\n");
ret = readl_poll_timeout(dsi->base + DSI_PHY_STATUS,
val, val & PHY_STOP_STATE_CLK_LANE,
PHY_STATUS_TIMEOUT_US);
if (ret)
dev_warn(dsi->dev, "failed to wait phy clk lane stop state\n");
dev_warn(dsi->dsi_host.dev,
"failed to wait phy clk lane stop state\n");
}
static void dw_mipi_dsi_clear_err(struct dw_mipi_dsi *dsi)
@ -729,7 +733,7 @@ static void dw_mipi_dsi_bridge_set(struct dw_mipi_dsi *dsi,
ret = phy_ops->get_lane_mbps(dsi->device, timings, device->lanes,
device->format, &dsi->lane_mbps);
if (ret)
dev_warn(dsi->dev, "Phy get_lane_mbps() failed\n");
dev_warn(dsi->dsi_host.dev, "Phy get_lane_mbps() failed\n");
dw_mipi_dsi_init_pll(dsi);
dw_mipi_dsi_dpi_config(dsi, timings);
@ -748,7 +752,7 @@ static void dw_mipi_dsi_bridge_set(struct dw_mipi_dsi *dsi,
ret = phy_ops->init(dsi->device);
if (ret)
dev_warn(dsi->dev, "Phy init() failed\n");
dev_warn(dsi->dsi_host.dev, "Phy init() failed\n");
dw_mipi_dsi_dphy_enable(dsi);

127
include/dm/device_compat.h
View File

@ -1,5 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright (C) 2020 Sean Anderson <seanga2@gmail.com>
* Copyright (c) 2013 Google, Inc
*
* (C) Copyright 2012
@ -10,6 +11,8 @@
#ifndef _DM_DEVICE_COMPAT_H
#define _DM_DEVICE_COMPAT_H
#include <log.h>
#include <linux/build_bug.h>
#include <linux/compat.h>
/*
@ -33,54 +36,106 @@
#endif
/*
* REVISIT:
* print device name like Linux
* Define a new identifier which can be tested on by C code. A similar
* definition is made for DEBUG in <log.h>.
*/
#define dev_printk(dev, fmt, ...) \
({ \
printk(fmt, ##__VA_ARGS__); \
#ifdef VERBOSE_DEBUG
#define _VERBOSE_DEBUG 1
#else
#define _VERBOSE_DEBUG 0
#endif
/**
* dev_printk_emit() - Emit a formatted log message
* @cat: Category of the message
* @level: Log level of the message
* @fmt: Format string
* @...: Arguments for @fmt
*
* This macro logs a message through the appropriate channel. It is a macro so
* the if statements can be optimized out (as @level should be a constant known
* at compile-time).
*
* If DEBUG or VERBOSE_DEBUG is defined, then some messages are always printed
* (through printf()). This is to match the historical behavior of the dev_xxx
* functions.
*
* If LOG is enabled, use log() to emit the message, otherwise print it based on
* the console loglevel.
*/
#define dev_printk_emit(cat, level, fmt, ...) \
({ \
if ((_DEBUG && level == LOGL_DEBUG) || \
(_VERBOSE_DEBUG && level == LOGL_DEBUG_CONTENT)) \
printf(fmt, ##__VA_ARGS__); \
else if (CONFIG_IS_ENABLED(LOG)) \
log(cat, level, fmt, ##__VA_ARGS__); \
else if (level < CONFIG_VAL(LOGLEVEL)) \
printf(fmt, ##__VA_ARGS__); \
})
#define __dev_printk(level, dev, fmt, ...) \
({ \
if (level < CONFIG_VAL(LOGLEVEL)) \
dev_printk(dev, fmt, ##__VA_ARGS__); \
/**
* __dev_printk() - Log a message for a device
* @level: Log level of the message
* @dev: A &struct udevice or &struct device
* @fmt: Format string
* @...: Arguments for @fmt
*
* This macro formats and prints dev_xxx log messages. It is done as a macro
* because working with variadic argument is much easier this way, we can
* interrogate the type of device we are passed (and whether it *is* a &struct
* udevice or &struct device), and dev_printk_emit() can optimize out unused if
* branches.
*
* Because this is a macro, we must enforce type checks ourselves. Ideally, we
* would only accept udevices, but there is a significant amount of code (mostly
* USB) which calls dev_xxx with &struct device. When assigning ``__dev``, we
* must first cast ``dev`` to ``void *`` so we don't get warned when ``dev`` is
* a &struct device. Even though the latter branch is not taken, it will still
* get compiled and type-checked.
*
* The format strings in case of a ``NULL`` ``dev`` MUST be kept the same.
* Otherwise, @fmt will be duplicated in the data section (with slightly
* different prefixes). This is why ``(NULL udevice *)`` is printed as two
* string arguments, and not by string pasting.
*/
#define __dev_printk(level, dev, fmt, ...) \
({ \
if (__same_type(dev, struct device *)) { \
dev_printk_emit(LOG_CATEGORY, level, fmt, ##__VA_ARGS__); \
} else { \
BUILD_BUG_ON(!__same_type(dev, struct udevice *)); \
struct udevice *__dev = (void *)dev; \
if (__dev) \
dev_printk_emit(__dev->driver->id, level, \
"%s %s: " fmt, \
__dev->driver->name, __dev->name, \
##__VA_ARGS__); \
else \
dev_printk_emit(LOG_CATEGORY, level, \
"%s %s: " fmt, \
"(NULL", "udevice *)", \
##__VA_ARGS__); \
} \
})
#define dev_emerg(dev, fmt, ...) \
__dev_printk(0, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_EMERG, dev, fmt, ##__VA_ARGS__)
#define dev_alert(dev, fmt, ...) \
__dev_printk(1, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_ALERT, dev, fmt, ##__VA_ARGS__)
#define dev_crit(dev, fmt, ...) \
__dev_printk(2, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_CRIT, dev, fmt, ##__VA_ARGS__)
#define dev_err(dev, fmt, ...) \
__dev_printk(3, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_ERR, dev, fmt, ##__VA_ARGS__)
#define dev_warn(dev, fmt, ...) \
__dev_printk(4, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_WARNING, dev, fmt, ##__VA_ARGS__)
#define dev_notice(dev, fmt, ...) \
__dev_printk(5, dev, fmt, ##__VA_ARGS__)
__dev_printk(LOGL_NOTICE, dev, fmt, ##__VA_ARGS__)
#define dev_info(dev, fmt, ...) \
__dev_printk(6, dev, fmt, ##__VA_ARGS__)
#ifdef DEBUG
__dev_printk(LOGL_INFO, dev, fmt, ##__VA_ARGS__)
#define dev_dbg(dev, fmt, ...) \
__dev_printk(7, dev, fmt, ##__VA_ARGS__)
#else
#define dev_dbg(dev, fmt, ...) \
({ \
if (0) \
__dev_printk(7, dev, fmt, ##__VA_ARGS__); \
})
#endif
#ifdef VERBOSE_DEBUG
#define dev_vdbg dev_dbg
#else
#define dev_vdbg(dev, fmt, ...) \
({ \
if (0) \
__dev_printk(7, dev, fmt, ##__VA_ARGS__); \
})
#endif
__dev_printk(LOGL_DEBUG, dev, fmt, ##__VA_ARGS__)
#define dev_vdbg(dev, fmt, ...) \
__dev_printk(LOGL_DEBUG_CONTENT, dev, fmt, ##__VA_ARGS__)
#endif

19
include/linux/compat.h
View File

@ -52,25 +52,6 @@ extern struct p_current *current;
#define dev_warn(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_emerg(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_alert(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_crit(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_err(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_warn(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_notice(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_info(dev, fmt, args...) \
printf(fmt, ##args)
#define netdev_dbg(dev, fmt, args...) \
debug(fmt, ##args)
#define netdev_vdbg(dev, fmt, args...) \
debug(fmt, ##args)
#define GFP_ATOMIC ((gfp_t) 0)
#define GFP_KERNEL ((gfp_t) 0)
#define GFP_NOFS ((gfp_t) 0)

2
include/mmc.h
View File

@ -888,6 +888,8 @@ void mmc_set_preinit(struct mmc *mmc, int preinit);
#define mmc_host_is_spi(mmc) 0
#endif
#define mmc_dev(x) ((x)->dev)
void board_mmc_power_init(void);
int board_mmc_init(struct bd_info *bis);
int cpu_mmc_init(struct bd_info *bis);

13
include/remoteproc.h
View File

@ -226,19 +226,6 @@ int rproc_elf32_sanity_check(ulong addr, ulong size);
*/
int rproc_elf64_sanity_check(ulong addr, ulong size);
/**
* rproc_elf_sanity_check() - Verify if an image is a valid ELF one
*
* Check if a valid ELF image exists at the given memory location. Auto
* detects ELF32/ELF64 and verifies basic ELF64/ELF32 format requirements
* like magic number and sections size.
*
* @addr: address of the image to verify
* @size: size of the image
* @return 0 if the image looks good, else appropriate error value.
*/
int rproc_elf_sanity_check(ulong addr, ulong size);
/**
* rproc_elf32_load_image() - load an ELF32 image
* @dev: device loading the ELF32 image

4
net/mdio-uclass.c
View File

@ -145,7 +145,7 @@ static struct phy_device *dm_eth_connect_phy_handle(struct udevice *ethdev,
break;
if (!ofnode_valid(phandle.node)) {
dev_dbg(dev, "can't find PHY node\n");
dev_dbg(ethdev, "can't find PHY node\n");
return NULL;
}
@ -161,7 +161,7 @@ static struct phy_device *dm_eth_connect_phy_handle(struct udevice *ethdev,
if (uclass_get_device_by_ofnode(UCLASS_MDIO,
ofnode_get_parent(phandle.node),
&mdiodev)) {
dev_dbg(dev, "can't find MDIO bus for node %s\n",
dev_dbg(ethdev, "can't find MDIO bus for node %s\n",
ofnode_get_name(ofnode_get_parent(phandle.node)));
return NULL;
}