| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| |
| #include <pwm/pwm.h> |
| #include <errno.h> |
| #include <assert.h> |
| |
| /** |
| * Configure a PWM device. |
| * |
| * @param dev The device to configure. |
| * @param cfg Configuration data for this device. If NULL the device will be |
| * given default configuration values. |
| * |
| * @return 0 on success, non-zero error code on failure. |
| */ |
| int |
| pwm_configure_device(struct pwm_dev *dev, struct pwm_dev_cfg *cfg) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_configure_device != NULL); |
| |
| return (dev->pwm_funcs.pwm_configure_device(dev, cfg)); |
| } |
| |
| /** |
| * Configure a channel on the PWM device. |
| * |
| * @param dev The device to configure. |
| * @param cnum The channel number to configure. |
| * @param cfg Configuration data for this channel. If NULL the channel will be |
| * disabled or given default configuration values. |
| * |
| * @return 0 on success, non-zero error code on failure. |
| */ |
| int |
| pwm_configure_channel(struct pwm_dev *dev, |
| uint8_t cnum, |
| struct pwm_chan_cfg *cfg) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_configure_channel != NULL); |
| if (cnum >= dev->pwm_chan_count) { |
| return (EINVAL); |
| } |
| |
| return (dev->pwm_funcs.pwm_configure_channel(dev, cnum, cfg)); |
| } |
| |
| /** |
| * Set the specified duty cycle on a PWM Channel. |
| * |
| * This duty cycle is a fractional duty cycle where 0 == off, |
| * base_freq / pwm_freq == 100% and any value in between is on for fraction clock |
| * cycles and off for (base_freq / pwm_freq)-fraction clock cycles. |
| * |
| * @param dev The device which the channel belongs to. |
| * @param cnum The channel number. This channel should be already configured. |
| * @param fraction The fraction value. |
| * |
| * @return 0 on success, non-zero error code on failure. |
| */ |
| int |
| pwm_set_duty_cycle(struct pwm_dev *dev, uint8_t cnum, uint16_t fraction) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_set_duty_cycle != NULL); |
| if (cnum >= dev->pwm_chan_count) { |
| return (EINVAL); |
| } |
| |
| return (dev->pwm_funcs.pwm_set_duty_cycle(dev, cnum, fraction)); |
| } |
| |
| /** |
| * Enable a given PWM device. |
| * This device should start playing on its previously configured channels. |
| * |
| * @param dev The PWM device to be enabled. |
| * |
| * @return 0 on success, non-zero error code on failure. |
| */ |
| int |
| pwm_enable(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_enable != NULL); |
| |
| return (dev->pwm_funcs.pwm_enable(dev)); |
| } |
| |
| /** |
| * Check whether a PWM device is enabled. |
| * |
| * @param dev The device which the channel belongs to. |
| * |
| * @return true if enabled, false if not. |
| */ |
| bool |
| pwm_is_enabled(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_is_enabled != NULL); |
| |
| return (dev->pwm_funcs.pwm_is_enabled(dev)); |
| } |
| |
| /** |
| * Set the frequency for the device's clock. |
| * This frequency must be between 1/2 the clock frequency and |
| * the clock divided by the resolution. |
| * |
| * @param dev The device to configure. |
| * @param freq_hz The frequency value in Hz. |
| * |
| * @return A value is in Hz on success, negative error code on failure. |
| */ |
| int |
| pwm_set_frequency(struct pwm_dev *dev, uint32_t freq_hz) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_set_frequency != NULL); |
| |
| return (dev->pwm_funcs.pwm_set_frequency(dev, freq_hz)); |
| } |
| |
| /** |
| * Get the underlying clock driving the PWM device. |
| * |
| * @param dev |
| * |
| * @return value is in Hz on success, negative error code on failure. |
| */ |
| int |
| pwm_get_clock_freq(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_get_clock_freq != NULL); |
| |
| return (dev->pwm_funcs.pwm_get_clock_freq(dev)); |
| } |
| |
| /** |
| * Get the top value for the cycle counter, i.e. the value which sets |
| * the duty cycle to 100%. |
| * |
| * @param dev |
| * |
| * @return value in cycles on success, negative error code on failure. |
| */ |
| int |
| pwm_get_top_value(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_get_top_value != NULL); |
| |
| return (dev->pwm_funcs.pwm_get_top_value(dev)); |
| } |
| |
| /** |
| * Get the resolution of the PWM in bits. |
| * |
| * @param dev The device to query. |
| * |
| * @return The value in bits on success, negative error code on failure. |
| */ |
| int |
| pwm_get_resolution_bits(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_get_resolution_bits != NULL); |
| |
| return (dev->pwm_funcs.pwm_get_resolution_bits(dev)); |
| } |
| |
| /** |
| * Disable the PWM device, the device will stop playing while remaining configured. |
| * |
| * @param dev The device to disable. |
| * |
| * @return 0 on success, negative error code on failure. |
| */ |
| int |
| pwm_disable(struct pwm_dev *dev) |
| { |
| assert(dev); |
| assert(dev->pwm_funcs.pwm_disable != NULL); |
| |
| return (dev->pwm_funcs.pwm_disable(dev)); |
| } |