Changes between Version 11 and Version 12 of 802.11/app_notes/FDD-NoMAC

Timestamp:

Feb 15, 2017, 11:16:31 AM (7 years ago)

Author:

chunter

Comment:

--

802.11/app_notes/FDD-NoMAC

@@ -152 +152 @@
 Finally the NoMAC application must be modified to support simultaneous Tx and Rx operations. In the reference code NoMAC implements two callback functions, {{{frame_transmit()}}} and {{{frame_receive()}}}. The lower MAC framework calls these functions to handle new Tx and Rx events. By default these callbacks block during a Tx/Rx event until the corresponding PHY event is complete. In order to support FDD operation these functions must be generalized to not block during PHY events. Instead the callbacks are responsible for starting the Tx/Rx processing and new functions are implemented to finish Tx/Rx processing.
 
-'''TODO'''
+Fundamentally, FDD changes NoMAC so that Tx and Rx events no longer occur in complete atomic contexts. The NoMAC code still has to operate serially while the Tx and Rx operations operate in parallels. We will need a few new global variables to help us track whether we are currently transmitting and/or receiving and, if so, which packet buffers are currently being used. Add the following to the top of {{{wlan_mac_nomac.c}}}:
+
+{{{#!c
+typedef enum {TX_STATE_IDLE, TX_STATE_PENDING} tx_state_t;
+typedef enum {RX_STATE_IDLE, RX_STATE_PENDING} rx_state_t;
+
+tx_state_t                                                         tx_state;
+u8                                                                         pending_tx_pkt_buf;
+rx_state_t                                                         rx_state;
+u8                                                                         pending_rx_pkt_buf;
+}}}
+
+Next, we will update the ```frame_transmit()``` function such that it immediately returns after submitting the packet to the MAC Tx Controller rather than wait for the PHY to finish. Replace ```frame_transmit()``` with the following:
+
+{{{#!c
+int frame_transmit(u8 pkt_buf) {
+    // The pkt_buf, rate, and length arguments provided to this function specifically relate to
+    // the MPDU that the WLAN MAC LOW framework wants to send.
+
+    u8 tx_gain;
+
+    tx_state = TX_STATE_PENDING;
+    pending_tx_pkt_buf = pkt_buf;
+
+    tx_frame_info_t   * tx_frame_info       = (tx_frame_info_t*) (TX_PKT_BUF_TO_ADDR(pkt_buf));
+    u8                  mpdu_tx_ant_mask    = 0;
+
+    // Extract waveform params from the tx_frame_info
+    u8  mcs      = tx_frame_info->params.phy.mcs;
+    u8  phy_mode = (tx_frame_info->params.phy.phy_mode & (PHY_MODE_HTMF | PHY_MODE_NONHT));
+    u16 length   = tx_frame_info->length;
+
+    // Write the PHY premable (SIGNAL or L-SIG/HT-SIG) to the packet buffer
+    write_phy_preamble(pkt_buf, phy_mode, mcs, length);
+
+    // Set the antenna mode
+    switch(tx_frame_info->params.phy.antenna_mode) {
+        case TX_ANTMODE_SISO_ANTA:  mpdu_tx_ant_mask |= 0x1;  break;
+        case TX_ANTMODE_SISO_ANTB:  mpdu_tx_ant_mask |= 0x2;  break;
+        case TX_ANTMODE_SISO_ANTC:  mpdu_tx_ant_mask |= 0x4;  break;
+        case TX_ANTMODE_SISO_ANTD:  mpdu_tx_ant_mask |= 0x8;  break;
+        default:                    mpdu_tx_ant_mask  = 0x1;  break;      // Default to RF_A
+    }
+
+    // Fill in the number of attempts to transmit the packet
+    tx_frame_info->num_tx_attempts  = 1;
+
+    // Update tx_frame_info with current PHY sampling rate
+    tx_frame_info->phy_samp_rate        = (u8)wlan_mac_low_get_phy_samp_rate();
+
+    // Convert the requested Tx power (dBm) to a Tx gain setting for the radio
+    tx_gain = wlan_mac_low_dbm_to_gain_target(tx_frame_info->params.phy.power);
+
+    // Set the MAC HW control parameters
+    //  args: (pktBuf, antMask, preTx_backoff_slots, preWait_postRxTimer1, preWait_postTxTimer1, postWait_postTxTimer2, phy_mode)
+    wlan_mac_tx_ctrl_A_params(pkt_buf, mpdu_tx_ant_mask, 0, 0, 0, 0, phy_mode);
+
+    // Set Tx Gains - use same gain for all RF interfaces
+    wlan_mac_tx_ctrl_A_gains(tx_gain, tx_gain, tx_gain, tx_gain);
+
+    // Before we mess with any PHY state, we need to make sure it isn't actively
+    //  transmitting. For example, it may be sending an ACK when we get to this part of the code
+    while (wlan_mac_get_status() & WLAN_MAC_STATUS_MASK_TX_PHY_ACTIVE) {}
+
+    // Submit the MPDU for transmission - this starts the MAC hardware's MPDU Tx state machine
+    wlan_mac_tx_ctrl_A_start(1);
+    wlan_mac_tx_ctrl_A_start(0);
+
+    return TX_FRAME_INFO_RESULT_SUCCESS;
+}
+}}}
+
+Now we need a function that will "finish" the transmission with everything that used to take place after {{{wlan_mac_tx_ctrl_A_start()}}} from NoMAC's original {{{frame_transmit()}}}. This function should poll the status of the transmission and immediately quit if the transmission is still ongoing. Add the following function to {{{wlan_mac_nomac.c}}} and be sure to add a new declaration for it in the header file:
+
+{{{#!c
+void finish_frame_transmit(){
+        wlan_mac_low_tx_details_t low_tx_details = {0};
+    u32 mac_tx_ctrl_status;
+
+    tx_frame_info_t   * tx_frame_info       = (tx_frame_info_t*) (TX_PKT_BUF_TO_ADDR(pending_tx_pkt_buf));
+
+    // Extract waveform params from the tx_frame_info
+    u8  mcs      = tx_frame_info->params.phy.mcs;
+    u8  phy_mode = (tx_frame_info->params.phy.phy_mode & (PHY_MODE_HTMF | PHY_MODE_NONHT));
+
+    // Get the MAC HW status
+        mac_tx_ctrl_status = wlan_mac_get_tx_ctrl_status();
+
+        if(mac_tx_ctrl_status & WLAN_MAC_TXCTRL_STATUS_MASK_TX_A_DONE){
+
+            // Fill in the Tx low details
+                low_tx_details.phy_params_mpdu.mcs          = mcs;
+                low_tx_details.phy_params_mpdu.phy_mode     = phy_mode;
+                low_tx_details.phy_params_mpdu.power        = tx_frame_info->params.phy.power;
+                low_tx_details.phy_params_mpdu.antenna_mode = tx_frame_info->params.phy.antenna_mode;
+                low_tx_details.chan_num                     = wlan_mac_low_get_active_channel();
+                low_tx_details.num_slots                    = 0;
+                low_tx_details.cw                           = 0;
+                low_tx_details.attempt_number                           = 1;
+                low_tx_details.tx_start_timestamp_mpdu = wlan_mac_low_get_tx_start_timestamp();
+                low_tx_details.tx_start_timestamp_frac_mpdu = wlan_mac_low_get_tx_start_timestamp_frac();
+                low_tx_details.tx_details_type                          = TX_DETAILS_MPDU;
+
+                // Send IPC message containing the details about this low-level transmission
+                wlan_mac_low_send_low_tx_details(pending_tx_pkt_buf, &low_tx_details);
+                wlan_mac_low_finish_frame_transmit(pending_tx_pkt_buf);
+                tx_state = TX_STATE_IDLE;
+        }
+}
+}}}
+
+Next, we need to perform a similar dissection of the {{{frame_receive()}}} context to quit early before the reception has finished. Note: it is important to return the value {{{FRAME_RX_RET_SKIP_RX_STARTED_RESET}}} from this context to prevent the MAC Low Framework from resetting the PHY while the reception is still ongoing. Replace {{{frame_receive()}}} with the following:
+
+{{{#!c
+u32 frame_receive(u8 rx_pkt_buf, phy_rx_details_t* phy_details){
+
+    void              * pkt_buf_addr        = (void *) RX_PKT_BUF_TO_ADDR(rx_pkt_buf);
+    rx_frame_info_t   * rx_frame_info       = (rx_frame_info_t *) pkt_buf_addr;
+
+    rx_state = RX_STATE_PENDING;
+    pending_rx_pkt_buf = rx_pkt_buf;
+
+    // Fill in the MPDU info fields for the reception. These values are known at RX_START. The other fields below
+    //  must be written after RX_END
+    rx_frame_info->flags          = 0;
+    rx_frame_info->phy_details    = *phy_details;
+    rx_frame_info->channel        = wlan_mac_low_get_active_channel();
+    rx_frame_info->phy_samp_rate  = (u8)wlan_mac_low_get_phy_samp_rate();
+    rx_frame_info->timestamp      = wlan_mac_low_get_rx_start_timestamp();
+    rx_frame_info->timestamp_frac = wlan_mac_low_get_rx_start_timestamp_frac();
+
+    return FRAME_RX_RET_SKIP_RX_STARTED_RESET;
+}
+}}}
+
+Next, we need to finish the frame reception in another function. Like {{{finish_frame_transmit()}}} from above, this function should immediately quit if the PHY is still receiving a frame. Add the following function to {{{wlan_mac_nomac.c}}} and declare it in NoMAC's header:
+
+{{{
+#!c
+void finish_frame_receive(){
+
+    void              * pkt_buf_addr        = (void *) RX_PKT_BUF_TO_ADDR(pending_rx_pkt_buf);
+    rx_frame_info_t   * rx_frame_info       = (rx_frame_info_t *) pkt_buf_addr;
+
+        u32 mac_hw_status = wlan_mac_get_status();
+
+        if(mac_hw_status & (WLAN_MAC_STATUS_MASK_RX_PHY_ACTIVE | WLAN_MAC_STATUS_MASK_RX_PHY_WRITING_PAYLOAD)){
+                // The PHY is not finished receiving. Jump back to main()
+                return;
+        } else {
+
+                if(wlan_mac_hw_rx_finish() == 1){
+                        //FCS was good
+                        rx_frame_info->flags |= RX_FRAME_INFO_FLAGS_FCS_GOOD;
+                } else {
+                        //FCS was bad
+                        rx_frame_info->flags &= ~RX_FRAME_INFO_FLAGS_FCS_GOOD;
+                }
+
+                // Update the rest of the frame_info fields using post-Rx information
+                rx_frame_info->ant_mode = wlan_phy_rx_get_active_rx_ant();
+                rx_frame_info->cfo_est  = wlan_phy_rx_get_cfo_est();
+                rx_frame_info->rf_gain  = wlan_phy_rx_get_agc_RFG(rx_frame_info->ant_mode);
+                rx_frame_info->bb_gain  = wlan_phy_rx_get_agc_BBG(rx_frame_info->ant_mode);
+                rx_frame_info->rx_power = wlan_mac_low_calculate_rx_power(wlan_phy_rx_get_pkt_rssi(rx_frame_info->ant_mode), wlan_phy_rx_get_agc_RFG(rx_frame_info->ant_mode));
+
+                // Increment the LEDs based on the FCS status
+                if(rx_frame_info->flags & RX_FRAME_INFO_FLAGS_FCS_GOOD){
+                        green_led_index = (green_led_index + 1) % NUM_LEDS;
+                        userio_write_leds_green(USERIO_BASEADDR, (1 << green_led_index));
+                } else {
+                        red_led_index = (red_led_index + 1) % NUM_LEDS;
+                        userio_write_leds_red(USERIO_BASEADDR, (1 << red_led_index));
+                }
+
+                rx_frame_info->rx_pkt_buf_state = RX_PKT_BUF_READY;
+                if (unlock_rx_pkt_buf(pending_rx_pkt_buf) != PKT_BUF_MUTEX_SUCCESS) {
+                        xil_printf("Error: unable to unlock RX pkt_buf %d\n", pending_rx_pkt_buf);
+                        wlan_mac_low_send_exception(WLAN_ERROR_CODE_CPU_LOW_RX_MUTEX);
+                } else {
+
+                        wlan_mac_low_frame_ipc_send();
+
+                        // Find a free packet buffer and begin receiving packets there (blocks until free buf is found)
+                        wlan_mac_low_lock_empty_rx_pkt_buf();
+                }
+
+                wlan_mac_hw_clear_rx_started(); //FDD-NoMAC
+                rx_state = RX_STATE_IDLE;
+        }
+}
+}}}
+
+Finally, we will call our new functions for finishing Tx or Rx events from the primary while loop in {{{main()}}}. Replace the existing while loop with the following:
+
+{{{#!c
+    while(1){
+        switch(rx_state){
+                case RX_STATE_IDLE:
+                        // Poll PHY RX start
+                                wlan_mac_low_poll_frame_rx();
+                break;
+                case RX_STATE_PENDING:
+                        finish_frame_receive();
+                        break;
+        }
+
+        switch(tx_state){
+                        case TX_STATE_IDLE:
+                                // Poll IPC rx for a new tx packet
+                                wlan_mac_low_poll_ipc_rx();
+                        break;
+                        case TX_STATE_PENDING:
+                                //Finish any ongoing transmission
+                                finish_frame_transmit();
+                        break;
+        }
+    }
+}}}
+
+----
+
+=== 4. Evaluation with Experiments Framework ===
 
 ----