1 /*
2 * Copyright (c) 2016-2020, Texas Instruments Incorporated
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
34 /**
35 *
36 * \file board_flash.c
37 *
38 * \brief This contains board flash common APIs.
39 *
40 ******************************************************************************/
42 #include "board_cfg.h"
43 #include "board_flash.h"
45 /* This structure holds information about the flash devices on the board */
46 Board_FlashInfo Board_flashInfo[MAX_BOARD_FLASH_INSTANCE_NUM] =
47 {
48 {0, },
49 };
51 static uint32_t Board_getFlashIntf(uint32_t deviceId)
52 {
53 uint32_t flashIntf = 0;
55 if((deviceId == BOARD_FLASH_ID_NORN25Q128) || \
56 (deviceId == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
57 (deviceId == BOARD_FLASH_ID_W25X32VSFIG))
58 {
59 flashIntf = BOARD_FLASH_NOR_SPI;
60 }
61 else if((deviceId == BOARD_FLASH_ID_MT25QU512ABB) || \
62 (deviceId == BOARD_FLASH_ID_S25FL512S) || \
63 (deviceId == BOARD_FLASH_ID_S25FL256S) ||
64 (deviceId == BOARD_FLASH_ID_GD25B16CSAG) ||
65 (deviceId == BOARD_FLASH_ID_GD25B64CW2G) ||
66 (deviceId == BOARD_FLASH_ID_W25Q16FWSF) ||
67 (deviceId == BOARD_FLASH_ID_MX25V1635F))
68 {
69 flashIntf = BOARD_FLASH_NOR_QSPI;
70 }
71 else if(deviceId == BOARD_FLASH_ID_MT29W160EB)
72 {
73 flashIntf = BOARD_FLASH_NOR_GPMC;
74 }
75 else if(deviceId == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
76 {
77 flashIntf = BOARD_FLASH_NAND_GPMC;
78 }
79 else if((deviceId == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
80 (deviceId == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
81 (deviceId == BOARD_FLASH_ID_S28HS512T))
82 {
83 flashIntf = BOARD_FLASH_NOR_OSPI;
84 }
85 else if(BOARD_FLASH_ID_S71KS512S)
86 {
87 flashIntf = BOARD_FLASH_NOR_HPF;
88 }
89 else
90 {
91 /* Unknown flash type */
92 flashIntf = BOARD_FLASH_NOR_INTF_MAX;
93 }
95 return (flashIntf);
96 }
97 /******************************************************************************
98 * BOARD_flashOpen
99 ******************************************************************************/
100 Board_flashHandle Board_flashOpen(uint32_t deviceId, uint32_t portNum, void *params)
101 {
102 uint32_t count;
103 Board_FlashInfo *flashInfo;
104 uint32_t flashIntf;
106 for (count = 0; count < MAX_BOARD_FLASH_INSTANCE_NUM; count++)
107 {
108 if (Board_flashInfo[count].flashHandle == 0)
109 {
110 flashInfo = &Board_flashInfo[count];
111 break;
112 }
113 }
115 if (count == MAX_BOARD_FLASH_INSTANCE_NUM)
116 {
117 return (0U);
118 }
120 flashIntf = Board_getFlashIntf(deviceId);
122 #if defined (BOARD_NOR_FLASH_IN)
123 NOR_HANDLE flashHandle;
124 NOR_Info *norInfo;
126 if ( \
127 (deviceId == BOARD_FLASH_ID_S25FL512S) || \
128 (deviceId == BOARD_FLASH_ID_S25FL256S) || \
129 (deviceId == BOARD_FLASH_ID_MT29W160EB) || \
130 (deviceId == BOARD_FLASH_ID_W25X32VSFIG) || \
131 (deviceId == BOARD_FLASH_ID_NORN25Q128) || \
132 (deviceId == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
133 (deviceId == BOARD_FLASH_ID_MT25QU512ABB) || \
134 (deviceId == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
135 (deviceId == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
136 (deviceId == BOARD_FLASH_ID_S71KS512S) || \
137 (deviceId == BOARD_FLASH_ID_S28HS512T) || \
138 (deviceId == BOARD_FLASH_ID_GD25B16CSAG) || \
139 (deviceId == BOARD_FLASH_ID_GD25B64CW2G) || \
140 (deviceId == BOARD_FLASH_ID_W25Q16FWSF) || \
141 (deviceId == BOARD_FLASH_ID_MX25V1635F)
142 )
143 {
144 /* Open the NOR flash */
145 flashHandle = NOR_open(flashIntf, portNum, params);
146 if (!flashHandle)
147 {
148 return 0;
149 }
151 norInfo = (NOR_Info *)flashHandle;
152 if (deviceId != norInfo->deviceId)
153 {
155 NOR_close(flashHandle);
156 return 0;
157 }
159 flashInfo->flashHandle = flashHandle;
160 flashInfo->manufacturer_id = norInfo->manufacturerId;
161 flashInfo->device_id = norInfo->deviceId;
162 flashInfo->type = BOARD_FLASH_NOR;
163 flashInfo->block_count = norInfo->blockCnt;
164 flashInfo->page_count = norInfo->pageCnt;
165 flashInfo->page_size = norInfo->pageSize;
166 flashInfo->sector_size = norInfo->sectorSize;
167 flashInfo->blkErase_flag = true; /* Default set to Block Erase */
169 return (Board_flashHandle)&(Board_flashInfo);
170 }
171 #elif defined (BOARD_NAND_FLASH_IN)
172 NAND_HANDLE flashHandle;
173 NAND_Info *nandInfo;
175 if (deviceId == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
176 {
177 /* Open the Nand flash */
178 flashHandle = NAND_open(flashIntf, portNum, params);
179 if (!flashHandle)
180 {
181 return 0;
182 }
183 nandInfo = (NAND_Info *)flashHandle;
185 if (deviceId != nandInfo->deviceId)
186 {
187 NAND_close(flashHandle);
188 return 0;
189 }
191 flashInfo->flashHandle = flashHandle;
192 flashInfo->manufacturer_id = nandInfo->manufacturerId;
193 flashInfo->device_id = nandInfo->deviceId;
194 flashInfo->type = BOARD_FLASH_NAND;
195 flashInfo->block_count = nandInfo->blockCnt;
196 flashInfo->page_count = nandInfo->pageCnt;
197 flashInfo->page_size = nandInfo->pageSize;
198 flashInfo->spare_size = nandInfo->spareSize;
199 flashInfo->bboffset = nandInfo->bbOffset;
200 flashInfo->bblist = nandInfo->bbList;
202 return (Board_flashHandle)(flashInfo);
203 }
204 #endif
206 return 0;
207 }
209 /******************************************************************************
210 * BOARD_flashClose
211 ******************************************************************************/
212 Board_flash_STATUS Board_flashClose(Board_flashHandle handle)
213 {
214 Board_FlashInfo *flashInfo;
216 if (!handle)
217 {
218 return BOARD_FLASH_EFAIL;
219 }
221 flashInfo = (Board_FlashInfo *)handle;
222 if (!flashInfo->flashHandle)
223 {
224 return BOARD_FLASH_EFAIL;
225 }
227 #if defined(BOARD_NOR_FLASH_IN)
228 if ( \
229 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
230 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
231 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
232 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
233 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
234 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
235 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
236 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
237 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
238 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
239 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
240 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
241 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
242 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
243 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
244 )
245 {
246 NOR_close(flashInfo->flashHandle);
247 }
248 #elif defined (BOARD_NAND_FLASH_IN)
249 if (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
250 {
251 NAND_close(flashInfo->flashHandle);
252 }
253 #endif
255 flashInfo->flashHandle = 0;
257 return BOARD_FLASH_EOK;
258 }
260 /******************************************************************************
261 * BOARD_flashRead
262 ******************************************************************************/
263 Board_flash_STATUS Board_flashRead(Board_flashHandle handle,
264 uint32_t offset,
265 uint8_t *buf,
266 uint32_t len,
267 void *params)
268 {
269 Board_FlashInfo *flashInfo;
271 if (!handle)
272 {
273 return BOARD_FLASH_EFAIL;
274 }
276 flashInfo = (Board_FlashInfo *)handle;
277 if (!flashInfo->flashHandle)
278 {
279 return BOARD_FLASH_EFAIL;
280 }
282 if (buf == NULL || len == 0)
283 {
284 return BOARD_FLASH_EINVALID;
285 }
287 #if defined(BOARD_NOR_FLASH_IN)
288 uint32_t readMode = 0;
290 if ( \
291 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
292 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
293 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
294 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
295 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
296 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
297 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
298 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
299 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
300 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
301 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
302 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
303 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
304 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
305 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
306 )
307 {
308 if (params)
309 {
310 readMode = *((uint32_t *)params);
311 }
313 if (NOR_read(flashInfo->flashHandle, offset, len, buf, readMode) \
314 != NOR_PASS)
315 {
316 return (BOARD_FLASH_EFAIL);
317 }
318 return BOARD_FLASH_EOK;
319 }
320 #elif defined (BOARD_NAND_FLASH_IN)
321 if (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
322 {
323 if (NAND_read(flashInfo->flashHandle, offset, len, buf) \
324 != NAND_PASS)
325 {
326 return (BOARD_FLASH_EFAIL);
327 }
328 return BOARD_FLASH_EOK;
329 }
330 #endif
332 return BOARD_FLASH_EUNSUPPORTED;
333 }
335 /**
336 * \brief This function computes the sector and page based on an offset
337 * This function also sets the blkErase_flag to false to support
338 * Sector erase. This flag is used by the Board_flashEraseBlk()
339 * to determine the erase type
340 *
341 * \param handle [IN] Pointer to Board_FlashHandle.
342 * offset [IN] Flash Offset to be computed to Sector
343 * sector [IN] Computed Sector number
344 * page [IN] Computed page number
345 * hybridSector_flag [IN] Flag to enable Hybrid Sector Erase
346 *
347 * \return Returns Board_flash_STATUS
348 *
349 */
350 Board_flash_STATUS Board_flashOffsetToSectorPage(Board_flashHandle handle,
351 uint32_t offset,
352 uint32_t *sector,
353 uint32_t *page,
354 bool hybridSector_flag)
355 {
356 uint32_t leftover, block_count, sector_count, page_size, page_count;
357 Board_FlashInfo *flashInfo;
359 if (!handle)
360 {
361 return BOARD_FLASH_EFAIL;
362 }
364 flashInfo = (Board_FlashInfo *)handle;
365 if (!flashInfo->flashHandle)
366 {
367 return BOARD_FLASH_EFAIL;
368 }
369 if ((flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) && (hybridSector_flag == false))
370 {
371 /* In case of S25FL256S device if hybridSector_flag is not set indicating
372 uniform sector erase of 64KB, which is handled by Block erase */
373 return Board_flashOffsetToBlkPage(handle, offset, sector, page);
374 }
376 if ( \
377 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
378 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
379 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
380 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
381 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
382 (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP) || \
383 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
384 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
385 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T)
386 )
387 {
388 block_count = flashInfo->block_count;
389 page_size = flashInfo->page_size;
390 page_count = flashInfo->page_count;
391 }
392 else
393 {
394 return BOARD_FLASH_EUNSUPPORTED;
395 }
397 sector_count = (page_count * page_size * block_count) / flashInfo->sector_size;
399 *sector = offset / flashInfo->sector_size;
400 leftover = offset % flashInfo->sector_size;
401 *page = leftover / page_size;
402 if (leftover % page_size)
403 {
404 /* All writes must be page aligned for now */
405 return BOARD_FLASH_EUNSUPPORTED;
406 }
407 if (*sector > sector_count)
408 {
409 return BOARD_FLASH_EINVALID;
410 }
411 if (*page > page_count)
412 {
413 return BOARD_FLASH_EINVALID;
414 }
416 flashInfo->blkErase_flag = false; /* This flag to be set false for Sector erase */
418 return BOARD_FLASH_EOK;
419 }
421 /**
422 * \brief This function computes the block and page number based on the
423 * offset. This function also sets the blkErase_flag to true to
424 * support Block erase. This flag is used by the
425 * Board_flashEraseBlk() to determine the erase type.
426 *
427 * \param handle [IN] Pointer to Board_FlashHandle.
428 * offset [IN] Flash Offset to be computed to Sector
429 * page [IN] Computed Page number
430 * page [IN] Computed page number
431 *
432 * \return Returns Board_flash_STATUS
433 *
434 */
435 Board_flash_STATUS Board_flashOffsetToBlkPage(Board_flashHandle handle,
436 uint32_t offset,
437 uint32_t *block,
438 uint32_t *page)
439 {
440 uint32_t leftover, block_size, block_count, page_size, page_count;
441 Board_FlashInfo *flashInfo;
443 if (!handle)
444 {
445 return BOARD_FLASH_EFAIL;
446 }
448 flashInfo = (Board_FlashInfo *)handle;
449 if (!flashInfo->flashHandle)
450 {
451 return BOARD_FLASH_EFAIL;
452 }
454 if ( \
455 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
456 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
457 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
458 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
459 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
460 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
461 (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP) || \
462 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
463 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
464 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
465 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
466 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
467 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
468 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
469 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
470 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
471 )
472 {
473 block_count = flashInfo->block_count;
474 page_size = flashInfo->page_size;
475 page_count = flashInfo->page_count;
476 }
477 else
478 {
479 return BOARD_FLASH_EUNSUPPORTED;
480 }
482 block_size = (page_count * page_size);
484 *block = offset / block_size;
485 leftover = offset % block_size;
486 *page = leftover / page_size;
487 if (leftover % page_size)
488 {
489 /* All writes must be page aligned for now */
490 return BOARD_FLASH_EUNSUPPORTED;
491 }
492 if (*block > block_count)
493 {
494 return BOARD_FLASH_EINVALID;
495 }
496 if (*page > page_count)
497 {
498 return BOARD_FLASH_EINVALID;
499 }
501 flashInfo->blkErase_flag = true; /* This flag to be set true for Block erase */
502 return BOARD_FLASH_EOK;
503 }
505 /******************************************************************************
506 * Computes a block and page based on an offset
507 ******************************************************************************/
508 Board_flash_STATUS Board_flashBlkPageToOffset(Board_flashHandle handle,
509 uint32_t *offset,
510 uint32_t block,
511 uint32_t page)
512 {
513 uint32_t block_count, page_size, page_count;
514 Board_FlashInfo *flashInfo;
516 if (!handle)
517 {
518 return BOARD_FLASH_EFAIL;
519 }
521 flashInfo = (Board_FlashInfo *)handle;
522 if (!flashInfo->flashHandle)
523 {
524 return BOARD_FLASH_EFAIL;
525 }
527 if ( \
528 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
529 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
530 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
531 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
532 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
533 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
534 (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP) || \
535 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
536 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
537 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
538 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
539 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
540 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
541 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
542 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
543 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
544 )
545 {
546 block_count = flashInfo->block_count;
547 page_size = flashInfo->page_size;
548 page_count = flashInfo->page_count;
549 }
550 else
551 {
552 return BOARD_FLASH_EUNSUPPORTED;
553 }
555 if (block >block_count || page > page_count)
556 {
557 return BOARD_FLASH_EINVALID;
558 }
560 *offset = (block * (page_count * page_size)) + (page * page_size);
562 return BOARD_FLASH_EOK;
563 }
565 /******************************************************************************
566 * BOARD_flashWrite
567 ******************************************************************************/
568 Board_flash_STATUS Board_flashWrite(Board_flashHandle handle,
569 uint32_t offset,
570 uint8_t *buf,
571 uint32_t len,
572 void *params)
573 {
574 Board_FlashInfo *flashInfo;
576 if (!handle)
577 {
578 return BOARD_FLASH_EFAIL;
579 }
581 flashInfo = (Board_FlashInfo *)handle;
582 if (!flashInfo->flashHandle)
583 {
584 return BOARD_FLASH_EFAIL;
585 }
587 if (buf == NULL || len == 0)
588 {
589 return BOARD_FLASH_EINVALID;
590 }
592 #if defined(BOARD_NOR_FLASH_IN)
593 uint32_t writeMode = 0;
595 if ( \
596 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
597 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
598 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
599 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
600 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
601 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
602 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
603 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
604 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
605 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
606 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
607 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
608 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
609 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
610 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
611 )
612 {
613 if (params)
614 {
615 writeMode = *((uint32_t *)params);
616 }
618 if (NOR_write(flashInfo->flashHandle, offset, len, buf,
619 writeMode) != NOR_PASS)
620 {
621 return (BOARD_FLASH_EFAIL);
622 }
623 return BOARD_FLASH_EOK;
624 }
625 #elif defined (BOARD_NAND_FLASH_IN)
626 if (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
627 {
628 if (NAND_write(flashInfo->flashHandle, offset, len, buf) != NAND_PASS)
629 {
630 return (BOARD_FLASH_EFAIL);
631 }
632 return BOARD_FLASH_EOK;
633 }
634 #endif
636 return BOARD_FLASH_EUNSUPPORTED;
637 }
639 /**
640 * \brief platform_device_erase_block
641 *
642 * Board_flashEraseBlk supports Block and Sector erase based on the blkErase_flag
643 * This API expects blkErase_flag to be set to the appropriate Boolean value to
644 * determine the type of erase.
645 *
646 * blkErase_flag is set in one of the Board_flashOffsetToSectorPage() or
647 * Board_flashOffsetToBlkPage() APIs for sector or block erase respectively.
648 *
649 * \param
650 * handle - Handle to the flash device
651 * blk_num - Block number to be erased when blkErase_flag=true
652 * Sector number to be erased when blkErase_flag=false
653 *
654 *
655 ********************************************************************************/
656 Board_flash_STATUS Board_flashEraseBlk(Board_flashHandle handle,
657 uint32_t blk_num)
658 {
659 Board_FlashInfo *flashInfo;
661 if (!handle)
662 {
663 return BOARD_FLASH_EFAIL;
664 }
666 flashInfo = (Board_FlashInfo *)handle;
667 if (!flashInfo->flashHandle)
668 {
669 return BOARD_FLASH_EFAIL;
670 }
672 if (flashInfo->blkErase_flag)
673 {
674 if (blk_num > flashInfo->block_count)
675 {
676 return BOARD_FLASH_EFAIL;
677 }
678 }
680 #if defined(BOARD_NOR_FLASH_IN)
681 if ( \
682 (flashInfo->device_id == BOARD_FLASH_ID_S25FL512S) || \
683 (flashInfo->device_id == BOARD_FLASH_ID_S25FL256S) || \
684 (flashInfo->device_id == BOARD_FLASH_ID_MT29W160EB) || \
685 (flashInfo->device_id == BOARD_FLASH_ID_W25X32VSFIG) || \
686 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128) || \
687 (flashInfo->device_id == BOARD_FLASH_ID_NORN25Q128A13ESF40F) || \
688 (flashInfo->device_id == BOARD_FLASH_ID_MT25QU512ABB) || \
689 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU512ABA1G12) || \
690 (flashInfo->device_id == BOARD_FLASH_ID_MT35XU256ABA1G12) || \
691 (flashInfo->device_id == BOARD_FLASH_ID_S71KS512S) || \
692 (flashInfo->device_id == BOARD_FLASH_ID_S28HS512T) || \
693 (flashInfo->device_id == BOARD_FLASH_ID_GD25B16CSAG) || \
694 (flashInfo->device_id == BOARD_FLASH_ID_GD25B64CW2G) || \
695 (flashInfo->device_id == BOARD_FLASH_ID_W25Q16FWSF) || \
696 (flashInfo->device_id == BOARD_FLASH_ID_MX25V1635F)
697 )
698 {
699 if (NOR_erase (flashInfo->flashHandle, blk_num, flashInfo->blkErase_flag) != NOR_PASS)
700 {
701 return (BOARD_FLASH_EFAIL);
702 }
703 return BOARD_FLASH_EOK;
704 }
705 #elif defined (BOARD_NAND_FLASH_IN)
706 NAND_STATUS status;
708 if (flashInfo->device_id == BOARD_FLASH_ID_MT29F4G08ABAEAWP)
709 {
710 if (flashInfo->bblist[blk_num] == NAND_BAD_BLOCK)
711 {
712 return (BOARD_FLASH_EFAIL);
713 }
715 status = NAND_erase(flashInfo->flashHandle, blk_num);
716 if (status != NAND_PASS)
717 {
718 if (status == NAND_BLOCK_BAD)
719 {
720 flashInfo->bblist[blk_num] = NAND_BAD_BLOCK;
721 }
722 return (BOARD_FLASH_EFAIL);
723 }
724 else
725 {
726 return (BOARD_FLASH_EOK);
727 }
728 }
729 #endif
731 return BOARD_FLASH_EUNSUPPORTED;
732 }