static int lsm9ds0_gyro_init(struct device *dev)
{
const struct lsm9ds0_gyro_config * const config =
dev->config->config_info;
struct lsm9ds0_gyro_data *data = dev->driver_data;
data->i2c_master = device_get_binding(config->i2c_master_dev_name);
if (!data->i2c_master) {
SYS_LOG_DBG("i2c master not found: %s",
config->i2c_master_dev_name);
return -EINVAL;
}
if (lsm9ds0_gyro_init_chip(dev) < 0) {
SYS_LOG_DBG("failed to initialize chip");
return -EIO;
}
#if defined(CONFIG_LSM9DS0_GYRO_TRIGGER_DRDY)
if (lsm9ds0_gyro_init_interrupt(dev) < 0) {
SYS_LOG_DBG("failed to initialize interrupts");
return -EIO;
}
data->dev = dev;
#endif
dev->driver_api = &lsm9ds0_gyro_api_funcs;
return 0;
}
/* Allocate and send data to USB Host */
static void send_data(u8_t *cfg, u8_t *data, size_t len)
{
struct net_pkt *pkt;
struct net_buf *buf;
pkt = net_pkt_get_reserve_rx(0, K_NO_WAIT);
if (!pkt) {
SYS_LOG_DBG("No pkt available");
return;
}
buf = net_pkt_get_frag(pkt, K_NO_WAIT);
if (!buf) {
SYS_LOG_DBG("No fragment available");
net_pkt_unref(pkt);
return;
}
net_pkt_frag_insert(pkt, buf);
SYS_LOG_DBG("queue pkt %p buf %p len %u", pkt, buf, len);
/* Add configuration id */
memcpy(net_buf_add(buf, 2), cfg, 2);
memcpy(net_buf_add(buf, len), data, len);
/* simulate LQI */
net_buf_add(buf, 1);
/* simulate FCS */
net_buf_add(buf, 2);
k_fifo_put(&tx_queue, pkt);
}
/**
* @brief configure MPU regions for the memory partitions of the memory domain
*
* @param mem_domain memory domain that thread belongs to
*/
void arm_core_mpu_configure_mem_domain(struct k_mem_domain *mem_domain)
{
u32_t region_index =
_get_region_index_by_type(THREAD_DOMAIN_PARTITION_REGION);
u32_t num_partitions;
struct k_mem_partition *pparts;
struct arm_mpu_region region_conf;
if (mem_domain) {
SYS_LOG_DBG("configure domain: %p", mem_domain);
num_partitions = mem_domain->num_partitions;
pparts = mem_domain->partitions;
} else {
SYS_LOG_DBG("disable domain partition regions");
num_partitions = 0;
pparts = NULL;
}
for (; region_index < _get_num_regions(); region_index++) {
if (num_partitions && pparts->size) {
SYS_LOG_DBG("set region 0x%x 0x%x 0x%x",
region_index, pparts->start, pparts->size);
region_conf.base = pparts->start;
_get_ram_region_attr_by_conf(®ion_conf.attr,
pparts->attr, pparts->start, pparts->size);
_region_init(region_index, ®ion_conf);
num_partitions--;
} else {
_disable_region(region_index);
}
pparts++;
}
}
/**
* @brief Handler called for Class requests not handled by the USB stack.
*
* @param pSetup Information about the request to execute.
* @param len Size of the buffer.
* @param data Buffer containing the request result.
*
* @return 0 on success, negative errno code on fail.
*/
static int mass_storage_class_handle_req(struct usb_setup_packet *pSetup,
int32_t *len, uint8_t **data)
{
switch (pSetup->bRequest) {
case MSC_REQUEST_RESET:
SYS_LOG_DBG("\nMSC_REQUEST_RESET");
msd_state_machine_reset();
break;
case MSC_REQUEST_GET_MAX_LUN:
SYS_LOG_DBG("\nMSC_REQUEST_GET_MAX_LUN ");
max_lun_count = 0;
*data = (uint8_t *)(&max_lun_count);
*len = 1;
break;
default:
SYS_LOG_DBG("Mass Storage unknown request 0x%x, value 0x%x",
pSetup->bRequest, pSetup->wValue);
return -EINVAL;
}
return 0;
}
static int do_deregister_reply_cb(const struct zoap_packet *response,
struct zoap_reply *reply,
const struct sockaddr *from)
{
u8_t code;
int index;
code = zoap_header_get_code(response);
SYS_LOG_DBG("Deregister 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 clients index not found.");
return 0;
}
if (code == ZOAP_RESPONSE_CODE_DELETED) {
clients[index].registered = 0;
SYS_LOG_DBG("Deregistration success");
set_sm_state(index, ENGINE_DEREGISTERED);
} else {
SYS_LOG_ERR("failed with code %u.%u",
ZOAP_RESPONSE_CODE_CLASS(code),
ZOAP_RESPONSE_CODE_DETAIL(code));
if (get_sm_state(index) == ENGINE_DEREGISTER_SENT) {
set_sm_state(index, ENGINE_DEREGISTER_FAILED);
}
}
return 0;
}
static int amg88xx_init_device(struct device *dev)
{
struct amg88xx_data *drv_data = dev->driver_data;
u8_t tmp;
if (amg88xx_reg_read(drv_data, AMG88XX_PCLT, &tmp)) {
SYS_LOG_ERR("Failed to read Power mode");
return -EIO;
}
SYS_LOG_DBG("Power mode 0x%02x", tmp);
if (tmp != AMG88XX_PCLT_NORMAL_MODE) {
if (amg88xx_reg_write(drv_data, AMG88XX_PCLT,
AMG88XX_PCLT_NORMAL_MODE)) {
return -EIO;
}
k_busy_wait(AMG88XX_WAIT_MODE_CHANGE_US);
}
if (amg88xx_reg_write(drv_data, AMG88XX_RST,
AMG88XX_RST_INITIAL_RST)) {
return -EIO;
}
k_busy_wait(AMG88XX_WAIT_INITIAL_RESET_US);
if (amg88xx_reg_write(drv_data, AMG88XX_FPSC, AMG88XX_FPSC_10FPS)) {
return -EIO;
}
SYS_LOG_DBG("");
return 0;
}
int bmg160_trigger_init(struct device *dev)
{
const struct bmg160_device_config *cfg = dev->config->config_info;
struct bmg160_device_data *bmg160 = dev->driver_data;
/* set INT1 pin to: push-pull, active low */
if (bmg160_write_byte(dev, BMG160_REG_INT_EN1, 0) < 0) {
SYS_LOG_DBG("Failed to select interrupt pins type.");
return -EIO;
}
/* set interrupt mode to non-latched */
if (bmg160_write_byte(dev, BMG160_REG_INT_RST_LATCH, 0) < 0) {
SYS_LOG_DBG("Failed to set the interrupt mode.");
return -EIO;
}
/* map anymotion and high rate interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP0,
BMG160_INT1_ANY | BMG160_INT1_HIGH) < 0) {
SYS_LOG_DBG("Unable to map interrupts.");
return -EIO;
}
/* map data ready, FIFO and FastOffset interrupts to INT1 pin */
if (bmg160_write_byte(dev, BMG160_REG_INT_MAP1,
BMG160_INT1_DATA | BMG160_INT1_FIFO |
BMG160_INT1_FAST_OFFSET) < 0) {
SYS_LOG_DBG("Unable to map interrupts.");
return -EIO;
}
bmg160->gpio = device_get_binding((char *)cfg->gpio_port);
if (!bmg160->gpio) {
SYS_LOG_DBG("Gpio controller %s not found", cfg->gpio_port);
return -EINVAL;
}
#if defined(CONFIG_BMG160_TRIGGER_OWN_THREAD)
k_sem_init(&bmg160->trig_sem, 0, UINT_MAX);
k_thread_create(&bmg160_thread, bmg160_thread_stack,
CONFIG_BMG160_THREAD_STACK_SIZE, bmg160_thread_main,
dev, NULL, NULL, K_PRIO_COOP(10), 0, 0);
#elif defined(CONFIG_BMG160_TRIGGER_GLOBAL_THREAD)
bmg160->work.handler = bmg160_work_cb;
bmg160->dev = dev;
#endif
gpio_pin_configure(bmg160->gpio, cfg->int_pin,
GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE |
GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE);
gpio_init_callback(&bmg160->gpio_cb, bmg160_gpio_callback,
BIT(cfg->int_pin));
gpio_add_callback(bmg160->gpio, &bmg160->gpio_cb);
gpio_pin_enable_callback(bmg160->gpio, cfg->int_pin);
return 0;
}
static int spi_dw_configure(struct device *dev,
struct spi_config *config)
{
const struct spi_dw_config *info = dev->config->config_info;
struct spi_dw_data *spi = dev->driver_data;
u32_t flags = config->config;
u32_t ctrlr0 = 0;
u32_t mode;
SYS_LOG_DBG("%p (0x%x), %p", dev, info->regs, config);
/* Check status */
if (!_spi_dw_is_controller_ready(dev)) {
SYS_LOG_DBG("Controller is busy");
return -EBUSY;
}
/* Word size */
ctrlr0 |= DW_SPI_CTRLR0_DFS(SPI_WORD_SIZE_GET(flags));
/* Determine how many bytes are required per-frame */
spi->dfs = SPI_WS_TO_DFS(SPI_WORD_SIZE_GET(flags));
/* SPI mode */
mode = SPI_MODE(flags);
if (mode & SPI_MODE_CPOL) {
ctrlr0 |= DW_SPI_CTRLR0_SCPOL;
}
if (mode & SPI_MODE_CPHA) {
ctrlr0 |= DW_SPI_CTRLR0_SCPH;
}
if (mode & SPI_MODE_LOOP) {
ctrlr0 |= DW_SPI_CTRLR0_SRL;
}
/* Installing the configuration */
write_ctrlr0(ctrlr0, info->regs);
/*
* Configure the rate. Use this small hack to allow the user to call
* spi_configure() with both a divider (as the driver was initially
* written) and a frequency (as the SPI API suggests to). The clock
* divider is a 16bit value, hence we can fairly, and safely, assume
* that everything above this value is a frequency. The trade-off is
* that if one wants to use a bus frequency of 64kHz (or less), it has
* the use a divider...
*/
if (config->max_sys_freq > 0xffff) {
write_baudr(SPI_DW_CLK_DIVIDER(config->max_sys_freq),
info->regs);
} else {
write_baudr(config->max_sys_freq, info->regs);
}
return 0;
}
static inline int lsm9ds0_mfd_sample_fetch_accel(struct device *dev)
{
struct lsm9ds0_mfd_data *data = dev->driver_data;
const struct lsm9ds0_mfd_config *config = dev->config->config_info;
u8_t out_l, out_h;
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_X)
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_X_L_A, &out_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_X_H_A, &out_h) < 0) {
SYS_LOG_DBG("failed to read accel sample (X axis)");
return -EIO;
}
data->sample_accel_x = (s16_t)((u16_t)(out_l) |
((u16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Y)
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_Y_L_A, &out_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_Y_H_A, &out_h) < 0) {
SYS_LOG_DBG("failed to read accel sample (Y axis)");
return -EIO;
}
data->sample_accel_y = (s16_t)((u16_t)(out_l) |
((u16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_ENABLE_Z)
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_Z_L_A, &out_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_MFD_REG_OUT_Z_H_A, &out_h) < 0) {
SYS_LOG_DBG("failed to read accel sample (Z axis)");
return -EIO;
}
data->sample_accel_z = (s16_t)((u16_t)(out_l) |
((u16_t)(out_h) << 8));
#endif
#if defined(CONFIG_LSM9DS0_MFD_ACCEL_FULL_SCALE_RUNTIME)
data->sample_accel_fs = data->accel_fs;
#endif
return 0;
}
static int i2c_dw_initialize(struct device *dev)
{
const struct i2c_dw_rom_config * const rom = dev->config->config_info;
struct i2c_dw_dev_config * const dw = dev->driver_data;
volatile struct i2c_dw_registers *regs;
if (!i2c_dw_pci_setup(dev)) {
dev->driver_api = NULL;
return -EIO;
}
k_sem_init(&dw->device_sync_sem, 0, UINT_MAX);
regs = (struct i2c_dw_registers *) dw->base_address;
/* verify that we have a valid DesignWare register first */
if (regs->ic_comp_type != I2C_DW_MAGIC_KEY) {
dev->driver_api = NULL;
SYS_LOG_DBG("I2C: DesignWare magic key not found, check base "
"address. Stopping initialization");
return -EIO;
}
/*
* grab the default value on initialization. This should be set to the
* IC_MAX_SPEED_MODE in the hardware. If it does support high speed we
* can move provide support for it
*/
if (regs->ic_con.bits.speed == I2C_DW_SPEED_HIGH) {
SYS_LOG_DBG("I2C: high speed supported");
dw->support_hs_mode = true;
} else {
SYS_LOG_DBG("I2C: high speed NOT supported");
dw->support_hs_mode = false;
}
rom->config_func(dev);
dw->app_config = I2C_MODE_MASTER | _i2c_map_dt_bitrate(rom->bitrate);
if (i2c_dw_runtime_configure(dev, dw->app_config) != 0) {
SYS_LOG_DBG("I2C: Cannot set default configuration");
return -EIO;
}
dw->state = I2C_DW_STATE_READY;
return 0;
}
static void tx_thread(void)
{
SYS_LOG_DBG("Tx thread started");
while (1) {
uint8_t cmd;
struct net_buf *pkt, *buf;
pkt = net_buf_get(&tx_queue, K_FOREVER);
buf = net_buf_frag_last(pkt);
cmd = net_buf_pull_u8(buf);
hexdump(">", buf->data, buf->len);
switch (cmd) {
case RESET:
SYS_LOG_DBG("Reset device");
break;
case TX:
tx(pkt);
break;
case START:
start();
break;
case STOP:
stop();
break;
case SET_CHANNEL:
set_channel(buf->data, buf->len);
break;
case SET_IEEE_ADDR:
set_ieee_addr(buf->data, buf->len);
break;
case SET_SHORT_ADDR:
set_short_addr(buf->data, buf->len);
break;
case SET_PAN_ID:
set_pan_id(buf->data, buf->len);
break;
default:
SYS_LOG_ERR("%x: Not handled for now", cmd);
break;
}
net_nbuf_unref(pkt);
k_yield();
}
}
static void testUnitReady(void)
{
if (cbw.DataLength != 0) {
if ((cbw.Flags & 0x80) != 0) {
SYS_LOG_DBG("TUR - BI - STALL");
usb_ep_set_stall(EPBULK_IN);
} else {
SYS_LOG_DBG("TUR - BO - STALL");
usb_ep_set_stall(EPBULK_OUT);
}
}
csw.Status = CSW_PASSED;
sendCSW();
}
int stm32_i2c_msg_read(struct device *dev, struct i2c_msg *msg,
u8_t *next_msg_flags, uint16_t slave)
{
const struct i2c_stm32_config *cfg = DEV_CFG(dev);
struct i2c_stm32_data *data = DEV_DATA(dev);
I2C_TypeDef *i2c = cfg->i2c;
data->current.len = msg->len;
data->current.buf = msg->buf;
data->current.is_write = 0;
data->current.is_arlo = 0;
data->current.is_err = 0;
data->current.is_nack = 0;
data->current.msg = msg;
msg_init(dev, msg, next_msg_flags, slave, LL_I2C_REQUEST_READ);
stm32_i2c_enable_transfer_interrupts(dev);
LL_I2C_EnableIT_RX(i2c);
k_sem_take(&data->device_sync_sem, K_FOREVER);
if (data->current.is_nack || data->current.is_err ||
data->current.is_arlo) {
goto error;
}
return 0;
error:
if (data->current.is_arlo) {
SYS_LOG_DBG("%s: ARLO %d", __func__,
data->current.is_arlo);
data->current.is_arlo = 0;
}
if (data->current.is_nack) {
SYS_LOG_DBG("%s: NACK", __func__);
data->current.is_nack = 0;
}
if (data->current.is_err) {
SYS_LOG_DBG("%s: ERR %d", __func__,
data->current.is_err);
data->current.is_err = 0;
}
return -EIO;
}
static void sx9500_thread_main(int arg1, int unused)
{
struct device *dev = INT_TO_POINTER(arg1);
struct sx9500_data *data = dev->driver_data;
uint8_t reg_val;
ARG_UNUSED(unused);
while (1) {
k_sem_take(&data->sem, K_FOREVER);
if (i2c_reg_read_byte(data->i2c_master, data->i2c_slave_addr,
SX9500_REG_IRQ_SRC, ®_val) < 0) {
SYS_LOG_DBG("sx9500: error %d reading IRQ source register", ret);
continue;
}
if ((reg_val & SX9500_CONV_DONE_IRQ) && data->handler_drdy) {
data->handler_drdy(dev, &data->trigger_drdy);
}
if ((reg_val & SX9500_NEAR_FAR_IRQ) && data->handler_near_far) {
data->handler_near_far(dev, &data->trigger_near_far);
}
}
}
int lis3dh_sample_fetch(struct device *dev, enum sensor_channel chan)
{
struct lis3dh_data *drv_data = dev->driver_data;
uint8_t buf[6];
int rc;
__ASSERT(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_ACCEL_ANY);
/*
* since all accel data register addresses are consecutive,
* a burst read can be used to read all the samples
*/
rc = i2c_burst_read(drv_data->i2c, LIS3DH_I2C_ADDRESS,
LIS3DH_REG_ACCEL_X_LSB, buf, 6);
if (rc != 0) {
SYS_LOG_DBG("Could not read accel axis data");
return -EIO;
}
drv_data->x_sample = (buf[1] << 8) | buf[0];
drv_data->y_sample = (buf[3] << 8) | buf[2];
drv_data->z_sample = (buf[5] << 8) | buf[4];
return 0;
}
static int lsm6ds0_sample_fetch_gyro(struct device *dev)
{
struct lsm6ds0_data *data = dev->driver_data;
const struct lsm6ds0_config *config = dev->config->config_info;
u8_t buf[6];
if (i2c_burst_read(data->i2c_master, config->i2c_slave_addr,
LSM6DS0_REG_OUT_X_L_G, buf, sizeof(buf)) < 0) {
SYS_LOG_DBG("failed to read sample");
return -EIO;
}
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
data->gyro_sample_x = (s16_t)((u16_t)(buf[0]) |
((u16_t)(buf[1]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
data->gyro_sample_y = (s16_t)((u16_t)(buf[2]) |
((u16_t)(buf[3]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
data->gyro_sample_z = (s16_t)((u16_t)(buf[4]) |
((u16_t)(buf[5]) << 8));
#endif
return 0;
}
static int sm_do_init(int index)
{
SYS_LOG_DBG("RD Client started with endpoint "
"'%s' and client lifetime %d",
clients[index].ep_name,
clients[index].lifetime);
/* Zephyr has joined network already */
clients[index].has_registration_info = 1;
clients[index].registered = 0;
clients[index].bootstrapped = 0;
clients[index].trigger_update = 0;
#if defined(CONFIG_LWM2M_BOOTSTRAP_SERVER)
clients[index].use_bootstrap = 1;
#else
clients[index].use_registration = 1;
#endif
if (clients[index].lifetime == 0) {
clients[index].lifetime = CONFIG_LWM2M_ENGINE_DEFAULT_LIFETIME;
}
/* Do bootstrap or registration */
if (clients[index].use_bootstrap) {
set_sm_state(index, ENGINE_DO_BOOTSTRAP);
} else {
set_sm_state(index, ENGINE_DO_REGISTRATION);
}
return 0;
}
static void process_data(struct net_pkt *pkt)
{
struct net_buf *buf = net_buf_frag_last(pkt->frags);
u8_t seq, num_attr;
int ret, i;
seq = net_buf_pull_u8(buf);
num_attr = net_buf_pull_u8(buf);
SYS_LOG_DBG("seq %u num_attr %u", seq, num_attr);
/**
* There are some attributes sent over this protocol
* discard them and return packet data report.
*/
for (i = 0; i < num_attr; i++) {
/* attr */
net_buf_pull_u8(buf);
/* value */
net_buf_pull_be16(buf);
}
/* Transmit data through radio */
ret = radio_api->tx(ieee802154_dev, pkt, buf);
if (ret) {
SYS_LOG_ERR("Error transmit data");
}
/* TODO: Return correct status codes */
/* TODO: Implement re-transmissions if needed */
/* Send packet data report */
send_pkt_report(seq, ret, 1);
}
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();
}
}
static int lps25hb_sample_fetch(struct device *dev,
enum sensor_channel chan)
{
struct lps25hb_data *data = dev->driver_data;
const struct lps25hb_config *config = dev->config->config_info;
u8_t out[5];
int offset;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
for (offset = 0; offset < sizeof(out); ++offset) {
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LPS25HB_REG_PRESS_OUT_XL + offset,
out + offset) < 0) {
SYS_LOG_DBG("failed to read sample");
return -EIO;
}
}
data->sample_press = (s32_t)((u32_t)(out[0]) |
((u32_t)(out[1]) << 8) |
((u32_t)(out[2]) << 16));
data->sample_temp = (s16_t)((u16_t)(out[3]) |
((u16_t)(out[4]) << 8));
return 0;
}
static inline void telnet_reply_command(void)
{
if (k_sem_take(&cmd_lock, K_NO_WAIT)) {
return;
}
if (!telnet_cmd.iac) {
goto out;
}
switch (telnet_cmd.op) {
case NVT_CMD_AO:
/* OK, no output then */
__printk_hook_install(telnet_console_out_nothing);
telnet_rb_init();
break;
case NVT_CMD_AYT:
telnet_reply_ay_command();
break;
case NVT_CMD_DO:
telnet_reply_do_command();
break;
default:
SYS_LOG_DBG("Operation %u not handled",
telnet_cmd.op);
break;
}
telnet_cmd.iac = NVT_NUL;
telnet_cmd.op = NVT_NUL;
telnet_cmd.opt = NVT_NUL;
out:
k_sem_give(&cmd_lock);
}
int stm32_i2c_configure_timing(struct device *dev, u32_t clock)
{
const struct i2c_stm32_config *cfg = DEV_CFG(dev);
struct i2c_stm32_data *data = DEV_DATA(dev);
I2C_TypeDef *i2c = cfg->i2c;
u32_t i2c_hold_time_min, i2c_setup_time_min;
u32_t i2c_h_min_time, i2c_l_min_time;
u32_t presc = 1;
u32_t timing = 0;
switch (I2C_SPEED_GET(data->dev_config)) {
case I2C_SPEED_STANDARD:
i2c_h_min_time = 4000;
i2c_l_min_time = 4700;
i2c_hold_time_min = 500;
i2c_setup_time_min = 1250;
break;
case I2C_SPEED_FAST:
i2c_h_min_time = 600;
i2c_l_min_time = 1300;
i2c_hold_time_min = 375;
i2c_setup_time_min = 500;
break;
default:
return -EINVAL;
}
/* Calculate period until prescaler matches */
do {
u32_t t_presc = clock / presc;
u32_t ns_presc = NSEC_PER_SEC / t_presc;
u32_t sclh = i2c_h_min_time / ns_presc;
u32_t scll = i2c_l_min_time / ns_presc;
u32_t sdadel = i2c_hold_time_min / ns_presc;
u32_t scldel = i2c_setup_time_min / ns_presc;
if ((sclh - 1) > 255 || (scll - 1) > 255) {
++presc;
continue;
}
if (sdadel > 15 || (scldel - 1) > 15) {
++presc;
continue;
}
timing = __LL_I2C_CONVERT_TIMINGS(presc - 1,
scldel - 1, sdadel, sclh - 1, scll - 1);
break;
} while (presc < 16);
if (presc >= 16) {
SYS_LOG_DBG("I2C:failed to find prescaler value");
return -EINVAL;
}
LL_I2C_SetTiming(i2c, timing);
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);
}
int tmp007_attr_set(struct device *dev,
enum sensor_channel chan,
enum sensor_attribute attr,
const struct sensor_value *val)
{
struct tmp007_data *drv_data = dev->driver_data;
int64_t value;
uint8_t reg;
if (chan != SENSOR_CHAN_TEMP) {
return -ENOTSUP;
}
if (attr == SENSOR_ATTR_UPPER_THRESH) {
reg = TMP007_REG_TOBJ_TH_HIGH;
} else if (attr == SENSOR_ATTR_LOWER_THRESH) {
reg = TMP007_REG_TOBJ_TH_LOW;
} else {
return -ENOTSUP;
}
value = (int64_t)val->val1 * 1000000 + val->val2;
value = (value / TMP007_TEMP_TH_SCALE) << 6;
if (tmp007_reg_write(drv_data, reg, value) != 0) {
SYS_LOG_DBG("Failed to set attribute!");
return -EIO;
}
return 0;
}
int i2c_stm32_slave_unregister(struct device *dev,
struct i2c_slave_config *config)
{
const struct i2c_stm32_config *cfg = DEV_CFG(dev);
struct i2c_stm32_data *data = DEV_DATA(dev);
I2C_TypeDef *i2c = cfg->i2c;
if (!data->slave_attached) {
return -EINVAL;
}
if (data->master_active) {
return -EBUSY;
}
LL_I2C_DisableOwnAddress1(i2c);
LL_I2C_DisableIT_ADDR(i2c);
stm32_i2c_disable_transfer_interrupts(dev);
LL_I2C_ClearFlag_NACK(i2c);
LL_I2C_ClearFlag_STOP(i2c);
LL_I2C_ClearFlag_ADDR(i2c);
LL_I2C_Disable(i2c);
SYS_LOG_DBG("i2c: slave unregistered");
return 0;
}
/*
* Process successfully sent packets
*/
static void tx_completed(Gmac *gmac, struct gmac_queue *queue)
{
struct gmac_desc_list *tx_desc_list = &queue->tx_desc_list;
struct gmac_desc *tx_desc;
struct net_pkt *pkt;
__ASSERT(tx_desc_list->buf[tx_desc_list->tail].w1 & GMAC_TXW1_USED,
"first buffer of a frame is not marked as own by GMAC");
while (tx_desc_list->tail != tx_desc_list->head) {
tx_desc = &tx_desc_list->buf[tx_desc_list->tail];
MODULO_INC(tx_desc_list->tail, tx_desc_list->len);
k_sem_give(&queue->tx_desc_sem);
if (tx_desc->w1 & GMAC_TXW1_LASTBUFFER) {
/* Release net buffer to the buffer pool */
pkt = UINT_TO_POINTER(ring_buf_get(&queue->tx_frames));
net_pkt_unref(pkt);
SYS_LOG_DBG("Dropping pkt %p", pkt);
break;
}
}
}
/*
* Reset TX queue when errors are detected
*/
static void tx_error_handler(Gmac *gmac, struct gmac_queue *queue)
{
struct net_pkt *pkt;
struct ring_buf *tx_frames = &queue->tx_frames;
queue->err_tx_flushed_count++;
/* Stop transmission, clean transmit pipeline and control registers */
gmac->GMAC_NCR &= ~GMAC_NCR_TXEN;
/* Free all pkt resources in the TX path */
while (tx_frames->tail != tx_frames->head) {
/* Release net buffer to the buffer pool */
pkt = UINT_TO_POINTER(tx_frames->buf[tx_frames->tail]);
net_pkt_unref(pkt);
SYS_LOG_DBG("Dropping pkt %p", pkt);
MODULO_INC(tx_frames->tail, tx_frames->len);
}
/* Reinitialize TX descriptor list */
k_sem_reset(&queue->tx_desc_sem);
tx_descriptors_init(gmac, queue);
for (int i = 0; i < queue->tx_desc_list.len - 1; i++) {
k_sem_give(&queue->tx_desc_sem);
}
/* Restart transmission */
gmac->GMAC_NCR |= GMAC_NCR_TXEN;
}
static int wpanusb_init(struct device *dev)
{
struct wpanusb_dev_data_t * const dev_data = DEV_DATA(dev);
int ret;
SYS_LOG_DBG("");
wpanusb_config.interface.payload_data = dev_data->interface_data;
wpanusb_dev = dev;
/* Initialize the USB driver with the right configuration */
ret = usb_set_config(&wpanusb_config);
if (ret < 0) {
SYS_LOG_ERR("Failed to configure USB");
return ret;
}
/* Enable USB driver */
ret = usb_enable(&wpanusb_config);
if (ret < 0) {
SYS_LOG_ERR("Failed to enable USB");
return ret;
}
return 0;
}
void spi_dw_isr(void *arg)
{
struct device *dev = (struct device *)arg;
const struct spi_dw_config *info = dev->config->config_info;
u32_t error = 0;
u32_t int_status;
int_status = read_isr(info->regs);
SYS_LOG_DBG("SPI int_status 0x%x - (tx: %d, rx: %d)",
int_status, read_txflr(info->regs), read_rxflr(info->regs));
if (int_status & DW_SPI_ISR_ERRORS_MASK) {
error = 1;
goto out;
}
if (int_status & DW_SPI_ISR_RXFIS) {
pull_data(dev);
}
if (int_status & DW_SPI_ISR_TXEIS) {
push_data(dev);
}
out:
clear_interrupts(info->regs);
completed(dev, error);
}
static int lsm9ds0_gyro_sample_fetch(struct device *dev,
enum sensor_channel chan)
{
struct lsm9ds0_gyro_data *data = dev->driver_data;
const struct lsm9ds0_gyro_config *config = dev->config->config_info;
uint8_t x_l, x_h, y_l, y_h, z_l, z_h;
__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL || chan == SENSOR_CHAN_GYRO_ANY);
if (i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_X_L_G, &x_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_X_H_G, &x_h) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_Y_L_G, &y_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_Y_H_G, &y_h) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_Z_L_G, &z_l) < 0 ||
i2c_reg_read_byte(data->i2c_master, config->i2c_slave_addr,
LSM9DS0_GYRO_REG_OUT_Z_H_G, &z_h) < 0) {
SYS_LOG_DBG("failed to read sample");
return -EIO;
}
data->sample_x = (int16_t)((uint16_t)(x_l) | ((uint16_t)(x_h) << 8));
data->sample_y = (int16_t)((uint16_t)(y_l) | ((uint16_t)(y_h) << 8));
data->sample_z = (int16_t)((uint16_t)(z_l) | ((uint16_t)(z_h) << 8));
#if defined(CONFIG_LSM9DS0_GYRO_FULLSCALE_RUNTIME)
data->sample_fs = data->fs;
#endif
return 0;
}
