Changes between Version 10 and Version 11 of 802.11/wlan_exp/app_notes/tutorial_token_mac/CPU_LOW

Timestamp:

Jul 10, 2015, 2:06:11 PM (9 years ago)

Author:

chunter

Comment:

--

802.11/wlan_exp/app_notes/tutorial_token_mac/CPU_LOW

@@ -365 +365 @@
 #!c
 
+#define POLL_MAC_STATUS_TOKEN_OFFER_ACCEPTED 0x10000000
 void token_new_reservation(ipc_token_new_reservation* new_reservation){
 
@@ -517 +518 @@
 }
 
+}}}
+
 Now we need to call the new function whenever we can. In the primary {{{while(1)}}} loop of the {{{main()}}} function of NoMAC, simply add a call to {{{poll_reservation_time()}}}.
 
 ----
 
-{{{
-#!c
-
-}}}
-
-----
-}}}
+Next, we need to change the {{{frame_receive()}}} function of the to deal with two potential kinds of receptions:
+
+1. If we are a STA, we could expect to receive a token offer from the AP. If we do, we should respond with a token response before the AP times out on the offer. After sending the token response, we know that we have entered a token reservation period so we should allow the transmission of new MPDUs and set the {{{reservation_ts_end}}} variable to represent the time when our token reservation period ends.
+2. If we are an AP, we could expect to receive a token response from other STAs. If we do, we need to let the {{{token_new_reservation()}}} context know that we did. Note in a previous change that {{{token_new_reservation()}}} actively looks for a {{{POLL_MAC_STATUS_TOKEN_OFFER_ACCEPTED}}} flag to be returned from the receive context. We should raise this flag.
+
+The following function is a drop-in replacement to the existing {{{frame_receive function}}} that implements the above behavior:
+
+{{{
+#!c
+
+u32 frame_receive(u8 rx_pkt_buf, phy_rx_details* phy_details){
+        //This function is called after a good SIGNAL field is detected by either PHY (OFDM or DSSS)
+        //It is the responsibility of this function to wait until a sufficient number of bytes have been received
+        // before it can start to process those bytes. When this function is called the eventual checksum status is
+        // unknown. The packet contents can be provisionally processed (e.g. prepare an ACK for fast transmission),
+        // but post-reception actions must be conditioned on the eventual FCS status (good or bad).
+        //
+        // Note: The timing of this function is critical for correct operation of the 802.11 DCF. It is not
+        // safe to add large delays to this function (e.g. xil_printf or usleep)
+        //
+        //Two primary job responsibilities of this function:
+        // (1): Prepare outgoing ACK packets and instruct the MAC_DCF_HW core whether or not to send ACKs
+        // (2): Pass up MPDUs (FCS valid or invalid) to CPU_HIGH
+
+        u8 unicast_to_me;
+        mac_header_80211* rx_header;
+        mac_frame_custom_token* rx_token_frame;
+        u8 ctrl_tx_gain;
+        u32 tx_length;
+        u32 return_value = 0;
+        u32 mac_hw_status;
+        wlan_ipc_msg       ipc_msg_to_high_start;
+        ipc_token_new_reservation ipc_payload_start;
+
+        ipc_msg_to_high_start.msg_id            = IPC_MBOX_MSG_ID(IPC_MBOX_TOKEN_NEW_RESERVATION);
+
+        if( (sizeof(u32)*(sizeof(ipc_token_new_reservation)/sizeof(u32))) ==  sizeof(ipc_token_new_reservation) ){
+                ipc_msg_to_high_start.num_payload_words = (sizeof(ipc_token_new_reservation)/sizeof(u32));
+        } else {
+                ipc_msg_to_high_start.num_payload_words = (sizeof(ipc_token_new_reservation)/sizeof(u32)) + 1;
+        }
+
+        ipc_msg_to_high_start.payload_ptr       = (u32*)(&ipc_payload_start);
+
+        rx_frame_info* mpdu_info;
+        void* pkt_buf_addr = (void *)RX_PKT_BUF_TO_ADDR(rx_pkt_buf);
+
+        mpdu_info = (rx_frame_info*)pkt_buf_addr;
+
+        rx_header = (mac_header_80211*)((void*)(pkt_buf_addr + PHY_RX_PKT_BUF_MPDU_OFFSET));
+
+        //Wait until the PHY has written enough bytes so that the first address field can be processed
+        while(wlan_mac_get_last_byte_index() < MAC_HW_LASTBYTE_TOKEN){
+        };
+
+        unicast_to_me = wlan_addr_eq(rx_header->address_1, eeprom_addr);
+
+        if(unicast_to_me && (rx_header->frame_control_1 == MAC_FRAME_CTRL1_SUBTYPE_TOKEN_OFFER)){
+                //Received a token offer
+                rx_token_frame = (mac_frame_custom_token*)rx_header;
+
+                //Set up a Token Response
+                //wlan_mac_tx_ctrl_B_params(pktBuf, antMask, req_zeroNAV, preWait_postRxTimer1, preWait_postRxTimer2, postWait_postTxTimer1)
+                wlan_mac_tx_ctrl_B_params(TX_PKT_BUF_TOKEN, 0x1, 0, 1, 0, 0);
+
+                //ACKs are transmitted with a nominal Tx power used for all control packets
+                ctrl_tx_gain = wlan_mac_low_dbm_to_gain_target(15);
+                wlan_mac_tx_ctrl_B_gains(ctrl_tx_gain, ctrl_tx_gain, ctrl_tx_gain, ctrl_tx_gain);
+
+                //Construct the token response frame in the dedicated Tx pkt buf
+                tx_length = wlan_create_token_response_frame((void*)(TX_PKT_BUF_TO_ADDR(TX_PKT_BUF_TOKEN) + PHY_TX_PKT_BUF_MPDU_OFFSET),
+                                                                                                          rx_token_frame->address_ta,
+                                                                                                      eeprom_addr,
+                                                                                                      0,
+                                                                                                      rx_token_frame->res_duration_usec); //TODO: Calculate appropriate duration
+
+
+                //Write the SIGNAL field for the ACK
+                wlan_phy_set_tx_signal(TX_PKT_BUF_TOKEN, WLAN_PHY_RATE_BPSK12, tx_length);
+
+                mpdu_info->state = wlan_mac_dcf_hw_rx_finish();
+
+                if(mpdu_info->state == RX_MPDU_STATE_FCS_GOOD){
+
+                        memcpy( ipc_payload_start.addr, rx_token_frame->address_ra, 6 );
+                        ipc_payload_start.res_duration = rx_token_frame->res_duration_usec;
+                        ipc_mailbox_write_msg(&ipc_msg_to_high_start);
+
+                        wlan_mac_tx_ctrl_B_start(1);
+                        wlan_mac_tx_ctrl_B_start(0);
+
+                        do{
+                                mac_hw_status = wlan_mac_get_status();
+
+                                if( (mac_hw_status & WLAN_MAC_STATUS_MASK_TX_B_STATE) == WLAN_MAC_STATUS_TX_B_STATE_DO_TX ) {
+                                        break;
+                                }
+                        } while(mac_hw_status & WLAN_MAC_STATUS_MASK_TX_B_PENDING);
+
+                        //Since this is our reservation period, we are now allowed to transmit
+                        in_reservation = 1;
+                        reservation_ts_end = get_usec_timestamp() + ((u64)rx_token_frame->res_duration_usec);
+                        wlan_mac_low_enable_new_mpdu_tx();
+                }
+        } else if(unicast_to_me && (rx_header->frame_control_1 == MAC_FRAME_CTRL1_SUBTYPE_TOKEN_RESPONSE)) {
+                //Received a token offer
+                rx_token_frame = (mac_frame_custom_token*)rx_header;
+
+                if(rx_token_frame->res_duration_usec != 0){
+                        mpdu_info->state = wlan_mac_dcf_hw_rx_finish();
+                        if(mpdu_info->state == RX_MPDU_STATE_FCS_GOOD){
+                                return_value |= POLL_MAC_STATUS_TOKEN_OFFER_ACCEPTED;
+                        }
+                }
+        } else {
+                mpdu_info->state = wlan_mac_dcf_hw_rx_finish(); //Blocks until reception is complete
+        }
+
+        mpdu_info->flags = 0;
+        mpdu_info->phy_details = *phy_details;
+        mpdu_info->channel = wlan_mac_low_get_active_channel();
+        mpdu_info->timestamp = get_rx_start_timestamp();
+
+
+        mpdu_info->ant_mode = wlan_phy_rx_get_active_rx_ant();
+
+        mpdu_info->rf_gain = wlan_phy_rx_get_agc_RFG(mpdu_info->ant_mode);
+        mpdu_info->bb_gain = wlan_phy_rx_get_agc_BBG(mpdu_info->ant_mode);
+        mpdu_info->rx_power = wlan_mac_low_calculate_rx_power(wlan_phy_rx_get_pkt_rssi(mpdu_info->ant_mode), wlan_phy_rx_get_agc_RFG(mpdu_info->ant_mode));
+
+        if(mpdu_info->state == RX_MPDU_STATE_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));
+        }
+
+        //Unlock the pkt buf mutex before passing the packet up
+        // If this fails, something has gone horribly wrong
+        if(unlock_pkt_buf_rx(rx_pkt_buf) != PKT_BUF_MUTEX_SUCCESS){
+                xil_printf("Error: unable to unlock RX pkt_buf %d\n", rx_pkt_buf);
+                wlan_mac_low_send_exception(EXC_MUTEX_RX_FAILURE);
+        } 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();
+        }
+
+        //Unblock the PHY post-Rx (no harm calling this if the PHY isn't actually blocked)
+        wlan_mac_dcf_hw_unblock_rx_phy();
+
+        return return_value;
+
+}
+}}}
+
+----
+
+