static uint8_t gb_svc_dme_peer_set(struct gb_operation *op) {
struct gb_svc_dme_peer_set_request *req;
struct gb_svc_dme_peer_set_response *resp;
int rc;
uint16_t attr, selector;
uint32_t value;
if (gb_operation_get_request_payload_size(op) < sizeof(*req)) {
gb_error("dropping short message\n");
return GB_OP_INVALID;
}
req = gb_operation_get_request_payload(op);
resp = gb_operation_alloc_response(op, sizeof(*resp));
if (!resp) {
return GB_OP_NO_MEMORY;
}
attr = le16_to_cpu(req->attr);
selector = le16_to_cpu(req->selector);
value = le32_to_cpu(req->value);
rc = svc_dme_peer_set(req->intf_id, attr, selector, value,
&resp->result_code);
resp->result_code = cpu_to_le16(resp->result_code);
return gb_errno_to_op_result(rc);
}
/**
* @brief Flush the camera capture
*
* The Flush operation calls camera driver to flush capture.
*
* @param operation pointer to structure of Greybus operation message
* @return GB_OP_SUCCESS on success, error code on failure
*/
static uint8_t gb_camera_flush(struct gb_operation *operation)
{
struct gb_camera_flush_response *response;
uint32_t request_id = 0;
int ret;
lldbg("gb_camera_flush() + \n");
if (info->state != STATE_STREAMING && info->state != STATE_CONFIGURED) {
return GB_OP_INVALID;
}
ret = device_camera_flush(info->dev, &request_id);
if (ret) {
return gb_errno_to_op_result(ret);
}
info->state = STATE_CONFIGURED;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response) {
return GB_OP_NO_MEMORY;
}
response->request_id = cpu_to_le32(request_id);
lldbg(" request_id = %d + \n", request_id);
lldbg("gb_camera_flush() + \n");
return GB_OP_SUCCESS;
}
static uint8_t gb_control_get_ids(struct gb_operation *operation)
{
struct gb_control_get_ids_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->fw_version =
cpu_to_le32(CONFIG_VERSION_MAJOR << 16 | CONFIG_VERSION_MINOR);
#ifdef CONFIG_ARCH_UID
/* Populate the UID from the microprocessor */
up_getuid(&response->uid_high, &response->uid_low);
#endif
#ifdef CONFIG_ARCH_CHIPID
up_getchipid(&response->unipro_mfg_id, &response->unipro_prod_id);
#endif
#ifdef CONFIG_ARCH_BOARDID
up_getboardid(&response->ara_vend_id, &response->ara_prod_id);
#endif
return GB_OP_SUCCESS;
}
/**
* @brief Get Camera capabilities
*
* This operation retrieves the list of capabilities of the Camera Module and
* then returns to host.
*
* @param operation Pointer to structure of Greybus operation.
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_camera_capabilities(struct gb_operation *operation)
{
struct gb_camera_capabilities_response *response;
const uint8_t *caps;
size_t size;
int ret;
lldbg("gb_camera_capabilities() + \n");
if (info->state < STATE_UNCONFIGURED) {
lldbg("state error %d \n", info->state);
return GB_OP_INVALID;
}
/* Retrieve the capabilities and their size. */
ret = device_camera_capabilities(info->dev, &size, &caps);
if (ret) {
return gb_errno_to_op_result(ret);
}
if (size > GB_MAX_PAYLOAD_SIZE) {
return GB_OP_NO_MEMORY;
}
response = gb_operation_alloc_response(operation, sizeof(*response) + size);
if (!response) {
return GB_OP_NO_MEMORY;
}
memcpy(response->capabilities, caps, size);
lldbg("gb_camera_capabilities() - \n");
return GB_OP_SUCCESS;
}
static uint8_t gb_control_get_manifest_size(struct gb_operation *operation)
{
struct gb_control_get_manifest_size_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->size = cpu_to_le16(get_manifest_size());
return GB_OP_SUCCESS;
}
/**
* @brief Protocol get version function.
*
* Returns the major and minor Greybus UART protocol version number supported
* by the UART device.
*
* @param operation The pointer to structure of gb_operation.
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_uart_protocol_version(struct gb_operation *operation)
{
struct gb_uart_proto_version_response *response = NULL;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->major = GB_UART_VERSION_MAJOR;
response->minor = GB_UART_VERSION_MINOR;
return GB_OP_SUCCESS;
}
static uint8_t gb_control_interface_version(struct gb_operation *operation)
{
struct gb_control_interface_version_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->major = le16_to_cpu(GB_INTERFACE_VERSION_MAJOR);
response->minor = le16_to_cpu(GB_INTERFACE_VERSION_MINOR);
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_max_voltage(struct gb_operation *operation)
{
struct gb_battery_max_voltage_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->voltage = 3800;
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_status(struct gb_operation *operation)
{
struct gb_battery_status_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->status = GB_BATTERY_STATUS_FULL;
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_technology(struct gb_operation *operation)
{
struct gb_battery_technology_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->technology = GB_BATTERY_TECH_LIPO;
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_capacity(struct gb_operation *operation)
{
struct gb_battery_capacity_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->capacity = 150;
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_shutdowntemp(struct gb_operation *operation)
{
struct gb_battery_temperature_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->temperature = 50;
return GB_OP_SUCCESS;
}
static uint8_t gb_battery_protocol_version(struct gb_operation *operation)
{
struct gb_battery_proto_version_response *response;
gb_info("%s()\n", __func__);
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
response->major = GB_BATTERY_VERSION_MAJOR;
response->minor = GB_BATTERY_VERSION_MINOR;
return GB_OP_SUCCESS;
}
/**
* @brief Get battery current voltage in microvolt .
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_voltage(struct gb_operation *operation)
{
struct gb_battery_voltage_response *response;
uint32_t voltage = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_voltage(batt_dev, &voltage);
response->voltage = cpu_to_le32(voltage);
return gb_errno_to_op_result(ret);
}
/**
* @brief Get battery status.
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_status(struct gb_operation *operation)
{
struct gb_battery_status_response *response;
uint16_t status = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_status(batt_dev, &status);
response->status = cpu_to_le16(status);
return gb_errno_to_op_result(ret);
}
/**
* @brief Get battery total capacity in mAh.
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_capacity(struct gb_operation *operation)
{
struct gb_battery_capacity_response *response;
uint32_t capacity = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_total_capacity(batt_dev, &capacity);
response->capacity = cpu_to_le32(capacity);
return gb_errno_to_op_result(ret);
}
/**
* @brief Get battery shutdown temperature in 0.1 Celsius.
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_shutdown_temp(struct gb_operation *operation)
{
struct gb_battery_shutdown_temperature_response *response;
int temp = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_shutdown_temp(batt_dev, &temp);
response->temperature = cpu_to_le32(temp);
return gb_errno_to_op_result(ret);
}
static uint8_t gb_control_timesync_get_last_event(
struct gb_operation *operation)
{
uint64_t frame_time;
struct gb_control_timesync_get_last_event_response *response;
int retval;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
retval = timesync_get_last_event(&frame_time);
if (!retval)
response->frame_time = cpu_to_le64(frame_time);
return gb_errno_to_op_result(retval);
}
/**
* @brief Get battery current in microampere.
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_current(struct gb_operation *operation)
{
struct gb_battery_current_response *response;
int current = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_current(batt_dev, ¤t);
response->current = cpu_to_le32(current);
return gb_errno_to_op_result(ret);
}
/**
* @brief Get the battery adapter control technology type.
*
* @param operation The pointer to structure of gb_operation.
*
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_battery_technology(struct gb_operation *operation)
{
struct gb_battery_technology_response *response;
uint32_t tech = 0;
int ret = 0;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
ret = device_battery_technology(batt_dev, &tech);
response->technology = cpu_to_le32(tech);
return gb_errno_to_op_result(ret);
}
static uint8_t gb_ptp_power_source(struct gb_operation *operation)
{
struct gb_ptp_power_source_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
#if !defined (CONFIG_GREYBUS_PTP_INT_SND_NEVER) || defined (CONFIG_GREYBUS_PTP_EXT_SUPPORTED)
if (device_ptp_power_source(ptp_info->dev, &response->source))
return GB_OP_UNKNOWN_ERROR;
#else
response->source = PTP_POWER_AVAILABLE_NONE;
#endif
return GB_OP_SUCCESS;
}
static uint8_t gb_ptp_power_required(struct gb_operation *operation)
{
struct gb_ptp_power_required_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
#ifndef CONFIG_GREYBUS_PTP_INT_RCV_NEVER
if (device_ptp_power_required(ptp_info->dev, &response->required))
return GB_OP_UNKNOWN_ERROR;
#else
response->required = PTP_POWER_NOT_REQUIRED;
#endif
return GB_OP_SUCCESS;
}
/**
* @brief Returns the major and minor Greybus Camera Protocol version number
*
* This operation returns the major and minor version number supported by
* Greybus Camera Protocol
*
* @param operation Pointer to structure of Greybus operation.
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_camera_protocol_version(struct gb_operation *operation)
{
struct gb_camera_version_response *response;
lldbg("gb_camera_protocol_version() + \n");
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response) {
return GB_OP_NO_MEMORY;
}
response->major = GB_CAMERA_VERSION_MAJOR;
response->minor = GB_CAMERA_VERSION_MINOR;
lldbg("gb_camera_protocol_version() - \n");
return GB_OP_SUCCESS;
}
static uint8_t __attribute__((unused)) gb_control_intf_pwr_set(struct gb_operation *operation)
{
struct gb_control_intf_pwr_set_request *request;
struct gb_control_intf_pwr_set_response *response;
if (gb_operation_get_request_payload_size(operation) < sizeof(*request)) {
gb_error("dropping short message\n");
return GB_OP_INVALID;
}
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
request = gb_operation_get_request_payload(operation);
(void)request;
return GB_OP_PROTOCOL_BAD;
}
static uint8_t gp_ptp_get_functionality(struct gb_operation *operation)
{
struct gb_ptp_get_functionality_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
#if defined (CONFIG_GREYBUS_PTP_INT_SND_NEVER)
response->int_snd = PTP_INT_SND_NEVER;
#elif defined (CONFIG_GREYBUS_PTP_INT_SND_SUPPLEMENTAL)
response->int_snd = PTP_INT_SND_SUPPLEMENTAL;
#elif defined (CONFIG_GREYBUS_PTP_INT_SND_LOW_BATT_SAVER)
response->int_snd = PTP_INT_SND_LOW_BATT_SAVER;
#else
#error "define send power capabilities"
#endif
#if defined (CONFIG_GREYBUS_PTP_INT_RCV_NEVER)
response->int_rcv = PTP_INT_RCV_NEVER;
#elif defined (CONFIG_GREYBUS_PTP_INT_RCV_FIRST)
response->int_rcv = PTP_INT_RCV_FIRST;
#elif defined (CONFIG_GREYBUS_PTP_INT_RCV_SECOND)
response->int_rcv = PTP_INT_RCV_SECOND;
#elif defined (CONFIG_GREYBUS_PTP_INT_RCV_PARALLEL)
response->int_rcv = PTP_INT_RCV_PARALLEL;
#else
#error "define receive power capabilities"
#endif
#if defined (CONFIG_GREYBUS_PTP_EXT_NONE)
response->ext = PTP_EXT_NONE;
#elif defined (CONFIG_GREYBUS_PTP_EXT_SUPPORTED)
response->ext = PTP_EXT_SUPPORTED;
#else
#error "define external power sources capabilities"
#endif
response->unused = 0;
return GB_OP_SUCCESS;
}
static uint8_t gb_control_get_manifest(struct gb_operation *operation)
{
struct gb_control_get_manifest_response *response;
struct greybus_manifest_header *mh;
int size = get_manifest_size();
response = gb_operation_alloc_response(operation, size);
if (!response)
return GB_OP_NO_MEMORY;
mh = get_manifest_blob();
if (!mh) {
gb_error("Failed to get a valid manifest\n");
return GB_OP_INVALID;
}
memcpy(response->data, mh, size);
return GB_OP_SUCCESS;
}
static uint8_t gb_ptp_get_max_output_current(struct gb_operation *operation)
{
struct gb_ptp_get_max_output_current_response *response;
uint32_t current;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
#if !defined (CONFIG_GREYBUS_PTP_INT_SND_NEVER) || defined (CONFIG_GREYBUS_PTP_EXT_SUPPORTED)
if (device_ptp_get_max_output_current(ptp_info->dev, ¤t))
return GB_OP_UNKNOWN_ERROR;
#else
current = 0;
#endif
response->current = cpu_to_le32(current);
return GB_OP_SUCCESS;
}
static uint8_t gb_ptp_ext_power_present(struct gb_operation *operation)
{
struct gb_ptp_ext_power_present_response *response;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response)
return GB_OP_NO_MEMORY;
#if defined (CONFIG_GREYBUS_PTP_EXT_SUPPORTED)
if (device_ptp_ext_power_present(ptp_info->dev, &response->present))
return GB_OP_UNKNOWN_ERROR;
if (ptp_info->host_major == PTP_EXT_POWER_PRESENT_LAST_SUPPORTED_MAJOR &&
ptp_info->host_minor <= PTP_EXT_POWER_PRESENT_LAST_SUPPORTED_MINOR &&
response->present != PTP_EXT_POWER_NOT_PRESENT)
response->present = PTP_EXT_POWER_PRESENT;
#else
response->present = PTP_EXT_POWER_NOT_PRESENT;
#endif
return GB_OP_SUCCESS;
}
/**
* @brief Get Camera capabilities
*
* This operation retrieves the list of capabilities of the Camera Module and
* then returns to host.
*
* @param operation Pointer to structure of Greybus operation.
* @return GB_OP_SUCCESS on success, error code on failure.
*/
static uint8_t gb_camera_capabilities(struct gb_operation *operation)
{
struct gb_camera_capabilities_response *response;
uint8_t *capabilities;
uint16_t size;
int ret;
lldbg("gb_camera_capabilities() + \n");
if (info->state < STATE_UNCONFIGURED) {
lldbg("state error %d \n", info->state);
return GB_OP_INVALID;
}
ret = device_camera_get_required_size(info->dev, SIZE_CAPABILITIES, &size);
if (ret) {
return gb_errno_to_op_result(ret);
}
response = gb_operation_alloc_response(operation, sizeof(*response) + size);
if (!response) {
return GB_OP_NO_MEMORY;
}
/* camera module capabilities */
ret = device_camera_capabilities(info->dev, &size, capabilities);
if (ret) {
return gb_errno_to_op_result(ret);
}
response->size = cpu_to_le16(size);
memcpy(response->capabilities, &capabilities, size);
lldbg("gb_camera_capabilities() - \n");
return GB_OP_SUCCESS;
}
static uint8_t gb_ptp_protocol_version(struct gb_operation *operation)
{
struct gb_ptp_proto_version_request *request;
struct gb_ptp_proto_version_response *response;
if (gb_operation_get_request_payload_size(operation) < sizeof(*request)) {
gb_error("dropping short message\n");
return GB_OP_INVALID;
}
request = gb_operation_get_request_payload(operation);
ptp_info->host_major = request->major;
ptp_info->host_minor = request->minor;
response = gb_operation_alloc_response(operation, sizeof(*response));
if (!response) {
return GB_OP_NO_MEMORY;
}
response->major = GB_PTP_VERSION_MAJOR;
response->minor = GB_PTP_VERSION_MINOR;
return GB_OP_SUCCESS;
}
