diff options
Diffstat (limited to 'drivers/mtd/maps')
-rw-r--r-- | drivers/mtd/maps/Kconfig | 117 | ||||
-rw-r--r-- | drivers/mtd/maps/Makefile | 11 | ||||
-rw-r--r-- | drivers/mtd/maps/alchemy-flash.c | 192 | ||||
-rw-r--r-- | drivers/mtd/maps/amd76xrom.c | 4 | ||||
-rw-r--r-- | drivers/mtd/maps/bast-flash.c | 13 | ||||
-rw-r--r-- | drivers/mtd/maps/db1550-flash.c | 187 | ||||
-rw-r--r-- | drivers/mtd/maps/db1x00-flash.c | 226 | ||||
-rw-r--r-- | drivers/mtd/maps/elan-104nc.c | 228 | ||||
-rw-r--r-- | drivers/mtd/maps/ichxrom.c | 6 | ||||
-rw-r--r-- | drivers/mtd/maps/ixp2000.c | 7 | ||||
-rw-r--r-- | drivers/mtd/maps/mainstone-flash.c | 178 | ||||
-rw-r--r-- | drivers/mtd/maps/map_funcs.c | 11 | ||||
-rw-r--r-- | drivers/mtd/maps/omap_nor.c | 179 | ||||
-rw-r--r-- | drivers/mtd/maps/pb1550-flash.c | 203 | ||||
-rw-r--r-- | drivers/mtd/maps/pb1xxx-flash.c | 178 | ||||
-rw-r--r-- | drivers/mtd/maps/pci.c | 4 | ||||
-rw-r--r-- | drivers/mtd/maps/plat-ram.c | 278 | ||||
-rw-r--r-- | drivers/mtd/maps/scb2_flash.c | 4 | ||||
-rw-r--r-- | drivers/mtd/maps/sharpsl-flash.c | 33 |
19 files changed, 918 insertions, 1141 deletions
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig index 2bea2e0b06f2..44781a83b2e7 100644 --- a/drivers/mtd/maps/Kconfig +++ b/drivers/mtd/maps/Kconfig | |||
@@ -1,5 +1,5 @@ | |||
1 | # drivers/mtd/maps/Kconfig | 1 | # drivers/mtd/maps/Kconfig |
2 | # $Id: Kconfig,v 1.42 2005/01/05 16:59:50 dwmw2 Exp $ | 2 | # $Id: Kconfig,v 1.55 2005/07/02 01:53:24 tpoynor Exp $ |
3 | 3 | ||
4 | menu "Mapping drivers for chip access" | 4 | menu "Mapping drivers for chip access" |
5 | depends on MTD!=n | 5 | depends on MTD!=n |
@@ -122,16 +122,6 @@ config MTD_SBC_GXX | |||
122 | More info at | 122 | More info at |
123 | <http://www.arcomcontrols.com/products/icp/pc104/processors/SBC_GX1.htm>. | 123 | <http://www.arcomcontrols.com/products/icp/pc104/processors/SBC_GX1.htm>. |
124 | 124 | ||
125 | config MTD_ELAN_104NC | ||
126 | tristate "CFI Flash device mapped on Arcom ELAN-104NC" | ||
127 | depends on X86 && MTD_CFI_INTELEXT && MTD_PARTITIONS && MTD_COMPLEX_MAPPINGS | ||
128 | help | ||
129 | This provides a driver for the on-board flash of the Arcom Control | ||
130 | System's ELAN-104NC development board. By default the flash | ||
131 | is split into 3 partitions which are accessed as separate MTD | ||
132 | devices. This board utilizes Intel StrataFlash. More info at | ||
133 | <http://www.arcomcontrols.com/products/icp/pc104/processors/ELAN104NC.htm>. | ||
134 | |||
135 | config MTD_LUBBOCK | 125 | config MTD_LUBBOCK |
136 | tristate "CFI Flash device mapped on Intel Lubbock XScale eval board" | 126 | tristate "CFI Flash device mapped on Intel Lubbock XScale eval board" |
137 | depends on ARCH_LUBBOCK && MTD_CFI_INTELEXT && MTD_PARTITIONS | 127 | depends on ARCH_LUBBOCK && MTD_CFI_INTELEXT && MTD_PARTITIONS |
@@ -139,6 +129,14 @@ config MTD_LUBBOCK | |||
139 | This provides a driver for the on-board flash of the Intel | 129 | This provides a driver for the on-board flash of the Intel |
140 | 'Lubbock' XScale evaluation board. | 130 | 'Lubbock' XScale evaluation board. |
141 | 131 | ||
132 | config MTD_MAINSTONE | ||
133 | tristate "CFI Flash device mapped on Intel Mainstone XScale eval board" | ||
134 | depends on MACH_MAINSTONE && MTD_CFI_INTELEXT | ||
135 | select MTD_PARTITIONS | ||
136 | help | ||
137 | This provides a driver for the on-board flash of the Intel | ||
138 | 'Mainstone PXA27x evaluation board. | ||
139 | |||
142 | config MTD_OCTAGON | 140 | config MTD_OCTAGON |
143 | tristate "JEDEC Flash device mapped on Octagon 5066 SBC" | 141 | tristate "JEDEC Flash device mapped on Octagon 5066 SBC" |
144 | depends on X86 && MTD_JEDEC && MTD_COMPLEX_MAPPINGS | 142 | depends on X86 && MTD_JEDEC && MTD_COMPLEX_MAPPINGS |
@@ -213,74 +211,11 @@ config MTD_NETtel | |||
213 | help | 211 | help |
214 | Support for flash chips on NETtel/SecureEdge/SnapGear boards. | 212 | Support for flash chips on NETtel/SecureEdge/SnapGear boards. |
215 | 213 | ||
216 | config MTD_PB1XXX | 214 | config MTD_ALCHEMY |
217 | tristate "Flash devices on Alchemy PB1xxx boards" | 215 | tristate ' AMD Alchemy Pb1xxx/Db1xxx/RDK MTD support' |
218 | depends on MIPS && ( MIPS_PB1000 || MIPS_PB1100 || MIPS_PB1500 ) | 216 | depends on MIPS && SOC_AU1X00 |
219 | help | ||
220 | Flash memory access on Alchemy Pb1000/Pb1100/Pb1500 boards | ||
221 | |||
222 | config MTD_PB1XXX_BOOT | ||
223 | bool "PB1x00 boot flash device" | ||
224 | depends on MTD_PB1XXX && ( MIPS_PB1100 || MIPS_PB1500 ) | ||
225 | help | ||
226 | Use the first of the two 32MiB flash banks on Pb1100/Pb1500 board. | ||
227 | You can say 'Y' to both this and 'MTD_PB1XXX_USER' below, to use | ||
228 | both banks. | ||
229 | |||
230 | config MTD_PB1XXX_USER | ||
231 | bool "PB1x00 user flash device" | ||
232 | depends on MTD_PB1XXX && ( MIPS_PB1100 || MIPS_PB1500 ) | ||
233 | default y if MTD_PB1XX_BOOT = n | ||
234 | help | ||
235 | Use the second of the two 32MiB flash banks on Pb1100/Pb1500 board. | ||
236 | You can say 'Y' to both this and 'MTD_PB1XXX_BOOT' above, to use | ||
237 | both banks. | ||
238 | |||
239 | config MTD_PB1550 | ||
240 | tristate "Flash devices on Alchemy PB1550 board" | ||
241 | depends on MIPS && MIPS_PB1550 | ||
242 | help | ||
243 | Flash memory access on Alchemy Pb1550 board | ||
244 | |||
245 | config MTD_PB1550_BOOT | ||
246 | bool "PB1550 boot flash device" | ||
247 | depends on MTD_PB1550 | ||
248 | help | 217 | help |
249 | Use the first of the two 64MiB flash banks on Pb1550 board. | 218 | Flash memory access on AMD Alchemy Pb/Db/RDK Reference Boards |
250 | You can say 'Y' to both this and 'MTD_PB1550_USER' below, to use | ||
251 | both banks. | ||
252 | |||
253 | config MTD_PB1550_USER | ||
254 | bool "PB1550 user flash device" | ||
255 | depends on MTD_PB1550 | ||
256 | default y if MTD_PB1550_BOOT = n | ||
257 | help | ||
258 | Use the second of the two 64MiB flash banks on Pb1550 board. | ||
259 | You can say 'Y' to both this and 'MTD_PB1550_BOOT' above, to use | ||
260 | both banks. | ||
261 | |||
262 | config MTD_DB1550 | ||
263 | tristate "Flash devices on Alchemy DB1550 board" | ||
264 | depends on MIPS && MIPS_DB1550 | ||
265 | help | ||
266 | Flash memory access on Alchemy Db1550 board | ||
267 | |||
268 | config MTD_DB1550_BOOT | ||
269 | bool "DB1550 boot flash device" | ||
270 | depends on MTD_DB1550 | ||
271 | help | ||
272 | Use the first of the two 64MiB flash banks on Db1550 board. | ||
273 | You can say 'Y' to both this and 'MTD_DB1550_USER' below, to use | ||
274 | both banks. | ||
275 | |||
276 | config MTD_DB1550_USER | ||
277 | bool "DB1550 user flash device" | ||
278 | depends on MTD_DB1550 | ||
279 | default y if MTD_DB1550_BOOT = n | ||
280 | help | ||
281 | Use the second of the two 64MiB flash banks on Db1550 board. | ||
282 | You can say 'Y' to both this and 'MTD_DB1550_BOOT' above, to use | ||
283 | both banks. | ||
284 | 219 | ||
285 | config MTD_DILNETPC | 220 | config MTD_DILNETPC |
286 | tristate "CFI Flash device mapped on DIL/Net PC" | 221 | tristate "CFI Flash device mapped on DIL/Net PC" |
@@ -588,6 +523,15 @@ config MTD_MPC1211 | |||
588 | This enables access to the flash chips on the Interface MPC-1211(CTP/PCI/MPC-SH02). | 523 | This enables access to the flash chips on the Interface MPC-1211(CTP/PCI/MPC-SH02). |
589 | If you have such a board, say 'Y'. | 524 | If you have such a board, say 'Y'. |
590 | 525 | ||
526 | config MTD_OMAP_NOR | ||
527 | tristate "TI OMAP board mappings" | ||
528 | depends on MTD_CFI && ARCH_OMAP | ||
529 | help | ||
530 | This enables access to the NOR flash chips on TI OMAP-based | ||
531 | boards defining flash platform devices and flash platform data. | ||
532 | These boards include the Innovator, H2, H3, OSK, Perseus2, and | ||
533 | more. If you have such a board, say 'Y'. | ||
534 | |||
591 | # This needs CFI or JEDEC, depending on the cards found. | 535 | # This needs CFI or JEDEC, depending on the cards found. |
592 | config MTD_PCI | 536 | config MTD_PCI |
593 | tristate "PCI MTD driver" | 537 | tristate "PCI MTD driver" |
@@ -647,13 +591,14 @@ config MTD_DMV182 | |||
647 | Map driver for Dy-4 SVME/DMV-182 board. | 591 | Map driver for Dy-4 SVME/DMV-182 board. |
648 | 592 | ||
649 | config MTD_BAST | 593 | config MTD_BAST |
650 | tristate "Map driver for Simtec BAST (EB2410ITX)" | 594 | tristate "Map driver for Simtec BAST (EB2410ITX) or Thorcom VR1000" |
651 | depends on ARCH_BAST | 595 | depends on ARCH_BAST || MACH_VR1000 |
652 | select MTD_PARTITIONS | 596 | select MTD_PARTITIONS |
653 | select MTD_MAP_BANK_WIDTH_16 | 597 | select MTD_MAP_BANK_WIDTH_16 |
654 | select MTD_JEDECPROBE | 598 | select MTD_JEDECPROBE |
655 | help | 599 | help |
656 | Map driver for NOR flash on the Simtec BAST (EB2410ITX). | 600 | Map driver for NOR flash on the Simtec BAST (EB2410ITX), or the |
601 | Thorcom VR1000 | ||
657 | 602 | ||
658 | Note, this driver *cannot* over-ride the WP link on the | 603 | Note, this driver *cannot* over-ride the WP link on the |
659 | board, or currently detect the state of the link. | 604 | board, or currently detect the state of the link. |
@@ -669,5 +614,15 @@ config MTD_SHARP_SL | |||
669 | help | 614 | help |
670 | This enables access to the flash chip on the Sharp SL Series of PDAs. | 615 | This enables access to the flash chip on the Sharp SL Series of PDAs. |
671 | 616 | ||
617 | config MTD_PLATRAM | ||
618 | tristate "Map driver for platform device RAM (mtd-ram)" | ||
619 | depends on MTD | ||
620 | select MTD_RAM | ||
621 | help | ||
622 | Map driver for RAM areas described via the platform device | ||
623 | system. | ||
624 | |||
625 | This selection automatically selects the map_ram driver. | ||
626 | |||
672 | endmenu | 627 | endmenu |
673 | 628 | ||
diff --git a/drivers/mtd/maps/Makefile b/drivers/mtd/maps/Makefile index 7ffe02b85301..7bcbc49e329f 100644 --- a/drivers/mtd/maps/Makefile +++ b/drivers/mtd/maps/Makefile | |||
@@ -1,7 +1,7 @@ | |||
1 | # | 1 | # |
2 | # linux/drivers/maps/Makefile | 2 | # linux/drivers/maps/Makefile |
3 | # | 3 | # |
4 | # $Id: Makefile.common,v 1.23 2005/01/05 17:06:36 dwmw2 Exp $ | 4 | # $Id: Makefile.common,v 1.30 2005/07/02 01:53:24 tpoynor Exp $ |
5 | 5 | ||
6 | ifeq ($(CONFIG_MTD_COMPLEX_MAPPINGS),y) | 6 | ifeq ($(CONFIG_MTD_COMPLEX_MAPPINGS),y) |
7 | obj-$(CONFIG_MTD) += map_funcs.o | 7 | obj-$(CONFIG_MTD) += map_funcs.o |
@@ -15,7 +15,6 @@ obj-$(CONFIG_MTD_CFI_FLAGADM) += cfi_flagadm.o | |||
15 | obj-$(CONFIG_MTD_CSTM_MIPS_IXX) += cstm_mips_ixx.o | 15 | obj-$(CONFIG_MTD_CSTM_MIPS_IXX) += cstm_mips_ixx.o |
16 | obj-$(CONFIG_MTD_DC21285) += dc21285.o | 16 | obj-$(CONFIG_MTD_DC21285) += dc21285.o |
17 | obj-$(CONFIG_MTD_DILNETPC) += dilnetpc.o | 17 | obj-$(CONFIG_MTD_DILNETPC) += dilnetpc.o |
18 | obj-$(CONFIG_MTD_ELAN_104NC) += elan-104nc.o | ||
19 | obj-$(CONFIG_MTD_EPXA10DB) += epxa10db-flash.o | 18 | obj-$(CONFIG_MTD_EPXA10DB) += epxa10db-flash.o |
20 | obj-$(CONFIG_MTD_IQ80310) += iq80310.o | 19 | obj-$(CONFIG_MTD_IQ80310) += iq80310.o |
21 | obj-$(CONFIG_MTD_L440GX) += l440gx.o | 20 | obj-$(CONFIG_MTD_L440GX) += l440gx.o |
@@ -23,6 +22,7 @@ obj-$(CONFIG_MTD_AMD76XROM) += amd76xrom.o | |||
23 | obj-$(CONFIG_MTD_ICHXROM) += ichxrom.o | 22 | obj-$(CONFIG_MTD_ICHXROM) += ichxrom.o |
24 | obj-$(CONFIG_MTD_TSUNAMI) += tsunami_flash.o | 23 | obj-$(CONFIG_MTD_TSUNAMI) += tsunami_flash.o |
25 | obj-$(CONFIG_MTD_LUBBOCK) += lubbock-flash.o | 24 | obj-$(CONFIG_MTD_LUBBOCK) += lubbock-flash.o |
25 | obj-$(CONFIG_MTD_MAINSTONE) += mainstone-flash.o | ||
26 | obj-$(CONFIG_MTD_MBX860) += mbx860.o | 26 | obj-$(CONFIG_MTD_MBX860) += mbx860.o |
27 | obj-$(CONFIG_MTD_CEIVA) += ceiva.o | 27 | obj-$(CONFIG_MTD_CEIVA) += ceiva.o |
28 | obj-$(CONFIG_MTD_OCTAGON) += octagon-5066.o | 28 | obj-$(CONFIG_MTD_OCTAGON) += octagon-5066.o |
@@ -44,10 +44,7 @@ obj-$(CONFIG_MTD_DBOX2) += dbox2-flash.o | |||
44 | obj-$(CONFIG_MTD_OCELOT) += ocelot.o | 44 | obj-$(CONFIG_MTD_OCELOT) += ocelot.o |
45 | obj-$(CONFIG_MTD_SOLUTIONENGINE)+= solutionengine.o | 45 | obj-$(CONFIG_MTD_SOLUTIONENGINE)+= solutionengine.o |
46 | obj-$(CONFIG_MTD_PCI) += pci.o | 46 | obj-$(CONFIG_MTD_PCI) += pci.o |
47 | obj-$(CONFIG_MTD_PB1XXX) += pb1xxx-flash.o | 47 | obj-$(CONFIG_MTD_ALCHEMY) += alchemy-flash.o |
48 | obj-$(CONFIG_MTD_DB1X00) += db1x00-flash.o | ||
49 | obj-$(CONFIG_MTD_PB1550) += pb1550-flash.o | ||
50 | obj-$(CONFIG_MTD_DB1550) += db1550-flash.o | ||
51 | obj-$(CONFIG_MTD_LASAT) += lasat.o | 48 | obj-$(CONFIG_MTD_LASAT) += lasat.o |
52 | obj-$(CONFIG_MTD_AUTCPU12) += autcpu12-nvram.o | 49 | obj-$(CONFIG_MTD_AUTCPU12) += autcpu12-nvram.o |
53 | obj-$(CONFIG_MTD_EDB7312) += edb7312.o | 50 | obj-$(CONFIG_MTD_EDB7312) += edb7312.o |
@@ -71,3 +68,5 @@ obj-$(CONFIG_MTD_IXP2000) += ixp2000.o | |||
71 | obj-$(CONFIG_MTD_WRSBC8260) += wr_sbc82xx_flash.o | 68 | obj-$(CONFIG_MTD_WRSBC8260) += wr_sbc82xx_flash.o |
72 | obj-$(CONFIG_MTD_DMV182) += dmv182.o | 69 | obj-$(CONFIG_MTD_DMV182) += dmv182.o |
73 | obj-$(CONFIG_MTD_SHARP_SL) += sharpsl-flash.o | 70 | obj-$(CONFIG_MTD_SHARP_SL) += sharpsl-flash.o |
71 | obj-$(CONFIG_MTD_PLATRAM) += plat-ram.o | ||
72 | obj-$(CONFIG_MTD_OMAP_NOR) += omap_nor.o | ||
diff --git a/drivers/mtd/maps/alchemy-flash.c b/drivers/mtd/maps/alchemy-flash.c new file mode 100644 index 000000000000..27fd2a3c3b60 --- /dev/null +++ b/drivers/mtd/maps/alchemy-flash.c | |||
@@ -0,0 +1,192 @@ | |||
1 | /* | ||
2 | * Flash memory access on AMD Alchemy evaluation boards | ||
3 | * | ||
4 | * $Id: alchemy-flash.c,v 1.1 2005/02/27 21:50:21 ppopov Exp $ | ||
5 | * | ||
6 | * (C) 2003, 2004 Pete Popov <ppopov@embeddedalley.com> | ||
7 | * | ||
8 | */ | ||
9 | |||
10 | #include <linux/config.h> | ||
11 | #include <linux/init.h> | ||
12 | #include <linux/module.h> | ||
13 | #include <linux/types.h> | ||
14 | #include <linux/kernel.h> | ||
15 | |||
16 | #include <linux/mtd/mtd.h> | ||
17 | #include <linux/mtd/map.h> | ||
18 | #include <linux/mtd/partitions.h> | ||
19 | |||
20 | #include <asm/io.h> | ||
21 | |||
22 | #ifdef DEBUG_RW | ||
23 | #define DBG(x...) printk(x) | ||
24 | #else | ||
25 | #define DBG(x...) | ||
26 | #endif | ||
27 | |||
28 | #ifdef CONFIG_MIPS_PB1000 | ||
29 | #define BOARD_MAP_NAME "Pb1000 Flash" | ||
30 | #define BOARD_FLASH_SIZE 0x00800000 /* 8MB */ | ||
31 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
32 | #endif | ||
33 | |||
34 | #ifdef CONFIG_MIPS_PB1500 | ||
35 | #define BOARD_MAP_NAME "Pb1500 Flash" | ||
36 | #define BOARD_FLASH_SIZE 0x04000000 /* 64MB */ | ||
37 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
38 | #endif | ||
39 | |||
40 | #ifdef CONFIG_MIPS_PB1100 | ||
41 | #define BOARD_MAP_NAME "Pb1100 Flash" | ||
42 | #define BOARD_FLASH_SIZE 0x04000000 /* 64MB */ | ||
43 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
44 | #endif | ||
45 | |||
46 | #ifdef CONFIG_MIPS_PB1550 | ||
47 | #define BOARD_MAP_NAME "Pb1550 Flash" | ||
48 | #define BOARD_FLASH_SIZE 0x08000000 /* 128MB */ | ||
49 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
50 | #endif | ||
51 | |||
52 | #ifdef CONFIG_MIPS_PB1200 | ||
53 | #define BOARD_MAP_NAME "Pb1200 Flash" | ||
54 | #define BOARD_FLASH_SIZE 0x08000000 /* 128MB */ | ||
55 | #define BOARD_FLASH_WIDTH 2 /* 16-bits */ | ||
56 | #endif | ||
57 | |||
58 | #ifdef CONFIG_MIPS_DB1000 | ||
59 | #define BOARD_MAP_NAME "Db1000 Flash" | ||
60 | #define BOARD_FLASH_SIZE 0x02000000 /* 32MB */ | ||
61 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
62 | #endif | ||
63 | |||
64 | #ifdef CONFIG_MIPS_DB1500 | ||
65 | #define BOARD_MAP_NAME "Db1500 Flash" | ||
66 | #define BOARD_FLASH_SIZE 0x02000000 /* 32MB */ | ||
67 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
68 | #endif | ||
69 | |||
70 | #ifdef CONFIG_MIPS_DB1100 | ||
71 | #define BOARD_MAP_NAME "Db1100 Flash" | ||
72 | #define BOARD_FLASH_SIZE 0x02000000 /* 32MB */ | ||
73 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
74 | #endif | ||
75 | |||
76 | #ifdef CONFIG_MIPS_DB1550 | ||
77 | #define BOARD_MAP_NAME "Db1550 Flash" | ||
78 | #define BOARD_FLASH_SIZE 0x08000000 /* 128MB */ | ||
79 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
80 | #endif | ||
81 | |||
82 | #ifdef CONFIG_MIPS_DB1200 | ||
83 | #define BOARD_MAP_NAME "Db1200 Flash" | ||
84 | #define BOARD_FLASH_SIZE 0x04000000 /* 64MB */ | ||
85 | #define BOARD_FLASH_WIDTH 2 /* 16-bits */ | ||
86 | #endif | ||
87 | |||
88 | #ifdef CONFIG_MIPS_HYDROGEN3 | ||
89 | #define BOARD_MAP_NAME "Hydrogen3 Flash" | ||
90 | #define BOARD_FLASH_SIZE 0x02000000 /* 32MB */ | ||
91 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
92 | #define USE_LOCAL_ACCESSORS /* why? */ | ||
93 | #endif | ||
94 | |||
95 | #ifdef CONFIG_MIPS_BOSPORUS | ||
96 | #define BOARD_MAP_NAME "Bosporus Flash" | ||
97 | #define BOARD_FLASH_SIZE 0x01000000 /* 16MB */ | ||
98 | #define BOARD_FLASH_WIDTH 2 /* 16-bits */ | ||
99 | #endif | ||
100 | |||
101 | #ifdef CONFIG_MIPS_MIRAGE | ||
102 | #define BOARD_MAP_NAME "Mirage Flash" | ||
103 | #define BOARD_FLASH_SIZE 0x04000000 /* 64MB */ | ||
104 | #define BOARD_FLASH_WIDTH 4 /* 32-bits */ | ||
105 | #define USE_LOCAL_ACCESSORS /* why? */ | ||
106 | #endif | ||
107 | |||
108 | static struct map_info alchemy_map = { | ||
109 | .name = BOARD_MAP_NAME, | ||
110 | }; | ||
111 | |||
112 | static struct mtd_partition alchemy_partitions[] = { | ||
113 | { | ||
114 | .name = "User FS", | ||
115 | .size = BOARD_FLASH_SIZE - 0x00400000, | ||
116 | .offset = 0x0000000 | ||
117 | },{ | ||
118 | .name = "YAMON", | ||
119 | .size = 0x0100000, | ||
120 | .offset = MTDPART_OFS_APPEND, | ||
121 | .mask_flags = MTD_WRITEABLE | ||
122 | },{ | ||
123 | .name = "raw kernel", | ||
124 | .size = (0x300000 - 0x40000), /* last 256KB is yamon env */ | ||
125 | .offset = MTDPART_OFS_APPEND, | ||
126 | } | ||
127 | }; | ||
128 | |||
129 | #define NB_OF(x) (sizeof(x)/sizeof(x[0])) | ||
130 | |||
131 | static struct mtd_info *mymtd; | ||
132 | |||
133 | int __init alchemy_mtd_init(void) | ||
134 | { | ||
135 | struct mtd_partition *parts; | ||
136 | int nb_parts = 0; | ||
137 | unsigned long window_addr; | ||
138 | unsigned long window_size; | ||
139 | |||
140 | /* Default flash buswidth */ | ||
141 | alchemy_map.bankwidth = BOARD_FLASH_WIDTH; | ||
142 | |||
143 | window_addr = 0x20000000 - BOARD_FLASH_SIZE; | ||
144 | window_size = BOARD_FLASH_SIZE; | ||
145 | #ifdef CONFIG_MIPS_MIRAGE_WHY | ||
146 | /* Boot ROM flash bank only; no user bank */ | ||
147 | window_addr = 0x1C000000; | ||
148 | window_size = 0x04000000; | ||
149 | /* USERFS from 0x1C00 0000 to 0x1FC00000 */ | ||
150 | alchemy_partitions[0].size = 0x03C00000; | ||
151 | #endif | ||
152 | |||
153 | /* | ||
154 | * Static partition definition selection | ||
155 | */ | ||
156 | parts = alchemy_partitions; | ||
157 | nb_parts = NB_OF(alchemy_partitions); | ||
158 | alchemy_map.size = window_size; | ||
159 | |||
160 | /* | ||
161 | * Now let's probe for the actual flash. Do it here since | ||
162 | * specific machine settings might have been set above. | ||
163 | */ | ||
164 | printk(KERN_NOTICE BOARD_MAP_NAME ": probing %d-bit flash bus\n", | ||
165 | alchemy_map.bankwidth*8); | ||
166 | alchemy_map.virt = ioremap(window_addr, window_size); | ||
167 | mymtd = do_map_probe("cfi_probe", &alchemy_map); | ||
168 | if (!mymtd) { | ||
169 | iounmap(alchemy_map.virt); | ||
170 | return -ENXIO; | ||
171 | } | ||
172 | mymtd->owner = THIS_MODULE; | ||
173 | |||
174 | add_mtd_partitions(mymtd, parts, nb_parts); | ||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | static void __exit alchemy_mtd_cleanup(void) | ||
179 | { | ||
180 | if (mymtd) { | ||
181 | del_mtd_partitions(mymtd); | ||
182 | map_destroy(mymtd); | ||
183 | iounmap(alchemy_map.virt); | ||
184 | } | ||
185 | } | ||
186 | |||
187 | module_init(alchemy_mtd_init); | ||
188 | module_exit(alchemy_mtd_cleanup); | ||
189 | |||
190 | MODULE_AUTHOR("Embedded Alley Solutions, Inc"); | ||
191 | MODULE_DESCRIPTION(BOARD_MAP_NAME " MTD driver"); | ||
192 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/mtd/maps/amd76xrom.c b/drivers/mtd/maps/amd76xrom.c index 51e97b05304e..e8a900a77685 100644 --- a/drivers/mtd/maps/amd76xrom.c +++ b/drivers/mtd/maps/amd76xrom.c | |||
@@ -2,7 +2,7 @@ | |||
2 | * amd76xrom.c | 2 | * amd76xrom.c |
3 | * | 3 | * |
4 | * Normal mappings of chips in physical memory | 4 | * Normal mappings of chips in physical memory |
5 | * $Id: amd76xrom.c,v 1.19 2004/11/28 09:40:39 dwmw2 Exp $ | 5 | * $Id: amd76xrom.c,v 1.20 2005/03/18 14:04:35 gleixner Exp $ |
6 | */ | 6 | */ |
7 | 7 | ||
8 | #include <linux/module.h> | 8 | #include <linux/module.h> |
@@ -314,7 +314,7 @@ static int __init init_amd76xrom(void) | |||
314 | } | 314 | } |
315 | return -ENXIO; | 315 | return -ENXIO; |
316 | #if 0 | 316 | #if 0 |
317 | return pci_module_init(&amd76xrom_driver); | 317 | return pci_register_driver(&amd76xrom_driver); |
318 | #endif | 318 | #endif |
319 | } | 319 | } |
320 | 320 | ||
diff --git a/drivers/mtd/maps/bast-flash.c b/drivers/mtd/maps/bast-flash.c index 44de3a81b277..0c45464e3f7b 100644 --- a/drivers/mtd/maps/bast-flash.c +++ b/drivers/mtd/maps/bast-flash.c | |||
@@ -1,14 +1,15 @@ | |||
1 | /* linux/drivers/mtd/maps/bast_flash.c | 1 | /* linux/drivers/mtd/maps/bast_flash.c |
2 | * | 2 | * |
3 | * Copyright (c) 2004 Simtec Electronics | 3 | * Copyright (c) 2004-2005 Simtec Electronics |
4 | * Ben Dooks <ben@simtec.co.uk> | 4 | * Ben Dooks <ben@simtec.co.uk> |
5 | * | 5 | * |
6 | * Simtec Bast (EB2410ITX) NOR MTD Mapping driver | 6 | * Simtec Bast (EB2410ITX) NOR MTD Mapping driver |
7 | * | 7 | * |
8 | * Changelog: | 8 | * Changelog: |
9 | * 20-Sep-2004 BJD Initial version | 9 | * 20-Sep-2004 BJD Initial version |
10 | * 17-Jan-2005 BJD Add whole device if no partitions found | ||
10 | * | 11 | * |
11 | * $Id: bast-flash.c,v 1.1 2004/09/21 14:29:04 bjd Exp $ | 12 | * $Id: bast-flash.c,v 1.2 2005/01/18 11:13:47 bjd Exp $ |
12 | * | 13 | * |
13 | * This program is free software; you can redistribute it and/or modify | 14 | * This program is free software; you can redistribute it and/or modify |
14 | * it under the terms of the GNU General Public License as published by | 15 | * it under the terms of the GNU General Public License as published by |
@@ -46,9 +47,9 @@ | |||
46 | #include <asm/arch/bast-cpld.h> | 47 | #include <asm/arch/bast-cpld.h> |
47 | 48 | ||
48 | #ifdef CONFIG_MTD_BAST_MAXSIZE | 49 | #ifdef CONFIG_MTD_BAST_MAXSIZE |
49 | #define AREA_MAXSIZE (CONFIG_MTD_BAST_MAXSIZE * (1024*1024)) | 50 | #define AREA_MAXSIZE (CONFIG_MTD_BAST_MAXSIZE * SZ_1M) |
50 | #else | 51 | #else |
51 | #define AREA_MAXSIZE (32*1024*1024) | 52 | #define AREA_MAXSIZE (32 * SZ_1M) |
52 | #endif | 53 | #endif |
53 | 54 | ||
54 | #define PFX "bast-flash: " | 55 | #define PFX "bast-flash: " |
@@ -189,6 +190,8 @@ static int bast_flash_probe(struct device *dev) | |||
189 | err = add_mtd_partitions(info->mtd, info->partitions, err); | 190 | err = add_mtd_partitions(info->mtd, info->partitions, err); |
190 | if (err) | 191 | if (err) |
191 | printk(KERN_ERR PFX "cannot add/parse partitions\n"); | 192 | printk(KERN_ERR PFX "cannot add/parse partitions\n"); |
193 | } else { | ||
194 | err = add_mtd_device(info->mtd); | ||
192 | } | 195 | } |
193 | 196 | ||
194 | if (err == 0) | 197 | if (err == 0) |
diff --git a/drivers/mtd/maps/db1550-flash.c b/drivers/mtd/maps/db1550-flash.c deleted file mode 100644 index d213888462a4..000000000000 --- a/drivers/mtd/maps/db1550-flash.c +++ /dev/null | |||
@@ -1,187 +0,0 @@ | |||
1 | /* | ||
2 | * Flash memory access on Alchemy Db1550 board | ||
3 | * | ||
4 | * $Id: db1550-flash.c,v 1.7 2004/11/04 13:24:14 gleixner Exp $ | ||
5 | * | ||
6 | * (C) 2004 Embedded Edge, LLC, based on db1550-flash.c: | ||
7 | * (C) 2003, 2004 Pete Popov <ppopov@embeddedalley.com> | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #include <linux/config.h> | ||
12 | #include <linux/init.h> | ||
13 | #include <linux/module.h> | ||
14 | #include <linux/types.h> | ||
15 | #include <linux/kernel.h> | ||
16 | |||
17 | #include <linux/mtd/mtd.h> | ||
18 | #include <linux/mtd/map.h> | ||
19 | #include <linux/mtd/partitions.h> | ||
20 | |||
21 | #include <asm/io.h> | ||
22 | |||
23 | #ifdef DEBUG_RW | ||
24 | #define DBG(x...) printk(x) | ||
25 | #else | ||
26 | #define DBG(x...) | ||
27 | #endif | ||
28 | |||
29 | static unsigned long window_addr; | ||
30 | static unsigned long window_size; | ||
31 | |||
32 | |||
33 | static struct map_info db1550_map = { | ||
34 | .name = "Db1550 flash", | ||
35 | }; | ||
36 | |||
37 | static unsigned char flash_bankwidth = 4; | ||
38 | |||
39 | /* | ||
40 | * Support only 64MB NOR Flash parts | ||
41 | */ | ||
42 | |||
43 | #if defined(CONFIG_MTD_DB1550_BOOT) && defined(CONFIG_MTD_DB1550_USER) | ||
44 | #define DB1550_BOTH_BANKS | ||
45 | #elif defined(CONFIG_MTD_DB1550_BOOT) && !defined(CONFIG_MTD_DB1550_USER) | ||
46 | #define DB1550_BOOT_ONLY | ||
47 | #elif !defined(CONFIG_MTD_DB1550_BOOT) && defined(CONFIG_MTD_DB1550_USER) | ||
48 | #define DB1550_USER_ONLY | ||
49 | #endif | ||
50 | |||
51 | #ifdef DB1550_BOTH_BANKS | ||
52 | /* both banks will be used. Combine the first bank and the first | ||
53 | * part of the second bank together into a single jffs/jffs2 | ||
54 | * partition. | ||
55 | */ | ||
56 | static struct mtd_partition db1550_partitions[] = { | ||
57 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
58 | * 1C00 0000 1FFF FFFF CE0 64MB Boot NOR Flash | ||
59 | * 1800 0000 1BFF FFFF CE0 64MB Param NOR Flash | ||
60 | */ | ||
61 | { | ||
62 | .name = "User FS", | ||
63 | .size = (0x1FC00000 - 0x18000000), | ||
64 | .offset = 0x0000000 | ||
65 | },{ | ||
66 | .name = "yamon", | ||
67 | .size = 0x0100000, | ||
68 | .offset = MTDPART_OFS_APPEND, | ||
69 | .mask_flags = MTD_WRITEABLE | ||
70 | },{ | ||
71 | .name = "raw kernel", | ||
72 | .size = (0x300000 - 0x40000), /* last 256KB is yamon env */ | ||
73 | .offset = MTDPART_OFS_APPEND, | ||
74 | } | ||
75 | }; | ||
76 | #elif defined(DB1550_BOOT_ONLY) | ||
77 | static struct mtd_partition db1550_partitions[] = { | ||
78 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
79 | * 1C00 0000 1FFF FFFF CE0 64MB Boot NOR Flash | ||
80 | */ | ||
81 | { | ||
82 | .name = "User FS", | ||
83 | .size = 0x03c00000, | ||
84 | .offset = 0x0000000 | ||
85 | },{ | ||
86 | .name = "yamon", | ||
87 | .size = 0x0100000, | ||
88 | .offset = MTDPART_OFS_APPEND, | ||
89 | .mask_flags = MTD_WRITEABLE | ||
90 | },{ | ||
91 | .name = "raw kernel", | ||
92 | .size = (0x300000-0x40000), /* last 256KB is yamon env */ | ||
93 | .offset = MTDPART_OFS_APPEND, | ||
94 | } | ||
95 | }; | ||
96 | #elif defined(DB1550_USER_ONLY) | ||
97 | static struct mtd_partition db1550_partitions[] = { | ||
98 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
99 | * 1800 0000 1BFF FFFF CE0 64MB Param NOR Flash | ||
100 | */ | ||
101 | { | ||
102 | .name = "User FS", | ||
103 | .size = (0x4000000 - 0x200000), /* reserve 2MB for raw kernel */ | ||
104 | .offset = 0x0000000 | ||
105 | },{ | ||
106 | .name = "raw kernel", | ||
107 | .size = MTDPART_SIZ_FULL, | ||
108 | .offset = MTDPART_OFS_APPEND, | ||
109 | } | ||
110 | }; | ||
111 | #else | ||
112 | #error MTD_DB1550 define combo error /* should never happen */ | ||
113 | #endif | ||
114 | |||
115 | #define NB_OF(x) (sizeof(x)/sizeof(x[0])) | ||
116 | |||
117 | static struct mtd_info *mymtd; | ||
118 | |||
119 | /* | ||
120 | * Probe the flash density and setup window address and size | ||
121 | * based on user CONFIG options. There are times when we don't | ||
122 | * want the MTD driver to be probing the boot or user flash, | ||
123 | * so having the option to enable only one bank is important. | ||
124 | */ | ||
125 | int setup_flash_params(void) | ||
126 | { | ||
127 | #if defined(DB1550_BOTH_BANKS) | ||
128 | window_addr = 0x18000000; | ||
129 | window_size = 0x8000000; | ||
130 | #elif defined(DB1550_BOOT_ONLY) | ||
131 | window_addr = 0x1C000000; | ||
132 | window_size = 0x4000000; | ||
133 | #else /* USER ONLY */ | ||
134 | window_addr = 0x18000000; | ||
135 | window_size = 0x4000000; | ||
136 | #endif | ||
137 | return 0; | ||
138 | } | ||
139 | |||
140 | int __init db1550_mtd_init(void) | ||
141 | { | ||
142 | struct mtd_partition *parts; | ||
143 | int nb_parts = 0; | ||
144 | |||
145 | /* Default flash bankwidth */ | ||
146 | db1550_map.bankwidth = flash_bankwidth; | ||
147 | |||
148 | if (setup_flash_params()) | ||
149 | return -ENXIO; | ||
150 | |||
151 | /* | ||
152 | * Static partition definition selection | ||
153 | */ | ||
154 | parts = db1550_partitions; | ||
155 | nb_parts = NB_OF(db1550_partitions); | ||
156 | db1550_map.size = window_size; | ||
157 | |||
158 | /* | ||
159 | * Now let's probe for the actual flash. Do it here since | ||
160 | * specific machine settings might have been set above. | ||
161 | */ | ||
162 | printk(KERN_NOTICE "Db1550 flash: probing %d-bit flash bus\n", | ||
163 | db1550_map.bankwidth*8); | ||
164 | db1550_map.virt = ioremap(window_addr, window_size); | ||
165 | mymtd = do_map_probe("cfi_probe", &db1550_map); | ||
166 | if (!mymtd) return -ENXIO; | ||
167 | mymtd->owner = THIS_MODULE; | ||
168 | |||
169 | add_mtd_partitions(mymtd, parts, nb_parts); | ||
170 | return 0; | ||
171 | } | ||
172 | |||
173 | static void __exit db1550_mtd_cleanup(void) | ||
174 | { | ||
175 | if (mymtd) { | ||
176 | del_mtd_partitions(mymtd); | ||
177 | map_destroy(mymtd); | ||
178 | iounmap((void *) db1550_map.virt); | ||
179 | } | ||
180 | } | ||
181 | |||
182 | module_init(db1550_mtd_init); | ||
183 | module_exit(db1550_mtd_cleanup); | ||
184 | |||
185 | MODULE_AUTHOR("Embedded Edge, LLC"); | ||
186 | MODULE_DESCRIPTION("Db1550 mtd map driver"); | ||
187 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/mtd/maps/db1x00-flash.c b/drivers/mtd/maps/db1x00-flash.c deleted file mode 100644 index faa68ec56902..000000000000 --- a/drivers/mtd/maps/db1x00-flash.c +++ /dev/null | |||
@@ -1,226 +0,0 @@ | |||
1 | /* | ||
2 | * Flash memory access on Alchemy Db1xxx boards | ||
3 | * | ||
4 | * $Id: db1x00-flash.c,v 1.6 2004/11/04 13:24:14 gleixner Exp $ | ||
5 | * | ||
6 | * (C) 2003 Pete Popov <ppopov@embeddedalley.com> | ||
7 | * | ||
8 | */ | ||
9 | |||
10 | #include <linux/config.h> | ||
11 | #include <linux/module.h> | ||
12 | #include <linux/types.h> | ||
13 | #include <linux/init.h> | ||
14 | #include <linux/kernel.h> | ||
15 | |||
16 | #include <linux/mtd/mtd.h> | ||
17 | #include <linux/mtd/map.h> | ||
18 | #include <linux/mtd/partitions.h> | ||
19 | |||
20 | #include <asm/io.h> | ||
21 | |||
22 | #ifdef DEBUG_RW | ||
23 | #define DBG(x...) printk(x) | ||
24 | #else | ||
25 | #define DBG(x...) | ||
26 | #endif | ||
27 | |||
28 | /* MTD CONFIG OPTIONS */ | ||
29 | #if defined(CONFIG_MTD_DB1X00_BOOT) && defined(CONFIG_MTD_DB1X00_USER) | ||
30 | #define DB1X00_BOTH_BANKS | ||
31 | #elif defined(CONFIG_MTD_DB1X00_BOOT) && !defined(CONFIG_MTD_DB1X00_USER) | ||
32 | #define DB1X00_BOOT_ONLY | ||
33 | #elif !defined(CONFIG_MTD_DB1X00_BOOT) && defined(CONFIG_MTD_DB1X00_USER) | ||
34 | #define DB1X00_USER_ONLY | ||
35 | #endif | ||
36 | |||
37 | static unsigned long window_addr; | ||
38 | static unsigned long window_size; | ||
39 | static unsigned long flash_size; | ||
40 | |||
41 | static unsigned short *bcsr = (unsigned short *)0xAE000000; | ||
42 | static unsigned char flash_bankwidth = 4; | ||
43 | |||
44 | /* | ||
45 | * The Db1x boards support different flash densities. We setup | ||
46 | * the mtd_partition structures below for default of 64Mbit | ||
47 | * flash densities, and override the partitions sizes, if | ||
48 | * necessary, after we check the board status register. | ||
49 | */ | ||
50 | |||
51 | #ifdef DB1X00_BOTH_BANKS | ||
52 | /* both banks will be used. Combine the first bank and the first | ||
53 | * part of the second bank together into a single jffs/jffs2 | ||
54 | * partition. | ||
55 | */ | ||
56 | static struct mtd_partition db1x00_partitions[] = { | ||
57 | { | ||
58 | .name = "User FS", | ||
59 | .size = 0x1c00000, | ||
60 | .offset = 0x0000000 | ||
61 | },{ | ||
62 | .name = "yamon", | ||
63 | .size = 0x0100000, | ||
64 | .offset = MTDPART_OFS_APPEND, | ||
65 | .mask_flags = MTD_WRITEABLE | ||
66 | },{ | ||
67 | .name = "raw kernel", | ||
68 | .size = (0x300000-0x40000), /* last 256KB is env */ | ||
69 | .offset = MTDPART_OFS_APPEND, | ||
70 | } | ||
71 | }; | ||
72 | #elif defined(DB1X00_BOOT_ONLY) | ||
73 | static struct mtd_partition db1x00_partitions[] = { | ||
74 | { | ||
75 | .name = "User FS", | ||
76 | .size = 0x00c00000, | ||
77 | .offset = 0x0000000 | ||
78 | },{ | ||
79 | .name = "yamon", | ||
80 | .size = 0x0100000, | ||
81 | .offset = MTDPART_OFS_APPEND, | ||
82 | .mask_flags = MTD_WRITEABLE | ||
83 | },{ | ||
84 | .name = "raw kernel", | ||
85 | .size = (0x300000-0x40000), /* last 256KB is env */ | ||
86 | .offset = MTDPART_OFS_APPEND, | ||
87 | } | ||
88 | }; | ||
89 | #elif defined(DB1X00_USER_ONLY) | ||
90 | static struct mtd_partition db1x00_partitions[] = { | ||
91 | { | ||
92 | .name = "User FS", | ||
93 | .size = 0x0e00000, | ||
94 | .offset = 0x0000000 | ||
95 | },{ | ||
96 | .name = "raw kernel", | ||
97 | .size = MTDPART_SIZ_FULL, | ||
98 | .offset = MTDPART_OFS_APPEND, | ||
99 | } | ||
100 | }; | ||
101 | #else | ||
102 | #error MTD_DB1X00 define combo error /* should never happen */ | ||
103 | #endif | ||
104 | #define NB_OF(x) (sizeof(x)/sizeof(x[0])) | ||
105 | |||
106 | #define NAME "Db1x00 Linux Flash" | ||
107 | |||
108 | static struct map_info db1xxx_mtd_map = { | ||
109 | .name = NAME, | ||
110 | }; | ||
111 | |||
112 | static struct mtd_partition *parsed_parts; | ||
113 | static struct mtd_info *db1xxx_mtd; | ||
114 | |||
115 | /* | ||
116 | * Probe the flash density and setup window address and size | ||
117 | * based on user CONFIG options. There are times when we don't | ||
118 | * want the MTD driver to be probing the boot or user flash, | ||
119 | * so having the option to enable only one bank is important. | ||
120 | */ | ||
121 | int setup_flash_params(void) | ||
122 | { | ||
123 | switch ((bcsr[2] >> 14) & 0x3) { | ||
124 | case 0: /* 64Mbit devices */ | ||
125 | flash_size = 0x800000; /* 8MB per part */ | ||
126 | #if defined(DB1X00_BOTH_BANKS) | ||
127 | window_addr = 0x1E000000; | ||
128 | window_size = 0x2000000; | ||
129 | #elif defined(DB1X00_BOOT_ONLY) | ||
130 | window_addr = 0x1F000000; | ||
131 | window_size = 0x1000000; | ||
132 | #else /* USER ONLY */ | ||
133 | window_addr = 0x1E000000; | ||
134 | window_size = 0x1000000; | ||
135 | #endif | ||
136 | break; | ||
137 | case 1: | ||
138 | /* 128 Mbit devices */ | ||
139 | flash_size = 0x1000000; /* 16MB per part */ | ||
140 | #if defined(DB1X00_BOTH_BANKS) | ||
141 | window_addr = 0x1C000000; | ||
142 | window_size = 0x4000000; | ||
143 | /* USERFS from 0x1C00 0000 to 0x1FC0 0000 */ | ||
144 | db1x00_partitions[0].size = 0x3C00000; | ||
145 | #elif defined(DB1X00_BOOT_ONLY) | ||
146 | window_addr = 0x1E000000; | ||
147 | window_size = 0x2000000; | ||
148 | /* USERFS from 0x1E00 0000 to 0x1FC0 0000 */ | ||
149 | db1x00_partitions[0].size = 0x1C00000; | ||
150 | #else /* USER ONLY */ | ||
151 | window_addr = 0x1C000000; | ||
152 | window_size = 0x2000000; | ||
153 | /* USERFS from 0x1C00 0000 to 0x1DE00000 */ | ||
154 | db1x00_partitions[0].size = 0x1DE0000; | ||
155 | #endif | ||
156 | break; | ||
157 | case 2: | ||
158 | /* 256 Mbit devices */ | ||
159 | flash_size = 0x4000000; /* 64MB per part */ | ||
160 | #if defined(DB1X00_BOTH_BANKS) | ||
161 | return 1; | ||
162 | #elif defined(DB1X00_BOOT_ONLY) | ||
163 | /* Boot ROM flash bank only; no user bank */ | ||
164 | window_addr = 0x1C000000; | ||
165 | window_size = 0x4000000; | ||
166 | /* USERFS from 0x1C00 0000 to 0x1FC00000 */ | ||
167 | db1x00_partitions[0].size = 0x3C00000; | ||
168 | #else /* USER ONLY */ | ||
169 | return 1; | ||
170 | #endif | ||
171 | break; | ||
172 | default: | ||
173 | return 1; | ||
174 | } | ||
175 | db1xxx_mtd_map.size = window_size; | ||
176 | db1xxx_mtd_map.bankwidth = flash_bankwidth; | ||
177 | db1xxx_mtd_map.phys = window_addr; | ||
178 | db1xxx_mtd_map.bankwidth = flash_bankwidth; | ||
179 | return 0; | ||
180 | } | ||
181 | |||
182 | int __init db1x00_mtd_init(void) | ||
183 | { | ||
184 | struct mtd_partition *parts; | ||
185 | int nb_parts = 0; | ||
186 | |||
187 | if (setup_flash_params()) | ||
188 | return -ENXIO; | ||
189 | |||
190 | /* | ||
191 | * Static partition definition selection | ||
192 | */ | ||
193 | parts = db1x00_partitions; | ||
194 | nb_parts = NB_OF(db1x00_partitions); | ||
195 | |||
196 | /* | ||
197 | * Now let's probe for the actual flash. Do it here since | ||
198 | * specific machine settings might have been set above. | ||
199 | */ | ||
200 | printk(KERN_NOTICE "Db1xxx flash: probing %d-bit flash bus\n", | ||
201 | db1xxx_mtd_map.bankwidth*8); | ||
202 | db1xxx_mtd_map.virt = ioremap(window_addr, window_size); | ||
203 | db1xxx_mtd = do_map_probe("cfi_probe", &db1xxx_mtd_map); | ||
204 | if (!db1xxx_mtd) return -ENXIO; | ||
205 | db1xxx_mtd->owner = THIS_MODULE; | ||
206 | |||
207 | add_mtd_partitions(db1xxx_mtd, parts, nb_parts); | ||
208 | return 0; | ||
209 | } | ||
210 | |||
211 | static void __exit db1x00_mtd_cleanup(void) | ||
212 | { | ||
213 | if (db1xxx_mtd) { | ||
214 | del_mtd_partitions(db1xxx_mtd); | ||
215 | map_destroy(db1xxx_mtd); | ||
216 | if (parsed_parts) | ||
217 | kfree(parsed_parts); | ||
218 | } | ||
219 | } | ||
220 | |||
221 | module_init(db1x00_mtd_init); | ||
222 | module_exit(db1x00_mtd_cleanup); | ||
223 | |||
224 | MODULE_AUTHOR("Pete Popov"); | ||
225 | MODULE_DESCRIPTION("Db1x00 mtd map driver"); | ||
226 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/mtd/maps/elan-104nc.c b/drivers/mtd/maps/elan-104nc.c deleted file mode 100644 index e9465f5c069e..000000000000 --- a/drivers/mtd/maps/elan-104nc.c +++ /dev/null | |||
@@ -1,228 +0,0 @@ | |||
1 | /* elan-104nc.c -- MTD map driver for Arcom Control Systems ELAN-104NC | ||
2 | |||
3 | Copyright (C) 2000 Arcom Control System Ltd | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published by | ||
7 | the Free Software Foundation; either version 2 of the License, or | ||
8 | (at your option) any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
13 | GNU General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with this program; if not, write to the Free Software | ||
17 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | ||
18 | |||
19 | $Id: elan-104nc.c,v 1.25 2004/11/28 09:40:39 dwmw2 Exp $ | ||
20 | |||
21 | The ELAN-104NC has up to 8 Mibyte of Intel StrataFlash (28F320/28F640) in x16 | ||
22 | mode. This drivers uses the CFI probe and Intel Extended Command Set drivers. | ||
23 | |||
24 | The flash is accessed as follows: | ||
25 | |||
26 | 32 kbyte memory window at 0xb0000-0xb7fff | ||
27 | |||
28 | 16 bit I/O port (0x22) for some sort of paging. | ||
29 | |||
30 | The single flash device is divided into 3 partition which appear as separate | ||
31 | MTD devices. | ||
32 | |||
33 | Linux thinks that the I/O port is used by the PIC and hence check_region() will | ||
34 | always fail. So we don't do it. I just hope it doesn't break anything. | ||
35 | */ | ||
36 | #include <linux/module.h> | ||
37 | #include <linux/slab.h> | ||
38 | #include <linux/ioport.h> | ||
39 | #include <linux/init.h> | ||
40 | #include <asm/io.h> | ||
41 | |||
42 | #include <linux/mtd/map.h> | ||
43 | #include <linux/mtd/mtd.h> | ||
44 | #include <linux/mtd/partitions.h> | ||
45 | |||
46 | #define WINDOW_START 0xb0000 | ||
47 | /* Number of bits in offset. */ | ||
48 | #define WINDOW_SHIFT 15 | ||
49 | #define WINDOW_LENGTH (1 << WINDOW_SHIFT) | ||
50 | /* The bits for the offset into the window. */ | ||
51 | #define WINDOW_MASK (WINDOW_LENGTH-1) | ||
52 | #define PAGE_IO 0x22 | ||
53 | #define PAGE_IO_SIZE 2 | ||
54 | |||
55 | static volatile int page_in_window = -1; // Current page in window. | ||
56 | static void __iomem *iomapadr; | ||
57 | static DEFINE_SPINLOCK(elan_104nc_spin); | ||
58 | |||
59 | /* partition_info gives details on the logical partitions that the split the | ||
60 | * single flash device into. If the size if zero we use up to the end of the | ||
61 | * device. */ | ||
62 | static struct mtd_partition partition_info[]={ | ||
63 | { .name = "ELAN-104NC flash boot partition", | ||
64 | .offset = 0, | ||
65 | .size = 640*1024 }, | ||
66 | { .name = "ELAN-104NC flash partition 1", | ||
67 | .offset = 640*1024, | ||
68 | .size = 896*1024 }, | ||
69 | { .name = "ELAN-104NC flash partition 2", | ||
70 | .offset = (640+896)*1024 } | ||
71 | }; | ||
72 | #define NUM_PARTITIONS (sizeof(partition_info)/sizeof(partition_info[0])) | ||
73 | |||
74 | /* | ||
75 | * If no idea what is going on here. This is taken from the FlashFX stuff. | ||
76 | */ | ||
77 | #define ROMCS 1 | ||
78 | |||
79 | static inline void elan_104nc_setup(void) | ||
80 | { | ||
81 | u16 t; | ||
82 | |||
83 | outw( 0x0023 + ROMCS*2, PAGE_IO ); | ||
84 | t=inb( PAGE_IO+1 ); | ||
85 | |||
86 | t=(t & 0xf9) | 0x04; | ||
87 | |||
88 | outw( ((0x0023 + ROMCS*2) | (t << 8)), PAGE_IO ); | ||
89 | } | ||
90 | |||
91 | static inline void elan_104nc_page(struct map_info *map, unsigned long ofs) | ||
92 | { | ||
93 | unsigned long page = ofs >> WINDOW_SHIFT; | ||
94 | |||
95 | if( page!=page_in_window ) { | ||
96 | int cmd1; | ||
97 | int cmd2; | ||
98 | |||
99 | cmd1=(page & 0x700) + 0x0833 + ROMCS*0x4000; | ||
100 | cmd2=((page & 0xff) << 8) + 0x0032; | ||
101 | |||
102 | outw( cmd1, PAGE_IO ); | ||
103 | outw( cmd2, PAGE_IO ); | ||
104 | |||
105 | page_in_window = page; | ||
106 | } | ||
107 | } | ||
108 | |||
109 | |||
110 | static map_word elan_104nc_read16(struct map_info *map, unsigned long ofs) | ||
111 | { | ||
112 | map_word ret; | ||
113 | spin_lock(&elan_104nc_spin); | ||
114 | elan_104nc_page(map, ofs); | ||
115 | ret.x[0] = readw(iomapadr + (ofs & WINDOW_MASK)); | ||
116 | spin_unlock(&elan_104nc_spin); | ||
117 | return ret; | ||
118 | } | ||
119 | |||
120 | static void elan_104nc_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) | ||
121 | { | ||
122 | while (len) { | ||
123 | unsigned long thislen = len; | ||
124 | if (len > (WINDOW_LENGTH - (from & WINDOW_MASK))) | ||
125 | thislen = WINDOW_LENGTH-(from & WINDOW_MASK); | ||
126 | |||
127 | spin_lock(&elan_104nc_spin); | ||
128 | elan_104nc_page(map, from); | ||
129 | memcpy_fromio(to, iomapadr + (from & WINDOW_MASK), thislen); | ||
130 | spin_unlock(&elan_104nc_spin); | ||
131 | to += thislen; | ||
132 | from += thislen; | ||
133 | len -= thislen; | ||
134 | } | ||
135 | } | ||
136 | |||
137 | static void elan_104nc_write16(struct map_info *map, map_word d, unsigned long adr) | ||
138 | { | ||
139 | spin_lock(&elan_104nc_spin); | ||
140 | elan_104nc_page(map, adr); | ||
141 | writew(d.x[0], iomapadr + (adr & WINDOW_MASK)); | ||
142 | spin_unlock(&elan_104nc_spin); | ||
143 | } | ||
144 | |||
145 | static void elan_104nc_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) | ||
146 | { | ||
147 | while(len) { | ||
148 | unsigned long thislen = len; | ||
149 | if (len > (WINDOW_LENGTH - (to & WINDOW_MASK))) | ||
150 | thislen = WINDOW_LENGTH-(to & WINDOW_MASK); | ||
151 | |||
152 | spin_lock(&elan_104nc_spin); | ||
153 | elan_104nc_page(map, to); | ||
154 | memcpy_toio(iomapadr + (to & WINDOW_MASK), from, thislen); | ||
155 | spin_unlock(&elan_104nc_spin); | ||
156 | to += thislen; | ||
157 | from += thislen; | ||
158 | len -= thislen; | ||
159 | } | ||
160 | } | ||
161 | |||
162 | static struct map_info elan_104nc_map = { | ||
163 | .name = "ELAN-104NC flash", | ||
164 | .phys = NO_XIP, | ||
165 | .size = 8*1024*1024, /* this must be set to a maximum possible amount | ||
166 | of flash so the cfi probe routines find all | ||
167 | the chips */ | ||
168 | .bankwidth = 2, | ||
169 | .read = elan_104nc_read16, | ||
170 | .copy_from = elan_104nc_copy_from, | ||
171 | .write = elan_104nc_write16, | ||
172 | .copy_to = elan_104nc_copy_to | ||
173 | }; | ||
174 | |||
175 | /* MTD device for all of the flash. */ | ||
176 | static struct mtd_info *all_mtd; | ||
177 | |||
178 | static void cleanup_elan_104nc(void) | ||
179 | { | ||
180 | if( all_mtd ) { | ||
181 | del_mtd_partitions( all_mtd ); | ||
182 | map_destroy( all_mtd ); | ||
183 | } | ||
184 | |||
185 | iounmap(iomapadr); | ||
186 | } | ||
187 | |||
188 | static int __init init_elan_104nc(void) | ||
189 | { | ||
190 | /* Urg! We use I/O port 0x22 without request_region()ing it, | ||
191 | because it's already allocated to the PIC. */ | ||
192 | |||
193 | iomapadr = ioremap(WINDOW_START, WINDOW_LENGTH); | ||
194 | if (!iomapadr) { | ||
195 | printk( KERN_ERR"%s: failed to ioremap memory region\n", | ||
196 | elan_104nc_map.name ); | ||
197 | return -EIO; | ||
198 | } | ||
199 | |||
200 | printk( KERN_INFO"%s: IO:0x%x-0x%x MEM:0x%x-0x%x\n", | ||
201 | elan_104nc_map.name, | ||
202 | PAGE_IO, PAGE_IO+PAGE_IO_SIZE-1, | ||
203 | WINDOW_START, WINDOW_START+WINDOW_LENGTH-1 ); | ||
204 | |||
205 | elan_104nc_setup(); | ||
206 | |||
207 | /* Probe for chip. */ | ||
208 | all_mtd = do_map_probe("cfi_probe", &elan_104nc_map ); | ||
209 | if( !all_mtd ) { | ||
210 | cleanup_elan_104nc(); | ||
211 | return -ENXIO; | ||
212 | } | ||
213 | |||
214 | all_mtd->owner = THIS_MODULE; | ||
215 | |||
216 | /* Create MTD devices for each partition. */ | ||
217 | add_mtd_partitions( all_mtd, partition_info, NUM_PARTITIONS ); | ||
218 | |||
219 | return 0; | ||
220 | } | ||
221 | |||
222 | module_init(init_elan_104nc); | ||
223 | module_exit(cleanup_elan_104nc); | ||
224 | |||
225 | |||
226 | MODULE_LICENSE("GPL"); | ||
227 | MODULE_AUTHOR("Arcom Control Systems Ltd."); | ||
228 | MODULE_DESCRIPTION("MTD map driver for Arcom Control Systems ELAN-104NC"); | ||
diff --git a/drivers/mtd/maps/ichxrom.c b/drivers/mtd/maps/ichxrom.c index 29d1cc1bb426..e505207cd489 100644 --- a/drivers/mtd/maps/ichxrom.c +++ b/drivers/mtd/maps/ichxrom.c | |||
@@ -2,7 +2,7 @@ | |||
2 | * ichxrom.c | 2 | * ichxrom.c |
3 | * | 3 | * |
4 | * Normal mappings of chips in physical memory | 4 | * Normal mappings of chips in physical memory |
5 | * $Id: ichxrom.c,v 1.16 2004/11/28 09:40:39 dwmw2 Exp $ | 5 | * $Id: ichxrom.c,v 1.18 2005/07/07 10:26:20 dwmw2 Exp $ |
6 | */ | 6 | */ |
7 | 7 | ||
8 | #include <linux/module.h> | 8 | #include <linux/module.h> |
@@ -338,9 +338,9 @@ static struct pci_device_id ichxrom_pci_tbl[] __devinitdata = { | |||
338 | { 0, }, | 338 | { 0, }, |
339 | }; | 339 | }; |
340 | 340 | ||
341 | #if 0 | ||
341 | MODULE_DEVICE_TABLE(pci, ichxrom_pci_tbl); | 342 | MODULE_DEVICE_TABLE(pci, ichxrom_pci_tbl); |
342 | 343 | ||
343 | #if 0 | ||
344 | static struct pci_driver ichxrom_driver = { | 344 | static struct pci_driver ichxrom_driver = { |
345 | .name = MOD_NAME, | 345 | .name = MOD_NAME, |
346 | .id_table = ichxrom_pci_tbl, | 346 | .id_table = ichxrom_pci_tbl, |
@@ -366,7 +366,7 @@ static int __init init_ichxrom(void) | |||
366 | } | 366 | } |
367 | return -ENXIO; | 367 | return -ENXIO; |
368 | #if 0 | 368 | #if 0 |
369 | return pci_module_init(&ichxrom_driver); | 369 | return pci_register_driver(&ichxrom_driver); |
370 | #endif | 370 | #endif |
371 | } | 371 | } |
372 | 372 | ||
diff --git a/drivers/mtd/maps/ixp2000.c b/drivers/mtd/maps/ixp2000.c index c5b5f447e34b..3e94b616743d 100644 --- a/drivers/mtd/maps/ixp2000.c +++ b/drivers/mtd/maps/ixp2000.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * $Id: ixp2000.c,v 1.5 2004/11/16 17:15:48 dsaxena Exp $ | 2 | * $Id: ixp2000.c,v 1.6 2005/03/18 14:07:46 gleixner Exp $ |
3 | * | 3 | * |
4 | * drivers/mtd/maps/ixp2000.c | 4 | * drivers/mtd/maps/ixp2000.c |
5 | * | 5 | * |
@@ -216,11 +216,6 @@ static int ixp2000_flash_probe(struct device *_dev) | |||
216 | goto Error; | 216 | goto Error; |
217 | } | 217 | } |
218 | 218 | ||
219 | /* | ||
220 | * Setup read mode for FLASH | ||
221 | */ | ||
222 | *IXP2000_SLOWPORT_FRM = 1; | ||
223 | |||
224 | #if defined(__ARMEB__) | 219 | #if defined(__ARMEB__) |
225 | /* | 220 | /* |
226 | * Enable erratum 44 workaround for NPUs with broken slowport | 221 | * Enable erratum 44 workaround for NPUs with broken slowport |
diff --git a/drivers/mtd/maps/mainstone-flash.c b/drivers/mtd/maps/mainstone-flash.c new file mode 100644 index 000000000000..87e93fa60588 --- /dev/null +++ b/drivers/mtd/maps/mainstone-flash.c | |||
@@ -0,0 +1,178 @@ | |||
1 | /* | ||
2 | * $Id: $ | ||
3 | * | ||
4 | * Map driver for the Mainstone developer platform. | ||
5 | * | ||
6 | * Author: Nicolas Pitre | ||
7 | * Copyright: (C) 2001 MontaVista Software Inc. | ||
8 | * | ||
9 | * This program is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License version 2 as | ||
11 | * published by the Free Software Foundation. | ||
12 | */ | ||
13 | |||
14 | #include <linux/module.h> | ||
15 | #include <linux/types.h> | ||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/dma-mapping.h> | ||
19 | #include <linux/mtd/mtd.h> | ||
20 | #include <linux/mtd/map.h> | ||
21 | #include <linux/mtd/partitions.h> | ||
22 | #include <asm/io.h> | ||
23 | #include <asm/hardware.h> | ||
24 | #include <asm/arch/pxa-regs.h> | ||
25 | #include <asm/arch/mainstone.h> | ||
26 | |||
27 | |||
28 | #define ROM_ADDR 0x00000000 | ||
29 | #define FLASH_ADDR 0x04000000 | ||
30 | |||
31 | #define WINDOW_SIZE 0x04000000 | ||
32 | |||
33 | static void mainstone_map_inval_cache(struct map_info *map, unsigned long from, | ||
34 | ssize_t len) | ||
35 | { | ||
36 | consistent_sync((char *)map->cached + from, len, DMA_FROM_DEVICE); | ||
37 | } | ||
38 | |||
39 | static struct map_info mainstone_maps[2] = { { | ||
40 | .size = WINDOW_SIZE, | ||
41 | .phys = PXA_CS0_PHYS, | ||
42 | .inval_cache = mainstone_map_inval_cache, | ||
43 | }, { | ||
44 | .size = WINDOW_SIZE, | ||
45 | .phys = PXA_CS1_PHYS, | ||
46 | .inval_cache = mainstone_map_inval_cache, | ||
47 | } }; | ||
48 | |||
49 | static struct mtd_partition mainstone_partitions[] = { | ||
50 | { | ||
51 | .name = "Bootloader", | ||
52 | .size = 0x00040000, | ||
53 | .offset = 0, | ||
54 | .mask_flags = MTD_WRITEABLE /* force read-only */ | ||
55 | },{ | ||
56 | .name = "Kernel", | ||
57 | .size = 0x00400000, | ||
58 | .offset = 0x00040000, | ||
59 | },{ | ||
60 | .name = "Filesystem", | ||
61 | .size = MTDPART_SIZ_FULL, | ||
62 | .offset = 0x00440000 | ||
63 | } | ||
64 | }; | ||
65 | |||
66 | static struct mtd_info *mymtds[2]; | ||
67 | static struct mtd_partition *parsed_parts[2]; | ||
68 | static int nr_parsed_parts[2]; | ||
69 | |||
70 | static const char *probes[] = { "RedBoot", "cmdlinepart", NULL }; | ||
71 | |||
72 | static int __init init_mainstone(void) | ||
73 | { | ||
74 | int SW7 = 0; /* FIXME: get from SCR (Mst doc section 3.2.1.1) */ | ||
75 | int ret = 0, i; | ||
76 | |||
77 | mainstone_maps[0].bankwidth = (BOOT_DEF & 1) ? 2 : 4; | ||
78 | mainstone_maps[1].bankwidth = 4; | ||
79 | |||
80 | /* Compensate for SW7 which swaps the flash banks */ | ||
81 | mainstone_maps[SW7].name = "processor flash"; | ||
82 | mainstone_maps[SW7 ^ 1].name = "main board flash"; | ||
83 | |||
84 | printk(KERN_NOTICE "Mainstone configured to boot from %s\n", | ||
85 | mainstone_maps[0].name); | ||
86 | |||
87 | for (i = 0; i < 2; i++) { | ||
88 | mainstone_maps[i].virt = ioremap(mainstone_maps[i].phys, | ||
89 | WINDOW_SIZE); | ||
90 | if (!mainstone_maps[i].virt) { | ||
91 | printk(KERN_WARNING "Failed to ioremap %s\n", | ||
92 | mainstone_maps[i].name); | ||
93 | if (!ret) | ||
94 | ret = -ENOMEM; | ||
95 | continue; | ||
96 | } | ||
97 | mainstone_maps[i].cached = | ||
98 | ioremap_cached(mainstone_maps[i].phys, WINDOW_SIZE); | ||
99 | if (!mainstone_maps[i].cached) | ||
100 | printk(KERN_WARNING "Failed to ioremap cached %s\n", | ||
101 | mainstone_maps[i].name); | ||
102 | simple_map_init(&mainstone_maps[i]); | ||
103 | |||
104 | printk(KERN_NOTICE | ||
105 | "Probing %s at physical address 0x%08lx" | ||
106 | " (%d-bit bankwidth)\n", | ||
107 | mainstone_maps[i].name, mainstone_maps[i].phys, | ||
108 | mainstone_maps[i].bankwidth * 8); | ||
109 | |||
110 | mymtds[i] = do_map_probe("cfi_probe", &mainstone_maps[i]); | ||
111 | |||
112 | if (!mymtds[i]) { | ||
113 | iounmap((void *)mainstone_maps[i].virt); | ||
114 | if (mainstone_maps[i].cached) | ||
115 | iounmap(mainstone_maps[i].cached); | ||
116 | if (!ret) | ||
117 | ret = -EIO; | ||
118 | continue; | ||
119 | } | ||
120 | mymtds[i]->owner = THIS_MODULE; | ||
121 | |||
122 | ret = parse_mtd_partitions(mymtds[i], probes, | ||
123 | &parsed_parts[i], 0); | ||
124 | |||
125 | if (ret > 0) | ||
126 | nr_parsed_parts[i] = ret; | ||
127 | } | ||
128 | |||
129 | if (!mymtds[0] && !mymtds[1]) | ||
130 | return ret; | ||
131 | |||
132 | for (i = 0; i < 2; i++) { | ||
133 | if (!mymtds[i]) { | ||
134 | printk(KERN_WARNING "%s is absent. Skipping\n", | ||
135 | mainstone_maps[i].name); | ||
136 | } else if (nr_parsed_parts[i]) { | ||
137 | add_mtd_partitions(mymtds[i], parsed_parts[i], | ||
138 | nr_parsed_parts[i]); | ||
139 | } else if (!i) { | ||
140 | printk("Using static partitions on %s\n", | ||
141 | mainstone_maps[i].name); | ||
142 | add_mtd_partitions(mymtds[i], mainstone_partitions, | ||
143 | ARRAY_SIZE(mainstone_partitions)); | ||
144 | } else { | ||
145 | printk("Registering %s as whole device\n", | ||
146 | mainstone_maps[i].name); | ||
147 | add_mtd_device(mymtds[i]); | ||
148 | } | ||
149 | } | ||
150 | return 0; | ||
151 | } | ||
152 | |||
153 | static void __exit cleanup_mainstone(void) | ||
154 | { | ||
155 | int i; | ||
156 | for (i = 0; i < 2; i++) { | ||
157 | if (!mymtds[i]) | ||
158 | continue; | ||
159 | |||
160 | if (nr_parsed_parts[i] || !i) | ||
161 | del_mtd_partitions(mymtds[i]); | ||
162 | else | ||
163 | del_mtd_device(mymtds[i]); | ||
164 | |||
165 | map_destroy(mymtds[i]); | ||
166 | iounmap((void *)mainstone_maps[i].virt); | ||
167 | if (mainstone_maps[i].cached) | ||
168 | iounmap(mainstone_maps[i].cached); | ||
169 | kfree(parsed_parts[i]); | ||
170 | } | ||
171 | } | ||
172 | |||
173 | module_init(init_mainstone); | ||
174 | module_exit(cleanup_mainstone); | ||
175 | |||
176 | MODULE_LICENSE("GPL"); | ||
177 | MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>"); | ||
178 | MODULE_DESCRIPTION("MTD map driver for Intel Mainstone"); | ||
diff --git a/drivers/mtd/maps/map_funcs.c b/drivers/mtd/maps/map_funcs.c index 38f6a7af53f8..9105e6ca0aa6 100644 --- a/drivers/mtd/maps/map_funcs.c +++ b/drivers/mtd/maps/map_funcs.c | |||
@@ -1,5 +1,5 @@ | |||
1 | /* | 1 | /* |
2 | * $Id: map_funcs.c,v 1.9 2004/07/13 22:33:15 dwmw2 Exp $ | 2 | * $Id: map_funcs.c,v 1.10 2005/06/06 23:04:36 tpoynor Exp $ |
3 | * | 3 | * |
4 | * Out-of-line map I/O functions for simple maps when CONFIG_COMPLEX_MAPPINGS | 4 | * Out-of-line map I/O functions for simple maps when CONFIG_COMPLEX_MAPPINGS |
5 | * is enabled. | 5 | * is enabled. |
@@ -9,23 +9,24 @@ | |||
9 | #include <linux/module.h> | 9 | #include <linux/module.h> |
10 | 10 | ||
11 | #include <linux/mtd/map.h> | 11 | #include <linux/mtd/map.h> |
12 | #include <linux/mtd/xip.h> | ||
12 | 13 | ||
13 | static map_word simple_map_read(struct map_info *map, unsigned long ofs) | 14 | static map_word __xipram simple_map_read(struct map_info *map, unsigned long ofs) |
14 | { | 15 | { |
15 | return inline_map_read(map, ofs); | 16 | return inline_map_read(map, ofs); |
16 | } | 17 | } |
17 | 18 | ||
18 | static void simple_map_write(struct map_info *map, const map_word datum, unsigned long ofs) | 19 | static void __xipram simple_map_write(struct map_info *map, const map_word datum, unsigned long ofs) |
19 | { | 20 | { |
20 | inline_map_write(map, datum, ofs); | 21 | inline_map_write(map, datum, ofs); |
21 | } | 22 | } |
22 | 23 | ||
23 | static void simple_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) | 24 | static void __xipram simple_map_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len) |
24 | { | 25 | { |
25 | inline_map_copy_from(map, to, from, len); | 26 | inline_map_copy_from(map, to, from, len); |
26 | } | 27 | } |
27 | 28 | ||
28 | static void simple_map_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) | 29 | static void __xipram simple_map_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len) |
29 | { | 30 | { |
30 | inline_map_copy_to(map, to, from, len); | 31 | inline_map_copy_to(map, to, from, len); |
31 | } | 32 | } |
diff --git a/drivers/mtd/maps/omap_nor.c b/drivers/mtd/maps/omap_nor.c new file mode 100644 index 000000000000..8cc71409a328 --- /dev/null +++ b/drivers/mtd/maps/omap_nor.c | |||
@@ -0,0 +1,179 @@ | |||
1 | /* | ||
2 | * Flash memory support for various TI OMAP boards | ||
3 | * | ||
4 | * Copyright (C) 2001-2002 MontaVista Software Inc. | ||
5 | * Copyright (C) 2003-2004 Texas Instruments | ||
6 | * Copyright (C) 2004 Nokia Corporation | ||
7 | * | ||
8 | * Assembled using driver code copyright the companies above | ||
9 | * and written by David Brownell, Jian Zhang <jzhang@ti.com>, | ||
10 | * Tony Lindgren <tony@atomide.com> and others. | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or modify it | ||
13 | * under the terms of the GNU General Public License as published by the | ||
14 | * Free Software Foundation; either version 2 of the License, or (at your | ||
15 | * option) any later version. | ||
16 | * | ||
17 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | ||
18 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
19 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN | ||
20 | * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, | ||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT | ||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF | ||
23 | * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON | ||
24 | * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | ||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
27 | * | ||
28 | * You should have received a copy of the GNU General Public License along | ||
29 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
30 | * 675 Mass Ave, Cambridge, MA 02139, USA. | ||
31 | */ | ||
32 | |||
33 | #include <linux/device.h> | ||
34 | #include <linux/module.h> | ||
35 | #include <linux/types.h> | ||
36 | #include <linux/kernel.h> | ||
37 | #include <linux/init.h> | ||
38 | #include <linux/ioport.h> | ||
39 | #include <linux/mtd/mtd.h> | ||
40 | #include <linux/mtd/map.h> | ||
41 | #include <linux/mtd/partitions.h> | ||
42 | |||
43 | #include <asm/io.h> | ||
44 | #include <asm/hardware.h> | ||
45 | #include <asm/mach-types.h> | ||
46 | #include <asm/mach/flash.h> | ||
47 | #include <asm/arch/tc.h> | ||
48 | |||
49 | #ifdef CONFIG_MTD_PARTITIONS | ||
50 | static const char *part_probes[] = { /* "RedBoot", */ "cmdlinepart", NULL }; | ||
51 | #endif | ||
52 | |||
53 | struct omapflash_info { | ||
54 | struct mtd_partition *parts; | ||
55 | struct mtd_info *mtd; | ||
56 | struct map_info map; | ||
57 | }; | ||
58 | |||
59 | static void omap_set_vpp(struct map_info *map, int enable) | ||
60 | { | ||
61 | static int count; | ||
62 | |||
63 | if (enable) { | ||
64 | if (count++ == 0) | ||
65 | OMAP_EMIFS_CONFIG_REG |= OMAP_EMIFS_CONFIG_WP; | ||
66 | } else { | ||
67 | if (count && (--count == 0)) | ||
68 | OMAP_EMIFS_CONFIG_REG &= ~OMAP_EMIFS_CONFIG_WP; | ||
69 | } | ||
70 | } | ||
71 | |||
72 | static int __devinit omapflash_probe(struct device *dev) | ||
73 | { | ||
74 | int err; | ||
75 | struct omapflash_info *info; | ||
76 | struct platform_device *pdev = to_platform_device(dev); | ||
77 | struct flash_platform_data *pdata = pdev->dev.platform_data; | ||
78 | struct resource *res = pdev->resource; | ||
79 | unsigned long size = res->end - res->start + 1; | ||
80 | |||
81 | info = kmalloc(sizeof(struct omapflash_info), GFP_KERNEL); | ||
82 | if (!info) | ||
83 | return -ENOMEM; | ||
84 | |||
85 | memset(info, 0, sizeof(struct omapflash_info)); | ||
86 | |||
87 | if (!request_mem_region(res->start, size, "flash")) { | ||
88 | err = -EBUSY; | ||
89 | goto out_free_info; | ||
90 | } | ||
91 | |||
92 | info->map.virt = ioremap(res->start, size); | ||
93 | if (!info->map.virt) { | ||
94 | err = -ENOMEM; | ||
95 | goto out_release_mem_region; | ||
96 | } | ||
97 | info->map.name = pdev->dev.bus_id; | ||
98 | info->map.phys = res->start; | ||
99 | info->map.size = size; | ||
100 | info->map.bankwidth = pdata->width; | ||
101 | info->map.set_vpp = omap_set_vpp; | ||
102 | |||
103 | simple_map_init(&info->map); | ||
104 | info->mtd = do_map_probe(pdata->map_name, &info->map); | ||
105 | if (!info->mtd) { | ||
106 | err = -EIO; | ||
107 | goto out_iounmap; | ||
108 | } | ||
109 | info->mtd->owner = THIS_MODULE; | ||
110 | |||
111 | #ifdef CONFIG_MTD_PARTITIONS | ||
112 | err = parse_mtd_partitions(info->mtd, part_probes, &info->parts, 0); | ||
113 | if (err > 0) | ||
114 | add_mtd_partitions(info->mtd, info->parts, err); | ||
115 | else if (err < 0 && pdata->parts) | ||
116 | add_mtd_partitions(info->mtd, pdata->parts, pdata->nr_parts); | ||
117 | else | ||
118 | #endif | ||
119 | add_mtd_device(info->mtd); | ||
120 | |||
121 | dev_set_drvdata(&pdev->dev, info); | ||
122 | |||
123 | return 0; | ||
124 | |||
125 | out_iounmap: | ||
126 | iounmap(info->map.virt); | ||
127 | out_release_mem_region: | ||
128 | release_mem_region(res->start, size); | ||
129 | out_free_info: | ||
130 | kfree(info); | ||
131 | |||
132 | return err; | ||
133 | } | ||
134 | |||
135 | static int __devexit omapflash_remove(struct device *dev) | ||
136 | { | ||
137 | struct platform_device *pdev = to_platform_device(dev); | ||
138 | struct omapflash_info *info = dev_get_drvdata(&pdev->dev); | ||
139 | |||
140 | dev_set_drvdata(&pdev->dev, NULL); | ||
141 | |||
142 | if (info) { | ||
143 | if (info->parts) { | ||
144 | del_mtd_partitions(info->mtd); | ||
145 | kfree(info->parts); | ||
146 | } else | ||
147 | del_mtd_device(info->mtd); | ||
148 | map_destroy(info->mtd); | ||
149 | release_mem_region(info->map.phys, info->map.size); | ||
150 | iounmap((void __iomem *) info->map.virt); | ||
151 | kfree(info); | ||
152 | } | ||
153 | |||
154 | return 0; | ||
155 | } | ||
156 | |||
157 | static struct device_driver omapflash_driver = { | ||
158 | .name = "omapflash", | ||
159 | .bus = &platform_bus_type, | ||
160 | .probe = omapflash_probe, | ||
161 | .remove = __devexit_p(omapflash_remove), | ||
162 | }; | ||
163 | |||
164 | static int __init omapflash_init(void) | ||
165 | { | ||
166 | return driver_register(&omapflash_driver); | ||
167 | } | ||
168 | |||
169 | static void __exit omapflash_exit(void) | ||
170 | { | ||
171 | driver_unregister(&omapflash_driver); | ||
172 | } | ||
173 | |||
174 | module_init(omapflash_init); | ||
175 | module_exit(omapflash_exit); | ||
176 | |||
177 | MODULE_LICENSE("GPL"); | ||
178 | MODULE_DESCRIPTION("MTD NOR map driver for TI OMAP boards"); | ||
179 | |||
diff --git a/drivers/mtd/maps/pb1550-flash.c b/drivers/mtd/maps/pb1550-flash.c deleted file mode 100644 index 1424726a219e..000000000000 --- a/drivers/mtd/maps/pb1550-flash.c +++ /dev/null | |||
@@ -1,203 +0,0 @@ | |||
1 | /* | ||
2 | * Flash memory access on Alchemy Pb1550 board | ||
3 | * | ||
4 | * $Id: pb1550-flash.c,v 1.6 2004/11/04 13:24:15 gleixner Exp $ | ||
5 | * | ||
6 | * (C) 2004 Embedded Edge, LLC, based on pb1550-flash.c: | ||
7 | * (C) 2003 Pete Popov <ppopov@pacbell.net> | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #include <linux/config.h> | ||
12 | #include <linux/init.h> | ||
13 | #include <linux/module.h> | ||
14 | #include <linux/types.h> | ||
15 | #include <linux/kernel.h> | ||
16 | |||
17 | #include <linux/mtd/mtd.h> | ||
18 | #include <linux/mtd/map.h> | ||
19 | #include <linux/mtd/partitions.h> | ||
20 | |||
21 | #include <asm/io.h> | ||
22 | #include <asm/au1000.h> | ||
23 | #include <asm/pb1550.h> | ||
24 | |||
25 | #ifdef DEBUG_RW | ||
26 | #define DBG(x...) printk(x) | ||
27 | #else | ||
28 | #define DBG(x...) | ||
29 | #endif | ||
30 | |||
31 | static unsigned long window_addr; | ||
32 | static unsigned long window_size; | ||
33 | |||
34 | |||
35 | static struct map_info pb1550_map = { | ||
36 | .name = "Pb1550 flash", | ||
37 | }; | ||
38 | |||
39 | static unsigned char flash_bankwidth = 4; | ||
40 | |||
41 | /* | ||
42 | * Support only 64MB NOR Flash parts | ||
43 | */ | ||
44 | |||
45 | #ifdef PB1550_BOTH_BANKS | ||
46 | /* both banks will be used. Combine the first bank and the first | ||
47 | * part of the second bank together into a single jffs/jffs2 | ||
48 | * partition. | ||
49 | */ | ||
50 | static struct mtd_partition pb1550_partitions[] = { | ||
51 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
52 | * 1C00 0000 1FFF FFFF CE0 64MB Boot NOR Flash | ||
53 | * 1800 0000 1BFF FFFF CE0 64MB Param NOR Flash | ||
54 | */ | ||
55 | { | ||
56 | .name = "User FS", | ||
57 | .size = (0x1FC00000 - 0x18000000), | ||
58 | .offset = 0x0000000 | ||
59 | },{ | ||
60 | .name = "yamon", | ||
61 | .size = 0x0100000, | ||
62 | .offset = MTDPART_OFS_APPEND, | ||
63 | .mask_flags = MTD_WRITEABLE | ||
64 | },{ | ||
65 | .name = "raw kernel", | ||
66 | .size = (0x300000 - 0x40000), /* last 256KB is yamon env */ | ||
67 | .offset = MTDPART_OFS_APPEND, | ||
68 | } | ||
69 | }; | ||
70 | #elif defined(PB1550_BOOT_ONLY) | ||
71 | static struct mtd_partition pb1550_partitions[] = { | ||
72 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
73 | * 1C00 0000 1FFF FFFF CE0 64MB Boot NOR Flash | ||
74 | */ | ||
75 | { | ||
76 | .name = "User FS", | ||
77 | .size = 0x03c00000, | ||
78 | .offset = 0x0000000 | ||
79 | },{ | ||
80 | .name = "yamon", | ||
81 | .size = 0x0100000, | ||
82 | .offset = MTDPART_OFS_APPEND, | ||
83 | .mask_flags = MTD_WRITEABLE | ||
84 | },{ | ||
85 | .name = "raw kernel", | ||
86 | .size = (0x300000-0x40000), /* last 256KB is yamon env */ | ||
87 | .offset = MTDPART_OFS_APPEND, | ||
88 | } | ||
89 | }; | ||
90 | #elif defined(PB1550_USER_ONLY) | ||
91 | static struct mtd_partition pb1550_partitions[] = { | ||
92 | /* assume boot[2:0]:swap is '0000' or '1000', which translates to: | ||
93 | * 1800 0000 1BFF FFFF CE0 64MB Param NOR Flash | ||
94 | */ | ||
95 | { | ||
96 | .name = "User FS", | ||
97 | .size = (0x4000000 - 0x200000), /* reserve 2MB for raw kernel */ | ||
98 | .offset = 0x0000000 | ||
99 | },{ | ||
100 | .name = "raw kernel", | ||
101 | .size = MTDPART_SIZ_FULL, | ||
102 | .offset = MTDPART_OFS_APPEND, | ||
103 | } | ||
104 | }; | ||
105 | #else | ||
106 | #error MTD_PB1550 define combo error /* should never happen */ | ||
107 | #endif | ||
108 | |||
109 | #define NB_OF(x) (sizeof(x)/sizeof(x[0])) | ||
110 | |||
111 | static struct mtd_info *mymtd; | ||
112 | |||
113 | /* | ||
114 | * Probe the flash density and setup window address and size | ||
115 | * based on user CONFIG options. There are times when we don't | ||
116 | * want the MTD driver to be probing the boot or user flash, | ||
117 | * so having the option to enable only one bank is important. | ||
118 | */ | ||
119 | int setup_flash_params(void) | ||
120 | { | ||
121 | u16 boot_swapboot; | ||
122 | boot_swapboot = (au_readl(MEM_STSTAT) & (0x7<<1)) | | ||
123 | ((bcsr->status >> 6) & 0x1); | ||
124 | printk("Pb1550 MTD: boot:swap %d\n", boot_swapboot); | ||
125 | |||
126 | switch (boot_swapboot) { | ||
127 | case 0: /* 512Mbit devices, both enabled */ | ||
128 | case 1: | ||
129 | case 8: | ||
130 | case 9: | ||
131 | #if defined(PB1550_BOTH_BANKS) | ||
132 | window_addr = 0x18000000; | ||
133 | window_size = 0x8000000; | ||
134 | #elif defined(PB1550_BOOT_ONLY) | ||
135 | window_addr = 0x1C000000; | ||
136 | window_size = 0x4000000; | ||
137 | #else /* USER ONLY */ | ||
138 | window_addr = 0x1E000000; | ||
139 | window_size = 0x4000000; | ||
140 | #endif | ||
141 | break; | ||
142 | case 0xC: | ||
143 | case 0xD: | ||
144 | case 0xE: | ||
145 | case 0xF: | ||
146 | /* 64 MB Boot NOR Flash is disabled */ | ||
147 | /* and the start address is moved to 0x0C00000 */ | ||
148 | window_addr = 0x0C000000; | ||
149 | window_size = 0x4000000; | ||
150 | default: | ||
151 | printk("Pb1550 MTD: unsupported boot:swap setting\n"); | ||
152 | return 1; | ||
153 | } | ||
154 | return 0; | ||
155 | } | ||
156 | |||
157 | int __init pb1550_mtd_init(void) | ||
158 | { | ||
159 | struct mtd_partition *parts; | ||
160 | int nb_parts = 0; | ||
161 | |||
162 | /* Default flash bankwidth */ | ||
163 | pb1550_map.bankwidth = flash_bankwidth; | ||
164 | |||
165 | if (setup_flash_params()) | ||
166 | return -ENXIO; | ||
167 | |||
168 | /* | ||
169 | * Static partition definition selection | ||
170 | */ | ||
171 | parts = pb1550_partitions; | ||
172 | nb_parts = NB_OF(pb1550_partitions); | ||
173 | pb1550_map.size = window_size; | ||
174 | |||
175 | /* | ||
176 | * Now let's probe for the actual flash. Do it here since | ||
177 | * specific machine settings might have been set above. | ||
178 | */ | ||
179 | printk(KERN_NOTICE "Pb1550 flash: probing %d-bit flash bus\n", | ||
180 | pb1550_map.bankwidth*8); | ||
181 | pb1550_map.virt = ioremap(window_addr, window_size); | ||
182 | mymtd = do_map_probe("cfi_probe", &pb1550_map); | ||
183 | if (!mymtd) return -ENXIO; | ||
184 | mymtd->owner = THIS_MODULE; | ||
185 | |||
186 | add_mtd_partitions(mymtd, parts, nb_parts); | ||
187 | return 0; | ||
188 | } | ||
189 | |||
190 | static void __exit pb1550_mtd_cleanup(void) | ||
191 | { | ||
192 | if (mymtd) { | ||
193 | del_mtd_partitions(mymtd); | ||
194 | map_destroy(mymtd); | ||
195 | } | ||
196 | } | ||
197 | |||
198 | module_init(pb1550_mtd_init); | ||
199 | module_exit(pb1550_mtd_cleanup); | ||
200 | |||
201 | MODULE_AUTHOR("Embedded Edge, LLC"); | ||
202 | MODULE_DESCRIPTION("Pb1550 mtd map driver"); | ||
203 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/mtd/maps/pb1xxx-flash.c b/drivers/mtd/maps/pb1xxx-flash.c deleted file mode 100644 index 06e731540552..000000000000 --- a/drivers/mtd/maps/pb1xxx-flash.c +++ /dev/null | |||
@@ -1,178 +0,0 @@ | |||
1 | /* | ||
2 | * Flash memory access on Alchemy Pb1xxx boards | ||
3 | * | ||
4 | * (C) 2001 Pete Popov <ppopov@mvista.com> | ||
5 | * | ||
6 | * $Id: pb1xxx-flash.c,v 1.14 2004/11/04 13:24:15 gleixner Exp $ | ||
7 | */ | ||
8 | |||
9 | #include <linux/config.h> | ||
10 | #include <linux/module.h> | ||
11 | #include <linux/types.h> | ||
12 | #include <linux/init.h> | ||
13 | #include <linux/kernel.h> | ||
14 | |||
15 | #include <linux/mtd/mtd.h> | ||
16 | #include <linux/mtd/map.h> | ||
17 | #include <linux/mtd/partitions.h> | ||
18 | |||
19 | #include <asm/io.h> | ||
20 | |||
21 | #ifdef DEBUG_RW | ||
22 | #define DBG(x...) printk(x) | ||
23 | #else | ||
24 | #define DBG(x...) | ||
25 | #endif | ||
26 | |||
27 | #ifdef CONFIG_MIPS_PB1000 | ||
28 | |||
29 | #define WINDOW_ADDR 0x1F800000 | ||
30 | #define WINDOW_SIZE 0x800000 | ||
31 | |||
32 | static struct mtd_partition pb1xxx_partitions[] = { | ||
33 | { | ||
34 | .name = "yamon env", | ||
35 | .size = 0x00020000, | ||
36 | .offset = 0, | ||
37 | .mask_flags = MTD_WRITEABLE}, | ||
38 | { | ||
39 | .name = "User FS", | ||
40 | .size = 0x003e0000, | ||
41 | .offset = 0x20000,}, | ||
42 | { | ||
43 | .name = "boot code", | ||
44 | .size = 0x100000, | ||
45 | .offset = 0x400000, | ||
46 | .mask_flags = MTD_WRITEABLE}, | ||
47 | { | ||
48 | .name = "raw/kernel", | ||
49 | .size = 0x300000, | ||
50 | .offset = 0x500000} | ||
51 | }; | ||
52 | |||
53 | #elif defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100) | ||
54 | |||
55 | #if defined(CONFIG_MTD_PB1500_BOOT) && defined(CONFIG_MTD_PB1500_USER) | ||
56 | /* both 32MB banks will be used. Combine the first 32MB bank and the | ||
57 | * first 28MB of the second bank together into a single jffs/jffs2 | ||
58 | * partition. | ||
59 | */ | ||
60 | #define WINDOW_ADDR 0x1C000000 | ||
61 | #define WINDOW_SIZE 0x4000000 | ||
62 | static struct mtd_partition pb1xxx_partitions[] = { | ||
63 | { | ||
64 | .name = "User FS", | ||
65 | .size = 0x3c00000, | ||
66 | .offset = 0x0000000 | ||
67 | },{ | ||
68 | .name = "yamon", | ||
69 | .size = 0x0100000, | ||
70 | .offset = 0x3c00000, | ||
71 | .mask_flags = MTD_WRITEABLE | ||
72 | },{ | ||
73 | .name = "raw kernel", | ||
74 | .size = 0x02c0000, | ||
75 | .offset = 0x3d00000 | ||
76 | } | ||
77 | }; | ||
78 | #elif defined(CONFIG_MTD_PB1500_BOOT) && !defined(CONFIG_MTD_PB1500_USER) | ||
79 | #define WINDOW_ADDR 0x1E000000 | ||
80 | #define WINDOW_SIZE 0x2000000 | ||
81 | static struct mtd_partition pb1xxx_partitions[] = { | ||
82 | { | ||
83 | .name = "User FS", | ||
84 | .size = 0x1c00000, | ||
85 | .offset = 0x0000000 | ||
86 | },{ | ||
87 | .name = "yamon", | ||
88 | .size = 0x0100000, | ||
89 | .offset = 0x1c00000, | ||
90 | .mask_flags = MTD_WRITEABLE | ||
91 | },{ | ||
92 | .name = "raw kernel", | ||
93 | .size = 0x02c0000, | ||
94 | .offset = 0x1d00000 | ||
95 | } | ||
96 | }; | ||
97 | #elif !defined(CONFIG_MTD_PB1500_BOOT) && defined(CONFIG_MTD_PB1500_USER) | ||
98 | #define WINDOW_ADDR 0x1C000000 | ||
99 | #define WINDOW_SIZE 0x2000000 | ||
100 | static struct mtd_partition pb1xxx_partitions[] = { | ||
101 | { | ||
102 | .name = "User FS", | ||
103 | .size = 0x1e00000, | ||
104 | .offset = 0x0000000 | ||
105 | },{ | ||
106 | .name = "raw kernel", | ||
107 | .size = 0x0200000, | ||
108 | .offset = 0x1e00000, | ||
109 | } | ||
110 | }; | ||
111 | #else | ||
112 | #error MTD_PB1500 define combo error /* should never happen */ | ||
113 | #endif | ||
114 | #else | ||
115 | #error Unsupported board | ||
116 | #endif | ||
117 | |||
118 | #define NAME "Pb1x00 Linux Flash" | ||
119 | #define PADDR WINDOW_ADDR | ||
120 | #define BUSWIDTH 4 | ||
121 | #define SIZE WINDOW_SIZE | ||
122 | #define PARTITIONS 4 | ||
123 | |||
124 | static struct map_info pb1xxx_mtd_map = { | ||
125 | .name = NAME, | ||
126 | .size = SIZE, | ||
127 | .bankwidth = BUSWIDTH, | ||
128 | .phys = PADDR, | ||
129 | }; | ||
130 | |||
131 | static struct mtd_info *pb1xxx_mtd; | ||
132 | |||
133 | int __init pb1xxx_mtd_init(void) | ||
134 | { | ||
135 | struct mtd_partition *parts; | ||
136 | int nb_parts = 0; | ||
137 | char *part_type; | ||
138 | |||
139 | /* | ||
140 | * Static partition definition selection | ||
141 | */ | ||
142 | part_type = "static"; | ||
143 | parts = pb1xxx_partitions; | ||
144 | nb_parts = ARRAY_SIZE(pb1xxx_partitions); | ||
145 | |||
146 | /* | ||
147 | * Now let's probe for the actual flash. Do it here since | ||
148 | * specific machine settings might have been set above. | ||
149 | */ | ||
150 | printk(KERN_NOTICE "Pb1xxx flash: probing %d-bit flash bus\n", | ||
151 | BUSWIDTH*8); | ||
152 | pb1xxx_mtd_map.virt = ioremap(WINDOW_ADDR, WINDOW_SIZE); | ||
153 | |||
154 | simple_map_init(&pb1xxx_mtd_map); | ||
155 | |||
156 | pb1xxx_mtd = do_map_probe("cfi_probe", &pb1xxx_mtd_map); | ||
157 | if (!pb1xxx_mtd) return -ENXIO; | ||
158 | pb1xxx_mtd->owner = THIS_MODULE; | ||
159 | |||
160 | add_mtd_partitions(pb1xxx_mtd, parts, nb_parts); | ||
161 | return 0; | ||
162 | } | ||
163 | |||
164 | static void __exit pb1xxx_mtd_cleanup(void) | ||
165 | { | ||
166 | if (pb1xxx_mtd) { | ||
167 | del_mtd_partitions(pb1xxx_mtd); | ||
168 | map_destroy(pb1xxx_mtd); | ||
169 | iounmap((void *) pb1xxx_mtd_map.virt); | ||
170 | } | ||
171 | } | ||
172 | |||
173 | module_init(pb1xxx_mtd_init); | ||
174 | module_exit(pb1xxx_mtd_cleanup); | ||
175 | |||
176 | MODULE_AUTHOR("Pete Popov"); | ||
177 | MODULE_DESCRIPTION("Pb1xxx CFI map driver"); | ||
178 | MODULE_LICENSE("GPL"); | ||
diff --git a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c index 08b60bdc5381..18dbd3af1eaa 100644 --- a/drivers/mtd/maps/pci.c +++ b/drivers/mtd/maps/pci.c | |||
@@ -7,7 +7,7 @@ | |||
7 | * it under the terms of the GNU General Public License version 2 as | 7 | * it under the terms of the GNU General Public License version 2 as |
8 | * published by the Free Software Foundation. | 8 | * published by the Free Software Foundation. |
9 | * | 9 | * |
10 | * $Id: pci.c,v 1.9 2004/11/28 09:40:40 dwmw2 Exp $ | 10 | * $Id: pci.c,v 1.10 2005/03/18 14:04:35 gleixner Exp $ |
11 | * | 11 | * |
12 | * Generic PCI memory map driver. We support the following boards: | 12 | * Generic PCI memory map driver. We support the following boards: |
13 | * - Intel IQ80310 ATU. | 13 | * - Intel IQ80310 ATU. |
@@ -370,7 +370,7 @@ static struct pci_driver mtd_pci_driver = { | |||
370 | 370 | ||
371 | static int __init mtd_pci_maps_init(void) | 371 | static int __init mtd_pci_maps_init(void) |
372 | { | 372 | { |
373 | return pci_module_init(&mtd_pci_driver); | 373 | return pci_register_driver(&mtd_pci_driver); |
374 | } | 374 | } |
375 | 375 | ||
376 | static void __exit mtd_pci_maps_exit(void) | 376 | static void __exit mtd_pci_maps_exit(void) |
diff --git a/drivers/mtd/maps/plat-ram.c b/drivers/mtd/maps/plat-ram.c new file mode 100644 index 000000000000..118b04544cad --- /dev/null +++ b/drivers/mtd/maps/plat-ram.c | |||
@@ -0,0 +1,278 @@ | |||
1 | /* drivers/mtd/maps/plat-ram.c | ||
2 | * | ||
3 | * (c) 2004-2005 Simtec Electronics | ||
4 | * http://www.simtec.co.uk/products/SWLINUX/ | ||
5 | * Ben Dooks <ben@simtec.co.uk> | ||
6 | * | ||
7 | * Generic platfrom device based RAM map | ||
8 | * | ||
9 | * $Id: plat-ram.c,v 1.3 2005/03/19 22:41:27 gleixner Exp $ | ||
10 | * | ||
11 | * This program is free software; you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation; either version 2 of the License, or | ||
14 | * (at your option) any later version. | ||
15 | * | ||
16 | * This program is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with this program; if not, write to the Free Software | ||
23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
24 | */ | ||
25 | |||
26 | #include <linux/module.h> | ||
27 | #include <linux/types.h> | ||
28 | #include <linux/init.h> | ||
29 | #include <linux/kernel.h> | ||
30 | #include <linux/string.h> | ||
31 | #include <linux/ioport.h> | ||
32 | #include <linux/device.h> | ||
33 | |||
34 | #include <linux/mtd/mtd.h> | ||
35 | #include <linux/mtd/map.h> | ||
36 | #include <linux/mtd/partitions.h> | ||
37 | #include <linux/mtd/plat-ram.h> | ||
38 | |||
39 | #include <asm/io.h> | ||
40 | |||
41 | /* private structure for each mtd platform ram device created */ | ||
42 | |||
43 | struct platram_info { | ||
44 | struct device *dev; | ||
45 | struct mtd_info *mtd; | ||
46 | struct map_info map; | ||
47 | struct mtd_partition *partitions; | ||
48 | struct resource *area; | ||
49 | struct platdata_mtd_ram *pdata; | ||
50 | }; | ||
51 | |||
52 | /* to_platram_info() | ||
53 | * | ||
54 | * device private data to struct platram_info conversion | ||
55 | */ | ||
56 | |||
57 | static inline struct platram_info *to_platram_info(struct device *dev) | ||
58 | { | ||
59 | return (struct platram_info *)dev_get_drvdata(dev); | ||
60 | } | ||
61 | |||
62 | /* platram_setrw | ||
63 | * | ||
64 | * call the platform device's set rw/ro control | ||
65 | * | ||
66 | * to = 0 => read-only | ||
67 | * = 1 => read-write | ||
68 | */ | ||
69 | |||
70 | static inline void platram_setrw(struct platram_info *info, int to) | ||
71 | { | ||
72 | if (info->pdata == NULL) | ||
73 | return; | ||
74 | |||
75 | if (info->pdata->set_rw != NULL) | ||
76 | (info->pdata->set_rw)(info->dev, to); | ||
77 | } | ||
78 | |||
79 | /* platram_remove | ||
80 | * | ||
81 | * called to remove the device from the driver's control | ||
82 | */ | ||
83 | |||
84 | static int platram_remove(struct device *dev) | ||
85 | { | ||
86 | struct platram_info *info = to_platram_info(dev); | ||
87 | |||
88 | dev_set_drvdata(dev, NULL); | ||
89 | |||
90 | dev_dbg(dev, "removing device\n"); | ||
91 | |||
92 | if (info == NULL) | ||
93 | return 0; | ||
94 | |||
95 | if (info->mtd) { | ||
96 | #ifdef CONFIG_MTD_PARTITIONS | ||
97 | if (info->partitions) { | ||
98 | del_mtd_partitions(info->mtd); | ||
99 | kfree(info->partitions); | ||
100 | } | ||
101 | #endif | ||
102 | del_mtd_device(info->mtd); | ||
103 | map_destroy(info->mtd); | ||
104 | } | ||
105 | |||
106 | /* ensure ram is left read-only */ | ||
107 | |||
108 | platram_setrw(info, PLATRAM_RO); | ||
109 | |||
110 | /* release resources */ | ||
111 | |||
112 | if (info->area) { | ||
113 | release_resource(info->area); | ||
114 | kfree(info->area); | ||
115 | } | ||
116 | |||
117 | if (info->map.virt != NULL) | ||
118 | iounmap(info->map.virt); | ||
119 | |||
120 | kfree(info); | ||
121 | |||
122 | return 0; | ||
123 | } | ||
124 | |||
125 | /* platram_probe | ||
126 | * | ||
127 | * called from device drive system when a device matching our | ||
128 | * driver is found. | ||
129 | */ | ||
130 | |||
131 | static int platram_probe(struct device *dev) | ||
132 | { | ||
133 | struct platform_device *pd = to_platform_device(dev); | ||
134 | struct platdata_mtd_ram *pdata; | ||
135 | struct platram_info *info; | ||
136 | struct resource *res; | ||
137 | int err = 0; | ||
138 | |||
139 | dev_dbg(dev, "probe entered\n"); | ||
140 | |||
141 | if (dev->platform_data == NULL) { | ||
142 | dev_err(dev, "no platform data supplied\n"); | ||
143 | err = -ENOENT; | ||
144 | goto exit_error; | ||
145 | } | ||
146 | |||
147 | pdata = dev->platform_data; | ||
148 | |||
149 | info = kmalloc(sizeof(*info), GFP_KERNEL); | ||
150 | if (info == NULL) { | ||
151 | dev_err(dev, "no memory for flash info\n"); | ||
152 | err = -ENOMEM; | ||
153 | goto exit_error; | ||
154 | } | ||
155 | |||
156 | memset(info, 0, sizeof(*info)); | ||
157 | dev_set_drvdata(dev, info); | ||
158 | |||
159 | info->dev = dev; | ||
160 | info->pdata = pdata; | ||
161 | |||
162 | /* get the resource for the memory mapping */ | ||
163 | |||
164 | res = platform_get_resource(pd, IORESOURCE_MEM, 0); | ||
165 | |||
166 | if (res == NULL) { | ||
167 | dev_err(dev, "no memory resource specified\n"); | ||
168 | err = -ENOENT; | ||
169 | goto exit_free; | ||
170 | } | ||
171 | |||
172 | dev_dbg(dev, "got platform resource %p (0x%lx)\n", res, res->start); | ||
173 | |||
174 | /* setup map parameters */ | ||
175 | |||
176 | info->map.phys = res->start; | ||
177 | info->map.size = (res->end - res->start) + 1; | ||
178 | info->map.name = pdata->mapname != NULL ? pdata->mapname : pd->name; | ||
179 | info->map.bankwidth = pdata->bankwidth; | ||
180 | |||
181 | /* register our usage of the memory area */ | ||
182 | |||
183 | info->area = request_mem_region(res->start, info->map.size, pd->name); | ||
184 | if (info->area == NULL) { | ||
185 | dev_err(dev, "failed to request memory region\n"); | ||
186 | err = -EIO; | ||
187 | goto exit_free; | ||
188 | } | ||
189 | |||
190 | /* remap the memory area */ | ||
191 | |||
192 | info->map.virt = ioremap(res->start, info->map.size); | ||
193 | dev_dbg(dev, "virt %p, %lu bytes\n", info->map.virt, info->map.size); | ||
194 | |||
195 | if (info->map.virt == NULL) { | ||
196 | dev_err(dev, "failed to ioremap() region\n"); | ||
197 | err = -EIO; | ||
198 | goto exit_free; | ||
199 | } | ||
200 | |||
201 | simple_map_init(&info->map); | ||
202 | |||
203 | dev_dbg(dev, "initialised map, probing for mtd\n"); | ||
204 | |||
205 | /* probe for the right mtd map driver */ | ||
206 | |||
207 | info->mtd = do_map_probe("map_ram" , &info->map); | ||
208 | if (info->mtd == NULL) { | ||
209 | dev_err(dev, "failed to probe for map_ram\n"); | ||
210 | err = -ENOMEM; | ||
211 | goto exit_free; | ||
212 | } | ||
213 | |||
214 | info->mtd->owner = THIS_MODULE; | ||
215 | |||
216 | platram_setrw(info, PLATRAM_RW); | ||
217 | |||
218 | /* check to see if there are any available partitions, or wether | ||
219 | * to add this device whole */ | ||
220 | |||
221 | #ifdef CONFIG_MTD_PARTITIONS | ||
222 | if (pdata->nr_partitions > 0) { | ||
223 | const char **probes = { NULL }; | ||
224 | |||
225 | if (pdata->probes) | ||
226 | probes = (const char **)pdata->probes; | ||
227 | |||
228 | err = parse_mtd_partitions(info->mtd, probes, | ||
229 | &info->partitions, 0); | ||
230 | if (err > 0) { | ||
231 | err = add_mtd_partitions(info->mtd, info->partitions, | ||
232 | err); | ||
233 | } | ||
234 | } | ||
235 | #endif /* CONFIG_MTD_PARTITIONS */ | ||
236 | |||
237 | if (add_mtd_device(info->mtd)) { | ||
238 | dev_err(dev, "add_mtd_device() failed\n"); | ||
239 | err = -ENOMEM; | ||
240 | } | ||
241 | |||
242 | dev_info(dev, "registered mtd device\n"); | ||
243 | return err; | ||
244 | |||
245 | exit_free: | ||
246 | platram_remove(dev); | ||
247 | exit_error: | ||
248 | return err; | ||
249 | } | ||
250 | |||
251 | /* device driver info */ | ||
252 | |||
253 | static struct device_driver platram_driver = { | ||
254 | .name = "mtd-ram", | ||
255 | .bus = &platform_bus_type, | ||
256 | .probe = platram_probe, | ||
257 | .remove = platram_remove, | ||
258 | }; | ||
259 | |||
260 | /* module init/exit */ | ||
261 | |||
262 | static int __init platram_init(void) | ||
263 | { | ||
264 | printk("Generic platform RAM MTD, (c) 2004 Simtec Electronics\n"); | ||
265 | return driver_register(&platram_driver); | ||
266 | } | ||
267 | |||
268 | static void __exit platram_exit(void) | ||
269 | { | ||
270 | driver_unregister(&platram_driver); | ||
271 | } | ||
272 | |||
273 | module_init(platram_init); | ||
274 | module_exit(platram_exit); | ||
275 | |||
276 | MODULE_LICENSE("GPL"); | ||
277 | MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>"); | ||
278 | MODULE_DESCRIPTION("MTD platform RAM map driver"); | ||
diff --git a/drivers/mtd/maps/scb2_flash.c b/drivers/mtd/maps/scb2_flash.c index 5bb3b600e5d0..97a8dfd69258 100644 --- a/drivers/mtd/maps/scb2_flash.c +++ b/drivers/mtd/maps/scb2_flash.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | * MTD map driver for BIOS Flash on Intel SCB2 boards | 2 | * MTD map driver for BIOS Flash on Intel SCB2 boards |
3 | * $Id: scb2_flash.c,v 1.11 2004/11/28 09:40:40 dwmw2 Exp $ | 3 | * $Id: scb2_flash.c,v 1.12 2005/03/18 14:04:35 gleixner Exp $ |
4 | * Copyright (C) 2002 Sun Microsystems, Inc. | 4 | * Copyright (C) 2002 Sun Microsystems, Inc. |
5 | * Tim Hockin <thockin@sun.com> | 5 | * Tim Hockin <thockin@sun.com> |
6 | * | 6 | * |
@@ -238,7 +238,7 @@ static struct pci_driver scb2_flash_driver = { | |||
238 | static int __init | 238 | static int __init |
239 | scb2_flash_init(void) | 239 | scb2_flash_init(void) |
240 | { | 240 | { |
241 | return pci_module_init(&scb2_flash_driver); | 241 | return pci_register_driver(&scb2_flash_driver); |
242 | } | 242 | } |
243 | 243 | ||
244 | static void __exit | 244 | static void __exit |
diff --git a/drivers/mtd/maps/sharpsl-flash.c b/drivers/mtd/maps/sharpsl-flash.c index b3b39cb7c608..d15da6fd84c1 100644 --- a/drivers/mtd/maps/sharpsl-flash.c +++ b/drivers/mtd/maps/sharpsl-flash.c | |||
@@ -4,7 +4,7 @@ | |||
4 | * Copyright (C) 2001 Lineo Japan, Inc. | 4 | * Copyright (C) 2001 Lineo Japan, Inc. |
5 | * Copyright (C) 2002 SHARP | 5 | * Copyright (C) 2002 SHARP |
6 | * | 6 | * |
7 | * $Id: sharpsl-flash.c,v 1.2 2004/11/24 20:38:06 rpurdie Exp $ | 7 | * $Id: sharpsl-flash.c,v 1.5 2005/03/21 08:42:11 rpurdie Exp $ |
8 | * | 8 | * |
9 | * based on rpxlite.c,v 1.15 2001/10/02 15:05:14 dwmw2 Exp | 9 | * based on rpxlite.c,v 1.15 2001/10/02 15:05:14 dwmw2 Exp |
10 | * Handle mapping of the flash on the RPX Lite and CLLF boards | 10 | * Handle mapping of the flash on the RPX Lite and CLLF boards |
@@ -24,13 +24,14 @@ | |||
24 | #include <linux/module.h> | 24 | #include <linux/module.h> |
25 | #include <linux/types.h> | 25 | #include <linux/types.h> |
26 | #include <linux/kernel.h> | 26 | #include <linux/kernel.h> |
27 | #include <asm/io.h> | ||
28 | #include <linux/mtd/mtd.h> | 27 | #include <linux/mtd/mtd.h> |
29 | #include <linux/mtd/map.h> | 28 | #include <linux/mtd/map.h> |
30 | #include <linux/mtd/partitions.h> | 29 | #include <linux/mtd/partitions.h> |
30 | #include <asm/io.h> | ||
31 | #include <asm/mach-types.h> | ||
31 | 32 | ||
32 | #define WINDOW_ADDR 0x00000000 | 33 | #define WINDOW_ADDR 0x00000000 |
33 | #define WINDOW_SIZE 0x01000000 | 34 | #define WINDOW_SIZE 0x00800000 |
34 | #define BANK_WIDTH 2 | 35 | #define BANK_WIDTH 2 |
35 | 36 | ||
36 | static struct mtd_info *mymtd; | 37 | static struct mtd_info *mymtd; |
@@ -44,9 +45,7 @@ struct map_info sharpsl_map = { | |||
44 | 45 | ||
45 | static struct mtd_partition sharpsl_partitions[1] = { | 46 | static struct mtd_partition sharpsl_partitions[1] = { |
46 | { | 47 | { |
47 | name: "Filesystem", | 48 | name: "Boot PROM Filesystem", |
48 | size: 0x006d0000, | ||
49 | offset: 0x00120000 | ||
50 | } | 49 | } |
51 | }; | 50 | }; |
52 | 51 | ||
@@ -58,12 +57,16 @@ int __init init_sharpsl(void) | |||
58 | int nb_parts = 0; | 57 | int nb_parts = 0; |
59 | char *part_type = "static"; | 58 | char *part_type = "static"; |
60 | 59 | ||
61 | printk(KERN_NOTICE "Sharp SL series flash device: %x at %x\n", WINDOW_SIZE, WINDOW_ADDR); | 60 | printk(KERN_NOTICE "Sharp SL series flash device: %x at %x\n", |
61 | WINDOW_SIZE, WINDOW_ADDR); | ||
62 | sharpsl_map.virt = ioremap(WINDOW_ADDR, WINDOW_SIZE); | 62 | sharpsl_map.virt = ioremap(WINDOW_ADDR, WINDOW_SIZE); |
63 | if (!sharpsl_map.virt) { | 63 | if (!sharpsl_map.virt) { |
64 | printk("Failed to ioremap\n"); | 64 | printk("Failed to ioremap\n"); |
65 | return -EIO; | 65 | return -EIO; |
66 | } | 66 | } |
67 | |||
68 | simple_map_init(&sharpsl_map); | ||
69 | |||
67 | mymtd = do_map_probe("map_rom", &sharpsl_map); | 70 | mymtd = do_map_probe("map_rom", &sharpsl_map); |
68 | if (!mymtd) { | 71 | if (!mymtd) { |
69 | iounmap(sharpsl_map.virt); | 72 | iounmap(sharpsl_map.virt); |
@@ -72,6 +75,22 @@ int __init init_sharpsl(void) | |||
72 | 75 | ||
73 | mymtd->owner = THIS_MODULE; | 76 | mymtd->owner = THIS_MODULE; |
74 | 77 | ||
78 | if (machine_is_corgi() || machine_is_shepherd() || machine_is_husky() | ||
79 | || machine_is_poodle()) { | ||
80 | sharpsl_partitions[0].size=0x006d0000; | ||
81 | sharpsl_partitions[0].offset=0x00120000; | ||
82 | } else if (machine_is_tosa()) { | ||
83 | sharpsl_partitions[0].size=0x006a0000; | ||
84 | sharpsl_partitions[0].offset=0x00160000; | ||
85 | } else if (machine_is_spitz()) { | ||
86 | sharpsl_partitions[0].size=0x006b0000; | ||
87 | sharpsl_partitions[0].offset=0x00140000; | ||
88 | } else { | ||
89 | map_destroy(mymtd); | ||
90 | iounmap(sharpsl_map.virt); | ||
91 | return -ENODEV; | ||
92 | } | ||
93 | |||
75 | parts = sharpsl_partitions; | 94 | parts = sharpsl_partitions; |
76 | nb_parts = NB_OF(sharpsl_partitions); | 95 | nb_parts = NB_OF(sharpsl_partitions); |
77 | 96 | ||