Initial commit

AntonioLangiu · AntonioLangiu · commit e30fad6ccac7 · 2018-01-13T13:51:21.000+01:00
diff --git a/.gitmodules b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "cryptoauthlib"]
+	path = cryptoauthlib
+	url = https://github.com/MicrochipTech/cryptoauthlib
diff --git a/README.md b/README.md
@@ -0,0 +1,10 @@
+# CryptoAuthLib
+
+This repository contains the HAL to use Atmel CryptoAuthLib with CC2650.
+
+It has been tested with a [TI Sensortag CC2650](http://www.ti.com/tool/cc2650stk).
+
+If you are planning to use it with Contiki you should also patch the
+library to use Contiki memory allocation primitives. The patches are
+contained in the `patch` folder and can be applied calling the
+`autogen.sh` script.
diff --git a/cryptoauthlib b/cryptoauthlib
@@ -0,0 +1 @@
+Subproject commit b31ed52daf2260329a131da19f8cc40a4d32d150
diff --git a/hal/hal_cc2650_i2c_contiki.c b/hal/hal_cc2650_i2c_contiki.c
@@ -0,0 +1,169 @@
+#include "atca_hal.h"
+#include "hal_cc2650_i2c.h"
+#include "board-i2c.h"
+#include "rtimer.h"
+#include "ti-lib.h"
+#include <string.h>
+#include <stdio.h>
+
+/** This implementation uses the primitives offered by Contiki.
+ * In this way, sharing the code between the two implementations
+ * is possible to reduce the final memory footprint.
+ */
+
+/** \brief discover i2c buses available for this hardware
+ * this maintains a list of logical to physical bus mappings freeing the application
+ * of the a-priori knowledge
+ * \param[in] i2c_buses - an array of logical bus numbers
+ * \param[in] max_buses - maximum number of buses the app wants to attempt to discover
+ */
+ATCA_STATUS hal_i2c_discover_buses( int i2c_buses[], int max_buses )
+{
+	return ATCA_UNIMPLEMENTED;
+}
+
+/** \brief discover any CryptoAuth devices on a given logical bus number
+ * \param[in]  busNum  logical bus number on which to look for CryptoAuth devices
+ * \param[out] cfg     pointer to head of an array of interface config structures which get filled in by this method
+ * \param[out] found   number of devices found on this bus
+ */
+ATCA_STATUS hal_i2c_discover_devices( int busNum, ATCAIfaceCfg cfg[], int *found )
+{
+	return ATCA_UNIMPLEMENTED;
+}
+
+/** \brief HAL implementation of I2C init
+ *
+ * this implementation assumes I2C peripheral has been enabled by user. It only initialize an
+ * I2C interface using given config.
+ *
+ *  \param[in] hal pointer to HAL specific data that is maintained by this HAL
+ *  \param[in] cfg pointer to HAL specific configuration data that is used to initialize this HAL
+ * \return ATCA_STATUS
+ */
+ATCA_STATUS hal_i2c_init( void* hal, ATCAIfaceCfg* cfg )
+{
+    board_i2c_wakeup();
+    return ATCA_SUCCESS;
+}
+
+/** \brief HAL implementation of I2C post init
+ * \param[in] iface  instance
+ * \return ATCA_STATUS
+ */
+ATCA_STATUS hal_i2c_post_init( ATCAIface iface )
+{
+    return ATCA_SUCCESS;
+}
+
+/** \brief HAL implementation of I2C send over ASF
+ * \param[in] iface     instance
+ * \param[in] txdata    pointer to space to bytes to send
+ * \param[in] txlength  number of bytes to send
+ * \return ATCA_STATUS
+ */
+ATCA_STATUS hal_i2c_send( ATCAIface iface, uint8_t* txdata, int txlength)
+{
+    const ATCAIfaceCfg *cfg = atgetifacecfg(iface);
+    txdata[0] = 0x03;	// insert the Word Address Value, Command token
+    txlength++;		// account for word address value byte.
+    board_i2c_select(DEFAULT_I2C_INTERFACE, cfg->atcai2c.slave_address >> 1);
+    bool success = board_i2c_write(txdata, txlength);
+    board_i2c_deselect();
+    return success? ATCA_SUCCESS: ATCA_COMM_FAIL;
+}
+
+/** \brief HAL implementation of I2C receive function for ASF I2C
+ * \param[in] iface     instance
+ * \param[in] rxdata    pointer to space to receive the data
+ * \param[in] rxlength  ptr to expected number of receive bytes to request
+ * \return ATCA_STATUS
+ */
+ATCA_STATUS hal_i2c_receive( ATCAIface iface, uint8_t *rxdata, uint16_t *rxlength )
+{
+    const ATCAIfaceCfg *cfg = atgetifacecfg(iface);
+    board_i2c_select(DEFAULT_I2C_INTERFACE, cfg->atcai2c.slave_address >> 1);
+    bool success = board_i2c_read(rxdata, *rxlength);
+    board_i2c_deselect();
+    return success? ATCA_SUCCESS: ATCA_COMM_FAIL;
+}
+
+ATCA_STATUS hal_i2c_wake( ATCAIface iface) {
+    ATCAIfaceCfg *cfg = atgetifacecfg(iface);
+    int retries = cfg->rx_retries;
+    bool status = false;
+    uint8_t data[16], expected[4] = { 0x04, 0x11, 0x33, 0x43 };
+
+    /* Send the wake up sequence using the GPIO interface for tWLO */
+    ti_lib_i2c_master_disable(I2C0_BASE);
+    ti_lib_ioc_pin_type_gpio_output(BOARD_IOID_SDA);
+    ti_lib_ioc_pin_type_gpio_output(BOARD_IOID_SCL);
+    ti_lib_gpio_clear_dio(BOARD_IOID_SDA);
+    ti_lib_gpio_clear_dio(BOARD_IOID_SCL);
+    atca_delay_us(200);
+
+    /* Restore the value of the SDA and SCL pins and wait tWHI */
+    board_i2c_wakeup();
+    ti_lib_i2c_master_disable(I2C0_BASE); 
+    ti_lib_ioc_io_port_pull_set(BOARD_IOID_SDA, IOC_NO_IOPULL);
+    ti_lib_ioc_io_port_pull_set(BOARD_IOID_SCL, IOC_NO_IOPULL);
+    ti_lib_ioc_pin_type_i2c(I2C0_BASE, BOARD_IOID_SDA, BOARD_IOID_SCL);
+    ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SDA_HP);
+    ti_lib_ioc_pin_type_gpio_input(BOARD_IOID_SCL_HP);
+    ti_lib_i2c_master_init_exp_clk(I2C0_BASE, ti_lib_sys_ctrl_clock_get(),true);
+    atca_delay_us(cfg->wake_delay);
+
+    /* Try to read the wake up value from the device */
+    board_i2c_select(DEFAULT_I2C_INTERFACE, cfg->atcai2c.slave_address >> 1); 
+    while (retries-- > 0 && status != true){
+        status = board_i2c_read(data, 4);
+    }
+    board_i2c_deselect();
+
+    if (status != true) {
+        printf("The read was not successfull\n");
+        return ATCA_TOO_MANY_COMM_RETRIES;
+    }
+
+    if (memcmp(data, expected, 4) == 0) {
+        printf("Wake up successfull\n");
+        return ATCA_SUCCESS;
+    }
+    printf("The received data was not correct\n");
+    return ATCA_COMM_FAIL;
+}
+
+static ATCA_STATUS send_single(ATCAIface iface, uint8_t single) {
+    const ATCAIfaceCfg *cfg = atgetifacecfg(iface);
+    board_i2c_select(DEFAULT_I2C_INTERFACE, cfg->atcai2c.slave_address >> 1);
+    bool success = board_i2c_write_single(single);
+    board_i2c_deselect();
+    return success? ATCA_SUCCESS: ATCA_COMM_FAIL;
+}
+
+/** \brief idle CryptoAuth device using I2C bus
+ * \param[in] iface  interface to logical device to idle
+ */
+ATCA_STATUS hal_i2c_idle( ATCAIface iface )
+{
+    printf("send idle\n");
+    return send_single(iface, 0x02);
+}
+
+/** \brief sleep CryptoAuth device using I2C bus
+ * \param[in] iface  interface to logical device to sleep
+ */
+ATCA_STATUS hal_i2c_sleep( ATCAIface iface )
+{
+    printf("send sleep\n");
+    return send_single(iface, 0x01);
+}
+
+/** \brief manages reference count on given bus and releases resource if no more refences exist
+ * \param[in] hal_data - opaque pointer to hal data structure - known only to the HAL implementation
+ */
+ATCA_STATUS hal_i2c_release( void *hal_data )
+{
+    board_i2c_shutdown();
+    return ATCA_SUCCESS;
+}
diff --git a/hal/hal_cc2650_i2c_contiki.h b/hal/hal_cc2650_i2c_contiki.h
@@ -0,0 +1,6 @@
+#ifndef HAL_CC2650_I2C_H_
+#define HAL_CC2650_I2C_H_
+
+#define DEFAULT_I2C_INTERFACE BOARD_I2C_INTERFACE_0
+
+#endif /* HAL_CC2650_I2C_H_ */
diff --git a/hal/hal_cc2650_timer_contiki.c b/hal/hal_cc2650_timer_contiki.c
@@ -0,0 +1,42 @@
+#include "atca_hal.h"
+#include "rtimer.h"
+#include <stdio.h>
+
+/** \defgroup hal_ Hardware abstraction layer (hal_)
+ *
+ * \brief
+ * These methods define the hardware abstraction layer for communicating with a CryptoAuth device
+ *
+   @{ */
+
+/** \brief This function delays for a number of microseconds.
+ *
+ * \param[in] delay number of 0.001 milliseconds to delay
+ */
+void atca_delay_us(uint32_t delay)
+{
+    rtimer_clock_t end_time = RTIMER_NOW() + (delay*RTIMER_SECOND/1000000);
+    while(RTIMER_CLOCK_LT(RTIMER_NOW(), end_time));
+}
+
+/** \brief This function delays for a number of tens of microseconds.
+ *
+ * \param[in] delay number of 0.01 milliseconds to delay
+ */
+void atca_delay_10us(uint32_t delay)
+{
+   atca_delay_us(delay*10); 
+}
+
+/** \brief This function delays for a number of milliseconds.
+ *
+ *         You can override this function if you like to do
+ *         something else in your system while delaying.
+ * \param[in] delay number of milliseconds to delay
+ */
+void atca_delay_ms(uint32_t delay)
+{
+    atca_delay_us(delay*1000);
+}
+
+/** @} */

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[submodule "cryptoauthlib"]`
	`2`	`+ path = cryptoauthlib`
	`3`	`+ url = https://github.com/MicrochipTech/cryptoauthlib`