mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
170 lines
6.4 KiB
170 lines
6.4 KiB
/* |
|
Copyright (c) 2012-2014, Broadcom Europe Ltd |
|
All rights reserved. |
|
|
|
Redistribution and use in source and binary forms, with or without |
|
modification, are permitted provided that the following conditions are met: |
|
* Redistributions of source code must retain the above copyright |
|
notice, this list of conditions and the following disclaimer. |
|
* 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. |
|
* Neither the name of the copyright holder 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. |
|
*/ |
|
|
|
// Contains global defs used by submodules within vchi |
|
|
|
#ifndef VCHI_COMMON_H_ |
|
#define VCHI_COMMON_H_ |
|
|
|
|
|
//flags used when sending messages (must be bitmapped) |
|
typedef enum |
|
{ |
|
VCHI_FLAGS_NONE = 0x0, |
|
VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE = 0x1, // waits for message to be received, or sent (NB. not the same as being seen on other side) |
|
VCHI_FLAGS_CALLBACK_WHEN_OP_COMPLETE = 0x2, // run a callback when message sent |
|
VCHI_FLAGS_BLOCK_UNTIL_QUEUED = 0x4, // return once the transfer is in a queue ready to go |
|
VCHI_FLAGS_ALLOW_PARTIAL = 0x8, |
|
VCHI_FLAGS_BLOCK_UNTIL_DATA_READ = 0x10, |
|
VCHI_FLAGS_CALLBACK_WHEN_DATA_READ = 0x20, |
|
|
|
VCHI_FLAGS_ALIGN_SLOT = 0x000080, // internal use only |
|
VCHI_FLAGS_BULK_AUX_QUEUED = 0x010000, // internal use only |
|
VCHI_FLAGS_BULK_AUX_COMPLETE = 0x020000, // internal use only |
|
VCHI_FLAGS_BULK_DATA_QUEUED = 0x040000, // internal use only |
|
VCHI_FLAGS_BULK_DATA_COMPLETE = 0x080000, // internal use only |
|
VCHI_FLAGS_INTERNAL = 0xFF0000 |
|
} VCHI_FLAGS_T; |
|
|
|
// constants for vchi_crc_control() |
|
typedef enum { |
|
VCHI_CRC_NOTHING = -1, |
|
VCHI_CRC_PER_SERVICE = 0, |
|
VCHI_CRC_EVERYTHING = 1, |
|
} VCHI_CRC_CONTROL_T; |
|
|
|
//callback reasons when an event occurs on a service |
|
typedef enum |
|
{ |
|
VCHI_CALLBACK_REASON_MIN, |
|
|
|
//This indicates that there is data available |
|
//handle is the msg id that was transmitted with the data |
|
// When a message is received and there was no FULL message available previously, send callback |
|
// Tasks get kicked by the callback, reset their event and try and read from the fifo until it fails |
|
VCHI_CALLBACK_MSG_AVAILABLE, |
|
VCHI_CALLBACK_MSG_SENT, |
|
VCHI_CALLBACK_MSG_SPACE_AVAILABLE, // XXX not yet implemented |
|
|
|
// This indicates that a transfer from the other side has completed |
|
VCHI_CALLBACK_BULK_RECEIVED, |
|
//This indicates that data queued up to be sent has now gone |
|
//handle is the msg id that was used when sending the data |
|
VCHI_CALLBACK_BULK_SENT, |
|
VCHI_CALLBACK_BULK_RX_SPACE_AVAILABLE, // XXX not yet implemented |
|
VCHI_CALLBACK_BULK_TX_SPACE_AVAILABLE, // XXX not yet implemented |
|
|
|
VCHI_CALLBACK_SERVICE_CLOSED, |
|
|
|
// this side has sent XOFF to peer due to lack of data consumption by service |
|
// (suggests the service may need to take some recovery action if it has |
|
// been deliberately holding off consuming data) |
|
VCHI_CALLBACK_SENT_XOFF, |
|
VCHI_CALLBACK_SENT_XON, |
|
|
|
// indicates that a bulk transfer has finished reading the source buffer |
|
VCHI_CALLBACK_BULK_DATA_READ, |
|
|
|
// power notification events (currently host side only) |
|
VCHI_CALLBACK_PEER_OFF, |
|
VCHI_CALLBACK_PEER_SUSPENDED, |
|
VCHI_CALLBACK_PEER_ON, |
|
VCHI_CALLBACK_PEER_RESUMED, |
|
VCHI_CALLBACK_FORCED_POWER_OFF, |
|
|
|
#ifdef USE_VCHIQ_ARM |
|
// some extra notifications provided by vchiq_arm |
|
VCHI_CALLBACK_SERVICE_OPENED, |
|
VCHI_CALLBACK_BULK_RECEIVE_ABORTED, |
|
VCHI_CALLBACK_BULK_TRANSMIT_ABORTED, |
|
#endif |
|
|
|
VCHI_CALLBACK_REASON_MAX |
|
} VCHI_CALLBACK_REASON_T; |
|
|
|
// service control options |
|
typedef enum |
|
{ |
|
VCHI_SERVICE_OPTION_MIN, |
|
|
|
VCHI_SERVICE_OPTION_TRACE, |
|
VCHI_SERVICE_OPTION_SYNCHRONOUS, |
|
|
|
VCHI_SERVICE_OPTION_MAX |
|
} VCHI_SERVICE_OPTION_T; |
|
|
|
//Callback used by all services / bulk transfers |
|
typedef void (*VCHI_CALLBACK_T)( void *callback_param, //my service local param |
|
VCHI_CALLBACK_REASON_T reason, |
|
void *handle ); //for transmitting msg's only |
|
|
|
|
|
|
|
/* |
|
* Define vector struct for scatter-gather (vector) operations |
|
* Vectors can be nested - if a vector element has negative length, then |
|
* the data pointer is treated as pointing to another vector array, with |
|
* '-vec_len' elements. Thus to append a header onto an existing vector, |
|
* you can do this: |
|
* |
|
* void foo(const VCHI_MSG_VECTOR_T *v, int n) |
|
* { |
|
* VCHI_MSG_VECTOR_T nv[2]; |
|
* nv[0].vec_base = my_header; |
|
* nv[0].vec_len = sizeof my_header; |
|
* nv[1].vec_base = v; |
|
* nv[1].vec_len = -n; |
|
* ... |
|
* |
|
*/ |
|
typedef struct vchi_msg_vector { |
|
const void *vec_base; |
|
int32_t vec_len; |
|
} VCHI_MSG_VECTOR_T; |
|
|
|
// Opaque type for a connection API |
|
typedef struct opaque_vchi_connection_api_t VCHI_CONNECTION_API_T; |
|
|
|
// Opaque type for a message driver |
|
typedef struct opaque_vchi_message_driver_t VCHI_MESSAGE_DRIVER_T; |
|
|
|
|
|
// Iterator structure for reading ahead through received message queue. Allocated by client, |
|
// initialised by vchi_msg_look_ahead. Fields are for internal VCHI use only. |
|
// Iterates over messages in queue at the instant of the call to vchi_msg_lookahead - |
|
// will not proceed to messages received since. Behaviour is undefined if an iterator |
|
// is used again after messages for that service are removed/dequeued by any |
|
// means other than vchi_msg_iter_... calls on the iterator itself. |
|
typedef struct { |
|
struct opaque_vchi_service_t *service; |
|
void *last; |
|
void *next; |
|
void *remove; |
|
} VCHI_MSG_ITER_T; |
|
|
|
|
|
#endif // VCHI_COMMON_H_
|
|
|