Inital commit of stm32f4xx framework.

stm/.gitignore

+build

stm/Makefile

+STMSRC=lib
+FATFSSRC=fatfs
+PYSRC=../py
+BUILD=build
+
+AS = arm-none-eabi-as
+CC = arm-none-eabi-gcc
+LD = arm-none-eabi-ld
+CFLAGS_CORTEX_M4 = -mthumb -mtune=cortex-m4 -mabi=aapcs-linux -mcpu=cortex-m4 -mfloat-abi=hard -DSTM32F40XX -DHSE_VALUE=8000000
+CFLAGS = -I. -I$(PYSRC) -I$(FATFSSRC) -I$(STMSRC) -Wall -ansi -std=gnu99 -Os -DNDEBUG $(CFLAGS_CORTEX_M4)
+CFLAGS_PY = -DEMIT_ENABLE_THUMB
+LDFLAGS = --nostdlib -T stm.ld
+
+SRC_C = \
+	main.c \
+	printf.c \
+	system_stm32f4xx.c \
+	flash.c \
+	string0.c \
+	malloc0.c \
+	stm32fxxx_it.c \
+	usb.c \
+#	sd.c \
+
+SRC_S = \
+	delay.s \
+	startup_stm32f40xx.s \
+
+PY_O = \
+#	malloc.o \
+	qstr.o \
+	misc.o \
+	lexer.o \
+	parse.o \
+	scope.o \
+	compile.o \
+	emitcommon.o \
+	emitpass1.o \
+	emitbc.o \
+	asmthumb.o \
+	emitnthumb.o \
+	emitinlinethumb.o \
+	runtime.o \
+	vm.o \
+
+SRC_FATFS = \
+	ff.c \
+	diskio.c \
+
+SRC_STM = \
+	stm32f4xx_rcc.c \
+	stm32f4xx_flash.c \
+	stm32f4xx_dma.c \
+	stm32f4xx_exti.c \
+	stm32f4xx_gpio.c \
+	stm_misc.c \
+	usb_core.c \
+	usb_dcd.c \
+	usb_dcd_int.c \
+	usb_bsp.c \
+	usbd_core.c \
+	usbd_ioreq.c \
+	usbd_req.c \
+	usbd_usr.c \
+	usbd_desc.c \
+	usbd_cdc_core.c \
+	usbd_cdc_vcp.c \
+	usbd_msc_bot.c  \
+	usbd_msc_core.c \
+	usbd_msc_data.c \
+	usbd_msc_scsi.c \
+	usbd_storage_msd.c \
+
+# not needed
+#	usb_otg.c \
+#	usb_hcd.c \
+#	usb_hcd_int.c \
+
+# for SD card
+#	stm32f4xx_sdio.c \
+#	stm324x7i_eval.c \
+#	stm324x7i_eval_sdio_sd.c \
+
+OBJ = $(addprefix $(BUILD)/, $(SRC_C:.c=.o) $(SRC_S:.s=.o) $(PY_O) $(SRC_FATFS:.c=.o) $(SRC_STM:.c=.o))
+
+all: $(BUILD) $(BUILD)/flash.dfu
+
+$(BUILD)/flash.dfu: $(BUILD)/flash.bin
+	python2 ~/stm/dfu/dfu.py -b 0x08000000:$< $@
+
+$(BUILD)/flash.bin: $(BUILD)/flash.elf
+	arm-none-eabi-objcopy -O binary -j .isr_vector -j .text -j .data $^ $@
+
+$(BUILD)/flash.elf: $(OBJ)
+	$(LD) $(LDFLAGS) -o $@ $(OBJ)
+	arm-none-eabi-size $@
+
+$(BUILD):
+	mkdir $@
+
+$(BUILD)/%.o: %.s
+	$(AS) -o $@ $<
+
+$(BUILD)/%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+$(BUILD)/%.o: $(FATFSSRC)/%.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+$(BUILD)/%.o: $(STMSRC)/%.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+$(BUILD)/%.o: $(PYSRC)/%.c mpyconfig.h
+	$(CC) $(CFLAGS) $(CFLAGS_PY) -c -o $@ $<
+
+$(BUILD)/emitnthumb.o: $(PYSRC)/emitnative.c $(PYSRC)/emit.h
+	$(CC) $(CFLAGS) $(CFLAGS_PY) -DN_THUMB -c -o $@ $<
+
+# optimising vm for speed, adds only a small amount to code size but makes a huge difference to speed (20% faster)
+$(BUILD)/vm.o: $(PYSRC)/vm.c
+	$(CC) $(CFLAGS) $(CFLAGS_PY) -O3 -c -o $@ $<
+
+$(BUILD)/parse.o: $(PYSRC)/grammar.h
+$(BUILD)/compile.o: $(PYSRC)/grammar.h
+$(BUILD)/emitbc.o: $(PYSRC)/emit.h
+
+clean:
+	/bin/rm -r $(BUILD)
+
+.PHONY: all clean

stm/delay.s

+    .syntax unified
+    .cpu cortex-m4
+    .thumb
+    .text
+    .align  2
+    .global delay_ms
+    .thumb
+    .thumb_func
+    .type   delay_ms, %function
+@ void delay_ms(int ms)
+delay_ms:
+    @ r0 is argument, trashes r2, r3
+    adds    r3, r0, #0
+    b       .L2
+.L5:
+    movw    r2, #55999
+    b       .L3
+.L4:
+    subs    r2, r2, #1
+.L3:
+    cmp     r2, #0
+    bgt     .L4
+    subs    r3, r3, #1
+.L2:
+    cmp     r3, #0
+    bgt     .L5
+    bx      lr
+    .size   delay_ms, .-delay_ms

stm/fatfs/diskio.c

+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2013        */
+/*-----------------------------------------------------------------------*/
+/* If a working storage control module is available, it should be        */
+/* attached to the FatFs via a glue function rather than modifying it.   */
+/* This is an example of glue functions to attach various exsisting      */
+/* storage control module to the FatFs module with a defined API.        */
+/*-----------------------------------------------------------------------*/
+
+#include <stdint.h>
+#include <stdio.h>
+#include "ff.h"        /* FatFs lower layer API */
+#include "diskio.h"        /* FatFs lower layer API */
+
+PARTITION VolToPart[] = {
+    {0, 1},     // Logical drive 0 ==> Physical drive 0, 1st partition
+    /*
+    {0, 2},     // Logical drive 1 ==> Physical drive 0, 2nd partition
+    {0, 3},     // Logical drive 2 ==> Physical drive 0, 3rd partition
+    {1, 0},     // Logical drive 3 ==> Physical drive 1 (auto detection)
+    */
+};
+
+#define PD_FLASH_SECTOR_SIZE (512)
+#define PD_FLASH_PART1_START_SECTOR (0x100)
+#define PD_FLASH_PART1_NUM_SECTORS (128) // 64k
+#define PD_FLASH_MEM_START_ADDR (0x08020000) // 128k above start, first 128k block
+
+#define PD_FLASH_RAM_BUF (0x10000000) // CCM data RAM, 64k
+
+static void pd_flash_init() {
+    printf("IN\n");
+    // fill RAM buffer
+    uint32_t *src = (uint32_t*)PD_FLASH_MEM_START_ADDR;
+    uint32_t *dest = (uint32_t*)PD_FLASH_RAM_BUF;
+    for (int i = 0; i < PD_FLASH_PART1_NUM_SECTORS * PD_FLASH_SECTOR_SIZE / 4; i++) {
+        *dest++ = *src++;
+    }
+}
+
+extern void flash_write(uint32_t flash_dest, const uint32_t *src, uint32_t num_word32);
+
+static void pd_flash_flush() {
+    printf("FL\n");
+    // sync the RAM buffer by writing it to the flash page
+    flash_write(PD_FLASH_MEM_START_ADDR, (const uint32_t*)PD_FLASH_RAM_BUF, PD_FLASH_PART1_NUM_SECTORS * PD_FLASH_SECTOR_SIZE / 4);
+}
+
+static void build_partition(uint8_t *buf, int boot, int type, uint32_t start_sector, uint32_t num_sectors) {
+    buf[0] = boot;
+
+    if (num_sectors == 0) {
+        buf[1] = 0;
+        buf[2] = 0;
+        buf[3] = 0;
+    } else {
+        buf[1] = 0xff;
+        buf[2] = 0xff;
+        buf[3] = 0xff;
+    }
+
+    buf[4] = type;
+
+    if (num_sectors == 0) {
+        buf[5] = 0;
+        buf[6] = 0;
+        buf[7] = 0;
+    } else {
+        buf[5] = 0xff;
+        buf[6] = 0xff;
+        buf[7] = 0xff;
+    }
+
+    buf[8] = start_sector;
+    buf[9] = start_sector >> 8;
+    buf[10] = start_sector >> 16;
+    buf[11] = start_sector >> 24;
+
+    buf[12] = num_sectors;
+    buf[13] = num_sectors >> 8;
+    buf[14] = num_sectors >> 16;
+    buf[15] = num_sectors >> 24;
+}
+
+static DRESULT pd_flash_read_sector(uint8_t *dest, uint32_t sector) {
+    //printf("RD %u\n", sector);
+    if (sector == 0) {
+        // fake the MBR so we can decide on our own partition table
+
+        for (int i = 0; i < 446; i++) {
+            dest[i] = 0;
+        }
+
+        build_partition(dest + 446, 0, 0x01 /* FAT12 */, PD_FLASH_PART1_START_SECTOR, PD_FLASH_PART1_NUM_SECTORS);
+        build_partition(dest + 462, 0, 0, 0, 0);
+        build_partition(dest + 478, 0, 0, 0, 0);
+        build_partition(dest + 494, 0, 0, 0, 0);
+
+        dest[510] = 0x55;
+        dest[511] = 0xaa;
+
+        return RES_OK;
+
+    } else if (PD_FLASH_PART1_START_SECTOR <= sector && sector < PD_FLASH_PART1_START_SECTOR + PD_FLASH_PART1_NUM_SECTORS) {
+        // non-MBR sector(s), just copy straight from flash
+        uint8_t *src = (uint8_t*)PD_FLASH_RAM_BUF + (sector - PD_FLASH_PART1_START_SECTOR) * PD_FLASH_SECTOR_SIZE;
+        for (int i = PD_FLASH_SECTOR_SIZE; i > 0; i--) {
+            *dest++ = *src++;
+        }
+        return RES_OK;
+
+    } else {
+        // bad sector number
+        return RES_ERROR;
+    }
+}
+
+static DRESULT pd_flash_write_sector(const uint8_t *src, uint32_t sector) {
+    printf("WR %u\n", sector);
+    if (sector == 0) {
+        // can't write MBR, but pretend we did
+
+        return RES_OK;
+
+    } else if (PD_FLASH_PART1_START_SECTOR <= sector && sector < PD_FLASH_PART1_START_SECTOR + PD_FLASH_PART1_NUM_SECTORS) {
+        // non-MBR sector(s), copy to RAM buffer
+        uint8_t *dest = (uint8_t*)PD_FLASH_RAM_BUF + (sector - PD_FLASH_PART1_START_SECTOR) * PD_FLASH_SECTOR_SIZE;
+        for (int i = PD_FLASH_SECTOR_SIZE; i > 0; i--) {
+            *dest++ = *src++;
+        }
+        return RES_OK;
+
+    } else {
+        // bad sector number
+        return RES_ERROR;
+    }
+}
+
+/* Definitions of physical drive number for each media */
+#define PD_FLASH (0)
+#define PD_SD    (1)
+
+/*-----------------------------------------------------------------------*/
+/* Initialize a Drive                                                    */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+    BYTE pdrv                /* Physical drive nmuber (0..) */
+)
+{
+    switch (pdrv) {
+        case PD_FLASH :
+            pd_flash_init();
+            return 0;
+    }
+
+    return STA_NOINIT;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Get Disk Status                                                       */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+    BYTE pdrv        /* Physical drive nmuber (0..) */
+)
+{
+    switch (pdrv) {
+        case PD_FLASH :
+            // flash is ready
+            return 0;
+
+        case PD_SD:
+            return STA_NOINIT;
+    }
+
+    return STA_NOINIT;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read (
+    BYTE pdrv,        /* Physical drive nmuber (0..) */
+    BYTE *buff,        /* Data buffer to store read data */
+    DWORD sector,    /* Sector address (LBA) */
+    UINT count        /* Number of sectors to read (1..128) */
+)
+{
+    DRESULT res;
+    switch (pdrv) {
+        case PD_FLASH:
+            for (int i = 0; i < count; i++) {
+                if ((res = pd_flash_read_sector(buff + i * PD_FLASH_SECTOR_SIZE, sector + i)) != RES_OK) {
+                    return res;
+                }
+            }
+            return RES_OK;
+    }
+
+    return RES_PARERR;
+}
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+#if _USE_WRITE
+DRESULT disk_write (
+    BYTE pdrv,            /* Physical drive nmuber (0..) */
+    const BYTE *buff,    /* Data to be written */
+    DWORD sector,        /* Sector address (LBA) */
+    UINT count            /* Number of sectors to write (1..128) */
+)
+{
+    DRESULT res;
+    switch (pdrv) {
+        case PD_FLASH:
+            for (int i = 0; i < count; i++) {
+                if ((res = pd_flash_write_sector(buff + i * PD_FLASH_SECTOR_SIZE, sector + i)) != RES_OK) {
+                    return res;
+                }
+            }
+            return RES_OK;
+    }
+
+    return RES_PARERR;
+}
+#endif
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+#if _USE_IOCTL
+DRESULT disk_ioctl (
+    BYTE pdrv,        /* Physical drive nmuber (0..) */
+    BYTE cmd,        /* Control code */
+    void *buff        /* Buffer to send/receive control data */
+)
+{
+    switch (pdrv) {
+        case PD_FLASH:
+            switch (cmd) {
+                case CTRL_SYNC:
+                    pd_flash_flush();
+                    return RES_OK;
+
+                case GET_BLOCK_SIZE:
+                    *((DWORD*)buff) = 1; // block erase size in units of the sector size
+                    return RES_OK;
+            }
+    }
+
+    return RES_PARERR;
+}
+#endif
+
+DWORD get_fattime (
+    void
+)
+{
+    int year = 2013;
+    int month = 10;
+    int day = 12;
+    int hour = 21;
+    int minute = 42;
+    int second = 13;
+    return ((year - 1980) << 25) | ((month) << 21) | ((day) << 16) | ((hour) << 11) | ((minute) << 5) | (second / 2);
+}

stm/fatfs/diskio.h

+/*-----------------------------------------------------------------------
+/  Low level disk interface modlue include file   (C)ChaN, 2013
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define _USE_WRITE	1	/* 1: Enable disk_write function */
+#define _USE_IOCTL	1	/* 1: Enable disk_ioctl fucntion */
+
+#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 pdrv);
+DSTATUS disk_status (BYTE pdrv);
+DRESULT disk_read (BYTE pdrv, BYTE*buff, DWORD sector, UINT count);
+DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
+DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
+
+DWORD get_fattime (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 fucntion */
+
+/* Generic command (used by FatFs) */
+#define CTRL_SYNC			0	/* Flush disk cache (for write functions) */
+#define GET_SECTOR_COUNT	1	/* Get media size (for only f_mkfs()) */
+#define GET_SECTOR_SIZE		2	/* Get sector size (for multiple sector size (_MAX_SS >= 1024)) */
+#define GET_BLOCK_SIZE		3	/* Get erase block size (for only f_mkfs()) */
+#define CTRL_ERASE_SECTOR	4	/* Force erased a block of sectors (for only _USE_ERASE) */
+
+/* Generic command (not used by FatFs) */
+#define CTRL_POWER			5	/* Get/Set power status */
+#define CTRL_LOCK			6	/* Lock/Unlock media removal */
+#define CTRL_EJECT			7	/* Eject media */
+#define CTRL_FORMAT			8	/* Create physical format on the media */
+
+/* MMC/SDC specific ioctl command */
+#define MMC_GET_TYPE		10	/* Get card type */
+#define MMC_GET_CSD			11	/* Get CSD */
+#define MMC_GET_CID			12	/* Get CID */
+#define MMC_GET_OCR			13	/* Get OCR */
+#define MMC_GET_SDSTAT		14	/* Get SD status */
+
+/* ATA/CF specific ioctl command */
+#define ATA_GET_REV			20	/* Get F/W revision */
+#define ATA_GET_MODEL		21	/* Get model name */
+#define ATA_GET_SN			22	/* Get serial number */
+
+
+/* MMC card type flags (MMC_GET_TYPE) */
+#define CT_MMC		0x01		/* MMC ver 3 */
+#define CT_SD1		0x02		/* SD ver 1 */
+#define CT_SD2		0x04		/* SD ver 2 */
+#define CT_SDC		(CT_SD1|CT_SD2)	/* SD */
+#define CT_BLOCK	0x08		/* Block addressing */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

stm/fatfs/ff.h

+/*---------------------------------------------------------------------------/
+/  FatFs - FAT file system module include file  R0.10     (C)ChaN, 2013
+/----------------------------------------------------------------------------/
+/ FatFs module is a generic FAT file system module for small embedded systems.
+/ This is a free software that opened for education, research and commercial
+/ developments under license policy of following terms.
+/
+/  Copyright (C) 2013, 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 product UNDER YOUR RESPONSIBILITY.
+/ * Redistributions of source code must retain the above copyright notice.
+/
+/----------------------------------------------------------------------------*/
+
+#ifndef _FATFS
+#define _FATFS	80960	/* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "integer.h"	/* Basic integer types */
+#include "ffconf.h"		/* FatFs configuration options */
+
+#if _FATFS != _FFCONF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+
+/* Definitions of volume management */
+
+#if _MULTI_PARTITION		/* Multiple partition configuration */
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+extern PARTITION VolToPart[];	/* Volume - Partition resolution table */
+#define LD2PD(vol) (VolToPart[vol].pd)	/* Get physical drive number */
+#define LD2PT(vol) (VolToPart[vol].pt)	/* Get partition index */
+
+#else							/* Single partition configuration */
+#define LD2PD(vol) (BYTE)(vol)	/* Each logical drive is bound to the same physical drive number */
+#define LD2PT(vol) 0			/* Find first valid partition or in SFD */
+
+#endif
+
+
+
+/* Type of path name strings on FatFs API */
+
+#if _LFN_UNICODE			/* Unicode string */
+#if !_USE_LFN
+#error _LFN_UNICODE must be 0 in non-LFN cfg.
+#endif
+#ifndef _INC_TCHAR
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#endif
+
+#else						/* ANSI/OEM string */
+#ifndef _INC_TCHAR
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#endif
+
+#endif
+
+
+
+/* File system object structure (FATFS) */
+
+typedef struct {
+	BYTE	fs_type;		/* FAT sub-type (0:Not mounted) */
+	BYTE	drv;			/* Physical drive number */
+	BYTE	csize;			/* Sectors per cluster (1,2,4...128) */
+	BYTE	n_fats;			/* Number of FAT copies (1 or 2) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
+	WORD	id;				/* File system mount ID */
+	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
+#if _MAX_SS != 512
+	WORD	ssize;			/* Bytes per sector (512, 1024, 2048 or 4096) */
+#endif
+#if _FS_REENTRANT
+	_SYNC_t	sobj;			/* Identifier of sync object */
+#endif
+#if !_FS_READONLY
+	DWORD	last_clust;		/* Last allocated cluster */
+	DWORD	free_clust;		/* Number of free clusters */
+#endif
+#if _FS_RPATH
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
+#endif
+	DWORD	n_fatent;		/* Number of FAT entries (= number of clusters + 2) */
+	DWORD	fsize;			/* Sectors per FAT */
+	DWORD	volbase;		/* Volume start sector */
+	DWORD	fatbase;		/* FAT start sector */
+	DWORD	dirbase;		/* Root directory start sector (FAT32:Cluster#) */
+	DWORD	database;		/* Data start sector */
+	DWORD	winsect;		/* Current sector appearing in the win[] */
+	BYTE	win[_MAX_SS];	/* Disk access window for Directory, FAT (and file data at tiny cfg) */