src/flash/nor/ocl.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Pavel Chromy                                    *
   3  *   chromy@asix.cz                                                        *
   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 #include "ocl.h"
  26 #include <target/embeddedice.h>
  27
  28
  29 struct ocl_priv
  30 {
  31         struct arm_jtag *jtag_info;
  32         unsigned int buflen;
  33         unsigned int bufalign;
  34 };
  35
  36 static int ocl_erase_check(struct flash_bank *bank)
  37 {
  38         return ERROR_OK;
  39 }
  40
  41 static int ocl_protect_check(struct flash_bank *bank)
  42 {
  43         return ERROR_OK;
  44 }
  45
  46 /* flash_bank ocl 0 0 0 0 <target#> */
  47 FLASH_BANK_COMMAND_HANDLER(ocl_flash_bank_command)
  48 {
  49         struct arm7_9_common *arm7_9;
  50         struct ocl_priv *ocl;
  51
  52         if (CMD_ARGC < 6)
  53         {
  54                 LOG_WARNING("incomplete flash_bank ocl configuration");
  55                 return ERROR_FLASH_BANK_INVALID;
  56         }
  57
  58         struct flash_bank *bank = flash_bank_from_object(object);
  59         arm7_9 = target_to_arm7_9(bank->target);
  60         if (!is_arm7_9(arm7_9))
  61                 return ERROR_TARGET_INVALID;
  62
  63         ocl = malloc(sizeof(struct ocl_priv));
  64         ocl->jtag_info = &arm7_9->jtag_info;
  65         ocl->buflen = 0;
  66         ocl->bufalign = 1;
  67
  68         set_flash_bank_data(bank, ocl);
  69
  70         return ERROR_OK;
  71 }
  72
  73 static struct ocl_priv *ocl_bank_data(struct flash_bank *bank)
  74 {
  75         return (struct ocl_priv *)flash_bank_data(bank);
  76 }
  77
  78 static int ocl_erase(struct flash_bank *bank, int first, int last)
  79 {
  80         struct ocl_priv *ocl = ocl_bank_data(bank);
  81         int retval;
  82         uint32_t dcc_buffer[3];
  83
  84         /* check preconditions */
  85         if (bank->num_sectors == 0)
  86                 return ERROR_FLASH_BANK_NOT_PROBED;
  87
  88         if (bank->target->state != TARGET_RUNNING)
  89         {
  90                 LOG_ERROR("target has to be running to communicate with the loader");
  91                 return ERROR_TARGET_NOT_RUNNING;
  92         }
  93
  94         if ((first == 0) && (last == bank->num_sectors - 1))
  95         {
  96                 dcc_buffer[0] = OCL_ERASE_ALL;
  97                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
  98                         return retval;
  99         }
 100         else
 101         {
 102                 dcc_buffer[0] = OCL_ERASE_BLOCK;
 103                 dcc_buffer[1] = first;
 104                 dcc_buffer[2] = last;
 105                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 3) != ERROR_OK))
 106                         return retval;
 107         }
 108
 109         /* wait for response, fixed timeout of 1 s */
 110         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))
 111         {
 112                 if (retval == ERROR_TARGET_TIMEOUT)
 113                         LOG_ERROR("loader not responding");
 114                 return retval;
 115         }
 116
 117         /* receive response */
 118         if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer + 1, 1) != ERROR_OK))
 119                 return retval;
 120
 121         if (dcc_buffer[1] != OCL_CMD_DONE)
 122         {
 123                 if (dcc_buffer[0] == OCL_ERASE_ALL)
 124                         LOG_ERROR("loader response to OCL_ERASE_ALL 0x%08" PRIx32 "", dcc_buffer[1]);
 125                 else
 126                         LOG_ERROR("loader response to OCL_ERASE_BLOCK 0x%08" PRIx32 "", dcc_buffer[1]);
 127                 return ERROR_FLASH_OPERATION_FAILED;
 128         }
 129
 130         return ERROR_OK;
 131 }
 132
 133 static int ocl_protect(struct flash_bank *bank, int set, int first, int last)
 134 {
 135         return ERROR_OK;
 136 }
 137
 138 static int ocl_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 139 {
 140         struct ocl_priv *ocl = ocl_bank_data(bank);
 141         int retval;
 142         uint32_t *dcc_buffer;
 143         uint32_t *dcc_bufptr;
 144         int byteofs;
 145         int runlen;
 146         uint32_t chksum;
 147
 148         int i;
 149
 150         /* check preconditions */
 151         if (ocl->buflen == 0 || ocl->bufalign == 0)
 152                 return ERROR_FLASH_BANK_NOT_PROBED;
 153
 154         if (bank->target->state != TARGET_RUNNING)
 155         {
 156                 LOG_ERROR("target has to be running to communicate with the loader");
 157                 return ERROR_TARGET_NOT_RUNNING;
 158         }
 159
 160         /* allocate buffer for max. ocl buffer + overhead */
 161         dcc_buffer = malloc(sizeof(uint32_t)*(ocl->buflen/4 + 3));
 162
 163         while (count)
 164         {
 165                 if (count + (offset % ocl->bufalign) > ocl->buflen)
 166                         runlen = ocl->buflen - (offset % ocl->bufalign);
 167                 else
 168                         runlen = count;
 169
 170                 dcc_buffer[0] = OCL_FLASH_BLOCK | runlen;
 171                 dcc_buffer[1] = offset;
 172                 dcc_bufptr = &dcc_buffer[2];
 173
 174                 *dcc_bufptr = 0xffffffff;
 175                 byteofs = (offset % ocl->bufalign) % 4;
 176                 chksum = OCL_CHKS_INIT;
 177
 178                 /* copy data to DCC buffer in proper byte order and properly aligned */
 179                 for (i = 0; i < runlen; i++)
 180                 {
 181                         switch (byteofs++)
 182                         {
 183                                 case 0:
 184                                         *dcc_bufptr &= *(buffer++) | 0xffffff00;
 185                                         break;
 186                                 case 1:
 187                                         *dcc_bufptr &= ((*(buffer++)) << 8) | 0xffff00ff;
 188                                         break;
 189                                 case 2:
 190                                         *dcc_bufptr &= ((*(buffer++)) << 16) | 0xff00ffff;
 191                                         break;
 192                                 case 3:
 193                                         *dcc_bufptr &= ((*(buffer++)) << 24) | 0x00ffffff;
 194                                         chksum ^= *(dcc_bufptr++);
 195                                         *dcc_bufptr = 0xffffffff;
 196                                         byteofs = 0;
 197                                         break;
 198                         }
 199                 }
 200
 201                 /* add the remaining word to checksum */
 202                 if (byteofs)
 203                         chksum ^= *(dcc_bufptr++);
 204
 205                 *(dcc_bufptr++) = chksum;
 206
 207                 /* send the data */
 208                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, dcc_bufptr-dcc_buffer)) != ERROR_OK)
 209                 {
 210                         free(dcc_buffer);
 211                   return retval;
 212                 }
 213
 214                 /* wait for response, fixed timeout of 1 s */
 215                 if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))
 216                 {
 217                         if (retval == ERROR_TARGET_TIMEOUT)
 218                                 LOG_ERROR("loader not responding");
 219                         free(dcc_buffer);
 220                         return retval;
 221                 }
 222
 223                 /* receive response */
 224                 if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 225                 {
 226                         free(dcc_buffer);
 227                         return retval;
 228                 }
 229
 230                 if (dcc_buffer[0] != OCL_CMD_DONE)
 231                 {
 232                         LOG_ERROR("loader response to OCL_FLASH_BLOCK 0x%08" PRIx32 "", dcc_buffer[0]);
 233                         free(dcc_buffer);
 234                         return ERROR_FLASH_OPERATION_FAILED;
 235                 }
 236
 237                 count -= runlen;
 238                 offset += runlen;
 239         }
 240
 241         free(dcc_buffer);
 242         return ERROR_OK;
 243 }
 244
 245 static int ocl_probe(struct flash_bank *bank)
 246 {
 247         struct ocl_priv *ocl = ocl_bank_data(bank);
 248         int retval;
 249         uint32_t dcc_buffer[1];
 250         int sectsize;
 251         int i;
 252
 253         /* purge pending data in DCC */
 254         embeddedice_receive(ocl->jtag_info, dcc_buffer, 1);
 255
 256         dcc_buffer[0] = OCL_PROBE;
 257         if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 258                 return retval;
 259
 260         /* wait for response, fixed timeout of 1 s */
 261         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))
 262         {
 263                 if (retval == ERROR_TARGET_TIMEOUT)
 264                         LOG_ERROR("loader not responding");
 265                 return retval;
 266         }
 267
 268         /* receive response */
 269         if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 270                 return retval;
 271
 272         if (dcc_buffer[0] != OCL_CMD_DONE)
 273         {
 274                 LOG_ERROR("loader response to OCL_PROBE 0x%08" PRIx32 "", dcc_buffer[0]);
 275                 return ERROR_FLASH_OPERATION_FAILED;
 276         }
 277
 278         /* receive and fill in parameters, detection of loader is important, receive it one by one */
 279         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)
 280                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 281                 return retval;
 282         bank->base = dcc_buffer[0];
 283
 284         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)
 285                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 286                 return retval;
 287         bank->size = dcc_buffer[0];
 288
 289         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)
 290                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 291                 return retval;
 292         bank->num_sectors = dcc_buffer[0];
 293
 294         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)
 295                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))
 296                 return retval;
 297         ocl->buflen = dcc_buffer[0] & 0xffff;
 298         ocl->bufalign = dcc_buffer[0] >> 16;
 299
 300         bank->sectors = realloc(bank->sectors, sizeof(struct flash_sector)*bank->num_sectors);
 301         if (bank->num_sectors == 0)
 302         {
 303                 LOG_ERROR("number of sectors shall be non zero value");
 304                 return ERROR_FLASH_BANK_INVALID;
 305         }
 306         if (bank->size % bank->num_sectors) {
 307                 LOG_ERROR("bank size not divisible by number of sectors");
 308                 return ERROR_FLASH_BANK_INVALID;
 309         }
 310         sectsize = bank->size / bank->num_sectors;
 311         for (i = 0; i < bank->num_sectors; i++)
 312         {
 313                 bank->sectors[i].offset = i * sectsize;
 314                 bank->sectors[i].size = sectsize;
 315                 bank->sectors[i].is_erased = -1;
 316                 bank->sectors[i].is_protected = -1;
 317         }
 318
 319         if (ocl->bufalign == 0)
 320                 ocl->bufalign = 1;
 321
 322         if (ocl->buflen == 0)
 323         {
 324                 LOG_ERROR("buflen shall be non zero value");
 325                 return ERROR_FLASH_BANK_INVALID;
 326         }
 327
 328         if ((ocl->bufalign > ocl->buflen) || (ocl->buflen % ocl->bufalign))
 329         {
 330                 LOG_ERROR("buflen is not multiple of bufalign");
 331                 return ERROR_FLASH_BANK_INVALID;
 332         }
 333
 334         if (ocl->buflen % 4)
 335         {
 336                 LOG_ERROR("buflen shall be divisible by 4");
 337                 return ERROR_FLASH_BANK_INVALID;
 338         }
 339
 340         return ERROR_OK;
 341 }
 342
 343 static int ocl_info(struct flash_bank *bank, char *buf, int buf_size)
 344 {
 345         return ERROR_OK;
 346 }
 347
 348 static int ocl_auto_probe(struct flash_bank *bank)
 349 {
 350         struct ocl_priv *ocl = ocl_bank_data(bank);
 351
 352         if (ocl->buflen == 0 || ocl->bufalign == 0)
 353                 return ERROR_FLASH_BANK_NOT_PROBED;
 354
 355         return ERROR_OK;
 356 }
 357
 358 FLASH_DRIVER(ocl, &ocl_flash_bank_command, NULL,
 359                 .erase = &ocl_erase,
 360                 .protect = &ocl_protect,
 361                 .write = &ocl_write,
 362                 .probe = &ocl_probe,
 363                 .erase_check = &ocl_erase_check,
 364                 .protect_check = &ocl_protect_check,
 365                 .info = &ocl_info,
 366                 .auto_probe = &ocl_auto_probe,
 367         );