staging: vc04_services: Drop no longer needed headers (4d695848) · Commits · 戴 / test

drivers/staging/vc04_services/interface/vchi/connections/connection.h

deleted100644 → 0

+0 −324

Original line number	Diff line number	Diff line
		/**
		* 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 <linux/kernel.h>
		#include <linux/types.h>
		#include <linux/semaphore.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 ********************************/

drivers/staging/vc04_services/interface/vchi/message_drivers/message.h

deleted100644 → 0

+0 −196

File deleted.

Preview size limit exceeded, changes collapsed.

drivers/staging/vc04_services/interface/vchi/vchi.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -36,7 +36,6 @@

		#include "interface/vchi/vchi_cfg.h"
		#include "interface/vchi/vchi_common.h"
		#include "interface/vchi/connections/connection.h"
		#include "vchi_mh.h"

		/******************************************************************************

drivers/staging/vc04_services/interface/vchi/vchi_cfg_internal.h

deleted100644 → 0

+0 −71

Original line number	Diff line number	Diff line
		/**
		* 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 VCHI_CFG_INTERNAL_H_
		#define VCHI_CFG_INTERNAL_H_

		/****************************************************************************************
		* Control optimisation attempts.
		***************************************************************************************/

		// Don't use lots of short-term locks - use great long ones, reducing the overall locks-per-second
		#define VCHI_COARSE_LOCKING

		// Avoid lock then unlock on exit from blocking queue operations (msg tx, bulk rx/tx)
		// (only relevant if VCHI_COARSE_LOCKING)
		#define VCHI_ELIDE_BLOCK_EXIT_LOCK

		// Avoid lock on non-blocking peek
		// (only relevant if VCHI_COARSE_LOCKING)
		#define VCHI_AVOID_PEEK_LOCK

		// Use one slot-handler thread per connection, rather than 1 thread dealing with all connections in rotation.
		#define VCHI_MULTIPLE_HANDLER_THREADS

		// Put free descriptors onto the head of the free queue, rather than the tail, so that we don't thrash
		// our way through the pool of descriptors.
		#define VCHI_PUSH_FREE_DESCRIPTORS_ONTO_HEAD

		// Don't issue a MSG_AVAILABLE callback for every single message. Possibly only safe if VCHI_COARSE_LOCKING.
		#define VCHI_FEWER_MSG_AVAILABLE_CALLBACKS

		// Don't use message descriptors for TX messages that don't need them
		#define VCHI_MINIMISE_TX_MSG_DESCRIPTORS

		// Nano-locks for multiqueue
		//#define VCHI_MQUEUE_NANOLOCKS

		// Lock-free(er) dequeuing
		//#define VCHI_RX_NANOLOCKS

		#endif /VCHI_CFG_INTERNAL_H_/

Admin message