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