start testing fatfs

avr/usbload/Makefile

@@ -30,11 +30,16 @@ SIZE    = avr-size
 ifeq ($(DEBUG),1)
     LDFLAGS =  -Wl,-u,vfprintf -lprintf_flt 
     CFLAGS  = -Iusbdrv -I. -DDEBUG_LEVEL=0 
-    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o  main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o dump.o timer.o watchdog.o rle.c loader.o info.o shared_memory.o mmc.o fat.o
+    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o \
+               main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o \
+               dump.o timer.o watchdog.o rle.c loader.o info.o shared_memory.o \
+               command.o testing.o rtc.o mmc.o ff.o
 else 
     LDFLAGS =  -Wl,-u
     CFLAGS  = -Iusbdrv -I. -DDEBUG_LEVEL=0 -DNO_DEBUG -DNO_INFO
-    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o  main.o usb_bulk.o uart.o fifo.o sram.o crc.o debug.o dump.o timer.o watchdog.o rle.c loader.o info.o shared_memory.o
+    OBJECTS = usbdrv/usbdrv.o usbdrv/usbdrvasm.o usbdrv/oddebug.o  main.o usb_bulk.o \
+              uart.o fifo.o sram.o crc.o debug.o dump.o timer.o watchdog.o rle.c loader.o \
+              info.o shared_memory.o command.o
 endif
 
 COMPILE = avr-gcc -Wall -Os -DF_CPU=$(F_CPU) $(CFLAGS) -mmcu=$(DEVICE)

avr/usbload/command.c

@@ -0,0 +1,61 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+#include <avr/io.h>
+#include <util/delay.h>         
+#include <stdlib.h>
+
+#include "config.h"
+#include "requests.h"           
+#include "sram.h"
+#include "info.h"
+
+extern uint32_t req_bank_size;
+
+
+void send_reset()
+{
+    info("Reset Snes\n");
+    snes_reset_on();
+    snes_reset_lo();
+    _delay_ms(2);
+    snes_reset_hi();
+    snes_reset_off();
+}
+
+void send_irq()
+{
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+}
+
+void set_rom_mode()
+{
+    if (req_bank_size == 0x8000) {
+        snes_lorom();
+        info("Set Snes lowrom \n");
+    } else {
+        snes_hirom();
+        info("Set Snes hirom \n");
+    }
+}

avr/usbload/command.h

@@ -0,0 +1,29 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __COMMAND_H__
+#define __COMMAND_H__
+
+void send_reset();
+void send_irq();
+void set_rom_mode();
+
+#endif

avr/usbload/config.h

@@ -29,6 +29,7 @@
 #define DEBUG_SRAM_RAW              16
 #define DEBUG_SREG                  32
 #define DEBUG_CRC                   64
+#define DEBUG_SHM                   128
 
 #define REQ_STATUS_IDLE             0x01
 #define REQ_STATUS_UPLOAD           0x02

avr/usbload/crc.c

@@ -91,31 +91,13 @@ uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t top_addr, uint32_t
 
 
 
-void crc_check_memory(uint32_t bottom_addr,uint32_t top_addr,uint32_t bank_size,uint8_t *buffer)
-{
-    uint16_t crc = 0;
-    uint32_t addr;
-    uint8_t req_bank = 0;
-    for (addr = bottom_addr; addr < top_addr; addr += TRANSFER_BUFFER_SIZE) {
-        if (addr && addr % bank_size == 0) {
-            debug(DEBUG_CRC,"crc_check_memory: bank=0x%02x addr=0x%08lx crc=0x%04x\n",
-                req_bank,addr,crc);
-            req_bank++;
-            crc = 0;
-        }
-        sram_read_buffer(addr, buffer, TRANSFER_BUFFER_SIZE);
-        crc = do_crc_update(crc, buffer, TRANSFER_BUFFER_SIZE);
-    }
-}
-
-
 
 uint16_t crc_check_memory_range(uint32_t start_addr, uint32_t size,uint8_t *buffer)
 {
     uint16_t crc = 0;
     uint32_t addr;
     for (addr = start_addr; addr < start_addr + size; addr += TRANSFER_BUFFER_SIZE) {
-        sram_read_buffer(addr, buffer, TRANSFER_BUFFER_SIZE);
+        sram_bulk_read_buffer(addr, buffer, TRANSFER_BUFFER_SIZE);
         crc = do_crc_update(crc, buffer, TRANSFER_BUFFER_SIZE);
     }
     return crc;

avr/usbload/crc.h

@@ -29,7 +29,6 @@
 uint16_t crc_xmodem_update(uint16_t crc, uint8_t data);
 uint16_t do_crc(uint8_t * data,uint16_t size);
 uint16_t do_crc_update(uint16_t crc,uint8_t * data,uint16_t size);
-void crc_check_memory(uint32_t bottom_addr,uint32_t top_addr,uint32_t bank_size,uint8_t *buffer);
 uint16_t crc_check_memory_range(uint32_t start_addr, uint32_t size,uint8_t *buffer);
 uint16_t crc_check_bulk_memory(uint32_t bottom_addr, uint32_t bank_size,uint32_t top_addr);
 

avr/usbload/diskio.h

@@ -0,0 +1,81 @@
+/*-----------------------------------------------------------------------
+/  Low level disk interface modlue include file  R0.05   (C)ChaN, 2007
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO
+
+#define _READONLY	0	/* 1: Read-only mode */
+#define _USE_IOCTL	1
+
+#include "integer.h"
+
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+DSTATUS disk_initialize (BYTE);
+DSTATUS disk_status (BYTE);
+DRESULT disk_read (BYTE, BYTE*, DWORD, BYTE);
+#if	_READONLY == 0
+DRESULT disk_write (BYTE, const BYTE*, DWORD, BYTE);
+#endif
+DRESULT disk_ioctl (BYTE, BYTE, void*);
+void	disk_timerproc (void);
+
+
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+
+/* Command code for disk_ioctrl() */
+
+/* Generic command */
+#define CTRL_SYNC			0	/* Mandatory for write functions */
+#define GET_SECTOR_COUNT	1	/* Mandatory for only f_mkfs() */
+#define GET_SECTOR_SIZE		2
+#define GET_BLOCK_SIZE		3	/* Mandatory for only f_mkfs() */
+#define CTRL_POWER			4
+#define CTRL_LOCK			5
+#define CTRL_EJECT			6
+/* MMC/SDC command */
+#define MMC_GET_TYPE		10
+#define MMC_GET_CSD			11
+#define MMC_GET_CID			12
+#define MMC_GET_OCR			13
+#define MMC_GET_SDSTAT		14
+/* ATA/CF command */
+#define ATA_GET_REV			20
+#define ATA_GET_MODEL		21
+#define ATA_GET_SN			22
+
+
+
+/* Card type flags (CardType) */
+#define CT_MMC				0x01
+#define CT_SD1				0x02
+#define CT_SD2				0x04
+#define CT_SDC				(CT_SD1|CT_SD2)
+#define CT_BLOCK			0x08
+
+
+#define _DISKIO
+#endif

avr/usbload/dump.h

@@ -31,4 +31,4 @@ void dump_memory(uint32_t bottom_addr, uint32_t top_addr);
 void dump_packet(uint32_t addr,uint32_t len,uint8_t *packet);
 
 #endif 
-        
+

avr/usbload/fat.c

@@ -1,192 +0,0 @@
-#include "fat.h"
-
-uint8_t cluster_size;
-uint16_t fat_offset;
-uint16_t cluster_offset;
-uint16_t volume_boot_record_addr;
-
-void fat_init(uint8_t * Buffer)
-{
-    struct BootSec *bootp;
-    mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
-    if (Buffer[510] == 0x55 && Buffer[511] == 0xAA) {
-        FAT_DEBUG("MBR Signatur found!\r\n");
-    }
-
-    else {
-        FAT_DEBUG("MBR Signatur not found!\r\n");
-        while (1);
-    }
-    volume_boot_record_addr = Buffer[VBR_ADDR] + (Buffer[VBR_ADDR + 1] << 8);
-    mmc_read_sector(volume_boot_record_addr, Buffer);
-    if (Buffer[510] == 0x55 && Buffer[511] == 0xAA) {
-        FAT_DEBUG("VBR Signatur found!\r\n");
-    }
-
-    else {
-        FAT_DEBUG("VBR Signatur not found!\r\n");
-        volume_boot_record_addr = MASTER_BOOT_RECORD;
-        mmc_read_sector(MASTER_BOOT_RECORD, Buffer);
-    }
-    bootp = (struct BootSec *) Buffer;
-    cluster_size = bootp->BPB_SecPerClus;
-    fat_offset = bootp->BPB_RsvdSecCnt;
-    cluster_offset = ((bootp->BPB_BytesPerSec * 32) / BlockSize);
-    cluster_offset += fat_root_dir_addr(Buffer);
-}
-
-uint16_t fat_root_dir_addr(uint8_t * Buffer)
-{
-    struct BootSec *bootp;
-    uint16_t FirstRootDirSecNum;
-
-
-    mmc_read_sector(volume_boot_record_addr, Buffer);
-    bootp = (struct BootSec *) Buffer;
-
-
-    FirstRootDirSecNum = (bootp->BPB_RsvdSecCnt +
-                          (bootp->BPB_NumFATs * bootp->BPB_FATSz16));
-    FirstRootDirSecNum += volume_boot_record_addr;
-    return (FirstRootDirSecNum);
-}
-
-
-uint16_t fat_read_dir_ent(uint16_t dir_cluster,
-                          uint8_t Entry_Count,
-                          uint32_t * Size,
-                          uint8_t * Dir_Attrib, uint8_t * Buffer)
-{
-    uint8_t *pointer;
-    uint16_t TMP_Entry_Count = 0;
-    uint32_t Block = 0;
-    struct DirEntry *dir;
-    uint16_t blk;
-    uint16_t a;
-    uint8_t b;
-    pointer = Buffer;
-    if (dir_cluster == 0) {
-        Block = fat_root_dir_addr(Buffer);
-    }
-
-    else {
-        fat_load(dir_cluster, &Block, Buffer);
-        Block = ((Block - 2) * cluster_size) + cluster_offset;
-    }
-
-
-    for (blk = Block;; blk++) {
-        mmc_read_sector(blk, Buffer);
-        for (a = 0; a < BlockSize; a = a + 32) {
-            dir = (struct DirEntry *) &Buffer[a];
-            if (dir->DIR_Name[0] == 0) {
-                return (0xFFFF);
-            }
-
-            if ((dir->DIR_Attr != ATTR_LONG_NAME) &&
-                (dir->DIR_Name[0] != DIR_ENTRY_IS_FREE)) {
-
-
-                if (TMP_Entry_Count == Entry_Count) {
-
-
-                    for (b = 0; b < 11; b++) {
-                        if (dir->DIR_Name[b] != SPACE) {
-                            if (b == 8) {
-                                *pointer++ = '.';
-                            }
-                            *pointer++ = dir->DIR_Name[b];
-                        }
-                    }
-                    *pointer++ = '\0';
-                    *Dir_Attrib = dir->DIR_Attr;
-
-
-                    *Size = dir->DIR_FileSize;
-
-
-                    dir_cluster = dir->DIR_FstClusLO;
-
-
-                    return (dir_cluster);
-                }
-                TMP_Entry_Count++;
-            }
-        }
-    }
-    return (0xFFFF);
-}
-
-void fat_load(uint16_t Cluster, uint32_t * Block, uint8_t * TMP_Buffer)
-{
-    uint16_t FAT_Block_Store = 0;
-    uint16_t FAT_Byte_Addresse;
-    uint16_t FAT_Block_Addresse;
-    uint16_t a;
-
-    for (a = 0;; a++) {
-        if (a == *Block) {
-            *Block = (0x0000FFFF & Cluster);
-            return;
-        }
-        if (Cluster == 0xFFFF) {
-            break;
-        }
-
-        FAT_Byte_Addresse = (Cluster * 2) % BlockSize;
-
-
-        FAT_Block_Addresse =
-            ((Cluster * 2) / BlockSize) + volume_boot_record_addr + fat_offset;
-
-        if (FAT_Block_Addresse != FAT_Block_Store) {
-            FAT_Block_Store = FAT_Block_Addresse;
-            mmc_read_sector(FAT_Block_Addresse, TMP_Buffer);
-        }
-        Cluster =
-            (TMP_Buffer[FAT_Byte_Addresse + 1] << 8) +
-            TMP_Buffer[FAT_Byte_Addresse];
-    }
-    return;
-}
-
-void fat_read_file(uint16_t Cluster, uint8_t * Buffer, uint32_t BlockCount)
-{
-
-    uint32_t Block = (BlockCount / cluster_size);
-    fat_load(Cluster, &Block, Buffer);
-    Block = ((Block - 2) * cluster_size) + cluster_offset;
-    Block += (BlockCount % cluster_size);
-    mmc_read_sector(Block, Buffer);
-    return;
-}
-
-void fat_write_file(uint16_t cluster, uint8_t * buffer, uint32_t blockCount)
-{
-    uint8_t tmp_buffer[513];
-    uint32_t block = (blockCount / cluster_size);
-    fat_load(cluster, &block, tmp_buffer);
-    block = ((block - 2) * cluster_size) + cluster_offset;
-    block += (blockCount % cluster_size);
-    mmc_write_sector(block, buffer);
-    return;
-}
-
-uint8_t fat_search_file(uint8_t * File_Name,
-                        uint16_t * Cluster,
-                        uint32_t * Size, uint8_t * Dir_Attrib, uint8_t * Buffer)
-{
-    uint16_t Dir_Cluster_Store = *Cluster;
-    uint8_t a;
-    for (a = 0; a < 100; a++) {
-        *Cluster =
-            fat_read_dir_ent(Dir_Cluster_Store, a, Size, Dir_Attrib, Buffer);
-        if (*Cluster == 0xffff) {
-            return (0);
-        }
-        if (strcasecmp((char *) File_Name, (char *) Buffer) == 0) {
-            return (1);
-        }
-    }
-    return (2);
-}

avr/usbload/fat.h

@@ -1,103 +0,0 @@
-/*
- */
-
-#ifndef _FAT_H_
-#define _FAT_H_
-#include <string.h>
-#include "mmc.h"
-#include "uart.h"
-
-#define FAT_DEBUG	uart_puts
-
-
-
-extern uint16_t fat_root_dir_addr(uint8_t *);
-extern uint16_t fat_read_dir_ent(uint16_t, uint8_t,
-                                 uint32_t *, uint8_t *, uint8_t *);
-extern void fat_load(uint16_t, uint32_t *, uint8_t *);
-extern void fat_read_file(uint16_t, uint8_t *, uint32_t);
-extern void fat_write_file(uint16_t, uint8_t *, uint32_t);
-extern void fat_init(uint8_t * Buffer);
-extern uint8_t fat_search_file(uint8_t *, uint16_t *,
-                               uint32_t *, uint8_t *, uint8_t *);
-
-
-#define BlockSize			512
-
-
-#define MASTER_BOOT_RECORD	0
-
-
-#define VBR_ADDR 			0x1C6
-
-
-#define SPACE 				0x20
-#define DIR_ENTRY_IS_FREE   0xE5
-#define FIRST_LONG_ENTRY	0x01
-#define SECOND_LONG_ENTRY	0x42
-
-
-#define ATTR_LONG_NAME		0x0F
-#define ATTR_READ_ONLY		0x01
-#define ATTR_HIDDEN			0x02
-#define ATTR_SYSTEM			0x04
-#define ATTR_VOLUME_ID		0x08
-#define ATTR_DIRECTORY		0x10
-#define ATTR_ARCHIVE		0x20
-struct BootSec {
-    uint8_t BS_jmpBoot[3];
-    uint8_t BS_OEMName[8];
-    uint16_t BPB_BytesPerSec;
-    uint8_t BPB_SecPerClus;
-    uint16_t BPB_RsvdSecCnt;
-    uint8_t BPB_NumFATs;
-    uint16_t BPB_RootEntCnt;
-    uint16_t BPB_TotSec16;
-    uint8_t BPB_Media;
-    uint16_t BPB_FATSz16;
-    uint16_t BPB_SecPerTrk;
-    uint16_t BPB_NumHeads;
-    uint32_t BPB_HiddSec;
-    uint32_t BPB_TotSec32;
-};
-
-
-#define BS_DRVNUM			36
-#define BS_RESERVED1		37
-#define BS_BOOTSIG			38
-#define BS_VOLID			39
-#define BS_VOLLAB			43
-#define BS_FILSYSTYPE		54
-
-
-#define BPB_FATSZ32			36
-#define BPB_EXTFLAGS		40
-#define BPB_FSVER			42
-#define BPB_ROOTCLUS		44
-#define BPB_FSINFO			48
-#define BPB_BKBOOTSEC		50
-#define BPB_RESERVED		52
-
-#define FAT32_BS_DRVNUM		64
-#define FAT32_BS_RESERVED1	65
-#define FAT32_BS_BOOTSIG	66
-#define FAT32_BS_VOLID		67
-#define FAT32_BS_VOLLAB		71
-#define FAT32_BS_FILSYSTYPE	82
-
-struct DirEntry {
-    uint8_t DIR_Name[11];
-    uint8_t DIR_Attr;
-    uint8_t DIR_NTRes;
-    uint8_t DIR_CrtTimeTenth;
-    uint16_t DIR_CrtTime;
-    uint16_t DIR_CrtDate;
-    uint16_t DIR_LastAccDate;
-    uint16_t DIR_FstClusHI;
-    uint16_t DIR_WrtTime;
-    uint16_t DIR_WrtDate;
-    uint16_t DIR_FstClusLO;
-    uint32_t DIR_FileSize;
-};
-
-#endif

avr/usbload/ff.h

@@ -0,0 +1,547 @@
+/*---------------------------------------------------------------------------/
+/  FatFs - FAT file system module include file  R0.07a       (C)ChaN, 2009
+/----------------------------------------------------------------------------/
+/ FatFs module is an open source software to implement FAT file system to
+/ small embedded systems. This is a free software and is opened for education,
+/ research and commercial developments under license policy of following trems.
+/
+/  Copyright (C) 2009, ChaN, all right reserved.
+/
+/ * The FatFs module is a free software and there is NO WARRANTY.
+/ * No restriction on use. You can use, modify and redistribute it for
+/   personal, non-profit or commercial use UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/----------------------------------------------------------------------------*/
+
+#include "integer.h"
+
+/*---------------------------------------------------------------------------/
+/ FatFs Configuration Options
+/
+/ CAUTION! Do not forget to make clean the project after any changes to
+/ the configuration options.
+/
+/----------------------------------------------------------------------------*/
+#ifndef _FATFS
+#define _FATFS
+
+#define _WORD_ACCESS	1
+/* The _WORD_ACCESS option defines which access method is used to the word
+/  data in the FAT structure.
+/
+/   0: Byte-by-byte access. Always compatible with all platforms.
+/   1: Word access. Do not choose this unless following condition is met.
+/
+/  When the byte order on the memory is big-endian or address miss-aligned
+/  word access results incorrect behavior, the _WORD_ACCESS must be set to 0.
+/  If it is not the case, the value can also be set to 1 to improve the
+/  performance and code efficiency. */
+
+
+#define _FS_READONLY	0
+/* Setting _FS_READONLY to 1 defines read only configuration. This removes
+/  writing functions, f_write, f_sync, f_unlink, f_mkdir, f_chmod, f_rename,
+/  f_truncate and useless f_getfree. */
+
+
+#define _FS_MINIMIZE	0
+/* The _FS_MINIMIZE option defines minimization level to remove some functions.
+/
+/   0: Full function.
+/   1: f_stat, f_getfree, f_unlink, f_mkdir, f_chmod, f_truncate and f_rename
+/      are removed.
+/   2: f_opendir and f_readdir are removed in addition to level 1.
+/   3: f_lseek is removed in addition to level 2. */
+
+
+#define	_FS_TINY	1
+/* When _FS_TINY is set to 1, FatFs uses the sector buffer in the file system
+/  object instead of the sector buffer in the individual file object for file
+/  data transfer. This reduces memory consumption 512 bytes each file object. */
+
+
+#define	_USE_STRFUNC	0
+/* To enable string functions, set _USE_STRFUNC to 1 or 2. */
+
+
+#define	_USE_MKFS	1
+/* To enable f_mkfs function, set _USE_MKFS to 1 and set _FS_READONLY to 0 */
+
+
+#define	_USE_FORWARD	0
+/* To enable f_forward function, set _USE_FORWARD to 1 and set _FS_TINY to 1. */
+
+
+#define _DRIVES		2
+/* Number of volumes (logical drives) to be used. */
+
+
+#define	_MAX_SS	512
+/* Maximum sector size to be handled. (512/1024/2048/4096) */
+/* 512 for memroy card and hard disk, 1024 for floppy disk, 2048 for MO disk */
+
+
+#define	_MULTI_PARTITION	0
+/* When _MULTI_PARTITION is set to 0, each volume is bound to the same physical
+/ drive number and can mount only first primaly partition. When it is set to 1,
+/ each volume is tied to the partitions listed in Drives[]. */
+
+
+#define _CODE_PAGE	437
+/* The _CODE_PAGE specifies the OEM code page to be used on the target system.
+/  When it is non LFN configuration, there is no difference between SBCS code
+/  pages. When LFN is enabled, the code page must always be set correctly.
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   775 - Baltic
+/   850 - Multilingual Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   858 - Multilingual Latin 1 + Euro
+/   862 - Hebrew
+/   866 - Russian
+/   874 - Thai
+/   932 - Japanese Shift-JIS       (DBCS)
+/   936 - Simplified Chinese GBK   (DBCS)
+/   949 - Korean                   (DBCS)
+/   950 - Traditional Chinese Big5 (DBCS)
+/   1258 - Vietnam
+*/
+
+
+#define	_USE_LFN	0
+#define	_MAX_LFN	255		/* Maximum LFN length to handle (max:255) */
+/* The _USE_LFN option switches the LFN support.
+/
+/   0: Disable LFN.
+/   1: Enable LFN with static working buffer on the bss. NOT REENTRANT.
+/   2: Enable LFN with dynamic working buffer on the caller's STACK.
+/
+/  The working buffer occupies (_MAX_LFN + 1) * 2 bytes. When enable LFN,
+/  a Unicode - OEM code conversion function ff_convert() must be added to
+/  the project. */
+
+
+#define _FS_REENTRANT	0
+#define _TIMEOUT		1000	/* Timeout period in unit of time ticks */
+#define	_SYNC_t			HANDLE	/* Type of sync object used on the OS. */
+								/* e.g. HANDLE, OS_EVENT*, ID and etc.. */
+/* To make the FatFs module re-entrant, set _FS_REENTRANT to 1 and add user
+/  provided synchronization handlers, ff_req_grant, ff_rel_grant,
+/  ff_del_syncobj and ff_cre_syncobj function to the project. */
+
+
+
+/* End of configuration options. Do not change followings without care.     */
+/*--------------------------------------------------------------------------*/
+
+
+
+/* Definitions corresponds to multiple sector size */
+
+#if _MAX_SS == 512
+#define	SS(fs)	512
+#else
+#if _MAX_SS == 1024 || _MAX_SS == 2048 || _MAX_SS == 4096
+#define	SS(fs)	((fs)->s_size)
+#else
+#error Sector size must be 512, 1024, 2048 or 4096.
+#endif
+#endif
+
+
+
+/* File system object structure */
+
+typedef struct _FATFS {
+	BYTE	fs_type;	/* FAT sub type */
+	BYTE	drive;		/* Physical drive number */
+	BYTE	csize;		/* Number of sectors per cluster */
+	BYTE	n_fats;		/* Number of FAT copies */
+	BYTE	wflag;		/* win[] dirty flag (1:must be written back) */
+	BYTE	pad1;
+	WORD	id;			/* File system mount ID */
+	WORD	n_rootdir;	/* Number of root directory entries (0 on FAT32) */
+#if _FS_REENTRANT
+	_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
+#if _MAX_SS != 512U
+	WORD	s_size;		/* Sector size */
+#endif
+#if !_FS_READONLY
+	BYTE	fsi_flag;	/* fsinfo dirty flag (1:must be written back) */
+	BYTE	pad2;
+	DWORD	last_clust;	/* Last allocated cluster */
+	DWORD	free_clust;	/* Number of free clusters */
+	DWORD	fsi_sector;	/* fsinfo sector */
+#endif
+	DWORD	sects_fat;	/* Sectors per fat */
+	DWORD	max_clust;	/* Maximum cluster# + 1. Number of clusters is max_clust - 2 */
+	DWORD	fatbase;	/* FAT start sector */
+	DWORD	dirbase;	/* Root directory start sector (Cluster# on FAT32) */
+	DWORD	database;	/* Data start sector */
+	DWORD	winsect;	/* Current sector appearing in the win[] */
+	BYTE	win[_MAX_SS];/* Disk access window for Directory/FAT */
+} FATFS;
+
+
+
+/* Directory object structure */
+
+typedef struct _DIR {
+	WORD	id;			/* Owner file system mount ID */
+	WORD	index;		/* Current index number */
+	FATFS*	fs;			/* Pointer to the owner file system object */
+	DWORD	sclust;		/* Table start cluster (0:Static table) */
+	DWORD	clust;		/* Current cluster */
+	DWORD	sect;		/* Current sector */
+	BYTE*	dir;		/* Pointer to the current SFN entry in the win[] */
+	BYTE*	fn;			/* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
+#if _USE_LFN
+	WCHAR*	lfn;		/* Pointer to the LFN working buffer */
+	WORD	lfn_idx;	/* Last matched LFN index (0xFFFF:No LFN) */
+#endif
+} DIR;
+
+
+
+/* File object structure */
+
+typedef struct _FIL {
+	FATFS*	fs;			/* Pointer to the owner file system object */
+	WORD	id;			/* Owner file system mount ID */
+	BYTE	flag;		/* File status flags */
+	BYTE	csect;		/* Sector address in the cluster */
+	DWORD	fptr;		/* File R/W pointer */
+	DWORD	fsize;		/* File size */
+	DWORD	org_clust;	/* File start cluster */
+	DWORD	curr_clust;	/* Current cluster */
+	DWORD	dsect;		/* Current data sector */
+#if !_FS_READONLY
+	DWORD	dir_sect;	/* Sector containing the directory entry */
+	BYTE*	dir_ptr;	/* Ponter to the directory entry in the window */
+#endif
+#if !_FS_TINY
+	BYTE	buf[_MAX_SS];/* File R/W buffer */
+#endif
+} FIL;
+
+
+
+/* File status structure */
+
+typedef struct _FILINFO {
+	DWORD fsize;		/* File size */
+	WORD fdate;			/* Last modified date */
+	WORD ftime;			/* Last modified time */
+	BYTE fattrib;		/* Attribute */
+	char fname[13];		/* Short file name (8.3 format) */
+#if _USE_LFN
+	char *lfname;		/* Pointer to the LFN buffer */
+	int lfsize;			/* Size of LFN buffer [bytes] */
+#endif
+} FILINFO;
+
+
+
+/* DBCS code ranges */
+
+#if _CODE_PAGE == 932	/* CP932 (Japanese Shift-JIS) */
+#define _DF1S	0x81	/* DBC 1st byte range 1 start */
+#define _DF1E	0x9F	/* DBC 1st byte range 1 end */
+#define _DF2S	0xE0	/* DBC 1st byte range 2 start */
+#define _DF2E	0xFC	/* DBC 1st byte range 2 end */
+#define _DS1S	0x40	/* DBC 2nd byte range 1 start */
+#define _DS1E	0x7E	/* DBC 2nd byte range 1 end */
+#define _DS2S	0x80	/* DBC 2nd byte range 2 start */
+#define _DS2E	0xFC	/* DBC 2nd byte range 2 end */
+
+#elif _CODE_PAGE == 936	/* CP936 (Simplified Chinese GBK) */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0x80
+#define _DS2E	0xFE
+
+#elif _CODE_PAGE == 949	/* CP949 (Korean) */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x41
+#define _DS1E	0x5A
+#define _DS2S	0x61
+#define _DS2E	0x7A
+#define _DS3S	0x81
+#define _DS3E	0xFE
+
+#elif _CODE_PAGE == 950	/* CP950 (Traditional Chinese Big5) */
+#define _DF1S	0x81
+#define _DF1E	0xFE
+#define _DS1S	0x40
+#define _DS1E	0x7E
+#define _DS2S	0xA1
+#define _DS2E	0xFE
+
+#else					/* SBCS code pages */
+#define _DF1S	0
+
+#endif
+
+
+
+/* Character code support macros */
+
+#define IsUpper(c)	(((c)>='A')&&((c)<='Z'))
+#define IsLower(c)	(((c)>='a')&&((c)<='z'))
+#define IsDigit(c)	(((c)>='0')&&((c)<='9'))
+
+#if _DF1S	/* DBCS configuration */
+
+#if _DF2S	/* Two 1st byte areas */
+#define IsDBCS1(c)	(((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E) || ((BYTE)(c) >= _DF2S && (BYTE)(c) <= _DF2E))
+#else		/* One 1st byte area */
+#define IsDBCS1(c)	((BYTE)(c) >= _DF1S && (BYTE)(c) <= _DF1E)
+#endif
+
+#if _DS3S	/* Three 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E) || ((BYTE)(c) >= _DS3S && (BYTE)(c) <= _DS3E))
+#else		/* Two 2nd byte areas */
+#define IsDBCS2(c)	(((BYTE)(c) >= _DS1S && (BYTE)(c) <= _DS1E) || ((BYTE)(c) >= _DS2S && (BYTE)(c) <= _DS2E))
+#endif
+
+#else		/* SBCS configuration */
+
+#define IsDBCS1(c)	0
+#define IsDBCS2(c)	0
+
+#endif /* _DF1S */
+
+
+
+/* Definitions corresponds to multi partition */
+
+#if _MULTI_PARTITION		/* Multiple partition configuration */
+
+typedef struct _PARTITION {
+	BYTE pd;	/* Physical drive# */
+	BYTE pt;	/* Partition # (0-3) */
+} PARTITION;
+
+extern
+const PARTITION Drives[];			/* Logical drive# to physical location conversion table */
+#define LD2PD(drv) (Drives[drv].pd)	/* Get physical drive# */
+#define LD2PT(drv) (Drives[drv].pt)	/* Get partition# */
+
+#else						/* Single partition configuration */
+
+#define LD2PD(drv) (drv)	/* Physical drive# is equal to the logical drive# */
+#define LD2PT(drv) 0		/* Always mounts the 1st partition */
+
+#endif
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,			/* 0 */
+	FR_DISK_ERR,		/* 1 */
+	FR_INT_ERR,			/* 2 */
+	FR_NOT_READY,		/* 3 */
+	FR_NO_FILE,			/* 4 */
+	FR_NO_PATH,			/* 5 */
+	FR_INVALID_NAME,	/* 6 */
+	FR_DENIED,			/* 7 */
+	FR_EXIST,			/* 8 */
+	FR_INVALID_OBJECT,	/* 9 */
+	FR_WRITE_PROTECTED,	/* 10 */
+	FR_INVALID_DRIVE,	/* 11 */
+	FR_NOT_ENABLED,		/* 12 */
+	FR_NO_FILESYSTEM,	/* 13 */
+	FR_MKFS_ABORTED,	/* 14 */
+	FR_TIMEOUT			/* 15 */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
+
+FRESULT f_mount (BYTE, FATFS*);						/* Mount/Unmount a logical drive */
+FRESULT f_open (FIL*, const char*, BYTE);			/* Open or create a file */
+FRESULT f_read (FIL*, void*, UINT, UINT*);			/* Read data from a file */
+FRESULT f_write (FIL*, const void*, UINT, UINT*);	/* Write data to a file */
+FRESULT f_lseek (FIL*, DWORD);						/* Move file pointer of a file object */
+FRESULT f_close (FIL*);								/* Close an open file object */
+FRESULT f_opendir (DIR*, const char*);				/* Open an existing directory */
+FRESULT f_readdir (DIR*, FILINFO*);					/* Read a directory item */
+FRESULT f_stat (const char*, FILINFO*);				/* Get file status */
+FRESULT f_getfree (const char*, DWORD*, FATFS**);	/* Get number of free clusters on the drive */
+FRESULT f_truncate (FIL*);							/* Truncate file */
+FRESULT f_sync (FIL*);								/* Flush cached data of a writing file */
+FRESULT f_unlink (const char*);						/* Delete an existing file or directory */
+FRESULT	f_mkdir (const char*);						/* Create a new directory */
+FRESULT f_chmod (const char*, BYTE, BYTE);			/* Change attriburte of the file/dir */
+FRESULT f_utime (const char*, const FILINFO*);		/* Change timestamp of the file/dir */
+FRESULT f_rename (const char*, const char*);		/* Rename/Move a file or directory */
+FRESULT f_forward (FIL*, UINT(*)(const BYTE*,UINT), UINT, UINT*);	/* Forward data to the stream */
+FRESULT f_mkfs (BYTE, BYTE, WORD);					/* Create a file system on the drive */
+
+#if _USE_STRFUNC
+int f_putc (int, FIL*);								/* Put a character to the file */
+int f_puts (const char*, FIL*);						/* Put a string to the file */
+int f_printf (FIL*, const char*, ...);				/* Put a formatted string to the file */
+char* f_gets (char*, int, FIL*);					/* Get a string from the file */
+#define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
+#define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
+#ifndef EOF
+#define EOF -1
+#endif
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* User defined functions                                       */
+
+/* Real time clock */
+#if !_FS_READONLY
+DWORD get_fattime (void);	/* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
+							/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
+#endif
+
+/* Unicode - OEM code conversion */
+#if _USE_LFN
+WCHAR ff_convert (WCHAR, UINT);
+#endif
+
+/* Sync functions */
+#if _FS_REENTRANT
+BOOL ff_cre_syncobj(BYTE, _SYNC_t*);
+BOOL ff_del_syncobj(_SYNC_t);
+BOOL ff_req_grant(_SYNC_t);
+void ff_rel_grant(_SYNC_t);
+#endif
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
+
+/* File access control and file status flags (FIL.flag) */
+
+#define	FA_READ				0x01
+#define	FA_OPEN_EXISTING	0x00
+#if _FS_READONLY == 0
+#define	FA_WRITE			0x02
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define FA__WRITTEN			0x20
+#define FA__DIRTY			0x40
+#endif
+#define FA__ERROR			0x80
+
+
+/* FAT sub type (FATFS.fs_type) */
+
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+
+
+/* File attribute bits for directory entry */
+
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define	AM_VOL	0x08	/* Volume label */
+#define AM_LFN	0x0F	/* LFN entry */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+#define AM_MASK	0x3F	/* Mask of defined bits */
+
+
+/* FatFs refers the members in the FAT structures with byte offset instead
+/ of structure member because there are incompatibility of the packing option
+/ between various compilers. */
+
+#define BS_jmpBoot			0
+#define BS_OEMName			3
+#define BPB_BytsPerSec		11
+#define BPB_SecPerClus		13
+#define BPB_RsvdSecCnt		14
+#define BPB_NumFATs			16
+#define BPB_RootEntCnt		17
+#define BPB_TotSec16		19
+#define BPB_Media			21
+#define BPB_FATSz16			22
+#define BPB_SecPerTrk		24
+#define BPB_NumHeads		26
+#define BPB_HiddSec			28
+#define BPB_TotSec32		32
+#define BS_55AA				510
+
+#define BS_DrvNum			36
+#define BS_BootSig			38
+#define BS_VolID			39
+#define BS_VolLab			43
+#define BS_FilSysType		54
+
+#define BPB_FATSz32			36
+#define BPB_ExtFlags		40
+#define BPB_FSVer			42
+#define BPB_RootClus		44
+#define BPB_FSInfo			48
+#define BPB_BkBootSec		50
+#define BS_DrvNum32			64
+#define BS_BootSig32		66
+#define BS_VolID32			67
+#define BS_VolLab32			71
+#define BS_FilSysType32		82
+
+#define	FSI_LeadSig			0
+#define	FSI_StrucSig		484
+#define	FSI_Free_Count		488
+#define	FSI_Nxt_Free		492
+
+#define MBR_Table			446
+
+#define	DIR_Name			0
+#define	DIR_Attr			11
+#define	DIR_NTres			12
+#define	DIR_CrtTime			14
+#define	DIR_CrtDate			16
+#define	DIR_FstClusHI		20
+#define	DIR_WrtTime			22
+#define	DIR_WrtDate			24
+#define	DIR_FstClusLO		26
+#define	DIR_FileSize		28
+#define	LDIR_Ord			0
+#define	LDIR_Attr			11
+#define	LDIR_Type			12
+#define	LDIR_Chksum			13
+#define	LDIR_FstClusLO		26
+
+
+
+/*--------------------------------*/
+/* Multi-byte word access macros  */
+
+#if _WORD_ACCESS == 1	/* Enable word access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(*(WORD*)(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(*(DWORD*)(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(WORD*)(BYTE*)(ptr)=(WORD)(val)
+#define	ST_DWORD(ptr,val)	*(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
+#else					/* Use byte-by-byte access to the FAT structure */
+#define	LD_WORD(ptr)		(WORD)(((WORD)*(BYTE*)((ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
+#define	LD_DWORD(ptr)		(DWORD)(((DWORD)*(BYTE*)((ptr)+3)<<24)|((DWORD)*(BYTE*)((ptr)+2)<<16)|((WORD)*(BYTE*)((ptr)+1)<<8)|*(BYTE*)(ptr))
+#define	ST_WORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8)
+#define	ST_DWORD(ptr,val)	*(BYTE*)(ptr)=(BYTE)(val); *(BYTE*)((ptr)+1)=(BYTE)((WORD)(val)>>8); *(BYTE*)((ptr)+2)=(BYTE)((DWORD)(val)>>16); *(BYTE*)((ptr)+3)=(BYTE)((DWORD)(val)>>24)
+#endif
+
+
+#endif /* _FATFS */

avr/usbload/integer.h

@@ -0,0 +1,37 @@
+/*-------------------------------------------*/
+/* Integer type definitions for FatFs module */
+/*-------------------------------------------*/
+
+#ifndef _INTEGER
+
+#if 0
+#include <windows.h>
+#else
+
+/* These types must be 16-bit, 32-bit or larger integer */
+typedef int				INT;
+typedef unsigned int	UINT;
+
+/* These types must be 8-bit integer */
+typedef signed char		CHAR;
+typedef unsigned char	UCHAR;
+typedef unsigned char	BYTE;
+
+/* These types must be 16-bit integer */
+typedef short			SHORT;
+typedef unsigned short	USHORT;
+typedef unsigned short	WORD;
+typedef unsigned short	WCHAR;
+
+/* These types must be 32-bit integer */
+typedef long			LONG;
+typedef unsigned long	ULONG;
+typedef unsigned long	DWORD;
+
+/* Boolean type */
+typedef enum { FALSE = 0, TRUE } BOOL;
+
+#endif
+
+#define _INTEGER
+#endif

avr/usbload/loader.c

@@ -1,6 +1,6 @@
 /*
 File: main.smc 
-Time: Thu, 06 Aug 2009 08:37:50
+Time: Thu, 06 Aug 2009 20:01:38
 */
 #include <avr/pgmspace.h>       
 #include <loader.h>       

avr/usbload/main.c

@@ -21,16 +21,16 @@
 
 
 #include <avr/io.h>
-#include <avr/interrupt.h>      /* for sei() */
+#include <avr/interrupt.h>      
-#include <util/delay.h>         /* for _delay_ms() */
+#include <util/delay.h>         
 #include <stdlib.h>
-#include <avr/pgmspace.h>       /* required by usbdrv.h */
+#include <avr/pgmspace.h>       
 #include <avr/eeprom.h>
 
 #include "usbdrv.h"
-#include "oddebug.h"            /* This is also an example for using debug macros */
+#include "oddebug.h"            
 #include "config.h"
-#include "requests.h"           /* The custom request numbers we use */
+#include "requests.h"           
 #include "uart.h"
 #include "sram.h"
 #include "debug.h"
@@ -42,9 +42,9 @@
 #include "watchdog.h"
 #include "rle.h"
 #include "loader.h"
+#include "command.h"
 #include "shared_memory.h"
-#include "mmc.h"
+#include "testing.h"
-#include "fat.h"
 
 
 
@@ -60,6 +60,8 @@ uint32_t req_size;
 uint8_t req_bank;
 uint32_t req_bank_size;
 uint16_t req_bank_cnt;
+uint8_t req_percent;
+uint8_t req_percent_last;
 uint8_t req_state = REQ_STATUS_IDLE;
 uint8_t rx_remaining = 0;
 uint8_t tx_remaining = 0;
@@ -77,76 +79,8 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
 
     usbRequest_t *rq = (void *) data;
     uint8_t ret_len = 0;
-    /*
-     * -------------------------------------------------------------------------
-     */
-    if (rq->bRequest == USB_UPLOAD_INIT) {
 
-        if (req_state != REQ_STATUS_IDLE) {
+    if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
-            debug(DEBUG_USB,
-                  "USB_UPLOAD_INIT: ERROR state is not REQ_STATUS_IDLE\n");
-            return 0;
-        }
-
-        req_bank = 0;
-        rx_remaining = 0;
-        req_bank_size = (uint32_t) 1 << rq->wValue.word;
-        sync_errors = 0;
-        crc = 0;
-        debug(DEBUG_USB, "USB_UPLOAD_INIT: bank_size=0x%08lx\n", req_bank_size);
-
-        /*
-         * -------------------------------------------------------------------------
-         */
-    } else if (rq->bRequest == USB_UPLOAD_ADDR) {
-
-        req_state = REQ_STATUS_UPLOAD;
-        req_addr = rq->wValue.word;
-        req_addr = req_addr << 16;
-        req_addr = req_addr | rq->wIndex.word;
-        if (rx_remaining) {
-            sync_errors++;
-            debug
-                (DEBUG_USB,
-                 "USB_UPLOAD_ADDR: Out of sync addr=0x%lx remain=%i packet=%i sync_error=%i\n",
-                 req_addr, rx_remaining, rq->wLength.word, sync_errors);
-            ret_len = 0;
-        }
-        rx_remaining = rq->wLength.word;
-        ret_len = USB_MAX_TRANS;
-
-
-        if (req_addr && (req_addr % 0x1000) == 0) {
-            debug(DEBUG_USB,
-                  "USB_UPLOAD_ADDR: bank=0x%02x addr=0x%08lx crc=%04x\n",
-                  req_bank, req_addr, crc_check_bulk_memory(req_addr - 0x1000,
-                                                            req_addr,
-                                                            req_bank_size));
-
-        }
-        if (req_addr && req_addr % req_bank_size == 0) {
-            debug(DEBUG_USB, "USB_UPLOAD_ADDR: req_bank=0x%02x addr=0x%08lx\n",
-                  req_bank, req_addr);
-
-            req_bank++;
-            // shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS,req_bank);
-        }
-        ret_len = USB_MAX_TRANS;
-        /*
-         * -------------------------------------------------------------------------
-         */
-    } else if (rq->bRequest == USB_DOWNLOAD_INIT) {
-        debug(DEBUG_USB, "USB_DOWNLOAD_INIT\n");
-
-        /*
-         * -------------------------------------------------------------------------
-         */
-    } else if (rq->bRequest == USB_DOWNLOAD_ADDR) {
-        debug(DEBUG_USB, "USB_DOWNLOAD_ADDR\n");
-        /*
-         * -------------------------------------------------------------------------
-         */
-    } else if (rq->bRequest == USB_BULK_UPLOAD_INIT) {
 
         req_bank = 0;
         rx_remaining = 0;
@@ -155,13 +89,14 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
         req_bank_size = (uint32_t) (1L << rq->wValue.word);
         req_bank_cnt = rq->wIndex.word;
         req_addr_end = (uint32_t) req_bank_size *req_bank_cnt;
-
+        req_percent = 0;
+        req_percent_last = 0;
         sync_errors = 0;
         debug(DEBUG_USB,
               "USB_BULK_UPLOAD_INIT: bank_size=0x%08lx bank_cnt=0x%x end_addr=0x%08lx\n",
               req_bank_size, req_bank_cnt, req_addr_end);
 
-        shared_memory_put(SHARED_MEM_CMD_BANK_COUNT, req_bank_cnt);
+        shared_memory_write(SHARED_MEM_TX_CMD_BANK_COUNT, req_bank_cnt);
         if (req_addr == 0x000000) {
             timer_start();
         }
@@ -176,6 +111,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
         req_addr = req_addr | rq->wIndex.word;
         rx_remaining = rq->wLength.word;
 
+
         if (req_addr && req_addr % req_bank_size == 0) {
 #ifdef FLT_DEBUG
             debug(DEBUG_USB,
@@ -187,7 +123,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
                   req_bank, req_addr, timer_stop_int());
 #endif
             req_bank++;
-            shared_memory_put(SHARED_MEM_CMD_UPLOAD_PROGESS, req_bank);
+            shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_PROGESS, req_bank);
             sram_bulk_write_start(req_addr);
             timer_start();
 
@@ -206,6 +142,16 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
         req_addr = req_addr << 16;
         req_addr = req_addr | rq->wIndex.word;
         rx_remaining = rq->wLength.word;
+
+        req_percent = (uint32_t)( 100 * req_addr )  / req_addr_end;
+        if (req_percent!=req_percent_last){
+            debug(DEBUG_USB,
+                "USB_BULK_UPLOAD_ADDR: precent=%i\n",  req_percent);
+            shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_PROGESS, req_percent);
+            sram_bulk_write_start(req_addr);
+        }
+        req_percent_last = req_percent;
+
 #if 0
         if (req_addr && (req_addr % 0x1000) == 0) {
             debug(DEBUG_USB,
@@ -229,7 +175,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
 #endif
             req_bank++;
             timer_start();
-            shared_memory_put(SHARED_MEM_CMD_BANK_CURRENT, req_bank);
+            shared_memory_write(SHARED_MEM_TX_CMD_BANK_CURRENT, req_bank);
             sram_bulk_write_start(req_addr);
 
         }
@@ -246,7 +192,7 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
         debug(DEBUG_USB, "USB_BULK_UPLOAD_END:\n");
         req_state = REQ_STATUS_IDLE;
         sram_bulk_write_end();
-        shared_memory_put(SHARED_MEM_CMD_UPLOAD_END, 0);
+        shared_memory_write(SHARED_MEM_TX_CMD_UPLOAD_END, 0);
         ret_len = 0;
 
         /*
@@ -312,174 +258,6 @@ usbMsgLen_t usbFunctionSetup(uchar data[8])
 /*
  * ------------------------------------------------------------------------- 
  */
-#define ENABLE_TEST
-#ifdef ENABLE_TEST
- 
- 
-uint8_t buffer[512];
- 
-void test_sdcard(){
-	uint16_t 	fat_cluster = 0;
-    uint8_t 	fat_attrib = 0;
-    uint32_t 	fat_size = 0;
-    uint32_t 	rom_addr = 0;
-    uint8_t 	bank_cnt = 0;
- 	uint16_t 	crc = 0;
-	uint16_t 	block_cnt;
-	uint16_t    clustervar;
-	uint8_t     dir_attrib = 0;
-	uint32_t    file_size = 0;
-    uint8_t 	i = 0;
-    
-    #define FILENAME	"mrdo.smc"   //failed
-    #define ROMSIZE      2             // 4 == 4mbit == 512kb
-    #define BUFFER_SIZE 512
-    #define BLOCKS 		(ROMSIZE << 8)
-    
-    while ( mmc_init() !=0) {
-		info("No sdcard...\n");
-    }
-    info("MMC Init done\n");
-    fat_init(read_buffer);
-    info("FAT Init done.\n");
-    
-    
-	info("\r\nDirectory\r\n");
-	for (i = 1;i < 240;i++){
-	    clustervar = fat_read_dir_ent(0,i,&file_size,&dir_attrib,buffer);
-	    if (clustervar == 0xffff){
-				break;
-		}
-		info("Cluster = %4x DirA = %2x FileName = %s size=%li\n",clustervar,dir_attrib,buffer,file_size);
-	}
-    
-    info("Look for %s\n",FILENAME);
-
-    if (fat_search_file((uint8_t*)FILENAME,
-						&fat_cluster,
-						&fat_size,
-						&fat_attrib,
-						read_buffer) == 1) {
-	   
-
-        for (block_cnt=0; block_cnt<BLOCKS; block_cnt++) {
-        	fat_read_file (fat_cluster,read_buffer,block_cnt);
-			
-			if (block_cnt && block_cnt % 64 == 0){
-				printf("Write Ram Bank: 0x%x Addr: 0x%lx Block: %x CRC: %x\n",bank_cnt,rom_addr,block_cnt,crc);
-				bank_cnt++;
-				crc = 0;
-			}
-        }
-		printf("Write Ram Bank: 0x%x Addr: 0x%lx Block: %x CRC: %x\n",bank_cnt,rom_addr,block_cnt,crc);
-		printf("Done\n");
-	}
-	
-}
-
-
-void test_read_write()
-{
-
-    uint8_t i;
-    uint32_t addr;
-    avr_bus_active();
-    addr = 0x000000;
-    i = 1;
-    while (addr++ <= 0x0000ff) {
-        sram_write(addr, i++);
-    }
-    addr = 0x000000;
-    while (addr++ <= 0x0000ff) {
-        info("read addr=0x%08lx %x\n", addr, sram_read(addr));
-    }
-}
-
-
-
-void test_bulk_read_write()
-{
-
-    uint8_t i;
-    uint32_t addr;
-    avr_bus_active();
-    addr = 0x000000;
-    i = 0;
-    sram_bulk_write_start(addr);
-    while (addr++ <= 0x8000) {
-        sram_bulk_write(i++);
-        sram_bulk_write_next();
-    }
-    sram_bulk_write_end();
-
-    addr = 0x000000;
-    sram_bulk_read_start(addr);
-    while (addr <= 0x8000) {
-        info("addr=0x%08lx %x\n", addr, sram_bulk_read());
-        sram_bulk_read_next();
-        addr++;
-    }
-    sram_bulk_read_end();
-}
-
-
-void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr)
-{
-    uint32_t addr = 0;
-    uint8_t c;
-    sram_bulk_read_start(bottom_addr);
-    for (addr = bottom_addr; addr < top_addr; addr++) {
-        c = sram_bulk_read();
-        if (c != 0xff)
-            info("addr=0x%08lx c=0x%x\n", addr, c);
-        sram_bulk_read_next();
-    }
-    sram_bulk_read_end();
-}
-
-
-
-void test_crc()
-{
-    info("test_crc: clear\n");
-    avr_bus_active();
-    sram_bulk_set(0x000000, 0x10000, 0xff);
-    info("test_crc: crc\n");
-    crc_check_bulk_memory(0x000000, 0x10000, 0x8000);
-    info("test_crc: check\n");
-    test_non_zero_memory(0x000000, 0x10000);
-}
-#endif
-
-void send_reset()
-{
-    info("Reset Snes\n");
-    snes_reset_on();
-    snes_reset_lo();
-    _delay_ms(2);
-    snes_reset_hi();
-    snes_reset_off();
-}
-
-void send_irq()
-{
-    snes_irq_on();
-    snes_irq_lo();
-    _delay_us(20);
-    snes_irq_hi();
-    snes_irq_off();
-}
-
-void set_rom_mode()
-{
-    if (req_bank_size == 0x8000) {
-        snes_lorom();
-        info("Set Snes lowrom \n");
-    } else {
-        snes_hirom();
-        info("Set Snes hirom \n");
-    }
-}
 
 
 void usb_connect()
@@ -509,7 +287,6 @@ void boot_startup_rom()
     info("Activate AVR bus\n");
     avr_bus_active();
 
-
     info("IRQ off\n");
     snes_irq_lo();
     snes_irq_off();
@@ -546,6 +323,7 @@ void boot_startup_rom()
 #endif
 }
 
+
 int main(void)
 {
 
@@ -554,7 +332,6 @@ int main(void)
 
     info("Sytem start\n");
     system_init();
-    test_sdcard();
 
 #if 0
     test_read_write();
@@ -584,13 +361,8 @@ int main(void)
         while (req_state != REQ_STATUS_SNES) {
             usbPoll();
         }
-        shared_memory_put(SHARED_MEM_CMD_TERMINATE, 0);
+        shared_memory_write(SHARED_MEM_TX_CMD_TERMINATE, 0);
         info("USB poll done\n");
-        snes_reset_hi();
-        snes_reset_off();
-        snes_irq_lo();
-        snes_irq_off();
-        info("IRQ off\n");
         set_rom_mode();
         snes_wr_disable();
         info("Disable snes WR\n");
@@ -602,7 +374,6 @@ int main(void)
 
         info("Poll\n");
         while (req_state != REQ_STATUS_AVR) {
-
             usbPoll();
 
 #ifdef DO_IRQ

avr/usbload/mmc.c

@@ -1,194 +1,600 @@
-#include "mmc.h"
+/*-----------------------------------------------------------------------*/
-#include <util/delay.h>
+/* MMC/SDSC/SDHC (in SPI mode) control module  (C)ChaN, 2007             */
-
+/*-----------------------------------------------------------------------*/
-uint8_t mmc_init()
+/* Only rcvr_spi(), xmit_spi(), disk_timerproc() and some macros         */
-{
+/* are platform dependent.                                               */
-    uint16_t Timeout = 0, i;
+/*-----------------------------------------------------------------------*/
-    MMC_REG |= ((1 << MMC_DO) | (1 << MMC_CS) | (1 << MMC_CLK));
+
-    MMC_REG &= ~(1 << MMC_DI);
+
-    MMC_WRITE |= ((1 << MMC_DO) | (1 << MMC_DI) | (1 << MMC_CS));
+#include <avr/io.h>
-    _delay_ms(20);
+#include "diskio.h"
-    for (i = 0; i < 250; i++) {
+
-        MMC_WRITE ^= (1 << MMC_CLK);
+
-        _delay_us(4);
+/* Definitions for MMC/SDC command */
-    }
+#define CMD0	(0x40+0)	/* GO_IDLE_STATE */
-    MMC_WRITE &= ~(1 << MMC_CLK);
+#define CMD1	(0x40+1)	/* SEND_OP_COND (MMC) */
-    _delay_us(10);
+#define	ACMD41	(0xC0+41)	/* SEND_OP_COND (SDC) */
-    MMC_WRITE &= ~(1 << MMC_CS);
+#define CMD8	(0x40+8)	/* SEND_IF_COND */
-    _delay_us(3);
+#define CMD9	(0x40+9)	/* SEND_CSD */
-
+#define CMD10	(0x40+10)	/* SEND_CID */
-    uint8_t CMD[] = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
+#define CMD12	(0x40+12)	/* STOP_TRANSMISSION */
-    while (mmc_write_command(CMD) != 1) {
+#define ACMD13	(0xC0+13)	/* SD_STATUS (SDC) */
-        if (Timeout++ > 20) {
+#define CMD16	(0x40+16)	/* SET_BLOCKLEN */
-            mmc_disable();
+#define CMD17	(0x40+17)	/* READ_SINGLE_BLOCK */
-            return (1);
+#define CMD18	(0x40+18)	/* READ_MULTIPLE_BLOCK */
-        }
+#define CMD23	(0x40+23)	/* SET_BLOCK_COUNT (MMC) */
-    }
+#define	ACMD23	(0xC0+23)	/* SET_WR_BLK_ERASE_COUNT (SDC) */
-
+#define CMD24	(0x40+24)	/* WRITE_BLOCK */
-    Timeout = 0;
+#define CMD25	(0x40+25)	/* WRITE_MULTIPLE_BLOCK */
-    CMD[0] = 0x41;
+#define CMD55	(0x40+55)	/* APP_CMD */
-    CMD[5] = 0xFF;
+#define CMD58	(0x40+58)	/* READ_OCR */
-    while (mmc_write_command(CMD) != 0) {
+
-        if (Timeout++ > 800) {
+
-            mmc_disable();
+/* Port Controls  (Platform dependent) */
-            return (9);
+#define SELECT()	PORTB &= ~1		/* MMC CS = L */
-        }
+#define	DESELECT()	PORTB |= 1		/* MMC CS = H */
-    }
+
-    return (0);
+#define SOCKPORT	PINB			/* Socket contact port */
-}
+#define SOCKWP		0x20			/* Write protect switch (PB5) */
-
+#define SOCKINS		0x10			/* Card detect switch (PB4) */
-uint8_t mmc_write_command(uint8_t * cmd)
+
-{
+#define	FCLK_SLOW()					/* Set slow clock (100k-400k) */
-    uint8_t tmp = 0xff;
+#define	FCLK_FAST()					/* Set fast clock (depends on the CSD) */
-    uint16_t Timeout = 0;
+
-    uint8_t a;
+
-
+/*--------------------------------------------------------------------------
-    for (a = 0; a < 0x06; a++) {
+
-        mmc_write_byte(*cmd++);
+   Module Private Functions
-    }
+
-
+---------------------------------------------------------------------------*/
-    while (tmp == 0xff) {
+
-        tmp = mmc_read_byte();
+static volatile
-        if (Timeout++ > 50) {
+DSTATUS Stat = STA_NOINIT;	/* Disk status */
-            break;
+
-        }
+static volatile
-    }
+BYTE Timer1, Timer2;	/* 100Hz decrement timer */
-    return (tmp);
+
-}
+static
-
+BYTE CardType;			/* Card type flags */
-
+
-uint8_t mmc_read_byte(void)
+
-{
+/*-----------------------------------------------------------------------*/
-    uint8_t Byte = 0, j;
+/* Transmit a byte to MMC via SPI  (Platform dependent)                  */
-    for (j = 0; j < 8; j++) {
+/*-----------------------------------------------------------------------*/
-        Byte = (Byte << 1);
+
-        MMC_WRITE |= (1 << MMC_CLK);
+#define xmit_spi(dat) 	SPDR=(dat); loop_until_bit_is_set(SPSR,SPIF)
-        _delay_us(4);
+
-        if (PINB & (1 << MMC_DI)) {
+
-            Byte |= 1;
+
-        }
+/*-----------------------------------------------------------------------*/
-
+/* Receive a byte from MMC via SPI  (Platform dependent)                 */
-        else {
+/*-----------------------------------------------------------------------*/
-            Byte &= ~1;
+
-        }
+static
-        MMC_WRITE &= ~(1 << MMC_CLK);
+BYTE rcvr_spi (void)
-        _delay_us(4);
+{
-    }
+	SPDR = 0xFF;
-    return (Byte);
+	loop_until_bit_is_set(SPSR, SPIF);
-}
+	return SPDR;
-
+}
-
+
-void mmc_write_byte(uint8_t Byte)
+/* Alternative macro to receive data fast */
-{
+#define rcvr_spi_m(dst)	SPDR=0xFF; loop_until_bit_is_set(SPSR,SPIF); *(dst)=SPDR
-    uint8_t i;
+
-    for (i = 0; i < 8; i++) {
+
-        if (Byte & 0x80) {
+
-            MMC_WRITE |= (1 << MMC_DO);
+/*-----------------------------------------------------------------------*/
-        }
+/* Wait for card ready                                                   */
-
+/*-----------------------------------------------------------------------*/
-        else {
+
-            MMC_WRITE &= ~(1 << MMC_DO);
+static
-        }
+BYTE wait_ready (void)
-        Byte = (Byte << 1);
+{
-        MMC_WRITE |= (1 << MMC_CLK);
+	BYTE res;
-        _delay_us(4);
+
-        MMC_WRITE &= ~(1 << MMC_CLK);
+
-        _delay_us(4);
+	Timer2 = 50;	/* Wait for ready in timeout of 500ms */
-    }
+	rcvr_spi();
-    MMC_WRITE |= (1 << MMC_DO);
+	do
-}
+		res = rcvr_spi();
-
+	while ((res != 0xFF) && Timer2);
-uint8_t mmc_write_sector(uint32_t addr, uint8_t * Buffer)
+
-{
+	return res;
-    uint8_t tmp;
+}
-
+
-
+
-    uint8_t cmd[] = { 0x58, 0x00, 0x00, 0x00, 0x00, 0xFF };
+
-    uint8_t a;
+/*-----------------------------------------------------------------------*/
-    uint16_t i;
+/* Deselect the card and release SPI bus                                 */
-
+/*-----------------------------------------------------------------------*/
-    addr = addr << 9;
+
-    cmd[1] = ((addr & 0xFF000000) >> 24);
+static
-    cmd[2] = ((addr & 0x00FF0000) >> 16);
+void release_spi (void)
-    cmd[3] = ((addr & 0x0000FF00) >> 8);
+{
-
+	DESELECT();
-
+	rcvr_spi();
-    tmp = mmc_write_command(cmd);
+}
-    if (tmp != 0) {
+
-        return (tmp);
+
-    }
+
-
+/*-----------------------------------------------------------------------*/
-    for (a = 0; a < 100; a++) {
+/* Power Control  (Platform dependent)                                   */
-        mmc_read_byte();
+/*-----------------------------------------------------------------------*/
-    }
+/* When the target system does not support socket power control, there   */
-
+/* is nothing to do in these functions and chk_power always returns 1.   */
-    mmc_write_byte(0xFE);
+
-
+static
-    for (a = 0; i < 512; i++) {
+void power_on (void)
-        mmc_write_byte(*Buffer++);
+{
-    }
+	PORTE &= ~0x80;				/* Socket power ON */
-
+	for (Timer1 = 3; Timer1; );	/* Wait for 30ms */
-    mmc_write_byte(0xFF);
+	PORTB = 0b10110101;			/* Enable drivers */
-    mmc_write_byte(0xFF);
+	DDRB  = 0b11000111;
-
+	SPCR = 0b01010000;			/* Initialize SPI port (Mode 0) */
-    if ((mmc_read_byte() & 0x1F) != 0x05)
+	SPSR = 0b00000001;
-        return (1);
+}
-
+
-    while (mmc_read_byte() != 0xff) {
+static
-    };
+void power_off (void)
-    return (0);
+{
-}
+	SELECT();				/* Wait for card ready */
-
+	wait_ready();
-
+	release_spi();
-void mmc_read_block(uint8_t * cmd, uint8_t * Buffer, uint16_t Bytes)
+
-{
+	SPCR = 0;				/* Disable SPI function */
-    uint16_t a;
+	DDRB  = 0b11000000;		/* Disable drivers */
-
+	PORTB = 0b10110000;
-    if (mmc_write_command(cmd) != 0) {
+	PORTE |=  0x80;			/* Socket power OFF */
-        return;
+	Stat |= STA_NOINIT;		/* Set STA_NOINIT */
-    }
+}
-
+
-    while (mmc_read_byte() != 0xfe) {
+static
-    };
+int chk_power(void)		/* Socket power state: 0=off, 1=on */
-
+{
-
+	return (PORTE & 0x80) ? 0 : 1;
-    for (a = 0; a < Bytes; a++) {
+}
-        *Buffer++ = mmc_read_byte();
+
-    }
+
-
+
-    mmc_read_byte();
+/*-----------------------------------------------------------------------*/
-    mmc_read_byte();
+/* Receive a data packet from MMC                                        */
-    return;
+/*-----------------------------------------------------------------------*/
-}
+
-
+static
-uint8_t mmc_read_sector(uint32_t addr, uint8_t * Buffer)
+BOOL rcvr_datablock (
-{
+	BYTE *buff,			/* Data buffer to store received data */
-
+	UINT btr			/* Byte count (must be multiple of 4) */
-
+)
-    uint8_t cmd[] = { 0x51, 0x00, 0x00, 0x00, 0x00, 0xFF };
+{
-
+	BYTE token;
-    addr = addr << 9;
+
-    cmd[1] = ((addr & 0xFF000000) >> 24);
+
-    cmd[2] = ((addr & 0x00FF0000) >> 16);
+	Timer1 = 10;
-    cmd[3] = ((addr & 0x0000FF00) >> 8);
+	do {							/* Wait for data packet in timeout of 100ms */
-    mmc_read_block(cmd, Buffer, 512);
+		token = rcvr_spi();
-    return (0);
+	} while ((token == 0xFF) && Timer1);
-}
+	if(token != 0xFE) return FALSE;	/* If not valid data token, retutn with error */
-
+
-
+	do {							/* Receive the data block into buffer */
-uint8_t mmc_read_cid(uint8_t * Buffer)
+		rcvr_spi_m(buff++);
-{
+		rcvr_spi_m(buff++);
-
+		rcvr_spi_m(buff++);
-    uint8_t cmd[] = { 0x4A, 0x00, 0x00, 0x00, 0x00, 0xFF };
+		rcvr_spi_m(buff++);
-    mmc_read_block(cmd, Buffer, 16);
+	} while (btr -= 4);
-    return (0);
+	rcvr_spi();						/* Discard CRC */
-}
+	rcvr_spi();
-
+
-
+	return TRUE;					/* Return with success */
-uint8_t mmc_read_csd(uint8_t * Buffer)
+}
-{
+
-
+
-    uint8_t cmd[] = { 0x49, 0x00, 0x00, 0x00, 0x00, 0xFF };
+
-    mmc_read_block(cmd, Buffer, 16);
+/*-----------------------------------------------------------------------*/
-    return (0);
+/* Send a data packet to MMC                                             */
-}
+/*-----------------------------------------------------------------------*/
+
+#if _READONLY == 0
+static
+BOOL xmit_datablock (
+	const BYTE *buff,	/* 512 byte data block to be transmitted */
+	BYTE token			/* Data/Stop token */
+)
+{
+	BYTE resp, wc;
+
+
+	if (wait_ready() != 0xFF) return FALSE;
+
+	xmit_spi(token);					/* Xmit data token */
+	if (token != 0xFD) {	/* Is data token */
+		wc = 0;
+		do {							/* Xmit the 512 byte data block to MMC */
+			xmit_spi(*buff++);
+			xmit_spi(*buff++);
+		} while (--wc);
+		xmit_spi(0xFF);					/* CRC (Dummy) */
+		xmit_spi(0xFF);
+		resp = rcvr_spi();				/* Reveive data response */
+		if ((resp & 0x1F) != 0x05)		/* If not accepted, return with error */
+			return FALSE;
+	}
+
+	return TRUE;
+}
+#endif /* _READONLY */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Send a command packet to MMC                                          */
+/*-----------------------------------------------------------------------*/
+
+static
+BYTE send_cmd (
+	BYTE cmd,		/* Command byte */
+	DWORD arg		/* Argument */
+)
+{
+	BYTE n, res;
+
+
+	if (cmd & 0x80) {	/* ACMD<n> is the command sequense of CMD55-CMD<n> */
+		cmd &= 0x7F;
+		res = send_cmd(CMD55, 0);
+		if (res > 1) return res;
+	}
+
+	/* Select the card and wait for ready */
+	DESELECT();
+	SELECT();
+	if (wait_ready() != 0xFF) return 0xFF;
+
+	/* Send command packet */
+	xmit_spi(cmd);						/* Start + Command index */
+	xmit_spi((BYTE)(arg >> 24));		/* Argument[31..24] */
+	xmit_spi((BYTE)(arg >> 16));		/* Argument[23..16] */
+	xmit_spi((BYTE)(arg >> 8));			/* Argument[15..8] */
+	xmit_spi((BYTE)arg);				/* Argument[7..0] */
+	n = 0x01;							/* Dummy CRC + Stop */
+	if (cmd == CMD0) n = 0x95;			/* Valid CRC for CMD0(0) */
+	if (cmd == CMD8) n = 0x87;			/* Valid CRC for CMD8(0x1AA) */
+	xmit_spi(n);
+
+	/* Receive command response */
+	if (cmd == CMD12) rcvr_spi();		/* Skip a stuff byte when stop reading */
+	n = 10;								/* Wait for a valid response in timeout of 10 attempts */
+	do
+		res = rcvr_spi();
+	while ((res & 0x80) && --n);
+
+	return res;			/* Return with the response value */
+}
+
+
+
+/*--------------------------------------------------------------------------
+
+   Public Functions
+
+---------------------------------------------------------------------------*/
+
+
+/*-----------------------------------------------------------------------*/
+/* Initialize Disk Drive                                                 */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+	BYTE drv		/* Physical drive nmuber (0) */
+)
+{
+	BYTE n, cmd, ty, ocr[4];
+
+
+	if (drv) return STA_NOINIT;			/* Supports only single drive */
+	if (Stat & STA_NODISK) return Stat;	/* No card in the socket */
+
+	power_on();							/* Force socket power on */
+	FCLK_SLOW();
+	for (n = 10; n; n--) rcvr_spi();	/* 80 dummy clocks */
+
+	ty = 0;
+	if (send_cmd(CMD0, 0) == 1) {			/* Enter Idle state */
+		Timer1 = 100;						/* Initialization timeout of 1000 msec */
+		if (send_cmd(CMD8, 0x1AA) == 1) {	/* SDHC */
+			for (n = 0; n < 4; n++) ocr[n] = rcvr_spi();		/* Get trailing return value of R7 resp */
+			if (ocr[2] == 0x01 && ocr[3] == 0xAA) {				/* The card can work at vdd range of 2.7-3.6V */
+				while (Timer1 && send_cmd(ACMD41, 1UL << 30));	/* Wait for leaving idle state (ACMD41 with HCS bit) */
+				if (Timer1 && send_cmd(CMD58, 0) == 0) {		/* Check CCS bit in the OCR */
+					for (n = 0; n < 4; n++) ocr[n] = rcvr_spi();
+					ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;
+				}
+			}
+		} else {							/* SDSC or MMC */
+			if (send_cmd(ACMD41, 0) <= 1) 	{
+				ty = CT_SD1; cmd = ACMD41;	/* SDSC */
+			} else {
+				ty = CT_MMC; cmd = CMD1;	/* MMC */
+			}
+			while (Timer1 && send_cmd(cmd, 0));			/* Wait for leaving idle state */
+			if (!Timer1 || send_cmd(CMD16, 512) != 0)	/* Set R/W block length to 512 */
+				ty = 0;
+		}
+	}
+	CardType = ty;
+	release_spi();
+
+	if (ty) {			/* Initialization succeded */
+		Stat &= ~STA_NOINIT;		/* Clear STA_NOINIT */
+		FCLK_FAST();
+	} else {			/* Initialization failed */
+		power_off();
+	}
+
+	return Stat;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Get Disk Status                                                       */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+	BYTE drv		/* Physical drive nmuber (0) */
+)
+{
+	if (drv) return STA_NOINIT;		/* Supports only single drive */
+	return Stat;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read (
+	BYTE drv,			/* Physical drive nmuber (0) */
+	BYTE *buff,			/* Pointer to the data buffer to store read data */
+	DWORD sector,		/* Start sector number (LBA) */
+	BYTE count			/* Sector count (1..255) */
+)
+{
+	if (drv || !count) return RES_PARERR;
+	if (Stat & STA_NOINIT) return RES_NOTRDY;
+
+	if (!(CardType & CT_BLOCK)) sector *= 512;	/* Convert to byte address if needed */
+
+	if (count == 1) {	/* Single block read */
+		if ((send_cmd(CMD17, sector) == 0)	/* READ_SINGLE_BLOCK */
+			&& rcvr_datablock(buff, 512))
+			count = 0;
+	}
+	else {				/* Multiple block read */
+		if (send_cmd(CMD18, sector) == 0) {	/* READ_MULTIPLE_BLOCK */
+			do {
+				if (!rcvr_datablock(buff, 512)) break;
+				buff += 512;
+			} while (--count);
+			send_cmd(CMD12, 0);				/* STOP_TRANSMISSION */
+		}
+	}
+	release_spi();
+
+	return count ? RES_ERROR : RES_OK;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+#if _READONLY == 0
+DRESULT disk_write (
+	BYTE drv,			/* Physical drive nmuber (0) */
+	const BYTE *buff,	/* Pointer to the data to be written */
+	DWORD sector,		/* Start sector number (LBA) */
+	BYTE count			/* Sector count (1..255) */
+)
+{
+	if (drv || !count) return RES_PARERR;
+	if (Stat & STA_NOINIT) return RES_NOTRDY;
+	if (Stat & STA_PROTECT) return RES_WRPRT;
+
+	if (!(CardType & CT_BLOCK)) sector *= 512;	/* Convert to byte address if needed */
+
+	if (count == 1) {	/* Single block write */
+		if ((send_cmd(CMD24, sector) == 0)	/* WRITE_BLOCK */
+			&& xmit_datablock(buff, 0xFE))
+			count = 0;
+	}
+	else {				/* Multiple block write */
+		if (CardType & CT_SDC) send_cmd(ACMD23, count);
+		if (send_cmd(CMD25, sector) == 0) {	/* WRITE_MULTIPLE_BLOCK */
+			do {
+				if (!xmit_datablock(buff, 0xFC)) break;
+				buff += 512;
+			} while (--count);
+			if (!xmit_datablock(0, 0xFD))	/* STOP_TRAN token */
+				count = 1;
+		}
+	}
+	release_spi();
+
+	return count ? RES_ERROR : RES_OK;
+}
+#endif /* _READONLY == 0 */
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+#if _USE_IOCTL != 0
+DRESULT disk_ioctl (
+	BYTE drv,		/* Physical drive nmuber (0) */
+	BYTE ctrl,		/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+	DRESULT res;
+	BYTE n, csd[16], *ptr = buff;
+	WORD csize;
+
+
+	if (drv) return RES_PARERR;
+
+	res = RES_ERROR;
+
+	if (ctrl == CTRL_POWER) {
+		switch (*ptr) {
+		case 0:		/* Sub control code == 0 (POWER_OFF) */
+			if (chk_power())
+				power_off();		/* Power off */
+			res = RES_OK;
+			break;
+		case 1:		/* Sub control code == 1 (POWER_ON) */
+			power_on();				/* Power on */
+			res = RES_OK;
+			break;
+		case 2:		/* Sub control code == 2 (POWER_GET) */
+			*(ptr+1) = (BYTE)chk_power();
+			res = RES_OK;
+			break;
+		default :
+			res = RES_PARERR;
+		}
+	}
+	else {
+		if (Stat & STA_NOINIT) return RES_NOTRDY;
+
+		switch (ctrl) {
+		case CTRL_SYNC :		/* Make sure that no pending write process */
+			SELECT();
+			if (wait_ready() == 0xFF)
+				res = RES_OK;
+			break;
+
+		case GET_SECTOR_COUNT :	/* Get number of sectors on the disk (DWORD) */
+			if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {
+				if ((csd[0] >> 6) == 1) {	/* SDC ver 2.00 */
+					csize = csd[9] + ((WORD)csd[8] << 8) + 1;
+					*(DWORD*)buff = (DWORD)csize << 10;
+				} else {					/* SDC ver 1.XX or MMC*/
+					n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
+					csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
+					*(DWORD*)buff = (DWORD)csize << (n - 9);
+				}
+				res = RES_OK;
+			}
+			break;
+
+		case GET_SECTOR_SIZE :	/* Get R/W sector size (WORD) */
+			*(WORD*)buff = 512;
+			res = RES_OK;
+			break;
+
+		case GET_BLOCK_SIZE :	/* Get erase block size in unit of sector (DWORD) */
+			if (CardType & CT_SD2) {	/* SDC ver 2.00 */
+				if (send_cmd(ACMD13, 0) == 0) {	/* Read SD status */
+					rcvr_spi();
+					if (rcvr_datablock(csd, 16)) {				/* Read partial block */
+						for (n = 64 - 16; n; n--) rcvr_spi();	/* Purge trailing data */
+						*(DWORD*)buff = 16UL << (csd[10] >> 4);
+						res = RES_OK;
+					}
+				}
+			} else {					/* SDC ver 1.XX or MMC */
+				if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {	/* Read CSD */
+					if (CardType & CT_SD1) {	/* SDC ver 1.XX */
+						*(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
+					} else {					/* MMC */
+						*(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
+					}
+					res = RES_OK;
+				}
+			}
+			break;
+
+		case MMC_GET_TYPE :		/* Get card type flags (1 byte) */
+			*ptr = CardType;
+			res = RES_OK;
+			break;
+
+		case MMC_GET_CSD :		/* Receive CSD as a data block (16 bytes) */
+			if (send_cmd(CMD9, 0) == 0		/* READ_CSD */
+				&& rcvr_datablock(ptr, 16))
+				res = RES_OK;
+			break;
+
+		case MMC_GET_CID :		/* Receive CID as a data block (16 bytes) */
+			if (send_cmd(CMD10, 0) == 0		/* READ_CID */
+				&& rcvr_datablock(ptr, 16))
+				res = RES_OK;
+			break;
+
+		case MMC_GET_OCR :		/* Receive OCR as an R3 resp (4 bytes) */
+			if (send_cmd(CMD58, 0) == 0) {	/* READ_OCR */
+				for (n = 4; n; n--) *ptr++ = rcvr_spi();
+				res = RES_OK;
+			}
+			break;
+
+		case MMC_GET_SDSTAT :	/* Receive SD statsu as a data block (64 bytes) */
+			if (send_cmd(ACMD13, 0) == 0) {	/* SD_STATUS */
+				rcvr_spi();
+				if (rcvr_datablock(ptr, 64))
+					res = RES_OK;
+			}
+			break;
+
+		default:
+			res = RES_PARERR;
+		}
+
+		release_spi();
+	}
+
+	return res;
+}
+#endif /* _USE_IOCTL != 0 */
+
+
+/*-----------------------------------------------------------------------*/
+/* Device Timer Interrupt Procedure  (Platform dependent)                */
+/*-----------------------------------------------------------------------*/
+/* This function must be called in period of 10ms                        */
+
+void disk_timerproc (void)
+{
+	static BYTE pv;
+	BYTE n, s;
+
+
+	n = Timer1;						/* 100Hz decrement timer */
+	if (n) Timer1 = --n;
+	n = Timer2;
+	if (n) Timer2 = --n;
+
+	n = pv;
+	pv = SOCKPORT & (SOCKWP | SOCKINS);	/* Sample socket switch */
+
+	if (n == pv) {					/* Have contacts stabled? */
+		s = Stat;
+
+		if (pv & SOCKWP)			/* WP is H (write protected) */
+			s |= STA_PROTECT;
+		else						/* WP is L (write enabled) */
+			s &= ~STA_PROTECT;
+
+		if (pv & SOCKINS)			/* INS = H (Socket empty) */
+			s |= (STA_NODISK | STA_NOINIT);
+		else						/* INS = L (Card inserted) */
+			s &= ~STA_NODISK;
+
+		Stat = s;
+	}
+}
+

avr/usbload/mmc.h

@@ -1,29 +0,0 @@
-#ifndef _MMC_H_
-#define _MMC_H_
-
-#include <avr/io.h>
-
-
-#define MMC_WRITE			PORTB
-#define MMC_READ			PINB
-#define MMC_REG	DDRB
-
-#define MMC_CS  PB4
-#define MMC_DO  PB6
-#define MMC_DI  PB5
-#define MMC_CLK PB7
-extern uint8_t mmc_read_byte(void);
-extern void mmc_write_byte(uint8_t);
-extern void mmc_read_block(uint8_t *, uint8_t *, unsigned in);
-extern uint8_t mmc_init(void);
-extern uint8_t mmc_read_sector(uint32_t, uint8_t *);
-extern uint8_t mmc_write_sector(uint32_t, uint8_t *);
-extern uint8_t mmc_write_command(uint8_t *);
-extern uint8_t mmc_read_csd(uint8_t *);
-extern uint8_t mmc_read_cid(uint8_t *);
-
-#define mmc_disable() MMC_WRITE|= (1<<MMC_CS);
-
-#define mmc_enable() MMC_WRITE&=~(1<<MMC_CS);
-
-#endif

avr/usbload/rle.c

@@ -22,9 +22,9 @@
 #include <avr/io.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <avr/pgmspace.h>       /* required by usbdrv.h */
+#include <avr/pgmspace.h>       
-#include <util/delay.h>         /* for _delay_ms() */
+#include <util/delay.h>         
-#include <avr/interrupt.h>      /* for sei() */
+#include <avr/interrupt.h>      
 
 #include "sram.h"
 #include "debug.h"

avr/usbload/rtc.c

@@ -0,0 +1,44 @@
+/*--------------------------------------------------------------------------*/
+/*  RTC controls                                                            */
+
+#include <avr/io.h>
+#include "rtc.h"
+
+
+
+
+BOOL rtc_gettime (RTC *rtc)
+{
+	BYTE buf[8];
+
+
+	rtc->sec = (buf[0] & 0x0F) + ((buf[0] >> 4) & 7) * 10;
+	rtc->min = (buf[1] & 0x0F) + (buf[1] >> 4) * 10;
+	rtc->hour = (buf[2] & 0x0F) + ((buf[2] >> 4) & 3) * 10;
+	rtc->wday = (buf[2] & 0x07);
+	rtc->mday = (buf[4] & 0x0F) + ((buf[4] >> 4) & 3) * 10;
+	rtc->month = (buf[5] & 0x0F) + ((buf[5] >> 4) & 1) * 10;
+	rtc->year = 2000 + (buf[6] & 0x0F) + (buf[6] >> 4) * 10;
+    return TRUE;
+}
+
+
+
+
+BOOL rtc_settime (const RTC *rtc)
+{
+
+	BYTE buf[8];
+
+
+	buf[0] = rtc->sec / 10 * 16 + rtc->sec % 10;
+	buf[1] = rtc->min / 10 * 16 + rtc->min % 10;
+	buf[2] = rtc->hour / 10 * 16 + rtc->hour % 10;
+	buf[3] = rtc->wday & 7;
+	buf[4] = rtc->mday / 10 * 16 + rtc->mday % 10;
+	buf[5] = rtc->month / 10 * 16 + rtc->month % 10;
+	buf[6] = (rtc->year - 2000) / 10 * 16 + (rtc->year - 2000) % 10;
+	return 1;
+}
+
+

avr/usbload/rtc.h

@@ -0,0 +1,15 @@
+#include "integer.h"
+
+typedef struct {
+	WORD	year;	/* 2000..2099 */
+	BYTE	month;	/* 1..12 */
+	BYTE	mday;	/* 1.. 31 */
+	BYTE	wday;	/* 1..7 */
+	BYTE	hour;	/* 0..23 */
+	BYTE	min;	/* 0..59 */
+	BYTE	sec;	/* 0..59 */
+} RTC;
+
+BOOL rtc_gettime (RTC*);					/* Get time */
+BOOL rtc_settime (const RTC*);				/* Set time */
+

avr/usbload/shared_memory.c

@@ -38,20 +38,21 @@ uint8_t scratchpad_state;
 uint8_t scratchpad_cmd;
 uint8_t scratchpad_payload;
 
-void shared_memory_scratchpad_save()
+void shared_memory_scratchpad_tx_save()
 {
-    scratchpad_state = sram_read(SHARED_MEM_LOC_STATE);
+    scratchpad_state = sram_read(SHARED_MEM_TX_LOC_STATE);
-    scratchpad_cmd = sram_read(SHARED_MEM_LOC_CMD);
+    scratchpad_cmd = sram_read(SHARED_MEM_TX_LOC_CMD);
-    scratchpad_payload = sram_read(SHARED_MEM_LOC_PAYLOAD);
+    scratchpad_payload = sram_read(SHARED_MEM_TX_LOC_PAYLOAD);
 }
 
-void shared_memory_scratchpad_restore()
+void shared_memory_scratchpad_tx_restore()
 {
-    sram_write(SHARED_MEM_LOC_STATE, scratchpad_state);
+    sram_write(SHARED_MEM_TX_LOC_STATE, scratchpad_state);
-    sram_write(SHARED_MEM_LOC_CMD, scratchpad_cmd);
+    sram_write(SHARED_MEM_TX_LOC_CMD, scratchpad_cmd);
-    sram_write(SHARED_MEM_LOC_PAYLOAD, scratchpad_payload);
+    sram_write(SHARED_MEM_TX_LOC_PAYLOAD, scratchpad_payload);
 }
 
+
 void shared_memory_irq_hook()
 {
     irq_addr_lo = sram_read(SHARED_IRQ_LOC_LO);
@@ -66,32 +67,84 @@ void shared_memory_irq_restore()
     sram_write(SHARED_IRQ_LOC_HI, irq_addr_hi);
 }
 
-void shared_memory_put(uint8_t cmd, uint8_t value)
+void shared_memory_write(uint8_t cmd, uint8_t value)
 {
 
-    info("Write shared memory 0x%04x=0x%02x 0x%04x=0x%02x \n",
+    debug(DEBUG_SHM,"shared_memory_write:  0x%04x=0x%02x 0x%04x=0x%02x \n",
-         SHARED_MEM_LOC_CMD, cmd, SHARED_MEM_LOC_PAYLOAD, value);
+         SHARED_MEM_TX_LOC_CMD, cmd, SHARED_MEM_TX_LOC_PAYLOAD, value);
 
-    shared_memory_scratchpad_save();
+    shared_memory_scratchpad_tx_save();
     shared_memory_irq_hook();
 
-    sram_write(SHARED_MEM_LOC_STATE, SHARED_MEM_SNES_ACK);
+    sram_write(SHARED_MEM_TX_LOC_STATE, SHARED_MEM_TX_SNES_ACK);
-    sram_write(SHARED_MEM_LOC_CMD, cmd);
+    sram_write(SHARED_MEM_TX_LOC_CMD, cmd);
-    sram_write(SHARED_MEM_LOC_PAYLOAD, value);
+    sram_write(SHARED_MEM_TX_LOC_PAYLOAD, value);
+
+    snes_hirom();
+    snes_bus_active();
+
+#if SHARED_MEM_SWITCH_IRQ    
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+#else
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
+#endif
+
+    avr_bus_active();
+    snes_lorom();
+
+    shared_memory_scratchpad_tx_restore();
+    shared_memory_irq_restore();
+
+}
+
+void shared_memory_yield()
+{
 
     snes_hirom();
     snes_wr_disable();
     snes_bus_active();
-    _delay_ms(50);
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
-
-
     avr_bus_active();
-    snes_irq_lo();
-    snes_irq_off();
     snes_lorom();
     snes_wr_disable();
 
-    shared_memory_scratchpad_restore();
+}
-    shared_memory_irq_restore();
+
-
+
+int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer)
+{
+    uint8_t state;
+    state = sram_read(SHARED_MEM_RX_LOC_STATE);
+    if (state != SHARED_MEM_RX_AVR_ACK){
+        return 1;
+    }
+
+    *cmd = sram_read(SHARED_MEM_RX_LOC_CMD);
+    *len = sram_read(SHARED_MEM_RX_LOC_LEN);
+    debug(DEBUG_SHM,"shared_memory_read: 0x%04x=0x%02x 0x%04x=0x%02x \n",
+         SHARED_MEM_RX_LOC_CMD, *cmd, SHARED_MEM_RX_LOC_LEN, *len);
+
+    sram_bulk_read_buffer(SHARED_MEM_RX_LOC_PAYLOAD,buffer, *len);
+    sram_write(SHARED_MEM_RX_LOC_STATE, SHARED_MEM_RX_AVR_RTS);
+
+    snes_hirom();
+    snes_bus_active();
+
+#if SHARED_MEM_SWITCH_IRQ    
+    snes_irq_on();
+    snes_irq_lo();
+    _delay_us(20);
+    snes_irq_hi();
+    snes_irq_off();
+#else
+    _delay_ms(SHARED_MEM_SWITCH_DELAY);
+#endif
+
+    avr_bus_active();
+    snes_lorom();
+    return 0;
 }

avr/usbload/shared_memory.h

@@ -22,30 +22,42 @@
 #define __SHARED_MEMORY_H__
 
 
-#define SHARED_MEM_SNES_ACK           0xa5
+#define SHARED_MEM_SWITCH_IRQ               0
-#define SHARED_MEM_SNES_RTS           0x5a
+#define SHARED_MEM_SWITCH_DELAY             20
 
+#define SHARED_MEM_TX_SNES_ACK              0xa5
+#define SHARED_MEM_TX_SNES_RTS              0x5a
 
-#define SHARED_MEM_CMD_BANK_COUNT     0
+#define SHARED_MEM_TX_CMD_BANK_COUNT        0x00
-#define SHARED_MEM_CMD_BANK_CURRENT   1
+#define SHARED_MEM_TX_CMD_BANK_CURRENT      0x01
 
-#define SHARED_MEM_CMD_UPLOAD_START   3
+#define SHARED_MEM_TX_CMD_UPLOAD_START      0x03
-#define SHARED_MEM_CMD_UPLOAD_END     4
+#define SHARED_MEM_TX_CMD_UPLOAD_END        0x04
-#define SHARED_MEM_CMD_UPLOAD_PROGESS 5
+#define SHARED_MEM_TX_CMD_UPLOAD_PROGESS    0x05
-#define SHARED_MEM_CMD_TERMINATE      6
+#define SHARED_MEM_TX_CMD_TERMINATE         0x06
 
+#define SHARED_MEM_TX_LOC_STATE             0x000000
+#define SHARED_MEM_TX_LOC_CMD               0x000001
+#define SHARED_MEM_TX_LOC_PAYLOAD           0x000002
 
-#define SHARED_MEM_LOC_STATE            0x000000
+#define SHARED_MEM_RX_AVR_ACK               0xa5
-#define SHARED_MEM_LOC_CMD              0x000001
+#define SHARED_MEM_RX_AVR_RTS               0x5a
-#define SHARED_MEM_LOC_PAYLOAD          0x000002
 
-#define SHARED_IRQ_LOC_LO              0x00fffe
+#define SHARED_MEM_RX_CMD_PRINFT            0x00
-#define SHARED_IRQ_LOC_HI              0x00ffff
+#define SHARED_MEM_RX_CMD_FILESEL           0x01
 
+#define SHARED_MEM_RX_LOC_STATE             0x001000
+#define SHARED_MEM_RX_LOC_CMD               0x001001
+#define SHARED_MEM_RX_LOC_LEN               0x001002
+#define SHARED_MEM_RX_LOC_PAYLOAD           0x001003
 
-#define SHARED_IRQ_HANDLER_LO           0x00
+#define SHARED_IRQ_LOC_LO                   0x00fffe
-#define SHARED_IRQ_HANDLER_HI           0x10
+#define SHARED_IRQ_LOC_HI                   0x00ffff
 
-void shared_memory_put(uint8_t cmd, uint8_t value);
+#define SHARED_IRQ_HANDLER_LO               0x00
+#define SHARED_IRQ_HANDLER_HI               0x10
+
+void shared_memory_write(uint8_t cmd, uint8_t value);
+int shared_memory_read(uint8_t *cmd, uint8_t *len,uint8_t *buffer);
 
 #endif

avr/usbload/sram.c

@@ -309,48 +309,3 @@ void sram_bulk_set(uint32_t addr, uint32_t len,uint8_t value){
     sram_bulk_write_end();
 }
 
-void sram_setr(uint32_t addr, uint32_t len,uint8_t value)
-{
-    uint32_t i;
-    debug(DEBUG_SRAM,"sram_clear: addr=0x%08lx len=%li\n\r", addr,len);
-    for (i = addr; i < (addr + len); i++) {
-        if (0 == i % 0xfff)
-            debug(DEBUG_SRAM,"sram_clear: addr=0x%08lx\n\r", i);
-        sram_write(i, value);
-    }
-}
-
-void sram_copy(uint32_t addr, uint8_t * src, uint32_t len)
-{
-
-    uint32_t i;
-    uint8_t *ptr = src;
-    debug(DEBUG_SRAM,"sram_copy: addr=0x%08lx src=0x%p len=%li\n\r", addr,src,len);
-    for (i = addr; i < (addr + len); i++)
-        sram_write(i, *ptr++);
-}
-
-void sram_read_buffer(uint32_t addr, uint8_t * dst, uint32_t len)
-{
-
-    uint32_t i;
-    uint8_t *ptr = dst;
-    debug(DEBUG_SRAM,"sram_read_buffer: addr=0x%08lx dst=0x%p len=%li\n\r", addr,dst,len);
-    for (i = addr; i < (addr + len); i++) {
-        *ptr = sram_read(i);
-        ptr++;
-    }
-}
-
-
-uint8_t sram_check(uint8_t * buffer, uint32_t len)
-{
-    uint16_t cnt;
-    debug(DEBUG_SRAM,"sram_check: len=%li\n\r",len);
-    for (cnt = 0; cnt < len; cnt++)
-        if (buffer[cnt])
-            return 1;
-    return 0;
-}
-
-

avr/usbload/sram.h

@@ -186,9 +186,6 @@ void sreg_set(uint32_t addr);
 
 uint8_t sram_read(uint32_t addr);
 void sram_write(uint32_t addr, uint8_t data);
-void sram_set(uint32_t addr, uint32_t len, uint8_t value);
-void sram_copy(uint32_t addr,uint8_t *src, uint32_t len);
-void sram_read_buffer(uint32_t addr,uint8_t *dst, uint32_t len);
 
 void sram_bulk_read_start(uint32_t addr);
 inline void sram_bulk_read_next(void);

avr/usbload/testing.c

@@ -0,0 +1,264 @@
+
+
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>      
+#include <util/delay.h>         
+#include <avr/pgmspace.h>       
+#include <avr/eeprom.h>
+
+#include "usbdrv.h"
+#include "oddebug.h"            
+#include "config.h"
+#include "requests.h"           
+#include "uart.h"
+#include "sram.h"
+#include "debug.h"
+#include "info.h"
+#include "dump.h"
+#include "crc.h"
+#include "usb_bulk.h"
+#include "timer.h"
+#include "watchdog.h"
+#include "rle.h"
+#include "loader.h"
+#include "command.h"
+#include "shared_memory.h"
+#include "testing.h"
+
+void test_read_write()
+{
+
+    uint8_t i;
+    uint32_t addr;
+    avr_bus_active();
+    addr = 0x000000;
+    i = 1;
+    while (addr++ <= 0x0000ff) {
+        sram_write(addr, i++);
+    }
+    addr = 0x000000;
+    while (addr++ <= 0x0000ff) {
+        info("read addr=0x%08lx %x\n", addr, sram_read(addr));
+    }
+}
+
+
+
+void test_bulk_read_write()
+{
+
+    uint8_t i;
+    uint32_t addr;
+    avr_bus_active();
+    addr = 0x000000;
+    i = 0;
+    sram_bulk_write_start(addr);
+    while (addr++ <= 0x8000) {
+        sram_bulk_write(i++);
+        sram_bulk_write_next();
+    }
+    sram_bulk_write_end();
+
+    addr = 0x000000;
+    sram_bulk_read_start(addr);
+    while (addr <= 0x8000) {
+        info("addr=0x%08lx %x\n", addr, sram_bulk_read());
+        sram_bulk_read_next();
+        addr++;
+    }
+    sram_bulk_read_end();
+}
+
+
+void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr)
+{
+    uint32_t addr = 0;
+    uint8_t c;
+    sram_bulk_read_start(bottom_addr);
+    for (addr = bottom_addr; addr < top_addr; addr++) {
+        c = sram_bulk_read();
+        if (c != 0xff)
+            info("addr=0x%08lx c=0x%x\n", addr, c);
+        sram_bulk_read_next();
+    }
+    sram_bulk_read_end();
+}
+
+
+
+void test_crc()
+{
+    info("test_crc: clear\n");
+    avr_bus_active();
+    sram_bulk_set(0x000000, 0x10000, 0xff);
+    info("test_crc: crc\n");
+    crc_check_bulk_memory(0x000000, 0x10000, 0x8000);
+    info("test_crc: check\n");
+    test_non_zero_memory(0x000000, 0x10000);
+}
+
+
+
+
+
+
+/*----------------------------------------------------------------------*/
+/* FAT file system sample project for FatFs R0.06  (C)ChaN, 2008        */
+/*----------------------------------------------------------------------*/
+
+#include "ff.h"
+#include "diskio.h"
+#include "rtc.h"
+
+
+
+DWORD acc_size;				/* Work register for fs command */
+WORD acc_files, acc_dirs;
+FILINFO finfo;
+
+
+FATFS fatfs[2];				/* File system object for each logical drive */
+BYTE Buff[1024];			/* Working buffer */
+
+volatile WORD Timer;		/* 100Hz increment timer */
+
+
+
+#if _MULTI_PARTITION != 0
+    const PARTITION Drives[] = { {0,0}, {0,1} };
+#endif
+
+/*
+ISR(TIMER2_COMP_vect)
+{
+	Timer++;			
+	disk_timerproc();	
+}
+*/
+
+DWORD get_fattime ()
+{
+	RTC rtc;
+
+
+	//rtc_gettime(&rtc);
+
+	return	  ((DWORD)(rtc.year - 1980) << 25)
+			| ((DWORD)rtc.month << 21)
+			| ((DWORD)rtc.mday << 16)
+			| ((DWORD)rtc.hour << 11)
+			| ((DWORD)rtc.min << 5)
+			| ((DWORD)rtc.sec >> 1);
+}
+
+
+
+static
+FRESULT scan_files (char* path)
+{
+	DIR dirs;
+	FRESULT res;
+	int i;
+
+	if ((res = f_opendir(&dirs, path)) == FR_OK) {
+		i = strlen(path);
+		while (((res = f_readdir(&dirs, &finfo)) == FR_OK) && finfo.fname[0]) {
+			if (finfo.fattrib & AM_DIR) {
+				acc_dirs++;
+				*(path+i) = '/'; strcpy(path+i+1, &finfo.fname[0]);
+				res = scan_files(path);
+				*(path+i) = '\0';
+				if (res != FR_OK) break;
+			} else {
+				acc_files++;
+				acc_size += finfo.fsize;
+			}
+		}
+	}
+
+	return res;
+}
+
+
+static
+void put_rc (FRESULT rc)
+{
+	const prog_char *p;
+	static const prog_char str[] =
+		"OK\0" "DISK_ERR\0" "INT_ERR\0" "NOT_READY\0" "NO_FILE\0" "NO_PATH\0"
+		"INVALID_NAME\0" "DENIED\0" "EXIST\0" "INVALID_OBJECT\0" "WRITE_PROTECTED\0"
+		"INVALID_DRIVE\0" "NOT_ENABLED\0" "NO_FILE_SYSTEM\0" "MKFS_ABORTED\0" "TIMEOUT\0";
+	FRESULT i;
+
+	for (p = str, i = 0; i != rc && pgm_read_byte_near(p); i++) {
+		while(pgm_read_byte_near(p++));
+	}
+	printf("rc=%u FR_%s\n", (WORD)rc, p);
+}
+
+
+
+
+void test_sdcard (void)
+{
+	char *ptr, *ptr2;
+	DWORD p1, p2, p3;
+	BYTE res, b1;
+	WORD w1;
+	UINT s1, s2, cnt;
+	DWORD ofs, sect = 0;
+	RTC rtc;
+	FATFS *fs;
+	DIR dir;				/* Directory object */
+	FIL file1, file2;		/* File object */
+
+
+    printf("Try to init disk\n");
+    put_rc(f_mount((BYTE) 0, &fatfs[0]));
+    res = f_getfree("", &p2, &fs);
+    if (res)
+        put_rc(res);
+
+    printf(     "FAT TYPE = %u\nBYTES/CLUSTER = %lu\nNUMBER OF FATS = %u\n"
+                "ROOT DIR ENTRIES = %u\nSECTORS/FAT = %lu\nNUMBER OF CLUSTERS = %lu\n"
+                "FAT START = %lu\nDIR START LBA,CLUSTER = %lu\nDATA START LBA = %lu\n",
+                (WORD) fs->fs_type, (DWORD) fs->csize * 512,
+                (WORD) fs->n_fats, fs->n_rootdir, (DWORD) fs->sects_fat,
+                (DWORD) fs->max_clust - 2, fs->fatbase, fs->dirbase, fs->database);
+    acc_size = acc_files = acc_dirs = 0;
+
+    printf("scan files\n");
+    res = scan_files("");
+    if (res)
+        put_rc(res);
+    printf("%u FILES, %lu BYTES\n%u FOLDERS\n"
+                "%lu KB TOTAK DISK SPACE\n%lu KB AVAILABLE\n", acc_files,
+                acc_size, acc_dirs, (fs->max_clust - 2) * (fs->csize / 2),
+                p2 * (fs->csize / 2));
+
+}
+
+

avr/usbload/testing.h

@@ -0,0 +1,31 @@
+/*
+ * =====================================================================================
+ *
+ * ________        .__        __    ________               ____  ________
+ * \_____  \  __ __|__| ____ |  | __\______ \   _______  _/_   |/  _____/
+ *  /  / \  \|  |  \  |/ ___\|  |/ / |    |  \_/ __ \  \/ /|   /   __  \
+ * /   \_/.  \  |  /  \  \___|    <  |    `   \  ___/\   / |   \  |__\  \
+ * \_____\ \_/____/|__|\___  >__|_ \/_______  /\___  >\_/  |___|\_____  /
+ *        \__>             \/     \/        \/     \/                 \/
+ *
+ *                                  www.optixx.org
+ *
+ *
+ *        Version:  1.0
+ *        Created:  07/21/2009 03:32:16 PM
+ *         Author:  david@optixx.org
+ *
+ * =====================================================================================
+ */
+
+
+#ifndef __TESTING_H__
+#define __TESTING_H__
+
+
+void test_read_write();
+void test_bulk_read_write();
+void test_non_zero_memory(uint32_t bottom_addr, uint32_t top_addr);
+void test_crc();
+ 
+#endif

avr/usbload/uart.h

@@ -37,3 +37,4 @@ static int uart_stream(char c, FILE *stream);
 #endif
 
 
+

avr/usbload/usb_bulk.c

@@ -60,16 +60,7 @@ uint8_t usbFunctionWrite(uint8_t * data, uint8_t len)
                rx_remaining, len);
         len = rx_remaining;
     }
-    if (req_state == REQ_STATUS_UPLOAD) {
+    if (req_state == REQ_STATUS_BULK_UPLOAD) {
-
-        rx_remaining -= len;
-        debug(DEBUG_USB_TRANS,"usbFunctionWrite REQ_STATUS_UPLOAD addr: 0x%08lx len: %i rx_remaining=%i\n",
-               req_addr, len, rx_remaining);
-        debug(DEBUG_USB_TRANS,"usbFunctionWrite %02x %02x %02x %02x %02x %02x %02x %x\n",
-        data[0],data[1],data[2],data[3],data[4],data[5],data[6],data[7]);         
-        sram_copy(req_addr, data, len);
-        req_addr += len;
-    } else if (req_state == REQ_STATUS_BULK_UPLOAD) {
 
         rx_remaining -= len;
         debug(DEBUG_USB_TRANS,"usbFunctionWrite REQ_STATUS_BULK_UPLOAD addr: 0x%08lx len: %i rx_remaining=%i\n",

quickdev16.tmproj

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>currentDocument</key>
+	<string>avr/usbload/main.c</string>
 	<key>documents</key>
 	<array>
 		<dict>
@@ -19,6 +21,616 @@
 	<integer>271</integer>
 	<key>metaData</key>
 	<dict>
+		<key>avr/bootloader/config.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>22</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/Makefile</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>11</integer>
+				<key>line</key>
+				<integer>18</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>1</integer>
+		</dict>
+		<key>avr/usbload/commandline/Makefile</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>24</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/commandline/opendevice.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>26</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>3</integer>
+				<key>line</key>
+				<integer>19</integer>
+			</dict>
+		</dict>
+		<key>avr/usbload/commandline/snesuploader.ll</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>36</integer>
+				<key>line</key>
+				<integer>9</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/config.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>23</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/crc.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>31</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>21</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>31</integer>
+			</dict>
+		</dict>
+		<key>avr/usbload/debug.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>31</integer>
+				<key>line</key>
+				<integer>39</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/debug.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>6</integer>
+				<key>line</key>
+				<integer>30</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>4</integer>
+				<key>line</key>
+				<integer>30</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>11</integer>
+				<key>line</key>
+				<integer>30</integer>
+			</dict>
+		</dict>
+		<key>avr/usbload/dump.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>26</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/dump.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>19</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/fifo.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>17</integer>
+				<key>line</key>
+				<integer>22</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/info.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>4</integer>
+				<key>line</key>
+				<integer>33</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/info.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>22</integer>
+				<key>line</key>
+				<integer>32</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/loader.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>1664</integer>
+		</dict>
+		<key>avr/usbload/loader.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/main.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>452</integer>
+		</dict>
+		<key>avr/usbload/requests.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>19</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/rle.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>14</integer>
+		</dict>
+		<key>avr/usbload/rle.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/shared_memory.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>46</integer>
+		</dict>
+		<key>avr/usbload/shared_memory.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/sram.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>32</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/sram.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>19</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/timer.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>31</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>22</integer>
+		</dict>
+		<key>avr/usbload/timer.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>29</integer>
+			</dict>
+			<key>columnSelection</key>
+			<false/>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+			<key>selectFrom</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>selectTo</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>29</integer>
+			</dict>
+		</dict>
+		<key>avr/usbload/uart.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>26</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/usb_bulk.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>37</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>avr/usbload/watchdog.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>22</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>poc/avr_sdcard/checksize</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>poc/avr_sdcard/fat.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>poc/avr_sdcard/fat.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>poc/avr_sdcard/main.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>422</integer>
+		</dict>
+		<key>poc/avr_sdcard/main.lst</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>405</integer>
+		</dict>
+		<key>poc/avr_sdcard/main.map</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>526</integer>
+		</dict>
+		<key>poc/avr_sdcard/main.sym</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>poc/avr_sdcard/mmc.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>16</integer>
+				<key>line</key>
+				<integer>292</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>5</integer>
+		</dict>
+		<key>poc/avr_sdcard/mmc.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>24</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>4</integer>
+		</dict>
+		<key>scripts/conv_rle.py</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>32</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>7</integer>
+		</dict>
 		<key>snes/banktest/LoadGraphics.asm</key>
 		<dict>
 			<key>caret</key>
@@ -47,7 +659,274 @@
 			<key>firstVisibleLine</key>
 			<integer>211</integer>
 		</dict>
+		<key>snes/loader/main.asm</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>14</integer>
+				<key>line</key>
+				<integer>232</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>259</integer>
+		</dict>
+		<key>snes/loader/routines/joypadread.asm</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>75</integer>
+		</dict>
+		<key>snes/loader/routines/menusystem.asm</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>655</integer>
+		</dict>
+		<key>snes/loader/routines/miscdata.asm</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>5</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/Makefile_ata</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/Makefile_cfc</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/Makefile_cfmm</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/Makefile_mmc</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/cfmm.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/ff.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/ff.h</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/ffsample/avr/main.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>30</integer>
+				<key>line</key>
+				<integer>177</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>152</integer>
+		</dict>
+		<key>tools/ffsample/avr/mmc.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>15</integer>
+		</dict>
+		<key>tools/ffsample/avr/rtc.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>0</integer>
+				<key>line</key>
+				<integer>0</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>0</integer>
+		</dict>
+		<key>tools/huffman/huffman-encode.c</key>
+		<dict>
+			<key>caret</key>
+			<dict>
+				<key>column</key>
+				<integer>14</integer>
+				<key>line</key>
+				<integer>443</integer>
+			</dict>
+			<key>firstVisibleColumn</key>
+			<integer>0</integer>
+			<key>firstVisibleLine</key>
+			<integer>418</integer>
+		</dict>
 	</dict>
+	<key>openDocuments</key>
+	<array>
+		<string>snes/loader/main.asm</string>
+		<string>snes/loader/routines/joypadread.asm</string>
+		<string>snes/loader/routines/menusystem.asm</string>
+		<string>snes/loader/routines/miscdata.asm</string>
+		<string>avr/usbload/main.c</string>
+		<string>tools/huffman/huffman-encode.c</string>
+		<string>scripts/conv_rle.py</string>
+		<string>avr/usbload/loader.h</string>
+		<string>poc/avr_sdcard/fat.h</string>
+		<string>poc/avr_sdcard/fat.c</string>
+		<string>poc/avr_sdcard/main.c</string>
+		<string>poc/avr_sdcard/mmc.c</string>
+		<string>poc/avr_sdcard/main.sym</string>
+		<string>poc/avr_sdcard/mmc.h</string>
+		<string>poc/avr_sdcard/main.map</string>
+		<string>poc/avr_sdcard/main.lst</string>
+		<string>tools/ffsample/avr/Makefile_ata</string>
+		<string>tools/ffsample/avr/ff.h</string>
+		<string>tools/ffsample/avr/ff.c</string>
+		<string>tools/ffsample/avr/Makefile_mmc</string>
+		<string>tools/ffsample/avr/Makefile_cfc</string>
+		<string>tools/ffsample/avr/Makefile_cfmm</string>
+		<string>tools/ffsample/avr/rtc.c</string>
+		<string>tools/ffsample/avr/mmc.c</string>
+		<string>tools/ffsample/avr/main.c</string>
+		<string>tools/ffsample/avr/cfmm.c</string>
+		<string>poc/avr_sdcard/checksize</string>
+		<string>avr/usbload/loader.c</string>
+		<string>avr/usbload/timer.h</string>
+		<string>avr/usbload/timer.c</string>
+		<string>avr/usbload/uart.c</string>
+		<string>avr/usbload/usb_bulk.c</string>
+		<string>avr/usbload/watchdog.c</string>
+		<string>avr/usbload/debug.h</string>
+		<string>avr/usbload/debug.c</string>
+		<string>avr/usbload/fifo.c</string>
+		<string>avr/usbload/commandline/Makefile</string>
+		<string>avr/usbload/info.c</string>
+		<string>avr/usbload/dump.h</string>
+		<string>avr/usbload/info.h</string>
+		<string>avr/bootloader/config.h</string>
+		<string>avr/usbload/config.h</string>
+		<string>avr/usbload/Makefile</string>
+		<string>avr/usbload/shared_memory.c</string>
+		<string>avr/usbload/shared_memory.h</string>
+		<string>avr/usbload/commandline/opendevice.c</string>
+		<string>avr/usbload/sram.h</string>
+		<string>avr/usbload/requests.h</string>
+		<string>avr/usbload/rle.c</string>
+		<string>avr/usbload/sram.c</string>
+		<string>avr/usbload/rle.h</string>
+		<string>avr/usbload/dump.c</string>
+		<string>avr/usbload/crc.c</string>
+		<string>avr/usbload/commandline/snesuploader.ll</string>
+	</array>
 	<key>showFileHierarchyDrawer</key>
 	<false/>
 	<key>showFileHierarchyPanel</key>