altos: Remove 8051 address space specifiers

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

65 files changed, 538 insertions, 542 deletions

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_ */