Enable blockdev core to automatically create partitions based on DOS partition table. This code is based on /disk/, and should eventually replace it.

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- drivers/blockdev/Makefile | 1 + drivers/blockdev/core.c | 752 +++++++++++++++++++++++++++++++ drivers/blockdev/part_types/part_dos.c | 148 ++++++ drivers/blockdev/part_types/part_dos.h | 49 ++ drivers/blockdev/part_types/part_types.h | 34 ++ 5 files changed, 984 insertions(+) create mode 100644 drivers/blockdev/core.c create mode 100644 drivers/blockdev/part_types/part_dos.c create mode 100644 drivers/blockdev/part_types/part_dos.h create mode 100644 drivers/blockdev/part_types/part_types.h

diff --git a/drivers/blockdev/Makefile b/drivers/blockdev/Makefile index 693e236..a988924 100644 --- a/drivers/blockdev/Makefile +++ b/drivers/blockdev/Makefile @@ -22,6 +22,7 @@ include $(TOPDIR)/config.mk LIB := $(obj)libblockdev.o

COBJS-${CONFIG_DM_BLOCK} := core.o +COBJS-${CONFIG_DOS_PARTITION} += part_types/part_dos.o

COBJS := $(COBJS-y) SRCS := $(COBJS:.o=.c) diff --git a/drivers/blockdev/core.c b/drivers/blockdev/core.c new file mode 100644 index 0000000..bf1c70d --- /dev/null +++ b/drivers/blockdev/core.c @@ -0,0 +1,752 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include <dm/blockdev.h> +#include <dm/manager.h> +#include <malloc.h> +#include "part_types/part_types.h" + +static const char * const blockdev_name[] = {"unk", "unk", "ata", "sd", "usb"}; +static const char * const iftype_name[] = {"unknown", "-", "ATAPI", "SD/MMC", + "USB"}; + +#define BLOCKDEV_PARTITION_SEPARATOR ':' + +#define BLOCKDEV_IFTYPE_BITS 4 +#define BLOCKDEV_IFTYPE_COUNT (1<<BLOCKDEV_IFTYPE_BITS) +#define BLOCKDEV_IFTYPE_MAX BLOCKDEV_IFTYPE_COUNT-1 + +struct blockdev_id { + struct { + unsigned type:BLOCKDEV_IFTYPE_BITS; + unsigned number:(16-BLOCKDEV_IFTYPE_BITS); + } disk; + unsigned partition:16; +}; + +static struct blockdev_id invalid_id = {{0xf, 0xfff}, 0xffff}; +static struct blockdev_id empty_id = {{0x0, 0x0}, 0x0}; + +static inline int id_cmp(const struct blockdev_id *left, + const struct blockdev_id *right) +{ + return memcmp(left, right, sizeof(struct blockdev_id)); +} + +struct blockdev_core_entry { + struct list_head list; + struct instance *instance; + struct blockdev_ops *ops; + struct blockdev_id name; +}; + +struct blockdev_core_private { + /* Put cache here */ +}; + +struct bdid_instance_pair { + struct blockdev_id id; + struct instance *inst; +}; + +static struct blockdev_core_entry *get_entry_by_instance(struct instance *i) +{ + struct blockdev_core_entry *tmp; + struct core_instance *core = get_core_instance(CORE_BLOCKDEV); + + if (!core) + return NULL; + + list_for_each_entry(tmp, &core->succ, list) + if (tmp->instance == i) + return tmp; + + return NULL; +} + +static struct blockdev_core_entry *get_entry_by_id(struct blockdev_id id) +{ + struct blockdev_core_entry *tmp; + struct core_instance *core = get_core_instance(CORE_BLOCKDEV); + + if (!core) + return NULL; + + list_for_each_entry(tmp, &core->succ, list) + if (!id_cmp(&tmp->name, &id)) + return tmp; + + return NULL; +} + +static inline int try_match_name(enum blockdev_iftype type, + struct blockdev_id *id, char **name) +{ + int len = strlen(blockdev_name[type]); + + if (!strncmp(*name, blockdev_name[type], len)) { + id->disk.type = type; + *name += len; + return 0; + } + return 1; +} + +static struct blockdev_id get_id_from_name(char *name) +{ + struct blockdev_id disk_id = empty_id; + + if (!try_match_name(BLOCKDEV_IFTYPE_UNKNOWN, &disk_id, &name)) + goto get_number; + if (!try_match_name(BLOCKDEV_IFTYPE_ATA, &disk_id, &name)) + goto get_number; + if (!try_match_name(BLOCKDEV_IFTYPE_SD, &disk_id, &name)) + goto get_number; + if (!try_match_name(BLOCKDEV_IFTYPE_USB, &disk_id, &name)) + goto get_number; + + return invalid_id; + +get_number: + /* get disk number from name */ + if ((*name < '0') || (*name > '9')) + return invalid_id; + + disk_id.disk.number *= 10; + disk_id.disk.number += (*name-'0'); + name++; + + switch (*name) { + case 0: + return disk_id; + case BLOCKDEV_PARTITION_SEPARATOR: + name += 1; + goto get_part; + default: + goto get_number; + } + return invalid_id; + +get_part: + /* get partition number fron name */ + if ((*name < '0') || (*name > '9')) + return invalid_id; + + disk_id.partition *= 10; + disk_id.partition += (*name-'0'); + name++; + + switch (*name) { + case 0: + return disk_id; + default: + goto get_part; + } + + return invalid_id; +} + +static int get_free_index(struct core_instance *core, enum blockdev_iftype type) +{ + int retval = 0; + struct blockdev_core_entry *entry; + + list_for_each_entry(entry, &core->succ, list) { + if ((entry->name.disk.type == type) && + (entry->name.disk.number >= retval)) + retval = entry->name.disk.number + 1; + } + + return retval; +} + +static struct blockdev_id create_id_from_hint(struct core_instance *core, + struct instance *dev, void* data) +{ + struct blockdev_id retval = empty_id; + struct blockdev_core_entry *entry; + struct blockdev_core_hint *hint = data; + + /* no hint means we have no idea what type of device we have */ + if (!hint) + retval.disk.type = BLOCKDEV_IFTYPE_UNKNOWN; + else { + /* for a partition, we find its parent and use its name */ + if (hint->iftype == BLOCKDEV_IFTYPE_PARTITION) { + entry = get_entry_by_instance(dev->bus); + retval.disk = entry->name.disk; + retval.partition = hint->part_number; + return retval; + /* if we have a valid hint for a disk, get a free index */ + } else { + retval.disk.type = hint->iftype; + retval.disk.number = get_free_index(core, hint->iftype); + retval.partition = 0; + } + } + + return retval; +} + +/* Core API functions */ +static int get_count(struct core_instance *core) +{ + int cnt = 0; + struct blockdev_core_entry *entry = NULL; + + list_for_each_entry(entry, &core->succ, list) + cnt++; + + return cnt; +} + +static struct instance *get_child(struct core_instance *core, int index) +{ + struct blockdev_core_entry *entry = NULL; + + list_for_each_entry(entry, &core->succ, list) { + if (!index) + return entry->instance; + index--; + } + + return NULL; +} + +static int bind(struct core_instance *core, struct instance *dev, void *ops, + void *data) +{ + struct blockdev_core_entry *entry; + + if (ops == NULL) + return -EINVAL; + + entry = malloc(sizeof(*entry)); + if (entry == NULL) + return -ENOMEM; + + INIT_LIST_HEAD(&entry->list); + entry->instance = dev; + entry->ops = ops; + entry->name = create_id_from_hint(core, dev, data); + list_add_tail(&entry->list, &core->succ); + + return 0; +} + +static int unbind(struct core_instance *core, struct instance *dev) +{ + struct blockdev_core_entry *entry, *n; + + list_for_each_entry_safe(entry, n, &core->succ, list) { + if (entry->instance == dev) { + list_del(&entry->list); + free(entry); + } + } + + return 0; +} + +static int replace(struct core_instance *core, struct instance *new, + struct instance *old) +{ + struct blockdev_core_entry *entry = get_entry_by_instance(old); + + if (!entry) + return -ENOENT; + + entry->instance = new; + + return 0; +} + +static int init(struct core_instance *core) +{ + INIT_LIST_HEAD(&core->succ); + core->private_data = NULL; + + return 0; +} + +static int reloc(struct core_instance *core, struct core_instance *old) +{ + struct blockdev_core_entry *entry, *new; + + /* no private_data to copy, yet */ + + /* fixup links in old list and prepare new list head */ + /* FIXME */ + /* list_fix_reloc(&old->succ); */ + INIT_LIST_HEAD(&core->succ); + core->private_data = NULL; + + /* copy list entries to new memory */ + list_for_each_entry(entry, &old->succ, list) { + new = malloc(sizeof(*new)); + if (!new) + return -ENOMEM; + + INIT_LIST_HEAD(&new->list); + new->instance = entry->instance; + new->ops = entry->ops; + new->name = entry->name; + list_add_tail(&new->list, &core->succ); + /*no free at this point, old memory should not be freed*/ + } + + return 0; +} + +static int destroy(struct core_instance *core) +{ + struct blockdev_core_entry *entry, *n; + + /* destroy private data */ + free(core->private_data); + core->private_data = NULL; + + /* destroy successor list */ + list_for_each_entry_safe(entry, n, &core->succ, list) { + list_del(&entry->list); + free(entry); + } + + return 0; +} + +U_BOOT_CORE(CORE_BLOCKDEV, + init, + reloc, + destroy, + get_count, + get_child, + bind, + unbind, + replace); + +/* Driver wrapping API */ +lbaint_t blockdev_read(struct instance *i, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *device_ops = NULL; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + device_ops = entry->ops; + if (!device_ops || !device_ops->read) + return -EINVAL; + + return device_ops->read(i, start, blkcnt, buffer); +} + +lbaint_t blockdev_write(struct instance *i, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *device_ops = NULL; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + device_ops = entry->ops; + if (!device_ops || !device_ops->write) + return -EINVAL; + + return device_ops->write(i, start, blkcnt, buffer); +} + +lbaint_t blockdev_erase(struct instance *i, lbaint_t start, lbaint_t blkcnt) +{ + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *device_ops = NULL; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + device_ops = entry->ops; + if (!device_ops) + return -EINVAL; + + return device_ops->erase(i, start, blkcnt); +} + +int blockdev_get_option(struct instance *i, enum blockdev_option_code op, + struct option *result) +{ + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *device_ops = NULL; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + device_ops = entry->ops; + if (!device_ops) + return -EINVAL; + + return device_ops->get_option(i, op, result); +} + +int blockdev_set_option(struct instance *i, enum blockdev_option_code op, + struct option *value) +{ + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *device_ops = NULL; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + device_ops = entry->ops; + if (!device_ops) + return -EINVAL; + + return device_ops->set_option(i, op, value); +} + +/* Command related functions */ +struct instance *get_blockdev_by_name(char *name) +{ + struct blockdev_id disk_id = empty_id; + struct blockdev_core_entry *entry; + + if (!name) + return NULL; + + disk_id = get_id_from_name(name); + + if (id_cmp(&disk_id, &invalid_id)) { + entry = get_entry_by_id(disk_id); + if (entry) + return entry->instance; + } + + return NULL; +} + +int scan_partitions(struct instance *dev) +{ + struct blockdev_core_entry *entry; + struct driver_instance *di, *tmp; + + entry = get_entry_by_instance(dev); + /* ignore if instance is partition or not a blockdev */ + if (!entry || (entry->name.partition != 0)) + return -EINVAL; + + /* remove all children */ + list_for_each_entry_safe(di, tmp, &dev->succ, list) { + driver_remove(&di->i); + driver_unbind(&di->i); + } + + /* determine type of partition table and scan for partitions */ +#ifdef CONFIG_DOS_PARTITION + if (!test_partitions_dos(dev)) + return scan_partitions_dos(dev); +#endif + + return -ENOENT; +} + +static inline int part_number_overflow(int number) +{ + /* just support 128 partitions for now */ + return (number > 128); +} + +int add_partition(struct instance *parent, lbaint_t start, lbaint_t length, + unsigned int number) +{ + struct blockdev_partition_platform_data *platform = NULL; + struct driver_info *info = NULL; + + /* check for overflow in partition number */ + if (part_number_overflow(number)) + return -EINVAL; + + platform = malloc(sizeof(*platform)); + info = malloc(sizeof(*info)); + if (!platform || !info) { + /* malloc went wrong, cleanup and indicate imminent death */ + free(platform); + free(info); + return -ENOMEM; + } + + platform->offset = start; + platform->block_count = length; + platform->part_number = number; + info->name = "blockdev_partition"; + info->platform_data = platform; + if (!driver_bind(parent, info)) + return -ENOMEM; + + return 0; +} + +/* Info printing stuff */ +static char *type_name(unsigned type) +{ + switch (type) { + case BLOCKDEV_TYPE_UNKNOWN: + return "Unknown/Not Connected"; + case BLOCKDEV_TYPE_HARDDISK: + return "Hard drive"; + case BLOCKDEV_TYPE_TAPE: + return "Tape"; + case BLOCKDEV_TYPE_CDROM: + return "CDROM"; + case BLOCKDEV_TYPE_OPDISK: + return "Optical disk"; + default: + return "Unknown"; + }; +} + +static inline int get_opt_u(struct blockdev_ops *ops, struct instance *dev, + enum blockdev_option_code code, struct option *opt) +{ + int retval = ops->get_option(dev, code, opt); + if (retval) + return retval; + + /* If we dont get the correct type we fail. */ + if (OPTION_TYPE(*opt) != OPTION_TYPE_U) + retval = -EINVAL; + + /* If we get a mallocated string we should free it. */ + if (opt->flags & OPTION_PTR_MALLOCED) + free(opt->data.data_s); + + return retval; +} + +static inline int get_opt_s(struct blockdev_ops *ops, struct instance *dev, + enum blockdev_option_code code, struct option *opt) +{ + int retval = ops->get_option(dev, code, opt); + if (retval) + return retval; + + /* If we dont get the correct type we fail. */ + if (OPTION_TYPE(*opt) != OPTION_TYPE_S) + retval = -EINVAL; + + return retval; +} + +int print_blockdev_info(struct instance *dev) +{ + struct option opt; + unsigned int type = 0; + unsigned int block_size = 0; + lbaint_t offset = 0; + lbaint_t block_count = 0; + char *vendor = NULL; + char *product = NULL; + char *revision = NULL; + int vendor_malloc = 0; + int product_malloc = 0; + int revision_malloc = 0; + struct blockdev_id id = empty_id; + struct blockdev_core_entry *entry = NULL; + struct blockdev_ops *ops = NULL; + int retval = 0; + enum blockdev_iftype iftype; + + entry = get_entry_by_instance(dev); + if (!entry) + return -ENOENT; + else { + id = entry->name; + ops = entry->ops; + } + + /* we are not using blockdev_get_option, so we activate manually here */ + retval = driver_activate(dev); + if (retval) + return retval; + + retval = get_opt_u(ops, dev, BLKD_OPT_TYPE, &opt); + if (retval) + return retval; + type = opt.data.data_u; + + if (type == BLOCKDEV_TYPE_PARTITION) { + /* get options that make sense for a partition */ + retval = get_opt_u(ops, dev, BLKD_OPT_BLOCKCOUNT, &opt); + if (retval) + return retval; + block_count = opt.data.data_u; + + retval = get_opt_u(ops, dev, BLKD_OPT_OFFSET, &opt); + if (retval) + return retval; + offset = opt.data.data_u; + + /* print some information message */ + printf("%s%d:%d\n\tpartition on %s%d\n\t" + "offset: %lu\n\tblock count: %lu\n\n", + blockdev_name[id.disk.type], id.disk.number, + id.partition, blockdev_name[id.disk.type], + id.disk.number, offset, block_count); + + } else { + /* get options that make sense for a disk */ + retval = get_opt_u(ops, dev, BLKD_OPT_IFTYPE, &opt); + if (retval) + return retval; + iftype = opt.data.data_u; + + retval = get_opt_u(ops, dev, BLKD_OPT_BLOCKSIZE, &opt); + if (retval) + return retval; + block_size = opt.data.data_u; + + retval = get_opt_u(ops, dev, BLKD_OPT_BLOCKCOUNT, &opt); + if (retval) + return retval; + block_count = opt.data.data_u; + + retval = get_opt_s(ops, dev, BLKD_OPT_VENDOR, &opt); + if (retval) + return retval; + vendor = opt.data.data_s; + vendor_malloc = opt.flags & OPTION_PTR_MALLOCED; + + retval = get_opt_s(ops, dev, BLKD_OPT_PRODUCT, &opt); + if (retval) + return retval; + product = opt.data.data_s; + product_malloc = opt.flags & OPTION_PTR_MALLOCED; + + retval = get_opt_s(ops, dev, BLKD_OPT_REVISION, &opt); + if (retval) + return retval; + revision = opt.data.data_s; + revision_malloc = opt.flags & OPTION_PTR_MALLOCED; + + /* print some information message */ + printf("%s%d\n\tvendor: %s\n\tproduct: %s\n\t" + "revision: %s\n\ttype: %s\n\tiftype: %s\n\t" + "block size: %d\n\tblock count: %lu\n\n", + blockdev_name[id.disk.type], id.disk.number, + vendor, product, revision, type_name(type), + iftype_name[iftype], block_size, block_count); + + /*cleanup if we got dynamic memory pointers*/ + if (vendor_malloc) + free(vendor); + + if (product_malloc) + free(product); + + if (revision_malloc) + free(revision); + } + + return retval; +} + +static void sort_bdid_i(struct bdid_instance_pair *data, size_t count) +{ + /* use bubble sort for now */ + int a, b; + struct bdid_instance_pair tswap; + + for (a = 1; a < count; a++) { + for (b = a; b > 0; b--) { + if (id_cmp(&data[b].id, &data[b-1].id) < 0) { + /*swap position b and b-1 */ + tswap = data[b-1]; + data[b-1] = data[b]; + data[b] = tswap; + } + } + } +} + +int print_blockdev_info_all(void) +{ + struct core_instance *core = NULL; + struct bdid_instance_pair *sorted_pairs = NULL; + struct blockdev_core_entry *entry = NULL; + int count = 0; + int idx = 0; + + core = get_core_instance(CORE_BLOCKDEV); + if (!core) + return -ENOMEM; + + count = core_get_count(CORE_BLOCKDEV); + sorted_pairs = malloc(sizeof(*sorted_pairs) * count); + if (!sorted_pairs) + return -ENOMEM; + + /* get list of all instances and associated IDs */ + list_for_each_entry(entry, &core->succ, list) { + sorted_pairs[idx].id = entry->name; + sorted_pairs[idx].inst = entry->instance; + idx++; + } + + /* sort isntances by ID */ + sort_bdid_i(sorted_pairs, count); + + /* print info about each instance */ + for (idx = 0; idx < count; idx++) + print_blockdev_info(sorted_pairs[idx].inst); + return 0; +} diff --git a/drivers/blockdev/part_types/part_dos.c b/drivers/blockdev/part_types/part_dos.c new file mode 100644 index 0000000..7d19818 --- /dev/null +++ b/drivers/blockdev/part_types/part_dos.c @@ -0,0 +1,148 @@ +/* + * (C) Copyright 2001 + * Raymond Lo, lo@routefree.com + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +/* + * Support for harddisk partitions. + * + * To be compatible with LinuxPPC and Apple we use the standard Apple + * SCSI disk partitioning scheme. For more information see: + * http://developer.apple.com/techpubs/mac/Devices/Devices-126.html#MARKER-14-9... + */ + +#include <common.h> +#include <ide.h> +#include "part_dos.h" +#include <dm/blockdev.h> + +#if defined(CONFIG_CMD_IDE) || \ + defined(CONFIG_CMD_MG_DISK) || \ + defined(CONFIG_CMD_SATA) || \ + defined(CONFIG_CMD_SCSI) || \ + defined(CONFIG_CMD_USB) || \ + defined(CONFIG_MMC) || \ + defined(CONFIG_SYSTEMACE) + +/* Convert char[4] in little endian format to the host format integer + */ +static inline int le32_to_int(unsigned char *le32) +{ + return ((le32[3] << 24) + + (le32[2] << 16) + + (le32[1] << 8) + + le32[0]); +} + +static inline int is_extended(int part_type) +{ + return (part_type == 0x5 || + part_type == 0xf || + part_type == 0x85); +} + +int test_partitions_dos(struct instance *dev) +{ + struct option blksz; + int error = blockdev_get_option(dev, BLKD_OPT_BLOCKSIZE, &blksz); + if (error) + return error; + + ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, blksz.data.data_u); + + if ((blockdev_read(dev, 0, 1, buffer) != 1) || + (buffer[DOS_PART_MAGIC_OFFSET + 0] != 0x55) || + (buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa)) { + return -EINVAL; + } + return 0; +} + + + +int scan_partitions_dos(struct instance *dev) +{ + struct dos_partition *pt; + lbaint_t extpt_sector = 0; + struct option blksz; + int error = blockdev_get_option(dev, BLKD_OPT_BLOCKSIZE, &blksz); + if (error) + return error; + + ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, blksz.data.data_u); + + if (blockdev_read(dev, 0, 1, buffer) != 1) { + printf("** Can't read partition table **\n"); + return -EINVAL; + } + + if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || + buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) { + printf("bad MBR sector signature 0x%02x%02x\n", + buffer[DOS_PART_MAGIC_OFFSET], + buffer[DOS_PART_MAGIC_OFFSET + 1]); + return -EINVAL; + } + + pt = (struct dos_partition *) (buffer + DOS_PART_TBL_OFFSET); + int i; + for (i = 0; i < 4; i++, pt++) { + if (((pt->boot_ind & ~0x80) == 0) && + (pt->sys_ind != 0) && + (is_extended(pt->sys_ind) == 0)) { + add_partition(dev, le32_to_int(pt->start4), + le32_to_int(pt->size4), i+1); + } + if (is_extended(pt->sys_ind)) + extpt_sector = le32_to_int(pt->start4); + } + + if (extpt_sector == 0) + return 0; + + /* repeat once for extended partitions */ + if (blockdev_read(dev, extpt_sector, 1, buffer) != 1) { + printf("** Can't read extended partition table **\n"); + return -EINVAL; + } + + if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || + buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) { + printf("bad MBR sector signature 0x%02x%02x\n", + buffer[DOS_PART_MAGIC_OFFSET], + buffer[DOS_PART_MAGIC_OFFSET + 1]); + return -EINVAL; + } + + pt = (struct dos_partition *) (buffer + DOS_PART_TBL_OFFSET); + for (i = 0; i < 4; i++, pt++) { + if (((pt->boot_ind & ~0x80) == 0) && + (pt->sys_ind != 0) && + (is_extended(pt->sys_ind) == 0)) { + add_partition(dev, le32_to_int(pt->start4), + le32_to_int(pt->size4), i+5); + } + } + + return 0; +} +#endif diff --git a/drivers/blockdev/part_types/part_dos.h b/drivers/blockdev/part_types/part_dos.h new file mode 100644 index 0000000..98b0293 --- /dev/null +++ b/drivers/blockdev/part_types/part_dos.h @@ -0,0 +1,49 @@ +/* + * (C) Copyright 2000 + * Wolfgang Denk, DENX Software Engineering, wd@denx.de. + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#ifndef _DISK_PART_DOS_H +#define _DISK_PART_DOS_H + + +#define DOS_PART_TBL_OFFSET 0x1be +#define DOS_PART_MAGIC_OFFSET 0x1fe +#define DOS_PBR_FSTYPE_OFFSET 0x36 +#define DOS_PBR32_FSTYPE_OFFSET 0x52 +#define DOS_PBR_MEDIA_TYPE_OFFSET 0x15 +#define DOS_MBR 0 +#define DOS_PBR 1 + +struct dos_partition { + unsigned char boot_ind; /* 0x80 - active */ + unsigned char head; /* starting head */ + unsigned char sector; /* starting sector */ + unsigned char cyl; /* starting cylinder */ + unsigned char sys_ind; /* What partition type */ + unsigned char end_head; /* end head */ + unsigned char end_sector; /* end sector */ + unsigned char end_cyl; /* end cylinder */ + unsigned char start4[4]; /* starting sector counting from 0*/ + unsigned char size4[4]; /* nr of sectors in partition */ +}; + +#endif /* _DISK_PART_DOS_H */ diff --git a/drivers/blockdev/part_types/part_types.h b/drivers/blockdev/part_types/part_types.h new file mode 100644 index 0000000..d5e6f61 --- /dev/null +++ b/drivers/blockdev/part_types/part_types.h @@ -0,0 +1,34 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#ifndef _BLOCKDEV_PART_TYPES_H_ +#define _BLOCKDEV_PART_TYPES_H_ 1 + +#include <dm/structures.h> + +#ifdef CONFIG_DOS_PARTITION +int test_partitions_dos(struct instance *i); +int scan_partitions_dos(struct instance *i); +#endif + +#endif

This core provides unified access to different block controllers (SATA, SCSI).

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- Makefile | 1 + drivers/blockctrl/Makefile | 42 ++++++ drivers/blockctrl/core.c | 349 +++++++++++++++++++++++++++++++++++++++++++++ include/dm/blockctrl.h | 75 ++++++++++ 4 files changed, 467 insertions(+) create mode 100644 drivers/blockctrl/Makefile create mode 100644 drivers/blockctrl/core.c create mode 100644 include/dm/blockctrl.h

diff --git a/Makefile b/Makefile index e43fd9d..4420484 100644 --- a/Makefile +++ b/Makefile @@ -304,6 +304,7 @@ LIBS-y += test/libtest.o LIBS-$(CONFIG_DM) += common/dm/libdm.o LIBS-$(CONFIG_DM) += drivers/demo/libdemo.o LIBS-${CONFIG_DM_BLOCK} += drivers/blockdev/libblockdev.o +LIBS-${CONFIG_DM_BLOCK} += drivers/blockctrl/libblockctrl.o

ifneq ($(CONFIG_AM33XX)$(CONFIG_OMAP34XX)$(CONFIG_OMAP44XX)$(CONFIG_OMAP54XX),) LIBS-y += $(CPUDIR)/omap-common/libomap-common.o diff --git a/drivers/blockctrl/Makefile b/drivers/blockctrl/Makefile new file mode 100644 index 0000000..21a9094 --- /dev/null +++ b/drivers/blockctrl/Makefile @@ -0,0 +1,42 @@ +# See file CREDITS for list of people who contributed to this +# project. +# +# 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. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# + +include $(TOPDIR)/config.mk + +LIB := $(obj)libblockctrl.o + +COBJS-${CONFIG_DM_BLOCK} := core.o + +COBJS := $(COBJS-y) +SRCS := $(COBJS:.o=.c) +OBJS := $(addprefix $(obj),$(COBJS)) + +all: $(LIB) + +$(LIB): $(obj).depend $(OBJS) + $(call cmd_link_o_target, $(OBJS)) + +######################################################################### + +# defines $(obj).depend target +include $(SRCTREE)/rules.mk + +sinclude $(obj).depend + +######################################################################### diff --git a/drivers/blockctrl/core.c b/drivers/blockctrl/core.c new file mode 100644 index 0000000..1f1f834 --- /dev/null +++ b/drivers/blockctrl/core.c @@ -0,0 +1,349 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include <dm/blockctrl.h> +#include <dm/manager.h> +#include <malloc.h> + +struct blockctrl_core_entry { + struct list_head list; + struct instance *instance; + struct blockctrl_ops *ops; +}; + +static struct blockctrl_core_entry *get_entry_by_instance(struct instance *dev) +{ + struct blockctrl_core_entry *entry; + struct core_instance *core = get_core_instance(CORE_BLOCKCTRL); + + if (!core) + return NULL; + + list_for_each_entry(entry, &core->succ, list) { + if (entry->instance == dev) + return entry; + } + + return NULL; +} + +/* Core API functions */ +static int get_count(struct core_instance *core) +{ + int count = 0; + struct blockctrl_core_entry *entry; + + list_for_each_entry(entry, &core->succ, list) { + count++; + } + + return count; +} + +static struct instance *get_child(struct core_instance *core, int index) +{ + struct blockctrl_core_entry *entry = NULL; + + list_for_each_entry(entry, &core->succ, list) { + if (!index) + return entry->instance; + index--; + } + + return NULL; +} + +static int bind(struct core_instance *core, struct instance *dev, void *ops, + void *data) +{ + struct blockctrl_core_entry *entry; + + if (ops == NULL) + return -EINVAL; + + entry = malloc(sizeof(*entry)); + if (entry == NULL) + return -ENOMEM; + + INIT_LIST_HEAD(&entry->list); + entry->instance = dev; + entry->ops = ops; + list_add_tail(&entry->list, &core->succ); + + return 0; +} + +static int unbind(struct core_instance *core, struct instance *dev) +{ + struct blockctrl_core_entry *entry, *n; + + list_for_each_entry_safe(entry, n, &core->succ, list) { + if (entry->instance == dev) { + list_del(&entry->list); + free(entry); + } + } + + return 0; +} + +static int replace(struct core_instance *core, struct instance *new, + struct instance *old) +{ + struct blockctrl_core_entry *entry = get_entry_by_instance(old); + + if (!entry) + return -ENOENT; + + entry->instance = new; + + return 0; +} + +static int init(struct core_instance *core) +{ + INIT_LIST_HEAD(&core->succ); + core->private_data = NULL; + + return 0; +} + +static int reloc(struct core_instance *core, struct core_instance *old) +{ + struct blockctrl_core_entry *entry, *new; + + /* no private_data to copy, yet */ + + /* fixup links in old list and prepare new list head */ + /* FIXME */ + /* list_fix_reloc(&old->succ); */ + INIT_LIST_HEAD(&core->succ); + core->private_data = NULL; + + /* copy list entries to new memory */ + list_for_each_entry(entry, &old->succ, list) { + new = malloc(sizeof(*new)); + if (!new) + return -ENOMEM; + + INIT_LIST_HEAD(&new->list); + new->instance = entry->instance; + new->ops = entry->ops; + list_add_tail(&new->list, &core->succ); + /*no free at this point, old memory should not be freed*/ + } + + return 0; +} + +static int destroy(struct core_instance *core) +{ + struct blockctrl_core_entry *entry, *n; + + /* destroy private data */ + free(core->private_data); + core->private_data = NULL; + + /* destroy successor list */ + list_for_each_entry_safe(entry, n, &core->succ, list) { + list_del(&entry->list); + free(entry); + } + + return 0; +} + +U_BOOT_CORE(CORE_BLOCKCTRL, + init, + reloc, + destroy, + get_count, + get_child, + bind, + unbind, + replace); + +lbaint_t blockctrl_read(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer) +{ + struct blockctrl_core_entry *entry; + struct blockctrl_ops *driver_ops; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + driver_ops = entry->ops; + if (!driver_ops || !driver_ops->read) + return -EINVAL; + + return driver_ops->read(i, port, start, length, buffer); +} + +lbaint_t blockctrl_write(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer) +{ + struct blockctrl_core_entry *entry; + struct blockctrl_ops *driver_ops; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + driver_ops = entry->ops; + if (!driver_ops || !driver_ops->write) + return -EINVAL; + + return driver_ops->write(i, port, start, length, buffer); +} + +int blockctrl_scan(struct instance *i, int port) +{ + struct blockctrl_core_entry *entry; + struct blockctrl_ops *driver_ops; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + driver_ops = entry->ops; + if (!driver_ops || !driver_ops->scan) + return -EINVAL; + + return driver_ops->scan(i, port); +} + +int blockctrl_get_port_count(struct instance *i) +{ + struct blockctrl_core_entry *entry; + struct blockctrl_ops *driver_ops; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + driver_ops = entry->ops; + if (!driver_ops || !driver_ops->get_port_count) + return -EINVAL; + + return driver_ops->get_port_count(i); +} + +int blockctrl_get_port_option(struct instance *i, int port, + enum blockctrl_port_option_code op, struct option *result) +{ + struct blockctrl_core_entry *entry; + struct blockctrl_ops *driver_ops; + int error; + + entry = get_entry_by_instance(i); + if (!entry) + return -ENOENT; + + error = driver_activate(i); + if (error) + return error; + + driver_ops = entry->ops; + if (!driver_ops || !driver_ops->get_port_option) + return -EINVAL; + + return driver_ops->get_port_option(i, port, op, result); +} + +struct instance *blockctrl_rescan_port(struct instance *i, int port) +{ + /* we assume that all children of blockctrl are blockdev_ata */ + struct instance *child = NULL; + struct blockctrl_core_entry *entry; + struct driver_instance *di; + struct blockdev_ata_platform_data *pdata; + struct driver_info *info; + int nfound; + + entry = get_entry_by_instance(i); + if (!entry) + return NULL; + + list_for_each_entry(di, &i->succ, list) { + if (di->i.info) + pdata = di->i.info->platform_data; + else + pdata = NULL; + + if (pdata && (pdata->port_number == port)) + child = &di->i; + } + + /* + * If we have an active link, we check whether this is a new device, + * in which case we simply bind a new instance, or an old device, + * in which case we reactivate the device to force partition rescan. + * If we dont have an active link, we remove any device attached. + */ + nfound = blockctrl_scan(i, port); + if (!nfound) { + if (child) { + /* rescan the disk size and partitions, just in case */ + driver_remove(child); + scan_partitions(child); + } else { + pdata = malloc(sizeof(*pdata)); + pdata->port_number = port; + info = malloc(sizeof(*info)); + info->platform_data = pdata; + info->name = "blockdev_ata"; + child = driver_bind(i, info); + scan_partitions(child); + return child; + } + } else { + /* link is not active, remove and unbind the child device */ + if (child) { + driver_remove(child); + driver_unbind(child); + } + } + + return NULL; +} diff --git a/include/dm/blockctrl.h b/include/dm/blockctrl.h new file mode 100644 index 0000000..4b6d582 --- /dev/null +++ b/include/dm/blockctrl.h @@ -0,0 +1,75 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#ifndef _DM_BLOCKCTRL_H_ +#define _DM_BLOCKCTRL_H 1 + +#include <dm/structures.h> +#include <dm/blockdev.h> + +enum blockctrl_port_option_code { + BLKP_OPT_IFTYPE = 0, + BLKP_OPT_IFSPEED, + BLKP_OPT_BLOCKSIZE, + BLKP_OPT_BLOCKCOUNT, + BLKP_OPT_REMOVABLE, + BLKP_OPT_LBA48, + BLKP_OPT_VENDOR, + BLKP_OPT_PRODUCT, + BLKP_OPT_REVISION, +}; + +enum blockctrl_iftype { + BLKP_IFTYPE_SATA, + BLKP_IFTYPE_PATA, + BLKP_IFTYPE_SCSI, + BLKP_IFTYPE_VIRTUAL, +}; + + +struct blockctrl_ops { + lbaint_t (*read)(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer); + lbaint_t (*write)(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer); + int (*scan)(struct instance *i, int port); + int (*get_port_count)(struct instance *i); + int (*get_port_option)(struct instance *i, int port, + enum blockctrl_port_option_code op, + struct option *result); +}; + +/* driver wrappers */ +lbaint_t blockctrl_read(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer); +lbaint_t blockctrl_write(struct instance *i, int port, lbaint_t start, + lbaint_t length, void *buffer); +int blockctrl_scan(struct instance *i, int port); +int blockctrl_get_port_count(struct instance *i); +int blockctrl_get_port_option(struct instance *i, int port, + enum blockctrl_port_option_code op, struct option *result); + +/* command helpers */ +struct instance *blockctrl_rescan_port(struct instance *i, int port); + +#endif

ata blockdev is an universal child of a blockctrl device, be it (P/S)ATA or SCSI partition blockdev is a child of other blockdev drivers

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- drivers/blockdev/Makefile | 2 +- drivers/blockdev/ata.c | 234 +++++++++++++++++++++++++++++++++++++++++++ drivers/blockdev/ata.h | 37 +++++++ drivers/blockdev/partition.c | 179 +++++++++++++++++++++++++++++++++ 4 files changed, 451 insertions(+), 1 deletion(-) create mode 100644 drivers/blockdev/ata.c create mode 100644 drivers/blockdev/ata.h create mode 100644 drivers/blockdev/partition.c

diff --git a/drivers/blockdev/Makefile b/drivers/blockdev/Makefile index a988924..668ffbd 100644 --- a/drivers/blockdev/Makefile +++ b/drivers/blockdev/Makefile @@ -21,7 +21,7 @@ include $(TOPDIR)/config.mk

LIB := $(obj)libblockdev.o

-COBJS-${CONFIG_DM_BLOCK} := core.o +COBJS-${CONFIG_DM_BLOCK} := core.o ata.o partition.o COBJS-${CONFIG_DOS_PARTITION} += part_types/part_dos.o

COBJS := $(COBJS-y) diff --git a/drivers/blockdev/ata.c b/drivers/blockdev/ata.c new file mode 100644 index 0000000..698dc18 --- /dev/null +++ b/drivers/blockdev/ata.c @@ -0,0 +1,234 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include "ata.h" +#include <dm/blockctrl.h> +#include <dm/manager.h> +#include <common.h> +#include <malloc.h> + +static lbaint_t read(struct instance *dev, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + if (!buffer) + return 0; + + struct blockdev_ata_platform_data *platform = dev->info->platform_data; + struct blockdev_ata_private_data *priv = dev->private_data; + /* check for access beyond disk boundary */ + if ((start + blkcnt) > priv->block_count) + blkcnt = (priv->block_count - start); + + return blockctrl_read(dev->bus, platform->port_number, + start, blkcnt, buffer); +} + +static lbaint_t write(struct instance *dev, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + if (!buffer) + return 0; + + struct blockdev_ata_platform_data *platform = dev->info->platform_data; + struct blockdev_ata_private_data *priv = dev->private_data; + /* check for access beyond disk boundary */ + if ((start + blkcnt) > priv->block_count) + blkcnt = (priv->block_count - start); + + return blockctrl_write(dev->bus, platform->port_number, + start, blkcnt, buffer); +} + +static lbaint_t erase(struct instance *dev, lbaint_t start, lbaint_t blkcnt) +{ + /* TRIM is not supported on ATA, so we just pretend to do something */ + return blkcnt; +} + +static int get_option(struct instance *dev, enum blockdev_option_code op, + struct option *result) +{ + struct blockdev_ata_private_data *priv = dev->private_data; + struct blockdev_ata_platform_data *plat = dev->info->platform_data; + int port = plat->port_number; + + if (!result || !priv) + return -EINVAL; + + switch (op) { + case BLKD_OPT_IFTYPE: + result->flags = OPTION_TYPE_U; + result->data.data_u = BLOCKDEV_IFTYPE_ATA; + return 0; + case BLKD_OPT_TYPE: + result->flags = OPTION_TYPE_U; + result->data.data_u = BLOCKDEV_TYPE_HARDDISK; + return 0; + case BLKD_OPT_OFFSET: + result->flags = OPTION_TYPE_U; + result->data.data_u = 0; + return 0; + case BLKD_OPT_BLOCKSIZE: + result->flags = OPTION_TYPE_U; + result->data.data_u = priv->block_size; + return 0; + case BLKD_OPT_BLOCKCOUNT: + result->flags = OPTION_TYPE_U; + result->data.data_u = priv->block_count; + return 0; + case BLKD_OPT_VENDOR: + result->flags = OPTION_TYPE_S; + result->data.data_s = priv->vendor; + return 0; + case BLKD_OPT_PRODUCT: + result->flags = OPTION_TYPE_S; + result->data.data_s = priv->product; + return 0; + case BLKD_OPT_REVISION: + result->flags = OPTION_TYPE_S; + result->data.data_s = priv->revision; + return 0; + case BLKD_OPT_LBA48: + return blockctrl_get_port_option(dev->bus, port, + BLKP_OPT_LBA48, result); + default: + break; + /* TODO: more options */ + + } + return -EINVAL; +} + +static int set_option(struct instance *dev, enum blockdev_option_code op, + struct option *value) +{ + /* there are currently no meaningful options to set */ + return -EINVAL; +} + +static struct blockdev_ops ops = { + .read = read, + .write = write, + .erase = erase, + .get_option = get_option, + .set_option = set_option, +}; + + +static int bind(struct instance *dev) +{ + /* prepare hint for the core to properly identify this as a ATA disk */ + struct blockdev_core_hint hint = { + .iftype = BLOCKDEV_IFTYPE_ATA + }; + core_bind(CORE_BLOCKDEV, dev, &ops, &hint); + return 0; +} + +static int probe(struct instance *dev) +{ + struct option op; + struct blockdev_ata_private_data *priv; + int error; + struct blockdev_ata_platform_data *plat = dev->info->platform_data; + int port = plat->port_number; + + priv = calloc(sizeof(*priv), 1); + if (!priv) + return -ENOMEM; + + error = blockctrl_get_port_option(dev->bus, port, BLKP_OPT_BLOCKSIZE, + &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_U)) + return -EINVAL; + priv->block_size = op.data.data_u; + + error = blockctrl_get_port_option(dev->bus, port, BLKP_OPT_BLOCKCOUNT, + &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_U)) + return -EINVAL; + priv->block_count = op.data.data_u; + + error = blockctrl_get_port_option(dev->bus, port, BLKP_OPT_VENDOR, &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_S)) + return -EINVAL; + strncpy(priv->vendor, op.data.data_s, 40); + priv->vendor[40] = 0; + if (op.flags & OPTION_PTR_MALLOCED) + free(op.data.data_s); + + error = blockctrl_get_port_option(dev->bus, port, BLKP_OPT_PRODUCT, + &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_S)) + return -EINVAL; + strncpy(priv->product, op.data.data_s, 20); + priv->vendor[20] = 0; + if (op.flags & OPTION_PTR_MALLOCED) + free(op.data.data_s); + + error = blockctrl_get_port_option(dev->bus, port, BLKP_OPT_REVISION, + &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_S)) + return -EINVAL; + strncpy(priv->revision, op.data.data_s, 8); + priv->revision[8] = 0; + if (op.flags & OPTION_PTR_MALLOCED) + free(op.data.data_s); + + dev->private_data = priv; + + return 0; +} + +static int reloc(struct instance *dev, struct instance *old) +{ + core_replace(CORE_BLOCKDEV, dev, old); + dev->private_data = malloc(sizeof(struct blockdev_ata_private_data)); + if (!dev->private_data) + return -ENOMEM; + + memcpy(dev->private_data, old->private_data, + sizeof(struct blockdev_ata_private_data)); + + return 0; +} + +static int remove(struct instance *dev) +{ + /* remove our metadata cache */ + free(dev->private_data); + return 0; +} + +static int unbind(struct instance *dev) +{ + core_unbind(CORE_BLOCKDEV, dev); + return 0; +} + +U_BOOT_DRIVER(blockdev_ata, + bind, + probe, + reloc, + remove, + unbind); diff --git a/drivers/blockdev/ata.h b/drivers/blockdev/ata.h new file mode 100644 index 0000000..da63b5d --- /dev/null +++ b/drivers/blockdev/ata.h @@ -0,0 +1,37 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#ifndef _BLOCKDEV_ATA_H_ +#define _BLOCKDEV_ATA_H_ +#include <dm/blockdev.h> + +struct blockdev_ata_private_data { + /* cache for get_option() */ + lbaint_t block_size; + lbaint_t block_count; + char vendor[40+1]; + char product[20+1]; + char revision[8+1]; +}; + +#endif diff --git a/drivers/blockdev/partition.c b/drivers/blockdev/partition.c new file mode 100644 index 0000000..c5c0f48 --- /dev/null +++ b/drivers/blockdev/partition.c @@ -0,0 +1,179 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include <dm/blockdev.h> +#include <dm/manager.h> + +static lbaint_t read(struct instance *dev, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + if (!buffer) + return 0; + + struct blockdev_partition_platform_data *platform = + dev->info->platform_data; + /* check for access beyond partition boundary */ + if ((start + blkcnt) > platform->block_count) + blkcnt = (platform->block_count - start); + + start += platform->offset; + + return blockdev_read(dev->bus, start, blkcnt, buffer); +} + +static lbaint_t write(struct instance *dev, lbaint_t start, lbaint_t blkcnt, + void *buffer) +{ + if (!buffer) + return 0; + + struct blockdev_partition_platform_data *platform = + dev->info->platform_data; + /* check for access beyond partition boundary */ + if ((start + blkcnt) > platform->block_count) + blkcnt = (platform->block_count - start); + + start += platform->offset; + + return blockdev_write(dev->bus, start, blkcnt, buffer); +} + +static lbaint_t erase(struct instance *dev, lbaint_t start, lbaint_t blkcnt) +{ + struct blockdev_partition_platform_data *platform = + dev->info->platform_data; + /* check for access beyond partition boundary */ + if ((start + blkcnt) > platform->block_count) + blkcnt = (platform->block_count - start); + + start += platform->offset; + + return blockdev_erase(dev->bus, start, blkcnt); +} + +static int get_option(struct instance *dev, enum blockdev_option_code op, + struct option *result) +{ + if (!result) + return -EINVAL; + + struct blockdev_partition_platform_data *platform = + dev->info->platform_data; + + switch (op) { + case BLKD_OPT_TYPE: + result->flags = OPTION_TYPE_U; + result->data.data_u = BLOCKDEV_TYPE_PARTITION; + return 0; + case BLKD_OPT_BLOCKCOUNT: + result->flags = OPTION_TYPE_U; + result->data.data_u = platform->block_count; + return 0; + case BLKD_OPT_OFFSET: + result->flags = OPTION_TYPE_U; + result->data.data_u = platform->offset; + return 0; + case BLKD_OPT_IFTYPE: + case BLKD_OPT_BLOCKSIZE: + case BLKD_OPT_REMOVABLE: + case BLKD_OPT_LBA48: + case BLKD_OPT_VENDOR: + case BLKD_OPT_PRODUCT: + case BLKD_OPT_REVISION: + case BLKD_OPT_SCSILUN: + case BLKD_OPT_SCSITARGET: + return blockdev_get_option(dev->bus, op, result); + + default: + break; + } + + return -EINVAL; +} + + +static int set_option(struct instance *dev, enum blockdev_option_code op, + struct option *value) +{ + /* there are currently no meaningful options to set */ + return -EINVAL; +} + +static struct blockdev_ops ops = { + .read = read, + .write = write, + .erase = erase, + .get_option = get_option, + .set_option = set_option +}; + + +static int bind(struct instance *dev) +{ + /* prepare hint for the core to properly identify this as a partition */ + struct blockdev_partition_platform_data *platform = + dev->info->platform_data; + + struct blockdev_core_hint hint = { + .iftype = BLOCKDEV_IFTYPE_PARTITION, + .part_number = platform->part_number + }; + core_bind(CORE_BLOCKDEV, dev, &ops, &hint); + + return 0; +} + +static int probe(struct instance *dev) +{ + /* there is nothing to activate */ + return 0; +} + +static int reloc(struct instance *dev, struct instance *old) +{ + core_replace(CORE_BLOCKDEV, dev, old); + /* there are no private data to relocate */ + + return 0; +} + +static int remove(struct instance *dev) +{ + /* nothing to do here */ + return 0; +} + +static int unbind(struct instance *dev) +{ + core_unbind(CORE_BLOCKDEV, dev); + + return 0; +} + + +U_BOOT_DRIVER(blockdev_partition, + bind, + probe, + reloc, + remove, + unbind);

cmd_fatdm.c is a copy of cmd_fat.c with just trivaial changes, but those touch large portion of the lines due to different number of parameters (old API has a separate parameter for interface and for disk number, new API has this as one)

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- common/Makefile | 4 ++ common/cmd_fatdm.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/fat/Makefile | 7 +- fs/fat/dev_dm.c | 141 +++++++++++++++++++++++++++++++++++++++ include/fat.h | 8 +++ 5 files changed, 351 insertions(+), 1 deletion(-) create mode 100644 common/cmd_fatdm.c create mode 100644 fs/fat/dev_dm.c

diff --git a/common/Makefile b/common/Makefile index aa09f17..29e5798 100644 --- a/common/Makefile +++ b/common/Makefile @@ -88,7 +88,11 @@ COBJS-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o COBJS-$(CONFIG_CMD_ELF) += cmd_elf.o COBJS-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o COBJS-$(CONFIG_CMD_EXT2) += cmd_ext2.o +ifdef CONFIG_DM +COBJS-$(CONFIG_CMD_FAT) += cmd_fatdm.o +else COBJS-$(CONFIG_CMD_FAT) += cmd_fat.o +endif COBJS-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o COBJS-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o COBJS-$(CONFIG_CMD_FDOS) += cmd_fdos.o diff --git a/common/cmd_fatdm.c b/common/cmd_fatdm.c new file mode 100644 index 0000000..d91c53f --- /dev/null +++ b/common/cmd_fatdm.c @@ -0,0 +1,192 @@ +/* + * (C) Copyright 2002 + * Richard Jones, rjones@nexus-tech.net + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +/* + * Boot support + */ +#include <common.h> +#include <command.h> +#include <s_record.h> +#include <net.h> +#include <ata.h> +#include <part.h> +#include <fat.h> +#include <dm/structures.h> +#include <dm/blockdev.h> + +int do_fat_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + long size; + unsigned long offset; + unsigned long count; + char buf[12]; + struct instance *bdev; + + if (argc < 4) + return CMD_RET_USAGE; + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + puts("\n** Invalid boot device **\n"); + return -EINVAL; + } + if (fat_register_device(bdev)) { + printf("\n** Unable to use %s for fatload **\n", argv[1]); + return -EINVAL; + } + offset = simple_strtoul(argv[2], NULL, 16); + if (argc == 5) + count = simple_strtoul(argv[5], NULL, 16); + else + count = 0; + size = file_fat_read(argv[3], (unsigned char *)offset, count); + + if (size == -1) { + printf("\n** Unable to read "%s" from %s **\n", + argv[3], argv[1]); + return -EIO; + } + + printf("\n%ld bytes read\n", size); + + sprintf(buf, "%lX", size); + setenv("filesize", buf); + + return 0; +} + + +U_BOOT_CMD( + fatload, 6, 0, do_fat_fsload, + "load binary file from a dos filesystem", + "<dev[:part]> <addr> <filename> [bytes]\n" + " - load binary file 'filename' from 'dev'\n" + " to address 'addr' from dos filesystem" +); + +int do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + char *filename = "/"; + int ret; + struct instance *bdev; + + if (argc < 2) + return CMD_RET_USAGE; + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + puts("\n** Invalid boot device **\n"); + return -EINVAL; + } + if (fat_register_device(bdev)) { + printf("\n** Unable to use %s for fatls **\n", argv[1]); + return -EINVAL; + } + if (argc == 3) + ret = file_fat_ls(argv[2]); + else + ret = file_fat_ls(filename); + + if (ret != 0) + printf("No Fat FS detected\n"); + return ret; +} + +U_BOOT_CMD( + fatls, 3, 1, do_fat_ls, + "list files in a directory (default /)", + "<dev[:part]> [directory]\n" + " - list files from 'dev' in a 'directory'" +); + +int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + struct instance *bdev; + + if (argc < 2) + return CMD_RET_USAGE; + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + puts("\n** Invalid boot device **\n"); + return -EINVAL; + } + if (fat_register_device(bdev)) { + printf("\n** Unable to use %s for fatinfo **\n", argv[1]); + return -EIO; + } + return file_fat_detectfs(); +} + +U_BOOT_CMD( + fatinfo, 2, 1, do_fat_fsinfo, + "print information about filesystem", + "<dev[:part]>\n" + " - print information about filesystem from 'dev' on 'interface'" +); + +#ifdef CONFIG_FAT_WRITE +static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag, + int argc, char * const argv[]) +{ + long size; + unsigned long addr; + unsigned long count; + struct instance *bdev; + + if (argc < 4) + return CMD_RET_USAGE; + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + puts("\n** Invalid boot device **\n"); + return 1; + } + if (fat_register_device(bdev)) { + printf("\n** Unable to use %s for fatwrite **\n", + argv[1]); + return 1; + } + addr = simple_strtoul(argv[2], NULL, 16); + count = simple_strtoul(argv[4], NULL, 16); + + size = file_fat_write(argv[3], (void *)addr, count); + if (size == -1) { + printf("\n** Unable to write "%s" to %s **\n", + argv[3], argv[1]); + return 1; + } + + printf("%ld bytes written\n", size); + + return 0; +} + +U_BOOT_CMD( + fatwrite, 6, 0, do_fat_fswrite, + "write file into a dos filesystem", + "<dev[:part]> <addr> <filename> <bytes>\n" + " - write file 'filename' from the address 'addr' in RAM\n" + " to 'dev' on 'interface'" +); +#endif diff --git a/fs/fat/Makefile b/fs/fat/Makefile index 176e6f4..f85480c 100644 --- a/fs/fat/Makefile +++ b/fs/fat/Makefile @@ -24,8 +24,13 @@ include $(TOPDIR)/config.mk LIB = $(obj)libfat.o

AOBJS = -COBJS-$(CONFIG_CMD_FAT) := fat.o dev.o +COBJS-$(CONFIG_CMD_FAT) := fat.o COBJS-$(CONFIG_FAT_WRITE) := fat_write.o +ifdef CONFIG_DM +COBJS-$(CONFIG_CMD_FAT) += dev_dm.o +else +COBJS-$(CONFIG_CMD_FAT) += dev.o +endif

ifndef CONFIG_SPL_BUILD COBJS-$(CONFIG_CMD_FAT) += file.o diff --git a/fs/fat/dev_dm.c b/fs/fat/dev_dm.c new file mode 100644 index 0000000..3f66e54 --- /dev/null +++ b/fs/fat/dev_dm.c @@ -0,0 +1,141 @@ +/* + * (C) Copyright 2012 + * Pavel Herrmann morpheus.ibis@gmail.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include <dm/structures.h> +#include <dm/blockdev.h> +#include <fat.h> +#include <errno.h> + +static struct instance *bdev; + +#define DOS_BOOT_MAGIC_OFFSET 0x1fe +#define DOS_FS_TYPE_OFFSET 0x36 +#define DOS_FS32_TYPE_OFFSET 0x52 + +int fat_disk_read(__u32 block, __u32 nr_blocks, void *buf) +{ + if (!bdev) + return -1; + + return blockdev_read(bdev, block, nr_blocks, buf); +} + +int fat_disk_write(__u32 block, __u32 nr_blocks, void *buf) +{ + if (!bdev) + return -1; + + return blockdev_write(bdev, block, nr_blocks, buf); +} + +int fat_get_blksz(void) +{ + struct option op; + int error; + + error = blockdev_get_option(bdev, BLKD_OPT_BLOCKSIZE, &op); + if ((error) || (OPTION_TYPE(op) != OPTION_TYPE_U)) + return -EINVAL; + + return op.data.data_u; +} + +int fat_get_partsize(void) +{ + struct option op; + int error; + + error = blockdev_get_option(bdev, BLKD_OPT_BLOCKCOUNT, &op); + if ((error) || (OPTION_TYPE(op) != OPTION_TYPE_U)) + return -EINVAL; + + return op.data.data_u; +} + +int fat_register_device(struct instance *dev) +{ + int blksz; + + if (!dev) + return -EINVAL; + + bdev = dev; + blksz = fat_get_blksz(); + if (blksz < 0) { + /*this should not happen, lets just warn and guess */ + printf("Error reading device block size!!!\nGuessing 512\n"); + blksz = 512; + } + ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, blksz); + + /* Make sure it has a valid FAT header */ + if (fat_disk_read(0, 1, buffer) != 1) { + bdev = NULL; + return -EIO; + } + + /* Check if it's actually a DOS volume */ + if (memcmp(buffer + DOS_BOOT_MAGIC_OFFSET, "\x55\xAA", 2)) { + bdev = NULL; + return -ENOENT; + } + + /* Check for FAT12/FAT16/FAT32 filesystem */ + if (!memcmp(buffer + DOS_FS_TYPE_OFFSET, "FAT", 3)) + return 0; + if (!memcmp(buffer + DOS_FS32_TYPE_OFFSET, "FAT32", 5)) + return 0; + + bdev = NULL; + return -EINVAL; + +} + +int file_fat_detectfs(void) +{ + boot_sector bs; + volume_info volinfo; + int fatsize; + char vol_label[12]; + + if (!bdev) { + printf("No current device\n"); + return -EINVAL; + } + + print_blockdev_info(bdev); + + if (fat_read_bootsectandvi(&bs, &volinfo, &fatsize)) { + printf("\nNo valid FAT fs found\n"); + return -EINVAL; + } + + memcpy(vol_label, volinfo.volume_label, 11); + vol_label[11] = '\0'; + volinfo.fs_type[5] = '\0'; + + printf("Filesystem: %s "%s"\n", volinfo.fs_type, vol_label); + + return 0; +} + diff --git a/include/fat.h b/include/fat.h index 98f77a5..85f2f0b 100644 --- a/include/fat.h +++ b/include/fat.h @@ -29,6 +29,10 @@

#include <asm/byteorder.h>

+#ifdef CONFIG_DM +#include <dm/structures.h> +#endif + #define CONFIG_SUPPORT_VFAT /* Maximum Long File Name length supported here is 128 UTF-16 code units */ #define VFAT_MAXLEN_BYTES 256 /* Maximum LFN buffer in bytes */ @@ -210,7 +214,11 @@ int file_fat_detectfs(void); int file_fat_ls(const char *dir); long file_fat_read(const char *filename, void *buffer, unsigned long maxsize); const char *file_getfsname(int idx); +#ifdef CONFIG_DM +int fat_register_device(struct instance *dev); +#else int fat_register_device(block_dev_desc_t *dev_desc, int part_no); +#endif

int file_fat_write(const char *filename, void *buffer, unsigned long maxsize);

cmd_reiserdm.c is a copy of cmd_reiser.c with just trivial changes, but those touch large portion of the lines due to different number of parameters (old API has a separate parameter for interface and for disk number, new API has this as one)

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- common/Makefile | 4 ++ common/cmd_reiserdm.c | 193 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/reiserfs/Makefile | 8 ++- fs/reiserfs/dev_dm.c | 104 +++++++++++++++++++++++++++ include/reiserfs.h | 8 ++- 5 files changed, 315 insertions(+), 2 deletions(-) create mode 100644 common/cmd_reiserdm.c create mode 100644 fs/reiserfs/dev_dm.c

diff --git a/common/Makefile b/common/Makefile index 22f9234..d83c66e 100644 --- a/common/Makefile +++ b/common/Makefile @@ -142,7 +142,11 @@ COBJS-y += cmd_pcmcia.o COBJS-$(CONFIG_CMD_PORTIO) += cmd_portio.o COBJS-$(CONFIG_CMD_PXE) += cmd_pxe.o COBJS-$(CONFIG_CMD_REGINFO) += cmd_reginfo.o +ifdef CONFIG_DM +COBJS-$(CONFIG_CMD_REISER) += cmd_reiserdm.o +else COBJS-$(CONFIG_CMD_REISER) += cmd_reiser.o +endif COBJS-$(CONFIG_CMD_SATA) += cmd_sata.o COBJS-$(CONFIG_CMD_SF) += cmd_sf.o COBJS-$(CONFIG_CMD_SCSI) += cmd_scsi.o diff --git a/common/cmd_reiserdm.c b/common/cmd_reiserdm.c new file mode 100644 index 0000000..ed16563 --- /dev/null +++ b/common/cmd_reiserdm.c @@ -0,0 +1,193 @@ +/* + * (C) Copyright 2003 - 2004 + * Sysgo Real-Time Solutions, AG <www.elinos.com> + * Pavel Bartusek pba@sysgo.com + * + * See file CREDITS for list of people who contributed to this + * project. + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + */ + +/* + * Reiserfs support + */ +#include <common.h> +#include <config.h> +#include <command.h> +#include <image.h> +#include <linux/ctype.h> +#include <asm/byteorder.h> +#include <reiserfs.h> +#include <dm/structures.h> +#include <dm/blockdev.h> + +/* #define REISER_DEBUG */ + +#ifdef REISER_DEBUG +#define PRINTF(fmt, args...) printf(fmt, ##args) +#else +#define PRINTF(fmt, args...) +#endif + +int do_reiserls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + char *filename = "/"; + int part_length; + struct instance *bdev; + + if (argc < 2) + return CMD_RET_USAGE; + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + printf("\n** Block device %s not supported\n", argv[1]); + return 1; + } + + if (argc == 3) + filename = argv[2]; + + PRINTF("Using device %s, directory: %s\n", argv[1], filename); + + part_length = reiserfs_set_blk_dev(bdev); + if (part_length == 0) { + printf("** Bad partition - %s **\n", argv[1]); + return 1; + } + + if (!reiserfs_mount(part_length)) { + printf("** Bad Reiserfs partition or disk - %s **\n", argv[1]); + return 1; + } + + if (reiserfs_ls(filename)) { + printf("** Error reiserfs_ls() **\n"); + return 1; + }; + + return 0; +} + +U_BOOT_CMD( + reiserls, 3, 1, do_reiserls, + "list files in a directory (default /)", + "<dev[:part]> [directory]\n" + " - list files from 'dev' on 'interface' in a 'directory'" +); + +/****************************************************************************** + * Reiserfs boot command intepreter. Derived from diskboot + */ +int do_reiserload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +{ + char *filename = NULL; + ulong addr = 0, part_length, filelen; + char buf[12]; + unsigned long count; + char *addr_str; + struct instance *bdev; + + switch (argc) { + case 2: + addr_str = getenv("loadaddr"); + if (addr_str != NULL) + addr = simple_strtoul(addr_str, NULL, 16); + else + addr = CONFIG_SYS_LOAD_ADDR; + filename = getenv("bootfile"); + count = 0; + break; + case 3: + addr = simple_strtoul(argv[2], NULL, 16); + filename = getenv("bootfile"); + count = 0; + break; + case 4: + addr = simple_strtoul(argv[2], NULL, 16); + filename = argv[3]; + count = 0; + break; + case 5: + addr = simple_strtoul(argv[2], NULL, 16); + filename = argv[3]; + count = simple_strtoul(argv[4], NULL, 16); + break; + + default: + return CMD_RET_USAGE; + } + + if (!filename) { + puts("\n** No boot file defined **\n"); + return 1; + } + + bdev = get_blockdev_by_name(argv[1]); + if (!bdev) { + printf("\n** Block device %s not supported\n", argv[1]); + return 1; + } + + PRINTF("Using device %s\n", argv[1]); + + PRINTF("\nLoading from block device %s, File:%s\n", + argv[1], filename); + + + part_length = reiserfs_set_blk_dev(bdev); + if (part_length == 0) { + printf("** Bad partition - %s **\n", argv[1]); + return 1; + } + + if (!reiserfs_mount(part_length)) { + printf("** Bad Reiserfs partition or disk - %s **\n", argv[1]); + return 1; + } + + filelen = reiserfs_open(filename); + if (filelen < 0) { + printf("** File not found %s\n", filename); + return 1; + } + if ((count < filelen) && (count != 0)) + filelen = count; + + if (reiserfs_read((char *)addr, filelen) != filelen) { + printf("\n** Unable to read "%s" from %s **\n", filename, + argv[1]); + return 1; + } + + /* Loading ok, update default load address */ + load_addr = addr; + + printf("\n%ld bytes read\n", filelen); + sprintf(buf, "%lX", filelen); + setenv("filesize", buf); + + return filelen; +} + +U_BOOT_CMD( + reiserload, 5, 0, do_reiserload, + "load binary file from a Reiser filesystem", + "<dev[:part]> [addr] [filename] [bytes]\n" + " - load binary file 'filename' from 'dev' on 'interface'\n" + " to address 'addr' from dos filesystem" +); diff --git a/fs/reiserfs/Makefile b/fs/reiserfs/Makefile index 495759c..bb30101 100644 --- a/fs/reiserfs/Makefile +++ b/fs/reiserfs/Makefile @@ -30,7 +30,13 @@ include $(TOPDIR)/config.mk LIB = $(obj)libreiserfs.o

AOBJS = -COBJS-$(CONFIG_CMD_REISER) := reiserfs.o dev.o mode_string.o +COBJS-$(CONFIG_CMD_REISER) := reiserfs.o mode_string.o + +ifdef CONFIG_DM +COBJS-${CONFIG_CMD_REISER} += dev_dm.o +else +COBJS-${CONFIG_CMD_REISER} += dev.o +endif

SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) diff --git a/fs/reiserfs/dev_dm.c b/fs/reiserfs/dev_dm.c new file mode 100644 index 0000000..4dad499 --- /dev/null +++ b/fs/reiserfs/dev_dm.c @@ -0,0 +1,104 @@ +/* + * (C) Copyright 2003 - 2004 + * Sysgo AG, <www.elinos.com>, Pavel Bartusek pba@sysgo.com + * + * 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include <common.h> +#include <config.h> +#include <reiserfs.h> + +#include "reiserfs_private.h" + +#include <dm/structures.h> +#include <dm/blockdev.h> + +static struct instance *bdev; + +int reiserfs_set_blk_dev(struct instance *dev) +{ + struct option op; + int error; + + if (!dev) + return 0; + + error = blockdev_get_option(dev, BLKD_OPT_BLOCKCOUNT, &op); + if (error || (OPTION_TYPE(op) != OPTION_TYPE_U)) + return 0; + bdev = dev; + + return op.data.data_u; +} + + +int reiserfs_devread(int sector, int byte_offset, int byte_len, char *buf) +{ + char sec_buf[SECTOR_SIZE]; + unsigned block_len; + + /* + * Get the read to the beginning of a partition. + */ + sector += byte_offset >> SECTOR_BITS; + byte_offset &= SECTOR_SIZE - 1; + +#if defined(DEBUG) + printf(" <%d, %d, %d> ", sector, byte_offset, byte_len); +#endif + + + if (!bdev) + return 0; + + + if (byte_offset != 0) { + /* read first part which isn't aligned with start of sector */ + if (blockdev_read(bdev, sector, 1, sec_buf) != 1) { + printf(" ** reiserfs_devread() read error\n"); + return 0; + } + memcpy(buf, sec_buf+byte_offset, + min(SECTOR_SIZE-byte_offset, byte_len)); + buf += min(SECTOR_SIZE-byte_offset, byte_len); + byte_len -= min(SECTOR_SIZE-byte_offset, byte_len); + sector++; + } + + /* read sector aligned part */ + block_len = byte_len & ~(SECTOR_SIZE-1); + if (blockdev_read(bdev, sector, block_len / SECTOR_SIZE, buf) != + block_len / SECTOR_SIZE) { + printf(" ** reiserfs_devread() read error - block\n"); + return 0; + } + buf += block_len; + byte_len -= block_len; + sector += block_len/SECTOR_SIZE; + + if (byte_len != 0) { + /* read rest of data which are not in whole sector */ + if (blockdev_read(bdev, sector, 1, sec_buf) != 1) { + printf(" ** reiserfs_devread() read error - " + "last part\n"); + return 0; + } + memcpy(buf, sec_buf, byte_len); + } + + return 1; +} diff --git a/include/reiserfs.h b/include/reiserfs.h index c465b3c..e0ce2c1 100644 --- a/include/reiserfs.h +++ b/include/reiserfs.h @@ -27,6 +27,9 @@ * from the original reiser fs code, as found in the linux kernel. */

+#ifdef CONFIG_DM +#include <dm/structures.h> +#endif

#define SECTOR_SIZE 0x200 #define SECTOR_BITS 9 @@ -74,8 +77,11 @@ typedef enum MAX_ERR_NUM } reiserfs_error_t;

- +#ifdef CONFIG_DM +extern int reiserfs_set_blk_dev(struct instance *bdev); +#else extern int reiserfs_set_blk_dev(block_dev_desc_t *rbdd, int part); +#endif extern int reiserfs_ls (char *dirname); extern int reiserfs_open (char *filename); extern int reiserfs_read (char *buf, unsigned len);

add CONFIG_DM_BLOCK to include/configs/sandbox.h to enable it all

Signed-off-by: Pavel Herrmann morpheus.ibis@gmail.com --- arch/sandbox/lib/board.c | 8 ++++++++ include/configs/sandbox.h | 4 ++++ 2 files changed, 12 insertions(+)

diff --git a/arch/sandbox/lib/board.c b/arch/sandbox/lib/board.c index c79cc62..a6fc67d 100644 --- a/arch/sandbox/lib/board.c +++ b/arch/sandbox/lib/board.c @@ -243,6 +243,10 @@ void board_init_r(gd_t *id, ulong dest_addr) .name = "gpio_sandbox", .platform_data = NULL }; + static const struct driver_info sata_info = { + .name = "sata_legacy", + .platform_data = NULL + };

struct instance *root = get_root_instance(); struct instance *demo1, *demo2, *demo3; @@ -254,8 +258,12 @@ void board_init_r(gd_t *id, ulong dest_addr) demo3 = driver_bind(demo2, &info); driver_bind(demo2, &info); driver_bind(root, &gs_info); + driver_bind(root, &sata_info);

demo_hello(demo2); + void *startram = os_malloc(1024*1024*16); + void *endram = startram + (1024*1024*16); + printf("scratch memory from %p to %p\n", startram, endram);

/* initialize environment */ env_relocate(); diff --git a/include/configs/sandbox.h b/include/configs/sandbox.h index a713430..70ae37b 100644 --- a/include/configs/sandbox.h +++ b/include/configs/sandbox.h @@ -99,6 +99,10 @@ #define CONFIG_SYS_SATA_MAX_DEVICE 2 #define CONFIG_DOS_PARTITION #define CONFIG_CMD_FAT +#define CONFIG_FAT_WRITE #define CONFIG_CMD_EXT2

+#define CONFIG_DM_BLOCK +#define CONFIG_BLOCK_SATA_LEGACY + #endif