bluenrg_updater_aci.c

00001 /******************** (C) COPYRIGHT 2013 STMicroelectronics ********************
00002 * File Name          : bluenrg_hci.c
00003 * Author             : AMS - HEA&RF BU
00004 * Version            : V1.0.0
00005 * Date               : 4-Oct-2013
00006 * Description        : File with HCI commands for BlueNRG FW6.0 and above.
00007 ********************************************************************************
00008 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
00009 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
00010 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
00011 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
00012 * CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
00013 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
00014 *******************************************************************************/
00015 
00016 #include "ble_hal_types.h"
00017 #include "ble_osal.h"
00018 #include "ble_status.h"
00019 #include "ble_hal.h"
00020 #include "ble_osal.h"
00021 #include "ble_hci_const.h"
00022 #include "bluenrg_aci_const.h"
00023 #include "bluenrg_updater_aci.h"
00024 
00025 #define MIN(a,b)            ((a) < (b) )? (a) : (b)
00026 #define MAX(a,b)            ((a) > (b) )? (a) : (b)
00027 
00028 tBleStatus aci_updater_start(void)
00029 {
00030   struct hci_request rq;
00031   uint8_t status = 0;
00032 
00033   Osal_MemSet(&rq, 0, sizeof(rq));
00034   rq.ogf = OGF_VENDOR_CMD;
00035   rq.ocf = OCF_UPDATER_START;
00036   rq.rparam = &status;
00037   rq.rlen = 1;
00038 
00039   hci_send_req(&rq, FALSE); // No command complete is sent.
00040 
00041   return status;  
00042 }
00043 
00044 tBleStatus aci_updater_reboot(void)
00045 {
00046   struct hci_request rq;
00047   uint8_t status = 0;
00048 
00049   Osal_MemSet(&rq, 0, sizeof(rq));
00050   rq.ogf = OGF_VENDOR_CMD;
00051   rq.ocf = OCF_UPDATER_REBOOT;
00052   rq.rparam = &status;
00053   rq.rlen = 1;
00054 
00055   hci_send_req(&rq, FALSE); // No command complete is sent.
00056 
00057   return status;
00058 }
00059 
00060 tBleStatus aci_get_updater_version(uint8_t *version)
00061 {
00062   struct hci_request rq;
00063   get_updater_version_rp resp;
00064 
00065   Osal_MemSet(&resp, 0, sizeof(resp));
00066 
00067   Osal_MemSet(&rq, 0, sizeof(rq));
00068   rq.ogf = OGF_VENDOR_CMD;
00069   rq.ocf = OCF_GET_UPDATER_VERSION;
00070   rq.rparam = &resp;
00071   rq.rlen = GET_UPDATER_VERSION_RP_SIZE;
00072 
00073   if (hci_send_req(&rq, FALSE) < 0)
00074     return BLE_STATUS_TIMEOUT;
00075     
00076   *version = resp.version;
00077 
00078   return resp.status;
00079 }
00080 
00081 tBleStatus aci_get_updater_buffer_size(uint8_t *buffer_size)
00082 {
00083   struct hci_request rq;
00084   get_updater_bufsize_rp resp;
00085 
00086   Osal_MemSet(&resp, 0, sizeof(resp));
00087 
00088   Osal_MemSet(&rq, 0, sizeof(rq));
00089   rq.ogf = OGF_VENDOR_CMD;
00090   rq.ocf = OCF_GET_UPDATER_BUFSIZE;
00091   rq.rparam = &resp;
00092   rq.rlen = GET_UPDATER_BUFSIZE_RP_SIZE;
00093 
00094   if (hci_send_req(&rq, FALSE) < 0)
00095     return BLE_STATUS_TIMEOUT;
00096     
00097   *buffer_size = resp.buffer_size;
00098 
00099   return resp.status;
00100 }
00101 
00102 tBleStatus aci_erase_blue_flag(void)
00103 {
00104   struct hci_request rq;
00105   uint8_t status;
00106 
00107   Osal_MemSet(&rq, 0, sizeof(rq));
00108   rq.ogf = OGF_VENDOR_CMD;
00109   rq.ocf = OCF_UPDATER_ERASE_BLUE_FLAG;
00110   rq.rparam = &status;
00111   rq.rlen = 1;
00112 
00113   if (hci_send_req(&rq, FALSE) < 0)
00114     return BLE_STATUS_TIMEOUT;
00115 
00116   return status;  
00117 }
00118 
00119 tBleStatus aci_reset_blue_flag(void)
00120 {
00121   struct hci_request rq;
00122   uint8_t status;
00123 
00124   Osal_MemSet(&rq, 0, sizeof(rq));
00125   rq.ogf = OGF_VENDOR_CMD;
00126   rq.ocf = OCF_UPDATER_RESET_BLUE_FLAG;
00127   rq.rparam = &status;
00128   rq.rlen = 1;
00129 
00130   if (hci_send_req(&rq, FALSE) < 0)
00131     return BLE_STATUS_TIMEOUT;
00132 
00133   return status;  
00134 }
00135 
00136 tBleStatus aci_updater_erase_sector(uint32_t address)
00137 {
00138   struct hci_request rq;
00139   updater_erase_sector_cp cp;    
00140   uint8_t status;
00141     
00142   cp.address = htobl(address);
00143 
00144   Osal_MemSet(&rq, 0, sizeof(rq));
00145   rq.ogf = OGF_VENDOR_CMD;
00146   rq.ocf = OCF_UPDATER_ERASE_SECTOR;
00147   rq.cparam = &cp;
00148   rq.clen = UPDATER_ERASE_SECTOR_CP_SIZE;
00149   rq.rparam = &status;
00150   rq.rlen = 1;
00151 
00152   if (hci_send_req(&rq, FALSE) < 0)
00153     return BLE_STATUS_TIMEOUT;
00154 
00155   return status;
00156 }
00157 
00158 tBleStatus aci_updater_program_data_block(uint32_t address, 
00159                    uint16_t len,
00160                    const uint8_t *data)
00161 {
00162   struct hci_request rq;
00163   uint8_t status;
00164   updater_prog_data_block_cp cp;
00165     
00166   if( len > sizeof(cp.data))
00167     return BLE_STATUS_INVALID_PARAMS;
00168   
00169   cp.address = htobl(address);
00170   cp.data_len = htobs(len);        
00171   Osal_MemCpy(cp.data, data, len);
00172 
00173   Osal_MemSet(&rq, 0, sizeof(rq));
00174   rq.ogf = OGF_VENDOR_CMD;
00175   rq.ocf = OCF_UPDATER_PROG_DATA_BLOCK;
00176   rq.cparam = &cp;
00177   rq.clen = UPDATER_PROG_DATA_BLOCK_CP_SIZE+len;
00178   rq.rparam = &status;
00179   rq.rlen = 1;
00180 
00181   if (hci_send_req(&rq, FALSE) < 0)
00182     return BLE_STATUS_TIMEOUT;
00183     
00184   return status;
00185 }
00186 
00187 tBleStatus aci_updater_read_data_block(uint32_t address,
00188                 uint16_t data_len,
00189                 uint8_t *data)
00190 {
00191   struct hci_request rq;
00192   updater_read_data_block_cp cp;
00193   uint8_t buffer[HCI_MAX_PAYLOAD_SIZE];
00194     
00195   if((data_len+1) > HCI_MAX_PAYLOAD_SIZE)
00196     return BLE_STATUS_INVALID_PARAMS;
00197     
00198   cp.address = htobl(address);
00199   cp.data_len = htobs(data_len);
00200 
00201   Osal_MemSet(&rq, 0, sizeof(rq));
00202   rq.ogf = OGF_VENDOR_CMD;
00203   rq.ocf = OCF_UPDATER_READ_DATA_BLOCK;
00204   rq.cparam = &cp;
00205   rq.clen = UPDATER_READ_DATA_BLOCK_CP_SIZE;
00206   rq.rparam = buffer;
00207   rq.rlen = data_len + 1;
00208 
00209   if (hci_send_req(&rq, FALSE) < 0)
00210     return BLE_STATUS_TIMEOUT;
00211     
00212   // First byte is status
00213   Osal_MemCpy(data, buffer+1, data_len);
00214 
00215   return buffer[0];
00216 }
00217 
00218 tBleStatus aci_updater_calc_crc(uint32_t address,
00219                          uint8_t num_sectors,
00220                          uint32_t *crc)
00221 {
00222   struct hci_request rq;
00223   updater_calc_crc_cp cp;
00224   updater_calc_crc_rp resp;
00225     
00226   Osal_MemSet(&resp, 0, sizeof(resp));
00227     
00228   cp.address = htobl(address);
00229   cp.num_sectors = num_sectors;
00230 
00231   Osal_MemSet(&rq, 0, sizeof(rq));
00232   rq.ogf = OGF_VENDOR_CMD;
00233   rq.ocf = OCF_UPDATER_CALC_CRC;
00234   rq.cparam = &cp;
00235   rq.clen = UPDATER_CALC_CRC_CP_SIZE;
00236   rq.rparam = &resp;
00237   rq.rlen = UPDATER_CALC_CRC_RP_SIZE;
00238 
00239   if (hci_send_req(&rq, FALSE) < 0)
00240     return BLE_STATUS_TIMEOUT;
00241     
00242   *crc = btohl(resp.crc);
00243     
00244   return resp.status;
00245 }
00246 
00247 tBleStatus aci_updater_hw_version(uint8_t *version)
00248 {
00249   struct hci_request rq;
00250   updater_hw_version_rp resp;
00251 
00252   Osal_MemSet(&resp, 0, sizeof(resp));
00253 
00254   Osal_MemSet(&rq, 0, sizeof(rq));
00255   rq.ogf = OGF_VENDOR_CMD;
00256   rq.ocf = OCF_UPDATER_HW_VERSION;
00257   rq.rparam = &resp;
00258   rq.rlen = UPDATER_HW_VERSION_RP_SIZE;
00259 
00260   if (hci_send_req(&rq, FALSE) < 0)
00261     return BLE_STATUS_TIMEOUT;
00262     
00263   *version = resp.version;
00264 
00265   return resp.status;
00266 }
00267 
00268 
00269