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