Changes since v3:
- Modify commit message for PATCH 1/3 pwm: mtk_disp: clear the clock operations
Changes since v1:
- Seperate clock operation as single patch.
- Seperate apply() as single patch.
- Seperate get_state() operation as single patch.
Rex-BC Chen (3):
pwm: mtk_disp: clear the clock operations
pwm: mtk_disp: convert the driver to atomic API
pwm: mtk_disp: implement .get_state()
drivers/pwm/pwm-mtk-disp.c | 179 +++++++++++++++++++++----------------
1 file changed, 104 insertions(+), 75 deletions(-)
--
2.18.0
Remove the clk_prepare from mtk_disp_pwm_probe.
Remove the clk_unprepare from mtk_disp_pwm_remove.
After using atomic API and get_state() function which are implemented in PATCH [2/3], [3/3],
clk_prepare/clk_unprepare are useless in probe/remove function.
So we remove clk_prepare/clk_unprepare in probe/remove fuinction.
Signed-off-by: Rex-BC Chen <[email protected]>
Signed-off-by: Jitao Shi <[email protected]>
---
drivers/pwm/pwm-mtk-disp.c | 23 ++---------------------
1 file changed, 2 insertions(+), 21 deletions(-)
diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
index 87c6b4bc5d43..21416a8b6b47 100644
--- a/drivers/pwm/pwm-mtk-disp.c
+++ b/drivers/pwm/pwm-mtk-disp.c
@@ -192,14 +192,6 @@ static int mtk_disp_pwm_probe(struct platform_device *pdev)
if (IS_ERR(mdp->clk_mm))
return PTR_ERR(mdp->clk_mm);
- ret = clk_prepare(mdp->clk_main);
- if (ret < 0)
- return ret;
-
- ret = clk_prepare(mdp->clk_mm);
- if (ret < 0)
- goto disable_clk_main;
-
mdp->chip.dev = &pdev->dev;
mdp->chip.ops = &mtk_disp_pwm_ops;
mdp->chip.base = -1;
@@ -208,7 +200,7 @@ static int mtk_disp_pwm_probe(struct platform_device *pdev)
ret = pwmchip_add(&mdp->chip);
if (ret < 0) {
dev_err(&pdev->dev, "pwmchip_add() failed: %d\n", ret);
- goto disable_clk_mm;
+ return ret;
}
platform_set_drvdata(pdev, mdp);
@@ -227,24 +219,13 @@ static int mtk_disp_pwm_probe(struct platform_device *pdev)
}
return 0;
-
-disable_clk_mm:
- clk_unprepare(mdp->clk_mm);
-disable_clk_main:
- clk_unprepare(mdp->clk_main);
- return ret;
}
static int mtk_disp_pwm_remove(struct platform_device *pdev)
{
struct mtk_disp_pwm *mdp = platform_get_drvdata(pdev);
- int ret;
-
- ret = pwmchip_remove(&mdp->chip);
- clk_unprepare(mdp->clk_mm);
- clk_unprepare(mdp->clk_main);
- return ret;
+ return pwmchip_remove(&mdp->chip);
}
static const struct mtk_pwm_data mt2701_pwm_data = {
--
2.18.0
implement get_state function for pwm-mtk-disp
Signed-off-by: Rex-BC Chen <[email protected]>
Signed-off-by: Jitao Shi <[email protected]>
---
drivers/pwm/pwm-mtk-disp.c | 46 ++++++++++++++++++++++++++++++++++++++
1 file changed, 46 insertions(+)
diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
index 502228adf718..166e0a8ca703 100644
--- a/drivers/pwm/pwm-mtk-disp.c
+++ b/drivers/pwm/pwm-mtk-disp.c
@@ -179,8 +179,54 @@ static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
return mtk_disp_pwm_enable(chip, state);
}
+static void mtk_disp_pwm_get_state(struct pwm_chip *chip,
+ struct pwm_device *pwm,
+ struct pwm_state *state)
+{
+ struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
+ u32 clk_div, period, high_width, con0, con1;
+ u64 rate;
+ int err;
+
+ err = clk_prepare_enable(mdp->clk_main);
+ if (err < 0) {
+ dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n", err);
+ return;
+ }
+ err = clk_prepare_enable(mdp->clk_mm);
+ if (err < 0) {
+ dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n", err);
+ clk_disable_unprepare(mdp->clk_main);
+ return;
+ }
+
+ rate = clk_get_rate(mdp->clk_main);
+
+ con0 = readl(mdp->base + mdp->data->con0);
+ con1 = readl(mdp->base + mdp->data->con1);
+
+ state->polarity = con0 & PWM_POLARITY ?
+ PWM_POLARITY_INVERSED : PWM_POLARITY_NORMAL;
+ state->enabled = !!(con0 & BIT(0));
+
+ clk_div = (con0 & PWM_CLKDIV_MASK) >> PWM_CLKDIV_SHIFT;
+ period = con1 & PWM_PERIOD_MASK;
+ state->period = div_u64(period * (clk_div + 1) * NSEC_PER_SEC, rate);
+ high_width = (con1 & PWM_HIGH_WIDTH_MASK) >> PWM_HIGH_WIDTH_SHIFT;
+ state->duty_cycle = div_u64(high_width * (clk_div + 1) * NSEC_PER_SEC,
+ rate);
+
+ if (!state->enabled) {
+ clk_disable_unprepare(mdp->clk_mm);
+ clk_disable_unprepare(mdp->clk_main);
+ }
+
+ mdp->enabled = state->enabled;
+}
+
static const struct pwm_ops mtk_disp_pwm_ops = {
.apply = mtk_disp_pwm_apply,
+ .get_state = mtk_disp_pwm_get_state,
.owner = THIS_MODULE,
};
--
2.18.0
Switch the driver to atomic API apply().
Signed-off-by: Rex-BC Chen <[email protected]>
Signed-off-by: Jitao Shi <[email protected]>
---
drivers/pwm/pwm-mtk-disp.c | 114 +++++++++++++++++++------------------
1 file changed, 58 insertions(+), 56 deletions(-)
diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
index 21416a8b6b47..502228adf718 100644
--- a/drivers/pwm/pwm-mtk-disp.c
+++ b/drivers/pwm/pwm-mtk-disp.c
@@ -20,6 +20,7 @@
#define PWM_CLKDIV_SHIFT 16
#define PWM_CLKDIV_MAX 0x3ff
#define PWM_CLKDIV_MASK (PWM_CLKDIV_MAX << PWM_CLKDIV_SHIFT)
+#define PWM_POLARITY BIT(2)
#define PWM_PERIOD_BIT_WIDTH 12
#define PWM_PERIOD_MASK ((1 << PWM_PERIOD_BIT_WIDTH) - 1)
@@ -47,6 +48,7 @@ struct mtk_disp_pwm {
struct clk *clk_main;
struct clk *clk_mm;
void __iomem *base;
+ bool enabled;
};
static inline struct mtk_disp_pwm *to_mtk_disp_pwm(struct pwm_chip *chip)
@@ -66,11 +68,11 @@ static void mtk_disp_pwm_update_bits(struct mtk_disp_pwm *mdp, u32 offset,
writel(value, address);
}
-static int mtk_disp_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
- int duty_ns, int period_ns)
+static int mtk_disp_pwm_enable(struct pwm_chip *chip,
+ const struct pwm_state *state)
{
struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
- u32 clk_div, period, high_width, value;
+ u32 clk_div, period, high_width, value, polarity;
u64 div, rate;
int err;
@@ -84,33 +86,47 @@ static int mtk_disp_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
* period = (PWM_CLK_RATE * period_ns) / (10^9 * (clk_div + 1)) - 1
* high_width = (PWM_CLK_RATE * duty_ns) / (10^9 * (clk_div + 1))
*/
+ if (!mdp->enabled) {
+ err = clk_prepare_enable(mdp->clk_main);
+ if (err < 0) {
+ dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n",
+ err);
+ return err;
+ }
+ err = clk_prepare_enable(mdp->clk_mm);
+ if (err < 0) {
+ dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n",
+ err);
+ clk_disable_unprepare(mdp->clk_main);
+ return err;
+ }
+ }
rate = clk_get_rate(mdp->clk_main);
- clk_div = div_u64(rate * period_ns, NSEC_PER_SEC) >>
+ clk_div = div_u64(rate * state->period, NSEC_PER_SEC) >>
PWM_PERIOD_BIT_WIDTH;
- if (clk_div > PWM_CLKDIV_MAX)
+ if (clk_div > PWM_CLKDIV_MAX) {
+ dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
+ rate);
+ clk_disable_unprepare(mdp->clk_mm);
+ clk_disable_unprepare(mdp->clk_main);
return -EINVAL;
-
+ }
div = NSEC_PER_SEC * (clk_div + 1);
- period = div64_u64(rate * period_ns, div);
+ period = div64_u64(rate * state->period, div);
if (period > 0)
period--;
- high_width = div64_u64(rate * duty_ns, div);
+ high_width = div64_u64(rate * state->duty_cycle, div);
value = period | (high_width << PWM_HIGH_WIDTH_SHIFT);
-
- err = clk_enable(mdp->clk_main);
- if (err < 0)
- return err;
-
- err = clk_enable(mdp->clk_mm);
- if (err < 0) {
- clk_disable(mdp->clk_main);
- return err;
- }
+ polarity = 0;
+ if (state->polarity == PWM_POLARITY_INVERSED)
+ polarity = PWM_POLARITY;
mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
PWM_CLKDIV_MASK,
clk_div << PWM_CLKDIV_SHIFT);
+ mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
+ PWM_POLARITY, polarity);
mtk_disp_pwm_update_bits(mdp, mdp->data->con1,
PWM_PERIOD_MASK | PWM_HIGH_WIDTH_MASK,
value);
@@ -122,50 +138,49 @@ static int mtk_disp_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
mtk_disp_pwm_update_bits(mdp, mdp->data->commit,
mdp->data->commit_mask,
0x0);
+ } else {
+ mtk_disp_pwm_update_bits(mdp, mdp->data->bls_debug,
+ mdp->data->bls_debug_mask,
+ mdp->data->bls_debug_mask);
+ mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
+ mdp->data->con0_sel,
+ mdp->data->con0_sel);
}
- clk_disable(mdp->clk_mm);
- clk_disable(mdp->clk_main);
-
+ mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
+ mdp->data->enable_mask);
+ mdp->enabled = true;
return 0;
}
-static int mtk_disp_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
+static int mtk_disp_pwm_disable(struct pwm_chip *chip,
+ const struct pwm_state *state)
{
struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
- int err;
-
- err = clk_enable(mdp->clk_main);
- if (err < 0)
- return err;
- err = clk_enable(mdp->clk_mm);
- if (err < 0) {
- clk_disable(mdp->clk_main);
- return err;
+ mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
+ 0x0);
+ if (mdp->enabled) {
+ clk_disable_unprepare(mdp->clk_mm);
+ clk_disable_unprepare(mdp->clk_main);
}
- mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
- mdp->data->enable_mask);
+ mdp->enabled = false;
return 0;
}
-static void mtk_disp_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
+static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
+ const struct pwm_state *state)
{
- struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
+ if (!state->enabled)
+ return mtk_disp_pwm_disable(chip, state);
- mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
- 0x0);
-
- clk_disable(mdp->clk_mm);
- clk_disable(mdp->clk_main);
+ return mtk_disp_pwm_enable(chip, state);
}
static const struct pwm_ops mtk_disp_pwm_ops = {
- .config = mtk_disp_pwm_config,
- .enable = mtk_disp_pwm_enable,
- .disable = mtk_disp_pwm_disable,
+ .apply = mtk_disp_pwm_apply,
.owner = THIS_MODULE,
};
@@ -205,19 +220,6 @@ static int mtk_disp_pwm_probe(struct platform_device *pdev)
platform_set_drvdata(pdev, mdp);
- /*
- * For MT2701, disable double buffer before writing register
- * and select manual mode and use PWM_PERIOD/PWM_HIGH_WIDTH.
- */
- if (!mdp->data->has_commit) {
- mtk_disp_pwm_update_bits(mdp, mdp->data->bls_debug,
- mdp->data->bls_debug_mask,
- mdp->data->bls_debug_mask);
- mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
- mdp->data->con0_sel,
- mdp->data->con0_sel);
- }
-
return 0;
}
--
2.18.0
On Tue, Apr 06, 2021 at 05:57:42PM +0800, Rex-BC Chen wrote:
> implement get_state function for pwm-mtk-disp
>
> Signed-off-by: Rex-BC Chen <[email protected]>
> Signed-off-by: Jitao Shi <[email protected]>
Ideally you S-o-b line is the last one to show the order in which this
patch went from one person to another.
> ---
> drivers/pwm/pwm-mtk-disp.c | 46 ++++++++++++++++++++++++++++++++++++++
> 1 file changed, 46 insertions(+)
>
> diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
> index 502228adf718..166e0a8ca703 100644
> --- a/drivers/pwm/pwm-mtk-disp.c
> +++ b/drivers/pwm/pwm-mtk-disp.c
> @@ -179,8 +179,54 @@ static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
> return mtk_disp_pwm_enable(chip, state);
> }
>
> +static void mtk_disp_pwm_get_state(struct pwm_chip *chip,
> + struct pwm_device *pwm,
> + struct pwm_state *state)
> +{
> + struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
> + u32 clk_div, period, high_width, con0, con1;
> + u64 rate;
> + int err;
> +
> + err = clk_prepare_enable(mdp->clk_main);
> + if (err < 0) {
> + dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n", err);
> + return;
> + }
> + err = clk_prepare_enable(mdp->clk_mm);
> + if (err < 0) {
> + dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n", err);
> + clk_disable_unprepare(mdp->clk_main);
As before: %pe please
> + return;
> + }
> +
> + rate = clk_get_rate(mdp->clk_main);
> +
> + con0 = readl(mdp->base + mdp->data->con0);
> + con1 = readl(mdp->base + mdp->data->con1);
> +
> + state->polarity = con0 & PWM_POLARITY ?
> + PWM_POLARITY_INVERSED : PWM_POLARITY_NORMAL;
> + state->enabled = !!(con0 & BIT(0));
> +
> + clk_div = (con0 & PWM_CLKDIV_MASK) >> PWM_CLKDIV_SHIFT;
> + period = con1 & PWM_PERIOD_MASK;
> + state->period = div_u64(period * (clk_div + 1) * NSEC_PER_SEC, rate);
> + high_width = (con1 & PWM_HIGH_WIDTH_MASK) >> PWM_HIGH_WIDTH_SHIFT;
> + state->duty_cycle = div_u64(high_width * (clk_div + 1) * NSEC_PER_SEC,
> + rate);
Please round up these divisions as in .apply() we're rounding down.
Otherwise .get_state isn't the inverse of .apply().
> +
> + if (!state->enabled) {
> + clk_disable_unprepare(mdp->clk_mm);
> + clk_disable_unprepare(mdp->clk_main);
That's wrong, you enabled unconditionally so you should also disable
unconditionally. If you want to prevent that clocks of a running PWM are
disabled by the unused clk initcall, this must be done in .probe() to be
sure it runs exactly once and early enough.
> + }
> +
> + mdp->enabled = state->enabled;
> +}
> +
Best regards
Uwe
--
Pengutronix e.K. | Uwe Kleine-K?nig |
Industrial Linux Solutions | https://www.pengutronix.de/ |
Hi Rex-BC,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on v5.12-rc6]
[also build test WARNING on next-20210406]
[cannot apply to pwm/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Rex-BC-Chen/Convert-the-mtk_disp-driver-to-aotmic-API/20210406-180018
base: e49d033bddf5b565044e2abe4241353959bc9120
config: powerpc64-randconfig-r023-20210406 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project a46f59a747a7273cc439efaf3b4f98d8b63d2f20)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# install powerpc64 cross compiling tool for clang build
# apt-get install binutils-powerpc64-linux-gnu
# https://github.com/0day-ci/linux/commit/0a2486ac437e3b8d36a0bf8ce9648c22e42ffda4
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Rex-BC-Chen/Convert-the-mtk_disp-driver-to-aotmic-API/20210406-180018
git checkout 0a2486ac437e3b8d36a0bf8ce9648c22e42ffda4
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=powerpc64
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <[email protected]>
All warnings (new ones prefixed by >>):
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:155:1: note: expanded from here
__do_outl
^
arch/powerpc/include/asm/io.h:537:62: note: expanded from macro '__do_outl'
#define __do_outl(val, port) writel(val,(PCI_IO_ADDR)_IO_BASE+port);
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:43:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(insb, (unsigned long p, void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:169:1: note: expanded from here
__do_insb
^
arch/powerpc/include/asm/io.h:556:56: note: expanded from macro '__do_insb'
#define __do_insb(p, b, n) readsb((PCI_IO_ADDR)_IO_BASE+(p), (b), (n))
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:45:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(insw, (unsigned long p, void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:171:1: note: expanded from here
__do_insw
^
arch/powerpc/include/asm/io.h:557:56: note: expanded from macro '__do_insw'
#define __do_insw(p, b, n) readsw((PCI_IO_ADDR)_IO_BASE+(p), (b), (n))
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:47:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(insl, (unsigned long p, void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:173:1: note: expanded from here
__do_insl
^
arch/powerpc/include/asm/io.h:558:56: note: expanded from macro '__do_insl'
#define __do_insl(p, b, n) readsl((PCI_IO_ADDR)_IO_BASE+(p), (b), (n))
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:49:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(outsb, (unsigned long p, const void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:175:1: note: expanded from here
__do_outsb
^
arch/powerpc/include/asm/io.h:559:58: note: expanded from macro '__do_outsb'
#define __do_outsb(p, b, n) writesb((PCI_IO_ADDR)_IO_BASE+(p),(b),(n))
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:51:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(outsw, (unsigned long p, const void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:177:1: note: expanded from here
__do_outsw
^
arch/powerpc/include/asm/io.h:560:58: note: expanded from macro '__do_outsw'
#define __do_outsw(p, b, n) writesw((PCI_IO_ADDR)_IO_BASE+(p),(b),(n))
~~~~~~~~~~~~~~~~~~~~~^
In file included from drivers/pwm/pwm-mtk-disp.c:10:
In file included from include/linux/io.h:13:
In file included from arch/powerpc/include/asm/io.h:619:
arch/powerpc/include/asm/io-defs.h:53:1: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
DEF_PCI_AC_NORET(outsl, (unsigned long p, const void *b, unsigned long c),
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
arch/powerpc/include/asm/io.h:616:3: note: expanded from macro 'DEF_PCI_AC_NORET'
__do_##name al; \
^~~~~~~~~~~~~~
<scratch space>:179:1: note: expanded from here
__do_outsl
^
arch/powerpc/include/asm/io.h:561:58: note: expanded from macro '__do_outsl'
#define __do_outsl(p, b, n) writesl((PCI_IO_ADDR)_IO_BASE+(p),(b),(n))
~~~~~~~~~~~~~~~~~~~~~^
>> drivers/pwm/pwm-mtk-disp.c:109:4: warning: format specifies type 'int' but the argument has type 'u64' (aka 'unsigned long long') [-Wformat]
rate);
^~~~
include/linux/dev_printk.h:112:32: note: expanded from macro 'dev_err'
_dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
~~~ ^~~~~~~~~~~
13 warnings generated.
vim +109 drivers/pwm/pwm-mtk-disp.c
70
71 static int mtk_disp_pwm_enable(struct pwm_chip *chip,
72 const struct pwm_state *state)
73 {
74 struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
75 u32 clk_div, period, high_width, value, polarity;
76 u64 div, rate;
77 int err;
78
79 /*
80 * Find period, high_width and clk_div to suit duty_ns and period_ns.
81 * Calculate proper div value to keep period value in the bound.
82 *
83 * period_ns = 10^9 * (clk_div + 1) * (period + 1) / PWM_CLK_RATE
84 * duty_ns = 10^9 * (clk_div + 1) * high_width / PWM_CLK_RATE
85 *
86 * period = (PWM_CLK_RATE * period_ns) / (10^9 * (clk_div + 1)) - 1
87 * high_width = (PWM_CLK_RATE * duty_ns) / (10^9 * (clk_div + 1))
88 */
89 if (!mdp->enabled) {
90 err = clk_prepare_enable(mdp->clk_main);
91 if (err < 0) {
92 dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n",
93 err);
94 return err;
95 }
96 err = clk_prepare_enable(mdp->clk_mm);
97 if (err < 0) {
98 dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n",
99 err);
100 clk_disable_unprepare(mdp->clk_main);
101 return err;
102 }
103 }
104 rate = clk_get_rate(mdp->clk_main);
105 clk_div = div_u64(rate * state->period, NSEC_PER_SEC) >>
106 PWM_PERIOD_BIT_WIDTH;
107 if (clk_div > PWM_CLKDIV_MAX) {
108 dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
> 109 rate);
110 clk_disable_unprepare(mdp->clk_mm);
111 clk_disable_unprepare(mdp->clk_main);
112 return -EINVAL;
113 }
114 div = NSEC_PER_SEC * (clk_div + 1);
115 period = div64_u64(rate * state->period, div);
116 if (period > 0)
117 period--;
118
119 high_width = div64_u64(rate * state->duty_cycle, div);
120 value = period | (high_width << PWM_HIGH_WIDTH_SHIFT);
121 polarity = 0;
122 if (state->polarity == PWM_POLARITY_INVERSED)
123 polarity = PWM_POLARITY;
124
125 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
126 PWM_CLKDIV_MASK,
127 clk_div << PWM_CLKDIV_SHIFT);
128 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
129 PWM_POLARITY, polarity);
130 mtk_disp_pwm_update_bits(mdp, mdp->data->con1,
131 PWM_PERIOD_MASK | PWM_HIGH_WIDTH_MASK,
132 value);
133
134 if (mdp->data->has_commit) {
135 mtk_disp_pwm_update_bits(mdp, mdp->data->commit,
136 mdp->data->commit_mask,
137 mdp->data->commit_mask);
138 mtk_disp_pwm_update_bits(mdp, mdp->data->commit,
139 mdp->data->commit_mask,
140 0x0);
141 } else {
142 mtk_disp_pwm_update_bits(mdp, mdp->data->bls_debug,
143 mdp->data->bls_debug_mask,
144 mdp->data->bls_debug_mask);
145 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
146 mdp->data->con0_sel,
147 mdp->data->con0_sel);
148 }
149
150 mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
151 mdp->data->enable_mask);
152 mdp->enabled = true;
153 return 0;
154 }
155
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
Hi Rex-BC,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on v5.12-rc6]
[also build test WARNING on next-20210401]
[cannot apply to pwm/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Rex-BC-Chen/Convert-the-mtk_disp-driver-to-aotmic-API/20210406-180018
base: e49d033bddf5b565044e2abe4241353959bc9120
config: xtensa-allyesconfig (attached as .config)
compiler: xtensa-linux-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/0a2486ac437e3b8d36a0bf8ce9648c22e42ffda4
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Rex-BC-Chen/Convert-the-mtk_disp-driver-to-aotmic-API/20210406-180018
git checkout 0a2486ac437e3b8d36a0bf8ce9648c22e42ffda4
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=xtensa
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <[email protected]>
All warnings (new ones prefixed by >>):
In file included from include/linux/device.h:15,
from include/linux/node.h:18,
from include/linux/cpu.h:17,
from include/linux/of_device.h:5,
from drivers/pwm/pwm-mtk-disp.c:13:
drivers/pwm/pwm-mtk-disp.c: In function 'mtk_disp_pwm_enable':
>> drivers/pwm/pwm-mtk-disp.c:108:22: warning: format '%d' expects argument of type 'int', but argument 3 has type 'u64' {aka 'long long unsigned int'} [-Wformat=]
108 | dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
include/linux/dev_printk.h:19:22: note: in definition of macro 'dev_fmt'
19 | #define dev_fmt(fmt) fmt
| ^~~
drivers/pwm/pwm-mtk-disp.c:108:3: note: in expansion of macro 'dev_err'
108 | dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
| ^~~~~~~
drivers/pwm/pwm-mtk-disp.c:108:55: note: format string is defined here
108 | dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
| ~^
| |
| int
| %lld
vim +108 drivers/pwm/pwm-mtk-disp.c
70
71 static int mtk_disp_pwm_enable(struct pwm_chip *chip,
72 const struct pwm_state *state)
73 {
74 struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
75 u32 clk_div, period, high_width, value, polarity;
76 u64 div, rate;
77 int err;
78
79 /*
80 * Find period, high_width and clk_div to suit duty_ns and period_ns.
81 * Calculate proper div value to keep period value in the bound.
82 *
83 * period_ns = 10^9 * (clk_div + 1) * (period + 1) / PWM_CLK_RATE
84 * duty_ns = 10^9 * (clk_div + 1) * high_width / PWM_CLK_RATE
85 *
86 * period = (PWM_CLK_RATE * period_ns) / (10^9 * (clk_div + 1)) - 1
87 * high_width = (PWM_CLK_RATE * duty_ns) / (10^9 * (clk_div + 1))
88 */
89 if (!mdp->enabled) {
90 err = clk_prepare_enable(mdp->clk_main);
91 if (err < 0) {
92 dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n",
93 err);
94 return err;
95 }
96 err = clk_prepare_enable(mdp->clk_mm);
97 if (err < 0) {
98 dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n",
99 err);
100 clk_disable_unprepare(mdp->clk_main);
101 return err;
102 }
103 }
104 rate = clk_get_rate(mdp->clk_main);
105 clk_div = div_u64(rate * state->period, NSEC_PER_SEC) >>
106 PWM_PERIOD_BIT_WIDTH;
107 if (clk_div > PWM_CLKDIV_MAX) {
> 108 dev_err(chip->dev, "clock rate is too high: rate = %d Hz\n",
109 rate);
110 clk_disable_unprepare(mdp->clk_mm);
111 clk_disable_unprepare(mdp->clk_main);
112 return -EINVAL;
113 }
114 div = NSEC_PER_SEC * (clk_div + 1);
115 period = div64_u64(rate * state->period, div);
116 if (period > 0)
117 period--;
118
119 high_width = div64_u64(rate * state->duty_cycle, div);
120 value = period | (high_width << PWM_HIGH_WIDTH_SHIFT);
121 polarity = 0;
122 if (state->polarity == PWM_POLARITY_INVERSED)
123 polarity = PWM_POLARITY;
124
125 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
126 PWM_CLKDIV_MASK,
127 clk_div << PWM_CLKDIV_SHIFT);
128 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
129 PWM_POLARITY, polarity);
130 mtk_disp_pwm_update_bits(mdp, mdp->data->con1,
131 PWM_PERIOD_MASK | PWM_HIGH_WIDTH_MASK,
132 value);
133
134 if (mdp->data->has_commit) {
135 mtk_disp_pwm_update_bits(mdp, mdp->data->commit,
136 mdp->data->commit_mask,
137 mdp->data->commit_mask);
138 mtk_disp_pwm_update_bits(mdp, mdp->data->commit,
139 mdp->data->commit_mask,
140 0x0);
141 } else {
142 mtk_disp_pwm_update_bits(mdp, mdp->data->bls_debug,
143 mdp->data->bls_debug_mask,
144 mdp->data->bls_debug_mask);
145 mtk_disp_pwm_update_bits(mdp, mdp->data->con0,
146 mdp->data->con0_sel,
147 mdp->data->con0_sel);
148 }
149
150 mtk_disp_pwm_update_bits(mdp, DISP_PWM_EN, mdp->data->enable_mask,
151 mdp->data->enable_mask);
152 mdp->enabled = true;
153 return 0;
154 }
155
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
On Tue, Apr 06, 2021 at 12:27:56PM +0200, Uwe Kleine-König wrote:
> On Tue, Apr 06, 2021 at 05:57:42PM +0800, Rex-BC Chen wrote:
> > implement get_state function for pwm-mtk-disp
> >
> > Signed-off-by: Rex-BC Chen <[email protected]>
> > Signed-off-by: Jitao Shi <[email protected]>
>
> Ideally you S-o-b line is the last one to show the order in which this
> patch went from one person to another.
>
> > ---
> > drivers/pwm/pwm-mtk-disp.c | 46 ++++++++++++++++++++++++++++++++++++++
> > 1 file changed, 46 insertions(+)
> >
> > diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
> > index 502228adf718..166e0a8ca703 100644
> > --- a/drivers/pwm/pwm-mtk-disp.c
> > +++ b/drivers/pwm/pwm-mtk-disp.c
> > @@ -179,8 +179,54 @@ static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
> > return mtk_disp_pwm_enable(chip, state);
> > }
> >
> > +static void mtk_disp_pwm_get_state(struct pwm_chip *chip,
> > + struct pwm_device *pwm,
> > + struct pwm_state *state)
> > +{
> > + struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
> > + u32 clk_div, period, high_width, con0, con1;
> > + u64 rate;
> > + int err;
> > +
> > + err = clk_prepare_enable(mdp->clk_main);
> > + if (err < 0) {
> > + dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n", err);
> > + return;
> > + }
> > + err = clk_prepare_enable(mdp->clk_mm);
> > + if (err < 0) {
> > + dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n", err);
> > + clk_disable_unprepare(mdp->clk_main);
>
> As before: %pe please
According to the documentation %pe only works on pointers for which
IS_ERR() is true, so I'm not sure it can be used with plain integer
error codes.
Looks like there's a bunch of drivers that will do %pe and then use
ERR_PTR(err) to make this work, but to be honest, that seems like
jumping through hoops.
But I don't feel strongly either way, so choose whichever you want.
Thierry
On Fri, Apr 09, 2021 at 02:24:43PM +0200, Thierry Reding wrote:
> On Tue, Apr 06, 2021 at 12:27:56PM +0200, Uwe Kleine-K?nig wrote:
> > On Tue, Apr 06, 2021 at 05:57:42PM +0800, Rex-BC Chen wrote:
> > > implement get_state function for pwm-mtk-disp
> > >
> > > Signed-off-by: Rex-BC Chen <[email protected]>
> > > Signed-off-by: Jitao Shi <[email protected]>
> >
> > Ideally you S-o-b line is the last one to show the order in which this
> > patch went from one person to another.
> >
> > > ---
> > > drivers/pwm/pwm-mtk-disp.c | 46 ++++++++++++++++++++++++++++++++++++++
> > > 1 file changed, 46 insertions(+)
> > >
> > > diff --git a/drivers/pwm/pwm-mtk-disp.c b/drivers/pwm/pwm-mtk-disp.c
> > > index 502228adf718..166e0a8ca703 100644
> > > --- a/drivers/pwm/pwm-mtk-disp.c
> > > +++ b/drivers/pwm/pwm-mtk-disp.c
> > > @@ -179,8 +179,54 @@ static int mtk_disp_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
> > > return mtk_disp_pwm_enable(chip, state);
> > > }
> > >
> > > +static void mtk_disp_pwm_get_state(struct pwm_chip *chip,
> > > + struct pwm_device *pwm,
> > > + struct pwm_state *state)
> > > +{
> > > + struct mtk_disp_pwm *mdp = to_mtk_disp_pwm(chip);
> > > + u32 clk_div, period, high_width, con0, con1;
> > > + u64 rate;
> > > + int err;
> > > +
> > > + err = clk_prepare_enable(mdp->clk_main);
> > > + if (err < 0) {
> > > + dev_err(chip->dev, "Can't enable mdp->clk_main: %d\n", err);
> > > + return;
> > > + }
> > > + err = clk_prepare_enable(mdp->clk_mm);
> > > + if (err < 0) {
> > > + dev_err(chip->dev, "Can't enable mdp->clk_mm: %d\n", err);
> > > + clk_disable_unprepare(mdp->clk_main);
> >
> > As before: %pe please
>
> According to the documentation %pe only works on pointers for which
> IS_ERR() is true, so I'm not sure it can be used with plain integer
> error codes.
It cannot.
> Looks like there's a bunch of drivers that will do %pe and then use
> ERR_PTR(err) to make this work, but to be honest, that seems like
> jumping through hoops.
When I suggested to implement %dE to print error codes this was shot
down by the printk guys who's position is that %pe has to be good enough
for everybody. And yes, you'd need to pass ERR_PTR(err) then.
Best regards
Uwe
--
Pengutronix e.K. | Uwe Kleine-K?nig |
Industrial Linux Solutions | https://www.pengutronix.de/ |