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