board/[k-z]*: Augment CONFIG_COMMANDS tests with defined(CONFIG_CMD_*).
[platform/kernel/u-boot.git] / board / prodrive / alpr / nand.c
1 /*
2  * (C) Copyright 2006
3  * Heiko Schocher, DENX Software Engineering, hs@denx.de
4  *
5  * (C) Copyright 2006
6  * Stefan Roese, DENX Software Engineering, sr@denx.de.
7  *
8  * See file CREDITS for list of people who contributed to this
9  * project.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of
14  * the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24  * MA 02111-1307 USA
25  */
26
27 #include <common.h>
28
29 #if (CONFIG_COMMANDS & CFG_CMD_NAND) || defined(CONFIG_CMD_NAND)
30
31 #include <asm/processor.h>
32 #include <nand.h>
33
34 struct alpr_ndfc_regs {
35         u8 cmd[4];
36         u8 addr_wait;
37         u8 term;
38         u8 dummy;
39         u8 dummy2;
40         u8 data;
41 };
42
43 static u8 hwctl;
44 static struct alpr_ndfc_regs *alpr_ndfc = NULL;
45
46 #define readb(addr)     (u8)(*(volatile u8 *)(addr))
47 #define writeb(d,addr)  *(volatile u8 *)(addr) = ((u8)(d))
48
49 /*
50  * The ALPR has a NAND Flash Controller (NDFC) that handles all accesses to
51  * the NAND devices.  The NDFC has command, address and data registers that
52  * when accessed will set up the NAND flash pins appropriately.  We'll use the
53  * hwcontrol function to save the configuration in a global variable.
54  * We can then use this information in the read and write functions to
55  * determine which NDFC register to access.
56  *
57  * There are 2 NAND devices on the board, a Hynix HY27US08561A (1 GByte).
58  */
59 static void alpr_nand_hwcontrol(struct mtd_info *mtd, int cmd)
60 {
61         switch (cmd) {
62         case NAND_CTL_SETCLE:
63                 hwctl |= 0x1;
64                 break;
65         case NAND_CTL_CLRCLE:
66                 hwctl &= ~0x1;
67                 break;
68         case NAND_CTL_SETALE:
69                 hwctl |= 0x2;
70                 break;
71         case NAND_CTL_CLRALE:
72                 hwctl &= ~0x2;
73                 break;
74         case NAND_CTL_SETNCE:
75                 break;
76         case NAND_CTL_CLRNCE:
77                 writeb(0x00, &(alpr_ndfc->term));
78                 break;
79         }
80 }
81
82 static void alpr_nand_write_byte(struct mtd_info *mtd, u_char byte)
83 {
84         struct nand_chip *nand = mtd->priv;
85
86         if (hwctl & 0x1)
87                 /*
88                  * IO_ADDR_W used as CMD[i] reg to support multiple NAND
89                  * chips.
90                  */
91                 writeb(byte, nand->IO_ADDR_W);
92         else if (hwctl & 0x2) {
93                 writeb(byte, &(alpr_ndfc->addr_wait));
94         } else
95                 writeb(byte, &(alpr_ndfc->data));
96 }
97
98 static u_char alpr_nand_read_byte(struct mtd_info *mtd)
99 {
100         return readb(&(alpr_ndfc->data));
101 }
102
103 static void alpr_nand_write_buf(struct mtd_info *mtd, const u_char *buf, int len)
104 {
105         struct nand_chip *nand = mtd->priv;
106         int i;
107
108         for (i = 0; i < len; i++) {
109                 if (hwctl & 0x1)
110                          /*
111                           * IO_ADDR_W used as CMD[i] reg to support multiple NAND
112                           * chips.
113                           */
114                         writeb(buf[i], nand->IO_ADDR_W);
115                 else if (hwctl & 0x2)
116                         writeb(buf[i], &(alpr_ndfc->addr_wait));
117                 else
118                         writeb(buf[i], &(alpr_ndfc->data));
119         }
120 }
121
122 static void alpr_nand_read_buf(struct mtd_info *mtd, u_char *buf, int len)
123 {
124         int i;
125
126         for (i = 0; i < len; i++) {
127                 buf[i] = readb(&(alpr_ndfc->data));
128         }
129 }
130
131 static int alpr_nand_verify_buf(struct mtd_info *mtd, const u_char *buf, int len)
132 {
133         int i;
134
135         for (i = 0; i < len; i++)
136                 if (buf[i] != readb(&(alpr_ndfc->data)))
137                         return i;
138
139         return 0;
140 }
141
142 static int alpr_nand_dev_ready(struct mtd_info *mtd)
143 {
144         volatile u_char val;
145
146         /*
147          * Blocking read to wait for NAND to be ready
148          */
149         val = readb(&(alpr_ndfc->addr_wait));
150
151         /*
152          * Return always true
153          */
154         return 1;
155 }
156
157 int board_nand_init(struct nand_chip *nand)
158 {
159         alpr_ndfc = (struct alpr_ndfc_regs *)CFG_NAND_BASE;
160
161         nand->eccmode = NAND_ECC_SOFT;
162
163         /* Reference hardware control function */
164         nand->hwcontrol  = alpr_nand_hwcontrol;
165         /* Set command delay time */
166         nand->write_byte = alpr_nand_write_byte;
167         nand->read_byte  = alpr_nand_read_byte;
168         nand->write_buf  = alpr_nand_write_buf;
169         nand->read_buf   = alpr_nand_read_buf;
170         nand->verify_buf = alpr_nand_verify_buf;
171         nand->dev_ready  = alpr_nand_dev_ready;
172
173         return 0;
174 }
175 #endif