fnet_cpu.h

/**************************************************************************
*
* Copyright 2008-2018 by Andrey Butok. FNET Community.
*
***************************************************************************
*
*  Licensed under the Apache License, Version 2.0 (the "License"); you may
*  not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*  http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
*  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
***************************************************************************
*
*  CPU-specific library API.
*
***************************************************************************/

#ifndef _FNET_CPU_H_

#define _FNET_CPU_H_

#include "fnet_config.h"

#if FNET_MCF    /* ColdFire.*/
    #include "mcf/fnet_mcf.h"
#endif

#if FNET_MK     /* Kinetis.*/
    #include "mk/fnet_mk.h"
#endif

#if FNET_MPC     /* MPC.*/
    #include "mpc/fnet_mpc.h"
#endif

#if FNET_LPC     /* LPC.*/
    #include "lpc/fnet_lpc.h"
#endif

#if FNET_MIMXRT     /* i.MX RT.*/
    #include "mimxrt/fnet_mimxrt.h"
#endif

#include "stack/fnet_stdlib.h"


/* Non-cacheable region definition macro. */
/* Used MCUX "NonCacheable" name for this section. */
#if FNET_CFG_CPU_CACHE
    #if FNET_CFG_COMP_IAR
        #define FNET_AT_NONCACHEABLE_SECTION(var) var @FNET_CFG_CPU_NONCACHEABLE_SECTION
    #elif FNET_CFG_COMP_UV || FNET_CFG_COMP_GNUC || FNET_CFG_COMP_GHS
        #define FNET_AT_NONCACHEABLE_SECTION(var) __attribute__((section(FNET_CFG_CPU_NONCACHEABLE_SECTION))) var
    #else
        #error Compiler is not supported
        #define FNET_AT_NONCACHEABLE_SECTION(var) var
    #endif
#else
    #define FNET_AT_NONCACHEABLE_SECTION(var) var
#endif


#if defined(__cplusplus)
extern "C" {
#endif

/************************************************************************
*     For doing byte order conversions between CPU
*     and the independent "network" order.
*     For Freescale CPUs they just return the variable passed.
*************************************************************************/

#if FNET_CFG_CPU_LITTLE_ENDIAN /* Little endian.*/ || defined(__DOXYGEN__)

/**************************************************************************/ 
#define FNET_HTONS(short_var)   (((((fnet_uint16_t)(short_var)) & 0x00FFU) << 8U) | (((fnet_uint16_t)(short_var) & 0xFF00U) >> 8U))
/**************************************************************************/ 
#define FNET_NTOHS(short_var)   FNET_HTONS(short_var)
/**************************************************************************/ 
#define FNET_HTONL(long_var)    ((((long_var) & 0x000000FFU) << 24U) | (((long_var) & 0x0000FF00U) << 8U) | (((long_var) & 0x00FF0000U) >> 8U) | (((long_var) & 0xFF000000U) >> 24U))
/**************************************************************************/ 
#define FNET_NTOHL(long_var)    FNET_HTONL(long_var)

/***************************************************************************/ 
fnet_uint16_t fnet_htons(fnet_uint16_t short_var);

#define fnet_ntohs   fnet_htons
/***************************************************************************/ 
fnet_uint16_t fnet_ntohs(fnet_uint16_t short_var);

/***************************************************************************/ 
fnet_uint32_t fnet_htonl(fnet_uint32_t long_var);

#define fnet_ntohl    fnet_htonl
/***************************************************************************/ 
fnet_uint32_t fnet_ntohl(fnet_uint32_t long_var);


#else /* Big endian. */
#define FNET_HTONS(short_var)   (short_var)
#define FNET_NTOHS(short_var)   (short_var)
#define FNET_HTONL(long_var)    (long_var)
#define FNET_NTOHL(long_var)    (long_var)

#define fnet_htons(short_var)   (short_var) /* Convert 16 bit integer from host- to network byte order.*/
#define fnet_ntohs(short_var)   (short_var) /* Convert 16 bit integer from network - to host byte order.*/
#define fnet_htonl(long_var)    (long_var)  /* Convert 32 bit integer from host- to network byte order.*/
#define fnet_ntohl(long_var)    (long_var)  /* Convert 32 bit integer from network - to host byte order.*/
#endif

/**************************************************************************/ 
typedef fnet_uint32_t fnet_cpu_irq_desc_t;

/***************************************************************************/ 
void fnet_cpu_reset (void);

/***************************************************************************/ 
fnet_cpu_irq_desc_t fnet_cpu_irq_disable(void);

/***************************************************************************/ 
void fnet_cpu_irq_enable(fnet_cpu_irq_desc_t irq_desc);

/***************************************************************************/ 
void fnet_cpu_serial_putchar( fnet_index_t port_number, fnet_char_t character );

/***************************************************************************/ 
fnet_int32_t fnet_cpu_serial_getchar( fnet_index_t port_number );

/***************************************************************************/ 
fnet_return_t fnet_cpu_serial_init(fnet_index_t port_number, fnet_uint32_t baud_rate);

/***************************************************************************/ 
fnet_return_t  fnet_cpu_flash_erase(void *flash_addr, fnet_size_t bytes);

/***************************************************************************/ 
fnet_return_t  fnet_cpu_flash_write(fnet_uint8_t *dest, const fnet_uint8_t *data);

/***************************************************************************/ 
void fnet_cpu_isr(void);

/***************************************************************************/ 
#ifndef FNET_CPU_ADDR_TO_INSTRUCTION
#define FNET_CPU_ADDR_TO_INSTRUCTION(addr)    (addr)
#endif

/***************************************************************************/ 
#ifndef FNET_CPU_INSTRUCTION_TO_ADDR
#define FNET_CPU_INSTRUCTION_TO_ADDR(addr)    (addr)
#endif

/***************************************************************************/ 
#ifndef FNET_CPU_DATA_MEMORY_BARRIER
#define FNET_CPU_DATA_MEMORY_BARRIER do{}while(0)
#endif


struct fnet_netif; /* Forward declaration.*/
#if FNET_CFG_CPU_ETH0
extern struct fnet_netif fnet_cpu_eth0_if;
#define FNET_CPU_ETH0_IF ((fnet_netif_desc_t)(&fnet_cpu_eth0_if))
#endif
#if FNET_CFG_CPU_ETH1
extern struct fnet_netif  fnet_cpu_eth1_if;
#define FNET_CPU_ETH1_IF ((fnet_netif_desc_t)(&fnet_cpu_eth1_if))
#endif
#if FNET_CFG_CPU_WIFI
extern struct fnet_netif  fnet_cpu_wifi_if;
#define FNET_CPU_WIFI_IF ((fnet_netif_desc_t)(&fnet_cpu_wifi_if))
#endif

/***************************************************************************/ 
#define FNET_CPU_NETIF_NUMBER      (FNET_CFG_CPU_ETH0+FNET_CFG_CPU_ETH1+FNET_CFG_CPU_WIFI)

#if defined(__cplusplus)
}
#endif

#endif /* _FNET_CPU_H_ */