/*
   * Copyright (C) 2014 INRIA
   * Copyright (C) 2015-2016 Freie Universität Berlin
   *
   * This file is subject to the terms and conditions of the GNU Lesser
   * General Public License v2.1. See the file LICENSE in the top level
   * directory for more details.
   */
  
  /**
   * @ingroup     drivers_xbee
   * @{
   *
   * @file
   * @brief       High-level driver implementation for the XBee S1 802.15.4 modem
   *
   * @author      Kévin Roussel <kevin.roussel@inria.fr>
   * @author      Hauke Petersen <hauke.petersen@fu-berlin.de>
   *
   * @}
   */
  
  #include <string.h>
  #include <errno.h>
  
  #include "xbee.h"
  #include "assert.h"
  #include "xtimer.h"
  #include "net/eui64.h"
  #include "net/netdev.h"
  #include "net/ieee802154.h"
  #ifdef MODULE_GNRC
  #include "net/gnrc.h"
  #endif
  
  #define ENABLE_DEBUG    (0)
  #include "debug.h"
  
  /**
   * @brief   Internal driver event type when RX is finished
   */
  #define ISR_EVENT_RX_DONE           (0x0001)
  
  /**
   * @brief   Delay when entering command mode, must be > 1s
   */
  #define ENTER_CMD_MODE_DELAY        (1100UL * US_PER_MS)
  /**
   * @brief   Delay when resetting the device, 10ms
   */
  #define RESET_DELAY                 (10UL * US_PER_MS)
  
  /**
   * @brief   Timeout for receiving AT command response
   */
  #define RESP_TIMEOUT_USEC           (US_PER_SEC)
  
  /**
   * @brief   Start delimiter in API frame mode
   */
  #define API_START_DELIMITER         (0x7e)
  
  /**
   * @brief   Command IDs when communicating in API frame mode
   * @{
   */
  #define API_ID_MODEM_STATUS         (0x8a)  /**< modem status frame */
  #define API_ID_AT                   (0x08)  /**< AT command request frame */
  #define API_ID_AT_QUEUE             (0x09)  /**< queued AT command frame */
  #define API_ID_AT_RESP              (0x88)  /**< AT command response frame */
  #define API_ID_TX_LONG_ADDR         (0x00)  /**< TX frame (long address) */
  #define API_ID_TX_SHORT_ADDR        (0x01)  /**< TX frame (short address) */
  #define API_ID_TX_RESP              (0x89)  /**< TX response frame */
  #define API_ID_RX_LONG_ADDR         (0x80)  /**< RX frame (long address) */
  #define API_ID_RX_SHORT_ADDR        (0x81)  /**< RX frame (short address) */
  /** @} */
  
  /**
   * @brief   Internal option flags (to be expanded if needed)
   * @{
   */
  #define OPT_DIS_AUTO_ACK            (0x01)  /**< disable sending of auto ACKs */
  #define OPT_BCAST_ADDR              (0x02)  /**< address broadcast */
  #define OPT_BCAST_PAN               (0x04)  /**< PAN broadcast */
  /** @} */
  
  /**
   * @brief   Data-structure describing AT command response frames
   */
  typedef struct {
      uint8_t status;         /**< AT command response status, 0 for success */
      uint8_t data[8];        /**< returned data from the AT command */
      uint8_t data_len;       /**< number ob bytes written to @p data */
  } resp_t;
  
  
  /*
   * Driver's internal utility functions
   */
  static uint8_t _cksum(size_t offset, uint8_t *buf, size_t size)
  {
      uint8_t res = 0xff;
      for (size_t i = offset; i < size; i++) {
          res -= buf[i];
      }
      return res;
  }
  
  static void _at_cmd(xbee_t *dev, const char *cmd)
  {
      DEBUG("[xbee] AT_CMD: %s\n", cmd);
  
      uart_write(dev->p.uart, (uint8_t *)cmd, strlen(cmd));
  }
  
  static void isr_resp_timeout(void *arg)
  {
      xbee_t *dev = (xbee_t *)arg;
  
      if (mutex_trylock(&(dev->resp_lock)) == 0) {
          dev->int_state = XBEE_INT_STATE_IDLE;
      }
  
      mutex_unlock(&(dev->resp_lock));
  }
  
  static void _api_at_cmd(xbee_t *dev, uint8_t *cmd, uint8_t size, resp_t *resp)
  {
      DEBUG("[xbee] AT_CMD: %s\n", cmd);
  
      /* acquire TX lock */
      mutex_lock(&(dev->tx_lock));
      /* construct API frame */
      dev->cmd_buf[0] = API_START_DELIMITER;
      dev->cmd_buf[1] = (size + 2) >> 8;
      dev->cmd_buf[2] = (size + 2) & 0xff;
      dev->cmd_buf[3] = API_ID_AT;
      dev->cmd_buf[4] = 1;             /* use fixed frame id */
      memcpy(dev->cmd_buf + 5, cmd, size);
      dev->cmd_buf[size + 5] = _cksum(3, dev->cmd_buf, size + 5);
  
      /* reset the response data counter */
      dev->resp_count = 0;
      /* start send data */
      uart_write(dev->p.uart, dev->cmd_buf, size + 6);
  
      xtimer_ticks64_t sent_time = xtimer_now64();
  
      xtimer_t resp_timer;
  
      resp_timer.callback = isr_resp_timeout;
      resp_timer.arg = dev;
  
      xtimer_set(&resp_timer, RESP_TIMEOUT_USEC);
  
      /* wait for results */
      while ((dev->resp_limit != dev->resp_count) &&
             (xtimer_less(
                  xtimer_diff32_64(xtimer_now64(), sent_time),
                  xtimer_ticks_from_usec(RESP_TIMEOUT_USEC)))) {
          mutex_lock(&(dev->resp_lock));
      }
  
      xtimer_remove(&resp_timer);
  
      if (dev->resp_limit != dev->resp_count) {
          DEBUG("[xbee] api_at_cmd: response timeout\n");
          resp->status = 255;
          mutex_unlock(&(dev->tx_lock));
  
          return;
      }
  
      /* populate response data structure */
      resp->status = dev->resp_buf[3];
      resp->data_len = dev->resp_limit - 5;
      if (resp->data_len > 0) {
          memcpy(resp->data, &(dev->resp_buf[4]), resp->data_len);
      }
      mutex_unlock(&(dev->tx_lock));
  }
  
  /*
   * Interrupt callbacks
   */
  static void _rx_cb(void *arg, uint8_t c)
  {
      xbee_t *dev = (xbee_t *)arg;
  
      switch (dev->int_state) {
          case XBEE_INT_STATE_IDLE:
              /* check for beginning of new data frame */
              if (c == API_START_DELIMITER) {
                  dev->int_state = XBEE_INT_STATE_SIZE1;
              }
              break;
          case XBEE_INT_STATE_SIZE1:
              dev->int_size = ((uint16_t)c) << 8;
              dev->int_state = XBEE_INT_STATE_SIZE2;
              break;
          case XBEE_INT_STATE_SIZE2:
              dev->int_size += c;
              dev->int_state = XBEE_INT_STATE_TYPE;
              break;
          case XBEE_INT_STATE_TYPE:
              if (c == API_ID_RX_SHORT_ADDR || c == API_ID_RX_LONG_ADDR) {
                  /* in case old data was not processed, ignore incoming data */
                  if (dev->rx_count != 0) {
                      dev->int_state = XBEE_INT_STATE_IDLE;
                      return;
                  }
                  dev->rx_limit = dev->int_size + 1;
                  dev->rx_buf[dev->rx_count++] = c;
                  dev->int_state = XBEE_INT_STATE_RX;
              }
              else if (c == API_ID_AT_RESP) {
                  dev->resp_limit = dev->int_size;
                  dev->int_state = XBEE_INT_STATE_RESP;
              }
              else {
                  dev->int_state = XBEE_INT_STATE_IDLE;
              }
              break;
          case XBEE_INT_STATE_RESP:
              dev->resp_buf[dev->resp_count++] = c;
              if (dev->resp_count == dev->resp_limit) {
                  /* here we ignore the checksum to prevent deadlocks */
                  mutex_unlock(&(dev->resp_lock));
                  dev->int_state = XBEE_INT_STATE_IDLE;
              }
              break;
          case XBEE_INT_STATE_RX:
              dev->rx_buf[dev->rx_count++] = c;
              if (dev->rx_count == dev->rx_limit) {
                  /* packet is complete */
                  if (dev->event_callback) {
                      dev->event_callback((netdev_t *)dev, NETDEV_EVENT_ISR);
                  }
                  dev->int_state = XBEE_INT_STATE_IDLE;
              }
              break;
          default:
              /* this should never be the case */
              break;
      }
  }
  
  /*
   * Getter and setter functions
   */
  static int _get_addr_long(xbee_t *dev, uint8_t *val, size_t len)
  {
      uint8_t cmd[2];
      resp_t resp;
  
      if (len < IEEE802154_LONG_ADDRESS_LEN) {
          return -EOVERFLOW;
      }
  
      /* read 4 high byte - AT command: SH*/
      cmd[0] = 'S';
      cmd[1] = 'H';
      _api_at_cmd(dev, cmd, 2, &resp);
      if (resp.status == 0) {
          memcpy(val, resp.data, 4);
      }
      else {
          return -ECANCELED;
      }
      /* read next 4 byte - AT command: SL */
      cmd[1] = 'L';
      _api_at_cmd(dev, cmd, 2, &resp);
      if (resp.status == 0) {
          memcpy(val + 4, resp.data, 4);
          return IEEE802154_LONG_ADDRESS_LEN;
      }
      return -ECANCELED;
  }
  
  static int _set_short_addr(xbee_t *dev, const uint8_t *address)
  {
      uint8_t cmd[4];
      resp_t resp;
  
      cmd[0] = 'M';
      cmd[1] = 'Y';
      cmd[2] = address[0];
      cmd[3] = address[1];
      _api_at_cmd(dev, cmd, 4, &resp);
  
      return resp.status;
  }
  
  static int _set_addr(xbee_t *dev, const uint8_t *val, size_t len)
  {
      uint8_t addr[2];
  
      /* device only supports setting the short address */
      if (len != 2) {
          return -ENOTSUP;
      }
  
      addr[0] = val[0];
      addr[1] = val[1];
  
  #ifdef MODULE_SIXLOWPAN
      /* https://tools.ietf.org/html/rfc4944#section-12 requires the first bit
       * to 0 for unicast addresses */
      addr[1] &= 0x7F;
  #endif
  
      if (dev->addr_flags & XBEE_ADDR_FLAGS_LONG ||
          _set_short_addr(dev, addr) == 0) {
  
          memcpy(dev->addr_short, addr, 2);
  
          return 2;
      }
  
      return -ECANCELED;
  }
  
  static int _set_addr_len(xbee_t *dev, const uint16_t *val, size_t len)
  {
      if (len != sizeof(uint16_t)) {
          return -EOVERFLOW;
      }
  
      switch (*val) {
          case IEEE802154_LONG_ADDRESS_LEN:
              dev->addr_flags |= XBEE_ADDR_FLAGS_LONG;
  
              /* disable short address */
              uint8_t disabled_addr[] = { 0xFF, 0xFF };
  
              _set_short_addr(dev, disabled_addr);
  
              break;
          case IEEE802154_SHORT_ADDRESS_LEN:
              dev->addr_flags &= ~XBEE_ADDR_FLAGS_LONG;
  
              /* restore short address */
              _set_short_addr(dev, dev->addr_short);
  
              break;
          default:
              return -EINVAL;
      }
  
      return sizeof(uint16_t);
  }
  
  static int _get_channel(xbee_t *dev, uint8_t *val, size_t max)
  {
      uint8_t cmd[2];
      resp_t resp;
  
      if (max < 2) {
          return -EOVERFLOW;
      }
      cmd[0] = 'C';
      cmd[1] = 'H';
      _api_at_cmd(dev, cmd, 2, &resp);
      if (resp.status == 0) {
          val[0] = resp.data[0];
          val[1] = 0;
          return 2;
      }
      return -ECANCELED;
  }
  
  static int _set_channel(xbee_t *dev, const uint8_t *val, size_t len)
  {
      uint8_t cmd[3];
      resp_t resp;
  
      if (len != 2 || val[1] != 0) {
          return -EINVAL;
      }
      cmd[0] = 'C';
      cmd[1] = 'H';
      cmd[2] = val[0];
      _api_at_cmd(dev, cmd, 3, &resp);
      if (resp.status == 0) {
          return 2;
      }
      return -EINVAL;
  }
  
  static int _get_panid(xbee_t *dev, uint8_t *val, size_t max)
  {
      uint8_t cmd[2];
      resp_t resp;
  
      if (max < 2) {
          return -EOVERFLOW;
      }
      cmd[0] = 'I';
      cmd[1] = 'D';
      _api_at_cmd(dev, cmd, 2, &resp);
      if (resp.status == 0) {
          val[0] = resp.data[1];
          val[1] = resp.data[0];
          return 2;
      }
      return -ECANCELED;
  }
  
  static int _set_panid(xbee_t *dev, const uint8_t *val, size_t len)
  {
      uint8_t cmd[4];
      resp_t resp;
  
      if (len != 2) {
          return -EINVAL;
      }
      cmd[0] = 'I';
      cmd[1] = 'D';
      cmd[2] = val[1];
      cmd[3] = val[0];
      _api_at_cmd(dev, cmd, 4, &resp);
      if (resp.status == 0) {
          return 2;
      }
      return -EINVAL;
  }
  
  #ifdef MODULE_XBEE_ENCRYPTION
  static int _set_encryption(xbee_t *dev, const uint8_t *val)
  {
      uint8_t cmd[3];
      resp_t resp;
      /* get the current state of Encryption */
      cmd[0] = 'E';
      cmd[1] = 'E';
      _api_at_cmd(dev, cmd, 2, &resp);
  
      /* Prevent writing the same value in EE. */
      if (val[0] != resp.data[0] ){
          cmd[0] = 'E';
          cmd[1] = 'E';
          cmd[2] = val[0];
          _api_at_cmd(dev, cmd, 3, &resp);
      }
      if (resp.status == 0) {
          return 2;
      }
      return -ECANCELED;
  }
  
  static int _set_encryption_key(xbee_t *dev, const uint8_t *val, size_t len)
  {
          uint8_t cmd[18];
          resp_t resp;
          if (len != 16) { /* the AES key is 128bit, 16 byte */
              return  -EINVAL;
          }
          cmd[0] = 'K';
          cmd[1] = 'Y';
  
         for (int i = 0; i < 16; i++) { /* Append the key to the KY API AT command */
             cmd[i + 2] = val[i];
         }
          _api_at_cmd(dev, cmd, 18, &resp);
          if (resp.status == 0) {
              return 2;
          }
          return -ECANCELED;
  }
  #endif
  
  /*
   * Driver's "public" functions
   */
  
  void xbee_setup(xbee_t *dev, const xbee_params_t *params)
  {
      assert(dev && (params->uart < UART_NUMOF));
  
      /* set device driver */
      dev->driver = &xbee_driver;
      dev->event_callback = NULL;
      dev->context = dev;
  
      /* set peripherals to use */
      memcpy(&dev->p, params, sizeof(xbee_params_t));
  
      /* initialize pins */
      if (dev->p.pin_reset != GPIO_UNDEF) {
          gpio_init(dev->p.pin_reset, GPIO_OUT);
          gpio_set(dev->p.pin_reset);
      }
      if (dev->p.pin_sleep != GPIO_UNDEF) {
          gpio_init(dev->p.pin_sleep, GPIO_OUT);
          gpio_clear(dev->p.pin_sleep);
      }
      /* we initialize the UART later, since we can not handle interrupts, yet */
  }
  
  int xbee_build_hdr(xbee_t *dev, uint8_t *xhdr, size_t payload_len,
                     void *dst_addr, size_t addr_len)
  {
      /* make sure payload fits into a packet */
      if (payload_len > XBEE_MAX_PAYLOAD_LENGTH) {
          return -EOVERFLOW;
      }
  
      /* set start delimiter, configure address and set options. Also make sure,
       * that the link layer address is of known length */
      xhdr[0] = API_START_DELIMITER;
      xhdr[4] = dev->tx_fid++;
      if (addr_len == IEEE802154_SHORT_ADDRESS_LEN) {
          xhdr[3] = API_ID_TX_SHORT_ADDR;
          xhdr[7] = dev->options;
      }
      else if (addr_len == IEEE802154_LONG_ADDRESS_LEN) {
          xhdr[3] = API_ID_TX_LONG_ADDR;
          xhdr[13] = dev->options;
      }
      else {
          return -ENOMSG;
      }
  
      /* finally configure the packet size and copy the actual dst address */
      uint16_t size = (uint16_t)(payload_len + addr_len + 3);
      xhdr[1] = (uint8_t)(size >> 8);
      xhdr[2] = (uint8_t)(size & 0xff);
      memcpy(&xhdr[5], dst_addr, addr_len);
  
      return (int)(addr_len + 6);
  }
  
  int xbee_parse_hdr(xbee_t *dev, const uint8_t *xhdr, xbee_l2hdr_t *l2hdr)
  {
      uint8_t alen;
  
      assert(xhdr && l2hdr);
  
      /* get the address length */
      if (xhdr[0] == API_ID_RX_SHORT_ADDR) {
          alen = IEEE802154_SHORT_ADDRESS_LEN;
      }
      else if (xhdr[0] == API_ID_RX_LONG_ADDR) {
          alen = IEEE802154_LONG_ADDRESS_LEN;
      }
      else {
          return -ENOMSG;
      }
  
      /* copy the actual SRC address and the RSSI value */
      memcpy(l2hdr->src_addr, &xhdr[1], alen);
      l2hdr->rssi = xhdr[1 + alen];
  
      /* copy the destination address */
      l2hdr->bcast = (xhdr[2 + alen] & OPT_BCAST_ADDR) ? 1 : 0;
      if (l2hdr->bcast) {
          memset(l2hdr->dst_addr, 0xff, alen);
      }
      else {
          if (alen == IEEE802154_SHORT_ADDRESS_LEN) {
              memcpy(l2hdr->dst_addr, dev->addr_short, alen);
          }
          else {
              memcpy(l2hdr->dst_addr, dev->addr_long.uint8, alen);
          }
      }
      l2hdr->addr_len = alen;
  
      return (int)(alen + 3);
  }
  
  int xbee_init(netdev_t *dev)
  {
      uint8_t tmp[2];
      xbee_t *xbee = (xbee_t *)dev;
  
      /* set default options */
      xbee->addr_flags = XBEE_ADDR_FLAGS_LONG;
      xbee->options = 0;
      /* initialize buffers and locks*/
      mutex_init(&(xbee->tx_lock));
      mutex_init(&(xbee->resp_lock));
      xbee->resp_limit = 1;    /* needs to be greater then 0 initially */
      xbee->rx_count = 0;
      /* initialize UART and GPIO pins */
      if (uart_init(xbee->p.uart, xbee->p.br, _rx_cb, xbee) != UART_OK) {
          DEBUG("[xbee] init: error initializing UART\n");
          return -ENXIO;
      }
      /* if reset pin is connected, do a hardware reset */
      if (xbee->p.pin_reset != GPIO_UNDEF) {
          gpio_clear(xbee->p.pin_reset);
          xtimer_usleep(RESET_DELAY);
          gpio_set(xbee->p.pin_reset);
      }
      /* put the XBee device into command mode */
      xtimer_usleep(ENTER_CMD_MODE_DELAY);
      _at_cmd(xbee, "+++");
      xtimer_usleep(ENTER_CMD_MODE_DELAY);
      /* disable non IEEE802.15.4 extensions */
      _at_cmd(xbee, "ATMM2\r");
      /* put XBee module in "API mode without escaped characters" */
      _at_cmd(xbee, "ATAP1\r");
      /* apply AT commands */
      _at_cmd(xbee, "ATAC\r");
      /* exit command mode */
      _at_cmd(xbee, "ATCN\r");
  
      /* load long address (we can not set it, its read only for Xbee devices) */
      if (_get_addr_long(xbee, xbee->addr_long.uint8, IEEE802154_LONG_ADDRESS_LEN) < 0) {
          DEBUG("[xbee] init: error getting address\n");
          return -EIO;
      }
      if (_set_addr(xbee, &((xbee->addr_long).uint8[6]), IEEE802154_SHORT_ADDRESS_LEN) < 0) {
          DEBUG("[xbee] init: error setting short address\n");
          return -EIO;
      }
      /* set default channel */
      tmp[1] = 0;
      tmp[0] = XBEE_DEFAULT_CHANNEL;
      if (_set_channel(xbee, tmp, 2) < 0) {
          DEBUG("[xbee] init: error setting channel\n");
          return -EIO;
      }
      /* set default PAN ID */
      tmp[1] = (uint8_t)(XBEE_DEFAULT_PANID >> 8);
      tmp[0] = (uint8_t)(XBEE_DEFAULT_PANID & 0xff);
      if (_set_panid(xbee, tmp, 2) < 0) {
          DEBUG("[xbee] init: error setting PAN ID\n");
          return -EIO;
      }
  
      DEBUG("[xbee] init: Initialization successful\n");
      return 0;
  }
  
  static int xbee_send(netdev_t *dev, const struct iovec *vector, unsigned count)
  {
      xbee_t *xbee = (xbee_t *)dev;
      size_t size;
      uint8_t csum;
  
      assert(xbee && vector && (count > 0));
  
      /* calculate the checksum and the packet size */
      size = vector[0].iov_len;
      csum = _cksum(3, (uint8_t *)vector[0].iov_base, size);
      for (unsigned i = 1; i < count; i++) {
          size += vector[i].iov_len;
          for (size_t p = 0; p < vector[i].iov_len; p++) {
              csum -= ((uint8_t *)vector[i].iov_base)[p];
          }
      }
  
      /* make sure the data fits into a packet */
      if (size >= XBEE_MAX_PKT_LENGTH) {
          DEBUG("[xbee] send: data to send is too large for TX buffer\n");
          return -1;
      }
  
      /* send the actual data packet */
      DEBUG("[xbee] send: now sending out %i byte\n", (int)size);
      mutex_lock(&(xbee->tx_lock));
      for (unsigned i = 0; i < count; i++) {
          uart_write(xbee->p.uart, vector[i].iov_base, vector[i].iov_len);
      }
      uart_write(xbee->p.uart, &csum, 1);
      mutex_unlock(&(xbee->tx_lock));
  
      /* return number of payload byte */
      return (int)size;
  }
  
  static int xbee_recv(netdev_t *dev, void *buf, size_t len, void *info)
  {
      (void)info;
      size_t size;
      xbee_t *xbee = (xbee_t *)dev;
  
      assert(xbee);
  
      /* make sure we have new data waiting */
      if (xbee->rx_count != xbee->rx_limit) {
          DEBUG("[xbee] recv: no data available for reading\n");
          return 0;
      }
  
      /* data available, so we read it (or it's size) */
      size = (size_t)(xbee->rx_limit - 1);
      if (buf == NULL) {
          if (len > 0) {
              DEBUG("[xbee] recv: reading size and dropping: %i\n", size);
              xbee->rx_count = 0;
          }
          else {
              DEBUG("[xbee] recv: reading size without dropping: %i\n", size);
          }
      }
      else {
          size = (size > len) ? len : size;
          DEBUG("[xbee] recv: consuming packet: reading %i byte\n", size);
          memcpy(buf, xbee->rx_buf, size);
          xbee->rx_count = 0;
      }
  
      return (int)size;
  }
  
  static void xbee_isr(netdev_t *netdev)
  {
      xbee_t *dev = (xbee_t *)netdev;
  
      if (dev->rx_count == dev->rx_limit) {
          /* make sure the checksum checks out */
          if (_cksum(0, dev->rx_buf, dev->rx_limit) != 0) {
              DEBUG("[xbee] isr: invalid RX checksum\n");
              dev->rx_count = 0;
          }
          else {
              DEBUG("[xbee] isr: data available, waiting for read\n");
              dev->event_callback(netdev, NETDEV_EVENT_RX_COMPLETE);
          }
      }
  }
  
  static int xbee_get(netdev_t *ndev, netopt_t opt, void *value, size_t max_len)
  {
      xbee_t *dev = (xbee_t *)ndev;
      assert(dev);
  
      switch (opt) {
          case NETOPT_ADDRESS:
              assert(max_len >= IEEE802154_SHORT_ADDRESS_LEN);
              memcpy(value, dev->addr_short, IEEE802154_SHORT_ADDRESS_LEN);
              return IEEE802154_SHORT_ADDRESS_LEN;
          case NETOPT_ADDRESS_LONG:
              assert(max_len >= IEEE802154_LONG_ADDRESS_LEN);
              memcpy(value, dev->addr_long.uint8, IEEE802154_LONG_ADDRESS_LEN);
              return IEEE802154_LONG_ADDRESS_LEN;
          case NETOPT_ADDR_LEN:
          case NETOPT_SRC_LEN:
              if (max_len < sizeof(uint16_t)) {
                  return -EOVERFLOW;
              }
              if (dev->addr_flags & XBEE_ADDR_FLAGS_LONG) {
                  *((uint16_t *)value) = IEEE802154_LONG_ADDRESS_LEN;
              }
              else {
                  *((uint16_t *)value) = IEEE802154_SHORT_ADDRESS_LEN;
              }
              return sizeof(uint16_t);
          case NETOPT_IPV6_IID:
              if (max_len < sizeof(eui64_t)) {
                  return -EOVERFLOW;
              }
              if (dev->addr_flags & XBEE_ADDR_FLAGS_LONG) {
                  ieee802154_get_iid(value, dev->addr_long.uint8,
                                     IEEE802154_LONG_ADDRESS_LEN);
              }
              else {
                  ieee802154_get_iid(value, dev->addr_short,
                                     IEEE802154_SHORT_ADDRESS_LEN);
              }
              return sizeof(eui64_t);
          case NETOPT_CHANNEL:
              return _get_channel(dev, (uint8_t *)value, max_len);
          case NETOPT_MAX_PACKET_SIZE:
              if (max_len < sizeof(uint16_t)) {
                  return -EOVERFLOW;
              }
              *((uint16_t *)value) = XBEE_MAX_PAYLOAD_LENGTH;
              return sizeof(uint16_t);
          case NETOPT_NID:
              return _get_panid(dev, (uint8_t *)value, max_len);
  #ifdef MODULE_GNRC
          case NETOPT_PROTO:
              if (max_len != sizeof(gnrc_nettype_t)) {
                  return -EOVERFLOW;
              }
              *((gnrc_nettype_t *)value) = XBEE_DEFAULT_PROTOCOL;
              return sizeof(gnrc_nettype_t);
  #endif
          default:
              return -ENOTSUP;
      }
  }
  
  static int xbee_set(netdev_t *ndev, netopt_t opt, const void *value, size_t len)
  {
      xbee_t *dev = (xbee_t *)ndev;
      assert(dev);
  
      switch (opt) {
          case NETOPT_ADDRESS:
              return _set_addr(dev, value, len);
          case NETOPT_ADDR_LEN:
          case NETOPT_SRC_LEN:
              return _set_addr_len(dev, value, len);
          case NETOPT_CHANNEL:
              return _set_channel(dev, value, len);
          case NETOPT_NID:
              return _set_panid(dev, value, len);
  #ifdef MODULE_XBEE_ENCRYPTION
          case NETOPT_ENCRYPTION:
              return _set_encryption(dev, value);
          case NETOPT_ENCRYPTION_KEY:
              return _set_encryption_key(dev, value, len);
  #endif
          default:
              return -ENOTSUP;
      }
  }
  
  /*
   * The drivers netdev interface
   */
  const netdev_driver_t xbee_driver = {
      .send = xbee_send,
      .recv = xbee_recv,
      .init = xbee_init,
      .isr  = xbee_isr,
      .get  = xbee_get,
      .set  = xbee_set,
  };