mtdpart.c

SMDK2440 boot code, base on vivi

/*
 * vivi/drivers/mtd/mtdpart.c: Simple MTD partitioning layer
 *
 * Copyright (C) 2001-2004 MIZI Research, Inc. All Rights Reserved.
 *
 * Author:	Janghoon Lyu
 * Created:	December 23, 2001
 *
 * Last modified: $Date: 2004/03/30 04:10:20 $
 *                $Revision: 1.14 $
 *
 * $Id: mtdpart.c,v 1.14 2004/03/30 04:10:20 nandy Exp $
 *
 *
 * o Structure of MTD partition block
 *
 * +--------------------------------+
 * |  number of partition (4 bytes) |
 * +--------------------------------+
 * |                                |
 * |  partition table               |
 * |                                |
 * +--------------------------------+
 *
 */

#include <config.h>
#include <machine.h>
#include <memory.h>
#include <command.h>
#include <types.h>
#include <vstring.h>
#include <mtd/mtd.h>
#include <mtd/partitions.h>
#include <vfs.h>
#include <vmalloc.h>

extern mtd_partition_t default_mtd_partitions[];
extern int default_nb_part;

mtd_partition_t *mtd_parts = NULL;
int nb_mtd_parts = 0;

#ifdef CONFIG_MTD_PARTITIONS_PARSER
int (*mtd_part_parser) (void *ptr) = NULL;

int mtdpart_add_parser(int (*func) (void *ptr)) 
{
	mtd_part_parser = func;
	return 0;
}

int mtdpart_del_parser(int (*func) (void *ptr)) 
{
	mtd_part_parser = NULL;
	return 0;
}

void mtdpart_refresh(void)
{
	/* Try to parse mtd partition information */
	if ((mymtd != NULL) && (mtd_part_parser != NULL)) {
		nb_mtd_parts = mtd_part_parser(mtd_parts);
		printk("Parsing mtd partition information... ");
		if (nb_mtd_parts > 0) {
			printk("ok\n");
		} else {
			printk("fail\n");
		}
	}
}
#endif /* CONFIG_MTD_PARTITIONS_PARSER */

/*
 * APIs for vivi
 */

/*
 * get a mtd partition by name
 */
mtd_partition_t *
get_mtd_partition(const char *name)
{
	int i, num = nb_mtd_parts;
	mtd_partition_t *parts = mtd_parts;

	for (i = 0; i < num; i++, parts++) {
		if ((strncmp(parts->name, name, strlen(name)) == 0) &&
		    (strlen(parts->name) == strlen(name))) {
			return parts;
		}
	}
	return NULL;
}

/*
 * get a information of mtd by offset
 */
mtd_partition_t *
find_mtd_partition(ulong ofs)
{
	int i, num = nb_mtd_parts;
	mtd_partition_t *parts = mtd_parts;

	for (i = 0; i < num; i++, parts++) {
		if ((parts->offset <= ofs) && (ofs < (parts->offset+parts->size))) {
			return parts;
		}
	}
	return NULL;
}

/*
 * add mtd partitions
 */
static int 
add_mtd_partition(mtd_partition_t *new_part)
{
	int num = nb_mtd_parts;
	mtd_partition_t *parts = mtd_parts;

	memcpy((parts + num), new_part, sizeof(mtd_partition_t));
	num++;
	nb_mtd_parts = num;
	return 0;
}

/*
 * delete mtd partition
 */
static int 
del_mtd_partition(const char *part_name)
{
	int i, j;
	int num = nb_mtd_parts;
	mtd_partition_t *parts = mtd_parts;

	for (i = 0; i < num; i++) {
		if (!strncmp((parts + i)->name, part_name, strlen(part_name)))
			break;
	}
	
	if (i == num)
		return -1;

	for (j = i; j < num; j++) {
		memcpy((parts+j), (parts+j+1), sizeof(mtd_partition_t));
	}

	num--;
	nb_mtd_parts = num;

	return 0;
}

/*
 * reset mtd partitions: set mtd partition table to default partition table
 */
static int 
reset_mtd_partition(void)
{
	/* Try to find built-in mtd partitions */
	if (default_mtd_partitions == NULL) {
		printk("Can't get default mtd partition information\n");
		return -1;
	}

	nb_mtd_parts = default_nb_part;
	memcpy(mtd_parts, default_mtd_partitions, sizeof(mtd_partition_t)*nb_mtd_parts);
	return 0;
}

/*
 * print partition informations
 */
static void 
display_mtd_partition(void)
{
	mtd_partition_t *parts = mtd_parts;
	int i, nb_parts = nb_mtd_parts;
	char sflag[16];


	printk("Number of partitions: %d\n", nb_parts);
	      /*name            :       offset          size            flag*/
	printk("%-16s:\toffset\t\tsize\t\tflag\n", "name");
	printk("------------------------------------------------------------\n");
	for(i = 0; i < nb_parts; i++) {
		switch (parts->flag) {
		case MF_CRAMFS:
			strcpy(sflag, "cramfs\0");
			break;
		case MF_BON:
			strcpy(sflag, "bon(cramfs)\0");
			break;
		case MF_YAFFS:
			strcpy(sflag, "yaffs\0");
			break;
		case MF_RAW:
			strcpy(sflag, "raw\0");
			break;
		case MF_DOC:
			strcpy(sflag, "doc\0");
			break;
		default:
			strcpy(sflag, "unknown\0");
			break;
		}

		printk("%-16s:\t0x%08lx\t0x%08lx\t%s\n", 
			parts->name, parts->offset, 
			parts->size, sflag);	
		parts++;
	}
}

static ulong
flagtoul(char *flag)
{
	if (strncmp(flag, "cramfs", 5) == 0) return MF_CRAMFS;
	else if (strncmp(flag, "jffs2", 5) == 0) return MF_JFFS2;
	else if (strncmp(flag, "lock", 4) == 0) return MF_LOCK;
	else if (strncmp(flag, "ram", 3) == 0) return MF_RAM;
	else if (strncmp(flag, "bon", 3) == 0) return MF_BON;
	else if (strncmp(flag, "yaffs", 3) == 0) return MF_YAFFS;
	else if (strncmp(flag, "raw", 3) == 0) return MF_RAW;
	else return 0;
}

static ulong
parse_flags(char *str)
{
	char *delim;
	ulong flag;

	flag = 0;
	delim = str;
	while ((str = delim) != NULL) {
		delim = strchr(str, '|');
		if (delim != NULL)
			*delim++ = '\0';
		flag |= flagtoul(str);
	}

	return flag;
}


/*
 * vivi command
 */
void
usage(void)
{
printk("Usage:\n");
printk("  add <name> <offset> <size> <flag>  -- Add a mtd partition entry\n");
printk("  del <name>                         -- Delete a mtd partition entry\n");
printk("  reset                              -- Reset mtd parition table\n");
//printk("  save                               -- Save mtd partition table\n");
printk("  info                               -- Display mtd partition table\n");
}
void command_part(int argc, const char **argv)
{
	switch (argc) {
	case 2:
		if (strncmp(argv[1], "reset", 5) == 0) {
			reset_mtd_partition();
			return;
		}

		if (strncmp(argv[1], "info", 4) == 0) {
			display_mtd_partition();
			return;
		}

		break;
	case 3:
		if (strncmp(argv[1], "del", 3) == 0) {
			if (del_mtd_partition(argv[2]) < 0)
				printk("'%s' is not exist.\n", argv[2]);
			else
				printk("deleted '%s' partition\n", argv[2]);

			return;
		}

		break;
	case 6:
		if (strncmp(argv[1], "add", 3) == 0) {
			mtd_partition_t part;
			int n;

			n = strlen(argv[2]);

			if ((n-1) > MAX_PART_NAME) {
				printk("invalid partition name\n");
			}

			strcpy((char *)part.name, argv[2]);
			part.name[n] = '\0';
			part.offset = simple_strtoul(argv[3], NULL, 0);
			part.size = simple_strtoul(argv[4], NULL, 0);
			part.flag = parse_flags((char *)argv[5]);
			part.priv = NULL;

			add_mtd_partition(&part);
			printk("%s: offset = 0x%08lx, size = 0x%08lx, flag = %d\n",
				part.name, part.offset, part.size, part.flag);

			return;
		}

		break;
	default:
		break;
	}
	usage();
}

user_command_t part_cmd = {
	"part", 
	command_part, 
	NULL
};

/*
 * mtd_part_init(): Initialize mtd partitions.
 */
int
mtd_part_init(void)
{
	/* allocate memory */
	mtd_parts = vmalloc(MAX_PARTITIONS * sizeof(mtd_partition_t));


#ifdef CONFIG_MTD_PARTITIONS_PARSER
	/* Try to parse mtd partition information */
	if ((mymtd != NULL) && (mtd_part_parser != NULL)) {
		nb_mtd_parts = mtd_part_parser(mtd_parts);
		printk("Parsing mtd partition information... ");
		if (nb_mtd_parts > 0) {
			printk("ok\n");
			goto done;
		} else {
			printk("fail\n");
		}
	}
#endif

#ifdef CONFIG_VIVI_FS
	/* Try to find stored mtd partition informations */
#endif
	
	/* Try to find built-in mtd partitions */
	if (default_mtd_partitions != NULL) {
		printk("Found default mtd partitions\n");
		nb_mtd_parts = default_nb_part;
		memcpy(mtd_parts, default_mtd_partitions, sizeof(mtd_partition_t)*nb_mtd_parts);
		goto done;
	} else {
		printk("Can't get default mtd partition information\n");
	}

	return 1;

done:
	add_command(&part_cmd);
	return 0;
}