[mirror_ubuntu-bionic-kernel.git] / drivers / mtd / maps / dmv182.c


/*
 * drivers/mtd/maps/dmv182.c
 *
 * Flash map driver for the Dy4 SVME182 board
 *
 * $Id: dmv182.c,v 1.6 2005/11/07 11:14:26 gleixner Exp $
 *
 * Copyright 2003-2004, TimeSys Corporation
 *
 * Based on the SVME181 flash map, by Tom Nelson, Dot4, Inc. for TimeSys Corp.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <asm/io.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>
#include <linux/errno.h>

/*
 * This driver currently handles only the 16MiB user flash bank 1 on the
 * board.  It does not provide access to bank 0 (contains the Dy4 FFW), bank 2
 * (VxWorks boot), or the optional 48MiB expansion flash.
 *
 * scott.wood@timesys.com: On the newer boards with 128MiB flash, it
 * now supports the first 96MiB (the boot flash bank containing FFW
 * is excluded).  The VxWorks loader is in partition 1.
 */

#define FLASH_BASE_ADDR 0xf0000000
#define FLASH_BANK_SIZE (128*1024*1024)

MODULE_AUTHOR("Scott Wood, TimeSys Corporation <scott.wood@timesys.com>");
MODULE_DESCRIPTION("User-programmable flash device on the Dy4 SVME182 board");
MODULE_LICENSE("GPL");

static struct map_info svme182_map = {
	.name		= "Dy4 SVME182",
	.bankwidth	= 32,
	.size		=  128 * 1024 * 1024
};

#define BOOTIMAGE_PART_SIZE		((6*1024*1024)-RESERVED_PART_SIZE)

// Allow 6MiB for the kernel
#define NEW_BOOTIMAGE_PART_SIZE  (6 * 1024 * 1024)
// Allow 1MiB for the bootloader
#define NEW_BOOTLOADER_PART_SIZE (1024 * 1024)
// Use the remaining 9MiB at the end of flash for the RFS
#define NEW_RFS_PART_SIZE        (0x01000000 - NEW_BOOTLOADER_PART_SIZE - \
                                  NEW_BOOTIMAGE_PART_SIZE)

static struct mtd_partition svme182_partitions[] = {
	// The Lower PABS is only 128KiB, but the partition code doesn't
	// like partitions that don't end on the largest erase block
	// size of the device, even if all of the erase blocks in the
	// partition are small ones.  The hardware should prevent
	// writes to the actual PABS areas.
	{
		name:       "Lower PABS and CPU 0 bootloader or kernel",
		size:       6*1024*1024,
		offset:     0,
	},
	{
		name:       "Root Filesystem",
		size:       10*1024*1024,
		offset:     MTDPART_OFS_NXTBLK
	},
	{
		name:       "CPU1 Bootloader",
		size:       1024*1024,
		offset:     MTDPART_OFS_NXTBLK,
	},
	{
		name:       "Extra",
		size:       110*1024*1024,
		offset:     MTDPART_OFS_NXTBLK
	},
	{
		name:       "Foundation Firmware and Upper PABS",
		size:       1024*1024,
		offset:     MTDPART_OFS_NXTBLK,
		mask_flags: MTD_WRITEABLE // read-only
	}
};

static struct mtd_info *this_mtd;

static int __init init_svme182(void)
{
	struct mtd_partition *partitions;
	int num_parts = ARRAY_SIZE(svme182_partitions);

	partitions = svme182_partitions;

	svme182_map.virt = ioremap(FLASH_BASE_ADDR, svme182_map.size);

	if (svme182_map.virt == 0) {
		printk("Failed to ioremap FLASH memory area.\n");
		return -EIO;
	}

	simple_map_init(&svme182_map);

	this_mtd = do_map_probe("cfi_probe", &svme182_map);
	if (!this_mtd)
	{
		iounmap((void *)svme182_map.virt);
		return -ENXIO;
	}

	printk(KERN_NOTICE "SVME182 flash device: %dMiB at 0x%08x\n",
		   this_mtd->size >> 20, FLASH_BASE_ADDR);

	this_mtd->owner = THIS_MODULE;
	add_mtd_partitions(this_mtd, partitions, num_parts);

	return 0;
}

static void __exit cleanup_svme182(void)
{
	if (this_mtd)
	{
		del_mtd_partitions(this_mtd);
		map_destroy(this_mtd);
	}

	if (svme182_map.virt)
	{
		iounmap((void *)svme182_map.virt);
		svme182_map.virt = 0;
	}

	return;
}

module_init(init_svme182);
module_exit(cleanup_svme182);
Commit	Line	Data
1da177e4 LT	1
1da177e4 LT	2	/*
f30c2269	3	* drivers/mtd/maps/dmv182.c
69f34c98	4	*
1da177e4	5	* Flash map driver for the Dy4 SVME182 board
69f34c98 TG	6	*
69f34c98 TG	7	* $Id: dmv182.c,v 1.6 2005/11/07 11:14:26 gleixner Exp $
1da177e4 LT	8	*
	9	* Copyright 2003-2004, TimeSys Corporation
	10	*
	11	* Based on the SVME181 flash map, by Tom Nelson, Dot4, Inc. for TimeSys Corp.
	12	*
	13	* This program is free software; you can redistribute it and/or modify it
	14	* under the terms of the GNU General Public License as published by the
	15	* Free Software Foundation; either version 2 of the License, or (at your
	16	* option) any later version.
	17	*/
	18
1da177e4 LT	19	#include <linux/module.h>
	20	#include <linux/init.h>
	21	#include <linux/types.h>
	22	#include <linux/kernel.h>
	23	#include <asm/io.h>
	24	#include <linux/mtd/mtd.h>
	25	#include <linux/mtd/map.h>
	26	#include <linux/mtd/partitions.h>
	27	#include <linux/errno.h>
	28
	29	/*
	30	* This driver currently handles only the 16MiB user flash bank 1 on the
	31	* board. It does not provide access to bank 0 (contains the Dy4 FFW), bank 2
	32	* (VxWorks boot), or the optional 48MiB expansion flash.
	33	*
	34	* scott.wood@timesys.com: On the newer boards with 128MiB flash, it
	35	* now supports the first 96MiB (the boot flash bank containing FFW
	36	* is excluded). The VxWorks loader is in partition 1.
	37	*/
	38
	39	#define FLASH_BASE_ADDR 0xf0000000
	40	#define FLASH_BANK_SIZE (12810241024)
	41
	42	MODULE_AUTHOR("Scott Wood, TimeSys Corporation <scott.wood@timesys.com>");
	43	MODULE_DESCRIPTION("User-programmable flash device on the Dy4 SVME182 board");
	44	MODULE_LICENSE("GPL");
	45
	46	static struct map_info svme182_map = {
	47	.name = "Dy4 SVME182",
	48	.bankwidth = 32,
	49	.size = 128 * 1024 * 1024
	50	};
	51
	52	#define BOOTIMAGE_PART_SIZE ((610241024)-RESERVED_PART_SIZE)
	53
	54	// Allow 6MiB for the kernel
	55	#define NEW_BOOTIMAGE_PART_SIZE (6 * 1024 * 1024)
	56	// Allow 1MiB for the bootloader
	57	#define NEW_BOOTLOADER_PART_SIZE (1024 * 1024)
	58	// Use the remaining 9MiB at the end of flash for the RFS
	59	#define NEW_RFS_PART_SIZE (0x01000000 - NEW_BOOTLOADER_PART_SIZE - \
	60	NEW_BOOTIMAGE_PART_SIZE)
	61
	62	static struct mtd_partition svme182_partitions[] = {
	63	// The Lower PABS is only 128KiB, but the partition code doesn't
	64	// like partitions that don't end on the largest erase block
	65	// size of the device, even if all of the erase blocks in the
	66	// partition are small ones. The hardware should prevent
	67	// writes to the actual PABS areas.
	68	{
	69	name: "Lower PABS and CPU 0 bootloader or kernel",
	70	size: 610241024,
	71	offset: 0,
	72	},
	73	{
	74	name: "Root Filesystem",
	75	size: 1010241024,
	76	offset: MTDPART_OFS_NXTBLK
	77	},
	78	{
	79	name: "CPU1 Bootloader",
	80	size: 1024*1024,
	81	offset: MTDPART_OFS_NXTBLK,
	82	},
83	{
84	name: "Extra",
85	size: 11010241024,
86	offset: MTDPART_OFS_NXTBLK
87	},
88	{
89	name: "Foundation Firmware and Upper PABS",
90	size: 1024*1024,
91	offset: MTDPART_OFS_NXTBLK,
92	mask_flags: MTD_WRITEABLE // read-only
93	}
94	};
95
96	static struct mtd_info *this_mtd;
97
98	static int __init init_svme182(void)
99	{
100	struct mtd_partition *partitions;
87d10f3c	101	int num_parts = ARRAY_SIZE(svme182_partitions);
1da177e4 LT	102
	103	partitions = svme182_partitions;
	104
	105	svme182_map.virt = ioremap(FLASH_BASE_ADDR, svme182_map.size);
69f34c98	106
1da177e4 LT	107	if (svme182_map.virt == 0) {
	108	printk("Failed to ioremap FLASH memory area.\n");
	109	return -EIO;
	110	}
	111
	112	simple_map_init(&svme182_map);
	113
	114	this_mtd = do_map_probe("cfi_probe", &svme182_map);
	115	if (!this_mtd)
	116	{
	117	iounmap((void *)svme182_map.virt);
	118	return -ENXIO;
	119	}
	120
	121	printk(KERN_NOTICE "SVME182 flash device: %dMiB at 0x%08x\n",
	122	this_mtd->size >> 20, FLASH_BASE_ADDR);
	123
	124	this_mtd->owner = THIS_MODULE;
	125	add_mtd_partitions(this_mtd, partitions, num_parts);
	126
	127	return 0;
	128	}
	129
	130	static void __exit cleanup_svme182(void)
	131	{
	132	if (this_mtd)
	133	{
	134	del_mtd_partitions(this_mtd);
	135	map_destroy(this_mtd);
	136	}
	137
	138	if (svme182_map.virt)
	139	{
	140	iounmap((void *)svme182_map.virt);
	141	svme182_map.virt = 0;
	142	}
	143
	144	return;
	145	}
	146
	147	module_init(init_svme182);
	148	module_exit(cleanup_svme182);