driverRFPhy.c

00001 /*
00002  * driverRFPhy.c
00003  *
00004  *  Created on: 14 July 2014
00005  *      Author: mBed team
00006  */
00007 #include "arm_hal_interrupt.h"
00008 #include "arm_hal_phy.h"
00009 #include "driverRFPhy.h"
00010 #include "driverAtmelRFInterface.h"
00011 #include <string.h>
00012 
00013 #include <stdio.h>
00014 
00015 #include "configuration.h"
00016 
00017 /*RF receive buffer*/
00018 static uint8_t rf_buffer[RF_BUFFER_SIZE];
00019 /*RF ACK receive buffer*/
00020 static uint8_t ack_rx_buf[5];
00021 /*ACK wait duration changes depending on data rate*/
00022 static uint16_t rf_ack_wait_duration = RF_ACK_WAIT_TIMEOUT;
00023 
00024 // TUNABLES
00025 extern uint8_t rf_channel;
00026 
00027 static uint8_t radio_tx_power = 0x07;
00028 static uint8_t rf_tuned = 1;
00029 static uint8_t radio_rpc_value = 0xef;
00030 static uint8_t rf_use_front_end = 0;
00031 static uint8_t rf_use_antenna_diversity = 0;
00032 static uint8_t rf_csd_port = 0;
00033 static uint8_t rf_csd_pin = 0;
00034 static uint8_t rf_cps_port = 0;
00035 static uint8_t rf_cps_pin = 0;
00036 static uint8_t tx_sequence = 0xff;
00037 static uint8_t need_ack = 0;
00038 static uint8_t rf_rx_mode = 0;
00039 static uint8_t rf_flags = 0;
00040 static uint8_t rf_rnd_rssi = 0;
00041 static int8_t rf_radio_driver_id = -1;
00042 static phy_device_driver_s device_driver;
00043 static uint8_t atmel_MAC[8];
00044 static phy_device_channel_info_s channel_info;
00045 static uint8_t mac_tx_handle = 0;
00046 
00047 /*
00048  * \brief Function sets given RF flag on.
00049  *
00050  * \param x Given RF flag
00051  *
00052  * \return none
00053  */
00054 void rf_flags_set(uint8_t x)
00055 {
00056     rf_flags |= x;
00057 }
00058 
00059 /*
00060  * \brief Function clears given RF flag on.
00061  *
00062  * \param x Given RF flag
00063  *
00064  * \return none
00065  */
00066 void rf_flags_clear(uint8_t x)
00067 {
00068     rf_flags &= ~x;
00069 }
00070 
00071 /*
00072  * \brief Function checks if given RF flag is on.
00073  *
00074  * \param x Given RF flag
00075  *
00076  * \return states of the given flags
00077  */
00078 uint8_t rf_flags_check(uint8_t x)
00079 {
00080     return (rf_flags & x);
00081 }
00082 
00083 /*
00084  * \brief Function clears all RF flags.
00085  *
00086  * \param none
00087  *
00088  * \return none
00089  */
00090 void rf_flags_reset(void)
00091 {
00092     rf_flags = 0;
00093 }
00094 
00095 /*
00096  * \brief Function sets CPS and CSD pins of the Front end.
00097  *
00098  * \param none
00099  *
00100  * \return none
00101  */
00102 void rf_front_end_rx_lna(void)
00103 {
00104         /* not supported in this version  */
00105 }
00106 
00107 /*
00108  * \brief Function clears CPS and CSD pins of the Front end.
00109  *
00110  * \param none
00111  *
00112  * \return none
00113  */
00114 void rf_front_end_sleep(void)
00115 {
00116         /* not supported in this version  */
00117 }
00118 
00119 /*
00120  * \brief Function initialises and registers the RF driver.
00121  *
00122  * \param none
00123  *
00124  * \return rf_radio_driver_id Driver ID given by NET library
00125  */
00126 int8_t rf_device_register(void)
00127 {
00128     rf_init();
00129     /*Set pointer to MAC address*/
00130     device_driver.PHY_MAC = atmel_MAC;
00131     device_driver.driver_description = "ATMEL_MAC";
00132 #if PHY_LINK_15_4_2_4GHZ_TYPE
00133       /*Number of channels in PHY*/
00134         channel_info.channel_count = 16;
00135         /*Channel mask 26-11*/
00136         channel_info.channel_mask = 0x07FFF800;
00137         /*Type of RF PHY is SubGHz*/
00138         device_driver.link_type = PHY_LINK_15_4_2_4GHZ_TYPE;
00139         device_driver.link_channel_info = &channel_info;
00140 #else
00141         /*Number of channels in PHY*/
00142     channel_info.channel_count = 11;
00143     /*Channel mask 0-10*/
00144     channel_info.channel_mask = 0x000007ff;
00145     /*Type of RF PHY is SubGHz*/
00146     device_driver.link_type = PHY_LINK_15_4_SUBGHZ_TYPE;
00147     device_driver.link_channel_info = &channel_info;
00148 #endif
00149    /*Maximum size of payload is 127*/
00150     device_driver.phy_MTU = 127;
00151     /*No header in PHY*/
00152     device_driver.phy_header_length = 0;
00153     /*No tail in PHY*/
00154     device_driver.phy_tail_length = 0;
00155     /*Set address write function*/
00156     device_driver.phy_xx_address_write = &rf_address_write;
00157     /*Set RF extension function*/
00158     device_driver.phy_xx_extension = &rf_extension;
00159     /*Set RF state control function*/
00160     device_driver.phy_xx_state_control = &rf_interface_state_control;
00161     /*Set transmit function*/
00162     device_driver.phy_xx_tx = &rf_start_cca;
00163     printf("RF Device Registration...");
00164     /*Register device driver*/
00165     rf_radio_driver_id = arm_net_phy_register(&device_driver);
00166     printf("OK\r\n");   
00167     return rf_radio_driver_id;
00168 }
00169 
00170 /*
00171  * \brief Function returns the generated 8-bit random value for seeding Pseudo-random generator. This value was generated by reading noise from RF channel in RF initialisation.
00172  *
00173  * \param none
00174  *
00175  * \return random RSSI value
00176  */
00177 int8_t rf_read_random(void)
00178 {
00179     return rf_rnd_rssi;
00180 }
00181 
00182 /*
00183  * \brief Function is a call back for ACK wait timeout.
00184  *
00185  * \param none
00186  *
00187  * \return none
00188  */
00189 void rf_ack_wait_timer_interrupt(void)
00190 {
00191     arm_enter_critical();
00192     /*Force PLL state*/
00193     rf_if_change_trx_state(FORCE_PLL_ON);
00194     rf_poll_trx_state_change(PLL_ON);
00195     /*Start receiver in RX_AACK_ON state*/
00196     rf_rx_mode = 0;
00197     rf_flags_clear(RFF_RX);
00198     rf_receive();
00199     arm_exit_critical();
00200 }
00201 
00202 /*
00203  * \brief Function is a call back for calibration interval timer.
00204  *
00205  * \param none
00206  *
00207  * \return none
00208  */
00209 void rf_calibration_timer_interrupt(void)
00210 {
00211     /*Calibrate RF*/
00212     rf_calibration_cb();
00213     /*Start new calibration timeout*/
00214     rf_calibration_timer_start(RF_CALIBRATION_INTERVAL);
00215 }
00216 
00217 /*
00218  * \brief Function initialises the RF timer for ACK wait and calibration.
00219  *
00220  * \param none
00221  *
00222  * \return none
00223  */
00224 void rf_timer_init(void)
00225 {
00226     rf_if_timer_init();
00227 }
00228 
00229 /*
00230  * \brief Function starts the ACK wait timeout.
00231  *
00232  * \param slots Given slots, resolution 50us
00233  *
00234  * \return none
00235  */
00236 void rf_ack_wait_timer_start(uint16_t slots)
00237 {
00238     rf_if_ack_wait_timer_start(slots);
00239 }
00240 
00241 /*
00242  * \brief Function starts the calibration interval.
00243  *
00244  * \param slots Given slots, resolution 50us
00245  *
00246  * \return none
00247  */
00248 void rf_calibration_timer_start(uint32_t slots)
00249 {
00250     rf_if_calibration_timer_start(slots);
00251 }
00252 
00253 /*
00254  * \brief Function stops the ACK wait timeout.
00255  *
00256  * \param none
00257  *
00258  * \return none
00259  */
00260 void rf_ack_wait_timer_stop(void)
00261 {
00262     rf_if_ack_wait_timer_stop();
00263 }
00264 
00265 /*
00266  * \brief Function reads the MAC address array.
00267  *
00268  * \param ptr Pointer to read array
00269  *
00270  * \return none
00271  */
00272 void rf_read_mac_address(uint8_t *ptr)
00273 {
00274     memcpy(ptr, atmel_MAC, 8);
00275 }
00276 
00277 /*
00278  * \brief Function sets the MAC address array.
00279  *
00280  * \param ptr Pointer to given MAC address array
00281  *
00282  * \return none
00283  */
00284 void rf_set_mac_address(const uint8_t *ptr)
00285 {
00286     memcpy(atmel_MAC,ptr,8);
00287 }
00288 
00289 /*
00290  * \brief Function writes various RF settings in startup.
00291  *
00292  * \param none
00293  *
00294  * \return none
00295  */
00296 void rf_write_settings(void)
00297 {    
00298     arm_enter_critical();
00299   
00300   //printf("RF Write Settings: 1\r\n"); 
00301     rf_if_write_rf_settings();
00302  
00303   //printf("RF Write Settings: 2\r\n");
00304     /*Set output power*/
00305     rf_if_write_set_tx_power_register(radio_tx_power);
00306  
00307   //printf("RF Write Settings: 3\r\n");
00308     /*Set RPC register*/
00309     rf_if_write_set_trx_rpc_register(radio_rpc_value);
00310  
00311   //printf("RF Write Settings: 4\r\n");
00312     /*Initialise Front end*/
00313     if(rf_use_front_end)
00314     {
00315         printf("RF Front End used\r\n");
00316         rf_if_enable_pa_ext();
00317                 /*  not supported in this version  */    
00318     }
00319   
00320   //printf("RF Write Settings: 5\r\n");  
00321     /*Initialise Antenna Diversity*/
00322     if(rf_use_antenna_diversity) {
00323         printf("RF Antenna diversity\r\n");
00324         rf_if_write_antenna_diversity_settings();
00325     }    
00326   
00327   printf("RF Write Settings: 7\r\n");
00328     arm_exit_critical();
00329    printf("RF Write Settings End\r\n");
00330 }
00331 
00332 /*
00333  * \brief Function writes 16-bit address in RF address filter.
00334  *
00335  * \param short_address Given short address
00336  *
00337  * \return none
00338  */
00339 void rf_set_short_adr(uint8_t * short_address)
00340 {
00341     uint8_t rf_off_flag = 0;
00342     arm_enter_critical();
00343     /*Wake up RF if sleeping*/
00344     if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F)
00345     {
00346         rf_if_disable_slptr();
00347         rf_off_flag = 1;
00348         rf_poll_trx_state_change(TRX_OFF);
00349     }
00350     /*Write address filter registers*/
00351     rf_if_write_short_addr_registers(short_address);
00352     /*RF back to sleep*/
00353     if(rf_off_flag)
00354         rf_if_enable_slptr();
00355     arm_exit_critical();
00356 }
00357 
00358 /*
00359  * \brief Function writes PAN Id in RF PAN Id filter.
00360  *
00361  * \param pan_id Given PAN Id
00362  *
00363  * \return none
00364  */
00365 void rf_set_pan_id(uint8_t *pan_id)
00366 {
00367     uint8_t rf_off_flag = 0;
00368 
00369     arm_enter_critical();
00370     /*Wake up RF if sleeping*/
00371     if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F)
00372     {
00373         rf_if_disable_slptr();
00374         rf_off_flag = 1;
00375         rf_poll_trx_state_change(TRX_OFF);
00376     }
00377     /*Write address filter registers*/
00378     rf_if_write_pan_id_registers(pan_id);
00379     /*RF back to sleep*/
00380     if(rf_off_flag)
00381         rf_if_enable_slptr();
00382     arm_exit_critical();
00383 }
00384 
00385 /*
00386  * \brief Function writes 64-bit address in RF address filter.
00387  *
00388  * \param address Given 64-bit address
00389  *
00390  * \return none
00391  */
00392 void rf_set_address(uint8_t *address)
00393 {
00394     uint8_t rf_off_flag = 0;
00395 
00396     arm_enter_critical();
00397     /*Wake up RF if sleeping*/
00398     if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1F)
00399     {
00400         rf_if_disable_slptr();
00401         rf_off_flag = 1;
00402         rf_poll_trx_state_change(TRX_OFF);
00403     }
00404     /*Write address filter registers*/
00405     rf_if_write_ieee_addr_registers(address);
00406     /*RF back to sleep*/
00407     if(rf_off_flag)
00408         rf_if_enable_slptr();
00409 
00410     arm_exit_critical();
00411 }
00412 
00413 /*
00414  * \brief Function sets the RF channel.
00415  *
00416  * \param ch New channel
00417  *
00418  * \return none
00419  */
00420 void rf_channel_set(uint8_t ch)
00421 {
00422     arm_enter_critical();
00423     rf_channel = ch;
00424     if(ch < 0x1f)
00425         rf_if_set_channel_register(ch);
00426     arm_exit_critical();
00427 }
00428 
00429 
00430 /*
00431  * \brief Function initialises the radio driver and resets the radio.
00432  *
00433  * \param none
00434  *
00435  * \return none
00436  */
00437 void rf_init(void)
00438 {
00439    printf("RF Init Start\r\n");
00440     /*Initialise timers*/
00441     rf_timer_init();                //TODO
00442     rf_channel = RF_DEFAULT_CHANNEL;
00443    printf("RF Reset\r\n");  
00444     /*Reset RF module*/
00445     rf_if_reset_radio();
00446    printf("RF Write Settings\r\n"); 
00447     /*Write RF settings*/
00448     rf_write_settings();
00449    printf("RF Init PHY Mode\r\n"); 
00450     /*Initialise PHY mode*/
00451     rf_init_phy_mode();
00452     /*Clear RF flags*/
00453     rf_flags_reset();
00454     /*Set RF in TRX OFF state*/
00455     rf_if_change_trx_state(TRX_OFF);
00456     /*Set RF in PLL_ON state*/
00457     rf_if_change_trx_state(PLL_ON);
00458     /*Start receiver*/
00459     rf_receive();
00460     /*Read random variable. This will be used when seeding pseudo-random generator*/
00461     rf_rnd_rssi = rf_if_read_rnd();
00462     /*Start RF calibration timer*/
00463     rf_calibration_timer_start(RF_CALIBRATION_INTERVAL);  //ACA!
00464         printf("RF Init End\r\n");
00465 }
00466 
00467 /**
00468  * \brief Function gets called when MAC is setting radio off.
00469  *
00470  * \param none
00471  *
00472  * \return none
00473  */
00474 void rf_off(void)
00475 {
00476     if(rf_flags_check(RFF_ON))
00477     {
00478         rf_cca_abort();
00479         uint16_t while_counter = 0;
00480         /*Wait while receiving*/
00481         while(rf_if_read_trx_state() == BUSY_RX_AACK || rf_if_read_trx_state() == BUSY_RX)
00482         {
00483             while_counter++;
00484             if(while_counter == 0xffff)
00485                 break;
00486         }
00487         /*RF state change: RX_AACK_ON->PLL_ON->TRX_OFF->SLEEP*/
00488         if(rf_if_read_trx_state() == RX_AACK_ON)
00489         {
00490             rf_if_change_trx_state(PLL_ON);
00491         }
00492         rf_if_change_trx_state(TRX_OFF);
00493         rf_if_enable_slptr();
00494         rf_flags_clear(~RFF_ON);
00495         /*Front end in sleep*/
00496         if(rf_use_front_end)
00497         {
00498             rf_if_disable_pa_ext();
00499             rf_front_end_sleep();
00500         }
00501         /*Disable Antenna Diversity*/
00502         if(rf_use_antenna_diversity)
00503             rf_if_disable_ant_div();
00504     }
00505 }
00506 
00507 /*
00508  * \brief Function polls the RF state until it has changed to desired state.
00509  *
00510  * \param trx_state RF state
00511  *
00512  * \return none
00513  */
00514 void rf_poll_trx_state_change(rf_trx_states_t trx_state)
00515 {
00516     uint16_t while_counter = 0;
00517     arm_enter_critical();
00518 
00519     if(trx_state != RF_TX_START)
00520     {
00521         if(trx_state == FORCE_PLL_ON)
00522             trx_state = PLL_ON;
00523         else if(trx_state == FORCE_TRX_OFF)
00524             trx_state = TRX_OFF;
00525 
00526         while(rf_if_read_trx_state() != trx_state)
00527         {
00528             while_counter++;
00529             if(while_counter == 0x1ff)
00530                 break;
00531         }
00532     }
00533     arm_exit_critical();
00534 }
00535 
00536 /*
00537  * \brief Function starts the CCA process before starting data transmission and copies the data to RF TX FIFO.
00538  *
00539  * \param data_ptr Pointer to TX data
00540  * \param data_length Length of the TX data
00541  * \param tx_handle Handle to transmission
00542  * \return 0 Success
00543  * \return -1 Busy
00544  */
00545 int8_t rf_start_cca(uint8_t *data_ptr, uint16_t data_length, uint8_t tx_handle)
00546 {
00547     /*Check if transmitter is busy*/
00548     if((rf_if_read_trx_state() == BUSY_RX_AACK) || (rf_if_read_trx_state() == BUSY_RX))
00549     {
00550         /*Return busy*/
00551         return -1;
00552     }
00553     else
00554     {
00555         arm_enter_critical();
00556         /*Check if transmitted data needs to be acked*/
00557         if(*data_ptr & 0x20)
00558             need_ack = 1;
00559         else
00560             need_ack = 0;
00561         /*Store the sequence number for ACK handling*/
00562         tx_sequence = *(data_ptr + 2);
00563         /*Set radio in RX state to read channel*/
00564         rf_receive();
00565         /*Write TX FIFO*/
00566         rf_if_write_frame_buffer(data_ptr, (uint8_t)data_length);
00567         rf_flags_set(RFF_CCA);
00568         /*Start CCA process*/
00569         rf_if_enable_cca_ed_done_interrupt();
00570         rf_if_start_cca_process();
00571         /*Store TX handle*/
00572         mac_tx_handle = tx_handle;
00573         arm_exit_critical();
00574     }
00575 
00576     /*Return success*/
00577     return 0;
00578 }
00579 
00580 /*
00581  * \brief Function aborts CCA process.
00582  *
00583  * \param none
00584  *
00585  * \return none
00586  */
00587 void rf_cca_abort(void)
00588 {
00589     /*Clear RFF_CCA RF flag*/
00590     rf_flags_clear(RFF_CCA);
00591 }
00592 
00593 
00594 
00595 /*
00596  * \brief Function starts the transmission of the frame.
00597  *
00598  * \param none
00599  *
00600  * \return none
00601  */
00602 void rf_start_tx(void)
00603 {
00604     /*Only start transmitting from RX state*/
00605     uint8_t trx_state = rf_if_read_trx_state();
00606     if((trx_state != RX_AACK_ON) && (trx_state != RX_ON))
00607     {
00608         arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, PHY_LINK_CCA_FAIL, 1, 1);
00609     }
00610     else
00611     {
00612         /*RF state change: ->PLL_ON->RF_TX_START*/
00613         rf_if_change_trx_state(FORCE_PLL_ON);
00614         rf_flags_clear(RFF_RX);
00615         rf_if_enable_tx_end_interrupt();
00616         rf_flags_set(RFF_TX);
00617         rf_if_change_trx_state(RF_TX_START);
00618     }
00619 }
00620 
00621 /*
00622  * \brief Function sets the RF in RX state.
00623  *
00624  * \param none
00625  *
00626  * \return none
00627  */
00628 void rf_receive(void)
00629 {
00630     uint16_t while_counter = 0;
00631     if(rf_flags_check(RFF_ON) == 0)
00632     {
00633         rf_on();
00634     }
00635     /*If not yet in RX state set it*/
00636     if(rf_flags_check(RFF_RX) == 0)
00637     {
00638         arm_enter_critical();
00639         /*Wait while receiving data*/
00640         while((rf_if_read_trx_state() == BUSY_RX) || (rf_if_read_trx_state() == BUSY_RX_AACK))
00641         {
00642             while_counter++;
00643             if(while_counter == 0xffff)
00644             {
00645                 break;
00646             }
00647         }
00648         /*Wake up from sleep state*/
00649         if(rf_if_read_trx_state() == 0x00 || rf_if_read_trx_state() == 0x1f)
00650         {
00651             rf_if_disable_slptr();
00652             rf_poll_trx_state_change(TRX_OFF);
00653         }
00654 
00655         rf_if_change_trx_state(PLL_ON);
00656         /*ACK is always received in RX_ON state to bypass address filters*/
00657         if(rf_rx_mode)
00658         {
00659             rf_rx_mode = 0;
00660             rf_if_change_trx_state(RX_ON);
00661         }
00662         else
00663         {
00664             rf_if_change_trx_state(RX_AACK_ON);
00665             /*If calibration timer was unable to calibrate the RF, run calibration now*/
00666             if(!rf_tuned)
00667             {
00668                 /*Start calibration. This can be done in states TRX_OFF, PLL_ON or in any receive state*/
00669                 rf_if_calibration();
00670                 /*RF is tuned now*/
00671                 rf_tuned = 1;
00672             }
00673         }
00674         rf_channel_set(rf_channel);
00675         rf_flags_set(RFF_RX);
00676         rf_if_enable_rx_end_interrupt();
00677         /*Enable LNA if Front end used*/
00678         if(rf_use_front_end)
00679             rf_front_end_rx_lna();
00680         arm_exit_critical();
00681     }
00682     /*Stop the running CCA process*/
00683     if(rf_flags_check(RFF_CCA))
00684         rf_cca_abort();
00685 }
00686 
00687 /*
00688  * \brief Function calibrates the radio.
00689  *
00690  * \param none
00691  *
00692  * \return none
00693  */
00694 void rf_calibration_cb(void)
00695 {
00696     /*clear tuned flag to start tuning in rf_receive*/
00697     rf_tuned = 0;
00698     /*If RF is in default receive state, start calibration*/
00699     if(rf_if_read_trx_state() == RX_AACK_ON)
00700     {
00701         arm_enter_critical();
00702         /*Set RF in PLL_ON state*/
00703         rf_if_change_trx_state(PLL_ON);
00704         /*Set RF in TRX_OFF state to start PLL tuning*/
00705         rf_if_change_trx_state(TRX_OFF);
00706         /*Set RF in RX_ON state to calibrate*/
00707         rf_if_change_trx_state(RX_ON);
00708         /*Calibrate FTN*/
00709         rf_if_calibration();
00710         /*RF is tuned now*/
00711         rf_tuned = 1;
00712         /*Back to default receive state*/
00713         rf_flags_clear(RFF_RX);
00714         rf_receive();
00715         arm_exit_critical();
00716     }
00717 }
00718 
00719 /*
00720  * \brief Function sets RF_ON flag when radio is powered.
00721  *
00722  * \param none
00723  *
00724  * \return none
00725  */
00726 void rf_on(void)
00727 {
00728     /*Set RFF_ON flag*/
00729     if(rf_flags_check(RFF_ON) == 0)
00730     {
00731         rf_flags_set(RFF_ON);
00732         /*Wake up Front end*/
00733         if(rf_use_front_end)
00734         {
00735             /*Set PA_EXT_EN to enable controlling of external front end*/
00736             rf_if_enable_pa_ext();
00737             rf_front_end_rx_lna();
00738         }
00739         /*Enable Antenna diversity*/
00740         if(rf_use_antenna_diversity)
00741             /*Set ANT_EXT_SW_EN to enable controlling of antenna diversity*/
00742             rf_if_enable_ant_div();
00743     }
00744 }
00745 
00746 /*
00747  * \brief Function handles the received ACK frame.
00748  *
00749  * \param seq_number Sequence number of received ACK
00750  * \param data_pending Pending bit state in received ACK
00751  *
00752  * \return none
00753  */
00754 void rf_handle_ack(uint8_t seq_number, uint8_t data_pending)
00755 {
00756     phy_link_tx_status_e phy_status;
00757     arm_enter_critical();
00758     /*Received ACK sequence must be equal with transmitted packet sequence*/
00759     if(tx_sequence == seq_number)
00760     {
00761         rf_ack_wait_timer_stop();
00762         /*When data pending bit in ACK frame is set, inform NET library*/
00763         if(data_pending)
00764             phy_status =    PHY_LINK_TX_DONE_PENDING;
00765         else
00766             phy_status = PHY_LINK_TX_DONE;
00767         /*Call PHY TX Done API*/
00768         arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle,phy_status, 1, 1);
00769     }
00770     arm_exit_critical();
00771 }
00772 
00773 /*
00774  * \brief Function is a call back for RX end interrupt.
00775  *
00776  * \param none
00777  *
00778  * \return none
00779  */
00780 void rf_handle_rx_end(void)
00781 {
00782     uint8_t rf_lqi;
00783 
00784     /*Frame received interrupt*/
00785     if(rf_flags_check(RFF_RX))
00786     {
00787         /*Check CRC_valid bit*/
00788         if(rf_if_check_crc())
00789         {
00790             uint8_t *rf_rx_ptr;
00791             uint8_t receiving_ack = 0;
00792             /*Read length*/
00793             uint8_t len = rf_if_read_received_frame_length();
00794             /*Not ACK frame*/
00795             if(len > 5)
00796             {
00797                 rf_rx_ptr = rf_buffer;
00798             }
00799             /*ACK received*/
00800             else
00801             {
00802                 /*Read ACK in static ACK buffer*/
00803                 receiving_ack = 1;
00804                 rf_rx_ptr = ack_rx_buf;
00805             }
00806             /*Check the length is valid*/
00807             if(len > 1 && len < RF_BUFFER_SIZE)
00808             {
00809                 /*Read received packet*/
00810                 rf_if_read_packet(rf_rx_ptr, len);
00811                 /*Get LQI*/
00812                 rf_lqi = rf_if_read_lqi();
00813                 /*Handle received ACK*/
00814                 if(receiving_ack && ((ack_rx_buf[0] & 0x07) == 0x02))
00815                 {
00816                     uint8_t pending = 0;
00817                     /*Check if data is pending*/
00818                     if ((ack_rx_buf[0] & 0x10))
00819                     {
00820                         pending=1;
00821                     }
00822                     /*Send sequence number in ACK handler*/
00823                     rf_handle_ack(ack_rx_buf[2], pending);
00824                 }
00825                 /*Handle received data*/
00826                 else if(rf_if_read_trx_state() != RX_ON && rf_if_read_trx_state() != BUSY_RX)
00827                 {
00828                     arm_net_phy_rx(rf_buffer,len - 2, rf_lqi, rf_radio_driver_id);
00829                 }
00830             }
00831         }
00832     }
00833     /*Start receiver*/
00834     rf_flags_clear(RFF_RX);
00835     rf_receive();
00836 }
00837 
00838 /*
00839  * \brief Function is called when MAC is shutting down the radio.
00840  *
00841  * \param none
00842  *
00843  * \return none
00844  */
00845 void rf_shutdown(void)
00846 {
00847     /*Call RF OFF*/
00848     rf_off();
00849     /*Clear RF flags*/
00850     rf_flags_reset();
00851 }
00852 
00853 /*
00854  * \brief Function is a call back for TX end interrupt.
00855  *
00856  * \param none
00857  *
00858  * \return none
00859  */
00860 void rf_handle_tx_end(void)
00861 {
00862     phy_link_tx_status_e phy_status = PHY_LINK_TX_SUCCESS;
00863 
00864     rf_rx_mode = 0;
00865     /*If ACK is needed for this transmission*/
00866     if(need_ack && rf_flags_check(RFF_TX))
00867     {
00868         rf_ack_wait_timer_start(rf_ack_wait_duration);
00869         rf_rx_mode = 1;
00870     }
00871     rf_flags_clear(RFF_RX);
00872     /*Start receiver*/
00873     rf_receive();
00874 
00875     /*Call PHY TX Done API*/
00876     arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, phy_status, 1, 1);
00877 }
00878 
00879 /*
00880  * \brief Function is a call back for CCA ED done interrupt.
00881  *
00882  * \param none
00883  *
00884  * \return none
00885  */
00886 void rf_handle_cca_ed_done(void)
00887 {
00888     rf_flags_clear(RFF_CCA);
00889     /*Check the result of CCA process*/
00890     if(rf_if_check_cca())
00891     {
00892         rf_start_tx();
00893     }
00894     else
00895     {
00896         /*Send CCA fail notification*/
00897         arm_net_phy_tx_done(rf_radio_driver_id, mac_tx_handle, PHY_LINK_CCA_FAIL, 1, 1);
00898     }
00899 }
00900 
00901 /*
00902  * \brief Function sets the TX power variable.
00903  *
00904  * \param power TX power setting
00905  *
00906  * \return 0 Success
00907  * \return -1 Fail
00908  */
00909 int8_t rf_tx_power_set(uint8_t power)
00910 {
00911     int8_t ret_val = -1;
00912     if(power < 16)
00913     {
00914         radio_tx_power = power;
00915         ret_val = 0;
00916     }
00917     return ret_val;
00918 }
00919 
00920 /*
00921  * \brief Function returns the TX power variable.
00922  *
00923  * \param none
00924  *
00925  * \return radio_tx_power TX power variable
00926  */
00927 uint8_t rf_tx_power_get(void)
00928 {
00929   return radio_tx_power;
00930 }
00931 
00932 /*
00933  * \brief Function sets the RF RPC variable.
00934  *
00935  * \param rpc_value RPC setting
00936  *
00937  * \return 0 Success
00938  */
00939 int8_t rf_rpc_set(uint8_t rpc_value)
00940 {
00941     int8_t ret_val = -1;
00942     radio_rpc_value = rpc_value;
00943     ret_val = 0;
00944     return ret_val;
00945 }
00946 
00947 /*
00948  * \brief Function enables the usage of Front end.
00949  *
00950  * \param none
00951  *
00952  * \return 0 Success
00953  */
00954 int8_t rf_enable_pa(void)
00955 {
00956     int8_t ret_val = 0;
00957     rf_use_front_end = 1;
00958     return ret_val;
00959 }
00960 
00961 /*
00962  * \brief Function enables the usage of Antenna diversity.
00963  *
00964  * \param none
00965  *
00966  * \return 0 Success
00967  */
00968 int8_t rf_enable_antenna_diversity(void)
00969 {
00970     int8_t ret_val = 0;
00971     rf_use_antenna_diversity = 1;
00972     return ret_val;
00973 }
00974 
00975 /*
00976  * \brief Function defines the CSD pin of the Front end.
00977  *
00978  * \param port CSD port
00979  * \param port CSD pin
00980  *
00981  * \return 0 Success
00982  */
00983 int8_t rf_set_csd_pin(uint8_t port, uint8_t pin)
00984 {
00985     int8_t ret_val = -1;
00986 
00987     rf_csd_port = port;
00988     rf_csd_pin = pin;
00989     ret_val = 0;
00990 
00991     return ret_val;
00992 }
00993 
00994 /*
00995  * \brief Function defines the CPS pin of the Front end.
00996  *
00997  * \param port CPS port
00998  * \param port CPS pin
00999  *
01000  * \return 0 Success
01001  */
01002 int8_t rf_set_cps_pin(uint8_t port, uint8_t pin)
01003 {
01004     int8_t ret_val = -1;
01005 
01006     rf_cps_port = port;
01007     rf_cps_pin = pin;
01008     ret_val = 0;
01009 
01010     return ret_val;
01011 }
01012 
01013 /*
01014  * \brief Function gives the control of RF states to MAC.
01015  *
01016  * \param new_state RF state
01017  * \param rf_channel RF channel
01018  *
01019  * \return 0 Success
01020  */
01021 static int8_t rf_interface_state_control(phy_interface_state_e new_state, uint8_t rf_channel)
01022 {
01023     int8_t ret_val = 0;
01024     switch (new_state)
01025     {
01026         /*Reset PHY driver and set to idle*/
01027         case PHY_INTERFACE_RESET:
01028             break;
01029         /*Disable PHY Interface driver*/
01030         case PHY_INTERFACE_DOWN:
01031             rf_shutdown();
01032             break;
01033         /*Enable PHY Interface driver*/
01034         case PHY_INTERFACE_UP:
01035             rf_channel_set(rf_channel);
01036             rf_receive();
01037             break;
01038         /*Enable wireless interface ED scan mode*/
01039         case PHY_INTERFACE_RX_ENERGY_STATE:
01040             break;
01041     }
01042     return ret_val;
01043 }
01044 
01045 /*
01046  * \brief Function controls the ACK pending, channel setting and energy detection.
01047  *
01048  * \param extension_type Type of control
01049  * \param data_ptr Data from NET library
01050  *
01051  * \return 0 Success
01052  */
01053 static int8_t rf_extension(phy_extension_type_e extension_type, uint8_t *data_ptr)
01054 {
01055     switch (extension_type)
01056     {
01057         /*Control MAC pending bit for Indirect data transmission*/
01058         case PHY_EXTENSION_CTRL_PENDING_BIT:
01059             if(*data_ptr)
01060             {
01061                 rf_if_ack_pending_ctrl(1);
01062             }
01063             else
01064             {
01065                 rf_if_ack_pending_ctrl(0);
01066             }
01067             break;
01068         /*Return frame pending status*/
01069         case PHY_EXTENSION_READ_LAST_ACK_PENDING_STATUS:
01070             *data_ptr = rf_if_last_acked_pending();
01071             break;
01072         /*Set channel*/
01073         case PHY_EXTENSION_SET_CHANNEL:
01074             break;
01075         /*Read energy on the channel*/
01076         case PHY_EXTENSION_READ_CHANNEL_ENERGY:
01077             break;
01078         /*Read status of the link*/
01079         case PHY_EXTENSION_READ_LINK_STATUS:
01080             break;
01081     }
01082     return 0;
01083 }
01084 
01085 /*
01086  * \brief Function sets the addresses to RF address filters.
01087  *
01088  * \param address_type Type of address
01089  * \param address_ptr Pointer to given address
01090  *
01091  * \return 0 Success
01092  */
01093 static int8_t rf_address_write(phy_address_type_e address_type, uint8_t *address_ptr)
01094 {
01095     int8_t ret_val = 0;
01096     switch (address_type)
01097     {
01098         /*Set 48-bit address*/
01099         case PHY_MAC_48BIT:
01100             break;
01101             /*Set 64-bit address*/
01102         case PHY_MAC_64BIT:
01103             rf_set_address(address_ptr);
01104             break;
01105         /*Set 16-bit address*/
01106         case PHY_MAC_16BIT:
01107             rf_set_short_adr(address_ptr);
01108             break;
01109         /*Set PAN Id*/
01110         case PHY_MAC_PANID:
01111             rf_set_pan_id(address_ptr);
01112             break;
01113     }
01114     return ret_val;
01115 }
01116 
01117 /*
01118  * \brief Function initialises the ACK wait time and returns the used PHY mode.
01119  *
01120  * \param none
01121  *
01122  * \return tmp Used PHY mode
01123  */
01124 uint8_t rf_init_phy_mode(void)
01125 {
01126     uint8_t tmp;
01127     /*Read used PHY Mode*/
01128     tmp = rf_if_read_register(TRX_CTRL_2);
01129     /*Set ACK wait time for used data rate*/
01130     if((tmp & 0x1f) == 0x00)
01131     {
01132         rf_ack_wait_duration = 938;
01133         tmp = BPSK_20;
01134     }
01135     else if((tmp & 0x1f) == 0x04)
01136     {
01137         rf_ack_wait_duration = 469;
01138         tmp = BPSK_40;
01139     }
01140     else if((tmp & 0x1f) == 0x14)
01141     {
01142         rf_ack_wait_duration = 469;
01143         tmp = BPSK_40_ALT;
01144     }
01145     else if((tmp & 0x1f) == 0x08)
01146     {
01147         rf_ack_wait_duration = 100;
01148         tmp = OQPSK_SIN_RC_100;
01149     }
01150     else if((tmp & 0x1f) == 0x09)
01151     {
01152         rf_ack_wait_duration = 50;
01153         tmp = OQPSK_SIN_RC_200;
01154     }
01155     else if((tmp & 0x1f) == 0x18)
01156     {
01157         rf_ack_wait_duration = 100;
01158         tmp = OQPSK_RC_100;
01159     }
01160     else if((tmp & 0x1f) == 0x19)
01161     {
01162         rf_ack_wait_duration = 50;
01163         tmp = OQPSK_RC_200;
01164     }
01165     else if((tmp & 0x1f) == 0x0c)
01166     {
01167         rf_ack_wait_duration = 50;
01168         tmp = OQPSK_SIN_250;
01169     }
01170     else if((tmp & 0x1f) == 0x0d)
01171     {
01172         rf_ack_wait_duration = 25;
01173         tmp = OQPSK_SIN_500;
01174     }
01175     else if((tmp & 0x1f) == 0x0f)
01176     {
01177         rf_ack_wait_duration = 25;
01178         tmp = OQPSK_SIN_500_ALT;
01179     }
01180     else if((tmp & 0x1f) == 0x1c)
01181     {
01182         rf_ack_wait_duration = 50;
01183         tmp = OQPSK_RC_250;
01184     }
01185     else if((tmp & 0x1f) == 0x1d)
01186     {
01187         rf_ack_wait_duration = 25;
01188         tmp = OQPSK_RC_500;
01189     }
01190     else if((tmp & 0x1f) == 0x1f)
01191     {
01192         rf_ack_wait_duration = 25;
01193         tmp = OQPSK_RC_500_ALT;
01194     }
01195     else if((tmp & 0x3f) == 0x2A)
01196     {
01197         rf_ack_wait_duration = 25;
01198         tmp = OQPSK_SIN_RC_400_SCR_ON;
01199     }
01200     else if((tmp & 0x3f) == 0x0A)
01201     {
01202         rf_ack_wait_duration = 25;
01203         tmp = OQPSK_SIN_RC_400_SCR_OFF;
01204     }
01205     else if((tmp & 0x3f) == 0x3A)
01206     {
01207         rf_ack_wait_duration = 25;
01208         tmp = OQPSK_RC_400_SCR_ON;
01209     }
01210     else if((tmp & 0x3f) == 0x1A)
01211     {
01212         rf_ack_wait_duration = 25;
01213         tmp = OQPSK_RC_400_SCR_OFF;
01214     }
01215     else if((tmp & 0x3f) == 0x2E)
01216     {
01217         rf_ack_wait_duration = 13;
01218         tmp = OQPSK_SIN_1000_SCR_ON;
01219     }
01220     else if((tmp & 0x3f) == 0x0E)
01221     {
01222         rf_ack_wait_duration = 13;
01223         tmp = OQPSK_SIN_1000_SCR_OFF;
01224     }
01225     else if((tmp & 0x3f) == 0x3E)
01226     {
01227         rf_ack_wait_duration = 13;
01228         tmp = OQPSK_RC_1000_SCR_ON;
01229     }
01230     else if((tmp & 0x3f) == 0x1E)
01231     {
01232         rf_ack_wait_duration = 13;
01233         tmp = OQPSK_RC_1000_SCR_OFF;
01234     }
01235     return tmp;
01236 }
01237