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 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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)) {
528 "timeout while waiting for completion of auto encode cycle");
529 return ERROR_NAND_OPERATION_FAILED
;
533 /* MLC_CMD = auto program command */
534 target_write_u32(target
, 0x200b8000, NAND_CMD_PAGEPROG
);
536 retval
= nand_read_status(nand
, &status
);
537 if (retval
!= ERROR_OK
) {
538 LOG_ERROR("couldn't read status");
539 return ERROR_NAND_OPERATION_FAILED
;
542 if (status
& NAND_STATUS_FAIL
) {
543 LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status
);
544 return ERROR_NAND_OPERATION_FAILED
;
549 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
551 /**********************************************************************
552 * Write both SLC NAND flash page main area and spare area.
554 * ------------------------------------------
555 * | 512 bytes main | 16 bytes spare |
556 * ------------------------------------------
558 * ------------------------------------------
559 * | 2048 bytes main | 64 bytes spare |
560 * ------------------------------------------
561 * If DMA & ECC enabled, then the ECC generated for the 1st 256-byte
562 * data is written to the 3rd word of the spare area. The ECC
563 * generated for the 2nd 256-byte data is written to the 4th word
564 * of the spare area. The ECC generated for the 3rd 256-byte data is
565 * written to the 7th word of the spare area. The ECC generated
566 * for the 4th 256-byte data is written to the 8th word of the
567 * spare area and so on.
569 **********************************************************************/
571 int i
= 0, target_mem_base
;
572 uint8_t *ecc_flash_buffer
;
573 struct working_area
*pworking_area
;
575 if (lpc3180_info
->is_bulk
) {
578 /*if oob only mode is active original method is used as SLC
579 *controller hangs during DMA interworking. Anyway the code supports
580 *the oob only mode below. */
581 return nand_write_page_raw(nand
,
588 retval
= nand_page_command(nand
, page
, NAND_CMD_SEQIN
, !data
);
589 if (ERROR_OK
!= retval
)
592 /* allocate a working area */
593 if (target
->working_area_size
< (uint32_t) nand
->page_size
+ 0x200) {
594 LOG_ERROR("Reserve at least 0x%x physical target working area",
595 nand
->page_size
+ 0x200);
596 return ERROR_FLASH_OPERATION_FAILED
;
598 if (target
->working_area_phys
%4) {
600 "Reserve the physical target working area at word boundary");
601 return ERROR_FLASH_OPERATION_FAILED
;
603 if (target_alloc_working_area(target
, target
->working_area_size
,
604 &pworking_area
) != ERROR_OK
) {
605 LOG_ERROR("no working area specified, can't read LPC internal flash");
606 return ERROR_FLASH_OPERATION_FAILED
;
608 target_mem_base
= target
->working_area_phys
;
610 if (nand
->page_size
== 2048)
611 page_buffer
= malloc(2048);
613 page_buffer
= malloc(512);
615 ecc_flash_buffer
= malloc(64);
617 /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst
618 *enabled, DMA write to SLC, WIDTH = bus_width) */
619 target_write_u32(target
, 0x20020014, 0x3c);
622 /* set DMA LLI-s in target memory and in DMA*/
623 for (i
= 0; i
< nand
->page_size
/0x100; i
++) {
626 /* -------LLI for 256 byte block---------
627 * DMACC0SrcAddr = SRAM */
628 target_write_u32(target
,
629 target_mem_base
+0+i
*32,
630 target_mem_base
+DATA_OFFS
+i
*256);
632 target_write_u32(target
,
634 target_mem_base
+DATA_OFFS
);
635 /* DMACCxDestAddr = SLC_DMA_DATA */
636 target_write_u32(target
, target_mem_base
+4+i
*32, 0x20020038);
638 target_write_u32(target
, 0x31000104, 0x20020038);
639 /* DMACCxLLI = next element */
640 tmp
= (target_mem_base
+(1+i
*2)*16)&0xfffffffc;
641 target_write_u32(target
, target_mem_base
+8+i
*32, tmp
);
643 target_write_u32(target
, 0x31000108, tmp
);
644 /* DMACCxControl = TransferSize =64, Source burst size =16,
645 * Destination burst size = 16, Source transfer width = 32 bit,
646 * Destination transfer width = 32 bit, Source AHB master select = M0,
647 * Destination AHB master select = M0, Source increment = 1,
648 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
649 target_write_u32(target
,
650 target_mem_base
+12+i
*32,
651 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
654 target_write_u32(target
,
656 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
659 /* -------LLI for 3 byte ECC---------
660 * DMACC0SrcAddr = SLC_ECC*/
661 target_write_u32(target
, target_mem_base
+16+i
*32, 0x20020034);
662 /* DMACCxDestAddr = SRAM */
663 target_write_u32(target
,
664 target_mem_base
+20+i
*32,
665 target_mem_base
+SPARE_OFFS
+8+16*(i
>>1)+(i
%2)*4);
666 /* DMACCxLLI = next element */
667 tmp
= (target_mem_base
+(2+i
*2)*16)&0xfffffffc;
668 target_write_u32(target
, target_mem_base
+24+i
*32, tmp
);
669 /* DMACCxControl = TransferSize =1, Source burst size =4,
670 * Destination burst size = 4, Source transfer width = 32 bit,
671 * Destination transfer width = 32 bit, Source AHB master select = M0,
672 * Destination AHB master select = M0, Source increment = 0,
673 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
674 target_write_u32(target
,
675 target_mem_base
+28+i
*32,
676 0x01 | 1<<12 | 1<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
679 } else if (data
&& oob
) {
680 /* -------LLI for 512 or 2048 bytes page---------
681 * DMACC0SrcAddr = SRAM */
682 target_write_u32(target
, target_mem_base
, target_mem_base
+DATA_OFFS
);
683 target_write_u32(target
, 0x31000100, target_mem_base
+DATA_OFFS
);
684 /* DMACCxDestAddr = SLC_DMA_DATA */
685 target_write_u32(target
, target_mem_base
+4, 0x20020038);
686 target_write_u32(target
, 0x31000104, 0x20020038);
687 /* DMACCxLLI = next element */
688 target_write_u32(target
,
690 (target_mem_base
+32)&0xfffffffc);
691 target_write_u32(target
, 0x31000108,
692 (target_mem_base
+32)&0xfffffffc);
693 /* DMACCxControl = TransferSize =512 or 128, Source burst size =16,
694 * Destination burst size = 16, Source transfer width = 32 bit,
695 * Destination transfer width = 32 bit, Source AHB master select = M0,
696 * Destination AHB master select = M0, Source increment = 1,
697 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
698 target_write_u32(target
,
701 2048 ? 512 : 128) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 |
702 1<<26 | 0<<27 | 0<<31);
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);
709 } else if (!data
&& oob
)
712 /* -------LLI for spare area---------
713 * DMACC0SrcAddr = SRAM*/
714 target_write_u32(target
, target_mem_base
+0+i
*32, target_mem_base
+SPARE_OFFS
);
716 target_write_u32(target
, 0x31000100, target_mem_base
+SPARE_OFFS
);
717 /* DMACCxDestAddr = SLC_DMA_DATA */
718 target_write_u32(target
, target_mem_base
+4+i
*32, 0x20020038);
720 target_write_u32(target
, 0x31000104, 0x20020038);
721 /* DMACCxLLI = next element = NULL */
722 target_write_u32(target
, target_mem_base
+8+i
*32, 0);
724 target_write_u32(target
, 0x31000108, 0);
725 /* DMACCxControl = TransferSize =16 for large page or 4 for small page,
726 * Source burst size =16, Destination burst size = 16, Source transfer width = 32 bit,
727 * Destination transfer width = 32 bit, Source AHB master select = M0,
728 * Destination AHB master select = M0, Source increment = 1,
729 * Destination increment = 0, Terminal count interrupt enable bit = 0*/
730 target_write_u32(target
,
731 target_mem_base
+12+i
*32,
733 2048 ? 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 1<<26 |
736 target_write_u32(target
, 0x3100010c,
737 (nand
->page_size
== 2048 ?
738 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 |
739 0<<25 | 1<<26 | 0<<27 | 0<<31);
741 memset(ecc_flash_buffer
, 0xff, 64);
743 memcpy(ecc_flash_buffer
, oob
, oob_size
);
744 target_write_memory(target
,
745 target_mem_base
+SPARE_OFFS
,
751 memset(page_buffer
, 0xff, nand
->page_size
== 2048 ? 2048 : 512);
752 memcpy(page_buffer
, data
, data_size
);
753 target_write_memory(target
,
754 target_mem_base
+DATA_OFFS
,
756 nand
->page_size
== 2048 ? 512 : 128,
761 free(ecc_flash_buffer
);
763 /* Enable DMA after channel set up !
764 LLI only works when DMA is the flow controller!
766 /* DMACCxConfig= E=1, SrcPeripheral = 1 (SLC), DestPeripheral = 1 (SLC),
767 *FlowCntrl = 2 (Pher -> Mem, DMA), IE = 0, ITC = 0, L= 0, H=0*/
768 target_write_u32(target
,
770 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
772 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
773 target_write_u32(target
, 0x20020010, 0x3);
775 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
776 target_write_u32(target
, 0x20020028, 2);
780 target_write_u32(target
, 0x20020030,
781 (nand
->page_size
== 2048 ? 0x10 : 0x04));
783 target_write_u32(target
, 0x20020030,
784 (nand
->page_size
== 2048 ? 0x840 : 0x210));
786 nand_write_finish(nand
);
788 if (!lpc3180_tc_ready(nand
, 1000)) {
789 LOG_ERROR("timeout while waiting for completion of DMA");
790 return ERROR_NAND_OPERATION_FAILED
;
793 target_free_working_area(target
, pworking_area
);
795 LOG_INFO("Page = 0x%" PRIx32
" was written.", page
);
798 return nand_write_page_raw(nand
, page
, data
, data_size
, oob
, oob_size
);
804 static int lpc3180_read_page(struct nand_device
*nand
,
811 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
812 struct target
*target
= nand
->target
;
813 uint8_t *page_buffer
;
815 if (target
->state
!= TARGET_HALTED
) {
816 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
817 return ERROR_NAND_OPERATION_FAILED
;
820 if (lpc3180_info
->selected_controller
== LPC3180_NO_CONTROLLER
) {
821 LOG_ERROR("BUG: no LPC3180 NAND flash controller selected");
822 return ERROR_NAND_OPERATION_FAILED
;
823 } else if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
825 uint32_t page_bytes_done
= 0;
826 uint32_t oob_bytes_done
= 0;
830 if (oob
&& (oob_size
> 6)) {
831 LOG_ERROR("LPC3180 MLC controller can't read more than 6 bytes of OOB data");
832 return ERROR_NAND_OPERATION_NOT_SUPPORTED
;
836 if (data_size
> (uint32_t)nand
->page_size
) {
837 LOG_ERROR("data size exceeds page size");
838 return ERROR_NAND_OPERATION_NOT_SUPPORTED
;
841 if (nand
->page_size
== 2048) {
842 page_buffer
= malloc(2048);
843 oob_buffer
= malloc(64);
845 page_buffer
= malloc(512);
846 oob_buffer
= malloc(16);
850 /* MLC_CMD = Read OOB
851 * we can use the READOOB command on both small and large page devices,
852 * as the controller translates the 0x50 command to a 0x0 with appropriate
853 * positioning of the serial buffer read pointer
855 target_write_u32(target
, 0x200b8000, NAND_CMD_READOOB
);
857 /* MLC_CMD = Read0 */
858 target_write_u32(target
, 0x200b8000, NAND_CMD_READ0
);
861 if (nand
->page_size
== 512) {
863 * MLC_ADDR = 0x0 (one column cycle) */
864 target_write_u32(target
, 0x200b8004, 0x0);
867 target_write_u32(target
, 0x200b8004, page
& 0xff);
868 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
870 if (nand
->address_cycles
== 4)
871 target_write_u32(target
, 0x200b8004, (page
>> 16) & 0xff);
874 * MLC_ADDR = 0x0 (two column cycles) */
875 target_write_u32(target
, 0x200b8004, 0x0);
876 target_write_u32(target
, 0x200b8004, 0x0);
879 target_write_u32(target
, 0x200b8004, page
& 0xff);
880 target_write_u32(target
, 0x200b8004, (page
>> 8) & 0xff);
882 /* MLC_CMD = Read Start */
883 target_write_u32(target
, 0x200b8000, NAND_CMD_READSTART
);
886 while (page_bytes_done
< (uint32_t)nand
->page_size
) {
887 /* MLC_ECC_AUTO_DEC_REG = dummy */
888 target_write_u32(target
, 0x200b8014, 0xaa55aa55);
890 if (!lpc3180_controller_ready(nand
, 1000)) {
892 "timeout while waiting for completion of auto decode cycle");
893 return ERROR_NAND_OPERATION_FAILED
;
896 target_read_u32(target
, 0x200b8048, &mlc_isr
);
899 if (mlc_isr
& 0x40) {
900 LOG_ERROR("uncorrectable error detected: 0x%2.2x",
902 return ERROR_NAND_OPERATION_FAILED
;
905 LOG_WARNING("%i symbol error detected and corrected",
906 ((int)(((mlc_isr
& 0x30) >> 4) + 1)));
910 target_read_memory(target
,
914 page_buffer
+ page_bytes_done
);
917 target_read_memory(target
,
921 oob_buffer
+ oob_bytes_done
);
923 page_bytes_done
+= 512;
924 oob_bytes_done
+= 16;
928 memcpy(data
, page_buffer
, data_size
);
931 memcpy(oob
, oob_buffer
, oob_size
);
935 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
937 /**********************************************************************
938 * Read both SLC NAND flash page main area and spare area.
940 * ------------------------------------------
941 * | 512 bytes main | 16 bytes spare |
942 * ------------------------------------------
944 * ------------------------------------------
945 * | 2048 bytes main | 64 bytes spare |
946 * ------------------------------------------
947 * If DMA & ECC enabled, then the ECC generated for the 1st 256-byte
948 * data is compared with the 3rd word of the spare area. The ECC
949 * generated for the 2nd 256-byte data is compared with the 4th word
950 * of the spare area. The ECC generated for the 3rd 256-byte data is
951 * compared with the 7th word of the spare area. The ECC generated
952 * for the 4th 256-byte data is compared with the 8th word of the
953 * spare area and so on.
955 **********************************************************************/
957 int retval
, i
, target_mem_base
;
958 uint8_t *ecc_hw_buffer
;
959 uint8_t *ecc_flash_buffer
;
960 struct working_area
*pworking_area
;
962 if (lpc3180_info
->is_bulk
) {
964 /* read always the data and also oob areas*/
966 retval
= nand_page_command(nand
, page
, NAND_CMD_READ0
, 0);
967 if (ERROR_OK
!= retval
)
970 /* allocate a working area */
971 if (target
->working_area_size
< (uint32_t) nand
->page_size
+ 0x200) {
972 LOG_ERROR("Reserve at least 0x%x physical target working area",
973 nand
->page_size
+ 0x200);
974 return ERROR_FLASH_OPERATION_FAILED
;
976 if (target
->working_area_phys
%4) {
978 "Reserve the physical target working area at word boundary");
979 return ERROR_FLASH_OPERATION_FAILED
;
981 if (target_alloc_working_area(target
, target
->working_area_size
,
982 &pworking_area
) != ERROR_OK
) {
983 LOG_ERROR("no working area specified, can't read LPC internal flash");
984 return ERROR_FLASH_OPERATION_FAILED
;
986 target_mem_base
= target
->working_area_phys
;
988 if (nand
->page_size
== 2048)
989 page_buffer
= malloc(2048);
991 page_buffer
= malloc(512);
993 ecc_hw_buffer
= malloc(32);
994 ecc_flash_buffer
= malloc(64);
996 /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst
997 *enabled, DMA read from SLC, WIDTH = bus_width) */
998 target_write_u32(target
, 0x20020014, 0x3e);
1000 /* set DMA LLI-s in target memory and in DMA*/
1001 for (i
= 0; i
< nand
->page_size
/0x100; i
++) {
1003 /* -------LLI for 256 byte block---------
1004 * DMACC0SrcAddr = SLC_DMA_DATA*/
1005 target_write_u32(target
, target_mem_base
+0+i
*32, 0x20020038);
1007 target_write_u32(target
, 0x31000100, 0x20020038);
1008 /* DMACCxDestAddr = SRAM */
1009 target_write_u32(target
,
1010 target_mem_base
+4+i
*32,
1011 target_mem_base
+DATA_OFFS
+i
*256);
1013 target_write_u32(target
,
1015 target_mem_base
+DATA_OFFS
);
1016 /* DMACCxLLI = next element */
1017 tmp
= (target_mem_base
+(1+i
*2)*16)&0xfffffffc;
1018 target_write_u32(target
, target_mem_base
+8+i
*32, tmp
);
1020 target_write_u32(target
, 0x31000108, tmp
);
1021 /* DMACCxControl = TransferSize =64, Source burst size =16,
1022 * Destination burst size = 16, Source transfer width = 32 bit,
1023 * Destination transfer width = 32 bit, Source AHB master select = M0,
1024 * Destination AHB master select = M0, Source increment = 0,
1025 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1026 target_write_u32(target
,
1027 target_mem_base
+12+i
*32,
1028 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1031 target_write_u32(target
,
1033 0x40 | 3<<12 | 3<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1036 /* -------LLI for 3 byte ECC---------
1037 * DMACC0SrcAddr = SLC_ECC*/
1038 target_write_u32(target
, target_mem_base
+16+i
*32, 0x20020034);
1039 /* DMACCxDestAddr = SRAM */
1040 target_write_u32(target
,
1041 target_mem_base
+20+i
*32,
1042 target_mem_base
+ECC_OFFS
+i
*4);
1043 /* DMACCxLLI = next element */
1044 tmp
= (target_mem_base
+(2+i
*2)*16)&0xfffffffc;
1045 target_write_u32(target
, target_mem_base
+24+i
*32, tmp
);
1046 /* DMACCxControl = TransferSize =1, Source burst size =4,
1047 * Destination burst size = 4, Source transfer width = 32 bit,
1048 * Destination transfer width = 32 bit, Source AHB master select = M0,
1049 * Destination AHB master select = M0, Source increment = 0,
1050 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1051 target_write_u32(target
,
1052 target_mem_base
+28+i
*32,
1053 0x01 | 1<<12 | 1<<15 | 2<<18 | 2<<21 | 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<
1057 /* -------LLI for spare area---------
1058 * DMACC0SrcAddr = SLC_DMA_DATA*/
1059 target_write_u32(target
, target_mem_base
+0+i
*32, 0x20020038);
1060 /* DMACCxDestAddr = SRAM */
1061 target_write_u32(target
, target_mem_base
+4+i
*32, target_mem_base
+SPARE_OFFS
);
1062 /* DMACCxLLI = next element = NULL */
1063 target_write_u32(target
, target_mem_base
+8+i
*32, 0);
1064 /* DMACCxControl = TransferSize =16 for large page or 4 for small page,
1065 * Source burst size =16, Destination burst size = 16, Source transfer width = 32 bit,
1066 * Destination transfer width = 32 bit, Source AHB master select = M0,
1067 * Destination AHB master select = M0, Source increment = 0,
1068 * Destination increment = 1, Terminal count interrupt enable bit = 0*/
1069 target_write_u32(target
,
1070 target_mem_base
+ 12 + i
* 32,
1071 (nand
->page_size
== 2048 ? 0x10 : 0x04) | 3<<12 | 3<<15 | 2<<18 | 2<<21 |
1072 0<<24 | 0<<25 | 0<<26 | 1<<27 | 0<<31);
1074 /* Enable DMA after channel set up !
1075 LLI only works when DMA is the flow controller!
1077 /* DMACCxConfig= E=1, SrcPeripheral = 1 (SLC), DestPeripheral = 1 (SLC),
1078 *FlowCntrl = 2 (Pher-> Mem, DMA), IE = 0, ITC = 0, L= 0, H=0*/
1079 target_write_u32(target
,
1081 1 | 1<<1 | 1<<6 | 2<<11 | 0<<14 | 0<<15 | 0<<16 | 0<<18);
1083 /* SLC_CTRL = 3 (START DMA), ECC_CLEAR */
1084 target_write_u32(target
, 0x20020010, 0x3);
1086 /* SLC_ICR = 2, INT_TC_CLR, clear pending TC*/
1087 target_write_u32(target
, 0x20020028, 2);
1090 target_write_u32(target
, 0x20020030,
1091 (nand
->page_size
== 2048 ? 0x840 : 0x210));
1093 if (!lpc3180_tc_ready(nand
, 1000)) {
1094 LOG_ERROR("timeout while waiting for completion of DMA");
1096 free(ecc_hw_buffer
);
1097 free(ecc_flash_buffer
);
1098 target_free_working_area(target
, pworking_area
);
1099 return ERROR_NAND_OPERATION_FAILED
;
1103 target_read_memory(target
,
1104 target_mem_base
+DATA_OFFS
,
1106 nand
->page_size
== 2048 ? 512 : 128,
1108 memcpy(data
, page_buffer
, data_size
);
1110 LOG_INFO("Page = 0x%" PRIx32
" was read.", page
);
1112 /* check hw generated ECC for each 256 bytes block with the saved
1113 *ECC in flash spare area*/
1114 int idx
= nand
->page_size
/0x200;
1115 target_read_memory(target
,
1116 target_mem_base
+SPARE_OFFS
,
1120 target_read_memory(target
,
1121 target_mem_base
+ECC_OFFS
,
1125 for (i
= 0; i
< idx
; i
++) {
1126 if ((0x00ffffff & *(uint32_t *)(void *)(ecc_hw_buffer
+i
*8)) !=
1127 (0x00ffffff & *(uint32_t *)(void *)(ecc_flash_buffer
+8+i
*16)))
1129 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32
,
1131 if ((0x00ffffff & *(uint32_t *)(void *)(ecc_hw_buffer
+4+i
*8)) !=
1132 (0x00ffffff & *(uint32_t *)(void *)(ecc_flash_buffer
+12+i
*16)))
1134 "ECC mismatch at 256 bytes size block= %d at page= 0x%" PRIx32
,
1140 memcpy(oob
, ecc_flash_buffer
, oob_size
);
1143 free(ecc_hw_buffer
);
1144 free(ecc_flash_buffer
);
1146 target_free_working_area(target
, pworking_area
);
1149 return nand_read_page_raw(nand
, page
, data
, data_size
, oob
, oob_size
);
1155 static int lpc3180_controller_ready(struct nand_device
*nand
, int timeout
)
1157 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1158 struct target
*target
= nand
->target
;
1160 if (target
->state
!= TARGET_HALTED
) {
1161 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1162 return ERROR_NAND_OPERATION_FAILED
;
1165 LOG_DEBUG("lpc3180_controller_ready count start=%d", timeout
);
1168 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
1171 /* Read MLC_ISR, wait for controller to become ready */
1172 target_read_u8(target
, 0x200b8048, &status
);
1175 LOG_DEBUG("lpc3180_controller_ready count=%d",
1179 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
1182 /* Read SLC_STAT and check READY bit */
1183 target_read_u32(target
, 0x20020018, &status
);
1186 LOG_DEBUG("lpc3180_controller_ready count=%d",
1193 } while (timeout
-- > 0);
1198 static int lpc3180_nand_ready(struct nand_device
*nand
, int timeout
)
1200 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1201 struct target
*target
= nand
->target
;
1203 if (target
->state
!= TARGET_HALTED
) {
1204 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1205 return ERROR_NAND_OPERATION_FAILED
;
1208 LOG_DEBUG("lpc3180_nand_ready count start=%d", timeout
);
1211 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
) {
1212 uint8_t status
= 0x0;
1214 /* Read MLC_ISR, wait for NAND flash device to become ready */
1215 target_read_u8(target
, 0x200b8048, &status
);
1218 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1222 } else if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
1223 uint32_t status
= 0x0;
1225 /* Read SLC_STAT and check READY bit */
1226 target_read_u32(target
, 0x20020018, &status
);
1229 LOG_DEBUG("lpc3180_nand_ready count end=%d",
1236 } while (timeout
-- > 0);
1241 static int lpc3180_tc_ready(struct nand_device
*nand
, int timeout
)
1243 struct lpc3180_nand_controller
*lpc3180_info
= nand
->controller_priv
;
1244 struct target
*target
= nand
->target
;
1246 if (target
->state
!= TARGET_HALTED
) {
1247 LOG_ERROR("target must be halted to use LPC3180 NAND flash controller");
1248 return ERROR_NAND_OPERATION_FAILED
;
1251 LOG_DEBUG("lpc3180_tc_ready count start=%d",
1255 if (lpc3180_info
->selected_controller
== LPC3180_SLC_CONTROLLER
) {
1256 uint32_t status
= 0x0;
1257 /* Read SLC_INT_STAT and check INT_TC_STAT bit */
1258 target_read_u32(target
, 0x2002001c, &status
);
1261 LOG_DEBUG("lpc3180_tc_ready count=%d",
1268 } while (timeout
-- > 0);
1273 COMMAND_HANDLER(handle_lpc3180_select_command
)
1275 struct lpc3180_nand_controller
*lpc3180_info
= NULL
;
1276 char *selected
[] = {
1280 if ((CMD_ARGC
< 1) || (CMD_ARGC
> 3))
1281 return ERROR_COMMAND_SYNTAX_ERROR
;
1284 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], num
);
1285 struct nand_device
*nand
= get_nand_device_by_num(num
);
1287 command_print(CMD_CTX
, "nand device '#%s' is out of bounds", CMD_ARGV
[0]);
1291 lpc3180_info
= nand
->controller_priv
;
1293 if (CMD_ARGC
>= 2) {
1294 if (strcmp(CMD_ARGV
[1], "mlc") == 0)
1295 lpc3180_info
->selected_controller
= LPC3180_MLC_CONTROLLER
;
1296 else if (strcmp(CMD_ARGV
[1], "slc") == 0) {
1297 lpc3180_info
->selected_controller
= LPC3180_SLC_CONTROLLER
;
1298 if (CMD_ARGC
== 3 && strcmp(CMD_ARGV
[2], "bulk") == 0)
1299 lpc3180_info
->is_bulk
= 1;
1301 lpc3180_info
->is_bulk
= 0;
1303 return ERROR_COMMAND_SYNTAX_ERROR
;
1306 if (lpc3180_info
->selected_controller
== LPC3180_MLC_CONTROLLER
)
1307 command_print(CMD_CTX
, "%s controller selected",
1308 selected
[lpc3180_info
->selected_controller
]);
1310 command_print(CMD_CTX
,
1311 lpc3180_info
->is_bulk
? "%s controller selected bulk mode is available" :
1312 "%s controller selected bulk mode is not available",
1313 selected
[lpc3180_info
->selected_controller
]);
1318 static const struct command_registration lpc3180_exec_command_handlers
[] = {
1321 .handler
= handle_lpc3180_select_command
,
1322 .mode
= COMMAND_EXEC
,
1324 "select MLC or SLC controller (default is MLC), SLC can be set to bulk mode",
1325 .usage
= "bank_id ['mlc'|'slc' ['bulk'] ]",
1327 COMMAND_REGISTRATION_DONE
1329 static const struct command_registration lpc3180_command_handler
[] = {
1332 .mode
= COMMAND_ANY
,
1333 .help
= "LPC3180 NAND flash controller commands",
1335 .chain
= lpc3180_exec_command_handlers
,
1337 COMMAND_REGISTRATION_DONE
1340 struct nand_flash_controller lpc3180_nand_controller
= {
1342 .commands
= lpc3180_command_handler
,
1343 .nand_device_command
= lpc3180_nand_device_command
,
1344 .init
= lpc3180_init
,
1345 .reset
= lpc3180_reset
,
1346 .command
= lpc3180_command
,
1347 .address
= lpc3180_address
,
1348 .write_data
= lpc3180_write_data
,
1349 .read_data
= lpc3180_read_data
,
1350 .write_page
= lpc3180_write_page
,
1351 .read_page
= lpc3180_read_page
,
1352 .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)