kernel/patches-2.4.31/redwood.c

   1 /*
   2  * redwood.c - mapper for IBM Redwood-4/5/6 board.
   3  *
   4  *
   5  * Copyright 2001 - 2002 MontaVista Softare Inc.
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  *  under  the terms of  the GNU General  Public License as published by the
   9  *  Free Software Foundation;  either version 2 of the  License, or (at your
  10  *  option) any later version.
  11  *
  12  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR   IMPLIED
  13  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
  14  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  15  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT,  INDIRECT,
  16  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  17  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
  18  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  19  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
  20  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  21  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22  *
  23  *  You should have received a copy of the  GNU General Public License along
  24  *  with this program; if not, write  to the Free Software Foundation, Inc.,
  25  *  675 Mass Ave, Cambridge, MA 02139, USA.
  26  *
  27  *  History: 12/17/2001 - Armin
  28  *              migrated to use do_map_probe
  29  *
  30  *              : 07/11/02 - Armin
  31  *              added redwood 6 support
  32  *
  33  */
  34
  35 #include <linux/config.h>
  36 #include <linux/module.h>
  37 #include <linux/types.h>
  38 #include <linux/kernel.h>
  39
  40 #include <linux/mtd/mtd.h>
  41 #include <linux/mtd/map.h>
  42 #include <linux/mtd/partitions.h>
  43
  44 #include <asm/io.h>
  45 #define STBXX_VPD_SZ    0x10000
  46 #define STBXX_OB_SZ     0x20000
  47 #define STBXX_4MB       0x4000000
  48
  49 #if !defined (CONFIG_REDWOOD_6)
  50
  51 #define WINDOW_ADDR 0xffc00000
  52 #define WINDOW_SIZE 0x00400000
  53
  54 #define RW_PART0_OF     0
  55 #define RW_PART0_SZ     0x10000
  56 #define RW_PART1_OF     RW_PART0_SZ
  57 #define RW_PART1_SZ     0x200000 - 0x10000
  58 #define RW_PART2_OF     0x200000
  59 #define RW_PART2_SZ     0x10000
  60 #define RW_PART3_OF     0x210000
  61 #define RW_PART3_SZ     0x200000 - (0x10000 + 0x20000)
  62 #define RW_PART4_OF     0x3e0000
  63 #define RW_PART4_SZ     0x20000
  64 static struct mtd_partition redwood_flash_partitions[] = {
  65         {
  66                 name: "Redwood OpenBIOS Vital Product Data",
  67                 offset: RW_PART0_OF,
  68                 size: RW_PART0_SZ,
  69                 mask_flags: MTD_WRITEABLE       /* force read-only */
  70         },
  71         {
  72                 name: "Redwood kernel",
  73                 offset: RW_PART1_OF,
  74                 size: RW_PART1_SZ
  75         },
  76         {
  77                 name: "Redwood OpenBIOS non-volatile storage",
  78                 offset: RW_PART2_OF,
  79                 size: RW_PART2_SZ,
  80                 mask_flags: MTD_WRITEABLE       /* force read-only */
  81         },
  82         {
  83                 name: "Redwood filesystem",
  84                 offset: RW_PART3_OF,
  85                 size: RW_PART3_SZ
  86         },
  87         {
  88                 name: "Redwood OpenBIOS",
  89                 offset: RW_PART4_OF,
  90                 size: RW_PART4_SZ,
  91                 mask_flags: MTD_WRITEABLE       /* force read-only */
  92         }
  93 };
  94
  95 #else
  96
  97 /* FIXME: the window is bigger - armin */
  98
  99 /*
 100  * Change4VideoDongle - H. Lin
 101  * Warnning: What effects would be if not end on erase block size??
 102  * Thus combine VPD,NVRAM,into one 64KB partition, named VPD
 103  */
 104 #if 1   //hcw
 105
 106 /* Supported Devices on HCW MediaMVP */
 107 #define AMD2048X16K
 108 #define AMD512X16K
 109
 110 #ifdef AMD2048X16K
 111
 112 #define MB4_WINDOW_ADDR 0xffc00000                              /* 4MB part */
 113 #define MB4_WINDOW_SIZE 0x00400000                              /* to hook GPIO Pin26 (BI_ADDR10) to A20 */
 114
 115 #define MB4_RW_PART0_OF 0x000000
 116 #define MB4_RW_PART0_SZ 0x2c0000
 117 /*
 118 #define MB4_RW_PART0_SZ 0x2c0000
 119
 120 #define MB4_RW_PART5_OF MB4_RW_PART0_OF + MB4_RW_PART0_SZ
 121 #define MB4_RW_PART5_SZ 0x200000
 122
 123 #define MB4_RW_PART4_OF MB4_RW_PART5_OF + MB4_RW_PART5_SZ
 124 */
 125 #define MB4_RW_PART4_OF MB4_RW_PART0_OF + MB4_RW_PART0_SZ
 126 #define MB4_RW_PART4_SZ 0x100000
 127
 128 #define MB4_RW_PART1_OF MB4_RW_PART4_OF + MB4_RW_PART4_SZ
 129 #define MB4_RW_PART1_SZ 0x010000                                        /* 64KB VPD = 4KB VPD + 4KB NVRAM */
 130
 131 #define MB4_RW_PART2_OF MB4_RW_PART1_OF + MB4_RW_PART1_SZ
 132 #define MB4_RW_PART2_SZ 0x010000                                        /* 64KB LOGO = 56KB LOGO + 8KB XXX */
 133
 134 #define MB4_RW_PART3_OF MB4_RW_PART2_OF + MB4_RW_PART2_SZ       /* 128KB Bootloader(Open BIOS) */
 135 #define MB4_RW_PART3_SZ 0x020000
 136
 137 static struct mtd_partition mb4_redwood_flash_partitions[] = {
 138         {
 139                 name: "HCW MediaMVP KERN",
 140                 offset: MB4_RW_PART0_OF,
 141                 size: MB4_RW_PART0_SZ,
 142         },
 143 /*
 144         {
 145                 name: "HCW MediaMVP FS",
 146                 offset: MB4_RW_PART5_OF,
 147                 size: MB4_RW_PART5_SZ,
 148         },
 149 */
 150         {
 151                 name: "HCW MediaMVP DATA",
 152                 offset: MB4_RW_PART4_OF,
 153                 size: MB4_RW_PART4_SZ,
 154         },
 155         {
 156                 name: "HCW MediaMVP VPD",
 157                 offset: MB4_RW_PART1_OF,
 158                 size: MB4_RW_PART1_SZ,
 159         },
 160         {
 161                 name: "HCW MediaMVP LOGO",
 162                 offset: MB4_RW_PART2_OF,
 163                 size: MB4_RW_PART2_SZ,
 164         },
 165         {
 166                 name: "HCW MediaMVP BOOT",
 167                 offset: MB4_RW_PART3_OF,
 168                 size: MB4_RW_PART3_SZ,
 169         }
 170 };
 171
 172 #endif
 173
 174
 175 #ifdef AMD512X16K
 176
 177 #define MB1_WINDOW_ADDR 0xfff00000
 178 #define MB1_WINDOW_SIZE 0x00100000
 179
 180 #define MB1_RW_PART0_OF 0
 181 #define MB1_RW_PART0_SZ 0x80000                                 /* 8*64 = 512KB data */
 182
 183 #define MB1_RW_PART1_OF MB1_RW_PART0_OF + MB1_RW_PART0_SZ
 184 #define MB1_RW_PART1_SZ 0x10000                                 /* 64KB VPD = 4KB VPD + 4KB NVRAM */
 185
 186 #define MB1_RW_PART2_OF MB1_RW_PART1_OF + MB1_RW_PART1_SZ
 187 #define MB1_RW_PART2_SZ 0x10000                                 /* 64KB LOGO = 56KB LOGO + 8KB XXX */
 188
 189 #define MB1_RW_PART3_OF MB1_RW_PART2_OF + MB1_RW_PART2_SZ
 190 #define MB1_RW_PART3_SZ 0x80000-0x20000-0x20000                 /* 320 - 64 = 256KB File System */
 191
 192 #define MB1_RW_PART4_OF MB1_RW_PART3_OF + MB1_RW_PART3_SZ       /* 128KB Bootloader(Open BIOS) */
 193 #define MB1_RW_PART4_SZ 0x20000
 194
 195 static struct mtd_partition mb1_redwood_flash_partitions[] = {
 196         {
 197                 name: "HCW MediaMVP KERN",
 198                 offset: MB1_RW_PART0_OF,
 199                 size: MB1_RW_PART0_SZ,
 200         },
 201         {
 202                 name: "HCW MediaMVP VPD",
 203                 offset: MB1_RW_PART1_OF,
 204                 size: MB1_RW_PART1_SZ,
 205                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 206         },
 207         {
 208                 name: "HCW MediaMVP LOGO",
 209                 offset: MB1_RW_PART2_OF,
 210                 size: MB1_RW_PART2_SZ,
 211                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 212         },
 213         {
 214                 name: "HCW MediaMVP FS",
 215                 offset: MB1_RW_PART3_OF,
 216                 size: MB1_RW_PART3_SZ,
 217         },
 218         {
 219                 name: "HCW MediaMVP BOOT",
 220                 offset: MB1_RW_PART4_OF,
 221                 size: MB1_RW_PART4_SZ,
 222                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 223         }
 224 };
 225 #endif
 226
 227 #ifdef AMD128X16K
 228
 229 #define MBQ_WINDOW_ADDR 0xfffC0000
 230 #define MBQ_WINDOW_SIZE 0x00040000
 231
 232 #define MBQ_RW_PART0_OF 0
 233 #define MBQ_RW_PART0_SZ 0x10000         /* 64KB VPD (4KB VPD + 4KB NVRAM) */
 234
 235 #define MBQ_RW_PART1_OF MBQ_RW_PART0_OF + MBQ_RW_PART0_SZ
 236 #define MBQ_RW_PART1_SZ 0x10000         /* 64KB Logo */
 237
 238 #define MBQ_RW_PART2_OF MBQ_RW_PART1_OF + MBQ_RW_PART1_SZ
 239 #define MBQ_RW_PART2_SZ 0x20000         /* 128KB Bootloader(Open BIOS) */
 240
 241
 242 static struct mtd_partition mbq_redwood_flash_partitions[] = {
 243         {
 244                 name: "HCW MediaMVP VPD",
 245                 offset: MBQ_RW_PART0_OF,
 246                 size: MBQ_RW_PART0_SZ,
 247                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 248         },
 249         {
 250                 name: "HCW MediaMVP LOGO",
 251                 offset: MBQ_RW_PART1_OF,
 252                 size: MBQ_RW_PART1_SZ,
 253                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 254         },
 255         {
 256                 name: "HCW MediaMVP BOOT",
 257                 offset: MBQ_RW_PART2_OF,
 258                 size: MBQ_RW_PART2_SZ,
 259                 //mask_flags: MTD_WRITEABLE     /* force read-only */
 260         }
 261 };
 262
 263 #endif
 264
 265 #else   //org
 266
 267 #define WINDOW_ADDR 0xff800000
 268 #define WINDOW_SIZE 0x00800000
 269
 270 #define RW_PART0_OF     0
 271 #define RW_PART0_SZ     0x400000        /* 4 MB data */
 272 #define RW_PART1_OF     RW_PART0_OF + RW_PART0_SZ
 273 #define RW_PART1_SZ     0x10000         /* 64K VPD */
 274 #define RW_PART2_OF     RW_PART1_OF + RW_PART1_SZ
 275 #define RW_PART2_SZ     0x400000 - (0x10000 + 0x20000)
 276 #define RW_PART3_OF     RW_PART2_OF + RW_PART2_SZ
 277 #define RW_PART3_SZ     0x20000
 278
 279 static struct mtd_partition redwood_flash_partitions[] = {
 280         {
 281                 name: "Redwood kernel",
 282                 offset: RW_PART0_OF,
 283                 size: RW_PART0_SZ
 284         },
 285         {
 286                 name: "Redwood OpenBIOS Vital Product Data",
 287                 offset: RW_PART1_OF,
 288                 size: RW_PART1_SZ,
 289                 mask_flags: MTD_WRITEABLE       /* force read-only */
 290         },
 291         {
 292                 name: "Redwood filesystem",
 293                 offset: RW_PART2_OF,
 294                 size: RW_PART2_SZ
 295         },
 296         {
 297                 name: "Redwood OpenBIOS",
 298                 offset: RW_PART3_OF,
 299                 size: RW_PART3_SZ,
 300                 mask_flags: MTD_WRITEABLE       /* force read-only */
 301         }
 302 };
 303
 304 #endif
 305
 306 #endif
 307
 308 __u8 redwood_flash_read8(struct map_info *map, unsigned long ofs)
 309 {
 310         return *(__u8 *)(map->map_priv_1 + ofs);
 311 }
 312
 313 __u16 redwood_flash_read16(struct map_info *map, unsigned long ofs)
 314 {
 315         return *(__u16 *)(map->map_priv_1 + ofs);
 316 }
 317
 318 __u32 redwood_flash_read32(struct map_info *map, unsigned long ofs)
 319 {
 320         return *(volatile unsigned int *)(map->map_priv_1 + ofs);
 321 }
 322
 323 void redwood_flash_copy_from(struct map_info *map, void *to,
 324                 unsigned long from, ssize_t len)
 325 {
 326         memcpy(to, (void *)(map->map_priv_1 + from), len);
 327 }
 328
 329 void redwood_flash_write8(struct map_info *map, __u8 d, unsigned long adr)
 330 {
 331         *(__u8 *)(map->map_priv_1 + adr) = d;
 332 }
 333
 334 void redwood_flash_write16(struct map_info *map, __u16 d, unsigned long adr)
 335 {
 336         *(__u16 *)(map->map_priv_1 + adr) = d;
 337 }
 338
 339 void redwood_flash_write32(struct map_info *map, __u32 d, unsigned long adr)
 340 {
 341         *(__u32 *)(map->map_priv_1 + adr) = d;
 342 }
 343
 344 void redwood_flash_copy_to(struct map_info *map, unsigned long to,
 345                 const void *from, ssize_t len)
 346 {
 347         memcpy((void *)(map->map_priv_1 + to), from, len);
 348 }
 349
 350
 351
 352 struct map_info redwood_flash_map = {
 353         name: "HCW MediaMVP",
 354 //      size: WINDOW_SIZE,
 355         buswidth: 2,
 356         read8: redwood_flash_read8,
 357         read16: redwood_flash_read16,
 358         read32: redwood_flash_read32,
 359         copy_from: redwood_flash_copy_from,
 360         write8: redwood_flash_write8,
 361         write16: redwood_flash_write16,
 362         write32: redwood_flash_write32,
 363         copy_to: redwood_flash_copy_to
 364 };
 365
 366 #define NUM_REDWOOD_FLASH_PARTITIONS(flash_partitions) \
 367         (sizeof(flash_partitions)/sizeof((flash_partitions)[0]))
 368
 369
 370 static struct mtd_info *redwood_mtd;
 371
 372 int __init init_redwood_flash(void)
 373 {
 374         int numparts;
 375         struct mtd_partition *redwood_flash_partitions;
 376
 377 #ifdef AMD512X16K
 378         /*
 379          * Am29LV800/200BT does NOT seem to do CFI
 380          */
 381         redwood_flash_map.map_priv_1 =
 382                 (unsigned long)ioremap(MB1_WINDOW_ADDR, MB1_WINDOW_SIZE);
 383
 384         if (!redwood_flash_map.map_priv_1) {
 385                 printk("init_redwood_flash: failed to ioremap\n");
 386                 return -EIO;
 387         }
 388
 389         printk(KERN_NOTICE "HCW MediaMVP: flash mapping: %x at %x to %lx\n",
 390                         MB1_WINDOW_SIZE, MB1_WINDOW_ADDR, redwood_flash_map.map_priv_1);
 391
 392         redwood_flash_map.size = MB1_WINDOW_SIZE;
 393         redwood_mtd = do_map_probe("jedec_probe",&redwood_flash_map);
 394         if(redwood_mtd) {
 395                 printk("jedec_probe: found redwood_mtd size = %08x\n", redwood_mtd->size);
 396                 if( redwood_mtd->size == 0x00100000 ) {
 397                         redwood_flash_partitions = mb1_redwood_flash_partitions;
 398                         numparts = NUM_REDWOOD_FLASH_PARTITIONS(mb1_redwood_flash_partitions);
 399                         printk(KERN_NOTICE "HCW MediaMVP: jedec_probe: add [%d]parts\n", numparts);
 400                         goto add_parts;
 401                 } else {
 402                         map_destroy( redwood_mtd );
 403                 }
 404         }
 405         printk(KERN_NOTICE "HCW MediaMVP: jedec_probe: no known JEDEC part found\n");
 406         iounmap((void*)(redwood_flash_map.map_priv_1));
 407
 408 try_4mb_flash:
 409 #endif
 410
 411 #ifdef AMD2048X16K
 412
 413         redwood_flash_map.map_priv_1 =
 414                 (unsigned long)ioremap(MB4_WINDOW_ADDR, MB4_WINDOW_SIZE);
 415
 416         if (!redwood_flash_map.map_priv_1) {
 417                 printk("init_redwood_flash: failed to ioremap\n");
 418                 return -EIO;
 419         }
 420
 421         printk(KERN_NOTICE "HCW MediaMVP: flash mapping: %x at %x to %lx\n",
 422                         MB4_WINDOW_SIZE, MB4_WINDOW_ADDR, redwood_flash_map.map_priv_1);
 423
 424 #if 1
 425         /*
 426          * do CFI for 320DT
 427          */
 428         redwood_flash_map.size = MB4_WINDOW_SIZE;
 429         redwood_mtd = do_map_probe("cfi_probe",&redwood_flash_map);
 430         if(redwood_mtd) {
 431                 printk("cfi_probe: found redwood_mtd size = %08x\n", redwood_mtd->size);
 432                 redwood_flash_partitions = mb4_redwood_flash_partitions;
 433                 numparts = NUM_REDWOOD_FLASH_PARTITIONS(mb4_redwood_flash_partitions);
 434                 printk(KERN_NOTICE "HCW MediaMVP: cfi_probe: adding [%d]parts\n", numparts);
 435                 goto add_parts;
 436         }
 437         else {
 438                 printk(KERN_NOTICE "HCW MediaMVP: cfi_probe: no known CFI part found\n");
 439                 iounmap((void*)(redwood_flash_map.map_priv_1));
 440         }
 441 #endif
 442
 443 #if 0
 444         /*
 445          * try jedec too for ST320DT???
 446          */
 447         redwood_flash_map.map_priv_1 =
 448                 (unsigned long)ioremap(MB4_WINDOW_ADDR, MB4_WINDOW_SIZE);
 449
 450         if (!redwood_flash_map.map_priv_1) {
 451                 printk("init_redwood_flash: failed to ioremap\n");
 452                 return -EIO;
 453         }
 454
 455         printk(KERN_NOTICE "HCW MediaMVP: flash mapping: %x at %x to %lx\n",
 456                         MB4_WINDOW_SIZE, MB4_WINDOW_ADDR, redwood_flash_map.map_priv_1);
 457
 458         redwood_flash_map.size = MB4_WINDOW_SIZE;
 459         redwood_mtd = do_map_probe("jedec_probe",&redwood_flash_map);
 460         if(redwood_mtd) {
 461                 printk("jedec_probe: found redwood_mtd size = %08x\n", redwood_mtd->size);
 462                 redwood_flash_partitions = mb4_redwood_flash_partitions;
 463                 numparts = NUM_REDWOOD_FLASH_PARTITIONS(mb4_redwood_flash_partitions);
 464                 printk(KERN_NOTICE "HCW MediaMVP: jedec_probe: adding [%d]parts\n", numparts);
 465                 goto add_parts;
 466         }
 467         else {
 468                 printk(KERN_NOTICE "HCW MediaMVP: jedec_probe: no known CFI part found\n");
 469                 iounmap((void*)(redwood_flash_map.map_priv_1));
 470         }
 471 #endif
 472 #endif
 473
 474
 475 add_parts:
 476         if (redwood_mtd) {
 477                 redwood_mtd->module = THIS_MODULE;
 478                 return add_mtd_partitions(redwood_mtd, redwood_flash_partitions, numparts);
 479         }
 480
 481         return -ENXIO;
 482 }
 483
 484 static void __exit cleanup_redwood_flash(void)
 485 {
 486         if (redwood_mtd) {
 487                 del_mtd_partitions(redwood_mtd);
 488                 /* moved iounmap after map_destroy  -armin*/
 489                 map_destroy(redwood_mtd);
 490                 iounmap((void *)redwood_flash_map.map_priv_1);
 491         }
 492 }
 493
 494 module_init(init_redwood_flash);
 495 module_exit(cleanup_redwood_flash);
 496
 497 MODULE_LICENSE("GPL");
 498 MODULE_AUTHOR("Armin Kuster <akuster@mvista.com>");
 499 MODULE_DESCRIPTION("MTD map driver for the IBM Redwood reference boards");