drivers/net/ieee802154/at86rf230.c

   1 /*
   2  * AT86RF230/RF231 driver
   3  *
   4  * Copyright (C) 2009-2012 Siemens AG
   5  *
   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.
   9  *
  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.
  14  *
  15  * Written by:
  16  * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
  17  * Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
  18  * Alexander Aring <aar@pengutronix.de>
  19  */
  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>
  35
  36 #include <net/mac802154.h>
  37 #include <net/cfg802154.h>
  38
  39 #include "at86rf230.h"
  40
  41 struct at86rf230_local;
  42 /* at86rf2xx chip depend data.
  43  * All timings are in us.
  44  */
  45 struct at86rf2xx_chip_data {
  46         u16 t_sleep_cycle;
  47         u16 t_channel_switch;
  48         u16 t_reset_to_off;
  49         u16 t_off_to_aack;
  50         u16 t_off_to_tx_on;
  51         u16 t_off_to_sleep;
  52         u16 t_sleep_to_off;
  53         u16 t_frame;
  54         u16 t_p_ack;
  55         int rssi_base_val;
  56
  57         int (*set_channel)(struct at86rf230_local *, u8, u8);
  58         int (*set_txpower)(struct at86rf230_local *, s32);
  59 };
  60
  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.
  64  *
  65  * We assume the max_frame_retries (7) value of 802.15.4 here.
  66  */
  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)
  70
  71 struct at86rf230_state_change {
  72         struct at86rf230_local *lp;
  73         int irq;
  74
  75         struct hrtimer timer;
  76         struct spi_message msg;
  77         struct spi_transfer trx;
  78         u8 buf[AT86RF2XX_MAX_BUF];
  79
  80         void (*complete)(void *context);
  81         u8 from_state;
  82         u8 to_state;
  83
  84         bool irq_enable;
  85 };
  86
  87 struct at86rf230_trac {
  88         u64 success;
  89         u64 success_data_pending;
  90         u64 success_wait_for_ack;
  91         u64 channel_access_failure;
  92         u64 no_ack;
  93         u64 invalid;
  94 };
  95
  96 struct at86rf230_local {
  97         struct spi_device *spi;
  98
  99         struct ieee802154_hw *hw;
 100         struct at86rf2xx_chip_data *data;
 101         struct regmap *regmap;
 102         int slp_tr;
 103         bool sleep;
 104
 105         struct completion state_complete;
 106         struct at86rf230_state_change state;
 107
 108         struct at86rf230_state_change irq;
 109
 110         unsigned long cal_timeout;
 111         bool is_tx;
 112         bool is_tx_from_off;
 113         u8 tx_retry;
 114         struct sk_buff *tx_skb;
 115         struct at86rf230_state_change tx;
 116
 117         struct at86rf230_trac trac;
 118 };
 119
 120 #define AT86RF2XX_NUMREGS 0x3F
 121
 122 static void
 123 at86rf230_async_state_change(struct at86rf230_local *lp,
 124                              struct at86rf230_state_change *ctx,
 125                              const u8 state, void (*complete)(void *context),
 126                              const bool irq_enable);
 127
 128 static inline void
 129 at86rf230_sleep(struct at86rf230_local *lp)
 130 {
 131         if (gpio_is_valid(lp->slp_tr)) {
 132                 gpio_set_value(lp->slp_tr, 1);
 133                 usleep_range(lp->data->t_off_to_sleep,
 134                              lp->data->t_off_to_sleep + 10);
 135                 lp->sleep = true;
 136         }
 137 }
 138
 139 static inline void
 140 at86rf230_awake(struct at86rf230_local *lp)
 141 {
 142         if (gpio_is_valid(lp->slp_tr)) {
 143                 gpio_set_value(lp->slp_tr, 0);
 144                 usleep_range(lp->data->t_sleep_to_off,
 145                              lp->data->t_sleep_to_off + 100);
 146                 lp->sleep = false;
 147         }
 148 }
 149
 150 static inline int
 151 __at86rf230_write(struct at86rf230_local *lp,
 152                   unsigned int addr, unsigned int data)
 153 {
 154         bool sleep = lp->sleep;
 155         int ret;
 156
 157         /* awake for register setting if sleep */
 158         if (sleep)
 159                 at86rf230_awake(lp);
 160
 161         ret = regmap_write(lp->regmap, addr, data);
 162
 163         /* sleep again if was sleeping */
 164         if (sleep)
 165                 at86rf230_sleep(lp);
 166
 167         return ret;
 168 }
 169
 170 static inline int
 171 __at86rf230_read(struct at86rf230_local *lp,
 172                  unsigned int addr, unsigned int *data)
 173 {
 174         bool sleep = lp->sleep;
 175         int ret;
 176
 177         /* awake for register setting if sleep */
 178         if (sleep)
 179                 at86rf230_awake(lp);
 180
 181         ret = regmap_read(lp->regmap, addr, data);
 182
 183         /* sleep again if was sleeping */
 184         if (sleep)
 185                 at86rf230_sleep(lp);
 186
 187         return ret;
 188 }
 189
 190 static inline int
 191 at86rf230_read_subreg(struct at86rf230_local *lp,
 192                       unsigned int addr, unsigned int mask,
 193                       unsigned int shift, unsigned int *data)
 194 {
 195         int rc;
 196
 197         rc = __at86rf230_read(lp, addr, data);
 198         if (!rc)
 199                 *data = (*data & mask) >> shift;
 200
 201         return rc;
 202 }
 203
 204 static inline int
 205 at86rf230_write_subreg(struct at86rf230_local *lp,
 206                        unsigned int addr, unsigned int mask,
 207                        unsigned int shift, unsigned int data)
 208 {
 209         bool sleep = lp->sleep;
 210         int ret;
 211
 212         /* awake for register setting if sleep */
 213         if (sleep)
 214                 at86rf230_awake(lp);
 215
 216         ret = regmap_update_bits(lp->regmap, addr, mask, data << shift);
 217
 218         /* sleep again if was sleeping */
 219         if (sleep)
 220                 at86rf230_sleep(lp);
 221
 222         return ret;
 223 }
 224
 225 static inline void
 226 at86rf230_slp_tr_rising_edge(struct at86rf230_local *lp)
 227 {
 228         gpio_set_value(lp->slp_tr, 1);
 229         udelay(1);
 230         gpio_set_value(lp->slp_tr, 0);
 231 }
 232
 233 static bool
 234 at86rf230_reg_writeable(struct device *dev, unsigned int reg)
 235 {
 236         switch (reg) {
 237         case RG_TRX_STATE:
 238         case RG_TRX_CTRL_0:
 239         case RG_TRX_CTRL_1:
 240         case RG_PHY_TX_PWR:
 241         case RG_PHY_ED_LEVEL:
 242         case RG_PHY_CC_CCA:
 243         case RG_CCA_THRES:
 244         case RG_RX_CTRL:
 245         case RG_SFD_VALUE:
 246         case RG_TRX_CTRL_2:
 247         case RG_ANT_DIV:
 248         case RG_IRQ_MASK:
 249         case RG_VREG_CTRL:
 250         case RG_BATMON:
 251         case RG_XOSC_CTRL:
 252         case RG_RX_SYN:
 253         case RG_XAH_CTRL_1:
 254         case RG_FTN_CTRL:
 255         case RG_PLL_CF:
 256         case RG_PLL_DCU:
 257         case RG_SHORT_ADDR_0:
 258         case RG_SHORT_ADDR_1:
 259         case RG_PAN_ID_0:
 260         case RG_PAN_ID_1:
 261         case RG_IEEE_ADDR_0:
 262         case RG_IEEE_ADDR_1:
 263         case RG_IEEE_ADDR_2:
 264         case RG_IEEE_ADDR_3:
 265         case RG_IEEE_ADDR_4:
 266         case RG_IEEE_ADDR_5:
 267         case RG_IEEE_ADDR_6:
 268         case RG_IEEE_ADDR_7:
 269         case RG_XAH_CTRL_0:
 270         case RG_CSMA_SEED_0:
 271         case RG_CSMA_SEED_1:
 272         case RG_CSMA_BE:
 273                 return true;
 274         default:
 275                 return false;
 276         }
 277 }
 278
 279 static bool
 280 at86rf230_reg_readable(struct device *dev, unsigned int reg)
 281 {
 282         bool rc;
 283
 284         /* all writeable are also readable */
 285         rc = at86rf230_reg_writeable(dev, reg);
 286         if (rc)
 287                 return rc;
 288
 289         /* readonly regs */
 290         switch (reg) {
 291         case RG_TRX_STATUS:
 292         case RG_PHY_RSSI:
 293         case RG_IRQ_STATUS:
 294         case RG_PART_NUM:
 295         case RG_VERSION_NUM:
 296         case RG_MAN_ID_1:
 297         case RG_MAN_ID_0:
 298                 return true;
 299         default:
 300                 return false;
 301         }
 302 }
 303
 304 static bool
 305 at86rf230_reg_volatile(struct device *dev, unsigned int reg)
 306 {
 307         /* can be changed during runtime */
 308         switch (reg) {
 309         case RG_TRX_STATUS:
 310         case RG_TRX_STATE:
 311         case RG_PHY_RSSI:
 312         case RG_PHY_ED_LEVEL:
 313         case RG_IRQ_STATUS:
 314         case RG_VREG_CTRL:
 315         case RG_PLL_CF:
 316         case RG_PLL_DCU:
 317                 return true;
 318         default:
 319                 return false;
 320         }
 321 }
 322
 323 static bool
 324 at86rf230_reg_precious(struct device *dev, unsigned int reg)
 325 {
 326         /* don't clear irq line on read */
 327         switch (reg) {
 328         case RG_IRQ_STATUS:
 329                 return true;
 330         default:
 331                 return false;
 332         }
 333 }
 334
 335 static const struct regmap_config at86rf230_regmap_spi_config = {
 336         .reg_bits = 8,
 337         .val_bits = 8,
 338         .write_flag_mask = CMD_REG | CMD_WRITE,
 339         .read_flag_mask = CMD_REG,
 340         .cache_type = REGCACHE_RBTREE,
 341         .max_register = AT86RF2XX_NUMREGS,
 342         .writeable_reg = at86rf230_reg_writeable,
 343         .readable_reg = at86rf230_reg_readable,
 344         .volatile_reg = at86rf230_reg_volatile,
 345         .precious_reg = at86rf230_reg_precious,
 346 };
 347
 348 static void
 349 at86rf230_async_error_recover(void *context)
 350 {
 351         struct at86rf230_state_change *ctx = context;
 352         struct at86rf230_local *lp = ctx->lp;
 353
 354         lp->is_tx = 0;
 355         at86rf230_async_state_change(lp, ctx, STATE_RX_AACK_ON, NULL, false);
 356         ieee802154_wake_queue(lp->hw);
 357 }
 358
 359 static inline void
 360 at86rf230_async_error(struct at86rf230_local *lp,
 361                       struct at86rf230_state_change *ctx, int rc)
 362 {
 363         dev_err(&lp->spi->dev, "spi_async error %d\n", rc);
 364
 365         at86rf230_async_state_change(lp, ctx, STATE_FORCE_TRX_OFF,
 366                                      at86rf230_async_error_recover, false);
 367 }
 368
 369 /* Generic function to get some register value in async mode */
 370 static void
 371 at86rf230_async_read_reg(struct at86rf230_local *lp, const u8 reg,
 372                          struct at86rf230_state_change *ctx,
 373                          void (*complete)(void *context),
 374                          const bool irq_enable)
 375 {
 376         int rc;
 377
 378         u8 *tx_buf = ctx->buf;
 379
 380         tx_buf[0] = (reg & CMD_REG_MASK) | CMD_REG;
 381         ctx->msg.complete = complete;
 382         ctx->irq_enable = irq_enable;
 383         rc = spi_async(lp->spi, &ctx->msg);
 384         if (rc) {
 385                 if (irq_enable)
 386                         enable_irq(ctx->irq);
 387
 388                 at86rf230_async_error(lp, ctx, rc);
 389         }
 390 }
 391
 392 static void
 393 at86rf230_async_state_assert(void *context)
 394 {
 395         struct at86rf230_state_change *ctx = context;
 396         struct at86rf230_local *lp = ctx->lp;
 397         const u8 *buf = ctx->buf;
 398         const u8 trx_state = buf[1] & TRX_STATE_MASK;
 399
 400         /* Assert state change */
 401         if (trx_state != ctx->to_state) {
 402                 /* Special handling if transceiver state is in
 403                  * STATE_BUSY_RX_AACK and a SHR was detected.
 404                  */
 405                 if  (trx_state == STATE_BUSY_RX_AACK) {
 406                         /* Undocumented race condition. If we send a state
 407                          * change to STATE_RX_AACK_ON the transceiver could
 408                          * change his state automatically to STATE_BUSY_RX_AACK
 409                          * if a SHR was detected. This is not an error, but we
 410                          * can't assert this.
 411                          */
 412                         if (ctx->to_state == STATE_RX_AACK_ON)
 413                                 goto done;
 414
 415                         /* If we change to STATE_TX_ON without forcing and
 416                          * transceiver state is STATE_BUSY_RX_AACK, we wait
 417                          * 'tFrame + tPAck' receiving time. In this time the
 418                          * PDU should be received. If the transceiver is still
 419                          * in STATE_BUSY_RX_AACK, we run a force state change
 420                          * to STATE_TX_ON. This is a timeout handling, if the
 421                          * transceiver stucks in STATE_BUSY_RX_AACK.
 422                          *
 423                          * Additional we do several retries to try to get into
 424                          * TX_ON state without forcing. If the retries are
 425                          * higher or equal than AT86RF2XX_MAX_TX_RETRIES we
 426                          * will do a force change.
 427                          */
 428                         if (ctx->to_state == STATE_TX_ON ||
 429                             ctx->to_state == STATE_TRX_OFF) {
 430                                 u8 state = ctx->to_state;
 431
 432                                 if (lp->tx_retry >= AT86RF2XX_MAX_TX_RETRIES)
 433                                         state = STATE_FORCE_TRX_OFF;
 434                                 lp->tx_retry++;
 435
 436                                 at86rf230_async_state_change(lp, ctx, state,
 437                                                              ctx->complete,
 438                                                              ctx->irq_enable);
 439                                 return;
 440                         }
 441                 }
 442
 443                 dev_warn(&lp->spi->dev, "unexcept state change from 0x%02x to 0x%02x. Actual state: 0x%02x\n",
 444                          ctx->from_state, ctx->to_state, trx_state);
 445         }
 446
 447 done:
 448         if (ctx->complete)
 449                 ctx->complete(context);
 450 }
 451
 452 static enum hrtimer_restart at86rf230_async_state_timer(struct hrtimer *timer)
 453 {
 454         struct at86rf230_state_change *ctx =
 455                 container_of(timer, struct at86rf230_state_change, timer);
 456         struct at86rf230_local *lp = ctx->lp;
 457
 458         at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
 459                                  at86rf230_async_state_assert,
 460                                  ctx->irq_enable);
 461
 462         return HRTIMER_NORESTART;
 463 }
 464
 465 /* Do state change timing delay. */
 466 static void
 467 at86rf230_async_state_delay(void *context)
 468 {
 469         struct at86rf230_state_change *ctx = context;
 470         struct at86rf230_local *lp = ctx->lp;
 471         struct at86rf2xx_chip_data *c = lp->data;
 472         bool force = false;
 473         ktime_t tim;
 474
 475         /* The force state changes are will show as normal states in the
 476          * state status subregister. We change the to_state to the
 477          * corresponding one and remember if it was a force change, this
 478          * differs if we do a state change from STATE_BUSY_RX_AACK.
 479          */
 480         switch (ctx->to_state) {
 481         case STATE_FORCE_TX_ON:
 482                 ctx->to_state = STATE_TX_ON;
 483                 force = true;
 484                 break;
 485         case STATE_FORCE_TRX_OFF:
 486                 ctx->to_state = STATE_TRX_OFF;
 487                 force = true;
 488                 break;
 489         default:
 490                 break;
 491         }
 492
 493         switch (ctx->from_state) {
 494         case STATE_TRX_OFF:
 495                 switch (ctx->to_state) {
 496                 case STATE_RX_AACK_ON:
 497                         tim = ktime_set(0, c->t_off_to_aack * NSEC_PER_USEC);
 498                         /* state change from TRX_OFF to RX_AACK_ON to do a
 499                          * calibration, we need to reset the timeout for the
 500                          * next one.
 501                          */
 502                         lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
 503                         goto change;
 504                 case STATE_TX_ARET_ON:
 505                 case STATE_TX_ON:
 506                         tim = ktime_set(0, c->t_off_to_tx_on * NSEC_PER_USEC);
 507                         /* state change from TRX_OFF to TX_ON or ARET_ON to do
 508                          * a calibration, we need to reset the timeout for the
 509                          * next one.
 510                          */
 511                         lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
 512                         goto change;
 513                 default:
 514                         break;
 515                 }
 516                 break;
 517         case STATE_BUSY_RX_AACK:
 518                 switch (ctx->to_state) {
 519                 case STATE_TRX_OFF:
 520                 case STATE_TX_ON:
 521                         /* Wait for worst case receiving time if we
 522                          * didn't make a force change from BUSY_RX_AACK
 523                          * to TX_ON or TRX_OFF.
 524                          */
 525                         if (!force) {
 526                                 tim = ktime_set(0, (c->t_frame + c->t_p_ack) *
 527                                                    NSEC_PER_USEC);
 528                                 goto change;
 529                         }
 530                         break;
 531                 default:
 532                         break;
 533                 }
 534                 break;
 535         /* Default value, means RESET state */
 536         case STATE_P_ON:
 537                 switch (ctx->to_state) {
 538                 case STATE_TRX_OFF:
 539                         tim = ktime_set(0, c->t_reset_to_off * NSEC_PER_USEC);
 540                         goto change;
 541                 default:
 542                         break;
 543                 }
 544                 break;
 545         default:
 546                 break;
 547         }
 548
 549         /* Default delay is 1us in the most cases */
 550         udelay(1);
 551         at86rf230_async_state_timer(&ctx->timer);
 552         return;
 553
 554 change:
 555         hrtimer_start(&ctx->timer, tim, HRTIMER_MODE_REL);
 556 }
 557
 558 static void
 559 at86rf230_async_state_change_start(void *context)
 560 {
 561         struct at86rf230_state_change *ctx = context;
 562         struct at86rf230_local *lp = ctx->lp;
 563         u8 *buf = ctx->buf;
 564         const u8 trx_state = buf[1] & TRX_STATE_MASK;
 565         int rc;
 566
 567         /* Check for "possible" STATE_TRANSITION_IN_PROGRESS */
 568         if (trx_state == STATE_TRANSITION_IN_PROGRESS) {
 569                 udelay(1);
 570                 at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
 571                                          at86rf230_async_state_change_start,
 572                                          ctx->irq_enable);
 573                 return;
 574         }
 575
 576         /* Check if we already are in the state which we change in */
 577         if (trx_state == ctx->to_state) {
 578                 if (ctx->complete)
 579                         ctx->complete(context);
 580                 return;
 581         }
 582
 583         /* Set current state to the context of state change */
 584         ctx->from_state = trx_state;
 585
 586         /* Going into the next step for a state change which do a timing
 587          * relevant delay.
 588          */
 589         buf[0] = (RG_TRX_STATE & CMD_REG_MASK) | CMD_REG | CMD_WRITE;
 590         buf[1] = ctx->to_state;
 591         ctx->msg.complete = at86rf230_async_state_delay;
 592         rc = spi_async(lp->spi, &ctx->msg);
 593         if (rc) {
 594                 if (ctx->irq_enable)
 595                         enable_irq(ctx->irq);
 596
 597                 at86rf230_async_error(lp, ctx, rc);
 598         }
 599 }
 600
 601 static void
 602 at86rf230_async_state_change(struct at86rf230_local *lp,
 603                              struct at86rf230_state_change *ctx,
 604                              const u8 state, void (*complete)(void *context),
 605                              const bool irq_enable)
 606 {
 607         /* Initialization for the state change context */
 608         ctx->to_state = state;
 609         ctx->complete = complete;
 610         ctx->irq_enable = irq_enable;
 611         at86rf230_async_read_reg(lp, RG_TRX_STATUS, ctx,
 612                                  at86rf230_async_state_change_start,
 613                                  irq_enable);
 614 }
 615
 616 static void
 617 at86rf230_sync_state_change_complete(void *context)
 618 {
 619         struct at86rf230_state_change *ctx = context;
 620         struct at86rf230_local *lp = ctx->lp;
 621
 622         complete(&lp->state_complete);
 623 }
 624
 625 /* This function do a sync framework above the async state change.
 626  * Some callbacks of the IEEE 802.15.4 driver interface need to be
 627  * handled synchronously.
 628  */
 629 static int
 630 at86rf230_sync_state_change(struct at86rf230_local *lp, unsigned int state)
 631 {
 632         unsigned long rc;
 633
 634         at86rf230_async_state_change(lp, &lp->state, state,
 635                                      at86rf230_sync_state_change_complete,
 636                                      false);
 637
 638         rc = wait_for_completion_timeout(&lp->state_complete,
 639                                          msecs_to_jiffies(100));
 640         if (!rc) {
 641                 at86rf230_async_error(lp, &lp->state, -ETIMEDOUT);
 642                 return -ETIMEDOUT;
 643         }
 644
 645         return 0;
 646 }
 647
 648 static void
 649 at86rf230_tx_complete(void *context)
 650 {
 651         struct at86rf230_state_change *ctx = context;
 652         struct at86rf230_local *lp = ctx->lp;
 653
 654         enable_irq(ctx->irq);
 655
 656         ieee802154_xmit_complete(lp->hw, lp->tx_skb, false);
 657 }
 658
 659 static void
 660 at86rf230_tx_on(void *context)
 661 {
 662         struct at86rf230_state_change *ctx = context;
 663         struct at86rf230_local *lp = ctx->lp;
 664
 665         at86rf230_async_state_change(lp, ctx, STATE_RX_AACK_ON,
 666                                      at86rf230_tx_complete, true);
 667 }
 668
 669 static void
 670 at86rf230_tx_trac_check(void *context)
 671 {
 672         struct at86rf230_state_change *ctx = context;
 673         struct at86rf230_local *lp = ctx->lp;
 674
 675         if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS)) {
 676                 u8 trac = TRAC_MASK(ctx->buf[1]);
 677
 678                 switch (trac) {
 679                 case TRAC_SUCCESS:
 680                         lp->trac.success++;
 681                         break;
 682                 case TRAC_SUCCESS_DATA_PENDING:
 683                         lp->trac.success_data_pending++;
 684                         break;
 685                 case TRAC_CHANNEL_ACCESS_FAILURE:
 686                         lp->trac.channel_access_failure++;
 687                         break;
 688                 case TRAC_NO_ACK:
 689                         lp->trac.no_ack++;
 690                         break;
 691                 case TRAC_INVALID:
 692                         lp->trac.invalid++;
 693                         break;
 694                 default:
 695                         WARN_ONCE(1, "received tx trac status %d\n", trac);
 696                         break;
 697                 }
 698         }
 699
 700         at86rf230_async_state_change(lp, &lp->irq, STATE_TX_ON,
 701                                      at86rf230_tx_on, true);
 702 }
 703
 704 static void
 705 at86rf230_rx_read_frame_complete(void *context)
 706 {
 707         struct at86rf230_state_change *ctx = context;
 708         struct at86rf230_local *lp = ctx->lp;
 709         u8 rx_local_buf[AT86RF2XX_MAX_BUF];
 710         const u8 *buf = ctx->buf;
 711         struct sk_buff *skb;
 712         u8 len, lqi;
 713
 714         len = buf[1];
 715         if (!ieee802154_is_valid_psdu_len(len)) {
 716                 dev_vdbg(&lp->spi->dev, "corrupted frame received\n");
 717                 len = IEEE802154_MTU;
 718         }
 719         lqi = buf[2 + len];
 720
 721         memcpy(rx_local_buf, buf + 2, len);
 722         ctx->trx.len = 2;
 723         enable_irq(ctx->irq);
 724
 725         skb = dev_alloc_skb(IEEE802154_MTU);
 726         if (!skb) {
 727                 dev_vdbg(&lp->spi->dev, "failed to allocate sk_buff\n");
 728                 return;
 729         }
 730
 731         memcpy(skb_put(skb, len), rx_local_buf, len);
 732         ieee802154_rx_irqsafe(lp->hw, skb, lqi);
 733 }
 734
 735 static void
 736 at86rf230_rx_trac_check(void *context)
 737 {
 738         struct at86rf230_state_change *ctx = context;
 739         struct at86rf230_local *lp = ctx->lp;
 740         u8 *buf = ctx->buf;
 741         int rc;
 742
 743         if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS)) {
 744                 u8 trac = TRAC_MASK(buf[1]);
 745
 746                 switch (trac) {
 747                 case TRAC_SUCCESS:
 748                         lp->trac.success++;
 749                         break;
 750                 case TRAC_SUCCESS_WAIT_FOR_ACK:
 751                         lp->trac.success_wait_for_ack++;
 752                         break;
 753                 case TRAC_INVALID:
 754                         lp->trac.invalid++;
 755                         break;
 756                 default:
 757                         WARN_ONCE(1, "received rx trac status %d\n", trac);
 758                         break;
 759                 }
 760         }
 761
 762         buf[0] = CMD_FB;
 763         ctx->trx.len = AT86RF2XX_MAX_BUF;
 764         ctx->msg.complete = at86rf230_rx_read_frame_complete;
 765         rc = spi_async(lp->spi, &ctx->msg);
 766         if (rc) {
 767                 ctx->trx.len = 2;
 768                 enable_irq(ctx->irq);
 769                 at86rf230_async_error(lp, ctx, rc);
 770         }
 771 }
 772
 773 static void
 774 at86rf230_irq_trx_end(struct at86rf230_local *lp)
 775 {
 776         if (lp->is_tx) {
 777                 lp->is_tx = 0;
 778                 at86rf230_async_read_reg(lp, RG_TRX_STATE, &lp->irq,
 779                                          at86rf230_tx_trac_check, true);
 780         } else {
 781                 at86rf230_async_read_reg(lp, RG_TRX_STATE, &lp->irq,
 782                                          at86rf230_rx_trac_check, true);
 783         }
 784 }
 785
 786 static void
 787 at86rf230_irq_status(void *context)
 788 {
 789         struct at86rf230_state_change *ctx = context;
 790         struct at86rf230_local *lp = ctx->lp;
 791         const u8 *buf = ctx->buf;
 792         const u8 irq = buf[1];
 793
 794         if (irq & IRQ_TRX_END) {
 795                 at86rf230_irq_trx_end(lp);
 796         } else {
 797                 enable_irq(ctx->irq);
 798                 dev_err(&lp->spi->dev, "not supported irq %02x received\n",
 799                         irq);
 800         }
 801 }
 802
 803 static irqreturn_t at86rf230_isr(int irq, void *data)
 804 {
 805         struct at86rf230_local *lp = data;
 806         struct at86rf230_state_change *ctx = &lp->irq;
 807         u8 *buf = ctx->buf;
 808         int rc;
 809
 810         disable_irq_nosync(irq);
 811
 812         buf[0] = (RG_IRQ_STATUS & CMD_REG_MASK) | CMD_REG;
 813         ctx->msg.complete = at86rf230_irq_status;
 814         rc = spi_async(lp->spi, &ctx->msg);
 815         if (rc) {
 816                 enable_irq(irq);
 817                 at86rf230_async_error(lp, ctx, rc);
 818                 return IRQ_NONE;
 819         }
 820
 821         return IRQ_HANDLED;
 822 }
 823
 824 static void
 825 at86rf230_write_frame_complete(void *context)
 826 {
 827         struct at86rf230_state_change *ctx = context;
 828         struct at86rf230_local *lp = ctx->lp;
 829         u8 *buf = ctx->buf;
 830         int rc;
 831
 832         ctx->trx.len = 2;
 833
 834         if (gpio_is_valid(lp->slp_tr)) {
 835                 at86rf230_slp_tr_rising_edge(lp);
 836         } else {
 837                 buf[0] = (RG_TRX_STATE & CMD_REG_MASK) | CMD_REG | CMD_WRITE;
 838                 buf[1] = STATE_BUSY_TX;
 839                 ctx->msg.complete = NULL;
 840                 rc = spi_async(lp->spi, &ctx->msg);
 841                 if (rc)
 842                         at86rf230_async_error(lp, ctx, rc);
 843         }
 844 }
 845
 846 static void
 847 at86rf230_write_frame(void *context)
 848 {
 849         struct at86rf230_state_change *ctx = context;
 850         struct at86rf230_local *lp = ctx->lp;
 851         struct sk_buff *skb = lp->tx_skb;
 852         u8 *buf = ctx->buf;
 853         int rc;
 854
 855         lp->is_tx = 1;
 856
 857         buf[0] = CMD_FB | CMD_WRITE;
 858         buf[1] = skb->len + 2;
 859         memcpy(buf + 2, skb->data, skb->len);
 860         ctx->trx.len = skb->len + 2;
 861         ctx->msg.complete = at86rf230_write_frame_complete;
 862         rc = spi_async(lp->spi, &ctx->msg);
 863         if (rc) {
 864                 ctx->trx.len = 2;
 865                 at86rf230_async_error(lp, ctx, rc);
 866         }
 867 }
 868
 869 static void
 870 at86rf230_xmit_tx_on(void *context)
 871 {
 872         struct at86rf230_state_change *ctx = context;
 873         struct at86rf230_local *lp = ctx->lp;
 874
 875         at86rf230_async_state_change(lp, ctx, STATE_TX_ARET_ON,
 876                                      at86rf230_write_frame, false);
 877 }
 878
 879 static void
 880 at86rf230_xmit_start(void *context)
 881 {
 882         struct at86rf230_state_change *ctx = context;
 883         struct at86rf230_local *lp = ctx->lp;
 884
 885         /* check if we change from off state */
 886         if (lp->is_tx_from_off) {
 887                 lp->is_tx_from_off = false;
 888                 at86rf230_async_state_change(lp, ctx, STATE_TX_ARET_ON,
 889                                              at86rf230_write_frame,
 890                                              false);
 891         } else {
 892                 at86rf230_async_state_change(lp, ctx, STATE_TX_ON,
 893                                              at86rf230_xmit_tx_on,
 894                                              false);
 895         }
 896 }
 897
 898 static int
 899 at86rf230_xmit(struct ieee802154_hw *hw, struct sk_buff *skb)
 900 {
 901         struct at86rf230_local *lp = hw->priv;
 902         struct at86rf230_state_change *ctx = &lp->tx;
 903
 904         lp->tx_skb = skb;
 905         lp->tx_retry = 0;
 906
 907         /* After 5 minutes in PLL and the same frequency we run again the
 908          * calibration loops which is recommended by at86rf2xx datasheets.
 909          *
 910          * The calibration is initiate by a state change from TRX_OFF
 911          * to TX_ON, the lp->cal_timeout should be reinit by state_delay
 912          * function then to start in the next 5 minutes.
 913          */
 914         if (time_is_before_jiffies(lp->cal_timeout)) {
 915                 lp->is_tx_from_off = true;
 916                 at86rf230_async_state_change(lp, ctx, STATE_TRX_OFF,
 917                                              at86rf230_xmit_start, false);
 918         } else {
 919                 at86rf230_xmit_start(ctx);
 920         }
 921
 922         return 0;
 923 }
 924
 925 static int
 926 at86rf230_ed(struct ieee802154_hw *hw, u8 *level)
 927 {
 928         BUG_ON(!level);
 929         *level = 0xbe;
 930         return 0;
 931 }
 932
 933 static int
 934 at86rf230_start(struct ieee802154_hw *hw)
 935 {
 936         struct at86rf230_local *lp = hw->priv;
 937
 938         /* reset trac stats on start */
 939         if (IS_ENABLED(CONFIG_IEEE802154_AT86RF230_DEBUGFS))
 940                 memset(&lp->trac, 0, sizeof(struct at86rf230_trac));
 941
 942         at86rf230_awake(lp);
 943         enable_irq(lp->spi->irq);
 944
 945         return at86rf230_sync_state_change(lp, STATE_RX_AACK_ON);
 946 }
 947
 948 static void
 949 at86rf230_stop(struct ieee802154_hw *hw)
 950 {
 951         struct at86rf230_local *lp = hw->priv;
 952         u8 csma_seed[2];
 953
 954         at86rf230_sync_state_change(lp, STATE_FORCE_TRX_OFF);
 955
 956         disable_irq(lp->spi->irq);
 957
 958         /* It's recommended to set random new csma_seeds before sleep state.
 959          * Makes only sense in the stop callback, not doing this inside of
 960          * at86rf230_sleep, this is also used when we don't transmit afterwards
 961          * when calling start callback again.
 962          */
 963         get_random_bytes(csma_seed, ARRAY_SIZE(csma_seed));
 964         at86rf230_write_subreg(lp, SR_CSMA_SEED_0, csma_seed[0]);
 965         at86rf230_write_subreg(lp, SR_CSMA_SEED_1, csma_seed[1]);
 966
 967         at86rf230_sleep(lp);
 968 }
 969
 970 static int
 971 at86rf23x_set_channel(struct at86rf230_local *lp, u8 page, u8 channel)
 972 {
 973         return at86rf230_write_subreg(lp, SR_CHANNEL, channel);
 974 }
 975
 976 #define AT86RF2XX_MAX_ED_LEVELS 0xF
 977 static const s32 at86rf23x_ed_levels[AT86RF2XX_MAX_ED_LEVELS + 1] = {
 978         -9100, -8900, -8700, -8500, -8300, -8100, -7900, -7700, -7500, -7300,
 979         -7100, -6900, -6700, -6500, -6300, -6100,
 980 };
 981
 982 static const s32 at86rf212_ed_levels_100[AT86RF2XX_MAX_ED_LEVELS + 1] = {
 983         -10000, -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200,
 984         -8000, -7800, -7600, -7400, -7200, -7000,
 985 };
 986
 987 static const s32 at86rf212_ed_levels_98[AT86RF2XX_MAX_ED_LEVELS + 1] = {
 988         -9800, -9600, -9400, -9200, -9000, -8800, -8600, -8400, -8200, -8000,
 989         -7800, -7600, -7400, -7200, -7000, -6800,
 990 };
 991
 992 static inline int
 993 at86rf212_update_cca_ed_level(struct at86rf230_local *lp, int rssi_base_val)
 994 {
 995         unsigned int cca_ed_thres;
 996         int rc;
 997
 998         rc = at86rf230_read_subreg(lp, SR_CCA_ED_THRES, &cca_ed_thres);
 999         if (rc < 0)
1000                 return rc;
1001
1002         switch (rssi_base_val) {
1003         case -98:
1004                 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_98;
1005                 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_98);
1006                 lp->hw->phy->cca_ed_level = at86rf212_ed_levels_98[cca_ed_thres];
1007                 break;
1008         case -100:
1009                 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100;
1010                 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100);
1011                 lp->hw->phy->cca_ed_level = at86rf212_ed_levels_100[cca_ed_thres];
1012                 break;
1013         default:
1014                 WARN_ON(1);
1015         }
1016
1017         return 0;
1018 }
1019
1020 static int
1021 at86rf212_set_channel(struct at86rf230_local *lp, u8 page, u8 channel)
1022 {
1023         int rc;
1024
1025         if (channel == 0)
1026                 rc = at86rf230_write_subreg(lp, SR_SUB_MODE, 0);
1027         else
1028                 rc = at86rf230_write_subreg(lp, SR_SUB_MODE, 1);
1029         if (rc < 0)
1030                 return rc;
1031
1032         if (page == 0) {
1033                 rc = at86rf230_write_subreg(lp, SR_BPSK_QPSK, 0);
1034                 lp->data->rssi_base_val = -100;
1035         } else {
1036                 rc = at86rf230_write_subreg(lp, SR_BPSK_QPSK, 1);
1037                 lp->data->rssi_base_val = -98;
1038         }
1039         if (rc < 0)
1040                 return rc;
1041
1042         rc = at86rf212_update_cca_ed_level(lp, lp->data->rssi_base_val);
1043         if (rc < 0)
1044                 return rc;
1045
1046         /* This sets the symbol_duration according frequency on the 212.
1047          * TODO move this handling while set channel and page in cfg802154.
1048          * We can do that, this timings are according 802.15.4 standard.
1049          * If we do that in cfg802154, this is a more generic calculation.
1050          *
1051          * This should also protected from ifs_timer. Means cancel timer and
1052          * init with a new value. For now, this is okay.
1053          */
1054         if (channel == 0) {
1055                 if (page == 0) {
1056                         /* SUB:0 and BPSK:0 -> BPSK-20 */
1057                         lp->hw->phy->symbol_duration = 50;
1058                 } else {
1059                         /* SUB:1 and BPSK:0 -> BPSK-40 */
1060                         lp->hw->phy->symbol_duration = 25;
1061                 }
1062         } else {
1063                 if (page == 0)
1064                         /* SUB:0 and BPSK:1 -> OQPSK-100/200/400 */
1065                         lp->hw->phy->symbol_duration = 40;
1066                 else
1067                         /* SUB:1 and BPSK:1 -> OQPSK-250/500/1000 */
1068                         lp->hw->phy->symbol_duration = 16;
1069         }
1070
1071         lp->hw->phy->lifs_period = IEEE802154_LIFS_PERIOD *
1072                                    lp->hw->phy->symbol_duration;
1073         lp->hw->phy->sifs_period = IEEE802154_SIFS_PERIOD *
1074                                    lp->hw->phy->symbol_duration;
1075
1076         return at86rf230_write_subreg(lp, SR_CHANNEL, channel);
1077 }
1078
1079 static int
1080 at86rf230_channel(struct ieee802154_hw *hw, u8 page, u8 channel)
1081 {
1082         struct at86rf230_local *lp = hw->priv;
1083         int rc;
1084
1085         rc = lp->data->set_channel(lp, page, channel);
1086         /* Wait for PLL */
1087         usleep_range(lp->data->t_channel_switch,
1088                      lp->data->t_channel_switch + 10);
1089
1090         lp->cal_timeout = jiffies + AT86RF2XX_CAL_LOOP_TIMEOUT;
1091         return rc;
1092 }
1093
1094 static int
1095 at86rf230_set_hw_addr_filt(struct ieee802154_hw *hw,
1096                            struct ieee802154_hw_addr_filt *filt,
1097                            unsigned long changed)
1098 {
1099         struct at86rf230_local *lp = hw->priv;
1100
1101         if (changed & IEEE802154_AFILT_SADDR_CHANGED) {
1102                 u16 addr = le16_to_cpu(filt->short_addr);
1103
1104                 dev_vdbg(&lp->spi->dev,
1105                          "at86rf230_set_hw_addr_filt called for saddr\n");
1106                 __at86rf230_write(lp, RG_SHORT_ADDR_0, addr);
1107                 __at86rf230_write(lp, RG_SHORT_ADDR_1, addr >> 8);
1108         }
1109
1110         if (changed & IEEE802154_AFILT_PANID_CHANGED) {
1111                 u16 pan = le16_to_cpu(filt->pan_id);
1112
1113                 dev_vdbg(&lp->spi->dev,
1114                          "at86rf230_set_hw_addr_filt called for pan id\n");
1115                 __at86rf230_write(lp, RG_PAN_ID_0, pan);
1116                 __at86rf230_write(lp, RG_PAN_ID_1, pan >> 8);
1117         }
1118
1119         if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) {
1120                 u8 i, addr[8];
1121
1122                 memcpy(addr, &filt->ieee_addr, 8);
1123                 dev_vdbg(&lp->spi->dev,
1124                          "at86rf230_set_hw_addr_filt called for IEEE addr\n");
1125                 for (i = 0; i < 8; i++)
1126                         __at86rf230_write(lp, RG_IEEE_ADDR_0 + i, addr[i]);
1127         }
1128
1129         if (changed & IEEE802154_AFILT_PANC_CHANGED) {
1130                 dev_vdbg(&lp->spi->dev,
1131                          "at86rf230_set_hw_addr_filt called for panc change\n");
1132                 if (filt->pan_coord)
1133                         at86rf230_write_subreg(lp, SR_AACK_I_AM_COORD, 1);
1134                 else
1135                         at86rf230_write_subreg(lp, SR_AACK_I_AM_COORD, 0);
1136         }
1137
1138         return 0;
1139 }
1140
1141 #define AT86RF23X_MAX_TX_POWERS 0xF
1142 static const s32 at86rf233_powers[AT86RF23X_MAX_TX_POWERS + 1] = {
1143         400, 370, 340, 300, 250, 200, 100, 0, -100, -200, -300, -400, -600,
1144         -800, -1200, -1700,
1145 };
1146
1147 static const s32 at86rf231_powers[AT86RF23X_MAX_TX_POWERS + 1] = {
1148         300, 280, 230, 180, 130, 70, 0, -100, -200, -300, -400, -500, -700,
1149         -900, -1200, -1700,
1150 };
1151
1152 #define AT86RF212_MAX_TX_POWERS 0x1F
1153 static const s32 at86rf212_powers[AT86RF212_MAX_TX_POWERS + 1] = {
1154         500, 400, 300, 200, 100, 0, -100, -200, -300, -400, -500, -600, -700,
1155         -800, -900, -1000, -1100, -1200, -1300, -1400, -1500, -1600, -1700,
1156         -1800, -1900, -2000, -2100, -2200, -2300, -2400, -2500, -2600,
1157 };
1158
1159 static int
1160 at86rf23x_set_txpower(struct at86rf230_local *lp, s32 mbm)
1161 {
1162         u32 i;
1163
1164         for (i = 0; i < lp->hw->phy->supported.tx_powers_size; i++) {
1165                 if (lp->hw->phy->supported.tx_powers[i] == mbm)
1166                         return at86rf230_write_subreg(lp, SR_TX_PWR_23X, i);
1167         }
1168
1169         return -EINVAL;
1170 }
1171
1172 static int
1173 at86rf212_set_txpower(struct at86rf230_local *lp, s32 mbm)
1174 {
1175         u32 i;
1176
1177         for (i = 0; i < lp->hw->phy->supported.tx_powers_size; i++) {
1178                 if (lp->hw->phy->supported.tx_powers[i] == mbm)
1179                         return at86rf230_write_subreg(lp, SR_TX_PWR_212, i);
1180         }
1181
1182         return -EINVAL;
1183 }
1184
1185 static int
1186 at86rf230_set_txpower(struct ieee802154_hw *hw, s32 mbm)
1187 {
1188         struct at86rf230_local *lp = hw->priv;
1189
1190         return lp->data->set_txpower(lp, mbm);
1191 }
1192
1193 static int
1194 at86rf230_set_lbt(struct ieee802154_hw *hw, bool on)
1195 {
1196         struct at86rf230_local *lp = hw->priv;
1197
1198         return at86rf230_write_subreg(lp, SR_CSMA_LBT_MODE, on);
1199 }
1200
1201 static int
1202 at86rf230_set_cca_mode(struct ieee802154_hw *hw,
1203                        const struct wpan_phy_cca *cca)
1204 {
1205         struct at86rf230_local *lp = hw->priv;
1206         u8 val;
1207
1208         /* mapping 802.15.4 to driver spec */
1209         switch (cca->mode) {
1210         case NL802154_CCA_ENERGY:
1211                 val = 1;
1212                 break;
1213         case NL802154_CCA_CARRIER:
1214                 val = 2;
1215                 break;
1216         case NL802154_CCA_ENERGY_CARRIER:
1217                 switch (cca->opt) {
1218                 case NL802154_CCA_OPT_ENERGY_CARRIER_AND:
1219                         val = 3;
1220                         break;
1221                 case NL802154_CCA_OPT_ENERGY_CARRIER_OR:
1222                         val = 0;
1223                         break;
1224                 default:
1225                         return -EINVAL;
1226                 }
1227                 break;
1228         default:
1229                 return -EINVAL;
1230         }
1231
1232         return at86rf230_write_subreg(lp, SR_CCA_MODE, val);
1233 }
1234
1235
1236 static int
1237 at86rf230_set_cca_ed_level(struct ieee802154_hw *hw, s32 mbm)
1238 {
1239         struct at86rf230_local *lp = hw->priv;
1240         u32 i;
1241
1242         for (i = 0; i < hw->phy->supported.cca_ed_levels_size; i++) {
1243                 if (hw->phy->supported.cca_ed_levels[i] == mbm)
1244                         return at86rf230_write_subreg(lp, SR_CCA_ED_THRES, i);
1245         }
1246
1247         return -EINVAL;
1248 }
1249
1250 static int
1251 at86rf230_set_csma_params(struct ieee802154_hw *hw, u8 min_be, u8 max_be,
1252                           u8 retries)
1253 {
1254         struct at86rf230_local *lp = hw->priv;
1255         int rc;
1256
1257         rc = at86rf230_write_subreg(lp, SR_MIN_BE, min_be);
1258         if (rc)
1259                 return rc;
1260
1261         rc = at86rf230_write_subreg(lp, SR_MAX_BE, max_be);
1262         if (rc)
1263                 return rc;
1264
1265         return at86rf230_write_subreg(lp, SR_MAX_CSMA_RETRIES, retries);
1266 }
1267
1268 static int
1269 at86rf230_set_frame_retries(struct ieee802154_hw *hw, s8 retries)
1270 {
1271         struct at86rf230_local *lp = hw->priv;
1272
1273         return at86rf230_write_subreg(lp, SR_MAX_FRAME_RETRIES, retries);
1274 }
1275
1276 static int
1277 at86rf230_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on)
1278 {
1279         struct at86rf230_local *lp = hw->priv;
1280         int rc;
1281
1282         if (on) {
1283                 rc = at86rf230_write_subreg(lp, SR_AACK_DIS_ACK, 1);
1284                 if (rc < 0)
1285                         return rc;
1286
1287                 rc = at86rf230_write_subreg(lp, SR_AACK_PROM_MODE, 1);
1288                 if (rc < 0)
1289                         return rc;
1290         } else {
1291                 rc = at86rf230_write_subreg(lp, SR_AACK_PROM_MODE, 0);
1292                 if (rc < 0)
1293                         return rc;
1294
1295                 rc = at86rf230_write_subreg(lp, SR_AACK_DIS_ACK, 0);
1296                 if (rc < 0)
1297                         return rc;
1298         }
1299
1300         return 0;
1301 }
1302
1303 static const struct ieee802154_ops at86rf230_ops = {
1304         .owner = THIS_MODULE,
1305         .xmit_async = at86rf230_xmit,
1306         .ed = at86rf230_ed,
1307         .set_channel = at86rf230_channel,
1308         .start = at86rf230_start,
1309         .stop = at86rf230_stop,
1310         .set_hw_addr_filt = at86rf230_set_hw_addr_filt,
1311         .set_txpower = at86rf230_set_txpower,
1312         .set_lbt = at86rf230_set_lbt,
1313         .set_cca_mode = at86rf230_set_cca_mode,
1314         .set_cca_ed_level = at86rf230_set_cca_ed_level,
1315         .set_csma_params = at86rf230_set_csma_params,
1316         .set_frame_retries = at86rf230_set_frame_retries,
1317         .set_promiscuous_mode = at86rf230_set_promiscuous_mode,
1318 };
1319
1320 static struct at86rf2xx_chip_data at86rf233_data = {
1321         .t_sleep_cycle = 330,
1322         .t_channel_switch = 11,
1323         .t_reset_to_off = 26,
1324         .t_off_to_aack = 80,
1325         .t_off_to_tx_on = 80,
1326         .t_off_to_sleep = 35,
1327         .t_sleep_to_off = 210,
1328         .t_frame = 4096,
1329         .t_p_ack = 545,
1330         .rssi_base_val = -91,
1331         .set_channel = at86rf23x_set_channel,
1332         .set_txpower = at86rf23x_set_txpower,
1333 };
1334
1335 static struct at86rf2xx_chip_data at86rf231_data = {
1336         .t_sleep_cycle = 330,
1337         .t_channel_switch = 24,
1338         .t_reset_to_off = 37,
1339         .t_off_to_aack = 110,
1340         .t_off_to_tx_on = 110,
1341         .t_off_to_sleep = 35,
1342         .t_sleep_to_off = 380,
1343         .t_frame = 4096,
1344         .t_p_ack = 545,
1345         .rssi_base_val = -91,
1346         .set_channel = at86rf23x_set_channel,
1347         .set_txpower = at86rf23x_set_txpower,
1348 };
1349
1350 static struct at86rf2xx_chip_data at86rf212_data = {
1351         .t_sleep_cycle = 330,
1352         .t_channel_switch = 11,
1353         .t_reset_to_off = 26,
1354         .t_off_to_aack = 200,
1355         .t_off_to_tx_on = 200,
1356         .t_off_to_sleep = 35,
1357         .t_sleep_to_off = 380,
1358         .t_frame = 4096,
1359         .t_p_ack = 545,
1360         .rssi_base_val = -100,
1361         .set_channel = at86rf212_set_channel,
1362         .set_txpower = at86rf212_set_txpower,
1363 };
1364
1365 static int at86rf230_hw_init(struct at86rf230_local *lp, u8 xtal_trim)
1366 {
1367         int rc, irq_type, irq_pol = IRQ_ACTIVE_HIGH;
1368         unsigned int dvdd;
1369         u8 csma_seed[2];
1370
1371         rc = at86rf230_sync_state_change(lp, STATE_FORCE_TRX_OFF);
1372         if (rc)
1373                 return rc;
1374
1375         irq_type = irq_get_trigger_type(lp->spi->irq);
1376         if (irq_type == IRQ_TYPE_EDGE_RISING ||
1377             irq_type == IRQ_TYPE_EDGE_FALLING)
1378                 dev_warn(&lp->spi->dev,
1379                          "Using edge triggered irq's are not recommended, because it can cause races and result in a non-functional driver!\n");
1380         if (irq_type == IRQ_TYPE_EDGE_FALLING ||
1381             irq_type == IRQ_TYPE_LEVEL_LOW)
1382                 irq_pol = IRQ_ACTIVE_LOW;
1383
1384         rc = at86rf230_write_subreg(lp, SR_IRQ_POLARITY, irq_pol);
1385         if (rc)
1386                 return rc;
1387
1388         rc = at86rf230_write_subreg(lp, SR_RX_SAFE_MODE, 1);
1389         if (rc)
1390                 return rc;
1391
1392         rc = at86rf230_write_subreg(lp, SR_IRQ_MASK, IRQ_TRX_END);
1393         if (rc)
1394                 return rc;
1395
1396         /* reset values differs in at86rf231 and at86rf233 */
1397         rc = at86rf230_write_subreg(lp, SR_IRQ_MASK_MODE, 0);
1398         if (rc)
1399                 return rc;
1400
1401         get_random_bytes(csma_seed, ARRAY_SIZE(csma_seed));
1402         rc = at86rf230_write_subreg(lp, SR_CSMA_SEED_0, csma_seed[0]);
1403         if (rc)
1404                 return rc;
1405         rc = at86rf230_write_subreg(lp, SR_CSMA_SEED_1, csma_seed[1]);
1406         if (rc)
1407                 return rc;
1408
1409         /* CLKM changes are applied immediately */
1410         rc = at86rf230_write_subreg(lp, SR_CLKM_SHA_SEL, 0x00);
1411         if (rc)
1412                 return rc;
1413
1414         /* Turn CLKM Off */
1415         rc = at86rf230_write_subreg(lp, SR_CLKM_CTRL, 0x00);
1416         if (rc)
1417                 return rc;
1418         /* Wait the next SLEEP cycle */
1419         usleep_range(lp->data->t_sleep_cycle,
1420                      lp->data->t_sleep_cycle + 100);
1421
1422         /* xtal_trim value is calculated by:
1423          * CL = 0.5 * (CX + CTRIM + CPAR)
1424          *
1425          * whereas:
1426          * CL = capacitor of used crystal
1427          * CX = connected capacitors at xtal pins
1428          * CPAR = in all at86rf2xx datasheets this is a constant value 3 pF,
1429          *        but this is different on each board setup. You need to fine
1430          *        tuning this value via CTRIM.
1431          * CTRIM = variable capacitor setting. Resolution is 0.3 pF range is
1432          *         0 pF upto 4.5 pF.
1433          *
1434          * Examples:
1435          * atben transceiver:
1436          *
1437          * CL = 8 pF
1438          * CX = 12 pF
1439          * CPAR = 3 pF (We assume the magic constant from datasheet)
1440          * CTRIM = 0.9 pF
1441          *
1442          * (12+0.9+3)/2 = 7.95 which is nearly at 8 pF
1443          *
1444          * xtal_trim = 0x3
1445          *
1446          * openlabs transceiver:
1447          *
1448          * CL = 16 pF
1449          * CX = 22 pF
1450          * CPAR = 3 pF (We assume the magic constant from datasheet)
1451          * CTRIM = 4.5 pF
1452          *
1453          * (22+4.5+3)/2 = 14.75 which is the nearest value to 16 pF
1454          *
1455          * xtal_trim = 0xf
1456          */
1457         rc = at86rf230_write_subreg(lp, SR_XTAL_TRIM, xtal_trim);
1458         if (rc)
1459                 return rc;
1460
1461         rc = at86rf230_read_subreg(lp, SR_DVDD_OK, &dvdd);
1462         if (rc)
1463                 return rc;
1464         if (!dvdd) {
1465                 dev_err(&lp->spi->dev, "DVDD error\n");
1466                 return -EINVAL;
1467         }
1468
1469         /* Force setting slotted operation bit to 0. Sometimes the atben
1470          * sets this bit and I don't know why. We set this always force
1471          * to zero while probing.
1472          */
1473         return at86rf230_write_subreg(lp, SR_SLOTTED_OPERATION, 0);
1474 }
1475
1476 static int
1477 at86rf230_get_pdata(struct spi_device *spi, int *rstn, int *slp_tr,
1478                     u8 *xtal_trim)
1479 {
1480         struct at86rf230_platform_data *pdata = spi->dev.platform_data;
1481         int ret;
1482
1483         if (!IS_ENABLED(CONFIG_OF) || !spi->dev.of_node) {
1484                 if (!pdata)
1485                         return -ENOENT;
1486
1487                 *rstn = pdata->rstn;
1488                 *slp_tr = pdata->slp_tr;
1489                 *xtal_trim = pdata->xtal_trim;
1490                 return 0;
1491         }
1492
1493         *rstn = of_get_named_gpio(spi->dev.of_node, "reset-gpio", 0);
1494         *slp_tr = of_get_named_gpio(spi->dev.of_node, "sleep-gpio", 0);
1495         ret = of_property_read_u8(spi->dev.of_node, "xtal-trim", xtal_trim);
1496         if (ret < 0 && ret != -EINVAL)
1497                 return ret;
1498
1499         return 0;
1500 }
1501
1502 static int
1503 at86rf230_detect_device(struct at86rf230_local *lp)
1504 {
1505         unsigned int part, version, val;
1506         u16 man_id = 0;
1507         const char *chip;
1508         int rc;
1509
1510         rc = __at86rf230_read(lp, RG_MAN_ID_0, &val);
1511         if (rc)
1512                 return rc;
1513         man_id |= val;
1514
1515         rc = __at86rf230_read(lp, RG_MAN_ID_1, &val);
1516         if (rc)
1517                 return rc;
1518         man_id |= (val << 8);
1519
1520         rc = __at86rf230_read(lp, RG_PART_NUM, &part);
1521         if (rc)
1522                 return rc;
1523
1524         rc = __at86rf230_read(lp, RG_VERSION_NUM, &version);
1525         if (rc)
1526                 return rc;
1527
1528         if (man_id != 0x001f) {
1529                 dev_err(&lp->spi->dev, "Non-Atmel dev found (MAN_ID %02x %02x)\n",
1530                         man_id >> 8, man_id & 0xFF);
1531                 return -EINVAL;
1532         }
1533
1534         lp->hw->flags = IEEE802154_HW_TX_OMIT_CKSUM |
1535                         IEEE802154_HW_CSMA_PARAMS |
1536                         IEEE802154_HW_FRAME_RETRIES | IEEE802154_HW_AFILT |
1537                         IEEE802154_HW_PROMISCUOUS;
1538
1539         lp->hw->phy->flags = WPAN_PHY_FLAG_TXPOWER |
1540                              WPAN_PHY_FLAG_CCA_ED_LEVEL |
1541                              WPAN_PHY_FLAG_CCA_MODE;
1542
1543         lp->hw->phy->supported.cca_modes = BIT(NL802154_CCA_ENERGY) |
1544                 BIT(NL802154_CCA_CARRIER) | BIT(NL802154_CCA_ENERGY_CARRIER);
1545         lp->hw->phy->supported.cca_opts = BIT(NL802154_CCA_OPT_ENERGY_CARRIER_AND) |
1546                 BIT(NL802154_CCA_OPT_ENERGY_CARRIER_OR);
1547
1548         lp->hw->phy->supported.cca_ed_levels = at86rf23x_ed_levels;
1549         lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf23x_ed_levels);
1550
1551         lp->hw->phy->cca.mode = NL802154_CCA_ENERGY;
1552
1553         switch (part) {
1554         case 2:
1555                 chip = "at86rf230";
1556                 rc = -ENOTSUPP;
1557                 goto not_supp;
1558         case 3:
1559                 chip = "at86rf231";
1560                 lp->data = &at86rf231_data;
1561                 lp->hw->phy->supported.channels[0] = 0x7FFF800;
1562                 lp->hw->phy->current_channel = 11;
1563                 lp->hw->phy->symbol_duration = 16;
1564                 lp->hw->phy->supported.tx_powers = at86rf231_powers;
1565                 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf231_powers);
1566                 break;
1567         case 7:
1568                 chip = "at86rf212";
1569                 lp->data = &at86rf212_data;
1570                 lp->hw->flags |= IEEE802154_HW_LBT;
1571                 lp->hw->phy->supported.channels[0] = 0x00007FF;
1572                 lp->hw->phy->supported.channels[2] = 0x00007FF;
1573                 lp->hw->phy->current_channel = 5;
1574                 lp->hw->phy->symbol_duration = 25;
1575                 lp->hw->phy->supported.lbt = NL802154_SUPPORTED_BOOL_BOTH;
1576                 lp->hw->phy->supported.tx_powers = at86rf212_powers;
1577                 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf212_powers);
1578                 lp->hw->phy->supported.cca_ed_levels = at86rf212_ed_levels_100;
1579                 lp->hw->phy->supported.cca_ed_levels_size = ARRAY_SIZE(at86rf212_ed_levels_100);
1580                 break;
1581         case 11:
1582                 chip = "at86rf233";
1583                 lp->data = &at86rf233_data;
1584                 lp->hw->phy->supported.channels[0] = 0x7FFF800;
1585                 lp->hw->phy->current_channel = 13;
1586                 lp->hw->phy->symbol_duration = 16;
1587                 lp->hw->phy->supported.tx_powers = at86rf233_powers;
1588                 lp->hw->phy->supported.tx_powers_size = ARRAY_SIZE(at86rf233_powers);
1589                 break;
1590         default:
1591                 chip = "unknown";
1592                 rc = -ENOTSUPP;
1593                 goto not_supp;
1594         }
1595
1596         lp->hw->phy->cca_ed_level = lp->hw->phy->supported.cca_ed_levels[7];
1597         lp->hw->phy->transmit_power = lp->hw->phy->supported.tx_powers[0];
1598
1599 not_supp:
1600         dev_info(&lp->spi->dev, "Detected %s chip version %d\n", chip, version);
1601
1602         return rc;
1603 }
1604
1605 static void
1606 at86rf230_setup_spi_messages(struct at86rf230_local *lp)
1607 {
1608         lp->state.lp = lp;
1609         lp->state.irq = lp->spi->irq;
1610         spi_message_init(&lp->state.msg);
1611         lp->state.msg.context = &lp->state;
1612         lp->state.trx.len = 2;
1613         lp->state.trx.tx_buf = lp->state.buf;
1614         lp->state.trx.rx_buf = lp->state.buf;
1615         spi_message_add_tail(&lp->state.trx, &lp->state.msg);
1616         hrtimer_init(&lp->state.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1617         lp->state.timer.function = at86rf230_async_state_timer;
1618
1619         lp->irq.lp = lp;
1620         lp->irq.irq = lp->spi->irq;
1621         spi_message_init(&lp->irq.msg);
1622         lp->irq.msg.context = &lp->irq;
1623         lp->irq.trx.len = 2;
1624         lp->irq.trx.tx_buf = lp->irq.buf;
1625         lp->irq.trx.rx_buf = lp->irq.buf;
1626         spi_message_add_tail(&lp->irq.trx, &lp->irq.msg);
1627         hrtimer_init(&lp->irq.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1628         lp->irq.timer.function = at86rf230_async_state_timer;
1629
1630         lp->tx.lp = lp;
1631         lp->tx.irq = lp->spi->irq;
1632         spi_message_init(&lp->tx.msg);
1633         lp->tx.msg.context = &lp->tx;
1634         lp->tx.trx.len = 2;
1635         lp->tx.trx.tx_buf = lp->tx.buf;
1636         lp->tx.trx.rx_buf = lp->tx.buf;
1637         spi_message_add_tail(&lp->tx.trx, &lp->tx.msg);
1638         hrtimer_init(&lp->tx.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1639         lp->tx.timer.function = at86rf230_async_state_timer;
1640 }
1641
1642 #ifdef CONFIG_IEEE802154_AT86RF230_DEBUGFS
1643 static struct dentry *at86rf230_debugfs_root;
1644
1645 static int at86rf230_stats_show(struct seq_file *file, void *offset)
1646 {
1647         struct at86rf230_local *lp = file->private;
1648
1649         seq_printf(file, "SUCCESS:\t\t%8llu\n", lp->trac.success);
1650         seq_printf(file, "SUCCESS_DATA_PENDING:\t%8llu\n",
1651                    lp->trac.success_data_pending);
1652         seq_printf(file, "SUCCESS_WAIT_FOR_ACK:\t%8llu\n",
1653                    lp->trac.success_wait_for_ack);
1654         seq_printf(file, "CHANNEL_ACCESS_FAILURE:\t%8llu\n",
1655                    lp->trac.channel_access_failure);
1656         seq_printf(file, "NO_ACK:\t\t\t%8llu\n", lp->trac.no_ack);
1657         seq_printf(file, "INVALID:\t\t%8llu\n", lp->trac.invalid);
1658         return 0;
1659 }
1660
1661 static int at86rf230_stats_open(struct inode *inode, struct file *file)
1662 {
1663         return single_open(file, at86rf230_stats_show, inode->i_private);
1664 }
1665
1666 static const struct file_operations at86rf230_stats_fops = {
1667         .open           = at86rf230_stats_open,
1668         .read           = seq_read,
1669         .llseek         = seq_lseek,
1670         .release        = single_release,
1671 };
1672
1673 static int at86rf230_debugfs_init(struct at86rf230_local *lp)
1674 {
1675         char debugfs_dir_name[DNAME_INLINE_LEN + 1] = "at86rf230-";
1676         struct dentry *stats;
1677
1678         strncat(debugfs_dir_name, dev_name(&lp->spi->dev), DNAME_INLINE_LEN);
1679
1680         at86rf230_debugfs_root = debugfs_create_dir(debugfs_dir_name, NULL);
1681         if (!at86rf230_debugfs_root)
1682                 return -ENOMEM;
1683
1684         stats = debugfs_create_file("trac_stats", S_IRUGO,
1685                                     at86rf230_debugfs_root, lp,
1686                                     &at86rf230_stats_fops);
1687         if (!stats)
1688                 return -ENOMEM;
1689
1690         return 0;
1691 }
1692
1693 static void at86rf230_debugfs_remove(void)
1694 {
1695         debugfs_remove_recursive(at86rf230_debugfs_root);
1696 }
1697 #else
1698 static int at86rf230_debugfs_init(struct at86rf230_local *lp) { return 0; }
1699 static void at86rf230_debugfs_remove(void) { }
1700 #endif
1701
1702 static int at86rf230_probe(struct spi_device *spi)
1703 {
1704         struct ieee802154_hw *hw;
1705         struct at86rf230_local *lp;
1706         unsigned int status;
1707         int rc, irq_type, rstn, slp_tr;
1708         u8 xtal_trim = 0;
1709
1710         if (!spi->irq) {
1711                 dev_err(&spi->dev, "no IRQ specified\n");
1712                 return -EINVAL;
1713         }
1714
1715         rc = at86rf230_get_pdata(spi, &rstn, &slp_tr, &xtal_trim);
1716         if (rc < 0) {
1717                 dev_err(&spi->dev, "failed to parse platform_data: %d\n", rc);
1718                 return rc;
1719         }
1720
1721         if (gpio_is_valid(rstn)) {
1722                 rc = devm_gpio_request_one(&spi->dev, rstn,
1723                                            GPIOF_OUT_INIT_HIGH, "rstn");
1724                 if (rc)
1725                         return rc;
1726         }
1727
1728         if (gpio_is_valid(slp_tr)) {
1729                 rc = devm_gpio_request_one(&spi->dev, slp_tr,
1730                                            GPIOF_OUT_INIT_LOW, "slp_tr");
1731                 if (rc)
1732                         return rc;
1733         }
1734
1735         /* Reset */
1736         if (gpio_is_valid(rstn)) {
1737                 udelay(1);
1738                 gpio_set_value(rstn, 0);
1739                 udelay(1);
1740                 gpio_set_value(rstn, 1);
1741                 usleep_range(120, 240);
1742         }
1743
1744         hw = ieee802154_alloc_hw(sizeof(*lp), &at86rf230_ops);
1745         if (!hw)
1746                 return -ENOMEM;
1747
1748         lp = hw->priv;
1749         lp->hw = hw;
1750         lp->spi = spi;
1751         lp->slp_tr = slp_tr;
1752         hw->parent = &spi->dev;
1753         ieee802154_random_extended_addr(&hw->phy->perm_extended_addr);
1754
1755         lp->regmap = devm_regmap_init_spi(spi, &at86rf230_regmap_spi_config);
1756         if (IS_ERR(lp->regmap)) {
1757                 rc = PTR_ERR(lp->regmap);
1758                 dev_err(&spi->dev, "Failed to allocate register map: %d\n",
1759                         rc);
1760                 goto free_dev;
1761         }
1762
1763         at86rf230_setup_spi_messages(lp);
1764
1765         rc = at86rf230_detect_device(lp);
1766         if (rc < 0)
1767                 goto free_dev;
1768
1769         init_completion(&lp->state_complete);
1770
1771         spi_set_drvdata(spi, lp);
1772
1773         rc = at86rf230_hw_init(lp, xtal_trim);
1774         if (rc)
1775                 goto free_dev;
1776
1777         /* Read irq status register to reset irq line */
1778         rc = at86rf230_read_subreg(lp, RG_IRQ_STATUS, 0xff, 0, &status);
1779         if (rc)
1780                 goto free_dev;
1781
1782         irq_type = irq_get_trigger_type(spi->irq);
1783         if (!irq_type)
1784                 irq_type = IRQF_TRIGGER_HIGH;
1785
1786         rc = devm_request_irq(&spi->dev, spi->irq, at86rf230_isr,
1787                               IRQF_SHARED | irq_type, dev_name(&spi->dev), lp);
1788         if (rc)
1789                 goto free_dev;
1790
1791         /* disable_irq by default and wait for starting hardware */
1792         disable_irq(spi->irq);
1793
1794         /* going into sleep by default */
1795         at86rf230_sleep(lp);
1796
1797         rc = at86rf230_debugfs_init(lp);
1798         if (rc)
1799                 goto free_dev;
1800
1801         rc = ieee802154_register_hw(lp->hw);
1802         if (rc)
1803                 goto free_debugfs;
1804
1805         return rc;
1806
1807 free_debugfs:
1808         at86rf230_debugfs_remove();
1809 free_dev:
1810         ieee802154_free_hw(lp->hw);
1811
1812         return rc;
1813 }
1814
1815 static int at86rf230_remove(struct spi_device *spi)
1816 {
1817         struct at86rf230_local *lp = spi_get_drvdata(spi);
1818
1819         /* mask all at86rf230 irq's */
1820         at86rf230_write_subreg(lp, SR_IRQ_MASK, 0);
1821         ieee802154_unregister_hw(lp->hw);
1822         ieee802154_free_hw(lp->hw);
1823         at86rf230_debugfs_remove();
1824         dev_dbg(&spi->dev, "unregistered at86rf230\n");
1825
1826         return 0;
1827 }
1828
1829 static const struct of_device_id at86rf230_of_match[] = {
1830         { .compatible = "atmel,at86rf230", },
1831         { .compatible = "atmel,at86rf231", },
1832         { .compatible = "atmel,at86rf233", },
1833         { .compatible = "atmel,at86rf212", },
1834         { },
1835 };
1836 MODULE_DEVICE_TABLE(of, at86rf230_of_match);
1837
1838 static const struct spi_device_id at86rf230_device_id[] = {
1839         { .name = "at86rf230", },
1840         { .name = "at86rf231", },
1841         { .name = "at86rf233", },
1842         { .name = "at86rf212", },
1843         { },
1844 };
1845 MODULE_DEVICE_TABLE(spi, at86rf230_device_id);
1846
1847 static struct spi_driver at86rf230_driver = {
1848         .id_table = at86rf230_device_id,
1849         .driver = {
1850                 .of_match_table = of_match_ptr(at86rf230_of_match),
1851                 .name   = "at86rf230",
1852                 .owner  = THIS_MODULE,
1853         },
1854         .probe      = at86rf230_probe,
1855         .remove     = at86rf230_remove,
1856 };
1857
1858 module_spi_driver(at86rf230_driver);
1859
1860 MODULE_DESCRIPTION("AT86RF230 Transceiver Driver");
1861 MODULE_LICENSE("GPL v2");