--- /dev/null
+/*
+ * Copyright © 2013 Keith Packard <keithp@keithp.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; version 2 of the License.
+ *
+ * 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 AO_FAT_TEST
+#include "ao.h"
+#endif
+
+#include "ao_fat.h"
+#include "ao_bufio.h"
+
+/* Partition information, block numbers */
+
+static uint8_t partition_type;
+static uint32_t partition_start, partition_end;
+
+/* File system parameters */
+static uint8_t sectors_per_cluster;
+static uint32_t bytes_per_cluster;
+static uint16_t reserved_sector_count;
+static uint8_t number_fat;
+static uint16_t root_entries;
+static uint16_t sectors_per_fat;
+static uint32_t fat_start;
+static uint32_t root_start;
+static uint32_t data_start;
+
+static uint32_t
+get_u32(uint8_t *base)
+{
+ return ((uint32_t) base[0] |
+ ((uint32_t) base[1] << 8) |
+ ((uint32_t) base[2] << 16) |
+ ((uint32_t) base[3] << 24));
+}
+
+static void
+put_u32(uint8_t *base, uint32_t value)
+{
+ base[0] = value;
+ base[1] = value >> 8;
+ base[2] = value >> 16;
+ base[3] = value >> 24;
+}
+
+static uint16_t
+get_u16(uint8_t *base)
+{
+ return ((uint16_t) base[0] | ((uint16_t) base[1] << 8));
+}
+
+static void
+put_u16(uint8_t *base, uint16_t value)
+{
+ base[0] = value;
+ base[1] = value >> 8;
+}
+
+static uint8_t
+ao_fat_cluster_valid(uint16_t cluster)
+{
+ return (2 <= cluster && cluster < 0xfff0);
+}
+
+/* Start using a block */
+static uint8_t *
+ao_fat_block_get(uint32_t block)
+{
+ block += partition_start;
+ if (block >= partition_end)
+ return NULL;
+ return ao_bufio_get(block);
+}
+
+/* Finish using a block, 'w' is 1 if modified */
+#define ao_fat_block_put(b,w) ao_bufio_put(b,w)
+
+/* Start using a root directory entry */
+static uint8_t *
+ao_fat_root_get(uint16_t e)
+{
+ uint32_t byte = e * 0x20;
+ uint32_t sector = byte >> 9;
+ uint16_t offset = byte & 0x1ff;
+ uint8_t *buf;
+
+ buf = ao_fat_block_get(root_start + sector);
+ if (!buf)
+ return NULL;
+ return buf + offset;
+}
+
+/* Finish using a root directory entry, 'w' is 1 if modified */
+static void
+ao_fat_root_put(uint8_t *root, uint16_t e, uint8_t write)
+{
+ uint16_t offset = ((e * 0x20) & 0x1ff);
+ uint8_t *buf = root - offset;
+
+ ao_fat_block_put(buf, write);
+}
+
+/* Get the next cluster entry in the chain */
+static uint16_t
+ao_fat_entry_read(uint16_t cluster)
+{
+ uint32_t sector;
+ uint16_t offset;
+ uint8_t *buf;
+ uint16_t ret;
+
+ if (!ao_fat_cluster_valid(cluster))
+ return 0xfff7;
+
+ cluster -= 2;
+ sector = cluster >> 8;
+ offset = (cluster << 1) & 0x1ff;
+ buf = ao_fat_block_get(fat_start + sector);
+ if (!buf)
+ return 0;
+ ret = buf[offset] | (buf[offset+1] << 8);
+ ao_fat_block_put(buf, 0);
+ return ret;
+}
+
+static uint16_t
+ao_fat_entry_replace(uint16_t cluster, uint16_t new_value)
+{
+ uint32_t sector;
+ uint16_t offset;
+ uint8_t *buf;
+ uint16_t ret;
+ uint8_t other_fats;
+
+ if (!ao_fat_cluster_valid(cluster))
+ return 0;
+
+ cluster -= 2;
+ sector = cluster >> 8;
+ offset = (cluster << 1) & 0x1ff;
+ buf = ao_fat_block_get(fat_start + sector);
+ if (!buf)
+ return 0;
+ ret = get_u16(buf + offset);
+ put_u16(buf + offset, new_value);
+ ao_fat_block_put(buf, 1);
+ for (other_fats = 1; other_fats < number_fat; other_fats++) {
+ buf = ao_fat_block_get(fat_start + other_fats * sectors_per_fat);
+ if (buf) {
+ put_u16(buf + offset, new_value);
+ ao_fat_block_put(buf, 1);
+ }
+ }
+ return ret;
+
+}
+
+static void
+ao_fat_clear_cluster_chain(uint16_t cluster)
+{
+ while (ao_fat_cluster_valid(cluster))
+ cluster = ao_fat_entry_replace(cluster, 0x0000);
+}
+
+static uint16_t
+ao_fat_cluster_seek(uint16_t cluster, uint16_t distance)
+{
+ while (distance) {
+ cluster = ao_fat_entry_read(cluster);
+ if (!ao_fat_cluster_valid(cluster))
+ break;
+ distance--;
+ }
+ return cluster;
+}
+
+static uint32_t
+ao_fat_sector_seek(uint16_t cluster, uint32_t sector)
+{
+ cluster = ao_fat_cluster_seek(cluster, sector / sectors_per_cluster);
+ if (!ao_fat_cluster_valid(cluster))
+ return 0xffffffff;
+ return data_start + (cluster-2) * sectors_per_cluster + sector % sectors_per_cluster;
+}
+
+/* Load the boot block and find the first partition */
+static uint8_t
+ao_fat_setup_partition(void)
+{
+ uint8_t *mbr;
+ uint8_t *partition;
+ uint32_t partition_size;
+
+ mbr = ao_bufio_get(0);
+ if (!mbr)
+ return 0;
+
+ /* Check the signature */
+ if (mbr[0x1fe] != 0x55 || mbr[0x1ff] != 0xaa) {
+ printf ("Invalid MBR signature %02x %02x\n",
+ mbr[0x1fe], mbr[0x1ff]);
+ ao_bufio_put(mbr, 0);
+ return 0;
+ }
+
+ /* Just use the first partition */
+ partition = &mbr[0x1be];
+
+ partition_type = partition[4];
+ switch (partition_type) {
+ case 4: /* FAT16 up to 32M */
+ case 6: /* FAT16 over 32M */
+ break;
+ case 0x0b: /* FAT32 up to 2047GB */
+ case 0x0c: /* FAT32 LBA */
+ break;
+ default:
+ printf ("Invalid partition type %02x\n", partition_type);
+ ao_bufio_put(mbr, 0);
+ return 0;
+ }
+
+ partition_start = get_u32(partition+8);
+ partition_size = get_u32(partition+12);
+ if (partition_size == 0) {
+ printf ("Zero-sized partition\n");
+ ao_bufio_put(mbr, 0);
+ return 0;
+ }
+ partition_end = partition_start + partition_size;
+ printf ("Partition type %02x start %08x end %08x\n",
+ partition_type, partition_start, partition_end);
+ ao_bufio_put(mbr, 0);
+ return 1;
+}
+
+static uint8_t
+ao_fat_setup_fs(void)
+{
+ uint8_t *boot = ao_fat_block_get(0);
+
+ if (!boot)
+ return 0;
+
+ /* Check the signature */
+ if (boot[0x1fe] != 0x55 || boot[0x1ff] != 0xaa) {
+ printf ("Invalid BOOT signature %02x %02x\n",
+ boot[0x1fe], boot[0x1ff]);
+ ao_bufio_put(boot, 0);
+ return 0;
+ }
+
+ /* Check the sector size */
+ if (get_u16(boot + 0xb) != 0x200) {
+ printf ("Invalid sector size %d\n",
+ get_u16(boot + 0xb));
+ ao_bufio_put(boot, 0);
+ return 0;
+ }
+
+ sectors_per_cluster = boot[0xd];
+ bytes_per_cluster = sectors_per_cluster << 9;
+ reserved_sector_count = get_u16(boot+0xe);
+ number_fat = boot[0x10];
+ root_entries = get_u16(boot + 0x11);
+ sectors_per_fat = get_u16(boot+0x16);
+
+ printf ("sectors per cluster %d\n", sectors_per_cluster);
+ printf ("reserved sectors %d\n", reserved_sector_count);
+ printf ("number of FATs %d\n", number_fat);
+ printf ("root entries %d\n", root_entries);
+ printf ("sectors per fat %d\n", sectors_per_fat);
+
+ fat_start = reserved_sector_count;;
+ root_start = fat_start + number_fat * sectors_per_fat;
+ data_start = root_start + ((root_entries * 0x20 + 0x1ff) >> 9);
+
+ printf ("fat start %d\n", fat_start);
+ printf ("root start %d\n", root_start);
+ printf ("data start %d\n", data_start);
+
+ return 1;
+}
+
+static uint8_t
+ao_fat_setup(void)
+{
+ if (!ao_fat_setup_partition())
+ return 0;
+ if (!ao_fat_setup_fs())
+ return 0;
+ return 1;
+}
+
+/*
+ * Low-level directory operations
+ */
+
+/*
+ * Basic file operations
+ */
+
+static struct ao_fat_dirent ao_file_dirent;
+static uint32_t ao_file_offset;
+
+static uint32_t
+ao_file_offset_to_sector(uint32_t offset)
+{
+ if (offset > ao_file_dirent.size)
+ return 0xffffffff;
+ return ao_fat_sector_seek(ao_file_dirent.cluster, offset >> 9);
+}
+
+uint8_t
+ao_fat_open(char name[11])
+{
+ uint16_t entry = 0;
+ struct ao_fat_dirent dirent;
+
+ while (ao_fat_readdir(&entry, &dirent)) {
+ if (!memcmp(name, dirent.name, 11)) {
+ ao_file_dirent = dirent;
+ ao_file_offset = 0;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+
+
+static uint8_t
+ao_fat_set_size(uint32_t size)
+{
+ uint16_t clear_cluster = 0;
+ uint8_t *dent;
+ uint16_t first_cluster;
+
+ first_cluster = ao_file_dirent.cluster;
+ printf ("set size to %d\n", size);
+ if (size == ao_file_dirent.size)
+ return 1;
+ if (size == 0) {
+ printf ("erase file\n");
+ clear_cluster = ao_file_dirent.cluster;
+ first_cluster = 0;
+ } else {
+ uint16_t new_num;
+ uint16_t old_num;
+
+ new_num = (size + bytes_per_cluster - 1) / bytes_per_cluster;
+ old_num = (ao_file_dirent.size + bytes_per_cluster - 1) / bytes_per_cluster;
+ if (new_num < old_num) {
+ uint16_t last_cluster;
+
+ printf("Remove %d clusters\n", old_num - new_num);
+ /* Go find the last cluster we want to preserve in the file */
+ last_cluster = ao_fat_cluster_seek(ao_file_dirent.cluster, new_num - 1);
+
+ printf ("Last cluster is now %04x\n", last_cluster);
+ /* Rewrite that cluster entry with 0xffff to mark the end of the chain */
+ clear_cluster = ao_fat_entry_replace(last_cluster, 0xffff);
+ } else if (new_num > old_num) {
+ uint16_t need;
+ uint16_t free;
+ uint16_t last_cluster;
+
+ if (old_num)
+ last_cluster = ao_fat_cluster_seek(ao_file_dirent.cluster, old_num - 1);
+ else
+ last_cluster = 0;
+
+ need = new_num - old_num;
+ printf ("Need %d clusters\n", need);
+ /* See if there are enough free clusters in the file system */
+ for (free = 2; need > 0 && (free - 2) < sectors_per_fat * 256; free++) {
+ if (!ao_fat_entry_read(free)) {
+ printf ("\tCluster %04x available\n", free);
+ need--;
+ }
+ }
+ /* Still need some, tell the user that we've failed */
+ if (need) {
+ printf ("File system full\n");
+ return 0;
+ }
+
+ need = new_num - old_num;
+ /* Now go allocate those clusters */
+ for (free = 2; need > 0 && (free - 2) < sectors_per_fat * 256; free++) {
+ if (!ao_fat_entry_read(free)) {
+ printf ("\tAllocate %04x\n", free);
+ if (last_cluster)
+ ao_fat_entry_replace(last_cluster, free);
+ else
+ first_cluster = free;
+ last_cluster = free;
+ need--;
+ }
+ }
+ /* Mark the new end of the chain */
+ ao_fat_entry_replace(last_cluster, 0xffff);
+ }
+ }
+
+ /* Deallocate clusters off the end of the file */
+ if (ao_fat_cluster_valid(clear_cluster)) {
+ printf ("Clear clusters starting with %04x\n", clear_cluster);
+ ao_fat_clear_cluster_chain(clear_cluster);
+ }
+
+ dent = ao_fat_root_get(ao_file_dirent.entry);
+ if (!dent)
+ return 0;
+ put_u32(dent + 0x1c, size);
+ put_u16(dent + 0x1a, first_cluster);
+ ao_fat_root_put(dent, ao_file_dirent.entry, 1);
+ ao_file_dirent.size = size;
+ ao_file_dirent.cluster = first_cluster;
+ return 1;
+}
+
+uint8_t
+ao_fat_creat(char name[11])
+{
+ uint16_t entry;
+
+ if (ao_fat_open(name))
+ return ao_fat_set_size(0);
+
+ for (entry = 0; entry < root_entries; entry++) {
+ uint8_t *dent = ao_fat_root_get(entry);
+
+ if (dent[0] == AO_FAT_DENT_EMPTY ||
+ dent[0] == AO_FAT_DENT_END) {
+ memmove(dent, name, 11);
+ dent[0x0b] = 0x00;
+ dent[0x0c] = 0x00;
+ dent[0x0d] = 0x00;
+ /* XXX fix time */
+ put_u16(dent + 0x0e, 0);
+ /* XXX fix date */
+ put_u16(dent + 0x10, 0);
+ /* XXX fix date */
+ put_u16(dent + 0x12, 0);
+ /* XXX FAT32 high cluster bytes */
+ put_u16(dent + 0x14, 0);
+ /* XXX fix time */
+ put_u16(dent + 0x16, 0);
+ /* XXX fix date */
+ put_u16(dent + 0x18, 0);
+ /* cluster number */
+ put_u16(dent + 0x1a, 0);
+ /* size */
+ put_u32(dent + 0x1c, 0);
+ ao_fat_root_put(dent, entry, 1);
+ return ao_fat_open(name);
+ }
+ }
+ return 0;
+}
+
+void
+ao_fat_close(void)
+{
+ memset(&ao_file_dirent, '\0', sizeof (struct ao_fat_dirent));
+ ao_bufio_flush();
+}
+
+int
+ao_fat_read(uint8_t *dest, int len)
+{
+ uint32_t sector;
+ uint16_t this_time;
+ uint16_t offset;
+ uint8_t *buf;
+ int ret = 0;
+
+ if (ao_file_offset + len > ao_file_dirent.size)
+ len = ao_file_dirent.size - ao_file_offset;
+
+ while (len) {
+ offset = ao_file_offset & 0x1ff;
+ if (offset + len < 512)
+ this_time = len;
+ else
+ this_time = 512 - offset;
+
+ sector = ao_file_offset_to_sector(ao_file_offset);
+ if (sector == 0xffffffff)
+ break;
+ buf = ao_fat_block_get(sector);
+ if (!buf)
+ break;
+ memcpy(dest, buf + offset, this_time);
+ ao_fat_block_put(buf, 0);
+
+ ret += this_time;
+ len -= this_time;
+ dest += this_time;
+ ao_file_offset += this_time;
+ }
+ return ret;
+}
+
+int
+ao_fat_write(uint8_t *src, int len)
+{
+ uint32_t sector;
+ uint16_t this_time;
+ uint16_t offset;
+ uint8_t *buf;
+ int ret = 0;
+
+ if (ao_file_offset + len > ao_file_dirent.size) {
+ if (!ao_fat_set_size(ao_file_offset + len))
+ return 0;
+ }
+
+ while (len) {
+ offset = ao_file_offset & 0x1ff;
+ if (offset + len < 512)
+ this_time = len;
+ else
+ this_time = 512 - offset;
+
+ sector = ao_file_offset_to_sector(ao_file_offset);
+ if (sector == 0xffffffff)
+ break;
+ buf = ao_fat_block_get(sector);
+ if (!buf)
+ break;
+ memcpy(buf + offset, src, this_time);
+ ao_fat_block_put(buf, 1);
+
+ ret += this_time;
+ len -= this_time;
+ src += this_time;
+ ao_file_offset += this_time;
+ }
+ return 0;
+}
+
+uint32_t
+ao_fat_seek(int32_t pos, uint8_t whence)
+{
+ switch (whence) {
+ case AO_FAT_SEEK_SET:
+ ao_file_offset = pos;
+ break;
+ case AO_FAT_SEEK_CUR:
+ ao_file_offset += pos;
+ break;
+ case AO_FAT_SEEK_END:
+ ao_file_offset = ao_file_dirent.size + pos;
+ break;
+ }
+ if (ao_file_offset > ao_file_dirent.size)
+ ao_fat_set_size(ao_file_offset);
+ return ao_file_offset;
+}
+
+uint8_t
+ao_fat_unlink(char name[11])
+{
+ uint16_t entry = 0;
+ struct ao_fat_dirent dirent;
+
+ while (ao_fat_readdir(&entry, &dirent)) {
+ if (memcmp(name, dirent.name, 11) == 0) {
+ uint8_t *next;
+ uint8_t *ent;
+ uint8_t delete;
+ ao_fat_clear_cluster_chain(dirent.cluster);
+ next = ao_fat_root_get(dirent.entry + 1);
+ if (next && next[0] != AO_FAT_DENT_END)
+ delete = AO_FAT_DENT_EMPTY;
+ else
+ delete = AO_FAT_DENT_END;
+ if (next)
+ ao_fat_root_put(next, dirent.entry + 1, 0);
+ ent = ao_fat_root_get(dirent.entry);
+ if (ent) {
+ memset(ent, '\0', 0x20);
+ *ent = delete;
+ ao_fat_root_put(ent, dirent.entry, 1);
+ }
+ ao_bufio_flush();
+ return 1;
+ }
+ }
+ return 0;
+}
+
+uint8_t
+ao_fat_rename(char old[11], char new[11])
+{
+ return 0;
+}
+
+uint8_t
+ao_fat_readdir(uint16_t *entry, struct ao_fat_dirent *dirent)
+{
+ uint8_t *dent;
+
+ if (*entry >= root_entries)
+ return 0;
+ for (;;) {
+ dent = ao_fat_root_get(*entry);
+
+ if (dent[0] == AO_FAT_DENT_END) {
+ ao_fat_root_put(dent, *entry, 0);
+ return 0;
+ }
+ if (dent[0] != AO_FAT_DENT_EMPTY &&
+ (dent[0x0b] & (AO_FAT_FILE_DIRECTORY|AO_FAT_FILE_VOLUME_LABEL)) == 0)
+ break;
+ ao_fat_root_put(dent, *entry, 0);
+ (*entry)++;
+ }
+ memcpy(dirent->name, dent, 11);
+ dirent->attr = dent[0xb];
+ dirent->size = get_u32(dent+0x1c);
+ dirent->cluster = get_u16(dent+0x1a);
+ dirent->entry = *entry;
+ ao_fat_root_put(dent, *entry, 0);
+ (*entry)++;
+ return 1;
+}
+
+static void
+ao_fat_list(void)
+{
+ uint16_t entry = 0;
+ struct ao_fat_dirent dirent;
+
+ while (ao_fat_readdir(&entry, &dirent)) {
+ printf ("%-8.8s.%-3.3s %02x %d\n",
+ dirent.name, dirent.name + 8, dirent.attr, dirent.size);
+ }
+}
+
+static void
+ao_fat_test(void)
+{
+ ao_fat_setup();
+ ao_fat_list();
+}
+
+static const struct ao_cmds ao_fat_cmds[] = {
+ { ao_fat_test, "F\0Test FAT" },
+ { 0, NULL },
+};
+
+void
+ao_fat_init(void)
+{
+ ao_bufio_init();
+ ao_cmd_register(&ao_fat_cmds[0]);
+}
+
projects / fw / altos / blobdiff