mbx.h

Go to the documentation of this file.

 
/*
 * This file is part of libethercat.
 *
 * libethercat is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 * 
 * libethercat is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public 
 * License along with libethercat (LICENSE.LGPL-V3); if not, write 
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth 
 * Floor, Boston, MA  02110-1301, USA.
 * 
 * Please note that the use of the EtherCAT technology, the EtherCAT 
 * brand name and the EtherCAT logo is only permitted if the property 
 * rights of Beckhoff Automation GmbH are observed. For further 
 * information please contact Beckhoff Automation GmbH & Co. KG, 
 * Hülshorstweg 20, D-33415 Verl, Germany (www.beckhoff.com) or the 
 * EtherCAT Technology Group, Ostendstraße 196, D-90482 Nuremberg, 
 * Germany (ETG, www.ethercat.org).
 *
 */
 
#ifndef LIBETHERCAT_MBX_H
#define LIBETHERCAT_MBX_H
 
#include <libosal/types.h>
#include <libosal/osal.h>
#include <libosal/task.h>
 
#include "libethercat/common.h"
 
#if LIBETHERCAT_MBX_SUPPORT_COE == 1
#include "libethercat/coe.h"
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_SOE == 1
#include "libethercat/soe.h"
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_FOE == 1
#include "libethercat/foe.h"
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_EOE == 1
#include "libethercat/eoe.h"
#endif
 
#include "libethercat/pool.h"
#include "libethercat/datagram.h"
 
#define MAILBOX_WRITE   (osal_uint16_t)(0u)     
#define MAILBOX_READ    (osal_uint16_t)(1u)     
 
// forward declarations
struct ec;
typedef struct ec ec_t;
    
#define MESSAGE_POOL_DEBUG(type) {}
 
/*
#define N_MESSAGE_POOL_DEBUG(type) \
{                                                                                       \
    int avail = 0;                                                                      \
    sem_getvalue(&slv->mbx.message_pool_ ## type->avail_cnt, &avail);                   \
    ec_log(10, __func__, "slave %d: " #type " pool avail %d\n", slave, avail);          \
}
*/
enum {
    EC_MBX_ERR = 0x00,          
    EC_MBX_AOE,                 
    EC_MBX_EOE,                 
    EC_MBX_COE,                 
    EC_MBX_FOE,                 
    EC_MBX_SOE,                 
    EC_MBX_VOE = 0x0f           
};
 
typedef struct PACKED ec_mbx_header {
    osal_uint16_t  length;           
    osal_uint16_t  address;          
    osal_uint8_t   priority;         
    osal_uint8_t   mbxtype : 4;      
    osal_uint8_t   counter : 4;      
} PACKED ec_mbx_header_t;
 
typedef struct PACKED ec_mbx_buffer {
    ec_mbx_header_t mbx_hdr;    
    ec_data_t      mbx_data;    
} PACKED ec_mbx_buffer_t;
 
typedef struct ec_mbx {
    osal_uint32_t handler_flags;        
    osal_mutex_t sync_mutex;            
    osal_binary_semaphore_t sync_sem;   
 
    int handler_running;        
    ec_t *pec;                  
    int slave;                  
    osal_task_t handler_tid;    
    
    osal_mutex_t lock;          
    int seq_counter;            
 
    pool_t message_pool_send_queued;
 
#if LIBETHERCAT_MBX_SUPPORT_COE == 1
    ec_coe_t coe;               
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_SOE == 1
    ec_soe_t soe;               
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_FOE == 1
    ec_foe_t foe;               
#endif
 
#if LIBETHERCAT_MBX_SUPPORT_EOE == 1
    ec_eoe_t eoe;               
#endif
 
    osal_uint32_t sm_state_bitno;
    osal_uint8_t *sm_state;     
    osal_uint8_t mbx_state;     
} ec_mbx_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
void ec_mbx_init(ec_t *pec, osal_uint16_t slave);
 
 
void ec_mbx_deinit(ec_t *pec, osal_uint16_t slave);
 
 
void ec_mbx_enqueue_head(ec_t *pec, osal_uint16_t slave, pool_entry_t *p_entry);
 
 
void ec_mbx_enqueue_tail(ec_t *pec, osal_uint16_t slave, pool_entry_t *p_entry);
 
 
void ec_mbx_sched_read(ec_t *pec, osal_uint16_t slave);
 
 
int ec_mbx_check(ec_t *pec, int slave, osal_uint16_t mbx_flag);
 
 
int ec_mbx_next_counter(ec_t *pec, int slave, int *seq_counter); 
 
#define ec_mbx_get_free_recv_buffer(pec, slave, entry, timeout, lock) \
    pool_get(&(pec)->mbx_message_pool_recv_free, &(entry), (timeout))
 
#define ec_mbx_get_free_send_buffer_old(pec, slave, entry, timeout, lock) \
    pool_get(&(pec)->mbx_message_pool_send_free, &(entry), (timeout))
 
 
int ec_mbx_get_free_send_buffer(ec_t *pec, osal_uint16_t slave, pool_entry_t **pp_entry, osal_timer_t *timeout);
 
#define ec_mbx_return_free_send_buffer(pec, slave, entry) \
    pool_put(&(pec)->mbx_message_pool_send_free, (entry)) 
 
#define ec_mbx_return_free_recv_buffer(pec, slave, entry) \
    pool_put(&(pec)->mbx_message_pool_recv_free, (entry))
 
 
void ec_mbx_do_handle(ec_t *pec, uint16_t slave);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBETHERCAT_MBX_H