Add avr_io_t *avr_io_findinstance function.

Fix ioport state inconsistency after bitbang output.

Author: hovercraft-github

simavr/sim/avr_bitbang.c

@@ -29,6 +29,7 @@ extern "C" {
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "avr_bitbang.h"
 
@@ -99,7 +100,16 @@ static void avr_bitbang_write_bit(avr_bitbang_t *p)
 
 	// output to HW pin
 	if ( p->p_out.port ) {
-		avr_raise_irq(avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_out.port ), p->p_out.pin), bit);
+		avr_raise_irq(p->p_out.irq, bit);
+		uint16_t addr = p->p_out.ioport->r_port;
+		uint8_t value = p->avr->data[addr];
+		if (bit)
+			value |= 1 << p->p_out.pin;
+		else
+			value &= ~(1 << p->p_out.pin);
+		// at least avr->data[addr] update is required, otherwise port state is broken
+		// also triggering vcd signal would be nice here
+		avr_core_watch_write(p->avr, addr, value);
 	}
 
 	// module callback
@@ -130,7 +140,16 @@ static void avr_bitbang_clk_edge(avr_bitbang_t *p)
 
 	// generate clock output on HW pin
 	if ( p->clk_generate && p->p_clk.port ) {
-		avr_raise_irq(avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_clk.port ), p->p_clk.pin), clk);
+		avr_raise_irq(p->p_clk.irq, clk);
+		uint16_t addr = p->p_clk.ioport->r_port;
+		uint8_t value = p->avr->data[addr];
+		if (clk)
+			value |= 1 << p->p_clk.pin;
+		else
+			value &= ~(1 << p->p_clk.pin);
+		// at least avr->data[addr] update is required, otherwise port state is broken
+		// also triggering vcd signal would be nice here
+		avr_core_watch_write(p->avr, addr, value);
 	}
 
 	if ( phase ) {
@@ -175,6 +194,36 @@ static void avr_bitbang_clk_hook(struct avr_irq_t * irq, uint32_t value, void *
 	avr_bitbang_clk_edge(p);
 }
 
+/**
+ * define bitbang pins
+ *
+ * @param p			bitbang structure
+ * @param clk		clock pin
+ * @param in		incoming data pin
+ * @param out		outgoing data pin
+ */
+void avr_bitbang_defpins(avr_bitbang_t * p, avr_iopin_t *clk, avr_iopin_t *in, avr_iopin_t *out)
+{
+	if (clk) {
+		p->p_clk.port = clk->port;
+		p->p_clk.pin = clk->pin;
+		p->p_clk.ioport = (avr_ioport_t *)avr_io_findinstance(p->avr, "port", clk->port);
+		p->p_clk.irq = avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_clk.port ), p->p_clk.pin);
+	}
+	if (in) {
+		p->p_in.port = in->port;
+		p->p_in.pin = in->pin;
+		p->p_in.ioport = (avr_ioport_t *)avr_io_findinstance(p->avr, "port", in->port);
+		p->p_in.irq = avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_in.port ), p->p_in.pin);
+	}
+	if (out) {
+		p->p_out.port = out->port;
+		p->p_out.pin = out->pin;
+		p->p_out.ioport = (avr_ioport_t *)avr_io_findinstance(p->avr, "port", out->port);
+		p->p_out.irq = avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_out.port ), p->p_out.pin);
+	}
+}
+
 /**
  * reset bitbang sub-module
  *
@@ -220,7 +269,7 @@ void avr_bitbang_start(avr_bitbang_t * p)
 	} else {
 		// slave mode -> attach clock function to clock pin
 		///@todo test
-		avr_irq_register_notify( avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_clk.port ), p->p_clk.pin), avr_bitbang_clk_hook, p);
+		avr_irq_register_notify( p->p_clk.irq, avr_bitbang_clk_hook, p);
 	}
 
 }
@@ -238,7 +287,7 @@ void avr_bitbang_stop(avr_bitbang_t * p)
 
 	p->enabled = 0;
 	avr_cycle_timer_cancel(p->avr, avr_bitbang_clk_timer, p);
-	avr_irq_unregister_notify( avr_io_getirq(p->avr, AVR_IOCTL_IOPORT_GETIRQ( p->p_clk.port ), p->p_clk.pin), avr_bitbang_clk_hook, p);
+	avr_irq_unregister_notify( p->p_clk.irq, avr_bitbang_clk_hook, p);
 }
 
 #ifdef __cplusplus

simavr/sim/avr_bitbang.h

@@ -48,6 +48,15 @@
 #include "avr_ioport.h"
 
 
+/**
+ * pin structure
+ */
+typedef struct avr_bitbang_iopin_t {
+	uint16_t port : 8;			///< port e.g. 'B'
+	uint16_t pin : 8;		///< pin number
+	avr_ioport_t * ioport;
+	avr_irq_t * irq;
+} avr_bitbang_iopin_t;
 
 
 /// SPI Module initialization and state structure
@@ -73,9 +82,9 @@ typedef struct avr_bitbang_t {
 	uint32_t (*callback_transfer_finished)(uint32_t data, void *param); 	///< callback function to notify about a complete transfer
 																			///		(read received data and write new output data)
 
-	avr_iopin_t	p_clk;		///< clock pin (optional)
-	avr_iopin_t	p_in;		///< data in pin
-	avr_iopin_t	p_out;		///< data out pin
+	avr_bitbang_iopin_t	p_clk;		///< clock pin (optional)
+	avr_bitbang_iopin_t	p_in;		///< data in pin
+	avr_bitbang_iopin_t	p_out;		///< data out pin
 
 // private data
 	uint32_t data;			///< data buffer
@@ -92,6 +101,16 @@ typedef struct avr_bitbang_t {
  */
 void avr_bitbang_reset(avr_t *avr, avr_bitbang_t * p);
 
+/**
+ * define bitbang pins
+ *
+ * @param p			bitbang structure
+ * @param clk		clock pin
+ * @param in		incoming data pin
+ * @param out		outgoing data pin
+ */
+void avr_bitbang_defpins(avr_bitbang_t * p, avr_iopin_t *clk, avr_iopin_t *in, avr_iopin_t *out);
+
 /**
  * start bitbang transfer
  *

simavr/sim/avr_spi.c

@@ -56,8 +56,9 @@ static void avr_spi_bitbang_switch_mode(avr_spi_t * p, uint8_t master)
 	if (!(p->flags & AVR_SPI_FLAG_IOPIN_DIR_CTRL))
 		return;
 	if (master) {
-		p->bit_bang.p_in = p->p_miso;
-		p->bit_bang.p_out = p->p_mosi;
+		//p->bit_bang.p_in = p->p_miso;
+		//p->bit_bang.p_out = p->p_mosi;
+		avr_bitbang_defpins(&(p->bit_bang), &(p->p_sck), &(p->p_miso), &(p->p_mosi));
 		avr_irq_t *irq;
 		uint32_t irq_val;
 		irq = avr_io_getirq( p->bit_bang.avr,
@@ -67,8 +68,9 @@ static void avr_spi_bitbang_switch_mode(avr_spi_t * p, uint8_t master)
 		avr_raise_irq(irq, irq_val);
 		p->bit_bang.clk_generate = 1;
 	} else {
-		p->bit_bang.p_in = p->p_mosi;
-		p->bit_bang.p_out = p->p_miso;
+		//p->bit_bang.p_in = p->p_mosi;
+		//p->bit_bang.p_out = p->p_miso;
+		avr_bitbang_defpins(&(p->bit_bang), &(p->p_sck), &(p->p_mosi), &(p->p_miso));
 		avr_irq_t *irq;
 		uint32_t irq_val;
 		irq = avr_io_getirq( p->bit_bang.avr,

simavr/sim/avr_spi.h

@@ -62,6 +62,7 @@ typedef struct avr_spi_t {
 	avr_regbit_t	cpha;		// if zero, sampling on the SCK leading edge
 	avr_regbit_t	spr[4];		// clock divider
 
+	avr_iopin_t		p_sck;		// clock in/out pin
 	avr_iopin_t		p_miso;		// data in/out pin
 	avr_iopin_t		p_mosi;		// data in/out pin
 	avr_bitbang_t	bit_bang;
@@ -91,7 +92,7 @@ void avr_spi_init(avr_t * avr, avr_spi_t * port);
 		.cpol = AVR_IO_REGBIT(SPCR ## _name, CPOL ## _name), \
 		.cpha = AVR_IO_REGBIT(SPCR ## _name, CPHA ## _name), \
 	\
-		.bit_bang.p_clk = AVR_IOPIN('B', _p_sck), \
+		.p_sck = AVR_IOPIN('B', _p_sck), \
 		.p_miso = AVR_IOPIN('B', _p_miso), \
 		.p_mosi = AVR_IOPIN('B', _p_mosi), \
 		.p_ss = AVR_IOPIN(_ss_pin_port, _p_ss), \
@@ -121,7 +122,7 @@ void avr_spi_init(avr_t * avr, avr_spi_t * port);
 		.cpol = AVR_IO_REGBIT(SPCR, CPOL), \
 		.cpha = AVR_IO_REGBIT(SPCR, CPHA), \
 	\
-		.bit_bang.p_clk = AVR_IOPIN('B', _p_sck), \
+		.p_sck = AVR_IOPIN('B', _p_sck), \
 		.p_miso = AVR_IOPIN('B', _p_miso), \
 		.p_mosi = AVR_IOPIN('B', _p_mosi), \
 		.p_ss = AVR_IOPIN(_ss_pin_port, _p_ss), \

simavr/sim/sim_io.c

@@ -296,3 +296,31 @@ avr_deallocate_ios(
 	}
 	avr->io_port = NULL;
 }
+
+avr_io_t *
+avr_io_findinstance(
+		avr_t * avr,
+		const char * kind,
+		char name)
+{
+	avr_io_t * io = avr->io_port;
+	while (io) {
+		if (!strcmp(io->kind, kind))
+		{
+			if (!strcmp(kind, "port") ||
+					!strcmp(kind, "uart") ||
+					!strcmp(kind, "usb") ||
+					!strcmp(kind, "spi") ||
+					!strcmp(kind, "twi") ||
+					!strcmp(kind, "timer")) {
+				avr_io_instance_t * io_inst = (avr_io_instance_t *)io;
+				if (io_inst->name == name)
+					return io;
+			} else {
+				return io;
+			}
+		}
+		io = io->next;
+	}
+	return NULL;
+}

simavr/sim/sim_io.h

@@ -104,6 +104,18 @@ avr_io_getirq(
 		avr_t * avr,
 		uint32_t ctl,
 		int index);
+typedef struct avr_io_instance_t {
+	avr_io_t	io;
+	char name;
+} avr_io_instance_t;
+// finds an IO module instance by its kind (e.g. "port" for ioport, "uart" for usart and so on)
+// and (if applicable) symbolic name (e.g. 'B' for ioport, '0' for uart)
+avr_io_t *
+avr_io_findinstance(
+		avr_t * avr,
+		const char * kind,
+		char name);
+
 
 // get the IRQ for an absolute IO address
 // this allows any code to hook an IRQ in any io address, for example