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