src/flash/nor/virtual.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Spencer Oliver                                  *
   3  *   spen@spen-soft.co.uk                                                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "imp.h"
  25
  26 static struct flash_bank* virtual_get_master_bank(struct flash_bank *bank)
  27 {
  28         struct flash_bank* master_bank;
  29
  30         master_bank = get_flash_bank_by_name_noprobe(bank->driver_priv);
  31         if (master_bank == NULL) {
  32                 LOG_ERROR("master flash bank '%s' does not exist", (char*)bank->driver_priv);
  33         }
  34
  35         return master_bank;
  36 }
  37
  38 static void virtual_update_bank_info(struct flash_bank *bank)
  39 {
  40         struct flash_bank *master_bank = virtual_get_master_bank(bank);
  41
  42         if (master_bank == NULL) {
  43                 return;
  44         }
  45
  46         /* update the info we do not have */
  47         bank->size = master_bank->size;
  48         bank->chip_width = master_bank->chip_width;
  49         bank->bus_width = master_bank->bus_width;
  50         bank->num_sectors = master_bank->num_sectors;
  51         bank->sectors = master_bank->sectors;
  52 }
  53
  54 FLASH_BANK_COMMAND_HANDLER(virtual_flash_bank_command)
  55 {
  56         if (CMD_ARGC < 7)
  57         {
  58                 LOG_WARNING("incomplete flash_bank virtual configuration");
  59                 return ERROR_FLASH_OPERATION_FAILED;
  60         }
  61
  62         /* get the master flash bank */
  63         const char *bank_name = CMD_ARGV[6];
  64         struct flash_bank *master_bank = get_flash_bank_by_name_noprobe(bank_name);
  65
  66         if (master_bank == NULL)
  67         {
  68                 LOG_ERROR("master flash bank '%s' does not exist", bank_name);
  69                 return ERROR_FLASH_OPERATION_FAILED;
  70         }
  71
  72         /* save master bank name - use this to get settings later */
  73         bank->driver_priv = strdup(bank_name);
  74
  75         return ERROR_OK;
  76 }
  77
  78 static int virtual_protect(struct flash_bank *bank, int set, int first, int last)
  79 {
  80         struct flash_bank *master_bank = virtual_get_master_bank(bank);
  81         int retval;
  82
  83         if (master_bank == NULL) {
  84                 return ERROR_FLASH_OPERATION_FAILED;
  85         }
  86
  87         /* call master handler */
  88         if ((retval = master_bank->driver->protect(master_bank, set,
  89                         first, last)) != ERROR_OK)
  90                 return retval;
  91
  92         return ERROR_OK;
  93 }
  94
  95 static int virtual_protect_check(struct flash_bank *bank)
  96 {
  97         struct flash_bank *master_bank = virtual_get_master_bank(bank);
  98         int retval;
  99
 100         if (master_bank == NULL) {
 101                 return ERROR_FLASH_OPERATION_FAILED;
 102         }
 103
 104         /* call master handler */
 105         if ((retval = master_bank->driver->protect_check(master_bank)) != ERROR_OK)
 106                 return retval;
 107
 108         return ERROR_OK;
 109 }
 110
 111 static int virtual_erase(struct flash_bank *bank, int first, int last)
 112 {
 113         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 114         int retval;
 115
 116         if (master_bank == NULL) {
 117                 return ERROR_FLASH_OPERATION_FAILED;
 118         }
 119
 120         /* call master handler */
 121         if ((retval = master_bank->driver->erase(master_bank,
 122                         first, last)) != ERROR_OK)
 123                 return retval;
 124
 125         return ERROR_OK;
 126 }
 127
 128 static int virtual_write(struct flash_bank *bank, uint8_t *buffer,
 129                 uint32_t offset, uint32_t count)
 130 {
 131         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 132         int retval;
 133
 134         if (master_bank == NULL) {
 135                 return ERROR_FLASH_OPERATION_FAILED;
 136         }
 137
 138         /* call master handler */
 139         if ((retval = master_bank->driver->write(master_bank, buffer,
 140                         offset, count)) != ERROR_OK)
 141                 return retval;
 142
 143         return ERROR_OK;
 144 }
 145
 146 static int virtual_probe(struct flash_bank *bank)
 147 {
 148         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 149         int retval;
 150
 151         if (master_bank == NULL) {
 152                 return ERROR_FLASH_OPERATION_FAILED;
 153         }
 154
 155         /* call master handler */
 156         if ((retval = master_bank->driver->probe(master_bank)) != ERROR_OK)
 157                 return retval;
 158
 159         /* update the info we do not have */
 160         virtual_update_bank_info(bank);
 161
 162         return ERROR_OK;
 163 }
 164
 165 static int virtual_auto_probe(struct flash_bank *bank)
 166 {
 167         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 168         int retval;
 169
 170         if (master_bank == NULL) {
 171                 return ERROR_FLASH_OPERATION_FAILED;
 172         }
 173
 174         /* call master handler */
 175         if ((retval = master_bank->driver->auto_probe(master_bank)) != ERROR_OK)
 176                 return retval;
 177
 178         /* update the info we do not have */
 179         virtual_update_bank_info(bank);
 180
 181         return ERROR_OK;
 182 }
 183
 184 static int virtual_info(struct flash_bank *bank, char *buf, int buf_size)
 185 {
 186         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 187
 188         if (master_bank == NULL) {
 189                 return ERROR_FLASH_OPERATION_FAILED;
 190         }
 191
 192         snprintf(buf, buf_size, "%s driver for flash bank %s at 0x%8.8" PRIx32 "",
 193                         bank->driver->name, master_bank->name, master_bank->base);
 194
 195         return ERROR_OK;
 196 }
 197
 198 int virtual_blank_check(struct flash_bank *bank)
 199 {
 200         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 201         int retval;
 202
 203         if (master_bank == NULL) {
 204                 return ERROR_FLASH_OPERATION_FAILED;
 205         }
 206
 207         /* call master handler */
 208         if ((retval = master_bank->driver->erase_check(master_bank)) != ERROR_OK)
 209                 return retval;
 210
 211         return ERROR_OK;
 212 }
 213
 214 int virtual_flash_read(struct flash_bank *bank,
 215                 uint8_t *buffer, uint32_t offset, uint32_t count)
 216 {
 217         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 218         int retval;
 219
 220         if (master_bank == NULL) {
 221                 return ERROR_FLASH_OPERATION_FAILED;
 222         }
 223
 224         /* call master handler */
 225         if ((retval = master_bank->driver->read(master_bank, buffer,
 226                         offset, count)) != ERROR_OK)
 227                 return retval;
 228
 229         return ERROR_OK;
 230 }
 231
 232 struct flash_driver virtual_flash = {
 233         .name = "virtual",
 234         .flash_bank_command = virtual_flash_bank_command,
 235         .erase = virtual_erase,
 236         .protect = virtual_protect,
 237         .write = virtual_write,
 238         .read = virtual_flash_read,
 239         .probe = virtual_probe,
 240         .auto_probe = virtual_auto_probe,
 241         .erase_check = virtual_blank_check,
 242         .protect_check = virtual_protect_check,
 243         .info = virtual_info,
 244 };