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

i2c: uniphier-f: replace debug() with dev_dbg()

Browse Source 
Use dev_dbg() functions.  It will be helpful to prefix log messages
with the corresponding device name when the core framework is ready.

While I am here, I renamed "dev", which was actually private data,
into "priv" because dev->dev looks confusing.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
This commit is contained in:
Masahiro Yamada 2017-10-13 19:21:58 +09:00
parent 804cf1c46f
commit 2b7b2df91e
1 changed files with 52 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
drivers/i2c/i2c-uniphier-f.c
View File

@ -6,13 +6,12 @@
* SPDX-License-Identifier: GPL-2.0+ * SPDX-License-Identifier: GPL-2.0+
*/ */
#include <common.h> #include <linux/errno.h>
#include <dm.h>
#include <linux/types.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/iopoll.h> #include <linux/iopoll.h>
#include <linux/sizes.h> #include <linux/sizes.h>
#include <linux/errno.h> #include <linux/types.h>
#include <dm.h>
#include <i2c.h> #include <i2c.h>
#include <fdtdec.h> #include <fdtdec.h>
@ -64,35 +63,27 @@ struct uniphier_fi2c_regs {
#define FIOCLK 50000000 #define FIOCLK 50000000
struct uniphier_fi2c_dev { struct uniphier_fi2c_priv {
struct udevice *dev;
struct uniphier_fi2c_regs __iomem *regs; /* register base */ struct uniphier_fi2c_regs __iomem *regs; /* register base */
unsigned long fioclk; /* internal operation clock */ unsigned long fioclk; /* internal operation clock */
unsigned long timeout; /* time out (us) */ unsigned long timeout; /* time out (us) */
}; };
static int reset_bus(struct uniphier_fi2c_regs __iomem *regs) static void uniphier_fi2c_reset(struct uniphier_fi2c_priv *priv)
{ {
u32 val; writel(I2C_RST_RST, &priv->regs->rst);
int ret;
/* bus forcible reset */
writel(I2C_RST_RST, &regs->rst);
ret = readl_poll_timeout(&regs->rst, val, !(val & I2C_RST_RST), 1);
if (ret < 0)
debug("error: fail to reset I2C controller\n");
return ret;
} }
static int check_device_busy(struct uniphier_fi2c_regs __iomem *regs) static int uniphier_fi2c_check_bus_busy(struct uniphier_fi2c_priv *priv)
{ {
u32 val; u32 val;
int ret; int ret;
ret = readl_poll_timeout(&regs->sr, val, !(val & I2C_SR_DB), 100); ret = readl_poll_timeout(&priv->regs->sr, val, !(val & I2C_SR_DB), 100);
if (ret < 0) { if (ret < 0) {
debug("error: device busy too long. reset...\n"); dev_dbg(priv->dev, "error: device busy too long. reset...\n");
ret = reset_bus(regs); uniphier_fi2c_reset(priv);
} }
return ret; return ret;
@ -101,8 +92,7 @@ static int check_device_busy(struct uniphier_fi2c_regs __iomem *regs)
static int uniphier_fi2c_probe(struct udevice *dev) static int uniphier_fi2c_probe(struct udevice *dev)
{ {
fdt_addr_t addr; fdt_addr_t addr;
struct uniphier_fi2c_dev *priv = dev_get_priv(dev); struct uniphier_fi2c_priv *priv = dev_get_priv(dev);
int ret;
addr = devfdt_get_addr(dev); addr = devfdt_get_addr(dev);
if (addr == FDT_ADDR_T_NONE) if (addr == FDT_ADDR_T_NONE)
@ -114,85 +104,85 @@ static int uniphier_fi2c_probe(struct udevice *dev)
priv->fioclk = FIOCLK; priv->fioclk = FIOCLK;
priv->dev = dev;
/* bus forcible reset */ /* bus forcible reset */
ret = reset_bus(priv->regs); uniphier_fi2c_reset(priv);
if (ret < 0)
return ret;
writel(I2C_BRST_FOEN | I2C_BRST_RSCLO, &priv->regs->brst); writel(I2C_BRST_FOEN | I2C_BRST_RSCLO, &priv->regs->brst);
return 0; return 0;
} }
static int wait_for_irq(struct uniphier_fi2c_dev *dev, u32 flags, static int wait_for_irq(struct uniphier_fi2c_priv *priv, u32 flags,
bool *stop) bool *stop)
{ {
u32 irq; u32 irq;
int ret; int ret;
ret = readl_poll_timeout(&dev->regs->intr, irq, irq & flags, ret = readl_poll_timeout(&priv->regs->intr, irq, irq & flags,
dev->timeout); priv->timeout);
if (ret < 0) { if (ret < 0) {
debug("error: time out\n"); dev_dbg(priv->dev, "error: time out\n");
return ret; return ret;
} }
if (irq & I2C_INT_AL) { if (irq & I2C_INT_AL) {
debug("error: arbitration lost\n"); dev_dbg(priv->dev, "error: arbitration lost\n");
*stop = false; *stop = false;
return ret; return ret;
} }
if (irq & I2C_INT_NA) { if (irq & I2C_INT_NA) {
debug("error: no answer\n"); dev_dbg(priv->dev, "error: no answer\n");
return ret; return ret;
} }
return 0; return 0;
} }
static int issue_stop(struct uniphier_fi2c_dev *dev, int old_ret) static int issue_stop(struct uniphier_fi2c_priv *priv, int old_ret)
{ {
int ret; int ret;
debug("stop condition\n"); dev_dbg(priv->dev, "stop condition\n");
writel(I2C_CR_MST | I2C_CR_STO, &dev->regs->cr); writel(I2C_CR_MST | I2C_CR_STO, &priv->regs->cr);
ret = check_device_busy(dev->regs); ret = uniphier_fi2c_check_bus_busy(priv);
if (ret < 0) if (ret < 0)
debug("error: device busy after operation\n"); dev_dbg(priv->dev, "error: device busy after operation\n");
return old_ret ? old_ret : ret; return old_ret ? old_ret : ret;
} }
static int uniphier_fi2c_transmit(struct uniphier_fi2c_dev *dev, uint addr, static int uniphier_fi2c_transmit(struct uniphier_fi2c_priv *priv, uint addr,
uint len, const u8 *buf, bool *stop) uint len, const u8 *buf, bool *stop)
{ {
int ret; int ret;
const u32 irq_flags = I2C_INT_TE | I2C_INT_NA | I2C_INT_AL; const u32 irq_flags = I2C_INT_TE | I2C_INT_NA | I2C_INT_AL;
struct uniphier_fi2c_regs __iomem *regs = dev->regs; struct uniphier_fi2c_regs __iomem *regs = priv->regs;
debug("%s: addr = %x, len = %d\n", __func__, addr, len); dev_dbg(priv->dev, "%s: addr = %x, len = %d\n", __func__, addr, len);
writel(I2C_DTTX_CMD | addr << 1, &regs->dttx); writel(I2C_DTTX_CMD | addr << 1, &regs->dttx);
writel(irq_flags, &regs->ie); writel(irq_flags, &regs->ie);
writel(irq_flags, &regs->ic); writel(irq_flags, &regs->ic);
debug("start condition\n"); dev_dbg(priv->dev, "start condition\n");
writel(I2C_CR_MST | I2C_CR_STA, &regs->cr); writel(I2C_CR_MST | I2C_CR_STA, &regs->cr);
ret = wait_for_irq(dev, irq_flags, stop); ret = wait_for_irq(priv, irq_flags, stop);
if (ret < 0) if (ret < 0)
goto error; goto error;
while (len--) { while (len--) {
debug("sending %x\n", *buf); dev_dbg(priv->dev, "sending %x\n", *buf);
writel(*buf++, &regs->dttx); writel(*buf++, &regs->dttx);
writel(irq_flags, &regs->ic); writel(irq_flags, &regs->ic);
ret = wait_for_irq(dev, irq_flags, stop); ret = wait_for_irq(priv, irq_flags, stop);
if (ret < 0) if (ret < 0)
goto error; goto error;
} }
@ -201,26 +191,26 @@ error:
writel(irq_flags, &regs->ic); writel(irq_flags, &regs->ic);
if (*stop) if (*stop)
ret = issue_stop(dev, ret); ret = issue_stop(priv, ret);
return ret; return ret;
} }
static int uniphier_fi2c_receive(struct uniphier_fi2c_dev *dev, uint addr, static int uniphier_fi2c_receive(struct uniphier_fi2c_priv *priv, uint addr,
uint len, u8 *buf, bool *stop) uint len, u8 *buf, bool *stop)
{ {
int ret = 0; int ret = 0;
const u32 irq_flags = I2C_INT_RB | I2C_INT_NA | I2C_INT_AL; const u32 irq_flags = I2C_INT_RB | I2C_INT_NA | I2C_INT_AL;
struct uniphier_fi2c_regs __iomem *regs = dev->regs; struct uniphier_fi2c_regs __iomem *regs = priv->regs;
debug("%s: addr = %x, len = %d\n", __func__, addr, len); dev_dbg(priv->dev, "%s: addr = %x, len = %d\n", __func__, addr, len);
/* /*
* In case 'len == 0', only the slave address should be sent * In case 'len == 0', only the slave address should be sent
* for probing, which is covered by the transmit function. * for probing, which is covered by the transmit function.
*/ */
if (len == 0) if (len == 0)
return uniphier_fi2c_transmit(dev, addr, len, buf, stop); return uniphier_fi2c_transmit(priv, addr, len, buf, stop);
writel(I2C_DTTX_CMD | I2C_DTTX_RD | addr << 1, &regs->dttx); writel(I2C_DTTX_CMD | I2C_DTTX_RD | addr << 1, &regs->dttx);
@ -228,17 +218,17 @@ static int uniphier_fi2c_receive(struct uniphier_fi2c_dev *dev, uint addr,
writel(irq_flags, &regs->ie); writel(irq_flags, &regs->ie);
writel(irq_flags, &regs->ic); writel(irq_flags, &regs->ic);
debug("start condition\n"); dev_dbg(priv->dev, "start condition\n");
writel(I2C_CR_MST | I2C_CR_STA | (len == 1 ? I2C_CR_NACK : 0), writel(I2C_CR_MST | I2C_CR_STA | (len == 1 ? I2C_CR_NACK : 0),
&regs->cr); &regs->cr);
while (len--) { while (len--) {
ret = wait_for_irq(dev, irq_flags, stop); ret = wait_for_irq(priv, irq_flags, stop);
if (ret < 0) if (ret < 0)
goto error; goto error;
*buf++ = readl(&regs->dtrx); *buf++ = readl(&regs->dtrx);
debug("received %x\n", *(buf - 1)); dev_dbg(priv->dev, "received %x\n", *(buf - 1));
if (len == 1) if (len == 1)
writel(I2C_CR_MST | I2C_CR_NACK, &regs->cr); writel(I2C_CR_MST | I2C_CR_NACK, &regs->cr);
@ -250,7 +240,7 @@ error:
writel(irq_flags, &regs->ic); writel(irq_flags, &regs->ic);
if (*stop) if (*stop)
ret = issue_stop(dev, ret); ret = issue_stop(priv, ret);
return ret; return ret;
} }
@ -259,10 +249,10 @@ static int uniphier_fi2c_xfer(struct udevice *bus, struct i2c_msg *msg,
int nmsgs) int nmsgs)
{ {
int ret; int ret;
struct uniphier_fi2c_dev *dev = dev_get_priv(bus); struct uniphier_fi2c_priv *priv = dev_get_priv(bus);
bool stop; bool stop;
ret = check_device_busy(dev->regs); ret = uniphier_fi2c_check_bus_busy(priv);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -271,10 +261,10 @@ static int uniphier_fi2c_xfer(struct udevice *bus, struct i2c_msg *msg,
stop = nmsgs > 1 && msg[1].flags & I2C_M_RD ? false : true; stop = nmsgs > 1 && msg[1].flags & I2C_M_RD ? false : true;
if (msg->flags & I2C_M_RD) if (msg->flags & I2C_M_RD)
ret = uniphier_fi2c_receive(dev, msg->addr, msg->len, ret = uniphier_fi2c_receive(priv, msg->addr, msg->len,
msg->buf, &stop); msg->buf, &stop);
else else
ret = uniphier_fi2c_transmit(dev, msg->addr, msg->len, ret = uniphier_fi2c_transmit(priv, msg->addr, msg->len,
msg->buf, &stop); msg->buf, &stop);
if (ret < 0) if (ret < 0)
@ -288,21 +278,21 @@ static int uniphier_fi2c_set_bus_speed(struct udevice *bus, unsigned int speed)
{ {
int ret; int ret;
unsigned int clk_count; unsigned int clk_count;
struct uniphier_fi2c_dev *dev = dev_get_priv(bus); struct uniphier_fi2c_priv *priv = dev_get_priv(bus);
struct uniphier_fi2c_regs __iomem *regs = dev->regs; struct uniphier_fi2c_regs __iomem *regs = priv->regs;
/* max supported frequency is 400 kHz */ /* max supported frequency is 400 kHz */
if (speed > 400000) if (speed > 400000)
return -EINVAL; return -EINVAL;
ret = check_device_busy(dev->regs); ret = uniphier_fi2c_check_bus_busy(priv);
if (ret < 0) if (ret < 0)
return ret; return ret;
/* make sure the bus is idle when changing the frequency */ /* make sure the bus is idle when changing the frequency */
writel(I2C_BRST_RSCLO, &regs->brst); writel(I2C_BRST_RSCLO, &regs->brst);
clk_count = dev->fioclk / speed; clk_count = priv->fioclk / speed;
writel(clk_count, &regs->cyc); writel(clk_count, &regs->cyc);
writel(clk_count / 2, &regs->lctl); writel(clk_count / 2, &regs->lctl);
@ -316,7 +306,7 @@ static int uniphier_fi2c_set_bus_speed(struct udevice *bus, unsigned int speed)
* 1000000 * 9 / speed usec. * 1000000 * 9 / speed usec.
* This time out value is long enough. * This time out value is long enough.
*/ */
dev->timeout = 100000000L / speed; priv->timeout = 100000000L / speed;
return 0; return 0;
} }
@ -336,6 +326,6 @@ U_BOOT_DRIVER(uniphier_fi2c) = {
.id = UCLASS_I2C, .id = UCLASS_I2C,
.of_match = uniphier_fi2c_of_match, .of_match = uniphier_fi2c_of_match,
.probe = uniphier_fi2c_probe, .probe = uniphier_fi2c_probe,
.priv_auto_alloc_size = sizeof(struct uniphier_fi2c_dev), .priv_auto_alloc_size = sizeof(struct uniphier_fi2c_priv),
.ops = &uniphier_fi2c_ops, .ops = &uniphier_fi2c_ops,
}; };