Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */
0002 /*
0003  * Copyright(c) 2014 - 2015 Google Inc. All rights reserved.
0004  * Copyright(c) 2014 - 2015 Linaro Ltd. All rights reserved.
0005  */
0006 
0007 #ifndef __GREYBUS_PROTOCOLS_H
0008 #define __GREYBUS_PROTOCOLS_H
0009 
0010 #include <linux/types.h>
0011 
0012 /* Fixed IDs for control/svc protocols */
0013 
0014 /* SVC switch-port device ids */
0015 #define GB_SVC_DEVICE_ID_SVC            0
0016 #define GB_SVC_DEVICE_ID_AP         1
0017 #define GB_SVC_DEVICE_ID_MIN            2
0018 #define GB_SVC_DEVICE_ID_MAX            31
0019 
0020 #define GB_SVC_CPORT_ID             0
0021 #define GB_CONTROL_BUNDLE_ID            0
0022 #define GB_CONTROL_CPORT_ID         0
0023 
0024 
0025 /*
0026  * All operation messages (both requests and responses) begin with
0027  * a header that encodes the size of the message (header included).
0028  * This header also contains a unique identifier, that associates a
0029  * response message with its operation.  The header contains an
0030  * operation type field, whose interpretation is dependent on what
0031  * type of protocol is used over the connection.  The high bit
0032  * (0x80) of the operation type field is used to indicate whether
0033  * the message is a request (clear) or a response (set).
0034  *
0035  * Response messages include an additional result byte, which
0036  * communicates the result of the corresponding request.  A zero
0037  * result value means the operation completed successfully.  Any
0038  * other value indicates an error; in this case, the payload of the
0039  * response message (if any) is ignored.  The result byte must be
0040  * zero in the header for a request message.
0041  *
0042  * The wire format for all numeric fields in the header is little
0043  * endian.  Any operation-specific data begins immediately after the
0044  * header.
0045  */
0046 struct gb_operation_msg_hdr {
0047     __le16  size;       /* Size in bytes of header + payload */
0048     __le16  operation_id;   /* Operation unique id */
0049     __u8    type;       /* E.g GB_I2C_TYPE_* or GB_GPIO_TYPE_* */
0050     __u8    result;     /* Result of request (in responses only) */
0051     __u8    pad[2];     /* must be zero (ignore when read) */
0052 } __packed;
0053 
0054 
0055 /* Generic request types */
0056 #define GB_REQUEST_TYPE_CPORT_SHUTDOWN      0x00
0057 #define GB_REQUEST_TYPE_INVALID         0x7f
0058 
0059 struct gb_cport_shutdown_request {
0060     __u8 phase;
0061 } __packed;
0062 
0063 
0064 /* Control Protocol */
0065 
0066 /* Greybus control request types */
0067 #define GB_CONTROL_TYPE_VERSION         0x01
0068 #define GB_CONTROL_TYPE_PROBE_AP        0x02
0069 #define GB_CONTROL_TYPE_GET_MANIFEST_SIZE   0x03
0070 #define GB_CONTROL_TYPE_GET_MANIFEST        0x04
0071 #define GB_CONTROL_TYPE_CONNECTED       0x05
0072 #define GB_CONTROL_TYPE_DISCONNECTED        0x06
0073 #define GB_CONTROL_TYPE_TIMESYNC_ENABLE     0x07
0074 #define GB_CONTROL_TYPE_TIMESYNC_DISABLE    0x08
0075 #define GB_CONTROL_TYPE_TIMESYNC_AUTHORITATIVE  0x09
0076 /*  Unused                  0x0a */
0077 #define GB_CONTROL_TYPE_BUNDLE_VERSION      0x0b
0078 #define GB_CONTROL_TYPE_DISCONNECTING       0x0c
0079 #define GB_CONTROL_TYPE_TIMESYNC_GET_LAST_EVENT 0x0d
0080 #define GB_CONTROL_TYPE_MODE_SWITCH     0x0e
0081 #define GB_CONTROL_TYPE_BUNDLE_SUSPEND      0x0f
0082 #define GB_CONTROL_TYPE_BUNDLE_RESUME       0x10
0083 #define GB_CONTROL_TYPE_BUNDLE_DEACTIVATE   0x11
0084 #define GB_CONTROL_TYPE_BUNDLE_ACTIVATE     0x12
0085 #define GB_CONTROL_TYPE_INTF_SUSPEND_PREPARE        0x13
0086 #define GB_CONTROL_TYPE_INTF_DEACTIVATE_PREPARE 0x14
0087 #define GB_CONTROL_TYPE_INTF_HIBERNATE_ABORT    0x15
0088 
0089 struct gb_control_version_request {
0090     __u8    major;
0091     __u8    minor;
0092 } __packed;
0093 
0094 struct gb_control_version_response {
0095     __u8    major;
0096     __u8    minor;
0097 } __packed;
0098 
0099 struct gb_control_bundle_version_request {
0100     __u8    bundle_id;
0101 } __packed;
0102 
0103 struct gb_control_bundle_version_response {
0104     __u8    major;
0105     __u8    minor;
0106 } __packed;
0107 
0108 /* Control protocol manifest get size request has no payload*/
0109 struct gb_control_get_manifest_size_response {
0110     __le16          size;
0111 } __packed;
0112 
0113 /* Control protocol manifest get request has no payload */
0114 struct gb_control_get_manifest_response {
0115     __u8            data[0];
0116 } __packed;
0117 
0118 /* Control protocol [dis]connected request */
0119 struct gb_control_connected_request {
0120     __le16          cport_id;
0121 } __packed;
0122 
0123 struct gb_control_disconnecting_request {
0124     __le16          cport_id;
0125 } __packed;
0126 /* disconnecting response has no payload */
0127 
0128 struct gb_control_disconnected_request {
0129     __le16          cport_id;
0130 } __packed;
0131 /* Control protocol [dis]connected response has no payload */
0132 
0133 /*
0134  * All Bundle power management operations use the same request and response
0135  * layout and status codes.
0136  */
0137 
0138 #define GB_CONTROL_BUNDLE_PM_OK     0x00
0139 #define GB_CONTROL_BUNDLE_PM_INVAL  0x01
0140 #define GB_CONTROL_BUNDLE_PM_BUSY   0x02
0141 #define GB_CONTROL_BUNDLE_PM_FAIL   0x03
0142 #define GB_CONTROL_BUNDLE_PM_NA     0x04
0143 
0144 struct gb_control_bundle_pm_request {
0145     __u8    bundle_id;
0146 } __packed;
0147 
0148 struct gb_control_bundle_pm_response {
0149     __u8    status;
0150 } __packed;
0151 
0152 /*
0153  * Interface Suspend Prepare and Deactivate Prepare operations use the same
0154  * response layout and error codes. Define a single response structure and reuse
0155  * it. Both operations have no payload.
0156  */
0157 
0158 #define GB_CONTROL_INTF_PM_OK       0x00
0159 #define GB_CONTROL_INTF_PM_BUSY     0x01
0160 #define GB_CONTROL_INTF_PM_NA       0x02
0161 
0162 struct gb_control_intf_pm_response {
0163     __u8    status;
0164 } __packed;
0165 
0166 /* APBridge protocol */
0167 
0168 /* request APB1 log */
0169 #define GB_APB_REQUEST_LOG          0x02
0170 
0171 /* request to map a cport to bulk in and bulk out endpoints */
0172 #define GB_APB_REQUEST_EP_MAPPING       0x03
0173 
0174 /* request to get the number of cports available */
0175 #define GB_APB_REQUEST_CPORT_COUNT      0x04
0176 
0177 /* request to reset a cport state */
0178 #define GB_APB_REQUEST_RESET_CPORT      0x05
0179 
0180 /* request to time the latency of messages on a given cport */
0181 #define GB_APB_REQUEST_LATENCY_TAG_EN       0x06
0182 #define GB_APB_REQUEST_LATENCY_TAG_DIS      0x07
0183 
0184 /* request to control the CSI transmitter */
0185 #define GB_APB_REQUEST_CSI_TX_CONTROL       0x08
0186 
0187 /* request to control audio streaming */
0188 #define GB_APB_REQUEST_AUDIO_CONTROL        0x09
0189 
0190 /* TimeSync requests */
0191 #define GB_APB_REQUEST_TIMESYNC_ENABLE      0x0d
0192 #define GB_APB_REQUEST_TIMESYNC_DISABLE     0x0e
0193 #define GB_APB_REQUEST_TIMESYNC_AUTHORITATIVE   0x0f
0194 #define GB_APB_REQUEST_TIMESYNC_GET_LAST_EVENT  0x10
0195 
0196 /* requests to set Greybus CPort flags */
0197 #define GB_APB_REQUEST_CPORT_FLAGS      0x11
0198 
0199 /* ARPC request */
0200 #define GB_APB_REQUEST_ARPC_RUN         0x12
0201 
0202 struct gb_apb_request_cport_flags {
0203     __le32  flags;
0204 #define GB_APB_CPORT_FLAG_CONTROL       0x01
0205 #define GB_APB_CPORT_FLAG_HIGH_PRIO     0x02
0206 } __packed;
0207 
0208 
0209 /* Firmware Download Protocol */
0210 
0211 /* Request Types */
0212 #define GB_FW_DOWNLOAD_TYPE_FIND_FIRMWARE   0x01
0213 #define GB_FW_DOWNLOAD_TYPE_FETCH_FIRMWARE  0x02
0214 #define GB_FW_DOWNLOAD_TYPE_RELEASE_FIRMWARE    0x03
0215 
0216 #define GB_FIRMWARE_TAG_MAX_SIZE        10
0217 
0218 /* firmware download find firmware request/response */
0219 struct gb_fw_download_find_firmware_request {
0220     __u8            firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE];
0221 } __packed;
0222 
0223 struct gb_fw_download_find_firmware_response {
0224     __u8            firmware_id;
0225     __le32          size;
0226 } __packed;
0227 
0228 /* firmware download fetch firmware request/response */
0229 struct gb_fw_download_fetch_firmware_request {
0230     __u8            firmware_id;
0231     __le32          offset;
0232     __le32          size;
0233 } __packed;
0234 
0235 struct gb_fw_download_fetch_firmware_response {
0236     __u8            data[0];
0237 } __packed;
0238 
0239 /* firmware download release firmware request */
0240 struct gb_fw_download_release_firmware_request {
0241     __u8            firmware_id;
0242 } __packed;
0243 /* firmware download release firmware response has no payload */
0244 
0245 
0246 /* Firmware Management Protocol */
0247 
0248 /* Request Types */
0249 #define GB_FW_MGMT_TYPE_INTERFACE_FW_VERSION    0x01
0250 #define GB_FW_MGMT_TYPE_LOAD_AND_VALIDATE_FW    0x02
0251 #define GB_FW_MGMT_TYPE_LOADED_FW       0x03
0252 #define GB_FW_MGMT_TYPE_BACKEND_FW_VERSION  0x04
0253 #define GB_FW_MGMT_TYPE_BACKEND_FW_UPDATE   0x05
0254 #define GB_FW_MGMT_TYPE_BACKEND_FW_UPDATED  0x06
0255 
0256 #define GB_FW_LOAD_METHOD_UNIPRO        0x01
0257 #define GB_FW_LOAD_METHOD_INTERNAL      0x02
0258 
0259 #define GB_FW_LOAD_STATUS_FAILED        0x00
0260 #define GB_FW_LOAD_STATUS_UNVALIDATED       0x01
0261 #define GB_FW_LOAD_STATUS_VALIDATED     0x02
0262 #define GB_FW_LOAD_STATUS_VALIDATION_FAILED 0x03
0263 
0264 #define GB_FW_BACKEND_FW_STATUS_SUCCESS     0x01
0265 #define GB_FW_BACKEND_FW_STATUS_FAIL_FIND   0x02
0266 #define GB_FW_BACKEND_FW_STATUS_FAIL_FETCH  0x03
0267 #define GB_FW_BACKEND_FW_STATUS_FAIL_WRITE  0x04
0268 #define GB_FW_BACKEND_FW_STATUS_INT     0x05
0269 #define GB_FW_BACKEND_FW_STATUS_RETRY       0x06
0270 #define GB_FW_BACKEND_FW_STATUS_NOT_SUPPORTED   0x07
0271 
0272 #define GB_FW_BACKEND_VERSION_STATUS_SUCCESS        0x01
0273 #define GB_FW_BACKEND_VERSION_STATUS_NOT_AVAILABLE  0x02
0274 #define GB_FW_BACKEND_VERSION_STATUS_NOT_SUPPORTED  0x03
0275 #define GB_FW_BACKEND_VERSION_STATUS_RETRY      0x04
0276 #define GB_FW_BACKEND_VERSION_STATUS_FAIL_INT       0x05
0277 
0278 /* firmware management interface firmware version request has no payload */
0279 struct gb_fw_mgmt_interface_fw_version_response {
0280     __u8            firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE];
0281     __le16          major;
0282     __le16          minor;
0283 } __packed;
0284 
0285 /* firmware management load and validate firmware request/response */
0286 struct gb_fw_mgmt_load_and_validate_fw_request {
0287     __u8            request_id;
0288     __u8            load_method;
0289     __u8            firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE];
0290 } __packed;
0291 /* firmware management load and validate firmware response has no payload*/
0292 
0293 /* firmware management loaded firmware request */
0294 struct gb_fw_mgmt_loaded_fw_request {
0295     __u8            request_id;
0296     __u8            status;
0297     __le16          major;
0298     __le16          minor;
0299 } __packed;
0300 /* firmware management loaded firmware response has no payload */
0301 
0302 /* firmware management backend firmware version request/response */
0303 struct gb_fw_mgmt_backend_fw_version_request {
0304     __u8            firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE];
0305 } __packed;
0306 
0307 struct gb_fw_mgmt_backend_fw_version_response {
0308     __le16          major;
0309     __le16          minor;
0310     __u8            status;
0311 } __packed;
0312 
0313 /* firmware management backend firmware update request */
0314 struct gb_fw_mgmt_backend_fw_update_request {
0315     __u8            request_id;
0316     __u8            firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE];
0317 } __packed;
0318 /* firmware management backend firmware update response has no payload */
0319 
0320 /* firmware management backend firmware updated request */
0321 struct gb_fw_mgmt_backend_fw_updated_request {
0322     __u8            request_id;
0323     __u8            status;
0324 } __packed;
0325 /* firmware management backend firmware updated response has no payload */
0326 
0327 
0328 /* Component Authentication Protocol (CAP) */
0329 
0330 /* Request Types */
0331 #define GB_CAP_TYPE_GET_ENDPOINT_UID    0x01
0332 #define GB_CAP_TYPE_GET_IMS_CERTIFICATE 0x02
0333 #define GB_CAP_TYPE_AUTHENTICATE    0x03
0334 
0335 /* CAP get endpoint uid request has no payload */
0336 struct gb_cap_get_endpoint_uid_response {
0337     __u8            uid[8];
0338 } __packed;
0339 
0340 /* CAP get endpoint ims certificate request/response */
0341 struct gb_cap_get_ims_certificate_request {
0342     __le32          certificate_class;
0343     __le32          certificate_id;
0344 } __packed;
0345 
0346 struct gb_cap_get_ims_certificate_response {
0347     __u8            result_code;
0348     __u8            certificate[];
0349 } __packed;
0350 
0351 /* CAP authenticate request/response */
0352 struct gb_cap_authenticate_request {
0353     __le32          auth_type;
0354     __u8            uid[8];
0355     __u8            challenge[32];
0356 } __packed;
0357 
0358 struct gb_cap_authenticate_response {
0359     __u8            result_code;
0360     __u8            response[64];
0361     __u8            signature[];
0362 } __packed;
0363 
0364 
0365 /* Bootrom Protocol */
0366 
0367 /* Version of the Greybus bootrom protocol we support */
0368 #define GB_BOOTROM_VERSION_MAJOR        0x00
0369 #define GB_BOOTROM_VERSION_MINOR        0x01
0370 
0371 /* Greybus bootrom request types */
0372 #define GB_BOOTROM_TYPE_VERSION         0x01
0373 #define GB_BOOTROM_TYPE_FIRMWARE_SIZE       0x02
0374 #define GB_BOOTROM_TYPE_GET_FIRMWARE        0x03
0375 #define GB_BOOTROM_TYPE_READY_TO_BOOT       0x04
0376 #define GB_BOOTROM_TYPE_AP_READY        0x05    /* Request with no-payload */
0377 #define GB_BOOTROM_TYPE_GET_VID_PID     0x06    /* Request with no-payload */
0378 
0379 /* Greybus bootrom boot stages */
0380 #define GB_BOOTROM_BOOT_STAGE_ONE       0x01 /* Reserved for the boot ROM */
0381 #define GB_BOOTROM_BOOT_STAGE_TWO       0x02 /* Bootrom package to be loaded by the boot ROM */
0382 #define GB_BOOTROM_BOOT_STAGE_THREE     0x03 /* Module personality package loaded by Stage 2 firmware */
0383 
0384 /* Greybus bootrom ready to boot status */
0385 #define GB_BOOTROM_BOOT_STATUS_INVALID      0x00 /* Firmware blob could not be validated */
0386 #define GB_BOOTROM_BOOT_STATUS_INSECURE     0x01 /* Firmware blob is valid but insecure */
0387 #define GB_BOOTROM_BOOT_STATUS_SECURE       0x02 /* Firmware blob is valid and secure */
0388 
0389 /* Max bootrom data fetch size in bytes */
0390 #define GB_BOOTROM_FETCH_MAX            2000
0391 
0392 struct gb_bootrom_version_request {
0393     __u8    major;
0394     __u8    minor;
0395 } __packed;
0396 
0397 struct gb_bootrom_version_response {
0398     __u8    major;
0399     __u8    minor;
0400 } __packed;
0401 
0402 /* Bootrom protocol firmware size request/response */
0403 struct gb_bootrom_firmware_size_request {
0404     __u8            stage;
0405 } __packed;
0406 
0407 struct gb_bootrom_firmware_size_response {
0408     __le32          size;
0409 } __packed;
0410 
0411 /* Bootrom protocol get firmware request/response */
0412 struct gb_bootrom_get_firmware_request {
0413     __le32          offset;
0414     __le32          size;
0415 } __packed;
0416 
0417 struct gb_bootrom_get_firmware_response {
0418     __u8            data[0];
0419 } __packed;
0420 
0421 /* Bootrom protocol Ready to boot request */
0422 struct gb_bootrom_ready_to_boot_request {
0423     __u8            status;
0424 } __packed;
0425 /* Bootrom protocol Ready to boot response has no payload */
0426 
0427 /* Bootrom protocol get VID/PID request has no payload */
0428 struct gb_bootrom_get_vid_pid_response {
0429     __le32          vendor_id;
0430     __le32          product_id;
0431 } __packed;
0432 
0433 
0434 /* Power Supply */
0435 
0436 /* Greybus power supply request types */
0437 #define GB_POWER_SUPPLY_TYPE_GET_SUPPLIES       0x02
0438 #define GB_POWER_SUPPLY_TYPE_GET_DESCRIPTION        0x03
0439 #define GB_POWER_SUPPLY_TYPE_GET_PROP_DESCRIPTORS   0x04
0440 #define GB_POWER_SUPPLY_TYPE_GET_PROPERTY       0x05
0441 #define GB_POWER_SUPPLY_TYPE_SET_PROPERTY       0x06
0442 #define GB_POWER_SUPPLY_TYPE_EVENT          0x07
0443 
0444 /* Greybus power supply battery technologies types */
0445 #define GB_POWER_SUPPLY_TECH_UNKNOWN            0x0000
0446 #define GB_POWER_SUPPLY_TECH_NiMH           0x0001
0447 #define GB_POWER_SUPPLY_TECH_LION           0x0002
0448 #define GB_POWER_SUPPLY_TECH_LIPO           0x0003
0449 #define GB_POWER_SUPPLY_TECH_LiFe           0x0004
0450 #define GB_POWER_SUPPLY_TECH_NiCd           0x0005
0451 #define GB_POWER_SUPPLY_TECH_LiMn           0x0006
0452 
0453 /* Greybus power supply types */
0454 #define GB_POWER_SUPPLY_UNKNOWN_TYPE            0x0000
0455 #define GB_POWER_SUPPLY_BATTERY_TYPE            0x0001
0456 #define GB_POWER_SUPPLY_UPS_TYPE            0x0002
0457 #define GB_POWER_SUPPLY_MAINS_TYPE          0x0003
0458 #define GB_POWER_SUPPLY_USB_TYPE            0x0004
0459 #define GB_POWER_SUPPLY_USB_DCP_TYPE            0x0005
0460 #define GB_POWER_SUPPLY_USB_CDP_TYPE            0x0006
0461 #define GB_POWER_SUPPLY_USB_ACA_TYPE            0x0007
0462 
0463 /* Greybus power supply health values */
0464 #define GB_POWER_SUPPLY_HEALTH_UNKNOWN          0x0000
0465 #define GB_POWER_SUPPLY_HEALTH_GOOD         0x0001
0466 #define GB_POWER_SUPPLY_HEALTH_OVERHEAT         0x0002
0467 #define GB_POWER_SUPPLY_HEALTH_DEAD         0x0003
0468 #define GB_POWER_SUPPLY_HEALTH_OVERVOLTAGE      0x0004
0469 #define GB_POWER_SUPPLY_HEALTH_UNSPEC_FAILURE       0x0005
0470 #define GB_POWER_SUPPLY_HEALTH_COLD         0x0006
0471 #define GB_POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE    0x0007
0472 #define GB_POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE  0x0008
0473 
0474 /* Greybus power supply status values */
0475 #define GB_POWER_SUPPLY_STATUS_UNKNOWN          0x0000
0476 #define GB_POWER_SUPPLY_STATUS_CHARGING         0x0001
0477 #define GB_POWER_SUPPLY_STATUS_DISCHARGING      0x0002
0478 #define GB_POWER_SUPPLY_STATUS_NOT_CHARGING     0x0003
0479 #define GB_POWER_SUPPLY_STATUS_FULL         0x0004
0480 
0481 /* Greybus power supply capacity level values */
0482 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN      0x0000
0483 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL     0x0001
0484 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_LOW      0x0002
0485 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_NORMAL       0x0003
0486 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_HIGH     0x0004
0487 #define GB_POWER_SUPPLY_CAPACITY_LEVEL_FULL     0x0005
0488 
0489 /* Greybus power supply scope values */
0490 #define GB_POWER_SUPPLY_SCOPE_UNKNOWN           0x0000
0491 #define GB_POWER_SUPPLY_SCOPE_SYSTEM            0x0001
0492 #define GB_POWER_SUPPLY_SCOPE_DEVICE            0x0002
0493 
0494 struct gb_power_supply_get_supplies_response {
0495     __u8    supplies_count;
0496 } __packed;
0497 
0498 struct gb_power_supply_get_description_request {
0499     __u8    psy_id;
0500 } __packed;
0501 
0502 struct gb_power_supply_get_description_response {
0503     __u8    manufacturer[32];
0504     __u8    model[32];
0505     __u8    serial_number[32];
0506     __le16  type;
0507     __u8    properties_count;
0508 } __packed;
0509 
0510 struct gb_power_supply_props_desc {
0511     __u8    property;
0512 #define GB_POWER_SUPPLY_PROP_STATUS             0x00
0513 #define GB_POWER_SUPPLY_PROP_CHARGE_TYPE            0x01
0514 #define GB_POWER_SUPPLY_PROP_HEALTH             0x02
0515 #define GB_POWER_SUPPLY_PROP_PRESENT                0x03
0516 #define GB_POWER_SUPPLY_PROP_ONLINE             0x04
0517 #define GB_POWER_SUPPLY_PROP_AUTHENTIC              0x05
0518 #define GB_POWER_SUPPLY_PROP_TECHNOLOGY             0x06
0519 #define GB_POWER_SUPPLY_PROP_CYCLE_COUNT            0x07
0520 #define GB_POWER_SUPPLY_PROP_VOLTAGE_MAX            0x08
0521 #define GB_POWER_SUPPLY_PROP_VOLTAGE_MIN            0x09
0522 #define GB_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN         0x0A
0523 #define GB_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN         0x0B
0524 #define GB_POWER_SUPPLY_PROP_VOLTAGE_NOW            0x0C
0525 #define GB_POWER_SUPPLY_PROP_VOLTAGE_AVG            0x0D
0526 #define GB_POWER_SUPPLY_PROP_VOLTAGE_OCV            0x0E
0527 #define GB_POWER_SUPPLY_PROP_VOLTAGE_BOOT           0x0F
0528 #define GB_POWER_SUPPLY_PROP_CURRENT_MAX            0x10
0529 #define GB_POWER_SUPPLY_PROP_CURRENT_NOW            0x11
0530 #define GB_POWER_SUPPLY_PROP_CURRENT_AVG            0x12
0531 #define GB_POWER_SUPPLY_PROP_CURRENT_BOOT           0x13
0532 #define GB_POWER_SUPPLY_PROP_POWER_NOW              0x14
0533 #define GB_POWER_SUPPLY_PROP_POWER_AVG              0x15
0534 #define GB_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN         0x16
0535 #define GB_POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN        0x17
0536 #define GB_POWER_SUPPLY_PROP_CHARGE_FULL            0x18
0537 #define GB_POWER_SUPPLY_PROP_CHARGE_EMPTY           0x19
0538 #define GB_POWER_SUPPLY_PROP_CHARGE_NOW             0x1A
0539 #define GB_POWER_SUPPLY_PROP_CHARGE_AVG             0x1B
0540 #define GB_POWER_SUPPLY_PROP_CHARGE_COUNTER         0x1C
0541 #define GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT        0x1D
0542 #define GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX    0x1E
0543 #define GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE        0x1F
0544 #define GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX    0x20
0545 #define GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT       0x21
0546 #define GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX       0x22
0547 #define GB_POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT        0x23
0548 #define GB_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN         0x24
0549 #define GB_POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN        0x25
0550 #define GB_POWER_SUPPLY_PROP_ENERGY_FULL            0x26
0551 #define GB_POWER_SUPPLY_PROP_ENERGY_EMPTY           0x27
0552 #define GB_POWER_SUPPLY_PROP_ENERGY_NOW             0x28
0553 #define GB_POWER_SUPPLY_PROP_ENERGY_AVG             0x29
0554 #define GB_POWER_SUPPLY_PROP_CAPACITY               0x2A
0555 #define GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN         0x2B
0556 #define GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX         0x2C
0557 #define GB_POWER_SUPPLY_PROP_CAPACITY_LEVEL         0x2D
0558 #define GB_POWER_SUPPLY_PROP_TEMP               0x2E
0559 #define GB_POWER_SUPPLY_PROP_TEMP_MAX               0x2F
0560 #define GB_POWER_SUPPLY_PROP_TEMP_MIN               0x30
0561 #define GB_POWER_SUPPLY_PROP_TEMP_ALERT_MIN         0x31
0562 #define GB_POWER_SUPPLY_PROP_TEMP_ALERT_MAX         0x32
0563 #define GB_POWER_SUPPLY_PROP_TEMP_AMBIENT           0x33
0564 #define GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN     0x34
0565 #define GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX     0x35
0566 #define GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW          0x36
0567 #define GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG          0x37
0568 #define GB_POWER_SUPPLY_PROP_TIME_TO_FULL_NOW           0x38
0569 #define GB_POWER_SUPPLY_PROP_TIME_TO_FULL_AVG           0x39
0570 #define GB_POWER_SUPPLY_PROP_TYPE               0x3A
0571 #define GB_POWER_SUPPLY_PROP_SCOPE              0x3B
0572 #define GB_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT        0x3C
0573 #define GB_POWER_SUPPLY_PROP_CALIBRATE              0x3D
0574     __u8    is_writeable;
0575 } __packed;
0576 
0577 struct gb_power_supply_get_property_descriptors_request {
0578     __u8    psy_id;
0579 } __packed;
0580 
0581 struct gb_power_supply_get_property_descriptors_response {
0582     __u8    properties_count;
0583     struct gb_power_supply_props_desc props[];
0584 } __packed;
0585 
0586 struct gb_power_supply_get_property_request {
0587     __u8    psy_id;
0588     __u8    property;
0589 } __packed;
0590 
0591 struct gb_power_supply_get_property_response {
0592     __le32  prop_val;
0593 };
0594 
0595 struct gb_power_supply_set_property_request {
0596     __u8    psy_id;
0597     __u8    property;
0598     __le32  prop_val;
0599 } __packed;
0600 
0601 struct gb_power_supply_event_request {
0602     __u8    psy_id;
0603     __u8    event;
0604 #define GB_POWER_SUPPLY_UPDATE      0x01
0605 } __packed;
0606 
0607 
0608 /* HID */
0609 
0610 /* Greybus HID operation types */
0611 #define GB_HID_TYPE_GET_DESC        0x02
0612 #define GB_HID_TYPE_GET_REPORT_DESC 0x03
0613 #define GB_HID_TYPE_PWR_ON      0x04
0614 #define GB_HID_TYPE_PWR_OFF     0x05
0615 #define GB_HID_TYPE_GET_REPORT      0x06
0616 #define GB_HID_TYPE_SET_REPORT      0x07
0617 #define GB_HID_TYPE_IRQ_EVENT       0x08
0618 
0619 /* Report type */
0620 #define GB_HID_INPUT_REPORT     0
0621 #define GB_HID_OUTPUT_REPORT        1
0622 #define GB_HID_FEATURE_REPORT       2
0623 
0624 /* Different request/response structures */
0625 /* HID get descriptor response */
0626 struct gb_hid_desc_response {
0627     __u8                bLength;
0628     __le16              wReportDescLength;
0629     __le16              bcdHID;
0630     __le16              wProductID;
0631     __le16              wVendorID;
0632     __u8                bCountryCode;
0633 } __packed;
0634 
0635 /* HID get report request/response */
0636 struct gb_hid_get_report_request {
0637     __u8                report_type;
0638     __u8                report_id;
0639 } __packed;
0640 
0641 /* HID set report request */
0642 struct gb_hid_set_report_request {
0643     __u8                report_type;
0644     __u8                report_id;
0645     __u8                report[];
0646 } __packed;
0647 
0648 /* HID input report request, via interrupt pipe */
0649 struct gb_hid_input_report_request {
0650     __u8                report[0];
0651 } __packed;
0652 
0653 
0654 /* I2C */
0655 
0656 /* Greybus i2c request types */
0657 #define GB_I2C_TYPE_FUNCTIONALITY   0x02
0658 #define GB_I2C_TYPE_TRANSFER        0x05
0659 
0660 /* functionality request has no payload */
0661 struct gb_i2c_functionality_response {
0662     __le32  functionality;
0663 } __packed;
0664 
0665 /*
0666  * Outgoing data immediately follows the op count and ops array.
0667  * The data for each write (master -> slave) op in the array is sent
0668  * in order, with no (e.g. pad) bytes separating them.
0669  *
0670  * Short reads cause the entire transfer request to fail So response
0671  * payload consists only of bytes read, and the number of bytes is
0672  * exactly what was specified in the corresponding op.  Like
0673  * outgoing data, the incoming data is in order and contiguous.
0674  */
0675 struct gb_i2c_transfer_op {
0676     __le16  addr;
0677     __le16  flags;
0678     __le16  size;
0679 } __packed;
0680 
0681 struct gb_i2c_transfer_request {
0682     __le16              op_count;
0683     struct gb_i2c_transfer_op   ops[];      /* op_count of these */
0684 } __packed;
0685 struct gb_i2c_transfer_response {
0686     __u8                data[0];    /* inbound data */
0687 } __packed;
0688 
0689 
0690 /* GPIO */
0691 
0692 /* Greybus GPIO request types */
0693 #define GB_GPIO_TYPE_LINE_COUNT     0x02
0694 #define GB_GPIO_TYPE_ACTIVATE       0x03
0695 #define GB_GPIO_TYPE_DEACTIVATE     0x04
0696 #define GB_GPIO_TYPE_GET_DIRECTION  0x05
0697 #define GB_GPIO_TYPE_DIRECTION_IN   0x06
0698 #define GB_GPIO_TYPE_DIRECTION_OUT  0x07
0699 #define GB_GPIO_TYPE_GET_VALUE      0x08
0700 #define GB_GPIO_TYPE_SET_VALUE      0x09
0701 #define GB_GPIO_TYPE_SET_DEBOUNCE   0x0a
0702 #define GB_GPIO_TYPE_IRQ_TYPE       0x0b
0703 #define GB_GPIO_TYPE_IRQ_MASK       0x0c
0704 #define GB_GPIO_TYPE_IRQ_UNMASK     0x0d
0705 #define GB_GPIO_TYPE_IRQ_EVENT      0x0e
0706 
0707 #define GB_GPIO_IRQ_TYPE_NONE       0x00
0708 #define GB_GPIO_IRQ_TYPE_EDGE_RISING    0x01
0709 #define GB_GPIO_IRQ_TYPE_EDGE_FALLING   0x02
0710 #define GB_GPIO_IRQ_TYPE_EDGE_BOTH  0x03
0711 #define GB_GPIO_IRQ_TYPE_LEVEL_HIGH 0x04
0712 #define GB_GPIO_IRQ_TYPE_LEVEL_LOW  0x08
0713 
0714 /* line count request has no payload */
0715 struct gb_gpio_line_count_response {
0716     __u8    count;
0717 } __packed;
0718 
0719 struct gb_gpio_activate_request {
0720     __u8    which;
0721 } __packed;
0722 /* activate response has no payload */
0723 
0724 struct gb_gpio_deactivate_request {
0725     __u8    which;
0726 } __packed;
0727 /* deactivate response has no payload */
0728 
0729 struct gb_gpio_get_direction_request {
0730     __u8    which;
0731 } __packed;
0732 struct gb_gpio_get_direction_response {
0733     __u8    direction;
0734 } __packed;
0735 
0736 struct gb_gpio_direction_in_request {
0737     __u8    which;
0738 } __packed;
0739 /* direction in response has no payload */
0740 
0741 struct gb_gpio_direction_out_request {
0742     __u8    which;
0743     __u8    value;
0744 } __packed;
0745 /* direction out response has no payload */
0746 
0747 struct gb_gpio_get_value_request {
0748     __u8    which;
0749 } __packed;
0750 struct gb_gpio_get_value_response {
0751     __u8    value;
0752 } __packed;
0753 
0754 struct gb_gpio_set_value_request {
0755     __u8    which;
0756     __u8    value;
0757 } __packed;
0758 /* set value response has no payload */
0759 
0760 struct gb_gpio_set_debounce_request {
0761     __u8    which;
0762     __le16  usec;
0763 } __packed;
0764 /* debounce response has no payload */
0765 
0766 struct gb_gpio_irq_type_request {
0767     __u8    which;
0768     __u8    type;
0769 } __packed;
0770 /* irq type response has no payload */
0771 
0772 struct gb_gpio_irq_mask_request {
0773     __u8    which;
0774 } __packed;
0775 /* irq mask response has no payload */
0776 
0777 struct gb_gpio_irq_unmask_request {
0778     __u8    which;
0779 } __packed;
0780 /* irq unmask response has no payload */
0781 
0782 /* irq event requests originate on another module and are handled on the AP */
0783 struct gb_gpio_irq_event_request {
0784     __u8    which;
0785 } __packed;
0786 /* irq event has no response */
0787 
0788 
0789 /* PWM */
0790 
0791 /* Greybus PWM operation types */
0792 #define GB_PWM_TYPE_PWM_COUNT       0x02
0793 #define GB_PWM_TYPE_ACTIVATE        0x03
0794 #define GB_PWM_TYPE_DEACTIVATE      0x04
0795 #define GB_PWM_TYPE_CONFIG      0x05
0796 #define GB_PWM_TYPE_POLARITY        0x06
0797 #define GB_PWM_TYPE_ENABLE      0x07
0798 #define GB_PWM_TYPE_DISABLE     0x08
0799 
0800 /* pwm count request has no payload */
0801 struct gb_pwm_count_response {
0802     __u8    count;
0803 } __packed;
0804 
0805 struct gb_pwm_activate_request {
0806     __u8    which;
0807 } __packed;
0808 
0809 struct gb_pwm_deactivate_request {
0810     __u8    which;
0811 } __packed;
0812 
0813 struct gb_pwm_config_request {
0814     __u8    which;
0815     __le32  duty;
0816     __le32  period;
0817 } __packed;
0818 
0819 struct gb_pwm_polarity_request {
0820     __u8    which;
0821     __u8    polarity;
0822 } __packed;
0823 
0824 struct gb_pwm_enable_request {
0825     __u8    which;
0826 } __packed;
0827 
0828 struct gb_pwm_disable_request {
0829     __u8    which;
0830 } __packed;
0831 
0832 /* SPI */
0833 
0834 /* Should match up with modes in linux/spi/spi.h */
0835 #define GB_SPI_MODE_CPHA        0x01        /* clock phase */
0836 #define GB_SPI_MODE_CPOL        0x02        /* clock polarity */
0837 #define GB_SPI_MODE_MODE_0      (0 | 0)     /* (original MicroWire) */
0838 #define GB_SPI_MODE_MODE_1      (0 | GB_SPI_MODE_CPHA)
0839 #define GB_SPI_MODE_MODE_2      (GB_SPI_MODE_CPOL | 0)
0840 #define GB_SPI_MODE_MODE_3      (GB_SPI_MODE_CPOL | GB_SPI_MODE_CPHA)
0841 #define GB_SPI_MODE_CS_HIGH     0x04        /* chipselect active high? */
0842 #define GB_SPI_MODE_LSB_FIRST       0x08        /* per-word bits-on-wire */
0843 #define GB_SPI_MODE_3WIRE       0x10        /* SI/SO signals shared */
0844 #define GB_SPI_MODE_LOOP        0x20        /* loopback mode */
0845 #define GB_SPI_MODE_NO_CS       0x40        /* 1 dev/bus, no chipselect */
0846 #define GB_SPI_MODE_READY       0x80        /* slave pulls low to pause */
0847 
0848 /* Should match up with flags in linux/spi/spi.h */
0849 #define GB_SPI_FLAG_HALF_DUPLEX     BIT(0)      /* can't do full duplex */
0850 #define GB_SPI_FLAG_NO_RX       BIT(1)      /* can't do buffer read */
0851 #define GB_SPI_FLAG_NO_TX       BIT(2)      /* can't do buffer write */
0852 
0853 /* Greybus spi operation types */
0854 #define GB_SPI_TYPE_MASTER_CONFIG   0x02
0855 #define GB_SPI_TYPE_DEVICE_CONFIG   0x03
0856 #define GB_SPI_TYPE_TRANSFER        0x04
0857 
0858 /* mode request has no payload */
0859 struct gb_spi_master_config_response {
0860     __le32  bits_per_word_mask;
0861     __le32  min_speed_hz;
0862     __le32  max_speed_hz;
0863     __le16  mode;
0864     __le16  flags;
0865     __u8    num_chipselect;
0866 } __packed;
0867 
0868 struct gb_spi_device_config_request {
0869     __u8    chip_select;
0870 } __packed;
0871 
0872 struct gb_spi_device_config_response {
0873     __le16  mode;
0874     __u8    bits_per_word;
0875     __le32  max_speed_hz;
0876     __u8    device_type;
0877 #define GB_SPI_SPI_DEV      0x00
0878 #define GB_SPI_SPI_NOR      0x01
0879 #define GB_SPI_SPI_MODALIAS 0x02
0880     __u8    name[32];
0881 } __packed;
0882 
0883 /**
0884  * struct gb_spi_transfer - a read/write buffer pair
0885  * @speed_hz: Select a speed other than the device default for this transfer. If
0886  *  0 the default (from @spi_device) is used.
0887  * @len: size of rx and tx buffers (in bytes)
0888  * @delay_usecs: microseconds to delay after this transfer before (optionally)
0889  *  changing the chipselect status, then starting the next transfer or
0890  *  completing this spi_message.
0891  * @cs_change: affects chipselect after this transfer completes
0892  * @bits_per_word: select a bits_per_word other than the device default for this
0893  *  transfer. If 0 the default (from @spi_device) is used.
0894  */
0895 struct gb_spi_transfer {
0896     __le32      speed_hz;
0897     __le32      len;
0898     __le16      delay_usecs;
0899     __u8        cs_change;
0900     __u8        bits_per_word;
0901     __u8        xfer_flags;
0902 #define GB_SPI_XFER_READ    0x01
0903 #define GB_SPI_XFER_WRITE   0x02
0904 #define GB_SPI_XFER_INPROGRESS  0x04
0905 } __packed;
0906 
0907 struct gb_spi_transfer_request {
0908     __u8            chip_select;    /* of the spi device */
0909     __u8            mode;       /* of the spi device */
0910     __le16          count;
0911     struct gb_spi_transfer  transfers[];    /* count of these */
0912 } __packed;
0913 
0914 struct gb_spi_transfer_response {
0915     __u8            data[0];    /* inbound data */
0916 } __packed;
0917 
0918 /* Version of the Greybus SVC protocol we support */
0919 #define GB_SVC_VERSION_MAJOR        0x00
0920 #define GB_SVC_VERSION_MINOR        0x01
0921 
0922 /* Greybus SVC request types */
0923 #define GB_SVC_TYPE_PROTOCOL_VERSION        0x01
0924 #define GB_SVC_TYPE_SVC_HELLO           0x02
0925 #define GB_SVC_TYPE_INTF_DEVICE_ID      0x03
0926 #define GB_SVC_TYPE_INTF_RESET          0x06
0927 #define GB_SVC_TYPE_CONN_CREATE         0x07
0928 #define GB_SVC_TYPE_CONN_DESTROY        0x08
0929 #define GB_SVC_TYPE_DME_PEER_GET        0x09
0930 #define GB_SVC_TYPE_DME_PEER_SET        0x0a
0931 #define GB_SVC_TYPE_ROUTE_CREATE        0x0b
0932 #define GB_SVC_TYPE_ROUTE_DESTROY       0x0c
0933 #define GB_SVC_TYPE_TIMESYNC_ENABLE     0x0d
0934 #define GB_SVC_TYPE_TIMESYNC_DISABLE        0x0e
0935 #define GB_SVC_TYPE_TIMESYNC_AUTHORITATIVE  0x0f
0936 #define GB_SVC_TYPE_INTF_SET_PWRM       0x10
0937 #define GB_SVC_TYPE_INTF_EJECT          0x11
0938 #define GB_SVC_TYPE_PING            0x13
0939 #define GB_SVC_TYPE_PWRMON_RAIL_COUNT_GET   0x14
0940 #define GB_SVC_TYPE_PWRMON_RAIL_NAMES_GET   0x15
0941 #define GB_SVC_TYPE_PWRMON_SAMPLE_GET       0x16
0942 #define GB_SVC_TYPE_PWRMON_INTF_SAMPLE_GET  0x17
0943 #define GB_SVC_TYPE_TIMESYNC_WAKE_PINS_ACQUIRE  0x18
0944 #define GB_SVC_TYPE_TIMESYNC_WAKE_PINS_RELEASE  0x19
0945 #define GB_SVC_TYPE_TIMESYNC_PING       0x1a
0946 #define GB_SVC_TYPE_MODULE_INSERTED     0x1f
0947 #define GB_SVC_TYPE_MODULE_REMOVED      0x20
0948 #define GB_SVC_TYPE_INTF_VSYS_ENABLE        0x21
0949 #define GB_SVC_TYPE_INTF_VSYS_DISABLE       0x22
0950 #define GB_SVC_TYPE_INTF_REFCLK_ENABLE      0x23
0951 #define GB_SVC_TYPE_INTF_REFCLK_DISABLE     0x24
0952 #define GB_SVC_TYPE_INTF_UNIPRO_ENABLE      0x25
0953 #define GB_SVC_TYPE_INTF_UNIPRO_DISABLE     0x26
0954 #define GB_SVC_TYPE_INTF_ACTIVATE       0x27
0955 #define GB_SVC_TYPE_INTF_RESUME         0x28
0956 #define GB_SVC_TYPE_INTF_MAILBOX_EVENT      0x29
0957 #define GB_SVC_TYPE_INTF_OOPS           0x2a
0958 
0959 /* Greybus SVC protocol status values */
0960 #define GB_SVC_OP_SUCCESS           0x00
0961 #define GB_SVC_OP_UNKNOWN_ERROR         0x01
0962 #define GB_SVC_INTF_NOT_DETECTED        0x02
0963 #define GB_SVC_INTF_NO_UPRO_LINK        0x03
0964 #define GB_SVC_INTF_UPRO_NOT_DOWN       0x04
0965 #define GB_SVC_INTF_UPRO_NOT_HIBERNATED     0x05
0966 #define GB_SVC_INTF_NO_V_SYS            0x06
0967 #define GB_SVC_INTF_V_CHG           0x07
0968 #define GB_SVC_INTF_WAKE_BUSY           0x08
0969 #define GB_SVC_INTF_NO_REFCLK           0x09
0970 #define GB_SVC_INTF_RELEASING           0x0a
0971 #define GB_SVC_INTF_NO_ORDER            0x0b
0972 #define GB_SVC_INTF_MBOX_SET            0x0c
0973 #define GB_SVC_INTF_BAD_MBOX            0x0d
0974 #define GB_SVC_INTF_OP_TIMEOUT          0x0e
0975 #define GB_SVC_PWRMON_OP_NOT_PRESENT        0x0f
0976 
0977 struct gb_svc_version_request {
0978     __u8    major;
0979     __u8    minor;
0980 } __packed;
0981 
0982 struct gb_svc_version_response {
0983     __u8    major;
0984     __u8    minor;
0985 } __packed;
0986 
0987 /* SVC protocol hello request */
0988 struct gb_svc_hello_request {
0989     __le16          endo_id;
0990     __u8            interface_id;
0991 } __packed;
0992 /* hello response has no payload */
0993 
0994 struct gb_svc_intf_device_id_request {
0995     __u8    intf_id;
0996     __u8    device_id;
0997 } __packed;
0998 /* device id response has no payload */
0999 
1000 struct gb_svc_intf_reset_request {
1001     __u8    intf_id;
1002 } __packed;
1003 /* interface reset response has no payload */
1004 
1005 struct gb_svc_intf_eject_request {
1006     __u8    intf_id;
1007 } __packed;
1008 /* interface eject response has no payload */
1009 
1010 struct gb_svc_conn_create_request {
1011     __u8    intf1_id;
1012     __le16  cport1_id;
1013     __u8    intf2_id;
1014     __le16  cport2_id;
1015     __u8    tc;
1016     __u8    flags;
1017 } __packed;
1018 /* connection create response has no payload */
1019 
1020 struct gb_svc_conn_destroy_request {
1021     __u8    intf1_id;
1022     __le16  cport1_id;
1023     __u8    intf2_id;
1024     __le16  cport2_id;
1025 } __packed;
1026 /* connection destroy response has no payload */
1027 
1028 struct gb_svc_dme_peer_get_request {
1029     __u8    intf_id;
1030     __le16  attr;
1031     __le16  selector;
1032 } __packed;
1033 
1034 struct gb_svc_dme_peer_get_response {
1035     __le16  result_code;
1036     __le32  attr_value;
1037 } __packed;
1038 
1039 struct gb_svc_dme_peer_set_request {
1040     __u8    intf_id;
1041     __le16  attr;
1042     __le16  selector;
1043     __le32  value;
1044 } __packed;
1045 
1046 struct gb_svc_dme_peer_set_response {
1047     __le16  result_code;
1048 } __packed;
1049 
1050 /* Greybus init-status values, currently retrieved using DME peer gets. */
1051 #define GB_INIT_SPI_BOOT_STARTED            0x02
1052 #define GB_INIT_TRUSTED_SPI_BOOT_FINISHED       0x03
1053 #define GB_INIT_UNTRUSTED_SPI_BOOT_FINISHED     0x04
1054 #define GB_INIT_BOOTROM_UNIPRO_BOOT_STARTED     0x06
1055 #define GB_INIT_BOOTROM_FALLBACK_UNIPRO_BOOT_STARTED    0x09
1056 #define GB_INIT_S2_LOADER_BOOT_STARTED          0x0D
1057 
1058 struct gb_svc_route_create_request {
1059     __u8    intf1_id;
1060     __u8    dev1_id;
1061     __u8    intf2_id;
1062     __u8    dev2_id;
1063 } __packed;
1064 /* route create response has no payload */
1065 
1066 struct gb_svc_route_destroy_request {
1067     __u8    intf1_id;
1068     __u8    intf2_id;
1069 } __packed;
1070 /* route destroy response has no payload */
1071 
1072 /* used for svc_intf_vsys_{enable,disable} */
1073 struct gb_svc_intf_vsys_request {
1074     __u8    intf_id;
1075 } __packed;
1076 
1077 struct gb_svc_intf_vsys_response {
1078     __u8    result_code;
1079 #define GB_SVC_INTF_VSYS_OK             0x00
1080     /* 0x01 is reserved */
1081 #define GB_SVC_INTF_VSYS_FAIL               0x02
1082 } __packed;
1083 
1084 /* used for svc_intf_refclk_{enable,disable} */
1085 struct gb_svc_intf_refclk_request {
1086     __u8    intf_id;
1087 } __packed;
1088 
1089 struct gb_svc_intf_refclk_response {
1090     __u8    result_code;
1091 #define GB_SVC_INTF_REFCLK_OK               0x00
1092     /* 0x01 is reserved */
1093 #define GB_SVC_INTF_REFCLK_FAIL             0x02
1094 } __packed;
1095 
1096 /* used for svc_intf_unipro_{enable,disable} */
1097 struct gb_svc_intf_unipro_request {
1098     __u8    intf_id;
1099 } __packed;
1100 
1101 struct gb_svc_intf_unipro_response {
1102     __u8    result_code;
1103 #define GB_SVC_INTF_UNIPRO_OK               0x00
1104     /* 0x01 is reserved */
1105 #define GB_SVC_INTF_UNIPRO_FAIL             0x02
1106 #define GB_SVC_INTF_UNIPRO_NOT_OFF          0x03
1107 } __packed;
1108 
1109 #define GB_SVC_UNIPRO_FAST_MODE         0x01
1110 #define GB_SVC_UNIPRO_SLOW_MODE         0x02
1111 #define GB_SVC_UNIPRO_FAST_AUTO_MODE        0x04
1112 #define GB_SVC_UNIPRO_SLOW_AUTO_MODE        0x05
1113 #define GB_SVC_UNIPRO_MODE_UNCHANGED        0x07
1114 #define GB_SVC_UNIPRO_HIBERNATE_MODE        0x11
1115 #define GB_SVC_UNIPRO_OFF_MODE          0x12
1116 
1117 #define GB_SVC_SMALL_AMPLITUDE          0x01
1118 #define GB_SVC_LARGE_AMPLITUDE          0x02
1119 
1120 #define GB_SVC_NO_DE_EMPHASIS           0x00
1121 #define GB_SVC_SMALL_DE_EMPHASIS        0x01
1122 #define GB_SVC_LARGE_DE_EMPHASIS        0x02
1123 
1124 #define GB_SVC_PWRM_RXTERMINATION       0x01
1125 #define GB_SVC_PWRM_TXTERMINATION       0x02
1126 #define GB_SVC_PWRM_LINE_RESET          0x04
1127 #define GB_SVC_PWRM_SCRAMBLING          0x20
1128 
1129 #define GB_SVC_PWRM_QUIRK_HSSER         0x00000001
1130 
1131 #define GB_SVC_UNIPRO_HS_SERIES_A       0x01
1132 #define GB_SVC_UNIPRO_HS_SERIES_B       0x02
1133 
1134 #define GB_SVC_SETPWRM_PWR_OK           0x00
1135 #define GB_SVC_SETPWRM_PWR_LOCAL        0x01
1136 #define GB_SVC_SETPWRM_PWR_REMOTE       0x02
1137 #define GB_SVC_SETPWRM_PWR_BUSY         0x03
1138 #define GB_SVC_SETPWRM_PWR_ERROR_CAP    0x04
1139 #define GB_SVC_SETPWRM_PWR_FATAL_ERROR  0x05
1140 
1141 struct gb_svc_l2_timer_cfg {
1142     __le16 tsb_fc0_protection_timeout;
1143     __le16 tsb_tc0_replay_timeout;
1144     __le16 tsb_afc0_req_timeout;
1145     __le16 tsb_fc1_protection_timeout;
1146     __le16 tsb_tc1_replay_timeout;
1147     __le16 tsb_afc1_req_timeout;
1148     __le16 reserved_for_tc2[3];
1149     __le16 reserved_for_tc3[3];
1150 } __packed;
1151 
1152 struct gb_svc_intf_set_pwrm_request {
1153     __u8    intf_id;
1154     __u8    hs_series;
1155     __u8    tx_mode;
1156     __u8    tx_gear;
1157     __u8    tx_nlanes;
1158     __u8    tx_amplitude;
1159     __u8    tx_hs_equalizer;
1160     __u8    rx_mode;
1161     __u8    rx_gear;
1162     __u8    rx_nlanes;
1163     __u8    flags;
1164     __le32  quirks;
1165     struct gb_svc_l2_timer_cfg local_l2timerdata, remote_l2timerdata;
1166 } __packed;
1167 
1168 struct gb_svc_intf_set_pwrm_response {
1169     __u8    result_code;
1170 } __packed;
1171 
1172 struct gb_svc_key_event_request {
1173     __le16  key_code;
1174 #define GB_KEYCODE_ARA         0x00
1175 
1176     __u8    key_event;
1177 #define GB_SVC_KEY_RELEASED    0x00
1178 #define GB_SVC_KEY_PRESSED     0x01
1179 } __packed;
1180 
1181 #define GB_SVC_PWRMON_MAX_RAIL_COUNT        254
1182 
1183 struct gb_svc_pwrmon_rail_count_get_response {
1184     __u8    rail_count;
1185 } __packed;
1186 
1187 #define GB_SVC_PWRMON_RAIL_NAME_BUFSIZE     32
1188 
1189 struct gb_svc_pwrmon_rail_names_get_response {
1190     __u8    status;
1191     __u8    name[][GB_SVC_PWRMON_RAIL_NAME_BUFSIZE];
1192 } __packed;
1193 
1194 #define GB_SVC_PWRMON_TYPE_CURR         0x01
1195 #define GB_SVC_PWRMON_TYPE_VOL          0x02
1196 #define GB_SVC_PWRMON_TYPE_PWR          0x03
1197 
1198 #define GB_SVC_PWRMON_GET_SAMPLE_OK     0x00
1199 #define GB_SVC_PWRMON_GET_SAMPLE_INVAL      0x01
1200 #define GB_SVC_PWRMON_GET_SAMPLE_NOSUPP     0x02
1201 #define GB_SVC_PWRMON_GET_SAMPLE_HWERR      0x03
1202 
1203 struct gb_svc_pwrmon_sample_get_request {
1204     __u8    rail_id;
1205     __u8    measurement_type;
1206 } __packed;
1207 
1208 struct gb_svc_pwrmon_sample_get_response {
1209     __u8    result;
1210     __le32  measurement;
1211 } __packed;
1212 
1213 struct gb_svc_pwrmon_intf_sample_get_request {
1214     __u8    intf_id;
1215     __u8    measurement_type;
1216 } __packed;
1217 
1218 struct gb_svc_pwrmon_intf_sample_get_response {
1219     __u8    result;
1220     __le32  measurement;
1221 } __packed;
1222 
1223 #define GB_SVC_MODULE_INSERTED_FLAG_NO_PRIMARY  0x0001
1224 
1225 struct gb_svc_module_inserted_request {
1226     __u8    primary_intf_id;
1227     __u8    intf_count;
1228     __le16  flags;
1229 } __packed;
1230 /* module_inserted response has no payload */
1231 
1232 struct gb_svc_module_removed_request {
1233     __u8    primary_intf_id;
1234 } __packed;
1235 /* module_removed response has no payload */
1236 
1237 struct gb_svc_intf_activate_request {
1238     __u8    intf_id;
1239 } __packed;
1240 
1241 #define GB_SVC_INTF_TYPE_UNKNOWN        0x00
1242 #define GB_SVC_INTF_TYPE_DUMMY          0x01
1243 #define GB_SVC_INTF_TYPE_UNIPRO         0x02
1244 #define GB_SVC_INTF_TYPE_GREYBUS        0x03
1245 
1246 struct gb_svc_intf_activate_response {
1247     __u8    status;
1248     __u8    intf_type;
1249 } __packed;
1250 
1251 struct gb_svc_intf_resume_request {
1252     __u8    intf_id;
1253 } __packed;
1254 
1255 struct gb_svc_intf_resume_response {
1256     __u8    status;
1257 } __packed;
1258 
1259 #define GB_SVC_INTF_MAILBOX_NONE        0x00
1260 #define GB_SVC_INTF_MAILBOX_AP          0x01
1261 #define GB_SVC_INTF_MAILBOX_GREYBUS     0x02
1262 
1263 struct gb_svc_intf_mailbox_event_request {
1264     __u8    intf_id;
1265     __le16  result_code;
1266     __le32  mailbox;
1267 } __packed;
1268 /* intf_mailbox_event response has no payload */
1269 
1270 struct gb_svc_intf_oops_request {
1271     __u8    intf_id;
1272     __u8    reason;
1273 } __packed;
1274 /* intf_oops response has no payload */
1275 
1276 
1277 /* RAW */
1278 
1279 /* Greybus raw request types */
1280 #define GB_RAW_TYPE_SEND            0x02
1281 
1282 struct gb_raw_send_request {
1283     __le32  len;
1284     __u8    data[];
1285 } __packed;
1286 
1287 
1288 /* UART */
1289 
1290 /* Greybus UART operation types */
1291 #define GB_UART_TYPE_SEND_DATA          0x02
1292 #define GB_UART_TYPE_RECEIVE_DATA       0x03    /* Unsolicited data */
1293 #define GB_UART_TYPE_SET_LINE_CODING        0x04
1294 #define GB_UART_TYPE_SET_CONTROL_LINE_STATE 0x05
1295 #define GB_UART_TYPE_SEND_BREAK         0x06
1296 #define GB_UART_TYPE_SERIAL_STATE       0x07    /* Unsolicited data */
1297 #define GB_UART_TYPE_RECEIVE_CREDITS        0x08
1298 #define GB_UART_TYPE_FLUSH_FIFOS        0x09
1299 
1300 /* Represents data from AP -> Module */
1301 struct gb_uart_send_data_request {
1302     __le16  size;
1303     __u8    data[];
1304 } __packed;
1305 
1306 /* recv-data-request flags */
1307 #define GB_UART_RECV_FLAG_FRAMING       0x01    /* Framing error */
1308 #define GB_UART_RECV_FLAG_PARITY        0x02    /* Parity error */
1309 #define GB_UART_RECV_FLAG_OVERRUN       0x04    /* Overrun error */
1310 #define GB_UART_RECV_FLAG_BREAK         0x08    /* Break */
1311 
1312 /* Represents data from Module -> AP */
1313 struct gb_uart_recv_data_request {
1314     __le16  size;
1315     __u8    flags;
1316     __u8    data[];
1317 } __packed;
1318 
1319 struct gb_uart_receive_credits_request {
1320     __le16  count;
1321 } __packed;
1322 
1323 struct gb_uart_set_line_coding_request {
1324     __le32  rate;
1325     __u8    format;
1326 #define GB_SERIAL_1_STOP_BITS           0
1327 #define GB_SERIAL_1_5_STOP_BITS         1
1328 #define GB_SERIAL_2_STOP_BITS           2
1329 
1330     __u8    parity;
1331 #define GB_SERIAL_NO_PARITY         0
1332 #define GB_SERIAL_ODD_PARITY            1
1333 #define GB_SERIAL_EVEN_PARITY           2
1334 #define GB_SERIAL_MARK_PARITY           3
1335 #define GB_SERIAL_SPACE_PARITY          4
1336 
1337     __u8    data_bits;
1338 
1339     __u8    flow_control;
1340 #define GB_SERIAL_AUTO_RTSCTS_EN        0x1
1341 } __packed;
1342 
1343 /* output control lines */
1344 #define GB_UART_CTRL_DTR            0x01
1345 #define GB_UART_CTRL_RTS            0x02
1346 
1347 struct gb_uart_set_control_line_state_request {
1348     __u8    control;
1349 } __packed;
1350 
1351 struct gb_uart_set_break_request {
1352     __u8    state;
1353 } __packed;
1354 
1355 /* input control lines and line errors */
1356 #define GB_UART_CTRL_DCD            0x01
1357 #define GB_UART_CTRL_DSR            0x02
1358 #define GB_UART_CTRL_RI             0x04
1359 
1360 struct gb_uart_serial_state_request {
1361     __u8    control;
1362 } __packed;
1363 
1364 struct gb_uart_serial_flush_request {
1365     __u8    flags;
1366 #define GB_SERIAL_FLAG_FLUSH_TRANSMITTER    0x01
1367 #define GB_SERIAL_FLAG_FLUSH_RECEIVER       0x02
1368 } __packed;
1369 
1370 /* Loopback */
1371 
1372 /* Greybus loopback request types */
1373 #define GB_LOOPBACK_TYPE_PING           0x02
1374 #define GB_LOOPBACK_TYPE_TRANSFER       0x03
1375 #define GB_LOOPBACK_TYPE_SINK           0x04
1376 
1377 /*
1378  * Loopback request/response header format should be identical
1379  * to simplify bandwidth and data movement analysis.
1380  */
1381 struct gb_loopback_transfer_request {
1382     __le32  len;
1383     __le32  reserved0;
1384     __le32  reserved1;
1385     __u8    data[];
1386 } __packed;
1387 
1388 struct gb_loopback_transfer_response {
1389     __le32  len;
1390     __le32  reserved0;
1391     __le32  reserved1;
1392     __u8    data[];
1393 } __packed;
1394 
1395 /* SDIO */
1396 /* Greybus SDIO operation types */
1397 #define GB_SDIO_TYPE_GET_CAPABILITIES       0x02
1398 #define GB_SDIO_TYPE_SET_IOS            0x03
1399 #define GB_SDIO_TYPE_COMMAND            0x04
1400 #define GB_SDIO_TYPE_TRANSFER           0x05
1401 #define GB_SDIO_TYPE_EVENT          0x06
1402 
1403 /* get caps response: request has no payload */
1404 struct gb_sdio_get_caps_response {
1405     __le32  caps;
1406 #define GB_SDIO_CAP_NONREMOVABLE    0x00000001
1407 #define GB_SDIO_CAP_4_BIT_DATA      0x00000002
1408 #define GB_SDIO_CAP_8_BIT_DATA      0x00000004
1409 #define GB_SDIO_CAP_MMC_HS      0x00000008
1410 #define GB_SDIO_CAP_SD_HS       0x00000010
1411 #define GB_SDIO_CAP_ERASE       0x00000020
1412 #define GB_SDIO_CAP_1_2V_DDR        0x00000040
1413 #define GB_SDIO_CAP_1_8V_DDR        0x00000080
1414 #define GB_SDIO_CAP_POWER_OFF_CARD  0x00000100
1415 #define GB_SDIO_CAP_UHS_SDR12       0x00000200
1416 #define GB_SDIO_CAP_UHS_SDR25       0x00000400
1417 #define GB_SDIO_CAP_UHS_SDR50       0x00000800
1418 #define GB_SDIO_CAP_UHS_SDR104      0x00001000
1419 #define GB_SDIO_CAP_UHS_DDR50       0x00002000
1420 #define GB_SDIO_CAP_DRIVER_TYPE_A   0x00004000
1421 #define GB_SDIO_CAP_DRIVER_TYPE_C   0x00008000
1422 #define GB_SDIO_CAP_DRIVER_TYPE_D   0x00010000
1423 #define GB_SDIO_CAP_HS200_1_2V      0x00020000
1424 #define GB_SDIO_CAP_HS200_1_8V      0x00040000
1425 #define GB_SDIO_CAP_HS400_1_2V      0x00080000
1426 #define GB_SDIO_CAP_HS400_1_8V      0x00100000
1427 
1428     /* see possible values below at vdd */
1429     __le32 ocr;
1430     __le32 f_min;
1431     __le32 f_max;
1432     __le16 max_blk_count;
1433     __le16 max_blk_size;
1434 } __packed;
1435 
1436 /* set ios request: response has no payload */
1437 struct gb_sdio_set_ios_request {
1438     __le32  clock;
1439     __le32  vdd;
1440 #define GB_SDIO_VDD_165_195 0x00000001
1441 #define GB_SDIO_VDD_20_21   0x00000002
1442 #define GB_SDIO_VDD_21_22   0x00000004
1443 #define GB_SDIO_VDD_22_23   0x00000008
1444 #define GB_SDIO_VDD_23_24   0x00000010
1445 #define GB_SDIO_VDD_24_25   0x00000020
1446 #define GB_SDIO_VDD_25_26   0x00000040
1447 #define GB_SDIO_VDD_26_27   0x00000080
1448 #define GB_SDIO_VDD_27_28   0x00000100
1449 #define GB_SDIO_VDD_28_29   0x00000200
1450 #define GB_SDIO_VDD_29_30   0x00000400
1451 #define GB_SDIO_VDD_30_31   0x00000800
1452 #define GB_SDIO_VDD_31_32   0x00001000
1453 #define GB_SDIO_VDD_32_33   0x00002000
1454 #define GB_SDIO_VDD_33_34   0x00004000
1455 #define GB_SDIO_VDD_34_35   0x00008000
1456 #define GB_SDIO_VDD_35_36   0x00010000
1457 
1458     __u8    bus_mode;
1459 #define GB_SDIO_BUSMODE_OPENDRAIN   0x00
1460 #define GB_SDIO_BUSMODE_PUSHPULL    0x01
1461 
1462     __u8    power_mode;
1463 #define GB_SDIO_POWER_OFF   0x00
1464 #define GB_SDIO_POWER_UP    0x01
1465 #define GB_SDIO_POWER_ON    0x02
1466 #define GB_SDIO_POWER_UNDEFINED 0x03
1467 
1468     __u8    bus_width;
1469 #define GB_SDIO_BUS_WIDTH_1 0x00
1470 #define GB_SDIO_BUS_WIDTH_4 0x02
1471 #define GB_SDIO_BUS_WIDTH_8 0x03
1472 
1473     __u8    timing;
1474 #define GB_SDIO_TIMING_LEGACY       0x00
1475 #define GB_SDIO_TIMING_MMC_HS       0x01
1476 #define GB_SDIO_TIMING_SD_HS        0x02
1477 #define GB_SDIO_TIMING_UHS_SDR12    0x03
1478 #define GB_SDIO_TIMING_UHS_SDR25    0x04
1479 #define GB_SDIO_TIMING_UHS_SDR50    0x05
1480 #define GB_SDIO_TIMING_UHS_SDR104   0x06
1481 #define GB_SDIO_TIMING_UHS_DDR50    0x07
1482 #define GB_SDIO_TIMING_MMC_DDR52    0x08
1483 #define GB_SDIO_TIMING_MMC_HS200    0x09
1484 #define GB_SDIO_TIMING_MMC_HS400    0x0A
1485 
1486     __u8    signal_voltage;
1487 #define GB_SDIO_SIGNAL_VOLTAGE_330  0x00
1488 #define GB_SDIO_SIGNAL_VOLTAGE_180  0x01
1489 #define GB_SDIO_SIGNAL_VOLTAGE_120  0x02
1490 
1491     __u8    drv_type;
1492 #define GB_SDIO_SET_DRIVER_TYPE_B   0x00
1493 #define GB_SDIO_SET_DRIVER_TYPE_A   0x01
1494 #define GB_SDIO_SET_DRIVER_TYPE_C   0x02
1495 #define GB_SDIO_SET_DRIVER_TYPE_D   0x03
1496 } __packed;
1497 
1498 /* command request */
1499 struct gb_sdio_command_request {
1500     __u8    cmd;
1501     __u8    cmd_flags;
1502 #define GB_SDIO_RSP_NONE        0x00
1503 #define GB_SDIO_RSP_PRESENT     0x01
1504 #define GB_SDIO_RSP_136         0x02
1505 #define GB_SDIO_RSP_CRC         0x04
1506 #define GB_SDIO_RSP_BUSY        0x08
1507 #define GB_SDIO_RSP_OPCODE      0x10
1508 
1509     __u8    cmd_type;
1510 #define GB_SDIO_CMD_AC      0x00
1511 #define GB_SDIO_CMD_ADTC    0x01
1512 #define GB_SDIO_CMD_BC      0x02
1513 #define GB_SDIO_CMD_BCR     0x03
1514 
1515     __le32  cmd_arg;
1516     __le16  data_blocks;
1517     __le16  data_blksz;
1518 } __packed;
1519 
1520 struct gb_sdio_command_response {
1521     __le32  resp[4];
1522 } __packed;
1523 
1524 /* transfer request */
1525 struct gb_sdio_transfer_request {
1526     __u8    data_flags;
1527 #define GB_SDIO_DATA_WRITE  0x01
1528 #define GB_SDIO_DATA_READ   0x02
1529 #define GB_SDIO_DATA_STREAM 0x04
1530 
1531     __le16  data_blocks;
1532     __le16  data_blksz;
1533     __u8    data[];
1534 } __packed;
1535 
1536 struct gb_sdio_transfer_response {
1537     __le16  data_blocks;
1538     __le16  data_blksz;
1539     __u8    data[];
1540 } __packed;
1541 
1542 /* event request: generated by module and is defined as unidirectional */
1543 struct gb_sdio_event_request {
1544     __u8    event;
1545 #define GB_SDIO_CARD_INSERTED   0x01
1546 #define GB_SDIO_CARD_REMOVED    0x02
1547 #define GB_SDIO_WP      0x04
1548 } __packed;
1549 
1550 /* Camera */
1551 
1552 /* Greybus Camera request types */
1553 #define GB_CAMERA_TYPE_CAPABILITIES     0x02
1554 #define GB_CAMERA_TYPE_CONFIGURE_STREAMS    0x03
1555 #define GB_CAMERA_TYPE_CAPTURE          0x04
1556 #define GB_CAMERA_TYPE_FLUSH            0x05
1557 #define GB_CAMERA_TYPE_METADATA         0x06
1558 
1559 #define GB_CAMERA_MAX_STREAMS           4
1560 #define GB_CAMERA_MAX_SETTINGS_SIZE     8192
1561 
1562 /* Greybus Camera Configure Streams request payload */
1563 struct gb_camera_stream_config_request {
1564     __le16 width;
1565     __le16 height;
1566     __le16 format;
1567     __le16 padding;
1568 } __packed;
1569 
1570 struct gb_camera_configure_streams_request {
1571     __u8 num_streams;
1572     __u8 flags;
1573 #define GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY   0x01
1574     __le16 padding;
1575     struct gb_camera_stream_config_request config[];
1576 } __packed;
1577 
1578 /* Greybus Camera Configure Streams response payload */
1579 struct gb_camera_stream_config_response {
1580     __le16 width;
1581     __le16 height;
1582     __le16 format;
1583     __u8 virtual_channel;
1584     __u8 data_type[2];
1585     __le16 max_pkt_size;
1586     __u8 padding;
1587     __le32 max_size;
1588 } __packed;
1589 
1590 struct gb_camera_configure_streams_response {
1591     __u8 num_streams;
1592 #define GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED    0x01
1593     __u8 flags;
1594     __u8 padding[2];
1595     __le32 data_rate;
1596     struct gb_camera_stream_config_response config[];
1597 };
1598 
1599 /* Greybus Camera Capture request payload - response has no payload */
1600 struct gb_camera_capture_request {
1601     __le32 request_id;
1602     __u8 streams;
1603     __u8 padding;
1604     __le16 num_frames;
1605     __u8 settings[];
1606 } __packed;
1607 
1608 /* Greybus Camera Flush response payload - request has no payload */
1609 struct gb_camera_flush_response {
1610     __le32 request_id;
1611 } __packed;
1612 
1613 /* Greybus Camera Metadata request payload - operation has no response */
1614 struct gb_camera_metadata_request {
1615     __le32 request_id;
1616     __le16 frame_number;
1617     __u8 stream;
1618     __u8 padding;
1619     __u8 metadata[];
1620 } __packed;
1621 
1622 /* Lights */
1623 
1624 /* Greybus Lights request types */
1625 #define GB_LIGHTS_TYPE_GET_LIGHTS       0x02
1626 #define GB_LIGHTS_TYPE_GET_LIGHT_CONFIG     0x03
1627 #define GB_LIGHTS_TYPE_GET_CHANNEL_CONFIG   0x04
1628 #define GB_LIGHTS_TYPE_GET_CHANNEL_FLASH_CONFIG 0x05
1629 #define GB_LIGHTS_TYPE_SET_BRIGHTNESS       0x06
1630 #define GB_LIGHTS_TYPE_SET_BLINK        0x07
1631 #define GB_LIGHTS_TYPE_SET_COLOR        0x08
1632 #define GB_LIGHTS_TYPE_SET_FADE         0x09
1633 #define GB_LIGHTS_TYPE_EVENT            0x0A
1634 #define GB_LIGHTS_TYPE_SET_FLASH_INTENSITY  0x0B
1635 #define GB_LIGHTS_TYPE_SET_FLASH_STROBE     0x0C
1636 #define GB_LIGHTS_TYPE_SET_FLASH_TIMEOUT    0x0D
1637 #define GB_LIGHTS_TYPE_GET_FLASH_FAULT      0x0E
1638 
1639 /* Greybus Light modes */
1640 
1641 /*
1642  * if you add any specific mode below, update also the
1643  * GB_CHANNEL_MODE_DEFINED_RANGE value accordingly
1644  */
1645 #define GB_CHANNEL_MODE_NONE        0x00000000
1646 #define GB_CHANNEL_MODE_BATTERY     0x00000001
1647 #define GB_CHANNEL_MODE_POWER       0x00000002
1648 #define GB_CHANNEL_MODE_WIRELESS    0x00000004
1649 #define GB_CHANNEL_MODE_BLUETOOTH   0x00000008
1650 #define GB_CHANNEL_MODE_KEYBOARD    0x00000010
1651 #define GB_CHANNEL_MODE_BUTTONS     0x00000020
1652 #define GB_CHANNEL_MODE_NOTIFICATION    0x00000040
1653 #define GB_CHANNEL_MODE_ATTENTION   0x00000080
1654 #define GB_CHANNEL_MODE_FLASH       0x00000100
1655 #define GB_CHANNEL_MODE_TORCH       0x00000200
1656 #define GB_CHANNEL_MODE_INDICATOR   0x00000400
1657 
1658 /* Lights Mode valid bit values */
1659 #define GB_CHANNEL_MODE_DEFINED_RANGE   0x000004FF
1660 #define GB_CHANNEL_MODE_VENDOR_RANGE    0x00F00000
1661 
1662 /* Greybus Light Channels Flags */
1663 #define GB_LIGHT_CHANNEL_MULTICOLOR 0x00000001
1664 #define GB_LIGHT_CHANNEL_FADER      0x00000002
1665 #define GB_LIGHT_CHANNEL_BLINK      0x00000004
1666 
1667 /* get count of lights in module */
1668 struct gb_lights_get_lights_response {
1669     __u8    lights_count;
1670 } __packed;
1671 
1672 /* light config request payload */
1673 struct gb_lights_get_light_config_request {
1674     __u8    id;
1675 } __packed;
1676 
1677 /* light config response payload */
1678 struct gb_lights_get_light_config_response {
1679     __u8    channel_count;
1680     __u8    name[32];
1681 } __packed;
1682 
1683 /* channel config request payload */
1684 struct gb_lights_get_channel_config_request {
1685     __u8    light_id;
1686     __u8    channel_id;
1687 } __packed;
1688 
1689 /* channel flash config request payload */
1690 struct gb_lights_get_channel_flash_config_request {
1691     __u8    light_id;
1692     __u8    channel_id;
1693 } __packed;
1694 
1695 /* channel config response payload */
1696 struct gb_lights_get_channel_config_response {
1697     __u8    max_brightness;
1698     __le32  flags;
1699     __le32  color;
1700     __u8    color_name[32];
1701     __le32  mode;
1702     __u8    mode_name[32];
1703 } __packed;
1704 
1705 /* channel flash config response payload */
1706 struct gb_lights_get_channel_flash_config_response {
1707     __le32  intensity_min_uA;
1708     __le32  intensity_max_uA;
1709     __le32  intensity_step_uA;
1710     __le32  timeout_min_us;
1711     __le32  timeout_max_us;
1712     __le32  timeout_step_us;
1713 } __packed;
1714 
1715 /* blink request payload: response have no payload */
1716 struct gb_lights_blink_request {
1717     __u8    light_id;
1718     __u8    channel_id;
1719     __le16  time_on_ms;
1720     __le16  time_off_ms;
1721 } __packed;
1722 
1723 /* set brightness request payload: response have no payload */
1724 struct gb_lights_set_brightness_request {
1725     __u8    light_id;
1726     __u8    channel_id;
1727     __u8    brightness;
1728 } __packed;
1729 
1730 /* set color request payload: response have no payload */
1731 struct gb_lights_set_color_request {
1732     __u8    light_id;
1733     __u8    channel_id;
1734     __le32  color;
1735 } __packed;
1736 
1737 /* set fade request payload: response have no payload */
1738 struct gb_lights_set_fade_request {
1739     __u8    light_id;
1740     __u8    channel_id;
1741     __u8    fade_in;
1742     __u8    fade_out;
1743 } __packed;
1744 
1745 /* event request: generated by module */
1746 struct gb_lights_event_request {
1747     __u8    light_id;
1748     __u8    event;
1749 #define GB_LIGHTS_LIGHT_CONFIG      0x01
1750 } __packed;
1751 
1752 /* set flash intensity request payload: response have no payload */
1753 struct gb_lights_set_flash_intensity_request {
1754     __u8    light_id;
1755     __u8    channel_id;
1756     __le32  intensity_uA;
1757 } __packed;
1758 
1759 /* set flash strobe state request payload: response have no payload */
1760 struct gb_lights_set_flash_strobe_request {
1761     __u8    light_id;
1762     __u8    channel_id;
1763     __u8    state;
1764 } __packed;
1765 
1766 /* set flash timeout request payload: response have no payload */
1767 struct gb_lights_set_flash_timeout_request {
1768     __u8    light_id;
1769     __u8    channel_id;
1770     __le32  timeout_us;
1771 } __packed;
1772 
1773 /* get flash fault request payload */
1774 struct gb_lights_get_flash_fault_request {
1775     __u8    light_id;
1776     __u8    channel_id;
1777 } __packed;
1778 
1779 /* get flash fault response payload */
1780 struct gb_lights_get_flash_fault_response {
1781     __le32  fault;
1782 #define GB_LIGHTS_FLASH_FAULT_OVER_VOLTAGE      0x00000000
1783 #define GB_LIGHTS_FLASH_FAULT_TIMEOUT           0x00000001
1784 #define GB_LIGHTS_FLASH_FAULT_OVER_TEMPERATURE      0x00000002
1785 #define GB_LIGHTS_FLASH_FAULT_SHORT_CIRCUIT     0x00000004
1786 #define GB_LIGHTS_FLASH_FAULT_OVER_CURRENT      0x00000008
1787 #define GB_LIGHTS_FLASH_FAULT_INDICATOR         0x00000010
1788 #define GB_LIGHTS_FLASH_FAULT_UNDER_VOLTAGE     0x00000020
1789 #define GB_LIGHTS_FLASH_FAULT_INPUT_VOLTAGE     0x00000040
1790 #define GB_LIGHTS_FLASH_FAULT_LED_OVER_TEMPERATURE  0x00000080
1791 } __packed;
1792 
1793 /* Audio */
1794 
1795 #define GB_AUDIO_TYPE_GET_TOPOLOGY_SIZE     0x02
1796 #define GB_AUDIO_TYPE_GET_TOPOLOGY      0x03
1797 #define GB_AUDIO_TYPE_GET_CONTROL       0x04
1798 #define GB_AUDIO_TYPE_SET_CONTROL       0x05
1799 #define GB_AUDIO_TYPE_ENABLE_WIDGET     0x06
1800 #define GB_AUDIO_TYPE_DISABLE_WIDGET        0x07
1801 #define GB_AUDIO_TYPE_GET_PCM           0x08
1802 #define GB_AUDIO_TYPE_SET_PCM           0x09
1803 #define GB_AUDIO_TYPE_SET_TX_DATA_SIZE      0x0a
1804                         /* 0x0b unused */
1805 #define GB_AUDIO_TYPE_ACTIVATE_TX       0x0c
1806 #define GB_AUDIO_TYPE_DEACTIVATE_TX     0x0d
1807 #define GB_AUDIO_TYPE_SET_RX_DATA_SIZE      0x0e
1808                         /* 0x0f unused */
1809 #define GB_AUDIO_TYPE_ACTIVATE_RX       0x10
1810 #define GB_AUDIO_TYPE_DEACTIVATE_RX     0x11
1811 #define GB_AUDIO_TYPE_JACK_EVENT        0x12
1812 #define GB_AUDIO_TYPE_BUTTON_EVENT      0x13
1813 #define GB_AUDIO_TYPE_STREAMING_EVENT       0x14
1814 #define GB_AUDIO_TYPE_SEND_DATA         0x15
1815 
1816 /* Module must be able to buffer 10ms of audio data, minimum */
1817 #define GB_AUDIO_SAMPLE_BUFFER_MIN_US       10000
1818 
1819 #define GB_AUDIO_PCM_NAME_MAX           32
1820 #define AUDIO_DAI_NAME_MAX          32
1821 #define AUDIO_CONTROL_NAME_MAX          32
1822 #define AUDIO_CTL_ELEM_NAME_MAX         44
1823 #define AUDIO_ENUM_NAME_MAX         64
1824 #define AUDIO_WIDGET_NAME_MAX           32
1825 
1826 /* See SNDRV_PCM_FMTBIT_* in Linux source */
1827 #define GB_AUDIO_PCM_FMT_S8         BIT(0)
1828 #define GB_AUDIO_PCM_FMT_U8         BIT(1)
1829 #define GB_AUDIO_PCM_FMT_S16_LE         BIT(2)
1830 #define GB_AUDIO_PCM_FMT_S16_BE         BIT(3)
1831 #define GB_AUDIO_PCM_FMT_U16_LE         BIT(4)
1832 #define GB_AUDIO_PCM_FMT_U16_BE         BIT(5)
1833 #define GB_AUDIO_PCM_FMT_S24_LE         BIT(6)
1834 #define GB_AUDIO_PCM_FMT_S24_BE         BIT(7)
1835 #define GB_AUDIO_PCM_FMT_U24_LE         BIT(8)
1836 #define GB_AUDIO_PCM_FMT_U24_BE         BIT(9)
1837 #define GB_AUDIO_PCM_FMT_S32_LE         BIT(10)
1838 #define GB_AUDIO_PCM_FMT_S32_BE         BIT(11)
1839 #define GB_AUDIO_PCM_FMT_U32_LE         BIT(12)
1840 #define GB_AUDIO_PCM_FMT_U32_BE         BIT(13)
1841 
1842 /* See SNDRV_PCM_RATE_* in Linux source */
1843 #define GB_AUDIO_PCM_RATE_5512          BIT(0)
1844 #define GB_AUDIO_PCM_RATE_8000          BIT(1)
1845 #define GB_AUDIO_PCM_RATE_11025         BIT(2)
1846 #define GB_AUDIO_PCM_RATE_16000         BIT(3)
1847 #define GB_AUDIO_PCM_RATE_22050         BIT(4)
1848 #define GB_AUDIO_PCM_RATE_32000         BIT(5)
1849 #define GB_AUDIO_PCM_RATE_44100         BIT(6)
1850 #define GB_AUDIO_PCM_RATE_48000         BIT(7)
1851 #define GB_AUDIO_PCM_RATE_64000         BIT(8)
1852 #define GB_AUDIO_PCM_RATE_88200         BIT(9)
1853 #define GB_AUDIO_PCM_RATE_96000         BIT(10)
1854 #define GB_AUDIO_PCM_RATE_176400        BIT(11)
1855 #define GB_AUDIO_PCM_RATE_192000        BIT(12)
1856 
1857 #define GB_AUDIO_STREAM_TYPE_CAPTURE        0x1
1858 #define GB_AUDIO_STREAM_TYPE_PLAYBACK       0x2
1859 
1860 #define GB_AUDIO_CTL_ELEM_ACCESS_READ       BIT(0)
1861 #define GB_AUDIO_CTL_ELEM_ACCESS_WRITE      BIT(1)
1862 
1863 /* See SNDRV_CTL_ELEM_TYPE_* in Linux source */
1864 #define GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN      0x01
1865 #define GB_AUDIO_CTL_ELEM_TYPE_INTEGER      0x02
1866 #define GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED   0x03
1867 #define GB_AUDIO_CTL_ELEM_TYPE_INTEGER64    0x06
1868 
1869 /* See SNDRV_CTL_ELEM_IFACE_* in Linux source */
1870 #define GB_AUDIO_CTL_ELEM_IFACE_CARD        0x00
1871 #define GB_AUDIO_CTL_ELEM_IFACE_HWDEP       0x01
1872 #define GB_AUDIO_CTL_ELEM_IFACE_MIXER       0x02
1873 #define GB_AUDIO_CTL_ELEM_IFACE_PCM     0x03
1874 #define GB_AUDIO_CTL_ELEM_IFACE_RAWMIDI     0x04
1875 #define GB_AUDIO_CTL_ELEM_IFACE_TIMER       0x05
1876 #define GB_AUDIO_CTL_ELEM_IFACE_SEQUENCER   0x06
1877 
1878 /* SNDRV_CTL_ELEM_ACCESS_* in Linux source */
1879 #define GB_AUDIO_ACCESS_READ            BIT(0)
1880 #define GB_AUDIO_ACCESS_WRITE           BIT(1)
1881 #define GB_AUDIO_ACCESS_VOLATILE        BIT(2)
1882 #define GB_AUDIO_ACCESS_TIMESTAMP       BIT(3)
1883 #define GB_AUDIO_ACCESS_TLV_READ        BIT(4)
1884 #define GB_AUDIO_ACCESS_TLV_WRITE       BIT(5)
1885 #define GB_AUDIO_ACCESS_TLV_COMMAND     BIT(6)
1886 #define GB_AUDIO_ACCESS_INACTIVE        BIT(7)
1887 #define GB_AUDIO_ACCESS_LOCK            BIT(8)
1888 #define GB_AUDIO_ACCESS_OWNER           BIT(9)
1889 
1890 /* enum snd_soc_dapm_type */
1891 #define GB_AUDIO_WIDGET_TYPE_INPUT      0x0
1892 #define GB_AUDIO_WIDGET_TYPE_OUTPUT     0x1
1893 #define GB_AUDIO_WIDGET_TYPE_MUX        0x2
1894 #define GB_AUDIO_WIDGET_TYPE_VIRT_MUX       0x3
1895 #define GB_AUDIO_WIDGET_TYPE_VALUE_MUX      0x4
1896 #define GB_AUDIO_WIDGET_TYPE_MIXER      0x5
1897 #define GB_AUDIO_WIDGET_TYPE_MIXER_NAMED_CTL    0x6
1898 #define GB_AUDIO_WIDGET_TYPE_PGA        0x7
1899 #define GB_AUDIO_WIDGET_TYPE_OUT_DRV        0x8
1900 #define GB_AUDIO_WIDGET_TYPE_ADC        0x9
1901 #define GB_AUDIO_WIDGET_TYPE_DAC        0xa
1902 #define GB_AUDIO_WIDGET_TYPE_MICBIAS        0xb
1903 #define GB_AUDIO_WIDGET_TYPE_MIC        0xc
1904 #define GB_AUDIO_WIDGET_TYPE_HP         0xd
1905 #define GB_AUDIO_WIDGET_TYPE_SPK        0xe
1906 #define GB_AUDIO_WIDGET_TYPE_LINE       0xf
1907 #define GB_AUDIO_WIDGET_TYPE_SWITCH     0x10
1908 #define GB_AUDIO_WIDGET_TYPE_VMID       0x11
1909 #define GB_AUDIO_WIDGET_TYPE_PRE        0x12
1910 #define GB_AUDIO_WIDGET_TYPE_POST       0x13
1911 #define GB_AUDIO_WIDGET_TYPE_SUPPLY     0x14
1912 #define GB_AUDIO_WIDGET_TYPE_REGULATOR_SUPPLY   0x15
1913 #define GB_AUDIO_WIDGET_TYPE_CLOCK_SUPPLY   0x16
1914 #define GB_AUDIO_WIDGET_TYPE_AIF_IN     0x17
1915 #define GB_AUDIO_WIDGET_TYPE_AIF_OUT        0x18
1916 #define GB_AUDIO_WIDGET_TYPE_SIGGEN     0x19
1917 #define GB_AUDIO_WIDGET_TYPE_DAI_IN     0x1a
1918 #define GB_AUDIO_WIDGET_TYPE_DAI_OUT        0x1b
1919 #define GB_AUDIO_WIDGET_TYPE_DAI_LINK       0x1c
1920 
1921 #define GB_AUDIO_WIDGET_STATE_DISABLED      0x01
1922 #define GB_AUDIO_WIDGET_STATE_ENAABLED      0x02
1923 
1924 #define GB_AUDIO_JACK_EVENT_INSERTION       0x1
1925 #define GB_AUDIO_JACK_EVENT_REMOVAL     0x2
1926 
1927 #define GB_AUDIO_BUTTON_EVENT_PRESS     0x1
1928 #define GB_AUDIO_BUTTON_EVENT_RELEASE       0x2
1929 
1930 #define GB_AUDIO_STREAMING_EVENT_UNSPECIFIED    0x1
1931 #define GB_AUDIO_STREAMING_EVENT_HALT       0x2
1932 #define GB_AUDIO_STREAMING_EVENT_INTERNAL_ERROR 0x3
1933 #define GB_AUDIO_STREAMING_EVENT_PROTOCOL_ERROR 0x4
1934 #define GB_AUDIO_STREAMING_EVENT_FAILURE    0x5
1935 #define GB_AUDIO_STREAMING_EVENT_UNDERRUN   0x6
1936 #define GB_AUDIO_STREAMING_EVENT_OVERRUN    0x7
1937 #define GB_AUDIO_STREAMING_EVENT_CLOCKING   0x8
1938 #define GB_AUDIO_STREAMING_EVENT_DATA_LEN   0x9
1939 
1940 #define GB_AUDIO_INVALID_INDEX          0xff
1941 
1942 /* enum snd_jack_types */
1943 #define GB_AUDIO_JACK_HEADPHONE         0x0000001
1944 #define GB_AUDIO_JACK_MICROPHONE        0x0000002
1945 #define GB_AUDIO_JACK_HEADSET           (GB_AUDIO_JACK_HEADPHONE | \
1946                          GB_AUDIO_JACK_MICROPHONE)
1947 #define GB_AUDIO_JACK_LINEOUT           0x0000004
1948 #define GB_AUDIO_JACK_MECHANICAL        0x0000008
1949 #define GB_AUDIO_JACK_VIDEOOUT          0x0000010
1950 #define GB_AUDIO_JACK_AVOUT         (GB_AUDIO_JACK_LINEOUT | \
1951                          GB_AUDIO_JACK_VIDEOOUT)
1952 #define GB_AUDIO_JACK_LINEIN            0x0000020
1953 #define GB_AUDIO_JACK_OC_HPHL           0x0000040
1954 #define GB_AUDIO_JACK_OC_HPHR           0x0000080
1955 #define GB_AUDIO_JACK_MICROPHONE2       0x0000200
1956 #define GB_AUDIO_JACK_ANC_HEADPHONE     (GB_AUDIO_JACK_HEADPHONE | \
1957                          GB_AUDIO_JACK_MICROPHONE | \
1958                          GB_AUDIO_JACK_MICROPHONE2)
1959 /* Kept separate from switches to facilitate implementation */
1960 #define GB_AUDIO_JACK_BTN_0         0x4000000
1961 #define GB_AUDIO_JACK_BTN_1         0x2000000
1962 #define GB_AUDIO_JACK_BTN_2         0x1000000
1963 #define GB_AUDIO_JACK_BTN_3         0x0800000
1964 
1965 struct gb_audio_pcm {
1966     __u8    stream_name[GB_AUDIO_PCM_NAME_MAX];
1967     __le32  formats;    /* GB_AUDIO_PCM_FMT_* */
1968     __le32  rates;      /* GB_AUDIO_PCM_RATE_* */
1969     __u8    chan_min;
1970     __u8    chan_max;
1971     __u8    sig_bits;   /* number of bits of content */
1972 } __packed;
1973 
1974 struct gb_audio_dai {
1975     __u8            name[AUDIO_DAI_NAME_MAX];
1976     __le16          data_cport;
1977     struct gb_audio_pcm capture;
1978     struct gb_audio_pcm playback;
1979 } __packed;
1980 
1981 struct gb_audio_integer {
1982     __le32  min;
1983     __le32  max;
1984     __le32  step;
1985 } __packed;
1986 
1987 struct gb_audio_integer64 {
1988     __le64  min;
1989     __le64  max;
1990     __le64  step;
1991 } __packed;
1992 
1993 struct gb_audio_enumerated {
1994     __le32  items;
1995     __le16  names_length;
1996     __u8    names[];
1997 } __packed;
1998 
1999 struct gb_audio_ctl_elem_info { /* See snd_ctl_elem_info in Linux source */
2000     __u8        type;       /* GB_AUDIO_CTL_ELEM_TYPE_* */
2001     __le16      dimen[4];
2002     union {
2003         struct gb_audio_integer     integer;
2004         struct gb_audio_integer64   integer64;
2005         struct gb_audio_enumerated  enumerated;
2006     } value;
2007 } __packed;
2008 
2009 struct gb_audio_ctl_elem_value { /* See snd_ctl_elem_value in Linux source */
2010     __le64              timestamp; /* XXX needed? */
2011     union {
2012         __le32  integer_value[2];   /* consider CTL_DOUBLE_xxx */
2013         __le64  integer64_value[2];
2014         __le32  enumerated_item[2];
2015     } value;
2016 } __packed;
2017 
2018 struct gb_audio_control {
2019     __u8    name[AUDIO_CONTROL_NAME_MAX];
2020     __u8    id;     /* 0-63 */
2021     __u8    iface;      /* GB_AUDIO_IFACE_* */
2022     __le16  data_cport;
2023     __le32  access;     /* GB_AUDIO_ACCESS_* */
2024     __u8    count;      /* count of same elements */
2025     __u8    count_values;   /* count of values, max=2 for CTL_DOUBLE_xxx */
2026     struct gb_audio_ctl_elem_info   info;
2027 } __packed;
2028 
2029 struct gb_audio_widget {
2030     __u8    name[AUDIO_WIDGET_NAME_MAX];
2031     __u8    sname[AUDIO_WIDGET_NAME_MAX];
2032     __u8    id;
2033     __u8    type;       /* GB_AUDIO_WIDGET_TYPE_* */
2034     __u8    state;      /* GB_AUDIO_WIDGET_STATE_* */
2035     __u8    ncontrols;
2036     struct gb_audio_control ctl[];  /* 'ncontrols' entries */
2037 } __packed;
2038 
2039 struct gb_audio_route {
2040     __u8    source_id;  /* widget id */
2041     __u8    destination_id; /* widget id */
2042     __u8    control_id; /* 0-63 */
2043     __u8    index;      /* Selection within the control */
2044 } __packed;
2045 
2046 struct gb_audio_topology {
2047     __u8    num_dais;
2048     __u8    num_controls;
2049     __u8    num_widgets;
2050     __u8    num_routes;
2051     __le32  size_dais;
2052     __le32  size_controls;
2053     __le32  size_widgets;
2054     __le32  size_routes;
2055     __le32  jack_type;
2056     /*
2057      * struct gb_audio_dai      dai[num_dais];
2058      * struct gb_audio_control  controls[num_controls];
2059      * struct gb_audio_widget   widgets[num_widgets];
2060      * struct gb_audio_route    routes[num_routes];
2061      */
2062     __u8    data[];
2063 } __packed;
2064 
2065 struct gb_audio_get_topology_size_response {
2066     __le16  size;
2067 } __packed;
2068 
2069 struct gb_audio_get_topology_response {
2070     struct gb_audio_topology    topology;
2071 } __packed;
2072 
2073 struct gb_audio_get_control_request {
2074     __u8    control_id;
2075     __u8    index;
2076 } __packed;
2077 
2078 struct gb_audio_get_control_response {
2079     struct gb_audio_ctl_elem_value  value;
2080 } __packed;
2081 
2082 struct gb_audio_set_control_request {
2083     __u8    control_id;
2084     __u8    index;
2085     struct gb_audio_ctl_elem_value  value;
2086 } __packed;
2087 
2088 struct gb_audio_enable_widget_request {
2089     __u8    widget_id;
2090 } __packed;
2091 
2092 struct gb_audio_disable_widget_request {
2093     __u8    widget_id;
2094 } __packed;
2095 
2096 struct gb_audio_get_pcm_request {
2097     __le16  data_cport;
2098 } __packed;
2099 
2100 struct gb_audio_get_pcm_response {
2101     __le32  format;
2102     __le32  rate;
2103     __u8    channels;
2104     __u8    sig_bits;
2105 } __packed;
2106 
2107 struct gb_audio_set_pcm_request {
2108     __le16  data_cport;
2109     __le32  format;
2110     __le32  rate;
2111     __u8    channels;
2112     __u8    sig_bits;
2113 } __packed;
2114 
2115 struct gb_audio_set_tx_data_size_request {
2116     __le16  data_cport;
2117     __le16  size;
2118 } __packed;
2119 
2120 struct gb_audio_activate_tx_request {
2121     __le16  data_cport;
2122 } __packed;
2123 
2124 struct gb_audio_deactivate_tx_request {
2125     __le16  data_cport;
2126 } __packed;
2127 
2128 struct gb_audio_set_rx_data_size_request {
2129     __le16  data_cport;
2130     __le16  size;
2131 } __packed;
2132 
2133 struct gb_audio_activate_rx_request {
2134     __le16  data_cport;
2135 } __packed;
2136 
2137 struct gb_audio_deactivate_rx_request {
2138     __le16  data_cport;
2139 } __packed;
2140 
2141 struct gb_audio_jack_event_request {
2142     __u8    widget_id;
2143     __u8    jack_attribute;
2144     __u8    event;
2145 } __packed;
2146 
2147 struct gb_audio_button_event_request {
2148     __u8    widget_id;
2149     __u8    button_id;
2150     __u8    event;
2151 } __packed;
2152 
2153 struct gb_audio_streaming_event_request {
2154     __le16  data_cport;
2155     __u8    event;
2156 } __packed;
2157 
2158 struct gb_audio_send_data_request {
2159     __le64  timestamp;
2160     __u8    data[];
2161 } __packed;
2162 
2163 
2164 /* Log */
2165 
2166 /* operations */
2167 #define GB_LOG_TYPE_SEND_LOG    0x02
2168 
2169 /* length */
2170 #define GB_LOG_MAX_LEN      1024
2171 
2172 struct gb_log_send_log_request {
2173     __le16  len;
2174     __u8    msg[];
2175 } __packed;
2176 
2177 #endif /* __GREYBUS_PROTOCOLS_H */
2178
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!