int validate_hw_compatibility(struct device *dev)
{
u32_t flags = 0;
flags = cipher_query_hwcaps(dev);
if ((flags & CAP_RAW_KEY) == 0) {
SYS_LOG_INF(" Please provision the key separately "
"as the module doesnt support a raw key");
return -1;
}
if ((flags & CAP_SYNC_OPS) == 0) {
SYS_LOG_ERR("The app assumes sync semantics. "
"Please rewrite the app accordingly before proceeding");
return -1;
}
if ((flags & CAP_SEPARATE_IO_BUFS) == 0) {
SYS_LOG_ERR("The app assumes distinct IO buffers. "
"Please rewrite the app accordingly before proceeding");
return -1;
}
cap_flags = CAP_RAW_KEY | CAP_SYNC_OPS | CAP_SEPARATE_IO_BUFS;
return 0;
}
static void rx_thread(void)
{
SYS_LOG_INF("RX thread started");
while (1) {
struct net_pkt *pkt;
struct net_buf *buf;
u8_t specifier;
pkt = k_fifo_get(&rx_queue, K_FOREVER);
buf = net_buf_frag_last(pkt->frags);
SYS_LOG_DBG("Got pkt %p buf %p", pkt, buf);
hexdump("SLIP >", buf->data, buf->len);
/* TODO: process */
specifier = net_buf_pull_u8(buf);
switch (specifier) {
case '?':
process_request(buf);
break;
case '!':
process_config(pkt);
break;
default:
SYS_LOG_ERR("Unknown message specifier %c", specifier);
break;
}
net_pkt_unref(pkt);
k_yield();
}
}
int lwm2m_rd_client_start(struct net_context *net_ctx,
struct sockaddr *peer_addr,
const char *ep_name)
{
int index;
if (client_count + 1 > CLIENT_INSTANCE_COUNT) {
return -ENOMEM;
}
if (peer_addr_exist(peer_addr)) {
return -EEXIST;
}
/* Server Peer IP information */
/* TODO: use server URI data from security */
index = client_count;
client_count++;
clients[index].net_ctx = net_ctx;
memcpy(&clients[index].reg_server, peer_addr, sizeof(struct sockaddr));
memcpy(&clients[index].bs_server, peer_addr, sizeof(struct sockaddr));
set_ep_ports(index);
set_sm_state(index, ENGINE_INIT);
strncpy(clients[index].ep_name, ep_name, CLIENT_EP_LEN - 1);
SYS_LOG_INF("LWM2M Client: %s", clients[index].ep_name);
return 0;
}
void main(void)
{
SYS_LOG_INF("Cipher Sample");
cbc_mode();
ctr_mode();
ccm_mode();
}
static int adc_sam_initialize(struct device *dev)
{
const struct adc_sam_dev_cfg *dev_cfg = DEV_CFG(dev);
struct adc_sam_dev_data *const dev_data = DEV_DATA(dev);
/* Initialize semaphores */
k_sem_init(&dev_data->sem_meas, 0, 1);
k_sem_init(&dev_data->mutex_thread, 1, 1);
/* Configure interrupts */
dev_cfg->irq_config();
/* Enable module's clock */
soc_pmc_peripheral_enable(dev_cfg->periph_id);
/* Configure ADC */
adc_sam_configure(dev);
/* Enable module interrupt */
irq_enable(dev_cfg->irq_id);
SYS_LOG_INF("Device %s initialized", DEV_NAME(dev));
return 0;
}
static int nrf5_init(struct device *dev)
{
const struct nrf5_802154_config *nrf5_radio_cfg = NRF5_802154_CFG(dev);
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
struct device *clk_m16;
k_sem_init(&nrf5_radio->rx_wait, 0, 1);
k_sem_init(&nrf5_radio->tx_wait, 0, 1);
k_sem_init(&nrf5_radio->cca_wait, 0, 1);
clk_m16 = device_get_binding(CONFIG_CLOCK_CONTROL_NRF5_M16SRC_DRV_NAME);
if (!clk_m16) {
return -ENODEV;
}
clock_control_on(clk_m16, NULL);
nrf_drv_radio802154_init();
nrf5_radio_cfg->irq_config_func(dev);
k_thread_create(&nrf5_radio->rx_thread, nrf5_radio->rx_stack,
CONFIG_IEEE802154_NRF5_RX_STACK_SIZE,
nrf5_rx_thread, dev, NULL, NULL,
K_PRIO_COOP(2), 0, 0);
SYS_LOG_INF("nRF5 802154 radio initialized");
return 0;
}
void main(void)
{
wpanusb_start(&__dev);
SYS_LOG_INF("Start");
#if DYNAMIC_REGISTER
ieee802154_dev = ieee802154_register_raw();
#else
ieee802154_dev = device_get_binding(CONFIG_TI_CC2520_DRV_NAME);
if (!ieee802154_dev) {
SYS_LOG_ERR("Cannot get CC250 device");
return;
}
#endif
/* Initialize nbufs */
net_nbuf_init();
/* Initialize transmit queue */
init_tx_queue();
radio_api = (struct ieee802154_radio_api *)ieee802154_dev->driver_api;
/* TODO: Initialize more */
SYS_LOG_DBG("radio_api %p initialized", radio_api);
SHELL_REGISTER("wpan", commands);
}
static int firmware_block_received_cb(u16_t obj_inst_id,
u8_t *data, u16_t data_len,
bool last_block, size_t total_size)
{
SYS_LOG_INF("FIRMWARE: BLOCK RECEIVED: len:%u last_block:%d",
data_len, last_block);
return 1;
}
static int device_factory_default_cb(u16_t obj_inst_id)
{
SYS_LOG_INF("DEVICE: FACTORY DEFAULT");
/* Add an error for testing */
lwm2m_device_add_err(LWM2M_DEVICE_ERROR_GPS_FAILURE);
/* Change the USB current for testing */
lwm2m_device_set_pwrsrc_current_ma(pwrsrc_usb, --usb_current);
return 1;
}
static int device_reboot_cb(u16_t obj_inst_id)
{
SYS_LOG_INF("DEVICE: REBOOT");
/* Add an error for testing */
lwm2m_device_add_err(LWM2M_DEVICE_ERROR_LOW_POWER);
/* Change the battery voltage for testing */
lwm2m_device_set_pwrsrc_voltage_mv(pwrsrc_bat, --battery_voltage);
return 1;
}
static int sm_do_deregister(int index)
{
struct zoap_packet request;
struct net_pkt *pkt = NULL;
struct zoap_pending *pending = NULL;
struct zoap_reply *reply = NULL;
int ret;
ret = lwm2m_init_message(clients[index].net_ctx,
&request, &pkt, ZOAP_TYPE_CON,
ZOAP_METHOD_DELETE, 0, NULL, 0);
if (ret) {
goto cleanup;
}
zoap_add_option(&request, ZOAP_OPTION_URI_PATH,
clients[index].server_ep,
strlen(clients[index].server_ep));
pending = lwm2m_init_message_pending(&request,
&clients[index].reg_server,
pendings, NUM_PENDINGS);
if (!pending) {
ret = -ENOMEM;
goto cleanup;
}
reply = zoap_reply_next_unused(replies, NUM_REPLIES);
if (!reply) {
SYS_LOG_ERR("No resources for waiting for replies.");
ret = -ENOMEM;
goto cleanup;
}
zoap_reply_init(reply, &request);
reply->reply = do_deregister_reply_cb;
SYS_LOG_INF("Deregister from '%s'", clients[index].server_ep);
ret = lwm2m_udp_sendto(pkt, &clients[index].reg_server);
if (ret < 0) {
SYS_LOG_ERR("Error sending LWM2M packet (err:%d).",
ret);
goto cleanup;
}
zoap_pending_cycle(pending);
k_delayed_work_submit(&retransmit_work, pending->timeout);
set_sm_state(index, ENGINE_DEREGISTER_SENT);
return ret;
cleanup:
lwm2m_init_message_cleanup(pkt, pending, reply);
return ret;
}
static int queue_init(Gmac *gmac, struct gmac_queue *queue)
{
int result;
__ASSERT_NO_MSG(queue->rx_desc_list.len > 0);
__ASSERT_NO_MSG(queue->tx_desc_list.len > 0);
__ASSERT(!((u32_t)queue->rx_desc_list.buf & ~GMAC_RBQB_ADDR_Msk),
"RX descriptors have to be word aligned");
__ASSERT(!((u32_t)queue->tx_desc_list.buf & ~GMAC_TBQB_ADDR_Msk),
"TX descriptors have to be word aligned");
/* Setup descriptor lists */
result = rx_descriptors_init(gmac, queue);
if (result < 0) {
return result;
}
tx_descriptors_init(gmac, queue);
/* Initialize TX descriptors semaphore. The semaphore is required as the
* size of the TX descriptor list is limited while the number of TX data
* buffers is not.
*/
k_sem_init(&queue->tx_desc_sem, queue->tx_desc_list.len - 1,
queue->tx_desc_list.len - 1);
/* Set Receive Buffer Queue Pointer Register */
gmac->GMAC_RBQB = (u32_t)queue->rx_desc_list.buf;
/* Set Transmit Buffer Queue Pointer Register */
gmac->GMAC_TBQB = (u32_t)queue->tx_desc_list.buf;
/* Configure GMAC DMA transfer */
gmac->GMAC_DCFGR =
/* Receive Buffer Size (defined in multiples of 64 bytes) */
GMAC_DCFGR_DRBS(CONFIG_NET_BUF_DATA_SIZE >> 6)
/* 4 kB Receiver Packet Buffer Memory Size */
| GMAC_DCFGR_RXBMS_FULL
/* 4 kB Transmitter Packet Buffer Memory Size */
| GMAC_DCFGR_TXPBMS
/* Transmitter Checksum Generation Offload Enable */
| GMAC_DCFGR_TXCOEN
/* Attempt to use INCR4 AHB bursts (Default) */
| GMAC_DCFGR_FBLDO_INCR4;
/* Setup RX/TX completion and error interrupts */
gmac->GMAC_IER = GMAC_INT_EN_FLAGS;
queue->err_rx_frames_dropped = 0;
queue->err_rx_flushed_count = 0;
queue->err_tx_flushed_count = 0;
SYS_LOG_INF("Queue %d activated", queue->que_idx);
return 0;
}
static bool init_ieee802154(void)
{
u16_t short_addr;
SYS_LOG_INF("Initialize ieee802.15.4");
ieee802154_dev = device_get_binding(CONFIG_IEEE802154_CC2520_DRV_NAME);
if (!ieee802154_dev) {
SYS_LOG_ERR("Cannot get CC250 device");
return false;
}
radio_api = (struct ieee802154_radio_api *)ieee802154_dev->driver_api;
/**
* Do actual initialization of the chip
*/
get_mac(ieee802154_dev);
#ifdef CONFIG_NET_SAMPLES_SETTINGS
SYS_LOG_INF("Set panid %x channel %d",
CONFIG_NET_SAMPLES_IEEE802154_PAN_ID,
CONFIG_NET_SAMPLES_IEEE802154_CHANNEL);
radio_api->set_pan_id(ieee802154_dev,
CONFIG_NET_SAMPLES_IEEE802154_PAN_ID);
radio_api->set_channel(ieee802154_dev,
CONFIG_NET_SAMPLES_IEEE802154_CHANNEL);
#endif /* CONFIG_NET_SAMPLES_SETTINGS */
/* Set short address */
short_addr = (mac_addr[0] << 8) + mac_addr[1];
radio_api->set_short_addr(ieee802154_dev, short_addr);
/* Set ieee address */
radio_api->set_ieee_addr(ieee802154_dev, mac_addr);
/* Start ieee802154 */
radio_api->start(ieee802154_dev);
return true;
}
static int dw_dma0_initialize(struct device *dev)
{
const struct dw_dma_dev_cfg *const dev_cfg = DEV_CFG(dev);
/* Disable all channels and Channel interrupts */
dw_dma_setup(dev);
/* Configure interrupts */
dev_cfg->irq_config();
/* Enable module's IRQ */
irq_enable(dev_cfg->irq_id);
SYS_LOG_INF("Device %s initialized", DEV_NAME(dev));
return 0;
}
static void dma_stm32_dump_reg(struct dma_stm32_device *ddata, u32_t id)
{
SYS_LOG_INF("Using stream: %d\n", id);
SYS_LOG_INF("SCR: 0x%x \t(config)\n",
dma_stm32_read(ddata, DMA_STM32_SCR(id)));
SYS_LOG_INF("SNDTR: 0x%x \t(length)\n",
dma_stm32_read(ddata, DMA_STM32_SNDTR(id)));
SYS_LOG_INF("SPAR: 0x%x \t(source)\n",
dma_stm32_read(ddata, DMA_STM32_SPAR(id)));
SYS_LOG_INF("SM0AR: 0x%x \t(destination)\n",
dma_stm32_read(ddata, DMA_STM32_SM0AR(id)));
SYS_LOG_INF("SM1AR: 0x%x \t(destination (double buffer mode))\n",
dma_stm32_read(ddata, DMA_STM32_SM1AR(id)));
SYS_LOG_INF("SFCR: 0x%x \t(fifo control)\n",
dma_stm32_read(ddata, DMA_STM32_SFCR(id)));
}
static int telnet_console_init(struct device *arg)
{
#ifdef CONFIG_NET_IPV4
struct sockaddr_in any_addr4 = {
.sin_family = AF_INET,
.sin_port = htons(TELNET_PORT),
.sin_addr = INADDR_ANY_INIT
};
static struct net_context *ctx4;
#endif
#ifdef CONFIG_NET_IPV6
struct sockaddr_in6 any_addr6 = {
.sin6_family = AF_INET6,
.sin6_port = htons(TELNET_PORT),
.sin6_addr = IN6ADDR_ANY_INIT
};
static struct net_context *ctx6;
#endif
#ifdef CONFIG_NET_IPV4
telnet_setup_server(&ctx4, AF_INET,
(struct sockaddr *)&any_addr4,
sizeof(any_addr4));
#endif
#ifdef CONFIG_NET_IPV6
telnet_setup_server(&ctx6, AF_INET6,
(struct sockaddr *)&any_addr6,
sizeof(any_addr6));
#endif
k_thread_spawn(&telnet_stack[0],
TELNET_STACK_SIZE,
(k_thread_entry_t)telnet_run,
NULL, NULL, NULL,
K_PRIO_COOP(TELNET_PRIORITY), 0, K_MSEC(10));
SYS_LOG_INF("Telnet console initialized");
return 0;
}
static int sam_xdmac_initialize(struct device *dev)
{
const struct sam_xdmac_dev_cfg *const dev_cfg = DEV_CFG(dev);
Xdmac *const xdmac = dev_cfg->regs;
/* Configure interrupts */
dev_cfg->irq_config();
/* Enable module's clock */
soc_pmc_peripheral_enable(dev_cfg->periph_id);
/* Disable all channels */
xdmac->XDMAC_GD = UINT32_MAX;
/* Disable all channel interrupts */
xdmac->XDMAC_GID = UINT32_MAX;
/* Enable module's IRQ */
irq_enable(dev_cfg->irq_id);
SYS_LOG_INF("Device %s initialized", DEV_NAME(dev));
return 0;
}
void main(void)
{
int ret;
char ep_name[ENDPOINT_LEN];
SYS_LOG_INF(APP_BANNER);
k_sem_init(&quit_lock, 0, UINT_MAX);
#if defined(CONFIG_NET_L2_BT)
if (bt_enable(NULL)) {
SYS_LOG_ERR("Bluetooth init failed");
return;
}
ipss_init();
ipss_advertise();
#endif
ret = lwm2m_setup();
if (ret < 0) {
SYS_LOG_ERR("Cannot setup LWM2M fields (%d)", ret);
return;
}
#if defined(CONFIG_NET_IPV6)
ret = setup_net_app_ctx(&udp6, CONFIG_NET_APP_PEER_IPV6_ADDR);
if (ret < 0) {
goto cleanup_ipv6;
}
ret = set_endpoint_name(ep_name, udp6.ipv6.local.family);
if (ret < 0) {
SYS_LOG_ERR("Cannot set IPv6 endpoint name (%d)", ret);
goto cleanup_ipv6;
}
ret = lwm2m_engine_start(udp6.ipv6.ctx);
if (ret < 0) {
SYS_LOG_ERR("Cannot init LWM2M IPv6 engine (%d)", ret);
goto cleanup_ipv6;
}
ret = lwm2m_rd_client_start(udp6.ipv6.ctx, &udp6.ipv6.remote,
ep_name);
if (ret < 0) {
SYS_LOG_ERR("LWM2M init LWM2M IPv6 RD client error (%d)",
ret);
goto cleanup_ipv6;
}
SYS_LOG_INF("IPv6 setup complete.");
#endif
#if defined(CONFIG_NET_IPV4)
ret = setup_net_app_ctx(&udp4, CONFIG_NET_APP_PEER_IPV4_ADDR);
if (ret < 0) {
goto cleanup_ipv4;
}
ret = set_endpoint_name(ep_name, udp4.ipv4.local.family);
if (ret < 0) {
SYS_LOG_ERR("Cannot set IPv4 endpoint name (%d)", ret);
goto cleanup_ipv4;
}
ret = lwm2m_engine_start(udp4.ipv4.ctx);
if (ret < 0) {
SYS_LOG_ERR("Cannot init LWM2M IPv4 engine (%d)", ret);
goto cleanup_ipv4;
}
ret = lwm2m_rd_client_start(udp4.ipv4.ctx, &udp4.ipv4.remote,
ep_name);
if (ret < 0) {
SYS_LOG_ERR("LWM2M init LWM2M IPv4 RD client error (%d)",
ret);
goto cleanup_ipv4;
}
SYS_LOG_INF("IPv4 setup complete.");
#endif
k_sem_take(&quit_lock, K_FOREVER);
#if defined(CONFIG_NET_IPV4)
cleanup_ipv4:
net_app_close(&udp4);
net_app_release(&udp4);
#endif
#if defined(CONFIG_NET_IPV6)
cleanup_ipv6:
net_app_close(&udp6);
net_app_release(&udp6);
#endif
}
static void eth0_iface_init(struct net_if *iface)
{
struct device *const dev = net_if_get_device(iface);
struct eth_sam_dev_data *const dev_data = DEV_DATA(dev);
const struct eth_sam_dev_cfg *const cfg = DEV_CFG(dev);
u32_t gmac_ncfgr_val;
u32_t link_status;
int result;
dev_data->iface = iface;
/* Initialize GMAC driver, maximum frame length is 1518 bytes */
gmac_ncfgr_val =
GMAC_NCFGR_MTIHEN /* Multicast Hash Enable */
| GMAC_NCFGR_LFERD /* Length Field Error Frame Discard */
| GMAC_NCFGR_RFCS /* Remove Frame Check Sequence */
| GMAC_NCFGR_RXCOEN; /* Receive Checksum Offload Enable */
result = gmac_init(cfg->regs, gmac_ncfgr_val);
if (result < 0) {
SYS_LOG_ERR("Unable to initialize ETH driver");
return;
}
#ifdef CONFIG_ETH_SAM_GMAC_MAC_I2C_EEPROM
/* Read MAC address from an external EEPROM */
get_mac_addr_from_i2c_eeprom(dev_data->mac_addr);
#endif
SYS_LOG_INF("MAC: %x:%x:%x:%x:%x:%x",
dev_data->mac_addr[0], dev_data->mac_addr[1],
dev_data->mac_addr[2], dev_data->mac_addr[3],
dev_data->mac_addr[4], dev_data->mac_addr[5]);
/* Set MAC Address for frame filtering logic */
mac_addr_set(cfg->regs, 0, dev_data->mac_addr);
/* Register Ethernet MAC Address with the upper layer */
net_if_set_link_addr(iface, dev_data->mac_addr,
sizeof(dev_data->mac_addr),
NET_LINK_ETHERNET);
/* Initialize GMAC queues */
/* Note: Queues 1 and 2 are not used, configured to stay idle */
priority_queue_init_as_idle(cfg->regs, &dev_data->queue_list[2]);
priority_queue_init_as_idle(cfg->regs, &dev_data->queue_list[1]);
result = queue_init(cfg->regs, &dev_data->queue_list[0]);
if (result < 0) {
SYS_LOG_ERR("Unable to initialize ETH queue");
return;
}
/* PHY initialize */
result = phy_sam_gmac_init(&cfg->phy);
if (result < 0) {
SYS_LOG_ERR("ETH PHY Initialization Error");
return;
}
/* PHY auto-negotiate link parameters */
result = phy_sam_gmac_auto_negotiate(&cfg->phy, &link_status);
if (result < 0) {
SYS_LOG_ERR("ETH PHY auto-negotiate sequence failed");
return;
}
/* Set up link parameters */
link_configure(cfg->regs, link_status);
}
void ccm_mode(void)
{
struct device *dev;
struct cipher_ctx ini;
struct cipher_pkt encrpt;
struct cipher_aead_pkt ccm_op;
struct cipher_pkt decrypt;
u8_t encrypted[50];
u8_t decrypted[25];
SYS_LOG_INF("CCM Mode");
dev = device_get_binding(CONFIG_CRYPTO_TINYCRYPT_SHIM_DRV_NAME);
if (!dev) {
SYS_LOG_ERR("TinyCrypt pseudo device not found");
return;
}
if (validate_hw_compatibility(dev)) {
SYS_LOG_ERR("Incompatible h/w");
return;
}
ini.keylen = sizeof(ccm_key);
ini.key.bit_stream = ccm_key;
ini.mode_params.ccm_info.nonce_len = sizeof(ccm_nonce);
ini.mode_params.ccm_info.tag_len = 8;
ini.flags = cap_flags;
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CCM,
CRYPTO_CIPHER_OP_ENCRYPT)) {
return;
}
encrpt.in_buf = ccm_data;
encrpt.in_len = sizeof(ccm_data);
encrpt.out_buf_max = sizeof(encrypted);
encrpt.out_buf = encrypted;
ccm_op.ad = ccm_hdr;
ccm_op.ad_len = sizeof(ccm_hdr);
ccm_op.pkt = &encrpt;
cipher_ccm_op(&ini, &ccm_op, ccm_nonce);
if (memcmp(encrpt.out_buf, ccm_expected, sizeof(ccm_expected))) {
SYS_LOG_ERR("CCM mode ENCRYPT - Mismatch between expected "
"and returned cipher text");
goto out;
}
SYS_LOG_INF("CCM mode ENCRYPT - Match");
cipher_free_session(dev, &ini);
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CCM,
CRYPTO_CIPHER_OP_DECRYPT)) {
return;
}
decrypt.in_buf = encrypted;
decrypt.in_len = sizeof(ccm_data);
decrypt.out_buf = decrypted;
decrypt.out_buf_max = sizeof(decrypted);
ccm_op.pkt = &decrypt;
if (cipher_ccm_op(&ini, &ccm_op, ccm_nonce)) {
SYS_LOG_ERR("CCM mode DECRYPT - Failed");
goto out;
}
if (memcmp(decrypt.out_buf, ccm_data, sizeof(ccm_data))) {
SYS_LOG_ERR("CCM mode DECRYPT - Mismatch between plaintext "
"and decrypted cipher text");
goto out;
}
SYS_LOG_INF("CCM mode DECRYPT - Match");
out:
cipher_free_session(dev, &ini);
}
void ctr_mode(void)
{
struct device *dev;
struct cipher_ctx ini;
struct cipher_pkt encrpt;
struct cipher_pkt decrypt;
u8_t encrypted[64] = {0};
u8_t decrypted[64] = {0};
u8_t iv[12] = {
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb
};
SYS_LOG_INF("CTR Mode");
dev = device_get_binding(CONFIG_CRYPTO_TINYCRYPT_SHIM_DRV_NAME);
if (!dev) {
SYS_LOG_ERR("TinyCrypt pseudo device not found");
return;
}
if (validate_hw_compatibility(dev)) {
SYS_LOG_ERR("Incompatible h/w");
return;
}
ini.keylen = 16;
ini.key.bit_stream = key;
ini.flags = cap_flags;
/* ivlen + ctrlen = keylen , so ctrlen is 128 - 96 = 32 bits */
ini.mode_params.ctr_info.ctr_len = 32;
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CTR,
CRYPTO_CIPHER_OP_ENCRYPT)) {
return;
}
encrpt.in_buf = plaintext;
encrpt.in_len = sizeof(plaintext);
encrpt.out_buf_max = sizeof(encrypted);
encrpt.out_buf = encrypted;
cipher_ctr_op(&ini, &encrpt, iv);
if (memcmp(encrpt.out_buf, ctr_ciphertext, sizeof(ctr_ciphertext))) {
SYS_LOG_ERR("ctr mode ENCRYPT - Mismatch between expected "
"and returned cipher text");
goto out;
}
SYS_LOG_INF("ctr mode ENCRYPT - Match");
cipher_free_session(dev, &ini);
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CTR,
CRYPTO_CIPHER_OP_DECRYPT)) {
return;
}
decrypt.in_buf = encrypted;
decrypt.in_len = sizeof(encrypted);
decrypt.out_buf = decrypted;
decrypt.out_buf_max = sizeof(decrypted);
cipher_ctr_op(&ini, &decrypt, iv);
if (memcmp(decrypt.out_buf, plaintext, sizeof(plaintext))) {
SYS_LOG_ERR("ctr mode DECRYPT - Mismatch between plaintext "
"and decypted cipher text");
goto out;
}
SYS_LOG_INF("ctr mode DECRYPT - Match");
out:
cipher_free_session(dev, &ini);
}
void cbc_mode(void)
{
struct device *dev;
struct cipher_ctx ini;
struct cipher_pkt encrpt;
struct cipher_pkt decrypt;
u8_t encrypted[80];
u8_t decrypted[64];
SYS_LOG_INF("CBC Mode");
dev = device_get_binding(CONFIG_CRYPTO_TINYCRYPT_SHIM_DRV_NAME);
if (!dev) {
SYS_LOG_ERR("TinyCrypt pseudo device not found");
return;
}
if (validate_hw_compatibility(dev)) {
SYS_LOG_ERR("Incompatible h/w");
return;
}
ini.keylen = 16;
ini.key.bit_stream = key;
ini.flags = cap_flags;
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CBC,
CRYPTO_CIPHER_OP_ENCRYPT)) {
return;
}
encrpt.in_buf = plaintext;
encrpt.in_len = sizeof(plaintext);
encrpt.out_buf_max = sizeof(encrypted);
encrpt.out_buf = encrypted;
cipher_cbc_op(&ini, &encrpt, iv);
if (memcmp(encrpt.out_buf, ciphertext, sizeof(ciphertext))) {
SYS_LOG_ERR("cbc mode ENCRYPT - Mismatch between expected and "
"returned cipher text");
goto out;
}
SYS_LOG_INF("cbc mode ENCRYPT - Match");
cipher_free_session(dev, &ini);
if (cipher_begin_session(dev, &ini, CRYPTO_CIPHER_ALGO_AES,
CRYPTO_CIPHER_MODE_CBC,
CRYPTO_CIPHER_OP_DECRYPT)) {
return;
}
decrypt.in_buf = encrpt.out_buf; /* encrypted */
decrypt.in_len = sizeof(encrypted);
decrypt.out_buf = decrypted;
decrypt.out_buf_max = sizeof(decrypted);
/* TinyCrypt keeps IV at the start of encrypted buffer */
cipher_cbc_op(&ini, &decrypt, encrypted);
if (memcmp(decrypt.out_buf, plaintext, sizeof(plaintext))) {
SYS_LOG_ERR("cbc mode DECRYPT - Mismatch between plaintext and "
"decrypted cipher text");
goto out;
}
SYS_LOG_INF("cbc mode DECRYPT - Match");
out:
cipher_free_session(dev, &ini);
}
static int do_registration_reply_cb(const struct zoap_packet *response,
struct zoap_reply *reply,
const struct sockaddr *from)
{
struct zoap_option options[2];
u8_t code;
int ret, index;
code = zoap_header_get_code(response);
SYS_LOG_DBG("Registration callback (code:%u.%u)",
ZOAP_RESPONSE_CODE_CLASS(code),
ZOAP_RESPONSE_CODE_DETAIL(code));
index = find_clients_index(from, false);
if (index < 0) {
SYS_LOG_ERR("Registration client index not found.");
return 0;
}
/* check state and possibly set registration to done */
if (code == ZOAP_RESPONSE_CODE_CREATED) {
ret = zoap_find_options(response, ZOAP_OPTION_LOCATION_PATH,
options, 2);
if (ret < 0) {
return ret;
}
if (ret < 2) {
SYS_LOG_ERR("Unexpected endpoint data returned.");
return -EINVAL;
}
/* option[0] should be "rd" */
if (options[1].len + 1 > sizeof(clients[index].server_ep)) {
SYS_LOG_ERR("Unexpected length of query: "
"%u (expected %zu)\n",
options[1].len,
sizeof(clients[index].server_ep));
return -EINVAL;
}
memcpy(clients[index].server_ep, options[1].value,
options[1].len);
clients[index].server_ep[options[1].len] = '\0';
set_sm_state(index, ENGINE_REGISTRATION_DONE);
clients[index].registered = 1;
SYS_LOG_INF("Registration Done (EP='%s')",
clients[index].server_ep);
return 0;
} else if (code == ZOAP_RESPONSE_CODE_NOT_FOUND) {
SYS_LOG_ERR("Failed: NOT_FOUND. Not Retrying.");
set_sm_state(index, ENGINE_REGISTRATION_DONE);
return 0;
} else if (code == ZOAP_RESPONSE_CODE_FORBIDDEN) {
SYS_LOG_ERR("Failed: 4.03 - Forbidden. Not Retrying.");
set_sm_state(index, ENGINE_REGISTRATION_DONE);
return 0;
}
/* TODO: Read payload for error message? */
/* Possible error response codes: 4.00 Bad request */
SYS_LOG_ERR("failed with code %u.%u. Re-init network",
ZOAP_RESPONSE_CODE_CLASS(code),
ZOAP_RESPONSE_CODE_DETAIL(code));
set_sm_state(index, ENGINE_INIT);
return 0;
}
void main(void)
{
struct device *dev;
u32_t baudrate, dtr = 0;
int ret;
dev = device_get_binding(CONFIG_CDC_ACM_PORT_NAME);
if (!dev) {
SYS_LOG_ERR("CDC ACM device not found");
return;
}
SYS_LOG_DBG("Wait for DTR");
while (1) {
uart_line_ctrl_get(dev, LINE_CTRL_DTR, &dtr);
if (dtr)
break;
}
uart_dev = dev;
SYS_LOG_DBG("DTR set, continue");
#if CONFIG_DCD_DSR
/* They are optional, we use them to test the interrupt endpoint */
ret = uart_line_ctrl_set(dev, LINE_CTRL_DCD, 1);
if (ret)
printk("Failed to set DCD, ret code %d\n", ret);
ret = uart_line_ctrl_set(dev, LINE_CTRL_DSR, 1);
if (ret)
printk("Failed to set DSR, ret code %d\n", ret);
/* Wait 1 sec for the host to do all settings */
sys_thread_busy_wait(1000000);
#endif
ret = uart_line_ctrl_get(dev, LINE_CTRL_BAUD_RATE, &baudrate);
if (ret)
printk("Failed to get baudrate, ret code %d\n", ret);
else
printk("Baudrate detected: %d\n", baudrate);
SYS_LOG_INF("USB serial initialized");
/* Initialize net_pkt */
net_pkt_init();
/* Initialize RX queue */
init_rx_queue();
/* Initialize TX queue */
init_tx_queue();
/* Initialize ieee802154 device */
if (!init_ieee802154()) {
SYS_LOG_ERR("Unable to initialize ieee802154");
return;
};
uart_irq_callback_set(dev, interrupt_handler);
/* Enable rx interrupts */
uart_irq_rx_enable(dev);
/* Enable tx interrupts */
uart_irq_tx_enable(dev);
}
static int eth_initialize(struct device *port)
{
struct eth_runtime *context = port->driver_data;
const struct eth_config *config = port->config->config_info;
uint32_t base_addr;
union {
struct {
uint8_t bytes[6];
uint8_t pad[2];
} __attribute__((packed));
uint32_t words[2];
} mac_addr;
if (!eth_setup(port))
return -EPERM;
base_addr = context->base_addr;
/* Read the MAC address from the device. */
mac_addr.words[1] = eth_read(base_addr, REG_ADDR_MACADDR_HI);
mac_addr.words[0] = eth_read(base_addr, REG_ADDR_MACADDR_LO);
net_set_mac(mac_addr.bytes, sizeof(mac_addr.bytes));
/* Initialize the frame filter enabling unicast messages */
eth_write(base_addr, REG_ADDR_MAC_FRAME_FILTER, MAC_FILTER_4_PM);
/* Initialize transmit descriptor. */
context->tx_desc.tdes0 = 0;
context->tx_desc.tdes1 = 0;
context->tx_desc.buf1_ptr = (uint8_t *)context->tx_buf;
context->tx_desc.tx_end_of_ring = 1;
context->tx_desc.first_seg_in_frm = 1;
context->tx_desc.last_seg_in_frm = 1;
context->tx_desc.tx_end_of_ring = 1;
/* Initialize receive descriptor. */
context->rx_desc.rdes0 = 0;
context->rx_desc.rdes1 = 0;
context->rx_desc.buf1_ptr = (uint8_t *)context->rx_buf;
context->rx_desc.own = 1;
context->rx_desc.first_desc = 1;
context->rx_desc.last_desc = 1;
context->rx_desc.rx_buf1_sz = UIP_BUFSIZE;
context->rx_desc.rx_end_of_ring = 1;
/* Install transmit and receive descriptors. */
eth_write(base_addr, REG_ADDR_RX_DESC_LIST, (uint32_t)&context->rx_desc);
eth_write(base_addr, REG_ADDR_TX_DESC_LIST, (uint32_t)&context->tx_desc);
eth_write(base_addr, REG_ADDR_MAC_CONF,
/* Set the RMII speed to 100Mbps */
MAC_CONF_14_RMII_100M |
/* Enable full-duplex mode */
MAC_CONF_11_DUPLEX |
/* Enable transmitter */
MAC_CONF_3_TX_EN |
/* Enable receiver */
MAC_CONF_2_RX_EN);
eth_write(base_addr, REG_ADDR_INT_ENABLE,
INT_ENABLE_NORMAL |
/* Enable receive interrupts */
INT_ENABLE_RX);
/* Mask all the MMC interrupts */
eth_write(base_addr, REG_MMC_RX_INTR_MASK, MMC_DEFAULT_MASK);
eth_write(base_addr, REG_MMC_TX_INTR_MASK, MMC_DEFAULT_MASK);
eth_write(base_addr, REG_MMC_RX_IPC_INTR_MASK, MMC_DEFAULT_MASK);
eth_write(base_addr, REG_ADDR_DMA_OPERATION,
/* Enable receive store-and-forward mode for simplicity. */
OP_MODE_25_RX_STORE_N_FORWARD |
/* Enable transmit store-and-forward mode for simplicity. */
OP_MODE_21_TX_STORE_N_FORWARD |
/* Place the transmitter state machine in the Running state. */
OP_MODE_13_START_TX |
/* Place the receiver state machine in the Running state. */
OP_MODE_1_START_RX);
SYS_LOG_INF("Enabled 100M full-duplex mode.");
net_driver_ethernet_register_tx(eth_net_tx);
config->config_func(port);
return 0;
}
static int stop(void)
{
SYS_LOG_INF("Stop IEEE 802.15.4 device");
return radio_api->stop(ieee802154_dev);
}
