| /* |
| * Ceiva flash memory driver. |
| * Copyright (C) 2002 Rob Scott <rscott@mtrob.fdns.net> |
| * |
| * Note: this driver supports jedec compatible devices. Modification |
| * for CFI compatible devices should be straight forward: change |
| * jedec_probe to cfi_probe. |
| * |
| * Based on: sa1100-flash.c, which has the following copyright: |
| * Flash memory access on SA11x0 based devices |
| * |
| * (C) 2000 Nicolas Pitre <nico@fluxnic.net> |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/types.h> |
| #include <linux/ioport.h> |
| #include <linux/kernel.h> |
| #include <linux/init.h> |
| #include <linux/slab.h> |
| |
| #include <linux/mtd/mtd.h> |
| #include <linux/mtd/map.h> |
| #include <linux/mtd/partitions.h> |
| #include <linux/mtd/concat.h> |
| |
| #include <mach/hardware.h> |
| #include <asm/mach-types.h> |
| #include <asm/io.h> |
| #include <asm/sizes.h> |
| |
| /* |
| * This isn't complete yet, so... |
| */ |
| #define CONFIG_MTD_CEIVA_STATICMAP |
| |
| #ifdef CONFIG_MTD_CEIVA_STATICMAP |
| /* |
| * See include/linux/mtd/partitions.h for definition of the mtd_partition |
| * structure. |
| * |
| * Please note: |
| * 1. The flash size given should be the largest flash size that can |
| * be accommodated. |
| * |
| * 2. The bus width must defined in clps_setup_flash. |
| * |
| * The MTD layer will detect flash chip aliasing and reduce the size of |
| * the map accordingly. |
| * |
| */ |
| |
| #ifdef CONFIG_ARCH_CEIVA |
| /* Flash / Partition sizing */ |
| /* For the 28F8003, we use the block mapping to calcuate the sizes */ |
| #define MAX_SIZE_KiB (16 + 8 + 8 + 96 + (7*128)) |
| #define BOOT_PARTITION_SIZE_KiB (16) |
| #define PARAMS_PARTITION_SIZE_KiB (8) |
| #define KERNEL_PARTITION_SIZE_KiB (4*128) |
| /* Use both remaining portion of first flash, and all of second flash */ |
| #define ROOT_PARTITION_SIZE_KiB (3*128) + (8*128) |
| |
| static struct mtd_partition ceiva_partitions[] = { |
| { |
| .name = "Ceiva BOOT partition", |
| .size = BOOT_PARTITION_SIZE_KiB*1024, |
| .offset = 0, |
| |
| },{ |
| .name = "Ceiva parameters partition", |
| .size = PARAMS_PARTITION_SIZE_KiB*1024, |
| .offset = (16 + 8) * 1024, |
| },{ |
| .name = "Ceiva kernel partition", |
| .size = (KERNEL_PARTITION_SIZE_KiB)*1024, |
| .offset = 0x20000, |
| |
| },{ |
| .name = "Ceiva root filesystem partition", |
| .offset = MTDPART_OFS_APPEND, |
| .size = (ROOT_PARTITION_SIZE_KiB)*1024, |
| } |
| }; |
| #endif |
| |
| static int __init clps_static_partitions(struct mtd_partition **parts) |
| { |
| int nb_parts = 0; |
| |
| #ifdef CONFIG_ARCH_CEIVA |
| if (machine_is_ceiva()) { |
| *parts = ceiva_partitions; |
| nb_parts = ARRAY_SIZE(ceiva_partitions); |
| } |
| #endif |
| return nb_parts; |
| } |
| #endif |
| |
| struct clps_info { |
| unsigned long base; |
| unsigned long size; |
| int width; |
| void *vbase; |
| struct map_info *map; |
| struct mtd_info *mtd; |
| struct resource *res; |
| }; |
| |
| #define NR_SUBMTD 4 |
| |
| static struct clps_info info[NR_SUBMTD]; |
| |
| static int __init clps_setup_mtd(struct clps_info *clps, int nr, struct mtd_info **rmtd) |
| { |
| struct mtd_info *subdev[nr]; |
| struct map_info *maps; |
| int i, found = 0, ret = 0; |
| |
| /* |
| * Allocate the map_info structs in one go. |
| */ |
| maps = kzalloc(sizeof(struct map_info) * nr, GFP_KERNEL); |
| if (!maps) |
| return -ENOMEM; |
| /* |
| * Claim and then map the memory regions. |
| */ |
| for (i = 0; i < nr; i++) { |
| if (clps[i].base == (unsigned long)-1) |
| break; |
| |
| clps[i].res = request_mem_region(clps[i].base, clps[i].size, "clps flash"); |
| if (!clps[i].res) { |
| ret = -EBUSY; |
| break; |
| } |
| |
| clps[i].map = maps + i; |
| |
| clps[i].map->name = "clps flash"; |
| clps[i].map->phys = clps[i].base; |
| |
| clps[i].vbase = ioremap(clps[i].base, clps[i].size); |
| if (!clps[i].vbase) { |
| ret = -ENOMEM; |
| break; |
| } |
| |
| clps[i].map->virt = (void __iomem *)clps[i].vbase; |
| clps[i].map->bankwidth = clps[i].width; |
| clps[i].map->size = clps[i].size; |
| |
| simple_map_init(&clps[i].map); |
| |
| clps[i].mtd = do_map_probe("jedec_probe", clps[i].map); |
| if (clps[i].mtd == NULL) { |
| ret = -ENXIO; |
| break; |
| } |
| clps[i].mtd->owner = THIS_MODULE; |
| subdev[i] = clps[i].mtd; |
| |
| printk(KERN_INFO "clps flash: JEDEC device at 0x%08lx, %dMiB, " |
| "%d-bit\n", clps[i].base, clps[i].mtd->size >> 20, |
| clps[i].width * 8); |
| found += 1; |
| } |
| |
| /* |
| * ENXIO is special. It means we didn't find a chip when |
| * we probed. We need to tear down the mapping, free the |
| * resource and mark it as such. |
| */ |
| if (ret == -ENXIO) { |
| iounmap(clps[i].vbase); |
| clps[i].vbase = NULL; |
| release_resource(clps[i].res); |
| clps[i].res = NULL; |
| } |
| |
| /* |
| * If we found one device, don't bother with concat support. |
| * If we found multiple devices, use concat if we have it |
| * available, otherwise fail. |
| */ |
| if (ret == 0 || ret == -ENXIO) { |
| if (found == 1) { |
| *rmtd = subdev[0]; |
| ret = 0; |
| } else if (found > 1) { |
| /* |
| * We detected multiple devices. Concatenate |
| * them together. |
| */ |
| *rmtd = mtd_concat_create(subdev, found, |
| "clps flash"); |
| if (*rmtd == NULL) |
| ret = -ENXIO; |
| } |
| } |
| |
| /* |
| * If we failed, clean up. |
| */ |
| if (ret) { |
| do { |
| if (clps[i].mtd) |
| map_destroy(clps[i].mtd); |
| if (clps[i].vbase) |
| iounmap(clps[i].vbase); |
| if (clps[i].res) |
| release_resource(clps[i].res); |
| } while (i--); |
| |
| kfree(maps); |
| } |
| |
| return ret; |
| } |
| |
| static void __exit clps_destroy_mtd(struct clps_info *clps, struct mtd_info *mtd) |
| { |
| int i; |
| |
| del_mtd_partitions(mtd); |
| |
| if (mtd != clps[0].mtd) |
| mtd_concat_destroy(mtd); |
| |
| for (i = NR_SUBMTD; i >= 0; i--) { |
| if (clps[i].mtd) |
| map_destroy(clps[i].mtd); |
| if (clps[i].vbase) |
| iounmap(clps[i].vbase); |
| if (clps[i].res) |
| release_resource(clps[i].res); |
| } |
| kfree(clps[0].map); |
| } |
| |
| /* |
| * We define the memory space, size, and width for the flash memory |
| * space here. |
| */ |
| |
| static int __init clps_setup_flash(void) |
| { |
| int nr = 0; |
| |
| #ifdef CONFIG_ARCH_CEIVA |
| if (machine_is_ceiva()) { |
| info[0].base = CS0_PHYS_BASE; |
| info[0].size = SZ_32M; |
| info[0].width = CEIVA_FLASH_WIDTH; |
| info[1].base = CS1_PHYS_BASE; |
| info[1].size = SZ_32M; |
| info[1].width = CEIVA_FLASH_WIDTH; |
| nr = 2; |
| } |
| #endif |
| return nr; |
| } |
| |
| static struct mtd_partition *parsed_parts; |
| static const char *probes[] = { "cmdlinepart", "RedBoot", NULL }; |
| |
| static void __init clps_locate_partitions(struct mtd_info *mtd) |
| { |
| const char *part_type = NULL; |
| int nr_parts = 0; |
| do { |
| /* |
| * Partition selection stuff. |
| */ |
| nr_parts = parse_mtd_partitions(mtd, probes, &parsed_parts, 0); |
| if (nr_parts > 0) { |
| part_type = "command line"; |
| break; |
| } |
| #ifdef CONFIG_MTD_CEIVA_STATICMAP |
| nr_parts = clps_static_partitions(&parsed_parts); |
| if (nr_parts > 0) { |
| part_type = "static"; |
| break; |
| } |
| printk("found: %d partitions\n", nr_parts); |
| #endif |
| } while (0); |
| |
| if (nr_parts == 0) { |
| printk(KERN_NOTICE "clps flash: no partition info " |
| "available, registering whole flash\n"); |
| add_mtd_device(mtd); |
| } else { |
| printk(KERN_NOTICE "clps flash: using %s partition " |
| "definition\n", part_type); |
| add_mtd_partitions(mtd, parsed_parts, nr_parts); |
| } |
| |
| /* Always succeeds. */ |
| } |
| |
| static void __exit clps_destroy_partitions(void) |
| { |
| kfree(parsed_parts); |
| } |
| |
| static struct mtd_info *mymtd; |
| |
| static int __init clps_mtd_init(void) |
| { |
| int ret; |
| int nr; |
| |
| nr = clps_setup_flash(); |
| if (nr < 0) |
| return nr; |
| |
| ret = clps_setup_mtd(info, nr, &mymtd); |
| if (ret) |
| return ret; |
| |
| clps_locate_partitions(mymtd); |
| |
| return 0; |
| } |
| |
| static void __exit clps_mtd_cleanup(void) |
| { |
| clps_destroy_mtd(info, mymtd); |
| clps_destroy_partitions(); |
| } |
| |
| module_init(clps_mtd_init); |
| module_exit(clps_mtd_cleanup); |
| |
| MODULE_AUTHOR("Rob Scott"); |
| MODULE_DESCRIPTION("Cirrus Logic JEDEC map driver"); |
| MODULE_LICENSE("GPL"); |