[z180-stamp.git] / stm32 / z180-stamp-stm32.c

/*
 */

#include <errno.h>
#include <stdio.h>
#include <unistd.h>

#include <libopencmsis/core_cm3.h>
#include <libopencm3/cm3/nvic.h>
#include <libopencm3/cm3/systick.h>
#include <libopencm3/stm32/rtc.h>
#include <libopencm3/stm32/usart.h>
#include <libopencm3/stm32/rcc.h>
#include <libopencm3/stm32/gpio.h>
#include <libopencm3/stm32/timer.h>

#define ODR	0x0c
#define IDR	0x08


/*
#define __ASM            __asm
#define __STATIC_INLINE  static inline

__attribute__((always_inline)) __STATIC_INLINE void __enable_irq(void)
{
  __ASM volatile ("cpsie i");
}

__attribute__((always_inline)) __STATIC_INLINE void __disable_irq(void)
{
  __ASM volatile ("cpsid i");
}
*/


#include "z80-if.h"
#include "hdrom.h"

#define USART_CONSOLE USART1

int _write(int fd, char *ptr, int len)  __attribute__((used));

#define S_10MS_TO	(1<<0)

/*
 * LED Connections
 */

#define LED_PORT	GPIOC
#define LED_BLUE_PIN	GPIO8
#define BLUE		8
#define LED_GREEN_PIN	GPIO9
#define GREEN		9


#define LED_BLUE_ON()     BBIO_PERIPH(LED_PORT+ODR, BLUE) = 1
#define LED_BLUE_OFF()    BBIO_PERIPH(LED_PORT+ODR, BLUE) = 0
#define LED_BLUE_TOGGLE() BBIO_PERIPH(LED_PORT+ODR, BLUE) = !BBIO_PERIPH(LED_PORT+ODR, BLUE)

#define LED_GREEN_ON()     BBIO_PERIPH(LED_PORT+ODR, GREEN) = 1
#define LED_GREEN_OFF()    BBIO_PERIPH(LED_PORT+ODR, GREEN) = 0
#define LED_GREEN_TOGGLE() BBIO_PERIPH(LED_PORT+ODR, GREEN) = !BBIO_PERIPH(LED_PORT+ODR, GREEN)


/*
 * Button connections
 */

//BBIO_PERIPH(GPIOA+IDR, 0);

#define KEY_PORT	GPIOA_IDR
#define KEY0		GPIO0
//#define KEY1		GPIO1
//#define KEY2		GPIO2

#define REPEAT_MASK	KEY0		// repeat: key0
#define REPEAT_START	100		// after 1s
#define REPEAT_NEXT	20		// every 200ms


typedef enum {
	NOTHING, PULSE, BLINK1, BLINK2
} LED_MODE;

typedef struct {
	uint8_t mode;
	uint8_t ontime, offtime;
} led_stat_t;

volatile uint8_t led_timer[2];
led_stat_t led_stat[2];

volatile int timeout_1s;
volatile uint32_t Stat;


/*--------------------------------------------------------------------------*/


static void clock_setup(void)
{
	rcc_clock_setup_in_hse_8mhz_out_24mhz();

	/* Enable clocks for:
		GPIO port A (for GPIO_USART1_TX and Button)
		GPIO port C (LEDs) 
		USART1
		TIM16 (RST-Pin) 
		TIM1  (IOE)
	   TODO: USART1 --> USART_CONSOLE
	*/
	rcc_peripheral_enable_clock(&RCC_APB2ENR, 
			  RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN 
			| RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN 
			| RCC_APB2ENR_USART1EN | RCC_APB2ENR_AFIOEN
			| RCC_APB2ENR_TIM1EN | RCC_APB2ENR_TIM16EN);
	/* Enable clocks for:
		TIM3
	*/
	rcc_peripheral_enable_clock(&RCC_APB1ENR, 
			RCC_APB1ENR_TIM3EN);

	/* Enable clocks for:
		TIM3
	*/
	rcc_peripheral_enable_clock(&RCC_AHBENR, 
			RCC_AHBENR_DMA1EN);
}

static void systick_setup(void)
{
	/* SysTick interrupt every N clock pulses: set reload to N-1 */
	STK_RVR = 24000000/1000 - 1;

	/* Set source to core clock, enable int and start counting. */
	STK_CSR = STK_CSR_CLKSOURCE_AHB | STK_CSR_TICKINT | STK_CSR_ENABLE;
}

#if 0
static void nvic_setup(void)
{
//	nvic_enable_irq(NVIC_RTC_IRQ);
//	nvic_set_priority(NVIC_RTC_IRQ, 1);
}
#endif

static void tim3_setup(void)
{
	TIM3_CR1 = TIM_CR1_CMS_EDGE | TIM_CR1_DIR_UP;
		
	TIM3_CCMR2 = 0
		| TIM_CCMR2_OC4M_FORCE_LOW	
	/*	| TIM_CCMR2_OC4M_FORCE_HIGH	*/
	/*	| TIM_CCMR2_OC4M_PWM2		*/
		
	/*	| TIM_CCMR2_OC4PE		*/
	/*	| TIM_CCMR2_OC4FE		*/
		| TIM_CCMR2_CC4S_OUT;
		
	TIM3_CCER = TIM_CCER_CC4E
		| TIM_CCER_CC4P;
	
	TIM3_ARR = 48;	/* default */
	TIM3_CCR4 = 1;	/*  */
}

static void gpio_setup(void)
{

	/* Disable JTAG-DP, but leave SW-DP Enabled. (free PA15, PB3, PB4)
	   Remap SPI1 to PB3, PB4, PB5 and PA15.
	   Remap TIM3 (CH1/PC6, CH2/PC7, CH3/PC8, CH4/PC9)
	*/
	gpio_primary_remap(AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON, 
		AFIO_MAPR_SPI1_REMAP | AFIO_MAPR_TIM3_REMAP_FULL_REMAP);

	/* LEDs and User Button. */
	gpio_set_mode(LED_PORT, GPIO_MODE_OUTPUT_2_MHZ,
		      GPIO_CNF_OUTPUT_PUSHPULL, LED_BLUE_PIN);
	gpio_set_mode(LED_PORT, GPIO_MODE_OUTPUT_10_MHZ,
		      GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, LED_GREEN_PIN);
	gpio_set_mode(GPIOA, GPIO_MODE_INPUT,
		      GPIO_CNF_INPUT_FLOAT, GPIO0);
}


static void usart_setup(void)
{
	/* Setup GPIO pin GPIO_USART1_TX/LED_GREEN_PIN on GPIO port A for transmit. */
	/* TODO: USART1 --> USART_CONSOLE */

	gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ,
		      GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_TX);

	/* Setup UART parameters. */
//	usart_set_baudrate(USART_CONSOLE, 38400);
	usart_set_baudrate(USART_CONSOLE, 115200);
	usart_set_databits(USART_CONSOLE, 8);
	usart_set_stopbits(USART_CONSOLE, USART_STOPBITS_1);
	usart_set_mode(USART_CONSOLE, USART_MODE_TX_RX);
	usart_set_parity(USART_CONSOLE, USART_PARITY_NONE);
	usart_set_flow_control(USART_CONSOLE, USART_FLOWCONTROL_NONE);

	/* Finally enable the USART. */
	usart_enable(USART_CONSOLE);
}

/*--------------------------------------------------------------------------*/

/**
 * Use USART_CONSOLE as a console.
 * This is a syscall for newlib
 * @param fd
 * @param ptr
 * @param len
 * @return
 */
int _write(int fd, char *ptr, int len)
{
	int i;

	if (fd == STDOUT_FILENO || fd == STDERR_FILENO) {
		for (i = 0; i < len; i++) {
			if (ptr[i] == '\n') {
				usart_send_blocking(USART_CONSOLE, '\r');
			}
			usart_send_blocking(USART_CONSOLE, ptr[i]);
		}
		return i;
	}
	errno = EIO;
	return -1;
}


/*--------------------------------------------------------------------------*/

void delay_systicks(int ticks)
{
	int start, stop, now;
	
	start = STK_CVR;
	stop = start - ticks;
	if (stop < 0) {
		stop += STK_RVR;
		do {
			now = STK_CVR;
		} while ((now > stop) || (now <= start));
	} else {
		do {
			now = STK_CVR;
		} while ((now > stop) && (now <= start));
	}
}


/*--------------------------------------------------------------------------*/

static void led_toggle(uint8_t lednr) {
	if (lednr == 0)
		LED_BLUE_TOGGLE();
	else if (lednr == 1)
		LED_GREEN_TOGGLE();
}

static void led_on(uint8_t lednr) {
	if (lednr == 0)
		LED_BLUE_ON();
	else if (lednr == 1)
		LED_GREEN_ON();
}

static void led_off(uint8_t lednr) {
	if (lednr == 0)
		LED_BLUE_OFF();
	else if (lednr == 1)
		LED_GREEN_OFF();
}

static uint8_t led_is_on(uint8_t lednr) {
	if (lednr == 0)
		return BBIO_PERIPH(LED_PORT+ODR, BLUE);
	else if (lednr == 1)
		return BBIO_PERIPH(LED_PORT+ODR, GREEN);
	else
		return 0;
}

static void ledset(uint8_t lednr, uint8_t what, uint8_t len) {

	led_stat[lednr].mode = what;
	switch (what) {
	case PULSE:
		led_stat[lednr].ontime = len;
		led_stat[lednr].offtime = 0;
		led_timer[lednr] = len;
		led_on(lednr);
		break;
	case BLINK1:
	case BLINK2:
		if (what == BLINK1)
			led_stat[lednr].offtime = 100 - len;
		else
			led_stat[lednr].offtime = 200 - len;
		led_stat[lednr].ontime = len;
		led_timer[lednr] = len;
		led_on(lednr);
		break;
	default:
		break;
	}
}

/*--------------------------------------------------------------------------*/

static volatile uint16_t key_state,
		key_press, // key press detect
		key_rpt; // key long press and repeat


static uint16_t get_key_press(uint16_t key_mask) {
	__disable_irq();
	// read and clear atomic !
	key_mask &= key_press; // read key(s)
	key_press ^= key_mask; // clear key(s)
	__enable_irq();
	return key_mask;
}

static uint16_t get_key_rpt(uint16_t key_mask) {
	__disable_irq();
	// read and clear atomic !
	key_mask &= key_rpt; // read key(s)
	key_rpt ^= key_mask; // clear key(s)
	__enable_irq();
	return key_mask;
}

static uint16_t get_key_short(uint16_t key_mask) {
	__disable_irq();
	// read key state and key press atomic !
	return get_key_press(key_state & key_mask);
}

/*
static uint16_t get_key_long(uint16_t key_mask) {
	return get_key_press(get_key_rpt(key_mask));
}
*/

static void key_timerproc() {
	static uint16_t key_in_last, rpt;
	uint16_t key_in, c;

	key_in = KEY_PORT;

	c = key_in_last & key_in & ~key_state;

//	key_state = key_state  & key_in_last | (key_state  | key_in_last) & key_in;
//	key_state = key_state  & key_in      | (key_state  | key_in)      & key_in_last;

	key_state = c | ((key_in_last | key_in) & key_state);
		
//	key_state = (key_state&key_in_last) | (key_state&key_in) | (key_in_last&key_in);

	key_press |= c;
	
	key_in_last = key_in;
	

	if ((key_state & REPEAT_MASK) == 0) // check repeat function
		rpt = REPEAT_START;
	if (--rpt == 0) {
		rpt = REPEAT_NEXT; // repeat delay
		key_rpt |= key_state & REPEAT_MASK;
	}


#if 0

static char ds[30];
int dsi = 0;

ds[dsi++] = key_state & 1   ? '1' : '0';
ds[dsi++] = key_in_last & 1 ? '1' : '0';
ds[dsi++] = key_in & 1      ? '1' : '0';
ds[dsi++] = ' ';

//ds[dsi++] = key_state & 1   ? '1' : '0';
//ds[dsi++] = key_in_last & 1 ? '1' : '0';

//ds[dsi++] = ' ';
//ds[dsi++] = ' ';
ds[dsi++] = 0;
puts(ds);	
#endif

}

/*--------------------------------------------------------------------------*/

void sys_tick_handler(void)
{
	static int tick_10ms = 0;
	static int count_ms = 0;

	int i;

	++tick_10ms;
	if (tick_10ms == 10)
	{
		Stat |= S_10MS_TO;

		tick_10ms = 0;
		
		i = led_timer[0];
		if (i)
			led_timer[0] = i - 1;
		i = led_timer[1];
		if (i)
			led_timer[1] = i - 1;

		key_timerproc();
		
		/* Drive timer procedure of low level disk I/O module */
		//disk_timerproc();
	}
	
	count_ms++;
	if (count_ms == 1000) {
		count_ms = 0;

		if (timeout_1s)
			--timeout_1s;
	}
}

void rtc_isr(void)
{
	/* The interrupt flag isn't cleared by hardware, we have to do it. */
	rtc_clear_flag(RTC_SEC);

}

/*--------------------------------------------------------------------------*/

void tim3_set(int mode)
{
	uint16_t cc_mode;
	
	cc_mode = TIM_CCMR2_CC4S_OUT;

	TIM3_CR1 = TIM_CR1_CMS_EDGE | TIM_CR1_DIR_UP | TIM_CR1_OPM;

	if (mode < 0)
		cc_mode |= TIM_CCMR2_OC4M_FORCE_LOW;
	else if (mode == 0)
		cc_mode |= TIM_CCMR2_OC4M_FORCE_HIGH;
	else {
		TIM3_ARR = mode;
		cc_mode |= TIM_CCMR2_OC4M_PWM2;
	}
			
	TIM3_CCMR2 = cc_mode;
		
	if (mode > 0)
		TIM3_CR1 |= TIM_CR1_CEN;
}

/*--------------------------------------------------------------------------*/

static uint32_t z80_sram_cmp(uint32_t addr, int length, uint8_t wval, int inc)
{
	uint8_t rval;
	int errors = 0;
	
	printf("SRAM: Check %#.5x byte... ", length); //fflush(stdout);
	while (length--) {
		if ((rval = z80_read(addr)) != wval) {
			if (errors == 0) { 
				printf("\nSRAM: Address  W  R\n" \
				       "      -------------\n");
//					       12345  00 11
			}
			printf("       %.5lx  %.2x %.2x\n", addr, wval, rval);
			
			if (++errors > 16 )
				break;
		}
		addr++;
		wval += inc;
	}
	printf("Done.\n");

	return addr;
}

#if 0
static void z80_sram_fill(uint32_t addr, int length, uint8_t startval, int inc)
{
	printf("SRAM: Write %#.5x byte... ", length); //fflush(stdout);
	while (length--) {
		z80_write(addr, startval);
		++addr; 
		startval += inc;
	}
	printf("Done.\n");
}


void z80_sram_fill_string(uint32_t addr, int length, const char *text)
{
	char c;
	const char *p = text;

	while (length--) {
		z80_write(addr++, c = *p++);
		if (c == 0)
			p = text;
	}
}


uint32_t z80_sram_cmp_string(uint32_t addr, int length, const char *text)
{
	char c;
	const char *p = text;

	while (length--) {
		c = *p++;
		if (z80_read(addr) != c)
			break;
		++addr;
		if (c == 0)
			p = text;
	}
	return addr;
}

const char * const qbfox = "Zhe quick brown fox jumps over the lazy dog!";
const char * const qbcat = "Zhe quick brown fox jumps over the lazy cat!";

#endif

uint8_t z80_get_byte(uint32_t adr)
{
	uint8_t data;
	
	z80_get_bus();
	data = z80_read(adr),
	z80_release_bus();
	
	return data;
}


/*--------------------------------------------------------------------------*/

static void do_10ms(void) 
{
	for (uint8_t i = 0; i < 2; i++) {
		switch (led_stat[i].mode) {
		case PULSE:
			if (led_timer[i] == 0) {
				led_off(i);
				led_stat[i].mode = NOTHING;
			}
			break;
		case BLINK1:
		case BLINK2:
			if (led_timer[i] == 0) {
				if (led_is_on(i))
					led_timer[i] = led_stat[i].offtime;
				else
					led_timer[i] = led_stat[i].ontime;
				led_toggle(i);
			}
			break;
		default:
			break;
		}
	}
}

/*--------------------------------------------------------------------------*/

int main(void)
{
	//uint32_t led_state = LED_BLUE_PIN;
	//uint32_t rc;
	//uint8_t startval = 0;
	//int count;
	int stat, ch;
	uint8_t c;

	clock_setup();
	gpio_setup();
	tim3_setup();
	setvbuf(stdout, NULL, _IONBF, 0);
	usart_setup();
	printf("Hello World!\n");

	z80_setup_bus();
	printf("z80_setup_bus done.\n");

	/*
	 * If the RTC is pre-configured just allow access, don't reconfigure.
	 * Otherwise enable it with the LSE as clock source and 0x7fff as
	 * prescale value.
	 */
	rtc_auto_awake(LSE, 0x7fff);

	systick_setup();
	///* Setup the RTC interrupt. */
	//nvic_setup();

	/* Enable the RTC interrupt to occur off the SEC flag. */
	//rtc_interrupt_enable(RTC_SEC);

	printf("get bus...");
	z80_busreq(LOW);
	z80_reset(HIGH);
	z80_get_bus();
	printf(" got it!\n");
	
	z80_memset(0, 0x76, 0x80000);
	//z80_sram_fill(0, 512 * 1024, 0x76, 0);
	z80_sram_cmp(0, 512 * 1024, 0x76, 0);
	
	z80_write_block((unsigned char *) hdrom, 0, hdrom_length);	
	z80_reset(LOW);
	printf("bus released! ");
	z80_release_bus();
	z80_reset(HIGH);
	printf(" reset released!\n");
	
	timeout_1s = 6;
	while (timeout_1s) {
		static int to=0;
		uint8_t b, rc, tc, m;
		if (to != timeout_1s) {
			b  = z80_get_byte(tx_fifo-0),
			rc = z80_get_byte(tx_fifo-1),
			tc = z80_get_byte(tx_fifo-2),
			m  =z80_get_byte(tx_fifo-3);
			printf(" %.2x  %.2x  %.2x  %.2x\n",
				b, rc, tc, m);
			to = timeout_1s;

			if ((rc==0) && (m==0x7f))
				break;
		}
	}
 
	z80_fifo_init();
	
	ledset(0, BLINK1, 50);

	while (1) {
//		static int tickstat = 0;
		
		if (Stat & S_10MS_TO) {
			Stat &= ~S_10MS_TO;
			do_10ms();
		}


//		if (get_key_long(KEY0))
//			ledset(1, PULSE, 100);
			
		if (get_key_short(KEY0))
			z80_reset_pulse();


/*
		switch (tickstat) {
		
			case 0:
				if (BBIO_PERIPH(GPIOA+IDR, 0))
				{
					tickstat = 1;

					LED_GREEN_ON();
					LED_GREEN_OFF();
					LED_GREEN_ON();
					delay_systicks(12);
					LED_GREEN_OFF();
				}
				break;
			default:
				if (!BBIO_PERIPH(GPIOA+IDR, 0))
					tickstat = 0;
		}
*/

		//BBIO_PERIPH(LED_PORT+0x0C, 9) = BBIO_PERIPH(GPIOA+0x08, 0);
		
		//BBIO_PERIPH(LED_PORT+0x0C, 9) = !z80_stat_halt();
		
		//BBIO_PERIPH(LED_PORT+0x0C, 9) = (~key_state & KEY0) != 0;
		

/*
		stat = z80_fifo_is_not_full(rx_fifo);
		if(stat) {
			z80_fifo_putc(rx_fifo, 'y');
			if (++count == 154) {
				putchar('\n');
				putchar('\r');
				count = 0;
			}

		}
*/

		stat = 	usart_get_flag(USART_CONSOLE, USART_SR_RXNE);
		if (stat) {
			c = usart_recv(USART_CONSOLE) & 0xff;
			switch (c) {
				case 'H':
					tim3_set(-1);
					break;
				case 'L':
					tim3_set(0);
					break;
				case 'P':
					tim3_set(24000000/1000000 * 5); /* 5 us */
					break;
				default:
					z80_fifo_putc(fifo_out, c);
			}
		}

		if (timeout_1s == 0) {
		
			while (z80_fifo_is_not_empty(fifo_in)) {
//				LED_GREEN_ON();
				c = z80_fifo_getc(fifo_in);
				putchar(c);
//				LED_GREEN_OFF();
			}
			
			timeout_1s = 1;
		}
		
		while ((ch = z80_inbuf_getc()) >= 0)
			printf(" 0x%.2X ", ch);
	}

	return 0;
}

#if 0

static char ds[30];
int dsi = 0;

ds[dsi++] = key_state1 & 1  ? '1' : '0';
ds[dsi++] = key_in_last & 1 ? '1' : '0';
ds[dsi++] = key_in & 1      ? '1' : '0';
ds[dsi++] = ' ';
ds[dsi++] = key_state1 & 1  ? '1' : '0';
ds[dsi++] = key_in_last & 1 ? '1' : '0';

ds[dsi++] = ' ';
ds[dsi++] = ' ';
ds[dsi++] = key_state & 1  ? '1' : '0';
ds[dsi++] = ct1 & 1  ? '0' : '1';
ds[dsi++] = ct0 & 1  ? '0' : '1';
ds[dsi++] = ' ';
ds[dsi++] = key_state & 1  ? '1' : '0';
//ds[dsi++] = '\r';
//ds[dsi++] = '\n';
ds[dsi++] = 0;
puts(ds);	
#endif
Commit	Line	Data
e64eba00 L	1	/*
	2	*/
	3
	4	#include <errno.h>
	5	#include <stdio.h>
	6	#include <unistd.h>
	7
	8	#include <libopencmsis/core_cm3.h>
	9	#include <libopencm3/cm3/nvic.h>
	10	#include <libopencm3/cm3/systick.h>
	11	#include <libopencm3/stm32/rtc.h>
	12	#include <libopencm3/stm32/usart.h>
	13	#include <libopencm3/stm32/rcc.h>
	14	#include <libopencm3/stm32/gpio.h>
	15	#include <libopencm3/stm32/timer.h>
	16
	17	#define ODR 0x0c
	18	#define IDR 0x08
	19
	20
	21	/*
	22	#define __ASM __asm
	23	#define __STATIC_INLINE static inline
	24
	25	__attribute__((always_inline)) __STATIC_INLINE void __enable_irq(void)
	26	{
	27	__ASM volatile ("cpsie i");
	28	}
	29
	30	__attribute__((always_inline)) __STATIC_INLINE void __disable_irq(void)
	31	{
	32	__ASM volatile ("cpsid i");
	33	}
	34	*/
	35
	36
	37
	38	#include "z80-if.h"
	39	#include "hdrom.h"
	40
	41	#define USART_CONSOLE USART1
	42
	43	int _write(int fd, char *ptr, int len) __attribute__((used));
	44
	45	#define S_10MS_TO (1<<0)
	46
	47	/*
	48	* LED Connections
	49	*/
	50
	51	#define LED_PORT GPIOC
	52	#define LED_BLUE_PIN GPIO8
	53	#define BLUE 8
	54	#define LED_GREEN_PIN GPIO9
	55	#define GREEN 9
	56
	57
	58	#define LED_BLUE_ON() BBIO_PERIPH(LED_PORT+ODR, BLUE) = 1
	59	#define LED_BLUE_OFF() BBIO_PERIPH(LED_PORT+ODR, BLUE) = 0
	60	#define LED_BLUE_TOGGLE() BBIO_PERIPH(LED_PORT+ODR, BLUE) = !BBIO_PERIPH(LED_PORT+ODR, BLUE)
	61
	62	#define LED_GREEN_ON() BBIO_PERIPH(LED_PORT+ODR, GREEN) = 1
	63	#define LED_GREEN_OFF() BBIO_PERIPH(LED_PORT+ODR, GREEN) = 0
	64	#define LED_GREEN_TOGGLE() BBIO_PERIPH(LED_PORT+ODR, GREEN) = !BBIO_PERIPH(LED_PORT+ODR, GREEN)
65
66
67	/*
68	* Button connections
69	*/
70
71	//BBIO_PERIPH(GPIOA+IDR, 0);
72
73	#define KEY_PORT GPIOA_IDR
74	#define KEY0 GPIO0
75	//#define KEY1 GPIO1
76	//#define KEY2 GPIO2
77
78	#define REPEAT_MASK KEY0 // repeat: key0
79	#define REPEAT_START 100 // after 1s
80	#define REPEAT_NEXT 20 // every 200ms
81
82
83	typedef enum {
84	NOTHING, PULSE, BLINK1, BLINK2
85	} LED_MODE;
86
87	typedef struct {
88	uint8_t mode;
89	uint8_t ontime, offtime;
90	} led_stat_t;
91
92	volatile uint8_t led_timer[2];
93	led_stat_t led_stat[2];
94
95	volatile int timeout_1s;
96	volatile uint32_t Stat;
97
98
99	/--------------------------------------------------------------------------/
100
101
102	static void clock_setup(void)
103	{
104	rcc_clock_setup_in_hse_8mhz_out_24mhz();
105
106	/* Enable clocks for:
107	GPIO port A (for GPIO_USART1_TX and Button)
108	GPIO port C (LEDs)
109	USART1
110	TIM16 (RST-Pin)
111	TIM1 (IOE)
112	TODO: USART1 --> USART_CONSOLE
113	*/
114	rcc_peripheral_enable_clock(&RCC_APB2ENR,
115	RCC_APB2ENR_IOPAEN \| RCC_APB2ENR_IOPBEN
116	\| RCC_APB2ENR_IOPCEN \| RCC_APB2ENR_IOPDEN
117	\| RCC_APB2ENR_USART1EN \| RCC_APB2ENR_AFIOEN
118	\| RCC_APB2ENR_TIM1EN \| RCC_APB2ENR_TIM16EN);
119	/* Enable clocks for:
120	TIM3
121	*/
122	rcc_peripheral_enable_clock(&RCC_APB1ENR,
123	RCC_APB1ENR_TIM3EN);
124
125	/* Enable clocks for:
126	TIM3
127	*/
128	rcc_peripheral_enable_clock(&RCC_AHBENR,
129	RCC_AHBENR_DMA1EN);
130	}
131
132	static void systick_setup(void)
133	{
134	/* SysTick interrupt every N clock pulses: set reload to N-1 */
135	STK_RVR = 24000000/1000 - 1;
136
137	/* Set source to core clock, enable int and start counting. */
138	STK_CSR = STK_CSR_CLKSOURCE_AHB \| STK_CSR_TICKINT \| STK_CSR_ENABLE;
139	}
140
141	#if 0
142	static void nvic_setup(void)
143	{
144	// nvic_enable_irq(NVIC_RTC_IRQ);
145	// nvic_set_priority(NVIC_RTC_IRQ, 1);
146	}
147	#endif
148
149	static void tim3_setup(void)
150	{
151	TIM3_CR1 = TIM_CR1_CMS_EDGE \| TIM_CR1_DIR_UP;
152
153	TIM3_CCMR2 = 0
154	\| TIM_CCMR2_OC4M_FORCE_LOW
155	/* \| TIM_CCMR2_OC4M_FORCE_HIGH */
156	/* \| TIM_CCMR2_OC4M_PWM2 */
157
158	/* \| TIM_CCMR2_OC4PE */
159	/* \| TIM_CCMR2_OC4FE */
160	\| TIM_CCMR2_CC4S_OUT;
161
162	TIM3_CCER = TIM_CCER_CC4E
163	\| TIM_CCER_CC4P;
164
165	TIM3_ARR = 48; /* default */
166	TIM3_CCR4 = 1; /* */
167	}
168
169	static void gpio_setup(void)
170	{
171
172	/* Disable JTAG-DP, but leave SW-DP Enabled. (free PA15, PB3, PB4)
173	Remap SPI1 to PB3, PB4, PB5 and PA15.
174	Remap TIM3 (CH1/PC6, CH2/PC7, CH3/PC8, CH4/PC9)
175	*/
176	gpio_primary_remap(AFIO_MAPR_SWJ_CFG_JTAG_OFF_SW_ON,
177	AFIO_MAPR_SPI1_REMAP \| AFIO_MAPR_TIM3_REMAP_FULL_REMAP);
178
179	/* LEDs and User Button. */
180	gpio_set_mode(LED_PORT, GPIO_MODE_OUTPUT_2_MHZ,
181	GPIO_CNF_OUTPUT_PUSHPULL, LED_BLUE_PIN);
182	gpio_set_mode(LED_PORT, GPIO_MODE_OUTPUT_10_MHZ,
183	GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, LED_GREEN_PIN);
184	gpio_set_mode(GPIOA, GPIO_MODE_INPUT,
185	GPIO_CNF_INPUT_FLOAT, GPIO0);
186	}
187
188
189	static void usart_setup(void)
190	{
191	/* Setup GPIO pin GPIO_USART1_TX/LED_GREEN_PIN on GPIO port A for transmit. */
192	/* TODO: USART1 --> USART_CONSOLE */
193
194	gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ,
195	GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, GPIO_USART1_TX);
196
197	/* Setup UART parameters. */
198	// usart_set_baudrate(USART_CONSOLE, 38400);
199	usart_set_baudrate(USART_CONSOLE, 115200);
200	usart_set_databits(USART_CONSOLE, 8);
201	usart_set_stopbits(USART_CONSOLE, USART_STOPBITS_1);
202	usart_set_mode(USART_CONSOLE, USART_MODE_TX_RX);
203	usart_set_parity(USART_CONSOLE, USART_PARITY_NONE);
204	usart_set_flow_control(USART_CONSOLE, USART_FLOWCONTROL_NONE);
205
206	/* Finally enable the USART. */
207	usart_enable(USART_CONSOLE);
208	}
209
210	/--------------------------------------------------------------------------/
211
212	/**
213	* Use USART_CONSOLE as a console.
214	* This is a syscall for newlib
215	* @param fd
216	* @param ptr
217	* @param len
218	* @return
219	*/
220	int _write(int fd, char *ptr, int len)
221	{
222	int i;
223
224	if (fd == STDOUT_FILENO \|\| fd == STDERR_FILENO) {
225	for (i = 0; i < len; i++) {
226	if (ptr[i] == '\n') {
227	usart_send_blocking(USART_CONSOLE, '\r');
228	}
229	usart_send_blocking(USART_CONSOLE, ptr[i]);
230	}
231	return i;
232	}
233	errno = EIO;
234	return -1;
235	}
236
237
238	/--------------------------------------------------------------------------/
239
240	void delay_systicks(int ticks)
241	{
242	int start, stop, now;
243
244	start = STK_CVR;
245	stop = start - ticks;
246	if (stop < 0) {
247	stop += STK_RVR;
248	do {
249	now = STK_CVR;
250	} while ((now > stop) \|\| (now <= start));
251	} else {
252	do {
253	now = STK_CVR;
254	} while ((now > stop) && (now <= start));
255	}
256	}
257
258
259	/--------------------------------------------------------------------------/
260
261	static void led_toggle(uint8_t lednr) {
262	if (lednr == 0)
263	LED_BLUE_TOGGLE();
264	else if (lednr == 1)
265	LED_GREEN_TOGGLE();
266	}
267
268	static void led_on(uint8_t lednr) {
269	if (lednr == 0)
270	LED_BLUE_ON();
271	else if (lednr == 1)
272	LED_GREEN_ON();
273	}
274
275	static void led_off(uint8_t lednr) {
276	if (lednr == 0)
277	LED_BLUE_OFF();
278	else if (lednr == 1)
279	LED_GREEN_OFF();
280	}
281
282	static uint8_t led_is_on(uint8_t lednr) {
283	if (lednr == 0)
284	return BBIO_PERIPH(LED_PORT+ODR, BLUE);
285	else if (lednr == 1)
286	return BBIO_PERIPH(LED_PORT+ODR, GREEN);
287	else
288	return 0;
289	}
290
291	static void ledset(uint8_t lednr, uint8_t what, uint8_t len) {
292
293	led_stat[lednr].mode = what;
294	switch (what) {
295	case PULSE:
296	led_stat[lednr].ontime = len;
297	led_stat[lednr].offtime = 0;
298	led_timer[lednr] = len;
299	led_on(lednr);
300	break;
301	case BLINK1:
302	case BLINK2:
303	if (what == BLINK1)
304	led_stat[lednr].offtime = 100 - len;
305	else
306	led_stat[lednr].offtime = 200 - len;
307	led_stat[lednr].ontime = len;
308	led_timer[lednr] = len;
309	led_on(lednr);
310	break;
311	default:
312	break;
313	}
314	}
315
316	/--------------------------------------------------------------------------/
317
318	static volatile uint16_t key_state,
319	key_press, // key press detect
320	key_rpt; // key long press and repeat
321
322
323	static uint16_t get_key_press(uint16_t key_mask) {
324	__disable_irq();
325	// read and clear atomic !
326	key_mask &= key_press; // read key(s)
327	key_press ^= key_mask; // clear key(s)
328	__enable_irq();
329	return key_mask;
330	}
331
332	static uint16_t get_key_rpt(uint16_t key_mask) {
333	__disable_irq();
334	// read and clear atomic !
335	key_mask &= key_rpt; // read key(s)
336	key_rpt ^= key_mask; // clear key(s)
337	__enable_irq();
338	return key_mask;
339	}
340
341	static uint16_t get_key_short(uint16_t key_mask) {
342	__disable_irq();
343	// read key state and key press atomic !
344	return get_key_press(key_state & key_mask);
345	}
346
347	/*
348	static uint16_t get_key_long(uint16_t key_mask) {
349	return get_key_press(get_key_rpt(key_mask));
350	}
351	*/
352
353	static void key_timerproc() {
354	static uint16_t key_in_last, rpt;
355	uint16_t key_in, c;
356
357	key_in = KEY_PORT;
358
359	c = key_in_last & key_in & ~key_state;
360
361	// key_state = key_state & key_in_last \| (key_state \| key_in_last) & key_in;
362	// key_state = key_state & key_in \| (key_state \| key_in) & key_in_last;
363
364	key_state = c \| ((key_in_last \| key_in) & key_state);
365
366	// key_state = (key_state&key_in_last) \| (key_state&key_in) \| (key_in_last&key_in);
367
368	key_press \|= c;
369
370	key_in_last = key_in;
371
372
373	if ((key_state & REPEAT_MASK) == 0) // check repeat function
374	rpt = REPEAT_START;
375	if (--rpt == 0) {
376	rpt = REPEAT_NEXT; // repeat delay
377	key_rpt \|= key_state & REPEAT_MASK;
378	}
379
380
381	#if 0
382
383	static char ds[30];
384	int dsi = 0;
385
386	ds[dsi++] = key_state & 1 ? '1' : '0';
387	ds[dsi++] = key_in_last & 1 ? '1' : '0';
388	ds[dsi++] = key_in & 1 ? '1' : '0';
389	ds[dsi++] = ' ';
390
391	//ds[dsi++] = key_state & 1 ? '1' : '0';
392	//ds[dsi++] = key_in_last & 1 ? '1' : '0';
393
394	//ds[dsi++] = ' ';
395	//ds[dsi++] = ' ';
396	ds[dsi++] = 0;
397	puts(ds);
398	#endif
399
400	}
401
402	/--------------------------------------------------------------------------/
403
404	void sys_tick_handler(void)
405	{
406	static int tick_10ms = 0;
407	static int count_ms = 0;
408
409	int i;
410
411	++tick_10ms;
412	if (tick_10ms == 10)
413	{
414	Stat \|= S_10MS_TO;
415
416	tick_10ms = 0;
417
418	i = led_timer[0];
419	if (i)
420	led_timer[0] = i - 1;
421	i = led_timer[1];
422	if (i)
423	led_timer[1] = i - 1;
424
425	key_timerproc();
426
427	/* Drive timer procedure of low level disk I/O module */
428	//disk_timerproc();
429	}
430
431	count_ms++;
432	if (count_ms == 1000) {
433	count_ms = 0;
434
435	if (timeout_1s)
436	--timeout_1s;
437	}
438	}
439
440	void rtc_isr(void)
441	{
442	/* The interrupt flag isn't cleared by hardware, we have to do it. */
443	rtc_clear_flag(RTC_SEC);
444
445	}
446
447	/--------------------------------------------------------------------------/
448
449	void tim3_set(int mode)
450	{
451	uint16_t cc_mode;
452
453	cc_mode = TIM_CCMR2_CC4S_OUT;
454
455	TIM3_CR1 = TIM_CR1_CMS_EDGE \| TIM_CR1_DIR_UP \| TIM_CR1_OPM;
456
457	if (mode < 0)
458	cc_mode \|= TIM_CCMR2_OC4M_FORCE_LOW;
459	else if (mode == 0)
460	cc_mode \|= TIM_CCMR2_OC4M_FORCE_HIGH;
461	else {
462	TIM3_ARR = mode;
463	cc_mode \|= TIM_CCMR2_OC4M_PWM2;
464	}
465
466	TIM3_CCMR2 = cc_mode;
467
468	if (mode > 0)
469	TIM3_CR1 \|= TIM_CR1_CEN;
470	}
471
472	/--------------------------------------------------------------------------/
473
474	static uint32_t z80_sram_cmp(uint32_t addr, int length, uint8_t wval, int inc)
475	{
476	uint8_t rval;
477	int errors = 0;
478
479	printf("SRAM: Check %#.5x byte... ", length); //fflush(stdout);
480	while (length--) {
481	if ((rval = z80_read(addr)) != wval) {
482	if (errors == 0) {
483	printf("\nSRAM: Address W R\n" \
484	" -------------\n");
485	// 12345 00 11
486	}
487	printf(" %.5lx %.2x %.2x\n", addr, wval, rval);
488
489	if (++errors > 16 )
490	break;
491	}
492	addr++;
493	wval += inc;
494	}
495	printf("Done.\n");
496
497	return addr;
498	}
499
500	#if 0
501	static void z80_sram_fill(uint32_t addr, int length, uint8_t startval, int inc)
502	{
503	printf("SRAM: Write %#.5x byte... ", length); //fflush(stdout);
504	while (length--) {
505	z80_write(addr, startval);
506	++addr;
507	startval += inc;
508	}
509	printf("Done.\n");
510	}
511
512
513	void z80_sram_fill_string(uint32_t addr, int length, const char *text)
514	{
515	char c;
516	const char *p = text;
517
518	while (length--) {
519	z80_write(addr++, c = *p++);
520	if (c == 0)
521	p = text;
522	}
523	}
524
525
526	uint32_t z80_sram_cmp_string(uint32_t addr, int length, const char *text)
527	{
528	char c;
529	const char *p = text;
530
531	while (length--) {
532	c = *p++;
533	if (z80_read(addr) != c)
534	break;
535	++addr;
536	if (c == 0)
537	p = text;
538	}
539	return addr;
540	}
541
542	const char * const qbfox = "Zhe quick brown fox jumps over the lazy dog!";
543	const char * const qbcat = "Zhe quick brown fox jumps over the lazy cat!";
544
545	#endif
546
547	uint8_t z80_get_byte(uint32_t adr)
548	{
549	uint8_t data;
550
551	z80_get_bus();
552	data = z80_read(adr),
553	z80_release_bus();
554
555	return data;
556	}
557
558
559	/--------------------------------------------------------------------------/
560
561	static void do_10ms(void)
562	{
563	for (uint8_t i = 0; i < 2; i++) {
564	switch (led_stat[i].mode) {
565	case PULSE:
566	if (led_timer[i] == 0) {
567	led_off(i);
568	led_stat[i].mode = NOTHING;
569	}
570	break;
571	case BLINK1:
572	case BLINK2:
573	if (led_timer[i] == 0) {
574	if (led_is_on(i))
575	led_timer[i] = led_stat[i].offtime;
576	else
577	led_timer[i] = led_stat[i].ontime;
578	led_toggle(i);
579	}
580	break;
581	default:
582	break;
583	}
584	}
585	}
586
587	/--------------------------------------------------------------------------/
588
589	int main(void)
590	{
591	//uint32_t led_state = LED_BLUE_PIN;
592	//uint32_t rc;
593	//uint8_t startval = 0;
594	//int count;
595	int stat, ch;
596	uint8_t c;
597
598	clock_setup();
599	gpio_setup();
600	tim3_setup();
601	setvbuf(stdout, NULL, _IONBF, 0);
602	usart_setup();
603	printf("Hello World!\n");
604
605	z80_setup_bus();
606	printf("z80_setup_bus done.\n");
607
608	/*
609	* If the RTC is pre-configured just allow access, don't reconfigure.
610	* Otherwise enable it with the LSE as clock source and 0x7fff as
611	* prescale value.
612	*/
613	rtc_auto_awake(LSE, 0x7fff);
614
615	systick_setup();
616	///* Setup the RTC interrupt. */
617	//nvic_setup();
618
619	/* Enable the RTC interrupt to occur off the SEC flag. */
620	//rtc_interrupt_enable(RTC_SEC);
621
622	printf("get bus...");
623	z80_busreq(LOW);
624	z80_reset(HIGH);
625	z80_get_bus();
626	printf(" got it!\n");
627
628	z80_memset(0, 0x76, 0x80000);
629	//z80_sram_fill(0, 512 * 1024, 0x76, 0);
630	z80_sram_cmp(0, 512 * 1024, 0x76, 0);
631
632	z80_write_block((unsigned char *) hdrom, 0, hdrom_length);
633	z80_reset(LOW);
634	printf("bus released! ");
635	z80_release_bus();
636	z80_reset(HIGH);
637	printf(" reset released!\n");
638
639	timeout_1s = 6;
640	while (timeout_1s) {
641	static int to=0;
642	uint8_t b, rc, tc, m;
643	if (to != timeout_1s) {
644	b = z80_get_byte(tx_fifo-0),
645	rc = z80_get_byte(tx_fifo-1),
646	tc = z80_get_byte(tx_fifo-2),
647	m =z80_get_byte(tx_fifo-3);
648	printf(" %.2x %.2x %.2x %.2x\n",
649	b, rc, tc, m);
650	to = timeout_1s;
651
652	if ((rc==0) && (m==0x7f))
653	break;
654	}
655	}
656
657	z80_fifo_init();
658
659	ledset(0, BLINK1, 50);
660
661	while (1) {
662	// static int tickstat = 0;
663
664	if (Stat & S_10MS_TO) {
665	Stat &= ~S_10MS_TO;
666	do_10ms();
667	}
668
669
670	// if (get_key_long(KEY0))
671	// ledset(1, PULSE, 100);
672
673	if (get_key_short(KEY0))
674	z80_reset_pulse();
675
676
677	/*
678	switch (tickstat) {
679
680	case 0:
681	if (BBIO_PERIPH(GPIOA+IDR, 0))
682	{
683	tickstat = 1;
684
685	LED_GREEN_ON();
686	LED_GREEN_OFF();
687	LED_GREEN_ON();
688	delay_systicks(12);
689	LED_GREEN_OFF();
690	}
691	break;
692	default:
693	if (!BBIO_PERIPH(GPIOA+IDR, 0))
694	tickstat = 0;
695	}
696	*/
697
698	//BBIO_PERIPH(LED_PORT+0x0C, 9) = BBIO_PERIPH(GPIOA+0x08, 0);
699
700	//BBIO_PERIPH(LED_PORT+0x0C, 9) = !z80_stat_halt();
701
702	//BBIO_PERIPH(LED_PORT+0x0C, 9) = (~key_state & KEY0) != 0;
703
704
705	/*
706	stat = z80_fifo_is_not_full(rx_fifo);
707	if(stat) {
708	z80_fifo_putc(rx_fifo, 'y');
709	if (++count == 154) {
710	putchar('\n');
711	putchar('\r');
712	count = 0;
713	}
714
715	}
716	*/
717
718	stat = usart_get_flag(USART_CONSOLE, USART_SR_RXNE);
719	if (stat) {
720	c = usart_recv(USART_CONSOLE) & 0xff;
721	switch (c) {
722	case 'H':
723	tim3_set(-1);
724	break;
725	case 'L':
726	tim3_set(0);
727	break;
728	case 'P':
729	tim3_set(24000000/1000000 * 5); /* 5 us */
730	break;
731	default:
732	z80_fifo_putc(fifo_out, c);
733	}
734	}
735
736	if (timeout_1s == 0) {
737
738	while (z80_fifo_is_not_empty(fifo_in)) {
739	// LED_GREEN_ON();
740	c = z80_fifo_getc(fifo_in);
741	putchar(c);
742	// LED_GREEN_OFF();
743	}
744
745	timeout_1s = 1;
746	}
747
748	while ((ch = z80_inbuf_getc()) >= 0)
749	printf(" 0x%.2X ", ch);
750	}
751
752	return 0;
753	}
754
755	#if 0
756
757	static char ds[30];
758	int dsi = 0;
759
760	ds[dsi++] = key_state1 & 1 ? '1' : '0';
761	ds[dsi++] = key_in_last & 1 ? '1' : '0';
762	ds[dsi++] = key_in & 1 ? '1' : '0';
763	ds[dsi++] = ' ';
764	ds[dsi++] = key_state1 & 1 ? '1' : '0';
765	ds[dsi++] = key_in_last & 1 ? '1' : '0';
766
767	ds[dsi++] = ' ';
768	ds[dsi++] = ' ';
769	ds[dsi++] = key_state & 1 ? '1' : '0';
770	ds[dsi++] = ct1 & 1 ? '0' : '1';
771	ds[dsi++] = ct0 & 1 ? '0' : '1';
772	ds[dsi++] = ' ';
773	ds[dsi++] = key_state & 1 ? '1' : '0';
774	//ds[dsi++] = '\r';
775	//ds[dsi++] = '\n';
776	ds[dsi++] = 0;
777	puts(ds);
778	#endif