git.oblomov.eu Git - linux-2.6/blob - 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/slab.h>
  49 #include <linux/ioport.h>
  50 #include <linux/init.h>
  51 #include <asm/io.h>
  52
  53 #include <linux/mtd/mtd.h>
  54 #include <linux/mtd/map.h>
  55 #include <linux/mtd/partitions.h>
  56
  57 // Defines
  58
  59 // - Hardware specific
  60
  61 #define WINDOW_START 0xdc000
  62
  63 /* Number of bits in offset. */
  64 #define WINDOW_SHIFT 14
  65 #define WINDOW_LENGTH (1 << WINDOW_SHIFT)
  66
  67 /* The bits for the offset into the window. */
  68 #define WINDOW_MASK (WINDOW_LENGTH-1)
  69 #define PAGE_IO 0x258
  70 #define PAGE_IO_SIZE 2
  71
  72 /* bit 7 of 0x259 must be 1 to enable device. */
  73 #define DEVICE_ENABLE 0x8000
  74
  75 // - Flash / Partition sizing
  76
  77 #define MAX_SIZE_KiB             16384
  78 #define BOOT_PARTITION_SIZE_KiB  768
  79 #define DATA_PARTITION_SIZE_KiB  1280
  80 #define APP_PARTITION_SIZE_KiB   6144
  81
  82 // Globals
  83
  84 static volatile int page_in_window = -1; // Current page in window.
  85 static void __iomem *iomapadr;
  86 static DEFINE_SPINLOCK(sbc_gxx_spin);
  87
  88 /* partition_info gives details on the logical partitions that the split the
  89  * single flash device into. If the size if zero we use up to the end of the
  90  * device. */
  91 static struct mtd_partition partition_info[]={
  92     { .name = "SBC-GXx flash boot partition",
  93       .offset = 0,
  94       .size =   BOOT_PARTITION_SIZE_KiB*1024 },
  95     { .name = "SBC-GXx flash data partition",
  96       .offset = BOOT_PARTITION_SIZE_KiB*1024,
  97       .size = (DATA_PARTITION_SIZE_KiB)*1024 },
  98     { .name = "SBC-GXx flash application partition",
  99       .offset = (BOOT_PARTITION_SIZE_KiB+DATA_PARTITION_SIZE_KiB)*1024 }
 100 };
 101
 102 #define NUM_PARTITIONS 3
 103
 104 static inline void sbc_gxx_page(struct map_info *map, unsigned long ofs)
 105 {
 106         unsigned long page = ofs >> WINDOW_SHIFT;
 107
 108         if( page!=page_in_window ) {
 109                 outw( page | DEVICE_ENABLE, PAGE_IO );
 110                 page_in_window = page;
 111         }
 112 }
 113
 114
 115 static map_word sbc_gxx_read8(struct map_info *map, unsigned long ofs)
 116 {
 117         map_word ret;
 118         spin_lock(&sbc_gxx_spin);
 119         sbc_gxx_page(map, ofs);
 120         ret.x[0] = readb(iomapadr + (ofs & WINDOW_MASK));
 121         spin_unlock(&sbc_gxx_spin);
 122         return ret;
 123 }
 124
 125 static void sbc_gxx_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
 126 {
 127         while(len) {
 128                 unsigned long thislen = len;
 129                 if (len > (WINDOW_LENGTH - (from & WINDOW_MASK)))
 130                         thislen = WINDOW_LENGTH-(from & WINDOW_MASK);
 131
 132                 spin_lock(&sbc_gxx_spin);
 133                 sbc_gxx_page(map, from);
 134                 memcpy_fromio(to, iomapadr + (from & WINDOW_MASK), thislen);
 135                 spin_unlock(&sbc_gxx_spin);
 136                 to += thislen;
 137                 from += thislen;
 138                 len -= thislen;
 139         }
 140 }
 141
 142 static void sbc_gxx_write8(struct map_info *map, map_word d, unsigned long adr)
 143 {
 144         spin_lock(&sbc_gxx_spin);
 145         sbc_gxx_page(map, adr);
 146         writeb(d.x[0], iomapadr + (adr & WINDOW_MASK));
 147         spin_unlock(&sbc_gxx_spin);
 148 }
 149
 150 static void sbc_gxx_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
 151 {
 152         while(len) {
 153                 unsigned long thislen = len;
 154                 if (len > (WINDOW_LENGTH - (to & WINDOW_MASK)))
 155                         thislen = WINDOW_LENGTH-(to & WINDOW_MASK);
 156
 157                 spin_lock(&sbc_gxx_spin);
 158                 sbc_gxx_page(map, to);
 159                 memcpy_toio(iomapadr + (to & WINDOW_MASK), from, thislen);
 160                 spin_unlock(&sbc_gxx_spin);
 161                 to += thislen;
 162                 from += thislen;
 163                 len -= thislen;
 164         }
 165 }
 166
 167 static struct map_info sbc_gxx_map = {
 168         .name = "SBC-GXx flash",
 169         .phys = NO_XIP,
 170         .size = MAX_SIZE_KiB*1024, /* this must be set to a maximum possible amount
 171                          of flash so the cfi probe routines find all
 172                          the chips */
 173         .bankwidth = 1,
 174         .read = sbc_gxx_read8,
 175         .copy_from = sbc_gxx_copy_from,
 176         .write = sbc_gxx_write8,
 177         .copy_to = sbc_gxx_copy_to
 178 };
 179
 180 /* MTD device for all of the flash. */
 181 static struct mtd_info *all_mtd;
 182
 183 static void cleanup_sbc_gxx(void)
 184 {
 185         if( all_mtd ) {
 186                 del_mtd_partitions( all_mtd );
 187                 map_destroy( all_mtd );
 188         }
 189
 190         iounmap(iomapadr);
 191         release_region(PAGE_IO,PAGE_IO_SIZE);
 192 }
 193
 194 static int __init init_sbc_gxx(void)
 195 {
 196         iomapadr = ioremap(WINDOW_START, WINDOW_LENGTH);
 197         if (!iomapadr) {
 198                 printk( KERN_ERR"%s: failed to ioremap memory region\n",
 199                         sbc_gxx_map.name );
 200                 return -EIO;
 201         }
 202
 203         if (!request_region( PAGE_IO, PAGE_IO_SIZE, "SBC-GXx flash")) {
 204                 printk( KERN_ERR"%s: IO ports 0x%x-0x%x in use\n",
 205                         sbc_gxx_map.name,
 206                         PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1 );
 207                 iounmap(iomapadr);
 208                 return -EAGAIN;
 209         }
 210
 211
 212         printk( KERN_INFO"%s: IO:0x%x-0x%x MEM:0x%x-0x%x\n",
 213                 sbc_gxx_map.name,
 214                 PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1,
 215                 WINDOW_START, WINDOW_START+WINDOW_LENGTH-1 );
 216
 217         /* Probe for chip. */
 218         all_mtd = do_map_probe( "cfi_probe", &sbc_gxx_map );
 219         if( !all_mtd ) {
 220                 cleanup_sbc_gxx();
 221                 return -ENXIO;
 222         }
 223
 224         all_mtd->owner = THIS_MODULE;
 225
 226         /* Create MTD devices for each partition. */
 227         add_mtd_partitions(all_mtd, partition_info, NUM_PARTITIONS );
 228
 229         return 0;
 230 }
 231
 232 module_init(init_sbc_gxx);
 233 module_exit(cleanup_sbc_gxx);
 234
 235 MODULE_LICENSE("GPL");
 236 MODULE_AUTHOR("Arcom Control Systems Ltd.");
 237 MODULE_DESCRIPTION("MTD map driver for SBC-GXm and SBC-GX1 series boards");