altos: Remove 8051 address space specifiers
authorKeith Packard <keithp@keithp.com>
Thu, 16 Aug 2018 00:47:37 +0000 (17:47 -0700)
committerKeith Packard <keithp@keithp.com>
Sat, 13 Oct 2018 15:22:50 +0000 (08:22 -0700)
Signed-off-by: Keith Packard <keithp@keithp.com>
172 files changed:
src/aes/ao_aes.c
src/attiny/ao_arch.h
src/attiny/ao_arch_funcs.h
src/attiny/ao_i2c_attiny.c
src/attiny/ao_led.c
src/attiny/ao_spi_attiny.c
src/avr/ao_adc_avr.c
src/avr/ao_arch.h
src/avr/ao_arch_funcs.h
src/avr/ao_eeprom_avr.c
src/avr/ao_i2c_usart.c
src/avr/ao_led.c
src/avr/ao_pwmin.c
src/avr/ao_pwmin.h
src/avr/ao_serial_avr.c
src/avr/ao_spi_usart.c
src/avr/ao_timer.c
src/avr/ao_usb_avr.c
src/cortexelf-v1/ao_cortexelf.c
src/cortexelf-v1/cortexelf.ld
src/drivers/ao_25lc1024.c
src/drivers/ao_74hc165.c
src/drivers/ao_74hc497.c
src/drivers/ao_at24c.c
src/drivers/ao_at45db161d.c
src/drivers/ao_btm.c
src/drivers/ao_cc1120.c
src/drivers/ao_cc1200.c
src/drivers/ao_companion.c
src/drivers/ao_gps_sirf.c
src/drivers/ao_gps_skytraq.c
src/drivers/ao_gps_ublox.c
src/drivers/ao_lcd.c
src/drivers/ao_lco.c
src/drivers/ao_lco_cmd.c
src/drivers/ao_lco_func.c
src/drivers/ao_lco_two.c
src/drivers/ao_m25.c
src/drivers/ao_mma655x.c
src/drivers/ao_mr25.c
src/drivers/ao_ms5607.c
src/drivers/ao_ms5607.h
src/drivers/ao_ms5607_convert_8051.c
src/drivers/ao_packet.c
src/drivers/ao_packet_master.c
src/drivers/ao_pad.c
src/drivers/ao_pca9922.c
src/drivers/ao_pyro_slave.c
src/drivers/ao_quadrature.c
src/drivers/ao_quadrature.h
src/drivers/ao_radio_master.c
src/drivers/ao_radio_slave.c
src/drivers/ao_watchdog.c
src/kernel/ao.h
src/kernel/ao_aes.h
src/kernel/ao_balloon.c
src/kernel/ao_beep.h
src/kernel/ao_cmd.c
src/kernel/ao_companion.h
src/kernel/ao_config.c
src/kernel/ao_config.h
src/kernel/ao_convert.c
src/kernel/ao_data.c
src/kernel/ao_data.h
src/kernel/ao_ee_fake.c
src/kernel/ao_eeprom.h
src/kernel/ao_flight.c
src/kernel/ao_flight.h
src/kernel/ao_flight_nano.c
src/kernel/ao_forward.c
src/kernel/ao_forward.h
src/kernel/ao_freq.c
src/kernel/ao_gps_print.c
src/kernel/ao_gps_report.c
src/kernel/ao_gps_report_mega.c
src/kernel/ao_gps_report_metrum.c
src/kernel/ao_gps_show.c
src/kernel/ao_host.h
src/kernel/ao_ignite.c
src/kernel/ao_int64.c
src/kernel/ao_int64.h
src/kernel/ao_kalman.c
src/kernel/ao_led.h
src/kernel/ao_log.c
src/kernel/ao_log.h
src/kernel/ao_log_big.c
src/kernel/ao_log_fireone.c
src/kernel/ao_log_mega.c
src/kernel/ao_log_metrum.c
src/kernel/ao_log_mini.c
src/kernel/ao_log_single.c
src/kernel/ao_log_telem.c
src/kernel/ao_log_telescience.c
src/kernel/ao_log_tiny.c
src/kernel/ao_monitor.c
src/kernel/ao_mutex.c
src/kernel/ao_notask.c
src/kernel/ao_notask.h
src/kernel/ao_packet.h
src/kernel/ao_pyro.c
src/kernel/ao_radio_cmac.c
src/kernel/ao_radio_cmac.h
src/kernel/ao_radio_cmac_cmd.c
src/kernel/ao_report.c
src/kernel/ao_report_micro.c
src/kernel/ao_rssi.c
src/kernel/ao_sample.c
src/kernel/ao_sample.h
src/kernel/ao_sample_profile.c
src/kernel/ao_send_packet.c
src/kernel/ao_serial.h
src/kernel/ao_stdio.c
src/kernel/ao_storage.c
src/kernel/ao_storage.h
src/kernel/ao_task.c
src/kernel/ao_task.h
src/kernel/ao_telemetry.c
src/kernel/ao_usb.h
src/lpc/altos-loader.ld
src/lpc/altos-standalone.ld
src/lpc/altos.ld
src/lpc/ao_adc_lpc.c
src/lpc/ao_arch.h
src/lpc/ao_beep_lpc.c
src/lpc/ao_interrupt.c
src/lpc/ao_led_lpc.c
src/lpc/ao_timer_lpc.c
src/lpc/ao_usb_lpc.c
src/micropeak-v2.0/micropeak.ld
src/nucleao-32/load.ld
src/pnpservo-v1/lambda.ld
src/product/ao_flash_task.c
src/product/ao_terraui.c
src/product/ao_test.c
src/stm-bringup/bringup.ld
src/stm-demo/ao_demo.c
src/stm-scheme-newlib/ao_demo.c
src/stm-vga/ao_demo.c
src/stm/altos-512.ld
src/stm/altos-loader.ld
src/stm/altos-ram.ld
src/stm/altos.ld
src/stm/ao_adc_single_stm.c
src/stm/ao_adc_stm.c
src/stm/ao_arch.h
src/stm/ao_beep_stm.c
src/stm/ao_eeprom_stm.c
src/stm/ao_interrupt.c
src/stm/ao_led.c
src/stm/ao_timer.c
src/stm/ao_usb_stm.c
src/stmf0/altos-loader.ld
src/stmf0/altos-raw.ld
src/stmf0/altos.ld
src/stmf0/ao_adc_stm.c
src/stmf0/ao_arch.h
src/stmf0/ao_beep_stm.c
src/stmf0/ao_interrupt.c
src/stmf0/ao_led.c
src/stmf0/ao_storage_stm.c
src/stmf0/ao_timer.c
src/stmf0/ao_usb_stm.c
src/telefireone-v1.0/ao_telefireone.c
src/telelco-v2.0/ao_lco_v2.c
src/test/ao_aes_test.c
src/test/ao_eeprom_read.h
src/test/ao_flight_test.c
src/test/ao_gps_test_skytraq.c
src/test/ao_gps_test_ublox.c
src/test/ao_int64_test.c
src/test/ao_ms5607_convert_test.c
src/usbrelay-v0.1/ao_usbrelay.c

index fd90c5b..0bc8188 100644 (file)
@@ -372,7 +372,7 @@ ao_aes_set_mode(enum ao_aes_mode mode)
 }
 
 void
-ao_aes_set_key(__xdata uint8_t *in)
+ao_aes_set_key(uint8_t *in)
 {
        memcpy(key, in, 16);
        xrijndaelKeySched((word32 *) key, 128, 128, &rkk);
@@ -385,8 +385,8 @@ ao_aes_zero_iv(void)
 }
 
 void
-ao_aes_run(__xdata uint8_t *in,
-          __xdata uint8_t *out)
+ao_aes_run(uint8_t *in,
+          uint8_t *out)
 {
        uint8_t i;
        uint8_t *_iv = (uint8_t *) iv;
index 68f5702..84a94be 100644 (file)
 
 #define ao_arch_naked_declare  __attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
-#define __critical
 #define __interrupt(n)
 #define __at(n)
 
index 0b67a40..3590115 100644 (file)
 
 
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_send_bus(void *block, uint16_t len);
 
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_recv_bus(void *block, uint16_t len);
 
 #define ao_spi_send(block, len, bus) ao_spi_send_bus(block, len)
 #define ao_spi_recv(block, len, bus) ao_spi_recv_bus(block, len)
@@ -110,10 +110,10 @@ ao_i2c_init(void);
 /* notask.c */
 
 uint8_t
-ao_sleep(__xdata void *wchan);
+ao_sleep(void *wchan);
 
 void
-ao_wakeup(__xdata void *wchan);
+ao_wakeup(void *wchan);
 
 extern alt_t   ao_max_height;
 
index f29ed6a..34185b5 100644 (file)
@@ -173,7 +173,7 @@ ao_i2c_stop_bus(void)
  * so using interrupts would take way too long
  */
 uint8_t
-ao_i2c_send_bus(void __xdata *block, uint16_t len, uint8_t stop)
+ao_i2c_send_bus(void *block, uint16_t len, uint8_t stop)
 {
        uint8_t *d = block;
 
@@ -206,7 +206,7 @@ ao_i2c_send_fixed_bus(uint8_t d, uint16_t len, uint8_t stop)
  * Poll, sending zeros and reading data back
  */
 uint8_t
-ao_i2c_recv_bus(void __xdata *block, uint16_t len, uint8_t stop)
+ao_i2c_recv_bus(void *block, uint16_t len, uint8_t stop)
 {
        uint8_t *d = block;
 
index 5f53129..8850549 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint8_t ao_led_enable;
+uint8_t ao_led_enable;
 
 #define LED_PORT       PORTB
 #define LED_DDR                DDRB
@@ -48,7 +48,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index f63eb65..1c90ad5 100644 (file)
@@ -82,7 +82,7 @@ ao_spi_transfer(uint8_t i)
  * so using interrupts would take way too long
  */
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_send_bus(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
@@ -95,7 +95,7 @@ ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
  * Poll, sending zeros and reading data back
  */
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_recv_bus(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
index 2732c4d..2aae95a 100644 (file)
@@ -19,8 +19,8 @@
 #include "ao.h"
 #include "ao_pwmin.h"
 
-volatile __xdata struct ao_data        ao_data_ring[AO_DATA_RING];
-volatile __data uint8_t                ao_data_head;
+volatile struct ao_data        ao_data_ring[AO_DATA_RING];
+volatile uint8_t               ao_data_head;
 
 #ifdef TELESCIENCE
 const uint8_t  adc_channels[AO_LOG_TELESCIENCE_NUM_ADC] = {
@@ -119,16 +119,16 @@ ao_adc_poll(void)
 }
 
 void
-ao_data_get(__xdata struct ao_data *packet)
+ao_data_get(struct ao_data *packet)
 {
        uint8_t i = ao_data_ring_prev(ao_data_head);
        memcpy(packet, (void *) &ao_data_ring[i], sizeof (struct ao_data));
 }
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
-       static __xdata struct ao_data   packet;
+       static struct ao_data   packet;
        uint8_t i;
        ao_data_get(&packet);
        printf("tick: %5u",  packet.tick);
@@ -137,7 +137,7 @@ ao_adc_dump(void) __reentrant
        printf("\n");
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
        { ao_adc_dump,  "a\0ADC" },
        { 0, NULL },
 };
index 2b1da64..6166c50 100644 (file)
 
 #define ao_arch_naked_declare  __attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
-#define __critical
 #define __interrupt(n)
 #define __at(n)
 
index 891ad9b..dc24866 100644 (file)
@@ -20,7 +20,7 @@
  * ao_spi.c
  */
 
-extern __xdata uint8_t ao_spi_mutex;
+extern uint8_t ao_spi_mutex;
 
 #define ao_spi_get_mask(reg,mask,bus,speed) do {       \
                ao_mutex_get(&ao_spi_mutex);    \
@@ -66,10 +66,10 @@ extern __xdata uint8_t      ao_spi_mutex;
 
 
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_send_bus(void *block, uint16_t len);
 
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant;
+ao_spi_recv_bus(void *block, uint16_t len);
 
 #define ao_spi_send(block, len, bus) ao_spi_send_bus(block, len)
 #define ao_spi_recv(block, len, bus) ao_spi_recv_bus(block, len)
index 2fdf177..84942cd 100644 (file)
 #include <ao_storage.h>
 
 /* Total bytes of available storage */
-__pdata ao_pos_t       ao_storage_total = 1024;
+ao_pos_t       ao_storage_total = 1024;
 
 /* Block size - device is erased in these units. */
-__pdata ao_pos_t       ao_storage_block = 1024;
+ao_pos_t       ao_storage_block = 1024;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata ao_pos_t       ao_storage_config = 0;
+ao_pos_t       ao_storage_config = 0;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. */
-__pdata uint16_t       ao_storage_unit = 1024;
+uint16_t       ao_storage_unit = 1024;
 
 /*
  * The internal flash chip is arranged in 8 byte sectors; the
@@ -45,7 +45,7 @@ __pdata uint16_t      ao_storage_unit = 1024;
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(ao_pos_t pos) __reentrant
+ao_storage_erase(ao_pos_t pos) 
 {
        /* Not necessary */
        return 1;
@@ -83,10 +83,10 @@ ao_intflash_read(uint16_t pos)
  */
 
 uint8_t
-ao_storage_device_write(ao_pos_t pos32, __xdata void *v, uint16_t len) __reentrant
+ao_storage_device_write(ao_pos_t pos32, void *v, uint16_t len) 
 {
        uint16_t pos = pos32;
-       __xdata uint8_t *d = v;
+       uint8_t *d = v;
 
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -101,7 +101,7 @@ ao_storage_device_write(ao_pos_t pos32, __xdata void *v, uint16_t len) __reentra
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(ao_pos_t pos, __xdata void *v, uint16_t len) __reentrant
+ao_storage_device_read(ao_pos_t pos, void *v, uint16_t len) 
 {
        uint8_t *d = v;
        
@@ -113,7 +113,7 @@ ao_storage_device_read(ao_pos_t pos, __xdata void *v, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -123,7 +123,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
        printf ("Using internal flash\n");
 }
index c95548d..67bee33 100644 (file)
@@ -22,7 +22,7 @@
  * Atmega32u4 TWI master mode (I2C)
  */
 
-__xdata uint8_t        ao_i2c_mutex;
+uint8_t        ao_i2c_mutex;
 
 /* Send bytes over I2C.
  *
@@ -30,7 +30,7 @@ __xdata uint8_t       ao_i2c_mutex;
  * so using interrupts would take way too long
  */
 void
-ao_i2c_send(void __xdata *block, uint16_t len) __reentrant
+ao_i2c_send(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
@@ -51,7 +51,7 @@ ao_i2c_send(void __xdata *block, uint16_t len) __reentrant
  * clocks the data coming in.
  */
 void
-ao_i2c_recv(void __xdata *block, uint16_t len) __reentrant
+ao_i2c_recv(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
index 8eba489..165e95d 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint8_t ao_led_enable;
+uint8_t ao_led_enable;
 
 #define LED_PORT       PORTB
 #define LED_DDR                DDRB
@@ -48,7 +48,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index 5eb392a..2d83380 100644 (file)
@@ -26,8 +26,8 @@
  * project payload developed at Challenger Middle School.  
  */
 
-volatile __data uint16_t ao_icp3_count = 0;
-volatile __data uint16_t ao_icp3_last = 0;
+volatile uint16_t ao_icp3_count = 0;
+volatile uint16_t ao_icp3_last = 0;
 
 uint16_t ao_icp3(void)
 {
@@ -39,7 +39,7 @@ uint16_t ao_icp3(void)
 }
 
 static void
-ao_pwmin_display(void) __reentrant
+ao_pwmin_display(void) 
 {
        /* display the most recent value */
        printf("icp 3: %5u\n", ao_icp3());
@@ -62,7 +62,7 @@ ISR(TIMER3_CAPT_vect)
        ao_icp3_last = ao_icp3_this;
 }
 
-__code struct ao_cmds ao_pwmin_cmds[] = {
+const struct ao_cmds ao_pwmin_cmds[] = {
        { ao_pwmin_display,     "p\0PWM input" },
        { 0, NULL },
 };
index 43c12f5..fcb5e26 100644 (file)
@@ -18,4 +18,4 @@
 
 void ao_pwmin_init(void);
 
-extern volatile __data uint16_t ao_icp3_count;
+extern volatile uint16_t ao_icp3_count;
index ab82b7b..cfdd7df 100644 (file)
@@ -18,8 +18,8 @@
 
 #include "ao.h"
 
-__xdata struct ao_fifo ao_serial1_rx_fifo;
-__xdata struct ao_fifo ao_serial1_tx_fifo;
+struct ao_fifo ao_serial1_rx_fifo;
+struct ao_fifo ao_serial1_tx_fifo;
 
 void
 ao_debug_out(char c)
@@ -40,7 +40,7 @@ ISR(USART1_RX_vect)
 #endif
 }
 
-static __xdata uint8_t ao_serial_tx1_started;
+static uint8_t ao_serial_tx1_started;
 
 static void
 ao_serial1_tx_start(void)
@@ -75,7 +75,7 @@ _ao_serial1_pollchar(void)
 #endif
 
 char
-ao_serial1_getchar(void) __critical
+ao_serial1_getchar(void) 
 {
        char    c;
 
@@ -99,7 +99,7 @@ ao_serial1_putchar(char c)
 }
 
 void
-ao_serial1_drain(void) __critical
+ao_serial1_drain(void) 
 {
        ao_arch_block_interrupts();
        while (!ao_fifo_empty(ao_serial1_tx_fifo))
index 0d509cb..6c30b02 100644 (file)
@@ -22,7 +22,7 @@
  * Atmega32u4 USART in MSPIM (master SPI mode)
  */
 
-__xdata uint8_t        ao_spi_mutex;
+uint8_t        ao_spi_mutex;
 
 /* Send bytes over SPI.
  *
@@ -30,7 +30,7 @@ __xdata uint8_t       ao_spi_mutex;
  * so using interrupts would take way too long
  */
 void
-ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_send_bus(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
@@ -47,7 +47,7 @@ ao_spi_send_bus(void __xdata *block, uint16_t len) __reentrant
  * Poll, sending zeros and reading data back
  */
 void
-ao_spi_recv_bus(void __xdata *block, uint16_t len) __reentrant
+ao_spi_recv_bus(void *block, uint16_t len) 
 {
        uint8_t *d = block;
 
index 2eaa8b6..ff6a829 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-volatile __data uint16_t ao_tick_count;
+volatile uint16_t ao_tick_count;
 
 uint16_t ao_time(void)
 {
@@ -33,8 +33,8 @@ uint16_t ao_time(void)
 #define T1_SAMPLE_TIME         30000   /* 3e6/30000 = 100 */
 
 #if HAS_ADC
-volatile __data uint8_t        ao_adc_interval = 1;
-volatile __data uint8_t        ao_adc_count;
+volatile uint8_t       ao_adc_interval = 1;
+volatile uint8_t       ao_adc_count;
 #endif
 
 void
@@ -53,7 +53,7 @@ ISR(TIMER1_COMPA_vect)
 
 #if HAS_ADC
 void
-ao_timer_set_adc_interval(uint8_t interval) __critical
+ao_timer_set_adc_interval(uint8_t interval) 
 {
        ao_adc_interval = interval;
        ao_adc_count = 0;
index 41d3c1b..df80099 100644 (file)
@@ -27,7 +27,7 @@
 #define debug(format, args...)
 #endif
 
-struct ao_task __xdata ao_usb_task;
+struct ao_task ao_usb_task;
 
 struct ao_usb_setup {
        uint8_t         dir_type_recip;
@@ -35,21 +35,21 @@ struct ao_usb_setup {
        uint16_t        value;
        uint16_t        index;
        uint16_t        length;
-} __xdata ao_usb_setup;
-
-static __xdata uint8_t         ao_usb_ep0_state;
-static const uint8_t * __xdata ao_usb_ep0_in_data;
-static __xdata uint8_t         ao_usb_ep0_in_len;
-static __xdata uint8_t ao_usb_ep0_in_pending;
-static __xdata uint8_t ao_usb_addr_pending;
-static __xdata uint8_t ao_usb_ep0_in_buf[2];
-static __xdata uint8_t         ao_usb_ep0_out_len;
-static __xdata uint8_t *__xdata ao_usb_ep0_out_data;
-
-static __xdata uint8_t ao_usb_in_flushed;
-__xdata uint8_t                ao_usb_running;
-static __xdata uint8_t ao_usb_configuration;
-static __xdata uint8_t ueienx_0;
+} ao_usb_setup;
+
+static uint8_t         ao_usb_ep0_state;
+static const uint8_t * ao_usb_ep0_in_data;
+static uint8_t         ao_usb_ep0_in_len;
+static uint8_t ao_usb_ep0_in_pending;
+static uint8_t ao_usb_addr_pending;
+static uint8_t ao_usb_ep0_in_buf[2];
+static uint8_t         ao_usb_ep0_out_len;
+static uint8_t *ao_usb_ep0_out_data;
+
+static uint8_t ao_usb_in_flushed;
+uint8_t                ao_usb_running;
+static uint8_t ao_usb_configuration;
+static uint8_t ueienx_0;
 
 void
 ao_usb_set_address(uint8_t address)
@@ -143,9 +143,9 @@ struct ao_usb_line_coding ao_usb_line_coding = {115200, 0, 0, 8};
 static void
 ao_usb_get_descriptor(uint16_t value)
 {
-       const uint8_t           *__xdata descriptor;
-       __xdata uint8_t         type = value >> 8;
-       __xdata uint8_t         index = value;
+       const uint8_t           *descriptor;
+       uint8_t         type = value >> 8;
+       uint8_t         index = value;
 
        descriptor = ao_usb_descriptors;
        while (descriptor[0] != 0) {
@@ -174,7 +174,7 @@ ao_usb_ep0_set_in_pending(uint8_t in_pending)
 static void
 ao_usb_ep0_flush(void)
 {
-       __xdata uint8_t this_len;
+       uint8_t this_len;
 
        cli();
        UENUM = 0;
@@ -242,7 +242,7 @@ static void
 ao_usb_ep0_setup(void)
 {
        /* Pull the setup packet out of the fifo */
-       ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_setup;
+       ao_usb_ep0_out_data = (uint8_t *) &ao_usb_setup;
        ao_usb_ep0_out_len = 8;
        ao_usb_ep0_fill(8, (1 << RXSTPI) | (1 << RXOUTI) | (1 << TXINI));
        if (ao_usb_ep0_out_len != 0) {
@@ -334,7 +334,7 @@ ao_usb_ep0_setup(void)
                case AO_USB_SET_LINE_CODING:
                        debug ("set line coding\n");
                        ao_usb_ep0_out_len = 7;
-                       ao_usb_ep0_out_data = (__xdata uint8_t *) &ao_usb_line_coding;
+                       ao_usb_ep0_out_data = (uint8_t *) &ao_usb_line_coding;
                        break;
                case AO_USB_GET_LINE_CODING:
                        debug ("get line coding\n");
@@ -636,7 +636,7 @@ ao_usb_enable(void)
 }
 
 #if USB_DEBUG
-struct ao_task __xdata ao_usb_echo_task;
+struct ao_task ao_usb_echo_task;
 
 static void
 ao_usb_echo(void)
index 5ed78bf..6bc2624 100644 (file)
@@ -218,7 +218,7 @@ led_cmd(void)
        ao_as1107_write_8(start, value);
 }
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
        { ao_video_toggle, "V\0Toggle video" },
        { ao_ball_toggle, "B\0Toggle ball" },
        { ao_ps2_read_keys, "K\0Read keys from keyboard" },
index 6ad2a67..069fe5b 100644 (file)
@@ -75,10 +75,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index a9c897b..c73f54d 100644 (file)
 #define EE_DEVICE_SIZE ((uint32_t) 128 * (uint32_t) 1024)
 
 /* Total bytes of available storage */
-__pdata uint32_t       ao_storage_total;
+uint32_t       ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t       ao_storage_block;
+uint32_t       ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t       ao_storage_config;
+uint32_t       ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t       ao_storage_unit;
+uint16_t       ao_storage_unit;
 
 /*
  * Using SPI on USART 0, with P1_2 as the chip select
@@ -43,7 +43,7 @@ __pdata uint16_t      ao_storage_unit;
 #define EE_CS          P1_2
 #define EE_CS_PIN      2
 
-static __xdata uint8_t ao_ee_mutex;
+static uint8_t ao_ee_mutex;
 
 #define ao_ee_delay() do { \
        _asm nop _endasm; \
@@ -58,7 +58,7 @@ static __xdata uint8_t ao_ee_mutex;
 struct ao_ee_instruction {
        uint8_t instruction;
        uint8_t address[3];
-} __xdata ao_ee_instruction;
+} ao_ee_instruction;
 
 static void
 ao_ee_write_enable(void)
@@ -92,9 +92,9 @@ ao_ee_wrsr(uint8_t status)
 
 #define EE_BLOCK_NONE  0xffff
 
-static __xdata uint8_t ao_ee_data[EE_BLOCK_SIZE];
-static __pdata uint16_t ao_ee_block = EE_BLOCK_NONE;
-static __pdata uint8_t ao_ee_block_dirty;
+static uint8_t ao_ee_data[EE_BLOCK_SIZE];
+static uint16_t ao_ee_block = EE_BLOCK_NONE;
+static uint8_t ao_ee_block_dirty;
 
 /* Write the current block to the EEPROM */
 static void
@@ -157,7 +157,7 @@ ao_ee_fill(uint16_t block)
 }
 
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *buf, uint16_t len) 
 {
        uint16_t block = (uint16_t) (pos >> EE_BLOCK_SHIFT);
 
@@ -176,7 +176,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentra
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *buf, uint16_t len) 
 {
        uint16_t block = (uint16_t) (pos >> EE_BLOCK_SHIFT);
 
@@ -189,7 +189,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentran
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
        ao_mutex_get(&ao_ee_mutex); {
                ao_ee_flush_internal();
@@ -197,7 +197,7 @@ ao_storage_flush(void) __reentrant
 }
 
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
        ao_mutex_get(&ao_ee_mutex); {
                ao_ee_flush_internal();
@@ -209,7 +209,7 @@ ao_storage_erase(uint32_t pos) __reentrant
 }
 
 static void
-ee_store(void) __reentrant
+ee_store(void) 
 {
 }
 
@@ -225,7 +225,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 }
 
index 8842801..b62e013 100644 (file)
@@ -27,7 +27,7 @@
 uint8_t
 ao_74hc165_read(void)
 {
-       static __xdata state;
+       static state;
        ao_spi_get(AO_74HC165_SPI_BUS);
        ao_spi_set_speed(AO_74HC165_SPI_BUS, AO_SPI_SPEED_FAST);
        AO_74HC165_CS = 1;
index b3fd3c9..e8c3943 100644 (file)
@@ -27,7 +27,7 @@
 uint8_t
 ao_74hc497_read(void)
 {
-       static __xdata state;
+       static state;
        ao_spi_get_bit(AO_74HC497_CS_PORT, AO_74HC497_CS_PIN, AO_74HC497_CS, AO_74HC497_SPI_BUS, AO_SPI_SPEED_FAST);
        ao_spi_recv(&state, 1, AO_74HC497_SPI_BUS);
        ao_spi_put_bit(AO_74HC497_CS_PORT, AO_74HC497_CS_PIN, AO_74HC497_CS, AO_74HC497_SPI_BUS);
index 8f91e3c..16141c7 100644 (file)
 #define AO_AT24C_PAGE_LEN      128
 
 /* Total bytes of available storage */
-__pdata ao_pos_t       ao_storage_total = 64l * 1024l;
+ao_pos_t       ao_storage_total = 64l * 1024l;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. */
-__pdata uint16_t       ao_storage_unit = 128;
+uint16_t       ao_storage_unit = 128;
 
 static void
 ao_at24c_set_address(uint8_t addr, ao_pos_t pos)
@@ -45,7 +45,7 @@ ao_at24c_set_address(uint8_t addr, ao_pos_t pos)
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(ao_pos_t pos) __reentrant
+ao_storage_erase(ao_pos_t pos) 
 {
        if (pos >= ao_storage_total || pos + AO_AT24C_PAGE_LEN > ao_storage_total)
                return 0;
@@ -61,7 +61,7 @@ ao_storage_erase(ao_pos_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(ao_pos_t pos, void *d, uint16_t len) 
 {
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -77,7 +77,7 @@ ao_storage_device_write(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(ao_pos_t pos, void *d, uint16_t len) 
 {
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -89,7 +89,7 @@ ao_storage_device_read(ao_pos_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
index abba3f1..516811b 100644 (file)
 #include "ao_at45db161d.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t       ao_storage_total;
+uint32_t       ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t       ao_storage_block;
+uint32_t       ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t       ao_storage_config;
+uint32_t       ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t       ao_storage_unit;
+uint16_t       ao_storage_unit;
 
 #define FLASH_CS               P1_1
 #define FLASH_CS_INDEX         1
 
 #define FLASH_BLOCK_SIZE_MAX   512
 
-__xdata uint8_t ao_flash_mutex;
+uint8_t ao_flash_mutex;
 
 #define ao_flash_delay() do { \
        _asm nop _endasm; \
@@ -51,7 +51,7 @@ __xdata uint8_t ao_flash_mutex;
 struct ao_flash_instruction {
        uint8_t instruction;
        uint8_t address[3];
-} __xdata ao_flash_instruction;
+} ao_flash_instruction;
 
 static void
 ao_flash_set_pagesize_512(void)
@@ -79,17 +79,17 @@ ao_flash_read_status(void)
 
 #define FLASH_BLOCK_NONE       0xffff
 
-static __xdata uint8_t ao_flash_data[FLASH_BLOCK_SIZE_MAX];
-static __pdata uint16_t ao_flash_block = FLASH_BLOCK_NONE;
-static __pdata uint8_t ao_flash_block_dirty;
-static __pdata uint8_t  ao_flash_write_pending;
-static __pdata uint8_t ao_flash_setup_done;
-static __pdata uint8_t ao_flash_block_shift;
-static __pdata uint16_t        ao_flash_block_size;
-static __pdata uint16_t        ao_flash_block_mask;
+static uint8_t ao_flash_data[FLASH_BLOCK_SIZE_MAX];
+static uint16_t ao_flash_block = FLASH_BLOCK_NONE;
+static uint8_t ao_flash_block_dirty;
+static uint8_t  ao_flash_write_pending;
+static uint8_t ao_flash_setup_done;
+static uint8_t ao_flash_block_shift;
+static uint16_t        ao_flash_block_size;
+static uint16_t        ao_flash_block_mask;
 
 void
-ao_storage_setup(void) __reentrant
+ao_storage_setup(void) 
 {
        uint8_t status;
 
@@ -234,7 +234,7 @@ ao_flash_fill(uint16_t block)
 }
 
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *buf, uint16_t len) 
 {
        uint16_t block = (uint16_t) (pos >> ao_flash_block_shift);
 
@@ -255,7 +255,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *buf, uint16_t len) __reentra
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *buf, uint16_t len) 
 {
        uint16_t block = (uint16_t) (pos >> ao_flash_block_shift);
 
@@ -270,7 +270,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *buf, uint16_t len) __reentran
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
        ao_mutex_get(&ao_flash_mutex); {
                ao_flash_flush_internal();
@@ -278,7 +278,7 @@ ao_storage_flush(void) __reentrant
 }
 
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
        ao_mutex_get(&ao_flash_mutex); {
                ao_flash_flush_internal();
@@ -290,7 +290,7 @@ ao_storage_erase(uint32_t pos) __reentrant
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
        uint8_t status;
 
index c65a854..3591f8f 100644 (file)
 #endif
 
 int8_t                 ao_btm_stdio;
-__xdata uint8_t                ao_btm_connected;
+uint8_t                ao_btm_connected;
 
 #define BT_DEBUG 0
 
 #if BT_DEBUG
-__xdata char           ao_btm_buffer[256];
+char           ao_btm_buffer[256];
 uint16_t               ao_btm_ptr;
 char                   ao_btm_dir;
 
@@ -137,7 +137,7 @@ ao_btm_send(void)
        ao_wakeup((void *) &ao_serial_btm_rx_fifo);
 }
 
-__code struct ao_cmds ao_btm_cmds[] = {
+const struct ao_cmds ao_btm_cmds[] = {
        { ao_btm_dump,          "d\0Dump btm buffer." },
        { ao_btm_speed,         "s <19200,57600>\0Set btm serial speed." },
        { ao_btm_send,          "S\0BTM interactive mode. ~ to exit." },
@@ -153,7 +153,7 @@ __code struct ao_cmds ao_btm_cmds[] = {
 #endif
 
 #define AO_BTM_MAX_REPLY       16
-__xdata char           ao_btm_reply[AO_BTM_MAX_REPLY];
+char           ao_btm_reply[AO_BTM_MAX_REPLY];
 
 /*
  * Read one bluetooth character.
@@ -252,7 +252,7 @@ ao_btm_wait_reply(void)
 }
 
 void
-ao_btm_string(__code char *cmd)
+ao_btm_string(const char *cmd)
 {
        char    c;
 
@@ -261,7 +261,7 @@ ao_btm_string(__code char *cmd)
 }
 
 uint8_t
-ao_btm_cmd(__code char *cmd)
+ao_btm_cmd(const char *cmd)
 {
        ao_btm_drain();
 
@@ -351,7 +351,7 @@ ao_btm_check_link()
 #endif
 }
 
-__xdata struct ao_task ao_btm_task;
+struct ao_task ao_btm_task;
 
 /*
  * A thread to initialize the bluetooth device and
index 2f09148..d581c24 100644 (file)
@@ -1066,7 +1066,7 @@ ao_radio_rx_wait(void)
 }
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
        uint8_t         len;
        uint8_t         radio_rssi = 0;
index de28200..f2f9c37 100644 (file)
@@ -988,7 +988,7 @@ ao_radio_dump_state(struct ao_radio_state *s)
 #endif
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
        uint8_t success = 0;
 
index 598b581..3967090 100644 (file)
                               AO_COMPANION_SPI_BUS);   \
        } while (0)
 
-__xdata struct ao_companion_command            ao_companion_command;
-__xdata struct ao_companion_setup              ao_companion_setup;
+struct ao_companion_command            ao_companion_command;
+struct ao_companion_setup              ao_companion_setup;
 
-__xdata uint16_t       ao_companion_data[AO_COMPANION_MAX_CHANNELS];
-__pdata uint8_t                ao_companion_running;
-__xdata uint8_t                ao_companion_mutex;
+uint16_t       ao_companion_data[AO_COMPANION_MAX_CHANNELS];
+uint8_t                ao_companion_running;
+uint8_t                ao_companion_mutex;
 
 static void
 ao_companion_send_command(uint8_t command)
@@ -116,7 +116,7 @@ ao_companion(void)
 }
 
 void
-ao_companion_status(void) __reentrant
+ao_companion_status(void) 
 {
        uint8_t i;
        printf("Companion running: %d\n", ao_companion_running);
@@ -134,12 +134,12 @@ ao_companion_status(void) __reentrant
        printf("\n");
 }
 
-__code struct ao_cmds ao_companion_cmds[] = {
+const struct ao_cmds ao_companion_cmds[] = {
        { ao_companion_status,  "L\0Companion link status" },
        { 0, NULL },
 };
 
-static __xdata struct ao_task ao_companion_task;
+static struct ao_task ao_companion_task;
 
 void
 ao_companion_init(void)
index 8bebd61..bdd9410 100644 (file)
 #include "ao.h"
 #endif
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location   ao_gps_data;
-__xdata struct ao_telemetry_satellite  ao_gps_tracking_data;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location   ao_gps_data;
+struct ao_telemetry_satellite  ao_gps_tracking_data;
 
 static const char ao_gps_set_nmea[] = "\r\n$PSRF100,0,57600,8,1,0*37\r\n";
 
@@ -107,7 +107,7 @@ struct sirf_geodetic_nav_data {
        uint8_t         hdop;
 };
 
-static __xdata struct sirf_geodetic_nav_data   ao_sirf_data;
+static struct sirf_geodetic_nav_data   ao_sirf_data;
 
 struct sirf_measured_sat_data {
        uint8_t         svid;
@@ -121,10 +121,10 @@ struct sirf_measured_tracker_data {
        struct sirf_measured_sat_data   sats[12];
 };
 
-static __xdata struct sirf_measured_tracker_data       ao_sirf_tracker_data;
+static struct sirf_measured_tracker_data       ao_sirf_tracker_data;
 
-static __pdata uint16_t ao_sirf_cksum;
-static __pdata uint16_t ao_sirf_len;
+static uint16_t ao_sirf_cksum;
+static uint16_t ao_sirf_len;
 
 #ifndef ao_sirf_getchar
 #define ao_sirf_getchar                ao_serial1_getchar
@@ -142,11 +142,11 @@ static uint8_t data_byte(void)
        return c;
 }
 
-static char __xdata *sirf_target;
+static char *sirf_target;
 
 static void sirf_u16(uint8_t offset)
 {
-       uint16_t __xdata *ptr = (uint16_t __xdata *) (sirf_target + offset);
+       uint16_t *ptr = (uint16_t *) (sirf_target + offset);
        uint16_t val;
 
        val = data_byte() << 8;
@@ -156,16 +156,16 @@ static void sirf_u16(uint8_t offset)
 
 static void sirf_u8(uint8_t offset)
 {
-       uint8_t __xdata *ptr = (uint8_t __xdata *) (sirf_target + offset);
+       uint8_t *ptr = (uint8_t *) (sirf_target + offset);
        uint8_t val;
 
        val = data_byte ();
        *ptr = val;
 }
 
-static void sirf_u32(uint8_t offset) __reentrant
+static void sirf_u32(uint8_t offset) 
 {
-       uint32_t __xdata *ptr = (uint32_t __xdata *) (sirf_target + offset);
+       uint32_t *ptr = (uint32_t *) (sirf_target + offset);
        uint32_t val;
 
        val = ((uint32_t) data_byte ()) << 24;
@@ -194,7 +194,7 @@ struct sirf_packet_parse {
 };
 
 static void
-ao_sirf_parse(void __xdata *target, const struct sirf_packet_parse *parse) __reentrant
+ao_sirf_parse(void *target, const struct sirf_packet_parse *parse) 
 {
        uint8_t i, offset, j;
 
@@ -258,7 +258,7 @@ static const struct sirf_packet_parse geodetic_nav_data_packet[] = {
 };
 
 static void
-ao_sirf_parse_41(void) __reentrant
+ao_sirf_parse_41(void) 
 {
        ao_sirf_parse(&ao_sirf_data, geodetic_nav_data_packet);
 }
@@ -279,7 +279,7 @@ static const struct sirf_packet_parse measured_sat_data_packet[] = {
 };
 
 static void
-ao_sirf_parse_4(void) __reentrant
+ao_sirf_parse_4(void) 
 {
        uint8_t i;
        ao_sirf_parse(&ao_sirf_tracker_data, measured_tracker_data_packet);
@@ -288,7 +288,7 @@ ao_sirf_parse_4(void) __reentrant
 }
 
 static void
-ao_gps_setup(void) __reentrant
+ao_gps_setup(void) 
 {
        uint8_t i, k;
        ao_sirf_set_speed(AO_SERIAL_SPEED_4800);
@@ -309,7 +309,7 @@ static const char ao_gps_set_message_rate[] = {
 };
 
 void
-ao_sirf_set_message_rate(uint8_t msg, uint8_t rate) __reentrant
+ao_sirf_set_message_rate(uint8_t msg, uint8_t rate) 
 {
        uint16_t        cksum = 0x00a6;
        uint8_t         i;
@@ -337,7 +337,7 @@ static const uint8_t sirf_disable[] = {
 };
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
        uint8_t i, k;
        uint16_t cksum;
@@ -443,7 +443,7 @@ ao_gps(void) __reentrant
        }
 }
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
 void
 ao_gps_init(void)
index 3ecae43..193f20d 100644 (file)
 #define ao_gps_set_speed       ao_serial1_set_speed
 #endif
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-static __data char ao_gps_char;
-static __data uint8_t ao_gps_cksum;
-static __data uint8_t ao_gps_error;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+static char ao_gps_char;
+static uint8_t ao_gps_cksum;
+static uint8_t ao_gps_error;
 
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location   ao_gps_data;
-__xdata struct ao_telemetry_satellite  ao_gps_tracking_data;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location   ao_gps_data;
+struct ao_telemetry_satellite  ao_gps_tracking_data;
 
-static __pdata uint16_t                                ao_gps_next_tick;
-static __pdata struct ao_telemetry_location    ao_gps_next;
-static __pdata uint8_t                         ao_gps_date_flags;
-static __pdata struct ao_telemetry_satellite   ao_gps_tracking_next;
+static uint16_t                                ao_gps_next_tick;
+static struct ao_telemetry_location    ao_gps_next;
+static uint8_t                         ao_gps_date_flags;
+static struct ao_telemetry_satellite   ao_gps_tracking_next;
 
 #define STQ_S 0xa0, 0xa1
 #define STQ_E 0x0d, 0x0a
@@ -60,7 +60,7 @@ static __pdata struct ao_telemetry_satellite  ao_gps_tracking_next;
     STQ_S, 0,15, id, a,b,c,d,e,f,g,h,i,j,k,l,m,n, \
     (id^a^b^c^d^e^f^g^h^i^j^k^l^m^n), STQ_E
 
-static __code uint8_t ao_gps_config[] = {
+static const uint8_t ao_gps_config[] = {
        SKYTRAQ_MSG_8(0x08, 1, 0, 1, 0, 1, 0, 0, 0), /* configure nmea */
        /* gga interval */
        /* gsa interval */
@@ -107,7 +107,7 @@ ao_gps_skip_sep(void)
                ao_gps_lexchar();
 }
 
-__data static uint8_t ao_gps_num_width;
+static uint8_t ao_gps_num_width;
 
 static int16_t
 ao_gps_decimal(uint8_t max_width)
@@ -162,11 +162,11 @@ ao_gps_hex(void)
 }
 
 static int32_t
-ao_gps_parse_pos(uint8_t deg_width) __reentrant
+ao_gps_parse_pos(uint8_t deg_width) 
 {
-       static __pdata uint16_t d;
-       static __pdata uint8_t  m;
-       static __pdata uint16_t f;
+       static uint16_t d;
+       static uint8_t  m;
+       static uint16_t f;
        char c;
 
        d = ao_gps_decimal(deg_width);
@@ -414,7 +414,7 @@ ao_nmea_rmc(void)
 #define ao_skytraq_sendstruct(s) ao_skytraq_sendbytes((s), sizeof(s))
 
 static void
-ao_skytraq_sendbytes(__code uint8_t *b, uint8_t l)
+ao_skytraq_sendbytes(const uint8_t *b, uint8_t l)
 {
        while (l--) {
                uint8_t c = *b++;
@@ -462,7 +462,7 @@ ao_gps_nmea_parse(void)
 static uint8_t ao_gps_updating;
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
        ao_gps_set_speed(AO_SERIAL_SPEED_9600);
 
@@ -486,9 +486,9 @@ ao_gps(void) __reentrant
        }
 }
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
-static __code uint8_t ao_gps_115200[] = {
+static const uint8_t ao_gps_115200[] = {
        SKYTRAQ_MSG_3(5,0,5,0)  /* Set to 115200 baud */
 };
 
@@ -500,7 +500,7 @@ ao_gps_set_speed_delay(uint8_t speed) {
 }
 
 static void
-gps_update(void) __reentrant
+gps_update(void) 
 {
        ao_gps_updating = 1;
        ao_task_minimize_latency = 1;
@@ -517,7 +517,7 @@ gps_update(void) __reentrant
                ao_gps_putchar(ao_usb_getchar());
 }
 
-__code struct ao_cmds ao_gps_cmds[] = {
+const struct ao_cmds ao_gps_cmds[] = {
        { ao_gps_show,  "g\0Display GPS" },
        { gps_update,   "U\0Update GPS firmware" },
        { 0, NULL },
index c720f80..f5268aa 100644 (file)
 
 #include <stdarg.h>
 
-__xdata uint8_t ao_gps_new;
-__xdata uint8_t ao_gps_mutex;
-__pdata uint16_t ao_gps_tick;
-__xdata struct ao_telemetry_location   ao_gps_data;
-__xdata struct ao_telemetry_satellite  ao_gps_tracking_data;
+uint8_t ao_gps_new;
+uint8_t ao_gps_mutex;
+uint16_t ao_gps_tick;
+struct ao_telemetry_location   ao_gps_data;
+struct ao_telemetry_satellite  ao_gps_tracking_data;
 
 #undef AO_SERIAL_SPEED_UBLOX
 
@@ -58,8 +58,8 @@ struct ao_ublox_cksum {
        uint8_t a, b;
 };
 
-static __pdata struct ao_ublox_cksum ao_ublox_cksum;
-static __pdata uint16_t ao_ublox_len;
+static struct ao_ublox_cksum ao_ublox_cksum;
+static uint16_t ao_ublox_len;
 
 #if AO_UBLOX_DEBUG
 
@@ -152,11 +152,11 @@ static uint8_t data_byte(void)
        return header_byte();
 }
 
-static char __xdata *ublox_target;
+static char *ublox_target;
 
 static void ublox_u16(uint8_t offset)
 {
-       uint16_t __xdata *ptr = (uint16_t __xdata *) (void __xdata *) (ublox_target + offset);
+       uint16_t *ptr = (uint16_t *) (void *) (ublox_target + offset);
        uint16_t val;
 
        val = data_byte();
@@ -166,16 +166,16 @@ static void ublox_u16(uint8_t offset)
 
 static void ublox_u8(uint8_t offset)
 {
-       uint8_t __xdata *ptr = (uint8_t __xdata *) (ublox_target + offset);
+       uint8_t *ptr = (uint8_t *) (ublox_target + offset);
        uint8_t val;
 
        val = data_byte ();
        *ptr = val;
 }
 
-static void ublox_u32(uint8_t offset) __reentrant
+static void ublox_u32(uint8_t offset) 
 {
-       uint32_t __xdata *ptr = (uint32_t __xdata *) (void __xdata *) (ublox_target + offset);
+       uint32_t *ptr = (uint32_t *) (void *) (ublox_target + offset);
        uint32_t val;
 
        val = ((uint32_t) data_byte ());
@@ -203,7 +203,7 @@ struct ublox_packet_parse {
 };
 
 static void
-ao_ublox_parse(void __xdata *target, const struct ublox_packet_parse *parse) __reentrant
+ao_ublox_parse(void *target, const struct ublox_packet_parse *parse) 
 {
        uint8_t i, offset;
 
@@ -610,7 +610,7 @@ ao_gps_set_rate(uint8_t rate)
 }
 
 void
-ao_gps(void) __reentrant
+ao_gps(void) 
 {
        uint8_t                 class, id;
        struct ao_ublox_cksum   cksum;
@@ -796,12 +796,12 @@ static void ao_gps_option(void)
 #define ao_gps_option ao_gps_show
 #endif
 
-__code struct ao_cmds ao_gps_cmds[] = {
+const struct ao_cmds ao_gps_cmds[] = {
        { ao_gps_option,        "g\0Display GPS" },
        { 0, NULL },
 };
 
-__xdata struct ao_task ao_gps_task;
+struct ao_task ao_gps_task;
 
 void
 ao_gps_init(void)
index c35093b..294361e 100644 (file)
@@ -20,7 +20,7 @@
 
 static uint16_t        ao_lcd_time = 3;
 
-static __xdata uint8_t ao_lcd_mutex;
+static uint8_t ao_lcd_mutex;
 
 static void
 ao_lcd_delay(void)
index e892c8c..8663520 100644 (file)
@@ -324,7 +324,7 @@ ao_lco_set_debug(void)
                ao_lco_debug = ao_cmd_lex_i != 0;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
        { ao_lco_set_debug,     "D <0 off, 1 on>\0Debug" },
        { ao_lco_search,        "s\0Search for pad boxes" },
        { 0, NULL }
index dba9a76..3fcdc85 100644 (file)
 #define HAS_STATIC_TEST        1
 #endif
 
-static __pdata uint16_t        lco_box;
-static __pdata uint8_t lco_channels;
-static __pdata uint16_t        tick_offset;
+static uint16_t        lco_box;
+static uint8_t lco_channels;
+static uint16_t        tick_offset;
 
 static void
-lco_args(void) __reentrant
+lco_args(void) 
 {
        ao_cmd_decimal();
        lco_box = ao_cmd_lex_i;
@@ -71,7 +71,7 @@ lco_ignite(uint8_t cmd)
 }
 
 static void
-lco_report_cmd(void) __reentrant
+lco_report_cmd(void) 
 {
        int8_t          r;
        uint8_t         c;
@@ -122,7 +122,7 @@ lco_report_cmd(void) __reentrant
 }
 
 static void
-lco_fire_cmd(void) __reentrant
+lco_fire_cmd(void) 
 {
        uint8_t         secs;
        uint8_t         i;
@@ -156,7 +156,7 @@ lco_fire_cmd(void) __reentrant
 
 #if HAS_STATIC_TEST
 static void
-lco_static_cmd(void) __reentrant
+lco_static_cmd(void) 
 {
        uint8_t         secs;
        uint8_t         i;
@@ -190,7 +190,7 @@ lco_static_cmd(void) __reentrant
 #endif
 
 static void
-lco_arm_cmd(void) __reentrant
+lco_arm_cmd(void) 
 {
        uint8_t i;
        int8_t  r;
@@ -205,7 +205,7 @@ lco_arm_cmd(void) __reentrant
 }
 
 static void
-lco_ignite_cmd(void) __reentrant
+lco_ignite_cmd(void) 
 {
        uint8_t i;
        lco_args();
@@ -216,13 +216,13 @@ lco_ignite_cmd(void) __reentrant
 
 #if HAS_STATIC_TEST
 static void
-lco_endstatic_cmd(void) __reentrant
+lco_endstatic_cmd(void) 
 {
        lco_ignite(AO_PAD_ENDSTATIC);
 }
 #endif
 
-static __code struct ao_cmds ao_lco_cmds[] = {
+static const struct ao_cmds ao_lco_cmds[] = {
        { lco_report_cmd,       "l <box> <channel>\0Get remote status" },
        { lco_fire_cmd,         "F <box> <channel> <secs>\0Fire remote igniters" },
 #if HAS_STATIC_TEST
index 92b344e..0635069 100644 (file)
@@ -21,8 +21,8 @@
 #include <ao_radio_cmac.h>
 #include <ao_lco_func.h>
 
-static __xdata struct ao_pad_command   command;
-static __xdata uint8_t                 ao_lco_mutex;
+static struct ao_pad_command   command;
+static uint8_t                 ao_lco_mutex;
 
 int8_t
 ao_lco_query(uint16_t box, struct ao_pad_query *query, uint16_t *tick_offset)
index 6f2d81f..12c02e8 100644 (file)
@@ -129,7 +129,7 @@ ao_lco_set_debug(void)
                ao_lco_debug = ao_cmd_lex_i;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
        { ao_lco_set_debug,     "D <0 off, 1 on>\0Debug" },
        { 0, NULL }
 };
index b506b0a..72617cc 100644 (file)
 #include "ao.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t       ao_storage_total;
+uint32_t       ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t       ao_storage_block;
+uint32_t       ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t       ao_storage_config;
+uint32_t       ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t       ao_storage_unit;
+uint16_t       ao_storage_unit;
 
 #define M25_DEBUG      0
 /*
@@ -89,7 +89,7 @@ static uint8_t ao_m25_numchips;                       /* number of chips detected */
 static uint8_t ao_m25_total;                   /* total sectors available */
 static ao_port_t ao_m25_wip;                   /* write in progress */
 
-static __xdata uint8_t ao_m25_mutex;
+static uint8_t ao_m25_mutex;
 
 /*
  * This little array is abused to send and receive data. A particular
@@ -99,7 +99,7 @@ static __xdata uint8_t ao_m25_mutex;
  * of which touch those last three bytes.
  */
 
-static __xdata uint8_t ao_m25_instruction[4];
+static uint8_t ao_m25_instruction[4];
 
 #define M25_SELECT(cs)         ao_spi_get_mask(AO_M25_SPI_CS_PORT,cs,AO_M25_SPI_BUS, AO_SPI_SPEED_FAST)
 #define M25_DESELECT(cs)       ao_spi_put_mask(AO_M25_SPI_CS_PORT,cs,AO_M25_SPI_BUS)
@@ -239,7 +239,7 @@ ao_m25_scan(void)
  * Erase the specified sector
  */
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
        ao_port_t       cs;
 
@@ -267,7 +267,7 @@ ao_storage_erase(uint32_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *d, uint16_t len) 
 {
        ao_port_t       cs;
 
@@ -294,7 +294,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
        ao_port_t       cs;
 
@@ -317,7 +317,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -330,7 +330,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
 #if M25_DEBUG
        ao_port_t       cs;
index 5d44bff..a48c1db 100644 (file)
@@ -259,7 +259,7 @@ ao_mma655x_dump(void)
        printf ("MMA655X value %d\n", ao_mma655x_current);
 }
 
-__code struct ao_cmds ao_mma655x_cmds[] = {
+const struct ao_cmds ao_mma655x_cmds[] = {
        { ao_mma655x_dump,      "A\0Display MMA655X data" },
        { 0, NULL },
 };
@@ -277,7 +277,7 @@ ao_mma655x(void)
        }
 }
 
-static __xdata struct ao_task ao_mma655x_task;
+static struct ao_task ao_mma655x_task;
 
 void
 ao_mma655x_init(void)
index 2d355c9..86dda22 100644 (file)
 #include "ao.h"
 
 /* Total bytes of available storage */
-__pdata uint32_t       ao_storage_total;
+uint32_t       ao_storage_total;
 
 /* Block size - device is erased in these units. At least 256 bytes */
-__pdata uint32_t       ao_storage_block;
+uint32_t       ao_storage_block;
 
 /* Byte offset of config block. Will be ao_storage_block bytes long */
-__pdata uint32_t       ao_storage_config;
+uint32_t       ao_storage_config;
 
 /* Storage unit size - device reads and writes must be within blocks of this size. Usually 256 bytes. */
-__pdata uint16_t       ao_storage_unit;
+uint16_t       ao_storage_unit;
 
 /*
  * MRAM is entirely random access; no erase operations are required,
@@ -51,7 +51,7 @@ __pdata uint16_t      ao_storage_unit;
 #define MR25_STATUS_BP_SHIFT   (2)
 #define MR25_STATUS_WEL                (1 << 1)        /* Write enable latch */
 
-static __xdata uint8_t ao_mr25_mutex;
+static uint8_t ao_mr25_mutex;
 
 /*
  * This little array is abused to send and receive data. A particular
@@ -61,7 +61,7 @@ static __xdata uint8_t ao_mr25_mutex;
  * those last three bytes.
  */
 
-static __xdata uint8_t ao_mr25_instruction[4];
+static uint8_t ao_mr25_instruction[4];
 
 #define MR25_SELECT()          ao_spi_get_mask(AO_MR25_SPI_CS_PORT,(1 << AO_MR25_SPI_CS_PIN),AO_MR25_SPI_BUS, AO_SPI_SPEED_FAST)
 #define MR25_DESELECT()                ao_spi_put_mask(AO_MR25_SPI_CS_PORT,(1 << AO_MR25_SPI_CS_PIN),AO_MR25_SPI_BUS)
@@ -93,7 +93,7 @@ ao_mr25_set_address(uint32_t pos)
  * Erase the specified sector (no-op for MRAM)
  */
 uint8_t
-ao_storage_erase(uint32_t pos) __reentrant
+ao_storage_erase(uint32_t pos) 
 {
        if (pos >= ao_storage_total || pos + ao_storage_block > ao_storage_total)
                return 0;
@@ -104,7 +104,7 @@ ao_storage_erase(uint32_t pos) __reentrant
  * Write to flash
  */
 uint8_t
-ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_write(uint32_t pos, void *d, uint16_t len) 
 {
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -128,7 +128,7 @@ ao_storage_device_write(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
  * Read from flash
  */
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -147,7 +147,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -157,7 +157,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
        printf ("Detected chips 1 size %d\n", ao_storage_total >> 8);
 }
index 4bfc17d..a468fee 100644 (file)
@@ -22,8 +22,8 @@
 
 #if HAS_MS5607 || HAS_MS5611
 
-__xdata struct ao_ms5607_prom  ao_ms5607_prom;
-static __xdata uint8_t         ms5607_configured;
+struct ao_ms5607_prom  ao_ms5607_prom;
+static uint8_t         ms5607_configured;
 
 #ifndef AO_MS5607_SPI_SPEED
 #define AO_MS5607_SPI_SPEED    AO_SPI_SPEED_FAST
@@ -97,12 +97,12 @@ ao_ms5607_prom_valid(uint8_t *prom)
 }
 
 static void
-ao_ms5607_prom_read(__xdata struct ao_ms5607_prom *prom)
+ao_ms5607_prom_read(struct ao_ms5607_prom *prom)
 {
        uint8_t         addr;
        uint16_t        *r;
 
-       r = (__xdata uint16_t *) prom;
+       r = (uint16_t *) prom;
        for (addr = 0; addr < 8; addr++) {
                uint8_t cmd = AO_MS5607_PROM_READ(addr);
                ao_ms5607_start();
@@ -138,20 +138,20 @@ ao_ms5607_setup(void)
        ao_ms5607_prom_read(&ao_ms5607_prom);
 }
 
-static __xdata volatile uint8_t        ao_ms5607_done;
+static volatile uint8_t        ao_ms5607_done;
 
 static void
 ao_ms5607_isr(void)
 {
        ao_exti_disable(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN);
        ao_ms5607_done = 1;
-       ao_wakeup((__xdata void *) &ao_ms5607_done);
+       ao_wakeup((void *) &ao_ms5607_done);
 }
 
 static uint32_t
 ao_ms5607_get_sample(uint8_t cmd) {
-       __xdata uint8_t reply[3];
-       __xdata uint8_t read;
+       uint8_t reply[3];
+       uint8_t read;
 
        ao_ms5607_done = 0;
 
@@ -198,7 +198,7 @@ ao_ms5607_get_sample(uint8_t cmd) {
 #define AO_CONVERT_D2  token_evaluator(AO_MS5607_CONVERT_D2_, AO_MS5607_TEMP_OVERSAMPLE)
 
 void
-ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample)
+ao_ms5607_sample(struct ao_ms5607_sample *sample)
 {
        sample->pres = ao_ms5607_get_sample(AO_CONVERT_D1);
        sample->temp = ao_ms5607_get_sample(AO_CONVERT_D2);
@@ -214,7 +214,7 @@ ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample)
 #define HAS_MS5607_TASK HAS_TASK
 #endif
 
-__xdata struct ao_ms5607_sample        ao_ms5607_current;
+struct ao_ms5607_sample        ao_ms5607_current;
 
 #if HAS_MS5607_TASK
 static void
@@ -233,7 +233,7 @@ ao_ms5607(void)
        }
 }
 
-__xdata struct ao_task ao_ms5607_task;
+struct ao_task ao_ms5607_task;
 #endif
 
 #if HAS_TASK
@@ -253,7 +253,7 @@ ao_ms5607_info(void)
 static void
 ao_ms5607_dump(void)
 {
-       __xdata struct ao_ms5607_value value;
+       struct ao_ms5607_value value;
 
        ao_ms5607_convert(&ao_ms5607_current, &value);
        printf ("Pressure:    %8lu %8ld\n", ao_ms5607_current.pres, value.pres);
@@ -261,7 +261,7 @@ ao_ms5607_dump(void)
        printf ("Altitude: %ld\n", ao_pa_to_altitude(value.pres));
 }
 
-__code struct ao_cmds ao_ms5607_cmds[] = {
+const struct ao_cmds ao_ms5607_cmds[] = {
        { ao_ms5607_dump,       "B\0Display MS5607 data" },
        { 0, NULL },
 };
index 18f99bf..322cc46 100644 (file)
@@ -57,8 +57,8 @@ struct ao_ms5607_value {
        int32_t         temp;   /* in °C * 100 */
 };
 
-extern __xdata struct ao_ms5607_sample ao_ms5607_current;
-extern __xdata struct ao_ms5607_prom   ao_ms5607_prom;
+extern struct ao_ms5607_sample ao_ms5607_current;
+extern struct ao_ms5607_prom   ao_ms5607_prom;
 
 void
 ao_ms5607_setup(void);
@@ -70,10 +70,10 @@ void
 ao_ms5607_info(void);
 
 void
-ao_ms5607_sample(__xdata struct ao_ms5607_sample *sample);
+ao_ms5607_sample(struct ao_ms5607_sample *sample);
 
 void
-ao_ms5607_convert(__xdata struct ao_ms5607_sample *sample,
-                 __xdata struct ao_ms5607_value *value);
+ao_ms5607_convert(struct ao_ms5607_sample *sample,
+                 struct ao_ms5607_value *value);
 
 #endif /* _AO_MS5607_H_ */
index b708110..e9052b4 100644 (file)
@@ -32,8 +32,8 @@
 #endif
 
 void
-ao_ms5607_convert(__xdata struct ao_ms5607_sample *sample,
-                 __xdata struct ao_ms5607_value *value)
+ao_ms5607_convert(struct ao_ms5607_sample *sample,
+                 struct ao_ms5607_value *value)
 {
        __LOCAL int32_t dT;
        __LOCAL int32_t TEMP;
index 1c93192..b5a0a4b 100644 (file)
 
 #include "ao.h"
 
-__xdata struct ao_packet_recv ao_rx_packet;
-__xdata struct ao_packet ao_tx_packet;
-__pdata uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
+struct ao_packet_recv ao_rx_packet;
+struct ao_packet ao_tx_packet;
+uint8_t ao_packet_rx_len, ao_packet_rx_used, ao_packet_tx_used;
 
-static __xdata uint8_t tx_data[AO_PACKET_MAX];
-static __xdata uint8_t rx_data[AO_PACKET_MAX];
-static __pdata uint8_t rx_seq;
+static uint8_t tx_data[AO_PACKET_MAX];
+static uint8_t rx_data[AO_PACKET_MAX];
+static uint8_t rx_seq;
 
-__xdata struct ao_task ao_packet_task;
-__xdata uint8_t ao_packet_enable;
-__xdata uint8_t ao_packet_restart;
+struct ao_task ao_packet_task;
+uint8_t ao_packet_enable;
+uint8_t ao_packet_restart;
 
 #if PACKET_HAS_MASTER
-__xdata uint8_t ao_packet_master_sleeping;
+uint8_t ao_packet_master_sleeping;
 #endif
 
 void
@@ -150,7 +150,7 @@ ao_packet_flush(void)
 #endif /* PACKET_HAS_MASTER */
 
 void
-ao_packet_putchar(char c) __reentrant
+ao_packet_putchar(char c) 
 {
        /* No need to block interrupts, all variables here
         * are only manipulated in task context
index e63771e..68a5efe 100644 (file)
@@ -39,7 +39,7 @@ ao_packet_getchar(void)
 }
 
 static void
-ao_packet_echo(void) __reentrant
+ao_packet_echo(void) 
 {
        int     c;
        while (ao_packet_enable) {
@@ -50,9 +50,9 @@ ao_packet_echo(void) __reentrant
        ao_exit();
 }
 
-static __xdata struct ao_task  ao_packet_echo_task;
-static __xdata uint16_t                ao_packet_master_delay;
-static __xdata uint16_t                ao_packet_master_time;
+static struct ao_task  ao_packet_echo_task;
+static uint16_t                ao_packet_master_delay;
+static uint16_t                ao_packet_master_time;
 
 #define AO_PACKET_MASTER_DELAY_SHORT   AO_MS_TO_TICKS(100)
 #define AO_PACKET_MASTER_DELAY_LONG    AO_MS_TO_TICKS(1000)
@@ -114,7 +114,7 @@ ao_packet_master(void)
 }
 
 static void
-ao_packet_forward(void) __reentrant
+ao_packet_forward(void) 
 {
        char c;
        ao_packet_enable = 1;
@@ -152,7 +152,7 @@ ao_packet_signal(void)
        printf ("RSSI: %d\n", ao_radio_rssi);
 }
 
-__code struct ao_cmds ao_packet_master_cmds[] = {
+const struct ao_cmds ao_packet_master_cmds[] = {
        { ao_packet_forward,    "p\0Remote packet link." },
        { ao_packet_signal,     "s\0Report signal strength." },
        { 0,    NULL },
index 208841f..7e139c7 100644 (file)
 #include <ao_74hc165.h>
 #include <ao_radio_cmac.h>
 
-static __xdata uint8_t ao_pad_ignite;
-static __xdata struct ao_pad_command   command;
-static __xdata struct ao_pad_query     query;
-static __pdata uint8_t ao_pad_armed;
-static __pdata uint16_t        ao_pad_arm_time;
-static __pdata uint8_t ao_pad_box;
-static __xdata uint8_t ao_pad_disabled;
-static __pdata uint16_t        ao_pad_packet_time;
+static uint8_t ao_pad_ignite;
+static struct ao_pad_command   command;
+static struct ao_pad_query     query;
+static uint8_t ao_pad_armed;
+static uint16_t        ao_pad_arm_time;
+static uint8_t ao_pad_box;
+static uint8_t ao_pad_disabled;
+static uint16_t        ao_pad_packet_time;
 
 #ifndef AO_PAD_RSSI_MINIMUM
 #define AO_PAD_RSSI_MINIMUM    -90
@@ -38,7 +38,7 @@ static __pdata uint16_t       ao_pad_packet_time;
 #define DEBUG  1
 
 #if DEBUG
-static __pdata uint8_t ao_pad_debug;
+static uint8_t ao_pad_debug;
 #define PRINTD(...) (ao_pad_debug ? (printf(__VA_ARGS__), 0) : 0)
 #define FLUSHD()    (ao_pad_debug ? (flush(), 0) : 0)
 #else
@@ -189,17 +189,17 @@ ao_pad_monitor(void)
 {
        uint8_t                 c;
        uint8_t                 sample;
-       __pdata AO_LED_TYPE     prev = 0, cur = 0;
-       __pdata uint8_t         beeping = 0;
-       __xdata volatile struct ao_data *packet;
-       __pdata uint16_t        arm_beep_time = 0;
+       AO_LED_TYPE     prev = 0, cur = 0;
+       uint8_t         beeping = 0;
+       volatile struct ao_data *packet;
+       uint16_t        arm_beep_time = 0;
 
        sample = ao_data_head;
        ao_led_set(LEDS_AVAILABLE);
        ao_delay(AO_MS_TO_TICKS(1000));
        ao_led_set(0);
        for (;;) {
-               __pdata int16_t                 pyro;
+               int16_t                 pyro;
 
                ao_arch_critical(
                        while (sample == ao_data_head)
@@ -526,9 +526,9 @@ ao_pad_manual(void)
        }
 }
 
-static __xdata struct ao_task ao_pad_task;
-static __xdata struct ao_task ao_pad_ignite_task;
-static __xdata struct ao_task ao_pad_monitor_task;
+static struct ao_task ao_pad_task;
+static struct ao_task ao_pad_ignite_task;
+static struct ao_task ao_pad_monitor_task;
 
 #if DEBUG
 void
@@ -560,7 +560,7 @@ ao_pad_alarm_debug(void)
 }
 #endif
 
-__code struct ao_cmds ao_pad_cmds[] = {
+const struct ao_cmds ao_pad_cmds[] = {
        { ao_pad_test,  "t\0Test pad continuity" },
        { ao_pad_manual,        "i <key> <n>\0Fire igniter. <key> is doit with D&I" },
 #if DEBUG
index 09f52a0..3516f03 100644 (file)
@@ -23,7 +23,7 @@
 
 #include <ao.h>
 
-static __xdata uint8_t ao_led_state;
+static uint8_t ao_led_state;
 
 static void
 ao_led_apply(void)
@@ -93,7 +93,7 @@ ao_led_toggle(uint8_t colors)
 }
 
 void
-ao_led_for(uint8_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint8_t colors, uint16_t ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index a293d92..8ea6d85 100644 (file)
@@ -33,7 +33,7 @@ static const struct ao_companion_setup        ao_telepyro_setup = {
 
 struct ao_config ao_config;
 
-extern volatile __data uint16_t ao_tick_count;
+extern volatile uint16_t ao_tick_count;
 uint16_t ao_boost_tick;
 
 void ao_spi_slave(void)
index 250e035..20781c4 100644 (file)
@@ -22,7 +22,7 @@
 #include <ao_fast_timer.h>
 #include <ao_event.h>
 
-__xdata int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
+int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
 #ifndef AO_QUADRATURE_SINGLE_CODE
 static int8_t ao_quadrature_step[AO_QUADRATURE_COUNT];
 #endif
index a99e4cc..ee551f6 100644 (file)
@@ -19,7 +19,7 @@
 #ifndef _AO_QUADRATURE_H_
 #define _AO_QUADRATURE_H_
 
-extern __xdata int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
+extern int32_t ao_quadrature_count[AO_QUADRATURE_COUNT];
 
 int32_t
 ao_quadrature_wait(uint8_t q);
index 79e4b22..8b62a4d 100644 (file)
 #include <ao_exti.h>
 #include <ao_radio_cmac.h>
 
-static __xdata struct ao_radio_spi_reply       ao_radio_spi_reply;
-static __xdata struct ao_radio_spi_request     ao_radio_spi_request;
-static volatile __xdata uint8_t                        ao_radio_wait_mode;
-static volatile __xdata uint8_t                        ao_radio_done = 0;
-static volatile __xdata uint8_t                        ao_radio_ready = 1;
-static __xdata uint8_t                         ao_radio_mutex;
-static __xdata uint8_t                         ao_radio_aes_seq;
+static struct ao_radio_spi_reply       ao_radio_spi_reply;
+static struct ao_radio_spi_request     ao_radio_spi_request;
+static volatile uint8_t                        ao_radio_wait_mode;
+static volatile uint8_t                        ao_radio_done = 0;
+static volatile uint8_t                        ao_radio_ready = 1;
+static uint8_t                         ao_radio_mutex;
+static uint8_t                         ao_radio_aes_seq;
 
-__xdata int8_t                                 ao_radio_cmac_rssi;
+int8_t                                 ao_radio_cmac_rssi;
 
 #if 0
 #define PRINTD(...) do { printf ("\r%5u %s: ", ao_tick_count, __func__); printf(__VA_ARGS__); flush(); } while(0)
@@ -126,7 +126,7 @@ ao_radio_put(void)
 }
 
 static void
-ao_radio_get_data(__xdata void *d, uint8_t size)
+ao_radio_get_data(void *d, uint8_t size)
 {
        PRINTD ("fetch\n");
        ao_radio_master_start();
@@ -157,7 +157,7 @@ ao_radio_send(const void *d, uint8_t size)
 
 
 uint8_t
-ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
+ao_radio_recv(void *d, uint8_t size, uint8_t timeout)
 {
        int8_t  ret;
        uint8_t recv;
@@ -198,7 +198,7 @@ ao_radio_cmac_set_key(void)
 }
 
 int8_t
-ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
+ao_radio_cmac_send(void *packet, uint8_t len) 
 {
        if (len > AO_CMAC_MAX_LEN)
                return AO_RADIO_CMAC_LEN_ERROR;
@@ -220,7 +220,7 @@ ao_radio_cmac_send(__xdata void *packet, uint8_t len) __reentrant
 }
 
 int8_t
-ao_radio_cmac_recv(__xdata void *packet, uint8_t len, uint16_t timeout) __reentrant
+ao_radio_cmac_recv(void *packet, uint8_t len, uint16_t timeout) 
 {
        int8_t  ret;
        int8_t  recv;
@@ -296,7 +296,7 @@ ao_radio_test_cmd(void)
                ao_radio_test(0);
 }
 
-__code struct ao_cmds ao_radio_cmds[] = {
+const struct ao_cmds ao_radio_cmds[] = {
        { ao_radio_test_cmd,    "C <1 start, 0 stop, none both>\0Radio carrier test" },
        { 0,    NULL },
 };
index 2f1dab2..7859d6b 100644 (file)
 #include <ao_radio_spi.h>
 #include <ao_radio_cmac.h>
 
-static __xdata struct ao_radio_spi_reply ao_radio_spi_reply;
+static struct ao_radio_spi_reply ao_radio_spi_reply;
 
-static __xdata struct ao_radio_spi_request ao_radio_spi_request;
+static struct ao_radio_spi_request ao_radio_spi_request;
 
-static __xdata uint8_t slave_state;
+static uint8_t slave_state;
 
 static void
 ao_radio_slave_low(void)
@@ -123,7 +123,7 @@ ao_radio_slave_spi(void)
        }
 }
 
-static __xdata struct ao_task ao_radio_slave_spi_task;
+static struct ao_task ao_radio_slave_spi_task;
 
 void
 ao_radio_slave_init(void)
index 1a877fc..01c3cd0 100644 (file)
@@ -46,7 +46,7 @@ ao_watchdog_set(void)
 }
        
 
-static __code struct ao_cmds ao_watchdog_cmds[] = {
+static const struct ao_cmds ao_watchdog_cmds[] = {
        { ao_watchdog_set,      "Q <0 off, 1 on>\0Enable or disable watchdog timer" },
        { 0,                    NULL },
 };
index 520f6ef..fd1d127 100644 (file)
@@ -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
index 5ae9842..f41b2e8 100644 (file)
@@ -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);
index d0f80a5..a5be8c1 100644 (file)
 
 #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)
index 1306af6..fdc150f 100644 (file)
@@ -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
index 7bb4654..d28db5b 100644 (file)
 #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" },
index 4c16145..bd702fe 100644 (file)
@@ -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);
index 10a6711..277dddd 100644 (file)
 #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 },
 };
index f730c73..41aafcc 100644 (file)
@@ -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);
index 1cd6234..f3e523e 100644 (file)
@@ -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;
 
index 35d42b8..536ffa2 100644 (file)
 #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);
index 30616ef..f88b30c 100644 (file)
@@ -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
index 84c1300..cef0a43 100644 (file)
@@ -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;
index bd8b672..f258c48 100644 (file)
@@ -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
index 170396f..f72efa0 100644 (file)
 
 /* 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)
index 005c7e8..af6b0c5 100644 (file)
@@ -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
index 797ea34..96d47fa 100644 (file)
 
 /* 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)
index b1ab3f5..6f664b6 100644 (file)
@@ -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");
 }
index 2fe28f6..5b21bf3 100644 (file)
@@ -20,6 +20,6 @@
 #define _AO_FORWARD_H_
 
 void
-ao_monitor_forward_init(void) __reentrant;
+ao_monitor_forward_init(void);
 
 #endif /* _AO_FORWARD_H_ */
index 6478dae..81640ce 100644 (file)
  * 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;
index b1183ba..6dfd1bd 100644 (file)
@@ -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)
index 75c2f36..0ef9a72 100644 (file)
@@ -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)
index 85614b8..37f1bea 100644 (file)
@@ -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)
index 523fb17..06863fe 100644 (file)
@@ -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)
index ec19776..ab29e5e 100644 (file)
@@ -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);
index 638dba9..592de54 100644 (file)
@@ -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)
index 52d9d77..5f41c55 100644 (file)
@@ -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)
index fdea61c..dffb855 100644 (file)
@@ -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;
index 11c1640..3014182 100644 (file)
@@ -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;
index e4cc6d4..4f4ffe8 100644 (file)
@@ -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
index 7de0923..803f85b 100644 (file)
@@ -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
index 5fb086c..1119cce 100644 (file)
 #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 },
index e2f1e0e..a971596 100644 (file)
  * 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
index 7d7332e..2a8cd63 100644 (file)
@@ -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();
 
index 1a82673..3dd52a1 100644 (file)
 #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))] ;
index 0ae4e53..341ff71 100644 (file)
@@ -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();
index 3472907..18fb9ff 100644 (file)
@@ -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();
 
index 12c5d6b..03bf226 100644 (file)
@@ -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();
 
index 63768e1..da62738 100644 (file)
 #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)
index 8969e02..8c0b88e 100644 (file)
 #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() {
index 3f514f1..a21af71 100644 (file)
 
 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;
 
index 046b7b2..5300311 100644 (file)
@@ -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);
index b9a39bf..b6b8d88 100644 (file)
 #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]);
index ff73e3b..4ef1a9b 100644 (file)
@@ -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);
index 7207353..a5bdc8a 100644 (file)
@@ -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;
index a444672..ce622b6 100644 (file)
@@ -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_ */
index 9d99b0e..24cd7b1 100644 (file)
@@ -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);
index 527112a..e24ab46 100644 (file)
@@ -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
index 92b365a..155fce3 100644 (file)
@@ -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)
index 74fe8c6..5fd6e10 100644 (file)
 #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);
index 6d29f39..e5b4ffd 100644 (file)
@@ -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 },
index 73f87cd..08967af 100644 (file)
@@ -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)
index 9c7afdc..efada54 100644 (file)
@@ -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;
index 66fb8b5..aacc38b 100644 (file)
@@ -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)
index 9f5082b..115eae8 100644 (file)
 #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];
index 5ae389b..af6eca4 100644 (file)
@@ -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
 
index 4819a16..b9d0e07 100644 (file)
@@ -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 }
 };
index c8a1d46..3206b2d 100644 (file)
 
 #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 }
 };
index ef3e93d..440b562 100644 (file)
@@ -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);
index 227499c..c3b51d1 100644 (file)
 
 #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);
index 400751d..5292e12 100644 (file)
@@ -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
index 59b137a..cf37a82 100644 (file)
 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_ */
index de23ea0..4f7072c 100644 (file)
 
 #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++) {
index 7549b59..ffeb731 100644 (file)
 
 /* 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 */
index 8ff28fd..9e1304f 100644 (file)
 #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()
index 40516de..7992c80 100644 (file)
@@ -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_ */
index 84d7610..be4f115 100644 (file)
@@ -61,9 +61,9 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data*)       /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
 
index db53dca..99d1014 100644 (file)
@@ -65,9 +65,9 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data ORIGIN(ram) : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
                __bss_start__ = .;
        } >ram
 
index e6a6a7e..028ad77 100644 (file)
@@ -69,9 +69,9 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
                __bss_start__ = .;
        } >ram
 
index 26a5ea0..6743c1f 100644 (file)
@@ -147,7 +147,7 @@ ao_adc_poll(void)
 }
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
        struct ao_data  packet;
 #ifndef AO_ADC_DUMP
@@ -167,7 +167,7 @@ ao_adc_dump(void) __reentrant
 #endif
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
        { ao_adc_dump,  "a\0Display current ADC values" },
        { 0, NULL },
 };
index f1df14e..889be53 100644 (file)
 
 #define ao_arch_naked_declare  __attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
index b121175..eab86ee 100644 (file)
@@ -59,7 +59,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
        ao_beep(beep);
        ao_delay(ticks);
index 3e0119c..8d71f43 100644 (file)
@@ -32,7 +32,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 #if RELOCATE_INTERRUPT
 extern char __interrupt_rom__, __interrupt_start__, __interrupt_end__;
@@ -61,7 +61,7 @@ void start(void) {
        memcpy(&__interrupt_start__, &__interrupt_rom__, &__interrupt_end__ - &__interrupt_start__);
        lpc_scb.sysmemremap = LPC_SCB_SYSMEMREMAP_MAP_RAM << LPC_SCB_SYSMEMREMAP_MAP;
 #endif
-       memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+       memcpy(&_start__, &__text_end__, &_end__ - &_start__);
        memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
        main();
 }
index 2d2c397..5fc726c 100644 (file)
@@ -18,7 +18,7 @@
 
 #include <ao.h>
 
-__pdata AO_PORT_TYPE ao_led_enable;
+AO_PORT_TYPE ao_led_enable;
 
 void
 ao_led_on(AO_PORT_TYPE colors)
@@ -49,7 +49,7 @@ ao_led_toggle(AO_PORT_TYPE colors)
 }
 
 void
-ao_led_for(AO_PORT_TYPE colors, uint16_t ticks) __reentrant
+ao_led_for(AO_PORT_TYPE colors, uint16_t ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index 166e2f1..8999c7a 100644 (file)
@@ -18,7 +18,7 @@
 
 #include <ao.h>
 
-volatile __data AO_TICK_TYPE ao_tick_count;
+volatile AO_TICK_TYPE ao_tick_count;
 
 uint16_t
 ao_time(void)
@@ -27,8 +27,8 @@ ao_time(void)
 }
 
 #if AO_DATA_ALL
-volatile __data uint8_t        ao_data_interval = 1;
-volatile __data uint8_t        ao_data_count;
+volatile uint8_t       ao_data_interval = 1;
+volatile uint8_t       ao_data_count;
 #endif
 
 void lpc_systick_isr(void)
index d26a143..5cd7aa5 100644 (file)
@@ -1003,7 +1003,7 @@ ao_usb_irq(void)
                control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
        { ao_usb_irq, "I\0Show USB interrupt counts" },
        { 0, NULL }
 };
index baeae5b..a73d4c1 100644 (file)
@@ -90,7 +90,7 @@ SECTIONS {
         */
 
        .textram BLOCK(8): {
-               __data_start__ = .;
+               _start__ = .;
                *(.ramtext)
        } >ram AT>rom
 
@@ -99,7 +99,7 @@ SECTIONS {
         */
        .data BLOCK(8): {
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 02a23a9..945f7c6 100644 (file)
@@ -82,10 +82,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 5de65eb..d3edbe9 100644 (file)
@@ -85,7 +85,7 @@ SECTIONS {
         */
 
        .textram BLOCK(8): {
-               __data_start__ = .;
+               _start__ = .;
                __text_ram_start__ = .;
                *(.ramtext)
                __text_ram_end = .;
@@ -96,7 +96,7 @@ SECTIONS {
        .data : {
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 1f0edb0..a680ca1 100644 (file)
@@ -29,7 +29,7 @@ ao_panic(uint8_t reason)
 }
 
 void
-ao_put_string(__code char *s)
+ao_put_string(const char *s)
 {
        char    c;
        while ((c = *s++)) {
index f8f23a0..3a989f5 100644 (file)
 #include <ao_flight.h>
 #include <math.h>
 
-static __xdata struct ao_telemetry_sensor              ao_tel_sensor;
-static __xdata struct ao_telemetry_location            ao_tel_location;
-static __xdata struct ao_telemetry_configuration       ao_tel_config;
-static __xdata int16_t                                         ao_tel_max_speed;
-static __xdata int16_t                                 ao_tel_max_height;
+static struct ao_telemetry_sensor              ao_tel_sensor;
+static struct ao_telemetry_location            ao_tel_location;
+static struct ao_telemetry_configuration       ao_tel_config;
+static int16_t                                         ao_tel_max_speed;
+static int16_t                                 ao_tel_max_height;
 static int8_t ao_tel_rssi;
 
-static __xdata char ao_lcd_line[17];
-static __xdata char ao_state_name[] = "SIPBFCDMLI";
+static char ao_lcd_line[17];
+static char ao_state_name[] = "SIPBFCDMLI";
 
 static void
 ao_terraui_line(uint8_t addr)
@@ -85,7 +85,7 @@ ao_terraui_logging(void)
        return '-';
 }
 
-static __code char ao_progress[4] = { '\011', '\012', '\014', '\013' };
+static const char ao_progress[4] = { '\011', '\012', '\014', '\013' };
 
 static uint8_t ao_telem_progress;
 static uint8_t ao_gps_progress;
@@ -165,7 +165,7 @@ static int16_t mag(int32_t d)
 static int32_t
 dist(int32_t d)
 {
-       __pdata uint32_t m;
+       uint32_t m;
        uint8_t neg = 0;
 
        if (d < 0) {
@@ -184,7 +184,7 @@ dist(int32_t d)
        return d;
 }
 
-static __code uint8_t cos_table[] = {
+static const uint8_t cos_table[] = {
    0, /*  0 */
    0, /*  1 */
    0, /*  2 */
@@ -242,7 +242,7 @@ static __code uint8_t cos_table[] = {
    1, /* 54 */
 };
 
-static __code uint8_t tan_table[] = {
+static const uint8_t tan_table[] = {
     0, /*  0 */
     4, /*  1 */
     9, /*  2 */
@@ -290,7 +290,7 @@ static __code uint8_t tan_table[] = {
   247, /* 44 */
 };
        
-int16_t ao_atan2(int32_t dy, int32_t dx) __reentrant
+int16_t ao_atan2(int32_t dy, int32_t dx) 
 {
        int8_t  m = 1;
        int16_t a = 0;
@@ -334,10 +334,10 @@ int16_t ao_atan2(int32_t dy, int32_t dx) __reentrant
        return t * m + a;
 }
 
-static __pdata int32_t lon_dist, lat_dist;
-static __pdata uint32_t        ground_dist, range;
-static __pdata uint8_t dist_in_km;
-static __pdata int16_t bearing, elevation;
+static int32_t lon_dist, lat_dist;
+static uint32_t        ground_dist, range;
+static uint8_t dist_in_km;
+static int16_t bearing, elevation;
 
 static void
 ao_terraui_lat_dist(void)
@@ -346,7 +346,7 @@ ao_terraui_lat_dist(void)
 }
 
 static void
-ao_terraui_lon_dist(void) __reentrant
+ao_terraui_lon_dist(void) 
 {
        uint8_t c = cos_table[ao_gps_data.latitude >> 24];
        lon_dist = ao_tel_location.longitude;
@@ -418,7 +418,7 @@ ao_terraui_recover(void)
 }
 
 static void
-ao_terraui_coord(int32_t c, char plus, char minus, char extra) __reentrant
+ao_terraui_coord(int32_t c, char plus, char minus, char extra) 
 {
        uint16_t        d;
        uint8_t         m;
@@ -448,7 +448,7 @@ ao_terraui_remote(void)
 }
 
 static void
-ao_terraui_local(void) __reentrant
+ao_terraui_local(void) 
 {
        ao_terraui_coord(ao_gps_data.latitude, 'n', 's',
                         ao_terraui_local_gps());
@@ -457,11 +457,11 @@ ao_terraui_local(void) __reentrant
        ao_terraui_line(AO_LCD_ADDR(1,0));
 }
 
-static __pdata uint8_t ao_set_freq;
-static __pdata uint32_t ao_set_freq_orig;
+static uint8_t ao_set_freq;
+static uint32_t ao_set_freq_orig;
 
 static void
-ao_terraui_freq(void) __reentrant
+ao_terraui_freq(void) 
 {
        uint16_t        MHz;
        uint16_t        frac;
@@ -508,7 +508,7 @@ ao_terraui_freq_button(char b) {
        ao_radio_recv_abort();
 }
 
-static __code void (*__code ao_terraui_page[])(void) = {
+static const void (*const ao_terraui_page[])(void) = {
        ao_terraui_startup,
        ao_terraui_info,
        ao_terraui_pad,
@@ -521,8 +521,8 @@ static __code void (*__code ao_terraui_page[])(void) = {
 
 #define NUM_PAGE       (sizeof (ao_terraui_page)/sizeof (ao_terraui_page[0]))
 
-static __pdata uint8_t ao_current_page = 0;
-static __pdata uint8_t ao_shown_about = 3;
+static uint8_t ao_current_page = 0;
+static uint8_t ao_shown_about = 3;
 
 static void
 ao_terraui(void)
@@ -575,7 +575,7 @@ ao_terraui(void)
        }
 }
 
-__xdata static struct ao_task ao_terraui_task;
+static struct ao_task ao_terraui_task;
 
 static void
 ao_terramonitor(void)
@@ -619,7 +619,7 @@ ao_terramonitor(void)
        }
 }
 
-__xdata static struct ao_task ao_terramonitor_task;
+static struct ao_task ao_terramonitor_task;
 
 static void
 ao_terragps(void)
@@ -634,7 +634,7 @@ ao_terragps(void)
        }
 }
 
-__xdata static struct ao_task ao_terragps_task;
+static struct ao_task ao_terragps_task;
 
 void
 ao_terraui_init(void)
index d1c6080..5db3629 100644 (file)
 
 #include "ao.h"
 
-struct ao_task __xdata blink_0_task;
-struct ao_task __xdata blink_1_task;
-struct ao_task __xdata wakeup_task;
-struct ao_task __xdata beep_task;
-struct ao_task __xdata echo_task;
+struct ao_task blink_0_task;
+struct ao_task blink_1_task;
+struct ao_task wakeup_task;
+struct ao_task beep_task;
+struct ao_task echo_task;
 
-void delay(int n) __reentrant
+void delay(int n) 
 {
        uint8_t j = 0;
        while (--n)
@@ -32,7 +32,7 @@ void delay(int n) __reentrant
                        ao_yield();
 }
 
-static __xdata uint8_t blink_chan;
+static uint8_t blink_chan;
 
 void
 blink_0(void)
@@ -51,7 +51,7 @@ blink_0(void)
 void
 blink_1(void)
 {
-       static __xdata struct ao_adc adc;
+       static struct ao_adc adc;
 
        for (;;) {
                ao_sleep(&ao_adc_head);
@@ -75,7 +75,7 @@ wakeup(void)
 void
 beep(void)
 {
-       static __xdata struct ao_adc adc;
+       static struct ao_adc adc;
 
        for (;;) {
                ao_delay(AO_SEC_TO_TICKS(1));
index dcdcf07..7103959 100644 (file)
@@ -44,13 +44,13 @@ SECTIONS {
        } > rom
 
        . = ORIGIN(ram);
-       __data_start__ = .;
+       _start__ = .;
 
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
                __bss_start__ = .;
        } >ram
 
index f6c8e3d..b0d0384 100644 (file)
@@ -197,7 +197,7 @@ ao_blink_toggle(void)
 }
 
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
        { ao_dma_test,  "D\0DMA test" },
        { ao_spi_write, "W\0SPI write" },
        { ao_spi_read, "R\0SPI read" },
index 13a3128..cb8e10e 100644 (file)
@@ -26,7 +26,7 @@ static void scheme_cmd() {
 }
 
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
        { scheme_cmd, "l\0Run scheme interpreter" },
        { 0, NULL }
 };
index 1b443b1..63740f8 100644 (file)
@@ -198,7 +198,7 @@ ao_console_send(void)
        }
 }
 
-__code struct ao_cmds ao_demo_cmds[] = {
+const struct ao_cmds ao_demo_cmds[] = {
        { ao_video_toggle, "V\0Toggle video" },
        { ao_ball_toggle, "B\0Toggle ball" },
        { ao_ps2_read_keys, "K\0Read keys from keyboard" },
index 78c4168..97a9c43 100644 (file)
@@ -74,10 +74,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 806b484..1ebbc7a 100644 (file)
@@ -65,7 +65,7 @@ SECTIONS {
         */
 
        .textram BLOCK(8): {
-               __data_start__ = .;
+               _start__ = .;
                __text_ram_start__ = .;
                *(.ramtext)
                __text_ram_end = .;
@@ -76,7 +76,7 @@ SECTIONS {
         */
        .data BLOCK(8): {
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
 
index 098454e..d8f072a 100644 (file)
@@ -42,13 +42,13 @@ SECTIONS {
                __text_end__ = .;
        } > ram
 
-       __data_start__ = .;
+       _start__ = .;
 
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : AT (ADDR(.ARM.exidx) + SIZEOF (.ARM.exidx)) {
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
                __bss_start__ = .;
        } >ram
 
index 6a8c711..e352ed3 100644 (file)
@@ -74,10 +74,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 8a7fda4..5737cd5 100644 (file)
@@ -95,7 +95,7 @@ ao_adc_dump(void)
        AO_ADC_DUMP(&packet);
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
        { ao_adc_dump,  "a\0Display current ADC values" },
        { 0, NULL },
 };
index 24912bb..2399e6a 100644 (file)
@@ -100,7 +100,7 @@ ao_adc_poll(void)
  * Fetch a copy of the most recent ADC data
  */
 void
-ao_adc_get(__xdata struct ao_adc *packet)
+ao_adc_get(struct ao_adc *packet)
 {
 #if HAS_FLIGHT
        uint8_t i = ao_data_ring_prev(ao_sample_data);
@@ -177,7 +177,7 @@ static const char *ao_adc_name[AO_NUM_ADC] = {
 #endif
 
 static void
-ao_adc_dump(void) __reentrant
+ao_adc_dump(void) 
 {
        struct ao_data  packet;
 #ifndef AO_ADC_DUMP
@@ -203,7 +203,7 @@ ao_adc_dump(void) __reentrant
 #endif
 }
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
        { ao_adc_dump,  "a\0Display current ADC values" },
        { 0, NULL },
 };
index 7b08b89..aee9df3 100644 (file)
 
 #define ao_arch_naked_declare  __attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
index 0b4e601..f9fa14c 100644 (file)
@@ -132,7 +132,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
        ao_beep(beep);
        ao_delay(ticks);
index 4f47712..d3e3338 100644 (file)
@@ -117,10 +117,10 @@ ao_intflash_read(uint16_t pos)
  */
 
 uint8_t
-ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len)
+ao_eeprom_write(ao_pos_t pos32, void *v, uint16_t len)
 {
        uint16_t pos = pos32;
-       __xdata uint8_t *d = v;
+       uint8_t *d = v;
 
        if (pos >= ao_eeprom_total || pos + len > ao_eeprom_total)
                return 0;
@@ -151,7 +151,7 @@ ao_eeprom_write(ao_pos_t pos32, __xdata void *v, uint16_t len)
  * Read from eeprom
  */
 uint8_t
-ao_eeprom_read(ao_pos_t pos, __xdata void *v, uint16_t len)
+ao_eeprom_read(ao_pos_t pos, void *v, uint16_t len)
 {
        uint8_t *d = v;
        
index eb1ed0b..d8be366 100644 (file)
@@ -24,7 +24,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 
 /* Interrupt functions */
@@ -83,7 +83,7 @@ void start(void)
 #endif
        /* Set interrupt vector table offset */
        stm_nvic.vto = (uint32_t) &stm_interrupt_vector;
-       memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+       memcpy(&_start__, &__text_end__, &_end__ - &_start__);
        memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
        main();
 }
index a7033db..bd83f4e 100644 (file)
@@ -153,7 +153,7 @@ ao_led_toggle(AO_LED_TYPE colors)
 }
 
 void
-ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) __reentrant
+ao_led_for(AO_LED_TYPE colors, AO_LED_TYPE ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index 9d118b7..9e9436c 100644 (file)
@@ -39,8 +39,8 @@ ao_time(void)
 #endif
 
 #if AO_DATA_ALL
-volatile __data uint8_t        ao_data_interval = 1;
-volatile __data uint8_t        ao_data_count;
+volatile uint8_t       ao_data_interval = 1;
+volatile uint8_t       ao_data_count;
 #endif
 
 void stm_systick_isr(void)
index b06814d..d7cbd5b 100644 (file)
@@ -1079,7 +1079,7 @@ ao_usb_irq(void)
                control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
        { ao_usb_irq, "I\0Show USB interrupt counts" },
        { 0, NULL }
 };
index 05887d0..4d9b81a 100644 (file)
@@ -66,7 +66,7 @@ SECTIONS {
         */
 
        .textram BLOCK(8): {
-               __data_start__ = .;
+               _start__ = .;
                __text_ram_start__ = .;
                *(.ramtext)
                __text_ram_end = .;
@@ -77,7 +77,7 @@ SECTIONS {
         */
        .data BLOCK(8): {
                *(.data)        /* initialized data */
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
 
index eb285e0..90c42ad 100644 (file)
@@ -61,10 +61,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 74fdf3e..64e1d00 100644 (file)
@@ -81,10 +81,10 @@ SECTIONS {
        /* Data -- relocated to RAM, but written to ROM
         */
        .data : {
-               __data_start__ = .;
+               _start__ = .;
                *(.data)        /* initialized data */
                . = ALIGN(4);
-               __data_end__ = .;
+               _end__ = .;
        } >ram AT>rom
 
        .bss : {
index 2b23dc5..571830b 100644 (file)
@@ -180,7 +180,7 @@ ao_adc_one(void)
 }
 #endif
 
-__code struct ao_cmds ao_adc_cmds[] = {
+const struct ao_cmds ao_adc_cmds[] = {
        { ao_adc_dump,  "a\0Display current ADC values" },
 #if AO_ADC_DEBUG
        { ao_adc_one,   "A ch\0Display one ADC channel" },
index db6324c..1564295 100644 (file)
 
 #define ao_arch_naked_declare  __attribute__((naked))
 #define ao_arch_naked_define
-#define __pdata
-#define __data
-#define __xdata
-#define __code const
-#define __reentrant
 #define __interrupt(n)
 #define __at(n)
 
index 1513723..abcc116 100644 (file)
@@ -376,7 +376,7 @@ ao_beep(uint8_t beep)
 }
 
 void
-ao_beep_for(uint8_t beep, uint16_t ticks) __reentrant
+ao_beep_for(uint8_t beep, uint16_t ticks) 
 {
        ao_beep(beep);
        ao_delay(ticks);
index a67f6f1..81878d8 100644 (file)
@@ -35,7 +35,7 @@
 extern void main(void);
 extern char __stack__;
 extern char __text_start__, __text_end__;
-extern char __data_start__, __data_end__;
+extern char _start__, _end__;
 extern char __bss_start__, __bss_end__;
 #if RELOCATE_INTERRUPT
 extern char __interrupt_rom__, __interrupt_start__, __interrupt_end__;
@@ -88,7 +88,7 @@ void start(void)
        stm_syscfg.cfgr1 = (stm_syscfg.cfgr1 & ~(STM_SYSCFG_CFGR1_MEM_MODE_MASK << STM_SYSCFG_CFGR1_MEM_MODE)) |
                (STM_SYSCFG_CFGR1_MEM_MODE_MAIN_FLASH << STM_SYSCFG_CFGR1_MEM_MODE);
 #endif
-       memcpy(&__data_start__, &__text_end__, &__data_end__ - &__data_start__);
+       memcpy(&_start__, &__text_end__, &_end__ - &_start__);
        memset(&__bss_start__, '\0', &__bss_end__ - &__bss_start__);
        main();
 }
index 0f39bef..a162932 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "ao.h"
 
-__pdata uint16_t ao_led_enable;
+uint16_t ao_led_enable;
 
 void
 ao_led_on(uint16_t colors)
@@ -76,7 +76,7 @@ ao_led_toggle(uint16_t colors)
 }
 
 void
-ao_led_for(uint16_t colors, uint16_t ticks) __reentrant
+ao_led_for(uint16_t colors, uint16_t ticks) 
 {
        ao_led_on(colors);
        ao_delay(ticks);
index 1a6198a..17c934a 100644 (file)
@@ -157,7 +157,7 @@ ao_storage_device_write(uint32_t pos, void *v, uint16_t len)
 }
 
 uint8_t
-ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
+ao_storage_device_read(uint32_t pos, void *d, uint16_t len) 
 {
        if (pos >= ao_storage_total || pos + len > ao_storage_total)
                return 0;
@@ -166,7 +166,7 @@ ao_storage_device_read(uint32_t pos, __xdata void *d, uint16_t len) __reentrant
 }
 
 void
-ao_storage_flush(void) __reentrant
+ao_storage_flush(void) 
 {
 }
 
@@ -179,7 +179,7 @@ ao_storage_setup(void)
 }
 
 void
-ao_storage_device_info(void) __reentrant
+ao_storage_device_info(void) 
 {
        printf ("Using internal flash, page %d bytes, total %d bytes\n",
                ao_storage_block, ao_storage_total);
index 50fd67b..1def5f6 100644 (file)
@@ -36,8 +36,8 @@ ao_time(void)
 }
 
 #if AO_DATA_ALL
-volatile __data uint8_t        ao_data_interval = 1;
-volatile __data uint8_t        ao_data_count;
+volatile uint8_t       ao_data_interval = 1;
+volatile uint8_t       ao_data_count;
 #endif
 
 void stm_systick_isr(void)
index c4860d8..ff29484 100644 (file)
@@ -1626,7 +1626,7 @@ ao_usb_irq(void)
                control_count, out_count, in_count, int_count, reset_count);
 }
 
-__code struct ao_cmds ao_usb_cmds[] = {
+const struct ao_cmds ao_usb_cmds[] = {
        { ao_usb_irq, "I\0Show USB interrupt counts" },
        { 0, NULL }
 };
index 115b3e9..790d7a4 100644 (file)
@@ -31,7 +31,7 @@ set_logging(void)
        ao_wakeup(&ao_log_running);
 }
 
-__code struct ao_cmds ao_firetwo_cmds[] = {
+const struct ao_cmds ao_firetwo_cmds[] = {
         { set_logging,  "L <0 off, 1 on>\0Log sensors to flash" },
         { 0,    NULL },
 };
index a9933d5..428b1a7 100644 (file)
@@ -287,7 +287,7 @@ ao_lco_set_debug(void)
                ao_lco_debug = ao_cmd_lex_i != 0;
 }
 
-__code struct ao_cmds ao_lco_cmds[] = {
+const struct ao_cmds ao_lco_cmds[] = {
        { ao_lco_set_debug,     "D <0 off, 1 on>\0Debug" },
        { ao_lco_search,        "s\0Search for pad boxes" },
        { 0, NULL }
index 135c6f1..e1ed572 100644 (file)
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #include <string.h>
 #include <stdio.h>
index 03c327c..afaadb1 100644 (file)
 #ifndef _AO_EEPROM_READ_H_
 #define _AO_EEPROM_READ_H_
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #include <stdint.h>
 #include <stdio.h>
index 0913e7b..a171930 100644 (file)
@@ -119,11 +119,7 @@ struct ao_adc {
 
 #endif
 
-#define __pdata
-#define __data
-#define __xdata
-#define __code
-#define __reentrant
+#define const
 
 #define HAS_FLIGHT 1
 #define HAS_IGNITE 1
index 61e7905..11c5460 100644 (file)
@@ -83,8 +83,8 @@ struct ao_gps_tracking_orig {
 #define ao_telemetry_satellite ao_gps_tracking_orig
 #define ao_telemetry_satellite_info ao_gps_sat_orig
 
-extern __xdata struct ao_telemetry_location    ao_gps_data;
-extern __xdata struct ao_telemetry_satellite   ao_gps_tracking_data;
+extern struct ao_telemetry_location    ao_gps_data;
+extern struct ao_telemetry_satellite   ao_gps_tracking_data;
 
 uint8_t ao_gps_mutex;
 
index 05334bb..0833e4f 100644 (file)
@@ -89,8 +89,8 @@ struct ao_telemetry_satellite {
 #define ao_gps_tracking_orig ao_telemetry_satellite
 #define ao_gps_sat_orig ao_telemetry_satellite_info
 
-extern __xdata struct ao_telemetry_location    ao_gps_data;
-extern __xdata struct ao_telemetry_satellite   ao_gps_tracking_data;
+extern struct ao_telemetry_location    ao_gps_data;
+extern struct ao_telemetry_satellite   ao_gps_tracking_data;
 
 uint8_t ao_gps_mutex;
 
index d329f67..c7a4891 100644 (file)
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __data
-#define __pdata
-#define __xdata
-#define __reentrant
 
 #include <ao_int64.h>
 #include <ao_int64.c>
index 4876d21..7708c33 100644 (file)
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  */
 
-#define __xdata
-#define __data
-#define __pdata
-#define __reentrant
 
 #include <stdint.h>
 #include <ao_ms5607.h>
index d908f4d..0eacdf5 100644 (file)
@@ -45,7 +45,7 @@ ao_relay_control(uint8_t output)
 }
 
 static void
-ao_relay_select(void) __reentrant
+ao_relay_select(void) 
 {
        uint8_t output;
 
@@ -59,7 +59,7 @@ ao_relay_select(void) __reentrant
                ao_relay_control(output);
 }
 
-static __code struct ao_cmds ao_relay_cmds[] = {
+static const struct ao_cmds ao_relay_cmds[] = {
        { ao_relay_select, "R <output>\0Select relay output" },
        { 0, NULL }
 };