From: taeyoung Date: Fri, 9 Sep 2016 11:30:02 +0000 (+0900) Subject: Add USB config HAL implementation for slp-gadget X-Git-Tag: submit/tizen/20160927.110043^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ebcf7b41762c202164a5e75a220f9c25f8a78b7f;p=platform%2Fadaptation%2Fsamsung_exynos%2Fdevice-manager-plugin-artik.git Add USB config HAL implementation for slp-gadget This implementation of USB config HAL allows to apply abstract gadget description received from USB gadget HAL to USB gadget subsystem in Kernel via slp-gadget sysfs interface. Change-Id: I3a621c9af78339b582bb46a5c3939bd52ab3e6d2 Signed-off-by: Krzysztof Opasiak --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 6e31fe0..06d4bc9 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,3 +8,4 @@ ADD_SUBDIRECTORY(hw/display) ADD_SUBDIRECTORY(hw/external_connection) ADD_SUBDIRECTORY(hw/touchscreen) ADD_SUBDIRECTORY(hw/usb_gadget) +ADD_SUBDIRECTORY(hw/usb_client) diff --git a/hw/usb_client/CMakeLists.txt b/hw/usb_client/CMakeLists.txt new file mode 100644 index 0000000..f7b32c1 --- /dev/null +++ b/hw/usb_client/CMakeLists.txt @@ -0,0 +1,19 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(usb_client C) + +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) + +INCLUDE(FindPkgConfig) +pkg_check_modules(usb_client_pkgs REQUIRED hwcommon dlog glib-2.0) + +FOREACH(flag ${usb_client_pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -fvisibility=hidden") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") + +ADD_LIBRARY(${PROJECT_NAME} MODULE usb_client.c ../shared.c) +TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${usb_client_pkgs_LDFLAGS}) +SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES PREFIX "") +INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${LIB_INSTALL_DIR}/hw COMPONENT RuntimeLibraries) diff --git a/hw/usb_client/usb_client.c b/hw/usb_client/usb_client.c new file mode 100644 index 0000000..f63354d --- /dev/null +++ b/hw/usb_client/usb_client.c @@ -0,0 +1,646 @@ +/* + * device-node + * + * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "../shared.h" + +#include +#include +#include + +#define zalloc(amount) calloc(1, amount) + +#define MAX_GADGET_STR_LEN 256 +#define MAX_FUNCS 32 + +#define LEGACY_ROOTPATH "/sys/class/usb_mode/usb0" + +/* Device descriptor values */ +#define LEGACY_ID_VENDOR_PATH LEGACY_ROOTPATH"/idVendor" +#define LEGACY_ID_PRODUCT_PATH LEGACY_ROOTPATH"/idProduct" +#define LEGACY_BCD_DEVICE_PATH LEGACY_ROOTPATH"/bcdDevice" +#define LEGACY_CLASS_PATH LEGACY_ROOTPATH"/bDeviceClass" +#define LEGACY_SUBCLASS_PATH LEGACY_ROOTPATH"/bDeviceSubClass" +#define LEGACY_PROTOCOL_PATH LEGACY_ROOTPATH"/bDeviceProtocol" + +/* Strings */ +#define LEGACY_IMANUFACTURER_PATH LEGACY_ROOTPATH"/iManufacturer" +#define LEGACY_IPRODUCT_PATH LEGACY_ROOTPATH"/iProduct" +#define LEGACY_ISERIAL_PATH LEGACY_ROOTPATH"/iSerial" + +/* Functions in each config */ +#define LEGACY_CONFIG_1_PATH LEGACY_ROOTPATH"/funcs_fconf" +#define LEGACY_CONFIG_2_PATH LEGACY_ROOTPATH"/funcs_sconf" +/* should be single char */ +#define LEGACY_FUNC_SEP "," + +/* ON/OFF switch */ +#define LEGACY_ENABLE_PATH LEGACY_ROOTPATH"/enable" +#define LEGACY_ENABLE "1" +#define LEGACY_DISABLE "0" + +#define LEGACY_BMATTRIBUTES ((1 << 7) | (1 << 6)) +#define LEGACY_MAX_POWER 500 + +/* +5 to be always big enough */ +#define INT_BUF_SIZE (sizeof(int)*8 + 5) + +static int get_int_from_file(char *path, int *_val) +{ + char buf[INT_BUF_SIZE]; + char *endptr; + long int val; + int ret; + + ret = sys_get_str(path, buf, sizeof(buf)); + if (ret) + return ret; + + val = strtol(buf, &endptr, 0); + if (val == LONG_MIN || val == LONG_MAX || + buf[0] == '\0' || (*endptr != '\0' && *endptr != '\n') + || val > INT_MAX) + return -EINVAL; + + *_val = (int)val; + return 0; +} + +static int legacy_read_gadget_attrs_strs(struct usb_gadget *gadget) +{ + int val; + int ret; + /* We assume that values received from kernel will be valid */ +#define GET_VALUE_FROM_SYSFS(path, field, type) \ + do { \ + ret = get_int_from_file(path, &val); \ + if (ret) \ + return ret; \ + \ + gadget->attrs.field = (type)val; \ + } while (0) + + GET_VALUE_FROM_SYSFS(LEGACY_CLASS_PATH, bDeviceClass, uint8_t); + GET_VALUE_FROM_SYSFS(LEGACY_SUBCLASS_PATH, bDeviceSubClass, uint8_t); + GET_VALUE_FROM_SYSFS(LEGACY_PROTOCOL_PATH, bDeviceProtocol, uint8_t); + GET_VALUE_FROM_SYSFS(LEGACY_ID_VENDOR_PATH, idVendor, uint16_t); + GET_VALUE_FROM_SYSFS(LEGACY_ID_PRODUCT_PATH, idVendor, uint16_t); + GET_VALUE_FROM_SYSFS(LEGACY_BCD_DEVICE_PATH, bcdDevice, uint16_t); +#undef GET_VALUE_FROM_SYSFS + +#define GET_STRING_FROM_SYSFS(path, field) \ + do { \ + char buf[MAX_GADGET_STR_LEN]; \ + \ + ret = sys_get_str(path, buf, sizeof(buf)); \ + if (ret) \ + goto err_##field; \ + \ + gadget->strs[0].field = strdup(buf); \ + if (!gadget->strs[0].field) { \ + ret = -ENOMEM; \ + goto err_##field; \ + } \ + } while (0) + + GET_STRING_FROM_SYSFS(LEGACY_IMANUFACTURER_PATH, manufacturer); + GET_STRING_FROM_SYSFS(LEGACY_IPRODUCT_PATH, product); + GET_STRING_FROM_SYSFS(LEGACY_ISERIAL_PATH, serial); +#undef GET_STRING_FROM_SYSFS + + return 0; + +err_serial: + free(gadget->strs[0].product); +err_product: + free(gadget->strs[0].manufacturer); +err_manufacturer: + return ret; +} + +static int legacy_find_func(const char *name) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(_available_funcs); ++i) + if (!strcmp(name, _available_funcs[i]->name)) + return i; + + return -1; +} + +static struct usb_function *legacy_find_func_in_gadget( + struct usb_gadget *gadget, const char *name) +{ + int i; + + for (i = 0; gadget->funcs[i]; ++i) + if (!strcmp(name, gadget->funcs[i]->name)) + return gadget->funcs[i]; + return NULL; +} + +static int legacy_alloc_config(int n_funcs, struct usb_configuration **_config) +{ + struct usb_configuration *config; + + config = zalloc(sizeof(*config)); + if (!config) + goto out; + + config->strs = calloc(1, sizeof(*config->strs)); + if (!config->strs) + goto free_config; + + config->funcs = calloc(n_funcs + 1, sizeof(*config->funcs)); + if (!config->funcs) + goto free_strs; + + /* + * We cannot read correct values + * so assume that they are always default + */ + config->attrs.bmAttributs = LEGACY_BMATTRIBUTES; + config->attrs.MaxPower = LEGACY_MAX_POWER; + + *_config = config; + + return 0; +free_strs: + free(config->strs); +free_config: + free(config); +out: + return -ENOMEM; +} + +static int legacy_alloc_new_func(struct usb_gadget *gadget, const char *fname, + struct usb_function **_func) +{ + struct usb_function *func; + int ret; + + ret = legacy_find_func(fname); + if (ret < 0) + return -ENOTSUP; + + ret = _available_funcs[ret]->clone(_available_funcs[ret], &func); + if (ret) + return ret; + + *_func = func; + return 0; +} + +static int legacy_read_config(struct usb_gadget *gadget, + char *cpath, + struct usb_configuration **_config) +{ + struct usb_configuration *config; + char buf[MAX_GADGET_STR_LEN]; + char *begin = buf; + char *fname; + char *sep = LEGACY_FUNC_SEP; + int i, f_cnt; + int f_idx; + int ret; + + ret = sys_get_str(cpath, buf, sizeof(buf)); + if (ret) + return ret; + + /* Empty */ + if (buf[0] == '\0' || buf[0] == '\n') + return 0; + + /* count number of functions in this config */ + f_cnt = 1; + for (i = 0; buf[i] != '\0'; ++i) + if (buf[i] == sep[0]) + ++f_cnt; + + ret = legacy_alloc_config(f_cnt, &config); + if (ret) + return ret; + + f_idx = 0; + for (fname = strsep(&begin, sep); fname; fname = strsep(&begin, sep)) { + struct usb_function *func; + + func = legacy_find_func_in_gadget(gadget, fname); + if (!func) { + /* new function not added yet to gadget */ + ret = legacy_alloc_new_func(gadget, fname, &func); + if (!ret) + goto free_config; + } + + config->funcs[f_idx++] = func; + } + + *_config = config; + return 0; +free_config: + free(config->strs); + free(config->funcs); + free(config); + return ret; +} + +static int legacy_get_current_gadget(struct usb_client *usb, + struct usb_gadget **_gadget) +{ + struct usb_gadget *gadget; + struct usb_gadget_strings *strs; + struct usb_configuration **configs; + struct usb_function **funcs; + int i; + int ret = -ENOMEM; + + gadget = zalloc(sizeof(*gadget)); + if (!gadget) + goto out; + + strs = calloc(2, sizeof(*strs)); + if (!strs) + goto free_gadget; + + strs[0].lang_code = 0x409; + + gadget->strs = strs; + + ret = legacy_read_gadget_attrs_strs(gadget); + if (ret) + goto free_strs; + + /* There will be no more functions than bits in int */ + funcs = calloc(MAX_FUNCS, sizeof(*funcs)); + if (!funcs) + goto free_strs_with_content; + + gadget->funcs = funcs; + + /* slp-gadget use max 2 confiuration and NULL termination */ + configs = calloc(3, sizeof(*configs)); + if (!configs) + goto free_funcs; + + gadget->configs = configs; + + ret = legacy_read_config(gadget, LEGACY_CONFIG_1_PATH, configs + 0); + if (ret) + goto free_configs; + + ret = legacy_read_config(gadget, LEGACY_CONFIG_2_PATH, configs + 1); + if (ret) + goto free_config_1; + + *_gadget = gadget; + return 0; + +free_config_1: + free(configs[0]->funcs); + free(configs[0]->strs); + free(configs[0]); +free_configs: + free(configs); + for (i = 0; gadget->funcs[i]; ++i) + gadget->funcs[i]->free_func(gadget->funcs[i]); +free_funcs: + free(funcs); +free_strs_with_content: + free(gadget->strs[0].manufacturer); + free(gadget->strs[0].product); + free(gadget->strs[0].serial); +free_strs: + free(gadget->strs); +free_gadget: + free(gadget); +out: + return ret; +} + +static bool legacy_is_function_supported(struct usb_client *usb, + struct usb_function *func) +{ + int ret; + + /* + * TODO + * Instead of only checking whether we know this function + * we should also parse sysfs to check if it is build into + * slp-gadget. + */ + ret = legacy_find_func(func->name); + + return ret >= 0; +} + +static bool legacy_is_gadget_supported(struct usb_client *usb, + struct usb_gadget *gadget) +{ + int i, j; + + if (!gadget || !gadget->configs || !gadget->funcs) + return false; + + /* + * TODO + * Here is a good place to ensure that serial is immutable + */ + if (gadget->strs) { + /* only strings in US_en are allowed */ + if (gadget->strs[0].lang_code != 0x409 || + gadget->strs[1].lang_code) + return false; + } + + for (j = 0; gadget->configs[j]; ++j) { + struct usb_configuration *config = gadget->configs[j]; + + if (config->strs && config->strs[0].lang_code) + return false; + + if (!config->funcs) + return false; + + for (i = 0; config->funcs[i]; ++i) + if (!legacy_is_function_supported(usb, config->funcs[i])) + return false; + } + + if (j == 0 || j > 2) + return false; + + return true; +} + +/* TODO. Maybe move this to sys ? */ +static int legacy_set_int_hex(char *path, int val) +{ + char buf[MAX_GADGET_STR_LEN]; + int r; + + if (!path) + return -EINVAL; + + snprintf(buf, sizeof(buf), "%x", val); + r = sys_set_str(path, buf); + if (r < 0) + return r; + + return 0; +} + +static int legacy_set_gadget_attrs(struct usb_gadget_attrs *attrs) +{ + int ret; + + ret = sys_set_int(LEGACY_CLASS_PATH, attrs->bDeviceClass); + if (ret) + return ret; + + ret = sys_set_int(LEGACY_SUBCLASS_PATH, attrs->bDeviceSubClass); + if (ret) + return ret; + + ret = sys_set_int(LEGACY_PROTOCOL_PATH, attrs->bDeviceProtocol); + if (ret) + return ret; + + ret = legacy_set_int_hex(LEGACY_ID_VENDOR_PATH, attrs->idVendor); + if (ret) + return ret; + + ret = legacy_set_int_hex(LEGACY_ID_PRODUCT_PATH, attrs->idProduct); + if (ret) + return ret; + + ret = legacy_set_int_hex(LEGACY_BCD_DEVICE_PATH, attrs->bcdDevice); + + return ret; +} + +static int legacy_set_gadget_strs(struct usb_gadget_strings *strs) +{ + int ret = 0; + + /* + * TODO + * Here is a good place to ensure that serial is immutable + */ + + if (strs->manufacturer) { + ret = sys_set_str(LEGACY_IMANUFACTURER_PATH, + strs->manufacturer); + if (ret) + return ret; + } + + if (strs->product) { + ret = sys_set_str(LEGACY_IPRODUCT_PATH, + strs->product); + if (ret) + return ret; + } + + if (strs->serial) { + ret = sys_set_str(LEGACY_ISERIAL_PATH, + strs->serial); + if (ret) + return ret; + } + + return ret; +} + +static int legacy_set_gadget_config(char *cpath, + struct usb_configuration *config) +{ + char buf[MAX_GADGET_STR_LEN]; + int left = sizeof(buf); + char *pos = buf; + int ret; + int i; + + if (!config) { + buf[0] = '\n'; + buf[1] = '\0'; + goto empty_config; + } + + for (i = 0; config->funcs[i]; ++i) { + ret = snprintf(pos, left, "%s" LEGACY_FUNC_SEP, + config->funcs[i]->name); + if (ret >= left) + return -EOVERFLOW; + + pos += ret; + left -= ret; + } + + /* eliminate last separator */ + *(pos - 1) = '\0'; + +empty_config: + return sys_set_str(cpath, buf); +} + +static int legacy_reconfigure_gadget(struct usb_client *usb, + struct usb_gadget *gadget) +{ + int ret; + + if (!usb || !gadget || !legacy_is_gadget_supported(usb, gadget)) + return -EINVAL; + + ret = legacy_set_gadget_attrs(&gadget->attrs); + if (ret) + return ret; + + if (gadget->strs) { + ret = legacy_set_gadget_strs(gadget->strs + 0); + if (ret) + return ret; + } + + ret = legacy_set_gadget_config(LEGACY_CONFIG_1_PATH, gadget->configs[0]); + if (ret) + return ret; + + ret = legacy_set_gadget_config(LEGACY_CONFIG_2_PATH, gadget->configs[1]); + + return ret; +} + +static int legacy_enable(struct usb_client *usb) +{ + return sys_set_str(LEGACY_ENABLE_PATH, + LEGACY_ENABLE); +} + +static int legacy_disable(struct usb_client *usb) +{ + return sys_set_str(LEGACY_ENABLE_PATH, + LEGACY_DISABLE); +} + +static void legacy_free_config(struct usb_configuration *config) +{ + int i; + + if (!config) + return; + + if (config->strs) { + for (i = 0; config->strs[i].lang_code; ++i) + free(config->strs[i].config_str); + + free(config->strs); + } + + /* + * Each function will be free later, + * for now we cleanup only pointers. + */ + if (config->funcs) + free(config->funcs); + + free(config); +} + +static void legacy_free_gadget(struct usb_gadget *gadget) +{ + int i; + + if (!gadget) + return; + + if (gadget->strs) { + for (i = 0; gadget->strs[i].lang_code; ++i) { + free(gadget->strs[i].manufacturer); + free(gadget->strs[i].product); + free(gadget->strs[i].serial); + } + free(gadget->strs); + } + + if (gadget->configs) { + for (i = 0; gadget->configs[i]; ++i) + legacy_free_config(gadget->configs[i]); + + free(gadget->configs); + } + + if (gadget->funcs) { + for (i = 0; gadget->funcs[i]; ++i) + gadget->funcs[i]->free_func(gadget->funcs[i]); + + free(gadget->funcs); + } +} + +static int legacy_gadget_open(struct hw_info *info, + const char *id, struct hw_common **common) +{ + struct usb_client *legacy; + + if (!info || !common) + return -EINVAL; + + legacy = zalloc(sizeof(*legacy)); + if (!legacy) + return -ENOMEM; + + legacy->common.info = info; + legacy->get_current_gadget = legacy_get_current_gadget; + legacy->reconfigure_gadget = legacy_reconfigure_gadget; + legacy->is_gadget_supported = legacy_is_gadget_supported; + legacy->is_function_supported = legacy_is_function_supported; + legacy->enable = legacy_enable; + legacy->disable = legacy_disable; + legacy->free_gadget = legacy_free_gadget; + + *common = &legacy->common; + return 0; +} + +static int legacy_gadget_close(struct hw_common *common) +{ + struct usb_client *legacy; + + if (!common) + return -EINVAL; + + legacy = container_of(common, struct usb_client, + common); + + free(legacy); + return 0; +} + +HARDWARE_MODULE_STRUCTURE = { + .magic = HARDWARE_INFO_TAG, + .hal_version = HARDWARE_INFO_VERSION, + .device_version = USB_CLIENT_HARDWARE_DEVICE_VERSION, + .id = USB_CLIENT_HARDWARE_DEVICE_ID, + .name = "legacy-gadget", + .open = legacy_gadget_open, + .close = legacy_gadget_close, +};