sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
93cdae50fc
nuttx/wireless/ieee802154/mac802154_internal.h

822 lines
27 KiB
C
Raw Normal View History

Remove carriage return endings and dangling white space at the end of lines
2017-07-10 00:53:08 +02:00
/****************************************************************************
* wireless/ieee802154/mac802154_internal.h
*
* Copyright (C) 2016 Sebastien Lorquet. All rights reserved.
* Copyright (C) 2017 Verge Inc. All rights reserved.
* Copyright (C) 2017 Gregory Nutt. All rights reserved.
*
* Author: Sebastien Lorquet <sebastien@lorquet.fr>
* Author: Anthony Merlino <anthony@vergeaero.com>
*
* The naming and comments for various fields are taken directly
* from the IEEE 802.15.4 2011 standard.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __WIRELESS_IEEE802154__MAC802154_INTERNAL_H
#define __WIRELESS_IEEE802154__MAC802154_INTERNAL_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <string.h>
#include <nuttx/wdog.h>
#include <nuttx/wqueue.h>
#include "mac802154_notif.h"
#include <nuttx/wireless/ieee802154/ieee802154_mac.h>
#include <nuttx/wireless/ieee802154/ieee802154_radio.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
/* If processing is not done at the interrupt level, then work queue support
* is required.
*/
#if !defined(CONFIG_SCHED_WORKQUEUE)
# error Work queue support is required in this configuration (CONFIG_SCHED_WORKQUEUE)
#else
/* Use the low priority work queue if possible */
# if defined(CONFIG_MAC802154_HPWORK)
# define MAC802154_WORK HPWORK
# elif defined(CONFIG_MAC802154_LPWORK)
# define MAC802154_WORK LPWORK
# else
# error Neither CONFIG_MAC802154_HPWORK nor CONFIG_MAC802154_LPWORK defined
# endif
#endif
#if !defined(CONFIG_MAC802154_NNOTIF) || CONFIG_MAC802154_NNOTIF <= 0
# undef CONFIG_MAC802154_NNOTIF
# define CONFIG_MAC802154_NNOTIF 6
#endif
#if !defined(CONFIG_MAC802154_NTXDESC) || CONFIG_MAC802154_NTXDESC <= 0
# undef CONFIG_MAC802154_NTXDESC
# define CONFIG_MAC802154_NTXDESC 3
#endif
#if CONFIG_MAC802154_NTXDESC > CONFIG_MAC802154_NNOTIF
# error CONFIG_MAC802154_NNOTIF must be greater than CONFIG_MAC802154_NTXDESC
#endif
#if !defined(CONFIG_IEEE802154_DEFAULT_EADDR)
# define CONFIG_IEEE802154_DEFAULT_EADDR 0xFFFFFFFFFFFFFFFF
#endif
/****************************************************************************
* Private Data
****************************************************************************/
/* Map between ieee802154_addrmode_e enum and actual address length */
static const uint8_t mac802154_addr_length[4] = {0, 0, 2, 8};
/****************************************************************************
* Private Types
****************************************************************************/
struct mac802154_radiocb_s
{
struct ieee802154_radiocb_s cb;
FAR struct ieee802154_privmac_s *priv;
};
/* Enumeration for representing what operation the MAC layer is currently doing.
* There can only be one command being handled at any given time, but certain
* operations such as association requires more than one command to be sent.
* Therefore, the need to track not only what command is currently active, but
* also, what overall operation the command is apart of is necessary.
*/
enum mac802154_operation_e
{
MAC802154_OP_NONE,
MAC802154_OP_ASSOC,
MAC802154_OP_POLL,
MAC802154_OP_SCAN,
MAC802154_OP_AUTOEXTRACT,
};
/* The privmac structure holds the internal state of the MAC and is the
* underlying represention of the opaque MACHANDLE. It contains storage for
* the IEEE802.15.4 MIB attributes.
*/
struct ieee802154_privmac_s
{
/*************************** General Fields *********************************/
FAR struct ieee802154_radio_s *radio; /* Contained IEEE802.15.4 radio dev */
FAR struct mac802154_maccb_s *cb; /* Head of a list of MAC callbacks */
FAR struct mac802154_radiocb_s radiocb; /* Interface to bind to radio */
sem_t exclsem; /* Support exclusive access */
uint8_t nclients; /* Number of notification clients */
/* Only support a single command at any given time. As of now I see no
* condition where you need to have more than one command frame simultaneously
*/
sem_t opsem; /* Exclusive operations */
/******************* Fields related to MAC operations ***********************/
enum mac802154_operation_e curr_op; /* The current overall operation */
enum ieee802154_cmdid_e curr_cmd; /* Type of the current cmd */
FAR struct ieee802154_txdesc_s *cmd_desc; /* TX descriptor for current cmd */
uint8_t nrxusers;
/******************* Fields related to SCAN operation ***********************/
/* List of PAN descriptors to track during scan procedures */
uint8_t scanindex;
uint8_t npandesc;
struct ieee802154_pandesc_s pandescs[MAC802154_NPANDESC];
uint8_t panidbeforescan[IEEE802154_PANIDSIZE];
struct ieee802154_scan_req_s currscan;
uint32_t scansymdur;
/******************* Fields related to notifications ************************/
/* Pre-allocated notifications to be passed to the registered callback. These
* need to be freed by the application using mac802154_xxxxnotif_free when
* the callee layer is finished with it's use.
*/
FAR struct mac802154_notif_s *notif_free;
struct mac802154_notif_s notif_pool[CONFIG_MAC802154_NNOTIF];
sem_t notif_sem;
/******************* Tx descriptor queues and pools *************************/
struct ieee802154_txdesc_s txdesc_pool[CONFIG_MAC802154_NTXDESC];
sem_t txdesc_sem;
sq_queue_t txdesc_queue;
sq_queue_t txdone_queue;
/* Support a singly linked list of transactions that will be sent using the
* CSMA algorithm. On a non-beacon enabled PAN, these transactions will be
* sent whenever. On a beacon-enabled PAN, these transactions will be sent
* during the CAP of the Coordinator's superframe.
*/
sq_queue_t csma_queue;
sq_queue_t gts_queue;
/* Support a singly linked list of transactions that will be sent indirectly.
* This list should only be used by a MAC acting as a coordinator. These
* transactions will stay here until the data is extracted by the destination
* device sending a Data Request MAC command or if too much time passes. This
* list should also be used to populate the address list of the outgoing
* beacon frame.
*/
sq_queue_t indirect_queue;
/* Support a singly linked list of frames received */
sq_queue_t dataind_queue;
/************* Fields related to addressing and coordinator *****************/
/* Holds all address information (Extended, Short, and PAN ID) for the MAC. */
struct ieee802154_addr_s addr;
struct ieee802154_pandesc_s pandesc;
/*************** Fields related to beacon-enabled networks ******************/
/* Holds attributes pertaining to the superframe specification */
struct ieee802154_superframespec_s sfspec;
/* We use 2 beacon frame structures so that we can ping-pong between them
* while updating the beacon
*/
struct ieee802154_beaconframe_s beaconframe[2];
/* Contents of beacon payload */
uint8_t beaconpayload[IEEE802154_MAX_BEACON_PAYLOAD_LEN];
uint8_t beaconpayloadlength;
/****************** Fields related to offloading work ***********************/
/* Work structures for offloading aynchronous work */
struct work_s tx_work;
struct work_s rx_work;
struct work_s purge_work;
ieee802154: Improves internal timer logic to handle work serially Before, the MAC timer used a watchdog to schedule work with the high priority worker queue. However, since everything in the MAC is supposed to be serialized through the use of the high priority work queue, but the timer uses a watchdog, there are some unintended consequences. To simplify, we now use the delayed work feature of the work queue.
2017-07-10 05:55:48 +02:00
struct work_s timer_work;
Remove carriage return endings and dangling white space at the end of lines
2017-07-10 00:53:08 +02:00
/****************** Uncategorized MAC PIB attributes ***********************/
/* The maximum number of symbols to wait for an acknowledgement frame to
* arrive following a transmitted data frame. [1] pg. 126
*
* NOTE: This may be able to be a 16-bit or even an 8-bit number. I wasn't
* sure at the time what the range of reasonable values was.
*/
uint32_t ack_waitdur;
/* The maximum time to wait either for a frame intended as a response to a
* data request frame or for a broadcast frame following a beacon with the
* Frame Pending field set to one. [1] pg. 127
*
* NOTE: This may be able to be a 16-bit or even an 8-bit number. I wasn't
* sure at the time what the range of reasonable values was.
*/
uint32_t max_frame_waittime;
/* The maximum time (in unit periods) that a transaction is stored by a
* coordinator and indicated in its beacon.
*/
uint16_t trans_persisttime;
uint8_t dsn; /* Seq. num added to tx data or MAC frame */
/* The maximum time, in multiples of aBaseSuperframeDuration, a device shall
* wait for a response command frame to be available following a request
* command frame. [1] 128.
*/
uint8_t resp_waittime;
/* The total transmit duration (including PHY header and FCS) specified in
* symbols. [1] pg. 129.
*/
uint32_t tx_totaldur;
/* Start of 8-bit bitfield */
uint32_t trackingbeacon : 1; /* Are we tracking the beacon */
uint32_t isassoc : 1; /* Are we associated to the PAN */
uint32_t autoreq : 1; /* Automatically send data req. if addr
* addr is in the beacon frame */
uint32_t gtspermit : 1; /* Is PAN Coord. accepting GTS reqs. */
uint32_t promisc : 1; /* Is promiscuous mode on? */
uint32_t rngsupport : 1; /* Does MAC sublayer support ranging */
uint32_t sec_enabled : 1; /* Does MAC sublayer have security en. */
uint32_t timestamp_support : 1; /* Does MAC layer supports timestamping */
/* End of 8-bit bitfield */
/* Start of 32-bit bitfield */
/* The offset, measured is symbols, between the symbol boundary at which the
* MLME captures the timestamp of each transmitted and received frame, and
* the onset of the first symbol past the SFD, namely the first symbol of
* the frames [1] pg. 129.
*/
uint32_t sync_symboffset : 12;
uint32_t txctrl_activedur : 17; /* Duration for which tx is permitted to
* be active */
uint32_t txctrl_pausedur : 1; /* Duration after tx before another tx is
* permitted. 0=2000, 1= 10000 */
/* What type of device is this node acting as */
enum ieee802154_devmode_e devmode : 2;
/* End of 32-bit bitfield */
/* Start of 32-bit bitfield */
uint32_t beacon_txtime : 24; /* Time of last beacon transmit */
uint32_t minbe : 4; /* Min value of backoff exponent (BE) */
uint32_t maxbe : 4; /* Max value of backoff exponent (BE) */
/* End of 32-bit bitfield */
/* Start of 8-bit bitfield */
uint8_t bf_ind : 1; /* Ping-pong index for beacon frame */
uint8_t beaconupdate : 1; /* Does the beacon frame need to be updated */
uint8_t max_csmabackoffs : 3; /* Max num backoffs for CSMA algorithm
* before declaring ch access failure */
uint8_t maxretries : 3; /* Max # of retries allowed after tx fail */
/* End of 8-bit bitfield. */
/* Start of 8-bit bitfield */
uint8_t rxonidle : 1; /* Receiver on when idle? */
/* End of 8-bit bitfield. */
/* TODO: Add Security-related MAC PIB attributes */
};
/****************************************************************************
* Function Prototypes
****************************************************************************/
int mac802154_txdesc_alloc(FAR struct ieee802154_privmac_s *priv,
FAR struct ieee802154_txdesc_s **txdesc,
bool allow_interrupt);
void mac802154_setupindirect(FAR struct ieee802154_privmac_s *priv,
FAR struct ieee802154_txdesc_s *txdesc);
void mac802154_createdatareq(FAR struct ieee802154_privmac_s *priv,
FAR struct ieee802154_addr_s *coordaddr,
enum ieee802154_addrmode_e srcmode,
FAR struct ieee802154_txdesc_s *txdesc);
void mac802154_updatebeacon(FAR struct ieee802154_privmac_s *priv);
/****************************************************************************
* Helper Macros/Inline Functions
****************************************************************************/
#define mac802154_putpanid(iob, panid) \
do \
{ \
IEEE802154_PANIDCOPY(&iob->io_data[iob->io_len], panid); \
iob->io_len += IEEE802154_PANIDSIZE; \
} \
while(0)
#define mac802154_putsaddr(iob, saddr) \
do \
{ \
IEEE802154_SADDRCOPY(&iob->io_data[iob->io_len], saddr); \
iob->io_len += IEEE802154_SADDRSIZE; \
} \
while(0)
#define mac802154_puteaddr(iob, eaddr) \
do \
{ \
IEEE802154_EADDRCOPY(&iob->io_data[iob->io_len], eaddr); \
iob->io_len += IEEE802154_EADDRSIZE; \
} \
while(0)
#define mac802154_takepanid(iob, panid) \
do \
{ \
IEEE802154_PANIDCOPY(panid, &iob->io_data[iob->io_offset]); \
iob->io_offset += IEEE802154_PANIDSIZE; \
} \
while(0)
#define mac802154_takesaddr(iob, saddr) \
do \
{ \
IEEE802154_SADDRCOPY(saddr, &iob->io_data[iob->io_offset]); \
iob->io_offset += IEEE802154_SADDRSIZE; \
} \
while(0)
#define mac802154_takeeaddr(iob, eaddr) \
do \
{ \
IEEE802154_EADDRCOPY(eaddr, &iob->io_data[iob->io_offset]); \
iob->io_offset += IEEE802154_EADDRSIZE; \
} \
while(0)
/* General helper macros ****************************************************/
/* GET 16-bit data: source in network order, result in host order */
#define GETHOST16(ptr,index) \
((((uint16_t)((ptr)[(index) + 1])) << 8) | ((uint16_t)(((ptr)[index]))))
/* GET 16-bit data: source in network order, result in network order */
#define GETNET16(ptr,index) \
((((uint16_t)((ptr)[index])) << 8) | ((uint16_t)(((ptr)[(index) + 1]))))
/* PUT 16-bit data: source in host order, result in network order */
#define PUTHOST16(ptr,index,value) \
do \
{ \
(ptr)[index] = (uint16_t)(value) & 0xff; \
(ptr)[index + 1] = ((uint16_t)(value) >> 8) & 0xff; \
} \
while(0)
/* Set bit in 16-bit value: source in host order, result in network order. */
#define IEEE802154_SETBITS_U16(ptr,index,value) \
do \
{ \
(ptr)[index] |= (uint16_t)(value) & 0xff; \
(ptr)[index + 1] |= ((uint16_t)(value) >> 8) & 0xff; \
} \
while(0)
/* Helper macros for setting/receiving bits for frame control field */
#define IEEE802154_SETFTYPE(ptr, index, ftype) \
IEEE802154_SETBITS_U16(ptr, index, (ftype << IEEE802154_FRAMECTRL_SHIFT_FTYPE))
#define IEEE802154_SETACKREQ(ptr, index) \
IEEE802154_SETBITS_U16(ptr, index, IEEE802154_FRAMECTRL_ACKREQ)
#define IEEE802154_SETDADDRMODE(ptr, index, mode) \
IEEE802154_SETBITS_U16(ptr, index, (mode << IEEE802154_FRAMECTRL_SHIFT_DADDR))
#define IEEE802154_SETSADDRMODE(ptr, index, mode) \
IEEE802154_SETBITS_U16(ptr, index, (mode << IEEE802154_FRAMECTRL_SHIFT_SADDR))
#define IEEE802154_SETPANIDCOMP(ptr, index) \
IEEE802154_SETBITS_U16(ptr, index, IEEE802154_FRAMECTRL_PANIDCOMP)
#define IEEE802154_SETVERSION(ptr, index, version) \
IEEE802154_SETBITS_U16(ptr, index, (version << IEEE802154_FRAMECTRL_SHIFT_VERSION))
/* Helper macros for setting/receiving bits for superframe specification */
#define IEEE802154_SETBEACONORDER(ptr, index, val) \
IEEE802154_SETBITS_U16(ptr, index, (val << IEEE802154_SFSPEC_SHIFT_BEACONORDER))
#define IEEE802154_SETSFORDER(ptr, index, val) \
IEEE802154_SETBITS_U16(ptr, index, (val << IEEE802154_SFSPEC_SHIFT_SFORDER))
#define IEEE802154_SETFINCAPSLOT(ptr, index, val) \
IEEE802154_SETBITS_U16(ptr, index, (val << IEEE802154_SFSPEC_SHIFT_FINCAPSLOT))
#define IEEE802154_SETBLE(ptr, index) \
IEEE802154_SETBITS_U16(ptr, index, IEEE802154_SFSPEC_BLE)
#define IEEE802154_SETPANCOORD(ptr, index) \
IEEE802154_SETBITS_U16(ptr, index, IEEE802154_SFSPEC_PANCOORD)
#define IEEE802154_SETASSOCPERMIT(ptr, index) \
IEEE802154_SETBITS_U16(ptr, index, IEEE802154_SFSPEC_ASSOCPERMIT)
#define IEEE802154_GETBEACONORDER(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_BEACONORDER) >> \
IEEE802154_SFSPEC_SHIFT_BEACONORDER)
#define IEEE802154_GETSFORDER(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_SFORDER) >> \
IEEE802154_SFSPEC_SHIFT_SFORDER)
#define IEEE802154_GETFINCAPSLOT(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_FINCAPSLOT) >> \
IEEE802154_SFSPEC_SHIFT_FINCAPSLOT)
#define IEEE802154_GETBLE(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_BLE) >> \
IEEE802154_SFSPEC_SHIFT_BLE)
#define IEEE802154_GETPANCOORD(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_PANCOORD) >> \
IEEE802154_SFSPEC_SHIFT_PANCOORD)
#define IEEE802154_GETASSOCPERMIT(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_SFSPEC_ASSOCPERMIT) >> \
IEEE802154_SFSPEC_SHIFT_ASSOCPERMIT)
/* Helper macros for setting/receiving bits for GTS specification */
#define IEEE802154_GETGTSDESCCOUNT(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_GTSSPEC_DESCCOUNT) >> \
IEEE802154_GTSSPEC_SHIFT_DESCCOUNT)
#define IEEE802154_GETGTSPERMIT(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_GTSSPEC_PERMIT) >> \
IEEE802154_GTSSPEC_SHIFT_PERMIT)
/* Helper macros for setting/receiving bits for GTS Directions */
#define IEEE802154_GETGTSDIRMASK(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_GTSDIR_MASK) >> \
IEEE802154_GTSDIR_SHIFT_MASK)
/* Helper macros for setting/receiving bits for Pending Address Specification */
#define IEEE802154_GETNPENDSADDR(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_PENDADDR_NSADDR) >> \
IEEE802154_PENDADDR_SHIFT_NSADDR)
#define IEEE802154_GETNPENDEADDR(ptr, index) \
((GETHOST16(ptr, index) & IEEE802154_PENDADDR_NEADDR) >> \
IEEE802154_PENDADDR_SHIFT_NEADDR)
/* General helpers **********************************************************/
#define mac802154_givesem(s) sem_post(s)
static inline int mac802154_takesem(sem_t *sem, bool allowinterrupt)
{
int ret;
do
{
/* Take a count from the semaphore, possibly waiting */
ret = sem_wait(sem);
if (ret < 0)
{
/* EINTR is the only error that we expect */
DEBUGASSERT(get_errno() == EINTR);
if (allowinterrupt)
{
return -EINTR;
}
}
}
while (ret != OK);
return OK;
}
#define mac802154_unlock(dev) \
mac802154_givesem(&dev->exclsem); \
wlinfo("MAC unlocked\n");
#define mac802154_lock(dev, allowinterrupt) \
mac802154_lockpriv(dev, allowinterrupt, __FUNCTION__)
static inline int mac802154_lockpriv(FAR struct ieee802154_privmac_s *dev,
bool allowinterrupt, FAR const char *funcname)
{
int ret;
wlinfo("Locking MAC: %s\n", funcname);
ret = mac802154_takesem(&dev->exclsem, allowinterrupt);
if (ret < 0)
{
wlinfo("Failed to lock MAC\n");
}
else
{
wlinfo("MAC locked\n");
}
return ret;
}
static inline void mac802154_txdesc_free(FAR struct ieee802154_privmac_s *priv,
FAR struct ieee802154_txdesc_s *txdesc)
{
sq_addlast((FAR sq_entry_t *)txdesc, &priv->txdesc_queue);
mac802154_givesem(&priv->txdesc_sem);
}
ieee802154: Improves internal timer logic to handle work serially Before, the MAC timer used a watchdog to schedule work with the high priority worker queue. However, since everything in the MAC is supposed to be serialized through the use of the high priority work queue, but the timer uses a watchdog, there are some unintended consequences. To simplify, we now use the delayed work feature of the work queue.
2017-07-10 05:55:48 +02:00
/****************************************************************************
* Name: mac802154_symtoticks
*
* Description:
* Helper function for converting symbols to system clock ticks
*
* Assumptions:
* priv MAC struct is locked when calling.
*
****************************************************************************/
static inline uint32_t mac802154_symtoticks(FAR struct ieee802154_privmac_s *priv,
uint32_t symbols)
{
union ieee802154_attr_u attrval;
uint32_t ret;
/* First, get the symbol duration from the radio layer. Symbol duration is
* returned in picoseconds to ensure precision is kept when multiplying to
* get overall times.
*/
priv->radio->getattr(priv->radio, IEEE802154_ATTR_PHY_SYMBOL_DURATION,
&attrval);
/* After this step, ret represents microseconds */
ret = ((uint64_t)attrval.phy.symdur_picosec * symbols) / (1000 * 1000);
/* This method should only be used for things that can be late. For instance,
* it's always okay to wait a little longer before disabling your receiver.
* Therefore, we force the tick count to round up.
*/
if (ret % USEC_PER_TICK == 0)
{
ret = ret/USEC_PER_TICK;
}
else
{
ret = ret/USEC_PER_TICK;
ret++;
}
return ret;
}
/****************************************************************************
* Name: mac802154_timerstart
*
* Description:
* Helper function wrapping the watchdog timer interface. Helps isolate
* different operations from having to worry about work queues and watchdog
* timers.
*
* Assumptions:
* priv MAC struct is locked when calling.
*
****************************************************************************/
static inline void mac802154_timerstart(FAR struct ieee802154_privmac_s *priv,
uint32_t numsymbols, worker_t worker)
{
DEBUGASSERT(work_available(&priv->timer_work));
/* Schedule the work, converting the number of symbols to the number of CPU ticks */
work_queue(MAC802154_WORK, &priv->timer_work, worker, priv,
mac802154_symtoticks(priv, numsymbols));
}
Remove carriage return endings and dangling white space at the end of lines
2017-07-10 00:53:08 +02:00
/****************************************************************************
* Name: mac802154_timercancel
*
* Description:
* Cancel timer and remove reference to callback function
*
* Assumptions:
* priv MAC struct is locked when calling.
*
****************************************************************************/
static inline int mac802154_timercancel(FAR struct ieee802154_privmac_s *priv)
{
ieee802154: Improves internal timer logic to handle work serially Before, the MAC timer used a watchdog to schedule work with the high priority worker queue. However, since everything in the MAC is supposed to be serialized through the use of the high priority work queue, but the timer uses a watchdog, there are some unintended consequences. To simplify, we now use the delayed work feature of the work queue.
2017-07-10 05:55:48 +02:00
work_cancel(MAC802154_WORK, &priv->timer_work);
Remove carriage return endings and dangling white space at the end of lines
2017-07-10 00:53:08 +02:00
wlinfo("Timer cancelled\n");
return OK;
}
static inline void mac802154_rxenable(FAR struct ieee802154_privmac_s *priv)
{
priv->nrxusers++;
/* If this is the first user, actually enable the receiver */
if (priv->nrxusers == 1)
{
wlinfo("Receiver enabled\n");
priv->radio->rxenable(priv->radio, true);
}
}
static inline void mac802154_rxdisable(FAR struct ieee802154_privmac_s *priv)
{
priv->nrxusers--;
/* If this is the first user, actually enable the receiver */
if (priv->nrxusers == 0)
{
wlinfo("Receiver disabled\n");
priv->radio->rxenable(priv->radio, true);
priv->radio->rxenable(priv->radio, false);
}
}
static inline void mac802154_setchannel(FAR struct ieee802154_privmac_s *priv,
uint8_t channel)
{
priv->radio->setattr(priv->radio, IEEE802154_ATTR_PHY_CHAN,
(FAR const union ieee802154_attr_u *)&channel);
}
static inline void mac802154_setchpage(FAR struct ieee802154_privmac_s *priv,
uint8_t chpage)
{
priv->radio->setattr(priv->radio, IEEE802154_ATTR_PHY_CURRENT_PAGE,
(FAR const union ieee802154_attr_u *)&chpage);
}
static inline void mac802154_setpanid(FAR struct ieee802154_privmac_s *priv,
const uint8_t *panid)
{
IEEE802154_PANIDCOPY(priv->addr.panid, panid);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_PANID,
(FAR const union ieee802154_attr_u *)panid);
}
static inline void mac802154_setsaddr(FAR struct ieee802154_privmac_s *priv,
const uint8_t *saddr)
{
IEEE802154_SADDRCOPY(priv->addr.saddr, saddr);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_SADDR,
(FAR const union ieee802154_attr_u *)saddr);
}
static inline void mac802154_seteaddr(FAR struct ieee802154_privmac_s *priv,
const uint8_t *eaddr)
{
IEEE802154_EADDRCOPY(priv->addr.eaddr, eaddr);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_EADDR,
(FAR const union ieee802154_attr_u *)eaddr);
}
static inline void mac802154_setcoordsaddr(FAR struct ieee802154_privmac_s *priv,
const uint8_t *saddr)
{
IEEE802154_SADDRCOPY(priv->pandesc.coordaddr.saddr, saddr);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_COORD_SADDR,
(FAR const union ieee802154_attr_u *)saddr);
}
static inline void mac802154_setcoordeaddr(FAR struct ieee802154_privmac_s *priv,
const uint8_t *eaddr)
{
IEEE802154_EADDRCOPY(priv->pandesc.coordaddr.eaddr, eaddr);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_COORD_EADDR,
(FAR const union ieee802154_attr_u *)eaddr);
}
static inline void mac802154_setcoordaddr(FAR struct ieee802154_privmac_s *priv,
FAR const struct ieee802154_addr_s *addr)
{
memcpy(&priv->pandesc.coordaddr, addr, sizeof(struct ieee802154_addr_s));
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_COORD_EADDR,
(FAR const union ieee802154_attr_u *)addr->eaddr);
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_COORD_SADDR,
(FAR const union ieee802154_attr_u *)addr->saddr);
}
static inline void mac802154_setrxonidle(FAR struct ieee802154_privmac_s *priv,
bool rxonidle)
{
priv->rxonidle = true;
if (priv->rxonidle)
{
mac802154_rxenable(priv);
}
else
{
mac802154_rxdisable(priv);
}
/* Unlike other attributes, we can't simply cast this one since it is a bit
* in a bitfield. Casting it will give us unpredicatble results. Instead
* of creating a ieee802154_attr_u, we use a local bool. Allocating the
* ieee802154_attr_u value would take up more room on the stack since it is
* as large as the largest attribute type.
*/
priv->radio->setattr(priv->radio, IEEE802154_ATTR_MAC_RX_ON_WHEN_IDLE,
(FAR const union ieee802154_attr_u *)&rxonidle);
}
#endif /* __WIRELESS_IEEE802154__MAC802154_INTERNAL_H */
Reference in New Issue Copy Permalink