/**************************************************************************** * drivers/modem/alt1250/altmdm.c * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. The * ASF licenses this file to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #if defined(CONFIG_MODEM_ALT1250) #include #include #include #include #include #include #include /* for ALTCOM_VERx */ #include "altmdm.h" #include "altmdm_event.h" #include "altmdm_spi.h" #include "altmdm_timer.h" #include "altcom_pkt.h" /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #define TX_DONE (1 << 0) #define TX_CANCEL (1 << 1) #define RESET_INTERVAL (50*1000) #define TXSUS_TIMEOUT (100) #define TIMEOUT_IDELEWTO_STATE (20) /* Sleep timer */ #define TIMEOUT_HDR_TRX_STATE (5000) #define TIMEOUT_BODY_TRX_STATE (5) #define TIMEOUT_NEXT_DELAY (300) /**************************************************************************** * Private Types ****************************************************************************/ typedef enum altmdm_state_e { ALTMDM_STATE_POWEROFF = 0, /* Modem Power Off state */ ALTMDM_STATE_SLEEP, /* Modem Sleep state */ ALTMDM_STATE_SLEEPWOTX, /* Modem Sleep with Tx suspend state */ ALTMDM_STATE_IDLE4RST, /* Idle for Reset transaction state */ ALTMDM_STATE_IDLEWTO, /* Idle with Sleep Time Out state */ ALTMDM_STATE_IDLEWOTO, /* Idle without Sleep Time Out state */ ALTMDM_STATE_IDLEWOTX, /* Idle with Tx suspend */ ALTMDM_STATE_V1SET, /* Altcom version 1 command setting state */ ALTMDM_STATE_V4SET, /* Altcom version 4 command setting state */ ALTMDM_STATE_SLEEPSET, /* Sleep packet setting state */ ALTMDM_STATE_TXPREPARE, /* Normal packet setting state */ ALTMDM_STATE_TXREQ, /* TX request signal assertion state */ ALTMDM_STATE_HDRSREQ, /* Waiting for Slave request signal state */ ALTMDM_STATE_HDRTRX, /* SPI Header transaction state */ ALTMDM_STATE_SLEEPPKT, /* Sleep Packet body size adjustment * state */ ALTMDM_STATE_BODYSREQ, /* Waiting for Slave request signal for body * state */ ALTMDM_STATE_BODYTRX, /* SPI body transaction state */ ALTMDM_STATE_GOTRX, /* Received normal body state */ ALTMDM_STATE_GOTRST, /* Received reset pakcet body state */ ALTMDM_STATE_GOTSLEEP, /* Received sleep packet body state */ ALTMDM_STATE_BACKTOIDLE, /* Back to Idle state */ ALTMDM_STATE_RETRECV, /* Return state */ ALTMDM_STATE_FORCERST, /* Modem force reset state */ ALTMDM_STATE_SLEEPING, /* Waiting for transition to sleep state */ ALTMDM_STATE_DECIDEDELAY, /* Determine if there is a need to delay for * next TRX */ ALTMDM_STATE_DELAYNEXT, /* Delayed state for the next TRX */ ALTMDM_STATE_SETSUSTIMER, /* Start TX suspend timer state */ ALTMDM_STATE_SETSUSTIMERSLEEP, /* Start TX suspend timer when sleep * state */ ALTMDM_STATE_DESTORY, /* State to be destroyed */ } altmdm_state_t; typedef enum version_phase_e { VP_NO_RESET, /* Reset packet is not received */ VP_V1 = ALTCOM_VER1, /* Confirmed Altcom version is 1 */ VP_V4 = ALTCOM_VER4, /* Confirmed Altcom version is 4 */ VP_UNKNOWN, /* Altcom version is unknown */ VP_TRYV1, /* Try sending version 1 packet */ VP_NOTV1, /* Trial of version 1 packet is fail */ VP_TRYV4, /* Try sending version 4 packet */ } version_phase_t; struct state_func_s { CODE int (*goto_next)(altmdm_state_t); CODE uint32_t (*wait_event)(void); CODE altmdm_state_t (*process_state)(uint32_t, altmdm_state_t); #ifdef CONFIG_MODEM_ALT1250_DEBUG FAR const char *name; #endif }; typedef struct altmdm_dev_s { sem_t lock_evt; struct altmdm_event_s event; sem_t lock_vp; version_phase_t vp; sem_t lock_counter; int wcounter; FAR struct spi_dev_s *spidev; FAR const struct alt1250_lower_s *lower; timer_t txsus_timer; altmdm_state_t current_state; altmdm_spipkt_t tx_pkt; altmdm_spipkt_t rx_pkt; int rx_retcode; struct altmdm_event_s txdone_event; sem_t lock_txreq; FAR void *txreq_buff; int txreq_size; int is_destroy; uint32_t reset_reason; int retry_mode; } altmdm_dev_t; /**************************************************************************** * Private Function Prototypes ****************************************************************************/ static int next_state_common(altmdm_state_t); static int next_state_poweroff(altmdm_state_t); static int next_state_sleep(altmdm_state_t); static int next_state_sleepwotx(altmdm_state_t); static int next_state_idle4rst(altmdm_state_t); static int next_state_idlewto(altmdm_state_t); static int next_state_idlewoto(altmdm_state_t); static int next_state_idlewotx(altmdm_state_t); static int next_state_hdrsreq(altmdm_state_t state); static int next_state_decidedelay(altmdm_state_t); static int next_state_destroy(altmdm_state_t); static uint32_t waitevt_state_common(void); static uint32_t waitevt_state_poweroff(void); static uint32_t waitevt_state_sleep(void); static uint32_t waitevt_state_sleepwotx(void); static uint32_t waitevt_state_idle4rst(void); static uint32_t waitevt_state_idlewto(void); static uint32_t waitevt_state_idlewoto(void); static uint32_t waitevt_state_idlewotx(void); static uint32_t waitevt_state_hdrsreq(void); static uint32_t waitevt_state_gotsleep(void); static uint32_t waitevt_state_bodysreq(void); static uint32_t waitevt_state_sleeping(void); static uint32_t waitevt_state_delaynext(void); static altmdm_state_t process_state_common(uint32_t, altmdm_state_t); static altmdm_state_t process_state_poweroff(uint32_t, altmdm_state_t); static altmdm_state_t process_state_sleep(uint32_t, altmdm_state_t); static altmdm_state_t process_state_sleepwotx(uint32_t, altmdm_state_t); static altmdm_state_t process_state_idle4rst(uint32_t, altmdm_state_t); static altmdm_state_t process_state_idlewto(uint32_t, altmdm_state_t); static altmdm_state_t process_state_idlewoto(uint32_t, altmdm_state_t); static altmdm_state_t process_state_idlewotx(uint32_t, altmdm_state_t); static altmdm_state_t process_state_v1set(uint32_t, altmdm_state_t); static altmdm_state_t process_state_v4set(uint32_t, altmdm_state_t); static altmdm_state_t process_state_sleepset(uint32_t, altmdm_state_t); static altmdm_state_t process_state_txprepare(uint32_t, altmdm_state_t); static altmdm_state_t process_state_txreq(uint32_t, altmdm_state_t); static altmdm_state_t process_state_hdrsreq(uint32_t, altmdm_state_t); static altmdm_state_t process_state_hdrtrx(uint32_t, altmdm_state_t); static altmdm_state_t process_state_sleeppkt(uint32_t, altmdm_state_t); static altmdm_state_t process_state_bodysreq(uint32_t, altmdm_state_t); static altmdm_state_t process_state_bodytrx(uint32_t, altmdm_state_t); static altmdm_state_t process_state_gotrx(uint32_t, altmdm_state_t); static altmdm_state_t process_state_gotrst(uint32_t, altmdm_state_t); static altmdm_state_t process_state_gotsleep(uint32_t, altmdm_state_t); static altmdm_state_t process_state_backtoidle(uint32_t, altmdm_state_t); static altmdm_state_t process_state_retrecv(uint32_t, altmdm_state_t); static altmdm_state_t process_state_forcerst(uint32_t, altmdm_state_t); static altmdm_state_t process_state_sleeping(uint32_t, altmdm_state_t); static altmdm_state_t process_state_decidedelay(uint32_t, altmdm_state_t); static altmdm_state_t process_state_delaynext(uint32_t, altmdm_state_t); static altmdm_state_t process_state_setsustimer(uint32_t, altmdm_state_t); static altmdm_state_t process_state_setsustimersleep(uint32_t, altmdm_state_t); /**************************************************************************** * Private Data ****************************************************************************/ #ifndef CONFIG_MODEM_ALT1250_DEBUG # define TABLE_CONTENT(array_name, namea, nameb, namec) \ [ALTMDM_STATE_##array_name] = \ { next_state_##namea, waitevt_state_##nameb, process_state_##namec } #else # define TABLE_CONTENT(array_name, namea, nameb, namec) \ [ALTMDM_STATE_##array_name] = \ { next_state_##namea, waitevt_state_##nameb, process_state_##namec, \ #array_name } static char *g_vp_name[] = { "NO_RESET", "V1 ", "", "", "V4 ", "UNKNOWN ", "TRYV1 ", "NOTV1 ", "TRYV4 " }; #endif /* State functions instance table */ static const struct state_func_s g_state_func[] = { TABLE_CONTENT(POWEROFF, poweroff, poweroff, poweroff), TABLE_CONTENT(SLEEP, sleep, sleep, sleep), TABLE_CONTENT(SLEEPWOTX, sleepwotx, sleepwotx, sleepwotx), TABLE_CONTENT(IDLE4RST, idle4rst, idle4rst, idle4rst), TABLE_CONTENT(IDLEWTO, idlewto, idlewto, idlewto), TABLE_CONTENT(IDLEWOTO, idlewoto, idlewoto, idlewoto), TABLE_CONTENT(IDLEWOTX, idlewotx, idlewotx, idlewotx), TABLE_CONTENT(V1SET, common, common, v1set), TABLE_CONTENT(V4SET, common, common, v4set), TABLE_CONTENT(SLEEPSET, common, common, sleepset), TABLE_CONTENT(TXPREPARE, common, common, txprepare), TABLE_CONTENT(TXREQ, common, common, txreq), TABLE_CONTENT(HDRSREQ, hdrsreq, hdrsreq, hdrsreq), TABLE_CONTENT(HDRTRX, common, common, hdrtrx), TABLE_CONTENT(SLEEPPKT, common, common, sleeppkt), TABLE_CONTENT(BODYSREQ, common, bodysreq, bodysreq), TABLE_CONTENT(BODYTRX, common, common, bodytrx), TABLE_CONTENT(GOTRX, common, common, gotrx), TABLE_CONTENT(GOTRST, common, common, gotrst), TABLE_CONTENT(GOTSLEEP, common, gotsleep, gotsleep), TABLE_CONTENT(BACKTOIDLE, common, common, backtoidle), TABLE_CONTENT(RETRECV, common, common, retrecv), TABLE_CONTENT(FORCERST, common, common, forcerst), TABLE_CONTENT(SLEEPING, common, sleeping, sleeping), TABLE_CONTENT(DECIDEDELAY, decidedelay, common, decidedelay), TABLE_CONTENT(DELAYNEXT, common, delaynext, delaynext), TABLE_CONTENT(SETSUSTIMER, common, common, setsustimer), TABLE_CONTENT(SETSUSTIMERSLEEP, common, common, setsustimersleep), TABLE_CONTENT(DESTORY, destroy, common, common), }; static struct altmdm_dev_s g_altmdm_dev; /**************************************************************************** * Private Functions ****************************************************************************/ #ifdef CONFIG_MODEM_ALT1250_DEBUG static void dump_current_all_status(FAR altmdm_dev_t *dev, uint32_t evt, altmdm_state_t next, int is_exit) { m_info("state[%s => %s], vp[%s], event out[%08lx]:cur[%08lx], " "wcount=%2d, txreq_buf=%s, txreq_sz=%4d, " "tx_hdr=%08lx, rx_hdr=%08lx, exit=%s\n", g_state_func[dev->current_state].name, g_state_func[next].name, g_vp_name[dev->vp], evt, dev->event.event, dev->wcounter, dev->txreq_buff == NULL ? "No-req " : "Request", dev->txreq_size, dev->tx_pkt.header, dev->rx_pkt.header, is_exit ? "Yes" : "No "); } #else # define dump_current_all_status(...) #endif static int sready_isr(int irq, FAR void *context, FAR void *arg) { altmdm_event_set(&g_altmdm_dev.event, EVENT_RXREQ); return 0; } static void txsustimer_handler(int signo, FAR siginfo_t *info, FAR void *uctx) { FAR struct altmdm_dev_s *priv = (FAR struct altmdm_dev_s *)(info->si_value.sival_ptr); altmdm_event_set(&priv->event, EVENT_TXSUSTO); } /**************************************************************************** * get wakelock count function ****************************************************************************/ static int get_wlock_count(void) { int cnt; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_counter); cnt = g_altmdm_dev.wcounter; nxsem_post(&g_altmdm_dev.lock_counter); return cnt; } /**************************************************************************** * Version Phase access functions ****************************************************************************/ static enum version_phase_e get_vp(void) { enum version_phase_e vp; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_vp); vp = g_altmdm_dev.vp; nxsem_post(&g_altmdm_dev.lock_vp); return vp; } static void set_vp(enum version_phase_e vp) { nxsem_wait_uninterruptible(&g_altmdm_dev.lock_vp); g_altmdm_dev.vp = vp; nxsem_post(&g_altmdm_dev.lock_vp); } static bool is_vp_valid(void) { enum version_phase_e vp; vp = get_vp(); return (vp == VP_V1 || vp == VP_V4); } static bool is_vp_noreset(void) { return (get_vp() == VP_NO_RESET); } /**************************************************************************** * return code setting function ****************************************************************************/ static void set_return_code(int code) { g_altmdm_dev.rx_retcode = code; } /**************************************************************************** * reset reason setting/getting functions ****************************************************************************/ static void set_reset_reason(uint32_t reason) { g_altmdm_dev.reset_reason = reason; } static uint32_t get_reset_reason(void) { return g_altmdm_dev.reset_reason; } /**************************************************************************** * tx done function ****************************************************************************/ static void tx_done(uint32_t result) { nxsem_wait_uninterruptible(&g_altmdm_dev.lock_txreq); g_altmdm_dev.txreq_buff = NULL; g_altmdm_dev.txreq_size = 0; altmdm_event_clear(&g_altmdm_dev.event, EVENT_TXREQ); altmdm_event_set(&g_altmdm_dev.txdone_event, result); nxsem_post(&g_altmdm_dev.lock_txreq); } /**************************************************************************** * converts unit of timer function ****************************************************************************/ static void usec2timespec(useconds_t usec, FAR struct timespec *timespec) { time_t sec; sec = usec / 1000000; timespec->tv_sec = sec; timespec->tv_nsec = (usec - (sec * 1000000)) * 1000; } static void process_before_poweroff(void) { uint32_t allevt = (uint32_t)(-1); set_vp(VP_NO_RESET); altmdm_timer_restart(g_altmdm_dev.txsus_timer, 0, 0); /* Cancel tx request. */ tx_done(TX_CANCEL); /* clear event without EVENT_POWERON */ altmdm_event_clear(&g_altmdm_dev.event, (allevt & ~(EVENT_POWERON | EVENT_DESTROY))); g_altmdm_dev.lower->irqenable(false); g_altmdm_dev.lower->set_wakeup(false); g_altmdm_dev.lower->set_mready(false); } /**************************************************************************** * force reset function ****************************************************************************/ static void force_reset(void) { if (is_vp_valid()) { set_reset_reason(LTE_RESTART_MODEM_INITIATED); } process_before_poweroff(); g_altmdm_dev.lower->reset(); g_altmdm_dev.lower->irqenable(true); } /**************************************************************************** * State common functions ****************************************************************************/ static int next_state_common(altmdm_state_t state) { return 0; } static uint32_t waitevt_state_common(void) { return 0; } static altmdm_state_t process_state_common(uint32_t event, altmdm_state_t state) { return state; } /**************************************************************************** * On POWEROFF state ****************************************************************************/ static int next_state_poweroff(altmdm_state_t state) { process_before_poweroff(); g_altmdm_dev.lower->poweroff(); return 0; } static uint32_t waitevt_state_poweroff(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_POWERON | EVENT_DESTROY | EVENT_SUSPEND | EVENT_RESUME, false, 0); } static altmdm_state_t process_state_poweroff(uint32_t event, altmdm_state_t state) { struct timespec interval; if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & (EVENT_POWERON | EVENT_SUSPEND | EVENT_RESUME)) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWERON); usec2timespec(RESET_INTERVAL, &interval); nxsig_nanosleep(&interval, NULL); g_altmdm_dev.spidev = g_altmdm_dev.lower->poweron(false); g_altmdm_dev.lower->set_mready(false); g_altmdm_dev.lower->set_wakeup(false); g_altmdm_dev.lower->irqenable(true); set_reset_reason(LTE_RESTART_USER_INITIATED); state = ALTMDM_STATE_SLEEP; } return state; } /**************************************************************************** * SLEEP state ****************************************************************************/ static int next_state_sleep(altmdm_state_t state) { uint32_t evt = altmdm_event_refer(&g_altmdm_dev.event); g_altmdm_dev.lower->set_wakeup(false); if ((evt & EVENT_SUSPEND) != 0) { set_return_code(ALTMDM_RETURN_SUSPENDED); return 1; } return 0; } static uint32_t waitevt_state_sleep(void) { uint32_t event; if (!is_vp_valid()) { return 0; } event = altmdm_event_wait(&g_altmdm_dev.event, EVENT_TXREQ | EVENT_RXREQ | EVENT_WLOCK | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY | EVENT_SUSPEND, false, 0); return event; } static altmdm_state_t process_state_sleep(uint32_t event, altmdm_state_t state) { /* The order of checking the events is related to processing * priority, so be careful when making changes. */ if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (!is_vp_valid()) { state = ALTMDM_STATE_IDLE4RST; } else if (event & EVENT_SUSPEND) { state = ALTMDM_STATE_SLEEP; } else if (event & (EVENT_TXREQ | EVENT_RXREQ)) { state = ALTMDM_STATE_IDLEWTO; } else if (event & EVENT_WLOCK) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_WLOCK); if (get_wlock_count() != 0) { state = ALTMDM_STATE_IDLEWOTO; } } return state; } /**************************************************************************** * SLEEPWOTX state ****************************************************************************/ static int next_state_sleepwotx(altmdm_state_t state) { g_altmdm_dev.lower->set_wakeup(false); return 0; } static uint32_t waitevt_state_sleepwotx(void) { uint32_t event; event = altmdm_event_wait(&g_altmdm_dev.event, EVENT_RXREQ | EVENT_TXSUSTO | EVENT_WLOCK | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY, false, 0); return event; } static altmdm_state_t process_state_sleepwotx(uint32_t event, altmdm_state_t state) { if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (event & EVENT_RXREQ) { state = ALTMDM_STATE_IDLEWOTX; } else if (event & EVENT_WLOCK) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_WLOCK); if (get_wlock_count() != 0) { state = ALTMDM_STATE_IDLEWOTX; } } else if (event & EVENT_TXSUSTO) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_TXSUSTO); state = ALTMDM_STATE_SLEEP; } return state; } /**************************************************************************** * IDLE4RST state ****************************************************************************/ static int next_state_idle4rst(altmdm_state_t state) { /* clear TX buffer */ altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, NULL, 0); g_altmdm_dev.lower->set_wakeup(true); return 0; } static uint32_t waitevt_state_idle4rst(void) { enum version_phase_e vp; vp = get_vp(); if (vp == VP_UNKNOWN) { return 0; } else if (vp == VP_NOTV1) { return 0; } return altmdm_event_wait(&g_altmdm_dev.event, EVENT_RXREQ | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY, false, 0); } static altmdm_state_t process_state_idle4rst(uint32_t event, altmdm_state_t state) { enum version_phase_e vp; vp = get_vp(); if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (vp == VP_UNKNOWN) { state = ALTMDM_STATE_V1SET; } else if (vp == VP_NOTV1) { state = ALTMDM_STATE_V4SET; } else if (event & EVENT_RXREQ) { state = ALTMDM_STATE_HDRSREQ; } return state; } /**************************************************************************** * IDLEWTO state ****************************************************************************/ static int next_state_idlewto(altmdm_state_t state) { /* clear TX buffer */ altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, NULL, 0); g_altmdm_dev.lower->set_wakeup(true); return 0; } static uint32_t waitevt_state_idlewto(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_TXREQ | EVENT_RXREQ | EVENT_WLOCK | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY | EVENT_SUSPEND, false, TIMEOUT_IDELEWTO_STATE); } static altmdm_state_t process_state_idlewto(uint32_t event, altmdm_state_t state) { /* The order of checking the events is related to processing * priority, so be careful when making changes. */ if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (event & EVENT_SUSPEND) { state = ALTMDM_STATE_SLEEPSET; } else if (event & EVENT_TXREQ) { state = ALTMDM_STATE_TXPREPARE; } else if (event & EVENT_RXREQ) { state = ALTMDM_STATE_HDRSREQ; } else if (event & EVENT_WLOCK) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_WLOCK); if (get_wlock_count() != 0) { state = ALTMDM_STATE_IDLEWOTO; } } else /* Time out case */ { state = ALTMDM_STATE_SLEEPSET; } return state; } /**************************************************************************** * IDLEWOTO state ****************************************************************************/ static int next_state_idlewoto(altmdm_state_t state) { /* clear TX buffer */ altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, NULL, 0); g_altmdm_dev.lower->set_wakeup(true); return 0; } static uint32_t waitevt_state_idlewoto(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_TXREQ | EVENT_RXREQ | EVENT_WLOCK | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY, false, 0); } static altmdm_state_t process_state_idlewoto(uint32_t event, altmdm_state_t state) { if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (event & EVENT_TXREQ) { state = ALTMDM_STATE_TXPREPARE; } else if (event & EVENT_RXREQ) { state = ALTMDM_STATE_HDRSREQ; } else if (event & EVENT_WLOCK) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_WLOCK); if (get_wlock_count() == 0) { state = ALTMDM_STATE_IDLEWTO; } } return state; } /**************************************************************************** * IDLEWOTX state ****************************************************************************/ static int next_state_idlewotx(altmdm_state_t state) { /* clear TX buffer */ altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, NULL, 0); g_altmdm_dev.lower->set_wakeup(true); return 0; } static uint32_t waitevt_state_idlewotx(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_RXREQ | EVENT_TXSUSTO | EVENT_POWEROFF | EVENT_RESET | EVENT_DESTROY, false, 0); } static altmdm_state_t process_state_idlewotx(uint32_t event, altmdm_state_t state) { if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RESET) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RESET); state = ALTMDM_STATE_FORCERST; } else if (event & EVENT_RXREQ) { state = ALTMDM_STATE_HDRSREQ; } else if (event & EVENT_TXSUSTO) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_TXSUSTO); if (!is_vp_valid()) { state = ALTMDM_STATE_IDLE4RST; } else if (get_wlock_count() == 0) { state = ALTMDM_STATE_IDLEWTO; } else { state = ALTMDM_STATE_IDLEWOTO; } } return state; } /**************************************************************************** * V1SET state ****************************************************************************/ static altmdm_state_t process_state_v1set(uint32_t event, altmdm_state_t state) { int len; FAR void *pkt; pkt = altcom_make_poweron_cmd_v1(&len); set_vp(VP_TRYV1); altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, pkt, len); return ALTMDM_STATE_TXREQ; } /**************************************************************************** * V4SET state ****************************************************************************/ static altmdm_state_t process_state_v4set(uint32_t event, altmdm_state_t state) { int len; FAR void *pkt; pkt = altcom_make_poweron_cmd_v4(&len); set_vp(VP_TRYV4); altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, pkt, len); return ALTMDM_STATE_TXREQ; } /**************************************************************************** * SLEEPSET state ****************************************************************************/ static altmdm_state_t process_state_sleepset(uint32_t event, altmdm_state_t state) { altmdm_set_sleeppkt(&g_altmdm_dev.tx_pkt); return ALTMDM_STATE_TXREQ; } /**************************************************************************** * TXPREPARE state ****************************************************************************/ static altmdm_state_t process_state_txprepare(uint32_t event, altmdm_state_t state) { FAR void *buff; int len; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_txreq); buff = g_altmdm_dev.txreq_buff; len = g_altmdm_dev.txreq_size; nxsem_post(&g_altmdm_dev.lock_txreq); altmdm_set_spipkt_txbuffer(&g_altmdm_dev.tx_pkt, buff, len); return ALTMDM_STATE_TXREQ; } /**************************************************************************** * TXREQ state ****************************************************************************/ static altmdm_state_t process_state_txreq(uint32_t event, altmdm_state_t state) { g_altmdm_dev.lower->set_mready(true); return ALTMDM_STATE_HDRSREQ; } /**************************************************************************** * HDRSREQ state ****************************************************************************/ static int next_state_hdrsreq(altmdm_state_t state) { uint32_t evt = altmdm_event_refer(&g_altmdm_dev.event); if (get_vp() == VP_V4) { g_altmdm_dev.retry_mode = (evt & EVENT_RETRYREQ) ? 1 : 0; if (g_altmdm_dev.retry_mode) { altmdm_set_retrypkt(&g_altmdm_dev.tx_pkt); } } else { g_altmdm_dev.retry_mode = 0; } return 0; } static uint32_t waitevt_state_hdrsreq(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_RXREQ | EVENT_POWEROFF | EVENT_DESTROY, false, TIMEOUT_HDR_TRX_STATE); } static altmdm_state_t process_state_hdrsreq(uint32_t event, altmdm_state_t state) { if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RXREQ) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RXREQ); state = ALTMDM_STATE_HDRTRX; } else /* Time out case */ { if (is_vp_noreset()) { state = ALTMDM_STATE_DECIDEDELAY; } else { m_err("[altmdm] Time out happened. Current State is %d\n", state); state = ALTMDM_STATE_FORCERST; } } return state; } /**************************************************************************** * HDRTRX state ****************************************************************************/ static altmdm_state_t process_state_hdrtrx(uint32_t event, altmdm_state_t state) { altmdm_do_hdr_transaction(g_altmdm_dev.spidev, g_altmdm_dev.lower, &g_altmdm_dev.tx_pkt, &g_altmdm_dev.rx_pkt); if (!altmdm_is_valid_spipkt_header(&g_altmdm_dev.rx_pkt)) { if (is_vp_noreset()) { state = ALTMDM_STATE_DECIDEDELAY; } else { m_err("[altmdm] Header error. Current State is %d\n", state); if (g_altmdm_dev.retry_mode) { state = ALTMDM_STATE_POWEROFF; } else { state = ALTMDM_STATE_FORCERST; } } } else if (is_reset_pkt(&g_altmdm_dev.rx_pkt) && g_altmdm_dev.retry_mode) { state = ALTMDM_STATE_POWEROFF; } else if (is_sleep_pkt(&g_altmdm_dev.tx_pkt)) { state = ALTMDM_STATE_SLEEPPKT; } else if ((pkt_total_size(&g_altmdm_dev.tx_pkt) == 0) && (pkt_total_size(&g_altmdm_dev.rx_pkt) == 0)) { state = ALTMDM_STATE_DECIDEDELAY; } else { state = ALTMDM_STATE_BODYSREQ; } return state; } /**************************************************************************** * SLEEPPKT state ****************************************************************************/ static altmdm_state_t process_state_sleeppkt(uint32_t event, altmdm_state_t state) { altmdm_overwrite_body_size(&g_altmdm_dev.rx_pkt, 4); return ALTMDM_STATE_BODYSREQ; } /**************************************************************************** * BODYSREQ state ****************************************************************************/ static uint32_t waitevt_state_bodysreq(void) { return altmdm_event_wait(&g_altmdm_dev.event, EVENT_RXREQ | EVENT_POWEROFF | EVENT_DESTROY, false, TIMEOUT_BODY_TRX_STATE); } static altmdm_state_t process_state_bodysreq(uint32_t event, altmdm_state_t state) { if (event & EVENT_DESTROY) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_DESTROY); state = ALTMDM_STATE_DESTORY; } else if (event & EVENT_POWEROFF) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_POWEROFF); state = ALTMDM_STATE_POWEROFF; } else if (event & EVENT_RXREQ) { altmdm_event_clear(&g_altmdm_dev.event, EVENT_RXREQ); state = ALTMDM_STATE_BODYTRX; } else /* Time out case */ { if (is_vp_noreset()) { state = ALTMDM_STATE_DECIDEDELAY; } else { m_err("[altmdm] Timeout happened. Current State is %d\n", state); state = ALTMDM_STATE_FORCERST; } } return state; } /**************************************************************************** * BODYTRX state ****************************************************************************/ static altmdm_state_t process_state_bodytrx(uint32_t event, altmdm_state_t state) { altmdm_do_body_transaction(g_altmdm_dev.spidev, g_altmdm_dev.lower, &g_altmdm_dev.tx_pkt, &g_altmdm_dev.rx_pkt); g_altmdm_dev.lower->set_mready(false); if (is_reset_pkt(&g_altmdm_dev.rx_pkt)) { state = ALTMDM_STATE_GOTRST; } else if (is_sleep_pkt(&g_altmdm_dev.tx_pkt)) { state = ALTMDM_STATE_GOTSLEEP; } else if (pkt_total_size(&g_altmdm_dev.rx_pkt) != 0 && g_altmdm_dev.retry_mode == 0) { state = ALTMDM_STATE_GOTRX; } else { state = ALTMDM_STATE_DECIDEDELAY; } if (has_sendrequest(&g_altmdm_dev.tx_pkt)) { if (is_reset_pkt(&g_altmdm_dev.rx_pkt)) { tx_done(TX_CANCEL); } else if (!is_buffer_full(&g_altmdm_dev.rx_pkt)) { tx_done(TX_DONE); } } if (!is_buffer_full(&g_altmdm_dev.rx_pkt)) { altmdm_timer_restart(g_altmdm_dev.txsus_timer, 0, 0); } return state; } /**************************************************************************** * GOTRX state ****************************************************************************/ static altmdm_state_t process_state_gotrx(uint32_t event, altmdm_state_t state) { enum version_phase_e vp; FAR void *rcv_data; state = ALTMDM_STATE_DECIDEDELAY; if (is_vp_valid()) { set_return_code(pkt_actual_size(&g_altmdm_dev.rx_pkt)); state = ALTMDM_STATE_RETRECV; } else { rcv_data = get_pkt_buffer(&g_altmdm_dev.rx_pkt); vp = get_vp(); if (vp == VP_TRYV1) { if (altcom_is_v1pkt_ok((FAR struct altcom_cmdhdr_s *)rcv_data)) { set_vp(VP_V1); set_return_code(ALTMDM_RETURN_RESET_V1); state = ALTMDM_STATE_RETRECV; } else { set_vp(VP_NOTV1); } } else if ((vp == VP_TRYV4) && altcom_is_v4pkt_ok((FAR struct altcom_cmdhdr_s *)rcv_data)) { set_vp(VP_V4); set_return_code(ALTMDM_RETURN_RESET_V4); state = ALTMDM_STATE_RETRECV; } } return state; } /**************************************************************************** * GOTRST state ****************************************************************************/ static altmdm_state_t process_state_gotrst(uint32_t event, altmdm_state_t state) { if (is_vp_noreset()) { set_return_code(ALTMDM_RETURN_RESET_PKT); set_vp(VP_UNKNOWN); state = ALTMDM_STATE_RETRECV; } else { m_err("[altmdm] Reset pkt received. Current State is %d\n", state); state = ALTMDM_STATE_FORCERST; } return state; } /**************************************************************************** * GOTSLEEP state ****************************************************************************/ static uint32_t waitevt_state_gotsleep(void) { uint32_t evt = altmdm_event_refer(&g_altmdm_dev.event); /* GOTSLEEP state only check current event flags for SUSPEND. */ if ((evt & EVENT_SUSPEND) != 0) { return EVENT_SUSPEND; } else { return 0; } } static altmdm_state_t process_state_gotsleep(uint32_t event, altmdm_state_t state) { if (event & EVENT_SUSPEND) { state = ALTMDM_STATE_SLEEP; } else { if (altmdm_is_sleeppkt_ok(&g_altmdm_dev.rx_pkt)) { state = ALTMDM_STATE_SLEEPING; } else { state = ALTMDM_STATE_DECIDEDELAY; } } return state; } /**************************************************************************** * BACKTOIDLE state ****************************************************************************/ static altmdm_state_t process_state_backtoidle(uint32_t event, altmdm_state_t state) { if (is_buffer_full(&g_altmdm_dev.rx_pkt)) { if (altmdm_timer_is_running(g_altmdm_dev.txsus_timer)) { state = ALTMDM_STATE_IDLEWOTX; } else { state = ALTMDM_STATE_SETSUSTIMER; } } else if (!is_vp_valid()) { state = ALTMDM_STATE_IDLE4RST; } else if (get_wlock_count() != 0) { state = ALTMDM_STATE_IDLEWOTO; } else { state = ALTMDM_STATE_IDLEWTO; } return state; } /**************************************************************************** * RETRECV state ****************************************************************************/ static altmdm_state_t process_state_retrecv(uint32_t event, altmdm_state_t state) { return ALTMDM_STATE_DECIDEDELAY; } /**************************************************************************** * FORCERST state ****************************************************************************/ static altmdm_state_t process_state_forcerst(uint32_t event, altmdm_state_t state) { force_reset(); return ALTMDM_STATE_BACKTOIDLE; } /**************************************************************************** * SLEEPING state ****************************************************************************/ static uint32_t waitevt_state_sleeping(void) { up_udelay(TIMEOUT_NEXT_DELAY); return 0; } static altmdm_state_t process_state_sleeping(uint32_t event, altmdm_state_t state) { if (is_buffer_full(&g_altmdm_dev.rx_pkt)) { if (altmdm_timer_is_running(g_altmdm_dev.txsus_timer)) { state = ALTMDM_STATE_SLEEPWOTX; } else { state = ALTMDM_STATE_SETSUSTIMERSLEEP; } } else { state = ALTMDM_STATE_SLEEP; } return state; } /**************************************************************************** * DECIDEDELAY state ****************************************************************************/ static int next_state_decidedelay(altmdm_state_t state) { return (state == ALTMDM_STATE_RETRECV); } static altmdm_state_t process_state_decidedelay(uint32_t event, altmdm_state_t state) { if (has_sendrequest(&g_altmdm_dev.tx_pkt) || is_sleep_pkt(&g_altmdm_dev.tx_pkt)) { state = ALTMDM_STATE_DELAYNEXT; } else { state = ALTMDM_STATE_BACKTOIDLE; } return state; } /**************************************************************************** * DELAYNEXT state ****************************************************************************/ static uint32_t waitevt_state_delaynext(void) { up_udelay(TIMEOUT_NEXT_DELAY); return 0; } static altmdm_state_t process_state_delaynext(uint32_t event, altmdm_state_t state) { state = ALTMDM_STATE_BACKTOIDLE; return state; } /**************************************************************************** * SETSUSTIMER state ****************************************************************************/ static altmdm_state_t process_state_setsustimer(uint32_t event, altmdm_state_t state) { altmdm_timer_restart(g_altmdm_dev.txsus_timer, TXSUS_TIMEOUT, 0); return ALTMDM_STATE_IDLEWOTX; } /**************************************************************************** * SETSUSTIMERSLEEP state ****************************************************************************/ static altmdm_state_t process_state_setsustimersleep(uint32_t event, altmdm_state_t state) { altmdm_timer_restart(g_altmdm_dev.txsus_timer, TXSUS_TIMEOUT, 0); return ALTMDM_STATE_SLEEPWOTX; } /**************************************************************************** * DESTORY state ****************************************************************************/ static int next_state_destroy(altmdm_state_t state) { next_state_poweroff(state); altmdm_event_clear(&g_altmdm_dev.event, (uint32_t)(-1)); altmdm_timer_stop(g_altmdm_dev.txsus_timer); set_return_code(ALTMDM_RETURN_EXIT); return 1; } /**************************************************************************** * Public Functions ****************************************************************************/ int altmdm_init(FAR struct spi_dev_s *spidev, FAR const struct alt1250_lower_s *lower) { altmdm_event_init(&g_altmdm_dev.event); altmdm_event_init(&g_altmdm_dev.txdone_event); nxsem_init(&g_altmdm_dev.lock_evt, 0, 1); nxsem_init(&g_altmdm_dev.lock_vp, 0, 1); nxsem_init(&g_altmdm_dev.lock_counter, 0, 1); nxsem_init(&g_altmdm_dev.lock_txreq, 0, 1); altmdm_spipkt_init(&g_altmdm_dev.tx_pkt); altmdm_spipkt_init(&g_altmdm_dev.rx_pkt); g_altmdm_dev.spidev = spidev; g_altmdm_dev.lower = lower; g_altmdm_dev.txsus_timer = altmdm_timer_start(0, 0, txsustimer_handler, &g_altmdm_dev); g_altmdm_dev.wcounter = 0; g_altmdm_dev.rx_retcode = 0; g_altmdm_dev.txreq_buff = NULL; g_altmdm_dev.txreq_size = 0; g_altmdm_dev.retry_mode = 0; lower->irqattach(sready_isr); if (altmdm_get_powersupply(lower)) { /* When the ALT1250 is turned on during initialization, * it means that the ALT1250 has returned from hibernation. * After recovery, ALTMDM state is Sleep. * And this function is supported only when the protocol * version is PV4. */ g_altmdm_dev.current_state = ALTMDM_STATE_SLEEP; g_altmdm_dev.vp = VP_V4; g_altmdm_dev.spidev = g_altmdm_dev.lower->poweron(true); g_altmdm_dev.lower->set_mready(false); g_altmdm_dev.lower->set_wakeup(false); g_altmdm_dev.lower->irqenable(true); altmdm_set_pm_event(EVENT_RETRYREQ, true); next_state_sleep(g_altmdm_dev.current_state); } else { g_altmdm_dev.current_state = ALTMDM_STATE_POWEROFF; g_altmdm_dev.vp = VP_NO_RESET; next_state_poweroff(g_altmdm_dev.current_state); } return 0; } int altmdm_fin(void) { altmdm_event_set(&g_altmdm_dev.event, EVENT_DESTROY); return OK; } int altmdm_poweron(void) { int ret = OK; uint32_t evt; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_evt); evt = altmdm_event_refer(&g_altmdm_dev.event); /* Is already accepted DESTROY request? */ if (evt & EVENT_DESTROY) { ret = -EOPNOTSUPP; } /* Is already accepted EVENT_POWERON request? */ else if (evt & EVENT_POWERON) { ret = -EALREADY; } /* Is in POWERON state? */ if ((g_altmdm_dev.current_state != ALTMDM_STATE_POWEROFF) && (g_altmdm_dev.current_state != ALTMDM_STATE_DESTORY)) { if (!(evt & EVENT_POWEROFF)) { ret = -EALREADY; } } if (ret == OK) { altmdm_event_set(&g_altmdm_dev.event, EVENT_POWERON); } nxsem_post(&g_altmdm_dev.lock_evt); return ret; } int altmdm_poweroff(void) { int ret = OK; uint32_t evt; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_evt); evt = altmdm_event_refer(&g_altmdm_dev.event); /* Is already accepted DESTROY request? */ if (evt & EVENT_DESTROY) { ret = -EOPNOTSUPP; } /* Is already accepted POWEROFF request? */ else if (evt & EVENT_POWEROFF) { ret = -EALREADY; } /* Is in POWEROFF state? */ if ((g_altmdm_dev.current_state == ALTMDM_STATE_POWEROFF) || (g_altmdm_dev.current_state == ALTMDM_STATE_DESTORY)) { if (!(evt & EVENT_POWERON)) { ret = -EALREADY; } } if (ret == OK) { altmdm_event_set(&g_altmdm_dev.event, EVENT_POWEROFF); } nxsem_post(&g_altmdm_dev.lock_evt); return ret; } bool altmdm_get_powersupply(FAR const struct alt1250_lower_s *lower) { if (!lower || !lower->powerstatus) { m_err("Lower driver not registered.\n"); return false; } return lower->powerstatus(); } int altmdm_reset(void) { nxsem_wait_uninterruptible(&g_altmdm_dev.lock_evt); altmdm_event_set(&g_altmdm_dev.event, EVENT_RESET); nxsem_post(&g_altmdm_dev.lock_evt); return 0; } int altmdm_read(FAR uint8_t *buff, int sz) { int is_exit = 0; uint32_t event = 0; altmdm_state_t next_state = ALTMDM_STATE_POWEROFF; altmdm_set_spipkt_rxbuffer(&g_altmdm_dev.rx_pkt, buff, sz); dump_current_all_status(&g_altmdm_dev, event, next_state, is_exit); /* State machine loop */ while (!is_exit) { /* Waiting events */ event = g_state_func[g_altmdm_dev.current_state].wait_event(); /* altmdm_fin(), altmdm_poweron(), and altmdm_poweroff() check * the event flag and decide whether or not to send the event. * Since this event flag checking process and the process to clear * the event flag will cause resource conflicts, so added this function * for exclusivity. */ nxsem_wait_uninterruptible(&g_altmdm_dev.lock_evt); /* Process on the state */ next_state = g_state_func[g_altmdm_dev.current_state].process_state( event, g_altmdm_dev.current_state); /* Going to next state */ is_exit = g_state_func[next_state].goto_next( g_altmdm_dev.current_state); dump_current_all_status(&g_altmdm_dev, event, next_state, is_exit); g_altmdm_dev.current_state = next_state; nxsem_post(&g_altmdm_dev.lock_evt); } return g_altmdm_dev.rx_retcode; } int altmdm_write(FAR uint8_t *buff, int sz) { bool should_wait = true; uint32_t ret; sz = (sz > get_spipayload_maxsize()) ? get_spipayload_maxsize() : sz; do { if (!is_vp_valid()) { return ALTMDM_RETURN_NOTREADY; } nxsem_wait_uninterruptible(&g_altmdm_dev.lock_txreq); if (g_altmdm_dev.txreq_buff == NULL) { g_altmdm_dev.txreq_buff = buff; g_altmdm_dev.txreq_size = sz; should_wait = false; altmdm_event_set(&g_altmdm_dev.event, EVENT_TXREQ); altmdm_event_clear(&g_altmdm_dev.txdone_event, (uint32_t)-1); } nxsem_post(&g_altmdm_dev.lock_txreq); if (should_wait) { ret = altmdm_event_wait(&g_altmdm_dev.txdone_event, TX_DONE | TX_CANCEL, true, 0); if (ret & TX_CANCEL) { return ALTMDM_RETURN_CANCELED; } } } while (should_wait); ret = altmdm_event_wait(&g_altmdm_dev.txdone_event, TX_DONE | TX_CANCEL, true, 0); if (ret & TX_DONE) { return sz; } else { return ALTMDM_RETURN_CANCELED; } } int altmdm_take_wlock(void) { int cnt; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_counter); cnt = ++g_altmdm_dev.wcounter; nxsem_post(&g_altmdm_dev.lock_counter); altmdm_event_set(&g_altmdm_dev.event, EVENT_WLOCK); return cnt; } int altmdm_give_wlock(void) { int cnt; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_counter); if (g_altmdm_dev.wcounter != 0) { g_altmdm_dev.wcounter--; } cnt = g_altmdm_dev.wcounter; nxsem_post(&g_altmdm_dev.lock_counter); if (cnt == 0) { altmdm_event_set(&g_altmdm_dev.event, EVENT_WLOCK); } return cnt; } int altmdm_count_wlock(void) { return g_altmdm_dev.wcounter; } uint32_t altmdm_get_reset_reason(void) { return get_reset_reason(); } uint8_t altmdm_get_protoversion(void) { enum version_phase_e vp; nxsem_wait_uninterruptible(&g_altmdm_dev.lock_vp); vp = g_altmdm_dev.vp; vp = ((vp == VP_V1) || (vp == VP_V4)) ? vp : ALTCOM_VERX; nxsem_post(&g_altmdm_dev.lock_vp); return (uint8_t)vp; } int altmdm_set_pm_event(uint32_t event, bool enable) { if (enable) { return altmdm_event_set(&g_altmdm_dev.event, event); } else { return altmdm_event_clear(&g_altmdm_dev.event, event); } } #endif