Subversion Repositories funbase_ip_library

/*

 * Copyright (c) 2010, Mentor Graphics Corporation

 * 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 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 the <ORGANIZATION> nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 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 MCAPI_DEFS_H

#define MCAPI_DEFS_H

#include <mcapi.h>

#include <openmcapi_cfg.h>

#ifdef          __cplusplus

extern  "C" {                               /* C declarations in C++     */

#endif /* _cplusplus */

extern mcapi_node_t MCAPI_Node_ID;

#define MCAPI_MSG_TYPE          0

#define MCAPI_CHAN_PKT_TYPE     1

#define MCAPI_CHAN_SCAL_TYPE    2

/* Packet header offsets. */

#define     MCAPI_SRC_NODE_OFFSET       0

#define     MCAPI_SRC_PORT_OFFSET       2

#define     MCAPI_DEST_NODE_OFFSET      4

#define     MCAPI_DEST_PORT_OFFSET      6

#define     MCAPI_PRIO_OFFSET           8

#define     MCAPI_UNUSED_OFFSET         10

/* The length of the MCAPI headers, in bytes. */

#define     MCAPI_HEADER_LEN        12

#define     MCAPI_GET_ENDP_LEN      12

#define     MCAPI_CONNECT_MSG_LEN   20

#define     MCAPI_FIN_MSG_LEN       8

/* Packet types. */

#define     MCAPI_MESSAGE_TYPE      1

#define     MCAPI_PACKET_TYPE       2

/* Protocol types. */

#define     MCAPI_GETENDP_REQUEST   1

#define     MCAPI_GETENDP_RESPONSE  2

#define     MCAPI_CONNECT_REQUEST   3

#define     MCAPI_CONNECT_RESPONSE  4

#define     MCAPI_CONNECT_SYN       5

#define     MCAPI_CONNECT_ACK       6

#define     MCAPI_CANCEL_MSG        7

#define     MCAPI_OPEN_TX           8

#define     MCAPI_OPEN_RX           9

#define     MCAPI_OPEN_TX_ACK       10

#define     MCAPI_OPEN_RX_ACK       11

#define     MCAPI_CONNECT_FIN       12

/* Protocol offsets. */

#define     MCAPI_PROT_TYPE         0

/* Endpoint Request Message offsets. */

#define     MCAPI_GETENDP_PORT      2

#define     MCAPI_GETENDP_ENDP      4

#define     MCAPI_GETENDP_STATUS    8

/* Connection message offsets. */

#define     MCAPI_CNCT_REQ_NODE     2

#define     MCAPI_CNCT_REQ_PORT     4

#define     MCAPI_CNCT_TX_NODE      6

#define     MCAPI_CNCT_TX_PORT      8

#define     MCAPI_CNCT_RX_NODE      10

#define     MCAPI_CNCT_RX_PORT      12

#define     MCAPI_CNCT_CHAN_TYPE    14

#define     MCAPI_CNCT_STATUS       16

/* Connection FIN offsets. */

#define     MCAPI_CNCT_FIN_TX_NODE  2

#define     MCAPI_CNCT_FIN_TX_PORT  4

#define     MCAPI_CNCT_FIN_PORT     6

#define     MCAPI_TX_SIDE           1

#define     MCAPI_RX_SIDE           2

/* Endpoint attributes that can be set/retrieved. */

#define     MCAPI_ATTR_NO_PRIORITIES            1   /* Number of priorities */

#define     MCAPI_ATTR_NO_BUFFERS               2   /* Number of buffers */

#define     MCAPI_ATTR_BUFFER_SIZE              3   /* Buffer size */

#define     MCAPI_ATTR_BUFFER_TYPE              4   /* Buffer type, FIFO */

#define     MCAPI_ATTR_MEMORY_TYPE              5   /* Shared/local (0-copy) */

#define     MCAPI_ATTR_TIMEOUT                  6   /* Timeout */

#define     MCAPI_ATTR_ENDP_PRIO                7   /* Priority on connected endpoint */

#define     MCAPI_ATTR_ENDP_STATUS              8   /* Endpoint status, connected, open etc. */

#define     MCAPI_ATTR_RECV_BUFFERS_AVAILABLE   9   /* Available receive buffers */

#define     MCAPI_FINALIZE_DRIVER               10  /* Shut down the driver. */

/* Identifiers denoting what types of operations a suspended thread wants

 * to be woken up for.

 */

#define     MCAPI_REQ_DELETED       1       /* Endpoint associated with the request has been deleted. */

#define     MCAPI_REQ_CREATED       2       /* Endpoint associated with the request has been created. */

#define     MCAPI_REQ_TX_FIN        3       /* Outgoing data has been sent. */

#define     MCAPI_REQ_RX_FIN        4       /* Incoming data has been received. */

#define     MCAPI_REQ_CONNECTED     5       /* Two endpoints have been connected. */

#define     MCAPI_REQ_RX_OPEN       6       /* The receive end of a connection has been opened. */

#define     MCAPI_REQ_TX_OPEN       7       /* The send end of a connection has been opened. */

#define     MCAPI_REQ_CLOSED        8       /* The local end of a connection has been closed. */

/* States of an MCAPI Node in the global list. */

#define     MCAPI_NODE_UNUSED           0

#define     MCAPI_NODE_INITIALIZED      1

#define     MCAPI_NODE_FINALIZED        2

/* State of an MCAPI Endpoint in the global list. */

#define     MCAPI_ENDP_CLOSED           0x1

#define     MCAPI_ENDP_OPEN             0x2

#define     MCAPI_ENDP_CONNECTING       0x4

#define     MCAPI_ENDP_CONNECTED        0x8

#define     MCAPI_ENDP_TX               0x10

#define     MCAPI_ENDP_RX               0x20

#define     MCAPI_ENDP_TX_ACKED         0x40

#define     MCAPI_ENDP_RX_ACKED         0x80

#define     MCAPI_ENDP_DISCONNECTED     0x100

#define     MCAPI_ENDP_CONNECTING_TX    0x200

#define     MCAPI_ENDP_CONNECTING_RX    0x400

/* Scalar types. */

#define     MCAPI_SCALAR_UINT8          1

#define     MCAPI_SCALAR_UINT16         2

#define     MCAPI_SCALAR_UINT32         3

#define     MCAPI_SCALAR_UINT64         4

#define     MCAPI_REMOVE_REQUEST        0x01

/* An MCAPI buffer structure for data.  Used to check the status

 * of a non-blocking operation.

 */

struct _mcapi_buffer

{

    MCAPI_POINTER  next_buf;

    MCAPI_POINTER  prev_buf;

    unsigned char  buf_ptr[MCAPI_MAX_DATA_LEN];

    mcapi_uint32_t buf_size;

    MCAPI_POINTER  mcapi_dev_ptr;

};

typedef struct _mcapi_buffer MCAPI_BUFFER;

/* Incoming RX queue structure for receiving data on an endpoint. */

struct _mcapi_buf_queue

{

    MCAPI_BUFFER *head;

    MCAPI_BUFFER *tail;

};

typedef struct _mcapi_buf_queue MCAPI_BUF_QUEUE;

typedef struct

{

    unsigned long *mcapi_rx_ptr;

    unsigned       mcapi_extra_data;

} MCAPI_DRIVER;

/* Endpoint data structure.  Holds all data pertinent to an individual

 * endpoint on a node.

 */

struct _mcapi_endpoint

{

    mcapi_node_t            mcapi_node_id;

    mcapi_port_t            mcapi_port_id;

    mcapi_node_t            mcapi_foreign_node_id;

    mcapi_port_t            mcapi_foreign_port_id;

    mcapi_uint32_t          mcapi_state;

    mcapi_uint32_t          mcapi_chan_type;

    mcapi_uint32_t          mcapi_endp_handle;

    mcapi_node_t            mcapi_req_node_id;

    mcapi_port_t            mcapi_req_port_id;

    mcapi_uint32_t          mcapi_priority;

    struct _mcapi_route     *mcapi_route;

    MCAPI_BUF_QUEUE         mcapi_rx_queue;

    MCAPI_DRIVER            mcapi_driver_spec;

};

typedef struct  _mcapi_endpoint     MCAPI_ENDPOINT;

/* An MCAPI interface used to send data to an endpoint. */

struct _mcapi_interface

{

    char            mcapi_int_name[MCAPI_INT_NAME_LEN];

    mcapi_uint32_t  mcapi_max_buf_size;

    mcapi_status_t  (*mcapi_tx_output)(MCAPI_BUFFER *, size_t, mcapi_priority_t, struct _mcapi_endpoint *);

    MCAPI_BUFFER    *(*mcapi_get_buffer)(mcapi_node_t, size_t, mcapi_uint32_t);

    void            (*mcapi_recover_buffer)(MCAPI_BUFFER *);

    mcapi_status_t  (*mcapi_ioctl)(mcapi_uint_t, void *, size_t);

};

typedef struct _mcapi_interface MCAPI_INTERFACE;

typedef struct

{

    mcapi_status_t  (*mcapi_init)(mcapi_node_t, struct _mcapi_interface *);

} MCAPI_INT_INIT;

/* An MCAPI route used to find the interface to use to send data to

 * a remote node.

 */

struct _mcapi_route

{

    mcapi_uint16_t          mcapi_rt_dest_node_id;

    mcapi_uint8_t           mcapi_padN[2];

    struct _mcapi_interface *mcapi_rt_int;

};

typedef struct _mcapi_route MCAPI_ROUTE;

/* Node data structure.  Holds all data pertinent to an individual node

 * in a system.

 */

typedef struct

{

    mcapi_uint16_t      mcapi_node_id;

    mcapi_uint16_t      mcapi_state;

    mcapi_uint32_t      mcapi_endpoint_count;

    mcapi_port_t        mcapi_status_port;

    mcapi_uint8_t       mcapi_padN;

    MCAPI_ENDPOINT      mcapi_endpoint_list[MCAPI_MAX_ENDPOINTS];

    MCAPI_ROUTE         mcapi_route_list[MCAPI_ROUTE_COUNT];

} MCAPI_NODE;

/* A queue of blocking requests within the system. */

typedef struct

{

    mcapi_request_t     *flink;

    mcapi_request_t     *blink;

} MCAPI_REQ_QUEUE;

/* A route initialization structure populated by the system designer

 * at compile-time.

 */

typedef struct

{

    mcapi_uint16_t  mcapi_rt_dest_id;

    char            mcapi_int_name[MCAPI_INT_NAME_LEN];

    mcapi_uint8_t   mcapi_padN[2];

} MCAPI_RT_INIT_STRUCT;

/* The global data structure; ie, MCAPI Database.  This data structure

 * is stored in global memory and is accessible by all nodes in the

 * system.

 */

typedef struct

{

    mcapi_uint32_t          mcapi_node_count;

    MCAPI_RT_INIT_STRUCT    mcapi_route_list[MCAPI_ROUTE_COUNT];

    MCAPI_REQ_QUEUE         mcapi_local_req_queue;

    MCAPI_REQ_QUEUE         mcapi_foreign_req_queue;

    MCAPI_NODE              mcapi_node_list[MCAPI_NODE_COUNT];

} MCAPI_GLOBAL_DATA;

typedef struct

{

    union

    {

        mcapi_uint8_t   scal_uint8;

        mcapi_uint16_t  scal_uint16;

        mcapi_uint32_t  scal_uint32;

        mcapi_uint64_t  scal_uint64;

    } mcapi_scal;

} MCAPI_SCALAR;

/* cntrl_msg.c */

MCAPI_THREAD_ENTRY(mcapi_process_ctrl_msg);

void mcapi_tx_response(MCAPI_GLOBAL_DATA *, mcapi_request_t *);

void mcapi_rx_data(void);

/* node_data.c */

void mcapi_lock_node_data(void);

void mcapi_unlock_node_data(void);

MCAPI_GLOBAL_DATA *mcapi_get_node_data(void);

void mcapi_init_node_data(void);

/* node.c */

int mcapi_find_node(mcapi_node_t, MCAPI_GLOBAL_DATA *);

/* handle.c */

mcapi_endpoint_t mcapi_encode_handle(mcapi_uint16_t, mcapi_uint16_t);

void mcapi_decode_handle(mcapi_endpoint_t, int *, int *);

/* endpoint.c */

int mcapi_find_endpoint(mcapi_port_t, MCAPI_NODE *);

mcapi_endpoint_t mcapi_encode_endpoint(mcapi_node_t, mcapi_port_t);

void mcapi_decode_endpoint(mcapi_endpoint_t, mcapi_node_t *, mcapi_port_t *);

MCAPI_ENDPOINT *mcapi_decode_local_endpoint(MCAPI_GLOBAL_DATA *, mcapi_node_t *,

                                            mcapi_port_t *, mcapi_endpoint_t,

                                            mcapi_status_t *);

MCAPI_ENDPOINT *mcapi_find_local_endpoint(MCAPI_GLOBAL_DATA *, mcapi_node_t ,

                                          mcapi_port_t);

/* suspend.c */

void mcapi_check_resume(int, mcapi_endpoint_t, MCAPI_ENDPOINT *, size_t, mcapi_status_t);

mcapi_request_t *mcapi_find_request(mcapi_request_t *, MCAPI_REQ_QUEUE *);

void mcapi_resume(MCAPI_GLOBAL_DATA *, mcapi_request_t *, mcapi_status_t);

/* get_endp.c */

void get_remote_endpoint(mcapi_node_t, mcapi_port_t, mcapi_status_t *,

                         mcapi_uint32_t);

/* queue.c */

void mcapi_enqueue(void *, void *);

void *mcapi_remove(void *, void *);

void *mcapi_dequeue(void *);

/* msg_snd.c */

void msg_send(mcapi_endpoint_t, mcapi_endpoint_t, void *, size_t, mcapi_priority_t ,

              mcapi_request_t *, mcapi_status_t *mcapi_status, mcapi_uint32_t);

/* msg_rcv.c */

void msg_recv(mcapi_endpoint_t, void *, size_t, size_t *, mcapi_request_t *,

              mcapi_status_t *, mcapi_uint32_t);

size_t msg_recv_copy_data(MCAPI_ENDPOINT *, void *);

/* msg_snd.c */

void pkt_send(mcapi_pktchan_send_hndl_t, void *, size_t, mcapi_request_t *,

              mcapi_status_t *, mcapi_uint32_t);

/* msg_rcv.c */

void pkt_rcv(mcapi_pktchan_recv_hndl_t, void **, size_t *, mcapi_request_t *,

             mcapi_status_t *, mcapi_uint32_t);

/* interface.c */

mcapi_status_t mcapi_init_interfaces(mcapi_node_t);

MCAPI_INTERFACE *mcapi_find_interface(char*);

/* loopback.c */

mcapi_status_t mcapi_loop_init(mcapi_node_t, MCAPI_INTERFACE *);

mcapi_status_t mcapi_loop_tx(MCAPI_BUFFER *, size_t, mcapi_priority_t,

                             MCAPI_ENDPOINT *);

mcapi_status_t mcapi_loop_ioctl(mcapi_uint_t, void *, size_t);

/* route.c */

MCAPI_ROUTE *mcapi_find_route(mcapi_node_t, MCAPI_NODE *);

/* buf_mgmt.c */

void mcapi_recover_buffer(MCAPI_BUFFER *);

MCAPI_BUFFER *mcapi_reserve_buffer(mcapi_node_t, size_t, mcapi_uint32_t);

/* connect.c */

void mcapi_connect(mcapi_endpoint_t, mcapi_endpoint_t, mcapi_uint32_t,

                   mcapi_request_t *, mcapi_status_t *);

void mcapi_open(mcapi_endpoint_t, mcapi_uint32_t, mcapi_request_t *,

                mcapi_uint32_t, mcapi_uint16_t, mcapi_uint16_t,

                mcapi_status_t *);

void mcapi_close(MCAPI_ENDPOINT *, mcapi_uint32_t, mcapi_request_t *,

                 mcapi_uint32_t, mcapi_status_t *);

void mcapi_tx_open(unsigned char *, MCAPI_ENDPOINT *, mcapi_node_t, mcapi_port_t,

                   mcapi_node_t, mcapi_port_t, mcapi_uint16_t, mcapi_uint16_t,

                   mcapi_status_t *);

void mcapi_tx_fin_msg(MCAPI_ENDPOINT *, mcapi_status_t *);

/* tls.c */

unsigned long mcapi_get32(unsigned char *, unsigned int);

void mcapi_put32(unsigned char *, unsigned int, unsigned long);

unsigned long long mcapi_get64(unsigned char *, unsigned int);

void mcapi_put64(unsigned char *, unsigned int, unsigned long long);

unsigned short mcapi_get16(unsigned char *, unsigned int);

void mcapi_put16(unsigned char *, unsigned int, unsigned short);

#define MCAPI_PUT8(bufferP, offset, value) \

  (((unsigned char *)(bufferP))[offset]) = (value)

#define MCAPI_PUT16(bufferP, offset, value) \

  mcapi_put16((unsigned char *)bufferP, offset, (value))

#define MCAPI_PUT32(bufferP, offset, value) \

  mcapi_put32((unsigned char *)bufferP, offset, (value))

#define MCAPI_GET32(bufferP, offset) \

  mcapi_get32((unsigned char *)bufferP, offset)

#define MCAPI_GET16(bufferP, offset) \

  mcapi_get16((unsigned char *)bufferP, offset)

#define MCAPI_GET8(bufferP, offset) \

  (((unsigned char *)(bufferP))[offset])

#define MCAPI_PUT64(bufferP, offset, value) \

  mcapi_put64((unsigned char *)bufferP, offset, (value))

#define MCAPI_GET64(bufferP, offset) \

  mcapi_get64((unsigned char *)bufferP, offset)

/* scal_snd.c */

void scal_send(mcapi_pktchan_send_hndl_t, MCAPI_SCALAR *, mcapi_uint8_t,

               mcapi_status_t *);

/* scal_rcv.c */

void scal_rcv(mcapi_sclchan_recv_hndl_t, MCAPI_SCALAR *, mcapi_uint8_t,

              mcapi_status_t *);

/* data_avail.c */

void mcapi_data_available(MCAPI_ENDPOINT *, mcapi_uint32_t, mcapi_uint_t *,

                          mcapi_status_t *);

/* data_count.c */

void mcapi_check_data(MCAPI_ENDPOINT *, mcapi_uint_t *);

/* create_endpoint.c */

mcapi_endpoint_t create_endpoint(MCAPI_NODE *, mcapi_port_t, mcapi_status_t *);

void mcapi_check_foreign_resume(int, mcapi_endpoint_t, mcapi_status_t);

/* forward.c */

void mcapi_forward(MCAPI_GLOBAL_DATA *, MCAPI_BUFFER *, mcapi_node_t);

/* request.c */

void mcapi_init_request(mcapi_request_t *, mcapi_uint8_t);

mcapi_request_t *mcapi_get_free_request_struct(void);

void mcapi_release_request_struct(mcapi_request_t *);

mcapi_boolean_t __mcapi_test(mcapi_request_t *request, size_t *size,

                             mcapi_status_t *mcapi_status);

/* mcapi_os.c */

mcapi_status_t MCAPI_Resume_Task(mcapi_request_t *);

mcapi_status_t MCAPI_Suspend_Task(MCAPI_GLOBAL_DATA *, mcapi_request_t *,

                                  MCAPI_COND_STRUCT *, mcapi_timeout_t);

mcapi_status_t MCAPI_Init_OS(void);

void MCAPI_Exit_OS(void);

void MCAPI_Cleanup_Task(void);

mcapi_status_t MCAPI_Create_Mutex(MCAPI_MUTEX *, char *);

mcapi_status_t MCAPI_Delete_Mutex(MCAPI_MUTEX *);

mcapi_status_t MCAPI_Obtain_Mutex(MCAPI_MUTEX *);

mcapi_status_t MCAPI_Release_Mutex(MCAPI_MUTEX *);

mcapi_status_t MCAPI_Set_RX_Event(void);

void MCAPI_Init_Condition(MCAPI_COND_STRUCT *);

void MCAPI_Set_Condition(mcapi_request_t *, MCAPI_COND_STRUCT *);

void MCAPI_Clear_Condition(mcapi_request_t *);

mcapi_int_t MCAPI_Lock_RX_Queue(void);

void MCAPI_Unlock_RX_Queue(mcapi_int_t cookie);

void MCAPI_Sleep(unsigned int secs);

/* The name of the shared memory interface. */

#define OPENMCAPI_SHM_NAME "sha_mem"

mcapi_status_t openmcapi_shm_init(mcapi_node_t node_id,

                                  MCAPI_INTERFACE* int_ptr);

#ifdef          __cplusplus

}

#endif /* _cplusplus */

#endif /* MCAPI_DEFS_H */