drivers/spi/spi-mtk-nor.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Mediatek SPI NOR controller driver
   4 //
   5 // Copyright (C) 2020 Chuanhong Guo <gch981213@gmail.com>
   6
   7 #include <linux/bits.h>
   8 #include <linux/clk.h>
   9 #include <linux/completion.h>
  10 #include <linux/dma-mapping.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/io.h>
  13 #include <linux/iopoll.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/of_device.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/spi/spi-mem.h>
  20 #include <linux/string.h>
  21
  22 #define DRIVER_NAME "mtk-spi-nor"
  23
  24 #define MTK_NOR_REG_CMD                 0x00
  25 #define MTK_NOR_CMD_WRITE               BIT(4)
  26 #define MTK_NOR_CMD_PROGRAM             BIT(2)
  27 #define MTK_NOR_CMD_READ                BIT(0)
  28 #define MTK_NOR_CMD_MASK                GENMASK(5, 0)
  29
  30 #define MTK_NOR_REG_PRG_CNT             0x04
  31 #define MTK_NOR_PRG_CNT_MAX             56
  32 #define MTK_NOR_REG_RDATA               0x0c
  33
  34 #define MTK_NOR_REG_RADR0               0x10
  35 #define MTK_NOR_REG_RADR(n)             (MTK_NOR_REG_RADR0 + 4 * (n))
  36 #define MTK_NOR_REG_RADR3               0xc8
  37
  38 #define MTK_NOR_REG_WDATA               0x1c
  39
  40 #define MTK_NOR_REG_PRGDATA0            0x20
  41 #define MTK_NOR_REG_PRGDATA(n)          (MTK_NOR_REG_PRGDATA0 + 4 * (n))
  42 #define MTK_NOR_REG_PRGDATA_MAX         5
  43
  44 #define MTK_NOR_REG_SHIFT0              0x38
  45 #define MTK_NOR_REG_SHIFT(n)            (MTK_NOR_REG_SHIFT0 + 4 * (n))
  46 #define MTK_NOR_REG_SHIFT_MAX           9
  47
  48 #define MTK_NOR_REG_CFG1                0x60
  49 #define MTK_NOR_FAST_READ               BIT(0)
  50
  51 #define MTK_NOR_REG_CFG2                0x64
  52 #define MTK_NOR_WR_CUSTOM_OP_EN         BIT(4)
  53 #define MTK_NOR_WR_BUF_EN               BIT(0)
  54
  55 #define MTK_NOR_REG_PP_DATA             0x98
  56
  57 #define MTK_NOR_REG_IRQ_STAT            0xa8
  58 #define MTK_NOR_REG_IRQ_EN              0xac
  59 #define MTK_NOR_IRQ_DMA                 BIT(7)
  60 #define MTK_NOR_IRQ_MASK                GENMASK(7, 0)
  61
  62 #define MTK_NOR_REG_CFG3                0xb4
  63 #define MTK_NOR_DISABLE_WREN            BIT(7)
  64 #define MTK_NOR_DISABLE_SR_POLL         BIT(5)
  65
  66 #define MTK_NOR_REG_WP                  0xc4
  67 #define MTK_NOR_ENABLE_SF_CMD           0x30
  68
  69 #define MTK_NOR_REG_BUSCFG              0xcc
  70 #define MTK_NOR_4B_ADDR                 BIT(4)
  71 #define MTK_NOR_QUAD_ADDR               BIT(3)
  72 #define MTK_NOR_QUAD_READ               BIT(2)
  73 #define MTK_NOR_DUAL_ADDR               BIT(1)
  74 #define MTK_NOR_DUAL_READ               BIT(0)
  75 #define MTK_NOR_BUS_MODE_MASK           GENMASK(4, 0)
  76
  77 #define MTK_NOR_REG_DMA_CTL             0x718
  78 #define MTK_NOR_DMA_START               BIT(0)
  79
  80 #define MTK_NOR_REG_DMA_FADR            0x71c
  81 #define MTK_NOR_REG_DMA_DADR            0x720
  82 #define MTK_NOR_REG_DMA_END_DADR        0x724
  83 #define MTK_NOR_REG_DMA_DADR_HB         0x738
  84 #define MTK_NOR_REG_DMA_END_DADR_HB     0x73c
  85
  86 #define MTK_NOR_PRG_MAX_SIZE            6
  87 // Reading DMA src/dst addresses have to be 16-byte aligned
  88 #define MTK_NOR_DMA_ALIGN               16
  89 #define MTK_NOR_DMA_ALIGN_MASK          (MTK_NOR_DMA_ALIGN - 1)
  90 // and we allocate a bounce buffer if destination address isn't aligned.
  91 #define MTK_NOR_BOUNCE_BUF_SIZE         PAGE_SIZE
  92
  93 // Buffered page program can do one 128-byte transfer
  94 #define MTK_NOR_PP_SIZE                 128
  95
  96 #define CLK_TO_US(sp, clkcnt)           DIV_ROUND_UP(clkcnt, sp->spi_freq / 1000000)
  97
  98 struct mtk_nor {
  99         struct spi_controller *ctlr;
 100         struct device *dev;
 101         void __iomem *base;
 102         u8 *buffer;
 103         dma_addr_t buffer_dma;
 104         struct clk *spi_clk;
 105         struct clk *ctlr_clk;
 106         unsigned int spi_freq;
 107         bool wbuf_en;
 108         bool has_irq;
 109         bool high_dma;
 110         struct completion op_done;
 111 };
 112
 113 static inline void mtk_nor_rmw(struct mtk_nor *sp, u32 reg, u32 set, u32 clr)
 114 {
 115         u32 val = readl(sp->base + reg);
 116
 117         val &= ~clr;
 118         val |= set;
 119         writel(val, sp->base + reg);
 120 }
 121
 122 static inline int mtk_nor_cmd_exec(struct mtk_nor *sp, u32 cmd, ulong clk)
 123 {
 124         ulong delay = CLK_TO_US(sp, clk);
 125         u32 reg;
 126         int ret;
 127
 128         writel(cmd, sp->base + MTK_NOR_REG_CMD);
 129         ret = readl_poll_timeout(sp->base + MTK_NOR_REG_CMD, reg, !(reg & cmd),
 130                                  delay / 3, (delay + 1) * 200);
 131         if (ret < 0)
 132                 dev_err(sp->dev, "command %u timeout.\n", cmd);
 133         return ret;
 134 }
 135
 136 static void mtk_nor_set_addr(struct mtk_nor *sp, const struct spi_mem_op *op)
 137 {
 138         u32 addr = op->addr.val;
 139         int i;
 140
 141         for (i = 0; i < 3; i++) {
 142                 writeb(addr & 0xff, sp->base + MTK_NOR_REG_RADR(i));
 143                 addr >>= 8;
 144         }
 145         if (op->addr.nbytes == 4) {
 146                 writeb(addr & 0xff, sp->base + MTK_NOR_REG_RADR3);
 147                 mtk_nor_rmw(sp, MTK_NOR_REG_BUSCFG, MTK_NOR_4B_ADDR, 0);
 148         } else {
 149                 mtk_nor_rmw(sp, MTK_NOR_REG_BUSCFG, 0, MTK_NOR_4B_ADDR);
 150         }
 151 }
 152
 153 static bool need_bounce(struct mtk_nor *sp, const struct spi_mem_op *op)
 154 {
 155         return ((uintptr_t)op->data.buf.in & MTK_NOR_DMA_ALIGN_MASK);
 156 }
 157
 158 static bool mtk_nor_match_read(const struct spi_mem_op *op)
 159 {
 160         int dummy = 0;
 161
 162         if (op->dummy.buswidth)
 163                 dummy = op->dummy.nbytes * BITS_PER_BYTE / op->dummy.buswidth;
 164
 165         if ((op->data.buswidth == 2) || (op->data.buswidth == 4)) {
 166                 if (op->addr.buswidth == 1)
 167                         return dummy == 8;
 168                 else if (op->addr.buswidth == 2)
 169                         return dummy == 4;
 170                 else if (op->addr.buswidth == 4)
 171                         return dummy == 6;
 172         } else if ((op->addr.buswidth == 1) && (op->data.buswidth == 1)) {
 173                 if (op->cmd.opcode == 0x03)
 174                         return dummy == 0;
 175                 else if (op->cmd.opcode == 0x0b)
 176                         return dummy == 8;
 177         }
 178         return false;
 179 }
 180
 181 static bool mtk_nor_match_prg(const struct spi_mem_op *op)
 182 {
 183         int tx_len, rx_len, prg_len, prg_left;
 184
 185         // prg mode is spi-only.
 186         if ((op->cmd.buswidth > 1) || (op->addr.buswidth > 1) ||
 187             (op->dummy.buswidth > 1) || (op->data.buswidth > 1))
 188                 return false;
 189
 190         tx_len = op->cmd.nbytes + op->addr.nbytes;
 191
 192         if (op->data.dir == SPI_MEM_DATA_OUT) {
 193                 // count dummy bytes only if we need to write data after it
 194                 tx_len += op->dummy.nbytes;
 195
 196                 // leave at least one byte for data
 197                 if (tx_len > MTK_NOR_REG_PRGDATA_MAX)
 198                         return false;
 199
 200                 // if there's no addr, meaning adjust_op_size is impossible,
 201                 // check data length as well.
 202                 if ((!op->addr.nbytes) &&
 203                     (tx_len + op->data.nbytes > MTK_NOR_REG_PRGDATA_MAX + 1))
 204                         return false;
 205         } else if (op->data.dir == SPI_MEM_DATA_IN) {
 206                 if (tx_len > MTK_NOR_REG_PRGDATA_MAX + 1)
 207                         return false;
 208
 209                 rx_len = op->data.nbytes;
 210                 prg_left = MTK_NOR_PRG_CNT_MAX / 8 - tx_len - op->dummy.nbytes;
 211                 if (prg_left > MTK_NOR_REG_SHIFT_MAX + 1)
 212                         prg_left = MTK_NOR_REG_SHIFT_MAX + 1;
 213                 if (rx_len > prg_left) {
 214                         if (!op->addr.nbytes)
 215                                 return false;
 216                         rx_len = prg_left;
 217                 }
 218
 219                 prg_len = tx_len + op->dummy.nbytes + rx_len;
 220                 if (prg_len > MTK_NOR_PRG_CNT_MAX / 8)
 221                         return false;
 222         } else {
 223                 prg_len = tx_len + op->dummy.nbytes;
 224                 if (prg_len > MTK_NOR_PRG_CNT_MAX / 8)
 225                         return false;
 226         }
 227         return true;
 228 }
 229
 230 static void mtk_nor_adj_prg_size(struct spi_mem_op *op)
 231 {
 232         int tx_len, tx_left, prg_left;
 233
 234         tx_len = op->cmd.nbytes + op->addr.nbytes;
 235         if (op->data.dir == SPI_MEM_DATA_OUT) {
 236                 tx_len += op->dummy.nbytes;
 237                 tx_left = MTK_NOR_REG_PRGDATA_MAX + 1 - tx_len;
 238                 if (op->data.nbytes > tx_left)
 239                         op->data.nbytes = tx_left;
 240         } else if (op->data.dir == SPI_MEM_DATA_IN) {
 241                 prg_left = MTK_NOR_PRG_CNT_MAX / 8 - tx_len - op->dummy.nbytes;
 242                 if (prg_left > MTK_NOR_REG_SHIFT_MAX + 1)
 243                         prg_left = MTK_NOR_REG_SHIFT_MAX + 1;
 244                 if (op->data.nbytes > prg_left)
 245                         op->data.nbytes = prg_left;
 246         }
 247 }
 248
 249 static int mtk_nor_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
 250 {
 251         struct mtk_nor *sp = spi_controller_get_devdata(mem->spi->master);
 252
 253         if (!op->data.nbytes)
 254                 return 0;
 255
 256         if ((op->addr.nbytes == 3) || (op->addr.nbytes == 4)) {
 257                 if ((op->data.dir == SPI_MEM_DATA_IN) &&
 258                     mtk_nor_match_read(op)) {
 259                         // limit size to prevent timeout calculation overflow
 260                         if (op->data.nbytes > 0x400000)
 261                                 op->data.nbytes = 0x400000;
 262
 263                         if ((op->addr.val & MTK_NOR_DMA_ALIGN_MASK) ||
 264                             (op->data.nbytes < MTK_NOR_DMA_ALIGN))
 265                                 op->data.nbytes = 1;
 266                         else if (!need_bounce(sp, op))
 267                                 op->data.nbytes &= ~MTK_NOR_DMA_ALIGN_MASK;
 268                         else if (op->data.nbytes > MTK_NOR_BOUNCE_BUF_SIZE)
 269                                 op->data.nbytes = MTK_NOR_BOUNCE_BUF_SIZE;
 270                         return 0;
 271                 } else if (op->data.dir == SPI_MEM_DATA_OUT) {
 272                         if (op->data.nbytes >= MTK_NOR_PP_SIZE)
 273                                 op->data.nbytes = MTK_NOR_PP_SIZE;
 274                         else
 275                                 op->data.nbytes = 1;
 276                         return 0;
 277                 }
 278         }
 279
 280         mtk_nor_adj_prg_size(op);
 281         return 0;
 282 }
 283
 284 static bool mtk_nor_supports_op(struct spi_mem *mem,
 285                                 const struct spi_mem_op *op)
 286 {
 287         if (!spi_mem_default_supports_op(mem, op))
 288                 return false;
 289
 290         if (op->cmd.buswidth != 1)
 291                 return false;
 292
 293         if ((op->addr.nbytes == 3) || (op->addr.nbytes == 4)) {
 294                 switch(op->data.dir) {
 295                 case SPI_MEM_DATA_IN:
 296                         if (mtk_nor_match_read(op))
 297                                 return true;
 298                         break;
 299                 case SPI_MEM_DATA_OUT:
 300                         if ((op->addr.buswidth == 1) &&
 301                             (op->dummy.nbytes == 0) &&
 302                             (op->data.buswidth == 1))
 303                                 return true;
 304                         break;
 305                 default:
 306                         break;
 307                 }
 308         }
 309
 310         return mtk_nor_match_prg(op);
 311 }
 312
 313 static void mtk_nor_setup_bus(struct mtk_nor *sp, const struct spi_mem_op *op)
 314 {
 315         u32 reg = 0;
 316
 317         if (op->addr.nbytes == 4)
 318                 reg |= MTK_NOR_4B_ADDR;
 319
 320         if (op->data.buswidth == 4) {
 321                 reg |= MTK_NOR_QUAD_READ;
 322                 writeb(op->cmd.opcode, sp->base + MTK_NOR_REG_PRGDATA(4));
 323                 if (op->addr.buswidth == 4)
 324                         reg |= MTK_NOR_QUAD_ADDR;
 325         } else if (op->data.buswidth == 2) {
 326                 reg |= MTK_NOR_DUAL_READ;
 327                 writeb(op->cmd.opcode, sp->base + MTK_NOR_REG_PRGDATA(3));
 328                 if (op->addr.buswidth == 2)
 329                         reg |= MTK_NOR_DUAL_ADDR;
 330         } else {
 331                 if (op->cmd.opcode == 0x0b)
 332                         mtk_nor_rmw(sp, MTK_NOR_REG_CFG1, MTK_NOR_FAST_READ, 0);
 333                 else
 334                         mtk_nor_rmw(sp, MTK_NOR_REG_CFG1, 0, MTK_NOR_FAST_READ);
 335         }
 336         mtk_nor_rmw(sp, MTK_NOR_REG_BUSCFG, reg, MTK_NOR_BUS_MODE_MASK);
 337 }
 338
 339 static int mtk_nor_dma_exec(struct mtk_nor *sp, u32 from, unsigned int length,
 340                             dma_addr_t dma_addr)
 341 {
 342         int ret = 0;
 343         ulong delay;
 344         u32 reg;
 345
 346         writel(from, sp->base + MTK_NOR_REG_DMA_FADR);
 347         writel(dma_addr, sp->base + MTK_NOR_REG_DMA_DADR);
 348         writel(dma_addr + length, sp->base + MTK_NOR_REG_DMA_END_DADR);
 349
 350         if (sp->high_dma) {
 351                 writel(upper_32_bits(dma_addr),
 352                        sp->base + MTK_NOR_REG_DMA_DADR_HB);
 353                 writel(upper_32_bits(dma_addr + length),
 354                        sp->base + MTK_NOR_REG_DMA_END_DADR_HB);
 355         }
 356
 357         if (sp->has_irq) {
 358                 reinit_completion(&sp->op_done);
 359                 mtk_nor_rmw(sp, MTK_NOR_REG_IRQ_EN, MTK_NOR_IRQ_DMA, 0);
 360         }
 361
 362         mtk_nor_rmw(sp, MTK_NOR_REG_DMA_CTL, MTK_NOR_DMA_START, 0);
 363
 364         delay = CLK_TO_US(sp, (length + 5) * BITS_PER_BYTE);
 365
 366         if (sp->has_irq) {
 367                 if (!wait_for_completion_timeout(&sp->op_done,
 368                                                  (delay + 1) * 100))
 369                         ret = -ETIMEDOUT;
 370         } else {
 371                 ret = readl_poll_timeout(sp->base + MTK_NOR_REG_DMA_CTL, reg,
 372                                          !(reg & MTK_NOR_DMA_START), delay / 3,
 373                                          (delay + 1) * 100);
 374         }
 375
 376         if (ret < 0)
 377                 dev_err(sp->dev, "dma read timeout.\n");
 378
 379         return ret;
 380 }
 381
 382 static int mtk_nor_read_bounce(struct mtk_nor *sp, const struct spi_mem_op *op)
 383 {
 384         unsigned int rdlen;
 385         int ret;
 386
 387         if (op->data.nbytes & MTK_NOR_DMA_ALIGN_MASK)
 388                 rdlen = (op->data.nbytes + MTK_NOR_DMA_ALIGN) & ~MTK_NOR_DMA_ALIGN_MASK;
 389         else
 390                 rdlen = op->data.nbytes;
 391
 392         ret = mtk_nor_dma_exec(sp, op->addr.val, rdlen, sp->buffer_dma);
 393
 394         if (!ret)
 395                 memcpy(op->data.buf.in, sp->buffer, op->data.nbytes);
 396
 397         return ret;
 398 }
 399
 400 static int mtk_nor_read_dma(struct mtk_nor *sp, const struct spi_mem_op *op)
 401 {
 402         int ret;
 403         dma_addr_t dma_addr;
 404
 405         if (need_bounce(sp, op))
 406                 return mtk_nor_read_bounce(sp, op);
 407
 408         dma_addr = dma_map_single(sp->dev, op->data.buf.in,
 409                                   op->data.nbytes, DMA_FROM_DEVICE);
 410
 411         if (dma_mapping_error(sp->dev, dma_addr))
 412                 return -EINVAL;
 413
 414         ret = mtk_nor_dma_exec(sp, op->addr.val, op->data.nbytes, dma_addr);
 415
 416         dma_unmap_single(sp->dev, dma_addr, op->data.nbytes, DMA_FROM_DEVICE);
 417
 418         return ret;
 419 }
 420
 421 static int mtk_nor_read_pio(struct mtk_nor *sp, const struct spi_mem_op *op)
 422 {
 423         u8 *buf = op->data.buf.in;
 424         int ret;
 425
 426         ret = mtk_nor_cmd_exec(sp, MTK_NOR_CMD_READ, 6 * BITS_PER_BYTE);
 427         if (!ret)
 428                 buf[0] = readb(sp->base + MTK_NOR_REG_RDATA);
 429         return ret;
 430 }
 431
 432 static int mtk_nor_write_buffer_enable(struct mtk_nor *sp)
 433 {
 434         int ret;
 435         u32 val;
 436
 437         if (sp->wbuf_en)
 438                 return 0;
 439
 440         val = readl(sp->base + MTK_NOR_REG_CFG2);
 441         writel(val | MTK_NOR_WR_BUF_EN, sp->base + MTK_NOR_REG_CFG2);
 442         ret = readl_poll_timeout(sp->base + MTK_NOR_REG_CFG2, val,
 443                                  val & MTK_NOR_WR_BUF_EN, 0, 10000);
 444         if (!ret)
 445                 sp->wbuf_en = true;
 446         return ret;
 447 }
 448
 449 static int mtk_nor_write_buffer_disable(struct mtk_nor *sp)
 450 {
 451         int ret;
 452         u32 val;
 453
 454         if (!sp->wbuf_en)
 455                 return 0;
 456         val = readl(sp->base + MTK_NOR_REG_CFG2);
 457         writel(val & ~MTK_NOR_WR_BUF_EN, sp->base + MTK_NOR_REG_CFG2);
 458         ret = readl_poll_timeout(sp->base + MTK_NOR_REG_CFG2, val,
 459                                  !(val & MTK_NOR_WR_BUF_EN), 0, 10000);
 460         if (!ret)
 461                 sp->wbuf_en = false;
 462         return ret;
 463 }
 464
 465 static int mtk_nor_pp_buffered(struct mtk_nor *sp, const struct spi_mem_op *op)
 466 {
 467         const u8 *buf = op->data.buf.out;
 468         u32 val;
 469         int ret, i;
 470
 471         ret = mtk_nor_write_buffer_enable(sp);
 472         if (ret < 0)
 473                 return ret;
 474
 475         for (i = 0; i < op->data.nbytes; i += 4) {
 476                 val = buf[i + 3] << 24 | buf[i + 2] << 16 | buf[i + 1] << 8 |
 477                       buf[i];
 478                 writel(val, sp->base + MTK_NOR_REG_PP_DATA);
 479         }
 480         return mtk_nor_cmd_exec(sp, MTK_NOR_CMD_WRITE,
 481                                 (op->data.nbytes + 5) * BITS_PER_BYTE);
 482 }
 483
 484 static int mtk_nor_pp_unbuffered(struct mtk_nor *sp,
 485                                  const struct spi_mem_op *op)
 486 {
 487         const u8 *buf = op->data.buf.out;
 488         int ret;
 489
 490         ret = mtk_nor_write_buffer_disable(sp);
 491         if (ret < 0)
 492                 return ret;
 493         writeb(buf[0], sp->base + MTK_NOR_REG_WDATA);
 494         return mtk_nor_cmd_exec(sp, MTK_NOR_CMD_WRITE, 6 * BITS_PER_BYTE);
 495 }
 496
 497 static int mtk_nor_spi_mem_prg(struct mtk_nor *sp, const struct spi_mem_op *op)
 498 {
 499         int rx_len = 0;
 500         int reg_offset = MTK_NOR_REG_PRGDATA_MAX;
 501         int tx_len, prg_len;
 502         int i, ret;
 503         void __iomem *reg;
 504         u8 bufbyte;
 505
 506         tx_len = op->cmd.nbytes + op->addr.nbytes;
 507
 508         // count dummy bytes only if we need to write data after it
 509         if (op->data.dir == SPI_MEM_DATA_OUT)
 510                 tx_len += op->dummy.nbytes + op->data.nbytes;
 511         else if (op->data.dir == SPI_MEM_DATA_IN)
 512                 rx_len = op->data.nbytes;
 513
 514         prg_len = op->cmd.nbytes + op->addr.nbytes + op->dummy.nbytes +
 515                   op->data.nbytes;
 516
 517         // an invalid op may reach here if the caller calls exec_op without
 518         // adjust_op_size. return -EINVAL instead of -ENOTSUPP so that
 519         // spi-mem won't try this op again with generic spi transfers.
 520         if ((tx_len > MTK_NOR_REG_PRGDATA_MAX + 1) ||
 521             (rx_len > MTK_NOR_REG_SHIFT_MAX + 1) ||
 522             (prg_len > MTK_NOR_PRG_CNT_MAX / 8))
 523                 return -EINVAL;
 524
 525         // fill tx data
 526         for (i = op->cmd.nbytes; i > 0; i--, reg_offset--) {
 527                 reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 528                 bufbyte = (op->cmd.opcode >> ((i - 1) * BITS_PER_BYTE)) & 0xff;
 529                 writeb(bufbyte, reg);
 530         }
 531
 532         for (i = op->addr.nbytes; i > 0; i--, reg_offset--) {
 533                 reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 534                 bufbyte = (op->addr.val >> ((i - 1) * BITS_PER_BYTE)) & 0xff;
 535                 writeb(bufbyte, reg);
 536         }
 537
 538         if (op->data.dir == SPI_MEM_DATA_OUT) {
 539                 for (i = 0; i < op->dummy.nbytes; i++, reg_offset--) {
 540                         reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 541                         writeb(0, reg);
 542                 }
 543
 544                 for (i = 0; i < op->data.nbytes; i++, reg_offset--) {
 545                         reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 546                         writeb(((const u8 *)(op->data.buf.out))[i], reg);
 547                 }
 548         }
 549
 550         for (; reg_offset >= 0; reg_offset--) {
 551                 reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 552                 writeb(0, reg);
 553         }
 554
 555         // trigger op
 556         writel(prg_len * BITS_PER_BYTE, sp->base + MTK_NOR_REG_PRG_CNT);
 557         ret = mtk_nor_cmd_exec(sp, MTK_NOR_CMD_PROGRAM,
 558                                prg_len * BITS_PER_BYTE);
 559         if (ret)
 560                 return ret;
 561
 562         // fetch read data
 563         reg_offset = 0;
 564         if (op->data.dir == SPI_MEM_DATA_IN) {
 565                 for (i = op->data.nbytes - 1; i >= 0; i--, reg_offset++) {
 566                         reg = sp->base + MTK_NOR_REG_SHIFT(reg_offset);
 567                         ((u8 *)(op->data.buf.in))[i] = readb(reg);
 568                 }
 569         }
 570
 571         return 0;
 572 }
 573
 574 static int mtk_nor_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
 575 {
 576         struct mtk_nor *sp = spi_controller_get_devdata(mem->spi->master);
 577         int ret;
 578
 579         if ((op->data.nbytes == 0) ||
 580             ((op->addr.nbytes != 3) && (op->addr.nbytes != 4)))
 581                 return mtk_nor_spi_mem_prg(sp, op);
 582
 583         if (op->data.dir == SPI_MEM_DATA_OUT) {
 584                 mtk_nor_set_addr(sp, op);
 585                 writeb(op->cmd.opcode, sp->base + MTK_NOR_REG_PRGDATA0);
 586                 if (op->data.nbytes == MTK_NOR_PP_SIZE)
 587                         return mtk_nor_pp_buffered(sp, op);
 588                 return mtk_nor_pp_unbuffered(sp, op);
 589         }
 590
 591         if ((op->data.dir == SPI_MEM_DATA_IN) && mtk_nor_match_read(op)) {
 592                 ret = mtk_nor_write_buffer_disable(sp);
 593                 if (ret < 0)
 594                         return ret;
 595                 mtk_nor_setup_bus(sp, op);
 596                 if (op->data.nbytes == 1) {
 597                         mtk_nor_set_addr(sp, op);
 598                         return mtk_nor_read_pio(sp, op);
 599                 } else {
 600                         return mtk_nor_read_dma(sp, op);
 601                 }
 602         }
 603
 604         return mtk_nor_spi_mem_prg(sp, op);
 605 }
 606
 607 static int mtk_nor_setup(struct spi_device *spi)
 608 {
 609         struct mtk_nor *sp = spi_controller_get_devdata(spi->master);
 610
 611         if (spi->max_speed_hz && (spi->max_speed_hz < sp->spi_freq)) {
 612                 dev_err(&spi->dev, "spi clock should be %u Hz.\n",
 613                         sp->spi_freq);
 614                 return -EINVAL;
 615         }
 616         spi->max_speed_hz = sp->spi_freq;
 617
 618         return 0;
 619 }
 620
 621 static int mtk_nor_transfer_one_message(struct spi_controller *master,
 622                                         struct spi_message *m)
 623 {
 624         struct mtk_nor *sp = spi_controller_get_devdata(master);
 625         struct spi_transfer *t = NULL;
 626         unsigned long trx_len = 0;
 627         int stat = 0;
 628         int reg_offset = MTK_NOR_REG_PRGDATA_MAX;
 629         void __iomem *reg;
 630         const u8 *txbuf;
 631         u8 *rxbuf;
 632         int i;
 633
 634         list_for_each_entry(t, &m->transfers, transfer_list) {
 635                 txbuf = t->tx_buf;
 636                 for (i = 0; i < t->len; i++, reg_offset--) {
 637                         reg = sp->base + MTK_NOR_REG_PRGDATA(reg_offset);
 638                         if (txbuf)
 639                                 writeb(txbuf[i], reg);
 640                         else
 641                                 writeb(0, reg);
 642                 }
 643                 trx_len += t->len;
 644         }
 645
 646         writel(trx_len * BITS_PER_BYTE, sp->base + MTK_NOR_REG_PRG_CNT);
 647
 648         stat = mtk_nor_cmd_exec(sp, MTK_NOR_CMD_PROGRAM,
 649                                 trx_len * BITS_PER_BYTE);
 650         if (stat < 0)
 651                 goto msg_done;
 652
 653         reg_offset = trx_len - 1;
 654         list_for_each_entry(t, &m->transfers, transfer_list) {
 655                 rxbuf = t->rx_buf;
 656                 for (i = 0; i < t->len; i++, reg_offset--) {
 657                         reg = sp->base + MTK_NOR_REG_SHIFT(reg_offset);
 658                         if (rxbuf)
 659                                 rxbuf[i] = readb(reg);
 660                 }
 661         }
 662
 663         m->actual_length = trx_len;
 664 msg_done:
 665         m->status = stat;
 666         spi_finalize_current_message(master);
 667
 668         return 0;
 669 }
 670
 671 static void mtk_nor_disable_clk(struct mtk_nor *sp)
 672 {
 673         clk_disable_unprepare(sp->spi_clk);
 674         clk_disable_unprepare(sp->ctlr_clk);
 675 }
 676
 677 static int mtk_nor_enable_clk(struct mtk_nor *sp)
 678 {
 679         int ret;
 680
 681         ret = clk_prepare_enable(sp->spi_clk);
 682         if (ret)
 683                 return ret;
 684
 685         ret = clk_prepare_enable(sp->ctlr_clk);
 686         if (ret) {
 687                 clk_disable_unprepare(sp->spi_clk);
 688                 return ret;
 689         }
 690
 691         return 0;
 692 }
 693
 694 static void mtk_nor_init(struct mtk_nor *sp)
 695 {
 696         writel(0, sp->base + MTK_NOR_REG_IRQ_EN);
 697         writel(MTK_NOR_IRQ_MASK, sp->base + MTK_NOR_REG_IRQ_STAT);
 698
 699         writel(MTK_NOR_ENABLE_SF_CMD, sp->base + MTK_NOR_REG_WP);
 700         mtk_nor_rmw(sp, MTK_NOR_REG_CFG2, MTK_NOR_WR_CUSTOM_OP_EN, 0);
 701         mtk_nor_rmw(sp, MTK_NOR_REG_CFG3,
 702                     MTK_NOR_DISABLE_WREN | MTK_NOR_DISABLE_SR_POLL, 0);
 703 }
 704
 705 static irqreturn_t mtk_nor_irq_handler(int irq, void *data)
 706 {
 707         struct mtk_nor *sp = data;
 708         u32 irq_status, irq_enabled;
 709
 710         irq_status = readl(sp->base + MTK_NOR_REG_IRQ_STAT);
 711         irq_enabled = readl(sp->base + MTK_NOR_REG_IRQ_EN);
 712         // write status back to clear interrupt
 713         writel(irq_status, sp->base + MTK_NOR_REG_IRQ_STAT);
 714
 715         if (!(irq_status & irq_enabled))
 716                 return IRQ_NONE;
 717
 718         if (irq_status & MTK_NOR_IRQ_DMA) {
 719                 complete(&sp->op_done);
 720                 writel(0, sp->base + MTK_NOR_REG_IRQ_EN);
 721         }
 722
 723         return IRQ_HANDLED;
 724 }
 725
 726 static size_t mtk_max_msg_size(struct spi_device *spi)
 727 {
 728         return MTK_NOR_PRG_MAX_SIZE;
 729 }
 730
 731 static const struct spi_controller_mem_ops mtk_nor_mem_ops = {
 732         .adjust_op_size = mtk_nor_adjust_op_size,
 733         .supports_op = mtk_nor_supports_op,
 734         .exec_op = mtk_nor_exec_op
 735 };
 736
 737 static const struct of_device_id mtk_nor_match[] = {
 738         { .compatible = "mediatek,mt8192-nor", .data = (void *)36 },
 739         { .compatible = "mediatek,mt8173-nor", .data = (void *)32 },
 740         { /* sentinel */ }
 741 };
 742 MODULE_DEVICE_TABLE(of, mtk_nor_match);
 743
 744 static int mtk_nor_probe(struct platform_device *pdev)
 745 {
 746         struct spi_controller *ctlr;
 747         struct mtk_nor *sp;
 748         void __iomem *base;
 749         struct clk *spi_clk, *ctlr_clk;
 750         int ret, irq;
 751         unsigned long dma_bits;
 752
 753         base = devm_platform_ioremap_resource(pdev, 0);
 754         if (IS_ERR(base))
 755                 return PTR_ERR(base);
 756
 757         spi_clk = devm_clk_get(&pdev->dev, "spi");
 758         if (IS_ERR(spi_clk))
 759                 return PTR_ERR(spi_clk);
 760
 761         ctlr_clk = devm_clk_get(&pdev->dev, "sf");
 762         if (IS_ERR(ctlr_clk))
 763                 return PTR_ERR(ctlr_clk);
 764
 765         dma_bits = (unsigned long)of_device_get_match_data(&pdev->dev);
 766         if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(dma_bits))) {
 767                 dev_err(&pdev->dev, "failed to set dma mask(%lu)\n", dma_bits);
 768                 return -EINVAL;
 769         }
 770
 771         ctlr = spi_alloc_master(&pdev->dev, sizeof(*sp));
 772         if (!ctlr) {
 773                 dev_err(&pdev->dev, "failed to allocate spi controller\n");
 774                 return -ENOMEM;
 775         }
 776
 777         ctlr->bits_per_word_mask = SPI_BPW_MASK(8);
 778         ctlr->dev.of_node = pdev->dev.of_node;
 779         ctlr->max_message_size = mtk_max_msg_size;
 780         ctlr->mem_ops = &mtk_nor_mem_ops;
 781         ctlr->mode_bits = SPI_RX_DUAL | SPI_RX_QUAD | SPI_TX_DUAL | SPI_TX_QUAD;
 782         ctlr->num_chipselect = 1;
 783         ctlr->setup = mtk_nor_setup;
 784         ctlr->transfer_one_message = mtk_nor_transfer_one_message;
 785         ctlr->auto_runtime_pm = true;
 786
 787         dev_set_drvdata(&pdev->dev, ctlr);
 788
 789         sp = spi_controller_get_devdata(ctlr);
 790         sp->base = base;
 791         sp->has_irq = false;
 792         sp->wbuf_en = false;
 793         sp->ctlr = ctlr;
 794         sp->dev = &pdev->dev;
 795         sp->spi_clk = spi_clk;
 796         sp->ctlr_clk = ctlr_clk;
 797         sp->high_dma = (dma_bits > 32);
 798         sp->buffer = dmam_alloc_coherent(&pdev->dev,
 799                                 MTK_NOR_BOUNCE_BUF_SIZE + MTK_NOR_DMA_ALIGN,
 800                                 &sp->buffer_dma, GFP_KERNEL);
 801         if (!sp->buffer)
 802                 return -ENOMEM;
 803
 804         if ((uintptr_t)sp->buffer & MTK_NOR_DMA_ALIGN_MASK) {
 805                 dev_err(sp->dev, "misaligned allocation of internal buffer.\n");
 806                 return -ENOMEM;
 807         }
 808
 809         ret = mtk_nor_enable_clk(sp);
 810         if (ret < 0)
 811                 return ret;
 812
 813         sp->spi_freq = clk_get_rate(sp->spi_clk);
 814
 815         mtk_nor_init(sp);
 816
 817         irq = platform_get_irq_optional(pdev, 0);
 818
 819         if (irq < 0) {
 820                 dev_warn(sp->dev, "IRQ not available.");
 821         } else {
 822                 ret = devm_request_irq(sp->dev, irq, mtk_nor_irq_handler, 0,
 823                                        pdev->name, sp);
 824                 if (ret < 0) {
 825                         dev_warn(sp->dev, "failed to request IRQ.");
 826                 } else {
 827                         init_completion(&sp->op_done);
 828                         sp->has_irq = true;
 829                 }
 830         }
 831
 832         pm_runtime_set_autosuspend_delay(&pdev->dev, -1);
 833         pm_runtime_use_autosuspend(&pdev->dev);
 834         pm_runtime_set_active(&pdev->dev);
 835         pm_runtime_enable(&pdev->dev);
 836         pm_runtime_get_noresume(&pdev->dev);
 837
 838         ret = devm_spi_register_controller(&pdev->dev, ctlr);
 839         if (ret < 0)
 840                 goto err_probe;
 841
 842         pm_runtime_mark_last_busy(&pdev->dev);
 843         pm_runtime_put_autosuspend(&pdev->dev);
 844
 845         dev_info(&pdev->dev, "spi frequency: %d Hz\n", sp->spi_freq);
 846
 847         return 0;
 848
 849 err_probe:
 850         pm_runtime_disable(&pdev->dev);
 851         pm_runtime_set_suspended(&pdev->dev);
 852         pm_runtime_dont_use_autosuspend(&pdev->dev);
 853
 854         mtk_nor_disable_clk(sp);
 855
 856         return ret;
 857 }
 858
 859 static int mtk_nor_remove(struct platform_device *pdev)
 860 {
 861         struct spi_controller *ctlr = dev_get_drvdata(&pdev->dev);
 862         struct mtk_nor *sp = spi_controller_get_devdata(ctlr);
 863
 864         pm_runtime_disable(&pdev->dev);
 865         pm_runtime_set_suspended(&pdev->dev);
 866         pm_runtime_dont_use_autosuspend(&pdev->dev);
 867
 868         mtk_nor_disable_clk(sp);
 869
 870         return 0;
 871 }
 872
 873 static int __maybe_unused mtk_nor_runtime_suspend(struct device *dev)
 874 {
 875         struct spi_controller *ctlr = dev_get_drvdata(dev);
 876         struct mtk_nor *sp = spi_controller_get_devdata(ctlr);
 877
 878         mtk_nor_disable_clk(sp);
 879
 880         return 0;
 881 }
 882
 883 static int __maybe_unused mtk_nor_runtime_resume(struct device *dev)
 884 {
 885         struct spi_controller *ctlr = dev_get_drvdata(dev);
 886         struct mtk_nor *sp = spi_controller_get_devdata(ctlr);
 887
 888         return mtk_nor_enable_clk(sp);
 889 }
 890
 891 static int __maybe_unused mtk_nor_suspend(struct device *dev)
 892 {
 893         return pm_runtime_force_suspend(dev);
 894 }
 895
 896 static int __maybe_unused mtk_nor_resume(struct device *dev)
 897 {
 898         return pm_runtime_force_resume(dev);
 899 }
 900
 901 static const struct dev_pm_ops mtk_nor_pm_ops = {
 902         SET_RUNTIME_PM_OPS(mtk_nor_runtime_suspend,
 903                            mtk_nor_runtime_resume, NULL)
 904         SET_SYSTEM_SLEEP_PM_OPS(mtk_nor_suspend, mtk_nor_resume)
 905 };
 906
 907 static struct platform_driver mtk_nor_driver = {
 908         .driver = {
 909                 .name = DRIVER_NAME,
 910                 .of_match_table = mtk_nor_match,
 911                 .pm = &mtk_nor_pm_ops,
 912         },
 913         .probe = mtk_nor_probe,
 914         .remove = mtk_nor_remove,
 915 };
 916
 917 module_platform_driver(mtk_nor_driver);
 918
 919 MODULE_DESCRIPTION("Mediatek SPI NOR controller driver");
 920 MODULE_AUTHOR("Chuanhong Guo <gch981213@gmail.com>");
 921 MODULE_LICENSE("GPL v2");
 922 MODULE_ALIAS("platform:" DRIVER_NAME);