1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <common.h>
29#include <fdtdec.h>
30#include <memalign.h>
31#include <nand.h>
32
33#include <linux/kernel.h>
34#include <linux/mtd/mtd.h>
35#include <linux/mtd/nand.h>
36#include <linux/mtd/partitions.h>
37#include <linux/io.h>
38
39#include <asm/gpio.h>
40#include <asm/arch/clock.h>
41
42DECLARE_GLOBAL_DATA_PTR;
43
44#define NFC_REG_CTL 0x0000
45#define NFC_REG_ST 0x0004
46#define NFC_REG_INT 0x0008
47#define NFC_REG_TIMING_CTL 0x000C
48#define NFC_REG_TIMING_CFG 0x0010
49#define NFC_REG_ADDR_LOW 0x0014
50#define NFC_REG_ADDR_HIGH 0x0018
51#define NFC_REG_SECTOR_NUM 0x001C
52#define NFC_REG_CNT 0x0020
53#define NFC_REG_CMD 0x0024
54#define NFC_REG_RCMD_SET 0x0028
55#define NFC_REG_WCMD_SET 0x002C
56#define NFC_REG_IO_DATA 0x0030
57#define NFC_REG_ECC_CTL 0x0034
58#define NFC_REG_ECC_ST 0x0038
59#define NFC_REG_DEBUG 0x003C
60#define NFC_REG_ECC_ERR_CNT(x) ((0x0040 + (x)) & ~0x3)
61#define NFC_REG_USER_DATA(x) (0x0050 + ((x) * 4))
62#define NFC_REG_SPARE_AREA 0x00A0
63#define NFC_REG_PAT_ID 0x00A4
64#define NFC_RAM0_BASE 0x0400
65#define NFC_RAM1_BASE 0x0800
66
67
68#define NFC_EN BIT(0)
69#define NFC_RESET BIT(1)
70#define NFC_BUS_WIDTH_MSK BIT(2)
71#define NFC_BUS_WIDTH_8 (0 << 2)
72#define NFC_BUS_WIDTH_16 (1 << 2)
73#define NFC_RB_SEL_MSK BIT(3)
74#define NFC_RB_SEL(x) ((x) << 3)
75#define NFC_CE_SEL_MSK (0x7 << 24)
76#define NFC_CE_SEL(x) ((x) << 24)
77#define NFC_CE_CTL BIT(6)
78#define NFC_PAGE_SHIFT_MSK (0xf << 8)
79#define NFC_PAGE_SHIFT(x) (((x) < 10 ? 0 : (x) - 10) << 8)
80#define NFC_SAM BIT(12)
81#define NFC_RAM_METHOD BIT(14)
82#define NFC_DEBUG_CTL BIT(31)
83
84
85#define NFC_RB_B2R BIT(0)
86#define NFC_CMD_INT_FLAG BIT(1)
87#define NFC_DMA_INT_FLAG BIT(2)
88#define NFC_CMD_FIFO_STATUS BIT(3)
89#define NFC_STA BIT(4)
90#define NFC_NATCH_INT_FLAG BIT(5)
91#define NFC_RB_STATE(x) BIT(x + 8)
92
93
94#define NFC_B2R_INT_ENABLE BIT(0)
95#define NFC_CMD_INT_ENABLE BIT(1)
96#define NFC_DMA_INT_ENABLE BIT(2)
97#define NFC_INT_MASK (NFC_B2R_INT_ENABLE | \
98 NFC_CMD_INT_ENABLE | \
99 NFC_DMA_INT_ENABLE)
100
101
102#define NFC_TIMING_CTL_EDO BIT(8)
103
104
105#define NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD) \
106 (((tWB) & 0x3) | (((tADL) & 0x3) << 2) | \
107 (((tWHR) & 0x3) << 4) | (((tRHW) & 0x3) << 6) | \
108 (((tCAD) & 0x7) << 8))
109
110
111#define NFC_CMD_LOW_BYTE_MSK 0xff
112#define NFC_CMD_HIGH_BYTE_MSK (0xff << 8)
113#define NFC_CMD(x) (x)
114#define NFC_ADR_NUM_MSK (0x7 << 16)
115#define NFC_ADR_NUM(x) (((x) - 1) << 16)
116#define NFC_SEND_ADR BIT(19)
117#define NFC_ACCESS_DIR BIT(20)
118#define NFC_DATA_TRANS BIT(21)
119#define NFC_SEND_CMD1 BIT(22)
120#define NFC_WAIT_FLAG BIT(23)
121#define NFC_SEND_CMD2 BIT(24)
122#define NFC_SEQ BIT(25)
123#define NFC_DATA_SWAP_METHOD BIT(26)
124#define NFC_ROW_AUTO_INC BIT(27)
125#define NFC_SEND_CMD3 BIT(28)
126#define NFC_SEND_CMD4 BIT(29)
127#define NFC_CMD_TYPE_MSK (0x3 << 30)
128#define NFC_NORMAL_OP (0 << 30)
129#define NFC_ECC_OP (1 << 30)
130#define NFC_PAGE_OP (2 << 30)
131
132
133#define NFC_READ_CMD_MSK 0xff
134#define NFC_RND_READ_CMD0_MSK (0xff << 8)
135#define NFC_RND_READ_CMD1_MSK (0xff << 16)
136
137
138#define NFC_PROGRAM_CMD_MSK 0xff
139#define NFC_RND_WRITE_CMD_MSK (0xff << 8)
140#define NFC_READ_CMD0_MSK (0xff << 16)
141#define NFC_READ_CMD1_MSK (0xff << 24)
142
143
144#define NFC_ECC_EN BIT(0)
145#define NFC_ECC_PIPELINE BIT(3)
146#define NFC_ECC_EXCEPTION BIT(4)
147#define NFC_ECC_BLOCK_SIZE_MSK BIT(5)
148#define NFC_ECC_BLOCK_512 (1 << 5)
149#define NFC_RANDOM_EN BIT(9)
150#define NFC_RANDOM_DIRECTION BIT(10)
151#define NFC_ECC_MODE_MSK (0xf << 12)
152#define NFC_ECC_MODE(x) ((x) << 12)
153#define NFC_RANDOM_SEED_MSK (0x7fff << 16)
154#define NFC_RANDOM_SEED(x) ((x) << 16)
155
156
157#define NFC_ECC_ERR(x) BIT(x)
158#define NFC_ECC_PAT_FOUND(x) BIT(x + 16)
159#define NFC_ECC_ERR_CNT(b, x) (((x) >> ((b) * 8)) & 0xff)
160
161#define NFC_DEFAULT_TIMEOUT_MS 1000
162
163#define NFC_SRAM_SIZE 1024
164
165#define NFC_MAX_CS 7
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180enum sunxi_nand_rb_type {
181 RB_NONE,
182 RB_NATIVE,
183 RB_GPIO,
184};
185
186
187
188
189
190
191
192
193struct sunxi_nand_rb {
194 enum sunxi_nand_rb_type type;
195 union {
196 struct gpio_desc gpio;
197 int nativeid;
198 } info;
199};
200
201
202
203
204
205
206
207struct sunxi_nand_chip_sel {
208 u8 cs;
209 struct sunxi_nand_rb rb;
210};
211
212
213
214
215
216
217
218
219struct sunxi_nand_hw_ecc {
220 int mode;
221 struct nand_ecclayout layout;
222};
223
224
225
226
227
228
229
230
231
232
233
234
235
236struct sunxi_nand_chip {
237 struct list_head node;
238 struct nand_chip nand;
239 unsigned long clk_rate;
240 u32 timing_cfg;
241 u32 timing_ctl;
242 int selected;
243 int addr_cycles;
244 u32 addr[2];
245 int cmd_cycles;
246 u8 cmd[2];
247 int nsels;
248 struct sunxi_nand_chip_sel sels[0];
249};
250
251static inline struct sunxi_nand_chip *to_sunxi_nand(struct nand_chip *nand)
252{
253 return container_of(nand, struct sunxi_nand_chip, nand);
254}
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271struct sunxi_nfc {
272 struct nand_hw_control controller;
273 struct device *dev;
274 void __iomem *regs;
275 struct clk *ahb_clk;
276 struct clk *mod_clk;
277 unsigned long assigned_cs;
278 unsigned long clk_rate;
279 struct list_head chips;
280};
281
282static inline struct sunxi_nfc *to_sunxi_nfc(struct nand_hw_control *ctrl)
283{
284 return container_of(ctrl, struct sunxi_nfc, controller);
285}
286
287static void sunxi_nfc_set_clk_rate(unsigned long hz)
288{
289 struct sunxi_ccm_reg *const ccm =
290 (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
291 int div_m, div_n;
292
293 div_m = (clock_get_pll6() + hz - 1) / hz;
294 for (div_n = 0; div_n < 3 && div_m > 16; div_n++) {
295 if (div_m % 2)
296 div_m++;
297 div_m >>= 1;
298 }
299 if (div_m > 16)
300 div_m = 16;
301
302
303 writel(CCM_NAND_CTRL_ENABLE | CCM_NAND_CTRL_PLL6 |
304 CCM_NAND_CTRL_N(div_n) | CCM_NAND_CTRL_M(div_m),
305 &ccm->nand0_clk_cfg);
306
307
308 setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_NAND0));
309#ifdef CONFIG_MACH_SUN9I
310 setbits_le32(&ccm->ahb_gate1, (1 << AHB_GATE_OFFSET_DMA));
311#else
312 setbits_le32(&ccm->ahb_gate0, (1 << AHB_GATE_OFFSET_DMA));
313#endif
314}
315
316static int sunxi_nfc_wait_int(struct sunxi_nfc *nfc, u32 flags,
317 unsigned int timeout_ms)
318{
319 unsigned int timeout_ticks;
320 u32 time_start, status;
321 int ret = -ETIMEDOUT;
322
323 if (!timeout_ms)
324 timeout_ms = NFC_DEFAULT_TIMEOUT_MS;
325
326 timeout_ticks = (timeout_ms * CONFIG_SYS_HZ) / 1000;
327
328 time_start = get_timer(0);
329
330 do {
331 status = readl(nfc->regs + NFC_REG_ST);
332 if ((status & flags) == flags) {
333 ret = 0;
334 break;
335 }
336
337 udelay(1);
338 } while (get_timer(time_start) < timeout_ticks);
339
340 writel(status & flags, nfc->regs + NFC_REG_ST);
341
342 return ret;
343}
344
345static int sunxi_nfc_wait_cmd_fifo_empty(struct sunxi_nfc *nfc)
346{
347 unsigned long timeout = (CONFIG_SYS_HZ *
348 NFC_DEFAULT_TIMEOUT_MS) / 1000;
349 u32 time_start;
350
351 time_start = get_timer(0);
352 do {
353 if (!(readl(nfc->regs + NFC_REG_ST) & NFC_CMD_FIFO_STATUS))
354 return 0;
355 } while (get_timer(time_start) < timeout);
356
357 dev_err(nfc->dev, "wait for empty cmd FIFO timedout\n");
358 return -ETIMEDOUT;
359}
360
361static int sunxi_nfc_rst(struct sunxi_nfc *nfc)
362{
363 unsigned long timeout = (CONFIG_SYS_HZ *
364 NFC_DEFAULT_TIMEOUT_MS) / 1000;
365 u32 time_start;
366
367 writel(0, nfc->regs + NFC_REG_ECC_CTL);
368 writel(NFC_RESET, nfc->regs + NFC_REG_CTL);
369
370 time_start = get_timer(0);
371 do {
372 if (!(readl(nfc->regs + NFC_REG_CTL) & NFC_RESET))
373 return 0;
374 } while (get_timer(time_start) < timeout);
375
376 dev_err(nfc->dev, "wait for NAND controller reset timedout\n");
377 return -ETIMEDOUT;
378}
379
380static int sunxi_nfc_dev_ready(struct mtd_info *mtd)
381{
382 struct nand_chip *nand = mtd_to_nand(mtd);
383 struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
384 struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
385 struct sunxi_nand_rb *rb;
386 unsigned long timeo = (sunxi_nand->nand.state == FL_ERASING ? 400 : 20);
387 int ret;
388
389 if (sunxi_nand->selected < 0)
390 return 0;
391
392 rb = &sunxi_nand->sels[sunxi_nand->selected].rb;
393
394 switch (rb->type) {
395 case RB_NATIVE:
396 ret = !!(readl(nfc->regs + NFC_REG_ST) &
397 NFC_RB_STATE(rb->info.nativeid));
398 if (ret)
399 break;
400
401 sunxi_nfc_wait_int(nfc, NFC_RB_B2R, timeo);
402 ret = !!(readl(nfc->regs + NFC_REG_ST) &
403 NFC_RB_STATE(rb->info.nativeid));
404 break;
405 case RB_GPIO:
406 ret = dm_gpio_get_value(&rb->info.gpio);
407 break;
408 case RB_NONE:
409 default:
410 ret = 0;
411 dev_err(nfc->dev, "cannot check R/B NAND status!\n");
412 break;
413 }
414
415 return ret;
416}
417
418static void sunxi_nfc_select_chip(struct mtd_info *mtd, int chip)
419{
420 struct nand_chip *nand = mtd_to_nand(mtd);
421 struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
422 struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
423 struct sunxi_nand_chip_sel *sel;
424 u32 ctl;
425
426 if (chip > 0 && chip >= sunxi_nand->nsels)
427 return;
428
429 if (chip == sunxi_nand->selected)
430 return;
431
432 ctl = readl(nfc->regs + NFC_REG_CTL) &
433 ~(NFC_PAGE_SHIFT_MSK | NFC_CE_SEL_MSK | NFC_RB_SEL_MSK | NFC_EN);
434
435 if (chip >= 0) {
436 sel = &sunxi_nand->sels[chip];
437
438 ctl |= NFC_CE_SEL(sel->cs) | NFC_EN |
439 NFC_PAGE_SHIFT(nand->page_shift - 10);
440 if (sel->rb.type == RB_NONE) {
441 nand->dev_ready = NULL;
442 } else {
443 nand->dev_ready = sunxi_nfc_dev_ready;
444 if (sel->rb.type == RB_NATIVE)
445 ctl |= NFC_RB_SEL(sel->rb.info.nativeid);
446 }
447
448 writel(mtd->writesize, nfc->regs + NFC_REG_SPARE_AREA);
449
450 if (nfc->clk_rate != sunxi_nand->clk_rate) {
451 sunxi_nfc_set_clk_rate(sunxi_nand->clk_rate);
452 nfc->clk_rate = sunxi_nand->clk_rate;
453 }
454 }
455
456 writel(sunxi_nand->timing_ctl, nfc->regs + NFC_REG_TIMING_CTL);
457 writel(sunxi_nand->timing_cfg, nfc->regs + NFC_REG_TIMING_CFG);
458 writel(ctl, nfc->regs + NFC_REG_CTL);
459
460 sunxi_nand->selected = chip;
461}
462
463static void sunxi_nfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
464{
465 struct nand_chip *nand = mtd_to_nand(mtd);
466 struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
467 struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
468 int ret;
469 int cnt;
470 int offs = 0;
471 u32 tmp;
472
473 while (len > offs) {
474 cnt = min(len - offs, NFC_SRAM_SIZE);
475
476 ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
477 if (ret)
478 break;
479
480 writel(cnt, nfc->regs + NFC_REG_CNT);
481 tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD;
482 writel(tmp, nfc->regs + NFC_REG_CMD);
483
484 ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0);
485 if (ret)
486 break;
487
488 if (buf)
489 memcpy_fromio(buf + offs, nfc->regs + NFC_RAM0_BASE,
490 cnt);
491 offs += cnt;
492 }
493}
494
495static void sunxi_nfc_write_buf(struct mtd_info *mtd, const uint8_t *buf,
496 int len)
497{
498 struct nand_chip *nand = mtd_to_nand(mtd);
499 struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
500 struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
501 int ret;
502 int cnt;
503 int offs = 0;
504 u32 tmp;
505
506 while (len > offs) {
507 cnt = min(len - offs, NFC_SRAM_SIZE);
508
509 ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
510 if (ret)
511 break;
512
513 writel(cnt, nfc->regs + NFC_REG_CNT);
514 memcpy_toio(nfc->regs + NFC_RAM0_BASE, buf + offs, cnt);
515 tmp = NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD |
516 NFC_ACCESS_DIR;
517 writel(tmp, nfc->regs + NFC_REG_CMD);
518
519 ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0);
520 if (ret)
521 break;
522
523 offs += cnt;
524 }
525}
526
527static uint8_t sunxi_nfc_read_byte(struct mtd_info *mtd)
528{
529 uint8_t ret;
530
531 sunxi_nfc_read_buf(mtd, &ret, 1);
532
533 return ret;
534}
535
536static void sunxi_nfc_cmd_ctrl(struct mtd_info *mtd, int dat,
537 unsigned int ctrl)
538{
539 struct nand_chip *nand = mtd_to_nand(mtd);
540 struct sunxi_nand_chip *sunxi_nand = to_sunxi_nand(nand);
541 struct sunxi_nfc *nfc = to_sunxi_nfc(sunxi_nand->nand.controller);
542 int ret;
543 u32 tmp;
544
545 ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
546 if (ret)
547 return;
548
549 if (ctrl & NAND_CTRL_CHANGE) {
550 tmp = readl(nfc->regs + NFC_REG_CTL);
551 if (ctrl & NAND_NCE)
552 tmp |= NFC_CE_CTL;
553 else
554 tmp &= ~NFC_CE_CTL;
555 writel(tmp, nfc->regs + NFC_REG_CTL);
556 }
557
558 if (dat == NAND_CMD_NONE && (ctrl & NAND_NCE) &&
559 !(ctrl & (NAND_CLE | NAND_ALE))) {
560 u32 cmd = 0;
561
562 if (!sunxi_nand->addr_cycles && !sunxi_nand->cmd_cycles)
563 return;
564
565 if (sunxi_nand->cmd_cycles--)
566 cmd |= NFC_SEND_CMD1 | sunxi_nand->cmd[0];
567
568 if (sunxi_nand->cmd_cycles--) {
569 cmd |= NFC_SEND_CMD2;
570 writel(sunxi_nand->cmd[1],
571 nfc->regs + NFC_REG_RCMD_SET);
572 }
573
574 sunxi_nand->cmd_cycles = 0;
575
576 if (sunxi_nand->addr_cycles) {
577 cmd |= NFC_SEND_ADR |
578 NFC_ADR_NUM(sunxi_nand->addr_cycles);
579 writel(sunxi_nand->addr[0],
580 nfc->regs + NFC_REG_ADDR_LOW);
581 }
582
583 if (sunxi_nand->addr_cycles > 4)
584 writel(sunxi_nand->addr[1],
585 nfc->regs + NFC_REG_ADDR_HIGH);
586
587 writel(cmd, nfc->regs + NFC_REG_CMD);
588 sunxi_nand->addr[0] = 0;
589 sunxi_nand->addr[1] = 0;
590 sunxi_nand->addr_cycles = 0;
591 sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0);
592 }
593
594 if (ctrl & NAND_CLE) {
595 sunxi_nand->cmd[sunxi_nand->cmd_cycles++] = dat;
596 } else if (ctrl & NAND_ALE) {
597 sunxi_nand->addr[sunxi_nand->addr_cycles / 4] |=
598 dat << ((sunxi_nand->addr_cycles % 4) * 8);
599 sunxi_nand->addr_cycles++;
600 }
601}
602
603
604static const u16 sunxi_nfc_randomizer_page_seeds[] = {
605 0x2b75, 0x0bd0, 0x5ca3, 0x62d1, 0x1c93, 0x07e9, 0x2162, 0x3a72,
606 0x0d67, 0x67f9, 0x1be7, 0x077d, 0x032f, 0x0dac, 0x2716, 0x2436,
607 0x7922, 0x1510, 0x3860, 0x5287, 0x480f, 0x4252, 0x1789, 0x5a2d,
608 0x2a49, 0x5e10, 0x437f, 0x4b4e, 0x2f45, 0x216e, 0x5cb7, 0x7130,
609 0x2a3f, 0x60e4, 0x4dc9, 0x0ef0, 0x0f52, 0x1bb9, 0x6211, 0x7a56,
610 0x226d, 0x4ea7, 0x6f36, 0x3692, 0x38bf, 0x0c62, 0x05eb, 0x4c55,
611 0x60f4, 0x728c, 0x3b6f, 0x2037, 0x7f69, 0x0936, 0x651a, 0x4ceb,
612 0x6218, 0x79f3, 0x383f, 0x18d9, 0x4f05, 0x5c82, 0x2912, 0x6f17,
613 0x6856, 0x5938, 0x1007, 0x61ab, 0x3e7f, 0x57c2, 0x542f, 0x4f62,
614 0x7454, 0x2eac, 0x7739, 0x42d4, 0x2f90, 0x435a, 0x2e52, 0x2064,
615 0x637c, 0x66ad, 0x2c90, 0x0bad, 0x759c, 0x0029, 0x0986, 0x7126,
616 0x1ca7, 0x1605, 0x386a, 0x27f5, 0x1380, 0x6d75, 0x24c3, 0x0f8e,
617 0x2b7a, 0x1418, 0x1fd1, 0x7dc1, 0x2d8e, 0x43af, 0x2267, 0x7da3,
618 0x4e3d, 0x1338, 0x50db, 0x454d, 0x764d, 0x40a3, 0x42e6, 0x262b,
619 0x2d2e, 0x1aea, 0x2e17, 0x173d, 0x3a6e, 0x71bf, 0x25f9, 0x0a5d,
620 0x7c57, 0x0fbe, 0x46ce, 0x4939, 0x6b17, 0x37bb, 0x3e91, 0x76db,
621};
622
623
624
625
626
627
628
629
630
631
632static const u16 sunxi_nfc_randomizer_ecc512_seeds[] = {
633 0x3346, 0x367f, 0x1f18, 0x769a, 0x4f64, 0x068c, 0x2ef1, 0x6b64,
634 0x28a9, 0x15d7, 0x30f8, 0x3659, 0x53db, 0x7c5f, 0x71d4, 0x4409,
635 0x26eb, 0x03cc, 0x655d, 0x47d4, 0x4daa, 0x0877, 0x712d, 0x3617,
636 0x3264, 0x49aa, 0x7f9e, 0x588e, 0x4fbc, 0x7176, 0x7f91, 0x6c6d,
637 0x4b95, 0x5fb7, 0x3844, 0x4037, 0x0184, 0x081b, 0x0ee8, 0x5b91,
638 0x293d, 0x1f71, 0x0e6f, 0x402b, 0x5122, 0x1e52, 0x22be, 0x3d2d,
639 0x75bc, 0x7c60, 0x6291, 0x1a2f, 0x61d4, 0x74aa, 0x4140, 0x29ab,
640 0x472d, 0x2852, 0x017e, 0x15e8, 0x5ec2, 0x17cf, 0x7d0f, 0x06b8,
641 0x117a, 0x6b94, 0x789b, 0x3126, 0x6ac5, 0x5be7, 0x150f, 0x51f8,
642 0x7889, 0x0aa5, 0x663d, 0x77e8, 0x0b87, 0x3dcb, 0x360d, 0x218b,
643 0x512f, 0x7dc9, 0x6a4d, 0x630a, 0x3547, 0x1dd2, 0x5aea, 0x69a5,
644 0x7bfa, 0x5e4f, 0x1519, 0x6430, 0x3a0e, 0x5eb3, 0x5425, 0x0c7a,
645 0x5540, 0x3670, 0x63c1, 0x31e9, 0x5a39, 0x2de7, 0x5979, 0x2891,
646 0x1562, 0x014b, 0x5b05, 0x2756, 0x5a34, 0x13aa, 0x6cb5, 0x2c36,
647 0x5e72, 0x1306, 0x0861, 0x15ef, 0x1ee8, 0x5a37, 0x7ac4, 0x45dd,
648 0x44c4, 0x7266, 0x2f41, 0x3ccc, 0x045e, 0x7d40, 0x7c66, 0x0fa0,
649};
650
651static const u16 sunxi_nfc_randomizer_ecc1024_seeds[] = {
652 0x2cf5, 0x35f1, 0x63a4, 0x5274, 0x2bd2, 0x778b, 0x7285, 0x32b6,
653 0x6a5c, 0x70d6, 0x757d, 0x6769, 0x5375, 0x1e81, 0x0cf3, 0x3982,
654 0x6787, 0x042a, 0x6c49, 0x1925, 0x56a8, 0x40a9, 0x063e, 0x7bd9,
655 0x4dbf, 0x55ec, 0x672e, 0x7334, 0x5185, 0x4d00, 0x232a, 0x7e07,
656 0x445d, 0x6b92, 0x528f, 0x4255, 0x53ba, 0x7d82, 0x2a2e, 0x3a4e,
657 0x75eb, 0x450c, 0x6844, 0x1b5d, 0x581a, 0x4cc6, 0x0379, 0x37b2,
658 0x419f, 0x0e92, 0x6b27, 0x5624, 0x01e3, 0x07c1, 0x44a5, 0x130c,
659 0x13e8, 0x5910, 0x0876, 0x60c5, 0x54e3, 0x5b7f, 0x2269, 0x509f,
660 0x7665, 0x36fd, 0x3e9a, 0x0579, 0x6295, 0x14ef, 0x0a81, 0x1bcc,
661 0x4b16, 0x64db, 0x0514, 0x4f07, 0x0591, 0x3576, 0x6853, 0x0d9e,
662 0x259f, 0x38b7, 0x64fb, 0x3094, 0x4693, 0x6ddd, 0x29bb, 0x0bc8,
663 0x3f47, 0x490e, 0x0c0e, 0x7933, 0x3c9e, 0x5840, 0x398d, 0x3e68,
664 0x4af1, 0x71f5, 0x57cf, 0x1121, 0x64eb, 0x3579, 0x15ac, 0x584d,
665 0x5f2a, 0x47e2, 0x6528, 0x6eac, 0x196e, 0x6b96, 0x0450, 0x0179,
666 0x609c, 0x06e1, 0x4626, 0x42c7, 0x273e, 0x486f, 0x0705, 0x1601,
667 0x145b, 0x407e, 0x062b, 0x57a5, 0x53f9, 0x5659, 0x4410, 0x3ccd,
668};
669
670static u16 sunxi_nfc_randomizer_step(u16 state, int count)
671{
672 state &= 0x7fff;
673
674
675
676
677
678 while (count--)
679 state = ((state >> 1) |
680 (((state ^ (state >> 1)) & 1) << 14)) & 0x7fff;
681
682 return state;
683}
684
685static u16 sunxi_nfc_randomizer_state(struct mtd_info *mtd, int page, bool ecc)
686{
687 const u16 *seeds = sunxi_nfc_randomizer_page_seeds;
688 int mod = mtd->erasesize / mtd->writesize;
689
690 if (mod > ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds))
691 mod = ARRAY_SIZE(sunxi_nfc_randomizer_page_seeds);
692
693 if (ecc) {
694 if (mtd->ecc_step_size == 512)
695 seeds = sunxi_nfc_randomizer_ecc512_seeds;
696 else
697 seeds = sunxi_nfc_randomizer_ecc1024_seeds;
698 }
699
700 return seeds[page % mod];
701}
702
703static void sunxi_nfc_randomizer_config(struct mtd_info *mtd,
704 int page, bool ecc)
705{
706 struct nand_chip *nand = mtd_to_nand(mtd);
707 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
708 u32 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL);
709 u16 state;
710
711 if (!(nand->options & NAND_NEED_SCRAMBLING))
712 return;
713
714 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL);
715 state = sunxi_nfc_randomizer_state(mtd, page, ecc);
716 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_SEED_MSK;
717 writel(ecc_ctl | NFC_RANDOM_SEED(state), nfc->regs + NFC_REG_ECC_CTL);
718}
719
720static void sunxi_nfc_randomizer_enable(struct mtd_info *mtd)
721{
722 struct nand_chip *nand = mtd_to_nand(mtd);
723 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
724
725 if (!(nand->options & NAND_NEED_SCRAMBLING))
726 return;
727
728 writel(readl(nfc->regs + NFC_REG_ECC_CTL) | NFC_RANDOM_EN,
729 nfc->regs + NFC_REG_ECC_CTL);
730}
731
732static void sunxi_nfc_randomizer_disable(struct mtd_info *mtd)
733{
734 struct nand_chip *nand = mtd_to_nand(mtd);
735 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
736
737 if (!(nand->options & NAND_NEED_SCRAMBLING))
738 return;
739
740 writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_RANDOM_EN,
741 nfc->regs + NFC_REG_ECC_CTL);
742}
743
744static void sunxi_nfc_randomize_bbm(struct mtd_info *mtd, int page, u8 *bbm)
745{
746 u16 state = sunxi_nfc_randomizer_state(mtd, page, true);
747
748 bbm[0] ^= state;
749 bbm[1] ^= sunxi_nfc_randomizer_step(state, 8);
750}
751
752static void sunxi_nfc_randomizer_write_buf(struct mtd_info *mtd,
753 const uint8_t *buf, int len,
754 bool ecc, int page)
755{
756 sunxi_nfc_randomizer_config(mtd, page, ecc);
757 sunxi_nfc_randomizer_enable(mtd);
758 sunxi_nfc_write_buf(mtd, buf, len);
759 sunxi_nfc_randomizer_disable(mtd);
760}
761
762static void sunxi_nfc_randomizer_read_buf(struct mtd_info *mtd, uint8_t *buf,
763 int len, bool ecc, int page)
764{
765 sunxi_nfc_randomizer_config(mtd, page, ecc);
766 sunxi_nfc_randomizer_enable(mtd);
767 sunxi_nfc_read_buf(mtd, buf, len);
768 sunxi_nfc_randomizer_disable(mtd);
769}
770
771static void sunxi_nfc_hw_ecc_enable(struct mtd_info *mtd)
772{
773 struct nand_chip *nand = mtd_to_nand(mtd);
774 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
775 struct sunxi_nand_hw_ecc *data = nand->ecc.priv;
776 u32 ecc_ctl;
777
778 ecc_ctl = readl(nfc->regs + NFC_REG_ECC_CTL);
779 ecc_ctl &= ~(NFC_ECC_MODE_MSK | NFC_ECC_PIPELINE |
780 NFC_ECC_BLOCK_SIZE_MSK);
781 ecc_ctl |= NFC_ECC_EN | NFC_ECC_MODE(data->mode) | NFC_ECC_EXCEPTION;
782
783 if (nand->ecc.size == 512)
784 ecc_ctl |= NFC_ECC_BLOCK_512;
785
786 writel(ecc_ctl, nfc->regs + NFC_REG_ECC_CTL);
787}
788
789static void sunxi_nfc_hw_ecc_disable(struct mtd_info *mtd)
790{
791 struct nand_chip *nand = mtd_to_nand(mtd);
792 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
793
794 writel(readl(nfc->regs + NFC_REG_ECC_CTL) & ~NFC_ECC_EN,
795 nfc->regs + NFC_REG_ECC_CTL);
796}
797
798static inline void sunxi_nfc_user_data_to_buf(u32 user_data, u8 *buf)
799{
800 buf[0] = user_data;
801 buf[1] = user_data >> 8;
802 buf[2] = user_data >> 16;
803 buf[3] = user_data >> 24;
804}
805
806static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info *mtd,
807 u8 *data, int data_off,
808 u8 *oob, int oob_off,
809 int *cur_off,
810 unsigned int *max_bitflips,
811 bool bbm, int page)
812{
813 struct nand_chip *nand = mtd_to_nand(mtd);
814 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
815 struct nand_ecc_ctrl *ecc = &nand->ecc;
816 int raw_mode = 0;
817 u32 status;
818 int ret;
819
820 if (*cur_off != data_off)
821 nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1);
822
823 sunxi_nfc_randomizer_read_buf(mtd, NULL, ecc->size, false, page);
824
825 if (data_off + ecc->size != oob_off)
826 nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
827
828 ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
829 if (ret)
830 return ret;
831
832 sunxi_nfc_randomizer_enable(mtd);
833 writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD | NFC_ECC_OP,
834 nfc->regs + NFC_REG_CMD);
835
836 ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0);
837 sunxi_nfc_randomizer_disable(mtd);
838 if (ret)
839 return ret;
840
841 *cur_off = oob_off + ecc->bytes + 4;
842
843 status = readl(nfc->regs + NFC_REG_ECC_ST);
844 if (status & NFC_ECC_PAT_FOUND(0)) {
845 u8 pattern = 0xff;
846
847 if (unlikely(!(readl(nfc->regs + NFC_REG_PAT_ID) & 0x1)))
848 pattern = 0x0;
849
850 memset(data, pattern, ecc->size);
851 memset(oob, pattern, ecc->bytes + 4);
852
853 return 1;
854 }
855
856 ret = NFC_ECC_ERR_CNT(0, readl(nfc->regs + NFC_REG_ECC_ERR_CNT(0)));
857
858 memcpy_fromio(data, nfc->regs + NFC_RAM0_BASE, ecc->size);
859
860 nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
861 sunxi_nfc_randomizer_read_buf(mtd, oob, ecc->bytes + 4, true, page);
862
863 if (status & NFC_ECC_ERR(0)) {
864
865
866
867
868 if (nand->options & NAND_NEED_SCRAMBLING) {
869 nand->cmdfunc(mtd, NAND_CMD_RNDOUT, data_off, -1);
870 nand->read_buf(mtd, data, ecc->size);
871 nand->cmdfunc(mtd, NAND_CMD_RNDOUT, oob_off, -1);
872 nand->read_buf(mtd, oob, ecc->bytes + 4);
873 }
874
875 ret = nand_check_erased_ecc_chunk(data, ecc->size,
876 oob, ecc->bytes + 4,
877 NULL, 0, ecc->strength);
878 if (ret >= 0)
879 raw_mode = 1;
880 } else {
881
882
883
884
885 sunxi_nfc_user_data_to_buf(readl(nfc->regs +
886 NFC_REG_USER_DATA(0)),
887 oob);
888
889
890 if (bbm && nand->options & NAND_NEED_SCRAMBLING)
891 sunxi_nfc_randomize_bbm(mtd, page, oob);
892 }
893
894 if (ret < 0) {
895 mtd->ecc_stats.failed++;
896 } else {
897 mtd->ecc_stats.corrected += ret;
898 *max_bitflips = max_t(unsigned int, *max_bitflips, ret);
899 }
900
901 return raw_mode;
902}
903
904static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info *mtd,
905 u8 *oob, int *cur_off,
906 bool randomize, int page)
907{
908 struct nand_chip *nand = mtd_to_nand(mtd);
909 struct nand_ecc_ctrl *ecc = &nand->ecc;
910 int offset = ((ecc->bytes + 4) * ecc->steps);
911 int len = mtd->oobsize - offset;
912
913 if (len <= 0)
914 return;
915
916 if (*cur_off != offset)
917 nand->cmdfunc(mtd, NAND_CMD_RNDOUT,
918 offset + mtd->writesize, -1);
919
920 if (!randomize)
921 sunxi_nfc_read_buf(mtd, oob + offset, len);
922 else
923 sunxi_nfc_randomizer_read_buf(mtd, oob + offset, len,
924 false, page);
925
926 *cur_off = mtd->oobsize + mtd->writesize;
927}
928
929static inline u32 sunxi_nfc_buf_to_user_data(const u8 *buf)
930{
931 return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
932}
933
934static int sunxi_nfc_hw_ecc_write_chunk(struct mtd_info *mtd,
935 const u8 *data, int data_off,
936 const u8 *oob, int oob_off,
937 int *cur_off, bool bbm,
938 int page)
939{
940 struct nand_chip *nand = mtd_to_nand(mtd);
941 struct sunxi_nfc *nfc = to_sunxi_nfc(nand->controller);
942 struct nand_ecc_ctrl *ecc = &nand->ecc;
943 int ret;
944
945 if (data_off != *cur_off)
946 nand->cmdfunc(mtd, NAND_CMD_RNDIN, data_off, -1);
947
948 sunxi_nfc_randomizer_write_buf(mtd, data, ecc->size, false, page);
949
950
951 if ((nand->options & NAND_NEED_SCRAMBLING) && bbm) {
952 u8 user_data[4];
953
954 memcpy(user_data, oob, 4);
955 sunxi_nfc_randomize_bbm(mtd, page, user_data);
956 writel(sunxi_nfc_buf_to_user_data(user_data),
957 nfc->regs + NFC_REG_USER_DATA(0));
958 } else {
959 writel(sunxi_nfc_buf_to_user_data(oob),
960 nfc->regs + NFC_REG_USER_DATA(0));
961 }
962
963 if (data_off + ecc->size != oob_off)
964 nand->cmdfunc(mtd, NAND_CMD_RNDIN, oob_off, -1);
965
966 ret = sunxi_nfc_wait_cmd_fifo_empty(nfc);
967 if (ret)
968 return ret;
969
970 sunxi_nfc_randomizer_enable(mtd);
971 writel(NFC_DATA_TRANS | NFC_DATA_SWAP_METHOD |
972 NFC_ACCESS_DIR | NFC_ECC_OP,
973 nfc->regs + NFC_REG_CMD);
974
975 ret = sunxi_nfc_wait_int(nfc, NFC_CMD_INT_FLAG, 0);
976 sunxi_nfc_randomizer_disable(mtd);
977 if (ret)
978 return ret;
979
980 *cur_off = oob_off + ecc->bytes + 4;
981
982 return 0;
983}
984
985static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info *mtd,
986 u8 *oob, int *cur_off,
987 int page)
988{
989 struct nand_chip *nand = mtd_to_nand(mtd);
990 struct nand_ecc_ctrl *ecc = &nand->ecc;
991 int offset = ((ecc->bytes + 4) * ecc->steps);
992 int len = mtd->oobsize - offset;
993
994 if (len <= 0)
995 return;
996
997 if (*cur_off != offset)
998 nand->cmdfunc(mtd, NAND_CMD_RNDIN,
999 offset + mtd->writesize, -1);
1000
1001 sunxi_nfc_randomizer_write_buf(mtd, oob + offset, len, false, page);
1002
1003 *cur_off = mtd->oobsize + mtd->writesize;
1004}
1005
1006static int sunxi_nfc_hw_ecc_read_page(struct mtd_info *mtd,
1007 struct nand_chip *chip, uint8_t *buf,
1008 int oob_required, int page)
1009{
1010 struct nand_ecc_ctrl *ecc = &chip->ecc;
1011 unsigned int max_bitflips = 0;
1012 int ret, i, cur_off = 0;
1013 bool raw_mode = false;
1014
1015 sunxi_nfc_hw_ecc_enable(mtd);
1016
1017 for (i = 0; i < ecc->steps; i++) {
1018 int data_off = i * ecc->size;
1019 int oob_off = i * (ecc->bytes + 4);
1020 u8 *data = buf + data_off;
1021 u8 *oob = chip->oob_poi + oob_off;
1022
1023 ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob,
1024 oob_off + mtd->writesize,
1025 &cur_off, &max_bitflips,
1026 !i, page);
1027 if (ret < 0)
1028 return ret;
1029 else if (ret)
1030 raw_mode = true;
1031 }
1032
1033 if (oob_required)
1034 sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off,
1035 !raw_mode, page);
1036
1037 sunxi_nfc_hw_ecc_disable(mtd);
1038
1039 return max_bitflips;
1040}
1041
1042static int sunxi_nfc_hw_ecc_read_subpage(struct mtd_info *mtd,
1043 struct nand_chip *chip,
1044 uint32_t data_offs, uint32_t readlen,
1045 uint8_t *bufpoi, int page)
1046{
1047 struct nand_ecc_ctrl *ecc = &chip->ecc;
1048 int ret, i, cur_off = 0;
1049 unsigned int max_bitflips = 0;
1050
1051 sunxi_nfc_hw_ecc_enable(mtd);
1052
1053 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
1054 for (i = data_offs / ecc->size;
1055 i < DIV_ROUND_UP(data_offs + readlen, ecc->size); i++) {
1056 int data_off = i * ecc->size;
1057 int oob_off = i * (ecc->bytes + 4);
1058 u8 *data = bufpoi + data_off;
1059 u8 *oob = chip->oob_poi + oob_off;
1060
1061 ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off,
1062 oob, oob_off + mtd->writesize,
1063 &cur_off, &max_bitflips, !i, page);
1064 if (ret < 0)
1065 return ret;
1066 }
1067
1068 sunxi_nfc_hw_ecc_disable(mtd);
1069
1070 return max_bitflips;
1071}
1072
1073static int sunxi_nfc_hw_ecc_write_page(struct mtd_info *mtd,
1074 struct nand_chip *chip,
1075 const uint8_t *buf, int oob_required,
1076 int page)
1077{
1078 struct nand_ecc_ctrl *ecc = &chip->ecc;
1079 int ret, i, cur_off = 0;
1080
1081 sunxi_nfc_hw_ecc_enable(mtd);
1082
1083 for (i = 0; i < ecc->steps; i++) {
1084 int data_off = i * ecc->size;
1085 int oob_off = i * (ecc->bytes + 4);
1086 const u8 *data = buf + data_off;
1087 const u8 *oob = chip->oob_poi + oob_off;
1088
1089 ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob,
1090 oob_off + mtd->writesize,
1091 &cur_off, !i, page);
1092 if (ret)
1093 return ret;
1094 }
1095
1096 if (oob_required || (chip->options & NAND_NEED_SCRAMBLING))
1097 sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi,
1098 &cur_off, page);
1099
1100 sunxi_nfc_hw_ecc_disable(mtd);
1101
1102 return 0;
1103}
1104
1105static int sunxi_nfc_hw_ecc_write_subpage(struct mtd_info *mtd,
1106 struct nand_chip *chip,
1107 u32 data_offs, u32 data_len,
1108 const u8 *buf, int oob_required,
1109 int page)
1110{
1111 struct nand_ecc_ctrl *ecc = &chip->ecc;
1112 int ret, i, cur_off = 0;
1113
1114 sunxi_nfc_hw_ecc_enable(mtd);
1115
1116 for (i = data_offs / ecc->size;
1117 i < DIV_ROUND_UP(data_offs + data_len, ecc->size); i++) {
1118 int data_off = i * ecc->size;
1119 int oob_off = i * (ecc->bytes + 4);
1120 const u8 *data = buf + data_off;
1121 const u8 *oob = chip->oob_poi + oob_off;
1122
1123 ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off, oob,
1124 oob_off + mtd->writesize,
1125 &cur_off, !i, page);
1126 if (ret)
1127 return ret;
1128 }
1129
1130 sunxi_nfc_hw_ecc_disable(mtd);
1131
1132 return 0;
1133}
1134
1135static int sunxi_nfc_hw_syndrome_ecc_read_page(struct mtd_info *mtd,
1136 struct nand_chip *chip,
1137 uint8_t *buf, int oob_required,
1138 int page)
1139{
1140 struct nand_ecc_ctrl *ecc = &chip->ecc;
1141 unsigned int max_bitflips = 0;
1142 int ret, i, cur_off = 0;
1143 bool raw_mode = false;
1144
1145 sunxi_nfc_hw_ecc_enable(mtd);
1146
1147 for (i = 0; i < ecc->steps; i++) {
1148 int data_off = i * (ecc->size + ecc->bytes + 4);
1149 int oob_off = data_off + ecc->size;
1150 u8 *data = buf + (i * ecc->size);
1151 u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4));
1152
1153 ret = sunxi_nfc_hw_ecc_read_chunk(mtd, data, data_off, oob,
1154 oob_off, &cur_off,
1155 &max_bitflips, !i, page);
1156 if (ret < 0)
1157 return ret;
1158 else if (ret)
1159 raw_mode = true;
1160 }
1161
1162 if (oob_required)
1163 sunxi_nfc_hw_ecc_read_extra_oob(mtd, chip->oob_poi, &cur_off,
1164 !raw_mode, page);
1165
1166 sunxi_nfc_hw_ecc_disable(mtd);
1167
1168 return max_bitflips;
1169}
1170
1171static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info *mtd,
1172 struct nand_chip *chip,
1173 const uint8_t *buf,
1174 int oob_required, int page)
1175{
1176 struct nand_ecc_ctrl *ecc = &chip->ecc;
1177 int ret, i, cur_off = 0;
1178
1179 sunxi_nfc_hw_ecc_enable(mtd);
1180
1181 for (i = 0; i < ecc->steps; i++) {
1182 int data_off = i * (ecc->size + ecc->bytes + 4);
1183 int oob_off = data_off + ecc->size;
1184 const u8 *data = buf + (i * ecc->size);
1185 const u8 *oob = chip->oob_poi + (i * (ecc->bytes + 4));
1186
1187 ret = sunxi_nfc_hw_ecc_write_chunk(mtd, data, data_off,
1188 oob, oob_off, &cur_off,
1189 false, page);
1190 if (ret)
1191 return ret;
1192 }
1193
1194 if (oob_required || (chip->options & NAND_NEED_SCRAMBLING))
1195 sunxi_nfc_hw_ecc_write_extra_oob(mtd, chip->oob_poi,
1196 &cur_off, page);
1197
1198 sunxi_nfc_hw_ecc_disable(mtd);
1199
1200 return 0;
1201}
1202
1203static const s32 tWB_lut[] = {6, 12, 16, 20};
1204static const s32 tRHW_lut[] = {4, 8, 12, 20};
1205
1206static int _sunxi_nand_lookup_timing(const s32 *lut, int lut_size, u32 duration,
1207 u32 clk_period)
1208{
1209 u32 clk_cycles = DIV_ROUND_UP(duration, clk_period);
1210 int i;
1211
1212 for (i = 0; i < lut_size; i++) {
1213 if (clk_cycles <= lut[i])
1214 return i;
1215 }
1216
1217
1218 return -EINVAL;
1219}
1220
1221#define sunxi_nand_lookup_timing(l, p, c) \
1222 _sunxi_nand_lookup_timing(l, ARRAY_SIZE(l), p, c)
1223
1224static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip *chip,
1225 const struct nand_sdr_timings *timings)
1226{
1227 u32 min_clk_period = 0;
1228 s32 tWB, tADL, tWHR, tRHW, tCAD;
1229
1230
1231 if (timings->tCLS_min > min_clk_period)
1232 min_clk_period = timings->tCLS_min;
1233
1234
1235 if (timings->tCLH_min > min_clk_period)
1236 min_clk_period = timings->tCLH_min;
1237
1238
1239 if (timings->tCS_min > min_clk_period)
1240 min_clk_period = timings->tCS_min;
1241
1242
1243 if (timings->tCH_min > min_clk_period)
1244 min_clk_period = timings->tCH_min;
1245
1246
1247 if (timings->tWP_min > min_clk_period)
1248 min_clk_period = timings->tWP_min;
1249
1250
1251 if (timings->tWH_min > min_clk_period)
1252 min_clk_period = timings->tWH_min;
1253
1254
1255 if (timings->tALS_min > min_clk_period)
1256 min_clk_period = timings->tALS_min;
1257
1258
1259 if (timings->tDS_min > min_clk_period)
1260 min_clk_period = timings->tDS_min;
1261
1262
1263 if (timings->tDH_min > min_clk_period)
1264 min_clk_period = timings->tDH_min;
1265
1266
1267 if (timings->tRR_min > (min_clk_period * 3))
1268 min_clk_period = DIV_ROUND_UP(timings->tRR_min, 3);
1269
1270
1271 if (timings->tALH_min > min_clk_period)
1272 min_clk_period = timings->tALH_min;
1273
1274
1275 if (timings->tRP_min > min_clk_period)
1276 min_clk_period = timings->tRP_min;
1277
1278
1279 if (timings->tREH_min > min_clk_period)
1280 min_clk_period = timings->tREH_min;
1281
1282
1283 if (timings->tRC_min > (min_clk_period * 2))
1284 min_clk_period = DIV_ROUND_UP(timings->tRC_min, 2);
1285
1286
1287 if (timings->tWC_min > (min_clk_period * 2))
1288 min_clk_period = DIV_ROUND_UP(timings->tWC_min, 2);
1289
1290
1291 tWB = sunxi_nand_lookup_timing(tWB_lut, timings->tWB_max,
1292 min_clk_period);
1293 if (tWB < 0) {
1294 dev_err(nfc->dev, "unsupported tWB\n");
1295 return tWB;
1296 }
1297
1298 tADL = DIV_ROUND_UP(timings->tADL_min, min_clk_period) >> 3;
1299 if (tADL > 3) {
1300 dev_err(nfc->dev, "unsupported tADL\n");
1301 return -EINVAL;
1302 }
1303
1304 tWHR = DIV_ROUND_UP(timings->tWHR_min, min_clk_period) >> 3;
1305 if (tWHR > 3) {
1306 dev_err(nfc->dev, "unsupported tWHR\n");
1307 return -EINVAL;
1308 }
1309
1310 tRHW = sunxi_nand_lookup_timing(tRHW_lut, timings->tRHW_min,
1311 min_clk_period);
1312 if (tRHW < 0) {
1313 dev_err(nfc->dev, "unsupported tRHW\n");
1314 return tRHW;
1315 }
1316
1317
1318
1319
1320
1321 tCAD = 0x7;
1322
1323
1324 chip->timing_cfg = NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD);
1325
1326
1327
1328
1329
1330
1331 chip->timing_ctl = (timings->tRC_min < 30000) ? NFC_TIMING_CTL_EDO : 0;
1332
1333
1334 min_clk_period = DIV_ROUND_UP(min_clk_period, 1000);
1335
1336
1337
1338
1339
1340
1341
1342 chip->clk_rate = 1000000000L / min_clk_period;
1343
1344 return 0;
1345}
1346
1347static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip *chip)
1348{
1349 struct mtd_info *mtd = nand_to_mtd(&chip->nand);
1350 const struct nand_sdr_timings *timings;
1351 int ret;
1352 int mode;
1353
1354 mode = onfi_get_async_timing_mode(&chip->nand);
1355 if (mode == ONFI_TIMING_MODE_UNKNOWN) {
1356 mode = chip->nand.onfi_timing_mode_default;
1357 } else {
1358 uint8_t feature[ONFI_SUBFEATURE_PARAM_LEN] = {};
1359 int i;
1360
1361 mode = fls(mode) - 1;
1362 if (mode < 0)
1363 mode = 0;
1364
1365 feature[0] = mode;
1366 for (i = 0; i < chip->nsels; i++) {
1367 chip->nand.select_chip(mtd, i);
1368 ret = chip->nand.onfi_set_features(mtd,
1369 &chip->nand,
1370 ONFI_FEATURE_ADDR_TIMING_MODE,
1371 feature);
1372 chip->nand.select_chip(mtd, -1);
1373 if (ret)
1374 return ret;
1375 }
1376 }
1377
1378 timings = onfi_async_timing_mode_to_sdr_timings(mode);
1379 if (IS_ERR(timings))
1380 return PTR_ERR(timings);
1381
1382 return sunxi_nand_chip_set_timings(chip, timings);
1383}
1384
1385static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info *mtd,
1386 struct nand_ecc_ctrl *ecc)
1387{
1388 static const u8 strengths[] = { 16, 24, 28, 32, 40, 48, 56, 60, 64 };
1389 struct sunxi_nand_hw_ecc *data;
1390 struct nand_ecclayout *layout;
1391 int nsectors;
1392 int ret;
1393 int i;
1394
1395 data = kzalloc(sizeof(*data), GFP_KERNEL);
1396 if (!data)
1397 return -ENOMEM;
1398
1399 if (ecc->size != 512 && ecc->size != 1024)
1400 return -EINVAL;
1401
1402
1403 if (ecc->size == 512 && mtd->writesize > 512) {
1404 ecc->size = 1024;
1405 ecc->strength *= 2;
1406 }
1407
1408
1409 for (i = 0; i < ARRAY_SIZE(strengths); i++) {
1410 if (ecc->strength <= strengths[i])
1411 break;
1412 }
1413
1414 if (i >= ARRAY_SIZE(strengths)) {
1415 dev_err(nfc->dev, "unsupported strength\n");
1416 ret = -ENOTSUPP;
1417 goto err;
1418 }
1419
1420 data->mode = i;
1421
1422
1423 ecc->bytes = DIV_ROUND_UP(ecc->strength * fls(8 * 1024), 8);
1424
1425
1426 ecc->bytes = ALIGN(ecc->bytes, 2);
1427
1428 layout = &data->layout;
1429 nsectors = mtd->writesize / ecc->size;
1430
1431 if (mtd->oobsize < ((ecc->bytes + 4) * nsectors)) {
1432 ret = -EINVAL;
1433 goto err;
1434 }
1435
1436 layout->eccbytes = (ecc->bytes * nsectors);
1437
1438 ecc->layout = layout;
1439 ecc->priv = data;
1440
1441 return 0;
1442
1443err:
1444 kfree(data);
1445
1446 return ret;
1447}
1448
1449#ifndef __UBOOT__
1450static void sunxi_nand_hw_common_ecc_ctrl_cleanup(struct nand_ecc_ctrl *ecc)
1451{
1452 kfree(ecc->priv);
1453}
1454#endif
1455
1456static int sunxi_nand_hw_ecc_ctrl_init(struct mtd_info *mtd,
1457 struct nand_ecc_ctrl *ecc)
1458{
1459 struct nand_ecclayout *layout;
1460 int nsectors;
1461 int i, j;
1462 int ret;
1463
1464 ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc);
1465 if (ret)
1466 return ret;
1467
1468 ecc->read_page = sunxi_nfc_hw_ecc_read_page;
1469 ecc->write_page = sunxi_nfc_hw_ecc_write_page;
1470 ecc->read_subpage = sunxi_nfc_hw_ecc_read_subpage;
1471 ecc->write_subpage = sunxi_nfc_hw_ecc_write_subpage;
1472 layout = ecc->layout;
1473 nsectors = mtd->writesize / ecc->size;
1474
1475 for (i = 0; i < nsectors; i++) {
1476 if (i) {
1477 layout->oobfree[i].offset =
1478 layout->oobfree[i - 1].offset +
1479 layout->oobfree[i - 1].length +
1480 ecc->bytes;
1481 layout->oobfree[i].length = 4;
1482 } else {
1483
1484
1485
1486
1487
1488 layout->oobfree[i].length = 2;
1489 layout->oobfree[i].offset = 2;
1490 }
1491
1492 for (j = 0; j < ecc->bytes; j++)
1493 layout->eccpos[(ecc->bytes * i) + j] =
1494 layout->oobfree[i].offset +
1495 layout->oobfree[i].length + j;
1496 }
1497
1498 if (mtd->oobsize > (ecc->bytes + 4) * nsectors) {
1499 layout->oobfree[nsectors].offset =
1500 layout->oobfree[nsectors - 1].offset +
1501 layout->oobfree[nsectors - 1].length +
1502 ecc->bytes;
1503 layout->oobfree[nsectors].length = mtd->oobsize -
1504 ((ecc->bytes + 4) * nsectors);
1505 }
1506
1507 return 0;
1508}
1509
1510static int sunxi_nand_hw_syndrome_ecc_ctrl_init(struct mtd_info *mtd,
1511 struct nand_ecc_ctrl *ecc)
1512{
1513 struct nand_ecclayout *layout;
1514 int nsectors;
1515 int i;
1516 int ret;
1517
1518 ret = sunxi_nand_hw_common_ecc_ctrl_init(mtd, ecc);
1519 if (ret)
1520 return ret;
1521
1522 ecc->prepad = 4;
1523 ecc->read_page = sunxi_nfc_hw_syndrome_ecc_read_page;
1524 ecc->write_page = sunxi_nfc_hw_syndrome_ecc_write_page;
1525
1526 layout = ecc->layout;
1527 nsectors = mtd->writesize / ecc->size;
1528
1529 for (i = 0; i < (ecc->bytes * nsectors); i++)
1530 layout->eccpos[i] = i;
1531
1532 layout->oobfree[0].length = mtd->oobsize - i;
1533 layout->oobfree[0].offset = i;
1534
1535 return 0;
1536}
1537
1538#ifndef __UBOOT__
1539static void sunxi_nand_ecc_cleanup(struct nand_ecc_ctrl *ecc)
1540{
1541 switch (ecc->mode) {
1542 case NAND_ECC_HW:
1543 case NAND_ECC_HW_SYNDROME:
1544 sunxi_nand_hw_common_ecc_ctrl_cleanup(ecc);
1545 break;
1546 case NAND_ECC_NONE:
1547 kfree(ecc->layout);
1548 default:
1549 break;
1550 }
1551}
1552#endif
1553
1554static int sunxi_nand_ecc_init(struct mtd_info *mtd, struct nand_ecc_ctrl *ecc)
1555{
1556 struct nand_chip *nand = mtd_to_nand(mtd);
1557 int ret;
1558
1559 if (!ecc->size) {
1560 ecc->size = nand->ecc_step_ds;
1561 ecc->strength = nand->ecc_strength_ds;
1562 }
1563
1564 if (!ecc->size || !ecc->strength)
1565 return -EINVAL;
1566
1567 switch (ecc->mode) {
1568 case NAND_ECC_SOFT_BCH:
1569 break;
1570 case NAND_ECC_HW:
1571 ret = sunxi_nand_hw_ecc_ctrl_init(mtd, ecc);
1572 if (ret)
1573 return ret;
1574 break;
1575 case NAND_ECC_HW_SYNDROME:
1576 ret = sunxi_nand_hw_syndrome_ecc_ctrl_init(mtd, ecc);
1577 if (ret)
1578 return ret;
1579 break;
1580 case NAND_ECC_NONE:
1581 ecc->layout = kzalloc(sizeof(*ecc->layout), GFP_KERNEL);
1582 if (!ecc->layout)
1583 return -ENOMEM;
1584 ecc->layout->oobfree[0].length = mtd->oobsize;
1585 case NAND_ECC_SOFT:
1586 break;
1587 default:
1588 return -EINVAL;
1589 }
1590
1591 return 0;
1592}
1593
1594static int sunxi_nand_chip_init(int node, struct sunxi_nfc *nfc, int devnum)
1595{
1596 const struct nand_sdr_timings *timings;
1597 const void *blob = gd->fdt_blob;
1598 struct sunxi_nand_chip *chip;
1599 struct mtd_info *mtd;
1600 struct nand_chip *nand;
1601 int nsels;
1602 int ret;
1603 int i;
1604 u32 cs[8], rb[8];
1605
1606 if (!fdt_getprop(blob, node, "reg", &nsels))
1607 return -EINVAL;
1608
1609 nsels /= sizeof(u32);
1610 if (!nsels || nsels > 8) {
1611 dev_err(dev, "invalid reg property size\n");
1612 return -EINVAL;
1613 }
1614
1615 chip = kzalloc(sizeof(*chip) +
1616 (nsels * sizeof(struct sunxi_nand_chip_sel)),
1617 GFP_KERNEL);
1618 if (!chip) {
1619 dev_err(dev, "could not allocate chip\n");
1620 return -ENOMEM;
1621 }
1622
1623 chip->nsels = nsels;
1624 chip->selected = -1;
1625
1626 for (i = 0; i < nsels; i++) {
1627 cs[i] = -1;
1628 rb[i] = -1;
1629 }
1630
1631 ret = fdtdec_get_int_array(gd->fdt_blob, node, "reg", cs, nsels);
1632 if (ret) {
1633 dev_err(dev, "could not retrieve reg property: %d\n", ret);
1634 return ret;
1635 }
1636
1637 ret = fdtdec_get_int_array(gd->fdt_blob, node, "allwinner,rb", rb,
1638 nsels);
1639 if (ret) {
1640 dev_err(dev, "could not retrieve reg property: %d\n", ret);
1641 return ret;
1642 }
1643
1644 for (i = 0; i < nsels; i++) {
1645 int tmp = cs[i];
1646
1647 if (tmp > NFC_MAX_CS) {
1648 dev_err(dev,
1649 "invalid reg value: %u (max CS = 7)\n",
1650 tmp);
1651 return -EINVAL;
1652 }
1653
1654 if (test_and_set_bit(tmp, &nfc->assigned_cs)) {
1655 dev_err(dev, "CS %d already assigned\n", tmp);
1656 return -EINVAL;
1657 }
1658
1659 chip->sels[i].cs = tmp;
1660
1661 tmp = rb[i];
1662 if (tmp >= 0 && tmp < 2) {
1663 chip->sels[i].rb.type = RB_NATIVE;
1664 chip->sels[i].rb.info.nativeid = tmp;
1665 } else {
1666 ret = gpio_request_by_name_nodev(blob, node,
1667 "rb-gpios", i,
1668 &chip->sels[i].rb.info.gpio,
1669 GPIOD_IS_IN);
1670 if (ret)
1671 chip->sels[i].rb.type = RB_GPIO;
1672 else
1673 chip->sels[i].rb.type = RB_NONE;
1674 }
1675 }
1676
1677 timings = onfi_async_timing_mode_to_sdr_timings(0);
1678 if (IS_ERR(timings)) {
1679 ret = PTR_ERR(timings);
1680 dev_err(dev,
1681 "could not retrieve timings for ONFI mode 0: %d\n",
1682 ret);
1683 return ret;
1684 }
1685
1686 ret = sunxi_nand_chip_set_timings(chip, timings);
1687 if (ret) {
1688 dev_err(dev, "could not configure chip timings: %d\n", ret);
1689 return ret;
1690 }
1691
1692 nand = &chip->nand;
1693
1694 nand->chip_delay = 200;
1695 nand->controller = &nfc->controller;
1696
1697
1698
1699
1700 nand->ecc.mode = NAND_ECC_HW;
1701 nand->flash_node = node;
1702 nand->select_chip = sunxi_nfc_select_chip;
1703 nand->cmd_ctrl = sunxi_nfc_cmd_ctrl;
1704 nand->read_buf = sunxi_nfc_read_buf;
1705 nand->write_buf = sunxi_nfc_write_buf;
1706 nand->read_byte = sunxi_nfc_read_byte;
1707
1708 mtd = nand_to_mtd(nand);
1709 ret = nand_scan_ident(mtd, nsels, NULL);
1710 if (ret)
1711 return ret;
1712
1713 if (nand->bbt_options & NAND_BBT_USE_FLASH)
1714 nand->bbt_options |= NAND_BBT_NO_OOB;
1715
1716 if (nand->options & NAND_NEED_SCRAMBLING)
1717 nand->options |= NAND_NO_SUBPAGE_WRITE;
1718
1719 nand->options |= NAND_SUBPAGE_READ;
1720
1721 ret = sunxi_nand_chip_init_timings(chip);
1722 if (ret) {
1723 dev_err(dev, "could not configure chip timings: %d\n", ret);
1724 return ret;
1725 }
1726
1727 ret = sunxi_nand_ecc_init(mtd, &nand->ecc);
1728 if (ret) {
1729 dev_err(dev, "ECC init failed: %d\n", ret);
1730 return ret;
1731 }
1732
1733 ret = nand_scan_tail(mtd);
1734 if (ret) {
1735 dev_err(dev, "nand_scan_tail failed: %d\n", ret);
1736 return ret;
1737 }
1738
1739 ret = nand_register(devnum, mtd);
1740 if (ret) {
1741 dev_err(dev, "failed to register mtd device: %d\n", ret);
1742 return ret;
1743 }
1744
1745 list_add_tail(&chip->node, &nfc->chips);
1746
1747 return 0;
1748}
1749
1750static int sunxi_nand_chips_init(int node, struct sunxi_nfc *nfc)
1751{
1752 const void *blob = gd->fdt_blob;
1753 int nand_node;
1754 int ret, i = 0;
1755
1756 for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0;
1757 nand_node = fdt_next_subnode(blob, nand_node))
1758 i++;
1759
1760 if (i > 8) {
1761 dev_err(dev, "too many NAND chips: %d (max = 8)\n", i);
1762 return -EINVAL;
1763 }
1764
1765 i = 0;
1766 for (nand_node = fdt_first_subnode(blob, node); nand_node >= 0;
1767 nand_node = fdt_next_subnode(blob, nand_node)) {
1768 ret = sunxi_nand_chip_init(nand_node, nfc, i++);
1769 if (ret)
1770 return ret;
1771 }
1772
1773 return 0;
1774}
1775
1776#ifndef __UBOOT__
1777static void sunxi_nand_chips_cleanup(struct sunxi_nfc *nfc)
1778{
1779 struct sunxi_nand_chip *chip;
1780
1781 while (!list_empty(&nfc->chips)) {
1782 chip = list_first_entry(&nfc->chips, struct sunxi_nand_chip,
1783 node);
1784 nand_release(&chip->mtd);
1785 sunxi_nand_ecc_cleanup(&chip->nand.ecc);
1786 list_del(&chip->node);
1787 kfree(chip);
1788 }
1789}
1790#endif
1791
1792void sunxi_nand_init(void)
1793{
1794 const void *blob = gd->fdt_blob;
1795 struct sunxi_nfc *nfc;
1796 fdt_addr_t regs;
1797 int node;
1798 int ret;
1799
1800 nfc = kzalloc(sizeof(*nfc), GFP_KERNEL);
1801 if (!nfc)
1802 return;
1803
1804 spin_lock_init(&nfc->controller.lock);
1805 init_waitqueue_head(&nfc->controller.wq);
1806 INIT_LIST_HEAD(&nfc->chips);
1807
1808 node = fdtdec_next_compatible(blob, 0, COMPAT_SUNXI_NAND);
1809 if (node < 0) {
1810 pr_err("unable to find nfc node in device tree\n");
1811 goto err;
1812 }
1813
1814 if (!fdtdec_get_is_enabled(blob, node)) {
1815 pr_err("nfc disabled in device tree\n");
1816 goto err;
1817 }
1818
1819 regs = fdtdec_get_addr(blob, node, "reg");
1820 if (regs == FDT_ADDR_T_NONE) {
1821 pr_err("unable to find nfc address in device tree\n");
1822 goto err;
1823 }
1824
1825 nfc->regs = (void *)regs;
1826
1827 ret = sunxi_nfc_rst(nfc);
1828 if (ret)
1829 goto err;
1830
1831 ret = sunxi_nand_chips_init(node, nfc);
1832 if (ret) {
1833 dev_err(dev, "failed to init nand chips\n");
1834 goto err;
1835 }
1836
1837 return;
1838
1839err:
1840 kfree(nfc);
1841}
1842
1843MODULE_LICENSE("GPL v2");
1844MODULE_AUTHOR("Boris BREZILLON");
1845MODULE_DESCRIPTION("Allwinner NAND Flash Controller driver");
1846
