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