| /* |
| * |
| * Proxy Server header file for TI81XX VPSS |
| * |
| * Copyright (C) 2009 TI |
| * Author: Yihe Hu <yihehu@ti.com> |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License as published by the |
| * Free Software Foundation; either version 2 of the License, or (at your |
| * option) any later version. |
| * |
| * This program 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 |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| */ |
| |
| #ifndef __LINUX_VPS_PROXYSERVER_H__ |
| #define __LINUX_VPS_PROXYSERVER_H__ |
| |
| #ifdef __KERNEL__ |
| |
| #define VPS_PSRV_MAX_NO_NOTIFY (32u) |
| /* < Maximum number of stream supported by Proxy Server. This define |
| could not be changed arbiterly, there is dependency on the number |
| of notify available with sysLink. Please refer the sysLink documentation |
| for details. */ |
| #define VPS_PSRV_MAX_NO_OF_CORES (12u) |
| /*< Maximum number of cores that Proxy Server could serve. */ |
| #define VPS_PSRV_NUMBER_OF_TASKS (0x5u) |
| /**< Used to specify the number of task that process requests from a remote |
| agent / client. Designed to be 5. Notify management would require |
| change if this changes */ |
| |
| |
| /** |
| * @brief This enumeration identifies the types of callbacks. |
| * |
| * On completion of an IO request OR on encountring an error, the proxy |
| * Server would notify the remote agents / clients via an priviously |
| * allocate notification number during FVID2 stream creation. |
| * |
| * Since notification happens on ONE notification channel Remote agents |
| * / clients could use this enumeration to differentiate between an |
| * error or IO completion notifications. |
| */ |
| enum vps_psrvcallbacktype { |
| VPS_FVID2_IO_CALLBACK = (0x01u), |
| /**< Specifies that callback is for IO completion */ |
| VPS_FVID2_ERR_CALLBACK = (0x02u) |
| /**< Specifies that the callback is for Error */ |
| }; |
| |
| |
| /** |
| * @brief Place holder for IO Request Callback |
| * Remote applications requires to be notified on completion of an IO |
| * request on HDVPSS sub-system. The structure defined here is an place |
| * holder that requires to be allocated by the remote agent / client, |
| * and passed to the proxy server. Proxy Server would update and |
| * update / maintain this structure. |
| * |
| */ |
| |
| struct vps_psrvcallback { |
| u32 cbtype; |
| /**< [OUT] Remote agents / clients could use this to determine if the |
| current notification is for IO completion event or error event */ |
| u32 syslnkntyno; |
| /**< [Reserved] for remote agent, expected to be used by Proxy Server. |
| Remote agents are expeted not to alter this */ |
| u32 syslnkprocid; |
| /**< [Reserved] for the remote agent, expected to be |
| used by Proxy Server. Remote agents are expeted not |
| to alter this */ |
| u32 callbackrtnvalue; |
| /**< [Reserved] Reserved for now, to be used if return |
| values requires to be handled in the HDVPSS sub-system */ |
| void *fvid2handle; |
| /**< [OUT] Handle to HDVPSS. Remote clients / agents |
| should not alter this.*/ |
| int (*appcallback) (void *handle, void *appdata, void *reserved); |
| /**< [OUT] Callback provided by the apps running on remote processor. |
| Expected to be used by the remote agent to notify apps - left |
| to remote agent to determine the use. Proxy Server will |
| not alter this. |
| */ |
| void *appdata; |
| /**< [OUT] Argument for the apps provided callback on the remote agent. |
| Proxy Server will not alter this. */ |
| void *reserved; |
| /**< [Reserved] Future requirements/enhancements if any */ |
| }; |
| |
| |
| /** |
| * @brief Place holder for Error Callback |
| * Remote applications requires to be notified on encountering an errors |
| * in the stream. |
| * The structure defined here is an place holder that requires to be |
| * allocated by the remote agent/client, and passed to the proxy server |
| * Proxy Server would update and update / maintain this structure. |
| */ |
| |
| struct vps_psrverrorcallback { |
| u32 cbtype; |
| /**< [OUT] Remote agents / clients could use this to determine if the |
| current notification is for IO completion event or error event */ |
| u32 syslnkntyno; |
| /**< [Reserved] for remote agent expected to be used by Proxy Server. |
| Agents are expected not alter this. */ |
| u32 syslnkprocid; |
| /**< [Reserved] for the remote agent, expected to be |
| used by Proxy Server. Remote agents are expeted not to |
| alter this */ |
| u32 callbackrtnvalue; |
| /**< [Reserved] Reserved for now, to be used if return values |
| requires to be handled in the HDVPSS sub-system */ |
| void *fvid2handle; |
| /**< [OUT] Handle to HDVPSS. Remote clients / agents should |
| not alter this.*/ |
| int (*appcallback)(void *handle, void *appdata, |
| void *errdata, void *reserved); |
| /**< [OUT] Error Callback provided by the apps running |
| on remote processor. Expected to be used by the remote |
| agent to notify apps - left to remote agent to determine the |
| use. Proxy Server will not alter this. */ |
| void *errlist; |
| /**< [OUT] Argument for the apps provided callback |
| on the remote agent. Proxy Server will not alter this. */ |
| void *reserved; |
| /**< [Reserved] Future requirements/enhancements if any */ |
| }; |
| |
| |
| |
| /** |
| * @brief This enumeration defines the types of commands that are supported by |
| * Proxy Server. The interpretation of the command structure |
| * (by Proxy Server) is defined type of command. |
| * A simplex command would indicate that a an single command is to be |
| * executed. |
| * A composite command would indicate that there are more the 1 |
| * command that requires to be executed. Typically multiple Q and DQ |
| */ |
| enum vps_psrvcommandtype { |
| VPS_FVID2_CMDTYPE_SIMPLEX = (0x01u), |
| /**< Specifies that command is a simplex command */ |
| VPS_FVID2_CMDTYPE_COMPOSITE = (0x02u), |
| /**< Specifies that the command is compound command and |
| all the commands in the command structure should be addressed |
| by the proxy server */ |
| VPS_FVID2_CMDTYPEMAX |
| /**< Rear enumeration guard */ |
| |
| }; |
| |
| |
| /** |
| * @brief Proxy Server Commands |
| * This enumeration defines the commands that would be honored by the |
| * HDVPSS sub-system/Proxy Server. These commands is expected to be |
| * exercised on a remote system that shares memory with the HDVPSS |
| * subsytem. |
| * |
| * Each of these commands requires the function arguments in a specific |
| * format, type definitions like VPS_PSrvFvid2InitParams, |
| * VPS_PSrvFvid2CreateParams, define the expected order. |
| * Application/Driver running on the remote processor is referred as |
| * an remote agent / client. |
| */ |
| enum vps_psrvcommands { |
| VPS_FVID2_INIT = (0x01u), |
| /**< The very first commands to VPS Subsystem. Expected to be |
| called once, either remotely or locally. Advised to exercise this |
| command before any operation. An return error code (TBD) will |
| mean that FVID2 has been initialized earlier and other FVID2 |
| calls will be honored by HDVPSS sub-system */ |
| VPS_FVID2_DE_INIT = (0x02u), |
| /**< The last control command, used to terminate FVID2 */ |
| VPS_FVID2_CREATE = (0x03u), |
| /**< Creates the named stream, calls FVID2 API FVID2_create. */ |
| VPS_FVID2_DELETE = (0x04u), |
| /**< Deletes the names stream, calls FVID2 API FVID2_delete */ |
| VPS_FVID2_CONTROL = (0x05u), |
| /**< To control a stream, calls FVID2 API FVID2_control */ |
| VPS_FVID2_QUEUE = (0x06u), |
| /**< To submit buffer that would be consumed by the driver, calls |
| FVID2 API FVID2_queue */ |
| VPS_FVID2_DEQUEUE = (0x07u), |
| /**< To retrieve the buffers that were submitted, calls the FVID2 API |
| FVID2_processFrames */ |
| VPS_FVID2_PROCESS_FRAMES = (0x08u), |
| /**< Similar to VPS_FVID2_QUEUE, expected to be used with |
| memory-to-memory driver. Calls the FVID2 API |
| FVID2_processFrames */ |
| VPS_FVID2_GET_PROCESSED_FRAMES = (0x09u), |
| /**< Similar to VPS_FVID2_DEQUEUE, expected to be used with |
| memory-to-memory driver. Calls the FVID2 API |
| FVID2_getProcessedFrames */ |
| VPS_FVID2_GET_FIRMWARE_VERSION = (0x0Au) |
| /**< Command used to determine the current version of the firmware, |
| running on the host processor. |
| */ |
| }; |
| |
| |
| /** |
| * @brief Proxy Server Host tasks type |
| * All client commands are processed by the host in a tasks context. |
| * Host spawns 4 tasks that would process these commands, typically |
| * one for display, capture, memory to memory and graphics. |
| * Applications could configure the host to associate an FVID2 channel |
| * with any of the tasks mentioned below. |
| * |
| * Note that there would a control task that would process commands |
| * FVID2_init, FVID2_deInit and FVID2_create. |
| * |
| * Please refer the user guide that came with this release for details. |
| * |
| */ |
| enum vps_psrvhosttasktype { |
| VPS_FVID2_TASK_TYPE_LOWER_GUARD = (0x00u), |
| /**< Lower guard */ |
| VPS_FVID2_TASK_TYPE_1 = (0x01u), |
| /**< Specifies that the command should be processed by task 1 */ |
| VPS_FVID2_TASK_TYPE_2 = (0x02u), |
| /**< Specifies that the command should be processed by task 2 */ |
| VPS_FVID2_TASK_TYPE_3 = (0x03u), |
| /**< Specifies that the command should be processed by task 3 */ |
| VPS_FVID2_TASK_TYPE_4 = (0x04u), |
| /**< Specifies that the command should be processed by task 4 */ |
| VPS_FVID2_TASK_TYPE_UPPER_GUARD |
| /**< Upper guard */ |
| }; |
| |
| |
| /** |
| * @brief Command Structure for Proxy Server |
| * A remote agent that requires to instruct the proxy sever, would |
| * require to use the structure below. An instace of this structure will |
| * reuqired to be populated and notificted to proxy server. |
| * This structure will define the type of command (one or multiple), |
| * and a pointer to actual FVID2 command (array of pointer in case of |
| * multiple commands) |
| */ |
| |
| struct vps_psrvcommandstruct { |
| u32 cmdtype; |
| /**< [IN] Specifies the command type. Only VPS_FVID2_CMDTYPE_SIMPLEX is |
| supported at this point */ |
| u32 yieldafterncmds; |
| /**< [IN] Used only when the cmdType is VPS_FVID2_CMDTYPE_COMPOSITE, |
| In cases where IO on a given streams is very high which could |
| potentially cause CPU starve on other IO streams. In these |
| conditions remote agents / clients could decide to YIELD the |
| CPU after executing N number of commands of this stream. |
| Expected to be used in conjunction with priority of streams |
| to achieve real time balance between streams. */ |
| u32 syslnkprocid; |
| /**< [Reserved] Reserved for remote agents, would be used by |
| proxy server to hold the Proc Id of the remote processor in |
| case of command VPS_FVID2_CREATE */ |
| u32 syslnkntyno; |
| /**< [Reserved] Reserved for remote agents, would be used by |
| proxy server to hold the event number associated with remote |
| processor in case of command VPS_FVID2_DELETE */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder return value, if Proxy Server could |
| not process thiscommand. |
| e.g. |
| Un-Supported command type |
| second command received while executing first command |
| etc... */ |
| u32 noofcommands; |
| /**< [IN] Applicable in case of VPS_FVID2_CMDTYPE_COMPOSITE, |
| specifies the number of commands |
| \warning This should be 1 always.*/ |
| void *simplexcmdarg; |
| /**< [IN] Used only when the cmdType is VPS_FVID2_CMDTYPE_SIMPLEX, |
| this pointer will point to a structure defined by the command. |
| e.g if the command is VPS_FVID2_QUEUE |
| VPS_PSrvCommandStruc.cmdType = VPS_FVID2_CMDTYPE_SIMPLEX |
| and |
| ((VPS_PSrvFvid2QueueParams *)simplexCmdArg)->command = |
| VPS_FVID2_QUEUE */ |
| void **compositecmdargs; |
| /**< [IN] Used only when the cmdType is VPS_FVID2_CMDTYPE_COMPOSITE, |
| this will point to array of void pointer, number elements |
| in the array will be equals to noOfCommands. |
| Type of each of the pointer contained in array will match the |
| command used. |
| \warning Commands VPS_FVID2_CREATE and VPS_FVID2_DELETE |
| will not supported in the composite type command. |
| \warning This is not implemented. */ |
| |
| }; |
| /** |
| * @brief determine the status of proxy server and revision. |
| * |
| * this structure defines the structures that would be used query the |
| * status of the proxy server and query the revision of the firmware. |
| * remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| */ |
| struct vps_psrvgetstatusvercmdparams { |
| u32 command; |
| /**< [in] command from the agent - in this case |
| vps_fvid2_get_firmware_version or |
| vps_fvid2_get_status. |
| #vps_psrvcommands lists all supported commands */ |
| u32 reserved; |
| /**< [reserved] reserved for future use */ |
| int returnvalue; |
| /**< [out] place holder for commands executions return value. |
| positive values indicating the length of version. an negative |
| value in case of an error */ |
| u32 status; |
| /**< [out] update for command VPS_FVID2_GET_STATUS. |
| positive indicates proxy server is ready to receive fivd2 |
| commands, from the clients */ |
| u32 version; |
| /**< [out] update for command VPS_FVID2_GET_FIRMWARE_VERSION. |
| It's expected to be interpreated as 4 byte Hexadecimal Value. |
| */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 Initialization parameters |
| * This structure defines the structures that would be used during |
| * FVID2 initialization. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2initparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_INIT */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *args; |
| /**< [IN] First Argument required by the FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 De Initialization parameters |
| * This structure defines the structures that would be used during FVID2 |
| * de initialization. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2deinitparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_DE_INIT */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *args; |
| /**< [IN] First Argument required by the FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 stream creation parameters |
| * This structure defines the structures that would be used during FVID2 |
| * create stream. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2createparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_CREATE */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| u32 hosttaskinstance; |
| /**< specifies the host task type */ |
| u32 syslnkntyno; |
| /**< [OUT] Proxy Server allocates a notification number, |
| remote clients agents are expected to use this number |
| for future transactions on this stream. Please refer |
| sysLink for details IPC notifications. Note that type of |
| eventId is defined as UInt16 by sysLink, its explicitly |
| defined as u32. */ |
| void *fvid2handle; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| u32 drvid; |
| /**< [IN] First Argument required by FVID2_create */ |
| u32 instanceid; |
| /**< [IN] Second Argument required by FVID2_create */ |
| void *createargs; |
| /**< [IN] Third Argument required by FVID2_create */ |
| void *createstatusargs; |
| /**< [IN] Fourth Argument required by FVID2_create */ |
| struct fvid2_cbparams *cbparams; |
| /**< [IN] Fivth Argument required by FVID2_create */ |
| struct vps_psrvcallback *ioreqcb; |
| /**< [IN] Place holder defined in the remote system which will be |
| populated by the Proxy Server and passed back to remote agent |
| on completion of an IO request.*/ |
| struct vps_psrverrorcallback *errcb; |
| /**< [IN] Place holder defined in the remote system which will be |
| populated by the Proxy Server and passed back to remote |
| agent on a error. Please refer FVID2 API header for details */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 stream deletion parameters |
| * This structure defines the structures that would be used during FVID2 |
| * stream deletion |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2deleteparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_DELETE */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2handle; |
| /**< [IN] Place holder for FVID2 stream handle */ |
| void *deleteargs; |
| /**< [IN] First Argument required by the FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 stream control parameters |
| * This structure defines the structures that would be used to |
| * control a previously created stream |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2controlparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_CONTROL */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2handle; |
| /**< [IN] FVID2 stream handle */ |
| u32 cmd; |
| /**< [IN] command refer FVID2 API */ |
| void *cmdargs; |
| /**< [IN] First Argument required by the FVID2 API refer FVID2 API */ |
| void *cmdstatusargs; |
| /**< [IN] Second Argument required by the FVID2 API refer FVID2 API */ |
| }; |
| |
| /** |
| * @brief FVID2 queue IO requests |
| * This structure defines the structures that would be used queue an IO |
| * request. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2queueparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_QUEUE */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2handle; |
| /**< [IN] FVID2 stream handle */ |
| struct fvid2_framelist *framelist; |
| /**< [IN] First Argument required by the FVID2 API refer FVID2 API */ |
| u32 streamid; |
| /**< [IN] Second Argument required by the FVID2 API refer FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 dequeue IO requests |
| * This structure defines the structures that would be used dequeue |
| * completed IO request. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2dequeueparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case VPS_FVID2_DEQUEUE */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2handle; |
| /**< [IN] FVID2 stream handle */ |
| struct fvid2_framelist *framelist; |
| /**< [IN] First Argument required by the FVID2 API refer FVID2 API */ |
| u32 streamid; |
| /**< [IN] Second Argument required by the FVID2 API refer FVID2 API */ |
| u32 timeout; |
| /**< [IN] third Argument required by the FVID2 API refer FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 Process Frames |
| * This structure defines the structures that would be used submit |
| * frames to be processed. |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2processframesparams { |
| u32 command; |
| /**< [IN] Command from the agent -VPS_FVID2_PROCESS_FRAMES */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2handle; |
| /**< [IN] FVID2 stream handle */ |
| struct fvid2_processlist *processlist; |
| /**< [IN] First Argument required by the FVID2 API refer FVID2 API */ |
| }; |
| |
| |
| |
| /** |
| * @brief FVID2 Retrieve Processed Frames |
| * This structure defines the structures that would be used retrieve |
| * processed frames |
| * Remote clients / agents allocates the memory for this structure, |
| * initializes the function parameters and pass a pointer to this struct |
| * |
| */ |
| struct vps_psrvfvid2getprocessedframesparams { |
| u32 command; |
| /**< [IN] Command from the agent - in this case |
| VPS_FVID2_GET_PROCESSED_FRAMES */ |
| u32 reserved; |
| /**< [Reserved] Reserved for future use */ |
| int returnvalue; |
| /**< [OUT] Place holder for FVID2 API return value */ |
| void *fvid2_handle; |
| /**< [IN] FVID2 stream handle */ |
| struct fvid2_processlist *processlist; |
| /**< [OUT] First Argument required by the FVID2 API refer FVID2 API */ |
| u32 timeout; |
| /**< [IN] third Argument required by the FVID2 API refer FVID2 API */ |
| }; |
| |
| |
| #endif |
| |
| #endif /* _VPS_PROXY_SERVER_H */ |
