2 * Copyright (C) 2013 Boris BREZILLON <b.brezillon.dev@gmail.com>
5 * https://github.com/yuq/sunxi-nfc-mtd
6 * Copyright (C) 2013 Qiang Yu <yuq825@gmail.com>
8 * https://github.com/hno/Allwinner-Info
9 * Copyright (C) 2013 Henrik Nordström <Henrik Nordström>
11 * Copyright (C) 2013 Dmitriy B. <rzk333@gmail.com>
12 * Copyright (C) 2013 Sergey Lapin <slapin@ossfans.org>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
25 #include <linux/dma-mapping.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/platform_device.h>
31 #include <linux/of_device.h>
32 #include <linux/of_gpio.h>
33 #include <linux/of_mtd.h>
34 #include <linux/mtd/mtd.h>
35 #include <linux/mtd/nand.h>
36 #include <linux/mtd/partitions.h>
37 #include <linux/clk.h>
38 #include <linux/delay.h>
39 #include <linux/dmaengine.h>
40 #include <linux/gpio.h>
41 #include <linux/interrupt.h>
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_RAM0_BASE 0x0400
64 #define NFC_RAM1_BASE 0x0800
66 /* define bit use in NFC_CTL */
68 #define NFC_RESET BIT(1)
69 #define NFC_BUS_WIDTH_MSK BIT(2)
70 #define NFC_BUS_WIDTH_8 (0 << 2)
71 #define NFC_BUS_WIDTH_16 (1 << 2)
72 #define NFC_RB_SEL_MSK BIT(3)
73 #define NFC_RB_SEL(x) ((x) << 3)
74 #define NFC_CE_SEL_MSK GENMASK(26, 24)
75 #define NFC_CE_SEL(x) ((x) << 24)
76 #define NFC_CE_CTL BIT(6)
77 #define NFC_PAGE_SHIFT_MSK GENMASK(11, 8)
78 #define NFC_PAGE_SHIFT(x) (((x) < 10 ? 0 : (x) - 10) << 8)
79 #define NFC_SAM BIT(12)
80 #define NFC_RAM_METHOD BIT(14)
81 #define NFC_DEBUG_CTL BIT(31)
83 /* define bit use in NFC_ST */
84 #define NFC_RB_B2R BIT(0)
85 #define NFC_CMD_INT_FLAG BIT(1)
86 #define NFC_DMA_INT_FLAG BIT(2)
87 #define NFC_CMD_FIFO_STATUS BIT(3)
88 #define NFC_STA BIT(4)
89 #define NFC_NATCH_INT_FLAG BIT(5)
90 #define NFC_RB_STATE(x) BIT(x + 8)
92 /* define bit use in NFC_INT */
93 #define NFC_B2R_INT_ENABLE BIT(0)
94 #define NFC_CMD_INT_ENABLE BIT(1)
95 #define NFC_DMA_INT_ENABLE BIT(2)
96 #define NFC_INT_MASK (NFC_B2R_INT_ENABLE | \
97 NFC_CMD_INT_ENABLE | \
100 /* define bit use in NFC_TIMING_CTL */
101 #define NFC_TIMING_CTL_EDO BIT(8)
103 /* define NFC_TIMING_CFG register layout */
104 #define NFC_TIMING_CFG(tWB, tADL, tWHR, tRHW, tCAD) \
105 (((tWB) & 0x3) | (((tADL) & 0x3) << 2) | \
106 (((tWHR) & 0x3) << 4) | (((tRHW) & 0x3) << 6) | \
107 (((tCAD) & 0x7) << 8))
109 /* define bit use in NFC_CMD */
110 #define NFC_CMD_LOW_BYTE_MSK GENMASK(7, 0)
111 #define NFC_CMD_HIGH_BYTE_MSK GENMASK(15, 8)
112 #define NFC_CMD(x) (x)
113 #define NFC_ADR_NUM_MSK GENMASK(18, 16)
114 #define NFC_ADR_NUM(x) (((x) - 1) << 16)
115 #define NFC_SEND_ADR BIT(19)
116 #define NFC_ACCESS_DIR BIT(20)
117 #define NFC_DATA_TRANS BIT(21)
118 #define NFC_SEND_CMD1 BIT(22)
119 #define NFC_WAIT_FLAG BIT(23)
120 #define NFC_SEND_CMD2 BIT(24)
121 #define NFC_SEQ BIT(25)
122 #define NFC_DATA_SWAP_METHOD BIT(26)
123 #define NFC_ROW_AUTO_INC BIT(27)
124 #define NFC_SEND_CMD3 BIT(28)
125 #define NFC_SEND_CMD4 BIT(29)
126 #define NFC_CMD_TYPE_MSK GENMASK(31, 30)
127 #define NFC_NORMAL_OP (0 << 30)
128 #define NFC_ECC_OP (1 << 30)
129 #define NFC_PAGE_OP (2 << 30)
131 /* define bit use in NFC_RCMD_SET */
132 #define NFC_READ_CMD_MSK GENMASK(7, 0)
133 #define NFC_RND_READ_CMD0_MSK GENMASK(15, 8)
134 #define NFC_RND_READ_CMD1_MSK GENMASK(23, 16)
136 /* define bit use in NFC_WCMD_SET */
137 #define NFC_PROGRAM_CMD_MSK GENMASK(7, 0)
138 #define NFC_RND_WRITE_CMD_MSK GENMASK(15, 8)
139 #define NFC_READ_CMD0_MSK GENMASK(23, 16)
140 #define NFC_READ_CMD1_MSK GENMASK(31, 24)
142 /* define bit use in NFC_ECC_CTL */
143 #define NFC_ECC_EN BIT(0)
144 #define NFC_ECC_PIPELINE BIT(3)
145 #define NFC_ECC_EXCEPTION BIT(4)
146 #define NFC_ECC_BLOCK_SIZE_MSK BIT(5)
147 #define NFC_RANDOM_EN BIT(9)
148 #define NFC_RANDOM_DIRECTION BIT(10)
149 #define NFC_ECC_MODE_MSK GENMASK(15, 12)
150 #define NFC_ECC_MODE(x) ((x) << 12)
151 #define NFC_RANDOM_SEED_MSK GENMASK(30, 16)
152 #define NFC_RANDOM_SEED(x) ((x) << 16)
154 /* define bit use in NFC_ECC_ST */
155 #define NFC_ECC_ERR(x) BIT(x)
156 #define NFC_ECC_PAT_FOUND(x) BIT(x + 16)
157 #define NFC_ECC_ERR_CNT(b, x) (((x) >> ((b) * 8)) & 0xff)
159 /* NFC_USER_DATA helper macros */
160 #define NFC_BUF_TO_USER_DATA(buf) ((buf)[0] | ((buf)[1] << 8) | \
161 ((buf)[2] << 16) | ((buf)[3] << 24))
163 #define NFC_DEFAULT_TIMEOUT_MS 1000
165 #define NFC_SRAM_SIZE 1024
170 * Ready/Busy detection type: describes the Ready/Busy detection modes
172 * @RB_NONE: no external detection available, rely on STATUS command
173 * and software timeouts
174 * @RB_NATIVE: use sunxi NAND controller Ready/Busy support. The Ready/Busy
175 * pin of the NAND flash chip must be connected to one of the
176 * native NAND R/B pins (those which can be muxed to the NAND
178 * @RB_GPIO: use a simple GPIO to handle Ready/Busy status. The Ready/Busy
179 * pin of the NAND flash chip must be connected to a GPIO capable
182 enum sunxi_nand_rb_type
{
189 * Ready/Busy structure: stores information related to Ready/Busy detection
191 * @type: the Ready/Busy detection mode
192 * @info: information related to the R/B detection mode. Either a gpio
193 * id or a native R/B id (those supported by the NAND controller).
195 struct sunxi_nand_rb
{
196 enum sunxi_nand_rb_type type
;
204 * Chip Select structure: stores information related to NAND Chip Select
206 * @cs: the NAND CS id used to communicate with a NAND Chip
207 * @rb: the Ready/Busy description
209 struct sunxi_nand_chip_sel
{
211 struct sunxi_nand_rb rb
;
215 * sunxi HW ECC infos: stores information related to HW ECC support
217 * @mode: the sunxi ECC mode field deduced from ECC requirements
218 * @layout: the OOB layout depending on the ECC requirements and the
221 struct sunxi_nand_hw_ecc
{
223 struct nand_ecclayout layout
;
227 * NAND chip structure: stores NAND chip device related information
229 * @node: used to store NAND chips into a list
230 * @nand: base NAND chip structure
231 * @mtd: base MTD structure
232 * @clk_rate: clk_rate required for this NAND chip
233 * @timing_cfg TIMING_CFG register value for this NAND chip
234 * @selected: current active CS
235 * @nsels: number of CS lines required by the NAND chip
236 * @sels: array of CS lines descriptions
238 struct sunxi_nand_chip
{
239 struct list_head node
;
240 struct nand_chip nand
;
242 unsigned long clk_rate
;
247 struct sunxi_nand_chip_sel sels
[0];
250 static inline struct sunxi_nand_chip
*to_sunxi_nand(struct nand_chip
*nand
)
252 return container_of(nand
, struct sunxi_nand_chip
, nand
);
256 * NAND Controller structure: stores sunxi NAND controller information
258 * @controller: base controller structure
259 * @dev: parent device (used to print error messages)
260 * @regs: NAND controller registers
261 * @ahb_clk: NAND Controller AHB clock
262 * @mod_clk: NAND Controller mod clock
263 * @assigned_cs: bitmask describing already assigned CS lines
264 * @clk_rate: NAND controller current clock rate
265 * @chips: a list containing all the NAND chips attached to
266 * this NAND controller
267 * @complete: a completion object used to wait for NAND
271 struct nand_hw_control controller
;
276 unsigned long assigned_cs
;
277 unsigned long clk_rate
;
278 struct list_head chips
;
279 struct completion complete
;
282 static inline struct sunxi_nfc
*to_sunxi_nfc(struct nand_hw_control
*ctrl
)
284 return container_of(ctrl
, struct sunxi_nfc
, controller
);
287 static irqreturn_t
sunxi_nfc_interrupt(int irq
, void *dev_id
)
289 struct sunxi_nfc
*nfc
= dev_id
;
290 u32 st
= readl(nfc
->regs
+ NFC_REG_ST
);
291 u32 ien
= readl(nfc
->regs
+ NFC_REG_INT
);
296 if ((ien
& st
) == ien
)
297 complete(&nfc
->complete
);
299 writel(st
& NFC_INT_MASK
, nfc
->regs
+ NFC_REG_ST
);
300 writel(~st
& ien
& NFC_INT_MASK
, nfc
->regs
+ NFC_REG_INT
);
305 static int sunxi_nfc_wait_int(struct sunxi_nfc
*nfc
, u32 flags
,
306 unsigned int timeout_ms
)
308 init_completion(&nfc
->complete
);
310 writel(flags
, nfc
->regs
+ NFC_REG_INT
);
313 timeout_ms
= NFC_DEFAULT_TIMEOUT_MS
;
315 if (!wait_for_completion_timeout(&nfc
->complete
,
316 msecs_to_jiffies(timeout_ms
))) {
317 dev_err(nfc
->dev
, "wait interrupt timedout\n");
324 static int sunxi_nfc_wait_cmd_fifo_empty(struct sunxi_nfc
*nfc
)
326 unsigned long timeout
= jiffies
+
327 msecs_to_jiffies(NFC_DEFAULT_TIMEOUT_MS
);
330 if (!(readl(nfc
->regs
+ NFC_REG_ST
) & NFC_CMD_FIFO_STATUS
))
332 } while (time_before(jiffies
, timeout
));
334 dev_err(nfc
->dev
, "wait for empty cmd FIFO timedout\n");
338 static int sunxi_nfc_rst(struct sunxi_nfc
*nfc
)
340 unsigned long timeout
= jiffies
+
341 msecs_to_jiffies(NFC_DEFAULT_TIMEOUT_MS
);
343 writel(0, nfc
->regs
+ NFC_REG_ECC_CTL
);
344 writel(NFC_RESET
, nfc
->regs
+ NFC_REG_CTL
);
347 if (!(readl(nfc
->regs
+ NFC_REG_CTL
) & NFC_RESET
))
349 } while (time_before(jiffies
, timeout
));
351 dev_err(nfc
->dev
, "wait for NAND controller reset timedout\n");
355 static int sunxi_nfc_dev_ready(struct mtd_info
*mtd
)
357 struct nand_chip
*nand
= mtd
->priv
;
358 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
359 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
360 struct sunxi_nand_rb
*rb
;
361 unsigned long timeo
= (sunxi_nand
->nand
.state
== FL_ERASING
? 400 : 20);
364 if (sunxi_nand
->selected
< 0)
367 rb
= &sunxi_nand
->sels
[sunxi_nand
->selected
].rb
;
371 ret
= !!(readl(nfc
->regs
+ NFC_REG_ST
) &
372 NFC_RB_STATE(rb
->info
.nativeid
));
376 sunxi_nfc_wait_int(nfc
, NFC_RB_B2R
, timeo
);
377 ret
= !!(readl(nfc
->regs
+ NFC_REG_ST
) &
378 NFC_RB_STATE(rb
->info
.nativeid
));
381 ret
= gpio_get_value(rb
->info
.gpio
);
386 dev_err(nfc
->dev
, "cannot check R/B NAND status!\n");
393 static void sunxi_nfc_select_chip(struct mtd_info
*mtd
, int chip
)
395 struct nand_chip
*nand
= mtd
->priv
;
396 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
397 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
398 struct sunxi_nand_chip_sel
*sel
;
401 if (chip
> 0 && chip
>= sunxi_nand
->nsels
)
404 if (chip
== sunxi_nand
->selected
)
407 ctl
= readl(nfc
->regs
+ NFC_REG_CTL
) &
408 ~(NFC_PAGE_SHIFT_MSK
| NFC_CE_SEL_MSK
| NFC_RB_SEL_MSK
| NFC_EN
);
411 sel
= &sunxi_nand
->sels
[chip
];
413 ctl
|= NFC_CE_SEL(sel
->cs
) | NFC_EN
|
414 NFC_PAGE_SHIFT(nand
->page_shift
- 10);
415 if (sel
->rb
.type
== RB_NONE
) {
416 nand
->dev_ready
= NULL
;
418 nand
->dev_ready
= sunxi_nfc_dev_ready
;
419 if (sel
->rb
.type
== RB_NATIVE
)
420 ctl
|= NFC_RB_SEL(sel
->rb
.info
.nativeid
);
423 writel(mtd
->writesize
, nfc
->regs
+ NFC_REG_SPARE_AREA
);
425 if (nfc
->clk_rate
!= sunxi_nand
->clk_rate
) {
426 clk_set_rate(nfc
->mod_clk
, sunxi_nand
->clk_rate
);
427 nfc
->clk_rate
= sunxi_nand
->clk_rate
;
431 writel(sunxi_nand
->timing_ctl
, nfc
->regs
+ NFC_REG_TIMING_CTL
);
432 writel(sunxi_nand
->timing_cfg
, nfc
->regs
+ NFC_REG_TIMING_CFG
);
433 writel(ctl
, nfc
->regs
+ NFC_REG_CTL
);
435 sunxi_nand
->selected
= chip
;
438 static void sunxi_nfc_read_buf(struct mtd_info
*mtd
, uint8_t *buf
, int len
)
440 struct nand_chip
*nand
= mtd
->priv
;
441 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
442 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
449 cnt
= min(len
- offs
, NFC_SRAM_SIZE
);
451 ret
= sunxi_nfc_wait_cmd_fifo_empty(nfc
);
455 writel(cnt
, nfc
->regs
+ NFC_REG_CNT
);
456 tmp
= NFC_DATA_TRANS
| NFC_DATA_SWAP_METHOD
;
457 writel(tmp
, nfc
->regs
+ NFC_REG_CMD
);
459 ret
= sunxi_nfc_wait_int(nfc
, NFC_CMD_INT_FLAG
, 0);
464 memcpy_fromio(buf
+ offs
, nfc
->regs
+ NFC_RAM0_BASE
,
470 static void sunxi_nfc_write_buf(struct mtd_info
*mtd
, const uint8_t *buf
,
473 struct nand_chip
*nand
= mtd
->priv
;
474 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
475 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
482 cnt
= min(len
- offs
, NFC_SRAM_SIZE
);
484 ret
= sunxi_nfc_wait_cmd_fifo_empty(nfc
);
488 writel(cnt
, nfc
->regs
+ NFC_REG_CNT
);
489 memcpy_toio(nfc
->regs
+ NFC_RAM0_BASE
, buf
+ offs
, cnt
);
490 tmp
= NFC_DATA_TRANS
| NFC_DATA_SWAP_METHOD
|
492 writel(tmp
, nfc
->regs
+ NFC_REG_CMD
);
494 ret
= sunxi_nfc_wait_int(nfc
, NFC_CMD_INT_FLAG
, 0);
502 static uint8_t sunxi_nfc_read_byte(struct mtd_info
*mtd
)
506 sunxi_nfc_read_buf(mtd
, &ret
, 1);
511 static void sunxi_nfc_cmd_ctrl(struct mtd_info
*mtd
, int dat
,
514 struct nand_chip
*nand
= mtd
->priv
;
515 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
516 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
520 ret
= sunxi_nfc_wait_cmd_fifo_empty(nfc
);
524 if (ctrl
& NAND_CTRL_CHANGE
) {
525 tmp
= readl(nfc
->regs
+ NFC_REG_CTL
);
530 writel(tmp
, nfc
->regs
+ NFC_REG_CTL
);
533 if (dat
== NAND_CMD_NONE
)
536 if (ctrl
& NAND_CLE
) {
537 writel(NFC_SEND_CMD1
| dat
, nfc
->regs
+ NFC_REG_CMD
);
539 writel(dat
, nfc
->regs
+ NFC_REG_ADDR_LOW
);
540 writel(NFC_SEND_ADR
, nfc
->regs
+ NFC_REG_CMD
);
543 sunxi_nfc_wait_int(nfc
, NFC_CMD_INT_FLAG
, 0);
546 static void sunxi_nfc_hw_ecc_enable(struct mtd_info
*mtd
)
548 struct nand_chip
*nand
= mtd
->priv
;
549 struct sunxi_nfc
*nfc
= to_sunxi_nfc(nand
->controller
);
550 struct sunxi_nand_hw_ecc
*data
= nand
->ecc
.priv
;
553 ecc_ctl
= readl(nfc
->regs
+ NFC_REG_ECC_CTL
);
554 ecc_ctl
&= ~(NFC_ECC_MODE_MSK
| NFC_ECC_PIPELINE
|
555 NFC_ECC_BLOCK_SIZE_MSK
);
556 ecc_ctl
|= NFC_ECC_EN
| NFC_ECC_MODE(data
->mode
) | NFC_ECC_EXCEPTION
;
558 writel(ecc_ctl
, nfc
->regs
+ NFC_REG_ECC_CTL
);
561 static void sunxi_nfc_hw_ecc_disable(struct mtd_info
*mtd
)
563 struct nand_chip
*nand
= mtd
->priv
;
564 struct sunxi_nfc
*nfc
= to_sunxi_nfc(nand
->controller
);
566 writel(readl(nfc
->regs
+ NFC_REG_ECC_CTL
) & ~NFC_ECC_EN
,
567 nfc
->regs
+ NFC_REG_ECC_CTL
);
570 static int sunxi_nfc_hw_ecc_read_chunk(struct mtd_info
*mtd
,
571 u8
*data
, int data_off
,
572 u8
*oob
, int oob_off
,
574 unsigned int *max_bitflips
)
576 struct nand_chip
*nand
= mtd
->priv
;
577 struct sunxi_nfc
*nfc
= to_sunxi_nfc(nand
->controller
);
578 struct nand_ecc_ctrl
*ecc
= &nand
->ecc
;
582 if (*cur_off
!= data_off
)
583 nand
->cmdfunc(mtd
, NAND_CMD_RNDOUT
, data_off
, -1);
585 sunxi_nfc_read_buf(mtd
, data
, ecc
->size
);
587 if (data_off
+ ecc
->bytes
!= oob_off
)
588 nand
->cmdfunc(mtd
, NAND_CMD_RNDOUT
, oob_off
, -1);
590 ret
= sunxi_nfc_wait_cmd_fifo_empty(nfc
);
594 writel(NFC_DATA_TRANS
| NFC_DATA_SWAP_METHOD
| NFC_ECC_OP
,
595 nfc
->regs
+ NFC_REG_CMD
);
597 ret
= sunxi_nfc_wait_int(nfc
, NFC_CMD_INT_FLAG
, 0);
601 status
= readl(nfc
->regs
+ NFC_REG_ECC_ST
);
602 ret
= NFC_ECC_ERR_CNT(0, readl(nfc
->regs
+ NFC_REG_ECC_ERR_CNT(0)));
604 memcpy_fromio(data
, nfc
->regs
+ NFC_RAM0_BASE
, ecc
->size
);
606 nand
->cmdfunc(mtd
, NAND_CMD_RNDOUT
, oob_off
, -1);
607 sunxi_nfc_read_buf(mtd
, oob
, ecc
->bytes
+ 4);
609 if (status
& NFC_ECC_ERR(0))
613 mtd
->ecc_stats
.failed
++;
615 mtd
->ecc_stats
.corrected
+= ret
;
616 *max_bitflips
= max_t(unsigned int, *max_bitflips
, ret
);
619 *cur_off
= oob_off
+ ecc
->bytes
+ 4;
624 static void sunxi_nfc_hw_ecc_read_extra_oob(struct mtd_info
*mtd
,
625 u8
*oob
, int *cur_off
)
627 struct nand_chip
*nand
= mtd
->priv
;
628 struct nand_ecc_ctrl
*ecc
= &nand
->ecc
;
629 int offset
= ((ecc
->bytes
+ 4) * ecc
->steps
);
630 int len
= mtd
->oobsize
- offset
;
635 if (*cur_off
!= offset
)
636 nand
->cmdfunc(mtd
, NAND_CMD_RNDOUT
,
637 offset
+ mtd
->writesize
, -1);
639 sunxi_nfc_read_buf(mtd
, oob
+ offset
, len
);
641 *cur_off
= mtd
->oobsize
+ mtd
->writesize
;
644 static int sunxi_nfc_hw_ecc_write_chunk(struct mtd_info
*mtd
,
645 const u8
*data
, int data_off
,
646 const u8
*oob
, int oob_off
,
649 struct nand_chip
*nand
= mtd
->priv
;
650 struct sunxi_nfc
*nfc
= to_sunxi_nfc(nand
->controller
);
651 struct nand_ecc_ctrl
*ecc
= &nand
->ecc
;
654 if (data_off
!= *cur_off
)
655 nand
->cmdfunc(mtd
, NAND_CMD_RNDIN
, data_off
, -1);
657 sunxi_nfc_write_buf(mtd
, data
, ecc
->size
);
659 /* Fill OOB data in */
660 writel(NFC_BUF_TO_USER_DATA(oob
), nfc
->regs
+ NFC_REG_USER_DATA(0));
662 if (data_off
+ ecc
->bytes
!= oob_off
)
663 nand
->cmdfunc(mtd
, NAND_CMD_RNDIN
, oob_off
, -1);
665 ret
= sunxi_nfc_wait_cmd_fifo_empty(nfc
);
669 writel(NFC_DATA_TRANS
| NFC_DATA_SWAP_METHOD
|
670 NFC_ACCESS_DIR
| NFC_ECC_OP
,
671 nfc
->regs
+ NFC_REG_CMD
);
673 ret
= sunxi_nfc_wait_int(nfc
, NFC_CMD_INT_FLAG
, 0);
677 *cur_off
= oob_off
+ ecc
->bytes
+ 4;
682 static void sunxi_nfc_hw_ecc_write_extra_oob(struct mtd_info
*mtd
,
683 u8
*oob
, int *cur_off
)
685 struct nand_chip
*nand
= mtd
->priv
;
686 struct nand_ecc_ctrl
*ecc
= &nand
->ecc
;
687 int offset
= ((ecc
->bytes
+ 4) * ecc
->steps
);
688 int len
= mtd
->oobsize
- offset
;
693 if (*cur_off
!= offset
)
694 nand
->cmdfunc(mtd
, NAND_CMD_RNDIN
,
695 offset
+ mtd
->writesize
, -1);
697 sunxi_nfc_write_buf(mtd
, oob
+ offset
, len
);
699 *cur_off
= mtd
->oobsize
+ mtd
->writesize
;
702 static int sunxi_nfc_hw_ecc_read_page(struct mtd_info
*mtd
,
703 struct nand_chip
*chip
, uint8_t *buf
,
704 int oob_required
, int page
)
706 struct nand_ecc_ctrl
*ecc
= &chip
->ecc
;
707 unsigned int max_bitflips
= 0;
708 int ret
, i
, cur_off
= 0;
710 sunxi_nfc_hw_ecc_enable(mtd
);
712 for (i
= 0; i
< ecc
->steps
; i
++) {
713 int data_off
= i
* ecc
->size
;
714 int oob_off
= i
* (ecc
->bytes
+ 4);
715 u8
*data
= buf
+ data_off
;
716 u8
*oob
= chip
->oob_poi
+ oob_off
;
718 ret
= sunxi_nfc_hw_ecc_read_chunk(mtd
, data
, data_off
, oob
,
719 oob_off
+ mtd
->writesize
,
720 &cur_off
, &max_bitflips
);
726 sunxi_nfc_hw_ecc_read_extra_oob(mtd
, chip
->oob_poi
, &cur_off
);
728 sunxi_nfc_hw_ecc_disable(mtd
);
733 static int sunxi_nfc_hw_ecc_write_page(struct mtd_info
*mtd
,
734 struct nand_chip
*chip
,
735 const uint8_t *buf
, int oob_required
)
737 struct nand_ecc_ctrl
*ecc
= &chip
->ecc
;
738 int ret
, i
, cur_off
= 0;
740 sunxi_nfc_hw_ecc_enable(mtd
);
742 for (i
= 0; i
< ecc
->steps
; i
++) {
743 int data_off
= i
* ecc
->size
;
744 int oob_off
= i
* (ecc
->bytes
+ 4);
745 const u8
*data
= buf
+ data_off
;
746 const u8
*oob
= chip
->oob_poi
+ oob_off
;
748 ret
= sunxi_nfc_hw_ecc_write_chunk(mtd
, data
, data_off
, oob
,
749 oob_off
+ mtd
->writesize
,
756 sunxi_nfc_hw_ecc_write_extra_oob(mtd
, chip
->oob_poi
, &cur_off
);
758 sunxi_nfc_hw_ecc_disable(mtd
);
763 static int sunxi_nfc_hw_syndrome_ecc_read_page(struct mtd_info
*mtd
,
764 struct nand_chip
*chip
,
765 uint8_t *buf
, int oob_required
,
768 struct nand_ecc_ctrl
*ecc
= &chip
->ecc
;
769 unsigned int max_bitflips
= 0;
770 int ret
, i
, cur_off
= 0;
772 sunxi_nfc_hw_ecc_enable(mtd
);
774 for (i
= 0; i
< ecc
->steps
; i
++) {
775 int data_off
= i
* (ecc
->size
+ ecc
->bytes
+ 4);
776 int oob_off
= data_off
+ ecc
->size
;
777 u8
*data
= buf
+ (i
* ecc
->size
);
778 u8
*oob
= chip
->oob_poi
+ (i
* (ecc
->bytes
+ 4));
780 ret
= sunxi_nfc_hw_ecc_read_chunk(mtd
, data
, data_off
, oob
,
788 sunxi_nfc_hw_ecc_read_extra_oob(mtd
, chip
->oob_poi
, &cur_off
);
790 sunxi_nfc_hw_ecc_disable(mtd
);
795 static int sunxi_nfc_hw_syndrome_ecc_write_page(struct mtd_info
*mtd
,
796 struct nand_chip
*chip
,
800 struct nand_ecc_ctrl
*ecc
= &chip
->ecc
;
801 int ret
, i
, cur_off
= 0;
803 sunxi_nfc_hw_ecc_enable(mtd
);
805 for (i
= 0; i
< ecc
->steps
; i
++) {
806 int data_off
= i
* (ecc
->size
+ ecc
->bytes
+ 4);
807 int oob_off
= data_off
+ ecc
->size
;
808 const u8
*data
= buf
+ (i
* ecc
->size
);
809 const u8
*oob
= chip
->oob_poi
+ (i
* (ecc
->bytes
+ 4));
811 ret
= sunxi_nfc_hw_ecc_write_chunk(mtd
, data
, data_off
,
812 oob
, oob_off
, &cur_off
);
818 sunxi_nfc_hw_ecc_write_extra_oob(mtd
, chip
->oob_poi
, &cur_off
);
820 sunxi_nfc_hw_ecc_disable(mtd
);
825 static const s32 tWB_lut
[] = {6, 12, 16, 20};
826 static const s32 tRHW_lut
[] = {4, 8, 12, 20};
828 static int _sunxi_nand_lookup_timing(const s32
*lut
, int lut_size
, u32 duration
,
831 u32 clk_cycles
= DIV_ROUND_UP(duration
, clk_period
);
834 for (i
= 0; i
< lut_size
; i
++) {
835 if (clk_cycles
<= lut
[i
])
843 #define sunxi_nand_lookup_timing(l, p, c) \
844 _sunxi_nand_lookup_timing(l, ARRAY_SIZE(l), p, c)
846 static int sunxi_nand_chip_set_timings(struct sunxi_nand_chip
*chip
,
847 const struct nand_sdr_timings
*timings
)
849 struct sunxi_nfc
*nfc
= to_sunxi_nfc(chip
->nand
.controller
);
850 u32 min_clk_period
= 0;
851 s32 tWB
, tADL
, tWHR
, tRHW
, tCAD
;
854 if (timings
->tCLS_min
> min_clk_period
)
855 min_clk_period
= timings
->tCLS_min
;
858 if (timings
->tCLH_min
> min_clk_period
)
859 min_clk_period
= timings
->tCLH_min
;
862 if (timings
->tCS_min
> min_clk_period
)
863 min_clk_period
= timings
->tCS_min
;
866 if (timings
->tCH_min
> min_clk_period
)
867 min_clk_period
= timings
->tCH_min
;
870 if (timings
->tWP_min
> min_clk_period
)
871 min_clk_period
= timings
->tWP_min
;
874 if (timings
->tWH_min
> min_clk_period
)
875 min_clk_period
= timings
->tWH_min
;
878 if (timings
->tALS_min
> min_clk_period
)
879 min_clk_period
= timings
->tALS_min
;
882 if (timings
->tDS_min
> min_clk_period
)
883 min_clk_period
= timings
->tDS_min
;
886 if (timings
->tDH_min
> min_clk_period
)
887 min_clk_period
= timings
->tDH_min
;
890 if (timings
->tRR_min
> (min_clk_period
* 3))
891 min_clk_period
= DIV_ROUND_UP(timings
->tRR_min
, 3);
894 if (timings
->tALH_min
> min_clk_period
)
895 min_clk_period
= timings
->tALH_min
;
898 if (timings
->tRP_min
> min_clk_period
)
899 min_clk_period
= timings
->tRP_min
;
902 if (timings
->tREH_min
> min_clk_period
)
903 min_clk_period
= timings
->tREH_min
;
906 if (timings
->tRC_min
> (min_clk_period
* 2))
907 min_clk_period
= DIV_ROUND_UP(timings
->tRC_min
, 2);
910 if (timings
->tWC_min
> (min_clk_period
* 2))
911 min_clk_period
= DIV_ROUND_UP(timings
->tWC_min
, 2);
913 /* T16 - T19 + tCAD */
914 tWB
= sunxi_nand_lookup_timing(tWB_lut
, timings
->tWB_max
,
917 dev_err(nfc
->dev
, "unsupported tWB\n");
921 tADL
= DIV_ROUND_UP(timings
->tADL_min
, min_clk_period
) >> 3;
923 dev_err(nfc
->dev
, "unsupported tADL\n");
927 tWHR
= DIV_ROUND_UP(timings
->tWHR_min
, min_clk_period
) >> 3;
929 dev_err(nfc
->dev
, "unsupported tWHR\n");
933 tRHW
= sunxi_nand_lookup_timing(tRHW_lut
, timings
->tRHW_min
,
936 dev_err(nfc
->dev
, "unsupported tRHW\n");
941 * TODO: according to ONFI specs this value only applies for DDR NAND,
942 * but Allwinner seems to set this to 0x7. Mimic them for now.
946 /* TODO: A83 has some more bits for CDQSS, CS, CLHZ, CCS, WC */
947 chip
->timing_cfg
= NFC_TIMING_CFG(tWB
, tADL
, tWHR
, tRHW
, tCAD
);
950 * ONFI specification 3.1, paragraph 4.15.2 dictates that EDO data
951 * output cycle timings shall be used if the host drives tRC less than
954 chip
->timing_ctl
= (timings
->tRC_min
< 30000) ? NFC_TIMING_CTL_EDO
: 0;
956 /* Convert min_clk_period from picoseconds to nanoseconds */
957 min_clk_period
= DIV_ROUND_UP(min_clk_period
, 1000);
960 * Convert min_clk_period into a clk frequency, then get the
961 * appropriate rate for the NAND controller IP given this formula
962 * (specified in the datasheet):
963 * nand clk_rate = 2 * min_clk_rate
965 chip
->clk_rate
= (2 * NSEC_PER_SEC
) / min_clk_period
;
970 static int sunxi_nand_chip_init_timings(struct sunxi_nand_chip
*chip
,
971 struct device_node
*np
)
973 const struct nand_sdr_timings
*timings
;
977 mode
= onfi_get_async_timing_mode(&chip
->nand
);
978 if (mode
== ONFI_TIMING_MODE_UNKNOWN
) {
979 mode
= chip
->nand
.onfi_timing_mode_default
;
981 uint8_t feature
[ONFI_SUBFEATURE_PARAM_LEN
] = {};
984 mode
= fls(mode
) - 1;
989 for (i
= 0; i
< chip
->nsels
; i
++) {
990 chip
->nand
.select_chip(&chip
->mtd
, i
);
991 ret
= chip
->nand
.onfi_set_features(&chip
->mtd
,
993 ONFI_FEATURE_ADDR_TIMING_MODE
,
995 chip
->nand
.select_chip(&chip
->mtd
, -1);
1001 timings
= onfi_async_timing_mode_to_sdr_timings(mode
);
1002 if (IS_ERR(timings
))
1003 return PTR_ERR(timings
);
1005 return sunxi_nand_chip_set_timings(chip
, timings
);
1008 static int sunxi_nand_hw_common_ecc_ctrl_init(struct mtd_info
*mtd
,
1009 struct nand_ecc_ctrl
*ecc
,
1010 struct device_node
*np
)
1012 static const u8 strengths
[] = { 16, 24, 28, 32, 40, 48, 56, 60, 64 };
1013 struct nand_chip
*nand
= mtd
->priv
;
1014 struct sunxi_nand_chip
*sunxi_nand
= to_sunxi_nand(nand
);
1015 struct sunxi_nfc
*nfc
= to_sunxi_nfc(sunxi_nand
->nand
.controller
);
1016 struct sunxi_nand_hw_ecc
*data
;
1017 struct nand_ecclayout
*layout
;
1022 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1026 /* Add ECC info retrieval from DT */
1027 for (i
= 0; i
< ARRAY_SIZE(strengths
); i
++) {
1028 if (ecc
->strength
<= strengths
[i
])
1032 if (i
>= ARRAY_SIZE(strengths
)) {
1033 dev_err(nfc
->dev
, "unsupported strength\n");
1040 /* HW ECC always request ECC bytes for 1024 bytes blocks */
1041 ecc
->bytes
= DIV_ROUND_UP(ecc
->strength
* fls(8 * 1024), 8);
1043 /* HW ECC always work with even numbers of ECC bytes */
1044 ecc
->bytes
= ALIGN(ecc
->bytes
, 2);
1046 layout
= &data
->layout
;
1047 nsectors
= mtd
->writesize
/ ecc
->size
;
1049 if (mtd
->oobsize
< ((ecc
->bytes
+ 4) * nsectors
)) {
1054 layout
->eccbytes
= (ecc
->bytes
* nsectors
);
1056 ecc
->layout
= layout
;
1067 static void sunxi_nand_hw_common_ecc_ctrl_cleanup(struct nand_ecc_ctrl
*ecc
)
1072 static int sunxi_nand_hw_ecc_ctrl_init(struct mtd_info
*mtd
,
1073 struct nand_ecc_ctrl
*ecc
,
1074 struct device_node
*np
)
1076 struct nand_ecclayout
*layout
;
1081 ret
= sunxi_nand_hw_common_ecc_ctrl_init(mtd
, ecc
, np
);
1085 ecc
->read_page
= sunxi_nfc_hw_ecc_read_page
;
1086 ecc
->write_page
= sunxi_nfc_hw_ecc_write_page
;
1087 layout
= ecc
->layout
;
1088 nsectors
= mtd
->writesize
/ ecc
->size
;
1090 for (i
= 0; i
< nsectors
; i
++) {
1092 layout
->oobfree
[i
].offset
=
1093 layout
->oobfree
[i
- 1].offset
+
1094 layout
->oobfree
[i
- 1].length
+
1096 layout
->oobfree
[i
].length
= 4;
1099 * The first 2 bytes are used for BB markers, hence we
1100 * only have 2 bytes available in the first user data
1103 layout
->oobfree
[i
].length
= 2;
1104 layout
->oobfree
[i
].offset
= 2;
1107 for (j
= 0; j
< ecc
->bytes
; j
++)
1108 layout
->eccpos
[(ecc
->bytes
* i
) + j
] =
1109 layout
->oobfree
[i
].offset
+
1110 layout
->oobfree
[i
].length
+ j
;
1113 if (mtd
->oobsize
> (ecc
->bytes
+ 4) * nsectors
) {
1114 layout
->oobfree
[nsectors
].offset
=
1115 layout
->oobfree
[nsectors
- 1].offset
+
1116 layout
->oobfree
[nsectors
- 1].length
+
1118 layout
->oobfree
[nsectors
].length
= mtd
->oobsize
-
1119 ((ecc
->bytes
+ 4) * nsectors
);
1125 static int sunxi_nand_hw_syndrome_ecc_ctrl_init(struct mtd_info
*mtd
,
1126 struct nand_ecc_ctrl
*ecc
,
1127 struct device_node
*np
)
1129 struct nand_ecclayout
*layout
;
1134 ret
= sunxi_nand_hw_common_ecc_ctrl_init(mtd
, ecc
, np
);
1139 ecc
->read_page
= sunxi_nfc_hw_syndrome_ecc_read_page
;
1140 ecc
->write_page
= sunxi_nfc_hw_syndrome_ecc_write_page
;
1142 layout
= ecc
->layout
;
1143 nsectors
= mtd
->writesize
/ ecc
->size
;
1145 for (i
= 0; i
< (ecc
->bytes
* nsectors
); i
++)
1146 layout
->eccpos
[i
] = i
;
1148 layout
->oobfree
[0].length
= mtd
->oobsize
- i
;
1149 layout
->oobfree
[0].offset
= i
;
1154 static void sunxi_nand_ecc_cleanup(struct nand_ecc_ctrl
*ecc
)
1156 switch (ecc
->mode
) {
1158 case NAND_ECC_HW_SYNDROME
:
1159 sunxi_nand_hw_common_ecc_ctrl_cleanup(ecc
);
1168 static int sunxi_nand_ecc_init(struct mtd_info
*mtd
, struct nand_ecc_ctrl
*ecc
,
1169 struct device_node
*np
)
1171 struct nand_chip
*nand
= mtd
->priv
;
1175 ecc
->size
= nand
->ecc_step_ds
;
1176 ecc
->strength
= nand
->ecc_strength_ds
;
1179 if (!ecc
->size
|| !ecc
->strength
)
1182 switch (ecc
->mode
) {
1183 case NAND_ECC_SOFT_BCH
:
1186 ret
= sunxi_nand_hw_ecc_ctrl_init(mtd
, ecc
, np
);
1190 case NAND_ECC_HW_SYNDROME
:
1191 ret
= sunxi_nand_hw_syndrome_ecc_ctrl_init(mtd
, ecc
, np
);
1196 ecc
->layout
= kzalloc(sizeof(*ecc
->layout
), GFP_KERNEL
);
1199 ecc
->layout
->oobfree
[0].length
= mtd
->oobsize
;
1209 static int sunxi_nand_chip_init(struct device
*dev
, struct sunxi_nfc
*nfc
,
1210 struct device_node
*np
)
1212 const struct nand_sdr_timings
*timings
;
1213 struct sunxi_nand_chip
*chip
;
1214 struct mtd_part_parser_data ppdata
;
1215 struct mtd_info
*mtd
;
1216 struct nand_chip
*nand
;
1222 if (!of_get_property(np
, "reg", &nsels
))
1225 nsels
/= sizeof(u32
);
1227 dev_err(dev
, "invalid reg property size\n");
1231 chip
= devm_kzalloc(dev
,
1233 (nsels
* sizeof(struct sunxi_nand_chip_sel
)),
1236 dev_err(dev
, "could not allocate chip\n");
1240 chip
->nsels
= nsels
;
1241 chip
->selected
= -1;
1243 for (i
= 0; i
< nsels
; i
++) {
1244 ret
= of_property_read_u32_index(np
, "reg", i
, &tmp
);
1246 dev_err(dev
, "could not retrieve reg property: %d\n",
1251 if (tmp
> NFC_MAX_CS
) {
1253 "invalid reg value: %u (max CS = 7)\n",
1258 if (test_and_set_bit(tmp
, &nfc
->assigned_cs
)) {
1259 dev_err(dev
, "CS %d already assigned\n", tmp
);
1263 chip
->sels
[i
].cs
= tmp
;
1265 if (!of_property_read_u32_index(np
, "allwinner,rb", i
, &tmp
) &&
1267 chip
->sels
[i
].rb
.type
= RB_NATIVE
;
1268 chip
->sels
[i
].rb
.info
.nativeid
= tmp
;
1270 ret
= of_get_named_gpio(np
, "rb-gpios", i
);
1273 chip
->sels
[i
].rb
.type
= RB_GPIO
;
1274 chip
->sels
[i
].rb
.info
.gpio
= tmp
;
1275 ret
= devm_gpio_request(dev
, tmp
, "nand-rb");
1279 ret
= gpio_direction_input(tmp
);
1283 chip
->sels
[i
].rb
.type
= RB_NONE
;
1288 timings
= onfi_async_timing_mode_to_sdr_timings(0);
1289 if (IS_ERR(timings
)) {
1290 ret
= PTR_ERR(timings
);
1292 "could not retrieve timings for ONFI mode 0: %d\n",
1297 ret
= sunxi_nand_chip_set_timings(chip
, timings
);
1299 dev_err(dev
, "could not configure chip timings: %d\n", ret
);
1304 /* Default tR value specified in the ONFI spec (chapter 4.15.1) */
1305 nand
->chip_delay
= 200;
1306 nand
->controller
= &nfc
->controller
;
1308 * Set the ECC mode to the default value in case nothing is specified
1311 nand
->ecc
.mode
= NAND_ECC_HW
;
1312 nand
->flash_node
= np
;
1313 nand
->select_chip
= sunxi_nfc_select_chip
;
1314 nand
->cmd_ctrl
= sunxi_nfc_cmd_ctrl
;
1315 nand
->read_buf
= sunxi_nfc_read_buf
;
1316 nand
->write_buf
= sunxi_nfc_write_buf
;
1317 nand
->read_byte
= sunxi_nfc_read_byte
;
1320 mtd
->dev
.parent
= dev
;
1322 mtd
->owner
= THIS_MODULE
;
1324 ret
= nand_scan_ident(mtd
, nsels
, NULL
);
1328 if (nand
->bbt_options
& NAND_BBT_USE_FLASH
)
1329 nand
->bbt_options
|= NAND_BBT_NO_OOB
;
1331 ret
= sunxi_nand_chip_init_timings(chip
, np
);
1333 dev_err(dev
, "could not configure chip timings: %d\n", ret
);
1337 ret
= sunxi_nand_ecc_init(mtd
, &nand
->ecc
, np
);
1339 dev_err(dev
, "ECC init failed: %d\n", ret
);
1343 ret
= nand_scan_tail(mtd
);
1345 dev_err(dev
, "nand_scan_tail failed: %d\n", ret
);
1349 ppdata
.of_node
= np
;
1350 ret
= mtd_device_parse_register(mtd
, NULL
, &ppdata
, NULL
, 0);
1352 dev_err(dev
, "failed to register mtd device: %d\n", ret
);
1357 list_add_tail(&chip
->node
, &nfc
->chips
);
1362 static int sunxi_nand_chips_init(struct device
*dev
, struct sunxi_nfc
*nfc
)
1364 struct device_node
*np
= dev
->of_node
;
1365 struct device_node
*nand_np
;
1366 int nchips
= of_get_child_count(np
);
1370 dev_err(dev
, "too many NAND chips: %d (max = 8)\n", nchips
);
1374 for_each_child_of_node(np
, nand_np
) {
1375 ret
= sunxi_nand_chip_init(dev
, nfc
, nand_np
);
1383 static void sunxi_nand_chips_cleanup(struct sunxi_nfc
*nfc
)
1385 struct sunxi_nand_chip
*chip
;
1387 while (!list_empty(&nfc
->chips
)) {
1388 chip
= list_first_entry(&nfc
->chips
, struct sunxi_nand_chip
,
1390 nand_release(&chip
->mtd
);
1391 sunxi_nand_ecc_cleanup(&chip
->nand
.ecc
);
1392 list_del(&chip
->node
);
1396 static int sunxi_nfc_probe(struct platform_device
*pdev
)
1398 struct device
*dev
= &pdev
->dev
;
1400 struct sunxi_nfc
*nfc
;
1404 nfc
= devm_kzalloc(dev
, sizeof(*nfc
), GFP_KERNEL
);
1409 spin_lock_init(&nfc
->controller
.lock
);
1410 init_waitqueue_head(&nfc
->controller
.wq
);
1411 INIT_LIST_HEAD(&nfc
->chips
);
1413 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1414 nfc
->regs
= devm_ioremap_resource(dev
, r
);
1415 if (IS_ERR(nfc
->regs
))
1416 return PTR_ERR(nfc
->regs
);
1418 irq
= platform_get_irq(pdev
, 0);
1420 dev_err(dev
, "failed to retrieve irq\n");
1424 nfc
->ahb_clk
= devm_clk_get(dev
, "ahb");
1425 if (IS_ERR(nfc
->ahb_clk
)) {
1426 dev_err(dev
, "failed to retrieve ahb clk\n");
1427 return PTR_ERR(nfc
->ahb_clk
);
1430 ret
= clk_prepare_enable(nfc
->ahb_clk
);
1434 nfc
->mod_clk
= devm_clk_get(dev
, "mod");
1435 if (IS_ERR(nfc
->mod_clk
)) {
1436 dev_err(dev
, "failed to retrieve mod clk\n");
1437 ret
= PTR_ERR(nfc
->mod_clk
);
1438 goto out_ahb_clk_unprepare
;
1441 ret
= clk_prepare_enable(nfc
->mod_clk
);
1443 goto out_ahb_clk_unprepare
;
1445 ret
= sunxi_nfc_rst(nfc
);
1447 goto out_mod_clk_unprepare
;
1449 writel(0, nfc
->regs
+ NFC_REG_INT
);
1450 ret
= devm_request_irq(dev
, irq
, sunxi_nfc_interrupt
,
1451 0, "sunxi-nand", nfc
);
1453 goto out_mod_clk_unprepare
;
1455 platform_set_drvdata(pdev
, nfc
);
1457 ret
= sunxi_nand_chips_init(dev
, nfc
);
1459 dev_err(dev
, "failed to init nand chips\n");
1460 goto out_mod_clk_unprepare
;
1465 out_mod_clk_unprepare
:
1466 clk_disable_unprepare(nfc
->mod_clk
);
1467 out_ahb_clk_unprepare
:
1468 clk_disable_unprepare(nfc
->ahb_clk
);
1473 static int sunxi_nfc_remove(struct platform_device
*pdev
)
1475 struct sunxi_nfc
*nfc
= platform_get_drvdata(pdev
);
1477 sunxi_nand_chips_cleanup(nfc
);
1482 static const struct of_device_id sunxi_nfc_ids
[] = {
1483 { .compatible
= "allwinner,sun4i-a10-nand" },
1486 MODULE_DEVICE_TABLE(of
, sunxi_nfc_ids
);
1488 static struct platform_driver sunxi_nfc_driver
= {
1490 .name
= "sunxi_nand",
1491 .of_match_table
= sunxi_nfc_ids
,
1493 .probe
= sunxi_nfc_probe
,
1494 .remove
= sunxi_nfc_remove
,
1496 module_platform_driver(sunxi_nfc_driver
);
1498 MODULE_LICENSE("GPL v2");
1499 MODULE_AUTHOR("Boris BREZILLON");
1500 MODULE_DESCRIPTION("Allwinner NAND Flash Controller driver");
1501 MODULE_ALIAS("platform:sunxi_nand");