device_uart_attach_ls_callback(bundle->dev, NULL, NULL);
device_uart_attach_ms_callback(bundle->dev, NULL, NULL);
uart_receiver_cb_deinit(info);
uart_status_cb_deinit(info);
device_close(bundle->dev);
bundle->dev = NULL;
free(info);
}
static struct gb_operation_handler gb_uart_handlers[] = {
GB_HANDLER(GB_UART_PROTOCOL_VERSION, gb_uart_protocol_version),
GB_HANDLER(GB_UART_PROTOCOL_SEND_DATA, gb_uart_send_data),
GB_HANDLER(GB_UART_PROTOCOL_SET_LINE_CODING, gb_uart_set_line_coding),
GB_HANDLER(GB_UART_PROTOCOL_SET_CONTROL_LINE_STATE,
gb_uart_set_control_line_state),
GB_HANDLER(GB_UART_PROTOCOL_SEND_BREAK, gb_uart_send_break),
};
struct gb_driver uart_driver = {
.init = gb_uart_init,
.exit = gb_uart_exit,
.op_handlers = (struct gb_operation_handler*) gb_uart_handlers,
.op_handlers_count = ARRAY_SIZE(gb_uart_handlers),
};
/**
if (!response)
return GB_OP_NO_MEMORY;
response->temperature = 50;
return GB_OP_SUCCESS;
}
static int gb_battery_init(unsigned int cport)
{
return 0;
}
static struct gb_operation_handler gb_battery_handlers[] = {
GB_HANDLER(GB_BATTERY_TYPE_PROTOCOL_VERSION, gb_battery_protocol_version),
GB_HANDLER(GB_BATTERY_TYPE_TECHNOLOGY, gb_battery_technology),
GB_HANDLER(GB_BATTERY_TYPE_STATUS, gb_battery_status),
GB_HANDLER(GB_BATTERY_TYPE_MAX_VOLTAGE, gb_battery_max_voltage),
GB_HANDLER(GB_BATTERY_TYPE_PERCENT_CAPACITY, gb_battery_percent_capacity),
GB_HANDLER(GB_BATTERY_TYPE_TEMPERATURE, gb_battery_temperature),
GB_HANDLER(GB_BATTERY_TYPE_VOLTAGE, gb_battery_voltage),
GB_HANDLER(GB_BATTERY_TYPE_CURRENT, gb_battery_current),
GB_HANDLER(GB_BATTERY_TYPE_CAPACITY, gb_battery_capacity),
GB_HANDLER(GB_BATTERY_TYPE_SHUTDOWN_TEMP, gb_battery_shutdowntemp),
};
static struct gb_driver gb_battery_driver = {
.init = gb_battery_init,
.op_handlers = gb_battery_handlers,
.op_handlers_count = ARRAY_SIZE(gb_battery_handlers),
struct gb_svc_route_destroy_request *req;
int rc;
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);
rc = svc_route_destroy(req->intf1_id, req->intf2_id);
return gb_errno_to_op_result(rc);
}
static struct gb_operation_handler gb_svc_handlers[] = {
GB_HANDLER(GB_SVC_TYPE_INTF_DEVICE_ID, gb_svc_intf_device_id),
GB_HANDLER(GB_SVC_TYPE_CONN_CREATE, gb_svc_connection_create),
GB_HANDLER(GB_SVC_TYPE_CONN_DESTROY, gb_svc_connection_destroy),
GB_HANDLER(GB_SVC_TYPE_ROUTE_CREATE, gb_svc_route_create),
GB_HANDLER(GB_SVC_TYPE_ROUTE_DESTROY, gb_svc_route_destroy),
GB_HANDLER(GB_SVC_TYPE_DME_PEER_GET, gb_svc_dme_peer_get),
GB_HANDLER(GB_SVC_TYPE_DME_PEER_SET, gb_svc_dme_peer_set),
};
struct gb_driver svc_driver = {
.op_handlers = (struct gb_operation_handler*) gb_svc_handlers,
.op_handlers_count = ARRAY_SIZE(gb_svc_handlers),
};
void gb_svc_register(int cport) {
g_svc_cport = cport;
*/
static void gb_camera_exit(unsigned int cport)
{
DEBUGASSERT(cport == info->cport);
device_close(info->dev);
free(info);
info = NULL;
}
/**
* @brief Greybus Camera Protocol operation handler
*/
static struct gb_operation_handler gb_camera_handlers[] = {
GB_HANDLER(GB_CAMERA_TYPE_PROTOCOL_VERSION, gb_camera_protocol_version),
GB_HANDLER(GB_CAMERA_TYPE_CAPABILITIES, gb_camera_capabilities),
GB_HANDLER(GB_CAMERA_TYPE_CONFIGURE_STREAMS, gb_camera_configure_streams),
GB_HANDLER(GB_CAMERA_TYPE_CAPTURE, gb_camera_capture),
GB_HANDLER(GB_CAMERA_TYPE_FLUSH, gb_camera_flush),
GB_HANDLER(GB_CAMERA_TYPE_METADATA, gb_camera_metadata),
};
/**
* @brief Greybus Camera Protocol driver ops
*/
static struct gb_driver gb_camera_driver = {
.init = gb_camera_init,
.exit = gb_camera_exit,
.op_handlers = gb_camera_handlers,
.op_handlers_count = ARRAY_SIZE(gb_camera_handlers),
}
unipro_reset_cport(le16_to_cpu(request->cport_id), NULL, NULL);
retval = gb_stop_listening(le16_to_cpu(request->cport_id));
if (retval) {
gb_error("Can not disconnect cport %d: error %d\n",
le16_to_cpu(request->cport_id), retval);
return GB_OP_INVALID;
}
return GB_OP_SUCCESS;
}
static struct gb_operation_handler gb_control_handlers[] = {
GB_HANDLER(GB_CONTROL_TYPE_PROTOCOL_VERSION, gb_control_protocol_version),
GB_HANDLER(GB_CONTROL_TYPE_PROBE_AP, gb_control_probe_ap),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST_SIZE, gb_control_get_manifest_size),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST, gb_control_get_manifest),
GB_HANDLER(GB_CONTROL_TYPE_CONNECTED, gb_control_connected),
GB_HANDLER(GB_CONTROL_TYPE_DISCONNECTED, gb_control_disconnected),
};
struct gb_driver control_driver = {
.op_handlers = (struct gb_operation_handler*) gb_control_handlers,
.op_handlers_count = ARRAY_SIZE(gb_control_handlers),
};
void gb_control_register(int cport)
{
gb_register_driver(cport, &control_driver);
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;
}
static struct gb_operation_handler gb_control_handlers[] = {
GB_HANDLER(GB_CONTROL_TYPE_PROTOCOL_VERSION, gb_control_protocol_version),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST_SIZE, gb_control_get_manifest_size),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST, gb_control_get_manifest),
GB_HANDLER(GB_CONTROL_TYPE_CONNECTED, gb_control_connected),
GB_HANDLER(GB_CONTROL_TYPE_DISCONNECTED, gb_control_disconnected),
GB_HANDLER(GB_CONTROL_TYPE_GET_IDS, gb_control_get_ids),
GB_HANDLER(GB_CONTROL_TYPE_REBOOT, gb_control_reboot),
};
struct gb_driver control_driver = {
.op_handlers = (struct gb_operation_handler*) gb_control_handlers,
.op_handlers_count = ARRAY_SIZE(gb_control_handlers),
};
void gb_control_register(int cport)
{
err:
device_close(ptp_info->dev);
free(ptp_info);
done:
return ret;
}
static void gb_ptp_exit(unsigned int cport)
{
device_close(ptp_info->dev);
free(ptp_info);
}
static struct gb_operation_handler gb_ptp_handlers[] = {
GB_HANDLER(GB_PTP_TYPE_PROTOCOL_VERSION, gb_ptp_protocol_version),
GB_HANDLER(GB_PTP_TYPE_GET_FUNCTIONALITY, gp_ptp_get_functionality),
GB_HANDLER(GB_PTP_TYPE_SET_CURRENT_FLOW, gb_ptp_set_current_flow),
GB_HANDLER(GB_PTP_TYPE_SET_MAX_INPUT_CURRENT, gb_ptp_set_max_input_current),
GB_HANDLER(GB_PTP_TYPE_GET_MAX_OUTPUT_CURRENT, gb_ptp_get_max_output_current),
GB_HANDLER(GB_PTP_TYPE_EXT_POWER_PRESENT, gb_ptp_ext_power_present),
GB_HANDLER(GB_PTP_TYPE_POWER_REQUIRED, gb_ptp_power_required),
GB_HANDLER(GB_PTP_TYPE_POWER_AVAILABLE, gb_ptp_power_available),
GB_HANDLER(GB_PTP_TYPE_POWER_SOURCE, gb_ptp_power_source)
};
static struct gb_driver gb_ptp_driver = {
.init = gb_ptp_init,
.exit = gb_ptp_exit,
.connected = gb_ptp_connected,
.disconnected = gb_ptp_disconnected,
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);
}
static struct gb_operation_handler gb_control_handlers[] = {
GB_HANDLER(GB_CONTROL_TYPE_PROTOCOL_VERSION, gb_control_protocol_version),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST_SIZE, gb_control_get_manifest_size),
GB_HANDLER(GB_CONTROL_TYPE_GET_MANIFEST, gb_control_get_manifest),
GB_HANDLER(GB_CONTROL_TYPE_CONNECTED, gb_control_connected),
GB_HANDLER(GB_CONTROL_TYPE_DISCONNECTED, gb_control_disconnected),
GB_HANDLER(GB_CONTROL_TYPE_INTERFACE_VERSION, gb_control_interface_version),
/* XXX SW-4136: see control-gb.h */
/*GB_HANDLER(GB_CONTROL_TYPE_INTF_POWER_STATE_SET, gb_control_intf_pwr_set),
GB_HANDLER(GB_CONTROL_TYPE_BUNDLE_POWER_STATE_SET, gb_control_bundle_pwr_set),*/
GB_HANDLER(GB_CONTROL_TYPE_TIMESYNC_ENABLE, gb_control_timesync_enable),
GB_HANDLER(GB_CONTROL_TYPE_TIMESYNC_DISABLE, gb_control_timesync_disable),
GB_HANDLER(GB_CONTROL_TYPE_TIMESYNC_AUTHORITATIVE, gb_control_timesync_authoritative),
GB_HANDLER(GB_CONTROL_TYPE_TIMESYNC_GET_LAST_EVENT, gb_control_timesync_get_last_event),
};
struct gb_driver control_driver = {
return GB_OP_SUCCESS;
}
static uint8_t gb_vibrator_vibrator_off(struct gb_operation *operation)
{
// Deactivate the GPIO line, somehow.
gpio_activate(GB_VIBRATOR_DUMMY_GPIO);
gpio_set_value(GB_VIBRATOR_DUMMY_GPIO, 0);
gpio_deactivate(GB_VIBRATOR_DUMMY_GPIO);
return GB_OP_SUCCESS;
}
static struct gb_operation_handler gb_vibrator_handlers[] = {
GB_HANDLER(GB_VIBRATOR_TYPE_PROTOCOL_VERSION, gb_vibrator_protocol_version),
GB_HANDLER(GB_VIBRATOR_TYPE_VIBRATOR_ON, gb_vibrator_vibrator_on),
GB_HANDLER(GB_VIBRATOR_TYPE_VIBRATOR_OFF, gb_vibrator_vibrator_off),
};
static struct gb_driver gb_vibrator_driver = {
.op_handlers = gb_vibrator_handlers,
.op_handlers_count = ARRAY_SIZE(gb_vibrator_handlers),
};
void gb_vibrator_register(int cport)
{
gb_register_driver(cport, &gb_vibrator_driver);
}
