1 /*
2 * Copyright (c) 2017-2024 Nordic Semiconductor ASA
3 * Copyright (c) 2016 Intel Corporation
4 *
5 * SPDX-License-Identifier: Apache-2.0
6 */
7
8 /**
9 * @file
10 * @brief Public API for FLASH drivers
11 */
12
13 #ifndef ZEPHYR_INCLUDE_DRIVERS_FLASH_H_
14 #define ZEPHYR_INCLUDE_DRIVERS_FLASH_H_
15
16 /**
17 * @brief FLASH internal Interface
18 * @defgroup flash_internal_interface FLASH internal Interface
19 * @ingroup io_interfaces
20 * @{
21 */
22
23 #include <errno.h>
24
25 #include <zephyr/types.h>
26 #include <stddef.h>
27 #include <sys/types.h>
28 #include <zephyr/device.h>
29
30 #ifdef __cplusplus
31 extern "C" {
32 #endif
33
34 #if defined(CONFIG_FLASH_PAGE_LAYOUT)
35 struct flash_pages_layout {
36 size_t pages_count; /* count of pages sequence of the same size */
37 size_t pages_size;
38 };
39 #endif /* CONFIG_FLASH_PAGE_LAYOUT */
40
41 /**
42 * @}
43 */
44
45 /**
46 * @brief FLASH Interface
47 * @defgroup flash_interface FLASH Interface
48 * @since 1.2
49 * @version 1.0.0
50 * @ingroup io_interfaces
51 * @{
52 */
53
54 /**
55 * Flash memory parameters. Contents of this structure suppose to be
56 * filled in during flash device initialization and stay constant
57 * through a runtime.
58 */
59 struct flash_parameters {
60 /** Minimal write alignment and size */
61 const size_t write_block_size;
62
63 /** @cond INTERNAL_HIDDEN */
64 /* User code should call flash_params_get_ functions on flash_parameters
65 * to get capabilities, rather than accessing object contents directly.
66 */
67 struct {
68 /* Device has no explicit erase, so it either erases on
69 * write or does not require it at all.
70 * This also includes devices that support erase but
71 * do not require it.
72 */
73 bool no_explicit_erase: 1;
74 } caps;
75 /** @endcond */
76 /** Value the device is filled in erased areas */
77 uint8_t erase_value;
78 };
79
80 /** Set for ordinary Flash where erase is needed before write of random data */
81 #define FLASH_ERASE_C_EXPLICIT 0x01
82 /** Reserved for users as initializer for variables that will later store
83 * capabilities.
84 */
85 #define FLASH_ERASE_CAPS_UNSET (int)-1
86 /* The values below are now reserved but not used */
87 #define FLASH_ERASE_C_SUPPORTED 0x02
88 #define FLASH_ERASE_C_VAL_BIT 0x04
89 #define FLASH_ERASE_UNIFORM_PAGE 0x08
90
91
92 /* @brief Parser for flash_parameters for retrieving erase capabilities
93 *
94 * The functions parses flash_parameters type object and returns combination
95 * of erase capabilities of 0 if device does not have any.
96 * Not that in some cases availability of erase may be dependent on driver
97 * options, so even if by hardware design a device provides some erase
98 * capabilities, the function may return 0 if these been disabled or not
99 * implemented by driver.
100 *
101 * @param p pointer to flash_parameters type object
102 *
103 * @return 0 or combination of FLASH_ERASE_C_ capabilities.
104 */
105 static inline
flash_params_get_erase_cap(const struct flash_parameters * p)106 int flash_params_get_erase_cap(const struct flash_parameters *p)
107 {
108 #if defined(CONFIG_FLASH_HAS_EXPLICIT_ERASE)
109 #if defined(CONFIG_FLASH_HAS_NO_EXPLICIT_ERASE)
110 return (p->caps.no_explicit_erase) ? 0 : FLASH_ERASE_C_EXPLICIT;
111 #else
112 ARG_UNUSED(p);
113 return FLASH_ERASE_C_EXPLICIT;
114 #endif
115 #endif
116 return 0;
117 }
118
119 /**
120 * @}
121 */
122
123 /**
124 * @addtogroup flash_internal_interface
125 * @{
126 */
127
128 typedef int (*flash_api_read)(const struct device *dev, off_t offset,
129 void *data,
130 size_t len);
131 /**
132 * @brief Flash write implementation handler type
133 *
134 * @note Any necessary write protection management must be performed by
135 * the driver, with the driver responsible for ensuring the "write-protect"
136 * after the operation completes (successfully or not) matches the write-protect
137 * state when the operation was started.
138 */
139 typedef int (*flash_api_write)(const struct device *dev, off_t offset,
140 const void *data, size_t len);
141
142 /**
143 * @brief Flash erase implementation handler type
144 *
145 * @note Any necessary erase protection management must be performed by
146 * the driver, with the driver responsible for ensuring the "erase-protect"
147 * after the operation completes (successfully or not) matches the erase-protect
148 * state when the operation was started.
149 *
150 * The callback is optional for RAM non-volatile devices, which do not
151 * require erase by design, but may be provided if it allows device to
152 * work more effectively, or if device has a support for internal fill
153 * operation the erase in driver uses.
154 */
155 typedef int (*flash_api_erase)(const struct device *dev, off_t offset,
156 size_t size);
157
158 /**
159 * @brief Get device size in bytes.
160 *
161 * Returns total logical device size in bytes.
162 *
163 * @param[in] dev flash device.
164 * @param[out] size device size in bytes.
165 *
166 * @return 0 on success, negative errno code on error.
167 */
168 typedef int (*flash_api_get_size)(const struct device *dev, uint64_t *size);
169
170 typedef const struct flash_parameters* (*flash_api_get_parameters)(const struct device *dev);
171
172 #if defined(CONFIG_FLASH_PAGE_LAYOUT)
173 /**
174 * @brief Retrieve a flash device's layout.
175 *
176 * A flash device layout is a run-length encoded description of the
177 * pages on the device. (Here, "page" means the smallest erasable
178 * area on the flash device.)
179 *
180 * For flash memories which have uniform page sizes, this routine
181 * returns an array of length 1, which specifies the page size and
182 * number of pages in the memory.
183 *
184 * Layouts for flash memories with nonuniform page sizes will be
185 * returned as an array with multiple elements, each of which
186 * describes a group of pages that all have the same size. In this
187 * case, the sequence of array elements specifies the order in which
188 * these groups occur on the device.
189 *
190 * @param dev Flash device whose layout to retrieve.
191 * @param layout The flash layout will be returned in this argument.
192 * @param layout_size The number of elements in the returned layout.
193 */
194 typedef void (*flash_api_pages_layout)(const struct device *dev,
195 const struct flash_pages_layout **layout,
196 size_t *layout_size);
197 #endif /* CONFIG_FLASH_PAGE_LAYOUT */
198
199 typedef int (*flash_api_sfdp_read)(const struct device *dev, off_t offset,
200 void *data, size_t len);
201 typedef int (*flash_api_read_jedec_id)(const struct device *dev, uint8_t *id);
202 typedef int (*flash_api_ex_op)(const struct device *dev, uint16_t code,
203 const uintptr_t in, void *out);
204
205 __subsystem struct flash_driver_api {
206 flash_api_read read;
207 flash_api_write write;
208 flash_api_erase erase;
209 flash_api_get_parameters get_parameters;
210 flash_api_get_size get_size;
211 #if defined(CONFIG_FLASH_PAGE_LAYOUT)
212 flash_api_pages_layout page_layout;
213 #endif /* CONFIG_FLASH_PAGE_LAYOUT */
214 #if defined(CONFIG_FLASH_JESD216_API)
215 flash_api_sfdp_read sfdp_read;
216 flash_api_read_jedec_id read_jedec_id;
217 #endif /* CONFIG_FLASH_JESD216_API */
218 #if defined(CONFIG_FLASH_EX_OP_ENABLED)
219 flash_api_ex_op ex_op;
220 #endif /* CONFIG_FLASH_EX_OP_ENABLED */
221 };
222
223 /**
224 * @}
225 */
226
227 /**
228 * @addtogroup flash_interface
229 * @{
230 */
231
232 /**
233 * @brief Read data from flash
234 *
235 * All flash drivers support reads without alignment restrictions on
236 * the read offset, the read size, or the destination address.
237 *
238 * @param dev : flash dev
239 * @param offset : Offset (byte aligned) to read
240 * @param data : Buffer to store read data
241 * @param len : Number of bytes to read.
242 *
243 * @return 0 on success, negative errno code on fail.
244 */
245 __syscall int flash_read(const struct device *dev, off_t offset, void *data,
246 size_t len);
247
z_impl_flash_read(const struct device * dev,off_t offset,void * data,size_t len)248 static inline int z_impl_flash_read(const struct device *dev, off_t offset,
249 void *data,
250 size_t len)
251 {
252 const struct flash_driver_api *api =
253 (const struct flash_driver_api *)dev->api;
254
255 return api->read(dev, offset, data, len);
256 }
257
258 /**
259 * @brief Write buffer into flash memory.
260 *
261 * All flash drivers support a source buffer located either in RAM or
262 * SoC flash, without alignment restrictions on the source address.
263 * Write size and offset must be multiples of the minimum write block size
264 * supported by the driver.
265 *
266 * Any necessary write protection management is performed by the driver
267 * write implementation itself.
268 *
269 * @param dev : flash device
270 * @param offset : starting offset for the write
271 * @param data : data to write
272 * @param len : Number of bytes to write
273 *
274 * @return 0 on success, negative errno code on fail.
275 */
276 __syscall int flash_write(const struct device *dev, off_t offset,
277 const void *data,
278 size_t len);
279
z_impl_flash_write(const struct device * dev,off_t offset,const void * data,size_t len)280 static inline int z_impl_flash_write(const struct device *dev, off_t offset,
281 const void *data, size_t len)
282 {
283 const struct flash_driver_api *api =
284 (const struct flash_driver_api *)dev->api;
285 int rc;
286
287 rc = api->write(dev, offset, data, len);
288
289 return rc;
290 }
291
292 /**
293 * @brief Erase part or all of a flash memory
294 *
295 * Acceptable values of erase size and offset are subject to
296 * hardware-specific multiples of page size and offset. Please check
297 * the API implemented by the underlying sub driver, for example by
298 * using flash_get_page_info_by_offs() if that is supported by your
299 * flash driver.
300 *
301 * Any necessary erase protection management is performed by the driver
302 * erase implementation itself.
303 *
304 * The function should be used only for devices that are really
305 * explicit erase devices; in case when code relies on erasing
306 * device, i.e. setting it to erase-value, prior to some operations,
307 * but should work with explicit erase and RAM non-volatile devices,
308 * then flash_flatten should rather be used.
309 *
310 * @param dev : flash device
311 * @param offset : erase area starting offset
312 * @param size : size of area to be erased
313 *
314 * @return 0 on success, negative errno code on fail.
315 *
316 * @see flash_flatten()
317 * @see flash_get_page_info_by_offs()
318 * @see flash_get_page_info_by_idx()
319 */
320 __syscall int flash_erase(const struct device *dev, off_t offset, size_t size);
321
z_impl_flash_erase(const struct device * dev,off_t offset,size_t size)322 static inline int z_impl_flash_erase(const struct device *dev, off_t offset,
323 size_t size)
324 {
325 int rc = -ENOSYS;
326
327 const struct flash_driver_api *api =
328 (const struct flash_driver_api *)dev->api;
329
330 if (api->erase != NULL) {
331 rc = api->erase(dev, offset, size);
332 }
333
334 return rc;
335 }
336
337 /**
338 * @brief Get device size in bytes.
339 *
340 * Returns total logical device size in bytes. Not all devices may support
341 * returning size, specifically those with non uniform page layouts or banked,
342 * in which case the function will return -ENOTSUP, and user has to rely
343 * on Flash page layout functions enabled by CONFIG_FLASH_PAGE_LAYOUT.
344 *
345 * @param[in] dev flash device.
346 * @param[out] size device size in bytes.
347 *
348 * @return 0 on success, negative errno code on error.
349 */
350 __syscall int flash_get_size(const struct device *dev, uint64_t *size);
351
z_impl_flash_get_size(const struct device * dev,uint64_t * size)352 static inline int z_impl_flash_get_size(const struct device *dev, uint64_t *size)
353 {
354 int rc = -ENOSYS;
355 const struct flash_driver_api *api = (const struct flash_driver_api *)dev->api;
356
357 if (api->get_size != NULL) {
358 rc = api->get_size(dev, size);
359 }
360
361 return rc;
362 }
363
364 /**
365 * @brief Fill selected range of device with specified value
366 *
367 * Utility function that allows to fill specified range on a device with
368 * provided value. The @p offset and @p size of range need to be aligned to
369 * a write block size of a device.
370 *
371 * @param dev : flash device
372 * @param val : value to use for filling the range
373 * @param offset : offset of the range to fill
374 * @param size : size of the range
375 *
376 * @return 0 on success, negative errno code on fail.
377 *
378 */
379 __syscall int flash_fill(const struct device *dev, uint8_t val, off_t offset, size_t size);
380
381 /**
382 * @brief Erase part or all of a flash memory or level it
383 *
384 * If device is explicit erase type device or device driver provides erase
385 * callback, the callback of the device is called, in which it behaves
386 * the same way as flash_erase.
387 * If a device does not require explicit erase, either because
388 * it has no erase at all or has auto-erase/erase-on-write,
389 * and does not provide erase callback then erase is emulated by
390 * leveling selected device memory area with erase_value assigned to
391 * device.
392 *
393 * Erase page offset and size are constrains of paged, explicit erase devices,
394 * but can be relaxed with devices without such requirement, which means that
395 * it is up to user code to make sure they are correct as the function
396 * will return on, if these constrains are not met, -EINVAL for
397 * paged device, but may succeed on non-explicit erase devices.
398 * For RAM non-volatile devices the erase pages are emulated,
399 * at this point, to allow smooth transition for code relying on
400 * device being paged to function properly; but this is completely
401 * software constrain.
402 *
403 * Generally: if your code previously required device to be erase
404 * prior to some actions to work, replace flash_erase calls with this
405 * function; but if your code can work with non-volatile RAM type devices,
406 * without emulating erase, you should rather have different path
407 * of execution for page-erase, i.e. Flash, devices and call
408 * flash_erase for them.
409 *
410 * @param dev : flash device
411 * @param offset : erase area starting offset
412 * @param size : size of area to be erased
413 *
414 * @return 0 on success, negative errno code on fail.
415 *
416 * @see flash_erase()
417 */
418 __syscall int flash_flatten(const struct device *dev, off_t offset, size_t size);
419
420 struct flash_pages_info {
421 off_t start_offset; /* offset from the base of flash address */
422 size_t size;
423 uint32_t index;
424 };
425
426 #if defined(CONFIG_FLASH_PAGE_LAYOUT)
427 /**
428 * @brief Get the size and start offset of flash page at certain flash offset.
429 *
430 * @param dev flash device
431 * @param offset Offset within the page
432 * @param info Page Info structure to be filled
433 *
434 * @return 0 on success, -EINVAL if page of the offset doesn't exist.
435 */
436 __syscall int flash_get_page_info_by_offs(const struct device *dev,
437 off_t offset,
438 struct flash_pages_info *info);
439
440 /**
441 * @brief Get the size and start offset of flash page of certain index.
442 *
443 * @param dev flash device
444 * @param page_index Index of the page. Index are counted from 0.
445 * @param info Page Info structure to be filled
446 *
447 * @return 0 on success, -EINVAL if page of the index doesn't exist.
448 */
449 __syscall int flash_get_page_info_by_idx(const struct device *dev,
450 uint32_t page_index,
451 struct flash_pages_info *info);
452
453 /**
454 * @brief Get the total number of flash pages.
455 *
456 * @param dev flash device
457 *
458 * @return Number of flash pages.
459 */
460 __syscall size_t flash_get_page_count(const struct device *dev);
461
462 /**
463 * @brief Callback type for iterating over flash pages present on a device.
464 *
465 * The callback should return true to continue iterating, and false to halt.
466 *
467 * @param info Information for current page
468 * @param data Private data for callback
469 * @return True to continue iteration, false to halt iteration.
470 * @see flash_page_foreach()
471 */
472 typedef bool (*flash_page_cb)(const struct flash_pages_info *info, void *data);
473
474 /**
475 * @brief Iterate over all flash pages on a device
476 *
477 * This routine iterates over all flash pages on the given device,
478 * ordered by increasing start offset. For each page, it invokes the
479 * given callback, passing it the page's information and a private
480 * data object.
481 *
482 * @param dev Device whose pages to iterate over
483 * @param cb Callback to invoke for each flash page
484 * @param data Private data for callback function
485 */
486 void flash_page_foreach(const struct device *dev, flash_page_cb cb,
487 void *data);
488 #endif /* CONFIG_FLASH_PAGE_LAYOUT */
489
490 #if defined(CONFIG_FLASH_JESD216_API)
491 /**
492 * @brief Read data from Serial Flash Discoverable Parameters
493 *
494 * This routine reads data from a serial flash device compatible with
495 * the JEDEC JESD216 standard for encoding flash memory
496 * characteristics.
497 *
498 * Availability of this API is conditional on selecting
499 * @c CONFIG_FLASH_JESD216_API and support of that functionality in
500 * the driver underlying @p dev.
501 *
502 * @param dev device from which parameters will be read
503 * @param offset address within the SFDP region containing data of interest
504 * @param data where the data to be read will be placed
505 * @param len the number of bytes of data to be read
506 *
507 * @retval 0 on success
508 * @retval -ENOTSUP if the flash driver does not support SFDP access
509 * @retval negative values for other errors.
510 */
511 __syscall int flash_sfdp_read(const struct device *dev, off_t offset,
512 void *data, size_t len);
513
z_impl_flash_sfdp_read(const struct device * dev,off_t offset,void * data,size_t len)514 static inline int z_impl_flash_sfdp_read(const struct device *dev,
515 off_t offset,
516 void *data, size_t len)
517 {
518 int rv = -ENOTSUP;
519 const struct flash_driver_api *api =
520 (const struct flash_driver_api *)dev->api;
521
522 if (api->sfdp_read != NULL) {
523 rv = api->sfdp_read(dev, offset, data, len);
524 }
525 return rv;
526 }
527
528 /**
529 * @brief Read the JEDEC ID from a compatible flash device.
530 *
531 * @param dev device from which id will be read
532 * @param id pointer to a buffer of at least 3 bytes into which id
533 * will be stored
534 *
535 * @retval 0 on successful store of 3-byte JEDEC id
536 * @retval -ENOTSUP if flash driver doesn't support this function
537 * @retval negative values for other errors
538 */
539 __syscall int flash_read_jedec_id(const struct device *dev, uint8_t *id);
540
z_impl_flash_read_jedec_id(const struct device * dev,uint8_t * id)541 static inline int z_impl_flash_read_jedec_id(const struct device *dev,
542 uint8_t *id)
543 {
544 int rv = -ENOTSUP;
545 const struct flash_driver_api *api =
546 (const struct flash_driver_api *)dev->api;
547
548 if (api->read_jedec_id != NULL) {
549 rv = api->read_jedec_id(dev, id);
550 }
551 return rv;
552 }
553 #endif /* CONFIG_FLASH_JESD216_API */
554
555 /**
556 * @brief Get the minimum write block size supported by the driver
557 *
558 * The write block size supported by the driver might differ from the write
559 * block size of memory used because the driver might implements write-modify
560 * algorithm.
561 *
562 * @param dev flash device
563 *
564 * @return write block size in bytes.
565 */
566 __syscall size_t flash_get_write_block_size(const struct device *dev);
567
z_impl_flash_get_write_block_size(const struct device * dev)568 static inline size_t z_impl_flash_get_write_block_size(const struct device *dev)
569 {
570 const struct flash_driver_api *api =
571 (const struct flash_driver_api *)dev->api;
572
573 return api->get_parameters(dev)->write_block_size;
574 }
575
576
577 /**
578 * @brief Get pointer to flash_parameters structure
579 *
580 * Returned pointer points to a structure that should be considered
581 * constant through a runtime, regardless if it is defined in RAM or
582 * Flash.
583 * Developer is free to cache the structure pointer or copy its contents.
584 *
585 * @return pointer to flash_parameters structure characteristic for
586 * the device.
587 */
588 __syscall const struct flash_parameters *flash_get_parameters(const struct device *dev);
589
z_impl_flash_get_parameters(const struct device * dev)590 static inline const struct flash_parameters *z_impl_flash_get_parameters(const struct device *dev)
591 {
592 const struct flash_driver_api *api =
593 (const struct flash_driver_api *)dev->api;
594
595 return api->get_parameters(dev);
596 }
597
598 /**
599 * @brief Execute flash extended operation on given device
600 *
601 * Besides of standard flash operations like write or erase, flash controllers
602 * also support additional features like write protection or readout
603 * protection. These features are not available in every flash controller,
604 * what's more controllers can implement it in a different way.
605 *
606 * It doesn't make sense to add a separate flash API function for every flash
607 * controller feature, because it could be unique (supported on small number of
608 * flash controllers) or the API won't be able to represent the same feature on
609 * every flash controller.
610 *
611 * @param dev Flash device
612 * @param code Operation which will be executed on the device.
613 * @param in Pointer to input data used by operation. If operation doesn't
614 * need any input data it could be NULL.
615 * @param out Pointer to operation output data. If operation doesn't produce
616 * any output it could be NULL.
617 *
618 * @retval 0 on success.
619 * @retval -ENOTSUP if given device doesn't support extended operation.
620 * @retval -ENOSYS if support for extended operations is not enabled in Kconfig
621 * @retval negative value on extended operation errors.
622 */
623 __syscall int flash_ex_op(const struct device *dev, uint16_t code,
624 const uintptr_t in, void *out);
625
626 /**
627 * @brief Copy flash memory from one device to another.
628 *
629 * Copy a region of flash memory from one place to another. The source and
630 * destination flash devices may be the same or different devices. However,
631 * this function will fail if the source and destination devices are the same
632 * if memory regions overlap and are not identical.
633 *
634 * The caller must supply a buffer of suitable size and ensure that the
635 * destination is erased beforehand, if necessary.
636 *
637 * @note If the source and destination devices are the same, and the source
638 * and destination offsets are also the same, this function succeeds without
639 * performing any copy operation.
640 *
641 * @param src_dev Source flash device.
642 * @param dst_dev Destination flash device.
643 * @param src_offset Offset within the source flash device.
644 * @param dst_offset Offset within the destination flash device.
645 * @param size Size of the region to copy, in bytes.
646 * @param[out] buf Pointer to a buffer of size @a buf_size.
647 * @param buf_size Size of the buffer pointed to by @a buf.
648 *
649 * @retval 0 on success
650 * @retval -EINVAL if an argument is invalid.
651 * @retval -EIO if an I/O error occurs.
652 * @retval -ENODEV if either @a src_dev or @a dst_dev are not ready.
653 */
654 __syscall int flash_copy(const struct device *src_dev, off_t src_offset,
655 const struct device *dst_dev, off_t dst_offset, off_t size, uint8_t *buf,
656 size_t buf_size);
657 /*
658 * Extended operation interface provides flexible way for supporting flash
659 * controller features. Code space is divided equally into Zephyr codes
660 * (MSb == 0) and vendor codes (MSb == 1). This way we can easily add extended
661 * operations to the drivers without cluttering the API or problems with API
662 * incompatibility. Extended operation can be promoted from vendor codes to
663 * Zephyr codes if the feature is available in most flash controllers and
664 * can be represented in the same way.
665 *
666 * It's not forbidden to have operation in Zephyr codes and vendor codes for
667 * the same functionality. In this case, vendor operation could provide more
668 * specific access when abstraction in Zephyr counterpart is insufficient.
669 */
670 #define FLASH_EX_OP_VENDOR_BASE 0x8000
671 #define FLASH_EX_OP_IS_VENDOR(c) ((c) & FLASH_EX_OP_VENDOR_BASE)
672
673 /**
674 * @brief Enumeration for extra flash operations
675 */
676 enum flash_ex_op_types {
677 /*
678 * Reset flash device.
679 */
680 FLASH_EX_OP_RESET = 0,
681 };
682
z_impl_flash_ex_op(const struct device * dev,uint16_t code,const uintptr_t in,void * out)683 static inline int z_impl_flash_ex_op(const struct device *dev, uint16_t code,
684 const uintptr_t in, void *out)
685 {
686 #if defined(CONFIG_FLASH_EX_OP_ENABLED)
687 const struct flash_driver_api *api =
688 (const struct flash_driver_api *)dev->api;
689
690 if (api->ex_op == NULL) {
691 return -ENOTSUP;
692 }
693
694 return api->ex_op(dev, code, in, out);
695 #else
696 ARG_UNUSED(dev);
697 ARG_UNUSED(code);
698 ARG_UNUSED(in);
699 ARG_UNUSED(out);
700
701 return -ENOSYS;
702 #endif /* CONFIG_FLASH_EX_OP_ENABLED */
703 }
704
705 #ifdef __cplusplus
706 }
707 #endif
708
709 /**
710 * @}
711 */
712
713 #include <zephyr/syscalls/flash.h>
714
715 #endif /* ZEPHYR_INCLUDE_DRIVERS_FLASH_H_ */
716
