diff options
Diffstat (limited to '')
| -rw-r--r-- | flashutils/Android.mk | 157 | ||||
| -rw-r--r-- | flashutils/dump_image.c | 150 | ||||
| -rw-r--r-- | flashutils/erase_image.c | 103 | ||||
| -rw-r--r-- | flashutils/flash_image.c | 155 | ||||
| -rw-r--r-- | flashutils/flashutils.c | 156 | ||||
| -rw-r--r-- | flashutils/flashutils.h | 50 |
6 files changed, 771 insertions, 0 deletions
diff --git a/flashutils/Android.mk b/flashutils/Android.mk new file mode 100644 index 000000000..449beccd4 --- /dev/null +++ b/flashutils/Android.mk @@ -0,0 +1,157 @@ +LOCAL_PATH := $(call my-dir) + +ifneq ($(TARGET_SIMULATOR),true) +ifeq ($(TARGET_ARCH),arm) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := flashutils.c +LOCAL_MODULE := libflashutils +LOCAL_MODULE_TAGS := optional +LOCAL_C_INCLUDES += bootable/recovery +LOCAL_STATIC_LIBRARIES := libmmcutils libmtdutils libbmlutils libcrecovery + +BOARD_RECOVERY_DEFINES := BOARD_BML_BOOT BOARD_BML_RECOVERY + +$(foreach board_define,$(BOARD_RECOVERY_DEFINES), \ + $(if $($(board_define)), \ + $(eval LOCAL_CFLAGS += -D$(board_define)=\"$($(board_define))\") \ + ) \ + ) + +include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := flash_image.c +LOCAL_MODULE := flash_image +LOCAL_MODULE_TAGS := optional +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcrecovery +LOCAL_SHARED_LIBRARIES := libcutils libc +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := dump_image.c +LOCAL_MODULE := dump_image +LOCAL_MODULE_TAGS := optional +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcrecovery +LOCAL_SHARED_LIBRARIES := libcutils libc +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := erase_image.c +LOCAL_MODULE := erase_image +LOCAL_MODULE_TAGS := optional +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcrecovery +LOCAL_SHARED_LIBRARIES := libcutils libc +include $(BUILD_EXECUTABLE) + +ALL_DEFAULT_INSTALLED_MODULES += $(addprefix $(TARGET_OUT)/bin/, flash_image dump_image erase_image) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := flash_image.c +LOCAL_MODULE := libflash_image +LOCAL_MODULE_TAGS := optional +LOCAL_CFLAGS += -Dmain=flash_image_main +include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := dump_image.c +LOCAL_MODULE := libdump_image +LOCAL_MODULE_TAGS := optional +LOCAL_CFLAGS += -Dmain=dump_image_main +include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := erase_image.c +LOCAL_MODULE := liberase_image +LOCAL_MODULE_TAGS := optional +LOCAL_CFLAGS += -Dmain=erase_image_main +include $(BUILD_STATIC_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := dump_image.c +LOCAL_MODULE := utility_dump_image +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := UTILITY_EXECUTABLES +LOCAL_MODULE_PATH := $(PRODUCT_OUT)/utilities +LOCAL_UNSTRIPPED_PATH := $(PRODUCT_OUT)/symbols/utilities +LOCAL_MODULE_STEM := dump_image +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcutils libc +LOCAL_FORCE_STATIC_EXECUTABLE := true +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := flash_image.c +LOCAL_MODULE := utility_flash_image +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := UTILITY_EXECUTABLES +LOCAL_MODULE_PATH := $(PRODUCT_OUT)/utilities +LOCAL_UNSTRIPPED_PATH := $(PRODUCT_OUT)/symbols/utilities +LOCAL_MODULE_STEM := flash_image +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcutils libc +LOCAL_FORCE_STATIC_EXECUTABLE := true +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := erase_image.c +LOCAL_MODULE := utility_erase_image +LOCAL_MODULE_TAGS := optional +LOCAL_MODULE_CLASS := UTILITY_EXECUTABLES +LOCAL_MODULE_PATH := $(PRODUCT_OUT)/utilities +LOCAL_UNSTRIPPED_PATH := $(PRODUCT_OUT)/symbols/utilities +LOCAL_MODULE_STEM := erase_image +LOCAL_STATIC_LIBRARIES := libflashutils libmtdutils libmmcutils libbmlutils libcutils libc +LOCAL_FORCE_STATIC_EXECUTABLE := true +include $(BUILD_EXECUTABLE) + +#Added for dynamic building for TWRP: + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := flashutils.c +LOCAL_MODULE := libflashutils +LOCAL_MODULE_TAGS := eng +LOCAL_C_INCLUDES += bootable/recovery +LOCAL_SHARED_LIBRARIES := libc libmmcutils libbmlutils +LOCAL_STATIC_LIBRARIES := libmtdutils + +BOARD_RECOVERY_DEFINES := BOARD_BML_BOOT BOARD_BML_RECOVERY + +$(foreach board_define,$(BOARD_RECOVERY_DEFINES), \ + $(if $($(board_define)), \ + $(eval LOCAL_CFLAGS += -D$(board_define)=\"$($(board_define))\") \ + ) \ + ) + +include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE := flash_image +LOCAL_MODULE_TAGS := eng +LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES +LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin +LOCAL_SRC_FILES := flash_image.c +LOCAL_SHARED_LIBRARIES := libflashutils libmmcutils libbmlutils libcutils libc +LOCAL_STATIC_LIBRARIES := libmtdutils +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_MODULE := dump_image +LOCAL_MODULE_TAGS := eng +LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES +LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin +LOCAL_SRC_FILES := dump_image.c +LOCAL_SHARED_LIBRARIES := libflashutils libmmcutils libbmlutils libcutils libc +LOCAL_STATIC_LIBRARIES := libmtdutils +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_MODULE := erase_image +LOCAL_MODULE_TAGS := eng +LOCAL_MODULE_CLASS := RECOVERY_EXECUTABLES +LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin +LOCAL_SRC_FILES := erase_image.c +LOCAL_SHARED_LIBRARIES := libflashutils libmmcutils libbmlutils libcutils libc +LOCAL_STATIC_LIBRARIES := libmtdutils +include $(BUILD_EXECUTABLE) + +endif # TARGET_ARCH == arm +endif # !TARGET_SIMULATOR diff --git a/flashutils/dump_image.c b/flashutils/dump_image.c new file mode 100644 index 000000000..64c4e1c42 --- /dev/null +++ b/flashutils/dump_image.c @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/ioctl.h> + +#include "cutils/log.h" +#include "flashutils.h" + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + +#if 0 + +#define LOG_TAG "dump_image" + +#define BLOCK_SIZE 2048 +#define SPARE_SIZE (BLOCK_SIZE >> 5) + +static int die(const char *msg, ...) { + int err = errno; + va_list args; + va_start(args, msg); + char buf[1024]; + vsnprintf(buf, sizeof(buf), msg, args); + va_end(args); + + if (err != 0) { + strlcat(buf, ": ", sizeof(buf)); + strlcat(buf, strerror(err), sizeof(buf)); + } + + fprintf(stderr, "%s\n", buf); + return 1; +} + +/* Read a flash partition and write it to an image file. */ + +int dump_image(char* partition_name, char* filename, dump_image_callback callback) { + MtdReadContext *in; + const MtdPartition *partition; + char buf[BLOCK_SIZE + SPARE_SIZE]; + size_t partition_size; + size_t read_size; + size_t total; + int fd; + int wrote; + int len; + + if (mtd_scan_partitions() <= 0) + return die("error scanning partitions"); + + partition = mtd_find_partition_by_name(partition_name); + if (partition == NULL) + return die("can't find %s partition", partition_name); + + if (mtd_partition_info(partition, &partition_size, NULL, NULL)) { + return die("can't get info of partition %s", partition_name); + } + + if (!strcmp(filename, "-")) { + fd = fileno(stdout); + } + else { + fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666); + } + + if (fd < 0) + return die("error opening %s", filename); + + in = mtd_read_partition(partition); + if (in == NULL) { + close(fd); + unlink(filename); + return die("error opening %s: %s\n", partition_name, strerror(errno)); + } + + total = 0; + while ((len = mtd_read_data(in, buf, BLOCK_SIZE)) > 0) { + wrote = write(fd, buf, len); + if (wrote != len) { + close(fd); + unlink(filename); + return die("error writing %s", filename); + } + total += BLOCK_SIZE; + if (callback != NULL) + callback(total, partition_size); + } + + mtd_read_close(in); + + if (close(fd)) { + unlink(filename); + return die("error closing %s", filename); + } + return 0; +} + +int main(int argc, char **argv) +{ + ssize_t (*read_func) (MtdReadContext *, char *, size_t); + MtdReadContext *in; + const MtdPartition *partition; + char buf[BLOCK_SIZE + SPARE_SIZE]; + size_t partition_size; + size_t read_size; + size_t total; + int fd; + int wrote; + int len; + + if (argc != 3) { + fprintf(stderr, "usage: %s partition file.img\n", argv[0]); + return 2; + } + + return dump_image(argv[1], argv[2], NULL); +} + +#endif + +int main(int argc, char **argv) +{ + if (argc != 3) { + fprintf(stderr, "usage: %s partition file.img\n", argv[0]); + return 2; + } + + return backup_raw_partition(NULL, argv[1], argv[2]); +} diff --git a/flashutils/erase_image.c b/flashutils/erase_image.c new file mode 100644 index 000000000..b09a42480 --- /dev/null +++ b/flashutils/erase_image.c @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * Portions Copyright (C) 2010 Magnus Eriksson <packetlss@gmail.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <fcntl.h> + +#include "cutils/log.h" +#include "flashutils.h" + +#if 0 + +#ifdef LOG_TAG +#undef LOG_TAG +#endif + + +#define LOG_TAG "erase_image" + +static int die(const char *msg, ...) { + int err = errno; + va_list args; + va_start(args, msg); + char buf[1024]; + vsnprintf(buf, sizeof(buf), msg, args); + va_end(args); + + if (err != 0) { + strlcat(buf, ": ", sizeof(buf)); + strlcat(buf, strerror(err), sizeof(buf)); + } + + fprintf(stderr, "%s\n", buf); + LOGE("%s\n", buf); + return 3; +} + + +int erase_image(char* partition_name) { + MtdWriteContext *out; + size_t erased; + size_t total_size; + size_t erase_size; + + if (mtd_scan_partitions() <= 0) die("error scanning partitions"); + const MtdPartition *partition = mtd_find_partition_by_name(partition_name); + if (partition == NULL) return die("can't find %s partition", partition_name); + + out = mtd_write_partition(partition); + if (out == NULL) return die("could not estabilish write context for %s", partition_name); + + // do the actual erase, -1 = full partition erase + erased = mtd_erase_blocks(out, -1); + + // erased = bytes erased, if zero, something borked + if (!erased) return die("error erasing %s", partition_name); + + return 0; +} + + +/* Erase a mtd partition */ + +int main(int argc, char **argv) { + if (argc != 2) { + fprintf(stderr, "usage: %s <partition>\n", argv[0]); + return 2; + } + + return erase_image(argv[1]); +} + +#endif + + +int main(int argc, char **argv) +{ + if (argc != 2) { + fprintf(stderr, "usage: %s partition\n", argv[0]); + return 2; + } + + return erase_raw_partition(NULL, argv[1]); +} diff --git a/flashutils/flash_image.c b/flashutils/flash_image.c new file mode 100644 index 000000000..c9f3683c3 --- /dev/null +++ b/flashutils/flash_image.c @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "cutils/log.h" +#include "flashutils.h" + +#if 0 +#define LOG_TAG "flash_image" + +#define HEADER_SIZE 2048 // size of header to compare for equality + +void die(const char *msg, ...) { + int err = errno; + va_list args; + va_start(args, msg); + char buf[1024]; + vsnprintf(buf, sizeof(buf), msg, args); + va_end(args); + + if (err != 0) { + strlcat(buf, ": ", sizeof(buf)); + strlcat(buf, strerror(err), sizeof(buf)); + } + + fprintf(stderr, "%s\n", buf); + LOGE("%s\n", buf); + exit(1); +} + +/* Read an image file and write it to a flash partition. */ + +int main(int argc, char **argv) { + const MtdPartition *ptn; + MtdWriteContext *write; + void *data; + unsigned sz; + + if (argc != 3) { + fprintf(stderr, "usage: %s partition file.img\n", argv[0]); + return 2; + } + + if (mtd_scan_partitions() <= 0) die("error scanning partitions"); + const MtdPartition *partition = mtd_find_partition_by_name(argv[1]); + if (partition == NULL) die("can't find %s partition", argv[1]); + + // If the first part of the file matches the partition, skip writing + + int fd = open(argv[2], O_RDONLY); + if (fd < 0) die("error opening %s", argv[2]); + + char header[HEADER_SIZE]; + int headerlen = read(fd, header, sizeof(header)); + if (headerlen <= 0) die("error reading %s header", argv[2]); + + MtdReadContext *in = mtd_read_partition(partition); + if (in == NULL) { + LOGW("error opening %s: %s\n", argv[1], strerror(errno)); + // just assume it needs re-writing + } else { + char check[HEADER_SIZE]; + int checklen = mtd_read_data(in, check, sizeof(check)); + if (checklen <= 0) { + LOGW("error reading %s: %s\n", argv[1], strerror(errno)); + // just assume it needs re-writing + } else if (checklen == headerlen && !memcmp(header, check, headerlen)) { + LOGI("header is the same, not flashing %s\n", argv[1]); + return 0; + } + mtd_read_close(in); + } + + // Skip the header (we'll come back to it), write everything else + LOGI("flashing %s from %s\n", argv[1], argv[2]); + + MtdWriteContext *out = mtd_write_partition(partition); + if (out == NULL) die("error writing %s", argv[1]); + + char buf[HEADER_SIZE]; + memset(buf, 0, headerlen); + int wrote = mtd_write_data(out, buf, headerlen); + if (wrote != headerlen) die("error writing %s", argv[1]); + + int len; + while ((len = read(fd, buf, sizeof(buf))) > 0) { + wrote = mtd_write_data(out, buf, len); + if (wrote != len) die("error writing %s", argv[1]); + } + if (len < 0) die("error reading %s", argv[2]); + + if (mtd_write_close(out)) die("error closing %s", argv[1]); + + // Now come back and write the header last + + out = mtd_write_partition(partition); + if (out == NULL) die("error re-opening %s", argv[1]); + + wrote = mtd_write_data(out, header, headerlen); + if (wrote != headerlen) die("error re-writing %s", argv[1]); + + // Need to write a complete block, so write the rest of the first block + size_t block_size; + if (mtd_partition_info(partition, NULL, &block_size, NULL)) + die("error getting %s block size", argv[1]); + + if (lseek(fd, headerlen, SEEK_SET) != headerlen) + die("error rewinding %s", argv[2]); + + int left = block_size - headerlen; + while (left < 0) left += block_size; + while (left > 0) { + len = read(fd, buf, left > (int)sizeof(buf) ? (int)sizeof(buf) : left); + if (len <= 0) die("error reading %s", argv[2]); + if (mtd_write_data(out, buf, len) != len) + die("error writing %s", argv[1]); + left -= len; + } + + if (mtd_write_close(out)) die("error closing %s", argv[1]); + return 0; +} +#endif + +int main(int argc, char **argv) +{ + if (argc != 3) { + fprintf(stderr, "usage: %s partition file.img\n", argv[0]); + return 2; + } + + int ret = restore_raw_partition(NULL, argv[1], argv[2]); + if (ret != 0) + fprintf(stderr, "failed with error: %d\n", ret); + return ret; +} diff --git a/flashutils/flashutils.c b/flashutils/flashutils.c new file mode 100644 index 000000000..de45e87b8 --- /dev/null +++ b/flashutils/flashutils.c @@ -0,0 +1,156 @@ +#include <signal.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/wait.h> +#include <stdio.h> + +#include "flashutils/flashutils.h" + +#ifndef BOARD_BML_BOOT +#define BOARD_BML_BOOT "/dev/block/bml7" +#endif + +#ifndef BOARD_BML_RECOVERY +#define BOARD_BML_RECOVERY "/dev/block/bml8" +#endif + +int the_flash_type = UNKNOWN; + +int device_flash_type() +{ + if (the_flash_type == UNKNOWN) { + if (access(BOARD_BML_BOOT, F_OK) == 0) { + the_flash_type = BML; + } else if (access("/proc/emmc", F_OK) == 0) { + the_flash_type = MMC; + } else if (access("/proc/mtd", F_OK) == 0) { + the_flash_type = MTD; + } else { + the_flash_type = UNSUPPORTED; + } + } + return the_flash_type; +} + +char* get_default_filesystem() +{ + return device_flash_type() == MMC ? "ext3" : "yaffs2"; +} + +int get_flash_type(const char* partitionType) { + int type = UNSUPPORTED; + if (strcmp(partitionType, "mtd") == 0) + type = MTD; + else if (strcmp(partitionType, "emmc") == 0) + type = MMC; + else if (strcmp(partitionType, "bml") == 0) + type = BML; + return type; +} + +static int detect_partition(const char *partitionType, const char *partition) +{ + int type = device_flash_type(); + if (strstr(partition, "/dev/block/mtd") != NULL) + type = MTD; + else if (strstr(partition, "/dev/block/mmc") != NULL) + type = MMC; + else if (strstr(partition, "/dev/block/bml") != NULL) + type = BML; + + if (partitionType != NULL) { + type = get_flash_type(partitionType); + } + + return type; +} +int restore_raw_partition(const char* partitionType, const char *partition, const char *filename) +{ + int type = detect_partition(partitionType, partition); + switch (type) { + case MTD: + return cmd_mtd_restore_raw_partition(partition, filename); + case MMC: + return cmd_mmc_restore_raw_partition(partition, filename); + case BML: + return cmd_bml_restore_raw_partition(partition, filename); + default: + return -1; + } +} + +int backup_raw_partition(const char* partitionType, const char *partition, const char *filename) +{ + int type = detect_partition(partitionType, partition); + switch (type) { + case MTD: + return cmd_mtd_backup_raw_partition(partition, filename); + case MMC: + return cmd_mmc_backup_raw_partition(partition, filename); + case BML: + return cmd_bml_backup_raw_partition(partition, filename); + default: + printf("unable to detect device type"); + return -1; + } +} + +int erase_raw_partition(const char* partitionType, const char *partition) +{ + int type = detect_partition(partitionType, partition); + switch (type) { + case MTD: + return cmd_mtd_erase_raw_partition(partition); + case MMC: + return cmd_mmc_erase_raw_partition(partition); + case BML: + return cmd_bml_erase_raw_partition(partition); + default: + return -1; + } +} + +int erase_partition(const char *partition, const char *filesystem) +{ + int type = detect_partition(NULL, partition); + switch (type) { + case MTD: + return cmd_mtd_erase_partition(partition, filesystem); + case MMC: + return cmd_mmc_erase_partition(partition, filesystem); + case BML: + return cmd_bml_erase_partition(partition, filesystem); + default: + return -1; + } +} + +int mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only) +{ + int type = detect_partition(NULL, partition); + switch (type) { + case MTD: + return cmd_mtd_mount_partition(partition, mount_point, filesystem, read_only); + case MMC: + return cmd_mmc_mount_partition(partition, mount_point, filesystem, read_only); + case BML: + return cmd_bml_mount_partition(partition, mount_point, filesystem, read_only); + default: + return -1; + } +} + +int get_partition_device(const char *partition, char *device) +{ + int type = device_flash_type(); + switch (type) { + case MTD: + return cmd_mtd_get_partition_device(partition, device); + case MMC: + return cmd_mmc_get_partition_device(partition, device); + case BML: + return cmd_bml_get_partition_device(partition, device); + default: + return -1; + } +} diff --git a/flashutils/flashutils.h b/flashutils/flashutils.h new file mode 100644 index 000000000..d112a3180 --- /dev/null +++ b/flashutils/flashutils.h @@ -0,0 +1,50 @@ +#ifndef FLASHUTILS_H +#define FLASHUTILS_H + +int restore_raw_partition(const char* partitionType, const char *partition, const char *filename); +int backup_raw_partition(const char* partitionType, const char *partition, const char *filename); +int erase_raw_partition(const char* partitionType, const char *partition); +int erase_partition(const char *partition, const char *filesystem); +int mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only); +int get_partition_device(const char *partition, char *device); + +#define FLASH_MTD 0 +#define FLASH_MMC 1 +#define FLASH_BML 2 + +int is_mtd_device(); +char* get_default_filesystem(); + +extern int cmd_mtd_restore_raw_partition(const char *partition, const char *filename); +extern int cmd_mtd_backup_raw_partition(const char *partition, const char *filename); +extern int cmd_mtd_erase_raw_partition(const char *partition); +extern int cmd_mtd_erase_partition(const char *partition, const char *filesystem); +extern int cmd_mtd_mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only); +extern int cmd_mtd_get_partition_device(const char *partition, char *device); + +extern int cmd_mmc_restore_raw_partition(const char *partition, const char *filename); +extern int cmd_mmc_backup_raw_partition(const char *partition, const char *filename); +extern int cmd_mmc_erase_raw_partition(const char *partition); +extern int cmd_mmc_erase_partition(const char *partition, const char *filesystem); +extern int cmd_mmc_mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only); +extern int cmd_mmc_get_partition_device(const char *partition, char *device); + +extern int cmd_bml_restore_raw_partition(const char *partition, const char *filename); +extern int cmd_bml_backup_raw_partition(const char *partition, const char *filename); +extern int cmd_bml_erase_raw_partition(const char *partition); +extern int cmd_bml_erase_partition(const char *partition, const char *filesystem); +extern int cmd_bml_mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only); +extern int cmd_bml_get_partition_device(const char *partition, char *device); + +extern int device_flash_type(); +extern int get_flash_type(const char* fs_type); + +enum flash_type { + UNSUPPORTED = -1, + UNKNOWN = 0, + MTD = 1, + MMC = 2, + BML = 3 +}; + +#endif
\ No newline at end of file |