Code Review / openocd.git / blob
? search:


a44f3c21e23e2282a71ee6dd6aaaf031c93112c3
[openocd.git] / src / flash / nand / lpc3180.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 *
5 * Copyright (C) 2010 richard vegh <vegh.ricsi@gmail.com> *
6 * Copyright (C) 2010 Oyvind Harboe <oyvind.harboe@zylin.com> *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "imp.h"
29 #include "lpc3180.h"
30 #include <target/target.h>
31
32 static int lpc3180_reset(struct nand_device *nand);
33 static int lpc3180_controller_ready(struct nand_device *nand, int timeout);
34 static int lpc3180_tc_ready(struct nand_device *nand, int timeout);
35
36 #define ECC_OFFS 0x120
37 #define SPARE_OFFS 0x140
38 #define DATA_OFFS 0x200
39
40 /* nand device lpc3180 <target#> <oscillator_frequency>
41 */
42 NAND_DEVICE_COMMAND_HANDLER(lpc3180_nand_device_command)
43 {
44 if (CMD_ARGC < 3)
45 return ERROR_COMMAND_SYNTAX_ERROR;
46
47 uint32_t osc_freq;
48 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], osc_freq);
49
50 struct lpc3180_nand_controller *lpc3180_info;
51 lpc3180_info = malloc(sizeof(struct lpc3180_nand_controller));
52 nand->controller_priv = lpc3180_info;
53
54 lpc3180_info->osc_freq = osc_freq;
55
56 if ((lpc3180_info->osc_freq < 1000) || (lpc3180_info->osc_freq > 20000))
57 LOG_WARNING(
58 "LPC3180 oscillator frequency should be between 1000 and 20000 kHz, was %i",
59 lpc3180_info->osc_freq);
60 lpc3180_info->selected_controller = LPC3180_NO_CONTROLLER;
61 lpc3180_info->sw_write_protection = 0;
62 lpc3180_info->sw_wp_lower_bound = 0x0;
63 lpc3180_info->sw_wp_upper_bound = 0x0;
64
65 return ERROR_OK;
66 }
67
68 static int lpc3180_pll(int fclkin, uint32_t pll_ctrl)
69 {
70 int bypass = (pll_ctrl & 0x8000) >> 15;
71 int direct = (pll_ctrl & 0x4000) >> 14;
72 int feedback = (pll_ctrl & 0x2000) >> 13;
73 int p = (1 << ((pll_ctrl & 0x1800) >> 11) * 2);
74 int n = ((pll_ctrl & 0x0600) >> 9) + 1;
75 int m = ((pll_ctrl & 0x01fe) >> 1) + 1;
76 int lock = (pll_ctrl & 0x1);
77
78 if (!lock)
79 LOG_WARNING("PLL is not locked");
80
81 if (!bypass && direct) /* direct mode */
82 return (m * fclkin) / n;
83
84 if (bypass && !direct) /* bypass mode */
85 return fclkin / (2 * p);
86
87 if (bypass & direct) /* direct bypass mode */
88 return fclkin;
89
90 if (feedback) /* integer mode */
91 return m * (fclkin / n);
92 else /* non-integer mode */
93 return (m / (2 * p)) * (fclkin / n);
94 }
95
96 static float lpc3180_cycle_time(struct nand_device *nand)
97 {
98 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
99 struct target *target = nand->target;
100 uint32_t sysclk_ctrl, pwr_ctrl, hclkdiv_ctrl, hclkpll_ctrl;
101 int sysclk;
102 int hclk;
103 int hclk_pll;
104 float cycle;
105
106 /* calculate timings */
107
108 /* determine current SYSCLK (13'MHz or main oscillator) */
109 target_read_u32(target, 0x40004050, &sysclk_ctrl);
110
111 if ((sysclk_ctrl & 1) == 0)
112 sysclk = lpc3180_info->osc_freq;
113 else
114 sysclk = 13000;
115
116 /* determine selected HCLK source */
117 target_read_u32(target, 0x40004044, &pwr_ctrl);
118
119 if ((pwr_ctrl & (1 << 2)) == 0) /* DIRECT RUN mode */
120 hclk = sysclk;
121 else {
122 target_read_u32(target, 0x40004058, &hclkpll_ctrl);
123 hclk_pll = lpc3180_pll(sysclk, hclkpll_ctrl);
124
125 target_read_u32(target, 0x40004040, &hclkdiv_ctrl);
126
127 if (pwr_ctrl & (1 << 10)) /* ARM_CLK and HCLK use PERIPH_CLK */
128 hclk = hclk_pll / (((hclkdiv_ctrl & 0x7c) >> 2) + 1);
129 else /* HCLK uses HCLK_PLL */
130 hclk = hclk_pll / (1 << (hclkdiv_ctrl & 0x3));
131 }
132
133 LOG_DEBUG("LPC3180 HCLK currently clocked at %i kHz", hclk);
134
135 cycle = (1.0 / hclk) * 1000000.0;
136
137 return cycle;
138 }
139
140 static int lpc3180_init(struct nand_device *nand)
141 {
142 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
143 struct target *target = nand->target;
144 int bus_width = nand->bus_width ? : 8;
145 int address_cycles = nand->address_cycles ? : 3;
146 int page_size = nand->page_size ? : 512;
147
148 if (target->state != TARGET_HALTED) {
149 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
150 return ERROR_NAND_OPERATION_FAILED;
151 }
152
153 /* sanitize arguments */
154 if ((bus_width != 8) && (bus_width != 16)) {
155 LOG_ERROR("LPC3180 only supports 8 or 16 bit bus width, not %i", bus_width);
156 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
157 }
158
159 /* The LPC3180 only brings out 8 bit NAND data bus, but the controller
160 * would support 16 bit, too, so we just warn about this for now
161 */
162 if (bus_width == 16)
163 LOG_WARNING("LPC3180 only supports 8 bit bus width");
164
165 /* inform calling code about selected bus width */
166 nand->bus_width = bus_width;
167
168 if ((address_cycles != 3) && (address_cycles != 4)) {
169 LOG_ERROR("LPC3180 only supports 3 or 4 address cycles, not %i", address_cycles);
170 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
171 }
172
173 if ((page_size != 512) && (page_size != 2048)) {
174 LOG_ERROR("LPC3180 only supports 512 or 2048 byte pages, not %i", page_size);
175 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
176 }
177
178 /* select MLC controller if none is currently selected */
179 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
180 LOG_DEBUG("no LPC3180 NAND flash controller selected, using default 'mlc'");
181 lpc3180_info->selected_controller = LPC3180_MLC_CONTROLLER;
182 }
183
184 if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
185 uint32_t mlc_icr_value = 0x0;
186 float cycle;
187 int twp, twh, trp, treh, trhz, trbwb, tcea;
188
189 /* FLASHCLK_CTRL = 0x22 (enable clock for MLC flash controller) */
190 target_write_u32(target, 0x400040c8, 0x22);
191
192 /* MLC_CEH = 0x0 (Force nCE assert) */
193 target_write_u32(target, 0x200b804c, 0x0);
194
195 /* MLC_LOCK = 0xa25e (unlock protected registers) */
196 target_write_u32(target, 0x200b8044, 0xa25e);
197
198 /* MLC_ICR = configuration */
199 if (lpc3180_info->sw_write_protection)
200 mlc_icr_value |= 0x8;
201 if (page_size == 2048)
202 mlc_icr_value |= 0x4;
203 if (address_cycles == 4)
204 mlc_icr_value |= 0x2;
205 if (bus_width == 16)
206 mlc_icr_value |= 0x1;
207 target_write_u32(target, 0x200b8030, mlc_icr_value);
208
209 /* calculate NAND controller timings */
210 cycle = lpc3180_cycle_time(nand);
211
212 twp = ((40 / cycle) + 1);
213 twh = ((20 / cycle) + 1);
214 trp = ((30 / cycle) + 1);
215 treh = ((15 / cycle) + 1);
216 trhz = ((30 / cycle) + 1);
217 trbwb = ((100 / cycle) + 1);
218 tcea = ((45 / cycle) + 1);
219
220 /* MLC_LOCK = 0xa25e (unlock protected registers) */
221 target_write_u32(target, 0x200b8044, 0xa25e);
222
223 /* MLC_TIME_REG */
224 target_write_u32(target, 0x200b8034, (twp & 0xf) | ((twh & 0xf) << 4) |
225 ((trp & 0xf) << 8) | ((treh & 0xf) << 12) | ((trhz & 0x7) << 16) |
226 ((trbwb & 0x1f) << 19) | ((tcea & 0x3) << 24));
227
228 lpc3180_reset(nand);
229 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
230 float cycle;
231 int r_setup, r_hold, r_width, r_rdy;
232 int w_setup, w_hold, w_width, w_rdy;
233
234 /* FLASHCLK_CTRL = 0x05 (enable clock for SLC flash controller) */
235 target_write_u32(target, 0x400040c8, 0x05);
236
237 /* after reset set other registers of SLC so reset calling is here at the begining*/
238 lpc3180_reset(nand);
239
240 /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst enabled,
241 *DMA read from SLC, WIDTH = bus_width) */
242 target_write_u32(target, 0x20020014, 0x3e | (bus_width == 16) ? 1 : 0);
243
244 /* SLC_IEN = 3 (INT_RDY_EN = 1) ,(INT_TC_STAT = 1) */
245 target_write_u32(target, 0x20020020, 0x03);
246
247 /* DMA configuration
248 * DMACLK_CTRL = 0x01 (enable clock for DMA controller) */
249 target_write_u32(target, 0x400040e8, 0x01);
250 /* DMACConfig = DMA enabled*/
251 target_write_u32(target, 0x31000030, 0x01);
252
253
254 /* calculate NAND controller timings */
255 cycle = lpc3180_cycle_time(nand);
256
257 r_setup = w_setup = 0;
258 r_hold = w_hold = 10 / cycle;
259 r_width = 30 / cycle;
260 w_width = 40 / cycle;
261 r_rdy = w_rdy = 100 / cycle;
262
263 /* SLC_TAC: SLC timing arcs register */
264 target_write_u32(target, 0x2002002c, (r_setup & 0xf) | ((r_hold & 0xf) << 4) |
265 ((r_width & 0xf) << 8) | ((r_rdy & 0xf) << 12) | ((w_setup & 0xf) << 16) |
266 ((w_hold & 0xf) << 20) | ((w_width & 0xf) << 24) | ((w_rdy & 0xf) << 28));
267
268 }
269
270 return ERROR_OK;
271 }
272
273 static int lpc3180_reset(struct nand_device *nand)
274 {
275 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
276 struct target *target = nand->target;
277
278 if (target->state != TARGET_HALTED) {
279 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
280 return ERROR_NAND_OPERATION_FAILED;
281 }
282
283 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
284 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
285 return ERROR_NAND_OPERATION_FAILED;
286 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
287 /* MLC_CMD = 0xff (reset controller and NAND device) */
288 target_write_u32(target, 0x200b8000, 0xff);
289
290 if (!lpc3180_controller_ready(nand, 100)) {
291 LOG_ERROR("LPC3180 NAND controller timed out after reset");
292 return ERROR_NAND_OPERATION_TIMEOUT;
293 }
294 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
295 /* SLC_CTRL = 0x6 (ECC_CLEAR, SW_RESET) */
296 target_write_u32(target, 0x20020010, 0x6);
297
298 if (!lpc3180_controller_ready(nand, 100)) {
299 LOG_ERROR("LPC3180 NAND controller timed out after reset");
300 return ERROR_NAND_OPERATION_TIMEOUT;
301 }
302 }
303
304 return ERROR_OK;
305 }
306
307 static int lpc3180_command(struct nand_device *nand, uint8_t command)
308 {
309 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
310 struct target *target = nand->target;
311
312 if (target->state != TARGET_HALTED) {
313 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
314 return ERROR_NAND_OPERATION_FAILED;
315 }
316
317 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
318 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
319 return ERROR_NAND_OPERATION_FAILED;
320 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
321 /* MLC_CMD = command */
322 target_write_u32(target, 0x200b8000, command);
323 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
324 /* SLC_CMD = command */
325 target_write_u32(target, 0x20020008, command);
326 }
327
328 return ERROR_OK;
329 }
330
331 static int lpc3180_address(struct nand_device *nand, uint8_t address)
332 {
333 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
334 struct target *target = nand->target;
335
336 if (target->state != TARGET_HALTED) {
337 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
338 return ERROR_NAND_OPERATION_FAILED;
339 }
340
341 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
342 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
343 return ERROR_NAND_OPERATION_FAILED;
344 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
345 /* MLC_ADDR = address */
346 target_write_u32(target, 0x200b8004, address);
347 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
348 /* SLC_ADDR = address */
349 target_write_u32(target, 0x20020004, address);
350 }
351
352 return ERROR_OK;
353 }
354
355 static int lpc3180_write_data(struct nand_device *nand, uint16_t data)
356 {
357 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
358 struct target *target = nand->target;
359
360 if (target->state != TARGET_HALTED) {
361 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
362 return ERROR_NAND_OPERATION_FAILED;
363 }
364
365 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
366 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
367 return ERROR_NAND_OPERATION_FAILED;
368 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
369 /* MLC_DATA = data */
370 target_write_u32(target, 0x200b0000, data);
371 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
372 /* SLC_DATA = data */
373 target_write_u32(target, 0x20020000, data);
374 }
375
376 return ERROR_OK;
377 }
378
379 static int lpc3180_read_data(struct nand_device *nand, void *data)
380 {
381 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
382 struct target *target = nand->target;
383
384 if (target->state != TARGET_HALTED) {
385 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
386 return ERROR_NAND_OPERATION_FAILED;
387 }
388
389 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
390 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
391 return ERROR_NAND_OPERATION_FAILED;
392 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
393 /* data = MLC_DATA, use sized access */
394 if (nand->bus_width == 8) {
395 uint8_t *data8 = data;
396 target_read_u8(target, 0x200b0000, data8);
397 } else if (nand->bus_width == 16) {
398 uint16_t *data16 = data;
399 target_read_u16(target, 0x200b0000, data16);
400 } else {
401 LOG_ERROR("BUG: bus_width neither 8 nor 16 bit");
402 return ERROR_NAND_OPERATION_FAILED;
403 }
404 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
405 uint32_t data32;
406
407 /* data = SLC_DATA, must use 32-bit access */
408 target_read_u32(target, 0x20020000, &data32);
409
410 if (nand->bus_width == 8) {
411 uint8_t *data8 = data;
412 *data8 = data32 & 0xff;
413 } else if (nand->bus_width == 16) {
414 uint16_t *data16 = data;
415 *data16 = data32 & 0xffff;
416 } else {
417 LOG_ERROR("BUG: bus_width neither 8 nor 16 bit");
418 return ERROR_NAND_OPERATION_FAILED;
419 }
420 }
421
422 return ERROR_OK;
423 }
424
425 static int lpc3180_write_page(struct nand_device *nand,
426 uint32_t page,
427 uint8_t *data,
428 uint32_t data_size,
429 uint8_t *oob,
430 uint32_t oob_size)
431 {
432 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
433 struct target *target = nand->target;
434 int retval;
435 uint8_t status;
436 uint8_t *page_buffer;
437
438 if (target->state != TARGET_HALTED) {
439 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
440 return ERROR_NAND_OPERATION_FAILED;
441 }
442
443 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
444 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
445 return ERROR_NAND_OPERATION_FAILED;
446 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
447 uint8_t *oob_buffer;
448 int quarter, num_quarters;
449
450 if (!data && oob) {
451 LOG_ERROR("LPC3180 MLC controller can't write OOB data only");
452 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
453 }
454
455 if (oob && (oob_size > 24)) {
456 LOG_ERROR("LPC3180 MLC controller can't write more "
457 "than 6 bytes for each quarter's OOB data");
458 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
459 }
460
461 if (data_size > (uint32_t)nand->page_size) {
462 LOG_ERROR("data size exceeds page size");
463 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
464 }
465
466 /* MLC_CMD = sequential input */
467 target_write_u32(target, 0x200b8000, NAND_CMD_SEQIN);
468
469 page_buffer = malloc(512);
470 oob_buffer = malloc(6);
471
472 if (nand->page_size == 512) {
473 /* MLC_ADDR = 0x0 (one column cycle) */
474 target_write_u32(target, 0x200b8004, 0x0);
475
476 /* MLC_ADDR = row */
477 target_write_u32(target, 0x200b8004, page & 0xff);
478 target_write_u32(target, 0x200b8004, (page >> 8) & 0xff);
479
480 if (nand->address_cycles == 4)
481 target_write_u32(target, 0x200b8004, (page >> 16) & 0xff);
482 } else {
483 /* MLC_ADDR = 0x0 (two column cycles) */
484 target_write_u32(target, 0x200b8004, 0x0);
485 target_write_u32(target, 0x200b8004, 0x0);
486
487 /* MLC_ADDR = row */
488 target_write_u32(target, 0x200b8004, page & 0xff);
489 target_write_u32(target, 0x200b8004, (page >> 8) & 0xff);
490 }
491
492 /* when using the MLC controller, we have to treat a large page device
493 * as being made out of four quarters, each the size of a small page device
494 */
495 num_quarters = (nand->page_size == 2048) ? 4 : 1;
496
497 for (quarter = 0; quarter < num_quarters; quarter++) {
498 int thisrun_data_size = (data_size > 512) ? 512 : data_size;
499 int thisrun_oob_size = (oob_size > 6) ? 6 : oob_size;
500
501 memset(page_buffer, 0xff, 512);
502 if (data) {
503 memcpy(page_buffer, data, thisrun_data_size);
504 data_size -= thisrun_data_size;
505 data += thisrun_data_size;
506 }
507
508 memset(oob_buffer, 0xff, 6);
509 if (oob) {
510 memcpy(oob_buffer, oob, thisrun_oob_size);
511 oob_size -= thisrun_oob_size;
512 oob += thisrun_oob_size;
513 }
514
515 /* write MLC_ECC_ENC_REG to start encode cycle */
516 target_write_u32(target, 0x200b8008, 0x0);
517
518 target_write_memory(target, 0x200a8000,
519 4, 128, page_buffer);
520 target_write_memory(target, 0x200a8000,
521 1, 6, oob_buffer);
522
523 /* write MLC_ECC_AUTO_ENC_REG to start auto encode */
524 target_write_u32(target, 0x200b8010, 0x0);
525
526 if (!lpc3180_controller_ready(nand, 1000)) {
527 LOG_ERROR("timeout while waiting for completion of auto encode cycle");
528 free(page_buffer);
529 free(oob_buffer);
530 return ERROR_NAND_OPERATION_FAILED;
531 }
532 }
533
534 /* MLC_CMD = auto program command */
535 target_write_u32(target, 0x200b8000, NAND_CMD_PAGEPROG);
536
537 retval = nand_read_status(nand, &status);
538 if (retval != ERROR_OK) {
539 LOG_ERROR("couldn't read status");
540 free(page_buffer);
541 free(oob_buffer);
542 return ERROR_NAND_OPERATION_FAILED;
543 }
544
545 if (status & NAND_STATUS_FAIL) {
546 LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status);
547 free(page_buffer);
548 free(oob_buffer);
549 return ERROR_NAND_OPERATION_FAILED;
550 }
551
552 free(page_buffer);
553 free(oob_buffer);
554 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
555
556 /**********************************************************************
557 * Write both SLC NAND flash page main area and spare area.
558 * Small page -
559 * ------------------------------------------
560 * | 512 bytes main | 16 bytes spare |
561 * ------------------------------------------
562 * Large page -
563 * ------------------------------------------
564 * | 2048 bytes main | 64 bytes spare |
565 * ------------------------------------------
566 * If DMA & ECC enabled, then the ECC generated for the 1st 256-byte
567 * data is written to the 3rd word of the spare area. The ECC
568 * generated for the 2nd 256-byte data is written to the 4th word
569 * of the spare area. The ECC generated for the 3rd 256-byte data is
570 * written to the 7th word of the spare area. The ECC generated
571 * for the 4th 256-byte data is written to the 8th word of the
572 * spare area and so on.
573 *
574 **********************************************************************/
575
576 int i = 0, target_mem_base;
577 uint8_t *ecc_flash_buffer;
578 struct working_area *pworking_area;
579
580 if (lpc3180_info->is_bulk) {
581
582 if (!data && oob) {
583 /*if oob only mode is active original method is used as SLC
584 *controller hangs during DMA interworking. Anyway the code supports
585 *the oob only mode below. */
586 return nand_write_page_raw(nand,
587 page,
588 data,
589 data_size,
590 oob,
591 oob_size);
592 }
593 retval = nand_page_command(nand, page, NAND_CMD_SEQIN, !data);
594 if (ERROR_OK != retval)
595 return retval;
596
597 /* allocate a working area */
598 if (target->working_area_size < (uint32_t) nand->page_size + 0x200) {
599 LOG_ERROR("Reserve at least 0x%x physical target working area",
600 nand->page_size + 0x200);
601 return ERROR_FLASH_OPERATION_FAILED;
602 }
603 if (target->working_area_phys%4) {
604 LOG_ERROR(
605 "Reserve the physical target working area at word boundary");
606 return ERROR_FLASH_OPERATION_FAILED;
607 }
608 if (target_alloc_working_area(target, target->working_area_size,
609 &pworking_area) != ERROR_OK) {
610 LOG_ERROR("no working area specified, can't read LPC internal flash");
611 return ERROR_FLASH_OPERATION_FAILED;
612 }
613 target_mem_base = target->working_area_phys;
614
615 if (nand->page_size == 2048)
616 page_buffer = malloc(2048);
617 else
618 page_buffer = malloc(512);
619
620 ecc_flash_buffer = malloc(64);
621
622 /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst
623 *enabled, DMA write to SLC, WIDTH = bus_width) */
624 target_write_u32(target, 0x20020014, 0x3c);
625
626 if (data && !oob) {
627 /* set DMA LLI-s in target memory and in DMA*/
628 for (i = 0; i < nand->page_size/0x100; i++) {
629
630 int tmp;
631 /* -------LLI for 256 byte block---------
632 * DMACC0SrcAddr = SRAM */
633 target_write_u32(target,
634 target_mem_base+0+i*32,
635 target_mem_base+DATA_OFFS+i*256);
636 if (i == 0)
637 target_write_u32(target,
638 0x31000100,
639 target_mem_base+DATA_OFFS);
640 /* DMACCxDestAddr = SLC_DMA_DATA */
641 target_write_u32(target, target_mem_base+4+i*32, 0x20020038);
642 if (i == 0)
643 target_write_u32(target, 0x31000104, 0x20020038);
644 /* DMACCxLLI = next element */
645 tmp = (target_mem_base+(1+i*2)*16)&0xfffffffc;
646 target_write_u32(target, target_mem_base+8+i*32, tmp);
647 if (i == 0)
648 target_write_u32(target, 0x31000108, tmp);
649 /* DMACCxControl = TransferSize =64, Source burst size =16,
650 * Destination burst size = 16, Source transfer width = 32 bit,
651 * Destination transfer width = 32 bit, Source AHB master select = M0,
652 * Destination AHB master select = M0, Source increment = 1,
653 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
654 target_write_u32(target,
655 target_mem_base+12+i*32,
656 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
657 0<<27 | 0<<31);
658 if (i == 0)
659 target_write_u32(target,
660 0x3100010c,
661 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
662 0<<27 | 0<<31);
663
664 /* -------LLI for 3 byte ECC---------
665 * DMACC0SrcAddr = SLC_ECC*/
666 target_write_u32(target, target_mem_base+16+i*32, 0x20020034);
667 /* DMACCxDestAddr = SRAM */
668 target_write_u32(target,
669 target_mem_base+20+i*32,
670 target_mem_base+SPARE_OFFS+8+16*(i>>1)+(i%2)*4);
671 /* DMACCxLLI = next element */
672 tmp = (target_mem_base+(2+i*2)*16)&0xfffffffc;
673 target_write_u32(target, target_mem_base+24+i*32, tmp);
674 /* DMACCxControl = TransferSize =1, Source burst size =4,
675 * Destination burst size = 4, Source transfer width = 32 bit,
676 * Destination transfer width = 32 bit, Source AHB master select = M0,
677 * Destination AHB master select = M0, Source increment = 0,
678 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
679 target_write_u32(target,
680 target_mem_base+28+i*32,
681 0x01 | 1<<12 | 1<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
682 31);
683 }
684 } else if (data && oob) {
685 /* -------LLI for 512 or 2048 bytes page---------
686 * DMACC0SrcAddr = SRAM */
687 target_write_u32(target, target_mem_base, target_mem_base+DATA_OFFS);
688 target_write_u32(target, 0x31000100, target_mem_base+DATA_OFFS);
689 /* DMACCxDestAddr = SLC_DMA_DATA */
690 target_write_u32(target, target_mem_base+4, 0x20020038);
691 target_write_u32(target, 0x31000104, 0x20020038);
692 /* DMACCxLLI = next element */
693 target_write_u32(target,
694 target_mem_base+8,
695 (target_mem_base+32)&0xfffffffc);
696 target_write_u32(target, 0x31000108,
697 (target_mem_base+32)&0xfffffffc);
698 /* DMACCxControl = TransferSize =512 or 128, Source burst size =16,
699 * Destination burst size = 16, Source transfer width = 32 bit,
700 * Destination transfer width = 32 bit, Source AHB master select = M0,
701 * Destination AHB master select = M0, Source increment = 1,
702 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
703 target_write_u32(target,
704 target_mem_base+12,
705 (nand->page_size ==
706 2048 ? 512 : 128) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 |
707 1<<26 | 0<<27 | 0<<31);
708 target_write_u32(target,
709 0x3100010c,
710 (nand->page_size ==
711 2048 ? 512 : 128) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 |
712 1<<26 | 0<<27 | 0<<31);
713 i = 1;
714 } else if (!data && oob)
715 i = 0;
716
717 /* -------LLI for spare area---------
718 * DMACC0SrcAddr = SRAM*/
719 target_write_u32(target, target_mem_base+0+i*32, target_mem_base+SPARE_OFFS);
720 if (i == 0)
721 target_write_u32(target, 0x31000100, target_mem_base+SPARE_OFFS);
722 /* DMACCxDestAddr = SLC_DMA_DATA */
723 target_write_u32(target, target_mem_base+4+i*32, 0x20020038);
724 if (i == 0)
725 target_write_u32(target, 0x31000104, 0x20020038);
726 /* DMACCxLLI = next element = NULL */
727 target_write_u32(target, target_mem_base+8+i*32, 0);
728 if (i == 0)
729 target_write_u32(target, 0x31000108, 0);
730 /* DMACCxControl = TransferSize =16 for large page or 4 for small page,
731 * Source burst size =16, Destination burst size = 16, Source transfer width = 32 bit,
732 * Destination transfer width = 32 bit, Source AHB master select = M0,
733 * Destination AHB master select = M0, Source increment = 1,
734 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
735 target_write_u32(target,
736 target_mem_base+12+i*32,
737 (nand->page_size ==
738 2048 ? 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
739 0<<27 | 0<<31);
740 if (i == 0)
741 target_write_u32(target, 0x3100010c,
742 (nand->page_size == 2048 ?
743 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 |
744 0<<25 | 1<<26 | 0<<27 | 0<<31);
745
746 memset(ecc_flash_buffer, 0xff, 64);
747 if (oob)
748 memcpy(ecc_flash_buffer, oob, oob_size);
749 target_write_memory(target,
750 target_mem_base+SPARE_OFFS,
751 4,
752 16,
753 ecc_flash_buffer);
754
755 if (data) {
756 memset(page_buffer, 0xff, nand->page_size == 2048 ? 2048 : 512);
757 memcpy(page_buffer, data, data_size);
758 target_write_memory(target,
759 target_mem_base+DATA_OFFS,
760 4,
761 nand->page_size == 2048 ? 512 : 128,
762 page_buffer);
763 }
764
765 free(page_buffer);
766 free(ecc_flash_buffer);
767
768 /* Enable DMA after channel set up !
769 LLI only works when DMA is the flow controller!
770 */
771 /* DMACCxConfig= E=1, SrcPeripheral = 1 (SLC), DestPeripheral = 1 (SLC),
772 *FlowCntrl = 2 (Pher -> Mem, DMA), IE = 0, ITC = 0, L= 0, H=0*/
773 target_write_u32(target,
774 0x31000110,
775 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
776
777 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
778 target_write_u32(target, 0x20020010, 0x3);
779
780 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
781 target_write_u32(target, 0x20020028, 2);
782
783 /* SLC_TC */
784 if (!data && oob)
785 target_write_u32(target, 0x20020030,
786 (nand->page_size == 2048 ? 0x10 : 0x04));
787 else
788 target_write_u32(target, 0x20020030,
789 (nand->page_size == 2048 ? 0x840 : 0x210));
790
791 nand_write_finish(nand);
792
793 if (!lpc3180_tc_ready(nand, 1000)) {
794 LOG_ERROR("timeout while waiting for completion of DMA");
795 return ERROR_NAND_OPERATION_FAILED;
796 }
797
798 target_free_working_area(target, pworking_area);
799
800 LOG_INFO("Page = 0x%" PRIx32 " was written.", page);
801
802 } else
803 return nand_write_page_raw(nand, page, data, data_size, oob, oob_size);
804 }
805
806 return ERROR_OK;
807 }
808
809 static int lpc3180_read_page(struct nand_device *nand,
810 uint32_t page,
811 uint8_t *data,
812 uint32_t data_size,
813 uint8_t *oob,
814 uint32_t oob_size)
815 {
816 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
817 struct target *target = nand->target;
818 uint8_t *page_buffer;
819
820 if (target->state != TARGET_HALTED) {
821 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
822 return ERROR_NAND_OPERATION_FAILED;
823 }
824
825 if (lpc3180_info->selected_controller == LPC3180_NO_CONTROLLER) {
826 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
827 return ERROR_NAND_OPERATION_FAILED;
828 } else if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
829 uint8_t *oob_buffer;
830 uint32_t page_bytes_done = 0;
831 uint32_t oob_bytes_done = 0;
832 uint32_t mlc_isr;
833
834 #if 0
835 if (oob && (oob_size > 6)) {
836 LOG_ERROR("LPC3180 MLC controller can't read more than 6 bytes of OOB data");
837 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
838 }
839 #endif
840
841 if (data_size > (uint32_t)nand->page_size) {
842 LOG_ERROR("data size exceeds page size");
843 return ERROR_NAND_OPERATION_NOT_SUPPORTED;
844 }
845
846 if (nand->page_size == 2048) {
847 page_buffer = malloc(2048);
848 oob_buffer = malloc(64);
849 } else {
850 page_buffer = malloc(512);
851 oob_buffer = malloc(16);
852 }
853
854 if (!data && oob) {
855 /* MLC_CMD = Read OOB
856 * we can use the READOOB command on both small and large page devices,
857 * as the controller translates the 0x50 command to a 0x0 with appropriate
858 * positioning of the serial buffer read pointer
859 */
860 target_write_u32(target, 0x200b8000, NAND_CMD_READOOB);
861 } else {
862 /* MLC_CMD = Read0 */
863 target_write_u32(target, 0x200b8000, NAND_CMD_READ0);
864 }
865
866 if (nand->page_size == 512) {
867 /* small page device
868 * MLC_ADDR = 0x0 (one column cycle) */
869 target_write_u32(target, 0x200b8004, 0x0);
870
871 /* MLC_ADDR = row */
872 target_write_u32(target, 0x200b8004, page & 0xff);
873 target_write_u32(target, 0x200b8004, (page >> 8) & 0xff);
874
875 if (nand->address_cycles == 4)
876 target_write_u32(target, 0x200b8004, (page >> 16) & 0xff);
877 } else {
878 /* large page device
879 * MLC_ADDR = 0x0 (two column cycles) */
880 target_write_u32(target, 0x200b8004, 0x0);
881 target_write_u32(target, 0x200b8004, 0x0);
882
883 /* MLC_ADDR = row */
884 target_write_u32(target, 0x200b8004, page & 0xff);
885 target_write_u32(target, 0x200b8004, (page >> 8) & 0xff);
886
887 /* MLC_CMD = Read Start */
888 target_write_u32(target, 0x200b8000, NAND_CMD_READSTART);
889 }
890
891 while (page_bytes_done < (uint32_t)nand->page_size) {
892 /* MLC_ECC_AUTO_DEC_REG = dummy */
893 target_write_u32(target, 0x200b8014, 0xaa55aa55);
894
895 if (!lpc3180_controller_ready(nand, 1000)) {
896 LOG_ERROR("timeout while waiting for completion of auto decode cycle");
897 free(page_buffer);
898 free(oob_buffer);
899 return ERROR_NAND_OPERATION_FAILED;
900 }
901
902 target_read_u32(target, 0x200b8048, &mlc_isr);
903
904 if (mlc_isr & 0x8) {
905 if (mlc_isr & 0x40) {
906 LOG_ERROR("uncorrectable error detected: 0x%2.2x",
907 (unsigned)mlc_isr);
908 free(page_buffer);
909 free(oob_buffer);
910 return ERROR_NAND_OPERATION_FAILED;
911 }
912
913 LOG_WARNING("%i symbol error detected and corrected",
914 ((int)(((mlc_isr & 0x30) >> 4) + 1)));
915 }
916
917 if (data)
918 target_read_memory(target,
919 0x200a8000,
920 4,
921 128,
922 page_buffer + page_bytes_done);
923
924 if (oob)
925 target_read_memory(target,
926 0x200a8000,
927 4,
928 4,
929 oob_buffer + oob_bytes_done);
930
931 page_bytes_done += 512;
932 oob_bytes_done += 16;
933 }
934
935 if (data)
936 memcpy(data, page_buffer, data_size);
937
938 if (oob)
939 memcpy(oob, oob_buffer, oob_size);
940
941 free(page_buffer);
942 free(oob_buffer);
943 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
944
945 /**********************************************************************
946 * Read both SLC NAND flash page main area and spare area.
947 * Small page -
948 * ------------------------------------------
949 * | 512 bytes main | 16 bytes spare |
950 * ------------------------------------------
951 * Large page -
952 * ------------------------------------------
953 * | 2048 bytes main | 64 bytes spare |
954 * ------------------------------------------
955 * If DMA & ECC enabled, then the ECC generated for the 1st 256-byte
956 * data is compared with the 3rd word of the spare area. The ECC
957 * generated for the 2nd 256-byte data is compared with the 4th word
958 * of the spare area. The ECC generated for the 3rd 256-byte data is
959 * compared with the 7th word of the spare area. The ECC generated
960 * for the 4th 256-byte data is compared with the 8th word of the
961 * spare area and so on.
962 *
963 **********************************************************************/
964
965 int retval, i, target_mem_base;
966 uint8_t *ecc_hw_buffer;
967 uint8_t *ecc_flash_buffer;
968 struct working_area *pworking_area;
969
970 if (lpc3180_info->is_bulk) {
971
972 /* read always the data and also oob areas*/
973
974 retval = nand_page_command(nand, page, NAND_CMD_READ0, 0);
975 if (ERROR_OK != retval)
976 return retval;
977
978 /* allocate a working area */
979 if (target->working_area_size < (uint32_t) nand->page_size + 0x200) {
980 LOG_ERROR("Reserve at least 0x%x physical target working area",
981 nand->page_size + 0x200);
982 return ERROR_FLASH_OPERATION_FAILED;
983 }
984 if (target->working_area_phys%4) {
985 LOG_ERROR(
986 "Reserve the physical target working area at word boundary");
987 return ERROR_FLASH_OPERATION_FAILED;
988 }
989 if (target_alloc_working_area(target, target->working_area_size,
990 &pworking_area) != ERROR_OK) {
991 LOG_ERROR("no working area specified, can't read LPC internal flash");
992 return ERROR_FLASH_OPERATION_FAILED;
993 }
994 target_mem_base = target->working_area_phys;
995
996 if (nand->page_size == 2048)
997 page_buffer = malloc(2048);
998 else
999 page_buffer = malloc(512);
1000
1001 ecc_hw_buffer = malloc(32);
1002 ecc_flash_buffer = malloc(64);
1003
1004 /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst
1005 *enabled, DMA read from SLC, WIDTH = bus_width) */
1006 target_write_u32(target, 0x20020014, 0x3e);
1007
1008 /* set DMA LLI-s in target memory and in DMA*/
1009 for (i = 0; i < nand->page_size/0x100; i++) {
1010 int tmp;
1011 /* -------LLI for 256 byte block---------
1012 * DMACC0SrcAddr = SLC_DMA_DATA*/
1013 target_write_u32(target, target_mem_base+0+i*32, 0x20020038);
1014 if (i == 0)
1015 target_write_u32(target, 0x31000100, 0x20020038);
1016 /* DMACCxDestAddr = SRAM */
1017 target_write_u32(target,
1018 target_mem_base+4+i*32,
1019 target_mem_base+DATA_OFFS+i*256);
1020 if (i == 0)
1021 target_write_u32(target,
1022 0x31000104,
1023 target_mem_base+DATA_OFFS);
1024 /* DMACCxLLI = next element */
1025 tmp = (target_mem_base+(1+i*2)*16)&0xfffffffc;
1026 target_write_u32(target, target_mem_base+8+i*32, tmp);
1027 if (i == 0)
1028 target_write_u32(target, 0x31000108, tmp);
1029 /* DMACCxControl = TransferSize =64, Source burst size =16,
1030 * Destination burst size = 16, Source transfer width = 32 bit,
1031 * Destination transfer width = 32 bit, Source AHB master select = M0,
1032 * Destination AHB master select = M0, Source increment = 0,
1033 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1034 target_write_u32(target,
1035 target_mem_base+12+i*32,
1036 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1037 31);
1038 if (i == 0)
1039 target_write_u32(target,
1040 0x3100010c,
1041 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1042 31);
1043
1044 /* -------LLI for 3 byte ECC---------
1045 * DMACC0SrcAddr = SLC_ECC*/
1046 target_write_u32(target, target_mem_base+16+i*32, 0x20020034);
1047 /* DMACCxDestAddr = SRAM */
1048 target_write_u32(target,
1049 target_mem_base+20+i*32,
1050 target_mem_base+ECC_OFFS+i*4);
1051 /* DMACCxLLI = next element */
1052 tmp = (target_mem_base+(2+i*2)*16)&0xfffffffc;
1053 target_write_u32(target, target_mem_base+24+i*32, tmp);
1054 /* DMACCxControl = TransferSize =1, Source burst size =4,
1055 * Destination burst size = 4, Source transfer width = 32 bit,
1056 * Destination transfer width = 32 bit, Source AHB master select = M0,
1057 * Destination AHB master select = M0, Source increment = 0,
1058 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1059 target_write_u32(target,
1060 target_mem_base+28+i*32,
1061 0x01 | 1<<12 | 1<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1062 31);
1063 }
1064
1065 /* -------LLI for spare area---------
1066 * DMACC0SrcAddr = SLC_DMA_DATA*/
1067 target_write_u32(target, target_mem_base+0+i*32, 0x20020038);
1068 /* DMACCxDestAddr = SRAM */
1069 target_write_u32(target, target_mem_base+4+i*32, target_mem_base+SPARE_OFFS);
1070 /* DMACCxLLI = next element = NULL */
1071 target_write_u32(target, target_mem_base+8+i*32, 0);
1072 /* DMACCxControl = TransferSize =16 for large page or 4 for small page,
1073 * Source burst size =16, Destination burst size = 16, Source transfer width = 32 bit,
1074 * Destination transfer width = 32 bit, Source AHB master select = M0,
1075 * Destination AHB master select = M0, Source increment = 0,
1076 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1077 target_write_u32(target,
1078 target_mem_base + 12 + i * 32,
1079 (nand->page_size == 2048 ? 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 |
1080 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<31);
1081
1082 /* Enable DMA after channel set up !
1083 LLI only works when DMA is the flow controller!
1084 */
1085 /* DMACCxConfig= E=1, SrcPeripheral = 1 (SLC), DestPeripheral = 1 (SLC),
1086 *FlowCntrl = 2 (Pher-> Mem, DMA), IE = 0, ITC = 0, L= 0, H=0*/
1087 target_write_u32(target,
1088 0x31000110,
1089 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
1090
1091 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
1092 target_write_u32(target, 0x20020010, 0x3);
1093
1094 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
1095 target_write_u32(target, 0x20020028, 2);
1096
1097 /* SLC_TC */
1098 target_write_u32(target, 0x20020030,
1099 (nand->page_size == 2048 ? 0x840 : 0x210));
1100
1101 if (!lpc3180_tc_ready(nand, 1000)) {
1102 LOG_ERROR("timeout while waiting for completion of DMA");
1103 free(page_buffer);
1104 free(ecc_hw_buffer);
1105 free(ecc_flash_buffer);
1106 target_free_working_area(target, pworking_area);
1107 return ERROR_NAND_OPERATION_FAILED;
1108 }
1109
1110 if (data) {
1111 target_read_memory(target,
1112 target_mem_base+DATA_OFFS,
1113 4,
1114 nand->page_size == 2048 ? 512 : 128,
1115 page_buffer);
1116 memcpy(data, page_buffer, data_size);
1117
1118 LOG_INFO("Page = 0x%" PRIx32 " was read.", page);
1119
1120 /* check hw generated ECC for each 256 bytes block with the saved
1121 *ECC in flash spare area*/
1122 int idx = nand->page_size/0x200;
1123 target_read_memory(target,
1124 target_mem_base+SPARE_OFFS,
1125 4,
1126 16,
1127 ecc_flash_buffer);
1128 target_read_memory(target,
1129 target_mem_base+ECC_OFFS,
1130 4,
1131 8,
1132 ecc_hw_buffer);
1133 for (i = 0; i < idx; i++) {
1134 if ((0x00ffffff & *(uint32_t *)(void *)(ecc_hw_buffer+i*8)) !=
1135 (0x00ffffff & *(uint32_t *)(void *)(ecc_flash_buffer+8+i*16)))
1136 LOG_WARNING(
1137 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32,
1138 i * 2 + 1, page);
1139 if ((0x00ffffff & *(uint32_t *)(void *)(ecc_hw_buffer+4+i*8)) !=
1140 (0x00ffffff & *(uint32_t *)(void *)(ecc_flash_buffer+12+i*16)))
1141 LOG_WARNING(
1142 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32,
1143 i * 2 + 2, page);
1144 }
1145 }
1146
1147 if (oob)
1148 memcpy(oob, ecc_flash_buffer, oob_size);
1149
1150 free(page_buffer);
1151 free(ecc_hw_buffer);
1152 free(ecc_flash_buffer);
1153
1154 target_free_working_area(target, pworking_area);
1155
1156 } else
1157 return nand_read_page_raw(nand, page, data, data_size, oob, oob_size);
1158 }
1159
1160 return ERROR_OK;
1161 }
1162
1163 static int lpc3180_controller_ready(struct nand_device *nand, int timeout)
1164 {
1165 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
1166 struct target *target = nand->target;
1167
1168 if (target->state != TARGET_HALTED) {
1169 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1170 return ERROR_NAND_OPERATION_FAILED;
1171 }
1172
1173 LOG_DEBUG("lpc3180_controller_ready count start=%d", timeout);
1174
1175 do {
1176 if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
1177 uint8_t status;
1178
1179 /* Read MLC_ISR, wait for controller to become ready */
1180 target_read_u8(target, 0x200b8048, &status);
1181
1182 if (status & 2) {
1183 LOG_DEBUG("lpc3180_controller_ready count=%d",
1184 timeout);
1185 return 1;
1186 }
1187 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
1188 uint32_t status;
1189
1190 /* Read SLC_STAT and check READY bit */
1191 target_read_u32(target, 0x20020018, &status);
1192
1193 if (status & 1) {
1194 LOG_DEBUG("lpc3180_controller_ready count=%d",
1195 timeout);
1196 return 1;
1197 }
1198 }
1199
1200 alive_sleep(1);
1201 } while (timeout-- > 0);
1202
1203 return 0;
1204 }
1205
1206 static int lpc3180_nand_ready(struct nand_device *nand, int timeout)
1207 {
1208 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
1209 struct target *target = nand->target;
1210
1211 if (target->state != TARGET_HALTED) {
1212 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1213 return ERROR_NAND_OPERATION_FAILED;
1214 }
1215
1216 LOG_DEBUG("lpc3180_nand_ready count start=%d", timeout);
1217
1218 do {
1219 if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) {
1220 uint8_t status = 0x0;
1221
1222 /* Read MLC_ISR, wait for NAND flash device to become ready */
1223 target_read_u8(target, 0x200b8048, &status);
1224
1225 if (status & 1) {
1226 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1227 timeout);
1228 return 1;
1229 }
1230 } else if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
1231 uint32_t status = 0x0;
1232
1233 /* Read SLC_STAT and check READY bit */
1234 target_read_u32(target, 0x20020018, &status);
1235
1236 if (status & 1) {
1237 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1238 timeout);
1239 return 1;
1240 }
1241 }
1242
1243 alive_sleep(1);
1244 } while (timeout-- > 0);
1245
1246 return 0;
1247 }
1248
1249 static int lpc3180_tc_ready(struct nand_device *nand, int timeout)
1250 {
1251 struct lpc3180_nand_controller *lpc3180_info = nand->controller_priv;
1252 struct target *target = nand->target;
1253
1254 if (target->state != TARGET_HALTED) {
1255 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1256 return ERROR_NAND_OPERATION_FAILED;
1257 }
1258
1259 LOG_DEBUG("lpc3180_tc_ready count start=%d",
1260 timeout);
1261
1262 do {
1263 if (lpc3180_info->selected_controller == LPC3180_SLC_CONTROLLER) {
1264 uint32_t status = 0x0;
1265 /* Read SLC_INT_STAT and check INT_TC_STAT bit */
1266 target_read_u32(target, 0x2002001c, &status);
1267
1268 if (status & 2) {
1269 LOG_DEBUG("lpc3180_tc_ready count=%d",
1270 timeout);
1271 return 1;
1272 }
1273 }
1274
1275 alive_sleep(1);
1276 } while (timeout-- > 0);
1277
1278 return 0;
1279 }
1280
1281 COMMAND_HANDLER(handle_lpc3180_select_command)
1282 {
1283 struct lpc3180_nand_controller *lpc3180_info = NULL;
1284 char *selected[] = {
1285 "no", "mlc", "slc"
1286 };
1287
1288 if ((CMD_ARGC < 1) || (CMD_ARGC > 3))
1289 return ERROR_COMMAND_SYNTAX_ERROR;
1290
1291 unsigned num;
1292 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
1293 struct nand_device *nand = get_nand_device_by_num(num);
1294 if (!nand) {
1295 command_print(CMD_CTX, "nand device '#%s' is out of bounds", CMD_ARGV[0]);
1296 return ERROR_OK;
1297 }
1298
1299 lpc3180_info = nand->controller_priv;
1300
1301 if (CMD_ARGC >= 2) {
1302 if (strcmp(CMD_ARGV[1], "mlc") == 0)
1303 lpc3180_info->selected_controller = LPC3180_MLC_CONTROLLER;
1304 else if (strcmp(CMD_ARGV[1], "slc") == 0) {
1305 lpc3180_info->selected_controller = LPC3180_SLC_CONTROLLER;
1306 if (CMD_ARGC == 3 && strcmp(CMD_ARGV[2], "bulk") == 0)
1307 lpc3180_info->is_bulk = 1;
1308 else
1309 lpc3180_info->is_bulk = 0;
1310 } else
1311 return ERROR_COMMAND_SYNTAX_ERROR;
1312 }
1313
1314 if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER)
1315 command_print(CMD_CTX, "%s controller selected",
1316 selected[lpc3180_info->selected_controller]);
1317 else
1318 command_print(CMD_CTX,
1319 lpc3180_info->is_bulk ? "%s controller selected bulk mode is available" :
1320 "%s controller selected bulk mode is not available",
1321 selected[lpc3180_info->selected_controller]);
1322
1323 return ERROR_OK;
1324 }
1325
1326 static const struct command_registration lpc3180_exec_command_handlers[] = {
1327 {
1328 .name = "select",
1329 .handler = handle_lpc3180_select_command,
1330 .mode = COMMAND_EXEC,
1331 .help =
1332 "select MLC or SLC controller (default is MLC), SLC can be set to bulk mode",
1333 .usage = "bank_id ['mlc'|'slc' ['bulk'] ]",
1334 },
1335 COMMAND_REGISTRATION_DONE
1336 };
1337 static const struct command_registration lpc3180_command_handler[] = {
1338 {
1339 .name = "lpc3180",
1340 .mode = COMMAND_ANY,
1341 .help = "LPC3180 NAND flash controller commands",
1342 .usage = "",
1343 .chain = lpc3180_exec_command_handlers,
1344 },
1345 COMMAND_REGISTRATION_DONE
1346 };
1347
1348 struct nand_flash_controller lpc3180_nand_controller = {
1349 .name = "lpc3180",
1350 .commands = lpc3180_command_handler,
1351 .nand_device_command = lpc3180_nand_device_command,
1352 .init = lpc3180_init,
1353 .reset = lpc3180_reset,
1354 .command = lpc3180_command,
1355 .address = lpc3180_address,
1356 .write_data = lpc3180_write_data,
1357 .read_data = lpc3180_read_data,
1358 .write_page = lpc3180_write_page,
1359 .read_page = lpc3180_read_page,
1360 .nand_ready = lpc3180_nand_ready,
1361 };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)