eive-obsw/bsp_mib/include/libxiphos.h

#ifndef __LIBXIPHOS_H__
#define __LIBXIPHOS_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <inttypes.h> /* required by libmtd.h */
#include <libmtd.h> /* required for libmtd_t */
#include <stddef.h>

/* String identifying this library's version */
extern const char *xsc_libxiphos_version;

/** Type for boolean values */
typedef int xsc_bool_t;

/** Type for the LibNOR instance descriptor */
typedef void * xsc_libnor_t;

/** Type for identifying the nominal or the gold (redundant) flash copy */
typedef enum {
	XSC_LIBNOR_COPY_NOMINAL,
	XSC_LIBNOR_COPY_GOLD,
	XSC_LIBNOR_COPY_TOTAL_NUMBER
} xsc_libnor_copy_t;

/** Type for identifying one of the two NOR flash chips */
typedef enum {
	XSC_LIBNOR_CHIP_0,  /* First NOR flash chip */
#if (!defined(CONFIG_Q7AE))
	XSC_LIBNOR_CHIP_1,  /* Second NOR flash chip */
#endif
	XSC_LIBNOR_CHIP_TOTAL_NUMBER
} xsc_libnor_chip_t;

/* Type for identifying the boot stage */
typedef enum {
	XSC_BOOT_STAGE_INITRAMFS, /* Booted from initramfs */
	XSC_BOOT_STAGE_ROOTFS,    /* Booted from rootfs flash partition */
	XSC_BOOT_STAGE_TOTAL_NUMBER
} xsc_boot_stage_t;

typedef enum {
	XSC_POWER_OFF, /* Power disabled */
	XSC_POWER_ON   /* Power enabled */
} xsc_power_t;

/** Type for identifying the partitions of a NOR flash copy */
typedef enum {
	XSC_LIBNOR_PART_NA = 0,
	XSC_LIBNOR_PART_FW,
	XSC_LIBNOR_PART_XSCINFO,
	XSC_LIBNOR_PART_ROOTFS,
	XSC_LIBNOR_PART_UENV,
	XSC_LIBNOR_PART_DTB,
	XSC_LIBNOR_PART_KERNEL,
	XSC_LIBNOR_PART_INITRAMFS,
	XSC_LIBNOR_PART_BCH,
	XSC_LIBNOR_PART_RWINFO,
	XSC_LIBNOR_PART_ROINFO,
	XSC_LIBNOR_PART_SYSTEM,
	XSC_LIBNOR_PART_ALL
} xsc_libnor_partitions_t;

typedef enum {
	XSC_LIBNOR_SYSFILE_NA = 0,
	XSC_LIBNOR_SYSFILE_KERNEL,
	XSC_LIBNOR_SYSFILE_DTB,
	XSC_LIBNOR_SYSFILE_LOGIC,
} xsc_libnor_system_files_t;

/** Type for identifying the action on the scratch buffer */
typedef enum {
    SCRATCH_READ = 0,
    SCRATCH_WRITE,
    SCRATCH_CLEAR
} xsc_scratch_action_t;

struct xsc_scratch_op {
    xsc_scratch_action_t action;
    char *var_name;
    char *var_value;
};

/** Type for specifying an error or status code */
typedef int xsc_status_t;
#define XSC_SUCCESS  (0) /* No Error */
#define XSC_ERROR   (-1) /* Error */
#define XSC_EINVAL  (-2) /* Invalid inputs */
#define XSC_EBUSY   (-3) /* Device is busy */

/** Returns the copy name */
const char *get_copy_name(xsc_libnor_t desc);

/** Returns the chip and copy for the given partition name */
xsc_status_t parse_copy_name(const char* name, xsc_libnor_chip_t *chip,
		xsc_libnor_copy_t *copy);

/* In the following structure, sizes of the memory and swap fields
 * are given as multiples of mem_unit bytes. */
struct xsc_proc_info {
   long uptime;             /* Seconds since boot */
   unsigned long loads[3];  /* 1, 5, and 15 minute load averages */
   unsigned long totalram;  /* Total usable main memory size */
   unsigned long freeram;   /* Available memory size */
   unsigned long sharedram; /* Amount of shared memory */
   unsigned long bufferram; /* Memory used by buffers */
   unsigned short procs;    /* Number of current processes */
   unsigned long totalhigh; /* Total high memory size */
   unsigned long freehigh;  /* Available high memory size */
   unsigned int mem_unit;   /* Memory unit size in bytes */
};

/* Retrieve the system information */
xsc_status_t xsc_info_proc(struct xsc_proc_info *info);

/**
 * xsc_info_pa3_status
 *
 * Returns the ProASIC3 Logic status register.
 */
xsc_status_t xsc_info_pa3_status(uint32_t *status);

/** Libsensors */

/** The user application is expected to use libsensors for reading ADCs
 *  Refer to libsensor documentation.
 * */

xsc_status_t xsc_ubi_get_mountinfo(int ubi_dev, int *mounted, int *rw, char
		*tgt, char *src, size_t bufsize);

xsc_status_t xsc_get_mountinfo(const char *source, int *mounted, char
		*target, size_t bufsize);

/**
 * xsc_info_pa3_logicrev
 */
xsc_status_t xsc_info_pa3_logicrev(uint32_t *status);

/**
 * xsc_boot_get_chip_copy
 *
 * Gets the currently booted NOR flash chip and copy
 *
 */
xsc_status_t xsc_boot_get_chip_copy(xsc_libnor_chip_t *boot_chip, xsc_libnor_copy_t *boot_copy);

/**
 * xsc_boot_copy
 *
 * Reboot on the chip copy specified
 *
 */
void xsc_boot_copy(xsc_libnor_chip_t boot_chip, xsc_libnor_copy_t boot_copy);

#if (defined(CONFIG_Q8_REVA) || defined(CONFIG_Q8S_REVA) || defined(CONFIG_Q8_REVB) || defined(CONFIG_Q8S_REVB))
/**
 * xsc_get_cur_lim_pwm
 *
 * Get the current limit PWM
 * Restricted to Q8 devices
 *
 */
xsc_status_t xsc_get_cur_lim_pwm(uint32_t *pwm);

/**
 * xsc_set_cur_lim_pwm
 *
 * Set the current limit PWM (range:0..15)
 * Restricted to Q8 devices
 *
 */
xsc_status_t xsc_set_cur_lim_pwm(uint32_t pwm);
#endif

/* # LibNOR: Q-card NOR flash management */

/**
 * xsc_libnor_open - open the Xiphos NOR library to use the given copy and chip
 *
 **/
xsc_status_t xsc_libnor_open(xsc_libnor_t *desc, xsc_libnor_chip_t chip, xsc_libnor_copy_t copy);

/**
 * xsc_libnor_open - open the Xiphos NOR library
 *
 **/
xsc_status_t xsc_libnor_open_any(xsc_libnor_t *desc);

/**
 * xsc_libnor_close - close the Xiphos NOR library
 *
 **/
void xsc_libnor_close(xsc_libnor_t desc);

/**
 * xsc_libnor_getmtd
 *
 * Return the MTD number for the specified name
 * */
xsc_status_t xsc_libnor_getmtd(xsc_libnor_t desc, const char *name,
        int *mtd_num);

/**
 * xsc_libnor_mtd_getsize
 *
 * Return the size of the specified MTD partition
 */
xsc_status_t xsc_libnor_mtd_getsize(xsc_libnor_t desc, const int mtd_num,
	size_t *mtd_size);

/**
 * xsc_libnor_copy_getmtd
 *
 * Return the MTD number for the specified copy (nom0, nom1, gold0, gold1)
 * */
xsc_status_t xsc_libnor_copy_getmtd(xsc_libnor_t desc, int *mtd_num);

/**
 * xsc_libnor_part_getmtd
 *
 * Return the MTD number for the specified partition (e.g. rootfs)
 * */
xsc_status_t xsc_libnor_part_getmtd(xsc_libnor_t desc, const char *part_name, int *mtd_num);

/**
 * xsc_erase_mtdn
 *
 * Erase the MTD blocks of the specified partition
 *
 * progress(int block_num, int erase_block_cnt, void* user_data): prototype for
 *    the user function that is called before each block erasure.
 *    If NULL the MTD section is wiped in one operation.
 * user_data: pointer to the data that will be feed to the progress function.
 *
 * */
xsc_status_t xsc_erase_mtdn(xsc_libnor_t desc, int mtdn, void (*progress)(int, int, void *), void *user_data);


/**
 * xsc_libnor_mtd_write
 *
 * Erase the MTD blocks of the specified partition then write the content of
 * the buffer to the partition
 *
 * bufsize should equal MTD size
 */
xsc_status_t xsc_libnor_mtd_write(xsc_libnor_t desc, int mtdn, int fd,
	char* buf, size_t bufsize);

/**
 * xsc_remount_rw
 *
 * Remount specified filesystem
 * */
xsc_status_t xsc_remount_rw(const char *name);

/**
 * xsc_umount
 *
 * Umount specified filesystem
 * */
xsc_status_t xsc_umount(const char *name);

/**
 * xsc_mtd_is_attached
 *
 * Check wether MTD section is attached to the current UBI filesystem
 *
 * mtdn: MTD number
 * Return the UBI device number
 * */
int xsc_mtd_is_attached(int mtdn, int *dev_num);

/**
 * xsc_mtd_ubi_attach
 *
 * Attach MTD section to a new UBI filesystem. If the MTD section is
 * already attached to a UBI filesystem, do nothing.
 *
 * mtdn: MTD number
 * Return UBI device number
 * */
xsc_status_t xsc_mtd_ubi_attach(int mtdn, int *dev_num);

/**
 * xsc_mtd_ubi_detach
 *
 * Remove specified UBI filesystem.
 *
 * dev_num: UBI device number
 * */
xsc_status_t xsc_mtd_ubi_detach(int dev_num);

/**
 * xsc_libnor_set_writeprotect
 *
 * Lock or unlock a whole (all partitions) NOR chip copy, resets hashes on lock
 * User can provide a callback function for the long operation of reading
 * the whole partition and computing the MD5SUM: md5progress
 * */
typedef void (*cb_md5_progress_t)(size_t n, size_t total_size, void *user_data);

xsc_status_t xsc_libnor_set_writeprotect(xsc_libnor_t desc,
		xsc_bool_t lock, xsc_bool_t auto_lock,
		cb_md5_progress_t md5progress, void *md5progress_user_data);

/**
 * xsc_libnor_get_writeprotect
 *
 * Returns the state of the writeprotection on a NOR chip copy.
 *
 * lock: set to 'True' if completely locked, 'False' otherwise
 *
 * */
xsc_status_t xsc_libnor_get_writeprotect(xsc_libnor_t desc,
		xsc_bool_t *lock);


int xsc_mtd_lock_copy(xsc_libnor_t desc, int mtdn, int lock, int check);

/*
 * xsc_mtd_lock_copy_q7ae - Get the locked status of a copy on the Q7AE.
 *
 * On Q7AE, one copy is on 2 chips. This function sets status to TRUE only if both chips are locked.
 */

xsc_status_t xsc_mtd_lock_copy_q7ae(xsc_libnor_t desc, int lock, int check, xsc_bool_t *status);

/**
 * xsc_part_getinfo
 *
 * Return the MTD number, the size and the lock status of the specified partition
 */
xsc_status_t xsc_part_getinfo(xsc_libnor_t libnor, const char *part,
		int *mtdn, size_t *size, xsc_bool_t *lock);

/**
 *
 * To further manipulate the nor flash, one can use the libmtd_t descriptor
 * along with the mtd_num of a partition and <libmtd.h>. See documentation
 * of libmtd.
 *
 * */

/* ## Watchdog */
struct watchdog_s;

/**
 * \brief Take control of the watchdog and activate it
 * \param handle   Returned handle
 * \return 0 on success, != 0 on failure
 * */
int xsc_watchdog_init(struct watchdog_s **handle);

/**
 * \brief Release the watchdog handle: only stops the watchdog if
 * magic close is set to 1
 *
 * \param handle The handle to release
 * \param magic_close set to 1 to also stop the watchdog
 * \return 0 on success, -1 otherwise
 **/
int xsc_watchdog_close(struct watchdog_s *handle, int magic_close);

/**
 * \brief Keep the watchdog alive
 *
 * \param handle The handle to the initialized watchdog
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_keepalive(struct watchdog_s *handle);

/**
 * \brief Disable the watchdog
 *
 * \param handle The handle to the initialized watchdog
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_disable(struct watchdog_s *handle);

/**
 * \brief Enable the watchdog
 *
 * \param handle The handle to the initialized watchdog
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_enable(struct watchdog_s *handle);

/**
 * \brief Set watchdog timeout after which the ProASIC will
 * reset the SoC
 *
 * \param handle The handle to the initialized watchdog
 * \param timeout_seconds The number of seconds after which the
 *                        watchdog will reset
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_set_timeout(struct watchdog_s *handle, int timeout_seconds);

/**
 * \brief Get watchdog timeout after which the ProASIC will
 * reset the SoC
 *
 * \param handle The handle to the initialized watchdog
 * \param timeout_seconds The number of seconds after which the
 *                        watchdog will reset
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_get_timeout(struct watchdog_s *handle, int *timeout_seconds);

/**
 * \brief Set the no-way-out flag which will prohibit disabling the
 * watchdog
 *
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_set_nowayout();

/**
 * \brief Get the status (enabled or disabled) and nowayout flag (set or not)
 *
 * \param nowayout  The nowayout flag status (0 = not set, 1 = set)
 * \param status    The status flag (0 = watchdog disabled, 1 = watchdog active)
 * \return 0 on success, -1 otherwise
 * */
int xsc_watchdog_get_status(int *nowayout, int *status);

/** Devices management */
typedef enum {
	XSC_DEV_MMC0 = 0,
	XSC_DEV_MMC1,
	XSC_DEV_MMC_BOTH,
	XSC_DEV_USB,
} xsc_device_t;

/**
 * xsc_device_get_paths - scans the /dev directory, recognize the device entries
 * and return the corresponding devices paths.
 * Paths are stored in strings allocated via malloc() and shall be freed by
 * xsc_device_free_paths.
 *
 * return count
 * */
int xsc_device_get_paths(xsc_device_t dev, char ***list);

void xsc_device_free_paths(int count, char **list);

/** USB external storage */

xsc_status_t xsc_usb_enable_power(xsc_power_t power);

xsc_status_t xsc_usb_get_power_status(xsc_power_t *power);

/**
 * xsc_usb_remove_all - disconnect and lock-down all USB devices
 * */
void xsc_usb_remove_all(void);

/**
 * xsc_usb_authorize_all - authorize the USB devices to connect to the system
 * */
void xsc_usb_authorize_all(void);

/** SD external storage */

/**
 * Check if any partition of the given slot is mounted.
 */
xsc_status_t xsc_sd_ismounted(xsc_device_t slot, int *mounted);
/**
 * xsc_sd_umount - umount all partitions of the given sd
 * supports XSC_DEV_MMC0, XSC_DEV_MMC1 and XSC_DEV_MMC_BOTH
 */
xsc_status_t xsc_sd_umount(xsc_device_t slot);

/**
 * xsc_sd_enable_power - enable power on selected devices
 * If force is true, the power off will be done even if partitions are mounted
 * supports XSC_DEV_MMC0, XSC_DEV_MMC1 and XSC_DEV_MMC_BOTH
 */
xsc_status_t xsc_sd_set_power(xsc_device_t slot, xsc_power_t power, int force);

/**
 * xsc_sd_get_power_status - Get the power status
 * supports XSC_DEV_MMC0 and XSC_DEV_MMC1 only
 */
xsc_status_t xsc_sd_get_power_status(xsc_device_t slot, xsc_power_t *power);

/**
 * xsc_nor_status - get the current status of the NOR chips.
 * copy is the current selected copy and power is the current power state.
 * If power is OFF, copy is undefined.
 */
xsc_status_t xsc_nor_status(xsc_libnor_copy_t *copy, xsc_power_t *power);

/**
 * xsc_nor_select - Select the given NOR copy
 */
xsc_status_t xsc_nor_select(xsc_libnor_copy_t copy);

/**
 * xsc_nor_set_power - Set the NOR power to ON or OFF
 */
xsc_status_t xsc_nor_set_power(xsc_power_t power);

/**
 * Print the environment.
 */
void *xsc_fw_printenv(char *flashbuf, size_t flash_bufsize);

/**
 * Search the environment for a variable.
 * Return the value, if found, or NULL, if not found.
 */
char *xsc_fw_getenv(const char *name, char *flashbuf, size_t flash_bufsize);

/*
 * Set/Clear a single variable in the environment.
 * This is called in sequence to update the environment
 * in RAM without updating the copy in flash after each set
 */
int xsc_fw_env_write(const char *name, const char *value, char *flashbuf, size_t flash_bufsize);

#ifdef __cplusplus
}
#endif

#endif // __LIBXIPHOS_H__