target/linux/mediatek/patches-4.14/0118-soc-mediatek-pwrap-add-pwrap_write32-for-writing-in-.patch

   1 From 635f800995e4ea2a18ce7520d816dab018ce091f Mon Sep 17 00:00:00 2001
   2 From: Sean Wang <sean.wang@mediatek.com>
   3 Date: Wed, 18 Oct 2017 16:28:44 +0800
   4 Subject: [PATCH 118/224] soc: mediatek: pwrap: add pwrap_write32 for writing
   5  in 32-bit mode
   6
   7 Some regulators such as MediaTek MT6380 also has to be written in
   8 32-bit mode. So the patch adds pwrap_write32, rename old pwrap_write
   9 into pwrap_write16 and one additional function pointer is introduced
  10 for increasing flexibility allowing the determination which mode is
  11 used by the pwrap slave detection through device tree.
  12
  13 Signed-off-by: Chenglin Xu <chenglin.xu@mediatek.com>
  14 Signed-off-by: Chen Zhong <chen.zhong@mediatek.com>
  15 Signed-off-by: Sean Wang <sean.wang@mediatek.com>
  16 Signed-off-by: Matthias Brugger <matthias.bgg@gmail.com>
  17 ---
  18  drivers/soc/mediatek/mtk-pmic-wrap.c | 70 +++++++++++++++++++++++++++---------
  19  1 file changed, 54 insertions(+), 16 deletions(-)
  20
  21 diff --git a/drivers/soc/mediatek/mtk-pmic-wrap.c b/drivers/soc/mediatek/mtk-pmic-wrap.c
  22 index 06930e2ebe4c..2d3a8faae124 100644
  23 --- a/drivers/soc/mediatek/mtk-pmic-wrap.c
  24 +++ b/drivers/soc/mediatek/mtk-pmic-wrap.c
  25 @@ -507,6 +507,7 @@ struct pwrap_slv_type {
  26          * which type is used by the detection through device tree.
  27          */
  28         int (*pwrap_read)(struct pmic_wrapper *wrp, u32 adr, u32 *rdata);
  29 +       int (*pwrap_write)(struct pmic_wrapper *wrp, u32 adr, u32 wdata);
  30  };
  31
  32  struct pmic_wrapper {
  33 @@ -601,22 +602,6 @@ static int pwrap_wait_for_state(struct pmic_wrapper *wrp,
  34         } while (1);
  35  }
  36
  37 -static int pwrap_write(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
  38 -{
  39 -       int ret;
  40 -
  41 -       ret = pwrap_wait_for_state(wrp, pwrap_is_fsm_idle);
  42 -       if (ret) {
  43 -               pwrap_leave_fsm_vldclr(wrp);
  44 -               return ret;
  45 -       }
  46 -
  47 -       pwrap_writel(wrp, (1 << 31) | ((adr >> 1) << 16) | wdata,
  48 -                       PWRAP_WACS2_CMD);
  49 -
  50 -       return 0;
  51 -}
  52 -
  53  static int pwrap_read16(struct pmic_wrapper *wrp, u32 adr, u32 *rdata)
  54  {
  55         int ret;
  56 @@ -673,6 +658,56 @@ static int pwrap_read(struct pmic_wrapper *wrp, u32 adr, u32 *rdata)
  57         return wrp->slave->pwrap_read(wrp, adr, rdata);
  58  }
  59
  60 +static int pwrap_write16(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
  61 +{
  62 +       int ret;
  63 +
  64 +       ret = pwrap_wait_for_state(wrp, pwrap_is_fsm_idle);
  65 +       if (ret) {
  66 +               pwrap_leave_fsm_vldclr(wrp);
  67 +               return ret;
  68 +       }
  69 +
  70 +       pwrap_writel(wrp, (1 << 31) | ((adr >> 1) << 16) | wdata,
  71 +                    PWRAP_WACS2_CMD);
  72 +
  73 +       return 0;
  74 +}
  75 +
  76 +static int pwrap_write32(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
  77 +{
  78 +       int ret, msb, rdata;
  79 +
  80 +       for (msb = 0; msb < 2; msb++) {
  81 +               ret = pwrap_wait_for_state(wrp, pwrap_is_fsm_idle);
  82 +               if (ret) {
  83 +                       pwrap_leave_fsm_vldclr(wrp);
  84 +                       return ret;
  85 +               }
  86 +
  87 +               pwrap_writel(wrp, (1 << 31) | (msb << 30) | (adr << 16) |
  88 +                            ((wdata >> (msb * 16)) & 0xffff),
  89 +                            PWRAP_WACS2_CMD);
  90 +
  91 +               /*
  92 +                * The pwrap_read operation is the requirement of hardware used
  93 +                * for the synchronization between two successive 16-bit
  94 +                * pwrap_writel operations composing one 32-bit bus writing.
  95 +                * Otherwise, we'll find the result fails on the lower 16-bit
  96 +                * pwrap writing.
  97 +                */
  98 +               if (!msb)
  99 +                       pwrap_read(wrp, adr, &rdata);
 100 +       }
 101 +
 102 +       return 0;
 103 +}
 104 +
 105 +static int pwrap_write(struct pmic_wrapper *wrp, u32 adr, u32 wdata)
 106 +{
 107 +       return wrp->slave->pwrap_write(wrp, adr, wdata);
 108 +}
 109 +
 110  static int pwrap_regmap_read(void *context, u32 adr, u32 *rdata)
 111  {
 112         return pwrap_read(context, adr, rdata);
 113 @@ -1082,18 +1117,21 @@ static const struct pwrap_slv_type pmic_mt6323 = {
 114         .dew_regs = mt6323_regs,
 115         .type = PMIC_MT6323,
 116         .pwrap_read = pwrap_read16,
 117 +       .pwrap_write = pwrap_write16,
 118  };
 119
 120  static const struct pwrap_slv_type pmic_mt6380 = {
 121         .dew_regs = NULL,
 122         .type = PMIC_MT6380,
 123         .pwrap_read = pwrap_read32,
 124 +       .pwrap_write = pwrap_write32,
 125  };
 126
 127  static const struct pwrap_slv_type pmic_mt6397 = {
 128         .dew_regs = mt6397_regs,
 129         .type = PMIC_MT6397,
 130         .pwrap_read = pwrap_read16,
 131 +       .pwrap_write = pwrap_write16,
 132  };
 133
 134  static const struct of_device_id of_slave_match_tbl[] = {
 135 --
 136 2.11.0
 137