projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'powerpc-4.6-3' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc...
[deliverable/linux.git] / drivers / mtd / nand / lpc32xx_mlc.c
1 /*
2 * Driver for NAND MLC Controller in LPC32xx
3 *
4 * Author: Roland Stigge <stigge@antcom.de>
5 *
6 * Copyright © 2011 WORK Microwave GmbH
7 * Copyright © 2011, 2012 Roland Stigge
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 *
20 * NAND Flash Controller Operation:
21 * - Read: Auto Decode
22 * - Write: Auto Encode
23 * - Tested Page Sizes: 2048, 4096
24 */
25
26 #include <linux/slab.h>
27 #include <linux/module.h>
28 #include <linux/platform_device.h>
29 #include <linux/mtd/mtd.h>
30 #include <linux/mtd/nand.h>
31 #include <linux/mtd/partitions.h>
32 #include <linux/clk.h>
33 #include <linux/err.h>
34 #include <linux/delay.h>
35 #include <linux/completion.h>
36 #include <linux/interrupt.h>
37 #include <linux/of.h>
38 #include <linux/of_mtd.h>
39 #include <linux/of_gpio.h>
40 #include <linux/mtd/lpc32xx_mlc.h>
41 #include <linux/io.h>
42 #include <linux/mm.h>
43 #include <linux/dma-mapping.h>
44 #include <linux/dmaengine.h>
45 #include <linux/mtd/nand_ecc.h>
46
47 #define DRV_NAME "lpc32xx_mlc"
48
49 /**********************************************************************
50 * MLC NAND controller register offsets
51 **********************************************************************/
52
53 #define MLC_BUFF(x) (x + 0x00000)
54 #define MLC_DATA(x) (x + 0x08000)
55 #define MLC_CMD(x) (x + 0x10000)
56 #define MLC_ADDR(x) (x + 0x10004)
57 #define MLC_ECC_ENC_REG(x) (x + 0x10008)
58 #define MLC_ECC_DEC_REG(x) (x + 0x1000C)
59 #define MLC_ECC_AUTO_ENC_REG(x) (x + 0x10010)
60 #define MLC_ECC_AUTO_DEC_REG(x) (x + 0x10014)
61 #define MLC_RPR(x) (x + 0x10018)
62 #define MLC_WPR(x) (x + 0x1001C)
63 #define MLC_RUBP(x) (x + 0x10020)
64 #define MLC_ROBP(x) (x + 0x10024)
65 #define MLC_SW_WP_ADD_LOW(x) (x + 0x10028)
66 #define MLC_SW_WP_ADD_HIG(x) (x + 0x1002C)
67 #define MLC_ICR(x) (x + 0x10030)
68 #define MLC_TIME_REG(x) (x + 0x10034)
69 #define MLC_IRQ_MR(x) (x + 0x10038)
70 #define MLC_IRQ_SR(x) (x + 0x1003C)
71 #define MLC_LOCK_PR(x) (x + 0x10044)
72 #define MLC_ISR(x) (x + 0x10048)
73 #define MLC_CEH(x) (x + 0x1004C)
74
75 /**********************************************************************
76 * MLC_CMD bit definitions
77 **********************************************************************/
78 #define MLCCMD_RESET 0xFF
79
80 /**********************************************************************
81 * MLC_ICR bit definitions
82 **********************************************************************/
83 #define MLCICR_WPROT (1 << 3)
84 #define MLCICR_LARGEBLOCK (1 << 2)
85 #define MLCICR_LONGADDR (1 << 1)
86 #define MLCICR_16BIT (1 << 0) /* unsupported by LPC32x0! */
87
88 /**********************************************************************
89 * MLC_TIME_REG bit definitions
90 **********************************************************************/
91 #define MLCTIMEREG_TCEA_DELAY(n) (((n) & 0x03) << 24)
92 #define MLCTIMEREG_BUSY_DELAY(n) (((n) & 0x1F) << 19)
93 #define MLCTIMEREG_NAND_TA(n) (((n) & 0x07) << 16)
94 #define MLCTIMEREG_RD_HIGH(n) (((n) & 0x0F) << 12)
95 #define MLCTIMEREG_RD_LOW(n) (((n) & 0x0F) << 8)
96 #define MLCTIMEREG_WR_HIGH(n) (((n) & 0x0F) << 4)
97 #define MLCTIMEREG_WR_LOW(n) (((n) & 0x0F) << 0)
98
99 /**********************************************************************
100 * MLC_IRQ_MR and MLC_IRQ_SR bit definitions
101 **********************************************************************/
102 #define MLCIRQ_NAND_READY (1 << 5)
103 #define MLCIRQ_CONTROLLER_READY (1 << 4)
104 #define MLCIRQ_DECODE_FAILURE (1 << 3)
105 #define MLCIRQ_DECODE_ERROR (1 << 2)
106 #define MLCIRQ_ECC_READY (1 << 1)
107 #define MLCIRQ_WRPROT_FAULT (1 << 0)
108
109 /**********************************************************************
110 * MLC_LOCK_PR bit definitions
111 **********************************************************************/
112 #define MLCLOCKPR_MAGIC 0xA25E
113
114 /**********************************************************************
115 * MLC_ISR bit definitions
116 **********************************************************************/
117 #define MLCISR_DECODER_FAILURE (1 << 6)
118 #define MLCISR_ERRORS ((1 << 4) | (1 << 5))
119 #define MLCISR_ERRORS_DETECTED (1 << 3)
120 #define MLCISR_ECC_READY (1 << 2)
121 #define MLCISR_CONTROLLER_READY (1 << 1)
122 #define MLCISR_NAND_READY (1 << 0)
123
124 /**********************************************************************
125 * MLC_CEH bit definitions
126 **********************************************************************/
127 #define MLCCEH_NORMAL (1 << 0)
128
129 struct lpc32xx_nand_cfg_mlc {
130 uint32_t tcea_delay;
131 uint32_t busy_delay;
132 uint32_t nand_ta;
133 uint32_t rd_high;
134 uint32_t rd_low;
135 uint32_t wr_high;
136 uint32_t wr_low;
137 int wp_gpio;
138 struct mtd_partition *parts;
139 unsigned num_parts;
140 };
141
142 static struct nand_ecclayout lpc32xx_nand_oob = {
143 .eccbytes = 40,
144 .eccpos = { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
145 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
146 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
147 54, 55, 56, 57, 58, 59, 60, 61, 62, 63 },
148 .oobfree = {
149 { .offset = 0,
150 .length = 6, },
151 { .offset = 16,
152 .length = 6, },
153 { .offset = 32,
154 .length = 6, },
155 { .offset = 48,
156 .length = 6, },
157 },
158 };
159
160 static struct nand_bbt_descr lpc32xx_nand_bbt = {
161 .options = NAND_BBT_ABSPAGE | NAND_BBT_2BIT | NAND_BBT_NO_OOB |
162 NAND_BBT_WRITE,
163 .pages = { 524224, 0, 0, 0, 0, 0, 0, 0 },
164 };
165
166 static struct nand_bbt_descr lpc32xx_nand_bbt_mirror = {
167 .options = NAND_BBT_ABSPAGE | NAND_BBT_2BIT | NAND_BBT_NO_OOB |
168 NAND_BBT_WRITE,
169 .pages = { 524160, 0, 0, 0, 0, 0, 0, 0 },
170 };
171
172 struct lpc32xx_nand_host {
173 struct nand_chip nand_chip;
174 struct lpc32xx_mlc_platform_data *pdata;
175 struct clk *clk;
176 void __iomem *io_base;
177 int irq;
178 struct lpc32xx_nand_cfg_mlc *ncfg;
179 struct completion comp_nand;
180 struct completion comp_controller;
181 uint32_t llptr;
182 /*
183 * Physical addresses of ECC buffer, DMA data buffers, OOB data buffer
184 */
185 dma_addr_t oob_buf_phy;
186 /*
187 * Virtual addresses of ECC buffer, DMA data buffers, OOB data buffer
188 */
189 uint8_t *oob_buf;
190 /* Physical address of DMA base address */
191 dma_addr_t io_base_phy;
192
193 struct completion comp_dma;
194 struct dma_chan *dma_chan;
195 struct dma_slave_config dma_slave_config;
196 struct scatterlist sgl;
197 uint8_t *dma_buf;
198 uint8_t *dummy_buf;
199 int mlcsubpages; /* number of 512bytes-subpages */
200 };
201
202 /*
203 * Activate/Deactivate DMA Operation:
204 *
205 * Using the PL080 DMA Controller for transferring the 512 byte subpages
206 * instead of doing readl() / writel() in a loop slows it down significantly.
207 * Measurements via getnstimeofday() upon 512 byte subpage reads reveal:
208 *
209 * - readl() of 128 x 32 bits in a loop: ~20us
210 * - DMA read of 512 bytes (32 bit, 4...128 words bursts): ~60us
211 * - DMA read of 512 bytes (32 bit, no bursts): ~100us
212 *
213 * This applies to the transfer itself. In the DMA case: only the
214 * wait_for_completion() (DMA setup _not_ included).
215 *
216 * Note that the 512 bytes subpage transfer is done directly from/to a
217 * FIFO/buffer inside the NAND controller. Most of the time (~400-800us for a
218 * 2048 bytes page) is spent waiting for the NAND IRQ, anyway. (The NAND
219 * controller transferring data between its internal buffer to/from the NAND
220 * chip.)
221 *
222 * Therefore, using the PL080 DMA is disabled by default, for now.
223 *
224 */
225 static int use_dma;
226
227 static void lpc32xx_nand_setup(struct lpc32xx_nand_host *host)
228 {
229 uint32_t clkrate, tmp;
230
231 /* Reset MLC controller */
232 writel(MLCCMD_RESET, MLC_CMD(host->io_base));
233 udelay(1000);
234
235 /* Get base clock for MLC block */
236 clkrate = clk_get_rate(host->clk);
237 if (clkrate == 0)
238 clkrate = 104000000;
239
240 /* Unlock MLC_ICR
241 * (among others, will be locked again automatically) */
242 writew(MLCLOCKPR_MAGIC, MLC_LOCK_PR(host->io_base));
243
244 /* Configure MLC Controller: Large Block, 5 Byte Address */
245 tmp = MLCICR_LARGEBLOCK | MLCICR_LONGADDR;
246 writel(tmp, MLC_ICR(host->io_base));
247
248 /* Unlock MLC_TIME_REG
249 * (among others, will be locked again automatically) */
250 writew(MLCLOCKPR_MAGIC, MLC_LOCK_PR(host->io_base));
251
252 /* Compute clock setup values, see LPC and NAND manual */
253 tmp = 0;
254 tmp |= MLCTIMEREG_TCEA_DELAY(clkrate / host->ncfg->tcea_delay + 1);
255 tmp |= MLCTIMEREG_BUSY_DELAY(clkrate / host->ncfg->busy_delay + 1);
256 tmp |= MLCTIMEREG_NAND_TA(clkrate / host->ncfg->nand_ta + 1);
257 tmp |= MLCTIMEREG_RD_HIGH(clkrate / host->ncfg->rd_high + 1);
258 tmp |= MLCTIMEREG_RD_LOW(clkrate / host->ncfg->rd_low);
259 tmp |= MLCTIMEREG_WR_HIGH(clkrate / host->ncfg->wr_high + 1);
260 tmp |= MLCTIMEREG_WR_LOW(clkrate / host->ncfg->wr_low);
261 writel(tmp, MLC_TIME_REG(host->io_base));
262
263 /* Enable IRQ for CONTROLLER_READY and NAND_READY */
264 writeb(MLCIRQ_CONTROLLER_READY | MLCIRQ_NAND_READY,
265 MLC_IRQ_MR(host->io_base));
266
267 /* Normal nCE operation: nCE controlled by controller */
268 writel(MLCCEH_NORMAL, MLC_CEH(host->io_base));
269 }
270
271 /*
272 * Hardware specific access to control lines
273 */
274 static void lpc32xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd,
275 unsigned int ctrl)
276 {
277 struct nand_chip *nand_chip = mtd_to_nand(mtd);
278 struct lpc32xx_nand_host *host = nand_get_controller_data(nand_chip);
279
280 if (cmd != NAND_CMD_NONE) {
281 if (ctrl & NAND_CLE)
282 writel(cmd, MLC_CMD(host->io_base));
283 else
284 writel(cmd, MLC_ADDR(host->io_base));
285 }
286 }
287
288 /*
289 * Read Device Ready (NAND device _and_ controller ready)
290 */
291 static int lpc32xx_nand_device_ready(struct mtd_info *mtd)
292 {
293 struct nand_chip *nand_chip = mtd_to_nand(mtd);
294 struct lpc32xx_nand_host *host = nand_get_controller_data(nand_chip);
295
296 if ((readb(MLC_ISR(host->io_base)) &
297 (MLCISR_CONTROLLER_READY | MLCISR_NAND_READY)) ==
298 (MLCISR_CONTROLLER_READY | MLCISR_NAND_READY))
299 return 1;
300
301 return 0;
302 }
303
304 static irqreturn_t lpc3xxx_nand_irq(int irq, struct lpc32xx_nand_host *host)
305 {
306 uint8_t sr;
307
308 /* Clear interrupt flag by reading status */
309 sr = readb(MLC_IRQ_SR(host->io_base));
310 if (sr & MLCIRQ_NAND_READY)
311 complete(&host->comp_nand);
312 if (sr & MLCIRQ_CONTROLLER_READY)
313 complete(&host->comp_controller);
314
315 return IRQ_HANDLED;
316 }
317
318 static int lpc32xx_waitfunc_nand(struct mtd_info *mtd, struct nand_chip *chip)
319 {
320 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
321
322 if (readb(MLC_ISR(host->io_base)) & MLCISR_NAND_READY)
323 goto exit;
324
325 wait_for_completion(&host->comp_nand);
326
327 while (!(readb(MLC_ISR(host->io_base)) & MLCISR_NAND_READY)) {
328 /* Seems to be delayed sometimes by controller */
329 dev_dbg(&mtd->dev, "Warning: NAND not ready.\n");
330 cpu_relax();
331 }
332
333 exit:
334 return NAND_STATUS_READY;
335 }
336
337 static int lpc32xx_waitfunc_controller(struct mtd_info *mtd,
338 struct nand_chip *chip)
339 {
340 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
341
342 if (readb(MLC_ISR(host->io_base)) & MLCISR_CONTROLLER_READY)
343 goto exit;
344
345 wait_for_completion(&host->comp_controller);
346
347 while (!(readb(MLC_ISR(host->io_base)) &
348 MLCISR_CONTROLLER_READY)) {
349 dev_dbg(&mtd->dev, "Warning: Controller not ready.\n");
350 cpu_relax();
351 }
352
353 exit:
354 return NAND_STATUS_READY;
355 }
356
357 static int lpc32xx_waitfunc(struct mtd_info *mtd, struct nand_chip *chip)
358 {
359 lpc32xx_waitfunc_nand(mtd, chip);
360 lpc32xx_waitfunc_controller(mtd, chip);
361
362 return NAND_STATUS_READY;
363 }
364
365 /*
366 * Enable NAND write protect
367 */
368 static void lpc32xx_wp_enable(struct lpc32xx_nand_host *host)
369 {
370 if (gpio_is_valid(host->ncfg->wp_gpio))
371 gpio_set_value(host->ncfg->wp_gpio, 0);
372 }
373
374 /*
375 * Disable NAND write protect
376 */
377 static void lpc32xx_wp_disable(struct lpc32xx_nand_host *host)
378 {
379 if (gpio_is_valid(host->ncfg->wp_gpio))
380 gpio_set_value(host->ncfg->wp_gpio, 1);
381 }
382
383 static void lpc32xx_dma_complete_func(void *completion)
384 {
385 complete(completion);
386 }
387
388 static int lpc32xx_xmit_dma(struct mtd_info *mtd, void *mem, int len,
389 enum dma_transfer_direction dir)
390 {
391 struct nand_chip *chip = mtd_to_nand(mtd);
392 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
393 struct dma_async_tx_descriptor *desc;
394 int flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT;
395 int res;
396
397 sg_init_one(&host->sgl, mem, len);
398
399 res = dma_map_sg(host->dma_chan->device->dev, &host->sgl, 1,
400 DMA_BIDIRECTIONAL);
401 if (res != 1) {
402 dev_err(mtd->dev.parent, "Failed to map sg list\n");
403 return -ENXIO;
404 }
405 desc = dmaengine_prep_slave_sg(host->dma_chan, &host->sgl, 1, dir,
406 flags);
407 if (!desc) {
408 dev_err(mtd->dev.parent, "Failed to prepare slave sg\n");
409 goto out1;
410 }
411
412 init_completion(&host->comp_dma);
413 desc->callback = lpc32xx_dma_complete_func;
414 desc->callback_param = &host->comp_dma;
415
416 dmaengine_submit(desc);
417 dma_async_issue_pending(host->dma_chan);
418
419 wait_for_completion_timeout(&host->comp_dma, msecs_to_jiffies(1000));
420
421 dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
422 DMA_BIDIRECTIONAL);
423 return 0;
424 out1:
425 dma_unmap_sg(host->dma_chan->device->dev, &host->sgl, 1,
426 DMA_BIDIRECTIONAL);
427 return -ENXIO;
428 }
429
430 static int lpc32xx_read_page(struct mtd_info *mtd, struct nand_chip *chip,
431 uint8_t *buf, int oob_required, int page)
432 {
433 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
434 int i, j;
435 uint8_t *oobbuf = chip->oob_poi;
436 uint32_t mlc_isr;
437 int res;
438 uint8_t *dma_buf;
439 bool dma_mapped;
440
441 if ((void *)buf <= high_memory) {
442 dma_buf = buf;
443 dma_mapped = true;
444 } else {
445 dma_buf = host->dma_buf;
446 dma_mapped = false;
447 }
448
449 /* Writing Command and Address */
450 chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
451
452 /* For all sub-pages */
453 for (i = 0; i < host->mlcsubpages; i++) {
454 /* Start Auto Decode Command */
455 writeb(0x00, MLC_ECC_AUTO_DEC_REG(host->io_base));
456
457 /* Wait for Controller Ready */
458 lpc32xx_waitfunc_controller(mtd, chip);
459
460 /* Check ECC Error status */
461 mlc_isr = readl(MLC_ISR(host->io_base));
462 if (mlc_isr & MLCISR_DECODER_FAILURE) {
463 mtd->ecc_stats.failed++;
464 dev_warn(&mtd->dev, "%s: DECODER_FAILURE\n", __func__);
465 } else if (mlc_isr & MLCISR_ERRORS_DETECTED) {
466 mtd->ecc_stats.corrected += ((mlc_isr >> 4) & 0x3) + 1;
467 }
468
469 /* Read 512 + 16 Bytes */
470 if (use_dma) {
471 res = lpc32xx_xmit_dma(mtd, dma_buf + i * 512, 512,
472 DMA_DEV_TO_MEM);
473 if (res)
474 return res;
475 } else {
476 for (j = 0; j < (512 >> 2); j++) {
477 *((uint32_t *)(buf)) =
478 readl(MLC_BUFF(host->io_base));
479 buf += 4;
480 }
481 }
482 for (j = 0; j < (16 >> 2); j++) {
483 *((uint32_t *)(oobbuf)) =
484 readl(MLC_BUFF(host->io_base));
485 oobbuf += 4;
486 }
487 }
488
489 if (use_dma && !dma_mapped)
490 memcpy(buf, dma_buf, mtd->writesize);
491
492 return 0;
493 }
494
495 static int lpc32xx_write_page_lowlevel(struct mtd_info *mtd,
496 struct nand_chip *chip,
497 const uint8_t *buf, int oob_required,
498 int page)
499 {
500 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
501 const uint8_t *oobbuf = chip->oob_poi;
502 uint8_t *dma_buf = (uint8_t *)buf;
503 int res;
504 int i, j;
505
506 if (use_dma && (void *)buf >= high_memory) {
507 dma_buf = host->dma_buf;
508 memcpy(dma_buf, buf, mtd->writesize);
509 }
510
511 for (i = 0; i < host->mlcsubpages; i++) {
512 /* Start Encode */
513 writeb(0x00, MLC_ECC_ENC_REG(host->io_base));
514
515 /* Write 512 + 6 Bytes to Buffer */
516 if (use_dma) {
517 res = lpc32xx_xmit_dma(mtd, dma_buf + i * 512, 512,
518 DMA_MEM_TO_DEV);
519 if (res)
520 return res;
521 } else {
522 for (j = 0; j < (512 >> 2); j++) {
523 writel(*((uint32_t *)(buf)),
524 MLC_BUFF(host->io_base));
525 buf += 4;
526 }
527 }
528 writel(*((uint32_t *)(oobbuf)), MLC_BUFF(host->io_base));
529 oobbuf += 4;
530 writew(*((uint16_t *)(oobbuf)), MLC_BUFF(host->io_base));
531 oobbuf += 12;
532
533 /* Auto Encode w/ Bit 8 = 0 (see LPC MLC Controller manual) */
534 writeb(0x00, MLC_ECC_AUTO_ENC_REG(host->io_base));
535
536 /* Wait for Controller Ready */
537 lpc32xx_waitfunc_controller(mtd, chip);
538 }
539 return 0;
540 }
541
542 static int lpc32xx_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
543 int page)
544 {
545 struct lpc32xx_nand_host *host = nand_get_controller_data(chip);
546
547 /* Read whole page - necessary with MLC controller! */
548 lpc32xx_read_page(mtd, chip, host->dummy_buf, 1, page);
549
550 return 0;
551 }
552
553 static int lpc32xx_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
554 int page)
555 {
556 /* None, write_oob conflicts with the automatic LPC MLC ECC decoder! */
557 return 0;
558 }
559
560 /* Prepares MLC for transfers with H/W ECC enabled: always enabled anyway */
561 static void lpc32xx_ecc_enable(struct mtd_info *mtd, int mode)
562 {
563 /* Always enabled! */
564 }
565
566 static int lpc32xx_dma_setup(struct lpc32xx_nand_host *host)
567 {
568 struct mtd_info *mtd = nand_to_mtd(&host->nand_chip);
569 dma_cap_mask_t mask;
570
571 if (!host->pdata || !host->pdata->dma_filter) {
572 dev_err(mtd->dev.parent, "no DMA platform data\n");
573 return -ENOENT;
574 }
575
576 dma_cap_zero(mask);
577 dma_cap_set(DMA_SLAVE, mask);
578 host->dma_chan = dma_request_channel(mask, host->pdata->dma_filter,
579 "nand-mlc");
580 if (!host->dma_chan) {
581 dev_err(mtd->dev.parent, "Failed to request DMA channel\n");
582 return -EBUSY;
583 }
584
585 /*
586 * Set direction to a sensible value even if the dmaengine driver
587 * should ignore it. With the default (DMA_MEM_TO_MEM), the amba-pl08x
588 * driver criticizes it as "alien transfer direction".
589 */
590 host->dma_slave_config.direction = DMA_DEV_TO_MEM;
591 host->dma_slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
592 host->dma_slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
593 host->dma_slave_config.src_maxburst = 128;
594 host->dma_slave_config.dst_maxburst = 128;
595 /* DMA controller does flow control: */
596 host->dma_slave_config.device_fc = false;
597 host->dma_slave_config.src_addr = MLC_BUFF(host->io_base_phy);
598 host->dma_slave_config.dst_addr = MLC_BUFF(host->io_base_phy);
599 if (dmaengine_slave_config(host->dma_chan, &host->dma_slave_config)) {
600 dev_err(mtd->dev.parent, "Failed to setup DMA slave\n");
601 goto out1;
602 }
603
604 return 0;
605 out1:
606 dma_release_channel(host->dma_chan);
607 return -ENXIO;
608 }
609
610 static struct lpc32xx_nand_cfg_mlc *lpc32xx_parse_dt(struct device *dev)
611 {
612 struct lpc32xx_nand_cfg_mlc *ncfg;
613 struct device_node *np = dev->of_node;
614
615 ncfg = devm_kzalloc(dev, sizeof(*ncfg), GFP_KERNEL);
616 if (!ncfg)
617 return NULL;
618
619 of_property_read_u32(np, "nxp,tcea-delay", &ncfg->tcea_delay);
620 of_property_read_u32(np, "nxp,busy-delay", &ncfg->busy_delay);
621 of_property_read_u32(np, "nxp,nand-ta", &ncfg->nand_ta);
622 of_property_read_u32(np, "nxp,rd-high", &ncfg->rd_high);
623 of_property_read_u32(np, "nxp,rd-low", &ncfg->rd_low);
624 of_property_read_u32(np, "nxp,wr-high", &ncfg->wr_high);
625 of_property_read_u32(np, "nxp,wr-low", &ncfg->wr_low);
626
627 if (!ncfg->tcea_delay || !ncfg->busy_delay || !ncfg->nand_ta ||
628 !ncfg->rd_high || !ncfg->rd_low || !ncfg->wr_high ||
629 !ncfg->wr_low) {
630 dev_err(dev, "chip parameters not specified correctly\n");
631 return NULL;
632 }
633
634 ncfg->wp_gpio = of_get_named_gpio(np, "gpios", 0);
635
636 return ncfg;
637 }
638
639 /*
640 * Probe for NAND controller
641 */
642 static int lpc32xx_nand_probe(struct platform_device *pdev)
643 {
644 struct lpc32xx_nand_host *host;
645 struct mtd_info *mtd;
646 struct nand_chip *nand_chip;
647 struct resource *rc;
648 int res;
649
650 /* Allocate memory for the device structure (and zero it) */
651 host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL);
652 if (!host)
653 return -ENOMEM;
654
655 rc = platform_get_resource(pdev, IORESOURCE_MEM, 0);
656 host->io_base = devm_ioremap_resource(&pdev->dev, rc);
657 if (IS_ERR(host->io_base))
658 return PTR_ERR(host->io_base);
659
660 host->io_base_phy = rc->start;
661
662 nand_chip = &host->nand_chip;
663 mtd = nand_to_mtd(nand_chip);
664 if (pdev->dev.of_node)
665 host->ncfg = lpc32xx_parse_dt(&pdev->dev);
666 if (!host->ncfg) {
667 dev_err(&pdev->dev,
668 "Missing or bad NAND config from device tree\n");
669 return -ENOENT;
670 }
671 if (host->ncfg->wp_gpio == -EPROBE_DEFER)
672 return -EPROBE_DEFER;
673 if (gpio_is_valid(host->ncfg->wp_gpio) &&
674 gpio_request(host->ncfg->wp_gpio, "NAND WP")) {
675 dev_err(&pdev->dev, "GPIO not available\n");
676 return -EBUSY;
677 }
678 lpc32xx_wp_disable(host);
679
680 host->pdata = dev_get_platdata(&pdev->dev);
681
682 /* link the private data structures */
683 nand_set_controller_data(nand_chip, host);
684 nand_set_flash_node(nand_chip, pdev->dev.of_node);
685 mtd->dev.parent = &pdev->dev;
686
687 /* Get NAND clock */
688 host->clk = clk_get(&pdev->dev, NULL);
689 if (IS_ERR(host->clk)) {
690 dev_err(&pdev->dev, "Clock initialization failure\n");
691 res = -ENOENT;
692 goto err_exit1;
693 }
694 clk_prepare_enable(host->clk);
695
696 nand_chip->cmd_ctrl = lpc32xx_nand_cmd_ctrl;
697 nand_chip->dev_ready = lpc32xx_nand_device_ready;
698 nand_chip->chip_delay = 25; /* us */
699 nand_chip->IO_ADDR_R = MLC_DATA(host->io_base);
700 nand_chip->IO_ADDR_W = MLC_DATA(host->io_base);
701
702 /* Init NAND controller */
703 lpc32xx_nand_setup(host);
704
705 platform_set_drvdata(pdev, host);
706
707 /* Initialize function pointers */
708 nand_chip->ecc.hwctl = lpc32xx_ecc_enable;
709 nand_chip->ecc.read_page_raw = lpc32xx_read_page;
710 nand_chip->ecc.read_page = lpc32xx_read_page;
711 nand_chip->ecc.write_page_raw = lpc32xx_write_page_lowlevel;
712 nand_chip->ecc.write_page = lpc32xx_write_page_lowlevel;
713 nand_chip->ecc.write_oob = lpc32xx_write_oob;
714 nand_chip->ecc.read_oob = lpc32xx_read_oob;
715 nand_chip->ecc.strength = 4;
716 nand_chip->waitfunc = lpc32xx_waitfunc;
717
718 nand_chip->options = NAND_NO_SUBPAGE_WRITE;
719 nand_chip->bbt_options = NAND_BBT_USE_FLASH | NAND_BBT_NO_OOB;
720 nand_chip->bbt_td = &lpc32xx_nand_bbt;
721 nand_chip->bbt_md = &lpc32xx_nand_bbt_mirror;
722
723 if (use_dma) {
724 res = lpc32xx_dma_setup(host);
725 if (res) {
726 res = -EIO;
727 goto err_exit2;
728 }
729 }
730
731 /*
732 * Scan to find existance of the device and
733 * Get the type of NAND device SMALL block or LARGE block
734 */
735 if (nand_scan_ident(mtd, 1, NULL)) {
736 res = -ENXIO;
737 goto err_exit3;
738 }
739
740 host->dma_buf = devm_kzalloc(&pdev->dev, mtd->writesize, GFP_KERNEL);
741 if (!host->dma_buf) {
742 res = -ENOMEM;
743 goto err_exit3;
744 }
745
746 host->dummy_buf = devm_kzalloc(&pdev->dev, mtd->writesize, GFP_KERNEL);
747 if (!host->dummy_buf) {
748 res = -ENOMEM;
749 goto err_exit3;
750 }
751
752 nand_chip->ecc.mode = NAND_ECC_HW;
753 nand_chip->ecc.size = 512;
754 nand_chip->ecc.layout = &lpc32xx_nand_oob;
755 host->mlcsubpages = mtd->writesize / 512;
756
757 /* initially clear interrupt status */
758 readb(MLC_IRQ_SR(host->io_base));
759
760 init_completion(&host->comp_nand);
761 init_completion(&host->comp_controller);
762
763 host->irq = platform_get_irq(pdev, 0);
764 if ((host->irq < 0) || (host->irq >= NR_IRQS)) {
765 dev_err(&pdev->dev, "failed to get platform irq\n");
766 res = -EINVAL;
767 goto err_exit3;
768 }
769
770 if (request_irq(host->irq, (irq_handler_t)&lpc3xxx_nand_irq,
771 IRQF_TRIGGER_HIGH, DRV_NAME, host)) {
772 dev_err(&pdev->dev, "Error requesting NAND IRQ\n");
773 res = -ENXIO;
774 goto err_exit3;
775 }
776
777 /*
778 * Fills out all the uninitialized function pointers with the defaults
779 * And scans for a bad block table if appropriate.
780 */
781 if (nand_scan_tail(mtd)) {
782 res = -ENXIO;
783 goto err_exit4;
784 }
785
786 mtd->name = DRV_NAME;
787
788 res = mtd_device_register(mtd, host->ncfg->parts,
789 host->ncfg->num_parts);
790 if (!res)
791 return res;
792
793 nand_release(mtd);
794
795 err_exit4:
796 free_irq(host->irq, host);
797 err_exit3:
798 if (use_dma)
799 dma_release_channel(host->dma_chan);
800 err_exit2:
801 clk_disable_unprepare(host->clk);
802 clk_put(host->clk);
803 err_exit1:
804 lpc32xx_wp_enable(host);
805 gpio_free(host->ncfg->wp_gpio);
806
807 return res;
808 }
809
810 /*
811 * Remove NAND device
812 */
813 static int lpc32xx_nand_remove(struct platform_device *pdev)
814 {
815 struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
816 struct mtd_info *mtd = nand_to_mtd(&host->nand_chip);
817
818 nand_release(mtd);
819 free_irq(host->irq, host);
820 if (use_dma)
821 dma_release_channel(host->dma_chan);
822
823 clk_disable_unprepare(host->clk);
824 clk_put(host->clk);
825
826 lpc32xx_wp_enable(host);
827 gpio_free(host->ncfg->wp_gpio);
828
829 return 0;
830 }
831
832 #ifdef CONFIG_PM
833 static int lpc32xx_nand_resume(struct platform_device *pdev)
834 {
835 struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
836
837 /* Re-enable NAND clock */
838 clk_prepare_enable(host->clk);
839
840 /* Fresh init of NAND controller */
841 lpc32xx_nand_setup(host);
842
843 /* Disable write protect */
844 lpc32xx_wp_disable(host);
845
846 return 0;
847 }
848
849 static int lpc32xx_nand_suspend(struct platform_device *pdev, pm_message_t pm)
850 {
851 struct lpc32xx_nand_host *host = platform_get_drvdata(pdev);
852
853 /* Enable write protect for safety */
854 lpc32xx_wp_enable(host);
855
856 /* Disable clock */
857 clk_disable_unprepare(host->clk);
858 return 0;
859 }
860
861 #else
862 #define lpc32xx_nand_resume NULL
863 #define lpc32xx_nand_suspend NULL
864 #endif
865
866 static const struct of_device_id lpc32xx_nand_match[] = {
867 { .compatible = "nxp,lpc3220-mlc" },
868 { /* sentinel */ },
869 };
870 MODULE_DEVICE_TABLE(of, lpc32xx_nand_match);
871
872 static struct platform_driver lpc32xx_nand_driver = {
873 .probe = lpc32xx_nand_probe,
874 .remove = lpc32xx_nand_remove,
875 .resume = lpc32xx_nand_resume,
876 .suspend = lpc32xx_nand_suspend,
877 .driver = {
878 .name = DRV_NAME,
879 .of_match_table = lpc32xx_nand_match,
880 },
881 };
882
883 module_platform_driver(lpc32xx_nand_driver);
884
885 MODULE_LICENSE("GPL");
886 MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
887 MODULE_DESCRIPTION("NAND driver for the NXP LPC32XX MLC controller");
Linux kernel - Deliverables
This page took 0.051675 seconds and 5 git commands to generate.