1/* 2 * NAND flash driver for the MikroTik RouterBoard 4xx series 3 * 4 * Copyright (C) 2008-2011 Gabor Juhos <juhosg@openwrt.org> 5 * Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org> 6 * 7 * This file was based on the driver for Linux 2.6.22 published by 8 * MikroTik for their RouterBoard 4xx series devices. 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License version 2 as published 12 * by the Free Software Foundation. 13 */ 14 15#include <linux/kernel.h> 16#include <linux/module.h> 17#include <linux/init.h> 18#include <linux/mtd/nand.h> 19#include <linux/mtd/mtd.h> 20#include <linux/mtd/partitions.h> 21#include <linux/platform_device.h> 22#include <linux/delay.h> 23#include <linux/io.h> 24#include <linux/gpio.h> 25#include <linux/slab.h> 26 27#include <asm/mach-ath79/ath79.h> 28#include <asm/mach-ath79/rb4xx_cpld.h> 29 30#define DRV_NAME "rb4xx-nand" 31#define DRV_VERSION "0.2.0" 32#define DRV_DESC "NAND flash driver for RouterBoard 4xx series" 33 34#define RB4XX_NAND_GPIO_READY 5 35#define RB4XX_NAND_GPIO_ALE 37 36#define RB4XX_NAND_GPIO_CLE 38 37#define RB4XX_NAND_GPIO_NCE 39 38 39struct rb4xx_nand_info { 40 struct nand_chip chip; 41 struct mtd_info mtd; 42}; 43 44/* 45 * We need to use the OLD Yaffs-1 OOB layout, otherwise the RB bootloader 46 * will not be able to find the kernel that we load. 47 */ 48static struct nand_ecclayout rb4xx_nand_ecclayout = { 49 .eccbytes = 6, 50 .eccpos = { 8, 9, 10, 13, 14, 15 }, 51 .oobavail = 9, 52 .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } 53}; 54 55static struct mtd_partition rb4xx_nand_partitions[] = { 56 { 57 .name = "booter", 58 .offset = 0, 59 .size = (256 * 1024), 60 .mask_flags = MTD_WRITEABLE, 61 }, 62 { 63 .name = "kernel", 64 .offset = (256 * 1024), 65 .size = (4 * 1024 * 1024) - (256 * 1024), 66 }, 67 { 68 .name = "rootfs", 69 .offset = MTDPART_OFS_NXTBLK, 70 .size = MTDPART_SIZ_FULL, 71 }, 72}; 73 74static int rb4xx_nand_dev_ready(struct mtd_info *mtd) 75{ 76 return gpio_get_value_cansleep(RB4XX_NAND_GPIO_READY); 77} 78 79static void rb4xx_nand_write_cmd(unsigned char cmd) 80{ 81 unsigned char data = cmd; 82 int err; 83 84 err = rb4xx_cpld_write(&data, 1); 85 if (err) 86 pr_err("rb4xx_nand: write cmd failed, err=%d\n", err); 87} 88 89static void rb4xx_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, 90 unsigned int ctrl) 91{ 92 if (ctrl & NAND_CTRL_CHANGE) { 93 gpio_set_value_cansleep(RB4XX_NAND_GPIO_CLE, 94 (ctrl & NAND_CLE) ? 1 : 0); 95 gpio_set_value_cansleep(RB4XX_NAND_GPIO_ALE, 96 (ctrl & NAND_ALE) ? 1 : 0); 97 gpio_set_value_cansleep(RB4XX_NAND_GPIO_NCE, 98 (ctrl & NAND_NCE) ? 0 : 1); 99 } 100 101 if (cmd != NAND_CMD_NONE) 102 rb4xx_nand_write_cmd(cmd); 103} 104 105static unsigned char rb4xx_nand_read_byte(struct mtd_info *mtd) 106{ 107 unsigned char data = 0; 108 int err; 109 110 err = rb4xx_cpld_read(&data, NULL, 1); 111 if (err) { 112 pr_err("rb4xx_nand: read data failed, err=%d\n", err); 113 data = 0xff; 114 } 115 116 return data; 117} 118 119static void rb4xx_nand_write_buf(struct mtd_info *mtd, const unsigned char *buf, 120 int len) 121{ 122 int err; 123 124 err = rb4xx_cpld_write(buf, len); 125 if (err) 126 pr_err("rb4xx_nand: write buf failed, err=%d\n", err); 127} 128 129static void rb4xx_nand_read_buf(struct mtd_info *mtd, unsigned char *buf, 130 int len) 131{ 132 int err; 133 134 err = rb4xx_cpld_read(buf, NULL, len); 135 if (err) 136 pr_err("rb4xx_nand: read buf failed, err=%d\n", err); 137} 138 139static int __devinit rb4xx_nand_probe(struct platform_device *pdev) 140{ 141 struct rb4xx_nand_info *info; 142 int ret; 143 144 printk(KERN_INFO DRV_DESC " version " DRV_VERSION "\n"); 145 146 ret = gpio_request(RB4XX_NAND_GPIO_READY, "NAND RDY"); 147 if (ret) { 148 dev_err(&pdev->dev, "unable to request gpio %d\n", 149 RB4XX_NAND_GPIO_READY); 150 goto err; 151 } 152 153 ret = gpio_direction_input(RB4XX_NAND_GPIO_READY); 154 if (ret) { 155 dev_err(&pdev->dev, "unable to set input mode on gpio %d\n", 156 RB4XX_NAND_GPIO_READY); 157 goto err_free_gpio_ready; 158 } 159 160 ret = gpio_request(RB4XX_NAND_GPIO_ALE, "NAND ALE"); 161 if (ret) { 162 dev_err(&pdev->dev, "unable to request gpio %d\n", 163 RB4XX_NAND_GPIO_ALE); 164 goto err_free_gpio_ready; 165 } 166 167 ret = gpio_direction_output(RB4XX_NAND_GPIO_ALE, 0); 168 if (ret) { 169 dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 170 RB4XX_NAND_GPIO_ALE); 171 goto err_free_gpio_ale; 172 } 173 174 ret = gpio_request(RB4XX_NAND_GPIO_CLE, "NAND CLE"); 175 if (ret) { 176 dev_err(&pdev->dev, "unable to request gpio %d\n", 177 RB4XX_NAND_GPIO_CLE); 178 goto err_free_gpio_ale; 179 } 180 181 ret = gpio_direction_output(RB4XX_NAND_GPIO_CLE, 0); 182 if (ret) { 183 dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 184 RB4XX_NAND_GPIO_CLE); 185 goto err_free_gpio_cle; 186 } 187 188 ret = gpio_request(RB4XX_NAND_GPIO_NCE, "NAND NCE"); 189 if (ret) { 190 dev_err(&pdev->dev, "unable to request gpio %d\n", 191 RB4XX_NAND_GPIO_NCE); 192 goto err_free_gpio_cle; 193 } 194 195 ret = gpio_direction_output(RB4XX_NAND_GPIO_NCE, 1); 196 if (ret) { 197 dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 198 RB4XX_NAND_GPIO_ALE); 199 goto err_free_gpio_nce; 200 } 201 202 info = kzalloc(sizeof(*info), GFP_KERNEL); 203 if (!info) { 204 dev_err(&pdev->dev, "rb4xx-nand: no memory for private data\n"); 205 ret = -ENOMEM; 206 goto err_free_gpio_nce; 207 } 208 209 info->chip.priv = &info; 210 info->mtd.priv = &info->chip; 211 info->mtd.owner = THIS_MODULE; 212 213 info->chip.cmd_ctrl = rb4xx_nand_cmd_ctrl; 214 info->chip.dev_ready = rb4xx_nand_dev_ready; 215 info->chip.read_byte = rb4xx_nand_read_byte; 216 info->chip.write_buf = rb4xx_nand_write_buf; 217 info->chip.read_buf = rb4xx_nand_read_buf; 218#if 0 219 info->chip.verify_buf = rb4xx_nand_verify_buf; 220#endif 221 222 info->chip.chip_delay = 25; 223 info->chip.ecc.mode = NAND_ECC_SOFT; 224 info->chip.options |= NAND_NO_AUTOINCR; 225 226 platform_set_drvdata(pdev, info); 227 228 ret = nand_scan_ident(&info->mtd, 1, NULL); 229 if (ret) { 230 ret = -ENXIO; 231 goto err_free_info; 232 } 233 234 if (info->mtd.writesize == 512) 235 info->chip.ecc.layout = &rb4xx_nand_ecclayout; 236 237 ret = nand_scan_tail(&info->mtd); 238 if (ret) { 239 return -ENXIO; 240 goto err_set_drvdata; 241 } 242 243 mtd_device_register(&info->mtd, rb4xx_nand_partitions, 244 ARRAY_SIZE(rb4xx_nand_partitions)); 245 if (ret) 246 goto err_release_nand; 247 248 return 0; 249 250err_release_nand: 251 nand_release(&info->mtd); 252err_set_drvdata: 253 platform_set_drvdata(pdev, NULL); 254err_free_info: 255 kfree(info); 256err_free_gpio_nce: 257 gpio_free(RB4XX_NAND_GPIO_NCE); 258err_free_gpio_cle: 259 gpio_free(RB4XX_NAND_GPIO_CLE); 260err_free_gpio_ale: 261 gpio_free(RB4XX_NAND_GPIO_ALE); 262err_free_gpio_ready: 263 gpio_free(RB4XX_NAND_GPIO_READY); 264err: 265 return ret; 266} 267 268static int __devexit rb4xx_nand_remove(struct platform_device *pdev) 269{ 270 struct rb4xx_nand_info *info = platform_get_drvdata(pdev); 271 272 nand_release(&info->mtd); 273 platform_set_drvdata(pdev, NULL); 274 kfree(info); 275 gpio_free(RB4XX_NAND_GPIO_NCE); 276 gpio_free(RB4XX_NAND_GPIO_CLE); 277 gpio_free(RB4XX_NAND_GPIO_ALE); 278 gpio_free(RB4XX_NAND_GPIO_READY); 279 280 return 0; 281} 282 283static struct platform_driver rb4xx_nand_driver = { 284 .probe = rb4xx_nand_probe, 285 .remove = __devexit_p(rb4xx_nand_remove), 286 .driver = { 287 .name = DRV_NAME, 288 .owner = THIS_MODULE, 289 }, 290}; 291 292static int __init rb4xx_nand_init(void) 293{ 294 return platform_driver_register(&rb4xx_nand_driver); 295} 296 297static void __exit rb4xx_nand_exit(void) 298{ 299 platform_driver_unregister(&rb4xx_nand_driver); 300} 301 302module_init(rb4xx_nand_init); 303module_exit(rb4xx_nand_exit); 304 305MODULE_DESCRIPTION(DRV_DESC); 306MODULE_VERSION(DRV_VERSION); 307MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>"); 308MODULE_AUTHOR("Imre Kaloz <kaloz@openwrt.org>"); 309MODULE_LICENSE("GPL v2"); 310