1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2010 richard vegh <vegh.ricsi@gmail.com> *
6 * Copyright (C) 2010 Oyvind Harboe <oyvind.harboe@zylin.com> *
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. *
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. *
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 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
22 ***************************************************************************/
30 #include <target/target.h>
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
);
36 #define ECC_OFFS 0x120
37 #define SPARE_OFFS 0x140
38 #define DATA_OFFS 0x200
40 /* nand device lpc3180 <target#> <oscillator_frequency>
42 NAND_DEVICE_COMMAND_HANDLER(lpc3180_nand_device_command
)
45 return ERROR_COMMAND_SYNTAX_ERROR
;
48 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], osc_freq
);
50 struct lpc3180_nand_controller
*lpc3180_info
;
51 lpc3180_info
= malloc(sizeof(struct lpc3180_nand_controller
));
52 nand
->controller_priv
= lpc3180_info
;
54 lpc3180_info
->osc_freq
= osc_freq
;
56 if ((lpc3180_info
->osc_freq
< 1000) || (lpc3180_info
->osc_freq
> 20000))
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;
68 static int lpc3180_pll(int fclkin
, uint32_t pll_ctrl
)
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);
79 LOG_WARNING("PLL is not locked");
81 if (!bypass
&& direct
) /* direct mode */
82 return (m
* fclkin
) / n
;
84 if (bypass
&& !direct
) /* bypass mode */
85 return fclkin
/ (2 * p
);
87 if (bypass
& direct
) /* direct bypass mode */
90 if (feedback
) /* integer mode */
91 return m
* (fclkin
/ n
);
92 else /* non-integer mode */
93 return (m
/ (2 * p
)) * (fclkin
/ n
);
96 static float lpc3180_cycle_time(struct nand_device
*nand
)
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
;
106 /* calculate timings */
108 /* determine current SYSCLK (13'MHz or main oscillator) */
109 target_read_u32(target
, 0x40004050, &sysclk_ctrl
);
111 if ((sysclk_ctrl
& 1) == 0)
112 sysclk
= lpc3180_info
->osc_freq
;
116 /* determine selected HCLK source */
117 target_read_u32(target
, 0x40004044, &pwr_ctrl
);
119 if ((pwr_ctrl
& (1 << 2)) == 0) /* DIRECT RUN mode */
122 target_read_u32(target
, 0x40004058, &hclkpll_ctrl
);
123 hclk_pll
= lpc3180_pll(sysclk
, hclkpll_ctrl
);
125 target_read_u32(target
, 0x40004040, &hclkdiv_ctrl
);
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));
133 LOG_DEBUG("LPC3180 HCLK currently clocked at %i kHz", hclk
);
135 cycle
= (1.0 / hclk
) * 1000000.0;
140 static int lpc3180_init(struct nand_device
*nand
)
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;
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
;
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
;
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
163 LOG_WARNING("LPC3180 only supports 8 bit bus width");
165 /* inform calling code about selected bus width */
166 nand
->bus_width
= bus_width
;
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
;
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
;
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
;
184 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
185 uint32_t mlc_icr_value
= 0x0;
187 int twp
, twh
, trp
, treh
, trhz
, trbwb
, tcea
;
189 /* FLASHCLK_CTRL = 0x22 (enable clock for MLC flash controller) */
190 target_write_u32(target
, 0x400040c8, 0x22);
192 /* MLC_CEH = 0x0 (Force nCE assert) */
193 target_write_u32(target
, 0x200b804c, 0x0);
195 /* MLC_LOCK = 0xa25e (unlock protected registers) */
196 target_write_u32(target
, 0x200b8044, 0xa25e);
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;
206 mlc_icr_value
|= 0x1;
207 target_write_u32(target
, 0x200b8030, mlc_icr_value
);
209 /* calculate NAND controller timings */
210 cycle
= lpc3180_cycle_time(nand
);
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);
220 /* MLC_LOCK = 0xa25e (unlock protected registers) */
221 target_write_u32(target
, 0x200b8044, 0xa25e);
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));
229 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
231 int r_setup
, r_hold
, r_width
, r_rdy
;
232 int w_setup
, w_hold
, w_width
, w_rdy
;
234 /* FLASHCLK_CTRL = 0x05 (enable clock for SLC flash controller) */
235 target_write_u32(target
, 0x400040c8, 0x05);
237 /* after reset set other registers of SLC so reset calling is here at the begining*/
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);
244 /* SLC_IEN = 3 (INT_RDY_EN = 1) ,(INT_TC_STAT = 1) */
245 target_write_u32(target
, 0x20020020, 0x03);
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);
254 /* calculate NAND controller timings */
255 cycle
= lpc3180_cycle_time(nand
);
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
;
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));
273 static int lpc3180_reset(struct nand_device
*nand
)
275 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
276 struct target
*target
= nand
->target
;
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
;
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);
290 if (!lpc3180_controller_ready(nand
, 100)) {
291 LOG_ERROR("LPC3180 NAND controller timed out after reset");
292 return ERROR_NAND_OPERATION_TIMEOUT
;
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);
298 if (!lpc3180_controller_ready(nand
, 100)) {
299 LOG_ERROR("LPC3180 NAND controller timed out after reset");
300 return ERROR_NAND_OPERATION_TIMEOUT
;
307 static int lpc3180_command(struct nand_device
*nand
, uint8_t command
)
309 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
310 struct target
*target
= nand
->target
;
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
;
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
);
331 static int lpc3180_address(struct nand_device
*nand
, uint8_t address
)
333 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
334 struct target
*target
= nand
->target
;
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
;
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
);
355 static int lpc3180_write_data(struct nand_device
*nand
, uint16_t data
)
357 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
358 struct target
*target
= nand
->target
;
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
;
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
);
379 static int lpc3180_read_data(struct nand_device
*nand
, void *data
)
381 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
382 struct target
*target
= nand
->target
;
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
;
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
);
401 LOG_ERROR("BUG: bus_width neither 8 nor 16 bit");
402 return ERROR_NAND_OPERATION_FAILED
;
404 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
407 /* data = SLC_DATA, must use 32-bit access */
408 target_read_u32(target
, 0x20020000, &data32
);
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;
417 LOG_ERROR("BUG: bus_width neither 8 nor 16 bit");
418 return ERROR_NAND_OPERATION_FAILED
;
425 static int lpc3180_write_page(struct nand_device
*nand
,
432 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
433 struct target
*target
= nand
->target
;
436 uint8_t *page_buffer
;
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
;
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
) {
448 int quarter
, num_quarters
;
451 LOG_ERROR("LPC3180 MLC controller can't write OOB data only");
452 return ERROR_NAND_OPERATION_NOT_SUPPORTED
;
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
;
461 if (data_size
> (uint32_t)nand
->page_size
) {
462 LOG_ERROR("data size exceeds page size");
463 return ERROR_NAND_OPERATION_NOT_SUPPORTED
;
466 /* MLC_CMD = sequential input */
467 target_write_u32(target
, 0x200b8000, NAND_CMD_SEQIN
);
469 page_buffer
= malloc(512);
470 oob_buffer
= malloc(6);
472 if (nand
->page_size
== 512) {
473 /* MLC_ADDR = 0x0 (one column cycle) */
474 target_write_u32(target
, 0x200b8004, 0x0);
477 target_write_u32(target
, 0x200b8004, page
& 0xff);
478 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
480 if (nand
->address_cycles
== 4)
481 target_write_u32(target
, 0x200b8004, (page
>> 16) & 0xff);
483 /* MLC_ADDR = 0x0 (two column cycles) */
484 target_write_u32(target
, 0x200b8004, 0x0);
485 target_write_u32(target
, 0x200b8004, 0x0);
488 target_write_u32(target
, 0x200b8004, page
& 0xff);
489 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
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
495 num_quarters
= (nand
->page_size
== 2048) ? 4 : 1;
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
;
501 memset(page_buffer
, 0xff, 512);
503 memcpy(page_buffer
, data
, thisrun_data_size
);
504 data_size
-= thisrun_data_size
;
505 data
+= thisrun_data_size
;
508 memset(oob_buffer
, 0xff, 6);
510 memcpy(oob_buffer
, oob
, thisrun_oob_size
);
511 oob_size
-= thisrun_oob_size
;
512 oob
+= thisrun_oob_size
;
515 /* write MLC_ECC_ENC_REG to start encode cycle */
516 target_write_u32(target
, 0x200b8008, 0x0);
518 target_write_memory(target
, 0x200a8000,
519 4, 128, page_buffer
);
520 target_write_memory(target
, 0x200a8000,
523 /* write MLC_ECC_AUTO_ENC_REG to start auto encode */
524 target_write_u32(target
, 0x200b8010, 0x0);
526 if (!lpc3180_controller_ready(nand
, 1000)) {
527 LOG_ERROR("timeout while waiting for completion of auto encode cycle");
530 return ERROR_NAND_OPERATION_FAILED
;
534 /* MLC_CMD = auto program command */
535 target_write_u32(target
, 0x200b8000, NAND_CMD_PAGEPROG
);
537 retval
= nand_read_status(nand
, &status
);
538 if (retval
!= ERROR_OK
) {
539 LOG_ERROR("couldn't read status");
542 return ERROR_NAND_OPERATION_FAILED
;
545 if (status
& NAND_STATUS_FAIL
) {
546 LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status
);
549 return ERROR_NAND_OPERATION_FAILED
;
554 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
556 /**********************************************************************
557 * Write both SLC NAND flash page main area and spare area.
559 * ------------------------------------------
560 * | 512 bytes main | 16 bytes spare |
561 * ------------------------------------------
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.
574 **********************************************************************/
576 int i
= 0, target_mem_base
;
577 uint8_t *ecc_flash_buffer
;
578 struct working_area
*pworking_area
;
580 if (lpc3180_info
->is_bulk
) {
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
,
593 retval
= nand_page_command(nand
, page
, NAND_CMD_SEQIN
, !data
);
594 if (ERROR_OK
!= retval
)
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
;
603 if (target
->working_area_phys
%4) {
605 "Reserve the physical target working area at word boundary");
606 return ERROR_FLASH_OPERATION_FAILED
;
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
;
613 target_mem_base
= target
->working_area_phys
;
615 if (nand
->page_size
== 2048)
616 page_buffer
= malloc(2048);
618 page_buffer
= malloc(512);
620 ecc_flash_buffer
= malloc(64);
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);
627 /* set DMA LLI-s in target memory and in DMA*/
628 for (i
= 0; i
< nand
->page_size
/0x100; i
++) {
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);
637 target_write_u32(target
,
639 target_mem_base
+DATA_OFFS
);
640 /* DMACCxDestAddr = SLC_DMA_DATA */
641 target_write_u32(target
, target_mem_base
+4+i
*32, 0x20020038);
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
);
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 |
659 target_write_u32(target
,
661 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
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<<
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
,
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
,
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
,
711 2048 ? 512 : 128) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 |
712 1<<26 | 0<<27 | 0<<31);
714 } else if (!data
&& oob
)
717 /* -------LLI for spare area---------
718 * DMACC0SrcAddr = SRAM*/
719 target_write_u32(target
, target_mem_base
+0+i
*32, target_mem_base
+SPARE_OFFS
);
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);
725 target_write_u32(target
, 0x31000104, 0x20020038);
726 /* DMACCxLLI = next element = NULL */
727 target_write_u32(target
, target_mem_base
+8+i
*32, 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,
738 2048 ? 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
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);
746 memset(ecc_flash_buffer
, 0xff, 64);
748 memcpy(ecc_flash_buffer
, oob
, oob_size
);
749 target_write_memory(target
,
750 target_mem_base
+SPARE_OFFS
,
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
,
761 nand
->page_size
== 2048 ? 512 : 128,
766 free(ecc_flash_buffer
);
768 /* Enable DMA after channel set up !
769 LLI only works when DMA is the flow controller!
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
,
775 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
777 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
778 target_write_u32(target
, 0x20020010, 0x3);
780 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
781 target_write_u32(target
, 0x20020028, 2);
785 target_write_u32(target
, 0x20020030,
786 (nand
->page_size
== 2048 ? 0x10 : 0x04));
788 target_write_u32(target
, 0x20020030,
789 (nand
->page_size
== 2048 ? 0x840 : 0x210));
791 nand_write_finish(nand
);
793 if (!lpc3180_tc_ready(nand
, 1000)) {
794 LOG_ERROR("timeout while waiting for completion of DMA");
795 return ERROR_NAND_OPERATION_FAILED
;
798 target_free_working_area(target
, pworking_area
);
800 LOG_INFO("Page = 0x%" PRIx32
" was written.", page
);
803 return nand_write_page_raw(nand
, page
, data
, data_size
, oob
, oob_size
);
809 static int lpc3180_read_page(struct nand_device
*nand
,
816 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
817 struct target
*target
= nand
->target
;
818 uint8_t *page_buffer
;
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
;
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
) {
830 uint32_t page_bytes_done
= 0;
831 uint32_t oob_bytes_done
= 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
;
841 if (data_size
> (uint32_t)nand
->page_size
) {
842 LOG_ERROR("data size exceeds page size");
843 return ERROR_NAND_OPERATION_NOT_SUPPORTED
;
846 if (nand
->page_size
== 2048) {
847 page_buffer
= malloc(2048);
848 oob_buffer
= malloc(64);
850 page_buffer
= malloc(512);
851 oob_buffer
= malloc(16);
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
860 target_write_u32(target
, 0x200b8000, NAND_CMD_READOOB
);
862 /* MLC_CMD = Read0 */
863 target_write_u32(target
, 0x200b8000, NAND_CMD_READ0
);
866 if (nand
->page_size
== 512) {
868 * MLC_ADDR = 0x0 (one column cycle) */
869 target_write_u32(target
, 0x200b8004, 0x0);
872 target_write_u32(target
, 0x200b8004, page
& 0xff);
873 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
875 if (nand
->address_cycles
== 4)
876 target_write_u32(target
, 0x200b8004, (page
>> 16) & 0xff);
879 * MLC_ADDR = 0x0 (two column cycles) */
880 target_write_u32(target
, 0x200b8004, 0x0);
881 target_write_u32(target
, 0x200b8004, 0x0);
884 target_write_u32(target
, 0x200b8004, page
& 0xff);
885 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
887 /* MLC_CMD = Read Start */
888 target_write_u32(target
, 0x200b8000, NAND_CMD_READSTART
);
891 while (page_bytes_done
< (uint32_t)nand
->page_size
) {
892 /* MLC_ECC_AUTO_DEC_REG = dummy */
893 target_write_u32(target
, 0x200b8014, 0xaa55aa55);
895 if (!lpc3180_controller_ready(nand
, 1000)) {
896 LOG_ERROR("timeout while waiting for completion of auto decode cycle");
899 return ERROR_NAND_OPERATION_FAILED
;
902 target_read_u32(target
, 0x200b8048, &mlc_isr
);
905 if (mlc_isr
& 0x40) {
906 LOG_ERROR("uncorrectable error detected: 0x%2.2x",
910 return ERROR_NAND_OPERATION_FAILED
;
913 LOG_WARNING("%i symbol error detected and corrected",
914 ((int)(((mlc_isr
& 0x30) >> 4) + 1)));
918 target_read_memory(target
,
922 page_buffer
+ page_bytes_done
);
925 target_read_memory(target
,
929 oob_buffer
+ oob_bytes_done
);
931 page_bytes_done
+= 512;
932 oob_bytes_done
+= 16;
936 memcpy(data
, page_buffer
, data_size
);
939 memcpy(oob
, oob_buffer
, oob_size
);
943 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
945 /**********************************************************************
946 * Read both SLC NAND flash page main area and spare area.
948 * ------------------------------------------
949 * | 512 bytes main | 16 bytes spare |
950 * ------------------------------------------
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.
963 **********************************************************************/
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
;
970 if (lpc3180_info
->is_bulk
) {
972 /* read always the data and also oob areas*/
974 retval
= nand_page_command(nand
, page
, NAND_CMD_READ0
, 0);
975 if (ERROR_OK
!= retval
)
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
;
984 if (target
->working_area_phys
%4) {
986 "Reserve the physical target working area at word boundary");
987 return ERROR_FLASH_OPERATION_FAILED
;
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
;
994 target_mem_base
= target
->working_area_phys
;
996 if (nand
->page_size
== 2048)
997 page_buffer
= malloc(2048);
999 page_buffer
= malloc(512);
1001 ecc_hw_buffer
= malloc(32);
1002 ecc_flash_buffer
= malloc(64);
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);
1008 /* set DMA LLI-s in target memory and in DMA*/
1009 for (i
= 0; i
< nand
->page_size
/0x100; i
++) {
1011 /* -------LLI for 256 byte block---------
1012 * DMACC0SrcAddr = SLC_DMA_DATA*/
1013 target_write_u32(target
, target_mem_base
+0+i
*32, 0x20020038);
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);
1021 target_write_u32(target
,
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
);
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<<
1039 target_write_u32(target
,
1041 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
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<<
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);
1082 /* Enable DMA after channel set up !
1083 LLI only works when DMA is the flow controller!
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
,
1089 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
1091 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
1092 target_write_u32(target
, 0x20020010, 0x3);
1094 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
1095 target_write_u32(target
, 0x20020028, 2);
1098 target_write_u32(target
, 0x20020030,
1099 (nand
->page_size
== 2048 ? 0x840 : 0x210));
1101 if (!lpc3180_tc_ready(nand
, 1000)) {
1102 LOG_ERROR("timeout while waiting for completion of DMA");
1104 free(ecc_hw_buffer
);
1105 free(ecc_flash_buffer
);
1106 target_free_working_area(target
, pworking_area
);
1107 return ERROR_NAND_OPERATION_FAILED
;
1111 target_read_memory(target
,
1112 target_mem_base
+DATA_OFFS
,
1114 nand
->page_size
== 2048 ? 512 : 128,
1116 memcpy(data
, page_buffer
, data_size
);
1118 LOG_INFO("Page = 0x%" PRIx32
" was read.", page
);
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
,
1128 target_read_memory(target
,
1129 target_mem_base
+ECC_OFFS
,
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)))
1137 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32
,
1139 if ((0x00ffffff & *(uint32_t *)(void *)(ecc_hw_buffer
+4+i
*8)) !=
1140 (0x00ffffff & *(uint32_t *)(void *)(ecc_flash_buffer
+12+i
*16)))
1142 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32
,
1148 memcpy(oob
, ecc_flash_buffer
, oob_size
);
1151 free(ecc_hw_buffer
);
1152 free(ecc_flash_buffer
);
1154 target_free_working_area(target
, pworking_area
);
1157 return nand_read_page_raw(nand
, page
, data
, data_size
, oob
, oob_size
);
1163 static int lpc3180_controller_ready(struct nand_device
*nand
, int timeout
)
1165 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1166 struct target
*target
= nand
->target
;
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
;
1173 LOG_DEBUG("lpc3180_controller_ready count start=%d", timeout
);
1176 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
1179 /* Read MLC_ISR, wait for controller to become ready */
1180 target_read_u8(target
, 0x200b8048, &status
);
1183 LOG_DEBUG("lpc3180_controller_ready count=%d",
1187 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
1190 /* Read SLC_STAT and check READY bit */
1191 target_read_u32(target
, 0x20020018, &status
);
1194 LOG_DEBUG("lpc3180_controller_ready count=%d",
1201 } while (timeout
-- > 0);
1206 static int lpc3180_nand_ready(struct nand_device
*nand
, int timeout
)
1208 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1209 struct target
*target
= nand
->target
;
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
;
1216 LOG_DEBUG("lpc3180_nand_ready count start=%d", timeout
);
1219 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
1220 uint8_t status
= 0x0;
1222 /* Read MLC_ISR, wait for NAND flash device to become ready */
1223 target_read_u8(target
, 0x200b8048, &status
);
1226 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1230 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
1231 uint32_t status
= 0x0;
1233 /* Read SLC_STAT and check READY bit */
1234 target_read_u32(target
, 0x20020018, &status
);
1237 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1244 } while (timeout
-- > 0);
1249 static int lpc3180_tc_ready(struct nand_device
*nand
, int timeout
)
1251 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1252 struct target
*target
= nand
->target
;
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
;
1259 LOG_DEBUG("lpc3180_tc_ready count start=%d",
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
);
1269 LOG_DEBUG("lpc3180_tc_ready count=%d",
1276 } while (timeout
-- > 0);
1281 COMMAND_HANDLER(handle_lpc3180_select_command
)
1283 struct lpc3180_nand_controller
*lpc3180_info
= NULL
;
1284 char *selected
[] = {
1288 if ((CMD_ARGC
< 1) || (CMD_ARGC
> 3))
1289 return ERROR_COMMAND_SYNTAX_ERROR
;
1292 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], num
);
1293 struct nand_device
*nand
= get_nand_device_by_num(num
);
1295 command_print(CMD_CTX
, "nand device '#%s' is out of bounds", CMD_ARGV
[0]);
1299 lpc3180_info
= nand
->controller_priv
;
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;
1309 lpc3180_info
->is_bulk
= 0;
1311 return ERROR_COMMAND_SYNTAX_ERROR
;
1314 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
)
1315 command_print(CMD_CTX
, "%s controller selected",
1316 selected
[lpc3180_info
->selected_controller
]);
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
]);
1326 static const struct command_registration lpc3180_exec_command_handlers
[] = {
1329 .handler
= handle_lpc3180_select_command
,
1330 .mode
= COMMAND_EXEC
,
1332 "select MLC or SLC controller (default is MLC), SLC can be set to bulk mode",
1333 .usage
= "bank_id ['mlc'|'slc' ['bulk'] ]",
1335 COMMAND_REGISTRATION_DONE
1337 static const struct command_registration lpc3180_command_handler
[] = {
1340 .mode
= COMMAND_ANY
,
1341 .help
= "LPC3180 NAND flash controller commands",
1343 .chain
= lpc3180_exec_command_handlers
,
1345 COMMAND_REGISTRATION_DONE
1348 struct nand_flash_controller lpc3180_nand_controller
= {
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
,
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)