/*
 *  TOPPERS ECHONET Lite Communication Middleware
 *
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 *
 *  上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
 *      免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  の責任を負わない．
 *
 *  @(#) $Id$
 */
#include "mbedcall.h"
#include "mbed_api.h"

#define __asm_mbedcall(...) do { \
	__asm__ __volatile__ ( "push { lr }" ); \
	__asm__ __volatile__ ( "svc 1" \
	: "=r"(r0) : __VA_ARGS__ : "memory"); \
	__asm__ __volatile__ ( "pop { lr }" ); \
	return r0; \
	} while (0)

static inline long __mbedcall0(long n)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0");
	__asm_mbedcall("r"(r7));
}

static inline long __mbedcall1(long n, long a)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	__asm_mbedcall("r"(r7), "0"(r0));
}

static inline long __mbedcall2(long n, long a, long b)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	register long r1 __asm__("r1") = b;
	__asm_mbedcall("r"(r7), "0"(r0), "r"(r1));
}

static inline long __mbedcall3(long n, long a, long b, long c)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	register long r1 __asm__("r1") = b;
	register long r2 __asm__("r2") = c;
	__asm_mbedcall("r"(r7), "0"(r0), "r"(r1), "r"(r2));
}

static inline long __mbedcall4(long n, long a, long b, long c, long d)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	register long r1 __asm__("r1") = b;
	register long r2 __asm__("r2") = c;
	register long r3 __asm__("r3") = d;
	__asm_mbedcall("r"(r7), "0"(r0), "r"(r1), "r"(r2), "r"(r3));
}

static inline long __mbedcall5(long n, long a, long b, long c, long d, long e)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	register long r1 __asm__("r1") = b;
	register long r2 __asm__("r2") = c;
	register long r3 __asm__("r3") = d;
	register long r4 __asm__("r4") = e;
	__asm_mbedcall("r"(r7), "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4));
}

static inline long __mbedcall6(long n, long a, long b, long c, long d, long e, long f)
{
	register long r7 __asm__("r7") = n;
	register long r0 __asm__("r0") = a;
	register long r1 __asm__("r1") = b;
	register long r2 __asm__("r2") = c;
	register long r3 __asm__("r3") = d;
	register long r4 __asm__("r4") = e;
	register long r5 __asm__("r5") = f;
	__asm_mbedcall("r"(r7), "0"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r5));
}

void analogin_init(analogin_t *obj, PinName pin)
{
	__mbedcall2(MBED_analogin_init, (long)obj, (long)pin);
}

uint16_t analogin_read_u16(analogin_t *obj)
{
	return __mbedcall1(MBED_analogin_read_u16, (long)obj);
}

void gpio_init(gpio_t *obj, PinName pin)
{
	__mbedcall2(MBED_gpio_init, (long)obj, (long)pin);
}

void gpio_mode(gpio_t *obj, PinMode mode)
{
	__mbedcall2(MBED_gpio_mode, (long)obj, (long)mode);
}

void gpio_dir(gpio_t *obj, PinDirection direction)
{
	__mbedcall2(MBED_gpio_dir, (long)obj, (long)direction);
}

void gpio_write(gpio_t *obj, int value)
{
	__mbedcall2(MBED_gpio_write, (long)obj, (long)value);
}

int  gpio_read(gpio_t *obj)
{
	return __mbedcall1(MBED_gpio_read, (long)obj);
}

int i2c_start(i2c_t *obj)
{
	return __mbedcall1(MBED_i2c_start, (long)obj);
}

int i2c_stop(i2c_t *obj)
{
	return __mbedcall1(MBED_i2c_stop, (long)obj);
}

void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{
	__mbedcall3(MBED_i2c_init, (long)obj, (long)sda, (long)scl);
}

int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{
	return __mbedcall5(MBED_i2c_read, (long)obj, (long)address, (long)data, (long)length, (long)stop);
}

int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
	return __mbedcall5(MBED_i2c_write, (long)obj, (long)address, (long)data, (long)length, (long)stop);
}

int i2c_byte_read(i2c_t *obj, int last)
{
	return __mbedcall2(MBED_i2c_byte_read, (long)obj, (long)last);
}

int i2c_byte_write(i2c_t *obj, int data)
{
	return __mbedcall2(MBED_i2c_byte_write, (long)obj, (long)data);
}

void pin_function(PinName pin, int function)
{
	__mbedcall2(MBED_pin_function, (long)pin, (long)function);
}

void pin_mode(PinName pin, PinMode mode)
{
	__mbedcall2(MBED_pin_mode, (long)pin, (long)mode);
}

void pwmout_free(pwmout_t* obj)
{
	__mbedcall1(MBED_pwmout_free, (long)obj);
}

void pwmout_init(pwmout_t* obj, PinName pin)
{
	__mbedcall2(MBED_pwmout_init, (long)obj, (long)pin);
}

void pwmout_pulsewidth_us(pwmout_t* obj, int us)
{
	__mbedcall2(MBED_pwmout_pulsewidth_us, (long)obj, (long)us);
}

void rtc_init(void)
{
	__mbedcall0(MBED_rtc_init);
}

void rtc_free(void)
{
	__mbedcall0(MBED_rtc_free);
}

int rtc_isenabled(void)
{
	return __mbedcall0(MBED_rtc_isenabled);
}

time_t rtc_read(void)
{
	return __mbedcall0(MBED_rtc_read);
}

void rtc_write(time_t t)
{
	__mbedcall1(MBED_rtc_write, (long)t);
}

void serial_baud(serial_t *obj, int baudrate)
{
	__mbedcall2(MBED_serial_baud, (long)obj, (long)baudrate);
}

void serial_init(serial_t *obj, PinName tx, PinName rx)
{
	__mbedcall3(MBED_serial_init, (long)obj, (long)tx, (long)rx);
}

int serial_readable(serial_t *obj)
{
	return __mbedcall1(MBED_serial_readable, (long)obj);
}

int serial_getc(serial_t *obj)
{
	return __mbedcall1(MBED_serial_getc, (long)obj);
}

void serial_putc(serial_t *obj, int c)
{
	__mbedcall2(MBED_serial_putc, (long)obj, (long)c);
}

void us_ticker_init(void)
{
	__mbedcall0(MBED_us_ticker_init);
}

uint32_t us_ticker_read(void)
{
	return __mbedcall0(MBED_us_ticker_read);
}

void us_ticker_set_interrupt(timestamp_t timestamp)
{
	__mbedcall1(MBED_us_ticker_set_interrupt, (long)timestamp);
}

void us_ticker_disable_interrupt(void)
{
	__mbedcall0(MBED_us_ticker_disable_interrupt);
}

void us_ticker_clear_interrupt(void)
{
	__mbedcall0(MBED_us_ticker_clear_interrupt);
}

int SD_begin()
{
	return __mbedcall0(MBED_SD_begin);
}

void __disable_irq()
{
	__mbedcall0(MBED___disable_irq);
}

void __enable_irq()
{
	__mbedcall0(MBED___enable_irq);
}

#include "assert.c"
#include "board.c"
#include "error.c"
#include "gpio.c"
#include "lp_ticker_api.c"
#include "mbed_interface.c"
#include "pinmap_common.c"
//#include "rtc_time.c"
#include "semihost_api.c"
#include "ticker_api.c"
#include "us_ticker_api.c"
#include "wait_api.c"