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, see <http://www.gnu.org/licenses/>. *
  17  ***************************************************************************/
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include "imp.h"
  24
  25 static struct flash_bank *virtual_get_master_bank(struct flash_bank *bank)
  26 {
  27         struct flash_bank *master_bank;
  28
  29         master_bank = get_flash_bank_by_name_noprobe(bank->driver_priv);
  30         if (master_bank == NULL)
  31                 LOG_ERROR("master flash bank '%s' does not exist", (char *)bank->driver_priv);
  32
  33         return master_bank;
  34 }
  35
  36 static void virtual_update_bank_info(struct flash_bank *bank)
  37 {
  38         struct flash_bank *master_bank = virtual_get_master_bank(bank);
  39
  40         if (master_bank == NULL)
  41                 return;
  42
  43         /* update the info we do not have */
  44         bank->size = master_bank->size;
  45         bank->chip_width = master_bank->chip_width;
  46         bank->bus_width = master_bank->bus_width;
  47         bank->erased_value = master_bank->erased_value;
  48         bank->default_padded_value = master_bank->default_padded_value;
  49         bank->write_start_alignment = master_bank->write_start_alignment;
  50         bank->write_end_alignment = master_bank->write_end_alignment;
  51         bank->minimal_write_gap = master_bank->minimal_write_gap;
  52         bank->num_sectors = master_bank->num_sectors;
  53         bank->sectors = master_bank->sectors;
  54         bank->num_prot_blocks = master_bank->num_prot_blocks;
  55         bank->prot_blocks = master_bank->prot_blocks;
  56 }
  57
  58 FLASH_BANK_COMMAND_HANDLER(virtual_flash_bank_command)
  59 {
  60         if (CMD_ARGC < 7)
  61                 return ERROR_COMMAND_SYNTAX_ERROR;
  62
  63         /* get the master flash bank */
  64         const char *bank_name = CMD_ARGV[6];
  65         struct flash_bank *master_bank = get_flash_bank_by_name_noprobe(bank_name);
  66
  67         if (master_bank == NULL) {
  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, unsigned int first,
  79                 unsigned int last)
  80 {
  81         struct flash_bank *master_bank = virtual_get_master_bank(bank);
  82         int retval;
  83
  84         if (master_bank == NULL)
  85                 return ERROR_FLASH_OPERATION_FAILED;
  86
  87         /* call master handler */
  88         retval = master_bank->driver->protect(master_bank, set, first, last);
  89         if (retval != 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         /* call master handler */
 104         retval = master_bank->driver->protect_check(master_bank);
 105         if (retval != ERROR_OK)
 106                 return retval;
 107
 108         return ERROR_OK;
 109 }
 110
 111 static int virtual_erase(struct flash_bank *bank, unsigned int first,
 112                 unsigned int last)
 113 {
 114         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 115         int retval;
 116
 117         if (master_bank == NULL)
 118                 return ERROR_FLASH_OPERATION_FAILED;
 119
 120         /* call master handler */
 121         retval = master_bank->driver->erase(master_bank, first, last);
 122         if (retval != ERROR_OK)
 123                 return retval;
 124
 125         return ERROR_OK;
 126 }
 127
 128 static int virtual_write(struct flash_bank *bank, const 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         /* call master handler */
 138         retval = master_bank->driver->write(master_bank, buffer, offset, count);
 139         if (retval != ERROR_OK)
 140                 return retval;
 141
 142         return ERROR_OK;
 143 }
 144
 145 static int virtual_probe(struct flash_bank *bank)
 146 {
 147         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 148         int retval;
 149
 150         if (master_bank == NULL)
 151                 return ERROR_FLASH_OPERATION_FAILED;
 152
 153         /* call master handler */
 154         retval = master_bank->driver->probe(master_bank);
 155         if (retval != ERROR_OK)
 156                 return retval;
 157
 158         /* update the info we do not have */
 159         virtual_update_bank_info(bank);
 160
 161         return ERROR_OK;
 162 }
 163
 164 static int virtual_auto_probe(struct flash_bank *bank)
 165 {
 166         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 167         int retval;
 168
 169         if (master_bank == NULL)
 170                 return ERROR_FLASH_OPERATION_FAILED;
 171
 172         /* call master handler */
 173         retval = master_bank->driver->auto_probe(master_bank);
 174         if (retval != ERROR_OK)
 175                 return retval;
 176
 177         /* update the info we do not have */
 178         virtual_update_bank_info(bank);
 179
 180         return ERROR_OK;
 181 }
 182
 183 static int virtual_info(struct flash_bank *bank, char *buf, int buf_size)
 184 {
 185         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 186
 187         if (master_bank == NULL)
 188                 return ERROR_FLASH_OPERATION_FAILED;
 189
 190         snprintf(buf, buf_size, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
 191                         bank->driver->name, master_bank->name, master_bank->base);
 192
 193         return ERROR_OK;
 194 }
 195
 196 static int virtual_blank_check(struct flash_bank *bank)
 197 {
 198         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 199         int retval;
 200
 201         if (master_bank == NULL)
 202                 return ERROR_FLASH_OPERATION_FAILED;
 203
 204         /* call master handler */
 205         retval = master_bank->driver->erase_check(master_bank);
 206         if (retval != ERROR_OK)
 207                 return retval;
 208
 209         return ERROR_OK;
 210 }
 211
 212 static int virtual_flash_read(struct flash_bank *bank,
 213                 uint8_t *buffer, uint32_t offset, uint32_t count)
 214 {
 215         struct flash_bank *master_bank = virtual_get_master_bank(bank);
 216         int retval;
 217
 218         if (master_bank == NULL)
 219                 return ERROR_FLASH_OPERATION_FAILED;
 220
 221         /* call master handler */
 222         retval = master_bank->driver->read(master_bank, buffer, offset, count);
 223         if (retval != ERROR_OK)
 224                 return retval;
 225
 226         return ERROR_OK;
 227 }
 228
 229 const struct flash_driver virtual_flash = {
 230         .name = "virtual",
 231         .flash_bank_command = virtual_flash_bank_command,
 232         .erase = virtual_erase,
 233         .protect = virtual_protect,
 234         .write = virtual_write,
 235         .read = virtual_flash_read,
 236         .probe = virtual_probe,
 237         .auto_probe = virtual_auto_probe,
 238         .erase_check = virtual_blank_check,
 239         .protect_check = virtual_protect_check,
 240         .info = virtual_info,
 241         .free_driver_priv = default_flash_free_driver_priv,
 242 };