drivers/mtd/devices/st_spi_fsm.c

   1 /*
   2  * st_spi_fsm.c - ST Fast Sequence Mode (FSM) Serial Flash Controller
   3  *
   4  * Author: Angus Clark <angus.clark@st.com>
   5  *
   6  * Copyright (C) 2010-2014 STMicroelectronics Limited
   7  *
   8  * JEDEC probe based on drivers/mtd/devices/m25p80.c
   9  *
  10  * This code is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/regmap.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/mfd/syscon.h>
  20 #include <linux/mtd/mtd.h>
  21 #include <linux/mtd/partitions.h>
  22 #include <linux/sched.h>
  23 #include <linux/delay.h>
  24 #include <linux/io.h>
  25 #include <linux/of.h>
  26
  27 #include "serial_flash_cmds.h"
  28
  29 /*
  30  * FSM SPI Controller Registers
  31  */
  32 #define SPI_CLOCKDIV                    0x0010
  33 #define SPI_MODESELECT                  0x0018
  34 #define SPI_CONFIGDATA                  0x0020
  35 #define SPI_STA_MODE_CHANGE             0x0028
  36 #define SPI_FAST_SEQ_TRANSFER_SIZE      0x0100
  37 #define SPI_FAST_SEQ_ADD1               0x0104
  38 #define SPI_FAST_SEQ_ADD2               0x0108
  39 #define SPI_FAST_SEQ_ADD_CFG            0x010c
  40 #define SPI_FAST_SEQ_OPC1               0x0110
  41 #define SPI_FAST_SEQ_OPC2               0x0114
  42 #define SPI_FAST_SEQ_OPC3               0x0118
  43 #define SPI_FAST_SEQ_OPC4               0x011c
  44 #define SPI_FAST_SEQ_OPC5               0x0120
  45 #define SPI_MODE_BITS                   0x0124
  46 #define SPI_DUMMY_BITS                  0x0128
  47 #define SPI_FAST_SEQ_FLASH_STA_DATA     0x012c
  48 #define SPI_FAST_SEQ_1                  0x0130
  49 #define SPI_FAST_SEQ_2                  0x0134
  50 #define SPI_FAST_SEQ_3                  0x0138
  51 #define SPI_FAST_SEQ_4                  0x013c
  52 #define SPI_FAST_SEQ_CFG                0x0140
  53 #define SPI_FAST_SEQ_STA                0x0144
  54 #define SPI_QUAD_BOOT_SEQ_INIT_1        0x0148
  55 #define SPI_QUAD_BOOT_SEQ_INIT_2        0x014c
  56 #define SPI_QUAD_BOOT_READ_SEQ_1        0x0150
  57 #define SPI_QUAD_BOOT_READ_SEQ_2        0x0154
  58 #define SPI_PROGRAM_ERASE_TIME          0x0158
  59 #define SPI_MULT_PAGE_REPEAT_SEQ_1      0x015c
  60 #define SPI_MULT_PAGE_REPEAT_SEQ_2      0x0160
  61 #define SPI_STATUS_WR_TIME_REG          0x0164
  62 #define SPI_FAST_SEQ_DATA_REG           0x0300
  63
  64 /*
  65  * Register: SPI_MODESELECT
  66  */
  67 #define SPI_MODESELECT_CONTIG           0x01
  68 #define SPI_MODESELECT_FASTREAD         0x02
  69 #define SPI_MODESELECT_DUALIO           0x04
  70 #define SPI_MODESELECT_FSM              0x08
  71 #define SPI_MODESELECT_QUADBOOT         0x10
  72
  73 /*
  74  * Register: SPI_CONFIGDATA
  75  */
  76 #define SPI_CFG_DEVICE_ST               0x1
  77 #define SPI_CFG_DEVICE_ATMEL            0x4
  78 #define SPI_CFG_MIN_CS_HIGH(x)          (((x) & 0xfff) << 4)
  79 #define SPI_CFG_CS_SETUPHOLD(x)         (((x) & 0xff) << 16)
  80 #define SPI_CFG_DATA_HOLD(x)            (((x) & 0xff) << 24)
  81
  82 #define SPI_CFG_DEFAULT_MIN_CS_HIGH    SPI_CFG_MIN_CS_HIGH(0x0AA)
  83 #define SPI_CFG_DEFAULT_CS_SETUPHOLD   SPI_CFG_CS_SETUPHOLD(0xA0)
  84 #define SPI_CFG_DEFAULT_DATA_HOLD      SPI_CFG_DATA_HOLD(0x00)
  85
  86 /*
  87  * Register: SPI_FAST_SEQ_TRANSFER_SIZE
  88  */
  89 #define TRANSFER_SIZE(x)                ((x) * 8)
  90
  91 /*
  92  * Register: SPI_FAST_SEQ_ADD_CFG
  93  */
  94 #define ADR_CFG_CYCLES_ADD1(x)          ((x) << 0)
  95 #define ADR_CFG_PADS_1_ADD1             (0x0 << 6)
  96 #define ADR_CFG_PADS_2_ADD1             (0x1 << 6)
  97 #define ADR_CFG_PADS_4_ADD1             (0x3 << 6)
  98 #define ADR_CFG_CSDEASSERT_ADD1         (1   << 8)
  99 #define ADR_CFG_CYCLES_ADD2(x)          ((x) << (0+16))
 100 #define ADR_CFG_PADS_1_ADD2             (0x0 << (6+16))
 101 #define ADR_CFG_PADS_2_ADD2             (0x1 << (6+16))
 102 #define ADR_CFG_PADS_4_ADD2             (0x3 << (6+16))
 103 #define ADR_CFG_CSDEASSERT_ADD2         (1   << (8+16))
 104
 105 /*
 106  * Register: SPI_FAST_SEQ_n
 107  */
 108 #define SEQ_OPC_OPCODE(x)               ((x) << 0)
 109 #define SEQ_OPC_CYCLES(x)               ((x) << 8)
 110 #define SEQ_OPC_PADS_1                  (0x0 << 14)
 111 #define SEQ_OPC_PADS_2                  (0x1 << 14)
 112 #define SEQ_OPC_PADS_4                  (0x3 << 14)
 113 #define SEQ_OPC_CSDEASSERT              (1   << 16)
 114
 115 /*
 116  * Register: SPI_FAST_SEQ_CFG
 117  */
 118 #define SEQ_CFG_STARTSEQ                (1 << 0)
 119 #define SEQ_CFG_SWRESET                 (1 << 5)
 120 #define SEQ_CFG_CSDEASSERT              (1 << 6)
 121 #define SEQ_CFG_READNOTWRITE            (1 << 7)
 122 #define SEQ_CFG_ERASE                   (1 << 8)
 123 #define SEQ_CFG_PADS_1                  (0x0 << 16)
 124 #define SEQ_CFG_PADS_2                  (0x1 << 16)
 125 #define SEQ_CFG_PADS_4                  (0x3 << 16)
 126
 127 /*
 128  * Register: SPI_MODE_BITS
 129  */
 130 #define MODE_DATA(x)                    (x & 0xff)
 131 #define MODE_CYCLES(x)                  ((x & 0x3f) << 16)
 132 #define MODE_PADS_1                     (0x0 << 22)
 133 #define MODE_PADS_2                     (0x1 << 22)
 134 #define MODE_PADS_4                     (0x3 << 22)
 135 #define DUMMY_CSDEASSERT                (1   << 24)
 136
 137 /*
 138  * Register: SPI_DUMMY_BITS
 139  */
 140 #define DUMMY_CYCLES(x)                 ((x & 0x3f) << 16)
 141 #define DUMMY_PADS_1                    (0x0 << 22)
 142 #define DUMMY_PADS_2                    (0x1 << 22)
 143 #define DUMMY_PADS_4                    (0x3 << 22)
 144 #define DUMMY_CSDEASSERT                (1   << 24)
 145
 146 /*
 147  * Register: SPI_FAST_SEQ_FLASH_STA_DATA
 148  */
 149 #define STA_DATA_BYTE1(x)               ((x & 0xff) << 0)
 150 #define STA_DATA_BYTE2(x)               ((x & 0xff) << 8)
 151 #define STA_PADS_1                      (0x0 << 16)
 152 #define STA_PADS_2                      (0x1 << 16)
 153 #define STA_PADS_4                      (0x3 << 16)
 154 #define STA_CSDEASSERT                  (0x1 << 20)
 155 #define STA_RDNOTWR                     (0x1 << 21)
 156
 157 /*
 158  * FSM SPI Instruction Opcodes
 159  */
 160 #define STFSM_OPC_CMD                   0x1
 161 #define STFSM_OPC_ADD                   0x2
 162 #define STFSM_OPC_STA                   0x3
 163 #define STFSM_OPC_MODE                  0x4
 164 #define STFSM_OPC_DUMMY         0x5
 165 #define STFSM_OPC_DATA                  0x6
 166 #define STFSM_OPC_WAIT                  0x7
 167 #define STFSM_OPC_JUMP                  0x8
 168 #define STFSM_OPC_GOTO                  0x9
 169 #define STFSM_OPC_STOP                  0xF
 170
 171 /*
 172  * FSM SPI Instructions (== opcode + operand).
 173  */
 174 #define STFSM_INSTR(cmd, op)            ((cmd) | ((op) << 4))
 175
 176 #define STFSM_INST_CMD1                 STFSM_INSTR(STFSM_OPC_CMD,      1)
 177 #define STFSM_INST_CMD2                 STFSM_INSTR(STFSM_OPC_CMD,      2)
 178 #define STFSM_INST_CMD3                 STFSM_INSTR(STFSM_OPC_CMD,      3)
 179 #define STFSM_INST_CMD4                 STFSM_INSTR(STFSM_OPC_CMD,      4)
 180 #define STFSM_INST_CMD5                 STFSM_INSTR(STFSM_OPC_CMD,      5)
 181 #define STFSM_INST_ADD1                 STFSM_INSTR(STFSM_OPC_ADD,      1)
 182 #define STFSM_INST_ADD2                 STFSM_INSTR(STFSM_OPC_ADD,      2)
 183
 184 #define STFSM_INST_DATA_WRITE           STFSM_INSTR(STFSM_OPC_DATA,     1)
 185 #define STFSM_INST_DATA_READ            STFSM_INSTR(STFSM_OPC_DATA,     2)
 186
 187 #define STFSM_INST_STA_RD1              STFSM_INSTR(STFSM_OPC_STA,      0x1)
 188 #define STFSM_INST_STA_WR1              STFSM_INSTR(STFSM_OPC_STA,      0x1)
 189 #define STFSM_INST_STA_RD2              STFSM_INSTR(STFSM_OPC_STA,      0x2)
 190 #define STFSM_INST_STA_WR1_2            STFSM_INSTR(STFSM_OPC_STA,      0x3)
 191
 192 #define STFSM_INST_MODE                 STFSM_INSTR(STFSM_OPC_MODE,     0)
 193 #define STFSM_INST_DUMMY                STFSM_INSTR(STFSM_OPC_DUMMY,    0)
 194 #define STFSM_INST_WAIT                 STFSM_INSTR(STFSM_OPC_WAIT,     0)
 195 #define STFSM_INST_STOP                 STFSM_INSTR(STFSM_OPC_STOP,     0)
 196
 197 #define STFSM_DEFAULT_EMI_FREQ 100000000UL                        /* 100 MHz */
 198 #define STFSM_DEFAULT_WR_TIME  (STFSM_DEFAULT_EMI_FREQ * (15/1000)) /* 15ms */
 199
 200 #define STFSM_FLASH_SAFE_FREQ  10000000UL                         /* 10 MHz */
 201
 202 #define STFSM_MAX_WAIT_SEQ_MS  1000     /* FSM execution time */
 203
 204 /* Flash Commands */
 205 #define FLASH_CMD_WREN         0x06
 206 #define FLASH_CMD_WRDI         0x04
 207 #define FLASH_CMD_RDID         0x9f
 208 #define FLASH_CMD_RDSR         0x05
 209 #define FLASH_CMD_RDSR2                0x35
 210 #define FLASH_CMD_WRSR         0x01
 211 #define FLASH_CMD_SE_4K                0x20
 212 #define FLASH_CMD_SE_32K       0x52
 213 #define FLASH_CMD_SE           0xd8
 214 #define FLASH_CMD_CHIPERASE    0xc7
 215 #define FLASH_CMD_WRVCR                0x81
 216 #define FLASH_CMD_RDVCR                0x85
 217
 218 #define FLASH_CMD_READ         0x03    /* READ */
 219 #define FLASH_CMD_READ_FAST    0x0b    /* FAST READ */
 220 #define FLASH_CMD_READ_1_1_2   0x3b    /* DUAL OUTPUT READ */
 221 #define FLASH_CMD_READ_1_2_2   0xbb    /* DUAL I/O READ */
 222 #define FLASH_CMD_READ_1_1_4   0x6b    /* QUAD OUTPUT READ */
 223 #define FLASH_CMD_READ_1_4_4   0xeb    /* QUAD I/O READ */
 224
 225 #define FLASH_CMD_WRITE                0x02    /* PAGE PROGRAM */
 226 #define FLASH_CMD_WRITE_1_1_2  0xa2    /* DUAL INPUT PROGRAM */
 227 #define FLASH_CMD_WRITE_1_2_2  0xd2    /* DUAL INPUT EXT PROGRAM */
 228 #define FLASH_CMD_WRITE_1_1_4  0x32    /* QUAD INPUT PROGRAM */
 229 #define FLASH_CMD_WRITE_1_4_4  0x12    /* QUAD INPUT EXT PROGRAM */
 230
 231 #define FLASH_CMD_EN4B_ADDR    0xb7    /* Enter 4-byte address mode */
 232 #define FLASH_CMD_EX4B_ADDR    0xe9    /* Exit 4-byte address mode */
 233
 234 /* READ commands with 32-bit addressing (N25Q256 and S25FLxxxS) */
 235 #define FLASH_CMD_READ4                0x13
 236 #define FLASH_CMD_READ4_FAST   0x0c
 237 #define FLASH_CMD_READ4_1_1_2  0x3c
 238 #define FLASH_CMD_READ4_1_2_2  0xbc
 239 #define FLASH_CMD_READ4_1_1_4  0x6c
 240 #define FLASH_CMD_READ4_1_4_4  0xec
 241
 242 /* S25FLxxxS commands */
 243 #define S25FL_CMD_WRITE4_1_1_4 0x34
 244 #define S25FL_CMD_SE4          0xdc
 245 #define S25FL_CMD_CLSR         0x30
 246 #define S25FL_CMD_DYBWR                0xe1
 247 #define S25FL_CMD_DYBRD                0xe0
 248 #define S25FL_CMD_WRITE4       0x12    /* Note, opcode clashes with
 249                                         * 'FLASH_CMD_WRITE_1_4_4'
 250                                         * as found on N25Qxxx devices! */
 251
 252 /* Status register */
 253 #define FLASH_STATUS_BUSY      0x01
 254 #define FLASH_STATUS_WEL       0x02
 255 #define FLASH_STATUS_BP0       0x04
 256 #define FLASH_STATUS_BP1       0x08
 257 #define FLASH_STATUS_BP2       0x10
 258 #define FLASH_STATUS_SRWP0     0x80
 259 #define FLASH_STATUS_TIMEOUT   0xff
 260 /* S25FL Error Flags */
 261 #define S25FL_STATUS_E_ERR     0x20
 262 #define S25FL_STATUS_P_ERR     0x40
 263
 264 #define FLASH_PAGESIZE         256                      /* In Bytes    */
 265 #define FLASH_PAGESIZE_32      (FLASH_PAGESIZE / 4)     /* In uint32_t */
 266 #define FLASH_MAX_BUSY_WAIT    (300 * HZ)       /* Maximum 'CHIPERASE' time */
 267
 268 /*
 269  * Flags to tweak operation of default read/write/erase routines
 270  */
 271 #define CFG_READ_TOGGLE_32BIT_ADDR     0x00000001
 272 #define CFG_WRITE_TOGGLE_32BIT_ADDR    0x00000002
 273 #define CFG_WRITE_EX_32BIT_ADDR_DELAY  0x00000004
 274 #define CFG_ERASESEC_TOGGLE_32BIT_ADDR 0x00000008
 275 #define CFG_S25FL_CHECK_ERROR_FLAGS    0x00000010
 276
 277 struct stfsm_seq {
 278         uint32_t data_size;
 279         uint32_t addr1;
 280         uint32_t addr2;
 281         uint32_t addr_cfg;
 282         uint32_t seq_opc[5];
 283         uint32_t mode;
 284         uint32_t dummy;
 285         uint32_t status;
 286         uint8_t  seq[16];
 287         uint32_t seq_cfg;
 288 } __packed __aligned(4);
 289
 290 struct stfsm {
 291         struct device           *dev;
 292         void __iomem            *base;
 293         struct resource         *region;
 294         struct mtd_info         mtd;
 295         struct mutex            lock;
 296         struct flash_info       *info;
 297
 298         uint32_t                configuration;
 299         uint32_t                fifo_dir_delay;
 300         bool                    booted_from_spi;
 301         bool                    reset_signal;
 302         bool                    reset_por;
 303
 304         struct stfsm_seq stfsm_seq_read;
 305         struct stfsm_seq stfsm_seq_write;
 306         struct stfsm_seq stfsm_seq_en_32bit_addr;
 307 };
 308
 309 /* Parameters to configure a READ or WRITE FSM sequence */
 310 struct seq_rw_config {
 311         uint32_t        flags;          /* flags to support config */
 312         uint8_t         cmd;            /* FLASH command */
 313         int             write;          /* Write Sequence */
 314         uint8_t         addr_pads;      /* No. of addr pads (MODE & DUMMY) */
 315         uint8_t         data_pads;      /* No. of data pads */
 316         uint8_t         mode_data;      /* MODE data */
 317         uint8_t         mode_cycles;    /* No. of MODE cycles */
 318         uint8_t         dummy_cycles;   /* No. of DUMMY cycles */
 319 };
 320
 321 /* SPI Flash Device Table */
 322 struct flash_info {
 323         char            *name;
 324         /*
 325          * JEDEC id zero means "no ID" (most older chips); otherwise it has
 326          * a high byte of zero plus three data bytes: the manufacturer id,
 327          * then a two byte device id.
 328          */
 329         u32             jedec_id;
 330         u16             ext_id;
 331         /*
 332          * The size listed here is what works with FLASH_CMD_SE, which isn't
 333          * necessarily called a "sector" by the vendor.
 334          */
 335         unsigned        sector_size;
 336         u16             n_sectors;
 337         u32             flags;
 338         /*
 339          * Note, where FAST_READ is supported, freq_max specifies the
 340          * FAST_READ frequency, not the READ frequency.
 341          */
 342         u32             max_freq;
 343         int             (*config)(struct stfsm *);
 344 };
 345
 346 static int stfsm_n25q_config(struct stfsm *fsm);
 347 static int stfsm_mx25_config(struct stfsm *fsm);
 348 static int stfsm_s25fl_config(struct stfsm *fsm);
 349 static int stfsm_w25q_config(struct stfsm *fsm);
 350
 351 static struct flash_info flash_types[] = {
 352         /*
 353          * ST Microelectronics/Numonyx --
 354          * (newer production versions may have feature updates
 355          * (eg faster operating frequency)
 356          */
 357 #define M25P_FLAG (FLASH_FLAG_READ_WRITE | FLASH_FLAG_READ_FAST)
 358         { "m25p40",  0x202013, 0,  64 * 1024,   8, M25P_FLAG, 25, NULL },
 359         { "m25p80",  0x202014, 0,  64 * 1024,  16, M25P_FLAG, 25, NULL },
 360         { "m25p16",  0x202015, 0,  64 * 1024,  32, M25P_FLAG, 25, NULL },
 361         { "m25p32",  0x202016, 0,  64 * 1024,  64, M25P_FLAG, 50, NULL },
 362         { "m25p64",  0x202017, 0,  64 * 1024, 128, M25P_FLAG, 50, NULL },
 363         { "m25p128", 0x202018, 0, 256 * 1024,  64, M25P_FLAG, 50, NULL },
 364
 365 #define M25PX_FLAG (FLASH_FLAG_READ_WRITE      |        \
 366                     FLASH_FLAG_READ_FAST        |       \
 367                     FLASH_FLAG_READ_1_1_2       |       \
 368                     FLASH_FLAG_WRITE_1_1_2)
 369         { "m25px32", 0x207116, 0,  64 * 1024,  64, M25PX_FLAG, 75, NULL },
 370         { "m25px64", 0x207117, 0,  64 * 1024, 128, M25PX_FLAG, 75, NULL },
 371
 372 #define MX25_FLAG (FLASH_FLAG_READ_WRITE       |        \
 373                    FLASH_FLAG_READ_FAST         |       \
 374                    FLASH_FLAG_READ_1_1_2        |       \
 375                    FLASH_FLAG_READ_1_2_2        |       \
 376                    FLASH_FLAG_READ_1_1_4        |       \
 377                    FLASH_FLAG_READ_1_4_4        |       \
 378                    FLASH_FLAG_SE_4K             |       \
 379                    FLASH_FLAG_SE_32K)
 380         { "mx25l25635e", 0xc22019, 0, 64*1024, 512,
 381           (MX25_FLAG | FLASH_FLAG_32BIT_ADDR | FLASH_FLAG_RESET), 70,
 382           stfsm_mx25_config },
 383
 384 #define N25Q_FLAG (FLASH_FLAG_READ_WRITE       |        \
 385                    FLASH_FLAG_READ_FAST         |       \
 386                    FLASH_FLAG_READ_1_1_2        |       \
 387                    FLASH_FLAG_READ_1_2_2        |       \
 388                    FLASH_FLAG_READ_1_1_4        |       \
 389                    FLASH_FLAG_READ_1_4_4        |       \
 390                    FLASH_FLAG_WRITE_1_1_2       |       \
 391                    FLASH_FLAG_WRITE_1_2_2       |       \
 392                    FLASH_FLAG_WRITE_1_1_4       |       \
 393                    FLASH_FLAG_WRITE_1_4_4)
 394         { "n25q128", 0x20ba18, 0, 64 * 1024,  256, N25Q_FLAG, 108,
 395           stfsm_n25q_config },
 396         { "n25q256", 0x20ba19, 0, 64 * 1024,  512,
 397           N25Q_FLAG | FLASH_FLAG_32BIT_ADDR, 108, stfsm_n25q_config },
 398
 399         /*
 400          * Spansion S25FLxxxP
 401          *     - 256KiB and 64KiB sector variants (identified by ext. JEDEC)
 402          */
 403 #define S25FLXXXP_FLAG (FLASH_FLAG_READ_WRITE  |        \
 404                         FLASH_FLAG_READ_1_1_2   |       \
 405                         FLASH_FLAG_READ_1_2_2   |       \
 406                         FLASH_FLAG_READ_1_1_4   |       \
 407                         FLASH_FLAG_READ_1_4_4   |       \
 408                         FLASH_FLAG_WRITE_1_1_4  |       \
 409                         FLASH_FLAG_READ_FAST)
 410         { "s25fl129p0", 0x012018, 0x4d00, 256 * 1024,  64, S25FLXXXP_FLAG, 80,
 411           stfsm_s25fl_config },
 412         { "s25fl129p1", 0x012018, 0x4d01,  64 * 1024, 256, S25FLXXXP_FLAG, 80,
 413           stfsm_s25fl_config },
 414
 415         /*
 416          * Spansion S25FLxxxS
 417          *     - 256KiB and 64KiB sector variants (identified by ext. JEDEC)
 418          *     - RESET# signal supported by die but not bristled out on all
 419          *       package types.  The package type is a function of board design,
 420          *       so this information is captured in the board's flags.
 421          *     - Supports 'DYB' sector protection. Depending on variant, sectors
 422          *       may default to locked state on power-on.
 423          */
 424 #define S25FLXXXS_FLAG (S25FLXXXP_FLAG         |        \
 425                         FLASH_FLAG_RESET        |       \
 426                         FLASH_FLAG_DYB_LOCKING)
 427         { "s25fl128s0", 0x012018, 0x0300,  256 * 1024, 64, S25FLXXXS_FLAG, 80,
 428           stfsm_s25fl_config },
 429         { "s25fl128s1", 0x012018, 0x0301,  64 * 1024, 256, S25FLXXXS_FLAG, 80,
 430           stfsm_s25fl_config },
 431         { "s25fl256s0", 0x010219, 0x4d00, 256 * 1024, 128,
 432           S25FLXXXS_FLAG | FLASH_FLAG_32BIT_ADDR, 80, stfsm_s25fl_config },
 433         { "s25fl256s1", 0x010219, 0x4d01,  64 * 1024, 512,
 434           S25FLXXXS_FLAG | FLASH_FLAG_32BIT_ADDR, 80, stfsm_s25fl_config },
 435
 436         /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
 437 #define W25X_FLAG (FLASH_FLAG_READ_WRITE       |        \
 438                    FLASH_FLAG_READ_FAST         |       \
 439                    FLASH_FLAG_READ_1_1_2        |       \
 440                    FLASH_FLAG_WRITE_1_1_2)
 441         { "w25x40",  0xef3013, 0,  64 * 1024,   8, W25X_FLAG, 75, NULL },
 442         { "w25x80",  0xef3014, 0,  64 * 1024,  16, W25X_FLAG, 75, NULL },
 443         { "w25x16",  0xef3015, 0,  64 * 1024,  32, W25X_FLAG, 75, NULL },
 444         { "w25x32",  0xef3016, 0,  64 * 1024,  64, W25X_FLAG, 75, NULL },
 445         { "w25x64",  0xef3017, 0,  64 * 1024, 128, W25X_FLAG, 75, NULL },
 446
 447         /* Winbond -- w25q "blocks" are 64K, "sectors" are 4KiB */
 448 #define W25Q_FLAG (FLASH_FLAG_READ_WRITE       |        \
 449                    FLASH_FLAG_READ_FAST         |       \
 450                    FLASH_FLAG_READ_1_1_2        |       \
 451                    FLASH_FLAG_READ_1_2_2        |       \
 452                    FLASH_FLAG_READ_1_1_4        |       \
 453                    FLASH_FLAG_READ_1_4_4        |       \
 454                    FLASH_FLAG_WRITE_1_1_4)
 455         { "w25q80",  0xef4014, 0,  64 * 1024,  16, W25Q_FLAG, 80,
 456           stfsm_w25q_config },
 457         { "w25q16",  0xef4015, 0,  64 * 1024,  32, W25Q_FLAG, 80,
 458           stfsm_w25q_config },
 459         { "w25q32",  0xef4016, 0,  64 * 1024,  64, W25Q_FLAG, 80,
 460           stfsm_w25q_config },
 461         { "w25q64",  0xef4017, 0,  64 * 1024, 128, W25Q_FLAG, 80,
 462           stfsm_w25q_config },
 463
 464         /* Sentinel */
 465         { NULL, 0x000000, 0, 0, 0, 0, 0, NULL },
 466 };
 467
 468 /*
 469  * FSM message sequence configurations:
 470  *
 471  * All configs are presented in order of preference
 472  */
 473
 474 /* Default READ configurations, in order of preference */
 475 static struct seq_rw_config default_read_configs[] = {
 476         {FLASH_FLAG_READ_1_4_4, FLASH_CMD_READ_1_4_4,   0, 4, 4, 0x00, 2, 4},
 477         {FLASH_FLAG_READ_1_1_4, FLASH_CMD_READ_1_1_4,   0, 1, 4, 0x00, 4, 0},
 478         {FLASH_FLAG_READ_1_2_2, FLASH_CMD_READ_1_2_2,   0, 2, 2, 0x00, 4, 0},
 479         {FLASH_FLAG_READ_1_1_2, FLASH_CMD_READ_1_1_2,   0, 1, 2, 0x00, 0, 8},
 480         {FLASH_FLAG_READ_FAST,  FLASH_CMD_READ_FAST,    0, 1, 1, 0x00, 0, 8},
 481         {FLASH_FLAG_READ_WRITE, FLASH_CMD_READ,         0, 1, 1, 0x00, 0, 0},
 482         {0x00,                  0,                      0, 0, 0, 0x00, 0, 0},
 483 };
 484
 485 /* Default WRITE configurations */
 486 static struct seq_rw_config default_write_configs[] = {
 487         {FLASH_FLAG_WRITE_1_4_4, FLASH_CMD_WRITE_1_4_4, 1, 4, 4, 0x00, 0, 0},
 488         {FLASH_FLAG_WRITE_1_1_4, FLASH_CMD_WRITE_1_1_4, 1, 1, 4, 0x00, 0, 0},
 489         {FLASH_FLAG_WRITE_1_2_2, FLASH_CMD_WRITE_1_2_2, 1, 2, 2, 0x00, 0, 0},
 490         {FLASH_FLAG_WRITE_1_1_2, FLASH_CMD_WRITE_1_1_2, 1, 1, 2, 0x00, 0, 0},
 491         {FLASH_FLAG_READ_WRITE,  FLASH_CMD_WRITE,       1, 1, 1, 0x00, 0, 0},
 492         {0x00,                   0,                     0, 0, 0, 0x00, 0, 0},
 493 };
 494
 495 /*
 496  * [N25Qxxx] Configuration
 497  */
 498 #define N25Q_VCR_DUMMY_CYCLES(x)        (((x) & 0xf) << 4)
 499 #define N25Q_VCR_XIP_DISABLED           ((uint8_t)0x1 << 3)
 500 #define N25Q_VCR_WRAP_CONT              0x3
 501
 502 /* N25Q 3-byte Address READ configurations
 503  *      - 'FAST' variants configured for 8 dummy cycles.
 504  *
 505  * Note, the number of dummy cycles used for 'FAST' READ operations is
 506  * configurable and would normally be tuned according to the READ command and
 507  * operating frequency.  However, this applies universally to all 'FAST' READ
 508  * commands, including those used by the SPIBoot controller, and remains in
 509  * force until the device is power-cycled.  Since the SPIBoot controller is
 510  * hard-wired to use 8 dummy cycles, we must configure the device to also use 8
 511  * cycles.
 512  */
 513 static struct seq_rw_config n25q_read3_configs[] = {
 514         {FLASH_FLAG_READ_1_4_4, FLASH_CMD_READ_1_4_4,   0, 4, 4, 0x00, 0, 8},
 515         {FLASH_FLAG_READ_1_1_4, FLASH_CMD_READ_1_1_4,   0, 1, 4, 0x00, 0, 8},
 516         {FLASH_FLAG_READ_1_2_2, FLASH_CMD_READ_1_2_2,   0, 2, 2, 0x00, 0, 8},
 517         {FLASH_FLAG_READ_1_1_2, FLASH_CMD_READ_1_1_2,   0, 1, 2, 0x00, 0, 8},
 518         {FLASH_FLAG_READ_FAST,  FLASH_CMD_READ_FAST,    0, 1, 1, 0x00, 0, 8},
 519         {FLASH_FLAG_READ_WRITE, FLASH_CMD_READ,         0, 1, 1, 0x00, 0, 0},
 520         {0x00,                  0,                      0, 0, 0, 0x00, 0, 0},
 521 };
 522
 523 /* N25Q 4-byte Address READ configurations
 524  *      - use special 4-byte address READ commands (reduces overheads, and
 525  *        reduces risk of hitting watchdog reset issues).
 526  *      - 'FAST' variants configured for 8 dummy cycles (see note above.)
 527  */
 528 static struct seq_rw_config n25q_read4_configs[] = {
 529         {FLASH_FLAG_READ_1_4_4, FLASH_CMD_READ4_1_4_4,  0, 4, 4, 0x00, 0, 8},
 530         {FLASH_FLAG_READ_1_1_4, FLASH_CMD_READ4_1_1_4,  0, 1, 4, 0x00, 0, 8},
 531         {FLASH_FLAG_READ_1_2_2, FLASH_CMD_READ4_1_2_2,  0, 2, 2, 0x00, 0, 8},
 532         {FLASH_FLAG_READ_1_1_2, FLASH_CMD_READ4_1_1_2,  0, 1, 2, 0x00, 0, 8},
 533         {FLASH_FLAG_READ_FAST,  FLASH_CMD_READ4_FAST,   0, 1, 1, 0x00, 0, 8},
 534         {FLASH_FLAG_READ_WRITE, FLASH_CMD_READ4,        0, 1, 1, 0x00, 0, 0},
 535         {0x00,                  0,                      0, 0, 0, 0x00, 0, 0},
 536 };
 537
 538 /*
 539  * [MX25xxx] Configuration
 540  */
 541 #define MX25_STATUS_QE                  (0x1 << 6)
 542
 543 static int stfsm_mx25_en_32bit_addr_seq(struct stfsm_seq *seq)
 544 {
 545         seq->seq_opc[0] = (SEQ_OPC_PADS_1 |
 546                            SEQ_OPC_CYCLES(8) |
 547                            SEQ_OPC_OPCODE(FLASH_CMD_EN4B_ADDR) |
 548                            SEQ_OPC_CSDEASSERT);
 549
 550         seq->seq[0] = STFSM_INST_CMD1;
 551         seq->seq[1] = STFSM_INST_WAIT;
 552         seq->seq[2] = STFSM_INST_STOP;
 553
 554         seq->seq_cfg = (SEQ_CFG_PADS_1 |
 555                         SEQ_CFG_ERASE |
 556                         SEQ_CFG_READNOTWRITE |
 557                         SEQ_CFG_CSDEASSERT |
 558                         SEQ_CFG_STARTSEQ);
 559
 560         return 0;
 561 }
 562
 563 /*
 564  * [S25FLxxx] Configuration
 565  */
 566 #define STFSM_S25FL_CONFIG_QE           (0x1 << 1)
 567
 568 /*
 569  * S25FLxxxS devices provide three ways of supporting 32-bit addressing: Bank
 570  * Register, Extended Address Modes, and a 32-bit address command set.  The
 571  * 32-bit address command set is used here, since it avoids any problems with
 572  * entering a state that is incompatible with the SPIBoot Controller.
 573  */
 574 static struct seq_rw_config stfsm_s25fl_read4_configs[] = {
 575         {FLASH_FLAG_READ_1_4_4,  FLASH_CMD_READ4_1_4_4,  0, 4, 4, 0x00, 2, 4},
 576         {FLASH_FLAG_READ_1_1_4,  FLASH_CMD_READ4_1_1_4,  0, 1, 4, 0x00, 0, 8},
 577         {FLASH_FLAG_READ_1_2_2,  FLASH_CMD_READ4_1_2_2,  0, 2, 2, 0x00, 4, 0},
 578         {FLASH_FLAG_READ_1_1_2,  FLASH_CMD_READ4_1_1_2,  0, 1, 2, 0x00, 0, 8},
 579         {FLASH_FLAG_READ_FAST,   FLASH_CMD_READ4_FAST,   0, 1, 1, 0x00, 0, 8},
 580         {FLASH_FLAG_READ_WRITE,  FLASH_CMD_READ4,        0, 1, 1, 0x00, 0, 0},
 581         {0x00,                   0,                      0, 0, 0, 0x00, 0, 0},
 582 };
 583
 584 static struct seq_rw_config stfsm_s25fl_write4_configs[] = {
 585         {FLASH_FLAG_WRITE_1_1_4, S25FL_CMD_WRITE4_1_1_4, 1, 1, 4, 0x00, 0, 0},
 586         {FLASH_FLAG_READ_WRITE,  S25FL_CMD_WRITE4,       1, 1, 1, 0x00, 0, 0},
 587         {0x00,                   0,                      0, 0, 0, 0x00, 0, 0},
 588 };
 589
 590 /*
 591  * [W25Qxxx] Configuration
 592  */
 593 #define W25Q_STATUS_QE                  (0x1 << 9)
 594
 595 static struct stfsm_seq stfsm_seq_read_jedec = {
 596         .data_size = TRANSFER_SIZE(8),
 597         .seq_opc[0] = (SEQ_OPC_PADS_1 |
 598                        SEQ_OPC_CYCLES(8) |
 599                        SEQ_OPC_OPCODE(FLASH_CMD_RDID)),
 600         .seq = {
 601                 STFSM_INST_CMD1,
 602                 STFSM_INST_DATA_READ,
 603                 STFSM_INST_STOP,
 604         },
 605         .seq_cfg = (SEQ_CFG_PADS_1 |
 606                     SEQ_CFG_READNOTWRITE |
 607                     SEQ_CFG_CSDEASSERT |
 608                     SEQ_CFG_STARTSEQ),
 609 };
 610
 611 static struct stfsm_seq stfsm_seq_read_status_fifo = {
 612         .data_size = TRANSFER_SIZE(4),
 613         .seq_opc[0] = (SEQ_OPC_PADS_1 |
 614                        SEQ_OPC_CYCLES(8) |
 615                        SEQ_OPC_OPCODE(FLASH_CMD_RDSR)),
 616         .seq = {
 617                 STFSM_INST_CMD1,
 618                 STFSM_INST_DATA_READ,
 619                 STFSM_INST_STOP,
 620         },
 621         .seq_cfg = (SEQ_CFG_PADS_1 |
 622                     SEQ_CFG_READNOTWRITE |
 623                     SEQ_CFG_CSDEASSERT |
 624                     SEQ_CFG_STARTSEQ),
 625 };
 626
 627 static struct stfsm_seq stfsm_seq_erase_sector = {
 628         /* 'addr_cfg' configured during initialisation */
 629         .seq_opc = {
 630                 (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 631                  SEQ_OPC_OPCODE(FLASH_CMD_WREN) | SEQ_OPC_CSDEASSERT),
 632
 633                 (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 634                  SEQ_OPC_OPCODE(FLASH_CMD_SE)),
 635         },
 636         .seq = {
 637                 STFSM_INST_CMD1,
 638                 STFSM_INST_CMD2,
 639                 STFSM_INST_ADD1,
 640                 STFSM_INST_ADD2,
 641                 STFSM_INST_STOP,
 642         },
 643         .seq_cfg = (SEQ_CFG_PADS_1 |
 644                     SEQ_CFG_READNOTWRITE |
 645                     SEQ_CFG_CSDEASSERT |
 646                     SEQ_CFG_STARTSEQ),
 647 };
 648
 649 static struct stfsm_seq stfsm_seq_erase_chip = {
 650         .seq_opc = {
 651                 (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 652                  SEQ_OPC_OPCODE(FLASH_CMD_WREN) | SEQ_OPC_CSDEASSERT),
 653
 654                 (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 655                  SEQ_OPC_OPCODE(FLASH_CMD_CHIPERASE) | SEQ_OPC_CSDEASSERT),
 656         },
 657         .seq = {
 658                 STFSM_INST_CMD1,
 659                 STFSM_INST_CMD2,
 660                 STFSM_INST_WAIT,
 661                 STFSM_INST_STOP,
 662         },
 663         .seq_cfg = (SEQ_CFG_PADS_1 |
 664                     SEQ_CFG_ERASE |
 665                     SEQ_CFG_READNOTWRITE |
 666                     SEQ_CFG_CSDEASSERT |
 667                     SEQ_CFG_STARTSEQ),
 668 };
 669
 670 static struct stfsm_seq stfsm_seq_write_status = {
 671         .seq_opc[0] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 672                        SEQ_OPC_OPCODE(FLASH_CMD_WREN) | SEQ_OPC_CSDEASSERT),
 673         .seq_opc[1] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 674                        SEQ_OPC_OPCODE(FLASH_CMD_WRSR)),
 675         .seq = {
 676                 STFSM_INST_CMD1,
 677                 STFSM_INST_CMD2,
 678                 STFSM_INST_STA_WR1,
 679                 STFSM_INST_STOP,
 680         },
 681         .seq_cfg = (SEQ_CFG_PADS_1 |
 682                     SEQ_CFG_READNOTWRITE |
 683                     SEQ_CFG_CSDEASSERT |
 684                     SEQ_CFG_STARTSEQ),
 685 };
 686
 687 static struct stfsm_seq stfsm_seq_wrvcr = {
 688         .seq_opc[0] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 689                        SEQ_OPC_OPCODE(FLASH_CMD_WREN) | SEQ_OPC_CSDEASSERT),
 690         .seq_opc[1] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 691                        SEQ_OPC_OPCODE(FLASH_CMD_WRVCR)),
 692         .seq = {
 693                 STFSM_INST_CMD1,
 694                 STFSM_INST_CMD2,
 695                 STFSM_INST_STA_WR1,
 696                 STFSM_INST_STOP,
 697         },
 698         .seq_cfg = (SEQ_CFG_PADS_1 |
 699                     SEQ_CFG_READNOTWRITE |
 700                     SEQ_CFG_CSDEASSERT |
 701                     SEQ_CFG_STARTSEQ),
 702 };
 703
 704 static int stfsm_n25q_en_32bit_addr_seq(struct stfsm_seq *seq)
 705 {
 706         seq->seq_opc[0] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 707                            SEQ_OPC_OPCODE(FLASH_CMD_EN4B_ADDR));
 708         seq->seq_opc[1] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
 709                            SEQ_OPC_OPCODE(FLASH_CMD_WREN) |
 710                            SEQ_OPC_CSDEASSERT);
 711
 712         seq->seq[0] = STFSM_INST_CMD2;
 713         seq->seq[1] = STFSM_INST_CMD1;
 714         seq->seq[2] = STFSM_INST_WAIT;
 715         seq->seq[3] = STFSM_INST_STOP;
 716
 717         seq->seq_cfg = (SEQ_CFG_PADS_1 |
 718                         SEQ_CFG_ERASE |
 719                         SEQ_CFG_READNOTWRITE |
 720                         SEQ_CFG_CSDEASSERT |
 721                         SEQ_CFG_STARTSEQ);
 722
 723         return 0;
 724 }
 725
 726 static inline int stfsm_is_idle(struct stfsm *fsm)
 727 {
 728         return readl(fsm->base + SPI_FAST_SEQ_STA) & 0x10;
 729 }
 730
 731 static inline uint32_t stfsm_fifo_available(struct stfsm *fsm)
 732 {
 733         return (readl(fsm->base + SPI_FAST_SEQ_STA) >> 5) & 0x7f;
 734 }
 735
 736 static void stfsm_clear_fifo(struct stfsm *fsm)
 737 {
 738         uint32_t avail;
 739
 740         for (;;) {
 741                 avail = stfsm_fifo_available(fsm);
 742                 if (!avail)
 743                         break;
 744
 745                 while (avail) {
 746                         readl(fsm->base + SPI_FAST_SEQ_DATA_REG);
 747                         avail--;
 748                 }
 749         }
 750 }
 751
 752 static inline void stfsm_load_seq(struct stfsm *fsm,
 753                                   const struct stfsm_seq *seq)
 754 {
 755         void __iomem *dst = fsm->base + SPI_FAST_SEQ_TRANSFER_SIZE;
 756         const uint32_t *src = (const uint32_t *)seq;
 757         int words = sizeof(*seq) / sizeof(*src);
 758
 759         BUG_ON(!stfsm_is_idle(fsm));
 760
 761         while (words--) {
 762                 writel(*src, dst);
 763                 src++;
 764                 dst += 4;
 765         }
 766 }
 767
 768 static void stfsm_wait_seq(struct stfsm *fsm)
 769 {
 770         unsigned long deadline;
 771         int timeout = 0;
 772
 773         deadline = jiffies + msecs_to_jiffies(STFSM_MAX_WAIT_SEQ_MS);
 774
 775         while (!timeout) {
 776                 if (time_after_eq(jiffies, deadline))
 777                         timeout = 1;
 778
 779                 if (stfsm_is_idle(fsm))
 780                         return;
 781
 782                 cond_resched();
 783         }
 784
 785         dev_err(fsm->dev, "timeout on sequence completion\n");
 786 }
 787
 788 static void stfsm_read_fifo(struct stfsm *fsm, uint32_t *buf, uint32_t size)
 789 {
 790         uint32_t remaining = size >> 2;
 791         uint32_t avail;
 792         uint32_t words;
 793
 794         dev_dbg(fsm->dev, "Reading %d bytes from FIFO\n", size);
 795
 796         BUG_ON((((uint32_t)buf) & 0x3) || (size & 0x3));
 797
 798         while (remaining) {
 799                 for (;;) {
 800                         avail = stfsm_fifo_available(fsm);
 801                         if (avail)
 802                                 break;
 803                         udelay(1);
 804                 }
 805                 words = min(avail, remaining);
 806                 remaining -= words;
 807
 808                 readsl(fsm->base + SPI_FAST_SEQ_DATA_REG, buf, words);
 809                 buf += words;
 810         }
 811 }
 812
 813 static int stfsm_write_fifo(struct stfsm *fsm, const uint32_t *buf,
 814                             uint32_t size)
 815 {
 816         uint32_t words = size >> 2;
 817
 818         dev_dbg(fsm->dev, "writing %d bytes to FIFO\n", size);
 819
 820         BUG_ON((((uint32_t)buf) & 0x3) || (size & 0x3));
 821
 822         writesl(fsm->base + SPI_FAST_SEQ_DATA_REG, buf, words);
 823
 824         return size;
 825 }
 826
 827 static int stfsm_enter_32bit_addr(struct stfsm *fsm, int enter)
 828 {
 829         struct stfsm_seq *seq = &fsm->stfsm_seq_en_32bit_addr;
 830         uint32_t cmd = enter ? FLASH_CMD_EN4B_ADDR : FLASH_CMD_EX4B_ADDR;
 831
 832         seq->seq_opc[0] = (SEQ_OPC_PADS_1 |
 833                            SEQ_OPC_CYCLES(8) |
 834                            SEQ_OPC_OPCODE(cmd) |
 835                            SEQ_OPC_CSDEASSERT);
 836
 837         stfsm_load_seq(fsm, seq);
 838
 839         stfsm_wait_seq(fsm);
 840
 841         return 0;
 842 }
 843
 844 static uint8_t stfsm_wait_busy(struct stfsm *fsm)
 845 {
 846         struct stfsm_seq *seq = &stfsm_seq_read_status_fifo;
 847         unsigned long deadline;
 848         uint32_t status;
 849         int timeout = 0;
 850
 851         /* Use RDRS1 */
 852         seq->seq_opc[0] = (SEQ_OPC_PADS_1 |
 853                            SEQ_OPC_CYCLES(8) |
 854                            SEQ_OPC_OPCODE(FLASH_CMD_RDSR));
 855
 856         /* Load read_status sequence */
 857         stfsm_load_seq(fsm, seq);
 858
 859         /*
 860          * Repeat until busy bit is deasserted, or timeout, or error (S25FLxxxS)
 861          */
 862         deadline = jiffies + FLASH_MAX_BUSY_WAIT;
 863         while (!timeout) {
 864                 if (time_after_eq(jiffies, deadline))
 865                         timeout = 1;
 866
 867                 stfsm_wait_seq(fsm);
 868
 869                 stfsm_read_fifo(fsm, &status, 4);
 870
 871                 if ((status & FLASH_STATUS_BUSY) == 0)
 872                         return 0;
 873
 874                 if ((fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS) &&
 875                     ((status & S25FL_STATUS_P_ERR) ||
 876                      (status & S25FL_STATUS_E_ERR)))
 877                         return (uint8_t)(status & 0xff);
 878
 879                 if (!timeout)
 880                         /* Restart */
 881                         writel(seq->seq_cfg, fsm->base + SPI_FAST_SEQ_CFG);
 882
 883                 cond_resched();
 884         }
 885
 886         dev_err(fsm->dev, "timeout on wait_busy\n");
 887
 888         return FLASH_STATUS_TIMEOUT;
 889 }
 890
 891 static int stfsm_read_status(struct stfsm *fsm, uint8_t cmd,
 892                            uint8_t *status)
 893 {
 894         struct stfsm_seq *seq = &stfsm_seq_read_status_fifo;
 895         uint32_t tmp;
 896
 897         dev_dbg(fsm->dev, "reading STA[%s]\n",
 898                 (cmd == FLASH_CMD_RDSR) ? "1" : "2");
 899
 900         seq->seq_opc[0] = (SEQ_OPC_PADS_1 |
 901                            SEQ_OPC_CYCLES(8) |
 902                            SEQ_OPC_OPCODE(cmd)),
 903
 904         stfsm_load_seq(fsm, seq);
 905
 906         stfsm_read_fifo(fsm, &tmp, 4);
 907
 908         *status = (uint8_t)(tmp >> 24);
 909
 910         stfsm_wait_seq(fsm);
 911
 912         return 0;
 913 }
 914
 915 static int stfsm_write_status(struct stfsm *fsm, uint16_t status,
 916                                int sta_bytes)
 917 {
 918         struct stfsm_seq *seq = &stfsm_seq_write_status;
 919
 920         dev_dbg(fsm->dev, "writing STA[%s] 0x%04x\n",
 921                 (sta_bytes == 1) ? "1" : "1+2", status);
 922
 923         seq->status = (uint32_t)status | STA_PADS_1 | STA_CSDEASSERT;
 924         seq->seq[2] = (sta_bytes == 1) ?
 925                 STFSM_INST_STA_WR1 : STFSM_INST_STA_WR1_2;
 926
 927         stfsm_load_seq(fsm, seq);
 928
 929         stfsm_wait_seq(fsm);
 930
 931         return 0;
 932 };
 933
 934 static int stfsm_wrvcr(struct stfsm *fsm, uint8_t data)
 935 {
 936         struct stfsm_seq *seq = &stfsm_seq_wrvcr;
 937
 938         dev_dbg(fsm->dev, "writing VCR 0x%02x\n", data);
 939
 940         seq->status = (STA_DATA_BYTE1(data) | STA_PADS_1 | STA_CSDEASSERT);
 941
 942         stfsm_load_seq(fsm, seq);
 943
 944         stfsm_wait_seq(fsm);
 945
 946         return 0;
 947 }
 948
 949 /*
 950  * SoC reset on 'boot-from-spi' systems
 951  *
 952  * Certain modes of operation cause the Flash device to enter a particular state
 953  * for a period of time (e.g. 'Erase Sector', 'Quad Enable', and 'Enter 32-bit
 954  * Addr' commands).  On boot-from-spi systems, it is important to consider what
 955  * happens if a warm reset occurs during this period.  The SPIBoot controller
 956  * assumes that Flash device is in its default reset state, 24-bit address mode,
 957  * and ready to accept commands.  This can be achieved using some form of
 958  * on-board logic/controller to force a device POR in response to a SoC-level
 959  * reset or by making use of the device reset signal if available (limited
 960  * number of devices only).
 961  *
 962  * Failure to take such precautions can cause problems following a warm reset.
 963  * For some operations (e.g. ERASE), there is little that can be done.  For
 964  * other modes of operation (e.g. 32-bit addressing), options are often
 965  * available that can help minimise the window in which a reset could cause a
 966  * problem.
 967  *
 968  */
 969 static bool stfsm_can_handle_soc_reset(struct stfsm *fsm)
 970 {
 971         /* Reset signal is available on the board and supported by the device */
 972         if (fsm->reset_signal && fsm->info->flags & FLASH_FLAG_RESET)
 973                 return true;
 974
 975         /* Board-level logic forces a power-on-reset */
 976         if (fsm->reset_por)
 977                 return true;
 978
 979         /* Reset is not properly handled and may result in failure to reboot */
 980         return false;
 981 }
 982
 983 /* Configure 'addr_cfg' according to addressing mode */
 984 static void stfsm_prepare_erasesec_seq(struct stfsm *fsm,
 985                                        struct stfsm_seq *seq)
 986 {
 987         int addr1_cycles = fsm->info->flags & FLASH_FLAG_32BIT_ADDR ? 16 : 8;
 988
 989         seq->addr_cfg = (ADR_CFG_CYCLES_ADD1(addr1_cycles) |
 990                          ADR_CFG_PADS_1_ADD1 |
 991                          ADR_CFG_CYCLES_ADD2(16) |
 992                          ADR_CFG_PADS_1_ADD2 |
 993                          ADR_CFG_CSDEASSERT_ADD2);
 994 }
 995
 996 /* Search for preferred configuration based on available flags */
 997 static struct seq_rw_config *
 998 stfsm_search_seq_rw_configs(struct stfsm *fsm,
 999                             struct seq_rw_config cfgs[])
1000 {
1001         struct seq_rw_config *config;
1002         int flags = fsm->info->flags;
1003
1004         for (config = cfgs; config->cmd != 0; config++)
1005                 if ((config->flags & flags) == config->flags)
1006                         return config;
1007
1008         return NULL;
1009 }
1010
1011 /* Prepare a READ/WRITE sequence according to configuration parameters */
1012 static void stfsm_prepare_rw_seq(struct stfsm *fsm,
1013                                  struct stfsm_seq *seq,
1014                                  struct seq_rw_config *cfg)
1015 {
1016         int addr1_cycles, addr2_cycles;
1017         int i = 0;
1018
1019         memset(seq, 0, sizeof(*seq));
1020
1021         /* Add READ/WRITE OPC  */
1022         seq->seq_opc[i++] = (SEQ_OPC_PADS_1 |
1023                              SEQ_OPC_CYCLES(8) |
1024                              SEQ_OPC_OPCODE(cfg->cmd));
1025
1026         /* Add WREN OPC for a WRITE sequence */
1027         if (cfg->write)
1028                 seq->seq_opc[i++] = (SEQ_OPC_PADS_1 |
1029                                      SEQ_OPC_CYCLES(8) |
1030                                      SEQ_OPC_OPCODE(FLASH_CMD_WREN) |
1031                                      SEQ_OPC_CSDEASSERT);
1032
1033         /* Address configuration (24 or 32-bit addresses) */
1034         addr1_cycles  = (fsm->info->flags & FLASH_FLAG_32BIT_ADDR) ? 16 : 8;
1035         addr1_cycles /= cfg->addr_pads;
1036         addr2_cycles  = 16 / cfg->addr_pads;
1037         seq->addr_cfg = ((addr1_cycles & 0x3f) << 0 |   /* ADD1 cycles */
1038                          (cfg->addr_pads - 1) << 6 |    /* ADD1 pads */
1039                          (addr2_cycles & 0x3f) << 16 |  /* ADD2 cycles */
1040                          ((cfg->addr_pads - 1) << 22)); /* ADD2 pads */
1041
1042         /* Data/Sequence configuration */
1043         seq->seq_cfg = ((cfg->data_pads - 1) << 16 |
1044                         SEQ_CFG_STARTSEQ |
1045                         SEQ_CFG_CSDEASSERT);
1046         if (!cfg->write)
1047                 seq->seq_cfg |= SEQ_CFG_READNOTWRITE;
1048
1049         /* Mode configuration (no. of pads taken from addr cfg) */
1050         seq->mode = ((cfg->mode_data & 0xff) << 0 |     /* data */
1051                      (cfg->mode_cycles & 0x3f) << 16 |  /* cycles */
1052                      (cfg->addr_pads - 1) << 22);       /* pads */
1053
1054         /* Dummy configuration (no. of pads taken from addr cfg) */
1055         seq->dummy = ((cfg->dummy_cycles & 0x3f) << 16 |        /* cycles */
1056                       (cfg->addr_pads - 1) << 22);              /* pads */
1057
1058
1059         /* Instruction sequence */
1060         i = 0;
1061         if (cfg->write)
1062                 seq->seq[i++] = STFSM_INST_CMD2;
1063
1064         seq->seq[i++] = STFSM_INST_CMD1;
1065
1066         seq->seq[i++] = STFSM_INST_ADD1;
1067         seq->seq[i++] = STFSM_INST_ADD2;
1068
1069         if (cfg->mode_cycles)
1070                 seq->seq[i++] = STFSM_INST_MODE;
1071
1072         if (cfg->dummy_cycles)
1073                 seq->seq[i++] = STFSM_INST_DUMMY;
1074
1075         seq->seq[i++] =
1076                 cfg->write ? STFSM_INST_DATA_WRITE : STFSM_INST_DATA_READ;
1077         seq->seq[i++] = STFSM_INST_STOP;
1078 }
1079
1080 static int stfsm_search_prepare_rw_seq(struct stfsm *fsm,
1081                                        struct stfsm_seq *seq,
1082                                        struct seq_rw_config *cfgs)
1083 {
1084         struct seq_rw_config *config;
1085
1086         config = stfsm_search_seq_rw_configs(fsm, cfgs);
1087         if (!config) {
1088                 dev_err(fsm->dev, "failed to find suitable config\n");
1089                 return -EINVAL;
1090         }
1091
1092         stfsm_prepare_rw_seq(fsm, seq, config);
1093
1094         return 0;
1095 }
1096
1097 /* Prepare a READ/WRITE/ERASE 'default' sequences */
1098 static int stfsm_prepare_rwe_seqs_default(struct stfsm *fsm)
1099 {
1100         uint32_t flags = fsm->info->flags;
1101         int ret;
1102
1103         /* Configure 'READ' sequence */
1104         ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read,
1105                                           default_read_configs);
1106         if (ret) {
1107                 dev_err(fsm->dev,
1108                         "failed to prep READ sequence with flags [0x%08x]\n",
1109                         flags);
1110                 return ret;
1111         }
1112
1113         /* Configure 'WRITE' sequence */
1114         ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write,
1115                                           default_write_configs);
1116         if (ret) {
1117                 dev_err(fsm->dev,
1118                         "failed to prep WRITE sequence with flags [0x%08x]\n",
1119                         flags);
1120                 return ret;
1121         }
1122
1123         /* Configure 'ERASE_SECTOR' sequence */
1124         stfsm_prepare_erasesec_seq(fsm, &stfsm_seq_erase_sector);
1125
1126         return 0;
1127 }
1128
1129 static int stfsm_mx25_config(struct stfsm *fsm)
1130 {
1131         uint32_t flags = fsm->info->flags;
1132         uint32_t data_pads;
1133         uint8_t sta;
1134         int ret;
1135         bool soc_reset;
1136
1137         /*
1138          * Use default READ/WRITE sequences
1139          */
1140         ret = stfsm_prepare_rwe_seqs_default(fsm);
1141         if (ret)
1142                 return ret;
1143
1144         /*
1145          * Configure 32-bit Address Support
1146          */
1147         if (flags & FLASH_FLAG_32BIT_ADDR) {
1148                 /* Configure 'enter_32bitaddr' FSM sequence */
1149                 stfsm_mx25_en_32bit_addr_seq(&fsm->stfsm_seq_en_32bit_addr);
1150
1151                 soc_reset = stfsm_can_handle_soc_reset(fsm);
1152                 if (soc_reset || !fsm->booted_from_spi) {
1153                         /* If we can handle SoC resets, we enable 32-bit address
1154                          * mode pervasively */
1155                         stfsm_enter_32bit_addr(fsm, 1);
1156
1157                 } else {
1158                         /* Else, enable/disable 32-bit addressing before/after
1159                          * each operation */
1160                         fsm->configuration = (CFG_READ_TOGGLE_32BIT_ADDR |
1161                                               CFG_WRITE_TOGGLE_32BIT_ADDR |
1162                                               CFG_ERASESEC_TOGGLE_32BIT_ADDR);
1163                         /* It seems a small delay is required after exiting
1164                          * 32-bit mode following a write operation.  The issue
1165                          * is under investigation.
1166                          */
1167                         fsm->configuration |= CFG_WRITE_EX_32BIT_ADDR_DELAY;
1168                 }
1169         }
1170
1171         /* For QUAD mode, set 'QE' STATUS bit */
1172         data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1;
1173         if (data_pads == 4) {
1174                 stfsm_read_status(fsm, FLASH_CMD_RDSR, &sta);
1175                 sta |= MX25_STATUS_QE;
1176                 stfsm_write_status(fsm, sta, 1);
1177         }
1178
1179         return 0;
1180 }
1181
1182 static int stfsm_n25q_config(struct stfsm *fsm)
1183 {
1184         uint32_t flags = fsm->info->flags;
1185         uint8_t vcr;
1186         int ret = 0;
1187         bool soc_reset;
1188
1189         /* Configure 'READ' sequence */
1190         if (flags & FLASH_FLAG_32BIT_ADDR)
1191                 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read,
1192                                                   n25q_read4_configs);
1193         else
1194                 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read,
1195                                                   n25q_read3_configs);
1196         if (ret) {
1197                 dev_err(fsm->dev,
1198                         "failed to prepare READ sequence with flags [0x%08x]\n",
1199                         flags);
1200                 return ret;
1201         }
1202
1203         /* Configure 'WRITE' sequence (default configs) */
1204         ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write,
1205                                           default_write_configs);
1206         if (ret) {
1207                 dev_err(fsm->dev,
1208                         "preparing WRITE sequence using flags [0x%08x] failed\n",
1209                         flags);
1210                 return ret;
1211         }
1212
1213         /* * Configure 'ERASE_SECTOR' sequence */
1214         stfsm_prepare_erasesec_seq(fsm, &stfsm_seq_erase_sector);
1215
1216         /* Configure 32-bit address support */
1217         if (flags & FLASH_FLAG_32BIT_ADDR) {
1218                 stfsm_n25q_en_32bit_addr_seq(&fsm->stfsm_seq_en_32bit_addr);
1219
1220                 soc_reset = stfsm_can_handle_soc_reset(fsm);
1221                 if (soc_reset || !fsm->booted_from_spi) {
1222                         /*
1223                          * If we can handle SoC resets, we enable 32-bit
1224                          * address mode pervasively
1225                          */
1226                         stfsm_enter_32bit_addr(fsm, 1);
1227                 } else {
1228                         /*
1229                          * If not, enable/disable for WRITE and ERASE
1230                          * operations (READ uses special commands)
1231                          */
1232                         fsm->configuration = (CFG_WRITE_TOGGLE_32BIT_ADDR |
1233                                               CFG_ERASESEC_TOGGLE_32BIT_ADDR);
1234                 }
1235         }
1236
1237         /*
1238          * Configure device to use 8 dummy cycles
1239          */
1240         vcr = (N25Q_VCR_DUMMY_CYCLES(8) | N25Q_VCR_XIP_DISABLED |
1241                N25Q_VCR_WRAP_CONT);
1242         stfsm_wrvcr(fsm, vcr);
1243
1244         return 0;
1245 }
1246
1247 static void stfsm_s25fl_prepare_erasesec_seq_32(struct stfsm_seq *seq)
1248 {
1249         seq->seq_opc[1] = (SEQ_OPC_PADS_1 |
1250                            SEQ_OPC_CYCLES(8) |
1251                            SEQ_OPC_OPCODE(S25FL_CMD_SE4));
1252
1253         seq->addr_cfg = (ADR_CFG_CYCLES_ADD1(16) |
1254                          ADR_CFG_PADS_1_ADD1 |
1255                          ADR_CFG_CYCLES_ADD2(16) |
1256                          ADR_CFG_PADS_1_ADD2 |
1257                          ADR_CFG_CSDEASSERT_ADD2);
1258 }
1259
1260 static void stfsm_s25fl_read_dyb(struct stfsm *fsm, uint32_t offs, uint8_t *dby)
1261 {
1262         uint32_t tmp;
1263         struct stfsm_seq seq = {
1264                 .data_size = TRANSFER_SIZE(4),
1265                 .seq_opc[0] = (SEQ_OPC_PADS_1 |
1266                                SEQ_OPC_CYCLES(8) |
1267                                SEQ_OPC_OPCODE(S25FL_CMD_DYBRD)),
1268                 .addr_cfg = (ADR_CFG_CYCLES_ADD1(16) |
1269                              ADR_CFG_PADS_1_ADD1 |
1270                              ADR_CFG_CYCLES_ADD2(16) |
1271                              ADR_CFG_PADS_1_ADD2),
1272                 .addr1 = (offs >> 16) & 0xffff,
1273                 .addr2 = offs & 0xffff,
1274                 .seq = {
1275                         STFSM_INST_CMD1,
1276                         STFSM_INST_ADD1,
1277                         STFSM_INST_ADD2,
1278                         STFSM_INST_DATA_READ,
1279                         STFSM_INST_STOP,
1280                 },
1281                 .seq_cfg = (SEQ_CFG_PADS_1 |
1282                             SEQ_CFG_READNOTWRITE |
1283                             SEQ_CFG_CSDEASSERT |
1284                             SEQ_CFG_STARTSEQ),
1285         };
1286
1287         stfsm_load_seq(fsm, &seq);
1288
1289         stfsm_read_fifo(fsm, &tmp, 4);
1290
1291         *dby = (uint8_t)(tmp >> 24);
1292
1293         stfsm_wait_seq(fsm);
1294 }
1295
1296 static void stfsm_s25fl_write_dyb(struct stfsm *fsm, uint32_t offs, uint8_t dby)
1297 {
1298         struct stfsm_seq seq = {
1299                 .seq_opc[0] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
1300                                SEQ_OPC_OPCODE(FLASH_CMD_WREN) |
1301                                SEQ_OPC_CSDEASSERT),
1302                 .seq_opc[1] = (SEQ_OPC_PADS_1 | SEQ_OPC_CYCLES(8) |
1303                                SEQ_OPC_OPCODE(S25FL_CMD_DYBWR)),
1304                 .addr_cfg = (ADR_CFG_CYCLES_ADD1(16) |
1305                              ADR_CFG_PADS_1_ADD1 |
1306                              ADR_CFG_CYCLES_ADD2(16) |
1307                              ADR_CFG_PADS_1_ADD2),
1308                 .status = (uint32_t)dby | STA_PADS_1 | STA_CSDEASSERT,
1309                 .addr1 = (offs >> 16) & 0xffff,
1310                 .addr2 = offs & 0xffff,
1311                 .seq = {
1312                         STFSM_INST_CMD1,
1313                         STFSM_INST_CMD2,
1314                         STFSM_INST_ADD1,
1315                         STFSM_INST_ADD2,
1316                         STFSM_INST_STA_WR1,
1317                         STFSM_INST_STOP,
1318                 },
1319                 .seq_cfg = (SEQ_CFG_PADS_1 |
1320                             SEQ_CFG_READNOTWRITE |
1321                             SEQ_CFG_CSDEASSERT |
1322                             SEQ_CFG_STARTSEQ),
1323         };
1324
1325         stfsm_load_seq(fsm, &seq);
1326         stfsm_wait_seq(fsm);
1327
1328         stfsm_wait_busy(fsm);
1329 }
1330
1331 static int stfsm_s25fl_clear_status_reg(struct stfsm *fsm)
1332 {
1333         struct stfsm_seq seq = {
1334                 .seq_opc[0] = (SEQ_OPC_PADS_1 |
1335                                SEQ_OPC_CYCLES(8) |
1336                                SEQ_OPC_OPCODE(S25FL_CMD_CLSR) |
1337                                SEQ_OPC_CSDEASSERT),
1338                 .seq_opc[1] = (SEQ_OPC_PADS_1 |
1339                                SEQ_OPC_CYCLES(8) |
1340                                SEQ_OPC_OPCODE(FLASH_CMD_WRDI) |
1341                                SEQ_OPC_CSDEASSERT),
1342                 .seq = {
1343                         STFSM_INST_CMD1,
1344                         STFSM_INST_CMD2,
1345                         STFSM_INST_WAIT,
1346                         STFSM_INST_STOP,
1347                 },
1348                 .seq_cfg = (SEQ_CFG_PADS_1 |
1349                             SEQ_CFG_ERASE |
1350                             SEQ_CFG_READNOTWRITE |
1351                             SEQ_CFG_CSDEASSERT |
1352                             SEQ_CFG_STARTSEQ),
1353         };
1354
1355         stfsm_load_seq(fsm, &seq);
1356
1357         stfsm_wait_seq(fsm);
1358
1359         return 0;
1360 }
1361
1362 static int stfsm_s25fl_config(struct stfsm *fsm)
1363 {
1364         struct flash_info *info = fsm->info;
1365         uint32_t flags = info->flags;
1366         uint32_t data_pads;
1367         uint32_t offs;
1368         uint16_t sta_wr;
1369         uint8_t sr1, cr1, dyb;
1370         int ret;
1371
1372         if (flags & FLASH_FLAG_32BIT_ADDR) {
1373                 /*
1374                  * Prepare Read/Write/Erase sequences according to S25FLxxx
1375                  * 32-bit address command set
1376                  */
1377                 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_read,
1378                                                   stfsm_s25fl_read4_configs);
1379                 if (ret)
1380                         return ret;
1381
1382                 ret = stfsm_search_prepare_rw_seq(fsm, &fsm->stfsm_seq_write,
1383                                                   stfsm_s25fl_write4_configs);
1384                 if (ret)
1385                         return ret;
1386
1387                 stfsm_s25fl_prepare_erasesec_seq_32(&stfsm_seq_erase_sector);
1388
1389         } else {
1390                 /* Use default configurations for 24-bit addressing */
1391                 ret = stfsm_prepare_rwe_seqs_default(fsm);
1392                 if (ret)
1393                         return ret;
1394         }
1395
1396         /*
1397          * For devices that support 'DYB' sector locking, check lock status and
1398          * unlock sectors if necessary (some variants power-on with sectors
1399          * locked by default)
1400          */
1401         if (flags & FLASH_FLAG_DYB_LOCKING) {
1402                 offs = 0;
1403                 for (offs = 0; offs < info->sector_size * info->n_sectors;) {
1404                         stfsm_s25fl_read_dyb(fsm, offs, &dyb);
1405                         if (dyb == 0x00)
1406                                 stfsm_s25fl_write_dyb(fsm, offs, 0xff);
1407
1408                         /* Handle bottom/top 4KiB parameter sectors */
1409                         if ((offs < info->sector_size * 2) ||
1410                             (offs >= (info->sector_size - info->n_sectors * 4)))
1411                                 offs += 0x1000;
1412                         else
1413                                 offs += 0x10000;
1414                 }
1415         }
1416
1417         /* Check status of 'QE' bit */
1418         data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1;
1419         stfsm_read_status(fsm, FLASH_CMD_RDSR2, &cr1);
1420         if (data_pads == 4) {
1421                 if (!(cr1 & STFSM_S25FL_CONFIG_QE)) {
1422                         /* Set 'QE' */
1423                         cr1 |= STFSM_S25FL_CONFIG_QE;
1424
1425                         stfsm_read_status(fsm, FLASH_CMD_RDSR, &sr1);
1426                         sta_wr = ((uint16_t)cr1  << 8) | sr1;
1427
1428                         stfsm_write_status(fsm, sta_wr, 2);
1429
1430                         stfsm_wait_busy(fsm);
1431                 }
1432         } else {
1433                 if ((cr1 & STFSM_S25FL_CONFIG_QE)) {
1434                         /* Clear 'QE' */
1435                         cr1 &= ~STFSM_S25FL_CONFIG_QE;
1436
1437                         stfsm_read_status(fsm, FLASH_CMD_RDSR, &sr1);
1438                         sta_wr = ((uint16_t)cr1  << 8) | sr1;
1439
1440                         stfsm_write_status(fsm, sta_wr, 2);
1441
1442                         stfsm_wait_busy(fsm);
1443                 }
1444
1445         }
1446
1447         /*
1448          * S25FLxxx devices support Program and Error error flags.
1449          * Configure driver to check flags and clear if necessary.
1450          */
1451         fsm->configuration |= CFG_S25FL_CHECK_ERROR_FLAGS;
1452
1453         return 0;
1454 }
1455
1456 static int stfsm_w25q_config(struct stfsm *fsm)
1457 {
1458         uint32_t data_pads;
1459         uint16_t sta_wr;
1460         uint8_t sta1, sta2;
1461         int ret;
1462
1463         ret = stfsm_prepare_rwe_seqs_default(fsm);
1464         if (ret)
1465                 return ret;
1466
1467         /* If using QUAD mode, set QE STATUS bit */
1468         data_pads = ((fsm->stfsm_seq_read.seq_cfg >> 16) & 0x3) + 1;
1469         if (data_pads == 4) {
1470                 stfsm_read_status(fsm, FLASH_CMD_RDSR, &sta1);
1471                 stfsm_read_status(fsm, FLASH_CMD_RDSR2, &sta2);
1472
1473                 sta_wr = ((uint16_t)sta2 << 8) | sta1;
1474
1475                 sta_wr |= W25Q_STATUS_QE;
1476
1477                 stfsm_write_status(fsm, sta_wr, 2);
1478
1479                 stfsm_wait_busy(fsm);
1480         }
1481
1482         return 0;
1483 }
1484
1485 static int stfsm_read(struct stfsm *fsm, uint8_t *buf, uint32_t size,
1486                       uint32_t offset)
1487 {
1488         struct stfsm_seq *seq = &fsm->stfsm_seq_read;
1489         uint32_t data_pads;
1490         uint32_t read_mask;
1491         uint32_t size_ub;
1492         uint32_t size_lb;
1493         uint32_t size_mop;
1494         uint32_t tmp[4];
1495         uint32_t page_buf[FLASH_PAGESIZE_32];
1496         uint8_t *p;
1497
1498         dev_dbg(fsm->dev, "reading %d bytes from 0x%08x\n", size, offset);
1499
1500         /* Enter 32-bit address mode, if required */
1501         if (fsm->configuration & CFG_READ_TOGGLE_32BIT_ADDR)
1502                 stfsm_enter_32bit_addr(fsm, 1);
1503
1504         /* Must read in multiples of 32 cycles (or 32*pads/8 Bytes) */
1505         data_pads = ((seq->seq_cfg >> 16) & 0x3) + 1;
1506         read_mask = (data_pads << 2) - 1;
1507
1508         /* Handle non-aligned buf */
1509         p = ((uint32_t)buf & 0x3) ? (uint8_t *)page_buf : buf;
1510
1511         /* Handle non-aligned size */
1512         size_ub = (size + read_mask) & ~read_mask;
1513         size_lb = size & ~read_mask;
1514         size_mop = size & read_mask;
1515
1516         seq->data_size = TRANSFER_SIZE(size_ub);
1517         seq->addr1 = (offset >> 16) & 0xffff;
1518         seq->addr2 = offset & 0xffff;
1519
1520         stfsm_load_seq(fsm, seq);
1521
1522         if (size_lb)
1523                 stfsm_read_fifo(fsm, (uint32_t *)p, size_lb);
1524
1525         if (size_mop) {
1526                 stfsm_read_fifo(fsm, tmp, read_mask + 1);
1527                 memcpy(p + size_lb, &tmp, size_mop);
1528         }
1529
1530         /* Handle non-aligned buf */
1531         if ((uint32_t)buf & 0x3)
1532                 memcpy(buf, page_buf, size);
1533
1534         /* Wait for sequence to finish */
1535         stfsm_wait_seq(fsm);
1536
1537         stfsm_clear_fifo(fsm);
1538
1539         /* Exit 32-bit address mode, if required */
1540         if (fsm->configuration & CFG_READ_TOGGLE_32BIT_ADDR)
1541                 stfsm_enter_32bit_addr(fsm, 0);
1542
1543         return 0;
1544 }
1545
1546 static int stfsm_write(struct stfsm *fsm, const uint8_t *buf,
1547                        uint32_t size, uint32_t offset)
1548 {
1549         struct stfsm_seq *seq = &fsm->stfsm_seq_write;
1550         uint32_t data_pads;
1551         uint32_t write_mask;
1552         uint32_t size_ub;
1553         uint32_t size_lb;
1554         uint32_t size_mop;
1555         uint32_t tmp[4];
1556         uint32_t page_buf[FLASH_PAGESIZE_32];
1557         uint8_t *t = (uint8_t *)&tmp;
1558         const uint8_t *p;
1559         int ret;
1560         int i;
1561
1562         dev_dbg(fsm->dev, "writing %d bytes to 0x%08x\n", size, offset);
1563
1564         /* Enter 32-bit address mode, if required */
1565         if (fsm->configuration & CFG_WRITE_TOGGLE_32BIT_ADDR)
1566                 stfsm_enter_32bit_addr(fsm, 1);
1567
1568         /* Must write in multiples of 32 cycles (or 32*pads/8 bytes) */
1569         data_pads = ((seq->seq_cfg >> 16) & 0x3) + 1;
1570         write_mask = (data_pads << 2) - 1;
1571
1572         /* Handle non-aligned buf */
1573         if ((uint32_t)buf & 0x3) {
1574                 memcpy(page_buf, buf, size);
1575                 p = (uint8_t *)page_buf;
1576         } else {
1577                 p = buf;
1578         }
1579
1580         /* Handle non-aligned size */
1581         size_ub = (size + write_mask) & ~write_mask;
1582         size_lb = size & ~write_mask;
1583         size_mop = size & write_mask;
1584
1585         seq->data_size = TRANSFER_SIZE(size_ub);
1586         seq->addr1 = (offset >> 16) & 0xffff;
1587         seq->addr2 = offset & 0xffff;
1588
1589         /* Need to set FIFO to write mode, before writing data to FIFO (see
1590          * GNBvb79594)
1591          */
1592         writel(0x00040000, fsm->base + SPI_FAST_SEQ_CFG);
1593
1594         /*
1595          * Before writing data to the FIFO, apply a small delay to allow a
1596          * potential change of FIFO direction to complete.
1597          */
1598         if (fsm->fifo_dir_delay == 0)
1599                 readl(fsm->base + SPI_FAST_SEQ_CFG);
1600         else
1601                 udelay(fsm->fifo_dir_delay);
1602
1603
1604         /* Write data to FIFO, before starting sequence (see GNBvd79593) */
1605         if (size_lb) {
1606                 stfsm_write_fifo(fsm, (uint32_t *)p, size_lb);
1607                 p += size_lb;
1608         }
1609
1610         /* Handle non-aligned size */
1611         if (size_mop) {
1612                 memset(t, 0xff, write_mask + 1);        /* fill with 0xff's */
1613                 for (i = 0; i < size_mop; i++)
1614                         t[i] = *p++;
1615
1616                 stfsm_write_fifo(fsm, tmp, write_mask + 1);
1617         }
1618
1619         /* Start sequence */
1620         stfsm_load_seq(fsm, seq);
1621
1622         /* Wait for sequence to finish */
1623         stfsm_wait_seq(fsm);
1624
1625         /* Wait for completion */
1626         ret = stfsm_wait_busy(fsm);
1627         if (ret && fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS)
1628                 stfsm_s25fl_clear_status_reg(fsm);
1629
1630         /* Exit 32-bit address mode, if required */
1631         if (fsm->configuration & CFG_WRITE_TOGGLE_32BIT_ADDR) {
1632                 stfsm_enter_32bit_addr(fsm, 0);
1633                 if (fsm->configuration & CFG_WRITE_EX_32BIT_ADDR_DELAY)
1634                         udelay(1);
1635         }
1636
1637         return 0;
1638 }
1639
1640 /*
1641  * Read an address range from the flash chip. The address range
1642  * may be any size provided it is within the physical boundaries.
1643  */
1644 static int stfsm_mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
1645                           size_t *retlen, u_char *buf)
1646 {
1647         struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent);
1648         uint32_t bytes;
1649
1650         dev_dbg(fsm->dev, "%s from 0x%08x, len %zd\n",
1651                 __func__, (u32)from, len);
1652
1653         mutex_lock(&fsm->lock);
1654
1655         while (len > 0) {
1656                 bytes = min_t(size_t, len, FLASH_PAGESIZE);
1657
1658                 stfsm_read(fsm, buf, bytes, from);
1659
1660                 buf += bytes;
1661                 from += bytes;
1662                 len -= bytes;
1663
1664                 *retlen += bytes;
1665         }
1666
1667         mutex_unlock(&fsm->lock);
1668
1669         return 0;
1670 }
1671
1672 static int stfsm_erase_sector(struct stfsm *fsm, uint32_t offset)
1673 {
1674         struct stfsm_seq *seq = &stfsm_seq_erase_sector;
1675         int ret;
1676
1677         dev_dbg(fsm->dev, "erasing sector at 0x%08x\n", offset);
1678
1679         /* Enter 32-bit address mode, if required */
1680         if (fsm->configuration & CFG_ERASESEC_TOGGLE_32BIT_ADDR)
1681                 stfsm_enter_32bit_addr(fsm, 1);
1682
1683         seq->addr1 = (offset >> 16) & 0xffff;
1684         seq->addr2 = offset & 0xffff;
1685
1686         stfsm_load_seq(fsm, seq);
1687
1688         stfsm_wait_seq(fsm);
1689
1690         /* Wait for completion */
1691         ret = stfsm_wait_busy(fsm);
1692         if (ret && fsm->configuration & CFG_S25FL_CHECK_ERROR_FLAGS)
1693                 stfsm_s25fl_clear_status_reg(fsm);
1694
1695         /* Exit 32-bit address mode, if required */
1696         if (fsm->configuration & CFG_ERASESEC_TOGGLE_32BIT_ADDR)
1697                 stfsm_enter_32bit_addr(fsm, 0);
1698
1699         return ret;
1700 }
1701
1702 static int stfsm_erase_chip(struct stfsm *fsm)
1703 {
1704         const struct stfsm_seq *seq = &stfsm_seq_erase_chip;
1705
1706         dev_dbg(fsm->dev, "erasing chip\n");
1707
1708         stfsm_load_seq(fsm, seq);
1709
1710         stfsm_wait_seq(fsm);
1711
1712         return stfsm_wait_busy(fsm);
1713 }
1714
1715 /*
1716  * Write an address range to the flash chip.  Data must be written in
1717  * FLASH_PAGESIZE chunks.  The address range may be any size provided
1718  * it is within the physical boundaries.
1719  */
1720 static int stfsm_mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
1721                            size_t *retlen, const u_char *buf)
1722 {
1723         struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent);
1724
1725         u32 page_offs;
1726         u32 bytes;
1727         uint8_t *b = (uint8_t *)buf;
1728         int ret = 0;
1729
1730         dev_dbg(fsm->dev, "%s to 0x%08x, len %zd\n", __func__, (u32)to, len);
1731
1732         /* Offset within page */
1733         page_offs = to % FLASH_PAGESIZE;
1734
1735         mutex_lock(&fsm->lock);
1736
1737         while (len) {
1738                 /* Write up to page boundary */
1739                 bytes = min(FLASH_PAGESIZE - page_offs, len);
1740
1741                 ret = stfsm_write(fsm, b, bytes, to);
1742                 if (ret)
1743                         goto out1;
1744
1745                 b += bytes;
1746                 len -= bytes;
1747                 to += bytes;
1748
1749                 /* We are now page-aligned */
1750                 page_offs = 0;
1751
1752                 *retlen += bytes;
1753
1754         }
1755
1756 out1:
1757         mutex_unlock(&fsm->lock);
1758
1759         return ret;
1760 }
1761
1762 /*
1763  * Erase an address range on the flash chip. The address range may extend
1764  * one or more erase sectors.  Return an error is there is a problem erasing.
1765  */
1766 static int stfsm_mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
1767 {
1768         struct stfsm *fsm = dev_get_drvdata(mtd->dev.parent);
1769         u32 addr, len;
1770         int ret;
1771
1772         dev_dbg(fsm->dev, "%s at 0x%llx, len %lld\n", __func__,
1773                 (long long)instr->addr, (long long)instr->len);
1774
1775         addr = instr->addr;
1776         len = instr->len;
1777
1778         mutex_lock(&fsm->lock);
1779
1780         /* Whole-chip erase? */
1781         if (len == mtd->size) {
1782                 ret = stfsm_erase_chip(fsm);
1783                 if (ret)
1784                         goto out1;
1785         } else {
1786                 while (len) {
1787                         ret = stfsm_erase_sector(fsm, addr);
1788                         if (ret)
1789                                 goto out1;
1790
1791                         addr += mtd->erasesize;
1792                         len -= mtd->erasesize;
1793                 }
1794         }
1795
1796         mutex_unlock(&fsm->lock);
1797
1798         instr->state = MTD_ERASE_DONE;
1799         mtd_erase_callback(instr);
1800
1801         return 0;
1802
1803 out1:
1804         instr->state = MTD_ERASE_FAILED;
1805         mutex_unlock(&fsm->lock);
1806
1807         return ret;
1808 }
1809
1810 static void stfsm_read_jedec(struct stfsm *fsm, uint8_t *jedec)
1811 {
1812         const struct stfsm_seq *seq = &stfsm_seq_read_jedec;
1813         uint32_t tmp[2];
1814
1815         stfsm_load_seq(fsm, seq);
1816
1817         stfsm_read_fifo(fsm, tmp, 8);
1818
1819         memcpy(jedec, tmp, 5);
1820
1821         stfsm_wait_seq(fsm);
1822 }
1823
1824 static struct flash_info *stfsm_jedec_probe(struct stfsm *fsm)
1825 {
1826         struct flash_info       *info;
1827         u16                     ext_jedec;
1828         u32                     jedec;
1829         u8                      id[5];
1830
1831         stfsm_read_jedec(fsm, id);
1832
1833         jedec     = id[0] << 16 | id[1] << 8 | id[2];
1834         /*
1835          * JEDEC also defines an optional "extended device information"
1836          * string for after vendor-specific data, after the three bytes
1837          * we use here. Supporting some chips might require using it.
1838          */
1839         ext_jedec = id[3] << 8  | id[4];
1840
1841         dev_dbg(fsm->dev, "JEDEC =  0x%08x [%02x %02x %02x %02x %02x]\n",
1842                 jedec, id[0], id[1], id[2], id[3], id[4]);
1843
1844         for (info = flash_types; info->name; info++) {
1845                 if (info->jedec_id == jedec) {
1846                         if (info->ext_id && info->ext_id != ext_jedec)
1847                                 continue;
1848                         return info;
1849                 }
1850         }
1851         dev_err(fsm->dev, "Unrecognized JEDEC id %06x\n", jedec);
1852
1853         return NULL;
1854 }
1855
1856 static int stfsm_set_mode(struct stfsm *fsm, uint32_t mode)
1857 {
1858         int ret, timeout = 10;
1859
1860         /* Wait for controller to accept mode change */
1861         while (--timeout) {
1862                 ret = readl(fsm->base + SPI_STA_MODE_CHANGE);
1863                 if (ret & 0x1)
1864                         break;
1865                 udelay(1);
1866         }
1867
1868         if (!timeout)
1869                 return -EBUSY;
1870
1871         writel(mode, fsm->base + SPI_MODESELECT);
1872
1873         return 0;
1874 }
1875
1876 static void stfsm_set_freq(struct stfsm *fsm, uint32_t spi_freq)
1877 {
1878         uint32_t emi_freq;
1879         uint32_t clk_div;
1880
1881         /* TODO: Make this dynamic */
1882         emi_freq = STFSM_DEFAULT_EMI_FREQ;
1883
1884         /*
1885          * Calculate clk_div - values between 2 and 128
1886          * Multiple of 2, rounded up
1887          */
1888         clk_div = 2 * DIV_ROUND_UP(emi_freq, 2 * spi_freq);
1889         if (clk_div < 2)
1890                 clk_div = 2;
1891         else if (clk_div > 128)
1892                 clk_div = 128;
1893
1894         /*
1895          * Determine a suitable delay for the IP to complete a change of
1896          * direction of the FIFO. The required delay is related to the clock
1897          * divider used. The following heuristics are based on empirical tests,
1898          * using a 100MHz EMI clock.
1899          */
1900         if (clk_div <= 4)
1901                 fsm->fifo_dir_delay = 0;
1902         else if (clk_div <= 10)
1903                 fsm->fifo_dir_delay = 1;
1904         else
1905                 fsm->fifo_dir_delay = DIV_ROUND_UP(clk_div, 10);
1906
1907         dev_dbg(fsm->dev, "emi_clk = %uHZ, spi_freq = %uHZ, clk_div = %u\n",
1908                 emi_freq, spi_freq, clk_div);
1909
1910         writel(clk_div, fsm->base + SPI_CLOCKDIV);
1911 }
1912
1913 static int stfsm_init(struct stfsm *fsm)
1914 {
1915         int ret;
1916
1917         /* Perform a soft reset of the FSM controller */
1918         writel(SEQ_CFG_SWRESET, fsm->base + SPI_FAST_SEQ_CFG);
1919         udelay(1);
1920         writel(0, fsm->base + SPI_FAST_SEQ_CFG);
1921
1922         /* Set clock to 'safe' frequency initially */
1923         stfsm_set_freq(fsm, STFSM_FLASH_SAFE_FREQ);
1924
1925         /* Switch to FSM */
1926         ret = stfsm_set_mode(fsm, SPI_MODESELECT_FSM);
1927         if (ret)
1928                 return ret;
1929
1930         /* Set timing parameters */
1931         writel(SPI_CFG_DEVICE_ST            |
1932                SPI_CFG_DEFAULT_MIN_CS_HIGH  |
1933                SPI_CFG_DEFAULT_CS_SETUPHOLD |
1934                SPI_CFG_DEFAULT_DATA_HOLD,
1935                fsm->base + SPI_CONFIGDATA);
1936         writel(STFSM_DEFAULT_WR_TIME, fsm->base + SPI_STATUS_WR_TIME_REG);
1937
1938         /* Clear FIFO, just in case */
1939         stfsm_clear_fifo(fsm);
1940
1941         return 0;
1942 }
1943
1944 static void stfsm_fetch_platform_configs(struct platform_device *pdev)
1945 {
1946         struct stfsm *fsm = platform_get_drvdata(pdev);
1947         struct device_node *np = pdev->dev.of_node;
1948         struct regmap *regmap;
1949         uint32_t boot_device_reg;
1950         uint32_t boot_device_spi;
1951         uint32_t boot_device;     /* Value we read from *boot_device_reg */
1952         int ret;
1953
1954         /* Booting from SPI NOR Flash is the default */
1955         fsm->booted_from_spi = true;
1956
1957         regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg");
1958         if (IS_ERR(regmap))
1959                 goto boot_device_fail;
1960
1961         fsm->reset_signal = of_property_read_bool(np, "st,reset-signal");
1962
1963         fsm->reset_por = of_property_read_bool(np, "st,reset-por");
1964
1965         /* Where in the syscon the boot device information lives */
1966         ret = of_property_read_u32(np, "st,boot-device-reg", &boot_device_reg);
1967         if (ret)
1968                 goto boot_device_fail;
1969
1970         /* Boot device value when booted from SPI NOR */
1971         ret = of_property_read_u32(np, "st,boot-device-spi", &boot_device_spi);
1972         if (ret)
1973                 goto boot_device_fail;
1974
1975         ret = regmap_read(regmap, boot_device_reg, &boot_device);
1976         if (ret)
1977                 goto boot_device_fail;
1978
1979         if (boot_device != boot_device_spi)
1980                 fsm->booted_from_spi = false;
1981
1982         return;
1983
1984 boot_device_fail:
1985         dev_warn(&pdev->dev,
1986                  "failed to fetch boot device, assuming boot from SPI\n");
1987 }
1988
1989 static int stfsm_probe(struct platform_device *pdev)
1990 {
1991         struct device_node *np = pdev->dev.of_node;
1992         struct mtd_part_parser_data ppdata;
1993         struct flash_info *info;
1994         struct resource *res;
1995         struct stfsm *fsm;
1996         int ret;
1997
1998         if (!np) {
1999                 dev_err(&pdev->dev, "No DT found\n");
2000                 return -EINVAL;
2001         }
2002         ppdata.of_node = np;
2003
2004         fsm = devm_kzalloc(&pdev->dev, sizeof(*fsm), GFP_KERNEL);
2005         if (!fsm)
2006                 return -ENOMEM;
2007
2008         fsm->dev = &pdev->dev;
2009
2010         platform_set_drvdata(pdev, fsm);
2011
2012         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2013         if (!res) {
2014                 dev_err(&pdev->dev, "Resource not found\n");
2015                 return -ENODEV;
2016         }
2017
2018         fsm->base = devm_ioremap_resource(&pdev->dev, res);
2019         if (IS_ERR(fsm->base)) {
2020                 dev_err(&pdev->dev,
2021                         "Failed to reserve memory region %pR\n", res);
2022                 return PTR_ERR(fsm->base);
2023         }
2024
2025         mutex_init(&fsm->lock);
2026
2027         ret = stfsm_init(fsm);
2028         if (ret) {
2029                 dev_err(&pdev->dev, "Failed to initialise FSM Controller\n");
2030                 return ret;
2031         }
2032
2033         stfsm_fetch_platform_configs(pdev);
2034
2035         /* Detect SPI FLASH device */
2036         info = stfsm_jedec_probe(fsm);
2037         if (!info)
2038                 return -ENODEV;
2039         fsm->info = info;
2040
2041         /* Use device size to determine address width */
2042         if (info->sector_size * info->n_sectors > 0x1000000)
2043                 info->flags |= FLASH_FLAG_32BIT_ADDR;
2044
2045         /*
2046          * Configure READ/WRITE/ERASE sequences according to platform and
2047          * device flags.
2048          */
2049         if (info->config) {
2050                 ret = info->config(fsm);
2051                 if (ret)
2052                         return ret;
2053         } else {
2054                 ret = stfsm_prepare_rwe_seqs_default(fsm);
2055                 if (ret)
2056                         return ret;
2057         }
2058
2059         fsm->mtd.name           = info->name;
2060         fsm->mtd.dev.parent     = &pdev->dev;
2061         fsm->mtd.type           = MTD_NORFLASH;
2062         fsm->mtd.writesize      = 4;
2063         fsm->mtd.writebufsize   = fsm->mtd.writesize;
2064         fsm->mtd.flags          = MTD_CAP_NORFLASH;
2065         fsm->mtd.size           = info->sector_size * info->n_sectors;
2066         fsm->mtd.erasesize      = info->sector_size;
2067
2068         fsm->mtd._read  = stfsm_mtd_read;
2069         fsm->mtd._write = stfsm_mtd_write;
2070         fsm->mtd._erase = stfsm_mtd_erase;
2071
2072         dev_info(&pdev->dev,
2073                 "Found serial flash device: %s\n"
2074                 " size = %llx (%lldMiB) erasesize = 0x%08x (%uKiB)\n",
2075                 info->name,
2076                 (long long)fsm->mtd.size, (long long)(fsm->mtd.size >> 20),
2077                 fsm->mtd.erasesize, (fsm->mtd.erasesize >> 10));
2078
2079         return mtd_device_parse_register(&fsm->mtd, NULL, &ppdata, NULL, 0);
2080 }
2081
2082 static int stfsm_remove(struct platform_device *pdev)
2083 {
2084         struct stfsm *fsm = platform_get_drvdata(pdev);
2085
2086         return mtd_device_unregister(&fsm->mtd);
2087 }
2088
2089 static struct of_device_id stfsm_match[] = {
2090         { .compatible = "st,spi-fsm", },
2091         {},
2092 };
2093 MODULE_DEVICE_TABLE(of, stfsm_match);
2094
2095 static struct platform_driver stfsm_driver = {
2096         .probe          = stfsm_probe,
2097         .remove         = stfsm_remove,
2098         .driver         = {
2099                 .name   = "st-spi-fsm",
2100                 .owner  = THIS_MODULE,
2101                 .of_match_table = stfsm_match,
2102         },
2103 };
2104 module_platform_driver(stfsm_driver);
2105
2106 MODULE_AUTHOR("Angus Clark <angus.clark@st.com>");
2107 MODULE_DESCRIPTION("ST SPI FSM driver");
2108 MODULE_LICENSE("GPL");