drivers/spi/cadence_qspi_apb.c

   1 /*
   2  * Copyright (C) 2012 Altera Corporation <www.altera.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *  - Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  *  - Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *  - Neither the name of the Altera Corporation nor the
  13  *    names of its contributors may be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL ALTERA CORPORATION BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <common.h>
  29 #include <log.h>
  30 #include <asm/io.h>
  31 #include <dma.h>
  32 #include <linux/bitops.h>
  33 #include <linux/delay.h>
  34 #include <linux/errno.h>
  35 #include <wait_bit.h>
  36 #include <spi.h>
  37 #include <spi-mem.h>
  38 #include <malloc.h>
  39 #include "cadence_qspi.h"
  40
  41 __weak void cadence_qspi_apb_enable_linear_mode(bool enable)
  42 {
  43         return;
  44 }
  45
  46 void cadence_qspi_apb_controller_enable(void *reg_base)
  47 {
  48         unsigned int reg;
  49         reg = readl(reg_base + CQSPI_REG_CONFIG);
  50         reg |= CQSPI_REG_CONFIG_ENABLE;
  51         writel(reg, reg_base + CQSPI_REG_CONFIG);
  52 }
  53
  54 void cadence_qspi_apb_controller_disable(void *reg_base)
  55 {
  56         unsigned int reg;
  57         reg = readl(reg_base + CQSPI_REG_CONFIG);
  58         reg &= ~CQSPI_REG_CONFIG_ENABLE;
  59         writel(reg, reg_base + CQSPI_REG_CONFIG);
  60 }
  61
  62 void cadence_qspi_apb_dac_mode_enable(void *reg_base)
  63 {
  64         unsigned int reg;
  65
  66         reg = readl(reg_base + CQSPI_REG_CONFIG);
  67         reg |= CQSPI_REG_CONFIG_DIRECT;
  68         writel(reg, reg_base + CQSPI_REG_CONFIG);
  69 }
  70
  71 static unsigned int cadence_qspi_calc_dummy(const struct spi_mem_op *op,
  72                                             bool dtr)
  73 {
  74         unsigned int dummy_clk;
  75
  76         if (!op->dummy.nbytes || !op->dummy.buswidth)
  77                 return 0;
  78
  79         dummy_clk = op->dummy.nbytes * (8 / op->dummy.buswidth);
  80         if (dtr)
  81                 dummy_clk /= 2;
  82
  83         return dummy_clk;
  84 }
  85
  86 static u32 cadence_qspi_calc_rdreg(struct cadence_spi_priv *priv)
  87 {
  88         u32 rdreg = 0;
  89
  90         rdreg |= priv->inst_width << CQSPI_REG_RD_INSTR_TYPE_INSTR_LSB;
  91         rdreg |= priv->addr_width << CQSPI_REG_RD_INSTR_TYPE_ADDR_LSB;
  92         rdreg |= priv->data_width << CQSPI_REG_RD_INSTR_TYPE_DATA_LSB;
  93
  94         return rdreg;
  95 }
  96
  97 static int cadence_qspi_buswidth_to_inst_type(u8 buswidth)
  98 {
  99         switch (buswidth) {
 100         case 0:
 101         case 1:
 102                 return CQSPI_INST_TYPE_SINGLE;
 103
 104         case 2:
 105                 return CQSPI_INST_TYPE_DUAL;
 106
 107         case 4:
 108                 return CQSPI_INST_TYPE_QUAD;
 109
 110         case 8:
 111                 return CQSPI_INST_TYPE_OCTAL;
 112
 113         default:
 114                 return -ENOTSUPP;
 115         }
 116 }
 117
 118 static int cadence_qspi_set_protocol(struct cadence_spi_priv *priv,
 119                                      const struct spi_mem_op *op)
 120 {
 121         int ret;
 122
 123         priv->dtr = op->data.dtr && op->cmd.dtr && op->addr.dtr;
 124
 125         ret = cadence_qspi_buswidth_to_inst_type(op->cmd.buswidth);
 126         if (ret < 0)
 127                 return ret;
 128         priv->inst_width = ret;
 129
 130         ret = cadence_qspi_buswidth_to_inst_type(op->addr.buswidth);
 131         if (ret < 0)
 132                 return ret;
 133         priv->addr_width = ret;
 134
 135         ret = cadence_qspi_buswidth_to_inst_type(op->data.buswidth);
 136         if (ret < 0)
 137                 return ret;
 138         priv->data_width = ret;
 139
 140         return 0;
 141 }
 142
 143 /* Return 1 if idle, otherwise return 0 (busy). */
 144 static unsigned int cadence_qspi_wait_idle(void *reg_base)
 145 {
 146         unsigned int start, count = 0;
 147         /* timeout in unit of ms */
 148         unsigned int timeout = 5000;
 149
 150         start = get_timer(0);
 151         for ( ; get_timer(start) < timeout ; ) {
 152                 if (CQSPI_REG_IS_IDLE(reg_base))
 153                         count++;
 154                 else
 155                         count = 0;
 156                 /*
 157                  * Ensure the QSPI controller is in true idle state after
 158                  * reading back the same idle status consecutively
 159                  */
 160                 if (count >= CQSPI_POLL_IDLE_RETRY)
 161                         return 1;
 162         }
 163
 164         /* Timeout, still in busy mode. */
 165         printf("QSPI: QSPI is still busy after poll for %d times.\n",
 166                CQSPI_REG_RETRY);
 167         return 0;
 168 }
 169
 170 void cadence_qspi_apb_readdata_capture(void *reg_base,
 171                                 unsigned int bypass, unsigned int delay)
 172 {
 173         unsigned int reg;
 174         cadence_qspi_apb_controller_disable(reg_base);
 175
 176         reg = readl(reg_base + CQSPI_REG_RD_DATA_CAPTURE);
 177
 178         if (bypass)
 179                 reg |= CQSPI_REG_RD_DATA_CAPTURE_BYPASS;
 180         else
 181                 reg &= ~CQSPI_REG_RD_DATA_CAPTURE_BYPASS;
 182
 183         reg &= ~(CQSPI_REG_RD_DATA_CAPTURE_DELAY_MASK
 184                 << CQSPI_REG_RD_DATA_CAPTURE_DELAY_LSB);
 185
 186         reg |= (delay & CQSPI_REG_RD_DATA_CAPTURE_DELAY_MASK)
 187                 << CQSPI_REG_RD_DATA_CAPTURE_DELAY_LSB;
 188
 189         writel(reg, reg_base + CQSPI_REG_RD_DATA_CAPTURE);
 190
 191         cadence_qspi_apb_controller_enable(reg_base);
 192 }
 193
 194 void cadence_qspi_apb_config_baudrate_div(void *reg_base,
 195         unsigned int ref_clk_hz, unsigned int sclk_hz)
 196 {
 197         unsigned int reg;
 198         unsigned int div;
 199
 200         cadence_qspi_apb_controller_disable(reg_base);
 201         reg = readl(reg_base + CQSPI_REG_CONFIG);
 202         reg &= ~(CQSPI_REG_CONFIG_BAUD_MASK << CQSPI_REG_CONFIG_BAUD_LSB);
 203
 204         /*
 205          * The baud_div field in the config reg is 4 bits, and the ref clock is
 206          * divided by 2 * (baud_div + 1). Round up the divider to ensure the
 207          * SPI clock rate is less than or equal to the requested clock rate.
 208          */
 209         div = DIV_ROUND_UP(ref_clk_hz, sclk_hz * 2) - 1;
 210
 211         /* ensure the baud rate doesn't exceed the max value */
 212         if (div > CQSPI_REG_CONFIG_BAUD_MASK)
 213                 div = CQSPI_REG_CONFIG_BAUD_MASK;
 214
 215         debug("%s: ref_clk %dHz sclk %dHz Div 0x%x, actual %dHz\n", __func__,
 216               ref_clk_hz, sclk_hz, div, ref_clk_hz / (2 * (div + 1)));
 217
 218         reg |= (div << CQSPI_REG_CONFIG_BAUD_LSB);
 219         writel(reg, reg_base + CQSPI_REG_CONFIG);
 220
 221         cadence_qspi_apb_controller_enable(reg_base);
 222 }
 223
 224 void cadence_qspi_apb_set_clk_mode(void *reg_base, uint mode)
 225 {
 226         unsigned int reg;
 227
 228         cadence_qspi_apb_controller_disable(reg_base);
 229         reg = readl(reg_base + CQSPI_REG_CONFIG);
 230         reg &= ~(CQSPI_REG_CONFIG_CLK_POL | CQSPI_REG_CONFIG_CLK_PHA);
 231
 232         if (mode & SPI_CPOL)
 233                 reg |= CQSPI_REG_CONFIG_CLK_POL;
 234         if (mode & SPI_CPHA)
 235                 reg |= CQSPI_REG_CONFIG_CLK_PHA;
 236
 237         writel(reg, reg_base + CQSPI_REG_CONFIG);
 238
 239         cadence_qspi_apb_controller_enable(reg_base);
 240 }
 241
 242 void cadence_qspi_apb_chipselect(void *reg_base,
 243         unsigned int chip_select, unsigned int decoder_enable)
 244 {
 245         unsigned int reg;
 246
 247         cadence_qspi_apb_controller_disable(reg_base);
 248
 249         debug("%s : chipselect %d decode %d\n", __func__, chip_select,
 250               decoder_enable);
 251
 252         reg = readl(reg_base + CQSPI_REG_CONFIG);
 253         /* docoder */
 254         if (decoder_enable) {
 255                 reg |= CQSPI_REG_CONFIG_DECODE;
 256         } else {
 257                 reg &= ~CQSPI_REG_CONFIG_DECODE;
 258                 /* Convert CS if without decoder.
 259                  * CS0 to 4b'1110
 260                  * CS1 to 4b'1101
 261                  * CS2 to 4b'1011
 262                  * CS3 to 4b'0111
 263                  */
 264                 chip_select = 0xF & ~(1 << chip_select);
 265         }
 266
 267         reg &= ~(CQSPI_REG_CONFIG_CHIPSELECT_MASK
 268                         << CQSPI_REG_CONFIG_CHIPSELECT_LSB);
 269         reg |= (chip_select & CQSPI_REG_CONFIG_CHIPSELECT_MASK)
 270                         << CQSPI_REG_CONFIG_CHIPSELECT_LSB;
 271         writel(reg, reg_base + CQSPI_REG_CONFIG);
 272
 273         cadence_qspi_apb_controller_enable(reg_base);
 274 }
 275
 276 void cadence_qspi_apb_delay(void *reg_base,
 277         unsigned int ref_clk, unsigned int sclk_hz,
 278         unsigned int tshsl_ns, unsigned int tsd2d_ns,
 279         unsigned int tchsh_ns, unsigned int tslch_ns)
 280 {
 281         unsigned int ref_clk_ns;
 282         unsigned int sclk_ns;
 283         unsigned int tshsl, tchsh, tslch, tsd2d;
 284         unsigned int reg;
 285
 286         cadence_qspi_apb_controller_disable(reg_base);
 287
 288         /* Convert to ns. */
 289         ref_clk_ns = DIV_ROUND_UP(1000000000, ref_clk);
 290
 291         /* Convert to ns. */
 292         sclk_ns = DIV_ROUND_UP(1000000000, sclk_hz);
 293
 294         /* The controller adds additional delay to that programmed in the reg */
 295         if (tshsl_ns >= sclk_ns + ref_clk_ns)
 296                 tshsl_ns -= sclk_ns + ref_clk_ns;
 297         if (tchsh_ns >= sclk_ns + 3 * ref_clk_ns)
 298                 tchsh_ns -= sclk_ns + 3 * ref_clk_ns;
 299         tshsl = DIV_ROUND_UP(tshsl_ns, ref_clk_ns);
 300         tchsh = DIV_ROUND_UP(tchsh_ns, ref_clk_ns);
 301         tslch = DIV_ROUND_UP(tslch_ns, ref_clk_ns);
 302         tsd2d = DIV_ROUND_UP(tsd2d_ns, ref_clk_ns);
 303
 304         reg = ((tshsl & CQSPI_REG_DELAY_TSHSL_MASK)
 305                         << CQSPI_REG_DELAY_TSHSL_LSB);
 306         reg |= ((tchsh & CQSPI_REG_DELAY_TCHSH_MASK)
 307                         << CQSPI_REG_DELAY_TCHSH_LSB);
 308         reg |= ((tslch & CQSPI_REG_DELAY_TSLCH_MASK)
 309                         << CQSPI_REG_DELAY_TSLCH_LSB);
 310         reg |= ((tsd2d & CQSPI_REG_DELAY_TSD2D_MASK)
 311                         << CQSPI_REG_DELAY_TSD2D_LSB);
 312         writel(reg, reg_base + CQSPI_REG_DELAY);
 313
 314         cadence_qspi_apb_controller_enable(reg_base);
 315 }
 316
 317 void cadence_qspi_apb_controller_init(struct cadence_spi_priv *priv)
 318 {
 319         unsigned reg;
 320
 321         cadence_qspi_apb_controller_disable(priv->regbase);
 322
 323         /* Configure the device size and address bytes */
 324         reg = readl(priv->regbase + CQSPI_REG_SIZE);
 325         /* Clear the previous value */
 326         reg &= ~(CQSPI_REG_SIZE_PAGE_MASK << CQSPI_REG_SIZE_PAGE_LSB);
 327         reg &= ~(CQSPI_REG_SIZE_BLOCK_MASK << CQSPI_REG_SIZE_BLOCK_LSB);
 328         reg |= (priv->page_size << CQSPI_REG_SIZE_PAGE_LSB);
 329         reg |= (priv->block_size << CQSPI_REG_SIZE_BLOCK_LSB);
 330         writel(reg, priv->regbase + CQSPI_REG_SIZE);
 331
 332         /* Configure the remap address register, no remap */
 333         writel(0, priv->regbase + CQSPI_REG_REMAP);
 334
 335         /* Indirect mode configurations */
 336         writel(priv->fifo_depth / 2, priv->regbase + CQSPI_REG_SRAMPARTITION);
 337
 338         /* Disable all interrupts */
 339         writel(0, priv->regbase + CQSPI_REG_IRQMASK);
 340
 341         cadence_qspi_apb_controller_enable(priv->regbase);
 342 }
 343
 344 int cadence_qspi_apb_exec_flash_cmd(void *reg_base, unsigned int reg)
 345 {
 346         unsigned int retry = CQSPI_REG_RETRY;
 347
 348         /* Write the CMDCTRL without start execution. */
 349         writel(reg, reg_base + CQSPI_REG_CMDCTRL);
 350         /* Start execute */
 351         reg |= CQSPI_REG_CMDCTRL_EXECUTE;
 352         writel(reg, reg_base + CQSPI_REG_CMDCTRL);
 353
 354         while (retry--) {
 355                 reg = readl(reg_base + CQSPI_REG_CMDCTRL);
 356                 if ((reg & CQSPI_REG_CMDCTRL_INPROGRESS) == 0)
 357                         break;
 358                 udelay(1);
 359         }
 360
 361         if (!retry) {
 362                 printf("QSPI: flash command execution timeout\n");
 363                 return -EIO;
 364         }
 365
 366         /* Polling QSPI idle status. */
 367         if (!cadence_qspi_wait_idle(reg_base))
 368                 return -EIO;
 369
 370         return 0;
 371 }
 372
 373 static int cadence_qspi_setup_opcode_ext(struct cadence_spi_priv *priv,
 374                                          const struct spi_mem_op *op,
 375                                          unsigned int shift)
 376 {
 377         unsigned int reg;
 378         u8 ext;
 379
 380         if (op->cmd.nbytes != 2)
 381                 return -EINVAL;
 382
 383         /* Opcode extension is the LSB. */
 384         ext = op->cmd.opcode & 0xff;
 385
 386         reg = readl(priv->regbase + CQSPI_REG_OP_EXT_LOWER);
 387         reg &= ~(0xff << shift);
 388         reg |= ext << shift;
 389         writel(reg, priv->regbase + CQSPI_REG_OP_EXT_LOWER);
 390
 391         return 0;
 392 }
 393
 394 static int cadence_qspi_enable_dtr(struct cadence_spi_priv *priv,
 395                                    const struct spi_mem_op *op,
 396                                    unsigned int shift,
 397                                    bool enable)
 398 {
 399         unsigned int reg;
 400         int ret;
 401
 402         reg = readl(priv->regbase + CQSPI_REG_CONFIG);
 403
 404         if (enable) {
 405                 reg |= CQSPI_REG_CONFIG_DTR_PROTO;
 406                 reg |= CQSPI_REG_CONFIG_DUAL_OPCODE;
 407
 408                 /* Set up command opcode extension. */
 409                 ret = cadence_qspi_setup_opcode_ext(priv, op, shift);
 410                 if (ret)
 411                         return ret;
 412         } else {
 413                 reg &= ~CQSPI_REG_CONFIG_DTR_PROTO;
 414                 reg &= ~CQSPI_REG_CONFIG_DUAL_OPCODE;
 415         }
 416
 417         writel(reg, priv->regbase + CQSPI_REG_CONFIG);
 418
 419         return 0;
 420 }
 421
 422 int cadence_qspi_apb_command_read_setup(struct cadence_spi_priv *priv,
 423                                         const struct spi_mem_op *op)
 424 {
 425         int ret;
 426         unsigned int reg;
 427
 428         ret = cadence_qspi_set_protocol(priv, op);
 429         if (ret)
 430                 return ret;
 431
 432         ret = cadence_qspi_enable_dtr(priv, op, CQSPI_REG_OP_EXT_STIG_LSB,
 433                                       priv->dtr);
 434         if (ret)
 435                 return ret;
 436
 437         reg = cadence_qspi_calc_rdreg(priv);
 438         writel(reg, priv->regbase + CQSPI_REG_RD_INSTR);
 439
 440         return 0;
 441 }
 442
 443 /* For command RDID, RDSR. */
 444 int cadence_qspi_apb_command_read(struct cadence_spi_priv *priv,
 445                                   const struct spi_mem_op *op)
 446 {
 447         void *reg_base = priv->regbase;
 448         unsigned int reg;
 449         unsigned int read_len;
 450         int status;
 451         unsigned int rxlen = op->data.nbytes;
 452         void *rxbuf = op->data.buf.in;
 453         unsigned int dummy_clk;
 454         u8 opcode;
 455
 456         if (rxlen > CQSPI_STIG_DATA_LEN_MAX || !rxbuf) {
 457                 printf("QSPI: Invalid input arguments rxlen %u\n", rxlen);
 458                 return -EINVAL;
 459         }
 460
 461         if (priv->dtr)
 462                 opcode = op->cmd.opcode >> 8;
 463         else
 464                 opcode = op->cmd.opcode;
 465
 466         reg = opcode << CQSPI_REG_CMDCTRL_OPCODE_LSB;
 467
 468         /* Set up dummy cycles. */
 469         dummy_clk = cadence_qspi_calc_dummy(op, priv->dtr);
 470         if (dummy_clk > CQSPI_DUMMY_CLKS_MAX)
 471                 return -ENOTSUPP;
 472
 473         if (dummy_clk)
 474                 reg |= (dummy_clk & CQSPI_REG_CMDCTRL_DUMMY_MASK)
 475                      << CQSPI_REG_CMDCTRL_DUMMY_LSB;
 476
 477         reg |= (0x1 << CQSPI_REG_CMDCTRL_RD_EN_LSB);
 478
 479         /* 0 means 1 byte. */
 480         reg |= (((rxlen - 1) & CQSPI_REG_CMDCTRL_RD_BYTES_MASK)
 481                 << CQSPI_REG_CMDCTRL_RD_BYTES_LSB);
 482
 483         /* setup ADDR BIT field */
 484         if (op->addr.nbytes) {
 485                 writel(op->addr.val, priv->regbase + CQSPI_REG_CMDADDRESS);
 486                 /*
 487                  * address bytes are zero indexed
 488                  */
 489                 reg |= (((op->addr.nbytes - 1) &
 490                           CQSPI_REG_CMDCTRL_ADD_BYTES_MASK) <<
 491                           CQSPI_REG_CMDCTRL_ADD_BYTES_LSB);
 492                 reg |= (0x1 << CQSPI_REG_CMDCTRL_ADDR_EN_LSB);
 493         }
 494
 495         status = cadence_qspi_apb_exec_flash_cmd(reg_base, reg);
 496         if (status != 0)
 497                 return status;
 498
 499         reg = readl(reg_base + CQSPI_REG_CMDREADDATALOWER);
 500
 501         /* Put the read value into rx_buf */
 502         read_len = (rxlen > 4) ? 4 : rxlen;
 503         memcpy(rxbuf, &reg, read_len);
 504         rxbuf += read_len;
 505
 506         if (rxlen > 4) {
 507                 reg = readl(reg_base + CQSPI_REG_CMDREADDATAUPPER);
 508
 509                 read_len = rxlen - read_len;
 510                 memcpy(rxbuf, &reg, read_len);
 511         }
 512         return 0;
 513 }
 514
 515 int cadence_qspi_apb_command_write_setup(struct cadence_spi_priv *priv,
 516                                          const struct spi_mem_op *op)
 517 {
 518         int ret;
 519         unsigned int reg;
 520
 521         ret = cadence_qspi_set_protocol(priv, op);
 522         if (ret)
 523                 return ret;
 524
 525         ret = cadence_qspi_enable_dtr(priv, op, CQSPI_REG_OP_EXT_STIG_LSB,
 526                                       priv->dtr);
 527         if (ret)
 528                 return ret;
 529
 530         reg = cadence_qspi_calc_rdreg(priv);
 531         writel(reg, priv->regbase + CQSPI_REG_RD_INSTR);
 532
 533         return 0;
 534 }
 535
 536 /* For commands: WRSR, WREN, WRDI, CHIP_ERASE, BE, etc. */
 537 int cadence_qspi_apb_command_write(struct cadence_spi_priv *priv,
 538                                    const struct spi_mem_op *op)
 539 {
 540         unsigned int reg = 0;
 541         unsigned int wr_data;
 542         unsigned int wr_len;
 543         unsigned int txlen = op->data.nbytes;
 544         const void *txbuf = op->data.buf.out;
 545         void *reg_base = priv->regbase;
 546         u32 addr;
 547         u8 opcode;
 548
 549         /* Reorder address to SPI bus order if only transferring address */
 550         if (!txlen) {
 551                 addr = cpu_to_be32(op->addr.val);
 552                 if (op->addr.nbytes == 3)
 553                         addr >>= 8;
 554                 txbuf = &addr;
 555                 txlen = op->addr.nbytes;
 556         }
 557
 558         if (txlen > CQSPI_STIG_DATA_LEN_MAX) {
 559                 printf("QSPI: Invalid input arguments txlen %u\n", txlen);
 560                 return -EINVAL;
 561         }
 562
 563         if (priv->dtr)
 564                 opcode = op->cmd.opcode >> 8;
 565         else
 566                 opcode = op->cmd.opcode;
 567
 568         reg |= opcode << CQSPI_REG_CMDCTRL_OPCODE_LSB;
 569
 570         if (txlen) {
 571                 /* writing data = yes */
 572                 reg |= (0x1 << CQSPI_REG_CMDCTRL_WR_EN_LSB);
 573                 reg |= ((txlen - 1) & CQSPI_REG_CMDCTRL_WR_BYTES_MASK)
 574                         << CQSPI_REG_CMDCTRL_WR_BYTES_LSB;
 575
 576                 wr_len = txlen > 4 ? 4 : txlen;
 577                 memcpy(&wr_data, txbuf, wr_len);
 578                 writel(wr_data, reg_base +
 579                         CQSPI_REG_CMDWRITEDATALOWER);
 580
 581                 if (txlen > 4) {
 582                         txbuf += wr_len;
 583                         wr_len = txlen - wr_len;
 584                         memcpy(&wr_data, txbuf, wr_len);
 585                         writel(wr_data, reg_base +
 586                                 CQSPI_REG_CMDWRITEDATAUPPER);
 587                 }
 588         }
 589
 590         /* Execute the command */
 591         return cadence_qspi_apb_exec_flash_cmd(reg_base, reg);
 592 }
 593
 594 /* Opcode + Address (3/4 bytes) + dummy bytes (0-4 bytes) */
 595 int cadence_qspi_apb_read_setup(struct cadence_spi_priv *priv,
 596                                 const struct spi_mem_op *op)
 597 {
 598         unsigned int reg;
 599         unsigned int rd_reg;
 600         unsigned int dummy_clk;
 601         unsigned int dummy_bytes = op->dummy.nbytes;
 602         int ret;
 603         u8 opcode;
 604
 605         ret = cadence_qspi_set_protocol(priv, op);
 606         if (ret)
 607                 return ret;
 608
 609         ret = cadence_qspi_enable_dtr(priv, op, CQSPI_REG_OP_EXT_READ_LSB,
 610                                       priv->dtr);
 611         if (ret)
 612                 return ret;
 613
 614         /* Setup the indirect trigger address */
 615         writel(priv->trigger_address,
 616                priv->regbase + CQSPI_REG_INDIRECTTRIGGER);
 617
 618         /* Configure the opcode */
 619         if (priv->dtr)
 620                 opcode = op->cmd.opcode >> 8;
 621         else
 622                 opcode = op->cmd.opcode;
 623
 624         rd_reg = opcode << CQSPI_REG_RD_INSTR_OPCODE_LSB;
 625         rd_reg |= cadence_qspi_calc_rdreg(priv);
 626
 627         writel(op->addr.val, priv->regbase + CQSPI_REG_INDIRECTRDSTARTADDR);
 628
 629         if (dummy_bytes) {
 630                 /* Convert to clock cycles. */
 631                 dummy_clk = cadence_qspi_calc_dummy(op, priv->dtr);
 632
 633                 if (dummy_clk > CQSPI_DUMMY_CLKS_MAX)
 634                         return -ENOTSUPP;
 635
 636                 if (dummy_clk)
 637                         rd_reg |= (dummy_clk & CQSPI_REG_RD_INSTR_DUMMY_MASK)
 638                                 << CQSPI_REG_RD_INSTR_DUMMY_LSB;
 639         }
 640
 641         writel(rd_reg, priv->regbase + CQSPI_REG_RD_INSTR);
 642
 643         /* set device size */
 644         reg = readl(priv->regbase + CQSPI_REG_SIZE);
 645         reg &= ~CQSPI_REG_SIZE_ADDRESS_MASK;
 646         reg |= (op->addr.nbytes - 1);
 647         writel(reg, priv->regbase + CQSPI_REG_SIZE);
 648         return 0;
 649 }
 650
 651 static u32 cadence_qspi_get_rd_sram_level(struct cadence_spi_priv *priv)
 652 {
 653         u32 reg = readl(priv->regbase + CQSPI_REG_SDRAMLEVEL);
 654         reg >>= CQSPI_REG_SDRAMLEVEL_RD_LSB;
 655         return reg & CQSPI_REG_SDRAMLEVEL_RD_MASK;
 656 }
 657
 658 static int cadence_qspi_wait_for_data(struct cadence_spi_priv *priv)
 659 {
 660         unsigned int timeout = 10000;
 661         u32 reg;
 662
 663         while (timeout--) {
 664                 reg = cadence_qspi_get_rd_sram_level(priv);
 665                 if (reg)
 666                         return reg;
 667                 udelay(1);
 668         }
 669
 670         return -ETIMEDOUT;
 671 }
 672
 673 static int
 674 cadence_qspi_apb_indirect_read_execute(struct cadence_spi_priv *priv,
 675                                        unsigned int n_rx, u8 *rxbuf)
 676 {
 677         unsigned int remaining = n_rx;
 678         unsigned int bytes_to_read = 0;
 679         int ret;
 680
 681         writel(n_rx, priv->regbase + CQSPI_REG_INDIRECTRDBYTES);
 682
 683         /* Start the indirect read transfer */
 684         writel(CQSPI_REG_INDIRECTRD_START,
 685                priv->regbase + CQSPI_REG_INDIRECTRD);
 686
 687         while (remaining > 0) {
 688                 ret = cadence_qspi_wait_for_data(priv);
 689                 if (ret < 0) {
 690                         printf("Indirect write timed out (%i)\n", ret);
 691                         goto failrd;
 692                 }
 693
 694                 bytes_to_read = ret;
 695
 696                 while (bytes_to_read != 0) {
 697                         bytes_to_read *= priv->fifo_width;
 698                         bytes_to_read = bytes_to_read > remaining ?
 699                                         remaining : bytes_to_read;
 700                         /*
 701                          * Handle non-4-byte aligned access to avoid
 702                          * data abort.
 703                          */
 704                         if (((uintptr_t)rxbuf % 4) || (bytes_to_read % 4))
 705                                 readsb(priv->ahbbase, rxbuf, bytes_to_read);
 706                         else
 707                                 readsl(priv->ahbbase, rxbuf,
 708                                        bytes_to_read >> 2);
 709                         rxbuf += bytes_to_read;
 710                         remaining -= bytes_to_read;
 711                         bytes_to_read = cadence_qspi_get_rd_sram_level(priv);
 712                 }
 713         }
 714
 715         /* Check indirect done status */
 716         ret = wait_for_bit_le32(priv->regbase + CQSPI_REG_INDIRECTRD,
 717                                 CQSPI_REG_INDIRECTRD_DONE, 1, 10, 0);
 718         if (ret) {
 719                 printf("Indirect read completion error (%i)\n", ret);
 720                 goto failrd;
 721         }
 722
 723         /* Clear indirect completion status */
 724         writel(CQSPI_REG_INDIRECTRD_DONE,
 725                priv->regbase + CQSPI_REG_INDIRECTRD);
 726
 727         /* Check indirect done status */
 728         ret = wait_for_bit_le32(priv->regbase + CQSPI_REG_INDIRECTRD,
 729                                 CQSPI_REG_INDIRECTRD_DONE, 0, 10, 0);
 730         if (ret) {
 731                 printf("Indirect read clear completion error (%i)\n", ret);
 732                 goto failrd;
 733         }
 734
 735         return 0;
 736
 737 failrd:
 738         /* Cancel the indirect read */
 739         writel(CQSPI_REG_INDIRECTRD_CANCEL,
 740                priv->regbase + CQSPI_REG_INDIRECTRD);
 741         return ret;
 742 }
 743
 744 int cadence_qspi_apb_read_execute(struct cadence_spi_priv *priv,
 745                                   const struct spi_mem_op *op)
 746 {
 747         u64 from = op->addr.val;
 748         void *buf = op->data.buf.in;
 749         size_t len = op->data.nbytes;
 750
 751         cadence_qspi_apb_enable_linear_mode(true);
 752
 753         if (priv->use_dac_mode && (from + len < priv->ahbsize)) {
 754                 if (len < 256 ||
 755                     dma_memcpy(buf, priv->ahbbase + from, len) < 0) {
 756                         memcpy_fromio(buf, priv->ahbbase + from, len);
 757                 }
 758                 if (!cadence_qspi_wait_idle(priv->regbase))
 759                         return -EIO;
 760                 return 0;
 761         }
 762
 763         return cadence_qspi_apb_indirect_read_execute(priv, len, buf);
 764 }
 765
 766 /* Opcode + Address (3/4 bytes) */
 767 int cadence_qspi_apb_write_setup(struct cadence_spi_priv *priv,
 768                                  const struct spi_mem_op *op)
 769 {
 770         unsigned int reg;
 771         int ret;
 772         u8 opcode;
 773
 774         ret = cadence_qspi_set_protocol(priv, op);
 775         if (ret)
 776                 return ret;
 777
 778         ret = cadence_qspi_enable_dtr(priv, op, CQSPI_REG_OP_EXT_WRITE_LSB,
 779                                       priv->dtr);
 780         if (ret)
 781                 return ret;
 782
 783         /* Setup the indirect trigger address */
 784         writel(priv->trigger_address,
 785                priv->regbase + CQSPI_REG_INDIRECTTRIGGER);
 786
 787         /* Configure the opcode */
 788         if (priv->dtr)
 789                 opcode = op->cmd.opcode >> 8;
 790         else
 791                 opcode = op->cmd.opcode;
 792
 793         reg = opcode << CQSPI_REG_WR_INSTR_OPCODE_LSB;
 794         reg |= priv->data_width << CQSPI_REG_WR_INSTR_TYPE_DATA_LSB;
 795         reg |= priv->addr_width << CQSPI_REG_WR_INSTR_TYPE_ADDR_LSB;
 796         writel(reg, priv->regbase + CQSPI_REG_WR_INSTR);
 797
 798         reg = cadence_qspi_calc_rdreg(priv);
 799         writel(reg, priv->regbase + CQSPI_REG_RD_INSTR);
 800
 801         writel(op->addr.val, priv->regbase + CQSPI_REG_INDIRECTWRSTARTADDR);
 802
 803         if (priv->dtr) {
 804                 /*
 805                  * Some flashes like the cypress Semper flash expect a 4-byte
 806                  * dummy address with the Read SR command in DTR mode, but this
 807                  * controller does not support sending address with the Read SR
 808                  * command. So, disable write completion polling on the
 809                  * controller's side. spi-nor will take care of polling the
 810                  * status register.
 811                  */
 812                 reg = readl(priv->regbase + CQSPI_REG_WR_COMPLETION_CTRL);
 813                 reg |= CQSPI_REG_WR_DISABLE_AUTO_POLL;
 814                 writel(reg, priv->regbase + CQSPI_REG_WR_COMPLETION_CTRL);
 815         }
 816
 817         reg = readl(priv->regbase + CQSPI_REG_SIZE);
 818         reg &= ~CQSPI_REG_SIZE_ADDRESS_MASK;
 819         reg |= (op->addr.nbytes - 1);
 820         writel(reg, priv->regbase + CQSPI_REG_SIZE);
 821         return 0;
 822 }
 823
 824 static int
 825 cadence_qspi_apb_indirect_write_execute(struct cadence_spi_priv *priv,
 826                                         unsigned int n_tx, const u8 *txbuf)
 827 {
 828         unsigned int page_size = priv->page_size;
 829         unsigned int remaining = n_tx;
 830         const u8 *bb_txbuf = txbuf;
 831         void *bounce_buf = NULL;
 832         unsigned int write_bytes;
 833         int ret;
 834
 835         /*
 836          * Use bounce buffer for non 32 bit aligned txbuf to avoid data
 837          * aborts
 838          */
 839         if ((uintptr_t)txbuf % 4) {
 840                 bounce_buf = malloc(n_tx);
 841                 if (!bounce_buf)
 842                         return -ENOMEM;
 843                 memcpy(bounce_buf, txbuf, n_tx);
 844                 bb_txbuf = bounce_buf;
 845         }
 846
 847         /* Configure the indirect read transfer bytes */
 848         writel(n_tx, priv->regbase + CQSPI_REG_INDIRECTWRBYTES);
 849
 850         /* Start the indirect write transfer */
 851         writel(CQSPI_REG_INDIRECTWR_START,
 852                priv->regbase + CQSPI_REG_INDIRECTWR);
 853
 854         /*
 855          * Some delay is required for the above bit to be internally
 856          * synchronized by the QSPI module.
 857          */
 858         ndelay(priv->wr_delay);
 859
 860         while (remaining > 0) {
 861                 write_bytes = remaining > page_size ? page_size : remaining;
 862                 writesl(priv->ahbbase, bb_txbuf, write_bytes >> 2);
 863                 if (write_bytes % 4)
 864                         writesb(priv->ahbbase,
 865                                 bb_txbuf + rounddown(write_bytes, 4),
 866                                 write_bytes % 4);
 867
 868                 ret = wait_for_bit_le32(priv->regbase + CQSPI_REG_SDRAMLEVEL,
 869                                         CQSPI_REG_SDRAMLEVEL_WR_MASK <<
 870                                         CQSPI_REG_SDRAMLEVEL_WR_LSB, 0, 10, 0);
 871                 if (ret) {
 872                         printf("Indirect write timed out (%i)\n", ret);
 873                         goto failwr;
 874                 }
 875
 876                 bb_txbuf += write_bytes;
 877                 remaining -= write_bytes;
 878         }
 879
 880         /* Check indirect done status */
 881         ret = wait_for_bit_le32(priv->regbase + CQSPI_REG_INDIRECTWR,
 882                                 CQSPI_REG_INDIRECTWR_DONE, 1, 10, 0);
 883         if (ret) {
 884                 printf("Indirect write completion error (%i)\n", ret);
 885                 goto failwr;
 886         }
 887
 888         /* Clear indirect completion status */
 889         writel(CQSPI_REG_INDIRECTWR_DONE,
 890                priv->regbase + CQSPI_REG_INDIRECTWR);
 891
 892         /* Check indirect done status */
 893         ret = wait_for_bit_le32(priv->regbase + CQSPI_REG_INDIRECTWR,
 894                                 CQSPI_REG_INDIRECTWR_DONE, 0, 10, 0);
 895         if (ret) {
 896                 printf("Indirect write clear completion error (%i)\n", ret);
 897                 goto failwr;
 898         }
 899
 900         if (bounce_buf)
 901                 free(bounce_buf);
 902         return 0;
 903
 904 failwr:
 905         /* Cancel the indirect write */
 906         writel(CQSPI_REG_INDIRECTWR_CANCEL,
 907                priv->regbase + CQSPI_REG_INDIRECTWR);
 908         if (bounce_buf)
 909                 free(bounce_buf);
 910         return ret;
 911 }
 912
 913 int cadence_qspi_apb_write_execute(struct cadence_spi_priv *priv,
 914                                    const struct spi_mem_op *op)
 915 {
 916         u32 to = op->addr.val;
 917         const void *buf = op->data.buf.out;
 918         size_t len = op->data.nbytes;
 919
 920         /*
 921          * Some flashes like the Cypress Semper flash expect a dummy 4-byte
 922          * address (all 0s) with the read status register command in DTR mode.
 923          * But this controller does not support sending dummy address bytes to
 924          * the flash when it is polling the write completion register in DTR
 925          * mode. So, we can not use direct mode when in DTR mode for writing
 926          * data.
 927          */
 928         cadence_qspi_apb_enable_linear_mode(true);
 929         if (!priv->dtr && priv->use_dac_mode && (to + len < priv->ahbsize)) {
 930                 memcpy_toio(priv->ahbbase + to, buf, len);
 931                 if (!cadence_qspi_wait_idle(priv->regbase))
 932                         return -EIO;
 933                 return 0;
 934         }
 935
 936         return cadence_qspi_apb_indirect_write_execute(priv, len, buf);
 937 }
 938
 939 void cadence_qspi_apb_enter_xip(void *reg_base, char xip_dummy)
 940 {
 941         unsigned int reg;
 942
 943         /* enter XiP mode immediately and enable direct mode */
 944         reg = readl(reg_base + CQSPI_REG_CONFIG);
 945         reg |= CQSPI_REG_CONFIG_ENABLE;
 946         reg |= CQSPI_REG_CONFIG_DIRECT;
 947         reg |= CQSPI_REG_CONFIG_XIP_IMM;
 948         writel(reg, reg_base + CQSPI_REG_CONFIG);
 949
 950         /* keep the XiP mode */
 951         writel(xip_dummy, reg_base + CQSPI_REG_MODE_BIT);
 952
 953         /* Enable mode bit at devrd */
 954         reg = readl(reg_base + CQSPI_REG_RD_INSTR);
 955         reg |= (1 << CQSPI_REG_RD_INSTR_MODE_EN_LSB);
 956         writel(reg, reg_base + CQSPI_REG_RD_INSTR);
 957 }