pwm.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 * Copyright (c) 2020-2021 Vestas Wind Systems A/S
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_PWM_H_
#define ZEPHYR_INCLUDE_DRIVERS_PWM_H_
 
#include <errno.h>
#include <zephyr/types.h>
#include <stddef.h>
#include <sys/math_extras.h>
#include <device.h>
#include <dt-bindings/pwm/pwm.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Bit 0 is used for PWM_POLARITY_NORMAL/PWM_POLARITY_INVERTED */
#define PWM_CAPTURE_TYPE_SHIFT          1U
#define PWM_CAPTURE_TYPE_MASK           (3U << PWM_CAPTURE_TYPE_SHIFT)
#define PWM_CAPTURE_MODE_SHIFT          3U
#define PWM_CAPTURE_MODE_MASK           (1U << PWM_CAPTURE_MODE_SHIFT)
#define PWM_CAPTURE_TYPE_PERIOD         (1U << PWM_CAPTURE_TYPE_SHIFT)
 
#define PWM_CAPTURE_TYPE_PULSE          (2U << PWM_CAPTURE_TYPE_SHIFT)
 
#define PWM_CAPTURE_TYPE_BOTH           (PWM_CAPTURE_TYPE_PERIOD | \
                                         PWM_CAPTURE_TYPE_PULSE)
 
#define PWM_CAPTURE_MODE_SINGLE         (0U << PWM_CAPTURE_MODE_SHIFT)
 
#define PWM_CAPTURE_MODE_CONTINUOUS     (1U << PWM_CAPTURE_MODE_SHIFT)
 
typedef uint8_t pwm_flags_t;
 
typedef int (*pwm_pin_set_t)(const struct device *dev, uint32_t pwm,
                             uint32_t period_cycles, uint32_t pulse_cycles,
                             pwm_flags_t flags);
 
typedef void (*pwm_capture_callback_handler_t)(const struct device *dev,
                                               uint32_t pwm,
                                               uint32_t period_cycles,
                                               uint32_t pulse_cycles,
                                               int status,
                                               void *user_data);
 
typedef int (*pwm_pin_configure_capture_t)(const struct device *dev,
                                           uint32_t pwm,
                                           pwm_flags_t flags,
                                           pwm_capture_callback_handler_t cb,
                                           void *user_data);
typedef int (*pwm_pin_enable_capture_t)(const struct device *dev,
                                        uint32_t pwm);
 
typedef int (*pwm_pin_disable_capture_t)(const struct device *dev,
                                         uint32_t pwm);
 
typedef int (*pwm_get_cycles_per_sec_t)(const struct device *dev,
                                        uint32_t pwm,
                                        uint64_t *cycles);
 
__subsystem struct pwm_driver_api {
        pwm_pin_set_t pin_set;
#ifdef CONFIG_PWM_CAPTURE
        pwm_pin_configure_capture_t pin_configure_capture;
        pwm_pin_enable_capture_t pin_enable_capture;
        pwm_pin_disable_capture_t pin_disable_capture;
#endif /* CONFIG_PWM_CAPTURE */
        pwm_get_cycles_per_sec_t get_cycles_per_sec;
};
 
__syscall int pwm_pin_set_cycles(const struct device *dev, uint32_t pwm,
                                 uint32_t period, uint32_t pulse, pwm_flags_t flags);
 
static inline int z_impl_pwm_pin_set_cycles(const struct device *dev,
                                            uint32_t pwm,
                                            uint32_t period, uint32_t pulse,
                                            pwm_flags_t flags)
{
        struct pwm_driver_api *api;
 
        api = (struct pwm_driver_api *)dev->api;
        return api->pin_set(dev, pwm, period, pulse, flags);
}
 
#ifdef CONFIG_PWM_CAPTURE
static inline int pwm_pin_configure_capture(const struct device *dev,
                                            uint32_t pwm,
                                            pwm_flags_t flags,
                                            pwm_capture_callback_handler_t cb,
                                            void *user_data)
{
        const struct pwm_driver_api *api = (struct pwm_driver_api *)dev->api;
 
        if (api->pin_configure_capture == NULL) {
                return -ENOSYS;
        }
 
        return api->pin_configure_capture(dev, pwm, flags, cb, user_data);
}
#endif /* CONFIG_PWM_CAPTURE */
 
__syscall int pwm_pin_enable_capture(const struct device *dev, uint32_t pwm);
 
#ifdef CONFIG_PWM_CAPTURE
static inline int z_impl_pwm_pin_enable_capture(const struct device *dev,
                                                uint32_t pwm)
{
        const struct pwm_driver_api *api = (struct pwm_driver_api *)dev->api;
 
        if (api->pin_enable_capture == NULL) {
                return -ENOSYS;
        }
 
        return api->pin_enable_capture(dev, pwm);
}
#endif /* CONFIG_PWM_CAPTURE */
 
__syscall int pwm_pin_disable_capture(const struct device *dev, uint32_t pwm);
 
#ifdef CONFIG_PWM_CAPTURE
static inline int z_impl_pwm_pin_disable_capture(const struct device *dev,
                                                 uint32_t pwm)
{
        const struct pwm_driver_api *api = (struct pwm_driver_api *)dev->api;
 
        if (api->pin_disable_capture == NULL) {
                return -ENOSYS;
        }
 
        return api->pin_disable_capture(dev, pwm);
}
#endif /* CONFIG_PWM_CAPTURE */
 
__syscall int pwm_pin_capture_cycles(const struct device *dev, uint32_t pwm,
                                     pwm_flags_t flags,
                                     uint32_t *period,
                                     uint32_t *pulse,
                                     k_timeout_t timeout);
 
__syscall int pwm_get_cycles_per_sec(const struct device *dev, uint32_t pwm,
                                     uint64_t *cycles);
 
static inline int z_impl_pwm_get_cycles_per_sec(const struct device *dev,
                                                uint32_t pwm,
                                                uint64_t *cycles)
{
        struct pwm_driver_api *api;
 
        api = (struct pwm_driver_api *)dev->api;
        return api->get_cycles_per_sec(dev, pwm, cycles);
}
 
static inline int pwm_pin_set_usec(const struct device *dev, uint32_t pwm,
                                   uint32_t period, uint32_t pulse,
                                   pwm_flags_t flags)
{
        uint64_t period_cycles, pulse_cycles, cycles_per_sec;
 
        if (pwm_get_cycles_per_sec(dev, pwm, &cycles_per_sec) != 0) {
                return -EIO;
        }
 
        period_cycles = (period * cycles_per_sec) / USEC_PER_SEC;
        if (period_cycles >= ((uint64_t)1 << 32)) {
                return -ENOTSUP;
        }
 
        pulse_cycles = (pulse * cycles_per_sec) / USEC_PER_SEC;
        if (pulse_cycles >= ((uint64_t)1 << 32)) {
                return -ENOTSUP;
        }
 
        return pwm_pin_set_cycles(dev, pwm, (uint32_t)period_cycles,
                                  (uint32_t)pulse_cycles, flags);
}
 
static inline int pwm_pin_set_nsec(const struct device *dev, uint32_t pwm,
                                   uint32_t period, uint32_t pulse,
                                   pwm_flags_t flags)
{
        uint64_t period_cycles, pulse_cycles, cycles_per_sec;
 
        if (pwm_get_cycles_per_sec(dev, pwm, &cycles_per_sec) != 0) {
                return -EIO;
        }
 
        period_cycles = (period * cycles_per_sec) / NSEC_PER_SEC;
        if (period_cycles >= ((uint64_t)1 << 32)) {
                return -ENOTSUP;
        }
 
        pulse_cycles = (pulse * cycles_per_sec) / NSEC_PER_SEC;
        if (pulse_cycles >= ((uint64_t)1 << 32)) {
                return -ENOTSUP;
        }
 
        return pwm_pin_set_cycles(dev, pwm, (uint32_t)period_cycles,
                                  (uint32_t)pulse_cycles, flags);
}
 
static inline int pwm_pin_cycles_to_usec(const struct device *dev, uint32_t pwm,
                                         uint32_t cycles, uint64_t *usec)
{
        uint64_t cycles_per_sec;
        uint64_t temp;
 
        if (pwm_get_cycles_per_sec(dev, pwm, &cycles_per_sec) != 0) {
                return -EIO;
        }
 
        if (u64_mul_overflow(cycles, (uint64_t)USEC_PER_SEC, &temp)) {
                return -ERANGE;
        }
 
        *usec = temp / cycles_per_sec;
 
        return 0;
}
 
static inline int pwm_pin_cycles_to_nsec(const struct device *dev, uint32_t pwm,
                                         uint32_t cycles, uint64_t *nsec)
{
        uint64_t cycles_per_sec;
        uint64_t temp;
 
        if (pwm_get_cycles_per_sec(dev, pwm, &cycles_per_sec) != 0) {
                return -EIO;
        }
 
        if (u64_mul_overflow(cycles, (uint64_t)NSEC_PER_SEC, &temp)) {
                return -ERANGE;
        }
 
        *nsec = temp / cycles_per_sec;
 
        return 0;
}
 
static inline int pwm_pin_capture_usec(const struct device *dev, uint32_t pwm,
                                       pwm_flags_t flags,
                                       uint64_t *period,
                                       uint64_t *pulse,
                                       k_timeout_t timeout)
{
        uint32_t period_cycles;
        uint32_t pulse_cycles;
        int err;
 
        err = pwm_pin_capture_cycles(dev, pwm, flags, &period_cycles,
                                     &pulse_cycles, timeout);
        if (err) {
                return err;
        }
 
        err = pwm_pin_cycles_to_usec(dev, pwm, period_cycles, period);
        if (err) {
                return err;
        }
 
        err = pwm_pin_cycles_to_usec(dev, pwm, pulse_cycles, pulse);
        if (err) {
                return err;
        }
 
        return 0;
}
 
static inline int pwm_pin_capture_nsec(const struct device *dev, uint32_t pwm,
                                       pwm_flags_t flags,
                                       uint64_t *period,
                                       uint64_t *pulse,
                                       k_timeout_t timeout)
{
        uint32_t period_cycles;
        uint32_t pulse_cycles;
        int err;
 
        err = pwm_pin_capture_cycles(dev, pwm, flags, &period_cycles,
                                     &pulse_cycles, timeout);
        if (err) {
                return err;
        }
 
        err = pwm_pin_cycles_to_nsec(dev, pwm, period_cycles, period);
        if (err) {
                return err;
        }
 
        err = pwm_pin_cycles_to_nsec(dev, pwm, pulse_cycles, pulse);
        if (err) {
                return err;
        }
 
        return 0;
}
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/pwm.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_PWM_H_ */