Add an option to disable pullup simulation in avr_ioport.c with a macro

to set it in firmware.  Also simulate the PUD bit for atmegax8 cores.
Move the ioport definition in sim_megax8.h as they should be first
after ba6dfa4.

Author: ga

simavr/cores/sim_megax8.h

@@ -44,11 +44,11 @@ void mx8_reset(struct avr_t * avr);
  */
 struct mcu_t {
 	avr_t core;
+	avr_ioport_t	portb,portc,portd;
 	avr_eeprom_t 	eeprom;
 	avr_watchdog_t	watchdog;
 	avr_flash_t 	selfprog;
 	avr_extint_t	extint;
-	avr_ioport_t	portb,portc,portd;
 	avr_uart_t		uart;
 	avr_acomp_t		acomp;
 	avr_adc_t		adc;
@@ -79,6 +79,7 @@ const struct mcu_t SIM_CORENAME = {
 
 		.init = mx8_init,
 		.reset = mx8_reset,
+		.frequency = 1000000, // Default CKDIV8 fuse.
 	},
 	AVR_EEPROM_DECLARE(EE_READY_vect),
 #ifdef RWWSRE
@@ -93,6 +94,7 @@ const struct mcu_t SIM_CORENAME = {
 	},
 	.portb = {
 		.name = 'B', .r_port = PORTB, .r_ddr = DDRB, .r_pin = PINB,
+		.pud = AVR_IO_REGBIT(MCUCR, PUD),
 		.pcint = {
 			.enable = AVR_IO_REGBIT(PCICR, PCIE0),
 			.raised = AVR_IO_REGBIT(PCIFR, PCIF0),
@@ -102,6 +104,7 @@ const struct mcu_t SIM_CORENAME = {
 	},
 	.portc = {
 		.name = 'C', .r_port = PORTC, .r_ddr = DDRC, .r_pin = PINC,
+		.pud = AVR_IO_REGBIT(MCUCR, PUD),
 		.pcint = {
 			.enable = AVR_IO_REGBIT(PCICR, PCIE1),
 			.raised = AVR_IO_REGBIT(PCIFR, PCIF1),
@@ -111,6 +114,7 @@ const struct mcu_t SIM_CORENAME = {
 	},
 	.portd = {
 		.name = 'D', .r_port = PORTD, .r_ddr = DDRD, .r_pin = PIND,
+		.pud = AVR_IO_REGBIT(MCUCR, PUD),
 		.pcint = {
 			.enable = AVR_IO_REGBIT(PCICR, PCIE2),
 			.raised = AVR_IO_REGBIT(PCIFR, PCIF2),

simavr/sim/avr/avr_mcu_section.h

@@ -66,6 +66,7 @@ enum {
 	AVR_MMCU_TAG_VCD_SRAM_16,
 	AVR_MMCU_TAG_VCD_IO_IRQ,
 	AVR_MMCU_TAG_PORT_EXTERNAL_PULL,
+	AVR_MMCU_TAG_PORT_NO_PULL,
 };
 
 enum {
@@ -153,7 +154,7 @@ struct avr_mmcu_vcd_ioirq_t {
 	}
 
 #define AVR_MCU_BYTE(_tag, _val) \
-	const uint8_t _##_tag _MMCU_ = { _tag, 1, _val }
+	const uint8_t _##_tag[] _MMCU_ = { _tag, 1, _val }
 
 /*!
  * This Macro allows you to specify traces for the VCD file output
@@ -332,6 +333,13 @@ struct avr_mmcu_vcd_ioirq_t {
 	AVR_MCU_LONG(AVR_MMCU_TAG_AVCC, (_avcc));\
 	AVR_MCU_LONG(AVR_MMCU_TAG_AREF, (_aref));
 
+/*!
+ * This tag stops the simulator from guessing the state of pins with
+ * pull-ups enabled.
+ */
+
+#define AVR_MCU_PORT_NO_PULL AVR_MCU_BYTE(AVR_MMCU_TAG_PORT_NO_PULL, 0)
+
 /*!
  * Sets the MCU type and speed.
  */

simavr/sim/avr_ioport.c

@@ -64,6 +64,7 @@ avr_ioport_read(
 	avr_ioport_t * p = (avr_ioport_t *)param;
 	uint8_t ddr = avr->data[p->r_ddr];
 	uint8_t v = (avr->data[p->r_pin] & ~ddr) | (avr->data[p->r_port] & ddr);
+
 	avr->data[addr] = v;
 	avr_raise_irq(p->io.irq + IOPORT_IRQ_REG_PIN, v);
 	D(if (avr->data[addr] != v) printf("** PIN%c(%02x) = %02x\r\n", p->name, addr, v);)
@@ -88,10 +89,15 @@ avr_ioport_update_irqs(
 	for (int i = 0; i < 8; i++) {
 		if (ddr & (1 << i))
 			avr_raise_irq(p->io.irq + i, (avr->data[p->r_port] >> i) & 1);
-		else if (p->external.pull_mask & (1 << i))
-			avr_raise_irq(p->io.irq + i, (p->external.pull_value >> i) & 1);
-		else if ((avr->data[p->r_port] >> i) & 1)
-			avr_raise_irq(p->io.irq + i, 1);
+		else if (!avr->options.no_pullups) {
+			if (p->external.pull_mask & (1 << i))
+				avr_raise_irq(p->io.irq + i,
+							  (p->external.pull_value >> i) & 1);
+			else if (((avr->data[p->r_port] >> i) & 1) &&
+					 (!p->pud.reg || avr_regbit_get(avr, p->pud) == 0)) {
+				avr_raise_irq(p->io.irq + i, 1);
+			}
+		}
 	}
 	uint8_t pin = (avr->data[p->r_pin] & ~ddr) | (avr->data[p->r_port] & ddr);
 	pin = (pin & ~p->external.pull_mask) | p->external.pull_value;
@@ -199,6 +205,7 @@ avr_ioport_irq_notify(
 	if (value && irq->irq != IOPORT_IRQ_PIN_ALL_IN)
 		value = mask;
 	new_pin = (avr->data[p->r_pin] & ~mask) | (value & mask);
+	new_pin = (avr->data[p->r_port] & ddr) | (new_pin & ~ddr);
 	old_value = irq->value;
 
 	if (output) {
@@ -224,7 +231,6 @@ avr_ioport_irq_notify(
 		// Set the real PIN bit.
 
 		if (irq->irq == IOPORT_IRQ_PIN_ALL_IN) {
-			new_pin = (avr->data[p->r_port] & ddr) | (new_pin & ~ddr);
 			p->irqing = 1;
 			for (int i = 0; i < 8; ++i)
 				avr_raise_irq(p->io.irq + i, (new_pin >> i) & 1);
@@ -331,7 +337,8 @@ avr_ioport_ioctl(
 			/*
 			 * Set the default IRQ values when pin is set as input
 			 */
-			if (ctl == AVR_IOCTL_IOPORT_SET_EXTERNAL(p->name)) {
+			if (ctl == AVR_IOCTL_IOPORT_SET_EXTERNAL(p->name) &&
+				!avr->options.no_pullups) {
 				avr_ioport_external_t * m = (avr_ioport_external_t*)io_param;
 				p->external.pull_mask = m->mask;
 				p->external.pull_value = m->value;

simavr/sim/avr_ioport.h

@@ -103,6 +103,7 @@ typedef struct avr_ioport_t {
 	avr_io_addr_t r_port;
 	avr_io_addr_t r_ddr;
 	avr_io_addr_t r_pin;
+	avr_regbit_t  pud;		// Pull-up disable bit.
 
 	avr_int_vector_t pcint;	// PCINT vector
 	avr_io_addr_t r_pcint;	// pcint 8 pins mask

simavr/sim/sim_avr.h

@@ -89,6 +89,15 @@ enum {
 #define AVR_DATA_TO_IO(v) ((v) - 32)
 #define AVR_IO_TO_DATA(v) ((v) + 32)
 
+/**
+ * Structure to hold simulator options.
+ * The current set is kept in avr->options.
+ */
+
+struct simavr_options {
+	unsigned int no_pullups : 1;	// Disable all ioport pull-up behaviours.
+};
+
 /**
  * Logging macros and associated log levels.
  * The current log level is kept in avr->log.
@@ -234,6 +243,8 @@ typedef struct avr_t {
 	uint32_t 			sleep_usec;
 	uint64_t			time_base;	// for avr_get_time_stamp()
 
+	struct simavr_options options;	// Simulation options.
+
 	// called at init time
 	void (*init)(struct avr_t * avr);
 	// called at reset time

simavr/sim/sim_elf.c

@@ -299,6 +299,7 @@ avr_load_firmware(
 	}
 	avr_set_command_register(avr, firmware->command_register_addr);
 	avr_set_console_register(avr, firmware->console_register_addr);
+	avr->options = firmware->options;
 
 	// rest is initialization of the VCD file
 	if (firmware->tracecount == 0)
@@ -516,6 +517,9 @@ elf_parse_mmcu_section(
 			case AVR_MMCU_TAG_SIMAVR_CONSOLE: {
 				firmware->console_register_addr = src[0] | (src[1] << 8);
 			}	break;
+			case AVR_MMCU_TAG_PORT_NO_PULL: {
+				firmware->options.no_pullups = 1;
+			}	break;
 		}
 		size -= next;
 		src += next - 2; // already incremented

simavr/sim/sim_elf.h

@@ -91,6 +91,7 @@ typedef struct elf_firmware_t {
 	char *		dwarf_file;	// Must be dynamically allocated.
 #endif
 	char *		file_name;	// Internal use.
+	struct simavr_options options;
 } elf_firmware_t ;
 
 /* The structure *firmware must be pre-initialised to zero, then optionally

tests/atmega48_ioport.c

@@ -0,0 +1,151 @@
+#ifndef F_CPU
+#define F_CPU 8000000
+#endif
+#include <avr/io.h>
+#include <stdio.h>
+#include <avr/interrupt.h>
+#include <avr/sleep.h>
+
+/*
+ * This demonstrate how to use the avr_mcu_section.h file
+ * The macro adds a section to the ELF file with useful
+ * information for the simulator
+ */
+#include "avr_mcu_section.h"
+AVR_MCU(F_CPU, "atmega48");
+
+/* This program is very similar to atmega168_test.c, but runs with pull-ups
+ * disabled, both by the next macro and by setting the PUD bit in MCUCR.
+ * Comment out one or both to check that both ways work.
+ */
+
+AVR_MCU_PORT_NO_PULL; // Pull-ups disabled in simulator.
+
+static int uart_putchar(char c, FILE *stream) {
+	if (c == '\n')
+		uart_putchar('\r', stream);
+	loop_until_bit_is_set(UCSR0A, UDRE0);
+	UDR0 = c;
+	return 0;
+}
+
+static FILE mystdout = FDEV_SETUP_STREAM(uart_putchar, NULL,
+                                         _FDEV_SETUP_WRITE);
+
+ISR(INT0_vect)
+{
+    printf("I<%02X ", PIND);
+}
+
+ISR(PCINT0_vect)
+{
+    printf("K ");
+}
+
+ISR(PCINT2_vect)
+{
+    printf("J<%02X ", PORTD);
+    PORTD = 0;
+}
+
+int main()
+{
+	stdout = &mystdout;
+
+	MCUCR |= _BV(PUD); // Pull-ups disabled by "hardware".
+
+	/* Enable output on Port D pins 0-3 and write to them. */
+
+	DDRD = 0xf;
+	PORTD = 0xa;
+
+	printf("P<%02X ", PIND);	// Should say P<2A as caller sets bit 5.
+
+	/* Toggle some outputs and PORTD bits. */
+
+	PIND = 3;					// PORTD == 0x09, pins now 0x29
+
+	/* Change directions. */
+
+	DDRD = 0x3c;				// Pins now 0x9
+
+	/* Change output. */
+
+	PORTD = 0xf0;
+
+	/* This should say P<30 - the controlling program turns off bit 0. */
+
+	printf("P<%02X ", PIND);
+
+	/* Set-up rising edge interrupt on pin 2 (INT 0). */
+
+	EICRA = 3;
+	EIMSK = 1;
+
+#ifdef NOTYET
+        /* Clear external interrupt flags, but INT0 (PD3) will
+         * immediately reset, as the pin is low.
+         */
+
+        EIFR = 0xff;
+#endif
+	/* Turn off pin 4, signal the controlling program to raise pin 2. */
+
+	PORTD = 0xe0;
+
+	/* Verify the interrupt flag is set. Result should be 3. */
+
+	printf("F<%02X ", EIFR);
+
+	sei();
+
+	/* This duplicates the value in the INT0 handler, but it
+	 * takes sufficient time to be sure that there is only one
+	 * interrupt.  There was a bug that caused continuous interrupts
+	 * when this was first tried.
+	 */
+
+	printf("P<%02X ", PIND);
+
+	/* TODO: Test the level-triggered interupt.  It can be started
+	 * by a pin-value change or by writing to either of EICRA and EIMSK.
+	 */
+
+	/* Try pin change interrupt. */
+
+	PCICR = (1 << PCIE2); /* Interrupt enable. */
+	PCMSK2 = 0x0a;        /* Pins 1 and 3. */
+	DDRD = 3;
+	PORTD = 1;            /* No interrupt. */
+	PORTD = 3;            /* Interrupt. */
+
+	/* Allow time for second interrupt. */
+
+	printf("P<%02X ", PIND);
+
+	// Test "write 1 to clear" on PORT B.
+
+	DDRB = 0xff;
+	PCICR = (1 << PCIE0); /* Interrupt enable. */
+	PCMSK0 = 3;           /* Pins 0 and 1. */
+	cli();
+	PORTB = 1;
+	PCIFR = 1;            /* Clear interrupt. */
+	sei();
+	printf("| ");
+	cli();
+	PORTB = 3;
+	PCIFR = 6;
+	sei();                /* Interrupt. */
+	printf("| ");
+
+	/* Prompt for input with IOPORT_IRQ_PIN_ALL_IN. */
+
+	DDRB = 2;
+	printf("P<%02X ", PIND); // Should get 98, not 99 because DDRD == 3.
+
+	// this quits the simulator, since interupts are off
+	// this is a "feature" that allows running tests cases and exit
+	cli();
+	sleep_cpu();
+}