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 <errno.h>
#include <stddef.h>
 
#include <zephyr/types.h>
#include <zephyr/device.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Clock control API */

#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_UNKNOWN   
};

typedef void *clock_control_subsys_t;

typedef void *clock_control_subsys_rate_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);

typedef int (*clock_control_set)(const struct device *dev,
                                 clock_control_subsys_t sys,
                                 clock_control_subsys_rate_t rate);

typedef int (*clock_control_configure_fn)(const struct device *dev,
                                          clock_control_subsys_t sys,
                                          void *data);

__subsystem 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;
        clock_control_set set_rate;
        clock_control_configure_fn configure;
};


static inline int clock_control_on(const struct device *dev,
                                   clock_control_subsys_t sys)
{
        const struct clock_control_driver_api *api = DEVICE_API_GET(clock_control, dev);
 
        if (api->on == NULL) {
                return -ENOSYS;
        }
 
        return api->on(dev, sys);
}

static inline int clock_control_off(const struct device *dev,
                                    clock_control_subsys_t sys)
{
        const struct clock_control_driver_api *api = DEVICE_API_GET(clock_control, dev);
 
        if (api->off == NULL) {
                return -ENOSYS;
        }
 
        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 = DEVICE_API_GET(clock_control, dev);
 
        if (api->async_on == NULL) {
                return -ENOSYS;
        }
 
        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 = DEVICE_API_GET(clock_control, dev);
 
        if (!api->get_status) {
                return CLOCK_CONTROL_STATUS_UNKNOWN;
        }
 
        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)
{
        const struct clock_control_driver_api *api = DEVICE_API_GET(clock_control, dev);
 
        if (api->get_rate == NULL) {
                return -ENOSYS;
        }
 
        return api->get_rate(dev, sys, rate);
}

static inline int clock_control_set_rate(const struct device *dev,
                clock_control_subsys_t sys,
                clock_control_subsys_rate_t rate)
{
        const struct clock_control_driver_api *api = DEVICE_API_GET(clock_control, dev);
 
        if (api->set_rate == NULL) {
                return -ENOSYS;
        }
 
        return api->set_rate(dev, sys, rate);
}

static inline int clock_control_configure(const struct device *dev,
                                          clock_control_subsys_t sys,
                                          void *data)
{
        const struct clock_control_driver_api *api = DEVICE_API_GET(clock_control, dev);
 
        if (api->configure == NULL) {
                return -ENOSYS;
        }
 
        return api->configure(dev, sys, data);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CLOCK_CONTROL_H_ */