1 /*
2 * Based on m25p80.c, by Mike Lavender (mike@steroidmicros.com), with
3 * influence from lart.c (Abraham Van Der Merwe) and mtd_dataflash.c
4 *
5 * Copyright (C) 2005, Intec Automation Inc.
6 * Copyright (C) 2014, Freescale Semiconductor, Inc.
7 *
8 * This code is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/err.h>
14 #include <linux/errno.h>
15 #include <linux/module.h>
16 #include <linux/device.h>
17 #include <linux/mutex.h>
18 #include <linux/math64.h>
19 #include <linux/sizes.h>
20
21 #include <linux/mtd/mtd.h>
22 #include <linux/of_platform.h>
23 #include <linux/spi/flash.h>
24 #include <linux/mtd/spi-nor.h>
25
26 /* Define max times to check status register before we give up. */
27
28 /*
29 * For everything but full-chip erase; probably could be much smaller, but kept
30 * around for safety for now
31 */
32 #define DEFAULT_READY_WAIT_JIFFIES (40UL * HZ)
33
34 /*
35 * For full-chip erase, calibrated to a 2MB flash (M25P16); should be scaled up
36 * for larger flash
37 */
38 #define CHIP_ERASE_2MB_READY_WAIT_JIFFIES (40UL * HZ)
39
40 #define SPI_NOR_MAX_ID_LEN 6
41
42 struct flash_info {
43 char *name;
44
45 /*
46 * This array stores the ID bytes.
47 * The first three bytes are the JEDIC ID.
48 * JEDEC ID zero means "no ID" (mostly older chips).
49 */
50 u8 id[SPI_NOR_MAX_ID_LEN];
51 u8 id_len;
52
53 /* The size listed here is what works with SPINOR_OP_SE, which isn't
54 * necessarily called a "sector" by the vendor.
55 */
56 unsigned sector_size;
57 u16 n_sectors;
58
59 u16 page_size;
60 u16 addr_width;
61
62 u16 flags;
63 #define SECT_4K 0x01 /* SPINOR_OP_BE_4K works uniformly */
64 #define SPI_NOR_NO_ERASE 0x02 /* No erase command needed */
65 #define SST_WRITE 0x04 /* use SST byte programming */
66 #define SPI_NOR_NO_FR 0x08 /* Can't do fastread */
67 #define SECT_4K_PMC 0x10 /* SPINOR_OP_BE_4K_PMC works uniformly */
68 #define SPI_NOR_DUAL_READ 0x20 /* Flash supports Dual Read */
69 #define SPI_NOR_QUAD_READ 0x40 /* Flash supports Quad Read */
70 #define USE_FSR 0x80 /* use flag status register */
71 };
72
73 #define JEDEC_MFR(info) ((info)->id[0])
74
75 static const struct flash_info *spi_nor_match_id(const char *name);
76
77 /*
78 * Read the status register, returning its value in the location
79 * Return the status register value.
80 * Returns negative if error occurred.
81 */
read_sr(struct spi_nor * nor)82 static int read_sr(struct spi_nor *nor)
83 {
84 int ret;
85 u8 val;
86
87 ret = nor->read_reg(nor, SPINOR_OP_RDSR, &val, 1);
88 if (ret < 0) {
89 pr_err("error %d reading SR\n", (int) ret);
90 return ret;
91 }
92
93 return val;
94 }
95
96 /*
97 * Read the flag status register, returning its value in the location
98 * Return the status register value.
99 * Returns negative if error occurred.
100 */
read_fsr(struct spi_nor * nor)101 static int read_fsr(struct spi_nor *nor)
102 {
103 int ret;
104 u8 val;
105
106 ret = nor->read_reg(nor, SPINOR_OP_RDFSR, &val, 1);
107 if (ret < 0) {
108 pr_err("error %d reading FSR\n", ret);
109 return ret;
110 }
111
112 return val;
113 }
114
115 /*
116 * Read configuration register, returning its value in the
117 * location. Return the configuration register value.
118 * Returns negative if error occured.
119 */
read_cr(struct spi_nor * nor)120 static int read_cr(struct spi_nor *nor)
121 {
122 int ret;
123 u8 val;
124
125 ret = nor->read_reg(nor, SPINOR_OP_RDCR, &val, 1);
126 if (ret < 0) {
127 dev_err(nor->dev, "error %d reading CR\n", ret);
128 return ret;
129 }
130
131 return val;
132 }
133
134 /*
135 * Dummy Cycle calculation for different type of read.
136 * It can be used to support more commands with
137 * different dummy cycle requirements.
138 */
spi_nor_read_dummy_cycles(struct spi_nor * nor)139 static inline int spi_nor_read_dummy_cycles(struct spi_nor *nor)
140 {
141 switch (nor->flash_read) {
142 case SPI_NOR_FAST:
143 case SPI_NOR_DUAL:
144 case SPI_NOR_QUAD:
145 return 8;
146 case SPI_NOR_NORMAL:
147 return 0;
148 }
149 return 0;
150 }
151
152 /*
153 * Write status register 1 byte
154 * Returns negative if error occurred.
155 */
write_sr(struct spi_nor * nor,u8 val)156 static inline int write_sr(struct spi_nor *nor, u8 val)
157 {
158 nor->cmd_buf[0] = val;
159 return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 1);
160 }
161
162 /*
163 * Set write enable latch with Write Enable command.
164 * Returns negative if error occurred.
165 */
write_enable(struct spi_nor * nor)166 static inline int write_enable(struct spi_nor *nor)
167 {
168 return nor->write_reg(nor, SPINOR_OP_WREN, NULL, 0);
169 }
170
171 /*
172 * Send write disble instruction to the chip.
173 */
write_disable(struct spi_nor * nor)174 static inline int write_disable(struct spi_nor *nor)
175 {
176 return nor->write_reg(nor, SPINOR_OP_WRDI, NULL, 0);
177 }
178
mtd_to_spi_nor(struct mtd_info * mtd)179 static inline struct spi_nor *mtd_to_spi_nor(struct mtd_info *mtd)
180 {
181 return mtd->priv;
182 }
183
184 /* Enable/disable 4-byte addressing mode. */
set_4byte(struct spi_nor * nor,const struct flash_info * info,int enable)185 static inline int set_4byte(struct spi_nor *nor, const struct flash_info *info,
186 int enable)
187 {
188 int status;
189 bool need_wren = false;
190 u8 cmd;
191
192 switch (JEDEC_MFR(info)) {
193 case SNOR_MFR_MICRON:
194 /* Some Micron need WREN command; all will accept it */
195 need_wren = true;
196 case SNOR_MFR_MACRONIX:
197 case SNOR_MFR_WINBOND:
198 if (need_wren)
199 write_enable(nor);
200
201 cmd = enable ? SPINOR_OP_EN4B : SPINOR_OP_EX4B;
202 status = nor->write_reg(nor, cmd, NULL, 0);
203 if (need_wren)
204 write_disable(nor);
205
206 return status;
207 default:
208 /* Spansion style */
209 nor->cmd_buf[0] = enable << 7;
210 return nor->write_reg(nor, SPINOR_OP_BRWR, nor->cmd_buf, 1);
211 }
212 }
spi_nor_sr_ready(struct spi_nor * nor)213 static inline int spi_nor_sr_ready(struct spi_nor *nor)
214 {
215 int sr = read_sr(nor);
216 if (sr < 0)
217 return sr;
218 else
219 return !(sr & SR_WIP);
220 }
221
spi_nor_fsr_ready(struct spi_nor * nor)222 static inline int spi_nor_fsr_ready(struct spi_nor *nor)
223 {
224 int fsr = read_fsr(nor);
225 if (fsr < 0)
226 return fsr;
227 else
228 return fsr & FSR_READY;
229 }
230
spi_nor_ready(struct spi_nor * nor)231 static int spi_nor_ready(struct spi_nor *nor)
232 {
233 int sr, fsr;
234 sr = spi_nor_sr_ready(nor);
235 if (sr < 0)
236 return sr;
237 fsr = nor->flags & SNOR_F_USE_FSR ? spi_nor_fsr_ready(nor) : 1;
238 if (fsr < 0)
239 return fsr;
240 return sr && fsr;
241 }
242
243 /*
244 * Service routine to read status register until ready, or timeout occurs.
245 * Returns non-zero if error.
246 */
spi_nor_wait_till_ready_with_timeout(struct spi_nor * nor,unsigned long timeout_jiffies)247 static int spi_nor_wait_till_ready_with_timeout(struct spi_nor *nor,
248 unsigned long timeout_jiffies)
249 {
250 unsigned long deadline;
251 int timeout = 0, ret;
252
253 deadline = jiffies + timeout_jiffies;
254
255 while (!timeout) {
256 if (time_after_eq(jiffies, deadline))
257 timeout = 1;
258
259 ret = spi_nor_ready(nor);
260 if (ret < 0)
261 return ret;
262 if (ret)
263 return 0;
264
265 cond_resched();
266 }
267
268 dev_err(nor->dev, "flash operation timed out\n");
269
270 return -ETIMEDOUT;
271 }
272
spi_nor_wait_till_ready(struct spi_nor * nor)273 static int spi_nor_wait_till_ready(struct spi_nor *nor)
274 {
275 return spi_nor_wait_till_ready_with_timeout(nor,
276 DEFAULT_READY_WAIT_JIFFIES);
277 }
278
279 /*
280 * Erase the whole flash memory
281 *
282 * Returns 0 if successful, non-zero otherwise.
283 */
erase_chip(struct spi_nor * nor)284 static int erase_chip(struct spi_nor *nor)
285 {
286 dev_dbg(nor->dev, " %lldKiB\n", (long long)(nor->mtd.size >> 10));
287
288 return nor->write_reg(nor, SPINOR_OP_CHIP_ERASE, NULL, 0);
289 }
290
spi_nor_lock_and_prep(struct spi_nor * nor,enum spi_nor_ops ops)291 static int spi_nor_lock_and_prep(struct spi_nor *nor, enum spi_nor_ops ops)
292 {
293 int ret = 0;
294
295 mutex_lock(&nor->lock);
296
297 if (nor->prepare) {
298 ret = nor->prepare(nor, ops);
299 if (ret) {
300 dev_err(nor->dev, "failed in the preparation.\n");
301 mutex_unlock(&nor->lock);
302 return ret;
303 }
304 }
305 return ret;
306 }
307
spi_nor_unlock_and_unprep(struct spi_nor * nor,enum spi_nor_ops ops)308 static void spi_nor_unlock_and_unprep(struct spi_nor *nor, enum spi_nor_ops ops)
309 {
310 if (nor->unprepare)
311 nor->unprepare(nor, ops);
312 mutex_unlock(&nor->lock);
313 }
314
315 /*
316 * Erase an address range on the nor chip. The address range may extend
317 * one or more erase sectors. Return an error is there is a problem erasing.
318 */
spi_nor_erase(struct mtd_info * mtd,struct erase_info * instr)319 static int spi_nor_erase(struct mtd_info *mtd, struct erase_info *instr)
320 {
321 struct spi_nor *nor = mtd_to_spi_nor(mtd);
322 u32 addr, len;
323 uint32_t rem;
324 int ret;
325
326 dev_dbg(nor->dev, "at 0x%llx, len %lld\n", (long long)instr->addr,
327 (long long)instr->len);
328
329 div_u64_rem(instr->len, mtd->erasesize, &rem);
330 if (rem)
331 return -EINVAL;
332
333 addr = instr->addr;
334 len = instr->len;
335
336 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_ERASE);
337 if (ret)
338 return ret;
339
340 /* whole-chip erase? */
341 if (len == mtd->size) {
342 unsigned long timeout;
343
344 write_enable(nor);
345
346 if (erase_chip(nor)) {
347 ret = -EIO;
348 goto erase_err;
349 }
350
351 /*
352 * Scale the timeout linearly with the size of the flash, with
353 * a minimum calibrated to an old 2MB flash. We could try to
354 * pull these from CFI/SFDP, but these values should be good
355 * enough for now.
356 */
357 timeout = max(CHIP_ERASE_2MB_READY_WAIT_JIFFIES,
358 CHIP_ERASE_2MB_READY_WAIT_JIFFIES *
359 (unsigned long)(mtd->size / SZ_2M));
360 ret = spi_nor_wait_till_ready_with_timeout(nor, timeout);
361 if (ret)
362 goto erase_err;
363
364 /* REVISIT in some cases we could speed up erasing large regions
365 * by using SPINOR_OP_SE instead of SPINOR_OP_BE_4K. We may have set up
366 * to use "small sector erase", but that's not always optimal.
367 */
368
369 /* "sector"-at-a-time erase */
370 } else {
371 while (len) {
372 write_enable(nor);
373
374 if (nor->erase(nor, addr)) {
375 ret = -EIO;
376 goto erase_err;
377 }
378
379 addr += mtd->erasesize;
380 len -= mtd->erasesize;
381
382 ret = spi_nor_wait_till_ready(nor);
383 if (ret)
384 goto erase_err;
385 }
386 }
387
388 write_disable(nor);
389
390 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
391
392 instr->state = MTD_ERASE_DONE;
393 mtd_erase_callback(instr);
394
395 return ret;
396
397 erase_err:
398 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_ERASE);
399 instr->state = MTD_ERASE_FAILED;
400 return ret;
401 }
402
stm_get_locked_range(struct spi_nor * nor,u8 sr,loff_t * ofs,uint64_t * len)403 static void stm_get_locked_range(struct spi_nor *nor, u8 sr, loff_t *ofs,
404 uint64_t *len)
405 {
406 struct mtd_info *mtd = &nor->mtd;
407 u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
408 int shift = ffs(mask) - 1;
409 int pow;
410
411 if (!(sr & mask)) {
412 /* No protection */
413 *ofs = 0;
414 *len = 0;
415 } else {
416 pow = ((sr & mask) ^ mask) >> shift;
417 *len = mtd->size >> pow;
418 *ofs = mtd->size - *len;
419 }
420 }
421
422 /*
423 * Return 1 if the entire region is locked, 0 otherwise
424 */
stm_is_locked_sr(struct spi_nor * nor,loff_t ofs,uint64_t len,u8 sr)425 static int stm_is_locked_sr(struct spi_nor *nor, loff_t ofs, uint64_t len,
426 u8 sr)
427 {
428 loff_t lock_offs;
429 uint64_t lock_len;
430
431 stm_get_locked_range(nor, sr, &lock_offs, &lock_len);
432
433 return (ofs + len <= lock_offs + lock_len) && (ofs >= lock_offs);
434 }
435
436 /*
437 * Lock a region of the flash. Compatible with ST Micro and similar flash.
438 * Supports only the block protection bits BP{0,1,2} in the status register
439 * (SR). Does not support these features found in newer SR bitfields:
440 * - TB: top/bottom protect - only handle TB=0 (top protect)
441 * - SEC: sector/block protect - only handle SEC=0 (block protect)
442 * - CMP: complement protect - only support CMP=0 (range is not complemented)
443 *
444 * Sample table portion for 8MB flash (Winbond w25q64fw):
445 *
446 * SEC | TB | BP2 | BP1 | BP0 | Prot Length | Protected Portion
447 * --------------------------------------------------------------------------
448 * X | X | 0 | 0 | 0 | NONE | NONE
449 * 0 | 0 | 0 | 0 | 1 | 128 KB | Upper 1/64
450 * 0 | 0 | 0 | 1 | 0 | 256 KB | Upper 1/32
451 * 0 | 0 | 0 | 1 | 1 | 512 KB | Upper 1/16
452 * 0 | 0 | 1 | 0 | 0 | 1 MB | Upper 1/8
453 * 0 | 0 | 1 | 0 | 1 | 2 MB | Upper 1/4
454 * 0 | 0 | 1 | 1 | 0 | 4 MB | Upper 1/2
455 * X | X | 1 | 1 | 1 | 8 MB | ALL
456 *
457 * Returns negative on errors, 0 on success.
458 */
stm_lock(struct spi_nor * nor,loff_t ofs,uint64_t len)459 static int stm_lock(struct spi_nor *nor, loff_t ofs, uint64_t len)
460 {
461 struct mtd_info *mtd = &nor->mtd;
462 u8 status_old, status_new;
463 u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
464 u8 shift = ffs(mask) - 1, pow, val;
465
466 status_old = read_sr(nor);
467
468 /* SPI NOR always locks to the end */
469 if (ofs + len != mtd->size) {
470 /* Does combined region extend to end? */
471 if (!stm_is_locked_sr(nor, ofs + len, mtd->size - ofs - len,
472 status_old))
473 return -EINVAL;
474 len = mtd->size - ofs;
475 }
476
477 /*
478 * Need smallest pow such that:
479 *
480 * 1 / (2^pow) <= (len / size)
481 *
482 * so (assuming power-of-2 size) we do:
483 *
484 * pow = ceil(log2(size / len)) = log2(size) - floor(log2(len))
485 */
486 pow = ilog2(mtd->size) - ilog2(len);
487 val = mask - (pow << shift);
488 if (val & ~mask)
489 return -EINVAL;
490 /* Don't "lock" with no region! */
491 if (!(val & mask))
492 return -EINVAL;
493
494 status_new = (status_old & ~mask) | val;
495
496 /* Only modify protection if it will not unlock other areas */
497 if ((status_new & mask) <= (status_old & mask))
498 return -EINVAL;
499
500 write_enable(nor);
501 return write_sr(nor, status_new);
502 }
503
504 /*
505 * Unlock a region of the flash. See stm_lock() for more info
506 *
507 * Returns negative on errors, 0 on success.
508 */
stm_unlock(struct spi_nor * nor,loff_t ofs,uint64_t len)509 static int stm_unlock(struct spi_nor *nor, loff_t ofs, uint64_t len)
510 {
511 struct mtd_info *mtd = &nor->mtd;
512 uint8_t status_old, status_new;
513 u8 mask = SR_BP2 | SR_BP1 | SR_BP0;
514 u8 shift = ffs(mask) - 1, pow, val;
515
516 status_old = read_sr(nor);
517
518 /* Cannot unlock; would unlock larger region than requested */
519 if (stm_is_locked_sr(nor, ofs - mtd->erasesize, mtd->erasesize,
520 status_old))
521 return -EINVAL;
522
523 /*
524 * Need largest pow such that:
525 *
526 * 1 / (2^pow) >= (len / size)
527 *
528 * so (assuming power-of-2 size) we do:
529 *
530 * pow = floor(log2(size / len)) = log2(size) - ceil(log2(len))
531 */
532 pow = ilog2(mtd->size) - order_base_2(mtd->size - (ofs + len));
533 if (ofs + len == mtd->size) {
534 val = 0; /* fully unlocked */
535 } else {
536 val = mask - (pow << shift);
537 /* Some power-of-two sizes are not supported */
538 if (val & ~mask)
539 return -EINVAL;
540 }
541
542 status_new = (status_old & ~mask) | val;
543
544 /* Only modify protection if it will not lock other areas */
545 if ((status_new & mask) >= (status_old & mask))
546 return -EINVAL;
547
548 write_enable(nor);
549 return write_sr(nor, status_new);
550 }
551
552 /*
553 * Check if a region of the flash is (completely) locked. See stm_lock() for
554 * more info.
555 *
556 * Returns 1 if entire region is locked, 0 if any portion is unlocked, and
557 * negative on errors.
558 */
stm_is_locked(struct spi_nor * nor,loff_t ofs,uint64_t len)559 static int stm_is_locked(struct spi_nor *nor, loff_t ofs, uint64_t len)
560 {
561 int status;
562
563 status = read_sr(nor);
564 if (status < 0)
565 return status;
566
567 return stm_is_locked_sr(nor, ofs, len, status);
568 }
569
spi_nor_lock(struct mtd_info * mtd,loff_t ofs,uint64_t len)570 static int spi_nor_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
571 {
572 struct spi_nor *nor = mtd_to_spi_nor(mtd);
573 int ret;
574
575 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_LOCK);
576 if (ret)
577 return ret;
578
579 ret = nor->flash_lock(nor, ofs, len);
580
581 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_UNLOCK);
582 return ret;
583 }
584
spi_nor_unlock(struct mtd_info * mtd,loff_t ofs,uint64_t len)585 static int spi_nor_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
586 {
587 struct spi_nor *nor = mtd_to_spi_nor(mtd);
588 int ret;
589
590 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
591 if (ret)
592 return ret;
593
594 ret = nor->flash_unlock(nor, ofs, len);
595
596 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
597 return ret;
598 }
599
spi_nor_is_locked(struct mtd_info * mtd,loff_t ofs,uint64_t len)600 static int spi_nor_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
601 {
602 struct spi_nor *nor = mtd_to_spi_nor(mtd);
603 int ret;
604
605 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_UNLOCK);
606 if (ret)
607 return ret;
608
609 ret = nor->flash_is_locked(nor, ofs, len);
610
611 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_LOCK);
612 return ret;
613 }
614
615 /* Used when the "_ext_id" is two bytes at most */
616 #define INFO(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \
617 .id = { \
618 ((_jedec_id) >> 16) & 0xff, \
619 ((_jedec_id) >> 8) & 0xff, \
620 (_jedec_id) & 0xff, \
621 ((_ext_id) >> 8) & 0xff, \
622 (_ext_id) & 0xff, \
623 }, \
624 .id_len = (!(_jedec_id) ? 0 : (3 + ((_ext_id) ? 2 : 0))), \
625 .sector_size = (_sector_size), \
626 .n_sectors = (_n_sectors), \
627 .page_size = 256, \
628 .flags = (_flags),
629
630 #define INFO6(_jedec_id, _ext_id, _sector_size, _n_sectors, _flags) \
631 .id = { \
632 ((_jedec_id) >> 16) & 0xff, \
633 ((_jedec_id) >> 8) & 0xff, \
634 (_jedec_id) & 0xff, \
635 ((_ext_id) >> 16) & 0xff, \
636 ((_ext_id) >> 8) & 0xff, \
637 (_ext_id) & 0xff, \
638 }, \
639 .id_len = 6, \
640 .sector_size = (_sector_size), \
641 .n_sectors = (_n_sectors), \
642 .page_size = 256, \
643 .flags = (_flags),
644
645 #define CAT25_INFO(_sector_size, _n_sectors, _page_size, _addr_width, _flags) \
646 .sector_size = (_sector_size), \
647 .n_sectors = (_n_sectors), \
648 .page_size = (_page_size), \
649 .addr_width = (_addr_width), \
650 .flags = (_flags),
651
652 /* NOTE: double check command sets and memory organization when you add
653 * more nor chips. This current list focusses on newer chips, which
654 * have been converging on command sets which including JEDEC ID.
655 *
656 * All newly added entries should describe *hardware* and should use SECT_4K
657 * (or SECT_4K_PMC) if hardware supports erasing 4 KiB sectors. For usage
658 * scenarios excluding small sectors there is config option that can be
659 * disabled: CONFIG_MTD_SPI_NOR_USE_4K_SECTORS.
660 * For historical (and compatibility) reasons (before we got above config) some
661 * old entries may be missing 4K flag.
662 */
663 static const struct flash_info spi_nor_ids[] = {
664 /* Atmel -- some are (confusingly) marketed as "DataFlash" */
665 { "at25fs010", INFO(0x1f6601, 0, 32 * 1024, 4, SECT_4K) },
666 { "at25fs040", INFO(0x1f6604, 0, 64 * 1024, 8, SECT_4K) },
667
668 { "at25df041a", INFO(0x1f4401, 0, 64 * 1024, 8, SECT_4K) },
669 { "at25df321a", INFO(0x1f4701, 0, 64 * 1024, 64, SECT_4K) },
670 { "at25df641", INFO(0x1f4800, 0, 64 * 1024, 128, SECT_4K) },
671
672 { "at26f004", INFO(0x1f0400, 0, 64 * 1024, 8, SECT_4K) },
673 { "at26df081a", INFO(0x1f4501, 0, 64 * 1024, 16, SECT_4K) },
674 { "at26df161a", INFO(0x1f4601, 0, 64 * 1024, 32, SECT_4K) },
675 { "at26df321", INFO(0x1f4700, 0, 64 * 1024, 64, SECT_4K) },
676
677 { "at45db081d", INFO(0x1f2500, 0, 64 * 1024, 16, SECT_4K) },
678
679 /* EON -- en25xxx */
680 { "en25f32", INFO(0x1c3116, 0, 64 * 1024, 64, SECT_4K) },
681 { "en25p32", INFO(0x1c2016, 0, 64 * 1024, 64, 0) },
682 { "en25q32b", INFO(0x1c3016, 0, 64 * 1024, 64, 0) },
683 { "en25p64", INFO(0x1c2017, 0, 64 * 1024, 128, 0) },
684 { "en25q64", INFO(0x1c3017, 0, 64 * 1024, 128, SECT_4K) },
685 { "en25qh128", INFO(0x1c7018, 0, 64 * 1024, 256, 0) },
686 { "en25qh256", INFO(0x1c7019, 0, 64 * 1024, 512, 0) },
687 { "en25s64", INFO(0x1c3817, 0, 64 * 1024, 128, SECT_4K) },
688
689 /* ESMT */
690 { "f25l32pa", INFO(0x8c2016, 0, 64 * 1024, 64, SECT_4K) },
691
692 /* Everspin */
693 { "mr25h256", CAT25_INFO( 32 * 1024, 1, 256, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
694 { "mr25h10", CAT25_INFO(128 * 1024, 1, 256, 3, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
695
696 /* Fujitsu */
697 { "mb85rs1mt", INFO(0x047f27, 0, 128 * 1024, 1, SPI_NOR_NO_ERASE) },
698
699 /* GigaDevice */
700 { "gd25q32", INFO(0xc84016, 0, 64 * 1024, 64, SECT_4K) },
701 { "gd25q64", INFO(0xc84017, 0, 64 * 1024, 128, SECT_4K) },
702 { "gd25q128", INFO(0xc84018, 0, 64 * 1024, 256, SECT_4K) },
703
704 /* Intel/Numonyx -- xxxs33b */
705 { "160s33b", INFO(0x898911, 0, 64 * 1024, 32, 0) },
706 { "320s33b", INFO(0x898912, 0, 64 * 1024, 64, 0) },
707 { "640s33b", INFO(0x898913, 0, 64 * 1024, 128, 0) },
708
709 /* ISSI */
710 { "is25cd512", INFO(0x7f9d20, 0, 32 * 1024, 2, SECT_4K) },
711 { "is25wp032", INFO(0x9d7016, 0, 64 * 1024, 64,
712 SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
713 { "is25wp064", INFO(0x9d7017, 0, 64 * 1024, 128,
714 SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
715 { "is25wp128", INFO(0x9d7018, 0, 64 * 1024, 256,
716 SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
717
718 /* Macronix */
719 { "mx25l512e", INFO(0xc22010, 0, 64 * 1024, 1, SECT_4K) },
720 { "mx25l2005a", INFO(0xc22012, 0, 64 * 1024, 4, SECT_4K) },
721 { "mx25l4005a", INFO(0xc22013, 0, 64 * 1024, 8, SECT_4K) },
722 { "mx25l8005", INFO(0xc22014, 0, 64 * 1024, 16, 0) },
723 { "mx25l1606e", INFO(0xc22015, 0, 64 * 1024, 32, SECT_4K) },
724 { "mx25l3205d", INFO(0xc22016, 0, 64 * 1024, 64, 0) },
725 { "mx25l3255e", INFO(0xc29e16, 0, 64 * 1024, 64, SECT_4K) },
726 { "mx25l6405d", INFO(0xc22017, 0, 64 * 1024, 128, 0) },
727 { "mx25u6435f", INFO(0xc22537, 0, 64 * 1024, 128, SECT_4K) },
728 { "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
729 { "mx25l12855e", INFO(0xc22618, 0, 64 * 1024, 256, 0) },
730 { "mx25l25635e", INFO(0xc22019, 0, 64 * 1024, 512, 0) },
731 { "mx25l25655e", INFO(0xc22619, 0, 64 * 1024, 512, 0) },
732 { "mx66l51235l", INFO(0xc2201a, 0, 64 * 1024, 1024, SPI_NOR_QUAD_READ) },
733 { "mx66l1g55g", INFO(0xc2261b, 0, 64 * 1024, 2048, SPI_NOR_QUAD_READ) },
734
735 /* Micron */
736 { "n25q032", INFO(0x20ba16, 0, 64 * 1024, 64, SPI_NOR_QUAD_READ) },
737 { "n25q032a", INFO(0x20bb16, 0, 64 * 1024, 64, SPI_NOR_QUAD_READ) },
738 { "n25q064", INFO(0x20ba17, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_QUAD_READ) },
739 { "n25q064a", INFO(0x20bb17, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_QUAD_READ) },
740 { "n25q128a11", INFO(0x20bb18, 0, 64 * 1024, 256, SPI_NOR_QUAD_READ) },
741 { "n25q128a13", INFO(0x20ba18, 0, 64 * 1024, 256, SPI_NOR_QUAD_READ) },
742 { "n25q256a", INFO(0x20ba19, 0, 64 * 1024, 512, SECT_4K | SPI_NOR_QUAD_READ) },
743 { "n25q512a", INFO(0x20bb20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
744 { "n25q512ax3", INFO(0x20ba20, 0, 64 * 1024, 1024, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
745 { "n25q00", INFO(0x20ba21, 0, 64 * 1024, 2048, SECT_4K | USE_FSR | SPI_NOR_QUAD_READ) },
746
747 /* PMC */
748 { "pm25lv512", INFO(0, 0, 32 * 1024, 2, SECT_4K_PMC) },
749 { "pm25lv010", INFO(0, 0, 32 * 1024, 4, SECT_4K_PMC) },
750 { "pm25lq032", INFO(0x7f9d46, 0, 64 * 1024, 64, SECT_4K) },
751
752 /* Spansion -- single (large) sector size only, at least
753 * for the chips listed here (without boot sectors).
754 */
755 { "s25sl032p", INFO(0x010215, 0x4d00, 64 * 1024, 64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
756 { "s25sl064p", INFO(0x010216, 0x4d00, 64 * 1024, 128, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
757 { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, 0) },
758 { "s25fl256s1", INFO(0x010219, 0x4d01, 64 * 1024, 512, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
759 { "s25fl512s", INFO(0x010220, 0x4d00, 256 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
760 { "s70fl01gs", INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
761 { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024, 64, 0) },
762 { "s25sl12801", INFO(0x012018, 0x0301, 64 * 1024, 256, 0) },
763 { "s25fl128s", INFO6(0x012018, 0x4d0180, 64 * 1024, 256, SECT_4K | SPI_NOR_QUAD_READ) },
764 { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024, 64, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
765 { "s25fl129p1", INFO(0x012018, 0x4d01, 64 * 1024, 256, SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
766 { "s25sl004a", INFO(0x010212, 0, 64 * 1024, 8, 0) },
767 { "s25sl008a", INFO(0x010213, 0, 64 * 1024, 16, 0) },
768 { "s25sl016a", INFO(0x010214, 0, 64 * 1024, 32, 0) },
769 { "s25sl032a", INFO(0x010215, 0, 64 * 1024, 64, 0) },
770 { "s25sl064a", INFO(0x010216, 0, 64 * 1024, 128, 0) },
771 { "s25fl004k", INFO(0xef4013, 0, 64 * 1024, 8, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
772 { "s25fl008k", INFO(0xef4014, 0, 64 * 1024, 16, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
773 { "s25fl016k", INFO(0xef4015, 0, 64 * 1024, 32, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
774 { "s25fl064k", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
775 { "s25fl132k", INFO(0x014016, 0, 64 * 1024, 64, SECT_4K) },
776 { "s25fl164k", INFO(0x014017, 0, 64 * 1024, 128, SECT_4K) },
777 { "s25fl204k", INFO(0x014013, 0, 64 * 1024, 8, SECT_4K | SPI_NOR_DUAL_READ) },
778
779 /* SST -- large erase sizes are "overlays", "sectors" are 4K */
780 { "sst25vf040b", INFO(0xbf258d, 0, 64 * 1024, 8, SECT_4K | SST_WRITE) },
781 { "sst25vf080b", INFO(0xbf258e, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
782 { "sst25vf016b", INFO(0xbf2541, 0, 64 * 1024, 32, SECT_4K | SST_WRITE) },
783 { "sst25vf032b", INFO(0xbf254a, 0, 64 * 1024, 64, SECT_4K | SST_WRITE) },
784 { "sst25vf064c", INFO(0xbf254b, 0, 64 * 1024, 128, SECT_4K) },
785 { "sst25wf512", INFO(0xbf2501, 0, 64 * 1024, 1, SECT_4K | SST_WRITE) },
786 { "sst25wf010", INFO(0xbf2502, 0, 64 * 1024, 2, SECT_4K | SST_WRITE) },
787 { "sst25wf020", INFO(0xbf2503, 0, 64 * 1024, 4, SECT_4K | SST_WRITE) },
788 { "sst25wf020a", INFO(0x621612, 0, 64 * 1024, 4, SECT_4K) },
789 { "sst25wf040b", INFO(0x621613, 0, 64 * 1024, 8, SECT_4K) },
790 { "sst25wf040", INFO(0xbf2504, 0, 64 * 1024, 8, SECT_4K | SST_WRITE) },
791 { "sst25wf080", INFO(0xbf2505, 0, 64 * 1024, 16, SECT_4K | SST_WRITE) },
792
793 /* ST Microelectronics -- newer production may have feature updates */
794 { "m25p05", INFO(0x202010, 0, 32 * 1024, 2, 0) },
795 { "m25p10", INFO(0x202011, 0, 32 * 1024, 4, 0) },
796 { "m25p20", INFO(0x202012, 0, 64 * 1024, 4, 0) },
797 { "m25p40", INFO(0x202013, 0, 64 * 1024, 8, 0) },
798 { "m25p80", INFO(0x202014, 0, 64 * 1024, 16, 0) },
799 { "m25p16", INFO(0x202015, 0, 64 * 1024, 32, 0) },
800 { "m25p32", INFO(0x202016, 0, 64 * 1024, 64, 0) },
801 { "m25p64", INFO(0x202017, 0, 64 * 1024, 128, 0) },
802 { "m25p128", INFO(0x202018, 0, 256 * 1024, 64, 0) },
803
804 { "m25p05-nonjedec", INFO(0, 0, 32 * 1024, 2, 0) },
805 { "m25p10-nonjedec", INFO(0, 0, 32 * 1024, 4, 0) },
806 { "m25p20-nonjedec", INFO(0, 0, 64 * 1024, 4, 0) },
807 { "m25p40-nonjedec", INFO(0, 0, 64 * 1024, 8, 0) },
808 { "m25p80-nonjedec", INFO(0, 0, 64 * 1024, 16, 0) },
809 { "m25p16-nonjedec", INFO(0, 0, 64 * 1024, 32, 0) },
810 { "m25p32-nonjedec", INFO(0, 0, 64 * 1024, 64, 0) },
811 { "m25p64-nonjedec", INFO(0, 0, 64 * 1024, 128, 0) },
812 { "m25p128-nonjedec", INFO(0, 0, 256 * 1024, 64, 0) },
813
814 { "m45pe10", INFO(0x204011, 0, 64 * 1024, 2, 0) },
815 { "m45pe80", INFO(0x204014, 0, 64 * 1024, 16, 0) },
816 { "m45pe16", INFO(0x204015, 0, 64 * 1024, 32, 0) },
817
818 { "m25pe20", INFO(0x208012, 0, 64 * 1024, 4, 0) },
819 { "m25pe80", INFO(0x208014, 0, 64 * 1024, 16, 0) },
820 { "m25pe16", INFO(0x208015, 0, 64 * 1024, 32, SECT_4K) },
821
822 { "m25px16", INFO(0x207115, 0, 64 * 1024, 32, SECT_4K) },
823 { "m25px32", INFO(0x207116, 0, 64 * 1024, 64, SECT_4K) },
824 { "m25px32-s0", INFO(0x207316, 0, 64 * 1024, 64, SECT_4K) },
825 { "m25px32-s1", INFO(0x206316, 0, 64 * 1024, 64, SECT_4K) },
826 { "m25px64", INFO(0x207117, 0, 64 * 1024, 128, 0) },
827 { "m25px80", INFO(0x207114, 0, 64 * 1024, 16, 0) },
828
829 /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
830 { "w25x05", INFO(0xef3010, 0, 64 * 1024, 1, SECT_4K) },
831 { "w25x10", INFO(0xef3011, 0, 64 * 1024, 2, SECT_4K) },
832 { "w25x20", INFO(0xef3012, 0, 64 * 1024, 4, SECT_4K) },
833 { "w25x40", INFO(0xef3013, 0, 64 * 1024, 8, SECT_4K) },
834 { "w25x80", INFO(0xef3014, 0, 64 * 1024, 16, SECT_4K) },
835 { "w25x16", INFO(0xef3015, 0, 64 * 1024, 32, SECT_4K) },
836 { "w25x32", INFO(0xef3016, 0, 64 * 1024, 64, SECT_4K) },
837 { "w25q32", INFO(0xef4016, 0, 64 * 1024, 64, SECT_4K) },
838 { "w25q32dw", INFO(0xef6016, 0, 64 * 1024, 64, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
839 { "w25x64", INFO(0xef3017, 0, 64 * 1024, 128, SECT_4K) },
840 { "w25q64", INFO(0xef4017, 0, 64 * 1024, 128, SECT_4K) },
841 { "w25q64dw", INFO(0xef6017, 0, 64 * 1024, 128, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
842 { "w25q128fw", INFO(0xef6018, 0, 64 * 1024, 256, SECT_4K | SPI_NOR_DUAL_READ | SPI_NOR_QUAD_READ) },
843 { "w25q80", INFO(0xef5014, 0, 64 * 1024, 16, SECT_4K) },
844 { "w25q80bl", INFO(0xef4014, 0, 64 * 1024, 16, SECT_4K) },
845 { "w25q128", INFO(0xef4018, 0, 64 * 1024, 256, SECT_4K) },
846 { "w25q256", INFO(0xef4019, 0, 64 * 1024, 512, SECT_4K) },
847
848 /* Catalyst / On Semiconductor -- non-JEDEC */
849 { "cat25c11", CAT25_INFO( 16, 8, 16, 1, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
850 { "cat25c03", CAT25_INFO( 32, 8, 16, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
851 { "cat25c09", CAT25_INFO( 128, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
852 { "cat25c17", CAT25_INFO( 256, 8, 32, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
853 { "cat25128", CAT25_INFO(2048, 8, 64, 2, SPI_NOR_NO_ERASE | SPI_NOR_NO_FR) },
854 { },
855 };
856
spi_nor_read_id(struct spi_nor * nor)857 static const struct flash_info *spi_nor_read_id(struct spi_nor *nor)
858 {
859 int tmp;
860 u8 id[SPI_NOR_MAX_ID_LEN];
861 const struct flash_info *info;
862
863 tmp = nor->read_reg(nor, SPINOR_OP_RDID, id, SPI_NOR_MAX_ID_LEN);
864 if (tmp < 0) {
865 dev_dbg(nor->dev, " error %d reading JEDEC ID\n", tmp);
866 return ERR_PTR(tmp);
867 }
868
869 for (tmp = 0; tmp < ARRAY_SIZE(spi_nor_ids) - 1; tmp++) {
870 info = &spi_nor_ids[tmp];
871 if (info->id_len) {
872 if (!memcmp(info->id, id, info->id_len))
873 return &spi_nor_ids[tmp];
874 }
875 }
876 dev_err(nor->dev, "unrecognized JEDEC id bytes: %02x, %2x, %2x\n",
877 id[0], id[1], id[2]);
878 return ERR_PTR(-ENODEV);
879 }
880
spi_nor_read(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,u_char * buf)881 static int spi_nor_read(struct mtd_info *mtd, loff_t from, size_t len,
882 size_t *retlen, u_char *buf)
883 {
884 struct spi_nor *nor = mtd_to_spi_nor(mtd);
885 int ret;
886
887 dev_dbg(nor->dev, "from 0x%08x, len %zd\n", (u32)from, len);
888
889 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_READ);
890 if (ret)
891 return ret;
892
893 ret = nor->read(nor, from, len, retlen, buf);
894
895 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_READ);
896 return ret;
897 }
898
sst_write(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)899 static int sst_write(struct mtd_info *mtd, loff_t to, size_t len,
900 size_t *retlen, const u_char *buf)
901 {
902 struct spi_nor *nor = mtd_to_spi_nor(mtd);
903 size_t actual;
904 int ret;
905
906 dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
907
908 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
909 if (ret)
910 return ret;
911
912 write_enable(nor);
913
914 nor->sst_write_second = false;
915
916 actual = to % 2;
917 /* Start write from odd address. */
918 if (actual) {
919 nor->program_opcode = SPINOR_OP_BP;
920
921 /* write one byte. */
922 nor->write(nor, to, 1, retlen, buf);
923 ret = spi_nor_wait_till_ready(nor);
924 if (ret)
925 goto time_out;
926 }
927 to += actual;
928
929 /* Write out most of the data here. */
930 for (; actual < len - 1; actual += 2) {
931 nor->program_opcode = SPINOR_OP_AAI_WP;
932
933 /* write two bytes. */
934 nor->write(nor, to, 2, retlen, buf + actual);
935 ret = spi_nor_wait_till_ready(nor);
936 if (ret)
937 goto time_out;
938 to += 2;
939 nor->sst_write_second = true;
940 }
941 nor->sst_write_second = false;
942
943 write_disable(nor);
944 ret = spi_nor_wait_till_ready(nor);
945 if (ret)
946 goto time_out;
947
948 /* Write out trailing byte if it exists. */
949 if (actual != len) {
950 write_enable(nor);
951
952 nor->program_opcode = SPINOR_OP_BP;
953 nor->write(nor, to, 1, retlen, buf + actual);
954
955 ret = spi_nor_wait_till_ready(nor);
956 if (ret)
957 goto time_out;
958 write_disable(nor);
959 }
960 time_out:
961 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
962 return ret;
963 }
964
965 /*
966 * Write an address range to the nor chip. Data must be written in
967 * FLASH_PAGESIZE chunks. The address range may be any size provided
968 * it is within the physical boundaries.
969 */
spi_nor_write(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)970 static int spi_nor_write(struct mtd_info *mtd, loff_t to, size_t len,
971 size_t *retlen, const u_char *buf)
972 {
973 struct spi_nor *nor = mtd_to_spi_nor(mtd);
974 u32 page_offset, page_size, i;
975 int ret;
976
977 dev_dbg(nor->dev, "to 0x%08x, len %zd\n", (u32)to, len);
978
979 ret = spi_nor_lock_and_prep(nor, SPI_NOR_OPS_WRITE);
980 if (ret)
981 return ret;
982
983 write_enable(nor);
984
985 page_offset = to & (nor->page_size - 1);
986
987 /* do all the bytes fit onto one page? */
988 if (page_offset + len <= nor->page_size) {
989 nor->write(nor, to, len, retlen, buf);
990 } else {
991 /* the size of data remaining on the first page */
992 page_size = nor->page_size - page_offset;
993 nor->write(nor, to, page_size, retlen, buf);
994
995 /* write everything in nor->page_size chunks */
996 for (i = page_size; i < len; i += page_size) {
997 page_size = len - i;
998 if (page_size > nor->page_size)
999 page_size = nor->page_size;
1000
1001 ret = spi_nor_wait_till_ready(nor);
1002 if (ret)
1003 goto write_err;
1004
1005 write_enable(nor);
1006
1007 nor->write(nor, to + i, page_size, retlen, buf + i);
1008 }
1009 }
1010
1011 ret = spi_nor_wait_till_ready(nor);
1012 write_err:
1013 spi_nor_unlock_and_unprep(nor, SPI_NOR_OPS_WRITE);
1014 return ret;
1015 }
1016
macronix_quad_enable(struct spi_nor * nor)1017 static int macronix_quad_enable(struct spi_nor *nor)
1018 {
1019 int ret, val;
1020
1021 val = read_sr(nor);
1022 write_enable(nor);
1023
1024 write_sr(nor, val | SR_QUAD_EN_MX);
1025
1026 if (spi_nor_wait_till_ready(nor))
1027 return 1;
1028
1029 ret = read_sr(nor);
1030 if (!(ret > 0 && (ret & SR_QUAD_EN_MX))) {
1031 dev_err(nor->dev, "Macronix Quad bit not set\n");
1032 return -EINVAL;
1033 }
1034
1035 return 0;
1036 }
1037
1038 /*
1039 * Write status Register and configuration register with 2 bytes
1040 * The first byte will be written to the status register, while the
1041 * second byte will be written to the configuration register.
1042 * Return negative if error occured.
1043 */
write_sr_cr(struct spi_nor * nor,u16 val)1044 static int write_sr_cr(struct spi_nor *nor, u16 val)
1045 {
1046 nor->cmd_buf[0] = val & 0xff;
1047 nor->cmd_buf[1] = (val >> 8);
1048
1049 return nor->write_reg(nor, SPINOR_OP_WRSR, nor->cmd_buf, 2);
1050 }
1051
spansion_quad_enable(struct spi_nor * nor)1052 static int spansion_quad_enable(struct spi_nor *nor)
1053 {
1054 int ret;
1055 int quad_en = CR_QUAD_EN_SPAN << 8;
1056
1057 write_enable(nor);
1058
1059 ret = write_sr_cr(nor, quad_en);
1060 if (ret < 0) {
1061 dev_err(nor->dev,
1062 "error while writing configuration register\n");
1063 return -EINVAL;
1064 }
1065
1066 ret = spi_nor_wait_till_ready(nor);
1067 if (ret) {
1068 dev_err(nor->dev,
1069 "timeout while writing configuration register\n");
1070 return ret;
1071 }
1072
1073 /* read back and check it */
1074 ret = read_cr(nor);
1075 if (!(ret > 0 && (ret & CR_QUAD_EN_SPAN))) {
1076 dev_err(nor->dev, "Spansion Quad bit not set\n");
1077 return -EINVAL;
1078 }
1079
1080 return 0;
1081 }
1082
set_quad_mode(struct spi_nor * nor,const struct flash_info * info)1083 static int set_quad_mode(struct spi_nor *nor, const struct flash_info *info)
1084 {
1085 int status;
1086
1087 switch (JEDEC_MFR(info)) {
1088 case SNOR_MFR_MACRONIX:
1089 status = macronix_quad_enable(nor);
1090 if (status) {
1091 dev_err(nor->dev, "Macronix quad-read not enabled\n");
1092 return -EINVAL;
1093 }
1094 return status;
1095 case SNOR_MFR_MICRON:
1096 return 0;
1097 default:
1098 status = spansion_quad_enable(nor);
1099 if (status) {
1100 dev_err(nor->dev, "Spansion quad-read not enabled\n");
1101 return -EINVAL;
1102 }
1103 return status;
1104 }
1105 }
1106
spi_nor_check(struct spi_nor * nor)1107 static int spi_nor_check(struct spi_nor *nor)
1108 {
1109 if (!nor->dev || !nor->read || !nor->write ||
1110 !nor->read_reg || !nor->write_reg || !nor->erase) {
1111 pr_err("spi-nor: please fill all the necessary fields!\n");
1112 return -EINVAL;
1113 }
1114
1115 return 0;
1116 }
1117
spi_nor_scan(struct spi_nor * nor,const char * name,enum read_mode mode)1118 int spi_nor_scan(struct spi_nor *nor, const char *name, enum read_mode mode)
1119 {
1120 const struct flash_info *info = NULL;
1121 struct device *dev = nor->dev;
1122 struct mtd_info *mtd = &nor->mtd;
1123 struct device_node *np = nor->flash_node;
1124 int ret;
1125 int i;
1126
1127 ret = spi_nor_check(nor);
1128 if (ret)
1129 return ret;
1130
1131 if (name)
1132 info = spi_nor_match_id(name);
1133 /* Try to auto-detect if chip name wasn't specified or not found */
1134 if (!info)
1135 info = spi_nor_read_id(nor);
1136 if (IS_ERR_OR_NULL(info))
1137 return -ENOENT;
1138
1139 /*
1140 * If caller has specified name of flash model that can normally be
1141 * detected using JEDEC, let's verify it.
1142 */
1143 if (name && info->id_len) {
1144 const struct flash_info *jinfo;
1145
1146 jinfo = spi_nor_read_id(nor);
1147 if (IS_ERR(jinfo)) {
1148 return PTR_ERR(jinfo);
1149 } else if (jinfo != info) {
1150 /*
1151 * JEDEC knows better, so overwrite platform ID. We
1152 * can't trust partitions any longer, but we'll let
1153 * mtd apply them anyway, since some partitions may be
1154 * marked read-only, and we don't want to lose that
1155 * information, even if it's not 100% accurate.
1156 */
1157 dev_warn(dev, "found %s, expected %s\n",
1158 jinfo->name, info->name);
1159 info = jinfo;
1160 }
1161 }
1162
1163 mutex_init(&nor->lock);
1164
1165 /*
1166 * Atmel, SST, Intel/Numonyx, and others serial NOR tend to power up
1167 * with the software protection bits set
1168 */
1169
1170 if (JEDEC_MFR(info) == SNOR_MFR_ATMEL ||
1171 JEDEC_MFR(info) == SNOR_MFR_INTEL ||
1172 JEDEC_MFR(info) == SNOR_MFR_SST) {
1173 write_enable(nor);
1174 write_sr(nor, 0);
1175 }
1176
1177 if (!mtd->name)
1178 mtd->name = dev_name(dev);
1179 mtd->priv = nor;
1180 mtd->type = MTD_NORFLASH;
1181 mtd->writesize = 1;
1182 mtd->flags = MTD_CAP_NORFLASH;
1183 mtd->size = info->sector_size * info->n_sectors;
1184 mtd->_erase = spi_nor_erase;
1185 mtd->_read = spi_nor_read;
1186
1187 /* NOR protection support for STmicro/Micron chips and similar */
1188 if (JEDEC_MFR(info) == SNOR_MFR_MICRON) {
1189 nor->flash_lock = stm_lock;
1190 nor->flash_unlock = stm_unlock;
1191 nor->flash_is_locked = stm_is_locked;
1192 }
1193
1194 if (nor->flash_lock && nor->flash_unlock && nor->flash_is_locked) {
1195 mtd->_lock = spi_nor_lock;
1196 mtd->_unlock = spi_nor_unlock;
1197 mtd->_is_locked = spi_nor_is_locked;
1198 }
1199
1200 /* sst nor chips use AAI word program */
1201 if (info->flags & SST_WRITE)
1202 mtd->_write = sst_write;
1203 else
1204 mtd->_write = spi_nor_write;
1205
1206 if (info->flags & USE_FSR)
1207 nor->flags |= SNOR_F_USE_FSR;
1208
1209 #ifdef CONFIG_MTD_SPI_NOR_USE_4K_SECTORS
1210 /* prefer "small sector" erase if possible */
1211 if (info->flags & SECT_4K) {
1212 nor->erase_opcode = SPINOR_OP_BE_4K;
1213 mtd->erasesize = 4096;
1214 } else if (info->flags & SECT_4K_PMC) {
1215 nor->erase_opcode = SPINOR_OP_BE_4K_PMC;
1216 mtd->erasesize = 4096;
1217 } else
1218 #endif
1219 {
1220 nor->erase_opcode = SPINOR_OP_SE;
1221 mtd->erasesize = info->sector_size;
1222 }
1223
1224 if (info->flags & SPI_NOR_NO_ERASE)
1225 mtd->flags |= MTD_NO_ERASE;
1226
1227 mtd->dev.parent = dev;
1228 nor->page_size = info->page_size;
1229 mtd->writebufsize = nor->page_size;
1230
1231 if (np) {
1232 /* If we were instantiated by DT, use it */
1233 if (of_property_read_bool(np, "m25p,fast-read"))
1234 nor->flash_read = SPI_NOR_FAST;
1235 else
1236 nor->flash_read = SPI_NOR_NORMAL;
1237 } else {
1238 /* If we weren't instantiated by DT, default to fast-read */
1239 nor->flash_read = SPI_NOR_FAST;
1240 }
1241
1242 /* Some devices cannot do fast-read, no matter what DT tells us */
1243 if (info->flags & SPI_NOR_NO_FR)
1244 nor->flash_read = SPI_NOR_NORMAL;
1245
1246 /* Quad/Dual-read mode takes precedence over fast/normal */
1247 if (mode == SPI_NOR_QUAD && info->flags & SPI_NOR_QUAD_READ) {
1248 ret = set_quad_mode(nor, info);
1249 if (ret) {
1250 dev_err(dev, "quad mode not supported\n");
1251 return ret;
1252 }
1253 nor->flash_read = SPI_NOR_QUAD;
1254 } else if (mode == SPI_NOR_DUAL && info->flags & SPI_NOR_DUAL_READ) {
1255 nor->flash_read = SPI_NOR_DUAL;
1256 }
1257
1258 /* Default commands */
1259 switch (nor->flash_read) {
1260 case SPI_NOR_QUAD:
1261 nor->read_opcode = SPINOR_OP_READ_1_1_4;
1262 break;
1263 case SPI_NOR_DUAL:
1264 nor->read_opcode = SPINOR_OP_READ_1_1_2;
1265 break;
1266 case SPI_NOR_FAST:
1267 nor->read_opcode = SPINOR_OP_READ_FAST;
1268 break;
1269 case SPI_NOR_NORMAL:
1270 nor->read_opcode = SPINOR_OP_READ;
1271 break;
1272 default:
1273 dev_err(dev, "No Read opcode defined\n");
1274 return -EINVAL;
1275 }
1276
1277 nor->program_opcode = SPINOR_OP_PP;
1278
1279 if (info->addr_width)
1280 nor->addr_width = info->addr_width;
1281 else if (mtd->size > 0x1000000) {
1282 /* enable 4-byte addressing if the device exceeds 16MiB */
1283 nor->addr_width = 4;
1284 if (JEDEC_MFR(info) == SNOR_MFR_SPANSION) {
1285 /* Dedicated 4-byte command set */
1286 switch (nor->flash_read) {
1287 case SPI_NOR_QUAD:
1288 nor->read_opcode = SPINOR_OP_READ4_1_1_4;
1289 break;
1290 case SPI_NOR_DUAL:
1291 nor->read_opcode = SPINOR_OP_READ4_1_1_2;
1292 break;
1293 case SPI_NOR_FAST:
1294 nor->read_opcode = SPINOR_OP_READ4_FAST;
1295 break;
1296 case SPI_NOR_NORMAL:
1297 nor->read_opcode = SPINOR_OP_READ4;
1298 break;
1299 }
1300 nor->program_opcode = SPINOR_OP_PP_4B;
1301 /* No small sector erase for 4-byte command set */
1302 nor->erase_opcode = SPINOR_OP_SE_4B;
1303 mtd->erasesize = info->sector_size;
1304 } else
1305 set_4byte(nor, info, 1);
1306 } else {
1307 nor->addr_width = 3;
1308 }
1309
1310 nor->read_dummy = spi_nor_read_dummy_cycles(nor);
1311
1312 dev_info(dev, "%s (%lld Kbytes)\n", info->name,
1313 (long long)mtd->size >> 10);
1314
1315 dev_dbg(dev,
1316 "mtd .name = %s, .size = 0x%llx (%lldMiB), "
1317 ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
1318 mtd->name, (long long)mtd->size, (long long)(mtd->size >> 20),
1319 mtd->erasesize, mtd->erasesize / 1024, mtd->numeraseregions);
1320
1321 if (mtd->numeraseregions)
1322 for (i = 0; i < mtd->numeraseregions; i++)
1323 dev_dbg(dev,
1324 "mtd.eraseregions[%d] = { .offset = 0x%llx, "
1325 ".erasesize = 0x%.8x (%uKiB), "
1326 ".numblocks = %d }\n",
1327 i, (long long)mtd->eraseregions[i].offset,
1328 mtd->eraseregions[i].erasesize,
1329 mtd->eraseregions[i].erasesize / 1024,
1330 mtd->eraseregions[i].numblocks);
1331 return 0;
1332 }
1333 EXPORT_SYMBOL_GPL(spi_nor_scan);
1334
spi_nor_match_id(const char * name)1335 static const struct flash_info *spi_nor_match_id(const char *name)
1336 {
1337 const struct flash_info *id = spi_nor_ids;
1338
1339 while (id->name) {
1340 if (!strcmp(name, id->name))
1341 return id;
1342 id++;
1343 }
1344 return NULL;
1345 }
1346
1347 MODULE_LICENSE("GPL");
1348 MODULE_AUTHOR("Huang Shijie <shijie8@gmail.com>");
1349 MODULE_AUTHOR("Mike Lavender");
1350 MODULE_DESCRIPTION("framework for SPI NOR");
1351