projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'omap-for-v4.8/legacy' into for-next
[deliverable/linux.git] / drivers / mtd / nand / mtk_nand.c
1 /*
2 * MTK NAND Flash controller driver.
3 * Copyright (C) 2016 MediaTek Inc.
4 * Authors: Xiaolei Li <xiaolei.li@mediatek.com>
5 * Jorge Ramirez-Ortiz <jorge.ramirez-ortiz@linaro.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17 #include <linux/platform_device.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/interrupt.h>
20 #include <linux/delay.h>
21 #include <linux/clk.h>
22 #include <linux/mtd/nand.h>
23 #include <linux/mtd/mtd.h>
24 #include <linux/module.h>
25 #include <linux/iopoll.h>
26 #include <linux/of.h>
27 #include "mtk_ecc.h"
28
29 /* NAND controller register definition */
30 #define NFI_CNFG (0x00)
31 #define CNFG_AHB BIT(0)
32 #define CNFG_READ_EN BIT(1)
33 #define CNFG_DMA_BURST_EN BIT(2)
34 #define CNFG_BYTE_RW BIT(6)
35 #define CNFG_HW_ECC_EN BIT(8)
36 #define CNFG_AUTO_FMT_EN BIT(9)
37 #define CNFG_OP_CUST (6 << 12)
38 #define NFI_PAGEFMT (0x04)
39 #define PAGEFMT_FDM_ECC_SHIFT (12)
40 #define PAGEFMT_FDM_SHIFT (8)
41 #define PAGEFMT_SPARE_16 (0)
42 #define PAGEFMT_SPARE_26 (1)
43 #define PAGEFMT_SPARE_27 (2)
44 #define PAGEFMT_SPARE_28 (3)
45 #define PAGEFMT_SPARE_32 (4)
46 #define PAGEFMT_SPARE_36 (5)
47 #define PAGEFMT_SPARE_40 (6)
48 #define PAGEFMT_SPARE_44 (7)
49 #define PAGEFMT_SPARE_48 (8)
50 #define PAGEFMT_SPARE_49 (9)
51 #define PAGEFMT_SPARE_50 (0xa)
52 #define PAGEFMT_SPARE_51 (0xb)
53 #define PAGEFMT_SPARE_52 (0xc)
54 #define PAGEFMT_SPARE_62 (0xd)
55 #define PAGEFMT_SPARE_63 (0xe)
56 #define PAGEFMT_SPARE_64 (0xf)
57 #define PAGEFMT_SPARE_SHIFT (4)
58 #define PAGEFMT_SEC_SEL_512 BIT(2)
59 #define PAGEFMT_512_2K (0)
60 #define PAGEFMT_2K_4K (1)
61 #define PAGEFMT_4K_8K (2)
62 #define PAGEFMT_8K_16K (3)
63 /* NFI control */
64 #define NFI_CON (0x08)
65 #define CON_FIFO_FLUSH BIT(0)
66 #define CON_NFI_RST BIT(1)
67 #define CON_BRD BIT(8) /* burst read */
68 #define CON_BWR BIT(9) /* burst write */
69 #define CON_SEC_SHIFT (12)
70 /* Timming control register */
71 #define NFI_ACCCON (0x0C)
72 #define NFI_INTR_EN (0x10)
73 #define INTR_AHB_DONE_EN BIT(6)
74 #define NFI_INTR_STA (0x14)
75 #define NFI_CMD (0x20)
76 #define NFI_ADDRNOB (0x30)
77 #define NFI_COLADDR (0x34)
78 #define NFI_ROWADDR (0x38)
79 #define NFI_STRDATA (0x40)
80 #define STAR_EN (1)
81 #define STAR_DE (0)
82 #define NFI_CNRNB (0x44)
83 #define NFI_DATAW (0x50)
84 #define NFI_DATAR (0x54)
85 #define NFI_PIO_DIRDY (0x58)
86 #define PIO_DI_RDY (0x01)
87 #define NFI_STA (0x60)
88 #define STA_CMD BIT(0)
89 #define STA_ADDR BIT(1)
90 #define STA_BUSY BIT(8)
91 #define STA_EMP_PAGE BIT(12)
92 #define NFI_FSM_CUSTDATA (0xe << 16)
93 #define NFI_FSM_MASK (0xf << 16)
94 #define NFI_ADDRCNTR (0x70)
95 #define CNTR_MASK GENMASK(16, 12)
96 #define NFI_STRADDR (0x80)
97 #define NFI_BYTELEN (0x84)
98 #define NFI_CSEL (0x90)
99 #define NFI_FDML(x) (0xA0 + (x) * sizeof(u32) * 2)
100 #define NFI_FDMM(x) (0xA4 + (x) * sizeof(u32) * 2)
101 #define NFI_FDM_MAX_SIZE (8)
102 #define NFI_FDM_MIN_SIZE (1)
103 #define NFI_MASTER_STA (0x224)
104 #define MASTER_STA_MASK (0x0FFF)
105 #define NFI_EMPTY_THRESH (0x23C)
106
107 #define MTK_NAME "mtk-nand"
108 #define KB(x) ((x) * 1024UL)
109 #define MB(x) (KB(x) * 1024UL)
110
111 #define MTK_TIMEOUT (500000)
112 #define MTK_RESET_TIMEOUT (1000000)
113 #define MTK_MAX_SECTOR (16)
114 #define MTK_NAND_MAX_NSELS (2)
115
116 struct mtk_nfc_bad_mark_ctl {
117 void (*bm_swap)(struct mtd_info *, u8 *buf, int raw);
118 u32 sec;
119 u32 pos;
120 };
121
122 /*
123 * FDM: region used to store free OOB data
124 */
125 struct mtk_nfc_fdm {
126 u32 reg_size;
127 u32 ecc_size;
128 };
129
130 struct mtk_nfc_nand_chip {
131 struct list_head node;
132 struct nand_chip nand;
133
134 struct mtk_nfc_bad_mark_ctl bad_mark;
135 struct mtk_nfc_fdm fdm;
136 u32 spare_per_sector;
137
138 int nsels;
139 u8 sels[0];
140 /* nothing after this field */
141 };
142
143 struct mtk_nfc_clk {
144 struct clk *nfi_clk;
145 struct clk *pad_clk;
146 };
147
148 struct mtk_nfc {
149 struct nand_hw_control controller;
150 struct mtk_ecc_config ecc_cfg;
151 struct mtk_nfc_clk clk;
152 struct mtk_ecc *ecc;
153
154 struct device *dev;
155 void __iomem *regs;
156
157 struct completion done;
158 struct list_head chips;
159
160 u8 *buffer;
161 };
162
163 static inline struct mtk_nfc_nand_chip *to_mtk_nand(struct nand_chip *nand)
164 {
165 return container_of(nand, struct mtk_nfc_nand_chip, nand);
166 }
167
168 static inline u8 *data_ptr(struct nand_chip *chip, const u8 *p, int i)
169 {
170 return (u8 *)p + i * chip->ecc.size;
171 }
172
173 static inline u8 *oob_ptr(struct nand_chip *chip, int i)
174 {
175 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
176 u8 *poi;
177
178 /* map the sector's FDM data to free oob:
179 * the beginning of the oob area stores the FDM data of bad mark sectors
180 */
181
182 if (i < mtk_nand->bad_mark.sec)
183 poi = chip->oob_poi + (i + 1) * mtk_nand->fdm.reg_size;
184 else if (i == mtk_nand->bad_mark.sec)
185 poi = chip->oob_poi;
186 else
187 poi = chip->oob_poi + i * mtk_nand->fdm.reg_size;
188
189 return poi;
190 }
191
192 static inline int mtk_data_len(struct nand_chip *chip)
193 {
194 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
195
196 return chip->ecc.size + mtk_nand->spare_per_sector;
197 }
198
199 static inline u8 *mtk_data_ptr(struct nand_chip *chip, int i)
200 {
201 struct mtk_nfc *nfc = nand_get_controller_data(chip);
202
203 return nfc->buffer + i * mtk_data_len(chip);
204 }
205
206 static inline u8 *mtk_oob_ptr(struct nand_chip *chip, int i)
207 {
208 struct mtk_nfc *nfc = nand_get_controller_data(chip);
209
210 return nfc->buffer + i * mtk_data_len(chip) + chip->ecc.size;
211 }
212
213 static inline void nfi_writel(struct mtk_nfc *nfc, u32 val, u32 reg)
214 {
215 writel(val, nfc->regs + reg);
216 }
217
218 static inline void nfi_writew(struct mtk_nfc *nfc, u16 val, u32 reg)
219 {
220 writew(val, nfc->regs + reg);
221 }
222
223 static inline void nfi_writeb(struct mtk_nfc *nfc, u8 val, u32 reg)
224 {
225 writeb(val, nfc->regs + reg);
226 }
227
228 static inline u32 nfi_readl(struct mtk_nfc *nfc, u32 reg)
229 {
230 return readl_relaxed(nfc->regs + reg);
231 }
232
233 static inline u16 nfi_readw(struct mtk_nfc *nfc, u32 reg)
234 {
235 return readw_relaxed(nfc->regs + reg);
236 }
237
238 static inline u8 nfi_readb(struct mtk_nfc *nfc, u32 reg)
239 {
240 return readb_relaxed(nfc->regs + reg);
241 }
242
243 static void mtk_nfc_hw_reset(struct mtk_nfc *nfc)
244 {
245 struct device *dev = nfc->dev;
246 u32 val;
247 int ret;
248
249 /* reset all registers and force the NFI master to terminate */
250 nfi_writel(nfc, CON_FIFO_FLUSH | CON_NFI_RST, NFI_CON);
251
252 /* wait for the master to finish the last transaction */
253 ret = readl_poll_timeout(nfc->regs + NFI_MASTER_STA, val,
254 !(val & MASTER_STA_MASK), 50,
255 MTK_RESET_TIMEOUT);
256 if (ret)
257 dev_warn(dev, "master active in reset [0x%x] = 0x%x\n",
258 NFI_MASTER_STA, val);
259
260 /* ensure any status register affected by the NFI master is reset */
261 nfi_writel(nfc, CON_FIFO_FLUSH | CON_NFI_RST, NFI_CON);
262 nfi_writew(nfc, STAR_DE, NFI_STRDATA);
263 }
264
265 static int mtk_nfc_send_command(struct mtk_nfc *nfc, u8 command)
266 {
267 struct device *dev = nfc->dev;
268 u32 val;
269 int ret;
270
271 nfi_writel(nfc, command, NFI_CMD);
272
273 ret = readl_poll_timeout_atomic(nfc->regs + NFI_STA, val,
274 !(val & STA_CMD), 10, MTK_TIMEOUT);
275 if (ret) {
276 dev_warn(dev, "nfi core timed out entering command mode\n");
277 return -EIO;
278 }
279
280 return 0;
281 }
282
283 static int mtk_nfc_send_address(struct mtk_nfc *nfc, int addr)
284 {
285 struct device *dev = nfc->dev;
286 u32 val;
287 int ret;
288
289 nfi_writel(nfc, addr, NFI_COLADDR);
290 nfi_writel(nfc, 0, NFI_ROWADDR);
291 nfi_writew(nfc, 1, NFI_ADDRNOB);
292
293 ret = readl_poll_timeout_atomic(nfc->regs + NFI_STA, val,
294 !(val & STA_ADDR), 10, MTK_TIMEOUT);
295 if (ret) {
296 dev_warn(dev, "nfi core timed out entering address mode\n");
297 return -EIO;
298 }
299
300 return 0;
301 }
302
303 static int mtk_nfc_hw_runtime_config(struct mtd_info *mtd)
304 {
305 struct nand_chip *chip = mtd_to_nand(mtd);
306 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
307 struct mtk_nfc *nfc = nand_get_controller_data(chip);
308 u32 fmt, spare;
309
310 if (!mtd->writesize)
311 return 0;
312
313 spare = mtk_nand->spare_per_sector;
314
315 switch (mtd->writesize) {
316 case 512:
317 fmt = PAGEFMT_512_2K | PAGEFMT_SEC_SEL_512;
318 break;
319 case KB(2):
320 if (chip->ecc.size == 512)
321 fmt = PAGEFMT_2K_4K | PAGEFMT_SEC_SEL_512;
322 else
323 fmt = PAGEFMT_512_2K;
324 break;
325 case KB(4):
326 if (chip->ecc.size == 512)
327 fmt = PAGEFMT_4K_8K | PAGEFMT_SEC_SEL_512;
328 else
329 fmt = PAGEFMT_2K_4K;
330 break;
331 case KB(8):
332 if (chip->ecc.size == 512)
333 fmt = PAGEFMT_8K_16K | PAGEFMT_SEC_SEL_512;
334 else
335 fmt = PAGEFMT_4K_8K;
336 break;
337 case KB(16):
338 fmt = PAGEFMT_8K_16K;
339 break;
340 default:
341 dev_err(nfc->dev, "invalid page len: %d\n", mtd->writesize);
342 return -EINVAL;
343 }
344
345 /*
346 * the hardware will double the value for this eccsize, so we need to
347 * halve it
348 */
349 if (chip->ecc.size == 1024)
350 spare >>= 1;
351
352 switch (spare) {
353 case 16:
354 fmt |= (PAGEFMT_SPARE_16 << PAGEFMT_SPARE_SHIFT);
355 break;
356 case 26:
357 fmt |= (PAGEFMT_SPARE_26 << PAGEFMT_SPARE_SHIFT);
358 break;
359 case 27:
360 fmt |= (PAGEFMT_SPARE_27 << PAGEFMT_SPARE_SHIFT);
361 break;
362 case 28:
363 fmt |= (PAGEFMT_SPARE_28 << PAGEFMT_SPARE_SHIFT);
364 break;
365 case 32:
366 fmt |= (PAGEFMT_SPARE_32 << PAGEFMT_SPARE_SHIFT);
367 break;
368 case 36:
369 fmt |= (PAGEFMT_SPARE_36 << PAGEFMT_SPARE_SHIFT);
370 break;
371 case 40:
372 fmt |= (PAGEFMT_SPARE_40 << PAGEFMT_SPARE_SHIFT);
373 break;
374 case 44:
375 fmt |= (PAGEFMT_SPARE_44 << PAGEFMT_SPARE_SHIFT);
376 break;
377 case 48:
378 fmt |= (PAGEFMT_SPARE_48 << PAGEFMT_SPARE_SHIFT);
379 break;
380 case 49:
381 fmt |= (PAGEFMT_SPARE_49 << PAGEFMT_SPARE_SHIFT);
382 break;
383 case 50:
384 fmt |= (PAGEFMT_SPARE_50 << PAGEFMT_SPARE_SHIFT);
385 break;
386 case 51:
387 fmt |= (PAGEFMT_SPARE_51 << PAGEFMT_SPARE_SHIFT);
388 break;
389 case 52:
390 fmt |= (PAGEFMT_SPARE_52 << PAGEFMT_SPARE_SHIFT);
391 break;
392 case 62:
393 fmt |= (PAGEFMT_SPARE_62 << PAGEFMT_SPARE_SHIFT);
394 break;
395 case 63:
396 fmt |= (PAGEFMT_SPARE_63 << PAGEFMT_SPARE_SHIFT);
397 break;
398 case 64:
399 fmt |= (PAGEFMT_SPARE_64 << PAGEFMT_SPARE_SHIFT);
400 break;
401 default:
402 dev_err(nfc->dev, "invalid spare per sector %d\n", spare);
403 return -EINVAL;
404 }
405
406 fmt |= mtk_nand->fdm.reg_size << PAGEFMT_FDM_SHIFT;
407 fmt |= mtk_nand->fdm.ecc_size << PAGEFMT_FDM_ECC_SHIFT;
408 nfi_writew(nfc, fmt, NFI_PAGEFMT);
409
410 nfc->ecc_cfg.strength = chip->ecc.strength;
411 nfc->ecc_cfg.len = chip->ecc.size + mtk_nand->fdm.ecc_size;
412
413 return 0;
414 }
415
416 static void mtk_nfc_select_chip(struct mtd_info *mtd, int chip)
417 {
418 struct nand_chip *nand = mtd_to_nand(mtd);
419 struct mtk_nfc *nfc = nand_get_controller_data(nand);
420 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(nand);
421
422 if (chip < 0)
423 return;
424
425 mtk_nfc_hw_runtime_config(mtd);
426
427 nfi_writel(nfc, mtk_nand->sels[chip], NFI_CSEL);
428 }
429
430 static int mtk_nfc_dev_ready(struct mtd_info *mtd)
431 {
432 struct mtk_nfc *nfc = nand_get_controller_data(mtd_to_nand(mtd));
433
434 if (nfi_readl(nfc, NFI_STA) & STA_BUSY)
435 return 0;
436
437 return 1;
438 }
439
440 static void mtk_nfc_cmd_ctrl(struct mtd_info *mtd, int dat, unsigned int ctrl)
441 {
442 struct mtk_nfc *nfc = nand_get_controller_data(mtd_to_nand(mtd));
443
444 if (ctrl & NAND_ALE) {
445 mtk_nfc_send_address(nfc, dat);
446 } else if (ctrl & NAND_CLE) {
447 mtk_nfc_hw_reset(nfc);
448
449 nfi_writew(nfc, CNFG_OP_CUST, NFI_CNFG);
450 mtk_nfc_send_command(nfc, dat);
451 }
452 }
453
454 static inline void mtk_nfc_wait_ioready(struct mtk_nfc *nfc)
455 {
456 int rc;
457 u8 val;
458
459 rc = readb_poll_timeout_atomic(nfc->regs + NFI_PIO_DIRDY, val,
460 val & PIO_DI_RDY, 10, MTK_TIMEOUT);
461 if (rc < 0)
462 dev_err(nfc->dev, "data not ready\n");
463 }
464
465 static inline u8 mtk_nfc_read_byte(struct mtd_info *mtd)
466 {
467 struct nand_chip *chip = mtd_to_nand(mtd);
468 struct mtk_nfc *nfc = nand_get_controller_data(chip);
469 u32 reg;
470
471 /* after each byte read, the NFI_STA reg is reset by the hardware */
472 reg = nfi_readl(nfc, NFI_STA) & NFI_FSM_MASK;
473 if (reg != NFI_FSM_CUSTDATA) {
474 reg = nfi_readw(nfc, NFI_CNFG);
475 reg |= CNFG_BYTE_RW | CNFG_READ_EN;
476 nfi_writew(nfc, reg, NFI_CNFG);
477
478 /*
479 * set to max sector to allow the HW to continue reading over
480 * unaligned accesses
481 */
482 reg = (MTK_MAX_SECTOR << CON_SEC_SHIFT) | CON_BRD;
483 nfi_writel(nfc, reg, NFI_CON);
484
485 /* trigger to fetch data */
486 nfi_writew(nfc, STAR_EN, NFI_STRDATA);
487 }
488
489 mtk_nfc_wait_ioready(nfc);
490
491 return nfi_readb(nfc, NFI_DATAR);
492 }
493
494 static void mtk_nfc_read_buf(struct mtd_info *mtd, u8 *buf, int len)
495 {
496 int i;
497
498 for (i = 0; i < len; i++)
499 buf[i] = mtk_nfc_read_byte(mtd);
500 }
501
502 static void mtk_nfc_write_byte(struct mtd_info *mtd, u8 byte)
503 {
504 struct mtk_nfc *nfc = nand_get_controller_data(mtd_to_nand(mtd));
505 u32 reg;
506
507 reg = nfi_readl(nfc, NFI_STA) & NFI_FSM_MASK;
508
509 if (reg != NFI_FSM_CUSTDATA) {
510 reg = nfi_readw(nfc, NFI_CNFG) | CNFG_BYTE_RW;
511 nfi_writew(nfc, reg, NFI_CNFG);
512
513 reg = MTK_MAX_SECTOR << CON_SEC_SHIFT | CON_BWR;
514 nfi_writel(nfc, reg, NFI_CON);
515
516 nfi_writew(nfc, STAR_EN, NFI_STRDATA);
517 }
518
519 mtk_nfc_wait_ioready(nfc);
520 nfi_writeb(nfc, byte, NFI_DATAW);
521 }
522
523 static void mtk_nfc_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
524 {
525 int i;
526
527 for (i = 0; i < len; i++)
528 mtk_nfc_write_byte(mtd, buf[i]);
529 }
530
531 static int mtk_nfc_sector_encode(struct nand_chip *chip, u8 *data)
532 {
533 struct mtk_nfc *nfc = nand_get_controller_data(chip);
534 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
535 int size = chip->ecc.size + mtk_nand->fdm.reg_size;
536
537 nfc->ecc_cfg.mode = ECC_DMA_MODE;
538 nfc->ecc_cfg.op = ECC_ENCODE;
539
540 return mtk_ecc_encode(nfc->ecc, &nfc->ecc_cfg, data, size);
541 }
542
543 static void mtk_nfc_no_bad_mark_swap(struct mtd_info *a, u8 *b, int c)
544 {
545 /* nop */
546 }
547
548 static void mtk_nfc_bad_mark_swap(struct mtd_info *mtd, u8 *buf, int raw)
549 {
550 struct nand_chip *chip = mtd_to_nand(mtd);
551 struct mtk_nfc_nand_chip *nand = to_mtk_nand(chip);
552 u32 bad_pos = nand->bad_mark.pos;
553
554 if (raw)
555 bad_pos += nand->bad_mark.sec * mtk_data_len(chip);
556 else
557 bad_pos += nand->bad_mark.sec * chip->ecc.size;
558
559 swap(chip->oob_poi[0], buf[bad_pos]);
560 }
561
562 static int mtk_nfc_format_subpage(struct mtd_info *mtd, u32 offset,
563 u32 len, const u8 *buf)
564 {
565 struct nand_chip *chip = mtd_to_nand(mtd);
566 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
567 struct mtk_nfc *nfc = nand_get_controller_data(chip);
568 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
569 u32 start, end;
570 int i, ret;
571
572 start = offset / chip->ecc.size;
573 end = DIV_ROUND_UP(offset + len, chip->ecc.size);
574
575 memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);
576 for (i = 0; i < chip->ecc.steps; i++) {
577 memcpy(mtk_data_ptr(chip, i), data_ptr(chip, buf, i),
578 chip->ecc.size);
579
580 if (start > i || i >= end)
581 continue;
582
583 if (i == mtk_nand->bad_mark.sec)
584 mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);
585
586 memcpy(mtk_oob_ptr(chip, i), oob_ptr(chip, i), fdm->reg_size);
587
588 /* program the CRC back to the OOB */
589 ret = mtk_nfc_sector_encode(chip, mtk_data_ptr(chip, i));
590 if (ret < 0)
591 return ret;
592 }
593
594 return 0;
595 }
596
597 static void mtk_nfc_format_page(struct mtd_info *mtd, const u8 *buf)
598 {
599 struct nand_chip *chip = mtd_to_nand(mtd);
600 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
601 struct mtk_nfc *nfc = nand_get_controller_data(chip);
602 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
603 u32 i;
604
605 memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);
606 for (i = 0; i < chip->ecc.steps; i++) {
607 if (buf)
608 memcpy(mtk_data_ptr(chip, i), data_ptr(chip, buf, i),
609 chip->ecc.size);
610
611 if (i == mtk_nand->bad_mark.sec)
612 mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);
613
614 memcpy(mtk_oob_ptr(chip, i), oob_ptr(chip, i), fdm->reg_size);
615 }
616 }
617
618 static inline void mtk_nfc_read_fdm(struct nand_chip *chip, u32 start,
619 u32 sectors)
620 {
621 struct mtk_nfc *nfc = nand_get_controller_data(chip);
622 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
623 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
624 u32 vall, valm;
625 u8 *oobptr;
626 int i, j;
627
628 for (i = 0; i < sectors; i++) {
629 oobptr = oob_ptr(chip, start + i);
630 vall = nfi_readl(nfc, NFI_FDML(i));
631 valm = nfi_readl(nfc, NFI_FDMM(i));
632
633 for (j = 0; j < fdm->reg_size; j++)
634 oobptr[j] = (j >= 4 ? valm : vall) >> ((j % 4) * 8);
635 }
636 }
637
638 static inline void mtk_nfc_write_fdm(struct nand_chip *chip)
639 {
640 struct mtk_nfc *nfc = nand_get_controller_data(chip);
641 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
642 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
643 u32 vall, valm;
644 u8 *oobptr;
645 int i, j;
646
647 for (i = 0; i < chip->ecc.steps; i++) {
648 oobptr = oob_ptr(chip, i);
649 vall = 0;
650 valm = 0;
651 for (j = 0; j < 8; j++) {
652 if (j < 4)
653 vall |= (j < fdm->reg_size ? oobptr[j] : 0xff)
654 << (j * 8);
655 else
656 valm |= (j < fdm->reg_size ? oobptr[j] : 0xff)
657 << ((j - 4) * 8);
658 }
659 nfi_writel(nfc, vall, NFI_FDML(i));
660 nfi_writel(nfc, valm, NFI_FDMM(i));
661 }
662 }
663
664 static int mtk_nfc_do_write_page(struct mtd_info *mtd, struct nand_chip *chip,
665 const u8 *buf, int page, int len)
666 {
667 struct mtk_nfc *nfc = nand_get_controller_data(chip);
668 struct device *dev = nfc->dev;
669 dma_addr_t addr;
670 u32 reg;
671 int ret;
672
673 addr = dma_map_single(dev, (void *)buf, len, DMA_TO_DEVICE);
674 ret = dma_mapping_error(nfc->dev, addr);
675 if (ret) {
676 dev_err(nfc->dev, "dma mapping error\n");
677 return -EINVAL;
678 }
679
680 reg = nfi_readw(nfc, NFI_CNFG) | CNFG_AHB | CNFG_DMA_BURST_EN;
681 nfi_writew(nfc, reg, NFI_CNFG);
682
683 nfi_writel(nfc, chip->ecc.steps << CON_SEC_SHIFT, NFI_CON);
684 nfi_writel(nfc, lower_32_bits(addr), NFI_STRADDR);
685 nfi_writew(nfc, INTR_AHB_DONE_EN, NFI_INTR_EN);
686
687 init_completion(&nfc->done);
688
689 reg = nfi_readl(nfc, NFI_CON) | CON_BWR;
690 nfi_writel(nfc, reg, NFI_CON);
691 nfi_writew(nfc, STAR_EN, NFI_STRDATA);
692
693 ret = wait_for_completion_timeout(&nfc->done, msecs_to_jiffies(500));
694 if (!ret) {
695 dev_err(dev, "program ahb done timeout\n");
696 nfi_writew(nfc, 0, NFI_INTR_EN);
697 ret = -ETIMEDOUT;
698 goto timeout;
699 }
700
701 ret = readl_poll_timeout_atomic(nfc->regs + NFI_ADDRCNTR, reg,
702 (reg & CNTR_MASK) >= chip->ecc.steps,
703 10, MTK_TIMEOUT);
704 if (ret)
705 dev_err(dev, "hwecc write timeout\n");
706
707 timeout:
708
709 dma_unmap_single(nfc->dev, addr, len, DMA_TO_DEVICE);
710 nfi_writel(nfc, 0, NFI_CON);
711
712 return ret;
713 }
714
715 static int mtk_nfc_write_page(struct mtd_info *mtd, struct nand_chip *chip,
716 const u8 *buf, int page, int raw)
717 {
718 struct mtk_nfc *nfc = nand_get_controller_data(chip);
719 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
720 size_t len;
721 const u8 *bufpoi;
722 u32 reg;
723 int ret;
724
725 if (!raw) {
726 /* OOB => FDM: from register, ECC: from HW */
727 reg = nfi_readw(nfc, NFI_CNFG) | CNFG_AUTO_FMT_EN;
728 nfi_writew(nfc, reg | CNFG_HW_ECC_EN, NFI_CNFG);
729
730 nfc->ecc_cfg.op = ECC_ENCODE;
731 nfc->ecc_cfg.mode = ECC_NFI_MODE;
732 ret = mtk_ecc_enable(nfc->ecc, &nfc->ecc_cfg);
733 if (ret) {
734 /* clear NFI config */
735 reg = nfi_readw(nfc, NFI_CNFG);
736 reg &= ~(CNFG_AUTO_FMT_EN | CNFG_HW_ECC_EN);
737 nfi_writew(nfc, reg, NFI_CNFG);
738
739 return ret;
740 }
741
742 memcpy(nfc->buffer, buf, mtd->writesize);
743 mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, raw);
744 bufpoi = nfc->buffer;
745
746 /* write OOB into the FDM registers (OOB area in MTK NAND) */
747 mtk_nfc_write_fdm(chip);
748 } else {
749 bufpoi = buf;
750 }
751
752 len = mtd->writesize + (raw ? mtd->oobsize : 0);
753 ret = mtk_nfc_do_write_page(mtd, chip, bufpoi, page, len);
754
755 if (!raw)
756 mtk_ecc_disable(nfc->ecc);
757
758 return ret;
759 }
760
761 static int mtk_nfc_write_page_hwecc(struct mtd_info *mtd,
762 struct nand_chip *chip, const u8 *buf,
763 int oob_on, int page)
764 {
765 return mtk_nfc_write_page(mtd, chip, buf, page, 0);
766 }
767
768 static int mtk_nfc_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
769 const u8 *buf, int oob_on, int pg)
770 {
771 struct mtk_nfc *nfc = nand_get_controller_data(chip);
772
773 mtk_nfc_format_page(mtd, buf);
774 return mtk_nfc_write_page(mtd, chip, nfc->buffer, pg, 1);
775 }
776
777 static int mtk_nfc_write_subpage_hwecc(struct mtd_info *mtd,
778 struct nand_chip *chip, u32 offset,
779 u32 data_len, const u8 *buf,
780 int oob_on, int page)
781 {
782 struct mtk_nfc *nfc = nand_get_controller_data(chip);
783 int ret;
784
785 ret = mtk_nfc_format_subpage(mtd, offset, data_len, buf);
786 if (ret < 0)
787 return ret;
788
789 /* use the data in the private buffer (now with FDM and CRC) */
790 return mtk_nfc_write_page(mtd, chip, nfc->buffer, page, 1);
791 }
792
793 static int mtk_nfc_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
794 int page)
795 {
796 int ret;
797
798 chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0x00, page);
799
800 ret = mtk_nfc_write_page_raw(mtd, chip, NULL, 1, page);
801 if (ret < 0)
802 return -EIO;
803
804 chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
805 ret = chip->waitfunc(mtd, chip);
806
807 return ret & NAND_STATUS_FAIL ? -EIO : 0;
808 }
809
810 static int mtk_nfc_update_ecc_stats(struct mtd_info *mtd, u8 *buf, u32 sectors)
811 {
812 struct nand_chip *chip = mtd_to_nand(mtd);
813 struct mtk_nfc *nfc = nand_get_controller_data(chip);
814 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
815 struct mtk_ecc_stats stats;
816 int rc, i;
817
818 rc = nfi_readl(nfc, NFI_STA) & STA_EMP_PAGE;
819 if (rc) {
820 memset(buf, 0xff, sectors * chip->ecc.size);
821 for (i = 0; i < sectors; i++)
822 memset(oob_ptr(chip, i), 0xff, mtk_nand->fdm.reg_size);
823 return 0;
824 }
825
826 mtk_ecc_get_stats(nfc->ecc, &stats, sectors);
827 mtd->ecc_stats.corrected += stats.corrected;
828 mtd->ecc_stats.failed += stats.failed;
829
830 return stats.bitflips;
831 }
832
833 static int mtk_nfc_read_subpage(struct mtd_info *mtd, struct nand_chip *chip,
834 u32 data_offs, u32 readlen,
835 u8 *bufpoi, int page, int raw)
836 {
837 struct mtk_nfc *nfc = nand_get_controller_data(chip);
838 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
839 u32 spare = mtk_nand->spare_per_sector;
840 u32 column, sectors, start, end, reg;
841 dma_addr_t addr;
842 int bitflips;
843 size_t len;
844 u8 *buf;
845 int rc;
846
847 start = data_offs / chip->ecc.size;
848 end = DIV_ROUND_UP(data_offs + readlen, chip->ecc.size);
849
850 sectors = end - start;
851 column = start * (chip->ecc.size + spare);
852
853 len = sectors * chip->ecc.size + (raw ? sectors * spare : 0);
854 buf = bufpoi + start * chip->ecc.size;
855
856 if (column != 0)
857 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, column, -1);
858
859 addr = dma_map_single(nfc->dev, buf, len, DMA_FROM_DEVICE);
860 rc = dma_mapping_error(nfc->dev, addr);
861 if (rc) {
862 dev_err(nfc->dev, "dma mapping error\n");
863
864 return -EINVAL;
865 }
866
867 reg = nfi_readw(nfc, NFI_CNFG);
868 reg |= CNFG_READ_EN | CNFG_DMA_BURST_EN | CNFG_AHB;
869 if (!raw) {
870 reg |= CNFG_AUTO_FMT_EN | CNFG_HW_ECC_EN;
871 nfi_writew(nfc, reg, NFI_CNFG);
872
873 nfc->ecc_cfg.mode = ECC_NFI_MODE;
874 nfc->ecc_cfg.sectors = sectors;
875 nfc->ecc_cfg.op = ECC_DECODE;
876 rc = mtk_ecc_enable(nfc->ecc, &nfc->ecc_cfg);
877 if (rc) {
878 dev_err(nfc->dev, "ecc enable\n");
879 /* clear NFI_CNFG */
880 reg &= ~(CNFG_DMA_BURST_EN | CNFG_AHB | CNFG_READ_EN |
881 CNFG_AUTO_FMT_EN | CNFG_HW_ECC_EN);
882 nfi_writew(nfc, reg, NFI_CNFG);
883 dma_unmap_single(nfc->dev, addr, len, DMA_FROM_DEVICE);
884
885 return rc;
886 }
887 } else {
888 nfi_writew(nfc, reg, NFI_CNFG);
889 }
890
891 nfi_writel(nfc, sectors << CON_SEC_SHIFT, NFI_CON);
892 nfi_writew(nfc, INTR_AHB_DONE_EN, NFI_INTR_EN);
893 nfi_writel(nfc, lower_32_bits(addr), NFI_STRADDR);
894
895 init_completion(&nfc->done);
896 reg = nfi_readl(nfc, NFI_CON) | CON_BRD;
897 nfi_writel(nfc, reg, NFI_CON);
898 nfi_writew(nfc, STAR_EN, NFI_STRDATA);
899
900 rc = wait_for_completion_timeout(&nfc->done, msecs_to_jiffies(500));
901 if (!rc)
902 dev_warn(nfc->dev, "read ahb/dma done timeout\n");
903
904 rc = readl_poll_timeout_atomic(nfc->regs + NFI_BYTELEN, reg,
905 (reg & CNTR_MASK) >= sectors, 10,
906 MTK_TIMEOUT);
907 if (rc < 0) {
908 dev_err(nfc->dev, "subpage done timeout\n");
909 bitflips = -EIO;
910 } else {
911 bitflips = 0;
912 if (!raw) {
913 rc = mtk_ecc_wait_done(nfc->ecc, ECC_DECODE);
914 bitflips = rc < 0 ? -ETIMEDOUT :
915 mtk_nfc_update_ecc_stats(mtd, buf, sectors);
916 mtk_nfc_read_fdm(chip, start, sectors);
917 }
918 }
919
920 dma_unmap_single(nfc->dev, addr, len, DMA_FROM_DEVICE);
921
922 if (raw)
923 goto done;
924
925 mtk_ecc_disable(nfc->ecc);
926
927 if (clamp(mtk_nand->bad_mark.sec, start, end) == mtk_nand->bad_mark.sec)
928 mtk_nand->bad_mark.bm_swap(mtd, bufpoi, raw);
929 done:
930 nfi_writel(nfc, 0, NFI_CON);
931
932 return bitflips;
933 }
934
935 static int mtk_nfc_read_subpage_hwecc(struct mtd_info *mtd,
936 struct nand_chip *chip, u32 off,
937 u32 len, u8 *p, int pg)
938 {
939 return mtk_nfc_read_subpage(mtd, chip, off, len, p, pg, 0);
940 }
941
942 static int mtk_nfc_read_page_hwecc(struct mtd_info *mtd,
943 struct nand_chip *chip, u8 *p,
944 int oob_on, int pg)
945 {
946 return mtk_nfc_read_subpage(mtd, chip, 0, mtd->writesize, p, pg, 0);
947 }
948
949 static int mtk_nfc_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
950 u8 *buf, int oob_on, int page)
951 {
952 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
953 struct mtk_nfc *nfc = nand_get_controller_data(chip);
954 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
955 int i, ret;
956
957 memset(nfc->buffer, 0xff, mtd->writesize + mtd->oobsize);
958 ret = mtk_nfc_read_subpage(mtd, chip, 0, mtd->writesize, nfc->buffer,
959 page, 1);
960 if (ret < 0)
961 return ret;
962
963 for (i = 0; i < chip->ecc.steps; i++) {
964 memcpy(oob_ptr(chip, i), mtk_oob_ptr(chip, i), fdm->reg_size);
965
966 if (i == mtk_nand->bad_mark.sec)
967 mtk_nand->bad_mark.bm_swap(mtd, nfc->buffer, 1);
968
969 if (buf)
970 memcpy(data_ptr(chip, buf, i), mtk_data_ptr(chip, i),
971 chip->ecc.size);
972 }
973
974 return ret;
975 }
976
977 static int mtk_nfc_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip,
978 int page)
979 {
980 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
981
982 return mtk_nfc_read_page_raw(mtd, chip, NULL, 1, page);
983 }
984
985 static inline void mtk_nfc_hw_init(struct mtk_nfc *nfc)
986 {
987 /*
988 * ACCON: access timing control register
989 * -------------------------------------
990 * 31:28: minimum required time for CS post pulling down after accessing
991 * the device
992 * 27:22: minimum required time for CS pre pulling down before accessing
993 * the device
994 * 21:16: minimum required time from NCEB low to NREB low
995 * 15:12: minimum required time from NWEB high to NREB low.
996 * 11:08: write enable hold time
997 * 07:04: write wait states
998 * 03:00: read wait states
999 */
1000 nfi_writel(nfc, 0x10804211, NFI_ACCCON);
1001
1002 /*
1003 * CNRNB: nand ready/busy register
1004 * -------------------------------
1005 * 7:4: timeout register for polling the NAND busy/ready signal
1006 * 0 : poll the status of the busy/ready signal after [7:4]*16 cycles.
1007 */
1008 nfi_writew(nfc, 0xf1, NFI_CNRNB);
1009 nfi_writew(nfc, PAGEFMT_8K_16K, NFI_PAGEFMT);
1010
1011 mtk_nfc_hw_reset(nfc);
1012
1013 nfi_readl(nfc, NFI_INTR_STA);
1014 nfi_writel(nfc, 0, NFI_INTR_EN);
1015 }
1016
1017 static irqreturn_t mtk_nfc_irq(int irq, void *id)
1018 {
1019 struct mtk_nfc *nfc = id;
1020 u16 sta, ien;
1021
1022 sta = nfi_readw(nfc, NFI_INTR_STA);
1023 ien = nfi_readw(nfc, NFI_INTR_EN);
1024
1025 if (!(sta & ien))
1026 return IRQ_NONE;
1027
1028 nfi_writew(nfc, ~sta & ien, NFI_INTR_EN);
1029 complete(&nfc->done);
1030
1031 return IRQ_HANDLED;
1032 }
1033
1034 static int mtk_nfc_enable_clk(struct device *dev, struct mtk_nfc_clk *clk)
1035 {
1036 int ret;
1037
1038 ret = clk_prepare_enable(clk->nfi_clk);
1039 if (ret) {
1040 dev_err(dev, "failed to enable nfi clk\n");
1041 return ret;
1042 }
1043
1044 ret = clk_prepare_enable(clk->pad_clk);
1045 if (ret) {
1046 dev_err(dev, "failed to enable pad clk\n");
1047 clk_disable_unprepare(clk->nfi_clk);
1048 return ret;
1049 }
1050
1051 return 0;
1052 }
1053
1054 static void mtk_nfc_disable_clk(struct mtk_nfc_clk *clk)
1055 {
1056 clk_disable_unprepare(clk->nfi_clk);
1057 clk_disable_unprepare(clk->pad_clk);
1058 }
1059
1060 static int mtk_nfc_ooblayout_free(struct mtd_info *mtd, int section,
1061 struct mtd_oob_region *oob_region)
1062 {
1063 struct nand_chip *chip = mtd_to_nand(mtd);
1064 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
1065 struct mtk_nfc_fdm *fdm = &mtk_nand->fdm;
1066 u32 eccsteps;
1067
1068 eccsteps = mtd->writesize / chip->ecc.size;
1069
1070 if (section >= eccsteps)
1071 return -ERANGE;
1072
1073 oob_region->length = fdm->reg_size - fdm->ecc_size;
1074 oob_region->offset = section * fdm->reg_size + fdm->ecc_size;
1075
1076 return 0;
1077 }
1078
1079 static int mtk_nfc_ooblayout_ecc(struct mtd_info *mtd, int section,
1080 struct mtd_oob_region *oob_region)
1081 {
1082 struct nand_chip *chip = mtd_to_nand(mtd);
1083 struct mtk_nfc_nand_chip *mtk_nand = to_mtk_nand(chip);
1084 u32 eccsteps;
1085
1086 if (section)
1087 return -ERANGE;
1088
1089 eccsteps = mtd->writesize / chip->ecc.size;
1090 oob_region->offset = mtk_nand->fdm.reg_size * eccsteps;
1091 oob_region->length = mtd->oobsize - oob_region->offset;
1092
1093 return 0;
1094 }
1095
1096 static const struct mtd_ooblayout_ops mtk_nfc_ooblayout_ops = {
1097 .free = mtk_nfc_ooblayout_free,
1098 .ecc = mtk_nfc_ooblayout_ecc,
1099 };
1100
1101 static void mtk_nfc_set_fdm(struct mtk_nfc_fdm *fdm, struct mtd_info *mtd)
1102 {
1103 struct nand_chip *nand = mtd_to_nand(mtd);
1104 struct mtk_nfc_nand_chip *chip = to_mtk_nand(nand);
1105 u32 ecc_bytes;
1106
1107 ecc_bytes = DIV_ROUND_UP(nand->ecc.strength * ECC_PARITY_BITS, 8);
1108
1109 fdm->reg_size = chip->spare_per_sector - ecc_bytes;
1110 if (fdm->reg_size > NFI_FDM_MAX_SIZE)
1111 fdm->reg_size = NFI_FDM_MAX_SIZE;
1112
1113 /* bad block mark storage */
1114 fdm->ecc_size = 1;
1115 }
1116
1117 static void mtk_nfc_set_bad_mark_ctl(struct mtk_nfc_bad_mark_ctl *bm_ctl,
1118 struct mtd_info *mtd)
1119 {
1120 struct nand_chip *nand = mtd_to_nand(mtd);
1121
1122 if (mtd->writesize == 512) {
1123 bm_ctl->bm_swap = mtk_nfc_no_bad_mark_swap;
1124 } else {
1125 bm_ctl->bm_swap = mtk_nfc_bad_mark_swap;
1126 bm_ctl->sec = mtd->writesize / mtk_data_len(nand);
1127 bm_ctl->pos = mtd->writesize % mtk_data_len(nand);
1128 }
1129 }
1130
1131 static void mtk_nfc_set_spare_per_sector(u32 *sps, struct mtd_info *mtd)
1132 {
1133 struct nand_chip *nand = mtd_to_nand(mtd);
1134 u32 spare[] = {16, 26, 27, 28, 32, 36, 40, 44,
1135 48, 49, 50, 51, 52, 62, 63, 64};
1136 u32 eccsteps, i;
1137
1138 eccsteps = mtd->writesize / nand->ecc.size;
1139 *sps = mtd->oobsize / eccsteps;
1140
1141 if (nand->ecc.size == 1024)
1142 *sps >>= 1;
1143
1144 for (i = 0; i < ARRAY_SIZE(spare); i++) {
1145 if (*sps <= spare[i]) {
1146 if (!i)
1147 *sps = spare[i];
1148 else if (*sps != spare[i])
1149 *sps = spare[i - 1];
1150 break;
1151 }
1152 }
1153
1154 if (i >= ARRAY_SIZE(spare))
1155 *sps = spare[ARRAY_SIZE(spare) - 1];
1156
1157 if (nand->ecc.size == 1024)
1158 *sps <<= 1;
1159 }
1160
1161 static int mtk_nfc_ecc_init(struct device *dev, struct mtd_info *mtd)
1162 {
1163 struct nand_chip *nand = mtd_to_nand(mtd);
1164 u32 spare;
1165 int free;
1166
1167 /* support only ecc hw mode */
1168 if (nand->ecc.mode != NAND_ECC_HW) {
1169 dev_err(dev, "ecc.mode not supported\n");
1170 return -EINVAL;
1171 }
1172
1173 /* if optional dt settings not present */
1174 if (!nand->ecc.size || !nand->ecc.strength) {
1175 /* use datasheet requirements */
1176 nand->ecc.strength = nand->ecc_strength_ds;
1177 nand->ecc.size = nand->ecc_step_ds;
1178
1179 /*
1180 * align eccstrength and eccsize
1181 * this controller only supports 512 and 1024 sizes
1182 */
1183 if (nand->ecc.size < 1024) {
1184 if (mtd->writesize > 512) {
1185 nand->ecc.size = 1024;
1186 nand->ecc.strength <<= 1;
1187 } else {
1188 nand->ecc.size = 512;
1189 }
1190 } else {
1191 nand->ecc.size = 1024;
1192 }
1193
1194 mtk_nfc_set_spare_per_sector(&spare, mtd);
1195
1196 /* calculate oob bytes except ecc parity data */
1197 free = ((nand->ecc.strength * ECC_PARITY_BITS) + 7) >> 3;
1198 free = spare - free;
1199
1200 /*
1201 * enhance ecc strength if oob left is bigger than max FDM size
1202 * or reduce ecc strength if oob size is not enough for ecc
1203 * parity data.
1204 */
1205 if (free > NFI_FDM_MAX_SIZE) {
1206 spare -= NFI_FDM_MAX_SIZE;
1207 nand->ecc.strength = (spare << 3) / ECC_PARITY_BITS;
1208 } else if (free < 0) {
1209 spare -= NFI_FDM_MIN_SIZE;
1210 nand->ecc.strength = (spare << 3) / ECC_PARITY_BITS;
1211 }
1212 }
1213
1214 mtk_ecc_adjust_strength(&nand->ecc.strength);
1215
1216 dev_info(dev, "eccsize %d eccstrength %d\n",
1217 nand->ecc.size, nand->ecc.strength);
1218
1219 return 0;
1220 }
1221
1222 static int mtk_nfc_nand_chip_init(struct device *dev, struct mtk_nfc *nfc,
1223 struct device_node *np)
1224 {
1225 struct mtk_nfc_nand_chip *chip;
1226 struct nand_chip *nand;
1227 struct mtd_info *mtd;
1228 int nsels, len;
1229 u32 tmp;
1230 int ret;
1231 int i;
1232
1233 if (!of_get_property(np, "reg", &nsels))
1234 return -ENODEV;
1235
1236 nsels /= sizeof(u32);
1237 if (!nsels || nsels > MTK_NAND_MAX_NSELS) {
1238 dev_err(dev, "invalid reg property size %d\n", nsels);
1239 return -EINVAL;
1240 }
1241
1242 chip = devm_kzalloc(dev, sizeof(*chip) + nsels * sizeof(u8),
1243 GFP_KERNEL);
1244 if (!chip)
1245 return -ENOMEM;
1246
1247 chip->nsels = nsels;
1248 for (i = 0; i < nsels; i++) {
1249 ret = of_property_read_u32_index(np, "reg", i, &tmp);
1250 if (ret) {
1251 dev_err(dev, "reg property failure : %d\n", ret);
1252 return ret;
1253 }
1254 chip->sels[i] = tmp;
1255 }
1256
1257 nand = &chip->nand;
1258 nand->controller = &nfc->controller;
1259
1260 nand_set_flash_node(nand, np);
1261 nand_set_controller_data(nand, nfc);
1262
1263 nand->options |= NAND_USE_BOUNCE_BUFFER | NAND_SUBPAGE_READ;
1264 nand->dev_ready = mtk_nfc_dev_ready;
1265 nand->select_chip = mtk_nfc_select_chip;
1266 nand->write_byte = mtk_nfc_write_byte;
1267 nand->write_buf = mtk_nfc_write_buf;
1268 nand->read_byte = mtk_nfc_read_byte;
1269 nand->read_buf = mtk_nfc_read_buf;
1270 nand->cmd_ctrl = mtk_nfc_cmd_ctrl;
1271
1272 /* set default mode in case dt entry is missing */
1273 nand->ecc.mode = NAND_ECC_HW;
1274
1275 nand->ecc.write_subpage = mtk_nfc_write_subpage_hwecc;
1276 nand->ecc.write_page_raw = mtk_nfc_write_page_raw;
1277 nand->ecc.write_page = mtk_nfc_write_page_hwecc;
1278 nand->ecc.write_oob_raw = mtk_nfc_write_oob_std;
1279 nand->ecc.write_oob = mtk_nfc_write_oob_std;
1280
1281 nand->ecc.read_subpage = mtk_nfc_read_subpage_hwecc;
1282 nand->ecc.read_page_raw = mtk_nfc_read_page_raw;
1283 nand->ecc.read_page = mtk_nfc_read_page_hwecc;
1284 nand->ecc.read_oob_raw = mtk_nfc_read_oob_std;
1285 nand->ecc.read_oob = mtk_nfc_read_oob_std;
1286
1287 mtd = nand_to_mtd(nand);
1288 mtd->owner = THIS_MODULE;
1289 mtd->dev.parent = dev;
1290 mtd->name = MTK_NAME;
1291 mtd_set_ooblayout(mtd, &mtk_nfc_ooblayout_ops);
1292
1293 mtk_nfc_hw_init(nfc);
1294
1295 ret = nand_scan_ident(mtd, nsels, NULL);
1296 if (ret)
1297 return -ENODEV;
1298
1299 /* store bbt magic in page, cause OOB is not protected */
1300 if (nand->bbt_options & NAND_BBT_USE_FLASH)
1301 nand->bbt_options |= NAND_BBT_NO_OOB;
1302
1303 ret = mtk_nfc_ecc_init(dev, mtd);
1304 if (ret)
1305 return -EINVAL;
1306
1307 if (nand->options & NAND_BUSWIDTH_16) {
1308 dev_err(dev, "16bits buswidth not supported");
1309 return -EINVAL;
1310 }
1311
1312 mtk_nfc_set_spare_per_sector(&chip->spare_per_sector, mtd);
1313 mtk_nfc_set_fdm(&chip->fdm, mtd);
1314 mtk_nfc_set_bad_mark_ctl(&chip->bad_mark, mtd);
1315
1316 len = mtd->writesize + mtd->oobsize;
1317 nfc->buffer = devm_kzalloc(dev, len, GFP_KERNEL);
1318 if (!nfc->buffer)
1319 return -ENOMEM;
1320
1321 ret = nand_scan_tail(mtd);
1322 if (ret)
1323 return -ENODEV;
1324
1325 ret = mtd_device_parse_register(mtd, NULL, NULL, NULL, 0);
1326 if (ret) {
1327 dev_err(dev, "mtd parse partition error\n");
1328 nand_release(mtd);
1329 return ret;
1330 }
1331
1332 list_add_tail(&chip->node, &nfc->chips);
1333
1334 return 0;
1335 }
1336
1337 static int mtk_nfc_nand_chips_init(struct device *dev, struct mtk_nfc *nfc)
1338 {
1339 struct device_node *np = dev->of_node;
1340 struct device_node *nand_np;
1341 int ret;
1342
1343 for_each_child_of_node(np, nand_np) {
1344 ret = mtk_nfc_nand_chip_init(dev, nfc, nand_np);
1345 if (ret) {
1346 of_node_put(nand_np);
1347 return ret;
1348 }
1349 }
1350
1351 return 0;
1352 }
1353
1354 static int mtk_nfc_probe(struct platform_device *pdev)
1355 {
1356 struct device *dev = &pdev->dev;
1357 struct device_node *np = dev->of_node;
1358 struct mtk_nfc *nfc;
1359 struct resource *res;
1360 int ret, irq;
1361
1362 nfc = devm_kzalloc(dev, sizeof(*nfc), GFP_KERNEL);
1363 if (!nfc)
1364 return -ENOMEM;
1365
1366 spin_lock_init(&nfc->controller.lock);
1367 init_waitqueue_head(&nfc->controller.wq);
1368 INIT_LIST_HEAD(&nfc->chips);
1369
1370 /* probe defer if not ready */
1371 nfc->ecc = of_mtk_ecc_get(np);
1372 if (IS_ERR(nfc->ecc))
1373 return PTR_ERR(nfc->ecc);
1374 else if (!nfc->ecc)
1375 return -ENODEV;
1376
1377 nfc->dev = dev;
1378
1379 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1380 nfc->regs = devm_ioremap_resource(dev, res);
1381 if (IS_ERR(nfc->regs)) {
1382 ret = PTR_ERR(nfc->regs);
1383 dev_err(dev, "no nfi base\n");
1384 goto release_ecc;
1385 }
1386
1387 nfc->clk.nfi_clk = devm_clk_get(dev, "nfi_clk");
1388 if (IS_ERR(nfc->clk.nfi_clk)) {
1389 dev_err(dev, "no clk\n");
1390 ret = PTR_ERR(nfc->clk.nfi_clk);
1391 goto release_ecc;
1392 }
1393
1394 nfc->clk.pad_clk = devm_clk_get(dev, "pad_clk");
1395 if (IS_ERR(nfc->clk.pad_clk)) {
1396 dev_err(dev, "no pad clk\n");
1397 ret = PTR_ERR(nfc->clk.pad_clk);
1398 goto release_ecc;
1399 }
1400
1401 ret = mtk_nfc_enable_clk(dev, &nfc->clk);
1402 if (ret)
1403 goto release_ecc;
1404
1405 irq = platform_get_irq(pdev, 0);
1406 if (irq < 0) {
1407 dev_err(dev, "no nfi irq resource\n");
1408 ret = -EINVAL;
1409 goto clk_disable;
1410 }
1411
1412 ret = devm_request_irq(dev, irq, mtk_nfc_irq, 0x0, "mtk-nand", nfc);
1413 if (ret) {
1414 dev_err(dev, "failed to request nfi irq\n");
1415 goto clk_disable;
1416 }
1417
1418 ret = dma_set_mask(dev, DMA_BIT_MASK(32));
1419 if (ret) {
1420 dev_err(dev, "failed to set dma mask\n");
1421 goto clk_disable;
1422 }
1423
1424 platform_set_drvdata(pdev, nfc);
1425
1426 ret = mtk_nfc_nand_chips_init(dev, nfc);
1427 if (ret) {
1428 dev_err(dev, "failed to init nand chips\n");
1429 goto clk_disable;
1430 }
1431
1432 return 0;
1433
1434 clk_disable:
1435 mtk_nfc_disable_clk(&nfc->clk);
1436
1437 release_ecc:
1438 mtk_ecc_release(nfc->ecc);
1439
1440 return ret;
1441 }
1442
1443 static int mtk_nfc_remove(struct platform_device *pdev)
1444 {
1445 struct mtk_nfc *nfc = platform_get_drvdata(pdev);
1446 struct mtk_nfc_nand_chip *chip;
1447
1448 while (!list_empty(&nfc->chips)) {
1449 chip = list_first_entry(&nfc->chips, struct mtk_nfc_nand_chip,
1450 node);
1451 nand_release(nand_to_mtd(&chip->nand));
1452 list_del(&chip->node);
1453 }
1454
1455 mtk_ecc_release(nfc->ecc);
1456 mtk_nfc_disable_clk(&nfc->clk);
1457
1458 return 0;
1459 }
1460
1461 #ifdef CONFIG_PM_SLEEP
1462 static int mtk_nfc_suspend(struct device *dev)
1463 {
1464 struct mtk_nfc *nfc = dev_get_drvdata(dev);
1465
1466 mtk_nfc_disable_clk(&nfc->clk);
1467
1468 return 0;
1469 }
1470
1471 static int mtk_nfc_resume(struct device *dev)
1472 {
1473 struct mtk_nfc *nfc = dev_get_drvdata(dev);
1474 struct mtk_nfc_nand_chip *chip;
1475 struct nand_chip *nand;
1476 struct mtd_info *mtd;
1477 int ret;
1478 u32 i;
1479
1480 udelay(200);
1481
1482 ret = mtk_nfc_enable_clk(dev, &nfc->clk);
1483 if (ret)
1484 return ret;
1485
1486 mtk_nfc_hw_init(nfc);
1487
1488 /* reset NAND chip if VCC was powered off */
1489 list_for_each_entry(chip, &nfc->chips, node) {
1490 nand = &chip->nand;
1491 mtd = nand_to_mtd(nand);
1492 for (i = 0; i < chip->nsels; i++) {
1493 nand->select_chip(mtd, i);
1494 nand->cmdfunc(mtd, NAND_CMD_RESET, -1, -1);
1495 }
1496 }
1497
1498 return 0;
1499 }
1500
1501 static SIMPLE_DEV_PM_OPS(mtk_nfc_pm_ops, mtk_nfc_suspend, mtk_nfc_resume);
1502 #endif
1503
1504 static const struct of_device_id mtk_nfc_id_table[] = {
1505 { .compatible = "mediatek,mt2701-nfc" },
1506 {}
1507 };
1508 MODULE_DEVICE_TABLE(of, mtk_nfc_id_table);
1509
1510 static struct platform_driver mtk_nfc_driver = {
1511 .probe = mtk_nfc_probe,
1512 .remove = mtk_nfc_remove,
1513 .driver = {
1514 .name = MTK_NAME,
1515 .of_match_table = mtk_nfc_id_table,
1516 #ifdef CONFIG_PM_SLEEP
1517 .pm = &mtk_nfc_pm_ops,
1518 #endif
1519 },
1520 };
1521
1522 module_platform_driver(mtk_nfc_driver);
1523
1524 MODULE_LICENSE("GPL");
1525 MODULE_AUTHOR("Xiaolei Li <xiaolei.li@mediatek.com>");
1526 MODULE_DESCRIPTION("MTK Nand Flash Controller Driver");
Linux kernel - Deliverables
This page took 0.064465 seconds and 5 git commands to generate.