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