3176 lines
82 KiB
C
3176 lines
82 KiB
C
/*
|
|
* http://www.cascoda.com/products/ca-821x/
|
|
* Copyright (c) 2016, Cascoda, Ltd.
|
|
* All rights reserved.
|
|
*
|
|
* This code is dual-licensed under both GPLv2 and 3-clause BSD. What follows is
|
|
* the license notice for both respectively.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*******************************************************************************
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <linux/cdev.h>
|
|
#include <linux/clk-provider.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/ieee802154.h>
|
|
#include <linux/io.h>
|
|
#include <linux/kfifo.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spi/spi.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/string.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <net/ieee802154_netdev.h>
|
|
#include <net/mac802154.h>
|
|
|
|
#define DRIVER_NAME "ca8210"
|
|
|
|
/* external clock frequencies */
|
|
#define ONE_MHZ 1000000
|
|
#define TWO_MHZ (2 * ONE_MHZ)
|
|
#define FOUR_MHZ (4 * ONE_MHZ)
|
|
#define EIGHT_MHZ (8 * ONE_MHZ)
|
|
#define SIXTEEN_MHZ (16 * ONE_MHZ)
|
|
|
|
/* spi constants */
|
|
#define CA8210_SPI_BUF_SIZE 256
|
|
#define CA8210_SYNC_TIMEOUT 1000 /* Timeout for synchronous commands [ms] */
|
|
|
|
/* test interface constants */
|
|
#define CA8210_TEST_INT_FILE_NAME "ca8210_test"
|
|
#define CA8210_TEST_INT_FIFO_SIZE 256
|
|
|
|
/* HWME attribute IDs */
|
|
#define HWME_EDTHRESHOLD (0x04)
|
|
#define HWME_EDVALUE (0x06)
|
|
#define HWME_SYSCLKOUT (0x0F)
|
|
#define HWME_LQILIMIT (0x11)
|
|
|
|
/* TDME attribute IDs */
|
|
#define TDME_CHANNEL (0x00)
|
|
#define TDME_ATM_CONFIG (0x06)
|
|
|
|
#define MAX_HWME_ATTRIBUTE_SIZE 16
|
|
#define MAX_TDME_ATTRIBUTE_SIZE 2
|
|
|
|
/* PHY/MAC PIB Attribute Enumerations */
|
|
#define PHY_CURRENT_CHANNEL (0x00)
|
|
#define PHY_TRANSMIT_POWER (0x02)
|
|
#define PHY_CCA_MODE (0x03)
|
|
#define MAC_ASSOCIATION_PERMIT (0x41)
|
|
#define MAC_AUTO_REQUEST (0x42)
|
|
#define MAC_BATT_LIFE_EXT (0x43)
|
|
#define MAC_BATT_LIFE_EXT_PERIODS (0x44)
|
|
#define MAC_BEACON_PAYLOAD (0x45)
|
|
#define MAC_BEACON_PAYLOAD_LENGTH (0x46)
|
|
#define MAC_BEACON_ORDER (0x47)
|
|
#define MAC_GTS_PERMIT (0x4d)
|
|
#define MAC_MAX_CSMA_BACKOFFS (0x4e)
|
|
#define MAC_MIN_BE (0x4f)
|
|
#define MAC_PAN_ID (0x50)
|
|
#define MAC_PROMISCUOUS_MODE (0x51)
|
|
#define MAC_RX_ON_WHEN_IDLE (0x52)
|
|
#define MAC_SHORT_ADDRESS (0x53)
|
|
#define MAC_SUPERFRAME_ORDER (0x54)
|
|
#define MAC_ASSOCIATED_PAN_COORD (0x56)
|
|
#define MAC_MAX_BE (0x57)
|
|
#define MAC_MAX_FRAME_RETRIES (0x59)
|
|
#define MAC_RESPONSE_WAIT_TIME (0x5A)
|
|
#define MAC_SECURITY_ENABLED (0x5D)
|
|
|
|
#define MAC_AUTO_REQUEST_SECURITY_LEVEL (0x78)
|
|
#define MAC_AUTO_REQUEST_KEY_ID_MODE (0x79)
|
|
|
|
#define NS_IEEE_ADDRESS (0xFF) /* Non-standard IEEE address */
|
|
|
|
/* MAC Address Mode Definitions */
|
|
#define MAC_MODE_NO_ADDR (0x00)
|
|
#define MAC_MODE_SHORT_ADDR (0x02)
|
|
#define MAC_MODE_LONG_ADDR (0x03)
|
|
|
|
/* MAC constants */
|
|
#define MAX_BEACON_OVERHEAD (75)
|
|
#define MAX_BEACON_PAYLOAD_LENGTH (IEEE802154_MTU - MAX_BEACON_OVERHEAD)
|
|
|
|
#define MAX_ATTRIBUTE_SIZE (122)
|
|
#define MAX_DATA_SIZE (114)
|
|
|
|
#define CA8210_VALID_CHANNELS (0x07FFF800)
|
|
|
|
/* MAC workarounds for V1.1 and MPW silicon (V0.x) */
|
|
#define CA8210_MAC_WORKAROUNDS (0)
|
|
#define CA8210_MAC_MPW (0)
|
|
|
|
/* memory manipulation macros */
|
|
#define LS_BYTE(x) ((u8)((x) & 0xFF))
|
|
#define MS_BYTE(x) ((u8)(((x) >> 8) & 0xFF))
|
|
|
|
/* message ID codes in SPI commands */
|
|
/* downstream */
|
|
#define MCPS_DATA_REQUEST (0x00)
|
|
#define MLME_ASSOCIATE_REQUEST (0x02)
|
|
#define MLME_ASSOCIATE_RESPONSE (0x03)
|
|
#define MLME_DISASSOCIATE_REQUEST (0x04)
|
|
#define MLME_GET_REQUEST (0x05)
|
|
#define MLME_ORPHAN_RESPONSE (0x06)
|
|
#define MLME_RESET_REQUEST (0x07)
|
|
#define MLME_RX_ENABLE_REQUEST (0x08)
|
|
#define MLME_SCAN_REQUEST (0x09)
|
|
#define MLME_SET_REQUEST (0x0A)
|
|
#define MLME_START_REQUEST (0x0B)
|
|
#define MLME_POLL_REQUEST (0x0D)
|
|
#define HWME_SET_REQUEST (0x0E)
|
|
#define HWME_GET_REQUEST (0x0F)
|
|
#define TDME_SETSFR_REQUEST (0x11)
|
|
#define TDME_GETSFR_REQUEST (0x12)
|
|
#define TDME_SET_REQUEST (0x14)
|
|
/* upstream */
|
|
#define MCPS_DATA_INDICATION (0x00)
|
|
#define MCPS_DATA_CONFIRM (0x01)
|
|
#define MLME_RESET_CONFIRM (0x0A)
|
|
#define MLME_SET_CONFIRM (0x0E)
|
|
#define MLME_START_CONFIRM (0x0F)
|
|
#define HWME_SET_CONFIRM (0x12)
|
|
#define HWME_GET_CONFIRM (0x13)
|
|
#define HWME_WAKEUP_INDICATION (0x15)
|
|
#define TDME_SETSFR_CONFIRM (0x17)
|
|
|
|
/* SPI command IDs */
|
|
/* bit indicating a confirm or indication from slave to master */
|
|
#define SPI_S2M (0x20)
|
|
/* bit indicating a synchronous message */
|
|
#define SPI_SYN (0x40)
|
|
|
|
/* SPI command definitions */
|
|
#define SPI_IDLE (0xFF)
|
|
#define SPI_NACK (0xF0)
|
|
|
|
#define SPI_MCPS_DATA_REQUEST (MCPS_DATA_REQUEST)
|
|
#define SPI_MCPS_DATA_INDICATION (MCPS_DATA_INDICATION + SPI_S2M)
|
|
#define SPI_MCPS_DATA_CONFIRM (MCPS_DATA_CONFIRM + SPI_S2M)
|
|
|
|
#define SPI_MLME_ASSOCIATE_REQUEST (MLME_ASSOCIATE_REQUEST)
|
|
#define SPI_MLME_RESET_REQUEST (MLME_RESET_REQUEST + SPI_SYN)
|
|
#define SPI_MLME_SET_REQUEST (MLME_SET_REQUEST + SPI_SYN)
|
|
#define SPI_MLME_START_REQUEST (MLME_START_REQUEST + SPI_SYN)
|
|
#define SPI_MLME_RESET_CONFIRM (MLME_RESET_CONFIRM + SPI_S2M + SPI_SYN)
|
|
#define SPI_MLME_SET_CONFIRM (MLME_SET_CONFIRM + SPI_S2M + SPI_SYN)
|
|
#define SPI_MLME_START_CONFIRM (MLME_START_CONFIRM + SPI_S2M + SPI_SYN)
|
|
|
|
#define SPI_HWME_SET_REQUEST (HWME_SET_REQUEST + SPI_SYN)
|
|
#define SPI_HWME_GET_REQUEST (HWME_GET_REQUEST + SPI_SYN)
|
|
#define SPI_HWME_SET_CONFIRM (HWME_SET_CONFIRM + SPI_S2M + SPI_SYN)
|
|
#define SPI_HWME_GET_CONFIRM (HWME_GET_CONFIRM + SPI_S2M + SPI_SYN)
|
|
#define SPI_HWME_WAKEUP_INDICATION (HWME_WAKEUP_INDICATION + SPI_S2M)
|
|
|
|
#define SPI_TDME_SETSFR_REQUEST (TDME_SETSFR_REQUEST + SPI_SYN)
|
|
#define SPI_TDME_SET_REQUEST (TDME_SET_REQUEST + SPI_SYN)
|
|
#define SPI_TDME_SETSFR_CONFIRM (TDME_SETSFR_CONFIRM + SPI_S2M + SPI_SYN)
|
|
|
|
/* TDME SFR addresses */
|
|
/* Page 0 */
|
|
#define CA8210_SFR_PACFG (0xB1)
|
|
#define CA8210_SFR_MACCON (0xD8)
|
|
#define CA8210_SFR_PACFGIB (0xFE)
|
|
/* Page 1 */
|
|
#define CA8210_SFR_LOTXCAL (0xBF)
|
|
#define CA8210_SFR_PTHRH (0xD1)
|
|
#define CA8210_SFR_PRECFG (0xD3)
|
|
#define CA8210_SFR_LNAGX40 (0xE1)
|
|
#define CA8210_SFR_LNAGX41 (0xE2)
|
|
#define CA8210_SFR_LNAGX42 (0xE3)
|
|
#define CA8210_SFR_LNAGX43 (0xE4)
|
|
#define CA8210_SFR_LNAGX44 (0xE5)
|
|
#define CA8210_SFR_LNAGX45 (0xE6)
|
|
#define CA8210_SFR_LNAGX46 (0xE7)
|
|
#define CA8210_SFR_LNAGX47 (0xE9)
|
|
|
|
#define PACFGIB_DEFAULT_CURRENT (0x3F)
|
|
#define PTHRH_DEFAULT_THRESHOLD (0x5A)
|
|
#define LNAGX40_DEFAULT_GAIN (0x29) /* 10dB */
|
|
#define LNAGX41_DEFAULT_GAIN (0x54) /* 21dB */
|
|
#define LNAGX42_DEFAULT_GAIN (0x6C) /* 27dB */
|
|
#define LNAGX43_DEFAULT_GAIN (0x7A) /* 30dB */
|
|
#define LNAGX44_DEFAULT_GAIN (0x84) /* 33dB */
|
|
#define LNAGX45_DEFAULT_GAIN (0x8B) /* 34dB */
|
|
#define LNAGX46_DEFAULT_GAIN (0x92) /* 36dB */
|
|
#define LNAGX47_DEFAULT_GAIN (0x96) /* 37dB */
|
|
|
|
#define CA8210_IOCTL_HARD_RESET (0x00)
|
|
|
|
/* Structs/Enums */
|
|
|
|
/**
|
|
* struct cas_control - spi transfer structure
|
|
* @msg: spi_message for each exchange
|
|
* @transfer: spi_transfer for each exchange
|
|
* @tx_buf: source array for transmission
|
|
* @tx_in_buf: array storing bytes received during transmission
|
|
* @priv: pointer to private data
|
|
*
|
|
* This structure stores all the necessary data passed around during a single
|
|
* spi exchange.
|
|
*/
|
|
struct cas_control {
|
|
struct spi_message msg;
|
|
struct spi_transfer transfer;
|
|
|
|
u8 tx_buf[CA8210_SPI_BUF_SIZE];
|
|
u8 tx_in_buf[CA8210_SPI_BUF_SIZE];
|
|
|
|
struct ca8210_priv *priv;
|
|
};
|
|
|
|
/**
|
|
* struct ca8210_test - ca8210 test interface structure
|
|
* @ca8210_dfs_spi_int: pointer to the entry in the debug fs for this device
|
|
* @up_fifo: fifo for upstream messages
|
|
* @readq: read wait queue
|
|
*
|
|
* This structure stores all the data pertaining to the debug interface
|
|
*/
|
|
struct ca8210_test {
|
|
struct dentry *ca8210_dfs_spi_int;
|
|
struct kfifo up_fifo;
|
|
wait_queue_head_t readq;
|
|
};
|
|
|
|
/**
|
|
* struct ca8210_priv - ca8210 private data structure
|
|
* @spi: pointer to the ca8210 spi device object
|
|
* @hw: pointer to the ca8210 ieee802154_hw object
|
|
* @hw_registered: true if hw has been registered with ieee802154
|
|
* @lock: spinlock protecting the private data area
|
|
* @mlme_workqueue: workqueue for triggering MLME Reset
|
|
* @irq_workqueue: workqueue for irq processing
|
|
* @tx_skb: current socket buffer to transmit
|
|
* @nextmsduhandle: msdu handle to pass to the 15.4 MAC layer for the
|
|
* next transmission
|
|
* @clk: external clock provided by the ca8210
|
|
* @last_dsn: sequence number of last data packet received, for
|
|
* resend detection
|
|
* @test: test interface data section for this instance
|
|
* @async_tx_pending: true if an asynchronous transmission was started and
|
|
* is not complete
|
|
* @sync_command_response: pointer to buffer to fill with sync response
|
|
* @ca8210_is_awake: nonzero if ca8210 is initialised, ready for comms
|
|
* @sync_down: counts number of downstream synchronous commands
|
|
* @sync_up: counts number of upstream synchronous commands
|
|
* @spi_transfer_complete: completion object for a single spi_transfer
|
|
* @sync_exchange_complete: completion object for a complete synchronous API
|
|
* exchange
|
|
* @promiscuous: whether the ca8210 is in promiscuous mode or not
|
|
* @retries: records how many times the current pending spi
|
|
* transfer has been retried
|
|
*/
|
|
struct ca8210_priv {
|
|
struct spi_device *spi;
|
|
struct ieee802154_hw *hw;
|
|
bool hw_registered;
|
|
spinlock_t lock;
|
|
struct workqueue_struct *mlme_workqueue;
|
|
struct workqueue_struct *irq_workqueue;
|
|
struct sk_buff *tx_skb;
|
|
u8 nextmsduhandle;
|
|
struct clk *clk;
|
|
int last_dsn;
|
|
struct ca8210_test test;
|
|
bool async_tx_pending;
|
|
u8 *sync_command_response;
|
|
struct completion ca8210_is_awake;
|
|
int sync_down, sync_up;
|
|
struct completion spi_transfer_complete, sync_exchange_complete;
|
|
bool promiscuous;
|
|
int retries;
|
|
};
|
|
|
|
/**
|
|
* struct work_priv_container - link between a work object and the relevant
|
|
* device's private data
|
|
* @work: work object being executed
|
|
* @priv: device's private data section
|
|
*
|
|
*/
|
|
struct work_priv_container {
|
|
struct work_struct work;
|
|
struct ca8210_priv *priv;
|
|
};
|
|
|
|
/**
|
|
* struct ca8210_platform_data - ca8210 platform data structure
|
|
* @extclockenable: true if the external clock is to be enabled
|
|
* @extclockfreq: frequency of the external clock
|
|
* @extclockgpio: ca8210 output gpio of the external clock
|
|
* @gpio_reset: gpio number of ca8210 reset line
|
|
* @gpio_irq: gpio number of ca8210 interrupt line
|
|
* @irq_id: identifier for the ca8210 irq
|
|
*
|
|
*/
|
|
struct ca8210_platform_data {
|
|
bool extclockenable;
|
|
unsigned int extclockfreq;
|
|
unsigned int extclockgpio;
|
|
int gpio_reset;
|
|
int gpio_irq;
|
|
int irq_id;
|
|
};
|
|
|
|
/**
|
|
* struct fulladdr - full MAC addressing information structure
|
|
* @mode: address mode (none, short, extended)
|
|
* @pan_id: 16-bit LE pan id
|
|
* @address: LE address, variable length as specified by mode
|
|
*
|
|
*/
|
|
struct fulladdr {
|
|
u8 mode;
|
|
u8 pan_id[2];
|
|
u8 address[8];
|
|
};
|
|
|
|
/**
|
|
* union macaddr: generic MAC address container
|
|
* @short_address: 16-bit short address
|
|
* @ieee_address: 64-bit extended address as LE byte array
|
|
*
|
|
*/
|
|
union macaddr {
|
|
u16 short_address;
|
|
u8 ieee_address[8];
|
|
};
|
|
|
|
/**
|
|
* struct secspec: security specification for SAP commands
|
|
* @security_level: 0-7, controls level of authentication & encryption
|
|
* @key_id_mode: 0-3, specifies how to obtain key
|
|
* @key_source: extended key retrieval data
|
|
* @key_index: single-byte key identifier
|
|
*
|
|
*/
|
|
struct secspec {
|
|
u8 security_level;
|
|
u8 key_id_mode;
|
|
u8 key_source[8];
|
|
u8 key_index;
|
|
};
|
|
|
|
/* downlink functions parameter set definitions */
|
|
struct mcps_data_request_pset {
|
|
u8 src_addr_mode;
|
|
struct fulladdr dst;
|
|
u8 msdu_length;
|
|
u8 msdu_handle;
|
|
u8 tx_options;
|
|
u8 msdu[MAX_DATA_SIZE];
|
|
};
|
|
|
|
struct mlme_set_request_pset {
|
|
u8 pib_attribute;
|
|
u8 pib_attribute_index;
|
|
u8 pib_attribute_length;
|
|
u8 pib_attribute_value[MAX_ATTRIBUTE_SIZE];
|
|
};
|
|
|
|
struct hwme_set_request_pset {
|
|
u8 hw_attribute;
|
|
u8 hw_attribute_length;
|
|
u8 hw_attribute_value[MAX_HWME_ATTRIBUTE_SIZE];
|
|
};
|
|
|
|
struct hwme_get_request_pset {
|
|
u8 hw_attribute;
|
|
};
|
|
|
|
struct tdme_setsfr_request_pset {
|
|
u8 sfr_page;
|
|
u8 sfr_address;
|
|
u8 sfr_value;
|
|
};
|
|
|
|
/* uplink functions parameter set definitions */
|
|
struct hwme_set_confirm_pset {
|
|
u8 status;
|
|
u8 hw_attribute;
|
|
};
|
|
|
|
struct hwme_get_confirm_pset {
|
|
u8 status;
|
|
u8 hw_attribute;
|
|
u8 hw_attribute_length;
|
|
u8 hw_attribute_value[MAX_HWME_ATTRIBUTE_SIZE];
|
|
};
|
|
|
|
struct tdme_setsfr_confirm_pset {
|
|
u8 status;
|
|
u8 sfr_page;
|
|
u8 sfr_address;
|
|
};
|
|
|
|
struct mac_message {
|
|
u8 command_id;
|
|
u8 length;
|
|
union {
|
|
struct mcps_data_request_pset data_req;
|
|
struct mlme_set_request_pset set_req;
|
|
struct hwme_set_request_pset hwme_set_req;
|
|
struct hwme_get_request_pset hwme_get_req;
|
|
struct tdme_setsfr_request_pset tdme_set_sfr_req;
|
|
struct hwme_set_confirm_pset hwme_set_cnf;
|
|
struct hwme_get_confirm_pset hwme_get_cnf;
|
|
struct tdme_setsfr_confirm_pset tdme_set_sfr_cnf;
|
|
u8 u8param;
|
|
u8 status;
|
|
u8 payload[148];
|
|
} pdata;
|
|
};
|
|
|
|
union pa_cfg_sfr {
|
|
struct {
|
|
u8 bias_current_trim : 3;
|
|
u8 /* reserved */ : 1;
|
|
u8 buffer_capacitor_trim : 3;
|
|
u8 boost : 1;
|
|
};
|
|
u8 paib;
|
|
};
|
|
|
|
struct preamble_cfg_sfr {
|
|
u8 timeout_symbols : 3;
|
|
u8 acquisition_symbols : 3;
|
|
u8 search_symbols : 2;
|
|
};
|
|
|
|
static int (*cascoda_api_upstream)(
|
|
const u8 *buf,
|
|
size_t len,
|
|
void *device_ref
|
|
);
|
|
|
|
/**
|
|
* link_to_linux_err() - Translates an 802.15.4 return code into the closest
|
|
* linux error
|
|
* @link_status: 802.15.4 status code
|
|
*
|
|
* Return: 0 or Linux error code
|
|
*/
|
|
static int link_to_linux_err(int link_status)
|
|
{
|
|
if (link_status < 0) {
|
|
/* status is already a Linux code */
|
|
return link_status;
|
|
}
|
|
switch (link_status) {
|
|
case IEEE802154_SUCCESS:
|
|
case IEEE802154_REALIGNMENT:
|
|
return 0;
|
|
case IEEE802154_IMPROPER_KEY_TYPE:
|
|
return -EKEYREJECTED;
|
|
case IEEE802154_IMPROPER_SECURITY_LEVEL:
|
|
case IEEE802154_UNSUPPORTED_LEGACY:
|
|
case IEEE802154_DENIED:
|
|
return -EACCES;
|
|
case IEEE802154_BEACON_LOST:
|
|
case IEEE802154_NO_ACK:
|
|
case IEEE802154_NO_BEACON:
|
|
return -ENETUNREACH;
|
|
case IEEE802154_CHANNEL_ACCESS_FAILURE:
|
|
case IEEE802154_TX_ACTIVE:
|
|
case IEEE802154_SCAN_IN_PROGRESS:
|
|
return -EBUSY;
|
|
case IEEE802154_DISABLE_TRX_FAILURE:
|
|
case IEEE802154_OUT_OF_CAP:
|
|
return -EAGAIN;
|
|
case IEEE802154_FRAME_TOO_LONG:
|
|
return -EMSGSIZE;
|
|
case IEEE802154_INVALID_GTS:
|
|
case IEEE802154_PAST_TIME:
|
|
return -EBADSLT;
|
|
case IEEE802154_INVALID_HANDLE:
|
|
return -EBADMSG;
|
|
case IEEE802154_INVALID_PARAMETER:
|
|
case IEEE802154_UNSUPPORTED_ATTRIBUTE:
|
|
case IEEE802154_ON_TIME_TOO_LONG:
|
|
case IEEE802154_INVALID_INDEX:
|
|
return -EINVAL;
|
|
case IEEE802154_NO_DATA:
|
|
return -ENODATA;
|
|
case IEEE802154_NO_SHORT_ADDRESS:
|
|
return -EFAULT;
|
|
case IEEE802154_PAN_ID_CONFLICT:
|
|
return -EADDRINUSE;
|
|
case IEEE802154_TRANSACTION_EXPIRED:
|
|
return -ETIME;
|
|
case IEEE802154_TRANSACTION_OVERFLOW:
|
|
return -ENOBUFS;
|
|
case IEEE802154_UNAVAILABLE_KEY:
|
|
return -ENOKEY;
|
|
case IEEE802154_INVALID_ADDRESS:
|
|
return -ENXIO;
|
|
case IEEE802154_TRACKING_OFF:
|
|
case IEEE802154_SUPERFRAME_OVERLAP:
|
|
return -EREMOTEIO;
|
|
case IEEE802154_LIMIT_REACHED:
|
|
return -EDQUOT;
|
|
case IEEE802154_READ_ONLY:
|
|
return -EROFS;
|
|
default:
|
|
return -EPROTO;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_int_driver_write() - Writes a message to the test interface to be
|
|
* read by the userspace
|
|
* @buf: Buffer containing upstream message
|
|
* @len: length of message to write
|
|
* @spi: SPI device of message originator
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_test_int_driver_write(
|
|
const u8 *buf,
|
|
size_t len,
|
|
void *spi
|
|
)
|
|
{
|
|
struct ca8210_priv *priv = spi_get_drvdata(spi);
|
|
struct ca8210_test *test = &priv->test;
|
|
char *fifo_buffer;
|
|
int i;
|
|
|
|
dev_dbg(
|
|
&priv->spi->dev,
|
|
"test_interface: Buffering upstream message:\n"
|
|
);
|
|
for (i = 0; i < len; i++)
|
|
dev_dbg(&priv->spi->dev, "%#03x\n", buf[i]);
|
|
|
|
fifo_buffer = kmemdup(buf, len, GFP_KERNEL);
|
|
if (!fifo_buffer)
|
|
return -ENOMEM;
|
|
kfifo_in(&test->up_fifo, &fifo_buffer, 4);
|
|
wake_up_interruptible(&priv->test.readq);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* SPI Operation */
|
|
|
|
static int ca8210_net_rx(
|
|
struct ieee802154_hw *hw,
|
|
u8 *command,
|
|
size_t len
|
|
);
|
|
static u8 mlme_reset_request_sync(
|
|
u8 set_default_pib,
|
|
void *device_ref
|
|
);
|
|
static int ca8210_spi_transfer(
|
|
struct spi_device *spi,
|
|
const u8 *buf,
|
|
size_t len
|
|
);
|
|
|
|
/**
|
|
* ca8210_reset_send() - Hard resets the ca8210 for a given time
|
|
* @spi: Pointer to target ca8210 spi device
|
|
* @ms: Milliseconds to hold the reset line low for
|
|
*/
|
|
static void ca8210_reset_send(struct spi_device *spi, unsigned int ms)
|
|
{
|
|
struct ca8210_platform_data *pdata = spi->dev.platform_data;
|
|
struct ca8210_priv *priv = spi_get_drvdata(spi);
|
|
long status;
|
|
|
|
gpio_set_value(pdata->gpio_reset, 0);
|
|
reinit_completion(&priv->ca8210_is_awake);
|
|
msleep(ms);
|
|
gpio_set_value(pdata->gpio_reset, 1);
|
|
priv->promiscuous = false;
|
|
|
|
/* Wait until wakeup indication seen */
|
|
status = wait_for_completion_interruptible_timeout(
|
|
&priv->ca8210_is_awake,
|
|
msecs_to_jiffies(CA8210_SYNC_TIMEOUT)
|
|
);
|
|
if (status == 0) {
|
|
dev_crit(
|
|
&spi->dev,
|
|
"Fatal: No wakeup from ca8210 after reset!\n"
|
|
);
|
|
}
|
|
|
|
dev_dbg(&spi->dev, "Reset the device\n");
|
|
}
|
|
|
|
/**
|
|
* ca8210_mlme_reset_worker() - Resets the MLME, Called when the MAC OVERFLOW
|
|
* condition happens.
|
|
* @work: Pointer to work being executed
|
|
*/
|
|
static void ca8210_mlme_reset_worker(struct work_struct *work)
|
|
{
|
|
struct work_priv_container *wpc = container_of(
|
|
work,
|
|
struct work_priv_container,
|
|
work
|
|
);
|
|
struct ca8210_priv *priv = wpc->priv;
|
|
|
|
mlme_reset_request_sync(0, priv->spi);
|
|
kfree(wpc);
|
|
}
|
|
|
|
/**
|
|
* ca8210_rx_done() - Calls various message dispatches responding to a received
|
|
* command
|
|
* @cas_ctl: Pointer to the cas_control object for the relevant spi transfer
|
|
*
|
|
* Presents a received SAP command from the ca8210 to the Cascoda EVBME, test
|
|
* interface and network driver.
|
|
*/
|
|
static void ca8210_rx_done(struct cas_control *cas_ctl)
|
|
{
|
|
u8 *buf;
|
|
unsigned int len;
|
|
struct work_priv_container *mlme_reset_wpc;
|
|
struct ca8210_priv *priv = cas_ctl->priv;
|
|
|
|
buf = cas_ctl->tx_in_buf;
|
|
len = buf[1] + 2;
|
|
if (len > CA8210_SPI_BUF_SIZE) {
|
|
dev_crit(
|
|
&priv->spi->dev,
|
|
"Received packet len (%u) erroneously long\n",
|
|
len
|
|
);
|
|
goto finish;
|
|
}
|
|
|
|
if (buf[0] & SPI_SYN) {
|
|
if (priv->sync_command_response) {
|
|
memcpy(priv->sync_command_response, buf, len);
|
|
complete(&priv->sync_exchange_complete);
|
|
} else {
|
|
if (cascoda_api_upstream)
|
|
cascoda_api_upstream(buf, len, priv->spi);
|
|
priv->sync_up++;
|
|
}
|
|
} else {
|
|
if (cascoda_api_upstream)
|
|
cascoda_api_upstream(buf, len, priv->spi);
|
|
}
|
|
|
|
ca8210_net_rx(priv->hw, buf, len);
|
|
if (buf[0] == SPI_MCPS_DATA_CONFIRM) {
|
|
if (buf[3] == IEEE802154_TRANSACTION_OVERFLOW) {
|
|
dev_info(
|
|
&priv->spi->dev,
|
|
"Waiting for transaction overflow to stabilise...\n");
|
|
msleep(2000);
|
|
dev_info(
|
|
&priv->spi->dev,
|
|
"Resetting MAC...\n");
|
|
|
|
mlme_reset_wpc = kmalloc(sizeof(*mlme_reset_wpc),
|
|
GFP_KERNEL);
|
|
if (!mlme_reset_wpc)
|
|
goto finish;
|
|
INIT_WORK(
|
|
&mlme_reset_wpc->work,
|
|
ca8210_mlme_reset_worker
|
|
);
|
|
mlme_reset_wpc->priv = priv;
|
|
queue_work(priv->mlme_workqueue, &mlme_reset_wpc->work);
|
|
}
|
|
} else if (buf[0] == SPI_HWME_WAKEUP_INDICATION) {
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Wakeup indication received, reason:\n"
|
|
);
|
|
switch (buf[2]) {
|
|
case 0:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Transceiver woken up from Power Up / System Reset\n"
|
|
);
|
|
break;
|
|
case 1:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Watchdog Timer Time-Out\n"
|
|
);
|
|
break;
|
|
case 2:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Transceiver woken up from Power-Off by Sleep Timer Time-Out\n");
|
|
break;
|
|
case 3:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Transceiver woken up from Power-Off by GPIO Activity\n"
|
|
);
|
|
break;
|
|
case 4:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Transceiver woken up from Standby by Sleep Timer Time-Out\n"
|
|
);
|
|
break;
|
|
case 5:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Transceiver woken up from Standby by GPIO Activity\n"
|
|
);
|
|
break;
|
|
case 6:
|
|
dev_notice(
|
|
&priv->spi->dev,
|
|
"Sleep-Timer Time-Out in Active Mode\n"
|
|
);
|
|
break;
|
|
default:
|
|
dev_warn(&priv->spi->dev, "Wakeup reason unknown\n");
|
|
break;
|
|
}
|
|
complete(&priv->ca8210_is_awake);
|
|
}
|
|
|
|
finish:;
|
|
}
|
|
|
|
static void ca8210_remove(struct spi_device *spi_device);
|
|
|
|
/**
|
|
* ca8210_spi_transfer_complete() - Called when a single spi transfer has
|
|
* completed
|
|
* @context: Pointer to the cas_control object for the finished transfer
|
|
*/
|
|
static void ca8210_spi_transfer_complete(void *context)
|
|
{
|
|
struct cas_control *cas_ctl = context;
|
|
struct ca8210_priv *priv = cas_ctl->priv;
|
|
bool duplex_rx = false;
|
|
int i;
|
|
u8 retry_buffer[CA8210_SPI_BUF_SIZE];
|
|
|
|
if (
|
|
cas_ctl->tx_in_buf[0] == SPI_NACK ||
|
|
(cas_ctl->tx_in_buf[0] == SPI_IDLE &&
|
|
cas_ctl->tx_in_buf[1] == SPI_NACK)
|
|
) {
|
|
/* ca8210 is busy */
|
|
dev_info(&priv->spi->dev, "ca8210 was busy during attempted write\n");
|
|
if (cas_ctl->tx_buf[0] == SPI_IDLE) {
|
|
dev_warn(
|
|
&priv->spi->dev,
|
|
"IRQ servicing NACKd, dropping transfer\n"
|
|
);
|
|
kfree(cas_ctl);
|
|
return;
|
|
}
|
|
if (priv->retries > 3) {
|
|
dev_err(&priv->spi->dev, "too many retries!\n");
|
|
kfree(cas_ctl);
|
|
ca8210_remove(priv->spi);
|
|
return;
|
|
}
|
|
memcpy(retry_buffer, cas_ctl->tx_buf, CA8210_SPI_BUF_SIZE);
|
|
kfree(cas_ctl);
|
|
ca8210_spi_transfer(
|
|
priv->spi,
|
|
retry_buffer,
|
|
CA8210_SPI_BUF_SIZE
|
|
);
|
|
priv->retries++;
|
|
dev_info(&priv->spi->dev, "retried spi write\n");
|
|
return;
|
|
} else if (
|
|
cas_ctl->tx_in_buf[0] != SPI_IDLE &&
|
|
cas_ctl->tx_in_buf[0] != SPI_NACK
|
|
) {
|
|
duplex_rx = true;
|
|
}
|
|
|
|
if (duplex_rx) {
|
|
dev_dbg(&priv->spi->dev, "READ CMD DURING TX\n");
|
|
for (i = 0; i < cas_ctl->tx_in_buf[1] + 2; i++)
|
|
dev_dbg(
|
|
&priv->spi->dev,
|
|
"%#03x\n",
|
|
cas_ctl->tx_in_buf[i]
|
|
);
|
|
ca8210_rx_done(cas_ctl);
|
|
}
|
|
complete(&priv->spi_transfer_complete);
|
|
kfree(cas_ctl);
|
|
priv->retries = 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_spi_transfer() - Initiate duplex spi transfer with ca8210
|
|
* @spi: Pointer to spi device for transfer
|
|
* @buf: Octet array to send
|
|
* @len: length of the buffer being sent
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_spi_transfer(
|
|
struct spi_device *spi,
|
|
const u8 *buf,
|
|
size_t len
|
|
)
|
|
{
|
|
int i, status = 0;
|
|
struct ca8210_priv *priv;
|
|
struct cas_control *cas_ctl;
|
|
|
|
if (!spi) {
|
|
pr_crit("NULL spi device passed to %s\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
|
|
priv = spi_get_drvdata(spi);
|
|
reinit_completion(&priv->spi_transfer_complete);
|
|
|
|
dev_dbg(&spi->dev, "%s called\n", __func__);
|
|
|
|
cas_ctl = kzalloc(sizeof(*cas_ctl), GFP_ATOMIC);
|
|
if (!cas_ctl)
|
|
return -ENOMEM;
|
|
|
|
cas_ctl->priv = priv;
|
|
memset(cas_ctl->tx_buf, SPI_IDLE, CA8210_SPI_BUF_SIZE);
|
|
memset(cas_ctl->tx_in_buf, SPI_IDLE, CA8210_SPI_BUF_SIZE);
|
|
memcpy(cas_ctl->tx_buf, buf, len);
|
|
|
|
for (i = 0; i < len; i++)
|
|
dev_dbg(&spi->dev, "%#03x\n", cas_ctl->tx_buf[i]);
|
|
|
|
spi_message_init(&cas_ctl->msg);
|
|
|
|
cas_ctl->transfer.tx_nbits = 1; /* 1 MOSI line */
|
|
cas_ctl->transfer.rx_nbits = 1; /* 1 MISO line */
|
|
cas_ctl->transfer.speed_hz = 0; /* Use device setting */
|
|
cas_ctl->transfer.bits_per_word = 0; /* Use device setting */
|
|
cas_ctl->transfer.tx_buf = cas_ctl->tx_buf;
|
|
cas_ctl->transfer.rx_buf = cas_ctl->tx_in_buf;
|
|
cas_ctl->transfer.delay.value = 0;
|
|
cas_ctl->transfer.delay.unit = SPI_DELAY_UNIT_USECS;
|
|
cas_ctl->transfer.cs_change = 0;
|
|
cas_ctl->transfer.len = sizeof(struct mac_message);
|
|
cas_ctl->msg.complete = ca8210_spi_transfer_complete;
|
|
cas_ctl->msg.context = cas_ctl;
|
|
|
|
spi_message_add_tail(
|
|
&cas_ctl->transfer,
|
|
&cas_ctl->msg
|
|
);
|
|
|
|
status = spi_async(spi, &cas_ctl->msg);
|
|
if (status < 0) {
|
|
dev_crit(
|
|
&spi->dev,
|
|
"status %d from spi_sync in write\n",
|
|
status
|
|
);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* ca8210_spi_exchange() - Exchange API/SAP commands with the radio
|
|
* @buf: Octet array of command being sent downstream
|
|
* @len: length of buf
|
|
* @response: buffer for storing synchronous response
|
|
* @device_ref: spi_device pointer for ca8210
|
|
*
|
|
* Effectively calls ca8210_spi_transfer to write buf[] to the spi, then for
|
|
* synchronous commands waits for the corresponding response to be read from
|
|
* the spi before returning. The response is written to the response parameter.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_spi_exchange(
|
|
const u8 *buf,
|
|
size_t len,
|
|
u8 *response,
|
|
void *device_ref
|
|
)
|
|
{
|
|
int status = 0;
|
|
struct spi_device *spi = device_ref;
|
|
struct ca8210_priv *priv = spi->dev.driver_data;
|
|
long wait_remaining;
|
|
|
|
if ((buf[0] & SPI_SYN) && response) { /* if sync wait for confirm */
|
|
reinit_completion(&priv->sync_exchange_complete);
|
|
priv->sync_command_response = response;
|
|
}
|
|
|
|
do {
|
|
reinit_completion(&priv->spi_transfer_complete);
|
|
status = ca8210_spi_transfer(priv->spi, buf, len);
|
|
if (status) {
|
|
dev_warn(
|
|
&spi->dev,
|
|
"spi write failed, returned %d\n",
|
|
status
|
|
);
|
|
if (status == -EBUSY)
|
|
continue;
|
|
if (((buf[0] & SPI_SYN) && response))
|
|
complete(&priv->sync_exchange_complete);
|
|
goto cleanup;
|
|
}
|
|
|
|
wait_remaining = wait_for_completion_interruptible_timeout(
|
|
&priv->spi_transfer_complete,
|
|
msecs_to_jiffies(1000)
|
|
);
|
|
if (wait_remaining == -ERESTARTSYS) {
|
|
status = -ERESTARTSYS;
|
|
} else if (wait_remaining == 0) {
|
|
dev_err(
|
|
&spi->dev,
|
|
"SPI downstream transfer timed out!\n"
|
|
);
|
|
status = -ETIME;
|
|
goto cleanup;
|
|
}
|
|
} while (status < 0);
|
|
|
|
if (!((buf[0] & SPI_SYN) && response))
|
|
goto cleanup;
|
|
|
|
wait_remaining = wait_for_completion_interruptible_timeout(
|
|
&priv->sync_exchange_complete,
|
|
msecs_to_jiffies(CA8210_SYNC_TIMEOUT)
|
|
);
|
|
if (wait_remaining == -ERESTARTSYS) {
|
|
status = -ERESTARTSYS;
|
|
} else if (wait_remaining == 0) {
|
|
dev_err(
|
|
&spi->dev,
|
|
"Synchronous confirm timeout\n"
|
|
);
|
|
status = -ETIME;
|
|
}
|
|
|
|
cleanup:
|
|
priv->sync_command_response = NULL;
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* ca8210_interrupt_handler() - Called when an irq is received from the ca8210
|
|
* @irq: Id of the irq being handled
|
|
* @dev_id: Pointer passed by the system, pointing to the ca8210's private data
|
|
*
|
|
* This function is called when the irq line from the ca8210 is asserted,
|
|
* signifying that the ca8210 has a message to send upstream to us. Starts the
|
|
* asynchronous spi read.
|
|
*
|
|
* Return: irq return code
|
|
*/
|
|
static irqreturn_t ca8210_interrupt_handler(int irq, void *dev_id)
|
|
{
|
|
struct ca8210_priv *priv = dev_id;
|
|
int status;
|
|
|
|
dev_dbg(&priv->spi->dev, "irq: Interrupt occurred\n");
|
|
do {
|
|
status = ca8210_spi_transfer(priv->spi, NULL, 0);
|
|
if (status && (status != -EBUSY)) {
|
|
dev_warn(
|
|
&priv->spi->dev,
|
|
"spi read failed, returned %d\n",
|
|
status
|
|
);
|
|
}
|
|
} while (status == -EBUSY);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int (*cascoda_api_downstream)(
|
|
const u8 *buf,
|
|
size_t len,
|
|
u8 *response,
|
|
void *device_ref
|
|
) = ca8210_spi_exchange;
|
|
|
|
/* Cascoda API / 15.4 SAP Primitives */
|
|
|
|
/**
|
|
* tdme_setsfr_request_sync() - TDME_SETSFR_request/confirm according to API
|
|
* @sfr_page: SFR Page
|
|
* @sfr_address: SFR Address
|
|
* @sfr_value: SFR Value
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of TDME-SETSFR.confirm
|
|
*/
|
|
static u8 tdme_setsfr_request_sync(
|
|
u8 sfr_page,
|
|
u8 sfr_address,
|
|
u8 sfr_value,
|
|
void *device_ref
|
|
)
|
|
{
|
|
int ret;
|
|
struct mac_message command, response;
|
|
struct spi_device *spi = device_ref;
|
|
|
|
command.command_id = SPI_TDME_SETSFR_REQUEST;
|
|
command.length = 3;
|
|
command.pdata.tdme_set_sfr_req.sfr_page = sfr_page;
|
|
command.pdata.tdme_set_sfr_req.sfr_address = sfr_address;
|
|
command.pdata.tdme_set_sfr_req.sfr_value = sfr_value;
|
|
response.command_id = SPI_IDLE;
|
|
ret = cascoda_api_downstream(
|
|
&command.command_id,
|
|
command.length + 2,
|
|
&response.command_id,
|
|
device_ref
|
|
);
|
|
if (ret) {
|
|
dev_crit(&spi->dev, "cascoda_api_downstream returned %d", ret);
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
if (response.command_id != SPI_TDME_SETSFR_CONFIRM) {
|
|
dev_crit(
|
|
&spi->dev,
|
|
"sync response to SPI_TDME_SETSFR_REQUEST was not SPI_TDME_SETSFR_CONFIRM, it was %d\n",
|
|
response.command_id
|
|
);
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
return response.pdata.tdme_set_sfr_cnf.status;
|
|
}
|
|
|
|
/**
|
|
* tdme_chipinit() - TDME Chip Register Default Initialisation Macro
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of API calls
|
|
*/
|
|
static u8 tdme_chipinit(void *device_ref)
|
|
{
|
|
u8 status = IEEE802154_SUCCESS;
|
|
u8 sfr_address;
|
|
struct spi_device *spi = device_ref;
|
|
struct preamble_cfg_sfr pre_cfg_value = {
|
|
.timeout_symbols = 3,
|
|
.acquisition_symbols = 3,
|
|
.search_symbols = 1,
|
|
};
|
|
/* LNA Gain Settings */
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX40),
|
|
LNAGX40_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX41),
|
|
LNAGX41_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX42),
|
|
LNAGX42_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX43),
|
|
LNAGX43_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX44),
|
|
LNAGX44_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX45),
|
|
LNAGX45_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX46),
|
|
LNAGX46_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_LNAGX47),
|
|
LNAGX47_DEFAULT_GAIN, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
/* Preamble Timing Config */
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_PRECFG),
|
|
*((u8 *)&pre_cfg_value), device_ref);
|
|
if (status)
|
|
goto finish;
|
|
/* Preamble Threshold High */
|
|
status = tdme_setsfr_request_sync(
|
|
1, (sfr_address = CA8210_SFR_PTHRH),
|
|
PTHRH_DEFAULT_THRESHOLD, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
/* Tx Output Power 8 dBm */
|
|
status = tdme_setsfr_request_sync(
|
|
0, (sfr_address = CA8210_SFR_PACFGIB),
|
|
PACFGIB_DEFAULT_CURRENT, device_ref);
|
|
if (status)
|
|
goto finish;
|
|
|
|
finish:
|
|
if (status != IEEE802154_SUCCESS) {
|
|
dev_err(
|
|
&spi->dev,
|
|
"failed to set sfr at %#03x, status = %#03x\n",
|
|
sfr_address,
|
|
status
|
|
);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* tdme_channelinit() - TDME Channel Register Default Initialisation Macro (Tx)
|
|
* @channel: 802.15.4 channel to initialise chip for
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of API calls
|
|
*/
|
|
static u8 tdme_channelinit(u8 channel, void *device_ref)
|
|
{
|
|
/* Transceiver front-end local oscillator tx two-point calibration
|
|
* value. Tuned for the hardware.
|
|
*/
|
|
u8 txcalval;
|
|
|
|
if (channel >= 25)
|
|
txcalval = 0xA7;
|
|
else if (channel >= 23)
|
|
txcalval = 0xA8;
|
|
else if (channel >= 22)
|
|
txcalval = 0xA9;
|
|
else if (channel >= 20)
|
|
txcalval = 0xAA;
|
|
else if (channel >= 17)
|
|
txcalval = 0xAB;
|
|
else if (channel >= 16)
|
|
txcalval = 0xAC;
|
|
else if (channel >= 14)
|
|
txcalval = 0xAD;
|
|
else if (channel >= 12)
|
|
txcalval = 0xAE;
|
|
else
|
|
txcalval = 0xAF;
|
|
|
|
return tdme_setsfr_request_sync(
|
|
1,
|
|
CA8210_SFR_LOTXCAL,
|
|
txcalval,
|
|
device_ref
|
|
); /* LO Tx Cal */
|
|
}
|
|
|
|
/**
|
|
* tdme_checkpibattribute() - Checks Attribute Values that are not checked in
|
|
* MAC
|
|
* @pib_attribute: Attribute Number
|
|
* @pib_attribute_length: Attribute length
|
|
* @pib_attribute_value: Pointer to Attribute Value
|
|
*
|
|
* Return: 802.15.4 status code of checks
|
|
*/
|
|
static u8 tdme_checkpibattribute(
|
|
u8 pib_attribute,
|
|
u8 pib_attribute_length,
|
|
const void *pib_attribute_value
|
|
)
|
|
{
|
|
u8 status = IEEE802154_SUCCESS;
|
|
u8 value;
|
|
|
|
value = *((u8 *)pib_attribute_value);
|
|
|
|
switch (pib_attribute) {
|
|
/* PHY */
|
|
case PHY_TRANSMIT_POWER:
|
|
if (value > 0x3F)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case PHY_CCA_MODE:
|
|
if (value > 0x03)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
/* MAC */
|
|
case MAC_BATT_LIFE_EXT_PERIODS:
|
|
if (value < 6 || value > 41)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_BEACON_PAYLOAD:
|
|
if (pib_attribute_length > MAX_BEACON_PAYLOAD_LENGTH)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_BEACON_PAYLOAD_LENGTH:
|
|
if (value > MAX_BEACON_PAYLOAD_LENGTH)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_BEACON_ORDER:
|
|
if (value > 15)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_MAX_BE:
|
|
if (value < 3 || value > 8)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_MAX_CSMA_BACKOFFS:
|
|
if (value > 5)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_MAX_FRAME_RETRIES:
|
|
if (value > 7)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_MIN_BE:
|
|
if (value > 8)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_RESPONSE_WAIT_TIME:
|
|
if (value < 2 || value > 64)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_SUPERFRAME_ORDER:
|
|
if (value > 15)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
/* boolean */
|
|
case MAC_ASSOCIATED_PAN_COORD:
|
|
case MAC_ASSOCIATION_PERMIT:
|
|
case MAC_AUTO_REQUEST:
|
|
case MAC_BATT_LIFE_EXT:
|
|
case MAC_GTS_PERMIT:
|
|
case MAC_PROMISCUOUS_MODE:
|
|
case MAC_RX_ON_WHEN_IDLE:
|
|
case MAC_SECURITY_ENABLED:
|
|
if (value > 1)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
/* MAC SEC */
|
|
case MAC_AUTO_REQUEST_SECURITY_LEVEL:
|
|
if (value > 7)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
case MAC_AUTO_REQUEST_KEY_ID_MODE:
|
|
if (value > 3)
|
|
status = IEEE802154_INVALID_PARAMETER;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* tdme_settxpower() - Sets the tx power for MLME_SET phyTransmitPower
|
|
* @txp: Transmit Power
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Normalised to 802.15.4 Definition (6-bit, signed):
|
|
* Bit 7-6: not used
|
|
* Bit 5-0: tx power (-32 - +31 dB)
|
|
*
|
|
* Return: 802.15.4 status code of api calls
|
|
*/
|
|
static u8 tdme_settxpower(u8 txp, void *device_ref)
|
|
{
|
|
u8 status;
|
|
s8 txp_val;
|
|
u8 txp_ext;
|
|
union pa_cfg_sfr pa_cfg_val;
|
|
|
|
/* extend from 6 to 8 bit */
|
|
txp_ext = 0x3F & txp;
|
|
if (txp_ext & 0x20)
|
|
txp_ext += 0xC0;
|
|
txp_val = (s8)txp_ext;
|
|
|
|
if (CA8210_MAC_MPW) {
|
|
if (txp_val > 0) {
|
|
/* 8 dBm: ptrim = 5, itrim = +3 => +4 dBm */
|
|
pa_cfg_val.bias_current_trim = 3;
|
|
pa_cfg_val.buffer_capacitor_trim = 5;
|
|
pa_cfg_val.boost = 1;
|
|
} else {
|
|
/* 0 dBm: ptrim = 7, itrim = +3 => -6 dBm */
|
|
pa_cfg_val.bias_current_trim = 3;
|
|
pa_cfg_val.buffer_capacitor_trim = 7;
|
|
pa_cfg_val.boost = 0;
|
|
}
|
|
/* write PACFG */
|
|
status = tdme_setsfr_request_sync(
|
|
0,
|
|
CA8210_SFR_PACFG,
|
|
pa_cfg_val.paib,
|
|
device_ref
|
|
);
|
|
} else {
|
|
/* Look-Up Table for Setting Current and Frequency Trim values
|
|
* for desired Output Power
|
|
*/
|
|
if (txp_val > 8) {
|
|
pa_cfg_val.paib = 0x3F;
|
|
} else if (txp_val == 8) {
|
|
pa_cfg_val.paib = 0x32;
|
|
} else if (txp_val == 7) {
|
|
pa_cfg_val.paib = 0x22;
|
|
} else if (txp_val == 6) {
|
|
pa_cfg_val.paib = 0x18;
|
|
} else if (txp_val == 5) {
|
|
pa_cfg_val.paib = 0x10;
|
|
} else if (txp_val == 4) {
|
|
pa_cfg_val.paib = 0x0C;
|
|
} else if (txp_val == 3) {
|
|
pa_cfg_val.paib = 0x08;
|
|
} else if (txp_val == 2) {
|
|
pa_cfg_val.paib = 0x05;
|
|
} else if (txp_val == 1) {
|
|
pa_cfg_val.paib = 0x03;
|
|
} else if (txp_val == 0) {
|
|
pa_cfg_val.paib = 0x01;
|
|
} else { /* < 0 */
|
|
pa_cfg_val.paib = 0x00;
|
|
}
|
|
/* write PACFGIB */
|
|
status = tdme_setsfr_request_sync(
|
|
0,
|
|
CA8210_SFR_PACFGIB,
|
|
pa_cfg_val.paib,
|
|
device_ref
|
|
);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* mcps_data_request() - mcps_data_request (Send Data) according to API Spec
|
|
* @src_addr_mode: Source Addressing Mode
|
|
* @dst_address_mode: Destination Addressing Mode
|
|
* @dst_pan_id: Destination PAN ID
|
|
* @dst_addr: Pointer to Destination Address
|
|
* @msdu_length: length of Data
|
|
* @msdu: Pointer to Data
|
|
* @msdu_handle: Handle of Data
|
|
* @tx_options: Tx Options Bit Field
|
|
* @security: Pointer to Security Structure or NULL
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of action
|
|
*/
|
|
static u8 mcps_data_request(
|
|
u8 src_addr_mode,
|
|
u8 dst_address_mode,
|
|
u16 dst_pan_id,
|
|
union macaddr *dst_addr,
|
|
u8 msdu_length,
|
|
u8 *msdu,
|
|
u8 msdu_handle,
|
|
u8 tx_options,
|
|
struct secspec *security,
|
|
void *device_ref
|
|
)
|
|
{
|
|
struct secspec *psec;
|
|
struct mac_message command;
|
|
|
|
command.command_id = SPI_MCPS_DATA_REQUEST;
|
|
command.pdata.data_req.src_addr_mode = src_addr_mode;
|
|
command.pdata.data_req.dst.mode = dst_address_mode;
|
|
if (dst_address_mode != MAC_MODE_NO_ADDR) {
|
|
command.pdata.data_req.dst.pan_id[0] = LS_BYTE(dst_pan_id);
|
|
command.pdata.data_req.dst.pan_id[1] = MS_BYTE(dst_pan_id);
|
|
if (dst_address_mode == MAC_MODE_SHORT_ADDR) {
|
|
command.pdata.data_req.dst.address[0] = LS_BYTE(
|
|
dst_addr->short_address
|
|
);
|
|
command.pdata.data_req.dst.address[1] = MS_BYTE(
|
|
dst_addr->short_address
|
|
);
|
|
} else { /* MAC_MODE_LONG_ADDR*/
|
|
memcpy(
|
|
command.pdata.data_req.dst.address,
|
|
dst_addr->ieee_address,
|
|
8
|
|
);
|
|
}
|
|
}
|
|
command.pdata.data_req.msdu_length = msdu_length;
|
|
command.pdata.data_req.msdu_handle = msdu_handle;
|
|
command.pdata.data_req.tx_options = tx_options;
|
|
memcpy(command.pdata.data_req.msdu, msdu, msdu_length);
|
|
psec = (struct secspec *)(command.pdata.data_req.msdu + msdu_length);
|
|
command.length = sizeof(struct mcps_data_request_pset) -
|
|
MAX_DATA_SIZE + msdu_length;
|
|
if (!security || security->security_level == 0) {
|
|
psec->security_level = 0;
|
|
command.length += 1;
|
|
} else {
|
|
*psec = *security;
|
|
command.length += sizeof(struct secspec);
|
|
}
|
|
|
|
if (ca8210_spi_transfer(device_ref, &command.command_id,
|
|
command.length + 2))
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
|
|
return IEEE802154_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* mlme_reset_request_sync() - MLME_RESET_request/confirm according to API Spec
|
|
* @set_default_pib: Set defaults in PIB
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of MLME-RESET.confirm
|
|
*/
|
|
static u8 mlme_reset_request_sync(
|
|
u8 set_default_pib,
|
|
void *device_ref
|
|
)
|
|
{
|
|
u8 status;
|
|
struct mac_message command, response;
|
|
struct spi_device *spi = device_ref;
|
|
|
|
command.command_id = SPI_MLME_RESET_REQUEST;
|
|
command.length = 1;
|
|
command.pdata.u8param = set_default_pib;
|
|
|
|
if (cascoda_api_downstream(
|
|
&command.command_id,
|
|
command.length + 2,
|
|
&response.command_id,
|
|
device_ref)) {
|
|
dev_err(&spi->dev, "cascoda_api_downstream failed\n");
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
if (response.command_id != SPI_MLME_RESET_CONFIRM)
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
|
|
status = response.pdata.status;
|
|
|
|
/* reset COORD Bit for Channel Filtering as Coordinator */
|
|
if (CA8210_MAC_WORKAROUNDS && set_default_pib && !status) {
|
|
status = tdme_setsfr_request_sync(
|
|
0,
|
|
CA8210_SFR_MACCON,
|
|
0,
|
|
device_ref
|
|
);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* mlme_set_request_sync() - MLME_SET_request/confirm according to API Spec
|
|
* @pib_attribute: Attribute Number
|
|
* @pib_attribute_index: Index within Attribute if an Array
|
|
* @pib_attribute_length: Attribute length
|
|
* @pib_attribute_value: Pointer to Attribute Value
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of MLME-SET.confirm
|
|
*/
|
|
static u8 mlme_set_request_sync(
|
|
u8 pib_attribute,
|
|
u8 pib_attribute_index,
|
|
u8 pib_attribute_length,
|
|
const void *pib_attribute_value,
|
|
void *device_ref
|
|
)
|
|
{
|
|
u8 status;
|
|
struct mac_message command, response;
|
|
|
|
/* pre-check the validity of pib_attribute values that are not checked
|
|
* in MAC
|
|
*/
|
|
if (tdme_checkpibattribute(
|
|
pib_attribute, pib_attribute_length, pib_attribute_value)) {
|
|
return IEEE802154_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (pib_attribute == PHY_CURRENT_CHANNEL) {
|
|
status = tdme_channelinit(
|
|
*((u8 *)pib_attribute_value),
|
|
device_ref
|
|
);
|
|
if (status)
|
|
return status;
|
|
}
|
|
|
|
if (pib_attribute == PHY_TRANSMIT_POWER) {
|
|
return tdme_settxpower(
|
|
*((u8 *)pib_attribute_value),
|
|
device_ref
|
|
);
|
|
}
|
|
|
|
command.command_id = SPI_MLME_SET_REQUEST;
|
|
command.length = sizeof(struct mlme_set_request_pset) -
|
|
MAX_ATTRIBUTE_SIZE + pib_attribute_length;
|
|
command.pdata.set_req.pib_attribute = pib_attribute;
|
|
command.pdata.set_req.pib_attribute_index = pib_attribute_index;
|
|
command.pdata.set_req.pib_attribute_length = pib_attribute_length;
|
|
memcpy(
|
|
command.pdata.set_req.pib_attribute_value,
|
|
pib_attribute_value,
|
|
pib_attribute_length
|
|
);
|
|
|
|
if (cascoda_api_downstream(
|
|
&command.command_id,
|
|
command.length + 2,
|
|
&response.command_id,
|
|
device_ref)) {
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
if (response.command_id != SPI_MLME_SET_CONFIRM)
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
|
|
return response.pdata.status;
|
|
}
|
|
|
|
/**
|
|
* hwme_set_request_sync() - HWME_SET_request/confirm according to API Spec
|
|
* @hw_attribute: Attribute Number
|
|
* @hw_attribute_length: Attribute length
|
|
* @hw_attribute_value: Pointer to Attribute Value
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of HWME-SET.confirm
|
|
*/
|
|
static u8 hwme_set_request_sync(
|
|
u8 hw_attribute,
|
|
u8 hw_attribute_length,
|
|
u8 *hw_attribute_value,
|
|
void *device_ref
|
|
)
|
|
{
|
|
struct mac_message command, response;
|
|
|
|
command.command_id = SPI_HWME_SET_REQUEST;
|
|
command.length = 2 + hw_attribute_length;
|
|
command.pdata.hwme_set_req.hw_attribute = hw_attribute;
|
|
command.pdata.hwme_set_req.hw_attribute_length = hw_attribute_length;
|
|
memcpy(
|
|
command.pdata.hwme_set_req.hw_attribute_value,
|
|
hw_attribute_value,
|
|
hw_attribute_length
|
|
);
|
|
|
|
if (cascoda_api_downstream(
|
|
&command.command_id,
|
|
command.length + 2,
|
|
&response.command_id,
|
|
device_ref)) {
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
if (response.command_id != SPI_HWME_SET_CONFIRM)
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
|
|
return response.pdata.hwme_set_cnf.status;
|
|
}
|
|
|
|
/**
|
|
* hwme_get_request_sync() - HWME_GET_request/confirm according to API Spec
|
|
* @hw_attribute: Attribute Number
|
|
* @hw_attribute_length: Attribute length
|
|
* @hw_attribute_value: Pointer to Attribute Value
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 802.15.4 status code of HWME-GET.confirm
|
|
*/
|
|
static u8 hwme_get_request_sync(
|
|
u8 hw_attribute,
|
|
u8 *hw_attribute_length,
|
|
u8 *hw_attribute_value,
|
|
void *device_ref
|
|
)
|
|
{
|
|
struct mac_message command, response;
|
|
|
|
command.command_id = SPI_HWME_GET_REQUEST;
|
|
command.length = 1;
|
|
command.pdata.hwme_get_req.hw_attribute = hw_attribute;
|
|
|
|
if (cascoda_api_downstream(
|
|
&command.command_id,
|
|
command.length + 2,
|
|
&response.command_id,
|
|
device_ref)) {
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
}
|
|
|
|
if (response.command_id != SPI_HWME_GET_CONFIRM)
|
|
return IEEE802154_SYSTEM_ERROR;
|
|
|
|
if (response.pdata.hwme_get_cnf.status == IEEE802154_SUCCESS) {
|
|
*hw_attribute_length =
|
|
response.pdata.hwme_get_cnf.hw_attribute_length;
|
|
memcpy(
|
|
hw_attribute_value,
|
|
response.pdata.hwme_get_cnf.hw_attribute_value,
|
|
*hw_attribute_length
|
|
);
|
|
}
|
|
|
|
return response.pdata.hwme_get_cnf.status;
|
|
}
|
|
|
|
/* Network driver operation */
|
|
|
|
/**
|
|
* ca8210_async_xmit_complete() - Called to announce that an asynchronous
|
|
* transmission has finished
|
|
* @hw: ieee802154_hw of ca8210 that has finished exchange
|
|
* @msduhandle: Identifier of transmission that has completed
|
|
* @status: Returned 802.15.4 status code of the transmission
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_async_xmit_complete(
|
|
struct ieee802154_hw *hw,
|
|
u8 msduhandle,
|
|
u8 status)
|
|
{
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
if (priv->nextmsduhandle != msduhandle) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"Unexpected msdu_handle on data confirm, Expected %d, got %d\n",
|
|
priv->nextmsduhandle,
|
|
msduhandle
|
|
);
|
|
return -EIO;
|
|
}
|
|
|
|
priv->async_tx_pending = false;
|
|
priv->nextmsduhandle++;
|
|
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"Link transmission unsuccessful, status = %d\n",
|
|
status
|
|
);
|
|
if (status != IEEE802154_TRANSACTION_OVERFLOW) {
|
|
ieee802154_xmit_error(priv->hw, priv->tx_skb, status);
|
|
return 0;
|
|
}
|
|
}
|
|
ieee802154_xmit_complete(priv->hw, priv->tx_skb, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_skb_rx() - Contructs a properly framed socket buffer from a received
|
|
* MCPS_DATA_indication
|
|
* @hw: ieee802154_hw that MCPS_DATA_indication was received by
|
|
* @len: length of MCPS_DATA_indication
|
|
* @data_ind: Octet array of MCPS_DATA_indication
|
|
*
|
|
* Called by the spi driver whenever a SAP command is received, this function
|
|
* will ascertain whether the command is of interest to the network driver and
|
|
* take necessary action.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_skb_rx(
|
|
struct ieee802154_hw *hw,
|
|
size_t len,
|
|
u8 *data_ind
|
|
)
|
|
{
|
|
struct ieee802154_hdr hdr;
|
|
int msdulen;
|
|
int hlen;
|
|
u8 mpdulinkquality = data_ind[23];
|
|
struct sk_buff *skb;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
/* Allocate mtu size buffer for every rx packet */
|
|
skb = dev_alloc_skb(IEEE802154_MTU + sizeof(hdr));
|
|
if (!skb)
|
|
return -ENOMEM;
|
|
|
|
skb_reserve(skb, sizeof(hdr));
|
|
|
|
msdulen = data_ind[22]; /* msdu_length */
|
|
if (msdulen > IEEE802154_MTU) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"received erroneously large msdu length!\n"
|
|
);
|
|
kfree_skb(skb);
|
|
return -EMSGSIZE;
|
|
}
|
|
dev_dbg(&priv->spi->dev, "skb buffer length = %d\n", msdulen);
|
|
|
|
if (priv->promiscuous)
|
|
goto copy_payload;
|
|
|
|
/* Populate hdr */
|
|
hdr.sec.level = data_ind[29 + msdulen];
|
|
dev_dbg(&priv->spi->dev, "security level: %#03x\n", hdr.sec.level);
|
|
if (hdr.sec.level > 0) {
|
|
hdr.sec.key_id_mode = data_ind[30 + msdulen];
|
|
memcpy(&hdr.sec.extended_src, &data_ind[31 + msdulen], 8);
|
|
hdr.sec.key_id = data_ind[39 + msdulen];
|
|
}
|
|
hdr.source.mode = data_ind[0];
|
|
dev_dbg(&priv->spi->dev, "srcAddrMode: %#03x\n", hdr.source.mode);
|
|
hdr.source.pan_id = *(u16 *)&data_ind[1];
|
|
dev_dbg(&priv->spi->dev, "srcPanId: %#06x\n", hdr.source.pan_id);
|
|
memcpy(&hdr.source.extended_addr, &data_ind[3], 8);
|
|
hdr.dest.mode = data_ind[11];
|
|
dev_dbg(&priv->spi->dev, "dstAddrMode: %#03x\n", hdr.dest.mode);
|
|
hdr.dest.pan_id = *(u16 *)&data_ind[12];
|
|
dev_dbg(&priv->spi->dev, "dstPanId: %#06x\n", hdr.dest.pan_id);
|
|
memcpy(&hdr.dest.extended_addr, &data_ind[14], 8);
|
|
|
|
/* Fill in FC implicitly */
|
|
hdr.fc.type = 1; /* Data frame */
|
|
if (hdr.sec.level)
|
|
hdr.fc.security_enabled = 1;
|
|
else
|
|
hdr.fc.security_enabled = 0;
|
|
if (data_ind[1] != data_ind[12] || data_ind[2] != data_ind[13])
|
|
hdr.fc.intra_pan = 1;
|
|
else
|
|
hdr.fc.intra_pan = 0;
|
|
hdr.fc.dest_addr_mode = hdr.dest.mode;
|
|
hdr.fc.source_addr_mode = hdr.source.mode;
|
|
|
|
/* Add hdr to front of buffer */
|
|
hlen = ieee802154_hdr_push(skb, &hdr);
|
|
|
|
if (hlen < 0) {
|
|
dev_crit(&priv->spi->dev, "failed to push mac hdr onto skb!\n");
|
|
kfree_skb(skb);
|
|
return hlen;
|
|
}
|
|
|
|
skb_reset_mac_header(skb);
|
|
skb->mac_len = hlen;
|
|
|
|
copy_payload:
|
|
/* Add <msdulen> bytes of space to the back of the buffer */
|
|
/* Copy msdu to skb */
|
|
skb_put_data(skb, &data_ind[29], msdulen);
|
|
|
|
ieee802154_rx_irqsafe(hw, skb, mpdulinkquality);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_net_rx() - Acts upon received SAP commands relevant to the network
|
|
* driver
|
|
* @hw: ieee802154_hw that command was received by
|
|
* @command: Octet array of received command
|
|
* @len: length of the received command
|
|
*
|
|
* Called by the spi driver whenever a SAP command is received, this function
|
|
* will ascertain whether the command is of interest to the network driver and
|
|
* take necessary action.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_net_rx(struct ieee802154_hw *hw, u8 *command, size_t len)
|
|
{
|
|
struct ca8210_priv *priv = hw->priv;
|
|
unsigned long flags;
|
|
u8 status;
|
|
|
|
dev_dbg(&priv->spi->dev, "%s: CmdID = %d\n", __func__, command[0]);
|
|
|
|
if (command[0] == SPI_MCPS_DATA_INDICATION) {
|
|
/* Received data */
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
if (command[26] == priv->last_dsn) {
|
|
dev_dbg(
|
|
&priv->spi->dev,
|
|
"DSN %d resend received, ignoring...\n",
|
|
command[26]
|
|
);
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
return 0;
|
|
}
|
|
priv->last_dsn = command[26];
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
return ca8210_skb_rx(hw, len - 2, command + 2);
|
|
} else if (command[0] == SPI_MCPS_DATA_CONFIRM) {
|
|
status = command[3];
|
|
if (priv->async_tx_pending) {
|
|
return ca8210_async_xmit_complete(
|
|
hw,
|
|
command[2],
|
|
status
|
|
);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_skb_tx() - Transmits a given socket buffer using the ca8210
|
|
* @skb: Socket buffer to transmit
|
|
* @msduhandle: Data identifier to pass to the 802.15.4 MAC
|
|
* @priv: Pointer to private data section of target ca8210
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_skb_tx(
|
|
struct sk_buff *skb,
|
|
u8 msduhandle,
|
|
struct ca8210_priv *priv
|
|
)
|
|
{
|
|
struct ieee802154_hdr header = { };
|
|
struct secspec secspec;
|
|
int mac_len, status;
|
|
|
|
dev_dbg(&priv->spi->dev, "%s called\n", __func__);
|
|
|
|
/* Get addressing info from skb - ieee802154 layer creates a full
|
|
* packet
|
|
*/
|
|
mac_len = ieee802154_hdr_peek_addrs(skb, &header);
|
|
if (mac_len < 0)
|
|
return mac_len;
|
|
|
|
secspec.security_level = header.sec.level;
|
|
secspec.key_id_mode = header.sec.key_id_mode;
|
|
if (secspec.key_id_mode == 2)
|
|
memcpy(secspec.key_source, &header.sec.short_src, 4);
|
|
else if (secspec.key_id_mode == 3)
|
|
memcpy(secspec.key_source, &header.sec.extended_src, 8);
|
|
secspec.key_index = header.sec.key_id;
|
|
|
|
/* Pass to Cascoda API */
|
|
status = mcps_data_request(
|
|
header.source.mode,
|
|
header.dest.mode,
|
|
header.dest.pan_id,
|
|
(union macaddr *)&header.dest.extended_addr,
|
|
skb->len - mac_len,
|
|
&skb->data[mac_len],
|
|
msduhandle,
|
|
header.fc.ack_request,
|
|
&secspec,
|
|
priv->spi
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
/**
|
|
* ca8210_start() - Starts the network driver
|
|
* @hw: ieee802154_hw of ca8210 being started
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_start(struct ieee802154_hw *hw)
|
|
{
|
|
int status;
|
|
u8 rx_on_when_idle;
|
|
u8 lqi_threshold = 0;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
priv->last_dsn = -1;
|
|
/* Turn receiver on when idle for now just to test rx */
|
|
rx_on_when_idle = 1;
|
|
status = mlme_set_request_sync(
|
|
MAC_RX_ON_WHEN_IDLE,
|
|
0,
|
|
1,
|
|
&rx_on_when_idle,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_crit(
|
|
&priv->spi->dev,
|
|
"Setting rx_on_when_idle failed, status = %d\n",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
status = hwme_set_request_sync(
|
|
HWME_LQILIMIT,
|
|
1,
|
|
&lqi_threshold,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_crit(
|
|
&priv->spi->dev,
|
|
"Setting lqilimit failed, status = %d\n",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_stop() - Stops the network driver
|
|
* @hw: ieee802154_hw of ca8210 being stopped
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static void ca8210_stop(struct ieee802154_hw *hw)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* ca8210_xmit_async() - Asynchronously transmits a given socket buffer using
|
|
* the ca8210
|
|
* @hw: ieee802154_hw of ca8210 to transmit from
|
|
* @skb: Socket buffer to transmit
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_xmit_async(struct ieee802154_hw *hw, struct sk_buff *skb)
|
|
{
|
|
struct ca8210_priv *priv = hw->priv;
|
|
int status;
|
|
|
|
dev_dbg(&priv->spi->dev, "calling %s\n", __func__);
|
|
|
|
priv->tx_skb = skb;
|
|
priv->async_tx_pending = true;
|
|
status = ca8210_skb_tx(skb, priv->nextmsduhandle, priv);
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* ca8210_get_ed() - Returns the measured energy on the current channel at this
|
|
* instant in time
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @level: Measured Energy Detect level
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_get_ed(struct ieee802154_hw *hw, u8 *level)
|
|
{
|
|
u8 lenvar;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
return link_to_linux_err(
|
|
hwme_get_request_sync(HWME_EDVALUE, &lenvar, level, priv->spi)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_channel() - Sets the current operating 802.15.4 channel of the
|
|
* ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @page: Channel page to set
|
|
* @channel: Channel number to set
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_channel(
|
|
struct ieee802154_hw *hw,
|
|
u8 page,
|
|
u8 channel
|
|
)
|
|
{
|
|
u8 status;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
status = mlme_set_request_sync(
|
|
PHY_CURRENT_CHANNEL,
|
|
0,
|
|
1,
|
|
&channel,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting channel, MLME-SET.confirm status = %d\n",
|
|
status
|
|
);
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_hw_addr_filt() - Sets the address filtering parameters of the
|
|
* ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @filt: Filtering parameters
|
|
* @changed: Bitmap representing which parameters to change
|
|
*
|
|
* Effectively just sets the actual addressing information identifying this node
|
|
* as all filtering is performed by the ca8210 as detailed in the IEEE 802.15.4
|
|
* 2006 specification.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_hw_addr_filt(
|
|
struct ieee802154_hw *hw,
|
|
struct ieee802154_hw_addr_filt *filt,
|
|
unsigned long changed
|
|
)
|
|
{
|
|
u8 status = 0;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
if (changed & IEEE802154_AFILT_PANID_CHANGED) {
|
|
status = mlme_set_request_sync(
|
|
MAC_PAN_ID,
|
|
0,
|
|
2,
|
|
&filt->pan_id, priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting pan id, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
}
|
|
if (changed & IEEE802154_AFILT_SADDR_CHANGED) {
|
|
status = mlme_set_request_sync(
|
|
MAC_SHORT_ADDRESS,
|
|
0,
|
|
2,
|
|
&filt->short_addr, priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting short address, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
}
|
|
if (changed & IEEE802154_AFILT_IEEEADDR_CHANGED) {
|
|
status = mlme_set_request_sync(
|
|
NS_IEEE_ADDRESS,
|
|
0,
|
|
8,
|
|
&filt->ieee_addr,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting ieee address, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
}
|
|
/* TODO: Should use MLME_START to set coord bit? */
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_tx_power() - Sets the transmit power of the ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @mbm: Transmit power in mBm (dBm*100)
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_tx_power(struct ieee802154_hw *hw, s32 mbm)
|
|
{
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
mbm /= 100;
|
|
return link_to_linux_err(
|
|
mlme_set_request_sync(PHY_TRANSMIT_POWER, 0, 1, &mbm, priv->spi)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_cca_mode() - Sets the clear channel assessment mode of the ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @cca: CCA mode to set
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_cca_mode(
|
|
struct ieee802154_hw *hw,
|
|
const struct wpan_phy_cca *cca
|
|
)
|
|
{
|
|
u8 status;
|
|
u8 cca_mode;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
cca_mode = cca->mode & 3;
|
|
if (cca_mode == 3 && cca->opt == NL802154_CCA_OPT_ENERGY_CARRIER_OR) {
|
|
/* cca_mode 0 == CS OR ED, 3 == CS AND ED */
|
|
cca_mode = 0;
|
|
}
|
|
status = mlme_set_request_sync(
|
|
PHY_CCA_MODE,
|
|
0,
|
|
1,
|
|
&cca_mode,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting cca mode, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_cca_ed_level() - Sets the CCA ED level of the ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @level: ED level to set (in mbm)
|
|
*
|
|
* Sets the minimum threshold of measured energy above which the ca8210 will
|
|
* back off and retry a transmission.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_cca_ed_level(struct ieee802154_hw *hw, s32 level)
|
|
{
|
|
u8 status;
|
|
u8 ed_threshold = (level / 100) * 2 + 256;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
status = hwme_set_request_sync(
|
|
HWME_EDTHRESHOLD,
|
|
1,
|
|
&ed_threshold,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting ed threshold, HWME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_csma_params() - Sets the CSMA parameters of the ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @min_be: Minimum backoff exponent when backing off a transmission
|
|
* @max_be: Maximum backoff exponent when backing off a transmission
|
|
* @retries: Number of times to retry after backing off
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_csma_params(
|
|
struct ieee802154_hw *hw,
|
|
u8 min_be,
|
|
u8 max_be,
|
|
u8 retries
|
|
)
|
|
{
|
|
u8 status;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
status = mlme_set_request_sync(MAC_MIN_BE, 0, 1, &min_be, priv->spi);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting min be, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
status = mlme_set_request_sync(MAC_MAX_BE, 0, 1, &max_be, priv->spi);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting max be, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
return link_to_linux_err(status);
|
|
}
|
|
status = mlme_set_request_sync(
|
|
MAC_MAX_CSMA_BACKOFFS,
|
|
0,
|
|
1,
|
|
&retries,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting max csma backoffs, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
/**
|
|
* ca8210_set_frame_retries() - Sets the maximum frame retries of the ca8210
|
|
* @hw: ieee802154_hw of target ca8210
|
|
* @retries: Number of retries
|
|
*
|
|
* Sets the number of times to retry a transmission if no acknowledgment was
|
|
* received from the other end when one was requested.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_set_frame_retries(struct ieee802154_hw *hw, s8 retries)
|
|
{
|
|
u8 status;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
status = mlme_set_request_sync(
|
|
MAC_MAX_FRAME_RETRIES,
|
|
0,
|
|
1,
|
|
&retries,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting frame retries, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
static int ca8210_set_promiscuous_mode(struct ieee802154_hw *hw, const bool on)
|
|
{
|
|
u8 status;
|
|
struct ca8210_priv *priv = hw->priv;
|
|
|
|
status = mlme_set_request_sync(
|
|
MAC_PROMISCUOUS_MODE,
|
|
0,
|
|
1,
|
|
(const void *)&on,
|
|
priv->spi
|
|
);
|
|
if (status) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"error setting promiscuous mode, MLME-SET.confirm status = %d",
|
|
status
|
|
);
|
|
} else {
|
|
priv->promiscuous = on;
|
|
}
|
|
return link_to_linux_err(status);
|
|
}
|
|
|
|
static const struct ieee802154_ops ca8210_phy_ops = {
|
|
.start = ca8210_start,
|
|
.stop = ca8210_stop,
|
|
.xmit_async = ca8210_xmit_async,
|
|
.ed = ca8210_get_ed,
|
|
.set_channel = ca8210_set_channel,
|
|
.set_hw_addr_filt = ca8210_set_hw_addr_filt,
|
|
.set_txpower = ca8210_set_tx_power,
|
|
.set_cca_mode = ca8210_set_cca_mode,
|
|
.set_cca_ed_level = ca8210_set_cca_ed_level,
|
|
.set_csma_params = ca8210_set_csma_params,
|
|
.set_frame_retries = ca8210_set_frame_retries,
|
|
.set_promiscuous_mode = ca8210_set_promiscuous_mode
|
|
};
|
|
|
|
/* Test/EVBME Interface */
|
|
|
|
/**
|
|
* ca8210_test_int_open() - Opens the test interface to the userspace
|
|
* @inodp: inode representation of file interface
|
|
* @filp: file interface
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_test_int_open(struct inode *inodp, struct file *filp)
|
|
{
|
|
struct ca8210_priv *priv = inodp->i_private;
|
|
|
|
filp->private_data = priv;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_check_upstream() - Checks a command received from the upstream
|
|
* testing interface for required action
|
|
* @buf: Buffer containing command to check
|
|
* @device_ref: Nondescript pointer to target device
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_test_check_upstream(u8 *buf, void *device_ref)
|
|
{
|
|
int ret;
|
|
u8 response[CA8210_SPI_BUF_SIZE];
|
|
|
|
if (buf[0] == SPI_MLME_SET_REQUEST) {
|
|
ret = tdme_checkpibattribute(buf[2], buf[4], buf + 5);
|
|
if (ret) {
|
|
response[0] = SPI_MLME_SET_CONFIRM;
|
|
response[1] = 3;
|
|
response[2] = IEEE802154_INVALID_PARAMETER;
|
|
response[3] = buf[2];
|
|
response[4] = buf[3];
|
|
if (cascoda_api_upstream)
|
|
cascoda_api_upstream(response, 5, device_ref);
|
|
return ret;
|
|
}
|
|
}
|
|
if (buf[0] == SPI_MLME_ASSOCIATE_REQUEST) {
|
|
return tdme_channelinit(buf[2], device_ref);
|
|
} else if (buf[0] == SPI_MLME_START_REQUEST) {
|
|
return tdme_channelinit(buf[4], device_ref);
|
|
} else if (
|
|
(buf[0] == SPI_MLME_SET_REQUEST) &&
|
|
(buf[2] == PHY_CURRENT_CHANNEL)
|
|
) {
|
|
return tdme_channelinit(buf[5], device_ref);
|
|
} else if (
|
|
(buf[0] == SPI_TDME_SET_REQUEST) &&
|
|
(buf[2] == TDME_CHANNEL)
|
|
) {
|
|
return tdme_channelinit(buf[4], device_ref);
|
|
} else if (
|
|
(CA8210_MAC_WORKAROUNDS) &&
|
|
(buf[0] == SPI_MLME_RESET_REQUEST) &&
|
|
(buf[2] == 1)
|
|
) {
|
|
/* reset COORD Bit for Channel Filtering as Coordinator */
|
|
return tdme_setsfr_request_sync(
|
|
0,
|
|
CA8210_SFR_MACCON,
|
|
0,
|
|
device_ref
|
|
);
|
|
}
|
|
return 0;
|
|
} /* End of EVBMECheckSerialCommand() */
|
|
|
|
/**
|
|
* ca8210_test_int_user_write() - Called by a process in userspace to send a
|
|
* message to the ca8210 drivers
|
|
* @filp: file interface
|
|
* @in_buf: Buffer containing message to write
|
|
* @len: length of message
|
|
* @off: file offset
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static ssize_t ca8210_test_int_user_write(
|
|
struct file *filp,
|
|
const char __user *in_buf,
|
|
size_t len,
|
|
loff_t *off
|
|
)
|
|
{
|
|
int ret;
|
|
struct ca8210_priv *priv = filp->private_data;
|
|
u8 command[CA8210_SPI_BUF_SIZE];
|
|
|
|
memset(command, SPI_IDLE, 6);
|
|
if (len > CA8210_SPI_BUF_SIZE || len < 2) {
|
|
dev_warn(
|
|
&priv->spi->dev,
|
|
"userspace requested erroneous write length (%zu)\n",
|
|
len
|
|
);
|
|
return -EBADE;
|
|
}
|
|
|
|
ret = copy_from_user(command, in_buf, len);
|
|
if (ret) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"%d bytes could not be copied from userspace\n",
|
|
ret
|
|
);
|
|
return -EIO;
|
|
}
|
|
if (len != command[1] + 2) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"write len does not match packet length field\n"
|
|
);
|
|
return -EBADE;
|
|
}
|
|
|
|
ret = ca8210_test_check_upstream(command, priv->spi);
|
|
if (ret == 0) {
|
|
ret = ca8210_spi_exchange(
|
|
command,
|
|
command[1] + 2,
|
|
NULL,
|
|
priv->spi
|
|
);
|
|
if (ret < 0) {
|
|
/* effectively 0 bytes were written successfully */
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"spi exchange failed\n"
|
|
);
|
|
return ret;
|
|
}
|
|
if (command[0] & SPI_SYN)
|
|
priv->sync_down++;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_int_user_read() - Called by a process in userspace to read a
|
|
* message from the ca8210 drivers
|
|
* @filp: file interface
|
|
* @buf: Buffer to write message to
|
|
* @len: length of message to read (ignored)
|
|
* @offp: file offset
|
|
*
|
|
* If the O_NONBLOCK flag was set when opening the file then this function will
|
|
* not block, i.e. it will return if the fifo is empty. Otherwise the function
|
|
* will block, i.e. wait until new data arrives.
|
|
*
|
|
* Return: number of bytes read
|
|
*/
|
|
static ssize_t ca8210_test_int_user_read(
|
|
struct file *filp,
|
|
char __user *buf,
|
|
size_t len,
|
|
loff_t *offp
|
|
)
|
|
{
|
|
int i, cmdlen;
|
|
struct ca8210_priv *priv = filp->private_data;
|
|
unsigned char *fifo_buffer;
|
|
unsigned long bytes_not_copied;
|
|
|
|
if (filp->f_flags & O_NONBLOCK) {
|
|
/* Non-blocking mode */
|
|
if (kfifo_is_empty(&priv->test.up_fifo))
|
|
return 0;
|
|
} else {
|
|
/* Blocking mode */
|
|
wait_event_interruptible(
|
|
priv->test.readq,
|
|
!kfifo_is_empty(&priv->test.up_fifo)
|
|
);
|
|
}
|
|
|
|
if (kfifo_out(&priv->test.up_fifo, &fifo_buffer, 4) != 4) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"test_interface: Wrong number of elements popped from upstream fifo\n"
|
|
);
|
|
return 0;
|
|
}
|
|
cmdlen = fifo_buffer[1];
|
|
bytes_not_copied = cmdlen + 2;
|
|
|
|
bytes_not_copied = copy_to_user(buf, fifo_buffer, bytes_not_copied);
|
|
if (bytes_not_copied > 0) {
|
|
dev_err(
|
|
&priv->spi->dev,
|
|
"%lu bytes could not be copied to user space!\n",
|
|
bytes_not_copied
|
|
);
|
|
}
|
|
|
|
dev_dbg(&priv->spi->dev, "test_interface: Cmd len = %d\n", cmdlen);
|
|
|
|
dev_dbg(&priv->spi->dev, "test_interface: Read\n");
|
|
for (i = 0; i < cmdlen + 2; i++)
|
|
dev_dbg(&priv->spi->dev, "%#03x\n", fifo_buffer[i]);
|
|
|
|
kfree(fifo_buffer);
|
|
|
|
return cmdlen + 2;
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_int_ioctl() - Called by a process in userspace to enact an
|
|
* arbitrary action
|
|
* @filp: file interface
|
|
* @ioctl_num: which action to enact
|
|
* @ioctl_param: arbitrary parameter for the action
|
|
*
|
|
* Return: status
|
|
*/
|
|
static long ca8210_test_int_ioctl(
|
|
struct file *filp,
|
|
unsigned int ioctl_num,
|
|
unsigned long ioctl_param
|
|
)
|
|
{
|
|
struct ca8210_priv *priv = filp->private_data;
|
|
|
|
switch (ioctl_num) {
|
|
case CA8210_IOCTL_HARD_RESET:
|
|
ca8210_reset_send(priv->spi, ioctl_param);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_int_poll() - Called by a process in userspace to determine which
|
|
* actions are currently possible for the file
|
|
* @filp: file interface
|
|
* @ptable: poll table
|
|
*
|
|
* Return: set of poll return flags
|
|
*/
|
|
static __poll_t ca8210_test_int_poll(
|
|
struct file *filp,
|
|
struct poll_table_struct *ptable
|
|
)
|
|
{
|
|
__poll_t return_flags = 0;
|
|
struct ca8210_priv *priv = filp->private_data;
|
|
|
|
poll_wait(filp, &priv->test.readq, ptable);
|
|
if (!kfifo_is_empty(&priv->test.up_fifo))
|
|
return_flags |= (EPOLLIN | EPOLLRDNORM);
|
|
if (wait_event_interruptible(
|
|
priv->test.readq,
|
|
!kfifo_is_empty(&priv->test.up_fifo))) {
|
|
return EPOLLERR;
|
|
}
|
|
return return_flags;
|
|
}
|
|
|
|
static const struct file_operations test_int_fops = {
|
|
.read = ca8210_test_int_user_read,
|
|
.write = ca8210_test_int_user_write,
|
|
.open = ca8210_test_int_open,
|
|
.release = NULL,
|
|
.unlocked_ioctl = ca8210_test_int_ioctl,
|
|
.poll = ca8210_test_int_poll
|
|
};
|
|
|
|
/* Init/Deinit */
|
|
|
|
/**
|
|
* ca8210_get_platform_data() - Populate a ca8210_platform_data object
|
|
* @spi_device: Pointer to ca8210 spi device object to get data for
|
|
* @pdata: Pointer to ca8210_platform_data object to populate
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_get_platform_data(
|
|
struct spi_device *spi_device,
|
|
struct ca8210_platform_data *pdata
|
|
)
|
|
{
|
|
int ret = 0;
|
|
|
|
if (!spi_device->dev.of_node)
|
|
return -EINVAL;
|
|
|
|
pdata->extclockenable = of_property_read_bool(
|
|
spi_device->dev.of_node,
|
|
"extclock-enable"
|
|
);
|
|
if (pdata->extclockenable) {
|
|
ret = of_property_read_u32(
|
|
spi_device->dev.of_node,
|
|
"extclock-freq",
|
|
&pdata->extclockfreq
|
|
);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
ret = of_property_read_u32(
|
|
spi_device->dev.of_node,
|
|
"extclock-gpio",
|
|
&pdata->extclockgpio
|
|
);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ca8210_config_extern_clk() - Configure the external clock provided by the
|
|
* ca8210
|
|
* @pdata: Pointer to ca8210_platform_data containing clock parameters
|
|
* @spi: Pointer to target ca8210 spi device
|
|
* @on: True to turn the clock on, false to turn off
|
|
*
|
|
* The external clock is configured with a frequency and output pin taken from
|
|
* the platform data.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_config_extern_clk(
|
|
struct ca8210_platform_data *pdata,
|
|
struct spi_device *spi,
|
|
bool on
|
|
)
|
|
{
|
|
u8 clkparam[2];
|
|
|
|
if (on) {
|
|
dev_info(&spi->dev, "Switching external clock on\n");
|
|
switch (pdata->extclockfreq) {
|
|
case SIXTEEN_MHZ:
|
|
clkparam[0] = 1;
|
|
break;
|
|
case EIGHT_MHZ:
|
|
clkparam[0] = 2;
|
|
break;
|
|
case FOUR_MHZ:
|
|
clkparam[0] = 3;
|
|
break;
|
|
case TWO_MHZ:
|
|
clkparam[0] = 4;
|
|
break;
|
|
case ONE_MHZ:
|
|
clkparam[0] = 5;
|
|
break;
|
|
default:
|
|
dev_crit(&spi->dev, "Invalid extclock-freq\n");
|
|
return -EINVAL;
|
|
}
|
|
clkparam[1] = pdata->extclockgpio;
|
|
} else {
|
|
dev_info(&spi->dev, "Switching external clock off\n");
|
|
clkparam[0] = 0; /* off */
|
|
clkparam[1] = 0;
|
|
}
|
|
return link_to_linux_err(
|
|
hwme_set_request_sync(HWME_SYSCLKOUT, 2, clkparam, spi)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* ca8210_register_ext_clock() - Register ca8210's external clock with kernel
|
|
* @spi: Pointer to target ca8210 spi device
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_register_ext_clock(struct spi_device *spi)
|
|
{
|
|
struct device_node *np = spi->dev.of_node;
|
|
struct ca8210_priv *priv = spi_get_drvdata(spi);
|
|
struct ca8210_platform_data *pdata = spi->dev.platform_data;
|
|
|
|
if (!np)
|
|
return -EFAULT;
|
|
|
|
priv->clk = clk_register_fixed_rate(
|
|
&spi->dev,
|
|
np->name,
|
|
NULL,
|
|
0,
|
|
pdata->extclockfreq
|
|
);
|
|
|
|
if (IS_ERR(priv->clk)) {
|
|
dev_crit(&spi->dev, "Failed to register external clk\n");
|
|
return PTR_ERR(priv->clk);
|
|
}
|
|
|
|
return of_clk_add_provider(np, of_clk_src_simple_get, priv->clk);
|
|
}
|
|
|
|
/**
|
|
* ca8210_unregister_ext_clock() - Unregister ca8210's external clock with
|
|
* kernel
|
|
* @spi: Pointer to target ca8210 spi device
|
|
*/
|
|
static void ca8210_unregister_ext_clock(struct spi_device *spi)
|
|
{
|
|
struct ca8210_priv *priv = spi_get_drvdata(spi);
|
|
|
|
if (IS_ERR_OR_NULL(priv->clk))
|
|
return;
|
|
|
|
of_clk_del_provider(spi->dev.of_node);
|
|
clk_unregister(priv->clk);
|
|
dev_info(&spi->dev, "External clock unregistered\n");
|
|
}
|
|
|
|
/**
|
|
* ca8210_reset_init() - Initialise the reset input to the ca8210
|
|
* @spi: Pointer to target ca8210 spi device
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_reset_init(struct spi_device *spi)
|
|
{
|
|
int ret;
|
|
struct ca8210_platform_data *pdata = spi->dev.platform_data;
|
|
|
|
pdata->gpio_reset = of_get_named_gpio(
|
|
spi->dev.of_node,
|
|
"reset-gpio",
|
|
0
|
|
);
|
|
|
|
ret = gpio_direction_output(pdata->gpio_reset, 1);
|
|
if (ret < 0) {
|
|
dev_crit(
|
|
&spi->dev,
|
|
"Reset GPIO %d did not set to output mode\n",
|
|
pdata->gpio_reset
|
|
);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ca8210_interrupt_init() - Initialise the irq output from the ca8210
|
|
* @spi: Pointer to target ca8210 spi device
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_interrupt_init(struct spi_device *spi)
|
|
{
|
|
int ret;
|
|
struct ca8210_platform_data *pdata = spi->dev.platform_data;
|
|
|
|
pdata->gpio_irq = of_get_named_gpio(
|
|
spi->dev.of_node,
|
|
"irq-gpio",
|
|
0
|
|
);
|
|
|
|
pdata->irq_id = gpio_to_irq(pdata->gpio_irq);
|
|
if (pdata->irq_id < 0) {
|
|
dev_crit(
|
|
&spi->dev,
|
|
"Could not get irq for gpio pin %d\n",
|
|
pdata->gpio_irq
|
|
);
|
|
gpio_free(pdata->gpio_irq);
|
|
return pdata->irq_id;
|
|
}
|
|
|
|
ret = request_irq(
|
|
pdata->irq_id,
|
|
ca8210_interrupt_handler,
|
|
IRQF_TRIGGER_FALLING,
|
|
"ca8210-irq",
|
|
spi_get_drvdata(spi)
|
|
);
|
|
if (ret) {
|
|
dev_crit(&spi->dev, "request_irq %d failed\n", pdata->irq_id);
|
|
gpio_free(pdata->gpio_irq);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* ca8210_dev_com_init() - Initialise the spi communication component
|
|
* @priv: Pointer to private data structure
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_dev_com_init(struct ca8210_priv *priv)
|
|
{
|
|
priv->mlme_workqueue = alloc_ordered_workqueue("MLME work queue", 0);
|
|
if (!priv->mlme_workqueue) {
|
|
dev_crit(&priv->spi->dev, "alloc of mlme_workqueue failed!\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
priv->irq_workqueue = alloc_ordered_workqueue("ca8210 irq worker", 0);
|
|
if (!priv->irq_workqueue) {
|
|
dev_crit(&priv->spi->dev, "alloc of irq_workqueue failed!\n");
|
|
destroy_workqueue(priv->mlme_workqueue);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ca8210_dev_com_clear() - Deinitialise the spi communication component
|
|
* @priv: Pointer to private data structure
|
|
*/
|
|
static void ca8210_dev_com_clear(struct ca8210_priv *priv)
|
|
{
|
|
destroy_workqueue(priv->mlme_workqueue);
|
|
destroy_workqueue(priv->irq_workqueue);
|
|
}
|
|
|
|
#define CA8210_MAX_TX_POWERS (9)
|
|
static const s32 ca8210_tx_powers[CA8210_MAX_TX_POWERS] = {
|
|
800, 700, 600, 500, 400, 300, 200, 100, 0
|
|
};
|
|
|
|
#define CA8210_MAX_ED_LEVELS (21)
|
|
static const s32 ca8210_ed_levels[CA8210_MAX_ED_LEVELS] = {
|
|
-10300, -10250, -10200, -10150, -10100, -10050, -10000, -9950, -9900,
|
|
-9850, -9800, -9750, -9700, -9650, -9600, -9550, -9500, -9450, -9400,
|
|
-9350, -9300
|
|
};
|
|
|
|
/**
|
|
* ca8210_hw_setup() - Populate the ieee802154_hw phy attributes with the
|
|
* ca8210's defaults
|
|
* @ca8210_hw: Pointer to ieee802154_hw to populate
|
|
*/
|
|
static void ca8210_hw_setup(struct ieee802154_hw *ca8210_hw)
|
|
{
|
|
/* Support channels 11-26 */
|
|
ca8210_hw->phy->supported.channels[0] = CA8210_VALID_CHANNELS;
|
|
ca8210_hw->phy->supported.tx_powers_size = CA8210_MAX_TX_POWERS;
|
|
ca8210_hw->phy->supported.tx_powers = ca8210_tx_powers;
|
|
ca8210_hw->phy->supported.cca_ed_levels_size = CA8210_MAX_ED_LEVELS;
|
|
ca8210_hw->phy->supported.cca_ed_levels = ca8210_ed_levels;
|
|
ca8210_hw->phy->current_channel = 18;
|
|
ca8210_hw->phy->current_page = 0;
|
|
ca8210_hw->phy->transmit_power = 800;
|
|
ca8210_hw->phy->cca.mode = NL802154_CCA_ENERGY_CARRIER;
|
|
ca8210_hw->phy->cca.opt = NL802154_CCA_OPT_ENERGY_CARRIER_AND;
|
|
ca8210_hw->phy->cca_ed_level = -9800;
|
|
ca8210_hw->phy->symbol_duration = 16;
|
|
ca8210_hw->phy->lifs_period = 40 * ca8210_hw->phy->symbol_duration;
|
|
ca8210_hw->phy->sifs_period = 12 * ca8210_hw->phy->symbol_duration;
|
|
ca8210_hw->flags =
|
|
IEEE802154_HW_AFILT |
|
|
IEEE802154_HW_OMIT_CKSUM |
|
|
IEEE802154_HW_FRAME_RETRIES |
|
|
IEEE802154_HW_PROMISCUOUS |
|
|
IEEE802154_HW_CSMA_PARAMS;
|
|
ca8210_hw->phy->flags =
|
|
WPAN_PHY_FLAG_TXPOWER |
|
|
WPAN_PHY_FLAG_CCA_ED_LEVEL |
|
|
WPAN_PHY_FLAG_CCA_MODE |
|
|
WPAN_PHY_FLAG_DATAGRAMS_ONLY;
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_interface_init() - Initialise the test file interface
|
|
* @priv: Pointer to private data structure
|
|
*
|
|
* Provided as an alternative to the standard linux network interface, the test
|
|
* interface exposes a file in the filesystem (ca8210_test) that allows
|
|
* 802.15.4 SAP Commands and Cascoda EVBME commands to be sent directly to
|
|
* the stack.
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_test_interface_init(struct ca8210_priv *priv)
|
|
{
|
|
struct ca8210_test *test = &priv->test;
|
|
char node_name[32];
|
|
|
|
snprintf(
|
|
node_name,
|
|
sizeof(node_name),
|
|
"ca8210@%d_%d",
|
|
priv->spi->controller->bus_num,
|
|
spi_get_chipselect(priv->spi, 0)
|
|
);
|
|
|
|
test->ca8210_dfs_spi_int = debugfs_create_file(
|
|
node_name,
|
|
0600, /* S_IRUSR | S_IWUSR */
|
|
NULL,
|
|
priv,
|
|
&test_int_fops
|
|
);
|
|
|
|
debugfs_create_symlink("ca8210", NULL, node_name);
|
|
init_waitqueue_head(&test->readq);
|
|
return kfifo_alloc(
|
|
&test->up_fifo,
|
|
CA8210_TEST_INT_FIFO_SIZE,
|
|
GFP_KERNEL
|
|
);
|
|
}
|
|
|
|
/**
|
|
* ca8210_test_interface_clear() - Deinitialise the test file interface
|
|
* @priv: Pointer to private data structure
|
|
*/
|
|
static void ca8210_test_interface_clear(struct ca8210_priv *priv)
|
|
{
|
|
struct ca8210_test *test = &priv->test;
|
|
|
|
debugfs_remove(test->ca8210_dfs_spi_int);
|
|
kfifo_free(&test->up_fifo);
|
|
dev_info(&priv->spi->dev, "Test interface removed\n");
|
|
}
|
|
|
|
/**
|
|
* ca8210_remove() - Shut down a ca8210 upon being disconnected
|
|
* @spi_device: Pointer to spi device data structure
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static void ca8210_remove(struct spi_device *spi_device)
|
|
{
|
|
struct ca8210_priv *priv;
|
|
struct ca8210_platform_data *pdata;
|
|
|
|
dev_info(&spi_device->dev, "Removing ca8210\n");
|
|
|
|
pdata = spi_device->dev.platform_data;
|
|
if (pdata) {
|
|
if (pdata->extclockenable) {
|
|
ca8210_unregister_ext_clock(spi_device);
|
|
ca8210_config_extern_clk(pdata, spi_device, 0);
|
|
}
|
|
free_irq(pdata->irq_id, spi_device->dev.driver_data);
|
|
kfree(pdata);
|
|
spi_device->dev.platform_data = NULL;
|
|
}
|
|
/* get spi_device private data */
|
|
priv = spi_get_drvdata(spi_device);
|
|
if (priv) {
|
|
dev_info(
|
|
&spi_device->dev,
|
|
"sync_down = %d, sync_up = %d\n",
|
|
priv->sync_down,
|
|
priv->sync_up
|
|
);
|
|
ca8210_dev_com_clear(spi_device->dev.driver_data);
|
|
if (priv->hw) {
|
|
if (priv->hw_registered)
|
|
ieee802154_unregister_hw(priv->hw);
|
|
ieee802154_free_hw(priv->hw);
|
|
priv->hw = NULL;
|
|
dev_info(
|
|
&spi_device->dev,
|
|
"Unregistered & freed ieee802154_hw.\n"
|
|
);
|
|
}
|
|
if (IS_ENABLED(CONFIG_IEEE802154_CA8210_DEBUGFS))
|
|
ca8210_test_interface_clear(priv);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ca8210_probe() - Set up a connected ca8210 upon being detected by the system
|
|
* @spi_device: Pointer to spi device data structure
|
|
*
|
|
* Return: 0 or linux error code
|
|
*/
|
|
static int ca8210_probe(struct spi_device *spi_device)
|
|
{
|
|
struct ca8210_priv *priv;
|
|
struct ieee802154_hw *hw;
|
|
struct ca8210_platform_data *pdata;
|
|
int ret;
|
|
|
|
dev_info(&spi_device->dev, "Inserting ca8210\n");
|
|
|
|
/* allocate ieee802154_hw and private data */
|
|
hw = ieee802154_alloc_hw(sizeof(struct ca8210_priv), &ca8210_phy_ops);
|
|
if (!hw) {
|
|
dev_crit(&spi_device->dev, "ieee802154_alloc_hw failed\n");
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
|
|
priv = hw->priv;
|
|
priv->hw = hw;
|
|
priv->spi = spi_device;
|
|
hw->parent = &spi_device->dev;
|
|
spin_lock_init(&priv->lock);
|
|
priv->async_tx_pending = false;
|
|
priv->hw_registered = false;
|
|
priv->sync_up = 0;
|
|
priv->sync_down = 0;
|
|
priv->promiscuous = false;
|
|
priv->retries = 0;
|
|
init_completion(&priv->ca8210_is_awake);
|
|
init_completion(&priv->spi_transfer_complete);
|
|
init_completion(&priv->sync_exchange_complete);
|
|
spi_set_drvdata(priv->spi, priv);
|
|
if (IS_ENABLED(CONFIG_IEEE802154_CA8210_DEBUGFS)) {
|
|
cascoda_api_upstream = ca8210_test_int_driver_write;
|
|
ca8210_test_interface_init(priv);
|
|
} else {
|
|
cascoda_api_upstream = NULL;
|
|
}
|
|
ca8210_hw_setup(hw);
|
|
ieee802154_random_extended_addr(&hw->phy->perm_extended_addr);
|
|
|
|
pdata = kmalloc(sizeof(*pdata), GFP_KERNEL);
|
|
if (!pdata) {
|
|
ret = -ENOMEM;
|
|
goto error;
|
|
}
|
|
|
|
priv->spi->dev.platform_data = pdata;
|
|
ret = ca8210_get_platform_data(priv->spi, pdata);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "ca8210_get_platform_data failed\n");
|
|
goto error;
|
|
}
|
|
|
|
ret = ca8210_dev_com_init(priv);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "ca8210_dev_com_init failed\n");
|
|
goto error;
|
|
}
|
|
ret = ca8210_reset_init(priv->spi);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "ca8210_reset_init failed\n");
|
|
goto error;
|
|
}
|
|
|
|
ret = ca8210_interrupt_init(priv->spi);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "ca8210_interrupt_init failed\n");
|
|
goto error;
|
|
}
|
|
|
|
msleep(100);
|
|
|
|
ca8210_reset_send(priv->spi, 1);
|
|
|
|
ret = tdme_chipinit(priv->spi);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "tdme_chipinit failed\n");
|
|
goto error;
|
|
}
|
|
|
|
if (pdata->extclockenable) {
|
|
ret = ca8210_config_extern_clk(pdata, priv->spi, 1);
|
|
if (ret) {
|
|
dev_crit(
|
|
&spi_device->dev,
|
|
"ca8210_config_extern_clk failed\n"
|
|
);
|
|
goto error;
|
|
}
|
|
ret = ca8210_register_ext_clock(priv->spi);
|
|
if (ret) {
|
|
dev_crit(
|
|
&spi_device->dev,
|
|
"ca8210_register_ext_clock failed\n"
|
|
);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
ret = ieee802154_register_hw(hw);
|
|
if (ret) {
|
|
dev_crit(&spi_device->dev, "ieee802154_register_hw failed\n");
|
|
goto error;
|
|
}
|
|
priv->hw_registered = true;
|
|
|
|
return 0;
|
|
error:
|
|
msleep(100); /* wait for pending spi transfers to complete */
|
|
ca8210_remove(spi_device);
|
|
return link_to_linux_err(ret);
|
|
}
|
|
|
|
static const struct of_device_id ca8210_of_ids[] = {
|
|
{.compatible = "cascoda,ca8210", },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, ca8210_of_ids);
|
|
|
|
static struct spi_driver ca8210_spi_driver = {
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
.of_match_table = ca8210_of_ids,
|
|
},
|
|
.probe = ca8210_probe,
|
|
.remove = ca8210_remove
|
|
};
|
|
|
|
module_spi_driver(ca8210_spi_driver);
|
|
|
|
MODULE_AUTHOR("Harry Morris <h.morris@cascoda.com>");
|
|
MODULE_DESCRIPTION("CA-8210 SoftMAC driver");
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
MODULE_VERSION("1.0");
|