target/linux/adm5120/files-3.8/drivers/mtd/maps/adm5120-flash.c

   1 /*
   2  *  Platform driver for NOR flash devices on ADM5120 based boards
   3  *
   4  *  Copyright (C) 2007-2008 Gabor Juhos <juhosg@openwrt.org>
   5  *
   6  *  This file was derived from: drivers/mtd/map/physmap.c
   7  *      Copyright (C) 2003 MontaVista Software Inc.
   8  *      Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
   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
  16 #include <linux/module.h>
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/init.h>
  20 #include <linux/slab.h>
  21 #include <linux/io.h>
  22 #include <linux/device.h>
  23 #include <linux/platform_device.h>
  24
  25 #include <linux/mtd/mtd.h>
  26 #include <linux/mtd/map.h>
  27 #include <linux/mtd/partitions.h>
  28
  29 #include <asm/mach-adm5120/adm5120_defs.h>
  30 #include <asm/mach-adm5120/adm5120_switch.h>
  31 #include <asm/mach-adm5120/adm5120_mpmc.h>
  32 #include <asm/mach-adm5120/adm5120_platform.h>
  33
  34 #define DRV_NAME        "adm5120-flash"
  35 #define DRV_DESC        "ADM5120 flash MAP driver"
  36 #define MAX_PARSED_PARTS 8
  37
  38 #ifdef ADM5120_FLASH_DEBUG
  39 #define MAP_DBG(m, f, a...)     printk(KERN_INFO "%s: " f, (m->name) , ## a)
  40 #else
  41 #define MAP_DBG(m, f, a...)     do {} while (0)
  42 #endif
  43 #define MAP_ERR(m, f, a...)     printk(KERN_ERR "%s: " f, (m->name) , ## a)
  44 #define MAP_INFO(m, f, a...)    printk(KERN_INFO "%s: " f, (m->name) , ## a)
  45
  46 struct adm5120_map_info {
  47         struct map_info map;
  48         void            (*switch_bank)(unsigned);
  49         unsigned long   window_size;
  50 };
  51
  52 struct adm5120_flash_info {
  53         struct mtd_info         *mtd;
  54         struct resource         *res;
  55         struct platform_device  *dev;
  56         struct adm5120_map_info amap;
  57 };
  58
  59 struct flash_desc {
  60         u32     phys;
  61         u32     srs_shift;
  62 };
  63
  64 /*
  65  * Globals
  66  */
  67 static DEFINE_SPINLOCK(adm5120_flash_spin);
  68 #define FLASH_LOCK()    spin_lock(&adm5120_flash_spin)
  69 #define FLASH_UNLOCK()  spin_unlock(&adm5120_flash_spin)
  70
  71 static u32 flash_bankwidths[4] = { 1, 2, 4, 0 };
  72
  73 static u32 flash_sizes[8] = {
  74         0, 512*1024, 1024*1024, 2*1024*1024,
  75         4*1024*1024, 0, 0, 0
  76 };
  77
  78 static struct flash_desc flash_descs[2] = {
  79         {
  80                 .phys           = ADM5120_SRAM0_BASE,
  81                 .srs_shift      = MEMCTRL_SRS0_SHIFT,
  82         }, {
  83                 .phys           = ADM5120_SRAM1_BASE,
  84                 .srs_shift      = MEMCTRL_SRS1_SHIFT,
  85         }
  86 };
  87
  88 static const char const *probe_types[] = {
  89         "cfi_probe",
  90         "jedec_probe",
  91         "map_rom",
  92         NULL
  93 };
  94
  95 static const char const *parse_types[] = {
  96         "cmdlinepart",
  97 #ifdef CONFIG_MTD_REDBOOT_PARTS
  98         "RedBoot",
  99 #endif
 100 #ifdef CONFIG_MTD_MYLOADER_PARTS
 101         "MyLoader",
 102 #endif
 103         NULL,
 104 };
 105
 106 #define BANK_SIZE       (2<<20)
 107 #define BANK_SIZE_MAX   (4<<20)
 108 #define BANK_OFFS_MASK  (BANK_SIZE-1)
 109 #define BANK_START_MASK (~BANK_OFFS_MASK)
 110
 111 static inline struct adm5120_map_info *map_to_amap(struct map_info *map)
 112 {
 113         return (struct adm5120_map_info *)map;
 114 }
 115
 116 static void adm5120_flash_switchbank(struct map_info *map,
 117                 unsigned long ofs)
 118 {
 119         struct adm5120_map_info *amap = map_to_amap(map);
 120         unsigned bank;
 121
 122         if (amap->switch_bank == NULL)
 123                 return;
 124
 125         bank = (ofs & BANK_START_MASK) >> 21;
 126         if (bank > 1)
 127                 BUG();
 128
 129         MAP_DBG(map, "switching to bank %u, ofs=%lX\n", bank, ofs);
 130         amap->switch_bank(bank);
 131 }
 132
 133 static map_word adm5120_flash_read(struct map_info *map, unsigned long ofs)
 134 {
 135         struct adm5120_map_info *amap = map_to_amap(map);
 136         map_word ret;
 137
 138         MAP_DBG(map, "reading from ofs %lX\n", ofs);
 139
 140         if (ofs >= amap->window_size)
 141                 return map_word_ff(map);
 142
 143         FLASH_LOCK();
 144         adm5120_flash_switchbank(map, ofs);
 145         ret = inline_map_read(map, (ofs & (amap->window_size-1)));
 146         FLASH_UNLOCK();
 147
 148         return ret;
 149 }
 150
 151 static void adm5120_flash_write(struct map_info *map, const map_word datum,
 152                 unsigned long ofs)
 153 {
 154         struct adm5120_map_info *amap = map_to_amap(map);
 155
 156         MAP_DBG(map, "writing to ofs %lX\n", ofs);
 157
 158         if (ofs > amap->window_size)
 159                 return;
 160
 161         FLASH_LOCK();
 162         adm5120_flash_switchbank(map, ofs);
 163         inline_map_write(map, datum, (ofs & (amap->window_size-1)));
 164         FLASH_UNLOCK();
 165 }
 166
 167 static void adm5120_flash_copy_from(struct map_info *map, void *to,
 168                 unsigned long from, ssize_t len)
 169 {
 170         struct adm5120_map_info *amap = map_to_amap(map);
 171         char *p;
 172         ssize_t t;
 173
 174         MAP_DBG(map, "copy_from, to=%lX, from=%lX, len=%lX\n",
 175                 (unsigned long)to, from, (unsigned long)len);
 176
 177         if (from > amap->window_size)
 178                 return;
 179
 180         p = (char *)to;
 181         while (len > 0) {
 182                 t = len;
 183                 if ((from < BANK_SIZE) && ((from+len) > BANK_SIZE))
 184                         t = BANK_SIZE-from;
 185
 186                 FLASH_LOCK();
 187                 MAP_DBG(map, "copying %lu byte(s) from %lX to %lX\n",
 188                         (unsigned long)t, (from & (amap->window_size-1)),
 189                         (unsigned long)p);
 190                 adm5120_flash_switchbank(map, from);
 191                 inline_map_copy_from(map, p, (from & (amap->window_size-1)), t);
 192                 FLASH_UNLOCK();
 193                 p += t;
 194                 from += t;
 195                 len -= t;
 196         }
 197 }
 198
 199 static int adm5120_flash_initres(struct adm5120_flash_info *info)
 200 {
 201         struct map_info *map = &info->amap.map;
 202         int err = 0;
 203
 204         info->res = request_mem_region(map->phys, info->amap.window_size,
 205                         map->name);
 206         if (info->res == NULL) {
 207                 MAP_ERR(map, "could not reserve memory region\n");
 208                 err = -ENOMEM;
 209                 goto out;
 210         }
 211
 212         map->virt = ioremap_nocache(map->phys, info->amap.window_size);
 213         if (map->virt == NULL) {
 214                 MAP_ERR(map, "failed to ioremap flash region\n");
 215                 err = -ENOMEM;
 216                 goto out;
 217         }
 218
 219 out:
 220         return err;
 221 }
 222
 223 static int adm5120_flash_initinfo(struct adm5120_flash_info *info,
 224                 struct platform_device *dev)
 225 {
 226         struct map_info *map = &info->amap.map;
 227         struct adm5120_flash_platform_data *pdata = dev->dev.platform_data;
 228         struct flash_desc *fdesc;
 229         u32 t = 0;
 230
 231         map->name = dev_name(&dev->dev);
 232
 233         if (dev->id > 1) {
 234                 MAP_ERR(map, "invalid flash id\n");
 235                 goto err_out;
 236         }
 237
 238         fdesc = &flash_descs[dev->id];
 239
 240         if (pdata)
 241                 info->amap.window_size = pdata->window_size;
 242
 243         if (info->amap.window_size == 0) {
 244                 /* get memory window size */
 245                 t = SW_READ_REG(SWITCH_REG_MEMCTRL) >> fdesc->srs_shift;
 246                 t &= MEMCTRL_SRS_MASK;
 247                 info->amap.window_size = flash_sizes[t];
 248         }
 249
 250         if (info->amap.window_size == 0) {
 251                 MAP_ERR(map, "unable to determine window size\n");
 252                 goto err_out;
 253         }
 254
 255         /* get flash bus width */
 256         switch (dev->id) {
 257         case 0:
 258                 t = MPMC_READ_REG(SC1) & SC_MW_MASK;
 259                 break;
 260         case 1:
 261                 t = MPMC_READ_REG(SC0) & SC_MW_MASK;
 262                 break;
 263         }
 264         map->bankwidth = flash_bankwidths[t];
 265         if (map->bankwidth == 0) {
 266                 MAP_ERR(map, "invalid bus width detected\n");
 267                 goto err_out;
 268         }
 269
 270         map->phys = fdesc->phys;
 271         map->size = BANK_SIZE_MAX;
 272
 273         simple_map_init(map);
 274         map->read = adm5120_flash_read;
 275         map->write = adm5120_flash_write;
 276         map->copy_from = adm5120_flash_copy_from;
 277
 278         if (pdata) {
 279                 map->set_vpp = pdata->set_vpp;
 280                 info->amap.switch_bank = pdata->switch_bank;
 281         }
 282
 283         info->dev = dev;
 284
 285         MAP_INFO(map, "probing at 0x%lX, size:%ldKiB, width:%d bits\n",
 286                 (unsigned long)map->phys,
 287                 (unsigned long)info->amap.window_size >> 10,
 288                 map->bankwidth*8);
 289
 290         return 0;
 291
 292 err_out:
 293         return -ENODEV;
 294 }
 295
 296 static void adm5120_flash_initbanks(struct adm5120_flash_info *info)
 297 {
 298         struct map_info *map = &info->amap.map;
 299
 300         if (info->mtd->size <= BANK_SIZE)
 301                 /* no bank switching needed */
 302                 return;
 303
 304         if (info->amap.switch_bank) {
 305                 info->amap.window_size = info->mtd->size;
 306                 return;
 307         }
 308
 309         MAP_ERR(map, "reduce visibility from %ldKiB to %ldKiB\n",
 310                 (unsigned long)map->size >> 10,
 311                 (unsigned long)info->mtd->size >> 10);
 312
 313         info->mtd->size = info->amap.window_size;
 314 }
 315
 316 static int adm5120_flash_remove(struct platform_device *dev)
 317 {
 318         struct adm5120_flash_info *info;
 319
 320         info = platform_get_drvdata(dev);
 321         if (info == NULL)
 322                 return 0;
 323
 324         platform_set_drvdata(dev, NULL);
 325
 326         if (info->mtd != NULL) {
 327                 mtd_device_unregister(info->mtd);
 328                 map_destroy(info->mtd);
 329         }
 330
 331         if (info->amap.map.virt != NULL)
 332                 iounmap(info->amap.map.virt);
 333
 334         if (info->res != NULL) {
 335                 release_resource(info->res);
 336                 kfree(info->res);
 337         }
 338
 339         return 0;
 340 }
 341
 342 static int adm5120_flash_probe(struct platform_device *dev)
 343 {
 344         struct adm5120_flash_platform_data *pdata;
 345         struct adm5120_flash_info *info;
 346         struct map_info *map;
 347         const char **probe_type;
 348         int err;
 349
 350         pdata = dev->dev.platform_data;
 351         if (!pdata) {
 352                 dev_err(&dev->dev, "no platform data\n");
 353                 return -EINVAL;
 354         }
 355
 356         info = kzalloc(sizeof(*info), GFP_KERNEL);
 357         if (info == NULL) {
 358                 err = -ENOMEM;
 359                 goto err_out;
 360         }
 361
 362         platform_set_drvdata(dev, info);
 363
 364         err = adm5120_flash_initinfo(info, dev);
 365         if (err)
 366                 goto err_out;
 367
 368         err = adm5120_flash_initres(info);
 369         if (err)
 370                 goto err_out;
 371
 372         map = &info->amap.map;
 373         for (probe_type = probe_types; info->mtd == NULL && *probe_type != NULL;
 374                 probe_type++)
 375                 info->mtd = do_map_probe(*probe_type, map);
 376
 377         if (info->mtd == NULL) {
 378                 MAP_ERR(map, "map_probe failed\n");
 379                 err = -ENXIO;
 380                 goto err_out;
 381         }
 382
 383         adm5120_flash_initbanks(info);
 384
 385         if (info->mtd->size < info->amap.window_size) {
 386                 /* readjust resources */
 387                 iounmap(map->virt);
 388                 release_resource(info->res);
 389                 kfree(info->res);
 390
 391                 info->amap.window_size = info->mtd->size;
 392                 map->size = info->mtd->size;
 393                 MAP_INFO(map, "reducing map size to %ldKiB\n",
 394                         (unsigned long)map->size >> 10);
 395                 err = adm5120_flash_initres(info);
 396                 if (err)
 397                         goto err_out;
 398         }
 399
 400         MAP_INFO(map, "found at 0x%lX, size:%ldKiB, width:%d bits\n",
 401                 (unsigned long)map->phys, (unsigned long)info->mtd->size >> 10,
 402                 map->bankwidth*8);
 403
 404         info->mtd->owner = THIS_MODULE;
 405
 406         err = mtd_device_parse_register(info->mtd, parse_types, 0,
 407                                         pdata->parts, pdata->nr_parts);
 408         if (err)
 409                 goto err_out;
 410
 411         return 0;
 412
 413 err_out:
 414         adm5120_flash_remove(dev);
 415         return err;
 416 }
 417
 418 #ifdef CONFIG_PM
 419 static int adm5120_flash_suspend(struct platform_device *dev,
 420                 pm_message_t state)
 421 {
 422         struct adm5120_flash_info *info = platform_get_drvdata(dev);
 423         int ret = 0;
 424
 425         if (info)
 426                 ret = info->mtd->suspend(info->mtd);
 427
 428         return ret;
 429 }
 430
 431 static int adm5120_flash_resume(struct platform_device *dev)
 432 {
 433         struct adm5120_flash_info *info = platform_get_drvdata(dev);
 434
 435         if (info)
 436                 info->mtd->resume(info->mtd);
 437
 438         return 0;
 439 }
 440
 441 static void adm5120_flash_shutdown(struct platform_device *dev)
 442 {
 443         struct adm5120_flash_info *info = platform_get_drvdata(dev);
 444
 445         if (info && info->mtd->suspend(info->mtd) == 0)
 446                 info->mtd->resume(info->mtd);
 447 }
 448 #endif
 449
 450 static struct platform_driver adm5120_flash_driver = {
 451         .probe          = adm5120_flash_probe,
 452         .remove         = adm5120_flash_remove,
 453 #ifdef CONFIG_PM
 454         .suspend        = adm5120_flash_suspend,
 455         .resume         = adm5120_flash_resume,
 456         .shutdown       = adm5120_flash_shutdown,
 457 #endif
 458         .driver         = {
 459                 .name   = DRV_NAME,
 460         },
 461 };
 462
 463 static int __init adm5120_flash_init(void)
 464 {
 465         int err;
 466
 467         err = platform_driver_register(&adm5120_flash_driver);
 468
 469         return err;
 470 }
 471
 472 static void __exit adm5120_flash_exit(void)
 473 {
 474         platform_driver_unregister(&adm5120_flash_driver);
 475 }
 476
 477 module_init(adm5120_flash_init);
 478 module_exit(adm5120_flash_exit);
 479
 480 MODULE_LICENSE("GPL v2");
 481 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 482 MODULE_DESCRIPTION(DRV_DESC);