drivers/spi/mtk_snor.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Mediatek SPI-NOR controller driver
   4 //
   5 // Copyright (C) 2020 SkyLake Huang <SkyLake.Huang@mediatek.com>
   6 //
   7 // Some parts are based on drivers/spi/spi-mtk-nor.c of linux version
   8
   9 #include <clk.h>
  10 #include <common.h>
  11 #include <cpu_func.h>
  12 #include <dm.h>
  13 #include <dm/device.h>
  14 #include <dm/device_compat.h>
  15 #include <dm/devres.h>
  16 #include <dm/pinctrl.h>
  17 #include <linux/bitops.h>
  18 #include <linux/completion.h>
  19 #include <linux/io.h>
  20 #include <linux/iopoll.h>
  21 #include <spi.h>
  22 #include <spi-mem.h>
  23 #include <stdbool.h>
  24 #include <watchdog.h>
  25 #include <linux/dma-mapping.h>
  26
  27 #define DRIVER_NAME "mtk-spi-nor"
  28
  29 #define MTK_NOR_REG_CMD 0x00
  30 #define MTK_NOR_CMD_WRSR BIT(5)
  31 #define MTK_NOR_CMD_WRITE BIT(4)
  32 #define MTK_NOR_CMD_PROGRAM BIT(2)
  33 #define MTK_NOR_CMD_RDSR BIT(1)
  34 #define MTK_NOR_CMD_READ BIT(0)
  35 #define MTK_NOR_CMD_MASK GENMASK(5, 0)
  36
  37 #define MTK_NOR_REG_PRG_CNT 0x04
  38 #define MTK_NOR_REG_RDSR 0x08
  39 #define MTK_NOR_REG_RDATA 0x0c
  40
  41 #define MTK_NOR_REG_RADR0 0x10
  42 #define MTK_NOR_REG_RADR(n) (MTK_NOR_REG_RADR0 + 4 * (n))
  43 #define MTK_NOR_REG_RADR3 0xc8
  44
  45 #define MTK_NOR_REG_WDATA 0x1c
  46
  47 #define MTK_NOR_REG_PRGDATA0 0x20
  48 #define MTK_NOR_REG_PRGDATA(n) (MTK_NOR_REG_PRGDATA0 + 4 * (n))
  49 #define MTK_NOR_REG_PRGDATA_MAX 5
  50
  51 #define MTK_NOR_REG_SHIFT0 0x38
  52 #define MTK_NOR_REG_SHIFT(n) (MTK_NOR_REG_SHIFT0 + 4 * (n))
  53 #define MTK_NOR_REG_SHIFT_MAX 9
  54
  55 #define MTK_NOR_REG_CFG1 0x60
  56 #define MTK_NOR_FAST_READ BIT(0)
  57
  58 #define MTK_NOR_REG_CFG2 0x64
  59 #define MTK_NOR_WR_CUSTOM_OP_EN BIT(4)
  60 #define MTK_NOR_WR_BUF_EN BIT(0)
  61
  62 #define MTK_NOR_REG_PP_DATA 0x98
  63
  64 #define MTK_NOR_REG_IRQ_STAT 0xa8
  65 #define MTK_NOR_REG_IRQ_EN 0xac
  66 #define MTK_NOR_IRQ_DMA BIT(7)
  67 #define MTK_NOR_IRQ_WRSR BIT(5)
  68 #define MTK_NOR_IRQ_MASK GENMASK(7, 0)
  69
  70 #define MTK_NOR_REG_CFG3 0xb4
  71 #define MTK_NOR_DISABLE_WREN BIT(7)
  72 #define MTK_NOR_DISABLE_SR_POLL BIT(5)
  73
  74 #define MTK_NOR_REG_WP 0xc4
  75 #define MTK_NOR_ENABLE_SF_CMD 0x30
  76
  77 #define MTK_NOR_REG_BUSCFG 0xcc
  78 #define MTK_NOR_4B_ADDR BIT(4)
  79 #define MTK_NOR_QUAD_ADDR BIT(3)
  80 #define MTK_NOR_QUAD_READ BIT(2)
  81 #define MTK_NOR_DUAL_ADDR BIT(1)
  82 #define MTK_NOR_DUAL_READ BIT(0)
  83 #define MTK_NOR_BUS_MODE_MASK GENMASK(4, 0)
  84
  85 #define MTK_NOR_REG_DMA_CTL 0x718
  86 #define MTK_NOR_DMA_START BIT(0)
  87
  88 #define MTK_NOR_REG_DMA_FADR 0x71c
  89 #define MTK_NOR_REG_DMA_DADR 0x720
  90 #define MTK_NOR_REG_DMA_END_DADR 0x724
  91
  92 #define MTK_NOR_PRG_MAX_SIZE 6
  93 // Reading DMA src/dst addresses have to be 16-byte aligned
  94 #define MTK_NOR_DMA_ALIGN 16
  95 #define MTK_NOR_DMA_ALIGN_MASK (MTK_NOR_DMA_ALIGN - 1)
  96 // and we allocate a bounce buffer if destination address isn't aligned.
  97 #define MTK_NOR_BOUNCE_BUF_SIZE PAGE_SIZE
  98
  99 // Buffered page program can do one 128-byte transfer
 100 #define MTK_NOR_PP_SIZE 128
 101
 102 #define CLK_TO_US(priv, clkcnt) DIV_ROUND_UP(clkcnt, (priv)->spi_freq / 1000000)
 103
 104 #define MTK_NOR_UNLOCK_ALL 0x0
 105
 106 struct mtk_snor_priv {
 107         struct device *dev;
 108         void __iomem *base;
 109         u8 *buffer;
 110         struct clk spi_clk;
 111         struct clk ctlr_clk;
 112         unsigned int spi_freq;
 113         bool wbuf_en;
 114 };
 115
 116 static inline void mtk_snor_rmw(struct mtk_snor_priv *priv, u32 reg, u32 set,
 117                                 u32 clr)
 118 {
 119         u32 val = readl(priv->base + reg);
 120
 121         val &= ~clr;
 122         val |= set;
 123         writel(val, priv->base + reg);
 124 }
 125
 126 static inline int mtk_snor_cmd_exec(struct mtk_snor_priv *priv, u32 cmd,
 127                                     ulong clk)
 128 {
 129         unsigned long long delay = CLK_TO_US(priv, clk);
 130         u32 reg;
 131         int ret;
 132
 133         writel(cmd, priv->base + MTK_NOR_REG_CMD);
 134         delay = (delay + 1) * 200;
 135         ret = readl_poll_timeout(priv->base + MTK_NOR_REG_CMD, reg,
 136                                  !(reg & cmd), delay);
 137         if (ret < 0)
 138                 dev_err(priv->dev, "command %u timeout.\n", cmd);
 139         return ret;
 140 }
 141
 142 static void mtk_snor_set_addr(struct mtk_snor_priv *priv,
 143                               const struct spi_mem_op *op)
 144 {
 145         u32 addr = op->addr.val;
 146         int i;
 147
 148         for (i = 0; i < 3; i++) {
 149                 writeb(addr & 0xff, priv->base + MTK_NOR_REG_RADR(i));
 150                 addr >>= 8;
 151         }
 152         if (op->addr.nbytes == 4) {
 153                 writeb(addr & 0xff, priv->base + MTK_NOR_REG_RADR3);
 154                 mtk_snor_rmw(priv, MTK_NOR_REG_BUSCFG, MTK_NOR_4B_ADDR, 0);
 155         } else {
 156                 mtk_snor_rmw(priv, MTK_NOR_REG_BUSCFG, 0, MTK_NOR_4B_ADDR);
 157         }
 158 }
 159
 160 static bool need_bounce(const struct spi_mem_op *op)
 161 {
 162         return ((uintptr_t)op->data.buf.in & MTK_NOR_DMA_ALIGN_MASK);
 163 }
 164
 165 static int mtk_snor_adjust_op_size(struct spi_slave *slave,
 166                                    struct spi_mem_op *op)
 167 {
 168         if (!op->data.nbytes)
 169                 return 0;
 170
 171         if (op->addr.nbytes == 3 || op->addr.nbytes == 4) {
 172                 if (op->data.dir == SPI_MEM_DATA_IN) { //&&
 173                         // limit size to prevent timeout calculation overflow
 174                         if (op->data.nbytes > 0x400000)
 175                                 op->data.nbytes = 0x400000;
 176                         if (op->addr.val & MTK_NOR_DMA_ALIGN_MASK ||
 177                             op->data.nbytes < MTK_NOR_DMA_ALIGN)
 178                                 op->data.nbytes = 1;
 179                         else if (!need_bounce(op))
 180                                 op->data.nbytes &= ~MTK_NOR_DMA_ALIGN_MASK;
 181                         else if (op->data.nbytes > MTK_NOR_BOUNCE_BUF_SIZE)
 182                                 op->data.nbytes = MTK_NOR_BOUNCE_BUF_SIZE;
 183                         return 0;
 184                 } else if (op->data.dir == SPI_MEM_DATA_OUT) {
 185                         if (op->data.nbytes >= MTK_NOR_PP_SIZE)
 186                                 op->data.nbytes = MTK_NOR_PP_SIZE;
 187                         else
 188                                 op->data.nbytes = 1;
 189                         return 0;
 190                 }
 191         }
 192
 193         return 0;
 194 }
 195
 196 static bool mtk_snor_supports_op(struct spi_slave *slave,
 197                                  const struct spi_mem_op *op)
 198 {
 199         /* This controller only supports 1-1-1 write mode */
 200         if (op->data.dir == SPI_MEM_DATA_OUT &&
 201             (op->cmd.buswidth != 1 || op->data.buswidth != 1))
 202                 return false;
 203
 204         return true;
 205 }
 206
 207 static void mtk_snor_setup_bus(struct mtk_snor_priv *priv,
 208                                const struct spi_mem_op *op)
 209 {
 210         u32 reg = 0;
 211
 212         if (op->addr.nbytes == 4)
 213                 reg |= MTK_NOR_4B_ADDR;
 214
 215         if (op->data.buswidth == 4) {
 216                 reg |= MTK_NOR_QUAD_READ;
 217                 writeb(op->cmd.opcode, priv->base + MTK_NOR_REG_PRGDATA(4));
 218                 if (op->addr.buswidth == 4)
 219                         reg |= MTK_NOR_QUAD_ADDR;
 220         } else if (op->data.buswidth == 2) {
 221                 reg |= MTK_NOR_DUAL_READ;
 222                 writeb(op->cmd.opcode, priv->base + MTK_NOR_REG_PRGDATA(3));
 223                 if (op->addr.buswidth == 2)
 224                         reg |= MTK_NOR_DUAL_ADDR;
 225         } else {
 226                 if (op->cmd.opcode == 0x0b)
 227                         mtk_snor_rmw(priv, MTK_NOR_REG_CFG1, MTK_NOR_FAST_READ,
 228                                      0);
 229                 else
 230                         mtk_snor_rmw(priv, MTK_NOR_REG_CFG1, 0,
 231                                      MTK_NOR_FAST_READ);
 232         }
 233         mtk_snor_rmw(priv, MTK_NOR_REG_BUSCFG, reg, MTK_NOR_BUS_MODE_MASK);
 234 }
 235
 236 static int mtk_snor_dma_exec(struct mtk_snor_priv *priv, u32 from,
 237                              unsigned int length, dma_addr_t dma_addr)
 238 {
 239         int ret = 0;
 240         ulong delay;
 241         u32 reg;
 242
 243         writel(from, priv->base + MTK_NOR_REG_DMA_FADR);
 244         writel(dma_addr, priv->base + MTK_NOR_REG_DMA_DADR);
 245         writel(dma_addr + length, priv->base + MTK_NOR_REG_DMA_END_DADR);
 246
 247         mtk_snor_rmw(priv, MTK_NOR_REG_DMA_CTL, MTK_NOR_DMA_START, 0);
 248
 249         delay = CLK_TO_US(priv, (length + 5) * BITS_PER_BYTE);
 250
 251         delay = (delay + 1) * 100;
 252         ret = readl_poll_timeout(priv->base + MTK_NOR_REG_DMA_CTL, reg,
 253                                  !(reg & MTK_NOR_DMA_START), delay);
 254
 255         if (ret < 0)
 256                 dev_err(priv->dev, "dma read timeout.\n");
 257
 258         return ret;
 259 }
 260
 261 static int mtk_snor_read_bounce(struct mtk_snor_priv *priv,
 262                                 const struct spi_mem_op *op)
 263 {
 264         unsigned int rdlen;
 265         int ret;
 266
 267         if (op->data.nbytes & MTK_NOR_DMA_ALIGN_MASK)
 268                 rdlen = (op->data.nbytes + MTK_NOR_DMA_ALIGN) &
 269                         ~MTK_NOR_DMA_ALIGN_MASK;
 270         else
 271                 rdlen = op->data.nbytes;
 272
 273         ret = mtk_snor_dma_exec(priv, op->addr.val, rdlen,
 274                                 (dma_addr_t)priv->buffer);
 275
 276         if (!ret)
 277                 memcpy(op->data.buf.in, priv->buffer, op->data.nbytes);
 278
 279         return ret;
 280 }
 281
 282 static int mtk_snor_read_dma(struct mtk_snor_priv *priv,
 283                              const struct spi_mem_op *op)
 284 {
 285         int ret;
 286         dma_addr_t dma_addr;
 287
 288         if (need_bounce(op))
 289                 return mtk_snor_read_bounce(priv, op);
 290
 291         dma_addr = dma_map_single(op->data.buf.in, op->data.nbytes,
 292                                   DMA_FROM_DEVICE);
 293
 294         if (dma_mapping_error(priv->dev, dma_addr))
 295                 return -EINVAL;
 296
 297         ret = mtk_snor_dma_exec(priv, op->addr.val, op->data.nbytes, dma_addr);
 298
 299         dma_unmap_single(dma_addr, op->data.nbytes, DMA_FROM_DEVICE);
 300
 301         return ret;
 302 }
 303
 304 static int mtk_snor_read_pio(struct mtk_snor_priv *priv,
 305                              const struct spi_mem_op *op)
 306 {
 307         u8 *buf = op->data.buf.in;
 308         int ret;
 309
 310         ret = mtk_snor_cmd_exec(priv, MTK_NOR_CMD_READ, 6 * BITS_PER_BYTE);
 311         if (!ret)
 312                 buf[0] = readb(priv->base + MTK_NOR_REG_RDATA);
 313         return ret;
 314 }
 315
 316 static int mtk_snor_write_buffer_enable(struct mtk_snor_priv *priv)
 317 {
 318         int ret;
 319         u32 val;
 320
 321         if (priv->wbuf_en)
 322                 return 0;
 323
 324         val = readl(priv->base + MTK_NOR_REG_CFG2);
 325         writel(val | MTK_NOR_WR_BUF_EN, priv->base + MTK_NOR_REG_CFG2);
 326         ret = readl_poll_timeout(priv->base + MTK_NOR_REG_CFG2, val,
 327                                  val & MTK_NOR_WR_BUF_EN, 10000);
 328         if (!ret)
 329                 priv->wbuf_en = true;
 330         return ret;
 331 }
 332
 333 static int mtk_snor_write_buffer_disable(struct mtk_snor_priv *priv)
 334 {
 335         int ret;
 336         u32 val;
 337
 338         if (!priv->wbuf_en)
 339                 return 0;
 340         val = readl(priv->base + MTK_NOR_REG_CFG2);
 341         writel(val & ~MTK_NOR_WR_BUF_EN, priv->base + MTK_NOR_REG_CFG2);
 342         ret = readl_poll_timeout(priv->base + MTK_NOR_REG_CFG2, val,
 343                                  !(val & MTK_NOR_WR_BUF_EN), 10000);
 344         if (!ret)
 345                 priv->wbuf_en = false;
 346         return ret;
 347 }
 348
 349 static int mtk_snor_pp_buffered(struct mtk_snor_priv *priv,
 350                                 const struct spi_mem_op *op)
 351 {
 352         const u8 *buf = op->data.buf.out;
 353         u32 val;
 354         int ret, i;
 355
 356         ret = mtk_snor_write_buffer_enable(priv);
 357         if (ret < 0)
 358                 return ret;
 359
 360         for (i = 0; i < op->data.nbytes; i += 4) {
 361                 val = buf[i + 3] << 24 | buf[i + 2] << 16 | buf[i + 1] << 8 |
 362                       buf[i];
 363                 writel(val, priv->base + MTK_NOR_REG_PP_DATA);
 364         }
 365         mtk_snor_cmd_exec(priv, MTK_NOR_CMD_WRITE,
 366                           (op->data.nbytes + 5) * BITS_PER_BYTE);
 367         return mtk_snor_write_buffer_disable(priv);
 368 }
 369
 370 static int mtk_snor_pp_unbuffered(struct mtk_snor_priv *priv,
 371                                   const struct spi_mem_op *op)
 372 {
 373         const u8 *buf = op->data.buf.out;
 374         int ret;
 375
 376         ret = mtk_snor_write_buffer_disable(priv);
 377         if (ret < 0)
 378                 return ret;
 379         writeb(buf[0], priv->base + MTK_NOR_REG_WDATA);
 380         return mtk_snor_cmd_exec(priv, MTK_NOR_CMD_WRITE, 6 * BITS_PER_BYTE);
 381 }
 382
 383 static int mtk_snor_cmd_program(struct mtk_snor_priv *priv,
 384                                 const struct spi_mem_op *op)
 385 {
 386         u32 tx_len = 0;
 387         u32 trx_len = 0;
 388         int reg_offset = MTK_NOR_REG_PRGDATA_MAX;
 389         void __iomem *reg;
 390         u8 *txbuf;
 391         int tx_cnt = 0;
 392         u8 *rxbuf = op->data.buf.in;
 393         int i = 0;
 394
 395         tx_len = 1 + op->addr.nbytes + op->dummy.nbytes;
 396         trx_len = tx_len + op->data.nbytes;
 397         if (op->data.dir == SPI_MEM_DATA_OUT)
 398                 tx_len += op->data.nbytes;
 399
 400         txbuf = kmalloc_array(tx_len, sizeof(u8), GFP_KERNEL);
 401         memset(txbuf, 0x0, tx_len * sizeof(u8));
 402
 403         /* Join all bytes to be transferred */
 404         txbuf[tx_cnt] = op->cmd.opcode;
 405         tx_cnt++;
 406         for (i = op->addr.nbytes; i > 0; i--, tx_cnt++)
 407                 txbuf[tx_cnt] = ((u8 *)&op->addr.val)[i - 1];
 408         for (i = op->dummy.nbytes; i > 0; i--, tx_cnt++)
 409                 txbuf[tx_cnt] = 0x0;
 410         if (op->data.dir == SPI_MEM_DATA_OUT)
 411                 for (i = op->data.nbytes; i > 0; i--, tx_cnt++)
 412                         txbuf[tx_cnt] = ((u8 *)op->data.buf.out)[i - 1];
 413
 414         for (i = MTK_NOR_REG_PRGDATA_MAX; i >= 0; i--)
 415                 writeb(0, priv->base + MTK_NOR_REG_PRGDATA(i));
 416
 417         for (i = 0; i < tx_len; i++, reg_offset--)
 418                 writeb(txbuf[i], priv->base + MTK_NOR_REG_PRGDATA(reg_offset));
 419
 420         kfree(txbuf);
 421
 422         writel(trx_len * BITS_PER_BYTE, priv->base + MTK_NOR_REG_PRG_CNT);
 423
 424         mtk_snor_cmd_exec(priv, MTK_NOR_CMD_PROGRAM, trx_len * BITS_PER_BYTE);
 425
 426         reg_offset = op->data.nbytes - 1;
 427         for (i = 0; i < op->data.nbytes; i++, reg_offset--) {
 428                 reg = priv->base + MTK_NOR_REG_SHIFT(reg_offset);
 429                 rxbuf[i] = readb(reg);
 430         }
 431
 432         return 0;
 433 }
 434
 435 static int mtk_snor_exec_op(struct spi_slave *slave,
 436                             const struct spi_mem_op *op)
 437 {
 438         struct udevice *bus = dev_get_parent(slave->dev);
 439         struct mtk_snor_priv *priv = dev_get_priv(bus);
 440         int ret;
 441
 442         if (op->data.dir == SPI_MEM_NO_DATA || op->addr.nbytes == 0) {
 443                 return mtk_snor_cmd_program(priv, op);
 444         } else if (op->data.dir == SPI_MEM_DATA_OUT) {
 445                 mtk_snor_set_addr(priv, op);
 446                 writeb(op->cmd.opcode, priv->base + MTK_NOR_REG_PRGDATA0);
 447                 if (op->data.nbytes == MTK_NOR_PP_SIZE)
 448                         return mtk_snor_pp_buffered(priv, op);
 449                 return mtk_snor_pp_unbuffered(priv, op);
 450         } else if (op->data.dir == SPI_MEM_DATA_IN) {
 451                 ret = mtk_snor_write_buffer_disable(priv);
 452                 if (ret < 0)
 453                         return ret;
 454                 mtk_snor_setup_bus(priv, op);
 455                 if (op->data.nbytes == 1) {
 456                         mtk_snor_set_addr(priv, op);
 457                         return mtk_snor_read_pio(priv, op);
 458                 } else {
 459                         return mtk_snor_read_dma(priv, op);
 460                 }
 461         }
 462
 463         return -ENOTSUPP;
 464 }
 465
 466 static int mtk_snor_probe(struct udevice *bus)
 467 {
 468         struct mtk_snor_priv *priv = dev_get_priv(bus);
 469         u8 *buffer;
 470         int ret;
 471         u32 reg;
 472
 473         priv->base = (void __iomem *)devfdt_get_addr(bus);
 474         if (!priv->base)
 475                 return -EINVAL;
 476
 477         ret = clk_get_by_name(bus, "spi", &priv->spi_clk);
 478         if (ret < 0)
 479                 return ret;
 480
 481         ret = clk_get_by_name(bus, "sf", &priv->ctlr_clk);
 482         if (ret < 0)
 483                 return ret;
 484
 485         buffer = devm_kmalloc(bus, MTK_NOR_BOUNCE_BUF_SIZE + MTK_NOR_DMA_ALIGN,
 486                               GFP_KERNEL);
 487         if (!buffer)
 488                 return -ENOMEM;
 489         if ((ulong)buffer & MTK_NOR_DMA_ALIGN_MASK)
 490                 buffer = (u8 *)(((ulong)buffer + MTK_NOR_DMA_ALIGN) &
 491                                 ~MTK_NOR_DMA_ALIGN_MASK);
 492         priv->buffer = buffer;
 493
 494         clk_enable(&priv->spi_clk);
 495         clk_enable(&priv->ctlr_clk);
 496
 497         priv->spi_freq = clk_get_rate(&priv->spi_clk);
 498         printf("spi frequency: %d Hz\n", priv->spi_freq);
 499
 500         /* With this setting, we issue one command at a time to
 501          * accommodate to SPI-mem framework.
 502          */
 503         writel(MTK_NOR_ENABLE_SF_CMD, priv->base + MTK_NOR_REG_WP);
 504         mtk_snor_rmw(priv, MTK_NOR_REG_CFG2, MTK_NOR_WR_CUSTOM_OP_EN, 0);
 505         mtk_snor_rmw(priv, MTK_NOR_REG_CFG3,
 506                      MTK_NOR_DISABLE_WREN | MTK_NOR_DISABLE_SR_POLL, 0);
 507
 508         /* Unlock all blocks using write status command.
 509          * SPI-MEM hasn't implemented unlock procedure on MXIC devices.
 510          * We may remove this later.
 511          */
 512         writel(2 * BITS_PER_BYTE, priv->base + MTK_NOR_REG_PRG_CNT);
 513         writel(MTK_NOR_UNLOCK_ALL, priv->base + MTK_NOR_REG_PRGDATA(5));
 514         writel(MTK_NOR_IRQ_WRSR, priv->base + MTK_NOR_REG_IRQ_EN);
 515         writel(MTK_NOR_CMD_WRSR, priv->base + MTK_NOR_REG_CMD);
 516         ret = readl_poll_timeout(priv->base + MTK_NOR_REG_IRQ_STAT, reg,
 517                                  !(reg & MTK_NOR_IRQ_WRSR),
 518                                  ((3 * BITS_PER_BYTE) + 1) * 200);
 519
 520         return 0;
 521 }
 522
 523 static int mtk_snor_set_speed(struct udevice *bus, uint speed)
 524 {
 525         /* MTK's SNOR controller does not have a bus clock divider.
 526          * We setup maximum bus clock in dts.
 527          */
 528
 529         return 0;
 530 }
 531
 532 static int mtk_snor_set_mode(struct udevice *bus, uint mode)
 533 {
 534         /* We set up mode later for each transmission.
 535          */
 536         return 0;
 537 }
 538
 539 static const struct spi_controller_mem_ops mtk_snor_mem_ops = {
 540         .adjust_op_size = mtk_snor_adjust_op_size,
 541         .supports_op = mtk_snor_supports_op,
 542         .exec_op = mtk_snor_exec_op
 543 };
 544
 545 static const struct dm_spi_ops mtk_snor_ops = {
 546         .mem_ops = &mtk_snor_mem_ops,
 547         .set_speed = mtk_snor_set_speed,
 548         .set_mode = mtk_snor_set_mode,
 549 };
 550
 551 static const struct udevice_id mtk_snor_ids[] = {
 552         { .compatible = "mediatek,mtk-snor" },
 553         {}
 554 };
 555
 556 U_BOOT_DRIVER(mtk_snor) = {
 557         .name = "mtk_snor",
 558         .id = UCLASS_SPI,
 559         .of_match = mtk_snor_ids,
 560         .ops = &mtk_snor_ops,
 561         .priv_auto = sizeof(struct mtk_snor_priv),
 562         .probe = mtk_snor_probe,
 563 };