altos: Remove 8051 address space specifiers

Signed-off-by: Keith Packard <keithp@keithp.com>

172 files changed, 974 insertions, 1025 deletions

diff --git a/src/aes/ao_aes.c b/src/aes/ao_aes.c
index fd90c5bf..0bc8188e 100644
--- a/src/aes/ao_aes.c
+++ b/src/aes/ao_aes.c
@@ -372,7 +372,7 @@ ao_aes_set_mode(enum ao_aes_mode mode)
 }
 
 void
-ao_aes_set_key(__xdata uint8_t *in)
+ao_aes_set_key(uint8_t *in)
 {
 	memcpy(key, in, 16);
 	xrijndaelKeySched((word32 *) key, 128, 128, &rkk);
@@ -385,8 +385,8 @@ ao_aes_zero_iv(void)
 }
 
 void
-ao_aes_run(__xdata uint8_t *in,
-	   __xdata uint8_t *out)
+ao_aes_run(uint8_t *in,
+	   uint8_t *out)
 {
 	uint8_t	i;
 	uint8_t *_iv = (uint8_t *) iv;
diff --git a/src/attiny/ao_arch.h b/src/attiny/ao_arch.h
index 68f5702d..84a94be7 100644
--- a/src/attiny/ao_arch.h
+++ b/src/attiny/ao_arch.h
@@ -38,12 +38,6 @@
 
 #define ao_arch_naked_declare	__attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
-#define __critical
 #define __interrupt(n)
 #define __at(n)
 
diff --git a/src/attiny/ao_arch_funcs.h b/src/attiny/ao_arch_funcs.h
index 0b67a407..35901154 100644
--- a/src/attiny/ao_arch_funcs.h
+++ b/src/attiny/ao_arch_funcs.h
@@ -57,10 +57,10 @@
 
 
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_send_bus(void *block, uint16_t len);
 
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_recv_bus(void *block, uint16_t len);
 
 #define ao_spi_send(block, len, bus) ao_spi_send_bus(block, len)
 #define ao_spi_recv(block, len, bus) ao_spi_recv_bus(block, len)
@@ -110,10 +110,10 @@ ao_i2c_init(void);
 /* notask.c */
 
 uint8_t
-ao_sleep(__xdata void *wchan);
+ao_sleep(void *wchan);
 
 void
-ao_wakeup(__xdata void *wchan);
+ao_wakeup(void *wchan);
 
 extern alt_t	ao_max_height;
 
diff --git a/src/attiny/ao_i2c_attiny.c b/src/attiny/ao_i2c_attiny.c
index f29ed6a9..34185b5a 100644
--- a/src/attiny/ao_i2c_attiny.c
+++ b/src/attiny/ao_i2c_attiny.c
@@ -173,7 +173,7 @@ ao_i2c_stop_bus(void)
  * so using interrupts would take way too long
  */
 uint8_t
-ao_i2c_send_bus(void __xdata *block, uint16_t len, uint8_t stop)
+ao_i2c_send_bus(void *block, uint16_t len, uint8_t stop)
 {
 	uint8_t	*d = block;
 
@@ -206,7 +206,7 @@ ao_i2c_send_fixed_bus(uint8_t d, uint16_t len, uint8_t stop)
  * Poll, sending zeros and reading data back
  */
 uint8_t
-ao_i2c_recv_bus(void __xdata *block, uint16_t len, uint8_t stop)
+ao_i2c_recv_bus(void *block, uint16_t len, uint8_t stop)
 {
 	uint8_t	*d = block;
 
diff --git a/src/attiny/ao_led.c b/src/attiny/ao_led.c
index 5f53129e..88505490 100644
--- a/src/attiny/ao_led.c
+++ b/src/attiny/ao_led.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint8_t ao_led_enable;
+uint8_t ao_led_enable;
 
 #define LED_PORT	PORTB
 #define LED_DDR		DDRB
@@ -48,7 +48,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/attiny/ao_spi_attiny.c b/src/attiny/ao_spi_attiny.c
index f63eb651..1c90ad56 100644
--- a/src/attiny/ao_spi_attiny.c
+++ b/src/attiny/ao_spi_attiny.c
@@ -82,7 +82,7 @@ ao_spi_transfer(uint8_t i)
  * so using interrupts would take way too long
  */
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_send_bus(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
@@ -95,7 +95,7 @@ ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
  * Poll, sending zeros and reading data back
  */
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_recv_bus(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
diff --git a/src/avr/ao_adc_avr.c b/src/avr/ao_adc_avr.c
index 2732c4db..2aae95ac 100644
--- a/src/avr/ao_adc_avr.c
+++ b/src/avr/ao_adc_avr.c
@@ -19,8 +19,8 @@
 #include "ao.h"
 #include "ao_pwmin.h"
 
-volatile __xdata struct ao_data	ao_data_ring[AO_DATA_RING];
-volatile __data uint8_t		ao_data_head;
+volatile struct ao_data	ao_data_ring[AO_DATA_RING];
+volatile uint8_t		ao_data_head;
 
 #ifdef TELESCIENCE
 const uint8_t	adc_channels[AO_LOG_TELESCIENCE_NUM_ADC] = {
@@ -119,16 +119,16 @@ ao_adc_poll(void)
 }
 
 void
-ao_data_get(__xdata struct ao_data *packet)
+ao_data_get(struct ao_data *packet)
 {
 	uint8_t	i = ao_data_ring_prev(ao_data_head);
 	memcpy(packet, (void *) &ao_data_ring[i], sizeof (struct ao_data));
 }
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
-	static __xdata struct ao_data	packet;
+	static struct ao_data	packet;
 	uint8_t i;
 	ao_data_get(&packet);
 	printf("tick: %5u",  packet.tick);
@@ -137,7 +137,7 @@ ao_adc_dump(void) __reentrant
 	printf("\n");
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
 	{ ao_adc_dump,	"a\0ADC" },
 	{ 0, NULL },
 };
diff --git a/src/avr/ao_arch.h b/src/avr/ao_arch.h
index 2b1da642..6166c50e 100644
--- a/src/avr/ao_arch.h
+++ b/src/avr/ao_arch.h
@@ -48,12 +48,6 @@
 
 #define ao_arch_naked_declare	__attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
-#define __critical
 #define __interrupt(n)
 #define __at(n)
 
diff --git a/src/avr/ao_arch_funcs.h b/src/avr/ao_arch_funcs.h
index 891ad9b1..dc248660 100644
--- a/src/avr/ao_arch_funcs.h
+++ b/src/avr/ao_arch_funcs.h
@@ -20,7 +20,7 @@
  * ao_spi.c
  */
 
-extern __xdata uint8_t	ao_spi_mutex;
+extern uint8_t	ao_spi_mutex;
 
 #define ao_spi_get_mask(reg,mask,bus,speed) do {	\
 		ao_mutex_get(&ao_spi_mutex);	\
@@ -66,10 +66,10 @@ extern __xdata uint8_t	ao_spi_mutex;
 
 
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_send_bus(void *block, uint16_t len);
 
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_recv_bus(void *block, uint16_t len);
 
 #define ao_spi_send(block, len, bus) ao_spi_send_bus(block, len)
 #define ao_spi_recv(block, len, bus) ao_spi_recv_bus(block, len)
diff --git a/src/avr/ao_eeprom_avr.c b/src/avr/ao_eeprom_avr.c
index 2fdf177b..84942cd7 100644
--- a/src/avr/ao_eeprom_avr.c
+++ b/src/avr/ao_eeprom_avr.c
@@ -21,16 +21,16 @@
 #include <ao_storage.h>
 
 /* Total bytes of available storage */
-__pdata ao_pos_t	ao_storage_total = 1024;
+ao_pos_t	ao_storage_total = 1024;
 
 /* Block size - device is erased in these units. */
-__pdata ao_pos_t	ao_storage_block = 1024;
+ao_pos_t	ao_storage_block = 1024;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata ao_pos_t	ao_storage_config = 0;
+ao_pos_t	ao_storage_config = 0;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. */
-__pdata uint16_t	ao_storage_unit = 1024;
+uint16_t	ao_storage_unit = 1024;
 
 /*
  * The internal flash chip is arranged in 8 byte sectors; the
@@ -45,7 +45,7 @@ __pdata uint16_t	ao_storage_unit = 1024;
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(ao_pos_t pos) __reentrant
+ao_storage_erase(ao_pos_t pos) 
 {
 	/* Not necessary */
 	return 1;
@@ -83,10 +83,10 @@ ao_intflash_read(uint16_t pos)
  */
 
 uint8_t
-ao_storage_device_write(ao_pos_t pos32, __xdata void *v, uint16_t len) __reentrant
+ao_storage_device_write(ao_pos_t pos32, void *v, uint16_t len) 
 {
 	uint16_t pos = pos32;
-	__xdata uint8_t *d = v;
+	uint8_t *d = v;
 
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -101,7 +101,7 @@ ao_storage_device_write(ao_pos_t pos32, __xdata void *v, uint16_t len) __reentra
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(ao_pos_t pos, __xdata void *v, uint16_t len) __reentrant
+ao_storage_device_read(ao_pos_t pos, void *v, uint16_t len) 
 {
 	uint8_t	*d = v;
 	
@@ -113,7 +113,7 @@ ao_storage_device_read(ao_pos_t pos, __xdata void *v, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -123,7 +123,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 	printf ("Using internal flash\n");
 }
diff --git a/src/avr/ao_i2c_usart.c b/src/avr/ao_i2c_usart.c
index c95548d4..67bee339 100644
--- a/src/avr/ao_i2c_usart.c
+++ b/src/avr/ao_i2c_usart.c
@@ -22,7 +22,7 @@
  * Atmega32u4 TWI master mode (I2C)
  */
 
-__xdata uint8_t	ao_i2c_mutex;
+uint8_t	ao_i2c_mutex;
 
 /* Send bytes over I2C.
  *
@@ -30,7 +30,7 @@ __xdata uint8_t	ao_i2c_mutex;
  * so using interrupts would take way too long
  */
 void
-ao_i2c_send(void __xdata *block, uint16_t len) __reentrant
+ao_i2c_send(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
@@ -51,7 +51,7 @@ ao_i2c_send(void __xdata *block, uint16_t len) __reentrant
  * clocks the data coming in.
  */
 void
-ao_i2c_recv(void __xdata *block, uint16_t len) __reentrant
+ao_i2c_recv(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
diff --git a/src/avr/ao_led.c b/src/avr/ao_led.c
index 8eba4898..165e95d3 100644
--- a/src/avr/ao_led.c
+++ b/src/avr/ao_led.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint8_t ao_led_enable;
+uint8_t ao_led_enable;
 
 #define LED_PORT	PORTB
 #define LED_DDR		DDRB
@@ -48,7 +48,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/avr/ao_pwmin.c b/src/avr/ao_pwmin.c
index 5eb392a4..2d83380f 100644
--- a/src/avr/ao_pwmin.c
+++ b/src/avr/ao_pwmin.c
@@ -26,8 +26,8 @@
  * project payload developed at Challenger Middle School.  
  */
 
-volatile __data uint16_t ao_icp3_count = 0;
-volatile __data uint16_t ao_icp3_last = 0;
+volatile uint16_t ao_icp3_count = 0;
+volatile uint16_t ao_icp3_last = 0;
 
 uint16_t ao_icp3(void)
 {
@@ -39,7 +39,7 @@ uint16_t ao_icp3(void)
 }
 
 static void
-ao_pwmin_display(void) __reentrant
+ao_pwmin_display(void) 
 {
 	/* display the most recent value */
 	printf("icp 3: %5u\n", ao_icp3());
@@ -62,7 +62,7 @@ ISR(TIMER3_CAPT_vect)
 	ao_icp3_last = ao_icp3_this;
 }
 
-__code struct ao_cmds ao_pwmin_cmds[] = {
+const struct ao_cmds ao_pwmin_cmds[] = {
 	{ ao_pwmin_display,	"p\0PWM input" },
 	{ 0, NULL },
 };
diff --git a/src/avr/ao_pwmin.h b/src/avr/ao_pwmin.h
index 43c12f53..fcb5e267 100644
--- a/src/avr/ao_pwmin.h
+++ b/src/avr/ao_pwmin.h
@@ -18,4 +18,4 @@
 
 void ao_pwmin_init(void);
 
-extern volatile __data uint16_t ao_icp3_count;
+extern volatile uint16_t ao_icp3_count;
diff --git a/src/avr/ao_serial_avr.c b/src/avr/ao_serial_avr.c
index ab82b7b1..cfdd7dfe 100644
--- a/src/avr/ao_serial_avr.c
+++ b/src/avr/ao_serial_avr.c
@@ -18,8 +18,8 @@
 
 #include "ao.h"
 
-__xdata struct ao_fifo	ao_serial1_rx_fifo;
-__xdata struct ao_fifo	ao_serial1_tx_fifo;
+struct ao_fifo	ao_serial1_rx_fifo;
+struct ao_fifo	ao_serial1_tx_fifo;
 
 void
 ao_debug_out(char c)
@@ -40,7 +40,7 @@ ISR(USART1_RX_vect)
 #endif
 }
 
-static __xdata uint8_t ao_serial_tx1_started;
+static uint8_t ao_serial_tx1_started;
 
 static void
 ao_serial1_tx_start(void)
@@ -75,7 +75,7 @@ _ao_serial1_pollchar(void)
 #endif
 
 char
-ao_serial1_getchar(void) __critical
+ao_serial1_getchar(void) 
 {
 	char	c;
 
@@ -99,7 +99,7 @@ ao_serial1_putchar(char c)
 }
 
 void
-ao_serial1_drain(void) __critical
+ao_serial1_drain(void) 
 {
 	ao_arch_block_interrupts();
 	while (!ao_fifo_empty(ao_serial1_tx_fifo))
diff --git a/src/avr/ao_spi_usart.c b/src/avr/ao_spi_usart.c
index 0d509cb7..6c30b025 100644
--- a/src/avr/ao_spi_usart.c
+++ b/src/avr/ao_spi_usart.c
@@ -22,7 +22,7 @@
  * Atmega32u4 USART in MSPIM (master SPI mode)
  */
 
-__xdata uint8_t	ao_spi_mutex;
+uint8_t	ao_spi_mutex;
 
 /* Send bytes over SPI.
  *
@@ -30,7 +30,7 @@ __xdata uint8_t	ao_spi_mutex;
  * so using interrupts would take way too long
  */
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_send_bus(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
@@ -47,7 +47,7 @@ ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
  * Poll, sending zeros and reading data back
  */
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_recv_bus(void *block, uint16_t len) 
 {
 	uint8_t	*d = block;
 
diff --git a/src/avr/ao_timer.c b/src/avr/ao_timer.c
index 2eaa8b63..ff6a829a 100644
--- a/src/avr/ao_timer.c
+++ b/src/avr/ao_timer.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-volatile __data uint16_t ao_tick_count;
+volatile uint16_t ao_tick_count;
 
 uint16_t ao_time(void)
 {
@@ -33,8 +33,8 @@ uint16_t ao_time(void)
 #define T1_SAMPLE_TIME		30000	/* 3e6/30000 = 100 */
 
 #if HAS_ADC
-volatile __data uint8_t	ao_adc_interval = 1;
-volatile __data uint8_t	ao_adc_count;
+volatile uint8_t	ao_adc_interval = 1;
+volatile uint8_t	ao_adc_count;
 #endif
 
 void
@@ -53,7 +53,7 @@ ISR(TIMER1_COMPA_vect)
 
 #if HAS_ADC
 void
-ao_timer_set_adc_interval(uint8_t interval) __critical
+ao_timer_set_adc_interval(uint8_t interval) 
 {
 	ao_adc_interval = interval;
 	ao_adc_count = 0;
diff --git a/src/avr/ao_usb_avr.c b/src/avr/ao_usb_avr.c
index 41d3c1be..df800994 100644
--- a/src/avr/ao_usb_avr.c
+++ b/src/avr/ao_usb_avr.c
@@ -27,7 +27,7 @@
 #define debug(format, args...)
 #endif
 
-struct ao_task __xdata ao_usb_task;
+struct ao_task ao_usb_task;
 
 struct ao_usb_setup {
 	uint8_t		dir_type_recip;
@@ -35,21 +35,21 @@ struct ao_usb_setup {
 	uint16_t	value;
 	uint16_t	index;
 	uint16_t	length;
-} __xdata ao_usb_setup;
-
-static __xdata uint8_t 	ao_usb_ep0_state;
-static const uint8_t * __xdata ao_usb_ep0_in_data;
-static __xdata uint8_t 	ao_usb_ep0_in_len;
-static __xdata uint8_t	ao_usb_ep0_in_pending;
-static __xdata uint8_t	ao_usb_addr_pending;
-static __xdata uint8_t	ao_usb_ep0_in_buf[2];
-static __xdata uint8_t 	ao_usb_ep0_out_len;
-static __xdata uint8_t *__xdata ao_usb_ep0_out_data;
-
-static __xdata uint8_t	ao_usb_in_flushed;
-__xdata uint8_t		ao_usb_running;
-static __xdata uint8_t	ao_usb_configuration;
-static __xdata uint8_t	ueienx_0;
+} ao_usb_setup;
+
+static uint8_t 	ao_usb_ep0_state;
+static const uint8_t * ao_usb_ep0_in_data;
+static uint8_t 	ao_usb_ep0_in_len;
+static uint8_t	ao_usb_ep0_in_pending;
+static uint8_t	ao_usb_addr_pending;
+static uint8_t	ao_usb_ep0_in_buf[2];
+static uint8_t 	ao_usb_ep0_out_len;
+static uint8_t *ao_usb_ep0_out_data;
+
+static uint8_t	ao_usb_in_flushed;
+uint8_t		ao_usb_running;
+static uint8_t	ao_usb_configuration;
+static uint8_t	ueienx_0;
 
 void
 ao_usb_set_address(uint8_t address)
@@ -143,9 +143,9 @@ struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8};
 static void
 ao_usb_get_descriptor(uint16_t value)
 {
-	const uint8_t		*__xdata descriptor;
-	__xdata uint8_t		type = value >> 8;
-	__xdata uint8_t		index = value;
+	const uint8_t		*descriptor;
+	uint8_t		type = value >> 8;
+	uint8_t		index = value;
 
 	descriptor = ao_usb_descriptors;
 	while (descriptor[0] != 0) {
@@ -174,7 +174,7 @@ ao_usb_ep0_set_in_pending(uint8_t in_pending)
 static void
 ao_usb_ep0_flush(void)
 {
-	__xdata uint8_t this_len;
+	uint8_t this_len;
 
 	cli();
 	UENUM = 0;
@@ -242,7 +242,7 @@ static void
 ao_usb_ep0_setup(void)
 {
 	/* Pull the setup packet out of the fifo */
-	ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_setup;
+	ao_usb_ep0_out_data = (uint8_t *) &ao_usb_setup;
 	ao_usb_ep0_out_len = 8;
 	ao_usb_ep0_fill(8, (1 << RXSTPI) | (1 << RXOUTI) | (1 << TXINI));
 	if (ao_usb_ep0_out_len != 0) {
@@ -334,7 +334,7 @@ ao_usb_ep0_setup(void)
 		case AO_USB_SET_LINE_CODING:
 			debug ("set line coding\n");
 			ao_usb_ep0_out_len = 7;
-			ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_line_coding;
+			ao_usb_ep0_out_data = (uint8_t *) &ao_usb_line_coding;
 			break;
 		case AO_USB_GET_LINE_CODING:
 			debug ("get line coding\n");
@@ -636,7 +636,7 @@ ao_usb_enable(void)
 }
 
 #if USB_DEBUG
-struct ao_task __xdata ao_usb_echo_task;
+struct ao_task ao_usb_echo_task;
 
 static void
 ao_usb_echo(void)
diff --git a/src/cortexelf-v1/ao_cortexelf.c b/src/cortexelf-v1/ao_cortexelf.c
index 5ed78bf0..6bc2624f 100644
--- a/src/cortexelf-v1/ao_cortexelf.c
+++ b/src/cortexelf-v1/ao_cortexelf.c
@@ -218,7 +218,7 @@ led_cmd(void)
 	ao_as1107_write_8(start, value);
 }
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
 	{ ao_video_toggle, "V\0Toggle video" },
 	{ ao_ball_toggle, "B\0Toggle ball" },
 	{ ao_ps2_read_keys, "K\0Read keys from keyboard" },
diff --git a/src/cortexelf-v1/cortexelf.ld b/src/cortexelf-v1/cortexelf.ld
index 6ad2a679..069fe5bd 100644
--- a/src/cortexelf-v1/cortexelf.ld
+++ b/src/cortexelf-v1/cortexelf.ld
@@ -75,10 +75,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/drivers/ao_25lc1024.c b/src/drivers/ao_25lc1024.c
index a9c897b3..c73f54df 100644
--- a/src/drivers/ao_25lc1024.c
+++ b/src/drivers/ao_25lc1024.c
@@ -24,16 +24,16 @@
 #define EE_DEVICE_SIZE	((uint32_t) 128 * (uint32_t) 1024)
 
 /* Total bytes of available storage */
-__pdata uint32_t	ao_storage_total;
+uint32_t	ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t	ao_storage_block;
+uint32_t	ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t	ao_storage_config;
+uint32_t	ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t	ao_storage_unit;
+uint16_t	ao_storage_unit;
 
 /*
  * Using SPI on USART 0, with P1_2 as the chip select
@@ -43,7 +43,7 @@ __pdata uint16_t	ao_storage_unit;
 #define EE_CS		P1_2
 #define EE_CS_PIN	2
 
-static __xdata uint8_t ao_ee_mutex;
+static uint8_t ao_ee_mutex;
 
 #define ao_ee_delay() do { \
 	_asm nop _endasm; \
@@ -58,7 +58,7 @@ static __xdata uint8_t ao_ee_mutex;
 struct ao_ee_instruction {
 	uint8_t	instruction;
 	uint8_t	address[3];
-} __xdata ao_ee_instruction;
+} ao_ee_instruction;
 
 static void
 ao_ee_write_enable(void)
@@ -92,9 +92,9 @@ ao_ee_wrsr(uint8_t status)
 
 #define EE_BLOCK_NONE	0xffff
 
-static __xdata uint8_t ao_ee_data[EE_BLOCK_SIZE];
-static __pdata uint16_t ao_ee_block = EE_BLOCK_NONE;
-static __pdata uint8_t	ao_ee_block_dirty;
+static uint8_t ao_ee_data[EE_BLOCK_SIZE];
+static uint16_t ao_ee_block = EE_BLOCK_NONE;
+static uint8_t	ao_ee_block_dirty;
 
 /* Write the current block to the EEPROM */
 static void
@@ -157,7 +157,7 @@ ao_ee_fill(uint16_t block)
 }
 
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *buf, uint16_t len) 
 {
 	uint16_t block = (uint16_t) (pos >> EE_BLOCK_SHIFT);
 
@@ -176,7 +176,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentra
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *buf, uint16_t len) 
 {
 	uint16_t block = (uint16_t) (pos >> EE_BLOCK_SHIFT);
 
@@ -189,7 +189,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentran
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 	ao_mutex_get(&ao_ee_mutex); {
 		ao_ee_flush_internal();
@@ -197,7 +197,7 @@ ao_storage_flush(void) __reentrant
 }
 
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
 	ao_mutex_get(&ao_ee_mutex); {
 		ao_ee_flush_internal();
@@ -209,7 +209,7 @@ ao_storage_erase(uint32_t pos) __reentrant
 }
 
 static void
-ee_store(void) __reentrant
+ee_store(void) 
 {
 }
 
@@ -225,7 +225,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 }
 
diff --git a/src/drivers/ao_74hc165.c b/src/drivers/ao_74hc165.c
index 8842801d..b62e0134 100644
--- a/src/drivers/ao_74hc165.c
+++ b/src/drivers/ao_74hc165.c
@@ -27,7 +27,7 @@
 uint8_t
 ao_74hc165_read(void)
 {
-	static __xdata state;
+	static state;
 	ao_spi_get(AO_74HC165_SPI_BUS);
 	ao_spi_set_speed(AO_74HC165_SPI_BUS, AO_SPI_SPEED_FAST);
 	AO_74HC165_CS = 1;
diff --git a/src/drivers/ao_74hc497.c b/src/drivers/ao_74hc497.c
index b3fd3c91..e8c39430 100644
--- a/src/drivers/ao_74hc497.c
+++ b/src/drivers/ao_74hc497.c
@@ -27,7 +27,7 @@
 uint8_t
 ao_74hc497_read(void)
 {
-	static __xdata state;
+	static state;
 	ao_spi_get_bit(AO_74HC497_CS_PORT, AO_74HC497_CS_PIN, AO_74HC497_CS, AO_74HC497_SPI_BUS, AO_SPI_SPEED_FAST);
 	ao_spi_recv(&state, 1, AO_74HC497_SPI_BUS);
 	ao_spi_put_bit(AO_74HC497_CS_PORT, AO_74HC497_CS_PIN, AO_74HC497_CS, AO_74HC497_SPI_BUS);
diff --git a/src/drivers/ao_at24c.c b/src/drivers/ao_at24c.c
index 8f91e3ca..16141c73 100644
--- a/src/drivers/ao_at24c.c
+++ b/src/drivers/ao_at24c.c
@@ -25,10 +25,10 @@
 #define AO_AT24C_PAGE_LEN	128
 
 /* Total bytes of available storage */
-__pdata ao_pos_t	ao_storage_total = 64l * 1024l;
+ao_pos_t	ao_storage_total = 64l * 1024l;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. */
-__pdata uint16_t	ao_storage_unit = 128;
+uint16_t	ao_storage_unit = 128;
 
 static void
 ao_at24c_set_address(uint8_t addr, ao_pos_t pos)
@@ -45,7 +45,7 @@ ao_at24c_set_address(uint8_t addr, ao_pos_t pos)
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(ao_pos_t pos) __reentrant
+ao_storage_erase(ao_pos_t pos) 
 {
 	if (pos >= ao_storage_total || pos + AO_AT24C_PAGE_LEN > ao_storage_total)
 		return 0;
@@ -61,7 +61,7 @@ ao_storage_erase(ao_pos_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(ao_pos_t pos, void *d, uint16_t len) 
 {
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -77,7 +77,7 @@ ao_storage_device_write(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(ao_pos_t pos, void *d, uint16_t len) 
 {
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -89,7 +89,7 @@ ao_storage_device_read(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
diff --git a/src/drivers/ao_at45db161d.c b/src/drivers/ao_at45db161d.c
index abba3f1f..516811b8 100644
--- a/src/drivers/ao_at45db161d.c
+++ b/src/drivers/ao_at45db161d.c
@@ -20,23 +20,23 @@
 #include "ao_at45db161d.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t	ao_storage_total;
+uint32_t	ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t	ao_storage_block;
+uint32_t	ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t	ao_storage_config;
+uint32_t	ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t	ao_storage_unit;
+uint16_t	ao_storage_unit;
 
 #define FLASH_CS		P1_1
 #define FLASH_CS_INDEX		1
 
 #define FLASH_BLOCK_SIZE_MAX	512
 
-__xdata uint8_t ao_flash_mutex;
+uint8_t ao_flash_mutex;
 
 #define ao_flash_delay() do { \
 	_asm nop _endasm; \
@@ -51,7 +51,7 @@ __xdata uint8_t ao_flash_mutex;
 struct ao_flash_instruction {
 	uint8_t	instruction;
 	uint8_t	address[3];
-} __xdata ao_flash_instruction;
+} ao_flash_instruction;
 
 static void
 ao_flash_set_pagesize_512(void)
@@ -79,17 +79,17 @@ ao_flash_read_status(void)
 
 #define FLASH_BLOCK_NONE	0xffff
 
-static __xdata uint8_t ao_flash_data[FLASH_BLOCK_SIZE_MAX];
-static __pdata uint16_t ao_flash_block = FLASH_BLOCK_NONE;
-static __pdata uint8_t	ao_flash_block_dirty;
-static __pdata uint8_t  ao_flash_write_pending;
-static __pdata uint8_t	ao_flash_setup_done;
-static __pdata uint8_t	ao_flash_block_shift;
-static __pdata uint16_t	ao_flash_block_size;
-static __pdata uint16_t	ao_flash_block_mask;
+static uint8_t ao_flash_data[FLASH_BLOCK_SIZE_MAX];
+static uint16_t ao_flash_block = FLASH_BLOCK_NONE;
+static uint8_t	ao_flash_block_dirty;
+static uint8_t  ao_flash_write_pending;
+static uint8_t	ao_flash_setup_done;
+static uint8_t	ao_flash_block_shift;
+static uint16_t	ao_flash_block_size;
+static uint16_t	ao_flash_block_mask;
 
 void
-ao_storage_setup(void) __reentrant
+ao_storage_setup(void) 
 {
 	uint8_t	status;
 
@@ -234,7 +234,7 @@ ao_flash_fill(uint16_t block)
 }
 
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *buf, uint16_t len) 
 {
 	uint16_t block = (uint16_t) (pos >> ao_flash_block_shift);
 
@@ -255,7 +255,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentra
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *buf, uint16_t len) 
 {
 	uint16_t block = (uint16_t) (pos >> ao_flash_block_shift);
 
@@ -270,7 +270,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentran
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 	ao_mutex_get(&ao_flash_mutex); {
 		ao_flash_flush_internal();
@@ -278,7 +278,7 @@ ao_storage_flush(void) __reentrant
 }
 
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
 	ao_mutex_get(&ao_flash_mutex); {
 		ao_flash_flush_internal();
@@ -290,7 +290,7 @@ ao_storage_erase(uint32_t pos) __reentrant
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 	uint8_t	status;
 
diff --git a/src/drivers/ao_btm.c b/src/drivers/ao_btm.c
index c65a8548..3591f8f2 100644
--- a/src/drivers/ao_btm.c
+++ b/src/drivers/ao_btm.c
@@ -30,12 +30,12 @@
 #endif
 
 int8_t			ao_btm_stdio;
-__xdata uint8_t		ao_btm_connected;
+uint8_t		ao_btm_connected;
 
 #define BT_DEBUG 0
 
 #if BT_DEBUG
-__xdata char		ao_btm_buffer[256];
+char		ao_btm_buffer[256];
 uint16_t		ao_btm_ptr;
 char			ao_btm_dir;
 
@@ -137,7 +137,7 @@ ao_btm_send(void)
 	ao_wakeup((void *) &ao_serial_btm_rx_fifo);
 }
 
-__code struct ao_cmds ao_btm_cmds[] = {
+const struct ao_cmds ao_btm_cmds[] = {
 	{ ao_btm_dump,		"d\0Dump btm buffer." },
 	{ ao_btm_speed,		"s <19200,57600>\0Set btm serial speed." },
 	{ ao_btm_send,		"S\0BTM interactive mode. ~ to exit." },
@@ -153,7 +153,7 @@ __code struct ao_cmds ao_btm_cmds[] = {
 #endif
 
 #define AO_BTM_MAX_REPLY	16
-__xdata char		ao_btm_reply[AO_BTM_MAX_REPLY];
+char		ao_btm_reply[AO_BTM_MAX_REPLY];
 
 /*
  * Read one bluetooth character.
@@ -252,7 +252,7 @@ ao_btm_wait_reply(void)
 }
 
 void
-ao_btm_string(__code char *cmd)
+ao_btm_string(const char *cmd)
 {
 	char	c;
 
@@ -261,7 +261,7 @@ ao_btm_string(__code char *cmd)
 }
 
 uint8_t
-ao_btm_cmd(__code char *cmd)
+ao_btm_cmd(const char *cmd)
 {
 	ao_btm_drain();
 
@@ -351,7 +351,7 @@ ao_btm_check_link()
 #endif
 }
 
-__xdata struct ao_task ao_btm_task;
+struct ao_task ao_btm_task;
 
 /*
  * A thread to initialize the bluetooth device and
diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index 2f091485..d581c246 100644
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -1066,7 +1066,7 @@ ao_radio_rx_wait(void)
 }
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
 	uint8_t		len;
 	uint8_t		radio_rssi = 0;
diff --git a/src/drivers/ao_cc1200.c b/src/drivers/ao_cc1200.c
index de282000..f2f9c372 100644
--- a/src/drivers/ao_cc1200.c
+++ b/src/drivers/ao_cc1200.c
@@ -988,7 +988,7 @@ ao_radio_dump_state(struct ao_radio_state *s)
 #endif
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
 	uint8_t	success = 0;
 
diff --git a/src/drivers/ao_companion.c b/src/drivers/ao_companion.c
index 598b5815..3967090b 100644
--- a/src/drivers/ao_companion.c
+++ b/src/drivers/ao_companion.c
@@ -43,12 +43,12 @@
 			       AO_COMPANION_SPI_BUS);	\
 	} while (0)
 
-__xdata struct ao_companion_command		ao_companion_command;
-__xdata struct ao_companion_setup		ao_companion_setup;
+struct ao_companion_command		ao_companion_command;
+struct ao_companion_setup		ao_companion_setup;
 
-__xdata uint16_t	ao_companion_data[AO_COMPANION_MAX_CHANNELS];
-__pdata uint8_t		ao_companion_running;
-__xdata uint8_t		ao_companion_mutex;
+uint16_t	ao_companion_data[AO_COMPANION_MAX_CHANNELS];
+uint8_t		ao_companion_running;
+uint8_t		ao_companion_mutex;
 
 static void
 ao_companion_send_command(uint8_t command)
@@ -116,7 +116,7 @@ ao_companion(void)
 }
 
 void
-ao_companion_status(void) __reentrant
+ao_companion_status(void) 
 {
 	uint8_t	i;
 	printf("Companion running: %d\n", ao_companion_running);
@@ -134,12 +134,12 @@ ao_companion_status(void) __reentrant
 	printf("\n");
 }
 
-__code struct ao_cmds ao_companion_cmds[] = {
+const struct ao_cmds ao_companion_cmds[] = {
 	{ ao_companion_status,	"L\0Companion link status" },
 	{ 0, NULL },
 };
 
-static __xdata struct ao_task ao_companion_task;
+static struct ao_task ao_companion_task;
 
 void
 ao_companion_init(void)
diff --git a/src/drivers/ao_gps_sirf.c b/src/drivers/ao_gps_sirf.c
index 8bebd610..bdd9410e 100644
--- a/src/drivers/ao_gps_sirf.c
+++ b/src/drivers/ao_gps_sirf.c
@@ -20,11 +20,11 @@
 #include "ao.h"
 #endif
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location	ao_gps_data;
-__xdata struct ao_telemetry_satellite	ao_gps_tracking_data;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location	ao_gps_data;
+struct ao_telemetry_satellite	ao_gps_tracking_data;
 
 static const char ao_gps_set_nmea[] = "\r\n$PSRF100,0,57600,8,1,0*37\r\n";
 
@@ -107,7 +107,7 @@ struct sirf_geodetic_nav_data {
 	uint8_t		hdop;
 };
 
-static __xdata struct sirf_geodetic_nav_data	ao_sirf_data;
+static struct sirf_geodetic_nav_data	ao_sirf_data;
 
 struct sirf_measured_sat_data {
 	uint8_t		svid;
@@ -121,10 +121,10 @@ struct sirf_measured_tracker_data {
 	struct sirf_measured_sat_data	sats[12];
 };
 
-static __xdata struct sirf_measured_tracker_data	ao_sirf_tracker_data;
+static struct sirf_measured_tracker_data	ao_sirf_tracker_data;
 
-static __pdata uint16_t ao_sirf_cksum;
-static __pdata uint16_t ao_sirf_len;
+static uint16_t ao_sirf_cksum;
+static uint16_t ao_sirf_len;
 
 #ifndef ao_sirf_getchar
 #define ao_sirf_getchar		ao_serial1_getchar
@@ -142,11 +142,11 @@ static uint8_t data_byte(void)
 	return c;
 }
 
-static char __xdata *sirf_target;
+static char *sirf_target;
 
 static void sirf_u16(uint8_t offset)
 {
-	uint16_t __xdata *ptr = (uint16_t __xdata *) (sirf_target + offset);
+	uint16_t *ptr = (uint16_t *) (sirf_target + offset);
 	uint16_t val;
 
 	val = data_byte() << 8;
@@ -156,16 +156,16 @@ static void sirf_u16(uint8_t offset)
 
 static void sirf_u8(uint8_t offset)
 {
-	uint8_t __xdata *ptr = (uint8_t __xdata *) (sirf_target + offset);
+	uint8_t *ptr = (uint8_t *) (sirf_target + offset);
 	uint8_t val;
 
 	val = data_byte ();
 	*ptr = val;
 }
 
-static void sirf_u32(uint8_t offset) __reentrant
+static void sirf_u32(uint8_t offset) 
 {
-	uint32_t __xdata *ptr = (uint32_t __xdata *) (sirf_target + offset);
+	uint32_t *ptr = (uint32_t *) (sirf_target + offset);
 	uint32_t val;
 
 	val = ((uint32_t) data_byte ()) << 24;
@@ -194,7 +194,7 @@ struct sirf_packet_parse {
 };
 
 static void
-ao_sirf_parse(void __xdata *target, const struct sirf_packet_parse *parse) __reentrant
+ao_sirf_parse(void *target, const struct sirf_packet_parse *parse) 
 {
 	uint8_t	i, offset, j;
 
@@ -258,7 +258,7 @@ static const struct sirf_packet_parse geodetic_nav_data_packet[] = {
 };
 
 static void
-ao_sirf_parse_41(void) __reentrant
+ao_sirf_parse_41(void) 
 {
 	ao_sirf_parse(&ao_sirf_data, geodetic_nav_data_packet);
 }
@@ -279,7 +279,7 @@ static const struct sirf_packet_parse measured_sat_data_packet[] = {
 };
 
 static void
-ao_sirf_parse_4(void) __reentrant
+ao_sirf_parse_4(void) 
 {
 	uint8_t	i;
 	ao_sirf_parse(&ao_sirf_tracker_data, measured_tracker_data_packet);
@@ -288,7 +288,7 @@ ao_sirf_parse_4(void) __reentrant
 }
 
 static void
-ao_gps_setup(void) __reentrant
+ao_gps_setup(void) 
 {
 	uint8_t	i, k;
 	ao_sirf_set_speed(AO_SERIAL_SPEED_4800);
@@ -309,7 +309,7 @@ static const char ao_gps_set_message_rate[] = {
 };
 
 void
-ao_sirf_set_message_rate(uint8_t msg, uint8_t rate) __reentrant
+ao_sirf_set_message_rate(uint8_t msg, uint8_t rate) 
 {
 	uint16_t	cksum = 0x00a6;
 	uint8_t		i;
@@ -337,7 +337,7 @@ static const uint8_t sirf_disable[] = {
 };
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
 	uint8_t	i, k;
 	uint16_t cksum;
@@ -443,7 +443,7 @@ ao_gps(void) __reentrant
 	}
 }
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
 void
 ao_gps_init(void)
diff --git a/src/drivers/ao_gps_skytraq.c b/src/drivers/ao_gps_skytraq.c
index 3ecae435..193f20dc 100644
--- a/src/drivers/ao_gps_skytraq.c
+++ b/src/drivers/ao_gps_skytraq.c
@@ -33,20 +33,20 @@
 #define ao_gps_set_speed	ao_serial1_set_speed
 #endif
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-static __data char ao_gps_char;
-static __data uint8_t ao_gps_cksum;
-static __data uint8_t ao_gps_error;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+static char ao_gps_char;
+static uint8_t ao_gps_cksum;
+static uint8_t ao_gps_error;
 
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location	ao_gps_data;
-__xdata struct ao_telemetry_satellite	ao_gps_tracking_data;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location	ao_gps_data;
+struct ao_telemetry_satellite	ao_gps_tracking_data;
 
-static __pdata uint16_t				ao_gps_next_tick;
-static __pdata struct ao_telemetry_location	ao_gps_next;
-static __pdata uint8_t				ao_gps_date_flags;
-static __pdata struct ao_telemetry_satellite	ao_gps_tracking_next;
+static uint16_t				ao_gps_next_tick;
+static struct ao_telemetry_location	ao_gps_next;
+static uint8_t				ao_gps_date_flags;
+static struct ao_telemetry_satellite	ao_gps_tracking_next;
 
 #define STQ_S 0xa0, 0xa1
 #define STQ_E 0x0d, 0x0a
@@ -60,7 +60,7 @@ static __pdata struct ao_telemetry_satellite	ao_gps_tracking_next;
     STQ_S, 0,15, id, a,b,c,d,e,f,g,h,i,j,k,l,m,n, \
     (id^a^b^c^d^e^f^g^h^i^j^k^l^m^n), STQ_E
 
-static __code uint8_t ao_gps_config[] = {
+static const uint8_t ao_gps_config[] = {
 	SKYTRAQ_MSG_8(0x08, 1, 0, 1, 0, 1, 0, 0, 0), /* configure nmea */
 	/* gga interval */
 	/* gsa interval */
@@ -107,7 +107,7 @@ ao_gps_skip_sep(void)
 		ao_gps_lexchar();
 }
 
-__data static uint8_t ao_gps_num_width;
+static uint8_t ao_gps_num_width;
 
 static int16_t
 ao_gps_decimal(uint8_t max_width)
@@ -162,11 +162,11 @@ ao_gps_hex(void)
 }
 
 static int32_t
-ao_gps_parse_pos(uint8_t deg_width) __reentrant
+ao_gps_parse_pos(uint8_t deg_width) 
 {
-	static __pdata uint16_t	d;
-	static __pdata uint8_t	m;
-	static __pdata uint16_t	f;
+	static uint16_t	d;
+	static uint8_t	m;
+	static uint16_t	f;
 	char c;
 
 	d = ao_gps_decimal(deg_width);
@@ -414,7 +414,7 @@ ao_nmea_rmc(void)
 #define ao_skytraq_sendstruct(s) ao_skytraq_sendbytes((s), sizeof(s))
 
 static void
-ao_skytraq_sendbytes(__code uint8_t *b, uint8_t l)
+ao_skytraq_sendbytes(const uint8_t *b, uint8_t l)
 {
 	while (l--) {
 		uint8_t	c = *b++;
@@ -462,7 +462,7 @@ ao_gps_nmea_parse(void)
 static uint8_t	ao_gps_updating;
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
 	ao_gps_set_speed(AO_SERIAL_SPEED_9600);
 
@@ -486,9 +486,9 @@ ao_gps(void) __reentrant
 	}
 }
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
-static __code uint8_t ao_gps_115200[] = {
+static const uint8_t ao_gps_115200[] = {
 	SKYTRAQ_MSG_3(5,0,5,0)	/* Set to 115200 baud */
 };
 
@@ -500,7 +500,7 @@ ao_gps_set_speed_delay(uint8_t speed) {
 }
 
 static void
-gps_update(void) __reentrant
+gps_update(void) 
 {
 	ao_gps_updating = 1;
 	ao_task_minimize_latency = 1;
@@ -517,7 +517,7 @@ gps_update(void) __reentrant
 		ao_gps_putchar(ao_usb_getchar());
 }
 
-__code struct ao_cmds ao_gps_cmds[] = {
+const struct ao_cmds ao_gps_cmds[] = {
 	{ ao_gps_show, 	"g\0Display GPS" },
 	{ gps_update,	"U\0Update GPS firmware" },
 	{ 0, NULL },
diff --git a/src/drivers/ao_gps_ublox.c b/src/drivers/ao_gps_ublox.c
index c720f802..f5268aa7 100644
--- a/src/drivers/ao_gps_ublox.c
+++ b/src/drivers/ao_gps_ublox.c
@@ -26,11 +26,11 @@
 
 #include <stdarg.h>
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location	ao_gps_data;
-__xdata struct ao_telemetry_satellite	ao_gps_tracking_data;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location	ao_gps_data;
+struct ao_telemetry_satellite	ao_gps_tracking_data;
 
 #undef AO_SERIAL_SPEED_UBLOX
 
@@ -58,8 +58,8 @@ struct ao_ublox_cksum {
 	uint8_t	a, b;
 };
 
-static __pdata struct ao_ublox_cksum ao_ublox_cksum;
-static __pdata uint16_t ao_ublox_len;
+static struct ao_ublox_cksum ao_ublox_cksum;
+static uint16_t ao_ublox_len;
 
 #if AO_UBLOX_DEBUG
 
@@ -152,11 +152,11 @@ static uint8_t data_byte(void)
 	return header_byte();
 }
 
-static char __xdata *ublox_target;
+static char *ublox_target;
 
 static void ublox_u16(uint8_t offset)
 {
-	uint16_t __xdata *ptr = (uint16_t __xdata *) (void __xdata *) (ublox_target + offset);
+	uint16_t *ptr = (uint16_t *) (void *) (ublox_target + offset);
 	uint16_t val;
 
 	val = data_byte();
@@ -166,16 +166,16 @@ static void ublox_u16(uint8_t offset)
 
 static void ublox_u8(uint8_t offset)
 {
-	uint8_t __xdata *ptr = (uint8_t __xdata *) (ublox_target + offset);
+	uint8_t *ptr = (uint8_t *) (ublox_target + offset);
 	uint8_t val;
 
 	val = data_byte ();
 	*ptr = val;
 }
 
-static void ublox_u32(uint8_t offset) __reentrant
+static void ublox_u32(uint8_t offset) 
 {
-	uint32_t __xdata *ptr = (uint32_t __xdata *) (void __xdata *) (ublox_target + offset);
+	uint32_t *ptr = (uint32_t *) (void *) (ublox_target + offset);
 	uint32_t val;
 
 	val = ((uint32_t) data_byte ());
@@ -203,7 +203,7 @@ struct ublox_packet_parse {
 };
 
 static void
-ao_ublox_parse(void __xdata *target, const struct ublox_packet_parse *parse) __reentrant
+ao_ublox_parse(void *target, const struct ublox_packet_parse *parse) 
 {
 	uint8_t	i, offset;
 
@@ -610,7 +610,7 @@ ao_gps_set_rate(uint8_t rate)
 }
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
 	uint8_t			class, id;
 	struct ao_ublox_cksum	cksum;
@@ -796,12 +796,12 @@ static void ao_gps_option(void)
 #define ao_gps_option ao_gps_show
 #endif
 
-__code struct ao_cmds ao_gps_cmds[] = {
+const struct ao_cmds ao_gps_cmds[] = {
 	{ ao_gps_option, 	"g\0Display GPS" },
 	{ 0, NULL },
 };
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
 void
 ao_gps_init(void)
diff --git a/src/drivers/ao_lcd.c b/src/drivers/ao_lcd.c
index c35093bc..294361eb 100644
--- a/src/drivers/ao_lcd.c
+++ b/src/drivers/ao_lcd.c
@@ -20,7 +20,7 @@
 
 static uint16_t	ao_lcd_time = 3;
 
-static __xdata uint8_t	ao_lcd_mutex;
+static uint8_t	ao_lcd_mutex;
 
 static void
 ao_lcd_delay(void)
diff --git a/src/drivers/ao_lco.c b/src/drivers/ao_lco.c
index e892c8c0..86635200 100644
--- a/src/drivers/ao_lco.c
+++ b/src/drivers/ao_lco.c
@@ -324,7 +324,7 @@ ao_lco_set_debug(void)
 		ao_lco_debug = ao_cmd_lex_i != 0;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
 	{ ao_lco_set_debug,	"D <0 off, 1 on>\0Debug" },
 	{ ao_lco_search,	"s\0Search for pad boxes" },
 	{ 0, NULL }
diff --git a/src/drivers/ao_lco_cmd.c b/src/drivers/ao_lco_cmd.c
index dba9a76a..3fcdc859 100644
--- a/src/drivers/ao_lco_cmd.c
+++ b/src/drivers/ao_lco_cmd.c
@@ -26,12 +26,12 @@
 #define HAS_STATIC_TEST	1
 #endif
 
-static __pdata uint16_t	lco_box;
-static __pdata uint8_t	lco_channels;
-static __pdata uint16_t	tick_offset;
+static uint16_t	lco_box;
+static uint8_t	lco_channels;
+static uint16_t	tick_offset;
 
 static void
-lco_args(void) __reentrant
+lco_args(void) 
 {
 	ao_cmd_decimal();
 	lco_box = ao_cmd_lex_i;
@@ -71,7 +71,7 @@ lco_ignite(uint8_t cmd)
 }
 
 static void
-lco_report_cmd(void) __reentrant
+lco_report_cmd(void) 
 {
 	int8_t		r;
 	uint8_t		c;
@@ -122,7 +122,7 @@ lco_report_cmd(void) __reentrant
 }
 
 static void
-lco_fire_cmd(void) __reentrant
+lco_fire_cmd(void) 
 {
 	uint8_t		secs;
 	uint8_t		i;
@@ -156,7 +156,7 @@ lco_fire_cmd(void) __reentrant
 
 #if HAS_STATIC_TEST
 static void
-lco_static_cmd(void) __reentrant
+lco_static_cmd(void) 
 {
 	uint8_t		secs;
 	uint8_t		i;
@@ -190,7 +190,7 @@ lco_static_cmd(void) __reentrant
 #endif
 
 static void
-lco_arm_cmd(void) __reentrant
+lco_arm_cmd(void) 
 {
 	uint8_t	i;
 	int8_t  r;
@@ -205,7 +205,7 @@ lco_arm_cmd(void) __reentrant
 }
 
 static void
-lco_ignite_cmd(void) __reentrant
+lco_ignite_cmd(void) 
 {
 	uint8_t i;
 	lco_args();
@@ -216,13 +216,13 @@ lco_ignite_cmd(void) __reentrant
 
 #if HAS_STATIC_TEST
 static void
-lco_endstatic_cmd(void) __reentrant
+lco_endstatic_cmd(void) 
 {
 	lco_ignite(AO_PAD_ENDSTATIC);
 }
 #endif
 
-static __code struct ao_cmds ao_lco_cmds[] = {
+static const struct ao_cmds ao_lco_cmds[] = {
 	{ lco_report_cmd,	"l <box> <channel>\0Get remote status" },
 	{ lco_fire_cmd,		"F <box> <channel> <secs>\0Fire remote igniters" },
 #if HAS_STATIC_TEST
diff --git a/src/drivers/ao_lco_func.c b/src/drivers/ao_lco_func.c
index 92b344ed..06350694 100644
--- a/src/drivers/ao_lco_func.c
+++ b/src/drivers/ao_lco_func.c
@@ -21,8 +21,8 @@
 #include <ao_radio_cmac.h>
 #include <ao_lco_func.h>
 
-static __xdata struct ao_pad_command	command;
-static __xdata uint8_t			ao_lco_mutex;
+static struct ao_pad_command	command;
+static uint8_t			ao_lco_mutex;
 
 int8_t
 ao_lco_query(uint16_t box, struct ao_pad_query *query, uint16_t *tick_offset)
diff --git a/src/drivers/ao_lco_two.c b/src/drivers/ao_lco_two.c
index 6f2d81ff..12c02e88 100644
--- a/src/drivers/ao_lco_two.c
+++ b/src/drivers/ao_lco_two.c
@@ -129,7 +129,7 @@ ao_lco_set_debug(void)
 		ao_lco_debug = ao_cmd_lex_i;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
 	{ ao_lco_set_debug,	"D <0 off, 1 on>\0Debug" },
 	{ 0, NULL }
 };
diff --git a/src/drivers/ao_m25.c b/src/drivers/ao_m25.c
index b506b0a7..72617cc4 100644
--- a/src/drivers/ao_m25.c
+++ b/src/drivers/ao_m25.c
@@ -19,16 +19,16 @@
 #include "ao.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t	ao_storage_total;
+uint32_t	ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t	ao_storage_block;
+uint32_t	ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t	ao_storage_config;
+uint32_t	ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t	ao_storage_unit;
+uint16_t	ao_storage_unit;
 
 #define M25_DEBUG	0
 /*
@@ -89,7 +89,7 @@ static uint8_t ao_m25_numchips;			/* number of chips detected */
 static uint8_t ao_m25_total;			/* total sectors available */
 static ao_port_t ao_m25_wip;			/* write in progress */
 
-static __xdata uint8_t ao_m25_mutex;
+static uint8_t ao_m25_mutex;
 
 /*
  * This little array is abused to send and receive data. A particular
@@ -99,7 +99,7 @@ static __xdata uint8_t ao_m25_mutex;
  * of which touch those last three bytes.
  */
 
-static __xdata uint8_t	ao_m25_instruction[4];
+static uint8_t	ao_m25_instruction[4];
 
 #define M25_SELECT(cs)		ao_spi_get_mask(AO_M25_SPI_CS_PORT,cs,AO_M25_SPI_BUS, AO_SPI_SPEED_FAST)
 #define M25_DESELECT(cs)	ao_spi_put_mask(AO_M25_SPI_CS_PORT,cs,AO_M25_SPI_BUS)
@@ -239,7 +239,7 @@ ao_m25_scan(void)
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
 	ao_port_t	cs;
 
@@ -267,7 +267,7 @@ ao_storage_erase(uint32_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *d, uint16_t len) 
 {
 	ao_port_t	cs;
 
@@ -294,7 +294,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
 	ao_port_t	cs;
 
@@ -317,7 +317,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -330,7 +330,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 #if M25_DEBUG
 	ao_port_t	cs;
diff --git a/src/drivers/ao_mma655x.c b/src/drivers/ao_mma655x.c
index 5d44bffd..a48c1db2 100644
--- a/src/drivers/ao_mma655x.c
+++ b/src/drivers/ao_mma655x.c
@@ -259,7 +259,7 @@ ao_mma655x_dump(void)
 	printf ("MMA655X value %d\n", ao_mma655x_current);
 }
 
-__code struct ao_cmds ao_mma655x_cmds[] = {
+const struct ao_cmds ao_mma655x_cmds[] = {
 	{ ao_mma655x_dump,	"A\0Display MMA655X data" },
 	{ 0, NULL },
 };
@@ -277,7 +277,7 @@ ao_mma655x(void)
 	}
 }
 
-static __xdata struct ao_task ao_mma655x_task;
+static struct ao_task ao_mma655x_task;
 
 void
 ao_mma655x_init(void)
diff --git a/src/drivers/ao_mr25.c b/src/drivers/ao_mr25.c
index 2d355c9f..86dda22a 100644
--- a/src/drivers/ao_mr25.c
+++ b/src/drivers/ao_mr25.c
@@ -19,16 +19,16 @@
 #include "ao.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t	ao_storage_total;
+uint32_t	ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t	ao_storage_block;
+uint32_t	ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t	ao_storage_config;
+uint32_t	ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t	ao_storage_unit;
+uint16_t	ao_storage_unit;
 
 /*
  * MRAM is entirely random access; no erase operations are required,
@@ -51,7 +51,7 @@ __pdata uint16_t	ao_storage_unit;
 #define MR25_STATUS_BP_SHIFT	(2)
 #define MR25_STATUS_WEL		(1 << 1)	/* Write enable latch */
 
-static __xdata uint8_t ao_mr25_mutex;
+static uint8_t ao_mr25_mutex;
 
 /*
  * This little array is abused to send and receive data. A particular
@@ -61,7 +61,7 @@ static __xdata uint8_t ao_mr25_mutex;
  * those last three bytes.
  */
 
-static __xdata uint8_t	ao_mr25_instruction[4];
+static uint8_t	ao_mr25_instruction[4];
 
 #define MR25_SELECT()		ao_spi_get_mask(AO_MR25_SPI_CS_PORT,(1 << AO_MR25_SPI_CS_PIN),AO_MR25_SPI_BUS, AO_SPI_SPEED_FAST)
 #define MR25_DESELECT()		ao_spi_put_mask(AO_MR25_SPI_CS_PORT,(1 << AO_MR25_SPI_CS_PIN),AO_MR25_SPI_BUS)
@@ -93,7 +93,7 @@ ao_mr25_set_address(uint32_t pos)
  * Erase the specified sector (no-op for MRAM)
  */
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
 	if (pos >= ao_storage_total || pos + ao_storage_block > ao_storage_total)
 		return 0;
@@ -104,7 +104,7 @@ ao_storage_erase(uint32_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *d, uint16_t len) 
 {
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -128,7 +128,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -147,7 +147,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -157,7 +157,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 	printf ("Detected chips 1 size %d\n", ao_storage_total >> 8);
 }
diff --git a/src/drivers/ao_ms5607.c b/src/drivers/ao_ms5607.c
index 4bfc17db..a468fee3 100644
--- a/src/drivers/ao_ms5607.c
+++ b/src/drivers/ao_ms5607.c
@@ -22,8 +22,8 @@
 
 #if HAS_MS5607 || HAS_MS5611
 
-__xdata struct ao_ms5607_prom	ao_ms5607_prom;
-static __xdata uint8_t	  	ms5607_configured;
+struct ao_ms5607_prom	ao_ms5607_prom;
+static uint8_t	  	ms5607_configured;
 
 #ifndef AO_MS5607_SPI_SPEED
 #define AO_MS5607_SPI_SPEED	AO_SPI_SPEED_FAST
@@ -97,12 +97,12 @@ ao_ms5607_prom_valid(uint8_t *prom)
 }
 
 static void
-ao_ms5607_prom_read(__xdata struct ao_ms5607_prom *prom)
+ao_ms5607_prom_read(struct ao_ms5607_prom *prom)
 {
 	uint8_t		addr;
 	uint16_t	*r;
 
-	r = (__xdata uint16_t *) prom;
+	r = (uint16_t *) prom;
 	for (addr = 0; addr < 8; addr++) {
 		uint8_t	cmd = AO_MS5607_PROM_READ(addr);
 		ao_ms5607_start();
@@ -138,20 +138,20 @@ ao_ms5607_setup(void)
 	ao_ms5607_prom_read(&ao_ms5607_prom);
 }
 
-static __xdata volatile uint8_t	ao_ms5607_done;
+static volatile uint8_t	ao_ms5607_done;
 
 static void
 ao_ms5607_isr(void)
 {
 	ao_exti_disable(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN);
 	ao_ms5607_done = 1;
-	ao_wakeup((__xdata void *) &ao_ms5607_done);
+	ao_wakeup((void *) &ao_ms5607_done);
 }
 
 static uint32_t
 ao_ms5607_get_sample(uint8_t cmd) {
-	__xdata uint8_t	reply[3];
-	__xdata uint8_t read;
+	uint8_t	reply[3];
+	uint8_t read;
 
 	ao_ms5607_done = 0;
 
@@ -198,7 +198,7 @@ ao_ms5607_get_sample(uint8_t cmd) {
 #define AO_CONVERT_D2	token_evaluator(AO_MS5607_CONVERT_D2_, AO_MS5607_TEMP_OVERSAMPLE)
 
 void
-ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample)
+ao_ms5607_sample(struct ao_ms5607_sample *sample)
 {
 	sample->pres = ao_ms5607_get_sample(AO_CONVERT_D1);
 	sample->temp = ao_ms5607_get_sample(AO_CONVERT_D2);
@@ -214,7 +214,7 @@ ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample)
 #define HAS_MS5607_TASK HAS_TASK
 #endif
 
-__xdata struct ao_ms5607_sample	ao_ms5607_current;
+struct ao_ms5607_sample	ao_ms5607_current;
 
 #if HAS_MS5607_TASK
 static void
@@ -233,7 +233,7 @@ ao_ms5607(void)
 	}
 }
 
-__xdata struct ao_task ao_ms5607_task;
+struct ao_task ao_ms5607_task;
 #endif
 
 #if HAS_TASK
@@ -253,7 +253,7 @@ ao_ms5607_info(void)
 static void
 ao_ms5607_dump(void)
 {
-	__xdata struct ao_ms5607_value value;
+	struct ao_ms5607_value value;
 
 	ao_ms5607_convert(&ao_ms5607_current, &value);
 	printf ("Pressure:    %8lu %8ld\n", ao_ms5607_current.pres, value.pres);
@@ -261,7 +261,7 @@ ao_ms5607_dump(void)
 	printf ("Altitude: %ld\n", ao_pa_to_altitude(value.pres));
 }
 
-__code struct ao_cmds ao_ms5607_cmds[] = {
+const struct ao_cmds ao_ms5607_cmds[] = {
 	{ ao_ms5607_dump,	"B\0Display MS5607 data" },
 	{ 0, NULL },
 };
diff --git a/src/drivers/ao_ms5607.h b/src/drivers/ao_ms5607.h
index 18f99bf8..322cc468 100644
--- a/src/drivers/ao_ms5607.h
+++ b/src/drivers/ao_ms5607.h
@@ -57,8 +57,8 @@ struct ao_ms5607_value {
 	int32_t		temp;	/* in °C * 100 */
 };
 
-extern __xdata struct ao_ms5607_sample	ao_ms5607_current;
-extern __xdata struct ao_ms5607_prom	ao_ms5607_prom;
+extern struct ao_ms5607_sample	ao_ms5607_current;
+extern struct ao_ms5607_prom	ao_ms5607_prom;
 
 void
 ao_ms5607_setup(void);
@@ -70,10 +70,10 @@ void
 ao_ms5607_info(void);
 
 void
-ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample);
+ao_ms5607_sample(struct ao_ms5607_sample *sample);
 
 void
-ao_ms5607_convert(__xdata struct ao_ms5607_sample *sample,
-		  __xdata struct ao_ms5607_value *value);
+ao_ms5607_convert(struct ao_ms5607_sample *sample,
+		  struct ao_ms5607_value *value);
 
 #endif /* _AO_MS5607_H_ */
diff --git a/src/drivers/ao_ms5607_convert_8051.c b/src/drivers/ao_ms5607_convert_8051.c
index b7081107..e9052b41 100644
--- a/src/drivers/ao_ms5607_convert_8051.c
+++ b/src/drivers/ao_ms5607_convert_8051.c
@@ -32,8 +32,8 @@
 #endif
 
 void
-ao_ms5607_convert(__xdata struct ao_ms5607_sample *sample,
-		  __xdata struct ao_ms5607_value *value)
+ao_ms5607_convert(struct ao_ms5607_sample *sample,
+		  struct ao_ms5607_value *value)
 {
 	__LOCAL int32_t	dT;
 	__LOCAL int32_t TEMP;
diff --git a/src/drivers/ao_packet.c b/src/drivers/ao_packet.c
index 1c931921..b5a0a4b7 100644
--- a/src/drivers/ao_packet.c
+++ b/src/drivers/ao_packet.c
@@ -18,20 +18,20 @@
 
 #include "ao.h"
 
-__xdata struct ao_packet_recv ao_rx_packet;
-__xdata struct ao_packet ao_tx_packet;
-__pdata uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
+struct ao_packet_recv ao_rx_packet;
+struct ao_packet ao_tx_packet;
+uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
 
-static __xdata uint8_t tx_data[AO_PACKET_MAX];
-static __xdata uint8_t rx_data[AO_PACKET_MAX];
-static __pdata uint8_t rx_seq;
+static uint8_t tx_data[AO_PACKET_MAX];
+static uint8_t rx_data[AO_PACKET_MAX];
+static uint8_t rx_seq;
 
-__xdata struct ao_task	ao_packet_task;
-__xdata uint8_t ao_packet_enable;
-__xdata uint8_t ao_packet_restart;
+struct ao_task	ao_packet_task;
+uint8_t ao_packet_enable;
+uint8_t ao_packet_restart;
 
 #if PACKET_HAS_MASTER
-__xdata uint8_t ao_packet_master_sleeping;
+uint8_t ao_packet_master_sleeping;
 #endif
 
 void
@@ -150,7 +150,7 @@ ao_packet_flush(void)
 #endif /* PACKET_HAS_MASTER */
 
 void
-ao_packet_putchar(char c) __reentrant
+ao_packet_putchar(char c) 
 {
 	/* No need to block interrupts, all variables here
 	 * are only manipulated in task context
diff --git a/src/drivers/ao_packet_master.c b/src/drivers/ao_packet_master.c
index e63771e5..68a5efef 100644
--- a/src/drivers/ao_packet_master.c
+++ b/src/drivers/ao_packet_master.c
@@ -39,7 +39,7 @@ ao_packet_getchar(void)
 }
 
 static void
-ao_packet_echo(void) __reentrant
+ao_packet_echo(void) 
 {
 	int	c;
 	while (ao_packet_enable) {
@@ -50,9 +50,9 @@ ao_packet_echo(void) __reentrant
 	ao_exit();
 }
 
-static __xdata struct ao_task	ao_packet_echo_task;
-static __xdata uint16_t		ao_packet_master_delay;
-static __xdata uint16_t		ao_packet_master_time;
+static struct ao_task	ao_packet_echo_task;
+static uint16_t		ao_packet_master_delay;
+static uint16_t		ao_packet_master_time;
 
 #define AO_PACKET_MASTER_DELAY_SHORT	AO_MS_TO_TICKS(100)
 #define AO_PACKET_MASTER_DELAY_LONG	AO_MS_TO_TICKS(1000)
@@ -114,7 +114,7 @@ ao_packet_master(void)
 }
 
 static void
-ao_packet_forward(void) __reentrant
+ao_packet_forward(void) 
 {
 	char c;
 	ao_packet_enable = 1;
@@ -152,7 +152,7 @@ ao_packet_signal(void)
 	printf ("RSSI: %d\n", ao_radio_rssi);
 }
 
-__code struct ao_cmds ao_packet_master_cmds[] = {
+const struct ao_cmds ao_packet_master_cmds[] = {
 	{ ao_packet_forward,	"p\0Remote packet link." },
 	{ ao_packet_signal,	"s\0Report signal strength." },
 	{ 0,	NULL },
diff --git a/src/drivers/ao_pad.c b/src/drivers/ao_pad.c
index 208841fb..7e139c78 100644
--- a/src/drivers/ao_pad.c
+++ b/src/drivers/ao_pad.c
@@ -22,14 +22,14 @@
 #include <ao_74hc165.h>
 #include <ao_radio_cmac.h>
 
-static __xdata uint8_t ao_pad_ignite;
-static __xdata struct ao_pad_command	command;
-static __xdata struct ao_pad_query	query;
-static __pdata uint8_t	ao_pad_armed;
-static __pdata uint16_t	ao_pad_arm_time;
-static __pdata uint8_t	ao_pad_box;
-static __xdata uint8_t	ao_pad_disabled;
-static __pdata uint16_t	ao_pad_packet_time;
+static uint8_t ao_pad_ignite;
+static struct ao_pad_command	command;
+static struct ao_pad_query	query;
+static uint8_t	ao_pad_armed;
+static uint16_t	ao_pad_arm_time;
+static uint8_t	ao_pad_box;
+static uint8_t	ao_pad_disabled;
+static uint16_t	ao_pad_packet_time;
 
 #ifndef AO_PAD_RSSI_MINIMUM
 #define AO_PAD_RSSI_MINIMUM	-90
@@ -38,7 +38,7 @@ static __pdata uint16_t	ao_pad_packet_time;
 #define DEBUG	1
 
 #if DEBUG
-static __pdata uint8_t	ao_pad_debug;
+static uint8_t	ao_pad_debug;
 #define PRINTD(...) (ao_pad_debug ? (printf(__VA_ARGS__), 0) : 0)
 #define FLUSHD()    (ao_pad_debug ? (flush(), 0) : 0)
 #else
@@ -189,17 +189,17 @@ ao_pad_monitor(void)
 {
 	uint8_t			c;
 	uint8_t			sample;
-	__pdata AO_LED_TYPE	prev = 0, cur = 0;
-	__pdata uint8_t		beeping = 0;
-	__xdata volatile struct ao_data	*packet;
-	__pdata uint16_t	arm_beep_time = 0;
+	AO_LED_TYPE	prev = 0, cur = 0;
+	uint8_t		beeping = 0;
+	volatile struct ao_data	*packet;
+	uint16_t	arm_beep_time = 0;
 
 	sample = ao_data_head;
 	ao_led_set(LEDS_AVAILABLE);
 	ao_delay(AO_MS_TO_TICKS(1000));
 	ao_led_set(0);
 	for (;;) {
-		__pdata int16_t			pyro;
+		int16_t			pyro;
 
 		ao_arch_critical(
 			while (sample == ao_data_head)
@@ -526,9 +526,9 @@ ao_pad_manual(void)
 	}
 }
 
-static __xdata struct ao_task ao_pad_task;
-static __xdata struct ao_task ao_pad_ignite_task;
-static __xdata struct ao_task ao_pad_monitor_task;
+static struct ao_task ao_pad_task;
+static struct ao_task ao_pad_ignite_task;
+static struct ao_task ao_pad_monitor_task;
 
 #if DEBUG
 void
@@ -560,7 +560,7 @@ ao_pad_alarm_debug(void)
 }
 #endif
 
-__code struct ao_cmds ao_pad_cmds[] = {
+const struct ao_cmds ao_pad_cmds[] = {
 	{ ao_pad_test,	"t\0Test pad continuity" },
 	{ ao_pad_manual,	"i <key> <n>\0Fire igniter. <key> is doit with D&I" },
 #if DEBUG
diff --git a/src/drivers/ao_pca9922.c b/src/drivers/ao_pca9922.c
index 09f52a0e..3516f03a 100644
--- a/src/drivers/ao_pca9922.c
+++ b/src/drivers/ao_pca9922.c
@@ -23,7 +23,7 @@
 
 #include <ao.h>
 
-static __xdata uint8_t	ao_led_state;
+static uint8_t	ao_led_state;
 
 static void
 ao_led_apply(void)
@@ -93,7 +93,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/drivers/ao_pyro_slave.c b/src/drivers/ao_pyro_slave.c
index a293d929..8ea6d858 100644
--- a/src/drivers/ao_pyro_slave.c
+++ b/src/drivers/ao_pyro_slave.c
@@ -33,7 +33,7 @@ static const struct ao_companion_setup	ao_telepyro_setup = {
 
 struct ao_config ao_config;
 
-extern volatile __data uint16_t ao_tick_count;
+extern volatile uint16_t ao_tick_count;
 uint16_t ao_boost_tick;
 
 void ao_spi_slave(void)
diff --git a/src/drivers/ao_quadrature.c b/src/drivers/ao_quadrature.c
index 250e035f..20781c40 100644
--- a/src/drivers/ao_quadrature.c
+++ b/src/drivers/ao_quadrature.c
@@ -22,7 +22,7 @@
 #include <ao_fast_timer.h>
 #include <ao_event.h>
 
-__xdata int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
+int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
 #ifndef AO_QUADRATURE_SINGLE_CODE
 static int8_t ao_quadrature_step[AO_QUADRATURE_COUNT];
 #endif
diff --git a/src/drivers/ao_quadrature.h b/src/drivers/ao_quadrature.h
index a99e4cc5..ee551f65 100644
--- a/src/drivers/ao_quadrature.h
+++ b/src/drivers/ao_quadrature.h
@@ -19,7 +19,7 @@
 #ifndef _AO_QUADRATURE_H_
 #define _AO_QUADRATURE_H_
 
-extern __xdata int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
+extern int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
 
 int32_t
 ao_quadrature_wait(uint8_t q);
diff --git a/src/drivers/ao_radio_master.c b/src/drivers/ao_radio_master.c
index 79e4b22b..8b62a4de 100644
--- a/src/drivers/ao_radio_master.c
+++ b/src/drivers/ao_radio_master.c
@@ -21,15 +21,15 @@
 #include <ao_exti.h>
 #include <ao_radio_cmac.h>
 
-static __xdata struct ao_radio_spi_reply	ao_radio_spi_reply;
-static __xdata struct ao_radio_spi_request	ao_radio_spi_request;
-static volatile __xdata uint8_t			ao_radio_wait_mode;
-static volatile __xdata uint8_t			ao_radio_done = 0;
-static volatile __xdata uint8_t			ao_radio_ready = 1;
-static __xdata uint8_t				ao_radio_mutex;
-static __xdata uint8_t				ao_radio_aes_seq;
+static struct ao_radio_spi_reply	ao_radio_spi_reply;
+static struct ao_radio_spi_request	ao_radio_spi_request;
+static volatile uint8_t			ao_radio_wait_mode;
+static volatile uint8_t			ao_radio_done = 0;
+static volatile uint8_t			ao_radio_ready = 1;
+static uint8_t				ao_radio_mutex;
+static uint8_t				ao_radio_aes_seq;
 
-__xdata int8_t					ao_radio_cmac_rssi;
+int8_t					ao_radio_cmac_rssi;
 
 #if 0
 #define PRINTD(...) do { printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
@@ -126,7 +126,7 @@ ao_radio_put(void)
 }
 
 static void
-ao_radio_get_data(__xdata void *d, uint8_t size)
+ao_radio_get_data(void *d, uint8_t size)
 {
 	PRINTD ("fetch\n");
 	ao_radio_master_start();
@@ -157,7 +157,7 @@ ao_radio_send(const void *d, uint8_t size)
 
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
 	int8_t	ret;
 	uint8_t	recv;
@@ -198,7 +198,7 @@ ao_radio_cmac_set_key(void)
 }
 
 int8_t
-ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
+ao_radio_cmac_send(void *packet, uint8_t len) 
 {
 	if (len > AO_CMAC_MAX_LEN)
 		return AO_RADIO_CMAC_LEN_ERROR;
@@ -220,7 +220,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
 }
 
 int8_t
-ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant
+ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout) 
 {
 	int8_t	ret;
 	int8_t	recv;
@@ -296,7 +296,7 @@ ao_radio_test_cmd(void)
 		ao_radio_test(0);
 }
 
-__code struct ao_cmds ao_radio_cmds[] = {
+const struct ao_cmds ao_radio_cmds[] = {
 	{ ao_radio_test_cmd,	"C <1 start, 0 stop, none both>\0Radio carrier test" },
 	{ 0,	NULL },
 };
diff --git a/src/drivers/ao_radio_slave.c b/src/drivers/ao_radio_slave.c
index 2f1dab29..7859d6b6 100644
--- a/src/drivers/ao_radio_slave.c
+++ b/src/drivers/ao_radio_slave.c
@@ -20,11 +20,11 @@
 #include <ao_radio_spi.h>
 #include <ao_radio_cmac.h>
 
-static __xdata struct ao_radio_spi_reply ao_radio_spi_reply;
+static struct ao_radio_spi_reply ao_radio_spi_reply;
 
-static __xdata struct ao_radio_spi_request ao_radio_spi_request;
+static struct ao_radio_spi_request ao_radio_spi_request;
 
-static __xdata uint8_t	slave_state;
+static uint8_t	slave_state;
 
 static void
 ao_radio_slave_low(void)
@@ -123,7 +123,7 @@ ao_radio_slave_spi(void)
 	}
 }
 
-static __xdata struct ao_task ao_radio_slave_spi_task;
+static struct ao_task ao_radio_slave_spi_task;
 
 void
 ao_radio_slave_init(void)
diff --git a/src/drivers/ao_watchdog.c b/src/drivers/ao_watchdog.c
index 1a877fcb..01c3cd0e 100644
--- a/src/drivers/ao_watchdog.c
+++ b/src/drivers/ao_watchdog.c
@@ -46,7 +46,7 @@ ao_watchdog_set(void)
 }
 	
 
-static __code struct ao_cmds ao_watchdog_cmds[] = {
+static const struct ao_cmds ao_watchdog_cmds[] = {
 	{ ao_watchdog_set,	"Q <0 off, 1 on>\0Enable or disable watchdog timer" },
 	{ 0,			NULL },
 };
diff --git a/src/kernel/ao.h b/src/kernel/ao.h
index 520f6ef2..fd1d1276 100644
--- a/src/kernel/ao.h
+++ b/src/kernel/ao.h
@@ -92,7 +92,7 @@ ao_panic(uint8_t reason);
 #define AO_TICK_SIGNED	int16_t
 #endif
 
-extern volatile __data AO_TICK_TYPE ao_tick_count;
+extern volatile AO_TICK_TYPE ao_tick_count;
 
 /* Our timer runs at 100Hz */
 #ifndef AO_HERTZ
@@ -141,13 +141,13 @@ ao_clock_resume(void);
 
 #ifndef ao_mutex_get
 uint8_t
-ao_mutex_try(__xdata uint8_t *ao_mutex, uint8_t task_id) __reentrant;
+ao_mutex_try(uint8_t *ao_mutex, uint8_t task_id);
 
 void
-ao_mutex_get(__xdata uint8_t *ao_mutex) __reentrant;
+ao_mutex_get(uint8_t *ao_mutex);
 
 void
-ao_mutex_put(__xdata uint8_t *ao_mutex) __reentrant;
+ao_mutex_put(uint8_t *ao_mutex);
 #endif
 
 /*
@@ -160,13 +160,13 @@ enum ao_cmd_status {
 	ao_cmd_syntax_error = 2,
 };
 
-extern __pdata uint16_t ao_cmd_lex_i;
-extern __pdata uint32_t ao_cmd_lex_u32;
-extern __pdata char	ao_cmd_lex_c;
-extern __pdata enum ao_cmd_status ao_cmd_status;
+extern uint16_t ao_cmd_lex_i;
+extern uint32_t ao_cmd_lex_u32;
+extern char	ao_cmd_lex_c;
+extern enum ao_cmd_status ao_cmd_status;
 
 void
-ao_put_string(__code char *s);
+ao_put_string(const char *s);
 
 void
 ao_cmd_readline(void);
@@ -196,22 +196,22 @@ void
 ao_cmd_hex(void);
 
 void
-ao_cmd_decimal(void) __reentrant;
+ao_cmd_decimal(void);
 
 /* Read a single hex nibble off stdin. */
 uint8_t
 ao_getnibble(void);
 
 uint8_t
-ao_match_word(__code char *word);
+ao_match_word(const char *word);
 
 struct ao_cmds {
 	void		(*func)(void);
-	__code char	*help;
+	const char	*help;
 };
 
 void
-ao_cmd_register(const __code struct ao_cmds *cmds);
+ao_cmd_register(const struct ao_cmds *cmds);
 
 void
 ao_cmd_init(void);
@@ -295,13 +295,13 @@ ao_report_init(void);
 #if HAS_BARO
 /* pressure from the sensor to altitude in meters */
 alt_t
-ao_pres_to_altitude(pres_t pres) __reentrant;
+ao_pres_to_altitude(pres_t pres);
 
 pres_t
-ao_altitude_to_pres(alt_t alt) __reentrant;
+ao_altitude_to_pres(alt_t alt);
 
 int16_t
-ao_temp_to_dC(int16_t temp) __reentrant;
+ao_temp_to_dC(int16_t temp);
 #endif
 
 /*
@@ -377,11 +377,11 @@ ao_spi_slave(void);
 #define AO_GPS_NEW_DATA		1
 #define AO_GPS_NEW_TRACKING	2
 
-extern __xdata uint8_t ao_gps_new;
-extern __pdata uint16_t ao_gps_tick;
-extern __xdata uint8_t ao_gps_mutex;
-extern __xdata struct ao_telemetry_location ao_gps_data;
-extern __xdata struct ao_telemetry_satellite ao_gps_tracking_data;
+extern uint8_t ao_gps_new;
+extern uint16_t ao_gps_tick;
+extern uint8_t ao_gps_mutex;
+extern struct ao_telemetry_location ao_gps_data;
+extern struct ao_telemetry_satellite ao_gps_tracking_data;
 
 struct ao_gps_orig {
 	uint8_t			year;
@@ -421,13 +421,13 @@ void
 ao_gps(void);
 
 void
-ao_gps_print(__xdata struct ao_gps_orig *gps_data);
+ao_gps_print(struct ao_gps_orig *gps_data);
 
 void
-ao_gps_tracking_print(__xdata struct ao_gps_tracking_orig *gps_tracking_data);
+ao_gps_tracking_print(struct ao_gps_tracking_orig *gps_tracking_data);
 
 void
-ao_gps_show(void) __reentrant;
+ao_gps_show(void);
 
 void
 ao_gps_init(void);
@@ -558,9 +558,9 @@ ao_telemetry_tiny_init(void);
  * ao_radio.c
  */
 
-extern __xdata uint8_t	ao_radio_dma;
+extern uint8_t	ao_radio_dma;
 
-extern __xdata int8_t	ao_radio_rssi;
+extern int8_t	ao_radio_rssi;
 
 #ifdef PKT_APPEND_STATUS_1_CRC_OK
 #define AO_RADIO_STATUS_CRC_OK	PKT_APPEND_STATUS_1_CRC_OK
@@ -590,12 +590,12 @@ ao_radio_general_isr(void) ao_arch_interrupt(16);
 
 #if HAS_RADIO_XMIT
 void
-ao_radio_send(const __xdata void *d, uint8_t size) __reentrant;
+ao_radio_send(const void *d, uint8_t size);
 #endif
 
 #if HAS_RADIO_RECV
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout) __reentrant;
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout);
 
 void
 ao_radio_recv_abort(void);
@@ -673,14 +673,14 @@ union ao_monitor {
 #endif
 };
 
-extern __xdata union ao_monitor ao_monitor_ring[AO_MONITOR_RING];
+extern union ao_monitor ao_monitor_ring[AO_MONITOR_RING];
 
 #define ao_monitor_ring_next(n)	(((n) + 1) & (AO_MONITOR_RING - 1))
 #define ao_monitor_ring_prev(n)	(((n) - 1) & (AO_MONITOR_RING - 1))
 
-extern __xdata uint8_t ao_monitoring_mutex;
-extern __data uint8_t ao_monitoring;
-extern __data uint8_t ao_monitor_head;
+extern uint8_t ao_monitoring_mutex;
+extern uint8_t ao_monitoring;
+extern uint8_t ao_monitor_head;
 
 void
 ao_monitor(void);
@@ -698,7 +698,7 @@ void
 ao_monitor_enable(void);
 
 void
-ao_monitor_init(void) __reentrant;
+ao_monitor_init(void);
 
 #endif
 
@@ -710,27 +710,27 @@ ao_monitor_init(void) __reentrant;
 
 struct ao_stdio {
 	int	(*_pollchar)(void);	/* Called with interrupts blocked */
-	void	(*putchar)(char c) __reentrant;
+	void	(*putchar)(char c);
 	void	(*flush)(void);
 	uint8_t	echo;
 };
 
-extern __xdata struct ao_stdio ao_stdios[];
-extern __pdata int8_t ao_cur_stdio;
-extern __pdata int8_t ao_num_stdios;
+extern struct ao_stdio ao_stdios[];
+extern int8_t ao_cur_stdio;
+extern int8_t ao_num_stdios;
 
 void
 flush(void);
 
-extern __xdata uint8_t ao_stdin_ready;
+extern uint8_t ao_stdin_ready;
 
 uint8_t
 ao_echo(void);
 
 int8_t
 ao_add_stdio(int (*pollchar)(void),
-	     void (*putchar)(char) __reentrant,
-	     void (*flush)(void)) __reentrant;
+	     void (*putchar)(char) ,
+	     void (*flush)(void));
 
 /*
  * ao_ignite.c
@@ -757,14 +757,14 @@ struct ao_ignition {
 	uint8_t firing;
 };
 
-extern __code char * __code ao_igniter_status_names[];
+extern const char * const ao_igniter_status_names[];
 
-extern __xdata struct ao_ignition ao_ignition[2];
+extern struct ao_ignition ao_ignition[2];
 
 enum ao_igniter_status
 ao_igniter_status(enum ao_igniter igniter);
 
-extern __pdata uint8_t ao_igniter_present;
+extern uint8_t ao_igniter_present;
 
 void
 ao_ignite_set_pins(void);
@@ -785,7 +785,7 @@ ao_igniter_init(void);
 /*
  * Set this to force the frequency to 434.550MHz
  */
-extern __xdata uint8_t ao_force_freq;
+extern uint8_t ao_force_freq;
 #endif
 
 /*
@@ -885,8 +885,8 @@ union ao_log_single {
 	uint8_t				bytes[AO_LOG_SINGLE_SIZE];
 };
 
-extern __xdata union ao_log_single	ao_log_single_write_data;
-extern __xdata union ao_log_single	ao_log_single_read_data;
+extern union ao_log_single	ao_log_single_write_data;
+extern union ao_log_single	ao_log_single_read_data;
 
 void
 ao_log_single_extra_query(void);
@@ -969,7 +969,7 @@ ao_sqrt(uint32_t op);
  * ao_freq.c
  */
 
-int32_t ao_freq_to_set(int32_t freq, int32_t cal) __reentrant;
+int32_t ao_freq_to_set(int32_t freq, int32_t cal);
 
 /*
  * ao_ms5607.c
diff --git a/src/kernel/ao_aes.h b/src/kernel/ao_aes.h
index 5ae98424..f41b2e87 100644
--- a/src/kernel/ao_aes.h
+++ b/src/kernel/ao_aes.h
@@ -21,7 +21,7 @@
 
 /* ao_aes.c */
 
-extern __xdata uint8_t ao_aes_mutex;
+extern uint8_t ao_aes_mutex;
 
 /* AES keys and blocks are 128 bits */
 
@@ -40,14 +40,14 @@ void
 ao_aes_set_mode(enum ao_aes_mode mode);
 
 void
-ao_aes_set_key(__xdata uint8_t *in);
+ao_aes_set_key(uint8_t *in);
 
 void
 ao_aes_zero_iv(void);
 
 void
-ao_aes_run(__xdata uint8_t *in,
-	   __xdata uint8_t *out);
+ao_aes_run(uint8_t *in,
+	   uint8_t *out);
 
 void
 ao_aes_init(void);
diff --git a/src/kernel/ao_balloon.c b/src/kernel/ao_balloon.c
index d0f80a5d..a5be8c16 100644
--- a/src/kernel/ao_balloon.c
+++ b/src/kernel/ao_balloon.c
@@ -34,16 +34,16 @@
 
 #if HAS_SENSOR_ERRORS
 /* Any sensor can set this to mark the flight computer as 'broken' */
-__xdata uint8_t			ao_sensor_errors;
+uint8_t			ao_sensor_errors;
 #endif
 
-__pdata uint16_t		ao_motor_number;	/* number of motors burned so far */
+uint16_t		ao_motor_number;	/* number of motors burned so far */
 
 /* Main flight thread. */
 
-__pdata enum ao_flight_state	ao_flight_state;	/* current flight state */
+enum ao_flight_state	ao_flight_state;	/* current flight state */
 
-__pdata uint8_t			ao_flight_force_idle;
+uint8_t			ao_flight_force_idle;
 
 void
 ao_flight(void)
@@ -127,7 +127,7 @@ ao_flight(void)
 	}
 }
 
-static __xdata struct ao_task	flight_task;
+static struct ao_task	flight_task;
 
 void
 ao_flight_init(void)
diff --git a/src/kernel/ao_beep.h b/src/kernel/ao_beep.h
index 1306af62..fdc150f1 100644
--- a/src/kernel/ao_beep.h
+++ b/src/kernel/ao_beep.h
@@ -85,7 +85,7 @@ ao_beep(uint8_t beep);
 
 /* Turn on the beeper for the specified time */
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant;
+ao_beep_for(uint8_t beep, uint16_t ticks);
 
 /* Initialize the beeper */
 void
diff --git a/src/kernel/ao_cmd.c b/src/kernel/ao_cmd.c
index 7bb4654e..d28db5b7 100644
--- a/src/kernel/ao_cmd.c
+++ b/src/kernel/ao_cmd.c
@@ -19,10 +19,10 @@
 #include "ao.h"
 #include "ao_task.h"
 
-__pdata uint16_t ao_cmd_lex_i;
-__pdata uint32_t ao_cmd_lex_u32;
-__pdata char	ao_cmd_lex_c;
-__pdata enum ao_cmd_status ao_cmd_status;
+uint16_t ao_cmd_lex_i;
+uint32_t ao_cmd_lex_u32;
+char	ao_cmd_lex_c;
+enum ao_cmd_status ao_cmd_status;
 
 #ifndef AO_CMD_LEN
 #if AO_PYRO_NUM
@@ -32,12 +32,12 @@ __pdata enum ao_cmd_status ao_cmd_status;
 #endif
 #endif
 
-static __xdata char	cmd_line[AO_CMD_LEN];
-static __pdata uint8_t	cmd_len;
-static __pdata uint8_t	cmd_i;
+static char	cmd_line[AO_CMD_LEN];
+static uint8_t	cmd_len;
+static uint8_t	cmd_i;
 
 void
-ao_put_string(__code char *s)
+ao_put_string(const char *s)
 {
 	char	c;
 	while ((c = *s++))
@@ -196,7 +196,7 @@ ao_cmd_hexbyte(void)
 void
 ao_cmd_hex(void)
 {
-	__pdata uint8_t	r = ao_cmd_lex_error;
+	uint8_t	r = ao_cmd_lex_error;
 	int8_t	n;
 
 	ao_cmd_lex_i = 0;
@@ -214,7 +214,7 @@ ao_cmd_hex(void)
 }
 
 void
-ao_cmd_decimal(void) __reentrant
+ao_cmd_decimal(void) 
 {
 	uint8_t	r = ao_cmd_lex_error;
 
@@ -234,7 +234,7 @@ ao_cmd_decimal(void) __reentrant
 }
 
 uint8_t
-ao_match_word(__code char *word)
+ao_match_word(const char *word)
 {
 	while (*word) {
 		if (ao_cmd_lex_c != *word) {
@@ -321,16 +321,16 @@ version(void)
 #define NUM_CMDS	11
 #endif
 
-static __code struct ao_cmds	*__xdata (ao_cmds[NUM_CMDS]);
-static __pdata uint8_t		ao_ncmds;
+static const struct ao_cmds	*(ao_cmds[NUM_CMDS]);
+static uint8_t		ao_ncmds;
 
 static void
 help(void)
 {
-	__pdata uint8_t cmds;
-	__pdata uint8_t cmd;
-	__code struct ao_cmds * __pdata cs;
-	__code const char *h;
+	uint8_t cmds;
+	uint8_t cmd;
+	const struct ao_cmds * cs;
+	const char *h;
 	uint8_t e;
 
 	for (cmds = 0; cmds < ao_ncmds; cmds++) {
@@ -363,7 +363,7 @@ report(void)
 }
 
 void
-ao_cmd_register(__code struct ao_cmds *cmds)
+ao_cmd_register(const struct ao_cmds *cmds)
 {
 	if (ao_ncmds >= NUM_CMDS)
 		ao_panic(AO_PANIC_CMD);
@@ -373,10 +373,10 @@ ao_cmd_register(__code struct ao_cmds *cmds)
 void
 ao_cmd(void)
 {
-	__pdata char	c;
+	char	c;
 	uint8_t cmd, cmds;
-	__code struct ao_cmds * __xdata cs;
-	void (*__xdata func)(void);
+	const struct ao_cmds * cs;
+	void (*func)(void);
 
 	for (;;) {
 		ao_cmd_readline();
@@ -424,10 +424,10 @@ ao_loader(void)
 #endif
 
 #if HAS_TASK
-__xdata struct ao_task ao_cmd_task;
+struct ao_task ao_cmd_task;
 #endif
 
-__code struct ao_cmds	ao_base_cmds[] = {
+const struct ao_cmds	ao_base_cmds[] = {
 	{ help,		"?\0Help" },
 #if HAS_TASK_INFO && HAS_TASK
 	{ ao_task_info,	"T\0Tasks" },
diff --git a/src/kernel/ao_companion.h b/src/kernel/ao_companion.h
index 4c161455..bd702fe3 100644
--- a/src/kernel/ao_companion.h
+++ b/src/kernel/ao_companion.h
@@ -44,11 +44,11 @@ struct ao_companion_setup {
 	uint8_t		channels;
 };
 
-extern __pdata uint8_t				ao_companion_running;
-extern __xdata uint8_t				ao_companion_mutex;
-extern __xdata struct ao_companion_command	ao_companion_command;
-extern __xdata struct ao_companion_setup	ao_companion_setup;
-extern __xdata uint16_t				ao_companion_data[AO_COMPANION_MAX_CHANNELS];
+extern uint8_t				ao_companion_running;
+extern uint8_t				ao_companion_mutex;
+extern struct ao_companion_command	ao_companion_command;
+extern struct ao_companion_setup	ao_companion_setup;
+extern uint16_t				ao_companion_data[AO_COMPANION_MAX_CHANNELS];
 
 void
 ao_companion_init(void);
diff --git a/src/kernel/ao_config.c b/src/kernel/ao_config.c
index 10a67116..277dddd9 100644
--- a/src/kernel/ao_config.c
+++ b/src/kernel/ao_config.c
@@ -30,13 +30,13 @@
 #include <ao_tracker.h>
 #endif
 
-__xdata struct ao_config ao_config;
-__pdata uint8_t ao_config_loaded;
-__pdata uint8_t ao_config_dirty;
-__xdata uint8_t ao_config_mutex;
+struct ao_config ao_config;
+uint8_t ao_config_loaded;
+uint8_t ao_config_dirty;
+uint8_t ao_config_mutex;
 
 #if HAS_FORCE_FREQ
-__xdata uint8_t ao_force_freq;
+uint8_t ao_force_freq;
 #endif
 
 #ifndef AO_CONFIG_DEFAULT_APRS_INTERVAL
@@ -100,7 +100,7 @@ ao_config_put(void)
 #if HAS_RADIO
 
 #if HAS_RADIO_FORWARD
-__xdata uint32_t	ao_send_radio_setting;
+uint32_t	ao_send_radio_setting;
 #endif
 
 void
@@ -283,10 +283,10 @@ ao_config_callsign_show(void)
 }
 
 void
-ao_config_callsign_set(void) __reentrant
+ao_config_callsign_set(void) 
 {
 	uint8_t	c;
-	static __xdata char callsign[AO_MAX_CALLSIGN + 1];
+	static char callsign[AO_MAX_CALLSIGN + 1];
 
 	ao_xmemset(callsign, '\0', sizeof callsign);
 	ao_cmd_white();
@@ -309,14 +309,14 @@ ao_config_callsign_set(void) __reentrant
 #if HAS_RADIO
 
 void
-ao_config_frequency_show(void) __reentrant
+ao_config_frequency_show(void) 
 {
 	printf("Frequency: %ld\n",
 	       ao_config.frequency);
 }
 
 void
-ao_config_frequency_set(void) __reentrant
+ao_config_frequency_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -334,14 +334,14 @@ ao_config_frequency_set(void) __reentrant
 
 #if HAS_RADIO_FORWARD
 void
-ao_config_send_frequency_show(void) __reentrant
+ao_config_send_frequency_show(void) 
 {
 	printf("Send frequency: %ld\n",
 	       ao_config.send_frequency);
 }
 
 void
-ao_config_send_frequency_set(void) __reentrant
+ao_config_send_frequency_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -360,14 +360,14 @@ ao_config_send_frequency_set(void) __reentrant
 #if HAS_FLIGHT
 
 void
-ao_config_main_deploy_show(void) __reentrant
+ao_config_main_deploy_show(void) 
 {
 	printf("Main deploy: %d meters\n",
 	       ao_config.main_deploy);
 }
 
 void
-ao_config_main_deploy_set(void) __reentrant
+ao_config_main_deploy_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -379,7 +379,7 @@ ao_config_main_deploy_set(void) __reentrant
 
 #if HAS_ACCEL
 void
-ao_config_accel_calibrate_show(void) __reentrant
+ao_config_accel_calibrate_show(void) 
 {
 	printf("Accel cal +1g: %d -1g: %d\n",
 	       ao_config.accel_plus_g, ao_config.accel_minus_g);
@@ -401,7 +401,7 @@ static int16_t accel_cal_through;
 #endif
 
 static int16_t
-ao_config_accel_calibrate_auto(char *orientation) __reentrant
+ao_config_accel_calibrate_auto(char *orientation) 
 {
 	uint16_t	i;
 	int32_t		accel_total;
@@ -442,7 +442,7 @@ ao_config_accel_calibrate_auto(char *orientation) __reentrant
 }
 
 void
-ao_config_accel_calibrate_set(void) __reentrant
+ao_config_accel_calibrate_set(void) 
 {
 	int16_t	up, down;
 #if HAS_GYRO
@@ -494,14 +494,14 @@ ao_config_accel_calibrate_set(void) __reentrant
 #endif /* HAS_ACCEL */
 
 void
-ao_config_apogee_delay_show(void) __reentrant
+ao_config_apogee_delay_show(void) 
 {
 	printf("Apogee delay: %d seconds\n",
 	       ao_config.apogee_delay);
 }
 
 void
-ao_config_apogee_delay_set(void) __reentrant
+ao_config_apogee_delay_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -512,14 +512,14 @@ ao_config_apogee_delay_set(void) __reentrant
 }
 
 void
-ao_config_apogee_lockout_show(void) __reentrant
+ao_config_apogee_lockout_show(void) 
 {
 	printf ("Apogee lockout: %d seconds\n",
 		ao_config.apogee_lockout);
 }
 
 void
-ao_config_apogee_lockout_set(void) __reentrant
+ao_config_apogee_lockout_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -533,13 +533,13 @@ ao_config_apogee_lockout_set(void) __reentrant
 
 #if HAS_RADIO
 void
-ao_config_radio_cal_show(void) __reentrant
+ao_config_radio_cal_show(void) 
 {
 	printf("Radio cal: %ld\n", ao_config.radio_cal);
 }
 
 void
-ao_config_radio_cal_set(void) __reentrant
+ao_config_radio_cal_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -558,13 +558,13 @@ ao_config_radio_cal_set(void) __reentrant
 #endif
 
 void
-ao_config_radio_rate_show(void) __reentrant
+ao_config_radio_rate_show(void) 
 {
 	printf("Telemetry rate: %d\n", ao_config.radio_rate);
 }
 
 void
-ao_config_radio_rate_set(void) __reentrant
+ao_config_radio_rate_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -588,7 +588,7 @@ ao_config_radio_rate_set(void) __reentrant
 #if HAS_LOG
 
 void
-ao_config_log_show(void) __reentrant
+ao_config_log_show(void) 
 {
 	printf("Max flight log: %d kB\n", (int16_t) (ao_config.flight_log_max >> 10));
 #if FLIGHT_LOG_APPEND
@@ -611,7 +611,7 @@ ao_config_log_fix_append(void)
 #endif
 
 void
-ao_config_log_set(void) __reentrant
+ao_config_log_set(void) 
 {
 #if FLIGHT_LOG_APPEND
 	printf("Flight log fixed size %d kB\n", ao_storage_log_max >> 10);
@@ -639,13 +639,13 @@ ao_config_log_set(void) __reentrant
 
 #if HAS_IGNITE
 void
-ao_config_ignite_mode_show(void) __reentrant
+ao_config_ignite_mode_show(void) 
 {
 	printf("Ignite mode: %d\n", ao_config.ignite_mode);
 }
 
 void
-ao_config_ignite_mode_set(void) __reentrant
+ao_config_ignite_mode_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -658,7 +658,7 @@ ao_config_ignite_mode_set(void) __reentrant
 
 #if HAS_ACCEL
 void
-ao_config_pad_orientation_show(void) __reentrant
+ao_config_pad_orientation_show(void) 
 {
 	printf("Pad orientation: %d\n", ao_config.pad_orientation);
 }
@@ -668,7 +668,7 @@ ao_config_pad_orientation_show(void) __reentrant
 #endif
 
 void
-ao_config_pad_orientation_set(void) __reentrant
+ao_config_pad_orientation_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -688,13 +688,13 @@ ao_config_pad_orientation_set(void) __reentrant
 
 #if HAS_RADIO
 void
-ao_config_radio_enable_show(void) __reentrant
+ao_config_radio_enable_show(void) 
 {
 	printf("Radio enable: %d\n", ao_config.radio_enable);
 }
 
 void
-ao_config_radio_enable_set(void) __reentrant
+ao_config_radio_enable_set(void) 
 {
 	ao_cmd_decimal();
 	if (ao_cmd_status != ao_cmd_success)
@@ -710,10 +710,10 @@ ao_config_radio_enable_set(void) __reentrant
 
 #if HAS_AES
 
-__xdata uint8_t	ao_config_aes_seq = 1;
+uint8_t	ao_config_aes_seq = 1;
 
 void
-ao_config_key_show(void) __reentrant
+ao_config_key_show(void) 
 {
 	uint8_t	i;
 	printf("AES key: ");
@@ -723,7 +723,7 @@ ao_config_key_show(void) __reentrant
 }
 
 void
-ao_config_key_set(void) __reentrant
+ao_config_key_set(void) 
 {
 	uint8_t i;
 
@@ -950,23 +950,23 @@ ao_config_pad_idle_set(void)
 #endif
 
 struct ao_config_var {
-	__code char	*str;
-	void		(*set)(void) __reentrant;
-	void		(*show)(void) __reentrant;
+	const char	*str;
+	void		(*set)(void);
+	void		(*show)(void);
 };
 
 static void
-ao_config_help(void) __reentrant;
+ao_config_help(void);
 
 static void
-ao_config_show(void) __reentrant;
+ao_config_show(void);
 
 #if HAS_EEPROM
 static void
-ao_config_save(void) __reentrant;
+ao_config_save(void);
 #endif
 
-__code struct ao_config_var ao_config_vars[] = {
+const struct ao_config_var ao_config_vars[] = {
 #if HAS_FLIGHT
 	{ "m <meters>\0Main deploy (m)",
 	  ao_config_main_deploy_set,	ao_config_main_deploy_show, },
@@ -1078,7 +1078,7 @@ ao_config_set(void)
 }
 
 static void
-ao_config_help(void) __reentrant
+ao_config_help(void) 
 {
 	uint8_t cmd;
 	for (cmd = 0; ao_config_vars[cmd].str != NULL; cmd++)
@@ -1089,7 +1089,7 @@ ao_config_help(void) __reentrant
 }
 
 static void
-ao_config_show(void) __reentrant
+ao_config_show(void) 
 {
 	uint8_t cmd;
 	ao_config_get();
@@ -1105,7 +1105,7 @@ ao_config_show(void) __reentrant
 
 #if HAS_EEPROM
 static void
-ao_config_save(void) __reentrant
+ao_config_save(void) 
 {
 	uint8_t saved = 0;
 	ao_mutex_get(&ao_config_mutex);
@@ -1122,7 +1122,7 @@ ao_config_save(void) __reentrant
 }
 #endif
 
-__code struct ao_cmds ao_config_cmds[] = {
+const struct ao_cmds ao_config_cmds[] = {
 	{ ao_config_set,	"c <var> <value>\0Set config (? for help, s to show)" },
 	{ 0, NULL },
 };
diff --git a/src/kernel/ao_config.h b/src/kernel/ao_config.h
index f730c73c..41aafcca 100644
--- a/src/kernel/ao_config.h
+++ b/src/kernel/ao_config.h
@@ -62,7 +62,7 @@
 
 #define AO_AES_LEN 16
 
-extern __xdata uint8_t ao_config_aes_seq;
+extern uint8_t ao_config_aes_seq;
 
 struct ao_config {
 	uint8_t		major;
@@ -130,7 +130,7 @@ struct ao_config {
 #define AO_CONFIG_DEFAULT_APRS_FORMAT	AO_APRS_FORMAT_COMPRESSED
 
 #if HAS_RADIO_FORWARD
-extern __xdata uint32_t	ao_send_radio_setting;
+extern uint32_t	ao_send_radio_setting;
 #endif
 
 #define AO_IGNITE_MODE_DUAL		0
@@ -151,8 +151,8 @@ extern __xdata uint32_t	ao_send_radio_setting;
 /* Make sure AO_CONFIG_MAX_SIZE is big enough */
 typedef uint8_t	config_check_space[(int) (AO_CONFIG_MAX_SIZE - sizeof (struct ao_config))];
 
-extern __xdata struct ao_config ao_config;
-extern __pdata uint8_t ao_config_loaded;
+extern struct ao_config ao_config;
+extern uint8_t ao_config_loaded;
 
 void
 _ao_config_edit_start(void);
diff --git a/src/kernel/ao_convert.c b/src/kernel/ao_convert.c
index 1cd62345..f3e523ec 100644
--- a/src/kernel/ao_convert.c
+++ b/src/kernel/ao_convert.c
@@ -30,7 +30,7 @@ static const ao_v_t altitude_table[] = {
 #define ALT_FRAC_MASK	(ALT_FRAC_SCALE - 1)
 
 ao_v_t
-ao_pres_to_altitude(int16_t pres) __reentrant
+ao_pres_to_altitude(int16_t pres) 
 {
 	uint8_t	o;
 	int16_t	part;
@@ -46,7 +46,7 @@ ao_pres_to_altitude(int16_t pres) __reentrant
 
 #if AO_NEED_ALTITUDE_TO_PRES
 int16_t
-ao_altitude_to_pres(ao_v_t alt) __reentrant
+ao_altitude_to_pres(ao_v_t alt) 
 {
 	ao_v_t span, sub_span;
 	uint8_t	l, h, m;
@@ -74,7 +74,7 @@ ao_altitude_to_pres(ao_v_t alt) __reentrant
 
 #if 0
 int16_t
-ao_temp_to_dC(int16_t temp) __reentrant
+ao_temp_to_dC(int16_t temp) 
 {
 	int16_t	ret;
 
diff --git a/src/kernel/ao_data.c b/src/kernel/ao_data.c
index 35d42b8f..536ffa2b 100644
--- a/src/kernel/ao_data.c
+++ b/src/kernel/ao_data.c
@@ -19,13 +19,13 @@
 #include <ao.h>
 #include <ao_data.h>
 
-volatile __xdata struct ao_data	ao_data_ring[AO_DATA_RING];
-volatile __data uint8_t		ao_data_head;
-volatile __data uint8_t		ao_data_present;
+volatile struct ao_data	ao_data_ring[AO_DATA_RING];
+volatile uint8_t		ao_data_head;
+volatile uint8_t		ao_data_present;
 
 #ifndef ao_data_count
 void
-ao_data_get(__xdata struct ao_data *packet)
+ao_data_get(struct ao_data *packet)
 {
 #if HAS_FLIGHT
 	uint8_t	i = ao_data_ring_prev(ao_sample_data);
diff --git a/src/kernel/ao_data.h b/src/kernel/ao_data.h
index 30616ef0..f88b30c9 100644
--- a/src/kernel/ao_data.h
+++ b/src/kernel/ao_data.h
@@ -97,12 +97,12 @@ struct ao_data {
 
 /* Get a copy of the last complete sample set */
 void
-ao_data_get(__xdata struct ao_data *packet);
+ao_data_get(struct ao_data *packet);
 
-extern volatile __xdata struct ao_data	ao_data_ring[AO_DATA_RING];
-extern volatile __data uint8_t		ao_data_head;
-extern volatile __data uint8_t		ao_data_present;
-extern volatile __data uint8_t		ao_data_count;
+extern volatile struct ao_data	ao_data_ring[AO_DATA_RING];
+extern volatile uint8_t		ao_data_head;
+extern volatile uint8_t		ao_data_present;
+extern volatile uint8_t		ao_data_count;
 
 /*
  * Mark a section of data as ready, check for data complete
diff --git a/src/kernel/ao_ee_fake.c b/src/kernel/ao_ee_fake.c
index 84c13000..cef0a438 100644
--- a/src/kernel/ao_ee_fake.c
+++ b/src/kernel/ao_ee_fake.c
@@ -23,7 +23,7 @@
  * wants to call these functions
  */
 uint8_t
-ao_ee_write_config(uint8_t *buf, uint16_t len) __reentrant
+ao_ee_write_config(uint8_t *buf, uint16_t len) 
 {
 	(void) buf;
 	(void) len;
@@ -31,7 +31,7 @@ ao_ee_write_config(uint8_t *buf, uint16_t len) __reentrant
 }
 
 uint8_t
-ao_ee_read_config(uint8_t *buf, uint16_t len) __reentrant
+ao_ee_read_config(uint8_t *buf, uint16_t len) 
 {
 	ao_xmemset(buf, '\0', len);
 	return 1;
diff --git a/src/kernel/ao_eeprom.h b/src/kernel/ao_eeprom.h
index bd8b6725..f258c48c 100644
--- a/src/kernel/ao_eeprom.h
+++ b/src/kernel/ao_eeprom.h
@@ -26,13 +26,13 @@ extern const ao_pos_t	ao_eeprom_total;
  */
 
 uint8_t
-ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len);
+ao_eeprom_write(ao_pos_t pos32, void *v, uint16_t len);
 
 /*
  * Read from eeprom
  */
 uint8_t
-ao_eeprom_read(ao_pos_t pos, __xdata void *v, uint16_t len);
+ao_eeprom_read(ao_pos_t pos, void *v, uint16_t len);
 
 /*
  * Initialize eeprom
diff --git a/src/kernel/ao_flight.c b/src/kernel/ao_flight.c
index 170396ff..f72efa06 100644
--- a/src/kernel/ao_flight.c
+++ b/src/kernel/ao_flight.c
@@ -47,28 +47,28 @@
 
 /* Main flight thread. */
 
-__pdata enum ao_flight_state	ao_flight_state;	/* current flight state */
-__pdata uint16_t		ao_boost_tick;		/* time of most recent boost detect */
-__pdata uint16_t		ao_launch_tick;		/* time of first boost detect */
-__pdata uint16_t		ao_motor_number;	/* number of motors burned so far */
+enum ao_flight_state	ao_flight_state;	/* current flight state */
+uint16_t		ao_boost_tick;		/* time of most recent boost detect */
+uint16_t		ao_launch_tick;		/* time of first boost detect */
+uint16_t		ao_motor_number;	/* number of motors burned so far */
 
 #if HAS_SENSOR_ERRORS
 /* Any sensor can set this to mark the flight computer as 'broken' */
-__xdata uint8_t			ao_sensor_errors;
+uint8_t			ao_sensor_errors;
 #endif
 
 /*
  * track min/max data over a long interval to detect
  * resting
  */
-static __data uint16_t		ao_interval_end;
-static __data ao_v_t		ao_interval_min_height;
-static __data ao_v_t		ao_interval_max_height;
+static uint16_t		ao_interval_end;
+static ao_v_t		ao_interval_min_height;
+static ao_v_t		ao_interval_max_height;
 #if HAS_ACCEL
-static __data ao_v_t		ao_coast_avg_accel;
+static ao_v_t		ao_coast_avg_accel;
 #endif
 
-__pdata uint8_t			ao_flight_force_idle;
+uint8_t			ao_flight_force_idle;
 
 /* We also have a clock, which can be used to sanity check things in
  * case of other failures
@@ -463,7 +463,7 @@ ao_orient_test_select(void)
 	ao_orient_test = !ao_orient_test;
 }
 
-__code struct ao_cmds ao_flight_cmds[] = {
+const struct ao_cmds ao_flight_cmds[] = {
 	{ ao_flight_dump, 	"F\0Dump flight status" },
 	{ ao_gyro_test,		"G\0Test gyro code" },
 	{ ao_orient_test_select,"O\0Test orientation code" },
@@ -471,7 +471,7 @@ __code struct ao_cmds ao_flight_cmds[] = {
 };
 #endif
 
-static __xdata struct ao_task	flight_task;
+static struct ao_task	flight_task;
 
 void
 ao_flight_init(void)
diff --git a/src/kernel/ao_flight.h b/src/kernel/ao_flight.h
index 005c7e84..af6b0c55 100644
--- a/src/kernel/ao_flight.h
+++ b/src/kernel/ao_flight.h
@@ -38,21 +38,21 @@ enum ao_flight_state {
 	ao_flight_test = 10
 };
 
-extern __pdata enum ao_flight_state	ao_flight_state;
-extern __pdata uint16_t			ao_boost_tick;
-extern __pdata uint16_t			ao_launch_tick;
-extern __pdata uint16_t			ao_motor_number;
+extern enum ao_flight_state	ao_flight_state;
+extern uint16_t			ao_boost_tick;
+extern uint16_t			ao_launch_tick;
+extern uint16_t			ao_motor_number;
 
 #if HAS_IMU || HAS_MMA655X
 #define HAS_SENSOR_ERRORS	1
 #endif
 
 #if HAS_SENSOR_ERRORS
-extern __xdata uint8_t			ao_sensor_errors;
+extern uint8_t			ao_sensor_errors;
 #endif
 
-extern __pdata uint16_t			ao_launch_time;
-extern __pdata uint8_t			ao_flight_force_idle;
+extern uint16_t			ao_launch_time;
+extern uint8_t			ao_flight_force_idle;
 
 /* Flight thread */
 void
diff --git a/src/kernel/ao_flight_nano.c b/src/kernel/ao_flight_nano.c
index 797ea344..96d47fac 100644
--- a/src/kernel/ao_flight_nano.c
+++ b/src/kernel/ao_flight_nano.c
@@ -20,18 +20,18 @@
 
 /* Main flight thread. */
 
-__pdata enum ao_flight_state	ao_flight_state;	/* current flight state */
-__pdata uint16_t		ao_launch_tick;		/* time of launch detect */
+enum ao_flight_state	ao_flight_state;	/* current flight state */
+uint16_t		ao_launch_tick;		/* time of launch detect */
 
 /*
  * track min/max data over a long interval to detect
  * resting
  */
-__pdata uint16_t		ao_interval_end;
-__pdata alt_t			ao_interval_min_height;
-__pdata alt_t			ao_interval_max_height;
+uint16_t		ao_interval_end;
+alt_t			ao_interval_min_height;
+alt_t			ao_interval_max_height;
 
-__pdata uint8_t			ao_flight_force_idle;
+uint8_t			ao_flight_force_idle;
 
 /* Landing is detected by getting constant readings from both pressure and accelerometer
  * for a fairly long time (AO_INTERVAL_TICKS)
@@ -111,7 +111,7 @@ ao_flight_nano(void)
 	}
 }
 
-static __xdata struct ao_task	flight_task;
+static struct ao_task	flight_task;
 
 void
 ao_flight_nano_init(void)
diff --git a/src/kernel/ao_forward.c b/src/kernel/ao_forward.c
index b1ab3f54..6f664b60 100644
--- a/src/kernel/ao_forward.c
+++ b/src/kernel/ao_forward.c
@@ -23,7 +23,7 @@ static void
 ao_monitor_forward(void)
 {
 	uint32_t					recv_radio_setting;
-	static __xdata struct ao_telemetry_all_recv	packet;
+	static struct ao_telemetry_all_recv	packet;
 
 	for (;;) {
 		while (ao_monitoring)
@@ -40,10 +40,10 @@ ao_monitor_forward(void)
 	}
 }
 
-static __xdata struct ao_task ao_monitor_forward_task;
+static struct ao_task ao_monitor_forward_task;
 
 void
-ao_monitor_forward_init(void) __reentrant
+ao_monitor_forward_init(void) 
 {
 	ao_add_task(&ao_monitor_forward_task, ao_monitor_forward, "monitor_forward");
 }
diff --git a/src/kernel/ao_forward.h b/src/kernel/ao_forward.h
index 2fe28f66..5b21bf3c 100644
--- a/src/kernel/ao_forward.h
+++ b/src/kernel/ao_forward.h
@@ -20,6 +20,6 @@
 #define _AO_FORWARD_H_
 
 void
-ao_monitor_forward_init(void) __reentrant;
+ao_monitor_forward_init(void);
 
 #endif /* _AO_FORWARD_H_ */
diff --git a/src/kernel/ao_freq.c b/src/kernel/ao_freq.c
index 6478dae2..81640ce8 100644
--- a/src/kernel/ao_freq.c
+++ b/src/kernel/ao_freq.c
@@ -26,11 +26,11 @@
  * frequency, and updating the radio setting along the way
  */
 
-int32_t ao_freq_to_set(int32_t freq, int32_t cal) __reentrant
+int32_t ao_freq_to_set(int32_t freq, int32_t cal) 
 {
-	static __pdata int32_t	set;
-	static __pdata uint8_t	neg;
-	static __pdata int32_t	error;
+	static int32_t	set;
+	static uint8_t	neg;
+	static int32_t	error;
 
 	set = 0;
 	neg = 0;
diff --git a/src/kernel/ao_gps_print.c b/src/kernel/ao_gps_print.c
index b1183bad..6dfd1bdd 100644
--- a/src/kernel/ao_gps_print.c
+++ b/src/kernel/ao_gps_print.c
@@ -26,7 +26,7 @@
 #endif
 
 void
-ao_gps_print(__xdata struct ao_gps_orig *gps_data) __reentrant
+ao_gps_print(struct ao_gps_orig *gps_data) 
 {
 	char	state;
 
@@ -82,10 +82,10 @@ ao_gps_print(__xdata struct ao_gps_orig *gps_data) __reentrant
 }
 
 void
-ao_gps_tracking_print(__xdata struct ao_gps_tracking_orig *gps_tracking_data) __reentrant
+ao_gps_tracking_print(struct ao_gps_tracking_orig *gps_tracking_data) 
 {
 	uint8_t	c, n, v;
-	__xdata struct ao_gps_sat_orig	*sat;
+	struct ao_gps_sat_orig	*sat;
 
 	n = gps_tracking_data->channels;
 	if (n == 0)
diff --git a/src/kernel/ao_gps_report.c b/src/kernel/ao_gps_report.c
index 75c2f367..0ef9a725 100644
--- a/src/kernel/ao_gps_report.c
+++ b/src/kernel/ao_gps_report.c
@@ -21,9 +21,9 @@
 void
 ao_gps_report(void)
 {
-	static __xdata struct ao_log_record		gps_log;
-	static __xdata struct ao_telemetry_location	gps_data;
-	static __xdata struct ao_telemetry_satellite	gps_tracking_data;
+	static struct ao_log_record		gps_log;
+	static struct ao_telemetry_location	gps_data;
+	static struct ao_telemetry_satellite	gps_tracking_data;
 	uint8_t	date_reported = 0;
 	uint8_t new;
 
@@ -85,7 +85,7 @@ ao_gps_report(void)
 	}
 }
 
-__xdata struct ao_task ao_gps_report_task;
+struct ao_task ao_gps_report_task;
 
 void
 ao_gps_report_init(void)
diff --git a/src/kernel/ao_gps_report_mega.c b/src/kernel/ao_gps_report_mega.c
index 85614b85..37f1beaa 100644
--- a/src/kernel/ao_gps_report_mega.c
+++ b/src/kernel/ao_gps_report_mega.c
@@ -59,9 +59,9 @@ ao_gps_sparse_should_log(int32_t lat, int32_t lon, int16_t alt)
 void
 ao_gps_report_mega(void)
 {
-	static __xdata struct ao_log_mega		gps_log;
-	static __xdata struct ao_telemetry_location	gps_data;
-	static __xdata struct ao_telemetry_satellite	gps_tracking_data;
+	static struct ao_log_mega		gps_log;
+	static struct ao_telemetry_location	gps_data;
+	static struct ao_telemetry_satellite	gps_tracking_data;
 	uint8_t	new;
 	uint8_t	c, n, i;
 
@@ -125,7 +125,7 @@ ao_gps_report_mega(void)
 	}
 }
 
-__xdata struct ao_task ao_gps_report_mega_task;
+struct ao_task ao_gps_report_mega_task;
 
 void
 ao_gps_report_mega_init(void)
diff --git a/src/kernel/ao_gps_report_metrum.c b/src/kernel/ao_gps_report_metrum.c
index 523fb17f..06863fe4 100644
--- a/src/kernel/ao_gps_report_metrum.c
+++ b/src/kernel/ao_gps_report_metrum.c
@@ -22,9 +22,9 @@
 void
 ao_gps_report_metrum(void)
 {
-	static __xdata struct ao_log_metrum		gps_log;
-	static __xdata struct ao_telemetry_location	gps_data;
-	static __xdata struct ao_telemetry_satellite	gps_tracking_data;
+	static struct ao_log_metrum		gps_log;
+	static struct ao_telemetry_location	gps_data;
+	static struct ao_telemetry_satellite	gps_tracking_data;
 	uint8_t	c, n, i;
 	uint8_t svid;
 	uint8_t new;
@@ -88,7 +88,7 @@ ao_gps_report_metrum(void)
 	}
 }
 
-__xdata struct ao_task ao_gps_report_metrum_task;
+struct ao_task ao_gps_report_metrum_task;
 
 void
 ao_gps_report_metrum_init(void)
diff --git a/src/kernel/ao_gps_show.c b/src/kernel/ao_gps_show.c
index ec197769..ab29e5e5 100644
--- a/src/kernel/ao_gps_show.c
+++ b/src/kernel/ao_gps_show.c
@@ -23,7 +23,7 @@
 #include <ao_data.h>
 
 void
-ao_gps_show(void) __reentrant
+ao_gps_show(void) 
 {
 	uint8_t	i;
 	ao_mutex_get(&ao_gps_mutex);
diff --git a/src/kernel/ao_host.h b/src/kernel/ao_host.h
index 638dba99..592de54c 100644
--- a/src/kernel/ao_host.h
+++ b/src/kernel/ao_host.h
@@ -41,11 +41,7 @@ struct ao_adc {
 	int16_t		sense_m;	/* main continuity sense */
 };
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #define a	(a)
 #define a	(a)
diff --git a/src/kernel/ao_ignite.c b/src/kernel/ao_ignite.c
index 52d9d77e..5f41c552 100644
--- a/src/kernel/ao_ignite.c
+++ b/src/kernel/ao_ignite.c
@@ -23,7 +23,7 @@
 #endif
 
 #if HAS_IGNITE
-__xdata struct ao_ignition ao_ignition[2];
+struct ao_ignition ao_ignition[2];
 
 void
 ao_ignite(enum ao_igniter igniter)
@@ -42,9 +42,9 @@ ao_ignite(enum ao_igniter igniter)
 enum ao_igniter_status
 ao_igniter_status(enum ao_igniter igniter)
 {
-	__xdata struct ao_data packet;
-	__pdata int16_t value;
-	__pdata uint8_t request, firing, fired;
+	struct ao_data packet;
+	int16_t value;
+	uint8_t request, firing, fired;
 
 	ao_arch_critical(
 		ao_data_get(&packet);
@@ -141,7 +141,7 @@ ao_igniter_fire(enum ao_igniter igniter)
 void
 ao_igniter(void)
 {
-	__xdata enum ao_igniter igniter;
+	enum ao_igniter igniter;
 
 	ao_config_get();
 	for (;;) {
@@ -187,13 +187,13 @@ ao_ignite_manual(void)
 	ao_cmd_status = ao_cmd_syntax_error;
 }
 
-__code char * __code ao_igniter_status_names[] = {
+const char * const ao_igniter_status_names[] = {
 	"unknown", "ready", "active", "open"
 };
 
 #if HAS_IGNITE
 void
-ao_ignite_print_status(enum ao_igniter igniter, __code char *name) __reentrant
+ao_ignite_print_status(enum ao_igniter igniter, const char *name) 
 {
 	enum ao_igniter_status status = ao_igniter_status(igniter);
 	printf("Igniter: %6s Status: %s\n",
@@ -214,14 +214,14 @@ ao_ignite_test(void)
 #endif
 }
 
-__code struct ao_cmds ao_ignite_cmds[] = {
+const struct ao_cmds ao_ignite_cmds[] = {
 	{ ao_ignite_manual,	"i <key> {main|drogue}\0Fire igniter. <key> is doit with D&I" },
 	{ ao_ignite_test,	"t\0Test igniter" },
 	{ 0,	NULL },
 };
 
 #if HAS_IGNITE
-__xdata struct ao_task ao_igniter_task;
+struct ao_task ao_igniter_task;
 
 void
 ao_ignite_set_pins(void)
diff --git a/src/kernel/ao_int64.c b/src/kernel/ao_int64.c
index fdea61c0..dffb8556 100644
--- a/src/kernel/ao_int64.c
+++ b/src/kernel/ao_int64.c
@@ -18,7 +18,7 @@
 
 #include <ao_int64.h>
 
-void ao_plus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t *b) __FATTR {
+void ao_plus64(ao_int64_t *r, ao_int64_t *a, ao_int64_t *b) __FATTR {
 	__LOCAL uint32_t	t;
 
 	r->high = a->high + b->high;
@@ -28,7 +28,7 @@ void ao_plus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t
 	r->low = t;
 }
 
-void ao_minus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t *b) __FATTR {
+void ao_minus64(ao_int64_t *r, ao_int64_t *a, ao_int64_t *b) __FATTR {
 	__LOCAL uint32_t	t;
 
 	r->high = a->high - b->high;
@@ -38,7 +38,7 @@ void ao_minus64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, __pdata ao_int64_t
 	r->low = t;
 }
 
-void ao_rshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATTR {
+void ao_rshift64(ao_int64_t *r, ao_int64_t *a, uint8_t d) __FATTR {
 	if (d < 32) {
 		r->low = a->low >> d;
 		if (d)
@@ -51,7 +51,7 @@ void ao_rshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATT
 	}
 }
 
-void ao_lshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATTR {
+void ao_lshift64(ao_int64_t *r, ao_int64_t *a, uint8_t d) __FATTR {
 	if (d < 32) {
 		r->high = a->high << d;
 		if (d)
@@ -64,7 +64,7 @@ void ao_lshift64(__pdata ao_int64_t *r, __pdata ao_int64_t *a, uint8_t d) __FATT
 	}
 }
 
-static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) __reentrant {
+static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) {
 	__LOCAL uint32_t	s;
 	__LOCAL ao_int64_t	t;
 	r->low = (uint32_t) (uint16_t) a * (uint16_t) b;
@@ -83,7 +83,7 @@ static void ao_umul64_32_32(__ARG ao_int64_t *r, uint32_t a, uint32_t b) __reent
 	ao_plus64(r, r, &t);
 }
 
-void ao_neg64(__pdata ao_int64_t *r, __pdata ao_int64_t *a) __FATTR {
+void ao_neg64(ao_int64_t *r, ao_int64_t *a) __FATTR {
 	r->high = ~a->high;
 	if (!(r->low = ~a->low + 1))
 		r->high++;
@@ -105,7 +105,7 @@ void ao_mul64_32_32(__ARG ao_int64_t *r, int32_t a, int32_t b) __FATTR {
 		ao_neg64(r, r);
 }
 
-static void ao_umul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) __reentrant {
+static void ao_umul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) {
 	__LOCAL ao_int64_t	r2, r3;
 
 	ao_umul64_32_32(&r2, a->high, b->low);
@@ -135,7 +135,7 @@ void ao_mul64(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG ao_int64_t *b) __F
 		ao_neg64(r, r);
 }
 
-static void ao_umul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, uint16_t b) __reentrant {
+static void ao_umul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, uint16_t b) {
 	__LOCAL uint32_t h;
 
 	h = a->high * b;
diff --git a/src/kernel/ao_int64.h b/src/kernel/ao_int64.h
index 11c16404..3014182a 100644
--- a/src/kernel/ao_int64.h
+++ b/src/kernel/ao_int64.h
@@ -27,14 +27,14 @@ typedef struct {
 } ao_int64_t;
 
 #define __FATTR
-#define __ARG __pdata
-#define __LOCAL static __pdata
-
-void ao_plus64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, __pdata ao_int64_t *ao_64b) __FATTR;
-void ao_minus64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, __pdata ao_int64_t *ao_64b) __FATTR;
-void ao_neg64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a) __FATTR;
-void ao_rshift64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, uint8_t d) __FATTR;
-void ao_lshift64(__pdata ao_int64_t *ao_64r, __pdata ao_int64_t *ao_64a, uint8_t d) __FATTR;
+#define __ARG 
+#define __LOCAL static 
+
+void ao_plus64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, ao_int64_t *ao_64b) __FATTR;
+void ao_minus64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, ao_int64_t *ao_64b) __FATTR;
+void ao_neg64(ao_int64_t *ao_64r, ao_int64_t *ao_64a) __FATTR;
+void ao_rshift64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, uint8_t d) __FATTR;
+void ao_lshift64(ao_int64_t *ao_64r, ao_int64_t *ao_64a, uint8_t d) __FATTR;
 void ao_mul64_32_32(__ARG ao_int64_t *r, __ARG int32_t a, __ARG int32_t b) __FATTR;
 void ao_mul64_64_16(__ARG ao_int64_t *r, __ARG ao_int64_t *a, __ARG uint16_t b) __FATTR;
 void ao_mul64(__ARG ao_int64_t * __ARG r, __ARG ao_int64_t * __ARG a, __ARG ao_int64_t *__ARG b) __FATTR;
diff --git a/src/kernel/ao_kalman.c b/src/kernel/ao_kalman.c
index e4cc6d4b..4f4ffe8f 100644
--- a/src/kernel/ao_kalman.c
+++ b/src/kernel/ao_kalman.c
@@ -24,9 +24,9 @@
 #include "ao_sample.h"
 #include "ao_kalman.h"
 
-static __pdata ao_k_t		ao_k_height;
-static __pdata ao_k_t		ao_k_speed;
-static __pdata ao_k_t		ao_k_accel;
+static ao_k_t		ao_k_height;
+static ao_k_t		ao_k_speed;
+static ao_k_t		ao_k_accel;
 
 #define AO_K_STEP_100		to_fix_v(0.01)
 #define AO_K_STEP_2_2_100	to_fix_v(0.00005)
@@ -37,24 +37,24 @@ static __pdata ao_k_t		ao_k_accel;
 #define AO_K_STEP_1		to_fix_v(1)
 #define AO_K_STEP_2_2_1		to_fix_v(0.5)
 
-__pdata ao_v_t			ao_height;
-__pdata ao_v_t			ao_speed;
-__pdata ao_v_t			ao_accel;
-__xdata ao_v_t			ao_max_height;
-static __pdata ao_k_t		ao_avg_height_scaled;
-__xdata ao_v_t			ao_avg_height;
+ao_v_t			ao_height;
+ao_v_t			ao_speed;
+ao_v_t			ao_accel;
+ao_v_t			ao_max_height;
+static ao_k_t		ao_avg_height_scaled;
+ao_v_t			ao_avg_height;
 
-__pdata ao_v_t			ao_error_h;
+ao_v_t			ao_error_h;
 #if !HAS_ACCEL || AO_FLIGHT_TEST
 #define AO_ERROR_H_SQ_AVG	1
 #endif
 
 #if AO_ERROR_H_SQ_AVG
-__pdata ao_v_t			ao_error_h_sq_avg;
+ao_v_t			ao_error_h_sq_avg;
 #endif
 
 #if HAS_ACCEL
-__pdata ao_v_t			ao_error_a;
+ao_v_t			ao_error_a;
 #endif
 
 static void
diff --git a/src/kernel/ao_led.h b/src/kernel/ao_led.h
index 7de09237..803f85b3 100644
--- a/src/kernel/ao_led.h
+++ b/src/kernel/ao_led.h
@@ -51,7 +51,7 @@ ao_led_toggle(AO_LED_TYPE colors);
 
 /* Turn on the specified LEDs for the indicated interval */
 void
-ao_led_for(AO_LED_TYPE colors, uint16_t ticks) __reentrant;
+ao_led_for(AO_LED_TYPE colors, uint16_t ticks);
 
 /* Initialize the LEDs */
 void
diff --git a/src/kernel/ao_log.c b/src/kernel/ao_log.c
index 5fb086ce..1119cce4 100644
--- a/src/kernel/ao_log.c
+++ b/src/kernel/ao_log.c
@@ -23,13 +23,13 @@
 #include <ao_tracker.h>
 #endif
 
-__xdata uint8_t	ao_log_mutex;
-__pdata uint32_t ao_log_current_pos;
-__pdata uint32_t ao_log_end_pos;
-__pdata uint32_t ao_log_start_pos;
-__xdata uint8_t	ao_log_running;
-__pdata enum ao_flight_state ao_log_state;
-__xdata int16_t ao_flight_number;
+uint8_t	ao_log_mutex;
+uint32_t ao_log_current_pos;
+uint32_t ao_log_end_pos;
+uint32_t ao_log_start_pos;
+uint8_t	ao_log_running;
+enum ao_flight_state ao_log_state;
+int16_t ao_flight_number;
 
 void
 ao_log_flush(void)
@@ -47,7 +47,7 @@ struct ao_log_erase {
 	uint16_t flight;
 };
 
-static __xdata struct ao_log_erase erase;
+static struct ao_log_erase erase;
 
 #ifndef LOG_MAX_ERASE
 #define LOG_MAX_ERASE	16
@@ -117,10 +117,10 @@ ao_log_erase_mark(void)
  * structure.
  */
 
-__xdata ao_log_type ao_log_data;
+ao_log_type ao_log_data;
 
 static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
+ao_log_csum(uint8_t *b) 
 {
 	uint8_t	sum = 0x5a;
 	uint8_t	i;
@@ -131,12 +131,12 @@ ao_log_csum(__xdata uint8_t *b) __reentrant
 }
 
 uint8_t
-ao_log_write(__xdata ao_log_type *log) __reentrant
+ao_log_write(ao_log_type *log) 
 {
 	uint8_t wrote = 0;
 	/* set checksum */
 	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
+	log->csum = ao_log_csum((uint8_t *) log);
 	ao_mutex_get(&ao_log_mutex); {
 		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
 			ao_log_stop();
@@ -223,7 +223,7 @@ ao_log_max_flight(void)
 }
 
 static void
-ao_log_erase(uint8_t slot) __reentrant
+ao_log_erase(uint8_t slot) 
 {
 	uint32_t log_current_pos, log_end_pos;
 
@@ -232,7 +232,7 @@ ao_log_erase(uint8_t slot) __reentrant
 	log_end_pos = log_current_pos + ao_config.flight_log_max;
 	while (log_current_pos < log_end_pos) {
 		uint8_t	i;
-		static __xdata uint8_t b;
+		static uint8_t b;
 
 		/*
 		 * Check to see if we've reached the end of
@@ -252,7 +252,7 @@ ao_log_erase(uint8_t slot) __reentrant
 }
 
 static void
-ao_log_find_max_erase_flight(void) __reentrant
+ao_log_find_max_erase_flight(void) 
 {
 	uint8_t	log_slot;
 
@@ -273,7 +273,7 @@ ao_log_find_max_erase_flight(void) __reentrant
 }
 
 uint8_t
-ao_log_scan(void) __reentrant
+ao_log_scan(void) 
 {
 	uint8_t		log_slot;
 	uint8_t		log_slots;
@@ -402,11 +402,11 @@ ao_log_full(void)
 #endif
 
 #if LOG_ADC
-static __xdata struct ao_task ao_log_task;
+static struct ao_task ao_log_task;
 #endif
 
 void
-ao_log_list(void) __reentrant
+ao_log_list(void) 
 {
 	uint8_t	slot;
 	uint8_t slots;
@@ -426,7 +426,7 @@ ao_log_list(void) __reentrant
 }
 
 void
-ao_log_delete(void) __reentrant
+ao_log_delete(void) 
 {
 	uint8_t slot;
 	uint8_t slots;
@@ -462,7 +462,7 @@ ao_log_delete(void) __reentrant
 	printf("No such flight: %d\n", cmd_flight);
 }
 
-__code struct ao_cmds ao_log_cmds[] = {
+const struct ao_cmds ao_log_cmds[] = {
 	{ ao_log_list,	"l\0List logs" },
 	{ ao_log_delete,	"d <flight-number>\0Delete flight" },
 	{ 0,	NULL },
diff --git a/src/kernel/ao_log.h b/src/kernel/ao_log.h
index e2f1e0e4..a9715962 100644
--- a/src/kernel/ao_log.h
+++ b/src/kernel/ao_log.h
@@ -29,13 +29,13 @@
  * the log. Tasks may wait for this to be initialized
  * by sleeping on this variable.
  */
-extern __xdata int16_t ao_flight_number;
-extern __xdata uint8_t	ao_log_mutex;
-extern __pdata uint32_t ao_log_current_pos;
-extern __pdata uint32_t ao_log_end_pos;
-extern __pdata uint32_t ao_log_start_pos;
-extern __xdata uint8_t	ao_log_running;
-extern __pdata enum ao_flight_state ao_log_state;
+extern int16_t ao_flight_number;
+extern uint8_t	ao_log_mutex;
+extern uint32_t ao_log_current_pos;
+extern uint32_t ao_log_end_pos;
+extern uint32_t ao_log_start_pos;
+extern uint8_t	ao_log_running;
+extern enum ao_flight_state ao_log_state;
 
 /* required functions from the underlying log system */
 
@@ -90,7 +90,7 @@ ao_log(void);
 
 /* Figure out the current flight number */
 uint8_t
-ao_log_scan(void) __reentrant;
+ao_log_scan(void);
 
 /* Return the position of the start of the given log slot */
 uint32_t
@@ -507,14 +507,14 @@ typedef struct ao_log_record ao_log_type;
 #endif
 
 #ifndef AO_LOG_UNCOMMON
-extern __xdata ao_log_type ao_log_data;
+extern ao_log_type ao_log_data;
 
 #define AO_LOG_SIZE sizeof(ao_log_type)
 
 /* Write a record to the eeprom log */
 
 uint8_t
-ao_log_write(__xdata ao_log_type *log) __reentrant;
+ao_log_write(ao_log_type *log);
 #endif
 
 void
diff --git a/src/kernel/ao_log_big.c b/src/kernel/ao_log_big.c
index 7d7332e9..2a8cd63d 100644
--- a/src/kernel/ao_log_big.c
+++ b/src/kernel/ao_log_big.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-static __data uint8_t	ao_log_data_pos;
+static uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_records fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_record))] ;
@@ -32,7 +32,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_record))] ;
 void
 ao_log(void)
 {
-	__pdata uint16_t	next_sensor, next_other;
+	uint16_t	next_sensor, next_other;
 
 	ao_storage_setup();
 
diff --git a/src/kernel/ao_log_fireone.c b/src/kernel/ao_log_fireone.c
index 1a82673d..3dd52a16 100644
--- a/src/kernel/ao_log_fireone.c
+++ b/src/kernel/ao_log_fireone.c
@@ -21,12 +21,12 @@
 #include <ao_data.h>
 #include <ao_flight.h>
 
-static __xdata struct ao_log_firetwo log;
+static struct ao_log_firetwo log;
 
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEFIRETWO;
+const uint8_t ao_log_format = AO_LOG_FORMAT_TELEFIRETWO;
 
 static uint8_t
-ao_log_csum(__xdata uint8_t *b) __reentrant
+ao_log_csum(uint8_t *b) 
 {
 	uint8_t	sum = 0x5a;
 	uint8_t	i;
@@ -37,12 +37,12 @@ ao_log_csum(__xdata uint8_t *b) __reentrant
 }
 
 uint8_t
-ao_log_firetwo(__xdata struct ao_log_firetwo *log) __reentrant
+ao_log_firetwo(struct ao_log_firetwo *log) 
 {
 	uint8_t wrote = 0;
 	/* set checksum */
 	log->csum = 0;
-	log->csum = ao_log_csum((__xdata uint8_t *) log);
+	log->csum = ao_log_csum((uint8_t *) log);
 	ao_mutex_get(&ao_log_mutex); {
 		if (ao_log_current_pos >= ao_log_end_pos && ao_log_running)
 			ao_log_stop();
@@ -66,7 +66,7 @@ ao_log_dump_check_data(void)
 }
 
 #if HAS_ADC
-static __data uint8_t	ao_log_data_pos;
+static uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_metrums fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_firetwo))] ;
diff --git a/src/kernel/ao_log_mega.c b/src/kernel/ao_log_mega.c
index 0ae4e536..341ff715 100644
--- a/src/kernel/ao_log_mega.c
+++ b/src/kernel/ao_log_mega.c
@@ -22,7 +22,7 @@
 #include <ao_flight.h>
 
 #if HAS_FLIGHT
-static __data uint8_t	ao_log_data_pos;
+static uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_megas fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mega))] ;
@@ -36,7 +36,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mega))] ;
 void
 ao_log(void)
 {
-	__pdata uint16_t	next_sensor, next_other;
+	uint16_t	next_sensor, next_other;
 	uint8_t			i;
 
 	ao_storage_setup();
diff --git a/src/kernel/ao_log_metrum.c b/src/kernel/ao_log_metrum.c
index 34729070..18fb9ffb 100644
--- a/src/kernel/ao_log_metrum.c
+++ b/src/kernel/ao_log_metrum.c
@@ -22,7 +22,7 @@
 #include <ao_flight.h>
 
 #if HAS_ADC
-static __data uint8_t	ao_log_data_pos;
+static uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_metrums fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_metrum))] ;
@@ -36,7 +36,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_metrum))] ;
 void
 ao_log(void)
 {
-	__pdata uint16_t	next_sensor, next_other;
+	uint16_t	next_sensor, next_other;
 
 	ao_storage_setup();
 
diff --git a/src/kernel/ao_log_mini.c b/src/kernel/ao_log_mini.c
index 12c5d6bb..03bf2265 100644
--- a/src/kernel/ao_log_mini.c
+++ b/src/kernel/ao_log_mini.c
@@ -21,7 +21,7 @@
 #include <ao_data.h>
 #include <ao_flight.h>
 
-static __data uint8_t	ao_log_data_pos;
+static uint8_t	ao_log_data_pos;
 
 /* a hack to make sure that ao_log_minis fill the eeprom block in even units */
 typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mini))] ;
@@ -34,7 +34,7 @@ typedef uint8_t check_log_size[1-(256 % sizeof(struct ao_log_mini))] ;
 void
 ao_log(void)
 {
-	__pdata uint16_t	next_sensor;
+	uint16_t	next_sensor;
 
 	ao_storage_setup();
 
diff --git a/src/kernel/ao_log_single.c b/src/kernel/ao_log_single.c
index 63768e1a..da627387 100644
--- a/src/kernel/ao_log_single.c
+++ b/src/kernel/ao_log_single.c
@@ -26,16 +26,16 @@
 #include "ao.h"
 #include "ao_product.h"
 
-static __xdata struct ao_task ao_log_single_task;
+static struct ao_task ao_log_single_task;
 
-__xdata uint8_t 	ao_log_running;
-__xdata uint8_t		ao_log_mutex;
-__pdata uint32_t	ao_log_start_pos;
-__pdata uint32_t	ao_log_end_pos;
-__pdata uint32_t	ao_log_current_pos;
+uint8_t 	ao_log_running;
+uint8_t		ao_log_mutex;
+uint32_t	ao_log_start_pos;
+uint32_t	ao_log_end_pos;
+uint32_t	ao_log_current_pos;
 
-__xdata union ao_log_single ao_log_single_write_data;
-__xdata union ao_log_single ao_log_single_read_data;
+union ao_log_single ao_log_single_write_data;
+union ao_log_single ao_log_single_read_data;
 
 uint8_t
 ao_log_single_write(void)
@@ -59,7 +59,7 @@ ao_log_single_write(void)
 static uint8_t
 ao_log_single_valid(void)
 {
-	__xdata uint8_t	*d = ao_log_single_read_data.bytes;
+	uint8_t	*d = ao_log_single_read_data.bytes;
 	uint8_t	i;
 	for (i = 0; i < AO_LOG_SINGLE_SIZE; i++)
 		if (*d++ != 0xff)
diff --git a/src/kernel/ao_log_telem.c b/src/kernel/ao_log_telem.c
index 8969e029..8c0b88e4 100644
--- a/src/kernel/ao_log_telem.c
+++ b/src/kernel/ao_log_telem.c
@@ -20,13 +20,13 @@
 #include <ao_flight.h>
 #include <ao_sample.h>
 
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELEMETRY;
+const uint8_t ao_log_format = AO_LOG_FORMAT_TELEMETRY;
 
-static __data uint8_t			ao_log_monitor_pos;
-__pdata enum ao_flight_state		ao_flight_state;
-__xdata int16_t				ao_max_height;	/* max of ao_height */
-__pdata int16_t				sense_d, sense_m;
-__pdata uint8_t				ao_igniter_present;
+static uint8_t			ao_log_monitor_pos;
+enum ao_flight_state		ao_flight_state;
+int16_t				ao_max_height;	/* max of ao_height */
+int16_t				sense_d, sense_m;
+uint8_t				ao_igniter_present;
 
 static void
 ao_log_telem_track() {
diff --git a/src/kernel/ao_log_telescience.c b/src/kernel/ao_log_telescience.c
index 3f514f18..a21af71d 100644
--- a/src/kernel/ao_log_telescience.c
+++ b/src/kernel/ao_log_telescience.c
@@ -23,12 +23,12 @@
 
 static uint8_t	ao_log_data_pos;
 
-__code uint8_t ao_log_format = AO_LOG_FORMAT_TELESCIENCE;
+const uint8_t ao_log_format = AO_LOG_FORMAT_TELESCIENCE;
 
 static void
-ao_log_telescience_csum(void) __reentrant
+ao_log_telescience_csum(void) 
 {
-	__xdata uint8_t *b = ao_log_single_write_data.bytes;
+	uint8_t *b = ao_log_single_write_data.bytes;
 	uint8_t	sum = 0x5a;
 	uint8_t	i;
 
diff --git a/src/kernel/ao_log_tiny.c b/src/kernel/ao_log_tiny.c
index 046b7b20..53003111 100644
--- a/src/kernel/ao_log_tiny.c
+++ b/src/kernel/ao_log_tiny.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-static __data uint16_t	ao_log_tiny_interval;
+static uint16_t	ao_log_tiny_interval;
 
 #define AO_LOG_TINY_INTERVAL_DEFAULT	AO_MS_TO_TICKS(1000)
 #if USE_FAST_ASCENT_LOG
@@ -46,8 +46,8 @@ static void ao_log_tiny_data(uint16_t d)
 	}
 }
 
-static __xdata uint16_t ao_log_pad_ring[AO_PAD_RING];
-static __pdata uint8_t ao_log_pad_ring_pos;
+static uint16_t ao_log_pad_ring[AO_PAD_RING];
+static uint8_t ao_log_pad_ring_pos;
 
 #define ao_pad_ring_next(n)	(((n) + 1) & (AO_PAD_RING - 1))
 
@@ -150,7 +150,7 @@ ao_log(void)
 int16_t
 ao_log_flight(uint8_t slot)
 {
-	static __xdata uint16_t flight;
+	static uint16_t flight;
 
 	(void) slot;
 	ao_storage_read(0, &flight, 2);
diff --git a/src/kernel/ao_monitor.c b/src/kernel/ao_monitor.c
index b9a39bfc..b6b8d888 100644
--- a/src/kernel/ao_monitor.c
+++ b/src/kernel/ao_monitor.c
@@ -36,15 +36,15 @@
 #error Must define AO_MONITOR_LED
 #endif
 
-__xdata uint8_t ao_monitoring_mutex;
-__data uint8_t ao_monitoring;
-static __data uint8_t ao_monitor_disabled;
-static __data uint8_t ao_internal_monitoring;
-static __data uint8_t ao_external_monitoring;
+uint8_t ao_monitoring_mutex;
+uint8_t ao_monitoring;
+static uint8_t ao_monitor_disabled;
+static uint8_t ao_internal_monitoring;
+static uint8_t ao_external_monitoring;
 
-__xdata union ao_monitor ao_monitor_ring[AO_MONITOR_RING];
+union ao_monitor ao_monitor_ring[AO_MONITOR_RING];
 
-__data uint8_t	ao_monitor_head;
+uint8_t	ao_monitor_head;
 
 static void
 _ao_monitor_adjust(void)
@@ -91,7 +91,7 @@ ao_monitor_get(void)
 }
 
 #if AO_MONITOR_LED
-__xdata struct ao_task ao_monitor_blink_task;
+struct ao_task ao_monitor_blink_task;
 
 void
 ao_monitor_blink(void)
@@ -125,7 +125,7 @@ void
 ao_monitor_put(void)
 {
 #if LEGACY_MONITOR
-	__xdata char callsign[AO_MAX_CALLSIGN+1];
+	char callsign[AO_MAX_CALLSIGN+1];
 #endif
 #if LEGACY_MONITOR || HAS_RSSI
 	int16_t rssi;
@@ -133,7 +133,7 @@ ao_monitor_put(void)
 	uint8_t ao_monitor_tail;
 	uint8_t state;
 	uint8_t sum, byte;
-	__xdata union ao_monitor	*m;
+	union ao_monitor	*m;
 
 #define recv_raw	((m->raw))
 #define recv_orig	((m->orig))
@@ -266,10 +266,10 @@ ao_monitor_put(void)
 	}
 }
 
-__xdata struct ao_task ao_monitor_put_task;
+struct ao_task ao_monitor_put_task;
 #endif
 
-__xdata struct ao_task ao_monitor_get_task;
+struct ao_task ao_monitor_get_task;
 
 void
 ao_monitor_set(uint8_t monitoring)
@@ -303,14 +303,14 @@ set_monitor(void)
 	_ao_monitor_adjust();
 }
 
-__code struct ao_cmds ao_monitor_cmds[] = {
+const struct ao_cmds ao_monitor_cmds[] = {
 	{ set_monitor,	"m <0 off, 1 old, 20 std>\0Set radio monitoring" },
 	{ 0,	NULL },
 };
 #endif
 
 void
-ao_monitor_init(void) __reentrant
+ao_monitor_init(void) 
 {
 #if HAS_MONITOR_PUT
 	ao_cmd_register(&ao_monitor_cmds[0]);
diff --git a/src/kernel/ao_mutex.c b/src/kernel/ao_mutex.c
index ff73e3bc..4ef1a9ba 100644
--- a/src/kernel/ao_mutex.c
+++ b/src/kernel/ao_mutex.c
@@ -25,7 +25,7 @@
 #if HAS_MUTEX_TRY
 
 uint8_t
-ao_mutex_try(__xdata uint8_t *mutex, uint8_t task_id) __reentrant
+ao_mutex_try(uint8_t *mutex, uint8_t task_id) 
 {
 	uint8_t	ret;
 	if (*mutex == task_id)
@@ -42,7 +42,7 @@ ao_mutex_try(__xdata uint8_t *mutex, uint8_t task_id) __reentrant
 #endif
 
 void
-ao_mutex_get(__xdata uint8_t *mutex) __reentrant
+ao_mutex_get(uint8_t *mutex) 
 {
 	if (*mutex == ao_cur_task->task_id)
 		ao_panic(AO_PANIC_MUTEX);
@@ -54,7 +54,7 @@ ao_mutex_get(__xdata uint8_t *mutex) __reentrant
 }
 
 void
-ao_mutex_put(__xdata uint8_t *mutex) __reentrant
+ao_mutex_put(uint8_t *mutex) 
 {
 	if (*mutex != ao_cur_task->task_id)
 		ao_panic(AO_PANIC_MUTEX);
diff --git a/src/kernel/ao_notask.c b/src/kernel/ao_notask.c
index 7207353a..a5bdc8a7 100644
--- a/src/kernel/ao_notask.c
+++ b/src/kernel/ao_notask.c
@@ -21,7 +21,7 @@
 static volatile void *ao_wchan;
 
 uint8_t
-ao_sleep(__xdata void *wchan)
+ao_sleep(void *wchan)
 {
 #if 1
 	ao_wchan = wchan;
@@ -55,7 +55,7 @@ ao_delay(uint16_t ticks)
 #endif
 
 void
-ao_wakeup(__xdata void *wchan)
+ao_wakeup(void *wchan)
 {
 	(void) wchan;
 	ao_wchan = 0;
diff --git a/src/kernel/ao_notask.h b/src/kernel/ao_notask.h
index a4446726..ce622b63 100644
--- a/src/kernel/ao_notask.h
+++ b/src/kernel/ao_notask.h
@@ -20,9 +20,9 @@
 #define _AO_NOTASK_H_
 
 uint8_t
-ao_sleep(__xdata void *wchan);
+ao_sleep(void *wchan);
 
 void
-ao_wakeup(__xdata void *wchan);
+ao_wakeup(void *wchan);
 
 #endif /* _AO_NOTASK_H_ */
diff --git a/src/kernel/ao_packet.h b/src/kernel/ao_packet.h
index 9d99b0e6..24cd7b13 100644
--- a/src/kernel/ao_packet.h
+++ b/src/kernel/ao_packet.h
@@ -43,13 +43,13 @@ struct ao_packet_recv {
 	uint8_t			status;
 };
 
-extern __xdata struct ao_packet_recv ao_rx_packet;
-extern __xdata struct ao_packet ao_tx_packet;
-extern __xdata struct ao_task	ao_packet_task;
-extern __xdata uint8_t ao_packet_enable;
-extern __xdata uint8_t ao_packet_master_sleeping;
-extern __pdata uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
-extern __xdata uint8_t ao_packet_restart;
+extern struct ao_packet_recv ao_rx_packet;
+extern struct ao_packet ao_tx_packet;
+extern struct ao_task	ao_packet_task;
+extern uint8_t ao_packet_enable;
+extern uint8_t ao_packet_master_sleeping;
+extern uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
+extern uint8_t ao_packet_restart;
 
 void
 ao_packet_send(void);
@@ -61,7 +61,7 @@ void
 ao_packet_flush(void);
 
 void
-ao_packet_putchar(char c) __reentrant;
+ao_packet_putchar(char c);
 
 int
 _ao_packet_pollchar(void);
@@ -69,7 +69,7 @@ _ao_packet_pollchar(void);
 #if PACKET_HAS_MASTER
 /* ao_packet_master.c */
 
-extern __xdata int8_t ao_packet_last_rssi;
+extern int8_t ao_packet_last_rssi;
 
 void
 ao_packet_master_init(void);
diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c
index 527112ac..e24ab46b 100644
--- a/src/kernel/ao_pyro.c
+++ b/src/kernel/ao_pyro.c
@@ -38,8 +38,8 @@
 enum ao_igniter_status
 ao_pyro_status(uint8_t p)
 {
-	__xdata struct ao_data packet;
-	__pdata int16_t value;
+	struct ao_data packet;
+	int16_t value;
 
 	ao_arch_critical(
 		ao_data_get(&packet);
@@ -404,7 +404,7 @@ ao_pyro(void)
 	ao_exit();
 }
 
-__xdata struct ao_task ao_pyro_task;
+struct ao_task ao_pyro_task;
 
 
 static void
diff --git a/src/kernel/ao_radio_cmac.c b/src/kernel/ao_radio_cmac.c
index 92b365a2..155fce35 100644
--- a/src/kernel/ao_radio_cmac.c
+++ b/src/kernel/ao_radio_cmac.c
@@ -19,9 +19,9 @@
 #include <ao.h>
 #include <ao_radio_cmac.h>
 
-static __xdata uint8_t ao_radio_cmac_mutex;
-__pdata int8_t ao_radio_cmac_rssi;
-static __xdata uint8_t cmac_data[AO_CMAC_MAX_LEN + AO_CMAC_KEY_LEN + 2 + AO_CMAC_KEY_LEN];
+static uint8_t ao_radio_cmac_mutex;
+int8_t ao_radio_cmac_rssi;
+static uint8_t cmac_data[AO_CMAC_MAX_LEN + AO_CMAC_KEY_LEN + 2 + AO_CMAC_KEY_LEN];
 
 static uint8_t
 round_len(uint8_t len)
@@ -45,7 +45,7 @@ round_len(uint8_t len)
  * Sign and deliver the data sitting in the cmac buffer
  */
 static void
-radio_cmac_send(uint8_t len) __reentrant
+radio_cmac_send(uint8_t len) 
 {
 	uint8_t	i;
 
@@ -77,7 +77,7 @@ radio_cmac_send(uint8_t len) __reentrant
  */
 
 static int8_t
-radio_cmac_recv(uint8_t len, uint16_t timeout) __reentrant
+radio_cmac_recv(uint8_t len, uint16_t timeout) 
 {
 	uint8_t	i;
 
@@ -127,7 +127,7 @@ radio_cmac_recv(uint8_t len, uint16_t timeout) __reentrant
 }
 
 int8_t
-ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
+ao_radio_cmac_send(void *packet, uint8_t len) 
 {
 	if (len > AO_CMAC_MAX_LEN)
 		return AO_RADIO_CMAC_LEN_ERROR;
@@ -145,7 +145,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
 }
 
 int8_t
-ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant
+ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout) 
 {
 	int8_t	i;
 	if (len > AO_CMAC_MAX_LEN)
diff --git a/src/kernel/ao_radio_cmac.h b/src/kernel/ao_radio_cmac.h
index 74fe8c60..5fd6e105 100644
--- a/src/kernel/ao_radio_cmac.h
+++ b/src/kernel/ao_radio_cmac.h
@@ -24,10 +24,10 @@
 #define AO_CMAC_KEY_LEN		AO_AES_LEN
 #define AO_CMAC_MAX_LEN		(128 - AO_CMAC_KEY_LEN)
 
-extern __pdata int8_t ao_radio_cmac_rssi;
+extern int8_t ao_radio_cmac_rssi;
 
 int8_t
-ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant;
+ao_radio_cmac_send(void *packet, uint8_t len);
 
 #define AO_RADIO_CMAC_OK	0
 #define AO_RADIO_CMAC_LEN_ERROR	-1
@@ -36,7 +36,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant;
 #define AO_RADIO_CMAC_TIMEOUT	-4
 
 int8_t
-ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant;
+ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout);
 
 void
 ao_radio_cmac_init(void);
diff --git a/src/kernel/ao_radio_cmac_cmd.c b/src/kernel/ao_radio_cmac_cmd.c
index 6d29f392..e5b4ffdf 100644
--- a/src/kernel/ao_radio_cmac_cmd.c
+++ b/src/kernel/ao_radio_cmac_cmd.c
@@ -20,7 +20,7 @@
 #include <ao_radio_cmac_cmd.h>
 #include <ao_radio_cmac.h>
 
-static __xdata uint8_t cmac_data[AO_CMAC_MAX_LEN];
+static uint8_t cmac_data[AO_CMAC_MAX_LEN];
 
 static uint8_t
 getnibble(void)
@@ -45,7 +45,7 @@ getbyte(void)
 }
 	
 static void
-radio_cmac_send_cmd(void) __reentrant
+radio_cmac_send_cmd(void) 
 {
 	uint8_t	i;
 	uint8_t	len;
@@ -69,7 +69,7 @@ radio_cmac_send_cmd(void) __reentrant
 }
 
 static void
-radio_cmac_recv_cmd(void) __reentrant
+radio_cmac_recv_cmd(void) 
 {
 	uint8_t		len, i;
 	uint16_t	timeout;
@@ -92,7 +92,7 @@ radio_cmac_recv_cmd(void) __reentrant
 		printf ("ERROR %d %d\n", i, ao_radio_cmac_rssi);
 }
 
-static __code struct ao_cmds ao_radio_cmac_cmds[] = {
+static const struct ao_cmds ao_radio_cmac_cmds[] = {
 	{ radio_cmac_send_cmd,	"s <length>\0Send AES-CMAC packet. Bytes to send follow on next line" },
 	{ radio_cmac_recv_cmd,	"S <length> <timeout>\0Receive AES-CMAC packet. Timeout in ms" },
 	{ 0, NULL },
diff --git a/src/kernel/ao_report.c b/src/kernel/ao_report.c
index 73f87cdd..08967af8 100644
--- a/src/kernel/ao_report.c
+++ b/src/kernel/ao_report.c
@@ -58,7 +58,7 @@ static const uint8_t flight_reports[] = {
 #endif
 #define pause(time)	ao_delay(time)
 
-static __pdata enum ao_flight_state ao_report_state;
+static enum ao_flight_state ao_report_state;
 
 /*
  * Farnsworth spacing
@@ -115,7 +115,7 @@ static __pdata enum ao_flight_state ao_report_state;
  */
 
 static void
-ao_report_beep(void) __reentrant
+ao_report_beep(void) 
 {
 	uint8_t r = flight_reports[ao_flight_state];
 	uint8_t l = r & 7;
@@ -134,7 +134,7 @@ ao_report_beep(void) __reentrant
 }
 
 static void
-ao_report_digit(uint8_t digit) __reentrant
+ao_report_digit(uint8_t digit) 
 {
 	if (!digit) {
 		mid(AO_MS_TO_TICKS(500));
@@ -151,8 +151,8 @@ ao_report_digit(uint8_t digit) __reentrant
 static void
 ao_report_number(int16_t n)
 {
-	__xdata uint8_t	digits[10];
-	__pdata uint8_t ndigits, i;
+	uint8_t	digits[10];
+	uint8_t ndigits, i;
 
 	if (n < 0)
 		n = 0;
@@ -178,7 +178,7 @@ ao_report_altitude(void)
 static void
 ao_report_battery(void)
 {
-	__xdata struct ao_data packet;
+	struct ao_data packet;
 	for (;;) {
 		ao_data_get(&packet);
 		if (packet.adc.v_batt != 0)
@@ -204,7 +204,7 @@ ao_report_igniter(void)
 }
 
 static void
-ao_report_continuity(void) __reentrant
+ao_report_continuity(void) 
 {
 	uint8_t	c;
 
@@ -285,7 +285,7 @@ ao_report(void)
 	}
 }
 
-static __xdata struct ao_task ao_report_task;
+static struct ao_task ao_report_task;
 
 void
 ao_report_init(void)
diff --git a/src/kernel/ao_report_micro.c b/src/kernel/ao_report_micro.c
index 9c7afdc5..efada54b 100644
--- a/src/kernel/ao_report_micro.c
+++ b/src/kernel/ao_report_micro.c
@@ -23,7 +23,7 @@
 #define pause(time)	ao_delay(time)
 
 static void
-ao_report_digit(uint8_t digit) __reentrant
+ao_report_digit(uint8_t digit) 
 {
 	if (!digit) {
 		mid(AO_MS_TO_TICKS(1000));
@@ -40,9 +40,9 @@ ao_report_digit(uint8_t digit) __reentrant
 void
 ao_report_altitude(void)
 {
-	__pdata alt_t	agl = ao_max_height;
-	static __xdata uint8_t	digits[11];
-	__pdata uint8_t ndigits, i;
+	alt_t	agl = ao_max_height;
+	static uint8_t	digits[11];
+	uint8_t ndigits, i;
 
 	if (agl < 0)
 		agl = 0;
diff --git a/src/kernel/ao_rssi.c b/src/kernel/ao_rssi.c
index 66fb8b57..aacc38b2 100644
--- a/src/kernel/ao_rssi.c
+++ b/src/kernel/ao_rssi.c
@@ -18,9 +18,9 @@
 
 #include "ao.h"
 
-static __xdata uint16_t		ao_rssi_time;
-static __pdata uint16_t		ao_rssi_delay;
-static __pdata AO_LED_TYPE	ao_rssi_led;
+static uint16_t		ao_rssi_time;
+static uint16_t		ao_rssi_delay;
+static AO_LED_TYPE	ao_rssi_led;
 
 void
 ao_rssi(void)
@@ -43,7 +43,7 @@ ao_rssi_set(int16_t rssi_value)
 	ao_wakeup(&ao_rssi_time);
 }
 
-__xdata struct ao_task ao_rssi_task;
+struct ao_task ao_rssi_task;
 
 void
 ao_rssi_init(AO_LED_TYPE rssi_led)
diff --git a/src/kernel/ao_sample.c b/src/kernel/ao_sample.c
index 9f5082bb..115eae80 100644
--- a/src/kernel/ao_sample.c
+++ b/src/kernel/ao_sample.c
@@ -35,63 +35,63 @@
 #define ACCEL_TYPE int16_t
 #endif
 
-__pdata uint16_t	ao_sample_tick;		/* time of last data */
-__pdata pres_t		ao_sample_pres;
-__pdata alt_t		ao_sample_alt;
-__pdata alt_t		ao_sample_height;
+uint16_t	ao_sample_tick;		/* time of last data */
+pres_t		ao_sample_pres;
+alt_t		ao_sample_alt;
+alt_t		ao_sample_height;
 #if HAS_ACCEL
-__pdata accel_t		ao_sample_accel;
+accel_t		ao_sample_accel;
 #endif
 #if HAS_GYRO
-__pdata accel_t		ao_sample_accel_along;
-__pdata accel_t		ao_sample_accel_across;
-__pdata accel_t		ao_sample_accel_through;
-__pdata gyro_t		ao_sample_roll;
-__pdata gyro_t		ao_sample_pitch;
-__pdata gyro_t		ao_sample_yaw;
-__pdata angle_t		ao_sample_orient;
-__pdata angle_t		ao_sample_orients[AO_NUM_ORIENT];
-__pdata uint8_t		ao_sample_orient_pos;
+accel_t		ao_sample_accel_along;
+accel_t		ao_sample_accel_across;
+accel_t		ao_sample_accel_through;
+gyro_t		ao_sample_roll;
+gyro_t		ao_sample_pitch;
+gyro_t		ao_sample_yaw;
+angle_t		ao_sample_orient;
+angle_t		ao_sample_orients[AO_NUM_ORIENT];
+uint8_t		ao_sample_orient_pos;
 #endif
 
-__data uint8_t		ao_sample_data;
+uint8_t		ao_sample_data;
 
 /*
  * Sensor calibration values
  */
 
-__pdata pres_t		ao_ground_pres;		/* startup pressure */
-__pdata alt_t		ao_ground_height;	/* MSL of ao_ground_pres */
+pres_t		ao_ground_pres;		/* startup pressure */
+alt_t		ao_ground_height;	/* MSL of ao_ground_pres */
 
 #if HAS_ACCEL
-__pdata accel_t		ao_ground_accel;	/* startup acceleration */
-__pdata accel_t		ao_accel_2g;		/* factory accel calibration */
-__pdata int32_t		ao_accel_scale;		/* sensor to m/s² conversion */
+accel_t		ao_ground_accel;	/* startup acceleration */
+accel_t		ao_accel_2g;		/* factory accel calibration */
+int32_t		ao_accel_scale;		/* sensor to m/s² conversion */
 #endif
 
 #if HAS_GYRO
-__pdata accel_t		ao_ground_accel_along;
-__pdata accel_t		ao_ground_accel_across;
-__pdata accel_t		ao_ground_accel_through;
-__pdata int32_t		ao_ground_pitch;
-__pdata int32_t		ao_ground_yaw;
-__pdata int32_t		ao_ground_roll;
+accel_t		ao_ground_accel_along;
+accel_t		ao_ground_accel_across;
+accel_t		ao_ground_accel_through;
+int32_t		ao_ground_pitch;
+int32_t		ao_ground_yaw;
+int32_t		ao_ground_roll;
 #endif
 
-static __pdata uint8_t	ao_preflight;		/* in preflight mode */
+static uint8_t	ao_preflight;		/* in preflight mode */
 
-static __pdata uint16_t	nsamples;
-__pdata int32_t ao_sample_pres_sum;
+static uint16_t	nsamples;
+int32_t ao_sample_pres_sum;
 #if HAS_ACCEL
-__pdata int32_t ao_sample_accel_sum;
+int32_t ao_sample_accel_sum;
 #endif
 #if HAS_GYRO
-__pdata int32_t ao_sample_accel_along_sum;
-__pdata int32_t ao_sample_accel_across_sum;
-__pdata int32_t	ao_sample_accel_through_sum;
-__pdata int32_t ao_sample_pitch_sum;
-__pdata int32_t ao_sample_yaw_sum;
-__pdata int32_t	ao_sample_roll_sum;
+int32_t ao_sample_accel_along_sum;
+int32_t ao_sample_accel_across_sum;
+int32_t	ao_sample_accel_through_sum;
+int32_t ao_sample_pitch_sum;
+int32_t ao_sample_yaw_sum;
+int32_t	ao_sample_roll_sum;
 static struct ao_quaternion ao_rotation;
 #endif
 
@@ -324,7 +324,7 @@ ao_sample(void)
 	ao_wakeup(&ao_sample_data);
 	ao_sleep((void *) &ao_data_head);
 	while (ao_sample_data != ao_data_head) {
-		__xdata struct ao_data *ao_data;
+		struct ao_data *ao_data;
 
 		/* Capture a sample */
 		ao_data = (struct ao_data *) &ao_data_ring[ao_sample_data];
diff --git a/src/kernel/ao_sample.h b/src/kernel/ao_sample.h
index 5ae389be..af6eca4e 100644
--- a/src/kernel/ao_sample.h
+++ b/src/kernel/ao_sample.h
@@ -115,41 +115,41 @@ typedef int16_t			ao_v_t;
 #define AO_MS_TO_SPEED(ms)	((ao_v_t) ((ms) * 16))
 #define AO_MSS_TO_ACCEL(mss)	((ao_v_t) ((mss) * 16))
 
-extern __pdata uint16_t	ao_sample_tick;		/* time of last data */
-extern __data uint8_t	ao_sample_adc;		/* Ring position of last processed sample */
-extern __data uint8_t	ao_sample_data;		/* Ring position of last processed sample */
+extern uint16_t	ao_sample_tick;		/* time of last data */
+extern uint8_t	ao_sample_adc;		/* Ring position of last processed sample */
+extern uint8_t	ao_sample_data;		/* Ring position of last processed sample */
 
 #if HAS_BARO
-extern __pdata pres_t	ao_sample_pres;		/* most recent pressure sensor reading */
-extern __pdata alt_t	ao_sample_alt;		/* MSL of ao_sample_pres */
-extern __pdata alt_t	ao_sample_height;	/* AGL of ao_sample_pres */
-extern __pdata pres_t	ao_ground_pres;		/* startup pressure */
-extern __pdata alt_t	ao_ground_height;	/* MSL of ao_ground_pres */
+extern pres_t	ao_sample_pres;		/* most recent pressure sensor reading */
+extern alt_t	ao_sample_alt;		/* MSL of ao_sample_pres */
+extern alt_t	ao_sample_height;	/* AGL of ao_sample_pres */
+extern pres_t	ao_ground_pres;		/* startup pressure */
+extern alt_t	ao_ground_height;	/* MSL of ao_ground_pres */
 #endif
 
 #if HAS_ACCEL
-extern __pdata accel_t	ao_sample_accel;	/* most recent accel sensor reading */
-extern __pdata accel_t	ao_ground_accel;	/* startup acceleration */
-extern __pdata accel_t 	ao_accel_2g;		/* factory accel calibration */
-extern __pdata int32_t	ao_accel_scale;		/* sensor to m/s² conversion */
+extern accel_t	ao_sample_accel;	/* most recent accel sensor reading */
+extern accel_t	ao_ground_accel;	/* startup acceleration */
+extern accel_t 	ao_accel_2g;		/* factory accel calibration */
+extern int32_t	ao_accel_scale;		/* sensor to m/s² conversion */
 #endif
 #if HAS_GYRO
-extern __pdata accel_t	ao_ground_accel_along;
-extern __pdata accel_t	ao_ground_accel_across;
-extern __pdata accel_t	ao_ground_accel_through;
-extern __pdata int32_t	ao_ground_pitch;	/* * 512 */
-extern __pdata int32_t	ao_ground_yaw;		/* * 512 */
-extern __pdata int32_t	ao_ground_roll;		/* * 512 */
-extern __pdata accel_t	ao_sample_accel_along;
-extern __pdata accel_t	ao_sample_accel_across;
-extern __pdata accel_t	ao_sample_accel_through;
-extern __pdata gyro_t	ao_sample_roll;
-extern __pdata gyro_t	ao_sample_pitch;
-extern __pdata gyro_t	ao_sample_yaw;
+extern accel_t	ao_ground_accel_along;
+extern accel_t	ao_ground_accel_across;
+extern accel_t	ao_ground_accel_through;
+extern int32_t	ao_ground_pitch;	/* * 512 */
+extern int32_t	ao_ground_yaw;		/* * 512 */
+extern int32_t	ao_ground_roll;		/* * 512 */
+extern accel_t	ao_sample_accel_along;
+extern accel_t	ao_sample_accel_across;
+extern accel_t	ao_sample_accel_through;
+extern gyro_t	ao_sample_roll;
+extern gyro_t	ao_sample_pitch;
+extern gyro_t	ao_sample_yaw;
 #define AO_NUM_ORIENT	64
-extern __pdata angle_t	ao_sample_orient;
-extern __pdata angle_t	ao_sample_orients[AO_NUM_ORIENT];
-extern __pdata uint8_t	ao_sample_orient_pos;
+extern angle_t	ao_sample_orient;
+extern angle_t	ao_sample_orients[AO_NUM_ORIENT];
+extern uint8_t	ao_sample_orient_pos;
 #endif
 
 void ao_sample_init(void);
@@ -176,19 +176,19 @@ uint8_t ao_sample(void);
 
 #define from_fix(x)	((x) >> 16)
 
-extern __pdata ao_v_t			ao_height;	/* meters */
-extern __pdata ao_v_t			ao_speed;	/* m/s * 16 */
-extern __pdata ao_v_t			ao_accel;	/* m/s² * 16 */
-extern __xdata ao_v_t			ao_max_height;	/* max of ao_height */
-extern __xdata ao_v_t			ao_avg_height;	/* running average of height */
+extern ao_v_t			ao_height;	/* meters */
+extern ao_v_t			ao_speed;	/* m/s * 16 */
+extern ao_v_t			ao_accel;	/* m/s² * 16 */
+extern ao_v_t			ao_max_height;	/* max of ao_height */
+extern ao_v_t			ao_avg_height;	/* running average of height */
 
-extern __pdata ao_v_t			ao_error_h;
+extern ao_v_t			ao_error_h;
 #if !HAS_ACCEL
-extern __pdata ao_v_t			ao_error_h_sq_avg;
+extern ao_v_t			ao_error_h_sq_avg;
 #endif
 
 #if HAS_ACCEL
-extern __pdata ao_v_t			ao_error_a;
+extern ao_v_t			ao_error_a;
 #endif
 #endif
 
diff --git a/src/kernel/ao_sample_profile.c b/src/kernel/ao_sample_profile.c
index 4819a161..b9d0e07f 100644
--- a/src/kernel/ao_sample_profile.c
+++ b/src/kernel/ao_sample_profile.c
@@ -160,7 +160,7 @@ ao_sample_profile_cmd(void)
 	}
 }
 
-static __code struct ao_cmds ao_sample_profile_cmds[] = {
+static const struct ao_cmds ao_sample_profile_cmds[] = {
 	{ ao_sample_profile_cmd,	"S <1 start,0 stop, d dump,c clear>\0Sample profile" },
 	{ 0, NULL }
 };
diff --git a/src/kernel/ao_send_packet.c b/src/kernel/ao_send_packet.c
index c8a1d46e..3206b2d6 100644
--- a/src/kernel/ao_send_packet.c
+++ b/src/kernel/ao_send_packet.c
@@ -20,14 +20,14 @@
 
 #define AO_MAX_SEND	128
 
-static __xdata uint8_t ao_send[AO_MAX_SEND];
+static uint8_t ao_send[AO_MAX_SEND];
 
 static void
 ao_send_packet(void)
 {
-	__pdata uint16_t count;
+	uint16_t count;
 	uint8_t b;
-	__pdata uint8_t	i;
+	uint8_t	i;
 
 	ao_cmd_hex();
 	count = ao_cmd_lex_i;
@@ -47,7 +47,7 @@ ao_send_packet(void)
 	ao_radio_send(ao_send, count);
 }
 
-static __code struct ao_cmds ao_send_packet_cmds[] = {
+static const struct ao_cmds ao_send_packet_cmds[] = {
 	{ ao_send_packet, "S <len>\0Send packet. Data on next line" },
 	{ 0, NULL }
 };
diff --git a/src/kernel/ao_serial.h b/src/kernel/ao_serial.h
index ef3e93d7..440b562b 100644
--- a/src/kernel/ao_serial.h
+++ b/src/kernel/ao_serial.h
@@ -26,8 +26,8 @@
 #define AO_SERIAL_SPEED_115200	4
 
 #if HAS_SERIAL_0
-extern volatile __xdata struct ao_fifo	ao_serial0_rx_fifo;
-extern volatile __xdata struct ao_fifo	ao_serial0_tx_fifo;
+extern volatile struct ao_fifo	ao_serial0_rx_fifo;
+extern volatile struct ao_fifo	ao_serial0_tx_fifo;
 
 char
 ao_serial0_getchar(void);
@@ -49,8 +49,8 @@ ao_serial0_set_speed(uint8_t speed);
 #endif
 
 #if HAS_SERIAL_1
-extern volatile __xdata struct ao_fifo	ao_serial1_rx_fifo;
-extern volatile __xdata struct ao_fifo	ao_serial1_tx_fifo;
+extern volatile struct ao_fifo	ao_serial1_rx_fifo;
+extern volatile struct ao_fifo	ao_serial1_tx_fifo;
 
 char
 ao_serial1_getchar(void);
@@ -72,8 +72,8 @@ ao_serial1_set_speed(uint8_t speed);
 #endif
 
 #if HAS_SERIAL_2
-extern volatile __xdata struct ao_fifo	ao_serial2_rx_fifo;
-extern volatile __xdata struct ao_fifo	ao_serial2_tx_fifo;
+extern volatile struct ao_fifo	ao_serial2_rx_fifo;
+extern volatile struct ao_fifo	ao_serial2_tx_fifo;
 
 char
 ao_serial2_getchar(void);
@@ -95,8 +95,8 @@ ao_serial2_set_speed(uint8_t speed);
 #endif
 
 #if HAS_SERIAL_3
-extern volatile __xdata struct ao_fifo	ao_serial3_rx_fifo;
-extern volatile __xdata struct ao_fifo	ao_serial3_tx_fifo;
+extern volatile struct ao_fifo	ao_serial3_rx_fifo;
+extern volatile struct ao_fifo	ao_serial3_tx_fifo;
 
 char
 ao_serial3_getchar(void);
diff --git a/src/kernel/ao_stdio.c b/src/kernel/ao_stdio.c
index 227499c8..c3b51d12 100644
--- a/src/kernel/ao_stdio.c
+++ b/src/kernel/ao_stdio.c
@@ -72,13 +72,13 @@
 
 #define AO_NUM_STDIOS	(HAS_USB + PACKET_HAS_SLAVE + USE_SERIAL_STDIN + CONSOLE_STDIN)
 
-__xdata struct ao_stdio ao_stdios[AO_NUM_STDIOS];
+struct ao_stdio ao_stdios[AO_NUM_STDIOS];
 
 #if AO_NUM_STDIOS > 1
-__pdata int8_t ao_cur_stdio;
-__pdata int8_t ao_num_stdios;
+int8_t ao_cur_stdio;
+int8_t ao_num_stdios;
 #else
-__pdata int8_t ao_cur_stdio;
+int8_t ao_cur_stdio;
 #define ao_cur_stdio	0
 #define ao_num_stdios	0
 #endif
@@ -108,10 +108,10 @@ flush(void)
 		ao_stdios[ao_cur_stdio].flush();
 }
 
-__xdata uint8_t ao_stdin_ready;
+uint8_t ao_stdin_ready;
 
 char
-ao_getchar(void) __reentrant
+ao_getchar(void) 
 {
 	int c;
 	int8_t stdio;
@@ -145,7 +145,7 @@ ao_echo(void)
 int8_t
 ao_add_stdio(int (*_pollchar)(void),
 	     void (*putchar)(char),
-	     void (*flush)(void)) __reentrant
+	     void (*flush)(void)) 
 {
 	if (ao_num_stdios == AO_NUM_STDIOS)
 		ao_panic(AO_PANIC_STDIO);
diff --git a/src/kernel/ao_storage.c b/src/kernel/ao_storage.c
index 400751de..5292e120 100644
--- a/src/kernel/ao_storage.c
+++ b/src/kernel/ao_storage.c
@@ -20,7 +20,7 @@
 #include <ao_storage.h>
 
 uint8_t
-ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_read(ao_pos_t pos, void *buf, uint16_t len) 
 {
 #ifdef CC1111
 	return ao_storage_device_read(pos, buf, len);
@@ -54,7 +54,7 @@ ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 }
 
 uint8_t
-ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_write(ao_pos_t pos, void *buf, uint16_t len) 
 {
 #ifdef CC1111
 	return ao_storage_device_write(pos, buf, len);
@@ -87,10 +87,10 @@ ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant
 #endif
 }
 
-static __xdata uint8_t storage_data[128];
+static uint8_t storage_data[128];
 
 static void
-ao_storage_dump(void) __reentrant
+ao_storage_dump(void) 
 {
 	uint8_t i, j;
 
@@ -118,12 +118,12 @@ ao_storage_dump(void) __reentrant
 /* not enough space for this today
  */
 static void
-ao_storage_store(void) __reentrant
+ao_storage_store(void) 
 {
 	uint16_t block;
 	uint8_t i;
 	uint16_t len;
-	static __xdata uint8_t b;
+	static uint8_t b;
 	uint32_t addr;
 
 	ao_cmd_hex();
@@ -147,7 +147,7 @@ ao_storage_store(void) __reentrant
 #endif
 
 void
-ao_storage_zap(void) __reentrant
+ao_storage_zap(void) 
 {
 	ao_cmd_hex();
 	if (ao_cmd_status != ao_cmd_success)
@@ -156,7 +156,7 @@ ao_storage_zap(void) __reentrant
 }
 
 void
-ao_storage_zapall(void) __reentrant
+ao_storage_zapall(void) 
 {
 	uint32_t	pos;
 
@@ -272,7 +272,7 @@ ao_storage_incr_check_block(uint32_t pos)
 }
 
 static uint8_t
-ao_storage_test_block(uint32_t pos) __reentrant
+ao_storage_test_block(uint32_t pos) 
 {
 	ao_storage_erase(pos);
 	printf(" erase"); flush();
@@ -299,7 +299,7 @@ ao_storage_test_block(uint32_t pos) __reentrant
 }
 
 static void
-ao_storage_test(void) __reentrant
+ao_storage_test(void) 
 {
 	uint32_t	pos;
 
@@ -316,7 +316,7 @@ ao_storage_test(void) __reentrant
 #endif /* AO_STORAGE_TEST */
 
 void
-ao_storage_info(void) __reentrant
+ao_storage_info(void) 
 {
 	ao_storage_setup();
 	printf("Storage size: %ld\n", (long) ao_storage_total);
@@ -324,7 +324,7 @@ ao_storage_info(void) __reentrant
 	ao_storage_device_info();
 }
 
-__code struct ao_cmds ao_storage_cmds[] = {
+const struct ao_cmds ao_storage_cmds[] = {
 	{ ao_storage_info, "f\0Show storage" },
 	{ ao_storage_dump, "e <block>\0Dump flash" },
 #if HAS_STORAGE_DEBUG
diff --git a/src/kernel/ao_storage.h b/src/kernel/ao_storage.h
index 59b137ad..cf37a824 100644
--- a/src/kernel/ao_storage.h
+++ b/src/kernel/ao_storage.h
@@ -31,10 +31,10 @@
 typedef ao_storage_pos_t ao_pos_t;
 
 /* Total bytes of available storage */
-extern __pdata ao_pos_t	ao_storage_total;
+extern ao_pos_t	ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-extern __pdata ao_pos_t	ao_storage_block;
+extern ao_pos_t	ao_storage_block;
 
 #ifndef USE_STORAGE_CONFIG
 #define USE_STORAGE_CONFIG 1
@@ -42,7 +42,7 @@ extern __pdata ao_pos_t	ao_storage_block;
 
 #if USE_STORAGE_CONFIG
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-extern __pdata ao_pos_t	ao_storage_config;
+extern ao_pos_t	ao_storage_config;
 
 #define ao_storage_log_max	ao_storage_config
 #else
@@ -50,27 +50,27 @@ extern __pdata ao_pos_t	ao_storage_config;
 #endif
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-extern __pdata uint16_t ao_storage_unit;
+extern uint16_t ao_storage_unit;
 
 /* Initialize above values. Can only be called once the OS is running */
 void
-ao_storage_setup(void) __reentrant;
+ao_storage_setup(void);
 
 /* Write data. Returns 0 on failure, 1 on success */
 uint8_t
-ao_storage_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant;
+ao_storage_write(ao_pos_t pos, void *buf, uint16_t len);
 
 /* Read data. Returns 0 on failure, 1 on success */
 uint8_t
-ao_storage_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant;
+ao_storage_read(ao_pos_t pos, void *buf, uint16_t len);
 
 /* Erase a block of storage. This always clears ao_storage_block bytes */
 uint8_t
-ao_storage_erase(ao_pos_t pos) __reentrant;
+ao_storage_erase(ao_pos_t pos);
 
 /* Flush any pending writes to stable storage */
 void
-ao_storage_flush(void) __reentrant;
+ao_storage_flush(void);
 
 /* Initialize the storage code */
 void
@@ -82,11 +82,11 @@ ao_storage_init(void);
 
 /* Read data within a storage unit */
 uint8_t
-ao_storage_device_read(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant;
+ao_storage_device_read(ao_pos_t pos, void *buf, uint16_t len);
 
 /* Write data within a storage unit */
 uint8_t
-ao_storage_device_write(ao_pos_t pos, __xdata void *buf, uint16_t len) __reentrant;
+ao_storage_device_write(ao_pos_t pos, void *buf, uint16_t len);
 
 /* Initialize low-level device bits */
 void
@@ -94,6 +94,6 @@ ao_storage_device_init(void);
 
 /* Print out information about flash chips */
 void
-ao_storage_device_info(void) __reentrant;
+ao_storage_device_info(void);
 
 #endif /* _AO_STORAGE_H_ */
diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c
index de23ea02..4f7072cb 100644
--- a/src/kernel/ao_task.c
+++ b/src/kernel/ao_task.c
@@ -29,12 +29,12 @@
 
 #define AO_NO_TASK_INDEX	0xff
 
-__xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS];
-__data uint8_t ao_num_tasks;
-__xdata struct ao_task *__data ao_cur_task;
+struct ao_task * ao_tasks[AO_NUM_TASKS];
+uint8_t ao_num_tasks;
+struct ao_task *ao_cur_task;
 
 #if !HAS_TASK_QUEUE
-static __data uint8_t ao_cur_task_index;
+static uint8_t ao_cur_task_index;
 #endif
 
 #ifdef ao_arch_task_globals
@@ -290,7 +290,7 @@ ao_task_validate(void)
 #endif /* HAS_TASK_QUEUE */
 
 void
-ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant
+ao_add_task(struct ao_task * task, void (*start)(void), const char *name) 
 {
 	uint8_t task_id;
 	uint8_t t;
@@ -321,7 +321,7 @@ ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *nam
 		);
 }
 
-__data uint8_t	ao_task_minimize_latency;
+uint8_t	ao_task_minimize_latency;
 
 /* Task switching function. This must not use any stack variables */
 void
@@ -382,7 +382,7 @@ ao_yield(void) ao_arch_naked_define
 	ao_cur_task = ao_list_first_entry(&run_queue, struct ao_task, queue);
 #else
 	{
-		__pdata uint8_t	ao_last_task_index = ao_cur_task_index;
+		uint8_t	ao_last_task_index = ao_cur_task_index;
 		for (;;) {
 			++ao_cur_task_index;
 			if (ao_cur_task_index == ao_num_tasks)
@@ -418,7 +418,7 @@ ao_yield(void) ao_arch_naked_define
 }
 
 uint8_t
-ao_sleep(__xdata void *wchan)
+ao_sleep(void *wchan)
 {
 #if HAS_TASK_QUEUE
 	uint32_t flags;
@@ -439,7 +439,7 @@ ao_sleep(__xdata void *wchan)
 }
 
 void
-ao_wakeup(__xdata void *wchan) __reentrant
+ao_wakeup(void *wchan) 
 {
 	ao_validate_cur_stack();
 #if HAS_TASK_QUEUE
@@ -470,7 +470,7 @@ ao_wakeup(__xdata void *wchan) __reentrant
 }
 
 uint8_t
-ao_sleep_for(__xdata void *wchan, uint16_t timeout)
+ao_sleep_for(void *wchan, uint16_t timeout)
 {
 	uint8_t	ret;
 	if (timeout) {
@@ -504,7 +504,7 @@ ao_sleep_for(__xdata void *wchan, uint16_t timeout)
 	return ret;
 }
 
-static __xdata uint8_t ao_forever;
+static uint8_t ao_forever;
 
 void
 ao_delay(uint16_t ticks)
@@ -541,7 +541,7 @@ void
 ao_task_info(void)
 {
 	uint8_t		i;
-	__xdata struct ao_task *task;
+	struct ao_task *task;
 	uint16_t	now = ao_time();
 
 	for (i = 0; i < ao_num_tasks; i++) {
diff --git a/src/kernel/ao_task.h b/src/kernel/ao_task.h
index 7549b598..ffeb7313 100644
--- a/src/kernel/ao_task.h
+++ b/src/kernel/ao_task.h
@@ -39,11 +39,11 @@
 
 /* An AltOS task */
 struct ao_task {
-	__xdata void *wchan;		/* current wait channel (NULL if running) */
+	void *wchan;		/* current wait channel (NULL if running) */
 	uint16_t alarm;			/* abort ao_sleep time */
 	ao_arch_task_members		/* any architecture-specific fields */
 	uint8_t task_id;		/* unique id */
-	__code char *name;		/* task name */
+	const char *name;		/* task name */
 #ifdef NEWLIB
 	int __errno;			/* storage for errno in newlib libc */
 #endif
@@ -66,10 +66,10 @@ struct ao_task {
 
 #define AO_NO_TASK		0	/* no task id */
 
-extern __xdata struct ao_task * __xdata ao_tasks[AO_NUM_TASKS];
-extern __data uint8_t ao_num_tasks;
-extern __xdata struct ao_task *__data ao_cur_task;
-extern __data uint8_t ao_task_minimize_latency;	/* Reduce IRQ latency */
+extern struct ao_task * ao_tasks[AO_NUM_TASKS];
+extern uint8_t ao_num_tasks;
+extern struct ao_task *ao_cur_task;
+extern uint8_t ao_task_minimize_latency;	/* Reduce IRQ latency */
 
 #ifndef HAS_ARCH_VALIDATE_CUR_STACK
 #define ao_validate_cur_stack()
@@ -85,7 +85,7 @@ extern __data uint8_t ao_task_minimize_latency;	/* Reduce IRQ latency */
  *  1 on alarm
  */
 uint8_t
-ao_sleep(__xdata void *wchan);
+ao_sleep(void *wchan);
 
 /* Suspend the current task until wchan is awoken or the timeout
  * expires. returns:
@@ -93,11 +93,11 @@ ao_sleep(__xdata void *wchan);
  *  1 on alarm
  */
 uint8_t
-ao_sleep_for(__xdata void *wchan, uint16_t timeout);
+ao_sleep_for(void *wchan, uint16_t timeout);
 
 /* Wake all tasks sleeping on wchan */
 void
-ao_wakeup(__xdata void *wchan) __reentrant;
+ao_wakeup(void *wchan);
 
 #if 0
 /* set an alarm to go off in 'delay' ticks */
@@ -115,7 +115,7 @@ ao_yield(void) ao_arch_naked_declare;
 
 /* Add a task to the run queue */
 void
-ao_add_task(__xdata struct ao_task * task, void (*start)(void), __code char *name) __reentrant;
+ao_add_task(struct ao_task * task, void (*start)(void), const char *name);
 
 #if HAS_TASK_QUEUE
 /* Called on timer interrupt to check alarms */
diff --git a/src/kernel/ao_telemetry.c b/src/kernel/ao_telemetry.c
index 8ff28fde..9e1304f7 100644
--- a/src/kernel/ao_telemetry.c
+++ b/src/kernel/ao_telemetry.c
@@ -20,10 +20,10 @@
 #include "ao_log.h"
 #include "ao_product.h"
 
-static __pdata uint16_t ao_telemetry_interval;
+static uint16_t ao_telemetry_interval;
 
 #if HAS_RADIO_RATE
-static __xdata uint16_t ao_telemetry_desired_interval;
+static uint16_t ao_telemetry_desired_interval;
 #endif
 
 /* TeleMetrum v1.0 just doesn't have enough space to
@@ -37,10 +37,10 @@ static __xdata uint16_t ao_telemetry_desired_interval;
 
 #ifdef SIMPLIFY
 #define ao_telemetry_time time
-#define RDF_SPACE	__pdata
+#define RDF_SPACE	
 #else
-#define RDF_SPACE	__xdata
-static __pdata uint16_t ao_telemetry_time;
+#define RDF_SPACE	
+static uint16_t ao_telemetry_time;
 #endif
 
 #if HAS_RDF
@@ -49,7 +49,7 @@ static RDF_SPACE uint16_t ao_rdf_time;
 #endif
 
 #if HAS_APRS
-static __pdata uint16_t ao_aprs_time;
+static uint16_t ao_aprs_time;
 
 #include <ao_aprs.h>
 #endif
@@ -74,7 +74,7 @@ static __pdata uint16_t ao_aprs_time;
 #define AO_TELEMETRY_SENSOR	AO_TELEMETRY_SENSOR_TELENANO
 #endif
 
-static __xdata union ao_telemetry_all	telemetry;
+static union ao_telemetry_all	telemetry;
 
 static void
 ao_telemetry_send(void)
@@ -88,7 +88,7 @@ ao_telemetry_send(void)
 static void
 ao_send_sensor(void)
 {
-	__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+		struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 
 	telemetry.generic.tick = packet->tick;
 	telemetry.generic.type = AO_TELEMETRY_SENSOR;
@@ -136,7 +136,7 @@ ao_send_sensor(void)
 static void
 ao_send_mega_sensor(void)
 {
-	__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+		struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 
 	telemetry.generic.tick = packet->tick;
 	telemetry.generic.type = AO_TELEMETRY_MEGA_SENSOR;
@@ -181,15 +181,15 @@ ao_send_mega_sensor(void)
 	ao_telemetry_send();
 }
 
-static __pdata int8_t ao_telemetry_mega_data_max;
-static __pdata int8_t ao_telemetry_mega_data_cur;
+static int8_t ao_telemetry_mega_data_max;
+static int8_t ao_telemetry_mega_data_cur;
 
 /* Send mega data packet */
 static void
 ao_send_mega_data(void)
 {
 	if (--ao_telemetry_mega_data_cur <= 0) {
-		__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+			struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 		uint8_t	i;
 
 		telemetry.generic.tick = packet->tick;
@@ -223,7 +223,7 @@ ao_send_mega_data(void)
 static void
 ao_send_metrum_sensor(void)
 {
-	__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+		struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 
 	telemetry.generic.tick = packet->tick;
 	telemetry.generic.type = AO_TELEMETRY_METRUM_SENSOR;
@@ -246,15 +246,15 @@ ao_send_metrum_sensor(void)
 	ao_telemetry_send();
 }
 
-static __pdata int8_t ao_telemetry_metrum_data_max;
-static __pdata int8_t ao_telemetry_metrum_data_cur;
+static int8_t ao_telemetry_metrum_data_max;
+static int8_t ao_telemetry_metrum_data_cur;
 
 /* Send telemetrum data packet */
 static void
 ao_send_metrum_data(void)
 {
 	if (--ao_telemetry_metrum_data_cur <= 0) {
-		__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+			struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 
 		telemetry.generic.tick = packet->tick;
 		telemetry.generic.type = AO_TELEMETRY_METRUM_DATA;
@@ -281,7 +281,7 @@ ao_send_metrum_data(void)
 static void
 ao_send_mini(void)
 {
-	__xdata	struct ao_data *packet = (__xdata struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
+		struct ao_data *packet = (struct ao_data *) &ao_data_ring[ao_data_ring_prev(ao_sample_data)];
 
 	telemetry.generic.tick = packet->tick;
 	telemetry.generic.type = AO_SEND_MINI;
@@ -306,9 +306,9 @@ ao_send_mini(void)
 
 #endif /* AO_SEND_MINI */
 
-static __pdata int8_t ao_telemetry_config_max;
-static __pdata int8_t ao_telemetry_config_cur;
-static __pdata uint16_t ao_telemetry_flight_number;
+static int8_t ao_telemetry_config_max;
+static int8_t ao_telemetry_config_cur;
+static uint16_t ao_telemetry_flight_number;
 
 #ifndef ao_telemetry_battery_convert
 #define ao_telemetry_battery_convert(a) (a)
@@ -346,9 +346,9 @@ ao_send_configuration(void)
 
 #if HAS_GPS
 
-static __pdata int8_t ao_telemetry_gps_max;
-static __pdata int8_t ao_telemetry_loc_cur;
-static __pdata int8_t ao_telemetry_sat_cur;
+static int8_t ao_telemetry_gps_max;
+static int8_t ao_telemetry_loc_cur;
+static int8_t ao_telemetry_sat_cur;
 
 static void
 ao_send_location(void)
@@ -387,8 +387,8 @@ ao_send_satellite(void)
 
 #if HAS_COMPANION
 
-static __pdata int8_t ao_telemetry_companion_max;
-static __pdata int8_t ao_telemetry_companion_cur;
+static int8_t ao_telemetry_companion_max;
+static int8_t ao_telemetry_companion_cur;
 
 static void
 ao_send_companion(void)
@@ -536,7 +536,7 @@ ao_telemetry_set_interval(uint16_t interval)
 #if HAS_RADIO_RATE
 	/* Limit max telemetry rate based on available radio bandwidth.
 	 */
-	static __xdata const uint16_t min_interval[] = {
+	static const uint16_t min_interval[] = {
 		/* [AO_RADIO_RATE_38400] = */ AO_MS_TO_TICKS(100),
 		/* [AO_RADIO_RATE_9600] = */ AO_MS_TO_TICKS(500),
 		/* [AO_RADIO_RATE_2400] = */ AO_MS_TO_TICKS(1000)
@@ -613,7 +613,7 @@ ao_rdf_set(uint8_t rdf)
 }
 #endif
 
-__xdata struct ao_task	ao_telemetry_task;
+struct ao_task	ao_telemetry_task;
 
 void
 ao_telemetry_init()
diff --git a/src/kernel/ao_usb.h b/src/kernel/ao_usb.h
index 40516de1..7992c806 100644
--- a/src/kernel/ao_usb.h
+++ b/src/kernel/ao_usb.h
@@ -69,7 +69,7 @@ ao_usb_disable(void);
 void
 ao_usb_init(void);
 
-extern __code __at (0x00aa) uint8_t ao_usb_descriptors [];
+extern const __at (0x00aa) uint8_t ao_usb_descriptors [];
 
 #define AO_USB_SETUP_DIR_MASK	(0x01 << 7)
 #define AO_USB_SETUP_TYPE_MASK	(0x03 << 5)
@@ -176,8 +176,8 @@ struct ao_usb_line_coding {
 	uint8_t		data_bits;
 } ;
 
-extern __xdata struct ao_usb_line_coding ao_usb_line_coding;
+extern struct ao_usb_line_coding ao_usb_line_coding;
 
-extern __pdata uint8_t ao_usb_running;
+extern uint8_t ao_usb_running;
 
 #endif /* _AO_USB_H_ */
diff --git a/src/lpc/altos-loader.ld b/src/lpc/altos-loader.ld
index 84d7610c..be4f115d 100644
--- a/src/lpc/altos-loader.ld
+++ b/src/lpc/altos-loader.ld
@@ -61,9 +61,9 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data*)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 
diff --git a/src/lpc/altos-standalone.ld b/src/lpc/altos-standalone.ld
index db53dcaf..99d10149 100644
--- a/src/lpc/altos-standalone.ld
+++ b/src/lpc/altos-standalone.ld
@@ -65,9 +65,9 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data ORIGIN(ram) : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 		__bss_start__ = .;
 	} >ram
 
diff --git a/src/lpc/altos.ld b/src/lpc/altos.ld
index e6a6a7ed..028ad775 100644
--- a/src/lpc/altos.ld
+++ b/src/lpc/altos.ld
@@ -69,9 +69,9 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 		__bss_start__ = .;
 	} >ram
 
diff --git a/src/lpc/ao_adc_lpc.c b/src/lpc/ao_adc_lpc.c
index 26a5ea08..6743c1f4 100644
--- a/src/lpc/ao_adc_lpc.c
+++ b/src/lpc/ao_adc_lpc.c
@@ -147,7 +147,7 @@ ao_adc_poll(void)
 }
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
 	struct ao_data	packet;
 #ifndef AO_ADC_DUMP
@@ -167,7 +167,7 @@ ao_adc_dump(void) __reentrant
 #endif
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
 	{ ao_adc_dump,	"a\0Display current ADC values" },
 	{ 0, NULL },
 };
diff --git a/src/lpc/ao_arch.h b/src/lpc/ao_arch.h
index f1df14eb..889be53e 100644
--- a/src/lpc/ao_arch.h
+++ b/src/lpc/ao_arch.h
@@ -42,11 +42,6 @@
 
 #define ao_arch_naked_declare	__attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
diff --git a/src/lpc/ao_beep_lpc.c b/src/lpc/ao_beep_lpc.c
index b1211752..eab86ee6 100644
--- a/src/lpc/ao_beep_lpc.c
+++ b/src/lpc/ao_beep_lpc.c
@@ -59,7 +59,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
 	ao_beep(beep);
 	ao_delay(ticks);
diff --git a/src/lpc/ao_interrupt.c b/src/lpc/ao_interrupt.c
index 3e0119c6..8d71f43f 100644
--- a/src/lpc/ao_interrupt.c
+++ b/src/lpc/ao_interrupt.c
@@ -32,7 +32,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 #if RELOCATE_INTERRUPT
 extern char __interrupt_rom__, __interrupt_start__, __interrupt_end__;
@@ -61,7 +61,7 @@ void start(void) {
 	memcpy(&__interrupt_start__, &__interrupt_rom__, &__interrupt_end__ - &__interrupt_start__);
 	lpc_scb.sysmemremap = LPC_SCB_SYSMEMREMAP_MAP_RAM << LPC_SCB_SYSMEMREMAP_MAP;
 #endif
-	memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+	memcpy(&_start__, &__text_end__, &_end__ - &_start__);
 	memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
 	main();
 }
diff --git a/src/lpc/ao_led_lpc.c b/src/lpc/ao_led_lpc.c
index 2d2c3972..5fc726c0 100644
--- a/src/lpc/ao_led_lpc.c
+++ b/src/lpc/ao_led_lpc.c
@@ -18,7 +18,7 @@
 
 #include <ao.h>
 
-__pdata AO_PORT_TYPE ao_led_enable;
+AO_PORT_TYPE ao_led_enable;
 
 void
 ao_led_on(AO_PORT_TYPE colors)
@@ -49,7 +49,7 @@ ao_led_toggle(AO_PORT_TYPE colors)
 }
 
 void
-ao_led_for(AO_PORT_TYPE colors, uint16_t ticks) __reentrant
+ao_led_for(AO_PORT_TYPE colors, uint16_t ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/lpc/ao_timer_lpc.c b/src/lpc/ao_timer_lpc.c
index 166e2f15..8999c7ac 100644
--- a/src/lpc/ao_timer_lpc.c
+++ b/src/lpc/ao_timer_lpc.c
@@ -18,7 +18,7 @@
 
 #include <ao.h>
 
-volatile __data AO_TICK_TYPE ao_tick_count;
+volatile AO_TICK_TYPE ao_tick_count;
 
 uint16_t
 ao_time(void)
@@ -27,8 +27,8 @@ ao_time(void)
 }
 
 #if AO_DATA_ALL
-volatile __data uint8_t	ao_data_interval = 1;
-volatile __data uint8_t	ao_data_count;
+volatile uint8_t	ao_data_interval = 1;
+volatile uint8_t	ao_data_count;
 #endif
 
 void lpc_systick_isr(void)
diff --git a/src/lpc/ao_usb_lpc.c b/src/lpc/ao_usb_lpc.c
index d26a1437..5cd7aa59 100644
--- a/src/lpc/ao_usb_lpc.c
+++ b/src/lpc/ao_usb_lpc.c
@@ -1003,7 +1003,7 @@ ao_usb_irq(void)
 		control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
 	{ ao_usb_irq, "I\0Show USB interrupt counts" },
 	{ 0, NULL }
 };
diff --git a/src/micropeak-v2.0/micropeak.ld b/src/micropeak-v2.0/micropeak.ld
index baeae5b8..a73d4c1d 100644
--- a/src/micropeak-v2.0/micropeak.ld
+++ b/src/micropeak-v2.0/micropeak.ld
@@ -90,7 +90,7 @@ SECTIONS {
 	 */
 
 	.textram BLOCK(8): {
-		__data_start__ = .;
+		_start__ = .;
 		*(.ramtext)
 	} >ram AT>rom
 
@@ -99,7 +99,7 @@ SECTIONS {
 	 */
 	.data BLOCK(8): {
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/nucleao-32/load.ld b/src/nucleao-32/load.ld
index 02a23a95..945f7c60 100644
--- a/src/nucleao-32/load.ld
+++ b/src/nucleao-32/load.ld
@@ -82,10 +82,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/pnpservo-v1/lambda.ld b/src/pnpservo-v1/lambda.ld
index 5de65eb5..d3edbe9f 100644
--- a/src/pnpservo-v1/lambda.ld
+++ b/src/pnpservo-v1/lambda.ld
@@ -85,7 +85,7 @@ SECTIONS {
 	 */
 
 	.textram BLOCK(8): {
-		__data_start__ = .;
+		_start__ = .;
 		__text_ram_start__ = .;
 		*(.ramtext)
 		__text_ram_end = .;
@@ -96,7 +96,7 @@ SECTIONS {
 	.data : {
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/product/ao_flash_task.c b/src/product/ao_flash_task.c
index 1f0edb05..a680ca18 100644
--- a/src/product/ao_flash_task.c
+++ b/src/product/ao_flash_task.c
@@ -29,7 +29,7 @@ ao_panic(uint8_t reason)
 }
 
 void
-ao_put_string(__code char *s)
+ao_put_string(const char *s)
 {
 	char	c;
 	while ((c = *s++)) {
diff --git a/src/product/ao_terraui.c b/src/product/ao_terraui.c
index f8f23a0f..3a989f5a 100644
--- a/src/product/ao_terraui.c
+++ b/src/product/ao_terraui.c
@@ -20,15 +20,15 @@
 #include <ao_flight.h>
 #include <math.h>
 
-static __xdata struct ao_telemetry_sensor		ao_tel_sensor;
-static __xdata struct ao_telemetry_location		ao_tel_location;
-static __xdata struct ao_telemetry_configuration	ao_tel_config;
-static __xdata int16_t 					ao_tel_max_speed;
-static __xdata int16_t					ao_tel_max_height;
+static struct ao_telemetry_sensor		ao_tel_sensor;
+static struct ao_telemetry_location		ao_tel_location;
+static struct ao_telemetry_configuration	ao_tel_config;
+static int16_t 					ao_tel_max_speed;
+static int16_t					ao_tel_max_height;
 static int8_t ao_tel_rssi;
 
-static __xdata char ao_lcd_line[17];
-static __xdata char ao_state_name[] = "SIPBFCDMLI";
+static char ao_lcd_line[17];
+static char ao_state_name[] = "SIPBFCDMLI";
 
 static void
 ao_terraui_line(uint8_t addr)
@@ -85,7 +85,7 @@ ao_terraui_logging(void)
 	return '-';
 }
 
-static __code char ao_progress[4] = { '\011', '\012', '\014', '\013' };
+static const char ao_progress[4] = { '\011', '\012', '\014', '\013' };
 
 static uint8_t	ao_telem_progress;
 static uint8_t	ao_gps_progress;
@@ -165,7 +165,7 @@ static int16_t mag(int32_t d)
 static int32_t
 dist(int32_t d)
 {
-	__pdata uint32_t m;
+	uint32_t m;
 	uint8_t neg = 0;
 
 	if (d < 0) {
@@ -184,7 +184,7 @@ dist(int32_t d)
 	return d;
 }
 
-static __code uint8_t cos_table[] = {
+static const uint8_t cos_table[] = {
    0, /*  0 */
    0, /*  1 */
    0, /*  2 */
@@ -242,7 +242,7 @@ static __code uint8_t cos_table[] = {
    1, /* 54 */
 };
 
-static __code uint8_t tan_table[] = {
+static const uint8_t tan_table[] = {
     0, /*  0 */
     4, /*  1 */
     9, /*  2 */
@@ -290,7 +290,7 @@ static __code uint8_t tan_table[] = {
   247, /* 44 */
 };
 	
-int16_t ao_atan2(int32_t dy, int32_t dx) __reentrant
+int16_t ao_atan2(int32_t dy, int32_t dx) 
 {
 	int8_t	m = 1;
 	int16_t	a = 0;
@@ -334,10 +334,10 @@ int16_t ao_atan2(int32_t dy, int32_t dx) __reentrant
 	return t * m + a;
 }
 
-static __pdata int32_t	lon_dist, lat_dist;
-static __pdata uint32_t	ground_dist, range;
-static __pdata uint8_t dist_in_km;
-static __pdata int16_t bearing, elevation;
+static int32_t	lon_dist, lat_dist;
+static uint32_t	ground_dist, range;
+static uint8_t dist_in_km;
+static int16_t bearing, elevation;
 
 static void
 ao_terraui_lat_dist(void)
@@ -346,7 +346,7 @@ ao_terraui_lat_dist(void)
 }
 
 static void
-ao_terraui_lon_dist(void) __reentrant
+ao_terraui_lon_dist(void) 
 {
 	uint8_t	c = cos_table[ao_gps_data.latitude >> 24];
 	lon_dist = ao_tel_location.longitude;
@@ -418,7 +418,7 @@ ao_terraui_recover(void)
 }
 
 static void
-ao_terraui_coord(int32_t c, char plus, char minus, char extra) __reentrant
+ao_terraui_coord(int32_t c, char plus, char minus, char extra) 
 {
 	uint16_t	d;
 	uint8_t		m;
@@ -448,7 +448,7 @@ ao_terraui_remote(void)
 }
 
 static void
-ao_terraui_local(void) __reentrant
+ao_terraui_local(void) 
 {
 	ao_terraui_coord(ao_gps_data.latitude, 'n', 's',
 			 ao_terraui_local_gps());
@@ -457,11 +457,11 @@ ao_terraui_local(void) __reentrant
 	ao_terraui_line(AO_LCD_ADDR(1,0));
 }
 
-static __pdata uint8_t ao_set_freq;
-static __pdata uint32_t ao_set_freq_orig;
+static uint8_t ao_set_freq;
+static uint32_t ao_set_freq_orig;
 
 static void
-ao_terraui_freq(void) __reentrant
+ao_terraui_freq(void) 
 {
 	uint16_t	MHz;
 	uint16_t	frac;
@@ -508,7 +508,7 @@ ao_terraui_freq_button(char b) {
 	ao_radio_recv_abort();
 }
 
-static __code void (*__code ao_terraui_page[])(void) = {
+static const void (*const ao_terraui_page[])(void) = {
 	ao_terraui_startup,
 	ao_terraui_info,
 	ao_terraui_pad,
@@ -521,8 +521,8 @@ static __code void (*__code ao_terraui_page[])(void) = {
 
 #define NUM_PAGE	(sizeof (ao_terraui_page)/sizeof (ao_terraui_page[0]))
 
-static __pdata uint8_t ao_current_page = 0;
-static __pdata uint8_t ao_shown_about = 3;
+static uint8_t ao_current_page = 0;
+static uint8_t ao_shown_about = 3;
 
 static void
 ao_terraui(void)
@@ -575,7 +575,7 @@ ao_terraui(void)
 	}
 }
 
-__xdata static struct ao_task ao_terraui_task;
+static struct ao_task ao_terraui_task;
 
 static void
 ao_terramonitor(void)
@@ -619,7 +619,7 @@ ao_terramonitor(void)
 	}
 }
 
-__xdata static struct ao_task ao_terramonitor_task;
+static struct ao_task ao_terramonitor_task;
 
 static void
 ao_terragps(void)
@@ -634,7 +634,7 @@ ao_terragps(void)
 	}
 }
 
-__xdata static struct ao_task ao_terragps_task;
+static struct ao_task ao_terragps_task;
 
 void
 ao_terraui_init(void)
diff --git a/src/product/ao_test.c b/src/product/ao_test.c
index d1c60804..5db36293 100644
--- a/src/product/ao_test.c
+++ b/src/product/ao_test.c
@@ -18,13 +18,13 @@
 
 #include "ao.h"
 
-struct ao_task __xdata blink_0_task;
-struct ao_task __xdata blink_1_task;
-struct ao_task __xdata wakeup_task;
-struct ao_task __xdata beep_task;
-struct ao_task __xdata echo_task;
+struct ao_task blink_0_task;
+struct ao_task blink_1_task;
+struct ao_task wakeup_task;
+struct ao_task beep_task;
+struct ao_task echo_task;
 
-void delay(int n) __reentrant
+void delay(int n) 
 {
 	uint8_t	j = 0;
 	while (--n)
@@ -32,7 +32,7 @@ void delay(int n) __reentrant
 			ao_yield();
 }
 
-static __xdata uint8_t blink_chan;
+static uint8_t blink_chan;
 
 void
 blink_0(void)
@@ -51,7 +51,7 @@ blink_0(void)
 void
 blink_1(void)
 {
-	static __xdata struct ao_adc adc;
+	static struct ao_adc adc;
 
 	for (;;) {
 		ao_sleep(&ao_adc_head);
@@ -75,7 +75,7 @@ wakeup(void)
 void
 beep(void)
 {
-	static __xdata struct ao_adc adc;
+	static struct ao_adc adc;
 
 	for (;;) {
 		ao_delay(AO_SEC_TO_TICKS(1));
diff --git a/src/stm-bringup/bringup.ld b/src/stm-bringup/bringup.ld
index dcdcf073..71039598 100644
--- a/src/stm-bringup/bringup.ld
+++ b/src/stm-bringup/bringup.ld
@@ -44,13 +44,13 @@ SECTIONS {
 	} > rom
 
 	. = ORIGIN(ram);
-	__data_start__ = .;
+	_start__ = .;
 
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 		__bss_start__ = .;
 	} >ram
 
diff --git a/src/stm-demo/ao_demo.c b/src/stm-demo/ao_demo.c
index f6c8e3df..b0d03840 100644
--- a/src/stm-demo/ao_demo.c
+++ b/src/stm-demo/ao_demo.c
@@ -197,7 +197,7 @@ ao_blink_toggle(void)
 }
 
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
 	{ ao_dma_test,	"D\0DMA test" },
 	{ ao_spi_write, "W\0SPI write" },
 	{ ao_spi_read, "R\0SPI read" },
diff --git a/src/stm-scheme-newlib/ao_demo.c b/src/stm-scheme-newlib/ao_demo.c
index 13a31288..cb8e10e8 100644
--- a/src/stm-scheme-newlib/ao_demo.c
+++ b/src/stm-scheme-newlib/ao_demo.c
@@ -26,7 +26,7 @@ static void scheme_cmd() {
 }
 
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
 	{ scheme_cmd, "l\0Run scheme interpreter" },
 	{ 0, NULL }
 };
diff --git a/src/stm-vga/ao_demo.c b/src/stm-vga/ao_demo.c
index 1b443b1f..63740f8e 100644
--- a/src/stm-vga/ao_demo.c
+++ b/src/stm-vga/ao_demo.c
@@ -198,7 +198,7 @@ ao_console_send(void)
 	}
 }
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
 	{ ao_video_toggle, "V\0Toggle video" },
 	{ ao_ball_toggle, "B\0Toggle ball" },
 	{ ao_ps2_read_keys, "K\0Read keys from keyboard" },
diff --git a/src/stm/altos-512.ld b/src/stm/altos-512.ld
index 78c41685..97a9c437 100644
--- a/src/stm/altos-512.ld
+++ b/src/stm/altos-512.ld
@@ -74,10 +74,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/stm/altos-loader.ld b/src/stm/altos-loader.ld
index 806b4842..1ebbc7a2 100644
--- a/src/stm/altos-loader.ld
+++ b/src/stm/altos-loader.ld
@@ -65,7 +65,7 @@ SECTIONS {
 	 */
 
 	.textram BLOCK(8): {
-		__data_start__ = .;
+		_start__ = .;
 		__text_ram_start__ = .;
 		*(.ramtext)
 		__text_ram_end = .;
@@ -76,7 +76,7 @@ SECTIONS {
 	 */
 	.data BLOCK(8): {
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 
diff --git a/src/stm/altos-ram.ld b/src/stm/altos-ram.ld
index 098454e1..d8f072a7 100644
--- a/src/stm/altos-ram.ld
+++ b/src/stm/altos-ram.ld
@@ -42,13 +42,13 @@ SECTIONS {
 		__text_end__ = .;
 	} > ram
 
-	__data_start__ = .;
+	_start__ = .;
 
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 		__bss_start__ = .;
 	} >ram
 
diff --git a/src/stm/altos.ld b/src/stm/altos.ld
index 6a8c7113..e352ed36 100644
--- a/src/stm/altos.ld
+++ b/src/stm/altos.ld
@@ -74,10 +74,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/stm/ao_adc_single_stm.c b/src/stm/ao_adc_single_stm.c
index 8a7fda4a..5737cd50 100644
--- a/src/stm/ao_adc_single_stm.c
+++ b/src/stm/ao_adc_single_stm.c
@@ -95,7 +95,7 @@ ao_adc_dump(void)
 	AO_ADC_DUMP(&packet);
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
 	{ ao_adc_dump,	"a\0Display current ADC values" },
 	{ 0, NULL },
 };
diff --git a/src/stm/ao_adc_stm.c b/src/stm/ao_adc_stm.c
index 24912bb2..2399e6a2 100644
--- a/src/stm/ao_adc_stm.c
+++ b/src/stm/ao_adc_stm.c
@@ -100,7 +100,7 @@ ao_adc_poll(void)
  * Fetch a copy of the most recent ADC data
  */
 void
-ao_adc_get(__xdata struct ao_adc *packet)
+ao_adc_get(struct ao_adc *packet)
 {
 #if HAS_FLIGHT
 	uint8_t	i = ao_data_ring_prev(ao_sample_data);
@@ -177,7 +177,7 @@ static const char *ao_adc_name[AO_NUM_ADC] = {
 #endif
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
 	struct ao_data	packet;
 #ifndef AO_ADC_DUMP
@@ -203,7 +203,7 @@ ao_adc_dump(void) __reentrant
 #endif
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
 	{ ao_adc_dump,	"a\0Display current ADC values" },
 	{ 0, NULL },
 };
diff --git a/src/stm/ao_arch.h b/src/stm/ao_arch.h
index 7b08b891..aee9df3c 100644
--- a/src/stm/ao_arch.h
+++ b/src/stm/ao_arch.h
@@ -41,11 +41,6 @@
 
 #define ao_arch_naked_declare	__attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
diff --git a/src/stm/ao_beep_stm.c b/src/stm/ao_beep_stm.c
index 0b4e6012..f9fa14c2 100644
--- a/src/stm/ao_beep_stm.c
+++ b/src/stm/ao_beep_stm.c
@@ -132,7 +132,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
 	ao_beep(beep);
 	ao_delay(ticks);
diff --git a/src/stm/ao_eeprom_stm.c b/src/stm/ao_eeprom_stm.c
index 4f477122..d3e3338d 100644
--- a/src/stm/ao_eeprom_stm.c
+++ b/src/stm/ao_eeprom_stm.c
@@ -117,10 +117,10 @@ ao_intflash_read(uint16_t pos)
  */
 
 uint8_t
-ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len)
+ao_eeprom_write(ao_pos_t pos32, void *v, uint16_t len)
 {
 	uint16_t pos = pos32;
-	__xdata uint8_t *d = v;
+	uint8_t *d = v;
 
 	if (pos >= ao_eeprom_total || pos + len > ao_eeprom_total)
 		return 0;
@@ -151,7 +151,7 @@ ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len)
  * Read from eeprom
  */
 uint8_t
-ao_eeprom_read(ao_pos_t pos, __xdata void *v, uint16_t len)
+ao_eeprom_read(ao_pos_t pos, void *v, uint16_t len)
 {
 	uint8_t	*d = v;
 	
diff --git a/src/stm/ao_interrupt.c b/src/stm/ao_interrupt.c
index eb1ed0b5..d8be3667 100644
--- a/src/stm/ao_interrupt.c
+++ b/src/stm/ao_interrupt.c
@@ -24,7 +24,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 
 /* Interrupt functions */
@@ -83,7 +83,7 @@ void start(void)
 #endif
 	/* Set interrupt vector table offset */
 	stm_nvic.vto = (uint32_t) &stm_interrupt_vector;
-	memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+	memcpy(&_start__, &__text_end__, &_end__ - &_start__);
 	memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
 	main();
 }
diff --git a/src/stm/ao_led.c b/src/stm/ao_led.c
index a7033dbb..bd83f4e4 100644
--- a/src/stm/ao_led.c
+++ b/src/stm/ao_led.c
@@ -153,7 +153,7 @@ ao_led_toggle(AO_LED_TYPE colors)
 }
 
 void
-ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) __reentrant
+ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/stm/ao_timer.c b/src/stm/ao_timer.c
index 9d118b72..9e9436cf 100644
--- a/src/stm/ao_timer.c
+++ b/src/stm/ao_timer.c
@@ -39,8 +39,8 @@ ao_time(void)
 #endif
 
 #if AO_DATA_ALL
-volatile __data uint8_t	ao_data_interval = 1;
-volatile __data uint8_t	ao_data_count;
+volatile uint8_t	ao_data_interval = 1;
+volatile uint8_t	ao_data_count;
 #endif
 
 void stm_systick_isr(void)
diff --git a/src/stm/ao_usb_stm.c b/src/stm/ao_usb_stm.c
index b06814d2..d7cbd5b7 100644
--- a/src/stm/ao_usb_stm.c
+++ b/src/stm/ao_usb_stm.c
@@ -1079,7 +1079,7 @@ ao_usb_irq(void)
 		control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
 	{ ao_usb_irq, "I\0Show USB interrupt counts" },
 	{ 0, NULL }
 };
diff --git a/src/stmf0/altos-loader.ld b/src/stmf0/altos-loader.ld
index 05887d0e..4d9b81ae 100644
--- a/src/stmf0/altos-loader.ld
+++ b/src/stmf0/altos-loader.ld
@@ -66,7 +66,7 @@ SECTIONS {
 	 */
 
 	.textram BLOCK(8): {
-		__data_start__ = .;
+		_start__ = .;
 		__text_ram_start__ = .;
 		*(.ramtext)
 		__text_ram_end = .;
@@ -77,7 +77,7 @@ SECTIONS {
 	 */
 	.data BLOCK(8): {
 		*(.data)	/* initialized data */
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 
diff --git a/src/stmf0/altos-raw.ld b/src/stmf0/altos-raw.ld
index eb285e07..90c42ad2 100644
--- a/src/stmf0/altos-raw.ld
+++ b/src/stmf0/altos-raw.ld
@@ -61,10 +61,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/stmf0/altos.ld b/src/stmf0/altos.ld
index 74fdf3ea..64e1d00c 100644
--- a/src/stmf0/altos.ld
+++ b/src/stmf0/altos.ld
@@ -81,10 +81,10 @@ SECTIONS {
 	/* Data -- relocated to RAM, but written to ROM
 	 */
 	.data : {
-		__data_start__ = .;
+		_start__ = .;
 		*(.data)	/* initialized data */
 		. = ALIGN(4);
-		__data_end__ = .;
+		_end__ = .;
 	} >ram AT>rom
 
 	.bss : {
diff --git a/src/stmf0/ao_adc_stm.c b/src/stmf0/ao_adc_stm.c
index 2b23dc50..571830bb 100644
--- a/src/stmf0/ao_adc_stm.c
+++ b/src/stmf0/ao_adc_stm.c
@@ -180,7 +180,7 @@ ao_adc_one(void)
 }
 #endif
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
 	{ ao_adc_dump,	"a\0Display current ADC values" },
 #if AO_ADC_DEBUG
 	{ ao_adc_one,	"A ch\0Display one ADC channel" },
diff --git a/src/stmf0/ao_arch.h b/src/stmf0/ao_arch.h
index db6324cb..15642951 100644
--- a/src/stmf0/ao_arch.h
+++ b/src/stmf0/ao_arch.h
@@ -43,11 +43,6 @@
 
 #define ao_arch_naked_declare	__attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
diff --git a/src/stmf0/ao_beep_stm.c b/src/stmf0/ao_beep_stm.c
index 15137230..abcc116c 100644
--- a/src/stmf0/ao_beep_stm.c
+++ b/src/stmf0/ao_beep_stm.c
@@ -376,7 +376,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
 	ao_beep(beep);
 	ao_delay(ticks);
diff --git a/src/stmf0/ao_interrupt.c b/src/stmf0/ao_interrupt.c
index a67f6f1a..81878d89 100644
--- a/src/stmf0/ao_interrupt.c
+++ b/src/stmf0/ao_interrupt.c
@@ -35,7 +35,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 #if RELOCATE_INTERRUPT
 extern char __interrupt_rom__, __interrupt_start__, __interrupt_end__;
@@ -88,7 +88,7 @@ void start(void)
 	stm_syscfg.cfgr1 = (stm_syscfg.cfgr1 & ~(STM_SYSCFG_CFGR1_MEM_MODE_MASK << STM_SYSCFG_CFGR1_MEM_MODE)) |
 		(STM_SYSCFG_CFGR1_MEM_MODE_MAIN_FLASH << STM_SYSCFG_CFGR1_MEM_MODE);
 #endif
-	memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+	memcpy(&_start__, &__text_end__, &_end__ - &_start__);
 	memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
 	main();
 }
diff --git a/src/stmf0/ao_led.c b/src/stmf0/ao_led.c
index 0f39befb..a162932a 100644
--- a/src/stmf0/ao_led.c
+++ b/src/stmf0/ao_led.c
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint16_t ao_led_enable;
+uint16_t ao_led_enable;
 
 void
 ao_led_on(uint16_t colors)
@@ -76,7 +76,7 @@ ao_led_toggle(uint16_t colors)
 }
 
 void
-ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint16_t colors, uint16_t ticks) 
 {
 	ao_led_on(colors);
 	ao_delay(ticks);
diff --git a/src/stmf0/ao_storage_stm.c b/src/stmf0/ao_storage_stm.c
index 1a6198a7..17c934a5 100644
--- a/src/stmf0/ao_storage_stm.c
+++ b/src/stmf0/ao_storage_stm.c
@@ -157,7 +157,7 @@ ao_storage_device_write(uint32_t pos, void *v, uint16_t len)
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
 	if (pos >= ao_storage_total || pos + len > ao_storage_total)
 		return 0;
@@ -166,7 +166,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -179,7 +179,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 	printf ("Using internal flash, page %d bytes, total %d bytes\n",
 		ao_storage_block, ao_storage_total);
diff --git a/src/stmf0/ao_timer.c b/src/stmf0/ao_timer.c
index 50fd67b8..1def5f69 100644
--- a/src/stmf0/ao_timer.c
+++ b/src/stmf0/ao_timer.c
@@ -36,8 +36,8 @@ ao_time(void)
 }
 
 #if AO_DATA_ALL
-volatile __data uint8_t	ao_data_interval = 1;
-volatile __data uint8_t	ao_data_count;
+volatile uint8_t	ao_data_interval = 1;
+volatile uint8_t	ao_data_count;
 #endif
 
 void stm_systick_isr(void)
diff --git a/src/stmf0/ao_usb_stm.c b/src/stmf0/ao_usb_stm.c
index c4860d8e..ff294849 100644
--- a/src/stmf0/ao_usb_stm.c
+++ b/src/stmf0/ao_usb_stm.c
@@ -1626,7 +1626,7 @@ ao_usb_irq(void)
 		control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
 	{ ao_usb_irq, "I\0Show USB interrupt counts" },
 	{ 0, NULL }
 };
diff --git a/src/telefireone-v1.0/ao_telefireone.c b/src/telefireone-v1.0/ao_telefireone.c
index 115b3e91..790d7a41 100644
--- a/src/telefireone-v1.0/ao_telefireone.c
+++ b/src/telefireone-v1.0/ao_telefireone.c
@@ -31,7 +31,7 @@ set_logging(void)
 	ao_wakeup(&ao_log_running);
 }
 
-__code struct ao_cmds ao_firetwo_cmds[] = {
+const struct ao_cmds ao_firetwo_cmds[] = {
         { set_logging,  "L <0 off, 1 on>\0Log sensors to flash" },
         { 0,    NULL },
 };
diff --git a/src/telelco-v2.0/ao_lco_v2.c b/src/telelco-v2.0/ao_lco_v2.c
index a9933d59..428b1a7c 100644
--- a/src/telelco-v2.0/ao_lco_v2.c
+++ b/src/telelco-v2.0/ao_lco_v2.c
@@ -287,7 +287,7 @@ ao_lco_set_debug(void)
 		ao_lco_debug = ao_cmd_lex_i != 0;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
 	{ ao_lco_set_debug,	"D <0 off, 1 on>\0Debug" },
 	{ ao_lco_search,	"s\0Search for pad boxes" },
 	{ 0, NULL }
diff --git a/src/test/ao_aes_test.c b/src/test/ao_aes_test.c
index 135c6f1a..e1ed5728 100644
--- a/src/test/ao_aes_test.c
+++ b/src/test/ao_aes_test.c
@@ -16,11 +16,7 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #include <string.h>
 #include <stdio.h>
diff --git a/src/test/ao_eeprom_read.h b/src/test/ao_eeprom_read.h
index 03c327ca..afaadb1e 100644
--- a/src/test/ao_eeprom_read.h
+++ b/src/test/ao_eeprom_read.h
@@ -15,11 +15,7 @@
 #ifndef _AO_EEPROM_READ_H_
 #define _AO_EEPROM_READ_H_
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #include <stdint.h>
 #include <stdio.h>
diff --git a/src/test/ao_flight_test.c b/src/test/ao_flight_test.c
index 0913e7ba..a171930e 100644
--- a/src/test/ao_flight_test.c
+++ b/src/test/ao_flight_test.c
@@ -119,11 +119,7 @@ struct ao_adc {
 
 #endif
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #define HAS_FLIGHT 1
 #define HAS_IGNITE 1
diff --git a/src/test/ao_gps_test_skytraq.c b/src/test/ao_gps_test_skytraq.c
index 61e7905a..11c54601 100644
--- a/src/test/ao_gps_test_skytraq.c
+++ b/src/test/ao_gps_test_skytraq.c
@@ -83,8 +83,8 @@ struct ao_gps_tracking_orig {
 #define ao_telemetry_satellite ao_gps_tracking_orig
 #define ao_telemetry_satellite_info ao_gps_sat_orig
 
-extern __xdata struct ao_telemetry_location	ao_gps_data;
-extern __xdata struct ao_telemetry_satellite	ao_gps_tracking_data;
+extern struct ao_telemetry_location	ao_gps_data;
+extern struct ao_telemetry_satellite	ao_gps_tracking_data;
 
 uint8_t ao_gps_mutex;
 
diff --git a/src/test/ao_gps_test_ublox.c b/src/test/ao_gps_test_ublox.c
index 05334bbf..0833e4f6 100644
--- a/src/test/ao_gps_test_ublox.c
+++ b/src/test/ao_gps_test_ublox.c
@@ -89,8 +89,8 @@ struct ao_telemetry_satellite {
 #define ao_gps_tracking_orig ao_telemetry_satellite
 #define ao_gps_sat_orig ao_telemetry_satellite_info
 
-extern __xdata struct ao_telemetry_location	ao_gps_data;
-extern __xdata struct ao_telemetry_satellite	ao_gps_tracking_data;
+extern struct ao_telemetry_location	ao_gps_data;
+extern struct ao_telemetry_satellite	ao_gps_tracking_data;
 
 uint8_t ao_gps_mutex;
 
diff --git a/src/test/ao_int64_test.c b/src/test/ao_int64_test.c
index d329f67b..c7a4891f 100644
--- a/src/test/ao_int64_test.c
+++ b/src/test/ao_int64_test.c
@@ -16,10 +16,6 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __data
-#define __pdata
-#define __xdata
-#define __reentrant
 
 #include <ao_int64.h>
 #include <ao_int64.c>
diff --git a/src/test/ao_ms5607_convert_test.c b/src/test/ao_ms5607_convert_test.c
index 4876d21e..7708c331 100644
--- a/src/test/ao_ms5607_convert_test.c
+++ b/src/test/ao_ms5607_convert_test.c
@@ -16,10 +16,6 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __xdata
-#define __data
-#define __pdata
-#define __reentrant
 
 #include <stdint.h>
 #include <ao_ms5607.h>
diff --git a/src/usbrelay-v0.1/ao_usbrelay.c b/src/usbrelay-v0.1/ao_usbrelay.c
index d908f4db..0eacdf5a 100644
--- a/src/usbrelay-v0.1/ao_usbrelay.c
+++ b/src/usbrelay-v0.1/ao_usbrelay.c
@@ -45,7 +45,7 @@ ao_relay_control(uint8_t output)
 }
 
 static void
-ao_relay_select(void) __reentrant
+ao_relay_select(void) 
 {
 	uint8_t output;
 
@@ -59,7 +59,7 @@ ao_relay_select(void) __reentrant
 		ao_relay_control(output);
 }
 
-static __code struct ao_cmds ao_relay_cmds[] = {
+static const struct ao_cmds ao_relay_cmds[] = {
 	{ ao_relay_select, "R <output>\0Select relay output" },
 	{ 0, NULL }
 };