mirror of
https://github.com/oopuuu/zTC1.git
synced 2025-12-17 23:48:13 +08:00
805 lines
21 KiB
C
805 lines
21 KiB
C
#include "common.h"
|
|
#include "moc_api.h"
|
|
|
|
extern const mico_api_t *lib_api_p;
|
|
|
|
extern platform_spi_driver_t platform_spi_drivers[];
|
|
extern platform_i2c_driver_t platform_i2c_drivers[];
|
|
|
|
|
|
/* WIFI MGR */
|
|
OSStatus StartNetwork(network_InitTypeDef_st* inNetworkInitPara)
|
|
{
|
|
return lib_api_p->micoWlanStart(inNetworkInitPara);
|
|
}
|
|
OSStatus StartAdvNetwork(network_InitTypeDef_adv_st* inNetworkInitParaAdv)
|
|
{
|
|
return lib_api_p->micoWlanStartAdv(inNetworkInitParaAdv);
|
|
}
|
|
|
|
OSStatus micoWlanStartEnt(network_Enterprise_st* inNetworkInitPara)
|
|
{
|
|
return lib_api_p->micoWlanStartEnt(inNetworkInitPara);
|
|
}
|
|
|
|
OSStatus getNetPara(IPStatusTypedef *outNetpara, WiFi_Interface inInterface)
|
|
{
|
|
return lib_api_p->micoWlanGetIPStatus(outNetpara, inInterface);
|
|
}
|
|
OSStatus CheckNetLink(LinkStatusTypeDef *outStatus)
|
|
{
|
|
return lib_api_p->micoWlanGetLinkStatus(outStatus);
|
|
}
|
|
void mxchipStartScan(void)
|
|
{
|
|
lib_api_p->micoWlanStartScan();
|
|
}
|
|
void mxchipStartAdvScan(void)
|
|
{
|
|
lib_api_p->micoWlanStartScanAdv();
|
|
}
|
|
OSStatus wifi_power_down(void)
|
|
{
|
|
return lib_api_p->micoWlanPowerOff();
|
|
}
|
|
OSStatus wifi_power_up(void)
|
|
{
|
|
return lib_api_p->micoWlanPowerOn();
|
|
}
|
|
OSStatus wlan_disconnect(void)
|
|
{
|
|
return lib_api_p->micoWlanSuspend();
|
|
}
|
|
OSStatus sta_disconnect(void)
|
|
{
|
|
return lib_api_p->micoWlanSuspendStation();
|
|
}
|
|
OSStatus uap_stop(void)
|
|
{
|
|
return lib_api_p->micoWlanSuspendSoftAP();
|
|
}
|
|
OSStatus OpenEasylink2_withdata(int inTimeout)
|
|
{
|
|
return lib_api_p->micoWlanStartEasyLink(inTimeout);
|
|
}
|
|
OSStatus OpenEasylink(int inTimeout)
|
|
{
|
|
return lib_api_p->micoWlanStartEasyLinkPlus(inTimeout);
|
|
}
|
|
OSStatus CloseEasylink2(void)
|
|
{
|
|
return lib_api_p->micoWlanStopEasyLink();
|
|
}
|
|
OSStatus CloseEasylink(void)
|
|
{
|
|
return lib_api_p->micoWlanStopEasyLinkPlus();
|
|
}
|
|
OSStatus OpenConfigmodeWPS(int inTimeout)
|
|
{
|
|
return lib_api_p->micoWlanStartWPS(inTimeout);
|
|
}
|
|
OSStatus CloseConfigmodeWPS(void)
|
|
{
|
|
return lib_api_p->micoWlanStopWPS();
|
|
}
|
|
OSStatus OpenAirkiss(int inTimeout)
|
|
{
|
|
return lib_api_p->micoWlanStartAirkiss(inTimeout);
|
|
}
|
|
OSStatus CloseAirkiss(void)
|
|
{
|
|
return lib_api_p->micoWlanStopAirkiss();
|
|
}
|
|
void ps_enable(void)
|
|
{
|
|
lib_api_p->micoWlanEnablePowerSave();
|
|
}
|
|
void ps_disable(void)
|
|
{
|
|
lib_api_p->micoWlanDisablePowerSave();
|
|
}
|
|
void wifimgr_debug_enable(bool enable)
|
|
{
|
|
lib_api_p->wifimgr_debug_enable(enable);
|
|
}
|
|
|
|
int mico_wlan_monitor_no_easylink(void)
|
|
{
|
|
return lib_api_p->mico_wlan_monitor_no_easylink();
|
|
}
|
|
|
|
|
|
int mico_wlan_monitor_rx_type(int type)
|
|
{
|
|
return lib_api_p->mico_wlan_monitor_rx_type(type);
|
|
}
|
|
int mico_wlan_start_monitor(void)
|
|
{
|
|
return lib_api_p->mico_wlan_start_monitor();
|
|
}
|
|
int mico_wlan_stop_monitor(void)
|
|
{
|
|
return lib_api_p->mico_wlan_stop_monitor();
|
|
}
|
|
int mico_wlan_set_channel(uint8_t channel)
|
|
{
|
|
return lib_api_p->mico_wlan_set_channel((int)channel);
|
|
}
|
|
void mico_wlan_register_monitor_cb(monitor_cb_t fn)
|
|
{
|
|
lib_api_p->mico_wlan_register_monitor_cb(fn);
|
|
}
|
|
|
|
int mxchip_active_scan(char*ssid, int is_adv)
|
|
{
|
|
return lib_api_p->mxchip_active_scan(ssid, is_adv);
|
|
}
|
|
|
|
void wlan_set_channel(int channel)
|
|
{
|
|
lib_api_p->wlan_set_channel(channel);
|
|
}
|
|
|
|
|
|
/* HAL: GPIO
|
|
{
|
|
return lib_api_p->;
|
|
} FLASH
|
|
{
|
|
return lib_api_p->;
|
|
} UART */
|
|
mico_logic_partition_t* MicoFlashGetInfo( mico_partition_t inPartition )
|
|
{
|
|
return lib_api_p->MicoFlashGetInfo(inPartition);
|
|
}
|
|
OSStatus MicoFlashErase(mico_partition_t inPartition, uint32_t off_set, uint32_t size)
|
|
{
|
|
return lib_api_p->MicoFlashErase(inPartition, off_set, size);
|
|
}
|
|
OSStatus MicoFlashWrite( mico_partition_t inPartition, volatile uint32_t* off_set, uint8_t* inBuffer ,uint32_t inBufferLength)
|
|
{
|
|
lib_api_p->MicoFlashWrite(inPartition, off_set, inBuffer, inBufferLength);
|
|
return 0;
|
|
}
|
|
OSStatus MicoFlashRead( mico_partition_t inPartition, volatile uint32_t* off_set, uint8_t* outBuffer, uint32_t inBufferLength)
|
|
{
|
|
return lib_api_p->MicoFlashRead(inPartition, off_set, outBuffer, inBufferLength);
|
|
}
|
|
OSStatus MicoFlashEnableSecurity( mico_partition_t partition, uint32_t off_set, uint32_t size )
|
|
{
|
|
return lib_api_p->MicoFlashEnableSecurity(partition, off_set, size );
|
|
}
|
|
|
|
OSStatus MicoGpioInitialize( mico_gpio_t gpio, mico_gpio_config_t configuration )
|
|
{
|
|
return lib_api_p->MicoGpioInitialize(gpio, configuration );
|
|
}
|
|
OSStatus MicoGpioFinalize( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioFinalize(gpio);
|
|
}
|
|
OSStatus MicoGpioOutputHigh( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioOutputHigh(gpio);
|
|
}
|
|
OSStatus MicoGpioOutputLow( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioOutputLow(gpio);
|
|
}
|
|
OSStatus MicoGpioOutputTrigger( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioOutputTrigger(gpio);
|
|
}
|
|
bool MicoGpioInputGet( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioInputGet(gpio);
|
|
}
|
|
OSStatus MicoGpioEnableIRQ( mico_gpio_t gpio, mico_gpio_irq_trigger_t trigger, mico_gpio_irq_handler_t handler, void* arg )
|
|
{
|
|
return lib_api_p->MicoGpioEnableIRQ(gpio, trigger, handler, arg );
|
|
}
|
|
OSStatus MicoGpioDisableIRQ( mico_gpio_t gpio )
|
|
{
|
|
return lib_api_p->MicoGpioDisableIRQ(gpio);
|
|
}
|
|
|
|
OSStatus MicoUartInitialize( mico_uart_t uart, const mico_uart_config_t* config, ring_buffer_t* optional_rx_buffer )
|
|
{
|
|
return lib_api_p->MicoUartInitialize(uart, config, optional_rx_buffer );
|
|
}
|
|
OSStatus MicoUartFinalize( mico_uart_t uart )
|
|
{
|
|
return lib_api_p->MicoUartFinalize(uart);
|
|
}
|
|
OSStatus MicoUartSend( mico_uart_t uart, const void* data, uint32_t size )
|
|
{
|
|
return lib_api_p->MicoUartSend(uart, data, size );
|
|
}
|
|
OSStatus MicoUartRecv( mico_uart_t uart, void* data, uint32_t size, uint32_t timeout )
|
|
{
|
|
return lib_api_p->MicoUartRecv(uart, data, size, timeout );
|
|
}
|
|
uint32_t MicoUartGetLengthInBuffer( mico_uart_t uart )
|
|
{
|
|
return lib_api_p->MicoUartGetLengthInBuffer(uart);
|
|
}
|
|
OSStatus MicoUartPinRedirect( mico_uart_t uart )
|
|
{
|
|
lib_api_p->MicoUartPinRedirect(uart);
|
|
return kNoErr;
|
|
}
|
|
|
|
void wifistate_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->wifistate_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
|
|
void wifidebug_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->wifidebug_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void wifiscan_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->wifiscan_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
|
|
void ifconfig_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->ifconfig_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void arp_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->arp_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void ping_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->ping_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void dns_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->dns_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void task_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->task_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void socket_show_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->socket_show_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void memory_show_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->memory_show_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void memory_dump_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->memory_dump_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void memory_set_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->memory_set_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void memp_dump_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->memp_dump_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
void driver_state_Command(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv)
|
|
{
|
|
lib_api_p->driver_state_Command(pcWriteBuffer, xWriteBufferLen, argc, argv);
|
|
}
|
|
|
|
int wlan_driver_version( char* outVersion, uint8_t inLength )
|
|
{
|
|
return lib_api_p->wlan_driver_version(outVersion, inLength);
|
|
}
|
|
|
|
void mico_wlan_get_mac_address( uint8_t *mac )
|
|
{
|
|
lib_api_p->wlan_get_mac_address(mac);
|
|
}
|
|
|
|
void InitMd5(md5_context*md5)
|
|
{
|
|
lib_api_p->InitMd5(md5);
|
|
}
|
|
void Md5Update(md5_context* md5, unsigned char *input, int ilen)
|
|
{
|
|
lib_api_p->Md5Update(md5, input, ilen);
|
|
}
|
|
void Md5Final(md5_context* md5, uint8_t* hash)
|
|
{
|
|
lib_api_p->Md5Final(md5, hash);
|
|
}
|
|
int Md5Hash(const uint8_t* data, uint32_t len, uint8_t* hash)
|
|
{
|
|
return lib_api_p->Md5Hash(data, len, hash);
|
|
}
|
|
void AesEncryptDirect(Aes* aes, uint8_t* out, const uint8_t* in)
|
|
{
|
|
lib_api_p->AesEncryptDirect(aes, out, in);
|
|
}
|
|
void AesDecryptDirect(Aes* aes, uint8_t* out, const uint8_t* in)
|
|
{
|
|
lib_api_p->AesDecryptDirect(aes, out, in);
|
|
}
|
|
//int AesSetKeyDirect(Aes* aes, const byte* key, word32 ilen,const byte* out, int dir);
|
|
int AesSetKeyDirect(Aes* aes, const unsigned char* key, unsigned int len, const unsigned char* iv, int dir)
|
|
{
|
|
return lib_api_p->AesSetKeyDirect(aes, key, len, iv, dir);
|
|
}
|
|
int aes_encrypt(int sz, const char * key, const char * in, char * out)
|
|
{
|
|
return lib_api_p->aes_encrypt(sz, key, in, out);
|
|
}
|
|
int aes_decrypt(int sz, const char * key, const char * in, char * out)
|
|
{
|
|
return lib_api_p->aes_decrypt(sz, key, in, out);
|
|
}
|
|
int AesSetKey(Aes* aes, const uint8_t* key, unsigned int len,
|
|
const uint8_t* iv, int dir)
|
|
{
|
|
return lib_api_p->AesSetKey(aes, key, len, iv, dir);
|
|
}
|
|
int AesSetIV(Aes* aes, const uint8_t* iv)
|
|
{
|
|
return lib_api_p->AesSetIV(aes, iv);
|
|
}
|
|
int AesCbcEncrypt(Aes* aes, uint8_t* out,
|
|
const uint8_t* in, unsigned int sz)
|
|
{
|
|
return lib_api_p->AesCbcEncrypt(aes, out, in, sz);
|
|
}
|
|
int AesCbcDecrypt(Aes* aes, uint8_t* out,
|
|
const uint8_t* in, unsigned int sz){
|
|
return lib_api_p->AesCbcDecrypt(aes, out, in, sz);
|
|
}
|
|
|
|
OSStatus mxchipInit(void)
|
|
{
|
|
lib_api_p->mxchipInit();
|
|
return kNoErr;
|
|
}
|
|
|
|
micoMemInfo_t* mico_memory_info(void)
|
|
{
|
|
return lib_api_p->mico_memory_info();
|
|
}
|
|
char* system_lib_version(void)
|
|
{
|
|
return lib_api_p->library_version;
|
|
}
|
|
|
|
void MicoSystemReboot(void)
|
|
{
|
|
lib_api_p->MicoSystemReboot();
|
|
}
|
|
|
|
char *mico_get_bootloader_ver(void)
|
|
{
|
|
return "bootloader";
|
|
}
|
|
|
|
void MicoSystemStandBy( uint32_t secondsToWakeup )
|
|
{
|
|
lib_api_p->wifi_off_mcu_standby(secondsToWakeup);
|
|
}
|
|
|
|
char *get_ali_key(void)
|
|
{
|
|
return lib_api_p->get_ali_key();
|
|
}
|
|
|
|
char *get_ali_secret(void)
|
|
{
|
|
return lib_api_p->get_ali_secret();
|
|
}
|
|
|
|
void MicoRtcInitialize(void)
|
|
{
|
|
lib_api_p->MicoRtcInitialize();
|
|
}
|
|
|
|
OSStatus MicoRtcGetTime(mico_rtc_time_t* time)
|
|
{
|
|
int ret = lib_api_p->MicoRtcGetTime(time);
|
|
|
|
time->month += 1;
|
|
time->year -= 100;
|
|
return ret;
|
|
}
|
|
|
|
OSStatus MicoRtcSetTime(mico_rtc_time_t* time)
|
|
{
|
|
time->month -= 1;
|
|
time->year += 100;
|
|
return lib_api_p->MicoRtcSetTime(time);
|
|
}
|
|
|
|
#if defined ( __ICCARM__ )
|
|
struct tm *localtime(const time_t * time)
|
|
{
|
|
return lib_api_p->localtime(time);
|
|
}
|
|
#endif
|
|
|
|
char *asctime(const struct tm *tm)
|
|
{
|
|
return lib_api_p->asctime(tm);
|
|
}
|
|
|
|
int wifi_set_country(int country)
|
|
{
|
|
return lib_api_p->wifi_set_country(country);
|
|
}
|
|
|
|
int switch_active_firmware(void)
|
|
{
|
|
return lib_api_p->switch_active_firmrware();
|
|
}
|
|
|
|
int get_last_reset_reason(void)
|
|
{
|
|
return lib_api_p->last_reset_reason();
|
|
}
|
|
|
|
void system_config_set(mico_system_config_t *cfg)
|
|
{
|
|
lib_api_p->system_config_set(cfg);
|
|
}
|
|
|
|
mico_system_config_t *system_config_get(void)
|
|
{
|
|
return lib_api_p->system_config_get();
|
|
}
|
|
|
|
int aon_write( uint32_t offset, uint8_t* in ,uint32_t len)
|
|
{
|
|
return lib_api_p->aon_write(offset, in, len);
|
|
}
|
|
|
|
int aon_read( uint32_t offset, uint8_t* out, uint32_t len)
|
|
{
|
|
return lib_api_p->aon_read(offset, out, len);
|
|
}
|
|
|
|
|
|
int lwip_ioctl(int s, long cmd, void *argp)
|
|
{
|
|
return lib_api_p->lwip_apis->lwip_ioctl(s, cmd, argp);
|
|
}
|
|
int lwip_fcntl(int s, int cmd, int val)
|
|
{
|
|
return lib_api_p->lwip_apis->lwip_fcntl(s, cmd, val);
|
|
}
|
|
|
|
void lwip_freeaddrinfo(struct addrinfo *ai)
|
|
{
|
|
lib_api_p->lwip_apis->lwip_freeaddrinfo(ai);
|
|
}
|
|
|
|
int lwip_getaddrinfo(const char *nodename,
|
|
const char *servname,
|
|
const struct addrinfo *hints,
|
|
struct addrinfo **res)
|
|
{
|
|
return lib_api_p->lwip_apis->lwip_getaddrinfo(nodename,
|
|
servname, hints, res);
|
|
}
|
|
|
|
char * ipaddr_ntoa(const ip_addr_t *addr)
|
|
{
|
|
return lib_api_p->lwip_apis->ipaddr_ntoa(addr);
|
|
}
|
|
uint32_t ipaddr_addr(const char *cp)
|
|
{
|
|
return lib_api_p->lwip_apis->ipaddr_addr(cp);
|
|
}
|
|
|
|
uint16_t
|
|
lwip_htons(uint16_t n)
|
|
{
|
|
return ((n & 0xff) << 8) | ((n & 0xff00) >> 8);
|
|
}
|
|
|
|
/**
|
|
* Convert an uint16_t from network- to host byte order.
|
|
*
|
|
* @param n uint16_t in network byte order
|
|
* @return n in host byte order
|
|
*/
|
|
uint16_t
|
|
lwip_ntohs(uint16_t n)
|
|
{
|
|
return lwip_htons(n);
|
|
}
|
|
|
|
/**
|
|
* Convert an uint32_t from host- to network byte order.
|
|
*
|
|
* @param n uint32_t in host byte order
|
|
* @return n in network byte order
|
|
*/
|
|
uint32_t
|
|
lwip_htonl(uint32_t n)
|
|
{
|
|
return ((n & 0xff) << 24) |
|
|
((n & 0xff00) << 8) |
|
|
((n & 0xff0000UL) >> 8) |
|
|
((n & 0xff000000UL) >> 24);
|
|
}
|
|
|
|
/**
|
|
* Convert an uint32_t from network- to host byte order.
|
|
*
|
|
* @param n uint32_t in network byte order
|
|
* @return n in host byte order
|
|
*/
|
|
uint32_t
|
|
lwip_ntohl(uint32_t n)
|
|
{
|
|
return lwip_htonl(n);
|
|
}
|
|
|
|
OSStatus MicoPwmInitialize(mico_pwm_t pwm, uint32_t freequency, float duty_cycle)
|
|
{
|
|
return lib_api_p->pwm_apis->pwm_init(pwm, freequency, duty_cycle);
|
|
}
|
|
|
|
OSStatus MicoPwmStart(mico_pwm_t pwm)
|
|
{
|
|
return lib_api_p->pwm_apis->pwm_start(pwm);
|
|
}
|
|
|
|
OSStatus MicoPwmStop(mico_pwm_t pwm)
|
|
{
|
|
return lib_api_p->pwm_apis->pwm_stop(pwm);
|
|
}
|
|
|
|
OSStatus MicoWdgInitialize( uint32_t timeout )
|
|
{
|
|
return lib_api_p->wdg_apis->wdg_init(timeout);
|
|
}
|
|
|
|
void MicoWdgReload( void )
|
|
{
|
|
lib_api_p->wdg_apis->wdg_reload();
|
|
}
|
|
|
|
OSStatus MicoWdgFinalize( void )
|
|
{
|
|
return lib_api_p->wdg_apis->wdg_stop();
|
|
}
|
|
|
|
int Cyassl_get_fd(const void *ssl)
|
|
{
|
|
return lib_api_p->ssl_get_fd(ssl);
|
|
}
|
|
|
|
OSStatus MicoAdcInitialize( mico_adc_t adc, uint32_t sampling_cycle )
|
|
{
|
|
return lib_api_p->adc_apis->MicoAdcInitialize(adc, sampling_cycle);
|
|
}
|
|
|
|
OSStatus MicoAdcFinalize( mico_adc_t adc )
|
|
{
|
|
return lib_api_p->adc_apis->MicoAdcFinalize(adc);
|
|
}
|
|
|
|
OSStatus MicoAdcTakeSample( mico_adc_t adc, uint16_t* output )
|
|
{
|
|
return lib_api_p->adc_apis->MicoAdcTakeSample(adc, output);
|
|
}
|
|
|
|
OSStatus MicoAdcTakeSampleStreram( mico_adc_t adc, void* buffer, uint16_t buffer_length )
|
|
{
|
|
return lib_api_p->adc_apis->MicoAdcTakeSampleStreram(adc, buffer, buffer_length);
|
|
}
|
|
|
|
OSStatus MicoI2cInitialize( mico_i2c_device_t* device )
|
|
{
|
|
OSStatus result;
|
|
|
|
if( platform_i2c_drivers[device->port].i2c_mutex == NULL)
|
|
mico_rtos_init_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
|
|
mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
result = lib_api_p->i2c_apis->i2c_init(device);
|
|
mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
return result;
|
|
}
|
|
|
|
OSStatus MicoI2cFinalize( mico_i2c_device_t* device )
|
|
{
|
|
if( platform_i2c_drivers[device->port].i2c_mutex != NULL){
|
|
mico_rtos_deinit_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
platform_i2c_drivers[device->port].i2c_mutex = NULL;
|
|
}
|
|
|
|
return lib_api_p->i2c_apis->i2c_deinit(device);
|
|
}
|
|
|
|
bool MicoI2cProbeDevice( mico_i2c_device_t* device, int retries )
|
|
{
|
|
bool ret;
|
|
|
|
mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
ret = lib_api_p->i2c_apis->i2c_probe_device(device, retries);
|
|
mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
return ret;
|
|
}
|
|
|
|
OSStatus MicoI2cBuildTxMessage( mico_i2c_message_t* message, const void* tx_buffer, uint16_t tx_buffer_length, uint16_t retries )
|
|
{
|
|
return lib_api_p->i2c_apis->i2c_build_tx_msg(message, tx_buffer, tx_buffer_length, retries );
|
|
}
|
|
|
|
OSStatus MicoI2cBuildRxMessage( mico_i2c_message_t* message, void* rx_buffer, uint16_t rx_buffer_length, uint16_t retries )
|
|
{
|
|
return lib_api_p->i2c_apis->i2c_build_rx_msg(message, rx_buffer, rx_buffer_length, retries );
|
|
}
|
|
|
|
OSStatus MicoI2cBuildCombinedMessage( mico_i2c_message_t* message, const void* tx_buffer, void* rx_buffer, uint16_t tx_buffer_length, uint16_t rx_buffer_length, uint16_t retries )
|
|
{
|
|
return lib_api_p->i2c_apis->i2c_build_combined_msg(message, tx_buffer, rx_buffer,
|
|
tx_buffer_length, rx_buffer_length, retries );
|
|
}
|
|
|
|
OSStatus MicoI2cTransfer( mico_i2c_device_t* device, mico_i2c_message_t* messages, uint16_t number_of_messages )
|
|
{
|
|
OSStatus err = kNoErr;
|
|
|
|
mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
err = lib_api_p->i2c_apis->i2c_transfer(device, messages, number_of_messages);
|
|
mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
|
|
|
|
return err;
|
|
}
|
|
|
|
OSStatus MicoSpiInitialize( const mico_spi_device_t* spi )
|
|
{
|
|
if ( platform_spi_drivers[spi->port].initialized == MICO_TRUE )
|
|
return kNoErr;
|
|
lib_api_p->spi_apis->spi_init(spi);
|
|
platform_spi_drivers[spi->port].initialized = MICO_TRUE;
|
|
return kNoErr;
|
|
}
|
|
|
|
OSStatus MicoSpiFinalize( const mico_spi_device_t* spi )
|
|
{
|
|
platform_spi_drivers[spi->port].initialized = MICO_FALSE;
|
|
return lib_api_p->spi_apis->spi_finalize(spi);
|
|
}
|
|
|
|
OSStatus MicoSpiTransfer( const mico_spi_device_t* spi, const mico_spi_message_segment_t* segments, uint16_t number_of_segments )
|
|
{
|
|
return lib_api_p->spi_apis->spi_transfer(spi, segments, number_of_segments );
|
|
}
|
|
|
|
|
|
OSStatus MicoRandomNumberRead( void *inBuffer, int inByteCount )
|
|
{
|
|
lib_api_p->get_random_sequence(inBuffer, inByteCount);
|
|
return kNoErr;
|
|
}
|
|
|
|
uint32_t RNG_GetRandomNumber(void)
|
|
{
|
|
uint32_t d;
|
|
MicoRandomNumberRead((unsigned char*)&d, 4);
|
|
return d;
|
|
}
|
|
|
|
int wlan_inject_frame(const uint8_t *buff, size_t len)
|
|
{
|
|
return lib_api_p->wlan_inject_frame(buff, len);
|
|
}
|
|
|
|
OSStatus mico_wlan_send_mgnt(uint8_t *buffer, uint32_t length)
|
|
{
|
|
// I don't know the return value;
|
|
lib_api_p->wlan_inject_frame(buffer, length);
|
|
return kNoErr;
|
|
}
|
|
|
|
void MicoMcuPowerSaveConfig(int enable)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* This API can be used to start/stop the management frame forwards
|
|
* to host through datapath.
|
|
*
|
|
* \param[in] bss_type The interface from which management frame needs to be
|
|
* collected.
|
|
* \param[in] mgmt_subtype_mask Management Subtype Mask
|
|
* If Bit X is set in mask, it means that IEEE Management Frame
|
|
* SubTyoe X is to be filtered and passed through to host.
|
|
* Bit Description
|
|
* [31:14] Reserved
|
|
* [13] Action frame
|
|
* [12:9] Reserved
|
|
* [8] Beacon
|
|
* [7:6] Reserved
|
|
* [5] Probe response
|
|
* [4] Probe request
|
|
* [3] Reassociation response
|
|
* [2] Reassociation request
|
|
* [1] Association response
|
|
* [0] Association request
|
|
* Support multiple bits set.
|
|
* 0 = stop forward frame
|
|
* 1 = start forward frame
|
|
*
|
|
*\param[in] rx_mgmt_callback The receive callback where the received management
|
|
* frames are passed.
|
|
|
|
* \return WM_SUCCESS if operation is successful.
|
|
* \return -WM_FAIL if command fails.
|
|
*
|
|
* \note Pass Management Subtype Mask all zero to disable all the management
|
|
* frame forward to host.
|
|
*/
|
|
int wlan_rx_mgmt_indication(const enum wlan_bss_type bss_type,
|
|
const uint32_t mgmt_subtype_mask,
|
|
void (*rx_mgmt_callback)(const enum wlan_bss_type
|
|
bss_type, const uint8_t *frame,
|
|
const uint16_t len))
|
|
{
|
|
return lib_api_p->wlan_rx_mgmt_indication(
|
|
bss_type, mgmt_subtype_mask, rx_mgmt_callback);
|
|
}
|
|
|
|
|
|
int wlan_remain_on_channel(const bool status, const uint8_t channel,
|
|
const uint32_t ms)
|
|
{
|
|
return lib_api_p->wlan_remain_on_channel(status, channel, ms);
|
|
}
|
|
|
|
int wifi_bridge_mode_enable(bool hidden_ssid)
|
|
{
|
|
return lib_api_p->wifi_bridge_mode_enable(hidden_ssid);
|
|
}
|
|
|
|
int wifi_bridge_mode_disable(void)
|
|
{
|
|
return lib_api_p->wifi_bridge_mode_disable();
|
|
}
|
|
|
|
int send_easylink_minus(uint32_t ip, char *ssid, char *key)
|
|
{
|
|
return lib_api_p->send_easylink_minus(ip, ssid, key);
|
|
}
|
|
|
|
OSStatus MicoIISInitialize( const mico_iis_device_t* iis )
|
|
{
|
|
return lib_api_p->iis_apis->iis_init(iis);
|
|
}
|
|
|
|
OSStatus MicoIISFinalize( const mico_iis_device_t* iis )
|
|
{
|
|
return lib_api_p->iis_apis->iis_finalize(iis);
|
|
}
|
|
|
|
OSStatus MicoIISTransfer( const mico_iis_device_t* iis, const mico_iis_message_segment_t* segments, uint16_t number_of_segments )
|
|
{
|
|
return lib_api_p->iis_apis->iis_transfer(iis,segments,number_of_segments);
|
|
}
|
|
|
|
OSStatus MicoIISWrite( const mico_iis_device_t* iis, uint8_t *p_buf, uint32_t size )
|
|
{
|
|
return lib_api_p->iis_apis->iis_write(iis, p_buf, size);
|
|
}
|
|
|
|
OSStatus MicoIISRead( const mico_iis_device_t* iis, uint8_t *p_buf, uint32_t size )
|
|
{
|
|
return lib_api_p->iis_apis->iis_read(iis, p_buf, size);
|
|
}
|
|
|
|
|
|
OSStatus mico_wlan_get_channel( uint8_t *channel )
|
|
{
|
|
*channel = lib_api_p->mico_wlan_get_channel();
|
|
return kNoErr;
|
|
}
|