flight/pios/stm32f4xx/pios_bl_helper.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup PIOS_BOOTLOADER Functions
   6  * @brief HAL code to interface to the OpenPilot AHRS module
   7  * @{
   8  *
   9  * @file       pios_bl_helper.c
  10  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
  11  * @brief      Bootloader Helper Functions
  12  * @see        The GNU Public License (GPL) Version 3
  13  *
  14  *****************************************************************************/
  15 /*
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 3 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful, but
  22  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  23  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  24  * for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along
  27  * with this program; if not, write to the Free Software Foundation, Inc.,
  28  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  */
  30
  31 #include <pios.h>
  32
  33 #ifdef PIOS_INCLUDE_BL_HELPER
  34
  35 #include <pios_board_info.h>
  36 #include <stm32f4xx_flash.h>
  37 #include <stdbool.h>
  38
  39 uint8_t *PIOS_BL_HELPER_FLASH_If_Read(uint32_t SectorAddress)
  40 {
  41     return (uint8_t *)(SectorAddress);
  42 }
  43
  44 #if defined(PIOS_INCLUDE_BL_HELPER_WRITE_SUPPORT)
  45
  46 static bool erase_flash(uint32_t startAddress, uint32_t endAddress);
  47
  48 uint8_t PIOS_BL_HELPER_FLASH_Ini()
  49 {
  50     FLASH_Unlock();
  51     FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
  52     return 1;
  53 }
  54
  55 struct device_flash_sector {
  56     uint32_t start;
  57     uint32_t size;
  58     uint16_t st_sector;
  59 };
  60
  61 static struct device_flash_sector flash_sectors[] = {
  62     [0] =  {
  63         .start     = 0x08000000,
  64         .size      = 16 * 1024,
  65         .st_sector = FLASH_Sector_0,
  66     },
  67     [1] =  {
  68         .start     = 0x08004000,
  69         .size      = 16 * 1024,
  70         .st_sector = FLASH_Sector_1,
  71     },
  72     [2] =  {
  73         .start     = 0x08008000,
  74         .size      = 16 * 1024,
  75         .st_sector = FLASH_Sector_2,
  76     },
  77     [3] =  {
  78         .start     = 0x0800C000,
  79         .size      = 16 * 1024,
  80         .st_sector = FLASH_Sector_3,
  81     },
  82     [4] =  {
  83         .start     = 0x08010000,
  84         .size      = 64 * 1024,
  85         .st_sector = FLASH_Sector_4,
  86     },
  87     [5] =  {
  88         .start     = 0x08020000,
  89         .size      = 128 * 1024,
  90         .st_sector = FLASH_Sector_5,
  91     },
  92     [6] =  {
  93         .start     = 0x08040000,
  94         .size      = 128 * 1024,
  95         .st_sector = FLASH_Sector_6,
  96     },
  97     [7] =  {
  98         .start     = 0x08060000,
  99         .size      = 128 * 1024,
 100         .st_sector = FLASH_Sector_7,
 101     },
 102     [8] =  {
 103         .start     = 0x08080000,
 104         .size      = 128 * 1024,
 105         .st_sector = FLASH_Sector_8,
 106     },
 107     [9] =  {
 108         .start     = 0x080A0000,
 109         .size      = 128 * 1024,
 110         .st_sector = FLASH_Sector_9,
 111     },
 112     [10] = {
 113         .start     = 0x080C0000,
 114         .size      = 128 * 1024,
 115         .st_sector = FLASH_Sector_10,
 116     },
 117     [11] = {
 118         .start     = 0x080E0000,
 119         .size      = 128 * 1024,
 120         .st_sector = FLASH_Sector_11,
 121     },
 122 };
 123
 124 static bool PIOS_BL_HELPER_FLASH_GetSectorInfo(uint32_t address, uint8_t *sector_number, uint32_t *sector_start, uint32_t *sector_size)
 125 {
 126     for (uint8_t i = 0; i < NELEMENTS(flash_sectors); i++) {
 127         struct device_flash_sector *sector = &flash_sectors[i];
 128         if ((address >= sector->start) &&
 129             (address < (sector->start + sector->size))) {
 130             /* address lies within this sector */
 131             *sector_number = sector->st_sector;
 132             *sector_start  = sector->start;
 133             *sector_size   = sector->size;
 134             return true;
 135         }
 136     }
 137
 138     return false;
 139 }
 140
 141 uint8_t PIOS_BL_HELPER_FLASH_Start()
 142 {
 143     const struct pios_board_info *bdinfo = &pios_board_info_blob;
 144     uint32_t startAddress = bdinfo->fw_base;
 145     uint32_t endAddress   = bdinfo->fw_base + bdinfo->fw_size + bdinfo->desc_size;
 146
 147     bool success = erase_flash(startAddress, endAddress);
 148
 149     return (success) ? 1 : 0;
 150 }
 151
 152
 153 uint8_t PIOS_BL_HELPER_FLASH_Erase_Bootloader()
 154 {
 155 /// Bootloader memory space erase
 156     uint32_t startAddress = BL_BANK_BASE;
 157     uint32_t endAddress   = BL_BANK_BASE + BL_BANK_SIZE;
 158
 159     bool success = erase_flash(startAddress, endAddress);
 160
 161     return (success) ? 1 : 0;
 162 }
 163
 164 static bool erase_flash(uint32_t startAddress, uint32_t endAddress)
 165 {
 166     uint32_t pageAddress = startAddress;
 167     bool fail = false;
 168
 169     while ((pageAddress < endAddress) && (fail == false)) {
 170         uint8_t sector_number;
 171         uint32_t sector_start;
 172         uint32_t sector_size;
 173         if (!PIOS_BL_HELPER_FLASH_GetSectorInfo(pageAddress,
 174                                                 &sector_number,
 175                                                 &sector_start,
 176                                                 &sector_size)) {
 177             /* We're asking for an invalid flash address */
 178             PIOS_Assert(0);
 179         }
 180         for (int retry = 0; retry < MAX_DEL_RETRYS; ++retry) {
 181             if (FLASH_EraseSector(sector_number, VoltageRange_3) == FLASH_COMPLETE) {
 182                 fail = false;
 183                 break;
 184             } else {
 185                 fail = true;
 186             }
 187         }
 188         /* Move to the next sector */
 189         pageAddress += sector_size;
 190     }
 191     return !fail;
 192 }
 193
 194 #endif /* if defined(PIOS_INCLUDE_BL_HELPER_WRITE_SUPPORT) */
 195
 196 uint32_t PIOS_BL_HELPER_CRC_Memory_Calc()
 197 {
 198     const struct pios_board_info *bdinfo = &pios_board_info_blob;
 199
 200     PIOS_BL_HELPER_CRC_Ini();
 201     CRC_ResetDR();
 202     CRC_CalcBlockCRC((uint32_t *)bdinfo->fw_base, (bdinfo->fw_size) >> 2);
 203     return CRC_GetCRC();
 204 }
 205
 206 void PIOS_BL_HELPER_FLASH_Read_Description(uint8_t *array, uint8_t size)
 207 {
 208     const struct pios_board_info *bdinfo = &pios_board_info_blob;
 209     uint8_t x = 0;
 210
 211     if (size > bdinfo->desc_size) {
 212         size = bdinfo->desc_size;
 213     }
 214     for (uint32_t i = bdinfo->fw_base + bdinfo->fw_size; i < bdinfo->fw_base + bdinfo->fw_size + size; ++i) {
 215         array[x] = *PIOS_BL_HELPER_FLASH_If_Read(i);
 216         ++x;
 217     }
 218 }
 219
 220 void PIOS_BL_HELPER_CRC_Ini()
 221 {}
 222
 223 #endif /* PIOS_INCLUDE_BL_HELPER */