void send_svc_event(int type, char *name, void *manifest)
{
int iid;
if (type == 0) {
if (manifest) {
parse_manifest_blob(manifest);
iid = get_interface_id(name);
if (iid > 0) {
gb_info("%s interface detected\n", name);
send_hot_plug(iid);
/*
* FIXME: hardcoded
* device ID
*/
send_link_up(iid, 2);
} else
gb_error("invalid interface ID, no hotplug plug event sent\n");
} else
gb_error("missing manifest blob, no hotplug event sent\n");
} else if (type == 1) {
iid = get_interface_id(name);
if (iid > 0) {
release_manifest_blob(manifest);
send_hot_unplug(iid);
gb_info("%s interface removed\n", name);
} else
gb_error("invalid interface ID, no hotplug unplug event sent\n");
}
}
static int gb_ptp_init(unsigned int cport)
{
int ret = 0;
ptp_info = zalloc(sizeof(*ptp_info));
if (!ptp_info) {
gb_info("%s(): failed to allocate memory\n", __func__);
ret = -ENOMEM;
goto done;
}
ptp_info->cport = cport;
ptp_info->dev = device_open(DEVICE_TYPE_PTP_HW, 0);
if (!ptp_info->dev) {
gb_info("%s(): failed to open device\n", __func__);
ret = -EIO;
goto err;
}
ret = device_ptp_register_callback(ptp_info->dev, gb_ptp_changed);
if (ret) {
gb_info("%s(): failed to register ptp changed callback\n", __func__);
goto err;
}
return 0;
err:
device_close(ptp_info->dev);
free(ptp_info);
done:
return ret;
}
/**
* @brief Report the error.
*
* When error in callback or thread, this function show error message to user.
*
* Note: as the discussion, only UART related errors such as overrun should be
* reported via UART protocol. So just show the generic errors to the console.
*
* @param error The error id.
* @param func_name The error function name.
* @return None.
*/
static void uart_report_error(int error, const char *func_name)
{
switch (error) {
case GB_UART_EVENT_PROTOCOL_ERROR:
gb_info("%s(): operation send error \n", func_name);
break;
case GB_UART_EVENT_DEVICE_ERROR:
gb_info("%s(): device io error \n", func_name);
break;
default:
break;
}
}
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_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_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_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;
}
int svc_handle(void *payload, int size)
{
struct svc_msg *m = (struct svc_msg *)payload;
switch (m->header.function_id) {
case SVC_FUNCTION_HANDSHAKE:
if (HS_VALID(m)) {
gb_info("AP handshake complete\n");
state = GBEMU_HS_COMPLETE;
sem_post(&svc_lock);
} else
gb_error("AP handshake invalid");
break;
case SVC_FUNCTION_UNIPRO_NETWORK_MANAGEMENT:
gb_debug("AP -> SVC set route to Device ID %d\n",
m->management.set_route.device_id);
break;
default:
gb_error("SVC message ID invalid");
return -1;
}
return size;
}
void gb_battery_register(int cport)
{
gb_info("%s()\n", __func__);
gb_register_driver(cport, &gb_battery_driver);
}
static uint8_t gb_battery_current(struct gb_operation *operation)
{
gb_info("%s()\n", __func__);
return GB_OP_SUCCESS;
}
/**
* @brief Protocol registering function.
*
* This function can be called by greybus to register the UART protocol.
*
* @param cport The number of CPort.
* @param bundle Bundle number.
* @return None.
*/
void gb_uart_register(int cport, int bundle)
{
gb_info("%s(): cport %d bundle %d\n", __func__, cport, bundle);
gb_register_driver(cport, bundle, &uart_driver);
}
/**
* @brief Protocol registering function.
*
* This function can be called by greybus to register the UART protocol.
*
* @param cport The number of CPort.
* @return None.
*/
void gb_uart_register(int cport)
{
gb_info("%s(): cport %d \n", __func__, cport);
gb_register_driver(cport, &uart_driver);
}
static uint8_t __attribute__((unused)) gb_control_bundle_pwr_set(struct gb_operation *operation)
{
struct gb_control_bundle_pwr_set_request *request;
struct gb_control_bundle_pwr_set_response *response;
struct device_pm_ops *pm_ops;
struct gb_bundle *bundle;
struct device *dev;
int status = 0;
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);
bundle = gb_bundle_get_by_id(request->bundle_id);
if (bundle == NULL) {
return GB_OP_INVALID;
}
dev = bundle->dev;
pm_ops = dev->driver->pm;
if (!pm_ops) {
gb_info("pm operations not supported by %s driver\n", dev->name);
response->result_code = GB_CONTROL_PWR_NOSUPP;
return GB_OP_SUCCESS;
}
switch (request->pwr_state) {
case GB_CONTROL_PWR_STATE_OFF:
if (pm_ops->poweroff) {
status = pm_ops->poweroff(dev);
} else {
gb_info("poweroff not supported by %s driver\n", dev->name);
response->result_code = GB_CONTROL_PWR_NOSUPP;
goto out;
}
break;
case GB_CONTROL_PWR_STATE_SUSPEND:
if (pm_ops->suspend) {
status = pm_ops->suspend(dev);
} else {
gb_info("suspend not supported by %s driver\n", dev->name);
response->result_code = GB_CONTROL_PWR_NOSUPP;
goto out;
}
break;
case GB_CONTROL_PWR_STATE_ON:
if (pm_ops->resume) {
status = pm_ops->resume(dev);
} else {
gb_info("resume not supported by %s driver\n", dev->name);
response->result_code = GB_CONTROL_PWR_NOSUPP;
goto out;
}
break;
default:
return GB_OP_PROTOCOL_BAD;
}
response->result_code = status ? GB_CONTROL_PWR_FAIL : GB_CONTROL_PWR_OK;
out:
return GB_OP_SUCCESS;
}
