2 * Freescale UPM NAND driver.
4 * Copyright © 2007-2008 MontaVista Software, Inc.
6 * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/mtd/nand.h>
18 #include <linux/mtd/nand_ecc.h>
19 #include <linux/mtd/partitions.h>
20 #include <linux/mtd/mtd.h>
21 #include <linux/of_address.h>
22 #include <linux/of_platform.h>
23 #include <linux/of_gpio.h>
25 #include <linux/slab.h>
26 #include <asm/fsl_lbc.h>
28 #define FSL_UPM_WAIT_RUN_PATTERN 0x1
29 #define FSL_UPM_WAIT_WRITE_BYTE 0x2
30 #define FSL_UPM_WAIT_WRITE_BUFFER 0x4
34 struct nand_chip chip
;
36 struct mtd_partition
*parts
;
38 uint8_t upm_addr_offset
;
39 uint8_t upm_cmd_offset
;
40 void __iomem
*io_base
;
41 int rnb_gpio
[NAND_MAX_CHIPS
];
42 uint32_t mchip_offsets
[NAND_MAX_CHIPS
];
44 uint32_t mchip_number
;
49 static inline struct fsl_upm_nand
*to_fsl_upm_nand(struct mtd_info
*mtdinfo
)
51 return container_of(mtd_to_nand(mtdinfo
), struct fsl_upm_nand
,
55 static int fun_chip_ready(struct mtd_info
*mtd
)
57 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
59 if (gpio_get_value(fun
->rnb_gpio
[fun
->mchip_number
]))
62 dev_vdbg(fun
->dev
, "busy\n");
66 static void fun_wait_rnb(struct fsl_upm_nand
*fun
)
68 if (fun
->rnb_gpio
[fun
->mchip_number
] >= 0) {
69 struct mtd_info
*mtd
= nand_to_mtd(&fun
->chip
);
72 while (--cnt
&& !fun_chip_ready(mtd
))
75 dev_err(fun
->dev
, "tired waiting for RNB\n");
81 static void fun_cmd_ctrl(struct mtd_info
*mtd
, int cmd
, unsigned int ctrl
)
83 struct nand_chip
*chip
= mtd_to_nand(mtd
);
84 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
87 if (!(ctrl
& fun
->last_ctrl
)) {
88 fsl_upm_end_pattern(&fun
->upm
);
90 if (cmd
== NAND_CMD_NONE
)
93 fun
->last_ctrl
= ctrl
& (NAND_ALE
| NAND_CLE
);
96 if (ctrl
& NAND_CTRL_CHANGE
) {
98 fsl_upm_start_pattern(&fun
->upm
, fun
->upm_addr_offset
);
99 else if (ctrl
& NAND_CLE
)
100 fsl_upm_start_pattern(&fun
->upm
, fun
->upm_cmd_offset
);
103 mar
= (cmd
<< (32 - fun
->upm
.width
)) |
104 fun
->mchip_offsets
[fun
->mchip_number
];
105 fsl_upm_run_pattern(&fun
->upm
, chip
->IO_ADDR_R
, mar
);
107 if (fun
->wait_flags
& FSL_UPM_WAIT_RUN_PATTERN
)
111 static void fun_select_chip(struct mtd_info
*mtd
, int mchip_nr
)
113 struct nand_chip
*chip
= mtd_to_nand(mtd
);
114 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
116 if (mchip_nr
== -1) {
117 chip
->cmd_ctrl(mtd
, NAND_CMD_NONE
, 0 | NAND_CTRL_CHANGE
);
118 } else if (mchip_nr
>= 0 && mchip_nr
< NAND_MAX_CHIPS
) {
119 fun
->mchip_number
= mchip_nr
;
120 chip
->IO_ADDR_R
= fun
->io_base
+ fun
->mchip_offsets
[mchip_nr
];
121 chip
->IO_ADDR_W
= chip
->IO_ADDR_R
;
127 static uint8_t fun_read_byte(struct mtd_info
*mtd
)
129 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
131 return in_8(fun
->chip
.IO_ADDR_R
);
134 static void fun_read_buf(struct mtd_info
*mtd
, uint8_t *buf
, int len
)
136 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
139 for (i
= 0; i
< len
; i
++)
140 buf
[i
] = in_8(fun
->chip
.IO_ADDR_R
);
143 static void fun_write_buf(struct mtd_info
*mtd
, const uint8_t *buf
, int len
)
145 struct fsl_upm_nand
*fun
= to_fsl_upm_nand(mtd
);
148 for (i
= 0; i
< len
; i
++) {
149 out_8(fun
->chip
.IO_ADDR_W
, buf
[i
]);
150 if (fun
->wait_flags
& FSL_UPM_WAIT_WRITE_BYTE
)
153 if (fun
->wait_flags
& FSL_UPM_WAIT_WRITE_BUFFER
)
157 static int fun_chip_init(struct fsl_upm_nand
*fun
,
158 const struct device_node
*upm_np
,
159 const struct resource
*io_res
)
161 struct mtd_info
*mtd
= nand_to_mtd(&fun
->chip
);
163 struct device_node
*flash_np
;
165 fun
->chip
.IO_ADDR_R
= fun
->io_base
;
166 fun
->chip
.IO_ADDR_W
= fun
->io_base
;
167 fun
->chip
.cmd_ctrl
= fun_cmd_ctrl
;
168 fun
->chip
.chip_delay
= fun
->chip_delay
;
169 fun
->chip
.read_byte
= fun_read_byte
;
170 fun
->chip
.read_buf
= fun_read_buf
;
171 fun
->chip
.write_buf
= fun_write_buf
;
172 fun
->chip
.ecc
.mode
= NAND_ECC_SOFT
;
173 if (fun
->mchip_count
> 1)
174 fun
->chip
.select_chip
= fun_select_chip
;
176 if (fun
->rnb_gpio
[0] >= 0)
177 fun
->chip
.dev_ready
= fun_chip_ready
;
179 mtd
->dev
.parent
= fun
->dev
;
181 flash_np
= of_get_next_child(upm_np
, NULL
);
185 nand_set_flash_node(&fun
->chip
, flash_np
);
186 mtd
->name
= kasprintf(GFP_KERNEL
, "0x%llx.%s", (u64
)io_res
->start
,
193 ret
= nand_scan(mtd
, fun
->mchip_count
);
197 ret
= mtd_device_register(mtd
, NULL
, 0);
199 of_node_put(flash_np
);
205 static int fun_probe(struct platform_device
*ofdev
)
207 struct fsl_upm_nand
*fun
;
208 struct resource io_res
;
215 fun
= kzalloc(sizeof(*fun
), GFP_KERNEL
);
219 ret
= of_address_to_resource(ofdev
->dev
.of_node
, 0, &io_res
);
221 dev_err(&ofdev
->dev
, "can't get IO base\n");
225 ret
= fsl_upm_find(io_res
.start
, &fun
->upm
);
227 dev_err(&ofdev
->dev
, "can't find UPM\n");
231 prop
= of_get_property(ofdev
->dev
.of_node
, "fsl,upm-addr-offset",
233 if (!prop
|| size
!= sizeof(uint32_t)) {
234 dev_err(&ofdev
->dev
, "can't get UPM address offset\n");
238 fun
->upm_addr_offset
= *prop
;
240 prop
= of_get_property(ofdev
->dev
.of_node
, "fsl,upm-cmd-offset", &size
);
241 if (!prop
|| size
!= sizeof(uint32_t)) {
242 dev_err(&ofdev
->dev
, "can't get UPM command offset\n");
246 fun
->upm_cmd_offset
= *prop
;
248 prop
= of_get_property(ofdev
->dev
.of_node
,
249 "fsl,upm-addr-line-cs-offsets", &size
);
250 if (prop
&& (size
/ sizeof(uint32_t)) > 0) {
251 fun
->mchip_count
= size
/ sizeof(uint32_t);
252 if (fun
->mchip_count
>= NAND_MAX_CHIPS
) {
253 dev_err(&ofdev
->dev
, "too much multiple chips\n");
256 for (i
= 0; i
< fun
->mchip_count
; i
++)
257 fun
->mchip_offsets
[i
] = be32_to_cpu(prop
[i
]);
259 fun
->mchip_count
= 1;
262 for (i
= 0; i
< fun
->mchip_count
; i
++) {
263 fun
->rnb_gpio
[i
] = -1;
264 rnb_gpio
= of_get_gpio(ofdev
->dev
.of_node
, i
);
266 ret
= gpio_request(rnb_gpio
, dev_name(&ofdev
->dev
));
269 "can't request RNB gpio #%d\n", i
);
272 gpio_direction_input(rnb_gpio
);
273 fun
->rnb_gpio
[i
] = rnb_gpio
;
274 } else if (rnb_gpio
== -EINVAL
) {
275 dev_err(&ofdev
->dev
, "RNB gpio #%d is invalid\n", i
);
280 prop
= of_get_property(ofdev
->dev
.of_node
, "chip-delay", NULL
);
282 fun
->chip_delay
= be32_to_cpup(prop
);
284 fun
->chip_delay
= 50;
286 prop
= of_get_property(ofdev
->dev
.of_node
, "fsl,upm-wait-flags", &size
);
287 if (prop
&& size
== sizeof(uint32_t))
288 fun
->wait_flags
= be32_to_cpup(prop
);
290 fun
->wait_flags
= FSL_UPM_WAIT_RUN_PATTERN
|
291 FSL_UPM_WAIT_WRITE_BYTE
;
293 fun
->io_base
= devm_ioremap_nocache(&ofdev
->dev
, io_res
.start
,
294 resource_size(&io_res
));
300 fun
->dev
= &ofdev
->dev
;
301 fun
->last_ctrl
= NAND_CLE
;
303 ret
= fun_chip_init(fun
, ofdev
->dev
.of_node
, &io_res
);
307 dev_set_drvdata(&ofdev
->dev
, fun
);
311 for (i
= 0; i
< fun
->mchip_count
; i
++) {
312 if (fun
->rnb_gpio
[i
] < 0)
314 gpio_free(fun
->rnb_gpio
[i
]);
322 static int fun_remove(struct platform_device
*ofdev
)
324 struct fsl_upm_nand
*fun
= dev_get_drvdata(&ofdev
->dev
);
325 struct mtd_info
*mtd
= nand_to_mtd(&fun
->chip
);
331 for (i
= 0; i
< fun
->mchip_count
; i
++) {
332 if (fun
->rnb_gpio
[i
] < 0)
334 gpio_free(fun
->rnb_gpio
[i
]);
342 static const struct of_device_id of_fun_match
[] = {
343 { .compatible
= "fsl,upm-nand" },
346 MODULE_DEVICE_TABLE(of
, of_fun_match
);
348 static struct platform_driver of_fun_driver
= {
350 .name
= "fsl,upm-nand",
351 .of_match_table
= of_fun_match
,
354 .remove
= fun_remove
,
357 module_platform_driver(of_fun_driver
);
359 MODULE_LICENSE("GPL");
360 MODULE_AUTHOR("Anton Vorontsov <avorontsov@ru.mvista.com>");
361 MODULE_DESCRIPTION("Driver for NAND chips working through Freescale "
362 "LocalBus User-Programmable Machine");