Refactor recovery's block device handling to work across variant hardware in a cleaner fashion.
Re add firmware update
Change-Id: I699ad22390ed14e597d17a7bcb32ad1b1af00b4b
support mmc misc
Change-Id: Iff02f8d03db6835f501d052140cebeefee521305
fix compile errors
Change-Id: I032edbd157a8a15f561bb83330c715ebaa008d18
fix compile errors
Change-Id: Idff3449be3376f22fceefc2c35637527f8df8f3f
Initial work to clean up the block devices.
Change-Id: I4be20ac124864a281be9cd116e211a2618404a27
all done
Change-Id: I0338f62f6a045556ebe90b0200685be113178319
fix up nandroid
Change-Id: I886f00271183e6d2921c080b0939341f2cf12a4d
diff --git a/mtdutils/mtdutils.c b/mtdutils/mtdutils.c
index 8069c3f..8b71867 100644
--- a/mtdutils/mtdutils.c
+++ b/mtdutils/mtdutils.c
@@ -557,3 +557,295 @@
}
return pos;
}
+
+#define BLOCK_SIZE 2048
+#define SPARE_SIZE (BLOCK_SIZE >> 5)
+#define HEADER_SIZE 2048
+
+int restore_raw_partition(const char *partition_name, const char *filename)
+{
+ const MtdPartition *ptn;
+ MtdWriteContext *write;
+ void *data;
+ unsigned sz;
+
+ if (mtd_scan_partitions() <= 0)
+ {
+ printf("error scanning partitions");
+ return -1;
+ }
+ const MtdPartition *partition = mtd_find_partition_by_name(partition_name);
+ if (partition == NULL)
+ {
+ printf("can't find %s partition", partition_name);
+ return -1;
+ }
+
+ // If the first part of the file matches the partition, skip writing
+
+ int fd = open(filename, O_RDONLY);
+ if (fd < 0)
+ {
+ printf("error opening %s", filename);
+ return -1;
+ }
+
+ char header[HEADER_SIZE];
+ int headerlen = read(fd, header, sizeof(header));
+ if (headerlen <= 0)
+ {
+ printf("error reading %s header", filename);
+ return -1;
+ }
+
+ MtdReadContext *in = mtd_read_partition(partition);
+ if (in == NULL) {
+ printf("error opening %s: %s\n", partition, 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) {
+ printf("error reading %s: %s\n", partition_name, strerror(errno));
+ // just assume it needs re-writing
+ } else if (checklen == headerlen && !memcmp(header, check, headerlen)) {
+ printf("header is the same, not flashing %s\n", partition_name);
+ return 0;
+ }
+ mtd_read_close(in);
+ }
+
+ // Skip the header (we'll come back to it), write everything else
+ printf("flashing %s from %s\n", partition_name, filename);
+
+ MtdWriteContext *out = mtd_write_partition(partition);
+ if (out == NULL)
+ {
+ printf("error writing %s", partition_name);
+ return -1;
+ }
+
+ char buf[HEADER_SIZE];
+ memset(buf, 0, headerlen);
+ int wrote = mtd_write_data(out, buf, headerlen);
+ if (wrote != headerlen)
+ {
+ printf("error writing %s", partition_name);
+ return -1;
+ }
+
+ int len;
+ while ((len = read(fd, buf, sizeof(buf))) > 0) {
+ wrote = mtd_write_data(out, buf, len);
+ if (wrote != len)
+ {
+ printf("error writing %s", partition_name);
+ return -1;
+ }
+ }
+ if (len < 0)
+ {
+ printf("error reading %s", filename);
+ return -1;
+ }
+
+ if (mtd_write_close(out))
+ {
+ printf("error closing %s", partition_name);
+ return -1;
+ }
+
+ // Now come back and write the header last
+
+ out = mtd_write_partition(partition);
+ if (out == NULL)
+ {
+ printf("error re-opening %s", partition_name);
+ return -1;
+ }
+
+ wrote = mtd_write_data(out, header, headerlen);
+ if (wrote != headerlen)
+ {
+ printf("error re-writing %s", partition_name);
+ return -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))
+ {
+ printf("error getting %s block size", partition_name);
+ return -1;
+ }
+
+ if (lseek(fd, headerlen, SEEK_SET) != headerlen)
+ {
+ printf("error rewinding %s", filename);
+ return -1;
+ }
+
+ 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){
+ printf("error reading %s", filename);
+ return -1;
+ }
+ if (mtd_write_data(out, buf, len) != len)
+ {
+ printf("error writing %s", partition_name);
+ return -1;
+ }
+
+ left -= len;
+ }
+
+ if (mtd_write_close(out))
+ {
+ printf("error closing %s", partition_name);
+ return -1;
+ }
+ return 0;
+}
+
+
+int backup_raw_partition(const char *partition_name, const char *filename)
+{
+ 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)
+ {
+ printf("error scanning partitions");
+ return -1;
+ }
+
+ partition = mtd_find_partition_by_name(partition_name);
+ if (partition == NULL)
+ {
+ printf("can't find %s partition", partition_name);
+ return -1;
+ }
+
+ if (mtd_partition_info(partition, &partition_size, NULL, NULL)) {
+ printf("can't get info of partition %s", partition_name);
+ return -1;
+ }
+
+ if (!strcmp(filename, "-")) {
+ fd = fileno(stdout);
+ }
+ else {
+ fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666);
+ }
+
+ if (fd < 0)
+ {
+ printf("error opening %s", filename);
+ return -1;
+ }
+
+ in = mtd_read_partition(partition);
+ if (in == NULL) {
+ close(fd);
+ unlink(filename);
+ printf("error opening %s: %s\n", partition_name, strerror(errno));
+ return -1;
+ }
+
+ total = 0;
+ while ((len = mtd_read_data(in, buf, BLOCK_SIZE)) > 0) {
+ wrote = write(fd, buf, len);
+ if (wrote != len) {
+ close(fd);
+ unlink(filename);
+ printf("error writing %s", filename);
+ return -1;
+ }
+ total += BLOCK_SIZE;
+ }
+
+ mtd_read_close(in);
+
+ if (close(fd)) {
+ unlink(filename);
+ printf("error closing %s", filename);
+ return -1;
+ }
+ return 0;
+}
+
+int erase_raw_partition(const char *partition_name)
+{
+ MtdWriteContext *out;
+ size_t erased;
+ size_t total_size;
+ size_t erase_size;
+
+ if (mtd_scan_partitions() <= 0)
+ {
+ printf("error scanning partitions");
+ return -1;
+ }
+ const MtdPartition *p = mtd_find_partition_by_name(partition_name);
+ if (p == NULL)
+ {
+ printf("can't find %s partition", partition_name);
+ return -1;
+ }
+
+ out = mtd_write_partition(p);
+ if (out == NULL)
+ {
+ printf("could not estabilish write context for %s", partition_name);
+ return -1;
+ }
+
+ // do the actual erase, -1 = full partition erase
+ erased = mtd_erase_blocks(out, -1);
+
+ // erased = bytes erased, if zero, something borked
+ if (!erased)
+ {
+ printf("error erasing %s", partition_name);
+ return -1;
+ }
+
+ return 0;
+}
+
+int erase_partition(const char *partition, const char *filesystem)
+{
+ return erase_raw_partition(partition);
+}
+
+
+int mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only)
+{
+ mtd_scan_partitions();
+ const MtdPartition *p;
+ p = mtd_find_partition_by_name(partition);
+ if (p == NULL) {
+ return -1;
+ }
+ return mtd_mount_partition(p, mount_point, filesystem, read_only);
+}
+
+int get_partition_device(const char *partition, char *device)
+{
+ mtd_scan_partitions();
+ MtdPartition *p = mtd_find_partition_by_name(partition);
+ if (p == NULL)
+ return -1;
+ sprintf(device, "/dev/block/mtdblock%d", p->device_index);
+ return 0;
+}