| /* |
| * Copyright (C) 2016 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. |
| */ |
| |
| package android.hardware.contexthub@1.0; |
| |
| enum Result : uint32_t { |
| OK, // Success |
| UNKNOWN_FAILURE, // Failure, unknown reason |
| BAD_PARAMS, // Parameters not sane |
| NOT_INIT, // Not initialized |
| TRANSACTION_FAILED, // Transaction failed |
| TRANSACTION_PENDING, // Pending transaction, cannot accept a new request |
| }; |
| |
| enum NanoAppFlags : uint32_t { |
| SIGNED = 1 << 0, |
| ENCRYPTED = 1 << 1, |
| }; |
| |
| struct NanoAppBinary { |
| uint64_t appId; // Nanoapp identifier |
| uint32_t appVersion; // Version of the app (semantics defined by app) |
| bitfield<NanoAppFlags> flags; |
| |
| // The version of the CHRE API that this nanoApp was compiled against. See |
| // the CHRE API header file chre/version.h for more information. The hub |
| // implementation must use this to confirm compatibility before loading |
| // this nanoApp. |
| uint8_t targetChreApiMajorVersion; |
| uint8_t targetChreApiMinorVersion; |
| |
| // Implementation-specific binary nanoapp data. This does not include the |
| // common nanoapp header that contains the app ID, etc., as this data is |
| // explicitly passed through the other fields in this struct. |
| vec<uint8_t> customBinary; |
| }; |
| |
| enum SensorType : uint32_t { |
| RESERVED, |
| ACCELEROMETER, |
| GYROSCOPE, |
| MAGNETOMETER, |
| BAROMETER, |
| PROXIMITY_SENSOR, |
| AMBIENT_LIGHT_SENSOR, |
| STATIONARY_DETECT, |
| INSTANT_MOTION_DETECT, |
| |
| GPS = 0x100, |
| // Reserving this space for variants on GPS |
| |
| WIFI = 0x200, |
| // Reserving this space for variants on WIFI |
| |
| AUDIO = 0x300, |
| // Reserving this space for variants on Audio |
| |
| CAMERA = 0x400, |
| // Reserving this space for variants on Camera |
| |
| BLE = 0x500, |
| // Reserving this space for variants on Bluetooth Low Energy |
| |
| WWAN = 0x600, |
| // Reserving this space for variants on WWAN |
| |
| PRIVATE_SENSOR_BASE = 0x10000, |
| // Sensor types beyond PRIVATE_SENSOR_BASE are custom types |
| }; |
| |
| struct PhysicalSensor{ |
| SensorType sensorType; // From the definitions above eg: 100 |
| string type; // Type as a string. eg: "GPS" |
| string name; // Identifier eg: "Bosch BMI160" |
| string vendor; // Vendor : eg "STM" |
| uint32_t version; // Version : eg 0x1001 |
| uint32_t fifoReservedCount; // Batching possible in hardware. Please |
| // note that here hardware does not include |
| // the context hub itself. Thus, this |
| // definition may be different from say the |
| // number advertised in the sensors HAL |
| // which allows for batching in a hub. |
| uint32_t fifoMaxCount; // Maximum number of batchable events. |
| uint64_t minDelayMs; // In milliseconds, corresponding to highest |
| // sampling freq. |
| uint64_t maxDelayMs; // In milliseconds, corresponds to minimum |
| // sampling frequency |
| float peakPowerMw; // At max frequency & no batching, power |
| // in milliwatts |
| }; |
| |
| struct ContextHub { |
| string name; // Descriptive name eg: "Awesome Hub #1" |
| string vendor; // Hub hardware vendor eg: "Qualcomm" |
| string toolchain; // Toolchain to make binaries eg: "gcc ARM" |
| uint32_t platformVersion; // Version of the hardware : eg 0x20 |
| uint32_t toolchainVersion; // Version of the toolchain : eg: 0x484 |
| uint32_t hubId; // A device unique ID for this hub |
| |
| float peakMips; // Peak MIPS platform can deliver |
| float stoppedPowerDrawMw; // If stopped, retention power, milliwatts |
| float sleepPowerDrawMw; // If sleeping, retention power, milliwatts |
| float peakPowerDrawMw; // For a busy CPU, power in milliwatts |
| |
| vec<PhysicalSensor> connectedSensors; // Array of connected sensors |
| |
| uint32_t maxSupportedMsgLen;// This is the maximum size of the message that can |
| // be sent to the hub in one chunk (in bytes) |
| |
| // Machine-readable CHRE platform ID, returned to nanoapps in the CHRE API |
| // function call chreGetPlatformId(). This field pairs with |
| // chreApiMajorVersion, chreApiMinorVersion, and chrePatchVersion to fully |
| // specify the CHRE implementation version. See also the CHRE API header |
| // file chre/version.h. |
| uint64_t chrePlatformId; |
| |
| // The version of the CHRE implementation returned to nanoApps in the CHRE |
| // API function call chreGetVersion(). The major and minor version specify |
| // the implemented version of the CHRE API, while the patch version |
| // describes the implementation version within the scope of the platform |
| // ID. See also the CHRE API header file chre/version.h. |
| uint8_t chreApiMajorVersion; |
| uint8_t chreApiMinorVersion; |
| uint16_t chrePatchVersion; |
| }; |
| |
| enum HostEndPoint : uint16_t { |
| BROADCAST = 0xFFFF, // The message endpoint is a broadcast end point. |
| // This value must never be used for a message from |
| // the host to the hub. |
| // If BROADCAST is specified as a destination for a |
| // message from the context hub to the ContextHub |
| // service, the message must be broadcast to all |
| // registered clients by the Context Hub service. |
| UNSPECIFIED = 0xFFFE, // The message endpoint is unspecified. This value |
| // must not be used for messages from the hub to host. |
| // This value may be used for messages from the host |
| // to the hub. |
| }; |
| |
| struct ContextHubMsg { |
| uint64_t appName; // Intended recipient (appId) |
| uint16_t hostEndPoint; // identifier for the endpoint. (also see enum HostEndPoint) |
| uint32_t msgType; // Identifier for message |
| vec<uint8_t> msg; // Message body |
| }; |
| |
| enum HubMemoryType : uint32_t { |
| MAIN = 0, // Main memory |
| SECONDARY = 1, // Secondary memory |
| TCM = 2, // Tightly coupled memory |
| }; |
| |
| enum HubMemoryFlag : uint32_t { |
| READ = 1 << 0, // Readable |
| WRITE = 1 << 1, // Writable |
| EXEC = 1 << 2, // Executable |
| }; |
| |
| struct MemRange { |
| uint32_t totalBytes; // Total capacity in bytes |
| uint32_t freeBytes; // Free capacity in bytes |
| HubMemoryType type; // Type of memory, see HubMemoryType |
| bitfield<HubMemoryFlag> flags; |
| }; |
| |
| enum AsyncEventType : uint32_t { |
| RESTARTED = 1, // Hub restarted unexpectedly |
| }; |
| |
| enum TransactionResult : int32_t { |
| SUCCESS, // Successful completion of transaction |
| FAILURE, // Failed transaction |
| }; |
| |
| struct HubAppInfo { |
| uint64_t appId; // Identifier of the app |
| uint32_t version; // Version of the app |
| vec<MemRange> memUsage; // Memory used by this app |
| bool enabled; // true if the app is currently enabled and running, |
| // or false if in the loaded but disabled state |
| }; |
| |