From 8f48df0533c95036b85a59a1e2b690ccaa216e38 Mon Sep 17 00:00:00 2001 From: Henry Bruce Date: Wed, 27 May 2015 15:36:46 -0700 Subject: [PATCH] usb: Skeleton platform code for FTDI FT4222 USB to i2c bridge Signed-off-by: Henry Bruce Signed-off-by: Brendan Le Foll --- CMakeLists.txt | 1 + api/mraa/common.h | 16 ++ api/mraa/types.h | 5 + include/mraa_adv_func.h | 15 ++ include/mraa_func.h | 51 +++++ include/mraa_internal.h | 7 + include/mraa_internal_types.h | 14 +- include/usb/ftdi_ft4222.h | 40 ++++ src/CMakeLists.txt | 13 +- src/i2c/i2c.c | 131 ++++++++---- src/mraa.c | 33 ++- src/usb/CMakeLists.txt | 7 + src/usb/ftdi_ft4222.c | 377 ++++++++++++++++++++++++++++++++++ src/usb/usb.c | 51 +++++ src/x86/intel_edison_fab_c.c | 3 +- 15 files changed, 710 insertions(+), 54 deletions(-) create mode 100644 include/mraa_func.h create mode 100644 include/usb/ftdi_ft4222.h create mode 100644 src/usb/CMakeLists.txt create mode 100644 src/usb/ftdi_ft4222.c create mode 100644 src/usb/usb.c diff --git a/CMakeLists.txt b/CMakeLists.txt index b3f3bb9..4868221 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -54,6 +54,7 @@ option (BUILDSWIG "Build swig modules." ON) option (BUILDSWIGPYTHON "Build swig python modules." ON) option (BUILDSWIGNODE "Build swig node modules." ON) option (BUILDSWIGJAVA "Build Java API." OFF) +option (USBPLAT "Detection USB platform." ON) option (IPK "Generate IPK using CPack" OFF) option (RPM "Generate RPM using CPack" OFF) option (BUILDPYTHON3 "Use python3 for building/installing" OFF) diff --git a/api/mraa/common.h b/api/mraa/common.h index 22ad47d..41fee98 100644 --- a/api/mraa/common.h +++ b/api/mraa/common.h @@ -29,6 +29,14 @@ #define MRAA_PLATFORM_NAME_MAX_SIZE 64 #define MRAA_PIN_NAME_SIZE 12 +#define MRAA_SUB_PLATFORM_BIT_SHIFT 9 +#define MRAA_SUB_PLATFORM_MASK (1< + * Copyright (c) 2015 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#pragma once + +#include "common.h" +#include "mraa.h" +#include "types.h" + +typedef struct { + mraa_i2c_context (*i2c_init_raw) (unsigned int bus); + mraa_result_t (*i2c_frequency) (mraa_i2c_context dev, mraa_i2c_mode_t mode); + mraa_result_t (*i2c_address) (mraa_i2c_context dev, uint8_t addr); + int (*i2c_read) (mraa_i2c_context dev, uint8_t* data, int length); + uint8_t (*i2c_read_byte) (mraa_i2c_context dev); + uint8_t (*i2c_read_byte_data) (mraa_i2c_context dev, const uint8_t command); + uint16_t (*i2c_read_word_data) (mraa_i2c_context dev, const uint8_t command); + int (*i2c_read_bytes_data) (mraa_i2c_context dev, uint8_t command, uint8_t* data, int length); + mraa_result_t (*i2c_write) (mraa_i2c_context dev, const uint8_t* data, int length); + mraa_result_t (*i2c_write_byte) (mraa_i2c_context dev, const uint8_t data); + mraa_result_t (*i2c_write_byte_data) (mraa_i2c_context dev, const uint8_t data, const uint8_t command); + mraa_result_t (*i2c_write_word_data) (mraa_i2c_context dev, const uint16_t data, const uint8_t command); + mraa_result_t (*i2c_stop) (mraa_i2c_context dev); +} mraa_i2c_func_t; + + +typedef struct { + mraa_i2c_func_t* i2c; +} mraa_func_t; + diff --git a/include/mraa_internal.h b/include/mraa_internal.h index f35a197..6c7bb99 100644 --- a/include/mraa_internal.h +++ b/include/mraa_internal.h @@ -59,6 +59,13 @@ mraa_platform_t mraa_x86_platform(); */ mraa_platform_t mraa_arm_platform(); +/** + * runtime detect running usb platform extender + * + * @return mraa_platform_t of the detected platform extender + */ +mraa_platform_t mraa_usb_platform_extender(mraa_board_t* board); + /** * helper function to check if file exists * diff --git a/include/mraa_internal_types.h b/include/mraa_internal_types.h index 70b212d..a140c86 100644 --- a/include/mraa_internal_types.h +++ b/include/mraa_internal_types.h @@ -27,6 +27,8 @@ #include "common.h" #include "mraa.h" +#include "mraa_func.h" +#include "mraa_adv_func.h" // general status failures for internal functions #define MRAA_PLATFORM_NO_INIT -3 @@ -59,7 +61,9 @@ struct _i2c { int busnum; /**< the bus number of the /dev/i2c-* device */ int fh; /**< the file handle to the /dev/i2c-* device */ int addr; /**< the address of the i2c slave */ - unsigned long funcs; + unsigned long funcs; /**< /dev/i2c-* device capabilities as per https://www.kernel.org/doc/Documentation/i2c/functionality */ + void *handle; /**< generic handle for non-standard drivers that don't use file descriptors */ + mraa_adv_func_t* func_table; /*@}*/ }; @@ -189,6 +193,7 @@ typedef struct { unsigned int bus_id; /**< ID as exposed in the system */ unsigned int scl; /**< i2c SCL */ unsigned int sda; /**< i2c SDA */ + // mraa_drv_api_t drv_type; /**< Driver type */ /*@}*/ } mraa_i2c_bus_t; @@ -222,7 +227,8 @@ typedef struct { /** * A Structure representing a platform/board. */ -typedef struct { + +typedef struct _board_t { /*@{*/ unsigned int phy_pin_count; /**< The Total IO pins on board */ unsigned int gpio_count; /**< GPIO Count */ @@ -243,5 +249,9 @@ typedef struct { int pwm_min_period; /**< Minimum period in us */ const char* platform_name; /**< Platform Name pointer */ mraa_pininfo_t* pins; /**< Pointer to pin array */ + mraa_adv_func_t* adv_func; /**< Pointer to advanced function disptach table */ + struct _board_t* sub_platform; /**< Pointer to sub platform */ /*@}*/ } mraa_board_t; + + diff --git a/include/usb/ftdi_ft4222.h b/include/usb/ftdi_ft4222.h new file mode 100644 index 0000000..7b15cbb --- /dev/null +++ b/include/usb/ftdi_ft4222.h @@ -0,0 +1,40 @@ +/* + * Author: Henry Bruce + * Copyright (c) 2015 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "mraa_internal.h" + +mraa_result_t mraa_ftdi_ft4222_init(); +mraa_result_t mraa_ftdi_ft4222_get_version(unsigned int* versionChip, unsigned int* versionLib); +mraa_board_t* mraa_ftdi_ft4222(mraa_board_t* board); + + +#ifdef __cplusplus +} +#endif diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ffd57e2..6b66618 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -35,6 +35,8 @@ set (mraa_LIB_ARM_SRCS_NOAUTO ${PROJECT_SOURCE_DIR}/src/arm/banana.c ) +set (mraa_LIBS ${CMAKE_THREAD_LIBS_INIT}) + if (X86PLAT) add_subdirectory(x86) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DX86PLAT=1") @@ -45,6 +47,13 @@ if (ARMPLAT) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DARMPLAT=1") endif() +if (USBPLAT) + add_subdirectory(usb) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DUSBPLAT=1") + set (mraa_LIBS ${mraa_LIBS} ft4222) +endif() + + set (mraa_LIB_SRCS ${mraa_LIB_PLAT_SRCS_NOAUTO} # autogenerated version file @@ -57,7 +66,9 @@ set (mraa_LIB_GLOB_HEADERS ) add_library (mraa SHARED ${mraa_LIB_SRCS}) -target_link_libraries (mraa ${CMAKE_THREAD_LIBS_INIT}) + + +target_link_libraries (mraa ${mraa_LIBS}) set_target_properties( mraa diff --git a/src/i2c/i2c.c b/src/i2c/i2c.c index c4e4146..f6917f7 100644 --- a/src/i2c/i2c.c +++ b/src/i2c/i2c.c @@ -37,6 +37,10 @@ #include #include "linux/i2c-dev.h" +// FIXME: Nasty macro to test for presence of function in context structure function table +#define IS_FUNC_DEFINED(dev, func) (dev != NULL && dev->func_table != NULL && dev->func_table->func != NULL) + + typedef union i2c_smbus_data_union { uint8_t byte; ///< data byte unsigned short word; ///< data short word @@ -51,6 +55,9 @@ typedef struct i2c_smbus_ioctl_data_struct { i2c_smbus_data_t* data; ///< data } i2c_smbus_ioctl_data_t; + +static mraa_adv_func_t* func_table; + int mraa_i2c_smbus_access(int fh, uint8_t read_write, uint8_t command, int size, i2c_smbus_data_t* data) { @@ -67,71 +74,94 @@ mraa_i2c_smbus_access(int fh, uint8_t read_write, uint8_t command, int size, i2c mraa_i2c_context mraa_i2c_init(int bus) { - if (plat == NULL) { + mraa_board_t* board = plat; + if (board == NULL) { syslog(LOG_ERR, "i2c: Platform Not Initialised"); return NULL; } - if (plat->i2c_bus_count == 0) { + + if (MRAA_IS_ON_SUB_PLATFORM(bus)) { + syslog(LOG_NOTICE, "i2c: Using sub platform"); + board = board->sub_platform; + if (board == NULL) { + syslog(LOG_ERR, "i2c: Sub platform Not Initialised"); + return NULL; + } + bus = MRAA_GET_SUB_PLATFORM_INDEX(bus); + } + + if (board->i2c_bus_count == 0) { syslog(LOG_ERR, "No i2c buses defined in platform"); return NULL; } - if (bus >= plat->i2c_bus_count) { + if (bus >= board->i2c_bus_count) { syslog(LOG_ERR, "Above i2c bus count"); return NULL; } - if (plat->i2c_bus[bus].bus_id == -1) { + if (board->i2c_bus[bus].bus_id == -1) { syslog(LOG_ERR, "Invalid i2c bus, moving to default i2c bus"); - bus = plat->def_i2c_bus; + bus = board->def_i2c_bus; } - int pos = plat->i2c_bus[bus].sda; - if (plat->pins[pos].i2c.mux_total > 0) { - if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS) { + int pos = board->i2c_bus[bus].sda; + if (board->pins[pos].i2c.mux_total > 0) { + if (mraa_setup_mux_mapped(board->pins[pos].i2c) != MRAA_SUCCESS) { syslog(LOG_ERR, "i2c: Failed to set-up i2c sda multiplexer"); return NULL; } } - pos = plat->i2c_bus[bus].scl; - if (plat->pins[pos].i2c.mux_total > 0) { - if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS) { + pos = board->i2c_bus[bus].scl; + if (board->pins[pos].i2c.mux_total > 0) { + if (mraa_setup_mux_mapped(board->pins[pos].i2c) != MRAA_SUCCESS) { syslog(LOG_ERR, "i2c: Failed to set-up i2c scl multiplexer"); return NULL; } } - return mraa_i2c_init_raw((unsigned int) plat->i2c_bus[bus].bus_id); + // FIXME: use global func_table variable to access advanced function table without changing i2c_init_raw() signature + func_table = board->adv_func; + return mraa_i2c_init_raw((unsigned int) board->i2c_bus[bus].bus_id); } mraa_i2c_context mraa_i2c_init_raw(unsigned int bus) { - if (advance_func->i2c_init_pre != NULL) { - if (advance_func->i2c_init_pre(bus) != MRAA_SUCCESS) - return NULL; - } mraa_i2c_context dev = (mraa_i2c_context) malloc(sizeof(struct _i2c)); if (dev == NULL) { syslog(LOG_CRIT, "i2c: Failed to allocate memory for context"); return NULL; } - - char filepath[32]; + + dev->func_table = func_table; dev->busnum = bus; - snprintf(filepath, 32, "/dev/i2c-%u", bus); - if ((dev->fh = open(filepath, O_RDWR)) < 1) { - syslog(LOG_ERR, "i2c: Failed to open requested i2c port %s", filepath); - } - syslog(LOG_DEBUG, "i2c: Opened i2c bus %s", filepath); - if (ioctl(dev->fh, I2C_FUNCS, &dev->funcs) < 0) { - syslog(LOG_CRIT, "i2c: Failed to get I2C_FUNC map from device"); - dev->funcs = 0; + if (IS_FUNC_DEFINED(dev, i2c_init_pre)) { + if (func_table->i2c_init_pre(bus) != MRAA_SUCCESS) + return NULL; + } + if (!IS_FUNC_DEFINED(dev, i2c_init_bus_replace)) { + char filepath[32]; + snprintf(filepath, 32, "/dev/i2c-%u", bus); + if ((dev->fh = open(filepath, O_RDWR)) < 1) { + syslog(LOG_ERR, "i2c: Failed to open requested i2c port %s", filepath); + } + syslog(LOG_DEBUG, "i2c: Opened i2c bus %s", filepath); + + if (ioctl(dev->fh, I2C_FUNCS, &dev->funcs) < 0) { + syslog(LOG_CRIT, "i2c: Failed to get I2C_FUNC map from device"); + dev->funcs = 0; + } + } else { + if (dev->func_table->i2c_init_bus_replace(dev) != MRAA_SUCCESS) { + free(dev); + return NULL; + } } - if (advance_func->i2c_init_post != NULL) { - mraa_result_t ret = advance_func->i2c_init_post(dev); + if (IS_FUNC_DEFINED(dev, i2c_init_post)) { + mraa_result_t ret = dev->func_table->i2c_init_post(dev); if (ret != MRAA_SUCCESS) { free(dev); return NULL; @@ -143,8 +173,8 @@ mraa_i2c_init_raw(unsigned int bus) mraa_result_t mraa_i2c_frequency(mraa_i2c_context dev, mraa_i2c_mode_t mode) { - if (advance_func->i2c_set_frequency_replace != NULL) { - return advance_func->i2c_set_frequency_replace(dev, mode); + if (IS_FUNC_DEFINED(dev, i2c_set_frequency_replace)) { + return dev->func_table->i2c_set_frequency_replace(dev, mode); } return MRAA_ERROR_FEATURE_NOT_SUPPORTED; } @@ -152,11 +182,16 @@ mraa_i2c_frequency(mraa_i2c_context dev, mraa_i2c_mode_t mode) int mraa_i2c_read(mraa_i2c_context dev, uint8_t* data, int length) { - // this is the read(3) syscall not mraa_i2c_read() - if (read(dev->fh, data, length) == length) { - return length; - } - return 0; + int bytes_read = 0; + if (!IS_FUNC_DEFINED(dev, i2c_read_replace)) { + // this is the read(3) syscall not mraa_i2c_read() + bytes_read = read(dev->fh, data, length); + } else + bytes_read = dev->func_table->i2c_read_replace(dev, data, length); + if (bytes_read == length) + return length; + else + return 0; } uint8_t @@ -240,11 +275,14 @@ mraa_i2c_write(mraa_i2c_context dev, const uint8_t* data, int length) mraa_result_t mraa_i2c_write_byte(mraa_i2c_context dev, const uint8_t data) { - if (mraa_i2c_smbus_access(dev->fh, I2C_SMBUS_WRITE, data, I2C_SMBUS_BYTE, NULL) < 0) { - syslog(LOG_ERR, "i2c: Failed to write"); - return MRAA_ERROR_INVALID_HANDLE; - } - return MRAA_SUCCESS; + if (!IS_FUNC_DEFINED(dev, i2c_write_byte_replace)) { + if (mraa_i2c_smbus_access(dev->fh, I2C_SMBUS_WRITE, data, I2C_SMBUS_BYTE, NULL) < 0) { + syslog(LOG_ERR, "i2c: Failed to write"); + return MRAA_ERROR_INVALID_HANDLE; + } + return MRAA_SUCCESS; + } else + return dev->func_table->i2c_write_byte_replace(dev, data); } mraa_result_t @@ -277,11 +315,14 @@ mraa_result_t mraa_i2c_address(mraa_i2c_context dev, uint8_t addr) { dev->addr = (int) addr; - if (ioctl(dev->fh, I2C_SLAVE_FORCE, addr) < 0) { - syslog(LOG_ERR, "i2c: Failed to set slave address %d", addr); - return MRAA_ERROR_INVALID_HANDLE; - } - return MRAA_SUCCESS; + if (dev->func_table->i2c_init_bus_replace == NULL) { + if (ioctl(dev->fh, I2C_SLAVE_FORCE, addr) < 0) { + syslog(LOG_ERR, "i2c: Failed to set slave address %d", addr); + return MRAA_ERROR_INVALID_HANDLE; + } + return MRAA_SUCCESS; + } else + return dev->func_table->i2c_address_replace(dev, addr); } mraa_result_t diff --git a/src/mraa.c b/src/mraa.c index 137ab91..0fcdd25 100644 --- a/src/mraa.c +++ b/src/mraa.c @@ -97,17 +97,29 @@ mraa_init() Py_InitializeEx(0); PyEval_InitThreads(); #endif + advance_func = (mraa_adv_func_t*) malloc(sizeof(mraa_adv_func_t)); memset(advance_func, 0, sizeof(mraa_adv_func_t)); -#if defined(X86PLAT) +#ifdef X86PLAT // Use runtime x86 platform detection platform_type = mraa_x86_platform(); -#elif defined(ARMPLAT) +#ifdef USBPLAT + // This is a platform extender so create null base platform if one doesn't already exist + if (plat == NULL) { + plat = (mraa_board_t*) calloc(1, sizeof(mraa_board_t)); + plat->platform_name = "Null platform"; + if (plat != NULL) { + int usb_platform_type = mraa_usb_platform_extender(plat); + if (platform_type == MRAA_UNKNOWN_PLATFORM) + platform_type = usb_platform_type; + } + } +#endif + +#if defined(ARMPLAT) // Use runtime ARM platform detection platform_type = mraa_arm_platform(); -#else -#error mraa_ARCH NOTHING #endif if (plat == NULL) { @@ -115,7 +127,7 @@ mraa_init() return MRAA_ERROR_PLATFORM_NOT_INITIALISED; } - syslog(LOG_INFO, "libmraa initialised for platform '%s' of type %d", mraa_get_platform_name(), platform_type); + syslog(LOG_NOTICE, "libmraa initialised for platform '%s' of type %d", mraa_get_platform_name(), platform_type); return MRAA_SUCCESS; } @@ -355,6 +367,17 @@ mraa_get_pin_name(int pin) return (char*) plat->pins[pin].name; } +int +mraa_get_default_i2c_bus() +{ + if (plat == NULL) { + return -1; + } else + return plat->def_i2c_bus; +} + + + mraa_boolean_t mraa_file_exist(const char* filename) { diff --git a/src/usb/CMakeLists.txt b/src/usb/CMakeLists.txt new file mode 100644 index 0000000..13edd12 --- /dev/null +++ b/src/usb/CMakeLists.txt @@ -0,0 +1,7 @@ +message (INFO " - Adding USB platforms") +set (mraa_LIB_SRCS_NOAUTO ${mraa_LIB_SRCS_NOAUTO} + ${PROJECT_SOURCE_DIR}/src/usb/usb.c + ${PROJECT_SOURCE_DIR}/src/usb/ftdi_ft4222.c + PARENT_SCOPE +) + diff --git a/src/usb/ftdi_ft4222.c b/src/usb/ftdi_ft4222.c new file mode 100644 index 0000000..b7a963f --- /dev/null +++ b/src/usb/ftdi_ft4222.c @@ -0,0 +1,377 @@ +/* + * Author: Henry Bruce + * Copyright (c) 2015 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include "linux/i2c-dev.h" +#include "common.h" +#include "ftd2xx.h" +#include "libft4222.h" +#include "usb/ftdi_ft4222.h" + +#define PLATFORM_NAME "FTDI FT4222" +#define I2CM_ERROR(status) (((status) & 0x02) != 0) + + +static FT_HANDLE ftHandle = (FT_HANDLE)NULL; +static int bus_speed = 400; + + +mraa_result_t +mraa_ftdi_ft4222_init() +{ + mraa_result_t mraaStatus = MRAA_SUCCESS; + FT_STATUS ftStatus; + FT_DEVICE_LIST_INFO_NODE *devInfo = NULL; + DWORD numDevs = 0; + int i; + int retCode = 0; + + ftStatus = FT_CreateDeviceInfoList(&numDevs); + if (ftStatus != FT_OK) + { + syslog(LOG_ERR, "FT_CreateDeviceInfoList failed: error code %d\n", ftStatus); + mraaStatus = MRAA_ERROR_NO_RESOURCES; + goto init_exit; + } + + if (numDevs == 0) + { + syslog(LOG_ERR, "No FT4222 devices connected.\n"); + goto init_exit; + } + + devInfo = calloc((size_t)numDevs, sizeof(FT_DEVICE_LIST_INFO_NODE)); + if (devInfo == NULL) + { + syslog(LOG_ERR, "FT4222 allocation failure.\n"); + mraaStatus = MRAA_ERROR_NO_RESOURCES; + goto init_exit; + } + + ftStatus = FT_GetDeviceInfoList(devInfo, &numDevs); + if (ftStatus != FT_OK) + { + syslog(LOG_ERR, "FT_GetDeviceInfoList failed (error code %d)\n", (int)ftStatus); + mraaStatus = MRAA_ERROR_NO_RESOURCES; + goto init_exit; + } + + syslog(LOG_INFO, "FT_GetDeviceInfoList returned %d devices\n", numDevs); + DWORD locationId; + int bus = 0; + if (numDevs > bus && devInfo[bus].Type == FT_DEVICE_4222H_3) { + locationId = devInfo[bus].LocId; + } else { + syslog(LOG_ERR, "FT_GetDeviceInfoList contains no valid devices\n"); + mraaStatus = MRAA_ERROR_NO_RESOURCES; + goto init_exit; + } + + ftStatus = FT_OpenEx((PVOID)(uintptr_t)locationId, FT_OPEN_BY_LOCATION, &ftHandle); + if (ftStatus != FT_OK) + { + syslog(LOG_ERR, "FT_OpenEx failed (error %d)\n", (int)ftStatus); + mraaStatus = MRAA_ERROR_NO_RESOURCES; + goto init_exit; + } + +init_exit: + if (devInfo != NULL); + free(devInfo); + if (mraaStatus == MRAA_SUCCESS) + syslog(LOG_NOTICE, "mraa_ftdi_ft4222_init completed successfully\n"); + return mraaStatus; +} + + +mraa_result_t +mraa_ftdi_ft4222_get_version(unsigned int* versionChip, unsigned int* versionLib) +{ + if (ftHandle != NULL) { + FT4222_Version ft4222Version; + FT4222_STATUS ft4222Status = FT4222_GetVersion(ftHandle, &ft4222Version); + if (FT4222_OK == ft4222Status){ + *versionChip = (unsigned int)ft4222Version.chipVersion; + *versionLib = (unsigned int)ft4222Version.dllVersion; + syslog(LOG_NOTICE, "FT4222_GetVersion %08X %08X\n", *versionChip, *versionLib); + return MRAA_SUCCESS; + } else { + syslog(LOG_ERR, "libmraa: FT4222_GetVersion failed (error %d)\n", (int)ft4222Status); + return MRAA_ERROR_NO_RESOURCES; + } + } else { + syslog(LOG_ERR, "libmraa: bad FT4222 handle\n"); + return MRAA_ERROR_INVALID_HANDLE; + } +} + + +mraa_i2c_context +mraa_ftdi_ft4222_i2c_init_raw(unsigned int bus) +{ + // Tell the FT4222 to be an I2C Master. + FT4222_STATUS ft4222Status = FT4222_I2CMaster_Init(ftHandle, bus_speed); + if (FT4222_OK != ft4222Status) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Init failed (error %d)!\n", ft4222Status); + return NULL; + } + + // Reset the I2CM registers to a known state. + ft4222Status = FT4222_I2CMaster_Reset(ftHandle); + if (FT4222_OK != ft4222Status) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Reset failed (error %d)!\n", ft4222Status); + return NULL; + } + + mraa_i2c_context dev = (mraa_i2c_context) malloc(sizeof(struct _i2c)); + if (dev == NULL) { + syslog(LOG_CRIT, "i2c: Failed to allocate memory for context"); + return NULL; + } + + dev->handle = ftHandle; + dev->fh = -1; // We don't use file descriptors + dev->funcs = I2C_FUNC_I2C; // Advertise minimal i2c support as per https://www.kernel.org/doc/Documentation/i2c/functionality + return dev; +} + +static mraa_result_t +mraa_ftdi_ft4222_i2c_init_bus_replace(mraa_i2c_context dev) +{ + // Tell the FT4222 to be an I2C Master. + FT4222_STATUS ft4222Status = FT4222_I2CMaster_Init(ftHandle, 400); + if (FT4222_OK != ft4222Status) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Init failed (error %d)!\n", ft4222Status); + return MRAA_ERROR_NO_RESOURCES; + } + + // Reset the I2CM registers to a known state. + ft4222Status = FT4222_I2CMaster_Reset(ftHandle); + if (FT4222_OK != ft4222Status) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Reset failed (error %d)!\n", ft4222Status); + return MRAA_ERROR_NO_RESOURCES; + } + + dev->handle = ftHandle; + dev->fh = -1; // We don't use file descriptors + dev->funcs = I2C_FUNC_I2C; // Advertise minimal i2c support as per https://www.kernel.org/doc/Documentation/i2c/functionality + return MRAA_SUCCESS; +} + + +static mraa_result_t +mraa_ftdi_ft4222_i2c_frequency(mraa_i2c_context dev, mraa_i2c_mode_t mode) +{ + return MRAA_ERROR_FEATURE_NOT_SUPPORTED; +} + + +static mraa_result_t +mraa_ftdi_ft4222_i2c_address(mraa_i2c_context dev, uint8_t addr) +{ + dev->addr = (int) addr; + return FT4222_I2CMaster_Init(ftHandle, bus_speed) == FT4222_OK ? MRAA_SUCCESS : MRAA_ERROR_NO_RESOURCES; +} + + +static int +mraa_ftdi_ft4222_i2c_read(mraa_i2c_context dev, uint8_t* data, int length) +{ + uint16 bytesRead = 0; + uint8 controllerStatus; + syslog(LOG_NOTICE, "FT4222_I2CMaster_Read(%02X, %d)", dev->addr, length); + FT4222_STATUS ft4222Status = FT4222_I2CMaster_Read(dev->handle, dev->addr, data, length, &bytesRead); + ft4222Status = FT4222_I2CMaster_GetStatus(ftHandle, &controllerStatus); + if (FT4222_OK != ft4222Status || I2CM_ERROR(controllerStatus)) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Read failed (error %d)\n", (int)ft4222Status); + return 0; + } + return bytesRead; +} + +static uint8_t +mraa_ftdi_ft4222_i2c_read_byte(mraa_i2c_context dev) +{ + return 0; +} + +static uint8_t +mraa_ftdi_ft4222_i2c_read_byte_data(mraa_i2c_context dev, uint8_t command) +{ + return 0; +} + +static uint16_t +mraa_ftdi_ft4222_i2c_read_word_data(mraa_i2c_context dev, uint8_t command) +{ + return 0; +} + +static int +mraa_ftdi_ft4222_i2c_read_bytes_data(mraa_i2c_context dev, uint8_t command, uint8_t* data, int length) +{ + return -1; +} + + +static mraa_result_t +mraa_ftdi_ft4222_i2c_write(mraa_i2c_context dev, const uint8_t* data, int bytesToWrite) +{ + uint16 bytesWritten = 0; + uint8 controllerStatus; + syslog(LOG_NOTICE, "FT4222_I2CMaster_Write(%#02X, %#02X, %d)", dev->addr, *data, bytesToWrite); + FT4222_STATUS ft4222Status = FT4222_I2CMaster_Write(dev->handle, dev->addr, (uint8_t*)data, bytesToWrite, &bytesWritten); + ft4222Status = FT4222_I2CMaster_GetStatus(ftHandle, &controllerStatus); + if (FT4222_OK != ft4222Status || I2CM_ERROR(controllerStatus)) + { + syslog(LOG_ERR, "FT4222_I2CMaster_Write failed (error %d)\n", (int)ft4222Status); + return MRAA_ERROR_INVALID_HANDLE; + } + + if (bytesWritten != bytesToWrite) + syslog(LOG_ERR, "FT4222_I2CMaster_Write wrote %u of %u bytes.\n", bytesWritten, bytesToWrite); + + return bytesToWrite == bytesWritten ? MRAA_SUCCESS : MRAA_ERROR_INVALID_HANDLE; +} + + +static mraa_result_t +mraa_ftdi_ft4222_i2c_write_byte(mraa_i2c_context dev, uint8_t data) +{ + return mraa_ftdi_ft4222_i2c_write(dev, &data, 1); +} + +static mraa_result_t +mraa_ftdi_ft4222_i2c_write_byte_data(mraa_i2c_context dev, const uint8_t data, const uint8_t command) +{ + mraa_result_t status = mraa_ftdi_ft4222_i2c_write_byte(dev, command); + if (status == MRAA_SUCCESS) + return mraa_ftdi_ft4222_i2c_write_byte(dev, data); + else + return status; +} + +static mraa_result_t +mraa_ftdi_ft4222_i2c_write_word_data(mraa_i2c_context dev, const uint16_t data, const uint8_t command) +{ + mraa_result_t status = mraa_ftdi_ft4222_i2c_write_byte(dev, command); + if (status == MRAA_SUCCESS) + return mraa_ftdi_ft4222_i2c_write(dev, (const uint8_t*)&data, 2); + else + return status; + +} + +static mraa_result_t +mraa_ftdi_ft4222_i2c_stop(mraa_i2c_context dev) +{ + return MRAA_SUCCESS; +} + + + + +mraa_adv_func_t* +mraa_i2c_ft4222_create_func_table() +{ + mraa_adv_func_t* func_table = (mraa_adv_func_t*) calloc(1, sizeof(mraa_adv_func_t)); + if (func_table != NULL) { + // func_table->i2c_init_raw_replace = &mraa_ftdi_ft4222_i2c_init_raw; + func_table->i2c_init_bus_replace = &mraa_ftdi_ft4222_i2c_init_bus_replace; + func_table->i2c_set_frequency_replace = &mraa_ftdi_ft4222_i2c_frequency; + func_table->i2c_address_replace = &mraa_ftdi_ft4222_i2c_address; + func_table->i2c_read_replace = &mraa_ftdi_ft4222_i2c_read; + func_table->i2c_read_byte_replace = &mraa_ftdi_ft4222_i2c_read_byte; + func_table->i2c_read_byte_data_replace = &mraa_ftdi_ft4222_i2c_read_byte_data; + func_table->i2c_read_word_data_replace = &mraa_ftdi_ft4222_i2c_read_word_data; + func_table->i2c_read_bytes_data_replace = &mraa_ftdi_ft4222_i2c_read_bytes_data; + func_table->i2c_write_replace = &mraa_ftdi_ft4222_i2c_write; + func_table->i2c_write_byte_replace = &mraa_ftdi_ft4222_i2c_write_byte; + func_table->i2c_write_byte_data_replace = &mraa_ftdi_ft4222_i2c_write_byte_data; + func_table->i2c_write_word_data_replace = &mraa_ftdi_ft4222_i2c_write_word_data; + func_table->i2c_stop_replace = &mraa_ftdi_ft4222_i2c_stop; + } + return func_table; +} + +mraa_board_t* +mraa_ftdi_ft4222(mraa_board_t* board) +{ + if (plat == NULL) + return NULL; + mraa_board_t* sub_plat = (mraa_board_t*) calloc(1, sizeof(mraa_board_t)); + if (sub_plat == NULL) + return NULL; + int pinIndex = 0; + int numUsbGpio = 0; + int numUsbPins = numUsbGpio + 2; // Add SDA and SCL + sub_plat->platform_name = PLATFORM_NAME; + sub_plat->phy_pin_count = numUsbPins; + sub_plat->gpio_count = numUsbGpio; + mraa_pininfo_t* pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t) * numUsbPins); + if (pins == NULL) { + return NULL; + } + sub_plat->pins = pins; + + // Virtual gpio pins on i2c I/O expander. + mraa_pincapabilities_t pinCapsGpio = (mraa_pincapabilities_t){ 1, 1, 0, 0, 0, 0, 0, 0 }; + for (pinIndex=0; pinIndex < numUsbGpio; ++pinIndex) { + char name[8]; + sprintf(name, "Pin%d", pinIndex); + strncpy(sub_plat->pins[pinIndex].name, name, 8); + sub_plat->pins[pinIndex].capabilites = pinCapsGpio; + } + + int bus = 0; + sub_plat->i2c_bus_count = 1; + sub_plat->def_i2c_bus = bus; + sub_plat->i2c_bus[bus].bus_id = bus; + // sub_plat->i2c_bus[bus].drv_type = drv_type; + + // i2c pins (these are virtual, entries are required to configure i2c layer) + mraa_pincapabilities_t pinCapsI2c = (mraa_pincapabilities_t){ 1, 0, 0, 0, 0, 1, 0, 0 }; + strncpy(sub_plat->pins[pinIndex].name, "SDA", 8); + sub_plat->pins[pinIndex].capabilites = pinCapsI2c; + sub_plat->pins[pinIndex].i2c.mux_total = 0; + sub_plat->i2c_bus[bus].sda = pinIndex; + pinIndex++; + strncpy(sub_plat->pins[pinIndex].name, "SCL", 8); + sub_plat->pins[pinIndex].capabilites = pinCapsI2c; + sub_plat->pins[pinIndex].i2c.mux_total = 0; + sub_plat->i2c_bus[bus].scl = pinIndex; + + // Set override functions + sub_plat->adv_func = mraa_i2c_ft4222_create_func_table(); + + board->sub_platform = sub_plat; + return sub_plat; +} + diff --git a/src/usb/usb.c b/src/usb/usb.c new file mode 100644 index 0000000..6629f37 --- /dev/null +++ b/src/usb/usb.c @@ -0,0 +1,51 @@ +/* + * Author: Henry Bruce + * Copyright (c) 2015 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include "mraa_internal.h" +#include "usb/ftdi_ft4222.h" + + +mraa_platform_t +mraa_usb_platform_extender(mraa_board_t* board) +{ + mraa_platform_t platform_type = MRAA_UNKNOWN_PLATFORM; + if (mraa_ftdi_ft4222_init() == MRAA_SUCCESS) { + unsigned int versionChip, versionLib; + if (mraa_ftdi_ft4222_get_version(&versionChip, &versionLib) == MRAA_SUCCESS) { + // TODO: Add ft4222 version checks + platform_type = MRAA_FTDI_FT4222; + } + } + switch (platform_type) { + case MRAA_FTDI_FT4222: + mraa_ftdi_ft4222(board); + break; + default: + syslog(LOG_ERR, "Unknown USB Platform Extender, currently not supported by MRAA"); + } + return platform_type; +} diff --git a/src/x86/intel_edison_fab_c.c b/src/x86/intel_edison_fab_c.c index 17f18d7..376bd0f 100644 --- a/src/x86/intel_edison_fab_c.c +++ b/src/x86/intel_edison_fab_c.c @@ -1116,7 +1116,8 @@ mraa_intel_edison_miniboard(mraa_board_t* b) mraa_board_t* mraa_intel_edison_fab_c() { - mraa_board_t* b = (mraa_board_t*) malloc(sizeof(mraa_board_t)); + // mraa_board_t* b = (mraa_board_t*) malloc(sizeof(mraa_board_t)); + mraa_board_t* b = (mraa_board_t*) calloc(1, sizeof(mraa_board_t)); if (b == NULL) { return NULL; }