drivers/net/ieee802154/ca8210.c

   1 /*
   2  * http://www.cascoda.com/products/ca-821x/
   3  * Copyright (c) 2016, Cascoda, Ltd.
   4  * All rights reserved.
   5  *
   6  * This code is dual-licensed under both GPLv2 and 3-clause BSD. What follows is
   7  * the license notice for both respectively.
   8  *
   9  *******************************************************************************
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  *******************************************************************************
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions are met:
  25  *
  26  * 1. Redistributions of source code must retain the above copyright notice,
  27  * this list of conditions and the following disclaimer.
  28  *
  29  * 2. Redistributions in binary form must reproduce the above copyright notice,
  30  * this list of conditions and the following disclaimer in the documentation
  31  * and/or other materials provided with the distribution.
  32  *
  33  * 3. Neither the name of the copyright holder nor the names of its contributors
  34  * may be used to endorse or promote products derived from this software without
  35  * specific prior written permission.
  36  *
  37  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  38  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  39  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  40  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
  41  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  42  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  43  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  44  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  45  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  47  * POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50 #include <linux/cdev.h>
  51 #include <linux/clk-provider.h>
  52 #include <linux/debugfs.h>
  53 #include <linux/delay.h>
  54 #include <linux/gpio.h>
  55 #include <linux/ieee802154.h>
  56 #include <linux/io.h>
  57 #include <linux/kfifo.h>
  58 #include <linux/of.h>
  59 #include <linux/of_device.h>
  60 #include <linux/of_gpio.h>
  61 #include <linux/module.h>
  62 #include <linux/mutex.h>
  63 #include <linux/poll.h>
  64 #include <linux/skbuff.h>
  65 #include <linux/slab.h>
  66 #include <linux/spi/spi.h>
  67 #include <linux/spinlock.h>
  68 #include <linux/string.h>
  69 #include <linux/workqueue.h>
  70 #include <linux/interrupt.h>
  71
  72 #include <net/ieee802154_netdev.h>
  73 #include <net/mac802154.h>
  74
  75 #define DRIVER_NAME "ca8210"
  76
  77 /* external clock frequencies */
  78 #define ONE_MHZ      1000000
  79 #define TWO_MHZ      (2 * ONE_MHZ)
  80 #define FOUR_MHZ     (4 * ONE_MHZ)
  81 #define EIGHT_MHZ    (8 * ONE_MHZ)
  82 #define SIXTEEN_MHZ  (16 * ONE_MHZ)
  83
  84 /* spi constants */
  85 #define CA8210_SPI_BUF_SIZE 256
  86 #define CA8210_SYNC_TIMEOUT 1000     /* Timeout for synchronous commands [ms] */
  87
  88 /* test interface constants */
  89 #define CA8210_TEST_INT_FILE_NAME "ca8210_test"
  90 #define CA8210_TEST_INT_FIFO_SIZE 256
  91
  92 /* HWME attribute IDs */
  93 #define HWME_EDTHRESHOLD       (0x04)
  94 #define HWME_EDVALUE           (0x06)
  95 #define HWME_SYSCLKOUT         (0x0F)
  96 #define HWME_LQILIMIT          (0x11)
  97
  98 /* TDME attribute IDs */
  99 #define TDME_CHANNEL          (0x00)
 100 #define TDME_ATM_CONFIG       (0x06)
 101
 102 #define MAX_HWME_ATTRIBUTE_SIZE  16
 103 #define MAX_TDME_ATTRIBUTE_SIZE  2
 104
 105 /* PHY/MAC PIB Attribute Enumerations */
 106 #define PHY_CURRENT_CHANNEL               (0x00)
 107 #define PHY_TRANSMIT_POWER                (0x02)
 108 #define PHY_CCA_MODE                      (0x03)
 109 #define MAC_ASSOCIATION_PERMIT            (0x41)
 110 #define MAC_AUTO_REQUEST                  (0x42)
 111 #define MAC_BATT_LIFE_EXT                 (0x43)
 112 #define MAC_BATT_LIFE_EXT_PERIODS         (0x44)
 113 #define MAC_BEACON_PAYLOAD                (0x45)
 114 #define MAC_BEACON_PAYLOAD_LENGTH         (0x46)
 115 #define MAC_BEACON_ORDER                  (0x47)
 116 #define MAC_GTS_PERMIT                    (0x4d)
 117 #define MAC_MAX_CSMA_BACKOFFS             (0x4e)
 118 #define MAC_MIN_BE                        (0x4f)
 119 #define MAC_PAN_ID                        (0x50)
 120 #define MAC_PROMISCUOUS_MODE              (0x51)
 121 #define MAC_RX_ON_WHEN_IDLE               (0x52)
 122 #define MAC_SHORT_ADDRESS                 (0x53)
 123 #define MAC_SUPERFRAME_ORDER              (0x54)
 124 #define MAC_ASSOCIATED_PAN_COORD          (0x56)
 125 #define MAC_MAX_BE                        (0x57)
 126 #define MAC_MAX_FRAME_RETRIES             (0x59)
 127 #define MAC_RESPONSE_WAIT_TIME            (0x5A)
 128 #define MAC_SECURITY_ENABLED              (0x5D)
 129
 130 #define MAC_AUTO_REQUEST_SECURITY_LEVEL   (0x78)
 131 #define MAC_AUTO_REQUEST_KEY_ID_MODE      (0x79)
 132
 133 #define NS_IEEE_ADDRESS                   (0xFF) /* Non-standard IEEE address */
 134
 135 /* MAC Address Mode Definitions */
 136 #define MAC_MODE_NO_ADDR                (0x00)
 137 #define MAC_MODE_SHORT_ADDR             (0x02)
 138 #define MAC_MODE_LONG_ADDR              (0x03)
 139
 140 /* MAC constants */
 141 #define MAX_BEACON_OVERHEAD        (75)
 142 #define MAX_BEACON_PAYLOAD_LENGTH  (IEEE802154_MTU - MAX_BEACON_OVERHEAD)
 143
 144 #define MAX_ATTRIBUTE_SIZE              (122)
 145 #define MAX_DATA_SIZE                   (114)
 146
 147 #define CA8210_VALID_CHANNELS                 (0x07FFF800)
 148
 149 /* MAC workarounds for V1.1 and MPW silicon (V0.x) */
 150 #define CA8210_MAC_WORKAROUNDS (0)
 151 #define CA8210_MAC_MPW         (0)
 152
 153 /* memory manipulation macros */
 154 #define LS_BYTE(x)     ((u8)((x) & 0xFF))
 155 #define MS_BYTE(x)     ((u8)(((x) >> 8) & 0xFF))
 156
 157 /* message ID codes in SPI commands */
 158 /* downstream */
 159 #define MCPS_DATA_REQUEST                     (0x00)
 160 #define MLME_ASSOCIATE_REQUEST                (0x02)
 161 #define MLME_ASSOCIATE_RESPONSE               (0x03)
 162 #define MLME_DISASSOCIATE_REQUEST             (0x04)
 163 #define MLME_GET_REQUEST                      (0x05)
 164 #define MLME_ORPHAN_RESPONSE                  (0x06)
 165 #define MLME_RESET_REQUEST                    (0x07)
 166 #define MLME_RX_ENABLE_REQUEST                (0x08)
 167 #define MLME_SCAN_REQUEST                     (0x09)
 168 #define MLME_SET_REQUEST                      (0x0A)
 169 #define MLME_START_REQUEST                    (0x0B)
 170 #define MLME_POLL_REQUEST                     (0x0D)
 171 #define HWME_SET_REQUEST                      (0x0E)
 172 #define HWME_GET_REQUEST                      (0x0F)
 173 #define TDME_SETSFR_REQUEST                   (0x11)
 174 #define TDME_GETSFR_REQUEST                   (0x12)
 175 #define TDME_SET_REQUEST                      (0x14)
 176 /* upstream */
 177 #define MCPS_DATA_INDICATION                  (0x00)
 178 #define MCPS_DATA_CONFIRM                     (0x01)
 179 #define MLME_RESET_CONFIRM                    (0x0A)
 180 #define MLME_SET_CONFIRM                      (0x0E)
 181 #define MLME_START_CONFIRM                    (0x0F)
 182 #define HWME_SET_CONFIRM                      (0x12)
 183 #define HWME_GET_CONFIRM                      (0x13)
 184 #define HWME_WAKEUP_INDICATION                (0x15)
 185 #define TDME_SETSFR_CONFIRM                   (0x17)
 186
 187 /* SPI command IDs */
 188 /* bit indicating a confirm or indication from slave to master */
 189 #define SPI_S2M                            (0x20)
 190 /* bit indicating a synchronous message */
 191 #define SPI_SYN                            (0x40)
 192
 193 /* SPI command definitions */
 194 #define SPI_IDLE                           (0xFF)
 195 #define SPI_NACK                           (0xF0)
 196
 197 #define SPI_MCPS_DATA_REQUEST          (MCPS_DATA_REQUEST)
 198 #define SPI_MCPS_DATA_INDICATION       (MCPS_DATA_INDICATION + SPI_S2M)
 199 #define SPI_MCPS_DATA_CONFIRM          (MCPS_DATA_CONFIRM + SPI_S2M)
 200
 201 #define SPI_MLME_ASSOCIATE_REQUEST     (MLME_ASSOCIATE_REQUEST)
 202 #define SPI_MLME_RESET_REQUEST         (MLME_RESET_REQUEST + SPI_SYN)
 203 #define SPI_MLME_SET_REQUEST           (MLME_SET_REQUEST + SPI_SYN)
 204 #define SPI_MLME_START_REQUEST         (MLME_START_REQUEST + SPI_SYN)
 205 #define SPI_MLME_RESET_CONFIRM         (MLME_RESET_CONFIRM + SPI_S2M + SPI_SYN)
 206 #define SPI_MLME_SET_CONFIRM           (MLME_SET_CONFIRM + SPI_S2M + SPI_SYN)
 207 #define SPI_MLME_START_CONFIRM         (MLME_START_CONFIRM + SPI_S2M + SPI_SYN)
 208
 209 #define SPI_HWME_SET_REQUEST           (HWME_SET_REQUEST + SPI_SYN)
 210 #define SPI_HWME_GET_REQUEST           (HWME_GET_REQUEST + SPI_SYN)
 211 #define SPI_HWME_SET_CONFIRM           (HWME_SET_CONFIRM + SPI_S2M + SPI_SYN)
 212 #define SPI_HWME_GET_CONFIRM           (HWME_GET_CONFIRM + SPI_S2M + SPI_SYN)
 213 #define SPI_HWME_WAKEUP_INDICATION     (HWME_WAKEUP_INDICATION + SPI_S2M)
 214
 215 #define SPI_TDME_SETSFR_REQUEST        (TDME_SETSFR_REQUEST + SPI_SYN)
 216 #define SPI_TDME_SET_REQUEST           (TDME_SET_REQUEST + SPI_SYN)
 217 #define SPI_TDME_SETSFR_CONFIRM        (TDME_SETSFR_CONFIRM + SPI_S2M + SPI_SYN)
 218
 219 /* TDME SFR addresses */
 220 /* Page 0 */
 221 #define CA8210_SFR_PACFG                   (0xB1)
 222 #define CA8210_SFR_MACCON                  (0xD8)
 223 #define CA8210_SFR_PACFGIB                 (0xFE)
 224 /* Page 1 */
 225 #define CA8210_SFR_LOTXCAL                 (0xBF)
 226 #define CA8210_SFR_PTHRH                   (0xD1)
 227 #define CA8210_SFR_PRECFG                  (0xD3)
 228 #define CA8210_SFR_LNAGX40                 (0xE1)
 229 #define CA8210_SFR_LNAGX41                 (0xE2)
 230 #define CA8210_SFR_LNAGX42                 (0xE3)
 231 #define CA8210_SFR_LNAGX43                 (0xE4)
 232 #define CA8210_SFR_LNAGX44                 (0xE5)
 233 #define CA8210_SFR_LNAGX45                 (0xE6)
 234 #define CA8210_SFR_LNAGX46                 (0xE7)
 235 #define CA8210_SFR_LNAGX47                 (0xE9)
 236
 237 #define PACFGIB_DEFAULT_CURRENT            (0x3F)
 238 #define PTHRH_DEFAULT_THRESHOLD            (0x5A)
 239 #define LNAGX40_DEFAULT_GAIN               (0x29) /* 10dB */
 240 #define LNAGX41_DEFAULT_GAIN               (0x54) /* 21dB */
 241 #define LNAGX42_DEFAULT_GAIN               (0x6C) /* 27dB */
 242 #define LNAGX43_DEFAULT_GAIN               (0x7A) /* 30dB */
 243 #define LNAGX44_DEFAULT_GAIN               (0x84) /* 33dB */
 244 #define LNAGX45_DEFAULT_GAIN               (0x8B) /* 34dB */
 245 #define LNAGX46_DEFAULT_GAIN               (0x92) /* 36dB */
 246 #define LNAGX47_DEFAULT_GAIN               (0x96) /* 37dB */
 247
 248 #define CA8210_IOCTL_HARD_RESET            (0x00)
 249
 250 /* Structs/Enums */
 251
 252 /**
 253  * struct cas_control - spi transfer structure
 254  * @msg:                  spi_message for each exchange
 255  * @transfer:             spi_transfer for each exchange
 256  * @tx_buf:               source array for transmission
 257  * @tx_in_buf:            array storing bytes received during transmission
 258  * @priv:                 pointer to private data
 259  *
 260  * This structure stores all the necessary data passed around during a single
 261  * spi exchange.
 262  */
 263 struct cas_control {
 264         struct spi_message msg;
 265         struct spi_transfer transfer;
 266
 267         u8 tx_buf[CA8210_SPI_BUF_SIZE];
 268         u8 tx_in_buf[CA8210_SPI_BUF_SIZE];
 269
 270         struct ca8210_priv *priv;
 271 };
 272
 273 /**
 274  * struct ca8210_test - ca8210 test interface structure
 275  * @ca8210_dfs_spi_int: pointer to the entry in the debug fs for this device
 276  * @up_fifo:            fifo for upstream messages
 277  * @readq:              read wait queue
 278  *
 279  * This structure stores all the data pertaining to the debug interface
 280  */
 281 struct ca8210_test {
 282         struct dentry *ca8210_dfs_spi_int;
 283         struct kfifo up_fifo;
 284         wait_queue_head_t readq;
 285 };
 286
 287 /**
 288  * struct ca8210_priv - ca8210 private data structure
 289  * @spi:                    pointer to the ca8210 spi device object
 290  * @hw:                     pointer to the ca8210 ieee802154_hw object
 291  * @hw_registered:          true if hw has been registered with ieee802154
 292  * @lock:                   spinlock protecting the private data area
 293  * @mlme_workqueue:           workqueue for triggering MLME Reset
 294  * @irq_workqueue:          workqueue for irq processing
 295  * @tx_skb:                 current socket buffer to transmit
 296  * @nextmsduhandle:         msdu handle to pass to the 15.4 MAC layer for the
 297  *                           next transmission
 298  * @clk:                    external clock provided by the ca8210
 299  * @last_dsn:               sequence number of last data packet received, for
 300  *                           resend detection
 301  * @test:                   test interface data section for this instance
 302  * @async_tx_pending:       true if an asynchronous transmission was started and
 303  *                           is not complete
 304  * @sync_command_response:  pointer to buffer to fill with sync response
 305  * @ca8210_is_awake:        nonzero if ca8210 is initialised, ready for comms
 306  * @sync_down:              counts number of downstream synchronous commands
 307  * @sync_up:                counts number of upstream synchronous commands
 308  * @spi_transfer_complete:  completion object for a single spi_transfer
 309  * @sync_exchange_complete: completion object for a complete synchronous API
 310  *                          exchange
 311  * @promiscuous:            whether the ca8210 is in promiscuous mode or not
 312  * @retries:                records how many times the current pending spi
 313  *                          transfer has been retried
 314  */
 315 struct ca8210_priv {
 316         struct spi_device *spi;
 317         struct ieee802154_hw *hw;
 318         bool hw_registered;
 319         spinlock_t lock;
 320         struct workqueue_struct *mlme_workqueue;
 321         struct workqueue_struct *irq_workqueue;
 322         struct sk_buff *tx_skb;
 323         u8 nextmsduhandle;
 324         struct clk *clk;
 325         int last_dsn;
 326         struct ca8210_test test;
 327         bool async_tx_pending;
 328         u8 *sync_command_response;
 329         struct completion ca8210_is_awake;
 330         int sync_down, sync_up;
 331         struct completion spi_transfer_complete, sync_exchange_complete;
 332         bool promiscuous;
 333         int retries;
 334 };
 335
 336 /**
 337  * struct work_priv_container - link between a work object and the relevant
 338  *                              device's private data
 339  * @work: work object being executed
 340  * @priv: device's private data section
 341  *
 342  */
 343 struct work_priv_container {
 344         struct work_struct work;
 345         struct ca8210_priv *priv;
 346 };
 347
 348 /**
 349  * struct ca8210_platform_data - ca8210 platform data structure
 350  * @extclockenable: true if the external clock is to be enabled
 351  * @extclockfreq:   frequency of the external clock
 352  * @extclockgpio:   ca8210 output gpio of the external clock
 353  * @gpio_reset:     gpio number of ca8210 reset line
 354  * @gpio_irq:       gpio number of ca8210 interrupt line
 355  * @irq_id:         identifier for the ca8210 irq
 356  *
 357  */
 358 struct ca8210_platform_data {
 359         bool extclockenable;
 360         unsigned int extclockfreq;
 361         unsigned int extclockgpio;
 362         int gpio_reset;
 363         int gpio_irq;
 364         int irq_id;
 365 };
 366
 367 /**
 368  * struct fulladdr - full MAC addressing information structure
 369  * @mode:    address mode (none, short, extended)
 370  * @pan_id:  16-bit LE pan id
 371  * @address: LE address, variable length as specified by mode
 372  *
 373  */
 374 struct fulladdr {
 375         u8         mode;
 376         u8         pan_id[2];
 377         u8         address[8];
 378 };
 379
 380 /**
 381  * union macaddr: generic MAC address container
 382  * @short_address: 16-bit short address
 383  * @ieee_address:  64-bit extended address as LE byte array
 384  *
 385  */
 386 union macaddr {
 387         u16        short_address;
 388         u8         ieee_address[8];
 389 };
 390
 391 /**
 392  * struct secspec: security specification for SAP commands
 393  * @security_level: 0-7, controls level of authentication & encryption
 394  * @key_id_mode:    0-3, specifies how to obtain key
 395  * @key_source:     extended key retrieval data
 396  * @key_index:      single-byte key identifier
 397  *
 398  */
 399 struct secspec {
 400         u8         security_level;
 401         u8         key_id_mode;
 402         u8         key_source[8];
 403         u8         key_index;
 404 };
 405
 406 /* downlink functions parameter set definitions */
 407 struct mcps_data_request_pset {
 408         u8              src_addr_mode;
 409         struct fulladdr dst;
 410         u8              msdu_length;
 411         u8              msdu_handle;
 412         u8              tx_options;
 413         u8              msdu[MAX_DATA_SIZE];
 414 };
 415
 416 struct mlme_set_request_pset {
 417         u8         pib_attribute;
 418         u8         pib_attribute_index;
 419         u8         pib_attribute_length;
 420         u8         pib_attribute_value[MAX_ATTRIBUTE_SIZE];
 421 };
 422
 423 struct hwme_set_request_pset {
 424         u8         hw_attribute;
 425         u8         hw_attribute_length;
 426         u8         hw_attribute_value[MAX_HWME_ATTRIBUTE_SIZE];
 427 };
 428
 429 struct hwme_get_request_pset {
 430         u8         hw_attribute;
 431 };
 432
 433 struct tdme_setsfr_request_pset {
 434         u8         sfr_page;
 435         u8         sfr_address;
 436         u8         sfr_value;
 437 };
 438
 439 /* uplink functions parameter set definitions */
 440 struct hwme_set_confirm_pset {
 441         u8         status;
 442         u8         hw_attribute;
 443 };
 444
 445 struct hwme_get_confirm_pset {
 446         u8         status;
 447         u8         hw_attribute;
 448         u8         hw_attribute_length;
 449         u8         hw_attribute_value[MAX_HWME_ATTRIBUTE_SIZE];
 450 };
 451
 452 struct tdme_setsfr_confirm_pset {
 453         u8         status;
 454         u8         sfr_page;
 455         u8         sfr_address;
 456 };
 457
 458 struct mac_message {
 459         u8      command_id;
 460         u8      length;
 461         union {
 462                 struct mcps_data_request_pset       data_req;
 463                 struct mlme_set_request_pset        set_req;
 464                 struct hwme_set_request_pset        hwme_set_req;
 465                 struct hwme_get_request_pset        hwme_get_req;
 466                 struct tdme_setsfr_request_pset     tdme_set_sfr_req;
 467                 struct hwme_set_confirm_pset        hwme_set_cnf;
 468                 struct hwme_get_confirm_pset        hwme_get_cnf;
 469                 struct tdme_setsfr_confirm_pset     tdme_set_sfr_cnf;
 470                 u8                                  u8param;
 471                 u8                                  status;
 472                 u8                                  payload[148];
 473         } pdata;
 474 };
 475
 476 union pa_cfg_sfr {
 477         struct {
 478                 u8 bias_current_trim     : 3;
 479                 u8 /* reserved */        : 1;
 480                 u8 buffer_capacitor_trim : 3;
 481                 u8 boost                 : 1;
 482         };
 483         u8 paib;
 484 };
 485
 486 struct preamble_cfg_sfr {
 487         u8 timeout_symbols      : 3;
 488         u8 acquisition_symbols  : 3;
 489         u8 search_symbols       : 2;
 490 };
 491
 492 static int (*cascoda_api_upstream)(
 493         const u8 *buf,
 494         size_t len,
 495         void *device_ref
 496 );
 497
 498 /**
 499  * link_to_linux_err() - Translates an 802.15.4 return code into the closest
 500  *                       linux error
 501  * @link_status:  802.15.4 status code
 502  *
 503  * Return: 0 or Linux error code
 504  */
 505 static int link_to_linux_err(int link_status)
 506 {
 507         if (link_status < 0) {
 508                 /* status is already a Linux code */
 509                 return link_status;
 510         }
 511         switch (link_status) {
 512         case IEEE802154_SUCCESS:
 513         case IEEE802154_REALIGNMENT:
 514                 return 0;
 515         case IEEE802154_IMPROPER_KEY_TYPE:
 516                 return -EKEYREJECTED;
 517         case IEEE802154_IMPROPER_SECURITY_LEVEL:
 518         case IEEE802154_UNSUPPORTED_LEGACY:
 519         case IEEE802154_DENIED:
 520                 return -EACCES;
 521         case IEEE802154_BEACON_LOST:
 522         case IEEE802154_NO_ACK:
 523         case IEEE802154_NO_BEACON:
 524                 return -ENETUNREACH;
 525         case IEEE802154_CHANNEL_ACCESS_FAILURE:
 526         case IEEE802154_TX_ACTIVE:
 527         case IEEE802154_SCAN_IN_PROGRESS:
 528                 return -EBUSY;
 529         case IEEE802154_DISABLE_TRX_FAILURE:
 530         case IEEE802154_OUT_OF_CAP:
 531                 return -EAGAIN;
 532         case IEEE802154_FRAME_TOO_LONG:
 533                 return -EMSGSIZE;
 534         case IEEE802154_INVALID_GTS:
 535         case IEEE802154_PAST_TIME:
 536                 return -EBADSLT;
 537         case IEEE802154_INVALID_HANDLE:
 538                 return -EBADMSG;
 539         case IEEE802154_INVALID_PARAMETER:
 540         case IEEE802154_UNSUPPORTED_ATTRIBUTE:
 541         case IEEE802154_ON_TIME_TOO_LONG:
 542         case IEEE802154_INVALID_INDEX:
 543                 return -EINVAL;
 544         case IEEE802154_NO_DATA:
 545                 return -ENODATA;
 546         case IEEE802154_NO_SHORT_ADDRESS:
 547                 return -EFAULT;
 548         case IEEE802154_PAN_ID_CONFLICT:
 549                 return -EADDRINUSE;
 550         case IEEE802154_TRANSACTION_EXPIRED:
 551                 return -ETIME;
 552         case IEEE802154_TRANSACTION_OVERFLOW:
 553                 return -ENOBUFS;
 554         case IEEE802154_UNAVAILABLE_KEY:
 555                 return -ENOKEY;
 556         case IEEE802154_INVALID_ADDRESS:
 557                 return -ENXIO;
 558         case IEEE802154_TRACKING_OFF:
 559         case IEEE802154_SUPERFRAME_OVERLAP:
 560                 return -EREMOTEIO;
 561         case IEEE802154_LIMIT_REACHED:
 562                 return -EDQUOT;
 563         case IEEE802154_READ_ONLY:
 564                 return -EROFS;
 565         default:
 566                 return -EPROTO;
 567         }
 568 }
 569
 570 /**
 571  * ca8210_test_int_driver_write() - Writes a message to the test interface to be
 572  *                                  read by the userspace
 573  * @buf:  Buffer containing upstream message
 574  * @len:  length of message to write
 575  * @spi:  SPI device of message originator
 576  *
 577  * Return: 0 or linux error code
 578  */
 579 static int ca8210_test_int_driver_write(
 580         const u8       *buf,
 581         size_t          len,
 582         void           *spi
 583 )
 584 {
 585         struct ca8210_priv *priv = spi_get_drvdata(spi);
 586         struct ca8210_test *test = &priv->test;
 587         char *fifo_buffer;
 588         int i;
 589
 590         dev_dbg(
 591                 &priv->spi->dev,
 592                 "test_interface: Buffering upstream message:\n"
 593         );
 594         for (i = 0; i < len; i++)
 595                 dev_dbg(&priv->spi->dev, "%#03x\n", buf[i]);
 596
 597         fifo_buffer = kmemdup(buf, len, GFP_KERNEL);
 598         if (!fifo_buffer)
 599                 return -ENOMEM;
 600         kfifo_in(&test->up_fifo, &fifo_buffer, 4);
 601         wake_up_interruptible(&priv->test.readq);
 602
 603         return 0;
 604 }
 605
 606 /* SPI Operation */
 607
 608 static int ca8210_net_rx(
 609         struct ieee802154_hw  *hw,
 610         u8                    *command,
 611         size_t                 len
 612 );
 613 static u8 mlme_reset_request_sync(
 614         u8       set_default_pib,
 615         void    *device_ref
 616 );
 617 static int ca8210_spi_transfer(
 618         struct spi_device *spi,
 619         const u8          *buf,
 620         size_t             len
 621 );
 622
 623 /**
 624  * ca8210_reset_send() - Hard resets the ca8210 for a given time
 625  * @spi:  Pointer to target ca8210 spi device
 626  * @ms:   Milliseconds to hold the reset line low for
 627  */
 628 static void ca8210_reset_send(struct spi_device *spi, unsigned int ms)
 629 {
 630         struct ca8210_platform_data *pdata = spi->dev.platform_data;
 631         struct ca8210_priv *priv = spi_get_drvdata(spi);
 632         long status;
 633
 634         gpio_set_value(pdata->gpio_reset, 0);
 635         reinit_completion(&priv->ca8210_is_awake);
 636         msleep(ms);
 637         gpio_set_value(pdata->gpio_reset, 1);
 638         priv->promiscuous = false;
 639
 640         /* Wait until wakeup indication seen */
 641         status = wait_for_completion_interruptible_timeout(
 642                 &priv->ca8210_is_awake,
 643                 msecs_to_jiffies(CA8210_SYNC_TIMEOUT)
 644         );
 645         if (status == 0) {
 646                 dev_crit(
 647                         &spi->dev,
 648                         "Fatal: No wakeup from ca8210 after reset!\n"
 649                 );
 650         }
 651
 652         dev_dbg(&spi->dev, "Reset the device\n");
 653 }
 654
 655 /**
 656  * ca8210_mlme_reset_worker() - Resets the MLME, Called when the MAC OVERFLOW
 657  *                              condition happens.
 658  * @work:  Pointer to work being executed
 659  */
 660 static void ca8210_mlme_reset_worker(struct work_struct *work)
 661 {
 662         struct work_priv_container *wpc = container_of(
 663                 work,
 664                 struct work_priv_container,
 665                 work
 666         );
 667         struct ca8210_priv *priv = wpc->priv;
 668
 669         mlme_reset_request_sync(0, priv->spi);
 670         kfree(wpc);
 671 }
 672
 673 /**
 674  * ca8210_rx_done() - Calls various message dispatches responding to a received
 675  *                    command
 676  * @cas_ctl: Pointer to the cas_control object for the relevant spi transfer
 677  *
 678  * Presents a received SAP command from the ca8210 to the Cascoda EVBME, test
 679  * interface and network driver.
 680  */
 681 static void ca8210_rx_done(struct cas_control *cas_ctl)
 682 {
 683         u8 *buf;
 684         unsigned int len;
 685         struct work_priv_container *mlme_reset_wpc;
 686         struct ca8210_priv *priv = cas_ctl->priv;
 687
 688         buf = cas_ctl->tx_in_buf;
 689         len = buf[1] + 2;
 690         if (len > CA8210_SPI_BUF_SIZE) {
 691                 dev_crit(
 692                         &priv->spi->dev,
 693                         "Received packet len (%u) erroneously long\n",
 694                         len
 695                 );
 696                 goto finish;
 697         }
 698
 699         if (buf[0] & SPI_SYN) {
 700                 if (priv->sync_command_response) {
 701                         memcpy(priv->sync_command_response, buf, len);
 702                         complete(&priv->sync_exchange_complete);
 703                 } else {
 704                         if (cascoda_api_upstream)
 705                                 cascoda_api_upstream(buf, len, priv->spi);
 706                         priv->sync_up++;
 707                 }
 708         } else {
 709                 if (cascoda_api_upstream)
 710                         cascoda_api_upstream(buf, len, priv->spi);
 711         }
 712
 713         ca8210_net_rx(priv->hw, buf, len);
 714         if (buf[0] == SPI_MCPS_DATA_CONFIRM) {
 715                 if (buf[3] == IEEE802154_TRANSACTION_OVERFLOW) {
 716                         dev_info(
 717                                 &priv->spi->dev,
 718                                 "Waiting for transaction overflow to stabilise...\n");
 719                         msleep(2000);
 720                         dev_info(
 721                                 &priv->spi->dev,
 722                                 "Resetting MAC...\n");
 723
 724                         mlme_reset_wpc = kmalloc(sizeof(*mlme_reset_wpc),
 725                                                  GFP_KERNEL);
 726                         if (!mlme_reset_wpc)
 727                                 goto finish;
 728                         INIT_WORK(
 729                                 &mlme_reset_wpc->work,
 730                                 ca8210_mlme_reset_worker
 731                         );
 732                         mlme_reset_wpc->priv = priv;
 733                         queue_work(priv->mlme_workqueue, &mlme_reset_wpc->work);
 734                 }
 735         } else if (buf[0] == SPI_HWME_WAKEUP_INDICATION) {
 736                 dev_notice(
 737                         &priv->spi->dev,
 738                         "Wakeup indication received, reason:\n"
 739                 );
 740                 switch (buf[2]) {
 741                 case 0:
 742                         dev_notice(
 743                                 &priv->spi->dev,
 744                                 "Transceiver woken up from Power Up / System Reset\n"
 745                         );
 746                         break;
 747                 case 1:
 748                         dev_notice(
 749                                 &priv->spi->dev,
 750                                 "Watchdog Timer Time-Out\n"
 751                         );
 752                         break;
 753                 case 2:
 754                         dev_notice(
 755                                 &priv->spi->dev,
 756                                 "Transceiver woken up from Power-Off by Sleep Timer Time-Out\n");
 757                         break;
 758                 case 3:
 759                         dev_notice(
 760                                 &priv->spi->dev,
 761                                 "Transceiver woken up from Power-Off by GPIO Activity\n"
 762                         );
 763                         break;
 764                 case 4:
 765                         dev_notice(
 766                                 &priv->spi->dev,
 767                                 "Transceiver woken up from Standby by Sleep Timer Time-Out\n"
 768                         );
 769                         break;
 770                 case 5:
 771                         dev_notice(
 772                                 &priv->spi->dev,
 773                                 "Transceiver woken up from Standby by GPIO Activity\n"
 774                         );
 775                         break;
 776                 case 6:
 777                         dev_notice(
 778                                 &priv->spi->dev,
 779                                 "Sleep-Timer Time-Out in Active Mode\n"
 780                         );
 781                         break;
 782                 default:
 783                         dev_warn(&priv->spi->dev, "Wakeup reason unknown\n");
 784                         break;
 785                 }
 786                 complete(&priv->ca8210_is_awake);
 787         }
 788
 789 finish:;
 790 }
 791
 792 static void ca8210_remove(struct spi_device *spi_device);
 793
 794 /**
 795  * ca8210_spi_transfer_complete() - Called when a single spi transfer has
 796  *                                  completed
 797  * @context:  Pointer to the cas_control object for the finished transfer
 798  */
 799 static void ca8210_spi_transfer_complete(void *context)
 800 {
 801         struct cas_control *cas_ctl = context;
 802         struct ca8210_priv *priv = cas_ctl->priv;
 803         bool duplex_rx = false;
 804         int i;
 805         u8 retry_buffer[CA8210_SPI_BUF_SIZE];
 806
 807         if (
 808                 cas_ctl->tx_in_buf[0] == SPI_NACK ||
 809                 (cas_ctl->tx_in_buf[0] == SPI_IDLE &&
 810                 cas_ctl->tx_in_buf[1] == SPI_NACK)
 811         ) {
 812                 /* ca8210 is busy */
 813                 dev_info(&priv->spi->dev, "ca8210 was busy during attempted write\n");
 814                 if (cas_ctl->tx_buf[0] == SPI_IDLE) {
 815                         dev_warn(
 816                                 &priv->spi->dev,
 817                                 "IRQ servicing NACKd, dropping transfer\n"
 818                         );
 819                         kfree(cas_ctl);
 820                         return;
 821                 }
 822                 if (priv->retries > 3) {
 823                         dev_err(&priv->spi->dev, "too many retries!\n");
 824                         kfree(cas_ctl);
 825                         ca8210_remove(priv->spi);
 826                         return;
 827                 }
 828                 memcpy(retry_buffer, cas_ctl->tx_buf, CA8210_SPI_BUF_SIZE);
 829                 kfree(cas_ctl);
 830                 ca8210_spi_transfer(
 831                         priv->spi,
 832                         retry_buffer,
 833                         CA8210_SPI_BUF_SIZE
 834                 );
 835                 priv->retries++;
 836                 dev_info(&priv->spi->dev, "retried spi write\n");
 837                 return;
 838         } else if (
 839                         cas_ctl->tx_in_buf[0] != SPI_IDLE &&
 840                         cas_ctl->tx_in_buf[0] != SPI_NACK
 841                 ) {
 842                 duplex_rx = true;
 843         }
 844
 845         if (duplex_rx) {
 846                 dev_dbg(&priv->spi->dev, "READ CMD DURING TX\n");
 847                 for (i = 0; i < cas_ctl->tx_in_buf[1] + 2; i++)
 848                         dev_dbg(
 849                                 &priv->spi->dev,
 850                                 "%#03x\n",
 851                                 cas_ctl->tx_in_buf[i]
 852                         );
 853                 ca8210_rx_done(cas_ctl);
 854         }
 855         complete(&priv->spi_transfer_complete);
 856         kfree(cas_ctl);
 857         priv->retries = 0;
 858 }
 859
 860 /**
 861  * ca8210_spi_transfer() - Initiate duplex spi transfer with ca8210
 862  * @spi: Pointer to spi device for transfer
 863  * @buf: Octet array to send
 864  * @len: length of the buffer being sent
 865  *
 866  * Return: 0 or linux error code
 867  */
 868 static int ca8210_spi_transfer(
 869         struct spi_device  *spi,
 870         const u8           *buf,
 871         size_t              len
 872 )
 873 {
 874         int i, status = 0;
 875         struct ca8210_priv *priv;
 876         struct cas_control *cas_ctl;
 877
 878         if (!spi) {
 879                 pr_crit("NULL spi device passed to %s\n", __func__);
 880                 return -ENODEV;
 881         }
 882
 883         priv = spi_get_drvdata(spi);
 884         reinit_completion(&priv->spi_transfer_complete);
 885
 886         dev_dbg(&spi->dev, "%s called\n", __func__);
 887
 888         cas_ctl = kmalloc(sizeof(*cas_ctl), GFP_ATOMIC);
 889         if (!cas_ctl)
 890                 return -ENOMEM;
 891
 892         cas_ctl->priv = priv;
 893         memset(cas_ctl->tx_buf, SPI_IDLE, CA8210_SPI_BUF_SIZE);
 894         memset(cas_ctl->tx_in_buf, SPI_IDLE, CA8210_SPI_BUF_SIZE);
 895         memcpy(cas_ctl->tx_buf, buf, len);
 896
 897         for (i = 0; i < len; i++)
 898                 dev_dbg(&spi->dev, "%#03x\n", cas_ctl->tx_buf[i]);
 899
 900         spi_message_init(&cas_ctl->msg);
 901
 902         cas_ctl->transfer.tx_nbits = 1; /* 1 MOSI line */
 903         cas_ctl->transfer.rx_nbits = 1; /* 1 MISO line */
 904         cas_ctl->transfer.speed_hz = 0; /* Use device setting */
 905         cas_ctl->transfer.bits_per_word = 0; /* Use device setting */
 906         cas_ctl->transfer.tx_buf = cas_ctl->tx_buf;
 907         cas_ctl->transfer.rx_buf = cas_ctl->tx_in_buf;
 908         cas_ctl->transfer.delay.value = 0;
 909         cas_ctl->transfer.delay.unit = SPI_DELAY_UNIT_USECS;
 910         cas_ctl->transfer.cs_change = 0;
 911         cas_ctl->transfer.len = sizeof(struct mac_message);
 912         cas_ctl->msg.complete = ca8210_spi_transfer_complete;
 913         cas_ctl->msg.context = cas_ctl;
 914
 915         spi_message_add_tail(
 916                 &cas_ctl->transfer,
 917                 &cas_ctl->msg
 918         );
 919
 920         status = spi_async(spi, &cas_ctl->msg);
 921         if (status < 0) {
 922                 dev_crit(
 923                         &spi->dev,
 924                         "status %d from spi_sync in write\n",
 925                         status
 926                 );
 927         }
 928
 929         return status;
 930 }
 931
 932 /**
 933  * ca8210_spi_exchange() - Exchange API/SAP commands with the radio
 934  * @buf:         Octet array of command being sent downstream
 935  * @len:         length of buf
 936  * @response:    buffer for storing synchronous response
 937  * @device_ref:  spi_device pointer for ca8210
 938  *
 939  * Effectively calls ca8210_spi_transfer to write buf[] to the spi, then for
 940  * synchronous commands waits for the corresponding response to be read from
 941  * the spi before returning. The response is written to the response parameter.
 942  *
 943  * Return: 0 or linux error code
 944  */
 945 static int ca8210_spi_exchange(
 946         const u8 *buf,
 947         size_t len,
 948         u8 *response,
 949         void *device_ref
 950 )
 951 {
 952         int status = 0;
 953         struct spi_device *spi = device_ref;
 954         struct ca8210_priv *priv = spi->dev.driver_data;
 955         long wait_remaining;
 956
 957         if ((buf[0] & SPI_SYN) && response) { /* if sync wait for confirm */
 958                 reinit_completion(&priv->sync_exchange_complete);
 959                 priv->sync_command_response = response;
 960         }
 961
 962         do {
 963                 reinit_completion(&priv->spi_transfer_complete);
 964                 status = ca8210_spi_transfer(priv->spi, buf, len);
 965                 if (status) {
 966                         dev_warn(
 967                                 &spi->dev,
 968                                 "spi write failed, returned %d\n",
 969                                 status
 970                         );
 971                         if (status == -EBUSY)
 972                                 continue;
 973                         if (((buf[0] & SPI_SYN) && response))
 974                                 complete(&priv->sync_exchange_complete);
 975                         goto cleanup;
 976                 }
 977
 978                 wait_remaining = wait_for_completion_interruptible_timeout(
 979                         &priv->spi_transfer_complete,
 980                         msecs_to_jiffies(1000)
 981                 );
 982                 if (wait_remaining == -ERESTARTSYS) {
 983                         status = -ERESTARTSYS;
 984                 } else if (wait_remaining == 0) {
 985                         dev_err(
 986                                 &spi->dev,
 987                                 "SPI downstream transfer timed out!\n"
 988                         );
 989                         status = -ETIME;
 990                         goto cleanup;
 991                 }
 992         } while (status < 0);
 993
 994         if (!((buf[0] & SPI_SYN) && response))
 995                 goto cleanup;
 996
 997         wait_remaining = wait_for_completion_interruptible_timeout(
 998                 &priv->sync_exchange_complete,
 999                 msecs_to_jiffies(CA8210_SYNC_TIMEOUT)
1000         );
1001         if (wait_remaining == -ERESTARTSYS) {
1002                 status = -ERESTARTSYS;
1003         } else if (wait_remaining == 0) {
1004                 dev_err(
1005                         &spi->dev,
1006                         "Synchronous confirm timeout\n"
1007                 );
1008                 status = -ETIME;
1009         }
1010
1011 cleanup:
1012         priv->sync_command_response = NULL;
1013         return status;
1014 }
1015
1016 /**
1017  * ca8210_interrupt_handler() - Called when an irq is received from the ca8210
1018  * @irq:     Id of the irq being handled
1019  * @dev_id:  Pointer passed by the system, pointing to the ca8210's private data
1020  *
1021  * This function is called when the irq line from the ca8210 is asserted,
1022  * signifying that the ca8210 has a message to send upstream to us. Starts the
1023  * asynchronous spi read.
1024  *
1025  * Return: irq return code
1026  */
1027 static irqreturn_t ca8210_interrupt_handler(int irq, void *dev_id)
1028 {
1029         struct ca8210_priv *priv = dev_id;
1030         int status;
1031
1032         dev_dbg(&priv->spi->dev, "irq: Interrupt occurred\n");
1033         do {
1034                 status = ca8210_spi_transfer(priv->spi, NULL, 0);
1035                 if (status && (status != -EBUSY)) {
1036                         dev_warn(
1037                                 &priv->spi->dev,
1038                                 "spi read failed, returned %d\n",
1039                                 status
1040                         );
1041                 }
1042         } while (status == -EBUSY);
1043         return IRQ_HANDLED;
1044 }
1045
1046 static int (*cascoda_api_downstream)(
1047         const u8 *buf,
1048         size_t len,
1049         u8 *response,
1050         void *device_ref
1051 ) = ca8210_spi_exchange;
1052
1053 /* Cascoda API / 15.4 SAP Primitives */
1054
1055 /**
1056  * tdme_setsfr_request_sync() - TDME_SETSFR_request/confirm according to API
1057  * @sfr_page:    SFR Page
1058  * @sfr_address: SFR Address
1059  * @sfr_value:   SFR Value
1060  * @device_ref:  Nondescript pointer to target device
1061  *
1062  * Return: 802.15.4 status code of TDME-SETSFR.confirm
1063  */
1064 static u8 tdme_setsfr_request_sync(
1065         u8            sfr_page,
1066         u8            sfr_address,
1067         u8            sfr_value,
1068         void         *device_ref
1069 )
1070 {
1071         int ret;
1072         struct mac_message command, response;
1073         struct spi_device *spi = device_ref;
1074
1075         command.command_id = SPI_TDME_SETSFR_REQUEST;
1076         command.length = 3;
1077         command.pdata.tdme_set_sfr_req.sfr_page    = sfr_page;
1078         command.pdata.tdme_set_sfr_req.sfr_address = sfr_address;
1079         command.pdata.tdme_set_sfr_req.sfr_value   = sfr_value;
1080         response.command_id = SPI_IDLE;
1081         ret = cascoda_api_downstream(
1082                 &command.command_id,
1083                 command.length + 2,
1084                 &response.command_id,
1085                 device_ref
1086         );
1087         if (ret) {
1088                 dev_crit(&spi->dev, "cascoda_api_downstream returned %d", ret);
1089                 return IEEE802154_SYSTEM_ERROR;
1090         }
1091
1092         if (response.command_id != SPI_TDME_SETSFR_CONFIRM) {
1093                 dev_crit(
1094                         &spi->dev,
1095                         "sync response to SPI_TDME_SETSFR_REQUEST was not SPI_TDME_SETSFR_CONFIRM, it was %d\n",
1096                         response.command_id
1097                 );
1098                 return IEEE802154_SYSTEM_ERROR;
1099         }
1100
1101         return response.pdata.tdme_set_sfr_cnf.status;
1102 }
1103
1104 /**
1105  * tdme_chipinit() - TDME Chip Register Default Initialisation Macro
1106  * @device_ref: Nondescript pointer to target device
1107  *
1108  * Return: 802.15.4 status code of API calls
1109  */
1110 static u8 tdme_chipinit(void *device_ref)
1111 {
1112         u8 status = IEEE802154_SUCCESS;
1113         u8 sfr_address;
1114         struct spi_device *spi = device_ref;
1115         struct preamble_cfg_sfr pre_cfg_value = {
1116                 .timeout_symbols     = 3,
1117                 .acquisition_symbols = 3,
1118                 .search_symbols      = 1,
1119         };
1120         /* LNA Gain Settings */
1121         status = tdme_setsfr_request_sync(
1122                 1, (sfr_address = CA8210_SFR_LNAGX40),
1123                 LNAGX40_DEFAULT_GAIN, device_ref);
1124         if (status)
1125                 goto finish;
1126         status = tdme_setsfr_request_sync(
1127                 1, (sfr_address = CA8210_SFR_LNAGX41),
1128                 LNAGX41_DEFAULT_GAIN, device_ref);
1129         if (status)
1130                 goto finish;
1131         status = tdme_setsfr_request_sync(
1132                 1, (sfr_address = CA8210_SFR_LNAGX42),
1133                 LNAGX42_DEFAULT_GAIN, device_ref);
1134         if (status)
1135                 goto finish;
1136         status = tdme_setsfr_request_sync(
1137                 1, (sfr_address = CA8210_SFR_LNAGX43),
1138                 LNAGX43_DEFAULT_GAIN, device_ref);
1139         if (status)
1140                 goto finish;
1141         status = tdme_setsfr_request_sync(
1142                 1, (sfr_address = CA8210_SFR_LNAGX44),
1143                 LNAGX44_DEFAULT_GAIN, device_ref);
1144         if (status)
1145                 goto finish;
1146         status = tdme_setsfr_request_sync(
1147                 1, (sfr_address = CA8210_SFR_LNAGX45),
1148                 LNAGX45_DEFAULT_GAIN, device_ref);
1149         if (status)
1150                 goto finish;
1151         status = tdme_setsfr_request_sync(
1152                 1, (sfr_address = CA8210_SFR_LNAGX46),
1153                 LNAGX46_DEFAULT_GAIN, device_ref);
1154         if (status)
1155                 goto finish;
1156         status = tdme_setsfr_request_sync(
1157                 1, (sfr_address = CA8210_SFR_LNAGX47),
1158                 LNAGX47_DEFAULT_GAIN, device_ref);
1159         if (status)
1160                 goto finish;
1161         /* Preamble Timing Config */
1162         status = tdme_setsfr_request_sync(
1163                 1, (sfr_address = CA8210_SFR_PRECFG),
1164                 *((u8 *)&pre_cfg_value), device_ref);
1165         if (status)
1166                 goto finish;
1167         /* Preamble Threshold High */
1168         status = tdme_setsfr_request_sync(
1169                 1, (sfr_address = CA8210_SFR_PTHRH),
1170                 PTHRH_DEFAULT_THRESHOLD, device_ref);
1171         if (status)
1172                 goto finish;
1173         /* Tx Output Power 8 dBm */
1174         status = tdme_setsfr_request_sync(
1175                 0, (sfr_address = CA8210_SFR_PACFGIB),
1176                 PACFGIB_DEFAULT_CURRENT, device_ref);
1177         if (status)
1178                 goto finish;
1179
1180 finish:
1181         if (status != IEEE802154_SUCCESS) {
1182                 dev_err(
1183                         &spi->dev,
1184                         "failed to set sfr at %#03x, status = %#03x\n",
1185                         sfr_address,
1186                         status
1187                 );
1188         }
1189         return status;
1190 }
1191
1192 /**
1193  * tdme_channelinit() - TDME Channel Register Default Initialisation Macro (Tx)
1194  * @channel:    802.15.4 channel to initialise chip for
1195  * @device_ref: Nondescript pointer to target device
1196  *
1197  * Return: 802.15.4 status code of API calls
1198  */
1199 static u8 tdme_channelinit(u8 channel, void *device_ref)
1200 {
1201         /* Transceiver front-end local oscillator tx two-point calibration
1202          * value. Tuned for the hardware.
1203          */
1204         u8 txcalval;
1205
1206         if (channel >= 25)
1207                 txcalval = 0xA7;
1208         else if (channel >= 23)
1209                 txcalval = 0xA8;
1210         else if (channel >= 22)
1211                 txcalval = 0xA9;
1212         else if (channel >= 20)
1213                 txcalval = 0xAA;
1214         else if (channel >= 17)
1215                 txcalval = 0xAB;
1216         else if (channel >= 16)
1217                 txcalval = 0xAC;
1218         else if (channel >= 14)
1219                 txcalval = 0xAD;
1220         else if (channel >= 12)
1221                 txcalval = 0xAE;
1222         else
1223                 txcalval = 0xAF;
1224
1225         return tdme_setsfr_request_sync(
1226                 1,
1227                 CA8210_SFR_LOTXCAL,
1228                 txcalval,
1229                 device_ref
1230         );  /* LO Tx Cal */
1231 }
1232
1233 /**
1234  * tdme_checkpibattribute() - Checks Attribute Values that are not checked in
1235  *                            MAC
1236  * @pib_attribute:        Attribute Number
1237  * @pib_attribute_length: Attribute length
1238  * @pib_attribute_value:  Pointer to Attribute Value
1239  *
1240  * Return: 802.15.4 status code of checks
1241  */
1242 static u8 tdme_checkpibattribute(
1243         u8            pib_attribute,
1244         u8            pib_attribute_length,
1245         const void   *pib_attribute_value
1246 )
1247 {
1248         u8 status = IEEE802154_SUCCESS;
1249         u8 value;
1250
1251         value  = *((u8 *)pib_attribute_value);
1252
1253         switch (pib_attribute) {
1254         /* PHY */
1255         case PHY_TRANSMIT_POWER:
1256                 if (value > 0x3F)
1257                         status = IEEE802154_INVALID_PARAMETER;
1258                 break;
1259         case PHY_CCA_MODE:
1260                 if (value > 0x03)
1261                         status = IEEE802154_INVALID_PARAMETER;
1262                 break;
1263         /* MAC */
1264         case MAC_BATT_LIFE_EXT_PERIODS:
1265                 if (value < 6 || value > 41)
1266                         status = IEEE802154_INVALID_PARAMETER;
1267                 break;
1268         case MAC_BEACON_PAYLOAD:
1269                 if (pib_attribute_length > MAX_BEACON_PAYLOAD_LENGTH)
1270                         status = IEEE802154_INVALID_PARAMETER;
1271                 break;
1272         case MAC_BEACON_PAYLOAD_LENGTH:
1273                 if (value > MAX_BEACON_PAYLOAD_LENGTH)
1274                         status = IEEE802154_INVALID_PARAMETER;
1275                 break;
1276         case MAC_BEACON_ORDER:
1277                 if (value > 15)
1278                         status = IEEE802154_INVALID_PARAMETER;
1279                 break;
1280         case MAC_MAX_BE:
1281                 if (value < 3 || value > 8)
1282                         status = IEEE802154_INVALID_PARAMETER;
1283                 break;
1284         case MAC_MAX_CSMA_BACKOFFS:
1285                 if (value > 5)
1286                         status = IEEE802154_INVALID_PARAMETER;
1287                 break;
1288         case MAC_MAX_FRAME_RETRIES:
1289                 if (value > 7)
1290                         status = IEEE802154_INVALID_PARAMETER;
1291                 break;
1292         case MAC_MIN_BE:
1293                 if (value > 8)
1294                         status = IEEE802154_INVALID_PARAMETER;
1295                 break;
1296         case MAC_RESPONSE_WAIT_TIME:
1297                 if (value < 2 || value > 64)
1298                         status = IEEE802154_INVALID_PARAMETER;
1299                 break;
1300         case MAC_SUPERFRAME_ORDER:
1301                 if (value > 15)
1302                         status = IEEE802154_INVALID_PARAMETER;
1303                 break;
1304         /* boolean */
1305         case MAC_ASSOCIATED_PAN_COORD:
1306         case MAC_ASSOCIATION_PERMIT:
1307         case MAC_AUTO_REQUEST:
1308         case MAC_BATT_LIFE_EXT:
1309         case MAC_GTS_PERMIT:
1310         case MAC_PROMISCUOUS_MODE:
1311         case MAC_RX_ON_WHEN_IDLE:
1312         case MAC_SECURITY_ENABLED:
1313                 if (value > 1)
1314                         status = IEEE802154_INVALID_PARAMETER;
1315                 break;
1316         /* MAC SEC */
1317         case MAC_AUTO_REQUEST_SECURITY_LEVEL:
1318                 if (value > 7)
1319                         status = IEEE802154_INVALID_PARAMETER;
1320                 break;
1321         case MAC_AUTO_REQUEST_KEY_ID_MODE:
1322                 if (value > 3)
1323                         status = IEEE802154_INVALID_PARAMETER;
1324                 break;
1325         default:
1326                 break;
1327         }
1328
1329         return status;
1330 }
1331
1332 /**
1333  * tdme_settxpower() - Sets the tx power for MLME_SET phyTransmitPower
1334  * @txp:        Transmit Power
1335  * @device_ref: Nondescript pointer to target device
1336  *
1337  * Normalised to 802.15.4 Definition (6-bit, signed):
1338  * Bit 7-6: not used
1339  * Bit 5-0: tx power (-32 - +31 dB)
1340  *
1341  * Return: 802.15.4 status code of api calls
1342  */
1343 static u8 tdme_settxpower(u8 txp, void *device_ref)
1344 {
1345         u8 status;
1346         s8 txp_val;
1347         u8 txp_ext;
1348         union pa_cfg_sfr pa_cfg_val;
1349
1350         /* extend from 6 to 8 bit */
1351         txp_ext = 0x3F & txp;
1352         if (txp_ext & 0x20)
1353                 txp_ext += 0xC0;
1354         txp_val = (s8)txp_ext;
1355
1356         if (CA8210_MAC_MPW) {
1357                 if (txp_val > 0) {
1358                         /* 8 dBm: ptrim = 5, itrim = +3 => +4 dBm */
1359                         pa_cfg_val.bias_current_trim     = 3;
1360                         pa_cfg_val.buffer_capacitor_trim = 5;
1361                         pa_cfg_val.boost                 = 1;
1362                 } else {
1363                         /* 0 dBm: ptrim = 7, itrim = +3 => -6 dBm */
1364                         pa_cfg_val.bias_current_trim     = 3;
1365                         pa_cfg_val.buffer_capacitor_trim = 7;
1366                         pa_cfg_val.boost                 = 0;
1367                 }
1368                 /* write PACFG */
1369                 status = tdme_setsfr_request_sync(
1370                         0,
1371                         CA8210_SFR_PACFG,
1372                         pa_cfg_val.paib,
1373                         device_ref
1374                 );
1375         } else {
1376                 /* Look-Up Table for Setting Current and Frequency Trim values
1377                  * for desired Output Power
1378                  */
1379                 if (txp_val > 8) {
1380                         pa_cfg_val.paib = 0x3F;
1381                 } else if (txp_val == 8) {
1382                         pa_cfg_val.paib = 0x32;
1383                 } else if (txp_val == 7) {
1384                         pa_cfg_val.paib = 0x22;
1385                 } else if (txp_val == 6) {
1386                         pa_cfg_val.paib = 0x18;
1387                 } else if (txp_val == 5) {
1388                         pa_cfg_val.paib = 0x10;
1389                 } else if (txp_val == 4) {
1390                         pa_cfg_val.paib = 0x0C;
1391                 } else if (txp_val == 3) {
1392                         pa_cfg_val.paib = 0x08;
1393                 } else if (txp_val == 2) {
1394                         pa_cfg_val.paib = 0x05;
1395                 } else if (txp_val == 1) {
1396                         pa_cfg_val.paib = 0x03;
1397                 } else if (txp_val == 0) {
1398                         pa_cfg_val.paib = 0x01;
1399                 } else { /* < 0 */
1400                         pa_cfg_val.paib = 0x00;
1401                 }
1402                 /* write PACFGIB */
1403                 status = tdme_setsfr_request_sync(
1404                         0,
1405                         CA8210_SFR_PACFGIB,
1406                         pa_cfg_val.paib,
1407                         device_ref
1408                 );
1409         }
1410
1411         return status;
1412 }
1413
1414 /**
1415  * mcps_data_request() - mcps_data_request (Send Data) according to API Spec
1416  * @src_addr_mode:    Source Addressing Mode
1417  * @dst_address_mode: Destination Addressing Mode
1418  * @dst_pan_id:       Destination PAN ID
1419  * @dst_addr:         Pointer to Destination Address
1420  * @msdu_length:      length of Data
1421  * @msdu:             Pointer to Data
1422  * @msdu_handle:      Handle of Data
1423  * @tx_options:       Tx Options Bit Field
1424  * @security:         Pointer to Security Structure or NULL
1425  * @device_ref:       Nondescript pointer to target device
1426  *
1427  * Return: 802.15.4 status code of action
1428  */
1429 static u8 mcps_data_request(
1430         u8               src_addr_mode,
1431         u8               dst_address_mode,
1432         u16              dst_pan_id,
1433         union macaddr   *dst_addr,
1434         u8               msdu_length,
1435         u8              *msdu,
1436         u8               msdu_handle,
1437         u8               tx_options,
1438         struct secspec  *security,
1439         void            *device_ref
1440 )
1441 {
1442         struct secspec *psec;
1443         struct mac_message command;
1444
1445         command.command_id = SPI_MCPS_DATA_REQUEST;
1446         command.pdata.data_req.src_addr_mode = src_addr_mode;
1447         command.pdata.data_req.dst.mode = dst_address_mode;
1448         if (dst_address_mode != MAC_MODE_NO_ADDR) {
1449                 command.pdata.data_req.dst.pan_id[0] = LS_BYTE(dst_pan_id);
1450                 command.pdata.data_req.dst.pan_id[1] = MS_BYTE(dst_pan_id);
1451                 if (dst_address_mode == MAC_MODE_SHORT_ADDR) {
1452                         command.pdata.data_req.dst.address[0] = LS_BYTE(
1453                                 dst_addr->short_address
1454                         );
1455                         command.pdata.data_req.dst.address[1] = MS_BYTE(
1456                                 dst_addr->short_address
1457                         );
1458                 } else {   /* MAC_MODE_LONG_ADDR*/
1459                         memcpy(
1460                                 command.pdata.data_req.dst.address,
1461                                 dst_addr->ieee_address,
1462                                 8
1463                         );
1464                 }
1465         }
1466         command.pdata.data_req.msdu_length = msdu_length;
1467         command.pdata.data_req.msdu_handle = msdu_handle;
1468         command.pdata.data_req.tx_options = tx_options;
1469         memcpy(command.pdata.data_req.msdu, msdu, msdu_length);
1470         psec = (struct secspec *)(command.pdata.data_req.msdu + msdu_length);
1471         command.length = sizeof(struct mcps_data_request_pset) -
1472                 MAX_DATA_SIZE + msdu_length;
1473         if (!security || security->security_level == 0) {
1474                 psec->security_level = 0;
1475                 command.length += 1;
1476         } else {
1477                 *psec = *security;
1478                 command.length += sizeof(struct secspec);
1479         }
1480
1481         if (ca8210_spi_transfer(device_ref, &command.command_id,
1482                                 command.length + 2))
1483                 return IEEE802154_SYSTEM_ERROR;
1484
1485         return IEEE802154_SUCCESS;
1486 }
1487
1488 /**
1489  * mlme_reset_request_sync() - MLME_RESET_request/confirm according to API Spec
1490  * @set_default_pib: Set defaults in PIB
1491  * @device_ref:      Nondescript pointer to target device
1492  *
1493  * Return: 802.15.4 status code of MLME-RESET.confirm
1494  */
1495 static u8 mlme_reset_request_sync(
1496         u8    set_default_pib,
1497         void *device_ref
1498 )
1499 {
1500         u8 status;
1501         struct mac_message command, response;
1502         struct spi_device *spi = device_ref;
1503
1504         command.command_id = SPI_MLME_RESET_REQUEST;
1505         command.length = 1;
1506         command.pdata.u8param = set_default_pib;
1507
1508         if (cascoda_api_downstream(
1509                 &command.command_id,
1510                 command.length + 2,
1511                 &response.command_id,
1512                 device_ref)) {
1513                 dev_err(&spi->dev, "cascoda_api_downstream failed\n");
1514                 return IEEE802154_SYSTEM_ERROR;
1515         }
1516
1517         if (response.command_id != SPI_MLME_RESET_CONFIRM)
1518                 return IEEE802154_SYSTEM_ERROR;
1519
1520         status = response.pdata.status;
1521
1522         /* reset COORD Bit for Channel Filtering as Coordinator */
1523         if (CA8210_MAC_WORKAROUNDS && set_default_pib && !status) {
1524                 status = tdme_setsfr_request_sync(
1525                         0,
1526                         CA8210_SFR_MACCON,
1527                         0,
1528                         device_ref
1529                 );
1530         }
1531
1532         return status;
1533 }
1534
1535 /**
1536  * mlme_set_request_sync() - MLME_SET_request/confirm according to API Spec
1537  * @pib_attribute:        Attribute Number
1538  * @pib_attribute_index:  Index within Attribute if an Array
1539  * @pib_attribute_length: Attribute length
1540  * @pib_attribute_value:  Pointer to Attribute Value
1541  * @device_ref:           Nondescript pointer to target device
1542  *
1543  * Return: 802.15.4 status code of MLME-SET.confirm
1544  */
1545 static u8 mlme_set_request_sync(
1546         u8            pib_attribute,
1547         u8            pib_attribute_index,
1548         u8            pib_attribute_length,
1549         const void   *pib_attribute_value,
1550         void         *device_ref
1551 )
1552 {
1553         u8 status;
1554         struct mac_message command, response;
1555
1556         /* pre-check the validity of pib_attribute values that are not checked
1557          * in MAC
1558          */
1559         if (tdme_checkpibattribute(
1560                 pib_attribute, pib_attribute_length, pib_attribute_value)) {
1561                 return IEEE802154_INVALID_PARAMETER;
1562         }
1563
1564         if (pib_attribute == PHY_CURRENT_CHANNEL) {
1565                 status = tdme_channelinit(
1566                         *((u8 *)pib_attribute_value),
1567                         device_ref
1568                 );
1569                 if (status)
1570                         return status;
1571         }
1572
1573         if (pib_attribute == PHY_TRANSMIT_POWER) {
1574                 return tdme_settxpower(
1575                         *((u8 *)pib_attribute_value),
1576                         device_ref
1577                 );
1578         }
1579
1580         command.command_id = SPI_MLME_SET_REQUEST;
1581         command.length = sizeof(struct mlme_set_request_pset) -
1582                 MAX_ATTRIBUTE_SIZE + pib_attribute_length;
1583         command.pdata.set_req.pib_attribute = pib_attribute;
1584         command.pdata.set_req.pib_attribute_index = pib_attribute_index;
1585         command.pdata.set_req.pib_attribute_length = pib_attribute_length;
1586         memcpy(
1587                 command.pdata.set_req.pib_attribute_value,
1588                 pib_attribute_value,
1589                 pib_attribute_length
1590         );
1591
1592         if (cascoda_api_downstream(
1593                 &command.command_id,
1594                 command.length + 2,
1595                 &response.command_id,
1596                 device_ref)) {
1597                 return IEEE802154_SYSTEM_ERROR;
1598         }
1599
1600         if (response.command_id != SPI_MLME_SET_CONFIRM)
1601                 return IEEE802154_SYSTEM_ERROR;
1602
1603         return response.pdata.status;
1604 }
1605
1606 /**
1607  * hwme_set_request_sync() - HWME_SET_request/confirm according to API Spec
1608  * @hw_attribute:        Attribute Number
1609  * @hw_attribute_length: Attribute length
1610  * @hw_attribute_value:  Pointer to Attribute Value
1611  * @device_ref:          Nondescript pointer to target device
1612  *
1613  * Return: 802.15.4 status code of HWME-SET.confirm
1614  */
1615 static u8 hwme_set_request_sync(
1616         u8           hw_attribute,
1617         u8           hw_attribute_length,
1618         u8          *hw_attribute_value,
1619         void        *device_ref
1620 )
1621 {
1622         struct mac_message command, response;
1623
1624         command.command_id = SPI_HWME_SET_REQUEST;
1625         command.length = 2 + hw_attribute_length;
1626         command.pdata.hwme_set_req.hw_attribute = hw_attribute;
1627         command.pdata.hwme_set_req.hw_attribute_length = hw_attribute_length;
1628         memcpy(
1629                 command.pdata.hwme_set_req.hw_attribute_value,
1630                 hw_attribute_value,
1631                 hw_attribute_length
1632         );
1633
1634         if (cascoda_api_downstream(
1635                 &command.command_id,
1636                 command.length + 2,
1637                 &response.command_id,
1638                 device_ref)) {
1639                 return IEEE802154_SYSTEM_ERROR;
1640         }
1641
1642         if (response.command_id != SPI_HWME_SET_CONFIRM)
1643                 return IEEE802154_SYSTEM_ERROR;
1644
1645         return response.pdata.hwme_set_cnf.status;
1646 }
1647
1648 /**
1649  * hwme_get_request_sync() - HWME_GET_request/confirm according to API Spec
1650  * @hw_attribute:        Attribute Number
1651  * @hw_attribute_length: Attribute length
1652  * @hw_attribute_value:  Pointer to Attribute Value
1653  * @device_ref:          Nondescript pointer to target device
1654  *
1655  * Return: 802.15.4 status code of HWME-GET.confirm
1656  */
1657 static u8 hwme_get_request_sync(
1658         u8           hw_attribute,
1659         u8          *hw_attribute_length,
1660         u8          *hw_attribute_value,
1661         void        *device_ref
1662 )
1663 {
1664         struct mac_message command, response;
1665
1666         command.command_id = SPI_HWME_GET_REQUEST;
1667         command.length = 1;
1668         command.pdata.hwme_get_req.hw_attribute = hw_attribute;
1669
1670         if (cascoda_api_downstream(
1671                 &command.command_id,
1672                 command.length + 2,
1673                 &response.command_id,
1674                 device_ref)) {
1675                 return IEEE802154_SYSTEM_ERROR;
1676         }
1677
1678         if (response.command_id != SPI_HWME_GET_CONFIRM)
1679                 return IEEE802154_SYSTEM_ERROR;
1680
1681         if (response.pdata.hwme_get_cnf.status == IEEE802154_SUCCESS) {
1682                 *hw_attribute_length =
1683                         response.pdata.hwme_get_cnf.hw_attribute_length;
1684                 memcpy(
1685                         hw_attribute_value,
1686                         response.pdata.hwme_get_cnf.hw_attribute_value,
1687                         *hw_attribute_length
1688                 );
1689         }
1690
1691         return response.pdata.hwme_get_cnf.status;
1692 }
1693
1694 /* Network driver operation */
1695
1696 /**
1697  * ca8210_async_xmit_complete() - Called to announce that an asynchronous
1698  *                                transmission has finished
1699  * @hw:          ieee802154_hw of ca8210 that has finished exchange
1700  * @msduhandle:  Identifier of transmission that has completed
1701  * @status:      Returned 802.15.4 status code of the transmission
1702  *
1703  * Return: 0 or linux error code
1704  */
1705 static int ca8210_async_xmit_complete(
1706         struct ieee802154_hw  *hw,
1707         u8                     msduhandle,
1708         u8                     status)
1709 {
1710         struct ca8210_priv *priv = hw->priv;
1711
1712         if (priv->nextmsduhandle != msduhandle) {
1713                 dev_err(
1714                         &priv->spi->dev,
1715                         "Unexpected msdu_handle on data confirm, Expected %d, got %d\n",
1716                         priv->nextmsduhandle,
1717                         msduhandle
1718                 );
1719                 return -EIO;
1720         }
1721
1722         priv->async_tx_pending = false;
1723         priv->nextmsduhandle++;
1724
1725         if (status) {
1726                 dev_err(
1727                         &priv->spi->dev,
1728                         "Link transmission unsuccessful, status = %d\n",
1729                         status
1730                 );
1731                 if (status != IEEE802154_TRANSACTION_OVERFLOW) {
1732                         ieee802154_xmit_error(priv->hw, priv->tx_skb, status);
1733                         return 0;
1734                 }
1735         }
1736         ieee802154_xmit_complete(priv->hw, priv->tx_skb, true);
1737
1738         return 0;
1739 }
1740
1741 /**
1742  * ca8210_skb_rx() - Contructs a properly framed socket buffer from a received
1743  *                   MCPS_DATA_indication
1744  * @hw:        ieee802154_hw that MCPS_DATA_indication was received by
1745  * @len:       length of MCPS_DATA_indication
1746  * @data_ind:  Octet array of MCPS_DATA_indication
1747  *
1748  * Called by the spi driver whenever a SAP command is received, this function
1749  * will ascertain whether the command is of interest to the network driver and
1750  * take necessary action.
1751  *
1752  * Return: 0 or linux error code
1753  */
1754 static int ca8210_skb_rx(
1755         struct ieee802154_hw  *hw,
1756         size_t                 len,
1757         u8                    *data_ind
1758 )
1759 {
1760         struct ieee802154_hdr hdr;
1761         int msdulen;
1762         int hlen;
1763         u8 mpdulinkquality = data_ind[23];
1764         struct sk_buff *skb;
1765         struct ca8210_priv *priv = hw->priv;
1766
1767         /* Allocate mtu size buffer for every rx packet */
1768         skb = dev_alloc_skb(IEEE802154_MTU + sizeof(hdr));
1769         if (!skb)
1770                 return -ENOMEM;
1771
1772         skb_reserve(skb, sizeof(hdr));
1773
1774         msdulen = data_ind[22]; /* msdu_length */
1775         if (msdulen > IEEE802154_MTU) {
1776                 dev_err(
1777                         &priv->spi->dev,
1778                         "received erroneously large msdu length!\n"
1779                 );
1780                 kfree_skb(skb);
1781                 return -EMSGSIZE;
1782         }
1783         dev_dbg(&priv->spi->dev, "skb buffer length = %d\n", msdulen);
1784
1785         if (priv->promiscuous)
1786                 goto copy_payload;
1787
1788         /* Populate hdr */
1789         hdr.sec.level = data_ind[29 + msdulen];
1790         dev_dbg(&priv->spi->dev, "security level: %#03x\n", hdr.sec.level);
1791         if (hdr.sec.level > 0) {
1792                 hdr.sec.key_id_mode = data_ind[30 + msdulen];
1793                 memcpy(&hdr.sec.extended_src, &data_ind[31 + msdulen], 8);
1794                 hdr.sec.key_id = data_ind[39 + msdulen];
1795         }
1796         hdr.source.mode = data_ind[0];
1797         dev_dbg(&priv->spi->dev, "srcAddrMode: %#03x\n", hdr.source.mode);
1798         hdr.source.pan_id = *(u16 *)&data_ind[1];
1799         dev_dbg(&priv->spi->dev, "srcPanId: %#06x\n", hdr.source.pan_id);
1800         memcpy(&hdr.source.extended_addr, &data_ind[3], 8);
1801         hdr.dest.mode = data_ind[11];
1802         dev_dbg(&priv->spi->dev, "dstAddrMode: %#03x\n", hdr.dest.mode);
1803         hdr.dest.pan_id = *(u16 *)&data_ind[12];
1804         dev_dbg(&priv->spi->dev, "dstPanId: %#06x\n", hdr.dest.pan_id);
1805         memcpy(&hdr.dest.extended_addr, &data_ind[14], 8);
1806
1807         /* Fill in FC implicitly */
1808         hdr.fc.type = 1; /* Data frame */
1809         if (hdr.sec.level)
1810                 hdr.fc.security_enabled = 1;
1811         else
1812                 hdr.fc.security_enabled = 0;
1813         if (data_ind[1] != data_ind[12] || data_ind[2] != data_ind[13])
1814                 hdr.fc.intra_pan = 1;
1815         else
1816                 hdr.fc.intra_pan = 0;
1817         hdr.fc.dest_addr_mode = hdr.dest.mode;
1818         hdr.fc.source_addr_mode = hdr.source.mode;
1819
1820         /* Add hdr to front of buffer */
1821         hlen = ieee802154_hdr_push(skb, &hdr);
1822
1823         if (hlen < 0) {
1824                 dev_crit(&priv->spi->dev, "failed to push mac hdr onto skb!\n");
1825                 kfree_skb(skb);
1826                 return hlen;
1827         }
1828
1829         skb_reset_mac_header(skb);
1830         skb->mac_len = hlen;
1831
1832 copy_payload:
1833         /* Add <msdulen> bytes of space to the back of the buffer */
1834         /* Copy msdu to skb */
1835         skb_put_data(skb, &data_ind[29], msdulen);
1836
1837         ieee802154_rx_irqsafe(hw, skb, mpdulinkquality);
1838         return 0;
1839 }
1840
1841 /**
1842  * ca8210_net_rx() - Acts upon received SAP commands relevant to the network
1843  *                   driver
1844  * @hw:       ieee802154_hw that command was received by
1845  * @command:  Octet array of received command
1846  * @len:      length of the received command
1847  *
1848  * Called by the spi driver whenever a SAP command is received, this function
1849  * will ascertain whether the command is of interest to the network driver and
1850  * take necessary action.
1851  *
1852  * Return: 0 or linux error code
1853  */
1854 static int ca8210_net_rx(struct ieee802154_hw *hw, u8 *command, size_t len)
1855 {
1856         struct ca8210_priv *priv = hw->priv;
1857         unsigned long flags;
1858         u8 status;
1859
1860         dev_dbg(&priv->spi->dev, "%s: CmdID = %d\n", __func__, command[0]);
1861
1862         if (command[0] == SPI_MCPS_DATA_INDICATION) {
1863                 /* Received data */
1864                 spin_lock_irqsave(&priv->lock, flags);
1865                 if (command[26] == priv->last_dsn) {
1866                         dev_dbg(
1867                                 &priv->spi->dev,
1868                                 "DSN %d resend received, ignoring...\n",
1869                                 command[26]
1870                         );
1871                         spin_unlock_irqrestore(&priv->lock, flags);
1872                         return 0;
1873                 }
1874                 priv->last_dsn = command[26];
1875                 spin_unlock_irqrestore(&priv->lock, flags);
1876                 return ca8210_skb_rx(hw, len - 2, command + 2);
1877         } else if (command[0] == SPI_MCPS_DATA_CONFIRM) {
1878                 status = command[3];
1879                 if (priv->async_tx_pending) {
1880                         return ca8210_async_xmit_complete(
1881                                 hw,
1882                                 command[2],
1883                                 status
1884                         );
1885                 }
1886         }
1887
1888         return 0;
1889 }
1890
1891 /**
1892  * ca8210_skb_tx() - Transmits a given socket buffer using the ca8210
1893  * @skb:         Socket buffer to transmit
1894  * @msduhandle:  Data identifier to pass to the 802.15.4 MAC
1895  * @priv:        Pointer to private data section of target ca8210
1896  *
1897  * Return: 0 or linux error code
1898  */
1899 static int ca8210_skb_tx(
1900         struct sk_buff      *skb,
1901         u8                   msduhandle,
1902         struct ca8210_priv  *priv
1903 )
1904 {
1905         int status;
1906         struct ieee802154_hdr header = { };
1907         struct secspec secspec;
1908         unsigned int mac_len;
1909
1910         dev_dbg(&priv->spi->dev, "%s called\n", __func__);
1911
1912         /* Get addressing info from skb - ieee802154 layer creates a full
1913          * packet
1914          */
1915         mac_len = ieee802154_hdr_peek_addrs(skb, &header);
1916
1917         secspec.security_level = header.sec.level;
1918         secspec.key_id_mode = header.sec.key_id_mode;
1919         if (secspec.key_id_mode == 2)
1920                 memcpy(secspec.key_source, &header.sec.short_src, 4);
1921         else if (secspec.key_id_mode == 3)
1922                 memcpy(secspec.key_source, &header.sec.extended_src, 8);
1923         secspec.key_index = header.sec.key_id;
1924
1925         /* Pass to Cascoda API */
1926         status =  mcps_data_request(
1927                 header.source.mode,
1928                 header.dest.mode,
1929                 header.dest.pan_id,
1930                 (union macaddr *)&header.dest.extended_addr,
1931                 skb->len - mac_len,
1932                 &skb->data[mac_len],
1933                 msduhandle,
1934                 header.fc.ack_request,
1935                 &secspec,
1936                 priv->spi
1937         );
1938         return link_to_linux_err(status);
1939 }
1940
1941 /**
1942  * ca8210_start() - Starts the network driver
1943  * @hw:  ieee802154_hw of ca8210 being started
1944  *
1945  * Return: 0 or linux error code
1946  */
1947 static int ca8210_start(struct ieee802154_hw *hw)
1948 {
1949         int status;
1950         u8 rx_on_when_idle;
1951         u8 lqi_threshold = 0;
1952         struct ca8210_priv *priv = hw->priv;
1953
1954         priv->last_dsn = -1;
1955         /* Turn receiver on when idle for now just to test rx */
1956         rx_on_when_idle = 1;
1957         status = mlme_set_request_sync(
1958                 MAC_RX_ON_WHEN_IDLE,
1959                 0,
1960                 1,
1961                 &rx_on_when_idle,
1962                 priv->spi
1963         );
1964         if (status) {
1965                 dev_crit(
1966                         &priv->spi->dev,
1967                         "Setting rx_on_when_idle failed, status = %d\n",
1968                         status
1969                 );
1970                 return link_to_linux_err(status);
1971         }
1972         status = hwme_set_request_sync(
1973                 HWME_LQILIMIT,
1974                 1,
1975                 &lqi_threshold,
1976                 priv->spi
1977         );
1978         if (status) {
1979                 dev_crit(
1980                         &priv->spi->dev,
1981                         "Setting lqilimit failed, status = %d\n",
1982                         status
1983                 );
1984                 return link_to_linux_err(status);
1985         }
1986
1987         return 0;
1988 }
1989
1990 /**
1991  * ca8210_stop() - Stops the network driver
1992  * @hw:  ieee802154_hw of ca8210 being stopped
1993  *
1994  * Return: 0 or linux error code
1995  */
1996 static void ca8210_stop(struct ieee802154_hw *hw)
1997 {
1998 }
1999
2000 /**
2001  * ca8210_xmit_async() - Asynchronously transmits a given socket buffer using
2002  *                       the ca8210
2003  * @hw:   ieee802154_hw of ca8210 to transmit from
2004  * @skb:  Socket buffer to transmit
2005  *
2006  * Return: 0 or linux error code
2007  */
2008 static int ca8210_xmit_async(struct ieee802154_hw *hw, struct sk_buff *skb)
2009 {
2010         struct ca8210_priv *priv = hw->priv;
2011         int status;
2012
2013         dev_dbg(&priv->spi->dev, "calling %s\n", __func__);
2014
2015         priv->tx_skb = skb;
2016         priv->async_tx_pending = true;
2017         status = ca8210_skb_tx(skb, priv->nextmsduhandle, priv);
2018         return status;
2019 }
2020
2021 /**
2022  * ca8210_get_ed() - Returns the measured energy on the current channel at this
2023  *                   instant in time
2024  * @hw:     ieee802154_hw of target ca8210
2025  * @level:  Measured Energy Detect level
2026  *
2027  * Return: 0 or linux error code
2028  */
2029 static int ca8210_get_ed(struct ieee802154_hw *hw, u8 *level)
2030 {
2031         u8 lenvar;
2032         struct ca8210_priv *priv = hw->priv;
2033
2034         return link_to_linux_err(
2035                 hwme_get_request_sync(HWME_EDVALUE, &lenvar, level, priv->spi)
2036         );
2037 }
2038
2039 /**
2040  * ca8210_set_channel() - Sets the current operating 802.15.4 channel of the
2041  *                        ca8210
2042  * @hw:       ieee802154_hw of target ca8210
2043  * @page:     Channel page to set
2044  * @channel:  Channel number to set
2045  *
2046  * Return: 0 or linux error code
2047  */
2048 static int ca8210_set_channel(
2049         struct ieee802154_hw  *hw,
2050         u8                     page,
2051         u8                     channel
2052 )
2053 {
2054         u8 status;
2055         struct ca8210_priv *priv = hw->priv;
2056
2057         status = mlme_set_request_sync(
2058                 PHY_CURRENT_CHANNEL,
2059                 0,
2060                 1,
2061                 &channel,
2062                 priv->spi
2063         );
2064         if (status) {
2065                 dev_err(
2066                         &priv->spi->dev,
2067                         "error setting channel, MLME-SET.confirm status = %d\n",
2068                         status
2069                 );
2070         }
2071         return link_to_linux_err(status);
2072 }
2073
2074 /**
2075  * ca8210_set_hw_addr_filt() - Sets the address filtering parameters of the
2076  *                             ca8210
2077  * @hw:       ieee802154_hw of target ca8210
2078  * @filt:     Filtering parameters
2079  * @changed:  Bitmap representing which parameters to change
2080  *
2081  * Effectively just sets the actual addressing information identifying this node
2082  * as all filtering is performed by the ca8210 as detailed in the IEEE 802.15.4
2083  * 2006 specification.
2084  *
2085  * Return: 0 or linux error code
2086  */
2087 static int ca8210_set_hw_addr_filt(
2088         struct ieee802154_hw            *hw,
2089         struct ieee802154_hw_addr_filt  *filt,
2090         unsigned long                    changed
2091 )
2092 {
2093         u8 status = 0;
2094         struct ca8210_priv *priv = hw->priv;
2095
2096         if (changed & IEEE802154_AFILT_PANID_CHANGED) {
2097                 status = mlme_set_request_sync(
2098                         MAC_PAN_ID,
2099                         0,
2100                         2,
2101                         &filt->pan_id, priv->spi
2102                 );
2103                 if (status) {
2104                         dev_err(
2105                                 &priv->spi->dev,
2106                                 "error setting pan id, MLME-SET.confirm status = %d",
2107                                 status
2108                         );
2109                         return link_to_linux_err(status);
2110                 }
2111         }
2112         if (changed & IEEE802154_AFILT_SADDR_CHANGED) {
2113                 status = mlme_set_request_sync(
2114                         MAC_SHORT_ADDRESS,
2115                         0,
2116                         2,
2117                         &filt->short_addr, priv->spi
2118                 );
2119                 if (status) {
2120                         dev_err(
2121                                 &priv->spi->dev,
2122                                 "error setting short address, MLME-SET.confirm status = %d",
2123                                 status
2124                         );
2125                         return link_to_linux_err(status);
2126                 }
2127         }
2128         if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) {
2129                 status = mlme_set_request_sync(
2130                         NS_IEEE_ADDRESS,
2131                         0,
2132                         8,
2133                         &filt->ieee_addr,
2134                         priv->spi
2135                 );
2136                 if (status) {
2137                         dev_err(
2138                                 &priv->spi->dev,
2139                                 "error setting ieee address, MLME-SET.confirm status = %d",
2140                                 status
2141                         );
2142                         return link_to_linux_err(status);
2143                 }
2144         }
2145         /* TODO: Should use MLME_START to set coord bit? */
2146         return 0;
2147 }
2148
2149 /**
2150  * ca8210_set_tx_power() - Sets the transmit power of the ca8210
2151  * @hw:   ieee802154_hw of target ca8210
2152  * @mbm:  Transmit power in mBm (dBm*100)
2153  *
2154  * Return: 0 or linux error code
2155  */
2156 static int ca8210_set_tx_power(struct ieee802154_hw *hw, s32 mbm)
2157 {
2158         struct ca8210_priv *priv = hw->priv;
2159
2160         mbm /= 100;
2161         return link_to_linux_err(
2162                 mlme_set_request_sync(PHY_TRANSMIT_POWER, 0, 1, &mbm, priv->spi)
2163         );
2164 }
2165
2166 /**
2167  * ca8210_set_cca_mode() - Sets the clear channel assessment mode of the ca8210
2168  * @hw:   ieee802154_hw of target ca8210
2169  * @cca:  CCA mode to set
2170  *
2171  * Return: 0 or linux error code
2172  */
2173 static int ca8210_set_cca_mode(
2174         struct ieee802154_hw       *hw,
2175         const struct wpan_phy_cca  *cca
2176 )
2177 {
2178         u8 status;
2179         u8 cca_mode;
2180         struct ca8210_priv *priv = hw->priv;
2181
2182         cca_mode = cca->mode & 3;
2183         if (cca_mode == 3 && cca->opt == NL802154_CCA_OPT_ENERGY_CARRIER_OR) {
2184                 /* cca_mode 0 == CS OR ED, 3 == CS AND ED */
2185                 cca_mode = 0;
2186         }
2187         status = mlme_set_request_sync(
2188                 PHY_CCA_MODE,
2189                 0,
2190                 1,
2191                 &cca_mode,
2192                 priv->spi
2193         );
2194         if (status) {
2195                 dev_err(
2196                         &priv->spi->dev,
2197                         "error setting cca mode, MLME-SET.confirm status = %d",
2198                         status
2199                 );
2200         }
2201         return link_to_linux_err(status);
2202 }
2203
2204 /**
2205  * ca8210_set_cca_ed_level() - Sets the CCA ED level of the ca8210
2206  * @hw:     ieee802154_hw of target ca8210
2207  * @level:  ED level to set (in mbm)
2208  *
2209  * Sets the minimum threshold of measured energy above which the ca8210 will
2210  * back off and retry a transmission.
2211  *
2212  * Return: 0 or linux error code
2213  */
2214 static int ca8210_set_cca_ed_level(struct ieee802154_hw *hw, s32 level)
2215 {
2216         u8 status;
2217         u8 ed_threshold = (level / 100) * 2 + 256;
2218         struct ca8210_priv *priv = hw->priv;
2219
2220         status = hwme_set_request_sync(
2221                 HWME_EDTHRESHOLD,
2222                 1,
2223                 &ed_threshold,
2224                 priv->spi
2225         );
2226         if (status) {
2227                 dev_err(
2228                         &priv->spi->dev,
2229                         "error setting ed threshold, HWME-SET.confirm status = %d",
2230                         status
2231                 );
2232         }
2233         return link_to_linux_err(status);
2234 }
2235
2236 /**
2237  * ca8210_set_csma_params() - Sets the CSMA parameters of the ca8210
2238  * @hw:       ieee802154_hw of target ca8210
2239  * @min_be:   Minimum backoff exponent when backing off a transmission
2240  * @max_be:   Maximum backoff exponent when backing off a transmission
2241  * @retries:  Number of times to retry after backing off
2242  *
2243  * Return: 0 or linux error code
2244  */
2245 static int ca8210_set_csma_params(
2246         struct ieee802154_hw  *hw,
2247         u8                     min_be,
2248         u8                     max_be,
2249         u8                     retries
2250 )
2251 {
2252         u8 status;
2253         struct ca8210_priv *priv = hw->priv;
2254
2255         status = mlme_set_request_sync(MAC_MIN_BE, 0, 1, &min_be, priv->spi);
2256         if (status) {
2257                 dev_err(
2258                         &priv->spi->dev,
2259                         "error setting min be, MLME-SET.confirm status = %d",
2260                         status
2261                 );
2262                 return link_to_linux_err(status);
2263         }
2264         status = mlme_set_request_sync(MAC_MAX_BE, 0, 1, &max_be, priv->spi);
2265         if (status) {
2266                 dev_err(
2267                         &priv->spi->dev,
2268                         "error setting max be, MLME-SET.confirm status = %d",
2269                         status
2270                 );
2271                 return link_to_linux_err(status);
2272         }
2273         status = mlme_set_request_sync(
2274                 MAC_MAX_CSMA_BACKOFFS,
2275                 0,
2276                 1,
2277                 &retries,
2278                 priv->spi
2279         );
2280         if (status) {
2281                 dev_err(
2282                         &priv->spi->dev,
2283                         "error setting max csma backoffs, MLME-SET.confirm status = %d",
2284                         status
2285                 );
2286         }
2287         return link_to_linux_err(status);
2288 }
2289
2290 /**
2291  * ca8210_set_frame_retries() - Sets the maximum frame retries of the ca8210
2292  * @hw:       ieee802154_hw of target ca8210
2293  * @retries:  Number of retries
2294  *
2295  * Sets the number of times to retry a transmission if no acknowledgment was
2296  * was received from the other end when one was requested.
2297  *
2298  * Return: 0 or linux error code
2299  */
2300 static int ca8210_set_frame_retries(struct ieee802154_hw *hw, s8 retries)
2301 {
2302         u8 status;
2303         struct ca8210_priv *priv = hw->priv;
2304
2305         status = mlme_set_request_sync(
2306                 MAC_MAX_FRAME_RETRIES,
2307                 0,
2308                 1,
2309                 &retries,
2310                 priv->spi
2311         );
2312         if (status) {
2313                 dev_err(
2314                         &priv->spi->dev,
2315                         "error setting frame retries, MLME-SET.confirm status = %d",
2316                         status
2317                 );
2318         }
2319         return link_to_linux_err(status);
2320 }
2321
2322 static int ca8210_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on)
2323 {
2324         u8 status;
2325         struct ca8210_priv *priv = hw->priv;
2326
2327         status = mlme_set_request_sync(
2328                 MAC_PROMISCUOUS_MODE,
2329                 0,
2330                 1,
2331                 (const void *)&on,
2332                 priv->spi
2333         );
2334         if (status) {
2335                 dev_err(
2336                         &priv->spi->dev,
2337                         "error setting promiscuous mode, MLME-SET.confirm status = %d",
2338                         status
2339                 );
2340         } else {
2341                 priv->promiscuous = on;
2342         }
2343         return link_to_linux_err(status);
2344 }
2345
2346 static const struct ieee802154_ops ca8210_phy_ops = {
2347         .start = ca8210_start,
2348         .stop = ca8210_stop,
2349         .xmit_async = ca8210_xmit_async,
2350         .ed = ca8210_get_ed,
2351         .set_channel = ca8210_set_channel,
2352         .set_hw_addr_filt = ca8210_set_hw_addr_filt,
2353         .set_txpower = ca8210_set_tx_power,
2354         .set_cca_mode = ca8210_set_cca_mode,
2355         .set_cca_ed_level = ca8210_set_cca_ed_level,
2356         .set_csma_params = ca8210_set_csma_params,
2357         .set_frame_retries = ca8210_set_frame_retries,
2358         .set_promiscuous_mode = ca8210_set_promiscuous_mode
2359 };
2360
2361 /* Test/EVBME Interface */
2362
2363 /**
2364  * ca8210_test_int_open() - Opens the test interface to the userspace
2365  * @inodp:  inode representation of file interface
2366  * @filp:   file interface
2367  *
2368  * Return: 0 or linux error code
2369  */
2370 static int ca8210_test_int_open(struct inode *inodp, struct file *filp)
2371 {
2372         struct ca8210_priv *priv = inodp->i_private;
2373
2374         filp->private_data = priv;
2375         return 0;
2376 }
2377
2378 /**
2379  * ca8210_test_check_upstream() - Checks a command received from the upstream
2380  *                                testing interface for required action
2381  * @buf:        Buffer containing command to check
2382  * @device_ref: Nondescript pointer to target device
2383  *
2384  * Return: 0 or linux error code
2385  */
2386 static int ca8210_test_check_upstream(u8 *buf, void *device_ref)
2387 {
2388         int ret;
2389         u8 response[CA8210_SPI_BUF_SIZE];
2390
2391         if (buf[0] == SPI_MLME_SET_REQUEST) {
2392                 ret = tdme_checkpibattribute(buf[2], buf[4], buf + 5);
2393                 if (ret) {
2394                         response[0]  = SPI_MLME_SET_CONFIRM;
2395                         response[1] = 3;
2396                         response[2] = IEEE802154_INVALID_PARAMETER;
2397                         response[3] = buf[2];
2398                         response[4] = buf[3];
2399                         if (cascoda_api_upstream)
2400                                 cascoda_api_upstream(response, 5, device_ref);
2401                         return ret;
2402                 }
2403         }
2404         if (buf[0] == SPI_MLME_ASSOCIATE_REQUEST) {
2405                 return tdme_channelinit(buf[2], device_ref);
2406         } else if (buf[0] == SPI_MLME_START_REQUEST) {
2407                 return tdme_channelinit(buf[4], device_ref);
2408         } else if (
2409                 (buf[0] == SPI_MLME_SET_REQUEST) &&
2410                 (buf[2] == PHY_CURRENT_CHANNEL)
2411         ) {
2412                 return tdme_channelinit(buf[5], device_ref);
2413         } else if (
2414                 (buf[0] == SPI_TDME_SET_REQUEST) &&
2415                 (buf[2] == TDME_CHANNEL)
2416         ) {
2417                 return tdme_channelinit(buf[4], device_ref);
2418         } else if (
2419                 (CA8210_MAC_WORKAROUNDS) &&
2420                 (buf[0] == SPI_MLME_RESET_REQUEST) &&
2421                 (buf[2] == 1)
2422         ) {
2423                 /* reset COORD Bit for Channel Filtering as Coordinator */
2424                 return tdme_setsfr_request_sync(
2425                         0,
2426                         CA8210_SFR_MACCON,
2427                         0,
2428                         device_ref
2429                 );
2430         }
2431         return 0;
2432 } /* End of EVBMECheckSerialCommand() */
2433
2434 /**
2435  * ca8210_test_int_user_write() - Called by a process in userspace to send a
2436  *                                message to the ca8210 drivers
2437  * @filp:    file interface
2438  * @in_buf:  Buffer containing message to write
2439  * @len:     length of message
2440  * @off:     file offset
2441  *
2442  * Return: 0 or linux error code
2443  */
2444 static ssize_t ca8210_test_int_user_write(
2445         struct file        *filp,
2446         const char __user  *in_buf,
2447         size_t              len,
2448         loff_t             *off
2449 )
2450 {
2451         int ret;
2452         struct ca8210_priv *priv = filp->private_data;
2453         u8 command[CA8210_SPI_BUF_SIZE];
2454
2455         memset(command, SPI_IDLE, 6);
2456         if (len > CA8210_SPI_BUF_SIZE || len < 2) {
2457                 dev_warn(
2458                         &priv->spi->dev,
2459                         "userspace requested erroneous write length (%zu)\n",
2460                         len
2461                 );
2462                 return -EBADE;
2463         }
2464
2465         ret = copy_from_user(command, in_buf, len);
2466         if (ret) {
2467                 dev_err(
2468                         &priv->spi->dev,
2469                         "%d bytes could not be copied from userspace\n",
2470                         ret
2471                 );
2472                 return -EIO;
2473         }
2474         if (len != command[1] + 2) {
2475                 dev_err(
2476                         &priv->spi->dev,
2477                         "write len does not match packet length field\n"
2478                 );
2479                 return -EBADE;
2480         }
2481
2482         ret = ca8210_test_check_upstream(command, priv->spi);
2483         if (ret == 0) {
2484                 ret = ca8210_spi_exchange(
2485                         command,
2486                         command[1] + 2,
2487                         NULL,
2488                         priv->spi
2489                 );
2490                 if (ret < 0) {
2491                         /* effectively 0 bytes were written successfully */
2492                         dev_err(
2493                                 &priv->spi->dev,
2494                                 "spi exchange failed\n"
2495                         );
2496                         return ret;
2497                 }
2498                 if (command[0] & SPI_SYN)
2499                         priv->sync_down++;
2500         }
2501
2502         return len;
2503 }
2504
2505 /**
2506  * ca8210_test_int_user_read() - Called by a process in userspace to read a
2507  *                               message from the ca8210 drivers
2508  * @filp:  file interface
2509  * @buf:   Buffer to write message to
2510  * @len:   length of message to read (ignored)
2511  * @offp:  file offset
2512  *
2513  * If the O_NONBLOCK flag was set when opening the file then this function will
2514  * not block, i.e. it will return if the fifo is empty. Otherwise the function
2515  * will block, i.e. wait until new data arrives.
2516  *
2517  * Return: number of bytes read
2518  */
2519 static ssize_t ca8210_test_int_user_read(
2520         struct file  *filp,
2521         char __user  *buf,
2522         size_t        len,
2523         loff_t       *offp
2524 )
2525 {
2526         int i, cmdlen;
2527         struct ca8210_priv *priv = filp->private_data;
2528         unsigned char *fifo_buffer;
2529         unsigned long bytes_not_copied;
2530
2531         if (filp->f_flags & O_NONBLOCK) {
2532                 /* Non-blocking mode */
2533                 if (kfifo_is_empty(&priv->test.up_fifo))
2534                         return 0;
2535         } else {
2536                 /* Blocking mode */
2537                 wait_event_interruptible(
2538                         priv->test.readq,
2539                         !kfifo_is_empty(&priv->test.up_fifo)
2540                 );
2541         }
2542
2543         if (kfifo_out(&priv->test.up_fifo, &fifo_buffer, 4) != 4) {
2544                 dev_err(
2545                         &priv->spi->dev,
2546                         "test_interface: Wrong number of elements popped from upstream fifo\n"
2547                 );
2548                 return 0;
2549         }
2550         cmdlen = fifo_buffer[1];
2551         bytes_not_copied = cmdlen + 2;
2552
2553         bytes_not_copied = copy_to_user(buf, fifo_buffer, bytes_not_copied);
2554         if (bytes_not_copied > 0) {
2555                 dev_err(
2556                         &priv->spi->dev,
2557                         "%lu bytes could not be copied to user space!\n",
2558                         bytes_not_copied
2559                 );
2560         }
2561
2562         dev_dbg(&priv->spi->dev, "test_interface: Cmd len = %d\n", cmdlen);
2563
2564         dev_dbg(&priv->spi->dev, "test_interface: Read\n");
2565         for (i = 0; i < cmdlen + 2; i++)
2566                 dev_dbg(&priv->spi->dev, "%#03x\n", fifo_buffer[i]);
2567
2568         kfree(fifo_buffer);
2569
2570         return cmdlen + 2;
2571 }
2572
2573 /**
2574  * ca8210_test_int_ioctl() - Called by a process in userspace to enact an
2575  *                           arbitrary action
2576  * @filp:        file interface
2577  * @ioctl_num:   which action to enact
2578  * @ioctl_param: arbitrary parameter for the action
2579  *
2580  * Return: status
2581  */
2582 static long ca8210_test_int_ioctl(
2583         struct file *filp,
2584         unsigned int ioctl_num,
2585         unsigned long ioctl_param
2586 )
2587 {
2588         struct ca8210_priv *priv = filp->private_data;
2589
2590         switch (ioctl_num) {
2591         case CA8210_IOCTL_HARD_RESET:
2592                 ca8210_reset_send(priv->spi, ioctl_param);
2593                 break;
2594         default:
2595                 break;
2596         }
2597         return 0;
2598 }
2599
2600 /**
2601  * ca8210_test_int_poll() - Called by a process in userspace to determine which
2602  *                          actions are currently possible for the file
2603  * @filp:   file interface
2604  * @ptable: poll table
2605  *
2606  * Return: set of poll return flags
2607  */
2608 static __poll_t ca8210_test_int_poll(
2609         struct file *filp,
2610         struct poll_table_struct *ptable
2611 )
2612 {
2613         __poll_t return_flags = 0;
2614         struct ca8210_priv *priv = filp->private_data;
2615
2616         poll_wait(filp, &priv->test.readq, ptable);
2617         if (!kfifo_is_empty(&priv->test.up_fifo))
2618                 return_flags |= (EPOLLIN | EPOLLRDNORM);
2619         if (wait_event_interruptible(
2620                 priv->test.readq,
2621                 !kfifo_is_empty(&priv->test.up_fifo))) {
2622                 return EPOLLERR;
2623         }
2624         return return_flags;
2625 }
2626
2627 static const struct file_operations test_int_fops = {
2628         .read =           ca8210_test_int_user_read,
2629         .write =          ca8210_test_int_user_write,
2630         .open =           ca8210_test_int_open,
2631         .release =        NULL,
2632         .unlocked_ioctl = ca8210_test_int_ioctl,
2633         .poll =           ca8210_test_int_poll
2634 };
2635
2636 /* Init/Deinit */
2637
2638 /**
2639  * ca8210_get_platform_data() - Populate a ca8210_platform_data object
2640  * @spi_device:  Pointer to ca8210 spi device object to get data for
2641  * @pdata:       Pointer to ca8210_platform_data object to populate
2642  *
2643  * Return: 0 or linux error code
2644  */
2645 static int ca8210_get_platform_data(
2646         struct spi_device *spi_device,
2647         struct ca8210_platform_data *pdata
2648 )
2649 {
2650         int ret = 0;
2651
2652         if (!spi_device->dev.of_node)
2653                 return -EINVAL;
2654
2655         pdata->extclockenable = of_property_read_bool(
2656                 spi_device->dev.of_node,
2657                 "extclock-enable"
2658         );
2659         if (pdata->extclockenable) {
2660                 ret = of_property_read_u32(
2661                         spi_device->dev.of_node,
2662                         "extclock-freq",
2663                         &pdata->extclockfreq
2664                 );
2665                 if (ret < 0)
2666                         return ret;
2667
2668                 ret = of_property_read_u32(
2669                         spi_device->dev.of_node,
2670                         "extclock-gpio",
2671                         &pdata->extclockgpio
2672                 );
2673         }
2674
2675         return ret;
2676 }
2677
2678 /**
2679  * ca8210_config_extern_clk() - Configure the external clock provided by the
2680  *                              ca8210
2681  * @pdata:  Pointer to ca8210_platform_data containing clock parameters
2682  * @spi:    Pointer to target ca8210 spi device
2683  * @on:     True to turn the clock on, false to turn off
2684  *
2685  * The external clock is configured with a frequency and output pin taken from
2686  * the platform data.
2687  *
2688  * Return: 0 or linux error code
2689  */
2690 static int ca8210_config_extern_clk(
2691         struct ca8210_platform_data *pdata,
2692         struct spi_device *spi,
2693         bool on
2694 )
2695 {
2696         u8 clkparam[2];
2697
2698         if (on) {
2699                 dev_info(&spi->dev, "Switching external clock on\n");
2700                 switch (pdata->extclockfreq) {
2701                 case SIXTEEN_MHZ:
2702                         clkparam[0] = 1;
2703                         break;
2704                 case EIGHT_MHZ:
2705                         clkparam[0] = 2;
2706                         break;
2707                 case FOUR_MHZ:
2708                         clkparam[0] = 3;
2709                         break;
2710                 case TWO_MHZ:
2711                         clkparam[0] = 4;
2712                         break;
2713                 case ONE_MHZ:
2714                         clkparam[0] = 5;
2715                         break;
2716                 default:
2717                         dev_crit(&spi->dev, "Invalid extclock-freq\n");
2718                         return -EINVAL;
2719                 }
2720                 clkparam[1] = pdata->extclockgpio;
2721         } else {
2722                 dev_info(&spi->dev, "Switching external clock off\n");
2723                 clkparam[0] = 0; /* off */
2724                 clkparam[1] = 0;
2725         }
2726         return link_to_linux_err(
2727                 hwme_set_request_sync(HWME_SYSCLKOUT, 2, clkparam, spi)
2728         );
2729 }
2730
2731 /**
2732  * ca8210_register_ext_clock() - Register ca8210's external clock with kernel
2733  * @spi:  Pointer to target ca8210 spi device
2734  *
2735  * Return: 0 or linux error code
2736  */
2737 static int ca8210_register_ext_clock(struct spi_device *spi)
2738 {
2739         struct device_node *np = spi->dev.of_node;
2740         struct ca8210_priv *priv = spi_get_drvdata(spi);
2741         struct ca8210_platform_data *pdata = spi->dev.platform_data;
2742         int ret = 0;
2743
2744         if (!np)
2745                 return -EFAULT;
2746
2747         priv->clk = clk_register_fixed_rate(
2748                 &spi->dev,
2749                 np->name,
2750                 NULL,
2751                 0,
2752                 pdata->extclockfreq
2753         );
2754
2755         if (IS_ERR(priv->clk)) {
2756                 dev_crit(&spi->dev, "Failed to register external clk\n");
2757                 return PTR_ERR(priv->clk);
2758         }
2759         ret = of_clk_add_provider(np, of_clk_src_simple_get, priv->clk);
2760         if (ret) {
2761                 clk_unregister(priv->clk);
2762                 dev_crit(
2763                         &spi->dev,
2764                         "Failed to register external clock as clock provider\n"
2765                 );
2766         } else {
2767                 dev_info(&spi->dev, "External clock set as clock provider\n");
2768         }
2769
2770         return ret;
2771 }
2772
2773 /**
2774  * ca8210_unregister_ext_clock() - Unregister ca8210's external clock with
2775  *                                 kernel
2776  * @spi:  Pointer to target ca8210 spi device
2777  */
2778 static void ca8210_unregister_ext_clock(struct spi_device *spi)
2779 {
2780         struct ca8210_priv *priv = spi_get_drvdata(spi);
2781
2782         if (!priv->clk)
2783                 return
2784
2785         of_clk_del_provider(spi->dev.of_node);
2786         clk_unregister(priv->clk);
2787         dev_info(&spi->dev, "External clock unregistered\n");
2788 }
2789
2790 /**
2791  * ca8210_reset_init() - Initialise the reset input to the ca8210
2792  * @spi:  Pointer to target ca8210 spi device
2793  *
2794  * Return: 0 or linux error code
2795  */
2796 static int ca8210_reset_init(struct spi_device *spi)
2797 {
2798         int ret;
2799         struct ca8210_platform_data *pdata = spi->dev.platform_data;
2800
2801         pdata->gpio_reset = of_get_named_gpio(
2802                 spi->dev.of_node,
2803                 "reset-gpio",
2804                 0
2805         );
2806
2807         ret = gpio_direction_output(pdata->gpio_reset, 1);
2808         if (ret < 0) {
2809                 dev_crit(
2810                         &spi->dev,
2811                         "Reset GPIO %d did not set to output mode\n",
2812                         pdata->gpio_reset
2813                 );
2814         }
2815
2816         return ret;
2817 }
2818
2819 /**
2820  * ca8210_interrupt_init() - Initialise the irq output from the ca8210
2821  * @spi:  Pointer to target ca8210 spi device
2822  *
2823  * Return: 0 or linux error code
2824  */
2825 static int ca8210_interrupt_init(struct spi_device *spi)
2826 {
2827         int ret;
2828         struct ca8210_platform_data *pdata = spi->dev.platform_data;
2829
2830         pdata->gpio_irq = of_get_named_gpio(
2831                 spi->dev.of_node,
2832                 "irq-gpio",
2833                 0
2834         );
2835
2836         pdata->irq_id = gpio_to_irq(pdata->gpio_irq);
2837         if (pdata->irq_id < 0) {
2838                 dev_crit(
2839                         &spi->dev,
2840                         "Could not get irq for gpio pin %d\n",
2841                         pdata->gpio_irq
2842                 );
2843                 gpio_free(pdata->gpio_irq);
2844                 return pdata->irq_id;
2845         }
2846
2847         ret = request_irq(
2848                 pdata->irq_id,
2849                 ca8210_interrupt_handler,
2850                 IRQF_TRIGGER_FALLING,
2851                 "ca8210-irq",
2852                 spi_get_drvdata(spi)
2853         );
2854         if (ret) {
2855                 dev_crit(&spi->dev, "request_irq %d failed\n", pdata->irq_id);
2856                 gpio_unexport(pdata->gpio_irq);
2857                 gpio_free(pdata->gpio_irq);
2858         }
2859
2860         return ret;
2861 }
2862
2863 /**
2864  * ca8210_dev_com_init() - Initialise the spi communication component
2865  * @priv:  Pointer to private data structure
2866  *
2867  * Return: 0 or linux error code
2868  */
2869 static int ca8210_dev_com_init(struct ca8210_priv *priv)
2870 {
2871         priv->mlme_workqueue = alloc_ordered_workqueue(
2872                 "MLME work queue",
2873                 WQ_UNBOUND
2874         );
2875         if (!priv->mlme_workqueue) {
2876                 dev_crit(&priv->spi->dev, "alloc of mlme_workqueue failed!\n");
2877                 return -ENOMEM;
2878         }
2879
2880         priv->irq_workqueue = alloc_ordered_workqueue(
2881                 "ca8210 irq worker",
2882                 WQ_UNBOUND
2883         );
2884         if (!priv->irq_workqueue) {
2885                 dev_crit(&priv->spi->dev, "alloc of irq_workqueue failed!\n");
2886                 destroy_workqueue(priv->mlme_workqueue);
2887                 return -ENOMEM;
2888         }
2889
2890         return 0;
2891 }
2892
2893 /**
2894  * ca8210_dev_com_clear() - Deinitialise the spi communication component
2895  * @priv:  Pointer to private data structure
2896  */
2897 static void ca8210_dev_com_clear(struct ca8210_priv *priv)
2898 {
2899         destroy_workqueue(priv->mlme_workqueue);
2900         destroy_workqueue(priv->irq_workqueue);
2901 }
2902
2903 #define CA8210_MAX_TX_POWERS (9)
2904 static const s32 ca8210_tx_powers[CA8210_MAX_TX_POWERS] = {
2905         800, 700, 600, 500, 400, 300, 200, 100, 0
2906 };
2907
2908 #define CA8210_MAX_ED_LEVELS (21)
2909 static const s32 ca8210_ed_levels[CA8210_MAX_ED_LEVELS] = {
2910         -10300, -10250, -10200, -10150, -10100, -10050, -10000, -9950, -9900,
2911         -9850, -9800, -9750, -9700, -9650, -9600, -9550, -9500, -9450, -9400,
2912         -9350, -9300
2913 };
2914
2915 /**
2916  * ca8210_hw_setup() - Populate the ieee802154_hw phy attributes with the
2917  *                     ca8210's defaults
2918  * @ca8210_hw:  Pointer to ieee802154_hw to populate
2919  */
2920 static void ca8210_hw_setup(struct ieee802154_hw *ca8210_hw)
2921 {
2922         /* Support channels 11-26 */
2923         ca8210_hw->phy->supported.channels[0] = CA8210_VALID_CHANNELS;
2924         ca8210_hw->phy->supported.tx_powers_size = CA8210_MAX_TX_POWERS;
2925         ca8210_hw->phy->supported.tx_powers = ca8210_tx_powers;
2926         ca8210_hw->phy->supported.cca_ed_levels_size = CA8210_MAX_ED_LEVELS;
2927         ca8210_hw->phy->supported.cca_ed_levels = ca8210_ed_levels;
2928         ca8210_hw->phy->current_channel = 18;
2929         ca8210_hw->phy->current_page = 0;
2930         ca8210_hw->phy->transmit_power = 800;
2931         ca8210_hw->phy->cca.mode = NL802154_CCA_ENERGY_CARRIER;
2932         ca8210_hw->phy->cca.opt = NL802154_CCA_OPT_ENERGY_CARRIER_AND;
2933         ca8210_hw->phy->cca_ed_level = -9800;
2934         ca8210_hw->phy->symbol_duration = 16;
2935         ca8210_hw->phy->lifs_period = 40 * ca8210_hw->phy->symbol_duration;
2936         ca8210_hw->phy->sifs_period = 12 * ca8210_hw->phy->symbol_duration;
2937         ca8210_hw->flags =
2938                 IEEE802154_HW_AFILT |
2939                 IEEE802154_HW_OMIT_CKSUM |
2940                 IEEE802154_HW_FRAME_RETRIES |
2941                 IEEE802154_HW_PROMISCUOUS |
2942                 IEEE802154_HW_CSMA_PARAMS;
2943         ca8210_hw->phy->flags =
2944                 WPAN_PHY_FLAG_TXPOWER |
2945                 WPAN_PHY_FLAG_CCA_ED_LEVEL |
2946                 WPAN_PHY_FLAG_CCA_MODE;
2947 }
2948
2949 /**
2950  * ca8210_test_interface_init() - Initialise the test file interface
2951  * @priv:  Pointer to private data structure
2952  *
2953  * Provided as an alternative to the standard linux network interface, the test
2954  * interface exposes a file in the filesystem (ca8210_test) that allows
2955  * 802.15.4 SAP Commands and Cascoda EVBME commands to be sent directly to
2956  * the stack.
2957  *
2958  * Return: 0 or linux error code
2959  */
2960 static int ca8210_test_interface_init(struct ca8210_priv *priv)
2961 {
2962         struct ca8210_test *test = &priv->test;
2963         char node_name[32];
2964
2965         snprintf(
2966                 node_name,
2967                 sizeof(node_name),
2968                 "ca8210@%d_%d",
2969                 priv->spi->master->bus_num,
2970                 priv->spi->chip_select
2971         );
2972
2973         test->ca8210_dfs_spi_int = debugfs_create_file(
2974                 node_name,
2975                 0600, /* S_IRUSR | S_IWUSR */
2976                 NULL,
2977                 priv,
2978                 &test_int_fops
2979         );
2980
2981         debugfs_create_symlink("ca8210", NULL, node_name);
2982         init_waitqueue_head(&test->readq);
2983         return kfifo_alloc(
2984                 &test->up_fifo,
2985                 CA8210_TEST_INT_FIFO_SIZE,
2986                 GFP_KERNEL
2987         );
2988 }
2989
2990 /**
2991  * ca8210_test_interface_clear() - Deinitialise the test file interface
2992  * @priv:  Pointer to private data structure
2993  */
2994 static void ca8210_test_interface_clear(struct ca8210_priv *priv)
2995 {
2996         struct ca8210_test *test = &priv->test;
2997
2998         debugfs_remove(test->ca8210_dfs_spi_int);
2999         kfifo_free(&test->up_fifo);
3000         dev_info(&priv->spi->dev, "Test interface removed\n");
3001 }
3002
3003 /**
3004  * ca8210_remove() - Shut down a ca8210 upon being disconnected
3005  * @spi_device:  Pointer to spi device data structure
3006  *
3007  * Return: 0 or linux error code
3008  */
3009 static void ca8210_remove(struct spi_device *spi_device)
3010 {
3011         struct ca8210_priv *priv;
3012         struct ca8210_platform_data *pdata;
3013
3014         dev_info(&spi_device->dev, "Removing ca8210\n");
3015
3016         pdata = spi_device->dev.platform_data;
3017         if (pdata) {
3018                 if (pdata->extclockenable) {
3019                         ca8210_unregister_ext_clock(spi_device);
3020                         ca8210_config_extern_clk(pdata, spi_device, 0);
3021                 }
3022                 free_irq(pdata->irq_id, spi_device->dev.driver_data);
3023                 kfree(pdata);
3024                 spi_device->dev.platform_data = NULL;
3025         }
3026         /* get spi_device private data */
3027         priv = spi_get_drvdata(spi_device);
3028         if (priv) {
3029                 dev_info(
3030                         &spi_device->dev,
3031                         "sync_down = %d, sync_up = %d\n",
3032                         priv->sync_down,
3033                         priv->sync_up
3034                 );
3035                 ca8210_dev_com_clear(spi_device->dev.driver_data);
3036                 if (priv->hw) {
3037                         if (priv->hw_registered)
3038                                 ieee802154_unregister_hw(priv->hw);
3039                         ieee802154_free_hw(priv->hw);
3040                         priv->hw = NULL;
3041                         dev_info(
3042                                 &spi_device->dev,
3043                                 "Unregistered & freed ieee802154_hw.\n"
3044                         );
3045                 }
3046                 if (IS_ENABLED(CONFIG_IEEE802154_CA8210_DEBUGFS))
3047                         ca8210_test_interface_clear(priv);
3048         }
3049 }
3050
3051 /**
3052  * ca8210_probe() - Set up a connected ca8210 upon being detected by the system
3053  * @spi_device:  Pointer to spi device data structure
3054  *
3055  * Return: 0 or linux error code
3056  */
3057 static int ca8210_probe(struct spi_device *spi_device)
3058 {
3059         struct ca8210_priv *priv;
3060         struct ieee802154_hw *hw;
3061         struct ca8210_platform_data *pdata;
3062         int ret;
3063
3064         dev_info(&spi_device->dev, "Inserting ca8210\n");
3065
3066         /* allocate ieee802154_hw and private data */
3067         hw = ieee802154_alloc_hw(sizeof(struct ca8210_priv), &ca8210_phy_ops);
3068         if (!hw) {
3069                 dev_crit(&spi_device->dev, "ieee802154_alloc_hw failed\n");
3070                 ret = -ENOMEM;
3071                 goto error;
3072         }
3073
3074         priv = hw->priv;
3075         priv->hw = hw;
3076         priv->spi = spi_device;
3077         hw->parent = &spi_device->dev;
3078         spin_lock_init(&priv->lock);
3079         priv->async_tx_pending = false;
3080         priv->hw_registered = false;
3081         priv->sync_up = 0;
3082         priv->sync_down = 0;
3083         priv->promiscuous = false;
3084         priv->retries = 0;
3085         init_completion(&priv->ca8210_is_awake);
3086         init_completion(&priv->spi_transfer_complete);
3087         init_completion(&priv->sync_exchange_complete);
3088         spi_set_drvdata(priv->spi, priv);
3089         if (IS_ENABLED(CONFIG_IEEE802154_CA8210_DEBUGFS)) {
3090                 cascoda_api_upstream = ca8210_test_int_driver_write;
3091                 ca8210_test_interface_init(priv);
3092         } else {
3093                 cascoda_api_upstream = NULL;
3094         }
3095         ca8210_hw_setup(hw);
3096         ieee802154_random_extended_addr(&hw->phy->perm_extended_addr);
3097
3098         pdata = kmalloc(sizeof(*pdata), GFP_KERNEL);
3099         if (!pdata) {
3100                 ret = -ENOMEM;
3101                 goto error;
3102         }
3103
3104         priv->spi->dev.platform_data = pdata;
3105         ret = ca8210_get_platform_data(priv->spi, pdata);
3106         if (ret) {
3107                 dev_crit(&spi_device->dev, "ca8210_get_platform_data failed\n");
3108                 goto error;
3109         }
3110
3111         ret = ca8210_dev_com_init(priv);
3112         if (ret) {
3113                 dev_crit(&spi_device->dev, "ca8210_dev_com_init failed\n");
3114                 goto error;
3115         }
3116         ret = ca8210_reset_init(priv->spi);
3117         if (ret) {
3118                 dev_crit(&spi_device->dev, "ca8210_reset_init failed\n");
3119                 goto error;
3120         }
3121
3122         ret = ca8210_interrupt_init(priv->spi);
3123         if (ret) {
3124                 dev_crit(&spi_device->dev, "ca8210_interrupt_init failed\n");
3125                 goto error;
3126         }
3127
3128         msleep(100);
3129
3130         ca8210_reset_send(priv->spi, 1);
3131
3132         ret = tdme_chipinit(priv->spi);
3133         if (ret) {
3134                 dev_crit(&spi_device->dev, "tdme_chipinit failed\n");
3135                 goto error;
3136         }
3137
3138         if (pdata->extclockenable) {
3139                 ret = ca8210_config_extern_clk(pdata, priv->spi, 1);
3140                 if (ret) {
3141                         dev_crit(
3142                                 &spi_device->dev,
3143                                 "ca8210_config_extern_clk failed\n"
3144                         );
3145                         goto error;
3146                 }
3147                 ret = ca8210_register_ext_clock(priv->spi);
3148                 if (ret) {
3149                         dev_crit(
3150                                 &spi_device->dev,
3151                                 "ca8210_register_ext_clock failed\n"
3152                         );
3153                         goto error;
3154                 }
3155         }
3156
3157         ret = ieee802154_register_hw(hw);
3158         if (ret) {
3159                 dev_crit(&spi_device->dev, "ieee802154_register_hw failed\n");
3160                 goto error;
3161         }
3162         priv->hw_registered = true;
3163
3164         return 0;
3165 error:
3166         msleep(100); /* wait for pending spi transfers to complete */
3167         ca8210_remove(spi_device);
3168         return link_to_linux_err(ret);
3169 }
3170
3171 static const struct of_device_id ca8210_of_ids[] = {
3172         {.compatible = "cascoda,ca8210", },
3173         {},
3174 };
3175 MODULE_DEVICE_TABLE(of, ca8210_of_ids);
3176
3177 static struct spi_driver ca8210_spi_driver = {
3178         .driver = {
3179                 .name =                 DRIVER_NAME,
3180                 .owner =                THIS_MODULE,
3181                 .of_match_table =       of_match_ptr(ca8210_of_ids),
3182         },
3183         .probe  =                       ca8210_probe,
3184         .remove =                       ca8210_remove
3185 };
3186
3187 module_spi_driver(ca8210_spi_driver);
3188
3189 MODULE_AUTHOR("Harry Morris <h.morris@cascoda.com>");
3190 MODULE_DESCRIPTION("CA-8210 SoftMAC driver");
3191 MODULE_LICENSE("Dual BSD/GPL");
3192 MODULE_VERSION("1.0");