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 "hal_types.h"
00017 #include "osal.h"
00018 #include "ble_status.h"
00019 #include "hal.h"
00020 #include "osal.h"
00021 #include "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;
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   if (hci_send_req(&rq) < 0)
00040     return BLE_STATUS_TIMEOUT;
00041 
00042   return status;  
00043 }
00044 
00045 tBleStatus aci_updater_reboot(void)
00046 {
00047   struct hci_request rq;
00048   uint8_t status;
00049 
00050   Osal_MemSet(&rq, 0, sizeof(rq));
00051   rq.ogf = OGF_VENDOR_CMD;
00052   rq.ocf = OCF_UPDATER_REBOOT;
00053   rq.rparam = &status;
00054   rq.rlen = 1;
00055 
00056   if (hci_send_req(&rq) < 0)
00057     return BLE_STATUS_TIMEOUT;
00058 
00059   return status;  
00060 }
00061 
00062 tBleStatus aci_get_updater_version(uint8_t *version)
00063 {
00064   struct hci_request rq;
00065   get_updater_version_rp resp;
00066 
00067   Osal_MemSet(&resp, 0, sizeof(resp));
00068 
00069   Osal_MemSet(&rq, 0, sizeof(rq));
00070   rq.ogf = OGF_VENDOR_CMD;
00071   rq.ocf = OCF_GET_UPDATER_VERSION;
00072   rq.rparam = &resp;
00073   rq.rlen = GET_UPDATER_VERSION_RP_SIZE;
00074 
00075   if (hci_send_req(&rq) < 0)
00076     return BLE_STATUS_TIMEOUT;
00077     
00078   *version = resp.version;
00079 
00080   return resp.status;
00081 }
00082 
00083 tBleStatus aci_get_updater_buffer_size(uint8_t *buffer_size)
00084 {
00085   struct hci_request rq;
00086   get_updater_bufsize_rp resp;
00087 
00088   Osal_MemSet(&resp, 0, sizeof(resp));
00089 
00090   Osal_MemSet(&rq, 0, sizeof(rq));
00091   rq.ogf = OGF_VENDOR_CMD;
00092   rq.ocf = OCF_GET_UPDATER_BUFSIZE;
00093   rq.rparam = &resp;
00094   rq.rlen = GET_UPDATER_BUFSIZE_RP_SIZE;
00095 
00096   if (hci_send_req(&rq) < 0)
00097     return BLE_STATUS_TIMEOUT;
00098     
00099   *buffer_size = resp.buffer_size;
00100 
00101   return resp.status;
00102 }
00103 
00104 tBleStatus aci_erase_blue_flag(void)
00105 {
00106   struct hci_request rq;
00107   uint8_t status;
00108 
00109   Osal_MemSet(&rq, 0, sizeof(rq));
00110   rq.ogf = OGF_VENDOR_CMD;
00111   rq.ocf = OCF_UPDATER_ERASE_BLUE_FLAG;
00112   rq.rparam = &status;
00113   rq.rlen = 1;
00114 
00115   if (hci_send_req(&rq) < 0)
00116     return BLE_STATUS_TIMEOUT;
00117 
00118   return status;  
00119 }
00120 
00121 tBleStatus aci_reset_blue_flag(void)
00122 {
00123   struct hci_request rq;
00124   uint8_t status;
00125 
00126   Osal_MemSet(&rq, 0, sizeof(rq));
00127   rq.ogf = OGF_VENDOR_CMD;
00128   rq.ocf = OCF_UPDATER_RESET_BLUE_FLAG;
00129   rq.rparam = &status;
00130   rq.rlen = 1;
00131 
00132   if (hci_send_req(&rq) < 0)
00133     return BLE_STATUS_TIMEOUT;
00134 
00135   return status;  
00136 }
00137 
00138 tBleStatus aci_updater_erase_sector(uint32_t address)
00139 {
00140   struct hci_request rq;
00141   updater_erase_sector_cp cp;    
00142   uint8_t status;
00143     
00144   cp.address = htobl(address);
00145 
00146   Osal_MemSet(&rq, 0, sizeof(rq));
00147   rq.ogf = OGF_VENDOR_CMD;
00148   rq.ocf = OCF_UPDATER_ERASE_SECTOR;
00149   rq.cparam = &cp;
00150   rq.clen = UPDATER_ERASE_SECTOR_CP_SIZE;
00151   rq.rparam = &status;
00152   rq.rlen = 1;
00153 
00154   if (hci_send_req(&rq) < 0)
00155     return BLE_STATUS_TIMEOUT;
00156 
00157   return status;
00158 }
00159 
00160 tBleStatus aci_updater_program_data_block(uint32_t address, 
00161                    uint16_t len,
00162                    const uint8_t *data)
00163 {
00164   struct hci_request rq;
00165   uint8_t status;
00166   uint8_t buffer[HCI_MAX_PACKET_SIZE];
00167   uint8_t indx = 0;
00168     
00169   if((len+6) > HCI_MAX_PACKET_SIZE)
00170     return BLE_STATUS_INVALID_PARAMS;
00171     
00172   address = htobl(address);
00173   Osal_MemCpy(buffer + indx, &address, 4);
00174   indx += 4;
00175     
00176   len = htobs(len);
00177   Osal_MemCpy(buffer + indx, &len, 2);
00178   indx += 2;
00179         
00180   Osal_MemCpy(buffer + indx, data, len);
00181   indx +=  len;
00182 
00183   Osal_MemSet(&rq, 0, sizeof(rq));
00184   rq.ogf = OGF_VENDOR_CMD;
00185   rq.ocf = OCF_UPDATER_PROG_DATA_BLOCK;
00186   rq.cparam = (void *)buffer;
00187   rq.clen = indx;
00188   rq.rparam = &status;
00189   rq.rlen = 1;
00190 
00191   if (hci_send_req(&rq) < 0)
00192     return BLE_STATUS_TIMEOUT;
00193     
00194   return status;
00195 }
00196 
00197 tBleStatus aci_updater_read_data_block(uint32_t address,
00198                 uint16_t data_len,
00199                 uint8_t *data)
00200 {
00201   struct hci_request rq;
00202   updater_read_data_block_cp cp;
00203   uint8_t buffer[HCI_MAX_PACKET_SIZE];
00204     
00205   if((data_len+1) > HCI_MAX_PACKET_SIZE)
00206     return BLE_STATUS_INVALID_PARAMS;
00207     
00208   cp.address = htobl(address);
00209   cp.data_len = htobs(data_len);
00210 
00211   Osal_MemSet(&rq, 0, sizeof(rq));
00212   rq.ogf = OGF_VENDOR_CMD;
00213   rq.ocf = OCF_UPDATER_READ_DATA_BLOCK;
00214   rq.cparam = &cp;
00215   rq.clen = UPDATER_READ_DATA_BLOCK_CP_SIZE;
00216   rq.rparam = buffer;
00217   rq.rlen = data_len + 1;
00218 
00219   if (hci_send_req(&rq) < 0)
00220     return BLE_STATUS_TIMEOUT;
00221     
00222   // First byte is status
00223   Osal_MemCpy(data, buffer+1, data_len);
00224 
00225   return buffer[0];
00226 }
00227 
00228 tBleStatus aci_updater_calc_crc(uint32_t address,
00229                          uint8_t num_sectors,
00230                          uint32_t *crc)
00231 {
00232   struct hci_request rq;
00233   updater_calc_crc_cp cp;
00234   updater_calc_crc_rp resp;
00235     
00236   Osal_MemSet(&resp, 0, sizeof(resp));
00237     
00238   cp.address = htobl(address);
00239   cp.num_sectors = num_sectors;
00240 
00241   Osal_MemSet(&rq, 0, sizeof(rq));
00242   rq.ogf = OGF_VENDOR_CMD;
00243   rq.ocf = OCF_UPDATER_CALC_CRC;
00244   rq.cparam = &cp;
00245   rq.clen = UPDATER_CALC_CRC_CP_SIZE;
00246   rq.rparam = &resp;
00247   rq.rlen = UPDATER_CALC_CRC_RP_SIZE;
00248 
00249   if (hci_send_req(&rq) < 0)
00250     return BLE_STATUS_TIMEOUT;
00251     
00252   *crc = btohl(resp.crc);
00253     
00254   return resp.status;
00255 }
00256 
00257 tBleStatus aci_updater_hw_version(uint8_t *version)
00258 {
00259   struct hci_request rq;
00260   updater_hw_version_rp resp;
00261 
00262   Osal_MemSet(&resp, 0, sizeof(resp));
00263 
00264   Osal_MemSet(&rq, 0, sizeof(rq));
00265   rq.ogf = OGF_VENDOR_CMD;
00266   rq.ocf = OCF_UPDATER_HW_VERSION;
00267   rq.rparam = &resp;
00268   rq.rlen = UPDATER_HW_VERSION_RP_SIZE;
00269 
00270   if (hci_send_req(&rq) < 0)
00271     return BLE_STATUS_TIMEOUT;
00272     
00273   *version = resp.version;
00274 
00275   return resp.status;
00276 }
00277 
00278 
00279 
00280 
00281