recovery/bootloader.c - device/samsung/tuna - Git at Google

 /*
  * Copyright (C) 2011 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 <linux/fs.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include "bootloader.h"

 #define SECTOR_SIZE 512
 #define NUM_SECONDARY_GPT_SECTORS 34
 #define PIT_PARTITION_TABLE_SIZE 0x1000 // 4KB
 #define BOOT_PART_LEN 0x20000 // 128KB
 #define SBL_OFFSET (PIT_PARTITION_TABLE_SIZE + (BOOT_PART_LEN * 4))

 #define SMALL_BUFFER_SIZE 0x20

 // A combination of these defines the specification of the device.
 #define OMAP4460  0x1
 #define OMAP4430  0x2
 #define CHIP_HS   0x4
 #define CHIP_EMU  0x8
 #define MSV_PROD 0x10

 // Location of the PIT partition table in EMMC
 #define PIT_PARTITION_TABLE_LOCATION 0x4400

 static const char* FAMILY_LOCATION = "/sys/board_properties/soc/family";
 static const char* TYPE_LOCATION = "/sys/board_properties/soc/type";
 static const char* MSV_LOCATION = "/sys/board_properties/soc/msv";

 static const char* MMC_LOCATION = "/dev/block/mmcblk0";

 /* pit structure = header + (pit partition info * n) */
 struct pit_header {
         unsigned int magic;
         int count;              /* onenand + mmc partitions */
         int dummy[5];
 } __attribute__((packed));

 struct pit_partinfo {
         int binary;             /* BINARY_TYPE_ */
         int device;             /* PARTITION_DEV_TYPE_ */
         int id;                 /* partition id */
         int attribute;          /* PARTITION_ATTR_ */
         int update;             /* PARTITION_UPDATE_ATTR_ - dedicated. */
         unsigned int blksize;   /* mmc start sector */
         unsigned int blklen;    /* sector count */
         unsigned int offset;    /* file offset (in TAR) */
         unsigned int filesize;  /* file size */
         char name[32];          /* partition name */
         char filename[32];      /* file name */
         char deltaname[32];     /* delta file name - dedicated. */
 } __attribute__((packed));

 unsigned int read_whole_file(const char* fname, char* buffer,
                              int buffer_size) {
   memset(buffer, 0, buffer_size);

   FILE* f = fopen(fname, "rb");
   if (f == NULL) {
     fprintf(stderr, "Cannot open %s!\n", fname);
     return -1;
   }

   int read_byte_count = fread(buffer, 1, buffer_size - 1, f);
   fclose(f);
   if (read_byte_count < 0) {
     fprintf(stderr, "Couldn't read %s\n", fname);
     return -1;
   }

   // Remove any newlines at the end.
   while (buffer[read_byte_count - 1] == '\n') {
     buffer[--read_byte_count] = 0;
   }

   return 0;
 }

 // Get the specifications for this device
 int get_specification() {
   int spec = 0;

   char file_data[SMALL_BUFFER_SIZE];

   if (read_whole_file(FAMILY_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
     if (strcmp(file_data, "OMAP4430") == 0) {
       spec |= OMAP4430;
     } else if (strcmp(file_data, "OMAP4460") == 0) {
       spec |= OMAP4460;
     } else {
       fprintf(stderr, "Unknown family: %s\n", file_data);
       return -1;
     }
   } else {
     fprintf(stderr, "No family\n");
     return -1;
   }

   if (read_whole_file(TYPE_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
     if (strcmp(file_data, "HS") == 0) {
       spec |= CHIP_HS;
     } else if (strcmp(file_data, "EMU") == 0) {
       spec |= CHIP_EMU;
     } else {
       fprintf(stderr, "Unknown chip type: %s\n", file_data);
       return -1;
     }
   } else {
     fprintf(stderr, "No chip type\n");
     return -1;
   }

   // MSV is either prod (non-zero) or eng (zero). Default to eng.
   if (read_whole_file(MSV_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
     if (strtoul(file_data, NULL, 16) != 0) {
       spec |= MSV_PROD;
     }
   } else {
     fprintf(stderr, "No msv\n");
   }

   return spec;
 }


 // Four different xloaders are supported by bootloader.img:
 // 4460 EMU, 4460 HS (eng), 4460 HS (prod), 4430 HS.
 // The layout of the bootloader.img is:
 //
 // PIT Partition table (4KB)
 // 4460 EMU xloader (128KB)
 // 4460 HS (eng) xloader (128KB)
 // 4460 HS (prod) xloader (128KB)
 // 4430 HS xloader(128KB)
 // sbl (the rest)
 int get_xloader_offset() {
   int spec = get_specification();

   if (spec < 0) {
     return -1;
   }

   if (spec & OMAP4460 &&
       spec & CHIP_EMU) {
     return 0;
   } else if (spec & OMAP4460 &&
              spec & CHIP_HS &&
              !(spec & MSV_PROD)) {
     return BOOT_PART_LEN;
   } else if (spec & OMAP4460 &&
              spec & CHIP_HS &&
              spec & MSV_PROD) {
     return BOOT_PART_LEN * 2;
   } else if (spec & OMAP4430 &&
              spec & CHIP_HS) {
     return BOOT_PART_LEN * 3;
   }

   fprintf(stderr, "Unsupported spec for bootloader.img: %d", spec);
   return -1;
 }

 int write_pit_partition_table(const char* image_data,
                               size_t image_size) {
   int written = 0;
   int close_status = 0;
   int to_write;
   const char* curr;


   int mmcfd = open(MMC_LOCATION, O_RDWR);
   if (mmcfd < 0) {
     fprintf(stderr, "Could not open %s\n", MMC_LOCATION);
     return -1;
   }

   // zero out gpt magic field
   if (lseek(mmcfd, SECTOR_SIZE, SEEK_SET) < 0) {
     fprintf(stderr, "Couldn't seek to the start of sector 1\n");
     close(mmcfd);
     return -1;
   }

   char buf[SECTOR_SIZE];
   if (read(mmcfd, buf, SECTOR_SIZE) != SECTOR_SIZE) {
     fprintf(stderr, "Failed to read sector 1\n");
     close(mmcfd);
     return -1;
   }

   memset(buf, 0, 8);

   if (lseek(mmcfd, SECTOR_SIZE, SEEK_SET) < 0) {
     fprintf(stderr, "Couldn't seek to the start of sector 1, part 2\n");
     close(mmcfd);
     return -1;
   }

   to_write = SECTOR_SIZE;
   curr = buf;
   while (to_write > 0) {
     written = write(mmcfd, curr, to_write);
     if (written < 0 && errno != EINTR) {
       fprintf(stderr, "Couldn't overwrite sector 1\n");
       close(mmcfd);
       return -1;
     }
     if (written > 0) {
       to_write -= written;
       curr += written;
     }
   }

   // modify the pit partition info to reflect userdata size
   // before writing the pit partition table
   char pit_partition_copy[PIT_PARTITION_TABLE_SIZE];
   memcpy(pit_partition_copy, image_data, PIT_PARTITION_TABLE_SIZE);

   struct pit_header* hd = (struct pit_header*) pit_partition_copy;
   int i;
   for (i = 0; i < hd->count; i++) {
     struct pit_partinfo* pi = (struct pit_partinfo*)
         (pit_partition_copy + sizeof(*hd) + sizeof(*pi) * i);
     if (strcmp(pi->name, "userdata") == 0) {
       unsigned int num_sectors;
       if (ioctl(mmcfd, BLKGETSIZE, &num_sectors) < 0) {
         fprintf(stderr, "Couldn't get sector count\n");
         close(mmcfd);
         return -1;
       }

       // There are NUM_SECONDARY_GPT_SECTORS sectors reserved at the end of the
       // device to hold a backup copy of the GPT, so we subtract that number.
       pi->blklen = num_sectors - pi->blksize - NUM_SECONDARY_GPT_SECTORS;
       break;
     }
   }

   if (i == hd->count) {
     fprintf(stderr, "No userdata partition found\n");
     close(mmcfd);
     return -1;
   }

   // copy the modified pit partition table data to the correct location
   if (lseek(mmcfd, PIT_PARTITION_TABLE_LOCATION, SEEK_SET) < 0) {
     fprintf(stderr, "Couldn't seek to the pit partition table location\n");
     close(mmcfd);
     return -1;
   }

   to_write = PIT_PARTITION_TABLE_SIZE;
   curr = pit_partition_copy;
   while (to_write > 0) {
     written = write(mmcfd, curr, to_write);
     if (written < 0 && errno != EINTR) {
       fprintf(stderr, "Failed writing pit partition table\n");
       close(mmcfd);
       return -1;
     }
     if (written > 0) {
       to_write -= written;
       curr += written;
     }
   }

   if (close(mmcfd) != 0) {
     fprintf(stderr, "Failed to close file\n");
     return -1;
   }

   return 0;
 }

 int write_xloader(const char* image_data,
                   size_t image_size,
                   const char* xloader_loc) {
   int xloader_offset = get_xloader_offset();

   if (xloader_offset < 0) {
     return -1;
   }

   // The offsets into xloader part of the bootloader image
   xloader_offset += PIT_PARTITION_TABLE_SIZE;

   FILE* xloader = fopen(xloader_loc, "r+b");
   if (xloader == NULL) {
     fprintf(stderr, "Could not open %s\n", xloader_loc);
     return -1;
   }

   // index into the correct xloader offset
   int written = fwrite(image_data+xloader_offset, 1, BOOT_PART_LEN, xloader);
   int close_status = fclose(xloader);
   if (written != BOOT_PART_LEN || close_status != 0) {
     fprintf(stderr, "Failed writing to /xloader\n");
     return -1;
   }

   return 0;
 }

 int write_sbl(const char* image_data,
               size_t image_size,
               const char* sbl_loc) {
   unsigned int sbl_size = image_size - SBL_OFFSET;
   FILE* sbl = fopen(sbl_loc, "r+b");
   if (sbl == NULL) {
     fprintf(stderr, "Could not open %s\n", sbl_loc);
     return -1;
   }

   int written = fwrite(image_data+SBL_OFFSET, 1, sbl_size, sbl);
   int close_status = fclose(sbl);
   if (written != sbl_size || close_status != 0) {
     fprintf(stderr, "Failed writing to /sbl\n");
     return -1;
   }

   return 0;
 }

 int update_bootloader(const char* image_data,
                       size_t image_size,
                       const char* xloader_loc,
                       const char* sbl_loc) {
   if (image_size < SBL_OFFSET) {
     fprintf(stderr, "image size %d is too small\n", image_size);
     return -1;
   }

   if (write_pit_partition_table(image_data, image_size) < 0) {
     return -1;
   }

   if (write_xloader(image_data, image_size, xloader_loc) < 0) {
     return -1;
   }

   if (write_sbl(image_data, image_size, sbl_loc) < 0) {
     return -1;
   }

   return 0;
 }
	/*
	* Copyright (C) 2011 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 <linux/fs.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/ioctl.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include "bootloader.h"

	#define SECTOR_SIZE 512
	#define NUM_SECONDARY_GPT_SECTORS 34
	#define PIT_PARTITION_TABLE_SIZE 0x1000 // 4KB
	#define BOOT_PART_LEN 0x20000 // 128KB
	#define SBL_OFFSET (PIT_PARTITION_TABLE_SIZE + (BOOT_PART_LEN * 4))

	#define SMALL_BUFFER_SIZE 0x20

	// A combination of these defines the specification of the device.
	#define OMAP4460 0x1
	#define OMAP4430 0x2
	#define CHIP_HS 0x4
	#define CHIP_EMU 0x8
	#define MSV_PROD 0x10

	// Location of the PIT partition table in EMMC
	#define PIT_PARTITION_TABLE_LOCATION 0x4400

	static const char* FAMILY_LOCATION = "/sys/board_properties/soc/family";
	static const char* TYPE_LOCATION = "/sys/board_properties/soc/type";
	static const char* MSV_LOCATION = "/sys/board_properties/soc/msv";

	static const char* MMC_LOCATION = "/dev/block/mmcblk0";

	/* pit structure = header + (pit partition info * n) */
	struct pit_header {
	unsigned int magic;
	int count; /* onenand + mmc partitions */
	int dummy[5];
	} __attribute__((packed));

	struct pit_partinfo {
	int binary; /* BINARY_TYPE_ */
	int device; /* PARTITION_DEV_TYPE_ */
	int id; /* partition id */
	int attribute; /* PARTITION_ATTR_ */
	int update; /* PARTITION_UPDATE_ATTR_ - dedicated. */
	unsigned int blksize; /* mmc start sector */
	unsigned int blklen; /* sector count */
	unsigned int offset; /* file offset (in TAR) */
	unsigned int filesize; /* file size */
	char name[32]; /* partition name */
	char filename[32]; /* file name */
	char deltaname[32]; /* delta file name - dedicated. */
	} __attribute__((packed));

	unsigned int read_whole_file(const char* fname, char* buffer,
	int buffer_size) {
	memset(buffer, 0, buffer_size);

	FILE* f = fopen(fname, "rb");
	if (f == NULL) {
	fprintf(stderr, "Cannot open %s!\n", fname);
	return -1;
	}

	int read_byte_count = fread(buffer, 1, buffer_size - 1, f);
	fclose(f);
	if (read_byte_count < 0) {
	fprintf(stderr, "Couldn't read %s\n", fname);
	return -1;
	}

	// Remove any newlines at the end.
	while (buffer[read_byte_count - 1] == '\n') {
	buffer[--read_byte_count] = 0;
	}

	return 0;
	}

	// Get the specifications for this device
	int get_specification() {
	int spec = 0;

	char file_data[SMALL_BUFFER_SIZE];

	if (read_whole_file(FAMILY_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
	if (strcmp(file_data, "OMAP4430") == 0) {
	spec \|= OMAP4430;
	} else if (strcmp(file_data, "OMAP4460") == 0) {
	spec \|= OMAP4460;
	} else {
	fprintf(stderr, "Unknown family: %s\n", file_data);
	return -1;
	}
	} else {
	fprintf(stderr, "No family\n");
	return -1;
	}

	if (read_whole_file(TYPE_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
	if (strcmp(file_data, "HS") == 0) {
	spec \|= CHIP_HS;
	} else if (strcmp(file_data, "EMU") == 0) {
	spec \|= CHIP_EMU;
	} else {
	fprintf(stderr, "Unknown chip type: %s\n", file_data);
	return -1;
	}
	} else {
	fprintf(stderr, "No chip type\n");
	return -1;
	}

	// MSV is either prod (non-zero) or eng (zero). Default to eng.
	if (read_whole_file(MSV_LOCATION, file_data, SMALL_BUFFER_SIZE) == 0) {
	if (strtoul(file_data, NULL, 16) != 0) {
	spec \|= MSV_PROD;
	}
	} else {
	fprintf(stderr, "No msv\n");
	}

	return spec;
	}


	// Four different xloaders are supported by bootloader.img:
	// 4460 EMU, 4460 HS (eng), 4460 HS (prod), 4430 HS.
	// The layout of the bootloader.img is:
	//
	// PIT Partition table (4KB)
	// 4460 EMU xloader (128KB)
	// 4460 HS (eng) xloader (128KB)
	// 4460 HS (prod) xloader (128KB)
	// 4430 HS xloader(128KB)
	// sbl (the rest)
	int get_xloader_offset() {
	int spec = get_specification();

	if (spec < 0) {
	return -1;
	}

	if (spec & OMAP4460 &&
	spec & CHIP_EMU) {
	return 0;
	} else if (spec & OMAP4460 &&
	spec & CHIP_HS &&
	!(spec & MSV_PROD)) {
	return BOOT_PART_LEN;
	} else if (spec & OMAP4460 &&
	spec & CHIP_HS &&
	spec & MSV_PROD) {
	return BOOT_PART_LEN * 2;
	} else if (spec & OMAP4430 &&
	spec & CHIP_HS) {
	return BOOT_PART_LEN * 3;
	}

	fprintf(stderr, "Unsupported spec for bootloader.img: %d", spec);
	return -1;
	}

	int write_pit_partition_table(const char* image_data,
	size_t image_size) {
	int written = 0;
	int close_status = 0;
	int to_write;
	const char* curr;


	int mmcfd = open(MMC_LOCATION, O_RDWR);
	if (mmcfd < 0) {
	fprintf(stderr, "Could not open %s\n", MMC_LOCATION);
	return -1;
	}

	// zero out gpt magic field
	if (lseek(mmcfd, SECTOR_SIZE, SEEK_SET) < 0) {
	fprintf(stderr, "Couldn't seek to the start of sector 1\n");
	close(mmcfd);
	return -1;
	}

	char buf[SECTOR_SIZE];
	if (read(mmcfd, buf, SECTOR_SIZE) != SECTOR_SIZE) {
	fprintf(stderr, "Failed to read sector 1\n");
	close(mmcfd);
	return -1;
	}

	memset(buf, 0, 8);

	if (lseek(mmcfd, SECTOR_SIZE, SEEK_SET) < 0) {
	fprintf(stderr, "Couldn't seek to the start of sector 1, part 2\n");
	close(mmcfd);
	return -1;
	}

	to_write = SECTOR_SIZE;
	curr = buf;
	while (to_write > 0) {
	written = write(mmcfd, curr, to_write);
	if (written < 0 && errno != EINTR) {
	fprintf(stderr, "Couldn't overwrite sector 1\n");
	close(mmcfd);
	return -1;
	}
	if (written > 0) {
	to_write -= written;
	curr += written;
	}
	}

	// modify the pit partition info to reflect userdata size
	// before writing the pit partition table
	char pit_partition_copy[PIT_PARTITION_TABLE_SIZE];
	memcpy(pit_partition_copy, image_data, PIT_PARTITION_TABLE_SIZE);

	struct pit_header* hd = (struct pit_header*) pit_partition_copy;
	int i;
	for (i = 0; i < hd->count; i++) {
	struct pit_partinfo* pi = (struct pit_partinfo*)
	(pit_partition_copy + sizeof(hd) + sizeof(pi) * i);
	if (strcmp(pi->name, "userdata") == 0) {
	unsigned int num_sectors;
	if (ioctl(mmcfd, BLKGETSIZE, &num_sectors) < 0) {
	fprintf(stderr, "Couldn't get sector count\n");
	close(mmcfd);
	return -1;
	}

	// There are NUM_SECONDARY_GPT_SECTORS sectors reserved at the end of the
	// device to hold a backup copy of the GPT, so we subtract that number.
	pi->blklen = num_sectors - pi->blksize - NUM_SECONDARY_GPT_SECTORS;
	break;
	}
	}

	if (i == hd->count) {
	fprintf(stderr, "No userdata partition found\n");
	close(mmcfd);
	return -1;
	}

	// copy the modified pit partition table data to the correct location
	if (lseek(mmcfd, PIT_PARTITION_TABLE_LOCATION, SEEK_SET) < 0) {
	fprintf(stderr, "Couldn't seek to the pit partition table location\n");
	close(mmcfd);
	return -1;
	}

	to_write = PIT_PARTITION_TABLE_SIZE;
	curr = pit_partition_copy;
	while (to_write > 0) {
	written = write(mmcfd, curr, to_write);
	if (written < 0 && errno != EINTR) {
	fprintf(stderr, "Failed writing pit partition table\n");
	close(mmcfd);
	return -1;
	}
	if (written > 0) {
	to_write -= written;
	curr += written;
	}
	}

	if (close(mmcfd) != 0) {
	fprintf(stderr, "Failed to close file\n");
	return -1;
	}

	return 0;
	}

	int write_xloader(const char* image_data,
	size_t image_size,
	const char* xloader_loc) {
	int xloader_offset = get_xloader_offset();

	if (xloader_offset < 0) {
	return -1;
	}

	// The offsets into xloader part of the bootloader image
	xloader_offset += PIT_PARTITION_TABLE_SIZE;

	FILE* xloader = fopen(xloader_loc, "r+b");
	if (xloader == NULL) {
	fprintf(stderr, "Could not open %s\n", xloader_loc);
	return -1;
	}

	// index into the correct xloader offset
	int written = fwrite(image_data+xloader_offset, 1, BOOT_PART_LEN, xloader);
	int close_status = fclose(xloader);
	if (written != BOOT_PART_LEN \|\| close_status != 0) {
	fprintf(stderr, "Failed writing to /xloader\n");
	return -1;
	}

	return 0;
	}

	int write_sbl(const char* image_data,
	size_t image_size,
	const char* sbl_loc) {
	unsigned int sbl_size = image_size - SBL_OFFSET;
	FILE* sbl = fopen(sbl_loc, "r+b");
	if (sbl == NULL) {
	fprintf(stderr, "Could not open %s\n", sbl_loc);
	return -1;
	}

	int written = fwrite(image_data+SBL_OFFSET, 1, sbl_size, sbl);
	int close_status = fclose(sbl);
	if (written != sbl_size \|\| close_status != 0) {
	fprintf(stderr, "Failed writing to /sbl\n");
	return -1;
	}

	return 0;
	}

	int update_bootloader(const char* image_data,
	size_t image_size,
	const char* xloader_loc,
	const char* sbl_loc) {
	if (image_size < SBL_OFFSET) {
	fprintf(stderr, "image size %d is too small\n", image_size);
	return -1;
	}

	if (write_pit_partition_table(image_data, image_size) < 0) {
	return -1;
	}

	if (write_xloader(image_data, image_size, xloader_loc) < 0) {
	return -1;
	}

	if (write_sbl(image_data, image_size, sbl_loc) < 0) {
	return -1;
	}

	return 0;
	}