// Copyright 2018 The Android Open Source Project
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
syntax = "proto2";
|
|
package android.vts;
|
option java_package = "com.android.vts.proto";
|
option java_outer_classname = "VtsResourceControllerMessage";
|
|
import "test/vts/proto/ComponentSpecificationMessage.proto";
|
|
// Possible operations on Fast Message Queue.
|
enum FmqOp {
|
// Unknown operation.
|
FMQ_UNKNOWN = 0;
|
// Create a new FMQ object.
|
FMQ_CREATE = 1;
|
// Read from a FMQ (no blocking).
|
FMQ_READ = 2;
|
// Read from a FMQ (with short-form blocking).
|
FMQ_READ_BLOCKING = 3;
|
// Read from a FMQ (with long-form blocking).
|
// TODO: support this from host side in the future
|
FMQ_READ_BLOCKING_LONG = 4;
|
// Write to a FMQ (no blocking).
|
FMQ_WRITE = 5;
|
// Write to a FMQ (with short-form blocking).
|
FMQ_WRITE_BLOCKING = 6;
|
// Write to a FMQ (with long-form blocking).
|
// TODO: support this from host side in the future
|
FMQ_WRITE_BLOCKING_LONG = 7;
|
// Get space available to write in FMQ.
|
FMQ_AVAILABLE_WRITE = 8;
|
// Get number of items available to read.
|
FMQ_AVAILABLE_READ = 9;
|
// Get size of item in FMQ.
|
FMQ_GET_QUANTUM_SIZE = 10;
|
// Get number of items that fit in FMQ.
|
FMQ_GET_QUANTUM_COUNT = 11;
|
// Check if FMQ is valid.
|
FMQ_IS_VALID = 12;
|
// Get address of queue descriptor.
|
// This is an operation that is used in the target-side
|
// drivers to pass queue descriptor address to identify
|
// the FMQ. It is not for communication between host and
|
// target.
|
FMQ_GET_DESC_ADDR = 13;
|
}
|
|
// Possible operations on hidl_memory.
|
enum HidlMemoryOp {
|
// Unknown operation.
|
MEM_PROTO_UNKNOWN = 0;
|
// Allcate a new memory region.
|
MEM_PROTO_ALLOCATE = 1;
|
// Signal starting to read memory.
|
MEM_PROTO_START_READ = 2;
|
// Signal starting to read a particular region of memory.
|
MEM_PROTO_START_READ_RANGE = 3;
|
// Perform actual read operation.
|
MEM_PROTO_READ_BYTES = 4;
|
// Signal starting to write to memory.
|
MEM_PROTO_START_UPDATE = 5;
|
// Signal starting to write to a particular region of memory.
|
MEM_PROTO_START_UPDATE_RANGE = 6;
|
// Perform actual write operation.
|
MEM_PROTO_UPDATE_BYTES = 7;
|
// Commit to a read/write operation.
|
MEM_PROTO_COMMIT = 8;
|
// Get the size of memory region.
|
MEM_PROTO_GET_SIZE = 9;
|
}
|
|
// Possible operations on hidl_handle.
|
enum HidlHandleOp {
|
// Unknown operation.
|
HANDLE_PROTO_UNKNOWN = 0;
|
// Create a handle object for a single file.
|
HANDLE_PROTO_CREATE_FILE = 1;
|
// Read from a handle object with one file.
|
HANDLE_PROTO_READ_FILE = 2;
|
// Write to a handle object with one file.
|
HANDLE_PROTO_WRITE_FILE = 3;
|
// Delete a handle object.
|
HANDLE_PROTO_DELETE = 4;
|
}
|
|
// The arguments for a FMQ operation.
|
message FmqRequestMessage {
|
// operation to be performed
|
optional FmqOp operation = 1;
|
|
// string to represent type of data in the queue
|
// TODO: support user-defined types
|
optional bytes data_type = 2;
|
// queue flavor
|
optional bool sync = 3;
|
|
// queue id
|
optional int32 queue_id = 4 [default = -1];
|
|
// queue size
|
optional uint64 queue_size = 5;
|
// whether to enable blocking
|
optional bool blocking = 6;
|
// whether to reset read/write pointers
|
optional bool reset_pointers = 7;
|
|
// data to be written
|
repeated VariableSpecificationMessage write_data = 8;
|
// length of data to be read
|
optional uint64 read_data_size = 9;
|
// wait time when blocking
|
optional int64 time_out_nanos = 10;
|
|
// store address of queue descriptor
|
// This is a field that is used by internal drivers
|
// to identify a FMQ.
|
// It is not used for communication between host and target.
|
optional uint64 queue_desc_addr = 11;
|
}
|
|
// The response for a FMQ operation,
|
// including scalar values and data read back from the queue.
|
message FmqResponseMessage {
|
// data read from the queue
|
repeated VariableSpecificationMessage read_data = 1;
|
|
// three possible return types from FMQ
|
// basic util function return values
|
optional uint64 sizet_return_val = 2;
|
// function that returns a queue id
|
optional int32 queue_id = 3;
|
// signal if the operation succeeds on target side
|
optional bool success = 4;
|
}
|
|
// The arguments for a hidl_memory operation.
|
message HidlMemoryRequestMessage {
|
// operation to be performed
|
optional HidlMemoryOp operation = 1;
|
// id to identify memory region
|
optional int32 mem_id = 2 [default = -1];
|
// requested memory size
|
optional uint64 mem_size = 3;
|
// offset from the start of memory region
|
optional uint64 start = 4;
|
// length of memory to be modified
|
optional uint64 length = 5;
|
// data to be written into memory
|
optional bytes write_data = 6;
|
}
|
|
// The response for a hidl_memory operation.
|
message HidlMemoryResponseMessage {
|
// indicate if the memory region is found
|
optional bool success = 1;
|
// new id assigned to the new memory region
|
optional int32 new_mem_id = 2;
|
// result returned by GetSize() method on the memory region
|
optional uint64 mem_size = 3;
|
// data read from memory
|
optional bytes read_data = 4;
|
}
|
|
// The arguments for a hidl_handle operation.
|
message HidlHandleRequestMessage {
|
// operation to be performed
|
optional HidlHandleOp operation = 1;
|
// identifies the handle object
|
optional int32 handle_id = 2 [default = -1];
|
// to specify what files to open, and additional integers
|
// in a handle object
|
optional HandleDataValueMessage handle_info = 3;
|
// number of bytes to read from the file
|
// read() function in C I/O takes in a size_t,
|
// so use unsigned integer here.
|
optional uint64 read_data_size = 4;
|
// data to be written into file
|
optional bytes write_data = 5;
|
}
|
|
// The response for a hidl_handle operation.
|
message HidlHandleResponseMessage {
|
// indicate if the operation succeeds
|
optional bool success = 1;
|
// new id assigned to the new handle object
|
optional int32 new_handle_id = 2;
|
// data read from the file
|
optional bytes read_data = 3;
|
// number of bytes written into the file if the request is a write operation
|
// write() function in C I/O returns a ssize_t,
|
// so use signed integer here.
|
optional int64 write_data_size = 4;
|
}
|
