diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/mtd/maps/sbc_gxx.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/mtd/maps/sbc_gxx.c')
-rw-r--r-- | drivers/mtd/maps/sbc_gxx.c | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/drivers/mtd/maps/sbc_gxx.c b/drivers/mtd/maps/sbc_gxx.c new file mode 100644 index 000000000000..65add28bde14 --- /dev/null +++ b/drivers/mtd/maps/sbc_gxx.c | |||
@@ -0,0 +1,239 @@ | |||
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 | $Id: sbc_gxx.c,v 1.33 2004/11/28 09:40:40 dwmw2 Exp $ | ||
21 | |||
22 | The SBC-MediaGX / SBC-GXx has up to 16 MiB of | ||
23 | Intel StrataFlash (28F320/28F640) in x8 mode. | ||
24 | |||
25 | This driver uses the CFI probe and Intel Extended Command Set drivers. | ||
26 | |||
27 | The flash is accessed as follows: | ||
28 | |||
29 | 16 KiB memory window at 0xdc000-0xdffff | ||
30 | |||
31 | Two IO address locations for paging | ||
32 | |||
33 | 0x258 | ||
34 | bit 0-7: address bit 14-21 | ||
35 | 0x259 | ||
36 | bit 0-1: address bit 22-23 | ||
37 | bit 7: 0 - reset/powered down | ||
38 | 1 - device enabled | ||
39 | |||
40 | The single flash device is divided into 3 partition which appear as | ||
41 | separate MTD devices. | ||
42 | |||
43 | 25/04/2001 AJL (Arcom) Modified signon strings and partition sizes | ||
44 | (to support bzImages up to 638KiB-ish) | ||
45 | */ | ||
46 | |||
47 | // Includes | ||
48 | |||
49 | #include <linux/module.h> | ||
50 | #include <linux/slab.h> | ||
51 | #include <linux/ioport.h> | ||
52 | #include <linux/init.h> | ||
53 | #include <asm/io.h> | ||
54 | |||
55 | #include <linux/mtd/mtd.h> | ||
56 | #include <linux/mtd/map.h> | ||
57 | #include <linux/mtd/partitions.h> | ||
58 | |||
59 | // Defines | ||
60 | |||
61 | // - Hardware specific | ||
62 | |||
63 | #define WINDOW_START 0xdc000 | ||
64 | |||
65 | /* Number of bits in offset. */ | ||
66 | #define WINDOW_SHIFT 14 | ||
67 | #define WINDOW_LENGTH (1 << WINDOW_SHIFT) | ||
68 | |||
69 | /* The bits for the offset into the window. */ | ||
70 | #define WINDOW_MASK (WINDOW_LENGTH-1) | ||
71 | #define PAGE_IO 0x258 | ||
72 | #define PAGE_IO_SIZE 2 | ||
73 | |||
74 | /* bit 7 of 0x259 must be 1 to enable device. */ | ||
75 | #define DEVICE_ENABLE 0x8000 | ||
76 | |||
77 | // - Flash / Partition sizing | ||
78 | |||
79 | #define MAX_SIZE_KiB 16384 | ||
80 | #define BOOT_PARTITION_SIZE_KiB 768 | ||
81 | #define DATA_PARTITION_SIZE_KiB 1280 | ||
82 | #define APP_PARTITION_SIZE_KiB 6144 | ||
83 | |||
84 | // Globals | ||
85 | |||
86 | static volatile int page_in_window = -1; // Current page in window. | ||
87 | static void __iomem *iomapadr; | ||
88 | static DEFINE_SPINLOCK(sbc_gxx_spin); | ||
89 | |||
90 | /* partition_info gives details on the logical partitions that the split the | ||
91 | * single flash device into. If the size if zero we use up to the end of the | ||
92 | * device. */ | ||
93 | static struct mtd_partition partition_info[]={ | ||
94 | { .name = "SBC-GXx flash boot partition", | ||
95 | .offset = 0, | ||
96 | .size = BOOT_PARTITION_SIZE_KiB*1024 }, | ||
97 | { .name = "SBC-GXx flash data partition", | ||
98 | .offset = BOOT_PARTITION_SIZE_KiB*1024, | ||
99 | .size = (DATA_PARTITION_SIZE_KiB)*1024 }, | ||
100 | { .name = "SBC-GXx flash application partition", | ||
101 | .offset = (BOOT_PARTITION_SIZE_KiB+DATA_PARTITION_SIZE_KiB)*1024 } | ||
102 | }; | ||
103 | |||
104 | #define NUM_PARTITIONS 3 | ||
105 | |||
106 | static inline void sbc_gxx_page(struct map_info *map, unsigned long ofs) | ||
107 | { | ||
108 | unsigned long page = ofs >> WINDOW_SHIFT; | ||
109 | |||
110 | if( page!=page_in_window ) { | ||
111 | outw( page | DEVICE_ENABLE, PAGE_IO ); | ||
112 | page_in_window = page; | ||
113 | } | ||
114 | } | ||
115 | |||
116 | |||
117 | static map_word sbc_gxx_read8(struct map_info *map, unsigned long ofs) | ||
118 | { | ||
119 | map_word ret; | ||
120 | spin_lock(&sbc_gxx_spin); | ||
121 | sbc_gxx_page(map, ofs); | ||
122 | ret.x[0] = readb(iomapadr + (ofs & WINDOW_MASK)); | ||
123 | spin_unlock(&sbc_gxx_spin); | ||
124 | return ret; | ||
125 | } | ||
126 | |||
127 | static void sbc_gxx_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) | ||
128 | { | ||
129 | while(len) { | ||
130 | unsigned long thislen = len; | ||
131 | if (len > (WINDOW_LENGTH - (from & WINDOW_MASK))) | ||
132 | thislen = WINDOW_LENGTH-(from & WINDOW_MASK); | ||
133 | |||
134 | spin_lock(&sbc_gxx_spin); | ||
135 | sbc_gxx_page(map, from); | ||
136 | memcpy_fromio(to, iomapadr + (from & WINDOW_MASK), thislen); | ||
137 | spin_unlock(&sbc_gxx_spin); | ||
138 | to += thislen; | ||
139 | from += thislen; | ||
140 | len -= thislen; | ||
141 | } | ||
142 | } | ||
143 | |||
144 | static void sbc_gxx_write8(struct map_info *map, map_word d, unsigned long adr) | ||
145 | { | ||
146 | spin_lock(&sbc_gxx_spin); | ||
147 | sbc_gxx_page(map, adr); | ||
148 | writeb(d.x[0], iomapadr + (adr & WINDOW_MASK)); | ||
149 | spin_unlock(&sbc_gxx_spin); | ||
150 | } | ||
151 | |||
152 | static void sbc_gxx_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) | ||
153 | { | ||
154 | while(len) { | ||
155 | unsigned long thislen = len; | ||
156 | if (len > (WINDOW_LENGTH - (to & WINDOW_MASK))) | ||
157 | thislen = WINDOW_LENGTH-(to & WINDOW_MASK); | ||
158 | |||
159 | spin_lock(&sbc_gxx_spin); | ||
160 | sbc_gxx_page(map, to); | ||
161 | memcpy_toio(iomapadr + (to & WINDOW_MASK), from, thislen); | ||
162 | spin_unlock(&sbc_gxx_spin); | ||
163 | to += thislen; | ||
164 | from += thislen; | ||
165 | len -= thislen; | ||
166 | } | ||
167 | } | ||
168 | |||
169 | static struct map_info sbc_gxx_map = { | ||
170 | .name = "SBC-GXx flash", | ||
171 | .phys = NO_XIP, | ||
172 | .size = MAX_SIZE_KiB*1024, /* this must be set to a maximum possible amount | ||
173 | of flash so the cfi probe routines find all | ||
174 | the chips */ | ||
175 | .bankwidth = 1, | ||
176 | .read = sbc_gxx_read8, | ||
177 | .copy_from = sbc_gxx_copy_from, | ||
178 | .write = sbc_gxx_write8, | ||
179 | .copy_to = sbc_gxx_copy_to | ||
180 | }; | ||
181 | |||
182 | /* MTD device for all of the flash. */ | ||
183 | static struct mtd_info *all_mtd; | ||
184 | |||
185 | static void cleanup_sbc_gxx(void) | ||
186 | { | ||
187 | if( all_mtd ) { | ||
188 | del_mtd_partitions( all_mtd ); | ||
189 | map_destroy( all_mtd ); | ||
190 | } | ||
191 | |||
192 | iounmap(iomapadr); | ||
193 | release_region(PAGE_IO,PAGE_IO_SIZE); | ||
194 | } | ||
195 | |||
196 | static int __init init_sbc_gxx(void) | ||
197 | { | ||
198 | iomapadr = ioremap(WINDOW_START, WINDOW_LENGTH); | ||
199 | if (!iomapadr) { | ||
200 | printk( KERN_ERR"%s: failed to ioremap memory region\n", | ||
201 | sbc_gxx_map.name ); | ||
202 | return -EIO; | ||
203 | } | ||
204 | |||
205 | if (!request_region( PAGE_IO, PAGE_IO_SIZE, "SBC-GXx flash")) { | ||
206 | printk( KERN_ERR"%s: IO ports 0x%x-0x%x in use\n", | ||
207 | sbc_gxx_map.name, | ||
208 | PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1 ); | ||
209 | iounmap(iomapadr); | ||
210 | return -EAGAIN; | ||
211 | } | ||
212 | |||
213 | |||
214 | printk( KERN_INFO"%s: IO:0x%x-0x%x MEM:0x%x-0x%x\n", | ||
215 | sbc_gxx_map.name, | ||
216 | PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1, | ||
217 | WINDOW_START, WINDOW_START+WINDOW_LENGTH-1 ); | ||
218 | |||
219 | /* Probe for chip. */ | ||
220 | all_mtd = do_map_probe( "cfi_probe", &sbc_gxx_map ); | ||
221 | if( !all_mtd ) { | ||
222 | cleanup_sbc_gxx(); | ||
223 | return -ENXIO; | ||
224 | } | ||
225 | |||
226 | all_mtd->owner = THIS_MODULE; | ||
227 | |||
228 | /* Create MTD devices for each partition. */ | ||
229 | add_mtd_partitions(all_mtd, partition_info, NUM_PARTITIONS ); | ||
230 | |||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | module_init(init_sbc_gxx); | ||
235 | module_exit(cleanup_sbc_gxx); | ||
236 | |||
237 | MODULE_LICENSE("GPL"); | ||
238 | MODULE_AUTHOR("Arcom Control Systems Ltd."); | ||
239 | MODULE_DESCRIPTION("MTD map driver for SBC-GXm and SBC-GX1 series boards"); | ||