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