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