Quelle  stm32-fmc2-ebi.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) STMicroelectronics 2020
 */

#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/reset.h>

/* FMC2 Controller Registers */
#define FMC2_BCR1   0x0
#define FMC2_BTR1   0x4
#define FMC2_BCR(x)   ((x) * 0x8 + FMC2_BCR1)
#define FMC2_BTR(x)   ((x) * 0x8 + FMC2_BTR1)
#define FMC2_PCSCNTR   0x20
#define FMC2_CFGR   0x20
#define FMC2_SR    0x84
#define FMC2_BWTR1   0x104
#define FMC2_BWTR(x)   ((x) * 0x8 + FMC2_BWTR1)
#define FMC2_SECCFGR   0x300
#define FMC2_CIDCFGR0   0x30c
#define FMC2_CIDCFGR(x)   ((x) * 0x8 + FMC2_CIDCFGR0)
#define FMC2_SEMCR0   0x310
#define FMC2_SEMCR(x)   ((x) * 0x8 + FMC2_SEMCR0)

/* Register: FMC2_BCR1 */
#define FMC2_BCR1_CCLKEN  BIT(20)
#define FMC2_BCR1_FMC2EN  BIT(31)

/* Register: FMC2_BCRx */
#define FMC2_BCR_MBKEN   BIT(0)
#define FMC2_BCR_MUXEN   BIT(1)
#define FMC2_BCR_MTYP   GENMASK(3, 2)
#define FMC2_BCR_MWID   GENMASK(5, 4)
#define FMC2_BCR_FACCEN   BIT(6)
#define FMC2_BCR_BURSTEN  BIT(8)
#define FMC2_BCR_WAITPOL  BIT(9)
#define FMC2_BCR_WAITCFG  BIT(11)
#define FMC2_BCR_WREN   BIT(12)
#define FMC2_BCR_WAITEN   BIT(13)
#define FMC2_BCR_EXTMOD   BIT(14)
#define FMC2_BCR_ASYNCWAIT  BIT(15)
#define FMC2_BCR_CPSIZE   GENMASK(18, 16)
#define FMC2_BCR_CBURSTRW  BIT(19)
#define FMC2_BCR_CSCOUNT  GENMASK(21, 20)
#define FMC2_BCR_NBLSET   GENMASK(23, 22)

/* Register: FMC2_BTRx/FMC2_BWTRx */
#define FMC2_BXTR_ADDSET  GENMASK(3, 0)
#define FMC2_BXTR_ADDHLD  GENMASK(7, 4)
#define FMC2_BXTR_DATAST  GENMASK(15, 8)
#define FMC2_BXTR_BUSTURN  GENMASK(19, 16)
#define FMC2_BTR_CLKDIV   GENMASK(23, 20)
#define FMC2_BTR_DATLAT   GENMASK(27, 24)
#define FMC2_BXTR_ACCMOD  GENMASK(29, 28)
#define FMC2_BXTR_DATAHLD  GENMASK(31, 30)

/* Register: FMC2_PCSCNTR */
#define FMC2_PCSCNTR_CSCOUNT  GENMASK(15, 0)
#define FMC2_PCSCNTR_CNTBEN(x)  BIT((x) + 16)

/* Register: FMC2_CFGR */
#define FMC2_CFGR_CLKDIV  GENMASK(19, 16)
#define FMC2_CFGR_CCLKEN  BIT(20)
#define FMC2_CFGR_FMC2EN  BIT(31)

/* Register: FMC2_SR */
#define FMC2_SR_ISOST   GENMASK(1, 0)

/* Register: FMC2_CIDCFGR */
#define FMC2_CIDCFGR_CFEN  BIT(0)
#define FMC2_CIDCFGR_SEMEN  BIT(1)
#define FMC2_CIDCFGR_SCID  GENMASK(6, 4)
#define FMC2_CIDCFGR_SEMWLC1  BIT(17)

/* Register: FMC2_SEMCR */
#define FMC2_SEMCR_SEM_MUTEX  BIT(0)
#define FMC2_SEMCR_SEMCID  GENMASK(6, 4)

#define FMC2_MAX_EBI_CE   4
#define FMC2_MAX_BANKS   5
#define FMC2_MAX_RESOURCES  6
#define FMC2_CID1   1

#define FMC2_BCR_CPSIZE_0  0x0
#define FMC2_BCR_CPSIZE_128  0x1
#define FMC2_BCR_CPSIZE_256  0x2
#define FMC2_BCR_CPSIZE_512  0x3
#define FMC2_BCR_CPSIZE_1024  0x4

#define FMC2_BCR_MWID_8   0x0
#define FMC2_BCR_MWID_16  0x1

#define FMC2_BCR_MTYP_SRAM  0x0
#define FMC2_BCR_MTYP_PSRAM  0x1
#define FMC2_BCR_MTYP_NOR  0x2

#define FMC2_BCR_CSCOUNT_0  0x0
#define FMC2_BCR_CSCOUNT_1  0x1
#define FMC2_BCR_CSCOUNT_64  0x2
#define FMC2_BCR_CSCOUNT_256  0x3

#define FMC2_BXTR_EXTMOD_A  0x0
#define FMC2_BXTR_EXTMOD_B  0x1
#define FMC2_BXTR_EXTMOD_C  0x2
#define FMC2_BXTR_EXTMOD_D  0x3

#define FMC2_BCR_NBLSET_MAX  0x3
#define FMC2_BXTR_ADDSET_MAX  0xf
#define FMC2_BXTR_ADDHLD_MAX  0xf
#define FMC2_BXTR_DATAST_MAX  0xff
#define FMC2_BXTR_BUSTURN_MAX  0xf
#define FMC2_BXTR_DATAHLD_MAX  0x3
#define FMC2_BTR_CLKDIV_MAX  0xf
#define FMC2_BTR_DATLAT_MAX  0xf
#define FMC2_PCSCNTR_CSCOUNT_MAX 0xff
#define FMC2_CFGR_CLKDIV_MAX  0xf

enum stm32_fmc2_ebi_bank {
 FMC2_EBI1 = 0,
 FMC2_EBI2,
 FMC2_EBI3,
 FMC2_EBI4,
 FMC2_NAND
};

enum stm32_fmc2_ebi_register_type {
 FMC2_REG_BCR = 1,
 FMC2_REG_BTR,
 FMC2_REG_BWTR,
 FMC2_REG_PCSCNTR,
 FMC2_REG_CFGR
};

enum stm32_fmc2_ebi_transaction_type {
 FMC2_ASYNC_MODE_1_SRAM = 0,
 FMC2_ASYNC_MODE_1_PSRAM,
 FMC2_ASYNC_MODE_A_SRAM,
 FMC2_ASYNC_MODE_A_PSRAM,
 FMC2_ASYNC_MODE_2_NOR,
 FMC2_ASYNC_MODE_B_NOR,
 FMC2_ASYNC_MODE_C_NOR,
 FMC2_ASYNC_MODE_D_NOR,
 FMC2_SYNC_READ_SYNC_WRITE_PSRAM,
 FMC2_SYNC_READ_ASYNC_WRITE_PSRAM,
 FMC2_SYNC_READ_SYNC_WRITE_NOR,
 FMC2_SYNC_READ_ASYNC_WRITE_NOR
};

enum stm32_fmc2_ebi_buswidth {
 FMC2_BUSWIDTH_8 = 8,
 FMC2_BUSWIDTH_16 = 16
};

enum stm32_fmc2_ebi_cpsize {
 FMC2_CPSIZE_0 = 0,
 FMC2_CPSIZE_128 = 128,
 FMC2_CPSIZE_256 = 256,
 FMC2_CPSIZE_512 = 512,
 FMC2_CPSIZE_1024 = 1024
};

enum stm32_fmc2_ebi_cscount {
 FMC2_CSCOUNT_0 = 0,
 FMC2_CSCOUNT_1 = 1,
 FMC2_CSCOUNT_64 = 64,
 FMC2_CSCOUNT_256 = 256
};

struct stm32_fmc2_ebi;

struct stm32_fmc2_ebi_data {
 const struct stm32_fmc2_prop *child_props;
 unsigned int nb_child_props;
 u32 fmc2_enable_reg;
 u32 fmc2_enable_bit;
 int (*nwait_used_by_ctrls)(struct stm32_fmc2_ebi *ebi);
 void (*set_setup)(struct stm32_fmc2_ebi *ebi);
 int (*save_setup)(struct stm32_fmc2_ebi *ebi);
 int (*check_rif)(struct stm32_fmc2_ebi *ebi, u32 resource);
 void (*put_sems)(struct stm32_fmc2_ebi *ebi);
 void (*get_sems)(struct stm32_fmc2_ebi *ebi);
};

struct stm32_fmc2_ebi {
 struct device *dev;
 struct clk *clk;
 struct regmap *regmap;
 const struct stm32_fmc2_ebi_data *data;
 u8 bank_assigned;
 u8 sem_taken;
 bool access_granted;

 u32 bcr[FMC2_MAX_EBI_CE];
 u32 btr[FMC2_MAX_EBI_CE];
 u32 bwtr[FMC2_MAX_EBI_CE];
 u32 pcscntr;
 u32 cfgr;
};

/*
 * struct stm32_fmc2_prop - STM32 FMC2 EBI property
 * @name: the device tree binding name of the property
 * @bprop: indicate that it is a boolean property
 * @mprop: indicate that it is a mandatory property
 * @reg_type: the register that have to be modified
 * @reg_mask: the bit that have to be modified in the selected register
 *            in case of it is a boolean property
 * @reset_val: the default value that have to be set in case the property
 *             has not been defined in the device tree
 * @check: this callback ckecks that the property is compliant with the
 *         transaction type selected
 * @calculate: this callback is called to calculate for exemple a timing
 *             set in nanoseconds in the device tree in clock cycles or in
 *             clock period
 * @set: this callback applies the values in the registers
 */
struct stm32_fmc2_prop {
 const char *name;
 bool bprop;
 bool mprop;
 int reg_type;
 u32 reg_mask;
 u32 reset_val;
 int (*check)(struct stm32_fmc2_ebi *ebi,
       const struct stm32_fmc2_prop *prop, int cs);
 u32 (*calculate)(struct stm32_fmc2_ebi *ebi, int cs, u32 setup);
 int (*set)(struct stm32_fmc2_ebi *ebi,
     const struct stm32_fmc2_prop *prop,
     int cs, u32 setup);
};

static int stm32_fmc2_ebi_check_mux(struct stm32_fmc2_ebi *ebi,
        const struct stm32_fmc2_prop *prop,
        int cs)
{
 u32 bcr;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (bcr & FMC2_BCR_MTYP)
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_waitcfg(struct stm32_fmc2_ebi *ebi,
     const struct stm32_fmc2_prop *prop,
     int cs)
{
 u32 bcr, val = FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if ((bcr & FMC2_BCR_MTYP) == val && bcr & FMC2_BCR_BURSTEN)
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_sync_trans(struct stm32_fmc2_ebi *ebi,
        const struct stm32_fmc2_prop *prop,
        int cs)
{
 u32 bcr;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (bcr & FMC2_BCR_BURSTEN)
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_mp25_check_cclk(struct stm32_fmc2_ebi *ebi,
       const struct stm32_fmc2_prop *prop,
       int cs)
{
 if (!ebi->access_granted)
  return -EACCES;

 return stm32_fmc2_ebi_check_sync_trans(ebi, prop, cs);
}

static int stm32_fmc2_ebi_mp25_check_clk_period(struct stm32_fmc2_ebi *ebi,
      const struct stm32_fmc2_prop *prop,
      int cs)
{
 u32 cfgr;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_CFGR, &cfgr);
 if (ret)
  return ret;

 if (cfgr & FMC2_CFGR_CCLKEN && !ebi->access_granted)
  return -EACCES;

 return stm32_fmc2_ebi_check_sync_trans(ebi, prop, cs);
}

static int stm32_fmc2_ebi_check_async_trans(struct stm32_fmc2_ebi *ebi,
         const struct stm32_fmc2_prop *prop,
         int cs)
{
 u32 bcr;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (!(bcr & FMC2_BCR_BURSTEN) || !(bcr & FMC2_BCR_CBURSTRW))
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_cpsize(struct stm32_fmc2_ebi *ebi,
           const struct stm32_fmc2_prop *prop,
           int cs)
{
 u32 bcr, val = FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_PSRAM);
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if ((bcr & FMC2_BCR_MTYP) == val && bcr & FMC2_BCR_BURSTEN)
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_address_hold(struct stm32_fmc2_ebi *ebi,
          const struct stm32_fmc2_prop *prop,
          int cs)
{
 u32 bcr, bxtr, val = FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_D);
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (prop->reg_type == FMC2_REG_BWTR)
  ret = regmap_read(ebi->regmap, FMC2_BWTR(cs), &bxtr);
 else
  ret = regmap_read(ebi->regmap, FMC2_BTR(cs), &bxtr);
 if (ret)
  return ret;

 if ((!(bcr & FMC2_BCR_BURSTEN) || !(bcr & FMC2_BCR_CBURSTRW)) &&
     ((bxtr & FMC2_BXTR_ACCMOD) == val || bcr & FMC2_BCR_MUXEN))
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_clk_period(struct stm32_fmc2_ebi *ebi,
        const struct stm32_fmc2_prop *prop,
        int cs)
{
 u32 bcr, bcr1;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (cs) {
  ret = regmap_read(ebi->regmap, FMC2_BCR1, &bcr1);
  if (ret)
   return ret;
 } else {
  bcr1 = bcr;
 }

 if (bcr & FMC2_BCR_BURSTEN && (!cs || !(bcr1 & FMC2_BCR1_CCLKEN)))
  return 0;

 return -EINVAL;
}

static int stm32_fmc2_ebi_check_cclk(struct stm32_fmc2_ebi *ebi,
         const struct stm32_fmc2_prop *prop,
         int cs)
{
 if (cs)
  return -EINVAL;

 return stm32_fmc2_ebi_check_sync_trans(ebi, prop, cs);
}

static u32 stm32_fmc2_ebi_ns_to_clock_cycles(struct stm32_fmc2_ebi *ebi,
          int cs, u32 setup)
{
 unsigned long hclk = clk_get_rate(ebi->clk);
 unsigned long hclkp = NSEC_PER_SEC / (hclk / 1000);

 return DIV_ROUND_UP(setup * 1000, hclkp);
}

static u32 stm32_fmc2_ebi_ns_to_clk_period(struct stm32_fmc2_ebi *ebi,
        int cs, u32 setup)
{
 u32 nb_clk_cycles = stm32_fmc2_ebi_ns_to_clock_cycles(ebi, cs, setup);
 u32 bcr, btr, clk_period;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR1, &bcr);
 if (ret)
  return ret;

 if (bcr & FMC2_BCR1_CCLKEN || !cs)
  ret = regmap_read(ebi->regmap, FMC2_BTR1, &btr);
 else
  ret = regmap_read(ebi->regmap, FMC2_BTR(cs), &btr);
 if (ret)
  return ret;

 clk_period = FIELD_GET(FMC2_BTR_CLKDIV, btr) + 1;

 return DIV_ROUND_UP(nb_clk_cycles, clk_period);
}

static u32 stm32_fmc2_ebi_mp25_ns_to_clk_period(struct stm32_fmc2_ebi *ebi,
      int cs, u32 setup)
{
 u32 nb_clk_cycles = stm32_fmc2_ebi_ns_to_clock_cycles(ebi, cs, setup);
 u32 cfgr, btr, clk_period;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_CFGR, &cfgr);
 if (ret)
  return ret;

 if (cfgr & FMC2_CFGR_CCLKEN) {
  clk_period = FIELD_GET(FMC2_CFGR_CLKDIV, cfgr) + 1;
 } else {
  ret = regmap_read(ebi->regmap, FMC2_BTR(cs), &btr);
  if (ret)
   return ret;

  clk_period = FIELD_GET(FMC2_BTR_CLKDIV, btr) + 1;
 }

 return DIV_ROUND_UP(nb_clk_cycles, clk_period);
}

static int stm32_fmc2_ebi_get_reg(int reg_type, int cs, u32 *reg)
{
 switch (reg_type) {
 case FMC2_REG_BCR:
  *reg = FMC2_BCR(cs);
  break;
 case FMC2_REG_BTR:
  *reg = FMC2_BTR(cs);
  break;
 case FMC2_REG_BWTR:
  *reg = FMC2_BWTR(cs);
  break;
 case FMC2_REG_PCSCNTR:
  *reg = FMC2_PCSCNTR;
  break;
 case FMC2_REG_CFGR:
  *reg = FMC2_CFGR;
  break;
 default:
  return -EINVAL;
 }

 return 0;
}

static int stm32_fmc2_ebi_set_bit_field(struct stm32_fmc2_ebi *ebi,
     const struct stm32_fmc2_prop *prop,
     int cs, u32 setup)
{
 u32 reg;
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 regmap_update_bits(ebi->regmap, reg, prop->reg_mask,
      setup ? prop->reg_mask : 0);

 return 0;
}

static int stm32_fmc2_ebi_set_trans_type(struct stm32_fmc2_ebi *ebi,
      const struct stm32_fmc2_prop *prop,
      int cs, u32 setup)
{
 u32 bcr_mask, bcr = FMC2_BCR_WREN;
 u32 btr_mask, btr = 0;
 u32 bwtr_mask, bwtr = 0;

 bwtr_mask = FMC2_BXTR_ACCMOD;
 btr_mask = FMC2_BXTR_ACCMOD;
 bcr_mask = FMC2_BCR_MUXEN | FMC2_BCR_MTYP | FMC2_BCR_FACCEN |
     FMC2_BCR_WREN | FMC2_BCR_WAITEN | FMC2_BCR_BURSTEN |
     FMC2_BCR_EXTMOD | FMC2_BCR_CBURSTRW;

 switch (setup) {
 case FMC2_ASYNC_MODE_1_SRAM:
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_SRAM);
  /*
 * MUXEN = 0, MTYP = 0, FACCEN = 0, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 0, ACCMOD = 0
 */
  break;
 case FMC2_ASYNC_MODE_1_PSRAM:
  /*
 * MUXEN = 0, MTYP = 1, FACCEN = 0, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_PSRAM);
  break;
 case FMC2_ASYNC_MODE_A_SRAM:
  /*
 * MUXEN = 0, MTYP = 0, FACCEN = 0, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 1, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_SRAM);
  bcr |= FMC2_BCR_EXTMOD;
  btr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_A);
  bwtr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_A);
  break;
 case FMC2_ASYNC_MODE_A_PSRAM:
  /*
 * MUXEN = 0, MTYP = 1, FACCEN = 0, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 1, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_PSRAM);
  bcr |= FMC2_BCR_EXTMOD;
  btr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_A);
  bwtr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_A);
  break;
 case FMC2_ASYNC_MODE_2_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN;
  break;
 case FMC2_ASYNC_MODE_B_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 1, CBURSTRW = 0, ACCMOD = 1
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN | FMC2_BCR_EXTMOD;
  btr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_B);
  bwtr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_B);
  break;
 case FMC2_ASYNC_MODE_C_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 1, CBURSTRW = 0, ACCMOD = 2
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN | FMC2_BCR_EXTMOD;
  btr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_C);
  bwtr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_C);
  break;
 case FMC2_ASYNC_MODE_D_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 0, WAITEN = 0,
 * WREN = 1, EXTMOD = 1, CBURSTRW = 0, ACCMOD = 3
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN | FMC2_BCR_EXTMOD;
  btr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_D);
  bwtr |= FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_D);
  break;
 case FMC2_SYNC_READ_SYNC_WRITE_PSRAM:
  /*
 * MUXEN = 0, MTYP = 1, FACCEN = 0, BURSTEN = 1, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 1, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_PSRAM);
  bcr |= FMC2_BCR_BURSTEN | FMC2_BCR_CBURSTRW;
  break;
 case FMC2_SYNC_READ_ASYNC_WRITE_PSRAM:
  /*
 * MUXEN = 0, MTYP = 1, FACCEN = 0, BURSTEN = 1, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_PSRAM);
  bcr |= FMC2_BCR_BURSTEN;
  break;
 case FMC2_SYNC_READ_SYNC_WRITE_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 1, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 1, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN | FMC2_BCR_BURSTEN | FMC2_BCR_CBURSTRW;
  break;
 case FMC2_SYNC_READ_ASYNC_WRITE_NOR:
  /*
 * MUXEN = 0, MTYP = 2, FACCEN = 1, BURSTEN = 1, WAITEN = 0,
 * WREN = 1, EXTMOD = 0, CBURSTRW = 0, ACCMOD = 0
 */
  bcr |= FIELD_PREP(FMC2_BCR_MTYP, FMC2_BCR_MTYP_NOR);
  bcr |= FMC2_BCR_FACCEN | FMC2_BCR_BURSTEN;
  break;
 default:
  /* Type of transaction not supported */
  return -EINVAL;
 }

 if (bcr & FMC2_BCR_EXTMOD)
  regmap_update_bits(ebi->regmap, FMC2_BWTR(cs),
       bwtr_mask, bwtr);
 regmap_update_bits(ebi->regmap, FMC2_BTR(cs), btr_mask, btr);
 regmap_update_bits(ebi->regmap, FMC2_BCR(cs), bcr_mask, bcr);

 return 0;
}

static int stm32_fmc2_ebi_set_buswidth(struct stm32_fmc2_ebi *ebi,
           const struct stm32_fmc2_prop *prop,
           int cs, u32 setup)
{
 u32 val;

 switch (setup) {
 case FMC2_BUSWIDTH_8:
  val = FIELD_PREP(FMC2_BCR_MWID, FMC2_BCR_MWID_8);
  break;
 case FMC2_BUSWIDTH_16:
  val = FIELD_PREP(FMC2_BCR_MWID, FMC2_BCR_MWID_16);
  break;
 default:
  /* Buswidth not supported */
  return -EINVAL;
 }

 regmap_update_bits(ebi->regmap, FMC2_BCR(cs), FMC2_BCR_MWID, val);

 return 0;
}

static int stm32_fmc2_ebi_set_cpsize(struct stm32_fmc2_ebi *ebi,
         const struct stm32_fmc2_prop *prop,
         int cs, u32 setup)
{
 u32 val;

 switch (setup) {
 case FMC2_CPSIZE_0:
  val = FIELD_PREP(FMC2_BCR_CPSIZE, FMC2_BCR_CPSIZE_0);
  break;
 case FMC2_CPSIZE_128:
  val = FIELD_PREP(FMC2_BCR_CPSIZE, FMC2_BCR_CPSIZE_128);
  break;
 case FMC2_CPSIZE_256:
  val = FIELD_PREP(FMC2_BCR_CPSIZE, FMC2_BCR_CPSIZE_256);
  break;
 case FMC2_CPSIZE_512:
  val = FIELD_PREP(FMC2_BCR_CPSIZE, FMC2_BCR_CPSIZE_512);
  break;
 case FMC2_CPSIZE_1024:
  val = FIELD_PREP(FMC2_BCR_CPSIZE, FMC2_BCR_CPSIZE_1024);
  break;
 default:
  /* Cpsize not supported */
  return -EINVAL;
 }

 regmap_update_bits(ebi->regmap, FMC2_BCR(cs), FMC2_BCR_CPSIZE, val);

 return 0;
}

static int stm32_fmc2_ebi_set_bl_setup(struct stm32_fmc2_ebi *ebi,
           const struct stm32_fmc2_prop *prop,
           int cs, u32 setup)
{
 u32 val;

 val = min_t(u32, setup, FMC2_BCR_NBLSET_MAX);
 val = FIELD_PREP(FMC2_BCR_NBLSET, val);
 regmap_update_bits(ebi->regmap, FMC2_BCR(cs), FMC2_BCR_NBLSET, val);

 return 0;
}

static int stm32_fmc2_ebi_set_address_setup(struct stm32_fmc2_ebi *ebi,
         const struct stm32_fmc2_prop *prop,
         int cs, u32 setup)
{
 u32 bcr, bxtr, reg;
 u32 val = FIELD_PREP(FMC2_BXTR_ACCMOD, FMC2_BXTR_EXTMOD_D);
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
 if (ret)
  return ret;

 if (prop->reg_type == FMC2_REG_BWTR)
  ret = regmap_read(ebi->regmap, FMC2_BWTR(cs), &bxtr);
 else
  ret = regmap_read(ebi->regmap, FMC2_BTR(cs), &bxtr);
 if (ret)
  return ret;

 if ((bxtr & FMC2_BXTR_ACCMOD) == val || bcr & FMC2_BCR_MUXEN)
  val = clamp_val(setup, 1, FMC2_BXTR_ADDSET_MAX);
 else
  val = min_t(u32, setup, FMC2_BXTR_ADDSET_MAX);
 val = FIELD_PREP(FMC2_BXTR_ADDSET, val);
 regmap_update_bits(ebi->regmap, reg, FMC2_BXTR_ADDSET, val);

 return 0;
}

static int stm32_fmc2_ebi_set_address_hold(struct stm32_fmc2_ebi *ebi,
        const struct stm32_fmc2_prop *prop,
        int cs, u32 setup)
{
 u32 val, reg;
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 val = clamp_val(setup, 1, FMC2_BXTR_ADDHLD_MAX);
 val = FIELD_PREP(FMC2_BXTR_ADDHLD, val);
 regmap_update_bits(ebi->regmap, reg, FMC2_BXTR_ADDHLD, val);

 return 0;
}

static int stm32_fmc2_ebi_set_data_setup(struct stm32_fmc2_ebi *ebi,
      const struct stm32_fmc2_prop *prop,
      int cs, u32 setup)
{
 u32 val, reg;
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 val = clamp_val(setup, 1, FMC2_BXTR_DATAST_MAX);
 val = FIELD_PREP(FMC2_BXTR_DATAST, val);
 regmap_update_bits(ebi->regmap, reg, FMC2_BXTR_DATAST, val);

 return 0;
}

static int stm32_fmc2_ebi_set_bus_turnaround(struct stm32_fmc2_ebi *ebi,
          const struct stm32_fmc2_prop *prop,
          int cs, u32 setup)
{
 u32 val, reg;
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 val = setup ? min_t(u32, setup - 1, FMC2_BXTR_BUSTURN_MAX) : 0;
 val = FIELD_PREP(FMC2_BXTR_BUSTURN, val);
 regmap_update_bits(ebi->regmap, reg, FMC2_BXTR_BUSTURN, val);

 return 0;
}

static int stm32_fmc2_ebi_set_data_hold(struct stm32_fmc2_ebi *ebi,
     const struct stm32_fmc2_prop *prop,
     int cs, u32 setup)
{
 u32 val, reg;
 int ret;

 ret = stm32_fmc2_ebi_get_reg(prop->reg_type, cs, ®);
 if (ret)
  return ret;

 if (prop->reg_type == FMC2_REG_BWTR)
  val = setup ? min_t(u32, setup - 1, FMC2_BXTR_DATAHLD_MAX) : 0;
 else
  val = min_t(u32, setup, FMC2_BXTR_DATAHLD_MAX);
 val = FIELD_PREP(FMC2_BXTR_DATAHLD, val);
 regmap_update_bits(ebi->regmap, reg, FMC2_BXTR_DATAHLD, val);

 return 0;
}

static int stm32_fmc2_ebi_set_clk_period(struct stm32_fmc2_ebi *ebi,
      const struct stm32_fmc2_prop *prop,
      int cs, u32 setup)
{
 u32 val;

 val = setup ? clamp_val(setup - 1, 1, FMC2_BTR_CLKDIV_MAX) : 1;
 val = FIELD_PREP(FMC2_BTR_CLKDIV, val);
 regmap_update_bits(ebi->regmap, FMC2_BTR(cs), FMC2_BTR_CLKDIV, val);

 return 0;
}

static int stm32_fmc2_ebi_mp25_set_clk_period(struct stm32_fmc2_ebi *ebi,
           const struct stm32_fmc2_prop *prop,
           int cs, u32 setup)
{
 u32 val, cfgr;
 int ret;

 ret = regmap_read(ebi->regmap, FMC2_CFGR, &cfgr);
 if (ret)
  return ret;

 if (cfgr & FMC2_CFGR_CCLKEN) {
  val = setup ? clamp_val(setup - 1, 1, FMC2_CFGR_CLKDIV_MAX) : 1;
  val = FIELD_PREP(FMC2_CFGR_CLKDIV, val);
  regmap_update_bits(ebi->regmap, FMC2_CFGR, FMC2_CFGR_CLKDIV, val);
 } else {
  val = setup ? clamp_val(setup - 1, 1, FMC2_BTR_CLKDIV_MAX) : 1;
  val = FIELD_PREP(FMC2_BTR_CLKDIV, val);
  regmap_update_bits(ebi->regmap, FMC2_BTR(cs), FMC2_BTR_CLKDIV, val);
 }

 return 0;
}

static int stm32_fmc2_ebi_set_data_latency(struct stm32_fmc2_ebi *ebi,
        const struct stm32_fmc2_prop *prop,
        int cs, u32 setup)
{
 u32 val;

 val = setup > 1 ? min_t(u32, setup - 2, FMC2_BTR_DATLAT_MAX) : 0;
 val = FIELD_PREP(FMC2_BTR_DATLAT, val);
 regmap_update_bits(ebi->regmap, FMC2_BTR(cs), FMC2_BTR_DATLAT, val);

 return 0;
}

static int stm32_fmc2_ebi_set_max_low_pulse(struct stm32_fmc2_ebi *ebi,
         const struct stm32_fmc2_prop *prop,
         int cs, u32 setup)
{
 u32 old_val, new_val, pcscntr;
 int ret;

 if (setup < 1)
  return 0;

 ret = regmap_read(ebi->regmap, FMC2_PCSCNTR, &pcscntr);
 if (ret)
  return ret;

 /* Enable counter for the bank */
 regmap_update_bits(ebi->regmap, FMC2_PCSCNTR,
      FMC2_PCSCNTR_CNTBEN(cs),
      FMC2_PCSCNTR_CNTBEN(cs));

 new_val = min_t(u32, setup - 1, FMC2_PCSCNTR_CSCOUNT_MAX);
 old_val = FIELD_GET(FMC2_PCSCNTR_CSCOUNT, pcscntr);
 if (old_val && new_val > old_val)
  /* Keep current counter value */
  return 0;

 new_val = FIELD_PREP(FMC2_PCSCNTR_CSCOUNT, new_val);
 regmap_update_bits(ebi->regmap, FMC2_PCSCNTR,
      FMC2_PCSCNTR_CSCOUNT, new_val);

 return 0;
}

static int stm32_fmc2_ebi_mp25_set_max_low_pulse(struct stm32_fmc2_ebi *ebi,
       const struct stm32_fmc2_prop *prop,
       int cs, u32 setup)
{
 u32 val;

 if (setup == FMC2_CSCOUNT_0)
  val = FIELD_PREP(FMC2_BCR_CSCOUNT, FMC2_BCR_CSCOUNT_0);
 else if (setup == FMC2_CSCOUNT_1)
  val = FIELD_PREP(FMC2_BCR_CSCOUNT, FMC2_BCR_CSCOUNT_1);
 else if (setup <= FMC2_CSCOUNT_64)
  val = FIELD_PREP(FMC2_BCR_CSCOUNT, FMC2_BCR_CSCOUNT_64);
 else
  val = FIELD_PREP(FMC2_BCR_CSCOUNT, FMC2_BCR_CSCOUNT_256);

 regmap_update_bits(ebi->regmap, FMC2_BCR(cs),
      FMC2_BCR_CSCOUNT, val);

 return 0;
}

static const struct stm32_fmc2_prop stm32_fmc2_child_props[] = {
 /* st,fmc2-ebi-cs-trans-type must be the first property */
 {
  .name = "st,fmc2-ebi-cs-transaction-type",
  .mprop = true,
  .set = stm32_fmc2_ebi_set_trans_type,
 },
 {
  .name = "st,fmc2-ebi-cs-cclk-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR1_CCLKEN,
  .check = stm32_fmc2_ebi_check_cclk,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-mux-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_MUXEN,
  .check = stm32_fmc2_ebi_check_mux,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-buswidth",
  .reset_val = FMC2_BUSWIDTH_16,
  .set = stm32_fmc2_ebi_set_buswidth,
 },
 {
  .name = "st,fmc2-ebi-cs-waitpol-high",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITPOL,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-waitcfg-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITCFG,
  .check = stm32_fmc2_ebi_check_waitcfg,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-wait-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITEN,
  .check = stm32_fmc2_ebi_check_sync_trans,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-asyncwait-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_ASYNCWAIT,
  .check = stm32_fmc2_ebi_check_async_trans,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-cpsize",
  .check = stm32_fmc2_ebi_check_cpsize,
  .set = stm32_fmc2_ebi_set_cpsize,
 },
 {
  .name = "st,fmc2-ebi-cs-byte-lane-setup-ns",
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bl_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-address-setup-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_ADDSET_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-address-hold-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_ADDHLD_MAX,
  .check = stm32_fmc2_ebi_check_address_hold,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-data-setup-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_DATAST_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-bus-turnaround-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_BUSTURN_MAX + 1,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bus_turnaround,
 },
 {
  .name = "st,fmc2-ebi-cs-data-hold-ns",
  .reg_type = FMC2_REG_BTR,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-clk-period-ns",
  .reset_val = FMC2_BTR_CLKDIV_MAX + 1,
  .check = stm32_fmc2_ebi_check_clk_period,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_clk_period,
 },
 {
  .name = "st,fmc2-ebi-cs-data-latency-ns",
  .check = stm32_fmc2_ebi_check_sync_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clk_period,
  .set = stm32_fmc2_ebi_set_data_latency,
 },
 {
  .name = "st,fmc2-ebi-cs-write-address-setup-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_ADDSET_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-write-address-hold-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_ADDHLD_MAX,
  .check = stm32_fmc2_ebi_check_address_hold,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-write-data-setup-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_DATAST_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-write-bus-turnaround-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_BUSTURN_MAX + 1,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bus_turnaround,
 },
 {
  .name = "st,fmc2-ebi-cs-write-data-hold-ns",
  .reg_type = FMC2_REG_BWTR,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-max-low-pulse-ns",
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_max_low_pulse,
 },
};

static const struct stm32_fmc2_prop stm32_fmc2_mp25_child_props[] = {
 /* st,fmc2-ebi-cs-trans-type must be the first property */
 {
  .name = "st,fmc2-ebi-cs-transaction-type",
  .mprop = true,
  .set = stm32_fmc2_ebi_set_trans_type,
 },
 {
  .name = "st,fmc2-ebi-cs-cclk-enable",
  .bprop = true,
  .reg_type = FMC2_REG_CFGR,
  .reg_mask = FMC2_CFGR_CCLKEN,
  .check = stm32_fmc2_ebi_mp25_check_cclk,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-mux-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_MUXEN,
  .check = stm32_fmc2_ebi_check_mux,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-buswidth",
  .reset_val = FMC2_BUSWIDTH_16,
  .set = stm32_fmc2_ebi_set_buswidth,
 },
 {
  .name = "st,fmc2-ebi-cs-waitpol-high",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITPOL,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-waitcfg-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITCFG,
  .check = stm32_fmc2_ebi_check_waitcfg,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-wait-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_WAITEN,
  .check = stm32_fmc2_ebi_check_sync_trans,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-asyncwait-enable",
  .bprop = true,
  .reg_type = FMC2_REG_BCR,
  .reg_mask = FMC2_BCR_ASYNCWAIT,
  .check = stm32_fmc2_ebi_check_async_trans,
  .set = stm32_fmc2_ebi_set_bit_field,
 },
 {
  .name = "st,fmc2-ebi-cs-cpsize",
  .check = stm32_fmc2_ebi_check_cpsize,
  .set = stm32_fmc2_ebi_set_cpsize,
 },
 {
  .name = "st,fmc2-ebi-cs-byte-lane-setup-ns",
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bl_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-address-setup-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_ADDSET_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-address-hold-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_ADDHLD_MAX,
  .check = stm32_fmc2_ebi_check_address_hold,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-data-setup-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_DATAST_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-bus-turnaround-ns",
  .reg_type = FMC2_REG_BTR,
  .reset_val = FMC2_BXTR_BUSTURN_MAX + 1,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bus_turnaround,
 },
 {
  .name = "st,fmc2-ebi-cs-data-hold-ns",
  .reg_type = FMC2_REG_BTR,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-clk-period-ns",
  .reset_val = FMC2_CFGR_CLKDIV_MAX + 1,
  .check = stm32_fmc2_ebi_mp25_check_clk_period,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_mp25_set_clk_period,
 },
 {
  .name = "st,fmc2-ebi-cs-data-latency-ns",
  .check = stm32_fmc2_ebi_check_sync_trans,
  .calculate = stm32_fmc2_ebi_mp25_ns_to_clk_period,
  .set = stm32_fmc2_ebi_set_data_latency,
 },
 {
  .name = "st,fmc2-ebi-cs-write-address-setup-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_ADDSET_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-write-address-hold-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_ADDHLD_MAX,
  .check = stm32_fmc2_ebi_check_address_hold,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_address_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-write-data-setup-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_DATAST_MAX,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_setup,
 },
 {
  .name = "st,fmc2-ebi-cs-write-bus-turnaround-ns",
  .reg_type = FMC2_REG_BWTR,
  .reset_val = FMC2_BXTR_BUSTURN_MAX + 1,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_bus_turnaround,
 },
 {
  .name = "st,fmc2-ebi-cs-write-data-hold-ns",
  .reg_type = FMC2_REG_BWTR,
  .check = stm32_fmc2_ebi_check_async_trans,
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_set_data_hold,
 },
 {
  .name = "st,fmc2-ebi-cs-max-low-pulse-ns",
  .calculate = stm32_fmc2_ebi_ns_to_clock_cycles,
  .set = stm32_fmc2_ebi_mp25_set_max_low_pulse,
 },
};

static int stm32_fmc2_ebi_mp25_check_rif(struct stm32_fmc2_ebi *ebi, u32 resource)
{
 u32 seccfgr, cidcfgr, semcr;
 int cid, ret;

 if (resource >= FMC2_MAX_RESOURCES)
  return -EINVAL;

 ret = regmap_read(ebi->regmap, FMC2_SECCFGR, &seccfgr);
 if (ret)
  return ret;

 if (seccfgr & BIT(resource)) {
  if (resource)
   dev_err(ebi->dev, "resource %d is configured as secure\n",
    resource);

  return -EACCES;
 }

 ret = regmap_read(ebi->regmap, FMC2_CIDCFGR(resource), &cidcfgr);
 if (ret)
  return ret;

 if (!(cidcfgr & FMC2_CIDCFGR_CFEN))
  /* CID filtering is turned off: access granted */
  return 0;

 if (!(cidcfgr & FMC2_CIDCFGR_SEMEN)) {
  /* Static CID mode */
  cid = FIELD_GET(FMC2_CIDCFGR_SCID, cidcfgr);
  if (cid != FMC2_CID1) {
   if (resource)
    dev_err(ebi->dev, "static CID%d set for resource %d\n",
     cid, resource);

   return -EACCES;
  }

  return 0;
 }

 /* Pass-list with semaphore mode */
 if (!(cidcfgr & FMC2_CIDCFGR_SEMWLC1)) {
  if (resource)
   dev_err(ebi->dev, "CID1 is block-listed for resource %d\n",
    resource);

  return -EACCES;
 }

 ret = regmap_read(ebi->regmap, FMC2_SEMCR(resource), &semcr);
 if (ret)
  return ret;

 if (!(semcr & FMC2_SEMCR_SEM_MUTEX)) {
  regmap_update_bits(ebi->regmap, FMC2_SEMCR(resource),
       FMC2_SEMCR_SEM_MUTEX, FMC2_SEMCR_SEM_MUTEX);

  ret = regmap_read(ebi->regmap, FMC2_SEMCR(resource), &semcr);
  if (ret)
   return ret;
 }

 cid = FIELD_GET(FMC2_SEMCR_SEMCID, semcr);
 if (cid != FMC2_CID1) {
  if (resource)
   dev_err(ebi->dev, "resource %d is already used by CID%d\n",
    resource, cid);

  return -EACCES;
 }

 ebi->sem_taken |= BIT(resource);

 return 0;
}

static void stm32_fmc2_ebi_mp25_put_sems(struct stm32_fmc2_ebi *ebi)
{
 unsigned int resource;

 for (resource = 0; resource < FMC2_MAX_RESOURCES; resource++) {
  if (!(ebi->sem_taken & BIT(resource)))
   continue;

  regmap_update_bits(ebi->regmap, FMC2_SEMCR(resource),
       FMC2_SEMCR_SEM_MUTEX, 0);
 }
}

static void stm32_fmc2_ebi_mp25_get_sems(struct stm32_fmc2_ebi *ebi)
{
 unsigned int resource;

 for (resource = 0; resource < FMC2_MAX_RESOURCES; resource++) {
  if (!(ebi->sem_taken & BIT(resource)))
   continue;

  regmap_update_bits(ebi->regmap, FMC2_SEMCR(resource),
       FMC2_SEMCR_SEM_MUTEX, FMC2_SEMCR_SEM_MUTEX);
 }
}

static int stm32_fmc2_ebi_parse_prop(struct stm32_fmc2_ebi *ebi,
         struct device_node *dev_node,
         const struct stm32_fmc2_prop *prop,
         int cs)
{
 struct device *dev = ebi->dev;
 u32 setup = 0;

 if (!prop->set) {
  dev_err(dev, "property %s is not well defined\n", prop->name);
  return -EINVAL;
 }

 if (prop->check && prop->check(ebi, prop, cs))
  /* Skeep this property */
  return 0;

 if (prop->bprop) {
  bool bprop;

  bprop = of_property_read_bool(dev_node, prop->name);
  if (prop->mprop && !bprop) {
   dev_err(dev, "mandatory property %s not defined in the device tree\n",
    prop->name);
   return -EINVAL;
  }

  if (bprop)
   setup = 1;
 } else {
  u32 val;
  int ret;

  ret = of_property_read_u32(dev_node, prop->name, &val);
  if (prop->mprop && ret) {
   dev_err(dev, "mandatory property %s not defined in the device tree\n",
    prop->name);
   return ret;
  }

  if (ret)
   setup = prop->reset_val;
  else if (prop->calculate)
   setup = prop->calculate(ebi, cs, val);
  else
   setup = val;
 }

 return prop->set(ebi, prop, cs, setup);
}

static void stm32_fmc2_ebi_enable_bank(struct stm32_fmc2_ebi *ebi, int cs)
{
 regmap_update_bits(ebi->regmap, FMC2_BCR(cs),
      FMC2_BCR_MBKEN, FMC2_BCR_MBKEN);
}

static void stm32_fmc2_ebi_disable_bank(struct stm32_fmc2_ebi *ebi, int cs)
{
 regmap_update_bits(ebi->regmap, FMC2_BCR(cs), FMC2_BCR_MBKEN, 0);
}

static int stm32_fmc2_ebi_save_setup(struct stm32_fmc2_ebi *ebi)
{
 unsigned int cs;
 int ret;

 for (cs = 0; cs < FMC2_MAX_EBI_CE; cs++) {
  if (!(ebi->bank_assigned & BIT(cs)))
   continue;

  ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &ebi->bcr[cs]);
  ret |= regmap_read(ebi->regmap, FMC2_BTR(cs), &ebi->btr[cs]);
  ret |= regmap_read(ebi->regmap, FMC2_BWTR(cs), &ebi->bwtr[cs]);
  if (ret)
   return ret;
 }

 return 0;
}

static int stm32_fmc2_ebi_mp1_save_setup(struct stm32_fmc2_ebi *ebi)
{
 int ret;

 ret = stm32_fmc2_ebi_save_setup(ebi);
 if (ret)
  return ret;

 return regmap_read(ebi->regmap, FMC2_PCSCNTR, &ebi->pcscntr);
}

static int stm32_fmc2_ebi_mp25_save_setup(struct stm32_fmc2_ebi *ebi)
{
 int ret;

 ret = stm32_fmc2_ebi_save_setup(ebi);
 if (ret)
  return ret;

 if (ebi->access_granted)
  ret = regmap_read(ebi->regmap, FMC2_CFGR, &ebi->cfgr);

 return ret;
}

static void stm32_fmc2_ebi_set_setup(struct stm32_fmc2_ebi *ebi)
{
 unsigned int cs;

 for (cs = 0; cs < FMC2_MAX_EBI_CE; cs++) {
  if (!(ebi->bank_assigned & BIT(cs)))
   continue;

  regmap_write(ebi->regmap, FMC2_BCR(cs), ebi->bcr[cs]);
  regmap_write(ebi->regmap, FMC2_BTR(cs), ebi->btr[cs]);
  regmap_write(ebi->regmap, FMC2_BWTR(cs), ebi->bwtr[cs]);
 }
}

static void stm32_fmc2_ebi_mp1_set_setup(struct stm32_fmc2_ebi *ebi)
{
 stm32_fmc2_ebi_set_setup(ebi);
 regmap_write(ebi->regmap, FMC2_PCSCNTR, ebi->pcscntr);
}

static void stm32_fmc2_ebi_mp25_set_setup(struct stm32_fmc2_ebi *ebi)
{
 stm32_fmc2_ebi_set_setup(ebi);

 if (ebi->access_granted)
  regmap_write(ebi->regmap, FMC2_CFGR, ebi->cfgr);
}

static void stm32_fmc2_ebi_disable_banks(struct stm32_fmc2_ebi *ebi)
{
 unsigned int cs;

 for (cs = 0; cs < FMC2_MAX_EBI_CE; cs++) {
  if (!(ebi->bank_assigned & BIT(cs)))
   continue;

  stm32_fmc2_ebi_disable_bank(ebi, cs);
 }
}

/* NWAIT signal can not be connected to EBI controller and NAND controller */
static int stm32_fmc2_ebi_nwait_used_by_ctrls(struct stm32_fmc2_ebi *ebi)
{
 struct device *dev = ebi->dev;
 unsigned int cs;
 u32 bcr;
 int ret;

 for (cs = 0; cs < FMC2_MAX_EBI_CE; cs++) {
  if (!(ebi->bank_assigned & BIT(cs)))
   continue;

  ret = regmap_read(ebi->regmap, FMC2_BCR(cs), &bcr);
  if (ret)
   return ret;

  if ((bcr & FMC2_BCR_WAITEN || bcr & FMC2_BCR_ASYNCWAIT) &&
      ebi->bank_assigned & BIT(FMC2_NAND)) {
   dev_err(dev, "NWAIT signal connected to EBI and NAND controllers\n");
   return -EINVAL;
  }
 }

 return 0;
}

static void stm32_fmc2_ebi_enable(struct stm32_fmc2_ebi *ebi)
{
 if (!ebi->access_granted)
  return;

 regmap_update_bits(ebi->regmap, ebi->data->fmc2_enable_reg,
      ebi->data->fmc2_enable_bit,
      ebi->data->fmc2_enable_bit);
}

static void stm32_fmc2_ebi_disable(struct stm32_fmc2_ebi *ebi)
{
 if (!ebi->access_granted)
  return;

 regmap_update_bits(ebi->regmap, ebi->data->fmc2_enable_reg,
      ebi->data->fmc2_enable_bit, 0);
}

static int stm32_fmc2_ebi_setup_cs(struct stm32_fmc2_ebi *ebi,
       struct device_node *dev_node,
       u32 cs)
{
 unsigned int i;
 int ret;

 stm32_fmc2_ebi_disable_bank(ebi, cs);

 for (i = 0; i < ebi->data->nb_child_props; i++) {
  const struct stm32_fmc2_prop *p = &ebi->data->child_props[i];

  ret = stm32_fmc2_ebi_parse_prop(ebi, dev_node, p, cs);
  if (ret) {
   dev_err(ebi->dev, "property %s could not be set: %d\n",
    p->name, ret);
   return ret;
  }
 }

 stm32_fmc2_ebi_enable_bank(ebi, cs);

 return 0;
}

static int stm32_fmc2_ebi_parse_dt(struct stm32_fmc2_ebi *ebi)
{
 struct device *dev = ebi->dev;
 bool child_found = false;
 u32 bank;
 int ret;

 for_each_available_child_of_node_scoped(dev->of_node, child) {
  ret = of_property_read_u32(child, "reg", &bank);
  if (ret)
   return dev_err_probe(dev, ret, "could not retrieve reg property\n");

  if (bank >= FMC2_MAX_BANKS) {
   dev_err(dev, "invalid reg value: %d\n", bank);
   return -EINVAL;
  }

  if (ebi->bank_assigned & BIT(bank)) {
   dev_err(dev, "bank already assigned: %d\n", bank);
   return -EINVAL;
  }

  if (ebi->data->check_rif) {
   ret = ebi->data->check_rif(ebi, bank + 1);
   if (ret) {
    dev_err(dev, "bank access failed: %d\n", bank);
    return ret;
   }
  }

  if (bank < FMC2_MAX_EBI_CE) {
   ret = stm32_fmc2_ebi_setup_cs(ebi, child, bank);
   if (ret)
    return dev_err_probe(dev, ret,
           "setup chip select %d failed\n", bank);
  }

  ebi->bank_assigned |= BIT(bank);
  child_found = true;
 }

 if (!child_found) {
  dev_warn(dev, "no subnodes found, disable the driver.\n");
  return -ENODEV;
 }

 if (ebi->data->nwait_used_by_ctrls) {
  ret = ebi->data->nwait_used_by_ctrls(ebi);
  if (ret)
   return ret;
 }

 stm32_fmc2_ebi_enable(ebi);

 return of_platform_populate(dev->of_node, NULL, NULL, dev);
}

static int stm32_fmc2_ebi_probe(struct platform_device *pdev)
{
 struct device *dev = &pdev->dev;
 struct stm32_fmc2_ebi *ebi;
 struct reset_control *rstc;
 int ret;

 ebi = devm_kzalloc(&pdev->dev, sizeof(*ebi), GFP_KERNEL);
 if (!ebi)
  return -ENOMEM;

 ebi->dev = dev;
 platform_set_drvdata(pdev, ebi);

 ebi->data = of_device_get_match_data(dev);
 if (!ebi->data)
  return -EINVAL;

 ebi->regmap = device_node_to_regmap(dev->of_node);
 if (IS_ERR(ebi->regmap))
  return PTR_ERR(ebi->regmap);

 ebi->clk = devm_clk_get(dev, NULL);
 if (IS_ERR(ebi->clk))
  return PTR_ERR(ebi->clk);

 rstc = devm_reset_control_get(dev, NULL);
 if (PTR_ERR(rstc) == -EPROBE_DEFER)
  return -EPROBE_DEFER;

 ret = devm_pm_runtime_enable(dev);
 if (ret)
  return ret;

 ret = pm_runtime_resume_and_get(dev);
 if (ret < 0)
  return ret;

 if (!IS_ERR(rstc)) {
  reset_control_assert(rstc);
  reset_control_deassert(rstc);
 }

 /* Check if CFGR register can be modified */
 ebi->access_granted = true;
 if (ebi->data->check_rif) {
  ret = ebi->data->check_rif(ebi, 0);
  if (ret) {
   u32 sr;

   ebi->access_granted = false;

   ret = regmap_read(ebi->regmap, FMC2_SR, &sr);
   if (ret)
    goto err_release;

   /* In case of CFGR is secure, just check that the FMC2 is enabled */
   if (sr & FMC2_SR_ISOST) {
    dev_err(dev, "FMC2 is not ready to be used.\n");
    ret = -EACCES;
    goto err_release;
   }
  }
 }

 ret = stm32_fmc2_ebi_parse_dt(ebi);
 if (ret)
  goto err_release;

 ret = ebi->data->save_setup(ebi);
 if (ret)
  goto err_release;

 return 0;

err_release:
 stm32_fmc2_ebi_disable_banks(ebi);
 stm32_fmc2_ebi_disable(ebi);
 if (ebi->data->put_sems)
  ebi->data->put_sems(ebi);
 pm_runtime_put_sync_suspend(dev);

 return ret;
}

static void stm32_fmc2_ebi_remove(struct platform_device *pdev)
{
 struct stm32_fmc2_ebi *ebi = platform_get_drvdata(pdev);

 of_platform_depopulate(&pdev->dev);
 stm32_fmc2_ebi_disable_banks(ebi);
 stm32_fmc2_ebi_disable(ebi);
 if (ebi->data->put_sems)
  ebi->data->put_sems(ebi);
 pm_runtime_put_sync_suspend(&pdev->dev);
}

static int __maybe_unused stm32_fmc2_ebi_runtime_suspend(struct device *dev)
{
 struct stm32_fmc2_ebi *ebi = dev_get_drvdata(dev);

 clk_disable_unprepare(ebi->clk);

 return 0;
}

static int __maybe_unused stm32_fmc2_ebi_runtime_resume(struct device *dev)
{
 struct stm32_fmc2_ebi *ebi = dev_get_drvdata(dev);

 return clk_prepare_enable(ebi->clk);
}

static int __maybe_unused stm32_fmc2_ebi_suspend(struct device *dev)
{
 struct stm32_fmc2_ebi *ebi = dev_get_drvdata(dev);

 stm32_fmc2_ebi_disable(ebi);
 if (ebi->data->put_sems)
  ebi->data->put_sems(ebi);
 pm_runtime_put_sync_suspend(dev);
 pinctrl_pm_select_sleep_state(dev);

 return 0;
}

static int __maybe_unused stm32_fmc2_ebi_resume(struct device *dev)
{
 struct stm32_fmc2_ebi *ebi = dev_get_drvdata(dev);
 int ret;

 pinctrl_pm_select_default_state(dev);

 ret = pm_runtime_resume_and_get(dev);
 if (ret < 0)
  return ret;

 if (ebi->data->get_sems)
  ebi->data->get_sems(ebi);
 ebi->data->set_setup(ebi);
 stm32_fmc2_ebi_enable(ebi);

 return 0;
}

static const struct dev_pm_ops stm32_fmc2_ebi_pm_ops = {
 SET_RUNTIME_PM_OPS(stm32_fmc2_ebi_runtime_suspend,
      stm32_fmc2_ebi_runtime_resume, NULL)
 SET_SYSTEM_SLEEP_PM_OPS(stm32_fmc2_ebi_suspend, stm32_fmc2_ebi_resume)
};

static const struct stm32_fmc2_ebi_data stm32_fmc2_ebi_mp1_data = {
 .child_props = stm32_fmc2_child_props,
 .nb_child_props = ARRAY_SIZE(stm32_fmc2_child_props),
 .fmc2_enable_reg = FMC2_BCR1,
 .fmc2_enable_bit = FMC2_BCR1_FMC2EN,
 .nwait_used_by_ctrls = stm32_fmc2_ebi_nwait_used_by_ctrls,
 .set_setup = stm32_fmc2_ebi_mp1_set_setup,
 .save_setup = stm32_fmc2_ebi_mp1_save_setup,
};

static const struct stm32_fmc2_ebi_data stm32_fmc2_ebi_mp25_data = {
 .child_props = stm32_fmc2_mp25_child_props,
 .nb_child_props = ARRAY_SIZE(stm32_fmc2_mp25_child_props),
 .fmc2_enable_reg = FMC2_CFGR,
 .fmc2_enable_bit = FMC2_CFGR_FMC2EN,
 .set_setup = stm32_fmc2_ebi_mp25_set_setup,
 .save_setup = stm32_fmc2_ebi_mp25_save_setup,
 .check_rif = stm32_fmc2_ebi_mp25_check_rif,
 .put_sems = stm32_fmc2_ebi_mp25_put_sems,
 .get_sems = stm32_fmc2_ebi_mp25_get_sems,
};

static const struct of_device_id stm32_fmc2_ebi_match[] = {
 {
  .compatible = "st,stm32mp1-fmc2-ebi",
  .data = &stm32_fmc2_ebi_mp1_data,
 },
 {
  .compatible = "st,stm32mp25-fmc2-ebi",
  .data = &stm32_fmc2_ebi_mp25_data,
 },
 {}
};
MODULE_DEVICE_TABLE(of, stm32_fmc2_ebi_match);

static struct platform_driver stm32_fmc2_ebi_driver = {
 .probe = stm32_fmc2_ebi_probe,
 .remove = stm32_fmc2_ebi_remove,
 .driver = {
  .name = "stm32_fmc2_ebi",
  .of_match_table = stm32_fmc2_ebi_match,
  .pm = &stm32_fmc2_ebi_pm_ops,
 },
};
module_platform_driver(stm32_fmc2_ebi_driver);

MODULE_ALIAS("platform:stm32_fmc2_ebi");
MODULE_AUTHOR("Christophe Kerello ");
MODULE_DESCRIPTION("STMicroelectronics STM32 FMC2 ebi driver");
MODULE_LICENSE("GPL v2");