nrf_soc.h

/*
 * Copyright (c) Nordic Semiconductor ASA
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef NRF_SOC_H__
#define NRF_SOC_H__
 
#include <stdint.h>
#include "nrf_svc.h"
#include "nrf_error.h"
#include "nrf_error_soc.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SOC_SVC_BASE               (0x20)                   
#define SOC_SVC_BASE_NOT_AVAILABLE (0x2D)                   
#define NRF_RADIO_NOTIFICATION_INACTIVE_GUARANTEED_TIME_US  (62)
 
#define NRF_RADIO_MINIMUM_TIMESLOT_LENGTH_EXTENSION_TIME_US (200)
 
#define NRF_RADIO_MAX_EXTENSION_PROCESSING_TIME_US           (25)
 
#define NRF_RADIO_MIN_EXTENSION_MARGIN_US                    (87)
 
#define SOC_ECB_KEY_LENGTH                (16)                       
#define SOC_ECB_CLEARTEXT_LENGTH          (16)                       
#define SOC_ECB_CIPHERTEXT_LENGTH         (SOC_ECB_CLEARTEXT_LENGTH) 
#define SD_EVT_IRQn                       (SWI01_IRQn)        
#define SD_EVT_IRQHandler                 (SWI01_IRQHandler)  
#define RADIO_NOTIFICATION_IRQn           (SWI02_IRQn)        
#define RADIO_NOTIFICATION_IRQHandler     (SWI02_IRQHandler)  
#define SD_EVT_IRQ_PRI                    (6)                 
#define RADIO_NOTIFICATION_IRQ_PRI        (6)                 
#define NRF_RADIO_LENGTH_MIN_US           (100)               
#define NRF_RADIO_LENGTH_MAX_US           (100000)            
#define NRF_RADIO_DISTANCE_MAX_US         (256000000UL - 1UL) 
#define NRF_RADIO_EARLIEST_TIMEOUT_MAX_US (256000000UL - 1UL) 
#define NRF_RADIO_START_JITTER_US         (0)                 
#define SD_RAND_SEED_SIZE                 (32)                
enum NRF_SOC_SVCS
{
  SD_FLASH_WRITE              = SOC_SVC_BASE + 9,
  SD_MUTEX_NEW                            = SOC_SVC_BASE_NOT_AVAILABLE,
  SD_MUTEX_ACQUIRE                        = SOC_SVC_BASE_NOT_AVAILABLE + 1,
  SD_MUTEX_RELEASE                        = SOC_SVC_BASE_NOT_AVAILABLE + 2,
  SD_RAND_APPLICATION_VECTOR_GET          = SOC_SVC_BASE_NOT_AVAILABLE + 3,
  SD_POWER_MODE_SET                       = SOC_SVC_BASE_NOT_AVAILABLE + 4,
  SD_POWER_POF_ENABLE                     = SOC_SVC_BASE_NOT_AVAILABLE + 8,
  SD_POWER_POF_THRESHOLD_SET              = SOC_SVC_BASE_NOT_AVAILABLE + 9,
  SD_POWER_GPREGRET_SET                   = SOC_SVC_BASE_NOT_AVAILABLE + 14,
  SD_POWER_GPREGRET_CLR                   = SOC_SVC_BASE_NOT_AVAILABLE + 15,
  SD_POWER_GPREGRET_GET                   = SOC_SVC_BASE_NOT_AVAILABLE + 16,
  SD_CLOCK_HFCLK_REQUEST                  = SOC_SVC_BASE_NOT_AVAILABLE + 19,
  SD_CLOCK_HFCLK_RELEASE                  = SOC_SVC_BASE_NOT_AVAILABLE + 20,
  SD_CLOCK_HFCLK_IS_RUNNING               = SOC_SVC_BASE_NOT_AVAILABLE + 21,
  SD_RADIO_NOTIFICATION_CFG_SET           = SOC_SVC_BASE_NOT_AVAILABLE + 22,
  SD_ECB_BLOCK_ENCRYPT                    = SOC_SVC_BASE_NOT_AVAILABLE + 23,
  SD_ECB_BLOCKS_ENCRYPT                   = SOC_SVC_BASE_NOT_AVAILABLE + 24,
  SD_RADIO_SESSION_OPEN                   = SOC_SVC_BASE_NOT_AVAILABLE + 25,
  SD_RADIO_SESSION_CLOSE                  = SOC_SVC_BASE_NOT_AVAILABLE + 26,
  SD_RADIO_REQUEST                        = SOC_SVC_BASE_NOT_AVAILABLE + 27,
  SD_EVT_GET                              = SOC_SVC_BASE_NOT_AVAILABLE + 28,
  SD_TEMP_GET                             = SOC_SVC_BASE_NOT_AVAILABLE + 29,
  SD_RAND_SEED_SET                        = SOC_SVC_BASE_NOT_AVAILABLE + 34,
  SVC_SOC_LAST                            = SOC_SVC_BASE_NOT_AVAILABLE + 35
};
 
enum NRF_MUTEX_VALUES
{
  NRF_MUTEX_FREE,
  NRF_MUTEX_TAKEN
};
 
enum NRF_POWER_MODES
{
  NRF_POWER_MODE_CONSTLAT,  
  NRF_POWER_MODE_LOWPWR     
};
 
enum NRF_POWER_THRESHOLDS
{
  NRF_POWER_THRESHOLD_V17 = 0UL, 
  NRF_POWER_THRESHOLD_V18,       
  NRF_POWER_THRESHOLD_V19,       
  NRF_POWER_THRESHOLD_V20,       
  NRF_POWER_THRESHOLD_V21,       
  NRF_POWER_THRESHOLD_V22,       
  NRF_POWER_THRESHOLD_V23,       
  NRF_POWER_THRESHOLD_V24,       
  NRF_POWER_THRESHOLD_V25,       
  NRF_POWER_THRESHOLD_V26,       
  NRF_POWER_THRESHOLD_V27,       
  NRF_POWER_THRESHOLD_V28        
};
 
 
enum NRF_RADIO_NOTIFICATION_DISTANCES
{
  NRF_RADIO_NOTIFICATION_DISTANCE_NONE = 0,        
  NRF_RADIO_NOTIFICATION_DISTANCE_200US = 200,     
  NRF_RADIO_NOTIFICATION_DISTANCE_420US = 420,     
  NRF_RADIO_NOTIFICATION_DISTANCE_800US = 800,     
  NRF_RADIO_NOTIFICATION_DISTANCE_1740US = 1740,   
  NRF_RADIO_NOTIFICATION_DISTANCE_2680US = 2680,   
  NRF_RADIO_NOTIFICATION_DISTANCE_3620US = 3620,   
  NRF_RADIO_NOTIFICATION_DISTANCE_4560US = 4560,   
  NRF_RADIO_NOTIFICATION_DISTANCE_5500US = 5500    
};
 
enum NRF_RADIO_NOTIFICATION_TYPES
{
  NRF_RADIO_NOTIFICATION_TYPE_NONE = 0,        
  NRF_RADIO_NOTIFICATION_TYPE_INT_ON_ACTIVE,   
  NRF_RADIO_NOTIFICATION_TYPE_INT_ON_INACTIVE, 
  NRF_RADIO_NOTIFICATION_TYPE_INT_ON_BOTH,     
};
 
enum NRF_RADIO_CALLBACK_SIGNAL_TYPE
{
  NRF_RADIO_CALLBACK_SIGNAL_TYPE_START,             
  NRF_RADIO_CALLBACK_SIGNAL_TYPE_TIMER0,            
  NRF_RADIO_CALLBACK_SIGNAL_TYPE_RADIO,             
  NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_FAILED,     
  NRF_RADIO_CALLBACK_SIGNAL_TYPE_EXTEND_SUCCEEDED   
};
 
enum NRF_RADIO_SIGNAL_CALLBACK_ACTION
{
  NRF_RADIO_SIGNAL_CALLBACK_ACTION_NONE,            
  NRF_RADIO_SIGNAL_CALLBACK_ACTION_EXTEND,          
  NRF_RADIO_SIGNAL_CALLBACK_ACTION_END,             
  NRF_RADIO_SIGNAL_CALLBACK_ACTION_REQUEST_AND_END  
};
 
enum NRF_RADIO_HFCLK_CFG
{
  NRF_RADIO_HFCLK_CFG_XTAL_GUARANTEED, 
  NRF_RADIO_HFCLK_CFG_NO_GUARANTEE    
};
 
enum NRF_RADIO_PRIORITY
{
  NRF_RADIO_PRIORITY_HIGH,                          
  NRF_RADIO_PRIORITY_NORMAL,                        
};
 
enum NRF_RADIO_REQUEST_TYPE
{
  NRF_RADIO_REQ_TYPE_EARLIEST,                      
  NRF_RADIO_REQ_TYPE_NORMAL                         
};
 
enum NRF_SOC_EVTS
{
  NRF_EVT_HFCLKSTARTED,                         
  NRF_EVT_POWER_FAILURE_WARNING,                
  NRF_EVT_FLASH_OPERATION_SUCCESS,              
  NRF_EVT_FLASH_OPERATION_ERROR,                
  NRF_EVT_RADIO_BLOCKED,                        
  NRF_EVT_RADIO_SIGNAL_CALLBACK_INVALID_RETURN, 
  NRF_EVT_RADIO_SESSION_IDLE,                   
  NRF_EVT_RADIO_SESSION_CLOSED,                 
  NRF_EVT_RAND_SEED_REQUEST,                    
  NRF_EVT_NUMBER_OF_EVTS
};
 
typedef volatile uint8_t nrf_mutex_t;
 
typedef struct
{
  uint8_t       hfclk;                              
  uint8_t       priority;                           
  uint32_t      length_us;                          
  uint32_t      timeout_us;                         
} nrf_radio_request_earliest_t;
 
typedef struct
{
  uint8_t       hfclk;                              
  uint8_t       priority;                           
  uint32_t      distance_us;                        
  uint32_t      length_us;                          
} nrf_radio_request_normal_t;
 
typedef struct
{
  uint8_t                         request_type;     
  union
  {
    nrf_radio_request_earliest_t  earliest;         
    nrf_radio_request_normal_t    normal;           
  } params;                                         
} nrf_radio_request_t;
 
typedef struct
{
  uint8_t               callback_action;            
  union
  {
    struct
    {
      nrf_radio_request_t * p_next;                 
    } request;                                      
    struct
    {
      uint32_t              length_us;              
    } extend;                                       
  } params;                                         
} nrf_radio_signal_callback_return_param_t;
 
typedef nrf_radio_signal_callback_return_param_t * (*nrf_radio_signal_callback_t) (uint8_t signal_type);
 
typedef uint8_t soc_ecb_key_t[SOC_ECB_KEY_LENGTH];                
typedef uint8_t soc_ecb_cleartext_t[SOC_ECB_CLEARTEXT_LENGTH];    
typedef uint8_t soc_ecb_ciphertext_t[SOC_ECB_CIPHERTEXT_LENGTH];  
typedef struct
{
  soc_ecb_key_t        key;            
  soc_ecb_cleartext_t  cleartext;      
  soc_ecb_ciphertext_t ciphertext;     
} nrf_ecb_hal_data_t;
 
typedef struct
{
  soc_ecb_key_t const *       p_key;           
  soc_ecb_cleartext_t const * p_cleartext;     
  soc_ecb_ciphertext_t *      p_ciphertext;    
} nrf_ecb_hal_data_block_t;
 
SVCALL(SD_MUTEX_NEW, uint32_t, sd_mutex_new(nrf_mutex_t * p_mutex));
 
SVCALL(SD_MUTEX_ACQUIRE, uint32_t, sd_mutex_acquire(nrf_mutex_t * p_mutex));
 
SVCALL(SD_MUTEX_RELEASE, uint32_t, sd_mutex_release(nrf_mutex_t * p_mutex));
 
SVCALL(SD_RAND_APPLICATION_VECTOR_GET, uint32_t, sd_rand_application_vector_get(uint8_t * p_buff, uint8_t length));
 
SVCALL(SD_RAND_SEED_SET, uint32_t, sd_rand_seed_set(uint8_t p_seed[SD_RAND_SEED_SIZE]));
 
SVCALL(SD_POWER_MODE_SET, uint32_t, sd_power_mode_set(uint8_t power_mode));
 
SVCALL(SD_POWER_POF_ENABLE, uint32_t, sd_power_pof_enable(uint8_t pof_enable));
 
SVCALL(SD_POWER_POF_THRESHOLD_SET, uint32_t, sd_power_pof_threshold_set(uint8_t threshold));
 
SVCALL(SD_POWER_GPREGRET_SET, uint32_t, sd_power_gpregret_set(uint32_t gpregret_id, uint32_t gpregret_msk));
 
SVCALL(SD_POWER_GPREGRET_CLR, uint32_t, sd_power_gpregret_clr(uint32_t gpregret_id, uint32_t gpregret_msk));
 
SVCALL(SD_POWER_GPREGRET_GET, uint32_t, sd_power_gpregret_get(uint32_t gpregret_id, uint32_t *p_gpregret));
 
SVCALL(SD_CLOCK_HFCLK_REQUEST, uint32_t, sd_clock_hfclk_request(void));
 
SVCALL(SD_CLOCK_HFCLK_RELEASE, uint32_t, sd_clock_hfclk_release(void));
 
SVCALL(SD_CLOCK_HFCLK_IS_RUNNING, uint32_t, sd_clock_hfclk_is_running(uint32_t * p_is_running));
 
SVCALL(SD_RADIO_NOTIFICATION_CFG_SET, uint32_t, sd_radio_notification_cfg_set(uint8_t type, uint16_t distance_us));
 
SVCALL(SD_ECB_BLOCK_ENCRYPT, uint32_t, sd_ecb_block_encrypt(nrf_ecb_hal_data_t * p_ecb_data));
 
SVCALL(SD_ECB_BLOCKS_ENCRYPT, uint32_t, sd_ecb_blocks_encrypt(uint8_t block_count, nrf_ecb_hal_data_block_t * p_data_blocks));
 
SVCALL(SD_EVT_GET, uint32_t, sd_evt_get(uint32_t * p_evt_id));
 
SVCALL(SD_TEMP_GET, uint32_t, sd_temp_get(int32_t * p_temp));
 
SVCALL(SD_FLASH_WRITE, uint32_t, sd_flash_write(uint32_t * p_dst, uint32_t const * p_src, uint32_t size));
 
 SVCALL(SD_RADIO_SESSION_OPEN, uint32_t, sd_radio_session_open(nrf_radio_signal_callback_t p_radio_signal_callback));
 
 SVCALL(SD_RADIO_SESSION_CLOSE, uint32_t, sd_radio_session_close(void));
 
 SVCALL(SD_RADIO_REQUEST, uint32_t, sd_radio_request(nrf_radio_request_t const * p_request));
 
#ifdef __cplusplus
}
#endif
#endif // NRF_SOC_H__