2022-03-28 10:46:18 +00:00
// Author: Xianjun Jiao, Michael Mehari, Wei Liu, Jetmir Haxhibeqiri, Pablo Avila Campos
// SPDX-FileCopyrightText: 2022 UGent
2021-01-20 12:30:12 +00:00
// SPDX-License-Identifier: AGPL-3.0-or-later
2019-12-10 13:03:47 +00:00
# include <linux/bitops.h>
# include <linux/dmapool.h>
# include <linux/io.h>
# include <linux/iopoll.h>
# include <linux/of_address.h>
# include <linux/of_platform.h>
# include <linux/of_irq.h>
# include <linux/slab.h>
# include <linux/clk.h>
# include <linux/io-64-nonatomic-lo-hi.h>
# include <linux/delay.h>
# include <linux/interrupt.h>
# include <linux/dmaengine.h>
# include <linux/slab.h>
# include <linux/delay.h>
# include <linux/etherdevice.h>
# include <linux/init.h>
# include <linux/kthread.h>
# include <linux/module.h>
# include <linux/of_dma.h>
# include <linux/platform_device.h>
# include <linux/random.h>
# include <linux/slab.h>
# include <linux/wait.h>
# include <linux/sched/task.h>
# include <linux/dma/xilinx_dma.h>
# include <linux/spi/spi.h>
# include <net/mac80211.h>
# include <linux/clk.h>
# include <linux/clkdev.h>
# include <linux/clk-provider.h>
# include <linux/iio/iio.h>
# include <linux/iio/sysfs.h>
# include <linux/gpio.h>
# include <linux/leds.h>
# define IIO_AD9361_USE_PRIVATE_H_
2021-05-05 14:44:39 +00:00
# include <../../drivers/iio/adc/ad9361_regs.h>
# include <../../drivers/iio/adc/ad9361.h>
# include <../../drivers/iio/adc/ad9361_private.h>
2019-12-10 13:03:47 +00:00
# include <../../drivers/iio/frequency/cf_axi_dds.h>
2021-05-05 14:44:39 +00:00
extern int ad9361_get_tx_atten ( struct ad9361_rf_phy * phy , u32 tx_num ) ;
extern int ad9361_set_tx_atten ( struct ad9361_rf_phy * phy , u32 atten_mdb ,
bool tx1 , bool tx2 , bool immed ) ;
extern int ad9361_ctrl_outs_setup ( struct ad9361_rf_phy * phy ,
struct ctrl_outs_control * ctrl ) ;
2022-03-29 07:56:20 +00:00
extern int ad9361_do_calib_run ( struct ad9361_rf_phy * phy , u32 cal , int arg ) ;
2019-12-10 13:03:47 +00:00
# include "../user_space/sdrctl_src/nl80211_testmode_def.h"
# include "hw_def.h"
# include "sdr.h"
2020-09-04 08:57:04 +00:00
# include "git_rev.h"
2019-12-10 13:03:47 +00:00
// driver API of component driver
extern struct tx_intf_driver_api * tx_intf_api ;
extern struct rx_intf_driver_api * rx_intf_api ;
extern struct openofdm_tx_driver_api * openofdm_tx_api ;
extern struct openofdm_rx_driver_api * openofdm_rx_api ;
extern struct xpu_driver_api * xpu_api ;
2022-01-06 13:42:01 +00:00
u32 gen_mpdu_crc ( u8 * data_in , u32 num_bytes ) ;
u8 gen_mpdu_delim_crc ( u16 m ) ;
2022-03-28 14:14:33 +00:00
u32 reverse32 ( u32 d ) ;
2022-03-28 13:12:50 +00:00
static int openwifi_set_antenna ( struct ieee80211_hw * dev , u32 tx_ant , u32 rx_ant ) ;
static int openwifi_get_antenna ( struct ieee80211_hw * dev , u32 * tx_ant , u32 * rx_ant ) ;
2022-03-28 13:23:53 +00:00
int rssi_half_db_to_rssi_dbm ( int rssi_half_db , int rssi_correction ) ;
int rssi_dbm_to_rssi_half_db ( int rssi_dbm , int rssi_correction ) ;
int rssi_correction_lookup_table ( u32 freq_MHz ) ;
2022-01-06 13:42:01 +00:00
2022-03-28 10:46:18 +00:00
# include "sdrctl_intf.c"
# include "sysfs_intf.c"
2022-03-28 13:08:01 +00:00
static int test_mode = 0 ; // bit0: aggregation enable(1)/disable(0); NO USE ANY MORE: bit1: tx offset tuning enable(0)/disable(1)
// Internal indication variables after parsing test_mode
static bool AGGR_ENABLE = false ;
static bool TX_OFFSET_TUNING_ENABLE = false ;
static int init_tx_att = 0 ;
2019-12-10 13:03:47 +00:00
MODULE_AUTHOR ( " Xianjun Jiao " ) ;
MODULE_DESCRIPTION ( " SDR driver " ) ;
MODULE_LICENSE ( " GPL v2 " ) ;
module_param ( test_mode , int , 0 ) ;
2022-03-28 13:08:01 +00:00
MODULE_PARM_DESC ( myint , " test_mode. bit0: aggregation enable(1)/disable(0) " ) ;
module_param ( init_tx_att , int , 0 ) ;
MODULE_PARM_DESC ( myint , " init_tx_att. TX attenuation in dB*1000 example: set to 3000 for 3dB attenuation " ) ;
2019-12-10 13:03:47 +00:00
// ---------------rfkill---------------------------------------
static bool openwifi_is_radio_enabled ( struct openwifi_priv * priv )
{
int reg ;
2022-03-28 12:58:46 +00:00
if ( priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_0MHZ_ANT0 | | priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0 | | priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_0MHZ_ANT_BOTH )
2019-12-10 13:03:47 +00:00
reg = ad9361_get_tx_atten ( priv - > ad9361_phy , 1 ) ;
2022-03-28 12:58:46 +00:00
else
reg = ad9361_get_tx_atten ( priv - > ad9361_phy , 2 ) ;
2019-12-10 13:03:47 +00:00
2022-03-28 12:58:46 +00:00
if ( reg = = ( AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) )
2019-12-10 13:03:47 +00:00
return true ; // 0 off, 1 on
return false ;
}
void openwifi_rfkill_init ( struct ieee80211_hw * hw )
{
struct openwifi_priv * priv = hw - > priv ;
priv - > rfkill_off = openwifi_is_radio_enabled ( priv ) ;
printk ( " %s openwifi_rfkill_init: wireless switch is %s \n " , sdr_compatible_str , priv - > rfkill_off ? " on " : " off " ) ;
wiphy_rfkill_set_hw_state ( hw - > wiphy , ! priv - > rfkill_off ) ;
wiphy_rfkill_start_polling ( hw - > wiphy ) ;
}
void openwifi_rfkill_poll ( struct ieee80211_hw * hw )
{
bool enabled ;
struct openwifi_priv * priv = hw - > priv ;
enabled = openwifi_is_radio_enabled ( priv ) ;
2020-06-12 08:50:34 +00:00
// printk("%s openwifi_rfkill_poll: wireless radio switch turned %s\n", sdr_compatible_str, enabled ? "on" : "off");
2019-12-10 13:03:47 +00:00
if ( unlikely ( enabled ! = priv - > rfkill_off ) ) {
priv - > rfkill_off = enabled ;
printk ( " %s openwifi_rfkill_poll: WARNING wireless radio switch turned %s \n " , sdr_compatible_str , enabled ? " on " : " off " ) ;
wiphy_rfkill_set_hw_state ( hw - > wiphy , ! enabled ) ;
}
}
void openwifi_rfkill_exit ( struct ieee80211_hw * hw )
{
printk ( " %s openwifi_rfkill_exit \n " , sdr_compatible_str ) ;
wiphy_rfkill_stop_polling ( hw - > wiphy ) ;
}
//----------------rfkill end-----------------------------------
2022-03-28 13:23:53 +00:00
inline int rssi_dbm_to_rssi_half_db ( int rssi_dbm , int rssi_correction )
{
return ( ( rssi_correction + rssi_dbm ) < < 1 ) ;
}
inline int rssi_correction_lookup_table ( u32 freq_MHz )
{
int rssi_correction ;
if ( freq_MHz < 2412 ) {
rssi_correction = 153 ;
} else if ( freq_MHz < = 2484 ) {
rssi_correction = 153 ;
} else if ( freq_MHz < 5160 ) {
rssi_correction = 153 ;
} else if ( freq_MHz < = 5240 ) {
rssi_correction = 145 ;
} else if ( freq_MHz < = 5320 ) {
rssi_correction = 148 ;
} else {
rssi_correction = 148 ;
}
return rssi_correction ;
}
2019-12-10 13:03:47 +00:00
static void ad9361_rf_set_channel ( struct ieee80211_hw * dev ,
struct ieee80211_conf * conf )
{
struct openwifi_priv * priv = dev - > priv ;
2022-03-28 14:44:52 +00:00
u32 actual_rx_lo = conf - > chandef . chan - > center_freq - priv - > rx_freq_offset_to_lo_MHz ;
2021-04-05 19:49:59 +00:00
u32 actual_tx_lo ;
2022-03-29 07:56:20 +00:00
u32 spi_disable ;
u32 diff_tx_lo ;
2019-12-10 13:03:47 +00:00
bool change_flag = ( actual_rx_lo ! = priv - > actual_rx_lo ) ;
2022-03-28 14:44:52 +00:00
int static_lbt_th , auto_lbt_th , fpga_lbt_th , receiver_rssi_dbm_th ;
2022-03-29 07:56:20 +00:00
struct timeval tv ;
unsigned long time_before = 0 ;
unsigned long time_after = 0 ;
2019-12-10 13:03:47 +00:00
if ( change_flag ) {
actual_tx_lo = conf - > chandef . chan - > center_freq - priv - > tx_freq_offset_to_lo_MHz ;
2022-03-29 07:56:20 +00:00
diff_tx_lo = priv - > last_tx_quad_cal_lo > actual_tx_lo ? priv - > last_tx_quad_cal_lo - actual_tx_lo : actual_tx_lo - priv - > last_tx_quad_cal_lo ;
2019-12-10 13:03:47 +00:00
2022-03-28 14:44:52 +00:00
// -------------------Tx Lo tuning-------------------
clk_set_rate ( priv - > ad9361_phy - > clks [ TX_RFPLL ] , ( ( ( ( u64 ) 1000000ull ) * ( ( u64 ) actual_tx_lo ) + priv - > rf_reg_val [ RF_TX_REG_IDX_FO ] ) > > 1 ) ) ;
2022-03-28 14:39:32 +00:00
priv - > actual_tx_lo = actual_tx_lo ;
2022-03-28 14:44:52 +00:00
// -------------------Rx Lo tuning-------------------
clk_set_rate ( priv - > ad9361_phy - > clks [ RX_RFPLL ] , ( ( ( ( u64 ) 1000000ull ) * ( ( u64 ) actual_rx_lo ) + priv - > rf_reg_val [ RF_RX_REG_IDX_FO ] ) > > 1 ) ) ;
2022-03-28 14:39:32 +00:00
priv - > actual_rx_lo = actual_rx_lo ;
2022-03-29 07:56:20 +00:00
// call Tx Quadrature calibration if frequency change is more than 100MHz
if ( diff_tx_lo > 100 ) {
priv - > last_tx_quad_cal_lo = actual_tx_lo ;
do_gettimeofday ( & tv ) ;
time_before = tv . tv_usec + ( ( u64 ) 1000000ull ) * ( ( u64 ) tv . tv_sec ) ;
spi_disable = xpu_api - > XPU_REG_SPI_DISABLE_read ( ) ; // disable FPGA SPI module
xpu_api - > XPU_REG_SPI_DISABLE_write ( 1 ) ;
ad9361_do_calib_run ( priv - > ad9361_phy , TX_QUAD_CAL , ( int ) priv - > ad9361_phy - > state - > last_tx_quad_cal_phase ) ;
// restore original SPI disable state
xpu_api - > XPU_REG_SPI_DISABLE_write ( spi_disable ) ;
do_gettimeofday ( & tv ) ;
time_after = tv . tv_usec + ( ( u64 ) 1000000ull ) * ( ( u64 ) tv . tv_sec ) ;
}
2019-12-10 13:03:47 +00:00
2022-03-28 14:44:52 +00:00
// get rssi correction value from lookup table
priv - > rssi_correction = rssi_correction_lookup_table ( actual_rx_lo ) ;
2020-12-14 12:32:15 +00:00
2022-03-28 14:44:52 +00:00
// set appropriate lbt threshold
2020-12-17 15:48:56 +00:00
// xpu_api->XPU_REG_LBT_TH_write((priv->rssi_correction-62)<<1); // -62dBm
2021-09-28 19:52:31 +00:00
// xpu_api->XPU_REG_LBT_TH_write((priv->rssi_correction-62-16)<<1); // wei's magic value is 135, here is 134 @ ch 44
2022-03-28 14:44:52 +00:00
// auto_lbt_th = ((priv->rssi_correction-62-16)<<1);
auto_lbt_th = rssi_dbm_to_rssi_half_db ( - 78 , priv - > rssi_correction ) ; // -78dBm, the same as above ((priv->rssi_correction-62-16)<<1)
static_lbt_th = rssi_dbm_to_rssi_half_db ( - ( priv - > drv_xpu_reg_val [ DRV_XPU_REG_IDX_LBT_TH ] ) , priv - > rssi_correction ) ;
fpga_lbt_th = ( priv - > drv_xpu_reg_val [ DRV_XPU_REG_IDX_LBT_TH ] = = 0 ? auto_lbt_th : static_lbt_th ) ;
2021-09-28 19:52:31 +00:00
xpu_api - > XPU_REG_LBT_TH_write ( fpga_lbt_th ) ;
priv - > last_auto_fpga_lbt_th = auto_lbt_th ;
2022-03-28 14:44:52 +00:00
// Set rssi_half_db threshold (-85dBm equivalent) to receiver. Receiver will not react to signal lower than this rssi. See test records (OPENOFDM_RX_POWER_THRES_INIT in hw_def.h)
receiver_rssi_dbm_th = ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_DEMOD_TH ] = = 0 ? OPENOFDM_RX_RSSI_DBM_TH_DEFAULT : ( - priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_DEMOD_TH ] ) ) ;
openofdm_rx_api - > OPENOFDM_RX_REG_POWER_THRES_write ( ( OPENOFDM_RX_DC_RUNNING_SUM_TH_INIT < < 16 ) | rssi_dbm_to_rssi_half_db ( receiver_rssi_dbm_th , priv - > rssi_correction ) ) ;
2019-12-10 13:03:47 +00:00
if ( actual_rx_lo < 2500 ) {
if ( priv - > band ! = BAND_2_4GHZ ) {
priv - > band = BAND_2_4GHZ ;
xpu_api - > XPU_REG_BAND_CHANNEL_write ( ( priv - > use_short_slot < < 24 ) | ( priv - > band < < 16 ) ) ;
}
2022-03-28 14:35:25 +00:00
} else {
2019-12-10 13:03:47 +00:00
if ( priv - > band ! = BAND_5_8GHZ ) {
priv - > band = BAND_5_8GHZ ;
xpu_api - > XPU_REG_BAND_CHANNEL_write ( ( priv - > use_short_slot < < 24 ) | ( priv - > band < < 16 ) ) ;
}
}
2022-03-29 07:56:20 +00:00
printk ( " %s ad9361_rf_set_channel %dM rssi_correction %d (change flag %d) fpga_lbt_th %d(%ddBm) (auto %d static %d) tx_quad_cal duration %lu us \n " , sdr_compatible_str , conf - > chandef . chan - > center_freq , priv - > rssi_correction , change_flag , fpga_lbt_th , rssi_half_db_to_rssi_dbm ( fpga_lbt_th , priv - > rssi_correction ) , auto_lbt_th , static_lbt_th , time_after - time_before ) ;
2019-12-10 13:03:47 +00:00
}
}
const struct openwifi_rf_ops ad9361_rf_ops = {
. name = " ad9361 " ,
// .init = ad9361_rf_init,
// .stop = ad9361_rf_stop,
. set_chan = ad9361_rf_set_channel ,
// .calc_rssi = ad9361_rf_calc_rssi,
} ;
u16 reverse16 ( u16 d ) {
union u16_byte2 tmp0 , tmp1 ;
tmp0 . a = d ;
tmp1 . c [ 0 ] = tmp0 . c [ 1 ] ;
tmp1 . c [ 1 ] = tmp0 . c [ 0 ] ;
return ( tmp1 . a ) ;
}
u32 reverse32 ( u32 d ) {
union u32_byte4 tmp0 , tmp1 ;
tmp0 . a = d ;
tmp1 . c [ 0 ] = tmp0 . c [ 3 ] ;
tmp1 . c [ 1 ] = tmp0 . c [ 2 ] ;
tmp1 . c [ 2 ] = tmp0 . c [ 1 ] ;
tmp1 . c [ 3 ] = tmp0 . c [ 0 ] ;
return ( tmp1 . a ) ;
}
2020-06-12 08:50:34 +00:00
static int openwifi_init_tx_ring ( struct openwifi_priv * priv , int ring_idx )
2019-12-10 13:03:47 +00:00
{
2020-06-12 08:50:34 +00:00
struct openwifi_ring * ring = & ( priv - > tx_ring [ ring_idx ] ) ;
2019-12-10 13:03:47 +00:00
int i ;
2022-03-29 12:44:39 +00:00
ring - > stop_flag = - 1 ;
2019-12-10 13:03:47 +00:00
ring - > bd_wr_idx = 0 ;
ring - > bd_rd_idx = 0 ;
ring - > bds = kmalloc ( sizeof ( struct openwifi_buffer_descriptor ) * NUM_TX_BD , GFP_KERNEL ) ;
if ( ring - > bds = = NULL ) {
printk ( " %s openwifi_init_tx_ring: WARNING Cannot allocate TX ring \n " , sdr_compatible_str ) ;
return - ENOMEM ;
}
for ( i = 0 ; i < NUM_TX_BD ; i + + ) {
2022-03-29 12:44:39 +00:00
ring - > bds [ i ] . skb_linked = NULL ; // for tx, skb is from upper layer
2021-02-04 08:54:47 +00:00
//at first right after skb allocated, head, data, tail are the same.
2021-02-04 09:16:34 +00:00
ring - > bds [ i ] . dma_mapping_addr = 0 ; // for tx, mapping is done after skb is received from upper layer in tx routine
2022-03-29 12:44:39 +00:00
ring - > bds [ i ] . seq_no = 0xffff ; // invalid value
ring - > bds [ i ] . prio = 0xff ; // invalid value
ring - > bds [ i ] . len_mpdu = 0 ; // invalid value
2019-12-10 13:03:47 +00:00
}
return 0 ;
}
2020-06-12 08:50:34 +00:00
static void openwifi_free_tx_ring ( struct openwifi_priv * priv , int ring_idx )
2019-12-10 13:03:47 +00:00
{
2020-06-12 08:50:34 +00:00
struct openwifi_ring * ring = & ( priv - > tx_ring [ ring_idx ] ) ;
2019-12-10 13:03:47 +00:00
int i ;
2022-03-29 12:44:39 +00:00
ring - > stop_flag = - 1 ;
2019-12-10 13:03:47 +00:00
ring - > bd_wr_idx = 0 ;
ring - > bd_rd_idx = 0 ;
for ( i = 0 ; i < NUM_TX_BD ; i + + ) {
if ( ring - > bds [ i ] . skb_linked = = 0 & & ring - > bds [ i ] . dma_mapping_addr = = 0 )
continue ;
if ( ring - > bds [ i ] . dma_mapping_addr ! = 0 )
2020-06-12 08:50:34 +00:00
dma_unmap_single ( priv - > tx_chan - > device - > dev , ring - > bds [ i ] . dma_mapping_addr , ring - > bds [ i ] . skb_linked - > len , DMA_MEM_TO_DEV ) ;
2019-12-10 13:03:47 +00:00
// if (ring->bds[i].skb_linked!=NULL)
2020-06-12 08:50:34 +00:00
// dev_kfree_skb(ring->bds[i].skb_linked); // only use dev_kfree_skb when there is exception
2019-12-10 13:03:47 +00:00
if ( ( ring - > bds [ i ] . dma_mapping_addr ! = 0 & & ring - > bds [ i ] . skb_linked = = 0 ) | |
( ring - > bds [ i ] . dma_mapping_addr = = 0 & & ring - > bds [ i ] . skb_linked ! = 0 ) )
2021-04-05 19:42:46 +00:00
printk ( " %s openwifi_free_tx_ring: WARNING ring %d i %d skb_linked %p dma_mapping_addr %08x \n " , sdr_compatible_str ,
2021-09-28 19:52:31 +00:00
ring_idx , i , ( void * ) ( ring - > bds [ i ] . skb_linked ) , ( unsigned int ) ( ring - > bds [ i ] . dma_mapping_addr ) ) ;
2019-12-10 13:03:47 +00:00
2022-03-29 12:44:39 +00:00
ring - > bds [ i ] . skb_linked = NULL ;
2019-12-10 13:03:47 +00:00
ring - > bds [ i ] . dma_mapping_addr = 0 ;
2022-03-29 12:44:39 +00:00
ring - > bds [ i ] . seq_no = 0xffff ; // invalid value
ring - > bds [ i ] . prio = 0xff ; // invalid value
ring - > bds [ i ] . len_mpdu = 0 ; // invalid value
2019-12-10 13:03:47 +00:00
}
if ( ring - > bds )
kfree ( ring - > bds ) ;
ring - > bds = NULL ;
}
static int openwifi_init_rx_ring ( struct openwifi_priv * priv )
{
2021-03-22 22:59:41 +00:00
int i ;
u8 * pdata_tmp ;
2019-12-10 13:03:47 +00:00
priv - > rx_cyclic_buf = dma_alloc_coherent ( priv - > rx_chan - > device - > dev , RX_BD_BUF_SIZE * NUM_RX_BD , & priv - > rx_cyclic_buf_dma_mapping_addr , GFP_KERNEL ) ;
if ( ! priv - > rx_cyclic_buf ) {
printk ( " %s openwifi_init_rx_ring: WARNING dma_alloc_coherent failed! \n " , sdr_compatible_str ) ;
dma_free_coherent ( priv - > rx_chan - > device - > dev , RX_BD_BUF_SIZE * NUM_RX_BD , priv - > rx_cyclic_buf , priv - > rx_cyclic_buf_dma_mapping_addr ) ;
return ( - 1 ) ;
}
2021-03-22 22:59:41 +00:00
// Set tsft_low and tsft_high to 0. If they are not zero, it means there is a packet in the buffer by DMA
for ( i = 0 ; i < NUM_RX_BD ; i + + ) {
pdata_tmp = priv - > rx_cyclic_buf + i * RX_BD_BUF_SIZE ; // our header insertion is at the beginning
2022-03-29 12:14:30 +00:00
( * ( ( u16 * ) ( pdata_tmp + 10 ) ) ) = 0 ;
2021-03-22 22:59:41 +00:00
}
2022-03-29 12:14:30 +00:00
printk ( " %s openwifi_init_rx_ring: NUM_RX_BD %d RX_BD_BUF_SIZE %d pkt existing flag are cleared! \n " , sdr_compatible_str ,
NUM_RX_BD , RX_BD_BUF_SIZE ) ;
2021-03-22 22:59:41 +00:00
2019-12-10 13:03:47 +00:00
return 0 ;
}
static void openwifi_free_rx_ring ( struct openwifi_priv * priv )
{
if ( priv - > rx_cyclic_buf )
dma_free_coherent ( priv - > rx_chan - > device - > dev , RX_BD_BUF_SIZE * NUM_RX_BD , priv - > rx_cyclic_buf , priv - > rx_cyclic_buf_dma_mapping_addr ) ;
priv - > rx_cyclic_buf_dma_mapping_addr = 0 ;
priv - > rx_cyclic_buf = 0 ;
}
static int rx_dma_setup ( struct ieee80211_hw * dev ) {
struct openwifi_priv * priv = dev - > priv ;
struct dma_device * rx_dev = priv - > rx_chan - > device ;
priv - > rxd = rx_dev - > device_prep_dma_cyclic ( priv - > rx_chan , priv - > rx_cyclic_buf_dma_mapping_addr , RX_BD_BUF_SIZE * NUM_RX_BD , RX_BD_BUF_SIZE , DMA_DEV_TO_MEM , DMA_CTRL_ACK | DMA_PREP_INTERRUPT ) ;
if ( ! ( priv - > rxd ) ) {
openwifi_free_rx_ring ( priv ) ;
2020-04-27 07:37:04 +00:00
printk ( " %s rx_dma_setup: WARNING rx_dev->device_prep_dma_cyclic %p \n " , sdr_compatible_str , ( void * ) ( priv - > rxd ) ) ;
2019-12-10 13:03:47 +00:00
return ( - 1 ) ;
}
priv - > rxd - > callback = 0 ;
priv - > rxd - > callback_param = 0 ;
priv - > rx_cookie = priv - > rxd - > tx_submit ( priv - > rxd ) ;
if ( dma_submit_error ( priv - > rx_cookie ) ) {
printk ( " %s rx_dma_setup: WARNING dma_submit_error(rx_cookie) %d \n " , sdr_compatible_str , ( u32 ) ( priv - > rx_cookie ) ) ;
return ( - 1 ) ;
}
dma_async_issue_pending ( priv - > rx_chan ) ;
return ( 0 ) ;
}
2022-03-28 13:23:53 +00:00
inline int rssi_half_db_to_rssi_dbm ( int rssi_half_db , int rssi_correction )
{
int rssi_db , rssi_dbm ;
rssi_db = ( rssi_half_db > > 1 ) ;
rssi_dbm = rssi_db - rssi_correction ;
rssi_dbm = ( rssi_dbm < ( - 128 ) ? ( - 128 ) : rssi_dbm ) ;
return rssi_dbm ;
}
2019-12-10 13:03:47 +00:00
static irqreturn_t openwifi_rx_interrupt ( int irq , void * dev_id )
{
struct ieee80211_hw * dev = dev_id ;
struct openwifi_priv * priv = dev - > priv ;
struct ieee80211_rx_status rx_status = { 0 } ;
struct sk_buff * skb ;
struct ieee80211_hdr * hdr ;
2022-03-29 10:16:04 +00:00
u32 addr1_low32 , addr2_low32 = 0 , addr3_low32 = 0 , len , rate_idx , tsft_low , tsft_high , loop_count = 0 ; //, fc_di;
2022-01-06 13:13:24 +00:00
bool ht_flag , short_gi , ht_aggr , ht_aggr_last ;
2020-06-12 08:50:34 +00:00
// u32 dma_driver_buf_idx_mod;
2022-03-29 10:16:04 +00:00
u8 * pdata_tmp ;
u8 fcs_ok ; //, target_buf_idx;//, phy_rx_sn_hw;
2019-12-10 13:03:47 +00:00
s8 signal ;
2022-03-29 10:17:54 +00:00
u16 agc_status_and_pkt_exist_flag , rssi_half_db , addr1_high16 , addr2_high16 = 0 , addr3_high16 = 0 , seq_no = 0 ;
2022-03-29 10:39:33 +00:00
bool content_ok , len_overflow , is_unicast ;
2019-12-10 13:03:47 +00:00
2021-09-29 14:52:45 +00:00
# ifdef USE_NEW_RX_INTERRUPT
int i ;
spin_lock ( & priv - > lock ) ;
for ( i = 0 ; i < NUM_RX_BD ; i + + ) {
pdata_tmp = priv - > rx_cyclic_buf + i * RX_BD_BUF_SIZE ;
agc_status_and_pkt_exist_flag = ( * ( ( u16 * ) ( pdata_tmp + 10 ) ) ) ; //check rx_intf_pl_to_m_axis.v. FPGA TODO: add pkt exist 1bit flag next to gpio_status_lock_by_sig_valid
if ( agc_status_and_pkt_exist_flag = = 0 ) // no packet in the buffer
continue ;
# else
static u8 target_buf_idx_old = 0 ;
2019-12-10 13:03:47 +00:00
spin_lock ( & priv - > lock ) ;
2021-03-22 22:59:41 +00:00
while ( 1 ) { // loop all rx buffers that have new rx packets
2020-06-12 08:50:34 +00:00
pdata_tmp = priv - > rx_cyclic_buf + target_buf_idx_old * RX_BD_BUF_SIZE ; // our header insertion is at the beginning
2021-09-29 14:52:45 +00:00
agc_status_and_pkt_exist_flag = ( * ( ( u16 * ) ( pdata_tmp + 10 ) ) ) ;
if ( agc_status_and_pkt_exist_flag = = 0 ) // no packet in the buffer
2021-03-22 22:59:41 +00:00
break ;
2021-09-29 14:52:45 +00:00
# endif
2021-03-22 22:59:41 +00:00
2021-09-29 14:52:45 +00:00
tsft_low = ( * ( ( u32 * ) ( pdata_tmp + 0 ) ) ) ;
tsft_high = ( * ( ( u32 * ) ( pdata_tmp + 4 ) ) ) ;
2022-03-29 10:17:54 +00:00
rssi_half_db = ( * ( ( u16 * ) ( pdata_tmp + 8 ) ) ) ;
2020-06-12 08:50:34 +00:00
len = ( * ( ( u16 * ) ( pdata_tmp + 12 ) ) ) ;
2019-12-10 13:03:47 +00:00
2020-06-12 08:50:34 +00:00
len_overflow = ( len > ( RX_BD_BUF_SIZE - 16 ) ? true : false ) ;
2019-12-10 13:03:47 +00:00
2020-06-12 08:50:34 +00:00
rate_idx = ( * ( ( u16 * ) ( pdata_tmp + 14 ) ) ) ;
2022-01-06 13:13:24 +00:00
ht_flag = ( ( rate_idx & 0x10 ) ! = 0 ) ;
2020-11-05 17:22:24 +00:00
short_gi = ( ( rate_idx & 0x20 ) ! = 0 ) ;
2022-01-06 13:13:24 +00:00
ht_aggr = ( ht_flag & ( ( rate_idx & 0x40 ) ! = 0 ) ) ;
ht_aggr_last = ( ht_flag & ( ( rate_idx & 0x80 ) ! = 0 ) ) ;
rate_idx = ( rate_idx & 0x1F ) ;
2019-12-10 13:03:47 +00:00
2020-06-12 08:50:34 +00:00
fcs_ok = ( len_overflow ? 0 : ( * ( ( u8 * ) ( pdata_tmp + 16 + len - 1 ) ) ) ) ;
//phy_rx_sn_hw = (fcs_ok&(NUM_RX_BD-1));
// phy_rx_sn_hw = (fcs_ok&0x7f);//0x7f is FPGA limitation
// dma_driver_buf_idx_mod = (state.residue&0x7f);
fcs_ok = ( ( fcs_ok & 0x80 ) ! = 0 ) ;
2020-11-05 17:22:24 +00:00
if ( ( len > = 14 & & ( ! len_overflow ) ) & & ( rate_idx > = 8 & & rate_idx < = 23 ) ) {
2020-06-12 08:50:34 +00:00
// if ( phy_rx_sn_hw!=dma_driver_buf_idx_mod) {
2022-03-29 10:13:05 +00:00
// printk("%s openwifi_rx: WARNING sn %d next buf_idx %d!\n", sdr_compatible_str,phy_rx_sn_hw,dma_driver_buf_idx_mod);
2020-06-12 08:50:34 +00:00
// }
content_ok = true ;
} else {
2022-03-29 10:34:51 +00:00
printk ( " %s openwifi_rx: WARNING content! len%d overflow%d rate_idx%d \n " , sdr_compatible_str ,
len , len_overflow , rate_idx ) ;
2020-06-12 08:50:34 +00:00
content_ok = false ;
}
2022-03-29 10:17:54 +00:00
signal = rssi_half_db_to_rssi_dbm ( rssi_half_db , priv - > rssi_correction ) ;
2020-06-12 08:50:34 +00:00
2022-03-29 10:36:53 +00:00
hdr = ( struct ieee80211_hdr * ) ( pdata_tmp + 16 ) ;
if ( len > = 20 ) {
addr2_low32 = * ( ( u32 * ) ( hdr - > addr2 + 2 ) ) ;
addr2_high16 = * ( ( u16 * ) ( hdr - > addr2 ) ) ;
}
addr1_low32 = * ( ( u32 * ) ( hdr - > addr1 + 2 ) ) ;
addr1_high16 = * ( ( u16 * ) ( hdr - > addr1 ) ) ;
2022-03-29 10:39:33 +00:00
if ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_PRINT_CFG ] & DMESG_LOG_ANY ) {
2020-06-12 08:50:34 +00:00
if ( len > = 26 ) {
addr3_low32 = * ( ( u32 * ) ( hdr - > addr3 + 2 ) ) ;
addr3_high16 = * ( ( u16 * ) ( hdr - > addr3 ) ) ;
}
if ( len > = 28 )
2022-03-29 10:14:29 +00:00
seq_no = ( ( hdr - > seq_ctrl & IEEE80211_SCTL_SEQ ) > > 4 ) ;
2020-06-12 08:50:34 +00:00
2022-03-29 10:39:33 +00:00
is_unicast = ( addr1_low32 ! = 0xffffffff | | addr1_high16 ! = 0xffff ) ;
if ( ( ( is_unicast ) & & ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_PRINT_CFG ] & DMESG_LOG_UNICAST ) ) | |
( ( ! is_unicast ) & & ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_PRINT_CFG ] & DMESG_LOG_BROADCAST ) ) | |
( ( fcs_ok = = 0 ) & & ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_PRINT_CFG ] & DMESG_LOG_ERROR ) ) )
printk ( " %s openwifi_rx: %dB ht%daggr%d/%d sgi%d %dM FC%04x DI%04x ADDR%04x%08x/%04x%08x/%04x%08x SC%d fcs%d buf_idx%d %ddBm \n " , sdr_compatible_str ,
2022-01-06 13:13:24 +00:00
len , ht_flag , ht_aggr , ht_aggr_last , short_gi , wifi_rate_table [ rate_idx ] , hdr - > frame_control , hdr - > duration_id ,
2020-06-12 08:50:34 +00:00
reverse16 ( addr1_high16 ) , reverse32 ( addr1_low32 ) , reverse16 ( addr2_high16 ) , reverse32 ( addr2_low32 ) , reverse16 ( addr3_high16 ) , reverse32 ( addr3_low32 ) ,
2021-09-29 14:52:45 +00:00
# ifdef USE_NEW_RX_INTERRUPT
2022-03-29 10:14:29 +00:00
seq_no , fcs_ok , i , signal ) ;
2021-09-29 14:52:45 +00:00
# else
2022-03-29 10:14:29 +00:00
seq_no , fcs_ok , target_buf_idx_old , signal ) ;
2021-09-29 14:52:45 +00:00
# endif
2020-06-12 08:50:34 +00:00
}
// priv->phy_rx_sn_hw_old = phy_rx_sn_hw;
if ( content_ok ) {
skb = dev_alloc_skb ( len ) ;
if ( skb ) {
skb_put_data ( skb , pdata_tmp + 16 , len ) ;
2022-03-28 12:49:15 +00:00
rx_status . antenna = priv - > runtime_rx_ant_cfg ;
2020-06-12 08:50:34 +00:00
// def in ieee80211_rate openwifi_rates 0~11. 0~3 11b(1M~11M), 4~11 11a/g(6M~54M)
rx_status . rate_idx = wifi_rate_table_mapping [ rate_idx ] ;
rx_status . signal = signal ;
2022-03-29 10:21:25 +00:00
// rx_status.freq = dev->conf.chandef.chan->center_freq;
rx_status . freq = priv - > actual_rx_lo ;
// rx_status.band = dev->conf.chandef.chan->band;
rx_status . band = ( rx_status . freq < 2500 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ ) ;
2020-06-12 08:50:34 +00:00
rx_status . mactime = ( ( ( u64 ) tsft_low ) | ( ( ( u64 ) tsft_high ) < < 32 ) ) ;
rx_status . flag | = RX_FLAG_MACTIME_START ;
if ( ! fcs_ok )
rx_status . flag | = RX_FLAG_FAILED_FCS_CRC ;
2020-11-05 17:22:24 +00:00
if ( rate_idx < = 15 )
rx_status . encoding = RX_ENC_LEGACY ;
else
rx_status . encoding = RX_ENC_HT ;
2020-06-12 08:50:34 +00:00
rx_status . bw = RATE_INFO_BW_20 ;
2020-11-05 17:22:24 +00:00
if ( short_gi )
rx_status . enc_flags | = RX_ENC_FLAG_SHORT_GI ;
2022-01-06 13:13:24 +00:00
if ( ht_aggr )
{
rx_status . ampdu_reference = priv - > ampdu_reference ;
rx_status . flag | = RX_FLAG_AMPDU_DETAILS | RX_FLAG_AMPDU_LAST_KNOWN ;
if ( ht_aggr_last )
rx_status . flag | = RX_FLAG_AMPDU_IS_LAST ;
}
2020-06-12 08:50:34 +00:00
memcpy ( IEEE80211_SKB_RXCB ( skb ) , & rx_status , sizeof ( rx_status ) ) ; // put rx_status into skb->cb, from now on skb->cb is not dma_dsts any more.
ieee80211_rx_irqsafe ( dev , skb ) ; // call mac80211 function
} else
2022-03-29 10:13:05 +00:00
printk ( " %s openwifi_rx: WARNING dev_alloc_skb failed! \n " , sdr_compatible_str ) ;
2022-01-06 13:13:24 +00:00
if ( ht_aggr_last )
priv - > ampdu_reference + + ;
2020-06-12 08:50:34 +00:00
}
2021-09-29 14:52:45 +00:00
( * ( ( u16 * ) ( pdata_tmp + 10 ) ) ) = 0 ; // clear the field (set by rx_intf_pl_to_m_axis.v) to indicate the packet has been processed
2020-06-12 08:50:34 +00:00
loop_count + + ;
2021-09-29 14:52:45 +00:00
# ifndef USE_NEW_RX_INTERRUPT
2021-03-22 22:59:41 +00:00
target_buf_idx_old = ( ( target_buf_idx_old + 1 ) & ( NUM_RX_BD - 1 ) ) ;
2021-09-29 14:52:45 +00:00
# endif
2019-12-10 13:03:47 +00:00
}
2020-06-12 08:50:34 +00:00
2022-03-29 10:39:33 +00:00
if ( loop_count ! = 1 & & ( priv - > drv_rx_reg_val [ DRV_RX_REG_IDX_PRINT_CFG ] & DMESG_LOG_ERROR ) )
2022-03-29 10:13:05 +00:00
printk ( " %s openwifi_rx: WARNING loop_count %d \n " , sdr_compatible_str , loop_count ) ;
2020-06-12 08:50:34 +00:00
2022-03-29 10:13:05 +00:00
// openwifi_rx_out:
2019-12-10 13:03:47 +00:00
spin_unlock ( & priv - > lock ) ;
return IRQ_HANDLED ;
}
static irqreturn_t openwifi_tx_interrupt ( int irq , void * dev_id )
{
struct ieee80211_hw * dev = dev_id ;
struct openwifi_priv * priv = dev - > priv ;
2022-03-29 12:44:39 +00:00
struct openwifi_ring * ring , * drv_ring_tmp ;
2019-12-10 13:03:47 +00:00
struct sk_buff * skb ;
struct ieee80211_tx_info * info ;
2022-03-29 12:44:39 +00:00
struct ieee80211_hdr * hdr ;
u32 reg_val1 , hw_queue_len , reg_val2 , dma_fifo_no_room_flag , num_slot_random , cw , loop_count = 0 , addr1_low32 , mcs_for_sysfs ;
2022-01-06 13:42:01 +00:00
u16 seq_no , pkt_cnt , blk_ack_ssn , start_idx ;
2022-03-29 12:44:39 +00:00
u8 nof_retx = - 1 , last_bd_rd_idx , i , prio , queue_idx , nof_retx_stat ;
2022-01-06 13:42:01 +00:00
u64 blk_ack_bitmap ;
2020-06-12 08:50:34 +00:00
// u16 prio_rd_idx_store[64]={0};
2022-03-29 12:44:39 +00:00
bool tx_fail = false , fpga_queue_has_room = false ;
bool use_ht_aggr , pkt_need_ack , use_ht_rate , prio_wake_up_flag = false ;
2019-12-10 13:03:47 +00:00
spin_lock ( & priv - > lock ) ;
2020-06-12 08:50:34 +00:00
while ( 1 ) { // loop all packets that have been sent by FPGA
2022-01-06 13:42:01 +00:00
reg_val1 = tx_intf_api - > TX_INTF_REG_PKT_INFO1_read ( ) ;
reg_val2 = tx_intf_api - > TX_INTF_REG_PKT_INFO2_read ( ) ;
blk_ack_bitmap = ( tx_intf_api - > TX_INTF_REG_PKT_INFO3_read ( ) | ( ( u64 ) tx_intf_api - > TX_INTF_REG_PKT_INFO4_read ( ) ) < < 32 ) ;
if ( reg_val1 ! = 0xFFFFFFFF ) {
nof_retx = ( reg_val1 & 0xF ) ;
last_bd_rd_idx = ( ( reg_val1 > > 5 ) & ( NUM_TX_BD - 1 ) ) ;
prio = ( ( reg_val1 > > 17 ) & 0x3 ) ;
num_slot_random = ( ( reg_val1 > > 19 ) & 0x1FF ) ;
//num_slot_random = ((0xFF80000 ®_val1)>>(2+5+NUM_BIT_MAX_PHY_TX_SN+NUM_BIT_MAX_NUM_HW_QUEUE));
cw = ( ( reg_val1 > > 28 ) & 0xF ) ;
//cw = ((0xF0000000 & reg_val1) >> 28);
2021-01-28 13:15:29 +00:00
if ( cw > 10 ) {
cw = 10 ;
num_slot_random + = 512 ;
}
2022-01-06 13:42:01 +00:00
pkt_cnt = ( reg_val2 & 0x3F ) ;
blk_ack_ssn = ( ( reg_val2 > > 6 ) & 0xFFF ) ;
2022-03-29 12:44:39 +00:00
queue_idx = ( ( reg_val1 > > 15 ) & ( MAX_NUM_HW_QUEUE - 1 ) ) ;
dma_fifo_no_room_flag = tx_intf_api - > TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read ( ) ;
hw_queue_len = tx_intf_api - > TX_INTF_REG_QUEUE_FIFO_DATA_COUNT_read ( ) ;
// check which linux prio is stopped by this queue (queue_idx)
for ( i = 0 ; i < MAX_NUM_SW_QUEUE ; i + + ) {
drv_ring_tmp = & ( priv - > tx_ring [ i ] ) ;
if ( drv_ring_tmp - > stop_flag = = prio ) {
if ( ( ( dma_fifo_no_room_flag > > i ) & 1 ) = = 0 & & ( NUM_TX_BD - ( ( hw_queue_len > > ( i * 8 ) ) & 0xFF ) ) > = RING_ROOM_THRESHOLD )
fpga_queue_has_room = true ;
else
fpga_queue_has_room = false ;
// Wake up Linux queue due to the current fpga queue releases some room
if ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_NORMAL_QUEUE_STOP )
printk ( " %s openwifi_tx_interrupt: WARNING ieee80211_wake_queue prio%d i%d queue%d no room flag%x hwq len%08x wr%d rd%d \n " , sdr_compatible_str ,
prio , i , queue_idx , dma_fifo_no_room_flag , hw_queue_len , drv_ring_tmp - > bd_wr_idx , last_bd_rd_idx ) ;
if ( fpga_queue_has_room ) {
prio_wake_up_flag = true ;
drv_ring_tmp - > stop_flag = - 1 ;
} else {
if ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_NORMAL_QUEUE_STOP )
printk ( " %s openwifi_tx_interrupt: WARNING no room! prio_wake_up_flag%d \n " , sdr_compatible_str , prio_wake_up_flag ) ;
}
2022-01-06 14:07:50 +00:00
}
2020-06-12 08:50:34 +00:00
}
2022-03-29 12:44:39 +00:00
if ( prio_wake_up_flag )
ieee80211_wake_queue ( dev , prio ) ;
2019-12-10 13:03:47 +00:00
2022-03-29 12:44:39 +00:00
ring = & ( priv - > tx_ring [ queue_idx ] ) ;
2022-01-06 13:42:01 +00:00
for ( i = 1 ; i < = pkt_cnt ; i + + )
{
ring - > bd_rd_idx = ( last_bd_rd_idx + i - pkt_cnt + 64 ) % 64 ;
seq_no = ring - > bds [ ring - > bd_rd_idx ] . seq_no ;
2022-03-29 12:44:39 +00:00
if ( seq_no = = 0xffff ) { // it has been forced cleared by the openwifi_tx (due to out-of-order Tx of different queues to the air?)
printk ( " %s openwifi_tx_interrupt: WARNING wr%d rd%d last_bd_rd_idx%d i%d pkt_cnt%d prio%d fpga q%d hwq len%d bd prio%d len_mpdu%d seq_no%d skb_linked%p dma_mapping_addr%llu \n " , sdr_compatible_str ,
ring - > bd_wr_idx , ring - > bd_rd_idx , last_bd_rd_idx , i , pkt_cnt , prio , queue_idx , hw_queue_len , ring - > bds [ ring - > bd_rd_idx ] . prio , ring - > bds [ ring - > bd_rd_idx ] . len_mpdu , seq_no , ring - > bds [ ring - > bd_rd_idx ] . skb_linked , ring - > bds [ ring - > bd_rd_idx ] . dma_mapping_addr ) ;
continue ;
}
2022-01-06 13:42:01 +00:00
skb = ring - > bds [ ring - > bd_rd_idx ] . skb_linked ;
2019-12-10 13:03:47 +00:00
2022-01-06 13:42:01 +00:00
dma_unmap_single ( priv - > tx_chan - > device - > dev , ring - > bds [ ring - > bd_rd_idx ] . dma_mapping_addr ,
skb - > len , DMA_MEM_TO_DEV ) ;
2019-12-10 13:03:47 +00:00
2022-01-06 14:11:05 +00:00
info = IEEE80211_SKB_CB ( skb ) ;
2022-03-29 12:20:38 +00:00
use_ht_aggr = ( ( info - > flags & IEEE80211_TX_CTL_AMPDU ) ! = 0 ) ;
2022-01-06 14:11:05 +00:00
ieee80211_tx_info_clear_status ( info ) ;
// Aggregation packet
2022-03-29 12:20:38 +00:00
if ( use_ht_aggr )
2022-01-06 13:42:01 +00:00
{
2022-01-06 14:11:05 +00:00
start_idx = ( seq_no > = blk_ack_ssn ) ? ( seq_no - blk_ack_ssn ) : ( seq_no + ( ( ~ blk_ack_ssn + 1 ) & 0x0FFF ) ) ;
tx_fail = ( ( ( blk_ack_bitmap > > start_idx ) & 0x1 ) = = 0 ) ;
info - > flags | = IEEE80211_TX_STAT_AMPDU ;
info - > status . ampdu_len = 1 ;
info - > status . ampdu_ack_len = ( tx_fail = = true ) ? 0 : 1 ;
2022-01-06 13:42:01 +00:00
skb_pull ( skb , LEN_MPDU_DELIM ) ;
//skb_trim(skb, num_byte_pad_skb);
}
2022-01-06 14:11:05 +00:00
// Normal packet
else
{
tx_fail = ( ( blk_ack_bitmap & 0x1 ) = = 0 ) ;
info - > flags & = ( ~ IEEE80211_TX_CTL_AMPDU ) ;
2022-01-06 13:42:01 +00:00
}
2022-03-29 12:44:39 +00:00
pkt_need_ack = ( ! ( info - > flags & IEEE80211_TX_CTL_NO_ACK ) ) ;
2022-01-06 14:11:05 +00:00
if ( tx_fail = = false )
info - > flags | = IEEE80211_TX_STAT_ACK ;
2022-01-06 13:42:01 +00:00
info - > status . rates [ 0 ] . count = nof_retx + 1 ; //according to our test, the 1st rate is the most important. we only do retry on the 1st rate
info - > status . rates [ 1 ] . idx = - 1 ;
2022-03-29 12:44:39 +00:00
// info->status.rates[2].idx = -1;
// info->status.rates[3].idx = -1;//in mac80211.h: #define IEEE80211_TX_MAX_RATES 4
2022-03-28 12:49:15 +00:00
info - > status . antenna = priv - > runtime_tx_ant_cfg ;
2022-01-06 13:42:01 +00:00
2022-03-29 12:44:39 +00:00
if ( ( ( ! pkt_need_ack ) & & ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_BROADCAST ) ) | | ( ( pkt_need_ack ) & & ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_UNICAST ) ) ) {
printk ( " %s openwifi_tx_interrupt: tx_result [nof_retx %d pass %d] SC%d prio%d q%d wr%d rd%d num_slot%d cw%d hwq len%08x no_room_flag%x \n " , sdr_compatible_str ,
nof_retx + 1 , ! tx_fail , seq_no , prio , queue_idx , ring - > bd_wr_idx , ring - > bd_rd_idx , num_slot_random , cw , hw_queue_len , dma_fifo_no_room_flag ) ;
}
2022-01-06 13:42:01 +00:00
ieee80211_tx_status_irqsafe ( dev , skb ) ;
2022-03-29 12:44:39 +00:00
ring - > bds [ ring - > bd_rd_idx ] . prio = 0xff ; // invalid value
ring - > bds [ ring - > bd_rd_idx ] . len_mpdu = 0 ; // invalid value
ring - > bds [ ring - > bd_rd_idx ] . seq_no = 0xffff ;
ring - > bds [ ring - > bd_rd_idx ] . skb_linked = NULL ;
ring - > bds [ ring - > bd_rd_idx ] . dma_mapping_addr = 0 ;
2022-01-06 13:42:01 +00:00
}
2020-06-12 08:50:34 +00:00
loop_count + + ;
// printk("%s openwifi_tx_interrupt: loop %d prio %d rd %d\n", sdr_compatible_str, loop_count, prio, ring->bd_rd_idx);
2019-12-10 13:03:47 +00:00
2020-06-12 08:50:34 +00:00
} else
break ;
2019-12-10 13:03:47 +00:00
}
2022-03-29 12:44:39 +00:00
if ( loop_count ! = 1 & & ( ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] ) & DMESG_LOG_ERROR ) )
2020-06-12 08:50:34 +00:00
printk ( " %s openwifi_tx_interrupt: WARNING loop_count %d \n " , sdr_compatible_str , loop_count ) ;
2019-12-10 13:03:47 +00:00
spin_unlock ( & priv - > lock ) ;
return IRQ_HANDLED ;
}
2022-01-06 13:42:01 +00:00
u32 crc_table [ 16 ] = { 0x4DBDF21C , 0x500AE278 , 0x76D3D2D4 , 0x6B64C2B0 , 0x3B61B38C , 0x26D6A3E8 , 0x000F9344 , 0x1DB88320 , 0xA005713C , 0xBDB26158 , 0x9B6B51F4 , 0x86DC4190 , 0xD6D930AC , 0xCB6E20C8 , 0xEDB71064 , 0xF0000000 } ;
u32 gen_mpdu_crc ( u8 * data_in , u32 num_bytes )
{
u32 i , crc = 0 ;
u8 idx ;
for ( i = 0 ; i < num_bytes ; i + + )
{
idx = ( crc & 0x0F ) ^ ( data_in [ i ] & 0x0F ) ;
crc = ( crc > > 4 ) ^ crc_table [ idx ] ;
idx = ( crc & 0x0F ) ^ ( ( data_in [ i ] > > 4 ) & 0x0F ) ;
crc = ( crc > > 4 ) ^ crc_table [ idx ] ;
}
return crc ;
2019-12-10 13:03:47 +00:00
}
2022-01-06 13:42:01 +00:00
u8 gen_mpdu_delim_crc ( u16 m )
2020-11-05 17:22:24 +00:00
{
2022-01-06 13:42:01 +00:00
u8 i , temp , c [ 8 ] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 } , mpdu_delim_crc ;
2020-11-05 17:22:24 +00:00
2022-01-06 13:42:01 +00:00
for ( i = 0 ; i < 16 ; i + + )
2020-11-05 17:22:24 +00:00
{
temp = c [ 7 ] ^ ( ( m > > i ) & 0x01 ) ;
c [ 7 ] = c [ 6 ] ;
c [ 6 ] = c [ 5 ] ;
c [ 5 ] = c [ 4 ] ;
c [ 4 ] = c [ 3 ] ;
c [ 3 ] = c [ 2 ] ;
c [ 2 ] = c [ 1 ] ^ temp ;
c [ 1 ] = c [ 0 ] ^ temp ;
c [ 0 ] = temp ;
}
2022-01-06 13:42:01 +00:00
mpdu_delim_crc = ( ( ~ c [ 7 ] & 0x01 ) < < 0 ) | ( ( ~ c [ 6 ] & 0x01 ) < < 1 ) | ( ( ~ c [ 5 ] & 0x01 ) < < 2 ) | ( ( ~ c [ 4 ] & 0x01 ) < < 3 ) | ( ( ~ c [ 3 ] & 0x01 ) < < 4 ) | ( ( ~ c [ 2 ] & 0x01 ) < < 5 ) | ( ( ~ c [ 1 ] & 0x01 ) < < 6 ) | ( ( ~ c [ 0 ] & 0x01 ) < < 7 ) ;
2020-11-05 17:22:24 +00:00
2022-01-06 13:42:01 +00:00
return mpdu_delim_crc ;
2019-12-10 13:03:47 +00:00
}
static inline struct gpio_led_data * //please align with the implementation in leds-gpio.c
cdev_to_gpio_led_data ( struct led_classdev * led_cdev )
{
return container_of ( led_cdev , struct gpio_led_data , cdev ) ;
}
2022-03-29 09:04:35 +00:00
inline int calc_n_ofdm ( int num_octet , int n_dbps )
{
int num_bit , num_ofdm_sym ;
num_bit = 22 + num_octet * 8 ;
num_ofdm_sym = ( num_bit / n_dbps ) + ( ( num_bit % n_dbps ) ! = 0 ) ;
return ( num_ofdm_sym ) ;
}
inline __le16 gen_ht_duration_id ( __le16 frame_control , __le16 aid , u8 qos_hdr , bool use_ht_aggr , u16 rate_hw_value , u16 sifs )
{
// COTS wifi ht QoS data duration field analysis (lots of capture):
// ht non-aggr QoS data: 44, type 2 (data frame) sub-type 8 (1000) 21.7/52/57.8/58.5/65Mbps
// ack ht 36 + 4*[(22+14*8)/78] = 36 + 4*2 = 44
// ack legacy 20 + 4*[(22+14*8)/72] = 20 + 4*2 = 28
// ht non-aggr QoS data: 60, type 2 (data frame) sub-type 8 (1000) 6.5Mbps
// ack ht 36 + 4*[(22+14*8)/26] = 36 + 4*6 = 60
// ack legacy 20 + 4*[(22+14*8)/24] = 20 + 4*6 = 44
// ht aggr QoS data: 52, type 2 (data frame) sub-type 8 (1000) 19.5/28.9/39/57.8/65/72.2Mbps
// ack ht 36 + 4*[(22+32*8)/78] = 36 + 4*4 = 52
// ack legacy 20 + 4*[(22+32*8)/72] = 20 + 4*4 = 36
// ht aggr QoS data: 60, type 2 (data frame) sub-type 8 (1000) 13/14.4Mbps
// ack ht 36 + 4*[(22+32*8)/52] = 36 + 4*6 = 60
// ack legacy 20 + 4*[(22+32*8)/48] = 20 + 4*6 = 44
// ht and legacy rate mapping is ont one on one, instead it is modulation combined with coding rate
// modulate coding ht-mcs ht-n_dbps legacy-mcs legacy-n_dbps
// BPSK 1/2 0 26 4 24
// QPSK 1/2 1 52 6 48
// QPSK 3/4 2 78 7 72
// 16QAM 1/2 3 104 8 96
// 16QAM 3/4 4 156 9 144
// 64QAM 2/3 5 208 10 192
// 64QAM 3/4 6 234 11 216
// conclusion: duration is: assume ack/blk-ack uses legacy, plus SIFS
// other observation: ht always use QoS data, not data (sub-type)
// other observation: management/control frame always in non-ht
__le16 dur = 0 ;
u16 n_dbps ;
int num_octet , num_ofdm_sym ;
if ( ieee80211_is_pspoll ( frame_control ) ) {
dur = ( aid | 0xc000 ) ;
} else if ( ieee80211_is_data_qos ( frame_control ) & & ( ~ ( qos_hdr & IEEE80211_QOS_CTL_ACK_POLICY_NOACK ) ) ) {
rate_hw_value = ( rate_hw_value > 6 ? 6 : rate_hw_value ) ;
n_dbps = ( rate_hw_value = = 0 ? wifi_n_dbps_table [ 4 ] : wifi_n_dbps_table [ rate_hw_value + 5 ] ) ;
num_octet = ( use_ht_aggr ? 32 : 14 ) ; //32 bytes for compressed block ack; 14 bytes for normal ack
num_ofdm_sym = calc_n_ofdm ( num_octet , n_dbps ) ;
dur = sifs + 20 + 4 * num_ofdm_sym ; // 20us legacy preamble
// printk("%s gen_ht_duration_id: num_octet %d n_dbps %d num_ofdm_sym %d dur %d\n", sdr_compatible_str,
// num_octet, n_dbps, num_ofdm_sym, dur);
} else {
printk ( " %s openwifi_tx: WARNING gen_ht_duration_id wrong pkt type! \n " , sdr_compatible_str ) ;
}
return dur ;
}
2022-03-29 12:44:39 +00:00
inline void report_pkt_loss_due_to_driver_drop ( struct ieee80211_hw * dev , struct sk_buff * skb )
{
struct openwifi_priv * priv = dev - > priv ;
struct ieee80211_tx_info * info ;
info = IEEE80211_SKB_CB ( skb ) ;
ieee80211_tx_info_clear_status ( info ) ;
info - > status . rates [ 0 ] . count = 1 ;
info - > status . rates [ 1 ] . idx = - 1 ;
info - > status . antenna = priv - > runtime_tx_ant_cfg ;
ieee80211_tx_status_irqsafe ( dev , skb ) ;
}
2019-12-10 13:03:47 +00:00
static void openwifi_tx ( struct ieee80211_hw * dev ,
struct ieee80211_tx_control * control ,
struct sk_buff * skb )
{
2020-06-12 08:50:34 +00:00
struct openwifi_priv * priv = dev - > priv ;
unsigned long flags ;
2019-12-10 13:03:47 +00:00
struct ieee80211_tx_info * info = IEEE80211_SKB_CB ( skb ) ;
struct ieee80211_hdr * hdr = ( struct ieee80211_hdr * ) skb - > data ;
2022-01-06 13:42:01 +00:00
struct openwifi_ring * ring = NULL ;
2022-03-29 09:24:42 +00:00
struct sk_buff * skb_new ; // temp skb for internal use
2022-03-29 12:44:39 +00:00
struct ieee80211_tx_info * info_skipped ;
2019-12-10 13:03:47 +00:00
dma_addr_t dma_mapping_addr ;
2022-03-29 12:44:39 +00:00
unsigned int i , j , empty_bd_idx = 0 ;
2022-03-29 09:01:13 +00:00
u16 rate_signal_value , rate_hw_value , len_mpdu , len_psdu , num_dma_symbol , len_mpdu_delim_pad = 0 , num_byte_pad ;
2022-03-29 09:21:46 +00:00
u32 num_dma_byte , addr1_low32 , addr2_low32 = 0 , addr3_low32 = 0 , tx_config , cts_reg , phy_hdr_config ; //, openofdm_state_history;
2022-03-29 09:16:49 +00:00
u16 addr1_high16 , addr2_high16 = 0 , addr3_high16 = 0 , sc , seq_no = 0 , cts_duration = 0 , cts_rate_hw_value = 0 , cts_rate_signal_value = 0 , sifs , ack_duration = 0 , traffic_pkt_duration , n_dbps ;
2022-03-29 12:44:39 +00:00
u8 pkt_need_ack , retry_limit_raw , use_short_gi , * dma_buf , retry_limit_hw_value , rc_flags , qos_hdr , prio , queue_idx , drv_ring_idx ;
2022-03-29 09:16:49 +00:00
bool drv_seqno = false , use_rts_cts , use_cts_protect , ht_aggr_start = false , use_ht_rate , use_ht_aggr , cts_use_traffic_rate = false , force_use_cts_protect = false ;
2019-12-10 13:03:47 +00:00
__le16 frame_control , duration_id ;
2022-03-29 09:18:51 +00:00
u32 dma_fifo_no_room_flag , hw_queue_len , delay_count = 0 ;
2020-06-12 08:50:34 +00:00
enum dma_status status ;
2022-01-06 13:42:01 +00:00
2022-03-29 08:47:32 +00:00
static u32 addr1_low32_prev = - 1 ;
static u16 rate_hw_value_prev = - 1 ;
static u8 pkt_need_ack_prev = - 1 ;
2022-01-06 14:12:03 +00:00
static u16 addr1_high16_prev = - 1 ;
static __le16 duration_id_prev = - 1 ;
2022-03-29 08:47:32 +00:00
static u8 prio_prev = - 1 ;
2022-01-06 13:42:01 +00:00
static u8 retry_limit_raw_prev = - 1 ;
2022-01-06 13:53:39 +00:00
static u8 use_short_gi_prev = - 1 ;
2022-01-06 13:42:01 +00:00
2019-12-10 13:03:47 +00:00
// static bool led_status=0;
// struct gpio_led_data *led_dat = cdev_to_gpio_led_data(priv->led[3]);
// if ( (priv->phy_tx_sn&7) ==0 ) {
// openofdm_state_history = openofdm_rx_api->OPENOFDM_RX_REG_STATE_HISTORY_read();
// if (openofdm_state_history!=openofdm_state_history_old){
// led_status = (~led_status);
// openofdm_state_history_old = openofdm_state_history;
// gpiod_set_value(led_dat->gpiod, led_status);
// }
// }
2020-06-12 08:50:34 +00:00
if ( skb - > data_len > 0 ) { // more data are not in linear data area skb->data
printk ( " %s openwifi_tx: WARNING skb->data_len>0 \n " , sdr_compatible_str ) ;
2019-12-10 13:03:47 +00:00
goto openwifi_tx_early_out ;
2020-06-12 08:50:34 +00:00
}
2019-12-10 13:03:47 +00:00
2022-01-06 13:42:01 +00:00
len_mpdu = skb - > len ;
2020-06-12 08:50:34 +00:00
// get Linux priority/queue setting info and target mac address
prio = skb_get_queue_mapping ( skb ) ;
2022-03-29 08:48:12 +00:00
if ( prio > = MAX_NUM_HW_QUEUE ) {
printk ( " %s openwifi_tx: WARNING prio%d \n " , sdr_compatible_str , prio ) ;
goto openwifi_tx_early_out ;
}
2020-06-12 08:50:34 +00:00
addr1_low32 = * ( ( u32 * ) ( hdr - > addr1 + 2 ) ) ;
2022-03-29 12:44:39 +00:00
// ---- DO your idea here! Map Linux/SW "prio" to driver "drv_ring_idx" (then 1on1 to FPGA queue_idx) ---
2020-06-12 08:50:34 +00:00
if ( priv - > slice_idx = = 0xFFFFFFFF ) { // use Linux default prio setting, if there isn't any slice config
2022-03-29 12:44:39 +00:00
drv_ring_idx = prio ;
} else { // customized prio to drv_ring_idx mapping
2020-06-12 08:50:34 +00:00
// check current packet belonging to which slice/hw-queue
2022-03-29 12:44:39 +00:00
for ( i = 0 ; i < MAX_NUM_HW_QUEUE ; i + + ) {
if ( priv - > dest_mac_addr_queue_map [ i ] = = addr1_low32 ) {
break ;
}
}
drv_ring_idx = ( i > = MAX_NUM_HW_QUEUE ? prio : i ) ; // if no address is hit
}
ring = & ( priv - > tx_ring [ drv_ring_idx ] ) ;
spin_lock_irqsave ( & priv - > lock , flags ) ;
if ( ring - > bds [ ring - > bd_wr_idx ] . seq_no ! = 0xffff ) { // not cleared yet by interrupt
for ( i = 1 ; i < NUM_TX_BD ; i + + ) {
if ( ring - > bds [ ( ring - > bd_wr_idx + i ) & ( NUM_TX_BD - 1 ) ] . seq_no = = 0xffff ) {
empty_bd_idx = i ;
break ;
2020-06-12 08:50:34 +00:00
}
2022-03-29 12:44:39 +00:00
}
hw_queue_len = tx_intf_api - > TX_INTF_REG_QUEUE_FIFO_DATA_COUNT_read ( ) ;
if ( empty_bd_idx ) { // clear all bds before the empty bd and report failure to Linux
for ( i = 0 ; i < empty_bd_idx ; i + + ) {
j = ( ( ring - > bd_wr_idx + i ) & ( NUM_TX_BD - 1 ) ) ;
printk ( " %s openwifi_tx: WARNING fake stop queue empty_bd_idx%d i%d lnx prio%d map to q%d stop%d hwq len%d wr%d rd%d bd prio%d len_mpdu%d seq_no%d skb_linked%p dma_mapping_addr%llu \n " , sdr_compatible_str ,
empty_bd_idx , i , prio , drv_ring_idx , ring - > stop_flag , hw_queue_len , ring - > bd_wr_idx , ring - > bd_rd_idx , ring - > bds [ j ] . prio , ring - > bds [ j ] . len_mpdu , ring - > bds [ j ] . seq_no , ring - > bds [ j ] . skb_linked , ring - > bds [ j ] . dma_mapping_addr ) ;
// tell Linux this skb failed
skb_new = ring - > bds [ j ] . skb_linked ;
dma_unmap_single ( priv - > tx_chan - > device - > dev , ring - > bds [ j ] . dma_mapping_addr ,
skb_new - > len , DMA_MEM_TO_DEV ) ;
info_skipped = IEEE80211_SKB_CB ( skb_new ) ;
ieee80211_tx_info_clear_status ( info_skipped ) ;
info_skipped - > status . rates [ 0 ] . count = 1 ;
info_skipped - > status . rates [ 1 ] . idx = - 1 ;
info_skipped - > status . antenna = priv - > runtime_tx_ant_cfg ;
ieee80211_tx_status_irqsafe ( dev , skb_new ) ;
ring - > bds [ j ] . prio = 0xff ; // invalid value
ring - > bds [ j ] . len_mpdu = 0 ; // invalid value
ring - > bds [ j ] . seq_no = 0xffff ;
ring - > bds [ j ] . skb_linked = NULL ;
ring - > bds [ j ] . dma_mapping_addr = 0 ;
}
if ( ring - > stop_flag ! = - 1 ) { //the interrupt seems will never come, we need to wake up the queue in case the interrupt will never wake it up
ieee80211_wake_queue ( dev , ring - > stop_flag ) ;
ring - > stop_flag = - 1 ;
}
} else {
j = ring - > bd_wr_idx ;
printk ( " %s openwifi_tx: WARNING real stop queue lnx prio%d map to q%d stop%d hwq len%d wr%d rd%d bd prio%d len_mpdu%d seq_no%d skb_linked%p dma_mapping_addr%llu \n " , sdr_compatible_str ,
prio , drv_ring_idx , ring - > stop_flag , hw_queue_len , ring - > bd_wr_idx , ring - > bd_rd_idx , ring - > bds [ j ] . prio , ring - > bds [ j ] . len_mpdu , ring - > bds [ j ] . seq_no , ring - > bds [ j ] . skb_linked , ring - > bds [ j ] . dma_mapping_addr ) ;
ieee80211_stop_queue ( dev , prio ) ; // here we should stop those prio related to the queue idx flag set in TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read
ring - > stop_flag = prio ;
spin_unlock_irqrestore ( & priv - > lock , flags ) ;
goto openwifi_tx_early_out ;
}
2020-06-12 08:50:34 +00:00
}
2022-03-29 12:44:39 +00:00
spin_unlock_irqrestore ( & priv - > lock , flags ) ;
// -------------------- end of Map Linux/SW "prio" to driver "drv_ring_idx" ------------------
2020-06-12 08:50:34 +00:00
// get other info from packet header
2019-12-10 13:03:47 +00:00
addr1_high16 = * ( ( u16 * ) ( hdr - > addr1 ) ) ;
2022-01-06 13:42:01 +00:00
if ( len_mpdu > = 20 ) {
2019-12-10 13:03:47 +00:00
addr2_low32 = * ( ( u32 * ) ( hdr - > addr2 + 2 ) ) ;
addr2_high16 = * ( ( u16 * ) ( hdr - > addr2 ) ) ;
}
2022-01-06 13:42:01 +00:00
if ( len_mpdu > = 26 ) {
2019-12-10 13:03:47 +00:00
addr3_low32 = * ( ( u32 * ) ( hdr - > addr3 + 2 ) ) ;
addr3_high16 = * ( ( u16 * ) ( hdr - > addr3 ) ) ;
}
frame_control = hdr - > frame_control ;
2022-03-29 08:56:47 +00:00
pkt_need_ack = ( ! ( info - > flags & IEEE80211_TX_CTL_NO_ACK ) ) ;
2019-12-10 13:03:47 +00:00
retry_limit_raw = info - > control . rates [ 0 ] . count ;
rc_flags = info - > control . rates [ 0 ] . flags ;
use_rts_cts = ( ( rc_flags & IEEE80211_TX_RC_USE_RTS_CTS ) ! = 0 ) ;
use_cts_protect = ( ( rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT ) ! = 0 ) ;
2020-11-05 17:22:24 +00:00
use_ht_rate = ( ( rc_flags & IEEE80211_TX_RC_MCS ) ! = 0 ) ;
use_short_gi = ( ( rc_flags & IEEE80211_TX_RC_SHORT_GI ) ! = 0 ) ;
2022-01-06 13:42:01 +00:00
use_ht_aggr = ( ( info - > flags & IEEE80211_TX_CTL_AMPDU ) ! = 0 ) ;
2022-03-29 08:45:49 +00:00
qos_hdr = ( * ( ieee80211_get_qos_ctl ( hdr ) ) ) ;
2019-12-10 13:03:47 +00:00
2022-03-29 08:56:47 +00:00
// get Linux rate (MCS) setting
rate_hw_value = ieee80211_get_tx_rate ( dev , info ) - > hw_value ;
// drv_tx_reg_val[DRV_TX_REG_IDX_RATE]
// override rate legacy: 4:6M, 5:9M, 6:12M, 7:18M, 8:24M, 9:36M, 10:48M, 11:54M
// drv_tx_reg_val[DRV_TX_REG_IDX_RATE_HT]
// override rate ht: 4:6.5M, 5:13M, 6:19.5M,7:26M, 8:39M, 9:52M, 10:58.5M, 11:65M
if ( ieee80211_is_data ( hdr - > frame_control ) ) { //rate override command
if ( use_ht_rate & & priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_RATE_HT ] > 0 ) {
rate_hw_value = ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_RATE_HT ] & 0xF ) - 4 ;
use_short_gi = ( ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_RATE_HT ] & 0x10 ) = = 0x10 ) ;
} else if ( ( ! use_ht_rate ) & & priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_RATE ] > 0 )
rate_hw_value = ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_RATE ] & 0xF ) ;
// TODO: need to map rate_hw_value back to info->control.rates[0].idx!!!
}
// Workaround for a FPGA bug: if aggr happens on ht mcs 0, the tx core will never end, running eneless and stuck the low MAC!
if ( use_ht_aggr & & rate_hw_value = = 0 )
rate_hw_value = 1 ;
2022-03-29 09:03:31 +00:00
sifs = ( priv - > actual_rx_lo < 2500 ? 10 : 16 ) ;
2022-03-29 09:04:35 +00:00
if ( use_ht_rate ) {
// printk("%s openwifi_tx: rate_hw_value %d aggr %d sifs %d\n", sdr_compatible_str, rate_hw_value, use_ht_aggr, sifs);
hdr - > duration_id = gen_ht_duration_id ( frame_control , control - > sta - > aid , qos_hdr , use_ht_aggr , rate_hw_value , sifs ) ; //linux only do it for 11a/g, not for 11n and later
}
duration_id = hdr - > duration_id ;
2019-12-10 13:03:47 +00:00
if ( use_rts_cts )
2020-06-12 08:50:34 +00:00
printk ( " %s openwifi_tx: WARNING sn %d use_rts_cts is not supported! \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
2019-12-10 13:03:47 +00:00
if ( use_cts_protect ) {
cts_rate_hw_value = ieee80211_get_rts_cts_rate ( dev , info ) - > hw_value ;
2022-01-06 13:42:01 +00:00
cts_duration = le16_to_cpu ( ieee80211_ctstoself_duration ( dev , info - > control . vif , len_mpdu , info ) ) ;
2019-12-10 13:03:47 +00:00
} else if ( force_use_cts_protect ) { // could override mac80211 setting here.
cts_rate_hw_value = 4 ; //wifi_mcs_table_11b_force_up[] translate it to 1011(6M)
if ( pkt_need_ack )
ack_duration = 44 ; //assume the ack we wait use 6Mbps: 4*ceil((22+14*8)/24) + 20(preamble+SIGNAL)
2022-03-29 09:03:31 +00:00
n_dbps = ( use_ht_rate ? wifi_n_dbps_ht_table [ rate_hw_value + 4 ] : wifi_n_dbps_table [ rate_hw_value ] ) ;
traffic_pkt_duration = ( use_ht_rate ? 36 : 20 ) + 4 * calc_n_ofdm ( len_mpdu , n_dbps ) ;
2019-12-10 13:03:47 +00:00
cts_duration = traffic_pkt_duration + sifs + pkt_need_ack * ( sifs + ack_duration ) ;
}
2020-09-04 08:57:04 +00:00
// this is 11b stuff
// if (info->flags&IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
// printk("%s openwifi_tx: WARNING IEEE80211_TX_RC_USE_SHORT_PREAMBLE\n", sdr_compatible_str);
2022-01-06 13:42:01 +00:00
if ( len_mpdu > = 28 ) {
2020-09-04 08:57:04 +00:00
if ( info - > flags & IEEE80211_TX_CTL_ASSIGN_SEQ ) {
2022-03-29 09:16:49 +00:00
if ( info - > flags & IEEE80211_TX_CTL_FIRST_FRAGMENT ) {
2020-09-04 08:57:04 +00:00
priv - > seqno + = 0x10 ;
2022-03-29 09:16:49 +00:00
drv_seqno = true ;
}
2020-09-04 08:57:04 +00:00
hdr - > seq_ctrl & = cpu_to_le16 ( IEEE80211_SCTL_FRAG ) ;
hdr - > seq_ctrl | = cpu_to_le16 ( priv - > seqno ) ;
}
sc = hdr - > seq_ctrl ;
2022-03-29 09:16:49 +00:00
seq_no = ( sc & IEEE80211_SCTL_SEQ ) > > 4 ;
2020-09-04 08:57:04 +00:00
}
2019-12-10 13:03:47 +00:00
// printk("%s openwifi_tx: rate&try: %d %d %03x; %d %d %03x; %d %d %03x; %d %d %03x\n", sdr_compatible_str,
// info->status.rates[0].idx,info->status.rates[0].count,info->status.rates[0].flags,
// info->status.rates[1].idx,info->status.rates[1].count,info->status.rates[1].flags,
// info->status.rates[2].idx,info->status.rates[2].count,info->status.rates[2].flags,
// info->status.rates[3].idx,info->status.rates[3].count,info->status.rates[3].flags);
// -----------end of preprocess some info from header and skb----------------
// /* HW will perform RTS-CTS when only RTS flags is set.
// * HW will perform CTS-to-self when both RTS and CTS flags are set.
// * RTS rate and RTS duration will be used also for CTS-to-self.
// */
// if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
// tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
// rts_duration = ieee80211_rts_duration(dev, priv->vif[0], // assume all vif have the same config
2022-01-06 13:42:01 +00:00
// len_mpdu, info);
2019-12-10 13:03:47 +00:00
// printk("%s openwifi_tx: rc_flags & IEEE80211_TX_RC_USE_RTS_CTS\n", sdr_compatible_str);
// } else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
// tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19;
// rts_duration = ieee80211_ctstoself_duration(dev, priv->vif[0], // assume all vif have the same config
2022-01-06 13:42:01 +00:00
// len_mpdu, info);
2019-12-10 13:03:47 +00:00
// printk("%s openwifi_tx: rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT\n", sdr_compatible_str);
// }
2022-01-06 13:42:01 +00:00
if ( use_ht_aggr )
{
2022-03-29 08:45:49 +00:00
if ( ieee80211_is_data_qos ( frame_control ) = = false )
2022-01-06 13:42:01 +00:00
{
2022-03-29 08:45:49 +00:00
printk ( " %s openwifi_tx: WARNING packet is not QoS packet! \n " , sdr_compatible_str ) ;
2019-12-10 13:03:47 +00:00
goto openwifi_tx_early_out ;
}
2022-01-06 13:42:01 +00:00
// psdu = [ MPDU DEL | MPDU | CRC | MPDU padding ]
len_mpdu_delim_pad = ( ( len_mpdu + LEN_PHY_CRC ) % 4 = = 0 ) ? 0 : ( 4 - ( len_mpdu + LEN_PHY_CRC ) % 4 ) ;
len_psdu = LEN_MPDU_DELIM + len_mpdu + LEN_PHY_CRC + len_mpdu_delim_pad ;
2022-01-06 14:12:03 +00:00
if ( ( addr1_low32 ! = addr1_low32_prev ) | | ( addr1_high16 ! = addr1_high16_prev ) | | ( duration_id ! = duration_id_prev ) | |
( rate_hw_value ! = rate_hw_value_prev ) | | ( use_short_gi ! = use_short_gi_prev ) | |
( prio ! = prio_prev ) | | ( retry_limit_raw ! = retry_limit_raw_prev ) | | ( pkt_need_ack ! = pkt_need_ack_prev ) )
2022-01-06 13:42:01 +00:00
{
2022-01-06 14:12:03 +00:00
addr1_low32_prev = addr1_low32 ;
addr1_high16_prev = addr1_high16 ;
duration_id_prev = duration_id ;
2022-01-06 13:42:01 +00:00
rate_hw_value_prev = rate_hw_value ;
use_short_gi_prev = use_short_gi ;
prio_prev = prio ;
retry_limit_raw_prev = retry_limit_raw ;
pkt_need_ack_prev = pkt_need_ack ;
ht_aggr_start = true ;
}
2019-12-10 13:03:47 +00:00
}
2022-01-06 13:42:01 +00:00
else
{
// psdu = [ MPDU ]
len_psdu = len_mpdu ;
2022-03-29 08:04:25 +00:00
// // Don't need to reset _prev variables every time when it is not ht aggr qos data. Reason:
// // 1. In 99.9999% cases, the ht always use qos data and goes to prio/queue_idx 2. By not resetting the variable to -1, we can have continuous aggregation packet operation in FPGA queue 2.
// // 2. In other words, the aggregation operation for queue 2 in FPGA won't be interrupted by other non aggregation packets (control/management/beacon/etc.) that go to queue 0 (or other queues than 2).
// // 3. From wired domain and upper level ( DSCP, AC (0~3), WMM management, 802.11D service classes and user priority (UP) ) to chip/FPGA queue index, thre should be some (complicated) mapping relationship.
// // 4. More decent design is setting these aggregation flags (ht_aggr_start) per queue/prio here in driver. But since now only queue 2 and 0 are used (data goes to queue 2, others go to queue 0) in normal (most) cases, let's not go to the decent (complicated) solution immediately.
// addr1_low32_prev = -1;
// addr1_high16_prev = -1;
// duration_id_prev = -1;
// use_short_gi_prev = -1;
// rate_hw_value_prev = -1;
// prio_prev = -1;
// retry_limit_raw_prev = -1;
// pkt_need_ack_prev = -1;
2022-01-06 13:42:01 +00:00
}
num_dma_symbol = ( len_psdu > > TX_INTF_NUM_BYTE_PER_DMA_SYMBOL_IN_BITS ) + ( ( len_psdu & ( TX_INTF_NUM_BYTE_PER_DMA_SYMBOL - 1 ) ) ! = 0 ) ;
2022-03-29 12:44:39 +00:00
if ( ( ( ! pkt_need_ack ) & & ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_BROADCAST ) ) | | ( ( pkt_need_ack ) & & ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_UNICAST ) ) )
printk ( " %s openwifi_tx: %dB RC%x %dM FC%04x DI%04x ADDR%04x%08x/%04x%08x/%04x%08x flag%08x QoS%02x SC%d_%d retr%d ack%d prio%d q%d wr%d rd%d \n " , sdr_compatible_str ,
len_mpdu , rc_flags , ( use_ht_rate = = false ? wifi_rate_all [ rate_hw_value ] : wifi_rate_all [ rate_hw_value + 12 ] ) , frame_control , duration_id ,
2022-03-29 09:23:10 +00:00
reverse16 ( addr1_high16 ) , reverse32 ( addr1_low32 ) , reverse16 ( addr2_high16 ) , reverse32 ( addr2_low32 ) , reverse16 ( addr3_high16 ) , reverse32 ( addr3_low32 ) ,
2022-03-29 12:44:39 +00:00
info - > flags , qos_hdr , seq_no , drv_seqno , retry_limit_raw , pkt_need_ack , prio , drv_ring_idx ,
2022-03-29 09:23:10 +00:00
// use_rts_cts,use_cts_protect|force_use_cts_protect,wifi_rate_all[cts_rate_hw_value],cts_duration,
ring - > bd_wr_idx , ring - > bd_rd_idx ) ;
2022-01-06 13:42:01 +00:00
// check whether the packet is bigger than DMA buffer size
num_dma_byte = ( num_dma_symbol < < TX_INTF_NUM_BYTE_PER_DMA_SYMBOL_IN_BITS ) ;
if ( num_dma_byte > TX_BD_BUF_SIZE ) {
printk ( " %s openwifi_tx: WARNING sn %d num_dma_byte > TX_BD_BUF_SIZE \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
2019-12-10 13:03:47 +00:00
goto openwifi_tx_early_out ;
}
2022-01-06 13:42:01 +00:00
// Copy MPDU delimiter and padding into sk_buff
if ( use_ht_aggr )
{
// when skb does not have enough headroom, skb_push will cause kernel panic. headroom needs to be extended if necessary
2022-03-29 09:24:42 +00:00
if ( skb_headroom ( skb ) < LEN_MPDU_DELIM ) { // in case original skb headroom is not enough to host MPDU delimiter
printk ( " %s openwifi_tx: WARNING(AGGR) sn %d skb_headroom(skb) %d < LEN_MPDU_DELIM %d \n " , sdr_compatible_str , ring - > bd_wr_idx , skb_headroom ( skb ) , LEN_MPDU_DELIM ) ;
2022-01-06 13:42:01 +00:00
if ( ( skb_new = skb_realloc_headroom ( skb , LEN_MPDU_DELIM ) ) = = NULL ) {
printk ( " %s openwifi_tx: WARNING sn %d skb_realloc_headroom failed! \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
goto openwifi_tx_early_out ;
}
if ( skb - > sk ! = NULL )
skb_set_owner_w ( skb_new , skb - > sk ) ;
dev_kfree_skb ( skb ) ;
skb = skb_new ;
}
skb_push ( skb , LEN_MPDU_DELIM ) ;
dma_buf = skb - > data ;
// fill in MPDU delimiter
* ( ( u16 * ) ( dma_buf + 0 ) ) = ( ( u16 ) ( len_mpdu + LEN_PHY_CRC ) < < 4 ) & 0xFFF0 ;
* ( ( u8 * ) ( dma_buf + 2 ) ) = gen_mpdu_delim_crc ( * ( ( u16 * ) dma_buf ) ) ;
* ( ( u8 * ) ( dma_buf + 3 ) ) = 0x4e ;
// Extend sk_buff to hold CRC + MPDU padding + empty MPDU delimiter
num_byte_pad = num_dma_byte - ( LEN_MPDU_DELIM + len_mpdu ) ;
2022-03-29 09:24:42 +00:00
if ( skb_tailroom ( skb ) < num_byte_pad ) { // in case original skb tailroom is not enough to host num_byte_pad
printk ( " %s openwifi_tx: WARNING(AGGR) sn %d skb_tailroom(skb) %d < num_byte_pad %d! \n " , sdr_compatible_str , ring - > bd_wr_idx , skb_tailroom ( skb ) , num_byte_pad ) ;
if ( ( skb_new = skb_copy_expand ( skb , skb_headroom ( skb ) , num_byte_pad , GFP_KERNEL ) ) = = NULL ) {
printk ( " %s openwifi_tx: WARNING(AGGR) sn %d skb_copy_expand failed! \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
goto openwifi_tx_early_out ;
}
if ( skb - > sk ! = NULL )
skb_set_owner_w ( skb_new , skb - > sk ) ;
dev_kfree_skb ( skb ) ;
skb = skb_new ;
2022-01-06 13:42:01 +00:00
}
skb_put ( skb , num_byte_pad ) ;
// fill in MPDU CRC
* ( ( u32 * ) ( dma_buf + LEN_MPDU_DELIM + len_mpdu ) ) = gen_mpdu_crc ( dma_buf + LEN_MPDU_DELIM , len_mpdu ) ;
// fill in MPDU delimiter padding
memset ( dma_buf + LEN_MPDU_DELIM + len_mpdu + LEN_PHY_CRC , 0 , len_mpdu_delim_pad ) ;
// num_dma_byte is on 8-byte boundary and len_psdu is on 4 byte boundary.
// If they have different lengths, add "empty MPDU delimiter" for alignment
if ( num_dma_byte = = len_psdu + 4 )
{
* ( ( u32 * ) ( dma_buf + len_psdu ) ) = 0x4e140000 ;
len_psdu = num_dma_byte ;
}
}
else
{
2022-01-06 13:53:39 +00:00
// Extend sk_buff to hold padding
num_byte_pad = num_dma_byte - len_mpdu ;
2022-03-29 09:24:42 +00:00
if ( skb_tailroom ( skb ) < num_byte_pad ) { // in case original skb tailroom is not enough to host num_byte_pad
printk ( " %s openwifi_tx: WARNING sn %d skb_tailroom(skb) %d < num_byte_pad %d! \n " , sdr_compatible_str , ring - > bd_wr_idx , skb_tailroom ( skb ) , num_byte_pad ) ;
if ( ( skb_new = skb_copy_expand ( skb , skb_headroom ( skb ) , num_byte_pad , GFP_KERNEL ) ) = = NULL ) {
printk ( " %s openwifi_tx: WARNING sn %d skb_copy_expand failed! \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
goto openwifi_tx_early_out ;
}
if ( skb - > sk ! = NULL )
skb_set_owner_w ( skb_new , skb - > sk ) ;
dev_kfree_skb ( skb ) ;
skb = skb_new ;
2022-01-06 13:53:39 +00:00
}
skb_put ( skb , num_byte_pad ) ;
2022-01-06 13:42:01 +00:00
dma_buf = skb - > data ;
}
// for(i = 0; i <= num_dma_symbol; i++)
// printk("%16llx\n", (*(u64*)(&(dma_buf[i*8]))));
rate_signal_value = ( use_ht_rate ? rate_hw_value : wifi_mcs_table_11b_force_up [ rate_hw_value ] ) ;
2019-12-10 13:03:47 +00:00
2021-04-05 19:53:29 +00:00
retry_limit_hw_value = ( retry_limit_raw = = 0 ? 0 : ( ( retry_limit_raw - 1 ) & 0xF ) ) ;
2019-12-10 13:03:47 +00:00
2022-03-29 12:44:39 +00:00
queue_idx = drv_ring_idx ; // from driver ring idx to FPGA queue_idx mapping
2019-12-10 13:03:47 +00:00
cts_rate_signal_value = wifi_mcs_table_11b_force_up [ cts_rate_hw_value ] ;
2022-01-06 13:42:01 +00:00
cts_reg = ( ( use_cts_protect | force_use_cts_protect ) < < 31 | cts_use_traffic_rate < < 30 | cts_duration < < 8 | cts_rate_signal_value < < 4 | rate_signal_value ) ;
2022-03-29 08:21:04 +00:00
tx_config = ( prio < < 26 | ring - > bd_wr_idx < < 20 | queue_idx < < 18 | retry_limit_hw_value < < 14 | pkt_need_ack < < 13 | num_dma_symbol ) ;
2022-01-06 13:42:01 +00:00
phy_hdr_config = ( ht_aggr_start < < 20 | rate_hw_value < < 16 | use_ht_rate < < 15 | use_short_gi < < 14 | use_ht_aggr < < 13 | len_psdu ) ;
2019-12-10 13:03:47 +00:00
/* We must be sure that tx_flags is written last because the HW
* looks at it to check if the rest of data is valid or not
*/
//wmb();
// entry->flags = cpu_to_le32(tx_flags);
2021-02-04 08:54:47 +00:00
/* We must be sure this has been written before following HW
* register write , because this write will make the HW attempts
2019-12-10 13:03:47 +00:00
* to DMA the just - written data
*/
//wmb();
2020-06-12 08:50:34 +00:00
spin_lock_irqsave ( & priv - > lock , flags ) ; // from now on, we'd better avoid interrupt because ring->stop_flag is shared with interrupt
// -------------check whether FPGA dma fifo and queue (queue_idx) has enough room-------------
2022-01-06 14:07:50 +00:00
dma_fifo_no_room_flag = tx_intf_api - > TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read ( ) ;
hw_queue_len = tx_intf_api - > TX_INTF_REG_QUEUE_FIFO_DATA_COUNT_read ( ) ;
2022-03-29 12:44:39 +00:00
if ( ( ( dma_fifo_no_room_flag > > queue_idx ) & 1 ) | | ( ( NUM_TX_BD - ( ( hw_queue_len > > ( queue_idx * 8 ) ) & 0xFF ) ) < = RING_ROOM_THRESHOLD ) | | ring - > stop_flag > = 0 ) {
if ( priv - > drv_tx_reg_val [ DRV_TX_REG_IDX_PRINT_CFG ] & DMESG_LOG_NORMAL_QUEUE_STOP )
printk ( " %s openwifi_tx: WARNING ieee80211_stop_queue prio%d queue%d no room flag%x hwq len%08x request%d wr%d rd%d \n " , sdr_compatible_str ,
prio , queue_idx , dma_fifo_no_room_flag , hw_queue_len , num_dma_symbol , ring - > bd_wr_idx , ring - > bd_rd_idx ) ;
2020-06-12 08:50:34 +00:00
ieee80211_stop_queue ( dev , prio ) ; // here we should stop those prio related to the queue idx flag set in TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read
2022-03-29 12:44:39 +00:00
ring - > stop_flag = prio ;
// goto openwifi_tx_early_out_after_lock;
2020-06-12 08:50:34 +00:00
}
// --------end of check whether FPGA fifo (queue_idx) has enough room------------
status = dma_async_is_tx_complete ( priv - > tx_chan , priv - > tx_cookie , NULL , NULL ) ;
2022-03-29 09:18:51 +00:00
while ( delay_count < 100 & & status ! = DMA_COMPLETE ) {
status = dma_async_is_tx_complete ( priv - > tx_chan , priv - > tx_cookie , NULL , NULL ) ;
delay_count + + ;
udelay ( 4 ) ;
// udelay(priv->stat.dbg_ch1);
}
2020-06-12 08:50:34 +00:00
if ( status ! = DMA_COMPLETE ) {
printk ( " %s openwifi_tx: WARNING status!=DMA_COMPLETE \n " , sdr_compatible_str ) ;
goto openwifi_tx_early_out_after_lock ;
}
2019-12-10 13:03:47 +00:00
//-------------------------fire skb DMA to hardware----------------------------------
dma_mapping_addr = dma_map_single ( priv - > tx_chan - > device - > dev , dma_buf ,
num_dma_byte , DMA_MEM_TO_DEV ) ;
if ( dma_mapping_error ( priv - > tx_chan - > device - > dev , dma_mapping_addr ) ) {
2020-06-12 08:50:34 +00:00
// dev_err(priv->tx_chan->device->dev, "sdr,sdr openwifi_tx: WARNING TX DMA mapping error\n");
printk ( " %s openwifi_tx: WARNING sn %d TX DMA mapping error \n " , sdr_compatible_str , ring - > bd_wr_idx ) ;
goto openwifi_tx_early_out_after_lock ;
2019-12-10 13:03:47 +00:00
}
2020-10-08 13:07:57 +00:00
sg_init_table ( & ( priv - > tx_sg ) , 1 ) ; // only need to be initialized once in openwifi_start
2019-12-10 13:03:47 +00:00
sg_dma_address ( & ( priv - > tx_sg ) ) = dma_mapping_addr ;
sg_dma_len ( & ( priv - > tx_sg ) ) = num_dma_byte ;
tx_intf_api - > TX_INTF_REG_CTS_TOSELF_CONFIG_write ( cts_reg ) ;
2022-01-06 13:42:01 +00:00
tx_intf_api - > TX_INTF_REG_TX_CONFIG_write ( tx_config ) ;
tx_intf_api - > TX_INTF_REG_PHY_HDR_CONFIG_write ( phy_hdr_config ) ;
2019-12-10 13:03:47 +00:00
priv - > txd = priv - > tx_chan - > device - > device_prep_slave_sg ( priv - > tx_chan , & ( priv - > tx_sg ) , 1 , DMA_MEM_TO_DEV , DMA_CTRL_ACK | DMA_PREP_INTERRUPT , NULL ) ;
if ( ! ( priv - > txd ) ) {
2020-06-12 08:50:34 +00:00
printk ( " %s openwifi_tx: WARNING sn %d device_prep_slave_sg %p \n " , sdr_compatible_str , ring - > bd_wr_idx , ( void * ) ( priv - > txd ) ) ;
2019-12-10 13:03:47 +00:00
goto openwifi_tx_after_dma_mapping ;
}
priv - > tx_cookie = priv - > txd - > tx_submit ( priv - > txd ) ;
if ( dma_submit_error ( priv - > tx_cookie ) ) {
2020-06-12 08:50:34 +00:00
printk ( " %s openwifi_tx: WARNING sn %d dma_submit_error(tx_cookie) %d \n " , sdr_compatible_str , ring - > bd_wr_idx , ( u32 ) ( priv - > tx_cookie ) ) ;
2019-12-10 13:03:47 +00:00
goto openwifi_tx_after_dma_mapping ;
}
2021-02-04 08:54:47 +00:00
// seems everything is ok. let's mark this pkt in bd descriptor ring
2022-03-29 12:44:39 +00:00
ring - > bds [ ring - > bd_wr_idx ] . prio = prio ;
ring - > bds [ ring - > bd_wr_idx ] . len_mpdu = len_mpdu ;
2022-03-29 09:16:49 +00:00
ring - > bds [ ring - > bd_wr_idx ] . seq_no = seq_no ;
2019-12-10 13:03:47 +00:00
ring - > bds [ ring - > bd_wr_idx ] . skb_linked = skb ;
ring - > bds [ ring - > bd_wr_idx ] . dma_mapping_addr = dma_mapping_addr ;
ring - > bd_wr_idx = ( ( ring - > bd_wr_idx + 1 ) & ( NUM_TX_BD - 1 ) ) ;
dma_async_issue_pending ( priv - > tx_chan ) ;
spin_unlock_irqrestore ( & priv - > lock , flags ) ;
return ;
openwifi_tx_after_dma_mapping :
dma_unmap_single ( priv - > tx_chan - > device - > dev , dma_mapping_addr , num_dma_byte , DMA_MEM_TO_DEV ) ;
2020-06-12 08:50:34 +00:00
openwifi_tx_early_out_after_lock :
2019-12-10 13:03:47 +00:00
spin_unlock_irqrestore ( & priv - > lock , flags ) ;
2022-03-29 12:44:39 +00:00
report_pkt_loss_due_to_driver_drop ( dev , skb ) ;
// dev_kfree_skb(skb);
2020-06-12 08:50:34 +00:00
// printk("%s openwifi_tx: WARNING openwifi_tx_after_dma_mapping phy_tx_sn %d queue %d\n", sdr_compatible_str,priv->phy_tx_sn,queue_idx);
return ;
2019-12-10 13:03:47 +00:00
openwifi_tx_early_out :
2022-03-29 12:44:39 +00:00
report_pkt_loss_due_to_driver_drop ( dev , skb ) ;
// dev_kfree_skb(skb);
2020-06-12 08:50:34 +00:00
// printk("%s openwifi_tx: WARNING openwifi_tx_early_out phy_tx_sn %d queue %d\n", sdr_compatible_str,priv->phy_tx_sn,queue_idx);
2019-12-10 13:03:47 +00:00
}
2022-03-28 12:49:15 +00:00
static int openwifi_set_antenna ( struct ieee80211_hw * dev , u32 tx_ant , u32 rx_ant )
{
struct openwifi_priv * priv = dev - > priv ;
u8 fpga_tx_ant_setting , target_rx_ant ;
u32 atten_mdb_tx0 , atten_mdb_tx1 ;
struct ctrl_outs_control ctrl_out ;
int ret ;
printk ( " %s openwifi_set_antenna: tx_ant%d rx_ant%d \n " , sdr_compatible_str , tx_ant , rx_ant ) ;
if ( tx_ant > = 4 | | tx_ant = = 0 ) {
return - EINVAL ;
} else if ( rx_ant > = 3 | | rx_ant = = 0 ) {
return - EINVAL ;
}
fpga_tx_ant_setting = ( ( tx_ant < = 2 ) ? ( tx_ant ) : ( tx_ant + 16 ) ) ;
target_rx_ant = ( ( rx_ant & 1 ) ? 0 : 1 ) ;
// try rf chip setting firstly, only update internal state variable when rf chip succeed
atten_mdb_tx0 = ( ( tx_ant & 1 ) ? ( AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) : AD9361_RADIO_OFF_TX_ATT ) ;
atten_mdb_tx1 = ( ( tx_ant & 2 ) ? ( AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) : AD9361_RADIO_OFF_TX_ATT ) ;
ret = ad9361_set_tx_atten ( priv - > ad9361_phy , atten_mdb_tx0 , true , false , true ) ;
if ( ret < 0 ) {
printk ( " %s openwifi_set_antenna: WARNING ad9361_set_tx_atten ant0 %d FAIL! \n " , sdr_compatible_str , atten_mdb_tx0 ) ;
return - EINVAL ;
} else {
printk ( " %s openwifi_set_antenna: ad9361_set_tx_atten ant0 %d OK \n " , sdr_compatible_str , atten_mdb_tx0 ) ;
}
ret = ad9361_set_tx_atten ( priv - > ad9361_phy , atten_mdb_tx1 , false , true , true ) ;
if ( ret < 0 ) {
printk ( " %s openwifi_set_antenna: WARNING ad9361_set_tx_atten ant1 %d FAIL! \n " , sdr_compatible_str , atten_mdb_tx1 ) ;
return - EINVAL ;
} else {
printk ( " %s openwifi_set_antenna: ad9361_set_tx_atten ant1 %d OK \n " , sdr_compatible_str , atten_mdb_tx1 ) ;
}
ctrl_out . en_mask = priv - > ctrl_out . en_mask ;
ctrl_out . index = ( target_rx_ant = = 0 ? AD9361_CTRL_OUT_INDEX_ANT0 : AD9361_CTRL_OUT_INDEX_ANT1 ) ;
ret = ad9361_ctrl_outs_setup ( priv - > ad9361_phy , & ( ctrl_out ) ) ;
if ( ret < 0 ) {
printk ( " %s openwifi_set_antenna: WARNING ad9361_ctrl_outs_setup en_mask 0x%02x index 0x%02x FAIL! \n " , sdr_compatible_str , ctrl_out . en_mask , ctrl_out . index ) ;
return - EINVAL ;
} else {
printk ( " %s openwifi_set_antenna: ad9361_ctrl_outs_setup en_mask 0x%02x index 0x%02x \n " , sdr_compatible_str , ctrl_out . en_mask , ctrl_out . index ) ;
}
tx_intf_api - > TX_INTF_REG_ANT_SEL_write ( fpga_tx_ant_setting ) ;
ret = tx_intf_api - > TX_INTF_REG_ANT_SEL_read ( ) ;
if ( ret ! = fpga_tx_ant_setting ) {
printk ( " %s openwifi_set_antenna: WARNING TX_INTF_REG_ANT_SEL_write target %d read back %d \n " , sdr_compatible_str , fpga_tx_ant_setting , ret ) ;
return - EINVAL ;
} else {
printk ( " %s openwifi_set_antenna: TX_INTF_REG_ANT_SEL_write value %d \n " , sdr_compatible_str , ret ) ;
}
rx_intf_api - > RX_INTF_REG_ANT_SEL_write ( target_rx_ant ) ;
ret = rx_intf_api - > RX_INTF_REG_ANT_SEL_read ( ) ;
if ( ret ! = target_rx_ant ) {
printk ( " %s openwifi_set_antenna: WARNING RX_INTF_REG_ANT_SEL_write target %d read back %d \n " , sdr_compatible_str , target_rx_ant , ret ) ;
return - EINVAL ;
} else {
printk ( " %s openwifi_set_antenna: RX_INTF_REG_ANT_SEL_write value %d \n " , sdr_compatible_str , ret ) ;
}
// update internal state variable
priv - > runtime_tx_ant_cfg = tx_ant ;
priv - > runtime_rx_ant_cfg = rx_ant ;
if ( TX_OFFSET_TUNING_ENABLE )
priv - > tx_intf_cfg = ( ( tx_ant & 1 ) ? TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0 : TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT1 ) ; //NO USE
else {
if ( tx_ant = = 3 )
priv - > tx_intf_cfg = TX_INTF_BW_20MHZ_AT_0MHZ_ANT_BOTH ;
else
priv - > tx_intf_cfg = ( ( tx_ant & 1 ) ? TX_INTF_BW_20MHZ_AT_0MHZ_ANT0 : TX_INTF_BW_20MHZ_AT_0MHZ_ANT1 ) ;
}
priv - > rx_intf_cfg = ( target_rx_ant = = 0 ? RX_INTF_BW_20MHZ_AT_0MHZ_ANT0 : RX_INTF_BW_20MHZ_AT_0MHZ_ANT1 ) ;
priv - > ctrl_out . index = ctrl_out . index ;
priv - > tx_freq_offset_to_lo_MHz = tx_intf_fo_mapping [ priv - > tx_intf_cfg ] ;
priv - > rx_freq_offset_to_lo_MHz = rx_intf_fo_mapping [ priv - > rx_intf_cfg ] ;
return 0 ;
}
static int openwifi_get_antenna ( struct ieee80211_hw * dev , u32 * tx_ant , u32 * rx_ant )
{
struct openwifi_priv * priv = dev - > priv ;
* tx_ant = priv - > runtime_tx_ant_cfg ;
* rx_ant = priv - > runtime_rx_ant_cfg ;
printk ( " %s openwifi_get_antenna: tx_ant%d rx_ant%d \n " , sdr_compatible_str , * tx_ant , * rx_ant ) ;
printk ( " %s openwifi_get_antenna: drv tx cfg %d offset %d drv rx cfg %d offset %d drv ctrl_out sel %x \n " , sdr_compatible_str ,
priv - > tx_intf_cfg , priv - > tx_freq_offset_to_lo_MHz , priv - > rx_intf_cfg , priv - > rx_freq_offset_to_lo_MHz , priv - > ctrl_out . index ) ;
printk ( " %s openwifi_get_antenna: fpga tx sel %d rx sel %d \n " , sdr_compatible_str ,
tx_intf_api - > TX_INTF_REG_ANT_SEL_read ( ) , rx_intf_api - > RX_INTF_REG_ANT_SEL_read ( ) ) ;
printk ( " %s openwifi_get_antenna: rf tx att0 %d tx att1 %d ctrl_out sel %x \n " , sdr_compatible_str ,
ad9361_get_tx_atten ( priv - > ad9361_phy , 1 ) , ad9361_get_tx_atten ( priv - > ad9361_phy , 2 ) , ad9361_spi_read ( priv - > ad9361_phy - > spi , REG_CTRL_OUTPUT_POINTER ) ) ;
return 0 ;
}
2019-12-10 13:03:47 +00:00
static int openwifi_start ( struct ieee80211_hw * dev )
{
struct openwifi_priv * priv = dev - > priv ;
2022-03-28 14:13:42 +00:00
int ret , i ;
2019-12-10 13:03:47 +00:00
u32 reg ;
for ( i = 0 ; i < MAX_NUM_VIF ; i + + ) {
priv - > vif [ i ] = NULL ;
}
2022-03-28 12:55:57 +00:00
// //keep software registers persistent between NIC down and up for multiple times
/*memset(priv->drv_tx_reg_val, 0, sizeof(priv->drv_tx_reg_val));
2020-06-12 08:50:34 +00:00
memset ( priv - > drv_rx_reg_val , 0 , sizeof ( priv - > drv_rx_reg_val ) ) ;
memset ( priv - > drv_xpu_reg_val , 0 , sizeof ( priv - > drv_xpu_reg_val ) ) ;
2022-03-28 12:55:57 +00:00
memset ( priv - > rf_reg_val , 0 , sizeof ( priv - > rf_reg_val ) ) ;
priv - > drv_xpu_reg_val [ DRV_XPU_REG_IDX_GIT_REV ] = GIT_REV ; */
2020-06-12 08:50:34 +00:00
2019-12-10 13:03:47 +00:00
//turn on radio
2022-03-28 12:49:15 +00:00
openwifi_set_antenna ( dev , priv - > runtime_tx_ant_cfg , priv - > runtime_rx_ant_cfg ) ;
reg = ad9361_get_tx_atten ( priv - > ad9361_phy , ( ( priv - > runtime_tx_ant_cfg = = 1 | | priv - > runtime_tx_ant_cfg = = 3 ) ? 1 : 2 ) ) ;
if ( reg = = ( AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) ) {
2019-12-10 13:03:47 +00:00
priv - > rfkill_off = 1 ; // 0 off, 1 on
printk ( " %s openwifi_start: rfkill radio on \n " , sdr_compatible_str ) ;
}
else
2022-03-28 12:49:15 +00:00
printk ( " %s openwifi_start: WARNING rfkill radio on failed. tx att read %d require %d \n " , sdr_compatible_str , reg , AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) ;
2019-12-10 13:03:47 +00:00
rx_intf_api - > hw_init ( priv - > rx_intf_cfg , 8 , 8 ) ;
2022-01-06 14:07:50 +00:00
tx_intf_api - > hw_init ( priv - > tx_intf_cfg , 8 , 8 , priv - > fpga_type ) ;
2019-12-10 13:03:47 +00:00
openofdm_tx_api - > hw_init ( priv - > openofdm_tx_cfg ) ;
openofdm_rx_api - > hw_init ( priv - > openofdm_rx_cfg ) ;
xpu_api - > hw_init ( priv - > xpu_cfg ) ;
xpu_api - > XPU_REG_MAC_ADDR_write ( priv - > mac_addr ) ;
printk ( " %s openwifi_start: rx_intf_cfg %d openofdm_rx_cfg %d tx_intf_cfg %d openofdm_tx_cfg %d \n " , sdr_compatible_str , priv - > rx_intf_cfg , priv - > openofdm_rx_cfg , priv - > tx_intf_cfg , priv - > openofdm_tx_cfg ) ;
printk ( " %s openwifi_start: rx_freq_offset_to_lo_MHz %d tx_freq_offset_to_lo_MHz %d \n " , sdr_compatible_str , priv - > rx_freq_offset_to_lo_MHz , priv - > tx_freq_offset_to_lo_MHz ) ;
2020-10-08 13:07:57 +00:00
tx_intf_api - > TX_INTF_REG_INTERRUPT_SEL_write ( 0x30004 ) ; //disable tx interrupt
2019-12-10 13:03:47 +00:00
rx_intf_api - > RX_INTF_REG_INTERRUPT_TEST_write ( 0x100 ) ; // disable rx interrupt by interrupt test mode
rx_intf_api - > RX_INTF_REG_M_AXIS_RST_write ( 1 ) ; // hold M AXIS in reset status
priv - > rx_chan = dma_request_slave_channel ( & ( priv - > pdev - > dev ) , " rx_dma_s2mm " ) ;
2021-05-05 14:46:28 +00:00
if ( IS_ERR ( priv - > rx_chan ) | | priv - > rx_chan = = NULL ) {
2019-12-10 13:03:47 +00:00
ret = PTR_ERR ( priv - > rx_chan ) ;
2021-05-05 14:46:28 +00:00
pr_err ( " %s openwifi_start: No Rx channel ret %d priv->rx_chan 0x%p \n " , sdr_compatible_str , ret , priv - > rx_chan ) ;
2019-12-10 13:03:47 +00:00
goto err_dma ;
}
priv - > tx_chan = dma_request_slave_channel ( & ( priv - > pdev - > dev ) , " tx_dma_mm2s " ) ;
2021-05-05 14:46:28 +00:00
if ( IS_ERR ( priv - > tx_chan ) | | priv - > tx_chan = = NULL ) {
2019-12-10 13:03:47 +00:00
ret = PTR_ERR ( priv - > tx_chan ) ;
2021-05-05 14:46:28 +00:00
pr_err ( " %s openwifi_start: No Tx channel ret %d priv->tx_chan 0x%p \n " , sdr_compatible_str , ret , priv - > tx_chan ) ;
2019-12-10 13:03:47 +00:00
goto err_dma ;
}
2021-05-05 14:46:28 +00:00
printk ( " %s openwifi_start: DMA channel setup successfully. priv->rx_chan 0x%p priv->tx_chan 0x%p \n " , sdr_compatible_str , priv - > rx_chan , priv - > tx_chan ) ;
2019-12-10 13:03:47 +00:00
ret = openwifi_init_rx_ring ( priv ) ;
if ( ret ) {
printk ( " %s openwifi_start: openwifi_init_rx_ring ret %d \n " , sdr_compatible_str , ret ) ;
goto err_free_rings ;
}
priv - > seqno = 0 ;
2020-06-12 08:50:34 +00:00
for ( i = 0 ; i < MAX_NUM_SW_QUEUE ; i + + ) {
if ( ( ret = openwifi_init_tx_ring ( priv , i ) ) ) {
printk ( " %s openwifi_start: openwifi_init_tx_ring %d ret %d \n " , sdr_compatible_str , i , ret ) ;
goto err_free_rings ;
}
2019-12-10 13:03:47 +00:00
}
if ( ( ret = rx_dma_setup ( dev ) ) ) {
printk ( " %s openwifi_start: rx_dma_setup ret %d \n " , sdr_compatible_str , ret ) ;
goto err_free_rings ;
}
priv - > irq_rx = irq_of_parse_and_map ( priv - > pdev - > dev . of_node , 1 ) ;
ret = request_irq ( priv - > irq_rx , openwifi_rx_interrupt ,
IRQF_SHARED , " sdr,rx_pkt_intr " , dev ) ;
if ( ret ) {
wiphy_err ( dev - > wiphy , " openwifi_start:failed to register IRQ handler openwifi_rx_interrupt \n " ) ;
goto err_free_rings ;
} else {
printk ( " %s openwifi_start: irq_rx %d \n " , sdr_compatible_str , priv - > irq_rx ) ;
}
priv - > irq_tx = irq_of_parse_and_map ( priv - > pdev - > dev . of_node , 3 ) ;
ret = request_irq ( priv - > irq_tx , openwifi_tx_interrupt ,
2021-05-05 14:53:15 +00:00
IRQF_SHARED , " sdr,tx_itrpt " , dev ) ;
2019-12-10 13:03:47 +00:00
if ( ret ) {
wiphy_err ( dev - > wiphy , " openwifi_start: failed to register IRQ handler openwifi_tx_interrupt \n " ) ;
goto err_free_rings ;
} else {
printk ( " %s openwifi_start: irq_tx %d \n " , sdr_compatible_str , priv - > irq_tx ) ;
}
rx_intf_api - > RX_INTF_REG_INTERRUPT_TEST_write ( 0x000 ) ; // enable rx interrupt get normal fcs valid pass through ddc to ARM
2020-10-08 13:07:57 +00:00
tx_intf_api - > TX_INTF_REG_INTERRUPT_SEL_write ( 0x4 ) ; //enable tx interrupt
2019-12-10 13:03:47 +00:00
rx_intf_api - > RX_INTF_REG_M_AXIS_RST_write ( 0 ) ; // release M AXIS
xpu_api - > XPU_REG_TSF_LOAD_VAL_write ( 0 , 0 ) ; // reset tsf timer
2022-03-29 09:34:57 +00:00
// disable ad9361 auto calibration and enable openwifi fpga spi control
priv - > ad9361_phy - > state - > auto_cal_en = false ; // turn off auto Tx quadrature calib.
priv - > ad9361_phy - > state - > manual_tx_quad_cal_en = true ; // turn on manual Tx quadrature calib.
xpu_api - > XPU_REG_SPI_DISABLE_write ( 0 ) ;
2019-12-10 13:03:47 +00:00
2022-03-28 14:13:42 +00:00
// normal_out:
2019-12-10 13:03:47 +00:00
printk ( " %s openwifi_start: normal end \n " , sdr_compatible_str ) ;
return 0 ;
err_free_rings :
openwifi_free_rx_ring ( priv ) ;
2020-06-12 08:50:34 +00:00
for ( i = 0 ; i < MAX_NUM_SW_QUEUE ; i + + )
openwifi_free_tx_ring ( priv , i ) ;
2019-12-10 13:03:47 +00:00
err_dma :
ret = - 1 ;
printk ( " %s openwifi_start: abnormal end ret %d \n " , sdr_compatible_str , ret ) ;
return ret ;
}
static void openwifi_stop ( struct ieee80211_hw * dev )
{
struct openwifi_priv * priv = dev - > priv ;
u32 reg , reg1 ;
int i ;
2022-03-29 07:56:20 +00:00
// enable ad9361 auto calibration and disable openwifi fpga spi control
priv - > ad9361_phy - > state - > auto_cal_en = true ; // turn on auto Tx quadrature calib.
priv - > ad9361_phy - > state - > manual_tx_quad_cal_en = false ; // turn off manual Tx quadrature calib.
xpu_api - > XPU_REG_SPI_DISABLE_write ( 1 ) ;
2019-12-10 13:03:47 +00:00
//turn off radio
# if 1
ad9361_tx_mute ( priv - > ad9361_phy , 1 ) ;
reg = ad9361_get_tx_atten ( priv - > ad9361_phy , 2 ) ;
reg1 = ad9361_get_tx_atten ( priv - > ad9361_phy , 1 ) ;
if ( reg = = AD9361_RADIO_OFF_TX_ATT & & reg1 = = AD9361_RADIO_OFF_TX_ATT ) {
priv - > rfkill_off = 0 ; // 0 off, 1 on
printk ( " %s openwifi_stop: rfkill radio off \n " , sdr_compatible_str ) ;
}
else
printk ( " %s openwifi_stop: WARNING rfkill radio off failed. tx att read %d %d require %d \n " , sdr_compatible_str , reg , reg1 , AD9361_RADIO_OFF_TX_ATT ) ;
# endif
//ieee80211_stop_queue(dev, 0);
2020-10-08 13:07:57 +00:00
tx_intf_api - > TX_INTF_REG_INTERRUPT_SEL_write ( 0x30004 ) ; //disable tx interrupt
2019-12-10 13:03:47 +00:00
rx_intf_api - > RX_INTF_REG_INTERRUPT_TEST_write ( 0x100 ) ; // disable fcs_valid by interrupt test mode
rx_intf_api - > RX_INTF_REG_M_AXIS_RST_write ( 1 ) ; // hold M AXIS in reset status
for ( i = 0 ; i < MAX_NUM_VIF ; i + + ) {
priv - > vif [ i ] = NULL ;
}
openwifi_free_rx_ring ( priv ) ;
2020-06-12 08:50:34 +00:00
for ( i = 0 ; i < MAX_NUM_SW_QUEUE ; i + + )
openwifi_free_tx_ring ( priv , i ) ;
2019-12-10 13:03:47 +00:00
pr_info ( " %s openwifi_stop: dropped channel %s \n " , sdr_compatible_str , dma_chan_name ( priv - > rx_chan ) ) ;
dmaengine_terminate_all ( priv - > rx_chan ) ;
dma_release_channel ( priv - > rx_chan ) ;
pr_info ( " %s openwifi_stop: dropped channel %s \n " , sdr_compatible_str , dma_chan_name ( priv - > tx_chan ) ) ;
dmaengine_terminate_all ( priv - > tx_chan ) ;
dma_release_channel ( priv - > tx_chan ) ;
//priv->rf->stop(dev);
free_irq ( priv - > irq_rx , dev ) ;
free_irq ( priv - > irq_tx , dev ) ;
2022-03-28 14:13:42 +00:00
// normal_out:
2019-12-10 13:03:47 +00:00
printk ( " %s openwifi_stop \n " , sdr_compatible_str ) ;
}
static u64 openwifi_get_tsf ( struct ieee80211_hw * dev ,
struct ieee80211_vif * vif )
{
u32 tsft_low , tsft_high ;
tsft_low = xpu_api - > XPU_REG_TSF_RUNTIME_VAL_LOW_read ( ) ;
tsft_high = xpu_api - > XPU_REG_TSF_RUNTIME_VAL_HIGH_read ( ) ;
//printk("%s openwifi_get_tsf: %08x%08x\n", sdr_compatible_str,tsft_high,tsft_low);
return ( ( ( u64 ) tsft_low ) | ( ( ( u64 ) tsft_high ) < < 32 ) ) ;
}
static void openwifi_set_tsf ( struct ieee80211_hw * hw , struct ieee80211_vif * vif , u64 tsf )
{
u32 tsft_high = ( ( tsf > > 32 ) & 0xffffffff ) ;
u32 tsft_low = ( tsf & 0xffffffff ) ;
xpu_api - > XPU_REG_TSF_LOAD_VAL_write ( tsft_high , tsft_low ) ;
printk ( " %s openwifi_set_tsf: %08x%08x \n " , sdr_compatible_str , tsft_high , tsft_low ) ;
}
static void openwifi_reset_tsf ( struct ieee80211_hw * hw , struct ieee80211_vif * vif )
{
xpu_api - > XPU_REG_TSF_LOAD_VAL_write ( 0 , 0 ) ;
printk ( " %s openwifi_reset_tsf \n " , sdr_compatible_str ) ;
}
static int openwifi_set_rts_threshold ( struct ieee80211_hw * hw , u32 value )
{
printk ( " %s openwifi_set_rts_threshold WARNING value %d \n " , sdr_compatible_str , value ) ;
return ( 0 ) ;
}
static void openwifi_beacon_work ( struct work_struct * work )
{
struct openwifi_vif * vif_priv =
container_of ( work , struct openwifi_vif , beacon_work . work ) ;
struct ieee80211_vif * vif =
container_of ( ( void * ) vif_priv , struct ieee80211_vif , drv_priv ) ;
struct ieee80211_hw * dev = vif_priv - > dev ;
struct ieee80211_mgmt * mgmt ;
struct sk_buff * skb ;
/* don't overflow the tx ring */
if ( ieee80211_queue_stopped ( dev , 0 ) )
goto resched ;
/* grab a fresh beacon */
skb = ieee80211_beacon_get ( dev , vif ) ;
if ( ! skb )
goto resched ;
/*
* update beacon timestamp w / TSF value
* TODO : make hardware update beacon timestamp
*/
mgmt = ( struct ieee80211_mgmt * ) skb - > data ;
mgmt - > u . beacon . timestamp = cpu_to_le64 ( openwifi_get_tsf ( dev , vif ) ) ;
/* TODO: use actual beacon queue */
skb_set_queue_mapping ( skb , 0 ) ;
openwifi_tx ( dev , NULL , skb ) ;
resched :
/*
* schedule next beacon
* TODO : use hardware support for beacon timing
*/
2022-03-28 14:08:23 +00:00
schedule_delayed_work ( & vif_priv - > beacon_work , usecs_to_jiffies ( 1024 * vif - > bss_conf . beacon_int ) ) ;
// printk("%s openwifi_beacon_work beacon_int %d\n", sdr_compatible_str, vif->bss_conf.beacon_int);
2019-12-10 13:03:47 +00:00
}
static int openwifi_add_interface ( struct ieee80211_hw * dev ,
struct ieee80211_vif * vif )
{
int i ;
struct openwifi_priv * priv = dev - > priv ;
struct openwifi_vif * vif_priv ;
switch ( vif - > type ) {
case NL80211_IFTYPE_AP :
case NL80211_IFTYPE_STATION :
case NL80211_IFTYPE_ADHOC :
case NL80211_IFTYPE_MONITOR :
case NL80211_IFTYPE_MESH_POINT :
break ;
default :
return - EOPNOTSUPP ;
}
// let's support more than 1 interface
for ( i = 0 ; i < MAX_NUM_VIF ; i + + ) {
if ( priv - > vif [ i ] = = NULL )
break ;
}
printk ( " %s openwifi_add_interface start. vif for loop result %d \n " , sdr_compatible_str , i ) ;
if ( i = = MAX_NUM_VIF )
return - EBUSY ;
priv - > vif [ i ] = vif ;
/* Initialize driver private area */
vif_priv = ( struct openwifi_vif * ) & vif - > drv_priv ;
vif_priv - > idx = i ;
vif_priv - > dev = dev ;
INIT_DELAYED_WORK ( & vif_priv - > beacon_work , openwifi_beacon_work ) ;
vif_priv - > enable_beacon = false ;
2022-03-28 14:07:37 +00:00
priv - > mac_addr [ 0 ] = vif - > addr [ 0 ] ;
priv - > mac_addr [ 1 ] = vif - > addr [ 1 ] ;
priv - > mac_addr [ 2 ] = vif - > addr [ 2 ] ;
priv - > mac_addr [ 3 ] = vif - > addr [ 3 ] ;
priv - > mac_addr [ 4 ] = vif - > addr [ 4 ] ;
priv - > mac_addr [ 5 ] = vif - > addr [ 5 ] ;
xpu_api - > XPU_REG_MAC_ADDR_write ( priv - > mac_addr ) ; // set mac addr in fpga
printk ( " %s openwifi_add_interface end with vif idx %d addr %02x:%02x:%02x:%02x:%02x:%02x \n " , sdr_compatible_str , vif_priv - > idx ,
vif - > addr [ 0 ] , vif - > addr [ 1 ] , vif - > addr [ 2 ] , vif - > addr [ 3 ] , vif - > addr [ 4 ] , vif - > addr [ 5 ] ) ;
2019-12-10 13:03:47 +00:00
return 0 ;
}
static void openwifi_remove_interface ( struct ieee80211_hw * dev ,
struct ieee80211_vif * vif )
{
struct openwifi_vif * vif_priv ;
struct openwifi_priv * priv = dev - > priv ;
vif_priv = ( struct openwifi_vif * ) & vif - > drv_priv ;
priv - > vif [ vif_priv - > idx ] = NULL ;
printk ( " %s openwifi_remove_interface vif idx %d \n " , sdr_compatible_str , vif_priv - > idx ) ;
}
static int openwifi_config ( struct ieee80211_hw * dev , u32 changed )
{
struct openwifi_priv * priv = dev - > priv ;
struct ieee80211_conf * conf = & dev - > conf ;
if ( changed & IEEE80211_CONF_CHANGE_CHANNEL )
priv - > rf - > set_chan ( dev , conf ) ;
else
printk ( " %s openwifi_config changed flag %08x \n " , sdr_compatible_str , changed ) ;
return 0 ;
}
static void openwifi_bss_info_changed ( struct ieee80211_hw * dev ,
struct ieee80211_vif * vif ,
struct ieee80211_bss_conf * info ,
u32 changed )
{
struct openwifi_priv * priv = dev - > priv ;
struct openwifi_vif * vif_priv ;
u32 bssid_low , bssid_high ;
vif_priv = ( struct openwifi_vif * ) & vif - > drv_priv ;
//be careful: we don have valid chip, so registers addresses in priv->map->BSSID[0] are not valid! should not print it!
//printk("%s openwifi_bss_info_changed map bssid %02x%02x%02x%02x%02x%02x\n",sdr_compatible_str,priv->map->BSSID[0],priv->map->BSSID[1],priv->map->BSSID[2],priv->map->BSSID[3],priv->map->BSSID[4],priv->map->BSSID[5]);
if ( changed & BSS_CHANGED_BSSID ) {
printk ( " %s openwifi_bss_info_changed BSS_CHANGED_BSSID %02x%02x%02x%02x%02x%02x \n " , sdr_compatible_str , info - > bssid [ 0 ] , info - > bssid [ 1 ] , info - > bssid [ 2 ] , info - > bssid [ 3 ] , info - > bssid [ 4 ] , info - > bssid [ 5 ] ) ;
// write new bssid to our HW, and do not change bssid filter
//u32 bssid_filter_high = xpu_api->XPU_REG_BSSID_FILTER_HIGH_read();
bssid_low = ( * ( ( u32 * ) ( info - > bssid ) ) ) ;
bssid_high = ( * ( ( u16 * ) ( info - > bssid + 4 ) ) ) ;
//bssid_filter_high = (bssid_filter_high&0x80000000);
//bssid_high = (bssid_high|bssid_filter_high);
xpu_api - > XPU_REG_BSSID_FILTER_LOW_write ( bssid_low ) ;
xpu_api - > XPU_REG_BSSID_FILTER_HIGH_write ( bssid_high ) ;
}
if ( changed & BSS_CHANGED_BEACON_INT ) {
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_INT %x \n " , sdr_compatible_str , info - > beacon_int ) ;
}
if ( changed & BSS_CHANGED_TXPOWER )
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_TXPOWER %x \n " , sdr_compatible_str , info - > txpower ) ;
if ( changed & BSS_CHANGED_ERP_CTS_PROT )
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_ERP_CTS_PROT %x \n " , sdr_compatible_str , info - > use_cts_prot ) ;
if ( changed & BSS_CHANGED_BASIC_RATES )
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_BASIC_RATES %x \n " , sdr_compatible_str , info - > basic_rates ) ;
if ( changed & ( BSS_CHANGED_ERP_SLOT | BSS_CHANGED_ERP_PREAMBLE ) ) {
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_ERP_SLOT %d BSS_CHANGED_ERP_PREAMBLE %d short slot %d \n " , sdr_compatible_str ,
changed & BSS_CHANGED_ERP_SLOT , changed & BSS_CHANGED_ERP_PREAMBLE , info - > use_short_slot ) ;
if ( info - > use_short_slot & & priv - > use_short_slot = = false ) {
priv - > use_short_slot = true ;
xpu_api - > XPU_REG_BAND_CHANNEL_write ( ( priv - > use_short_slot < < 24 ) | ( priv - > band < < 16 ) ) ;
} else if ( ( ! info - > use_short_slot ) & & priv - > use_short_slot = = true ) {
priv - > use_short_slot = false ;
xpu_api - > XPU_REG_BAND_CHANNEL_write ( ( priv - > use_short_slot < < 24 ) | ( priv - > band < < 16 ) ) ;
}
}
if ( changed & BSS_CHANGED_BEACON_ENABLED ) {
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_ENABLED \n " , sdr_compatible_str ) ;
vif_priv - > enable_beacon = info - > enable_beacon ;
}
if ( changed & ( BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON ) ) {
cancel_delayed_work_sync ( & vif_priv - > beacon_work ) ;
2022-03-28 14:06:24 +00:00
if ( vif_priv - > enable_beacon ) {
2019-12-10 13:03:47 +00:00
schedule_work ( & vif_priv - > beacon_work . work ) ;
2022-03-28 14:06:24 +00:00
printk ( " %s openwifi_bss_info_changed WARNING enable_beacon \n " , sdr_compatible_str ) ;
}
2019-12-10 13:03:47 +00:00
printk ( " %s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_ENABLED %d BSS_CHANGED_BEACON %d \n " , sdr_compatible_str ,
changed & BSS_CHANGED_BEACON_ENABLED , changed & BSS_CHANGED_BEACON ) ;
}
}
2021-01-28 13:15:29 +00:00
// helper function
u32 log2val ( u32 val ) {
u32 ret_val = 0 ;
while ( val > 1 ) {
val = val > > 1 ;
ret_val + + ;
}
return ret_val ;
}
2019-12-10 13:03:47 +00:00
static int openwifi_conf_tx ( struct ieee80211_hw * hw , struct ieee80211_vif * vif , u16 queue ,
const struct ieee80211_tx_queue_params * params )
{
2021-04-05 19:49:59 +00:00
u32 reg_val , cw_min_exp , cw_max_exp ;
2021-03-22 22:59:41 +00:00
2021-04-05 19:49:59 +00:00
printk ( " %s openwifi_conf_tx: [queue %d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d, aifs and txop ignored \n " ,
2019-12-10 13:03:47 +00:00
sdr_compatible_str , queue , params - > aifs , params - > cw_min , params - > cw_max , params - > txop ) ;
2021-03-22 22:59:41 +00:00
2021-04-05 19:49:59 +00:00
reg_val = xpu_api - > XPU_REG_CSMA_CFG_read ( ) ;
2021-01-28 13:15:29 +00:00
cw_min_exp = ( log2val ( params - > cw_min + 1 ) & 0x0F ) ;
cw_max_exp = ( log2val ( params - > cw_max + 1 ) & 0x0F ) ;
switch ( queue ) {
2021-04-05 19:49:59 +00:00
case 0 : reg_val = ( ( reg_val & 0xFFFFFF00 ) | ( ( cw_min_exp | ( cw_max_exp < < 4 ) ) < < 0 ) ) ; break ;
case 1 : reg_val = ( ( reg_val & 0xFFFF00FF ) | ( ( cw_min_exp | ( cw_max_exp < < 4 ) ) < < 8 ) ) ; break ;
case 2 : reg_val = ( ( reg_val & 0xFF00FFFF ) | ( ( cw_min_exp | ( cw_max_exp < < 4 ) ) < < 16 ) ) ; break ;
case 3 : reg_val = ( ( reg_val & 0x00FFFFFF ) | ( ( cw_min_exp | ( cw_max_exp < < 4 ) ) < < 24 ) ) ; break ;
2021-01-28 13:15:29 +00:00
default : printk ( " %s openwifi_conf_tx: WARNING queue %d does not exist " , sdr_compatible_str , queue ) ; return ( 0 ) ;
}
2021-04-05 19:49:59 +00:00
xpu_api - > XPU_REG_CSMA_CFG_write ( reg_val ) ;
2019-12-10 13:03:47 +00:00
return ( 0 ) ;
2021-09-28 19:52:31 +00:00
}
2019-12-10 13:03:47 +00:00
static u64 openwifi_prepare_multicast ( struct ieee80211_hw * dev ,
struct netdev_hw_addr_list * mc_list )
{
printk ( " %s openwifi_prepare_multicast \n " , sdr_compatible_str ) ;
return netdev_hw_addr_list_count ( mc_list ) ;
}
static void openwifi_configure_filter ( struct ieee80211_hw * dev ,
unsigned int changed_flags ,
unsigned int * total_flags ,
u64 multicast )
{
u32 filter_flag ;
( * total_flags ) & = SDR_SUPPORTED_FILTERS ;
2020-12-14 12:32:15 +00:00
( * total_flags ) | = FIF_ALLMULTI ; //because we need to pass all multicast (no matter it is for us or not) to upper layer
2019-12-10 13:03:47 +00:00
filter_flag = ( * total_flags ) ;
filter_flag = ( filter_flag | UNICAST_FOR_US | BROADCAST_ALL_ONE | BROADCAST_ALL_ZERO ) ;
//filter_flag = (filter_flag|UNICAST_FOR_US|BROADCAST_ALL_ONE|BROADCAST_ALL_ZERO|MONITOR_ALL); // all pkt will be delivered to arm
2020-01-03 17:53:21 +00:00
//if (priv->vif[0]->type == NL80211_IFTYPE_MONITOR)
if ( ( filter_flag & 0xf0 ) = = 0xf0 ) //FIF_BCN_PRBRESP_PROMISC/FIF_CONTROL/FIF_OTHER_BSS/FIF_PSPOLL are set means monitor mode
2019-12-10 13:03:47 +00:00
filter_flag = ( filter_flag | MONITOR_ALL ) ;
2020-01-03 17:53:21 +00:00
else
filter_flag = ( filter_flag & ( ~ MONITOR_ALL ) ) ;
2019-12-10 13:03:47 +00:00
2020-01-03 17:53:21 +00:00
if ( ! ( filter_flag & FIF_BCN_PRBRESP_PROMISC ) )
2019-12-10 13:03:47 +00:00
filter_flag = ( filter_flag | MY_BEACON ) ;
2020-01-03 17:53:21 +00:00
filter_flag = ( filter_flag | FIF_PSPOLL ) ;
2019-12-10 13:03:47 +00:00
xpu_api - > XPU_REG_FILTER_FLAG_write ( filter_flag | HIGH_PRIORITY_DISCARD_FLAG ) ;
//xpu_api->XPU_REG_FILTER_FLAG_write(filter_flag); //do not discard any pkt
printk ( " %s openwifi_configure_filter MON %d M_BCN %d BST0 %d BST1 %d UST %d PB_RQ %d PS_PL %d O_BSS %d CTL %d BCN_PRP %d PCP_FL %d FCS_FL %d ALL_MUT %d \n " , sdr_compatible_str ,
( filter_flag > > 13 ) & 1 , ( filter_flag > > 12 ) & 1 , ( filter_flag > > 11 ) & 1 , ( filter_flag > > 10 ) & 1 , ( filter_flag > > 9 ) & 1 , ( filter_flag > > 8 ) & 1 , ( filter_flag > > 7 ) & 1 , ( filter_flag > > 6 ) & 1 , ( filter_flag > > 5 ) & 1 , ( filter_flag > > 4 ) & 1 , ( filter_flag > > 3 ) & 1 , ( filter_flag > > 2 ) & 1 , ( filter_flag > > 1 ) & 1 ) ;
}
2022-01-06 13:13:24 +00:00
static int openwifi_ampdu_action ( struct ieee80211_hw * hw , struct ieee80211_vif * vif , struct ieee80211_ampdu_params * params )
{
struct ieee80211_sta * sta = params - > sta ;
enum ieee80211_ampdu_mlme_action action = params - > action ;
2022-03-28 12:02:23 +00:00
// struct openwifi_priv *priv = hw->priv;
2022-01-06 14:12:03 +00:00
u16 max_tx_bytes , buf_size ;
2022-01-06 13:42:01 +00:00
u32 ampdu_action_config ;
2022-01-06 13:13:24 +00:00
2022-03-28 13:08:01 +00:00
if ( ! AGGR_ENABLE ) {
return - EOPNOTSUPP ;
}
2022-01-06 13:13:24 +00:00
switch ( action )
{
case IEEE80211_AMPDU_TX_START :
ieee80211_start_tx_ba_cb_irqsafe ( vif , sta - > addr , params - > tid ) ;
2022-03-28 14:00:01 +00:00
printk ( " %s openwifi_ampdu_action: start TX aggregation. tid %d \n " , sdr_compatible_str , params - > tid ) ;
2022-01-06 13:13:24 +00:00
break ;
case IEEE80211_AMPDU_TX_STOP_CONT :
case IEEE80211_AMPDU_TX_STOP_FLUSH :
case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT :
ieee80211_stop_tx_ba_cb_irqsafe ( vif , sta - > addr , params - > tid ) ;
2022-03-28 14:00:01 +00:00
printk ( " %s openwifi_ampdu_action: stop TX aggregation. tid %d \n " , sdr_compatible_str , params - > tid ) ;
2022-01-06 13:13:24 +00:00
break ;
case IEEE80211_AMPDU_TX_OPERATIONAL :
2022-01-06 13:42:01 +00:00
buf_size = 4 ;
// buf_size = (params->buf_size) - 1;
max_tx_bytes = ( 1 < < ( IEEE80211_HT_MAX_AMPDU_FACTOR + sta - > ht_cap . ampdu_factor ) ) - 1 ;
2022-01-06 14:12:03 +00:00
ampdu_action_config = ( sta - > ht_cap . ampdu_density < < 24 | buf_size < < 16 | max_tx_bytes ) ;
2022-01-06 13:42:01 +00:00
tx_intf_api - > TX_INTF_REG_AMPDU_ACTION_CONFIG_write ( ampdu_action_config ) ;
2022-03-28 14:00:01 +00:00
printk ( " %s openwifi_ampdu_action: TX operational. tid %d max_tx_bytes %d ampdu_density %d buf_size %d \n " ,
sdr_compatible_str , params - > tid , max_tx_bytes , sta - > ht_cap . ampdu_density , buf_size ) ;
2022-01-06 13:13:24 +00:00
break ;
case IEEE80211_AMPDU_RX_START :
2022-03-28 12:02:23 +00:00
printk ( " %s openwifi_ampdu_action: start RX aggregation. tid %d \n " , sdr_compatible_str , params - > tid ) ;
2022-01-06 13:13:24 +00:00
break ;
case IEEE80211_AMPDU_RX_STOP :
2022-03-28 12:02:23 +00:00
printk ( " %s openwifi_ampdu_action: stop RX aggregation. tid %d \n " , sdr_compatible_str , params - > tid ) ;
2022-01-06 13:13:24 +00:00
break ;
default :
return - EOPNOTSUPP ;
}
return 0 ;
}
2019-12-10 13:03:47 +00:00
static const struct ieee80211_ops openwifi_ops = {
. tx = openwifi_tx ,
. start = openwifi_start ,
. stop = openwifi_stop ,
. add_interface = openwifi_add_interface ,
. remove_interface = openwifi_remove_interface ,
. config = openwifi_config ,
2022-03-28 13:12:50 +00:00
. set_antenna = openwifi_set_antenna ,
. get_antenna = openwifi_get_antenna ,
2019-12-10 13:03:47 +00:00
. bss_info_changed = openwifi_bss_info_changed ,
. conf_tx = openwifi_conf_tx ,
. prepare_multicast = openwifi_prepare_multicast ,
. configure_filter = openwifi_configure_filter ,
. rfkill_poll = openwifi_rfkill_poll ,
. get_tsf = openwifi_get_tsf ,
. set_tsf = openwifi_set_tsf ,
. reset_tsf = openwifi_reset_tsf ,
. set_rts_threshold = openwifi_set_rts_threshold ,
2022-01-06 13:13:24 +00:00
. ampdu_action = openwifi_ampdu_action ,
2019-12-10 13:03:47 +00:00
. testmode_cmd = openwifi_testmode_cmd ,
} ;
static const struct of_device_id openwifi_dev_of_ids [ ] = {
{ . compatible = " sdr,sdr " , } ,
{ }
} ;
MODULE_DEVICE_TABLE ( of , openwifi_dev_of_ids ) ;
static int custom_match_spi_dev ( struct device * dev , void * data )
{
const char * name = data ;
bool ret = sysfs_streq ( name , dev - > of_node - > name ) ;
printk ( " %s custom_match_spi_dev %s %s %d \n " , sdr_compatible_str , name , dev - > of_node - > name , ret ) ;
return ret ;
}
static int custom_match_platform_dev ( struct device * dev , void * data )
{
struct platform_device * plat_dev = to_platform_device ( dev ) ;
const char * name = data ;
char * name_in_sys_bus_platform_devices = strstr ( plat_dev - > name , name ) ;
bool match_flag = ( name_in_sys_bus_platform_devices ! = NULL ) ;
if ( match_flag ) {
printk ( " %s custom_match_platform_dev %s \n " , sdr_compatible_str , plat_dev - > name ) ;
}
return ( match_flag ) ;
}
static int openwifi_dev_probe ( struct platform_device * pdev )
{
struct ieee80211_hw * dev ;
struct openwifi_priv * priv ;
int err = 1 , rand_val ;
2020-12-29 20:33:36 +00:00
const char * chip_name , * fpga_model ;
2022-03-28 13:27:50 +00:00
u32 reg , i ; //, reg1;
2019-12-10 13:03:47 +00:00
struct device_node * np = pdev - > dev . of_node ;
struct device * tmp_dev ;
struct platform_device * tmp_pdev ;
struct iio_dev * tmp_indio_dev ;
// struct gpio_leds_priv *tmp_led_priv;
printk ( " \n " ) ;
if ( np ) {
const struct of_device_id * match ;
match = of_match_node ( openwifi_dev_of_ids , np ) ;
if ( match ) {
printk ( " %s openwifi_dev_probe: match! \n " , sdr_compatible_str ) ;
err = 0 ;
}
}
if ( err )
return err ;
dev = ieee80211_alloc_hw ( sizeof ( * priv ) , & openwifi_ops ) ;
if ( ! dev ) {
printk ( KERN_ERR " %s openwifi_dev_probe: ieee80211 alloc failed \n " , sdr_compatible_str ) ;
err = - ENOMEM ;
goto err_free_dev ;
}
priv = dev - > priv ;
priv - > pdev = pdev ;
2020-12-29 20:33:36 +00:00
err = of_property_read_string ( of_find_node_by_path ( " / " ) , " model " , & fpga_model ) ;
if ( err < 0 ) {
printk ( " %s openwifi_dev_probe: WARNING unknown openwifi FPGA model %d \n " , sdr_compatible_str , err ) ;
priv - > fpga_type = SMALL_FPGA ;
} else {
// LARGE FPGAs (i.e. ZCU102, Z7035, ZC706)
if ( strstr ( fpga_model , " ZCU102 " ) ! = NULL | | strstr ( fpga_model , " Z7035 " ) ! = NULL | | strstr ( fpga_model , " ZC706 " ) ! = NULL )
priv - > fpga_type = LARGE_FPGA ;
// SMALL FPGA: (i.e. ZED, ZC702, Z7020)
else if ( strstr ( fpga_model , " ZED " ) ! = NULL | | strstr ( fpga_model , " ZC702 " ) ! = NULL | | strstr ( fpga_model , " Z7020 " ) ! = NULL )
priv - > fpga_type = SMALL_FPGA ;
}
2019-12-10 13:03:47 +00:00
// //-------------find ad9361-phy driver for lo/channel control---------------
2022-03-28 13:20:03 +00:00
priv - > actual_rx_lo = 1000 ; //Some value aligned with rf_init/rf_init_11n.sh that is not WiFi channel to force ad9361_rf_set_channel execution triggered by Linux
priv - > actual_tx_lo = 1000 ; //Some value aligned with rf_init/rf_init_11n.sh that is not WiFi channel to force ad9361_rf_set_channel execution triggered by Linux
2022-03-29 07:56:20 +00:00
priv - > last_tx_quad_cal_lo = 1000 ;
2019-12-10 13:03:47 +00:00
tmp_dev = bus_find_device ( & spi_bus_type , NULL , " ad9361-phy " , custom_match_spi_dev ) ;
2020-04-27 07:37:04 +00:00
if ( tmp_dev = = NULL ) {
2019-12-10 13:03:47 +00:00
printk ( KERN_ERR " %s find_dev ad9361-phy failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
2020-04-27 07:37:04 +00:00
printk ( " %s bus_find_device ad9361-phy: %s. driver_data pointer %p \n " , sdr_compatible_str , ( ( struct spi_device * ) tmp_dev ) - > modalias , ( void * ) ( ( ( struct spi_device * ) tmp_dev ) - > dev . driver_data ) ) ;
if ( ( ( struct spi_device * ) tmp_dev ) - > dev . driver_data = = NULL ) {
printk ( KERN_ERR " %s find_dev ad9361-phy failed. dev.driver_data == NULL \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2020-04-27 07:37:04 +00:00
goto err_free_dev ;
}
2019-12-10 13:03:47 +00:00
priv - > ad9361_phy = ad9361_spi_to_phy ( ( struct spi_device * ) tmp_dev ) ;
if ( ! ( priv - > ad9361_phy ) ) {
printk ( KERN_ERR " %s ad9361_spi_to_phy failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
2020-03-04 18:39:12 +00:00
printk ( " %s ad9361_spi_to_phy ad9361-phy: %s \n " , sdr_compatible_str , priv - > ad9361_phy - > spi - > modalias ) ;
2019-12-10 13:03:47 +00:00
// //-------------find driver: axi_ad9361 hdl ref design module, dac channel---------------
tmp_dev = bus_find_device ( & platform_bus_type , NULL , " cf-ad9361-dds-core-lpc " , custom_match_platform_dev ) ;
if ( ! tmp_dev ) {
printk ( KERN_ERR " %s bus_find_device platform_bus_type cf-ad9361-dds-core-lpc failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
tmp_pdev = to_platform_device ( tmp_dev ) ;
if ( ! tmp_pdev ) {
printk ( KERN_ERR " %s to_platform_device failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
tmp_indio_dev = platform_get_drvdata ( tmp_pdev ) ;
if ( ! tmp_indio_dev ) {
printk ( KERN_ERR " %s platform_get_drvdata failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
priv - > dds_st = iio_priv ( tmp_indio_dev ) ;
if ( ! ( priv - > dds_st ) ) {
printk ( KERN_ERR " %s iio_priv failed \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - ENODEV ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
}
printk ( " %s openwifi_dev_probe: cf-ad9361-dds-core-lpc dds_st->version %08x chip_info->name %s \n " , sdr_compatible_str , priv - > dds_st - > version , priv - > dds_st - > chip_info - > name ) ;
cf_axi_dds_datasel ( priv - > dds_st , - 1 , DATA_SEL_DMA ) ;
printk ( " %s openwifi_dev_probe: cf_axi_dds_datasel DATA_SEL_DMA \n " , sdr_compatible_str ) ;
// //-------------find driver: axi_ad9361 hdl ref design module, adc channel---------------
// turn off radio by muting tx
// ad9361_tx_mute(priv->ad9361_phy, 1);
// reg = ad9361_get_tx_atten(priv->ad9361_phy, 2);
// reg1 = ad9361_get_tx_atten(priv->ad9361_phy, 1);
// if (reg == AD9361_RADIO_OFF_TX_ATT && reg1 == AD9361_RADIO_OFF_TX_ATT ) {
// priv->rfkill_off = 0;// 0 off, 1 on
// printk("%s openwifi_dev_probe: rfkill radio off\n",sdr_compatible_str);
// }
// else
// printk("%s openwifi_dev_probe: WARNING rfkill radio off failed. tx att read %d %d require %d\n",sdr_compatible_str, reg, reg1, AD9361_RADIO_OFF_TX_ATT);
2022-03-28 13:08:01 +00:00
// //-----------------------------parse the test_mode input--------------------------------
if ( test_mode & 1 )
AGGR_ENABLE = true ;
2019-12-10 13:03:47 +00:00
2022-03-28 13:08:01 +00:00
// if (test_mode&2)
// TX_OFFSET_TUNING_ENABLE = false;
2022-03-28 13:23:53 +00:00
priv - > rssi_correction = rssi_correction_lookup_table ( 5220 ) ; //5220MHz. this will be set in real-time by _rf_set_channel()
priv - > last_auto_fpga_lbt_th = rssi_dbm_to_rssi_half_db ( - 78 , priv - > rssi_correction ) ; //-78dBm. a magic value. just to avoid uninitialized
2019-12-10 13:03:47 +00:00
//priv->rf_bw = 20000000; // Signal quality issue! NOT use for now. 20MHz or 40MHz. 40MHz need ddc/duc. 20MHz works in bypass mode
priv - > rf_bw = 40000000 ; // 20MHz or 40MHz. 40MHz need ddc/duc. 20MHz works in bypass mode
priv - > xpu_cfg = XPU_NORMAL ;
priv - > openofdm_tx_cfg = OPENOFDM_TX_NORMAL ;
priv - > openofdm_rx_cfg = OPENOFDM_RX_NORMAL ;
printk ( " %s openwifi_dev_probe: priv->rf_bw == %dHz. bool for 20000000 %d, 40000000 %d \n " , sdr_compatible_str , priv - > rf_bw , ( priv - > rf_bw = = 20000000 ) , ( priv - > rf_bw = = 40000000 ) ) ;
2022-03-28 13:25:20 +00:00
if ( priv - > rf_bw = = 20000000 ) { //DO NOT USE. Not used for long time.
2019-12-10 13:03:47 +00:00
priv - > rx_intf_cfg = RX_INTF_BYPASS ;
priv - > tx_intf_cfg = TX_INTF_BYPASS ;
//priv->rx_freq_offset_to_lo_MHz = 0;
//priv->tx_freq_offset_to_lo_MHz = 0;
} else if ( priv - > rf_bw = = 40000000 ) {
//priv->rx_intf_cfg = RX_INTF_BW_20MHZ_AT_P_10MHZ; //work
//priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT1; //work
// // test ddc at central, duc at central+10M. It works. And also change rx BW from 40MHz to 20MHz in rf_init.sh. Rx sampling rate is still 40Msps
priv - > rx_intf_cfg = RX_INTF_BW_20MHZ_AT_0MHZ_ANT0 ;
2022-03-28 13:25:20 +00:00
if ( TX_OFFSET_TUNING_ENABLE )
priv - > tx_intf_cfg = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0 ; // Let's use rx0 tx0 as default mode, because it works for both 9361 and 9364
else
priv - > tx_intf_cfg = TX_INTF_BW_20MHZ_AT_0MHZ_ANT0 ;
2019-12-10 13:03:47 +00:00
// // try another antenna option
//priv->rx_intf_cfg = RX_INTF_BW_20MHZ_AT_0MHZ_ANT1;
//priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0;
#if 0
if ( priv - > rx_intf_cfg = = DDC_BW_20MHZ_AT_N_10MHZ ) {
priv - > rx_freq_offset_to_lo_MHz = - 10 ;
} else if ( priv - > rx_intf_cfg = = DDC_BW_20MHZ_AT_P_10MHZ ) {
priv - > rx_freq_offset_to_lo_MHz = 10 ;
} else if ( priv - > rx_intf_cfg = = DDC_BW_20MHZ_AT_0MHZ ) {
priv - > rx_freq_offset_to_lo_MHz = 0 ;
} else {
printk ( " %s openwifi_dev_probe: Warning! priv->rx_intf_cfg == %d \n " , sdr_compatible_str , priv - > rx_intf_cfg ) ;
}
# endif
} else {
printk ( " %s openwifi_dev_probe: Warning! priv->rf_bw == %dHz (should be 20000000 or 40000000) \n " , sdr_compatible_str , priv - > rf_bw ) ;
2022-03-28 13:17:12 +00:00
err = - EBADRQC ;
goto err_free_dev ;
2019-12-10 13:03:47 +00:00
}
2022-03-28 12:49:15 +00:00
2022-03-28 13:08:01 +00:00
printk ( " %s openwifi_dev_probe: test_mode %d AGGR_ENABLE %d TX_OFFSET_TUNING_ENABLE %d init_tx_att %d \n " , sdr_compatible_str , test_mode , AGGR_ENABLE , TX_OFFSET_TUNING_ENABLE , init_tx_att ) ;
2019-12-10 13:03:47 +00:00
2022-03-28 12:49:15 +00:00
priv - > runtime_tx_ant_cfg = ( ( priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_0MHZ_ANT0 | | priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0 ) ? 1 : ( priv - > tx_intf_cfg = = TX_INTF_BW_20MHZ_AT_0MHZ_ANT_BOTH ? 3 : 2 ) ) ;
priv - > runtime_rx_ant_cfg = ( priv - > rx_intf_cfg = = RX_INTF_BW_20MHZ_AT_0MHZ_ANT0 ? 1 : 2 ) ;
priv - > ctrl_out . en_mask = AD9361_CTRL_OUT_EN_MASK ;
priv - > ctrl_out . index = ( priv - > rx_intf_cfg = = RX_INTF_BW_20MHZ_AT_0MHZ_ANT0 ? AD9361_CTRL_OUT_INDEX_ANT0 : AD9361_CTRL_OUT_INDEX_ANT1 ) ;
2022-03-28 12:55:57 +00:00
memset ( priv - > drv_rx_reg_val , 0 , sizeof ( priv - > drv_rx_reg_val ) ) ;
memset ( priv - > drv_tx_reg_val , 0 , sizeof ( priv - > drv_tx_reg_val ) ) ;
memset ( priv - > drv_xpu_reg_val , 0 , sizeof ( priv - > drv_xpu_reg_val ) ) ;
memset ( priv - > rf_reg_val , 0 , sizeof ( priv - > rf_reg_val ) ) ;
2022-03-28 13:08:01 +00:00
priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] = init_tx_att ;
2019-12-10 13:03:47 +00:00
//let's by default turn radio on when probing
2022-03-28 12:49:15 +00:00
err = openwifi_set_antenna ( dev , priv - > runtime_tx_ant_cfg , priv - > runtime_rx_ant_cfg ) ;
if ( err ) {
printk ( " %s openwifi_dev_probe: WARNING openwifi_set_antenna FAIL %d \n " , sdr_compatible_str , err ) ;
err = - EIO ;
goto err_free_dev ;
2019-12-10 13:03:47 +00:00
}
2022-03-28 12:49:15 +00:00
reg = ad9361_spi_read ( priv - > ad9361_phy - > spi , REG_CTRL_OUTPUT_POINTER ) ;
printk ( " %s openwifi_dev_probe: ad9361_spi_read REG_CTRL_OUTPUT_POINTER 0x%02x \n " , sdr_compatible_str , reg ) ;
reg = ad9361_spi_read ( priv - > ad9361_phy - > spi , REG_CTRL_OUTPUT_ENABLE ) ;
printk ( " %s openwifi_dev_probe: ad9361_spi_read REG_CTRL_OUTPUT_ENABLE 0x%02x \n " , sdr_compatible_str , reg ) ;
reg = ad9361_get_tx_atten ( priv - > ad9361_phy , ( ( priv - > runtime_tx_ant_cfg = = 1 | | priv - > runtime_tx_ant_cfg = = 3 ) ? 1 : 2 ) ) ;
if ( reg = = ( AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) ) {
2019-12-10 13:03:47 +00:00
priv - > rfkill_off = 1 ; // 0 off, 1 on
printk ( " %s openwifi_dev_probe: rfkill radio on \n " , sdr_compatible_str ) ;
2021-09-28 19:52:31 +00:00
} else
2022-03-28 12:49:15 +00:00
printk ( " %s openwifi_dev_probe: WARNING rfkill radio on failed. tx att read %d require %d \n " , sdr_compatible_str , reg , AD9361_RADIO_ON_TX_ATT + priv - > rf_reg_val [ RF_TX_REG_IDX_ATT ] ) ;
2021-09-28 19:52:31 +00:00
2022-03-28 12:55:57 +00:00
priv - > drv_xpu_reg_val [ DRV_XPU_REG_IDX_GIT_REV ] = GIT_REV ;
2019-12-10 13:03:47 +00:00
// //set ad9361 in certain mode
#if 0
err = ad9361_set_trx_clock_chain_freq ( priv - > ad9361_phy , priv - > rf_bw ) ;
printk ( " %s openwifi_dev_probe: ad9361_set_trx_clock_chain_freq %dHz err %d \n " , sdr_compatible_str , priv - > rf_bw , err ) ;
err = ad9361_update_rf_bandwidth ( priv - > ad9361_phy , priv - > rf_bw , priv - > rf_bw ) ;
printk ( " %s openwifi_dev_probe: ad9361_update_rf_bandwidth %dHz err %d \n " , sdr_compatible_str , priv - > rf_bw , err ) ;
rx_intf_api - > hw_init ( priv - > rx_intf_cfg , 8 , 8 ) ;
2022-01-06 14:07:50 +00:00
tx_intf_api - > hw_init ( priv - > tx_intf_cfg , 8 , 8 , priv - > fpga_type ) ;
2019-12-10 13:03:47 +00:00
openofdm_tx_api - > hw_init ( priv - > openofdm_tx_cfg ) ;
openofdm_rx_api - > hw_init ( priv - > openofdm_rx_cfg ) ;
printk ( " %s openwifi_dev_probe: rx_intf_cfg %d openofdm_rx_cfg %d tx_intf_cfg %d openofdm_tx_cfg %d \n " , sdr_compatible_str , priv - > rx_intf_cfg , priv - > openofdm_rx_cfg , priv - > tx_intf_cfg , priv - > openofdm_tx_cfg ) ;
printk ( " %s openwifi_dev_probe: rx_freq_offset_to_lo_MHz %d tx_freq_offset_to_lo_MHz %d \n " , sdr_compatible_str , priv - > rx_freq_offset_to_lo_MHz , priv - > tx_freq_offset_to_lo_MHz ) ;
# endif
dev - > max_rates = 1 ; //maximum number of alternate rate retry stages the hw can handle.
SET_IEEE80211_DEV ( dev , & pdev - > dev ) ;
platform_set_drvdata ( pdev , dev ) ;
BUILD_BUG_ON ( sizeof ( priv - > rates_2GHz ) ! = sizeof ( openwifi_2GHz_rates ) ) ;
BUILD_BUG_ON ( sizeof ( priv - > rates_5GHz ) ! = sizeof ( openwifi_5GHz_rates ) ) ;
BUILD_BUG_ON ( sizeof ( priv - > channels_2GHz ) ! = sizeof ( openwifi_2GHz_channels ) ) ;
BUILD_BUG_ON ( sizeof ( priv - > channels_5GHz ) ! = sizeof ( openwifi_5GHz_channels ) ) ;
memcpy ( priv - > rates_2GHz , openwifi_2GHz_rates , sizeof ( openwifi_2GHz_rates ) ) ;
memcpy ( priv - > rates_5GHz , openwifi_5GHz_rates , sizeof ( openwifi_5GHz_rates ) ) ;
memcpy ( priv - > channels_2GHz , openwifi_2GHz_channels , sizeof ( openwifi_2GHz_channels ) ) ;
memcpy ( priv - > channels_5GHz , openwifi_5GHz_channels , sizeof ( openwifi_5GHz_channels ) ) ;
priv - > band = BAND_5_8GHZ ; //this can be changed by band _rf_set_channel() (2.4GHz ERP(OFDM)) (5GHz OFDM)
priv - > channel = 44 ; //currently useless. this can be changed by band _rf_set_channel()
priv - > use_short_slot = false ; //this can be changed by openwifi_bss_info_changed: BSS_CHANGED_ERP_SLOT
2022-01-06 13:13:24 +00:00
priv - > ampdu_reference = 0 ;
2019-12-10 13:03:47 +00:00
priv - > band_2GHz . band = NL80211_BAND_2GHZ ;
priv - > band_2GHz . channels = priv - > channels_2GHz ;
priv - > band_2GHz . n_channels = ARRAY_SIZE ( priv - > channels_2GHz ) ;
priv - > band_2GHz . bitrates = priv - > rates_2GHz ;
priv - > band_2GHz . n_bitrates = ARRAY_SIZE ( priv - > rates_2GHz ) ;
2020-11-05 17:22:24 +00:00
priv - > band_2GHz . ht_cap . ht_supported = true ;
2022-03-28 13:14:55 +00:00
// priv->band_2GHz.ht_cap.cap = IEEE80211_HT_CAP_SGI_20; //SGI -- short GI seems bring unnecessary stability issue
2022-03-28 13:08:01 +00:00
if ( AGGR_ENABLE ) {
priv - > band_2GHz . ht_cap . ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K ;
priv - > band_2GHz . ht_cap . ampdu_density = IEEE80211_HT_MPDU_DENSITY_2 ;
}
2020-11-05 17:22:24 +00:00
memset ( & priv - > band_2GHz . ht_cap . mcs , 0 , sizeof ( priv - > band_2GHz . ht_cap . mcs ) ) ;
priv - > band_2GHz . ht_cap . mcs . rx_mask [ 0 ] = 0xff ;
priv - > band_2GHz . ht_cap . mcs . tx_params = IEEE80211_HT_MCS_TX_DEFINED ;
2019-12-10 13:03:47 +00:00
dev - > wiphy - > bands [ NL80211_BAND_2GHZ ] = & ( priv - > band_2GHz ) ;
priv - > band_5GHz . band = NL80211_BAND_5GHZ ;
priv - > band_5GHz . channels = priv - > channels_5GHz ;
priv - > band_5GHz . n_channels = ARRAY_SIZE ( priv - > channels_5GHz ) ;
priv - > band_5GHz . bitrates = priv - > rates_5GHz ;
priv - > band_5GHz . n_bitrates = ARRAY_SIZE ( priv - > rates_5GHz ) ;
2020-11-05 17:22:24 +00:00
priv - > band_5GHz . ht_cap . ht_supported = true ;
2022-03-28 13:14:55 +00:00
// priv->band_5GHz.ht_cap.cap = IEEE80211_HT_CAP_SGI_20; //SGI -- short GI seems bring unnecessary stability issue
2022-03-28 13:08:01 +00:00
if ( AGGR_ENABLE ) {
priv - > band_5GHz . ht_cap . ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K ;
priv - > band_5GHz . ht_cap . ampdu_density = IEEE80211_HT_MPDU_DENSITY_2 ;
}
2020-11-05 17:22:24 +00:00
memset ( & priv - > band_5GHz . ht_cap . mcs , 0 , sizeof ( priv - > band_5GHz . ht_cap . mcs ) ) ;
priv - > band_5GHz . ht_cap . mcs . rx_mask [ 0 ] = 0xff ;
priv - > band_5GHz . ht_cap . mcs . tx_params = IEEE80211_HT_MCS_TX_DEFINED ;
2019-12-10 13:03:47 +00:00
dev - > wiphy - > bands [ NL80211_BAND_5GHZ ] = & ( priv - > band_5GHz ) ;
printk ( " %s openwifi_dev_probe: band_2GHz.n_channels %d n_bitrates %d band_5GHz.n_channels %d n_bitrates %d \n " , sdr_compatible_str ,
priv - > band_2GHz . n_channels , priv - > band_2GHz . n_bitrates , priv - > band_5GHz . n_channels , priv - > band_5GHz . n_bitrates ) ;
2022-03-28 13:26:35 +00:00
// ieee80211_hw_set(dev, HOST_BROADCAST_PS_BUFFERING); // remove this because we don't want: mac80211.h: host buffers frame for PS and we fetch them via ieee80211_get_buffered_bc()
2019-12-10 13:03:47 +00:00
ieee80211_hw_set ( dev , RX_INCLUDES_FCS ) ;
2022-03-28 13:26:35 +00:00
ieee80211_hw_set ( dev , BEACON_TX_STATUS ) ; //mac80211.h: The device/driver provides TX status for sent beacons.
ieee80211_hw_set ( dev , REPORTS_TX_ACK_STATUS ) ; //mac80211.h: Hardware can provide ack status reports of Tx frames to the stack
// * @IEEE80211_HW_AP_LINK_PS: When operating in AP mode the device
// * autonomously manages the PS status of connected stations. When
// * this flag is set mac80211 will not trigger PS mode for connected
// * stations based on the PM bit of incoming frames.
// * Use ieee80211_start_ps()/ieee8021_end_ps() to manually configure
// * the PS mode of connected stations.
ieee80211_hw_set ( dev , AP_LINK_PS ) ;
2022-03-28 13:08:01 +00:00
if ( AGGR_ENABLE ) {
ieee80211_hw_set ( dev , AMPDU_AGGREGATION ) ;
}
2022-03-28 13:27:07 +00:00
dev - > extra_tx_headroom = LEN_MPDU_DELIM ;
2019-12-10 13:03:47 +00:00
dev - > vif_data_size = sizeof ( struct openwifi_vif ) ;
dev - > wiphy - > interface_modes =
BIT ( NL80211_IFTYPE_MONITOR ) |
BIT ( NL80211_IFTYPE_P2P_GO ) |
BIT ( NL80211_IFTYPE_P2P_CLIENT ) |
BIT ( NL80211_IFTYPE_AP ) |
BIT ( NL80211_IFTYPE_STATION ) |
BIT ( NL80211_IFTYPE_ADHOC ) |
BIT ( NL80211_IFTYPE_MESH_POINT ) |
BIT ( NL80211_IFTYPE_OCB ) ;
dev - > wiphy - > iface_combinations = & openwifi_if_comb ;
dev - > wiphy - > n_iface_combinations = 1 ;
2022-03-28 12:49:15 +00:00
dev - > wiphy - > available_antennas_tx = NUM_TX_ANT_MASK ;
dev - > wiphy - > available_antennas_rx = NUM_RX_ANT_MASK ;
2019-12-10 13:03:47 +00:00
dev - > wiphy - > regulatory_flags = ( REGULATORY_STRICT_REG | REGULATORY_CUSTOM_REG ) ; // use our own config within strict regulation
//dev->wiphy->regulatory_flags = REGULATORY_CUSTOM_REG; // use our own config
wiphy_apply_custom_regulatory ( dev - > wiphy , & sdr_regd ) ;
chip_name = " ZYNQ " ;
/* we declare to MAC80211 all the queues except for beacon queue
* that will be eventually handled by DRV .
* TX rings are arranged in such a way that lower is the IDX ,
* higher is the priority , in order to achieve direct mapping
* with mac80211 , however the beacon queue is an exception and it
* is mapped on the highst tx ring IDX .
*/
2020-06-12 08:50:34 +00:00
dev - > queues = MAX_NUM_HW_QUEUE ;
//dev->queues = 1;
2019-12-10 13:03:47 +00:00
ieee80211_hw_set ( dev , SIGNAL_DBM ) ;
wiphy_ext_feature_set ( dev - > wiphy , NL80211_EXT_FEATURE_CQM_RSSI_LIST ) ;
priv - > rf = & ad9361_rf_ops ;
memset ( priv - > dest_mac_addr_queue_map , 0 , sizeof ( priv - > dest_mac_addr_queue_map ) ) ;
2020-06-12 08:50:34 +00:00
priv - > slice_idx = 0xFFFFFFFF ;
sg_init_table ( & ( priv - > tx_sg ) , 1 ) ;
2019-12-10 13:03:47 +00:00
get_random_bytes ( & rand_val , sizeof ( rand_val ) ) ;
rand_val % = 250 ;
priv - > mac_addr [ 0 ] = 0x66 ; priv - > mac_addr [ 1 ] = 0x55 ; priv - > mac_addr [ 2 ] = 0x44 ; priv - > mac_addr [ 3 ] = 0x33 ; priv - > mac_addr [ 4 ] = 0x22 ;
priv - > mac_addr [ 5 ] = rand_val + 1 ;
//priv->mac_addr[5]=0x11;
if ( ! is_valid_ether_addr ( priv - > mac_addr ) ) {
printk ( KERN_WARNING " %s openwifi_dev_probe: WARNING Invalid hwaddr! Using randomly generated MAC addr \n " , sdr_compatible_str ) ;
eth_random_addr ( priv - > mac_addr ) ;
}
2022-03-28 13:17:12 +00:00
printk ( " %s openwifi_dev_probe: mac_addr %02x:%02x:%02x:%02x:%02x:%02x \n " , sdr_compatible_str , priv - > mac_addr [ 0 ] , priv - > mac_addr [ 1 ] , priv - > mac_addr [ 2 ] , priv - > mac_addr [ 3 ] , priv - > mac_addr [ 4 ] , priv - > mac_addr [ 5 ] ) ;
2019-12-10 13:03:47 +00:00
SET_IEEE80211_PERM_ADDR ( dev , priv - > mac_addr ) ;
spin_lock_init ( & priv - > lock ) ;
err = ieee80211_register_hw ( dev ) ;
if ( err ) {
pr_err ( KERN_ERR " %s openwifi_dev_probe: WARNING Cannot register device \n " , sdr_compatible_str ) ;
2022-03-28 13:17:12 +00:00
err = - EIO ;
2019-12-10 13:03:47 +00:00
goto err_free_dev ;
} else {
printk ( " %s openwifi_dev_probe: ieee80211_register_hw %d \n " , sdr_compatible_str , err ) ;
}
// // //--------------------hook leds (not complete yet)--------------------------------
2021-02-04 08:54:47 +00:00
// tmp_dev = bus_find_device( &platform_bus_type, NULL, "leds", custom_match_platform_dev ); //leds is the name in devicetree, not "compatible" field
2019-12-10 13:03:47 +00:00
// if (!tmp_dev) {
// printk(KERN_ERR "%s bus_find_device platform_bus_type leds-gpio failed\n",sdr_compatible_str);
// err = -ENOMEM;
// goto err_free_dev;
// }
// tmp_pdev = to_platform_device(tmp_dev);
// if (!tmp_pdev) {
// printk(KERN_ERR "%s to_platform_device failed for leds-gpio\n",sdr_compatible_str);
// err = -ENOMEM;
// goto err_free_dev;
// }
// tmp_led_priv = platform_get_drvdata(tmp_pdev);
// if (!tmp_led_priv) {
// printk(KERN_ERR "%s platform_get_drvdata failed for leds-gpio\n",sdr_compatible_str);
// err = -ENOMEM;
// goto err_free_dev;
// }
// printk("%s openwifi_dev_probe: leds-gpio detect %d leds!\n",sdr_compatible_str, tmp_led_priv->num_leds);
// if (tmp_led_priv->num_leds!=4){
// printk(KERN_ERR "%s WARNING we expect 4 leds, but actual %d leds\n",sdr_compatible_str,tmp_led_priv->num_leds);
// err = -ENOMEM;
// goto err_free_dev;
// }
// gpiod_set_value(tmp_led_priv->leds[0].gpiod, 1);//light it
// gpiod_set_value(tmp_led_priv->leds[3].gpiod, 0);//black it
// priv->num_led = tmp_led_priv->num_leds;
// priv->led[0] = &(tmp_led_priv->leds[0].cdev);
// priv->led[1] = &(tmp_led_priv->leds[1].cdev);
// priv->led[2] = &(tmp_led_priv->leds[2].cdev);
// priv->led[3] = &(tmp_led_priv->leds[3].cdev);
// snprintf(priv->led_name[0], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::radio", wiphy_name(dev->wiphy));
// snprintf(priv->led_name[1], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::assoc", wiphy_name(dev->wiphy));
// snprintf(priv->led_name[2], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::tx", wiphy_name(dev->wiphy));
// snprintf(priv->led_name[3], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::rx", wiphy_name(dev->wiphy));
wiphy_info ( dev - > wiphy , " hwaddr %pm, %s + %s \n " ,
priv - > mac_addr , chip_name , priv - > rf - > name ) ;
openwifi_rfkill_init ( dev ) ;
return 0 ;
err_free_dev :
ieee80211_free_hw ( dev ) ;
return err ;
}
static int openwifi_dev_remove ( struct platform_device * pdev )
{
struct ieee80211_hw * dev = platform_get_drvdata ( pdev ) ;
if ( ! dev ) {
2020-04-27 07:37:04 +00:00
pr_info ( " %s openwifi_dev_remove: dev %p \n " , sdr_compatible_str , ( void * ) dev ) ;
2019-12-10 13:03:47 +00:00
return ( - 1 ) ;
}
openwifi_rfkill_exit ( dev ) ;
ieee80211_unregister_hw ( dev ) ;
ieee80211_free_hw ( dev ) ;
return ( 0 ) ;
}
static struct platform_driver openwifi_dev_driver = {
. driver = {
. name = " sdr,sdr " ,
. owner = THIS_MODULE ,
. of_match_table = openwifi_dev_of_ids ,
} ,
. probe = openwifi_dev_probe ,
. remove = openwifi_dev_remove ,
} ;
module_platform_driver ( openwifi_dev_driver ) ;