2 * AT86RF230/RF231 driver
4 * Copyright (C) 2009-2012 Siemens AG
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
17 * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
18 * Alexander Aring <aar@pengutronix.de>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/hrtimer.h>
23 #include <linux/jiffies.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/gpio.h>
27 #include <linux/delay.h>
28 #include <linux/spi/spi.h>
29 #include <linux/spi/at86rf230.h>
30 #include <linux/regmap.h>
31 #include <linux/skbuff.h>
32 #include <linux/of_gpio.h>
33 #include <linux/ieee802154.h>
34 #include <linux/debugfs.h>
36 #include <net/mac802154.h>
37 #include <net/cfg802154.h>
39 #include "at86rf230.h"
41 struct at86rf230_local;
42 /* at86rf2xx chip depend data.
43 * All timings are in us.
45 struct at86rf2xx_chip_data {
57 int (*set_channel)(struct at86rf230_local *, u8, u8);
58 int (*set_txpower)(struct at86rf230_local *, s32);
61 #define AT86RF2XX_MAX_BUF (127 + 3)
62 /* tx retries to access the TX_ON state
63 * if it's above then force change will be started.
65 * We assume the max_frame_retries (7) value of 802.15.4 here.
67 #define AT86RF2XX_MAX_TX_RETRIES 7
68 /* We use the recommended 5 minutes timeout to recalibrate */
69 #define AT86RF2XX_CAL_LOOP_TIMEOUT (5 * 60 * HZ)
71 struct at86rf230_state_change {
72 struct at86rf230_local *lp;
76 struct spi_message msg;
77 struct spi_transfer trx;
78 u8 buf[AT86RF2XX_MAX_BUF];
80 void (*complete)(void *context);
87 struct at86rf230_trac {
89 u64 success_data_pending;
90 u64 success_wait_for_ack;
91 u64 channel_access_failure;
96 struct at86rf230_local {
97 struct spi_device *spi;
99 struct ieee802154_hw *hw;
100 struct at86rf2xx_chip_data *data;
101 struct regmap *regmap;
105 struct completion state_complete;
106 struct at86rf230_state_change state;
108 unsigned long cal_timeout;
113 struct sk_buff *tx_skb;
114 struct at86rf230_state_change tx;
116 struct at86rf230_trac trac;
119 #define AT86RF2XX_NUMREGS 0x3F
122 at86rf230_async_state_change(struct at86rf230_local *lp,
123 struct at86rf230_state_change *ctx,
124 const u8 state, void (*complete)(void *context));
127 at86rf230_sleep(struct at86rf230_local *lp)
129 if (gpio_is_valid(lp->slp_tr)) {
130 gpio_set_value(lp->slp_tr, 1);
131 usleep_range(lp->data->t_off_to_sleep,
132 lp->data->t_off_to_sleep + 10);
138 at86rf230_awake(struct at86rf230_local *lp)
140 if (gpio_is_valid(lp->slp_tr)) {
141 gpio_set_value(lp->slp_tr, 0);
142 usleep_range(lp->data->t_sleep_to_off,
143 lp->data->t_sleep_to_off + 100);
149 __at86rf230_write(struct at86rf230_local *lp,
150 unsigned int addr, unsigned int data)
152 bool sleep = lp->sleep;
155 /* awake for register setting if sleep */
159 ret = regmap_write(lp->regmap, addr, data);
161 /* sleep again if was sleeping */
169 __at86rf230_read(struct at86rf230_local *lp,
170 unsigned int addr, unsigned int *data)
172 bool sleep = lp->sleep;
175 /* awake for register setting if sleep */
179 ret = regmap_read(lp->regmap, addr, data);
181 /* sleep again if was sleeping */
189 at86rf230_read_subreg(struct at86rf230_local *lp,
190 unsigned int addr, unsigned int mask,
191 unsigned int shift, unsigned int *data)
195 rc = __at86rf230_read(lp, addr, data);
197 *data = (*data & mask) >> shift;
203 at86rf230_write_subreg(struct at86rf230_local *lp,
204 unsigned int addr, unsigned int mask,
205 unsigned int shift, unsigned int data)
207 bool sleep = lp->sleep;
210 /* awake for register setting if sleep */
214 ret = regmap_update_bits(lp->regmap, addr, mask, data << shift);
216 /* sleep again if was sleeping */
224 at86rf230_slp_tr_rising_edge(struct at86rf230_local *lp)
226 gpio_set_value(lp->slp_tr, 1);
228 gpio_set_value(lp->slp_tr, 0);
232 at86rf230_reg_writeable(struct device *dev, unsigned int reg)
239 case RG_PHY_ED_LEVEL:
255 case RG_SHORT_ADDR_0:
256 case RG_SHORT_ADDR_1:
278 at86rf230_reg_readable(struct device *dev, unsigned int reg)
282 /* all writeable are also readable */
283 rc = at86rf230_reg_writeable(dev, reg);
303 at86rf230_reg_volatile(struct device *dev, unsigned int reg)
305 /* can be changed during runtime */
310 case RG_PHY_ED_LEVEL:
322 at86rf230_reg_precious(struct device *dev, unsigned int reg)
324 /* don't clear irq line on read */
333 static const struct regmap_config at86rf230_regmap_spi_config = {
336 .write_flag_mask = CMD_REG | CMD_WRITE,
337 .read_flag_mask = CMD_REG,
338 .cache_type = REGCACHE_RBTREE,
339 .max_register = AT86RF2XX_NUMREGS,
340 .writeable_reg = at86rf230_reg_writeable,
341 .readable_reg = at86rf230_reg_readable,
342 .volatile_reg = at86rf230_reg_volatile,
343 .precious_reg = at86rf230_reg_precious,
347 at86rf230_async_error_recover_complete(void *context)
349 struct at86rf230_state_change *ctx = context;
350 struct at86rf230_local *lp = ctx->lp;
357 dev_kfree_skb_any(lp->tx_skb);
358 ieee802154_wake_queue(lp->hw);
363 at86rf230_async_error_recover(void *context)
365 struct at86rf230_state_change *ctx = context;
366 struct at86rf230_local *lp = ctx->lp;
373 at86rf230_async_state_change(lp, ctx, STATE_RX_AACK_ON,
374 at86rf230_async_error_recover_complete);
378 at86rf230_async_error(struct at86rf230_local *lp,
379 struct at86rf230_state_change *ctx, int rc)
381 dev_err(&lp->spi->dev, "spi_async error %d\n", rc);
383 at86rf230_async_state_change(lp, ctx, STATE_FORCE_TRX_OFF,
384 at86rf230_async_error_recover);
387 /* Generic function to get some register value in async mode */
389 at86rf230_async_read_reg(struct at86rf230_local *lp, u8 reg,
390 struct at86rf230_state_change *ctx,
391 void (*complete)(void *context))
395 u8 *tx_buf = ctx->buf;
397 tx_buf[0] = (reg & CMD_REG_MASK) | CMD_REG;
398 ctx->msg.complete = complete;
399 rc = spi_async(lp->spi, &ctx->msg);
401 at86rf230_async_error(lp, ctx, rc);
405 at86rf230_async_write_reg(struct at86rf230_local *lp, u8 reg, u8 val,
406 struct at86rf230_state_change *ctx,
407 void (*complete)(void *context))
411 ctx->buf[0] = (reg & CMD_REG_MASK) | CMD_REG | CMD_WRITE;
413 ctx->msg.complete = complete;
414 rc = spi_async(lp->spi, &ctx->msg);
416 at86rf230_async_error(lp, ctx, rc);
420 at86rf230_async_state_assert(void *context)
422 struct at86rf230_state_change *ctx = context;
423 struct at86rf230_local *lp = ctx->lp;
424 const u8 *buf = ctx->buf;
425 const u8 trx_state = buf[1] & TRX_STATE_MASK;
427 /* Assert state change */
428 if (trx_state != ctx->to_state) {
429 /* Special handling if transceiver state is in
430 * STATE_BUSY_RX_AACK and a SHR was detected.
432 if (trx_state == STATE_BUSY_RX_AACK) {
433 /* Undocumented race condition. If we send a state
434 * change to STATE_RX_AACK_ON the transceiver could
435 * change his state automatically to STATE_BUSY_RX_AACK
436 * if a SHR was detected. This is not an error, but we
439 if (ctx->to_state == STATE_RX_AACK_ON)
442 /* If we change to STATE_TX_ON without forcing and
443 * transceiver state is STATE_BUSY_RX_AACK, we wait
444 * 'tFrame + tPAck' receiving time. In this time the
445 * PDU should be received. If the transceiver is still
446 * in STATE_BUSY_RX_AACK, we run a force state change
447 * to STATE_TX_ON. This is a timeout handling, if the
448 * transceiver stucks in STATE_BUSY_RX_AACK.
450 * Additional we do several retries to try to get into
451 * TX_ON state without forcing. If the retries are
452 * higher or equal than AT86RF2XX_MAX_TX_RETRIES we
453 * will do a force change.
455 if (ctx->to_state == STATE_TX_ON ||
456 ctx->to_state == STATE_TRX_OFF) {
457 u8 state = ctx->to_state;
459 if (lp->tx_retry >= AT86RF2XX_MAX_TX_RETRIES)
460 state = STATE_FORCE_TRX_OFF;
463 at86rf230_async_state_change(lp, ctx, state,
469 dev_warn(&lp->spi->dev, "unexcept state change from 0x%02x to 0x%02x. Actual state: 0x%02x\n",
470 ctx->from_state, ctx->to_state, trx_state);
475 ctx->complete(context);
478 static enum hrtimer_restart at86rf230_async_state_timer(struct hrtimer *timer)
480 struct at86rf230_state_change *ctx =
481 container_of(timer, struct at86rf230_state_change, timer);
482 struct at86rf230_local *lp = ctx->lp;
484 at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
485 at86rf230_async_state_assert);
487 return HRTIMER_NORESTART;
490 /* Do state change timing delay. */
492 at86rf230_async_state_delay(void *context)
494 struct at86rf230_state_change *ctx = context;
495 struct at86rf230_local *lp = ctx->lp;
496 struct at86rf2xx_chip_data *c = lp->data;
500 /* The force state changes are will show as normal states in the
501 * state status subregister. We change the to_state to the
502 * corresponding one and remember if it was a force change, this
503 * differs if we do a state change from STATE_BUSY_RX_AACK.
505 switch (ctx->to_state) {
506 case STATE_FORCE_TX_ON:
507 ctx->to_state = STATE_TX_ON;
510 case STATE_FORCE_TRX_OFF:
511 ctx->to_state = STATE_TRX_OFF;
518 switch (ctx->from_state) {
520 switch (ctx->to_state) {
521 case STATE_RX_AACK_ON:
522 tim = c->t_off_to_aack * NSEC_PER_USEC;
523 /* state change from TRX_OFF to RX_AACK_ON to do a
524 * calibration, we need to reset the timeout for the
527 lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
529 case STATE_TX_ARET_ON:
531 tim = c->t_off_to_tx_on * NSEC_PER_USEC;
532 /* state change from TRX_OFF to TX_ON or ARET_ON to do
533 * a calibration, we need to reset the timeout for the
536 lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
542 case STATE_BUSY_RX_AACK:
543 switch (ctx->to_state) {
546 /* Wait for worst case receiving time if we
547 * didn't make a force change from BUSY_RX_AACK
548 * to TX_ON or TRX_OFF.
551 tim = (c->t_frame + c->t_p_ack) * NSEC_PER_USEC;
559 /* Default value, means RESET state */
561 switch (ctx->to_state) {
563 tim = c->t_reset_to_off * NSEC_PER_USEC;
573 /* Default delay is 1us in the most cases */
575 at86rf230_async_state_timer(&ctx->timer);
579 hrtimer_start(&ctx->timer, tim, HRTIMER_MODE_REL);
583 at86rf230_async_state_change_start(void *context)
585 struct at86rf230_state_change *ctx = context;
586 struct at86rf230_local *lp = ctx->lp;
588 const u8 trx_state = buf[1] & TRX_STATE_MASK;
590 /* Check for "possible" STATE_TRANSITION_IN_PROGRESS */
591 if (trx_state == STATE_TRANSITION_IN_PROGRESS) {
593 at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
594 at86rf230_async_state_change_start);
598 /* Check if we already are in the state which we change in */
599 if (trx_state == ctx->to_state) {
601 ctx->complete(context);
605 /* Set current state to the context of state change */
606 ctx->from_state = trx_state;
608 /* Going into the next step for a state change which do a timing
611 at86rf230_async_write_reg(lp, RG_TRX_STATE, ctx->to_state, ctx,
612 at86rf230_async_state_delay);
616 at86rf230_async_state_change(struct at86rf230_local *lp,
617 struct at86rf230_state_change *ctx,
618 const u8 state, void (*complete)(void *context))
620 /* Initialization for the state change context */
621 ctx->to_state = state;
622 ctx->complete = complete;
623 at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
624 at86rf230_async_state_change_start);
628 at86rf230_sync_state_change_complete(void *context)
630 struct at86rf230_state_change *ctx = context;
631 struct at86rf230_local *lp = ctx->lp;
633 complete(&lp->state_complete);
636 /* This function do a sync framework above the async state change.
637 * Some callbacks of the IEEE 802.15.4 driver interface need to be
638 * handled synchronously.
641 at86rf230_sync_state_change(struct at86rf230_local *lp, unsigned int state)
645 at86rf230_async_state_change(lp, &lp->state, state,
646 at86rf230_sync_state_change_complete);
648 rc = wait_for_completion_timeout(&lp->state_complete,
649 msecs_to_jiffies(100));
651 at86rf230_async_error(lp, &lp->state, -ETIMEDOUT);
659 at86rf230_tx_complete(void *context)
661 struct at86rf230_state_change *ctx = context;
662 struct at86rf230_local *lp = ctx->lp;
664 ieee802154_xmit_complete(lp->hw, lp->tx_skb, false);
669 at86rf230_tx_on(void *context)
671 struct at86rf230_state_change *ctx = context;
672 struct at86rf230_local *lp = ctx->lp;
674 at86rf230_async_state_change(lp, ctx, STATE_RX_AACK_ON,
675 at86rf230_tx_complete);
679 at86rf230_tx_trac_check(void *context)
681 struct at86rf230_state_change *ctx = context;
682 struct at86rf230_local *lp = ctx->lp;
684 if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS)) {
685 u8 trac = TRAC_MASK(ctx->buf[1]);
691 case TRAC_SUCCESS_DATA_PENDING:
692 lp->trac.success_data_pending++;
694 case TRAC_CHANNEL_ACCESS_FAILURE:
695 lp->trac.channel_access_failure++;
704 WARN_ONCE(1, "received tx trac status %d\n", trac);
709 at86rf230_async_state_change(lp, ctx, STATE_TX_ON, at86rf230_tx_on);
713 at86rf230_rx_read_frame_complete(void *context)
715 struct at86rf230_state_change *ctx = context;
716 struct at86rf230_local *lp = ctx->lp;
717 const u8 *buf = ctx->buf;
722 if (!ieee802154_is_valid_psdu_len(len)) {
723 dev_vdbg(&lp->spi->dev, "corrupted frame received\n");
724 len = IEEE802154_MTU;
728 skb = dev_alloc_skb(IEEE802154_MTU);
730 dev_vdbg(&lp->spi->dev, "failed to allocate sk_buff\n");
735 skb_put_data(skb, buf + 2, len);
736 ieee802154_rx_irqsafe(lp->hw, skb, lqi);
741 at86rf230_rx_trac_check(void *context)
743 struct at86rf230_state_change *ctx = context;
744 struct at86rf230_local *lp = ctx->lp;
748 if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS)) {
749 u8 trac = TRAC_MASK(buf[1]);
755 case TRAC_SUCCESS_WAIT_FOR_ACK:
756 lp->trac.success_wait_for_ack++;
762 WARN_ONCE(1, "received rx trac status %d\n", trac);
768 ctx->trx.len = AT86RF2XX_MAX_BUF;
769 ctx->msg.complete = at86rf230_rx_read_frame_complete;
770 rc = spi_async(lp->spi, &ctx->msg);
773 at86rf230_async_error(lp, ctx, rc);
778 at86rf230_irq_trx_end(void *context)
780 struct at86rf230_state_change *ctx = context;
781 struct at86rf230_local *lp = ctx->lp;
785 at86rf230_async_read_reg(lp, RG_TRX_STATE, ctx,
786 at86rf230_tx_trac_check);
788 at86rf230_async_read_reg(lp, RG_TRX_STATE, ctx,
789 at86rf230_rx_trac_check);
794 at86rf230_irq_status(void *context)
796 struct at86rf230_state_change *ctx = context;
797 struct at86rf230_local *lp = ctx->lp;
798 const u8 *buf = ctx->buf;
801 enable_irq(lp->spi->irq);
803 if (irq & IRQ_TRX_END) {
804 at86rf230_irq_trx_end(ctx);
806 dev_err(&lp->spi->dev, "not supported irq %02x received\n",
813 at86rf230_setup_spi_messages(struct at86rf230_local *lp,
814 struct at86rf230_state_change *state)
817 state->irq = lp->spi->irq;
818 spi_message_init(&state->msg);
819 state->msg.context = state;
821 state->trx.tx_buf = state->buf;
822 state->trx.rx_buf = state->buf;
823 spi_message_add_tail(&state->trx, &state->msg);
824 hrtimer_init(&state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
825 state->timer.function = at86rf230_async_state_timer;
828 static irqreturn_t at86rf230_isr(int irq, void *data)
830 struct at86rf230_local *lp = data;
831 struct at86rf230_state_change *ctx;
834 disable_irq_nosync(irq);
836 ctx = kzalloc(sizeof(*ctx), GFP_ATOMIC);
842 at86rf230_setup_spi_messages(lp, ctx);
843 /* tell on error handling to free ctx */
846 ctx->buf[0] = (RG_IRQ_STATUS & CMD_REG_MASK) | CMD_REG;
847 ctx->msg.complete = at86rf230_irq_status;
848 rc = spi_async(lp->spi, &ctx->msg);
850 at86rf230_async_error(lp, ctx, rc);
859 at86rf230_write_frame_complete(void *context)
861 struct at86rf230_state_change *ctx = context;
862 struct at86rf230_local *lp = ctx->lp;
866 if (gpio_is_valid(lp->slp_tr))
867 at86rf230_slp_tr_rising_edge(lp);
869 at86rf230_async_write_reg(lp, RG_TRX_STATE, STATE_BUSY_TX, ctx,
874 at86rf230_write_frame(void *context)
876 struct at86rf230_state_change *ctx = context;
877 struct at86rf230_local *lp = ctx->lp;
878 struct sk_buff *skb = lp->tx_skb;
884 buf[0] = CMD_FB | CMD_WRITE;
885 buf[1] = skb->len + 2;
886 memcpy(buf + 2, skb->data, skb->len);
887 ctx->trx.len = skb->len + 2;
888 ctx->msg.complete = at86rf230_write_frame_complete;
889 rc = spi_async(lp->spi, &ctx->msg);
892 at86rf230_async_error(lp, ctx, rc);
897 at86rf230_xmit_tx_on(void *context)
899 struct at86rf230_state_change *ctx = context;
900 struct at86rf230_local *lp = ctx->lp;
902 at86rf230_async_state_change(lp, ctx, STATE_TX_ARET_ON,
903 at86rf230_write_frame);
907 at86rf230_xmit_start(void *context)
909 struct at86rf230_state_change *ctx = context;
910 struct at86rf230_local *lp = ctx->lp;
912 /* check if we change from off state */
913 if (lp->is_tx_from_off)
914 at86rf230_async_state_change(lp, ctx, STATE_TX_ARET_ON,
915 at86rf230_write_frame);
917 at86rf230_async_state_change(lp, ctx, STATE_TX_ON,
918 at86rf230_xmit_tx_on);
922 at86rf230_xmit(struct ieee802154_hw *hw, struct sk_buff *skb)
924 struct at86rf230_local *lp = hw->priv;
925 struct at86rf230_state_change *ctx = &lp->tx;
930 /* After 5 minutes in PLL and the same frequency we run again the
931 * calibration loops which is recommended by at86rf2xx datasheets.
933 * The calibration is initiate by a state change from TRX_OFF
934 * to TX_ON, the lp->cal_timeout should be reinit by state_delay
935 * function then to start in the next 5 minutes.
937 if (time_is_before_jiffies(lp->cal_timeout)) {
938 lp->is_tx_from_off = true;
939 at86rf230_async_state_change(lp, ctx, STATE_TRX_OFF,
940 at86rf230_xmit_start);
942 lp->is_tx_from_off = false;
943 at86rf230_xmit_start(ctx);
950 at86rf230_ed(struct ieee802154_hw *hw, u8 *level)
958 at86rf230_start(struct ieee802154_hw *hw)
960 struct at86rf230_local *lp = hw->priv;
962 /* reset trac stats on start */
963 if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS))
964 memset(&lp->trac, 0, sizeof(struct at86rf230_trac));
967 enable_irq(lp->spi->irq);
969 return at86rf230_sync_state_change(lp, STATE_RX_AACK_ON);
973 at86rf230_stop(struct ieee802154_hw *hw)
975 struct at86rf230_local *lp = hw->priv;
978 at86rf230_sync_state_change(lp, STATE_FORCE_TRX_OFF);
980 disable_irq(lp->spi->irq);
982 /* It's recommended to set random new csma_seeds before sleep state.
983 * Makes only sense in the stop callback, not doing this inside of
984 * at86rf230_sleep, this is also used when we don't transmit afterwards
985 * when calling start callback again.
987 get_random_bytes(csma_seed, ARRAY_SIZE(csma_seed));
988 at86rf230_write_subreg(lp, SR_CSMA_SEED_0, csma_seed[0]);
989 at86rf230_write_subreg(lp, SR_CSMA_SEED_1, csma_seed[1]);
995 at86rf23x_set_channel(struct at86rf230_local *lp, u8 page, u8 channel)
997 return at86rf230_write_subreg(lp, SR_CHANNEL, channel);
1000 #define AT86RF2XX_MAX_ED_LEVELS 0xF
1001 static const s32 at86rf233_ed_levels[AT86RF2XX_MAX_ED_LEVELS + 1] = {
1002 -9400, -9200, -9000, -8800, -8600, -8400, -8200, -8000, -7800, -7600,
1003 -7400, -7200, -7000, -6800, -6600, -6400,
1006 static const s32 at86rf231_ed_levels[AT86RF2XX_MAX_ED_LEVELS + 1] = {
1007 -9100, -8900, -8700, -8500, -8300, -8100, -7900, -7700, -7500, -7300,
1008 -7100, -6900, -6700, -6500, -6300, -6100,
1011 static const s32 at86rf212_ed_levels_100[AT86RF2XX_MAX_ED_LEVELS + 1] = {
1012 -10000, -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200,
1013 -8000, -7800, -7600, -7400, -7200, -7000,
1016 static const s32 at86rf212_ed_levels_98[AT86RF2XX_MAX_ED_LEVELS + 1] = {
1017 -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200, -8000,
1018 -7800, -7600, -7400, -7200, -7000, -6800,
1022 at86rf212_update_cca_ed_level(struct at86rf230_local *lp, int rssi_base_val)
1024 unsigned int cca_ed_thres;
1027 rc = at86rf230_read_subreg(lp, SR_CCA_ED_THRES, &cca_ed_thres);
1031 switch (rssi_base_val) {
1033 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_98;
1034 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_98);
1035 lp->hw->phy->cca_ed_level = at86rf212_ed_levels_98[cca_ed_thres];
1038 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100;
1039 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100);
1040 lp->hw->phy->cca_ed_level = at86rf212_ed_levels_100[cca_ed_thres];
1050 at86rf212_set_channel(struct at86rf230_local *lp, u8 page, u8 channel)
1055 rc = at86rf230_write_subreg(lp, SR_SUB_MODE, 0);
1057 rc = at86rf230_write_subreg(lp, SR_SUB_MODE, 1);
1062 rc = at86rf230_write_subreg(lp, SR_BPSK_QPSK, 0);
1063 lp->data->rssi_base_val = -100;
1065 rc = at86rf230_write_subreg(lp, SR_BPSK_QPSK, 1);
1066 lp->data->rssi_base_val = -98;
1071 rc = at86rf212_update_cca_ed_level(lp, lp->data->rssi_base_val);
1075 /* This sets the symbol_duration according frequency on the 212.
1076 * TODO move this handling while set channel and page in cfg802154.
1077 * We can do that, this timings are according 802.15.4 standard.
1078 * If we do that in cfg802154, this is a more generic calculation.
1080 * This should also protected from ifs_timer. Means cancel timer and
1081 * init with a new value. For now, this is okay.
1085 /* SUB:0 and BPSK:0 -> BPSK-20 */
1086 lp->hw->phy->symbol_duration = 50;
1088 /* SUB:1 and BPSK:0 -> BPSK-40 */
1089 lp->hw->phy->symbol_duration = 25;
1093 /* SUB:0 and BPSK:1 -> OQPSK-100/200/400 */
1094 lp->hw->phy->symbol_duration = 40;
1096 /* SUB:1 and BPSK:1 -> OQPSK-250/500/1000 */
1097 lp->hw->phy->symbol_duration = 16;
1100 lp->hw->phy->lifs_period = IEEE802154_LIFS_PERIOD *
1101 lp->hw->phy->symbol_duration;
1102 lp->hw->phy->sifs_period = IEEE802154_SIFS_PERIOD *
1103 lp->hw->phy->symbol_duration;
1105 return at86rf230_write_subreg(lp, SR_CHANNEL, channel);
1109 at86rf230_channel(struct ieee802154_hw *hw, u8 page, u8 channel)
1111 struct at86rf230_local *lp = hw->priv;
1114 rc = lp->data->set_channel(lp, page, channel);
1116 usleep_range(lp->data->t_channel_switch,
1117 lp->data->t_channel_switch + 10);
1119 lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
1124 at86rf230_set_hw_addr_filt(struct ieee802154_hw *hw,
1125 struct ieee802154_hw_addr_filt *filt,
1126 unsigned long changed)
1128 struct at86rf230_local *lp = hw->priv;
1130 if (changed & IEEE802154_AFILT_SADDR_CHANGED) {
1131 u16 addr = le16_to_cpu(filt->short_addr);
1133 dev_vdbg(&lp->spi->dev, "%s called for saddr\n", __func__);
1134 __at86rf230_write(lp, RG_SHORT_ADDR_0, addr);
1135 __at86rf230_write(lp, RG_SHORT_ADDR_1, addr >> 8);
1138 if (changed & IEEE802154_AFILT_PANID_CHANGED) {
1139 u16 pan = le16_to_cpu(filt->pan_id);
1141 dev_vdbg(&lp->spi->dev, "%s called for pan id\n", __func__);
1142 __at86rf230_write(lp, RG_PAN_ID_0, pan);
1143 __at86rf230_write(lp, RG_PAN_ID_1, pan >> 8);
1146 if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) {
1149 memcpy(addr, &filt->ieee_addr, 8);
1150 dev_vdbg(&lp->spi->dev, "%s called for IEEE addr\n", __func__);
1151 for (i = 0; i < 8; i++)
1152 __at86rf230_write(lp, RG_IEEE_ADDR_0 + i, addr[i]);
1155 if (changed & IEEE802154_AFILT_PANC_CHANGED) {
1156 dev_vdbg(&lp->spi->dev, "%s called for panc change\n", __func__);
1157 if (filt->pan_coord)
1158 at86rf230_write_subreg(lp, SR_AACK_I_AM_COORD, 1);
1160 at86rf230_write_subreg(lp, SR_AACK_I_AM_COORD, 0);
1166 #define AT86RF23X_MAX_TX_POWERS 0xF
1167 static const s32 at86rf233_powers[AT86RF23X_MAX_TX_POWERS + 1] = {
1168 400, 370, 340, 300, 250, 200, 100, 0, -100, -200, -300, -400, -600,
1172 static const s32 at86rf231_powers[AT86RF23X_MAX_TX_POWERS + 1] = {
1173 300, 280, 230, 180, 130, 70, 0, -100, -200, -300, -400, -500, -700,
1177 #define AT86RF212_MAX_TX_POWERS 0x1F
1178 static const s32 at86rf212_powers[AT86RF212_MAX_TX_POWERS + 1] = {
1179 500, 400, 300, 200, 100, 0, -100, -200, -300, -400, -500, -600, -700,
1180 -800, -900, -1000, -1100, -1200, -1300, -1400, -1500, -1600, -1700,
1181 -1800, -1900, -2000, -2100, -2200, -2300, -2400, -2500, -2600,
1185 at86rf23x_set_txpower(struct at86rf230_local *lp, s32 mbm)
1189 for (i = 0; i < lp->hw->phy->supported.tx_powers_size; i++) {
1190 if (lp->hw->phy->supported.tx_powers[i] == mbm)
1191 return at86rf230_write_subreg(lp, SR_TX_PWR_23X, i);
1198 at86rf212_set_txpower(struct at86rf230_local *lp, s32 mbm)
1202 for (i = 0; i < lp->hw->phy->supported.tx_powers_size; i++) {
1203 if (lp->hw->phy->supported.tx_powers[i] == mbm)
1204 return at86rf230_write_subreg(lp, SR_TX_PWR_212, i);
1211 at86rf230_set_txpower(struct ieee802154_hw *hw, s32 mbm)
1213 struct at86rf230_local *lp = hw->priv;
1215 return lp->data->set_txpower(lp, mbm);
1219 at86rf230_set_lbt(struct ieee802154_hw *hw, bool on)
1221 struct at86rf230_local *lp = hw->priv;
1223 return at86rf230_write_subreg(lp, SR_CSMA_LBT_MODE, on);
1227 at86rf230_set_cca_mode(struct ieee802154_hw *hw,
1228 const struct wpan_phy_cca *cca)
1230 struct at86rf230_local *lp = hw->priv;
1233 /* mapping 802.15.4 to driver spec */
1234 switch (cca->mode) {
1235 case NL802154_CCA_ENERGY:
1238 case NL802154_CCA_CARRIER:
1241 case NL802154_CCA_ENERGY_CARRIER:
1243 case NL802154_CCA_OPT_ENERGY_CARRIER_AND:
1246 case NL802154_CCA_OPT_ENERGY_CARRIER_OR:
1257 return at86rf230_write_subreg(lp, SR_CCA_MODE, val);
1261 at86rf230_set_cca_ed_level(struct ieee802154_hw *hw, s32 mbm)
1263 struct at86rf230_local *lp = hw->priv;
1266 for (i = 0; i < hw->phy->supported.cca_ed_levels_size; i++) {
1267 if (hw->phy->supported.cca_ed_levels[i] == mbm)
1268 return at86rf230_write_subreg(lp, SR_CCA_ED_THRES, i);
1275 at86rf230_set_csma_params(struct ieee802154_hw *hw, u8 min_be, u8 max_be,
1278 struct at86rf230_local *lp = hw->priv;
1281 rc = at86rf230_write_subreg(lp, SR_MIN_BE, min_be);
1285 rc = at86rf230_write_subreg(lp, SR_MAX_BE, max_be);
1289 return at86rf230_write_subreg(lp, SR_MAX_CSMA_RETRIES, retries);
1293 at86rf230_set_frame_retries(struct ieee802154_hw *hw, s8 retries)
1295 struct at86rf230_local *lp = hw->priv;
1297 return at86rf230_write_subreg(lp, SR_MAX_FRAME_RETRIES, retries);
1301 at86rf230_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on)
1303 struct at86rf230_local *lp = hw->priv;
1307 rc = at86rf230_write_subreg(lp, SR_AACK_DIS_ACK, 1);
1311 rc = at86rf230_write_subreg(lp, SR_AACK_PROM_MODE, 1);
1315 rc = at86rf230_write_subreg(lp, SR_AACK_PROM_MODE, 0);
1319 rc = at86rf230_write_subreg(lp, SR_AACK_DIS_ACK, 0);
1327 static const struct ieee802154_ops at86rf230_ops = {
1328 .owner = THIS_MODULE,
1329 .xmit_async = at86rf230_xmit,
1331 .set_channel = at86rf230_channel,
1332 .start = at86rf230_start,
1333 .stop = at86rf230_stop,
1334 .set_hw_addr_filt = at86rf230_set_hw_addr_filt,
1335 .set_txpower = at86rf230_set_txpower,
1336 .set_lbt = at86rf230_set_lbt,
1337 .set_cca_mode = at86rf230_set_cca_mode,
1338 .set_cca_ed_level = at86rf230_set_cca_ed_level,
1339 .set_csma_params = at86rf230_set_csma_params,
1340 .set_frame_retries = at86rf230_set_frame_retries,
1341 .set_promiscuous_mode = at86rf230_set_promiscuous_mode,
1344 static struct at86rf2xx_chip_data at86rf233_data = {
1345 .t_sleep_cycle = 330,
1346 .t_channel_switch = 11,
1347 .t_reset_to_off = 26,
1348 .t_off_to_aack = 80,
1349 .t_off_to_tx_on = 80,
1350 .t_off_to_sleep = 35,
1351 .t_sleep_to_off = 1000,
1354 .rssi_base_val = -94,
1355 .set_channel = at86rf23x_set_channel,
1356 .set_txpower = at86rf23x_set_txpower,
1359 static struct at86rf2xx_chip_data at86rf231_data = {
1360 .t_sleep_cycle = 330,
1361 .t_channel_switch = 24,
1362 .t_reset_to_off = 37,
1363 .t_off_to_aack = 110,
1364 .t_off_to_tx_on = 110,
1365 .t_off_to_sleep = 35,
1366 .t_sleep_to_off = 1000,
1369 .rssi_base_val = -91,
1370 .set_channel = at86rf23x_set_channel,
1371 .set_txpower = at86rf23x_set_txpower,
1374 static struct at86rf2xx_chip_data at86rf212_data = {
1375 .t_sleep_cycle = 330,
1376 .t_channel_switch = 11,
1377 .t_reset_to_off = 26,
1378 .t_off_to_aack = 200,
1379 .t_off_to_tx_on = 200,
1380 .t_off_to_sleep = 35,
1381 .t_sleep_to_off = 1000,
1384 .rssi_base_val = -100,
1385 .set_channel = at86rf212_set_channel,
1386 .set_txpower = at86rf212_set_txpower,
1389 static int at86rf230_hw_init(struct at86rf230_local *lp, u8 xtal_trim)
1391 int rc, irq_type, irq_pol = IRQ_ACTIVE_HIGH;
1395 rc = at86rf230_sync_state_change(lp, STATE_FORCE_TRX_OFF);
1399 irq_type = irq_get_trigger_type(lp->spi->irq);
1400 if (irq_type == IRQ_TYPE_EDGE_FALLING ||
1401 irq_type == IRQ_TYPE_LEVEL_LOW)
1402 irq_pol = IRQ_ACTIVE_LOW;
1404 rc = at86rf230_write_subreg(lp, SR_IRQ_POLARITY, irq_pol);
1408 rc = at86rf230_write_subreg(lp, SR_RX_SAFE_MODE, 1);
1412 rc = at86rf230_write_subreg(lp, SR_IRQ_MASK, IRQ_TRX_END);
1416 /* reset values differs in at86rf231 and at86rf233 */
1417 rc = at86rf230_write_subreg(lp, SR_IRQ_MASK_MODE, 0);
1421 get_random_bytes(csma_seed, ARRAY_SIZE(csma_seed));
1422 rc = at86rf230_write_subreg(lp, SR_CSMA_SEED_0, csma_seed[0]);
1425 rc = at86rf230_write_subreg(lp, SR_CSMA_SEED_1, csma_seed[1]);
1429 /* CLKM changes are applied immediately */
1430 rc = at86rf230_write_subreg(lp, SR_CLKM_SHA_SEL, 0x00);
1435 rc = at86rf230_write_subreg(lp, SR_CLKM_CTRL, 0x00);
1438 /* Wait the next SLEEP cycle */
1439 usleep_range(lp->data->t_sleep_cycle,
1440 lp->data->t_sleep_cycle + 100);
1442 /* xtal_trim value is calculated by:
1443 * CL = 0.5 * (CX + CTRIM + CPAR)
1446 * CL = capacitor of used crystal
1447 * CX = connected capacitors at xtal pins
1448 * CPAR = in all at86rf2xx datasheets this is a constant value 3 pF,
1449 * but this is different on each board setup. You need to fine
1450 * tuning this value via CTRIM.
1451 * CTRIM = variable capacitor setting. Resolution is 0.3 pF range is
1455 * atben transceiver:
1459 * CPAR = 3 pF (We assume the magic constant from datasheet)
1462 * (12+0.9+3)/2 = 7.95 which is nearly at 8 pF
1466 * openlabs transceiver:
1470 * CPAR = 3 pF (We assume the magic constant from datasheet)
1473 * (22+4.5+3)/2 = 14.75 which is the nearest value to 16 pF
1477 rc = at86rf230_write_subreg(lp, SR_XTAL_TRIM, xtal_trim);
1481 rc = at86rf230_read_subreg(lp, SR_DVDD_OK, &dvdd);
1485 dev_err(&lp->spi->dev, "DVDD error\n");
1489 /* Force setting slotted operation bit to 0. Sometimes the atben
1490 * sets this bit and I don't know why. We set this always force
1491 * to zero while probing.
1493 return at86rf230_write_subreg(lp, SR_SLOTTED_OPERATION, 0);
1497 at86rf230_get_pdata(struct spi_device *spi, int *rstn, int *slp_tr,
1500 struct at86rf230_platform_data *pdata = spi->dev.platform_data;
1503 if (!IS_ENABLED(CONFIG_OF) || !spi->dev.of_node) {
1507 *rstn = pdata->rstn;
1508 *slp_tr = pdata->slp_tr;
1509 *xtal_trim = pdata->xtal_trim;
1513 *rstn = of_get_named_gpio(spi->dev.of_node, "reset-gpio", 0);
1514 *slp_tr = of_get_named_gpio(spi->dev.of_node, "sleep-gpio", 0);
1515 ret = of_property_read_u8(spi->dev.of_node, "xtal-trim", xtal_trim);
1516 if (ret < 0 && ret != -EINVAL)
1523 at86rf230_detect_device(struct at86rf230_local *lp)
1525 unsigned int part, version, val;
1530 rc = __at86rf230_read(lp, RG_MAN_ID_0, &val);
1535 rc = __at86rf230_read(lp, RG_MAN_ID_1, &val);
1538 man_id |= (val << 8);
1540 rc = __at86rf230_read(lp, RG_PART_NUM, &part);
1544 rc = __at86rf230_read(lp, RG_VERSION_NUM, &version);
1548 if (man_id != 0x001f) {
1549 dev_err(&lp->spi->dev, "Non-Atmel dev found (MAN_ID %02x %02x)\n",
1550 man_id >> 8, man_id & 0xFF);
1554 lp->hw->flags = IEEE802154_HW_TX_OMIT_CKSUM |
1555 IEEE802154_HW_CSMA_PARAMS |
1556 IEEE802154_HW_FRAME_RETRIES | IEEE802154_HW_AFILT |
1557 IEEE802154_HW_PROMISCUOUS;
1559 lp->hw->phy->flags = WPAN_PHY_FLAG_TXPOWER |
1560 WPAN_PHY_FLAG_CCA_ED_LEVEL |
1561 WPAN_PHY_FLAG_CCA_MODE;
1563 lp->hw->phy->supported.cca_modes = BIT(NL802154_CCA_ENERGY) |
1564 BIT(NL802154_CCA_CARRIER) | BIT(NL802154_CCA_ENERGY_CARRIER);
1565 lp->hw->phy->supported.cca_opts = BIT(NL802154_CCA_OPT_ENERGY_CARRIER_AND) |
1566 BIT(NL802154_CCA_OPT_ENERGY_CARRIER_OR);
1568 lp->hw->phy->cca.mode = NL802154_CCA_ENERGY;
1577 lp->data = &at86rf231_data;
1578 lp->hw->phy->supported.channels[0] = 0x7FFF800;
1579 lp->hw->phy->current_channel = 11;
1580 lp->hw->phy->symbol_duration = 16;
1581 lp->hw->phy->supported.tx_powers = at86rf231_powers;
1582 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf231_powers);
1583 lp->hw->phy->supported.cca_ed_levels = at86rf231_ed_levels;
1584 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf231_ed_levels);
1588 lp->data = &at86rf212_data;
1589 lp->hw->flags |= IEEE802154_HW_LBT;
1590 lp->hw->phy->supported.channels[0] = 0x00007FF;
1591 lp->hw->phy->supported.channels[2] = 0x00007FF;
1592 lp->hw->phy->current_channel = 5;
1593 lp->hw->phy->symbol_duration = 25;
1594 lp->hw->phy->supported.lbt = NL802154_SUPPORTED_BOOL_BOTH;
1595 lp->hw->phy->supported.tx_powers = at86rf212_powers;
1596 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf212_powers);
1597 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100;
1598 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100);
1602 lp->data = &at86rf233_data;
1603 lp->hw->phy->supported.channels[0] = 0x7FFF800;
1604 lp->hw->phy->current_channel = 13;
1605 lp->hw->phy->symbol_duration = 16;
1606 lp->hw->phy->supported.tx_powers = at86rf233_powers;
1607 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf233_powers);
1608 lp->hw->phy->supported.cca_ed_levels = at86rf233_ed_levels;
1609 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf233_ed_levels);
1617 lp->hw->phy->cca_ed_level = lp->hw->phy->supported.cca_ed_levels[7];
1618 lp->hw->phy->transmit_power = lp->hw->phy->supported.tx_powers[0];
1621 dev_info(&lp->spi->dev, "Detected %s chip version %d\n", chip, version);
1626 #ifdef CONFIG_IEEE802154_AT86RF230_DEBUGFS
1627 static struct dentry *at86rf230_debugfs_root;
1629 static int at86rf230_stats_show(struct seq_file *file, void *offset)
1631 struct at86rf230_local *lp = file->private;
1633 seq_printf(file, "SUCCESS:\t\t%8llu\n", lp->trac.success);
1634 seq_printf(file, "SUCCESS_DATA_PENDING:\t%8llu\n",
1635 lp->trac.success_data_pending);
1636 seq_printf(file, "SUCCESS_WAIT_FOR_ACK:\t%8llu\n",
1637 lp->trac.success_wait_for_ack);
1638 seq_printf(file, "CHANNEL_ACCESS_FAILURE:\t%8llu\n",
1639 lp->trac.channel_access_failure);
1640 seq_printf(file, "NO_ACK:\t\t\t%8llu\n", lp->trac.no_ack);
1641 seq_printf(file, "INVALID:\t\t%8llu\n", lp->trac.invalid);
1645 static int at86rf230_stats_open(struct inode *inode, struct file *file)
1647 return single_open(file, at86rf230_stats_show, inode->i_private);
1650 static const struct file_operations at86rf230_stats_fops = {
1651 .open = at86rf230_stats_open,
1653 .llseek = seq_lseek,
1654 .release = single_release,
1657 static int at86rf230_debugfs_init(struct at86rf230_local *lp)
1659 char debugfs_dir_name[DNAME_INLINE_LEN + 1] = "at86rf230-";
1660 struct dentry *stats;
1662 strncat(debugfs_dir_name, dev_name(&lp->spi->dev), DNAME_INLINE_LEN);
1664 at86rf230_debugfs_root = debugfs_create_dir(debugfs_dir_name, NULL);
1665 if (!at86rf230_debugfs_root)
1668 stats = debugfs_create_file("trac_stats", S_IRUGO,
1669 at86rf230_debugfs_root, lp,
1670 &at86rf230_stats_fops);
1677 static void at86rf230_debugfs_remove(void)
1679 debugfs_remove_recursive(at86rf230_debugfs_root);
1682 static int at86rf230_debugfs_init(struct at86rf230_local *lp) { return 0; }
1683 static void at86rf230_debugfs_remove(void) { }
1686 static int at86rf230_probe(struct spi_device *spi)
1688 struct ieee802154_hw *hw;
1689 struct at86rf230_local *lp;
1690 unsigned int status;
1691 int rc, irq_type, rstn, slp_tr;
1695 dev_err(&spi->dev, "no IRQ specified\n");
1699 rc = at86rf230_get_pdata(spi, &rstn, &slp_tr, &xtal_trim);
1701 dev_err(&spi->dev, "failed to parse platform_data: %d\n", rc);
1705 if (gpio_is_valid(rstn)) {
1706 rc = devm_gpio_request_one(&spi->dev, rstn,
1707 GPIOF_OUT_INIT_HIGH, "rstn");
1712 if (gpio_is_valid(slp_tr)) {
1713 rc = devm_gpio_request_one(&spi->dev, slp_tr,
1714 GPIOF_OUT_INIT_LOW, "slp_tr");
1720 if (gpio_is_valid(rstn)) {
1722 gpio_set_value_cansleep(rstn, 0);
1724 gpio_set_value_cansleep(rstn, 1);
1725 usleep_range(120, 240);
1728 hw = ieee802154_alloc_hw(sizeof(*lp), &at86rf230_ops);
1735 lp->slp_tr = slp_tr;
1736 hw->parent = &spi->dev;
1737 ieee802154_random_extended_addr(&hw->phy->perm_extended_addr);
1739 lp->regmap = devm_regmap_init_spi(spi, &at86rf230_regmap_spi_config);
1740 if (IS_ERR(lp->regmap)) {
1741 rc = PTR_ERR(lp->regmap);
1742 dev_err(&spi->dev, "Failed to allocate register map: %d\n",
1747 at86rf230_setup_spi_messages(lp, &lp->state);
1748 at86rf230_setup_spi_messages(lp, &lp->tx);
1750 rc = at86rf230_detect_device(lp);
1754 init_completion(&lp->state_complete);
1756 spi_set_drvdata(spi, lp);
1758 rc = at86rf230_hw_init(lp, xtal_trim);
1762 /* Read irq status register to reset irq line */
1763 rc = at86rf230_read_subreg(lp, RG_IRQ_STATUS, 0xff, 0, &status);
1767 irq_type = irq_get_trigger_type(spi->irq);
1769 irq_type = IRQF_TRIGGER_HIGH;
1771 rc = devm_request_irq(&spi->dev, spi->irq, at86rf230_isr,
1772 IRQF_SHARED | irq_type, dev_name(&spi->dev), lp);
1776 /* disable_irq by default and wait for starting hardware */
1777 disable_irq(spi->irq);
1779 /* going into sleep by default */
1780 at86rf230_sleep(lp);
1782 rc = at86rf230_debugfs_init(lp);
1786 rc = ieee802154_register_hw(lp->hw);
1793 at86rf230_debugfs_remove();
1795 ieee802154_free_hw(lp->hw);
1800 static int at86rf230_remove(struct spi_device *spi)
1802 struct at86rf230_local *lp = spi_get_drvdata(spi);
1804 /* mask all at86rf230 irq's */
1805 at86rf230_write_subreg(lp, SR_IRQ_MASK, 0);
1806 ieee802154_unregister_hw(lp->hw);
1807 ieee802154_free_hw(lp->hw);
1808 at86rf230_debugfs_remove();
1809 dev_dbg(&spi->dev, "unregistered at86rf230\n");
1814 static const struct of_device_id at86rf230_of_match[] = {
1815 { .compatible = "atmel,at86rf230", },
1816 { .compatible = "atmel,at86rf231", },
1817 { .compatible = "atmel,at86rf233", },
1818 { .compatible = "atmel,at86rf212", },
1821 MODULE_DEVICE_TABLE(of, at86rf230_of_match);
1823 static const struct spi_device_id at86rf230_device_id[] = {
1824 { .name = "at86rf230", },
1825 { .name = "at86rf231", },
1826 { .name = "at86rf233", },
1827 { .name = "at86rf212", },
1830 MODULE_DEVICE_TABLE(spi, at86rf230_device_id);
1832 static struct spi_driver at86rf230_driver = {
1833 .id_table = at86rf230_device_id,
1835 .of_match_table = of_match_ptr(at86rf230_of_match),
1836 .name = "at86rf230",
1838 .probe = at86rf230_probe,
1839 .remove = at86rf230_remove,
1842 module_spi_driver(at86rf230_driver);
1844 MODULE_DESCRIPTION("AT86RF230 Transceiver Driver");
1845 MODULE_LICENSE("GPL v2");