Quellcode-Bibliothek spi-npcm-fiu.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
// Copyright (c) 2019 Nuvoton Technology corporation.

#include <linux/bits.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/clk.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/vmalloc.h>
#include <linux/regmap.h>
#include <linux/of.h>
#include <linux/spi/spi-mem.h>
#include <linux/mfd/syscon.h>

/* NPCM7xx GCR module */
#define NPCM7XX_INTCR3_OFFSET  0x9C
#define NPCM7XX_INTCR3_FIU_FIX  BIT(6)

/* Flash Interface Unit (FIU) Registers */
#define NPCM_FIU_DRD_CFG  0x00
#define NPCM_FIU_DWR_CFG  0x04
#define NPCM_FIU_UMA_CFG  0x08
#define NPCM_FIU_UMA_CTS  0x0C
#define NPCM_FIU_UMA_CMD  0x10
#define NPCM_FIU_UMA_ADDR  0x14
#define NPCM_FIU_PRT_CFG  0x18
#define NPCM_FIU_UMA_DW0  0x20
#define NPCM_FIU_UMA_DW1  0x24
#define NPCM_FIU_UMA_DW2  0x28
#define NPCM_FIU_UMA_DW3  0x2C
#define NPCM_FIU_UMA_DR0  0x30
#define NPCM_FIU_UMA_DR1  0x34
#define NPCM_FIU_UMA_DR2  0x38
#define NPCM_FIU_UMA_DR3  0x3C
#define NPCM_FIU_CFG   0x78
#define NPCM_FIU_MAX_REG_LIMIT  0x80

/* FIU Direct Read Configuration Register */
#define NPCM_FIU_DRD_CFG_LCK  BIT(31)
#define NPCM_FIU_DRD_CFG_R_BURST GENMASK(25, 24)
#define NPCM_FIU_DRD_CFG_ADDSIZ  GENMASK(17, 16)
#define NPCM_FIU_DRD_CFG_DBW  GENMASK(13, 12)
#define NPCM_FIU_DRD_CFG_ACCTYPE GENMASK(9, 8)
#define NPCM_FIU_DRD_CFG_RDCMD  GENMASK(7, 0)
#define NPCM_FIU_DRD_ADDSIZ_SHIFT 16
#define NPCM_FIU_DRD_DBW_SHIFT  12
#define NPCM_FIU_DRD_ACCTYPE_SHIFT 8

/* FIU Direct Write Configuration Register */
#define NPCM_FIU_DWR_CFG_LCK  BIT(31)
#define NPCM_FIU_DWR_CFG_W_BURST GENMASK(25, 24)
#define NPCM_FIU_DWR_CFG_ADDSIZ  GENMASK(17, 16)
#define NPCM_FIU_DWR_CFG_ABPCK  GENMASK(11, 10)
#define NPCM_FIU_DWR_CFG_DBPCK  GENMASK(9, 8)
#define NPCM_FIU_DWR_CFG_WRCMD  GENMASK(7, 0)
#define NPCM_FIU_DWR_ADDSIZ_SHIFT 16
#define NPCM_FIU_DWR_ABPCK_SHIFT 10
#define NPCM_FIU_DWR_DBPCK_SHIFT 8

/* FIU UMA Configuration Register */
#define NPCM_FIU_UMA_CFG_LCK  BIT(31)
#define NPCM_FIU_UMA_CFG_CMMLCK  BIT(30)
#define NPCM_FIU_UMA_CFG_RDATSIZ GENMASK(28, 24)
#define NPCM_FIU_UMA_CFG_DBSIZ  GENMASK(23, 21)
#define NPCM_FIU_UMA_CFG_WDATSIZ GENMASK(20, 16)
#define NPCM_FIU_UMA_CFG_ADDSIZ  GENMASK(13, 11)
#define NPCM_FIU_UMA_CFG_CMDSIZ  BIT(10)
#define NPCM_FIU_UMA_CFG_RDBPCK  GENMASK(9, 8)
#define NPCM_FIU_UMA_CFG_DBPCK  GENMASK(7, 6)
#define NPCM_FIU_UMA_CFG_WDBPCK  GENMASK(5, 4)
#define NPCM_FIU_UMA_CFG_ADBPCK  GENMASK(3, 2)
#define NPCM_FIU_UMA_CFG_CMBPCK  GENMASK(1, 0)
#define NPCM_FIU_UMA_CFG_ADBPCK_SHIFT 2
#define NPCM_FIU_UMA_CFG_WDBPCK_SHIFT 4
#define NPCM_FIU_UMA_CFG_DBPCK_SHIFT 6
#define NPCM_FIU_UMA_CFG_RDBPCK_SHIFT 8
#define NPCM_FIU_UMA_CFG_ADDSIZ_SHIFT 11
#define NPCM_FIU_UMA_CFG_WDATSIZ_SHIFT 16
#define NPCM_FIU_UMA_CFG_DBSIZ_SHIFT 21
#define NPCM_FIU_UMA_CFG_RDATSIZ_SHIFT 24

/* FIU UMA Control and Status Register */
#define NPCM_FIU_UMA_CTS_RDYIE  BIT(25)
#define NPCM_FIU_UMA_CTS_RDYST  BIT(24)
#define NPCM_FIU_UMA_CTS_SW_CS  BIT(16)
#define NPCM_FIU_UMA_CTS_DEV_NUM GENMASK(9, 8)
#define NPCM_FIU_UMA_CTS_EXEC_DONE BIT(0)
#define NPCM_FIU_UMA_CTS_DEV_NUM_SHIFT 8

/* FIU UMA Command Register */
#define NPCM_FIU_UMA_CMD_DUM3  GENMASK(31, 24)
#define NPCM_FIU_UMA_CMD_DUM2  GENMASK(23, 16)
#define NPCM_FIU_UMA_CMD_DUM1  GENMASK(15, 8)
#define NPCM_FIU_UMA_CMD_CMD  GENMASK(7, 0)

/* FIU UMA Address Register */
#define NPCM_FIU_UMA_ADDR_UMA_ADDR GENMASK(31, 0)
#define NPCM_FIU_UMA_ADDR_AB3  GENMASK(31, 24)
#define NPCM_FIU_UMA_ADDR_AB2  GENMASK(23, 16)
#define NPCM_FIU_UMA_ADDR_AB1  GENMASK(15, 8)
#define NPCM_FIU_UMA_ADDR_AB0  GENMASK(7, 0)

/* FIU UMA Write Data Bytes 0-3 Register */
#define NPCM_FIU_UMA_DW0_WB3  GENMASK(31, 24)
#define NPCM_FIU_UMA_DW0_WB2  GENMASK(23, 16)
#define NPCM_FIU_UMA_DW0_WB1  GENMASK(15, 8)
#define NPCM_FIU_UMA_DW0_WB0  GENMASK(7, 0)

/* FIU UMA Write Data Bytes 4-7 Register */
#define NPCM_FIU_UMA_DW1_WB7  GENMASK(31, 24)
#define NPCM_FIU_UMA_DW1_WB6  GENMASK(23, 16)
#define NPCM_FIU_UMA_DW1_WB5  GENMASK(15, 8)
#define NPCM_FIU_UMA_DW1_WB4  GENMASK(7, 0)

/* FIU UMA Write Data Bytes 8-11 Register */
#define NPCM_FIU_UMA_DW2_WB11  GENMASK(31, 24)
#define NPCM_FIU_UMA_DW2_WB10  GENMASK(23, 16)
#define NPCM_FIU_UMA_DW2_WB9  GENMASK(15, 8)
#define NPCM_FIU_UMA_DW2_WB8  GENMASK(7, 0)

/* FIU UMA Write Data Bytes 12-15 Register */
#define NPCM_FIU_UMA_DW3_WB15  GENMASK(31, 24)
#define NPCM_FIU_UMA_DW3_WB14  GENMASK(23, 16)
#define NPCM_FIU_UMA_DW3_WB13  GENMASK(15, 8)
#define NPCM_FIU_UMA_DW3_WB12  GENMASK(7, 0)

/* FIU UMA Read Data Bytes 0-3 Register */
#define NPCM_FIU_UMA_DR0_RB3  GENMASK(31, 24)
#define NPCM_FIU_UMA_DR0_RB2  GENMASK(23, 16)
#define NPCM_FIU_UMA_DR0_RB1  GENMASK(15, 8)
#define NPCM_FIU_UMA_DR0_RB0  GENMASK(7, 0)

/* FIU UMA Read Data Bytes 4-7 Register */
#define NPCM_FIU_UMA_DR1_RB15  GENMASK(31, 24)
#define NPCM_FIU_UMA_DR1_RB14  GENMASK(23, 16)
#define NPCM_FIU_UMA_DR1_RB13  GENMASK(15, 8)
#define NPCM_FIU_UMA_DR1_RB12  GENMASK(7, 0)

/* FIU UMA Read Data Bytes 8-11 Register */
#define NPCM_FIU_UMA_DR2_RB15  GENMASK(31, 24)
#define NPCM_FIU_UMA_DR2_RB14  GENMASK(23, 16)
#define NPCM_FIU_UMA_DR2_RB13  GENMASK(15, 8)
#define NPCM_FIU_UMA_DR2_RB12  GENMASK(7, 0)

/* FIU UMA Read Data Bytes 12-15 Register */
#define NPCM_FIU_UMA_DR3_RB15  GENMASK(31, 24)
#define NPCM_FIU_UMA_DR3_RB14  GENMASK(23, 16)
#define NPCM_FIU_UMA_DR3_RB13  GENMASK(15, 8)
#define NPCM_FIU_UMA_DR3_RB12  GENMASK(7, 0)

/* FIU Configuration Register */
#define NPCM_FIU_CFG_FIU_FIX  BIT(31)

/* FIU Read Mode */
enum {
 DRD_SINGLE_WIRE_MODE = 0,
 DRD_DUAL_IO_MODE = 1,
 DRD_QUAD_IO_MODE = 2,
 DRD_SPI_X_MODE  = 3,
};

enum {
 DWR_ABPCK_BIT_PER_CLK = 0,
 DWR_ABPCK_2_BIT_PER_CLK = 1,
 DWR_ABPCK_4_BIT_PER_CLK = 2,
};

enum {
 DWR_DBPCK_BIT_PER_CLK = 0,
 DWR_DBPCK_2_BIT_PER_CLK = 1,
 DWR_DBPCK_4_BIT_PER_CLK = 2,
};

#define NPCM_FIU_DRD_16_BYTE_BURST 0x3000000
#define NPCM_FIU_DWR_16_BYTE_BURST 0x3000000

#define MAP_SIZE_128MB   0x8000000
#define MAP_SIZE_16MB   0x1000000
#define MAP_SIZE_8MB   0x800000

#define FIU_DRD_MAX_DUMMY_NUMBER 3
#define NPCM_MAX_CHIP_NUM  4
#define CHUNK_SIZE   16
#define UMA_MICRO_SEC_TIMEOUT  150

enum {
 FIU0 = 0,
 FIU3,
 FIUX,
 FIU1,
};

struct npcm_fiu_info {
 char *name;
 u32 fiu_id;
 u32 max_map_size;
 u32 max_cs;
};

struct fiu_data {
 const struct npcm_fiu_info *npcm_fiu_data_info;
 int fiu_max;
};

static const struct npcm_fiu_info npcm7xx_fiu_info[] = {
 {.name = "FIU0", .fiu_id = FIU0,
  .max_map_size = MAP_SIZE_128MB, .max_cs = 2},
 {.name = "FIU3", .fiu_id = FIU3,
  .max_map_size = MAP_SIZE_128MB, .max_cs = 4},
 {.name = "FIUX", .fiu_id = FIUX,
  .max_map_size = MAP_SIZE_16MB, .max_cs = 2} };

static const struct fiu_data npcm7xx_fiu_data = {
 .npcm_fiu_data_info = npcm7xx_fiu_info,
 .fiu_max = 3,
};

static const struct npcm_fiu_info npxm8xx_fiu_info[] = {
 {.name = "FIU0", .fiu_id = FIU0,
  .max_map_size = MAP_SIZE_128MB, .max_cs = 2},
 {.name = "FIU3", .fiu_id = FIU3,
  .max_map_size = MAP_SIZE_128MB, .max_cs = 4},
 {.name = "FIUX", .fiu_id = FIUX,
  .max_map_size = MAP_SIZE_16MB, .max_cs = 2},
 {.name = "FIU1", .fiu_id = FIU1,
  .max_map_size = MAP_SIZE_16MB, .max_cs = 4} };

static const struct fiu_data npxm8xx_fiu_data = {
 .npcm_fiu_data_info = npxm8xx_fiu_info,
 .fiu_max = 4,
};

struct npcm_fiu_spi;

struct npcm_fiu_chip {
 void __iomem *flash_region_mapped_ptr;
 struct npcm_fiu_spi *fiu;
 unsigned long clkrate;
 u32 chipselect;
};

struct npcm_fiu_spi {
 struct npcm_fiu_chip chip[NPCM_MAX_CHIP_NUM];
 const struct npcm_fiu_info *info;
 struct spi_mem_op drd_op;
 struct resource *res_mem;
 struct regmap *regmap;
 unsigned long clkrate;
 struct device *dev;
 struct clk *clk;
 bool spix_mode;
};

static const struct regmap_config npcm_mtd_regmap_config = {
 .reg_bits = 32,
 .val_bits = 32,
 .reg_stride = 4,
 .max_register = NPCM_FIU_MAX_REG_LIMIT,
};

static void npcm_fiu_set_drd(struct npcm_fiu_spi *fiu,
        const struct spi_mem_op *op)
{
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_ACCTYPE,
      ilog2(op->addr.buswidth) <<
      NPCM_FIU_DRD_ACCTYPE_SHIFT);
 fiu->drd_op.addr.buswidth = op->addr.buswidth;
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_DBW,
      op->dummy.nbytes << NPCM_FIU_DRD_DBW_SHIFT);
 fiu->drd_op.dummy.nbytes = op->dummy.nbytes;
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_RDCMD, op->cmd.opcode);
 fiu->drd_op.cmd.opcode = op->cmd.opcode;
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_ADDSIZ,
      (op->addr.nbytes - 3) << NPCM_FIU_DRD_ADDSIZ_SHIFT);
 fiu->drd_op.addr.nbytes = op->addr.nbytes;
}

static ssize_t npcm_fiu_direct_read(struct spi_mem_dirmap_desc *desc,
        u64 offs, size_t len, void *buf)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(desc->mem->spi->controller);
 struct npcm_fiu_chip *chip = &fiu->chip[spi_get_chipselect(desc->mem->spi, 0)];
 void __iomem *src = (void __iomem *)(chip->flash_region_mapped_ptr +
          offs);
 u8 *buf_rx = buf;
 u32 i;

 if (fiu->spix_mode) {
  for (i = 0 ; i < len ; i++)
   *(buf_rx + i) = ioread8(src + i);
 } else {
  if (desc->info.op_tmpl.addr.buswidth != fiu->drd_op.addr.buswidth ||
      desc->info.op_tmpl.dummy.nbytes != fiu->drd_op.dummy.nbytes ||
      desc->info.op_tmpl.cmd.opcode != fiu->drd_op.cmd.opcode ||
      desc->info.op_tmpl.addr.nbytes != fiu->drd_op.addr.nbytes)
   npcm_fiu_set_drd(fiu, &desc->info.op_tmpl);

  memcpy_fromio(buf_rx, src, len);
 }

 return len;
}

static ssize_t npcm_fiu_direct_write(struct spi_mem_dirmap_desc *desc,
         u64 offs, size_t len, const void *buf)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(desc->mem->spi->controller);
 struct npcm_fiu_chip *chip = &fiu->chip[spi_get_chipselect(desc->mem->spi, 0)];
 void __iomem *dst = (void __iomem *)(chip->flash_region_mapped_ptr +
          offs);
 const u8 *buf_tx = buf;
 u32 i;

 if (fiu->spix_mode)
  for (i = 0 ; i < len ; i++)
   iowrite8(*(buf_tx + i), dst + i);
 else
  memcpy_toio(dst, buf_tx, len);

 return len;
}

static int npcm_fiu_uma_read(struct spi_mem *mem,
        const struct spi_mem_op *op, u32 addr,
         bool is_address_size, u8 *data, u32 data_size)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(mem->spi->controller);
 u32 uma_cfg = BIT(10);
 u32 data_reg[4];
 int ret;
 u32 val;
 u32 i;

 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
      NPCM_FIU_UMA_CTS_DEV_NUM,
      (spi_get_chipselect(mem->spi, 0) <<
       NPCM_FIU_UMA_CTS_DEV_NUM_SHIFT));
 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CMD,
      NPCM_FIU_UMA_CMD_CMD, op->cmd.opcode);

 if (is_address_size) {
  uma_cfg |= ilog2(op->cmd.buswidth);
  uma_cfg |= ilog2(op->addr.buswidth)
   << NPCM_FIU_UMA_CFG_ADBPCK_SHIFT;
  if (op->dummy.nbytes)
   uma_cfg |= ilog2(op->dummy.buswidth)
    << NPCM_FIU_UMA_CFG_DBPCK_SHIFT;
  uma_cfg |= ilog2(op->data.buswidth)
   << NPCM_FIU_UMA_CFG_RDBPCK_SHIFT;
  uma_cfg |= op->dummy.nbytes << NPCM_FIU_UMA_CFG_DBSIZ_SHIFT;
  uma_cfg |= op->addr.nbytes << NPCM_FIU_UMA_CFG_ADDSIZ_SHIFT;
  regmap_write(fiu->regmap, NPCM_FIU_UMA_ADDR, addr);
 } else {
  regmap_write(fiu->regmap, NPCM_FIU_UMA_ADDR, 0x0);
 }

 uma_cfg |= data_size << NPCM_FIU_UMA_CFG_RDATSIZ_SHIFT;
 regmap_write(fiu->regmap, NPCM_FIU_UMA_CFG, uma_cfg);
 regmap_write_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
     NPCM_FIU_UMA_CTS_EXEC_DONE,
     NPCM_FIU_UMA_CTS_EXEC_DONE);
 ret = regmap_read_poll_timeout(fiu->regmap, NPCM_FIU_UMA_CTS, val,
           (!(val & NPCM_FIU_UMA_CTS_EXEC_DONE)), 0,
           UMA_MICRO_SEC_TIMEOUT);
 if (ret)
  return ret;

 if (data_size) {
  for (i = 0; i < DIV_ROUND_UP(data_size, 4); i++)
   regmap_read(fiu->regmap, NPCM_FIU_UMA_DR0 + (i * 4),
        &data_reg[i]);
  memcpy(data, data_reg, data_size);
 }

 return 0;
}

static int npcm_fiu_uma_write(struct spi_mem *mem,
         const struct spi_mem_op *op, u8 cmd,
         bool is_address_size, u8 *data, u32 data_size)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(mem->spi->controller);
 u32 uma_cfg = BIT(10);
 u32 data_reg[4] = {0};
 u32 val;
 u32 i;

 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
      NPCM_FIU_UMA_CTS_DEV_NUM,
      (spi_get_chipselect(mem->spi, 0) <<
       NPCM_FIU_UMA_CTS_DEV_NUM_SHIFT));

 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CMD,
      NPCM_FIU_UMA_CMD_CMD, cmd);

 if (data_size) {
  memcpy(data_reg, data, data_size);
  for (i = 0; i < DIV_ROUND_UP(data_size, 4); i++)
   regmap_write(fiu->regmap, NPCM_FIU_UMA_DW0 + (i * 4),
         data_reg[i]);
 }

 if (is_address_size) {
  uma_cfg |= ilog2(op->cmd.buswidth);
  uma_cfg |= ilog2(op->addr.buswidth) <<
   NPCM_FIU_UMA_CFG_ADBPCK_SHIFT;
  uma_cfg |= ilog2(op->data.buswidth) <<
   NPCM_FIU_UMA_CFG_WDBPCK_SHIFT;
  uma_cfg |= op->addr.nbytes << NPCM_FIU_UMA_CFG_ADDSIZ_SHIFT;
  regmap_write(fiu->regmap, NPCM_FIU_UMA_ADDR, op->addr.val);
 } else {
  regmap_write(fiu->regmap, NPCM_FIU_UMA_ADDR, 0x0);
 }

 uma_cfg |= (data_size << NPCM_FIU_UMA_CFG_WDATSIZ_SHIFT);
 regmap_write(fiu->regmap, NPCM_FIU_UMA_CFG, uma_cfg);

 regmap_write_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
     NPCM_FIU_UMA_CTS_EXEC_DONE,
     NPCM_FIU_UMA_CTS_EXEC_DONE);

 return regmap_read_poll_timeout(fiu->regmap, NPCM_FIU_UMA_CTS, val,
           (!(val & NPCM_FIU_UMA_CTS_EXEC_DONE)), 0,
     UMA_MICRO_SEC_TIMEOUT);
}

static int npcm_fiu_manualwrite(struct spi_mem *mem,
    const struct spi_mem_op *op)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(mem->spi->controller);
 u8 *data = (u8 *)op->data.buf.out;
 u32 num_data_chunks;
 u32 remain_data;
 u32 idx = 0;
 int ret;

 num_data_chunks  = op->data.nbytes / CHUNK_SIZE;
 remain_data  = op->data.nbytes % CHUNK_SIZE;

 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
      NPCM_FIU_UMA_CTS_DEV_NUM,
      (spi_get_chipselect(mem->spi, 0) <<
       NPCM_FIU_UMA_CTS_DEV_NUM_SHIFT));
 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
      NPCM_FIU_UMA_CTS_SW_CS, 0);

 ret = npcm_fiu_uma_write(mem, op, op->cmd.opcode, true, NULL, 0);
 if (ret)
  return ret;

 /* Starting the data writing loop in multiples of 8 */
 for (idx = 0; idx < num_data_chunks; ++idx) {
  ret = npcm_fiu_uma_write(mem, op, data[0], false,
      &data[1], CHUNK_SIZE - 1);
  if (ret)
   return ret;

  data += CHUNK_SIZE;
 }

 /* Handling chunk remains */
 if (remain_data > 0) {
  ret = npcm_fiu_uma_write(mem, op, data[0], false,
      &data[1], remain_data - 1);
  if (ret)
   return ret;
 }

 regmap_update_bits(fiu->regmap, NPCM_FIU_UMA_CTS,
      NPCM_FIU_UMA_CTS_SW_CS, NPCM_FIU_UMA_CTS_SW_CS);

 return 0;
}

static int npcm_fiu_read(struct spi_mem *mem, const struct spi_mem_op *op)
{
 u8 *data = op->data.buf.in;
 int i, readlen, currlen;
 u8 *buf_ptr;
 u32 addr;
 int ret;

 i = 0;
 currlen = op->data.nbytes;

 do {
  addr = ((u32)op->addr.val + i);
  if (currlen < 16)
   readlen = currlen;
  else
   readlen = 16;

  buf_ptr = data + i;
  ret = npcm_fiu_uma_read(mem, op, addr, true, buf_ptr,
     readlen);
  if (ret)
   return ret;

  i += readlen;
  currlen -= 16;
 } while (currlen > 0);

 return 0;
}

static void npcm_fiux_set_direct_wr(struct npcm_fiu_spi *fiu)
{
 regmap_write(fiu->regmap, NPCM_FIU_DWR_CFG,
       NPCM_FIU_DWR_16_BYTE_BURST);
 regmap_update_bits(fiu->regmap, NPCM_FIU_DWR_CFG,
      NPCM_FIU_DWR_CFG_ABPCK,
      DWR_ABPCK_4_BIT_PER_CLK << NPCM_FIU_DWR_ABPCK_SHIFT);
 regmap_update_bits(fiu->regmap, NPCM_FIU_DWR_CFG,
      NPCM_FIU_DWR_CFG_DBPCK,
      DWR_DBPCK_4_BIT_PER_CLK << NPCM_FIU_DWR_DBPCK_SHIFT);
}

static void npcm_fiux_set_direct_rd(struct npcm_fiu_spi *fiu)
{
 u32 rx_dummy = 0;

 regmap_write(fiu->regmap, NPCM_FIU_DRD_CFG,
       NPCM_FIU_DRD_16_BYTE_BURST);
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_ACCTYPE,
      DRD_SPI_X_MODE << NPCM_FIU_DRD_ACCTYPE_SHIFT);
 regmap_update_bits(fiu->regmap, NPCM_FIU_DRD_CFG,
      NPCM_FIU_DRD_CFG_DBW,
      rx_dummy << NPCM_FIU_DRD_DBW_SHIFT);
}

static int npcm_fiu_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(mem->spi->controller);
 struct npcm_fiu_chip *chip = &fiu->chip[spi_get_chipselect(mem->spi, 0)];
 int ret = 0;
 u8 *buf;

 if (fiu->spix_mode || op->addr.nbytes > 4)
  return -EOPNOTSUPP;

 if (fiu->clkrate != chip->clkrate) {
  ret = clk_set_rate(fiu->clk, chip->clkrate);
  if (ret < 0)
   dev_warn(fiu->dev, "Failed setting %lu frequency, stay at %lu frequency\n",
     chip->clkrate, fiu->clkrate);
  else
   fiu->clkrate = chip->clkrate;
 }

 if (op->data.dir == SPI_MEM_DATA_IN) {
  if (!op->addr.nbytes) {
   buf = op->data.buf.in;
   ret = npcm_fiu_uma_read(mem, op, op->addr.val, false,
      buf, op->data.nbytes);
  } else {
   ret = npcm_fiu_read(mem, op);
  }
 } else  {
  if (!op->addr.nbytes && !op->data.nbytes)
   ret = npcm_fiu_uma_write(mem, op, op->cmd.opcode, false,
       NULL, 0);
  if (op->addr.nbytes && !op->data.nbytes) {
   int i;
   u8 buf_addr[4];
   u32 addr = op->addr.val;

   for (i = op->addr.nbytes - 1; i >= 0; i--) {
    buf_addr[i] = addr & 0xff;
    addr >>= 8;
   }
   ret = npcm_fiu_uma_write(mem, op, op->cmd.opcode, false,
       buf_addr, op->addr.nbytes);
  }
  if (!op->addr.nbytes && op->data.nbytes)
   ret = npcm_fiu_uma_write(mem, op, op->cmd.opcode, false,
       (u8 *)op->data.buf.out,
       op->data.nbytes);
  if (op->addr.nbytes && op->data.nbytes)
   ret = npcm_fiu_manualwrite(mem, op);
 }

 return ret;
}

static int npcm_fiu_dirmap_create(struct spi_mem_dirmap_desc *desc)
{
 struct npcm_fiu_spi *fiu =
  spi_controller_get_devdata(desc->mem->spi->controller);
 struct npcm_fiu_chip *chip = &fiu->chip[spi_get_chipselect(desc->mem->spi, 0)];
 struct regmap *gcr_regmap;

 if (!fiu->res_mem) {
  dev_warn(fiu->dev, "Reserved memory not defined, direct read disabled\n");
  desc->nodirmap = true;
  return 0;
 }

 if (!fiu->spix_mode &&
     desc->info.op_tmpl.data.dir == SPI_MEM_DATA_OUT) {
  desc->nodirmap = true;
  return 0;
 }

 if (!chip->flash_region_mapped_ptr) {
  chip->flash_region_mapped_ptr =
   devm_ioremap(fiu->dev, (fiu->res_mem->start +
       (fiu->info->max_map_size *
          spi_get_chipselect(desc->mem->spi, 0))),
          (u32)desc->info.length);
  if (!chip->flash_region_mapped_ptr) {
   dev_warn(fiu->dev, "Error mapping memory region, direct read disabled\n");
   desc->nodirmap = true;
   return 0;
  }
 }

 if (of_device_is_compatible(fiu->dev->of_node, "nuvoton,npcm750-fiu")) {
  gcr_regmap =
   syscon_regmap_lookup_by_compatible("nuvoton,npcm750-gcr");
  if (IS_ERR(gcr_regmap)) {
   dev_warn(fiu->dev, "Didn't find nuvoton,npcm750-gcr, direct read disabled\n");
   desc->nodirmap = true;
   return 0;
  }
  regmap_update_bits(gcr_regmap, NPCM7XX_INTCR3_OFFSET,
       NPCM7XX_INTCR3_FIU_FIX,
       NPCM7XX_INTCR3_FIU_FIX);
 } else {
  regmap_update_bits(fiu->regmap, NPCM_FIU_CFG,
       NPCM_FIU_CFG_FIU_FIX,
       NPCM_FIU_CFG_FIU_FIX);
 }

 if (desc->info.op_tmpl.data.dir == SPI_MEM_DATA_IN) {
  if (!fiu->spix_mode)
   npcm_fiu_set_drd(fiu, &desc->info.op_tmpl);
  else
   npcm_fiux_set_direct_rd(fiu);

 } else {
  npcm_fiux_set_direct_wr(fiu);
 }

 return 0;
}

static int npcm_fiu_setup(struct spi_device *spi)
{
 struct spi_controller *ctrl = spi->controller;
 struct npcm_fiu_spi *fiu = spi_controller_get_devdata(ctrl);
 struct npcm_fiu_chip *chip;

 chip = &fiu->chip[spi_get_chipselect(spi, 0)];
 chip->fiu = fiu;
 chip->chipselect = spi_get_chipselect(spi, 0);
 chip->clkrate = spi->max_speed_hz;

 fiu->clkrate = clk_get_rate(fiu->clk);

 return 0;
}

static const struct spi_controller_mem_ops npcm_fiu_mem_ops = {
 .exec_op = npcm_fiu_exec_op,
 .dirmap_create = npcm_fiu_dirmap_create,
 .dirmap_read = npcm_fiu_direct_read,
 .dirmap_write = npcm_fiu_direct_write,
};

static const struct of_device_id npcm_fiu_dt_ids[] = {
 { .compatible = "nuvoton,npcm750-fiu", .data = &npcm7xx_fiu_data  },
 { .compatible = "nuvoton,npcm845-fiu", .data = &npxm8xx_fiu_data  },
 { /* sentinel */ }
};

static int npcm_fiu_probe(struct platform_device *pdev)
{
 const struct fiu_data *fiu_data_match;
 struct device *dev = &pdev->dev;
 struct spi_controller *ctrl;
 struct npcm_fiu_spi *fiu;
 void __iomem *regbase;
 int id;

 ctrl = devm_spi_alloc_host(dev, sizeof(*fiu));
 if (!ctrl)
  return -ENOMEM;

 fiu = spi_controller_get_devdata(ctrl);

 fiu_data_match = of_device_get_match_data(dev);
 if (!fiu_data_match) {
  dev_err(dev, "No compatible OF match\n");
  return -ENODEV;
 }

 id = of_alias_get_id(dev->of_node, "fiu");
 if (id < 0 || id >= fiu_data_match->fiu_max) {
  dev_err(dev, "Invalid platform device id: %d\n", id);
  return -EINVAL;
 }

 fiu->info = &fiu_data_match->npcm_fiu_data_info[id];

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

 regbase = devm_platform_ioremap_resource_byname(pdev, "control");
 if (IS_ERR(regbase))
  return PTR_ERR(regbase);

 fiu->regmap = devm_regmap_init_mmio(dev, regbase,
         &npcm_mtd_regmap_config);
 if (IS_ERR(fiu->regmap)) {
  dev_err(dev, "Failed to create regmap\n");
  return PTR_ERR(fiu->regmap);
 }

 fiu->res_mem = platform_get_resource_byname(pdev, IORESOURCE_MEM,
          "memory");
 fiu->clk = devm_clk_get_enabled(dev, NULL);
 if (IS_ERR(fiu->clk))
  return PTR_ERR(fiu->clk);

 fiu->spix_mode = of_property_read_bool(dev->of_node,
            "nuvoton,spix-mode");

 platform_set_drvdata(pdev, fiu);

 ctrl->mode_bits = SPI_RX_DUAL | SPI_RX_QUAD
  | SPI_TX_DUAL | SPI_TX_QUAD;
 ctrl->setup = npcm_fiu_setup;
 ctrl->bus_num = -1;
 ctrl->mem_ops = &npcm_fiu_mem_ops;
 ctrl->num_chipselect = fiu->info->max_cs;
 ctrl->dev.of_node = dev->of_node;

 return devm_spi_register_controller(dev, ctrl);
}

static void npcm_fiu_remove(struct platform_device *pdev)
{
}

MODULE_DEVICE_TABLE(of, npcm_fiu_dt_ids);

static struct platform_driver npcm_fiu_driver = {
 .driver = {
  .name = "NPCM-FIU",
  .bus = &platform_bus_type,
  .of_match_table = npcm_fiu_dt_ids,
 },
 .probe = npcm_fiu_probe,
 .remove = npcm_fiu_remove,
};
module_platform_driver(npcm_fiu_driver);

MODULE_DESCRIPTION("Nuvoton FLASH Interface Unit SPI Controller Driver");
MODULE_AUTHOR("Tomer Maimon ");
MODULE_LICENSE("GPL v2");