/* SPDX-License-Identifier: MIT */
/******************************************************************************
* cameraif.h
*
* Unified camera device I/O interface for Xen guest OSes.
*
* Copyright (C) 2018-2019 EPAM Systems Inc.
*
* Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
*/
#ifndef __XEN_PUBLIC_IO_CAMERAIF_H__
#define __XEN_PUBLIC_IO_CAMERAIF_H__
#include "ring.h"
#include "../grant_table.h"
/*
******************************************************************************
* Protocol version
******************************************************************************
*/
#define XENCAMERA_PROTOCOL_VERSION "1"
/*
******************************************************************************
* Feature and Parameter Negotiation
******************************************************************************
*
* Front->back notifications: when enqueuing a new request, sending a
* notification can be made conditional on xencamera_req (i.e., the generic
* hold-off mechanism provided by the ring macros). Backends must set
* xencamera_req appropriately (e.g., using RING_FINAL_CHECK_FOR_REQUESTS()).
*
* Back->front notifications: when enqueuing a new response, sending a
* notification can be made conditional on xencamera_resp (i.e., the generic
* hold-off mechanism provided by the ring macros). Frontends must set
* xencamera_resp appropriately (e.g., using RING_FINAL_CHECK_FOR_RESPONSES()).
*
* The two halves of a para-virtual camera driver utilize nodes within
* XenStore to communicate capabilities and to negotiate operating parameters.
* This section enumerates these nodes which reside in the respective front and
* backend portions of XenStore, following the XenBus convention.
*
* All data in XenStore is stored as strings. Nodes specifying numeric
* values are encoded in decimal. Integer value ranges listed below are
* expressed as fixed sized integer types capable of storing the conversion
* of a properly formatted node string, without loss of information.
*
******************************************************************************
* Example configuration
******************************************************************************
*
* This is an example of backend and frontend configuration:
*
*--------------------------------- Backend -----------------------------------
*
* /local/domain/0/backend/vcamera/1/0/frontend-id = "1"
* /local/domain/0/backend/vcamera/1/0/frontend = "/local/domain/1/device/vcamera/0"
* /local/domain/0/backend/vcamera/1/0/state = "4"
* /local/domain/0/backend/vcamera/1/0/versions = "1,2"
*
*--------------------------------- Frontend ----------------------------------
*
* /local/domain/1/device/vcamera/0/backend-id = "0"
* /local/domain/1/device/vcamera/0/backend = "/local/domain/0/backend/vcamera/1"
* /local/domain/1/device/vcamera/0/state = "4"
* /local/domain/1/device/vcamera/0/version = "1"
* /local/domain/1/device/vcamera/0/be-alloc = "1"
*
*---------------------------- Device 0 configuration -------------------------
*
* /local/domain/1/device/vcamera/0/max-buffers = "3"
* /local/domain/1/device/vcamera/0/controls = "contrast,hue"
* /local/domain/1/device/vcamera/0/formats/YUYV/640x480/frame-rates = "30/1,15/1"
* /local/domain/1/device/vcamera/0/formats/YUYV/1920x1080/frame-rates = "15/2"
* /local/domain/1/device/vcamera/0/formats/BGRA/640x480/frame-rates = "15/1,15/2"
* /local/domain/1/device/vcamera/0/formats/BGRA/1200x720/frame-rates = "15/2"
* /local/domain/1/device/vcamera/0/unique-id = "0"
* /local/domain/1/device/vcamera/0/req-ring-ref = "2832"
* /local/domain/1/device/vcamera/0/req-event-channel = "15"
* /local/domain/1/device/vcamera/0/evt-ring-ref = "387"
* /local/domain/1/device/vcamera/0/evt-event-channel = "16"
*
*---------------------------- Device 1 configuration -------------------------
*
* /local/domain/1/device/vcamera/1/max-buffers = "8"
* /local/domain/1/device/vcamera/1/controls = "brightness,saturation,hue"
* /local/domain/1/device/vcamera/1/formats/YUYV/640x480/frame-rates = "30/1,15/2"
* /local/domain/1/device/vcamera/1/formats/YUYV/1920x1080/frame-rates = "15/2"
* /local/domain/1/device/vcamera/1/unique-id = "1"
* /local/domain/1/device/vcamera/1/req-ring-ref = "2833"
* /local/domain/1/device/vcamera/1/req-event-channel = "17"
* /local/domain/1/device/vcamera/1/evt-ring-ref = "388"
* /local/domain/1/device/vcamera/1/evt-event-channel = "18"
*
******************************************************************************
* Backend XenBus Nodes
******************************************************************************
*
*----------------------------- Protocol version ------------------------------
*
* versions
* Values: <string>
*
* List of XENCAMERA_LIST_SEPARATOR separated protocol versions supported
* by the backend. For example "1,2,3".
*
******************************************************************************
* Frontend XenBus Nodes
******************************************************************************
*
*-------------------------------- Addressing ---------------------------------
*
* dom-id
* Values: <uint16_t>
*
* Domain identifier.
*
* dev-id
* Values: <uint16_t>
*
* Device identifier.
*
* /local/domain/<dom-id>/device/vcamera/<dev-id>/...
*
*----------------------------- Protocol version ------------------------------
*
* version
* Values: <string>
*
* Protocol version, chosen among the ones supported by the backend.
*
*------------------------- Backend buffer allocation -------------------------
*
* be-alloc
* Values: "0", "1"
*
* If value is set to "1", then backend will be the buffer
* provider/allocator for this domain during XENCAMERA_OP_BUF_CREATE
* operation.
* If value is not "1" or omitted frontend must allocate buffers itself.
*
*------------------------------- Camera settings -----------------------------
*
* unique-id
* Values: <string>
*
* After device instance initialization each camera is assigned a
* unique ID, so it can be identified by the backend by this ID.
* This can be UUID or such.
*
* max-buffers
* Values: <uint8_t>
*
* Maximum number of camera buffers this frontend may use.
*
* controls
* Values: <list of string>
*
* List of supported camera controls separated by XENCAMERA_LIST_SEPARATOR.
* Camera controls are expressed as a list of string values w/o any
* ordering requirement.
*
* formats
* Values: <format, char[7]>
*
* Formats are organized as a set of directories one per each
* supported pixel format. The name of the directory is the
* corresponding FOURCC string label. The next level of
* the directory under <formats> represents supported resolutions.
* If the format represents a big-endian variant of a little
* endian format, then the "-BE" suffix must be added. E.g. 'AR15' vs
* 'AR15-BE'.
* If FOURCC string label has spaces then those are only allowed to
* be at the end of the label and must be trimmed, for example
* 'Y16' and 'Y16-BE' will be trimmed.
*
* resolution
* Values: <width, uint32_t>x<height, uint32_t>
*
* Resolutions are organized as a set of directories one per each
* supported resolution under corresponding <formats> directory.
* The name of the directory is the supported width and height
* of the camera resolution in pixels.
*
* frame-rates
* Values: <numerator, uint32_t>/<denominator, uint32_t>
*
* List of XENCAMERA_FRAME_RATE_SEPARATOR separated supported frame rates
* of the camera expressed as numerator and denominator of the
* corresponding frame rate.
*
*------------------- Camera Request Transport Parameters ---------------------
*
* This communication path is used to deliver requests from frontend to backend
* and get the corresponding responses from backend to frontend,
* set up per virtual camera device.
*
* req-event-channel
* Values: <uint32_t>
*
* The identifier of the Xen camera's control event channel
* used to signal activity in the ring buffer.
*
* req-ring-ref
* Values: <uint32_t>
*
* The Xen grant reference granting permission for the backend to map
* a sole page of camera's control ring buffer.
*
*-------------------- Camera Event Transport Parameters ----------------------
*
* This communication path is used to deliver asynchronous events from backend
* to frontend, set up per virtual camera device.
*
* evt-event-channel
* Values: <uint32_t>
*
* The identifier of the Xen camera's event channel
* used to signal activity in the ring buffer.
*
* evt-ring-ref
* Values: <uint32_t>
*
* The Xen grant reference granting permission for the backend to map
* a sole page of camera's event ring buffer.
*/
/*
******************************************************************************
* STATE DIAGRAMS
******************************************************************************
*
* Tool stack creates front and back state nodes with initial state
* XenbusStateInitialising.
* Tool stack creates and sets up frontend camera configuration
* nodes per domain.
*
*-------------------------------- Normal flow --------------------------------
*
* Front Back
* ================================= =====================================
* XenbusStateInitialising XenbusStateInitialising
* o Query backend device identification
* data.
* o Open and validate backend device.
* |
* |
* V
* XenbusStateInitWait
*
* o Query frontend configuration
* o Allocate and initialize
* event channels per configured
* camera.
* o Publish transport parameters
* that will be in effect during
* this connection.
* |
* |
* V
* XenbusStateInitialised
*
* o Query frontend transport parameters.
* o Connect to the event channels.
* |
* |
* V
* XenbusStateConnected
*
* o Create and initialize OS
* virtual camera as per
* configuration.
* |
* |
* V
* XenbusStateConnected
*
* XenbusStateUnknown
* XenbusStateClosed
* XenbusStateClosing
* o Remove virtual camera device
* o Remove event channels
* |
* |
* V
* XenbusStateClosed
*
*------------------------------- Recovery flow -------------------------------
*
* In case of frontend unrecoverable errors backend handles that as
* if frontend goes into the XenbusStateClosed state.
*
* In case of backend unrecoverable errors frontend tries removing
* the virtualized device. If this is possible at the moment of error,
* then frontend goes into the XenbusStateInitialising state and is ready for
* new connection with backend. If the virtualized device is still in use and
* cannot be removed, then frontend goes into the XenbusStateReconfiguring state
* until either the virtualized device is removed or backend initiates a new
* connection. On the virtualized device removal frontend goes into the
* XenbusStateInitialising state.
*
* Note on XenbusStateReconfiguring state of the frontend: if backend has
* unrecoverable errors then frontend cannot send requests to the backend
* and thus cannot provide functionality of the virtualized device anymore.
* After backend is back to normal the virtualized device may still hold some
* state: configuration in use, allocated buffers, client application state etc.
* In most cases, this will require frontend to implement complex recovery
* reconnect logic. Instead, by going into XenbusStateReconfiguring state,
* frontend will make sure no new clients of the virtualized device are
* accepted, allow existing client(s) to exit gracefully by signaling error
* state etc.
* Once all the clients are gone frontend can reinitialize the virtualized
* device and get into XenbusStateInitialising state again signaling the
* backend that a new connection can be made.
*
* There are multiple conditions possible under which frontend will go from
* XenbusStateReconfiguring into XenbusStateInitialising, some of them are OS
* specific. For example:
* 1. The underlying OS framework may provide callbacks to signal that the last
* client of the virtualized device has gone and the device can be removed
* 2. Frontend can schedule a deferred work (timer/tasklet/workqueue)
* to periodically check if this is the right time to re-try removal of
* the virtualized device.
* 3. By any other means.
*
******************************************************************************
* REQUEST CODES
******************************************************************************
*/
#define XENCAMERA_OP_CONFIG_SET 0x00
#define XENCAMERA_OP_CONFIG_GET 0x01
#define XENCAMERA_OP_CONFIG_VALIDATE 0x02
#define XENCAMERA_OP_FRAME_RATE_SET 0x03
#define XENCAMERA_OP_BUF_GET_LAYOUT 0x04
#define XENCAMERA_OP_BUF_REQUEST 0x05
#define XENCAMERA_OP_BUF_CREATE 0x06
#define XENCAMERA_OP_BUF_DESTROY 0x07
#define XENCAMERA_OP_BUF_QUEUE 0x08
#define XENCAMERA_OP_BUF_DEQUEUE 0x09
#define XENCAMERA_OP_CTRL_ENUM 0x0a
#define XENCAMERA_OP_CTRL_SET 0x0b
#define XENCAMERA_OP_CTRL_GET 0x0c
#define XENCAMERA_OP_STREAM_START 0x0d
#define XENCAMERA_OP_STREAM_STOP 0x0e
#define XENCAMERA_CTRL_BRIGHTNESS 0
#define XENCAMERA_CTRL_CONTRAST 1
#define XENCAMERA_CTRL_SATURATION 2
#define XENCAMERA_CTRL_HUE 3
/* Number of supported controls. */
#define XENCAMERA_MAX_CTRL 4
/* Control is read-only. */
#define XENCAMERA_CTRL_FLG_RO (1 << 0)
/* Control is write-only. */
#define XENCAMERA_CTRL_FLG_WO (1 << 1)
/* Control's value is volatile. */
#define XENCAMERA_CTRL_FLG_VOLATILE (1 << 2)
/* Supported color spaces. */
#define XENCAMERA_COLORSPACE_DEFAULT 0
#define XENCAMERA_COLORSPACE_SMPTE170M 1
#define XENCAMERA_COLORSPACE_REC709 2
#define XENCAMERA_COLORSPACE_SRGB 3
#define XENCAMERA_COLORSPACE_OPRGB 4
#define XENCAMERA_COLORSPACE_BT2020 5
#define XENCAMERA_COLORSPACE_DCI_P3 6
/* Color space transfer function. */
#define XENCAMERA_XFER_FUNC_DEFAULT 0
#define XENCAMERA_XFER_FUNC_709 1
#define XENCAMERA_XFER_FUNC_SRGB 2
#define XENCAMERA_XFER_FUNC_OPRGB 3
#define XENCAMERA_XFER_FUNC_NONE 4
#define XENCAMERA_XFER_FUNC_DCI_P3 5
#define XENCAMERA_XFER_FUNC_SMPTE2084 6
/* Color space Y’CbCr encoding. */
#define XENCAMERA_YCBCR_ENC_IGNORE 0
#define XENCAMERA_YCBCR_ENC_601 1
#define XENCAMERA_YCBCR_ENC_709 2
#define XENCAMERA_YCBCR_ENC_XV601 3
#define XENCAMERA_YCBCR_ENC_XV709 4
#define XENCAMERA_YCBCR_ENC_BT2020 5
#define XENCAMERA_YCBCR_ENC_BT2020_CONST_LUM 6
/* Quantization range. */
#define XENCAMERA_QUANTIZATION_DEFAULT 0
#define XENCAMERA_QUANTIZATION_FULL_RANGE 1
#define XENCAMERA_QUANTIZATION_LIM_RANGE 2
/*
******************************************************************************
* EVENT CODES
******************************************************************************
*/
#define XENCAMERA_EVT_FRAME_AVAIL 0x00
#define XENCAMERA_EVT_CTRL_CHANGE 0x01
/*
******************************************************************************
* XENSTORE FIELD AND PATH NAME STRINGS, HELPERS
******************************************************************************
*/
#define XENCAMERA_DRIVER_NAME "vcamera"
#define XENCAMERA_LIST_SEPARATOR ","
#define XENCAMERA_RESOLUTION_SEPARATOR "x"
#define XENCAMERA_FRACTION_SEPARATOR "/"
#define XENCAMERA_FIELD_BE_VERSIONS "versions"
#define XENCAMERA_FIELD_FE_VERSION "version"
#define XENCAMERA_FIELD_REQ_RING_REF "req-ring-ref"
#define XENCAMERA_FIELD_REQ_CHANNEL "req-event-channel"
#define XENCAMERA_FIELD_EVT_RING_REF "evt-ring-ref"
#define XENCAMERA_FIELD_EVT_CHANNEL "evt-event-channel"
#define XENCAMERA_FIELD_MAX_BUFFERS "max-buffers"
#define XENCAMERA_FIELD_CONTROLS "controls"
#define XENCAMERA_FIELD_FORMATS "formats"
#define XENCAMERA_FIELD_FRAME_RATES "frame-rates"
#define XENCAMERA_FIELD_BE_ALLOC "be-alloc"
#define XENCAMERA_FIELD_UNIQUE_ID "unique-id"
#define XENCAMERA_CTRL_BRIGHTNESS_STR "brightness"
#define XENCAMERA_CTRL_CONTRAST_STR "contrast"
#define XENCAMERA_CTRL_SATURATION_STR "saturation"
#define XENCAMERA_CTRL_HUE_STR "hue"
#define XENCAMERA_FOURCC_BIGENDIAN_STR "-BE"
/* Maximum number of buffer planes supported. */
#define XENCAMERA_MAX_PLANE 4
/*
******************************************************************************
* STATUS RETURN CODES
******************************************************************************
*
* Status return code is zero on success and -XEN_EXX on failure.
*
******************************************************************************
* Assumptions
******************************************************************************
*
* - usage of grant reference 0 as invalid grant reference:
* grant reference 0 is valid, but never exposed to a PV driver,
* because of the fact it is already in use/reserved by the PV console.
* - all references in this document to page sizes must be treated
* as pages of size XEN_PAGE_SIZE unless otherwise noted.
* - all FOURCC mappings used for configuration and messaging are
* Linux V4L2 ones: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/uapi/linux/videodev2.h
* with the following exceptions:
* - characters are allowed in [0x20; 0x7f] range
* - when used for XenStore configuration entries the following
* are not allowed:
* - '/', '\', ' ' (space), '<', '>', ':', '"', '|', '?', '*'
* - if trailing spaces are part of the FOURCC code then those must be
* trimmed
*
*
******************************************************************************
* Description of the protocol between frontend and backend driver
******************************************************************************
*
* The two halves of a Para-virtual camera driver communicate with
* each other using shared pages and event channels.
* Shared page contains a ring with request/response packets.
*
* All reserved fields in the structures below must be 0.
*
* For all request/response/event packets:
* - frame rate parameter is represented as a pair of 4 octet long
* numerator and denominator:
* - frame_rate_numer - uint32_t, numerator of the frame rate
* - frame_rate_denom - uint32_t, denominator of the frame rate
* The corresponding frame rate (Hz) is calculated as:
* frame_rate = frame_rate_numer / frame_rate_denom
* - buffer index is a zero based index of the buffer. Must be less than
* the value of XENCAMERA_OP_CONFIG_SET.num_bufs response:
* - index - uint8_t, index of the buffer.
*
*
*---------------------------------- Requests ---------------------------------
*
* All request packets have the same length (64 octets).
* All request packets have common header:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | operation | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* id - uint16_t, private guest value, echoed in response.
* operation - uint8_t, operation code, XENCAMERA_OP_XXX.
*
*
* Request to set/validate the configuration - request to set the
* configuration/mode of the camera (XENCAMERA_OP_CONFIG_SET) or to
* check if the configuration is valid and can be used
* (XENCAMERA_OP_CONFIG_VALIDATE):
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CONFIG_XXX | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | pixel format | 12
* +----------------+----------------+----------------+----------------+
* | width | 16
* +----------------+----------------+----------------+----------------+
* | height | 20
* +----------------+----------------+----------------+----------------+
* | reserved | 24
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* pixel_format - uint32_t, pixel format to be used, FOURCC code.
* width - uint32_t, width in pixels.
* height - uint32_t, height in pixels.
*
* See response format for this request.
*
* Notes:
* - the only difference between XENCAMERA_OP_CONFIG_VALIDATE and
* XENCAMERA_OP_CONFIG_SET is that the former doesn't actually change
* camera configuration, but queries if the configuration is valid.
* This can be used while stream is active and/or buffers allocated.
* - frontend must check the corresponding response in order to see
* if the values reported back by the backend do match the desired ones
* and can be accepted.
* - frontend may send multiple XENCAMERA_OP_CONFIG_SET requests before
* sending XENCAMERA_OP_STREAM_START request to update or tune the
* final stream configuration.
* - configuration cannot be changed during active streaming, e.g.
* after XENCAMERA_OP_STREAM_START and before XENCAMERA_OP_STREAM_STOP
* requests.
*/
struct xencamera_config_req {
uint32_t pixel_format;
uint32_t width;
uint32_t height;
};
/*
* Request current configuration of the camera:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CONFIG_GET | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* See response format for this request.
*
*
* Request to set the frame rate of the stream:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _FRAME_RATE_SET| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | frame_rate_numer | 12
* +----------------+----------------+----------------+----------------+
* | frame_rate_denom | 16
* +----------------+----------------+----------------+----------------+
* | reserved | 20
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* frame_rate_numer - uint32_t, numerator of the frame rate.
* frame_rate_denom - uint32_t, denominator of the frame rate.
*
* Notes:
* - to query the current (actual) frame rate use XENCAMERA_OP_CONFIG_GET
* request.
* - this request can be used with camera buffers allocated, but stream
* stopped, e.g. frontend is allowed to stop the stream with
* XENCAMERA_OP_STREAM_STOP, hold the buffers allocated (e.g. keep the
* configuration set with XENCAMERA_OP_CONFIG_SET), change the
* frame rate of the stream and (re)start the stream again with
* XENCAMERA_OP_STREAM_START.
* - frame rate cannot be changed during active streaming, e.g.
* after XENCAMERA_OP_STREAM_START and before XENCAMERA_OP_STREAM_STOP
* commands.
*/
struct xencamera_frame_rate_req {
uint32_t frame_rate_numer;
uint32_t frame_rate_denom;
};
/*
* Request camera buffer's layout:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _BUF_GET_LAYOUT| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* See response format for this request.
*
*
* Request number of buffers to be used:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_BUF_REQUEST| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | num_bufs | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* num_bufs - uint8_t, desired number of buffers to be used.
*
* If num_bufs is not zero then the backend validates the requested number of
* buffers and responds with the number of buffers allowed for this frontend.
* Frontend is responsible for checking the corresponding response in order to
* see if the values reported back by the backend do match the desired ones
* and can be accepted.
* Frontend is allowed to send multiple XENCAMERA_OP_BUF_REQUEST requests
* before sending XENCAMERA_OP_STREAM_START request to update or tune the
* final configuration.
* Frontend is not allowed to change the camera configuration after this call
* with a non-zero value of num_bufs. If camera reconfiguration is required
* then this request must be sent with num_bufs set to zero and any created
* buffers must be destroyed first.
* Frontend is not allowed to change the number of buffers after the
* streaming has started.
*
* If num_bufs is 0 and streaming has not started yet, then the backend will
* free all previously allocated buffers (if any).
* Trying to call this if streaming is in progress will result in an error.
*
* If camera reconfiguration is required then the streaming must be stopped
* and this request must be sent with num_bufs set to zero and any
* created buffers must be destroyed.
*
* Please note, that the number of buffers in this request must not exceed
* the value configured in XenStore.max-buffers.
*
* See response format for this request.
*/
struct xencamera_buf_request {
uint8_t num_bufs;
};
/*
* Request camera buffer creation:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_BUF_CREATE | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | index | reserved | 12
* +----------------+----------------+----------------+----------------+
* | plane_offset[0] | 16
* +----------------+----------------+----------------+----------------+
* | plane_offset[1] | 20
* +----------------+----------------+----------------+----------------+
* | plane_offset[2] | 24
* +----------------+----------------+----------------+----------------+
* | plane_offset[3] | 28
* +----------------+----------------+----------------+----------------+
* | gref_directory | 32
* +----------------+----------------+----------------+----------------+
* | reserved | 36
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* An attempt to create multiple buffers with the same index is an error.
* index can be re-used after destroying the corresponding camera buffer.
*
* index - uint8_t, index of the buffer to be created in the range
* from 0 to the num_bufs field returned in response for
* XENCAMERA_OP_BUF_REQUEST request
* plane_offset - array of uint32_t, offset of the corresponding plane
* in octets from the buffer start. Number of offsets returned is
* equal to the value returned in XENCAMERA_OP_BUF_GET_LAYOUT.num_planes.
* gref_directory - grant_ref_t, a reference to the first shared page
* describing shared buffer references. The size of the buffer is equal to
* XENCAMERA_OP_BUF_GET_LAYOUT.size response. At least one page exists. If
* shared buffer size exceeds what can be addressed by this single page,
* then reference to the next shared page must be supplied (see
* gref_dir_next_page below).
*
* If XENCAMERA_FIELD_BE_ALLOC configuration entry is set, then backend will
* allocate the buffer with the parameters provided in this request and page
* directory is handled as follows:
* Frontend on request:
* - allocates pages for the directory (gref_directory,
* gref_dir_next_page(s)
* - grants permissions for the pages of the directory to the backend
* - sets gref_dir_next_page fields
* Backend on response:
* - grants permissions for the pages of the buffer allocated to
* the frontend
* - fills in page directory with grant references
* (gref[] in struct xencamera_page_directory)
*/
struct xencamera_buf_create_req {
uint8_t index;
uint8_t reserved[3];
uint32_t plane_offset[XENCAMERA_MAX_PLANE];
grant_ref_t gref_directory;
};
/*
* Shared page for XENCAMERA_OP_BUF_CREATE buffer descriptor (gref_directory in
* the request) employs a list of pages, describing all pages of the shared
* data buffer:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | gref_dir_next_page | 4
* +----------------+----------------+----------------+----------------+
* | gref[0] | 8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | gref[i] | i*4+8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | gref[N - 1] | N*4+8
* +----------------+----------------+----------------+----------------+
*
* gref_dir_next_page - grant_ref_t, reference to the next page describing
* page directory. Must be 0 if there are no more pages in the list.
* gref[i] - grant_ref_t, reference to a shared page of the buffer
* allocated at XENCAMERA_OP_BUF_CREATE.
*
* Number of grant_ref_t entries in the whole page directory is not
* passed, but instead can be calculated as:
* num_grefs_total = (XENCAMERA_OP_BUF_REQUEST.size + XEN_PAGE_SIZE - 1) /
* XEN_PAGE_SIZE
*/
struct xencamera_page_directory {
grant_ref_t gref_dir_next_page;
grant_ref_t gref[1]; /* Variable length */
};
/*
* Request buffer destruction - destroy a previously allocated camera buffer:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_BUF_DESTROY| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | index | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* index - uint8_t, index of the buffer to be destroyed.
*
*
* Request queueing of the buffer for backend use:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_BUF_QUEUE | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | index | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* Notes:
* - frontends must not access the buffer content after this request until
* response to XENCAMERA_OP_BUF_DEQUEUE has been received.
* - buffers must be queued to the backend before destroying them with
* XENCAMERA_OP_BUF_DESTROY.
*
* index - uint8_t, index of the buffer to be queued.
*
*
* Request dequeueing of the buffer for frontend use:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_OP_BUF_DEQUEUE | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | index | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* Notes:
* - frontend is allowed to access the buffer content after the corresponding
* response to this request.
*
* index - uint8_t, index of the buffer to be queued.
*
*
* Request camera control details:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CTRL_ENUM | reserved | 4
* +----------------+----------------+----------------+----------------+
* | index | reserved | 8
* +----------------+----------------+----------------+----------------+
* | reserved | 12
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* See response format for this request.
*
* index - uint8_t, index of the control to be queried.
*/
struct xencamera_index {
uint8_t index;
};
/*
* Request camera control change:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_SET_CTRL | reserved | 4
* +----------------+----------------+----------------+----------------+
* | type | reserved | 8
* +----------------+----------------+----------------+----------------+
* | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* | value low 32-bit | 20
* +----------------+----------------+----------------+----------------+
* | value high 32-bit | 24
* +----------------+----------------+----------------+----------------+
* | reserved | 28
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* type - uint8_t, type of the control, one of the XENCAMERA_CTRL_XXX.
* value - int64_t, new value of the control.
*/
struct xencamera_ctrl_value {
uint8_t type;
uint8_t reserved[7];
int64_t value;
};
/*
* Request camera control state:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_GET_CTRL | reserved | 4
* +----------------+----------------+----------------+----------------+
* | type | reserved | 8
* +----------------+----------------+----------------+----------------+
* | reserved | 12
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* See response format for this request.
*
* type - uint8_t, type of the control, one of the XENCAMERA_CTRL_XXX.
*/
struct xencamera_get_ctrl_req {
uint8_t type;
};
/*
* Request camera capture stream start:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_OP_STREAM_START| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
*
* Request camera capture stream stop:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_OP_STREAM_STOP | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
*
*---------------------------------- Responses --------------------------------
*
* All response packets have the same length (64 octets).
*
* All response packets have common header:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | operation | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
*
* id - uint16_t, copied from the request.
* operation - uint8_t, XENCAMERA_OP_* - copied from request.
* status - int32_t, response status, zero on success and -XEN_EXX on failure.
*
*
* Configuration response - response for XENCAMERA_OP_CONFIG_SET,
* XENCAMERA_OP_CONFIG_GET and XENCAMERA_OP_CONFIG_VALIDATE requests:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CONFIG_XXX | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
* | pixel format | 12
* +----------------+----------------+----------------+----------------+
* | width | 16
* +----------------+----------------+----------------+----------------+
* | height | 20
* +----------------+----------------+----------------+----------------+
* | colorspace | 24
* +----------------+----------------+----------------+----------------+
* | xfer_func | 28
* +----------------+----------------+----------------+----------------+
* | ycbcr_enc | 32
* +----------------+----------------+----------------+----------------+
* | quantization | 36
* +----------------+----------------+----------------+----------------+
* | displ_asp_ratio_numer | 40
* +----------------+----------------+----------------+----------------+
* | displ_asp_ratio_denom | 44
* +----------------+----------------+----------------+----------------+
* | frame_rate_numer | 48
* +----------------+----------------+----------------+----------------+
* | frame_rate_denom | 52
* +----------------+----------------+----------------+----------------+
* | reserved | 56
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* Meaning of the corresponding values in this response is the same as for
* XENCAMERA_OP_CONFIG_SET and XENCAMERA_OP_FRAME_RATE_SET requests.
*
* colorspace - uint32_t, this supplements pixel_format parameter,
* one of the XENCAMERA_COLORSPACE_XXX.
* xfer_func - uint32_t, this supplements colorspace parameter,
* one of the XENCAMERA_XFER_FUNC_XXX.
* ycbcr_enc - uint32_t, this supplements colorspace parameter,
* one of the XENCAMERA_YCBCR_ENC_XXX. Please note, that ycbcr_enc is only
* valid for YCbCr pixelformats and should be ignored otherwise.
* quantization - uint32_t, this supplements colorspace parameter,
* one of the XENCAMERA_QUANTIZATION_XXX.
* displ_asp_ratio_numer - uint32_t, numerator of the display aspect ratio.
* displ_asp_ratio_denom - uint32_t, denominator of the display aspect ratio.
*/
struct xencamera_config_resp {
uint32_t pixel_format;
uint32_t width;
uint32_t height;
uint32_t colorspace;
uint32_t xfer_func;
uint32_t ycbcr_enc;
uint32_t quantization;
uint32_t displ_asp_ratio_numer;
uint32_t displ_asp_ratio_denom;
uint32_t frame_rate_numer;
uint32_t frame_rate_denom;
};
/*
* Request buffer response - response for XENCAMERA_OP_BUF_GET_LAYOUT
* request:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_BUF_GET_LAYOUT | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
* | num_planes | reserved | 12
* +----------------+----------------+----------------+----------------+
* | size | 16
* +----------------+----------------+----------------+----------------+
* | plane_size[0] | 20
* +----------------+----------------+----------------+----------------+
* | plane_size[1] | 24
* +----------------+----------------+----------------+----------------+
* | plane_size[2] | 28
* +----------------+----------------+----------------+----------------+
* | plane_size[3] | 32
* +----------------+----------------+----------------+----------------+
* | plane_stride[0] | 36
* +----------------+----------------+----------------+----------------+
* | plane_stride[1] | 40
* +----------------+----------------+----------------+----------------+
* | plane_stride[2] | 44
* +----------------+----------------+----------------+----------------+
* | plane_stride[3] | 48
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* num_planes - uint8_t, number of planes of the buffer.
* size - uint32_t, overall size of the buffer including sizes of the
* individual planes and padding if applicable.
* plane_size - array of uint32_t, size in octets of the corresponding plane
* including padding.
* plane_stride - array of uint32_t, size in octets occupied by the
* corresponding single image line including padding if applicable.
*
* Note! The sizes and strides in this response apply to all buffers created
* with XENCAMERA_OP_BUF_CREATE command, but individual buffers may have
* different plane offsets, see XENCAMERA_OP_BUF_REQUEST.plane_offset.
*/
struct xencamera_buf_get_layout_resp {
uint8_t num_planes;
uint8_t reserved[3];
uint32_t size;
uint32_t plane_size[XENCAMERA_MAX_PLANE];
uint32_t plane_stride[XENCAMERA_MAX_PLANE];
};
/*
* Request buffer response - response for XENCAMERA_OP_BUF_REQUEST
* request:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_OP_BUF_REQUEST | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
* | num_buffers | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* num_buffers - uint8_t, number of buffers to be used.
*
*
* Control enumerate response - response for XENCAMERA_OP_CTRL_ENUM:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CTRL_ENUM | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
* | index | type | reserved | 12
* +----------------+----------------+----------------+----------------+
* | flags | 16
* +----------------+----------------+----------------+----------------+
* | min low 32-bits | 20
* +----------------+----------------+----------------+----------------+
* | min high 32-bits | 24
* +----------------+----------------+----------------+----------------+
* | max low 32-bits | 28
* +----------------+----------------+----------------+----------------+
* | max high 32-bits | 32
* +----------------+----------------+----------------+----------------+
* | step low 32-bits | 36
* +----------------+----------------+----------------+----------------+
* | step high 32-bits | 40
* +----------------+----------------+----------------+----------------+
* | def_val low 32-bits | 44
* +----------------+----------------+----------------+----------------+
* | def_val high 32-bits | 48
* +----------------+----------------+----------------+----------------+
* | reserved | 52
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* index - uint8_t, index of the camera control in response.
* type - uint8_t, type of the control, one of the XENCAMERA_CTRL_XXX.
* flags - uint32_t, flags of the control, one of the XENCAMERA_CTRL_FLG_XXX.
* min - int64_t, minimum value of the control.
* max - int64_t, maximum value of the control.
* step - int64_t, minimum size in which control value can be changed.
* def_val - int64_t, default value of the control.
*/
struct xencamera_ctrl_enum_resp {
uint8_t index;
uint8_t type;
uint8_t reserved[2];
uint32_t flags;
int64_t min;
int64_t max;
int64_t step;
int64_t def_val;
};
/*
* Get control response - response for XENCAMERA_OP_CTRL_GET:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | _OP_CTRL_GET | reserved | 4
* +----------------+----------------+----------------+----------------+
* | status | 8
* +----------------+----------------+----------------+----------------+
* | type | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* | reserved | 20
* +----------------+----------------+----------------+----------------+
* | value low 32-bit | 24
* +----------------+----------------+----------------+----------------+
* | value high 32-bit | 28
* +----------------+----------------+----------------+----------------+
* | reserved | 32
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* type - uint8_t, type of the control, one of the XENCAMERA_CTRL_XXX.
* value - int64_t, new value of the control.
*/
/*
*----------------------------------- Events ----------------------------------
*
* Events are sent via a shared page allocated by the front and propagated by
* evt-event-channel/evt-ring-ref XenStore entries.
*
* All event packets have the same length (64 octets).
* All event packets have common header:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id | type | reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
*
* id - uint16_t, event id, may be used by front.
* type - uint8_t, type of the event.
*
*
* Frame captured event - event from back to front when a new captured
* frame is available:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_EVT_FRAME_AVAIL| reserved | 4
* +----------------+----------------+----------------+----------------+
* | reserved | 8
* +----------------+----------------+----------------+----------------+
* | index | reserved | 12
* +----------------+----------------+----------------+----------------+
* | used_sz | 16
* +----------------+----------------+----------------+----------------+
* | seq_num | 20
* +----------------+----------------+----------------+----------------+
* | reserved | 24
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* index - uint8_t, index of the buffer that contains new captured frame,
* see XENCAMERA_OP_BUF_CREATE description on the range
* used_sz - uint32_t, number of octets this frame has. This can be less
* than the XENCAMERA_OP_BUF_REQUEST.size (response) for compressed formats.
* seq_num - uint32_t, sequential number of the frame. Must be
* monotonically increasing. If skips are detected in seq_num then that
* means that the frames in-between were dropped. Note however that not
* all video capture hardware is capable of detecting dropped frames.
* In that case there will be no skips in the sequence counter.
*/
struct xencamera_frame_avail_evt {
uint8_t index;
uint8_t reserved[3];
uint32_t used_sz;
uint32_t seq_num;
};
/*
* Control change event- event from back to front when camera control
* has changed:
* 0 1 2 3 octet
* +----------------+----------------+----------------+----------------+
* | id |_EVT_CTRL_CHANGE| reserved | 4
* +----------------+----------------+----------------+----------------+
* | type | reserved | 8
* +----------------+----------------+----------------+----------------+
* | reserved | 12
* +----------------+----------------+----------------+----------------+
* | reserved | 16
* +----------------+----------------+----------------+----------------+
* | value low 32-bit | 20
* +----------------+----------------+----------------+----------------+
* | value high 32-bit | 24
* +----------------+----------------+----------------+----------------+
* | reserved | 28
* +----------------+----------------+----------------+----------------+
* |/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/|
* +----------------+----------------+----------------+----------------+
* | reserved | 64
* +----------------+----------------+----------------+----------------+
*
* type - uint8_t, type of the control, one of the XENCAMERA_CTRL_XXX.
* value - int64_t, new value of the control.
*
* Notes:
* - this event is not sent for write-only controls
* - this event is not sent to the originator of the control change
* - this event is not sent when frontend first connects, e.g. initial
* control state must be explicitly queried
*/
struct xencamera_req {
uint16_t id;
uint8_t operation;
uint8_t reserved[5];
union {
struct xencamera_config_req config;
struct xencamera_frame_rate_req frame_rate;
struct xencamera_buf_request buf_request;
struct xencamera_buf_create_req buf_create;
struct xencamera_index index;
struct xencamera_ctrl_value ctrl_value;
struct xencamera_get_ctrl_req get_ctrl;
uint8_t reserved[56];
} req;
};
struct xencamera_resp {
uint16_t id;
uint8_t operation;
uint8_t reserved;
int32_t status;
union {
struct xencamera_config_resp config;
struct xencamera_buf_get_layout_resp buf_layout;
struct xencamera_buf_request buf_request;
struct xencamera_ctrl_enum_resp ctrl_enum;
struct xencamera_ctrl_value ctrl_value;
uint8_t reserved1[56];
} resp;
};
struct xencamera_evt {
uint16_t id;
uint8_t type;
uint8_t reserved[5];
union {
struct xencamera_frame_avail_evt frame_avail;
struct xencamera_ctrl_value ctrl_value;
uint8_t reserved[56];
} evt;
};
DEFINE_RING_TYPES(xen_cameraif, struct xencamera_req, struct xencamera_resp);
/*
******************************************************************************
* Back to front events delivery
******************************************************************************
* In order to deliver asynchronous events from back to front a shared page is
* allocated by front and its granted reference propagated to back via
* XenStore entries (evt-ring-ref/evt-event-channel).
* This page has a common header used by both front and back to synchronize
* access and control event's ring buffer, while back being a producer of the
* events and front being a consumer. The rest of the page after the header
* is used for event packets.
*
* Upon reception of an event(s) front may confirm its reception
* for either each event, group of events or none.
*/
struct xencamera_event_page {
uint32_t in_cons;
uint32_t in_prod;
uint8_t reserved[56];
};
#define XENCAMERA_EVENT_PAGE_SIZE 4096
#define XENCAMERA_IN_RING_OFFS (sizeof(struct xencamera_event_page))
#define XENCAMERA_IN_RING_SIZE (XENCAMERA_EVENT_PAGE_SIZE - XENCAMERA_IN_RING_OFFS)
#define XENCAMERA_IN_RING_LEN (XENCAMERA_IN_RING_SIZE / sizeof(struct xencamera_evt))
#define XENCAMERA_IN_RING(page) \
((struct xencamera_evt *)((char *)(page) + XENCAMERA_IN_RING_OFFS))
#define XENCAMERA_IN_RING_REF(page, idx) \
(XENCAMERA_IN_RING((page))[(idx) % XENCAMERA_IN_RING_LEN])
#endif /* __XEN_PUBLIC_IO_CAMERAIF_H__ */
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/