--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <byteswap.h>
+#include <endian.h>
+#include <getopt.h>
+
+
+#if !defined(__BYTE_ORDER)
+#error "Unknown byte order"
+#endif
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define cpu_to_be16(x) (x)
+#define cpu_to_be32(x) (x)
+#define be16_to_cpu(x) (x)
+#define be32_to_cpu(x) (x)
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+#define cpu_to_be16(x) bswap_16(x)
+#define cpu_to_be32(x) bswap_32(x)
+#define be16_to_cpu(x) bswap_16(x)
+#define be32_to_cpu(x) bswap_32(x)
+#else
+#error "Unsupported endianness"
+#endif
+
+
+#define FAT_PTR_FLAGS_GET(x) ((be32_to_cpu(x) & 0xff000000) >> 24)
+#define FAT_PTR_FLAGS_SET(x, y) (x = cpu_to_be32((be32_to_cpu(x) & 0x00ffffff) | ((y & 0x000000ff) << 24)))
+
+#define FAT_PTR_VAL_GET(x) (be32_to_cpu(x) & 0x00ffffff)
+#define FAT_PTR_VAL_SET(x, y) (x = cpu_to_be32((be32_to_cpu(x) & 0xff000000) | (y & 0x00ffffff)))
+
+
+struct fat_entry {
+ /* first byte contains flags */
+ uint32_t previous;
+
+ /* first byte is reserved */
+ uint32_t next;
+} __attribute__ ((packed));
+
+struct file_entry {
+ uint8_t flags;
+
+ uint8_t res0[5];
+
+ uint16_t year;
+ uint8_t month;
+ uint8_t day;
+ uint8_t hour;
+ uint8_t minute;
+ uint8_t second;
+
+ uint8_t res1[3];
+
+ uint32_t length;
+
+ uint32_t parent_block;
+ uint16_t parent_index;
+
+ uint8_t res2[2];
+
+ uint32_t data_block;
+
+ char name[96];
+} __attribute__ ((packed));
+
+
+#define ERASEBLOCK_SIZE 0x10000
+#define BLOCK_SIZE 0x400
+
+#define BLOCKS_PER_ERASEBLOCK (ERASEBLOCK_SIZE / BLOCK_SIZE)
+#define FILE_ENTRIES_PER_BLOCK (BLOCK_SIZE / sizeof(struct file_entry))
+
+
+#define FLAG_FREE 0x80
+#define FLAG_VALID 0x40
+#define FLAG_INVALID 0x20
+#define FLAG_HIDE 0x10
+#define FLAG_DIRECTORY 0x02
+#define FLAG_READONLY 0x01
+
+
+static FILE *f;
+static size_t file_size = 0;
+
+static int dir_block = 1;
+static int dir_count = 0;
+
+static int next_data_block = 2;
+
+
+static inline size_t fat_entry_offset(int block) {
+ return ERASEBLOCK_SIZE * (block / (BLOCKS_PER_ERASEBLOCK-1))
+ + sizeof(struct fat_entry) * (block % (BLOCKS_PER_ERASEBLOCK-1));
+}
+
+static inline size_t block_offset(int block) {
+ return ERASEBLOCK_SIZE * (block / (BLOCKS_PER_ERASEBLOCK-1))
+ + BLOCK_SIZE * (1 + (block % (BLOCKS_PER_ERASEBLOCK-1)));
+}
+
+static int init_eraseblock(size_t offset) {
+ size_t end = offset - (offset % ERASEBLOCK_SIZE) + ERASEBLOCK_SIZE;
+ char *fill = "\xff";
+ int i;
+
+ while (file_size < end) {
+ if (fseek(f, file_size, SEEK_SET)) {
+ fprintf(stderr, "failed to seek to end\n");
+ return -1;
+ }
+
+ for (i = 0; i < ERASEBLOCK_SIZE; i++) {
+ if (fwrite(fill, 1, 1, f) != 1) {
+ fprintf(stderr, "failed to write eraseblock\n");
+ return -1;
+ }
+ }
+
+ file_size += ERASEBLOCK_SIZE;
+ }
+
+ return 0;
+}
+
+static inline void init_fat_entry(struct fat_entry *out) {
+ memset(out, '\xff', sizeof(struct fat_entry));
+}
+
+static int read_fat_entry(struct fat_entry *out, int block) {
+ size_t offset = fat_entry_offset(block);
+
+ if (init_eraseblock(offset)) {
+ return -1;
+ }
+
+ if (fseek(f, offset, SEEK_SET)) {
+ fprintf(stderr, "failed to seek to fat entry\n");
+ return -1;
+ }
+
+ if (fread(out, sizeof(struct fat_entry), 1, f) != 1) {
+ fprintf(stderr, "failed to read fat entry\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int write_fat_entry(struct fat_entry *in, int block) {
+ size_t offset = fat_entry_offset(block);
+
+ if (init_eraseblock(offset)) {
+ return -1;
+ }
+
+ if (fseek(f, offset, SEEK_SET)) {
+ fprintf(stderr, "failed to seek to fat entry\n");
+ return -1;
+ }
+
+ if (fwrite(in, sizeof(struct fat_entry), 1, f) != 1) {
+ fprintf(stderr, "failed to write fat entry\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static inline void init_file_entry(struct file_entry *out) {
+ memset(out, '\xff', sizeof(struct file_entry));
+}
+
+static int write_file_entry(struct file_entry *in, int block, int index) {
+ size_t offset = block_offset(block) + sizeof(struct file_entry) * index;
+
+ if (init_eraseblock(offset)) {
+ return -1;
+ }
+
+ if (fseek(f, offset, SEEK_SET)) {
+ fprintf(stderr, "failed to seek to file entry\n");
+ return -1;
+ }
+
+ if (fwrite(in, sizeof(struct file_entry), 1, f) != 1) {
+ fprintf(stderr, "failed to write file entry\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int write_block(void *in, size_t len, int block) {
+ size_t offset = block_offset(block);
+
+ if (init_eraseblock(offset)) {
+ return -1;
+ }
+
+ if (fseek(f, offset, SEEK_SET)) {
+ fprintf(stderr, "failed to seek to block\n");
+ return -1;
+ }
+
+ if (fwrite(in, len, 1, f) != 1) {
+ fprintf(stderr, "failed to write block\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int create_root_directory() {
+ struct fat_entry fat;
+ struct file_entry file;
+
+ /* write format flag / FAT entry for block 0 (contains root file entry) */
+ init_fat_entry(&fat);
+ fat.previous = cpu_to_be32((ERASEBLOCK_SIZE << 12) | BLOCK_SIZE);
+ if (write_fat_entry(&fat, 0)) {
+ return -1;
+ }
+
+ /* write root file entry */
+ init_file_entry(&file);
+ file.flags = ~(FLAG_FREE | FLAG_VALID) & 0xff;
+ file.parent_block = cpu_to_be32(0);
+ file.data_block = cpu_to_be32(1);
+ if (write_file_entry(&file, 0, 0)) {
+ return -1;
+ }
+
+ /* write FAT entry for block 1 (contains first file entries of root directory) */
+ init_fat_entry(&fat);
+ FAT_PTR_FLAGS_SET(fat.previous, ~(FLAG_FREE | FLAG_VALID));
+ if (write_fat_entry(&fat, 1)) {
+ return -1;
+ }
+
+ return 0;
+}
+
+static int write_file(char *name, char *path) {
+ int ret = -1;
+ struct fat_entry fat;
+ struct file_entry file;
+ FILE *fin;
+ char buf[BLOCK_SIZE];
+ size_t len;
+ size_t total = 0;
+ int first_data_block = next_data_block;
+ int data_block = 0;
+
+ fin = fopen(path, "r");
+ if (fin == NULL) {
+ fprintf(stderr, "failed to open input file\n");
+ return ret;
+ }
+
+ while ((len = fread(buf, 1, BLOCK_SIZE, fin)) != 0 || !data_block) {
+ total += len;
+
+ /* update next pointer of previous FAT entry */
+ if (data_block) {
+ if (read_fat_entry(&fat, data_block)) {
+ goto err;
+ }
+ FAT_PTR_VAL_SET(fat.next, next_data_block);
+ if (write_fat_entry(&fat, data_block)) {
+ goto err;
+ }
+ }
+
+ /* write FAT entry for new block */
+ init_fat_entry(&fat);
+ FAT_PTR_FLAGS_SET(fat.previous, ~(FLAG_FREE | FLAG_VALID));
+ if (data_block) {
+ FAT_PTR_VAL_SET(fat.previous, data_block);
+ }
+ if (write_fat_entry(&fat, next_data_block)) {
+ goto err;
+ }
+
+ /* write data block */
+ if (write_block(buf, len, next_data_block)) {
+ goto err;
+ }
+
+ data_block = next_data_block;
+ next_data_block++;
+ }
+
+ /* create new file entries block if necessary */
+ if (dir_count == FILE_ENTRIES_PER_BLOCK) {
+ /* update next pointer of previous FAT entry */
+ if (read_fat_entry(&fat, dir_block)) {
+ goto err;
+ }
+ FAT_PTR_VAL_SET(fat.next, next_data_block);
+ if (write_fat_entry(&fat, dir_block)) {
+ goto err;
+ }
+
+ /* write FAT entry for new block */
+ init_fat_entry(&fat);
+ FAT_PTR_FLAGS_SET(fat.previous, ~(FLAG_FREE | FLAG_VALID));
+ FAT_PTR_VAL_SET(fat.previous, dir_block);
+ if (write_fat_entry(&fat, next_data_block)) {
+ goto err;
+ }
+
+ dir_block = next_data_block;
+ dir_count = 0;
+ next_data_block++;
+ }
+
+ /* write file entry */
+ init_file_entry(&file);
+
+ file.flags = ~(FLAG_FREE | FLAG_VALID) & 0xff;
+
+ file.year = cpu_to_be16(1970);
+ file.month = 1;
+ file.day = 1;
+ file.hour = 0;
+ file.minute = 0;
+ file.second = 0;
+
+ file.length = cpu_to_be32(total);
+
+ file.parent_block = cpu_to_be32(0);
+ file.parent_index = cpu_to_be16(0);
+
+ file.data_block = cpu_to_be32(first_data_block);
+
+ snprintf(file.name, sizeof(file.name), "%s", name);
+
+ if (write_file_entry(&file, dir_block, dir_count)) {
+ goto err;
+ }
+
+ dir_count++;
+
+ ret = 0;
+err:
+ fclose(fin);
+ return ret;
+}
+
+static void usage(char* argv[]) {
+ printf("Usage: %s [OPTIONS...]\n"
+ "\n"
+ "Options:\n"
+ " -f <filename> filename in image\n"
+ " -i <file> input filename\n"
+ " -o <file> output filename\n"
+ , argv[0]);
+}
+
+int main(int argc, char* argv[]) {
+ int ret = EXIT_FAILURE;
+
+ static char *filename = NULL;
+ static char *input_filename = NULL;
+ static char *output_filename = NULL;
+
+ while ( 1 ) {
+ int c;
+
+ c = getopt(argc, argv, "f:i:o:");
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'f':
+ filename = optarg;
+ break;
+ case 'i':
+ input_filename = optarg;
+ break;
+ case 'o':
+ output_filename = optarg;
+ break;
+ default:
+ usage(argv);
+ goto err;
+ }
+ }
+
+ if (!filename || strlen(filename) == 0 ||
+ !input_filename || strlen(input_filename) == 0 ||
+ !output_filename || strlen(output_filename) == 0) {
+
+ usage(argv);
+ goto err;
+ }
+
+ f = fopen(output_filename, "w+");
+ if (f == NULL) {
+ fprintf(stderr, "failed to open output file\n");
+ goto err;
+ }
+
+ if (create_root_directory()) {
+ goto err_close;
+ }
+
+ if (write_file(filename, input_filename)) {
+ goto err_close;
+ }
+
+ ret = EXIT_SUCCESS;
+
+err_close:
+ fclose(f);
+err:
+ return ret;
+}
projects / project / firmware-utils.git / blobdiff