drivers/mtd/maps/sbc_gxx.c

   1 /* sbc_gxx.c -- MTD map driver for Arcom Control Systems SBC-MediaGX,
   2                 SBC-GXm and SBC-GX1 series boards.
   3
   4    Copyright (C) 2001 Arcom Control System Ltd
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19
  20 The SBC-MediaGX / SBC-GXx has up to 16 MiB of
  21 Intel StrataFlash (28F320/28F640) in x8 mode.
  22
  23 This driver uses the CFI probe and Intel Extended Command Set drivers.
  24
  25 The flash is accessed as follows:
  26
  27    16 KiB memory window at 0xdc000-0xdffff
  28
  29    Two IO address locations for paging
  30
  31    0x258
  32        bit 0-7: address bit 14-21
  33    0x259
  34        bit 0-1: address bit 22-23
  35        bit 7:   0 - reset/powered down
  36                 1 - device enabled
  37
  38 The single flash device is divided into 3 partition which appear as
  39 separate MTD devices.
  40
  41 25/04/2001 AJL (Arcom)  Modified signon strings and partition sizes
  42                         (to support bzImages up to 638KiB-ish)
  43 */
  44
  45 // Includes
  46
  47 #include <linux/module.h>
  48 #include <linux/ioport.h>
  49 #include <linux/init.h>
  50 #include <asm/io.h>
  51
  52 #include <linux/mtd/mtd.h>
  53 #include <linux/mtd/map.h>
  54 #include <linux/mtd/partitions.h>
  55
  56 // Defines
  57
  58 // - Hardware specific
  59
  60 #define WINDOW_START 0xdc000
  61
  62 /* Number of bits in offset. */
  63 #define WINDOW_SHIFT 14
  64 #define WINDOW_LENGTH (1 << WINDOW_SHIFT)
  65
  66 /* The bits for the offset into the window. */
  67 #define WINDOW_MASK (WINDOW_LENGTH-1)
  68 #define PAGE_IO 0x258
  69 #define PAGE_IO_SIZE 2
  70
  71 /* bit 7 of 0x259 must be 1 to enable device. */
  72 #define DEVICE_ENABLE 0x8000
  73
  74 // - Flash / Partition sizing
  75
  76 #define MAX_SIZE_KiB             16384
  77 #define BOOT_PARTITION_SIZE_KiB  768
  78 #define DATA_PARTITION_SIZE_KiB  1280
  79 #define APP_PARTITION_SIZE_KiB   6144
  80
  81 // Globals
  82
  83 static volatile int page_in_window = -1; // Current page in window.
  84 static void __iomem *iomapadr;
  85 static DEFINE_SPINLOCK(sbc_gxx_spin);
  86
  87 /* partition_info gives details on the logical partitions that the split the
  88  * single flash device into. If the size if zero we use up to the end of the
  89  * device. */
  90 static const struct mtd_partition partition_info[] = {
  91     { .name = "SBC-GXx flash boot partition",
  92       .offset = 0,
  93       .size =   BOOT_PARTITION_SIZE_KiB*1024 },
  94     { .name = "SBC-GXx flash data partition",
  95       .offset = BOOT_PARTITION_SIZE_KiB*1024,
  96       .size = (DATA_PARTITION_SIZE_KiB)*1024 },
  97     { .name = "SBC-GXx flash application partition",
  98       .offset = (BOOT_PARTITION_SIZE_KiB+DATA_PARTITION_SIZE_KiB)*1024 }
  99 };
 100
 101 #define NUM_PARTITIONS 3
 102
 103 static inline void sbc_gxx_page(struct map_info *map, unsigned long ofs)
 104 {
 105         unsigned long page = ofs >> WINDOW_SHIFT;
 106
 107         if( page!=page_in_window ) {
 108                 outw( page | DEVICE_ENABLE, PAGE_IO );
 109                 page_in_window = page;
 110         }
 111 }
 112
 113
 114 static map_word sbc_gxx_read8(struct map_info *map, unsigned long ofs)
 115 {
 116         map_word ret;
 117         spin_lock(&sbc_gxx_spin);
 118         sbc_gxx_page(map, ofs);
 119         ret.x[0] = readb(iomapadr + (ofs & WINDOW_MASK));
 120         spin_unlock(&sbc_gxx_spin);
 121         return ret;
 122 }
 123
 124 static void sbc_gxx_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
 125 {
 126         while(len) {
 127                 unsigned long thislen = len;
 128                 if (len > (WINDOW_LENGTH - (from & WINDOW_MASK)))
 129                         thislen = WINDOW_LENGTH-(from & WINDOW_MASK);
 130
 131                 spin_lock(&sbc_gxx_spin);
 132                 sbc_gxx_page(map, from);
 133                 memcpy_fromio(to, iomapadr + (from & WINDOW_MASK), thislen);
 134                 spin_unlock(&sbc_gxx_spin);
 135                 to += thislen;
 136                 from += thislen;
 137                 len -= thislen;
 138         }
 139 }
 140
 141 static void sbc_gxx_write8(struct map_info *map, map_word d, unsigned long adr)
 142 {
 143         spin_lock(&sbc_gxx_spin);
 144         sbc_gxx_page(map, adr);
 145         writeb(d.x[0], iomapadr + (adr & WINDOW_MASK));
 146         spin_unlock(&sbc_gxx_spin);
 147 }
 148
 149 static void sbc_gxx_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
 150 {
 151         while(len) {
 152                 unsigned long thislen = len;
 153                 if (len > (WINDOW_LENGTH - (to & WINDOW_MASK)))
 154                         thislen = WINDOW_LENGTH-(to & WINDOW_MASK);
 155
 156                 spin_lock(&sbc_gxx_spin);
 157                 sbc_gxx_page(map, to);
 158                 memcpy_toio(iomapadr + (to & WINDOW_MASK), from, thislen);
 159                 spin_unlock(&sbc_gxx_spin);
 160                 to += thislen;
 161                 from += thislen;
 162                 len -= thislen;
 163         }
 164 }
 165
 166 static struct map_info sbc_gxx_map = {
 167         .name = "SBC-GXx flash",
 168         .phys = NO_XIP,
 169         .size = MAX_SIZE_KiB*1024, /* this must be set to a maximum possible amount
 170                          of flash so the cfi probe routines find all
 171                          the chips */
 172         .bankwidth = 1,
 173         .read = sbc_gxx_read8,
 174         .copy_from = sbc_gxx_copy_from,
 175         .write = sbc_gxx_write8,
 176         .copy_to = sbc_gxx_copy_to
 177 };
 178
 179 /* MTD device for all of the flash. */
 180 static struct mtd_info *all_mtd;
 181
 182 static void cleanup_sbc_gxx(void)
 183 {
 184         if( all_mtd ) {
 185                 mtd_device_unregister(all_mtd);
 186                 map_destroy( all_mtd );
 187         }
 188
 189         iounmap(iomapadr);
 190         release_region(PAGE_IO,PAGE_IO_SIZE);
 191 }
 192
 193 static int __init init_sbc_gxx(void)
 194 {
 195         iomapadr = ioremap(WINDOW_START, WINDOW_LENGTH);
 196         if (!iomapadr) {
 197                 printk( KERN_ERR"%s: failed to ioremap memory region\n",
 198                         sbc_gxx_map.name );
 199                 return -EIO;
 200         }
 201
 202         if (!request_region( PAGE_IO, PAGE_IO_SIZE, "SBC-GXx flash")) {
 203                 printk( KERN_ERR"%s: IO ports 0x%x-0x%x in use\n",
 204                         sbc_gxx_map.name,
 205                         PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1 );
 206                 iounmap(iomapadr);
 207                 return -EAGAIN;
 208         }
 209
 210
 211         printk( KERN_INFO"%s: IO:0x%x-0x%x MEM:0x%x-0x%x\n",
 212                 sbc_gxx_map.name,
 213                 PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1,
 214                 WINDOW_START, WINDOW_START+WINDOW_LENGTH-1 );
 215
 216         /* Probe for chip. */
 217         all_mtd = do_map_probe( "cfi_probe", &sbc_gxx_map );
 218         if( !all_mtd ) {
 219                 cleanup_sbc_gxx();
 220                 return -ENXIO;
 221         }
 222
 223         all_mtd->owner = THIS_MODULE;
 224
 225         /* Create MTD devices for each partition. */
 226         mtd_device_register(all_mtd, partition_info, NUM_PARTITIONS);
 227
 228         return 0;
 229 }
 230
 231 module_init(init_sbc_gxx);
 232 module_exit(cleanup_sbc_gxx);
 233
 234 MODULE_LICENSE("GPL");
 235 MODULE_AUTHOR("Arcom Control Systems Ltd.");
 236 MODULE_DESCRIPTION("MTD map driver for SBC-GXm and SBC-GX1 series boards");