Line data    Source code

       1           1 : /*
       2             :  * Copyright (c) 2019 Vestas Wind Systems A/S
       3             :  *
       4             :  * Heavily based on drivers/flash.h which is:
       5             :  * Copyright (c) 2017 Nordic Semiconductor ASA
       6             :  * Copyright (c) 2016 Intel Corporation
       7             :  *
       8             :  * SPDX-License-Identifier: Apache-2.0
       9             :  */
      10             : 
      11             : /**
      12             :  * @file
      13             :  * @brief Public API for EEPROM drivers
      14             :  */
      15             : 
      16             : #ifndef ZEPHYR_INCLUDE_DRIVERS_EEPROM_H_
      17             : #define ZEPHYR_INCLUDE_DRIVERS_EEPROM_H_
      18             : 
      19             : /**
      20             :  * @brief EEPROM Interface
      21             :  * @defgroup eeprom_interface EEPROM Interface
      22             :  * @since 2.1
      23             :  * @version 1.0.0
      24             :  * @ingroup io_interfaces
      25             :  * @{
      26             :  */
      27             : 
      28             : #include <zephyr/types.h>
      29             : #include <stddef.h>
      30             : #include <sys/types.h>
      31             : #include <zephyr/device.h>
      32             : 
      33             : #ifdef __cplusplus
      34             : extern "C" {
      35             : #endif
      36             : 
      37             : /**
      38             :  * @cond INTERNAL_HIDDEN
      39             :  *
      40             :  * For internal driver use only, skip these in public documentation.
      41             :  */
      42             : 
      43             : /**
      44             :  * @brief Callback API upon reading from the EEPROM.
      45             :  * See @a eeprom_read() for argument description
      46             :  */
      47             : typedef int (*eeprom_api_read)(const struct device *dev, off_t offset,
      48             :                                void *data,
      49             :                                size_t len);
      50             : 
      51             : /**
      52             :  * @brief Callback API upon writing to the EEPROM.
      53             :  * See @a eeprom_write() for argument description
      54             :  */
      55             : typedef int (*eeprom_api_write)(const struct device *dev, off_t offset,
      56             :                                 const void *data, size_t len);
      57             : 
      58             : /**
      59             :  * @brief Callback API upon getting the EEPROM size.
      60             :  * See @a eeprom_get_size() for argument description
      61             :  */
      62             : typedef size_t (*eeprom_api_size)(const struct device *dev);
      63             : 
      64             : __subsystem struct eeprom_driver_api {
      65             :         eeprom_api_read read;
      66             :         eeprom_api_write write;
      67             :         eeprom_api_size size;
      68             : };
      69             : 
      70             : /** @endcond */
      71             : 
      72             : /**
      73             :  *  @brief Read data from EEPROM
      74             :  *
      75             :  *  @param dev EEPROM device
      76             :  *  @param offset Address offset to read from.
      77             :  *  @param data Buffer to store read data.
      78             :  *  @param len Number of bytes to read.
      79             :  *
      80             :  *  @return 0 on success, negative errno code on failure.
      81             :  */
      82           1 : __syscall int eeprom_read(const struct device *dev, off_t offset, void *data,
      83             :                           size_t len);
      84             : 
      85             : static inline int z_impl_eeprom_read(const struct device *dev, off_t offset,
      86             :                                      void *data, size_t len)
      87             : {
      88             :         const struct eeprom_driver_api *api =
      89             :                 (const struct eeprom_driver_api *)dev->api;
      90             : 
      91             :         return api->read(dev, offset, data, len);
      92             : }
      93             : 
      94             : /**
      95             :  *  @brief Write data to EEPROM
      96             :  *
      97             :  *  @param dev EEPROM device
      98             :  *  @param offset Address offset to write data to.
      99             :  *  @param data Buffer with data to write.
     100             :  *  @param len Number of bytes to write.
     101             :  *
     102             :  *  @return 0 on success, negative errno code on failure.
     103             :  */
     104           1 : __syscall int eeprom_write(const struct device *dev, off_t offset,
     105             :                            const void *data,
     106             :                            size_t len);
     107             : 
     108             : static inline int z_impl_eeprom_write(const struct device *dev, off_t offset,
     109             :                                       const void *data, size_t len)
     110             : {
     111             :         const struct eeprom_driver_api *api =
     112             :                 (const struct eeprom_driver_api *)dev->api;
     113             : 
     114             :         return api->write(dev, offset, data, len);
     115             : }
     116             : 
     117             : /**
     118             :  *  @brief Get the size of the EEPROM in bytes
     119             :  *
     120             :  *  @param dev EEPROM device.
     121             :  *
     122             :  *  @return EEPROM size in bytes.
     123             :  */
     124           1 : __syscall size_t eeprom_get_size(const struct device *dev);
     125             : 
     126             : static inline size_t z_impl_eeprom_get_size(const struct device *dev)
     127             : {
     128             :         const struct eeprom_driver_api *api =
     129             :                 (const struct eeprom_driver_api *)dev->api;
     130             : 
     131             :         return api->size(dev);
     132             : }
     133             : 
     134             : #ifdef __cplusplus
     135             : }
     136             : #endif
     137             : 
     138             : /**
     139             :  * @}
     140             :  */
     141             : 
     142             : #include <zephyr/syscalls/eeprom.h>
     143             : 
     144             : #endif /* ZEPHYR_INCLUDE_DRIVERS_EEPROM_H_ */