git.gag.com Git - fw/openocd/blob - src/flash/ocl.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2007 by Pavel Chromy                                    *\r
   3  *   chromy@asix.cz                                                        *\r
   4  *                                                                         *\r
   5  *   This program is free software; you can redistribute it and/or modify  *\r
   6  *   it under the terms of the GNU General Public License as published by  *\r
   7  *   the Free Software Foundation; either version 2 of the License, or     *\r
   8  *   (at your option) any later version.                                   *\r
   9  *                                                                         *\r
  10  *   This program is distributed in the hope that it will be useful,       *\r
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  13  *   GNU General Public License for more details.                          *\r
  14  *                                                                         *\r
  15  *   You should have received a copy of the GNU General Public License     *\r
  16  *   along with this program; if not, write to the                         *\r
  17  *   Free Software Foundation, Inc.,                                       *\r
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  19  ***************************************************************************/\r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "replacements.h"\r
  25 \r
  26 #include "ocl.h"\r
  27 \r
  28 #include "flash.h"\r
  29 #include "target.h"\r
  30 #include "log.h"\r
  31 #include "binarybuffer.h"\r
  32 #include "types.h"\r
  33 #include "embeddedice.h"\r
  34 #include "arm7_9_common.h"\r
  35 \r
  36 #include <stdlib.h>\r
  37 #include <string.h>\r
  38 #include <unistd.h>\r
  39 \r
  40 int ocl_register_commands(struct command_context_s *cmd_ctx);\r
  41 int ocl_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);\r
  42 int ocl_erase(struct flash_bank_s *bank, int first, int last);\r
  43 int ocl_protect(struct flash_bank_s *bank, int set, int first, int last);\r
  44 int ocl_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count);\r
  45 int ocl_probe(struct flash_bank_s *bank);\r
  46 int ocl_erase_check(struct flash_bank_s *bank);\r
  47 int ocl_protect_check(struct flash_bank_s *bank);\r
  48 int ocl_info(struct flash_bank_s *bank, char *buf, int buf_size);\r
  49 int ocl_auto_probe(struct flash_bank_s *bank);\r
  50 \r
  51 flash_driver_t ocl_flash =\r
  52 {\r
  53         .name = "ocl",\r
  54         .register_commands = ocl_register_commands,\r
  55         .flash_bank_command = ocl_flash_bank_command,\r
  56         .erase = ocl_erase,\r
  57         .protect = ocl_protect,\r
  58         .write = ocl_write,\r
  59         .probe = ocl_probe,\r
  60         .erase_check = ocl_erase_check,\r
  61         .protect_check = ocl_protect_check,\r
  62         .info = ocl_info,\r
  63         .auto_probe = ocl_auto_probe\r
  64 };\r
  65 \r
  66 \r
  67 typedef struct ocl_priv_s\r
  68 {\r
  69         arm_jtag_t *jtag_info;\r
  70         int buflen;\r
  71         int bufalign;\r
  72 } ocl_priv_t;\r
  73 \r
  74 \r
  75 int ocl_register_commands(struct command_context_s *cmd_ctx)\r
  76 {\r
  77         return ERROR_OK;\r
  78 }\r
  79 \r
  80 \r
  81 int ocl_erase_check(struct flash_bank_s *bank)\r
  82 {\r
  83         return ERROR_OK;\r
  84 }\r
  85 \r
  86 \r
  87 int ocl_protect_check(struct flash_bank_s *bank)\r
  88 {\r
  89         return ERROR_OK;\r
  90 }\r
  91 \r
  92 \r
  93 /* flash_bank ocl 0 0 0 0 <target#> */\r
  94 int ocl_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)\r
  95 {\r
  96         int retval;\r
  97         armv4_5_common_t *armv4_5;\r
  98         arm7_9_common_t *arm7_9;\r
  99         ocl_priv_t *ocl;\r
 100 \r
 101         if (argc < 6)\r
 102         {\r
 103                 LOG_WARNING("incomplete flash_bank ocl configuration");\r
 104                 return ERROR_FLASH_BANK_INVALID;\r
 105         }\r
 106 \r
 107         if ((retval = arm7_9_get_arch_pointers(bank->target, &armv4_5, &arm7_9)) != ERROR_OK)\r
 108                 return retval;\r
 109 \r
 110         ocl = bank->driver_priv = malloc(sizeof(ocl_priv_t));\r
 111         ocl->jtag_info = &arm7_9->jtag_info;\r
 112         ocl->buflen = 0;\r
 113         ocl->bufalign = 1;\r
 114 \r
 115         return ERROR_OK;\r
 116 }\r
 117 \r
 118 \r
 119 int ocl_erase(struct flash_bank_s *bank, int first, int last)\r
 120 {\r
 121         ocl_priv_t *ocl = bank->driver_priv;\r
 122         int retval;\r
 123         u32 dcc_buffer[3];\r
 124 \r
 125         /* check preconditions */\r
 126         if (bank->num_sectors == 0)\r
 127                 return ERROR_FLASH_BANK_NOT_PROBED;\r
 128                 \r
 129         if (bank->target->state != TARGET_RUNNING)\r
 130         {\r
 131                 LOG_ERROR("target has to be running to communicate with the loader");\r
 132                 return ERROR_TARGET_NOT_RUNNING;\r
 133         }\r
 134                 \r
 135         if ((first == 0) && (last == bank->num_sectors - 1))\r
 136         {\r
 137                 dcc_buffer[0] = OCL_ERASE_ALL;\r
 138                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 139                         return retval;\r
 140         }\r
 141         else\r
 142         {\r
 143                 dcc_buffer[0] = OCL_ERASE_BLOCK;\r
 144                 dcc_buffer[1] = first;\r
 145                 dcc_buffer[2] = last;\r
 146                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 3) != ERROR_OK))\r
 147                         return retval;\r
 148         }\r
 149 \r
 150         /* wait for response, fixed timeout of 1 s */\r
 151         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))\r
 152         {\r
 153                 if (retval == ERROR_TARGET_TIMEOUT)\r
 154                         LOG_ERROR("loader not responding");\r
 155                 return retval;\r
 156         }\r
 157 \r
 158         /* receive response */\r
 159         if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer+1, 1) != ERROR_OK))\r
 160                 return retval;\r
 161 \r
 162         if (dcc_buffer[1] != OCL_CMD_DONE)\r
 163         {\r
 164                 if (dcc_buffer[0] == OCL_ERASE_ALL)\r
 165                         LOG_ERROR("loader response to OCL_ERASE_ALL 0x%08lX", dcc_buffer[1]);\r
 166                 else\r
 167                         LOG_ERROR("loader response to OCL_ERASE_BLOCK 0x%08lX", dcc_buffer[1]);\r
 168                 return ERROR_FLASH_OPERATION_FAILED;\r
 169         }\r
 170 \r
 171         return ERROR_OK;\r
 172 }\r
 173 \r
 174 \r
 175 int ocl_protect(struct flash_bank_s *bank, int set, int first, int last)\r
 176 {\r
 177         return ERROR_OK;\r
 178 }\r
 179 \r
 180 \r
 181 int ocl_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)\r
 182 {\r
 183         ocl_priv_t *ocl = bank->driver_priv;\r
 184         int retval;\r
 185         u32 *dcc_buffer;\r
 186         u32 *dcc_bufptr;\r
 187         int byteofs;\r
 188         int runlen;\r
 189         u32 chksum;\r
 190         \r
 191         int i;\r
 192 \r
 193         /* check preconditions */\r
 194         if (ocl->buflen == 0 || ocl->bufalign==0)\r
 195                 return ERROR_FLASH_BANK_NOT_PROBED;\r
 196 \r
 197         if (bank->target->state != TARGET_RUNNING)\r
 198         {\r
 199                 LOG_ERROR("target has to be running to communicate with the loader");\r
 200                 return ERROR_TARGET_NOT_RUNNING;\r
 201         }\r
 202 \r
 203         /* allocate buffer for max. ocl buffer + overhead */\r
 204         dcc_buffer = malloc(sizeof(u32)*(ocl->buflen/4+3));\r
 205 \r
 206         while (count)\r
 207         {\r
 208                 if (count + (offset % ocl->bufalign) > ocl->buflen)\r
 209                         runlen = ocl->buflen - (offset % ocl->bufalign);\r
 210                 else\r
 211                         runlen = count;\r
 212 \r
 213                 dcc_buffer[0] = OCL_FLASH_BLOCK | runlen;\r
 214                 dcc_buffer[1] = offset;\r
 215                 dcc_bufptr = &dcc_buffer[2];\r
 216 \r
 217                 *dcc_bufptr = 0xffffffff;\r
 218                 byteofs = (offset % ocl->bufalign) % 4;\r
 219                 chksum = OCL_CHKS_INIT;\r
 220 \r
 221                 /* copy data to DCC buffer in proper byte order and properly aligned */\r
 222                 for (i=0; i<runlen; i++)\r
 223                 {\r
 224                         switch (byteofs++)\r
 225                         {\r
 226                                 case 0:\r
 227                                         *dcc_bufptr &= *(buffer++) | 0xffffff00;\r
 228                                         break;\r
 229                                 case 1:\r
 230                                         *dcc_bufptr &= ((*(buffer++))<<8) | 0xffff00ff;\r
 231                                         break;\r
 232                                 case 2:\r
 233                                         *dcc_bufptr &= ((*(buffer++))<<16) | 0xff00ffff;\r
 234                                         break;\r
 235                                 case 3:\r
 236                                         *dcc_bufptr &= ((*(buffer++))<<24) | 0x00ffffff;\r
 237                                         chksum ^= *(dcc_bufptr++);\r
 238                                         *dcc_bufptr = 0xffffffff;\r
 239                                         byteofs = 0;\r
 240                                         break;\r
 241                         }\r
 242                 }\r
 243 \r
 244                 /* add the remaining word to checksum */\r
 245                 if (byteofs)\r
 246                         chksum ^= *(dcc_bufptr++);\r
 247 \r
 248                 *(dcc_bufptr++) = chksum;\r
 249                 \r
 250                 /* send the data */\r
 251                 if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, dcc_bufptr-dcc_buffer)) != ERROR_OK)\r
 252                 {\r
 253                         free(dcc_buffer);\r
 254                   return retval;\r
 255                 }\r
 256 \r
 257                 /* wait for response, fixed timeout of 1 s */\r
 258                 if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))\r
 259                 {\r
 260                         if (retval == ERROR_TARGET_TIMEOUT)\r
 261                                 LOG_ERROR("loader not responding");\r
 262                         free(dcc_buffer);\r
 263                         return retval;\r
 264                 }\r
 265 \r
 266                 /* receive response */\r
 267                 if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 268                 {\r
 269                         free(dcc_buffer);\r
 270                         return retval;\r
 271                 }\r
 272 \r
 273                 if (dcc_buffer[0] != OCL_CMD_DONE)\r
 274                 {\r
 275                         LOG_ERROR("loader response to OCL_FLASH_BLOCK 0x%08lX", dcc_buffer[0]);\r
 276                         free(dcc_buffer);\r
 277                         return ERROR_FLASH_OPERATION_FAILED;\r
 278                 }\r
 279 \r
 280                 count -= runlen;\r
 281                 offset += runlen;\r
 282         }\r
 283 \r
 284         free(dcc_buffer);\r
 285         return ERROR_OK;\r
 286 }\r
 287 \r
 288 \r
 289 int ocl_probe(struct flash_bank_s *bank)\r
 290 {\r
 291         ocl_priv_t *ocl = bank->driver_priv;\r
 292         int retval;\r
 293         u32 dcc_buffer[1];\r
 294         int sectsize;\r
 295         int i;\r
 296 \r
 297         /* purge pending data in DCC */\r
 298         embeddedice_receive(ocl->jtag_info, dcc_buffer, 1);\r
 299 \r
 300         dcc_buffer[0] = OCL_PROBE;\r
 301         if ((retval = embeddedice_send(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 302                 return retval;\r
 303 \r
 304         /* wait for response, fixed timeout of 1 s */\r
 305         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 1000) != ERROR_OK))\r
 306         {\r
 307                 if (retval == ERROR_TARGET_TIMEOUT)\r
 308                         LOG_ERROR("loader not responding");\r
 309                 return retval;\r
 310         }\r
 311 \r
 312         /* receive response */\r
 313         if ((retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 314                 return retval;\r
 315                 \r
 316         if (dcc_buffer[0] != OCL_CMD_DONE)\r
 317         {\r
 318                 LOG_ERROR("loader response to OCL_PROBE 0x%08lX", dcc_buffer[0]);\r
 319                 return ERROR_FLASH_OPERATION_FAILED;\r
 320         }\r
 321 \r
 322         /* receive and fill in parameters, detection of loader is important, receive it one by one */\r
 323         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)\r
 324                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 325                 return retval;\r
 326         bank->base = dcc_buffer[0];\r
 327 \r
 328         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)\r
 329                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 330                 return retval;\r
 331         bank->size = dcc_buffer[0];\r
 332 \r
 333         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)\r
 334                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 335                 return retval;\r
 336         bank->num_sectors = dcc_buffer[0];\r
 337 \r
 338         if ((retval = embeddedice_handshake(ocl->jtag_info, EICE_COMM_CTRL_WBIT, 0) != ERROR_OK)\r
 339                 || (retval = embeddedice_receive(ocl->jtag_info, dcc_buffer, 1) != ERROR_OK))\r
 340                 return retval;\r
 341         ocl->buflen = dcc_buffer[0] & 0xffff;\r
 342         ocl->bufalign = dcc_buffer[0] >> 16;\r
 343 \r
 344         bank->sectors = realloc(bank->sectors, sizeof(flash_sector_t)*bank->num_sectors);\r
 345         if (bank->num_sectors == 0)\r
 346         {\r
 347                 LOG_ERROR("number of sectors shall be non zero value");\r
 348                 return ERROR_FLASH_BANK_INVALID;\r
 349         }\r
 350         if (bank->size % bank->num_sectors) {\r
 351                 LOG_ERROR("bank size not divisible by number of sectors");\r
 352                 return ERROR_FLASH_BANK_INVALID;\r
 353         }\r
 354         sectsize = bank->size / bank->num_sectors;\r
 355         for (i=0; i<bank->num_sectors; i++)\r
 356         {\r
 357                 bank->sectors[i].offset = i * sectsize;\r
 358                 bank->sectors[i].size = sectsize;\r
 359                 bank->sectors[i].is_erased = -1;\r
 360                 bank->sectors[i].is_protected = -1;\r
 361         }\r
 362 \r
 363         if (ocl->bufalign == 0)\r
 364                 ocl->bufalign = 1;\r
 365 \r
 366         if (ocl->buflen == 0)\r
 367         {\r
 368                 LOG_ERROR("buflen shall be non zero value");\r
 369                 return ERROR_FLASH_BANK_INVALID;\r
 370         }\r
 371 \r
 372         if ((ocl->bufalign > ocl->buflen) || (ocl->buflen % ocl->bufalign))\r
 373         {\r
 374                 LOG_ERROR("buflen is not multiple of bufalign");\r
 375                 return ERROR_FLASH_BANK_INVALID;\r
 376         }\r
 377 \r
 378         if (ocl->buflen % 4)\r
 379         {\r
 380                 LOG_ERROR("buflen shall be divisible by 4");\r
 381                 return ERROR_FLASH_BANK_INVALID;\r
 382         }\r
 383 \r
 384         return ERROR_OK;\r
 385 }\r
 386 \r
 387 \r
 388 int ocl_info(struct flash_bank_s *bank, char *buf, int buf_size)\r
 389 {\r
 390         return ERROR_OK;\r
 391 }\r
 392 \r
 393 \r
 394 int ocl_auto_probe(struct flash_bank_s *bank)\r
 395 {\r
 396         ocl_priv_t *ocl = bank->driver_priv;\r
 397 \r
 398         if (ocl->buflen == 0 || ocl->bufalign==0)\r
 399                 return ERROR_FLASH_BANK_NOT_PROBED;\r
 400 \r
 401         return ERROR_OK;\r
 402 }\r