clock_control.h

Go to the documentation of this file.

/* clock_control.h - public clock controller driver API */
 
/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_H_
#define ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_H_
 
#include <zephyr/types.h>
#include <stddef.h>
#include <device.h>
#include <sys/__assert.h>
#include <sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Clock control API */
 
/* Used to select all subsystem of a clock controller */
#define CLOCK_CONTROL_SUBSYS_ALL        NULL
 
enum clock_control_status {
        CLOCK_CONTROL_STATUS_STARTING,
        CLOCK_CONTROL_STATUS_OFF,
        CLOCK_CONTROL_STATUS_ON,
        CLOCK_CONTROL_STATUS_UNAVAILABLE,
        CLOCK_CONTROL_STATUS_UNKNOWN
};
 
typedef void *clock_control_subsys_t;
 
typedef void (*clock_control_cb_t)(const struct device *dev,
                                   clock_control_subsys_t subsys,
                                   void *user_data);
 
typedef int (*clock_control)(const struct device *dev,
                             clock_control_subsys_t sys);
 
typedef int (*clock_control_get)(const struct device *dev,
                                 clock_control_subsys_t sys,
                                 uint32_t *rate);
 
typedef int (*clock_control_async_on_fn)(const struct device *dev,
                                         clock_control_subsys_t sys,
                                         clock_control_cb_t cb,
                                         void *user_data);
 
typedef enum clock_control_status (*clock_control_get_status_fn)(
                                                    const struct device *dev,
                                                    clock_control_subsys_t sys);
 
struct clock_control_driver_api {
        clock_control                   on;
        clock_control                   off;
        clock_control_async_on_fn       async_on;
        clock_control_get               get_rate;
        clock_control_get_status_fn     get_status;
};
 
static inline int clock_control_on(const struct device *dev,
                                   clock_control_subsys_t sys)
{
        int ret = device_usable_check(dev);
 
        if (ret != 0) {
                return ret;
        }
 
        const struct clock_control_driver_api *api =
                (const struct clock_control_driver_api *)dev->api;
 
        return api->on(dev, sys);
}
 
static inline int clock_control_off(const struct device *dev,
                                    clock_control_subsys_t sys)
{
        int ret = device_usable_check(dev);
 
        if (ret != 0) {
                return ret;
        }
 
        const struct clock_control_driver_api *api =
                (const struct clock_control_driver_api *)dev->api;
 
        return api->off(dev, sys);
}
 
static inline int clock_control_async_on(const struct device *dev,
                                         clock_control_subsys_t sys,
                                         clock_control_cb_t cb,
                                         void *user_data)
{
        const struct clock_control_driver_api *api =
                (const struct clock_control_driver_api *)dev->api;
 
        if (api->async_on == NULL) {
                return -ENOSYS;
        }
 
        int ret = device_usable_check(dev);
 
        if (ret != 0) {
                return ret;
        }
 
        return api->async_on(dev, sys, cb, user_data);
}
 
static inline enum clock_control_status clock_control_get_status(const struct device *dev,
                                                                 clock_control_subsys_t sys)
{
        const struct clock_control_driver_api *api =
                (const struct clock_control_driver_api *)dev->api;
 
        if (!api->get_status) {
                return CLOCK_CONTROL_STATUS_UNKNOWN;
        }
 
        if (!device_is_ready(dev)) {
                return CLOCK_CONTROL_STATUS_UNAVAILABLE;
        }
 
        return api->get_status(dev, sys);
}
 
static inline int clock_control_get_rate(const struct device *dev,
                                         clock_control_subsys_t sys,
                                         uint32_t *rate)
{
        int ret = device_usable_check(dev);
 
        if (ret != 0) {
                return ret;
        }
 
        const struct clock_control_driver_api *api =
                (const struct clock_control_driver_api *)dev->api;
 
        if (api->get_rate == NULL) {
                return -ENOSYS;
        }
 
        return api->get_rate(dev, sys, rate);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_H_ */