Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* sbc_gxx.c -- MTD map driver for Arcom Control Systems SBC-MediaGX, |
2 | SBC-GXm and SBC-GX1 series boards. | |
69f34c98 | 3 | |
1da177e4 | 4 | Copyright (C) 2001 Arcom Control System Ltd |
69f34c98 | 5 | |
1da177e4 LT |
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. | |
69f34c98 | 10 | |
1da177e4 LT |
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. | |
69f34c98 | 15 | |
1da177e4 LT |
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 | ||
69f34c98 TG |
20 | The SBC-MediaGX / SBC-GXx has up to 16 MiB of |
21 | Intel StrataFlash (28F320/28F640) in x8 mode. | |
1da177e4 LT |
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 | |
69f34c98 | 28 | |
1da177e4 | 29 | Two IO address locations for paging |
69f34c98 | 30 | |
1da177e4 LT |
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 | ||
69f34c98 | 38 | The single flash device is divided into 3 partition which appear as |
1da177e4 LT |
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> | |
1da177e4 LT |
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 | ||
69f34c98 | 87 | /* partition_info gives details on the logical partitions that the split the |
1da177e4 LT |
88 | * single flash device into. If the size if zero we use up to the end of the |
89 | * device. */ | |
90 | static struct mtd_partition partition_info[]={ | |
69f34c98 TG |
91 | { .name = "SBC-GXx flash boot partition", |
92 | .offset = 0, | |
1da177e4 | 93 | .size = BOOT_PARTITION_SIZE_KiB*1024 }, |
69f34c98 TG |
94 | { .name = "SBC-GXx flash data partition", |
95 | .offset = BOOT_PARTITION_SIZE_KiB*1024, | |
1da177e4 | 96 | .size = (DATA_PARTITION_SIZE_KiB)*1024 }, |
69f34c98 | 97 | { .name = "SBC-GXx flash application partition", |
1da177e4 LT |
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); | |
69f34c98 | 130 | |
1da177e4 LT |
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) | |
69f34c98 | 150 | { |
1da177e4 LT |
151 | while(len) { |
152 | unsigned long thislen = len; | |
153 | if (len > (WINDOW_LENGTH - (to & WINDOW_MASK))) | |
154 | thislen = WINDOW_LENGTH-(to & WINDOW_MASK); | |
69f34c98 | 155 | |
1da177e4 LT |
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 ) { | |
ee0e87b1 | 185 | mtd_device_unregister(all_mtd); |
1da177e4 LT |
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 | } | |
69f34c98 | 201 | |
1da177e4 LT |
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 | } | |
69f34c98 TG |
209 | |
210 | ||
1da177e4 LT |
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 | } | |
69f34c98 | 222 | |
1da177e4 LT |
223 | all_mtd->owner = THIS_MODULE; |
224 | ||
225 | /* Create MTD devices for each partition. */ | |
ee0e87b1 | 226 | mtd_device_register(all_mtd, partition_info, NUM_PARTITIONS); |
1da177e4 LT |
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"); |