pic32mx.c 26.4 KB
Newer Older
oharboe's avatar
oharboe committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/***************************************************************************
 *   Copyright (C) 2005 by Dominic Rath                                    *
 *   Dominic.Rath@gmx.de                                                   *
 *                                                                         *
 *   Copyright (C) 2008 by Spencer Oliver                                  *
 *   spen@spen-soft.co.uk                                                  *
 *                                                                         *
 *   Copyright (C) 2008 by John McCarthy                                   *
 *   jgmcc@magma.ca                                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "pic32mx.h"
#include "mips32.h"


static
struct pic32mx_devs_s {
36
	uint8_t	devid;
oharboe's avatar
oharboe committed
37
	char	*name;
38
	uint32_t	pfm_size;
oharboe's avatar
oharboe committed
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
} pic32mx_devs[] = {
	{ 0x78, "460F512L USB", 512 },
	{ 0x74, "460F256L USB", 256 },
	{ 0x6D, "440F128L USB", 128 },
	{ 0x56, "440F512H USB", 512 },
	{ 0x52, "440F256H USB", 256 },
	{ 0x4D, "440F128H USB", 128 },
	{ 0x42, "420F032H USB",  32 },
	{ 0x38, "360F512L",     512 },
	{ 0x34, "360F256L",     256 },
	{ 0x2D, "340F128L",     128 },
	{ 0x2A, "320F128L",     128 },
	{ 0x16, "340F512H",     512 },
	{ 0x12, "340F256H",     256 },
	{ 0x0D, "340F128H",     128 },
	{ 0x0A, "320F128H",     128 },
	{ 0x06, "320F064H",      64 },
	{ 0x02, "320F032H",      32 },
	{ 0x00, NULL, 0 }
};

mifi's avatar
mifi committed
60
61
62
63
static int pic32mx_register_commands(struct command_context_s *cmd_ctx);
static int pic32mx_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
static int pic32mx_erase(struct flash_bank_s *bank, int first, int last);
static int pic32mx_protect(struct flash_bank_s *bank, int set, int first, int last);
64
65
66
static int pic32mx_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count);
static int pic32mx_write_row(struct flash_bank_s *bank, uint32_t address, uint32_t srcaddr);
static int pic32mx_write_word(struct flash_bank_s *bank, uint32_t address, uint32_t word);
mifi's avatar
mifi committed
67
68
69
70
71
static int pic32mx_probe(struct flash_bank_s *bank);
static int pic32mx_auto_probe(struct flash_bank_s *bank);
//static int pic32mx_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
static int pic32mx_protect_check(struct flash_bank_s *bank);
static int pic32mx_info(struct flash_bank_s *bank, char *buf, int buf_size);
oharboe's avatar
oharboe committed
72
73
74
75
76

#if 0
int pic32mx_handle_lock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
int pic32mx_handle_unlock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
#endif
mifi's avatar
mifi committed
77
78
79
static int pic32mx_handle_chip_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
static int pic32mx_handle_pgm_word_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
//static int pic32mx_chip_erase(struct flash_bank_s *bank);
oharboe's avatar
oharboe committed
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

flash_driver_t pic32mx_flash =
{
	.name = "pic32mx",
	.register_commands = pic32mx_register_commands,
	.flash_bank_command = pic32mx_flash_bank_command,
	.erase = pic32mx_erase,
	.protect = pic32mx_protect,
	.write = pic32mx_write,
	.probe = pic32mx_probe,
	.auto_probe = pic32mx_auto_probe,
	.erase_check = default_flash_mem_blank_check,
	.protect_check = pic32mx_protect_check,
	.info = pic32mx_info
};

mifi's avatar
mifi committed
96
static int pic32mx_register_commands(struct command_context_s *cmd_ctx)
oharboe's avatar
oharboe committed
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
{
	command_t *pic32mx_cmd = register_command(cmd_ctx, NULL, "pic32mx", NULL, COMMAND_ANY, "pic32mx flash specific commands");

#if 0
	register_command(cmd_ctx, pic32mx_cmd, "lock", pic32mx_handle_lock_command, COMMAND_EXEC,
					 "lock device");
	register_command(cmd_ctx, pic32mx_cmd, "unlock", pic32mx_handle_unlock_command, COMMAND_EXEC,
					 "unlock protected device");
#endif
	register_command(cmd_ctx, pic32mx_cmd, "chip_erase", pic32mx_handle_chip_erase_command, COMMAND_EXEC,
					 "erase device");
	register_command(cmd_ctx, pic32mx_cmd, "pgm_word", pic32mx_handle_pgm_word_command, COMMAND_EXEC,
					 "program a word");
	return ERROR_OK;
}

/* flash bank pic32mx <base> <size> 0 0 <target#>
 */
mifi's avatar
mifi committed
115
static int pic32mx_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)
oharboe's avatar
oharboe committed
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
{
	pic32mx_flash_bank_t *pic32mx_info;

	if (argc < 6)
	{
		LOG_WARNING("incomplete flash_bank pic32mx configuration");
		return ERROR_FLASH_BANK_INVALID;
	}

	pic32mx_info = malloc(sizeof(pic32mx_flash_bank_t));
	bank->driver_priv = pic32mx_info;

	pic32mx_info->write_algorithm = NULL;
	pic32mx_info->probed = 0;

	return ERROR_OK;
}

134
static uint32_t pic32mx_get_flash_status(flash_bank_t *bank)
oharboe's avatar
oharboe committed
135
136
{
	target_t *target = bank->target;
137
	uint32_t status;
oharboe's avatar
oharboe committed
138
139
140
141
142
143

	target_read_u32(target, PIC32MX_NVMCON, &status);

	return status;
}

144
static uint32_t pic32mx_wait_status_busy(flash_bank_t *bank, int timeout)
oharboe's avatar
oharboe committed
145
{
146
	uint32_t status;
oharboe's avatar
oharboe committed
147
148
149
150

	/* wait for busy to clear */
	while (((status = pic32mx_get_flash_status(bank)) & NVMCON_NVMWR) && (timeout-- > 0))
	{
duane's avatar
duane committed
151
		LOG_DEBUG("status: 0x%" PRIx32, status );
oharboe's avatar
oharboe committed
152
153
		alive_sleep(1);
	}
zwelch's avatar
zwelch committed
154
	if (timeout <= 0)
duane's avatar
duane committed
155
		LOG_DEBUG("timeout: status: 0x%" PRIx32, status );
oharboe's avatar
oharboe committed
156
157
158
159

	return status;
}

160
static int pic32mx_nvm_exec(struct flash_bank_s *bank, uint32_t op, uint32_t timeout)
oharboe's avatar
oharboe committed
161
162
{
	target_t *target = bank->target;
163
	uint32_t status;
oharboe's avatar
oharboe committed
164

zwelch's avatar
zwelch committed
165
	target_write_u32(target, PIC32MX_NVMCON, NVMCON_NVMWREN | op);
oharboe's avatar
oharboe committed
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

	/* unlock flash registers */
	target_write_u32(target, PIC32MX_NVMKEY, NVMKEY1);
	target_write_u32(target, PIC32MX_NVMKEY, NVMKEY2);

	/* start operation */
	target_write_u32(target, PIC32MX_NVMCONSET, NVMCON_NVMWR);

	status = pic32mx_wait_status_busy(bank, timeout);

	/* lock flash registers */
	target_write_u32(target, PIC32MX_NVMCONCLR, NVMCON_NVMWREN);

	return status;
}

mifi's avatar
mifi committed
182
static int pic32mx_protect_check(struct flash_bank_s *bank)
oharboe's avatar
oharboe committed
183
184
185
{
	target_t *target = bank->target;

186
	uint32_t devcfg0;
oharboe's avatar
oharboe committed
187
188
189
190
191
192
193
194
195
196
	int s;
	int num_pages;

	if (target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	target_read_u32(target, PIC32MX_DEVCFG0, &devcfg0);
zwelch's avatar
zwelch committed
197
	if ((devcfg0 & (1 << 28)) == 0) /* code protect bit */
oharboe's avatar
oharboe committed
198
		num_pages = 0xffff;  /* All pages protected */
zwelch's avatar
zwelch committed
199
	else if (bank->base == PIC32MX_KSEG1_BOOT_FLASH)
oharboe's avatar
oharboe committed
200
	{
zwelch's avatar
zwelch committed
201
		if (devcfg0 & (1 << 24))
oharboe's avatar
oharboe committed
202
203
204
205
206
207
208
209
210
211
212
213
214
215
			num_pages = 0;       /* All pages unprotected */
		else
			num_pages = 0xffff;  /* All pages protected */
	}
	else /* pgm flash */
		num_pages = (~devcfg0 >> 12) & 0xff;
	for (s = 0; s < bank->num_sectors && s < num_pages; s++)
		bank->sectors[s].is_protected = 1;
	for (; s < bank->num_sectors; s++)
		bank->sectors[s].is_protected = 0;

	return ERROR_OK;
}

mifi's avatar
mifi committed
216
static int pic32mx_erase(struct flash_bank_s *bank, int first, int last)
oharboe's avatar
oharboe committed
217
218
219
{
	target_t *target = bank->target;
	int i;
220
	uint32_t status;
oharboe's avatar
oharboe committed
221
222
223
224
225
226
227
228
229

	if (bank->target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if ((first == 0) && (last == (bank->num_sectors - 1)) && (bank->base == PIC32MX_KSEG0_PGM_FLASH || bank->base == PIC32MX_KSEG1_PGM_FLASH))
	{
230
		LOG_DEBUG("Erasing entire program flash");
oharboe's avatar
oharboe committed
231
		status = pic32mx_nvm_exec(bank, NVMCON_OP_PFM_ERASE, 50);
zwelch's avatar
zwelch committed
232
		if ( status & NVMCON_NVMERR )
oharboe's avatar
oharboe committed
233
			return ERROR_FLASH_OPERATION_FAILED;
zwelch's avatar
zwelch committed
234
		if ( status & NVMCON_LVDERR )
oharboe's avatar
oharboe committed
235
236
237
238
239
240
			return ERROR_FLASH_OPERATION_FAILED;
		return ERROR_OK;
	}

	for (i = first; i <= last; i++)
	{
zwelch's avatar
zwelch committed
241
		if (bank->base >= PIC32MX_KSEG1_PGM_FLASH)
242
243
244
			target_write_u32(target, PIC32MX_NVMADDR, KS1Virt2Phys(bank->base + bank->sectors[i].offset));
		else
			target_write_u32(target, PIC32MX_NVMADDR, KS0Virt2Phys(bank->base + bank->sectors[i].offset));
oharboe's avatar
oharboe committed
245
246
247

		status = pic32mx_nvm_exec(bank, NVMCON_OP_PAGE_ERASE, 10);

zwelch's avatar
zwelch committed
248
		if ( status & NVMCON_NVMERR )
oharboe's avatar
oharboe committed
249
			return ERROR_FLASH_OPERATION_FAILED;
zwelch's avatar
zwelch committed
250
		if ( status & NVMCON_LVDERR )
oharboe's avatar
oharboe committed
251
252
253
254
255
256
257
			return ERROR_FLASH_OPERATION_FAILED;
		bank->sectors[i].is_erased = 1;
	}

	return ERROR_OK;
}

mifi's avatar
mifi committed
258
static int pic32mx_protect(struct flash_bank_s *bank, int set, int first, int last)
oharboe's avatar
oharboe committed
259
260
261
{
	pic32mx_flash_bank_t *pic32mx_info = NULL;
	target_t *target = bank->target;
262
#if 0
zwelch's avatar
zwelch committed
263
	uint16_t prot_reg[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
oharboe's avatar
oharboe committed
264
265
	int i, reg, bit;
	int status;
266
	uint32_t protection;
267
#endif
oharboe's avatar
oharboe committed
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287

	pic32mx_info = bank->driver_priv;

	if (target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

#if 0
	if ((first && (first % pic32mx_info->ppage_size)) || ((last + 1) && (last + 1) % pic32mx_info->ppage_size))
	{
		LOG_WARNING("sector start/end incorrect - stm32 has %dK sector protection", pic32mx_info->ppage_size);
		return ERROR_FLASH_SECTOR_INVALID;
	}

	/* medium density - each bit refers to a 4bank protection
	 * high density - each bit refers to a 2bank protection */
	target_read_u32(target, PIC32MX_FLASH_WRPR, &protection);

zwelch's avatar
zwelch committed
288
289
290
291
	prot_reg[0] = (uint16_t)protection;
	prot_reg[1] = (uint16_t)(protection >> 8);
	prot_reg[2] = (uint16_t)(protection >> 16);
	prot_reg[3] = (uint16_t)(protection >> 24);
oharboe's avatar
oharboe committed
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315

	if (pic32mx_info->ppage_size == 2)
	{
		/* high density flash */

		/* bit 7 controls sector 62 - 255 protection */
		if (last > 61)
		{
			if (set)
				prot_reg[3] &= ~(1 << 7);
			else
				prot_reg[3] |= (1 << 7);
		}

		if (first > 61)
			first = 62;
		if (last > 61)
			last = 61;

		for (i = first; i <= last; i++)
		{
			reg = (i / pic32mx_info->ppage_size) / 8;
			bit = (i / pic32mx_info->ppage_size) - (reg * 8);

zwelch's avatar
zwelch committed
316
			if ( set )
oharboe's avatar
oharboe committed
317
318
319
320
321
322
323
324
325
326
327
328
329
				prot_reg[reg] &= ~(1 << bit);
			else
				prot_reg[reg] |= (1 << bit);
		}
	}
	else
	{
		/* medium density flash */
		for (i = first; i <= last; i++)
		{
			reg = (i / pic32mx_info->ppage_size) / 8;
			bit = (i / pic32mx_info->ppage_size) - (reg * 8);

zwelch's avatar
zwelch committed
330
			if ( set )
oharboe's avatar
oharboe committed
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
				prot_reg[reg] &= ~(1 << bit);
			else
				prot_reg[reg] |= (1 << bit);
		}
	}

	if ((status = pic32mx_erase_options(bank)) != ERROR_OK)
		return status;

	pic32mx_info->option_bytes.protection[0] = prot_reg[0];
	pic32mx_info->option_bytes.protection[1] = prot_reg[1];
	pic32mx_info->option_bytes.protection[2] = prot_reg[2];
	pic32mx_info->option_bytes.protection[3] = prot_reg[3];

	return pic32mx_write_options(bank);
#else
	return ERROR_OK;
#endif
}

351
static int pic32mx_write_block(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
oharboe's avatar
oharboe committed
352
353
{
	target_t *target = bank->target;
354
	uint32_t buffer_size = 512;
oharboe's avatar
oharboe committed
355
	working_area_t *source;
356
	uint32_t address = bank->base + offset;
357
	int retval = ERROR_OK;
oharboe's avatar
oharboe committed
358
#if 0
359
	pic32mx_flash_bank_t *pic32mx_info = bank->driver_priv;
oharboe's avatar
oharboe committed
360
361
	armv7m_algorithm_t armv7m_info;

362
	uint8_t pic32mx_flash_write_code[] = {
oharboe's avatar
oharboe committed
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
									/* write: */
		0xDF, 0xF8, 0x24, 0x40,		/* ldr	r4, PIC32MX_FLASH_CR */
		0x09, 0x4D,					/* ldr	r5, PIC32MX_FLASH_SR */
		0x4F, 0xF0, 0x01, 0x03,		/* mov	r3, #1 */
		0x23, 0x60,					/* str	r3, [r4, #0] */
		0x30, 0xF8, 0x02, 0x3B,		/* ldrh r3, [r0], #2 */
		0x21, 0xF8, 0x02, 0x3B,		/* strh r3, [r1], #2 */
									/* busy: */
		0x2B, 0x68,					/* ldr 	r3, [r5, #0] */
		0x13, 0xF0, 0x01, 0x0F,		/* tst 	r3, #0x01 */
		0xFB, 0xD0,					/* beq 	busy */
		0x13, 0xF0, 0x14, 0x0F,		/* tst	r3, #0x14 */
		0x01, 0xD1,					/* bne	exit */
		0x01, 0x3A,					/* subs	r2, r2, #1 */
		0xED, 0xD1,					/* bne	write */
									/* exit: */
		0xFE, 0xE7,					/* b exit */
		0x10, 0x20, 0x02, 0x40,		/* PIC32MX_FLASH_CR:	.word 0x40022010 */
		0x0C, 0x20, 0x02, 0x40		/* PIC32MX_FLASH_SR:	.word 0x4002200C */
	};

	/* flash write code */
	if (target_alloc_working_area(target, sizeof(pic32mx_flash_write_code), &pic32mx_info->write_algorithm) != ERROR_OK)
	{
		LOG_WARNING("no working area available, can't do block memory writes");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	};

zwelch's avatar
zwelch committed
391
	if ((retval = target_write_buffer(target, pic32mx_info->write_algorithm->address, sizeof(pic32mx_flash_write_code), pic32mx_flash_write_code)) != ERROR_OK)
oharboe's avatar
oharboe committed
392
		return retval;
393
#endif
oharboe's avatar
oharboe committed
394
395

	/* memory buffer */
396
	if (target_alloc_working_area(target, buffer_size, &source) != ERROR_OK)
oharboe's avatar
oharboe committed
397
	{
398
399
400
401
402
#if 0
		/* if we already allocated the writing code, but failed to get a buffer, free the algorithm */
		if (pic32mx_info->write_algorithm)
			target_free_working_area(target, pic32mx_info->write_algorithm);
#endif
oharboe's avatar
oharboe committed
403

404
405
406
		LOG_WARNING("no large enough working area available, can't do block memory writes");
		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
	}
oharboe's avatar
oharboe committed
407

408
	while (count >= buffer_size/4)
oharboe's avatar
oharboe committed
409
	{
410
		uint32_t status;
oharboe's avatar
oharboe committed
411

zwelch's avatar
zwelch committed
412
		if ((retval = target_write_buffer(target, source->address, buffer_size, buffer)) != ERROR_OK) {
duane's avatar
duane committed
413
			LOG_ERROR("Failed to write row buffer (%d words) to RAM", (int)(buffer_size/4));
oharboe's avatar
oharboe committed
414
			break;
415
		}
oharboe's avatar
oharboe committed
416

417
#if 0
oharboe's avatar
oharboe committed
418
419
		buf_set_u32(reg_params[0].value, 0, 32, source->address);
		buf_set_u32(reg_params[1].value, 0, 32, address);
420
		buf_set_u32(reg_params[2].value, 0, 32, buffer_size/4);
oharboe's avatar
oharboe committed
421

zwelch's avatar
zwelch committed
422
		if ((retval = target_run_algorithm(target, 0, NULL, 4, reg_params, pic32mx_info->write_algorithm->address, \
oharboe's avatar
oharboe committed
423
424
425
426
427
428
429
430
431
432
433
434
				pic32mx_info->write_algorithm->address + (sizeof(pic32mx_flash_write_code) - 10), 10000, &armv7m_info)) != ERROR_OK)
		{
			LOG_ERROR("error executing pic32mx flash write algorithm");
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}

		if (buf_get_u32(reg_params[3].value, 0, 32) & 0x14)
		{
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}
435
436
#endif
		status = pic32mx_write_row(bank, address, source->address);
zwelch's avatar
zwelch committed
437
		if ( status & NVMCON_NVMERR ) {
zwelch's avatar
zwelch committed
438
			LOG_ERROR("Flash write error NVMERR (status = 0x%08" PRIx32 ")", status);
439
440
441
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}
zwelch's avatar
zwelch committed
442
		if ( status & NVMCON_LVDERR ) {
zwelch's avatar
zwelch committed
443
			LOG_ERROR("Flash write error LVDERR (status = 0x%08" PRIx32 ")", status);
444
445
446
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}
oharboe's avatar
oharboe committed
447

448
449
450
		buffer  += buffer_size;
		address += buffer_size;
		count   -= buffer_size/4;
oharboe's avatar
oharboe committed
451
452
453
454
	}

	target_free_working_area(target, source);

zwelch's avatar
zwelch committed
455
	while (count > 0)
456
	{
457
458
		uint32_t value;
		memcpy(&value, buffer, sizeof(uint32_t));
459

460
		uint32_t status = pic32mx_write_word(bank, address, value);
zwelch's avatar
zwelch committed
461
		if ( status & NVMCON_NVMERR ) {
zwelch's avatar
zwelch committed
462
			LOG_ERROR("Flash write error NVMERR (status = 0x%08" PRIx32 ")", status);
463
464
465
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}
zwelch's avatar
zwelch committed
466
		if ( status & NVMCON_LVDERR ) {
zwelch's avatar
zwelch committed
467
			LOG_ERROR("Flash write error LVDERR (status = 0x%08" PRIx32 ")", status);
468
469
470
471
472
473
474
475
			retval = ERROR_FLASH_OPERATION_FAILED;
			break;
		}

		buffer  += 4;
		address += 4;
		count--;
	}
oharboe's avatar
oharboe committed
476
477
478
479

	return retval;
}

480
static int pic32mx_write_word(struct flash_bank_s *bank, uint32_t address, uint32_t word)
oharboe's avatar
oharboe committed
481
482
483
{
	target_t *target = bank->target;

zwelch's avatar
zwelch committed
484
	if (bank->base >= PIC32MX_KSEG1_PGM_FLASH)
485
486
487
		target_write_u32(target, PIC32MX_NVMADDR, KS1Virt2Phys(address));
	else
		target_write_u32(target, PIC32MX_NVMADDR, KS0Virt2Phys(address));
oharboe's avatar
oharboe committed
488
489
490
491
492
	target_write_u32(target, PIC32MX_NVMDATA, word);

	return pic32mx_nvm_exec(bank, NVMCON_OP_WORD_PROG, 5);
}

493
494
495
/*
 * Write a 128 word (512 byte) row to flash address from RAM srcaddr.
 */
496
static int pic32mx_write_row(struct flash_bank_s *bank, uint32_t address, uint32_t srcaddr)
oharboe's avatar
oharboe committed
497
498
{
	target_t *target = bank->target;
499

duane's avatar
duane committed
500
	LOG_DEBUG("addr: 0x%08" PRIx32 " srcaddr: 0x%08" PRIx32 "", address, srcaddr);
501

zwelch's avatar
zwelch committed
502
	if (address >= PIC32MX_KSEG1_PGM_FLASH)
503
504
505
		target_write_u32(target, PIC32MX_NVMADDR,    KS1Virt2Phys(address));
	else
		target_write_u32(target, PIC32MX_NVMADDR,    KS0Virt2Phys(address));
zwelch's avatar
zwelch committed
506
	if (srcaddr >= PIC32MX_KSEG1_RAM)
507
508
509
510
511
512
513
		target_write_u32(target, PIC32MX_NVMSRCADDR, KS1Virt2Phys(srcaddr));
	else
		target_write_u32(target, PIC32MX_NVMSRCADDR, KS0Virt2Phys(srcaddr));

	return pic32mx_nvm_exec(bank, NVMCON_OP_ROW_PROG, 100);
}

514
static int pic32mx_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
515
{
516
517
518
519
520
	uint32_t words_remaining = (count / 4);
	uint32_t bytes_remaining = (count & 0x00000003);
	uint32_t address = bank->base + offset;
	uint32_t bytes_written = 0;
	uint32_t status;
521
	int retval;
oharboe's avatar
oharboe committed
522
523
524
525
526
527
528
529
530

	if (bank->target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (offset & 0x3)
	{
duane's avatar
duane committed
531
		LOG_WARNING("offset 0x%" PRIx32 "breaks required 4-byte alignment", offset);
oharboe's avatar
oharboe committed
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
		return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
	}

	/* multiple words (4-byte) to be programmed? */
	if (words_remaining > 0)
	{
		/* try using a block write */
		if ((retval = pic32mx_write_block(bank, buffer, offset, words_remaining)) != ERROR_OK)
		{
			if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE)
			{
				/* if block write failed (no sufficient working area),
				 * we use normal (slow) single dword accesses */
				LOG_WARNING("couldn't use block writes, falling back to single memory accesses");
			}
			else if (retval == ERROR_FLASH_OPERATION_FAILED)
			{
				LOG_ERROR("flash writing failed with error code: 0x%x", retval);
				return ERROR_FLASH_OPERATION_FAILED;
			}
		}
		else
		{
			buffer += words_remaining * 4;
			address += words_remaining * 4;
			words_remaining = 0;
		}
	}

	while (words_remaining > 0)
	{
563
564
		uint32_t value;
		memcpy(&value, buffer + bytes_written, sizeof(uint32_t));
oharboe's avatar
oharboe committed
565

566
		status = pic32mx_write_word(bank, address, value);
zwelch's avatar
zwelch committed
567
		if ( status & NVMCON_NVMERR )
oharboe's avatar
oharboe committed
568
			return ERROR_FLASH_OPERATION_FAILED;
zwelch's avatar
zwelch committed
569
		if ( status & NVMCON_LVDERR )
oharboe's avatar
oharboe committed
570
571
572
573
574
575
576
577
578
			return ERROR_FLASH_OPERATION_FAILED;

		bytes_written += 4;
		words_remaining--;
		address += 4;
	}

	if (bytes_remaining)
	{
579
		uint32_t value = 0xffffffff;
580
		memcpy(&value, buffer + bytes_written, bytes_remaining);
oharboe's avatar
oharboe committed
581

582
		status = pic32mx_write_word(bank, address, value);
zwelch's avatar
zwelch committed
583
		if ( status & NVMCON_NVMERR )
oharboe's avatar
oharboe committed
584
			return ERROR_FLASH_OPERATION_FAILED;
zwelch's avatar
zwelch committed
585
		if ( status & NVMCON_LVDERR )
oharboe's avatar
oharboe committed
586
587
588
589
590
591
			return ERROR_FLASH_OPERATION_FAILED;
	}

	return ERROR_OK;
}

mifi's avatar
mifi committed
592
static int pic32mx_probe(struct flash_bank_s *bank)
oharboe's avatar
oharboe committed
593
594
595
596
597
598
{
	target_t *target = bank->target;
	pic32mx_flash_bank_t *pic32mx_info = bank->driver_priv;
	mips32_common_t *mips32 = target->arch_info;
	mips_ejtag_t *ejtag_info = &mips32->ejtag_info;
	int i;
zwelch's avatar
zwelch committed
599
	uint16_t num_pages = 0;
600
	uint32_t device_id;
oharboe's avatar
oharboe committed
601
602
603
604
605
	int page_size;

	pic32mx_info->probed = 0;

	device_id = ejtag_info->idcode;
duane's avatar
duane committed
606
607
	LOG_INFO( "device id = 0x%08" PRIx32 " (manuf 0x%03x dev 0x%02x, ver 0x%03x)", 
			  device_id,
zwelch's avatar
zwelch committed
608
609
610
			  (unsigned)((device_id >> 1)&0x7ff), 
			  (unsigned)((device_id >> 12)&0xff), 
			  (unsigned)((device_id >> 20)&0xfff) );
oharboe's avatar
oharboe committed
611

zwelch's avatar
zwelch committed
612
	if (((device_id >> 1)&0x7ff) != PIC32MX_MANUF_ID) {
oharboe's avatar
oharboe committed
613
614
615
616
617
		LOG_WARNING( "Cannot identify target as a PIC32MX family." );
		return ERROR_FLASH_OPERATION_FAILED;
	}

	page_size = 4096;
zwelch's avatar
zwelch committed
618
	if (bank->base == PIC32MX_KSEG1_BOOT_FLASH || bank->base == 1) {
oharboe's avatar
oharboe committed
619
620
621
622
		/* 0xBFC00000: Boot flash size fixed at 12k */
		num_pages = 12;
	} else {
		/* 0xBD000000: Program flash size varies with device */
zwelch's avatar
zwelch committed
623
		for (i = 0; pic32mx_devs[i].name != NULL; i++)
zwelch's avatar
zwelch committed
624
			if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
oharboe's avatar
oharboe committed
625
626
627
				num_pages = pic32mx_devs[i].pfm_size;
				break;
			}
zwelch's avatar
zwelch committed
628
		if (pic32mx_devs[i].name == NULL) {
oharboe's avatar
oharboe committed
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
			LOG_WARNING( "Cannot identify target as a PIC32MX family." );
			return ERROR_FLASH_OPERATION_FAILED;
		}
	}

#if 0
	if (bank->target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	/* get flash size from target */
	if (target_read_u16(target, 0x1FFFF7E0, &num_pages) != ERROR_OK)
	{
		/* failed reading flash size, default to max target family */
		num_pages = 0xffff;
	}
#endif

	LOG_INFO( "flash size = %dkbytes", num_pages );

	/* calculate numbers of pages */
	num_pages /= (page_size / 1024);

zwelch's avatar
zwelch committed
654
655
	if (bank->base == 0) bank->base = PIC32MX_KSEG1_PGM_FLASH;
	if (bank->base == 1) bank->base = PIC32MX_KSEG1_BOOT_FLASH;
oharboe's avatar
oharboe committed
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
	bank->size = (num_pages * page_size);
	bank->num_sectors = num_pages;
	bank->chip_width = 4;
	bank->bus_width  = 4;
	bank->sectors = malloc(sizeof(flash_sector_t) * num_pages);

	for (i = 0; i < num_pages; i++)
	{
		bank->sectors[i].offset = i * page_size;
		bank->sectors[i].size = page_size;
		bank->sectors[i].is_erased = -1;
		bank->sectors[i].is_protected = 1;
	}

	pic32mx_info->probed = 1;

	return ERROR_OK;
}

mifi's avatar
mifi committed
675
static int pic32mx_auto_probe(struct flash_bank_s *bank)
oharboe's avatar
oharboe committed
676
677
678
679
680
681
682
{
	pic32mx_flash_bank_t *pic32mx_info = bank->driver_priv;
	if (pic32mx_info->probed)
		return ERROR_OK;
	return pic32mx_probe(bank);
}

mifi's avatar
mifi committed
683
684
#if 0
static int pic32mx_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
oharboe's avatar
oharboe committed
685
686
687
{
	return ERROR_OK;
}
mifi's avatar
mifi committed
688
#endif
oharboe's avatar
oharboe committed
689

mifi's avatar
mifi committed
690
static int pic32mx_info(struct flash_bank_s *bank, char *buf, int buf_size)
oharboe's avatar
oharboe committed
691
692
693
694
{
	target_t *target = bank->target;
	mips32_common_t *mips32 = target->arch_info;
	mips_ejtag_t *ejtag_info = &mips32->ejtag_info;
695
	uint32_t device_id;
696
	int printed = 0, i;
oharboe's avatar
oharboe committed
697
698
699

	device_id = ejtag_info->idcode;

zwelch's avatar
zwelch committed
700
	if (((device_id >> 1)&0x7ff) != PIC32MX_MANUF_ID) {
duane's avatar
duane committed
701
702
		snprintf(buf, buf_size, 
				 "Cannot identify target as a PIC32MX family (manufacturer 0x%03d != 0x%03d)\n", 
zwelch's avatar
zwelch committed
703
				 (unsigned)((device_id >> 1)&0x7ff), 
duane's avatar
duane committed
704
				 PIC32MX_MANUF_ID);
oharboe's avatar
oharboe committed
705
706
		return ERROR_FLASH_OPERATION_FAILED;
	}
zwelch's avatar
zwelch committed
707
	for (i = 0; pic32mx_devs[i].name != NULL; i++)
zwelch's avatar
zwelch committed
708
		if (pic32mx_devs[i].devid == ((device_id >> 12) & 0xff)) {
oharboe's avatar
oharboe committed
709
710
711
			printed = snprintf(buf, buf_size, "PIC32MX%s", pic32mx_devs[i].name);
			break;
		}
zwelch's avatar
zwelch committed
712
	if (pic32mx_devs[i].name == NULL) {
oharboe's avatar
oharboe committed
713
714
715
716
717
		snprintf(buf, buf_size, "Cannot identify target as a PIC32MX family\n");
		return ERROR_FLASH_OPERATION_FAILED;
	}
	buf += printed;
	buf_size -= printed;
duane's avatar
duane committed
718
	printed = snprintf(buf, buf_size, "  Ver: 0x%03x", 
zwelch's avatar
zwelch committed
719
					   (unsigned)((device_id >> 20)&0xfff));
oharboe's avatar
oharboe committed
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820

	return ERROR_OK;
}

#if 0
int pic32mx_handle_lock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
	flash_bank_t *bank;
	target_t *target = NULL;
	pic32mx_flash_bank_t *pic32mx_info = NULL;

	if (argc < 1)
	{
		command_print(cmd_ctx, "pic32mx lock <bank>");
		return ERROR_OK;
	}

	bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
	if (!bank)
	{
		command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
		return ERROR_OK;
	}

	pic32mx_info = bank->driver_priv;

	target = bank->target;

	if (target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (pic32mx_erase_options(bank) != ERROR_OK)
	{
		command_print(cmd_ctx, "pic32mx failed to erase options");
		return ERROR_OK;
	}

	/* set readout protection */
	pic32mx_info->option_bytes.RDP = 0;

	if (pic32mx_write_options(bank) != ERROR_OK)
	{
		command_print(cmd_ctx, "pic32mx failed to lock device");
		return ERROR_OK;
	}

	command_print(cmd_ctx, "pic32mx locked");

	return ERROR_OK;
}

int pic32mx_handle_unlock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
	flash_bank_t *bank;
	target_t *target = NULL;
	pic32mx_flash_bank_t *pic32mx_info = NULL;

	if (argc < 1)
	{
		command_print(cmd_ctx, "pic32mx unlock <bank>");
		return ERROR_OK;
	}

	bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
	if (!bank)
	{
		command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
		return ERROR_OK;
	}

	pic32mx_info = bank->driver_priv;

	target = bank->target;

	if (target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	if (pic32mx_erase_options(bank) != ERROR_OK)
	{
		command_print(cmd_ctx, "pic32mx failed to unlock device");
		return ERROR_OK;
	}

	if (pic32mx_write_options(bank) != ERROR_OK)
	{
		command_print(cmd_ctx, "pic32mx failed to lock device");
		return ERROR_OK;
	}

	command_print(cmd_ctx, "pic32mx unlocked");

	return ERROR_OK;
}
#endif

mifi's avatar
mifi committed
821
822
#if 0
static int pic32mx_chip_erase(struct flash_bank_s *bank)
oharboe's avatar
oharboe committed
823
824
{
	target_t *target = bank->target;
825
#if 0
826
	uint32_t status;
827
#endif
oharboe's avatar
oharboe committed
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843

	if (target->state != TARGET_HALTED)
	{
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	LOG_INFO("PIC32MX chip erase called");

#if 0
	/* unlock option flash registers */
	target_write_u32(target, PIC32MX_FLASH_KEYR, KEY1);
	target_write_u32(target, PIC32MX_FLASH_KEYR, KEY2);

	/* chip erase flash memory */
	target_write_u32(target, PIC32MX_FLASH_CR, FLASH_MER);
zwelch's avatar
zwelch committed
844
	target_write_u32(target, PIC32MX_FLASH_CR, FLASH_MER | FLASH_STRT);
oharboe's avatar
oharboe committed
845
846
847
848
849

	status = pic32mx_wait_status_busy(bank, 10);

	target_write_u32(target, PIC32MX_FLASH_CR, FLASH_LOCK);

zwelch's avatar
zwelch committed
850
	if ( status & FLASH_WRPRTERR )
oharboe's avatar
oharboe committed
851
852
853
854
855
	{
		LOG_ERROR("pic32mx device protected");
		return ERROR_OK;
	}

zwelch's avatar
zwelch committed
856
	if ( status & FLASH_PGERR )
oharboe's avatar
oharboe committed
857
858
859
860
861
862
863
864
	{
		LOG_ERROR("pic32mx device programming failed");
		return ERROR_OK;
	}
#endif

	return ERROR_OK;
}
mifi's avatar
mifi committed
865
#endif
oharboe's avatar
oharboe committed
866

mifi's avatar
mifi committed
867
static int pic32mx_handle_chip_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
oharboe's avatar
oharboe committed
868
{
869
#if 0
oharboe's avatar
oharboe committed
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
	flash_bank_t *bank;
	int i;

	if (argc != 0)
	{
		command_print(cmd_ctx, "pic32mx chip_erase");
		return ERROR_OK;
	}

	bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
	if (!bank)
	{
		command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
		return ERROR_OK;
	}

	if (pic32mx_chip_erase(bank) == ERROR_OK)
	{
		/* set all sectors as erased */
		for (i = 0; i < bank->num_sectors; i++)
		{
			bank->sectors[i].is_erased = 1;
		}

		command_print(cmd_ctx, "pic32mx chip erase complete");
	}
	else
	{
		command_print(cmd_ctx, "pic32mx chip erase failed");
	}
#endif

	return ERROR_OK;
}

mifi's avatar
mifi committed
905
static int pic32mx_handle_pgm_word_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
oharboe's avatar
oharboe committed
906
907
{
	flash_bank_t *bank;
908
	uint32_t address, value;
oharboe's avatar
oharboe committed
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
	int status, res;

	if (argc != 3)
	{
		command_print(cmd_ctx, "pic32mx pgm_word <addr> <value> <bank>");
		return ERROR_OK;
	}

	address = strtoul(args[0], NULL, 0);
	value   = strtoul(args[1], NULL, 0);

	bank = get_flash_bank_by_num(strtoul(args[2], NULL, 0));
	if (!bank)
	{
		command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[2]);
		return ERROR_OK;
	}
zwelch's avatar
zwelch committed
926
	if (address < bank->base || address >= (bank->base + bank->size))
oharboe's avatar
oharboe committed
927
928
929
930
931
932
933
	{
		command_print(cmd_ctx, "flash address '%s' is out of bounds", args[0]);
		return ERROR_OK;
	}

	res = ERROR_OK;
	status = pic32mx_write_word(bank, address, value);
zwelch's avatar
zwelch committed
934
	if ( status & NVMCON_NVMERR )
oharboe's avatar
oharboe committed
935
		res = ERROR_FLASH_OPERATION_FAILED;
zwelch's avatar
zwelch committed
936
	if ( status & NVMCON_LVDERR )
oharboe's avatar
oharboe committed
937
938
939
940
941
		res = ERROR_FLASH_OPERATION_FAILED;

	if (res == ERROR_OK)
		command_print(cmd_ctx, "pic32mx pgm word complete");
	else
zwelch's avatar
zwelch committed
942
		command_print(cmd_ctx, "pic32mx pgm word failed (status = 0x%x)", status);
oharboe's avatar
oharboe committed
943
944
945

	return ERROR_OK;
}