Aksal/nuttx
3
1
Fork 1
mirror of https://github.com/apache/nuttx.git synced 2026-09-30 19:06:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

sched/semaphore: Fix pre-existing nxstyle issues in the touched files

Browse source 
The CI style check runs nxstyle over every file a pull request touches,
so the files changed by the previous two commits have to comply even
where the problems were not introduced here.  504 errors in 25 files are
fixed: whitespace, blank lines, brace placement, switch/case indentation,
label indentation and comment blocks only, with no functional change.

Assisted-by: DeepSeek Harness:deepseek-flash
Signed-off-by: rongbaichuan <rongbaichuan1027@163.com>
This commit is contained in:
rongbaichuan 2026-09-24 18:50:32 +08:00 • committed by Alin Jerpelea
parent 9c461f03ac
commit 00a379c3f7
25 changed files with 965 additions and 832 deletions
Download patch file Download diff file Expand all files Collapse all files

22
arch/arm/src/rtl8720c/amebaz_depend.c
View file

@ -61,6 +61,7 @@ static irqstate_t g_flags = 0;
void save_and_cli(void)
{
irqstate_t flags = rspin_lock_irqsave(&g_lock);
if (!rspin_lock_is_recursive(&g_lock))
{
g_flags = flags;
@ -166,6 +167,7 @@ void rtw_memset(void *pbuf, int c, uint32_t n)
void rtw_init_sema(void **sema, int init_val)
{
sem_t *_sema;
_sema = calloc(1, sizeof(sem_t));
if (!_sema)
{
@ -309,6 +311,7 @@ int rtw_init_xqueue(void **queue,
struct mq_attr attr;
struct file *mq;
int ret;
mq = malloc(sizeof(struct file));
if (!mq)
{
@ -334,6 +337,7 @@ int rtw_push_to_xqueue(void **queue, void *message, uint32_t timeout_ms)
{
struct file *mq = *queue;
struct mq_attr attr;
file_mq_getattr(mq, &attr);
return file_mq_send(mq, message, attr.mq_msgsize, 1);
}
@ -343,6 +347,7 @@ int rtw_pop_from_xqueue(void **queue, void *message, uint32_t timeout_ms)
struct file *mq = *queue;
struct mq_attr attr;
unsigned int prio;
file_mq_getattr(mq, &attr);
return !file_mq_receive(mq, message, attr.mq_msgsize, &prio);
}
@ -351,6 +356,7 @@ int rtw_deinit_xqueue(void **queue)
{
struct file *mq = *queue;
int ret;
ret = file_mq_close(mq);
if (ret >= 0)
{
@ -465,6 +471,7 @@ void ATOMIC_DEC(atomic_t *v)
int ATOMIC_ADD_RETURN(atomic_t *v, int i)
{
int temp;
save_and_cli();
temp = v->counter;
temp += i;
@ -476,6 +483,7 @@ int ATOMIC_ADD_RETURN(atomic_t *v, int i)
int ATOMIC_SUB_RETURN(atomic_t *v, int i)
{
int temp;
save_and_cli();
temp = v->counter;
temp -= i;
@ -510,6 +518,7 @@ static unsigned int __div64_32(uint64_t *n, unsigned int base)
uint64_t res;
uint64_t d = 1;
unsigned int high = rem >> 32;
res = 0;
if (high >= base)
{
@ -544,6 +553,7 @@ uint64_t rtw_modular64(uint64_t x, uint64_t y)
{
unsigned int __base = (y);
unsigned int __rem;
if (((x) >> 32) == 0)
{
__rem = (unsigned int)(x) % __base;
@ -562,6 +572,7 @@ static int arc4random(void)
{
uint32_t res = rtw_get_current_time();
static unsigned long rtw_seed = 0xdeadb00b;
rtw_seed = ((rtw_seed & 0x007f00ff) << 7) ^
((rtw_seed & 0x0f80ff00) >> 8) ^
(res << 13) ^ (res >> 9);
@ -574,6 +585,7 @@ int rtw_get_random_bytes(void *dst, uint32_t size)
unsigned int *lp;
int i;
int count;
count = size / sizeof(unsigned int);
lp = (unsigned int *)dst;
for (i = 0; i < count; i++)
@ -599,6 +611,7 @@ static int nuttx_task_hook(int argc, char *argv[])
{
struct task_struct *task;
struct nthread_wrapper *wrap;
task = (struct task_struct *)
((uintptr_t)strtoul(argv[1], NULL, 16));
if (!task || !task->priv)
@ -623,6 +636,7 @@ int rtw_create_task(struct task_struct *task, const char *name,
char *argv[2];
char arg1[16];
int pid;
snprintf(arg1, 16, "%p", task);
argv[0] = arg1;
argv[1] = NULL;
@ -659,6 +673,7 @@ int rtw_create_task(struct task_struct *task, const char *name,
void rtw_delete_task(struct task_struct *task)
{
struct nthread_wrapper *wrap = task->priv;
if (kill(wrap->pid, SIGKILL))
{
return;
@ -696,6 +711,7 @@ void *rtw_timer_create(const signed char *pctimername,
thread_func_t pxcallbackfunction)
{
struct ntimer_wrapper *wrap;
wrap = calloc(1, sizeof(*wrap));
if (!wrap)
{
@ -710,6 +726,7 @@ uint32_t rtw_timer_stop(void *xtimer,
unsigned long xblocktime)
{
struct ntimer_wrapper *wrap = xtimer;
if (!work_available(&wrap->work))
{
work_cancel(LPWORK, &wrap->work);
@ -722,6 +739,7 @@ uint32_t rtw_timer_delete(void *xtimer,
unsigned long xblocktime)
{
struct ntimer_wrapper *wrap = xtimer;
rtw_timer_stop(xtimer, xblocktime);
free(wrap);
return 1;
@ -730,6 +748,7 @@ uint32_t rtw_timer_delete(void *xtimer,
uint32_t rtw_timer_is_timer_active(void *xtimer)
{
struct ntimer_wrapper *wrap = xtimer;
return !work_available(&wrap->work);
}
@ -738,6 +757,7 @@ uint32_t rtw_timer_change_period(void *xtimer,
unsigned long xblocktime)
{
struct ntimer_wrapper *wrap = xtimer;
if (work_available(&wrap->work))
{
work_queue(LPWORK, &wrap->work, wrap->callback, wrap, xnewperiod);
@ -872,6 +892,7 @@ static void *device_mutex[5];
static void device_mutex_init(uint32_t device)
{
irqstate_t status;
if (atomic_or(&mutex_init, (1 << device)) & (1 << device) == 0)
{
rtw_mutex_init(&device_mutex[device]);
@ -897,6 +918,7 @@ void device_mutex_unlock(uint32_t device)
uint32_t rtw_get_free_heap_size(void)
{
struct mallinfo mem;
mem = mallinfo();
return mem.arena;
}

34
arch/risc-v/src/bl602/bl602_os_hal.c
View file

@ -938,6 +938,7 @@ static void bl_os_timer_callback(wdparm_t arg)
void *bl_os_timer_create(void *func, void *argv)
{
struct timer_adpt *timer = kmm_malloc(sizeof(struct timer_adpt));
if (!timer)
{
ASSERT(0);
@ -1065,6 +1066,7 @@ int bl_os_timer_start_periodic(void *timerid, long t_sec, long t_nsec)
void *bl_os_workqueue_create(void)
{
struct work_s *work = kmm_calloc(1, sizeof(struct work_s));
if (!work)
{
ASSERT(0);
@ -1145,6 +1147,7 @@ int bl_os_workqueue_submit_lpwork(void *work,
uint64_t bl_os_clock_gettime_ms(void)
{
struct timespec ts;
clock_systime_timespec(&ts);
return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}
@ -1521,23 +1524,23 @@ static void bl_os_log_writev(uint32_t level,
{
switch (level)
{
case LOG_LEVEL_ERROR:
{
vsyslog(LOG_ERR, format, args);
break;
}
case LOG_LEVEL_ERROR:
{
vsyslog(LOG_ERR, format, args);
break;
}
case LOG_LEVEL_WARN:
{
vsyslog(LOG_WARNING, format, args);
break;
}
case LOG_LEVEL_WARN:
{
vsyslog(LOG_WARNING, format, args);
break;
}
case LOG_LEVEL_INFO:
{
vsyslog(LOG_INFO, format, args);
break;
}
case LOG_LEVEL_INFO:
{
vsyslog(LOG_INFO, format, args);
break;
}
}
}
@ -1569,6 +1572,7 @@ void bl_os_log_write(uint32_t level,
if (&_wifi_log_flag)
{
va_list list;
va_start(list, format);
bl_os_log_writev(level, tag, NULL, 0, format, list);
va_end(list);

3
arch/risc-v/src/esp32c3-legacy/esp32c3_ble_adapter.c
View file

@ -2282,7 +2282,7 @@ int esp32c3_bt_controller_enable(esp_bt_mode_t mode)
if (g_lp_cntl.enable)
{
btdm_controller_enable_sleep(true);
btdm_controller_enable_sleep(true);
}
if (btdm_controller_enable(mode) != 0)
@ -2381,6 +2381,7 @@ void esp32c3_vhci_host_send_packet(uint8_t *data, uint16_t len)
int esp32c3_vhci_register_callback(const esp_vhci_host_callback_t *callback)
{
int ret = -1;
if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_ENABLED)
{
return ret;

6
arch/risc-v/src/esp32c3-legacy/esp32c3_wifi_adapter.c
View file

@ -4695,9 +4695,9 @@ esp_err_t esp_wifi_deinit(void)
}
#ifdef CONFIG_PM
esp32c3_pm_unregister_skip_sleep_callback(
esp32c3_pm_unregister_skip_sleep_callback(
esp_wifi_internal_is_tsf_active);
esp32c3_pm_unregister_inform_out_sleep_overhead_callback(
esp32c3_pm_unregister_inform_out_sleep_overhead_callback(
esp_wifi_internal_update_light_sleep_wake_ahead_time);
#endif
return ret;
@ -5464,6 +5464,7 @@ int esp_wifi_sta_connect(void)
{
int scan_retry = 3;
int retry_cnt = 0;
memset(&config, 0x0, sizeof(wifi_scan_config_t));
config.scan_type = IW_SCAN_TYPE_ACTIVE;
config.channel = g_channel;
@ -6916,6 +6917,7 @@ void esp_wifi_stop_callback(void)
wlinfo("Trying to stop Wi-Fi...");
int ret = esp_wifi_stop();
if (ret)
{
wlerr("ERROR: Failed to stop Wi-Fi ret=%d\n", ret);

11
arch/risc-v/src/esp32c3/esp_ble_adapter.c
View file

@ -919,6 +919,7 @@ static void *semphr_create_wrapper(uint32_t max, uint32_t init)
static void semphr_delete_wrapper(void *semphr)
{
struct bt_sem_s *bt_sem = (struct bt_sem_s *)semphr;
nxsem_destroy(&bt_sem->sem);
kmm_free(bt_sem);
}
@ -1432,6 +1433,7 @@ static int task_create_wrapper(void *task_func, const char *name,
static void task_delete_wrapper(void *task_handle)
{
pid_t pid = (pid_t)((uintptr_t)task_handle);
kthread_delete(pid);
}
@ -1471,6 +1473,7 @@ static bool IRAM_ATTR is_in_isr_wrapper(void)
static void *malloc_wrapper(size_t size)
{
void * p = kmm_malloc(size);
DEBUGASSERT(p);
return p;
@ -2567,6 +2570,7 @@ static esp_err_t btdm_low_power_mode_init(esp_bt_controller_config_t *cfg)
static void btdm_controller_mem_init(void)
{
extern void btdm_controller_rom_data_init(void);
btdm_controller_rom_data_init();
}
@ -2598,8 +2602,8 @@ static void bt_controller_deinit_internal(void)
if (g_osi_funcs_p != NULL)
{
free(g_osi_funcs_p);
g_osi_funcs_p = NULL;
free(g_osi_funcs_p);
g_osi_funcs_p = NULL;
}
g_btdm_controller_status = ESP_BT_CONTROLLER_STATUS_IDLE;
@ -3305,7 +3309,7 @@ error:
#endif
#if CONFIG_ESPRESSIF_WIFI_BT_COEXIST
coex_disable();
coex_disable();
#endif
if (g_lp_stat.phy_enabled)
{
@ -3476,6 +3480,7 @@ void esp_vhci_host_send_packet(uint8_t *data, uint16_t len)
int esp_vhci_register_callback(const esp_vhci_host_callback_t *callback)
{
int ret = ERROR;
if (g_btdm_controller_status != ESP_BT_CONTROLLER_STATUS_ENABLED)
{
return ret;

1
arch/risc-v/src/esp32c3/esp_coex_adapter.c
View file

@ -574,6 +574,7 @@ uint32_t esp_coex_common_clk_slowclk_cal_get_wrapper(void)
if (GET_PERI_REG_MASK(SYSTEM_BT_LPCK_DIV_FRAC_REG, SYSTEM_LPCLK_SEL_XTAL))
{
uint64_t time_per_us = 1000000ULL;
return (((time_per_us << RTC_CLK_CAL_FRACT) / (MHZ)) >>
(RTC_CLK_CAL_FRACT - SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH));
}

1
arch/risc-v/src/esp32c3/esp_wifi_adapter.c
View file

@ -1716,6 +1716,7 @@ static void esp_log_write_wrapper(unsigned int level,
if (level <= max_level)
{
va_list list;
va_start(list, format);
esp_log_writev(level, tag, format, list);
va_end(list);

1
arch/risc-v/src/esp32c6/esp_wifi_adapter.c
View file

@ -1703,6 +1703,7 @@ static void esp_log_write_wrapper(unsigned int level,
if (level <= max_level)
{
va_list list;
va_start(list, format);
esp_log_writev(level, tag, format, list);
va_end(list);

5
arch/xtensa/src/esp32/esp32_ble_adapter.c
View file

@ -1016,6 +1016,7 @@ static void *semphr_create_wrapper(uint32_t max, uint32_t init)
static void semphr_delete_wrapper(void *semphr)
{
struct bt_sem_s *bt_sem = (struct bt_sem_s *)semphr;
sem_destroy(&bt_sem->sem);
kmm_free(bt_sem);
}
@ -1533,6 +1534,7 @@ static int32_t task_create_wrapper(void *task_func, const char *name,
static void task_delete_wrapper(void *task_handle)
{
pid_t pid = (pid_t)((uintptr_t)task_handle);
kthread_delete(pid);
}
@ -1702,6 +1704,7 @@ static uint32_t IRAM_ATTR btdm_lpcycles_2_us(uint32_t cycles)
*/
uint64_t us = (uint64_t)g_btdm_lpcycle_us * cycles;
us = (us + (1 << (g_btdm_lpcycle_us_frac - 1))) >> g_btdm_lpcycle_us_frac;
return (uint32_t)us;
}
@ -1728,6 +1731,7 @@ static uint32_t IRAM_ATTR btdm_us_2_lpcycles(uint32_t us)
*/
uint64_t cycles;
cycles = ((uint64_t)(us) << g_btdm_lpcycle_us_frac) / g_btdm_lpcycle_us;
return (uint32_t)cycles;
}
@ -2493,6 +2497,7 @@ static void IRAM_ATTR cause_sw_intr(void *arg)
/* just convert void * to int, because the width is the same */
uint32_t intr_no = (uint32_t)arg;
XTHAL_SET_INTSET((1 << intr_no));
}

7
arch/xtensa/src/esp32/esp32_himem_chardev.c
View file

@ -222,7 +222,7 @@ static off_t himem_chardev_seek(struct file *filep,
merr("invalid parameter: whence:%d\n", whence);
nxmutex_unlock(&lock);
return -1;
}
}
filep->f_pos = priv->offset;
nxmutex_unlock(&lock);
return priv->offset;
@ -251,6 +251,7 @@ static const struct file_operations g_fops =
int himem_chardev_init(void)
{
int ret = 0;
ret = esp_himem_init();
if (ret != 0)
{
@ -275,6 +276,7 @@ int himem_chardev_init(void)
int himem_chardev_exit(void)
{
int ret = 0;
nxmutex_destroy(&lock);
ret = esp_himem_free_map_range(g_range_handle);
@ -287,6 +289,7 @@ int himem_chardev_register(char *name, size_t size)
int ret = 0;
struct himem_chardev_s *dev =
kmm_malloc(sizeof(struct himem_chardev_s));
if (dev == NULL)
{
merr("Failed to malloc.\n");
@ -296,6 +299,7 @@ int himem_chardev_register(char *name, size_t size)
/* 32KB Alignment */
size_t mod = size % ESP_HIMEM_BLKSZ;
if (mod != 0)
{
size += (ESP_HIMEM_BLKSZ - mod);
@ -352,6 +356,7 @@ int himem_chardev_unregister(char *name)
int success = 0;
struct himem_chardev_s *dev;
struct himem_chardev_s *tmp;
nxmutex_lock(&lock);
list_for_every_entry_safe(&g_himem_chardev_list, dev,
tmp, struct himem_chardev_s, node)

4
arch/xtensa/src/esp32/esp32_wifi_adapter.c
View file

@ -2690,6 +2690,7 @@ static void esp_log_write_wrapper(unsigned int level,
if (level <= max_level)
{
va_list list;
va_start(list, format);
esp_log_writev(level, tag, format, list);
va_end(list);
@ -2757,6 +2758,7 @@ static void *esp_realloc_internal(void *ptr, size_t size)
void *old_ptr = ptr;
void *new_ptr = NULL;
size_t old_size = 0;
if (size == 0)
{
kmm_free(ptr);
@ -2806,6 +2808,7 @@ static void *esp_calloc_internal(size_t n, size_t size)
return xtensa_imm_calloc(n, size);
#else
void *ptr = kmm_calloc(n, size);
if (ptr != NULL)
{
if (esp32_ptr_extram(ptr))
@ -2841,6 +2844,7 @@ static void *esp_zalloc_internal(size_t size)
return xtensa_imm_zalloc(size);
#else
void *ptr = kmm_zalloc(size);
if (ptr != NULL)
{
if (esp32_ptr_extram(ptr))

11
arch/xtensa/src/esp32s2/esp32s2_wifi_adapter.c
View file

@ -1792,7 +1792,7 @@ static void IRAM_ATTR esp_empty_wrapper(void)
static void esp_phy_enable_wrapper(void)
{
esp_phy_enable(PHY_MODEM_WIFI);
esp_phy_enable(PHY_MODEM_WIFI);
}
/****************************************************************************
@ -1812,7 +1812,7 @@ static void esp_phy_enable_wrapper(void)
static void esp_phy_disable_wrapper(void)
{
esp_phy_disable(PHY_MODEM_WIFI);
esp_phy_disable(PHY_MODEM_WIFI);
}
/****************************************************************************
@ -2458,10 +2458,11 @@ static uint32_t esp_clk_slowclk_cal_get_wrapper(void)
if (REG_GET_FIELD(SYSTEM_BT_LPCK_DIV_FRAC_REG, SYSTEM_LPCLK_SEL_XTAL))
{
uint64_t time_per_us = 1000000ULL;
return (((time_per_us << RTC_CLK_CAL_FRACT) / (MHZ)) >>
(RTC_CLK_CAL_FRACT - SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH));
}
else
else
{
return (getreg32(RTC_SLOW_CLK_CAL_REG) >>
(RTC_CLK_CAL_FRACT - SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH));
@ -2541,6 +2542,7 @@ static void esp_log_write_wrapper(unsigned int level,
if (level <= max_level)
{
va_list list;
va_start(list, format);
esp_log_writev(level, tag, format, list);
va_end(list);
@ -2608,6 +2610,7 @@ static void *esp_realloc_internal(void *ptr, size_t size)
void *old_ptr = ptr;
void *new_ptr = NULL;
size_t old_size = 0;
if (size == 0)
{
kmm_free(ptr);
@ -2657,6 +2660,7 @@ static void *esp_calloc_internal(size_t n, size_t size)
return xtensa_imm_calloc(n, size);
#else
void *ptr = kmm_calloc(n, size);
if (ptr != NULL)
{
if (esp32s2_ptr_extram(ptr))
@ -2692,6 +2696,7 @@ static void *esp_zalloc_internal(size_t size)
return xtensa_imm_zalloc(size);
#else
void *ptr = kmm_zalloc(size);
if (ptr != NULL)
{
if (esp32s2_ptr_extram(ptr))

13
arch/xtensa/src/esp32s3/esp32s3_ble_adapter.c
View file

@ -897,6 +897,7 @@ static void *semphr_create_wrapper(uint32_t max, uint32_t init)
static void semphr_delete_wrapper(void *semphr)
{
struct bt_sem_s *bt_sem = (struct bt_sem_s *)semphr;
nxsem_destroy(&bt_sem->sem);
kmm_free(bt_sem);
}
@ -1410,6 +1411,7 @@ static int task_create_wrapper(void *task_func, const char *name,
static void task_delete_wrapper(void *task_handle)
{
pid_t pid = (pid_t)((uintptr_t)task_handle);
kthread_delete(pid);
}
@ -1449,6 +1451,7 @@ static bool IRAM_ATTR is_in_isr_wrapper(void)
static void *malloc_wrapper(size_t size)
{
void * p = kmm_malloc(size);
DEBUGASSERT(p);
return p;
@ -2561,6 +2564,7 @@ static esp_err_t btdm_low_power_mode_init(esp_bt_controller_config_t *cfg)
static void btdm_controller_mem_init(void)
{
extern void btdm_controller_rom_data_init(void);
btdm_controller_rom_data_init();
}
@ -2592,8 +2596,8 @@ static void bt_controller_deinit_internal(void)
if (g_osi_funcs_p != NULL)
{
free(g_osi_funcs_p);
g_osi_funcs_p = NULL;
free(g_osi_funcs_p);
g_osi_funcs_p = NULL;
}
g_btdm_controller_status = ESP_BT_CONTROLLER_STATUS_IDLE;
@ -3296,7 +3300,7 @@ int esp32s3_bt_controller_enable(esp_bt_mode_t mode)
if (g_lp_cntl.enable)
{
btdm_controller_enable_sleep(true);
btdm_controller_enable_sleep(true);
}
/* Disable pll track by default in BLE controller on ESP32-C3 and
@ -3342,7 +3346,7 @@ error:
#endif
#if CONFIG_ESPRESSIF_WIFI_BT_COEXIST
coex_disable();
coex_disable();
#endif
if (g_lp_stat.phy_enabled)
{
@ -3513,6 +3517,7 @@ void esp32s3_vhci_host_send_packet(uint8_t *data, uint16_t len)
int esp32s3_vhci_register_callback(const esp_vhci_host_callback_t *callback)
{
int ret = ERROR;
if (g_btdm_controller_status != ESP_BT_CONTROLLER_STATUS_ENABLED)
{
return ret;

15
arch/xtensa/src/esp32s3/esp32s3_wifi_adapter.c
View file

@ -1937,8 +1937,8 @@ static void wifi_apb80m_release(void)
static void esp_phy_enable_wrapper(void)
{
esp_phy_enable(PHY_MODEM_WIFI);
phy_wifi_enable_set(1);
esp_phy_enable(PHY_MODEM_WIFI);
phy_wifi_enable_set(1);
}
/****************************************************************************
@ -1959,8 +1959,8 @@ static void esp_phy_enable_wrapper(void)
static void esp_phy_disable_wrapper(void)
{
phy_wifi_enable_set(0);
esp_phy_disable(PHY_MODEM_WIFI);
phy_wifi_enable_set(0);
esp_phy_disable(PHY_MODEM_WIFI);
}
/****************************************************************************
@ -2630,10 +2630,11 @@ static uint32_t esp_clk_slowclk_cal_get_wrapper(void)
if (REG_GET_FIELD(SYSTEM_BT_LPCK_DIV_FRAC_REG, SYSTEM_LPCLK_SEL_XTAL))
{
uint64_t time_per_us = 1000000ULL;
return (((time_per_us << RTC_CLK_CAL_FRACT) / (MHZ)) >>
(RTC_CLK_CAL_FRACT - SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH));
}
else
else
{
return (getreg32(RTC_SLOW_CLK_CAL_REG) >>
(RTC_CLK_CAL_FRACT - SOC_WIFI_LIGHT_SLEEP_CLK_WIDTH));
@ -2713,6 +2714,7 @@ static void esp_log_write_wrapper(unsigned int level,
if (level <= max_level)
{
va_list list;
va_start(list, format);
esp_log_writev(level, tag, format, list);
va_end(list);
@ -2780,6 +2782,7 @@ static void *esp_realloc_internal(void *ptr, size_t size)
void *old_ptr = ptr;
void *new_ptr = NULL;
size_t old_size = 0;
if (size == 0)
{
kmm_free(ptr);
@ -2829,6 +2832,7 @@ static void *esp_calloc_internal(size_t n, size_t size)
return xtensa_imm_calloc(n, size);
#else
void *ptr = kmm_calloc(n, size);
if (ptr != NULL)
{
if (esp32s3_ptr_extram(ptr))
@ -2864,6 +2868,7 @@ static void *esp_zalloc_internal(size_t size)
return xtensa_imm_zalloc(size);
#else
void *ptr = kmm_zalloc(size);
if (ptr != NULL)
{
if (esp32s3_ptr_extram(ptr))

12
drivers/mtd/mtd_config_nvs.c
View file

@ -629,6 +629,7 @@ static int nvs_flash_block_move(FAR struct nvs_fs *fs,
while (len)
{
size_t bytes_to_copy = MIN(buf_size, len);
rc = nvs_flash_rd(fs, addr, buf, bytes_to_copy);
if (rc)
{
@ -650,6 +651,7 @@ static int nvs_flash_block_move(FAR struct nvs_fs *fs,
uint32_t end_addr = MIN(data_end, addr + bytes_to_copy);
uint32_t begin_addr = MAX(data_begin, addr);
data_crc8 = crc8part(buf + (begin_addr - addr),
end_addr - begin_addr, data_crc8);
}
@ -853,6 +855,7 @@ static int nvs_flash_wrt_entry(FAR struct nvs_fs *fs, uint32_t id,
FAR const void *data, size_t len)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(entry, ate_size);
uint8_t buf[NVS_BUFFER_SIZE(fs)];
uint16_t copy_len = 0;
@ -947,6 +950,7 @@ static int nvs_recover_last_ate(FAR struct nvs_fs *fs,
FAR uint32_t *addr)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(end_ate, ate_size);
uint32_t data_end_addr;
uint32_t ate_end_addr;
@ -1001,6 +1005,7 @@ static int nvs_prev_ate(FAR struct nvs_fs *fs, FAR uint32_t *addr,
FAR struct nvs_ate *ate)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(close_ate, ate_size);
int rc;
@ -1088,6 +1093,7 @@ static void nvs_block_advance(FAR struct nvs_fs *fs, FAR uint32_t *addr)
static int nvs_block_close(FAR struct nvs_fs *fs)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(close_ate, ate_size);
int rc;
@ -1123,6 +1129,7 @@ static int nvs_block_close(FAR struct nvs_fs *fs)
static int nvs_add_gc_done_ate(FAR struct nvs_fs *fs)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(gc_done_ate, ate_size);
finfo("Adding gc done ate at %" PRIx32 "\n",
@ -1144,6 +1151,7 @@ static int nvs_add_gc_done_ate(FAR struct nvs_fs *fs)
static int nvs_expire_ate(FAR struct nvs_fs *fs, uint32_t addr)
{
uint8_t expired[NVS_BUFFER_SIZE(fs)];
memset(expired, ~fs->erasestate, fs->progsize);
return nvs_flash_wrt(fs, addr + nvs_align_up(fs, sizeof(struct nvs_ate)),
@ -1163,6 +1171,7 @@ static int nvs_expire_ate(FAR struct nvs_fs *fs, uint32_t addr)
static int nvs_gc(FAR struct nvs_fs *fs)
{
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(close_ate, ate_size);
NVS_ATE(gc_ate, ate_size);
uint32_t gc_prev_addr;
@ -1328,6 +1337,7 @@ static int nvs_startup(FAR struct nvs_fs *fs)
fs->progsize = geo.blocksize;
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(second_ate, ate_size);
NVS_ATE(last_ate, ate_size);
@ -1477,6 +1487,7 @@ static int nvs_startup(FAR struct nvs_fs *fs)
*/
bool gc_done_marker = false;
NVS_ATE(gc_done_ate, ate_size);
addr = fs->ate_wra + ate_size;
@ -1825,6 +1836,7 @@ static ssize_t nvs_write(FAR struct nvs_fs *fs,
size_t data_size;
size_t key_size;
size_t ate_size = nvs_ate_size(fs);
NVS_ATE(wlk_ate, ate_size);
uint32_t wlk_addr;
uint32_t rd_addr;

204
drivers/sensors/l86xxx_uorb.c
View file

@ -157,6 +157,7 @@ static int set_baud_rate(l86xxx_dev_s *dev, int br)
{
struct termios opt;
int err;
err = file_ioctl(&dev->uart, TCGETS, &opt);
if (err < 0)
{
@ -175,17 +176,17 @@ static int set_baud_rate(l86xxx_dev_s *dev, int br)
case 38400:
case 57600:
case 115200:
{
cfsetispeed(&opt, br);
cfsetospeed(&opt, br);
break;
}
{
cfsetispeed(&opt, br);
cfsetospeed(&opt, br);
break;
}
default:
{
snerr("Invalid baud rate, %ld\n", br);
return -EINVAL;
}
{
snerr("Invalid baud rate, %ld\n", br);
return -EINVAL;
}
}
err = file_ioctl(&dev->uart, TCSETS, &opt);
@ -196,8 +197,8 @@ static int set_baud_rate(l86xxx_dev_s *dev, int br)
}
/* These calls to read_line will flush out the buffer
after the baud rate change
*/
* after the baud rate change
*/
for (int i = 0; i < 5; ++i)
{
@ -247,43 +248,43 @@ static int send_command(l86xxx_dev_s *dev,
uint8_t checksum;
switch (cmd)
{
case CMD_HOT_START:
case CMD_WARM_START:
case CMD_COLD_START:
case CMD_FULL_COLD_START:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d", cmd);
break;
}
case CMD_HOT_START:
case CMD_WARM_START:
case CMD_COLD_START:
case CMD_FULL_COLD_START:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d", cmd);
break;
}
case CMD_STANDBY_MODE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,0", cmd);
break;
}
case CMD_STANDBY_MODE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,0", cmd);
break;
}
case SET_NMEA_BAUDRATE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
case SET_NMEA_BAUDRATE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
case SET_POS_FIX:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
case SET_POS_FIX:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
case FR_MODE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
case FR_MODE:
{
bw1 = snprintf(buf, sizeof(buf), "$PMTK%d,%d", cmd, (int)arg);
break;
}
default:
return -ENOSYS;
}
default:
return -ENOSYS;
}
sninfo("Sending command: %s to L86", buf);
checksum = minmea_checksum(buf);
@ -292,10 +293,10 @@ static int send_command(l86xxx_dev_s *dev,
nxmutex_lock(&dev->devlock);
err = file_write(&dev->uart, buf, bw1 + bw2);
if (err < 0)
{
snerr("Could not send command to device\n");
goto early_ret;
}
{
snerr("Could not send command to device\n");
goto early_ret;
}
/* These commands do not send ACKs so just return after they've been
* written
@ -315,15 +316,15 @@ static int send_command(l86xxx_dev_s *dev,
*/
if (cmd == SET_NMEA_BAUDRATE)
{
{
#ifdef CONFIG_SERIAL_TERMIOS
nxsched_usleep(20000); /* Should wait for a bit before changing interface baud rate */
err = set_baud_rate(dev, (int)arg);
nxsched_usleep(20000); /* Should wait for a bit before changing interface baud rate */
err = set_baud_rate(dev, (int)arg);
#else
err = -EINVAL;
err = -EINVAL;
#endif
goto early_ret;
}
goto early_ret;
}
/* Some commands will send ACKs,
* wait for them here before unlocking the mutex
@ -358,24 +359,24 @@ static int send_command(l86xxx_dev_s *dev,
sninfo("ACK received!\n");
/* Flag num is always in position 13 of ack, subtract by '0'
to obtain return val
*/
* to obtain return val
*/
switch (dev->buffer[13] - '0')
{
case 1:
err = -ENOSYS;
break;
case 2:
err = -EIO;
break;
case 3:
err = 0;
break;
default:
err = -EINVAL;
break;
break;
case 1:
err = -ENOSYS;
break;
case 2:
err = -EIO;
break;
case 3:
err = 0;
break;
default:
err = -EINVAL;
break;
break;
}
early_ret:
@ -439,41 +440,42 @@ static int l86xxx_control(FAR struct gnss_lowerhalf_s *lower,
{
FAR l86xxx_dev_s *dev = container_of(lower, FAR l86xxx_dev_s, lower);
L86XXX_PMTK_COMMAND pmtk_cmd;
switch (cmd)
{
case SNIOC_HOT_START:
pmtk_cmd = CMD_HOT_START;
break;
case SNIOC_WARM_START:
pmtk_cmd = CMD_WARM_START;
break;
case SNIOC_COLD_START:
pmtk_cmd = CMD_COLD_START;
break;
case SNIOC_FULL_COLD_START:
pmtk_cmd = CMD_FULL_COLD_START;
break;
case SNIOC_SET_INTERVAL:
pmtk_cmd = SET_POS_FIX;
break;
case SNIOC_SET_BAUD:
pmtk_cmd = SET_NMEA_BAUDRATE;
break;
case SNIOC_SET_OPERATIONAL_MODE:
if (arg == STANDBY)
{
pmtk_cmd = CMD_STANDBY_MODE;
}
else
{
pmtk_cmd = FR_MODE;
}
break;
default:
snerr("Unsupported command\n");
return -ENOSYS;
}
switch (cmd)
{
case SNIOC_HOT_START:
pmtk_cmd = CMD_HOT_START;
break;
case SNIOC_WARM_START:
pmtk_cmd = CMD_WARM_START;
break;
case SNIOC_COLD_START:
pmtk_cmd = CMD_COLD_START;
break;
case SNIOC_FULL_COLD_START:
pmtk_cmd = CMD_FULL_COLD_START;
break;
case SNIOC_SET_INTERVAL:
pmtk_cmd = SET_POS_FIX;
break;
case SNIOC_SET_BAUD:
pmtk_cmd = SET_NMEA_BAUDRATE;
break;
case SNIOC_SET_OPERATIONAL_MODE:
if (arg == STANDBY)
{
pmtk_cmd = CMD_STANDBY_MODE;
}
else
{
pmtk_cmd = FR_MODE;
}
break;
default:
snerr("Unsupported command\n");
return -ENOSYS;
}
return send_command(dev, pmtk_cmd, arg);
}

99
drivers/sensors/lis2mdl_uorb.c
View file

@ -1019,6 +1019,7 @@ static int lis2mdl_set_calibvalue(FAR struct sensor_lowerhalf_s *lower,
/* Get user calibration values */
FAR float *vals = (float *)(arg);
if (vals == NULL)
{
err = -EINVAL;
@ -1061,6 +1062,7 @@ static int lis2mdl_fetch(FAR struct sensor_lowerhalf_s *lower,
{
FAR struct lis2mdl_dev_s *dev =
container_of(lower, FAR struct lis2mdl_dev_s, lower);
return lis2mdl_push_data(dev);
}
#endif /* CONFIG_SENSORS_LIS2MDL_FETCH */
@ -1085,63 +1087,64 @@ static int lis2mdl_control(FAR struct sensor_lowerhalf_s *lower,
switch (cmd)
{
/* Get the WHOAMI register value */
/* Get the WHOAMI register value */
case SNIOC_WHO_AM_I:
{
uint8_t *id = ((uint8_t *)(arg));
if (id == NULL)
{
err = -EINVAL;
break;
}
case SNIOC_WHO_AM_I:
{
uint8_t *id = ((uint8_t *)(arg));
err = lis2mdl_read_reg(dev, REG_WHO_AM_I, id, 1);
}
break;
if (id == NULL)
{
err = -EINVAL;
break;
}
/* Set low power mode if `arg` is truthy */
err = lis2mdl_read_reg(dev, REG_WHO_AM_I, id, 1);
}
break;
case SNIOC_SET_POWER_MODE:
{
err = lis2mdl_low_power(dev, arg);
}
break;
/* Set low power mode if `arg` is truthy */
/* Soft reset */
case SNIOC_SET_POWER_MODE:
{
err = lis2mdl_low_power(dev, arg);
}
break;
case SNIOC_RESET:
{
err = lis2mdl_reset(dev);
}
break;
/* Soft reset */
/* Reboot memory contents */
case SNIOC_RESET:
{
err = lis2mdl_reset(dev);
}
break;
case SNIOC_SENSOR_OFF:
{
err = lis2mdl_reboot(dev);
}
break;
/* Reboot memory contents */
/* Enable/disable temperature compensation */
case SNIOC_SENSOR_OFF:
{
err = lis2mdl_reboot(dev);
}
break;
case SNIOC_SET_TEMP_OFFSET:
{
err = lis2mdl_temp_compensation(dev, arg);
}
break;
/* Enable/disable temperature compensation */
case SNIOC_LPF:
{
err = lis2mdl_enable_lpf(dev, arg);
}
break;
case SNIOC_SET_TEMP_OFFSET:
{
err = lis2mdl_temp_compensation(dev, arg);
}
break;
default:
err = -EINVAL;
snerr("Unknown command for LIS2MDL: %d\n", cmd);
break;
case SNIOC_LPF:
{
err = lis2mdl_enable_lpf(dev, arg);
}
break;
default:
err = -EINVAL;
snerr("Unknown command for LIS2MDL: %d\n", cmd);
break;
}
nxmutex_unlock(&dev->devlock);
@ -1159,6 +1162,7 @@ static int lis2mdl_control(FAR struct sensor_lowerhalf_s *lower,
static void lis2mdl_worker(FAR void *arg)
{
FAR struct lis2mdl_dev_s *dev = (FAR struct lis2mdl_dev_s *)(arg);
DEBUGASSERT(dev != NULL);
lis2mdl_push_data(dev);
}
@ -1175,6 +1179,7 @@ static int lis2mdl_int_handler(int irq, FAR void *context, FAR void *arg)
{
FAR struct lis2mdl_dev_s *dev = (FAR struct lis2mdl_dev_s *)(arg);
int err;
(void)context;
DEBUGASSERT(dev != NULL);
@ -1366,9 +1371,9 @@ int lis2mdl_register(FAR struct i2c_master_s *i2c, int devno, uint8_t addr,
if (err < 0)
{
sensor_unreg:
sensor_unreg:
sensor_unregister(&priv->lower, devno);
del_sem:
del_sem:
nxsem_destroy(&priv->run);
nxmutex_destroy(&priv->devlock);
kmm_free(priv);

146
drivers/sensors/lsm6dso32_uorb.c
View file

@ -520,6 +520,7 @@ static int gyro_set_fsr(FAR struct lsm6dso32_dev_s *dev,
enum lsm6dso32_fsr_gyro_e fsr)
{
int err;
err = lsm6dso32_set_bits(dev, CTRL2_G, (fsr & 0x7) << 1, 0x0c);
if (err < 0)
@ -772,6 +773,7 @@ static int gyro_int_handler(int irq, FAR void *context, FAR void *arg)
{
FAR struct lsm6dso32_dev_s *dev = (FAR struct lsm6dso32_dev_s *)(arg);
int err;
(void)(context);
DEBUGASSERT(arg != NULL);
@ -800,6 +802,7 @@ static int accel_int_handler(int irq, FAR void *context, FAR void *arg)
{
FAR struct lsm6dso32_dev_s *dev = (FAR struct lsm6dso32_dev_s *)(arg);
int err;
(void)(context);
DEBUGASSERT(arg != NULL);
@ -1569,79 +1572,80 @@ static int lsm6dso32_control(FAR struct sensor_lowerhalf_s *lower,
{
/* Read WHO_AM_I value into 8-bit unsigned integer buffer */
case SNIOC_WHO_AM_I:
{
uint8_t *id = (uint8_t *)(arg);
if (id == NULL)
{
err = -EINVAL;
break;
}
case SNIOC_WHO_AM_I:
{
uint8_t *id = (uint8_t *)(arg);
err = lsm6dso32_read_bytes(dev, WHO_AM_I, id, sizeof(uint8_t));
}
break;
if (id == NULL)
{
err = -EINVAL;
break;
}
case SNIOC_SETFULLSCALE:
{
/* Accelerometer FSR */
err = lsm6dso32_read_bytes(dev, WHO_AM_I, id, sizeof(uint8_t));
}
break;
if (lower->type == SENSOR_TYPE_ACCELEROMETER)
{
switch (arg)
{
case 4:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_4G);
break;
case 8:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_8G);
break;
case 16:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_16G);
break;
case 32:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_32G);
break;
default:
err = -EINVAL;
break;
}
}
case SNIOC_SETFULLSCALE:
{
/* Accelerometer FSR */
/* Gyroscope FSR */
if (lower->type == SENSOR_TYPE_ACCELEROMETER)
{
switch (arg)
{
case 4:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_4G);
break;
case 8:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_8G);
break;
case 16:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_16G);
break;
case 32:
err = accel_set_fsr(dev, LSM6DSO32_FSR_XL_32G);
break;
default:
err = -EINVAL;
break;
}
}
else if (lower->type == SENSOR_TYPE_GYROSCOPE)
{
switch (arg)
{
case 125:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_125DPS);
break;
case 250:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_250DPS);
break;
case 500:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_500DPS);
break;
case 1000:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_1000DPS);
break;
case 2000:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_2000DPS);
break;
default:
err = -EINVAL;
break;
}
}
}
break;
/* Gyroscope FSR */
default:
{
err = -EINVAL;
}
break;
else if (lower->type == SENSOR_TYPE_GYROSCOPE)
{
switch (arg)
{
case 125:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_125DPS);
break;
case 250:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_250DPS);
break;
case 500:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_500DPS);
break;
case 1000:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_1000DPS);
break;
case 2000:
err = gyro_set_fsr(dev, LSM6DSO32_FSR_GY_2000DPS);
break;
default:
err = -EINVAL;
break;
}
}
}
break;
default:
{
err = -EINVAL;
}
break;
}
nxmutex_unlock(&dev->devlock);
@ -2020,17 +2024,17 @@ int lsm6dso32_register(FAR struct i2c_master_s *i2c, uint8_t addr,
if (err < 0)
{
unreg_gyro_handler:
unreg_gyro_handler:
if (config->xl_attach != NULL)
{
kthread_delete(gyro_pid);
}
unreg_accel:
unreg_accel:
sensor_unregister(&priv->accel.lower, devno);
unreg_gyro:
unreg_gyro:
sensor_unregister(&priv->gyro.lower, devno);
del_accel_sem:
del_accel_sem:
nxsem_destroy(&priv->accel.run);
nxsem_destroy(&priv->gyro.run);
nxmutex_destroy(&priv->devlock);

276
drivers/sensors/mcp9600_uorb.c
View file

@ -366,6 +366,7 @@ static int mcp9600_config_alert(FAR struct mcp9600_dev_s *priv,
/* Configure limit */
int16_t limit = config->limit << 2; /* 2 LSBs must be 0 for this reg */
err = mcp9600_write_reg(priv, g_alert_limits[config->alert], &limit,
sizeof(limit));
if (err < 0)
@ -376,6 +377,7 @@ static int mcp9600_config_alert(FAR struct mcp9600_dev_s *priv,
/* Configure the config register */
uint8_t config_reg = 0;
config_reg |= (config->enable);
config_reg |= (config->int_mode << 1);
config_reg |= (config->active_high << 2);
@ -398,6 +400,7 @@ static int mcp9600_config_alert(FAR struct mcp9600_dev_s *priv,
static int mcp9600_write_devconf(FAR struct mcp9600_dev_s *dev)
{
uint8_t reg = 0;
reg |= (dev->conf.mode & 0x3);
reg |= ((dev->conf.num_samples & 0x7) << 2);
reg |= ((dev->conf.resolution & 0x3) << 5);
@ -467,6 +470,7 @@ static int mcp9600_set_interval(FAR struct sensor_lowerhalf_s *lower,
{
FAR struct mcp9600_sens_s *sens =
container_of(lower, FAR struct mcp9600_sens_s, lower);
sens->dev->interval = *period_us;
return 0;
}
@ -586,156 +590,160 @@ static int mcp9600_control(FAR struct sensor_lowerhalf_s *lower,
switch (cmd)
{
/* Set thermocouple type */
/* Set thermocouple type */
case SNIOC_SET_THERMO:
{
dev->conf.thermo_type = g_thermo_types[arg];
err = mcp9600_write_devconf(dev);
}
break;
/* Device ID */
case SNIOC_WHO_AM_I:
{
struct mcp9600_devinfo_s *devinfo =
(struct mcp9600_devinfo_s *)(arg);
if (devinfo == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_DEVID, devinfo, sizeof(*devinfo));
}
break;
/* Raw ADC data */
case SNIOC_READ_RAW_DATA:
{
int32_t *raw_data = (int32_t *)(arg);
if (raw_data == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_RAW_ADC, raw_data,
3); /* Only read 24 bits */
/* Sign bit 1, set all upper bits to 1 for correct value in 32-bit
* signed integer.
*/
if (*raw_data & 0x100000)
{
*raw_data |= 0xfffc0000;
}
}
case SNIOC_CHECK_STATUS_REG:
{
uint8_t status_reg;
struct mcp9600_status_s *status = (struct mcp9600_status_s *)(arg);
if (status == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_STATUS, &status_reg,
sizeof(status_reg));
if (err < 0)
{
break;
}
/* Set bits */
status->burst_complete = status_reg & 0x80;
status->temp_update = status_reg & 0x40;
status->temp_exceeded = status_reg & 0x10;
status->alerts[0] = status_reg & 0x1;
status->alerts[1] = status_reg & 0x2;
status->alerts[2] = status_reg & 0x4;
status->alerts[3] = status_reg & 0x8;
/* Clear what has been read (burst & temp registers) */
status_reg &= 0x3f;
err = mcp9600_write_reg(dev, REG_STATUS, &status_reg,
sizeof(status_reg));
}
break;
/* Configure the MCP9600 */
case SNIOC_CONFIGURE:
{
uint8_t registers[2] =
case SNIOC_SET_THERMO:
{
0, 0
};
dev->conf.thermo_type = g_thermo_types[arg];
err = mcp9600_write_devconf(dev);
}
break;
struct mcp9600_devconf_s *conf = (struct mcp9600_devconf_s *)(arg);
/* Device ID */
/* Validate options */
case SNIOC_WHO_AM_I:
{
struct mcp9600_devinfo_s *devinfo =
(struct mcp9600_devinfo_s *)(arg);
err = mcp9600_validate_conf(conf);
if (err < 0)
if (devinfo == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_DEVID, devinfo, sizeof(*devinfo));
}
break;
/* Raw ADC data */
case SNIOC_READ_RAW_DATA:
{
int32_t *raw_data = (int32_t *)(arg);
if (raw_data == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_RAW_ADC, raw_data,
3); /* Only read 24 bits */
/* Sign bit 1, set all upper bits to 1 for correct value in 32-bit
* signed integer.
*/
if (*raw_data & 0x100000)
{
*raw_data |= 0xfffc0000;
}
}
case SNIOC_CHECK_STATUS_REG:
{
uint8_t status_reg;
struct mcp9600_status_s *status = (struct mcp9600_status_s *)(arg);
if (status == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_read_reg(dev, REG_STATUS, &status_reg,
sizeof(status_reg));
if (err < 0)
{
break;
}
/* Set bits */
status->burst_complete = status_reg & 0x80;
status->temp_update = status_reg & 0x40;
status->temp_exceeded = status_reg & 0x10;
status->alerts[0] = status_reg & 0x1;
status->alerts[1] = status_reg & 0x2;
status->alerts[2] = status_reg & 0x4;
status->alerts[3] = status_reg & 0x8;
/* Clear what has been read (burst & temp registers) */
status_reg &= 0x3f;
err = mcp9600_write_reg(dev, REG_STATUS, &status_reg,
sizeof(status_reg));
}
break;
/* Configure the MCP9600 */
case SNIOC_CONFIGURE:
{
uint8_t registers[2] =
{
break;
0, 0
};
/* Sensor configuration */
struct mcp9600_devconf_s *conf = (struct mcp9600_devconf_s *)(arg);
registers[0] |= ((conf->thermo_type & 0x7) << 4);
registers[0] |= (conf->filter_coeff & 0x7);
/* Validate options */
/* Device configuration */
err = mcp9600_validate_conf(conf);
if (err < 0)
{
break;
};
registers[1] |= (conf->mode & 0x3);
registers[1] |= ((conf->num_samples & 0x7) << 2);
registers[1] |= ((conf->resolution & 0x3) << 5);
registers[1] |= ((conf->cold_res & 0x1) << 7);
/* Sensor configuration */
/* Copy in options. Since the sensor configuration and device
* configuration registers are sequential, we can do this in one
* write operation.
*/
registers[0] |= ((conf->thermo_type & 0x7) << 4);
registers[0] |= (conf->filter_coeff & 0x7);
err = mcp9600_write_reg(dev, REG_THERMO_SEN_CONF, registers,
sizeof(registers));
if (err < 0)
{
break;
};
/* Device configuration */
/* Store this as the official configuration */
registers[1] |= (conf->mode & 0x3);
registers[1] |= ((conf->num_samples & 0x7) << 2);
registers[1] |= ((conf->resolution & 0x3) << 5);
registers[1] |= ((conf->cold_res & 0x1) << 7);
memcpy(&dev->conf, conf, sizeof(dev->conf));
}
/* Copy in options. Since the sensor configuration and device
* configuration registers are sequential, we can do this in one
* write operation.
*/
/* Configure alerts */
err = mcp9600_write_reg(dev, REG_THERMO_SEN_CONF, registers,
sizeof(registers));
if (err < 0)
{
break;
};
case SNIOC_WRITECONF:
{
struct mcp9600_alert_conf_s *conf =
(struct mcp9600_alert_conf_s *)(arg);
if (conf == NULL)
{
err = -EINVAL;
break;
}
/* Store this as the official configuration */
err = mcp9600_config_alert(dev, conf);
}
memcpy(&dev->conf, conf, sizeof(dev->conf));
}
default:
err = -EINVAL;
break;
/* Configure alerts */
case SNIOC_WRITECONF:
{
struct mcp9600_alert_conf_s *conf =
(struct mcp9600_alert_conf_s *)(arg);
if (conf == NULL)
{
err = -EINVAL;
break;
}
err = mcp9600_config_alert(dev, conf);
}
default:
err = -EINVAL;
break;
}
nxmutex_unlock(&dev->devlock);
@ -933,11 +941,11 @@ int mcp9600_register(FAR struct i2c_master_s *i2c, uint8_t addr,
{
snerr("Failed to create the MCP9600 notification kthread.\n");
sensor_unregister(&priv->delta.lower, d_devno);
unreg_hot:
unreg_hot:
sensor_unregister(&priv->hot_junc.lower, h_devno);
unreg_cold:
unreg_cold:
sensor_unregister(&priv->cold_junc.lower, c_devno);
del_mutex:
del_mutex:
nxmutex_destroy(&priv->devlock);
nxsem_destroy(&priv->run);
kmm_free(priv);

49
drivers/sensors/nau7802.c
View file

@ -95,7 +95,7 @@ static const uint32_t ODR_TO_INTERVAL[] =
[NAU7802_ODR_40HZ] = 25000,
[NAU7802_ODR_80HZ] = 12500,
[NAU7802_ODR_320HZ] = 3125
};
};
typedef struct
{
@ -238,6 +238,7 @@ static int nau7802_read_bit(FAR nau7802_dev_s *dev, uint8_t addr,
static int nau7802_reset(FAR nau7802_dev_s *dev)
{
int err = 0;
err = nau7802_set_bits(dev, REG_PU_CTRL, 1, BIT_RR, 1);
if (err < 0)
{
@ -261,6 +262,7 @@ static int nau7802_reset(FAR nau7802_dev_s *dev)
usleep(200);
uint8_t reg_val;
err = nau7802_read_reg(dev, REG_PU_CTRL, &reg_val, sizeof(reg_val));
if (err < 0)
{
@ -291,6 +293,7 @@ static int nau7802_reset(FAR nau7802_dev_s *dev)
static int nau7802_enable(FAR nau7802_dev_s *dev, bool enable)
{
int err = 0;
if (!enable)
{
err = nau7802_set_bits(dev, REG_PU_CTRL, 1, BIT_PUA, 0);
@ -329,6 +332,7 @@ static int nau7802_enable(FAR nau7802_dev_s *dev, bool enable)
}
bool reg_val;
err = nau7802_read_bit(dev, REG_PU_CTRL, BIT_PUR, &reg_val);
if (err < 0 || !reg_val)
{
@ -419,6 +423,7 @@ static int nau7802_set_ldo(FAR nau7802_dev_s *dev, nau7802_ldo_e voltage)
}
int err = 0;
err = nau7802_set_bits(dev, REG_PU_CTRL, 1, BIT_AVVDS, 1);
if (err < 0)
{
@ -503,6 +508,7 @@ static int nau7802_push_data(FAR nau7802_dev_s *dev)
}
bool data_ready;
err = nau7802_data_available(dev, &data_ready);
if (err < 0 || !data_ready)
{
@ -588,6 +594,7 @@ static int nau7802_set_calibvalue(FAR struct sensor_lowerhalf_s *lower,
uint8_t reg_b0 = calibvalue & 0xff;
int err = 0;
err = nau7802_write_reg(dev, REG_GCAL1_B3, &reg_b3, sizeof(reg_b3));
if (err < 0)
{
@ -651,6 +658,7 @@ static int nau7802_calibrate(FAR struct sensor_lowerhalf_s *lower,
/* Wait for calibration to complete */
bool reg_val;
do
{
err = nau7802_read_bit(dev, REG_CTRL_2, CAL_START, &reg_val);
@ -699,26 +707,26 @@ static int nau7802_control(FAR struct sensor_lowerhalf_s *lower,
switch (cmd)
{
case SNIOC_RESET:
err = nau7802_reset(dev);
break;
case SNIOC_RESET:
err = nau7802_reset(dev);
break;
case SNIOC_SET_GAIN:
err = nau7802_set_gain(dev, arg);
break;
case SNIOC_SET_GAIN:
err = nau7802_set_gain(dev, arg);
break;
case SNIOC_SET_LDO:
err = nau7802_set_ldo(dev, arg);
break;
case SNIOC_SET_LDO:
err = nau7802_set_ldo(dev, arg);
break;
case SNIOC_GET_CALIBVALUE:
err = nau7802_get_calibvalue(dev, arg);
break;
case SNIOC_GET_CALIBVALUE:
err = nau7802_get_calibvalue(dev, arg);
break;
default:
err = -EINVAL;
snerr("Unknown command for NAU7802: %d\n", cmd);
break;
default:
err = -EINVAL;
snerr("Unknown command for NAU7802: %d\n", cmd);
break;
}
nxmutex_unlock(&dev->devlock);
@ -755,6 +763,7 @@ static int nau7802_activate(FAR struct sensor_lowerhalf_s *lower,
}
uint8_t reg_val;
err = nau7802_read_reg(dev, 0x1f, &reg_val, sizeof(reg_val));
if (err < 0 || (reg_val & 0xf) != 0xf)
{
@ -916,6 +925,7 @@ int nau7802_register(FAR struct i2c_master_s *i2c, int devno, uint8_t addr)
{
int err;
FAR nau7802_dev_s *priv = kmm_zalloc(sizeof(nau7802_dev_s));
DEBUGASSERT(i2c != NULL);
DEBUGASSERT(addr == 0x2a);
@ -946,6 +956,7 @@ int nau7802_register(FAR struct i2c_master_s *i2c, int devno, uint8_t addr)
FAR char *argv[2];
char arg1[32];
snprintf(arg1, 16, "%p", priv);
argv[0] = arg1;
argv[1] = NULL;
@ -963,9 +974,9 @@ int nau7802_register(FAR struct i2c_master_s *i2c, int devno, uint8_t addr)
if (err < 0)
{
sensor_unreg:
sensor_unreg:
sensor_unregister(&priv->lower, devno);
del_sem:
del_sem:
nxsem_destroy(&priv->run);
nxmutex_destroy(&priv->devlock);
kmm_free(priv);

97
drivers/sensors/sht4x_uorb.c
View file

@ -157,7 +157,7 @@ static const uint8_t g_crc_lookup[] =
0x56, 0x78, 0x49, 0x1a, 0x2b, 0xbc, 0x8d, 0xde, 0xef, 0x82, 0xb3,
0xe0, 0xd1, 0x46, 0x77, 0x24, 0x15, 0x3b, 0xa, 0x59, 0x68, 0xff,
0xce, 0x9d, 0xac,
}
}
#endif
/* Measurement times for the various precisions, in microseconds. */
@ -244,6 +244,7 @@ static const struct sensor_ops_s g_sensor_ops =
uint8_t sht4x_crc_lookup(const uint8_t *buf, uint8_t nbytes)
{
uint8_t crc = SHT4X_CRC_INIT;
for (uint8_t byte = 0; byte < nbytes; byte++)
{
crc = g_crc_lookup[crc ^ buf[byte]];
@ -265,6 +266,7 @@ uint8_t sht4x_crc_lookup(const uint8_t *buf, uint8_t nbytes)
uint8_t sht4x_crc_bitwise(const uint8_t *buf, uint8_t nbytes)
{
uint8_t crc = SHT4X_CRC_INIT;
for (uint8_t byte = 0; byte < nbytes; byte++)
{
crc ^= buf[byte];
@ -581,6 +583,7 @@ static int sht4x_set_interval(FAR struct sensor_lowerhalf_s *lower,
FAR struct sht4x_sensor_s *priv =
container_of(lower, FAR struct sht4x_sensor_s, sensor_lower);
FAR struct sht4x_dev_s *dev = priv->dev;
dev->interval = *period_us;
return 0;
}
@ -637,63 +640,67 @@ static int sht4x_control(FAR struct sensor_lowerhalf_s *lower,
switch (cmd)
{
case SNIOC_RESET:
err = sht4x_reset(dev);
break;
case SNIOC_RESET:
err = sht4x_reset(dev);
break;
case SNIOC_WHO_AM_I:
{
union sht4x_serialno_t serialno;
err = sht4x_cmd(dev, SHT4X_READ_SERIAL, 10, &serialno.halves.msb,
&serialno.halves.lsb);
*((FAR uint32_t *)(arg)) = serialno.full;
}
break;
case SNIOC_WHO_AM_I:
{
union sht4x_serialno_t serialno;
case SNIOC_HEAT:
{
struct timespec now;
clock_systime_timespec(&now);
err = sht4x_cmd(dev, SHT4X_READ_SERIAL, 10, &serialno.halves.msb,
&serialno.halves.lsb);
*((FAR uint32_t *)(arg)) = serialno.full;
}
break;
/* Check if it has been one second since the last heat command. */
case SNIOC_HEAT:
{
struct timespec now;
if (!has_time_passed(now, dev->last_heat, 1))
{
err = -EAGAIN; /* Signal to try again in some time. */
break;
}
clock_systime_timespec(&now);
/* Check for invalid heater command */
/* Check if it has been one second since the last heat command. */
if (0 < arg || arg >= (sizeof(g_heat_cmds) / sizeof(g_heat_cmds[0])))
{
return -EINVAL;
}
if (!has_time_passed(now, dev->last_heat, 1))
{
err = -EAGAIN; /* Signal to try again in some time. */
break;
}
/* Heat for the desired period */
/* Check for invalid heater command */
uint16_t trash;
err = sht4x_cmd(dev, g_heat_cmds[arg], g_heat_times[arg], &trash,
&trash);
if (err)
{
break;
}
if (0 < arg ||
arg >= (sizeof(g_heat_cmds) / sizeof(g_heat_cmds[0])))
{
return -EINVAL;
}
clock_systime_timespec(&dev->last_heat); /* Update last heat time. */
}
break;
/* Heat for the desired period */
case SNIOC_CONFIGURE:
uint16_t trash;
/* Caller must pass precision option as argument. */
err = sht4x_cmd(dev, g_heat_cmds[arg], g_heat_times[arg], &trash,
&trash);
if (err)
{
break;
}
dev->precision = arg;
break;
clock_systime_timespec(&dev->last_heat); /* Update last heat time. */
}
break;
default:
err = -EINVAL;
break;
case SNIOC_CONFIGURE:
/* Caller must pass precision option as argument. */
dev->precision = arg;
break;
default:
err = -EINVAL;
break;
}
nxmutex_unlock(&dev->devlock);

236
drivers/usbdev/cdcecm.c
View file

@ -1071,45 +1071,45 @@ static int cdcecm_mkstrdesc(uint8_t id, FAR struct usb_strdesc_s *strdesc)
switch (id)
{
#ifndef CONFIG_CDCECM_COMPOSITE
case 0:
{
/* Descriptor 0 is the language id */
case 0:
{
/* Descriptor 0 is the language id */
strdesc->len = 4;
strdesc->type = USB_DESC_TYPE_STRING;
data[0] = LSBYTE(CDCECM_STR_LANGUAGE);
data[1] = MSBYTE(CDCECM_STR_LANGUAGE);
return 4;
}
strdesc->len = 4;
strdesc->type = USB_DESC_TYPE_STRING;
data[0] = LSBYTE(CDCECM_STR_LANGUAGE);
data[1] = MSBYTE(CDCECM_STR_LANGUAGE);
return 4;
}
case CDCECM_MANUFACTURERSTRID:
str = CONFIG_CDCECM_VENDORSTR;
break;
case CDCECM_MANUFACTURERSTRID:
str = CONFIG_CDCECM_VENDORSTR;
break;
case CDCECM_PRODUCTSTRID:
str = CONFIG_CDCECM_PRODUCTSTR;
break;
case CDCECM_PRODUCTSTRID:
str = CONFIG_CDCECM_PRODUCTSTR;
break;
case CDCECM_SERIALSTRID:
case CDCECM_SERIALSTRID:
#ifdef CONFIG_BOARD_USBDEV_SERIALSTR
str = board_usbdev_serialstr();
str = board_usbdev_serialstr();
#else
str = "0";
str = "0";
#endif
break;
break;
case CDCECM_CONFIGSTRID:
str = "Default";
break;
case CDCECM_CONFIGSTRID:
str = "Default";
break;
#endif
case CDCECM_MACSTRID:
str = "020000112233";
break;
case CDCECM_MACSTRID:
str = "020000112233";
break;
default:
uwarn("Unknown string descriptor index: %d\n", id);
return -EINVAL;
default:
uwarn("Unknown string descriptor index: %d\n", id);
return -EINVAL;
}
/* The string is utf16-le. The poor man's utf-8 to utf16-le
@ -1145,88 +1145,88 @@ static int cdcecm_mkstrdesc(uint8_t id, FAR struct usb_strdesc_s *strdesc)
static void cdcecm_mkepcompdesc(int epidx,
FAR struct usb_ss_epcompdesc_s *epcompdesc)
{
switch (epidx)
switch (epidx)
{
case CDCECM_EP_INTIN_IDX: /* Interrupt IN endpoint */
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCECM_EP_INTIN_IDX: /* Interrupt IN endpoint */
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCECM_EPINTIN_MAXBURST >= USB_SS_INT_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_INT_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPINTIN_MAXBURST;
}
if (CONFIG_CDCECM_EPINTIN_MAXBURST >= USB_SS_INT_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_INT_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPINTIN_MAXBURST;
}
epcompdesc->attr = 0;
epcompdesc->wbytes[0] = LSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCECM_EPINTIN_SSSIZE);
epcompdesc->wbytes[1] = MSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCECM_EPINTIN_SSSIZE);
}
break;
epcompdesc->attr = 0;
epcompdesc->wbytes[0] = LSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCECM_EPINTIN_SSSIZE);
epcompdesc->wbytes[1] = MSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCECM_EPINTIN_SSSIZE);
}
break;
case CDCECM_EP_BULKOUT_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCECM_EP_BULKOUT_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCECM_EPBULKOUT_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPBULKOUT_MAXBURST;
}
if (CONFIG_CDCECM_EPBULKOUT_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPBULKOUT_MAXBURST;
}
if (CONFIG_CDCECM_EPBULKOUT_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCECM_EPBULKOUT_MAXSTREAM;
}
if (CONFIG_CDCECM_EPBULKOUT_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCECM_EPBULKOUT_MAXSTREAM;
}
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
case CDCECM_EP_BULKIN_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCECM_EP_BULKIN_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCECM_EPBULKIN_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPBULKIN_MAXBURST;
}
if (CONFIG_CDCECM_EPBULKIN_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCECM_EPBULKIN_MAXBURST;
}
if (CONFIG_CDCECM_EPBULKIN_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCECM_EPBULKIN_MAXSTREAM;
}
if (CONFIG_CDCECM_EPBULKIN_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCECM_EPBULKIN_MAXSTREAM;
}
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
default:
break;
default:
break;
}
}
#endif
@ -1589,32 +1589,32 @@ static int cdcecm_getdescriptor(FAR struct cdcecm_driver_s *self,
switch (type)
{
#ifndef CONFIG_CDCECM_COMPOSITE
case USB_DESC_TYPE_DEVICE:
{
return usbdev_copy_devdesc(desc, &g_devdesc, self->usbdev.speed);
}
break;
case USB_DESC_TYPE_DEVICE:
{
return usbdev_copy_devdesc(desc, &g_devdesc, self->usbdev.speed);
}
break;
#endif
#ifdef CONFIG_USBDEV_DUALSPEED
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
#endif /* CONFIG_USBDEV_DUALSPEED */
case USB_DESC_TYPE_CONFIG:
{
return cdcecm_mkcfgdesc((FAR uint8_t *)desc, &self->devinfo,
self->usbdev.speed, type);
}
break;
case USB_DESC_TYPE_CONFIG:
{
return cdcecm_mkcfgdesc((FAR uint8_t *)desc, &self->devinfo,
self->usbdev.speed, type);
}
break;
case USB_DESC_TYPE_STRING:
{
return cdcecm_mkstrdesc(index, (FAR struct usb_strdesc_s *)desc);
}
break;
case USB_DESC_TYPE_STRING:
{
return cdcecm_mkstrdesc(index, (FAR struct usb_strdesc_s *)desc);
}
break;
default:
uwarn("Unsupported descriptor type: 0x%02hhx\n", type);
break;
default:
uwarn("Unsupported descriptor type: 0x%02hhx\n", type);
break;
}
return -ENOTSUP;

247
drivers/usbdev/cdcncm.c
View file

@ -806,6 +806,7 @@ static int cdcmbim_poll(FAR struct file *filep, FAR struct pollfd *fds,
/* This is a request to tear down the poll. */
FAR struct pollfd **slot = (FAR struct pollfd **)fds->priv;
DEBUGASSERT(slot);
/* Remove all memory of the poll setup */
@ -1847,45 +1848,45 @@ static int cdcnm_mkstrdesc(uint8_t id, FAR struct usb_strdesc_s *strdesc,
switch (id)
{
#ifndef CONFIG_CDCNCM_COMPOSITE
case 0:
{
/* Descriptor 0 is the language id */
case 0:
{
/* Descriptor 0 is the language id */
strdesc->len = 4;
strdesc->type = USB_DESC_TYPE_STRING;
data[0] = LSBYTE(CDCECM_STR_LANGUAGE);
data[1] = MSBYTE(CDCECM_STR_LANGUAGE);
return 4;
}
strdesc->len = 4;
strdesc->type = USB_DESC_TYPE_STRING;
data[0] = LSBYTE(CDCECM_STR_LANGUAGE);
data[1] = MSBYTE(CDCECM_STR_LANGUAGE);
return 4;
}
case CDCECM_MANUFACTURERSTRID:
str = CONFIG_CDCNCM_VENDORSTR;
break;
case CDCECM_MANUFACTURERSTRID:
str = CONFIG_CDCNCM_VENDORSTR;
break;
case CDCECM_PRODUCTSTRID:
str = isncm ? CONFIG_CDCNCM_PRODUCTSTR : CONFIG_CDCMBIM_PRODUCTSTR;
break;
case CDCECM_PRODUCTSTRID:
str = isncm ? CONFIG_CDCNCM_PRODUCTSTR : CONFIG_CDCMBIM_PRODUCTSTR;
break;
case CDCECM_SERIALSTRID:
case CDCECM_SERIALSTRID:
#ifdef CONFIG_BOARD_USBDEV_SERIALSTR
str = board_usbdev_serialstr();
str = board_usbdev_serialstr();
#else
str = "0";
str = "0";
#endif
break;
break;
case CDCECM_CONFIGSTRID:
str = "Default";
break;
case CDCECM_CONFIGSTRID:
str = "Default";
break;
#endif
case CDCECM_MACSTRID:
str = "020000112233";
break;
case CDCECM_MACSTRID:
str = "020000112233";
break;
default:
uerr("Unknown string descriptor index: %d\n", id);
return -EINVAL;
default:
uerr("Unknown string descriptor index: %d\n", id);
return -EINVAL;
}
/* The string is utf16-le. The poor man's utf-8 to utf16-le
@ -1949,88 +1950,88 @@ static int cdcmbim_mkstrdesc(uint8_t id, FAR struct usb_strdesc_s *strdesc)
static void cdcncm_mkepcompdesc(int epidx,
FAR struct usb_ss_epcompdesc_s *epcompdesc)
{
switch (epidx)
switch (epidx)
{
case CDCNCM_EP_INTIN_IDX: /* Interrupt IN endpoint */
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCNCM_EP_INTIN_IDX: /* Interrupt IN endpoint */
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCNCM_EPINTIN_MAXBURST >= USB_SS_INT_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_INT_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPINTIN_MAXBURST;
}
if (CONFIG_CDCNCM_EPINTIN_MAXBURST >= USB_SS_INT_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_INT_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPINTIN_MAXBURST;
}
epcompdesc->attr = 0;
epcompdesc->wbytes[0] = LSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCNCM_EPINTIN_SSSIZE);
epcompdesc->wbytes[1] = MSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCNCM_EPINTIN_SSSIZE);
}
break;
epcompdesc->attr = 0;
epcompdesc->wbytes[0] = LSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCNCM_EPINTIN_SSSIZE);
epcompdesc->wbytes[1] = MSBYTE((epcompdesc->mxburst + 1) *
CONFIG_CDCNCM_EPINTIN_SSSIZE);
}
break;
case CDCNCM_EP_BULKOUT_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCNCM_EP_BULKOUT_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCNCM_EPBULKOUT_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPBULKOUT_MAXBURST;
}
if (CONFIG_CDCNCM_EPBULKOUT_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPBULKOUT_MAXBURST;
}
if (CONFIG_CDCNCM_EPBULKOUT_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCNCM_EPBULKOUT_MAXSTREAM;
}
if (CONFIG_CDCNCM_EPBULKOUT_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCNCM_EPBULKOUT_MAXSTREAM;
}
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
case CDCNCM_EP_BULKIN_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
case CDCNCM_EP_BULKIN_IDX:
{
epcompdesc->len = USB_SIZEOF_SS_EPCOMPDESC; /* Descriptor length */
epcompdesc->type = USB_DESC_TYPE_ENDPOINT_COMPANION; /* Descriptor type */
if (CONFIG_CDCNCM_EPBULKIN_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPBULKIN_MAXBURST;
}
if (CONFIG_CDCNCM_EPBULKIN_MAXBURST >= USB_SS_BULK_EP_MAXBURST)
{
epcompdesc->mxburst = USB_SS_BULK_EP_MAXBURST - 1;
}
else
{
epcompdesc->mxburst = CONFIG_CDCNCM_EPBULKIN_MAXBURST;
}
if (CONFIG_CDCNCM_EPBULKIN_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCNCM_EPBULKIN_MAXSTREAM;
}
if (CONFIG_CDCNCM_EPBULKIN_MAXSTREAM > USB_SS_BULK_EP_MAXSTREAM)
{
epcompdesc->attr = USB_SS_BULK_EP_MAXSTREAM;
}
else
{
epcompdesc->attr = CONFIG_CDCNCM_EPBULKIN_MAXSTREAM;
}
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
epcompdesc->wbytes[0] = 0;
epcompdesc->wbytes[1] = 0;
}
break;
default:
break;
default:
break;
}
}
#endif
@ -2462,36 +2463,36 @@ static int cdcncm_getdescriptor(FAR struct cdcncm_driver_s *self,
switch (type)
{
#ifndef CONFIG_CDCNCM_COMPOSITE
case USB_DESC_TYPE_DEVICE:
if (self->isncm)
{
return usbdev_copy_devdesc(desc,
&g_ncmdevdesc,
self->usbdev.speed);
}
case USB_DESC_TYPE_DEVICE:
if (self->isncm)
{
return usbdev_copy_devdesc(desc,
&g_ncmdevdesc,
self->usbdev.speed);
}
# ifdef CONFIG_NET_CDCMBIM
else
{
memcpy(desc, &g_mbimdevdesc, sizeof(g_mbimdevdesc));
return sizeof(g_mbimdevdesc);
}
else
{
memcpy(desc, &g_mbimdevdesc, sizeof(g_mbimdevdesc));
return sizeof(g_mbimdevdesc);
}
# endif
break;
break;
#endif
#ifdef CONFIG_USBDEV_DUALSPEED
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
#endif /* CONFIG_USBDEV_DUALSPEED */
case USB_DESC_TYPE_CONFIG:
return cdcncm_mkcfgdesc((FAR uint8_t *)desc, &self->devinfo,
self->usbdev.speed, type);
case USB_DESC_TYPE_CONFIG:
return cdcncm_mkcfgdesc((FAR uint8_t *)desc, &self->devinfo,
self->usbdev.speed, type);
case USB_DESC_TYPE_STRING:
return cdcncm_mkstrdesc(index, (FAR struct usb_strdesc_s *)desc);
case USB_DESC_TYPE_STRING:
return cdcncm_mkstrdesc(index, (FAR struct usb_strdesc_s *)desc);
default:
uerr("Unsupported descriptor type: 0x%02hhx\n", type);
break;
default:
uerr("Unsupported descriptor type: 0x%02hhx\n", type);
break;
}
return -ENOTSUP;
@ -2767,7 +2768,10 @@ static int cdcncm_setup(FAR struct usbdevclass_driver_s *driver,
case NCM_SET_NTB_FORMAT:
if (len != 0 || index != self->devinfo.ifnobase)
break;
{
break;
}
switch (value)
{
case 0x0000:
@ -2841,6 +2845,7 @@ static int cdcncm_setup(FAR struct usbdevclass_driver_s *driver,
FAR struct cdcmbim_driver_s *mbim =
(FAR struct cdcmbim_driver_s *)self;
FAR struct iob_s *iob;
ret = -ENOSPC;
if ((iob = iob_remove_queue(&mbim->tx_queue)) != NULL)

295
drivers/wireless/lpwan/rn2xx3/rn2xx3.c
View file

@ -822,6 +822,7 @@ static int rn2xx3_setbw(FAR struct rn2xx3_dev_s *priv, uint32_t bw)
{
char bwstr[16];
ssize_t length;
length =
file_write(&priv->uart, "radio set bw ", sizeof("radio set bw ") - 1);
if (length < 0)
@ -1666,167 +1667,179 @@ static int rn2xx3_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
switch (cmd)
{
case WLIOC_RESET:
{
err = rn2xx3_reset(priv);
break;
}
case WLIOC_RESET:
{
err = rn2xx3_reset(priv);
break;
}
case WLIOC_IQIEN:
{
err = rn2xx3_iqi_en(priv, arg);
break;
}
case WLIOC_IQIEN:
{
err = rn2xx3_iqi_en(priv, arg);
break;
}
case WLIOC_CRCEN:
{
err = rn2xx3_crc_en(priv, arg);
break;
}
case WLIOC_CRCEN:
{
err = rn2xx3_crc_en(priv, arg);
break;
}
case WLIOC_GETSNR:
{
FAR int8_t *snr = (FAR int8_t *)(arg);
DEBUGASSERT(snr != NULL);
err = rn2xx3_getsnr(priv, snr);
break;
}
case WLIOC_GETSNR:
{
FAR int8_t *snr = (FAR int8_t *)(arg);
case WLIOC_SETRADIOFREQ:
{
err = rn2xx3_setfreq(priv, arg);
break;
}
DEBUGASSERT(snr != NULL);
err = rn2xx3_getsnr(priv, snr);
break;
}
case WLIOC_GETRADIOFREQ:
{
FAR uint32_t *freq = (FAR uint32_t *)(arg);
DEBUGASSERT(freq != NULL);
err = rn2xx3_getfreq(priv, freq);
break;
}
case WLIOC_SETRADIOFREQ:
{
err = rn2xx3_setfreq(priv, arg);
break;
}
case WLIOC_SETTXPOWERF:
{
FAR int32_t *txpwr = (FAR int32_t *)(arg);
DEBUGASSERT(txpwr != NULL);
err = rn2xx3_settxpwr(priv, txpwr);
break;
}
case WLIOC_GETRADIOFREQ:
{
FAR uint32_t *freq = (FAR uint32_t *)(arg);
case WLIOC_GETTXPOWERF:
{
FAR int32_t *txpwr = (FAR int32_t *)(arg);
DEBUGASSERT(txpwr != NULL);
err = rn2xx3_gettxpwr(priv, txpwr);
break;
}
DEBUGASSERT(freq != NULL);
err = rn2xx3_getfreq(priv, freq);
break;
}
case WLIOC_SETBANDWIDTH:
{
err = rn2xx3_setbw(priv, arg);
break;
}
case WLIOC_SETTXPOWERF:
{
FAR int32_t *txpwr = (FAR int32_t *)(arg);
case WLIOC_GETBANDWIDTH:
{
FAR uint32_t *bw = (FAR uint32_t *)(arg);
DEBUGASSERT(bw != NULL);
err = rn2xx3_getbw(priv, bw);
break;
}
DEBUGASSERT(txpwr != NULL);
err = rn2xx3_settxpwr(priv, txpwr);
break;
}
case WLIOC_SETSPREAD:
{
err = rn2xx3_setsf(priv, arg);
break;
}
case WLIOC_GETTXPOWERF:
{
FAR int32_t *txpwr = (FAR int32_t *)(arg);
case WLIOC_GETSPREAD:
{
FAR uint8_t *sf = (FAR uint8_t *)(arg);
DEBUGASSERT(sf != NULL);
err = rn2xx3_getsf(priv, sf);
break;
}
DEBUGASSERT(txpwr != NULL);
err = rn2xx3_gettxpwr(priv, txpwr);
break;
}
case WLIOC_SETPRLEN:
{
err = rn2xx3_setprlen(priv, arg);
break;
}
case WLIOC_SETBANDWIDTH:
{
err = rn2xx3_setbw(priv, arg);
break;
}
case WLIOC_GETPRLEN:
{
FAR uint16_t *prlen = (FAR uint16_t *)(arg);
DEBUGASSERT(prlen != NULL);
err = rn2xx3_getprlen(priv, prlen);
break;
}
case WLIOC_GETBANDWIDTH:
{
FAR uint32_t *bw = (FAR uint32_t *)(arg);
case WLIOC_SETMOD:
{
err = rn2xx3_setmod(priv, arg);
break;
}
DEBUGASSERT(bw != NULL);
err = rn2xx3_getbw(priv, bw);
break;
}
case WLIOC_GETMOD:
{
FAR enum rn2xx3_mod_e *mod = (FAR enum rn2xx3_mod_e *)(arg);
DEBUGASSERT(mod != NULL);
err = rn2xx3_getmod(priv, mod);
break;
}
case WLIOC_SETSPREAD:
{
err = rn2xx3_setsf(priv, arg);
break;
}
case WLIOC_SETSYNC:
{
FAR uint64_t *syncword = (FAR uint64_t *)(arg);
DEBUGASSERT(syncword != NULL);
err = rn2xx3_setsync(priv, *syncword);
break;
}
case WLIOC_GETSPREAD:
{
FAR uint8_t *sf = (FAR uint8_t *)(arg);
case WLIOC_GETSYNC:
{
FAR uint64_t *sync = (FAR uint64_t *)(arg);
DEBUGASSERT(sync != NULL);
err = rn2xx3_getsync(priv, sync);
break;
}
DEBUGASSERT(sf != NULL);
err = rn2xx3_getsf(priv, sf);
break;
}
case WLIOC_SETBITRATE:
{
err = rn2xx3_setbitrate(priv, arg);
break;
}
case WLIOC_SETPRLEN:
{
err = rn2xx3_setprlen(priv, arg);
break;
}
case WLIOC_GETBITRATE:
{
FAR uint32_t *bitrate = (FAR uint32_t *)(arg);
DEBUGASSERT(bitrate != NULL);
err = rn2xx3_getbitrate(priv, bitrate);
break;
}
case WLIOC_GETPRLEN:
{
FAR uint16_t *prlen = (FAR uint16_t *)(arg);
case WLIOC_SETCODERATE:
{
err = rn2xx3_setcr(priv, arg);
break;
}
DEBUGASSERT(prlen != NULL);
err = rn2xx3_getprlen(priv, prlen);
break;
}
case WLIOC_GETCODERATE:
{
FAR enum rn2xx3_cr_e *cr = (FAR enum rn2xx3_cr_e *)(arg);
DEBUGASSERT(cr != NULL);
err = rn2xx3_getcr(priv, cr);
break;
}
case WLIOC_SETMOD:
{
err = rn2xx3_setmod(priv, arg);
break;
}
default:
{
err = -EINVAL;
break;
}
case WLIOC_GETMOD:
{
FAR enum rn2xx3_mod_e *mod = (FAR enum rn2xx3_mod_e *)(arg);
DEBUGASSERT(mod != NULL);
err = rn2xx3_getmod(priv, mod);
break;
}
case WLIOC_SETSYNC:
{
FAR uint64_t *syncword = (FAR uint64_t *)(arg);
DEBUGASSERT(syncword != NULL);
err = rn2xx3_setsync(priv, *syncword);
break;
}
case WLIOC_GETSYNC:
{
FAR uint64_t *sync = (FAR uint64_t *)(arg);
DEBUGASSERT(sync != NULL);
err = rn2xx3_getsync(priv, sync);
break;
}
case WLIOC_SETBITRATE:
{
err = rn2xx3_setbitrate(priv, arg);
break;
}
case WLIOC_GETBITRATE:
{
FAR uint32_t *bitrate = (FAR uint32_t *)(arg);
DEBUGASSERT(bitrate != NULL);
err = rn2xx3_getbitrate(priv, bitrate);
break;
}
case WLIOC_SETCODERATE:
{
err = rn2xx3_setcr(priv, arg);
break;
}
case WLIOC_GETCODERATE:
{
FAR enum rn2xx3_cr_e *cr = (FAR enum rn2xx3_cr_e *)(arg);
DEBUGASSERT(cr != NULL);
err = rn2xx3_getcr(priv, cr);
break;
}
default:
{
err = -EINVAL;
break;
}
}
early_ret:
@ -1919,9 +1932,9 @@ int rn2xx3_register(FAR const char *devpath, FAR const char *uartpath)
if (err < 0)
{
close_file:
close_file:
file_close(&priv->uart);
destroy_mutex:
destroy_mutex:
nxmutex_destroy(&priv->devlock);
kmm_free(priv);
}

2
fs/zipfs/zip_vfs.c
View file

@ -386,7 +386,7 @@ static off_t zipfs_seek(FAR struct file *filep, off_t offset,
goto err_with_lock;
}
offset += file_info.uncompressed_size;
offset += file_info.uncompressed_size;
break;
default:
ret = -EINVAL;