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; }