git.oblomov.eu Git - linux-2.6/blob - drivers/mtd/maps/nettel.c

   1 /****************************************************************************/
   2
   3 /*
   4  *      nettel.c -- mappings for NETtel/SecureEdge/SnapGear (x86) boards.
   5  *
   6  *      (C) Copyright 2000-2001, Greg Ungerer (gerg@snapgear.com)
   7  *      (C) Copyright 2001-2002, SnapGear (www.snapgear.com)
   8  *
   9  *      $Id: nettel.c,v 1.12 2005/11/29 14:30:00 gleixner Exp $
  10  */
  11
  12 /****************************************************************************/
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/types.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <linux/mtd/map.h>
  20 #include <linux/mtd/partitions.h>
  21 #include <linux/mtd/cfi.h>
  22 #include <linux/reboot.h>
  23 #include <linux/err.h>
  24 #include <linux/kdev_t.h>
  25 #include <linux/root_dev.h>
  26 #include <asm/io.h>
  27
  28 /****************************************************************************/
  29
  30 #define INTEL_BUSWIDTH          1
  31 #define AMD_WINDOW_MAXSIZE      0x00200000
  32 #define AMD_BUSWIDTH            1
  33
  34 /*
  35  *      PAR masks and shifts, assuming 64K pages.
  36  */
  37 #define SC520_PAR_ADDR_MASK     0x00003fff
  38 #define SC520_PAR_ADDR_SHIFT    16
  39 #define SC520_PAR_TO_ADDR(par) \
  40         (((par)&SC520_PAR_ADDR_MASK) << SC520_PAR_ADDR_SHIFT)
  41
  42 #define SC520_PAR_SIZE_MASK     0x01ffc000
  43 #define SC520_PAR_SIZE_SHIFT    2
  44 #define SC520_PAR_TO_SIZE(par) \
  45         ((((par)&SC520_PAR_SIZE_MASK) << SC520_PAR_SIZE_SHIFT) + (64*1024))
  46
  47 #define SC520_PAR(cs, addr, size) \
  48         ((cs) | \
  49         ((((size)-(64*1024)) >> SC520_PAR_SIZE_SHIFT) & SC520_PAR_SIZE_MASK) | \
  50         (((addr) >> SC520_PAR_ADDR_SHIFT) & SC520_PAR_ADDR_MASK))
  51
  52 #define SC520_PAR_BOOTCS        0x8a000000
  53 #define SC520_PAR_ROMCS1        0xaa000000
  54 #define SC520_PAR_ROMCS2        0xca000000      /* Cache disabled, 64K page */
  55
  56 static void *nettel_mmcrp = NULL;
  57
  58 #ifdef CONFIG_MTD_CFI_INTELEXT
  59 static struct mtd_info *intel_mtd;
  60 #endif
  61 static struct mtd_info *amd_mtd;
  62
  63 /****************************************************************************/
  64
  65 /****************************************************************************/
  66
  67 #ifdef CONFIG_MTD_CFI_INTELEXT
  68 static struct map_info nettel_intel_map = {
  69         .name = "SnapGear Intel",
  70         .size = 0,
  71         .bankwidth = INTEL_BUSWIDTH,
  72 };
  73
  74 static struct mtd_partition nettel_intel_partitions[] = {
  75         {
  76                 .name = "SnapGear kernel",
  77                 .offset = 0,
  78                 .size = 0x000e0000
  79         },
  80         {
  81                 .name = "SnapGear filesystem",
  82                 .offset = 0x00100000,
  83         },
  84         {
  85                 .name = "SnapGear config",
  86                 .offset = 0x000e0000,
  87                 .size = 0x00020000
  88         },
  89         {
  90                 .name = "SnapGear Intel",
  91                 .offset = 0
  92         },
  93         {
  94                 .name = "SnapGear BIOS Config",
  95                 .offset = 0x007e0000,
  96                 .size = 0x00020000
  97         },
  98         {
  99                 .name = "SnapGear BIOS",
 100                 .offset = 0x007e0000,
 101                 .size = 0x00020000
 102         },
 103 };
 104 #endif
 105
 106 static struct map_info nettel_amd_map = {
 107         .name = "SnapGear AMD",
 108         .size = AMD_WINDOW_MAXSIZE,
 109         .bankwidth = AMD_BUSWIDTH,
 110 };
 111
 112 static struct mtd_partition nettel_amd_partitions[] = {
 113         {
 114                 .name = "SnapGear BIOS config",
 115                 .offset = 0x000e0000,
 116                 .size = 0x00010000
 117         },
 118         {
 119                 .name = "SnapGear BIOS",
 120                 .offset = 0x000f0000,
 121                 .size = 0x00010000
 122         },
 123         {
 124                 .name = "SnapGear AMD",
 125                 .offset = 0
 126         },
 127         {
 128                 .name = "SnapGear high BIOS",
 129                 .offset = 0x001f0000,
 130                 .size = 0x00010000
 131         }
 132 };
 133
 134 #define NUM_AMD_PARTITIONS ARRAY_SIZE(nettel_amd_partitions)
 135
 136 /****************************************************************************/
 137
 138 #ifdef CONFIG_MTD_CFI_INTELEXT
 139
 140 /*
 141  *      Set the Intel flash back to read mode since some old boot
 142  *      loaders don't.
 143  */
 144 static int nettel_reboot_notifier(struct notifier_block *nb, unsigned long val, void *v)
 145 {
 146         struct cfi_private *cfi = nettel_intel_map.fldrv_priv;
 147         unsigned long b;
 148
 149         /* Make sure all FLASH chips are put back into read mode */
 150         for (b = 0; (b < nettel_intel_partitions[3].size); b += 0x100000) {
 151                 cfi_send_gen_cmd(0xff, 0x55, b, &nettel_intel_map, cfi,
 152                         cfi->device_type, NULL);
 153         }
 154         return(NOTIFY_OK);
 155 }
 156
 157 static struct notifier_block nettel_notifier_block = {
 158         nettel_reboot_notifier, NULL, 0
 159 };
 160
 161 /*
 162  *      Erase the configuration file system.
 163  *      Used to support the software reset button.
 164  */
 165 static void nettel_erasecallback(struct erase_info *done)
 166 {
 167         wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
 168         wake_up(wait_q);
 169 }
 170
 171 static struct erase_info nettel_erase;
 172
 173 int nettel_eraseconfig(void)
 174 {
 175         struct mtd_info *mtd;
 176         DECLARE_WAITQUEUE(wait, current);
 177         wait_queue_head_t wait_q;
 178         int ret;
 179
 180         init_waitqueue_head(&wait_q);
 181         mtd = get_mtd_device(NULL, 2);
 182         if (!IS_ERR(mtd)) {
 183                 nettel_erase.mtd = mtd;
 184                 nettel_erase.callback = nettel_erasecallback;
 185                 nettel_erase.callback = NULL;
 186                 nettel_erase.addr = 0;
 187                 nettel_erase.len = mtd->size;
 188                 nettel_erase.priv = (u_long) &wait_q;
 189                 nettel_erase.priv = 0;
 190
 191                 set_current_state(TASK_INTERRUPTIBLE);
 192                 add_wait_queue(&wait_q, &wait);
 193
 194                 ret = mtd->erase(mtd, &nettel_erase);
 195                 if (ret) {
 196                         set_current_state(TASK_RUNNING);
 197                         remove_wait_queue(&wait_q, &wait);
 198                         put_mtd_device(mtd);
 199                         return(ret);
 200                 }
 201
 202                 schedule();  /* Wait for erase to finish. */
 203                 remove_wait_queue(&wait_q, &wait);
 204
 205                 put_mtd_device(mtd);
 206         }
 207
 208         return(0);
 209 }
 210
 211 #else
 212
 213 int nettel_eraseconfig(void)
 214 {
 215         return(0);
 216 }
 217
 218 #endif
 219
 220 /****************************************************************************/
 221
 222 int __init nettel_init(void)
 223 {
 224         volatile unsigned long *amdpar;
 225         unsigned long amdaddr, maxsize;
 226         int num_amd_partitions=0;
 227 #ifdef CONFIG_MTD_CFI_INTELEXT
 228         volatile unsigned long *intel0par, *intel1par;
 229         unsigned long orig_bootcspar, orig_romcs1par;
 230         unsigned long intel0addr, intel0size;
 231         unsigned long intel1addr, intel1size;
 232         int intelboot, intel0cs, intel1cs;
 233         int num_intel_partitions;
 234 #endif
 235         int rc = 0;
 236
 237         nettel_mmcrp = (void *) ioremap_nocache(0xfffef000, 4096);
 238         if (nettel_mmcrp == NULL) {
 239                 printk("SNAPGEAR: failed to disable MMCR cache??\n");
 240                 return(-EIO);
 241         }
 242
 243         /* Set CPU clock to be 33.000MHz */
 244         *((unsigned char *) (nettel_mmcrp + 0xc64)) = 0x01;
 245
 246         amdpar = (volatile unsigned long *) (nettel_mmcrp + 0xc4);
 247
 248 #ifdef CONFIG_MTD_CFI_INTELEXT
 249         intelboot = 0;
 250         intel0cs = SC520_PAR_ROMCS1;
 251         intel0par = (volatile unsigned long *) (nettel_mmcrp + 0xc0);
 252         intel1cs = SC520_PAR_ROMCS2;
 253         intel1par = (volatile unsigned long *) (nettel_mmcrp + 0xbc);
 254
 255         /*
 256          *      Save the CS settings then ensure ROMCS1 and ROMCS2 are off,
 257          *      otherwise they might clash with where we try to map BOOTCS.
 258          */
 259         orig_bootcspar = *amdpar;
 260         orig_romcs1par = *intel0par;
 261         *intel0par = 0;
 262         *intel1par = 0;
 263 #endif
 264
 265         /*
 266          *      The first thing to do is determine if we have a separate
 267          *      boot FLASH device. Typically this is a small (1 to 2MB)
 268          *      AMD FLASH part. It seems that device size is about the
 269          *      only way to tell if this is the case...
 270          */
 271         amdaddr = 0x20000000;
 272         maxsize = AMD_WINDOW_MAXSIZE;
 273
 274         *amdpar = SC520_PAR(SC520_PAR_BOOTCS, amdaddr, maxsize);
 275         __asm__ ("wbinvd");
 276
 277         nettel_amd_map.phys = amdaddr;
 278         nettel_amd_map.virt = ioremap_nocache(amdaddr, maxsize);
 279         if (!nettel_amd_map.virt) {
 280                 printk("SNAPGEAR: failed to ioremap() BOOTCS\n");
 281                 iounmap(nettel_mmcrp);
 282                 return(-EIO);
 283         }
 284         simple_map_init(&nettel_amd_map);
 285
 286         if ((amd_mtd = do_map_probe("jedec_probe", &nettel_amd_map))) {
 287                 printk(KERN_NOTICE "SNAPGEAR: AMD flash device size = %dK\n",
 288                         amd_mtd->size>>10);
 289
 290                 amd_mtd->owner = THIS_MODULE;
 291
 292                 /* The high BIOS partition is only present for 2MB units */
 293                 num_amd_partitions = NUM_AMD_PARTITIONS;
 294                 if (amd_mtd->size < AMD_WINDOW_MAXSIZE)
 295                         num_amd_partitions--;
 296                 /* Don't add the partition until after the primary INTEL's */
 297
 298 #ifdef CONFIG_MTD_CFI_INTELEXT
 299                 /*
 300                  *      Map the Intel flash into memory after the AMD
 301                  *      It has to start on a multiple of maxsize.
 302                  */
 303                 maxsize = SC520_PAR_TO_SIZE(orig_romcs1par);
 304                 if (maxsize < (32 * 1024 * 1024))
 305                         maxsize = (32 * 1024 * 1024);
 306                 intel0addr = amdaddr + maxsize;
 307 #endif
 308         } else {
 309 #ifdef CONFIG_MTD_CFI_INTELEXT
 310                 /* INTEL boot FLASH */
 311                 intelboot++;
 312
 313                 if (!orig_romcs1par) {
 314                         intel0cs = SC520_PAR_BOOTCS;
 315                         intel0par = (volatile unsigned long *)
 316                                 (nettel_mmcrp + 0xc4);
 317                         intel1cs = SC520_PAR_ROMCS1;
 318                         intel1par = (volatile unsigned long *)
 319                                 (nettel_mmcrp + 0xc0);
 320
 321                         intel0addr = SC520_PAR_TO_ADDR(orig_bootcspar);
 322                         maxsize = SC520_PAR_TO_SIZE(orig_bootcspar);
 323                 } else {
 324                         /* Kernel base is on ROMCS1, not BOOTCS */
 325                         intel0cs = SC520_PAR_ROMCS1;
 326                         intel0par = (volatile unsigned long *)
 327                                 (nettel_mmcrp + 0xc0);
 328                         intel1cs = SC520_PAR_BOOTCS;
 329                         intel1par = (volatile unsigned long *)
 330                                 (nettel_mmcrp + 0xc4);
 331
 332                         intel0addr = SC520_PAR_TO_ADDR(orig_romcs1par);
 333                         maxsize = SC520_PAR_TO_SIZE(orig_romcs1par);
 334                 }
 335
 336                 /* Destroy useless AMD MTD mapping */
 337                 amd_mtd = NULL;
 338                 iounmap(nettel_amd_map.virt);
 339                 nettel_amd_map.virt = NULL;
 340 #else
 341                 /* Only AMD flash supported */
 342                 rc = -ENXIO;
 343                 goto out_unmap2;
 344 #endif
 345         }
 346
 347 #ifdef CONFIG_MTD_CFI_INTELEXT
 348         /*
 349          *      We have determined the INTEL FLASH configuration, so lets
 350          *      go ahead and probe for them now.
 351          */
 352
 353         /* Set PAR to the maximum size */
 354         if (maxsize < (32 * 1024 * 1024))
 355                 maxsize = (32 * 1024 * 1024);
 356         *intel0par = SC520_PAR(intel0cs, intel0addr, maxsize);
 357
 358         /* Turn other PAR off so the first probe doesn't find it */
 359         *intel1par = 0;
 360
 361         /* Probe for the the size of the first Intel flash */
 362         nettel_intel_map.size = maxsize;
 363         nettel_intel_map.phys = intel0addr;
 364         nettel_intel_map.virt = ioremap_nocache(intel0addr, maxsize);
 365         if (!nettel_intel_map.virt) {
 366                 printk("SNAPGEAR: failed to ioremap() ROMCS1\n");
 367                 rc = -EIO;
 368                 goto out_unmap2;
 369         }
 370         simple_map_init(&nettel_intel_map);
 371
 372         intel_mtd = do_map_probe("cfi_probe", &nettel_intel_map);
 373         if (!intel_mtd) {
 374                 rc = -ENXIO;
 375                 goto out_unmap1;
 376         }
 377
 378         /* Set PAR to the detected size */
 379         intel0size = intel_mtd->size;
 380         *intel0par = SC520_PAR(intel0cs, intel0addr, intel0size);
 381
 382         /*
 383          *      Map second Intel FLASH right after first. Set its size to the
 384          *      same maxsize used for the first Intel FLASH.
 385          */
 386         intel1addr = intel0addr + intel0size;
 387         *intel1par = SC520_PAR(intel1cs, intel1addr, maxsize);
 388         __asm__ ("wbinvd");
 389
 390         maxsize += intel0size;
 391
 392         /* Delete the old map and probe again to do both chips */
 393         map_destroy(intel_mtd);
 394         intel_mtd = NULL;
 395         iounmap(nettel_intel_map.virt);
 396
 397         nettel_intel_map.size = maxsize;
 398         nettel_intel_map.virt = ioremap_nocache(intel0addr, maxsize);
 399         if (!nettel_intel_map.virt) {
 400                 printk("SNAPGEAR: failed to ioremap() ROMCS1/2\n");
 401                 rc = -EIO;
 402                 goto out_unmap2;
 403         }
 404
 405         intel_mtd = do_map_probe("cfi_probe", &nettel_intel_map);
 406         if (! intel_mtd) {
 407                 rc = -ENXIO;
 408                 goto out_unmap1;
 409         }
 410
 411         intel1size = intel_mtd->size - intel0size;
 412         if (intel1size > 0) {
 413                 *intel1par = SC520_PAR(intel1cs, intel1addr, intel1size);
 414                 __asm__ ("wbinvd");
 415         } else {
 416                 *intel1par = 0;
 417         }
 418
 419         printk(KERN_NOTICE "SNAPGEAR: Intel flash device size = %dK\n",
 420                 (intel_mtd->size >> 10));
 421
 422         intel_mtd->owner = THIS_MODULE;
 423
 424 #ifndef CONFIG_BLK_DEV_INITRD
 425         ROOT_DEV = MKDEV(MTD_BLOCK_MAJOR, 1);
 426 #endif
 427
 428         num_intel_partitions = sizeof(nettel_intel_partitions) /
 429                 sizeof(nettel_intel_partitions[0]);
 430
 431         if (intelboot) {
 432                 /*
 433                  *      Adjust offset and size of last boot partition.
 434                  *      Must allow for BIOS region at end of FLASH.
 435                  */
 436                 nettel_intel_partitions[1].size = (intel0size + intel1size) -
 437                         (1024*1024 + intel_mtd->erasesize);
 438                 nettel_intel_partitions[3].size = intel0size + intel1size;
 439                 nettel_intel_partitions[4].offset =
 440                         (intel0size + intel1size) - intel_mtd->erasesize;
 441                 nettel_intel_partitions[4].size = intel_mtd->erasesize;
 442                 nettel_intel_partitions[5].offset =
 443                         nettel_intel_partitions[4].offset;
 444                 nettel_intel_partitions[5].size =
 445                         nettel_intel_partitions[4].size;
 446         } else {
 447                 /* No BIOS regions when AMD boot */
 448                 num_intel_partitions -= 2;
 449         }
 450         rc = add_mtd_partitions(intel_mtd, nettel_intel_partitions,
 451                 num_intel_partitions);
 452 #endif
 453
 454         if (amd_mtd) {
 455                 rc = add_mtd_partitions(amd_mtd, nettel_amd_partitions,
 456                         num_amd_partitions);
 457         }
 458
 459 #ifdef CONFIG_MTD_CFI_INTELEXT
 460         register_reboot_notifier(&nettel_notifier_block);
 461 #endif
 462
 463         return(rc);
 464
 465 #ifdef CONFIG_MTD_CFI_INTELEXT
 466 out_unmap1:
 467         iounmap(nettel_intel_map.virt);
 468 #endif
 469
 470 out_unmap2:
 471         iounmap(nettel_mmcrp);
 472         iounmap(nettel_amd_map.virt);
 473
 474         return(rc);
 475
 476 }
 477
 478 /****************************************************************************/
 479
 480 void __exit nettel_cleanup(void)
 481 {
 482 #ifdef CONFIG_MTD_CFI_INTELEXT
 483         unregister_reboot_notifier(&nettel_notifier_block);
 484 #endif
 485         if (amd_mtd) {
 486                 del_mtd_partitions(amd_mtd);
 487                 map_destroy(amd_mtd);
 488         }
 489         if (nettel_mmcrp) {
 490                 iounmap(nettel_mmcrp);
 491                 nettel_mmcrp = NULL;
 492         }
 493         if (nettel_amd_map.virt) {
 494                 iounmap(nettel_amd_map.virt);
 495                 nettel_amd_map.virt = NULL;
 496         }
 497 #ifdef CONFIG_MTD_CFI_INTELEXT
 498         if (intel_mtd) {
 499                 del_mtd_partitions(intel_mtd);
 500                 map_destroy(intel_mtd);
 501         }
 502         if (nettel_intel_map.virt) {
 503                 iounmap(nettel_intel_map.virt);
 504                 nettel_intel_map.virt = NULL;
 505         }
 506 #endif
 507 }
 508
 509 /****************************************************************************/
 510
 511 module_init(nettel_init);
 512 module_exit(nettel_cleanup);
 513
 514 MODULE_LICENSE("GPL");
 515 MODULE_AUTHOR("Greg Ungerer <gerg@snapgear.com>");
 516 MODULE_DESCRIPTION("SnapGear/SecureEdge FLASH support");
 517
 518 /****************************************************************************/