mirror of https://github.com/F-Stack/f-stack.git
325 lines
16 KiB
C
325 lines
16 KiB
C
/**
|
|
* Copyright (c) 2010-2012 Broadcom. 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,
|
|
* without modification.
|
|
* 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. The names of the above-listed copyright holders may not be used
|
|
* to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* ALTERNATIVELY, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") version 2, as published by the Free
|
|
* Software Foundation.
|
|
*
|
|
* 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 OWNER 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 CONNECTION_H_
|
|
#define CONNECTION_H_
|
|
|
|
#include "interface/vchi/vchi_cfg_internal.h"
|
|
#include "interface/vchi/vchi_common.h"
|
|
#include "interface/vchi/message_drivers/message.h"
|
|
|
|
/******************************************************************************
|
|
Global defs
|
|
*****************************************************************************/
|
|
|
|
// Opaque handle for a connection / service pair
|
|
typedef struct opaque_vchi_connection_connected_service_handle_t *VCHI_CONNECTION_SERVICE_HANDLE_T;
|
|
|
|
// opaque handle to the connection state information
|
|
typedef struct opaque_vchi_connection_info_t VCHI_CONNECTION_STATE_T;
|
|
|
|
typedef struct vchi_connection_t VCHI_CONNECTION_T;
|
|
|
|
|
|
/******************************************************************************
|
|
API
|
|
*****************************************************************************/
|
|
|
|
// Routine to init a connection with a particular low level driver
|
|
typedef VCHI_CONNECTION_STATE_T * (*VCHI_CONNECTION_INIT_T)( struct vchi_connection_t * connection,
|
|
const VCHI_MESSAGE_DRIVER_T * driver );
|
|
|
|
// Routine to control CRC enabling at a connection level
|
|
typedef int32_t (*VCHI_CONNECTION_CRC_CONTROL_T)( VCHI_CONNECTION_STATE_T *state_handle,
|
|
VCHI_CRC_CONTROL_T control );
|
|
|
|
// Routine to create a service
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_CONNECT_T)( VCHI_CONNECTION_STATE_T *state_handle,
|
|
int32_t service_id,
|
|
uint32_t rx_fifo_size,
|
|
uint32_t tx_fifo_size,
|
|
int server,
|
|
VCHI_CALLBACK_T callback,
|
|
void *callback_param,
|
|
int32_t want_crc,
|
|
int32_t want_unaligned_bulk_rx,
|
|
int32_t want_unaligned_bulk_tx,
|
|
VCHI_CONNECTION_SERVICE_HANDLE_T *service_handle );
|
|
|
|
// Routine to close a service
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_DISCONNECT_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle );
|
|
|
|
// Routine to queue a message
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_QUEUE_MESSAGE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
const void *data,
|
|
uint32_t data_size,
|
|
VCHI_FLAGS_T flags,
|
|
void *msg_handle );
|
|
|
|
// scatter-gather (vector) message queueing
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_QUEUE_MESSAGEV_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
VCHI_MSG_VECTOR_T *vector,
|
|
uint32_t count,
|
|
VCHI_FLAGS_T flags,
|
|
void *msg_handle );
|
|
|
|
// Routine to dequeue a message
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_DEQUEUE_MESSAGE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void *data,
|
|
uint32_t max_data_size_to_read,
|
|
uint32_t *actual_msg_size,
|
|
VCHI_FLAGS_T flags );
|
|
|
|
// Routine to peek at a message
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_PEEK_MESSAGE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void **data,
|
|
uint32_t *msg_size,
|
|
VCHI_FLAGS_T flags );
|
|
|
|
// Routine to hold a message
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_HOLD_MESSAGE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void **data,
|
|
uint32_t *msg_size,
|
|
VCHI_FLAGS_T flags,
|
|
void **message_handle );
|
|
|
|
// Routine to initialise a received message iterator
|
|
typedef int32_t (*VCHI_CONNECTION_SERVICE_LOOKAHEAD_MESSAGE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
VCHI_MSG_ITER_T *iter,
|
|
VCHI_FLAGS_T flags );
|
|
|
|
// Routine to release a held message
|
|
typedef int32_t (*VCHI_CONNECTION_HELD_MSG_RELEASE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void *message_handle );
|
|
|
|
// Routine to get info on a held message
|
|
typedef int32_t (*VCHI_CONNECTION_HELD_MSG_INFO_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void *message_handle,
|
|
void **data,
|
|
int32_t *msg_size,
|
|
uint32_t *tx_timestamp,
|
|
uint32_t *rx_timestamp );
|
|
|
|
// Routine to check whether the iterator has a next message
|
|
typedef int32_t (*VCHI_CONNECTION_MSG_ITER_HAS_NEXT_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service,
|
|
const VCHI_MSG_ITER_T *iter );
|
|
|
|
// Routine to advance the iterator
|
|
typedef int32_t (*VCHI_CONNECTION_MSG_ITER_NEXT_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service,
|
|
VCHI_MSG_ITER_T *iter,
|
|
void **data,
|
|
uint32_t *msg_size );
|
|
|
|
// Routine to remove the last message returned by the iterator
|
|
typedef int32_t (*VCHI_CONNECTION_MSG_ITER_REMOVE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service,
|
|
VCHI_MSG_ITER_T *iter );
|
|
|
|
// Routine to hold the last message returned by the iterator
|
|
typedef int32_t (*VCHI_CONNECTION_MSG_ITER_HOLD_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service,
|
|
VCHI_MSG_ITER_T *iter,
|
|
void **msg_handle );
|
|
|
|
// Routine to transmit bulk data
|
|
typedef int32_t (*VCHI_CONNECTION_BULK_QUEUE_TRANSMIT_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
const void *data_src,
|
|
uint32_t data_size,
|
|
VCHI_FLAGS_T flags,
|
|
void *bulk_handle );
|
|
|
|
// Routine to receive data
|
|
typedef int32_t (*VCHI_CONNECTION_BULK_QUEUE_RECEIVE_T)( VCHI_CONNECTION_SERVICE_HANDLE_T service_handle,
|
|
void *data_dst,
|
|
uint32_t data_size,
|
|
VCHI_FLAGS_T flags,
|
|
void *bulk_handle );
|
|
|
|
// Routine to report if a server is available
|
|
typedef int32_t (*VCHI_CONNECTION_SERVER_PRESENT)( VCHI_CONNECTION_STATE_T *state, int32_t service_id, int32_t peer_flags );
|
|
|
|
// Routine to report the number of RX slots available
|
|
typedef int (*VCHI_CONNECTION_RX_SLOTS_AVAILABLE)( const VCHI_CONNECTION_STATE_T *state );
|
|
|
|
// Routine to report the RX slot size
|
|
typedef uint32_t (*VCHI_CONNECTION_RX_SLOT_SIZE)( const VCHI_CONNECTION_STATE_T *state );
|
|
|
|
// Callback to indicate that the other side has added a buffer to the rx bulk DMA FIFO
|
|
typedef void (*VCHI_CONNECTION_RX_BULK_BUFFER_ADDED)(VCHI_CONNECTION_STATE_T *state,
|
|
int32_t service,
|
|
uint32_t length,
|
|
MESSAGE_TX_CHANNEL_T channel,
|
|
uint32_t channel_params,
|
|
uint32_t data_length,
|
|
uint32_t data_offset);
|
|
|
|
// Callback to inform a service that a Xon or Xoff message has been received
|
|
typedef void (*VCHI_CONNECTION_FLOW_CONTROL)(VCHI_CONNECTION_STATE_T *state, int32_t service_id, int32_t xoff);
|
|
|
|
// Callback to inform a service that a server available reply message has been received
|
|
typedef void (*VCHI_CONNECTION_SERVER_AVAILABLE_REPLY)(VCHI_CONNECTION_STATE_T *state, int32_t service_id, uint32_t flags);
|
|
|
|
// Callback to indicate that bulk auxiliary messages have arrived
|
|
typedef void (*VCHI_CONNECTION_BULK_AUX_RECEIVED)(VCHI_CONNECTION_STATE_T *state);
|
|
|
|
// Callback to indicate that bulk auxiliary messages have arrived
|
|
typedef void (*VCHI_CONNECTION_BULK_AUX_TRANSMITTED)(VCHI_CONNECTION_STATE_T *state, void *handle);
|
|
|
|
// Callback with all the connection info you require
|
|
typedef void (*VCHI_CONNECTION_INFO)(VCHI_CONNECTION_STATE_T *state, uint32_t protocol_version, uint32_t slot_size, uint32_t num_slots, uint32_t min_bulk_size);
|
|
|
|
// Callback to inform of a disconnect
|
|
typedef void (*VCHI_CONNECTION_DISCONNECT)(VCHI_CONNECTION_STATE_T *state, uint32_t flags);
|
|
|
|
// Callback to inform of a power control request
|
|
typedef void (*VCHI_CONNECTION_POWER_CONTROL)(VCHI_CONNECTION_STATE_T *state, MESSAGE_TX_CHANNEL_T channel, int32_t enable);
|
|
|
|
// allocate memory suitably aligned for this connection
|
|
typedef void * (*VCHI_BUFFER_ALLOCATE)(VCHI_CONNECTION_SERVICE_HANDLE_T service_handle, uint32_t * length);
|
|
|
|
// free memory allocated by buffer_allocate
|
|
typedef void (*VCHI_BUFFER_FREE)(VCHI_CONNECTION_SERVICE_HANDLE_T service_handle, void * address);
|
|
|
|
|
|
/******************************************************************************
|
|
System driver struct
|
|
*****************************************************************************/
|
|
|
|
struct opaque_vchi_connection_api_t
|
|
{
|
|
// Routine to init the connection
|
|
VCHI_CONNECTION_INIT_T init;
|
|
|
|
// Connection-level CRC control
|
|
VCHI_CONNECTION_CRC_CONTROL_T crc_control;
|
|
|
|
// Routine to connect to or create service
|
|
VCHI_CONNECTION_SERVICE_CONNECT_T service_connect;
|
|
|
|
// Routine to disconnect from a service
|
|
VCHI_CONNECTION_SERVICE_DISCONNECT_T service_disconnect;
|
|
|
|
// Routine to queue a message
|
|
VCHI_CONNECTION_SERVICE_QUEUE_MESSAGE_T service_queue_msg;
|
|
|
|
// scatter-gather (vector) message queue
|
|
VCHI_CONNECTION_SERVICE_QUEUE_MESSAGEV_T service_queue_msgv;
|
|
|
|
// Routine to dequeue a message
|
|
VCHI_CONNECTION_SERVICE_DEQUEUE_MESSAGE_T service_dequeue_msg;
|
|
|
|
// Routine to peek at a message
|
|
VCHI_CONNECTION_SERVICE_PEEK_MESSAGE_T service_peek_msg;
|
|
|
|
// Routine to hold a message
|
|
VCHI_CONNECTION_SERVICE_HOLD_MESSAGE_T service_hold_msg;
|
|
|
|
// Routine to initialise a received message iterator
|
|
VCHI_CONNECTION_SERVICE_LOOKAHEAD_MESSAGE_T service_look_ahead_msg;
|
|
|
|
// Routine to release a message
|
|
VCHI_CONNECTION_HELD_MSG_RELEASE_T held_msg_release;
|
|
|
|
// Routine to get information on a held message
|
|
VCHI_CONNECTION_HELD_MSG_INFO_T held_msg_info;
|
|
|
|
// Routine to check for next message on iterator
|
|
VCHI_CONNECTION_MSG_ITER_HAS_NEXT_T msg_iter_has_next;
|
|
|
|
// Routine to get next message on iterator
|
|
VCHI_CONNECTION_MSG_ITER_NEXT_T msg_iter_next;
|
|
|
|
// Routine to remove the last message returned by iterator
|
|
VCHI_CONNECTION_MSG_ITER_REMOVE_T msg_iter_remove;
|
|
|
|
// Routine to hold the last message returned by iterator
|
|
VCHI_CONNECTION_MSG_ITER_HOLD_T msg_iter_hold;
|
|
|
|
// Routine to transmit bulk data
|
|
VCHI_CONNECTION_BULK_QUEUE_TRANSMIT_T bulk_queue_transmit;
|
|
|
|
// Routine to receive data
|
|
VCHI_CONNECTION_BULK_QUEUE_RECEIVE_T bulk_queue_receive;
|
|
|
|
// Routine to report the available servers
|
|
VCHI_CONNECTION_SERVER_PRESENT server_present;
|
|
|
|
// Routine to report the number of RX slots available
|
|
VCHI_CONNECTION_RX_SLOTS_AVAILABLE connection_rx_slots_available;
|
|
|
|
// Routine to report the RX slot size
|
|
VCHI_CONNECTION_RX_SLOT_SIZE connection_rx_slot_size;
|
|
|
|
// Callback to indicate that the other side has added a buffer to the rx bulk DMA FIFO
|
|
VCHI_CONNECTION_RX_BULK_BUFFER_ADDED rx_bulk_buffer_added;
|
|
|
|
// Callback to inform a service that a Xon or Xoff message has been received
|
|
VCHI_CONNECTION_FLOW_CONTROL flow_control;
|
|
|
|
// Callback to inform a service that a server available reply message has been received
|
|
VCHI_CONNECTION_SERVER_AVAILABLE_REPLY server_available_reply;
|
|
|
|
// Callback to indicate that bulk auxiliary messages have arrived
|
|
VCHI_CONNECTION_BULK_AUX_RECEIVED bulk_aux_received;
|
|
|
|
// Callback to indicate that a bulk auxiliary message has been transmitted
|
|
VCHI_CONNECTION_BULK_AUX_TRANSMITTED bulk_aux_transmitted;
|
|
|
|
// Callback to provide information about the connection
|
|
VCHI_CONNECTION_INFO connection_info;
|
|
|
|
// Callback to notify that peer has requested disconnect
|
|
VCHI_CONNECTION_DISCONNECT disconnect;
|
|
|
|
// Callback to notify that peer has requested power change
|
|
VCHI_CONNECTION_POWER_CONTROL power_control;
|
|
|
|
// allocate memory suitably aligned for this connection
|
|
VCHI_BUFFER_ALLOCATE buffer_allocate;
|
|
|
|
// free memory allocated by buffer_allocate
|
|
VCHI_BUFFER_FREE buffer_free;
|
|
|
|
};
|
|
|
|
struct vchi_connection_t {
|
|
const VCHI_CONNECTION_API_T *api;
|
|
VCHI_CONNECTION_STATE_T *state;
|
|
#ifdef VCHI_COARSE_LOCKING
|
|
struct semaphore sem;
|
|
#endif
|
|
};
|
|
|
|
|
|
#endif /* CONNECTION_H_ */
|
|
|
|
/****************************** End of file **********************************/
|