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