1 // Author: Xianjun Jiao, Michael Mehari, Wei Liu, Jetmir Haxhibeqiri, Pablo Avila Campos 2 // SPDX-FileCopyrightText: 2022 UGent 3 // SPDX-License-Identifier: AGPL-3.0-or-later 4 5 #include <linux/bitops.h> 6 #include <linux/dmapool.h> 7 #include <linux/io.h> 8 #include <linux/iopoll.h> 9 #include <linux/of_address.h> 10 #include <linux/of_platform.h> 11 #include <linux/of_irq.h> 12 #include <linux/slab.h> 13 #include <linux/clk.h> 14 #include <linux/io-64-nonatomic-lo-hi.h> 15 16 #include <linux/delay.h> 17 #include <linux/interrupt.h> 18 19 #include <linux/dmaengine.h> 20 #include <linux/slab.h> 21 #include <linux/delay.h> 22 #include <linux/etherdevice.h> 23 24 #include <linux/init.h> 25 #include <linux/kthread.h> 26 #include <linux/module.h> 27 #include <linux/of_dma.h> 28 #include <linux/platform_device.h> 29 #include <linux/random.h> 30 #include <linux/slab.h> 31 #include <linux/wait.h> 32 #include <linux/sched/task.h> 33 #include <linux/dma/xilinx_dma.h> 34 #include <linux/spi/spi.h> 35 #include <net/mac80211.h> 36 37 #include <linux/clk.h> 38 #include <linux/clkdev.h> 39 #include <linux/clk-provider.h> 40 41 #include <linux/iio/iio.h> 42 #include <linux/iio/sysfs.h> 43 44 #include <linux/gpio.h> 45 #include <linux/leds.h> 46 47 #define IIO_AD9361_USE_PRIVATE_H_ 48 #include <../../drivers/iio/adc/ad9361_regs.h> 49 #include <../../drivers/iio/adc/ad9361.h> 50 #include <../../drivers/iio/adc/ad9361_private.h> 51 52 #include <../../drivers/iio/frequency/cf_axi_dds.h> 53 extern int ad9361_get_tx_atten(struct ad9361_rf_phy *phy, u32 tx_num); 54 extern int ad9361_set_tx_atten(struct ad9361_rf_phy *phy, u32 atten_mdb, 55 bool tx1, bool tx2, bool immed); 56 extern int ad9361_ctrl_outs_setup(struct ad9361_rf_phy *phy, 57 struct ctrl_outs_control *ctrl); 58 59 #include "../user_space/sdrctl_src/nl80211_testmode_def.h" 60 #include "hw_def.h" 61 #include "sdr.h" 62 #include "git_rev.h" 63 64 // driver API of component driver 65 extern struct tx_intf_driver_api *tx_intf_api; 66 extern struct rx_intf_driver_api *rx_intf_api; 67 extern struct openofdm_tx_driver_api *openofdm_tx_api; 68 extern struct openofdm_rx_driver_api *openofdm_rx_api; 69 extern struct xpu_driver_api *xpu_api; 70 71 u32 gen_mpdu_crc(u8 *data_in, u32 num_bytes); 72 u8 gen_mpdu_delim_crc(u16 m); 73 u32 reverse32(u32 d); 74 static int openwifi_set_antenna(struct ieee80211_hw *dev, u32 tx_ant, u32 rx_ant); 75 static int openwifi_get_antenna(struct ieee80211_hw *dev, u32 *tx_ant, u32 *rx_ant); 76 int rssi_half_db_to_rssi_dbm(int rssi_half_db, int rssi_correction); 77 int rssi_dbm_to_rssi_half_db(int rssi_dbm, int rssi_correction); 78 int rssi_correction_lookup_table(u32 freq_MHz); 79 80 #include "sdrctl_intf.c" 81 #include "sysfs_intf.c" 82 83 static int test_mode = 0; // bit0: aggregation enable(1)/disable(0); NO USE ANY MORE: bit1: tx offset tuning enable(0)/disable(1) 84 // Internal indication variables after parsing test_mode 85 static bool AGGR_ENABLE = false; 86 static bool TX_OFFSET_TUNING_ENABLE = false; 87 88 static int init_tx_att = 0; 89 90 MODULE_AUTHOR("Xianjun Jiao"); 91 MODULE_DESCRIPTION("SDR driver"); 92 MODULE_LICENSE("GPL v2"); 93 94 module_param(test_mode, int, 0); 95 MODULE_PARM_DESC(myint, "test_mode. bit0: aggregation enable(1)/disable(0)"); 96 97 module_param(init_tx_att, int, 0); 98 MODULE_PARM_DESC(myint, "init_tx_att. TX attenuation in dB*1000 example: set to 3000 for 3dB attenuation"); 99 100 // ---------------rfkill--------------------------------------- 101 static bool openwifi_is_radio_enabled(struct openwifi_priv *priv) 102 { 103 int reg; 104 105 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) 106 reg = ad9361_get_tx_atten(priv->ad9361_phy, 1); 107 else 108 reg = ad9361_get_tx_atten(priv->ad9361_phy, 2); 109 110 if (reg == (AD9361_RADIO_ON_TX_ATT+priv->rf_reg_val[RF_TX_REG_IDX_ATT])) 111 return true;// 0 off, 1 on 112 return false; 113 } 114 115 void openwifi_rfkill_init(struct ieee80211_hw *hw) 116 { 117 struct openwifi_priv *priv = hw->priv; 118 119 priv->rfkill_off = openwifi_is_radio_enabled(priv); 120 printk("%s openwifi_rfkill_init: wireless switch is %s\n", sdr_compatible_str, priv->rfkill_off ? "on" : "off"); 121 wiphy_rfkill_set_hw_state(hw->wiphy, !priv->rfkill_off); 122 wiphy_rfkill_start_polling(hw->wiphy); 123 } 124 125 void openwifi_rfkill_poll(struct ieee80211_hw *hw) 126 { 127 bool enabled; 128 struct openwifi_priv *priv = hw->priv; 129 130 enabled = openwifi_is_radio_enabled(priv); 131 // printk("%s openwifi_rfkill_poll: wireless radio switch turned %s\n", sdr_compatible_str, enabled ? "on" : "off"); 132 if (unlikely(enabled != priv->rfkill_off)) { 133 priv->rfkill_off = enabled; 134 printk("%s openwifi_rfkill_poll: WARNING wireless radio switch turned %s\n", sdr_compatible_str, enabled ? "on" : "off"); 135 wiphy_rfkill_set_hw_state(hw->wiphy, !enabled); 136 } 137 } 138 139 void openwifi_rfkill_exit(struct ieee80211_hw *hw) 140 { 141 printk("%s openwifi_rfkill_exit\n", sdr_compatible_str); 142 wiphy_rfkill_stop_polling(hw->wiphy); 143 } 144 //----------------rfkill end----------------------------------- 145 146 inline int rssi_dbm_to_rssi_half_db(int rssi_dbm, int rssi_correction) 147 { 148 return ((rssi_correction+rssi_dbm)<<1); 149 } 150 151 inline int rssi_correction_lookup_table(u32 freq_MHz) 152 { 153 int rssi_correction; 154 155 if (freq_MHz<2412) { 156 rssi_correction = 153; 157 } else if (freq_MHz<=2484) { 158 rssi_correction = 153; 159 } else if (freq_MHz<5160) { 160 rssi_correction = 153; 161 } else if (freq_MHz<=5240) { 162 rssi_correction = 145; 163 } else if (freq_MHz<=5320) { 164 rssi_correction = 148; 165 } else { 166 rssi_correction = 148; 167 } 168 169 return rssi_correction; 170 } 171 172 static void ad9361_rf_set_channel(struct ieee80211_hw *dev, 173 struct ieee80211_conf *conf) 174 { 175 struct openwifi_priv *priv = dev->priv; 176 u32 actual_rx_lo = conf->chandef.chan->center_freq - priv->rx_freq_offset_to_lo_MHz; 177 u32 actual_tx_lo; 178 bool change_flag = (actual_rx_lo != priv->actual_rx_lo); 179 int static_lbt_th, auto_lbt_th, fpga_lbt_th, receiver_rssi_dbm_th; 180 181 if (change_flag) { 182 actual_tx_lo = conf->chandef.chan->center_freq - priv->tx_freq_offset_to_lo_MHz; 183 184 // -------------------Tx Lo tuning------------------- 185 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) ); 186 priv->actual_tx_lo = actual_tx_lo; 187 188 // -------------------Rx Lo tuning------------------- 189 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) ); 190 priv->actual_rx_lo = actual_rx_lo; 191 192 // get rssi correction value from lookup table 193 priv->rssi_correction = rssi_correction_lookup_table(actual_rx_lo); 194 195 // set appropriate lbt threshold 196 // xpu_api->XPU_REG_LBT_TH_write((priv->rssi_correction-62)<<1); // -62dBm 197 // xpu_api->XPU_REG_LBT_TH_write((priv->rssi_correction-62-16)<<1); // wei's magic value is 135, here is 134 @ ch 44 198 // auto_lbt_th = ((priv->rssi_correction-62-16)<<1); 199 auto_lbt_th = rssi_dbm_to_rssi_half_db(-78, priv->rssi_correction); // -78dBm, the same as above ((priv->rssi_correction-62-16)<<1) 200 static_lbt_th = rssi_dbm_to_rssi_half_db(-(priv->drv_xpu_reg_val[DRV_XPU_REG_IDX_LBT_TH]), priv->rssi_correction); 201 fpga_lbt_th = (priv->drv_xpu_reg_val[DRV_XPU_REG_IDX_LBT_TH]==0?auto_lbt_th:static_lbt_th); 202 xpu_api->XPU_REG_LBT_TH_write(fpga_lbt_th); 203 priv->last_auto_fpga_lbt_th = auto_lbt_th; 204 205 // 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) 206 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])); 207 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)); 208 209 if (actual_rx_lo < 2500) { 210 if (priv->band != BAND_2_4GHZ) { 211 priv->band = BAND_2_4GHZ; 212 xpu_api->XPU_REG_BAND_CHANNEL_write( (priv->use_short_slot<<24)|(priv->band<<16) ); 213 } 214 } else { 215 if (priv->band != BAND_5_8GHZ) { 216 priv->band = BAND_5_8GHZ; 217 xpu_api->XPU_REG_BAND_CHANNEL_write( (priv->use_short_slot<<24)|(priv->band<<16) ); 218 } 219 } 220 printk("%s ad9361_rf_set_channel %dM rssi_correction %d (change flag %d) fpga_lbt_th %d(%ddBm) (auto %d static %d)\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); 221 } 222 } 223 224 const struct openwifi_rf_ops ad9361_rf_ops = { 225 .name = "ad9361", 226 // .init = ad9361_rf_init, 227 // .stop = ad9361_rf_stop, 228 .set_chan = ad9361_rf_set_channel, 229 // .calc_rssi = ad9361_rf_calc_rssi, 230 }; 231 232 u16 reverse16(u16 d) { 233 union u16_byte2 tmp0, tmp1; 234 tmp0.a = d; 235 tmp1.c[0] = tmp0.c[1]; 236 tmp1.c[1] = tmp0.c[0]; 237 return(tmp1.a); 238 } 239 240 u32 reverse32(u32 d) { 241 union u32_byte4 tmp0, tmp1; 242 tmp0.a = d; 243 tmp1.c[0] = tmp0.c[3]; 244 tmp1.c[1] = tmp0.c[2]; 245 tmp1.c[2] = tmp0.c[1]; 246 tmp1.c[3] = tmp0.c[0]; 247 return(tmp1.a); 248 } 249 250 static int openwifi_init_tx_ring(struct openwifi_priv *priv, int ring_idx) 251 { 252 struct openwifi_ring *ring = &(priv->tx_ring[ring_idx]); 253 int i; 254 255 ring->stop_flag = 0; 256 ring->bd_wr_idx = 0; 257 ring->bd_rd_idx = 0; 258 ring->bds = kmalloc(sizeof(struct openwifi_buffer_descriptor)*NUM_TX_BD,GFP_KERNEL); 259 if (ring->bds==NULL) { 260 printk("%s openwifi_init_tx_ring: WARNING Cannot allocate TX ring\n",sdr_compatible_str); 261 return -ENOMEM; 262 } 263 264 for (i = 0; i < NUM_TX_BD; i++) { 265 ring->bds[i].skb_linked=0; // for tx, skb is from upper layer 266 //at first right after skb allocated, head, data, tail are the same. 267 ring->bds[i].dma_mapping_addr = 0; // for tx, mapping is done after skb is received from upper layer in tx routine 268 ring->bds[i].seq_no = 0; 269 } 270 271 return 0; 272 } 273 274 static void openwifi_free_tx_ring(struct openwifi_priv *priv, int ring_idx) 275 { 276 struct openwifi_ring *ring = &(priv->tx_ring[ring_idx]); 277 int i; 278 279 ring->stop_flag = 0; 280 ring->bd_wr_idx = 0; 281 ring->bd_rd_idx = 0; 282 for (i = 0; i < NUM_TX_BD; i++) { 283 if (ring->bds[i].skb_linked == 0 && ring->bds[i].dma_mapping_addr == 0) 284 continue; 285 if (ring->bds[i].dma_mapping_addr != 0) 286 dma_unmap_single(priv->tx_chan->device->dev, ring->bds[i].dma_mapping_addr,ring->bds[i].skb_linked->len, DMA_MEM_TO_DEV); 287 // if (ring->bds[i].skb_linked!=NULL) 288 // dev_kfree_skb(ring->bds[i].skb_linked); // only use dev_kfree_skb when there is exception 289 if ( (ring->bds[i].dma_mapping_addr != 0 && ring->bds[i].skb_linked == 0) || 290 (ring->bds[i].dma_mapping_addr == 0 && ring->bds[i].skb_linked != 0)) 291 printk("%s openwifi_free_tx_ring: WARNING ring %d i %d skb_linked %p dma_mapping_addr %08x\n", sdr_compatible_str, 292 ring_idx, i, (void*)(ring->bds[i].skb_linked), (unsigned int)(ring->bds[i].dma_mapping_addr)); 293 294 ring->bds[i].skb_linked=0; 295 ring->bds[i].dma_mapping_addr = 0; 296 ring->bds[i].seq_no = 0; 297 } 298 if (ring->bds) 299 kfree(ring->bds); 300 ring->bds = NULL; 301 } 302 303 static int openwifi_init_rx_ring(struct openwifi_priv *priv) 304 { 305 int i; 306 u8 *pdata_tmp; 307 308 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); 309 if (!priv->rx_cyclic_buf) { 310 printk("%s openwifi_init_rx_ring: WARNING dma_alloc_coherent failed!\n", sdr_compatible_str); 311 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); 312 return(-1); 313 } 314 315 // Set tsft_low and tsft_high to 0. If they are not zero, it means there is a packet in the buffer by DMA 316 for (i=0; i<NUM_RX_BD; i++) { 317 pdata_tmp = priv->rx_cyclic_buf + i*RX_BD_BUF_SIZE; // our header insertion is at the beginning 318 (*((u32*)(pdata_tmp+0 ))) = 0; 319 (*((u32*)(pdata_tmp+4 ))) = 0; 320 } 321 printk("%s openwifi_init_rx_ring: tsft_low and tsft_high are cleared!\n", sdr_compatible_str); 322 323 return 0; 324 } 325 326 static void openwifi_free_rx_ring(struct openwifi_priv *priv) 327 { 328 if (priv->rx_cyclic_buf) 329 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); 330 331 priv->rx_cyclic_buf_dma_mapping_addr = 0; 332 priv->rx_cyclic_buf = 0; 333 } 334 335 static int rx_dma_setup(struct ieee80211_hw *dev){ 336 struct openwifi_priv *priv = dev->priv; 337 struct dma_device *rx_dev = priv->rx_chan->device; 338 339 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); 340 if (!(priv->rxd)) { 341 openwifi_free_rx_ring(priv); 342 printk("%s rx_dma_setup: WARNING rx_dev->device_prep_dma_cyclic %p\n", sdr_compatible_str, (void*)(priv->rxd)); 343 return(-1); 344 } 345 priv->rxd->callback = 0; 346 priv->rxd->callback_param = 0; 347 348 priv->rx_cookie = priv->rxd->tx_submit(priv->rxd); 349 350 if (dma_submit_error(priv->rx_cookie)) { 351 printk("%s rx_dma_setup: WARNING dma_submit_error(rx_cookie) %d\n", sdr_compatible_str, (u32)(priv->rx_cookie)); 352 return(-1); 353 } 354 355 dma_async_issue_pending(priv->rx_chan); 356 return(0); 357 } 358 359 inline int rssi_half_db_to_rssi_dbm(int rssi_half_db, int rssi_correction) 360 { 361 int rssi_db, rssi_dbm; 362 363 rssi_db = (rssi_half_db>>1); 364 365 rssi_dbm = rssi_db - rssi_correction; 366 367 rssi_dbm = (rssi_dbm < (-128)? (-128) : rssi_dbm); 368 369 return rssi_dbm; 370 } 371 372 static irqreturn_t openwifi_rx_interrupt(int irq, void *dev_id) 373 { 374 struct ieee80211_hw *dev = dev_id; 375 struct openwifi_priv *priv = dev->priv; 376 struct ieee80211_rx_status rx_status = {0}; 377 struct sk_buff *skb; 378 struct ieee80211_hdr *hdr; 379 u32 addr1_low32=0, addr2_low32=0, addr3_low32=0, len, rate_idx, tsft_low, tsft_high, loop_count=0;//, fc_di; 380 bool ht_flag, short_gi, ht_aggr, ht_aggr_last; 381 // u32 dma_driver_buf_idx_mod; 382 u8 *pdata_tmp, fcs_ok;//, target_buf_idx;//, phy_rx_sn_hw; 383 s8 signal; 384 u16 agc_status_and_pkt_exist_flag, rssi_val, addr1_high16=0, addr2_high16=0, addr3_high16=0, sc=0; 385 bool content_ok = false, len_overflow = false; 386 387 #ifdef USE_NEW_RX_INTERRUPT 388 int i; 389 spin_lock(&priv->lock); 390 for (i=0; i<NUM_RX_BD; i++) { 391 pdata_tmp = priv->rx_cyclic_buf + i*RX_BD_BUF_SIZE; 392 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 393 if ( agc_status_and_pkt_exist_flag==0 ) // no packet in the buffer 394 continue; 395 #else 396 static u8 target_buf_idx_old = 0; 397 spin_lock(&priv->lock); 398 while(1) { // loop all rx buffers that have new rx packets 399 pdata_tmp = priv->rx_cyclic_buf + target_buf_idx_old*RX_BD_BUF_SIZE; // our header insertion is at the beginning 400 agc_status_and_pkt_exist_flag = (*((u16*)(pdata_tmp+10))); 401 if ( agc_status_and_pkt_exist_flag==0 ) // no packet in the buffer 402 break; 403 #endif 404 405 tsft_low = (*((u32*)(pdata_tmp+0 ))); 406 tsft_high = (*((u32*)(pdata_tmp+4 ))); 407 rssi_val = (*((u16*)(pdata_tmp+8 ))); 408 len = (*((u16*)(pdata_tmp+12))); 409 410 len_overflow = (len>(RX_BD_BUF_SIZE-16)?true:false); 411 412 rate_idx = (*((u16*)(pdata_tmp+14))); 413 ht_flag = ((rate_idx&0x10)!=0); 414 short_gi = ((rate_idx&0x20)!=0); 415 ht_aggr = (ht_flag & ((rate_idx&0x40)!=0)); 416 ht_aggr_last = (ht_flag & ((rate_idx&0x80)!=0)); 417 rate_idx = (rate_idx&0x1F); 418 419 fcs_ok = ( len_overflow?0:(*(( u8*)(pdata_tmp+16+len-1))) ); 420 421 //phy_rx_sn_hw = (fcs_ok&(NUM_RX_BD-1)); 422 // phy_rx_sn_hw = (fcs_ok&0x7f);//0x7f is FPGA limitation 423 // dma_driver_buf_idx_mod = (state.residue&0x7f); 424 fcs_ok = ((fcs_ok&0x80)!=0); 425 426 if ( (len>=14 && (!len_overflow)) && (rate_idx>=8 && rate_idx<=23)) { 427 // if ( phy_rx_sn_hw!=dma_driver_buf_idx_mod) { 428 // printk("%s openwifi_rx_interrupt: WARNING sn %d next buf_idx %d!\n", sdr_compatible_str,phy_rx_sn_hw,dma_driver_buf_idx_mod); 429 // } 430 content_ok = true; 431 } else { 432 printk("%s openwifi_rx_interrupt: WARNING content!\n", sdr_compatible_str); 433 content_ok = false; 434 } 435 436 rssi_val = (rssi_val>>1); 437 if ( (rssi_val+128)<priv->rssi_correction ) 438 signal = -128; 439 else 440 signal = rssi_val - priv->rssi_correction; 441 442 // fc_di = (*((u32*)(pdata_tmp+16))); 443 // addr1_high16 = (*((u16*)(pdata_tmp+16+4))); 444 // addr1_low32 = (*((u32*)(pdata_tmp+16+4+2))); 445 // addr2_high16 = (*((u16*)(pdata_tmp+16+6+4))); 446 // addr2_low32 = (*((u32*)(pdata_tmp+16+6+4+2))); 447 // addr3_high16 = (*((u16*)(pdata_tmp+16+12+4))); 448 // addr3_low32 = (*((u32*)(pdata_tmp+16+12+4+2))); 449 if ( (priv->drv_rx_reg_val[DRV_RX_REG_IDX_PRINT_CFG]&2) || ( (priv->drv_rx_reg_val[DRV_RX_REG_IDX_PRINT_CFG]&1) && fcs_ok==0 ) ) { 450 hdr = (struct ieee80211_hdr *)(pdata_tmp+16); 451 addr1_low32 = *((u32*)(hdr->addr1+2)); 452 addr1_high16 = *((u16*)(hdr->addr1)); 453 if (len>=20) { 454 addr2_low32 = *((u32*)(hdr->addr2+2)); 455 addr2_high16 = *((u16*)(hdr->addr2)); 456 } 457 if (len>=26) { 458 addr3_low32 = *((u32*)(hdr->addr3+2)); 459 addr3_high16 = *((u16*)(hdr->addr3)); 460 } 461 if (len>=28) 462 sc = hdr->seq_ctrl; 463 464 if ( (addr1_low32!=0xffffffff || addr1_high16!=0xffff) || (priv->drv_rx_reg_val[DRV_RX_REG_IDX_PRINT_CFG]&4) ) 465 printk("%s openwifi_rx_interrupt:%4dbytes ht%d aggr%d/%d sgi%d %3dM FC%04x DI%04x addr1/2/3:%04x%08x/%04x%08x/%04x%08x SC%04x fcs%d buf_idx%d %ddBm\n", sdr_compatible_str, 466 len, ht_flag, ht_aggr, ht_aggr_last, short_gi, wifi_rate_table[rate_idx], hdr->frame_control, hdr->duration_id, 467 reverse16(addr1_high16), reverse32(addr1_low32), reverse16(addr2_high16), reverse32(addr2_low32), reverse16(addr3_high16), reverse32(addr3_low32), 468 #ifdef USE_NEW_RX_INTERRUPT 469 sc, fcs_ok, i, signal); 470 #else 471 sc, fcs_ok, target_buf_idx_old, signal); 472 #endif 473 } 474 475 // priv->phy_rx_sn_hw_old = phy_rx_sn_hw; 476 if (content_ok) { 477 skb = dev_alloc_skb(len); 478 if (skb) { 479 skb_put_data(skb,pdata_tmp+16,len); 480 481 rx_status.antenna = priv->runtime_rx_ant_cfg; 482 // def in ieee80211_rate openwifi_rates 0~11. 0~3 11b(1M~11M), 4~11 11a/g(6M~54M) 483 rx_status.rate_idx = wifi_rate_table_mapping[rate_idx]; 484 rx_status.signal = signal; 485 rx_status.freq = dev->conf.chandef.chan->center_freq; 486 rx_status.band = dev->conf.chandef.chan->band; 487 rx_status.mactime = ( ( (u64)tsft_low ) | ( ((u64)tsft_high)<<32 ) ); 488 rx_status.flag |= RX_FLAG_MACTIME_START; 489 if (!fcs_ok) 490 rx_status.flag |= RX_FLAG_FAILED_FCS_CRC; 491 if (rate_idx <= 15) 492 rx_status.encoding = RX_ENC_LEGACY; 493 else 494 rx_status.encoding = RX_ENC_HT; 495 rx_status.bw = RATE_INFO_BW_20; 496 if (short_gi) 497 rx_status.enc_flags |= RX_ENC_FLAG_SHORT_GI; 498 if(ht_aggr) 499 { 500 rx_status.ampdu_reference = priv->ampdu_reference; 501 rx_status.flag |= RX_FLAG_AMPDU_DETAILS | RX_FLAG_AMPDU_LAST_KNOWN; 502 if (ht_aggr_last) 503 rx_status.flag |= RX_FLAG_AMPDU_IS_LAST; 504 } 505 506 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. 507 ieee80211_rx_irqsafe(dev, skb); // call mac80211 function 508 } else 509 printk("%s openwifi_rx_interrupt: WARNING dev_alloc_skb failed!\n", sdr_compatible_str); 510 511 if(ht_aggr_last) 512 priv->ampdu_reference++; 513 } 514 (*((u16*)(pdata_tmp+10))) = 0; // clear the field (set by rx_intf_pl_to_m_axis.v) to indicate the packet has been processed 515 loop_count++; 516 #ifndef USE_NEW_RX_INTERRUPT 517 target_buf_idx_old=((target_buf_idx_old+1)&(NUM_RX_BD-1)); 518 #endif 519 } 520 521 if ( loop_count!=1 && (priv->drv_rx_reg_val[DRV_RX_REG_IDX_PRINT_CFG]&1) ) 522 printk("%s openwifi_rx_interrupt: WARNING loop_count %d\n", sdr_compatible_str,loop_count); 523 524 // openwifi_rx_interrupt_out: 525 spin_unlock(&priv->lock); 526 return IRQ_HANDLED; 527 } 528 529 static irqreturn_t openwifi_tx_interrupt(int irq, void *dev_id) 530 { 531 struct ieee80211_hw *dev = dev_id; 532 struct openwifi_priv *priv = dev->priv; 533 struct openwifi_ring *ring; 534 struct sk_buff *skb; 535 struct ieee80211_tx_info *info; 536 u32 reg_val1, hw_queue_len, reg_val2, prio, queue_idx, dma_fifo_no_room_flag, num_slot_random, cw, loop_count=0; 537 u16 seq_no, pkt_cnt, blk_ack_ssn, start_idx; 538 u8 nof_retx=-1, last_bd_rd_idx, i; 539 u64 blk_ack_bitmap; 540 // u16 prio_rd_idx_store[64]={0}; 541 bool tx_fail=false; 542 543 spin_lock(&priv->lock); 544 545 while(1) { // loop all packets that have been sent by FPGA 546 reg_val1 = tx_intf_api->TX_INTF_REG_PKT_INFO1_read(); 547 reg_val2 = tx_intf_api->TX_INTF_REG_PKT_INFO2_read(); 548 blk_ack_bitmap = (tx_intf_api->TX_INTF_REG_PKT_INFO3_read() | ((u64)tx_intf_api->TX_INTF_REG_PKT_INFO4_read())<<32); 549 550 if (reg_val1!=0xFFFFFFFF) { 551 nof_retx = (reg_val1&0xF); 552 last_bd_rd_idx = ((reg_val1>>5)&(NUM_TX_BD-1)); 553 prio = ((reg_val1>>17)&0x3); 554 num_slot_random = ((reg_val1>>19)&0x1FF); 555 //num_slot_random = ((0xFF80000 ®_val1)>>(2+5+NUM_BIT_MAX_PHY_TX_SN+NUM_BIT_MAX_NUM_HW_QUEUE)); 556 cw = ((reg_val1>>28)&0xF); 557 //cw = ((0xF0000000 & reg_val1) >> 28); 558 if(cw > 10) { 559 cw = 10 ; 560 num_slot_random += 512 ; 561 } 562 pkt_cnt = (reg_val2&0x3F); 563 blk_ack_ssn = ((reg_val2>>6)&0xFFF); 564 565 ring = &(priv->tx_ring[prio]); 566 567 if ( ring->stop_flag == 1) { 568 // Wake up Linux queue if FPGA and driver ring have room 569 queue_idx = ((reg_val1>>15)&(MAX_NUM_HW_QUEUE-1)); 570 dma_fifo_no_room_flag = tx_intf_api->TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read(); 571 hw_queue_len = tx_intf_api->TX_INTF_REG_QUEUE_FIFO_DATA_COUNT_read(); 572 573 if ( ((dma_fifo_no_room_flag>>queue_idx)&1)==0 && (NUM_TX_BD-((hw_queue_len>>(queue_idx*8))&0xFF))>=RING_ROOM_THRESHOLD ) { 574 // printk("%s openwifi_tx_interrupt: WARNING ieee80211_wake_queue loop %d call %d\n", sdr_compatible_str, loop_count, priv->call_counter); 575 printk("%s openwifi_tx_interrupt: WARNING ieee80211_wake_queue prio %d queue %d no room flag %x hw queue len %08x wr %d rd %d\n", sdr_compatible_str, 576 prio, queue_idx, dma_fifo_no_room_flag, hw_queue_len, ring->bd_wr_idx, last_bd_rd_idx); 577 ieee80211_wake_queue(dev, prio); 578 ring->stop_flag = 0; 579 } 580 } 581 582 for(i = 1; i <= pkt_cnt; i++) 583 { 584 ring->bd_rd_idx = (last_bd_rd_idx + i - pkt_cnt + 64)%64; 585 seq_no = ring->bds[ring->bd_rd_idx].seq_no; 586 skb = ring->bds[ring->bd_rd_idx].skb_linked; 587 588 dma_unmap_single(priv->tx_chan->device->dev,ring->bds[ring->bd_rd_idx].dma_mapping_addr, 589 skb->len, DMA_MEM_TO_DEV); 590 591 info = IEEE80211_SKB_CB(skb); 592 ieee80211_tx_info_clear_status(info); 593 594 // Aggregation packet 595 if(pkt_cnt > 1) 596 { 597 start_idx = (seq_no>=blk_ack_ssn) ? (seq_no-blk_ack_ssn) : (seq_no+((~blk_ack_ssn+1)&0x0FFF)); 598 tx_fail = (((blk_ack_bitmap>>start_idx)&0x1)==0); 599 info->flags |= IEEE80211_TX_STAT_AMPDU; 600 info->status.ampdu_len = 1; 601 info->status.ampdu_ack_len = (tx_fail == true) ? 0 : 1; 602 603 skb_pull(skb, LEN_MPDU_DELIM); 604 //skb_trim(skb, num_byte_pad_skb); 605 } 606 // Normal packet 607 else 608 { 609 tx_fail = ((blk_ack_bitmap&0x1)==0); 610 info->flags &= (~IEEE80211_TX_CTL_AMPDU); 611 } 612 613 if (tx_fail == false) 614 info->flags |= IEEE80211_TX_STAT_ACK; 615 616 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 617 info->status.rates[1].idx = -1; 618 info->status.rates[2].idx = -1; 619 info->status.rates[3].idx = -1;//in mac80211.h: #define IEEE80211_TX_MAX_RATES 4 620 info->status.antenna = priv->runtime_tx_ant_cfg; 621 622 if ( tx_fail && ((priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG])&1) ) 623 printk("%s openwifi_tx_interrupt: WARNING pkt_no %d/%d tx_result [nof_retx %d pass %d] prio%d wr%d rd%d\n", sdr_compatible_str, i, pkt_cnt, nof_retx+1, !tx_fail, prio, ring->bd_wr_idx, ring->bd_rd_idx); 624 if ( ( (!(info->flags & IEEE80211_TX_CTL_NO_ACK))||(priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG]&4) ) && ((priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG])&2) ) 625 printk("%s openwifi_tx_interrupt: tx_result [nof_retx %d pass %d] prio%d wr%d rd%d num_rand_slot %d cw %d \n", sdr_compatible_str, nof_retx+1, !tx_fail, prio, ring->bd_wr_idx, ring->bd_rd_idx, num_slot_random, cw); 626 627 ieee80211_tx_status_irqsafe(dev, skb); 628 } 629 630 loop_count++; 631 632 // printk("%s openwifi_tx_interrupt: loop %d prio %d rd %d\n", sdr_compatible_str, loop_count, prio, ring->bd_rd_idx); 633 634 } else 635 break; 636 } 637 if ( loop_count!=1 && ((priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG])&1) ) 638 printk("%s openwifi_tx_interrupt: WARNING loop_count %d\n", sdr_compatible_str, loop_count); 639 640 spin_unlock(&priv->lock); 641 return IRQ_HANDLED; 642 } 643 644 u32 crc_table[16] = {0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0, 0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320, 0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190, 0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000}; 645 u32 gen_mpdu_crc(u8 *data_in, u32 num_bytes) 646 { 647 u32 i, crc = 0; 648 u8 idx; 649 for( i = 0; i < num_bytes; i++) 650 { 651 idx = (crc & 0x0F) ^ (data_in[i] & 0x0F); 652 crc = (crc >> 4) ^ crc_table[idx]; 653 654 idx = (crc & 0x0F) ^ ((data_in[i] >> 4) & 0x0F); 655 crc = (crc >> 4) ^ crc_table[idx]; 656 } 657 658 return crc; 659 } 660 661 u8 gen_mpdu_delim_crc(u16 m) 662 { 663 u8 i, temp, c[8] = {1, 1, 1, 1, 1, 1, 1, 1}, mpdu_delim_crc; 664 665 for (i = 0; i < 16; i++) 666 { 667 temp = c[7] ^ ((m >> i) & 0x01); 668 669 c[7] = c[6]; 670 c[6] = c[5]; 671 c[5] = c[4]; 672 c[4] = c[3]; 673 c[3] = c[2]; 674 c[2] = c[1] ^ temp; 675 c[1] = c[0] ^ temp; 676 c[0] = temp; 677 } 678 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); 679 680 return mpdu_delim_crc; 681 } 682 683 static inline struct gpio_led_data * //please align with the implementation in leds-gpio.c 684 cdev_to_gpio_led_data(struct led_classdev *led_cdev) 685 { 686 return container_of(led_cdev, struct gpio_led_data, cdev); 687 } 688 689 static void openwifi_tx(struct ieee80211_hw *dev, 690 struct ieee80211_tx_control *control, 691 struct sk_buff *skb) 692 { 693 struct openwifi_priv *priv = dev->priv; 694 unsigned long flags; 695 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 696 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 697 struct openwifi_ring *ring = NULL; 698 dma_addr_t dma_mapping_addr; 699 unsigned int prio=0, i; 700 u32 num_dma_symbol, len_mpdu = 0, len_mpdu_delim_pad = 0, num_dma_byte, len_psdu, num_byte_pad; 701 u32 rate_signal_value,rate_hw_value=0,ack_flag; 702 u32 pkt_need_ack=0, addr1_low32=0, addr2_low32=0, addr3_low32=0, queue_idx=2, tx_config, cts_reg, phy_hdr_config;//, openofdm_state_history; 703 u16 addr1_high16=0, addr2_high16=0, addr3_high16=0, sc=0, cts_duration=0, cts_rate_hw_value=0, cts_rate_signal_value=0, sifs, ack_duration=0, traffic_pkt_duration; 704 u8 fc_flag,fc_type,fc_subtype,retry_limit_raw=0,use_short_gi=0,*dma_buf,retry_limit_hw_value,rc_flags,*qos_hdr; 705 bool use_rts_cts, use_cts_protect=false, ht_aggr_start=false, use_ht_rate=false, use_ht_aggr=false, addr_flag, cts_use_traffic_rate=false, force_use_cts_protect=false; 706 __le16 frame_control,duration_id; 707 u32 dma_fifo_no_room_flag, hw_queue_len; 708 enum dma_status status; 709 710 static u32 addr1_low32_prev = -1, rate_hw_value_prev = -1, pkt_need_ack_prev = -1; 711 static u16 addr1_high16_prev = -1; 712 static __le16 duration_id_prev = -1; 713 static unsigned int prio_prev = -1; 714 static u8 retry_limit_raw_prev = -1; 715 static u8 use_short_gi_prev = -1; 716 717 // static bool led_status=0; 718 // struct gpio_led_data *led_dat = cdev_to_gpio_led_data(priv->led[3]); 719 720 // if ( (priv->phy_tx_sn&7) ==0 ) { 721 // openofdm_state_history = openofdm_rx_api->OPENOFDM_RX_REG_STATE_HISTORY_read(); 722 // if (openofdm_state_history!=openofdm_state_history_old){ 723 // led_status = (~led_status); 724 // openofdm_state_history_old = openofdm_state_history; 725 // gpiod_set_value(led_dat->gpiod, led_status); 726 // } 727 // } 728 729 if (skb->data_len>0) {// more data are not in linear data area skb->data 730 printk("%s openwifi_tx: WARNING skb->data_len>0\n", sdr_compatible_str); 731 goto openwifi_tx_early_out; 732 } 733 734 len_mpdu = skb->len; 735 736 // get Linux priority/queue setting info and target mac address 737 prio = skb_get_queue_mapping(skb); 738 addr1_low32 = *((u32*)(hdr->addr1+2)); 739 ring = &(priv->tx_ring[prio]); 740 741 // -------------- DO your idea here! Map Linux/SW "prio" to hardware "queue_idx" ----------- 742 if (priv->slice_idx == 0xFFFFFFFF) {// use Linux default prio setting, if there isn't any slice config 743 queue_idx = prio; 744 } else {// customized prio to queue_idx mapping 745 //if (fc_type==2 && fc_subtype==0 && (!addr_flag)) { // for unicast data packet only 746 // check current packet belonging to which slice/hw-queue 747 for (i=0; i<MAX_NUM_HW_QUEUE; i++) { 748 if ( priv->dest_mac_addr_queue_map[i] == addr1_low32 ) { 749 break; 750 } 751 } 752 //} 753 queue_idx = (i>=MAX_NUM_HW_QUEUE?2:i); // if no address is hit, use FPGA queue 2. because the queue 2 is the longest. 754 } 755 // -------------------- end of Map Linux/SW "prio" to hardware "queue_idx" ------------------ 756 // get other info from packet header 757 addr1_high16 = *((u16*)(hdr->addr1)); 758 if (len_mpdu>=20) { 759 addr2_low32 = *((u32*)(hdr->addr2+2)); 760 addr2_high16 = *((u16*)(hdr->addr2)); 761 } 762 if (len_mpdu>=26) { 763 addr3_low32 = *((u32*)(hdr->addr3+2)); 764 addr3_high16 = *((u16*)(hdr->addr3)); 765 } 766 767 duration_id = hdr->duration_id; 768 frame_control=hdr->frame_control; 769 ack_flag = (info->flags&IEEE80211_TX_CTL_NO_ACK); 770 fc_type = ((frame_control)>>2)&3; 771 fc_subtype = ((frame_control)>>4)&0xf; 772 fc_flag = ( fc_type==2 || fc_type==0 || (fc_type==1 && (fc_subtype==8 || fc_subtype==9 || fc_subtype==10) ) ); 773 //if it is broadcasting or multicasting addr 774 addr_flag = ( (addr1_low32==0 && addr1_high16==0) || 775 (addr1_low32==0xFFFFFFFF && addr1_high16==0xFFFF) || 776 (addr1_high16==0x3333) || 777 (addr1_high16==0x0001 && hdr->addr1[2]==0x5E) ); 778 if ( fc_flag && ( !addr_flag ) && (!ack_flag) ) { // unicast data frame 779 pkt_need_ack = 1; //FPGA need to wait ACK after this pkt sent 780 } else { 781 pkt_need_ack = 0; 782 } 783 784 // get Linux rate (MCS) setting 785 rate_hw_value = ieee80211_get_tx_rate(dev, info)->hw_value; 786 //rate_hw_value = 10; //4:6M, 5:9M, 6:12M, 7:18M, 8:24M, 9:36M, 10:48M, 11:54M 787 if (priv->drv_tx_reg_val[DRV_TX_REG_IDX_RATE]>0 && fc_type==2 && (!addr_flag)) //rate override command 788 rate_hw_value = priv->drv_tx_reg_val[DRV_TX_REG_IDX_RATE]; 789 790 retry_limit_raw = info->control.rates[0].count; 791 792 rc_flags = info->control.rates[0].flags; 793 use_rts_cts = ((rc_flags&IEEE80211_TX_RC_USE_RTS_CTS)!=0); 794 use_cts_protect = ((rc_flags&IEEE80211_TX_RC_USE_CTS_PROTECT)!=0); 795 use_ht_rate = ((rc_flags&IEEE80211_TX_RC_MCS)!=0); 796 use_short_gi = ((rc_flags&IEEE80211_TX_RC_SHORT_GI)!=0); 797 use_ht_aggr = ((info->flags&IEEE80211_TX_CTL_AMPDU)!=0); 798 799 if (use_rts_cts) 800 printk("%s openwifi_tx: WARNING sn %d use_rts_cts is not supported!\n", sdr_compatible_str, ring->bd_wr_idx); 801 802 if (use_cts_protect) { 803 cts_rate_hw_value = ieee80211_get_rts_cts_rate(dev, info)->hw_value; 804 cts_duration = le16_to_cpu(ieee80211_ctstoself_duration(dev,info->control.vif,len_mpdu,info)); 805 } else if (force_use_cts_protect) { // could override mac80211 setting here. 806 cts_rate_hw_value = 4; //wifi_mcs_table_11b_force_up[] translate it to 1011(6M) 807 sifs = (priv->actual_rx_lo<2500?10:16); 808 if (pkt_need_ack) 809 ack_duration = 44;//assume the ack we wait use 6Mbps: 4*ceil((22+14*8)/24) + 20(preamble+SIGNAL) 810 traffic_pkt_duration = 20 + 4*(((22+len_mpdu*8)/wifi_n_dbps_table[rate_hw_value])+1); 811 cts_duration = traffic_pkt_duration + sifs + pkt_need_ack*(sifs+ack_duration); 812 } 813 814 // this is 11b stuff 815 // if (info->flags&IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 816 // printk("%s openwifi_tx: WARNING IEEE80211_TX_RC_USE_SHORT_PREAMBLE\n", sdr_compatible_str); 817 818 if (len_mpdu>=28) { 819 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 820 if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT) 821 priv->seqno += 0x10; 822 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); 823 hdr->seq_ctrl |= cpu_to_le16(priv->seqno); 824 } 825 sc = hdr->seq_ctrl; 826 } 827 828 if ( ( (!addr_flag)||(priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG]&4) ) && (priv->drv_tx_reg_val[DRV_TX_REG_IDX_PRINT_CFG]&2) ) 829 printk("%s openwifi_tx: %4dbytes ht%d aggr%d %3dM FC%04x DI%04x addr1/2/3:%04x%08x/%04x%08x/%04x%08x SC%04x flag%08x retr%d ack%d prio%d q%d wr%d rd%d\n", sdr_compatible_str, 830 len_mpdu, (use_ht_rate == false ? 0 : 1), (use_ht_aggr == false ? 0 : 1), (use_ht_rate == false ? wifi_rate_all[rate_hw_value] : wifi_rate_all[rate_hw_value + 12]),frame_control,duration_id, 831 reverse16(addr1_high16), reverse32(addr1_low32), reverse16(addr2_high16), reverse32(addr2_low32), reverse16(addr3_high16), reverse32(addr3_low32), 832 sc, info->flags, retry_limit_raw, pkt_need_ack, prio, queue_idx, 833 // use_rts_cts,use_cts_protect|force_use_cts_protect,wifi_rate_all[cts_rate_hw_value],cts_duration, 834 ring->bd_wr_idx,ring->bd_rd_idx); 835 836 // printk("%s openwifi_tx: rate&try: %d %d %03x; %d %d %03x; %d %d %03x; %d %d %03x\n", sdr_compatible_str, 837 // info->status.rates[0].idx,info->status.rates[0].count,info->status.rates[0].flags, 838 // info->status.rates[1].idx,info->status.rates[1].count,info->status.rates[1].flags, 839 // info->status.rates[2].idx,info->status.rates[2].count,info->status.rates[2].flags, 840 // info->status.rates[3].idx,info->status.rates[3].count,info->status.rates[3].flags); 841 842 // -----------end of preprocess some info from header and skb---------------- 843 844 // /* HW will perform RTS-CTS when only RTS flags is set. 845 // * HW will perform CTS-to-self when both RTS and CTS flags are set. 846 // * RTS rate and RTS duration will be used also for CTS-to-self. 847 // */ 848 // if (rc_flags & IEEE80211_TX_RC_USE_RTS_CTS) { 849 // tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19; 850 // rts_duration = ieee80211_rts_duration(dev, priv->vif[0], // assume all vif have the same config 851 // len_mpdu, info); 852 // printk("%s openwifi_tx: rc_flags & IEEE80211_TX_RC_USE_RTS_CTS\n", sdr_compatible_str); 853 // } else if (rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT) { 854 // tx_flags |= ieee80211_get_rts_cts_rate(dev, info)->hw_value << 19; 855 // rts_duration = ieee80211_ctstoself_duration(dev, priv->vif[0], // assume all vif have the same config 856 // len_mpdu, info); 857 // printk("%s openwifi_tx: rc_flags & IEEE80211_TX_RC_USE_CTS_PROTECT\n", sdr_compatible_str); 858 // } 859 860 if(use_ht_aggr) 861 { 862 qos_hdr = ieee80211_get_qos_ctl(hdr); 863 if(ieee80211_is_data_qos(frame_control) == false || qos_hdr[0] != priv->tid) 864 { 865 printk("%s openwifi_tx: WARNING packet is either not qos or tid %u does not match registered tid %u\n", sdr_compatible_str, qos_hdr[0], priv->tid); 866 goto openwifi_tx_early_out; 867 } 868 869 // psdu = [ MPDU DEL | MPDU | CRC | MPDU padding ] 870 len_mpdu_delim_pad = ((len_mpdu + LEN_PHY_CRC)%4 == 0) ? 0 :(4 - (len_mpdu + LEN_PHY_CRC)%4); 871 len_psdu = LEN_MPDU_DELIM + len_mpdu + LEN_PHY_CRC + len_mpdu_delim_pad; 872 873 if( (addr1_low32 != addr1_low32_prev) || (addr1_high16 != addr1_high16_prev) || (duration_id != duration_id_prev) || 874 (rate_hw_value != rate_hw_value_prev) || (use_short_gi != use_short_gi_prev) || 875 (prio != prio_prev) || (retry_limit_raw != retry_limit_raw_prev) || (pkt_need_ack != pkt_need_ack_prev) ) 876 { 877 addr1_low32_prev = addr1_low32; 878 addr1_high16_prev = addr1_high16; 879 duration_id_prev = duration_id; 880 rate_hw_value_prev = rate_hw_value; 881 use_short_gi_prev = use_short_gi; 882 prio_prev = prio; 883 retry_limit_raw_prev = retry_limit_raw; 884 pkt_need_ack_prev = pkt_need_ack; 885 886 ht_aggr_start = true; 887 } 888 } 889 else 890 { 891 // psdu = [ MPDU ] 892 len_psdu = len_mpdu; 893 894 addr1_low32_prev = -1; 895 addr1_high16_prev = -1; 896 duration_id_prev = -1; 897 use_short_gi_prev = -1; 898 rate_hw_value_prev = -1; 899 prio_prev = -1; 900 retry_limit_raw_prev = -1; 901 pkt_need_ack_prev = -1; 902 } 903 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); 904 905 // check whether the packet is bigger than DMA buffer size 906 num_dma_byte = (num_dma_symbol<<TX_INTF_NUM_BYTE_PER_DMA_SYMBOL_IN_BITS); 907 if (num_dma_byte > TX_BD_BUF_SIZE) { 908 printk("%s openwifi_tx: WARNING sn %d num_dma_byte > TX_BD_BUF_SIZE\n", sdr_compatible_str, ring->bd_wr_idx); 909 goto openwifi_tx_early_out; 910 } 911 912 // Copy MPDU delimiter and padding into sk_buff 913 if(use_ht_aggr) 914 { 915 // when skb does not have enough headroom, skb_push will cause kernel panic. headroom needs to be extended if necessary 916 if (skb_headroom(skb)<LEN_MPDU_DELIM) { 917 struct sk_buff *skb_new; // in case original skb headroom is not enough to host MPDU delimiter 918 printk("%s openwifi_tx: WARNING sn %d skb_headroom(skb)<LEN_MPDU_DELIM\n", sdr_compatible_str, ring->bd_wr_idx); 919 if ((skb_new = skb_realloc_headroom(skb, LEN_MPDU_DELIM)) == NULL) { 920 printk("%s openwifi_tx: WARNING sn %d skb_realloc_headroom failed!\n", sdr_compatible_str, ring->bd_wr_idx); 921 goto openwifi_tx_early_out; 922 } 923 if (skb->sk != NULL) 924 skb_set_owner_w(skb_new, skb->sk); 925 dev_kfree_skb(skb); 926 skb = skb_new; 927 } 928 skb_push( skb, LEN_MPDU_DELIM ); 929 dma_buf = skb->data; 930 931 // fill in MPDU delimiter 932 *((u16*)(dma_buf+0)) = ((u16)(len_mpdu+LEN_PHY_CRC) << 4) & 0xFFF0; 933 *((u8 *)(dma_buf+2)) = gen_mpdu_delim_crc(*((u16 *)dma_buf)); 934 *((u8 *)(dma_buf+3)) = 0x4e; 935 936 // Extend sk_buff to hold CRC + MPDU padding + empty MPDU delimiter 937 num_byte_pad = num_dma_byte - (LEN_MPDU_DELIM + len_mpdu); 938 if (skb_tailroom(skb)<num_byte_pad) { 939 printk("%s openwifi_tx: WARNING sn %d skb_tailroom(skb)<num_byte_pad!\n", sdr_compatible_str, ring->bd_wr_idx); 940 goto openwifi_tx_early_out; 941 } 942 skb_put( skb, num_byte_pad ); 943 944 // fill in MPDU CRC 945 *((u32*)(dma_buf+LEN_MPDU_DELIM+len_mpdu)) = gen_mpdu_crc(dma_buf+LEN_MPDU_DELIM, len_mpdu); 946 947 // fill in MPDU delimiter padding 948 memset(dma_buf+LEN_MPDU_DELIM+len_mpdu+LEN_PHY_CRC, 0, len_mpdu_delim_pad); 949 950 // num_dma_byte is on 8-byte boundary and len_psdu is on 4 byte boundary. 951 // If they have different lengths, add "empty MPDU delimiter" for alignment 952 if(num_dma_byte == len_psdu + 4) 953 { 954 *((u32*)(dma_buf+len_psdu)) = 0x4e140000; 955 len_psdu = num_dma_byte; 956 } 957 } 958 else 959 { 960 // Extend sk_buff to hold padding 961 num_byte_pad = num_dma_byte - len_mpdu; 962 if (skb_tailroom(skb)<num_byte_pad) { 963 printk("%s openwifi_tx: WARNING sn %d skb_tailroom(skb)<num_byte_pad!\n", sdr_compatible_str, ring->bd_wr_idx); 964 goto openwifi_tx_early_out; 965 } 966 skb_put( skb, num_byte_pad ); 967 968 dma_buf = skb->data; 969 } 970 // for(i = 0; i <= num_dma_symbol; i++) 971 // printk("%16llx\n", (*(u64*)(&(dma_buf[i*8])))); 972 973 rate_signal_value = (use_ht_rate ? rate_hw_value : wifi_mcs_table_11b_force_up[rate_hw_value]); 974 975 retry_limit_hw_value = ( retry_limit_raw==0?0:((retry_limit_raw - 1)&0xF) ); 976 977 cts_rate_signal_value = wifi_mcs_table_11b_force_up[cts_rate_hw_value]; 978 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); 979 tx_config = ( prio<<26 | ring->bd_wr_idx<<20 | queue_idx<<18 | retry_limit_hw_value<<14 | pkt_need_ack<<13 | (len_mpdu+LEN_PHY_CRC) ); 980 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 ); 981 982 /* We must be sure that tx_flags is written last because the HW 983 * looks at it to check if the rest of data is valid or not 984 */ 985 //wmb(); 986 // entry->flags = cpu_to_le32(tx_flags); 987 /* We must be sure this has been written before following HW 988 * register write, because this write will make the HW attempts 989 * to DMA the just-written data 990 */ 991 //wmb(); 992 993 spin_lock_irqsave(&priv->lock, flags); // from now on, we'd better avoid interrupt because ring->stop_flag is shared with interrupt 994 995 // -------------check whether FPGA dma fifo and queue (queue_idx) has enough room------------- 996 dma_fifo_no_room_flag = tx_intf_api->TX_INTF_REG_S_AXIS_FIFO_NO_ROOM_read(); 997 hw_queue_len = tx_intf_api->TX_INTF_REG_QUEUE_FIFO_DATA_COUNT_read(); 998 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==1 ) { 999 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 1000 printk("%s openwifi_tx: WARNING ieee80211_stop_queue prio %d queue %d no room flag %x hw queue len %08x request %d wr %d rd %d\n", sdr_compatible_str, 1001 prio, queue_idx, dma_fifo_no_room_flag, hw_queue_len, num_dma_symbol, ring->bd_wr_idx, ring->bd_rd_idx); 1002 ring->stop_flag = 1; 1003 goto openwifi_tx_early_out_after_lock; 1004 } 1005 // --------end of check whether FPGA fifo (queue_idx) has enough room------------ 1006 1007 status = dma_async_is_tx_complete(priv->tx_chan, priv->tx_cookie, NULL, NULL); 1008 if (status!=DMA_COMPLETE) { 1009 printk("%s openwifi_tx: WARNING status!=DMA_COMPLETE\n", sdr_compatible_str); 1010 goto openwifi_tx_early_out_after_lock; 1011 } 1012 1013 //-------------------------fire skb DMA to hardware---------------------------------- 1014 dma_mapping_addr = dma_map_single(priv->tx_chan->device->dev, dma_buf, 1015 num_dma_byte, DMA_MEM_TO_DEV); 1016 1017 if (dma_mapping_error(priv->tx_chan->device->dev,dma_mapping_addr)) { 1018 // dev_err(priv->tx_chan->device->dev, "sdr,sdr openwifi_tx: WARNING TX DMA mapping error\n"); 1019 printk("%s openwifi_tx: WARNING sn %d TX DMA mapping error\n", sdr_compatible_str, ring->bd_wr_idx); 1020 goto openwifi_tx_early_out_after_lock; 1021 } 1022 1023 sg_init_table(&(priv->tx_sg), 1); // only need to be initialized once in openwifi_start 1024 sg_dma_address( &(priv->tx_sg) ) = dma_mapping_addr; 1025 sg_dma_len( &(priv->tx_sg) ) = num_dma_byte; 1026 1027 tx_intf_api->TX_INTF_REG_CTS_TOSELF_CONFIG_write(cts_reg); 1028 tx_intf_api->TX_INTF_REG_TX_CONFIG_write(tx_config); 1029 tx_intf_api->TX_INTF_REG_PHY_HDR_CONFIG_write(phy_hdr_config); 1030 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); 1031 if (!(priv->txd)) { 1032 printk("%s openwifi_tx: WARNING sn %d device_prep_slave_sg %p\n", sdr_compatible_str, ring->bd_wr_idx, (void*)(priv->txd)); 1033 goto openwifi_tx_after_dma_mapping; 1034 } 1035 1036 priv->tx_cookie = priv->txd->tx_submit(priv->txd); 1037 1038 if (dma_submit_error(priv->tx_cookie)) { 1039 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)); 1040 goto openwifi_tx_after_dma_mapping; 1041 } 1042 1043 // seems everything is ok. let's mark this pkt in bd descriptor ring 1044 ring->bds[ring->bd_wr_idx].seq_no = (sc&IEEE80211_SCTL_SEQ)>>4; 1045 ring->bds[ring->bd_wr_idx].skb_linked = skb; 1046 ring->bds[ring->bd_wr_idx].dma_mapping_addr = dma_mapping_addr; 1047 1048 ring->bd_wr_idx = ((ring->bd_wr_idx+1)&(NUM_TX_BD-1)); 1049 1050 dma_async_issue_pending(priv->tx_chan); 1051 1052 spin_unlock_irqrestore(&priv->lock, flags); 1053 1054 return; 1055 1056 openwifi_tx_after_dma_mapping: 1057 dma_unmap_single(priv->tx_chan->device->dev, dma_mapping_addr, num_dma_byte, DMA_MEM_TO_DEV); 1058 1059 openwifi_tx_early_out_after_lock: 1060 dev_kfree_skb(skb); 1061 spin_unlock_irqrestore(&priv->lock, flags); 1062 // 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); 1063 return; 1064 1065 openwifi_tx_early_out: 1066 //dev_kfree_skb(skb); 1067 // 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); 1068 } 1069 1070 static int openwifi_set_antenna(struct ieee80211_hw *dev, u32 tx_ant, u32 rx_ant) 1071 { 1072 struct openwifi_priv *priv = dev->priv; 1073 u8 fpga_tx_ant_setting, target_rx_ant; 1074 u32 atten_mdb_tx0, atten_mdb_tx1; 1075 struct ctrl_outs_control ctrl_out; 1076 int ret; 1077 1078 printk("%s openwifi_set_antenna: tx_ant%d rx_ant%d\n",sdr_compatible_str,tx_ant,rx_ant); 1079 1080 if (tx_ant >= 4 || tx_ant == 0) { 1081 return -EINVAL; 1082 } else if (rx_ant >= 3 || rx_ant == 0) { 1083 return -EINVAL; 1084 } 1085 1086 fpga_tx_ant_setting = ((tx_ant<=2)?(tx_ant):(tx_ant+16)); 1087 target_rx_ant = ((rx_ant&1)?0:1); 1088 1089 // try rf chip setting firstly, only update internal state variable when rf chip succeed 1090 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); 1091 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); 1092 ret = ad9361_set_tx_atten(priv->ad9361_phy, atten_mdb_tx0, true, false, true); 1093 if (ret < 0) { 1094 printk("%s openwifi_set_antenna: WARNING ad9361_set_tx_atten ant0 %d FAIL!\n",sdr_compatible_str, atten_mdb_tx0); 1095 return -EINVAL; 1096 } else { 1097 printk("%s openwifi_set_antenna: ad9361_set_tx_atten ant0 %d OK\n",sdr_compatible_str, atten_mdb_tx0); 1098 } 1099 ret = ad9361_set_tx_atten(priv->ad9361_phy, atten_mdb_tx1, false, true, true); 1100 if (ret < 0) { 1101 printk("%s openwifi_set_antenna: WARNING ad9361_set_tx_atten ant1 %d FAIL!\n",sdr_compatible_str, atten_mdb_tx1); 1102 return -EINVAL; 1103 } else { 1104 printk("%s openwifi_set_antenna: ad9361_set_tx_atten ant1 %d OK\n",sdr_compatible_str, atten_mdb_tx1); 1105 } 1106 1107 ctrl_out.en_mask = priv->ctrl_out.en_mask; 1108 ctrl_out.index = (target_rx_ant==0?AD9361_CTRL_OUT_INDEX_ANT0:AD9361_CTRL_OUT_INDEX_ANT1); 1109 ret = ad9361_ctrl_outs_setup(priv->ad9361_phy, &(ctrl_out)); 1110 if (ret < 0) { 1111 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); 1112 return -EINVAL; 1113 } else { 1114 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); 1115 } 1116 1117 tx_intf_api->TX_INTF_REG_ANT_SEL_write(fpga_tx_ant_setting); 1118 ret = tx_intf_api->TX_INTF_REG_ANT_SEL_read(); 1119 if (ret != fpga_tx_ant_setting) { 1120 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); 1121 return -EINVAL; 1122 } else { 1123 printk("%s openwifi_set_antenna: TX_INTF_REG_ANT_SEL_write value %d\n",sdr_compatible_str, ret); 1124 } 1125 1126 rx_intf_api->RX_INTF_REG_ANT_SEL_write(target_rx_ant); 1127 ret = rx_intf_api->RX_INTF_REG_ANT_SEL_read(); 1128 if (ret != target_rx_ant) { 1129 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); 1130 return -EINVAL; 1131 } else { 1132 printk("%s openwifi_set_antenna: RX_INTF_REG_ANT_SEL_write value %d\n",sdr_compatible_str, ret); 1133 } 1134 1135 // update internal state variable 1136 priv->runtime_tx_ant_cfg = tx_ant; 1137 priv->runtime_rx_ant_cfg = rx_ant; 1138 1139 if (TX_OFFSET_TUNING_ENABLE) 1140 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 1141 else { 1142 if (tx_ant == 3) 1143 priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_0MHZ_ANT_BOTH; 1144 else 1145 priv->tx_intf_cfg = ((tx_ant&1)?TX_INTF_BW_20MHZ_AT_0MHZ_ANT0:TX_INTF_BW_20MHZ_AT_0MHZ_ANT1); 1146 } 1147 1148 priv->rx_intf_cfg = (target_rx_ant==0?RX_INTF_BW_20MHZ_AT_0MHZ_ANT0:RX_INTF_BW_20MHZ_AT_0MHZ_ANT1); 1149 priv->ctrl_out.index=ctrl_out.index; 1150 1151 priv->tx_freq_offset_to_lo_MHz = tx_intf_fo_mapping[priv->tx_intf_cfg]; 1152 priv->rx_freq_offset_to_lo_MHz = rx_intf_fo_mapping[priv->rx_intf_cfg]; 1153 1154 return 0; 1155 } 1156 static int openwifi_get_antenna(struct ieee80211_hw *dev, u32 *tx_ant, u32 *rx_ant) 1157 { 1158 struct openwifi_priv *priv = dev->priv; 1159 1160 *tx_ant = priv->runtime_tx_ant_cfg; 1161 *rx_ant = priv->runtime_rx_ant_cfg; 1162 1163 printk("%s openwifi_get_antenna: tx_ant%d rx_ant%d\n",sdr_compatible_str, *tx_ant, *rx_ant); 1164 1165 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, 1166 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); 1167 1168 printk("%s openwifi_get_antenna: fpga tx sel %d rx sel %d\n", sdr_compatible_str, 1169 tx_intf_api->TX_INTF_REG_ANT_SEL_read(), rx_intf_api->RX_INTF_REG_ANT_SEL_read()); 1170 1171 printk("%s openwifi_get_antenna: rf tx att0 %d tx att1 %d ctrl_out sel %x\n", sdr_compatible_str, 1172 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)); 1173 1174 return 0; 1175 } 1176 1177 static int openwifi_start(struct ieee80211_hw *dev) 1178 { 1179 struct openwifi_priv *priv = dev->priv; 1180 int ret, i; 1181 u32 reg; 1182 1183 for (i=0; i<MAX_NUM_VIF; i++) { 1184 priv->vif[i] = NULL; 1185 } 1186 1187 // //keep software registers persistent between NIC down and up for multiple times 1188 /*memset(priv->drv_tx_reg_val, 0, sizeof(priv->drv_tx_reg_val)); 1189 memset(priv->drv_rx_reg_val, 0, sizeof(priv->drv_rx_reg_val)); 1190 memset(priv->drv_xpu_reg_val, 0, sizeof(priv->drv_xpu_reg_val)); 1191 memset(priv->rf_reg_val,0,sizeof(priv->rf_reg_val)); 1192 priv->drv_xpu_reg_val[DRV_XPU_REG_IDX_GIT_REV] = GIT_REV;*/ 1193 1194 //turn on radio 1195 openwifi_set_antenna(dev, priv->runtime_tx_ant_cfg, priv->runtime_rx_ant_cfg); 1196 reg = ad9361_get_tx_atten(priv->ad9361_phy, ((priv->runtime_tx_ant_cfg==1 || priv->runtime_tx_ant_cfg==3)?1:2)); 1197 if (reg == (AD9361_RADIO_ON_TX_ATT+priv->rf_reg_val[RF_TX_REG_IDX_ATT])) { 1198 priv->rfkill_off = 1;// 0 off, 1 on 1199 printk("%s openwifi_start: rfkill radio on\n",sdr_compatible_str); 1200 } 1201 else 1202 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]); 1203 1204 rx_intf_api->hw_init(priv->rx_intf_cfg,8,8); 1205 tx_intf_api->hw_init(priv->tx_intf_cfg,8,8,priv->fpga_type); 1206 openofdm_tx_api->hw_init(priv->openofdm_tx_cfg); 1207 openofdm_rx_api->hw_init(priv->openofdm_rx_cfg); 1208 xpu_api->hw_init(priv->xpu_cfg); 1209 1210 xpu_api->XPU_REG_MAC_ADDR_write(priv->mac_addr); 1211 1212 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); 1213 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); 1214 1215 tx_intf_api->TX_INTF_REG_INTERRUPT_SEL_write(0x30004); //disable tx interrupt 1216 rx_intf_api->RX_INTF_REG_INTERRUPT_TEST_write(0x100); // disable rx interrupt by interrupt test mode 1217 rx_intf_api->RX_INTF_REG_M_AXIS_RST_write(1); // hold M AXIS in reset status 1218 1219 priv->rx_chan = dma_request_slave_channel(&(priv->pdev->dev), "rx_dma_s2mm"); 1220 if (IS_ERR(priv->rx_chan) || priv->rx_chan==NULL) { 1221 ret = PTR_ERR(priv->rx_chan); 1222 pr_err("%s openwifi_start: No Rx channel ret %d priv->rx_chan 0x%p\n",sdr_compatible_str, ret, priv->rx_chan); 1223 goto err_dma; 1224 } 1225 1226 priv->tx_chan = dma_request_slave_channel(&(priv->pdev->dev), "tx_dma_mm2s"); 1227 if (IS_ERR(priv->tx_chan) || priv->tx_chan==NULL) { 1228 ret = PTR_ERR(priv->tx_chan); 1229 pr_err("%s openwifi_start: No Tx channel ret %d priv->tx_chan 0x%p\n",sdr_compatible_str, ret, priv->tx_chan); 1230 goto err_dma; 1231 } 1232 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); 1233 1234 ret = openwifi_init_rx_ring(priv); 1235 if (ret) { 1236 printk("%s openwifi_start: openwifi_init_rx_ring ret %d\n", sdr_compatible_str,ret); 1237 goto err_free_rings; 1238 } 1239 1240 priv->seqno=0; 1241 for (i=0; i<MAX_NUM_SW_QUEUE; i++) { 1242 if ((ret = openwifi_init_tx_ring(priv, i))) { 1243 printk("%s openwifi_start: openwifi_init_tx_ring %d ret %d\n", sdr_compatible_str, i, ret); 1244 goto err_free_rings; 1245 } 1246 } 1247 1248 if ( (ret = rx_dma_setup(dev)) ) { 1249 printk("%s openwifi_start: rx_dma_setup ret %d\n", sdr_compatible_str,ret); 1250 goto err_free_rings; 1251 } 1252 1253 priv->irq_rx = irq_of_parse_and_map(priv->pdev->dev.of_node, 1); 1254 ret = request_irq(priv->irq_rx, openwifi_rx_interrupt, 1255 IRQF_SHARED, "sdr,rx_pkt_intr", dev); 1256 if (ret) { 1257 wiphy_err(dev->wiphy, "openwifi_start:failed to register IRQ handler openwifi_rx_interrupt\n"); 1258 goto err_free_rings; 1259 } else { 1260 printk("%s openwifi_start: irq_rx %d\n", sdr_compatible_str, priv->irq_rx); 1261 } 1262 1263 priv->irq_tx = irq_of_parse_and_map(priv->pdev->dev.of_node, 3); 1264 ret = request_irq(priv->irq_tx, openwifi_tx_interrupt, 1265 IRQF_SHARED, "sdr,tx_itrpt", dev); 1266 if (ret) { 1267 wiphy_err(dev->wiphy, "openwifi_start: failed to register IRQ handler openwifi_tx_interrupt\n"); 1268 goto err_free_rings; 1269 } else { 1270 printk("%s openwifi_start: irq_tx %d\n", sdr_compatible_str, priv->irq_tx); 1271 } 1272 1273 rx_intf_api->RX_INTF_REG_INTERRUPT_TEST_write(0x000); // enable rx interrupt get normal fcs valid pass through ddc to ARM 1274 tx_intf_api->TX_INTF_REG_INTERRUPT_SEL_write(0x4); //enable tx interrupt 1275 rx_intf_api->RX_INTF_REG_M_AXIS_RST_write(0); // release M AXIS 1276 xpu_api->XPU_REG_TSF_LOAD_VAL_write(0,0); // reset tsf timer 1277 1278 1279 // normal_out: 1280 printk("%s openwifi_start: normal end\n", sdr_compatible_str); 1281 return 0; 1282 1283 err_free_rings: 1284 openwifi_free_rx_ring(priv); 1285 for (i=0; i<MAX_NUM_SW_QUEUE; i++) 1286 openwifi_free_tx_ring(priv, i); 1287 1288 err_dma: 1289 ret = -1; 1290 printk("%s openwifi_start: abnormal end ret %d\n", sdr_compatible_str, ret); 1291 return ret; 1292 } 1293 1294 static void openwifi_stop(struct ieee80211_hw *dev) 1295 { 1296 struct openwifi_priv *priv = dev->priv; 1297 u32 reg, reg1; 1298 int i; 1299 1300 1301 //turn off radio 1302 #if 1 1303 ad9361_tx_mute(priv->ad9361_phy, 1); 1304 reg = ad9361_get_tx_atten(priv->ad9361_phy, 2); 1305 reg1 = ad9361_get_tx_atten(priv->ad9361_phy, 1); 1306 if (reg == AD9361_RADIO_OFF_TX_ATT && reg1 == AD9361_RADIO_OFF_TX_ATT ) { 1307 priv->rfkill_off = 0;// 0 off, 1 on 1308 printk("%s openwifi_stop: rfkill radio off\n",sdr_compatible_str); 1309 } 1310 else 1311 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); 1312 #endif 1313 1314 //ieee80211_stop_queue(dev, 0); 1315 tx_intf_api->TX_INTF_REG_INTERRUPT_SEL_write(0x30004); //disable tx interrupt 1316 rx_intf_api->RX_INTF_REG_INTERRUPT_TEST_write(0x100); // disable fcs_valid by interrupt test mode 1317 rx_intf_api->RX_INTF_REG_M_AXIS_RST_write(1); // hold M AXIS in reset status 1318 1319 for (i=0; i<MAX_NUM_VIF; i++) { 1320 priv->vif[i] = NULL; 1321 } 1322 1323 openwifi_free_rx_ring(priv); 1324 for (i=0; i<MAX_NUM_SW_QUEUE; i++) 1325 openwifi_free_tx_ring(priv, i); 1326 1327 pr_info("%s openwifi_stop: dropped channel %s\n", sdr_compatible_str, dma_chan_name(priv->rx_chan)); 1328 dmaengine_terminate_all(priv->rx_chan); 1329 dma_release_channel(priv->rx_chan); 1330 pr_info("%s openwifi_stop: dropped channel %s\n", sdr_compatible_str, dma_chan_name(priv->tx_chan)); 1331 dmaengine_terminate_all(priv->tx_chan); 1332 dma_release_channel(priv->tx_chan); 1333 1334 //priv->rf->stop(dev); 1335 1336 free_irq(priv->irq_rx, dev); 1337 free_irq(priv->irq_tx, dev); 1338 1339 // normal_out: 1340 printk("%s openwifi_stop\n", sdr_compatible_str); 1341 } 1342 1343 static u64 openwifi_get_tsf(struct ieee80211_hw *dev, 1344 struct ieee80211_vif *vif) 1345 { 1346 u32 tsft_low, tsft_high; 1347 1348 tsft_low = xpu_api->XPU_REG_TSF_RUNTIME_VAL_LOW_read(); 1349 tsft_high = xpu_api->XPU_REG_TSF_RUNTIME_VAL_HIGH_read(); 1350 //printk("%s openwifi_get_tsf: %08x%08x\n", sdr_compatible_str,tsft_high,tsft_low); 1351 return( ( (u64)tsft_low ) | ( ((u64)tsft_high)<<32 ) ); 1352 } 1353 1354 static void openwifi_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u64 tsf) 1355 { 1356 u32 tsft_high = ((tsf >> 32)&0xffffffff); 1357 u32 tsft_low = (tsf&0xffffffff); 1358 xpu_api->XPU_REG_TSF_LOAD_VAL_write(tsft_high,tsft_low); 1359 printk("%s openwifi_set_tsf: %08x%08x\n", sdr_compatible_str,tsft_high,tsft_low); 1360 } 1361 1362 static void openwifi_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 1363 { 1364 xpu_api->XPU_REG_TSF_LOAD_VAL_write(0,0); 1365 printk("%s openwifi_reset_tsf\n", sdr_compatible_str); 1366 } 1367 1368 static int openwifi_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 1369 { 1370 printk("%s openwifi_set_rts_threshold WARNING value %d\n", sdr_compatible_str,value); 1371 return(0); 1372 } 1373 1374 static void openwifi_beacon_work(struct work_struct *work) 1375 { 1376 struct openwifi_vif *vif_priv = 1377 container_of(work, struct openwifi_vif, beacon_work.work); 1378 struct ieee80211_vif *vif = 1379 container_of((void *)vif_priv, struct ieee80211_vif, drv_priv); 1380 struct ieee80211_hw *dev = vif_priv->dev; 1381 struct ieee80211_mgmt *mgmt; 1382 struct sk_buff *skb; 1383 1384 /* don't overflow the tx ring */ 1385 if (ieee80211_queue_stopped(dev, 0)) 1386 goto resched; 1387 1388 /* grab a fresh beacon */ 1389 skb = ieee80211_beacon_get(dev, vif); 1390 if (!skb) 1391 goto resched; 1392 1393 /* 1394 * update beacon timestamp w/ TSF value 1395 * TODO: make hardware update beacon timestamp 1396 */ 1397 mgmt = (struct ieee80211_mgmt *)skb->data; 1398 mgmt->u.beacon.timestamp = cpu_to_le64(openwifi_get_tsf(dev, vif)); 1399 1400 /* TODO: use actual beacon queue */ 1401 skb_set_queue_mapping(skb, 0); 1402 openwifi_tx(dev, NULL, skb); 1403 1404 resched: 1405 /* 1406 * schedule next beacon 1407 * TODO: use hardware support for beacon timing 1408 */ 1409 schedule_delayed_work(&vif_priv->beacon_work, usecs_to_jiffies(1024 * vif->bss_conf.beacon_int)); 1410 // printk("%s openwifi_beacon_work beacon_int %d\n", sdr_compatible_str, vif->bss_conf.beacon_int); 1411 } 1412 1413 static int openwifi_add_interface(struct ieee80211_hw *dev, 1414 struct ieee80211_vif *vif) 1415 { 1416 int i; 1417 struct openwifi_priv *priv = dev->priv; 1418 struct openwifi_vif *vif_priv; 1419 1420 switch (vif->type) { 1421 case NL80211_IFTYPE_AP: 1422 case NL80211_IFTYPE_STATION: 1423 case NL80211_IFTYPE_ADHOC: 1424 case NL80211_IFTYPE_MONITOR: 1425 case NL80211_IFTYPE_MESH_POINT: 1426 break; 1427 default: 1428 return -EOPNOTSUPP; 1429 } 1430 // let's support more than 1 interface 1431 for (i=0; i<MAX_NUM_VIF; i++) { 1432 if (priv->vif[i] == NULL) 1433 break; 1434 } 1435 1436 printk("%s openwifi_add_interface start. vif for loop result %d\n", sdr_compatible_str, i); 1437 1438 if (i==MAX_NUM_VIF) 1439 return -EBUSY; 1440 1441 priv->vif[i] = vif; 1442 1443 /* Initialize driver private area */ 1444 vif_priv = (struct openwifi_vif *)&vif->drv_priv; 1445 vif_priv->idx = i; 1446 1447 vif_priv->dev = dev; 1448 INIT_DELAYED_WORK(&vif_priv->beacon_work, openwifi_beacon_work); 1449 vif_priv->enable_beacon = false; 1450 1451 priv->mac_addr[0] = vif->addr[0]; 1452 priv->mac_addr[1] = vif->addr[1]; 1453 priv->mac_addr[2] = vif->addr[2]; 1454 priv->mac_addr[3] = vif->addr[3]; 1455 priv->mac_addr[4] = vif->addr[4]; 1456 priv->mac_addr[5] = vif->addr[5]; 1457 xpu_api->XPU_REG_MAC_ADDR_write(priv->mac_addr); // set mac addr in fpga 1458 1459 printk("%s openwifi_add_interface end with vif idx %d addr %02x:%02x:%02x:%02x:%02x:%02x\n", sdr_compatible_str,vif_priv->idx, 1460 vif->addr[0],vif->addr[1],vif->addr[2],vif->addr[3],vif->addr[4],vif->addr[5]); 1461 1462 return 0; 1463 } 1464 1465 static void openwifi_remove_interface(struct ieee80211_hw *dev, 1466 struct ieee80211_vif *vif) 1467 { 1468 struct openwifi_vif *vif_priv; 1469 struct openwifi_priv *priv = dev->priv; 1470 1471 vif_priv = (struct openwifi_vif *)&vif->drv_priv; 1472 priv->vif[vif_priv->idx] = NULL; 1473 printk("%s openwifi_remove_interface vif idx %d\n", sdr_compatible_str, vif_priv->idx); 1474 } 1475 1476 static int openwifi_config(struct ieee80211_hw *dev, u32 changed) 1477 { 1478 struct openwifi_priv *priv = dev->priv; 1479 struct ieee80211_conf *conf = &dev->conf; 1480 1481 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) 1482 priv->rf->set_chan(dev, conf); 1483 else 1484 printk("%s openwifi_config changed flag %08x\n", sdr_compatible_str, changed); 1485 1486 return 0; 1487 } 1488 1489 static void openwifi_bss_info_changed(struct ieee80211_hw *dev, 1490 struct ieee80211_vif *vif, 1491 struct ieee80211_bss_conf *info, 1492 u32 changed) 1493 { 1494 struct openwifi_priv *priv = dev->priv; 1495 struct openwifi_vif *vif_priv; 1496 u32 bssid_low, bssid_high; 1497 1498 vif_priv = (struct openwifi_vif *)&vif->drv_priv; 1499 1500 //be careful: we don have valid chip, so registers addresses in priv->map->BSSID[0] are not valid! should not print it! 1501 //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]); 1502 if (changed & BSS_CHANGED_BSSID) { 1503 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]); 1504 // write new bssid to our HW, and do not change bssid filter 1505 //u32 bssid_filter_high = xpu_api->XPU_REG_BSSID_FILTER_HIGH_read(); 1506 bssid_low = ( *( (u32*)(info->bssid) ) ); 1507 bssid_high = ( *( (u16*)(info->bssid+4) ) ); 1508 1509 //bssid_filter_high = (bssid_filter_high&0x80000000); 1510 //bssid_high = (bssid_high|bssid_filter_high); 1511 xpu_api->XPU_REG_BSSID_FILTER_LOW_write(bssid_low); 1512 xpu_api->XPU_REG_BSSID_FILTER_HIGH_write(bssid_high); 1513 } 1514 1515 if (changed & BSS_CHANGED_BEACON_INT) { 1516 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_INT %x\n",sdr_compatible_str,info->beacon_int); 1517 } 1518 1519 if (changed & BSS_CHANGED_TXPOWER) 1520 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_TXPOWER %x\n",sdr_compatible_str,info->txpower); 1521 1522 if (changed & BSS_CHANGED_ERP_CTS_PROT) 1523 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_ERP_CTS_PROT %x\n",sdr_compatible_str,info->use_cts_prot); 1524 1525 if (changed & BSS_CHANGED_BASIC_RATES) 1526 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_BASIC_RATES %x\n",sdr_compatible_str,info->basic_rates); 1527 1528 if (changed & (BSS_CHANGED_ERP_SLOT | BSS_CHANGED_ERP_PREAMBLE)) { 1529 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_ERP_SLOT %d BSS_CHANGED_ERP_PREAMBLE %d short slot %d\n",sdr_compatible_str, 1530 changed&BSS_CHANGED_ERP_SLOT,changed&BSS_CHANGED_ERP_PREAMBLE,info->use_short_slot); 1531 if (info->use_short_slot && priv->use_short_slot==false) { 1532 priv->use_short_slot=true; 1533 xpu_api->XPU_REG_BAND_CHANNEL_write( (priv->use_short_slot<<24)|(priv->band<<16) ); 1534 } else if ((!info->use_short_slot) && priv->use_short_slot==true) { 1535 priv->use_short_slot=false; 1536 xpu_api->XPU_REG_BAND_CHANNEL_write( (priv->use_short_slot<<24)|(priv->band<<16) ); 1537 } 1538 } 1539 1540 if (changed & BSS_CHANGED_BEACON_ENABLED) { 1541 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_ENABLED\n",sdr_compatible_str); 1542 vif_priv->enable_beacon = info->enable_beacon; 1543 } 1544 1545 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON)) { 1546 cancel_delayed_work_sync(&vif_priv->beacon_work); 1547 if (vif_priv->enable_beacon) { 1548 schedule_work(&vif_priv->beacon_work.work); 1549 printk("%s openwifi_bss_info_changed WARNING enable_beacon\n",sdr_compatible_str); 1550 } 1551 printk("%s openwifi_bss_info_changed WARNING BSS_CHANGED_BEACON_ENABLED %d BSS_CHANGED_BEACON %d\n",sdr_compatible_str, 1552 changed&BSS_CHANGED_BEACON_ENABLED,changed&BSS_CHANGED_BEACON); 1553 } 1554 } 1555 // helper function 1556 u32 log2val(u32 val){ 1557 u32 ret_val = 0 ; 1558 while(val>1){ 1559 val = val >> 1 ; 1560 ret_val ++ ; 1561 } 1562 return ret_val ; 1563 } 1564 1565 static int openwifi_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue, 1566 const struct ieee80211_tx_queue_params *params) 1567 { 1568 u32 reg_val, cw_min_exp, cw_max_exp; 1569 1570 printk("%s openwifi_conf_tx: [queue %d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d, aifs and txop ignored\n", 1571 sdr_compatible_str,queue,params->aifs,params->cw_min,params->cw_max,params->txop); 1572 1573 reg_val=xpu_api->XPU_REG_CSMA_CFG_read(); 1574 cw_min_exp = (log2val(params->cw_min + 1) & 0x0F); 1575 cw_max_exp = (log2val(params->cw_max + 1) & 0x0F); 1576 switch(queue){ 1577 case 0: reg_val = ( (reg_val & 0xFFFFFF00) | ((cw_min_exp | (cw_max_exp << 4)) << 0) ); break; 1578 case 1: reg_val = ( (reg_val & 0xFFFF00FF) | ((cw_min_exp | (cw_max_exp << 4)) << 8) ); break; 1579 case 2: reg_val = ( (reg_val & 0xFF00FFFF) | ((cw_min_exp | (cw_max_exp << 4)) << 16) ); break; 1580 case 3: reg_val = ( (reg_val & 0x00FFFFFF) | ((cw_min_exp | (cw_max_exp << 4)) << 24) ); break; 1581 default: printk("%s openwifi_conf_tx: WARNING queue %d does not exist",sdr_compatible_str, queue); return(0); 1582 } 1583 xpu_api->XPU_REG_CSMA_CFG_write(reg_val); 1584 return(0); 1585 } 1586 1587 static u64 openwifi_prepare_multicast(struct ieee80211_hw *dev, 1588 struct netdev_hw_addr_list *mc_list) 1589 { 1590 printk("%s openwifi_prepare_multicast\n", sdr_compatible_str); 1591 return netdev_hw_addr_list_count(mc_list); 1592 } 1593 1594 static void openwifi_configure_filter(struct ieee80211_hw *dev, 1595 unsigned int changed_flags, 1596 unsigned int *total_flags, 1597 u64 multicast) 1598 { 1599 u32 filter_flag; 1600 1601 (*total_flags) &= SDR_SUPPORTED_FILTERS; 1602 (*total_flags) |= FIF_ALLMULTI; //because we need to pass all multicast (no matter it is for us or not) to upper layer 1603 1604 filter_flag = (*total_flags); 1605 1606 filter_flag = (filter_flag|UNICAST_FOR_US|BROADCAST_ALL_ONE|BROADCAST_ALL_ZERO); 1607 //filter_flag = (filter_flag|UNICAST_FOR_US|BROADCAST_ALL_ONE|BROADCAST_ALL_ZERO|MONITOR_ALL); // all pkt will be delivered to arm 1608 1609 //if (priv->vif[0]->type == NL80211_IFTYPE_MONITOR) 1610 if ((filter_flag&0xf0) == 0xf0) //FIF_BCN_PRBRESP_PROMISC/FIF_CONTROL/FIF_OTHER_BSS/FIF_PSPOLL are set means monitor mode 1611 filter_flag = (filter_flag|MONITOR_ALL); 1612 else 1613 filter_flag = (filter_flag&(~MONITOR_ALL)); 1614 1615 if ( !(filter_flag&FIF_BCN_PRBRESP_PROMISC) ) 1616 filter_flag = (filter_flag|MY_BEACON); 1617 1618 filter_flag = (filter_flag|FIF_PSPOLL); 1619 1620 xpu_api->XPU_REG_FILTER_FLAG_write(filter_flag|HIGH_PRIORITY_DISCARD_FLAG); 1621 //xpu_api->XPU_REG_FILTER_FLAG_write(filter_flag); //do not discard any pkt 1622 1623 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, 1624 (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); 1625 } 1626 1627 static int openwifi_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, struct ieee80211_ampdu_params *params) 1628 { 1629 struct ieee80211_sta *sta = params->sta; 1630 enum ieee80211_ampdu_mlme_action action = params->action; 1631 // struct openwifi_priv *priv = hw->priv; 1632 u16 max_tx_bytes, buf_size; 1633 u32 ampdu_action_config; 1634 1635 if (!AGGR_ENABLE) { 1636 return -EOPNOTSUPP; 1637 } 1638 1639 switch (action) 1640 { 1641 case IEEE80211_AMPDU_TX_START: 1642 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, params->tid); 1643 printk("%s openwifi_ampdu_action: start TX aggregation. tid %d\n", sdr_compatible_str, params->tid); 1644 break; 1645 case IEEE80211_AMPDU_TX_STOP_CONT: 1646 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1647 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1648 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, params->tid); 1649 printk("%s openwifi_ampdu_action: stop TX aggregation. tid %d\n", sdr_compatible_str, params->tid); 1650 break; 1651 case IEEE80211_AMPDU_TX_OPERATIONAL: 1652 buf_size = 4; 1653 // buf_size = (params->buf_size) - 1; 1654 max_tx_bytes = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + sta->ht_cap.ampdu_factor)) - 1; 1655 ampdu_action_config = ( sta->ht_cap.ampdu_density<<24 | buf_size<<16 | max_tx_bytes ); 1656 tx_intf_api->TX_INTF_REG_AMPDU_ACTION_CONFIG_write(ampdu_action_config); 1657 printk("%s openwifi_ampdu_action: TX operational. tid %d max_tx_bytes %d ampdu_density %d buf_size %d\n", 1658 sdr_compatible_str, params->tid, max_tx_bytes, sta->ht_cap.ampdu_density, buf_size); 1659 break; 1660 case IEEE80211_AMPDU_RX_START: 1661 printk("%s openwifi_ampdu_action: start RX aggregation. tid %d\n", sdr_compatible_str, params->tid); 1662 break; 1663 case IEEE80211_AMPDU_RX_STOP: 1664 printk("%s openwifi_ampdu_action: stop RX aggregation. tid %d\n", sdr_compatible_str, params->tid); 1665 break; 1666 default: 1667 return -EOPNOTSUPP; 1668 } 1669 1670 return 0; 1671 } 1672 1673 static const struct ieee80211_ops openwifi_ops = { 1674 .tx = openwifi_tx, 1675 .start = openwifi_start, 1676 .stop = openwifi_stop, 1677 .add_interface = openwifi_add_interface, 1678 .remove_interface = openwifi_remove_interface, 1679 .config = openwifi_config, 1680 .set_antenna = openwifi_set_antenna, 1681 .get_antenna = openwifi_get_antenna, 1682 .bss_info_changed = openwifi_bss_info_changed, 1683 .conf_tx = openwifi_conf_tx, 1684 .prepare_multicast = openwifi_prepare_multicast, 1685 .configure_filter = openwifi_configure_filter, 1686 .rfkill_poll = openwifi_rfkill_poll, 1687 .get_tsf = openwifi_get_tsf, 1688 .set_tsf = openwifi_set_tsf, 1689 .reset_tsf = openwifi_reset_tsf, 1690 .set_rts_threshold = openwifi_set_rts_threshold, 1691 .ampdu_action = openwifi_ampdu_action, 1692 .testmode_cmd = openwifi_testmode_cmd, 1693 }; 1694 1695 static const struct of_device_id openwifi_dev_of_ids[] = { 1696 { .compatible = "sdr,sdr", }, 1697 {} 1698 }; 1699 MODULE_DEVICE_TABLE(of, openwifi_dev_of_ids); 1700 1701 static int custom_match_spi_dev(struct device *dev, void *data) 1702 { 1703 const char *name = data; 1704 1705 bool ret = sysfs_streq(name, dev->of_node->name); 1706 printk("%s custom_match_spi_dev %s %s %d\n", sdr_compatible_str,name, dev->of_node->name, ret); 1707 return ret; 1708 } 1709 1710 static int custom_match_platform_dev(struct device *dev, void *data) 1711 { 1712 struct platform_device *plat_dev = to_platform_device(dev); 1713 const char *name = data; 1714 char *name_in_sys_bus_platform_devices = strstr(plat_dev->name, name); 1715 bool match_flag = (name_in_sys_bus_platform_devices != NULL); 1716 1717 if (match_flag) { 1718 printk("%s custom_match_platform_dev %s\n", sdr_compatible_str,plat_dev->name); 1719 } 1720 return(match_flag); 1721 } 1722 1723 static int openwifi_dev_probe(struct platform_device *pdev) 1724 { 1725 struct ieee80211_hw *dev; 1726 struct openwifi_priv *priv; 1727 int err=1, rand_val; 1728 const char *chip_name, *fpga_model; 1729 u32 reg, i;//, reg1; 1730 1731 struct device_node *np = pdev->dev.of_node; 1732 1733 struct device *tmp_dev; 1734 struct platform_device *tmp_pdev; 1735 struct iio_dev *tmp_indio_dev; 1736 // struct gpio_leds_priv *tmp_led_priv; 1737 1738 printk("\n"); 1739 1740 if (np) { 1741 const struct of_device_id *match; 1742 1743 match = of_match_node(openwifi_dev_of_ids, np); 1744 if (match) { 1745 printk("%s openwifi_dev_probe: match!\n", sdr_compatible_str); 1746 err = 0; 1747 } 1748 } 1749 1750 if (err) 1751 return err; 1752 1753 dev = ieee80211_alloc_hw(sizeof(*priv), &openwifi_ops); 1754 if (!dev) { 1755 printk(KERN_ERR "%s openwifi_dev_probe: ieee80211 alloc failed\n",sdr_compatible_str); 1756 err = -ENOMEM; 1757 goto err_free_dev; 1758 } 1759 1760 priv = dev->priv; 1761 priv->pdev = pdev; 1762 1763 err = of_property_read_string(of_find_node_by_path("/"), "model", &fpga_model); 1764 if(err < 0) { 1765 printk("%s openwifi_dev_probe: WARNING unknown openwifi FPGA model %d\n",sdr_compatible_str, err); 1766 priv->fpga_type = SMALL_FPGA; 1767 } else { 1768 // LARGE FPGAs (i.e. ZCU102, Z7035, ZC706) 1769 if(strstr(fpga_model, "ZCU102") != NULL || strstr(fpga_model, "Z7035") != NULL || strstr(fpga_model, "ZC706") != NULL) 1770 priv->fpga_type = LARGE_FPGA; 1771 // SMALL FPGA: (i.e. ZED, ZC702, Z7020) 1772 else if(strstr(fpga_model, "ZED") != NULL || strstr(fpga_model, "ZC702") != NULL || strstr(fpga_model, "Z7020") != NULL) 1773 priv->fpga_type = SMALL_FPGA; 1774 } 1775 1776 // //-------------find ad9361-phy driver for lo/channel control--------------- 1777 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 1778 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 1779 tmp_dev = bus_find_device( &spi_bus_type, NULL, "ad9361-phy", custom_match_spi_dev ); 1780 if (tmp_dev == NULL) { 1781 printk(KERN_ERR "%s find_dev ad9361-phy failed\n",sdr_compatible_str); 1782 err = -ENODEV; 1783 goto err_free_dev; 1784 } 1785 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)); 1786 if (((struct spi_device*)tmp_dev)->dev.driver_data == NULL) { 1787 printk(KERN_ERR "%s find_dev ad9361-phy failed. dev.driver_data == NULL\n",sdr_compatible_str); 1788 err = -ENODEV; 1789 goto err_free_dev; 1790 } 1791 1792 priv->ad9361_phy = ad9361_spi_to_phy((struct spi_device*)tmp_dev); 1793 if (!(priv->ad9361_phy)) { 1794 printk(KERN_ERR "%s ad9361_spi_to_phy failed\n",sdr_compatible_str); 1795 err = -ENODEV; 1796 goto err_free_dev; 1797 } 1798 printk("%s ad9361_spi_to_phy ad9361-phy: %s\n", sdr_compatible_str, priv->ad9361_phy->spi->modalias); 1799 1800 // //-------------find driver: axi_ad9361 hdl ref design module, dac channel--------------- 1801 tmp_dev = bus_find_device( &platform_bus_type, NULL, "cf-ad9361-dds-core-lpc", custom_match_platform_dev ); 1802 if (!tmp_dev) { 1803 printk(KERN_ERR "%s bus_find_device platform_bus_type cf-ad9361-dds-core-lpc failed\n",sdr_compatible_str); 1804 err = -ENODEV; 1805 goto err_free_dev; 1806 } 1807 1808 tmp_pdev = to_platform_device(tmp_dev); 1809 if (!tmp_pdev) { 1810 printk(KERN_ERR "%s to_platform_device failed\n",sdr_compatible_str); 1811 err = -ENODEV; 1812 goto err_free_dev; 1813 } 1814 1815 tmp_indio_dev = platform_get_drvdata(tmp_pdev); 1816 if (!tmp_indio_dev) { 1817 printk(KERN_ERR "%s platform_get_drvdata failed\n",sdr_compatible_str); 1818 err = -ENODEV; 1819 goto err_free_dev; 1820 } 1821 1822 priv->dds_st = iio_priv(tmp_indio_dev); 1823 if (!(priv->dds_st)) { 1824 printk(KERN_ERR "%s iio_priv failed\n",sdr_compatible_str); 1825 err = -ENODEV; 1826 goto err_free_dev; 1827 } 1828 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); 1829 cf_axi_dds_datasel(priv->dds_st, -1, DATA_SEL_DMA); 1830 printk("%s openwifi_dev_probe: cf_axi_dds_datasel DATA_SEL_DMA\n",sdr_compatible_str); 1831 1832 // //-------------find driver: axi_ad9361 hdl ref design module, adc channel--------------- 1833 // turn off radio by muting tx 1834 // ad9361_tx_mute(priv->ad9361_phy, 1); 1835 // reg = ad9361_get_tx_atten(priv->ad9361_phy, 2); 1836 // reg1 = ad9361_get_tx_atten(priv->ad9361_phy, 1); 1837 // if (reg == AD9361_RADIO_OFF_TX_ATT && reg1 == AD9361_RADIO_OFF_TX_ATT ) { 1838 // priv->rfkill_off = 0;// 0 off, 1 on 1839 // printk("%s openwifi_dev_probe: rfkill radio off\n",sdr_compatible_str); 1840 // } 1841 // else 1842 // 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); 1843 1844 // //-----------------------------parse the test_mode input-------------------------------- 1845 if (test_mode&1) 1846 AGGR_ENABLE = true; 1847 1848 // if (test_mode&2) 1849 // TX_OFFSET_TUNING_ENABLE = false; 1850 1851 priv->rssi_correction = rssi_correction_lookup_table(5220);//5220MHz. this will be set in real-time by _rf_set_channel() 1852 priv->last_auto_fpga_lbt_th = rssi_dbm_to_rssi_half_db(-78, priv->rssi_correction);//-78dBm. a magic value. just to avoid uninitialized 1853 1854 //priv->rf_bw = 20000000; // Signal quality issue! NOT use for now. 20MHz or 40MHz. 40MHz need ddc/duc. 20MHz works in bypass mode 1855 priv->rf_bw = 40000000; // 20MHz or 40MHz. 40MHz need ddc/duc. 20MHz works in bypass mode 1856 1857 priv->xpu_cfg = XPU_NORMAL; 1858 1859 priv->openofdm_tx_cfg = OPENOFDM_TX_NORMAL; 1860 priv->openofdm_rx_cfg = OPENOFDM_RX_NORMAL; 1861 1862 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) ); 1863 if (priv->rf_bw == 20000000) { //DO NOT USE. Not used for long time. 1864 priv->rx_intf_cfg = RX_INTF_BYPASS; 1865 priv->tx_intf_cfg = TX_INTF_BYPASS; 1866 //priv->rx_freq_offset_to_lo_MHz = 0; 1867 //priv->tx_freq_offset_to_lo_MHz = 0; 1868 } else if (priv->rf_bw == 40000000) { 1869 //priv->rx_intf_cfg = RX_INTF_BW_20MHZ_AT_P_10MHZ; //work 1870 //priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT1; //work 1871 1872 // // 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 1873 priv->rx_intf_cfg = RX_INTF_BW_20MHZ_AT_0MHZ_ANT0; 1874 if (TX_OFFSET_TUNING_ENABLE) 1875 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 1876 else 1877 priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_0MHZ_ANT0; 1878 // // try another antenna option 1879 //priv->rx_intf_cfg = RX_INTF_BW_20MHZ_AT_0MHZ_ANT1; 1880 //priv->tx_intf_cfg = TX_INTF_BW_20MHZ_AT_N_10MHZ_ANT0; 1881 1882 #if 0 1883 if (priv->rx_intf_cfg == DDC_BW_20MHZ_AT_N_10MHZ) { 1884 priv->rx_freq_offset_to_lo_MHz = -10; 1885 } else if (priv->rx_intf_cfg == DDC_BW_20MHZ_AT_P_10MHZ) { 1886 priv->rx_freq_offset_to_lo_MHz = 10; 1887 } else if (priv->rx_intf_cfg == DDC_BW_20MHZ_AT_0MHZ) { 1888 priv->rx_freq_offset_to_lo_MHz = 0; 1889 } else { 1890 printk("%s openwifi_dev_probe: Warning! priv->rx_intf_cfg == %d\n",sdr_compatible_str,priv->rx_intf_cfg); 1891 } 1892 #endif 1893 } else { 1894 printk("%s openwifi_dev_probe: Warning! priv->rf_bw == %dHz (should be 20000000 or 40000000)\n",sdr_compatible_str, priv->rf_bw); 1895 err = -EBADRQC; 1896 goto err_free_dev; 1897 } 1898 1899 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); 1900 1901 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)); 1902 priv->runtime_rx_ant_cfg = (priv->rx_intf_cfg==RX_INTF_BW_20MHZ_AT_0MHZ_ANT0?1:2); 1903 1904 priv->ctrl_out.en_mask=AD9361_CTRL_OUT_EN_MASK; 1905 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); 1906 1907 memset(priv->drv_rx_reg_val,0,sizeof(priv->drv_rx_reg_val)); 1908 memset(priv->drv_tx_reg_val,0,sizeof(priv->drv_tx_reg_val)); 1909 memset(priv->drv_xpu_reg_val,0,sizeof(priv->drv_xpu_reg_val)); 1910 memset(priv->rf_reg_val,0,sizeof(priv->rf_reg_val)); 1911 1912 priv->rf_reg_val[RF_TX_REG_IDX_ATT] = init_tx_att; 1913 1914 //let's by default turn radio on when probing 1915 err = openwifi_set_antenna(dev, priv->runtime_tx_ant_cfg, priv->runtime_rx_ant_cfg); 1916 if (err) { 1917 printk("%s openwifi_dev_probe: WARNING openwifi_set_antenna FAIL %d\n",sdr_compatible_str, err); 1918 err = -EIO; 1919 goto err_free_dev; 1920 } 1921 reg = ad9361_spi_read(priv->ad9361_phy->spi, REG_CTRL_OUTPUT_POINTER); 1922 printk("%s openwifi_dev_probe: ad9361_spi_read REG_CTRL_OUTPUT_POINTER 0x%02x\n",sdr_compatible_str, reg); 1923 reg = ad9361_spi_read(priv->ad9361_phy->spi, REG_CTRL_OUTPUT_ENABLE); 1924 printk("%s openwifi_dev_probe: ad9361_spi_read REG_CTRL_OUTPUT_ENABLE 0x%02x\n",sdr_compatible_str, reg); 1925 1926 reg = ad9361_get_tx_atten(priv->ad9361_phy, ((priv->runtime_tx_ant_cfg==1 || priv->runtime_tx_ant_cfg==3)?1:2)); 1927 if (reg == (AD9361_RADIO_ON_TX_ATT+priv->rf_reg_val[RF_TX_REG_IDX_ATT])) { 1928 priv->rfkill_off = 1;// 0 off, 1 on 1929 printk("%s openwifi_dev_probe: rfkill radio on\n",sdr_compatible_str); 1930 } else 1931 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]); 1932 1933 priv->drv_xpu_reg_val[DRV_XPU_REG_IDX_GIT_REV] = GIT_REV; 1934 1935 // //set ad9361 in certain mode 1936 #if 0 1937 err = ad9361_set_trx_clock_chain_freq(priv->ad9361_phy,priv->rf_bw); 1938 printk("%s openwifi_dev_probe: ad9361_set_trx_clock_chain_freq %dHz err %d\n",sdr_compatible_str, priv->rf_bw,err); 1939 err = ad9361_update_rf_bandwidth(priv->ad9361_phy,priv->rf_bw,priv->rf_bw); 1940 printk("%s openwifi_dev_probe: ad9361_update_rf_bandwidth %dHz err %d\n",sdr_compatible_str, priv->rf_bw,err); 1941 1942 rx_intf_api->hw_init(priv->rx_intf_cfg,8,8); 1943 tx_intf_api->hw_init(priv->tx_intf_cfg,8,8,priv->fpga_type); 1944 openofdm_tx_api->hw_init(priv->openofdm_tx_cfg); 1945 openofdm_rx_api->hw_init(priv->openofdm_rx_cfg); 1946 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); 1947 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); 1948 #endif 1949 1950 dev->max_rates = 1; //maximum number of alternate rate retry stages the hw can handle. 1951 1952 SET_IEEE80211_DEV(dev, &pdev->dev); 1953 platform_set_drvdata(pdev, dev); 1954 1955 BUILD_BUG_ON(sizeof(priv->rates_2GHz) != sizeof(openwifi_2GHz_rates)); 1956 BUILD_BUG_ON(sizeof(priv->rates_5GHz) != sizeof(openwifi_5GHz_rates)); 1957 BUILD_BUG_ON(sizeof(priv->channels_2GHz) != sizeof(openwifi_2GHz_channels)); 1958 BUILD_BUG_ON(sizeof(priv->channels_5GHz) != sizeof(openwifi_5GHz_channels)); 1959 1960 memcpy(priv->rates_2GHz, openwifi_2GHz_rates, sizeof(openwifi_2GHz_rates)); 1961 memcpy(priv->rates_5GHz, openwifi_5GHz_rates, sizeof(openwifi_5GHz_rates)); 1962 memcpy(priv->channels_2GHz, openwifi_2GHz_channels, sizeof(openwifi_2GHz_channels)); 1963 memcpy(priv->channels_5GHz, openwifi_5GHz_channels, sizeof(openwifi_5GHz_channels)); 1964 1965 priv->band = BAND_5_8GHZ; //this can be changed by band _rf_set_channel() (2.4GHz ERP(OFDM)) (5GHz OFDM) 1966 priv->channel = 44; //currently useless. this can be changed by band _rf_set_channel() 1967 priv->use_short_slot = false; //this can be changed by openwifi_bss_info_changed: BSS_CHANGED_ERP_SLOT 1968 priv->ampdu_reference = 0; 1969 1970 priv->band_2GHz.band = NL80211_BAND_2GHZ; 1971 priv->band_2GHz.channels = priv->channels_2GHz; 1972 priv->band_2GHz.n_channels = ARRAY_SIZE(priv->channels_2GHz); 1973 priv->band_2GHz.bitrates = priv->rates_2GHz; 1974 priv->band_2GHz.n_bitrates = ARRAY_SIZE(priv->rates_2GHz); 1975 priv->band_2GHz.ht_cap.ht_supported = true; 1976 // priv->band_2GHz.ht_cap.cap = IEEE80211_HT_CAP_SGI_20; //SGI -- short GI seems bring unnecessary stability issue 1977 if (AGGR_ENABLE) { 1978 priv->band_2GHz.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K; 1979 priv->band_2GHz.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_2; 1980 } 1981 memset(&priv->band_2GHz.ht_cap.mcs, 0, sizeof(priv->band_2GHz.ht_cap.mcs)); 1982 priv->band_2GHz.ht_cap.mcs.rx_mask[0] = 0xff; 1983 priv->band_2GHz.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 1984 dev->wiphy->bands[NL80211_BAND_2GHZ] = &(priv->band_2GHz); 1985 1986 priv->band_5GHz.band = NL80211_BAND_5GHZ; 1987 priv->band_5GHz.channels = priv->channels_5GHz; 1988 priv->band_5GHz.n_channels = ARRAY_SIZE(priv->channels_5GHz); 1989 priv->band_5GHz.bitrates = priv->rates_5GHz; 1990 priv->band_5GHz.n_bitrates = ARRAY_SIZE(priv->rates_5GHz); 1991 priv->band_5GHz.ht_cap.ht_supported = true; 1992 // priv->band_5GHz.ht_cap.cap = IEEE80211_HT_CAP_SGI_20; //SGI -- short GI seems bring unnecessary stability issue 1993 if (AGGR_ENABLE) { 1994 priv->band_5GHz.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K; 1995 priv->band_5GHz.ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_2; 1996 } 1997 memset(&priv->band_5GHz.ht_cap.mcs, 0, sizeof(priv->band_5GHz.ht_cap.mcs)); 1998 priv->band_5GHz.ht_cap.mcs.rx_mask[0] = 0xff; 1999 priv->band_5GHz.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 2000 dev->wiphy->bands[NL80211_BAND_5GHZ] = &(priv->band_5GHz); 2001 2002 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, 2003 priv->band_2GHz.n_channels,priv->band_2GHz.n_bitrates,priv->band_5GHz.n_channels,priv->band_5GHz.n_bitrates); 2004 2005 // 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() 2006 ieee80211_hw_set(dev, RX_INCLUDES_FCS); 2007 ieee80211_hw_set(dev, BEACON_TX_STATUS);//mac80211.h: The device/driver provides TX status for sent beacons. 2008 2009 ieee80211_hw_set(dev, REPORTS_TX_ACK_STATUS);//mac80211.h: Hardware can provide ack status reports of Tx frames to the stack 2010 2011 // * @IEEE80211_HW_AP_LINK_PS: When operating in AP mode the device 2012 // * autonomously manages the PS status of connected stations. When 2013 // * this flag is set mac80211 will not trigger PS mode for connected 2014 // * stations based on the PM bit of incoming frames. 2015 // * Use ieee80211_start_ps()/ieee8021_end_ps() to manually configure 2016 // * the PS mode of connected stations. 2017 ieee80211_hw_set(dev, AP_LINK_PS); 2018 2019 if (AGGR_ENABLE) { 2020 ieee80211_hw_set(dev, AMPDU_AGGREGATION); 2021 } 2022 2023 dev->extra_tx_headroom = LEN_MPDU_DELIM; 2024 2025 dev->vif_data_size = sizeof(struct openwifi_vif); 2026 dev->wiphy->interface_modes = 2027 BIT(NL80211_IFTYPE_MONITOR)| 2028 BIT(NL80211_IFTYPE_P2P_GO) | 2029 BIT(NL80211_IFTYPE_P2P_CLIENT) | 2030 BIT(NL80211_IFTYPE_AP) | 2031 BIT(NL80211_IFTYPE_STATION) | 2032 BIT(NL80211_IFTYPE_ADHOC) | 2033 BIT(NL80211_IFTYPE_MESH_POINT) | 2034 BIT(NL80211_IFTYPE_OCB); 2035 dev->wiphy->iface_combinations = &openwifi_if_comb; 2036 dev->wiphy->n_iface_combinations = 1; 2037 2038 dev->wiphy->available_antennas_tx = NUM_TX_ANT_MASK; 2039 dev->wiphy->available_antennas_rx = NUM_RX_ANT_MASK; 2040 2041 dev->wiphy->regulatory_flags = (REGULATORY_STRICT_REG|REGULATORY_CUSTOM_REG); // use our own config within strict regulation 2042 //dev->wiphy->regulatory_flags = REGULATORY_CUSTOM_REG; // use our own config 2043 wiphy_apply_custom_regulatory(dev->wiphy, &sdr_regd); 2044 2045 chip_name = "ZYNQ"; 2046 2047 /* we declare to MAC80211 all the queues except for beacon queue 2048 * that will be eventually handled by DRV. 2049 * TX rings are arranged in such a way that lower is the IDX, 2050 * higher is the priority, in order to achieve direct mapping 2051 * with mac80211, however the beacon queue is an exception and it 2052 * is mapped on the highst tx ring IDX. 2053 */ 2054 dev->queues = MAX_NUM_HW_QUEUE; 2055 //dev->queues = 1; 2056 2057 ieee80211_hw_set(dev, SIGNAL_DBM); 2058 2059 wiphy_ext_feature_set(dev->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 2060 2061 priv->rf = &ad9361_rf_ops; 2062 2063 memset(priv->dest_mac_addr_queue_map,0,sizeof(priv->dest_mac_addr_queue_map)); 2064 priv->slice_idx = 0xFFFFFFFF; 2065 2066 sg_init_table(&(priv->tx_sg), 1); 2067 2068 get_random_bytes(&rand_val, sizeof(rand_val)); 2069 rand_val%=250; 2070 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; 2071 priv->mac_addr[5]=rand_val+1; 2072 //priv->mac_addr[5]=0x11; 2073 if (!is_valid_ether_addr(priv->mac_addr)) { 2074 printk(KERN_WARNING "%s openwifi_dev_probe: WARNING Invalid hwaddr! Using randomly generated MAC addr\n",sdr_compatible_str); 2075 eth_random_addr(priv->mac_addr); 2076 } 2077 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]); 2078 SET_IEEE80211_PERM_ADDR(dev, priv->mac_addr); 2079 2080 spin_lock_init(&priv->lock); 2081 2082 err = ieee80211_register_hw(dev); 2083 if (err) { 2084 pr_err(KERN_ERR "%s openwifi_dev_probe: WARNING Cannot register device\n",sdr_compatible_str); 2085 err = -EIO; 2086 goto err_free_dev; 2087 } else { 2088 printk("%s openwifi_dev_probe: ieee80211_register_hw %d\n",sdr_compatible_str, err); 2089 } 2090 2091 // // //--------------------hook leds (not complete yet)-------------------------------- 2092 // tmp_dev = bus_find_device( &platform_bus_type, NULL, "leds", custom_match_platform_dev ); //leds is the name in devicetree, not "compatible" field 2093 // if (!tmp_dev) { 2094 // printk(KERN_ERR "%s bus_find_device platform_bus_type leds-gpio failed\n",sdr_compatible_str); 2095 // err = -ENOMEM; 2096 // goto err_free_dev; 2097 // } 2098 2099 // tmp_pdev = to_platform_device(tmp_dev); 2100 // if (!tmp_pdev) { 2101 // printk(KERN_ERR "%s to_platform_device failed for leds-gpio\n",sdr_compatible_str); 2102 // err = -ENOMEM; 2103 // goto err_free_dev; 2104 // } 2105 2106 // tmp_led_priv = platform_get_drvdata(tmp_pdev); 2107 // if (!tmp_led_priv) { 2108 // printk(KERN_ERR "%s platform_get_drvdata failed for leds-gpio\n",sdr_compatible_str); 2109 // err = -ENOMEM; 2110 // goto err_free_dev; 2111 // } 2112 // printk("%s openwifi_dev_probe: leds-gpio detect %d leds!\n",sdr_compatible_str, tmp_led_priv->num_leds); 2113 // if (tmp_led_priv->num_leds!=4){ 2114 // printk(KERN_ERR "%s WARNING we expect 4 leds, but actual %d leds\n",sdr_compatible_str,tmp_led_priv->num_leds); 2115 // err = -ENOMEM; 2116 // goto err_free_dev; 2117 // } 2118 // gpiod_set_value(tmp_led_priv->leds[0].gpiod, 1);//light it 2119 // gpiod_set_value(tmp_led_priv->leds[3].gpiod, 0);//black it 2120 // priv->num_led = tmp_led_priv->num_leds; 2121 // priv->led[0] = &(tmp_led_priv->leds[0].cdev); 2122 // priv->led[1] = &(tmp_led_priv->leds[1].cdev); 2123 // priv->led[2] = &(tmp_led_priv->leds[2].cdev); 2124 // priv->led[3] = &(tmp_led_priv->leds[3].cdev); 2125 2126 // snprintf(priv->led_name[0], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::radio", wiphy_name(dev->wiphy)); 2127 // snprintf(priv->led_name[1], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::assoc", wiphy_name(dev->wiphy)); 2128 // snprintf(priv->led_name[2], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::tx", wiphy_name(dev->wiphy)); 2129 // snprintf(priv->led_name[3], OPENWIFI_LED_MAX_NAME_LEN, "openwifi-%s::rx", wiphy_name(dev->wiphy)); 2130 2131 wiphy_info(dev->wiphy, "hwaddr %pm, %s + %s\n", 2132 priv->mac_addr, chip_name, priv->rf->name); 2133 2134 openwifi_rfkill_init(dev); 2135 return 0; 2136 2137 err_free_dev: 2138 ieee80211_free_hw(dev); 2139 2140 return err; 2141 } 2142 2143 static int openwifi_dev_remove(struct platform_device *pdev) 2144 { 2145 struct ieee80211_hw *dev = platform_get_drvdata(pdev); 2146 2147 if (!dev) { 2148 pr_info("%s openwifi_dev_remove: dev %p\n", sdr_compatible_str, (void*)dev); 2149 return(-1); 2150 } 2151 2152 openwifi_rfkill_exit(dev); 2153 ieee80211_unregister_hw(dev); 2154 ieee80211_free_hw(dev); 2155 return(0); 2156 } 2157 2158 static struct platform_driver openwifi_dev_driver = { 2159 .driver = { 2160 .name = "sdr,sdr", 2161 .owner = THIS_MODULE, 2162 .of_match_table = openwifi_dev_of_ids, 2163 }, 2164 .probe = openwifi_dev_probe, 2165 .remove = openwifi_dev_remove, 2166 }; 2167 2168 module_platform_driver(openwifi_dev_driver); 2169