target/linux/rdc/files/drivers/mtd/maps/rdc3210.c

   1 /*******************************************************************
   2  * Simple Flash mapping for RDC3210                                *
   3  *                                                                 *
   4  *                                                     2005.03.23  *
   5  *                              Dante Su (dante_su@gemtek.com.tw)  *
   6  *                          Copyright (C) 2005 Gemtek Corporation  *
   7  *******************************************************************/
   8
   9 #include <linux/module.h>
  10 #include <linux/types.h>
  11 #include <linux/kernel.h>
  12 #include <asm/io.h>
  13 #include <linux/mtd/mtd.h>
  14 #include <linux/mtd/map.h>
  15 #include <linux/mtd/partitions.h>
  16 #include <linux/autoconf.h>
  17 #include <linux/sched.h>
  18 #include <linux/squashfs_fs.h>
  19
  20 static struct mtd_info          *rdc3210_mtd;
  21
  22 struct map_info rdc3210_map =
  23 {
  24         .name =         "RDC3210 Flash",
  25         .size =         CONFIG_MTD_RDC3210_SIZE,
  26         .bankwidth =    CONFIG_MTD_RDC3210_BUSWIDTH,
  27 };
  28
  29 /* Dante: This is the default static mapping, however this is nothing but a hint. (Say dynamic mapping) */
  30 static struct mtd_partition rdc3210_parts[] =
  31 {
  32 #if CONFIG_MTD_RDC3210_SIZE == 0x400000
  33         { name: "linux",   offset:  0,          size: 0x003C0000 },     /* 3840 KB = (Kernel + ROMFS) = (768 KB + 3072 KB) */
  34         { name: "romfs",   offset:  0x000C0000, size: 0x00300000 },     /* 3072 KB */
  35         { name: "nvram",   offset:  0x003C0000, size: 0x00010000 },     /*   64 KB */
  36 #ifdef CONFIG_MTD_RDC3210_FACTORY_PRESENT
  37         { name: "factory", offset:  0x003D0000, size: 0x00010000 },     /*   64 KB */
  38 #endif
  39         { name: "bootldr", offset:  0x003E0000, size: 0x00020000 },     /*  128 KB */
  40 #elif CONFIG_MTD_RDC3210_SIZE == 0x200000
  41         { name: "linux",   offset:  0x00008000, size: 0x001E8000 },
  42         { name: "romfs",   offset:  0x000C8000, size: 0x00128000 },
  43         { name: "nvram",   offset:  0x00000000, size: 0x00008000 },     /*   64 KB */
  44 #ifdef CONFIG_MTD_RDC3210_FACTORY_PRESENT
  45 #error Unsupported configuration!
  46 #endif
  47         { name: "bootldr", offset:  0x001F0000, size: 0x00010000 },
  48
  49 #elif CONFIG_MTD_RDC3210_SIZE == 0x800000
  50         { name: "linux",   offset:  0,          size: 0x001F0000 },     /* 1984 KB */
  51         { name: "config",  offset:  0x001F0000, size: 0x00010000 },     /*   64 KB */
  52         { name: "romfs",   offset:  0x00200000, size: 0x005D0000 },     /* 5952 KB */
  53 #ifdef CONFIG_MTD_RDC3210_FACTORY_PRESENT
  54         { name: "factory", offset:  0x007D0000, size: 0x00010000 },     /*   64 KB */
  55 #endif
  56         { name: "bootldr", offset:  0x007E0000, size: 0x00010000 },     /*   64 KB */
  57 #else
  58 #error Unsupported configuration!
  59 #endif
  60 };
  61
  62 static __u32 crctab[257] = {
  63         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
  64         0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
  65         0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
  66         0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
  67         0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
  68         0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
  69         0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
  70         0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
  71         0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
  72         0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
  73         0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
  74         0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
  75         0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
  76         0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
  77         0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
  78         0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
  79         0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
  80         0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
  81         0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
  82         0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
  83         0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
  84         0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
  85         0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
  86         0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
  87         0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
  88         0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
  89         0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
  90         0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
  91         0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
  92         0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
  93         0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
  94         0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
  95         0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
  96         0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
  97         0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
  98         0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
  99         0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
 100         0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
 101         0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 102         0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
 103         0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
 104         0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 105         0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
 106         0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
 107         0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 108         0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
 109         0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
 110         0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 111         0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
 112         0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
 113         0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 114         0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
 115         0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
 116         0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 117         0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
 118         0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
 119         0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 120         0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
 121         0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
 122         0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 123         0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
 124         0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
 125         0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 126         0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 127         0
 128 };
 129
 130 static __u32 crc32(__u8 * buf, __u32 len)
 131 {
 132         register int i;
 133         __u32 sum;
 134         register __u32 s0;
 135         s0 = ~0;
 136         for (i = 0; i < len; i++) {
 137                 s0 = (s0 >> 8) ^ crctab[(__u8) (s0 & 0xFF) ^ buf[i]];
 138         }
 139         sum = ~s0;
 140         return sum;
 141 }
 142
 143 static void erase_callback(struct erase_info *done)
 144 {
 145         wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv;
 146         wake_up(wait_q);
 147 }
 148
 149 static int erase_write (struct mtd_info *mtd, unsigned long pos,
 150                         int len, const char *buf)
 151 {
 152         struct erase_info erase;
 153         DECLARE_WAITQUEUE(wait, current);
 154         wait_queue_head_t wait_q;
 155         size_t retlen;
 156         int ret;
 157
 158         /*
 159          * First, let's erase the flash block.
 160          */
 161
 162         init_waitqueue_head(&wait_q);
 163         erase.mtd = mtd;
 164         erase.callback = erase_callback;
 165         erase.addr = pos;
 166         erase.len = len;
 167         erase.priv = (u_long)&wait_q;
 168
 169         set_current_state(TASK_INTERRUPTIBLE);
 170         add_wait_queue(&wait_q, &wait);
 171
 172         ret = mtd->erase(mtd, &erase);
 173         if (ret) {
 174                 set_current_state(TASK_RUNNING);
 175                 remove_wait_queue(&wait_q, &wait);
 176                 printk (KERN_WARNING "erase of region [0x%lx, 0x%x] "
 177                                      "on \"%s\" failed\n",
 178                         pos, len, mtd->name);
 179                 return ret;
 180         }
 181
 182         schedule();  /* Wait for erase to finish. */
 183         remove_wait_queue(&wait_q, &wait);
 184
 185         /*
 186          * Next, writhe data to flash.
 187          */
 188
 189         ret = mtd->write (mtd, pos, len, &retlen, buf);
 190         if (ret)
 191                 return ret;
 192         if (retlen != len)
 193                 return -EIO;
 194         return 0;
 195 }
 196
 197 static int __init init_rdc3210_map(void)
 198 {
 199         rdc3210_map.phys = -rdc3210_map.size;
 200         printk(KERN_NOTICE "flash device: %x at %x\n", rdc3210_map.size, rdc3210_map.phys);
 201
 202 #if CONFIG_MTD_RDC3210_SIZE == 0x800000
 203         simple_map_init(&rdc3210_map);
 204 #endif
 205
 206         rdc3210_map.map_priv_1 = (unsigned long)(rdc3210_map.virt = ioremap_nocache(rdc3210_map.phys, rdc3210_map.size));
 207
 208         if (!rdc3210_map.map_priv_1)
 209         {
 210                 printk("Failed to ioremap\n");
 211                 return -EIO;
 212         }
 213         rdc3210_mtd = do_map_probe("cfi_probe", &rdc3210_map);
 214 #ifdef CONFIG_MTD_RDC3210_STATIC_MAP    /* Dante: This is for fixed map */
 215         if (rdc3210_mtd)
 216         {
 217                 rdc3210_mtd->owner = THIS_MODULE;
 218                 add_mtd_partitions(rdc3210_mtd, rdc3210_parts, sizeof(rdc3210_parts)/sizeof(rdc3210_parts[0]));
 219                 return 0;
 220         }
 221 #else   /* Dante: This is for dynamic mapping */
 222
 223 #include "imghdr.h"
 224
 225         typedef struct {
 226                 u8      magic[4];
 227                 u32     kernelsz, ramdisksz;
 228                 u8      magic2[4];
 229                 u32     sz2;
 230         }sc_imghdr_t;
 231
 232         if (rdc3210_mtd)
 233         {       // Dante
 234                 sc_imghdr_t     *hdr2= (sc_imghdr_t *)(rdc3210_map.map_priv_1);
 235                 gt_imghdr_t     *hdr = (gt_imghdr_t *)hdr2
 236 #ifdef CONFIG_MTD_RDC3210_ALLOW_JFFS2
 237                         , *ptmp
 238 #endif
 239                         ;
 240                 int     len, tmp, tmp2, tmp3, tmp4, hdr_type = 0;
 241
 242                 if(!memcmp(hdr->magic, GTIMG_MAGIC, 4))
 243                 {
 244                         hdr_type = 1;
 245                         tmp = hdr->kernelsz + sizeof(gt_imghdr_t);
 246                         tmp2 = rdc3210_mtd->erasesize;
 247                         tmp3 = ((tmp / 32) + ((tmp % 32) ? 1 : 0)) * 32;
 248                         tmp4 = ((tmp / tmp2) + ((tmp % tmp2) ? 1 : 0)) * tmp2;
 249                 }
 250 #ifndef CONFIG_MTD_RDC3210_ALLOW_JFFS2
 251                 else if (!memcmp(hdr2->magic, "CSYS", 4))
 252                 {
 253                         hdr_type = 2;
 254                         tmp = hdr2->ramdisksz + hdr2->kernelsz + sizeof(sc_imghdr_t);
 255                         tmp2 = rdc3210_mtd->erasesize;
 256                         tmp3 = ((tmp / 32) + ((tmp % 32) ? 1 : 0)) * 32;
 257                         tmp4 = ((tmp / tmp2) + ((tmp % tmp2) ? 1 : 0)) * tmp2;
 258                 }
 259 #endif
 260                 else
 261                 {
 262                         iounmap((void *)rdc3210_map.map_priv_1);
 263                         rdc3210_map.map_priv_1 = 0L;
 264                         rdc3210_map.virt = NULL;
 265                         printk("Invalid MAGIC for Firmware Image!!!\n");
 266                         return -EIO;
 267                 }
 268 #ifdef CONFIG_MTD_RDC3210_ALLOW_JFFS2
 269                 tmp = (tmp3 == tmp4) ? tmp4 + tmp2 : tmp4;
 270                 if ((ptmp = (gt_imghdr_t *)vmalloc(tmp)) == NULL)
 271                 {
 272                         iounmap((void *)rdc3210_map.map_priv_1);
 273                         rdc3210_map.map_priv_1 = 0L;
 274                         rdc3210_map.virt = NULL;
 275                         printk("Can't allocate 0x%08x for flash-reading buffer!\n", tmp);
 276                         return -ENOMEM;
 277                 }
 278                 if (rdc3210_mtd->read(rdc3210_mtd, 0, tmp, &len, (__u8 *)ptmp) || len != tmp)
 279                 {
 280                         vfree(ptmp);
 281                         iounmap((void *)rdc3210_map.map_priv_1);
 282                         rdc3210_map.map_priv_1 = 0L;
 283                         rdc3210_map.virt = NULL;
 284                         printk("Can't read that much flash! Read 0x%08x of it.\n", len);
 285                         return -EIO;
 286                 }
 287 #endif
 288 #ifdef CONFIG_MTD_RDC3210_FACTORY_PRESENT
 289                 /* 1. Adjust Redboot */
 290                 tmp = rdc3210_mtd->size - rdc3210_parts[4].size;
 291                 rdc3210_parts[4].offset = tmp - (tmp % tmp2);
 292                 rdc3210_parts[4].size   = rdc3210_mtd->size - rdc3210_parts[4].offset;
 293
 294                 /* 2. Adjust Factory Default */
 295                 tmp -= rdc3210_parts[3].size;
 296                 rdc3210_parts[3].offset = tmp - (tmp % tmp2);
 297                 rdc3210_parts[3].size   = rdc3210_parts[4].offset - rdc3210_parts[3].offset;
 298 #else
 299                 /* 1. Adjust Redboot */
 300                 tmp = rdc3210_mtd->size - rdc3210_parts[3].size;
 301                 rdc3210_parts[3].offset = tmp - (tmp % tmp2);
 302                 rdc3210_parts[3].size   = rdc3210_mtd->size - rdc3210_parts[3].offset;
 303 #endif
 304                 if (hdr_type == 1) {
 305                 /* 3. Adjust NVRAM */
 306 #ifdef CONFIG_MTD_RDC3210_ALLOW_JFFS2
 307                 if (*(__u32 *)(((unsigned char *)ptmp)+tmp3) == SQUASHFS_MAGIC)
 308                 {
 309                         len = 1;
 310                         tmp4 = tmp3;
 311                         tmp = hdr->imagesz;
 312                 rdc3210_parts[2].name   = "rootfs_data";
 313                 rdc3210_parts[2].offset = rdc3210_parts[0].offset + (((tmp / tmp2) + ((tmp % tmp2) ? 1 : 0)) * tmp2);
 314                 }
 315                 else
 316 #else
 317                         tmp4 = tmp3;
 318 #endif
 319                 {
 320                         len = 0;
 321                 tmp -= rdc3210_parts[2].size;
 322                 rdc3210_parts[2].offset = tmp - (tmp % tmp2);
 323                 }
 324                 rdc3210_parts[2].size   = rdc3210_parts[3].offset - rdc3210_parts[2].offset;
 325                 }
 326                 else if (hdr_type == 2)
 327                 {
 328                         len = 0;
 329                         tmp4 = tmp3;
 330                 }
 331
 332                 /* 4. Adjust Linux (Kernel + ROMFS) */
 333                 rdc3210_parts[0].size   = rdc3210_parts[len + hdr_type + 1].offset - rdc3210_parts[0].offset;
 334
 335                 /* 5. Adjust ROMFS */
 336                 rdc3210_parts[1].offset = rdc3210_parts[0].offset + tmp4;
 337                 rdc3210_parts[1].size   = rdc3210_parts[hdr_type + 1].offset - rdc3210_parts[1].offset;
 338 #ifdef CONFIG_MTD_RDC3210_ALLOW_JFFS2
 339                 if (!(hdr->reserved || len))
 340                 {
 341                         __u8    buf[1024];
 342                         ptmp->reserved = hdr->imagesz;
 343                         ptmp->imagesz  = tmp4;
 344                         ptmp->checksum = ptmp->fastcksum = 0;
 345                         memcpy(buf, ptmp, 0x100);
 346                         memcpy(buf + 0x100, ((__u8 *)ptmp) + ((tmp4 >> 1) - ((tmp4 & 0x6) >> 1)), 0x100);
 347                         memcpy(buf + 0x200, ((__u8 *)ptmp) + (tmp4 - 0x200), 0x200);
 348                         ptmp->fastcksum = crc32(buf, sizeof(buf));
 349                         ptmp->checksum = crc32((__u8 *)ptmp, tmp4);
 350                         if (rdc3210_mtd->unlock) rdc3210_mtd->unlock(rdc3210_mtd, 0, tmp2);
 351                         if ((len = erase_write(rdc3210_mtd, 0, tmp2, (char *)ptmp)))
 352                         {
 353                                 vfree(ptmp);
 354                                 iounmap((void *)rdc3210_map.map_priv_1);
 355                                 rdc3210_map.map_priv_1 = 0L;
 356                                 rdc3210_map.virt = NULL;
 357                                 printk("Couldn't erase! Got %d.\n", len);
 358                                 return len;
 359                         }
 360                         if (rdc3210_mtd->sync) rdc3210_mtd->sync(rdc3210_mtd);
 361                 }
 362                 vfree(ptmp);
 363 #endif
 364                 rdc3210_mtd->owner = THIS_MODULE;
 365                 add_mtd_partitions(rdc3210_mtd, rdc3210_parts, sizeof(rdc3210_parts)/sizeof(rdc3210_parts[0]));
 366                 return 0;
 367         }
 368 #endif
 369         iounmap((void *)rdc3210_map.map_priv_1);
 370         rdc3210_map.map_priv_1 = 0L;
 371         rdc3210_map.virt = NULL;
 372         return -ENXIO;
 373 }
 374
 375 static void __exit cleanup_rdc3210_map(void)
 376 {
 377         if (rdc3210_mtd)
 378         {
 379                 del_mtd_partitions(rdc3210_mtd);
 380                 map_destroy(rdc3210_mtd);
 381         }
 382
 383         if (rdc3210_map.map_priv_1)
 384         {
 385                 iounmap((void *)rdc3210_map.map_priv_1);
 386                 rdc3210_map.map_priv_1 = 0L;
 387                 rdc3210_map.virt = NULL;
 388         }
 389 }
 390
 391 module_init(init_rdc3210_map);
 392 module_exit(cleanup_rdc3210_map);