mtd: nand: Pass the CS line to ->setup_data_interface()
[karo-tx-linux.git] / drivers / mtd / nand / tango_nand.c
1 /*
2  * Copyright (C) 2016 Sigma Designs
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * version 2 as published by the Free Software Foundation.
7  */
8
9 #include <linux/io.h>
10 #include <linux/of.h>
11 #include <linux/clk.h>
12 #include <linux/iopoll.h>
13 #include <linux/module.h>
14 #include <linux/mtd/nand.h>
15 #include <linux/dmaengine.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/platform_device.h>
18
19 /* Offsets relative to chip->base */
20 #define PBUS_CMD        0
21 #define PBUS_ADDR       4
22 #define PBUS_DATA       8
23
24 /* Offsets relative to reg_base */
25 #define NFC_STATUS      0x00
26 #define NFC_FLASH_CMD   0x04
27 #define NFC_DEVICE_CFG  0x08
28 #define NFC_TIMING1     0x0c
29 #define NFC_TIMING2     0x10
30 #define NFC_XFER_CFG    0x14
31 #define NFC_PKT_0_CFG   0x18
32 #define NFC_PKT_N_CFG   0x1c
33 #define NFC_BB_CFG      0x20
34 #define NFC_ADDR_PAGE   0x24
35 #define NFC_ADDR_OFFSET 0x28
36 #define NFC_XFER_STATUS 0x2c
37
38 /* NFC_STATUS values */
39 #define CMD_READY       BIT(31)
40
41 /* NFC_FLASH_CMD values */
42 #define NFC_READ        1
43 #define NFC_WRITE       2
44
45 /* NFC_XFER_STATUS values */
46 #define PAGE_IS_EMPTY   BIT(16)
47
48 /* Offsets relative to mem_base */
49 #define METADATA        0x000
50 #define ERROR_REPORT    0x1c0
51
52 /*
53  * Error reports are split in two bytes:
54  * byte 0 for the first packet in the page (PKT_0)
55  * byte 1 for other packets in the page (PKT_N, for N > 0)
56  * ERR_COUNT_PKT_N is the max error count over all but the first packet.
57  */
58 #define DECODE_OK_PKT_0(v)      ((v) & BIT(7))
59 #define DECODE_OK_PKT_N(v)      ((v) & BIT(15))
60 #define ERR_COUNT_PKT_0(v)      (((v) >> 0) & 0x3f)
61 #define ERR_COUNT_PKT_N(v)      (((v) >> 8) & 0x3f)
62
63 /* Offsets relative to pbus_base */
64 #define PBUS_CS_CTRL    0x83c
65 #define PBUS_PAD_MODE   0x8f0
66
67 /* PBUS_CS_CTRL values */
68 #define PBUS_IORDY      BIT(31)
69
70 /*
71  * PBUS_PAD_MODE values
72  * In raw mode, the driver communicates directly with the NAND chips.
73  * In NFC mode, the NAND Flash controller manages the communication.
74  * We use NFC mode for read and write; raw mode for everything else.
75  */
76 #define MODE_RAW        0
77 #define MODE_NFC        BIT(31)
78
79 #define METADATA_SIZE   4
80 #define BBM_SIZE        6
81 #define FIELD_ORDER     15
82
83 #define MAX_CS          4
84
85 struct tango_nfc {
86         struct nand_hw_control hw;
87         void __iomem *reg_base;
88         void __iomem *mem_base;
89         void __iomem *pbus_base;
90         struct tango_chip *chips[MAX_CS];
91         struct dma_chan *chan;
92         int freq_kHz;
93 };
94
95 #define to_tango_nfc(ptr) container_of(ptr, struct tango_nfc, hw)
96
97 struct tango_chip {
98         struct nand_chip nand_chip;
99         void __iomem *base;
100         u32 timing1;
101         u32 timing2;
102         u32 xfer_cfg;
103         u32 pkt_0_cfg;
104         u32 pkt_n_cfg;
105         u32 bb_cfg;
106 };
107
108 #define to_tango_chip(ptr) container_of(ptr, struct tango_chip, nand_chip)
109
110 #define XFER_CFG(cs, page_count, steps, metadata_size)  \
111         ((cs) << 24 | (page_count) << 16 | (steps) << 8 | (metadata_size))
112
113 #define PKT_CFG(size, strength) ((size) << 16 | (strength))
114
115 #define BB_CFG(bb_offset, bb_size) ((bb_offset) << 16 | (bb_size))
116
117 #define TIMING(t0, t1, t2, t3) ((t0) << 24 | (t1) << 16 | (t2) << 8 | (t3))
118
119 static void tango_cmd_ctrl(struct mtd_info *mtd, int dat, unsigned int ctrl)
120 {
121         struct tango_chip *tchip = to_tango_chip(mtd_to_nand(mtd));
122
123         if (ctrl & NAND_CLE)
124                 writeb_relaxed(dat, tchip->base + PBUS_CMD);
125
126         if (ctrl & NAND_ALE)
127                 writeb_relaxed(dat, tchip->base + PBUS_ADDR);
128 }
129
130 static int tango_dev_ready(struct mtd_info *mtd)
131 {
132         struct nand_chip *chip = mtd_to_nand(mtd);
133         struct tango_nfc *nfc = to_tango_nfc(chip->controller);
134
135         return readl_relaxed(nfc->pbus_base + PBUS_CS_CTRL) & PBUS_IORDY;
136 }
137
138 static u8 tango_read_byte(struct mtd_info *mtd)
139 {
140         struct tango_chip *tchip = to_tango_chip(mtd_to_nand(mtd));
141
142         return readb_relaxed(tchip->base + PBUS_DATA);
143 }
144
145 static void tango_read_buf(struct mtd_info *mtd, u8 *buf, int len)
146 {
147         struct tango_chip *tchip = to_tango_chip(mtd_to_nand(mtd));
148
149         ioread8_rep(tchip->base + PBUS_DATA, buf, len);
150 }
151
152 static void tango_write_buf(struct mtd_info *mtd, const u8 *buf, int len)
153 {
154         struct tango_chip *tchip = to_tango_chip(mtd_to_nand(mtd));
155
156         iowrite8_rep(tchip->base + PBUS_DATA, buf, len);
157 }
158
159 static void tango_select_chip(struct mtd_info *mtd, int idx)
160 {
161         struct nand_chip *chip = mtd_to_nand(mtd);
162         struct tango_nfc *nfc = to_tango_nfc(chip->controller);
163         struct tango_chip *tchip = to_tango_chip(chip);
164
165         if (idx < 0)
166                 return; /* No "chip unselect" function */
167
168         writel_relaxed(tchip->timing1, nfc->reg_base + NFC_TIMING1);
169         writel_relaxed(tchip->timing2, nfc->reg_base + NFC_TIMING2);
170         writel_relaxed(tchip->xfer_cfg, nfc->reg_base + NFC_XFER_CFG);
171         writel_relaxed(tchip->pkt_0_cfg, nfc->reg_base + NFC_PKT_0_CFG);
172         writel_relaxed(tchip->pkt_n_cfg, nfc->reg_base + NFC_PKT_N_CFG);
173         writel_relaxed(tchip->bb_cfg, nfc->reg_base + NFC_BB_CFG);
174 }
175
176 /*
177  * The controller does not check for bitflips in erased pages,
178  * therefore software must check instead.
179  */
180 static int check_erased_page(struct nand_chip *chip, u8 *buf)
181 {
182         struct mtd_info *mtd = nand_to_mtd(chip);
183         u8 *meta = chip->oob_poi + BBM_SIZE;
184         u8 *ecc = chip->oob_poi + BBM_SIZE + METADATA_SIZE;
185         const int ecc_size = chip->ecc.bytes;
186         const int pkt_size = chip->ecc.size;
187         int i, res, meta_len, bitflips = 0;
188
189         for (i = 0; i < chip->ecc.steps; ++i) {
190                 meta_len = i ? 0 : METADATA_SIZE;
191                 res = nand_check_erased_ecc_chunk(buf, pkt_size, ecc, ecc_size,
192                                                   meta, meta_len,
193                                                   chip->ecc.strength);
194                 if (res < 0)
195                         mtd->ecc_stats.failed++;
196
197                 bitflips = max(res, bitflips);
198                 buf += pkt_size;
199                 ecc += ecc_size;
200         }
201
202         return bitflips;
203 }
204
205 static int decode_error_report(struct tango_nfc *nfc)
206 {
207         u32 status, res;
208
209         status = readl_relaxed(nfc->reg_base + NFC_XFER_STATUS);
210         if (status & PAGE_IS_EMPTY)
211                 return 0;
212
213         res = readl_relaxed(nfc->mem_base + ERROR_REPORT);
214
215         if (DECODE_OK_PKT_0(res) && DECODE_OK_PKT_N(res))
216                 return max(ERR_COUNT_PKT_0(res), ERR_COUNT_PKT_N(res));
217
218         return -EBADMSG;
219 }
220
221 static void tango_dma_callback(void *arg)
222 {
223         complete(arg);
224 }
225
226 static int do_dma(struct tango_nfc *nfc, enum dma_data_direction dir, int cmd,
227                   const void *buf, int len, int page)
228 {
229         void __iomem *addr = nfc->reg_base + NFC_STATUS;
230         struct dma_chan *chan = nfc->chan;
231         struct dma_async_tx_descriptor *desc;
232         enum dma_transfer_direction tdir;
233         struct scatterlist sg;
234         struct completion tx_done;
235         int err = -EIO;
236         u32 res, val;
237
238         sg_init_one(&sg, buf, len);
239         if (dma_map_sg(chan->device->dev, &sg, 1, dir) != 1)
240                 return -EIO;
241
242         tdir = dir == DMA_TO_DEVICE ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
243         desc = dmaengine_prep_slave_sg(chan, &sg, 1, tdir, DMA_PREP_INTERRUPT);
244         if (!desc)
245                 goto dma_unmap;
246
247         desc->callback = tango_dma_callback;
248         desc->callback_param = &tx_done;
249         init_completion(&tx_done);
250
251         writel_relaxed(MODE_NFC, nfc->pbus_base + PBUS_PAD_MODE);
252
253         writel_relaxed(page, nfc->reg_base + NFC_ADDR_PAGE);
254         writel_relaxed(0, nfc->reg_base + NFC_ADDR_OFFSET);
255         writel_relaxed(cmd, nfc->reg_base + NFC_FLASH_CMD);
256
257         dmaengine_submit(desc);
258         dma_async_issue_pending(chan);
259
260         res = wait_for_completion_timeout(&tx_done, HZ);
261         if (res > 0)
262                 err = readl_poll_timeout(addr, val, val & CMD_READY, 0, 1000);
263
264         writel_relaxed(MODE_RAW, nfc->pbus_base + PBUS_PAD_MODE);
265
266 dma_unmap:
267         dma_unmap_sg(chan->device->dev, &sg, 1, dir);
268
269         return err;
270 }
271
272 static int tango_read_page(struct mtd_info *mtd, struct nand_chip *chip,
273                            u8 *buf, int oob_required, int page)
274 {
275         struct tango_nfc *nfc = to_tango_nfc(chip->controller);
276         int err, res, len = mtd->writesize;
277
278         if (oob_required)
279                 chip->ecc.read_oob(mtd, chip, page);
280
281         err = do_dma(nfc, DMA_FROM_DEVICE, NFC_READ, buf, len, page);
282         if (err)
283                 return err;
284
285         res = decode_error_report(nfc);
286         if (res < 0) {
287                 chip->ecc.read_oob_raw(mtd, chip, page);
288                 res = check_erased_page(chip, buf);
289         }
290
291         return res;
292 }
293
294 static int tango_write_page(struct mtd_info *mtd, struct nand_chip *chip,
295                             const u8 *buf, int oob_required, int page)
296 {
297         struct tango_nfc *nfc = to_tango_nfc(chip->controller);
298         int err, len = mtd->writesize;
299
300         /* Calling tango_write_oob() would send PAGEPROG twice */
301         if (oob_required)
302                 return -ENOTSUPP;
303
304         writel_relaxed(0xffffffff, nfc->mem_base + METADATA);
305         err = do_dma(nfc, DMA_TO_DEVICE, NFC_WRITE, buf, len, page);
306         if (err)
307                 return err;
308
309         return 0;
310 }
311
312 static void aux_read(struct nand_chip *chip, u8 **buf, int len, int *pos)
313 {
314         struct mtd_info *mtd = nand_to_mtd(chip);
315
316         *pos += len;
317
318         if (!*buf) {
319                 /* skip over "len" bytes */
320                 chip->cmdfunc(mtd, NAND_CMD_RNDOUT, *pos, -1);
321         } else {
322                 tango_read_buf(mtd, *buf, len);
323                 *buf += len;
324         }
325 }
326
327 static void aux_write(struct nand_chip *chip, const u8 **buf, int len, int *pos)
328 {
329         struct mtd_info *mtd = nand_to_mtd(chip);
330
331         *pos += len;
332
333         if (!*buf) {
334                 /* skip over "len" bytes */
335                 chip->cmdfunc(mtd, NAND_CMD_SEQIN, *pos, -1);
336         } else {
337                 tango_write_buf(mtd, *buf, len);
338                 *buf += len;
339         }
340 }
341
342 /*
343  * Physical page layout (not drawn to scale)
344  *
345  * NB: Bad Block Marker area splits PKT_N in two (N1, N2).
346  *
347  * +---+-----------------+-------+-----+-----------+-----+----+-------+
348  * | M |      PKT_0      | ECC_0 | ... |     N1    | BBM | N2 | ECC_N |
349  * +---+-----------------+-------+-----+-----------+-----+----+-------+
350  *
351  * Logical page layout:
352  *
353  *       +-----+---+-------+-----+-------+
354  * oob = | BBM | M | ECC_0 | ... | ECC_N |
355  *       +-----+---+-------+-----+-------+
356  *
357  *       +-----------------+-----+-----------------+
358  * buf = |      PKT_0      | ... |      PKT_N      |
359  *       +-----------------+-----+-----------------+
360  */
361 static void raw_read(struct nand_chip *chip, u8 *buf, u8 *oob)
362 {
363         struct mtd_info *mtd = nand_to_mtd(chip);
364         u8 *oob_orig = oob;
365         const int page_size = mtd->writesize;
366         const int ecc_size = chip->ecc.bytes;
367         const int pkt_size = chip->ecc.size;
368         int pos = 0; /* position within physical page */
369         int rem = page_size; /* bytes remaining until BBM area */
370
371         if (oob)
372                 oob += BBM_SIZE;
373
374         aux_read(chip, &oob, METADATA_SIZE, &pos);
375
376         while (rem > pkt_size) {
377                 aux_read(chip, &buf, pkt_size, &pos);
378                 aux_read(chip, &oob, ecc_size, &pos);
379                 rem = page_size - pos;
380         }
381
382         aux_read(chip, &buf, rem, &pos);
383         aux_read(chip, &oob_orig, BBM_SIZE, &pos);
384         aux_read(chip, &buf, pkt_size - rem, &pos);
385         aux_read(chip, &oob, ecc_size, &pos);
386 }
387
388 static void raw_write(struct nand_chip *chip, const u8 *buf, const u8 *oob)
389 {
390         struct mtd_info *mtd = nand_to_mtd(chip);
391         const u8 *oob_orig = oob;
392         const int page_size = mtd->writesize;
393         const int ecc_size = chip->ecc.bytes;
394         const int pkt_size = chip->ecc.size;
395         int pos = 0; /* position within physical page */
396         int rem = page_size; /* bytes remaining until BBM area */
397
398         if (oob)
399                 oob += BBM_SIZE;
400
401         aux_write(chip, &oob, METADATA_SIZE, &pos);
402
403         while (rem > pkt_size) {
404                 aux_write(chip, &buf, pkt_size, &pos);
405                 aux_write(chip, &oob, ecc_size, &pos);
406                 rem = page_size - pos;
407         }
408
409         aux_write(chip, &buf, rem, &pos);
410         aux_write(chip, &oob_orig, BBM_SIZE, &pos);
411         aux_write(chip, &buf, pkt_size - rem, &pos);
412         aux_write(chip, &oob, ecc_size, &pos);
413 }
414
415 static int tango_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
416                                u8 *buf, int oob_required, int page)
417 {
418         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
419         raw_read(chip, buf, chip->oob_poi);
420         return 0;
421 }
422
423 static int tango_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
424                                 const u8 *buf, int oob_required, int page)
425 {
426         chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
427         raw_write(chip, buf, chip->oob_poi);
428         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
429         return 0;
430 }
431
432 static int tango_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
433                           int page)
434 {
435         chip->cmdfunc(mtd, NAND_CMD_READ0, 0, page);
436         raw_read(chip, NULL, chip->oob_poi);
437         return 0;
438 }
439
440 static int tango_write_oob(struct mtd_info *mtd, struct nand_chip *chip,
441                            int page)
442 {
443         chip->cmdfunc(mtd, NAND_CMD_SEQIN, 0, page);
444         raw_write(chip, NULL, chip->oob_poi);
445         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
446         chip->waitfunc(mtd, chip);
447         return 0;
448 }
449
450 static int oob_ecc(struct mtd_info *mtd, int idx, struct mtd_oob_region *res)
451 {
452         struct nand_chip *chip = mtd_to_nand(mtd);
453         struct nand_ecc_ctrl *ecc = &chip->ecc;
454
455         if (idx >= ecc->steps)
456                 return -ERANGE;
457
458         res->offset = BBM_SIZE + METADATA_SIZE + ecc->bytes * idx;
459         res->length = ecc->bytes;
460
461         return 0;
462 }
463
464 static int oob_free(struct mtd_info *mtd, int idx, struct mtd_oob_region *res)
465 {
466         return -ERANGE; /* no free space in spare area */
467 }
468
469 static const struct mtd_ooblayout_ops tango_nand_ooblayout_ops = {
470         .ecc    = oob_ecc,
471         .free   = oob_free,
472 };
473
474 static u32 to_ticks(int kHz, int ps)
475 {
476         return DIV_ROUND_UP_ULL((u64)kHz * ps, NSEC_PER_SEC);
477 }
478
479 static int tango_set_timings(struct mtd_info *mtd, int csline,
480                              const struct nand_data_interface *conf)
481 {
482         const struct nand_sdr_timings *sdr = nand_get_sdr_timings(conf);
483         struct nand_chip *chip = mtd_to_nand(mtd);
484         struct tango_nfc *nfc = to_tango_nfc(chip->controller);
485         struct tango_chip *tchip = to_tango_chip(chip);
486         u32 Trdy, Textw, Twc, Twpw, Tacc, Thold, Trpw, Textr;
487         int kHz = nfc->freq_kHz;
488
489         if (IS_ERR(sdr))
490                 return PTR_ERR(sdr);
491
492         if (csline == NAND_DATA_IFACE_CHECK_ONLY)
493                 return 0;
494
495         Trdy = to_ticks(kHz, sdr->tCEA_max - sdr->tREA_max);
496         Textw = to_ticks(kHz, sdr->tWB_max);
497         Twc = to_ticks(kHz, sdr->tWC_min);
498         Twpw = to_ticks(kHz, sdr->tWC_min - sdr->tWP_min);
499
500         Tacc = to_ticks(kHz, sdr->tREA_max);
501         Thold = to_ticks(kHz, sdr->tREH_min);
502         Trpw = to_ticks(kHz, sdr->tRC_min - sdr->tREH_min);
503         Textr = to_ticks(kHz, sdr->tRHZ_max);
504
505         tchip->timing1 = TIMING(Trdy, Textw, Twc, Twpw);
506         tchip->timing2 = TIMING(Tacc, Thold, Trpw, Textr);
507
508         return 0;
509 }
510
511 static int chip_init(struct device *dev, struct device_node *np)
512 {
513         u32 cs;
514         int err, res;
515         struct mtd_info *mtd;
516         struct nand_chip *chip;
517         struct tango_chip *tchip;
518         struct nand_ecc_ctrl *ecc;
519         struct tango_nfc *nfc = dev_get_drvdata(dev);
520
521         tchip = devm_kzalloc(dev, sizeof(*tchip), GFP_KERNEL);
522         if (!tchip)
523                 return -ENOMEM;
524
525         res = of_property_count_u32_elems(np, "reg");
526         if (res < 0)
527                 return res;
528
529         if (res != 1)
530                 return -ENOTSUPP; /* Multi-CS chips are not supported */
531
532         err = of_property_read_u32_index(np, "reg", 0, &cs);
533         if (err)
534                 return err;
535
536         if (cs >= MAX_CS)
537                 return -EINVAL;
538
539         chip = &tchip->nand_chip;
540         ecc = &chip->ecc;
541         mtd = nand_to_mtd(chip);
542
543         chip->read_byte = tango_read_byte;
544         chip->write_buf = tango_write_buf;
545         chip->read_buf = tango_read_buf;
546         chip->select_chip = tango_select_chip;
547         chip->cmd_ctrl = tango_cmd_ctrl;
548         chip->dev_ready = tango_dev_ready;
549         chip->setup_data_interface = tango_set_timings;
550         chip->options = NAND_USE_BOUNCE_BUFFER |
551                         NAND_NO_SUBPAGE_WRITE |
552                         NAND_WAIT_TCCS;
553         chip->controller = &nfc->hw;
554         tchip->base = nfc->pbus_base + (cs * 256);
555
556         nand_set_flash_node(chip, np);
557         mtd_set_ooblayout(mtd, &tango_nand_ooblayout_ops);
558         mtd->dev.parent = dev;
559
560         err = nand_scan_ident(mtd, 1, NULL);
561         if (err)
562                 return err;
563
564         ecc->mode = NAND_ECC_HW;
565         ecc->algo = NAND_ECC_BCH;
566         ecc->bytes = DIV_ROUND_UP(ecc->strength * FIELD_ORDER, BITS_PER_BYTE);
567
568         ecc->read_page_raw = tango_read_page_raw;
569         ecc->write_page_raw = tango_write_page_raw;
570         ecc->read_page = tango_read_page;
571         ecc->write_page = tango_write_page;
572         ecc->read_oob = tango_read_oob;
573         ecc->write_oob = tango_write_oob;
574         ecc->options = NAND_ECC_CUSTOM_PAGE_ACCESS;
575
576         err = nand_scan_tail(mtd);
577         if (err)
578                 return err;
579
580         tchip->xfer_cfg = XFER_CFG(cs, 1, ecc->steps, METADATA_SIZE);
581         tchip->pkt_0_cfg = PKT_CFG(ecc->size + METADATA_SIZE, ecc->strength);
582         tchip->pkt_n_cfg = PKT_CFG(ecc->size, ecc->strength);
583         tchip->bb_cfg = BB_CFG(mtd->writesize, BBM_SIZE);
584
585         err = mtd_device_register(mtd, NULL, 0);
586         if (err)
587                 return err;
588
589         nfc->chips[cs] = tchip;
590
591         return 0;
592 }
593
594 static int tango_nand_remove(struct platform_device *pdev)
595 {
596         int cs;
597         struct tango_nfc *nfc = platform_get_drvdata(pdev);
598
599         dma_release_channel(nfc->chan);
600
601         for (cs = 0; cs < MAX_CS; ++cs) {
602                 if (nfc->chips[cs])
603                         nand_release(nand_to_mtd(&nfc->chips[cs]->nand_chip));
604         }
605
606         return 0;
607 }
608
609 static int tango_nand_probe(struct platform_device *pdev)
610 {
611         int err;
612         struct clk *clk;
613         struct resource *res;
614         struct tango_nfc *nfc;
615         struct device_node *np;
616
617         nfc = devm_kzalloc(&pdev->dev, sizeof(*nfc), GFP_KERNEL);
618         if (!nfc)
619                 return -ENOMEM;
620
621         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
622         nfc->reg_base = devm_ioremap_resource(&pdev->dev, res);
623         if (IS_ERR(nfc->reg_base))
624                 return PTR_ERR(nfc->reg_base);
625
626         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
627         nfc->mem_base = devm_ioremap_resource(&pdev->dev, res);
628         if (IS_ERR(nfc->mem_base))
629                 return PTR_ERR(nfc->mem_base);
630
631         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
632         nfc->pbus_base = devm_ioremap_resource(&pdev->dev, res);
633         if (IS_ERR(nfc->pbus_base))
634                 return PTR_ERR(nfc->pbus_base);
635
636         writel_relaxed(MODE_RAW, nfc->pbus_base + PBUS_PAD_MODE);
637
638         clk = clk_get(&pdev->dev, NULL);
639         if (IS_ERR(clk))
640                 return PTR_ERR(clk);
641
642         nfc->chan = dma_request_chan(&pdev->dev, "rxtx");
643         if (IS_ERR(nfc->chan))
644                 return PTR_ERR(nfc->chan);
645
646         platform_set_drvdata(pdev, nfc);
647         nand_hw_control_init(&nfc->hw);
648         nfc->freq_kHz = clk_get_rate(clk) / 1000;
649
650         for_each_child_of_node(pdev->dev.of_node, np) {
651                 err = chip_init(&pdev->dev, np);
652                 if (err) {
653                         tango_nand_remove(pdev);
654                         return err;
655                 }
656         }
657
658         return 0;
659 }
660
661 static const struct of_device_id tango_nand_ids[] = {
662         { .compatible = "sigma,smp8758-nand" },
663         { /* sentinel */ }
664 };
665
666 static struct platform_driver tango_nand_driver = {
667         .probe  = tango_nand_probe,
668         .remove = tango_nand_remove,
669         .driver = {
670                 .name           = "tango-nand",
671                 .of_match_table = tango_nand_ids,
672         },
673 };
674
675 module_platform_driver(tango_nand_driver);
676
677 MODULE_LICENSE("GPL");
678 MODULE_AUTHOR("Sigma Designs");
679 MODULE_DESCRIPTION("Tango4 NAND Flash controller driver");