This patch series contains the ninth attempt at implementation of a
generic PWM device interface framework. Think gpiolib, but for
devices and pseudo-devices that generate pulse-wave-modulated outputs.
Compared to the previous version, this patch series:
* Fixes an unbalanced get_device()/put_device()
A git tree containing these patches may be found here:
http://git.billgatliff.com/pwm.git
Regards,
b.g.
Bill Gatliff (3):
PWM: Implement a generic PWM framework
PWM: GPIO+hrtimer device emulation
PWM: Atmel PWMC driver
Documentation/pwm.txt | 276 ++++++++++++++++++++++
MAINTAINERS | 8 +
drivers/Kconfig | 2 +
drivers/Makefile | 2 +
drivers/pwm/Kconfig | 29 +++
drivers/pwm/Makefile | 7 +
drivers/pwm/atmel-pwmc.c | 452 ++++++++++++++++++++++++++++++++++++
drivers/pwm/gpio-pwm.c | 332 ++++++++++++++++++++++++++
drivers/pwm/pwm.c | 580 ++++++++++++++++++++++++++++++++++++++++++++++
include/linux/pwm/pwm.h | 143 ++++++++++++
10 files changed, 1831 insertions(+), 0 deletions(-)
create mode 100644 Documentation/pwm.txt
create mode 100644 drivers/pwm/Kconfig
create mode 100644 drivers/pwm/Makefile
create mode 100644 drivers/pwm/atmel-pwmc.c
create mode 100644 drivers/pwm/gpio-pwm.c
create mode 100644 drivers/pwm/pwm.c
create mode 100644 include/linux/pwm/pwm.h
--
1.7.4.1
Driver to allow the Atmel PWMC peripheral found on various
AT91 SoCs to be controlled using the Generic PWM framework.
Tested on the AT91SAM9263.
Signed-off-by: Bill Gatliff <[email protected]>
---
drivers/pwm/Kconfig | 8 +
drivers/pwm/Makefile | 1 +
drivers/pwm/atmel-pwmc.c | 452 ++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 461 insertions(+), 0 deletions(-)
create mode 100644 drivers/pwm/atmel-pwmc.c
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
index 476de67..560324a 100644
--- a/drivers/pwm/Kconfig
+++ b/drivers/pwm/Kconfig
@@ -19,3 +19,11 @@ config GPIO_PWM
To compile this feature as a module, chose M here; the module
will be called gpio-pwm. If unsure, say N.
+
+config ATMEL_PWMC
+ tristate "Atmel AT32/AT91 PWMC support"
+ depends on GENERIC_PWM && (AVR32 || ARCH_AT91SAM9263 || ARCH_AT91SAM9RL || ARCH_AT91CAP9)
+ help
+ This option enables support under the generic PWM
+ framework for PWMC peripheral channels found on
+ certain Atmel microcontrollers. If unsure, say N.
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
index ecec3e4..d274fa0 100644
--- a/drivers/pwm/Makefile
+++ b/drivers/pwm/Makefile
@@ -4,3 +4,4 @@
obj-$(CONFIG_GENERIC_PWM) := pwm.o
obj-$(CONFIG_GPIO_PWM) += gpio-pwm.o
+obj-$(CONFIG_ATMEL_PWMC) += atmel-pwmc.o
diff --git a/drivers/pwm/atmel-pwmc.c b/drivers/pwm/atmel-pwmc.c
new file mode 100644
index 0000000..1339335
--- /dev/null
+++ b/drivers/pwm/atmel-pwmc.c
@@ -0,0 +1,452 @@
+/*
+ * Atmel PWMC peripheral driver
+ *
+ * Copyright (C) 2011 Bill Gatliff <[email protected]>
+ * Copyright (C) 2007 David Brownell
+ *
+ * This program is free software; you may redistribute and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/completion.h>
+#include <linux/pwm/pwm.h>
+
+enum {
+ /* registers common to the PWMC peripheral */
+ PWMC_MR = 0,
+ PWMC_ENA = 4,
+ PWMC_DIS = 8,
+ PWMC_SR = 0xc,
+ PWMC_IER = 0x10,
+ PWMC_IDR = 0x14,
+ PWMC_IMR = 0x18,
+ PWMC_ISR = 0x1c,
+
+ /* registers per each PWMC channel */
+ PWMC_CMR = 0,
+ PWMC_CDTY = 4,
+ PWMC_CPRD = 8,
+ PWMC_CCNT = 0xc,
+ PWMC_CUPD = 0x10,
+
+ /* how to find each channel */
+ PWMC_CHAN_BASE = 0x200,
+ PWMC_CHAN_STRIDE = 0x20,
+
+ /* CMR bits of interest */
+ PWMC_CMR_CPD = 10,
+ PWMC_CMR_CPOL = 9,
+ PWMC_CMR_CALG = 8,
+ PWMC_CMR_CPRE_MASK = 0xf,
+};
+
+/* TODO: NCHAN==4 only for certain AT91-ish parts! */
+#define NCHAN 4
+struct atmel_pwmc {
+ struct pwm_device *p[NCHAN];
+ struct pwm_device_ops ops;
+ spinlock_t lock;
+ struct completion complete;
+ void __iomem *iobase;
+ struct clk *clk;
+ u32 ccnt_mask;
+};
+
+/* TODO: debugfs attributes for peripheral register values */
+
+static inline void pwmc_writel(const struct atmel_pwmc *p, unsigned offset, u32 val)
+{
+ __raw_writel(val, p->iobase + offset);
+}
+
+static inline u32 pwmc_readl(const struct atmel_pwmc *p, unsigned offset)
+{
+ return __raw_readl(p->iobase + offset);
+}
+
+static int __to_chan(const struct atmel_pwmc *ap, const struct pwm_device *p)
+{
+ int chan;
+ for (chan = 0; chan < NCHAN; chan++)
+ if (p == ap->p[chan])
+ return chan;
+ BUG();
+ return 0;
+}
+
+
+static void pwmc_chan_writel(const struct atmel_pwmc *ap, int chan, int offset, int val)
+{
+ if (PWMC_CMR == offset)
+ val &= ((1 << PWMC_CMR_CPD)
+ | (1 << PWMC_CMR_CPOL)
+ | (1 << PWMC_CMR_CALG)
+ | (PWMC_CMR_CPRE_MASK));
+ else
+ val &= ap->ccnt_mask;
+
+ pwmc_writel(ap, offset + PWMC_CHAN_BASE
+ + (chan * PWMC_CHAN_STRIDE), val);
+}
+
+static u32 pwmc_chan_readl(const struct atmel_pwmc *ap, int chan, int offset)
+{
+ return pwmc_readl(ap, offset + PWMC_CHAN_BASE
+ + (chan * PWMC_CHAN_STRIDE));
+}
+
+static int __atmel_pwmc_is_on(const struct atmel_pwmc *ap, int chan)
+{
+ return (pwmc_readl(ap, PWMC_SR) & BIT(chan)) ? 1 : 0;
+}
+
+static void __atmel_pwmc_stop(const struct atmel_pwmc *ap, int chan)
+{
+ pwmc_writel(ap, PWMC_DIS, BIT(chan));
+}
+
+static void __atmel_pwmc_start(const struct atmel_pwmc *ap, int chan)
+{
+ pwmc_writel(ap, PWMC_ENA, BIT(chan));
+}
+
+static void __atmel_pwmc_config_polarity(struct atmel_pwmc *ap, int chan,
+ struct pwm_config *c)
+{
+ unsigned long cmr = pwmc_chan_readl(ap, chan, PWMC_CMR);
+ struct pwm_device *p = ap->p[chan];
+
+ if (c->polarity)
+ clear_bit(PWMC_CMR_CPOL, &cmr);
+ else
+ set_bit(PWMC_CMR_CPOL, &cmr);
+ pwmc_chan_writel(ap, chan, PWMC_CMR, cmr);
+ p->polarity = c->polarity ? 1 : 0;
+
+ dev_dbg(&p->dev, "polarity %d\n", c->polarity);
+}
+
+static void __atmel_pwmc_config_duty_ticks(struct atmel_pwmc *ap, int chan,
+ struct pwm_config *c)
+{
+ unsigned long cmr, cprd, cpre, cdty;
+ struct pwm_device *p = ap->p[chan];
+
+ cmr = pwmc_chan_readl(ap, chan, PWMC_CMR);
+ cprd = pwmc_chan_readl(ap, chan, PWMC_CPRD);
+
+ cpre = cmr & PWMC_CMR_CPRE_MASK;
+ clear_bit(PWMC_CMR_CPD, &cmr);
+
+ cdty = cprd - (c->duty_ticks >> cpre);
+
+ p->duty_ticks = c->duty_ticks;
+
+ if (__atmel_pwmc_is_on(ap, chan)) {
+ pwmc_chan_writel(ap, chan, PWMC_CMR, cmr);
+ pwmc_chan_writel(ap, chan, PWMC_CUPD, cdty);
+ } else
+ pwmc_chan_writel(ap, chan, PWMC_CDTY, cdty);
+
+ dev_dbg(&p->dev, "duty_ticks = %lu cprd = %lx"
+ " cdty = %lx cpre = %lx\n", p->duty_ticks,
+ cprd, cdty, cpre);
+}
+
+static int __atmel_pwmc_config_period_ticks(struct atmel_pwmc *ap, int chan,
+ struct pwm_config *c)
+{
+ u32 cmr, cprd, cpre;
+ struct pwm_device *p = ap->p[chan];
+
+ cpre = fls(c->period_ticks);
+ if (cpre < 16)
+ cpre = 0;
+ else {
+ cpre -= 15;
+ if (cpre > 10)
+ return -EINVAL;
+ }
+
+ cmr = pwmc_chan_readl(ap, chan, PWMC_CMR);
+ cmr &= ~PWMC_CMR_CPRE_MASK;
+ cmr |= cpre;
+
+ cprd = c->period_ticks >> cpre;
+
+ pwmc_chan_writel(ap, chan, PWMC_CMR, cmr);
+ pwmc_chan_writel(ap, chan, PWMC_CPRD, cprd);
+ p->period_ticks = c->period_ticks;
+
+ dev_dbg(&p->dev, "period_ticks = %lu cprd = %x cpre = %x\n",
+ p->period_ticks, cprd, cpre);
+ return 0;
+}
+
+static int atmel_pwmc_config_nosleep(struct pwm_device *p, struct pwm_config *c)
+{
+ struct atmel_pwmc *ap = pwm_get_drvdata(p);
+ int chan = __to_chan(ap, p);
+ int ret = 0;
+ unsigned long flags;
+
+ spin_lock_irqsave(&ap->lock, flags);
+
+ switch (c->config_mask) {
+
+ case BIT(PWM_CONFIG_DUTY_TICKS):
+ __atmel_pwmc_config_duty_ticks(ap, chan, c);
+ break;
+
+ case BIT(PWM_CONFIG_STOP):
+ __atmel_pwmc_stop(ap, chan);
+ break;
+
+ case BIT(PWM_CONFIG_START):
+ __atmel_pwmc_start(ap, chan);
+ break;
+
+ case BIT(PWM_CONFIG_POLARITY):
+ __atmel_pwmc_config_polarity(ap, chan, c);
+ break;
+
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ spin_unlock_irqrestore(&ap->lock, flags);
+ return ret;
+}
+
+static int atmel_pwmc_stop_sync(struct atmel_pwmc *ap, int chan)
+{
+ struct pwm_device *p = ap->p[chan];
+ int was_on = __atmel_pwmc_is_on(ap, chan);
+ int ret;
+
+ if (!was_on)
+ return 0;
+
+ do {
+ init_completion(&ap->complete);
+ set_bit(PWM_FLAG_STOP, &p->flags);
+ pwmc_writel(ap, PWMC_IER, BIT(chan));
+
+ dev_dbg(&p->dev, "waiting on stop_sync completion...\n");
+
+ ret = wait_for_completion_interruptible(&ap->complete);
+
+ dev_dbg(&p->dev, "stop_sync complete (%d)\n", ret);
+
+ if (ret)
+ return ret;
+ } while (test_bit(PWM_FLAG_STOP, &p->flags));
+
+ return 1;
+}
+
+static int atmel_pwmc_config(struct pwm_device *p, struct pwm_config *c)
+{
+ struct atmel_pwmc *ap = pwm_get_drvdata(p);
+ int chan = __to_chan(ap, p);
+ int was_on = 0;
+ int ret;
+
+
+ if (!atmel_pwmc_config_nosleep(p, c))
+ return 0;
+
+ might_sleep();
+
+ dev_dbg(&p->dev, "config_mask %lx\n", c->config_mask);
+
+ was_on = atmel_pwmc_stop_sync(ap, chan);
+ if (was_on < 0)
+ return was_on;
+
+ if (test_bit(PWM_CONFIG_PERIOD_TICKS, &c->config_mask)) {
+ ret = __atmel_pwmc_config_period_ticks(ap, chan, c);
+ if (ret)
+ return ret;
+
+ if (!test_bit(PWM_CONFIG_DUTY_TICKS, &c->config_mask)) {
+ struct pwm_config d = {
+ .config_mask = PWM_CONFIG_DUTY_TICKS,
+ .duty_ticks = p->duty_ticks,
+ };
+ __atmel_pwmc_config_duty_ticks(ap, chan, &d);
+ }
+ }
+
+ if (test_bit(PWM_CONFIG_DUTY_TICKS, &c->config_mask))
+ __atmel_pwmc_config_duty_ticks(ap, chan, c);
+
+ if (test_bit(PWM_CONFIG_POLARITY, &c->config_mask))
+ __atmel_pwmc_config_polarity(ap, chan, c);
+
+ if (test_bit(PWM_CONFIG_START, &c->config_mask)
+ || (was_on && !test_bit(PWM_CONFIG_STOP, &c->config_mask)))
+ __atmel_pwmc_start(ap, chan);
+
+ return 0;
+}
+
+static int atmel_pwmc_request(struct pwm_device *p)
+{
+ struct atmel_pwmc *ap = pwm_get_drvdata(p);
+ int chan = __to_chan(ap, p);
+ unsigned long flags;
+
+ spin_lock_irqsave(&ap->lock, flags);
+ clk_enable(ap->clk);
+ p->tick_hz = clk_get_rate(ap->clk);
+ __atmel_pwmc_stop(ap, chan);
+ spin_unlock_irqrestore(&ap->lock, flags);
+
+ return 0;
+}
+
+static void atmel_pwmc_release(struct pwm_device *p)
+{
+ struct atmel_pwmc *ap = pwm_get_drvdata(p);
+ clk_disable(ap->clk);
+}
+
+const struct pwm_device_ops atmel_pwm_ops = {
+ .request = atmel_pwmc_request,
+ .release = atmel_pwmc_release,
+ .config_nosleep = atmel_pwmc_config_nosleep,
+ .config = atmel_pwmc_config,
+ .owner = THIS_MODULE,
+};
+
+static int __devinit atmel_pwmc_probe(struct platform_device *pdev)
+{
+ struct atmel_pwmc *ap;
+ struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ signed int chan;
+ int ret = 0;
+
+ ap = kzalloc(sizeof(*ap), GFP_KERNEL);
+ if (!ap) {
+ ret = -ENOMEM;
+ goto err_atmel_pwmc_alloc;
+ }
+
+ spin_lock_init(&ap->lock);
+ init_completion(&ap->complete);
+ platform_set_drvdata(pdev, ap);
+
+ /* TODO: the datasheets are unclear as to how large CCNT
+ * actually is across all adopters of the PWMC; sixteen bits
+ * seems a safe assumption for now */
+ ap->ccnt_mask = 0xffffUL;
+
+ ap->clk = clk_get(&pdev->dev, "pwm_clk");
+ if (IS_ERR(ap->clk)) {
+ ret = -ENODEV;
+ goto err_clk_get;
+ }
+
+ ap->iobase = ioremap_nocache(r->start, resource_size(r));
+ if (!ap->iobase) {
+ ret = -ENODEV;
+ goto err_ioremap;
+ }
+
+ clk_enable(ap->clk);
+ pwmc_writel(ap, PWMC_DIS, -1);
+ pwmc_writel(ap, PWMC_IDR, -1);
+ clk_disable(ap->clk);
+
+ for (chan = 0; chan < NCHAN; chan++) {
+ ap->p[chan] = pwm_register(&atmel_pwm_ops, &pdev->dev, "%s:%d",
+ dev_name(&pdev->dev), chan);
+ if (IS_ERR_OR_NULL(ap->p[chan]))
+ goto err_pwm_register;
+ pwm_set_drvdata(ap->p[chan], ap);
+ }
+
+ return 0;
+
+err_pwm_register:
+ while (--chan > 0)
+ pwm_unregister(ap->p[chan]);
+
+ iounmap(ap->iobase);
+err_ioremap:
+ clk_put(ap->clk);
+err_clk_get:
+ platform_set_drvdata(pdev, NULL);
+ kfree(ap);
+err_atmel_pwmc_alloc:
+ dev_dbg(&pdev->dev, "%s: error, returning %d\n", __func__, ret);
+ return ret;
+}
+
+static int __devexit atmel_pwmc_remove(struct platform_device *pdev)
+{
+ struct atmel_pwmc *ap = platform_get_drvdata(pdev);
+ int chan;
+
+ for (chan = 0; chan < NCHAN; chan++)
+ pwm_unregister(ap->p[chan]);
+
+ clk_enable(ap->clk);
+ pwmc_writel(ap, PWMC_IDR, -1);
+ pwmc_writel(ap, PWMC_DIS, -1);
+ clk_disable(ap->clk);
+
+ clk_put(ap->clk);
+ iounmap(ap->iobase);
+
+ kfree(ap);
+
+ return 0;
+}
+
+static struct platform_driver atmel_pwmc_driver = {
+ .driver = {
+ /* note: this name has to match the one in at91*_devices.c */
+ .name = "atmel_pwmc",
+ .owner = THIS_MODULE,
+ },
+ .probe = atmel_pwmc_probe,
+ .remove = __devexit_p(atmel_pwmc_remove),
+};
+
+static int __init atmel_pwmc_init(void)
+{
+ return platform_driver_register(&atmel_pwmc_driver);
+}
+module_init(atmel_pwmc_init);
+
+static void __exit atmel_pwmc_exit(void)
+{
+ platform_driver_unregister(&atmel_pwmc_driver);
+}
+module_exit(atmel_pwmc_exit);
+
+MODULE_AUTHOR("Bill Gatliff <[email protected]>");
+MODULE_DESCRIPTION("Driver for Atmel PWMC peripheral");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:atmel_pwmc");
--
1.7.4.1
Emulates a PWM device using a GPIO pin and an hrtimer. Subject
to CPU, scheduler and hardware limitations, can support many
PWM outputs, e.g. as many as you have GPIO pins available for.
On a 200 MHz ARM9 processor, a PWM frequency of 100 Hz can be attained
with this code so long as the duty cycle remains between about 20-80%.
At higher or lower duty cycles, the transition events may arrive too
close for the scheduler and CPU to reliably service.
This driver supports creation of new GPIO+hrtimer PWM devices via
configfs:
# mount config /config -t configfs
# mkdir /config/gpio-pwm/<gpio number>
The new PWM device will appear as /sys/class/pwm/gpio-pwm.<gpio number>.
Caveats:
* The GPIO pin number must be valid, not already in use
* The output state of the GPIO pin is configured when the PWM starts
running i.e. not immediately upon request, because the polarity of
the inactive state of the pin isn't known until the pwm device's
'polarity' attribute is configured
* After creating and binding the pwm device, you must then request
it by writing to /sys/class/pwm/gpio-pwm.<gpio number>/export
Unbind and destroy the pwm device by first stopping and unexporting
the pwm device under sysfs as usual; then do:
# rm -rf /config/gpio-pwm/<gpio number>
Signed-off-by: Bill Gatliff <[email protected]>
---
drivers/pwm/Kconfig | 11 ++
drivers/pwm/Makefile | 2 +
drivers/pwm/gpio-pwm.c | 332 +++++++++++++++++++++++++++++++++++++++++++++++
include/linux/pwm/pwm.h | 3 +
4 files changed, 348 insertions(+), 0 deletions(-)
create mode 100644 drivers/pwm/gpio-pwm.c
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
index bc550f7..476de67 100644
--- a/drivers/pwm/Kconfig
+++ b/drivers/pwm/Kconfig
@@ -8,3 +8,14 @@ menuconfig GENERIC_PWM
Enables PWM device support implemented via a generic
framework. If unsure, say N.
+config GPIO_PWM
+ tristate "GPIO+hrtimer PWM device emulation"
+ depends on GENERIC_PWM
+ help
+ When enabled, this feature emulates single-channel PWM
+ devices using high-resolution timers and GPIO pins. You may
+ create as many of these devices as desired, subject to CPU
+ throughput limitations and GPIO pin availability.
+
+ To compile this feature as a module, chose M here; the module
+ will be called gpio-pwm. If unsure, say N.
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
index 7baa201..ecec3e4 100644
--- a/drivers/pwm/Makefile
+++ b/drivers/pwm/Makefile
@@ -2,3 +2,5 @@
# Makefile for pwm devices
#
obj-$(CONFIG_GENERIC_PWM) := pwm.o
+
+obj-$(CONFIG_GPIO_PWM) += gpio-pwm.o
diff --git a/drivers/pwm/gpio-pwm.c b/drivers/pwm/gpio-pwm.c
new file mode 100644
index 0000000..b1a3801
--- /dev/null
+++ b/drivers/pwm/gpio-pwm.c
@@ -0,0 +1,332 @@
+/*
+ * Emulates a PWM device using an hrtimer and GPIO pin
+ *
+ * Copyright (C) 2011 Bill Gatliff <[email protected]>
+ *
+ * This program is free software; you may redistribute and/or modify
+ * it under the terms of the GNU General Public License Version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/hrtimer.h>
+#include <linux/err.h>
+#include <linux/workqueue.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/completion.h>
+#include <linux/configfs.h>
+#include <linux/pwm/pwm.h>
+
+#define DRIVER_NAME KBUILD_MODNAME
+
+struct gpio_pwm {
+ struct pwm_device *pwm;
+ struct pwm_device_ops ops;
+ struct hrtimer t;
+ struct work_struct work;
+ spinlock_t lock;
+ struct completion complete;
+ int gpio;
+ int callback;
+ unsigned long polarity : 1;
+ unsigned long active : 1;
+};
+
+static void gpio_pwm_work(struct work_struct *work)
+{
+ struct gpio_pwm *gp = container_of(work, struct gpio_pwm, work);
+
+ gpio_direction_output(gp->gpio, !(!!gp->polarity ^ !!gp->active));
+}
+
+static enum hrtimer_restart gpio_pwm_timeout(struct hrtimer *t)
+{
+ struct gpio_pwm *gp = container_of(t, struct gpio_pwm, t);
+ struct pwm_device *p = gp->pwm;
+
+ if (unlikely(p->duty_ticks == 0))
+ gp->active = 0;
+ else if (unlikely(p->duty_ticks == p->period_ticks))
+ gp->active = 1;
+ else
+ gp->active ^= 1;
+
+ if (gpio_cansleep(gp->gpio))
+ schedule_work(&gp->work);
+ else
+ gpio_pwm_work(&gp->work);
+
+ if (unlikely(!gp->active && test_bit(PWM_FLAG_STOP, &p->flags))) {
+ clear_bit(PWM_FLAG_STOP, &p->flags);
+ complete_all(&gp->complete);
+ goto done;
+ }
+
+ if (gp->active)
+ hrtimer_forward_now(&gp->t, ktime_set(0, p->duty_ticks));
+ else
+ hrtimer_forward_now(&gp->t, ktime_set(0, p->period_ticks
+ - p->duty_ticks));
+
+done:
+ return HRTIMER_RESTART;
+}
+
+static void gpio_pwm_start(struct pwm_device *p)
+{
+ struct gpio_pwm *gp = pwm_get_drvdata(p);
+
+ gp->active = 0;
+ hrtimer_start(&gp->t, ktime_set(0, p->period_ticks - p->duty_ticks),
+ HRTIMER_MODE_REL);
+ set_bit(PWM_FLAG_RUNNING, &p->flags);
+}
+
+static int gpio_pwm_config_nosleep(struct pwm_device *p, struct pwm_config *c)
+{
+ struct gpio_pwm *gp = pwm_get_drvdata(p);
+ int ret = 0;
+ unsigned long flags;
+
+ spin_lock_irqsave(&gp->lock, flags);
+
+ switch (c->config_mask) {
+
+ case BIT(PWM_CONFIG_DUTY_TICKS):
+ p->duty_ticks = c->duty_ticks;
+ break;
+
+ case BIT(PWM_CONFIG_START):
+ if (!hrtimer_active(&gp->t)) {
+ gpio_pwm_start(p);
+ }
+ break;
+ default:
+ ret = -EINVAL;
+ break;
+ }
+
+ spin_unlock_irqrestore(&gp->lock, flags);
+ return ret;
+}
+
+static int gpio_pwm_stop_sync(struct pwm_device *p)
+{
+ struct gpio_pwm *gp = pwm_get_drvdata(p);
+ int ret;
+ int was_on = hrtimer_active(&gp->t);
+
+ if (was_on) {
+ do {
+ init_completion(&gp->complete);
+ set_bit(PWM_FLAG_STOP, &p->flags);
+ ret = wait_for_completion_interruptible(&gp->complete);
+ if (ret)
+ return ret;
+ } while (test_bit(PWM_FLAG_STOP, &p->flags));
+ }
+
+ clear_bit(PWM_FLAG_RUNNING, &p->flags);
+
+ return was_on;
+}
+
+static int gpio_pwm_config(struct pwm_device *p, struct pwm_config *c)
+{
+ struct gpio_pwm *gp = pwm_get_drvdata(p);
+ int was_on = 0;
+
+ if (!gpio_pwm_config_nosleep(p, c))
+ return 0;
+
+ might_sleep();
+
+ was_on = gpio_pwm_stop_sync(p);
+ if (was_on < 0)
+ return was_on;
+
+ if (test_bit(PWM_CONFIG_PERIOD_TICKS, &c->config_mask))
+ p->period_ticks = c->period_ticks;
+ if (test_bit(PWM_CONFIG_DUTY_TICKS, &c->config_mask))
+ p->duty_ticks = c->duty_ticks;
+ if (test_bit(PWM_CONFIG_POLARITY, &c->config_mask))
+ gp->polarity = !!c->polarity;
+
+ if (test_bit(PWM_CONFIG_START, &c->config_mask)
+ || (was_on && !test_bit(PWM_CONFIG_STOP, &c->config_mask)))
+ gpio_pwm_start(p);
+
+ return 0;
+}
+
+static int gpio_pwm_request(struct pwm_device *p)
+{
+ p->tick_hz = 1000000000UL;
+ return 0;
+}
+
+static const struct pwm_device_ops gpio_pwm_device_ops = {
+ .owner = THIS_MODULE,
+ .config = gpio_pwm_config,
+ .config_nosleep = gpio_pwm_config_nosleep,
+ .request = gpio_pwm_request,
+};
+
+struct pwm_device *gpio_pwm_create(int gpio)
+{
+ struct gpio_pwm *gp;
+ int ret = 0;
+
+ if (!gpio_is_valid(gpio))
+ return ERR_PTR(-EINVAL);
+
+ if (gpio_request(gpio, DRIVER_NAME))
+ return ERR_PTR(-EBUSY);
+
+ gp = kzalloc(sizeof(*gp), GFP_KERNEL);
+ if (!gp)
+ goto err_alloc;
+
+ gp->gpio = gpio;
+ INIT_WORK(&gp->work, gpio_pwm_work);
+ init_completion(&gp->complete);
+ hrtimer_init(&gp->t, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ gp->t.function = gpio_pwm_timeout;
+
+ gp->pwm = pwm_register(&gpio_pwm_device_ops, NULL, "%s:%d", DRIVER_NAME, gpio);
+ if (IS_ERR_OR_NULL(gp->pwm))
+ goto err_pwm_register;
+
+ pwm_set_drvdata(gp->pwm, gp);
+
+ return gp->pwm;
+
+err_pwm_register:
+ kfree(gp);
+err_alloc:
+ gpio_free(gpio);
+ return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(gpio_pwm_create);
+
+int gpio_pwm_destroy(struct pwm_device *p)
+{
+ struct gpio_pwm *gp = pwm_get_drvdata(p);
+
+ if (pwm_is_requested(gp->pwm)) {
+ if (pwm_is_running(gp->pwm))
+ pwm_stop(gp->pwm);
+ pwm_release(gp->pwm);
+ }
+ hrtimer_cancel(&gp->t);
+ cancel_work_sync(&gp->work);
+
+ pwm_unregister(gp->pwm);
+ gpio_free(gp->gpio);
+ kfree(gp);
+
+ return 0;
+}
+EXPORT_SYMBOL(gpio_pwm_destroy);
+
+#ifdef CONFIG_CONFIGFS_FS
+struct gpio_pwm_target {
+ struct config_item item;
+ struct pwm_device *p;
+};
+
+static struct config_item_type gpio_pwm_item_type = {
+ .ct_owner = THIS_MODULE,
+};
+
+static struct config_item *make_gpio_pwm_target(struct config_group *group,
+ const char *name)
+{
+ struct gpio_pwm_target *t;
+ unsigned long gpio;
+ int ret;
+
+ t = kzalloc(sizeof(*t), GFP_KERNEL);
+ if (!t)
+ return ERR_PTR(-ENOMEM);
+
+ ret = strict_strtoul(name, 10, &gpio);
+ if (ret || !gpio_is_valid(gpio)) {
+ ret = -EINVAL;
+ goto err_invalid_gpio;
+ }
+
+ config_item_init_type_name(&t->item, name, &gpio_pwm_item_type);
+
+ t->p = gpio_pwm_create(gpio);
+ if (IS_ERR_OR_NULL(t->p))
+ goto err_gpio_pwm_create;
+
+ return &t->item;
+
+err_gpio_pwm_create:
+err_invalid_gpio:
+ kfree(t);
+ return ERR_PTR(ret);
+}
+
+static void drop_gpio_pwm_target(struct config_group *group,
+ struct config_item *item)
+{
+ struct gpio_pwm_target *t =
+ container_of(item, struct gpio_pwm_target, item);
+
+ gpio_pwm_destroy(t->p);
+ config_item_put(&t->item);
+ kfree(t);
+}
+
+static struct configfs_group_operations gpio_pwm_subsys_group_ops = {
+ .make_item = make_gpio_pwm_target,
+ .drop_item = drop_gpio_pwm_target,
+};
+
+static struct config_item_type gpio_pwm_subsys_type = {
+ .ct_group_ops = &gpio_pwm_subsys_group_ops,
+ .ct_owner = THIS_MODULE,
+};
+
+static struct configfs_subsystem gpio_pwm_subsys = {
+ .su_group = {
+ .cg_item = {
+ .ci_name = DRIVER_NAME,
+ .ci_type = &gpio_pwm_subsys_type,
+ },
+ },
+};
+
+static int __init gpio_pwm_init(void)
+{
+ config_group_init(&gpio_pwm_subsys.su_group);
+ mutex_init(&gpio_pwm_subsys.su_mutex);
+ return configfs_register_subsystem(&gpio_pwm_subsys);
+}
+module_init(gpio_pwm_init);
+
+static void __exit gpio_pwm_exit(void)
+{
+ configfs_unregister_subsystem(&gpio_pwm_subsys);
+}
+module_exit(gpio_pwm_exit);
+#endif
+
+MODULE_AUTHOR("Bill Gatliff <[email protected]>");
+MODULE_DESCRIPTION("PWM channel emulator using GPIO and a high-resolution timer");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/pwm/pwm.h b/include/linux/pwm/pwm.h
index 64707a7..4fac560 100644
--- a/include/linux/pwm/pwm.h
+++ b/include/linux/pwm/pwm.h
@@ -137,4 +137,7 @@ int pwm_config(struct pwm_device *p, struct pwm_config *c);
int pwm_synchronize(struct pwm_device *p, struct pwm_device *to_p);
int pwm_unsynchronize(struct pwm_device *p, struct pwm_device *from_p);
+struct pwm_device *gpio_pwm_create(int gpio);
+int gpio_pwm_destroy(struct pwm_device *p);
+
#endif
--
1.7.4.1
Updates the existing PWM-related functions to support multiple
and/or hotplugged PWM devices, and adds a sysfs interface.
Moves the code to drivers/pwm.
For now, this new code can exist alongside the current PWM
implementations; the existing implementations will be migrated
to this new framework as time permits. Eventually, the current
PWM implementation will be deprecated and then expunged.
Signed-off-by: Bill Gatliff <[email protected]>
---
Documentation/pwm.txt | 276 ++++++++++++++++++++++
MAINTAINERS | 8 +
drivers/Kconfig | 2 +
drivers/Makefile | 2 +
drivers/pwm/Kconfig | 10 +
drivers/pwm/Makefile | 4 +
drivers/pwm/pwm.c | 580 +++++++++++++++++++++++++++++++++++++++++++++++
include/linux/pwm/pwm.h | 140 ++++++++++++
8 files changed, 1022 insertions(+), 0 deletions(-)
create mode 100644 Documentation/pwm.txt
create mode 100644 drivers/pwm/Kconfig
create mode 100644 drivers/pwm/Makefile
create mode 100644 drivers/pwm/pwm.c
create mode 100644 include/linux/pwm/pwm.h
diff --git a/Documentation/pwm.txt b/Documentation/pwm.txt
new file mode 100644
index 0000000..6a0c95d
--- /dev/null
+++ b/Documentation/pwm.txt
@@ -0,0 +1,276 @@
+ Generic PWM Device API
+
+ February 7, 2011
+ Bill Gatliff
+ <[email protected]>
+
+
+
+The code in drivers/pwm and include/linux/pwm/ implements an API for
+applications involving pulse-width-modulation signals. This document
+describes how the API implementation facilitates both PWM-generating
+devices, and users of those devices.
+
+
+Motivation
+
+The primary goals for implementing the "generic PWM API" are to
+consolidate the various PWM implementations within a consistent and
+redundancy-reducing framework, and to facilitate the use of
+hotpluggable PWM devices.
+
+Previous PWM-related implementations within the Linux kernel achieved
+their consistency via cut-and-paste, but did not need to (and didn't)
+facilitate more than one PWM-generating device within the system---
+hotplug or otherwise. The Generic PWM Device API might be most
+appropriately viewed as an update to those implementations, rather
+than a complete rewrite.
+
+
+Challenges
+
+One of the difficulties in implementing a generic PWM framework is the
+fact that pulse-width-modulation applications involve real-world
+signals, which often must be carefully managed to prevent destruction
+of hardware that is linked to those signals. A DC motor that
+experiences a brief interruption in the PWM signal controlling it
+might destructively overheat; it could suddenly change speed, losing
+synchronization with a sensor; it could even suddenly change direction
+or torque, breaking the mechanical device connected to it.
+
+(A generic PWM device framework is not directly responsible for
+preventing the above scenarios: that responsibility lies with the
+hardware designer, and the application and driver authors. But it
+must to the greatest extent possible make it easy to avoid such
+problems).
+
+A generic PWM device framework must accommodate the substantial
+differences between available PWM-generating hardware devices, without
+becoming sub-optimal for any of them.
+
+Finally, a generic PWM device framework must be relatively
+lightweight, computationally speaking. Some PWM users demand
+high-speed outputs, plus the ability to regulate those outputs
+quickly. A device framework must be able to "keep up" with such
+hardware, while still leaving time to do real work.
+
+The Generic PWM Device API is an attempt to meet all of the above
+requirements. At its initial publication, the API was already in use
+managing small DC motors, sensors and solenoids through a
+custom-designed, optically-isolated H-bridge driver.
+
+
+Functional Overview
+
+The Generic PWM Device API framework is implemented in
+include/linux/pwm/pwm.h and drivers/pwm/pwm.c. The functions therein
+use information from pwm_device and pwm_config structures to invoke
+services in PWM peripheral device drivers. Consult
+drivers/pwm/atmel-pwmc.c for an example driver for the Atmel PWMC
+peripheral.
+
+There are two classes of adopters of the PWM framework:
+
+ Users -- those wishing to employ the API merely to produce PWM
+ signals; once they have identified the appropriate physical output
+ on the platform in question, they don't care about the details of
+ the underlying hardware
+
+ Driver authors -- those wishing to bind devices that can generate
+ PWM signals to the Generic PWM Device API, so that the services of
+ those devices become available to users. Assuming the hardware can
+ support the needs of a user, driver authors don't care about the
+ details of the user's application
+
+Generally speaking, users will first invoke pwm_request() to obtain a
+handle to a PWM device. They will then pass that handle to functions
+like pwm_duty_ns() and pwm_period_ns() to set the duty cycle and
+period of the PWM signal, respectively. They will also invoke
+pwm_start() and pwm_stop() to turn the signal on and off.
+
+The Generic PWM API framework also provides a sysfs interface to PWM
+devices, which is adequate for basic application needs and testing.
+
+Driver authors fill out a pwm_device_ops structure, which describes
+the capabilities of the PWM hardware being utilized. They then invoke
+pwm_register() (usually from within their device's probe() handler) to
+make the PWM API aware of their device. The framework will call back
+to the methods described in the pwm_device_ops structure as users
+begin to configure and utilize the hardware.
+
+Many PWM-capable peripherals provide two, three, or more channels of
+PWM output. The driver author calls pwm_register() once for each
+channel they wish to be supported by the Generic PWM API.
+
+Note that PWM signals can be produced by a variety of peripherals,
+beyond the true PWM peripherals offered by many system-on-chip
+devices. Other possibilities include timer/counters with
+compare-match capabilities, carefully-programmed synchronous serial
+ports (e.g. SPI), and GPIO pins driven by kernel interval timers.
+With a proper pwm_device structure, these devices and pseudo-devices
+can be accommodated by the Generic PWM Device API framework.
+
+The following paragraphs describe the basic functions provided by the
+Generic PWM API framework. See the kerneldoc in drivers/pwm/pwm.c for
+the most detailed documentation.
+
+
+Using the API to Generate PWM Signals -- Basic Kernel Functions
+
+pwm_request() -- Returns a pwm_device pointer, which is subsequently
+passed to the other user-related PWM functions. Once requested, a PWM
+channel is marked as in-use and subsequent requests prior to
+pwm_release() will fail.
+
+The names used to refer to PWM devices are defined by driver authors.
+Typically they are platform device bus identifiers, and this
+convention is encouraged for consistency.
+
+pwm_release() -- Marks a PWM channel as no longer in use. The PWM
+device is stopped before it is released by the API.
+
+pwm_period_ns() -- Specifies the PWM signal's period, in nanoseconds.
+
+pwm_duty_ns() -- Specifies the PWM signal's active duration, in nanoseconds.
+
+pwm_duty_percent() -- Specifies the PWM signal's active duration, as a
+percentage of the current period of the signal. NOTE: this value is
+not recalculated if the period of the signal is subsequently changed.
+
+pwm_start(), pwm_stop() -- Turns the PWM signal on and off. Except
+where stated otherwise by a driver author, signals are stopped at the
+end of the current period, at which time the output is set to its
+inactive state.
+
+pwm_polarity() -- Defines whether the PWM signal output's active
+region is "1" or "0". A 10% duty-cycle, polarity=1 signal will
+conventionally be at 5V (or 3.3V, or 1000V, or whatever the platform
+hardware does) for 10% of the period. The same configuration of a
+polarity=0 signal will be at 5V (or 3.3V, or ...) for 90% of the
+period.
+
+
+Using the Sysfs Interface to Generate PWM Signals from Userspace
+
+The Generic PWM API provides the following attributes under
+/sys/class/pwm/<device>/ to allow user applications to control
+and/or monitor PWM signal generation. Except for the 'export'
+attribute, all attributes are read-only if the PWM device is not
+exported to userspace.
+
+export (rw) -- write a label to this attribute to request that the PWM
+device be exported to userspace; returns the length of the label on
+success (for compatibilty with echo/cat), or -EBUSY if the device is
+already in use by the kernel or has already been exported to
+userspace. Read from this attribute to obtain the label of the current
+PWM device owner, if any.
+
+unexport (w) -- write a non-null string to this attribute to release
+the PWM device; the device then becomes available for reexport and/or
+requests. Returns -EBUSY if the device is not currently exported,
+-EINVAL if the device is not currently in use, or the length of the
+string on success.
+
+polarity (rw) -- write an ascii '1' to set active high, or a '0' for
+active low. Read to obtain the current polarity.
+
+period_ns (rw) -- write an ascii decimal number to set the period of
+the PWM device, in nanoseconds. Value written must not be less than
+duty_ns or -EINVAL is returned. Read to determine the current period
+of the PWM device, which might be slightly different than the value
+requested due to hardware limitations.
+
+duty_ns (rw) -- write an ascii decimal number to set the duration of
+the active portion of the PWM period, in nanoseconds; value written
+must not exceed period_ns. Read to obtain current duty_ns, which may
+be slightly different than the value requested due to hardware
+limitations.
+
+tick_hz (r) -- indicates the base tick rate of the underlying
+hardware, in nanoseconds. Returns '0' if the rate is not yet known,
+which might be the case if the device has not been requested yet (some
+drivers don't initialize this value until the hardware is requested,
+because the value is dynamic).
+
+run (rw) -- write '1' to start PWM signal generation, '0' to stop.
+Read to determine whether the PWM device is running or not.
+
+
+Using the API to Generate PWM Signals -- Advanced Functions
+
+pwm_config() -- Passes a pwm_config structure to the associated device
+driver. This function is invoked by pwm_start(), pwm_duty_ns(),
+etc. and is one of two main entry points to the PWM driver for the
+hardware being used. The configuration change is guaranteed atomic if
+multiple configuration changes are specified by the config structure.
+This function might sleep, depending on what the device driver has to
+do to satisfy the request. All PWM device drivers must support this
+entry point.
+
+pwm_config_nosleep() -- Passes a pwm_config structure to the
+associated device driver. If the driver must sleep in order to
+implement the requested configuration change, -EWOULDBLOCK is
+returned. Users may call this function from interrupt handlers, timer
+handlers, and other interrupt contexts, but must confine their
+configuration changes to only those that the driver can implement
+without sleeping. This is the other main entry point into the PWM
+hardware driver, but not all device drivers support this entry point.
+
+pwm_synchronize(), pwm_unsynchronize() -- "Synchronizes" two or more
+PWM channels, if the underlying hardware permits. (If it doesn't, the
+framework facilitates emulating this capability but it is not yet
+implemented). Synchronized channels will start and stop
+simultaneously when any single channel in the group is started or
+stopped. Use pwm_unsynchronize(..., NULL) to completely detach a
+channel from any other synchronized channels. By default, all PWM
+channels are unsynchronized.
+
+
+Implementing a PWM Device API Driver -- Functions for Driver Authors
+
+
+request -- (optional) Invoked each time a user requests a channel.
+Use to turn on clocks, clean up register states, etc. The framework
+takes care of device locking/unlocking; you will see only successful
+requests.
+
+release -- (optional) Invoked each time a user relinquishes a channel.
+The framework will have already stopped, unsynchronized and un-handled
+the channel. Use to turn off clocks, etc. as necessary.
+
+config -- Invoked to change the device configuration, always from a
+sleep-compatible context. All the changes indicated must be performed
+atomically, ideally synchronized to an end-of-period event (so that
+you avoid short or long output pulses). You may sleep, etc. as
+necessary within this function.
+
+config_nosleep -- (optional) Invoked to change device configuration
+from within a context that is not allowed to sleep. If you cannot
+perform the requested configuration changes without sleeping, return
+-EWOULDBLOCK.
+
+
+FAQs and Additional Notes
+
+The Atmel PWMC pwm_config() function tries to satisfy the user's
+configuration request by first invoking pwm_config_nosleep(). If that
+operation fails, then the PWM peripheral is brought to a synchronized
+stop, the configuration changes are made, and the device is restarted.
+
+The Atmel PWMC's use of pwm_config_nosleep() from pwm_config()
+minimizes redundant code between the two functions, and relieves the
+pwm_config() function of the need to explicitly test whether a
+requested configuration change can be carried out while the PWM device
+is in its current mode.
+
+PWM API driver authors are encouraged to adopt the Atmel PWMC's
+pwm_config()-vs.-pwm_config_nosleep() strategy in implementations for
+other devices as well.
+
+
+Acknowledgements
+
+The author expresses his gratitude to the countless developers who
+have reviewed and submitted feedback on the various versions of the
+Generic PWM Device API code, and those who have submitted drivers and
+applications that use the framework. You know who you are. ;)
diff --git a/MAINTAINERS b/MAINTAINERS
index 6b4b9cd..fe55958 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5051,6 +5051,14 @@ S: Maintained
F: Documentation/video4linux/README.pvrusb2
F: drivers/media/video/pvrusb2/
+PWM DEVICE API
+M: Bill Gatliff <[email protected]>
+L: [email protected]
+T: git git://git.billgatliff.com/pwm.git
+S: Maintained
+F: Documentation/pwm.txt
+F: drivers/pwm/
+
PXA2xx/PXA3xx SUPPORT
M: Eric Miao <[email protected]>
M: Russell King <[email protected]>
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 177c7d1..bc75da5 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -56,6 +56,8 @@ source "drivers/pps/Kconfig"
source "drivers/gpio/Kconfig"
+source "drivers/pwm/Kconfig"
+
source "drivers/w1/Kconfig"
source "drivers/power/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 3f135b6..132a823 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -6,6 +6,8 @@
#
obj-y += gpio/
+obj-$(CONFIG_GENERIC_PWM) += pwm/
+
obj-$(CONFIG_PCI) += pci/
obj-$(CONFIG_PARISC) += parisc/
obj-$(CONFIG_RAPIDIO) += rapidio/
diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
new file mode 100644
index 0000000..bc550f7
--- /dev/null
+++ b/drivers/pwm/Kconfig
@@ -0,0 +1,10 @@
+#
+# PWM infrastructure and devices
+#
+
+menuconfig GENERIC_PWM
+ tristate "PWM Support"
+ help
+ Enables PWM device support implemented via a generic
+ framework. If unsure, say N.
+
diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
new file mode 100644
index 0000000..7baa201
--- /dev/null
+++ b/drivers/pwm/Makefile
@@ -0,0 +1,4 @@
+#
+# Makefile for pwm devices
+#
+obj-$(CONFIG_GENERIC_PWM) := pwm.o
diff --git a/drivers/pwm/pwm.c b/drivers/pwm/pwm.c
new file mode 100644
index 0000000..9a08fea
--- /dev/null
+++ b/drivers/pwm/pwm.c
@@ -0,0 +1,580 @@
+/*
+ * PWM API implementation
+ *
+ * Copyright (C) 2011 Bill Gatliff <[email protected]>
+ * Copyright (C) 2011 Arun Murthy <[email protected]>
+ *
+ * This program is free software; you may redistribute and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/fs.h>
+#include <linux/sched.h>
+#include <linux/pwm/pwm.h>
+
+static const char *REQUEST_SYSFS = "sysfs";
+static struct class pwm_class;
+
+void pwm_set_drvdata(struct pwm_device *p, void *data)
+{
+ dev_set_drvdata(&p->dev, data);
+}
+EXPORT_SYMBOL(pwm_set_drvdata);
+
+void *pwm_get_drvdata(const struct pwm_device *p)
+{
+ return dev_get_drvdata(&p->dev);
+}
+EXPORT_SYMBOL(pwm_get_drvdata);
+
+static inline struct pwm_device *to_pwm_device(struct device *dev)
+{
+ return container_of(dev, struct pwm_device, dev);
+}
+
+static int pwm_match_name(struct device *dev, void *name)
+{
+ return !strcmp(name, dev_name(dev));
+}
+
+static int __pwm_request(struct pwm_device *p, const char *label)
+{
+ int ret;
+
+ if (!try_module_get(p->ops->owner))
+ return -ENODEV;
+
+ ret = test_and_set_bit(PWM_FLAG_REQUESTED, &p->flags);
+ if (ret) {
+ ret = -EBUSY;
+ goto err_flag_requested;
+ }
+
+ p->label = label;
+
+ if (p->ops->request) {
+ ret = p->ops->request(p);
+ if (ret)
+ goto err_request_ops;
+
+ }
+
+ return 0;
+
+err_request_ops:
+ clear_bit(PWM_FLAG_REQUESTED, &p->flags);
+
+err_flag_requested:
+ module_put(p->ops->owner);
+ return ret;
+}
+
+/**
+ * pwm_request - request a PWM device by name
+ *
+ * @name: name of PWM device
+ * @label: label that identifies requestor
+ *
+ * The @name format is driver-specific, but is typically of the form
+ * "<bus_id>:<chan>". For example, "atmel_pwmc:1" identifies the
+ * second ATMEL PWMC peripheral channel.
+ *
+ * Returns a pointer to the requested PWM device on success, -EINVAL
+ * otherwise.
+ */
+struct pwm_device *pwm_request(const char *name, const char *label)
+{
+ struct device *d;
+ struct pwm_device *p;
+ int ret;
+
+ d = class_find_device(&pwm_class, NULL, (char*)name, pwm_match_name);
+ if (!d)
+ return ERR_PTR(-EINVAL);
+
+ p = to_pwm_device(d);
+ ret = __pwm_request(p, label);
+ if (ret) {
+ put_device(d);
+ return ERR_PTR(ret);
+ }
+
+ return p;
+}
+EXPORT_SYMBOL(pwm_request);
+
+/**
+ * pwm_release - releases a previously-requested PWM channel
+ *
+ * @p: PWM device to release
+ */
+void pwm_release(struct pwm_device *p)
+{
+ if (!test_and_clear_bit(PWM_FLAG_REQUESTED, &p->flags)) {
+ WARN(1, "%s: releasing unrequested PWM device %s\n",
+ __func__, dev_name(&p->dev));
+ return;
+ }
+
+ pwm_stop(p);
+ pwm_unsynchronize(p, NULL);
+ p->label = NULL;
+
+ if (p->ops->release)
+ p->ops->release(p);
+
+ put_device(&p->dev);
+ module_put(p->ops->owner);
+}
+EXPORT_SYMBOL(pwm_release);
+
+static unsigned long pwm_ns_to_ticks(struct pwm_device *p, unsigned long nsecs)
+{
+ unsigned long long ticks;
+
+ ticks = nsecs;
+ ticks *= p->tick_hz;
+ do_div(ticks, 1000000000);
+ return ticks;
+}
+
+static unsigned long pwm_ticks_to_ns(struct pwm_device *p, unsigned long ticks)
+{
+ unsigned long long ns;
+
+ if (!p->tick_hz)
+ return 0;
+
+ ns = ticks;
+ ns *= 1000000000UL;
+ do_div(ns, p->tick_hz);
+ return ns;
+}
+
+/**
+ * pwm_config_nosleep - configures a PWM device in an atomic context
+ *
+ * @p: PWM device to configure
+ * @c: configuration to apply to the PWM device
+ *
+ * Returns whatever the PWM device driver's config_nosleep() returns,
+ * or -ENOSYS if the PWM device driver does not have a
+ * config_nosleep() method.
+ */
+int pwm_config_nosleep(struct pwm_device *p, struct pwm_config *c)
+{
+ if (!p->ops->config_nosleep)
+ return -ENOSYS;
+
+ return p->ops->config_nosleep(p, c);
+}
+EXPORT_SYMBOL(pwm_config_nosleep);
+
+/**
+ * pwm_config - configures a PWM device
+ *
+ * @p: PWM device to configure
+ * @c: configuration to apply to the PWM device
+ *
+ * Performs some basic sanity checking of the parameters, and returns
+ * -EINVAL if they are found to be invalid. Otherwise, returns
+ * whatever the PWM device's config() method returns.
+ */
+int pwm_config(struct pwm_device *p, struct pwm_config *c)
+{
+ int ret = 0;
+
+ dev_dbg(&p->dev, "%s: config_mask %lu period_ticks %lu "
+ "duty_ticks %lu polarity %d\n",
+ __func__, c->config_mask, c->period_ticks,
+ c->duty_ticks, c->polarity);
+
+ switch (c->config_mask & (BIT(PWM_CONFIG_PERIOD_TICKS)
+ | BIT(PWM_CONFIG_DUTY_TICKS))) {
+ case BIT(PWM_CONFIG_PERIOD_TICKS):
+ if (p->duty_ticks > c->period_ticks)
+ ret = -EINVAL;
+ break;
+ case BIT(PWM_CONFIG_DUTY_TICKS):
+ if (p->period_ticks < c->duty_ticks)
+ ret = -EINVAL;
+ break;
+ case BIT(PWM_CONFIG_DUTY_TICKS) | BIT(PWM_CONFIG_PERIOD_TICKS):
+ if (c->duty_ticks > c->period_ticks)
+ ret = -EINVAL;
+ break;
+ default:
+ break;
+ }
+
+ if (ret)
+ return ret;
+ return p->ops->config(p, c);
+}
+EXPORT_SYMBOL(pwm_config);
+
+/**
+ * pwm_set - compatibility function to ease migration from older code
+ * @p: the PWM device to configure
+ * @period_ns: period of the desired PWM signal, in nanoseconds
+ * @duty_ns: duration of active portion of desired PWM signal, in nanoseconds
+ * @polarity: 1 if active period is high, zero otherwise
+ */
+int pwm_set(struct pwm_device *p, unsigned long period_ns,
+ unsigned long duty_ns, int polarity)
+{
+ struct pwm_config c = {
+ .config_mask = (BIT(PWM_CONFIG_PERIOD_TICKS)
+ | BIT(PWM_CONFIG_DUTY_TICKS)
+ | BIT(PWM_CONFIG_POLARITY)),
+ .period_ticks = pwm_ns_to_ticks(p, period_ns),
+ .duty_ticks = pwm_ns_to_ticks(p, duty_ns),
+ .polarity = polarity
+ };
+
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_set);
+
+int pwm_set_period_ns(struct pwm_device *p, unsigned long period_ns)
+{
+ struct pwm_config c = {
+ .config_mask = BIT(PWM_CONFIG_PERIOD_TICKS),
+ .period_ticks = pwm_ns_to_ticks(p, period_ns),
+ };
+
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_set_period_ns);
+
+unsigned long pwm_get_period_ns(struct pwm_device *p)
+{
+ return pwm_ticks_to_ns(p, p->period_ticks);
+}
+EXPORT_SYMBOL(pwm_get_period_ns);
+
+int pwm_set_duty_ns(struct pwm_device *p, unsigned long duty_ns)
+{
+ struct pwm_config c = {
+ .config_mask = BIT(PWM_CONFIG_DUTY_TICKS),
+ .duty_ticks = pwm_ns_to_ticks(p, duty_ns),
+ };
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_set_duty_ns);
+
+unsigned long pwm_get_duty_ns(struct pwm_device *p)
+{
+ return pwm_ticks_to_ns(p, p->duty_ticks);
+}
+EXPORT_SYMBOL(pwm_get_duty_ns);
+
+int pwm_set_polarity(struct pwm_device *p, int polarity)
+{
+ struct pwm_config c = {
+ .config_mask = BIT(PWM_CONFIG_POLARITY),
+ .polarity = polarity,
+ };
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_set_polarity);
+
+int pwm_start(struct pwm_device *p)
+{
+ struct pwm_config c = {
+ .config_mask = BIT(PWM_CONFIG_START),
+ };
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_start);
+
+int pwm_stop(struct pwm_device *p)
+{
+ struct pwm_config c = {
+ .config_mask = BIT(PWM_CONFIG_STOP),
+ };
+ return pwm_config(p, &c);
+}
+EXPORT_SYMBOL(pwm_stop);
+
+int pwm_synchronize(struct pwm_device *p, struct pwm_device *to_p)
+{
+ if (!p->ops->synchronize)
+ return -ENOSYS;
+
+ return p->ops->synchronize(p, to_p);
+}
+EXPORT_SYMBOL(pwm_synchronize);
+
+int pwm_unsynchronize(struct pwm_device *p, struct pwm_device *from_p)
+{
+ if (!p->ops->unsynchronize)
+ return -ENOSYS;
+
+ return p->ops->unsynchronize(p, from_p);
+}
+EXPORT_SYMBOL(pwm_unsynchronize);
+
+static ssize_t pwm_run_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ return sprintf(buf, "%d\n", pwm_is_running(p));
+}
+
+static ssize_t pwm_run_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+
+ if (!pwm_is_exported(p))
+ return -EPERM;
+
+ if (sysfs_streq(buf, "1"))
+ pwm_start(p);
+ else if (sysfs_streq(buf, "0"))
+ pwm_stop(p);
+ else
+ return -EINVAL;
+
+ return len;
+}
+
+static ssize_t pwm_tick_hz_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ return sprintf(buf, "%lu\n", p->tick_hz);
+}
+
+static ssize_t pwm_duty_ns_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ return sprintf(buf, "%lu\n", pwm_get_duty_ns(p));
+}
+
+static ssize_t pwm_duty_ns_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ unsigned long duty_ns;
+ struct pwm_device *p = to_pwm_device(dev);
+ int ret;
+
+ if (!pwm_is_exported(p))
+ return -EPERM;
+
+ ret = strict_strtoul(buf, 10, &duty_ns);
+ if (ret)
+ return ret;
+ pwm_set_duty_ns(p, duty_ns);
+ return len;
+}
+
+static ssize_t pwm_period_ns_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ return sprintf(buf, "%lu\n", pwm_get_period_ns(p));
+}
+
+static ssize_t pwm_period_ns_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ unsigned long period_ns;
+ struct pwm_device *p = to_pwm_device(dev);
+ int ret;
+
+ if (!pwm_is_exported(p))
+ return -EPERM;
+
+ ret = strict_strtoul(buf, 10, &period_ns);
+ if (ret)
+ return ret;
+
+ pwm_set_period_ns(p, period_ns);
+ return len;
+}
+
+static ssize_t pwm_polarity_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ return sprintf(buf, "%d\n", p->polarity ? 1 : 0);
+}
+
+static ssize_t pwm_polarity_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ unsigned long polarity;
+ struct pwm_device *p = to_pwm_device(dev);
+ int ret;
+
+ if (!pwm_is_exported(p))
+ return -EPERM;
+
+ ret = strict_strtoul(buf, 10, &polarity);
+ if (ret)
+ return ret;
+
+ pwm_set_polarity(p, polarity);
+ return len;
+}
+
+static ssize_t pwm_export_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+
+ if (pwm_is_requested(p))
+ return sprintf(buf, "%s\n", p->label);
+ return 0;
+}
+
+static ssize_t pwm_export_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+ int ret;
+
+ get_device(dev);
+ ret = __pwm_request(p, REQUEST_SYSFS);
+
+ if (!ret)
+ set_bit(PWM_FLAG_EXPORTED, &p->flags);
+ else {
+ put_device(dev);
+ ret = -EBUSY;
+ }
+
+ return ret ? ret : len;
+}
+
+static ssize_t pwm_unexport_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct pwm_device *p = to_pwm_device(dev);
+
+ if (!pwm_is_exported(p))
+ return -EINVAL;
+
+ pwm_release(p);
+ clear_bit(PWM_FLAG_EXPORTED, &p->flags);
+ return len;
+}
+
+static struct device_attribute pwm_dev_attrs[] = {
+ __ATTR(export, S_IRUGO | S_IWUSR, pwm_export_show, pwm_export_store),
+ __ATTR(unexport, S_IWUSR, NULL, pwm_unexport_store),
+ __ATTR(polarity, S_IRUGO | S_IWUSR, pwm_polarity_show, pwm_polarity_store),
+ __ATTR(period_ns, S_IRUGO | S_IWUSR, pwm_period_ns_show, pwm_period_ns_store),
+ __ATTR(duty_ns, S_IRUGO | S_IWUSR, pwm_duty_ns_show, pwm_duty_ns_store),
+ __ATTR(tick_hz, S_IRUGO, pwm_tick_hz_show, NULL),
+ __ATTR(run, S_IRUGO | S_IWUSR, pwm_run_show, pwm_run_store),
+ __ATTR_NULL,
+};
+
+static struct class pwm_class = {
+ .name = "pwm",
+ .owner = THIS_MODULE,
+ .dev_attrs = pwm_dev_attrs,
+};
+
+static void __pwm_release(struct device *dev)
+{
+ struct pwm_device *p = container_of(dev, struct pwm_device, dev);
+ kfree(p);
+}
+
+/**
+ * pwm_register - registers a PWM device
+ *
+ * @ops: PWM device operations
+ * @parent: reference to parent device, if any
+ * @fmt: printf-style format specifier for device name
+ */
+struct pwm_device *pwm_register(const struct pwm_device_ops *ops,
+ struct device *parent, const char *fmt, ...)
+{
+ struct pwm_device *p;
+ int ret;
+ va_list vargs;
+
+ if (!ops || !ops->config)
+ return ERR_PTR(-EINVAL);
+
+ p = kzalloc(sizeof(*p), GFP_KERNEL);
+ if (!p)
+ return ERR_PTR(-ENOMEM);
+
+ p->ops = ops;
+
+ p->dev.class = &pwm_class;
+ p->dev.parent = parent;
+ p->dev.release = __pwm_release;
+
+ va_start(vargs, fmt);
+ ret = kobject_set_name_vargs(&p->dev.kobj, fmt, vargs);
+
+ ret = device_register(&p->dev);
+ if (ret)
+ goto err;
+
+ return p;
+
+err:
+ put_device(&p->dev);
+ return ERR_PTR(ret);
+}
+EXPORT_SYMBOL(pwm_register);
+
+void pwm_unregister(struct pwm_device *p)
+{
+ device_unregister(&p->dev);
+}
+EXPORT_SYMBOL(pwm_unregister);
+
+static int __init pwm_init(void)
+{
+ return class_register(&pwm_class);
+}
+
+static void __exit pwm_exit(void)
+{
+ class_unregister(&pwm_class);
+}
+
+postcore_initcall(pwm_init);
+module_exit(pwm_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Bill Gatliff <[email protected]>");
+MODULE_DESCRIPTION("Generic PWM device API implementation");
diff --git a/include/linux/pwm/pwm.h b/include/linux/pwm/pwm.h
new file mode 100644
index 0000000..64707a7
--- /dev/null
+++ b/include/linux/pwm/pwm.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2011 Bill Gatliff <[email protected]>
+ * Copyright (C) 2011 Arun Murthy <[email protected]>
+ *
+ * This program is free software; you may redistribute and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+#ifndef __LINUX_PWM_H
+#define __LINUX_PWM_H
+
+#include <linux/device.h>
+
+enum {
+ PWM_FLAG_REQUESTED = 0,
+ PWM_FLAG_STOP = 1,
+ PWM_FLAG_RUNNING = 2,
+ PWM_FLAG_EXPORTED = 3,
+};
+
+enum {
+ PWM_CONFIG_DUTY_TICKS = 0,
+ PWM_CONFIG_PERIOD_TICKS = 1,
+ PWM_CONFIG_POLARITY = 2,
+ PWM_CONFIG_START = 3,
+ PWM_CONFIG_STOP = 4,
+};
+
+struct pwm_config;
+struct pwm_device;
+
+struct pwm_device_ops {
+ struct module *owner;
+
+ int (*request) (struct pwm_device *p);
+ void (*release) (struct pwm_device *p);
+ int (*config) (struct pwm_device *p,
+ struct pwm_config *c);
+ int (*config_nosleep) (struct pwm_device *p,
+ struct pwm_config *c);
+ int (*synchronize) (struct pwm_device *p,
+ struct pwm_device *to_p);
+ int (*unsynchronize) (struct pwm_device *p,
+ struct pwm_device *from_p);
+};
+
+/**
+ * struct pwm_config - configuration data for a PWM device
+ *
+ * @config_mask: which fields are valid
+ * @duty_ticks: requested duty cycle, in ticks
+ * @period_ticks: requested period, in ticks
+ * @polarity: active high (1), or active low (0)
+ */
+struct pwm_config {
+ unsigned long config_mask;
+ unsigned long duty_ticks;
+ unsigned long period_ticks;
+ int polarity;
+};
+
+/**
+ * struct pwm_device - represents a PWM device
+ *
+ * @dev: device model reference
+ * @ops: operations supported by the PWM device
+ * @label: requestor of the PWM device, or NULL
+ * @flags: PWM device state, see FLAG_*
+ * @tick_hz: base tick rate of PWM device, in HZ
+ * @polarity: active high (1), or active low (0)
+ * @period_ticks: PWM device's current period, in ticks
+ * @duty_ticks: duration of PWM device's active cycle, in ticks
+ */
+struct pwm_device {
+ struct device dev;
+ const struct pwm_device_ops *ops;
+ const char *label;
+ unsigned long flags;
+ unsigned long tick_hz;
+ int polarity;
+ unsigned long period_ticks;
+ unsigned long duty_ticks;
+};
+
+struct pwm_device *pwm_request(const char *name, const char *label);
+void pwm_release(struct pwm_device *p);
+
+static inline int pwm_is_requested(const struct pwm_device *p)
+{
+ return test_bit(PWM_FLAG_REQUESTED, &p->flags);
+}
+
+static inline int pwm_is_running(const struct pwm_device *p)
+{
+ return test_bit(PWM_FLAG_RUNNING, &p->flags);
+}
+
+static inline int pwm_is_exported(const struct pwm_device *p)
+{
+ return test_bit(PWM_FLAG_EXPORTED, &p->flags);
+}
+
+struct pwm_device *pwm_register(const struct pwm_device_ops *ops, struct device *parent,
+ const char *fmt, ...);
+void pwm_unregister(struct pwm_device *p);
+
+void pwm_set_drvdata(struct pwm_device *p, void *data);
+void *pwm_get_drvdata(const struct pwm_device *p);
+
+int pwm_set(struct pwm_device *p, unsigned long period_ns,
+ unsigned long duty_ns, int polarity);
+
+int pwm_set_period_ns(struct pwm_device *p, unsigned long period_ns);
+unsigned long pwm_get_period_ns(struct pwm_device *p);
+
+int pwm_set_duty_ns(struct pwm_device *p, unsigned long duty_ns);
+unsigned long pwm_get_duty_ns(struct pwm_device *p);
+
+int pwm_set_polarity(struct pwm_device *p, int polarity);
+
+int pwm_start(struct pwm_device *p);
+int pwm_stop(struct pwm_device *p);
+
+int pwm_config_nosleep(struct pwm_device *p, struct pwm_config *c);
+int pwm_config(struct pwm_device *p, struct pwm_config *c);
+
+int pwm_synchronize(struct pwm_device *p, struct pwm_device *to_p);
+int pwm_unsynchronize(struct pwm_device *p, struct pwm_device *from_p);
+
+#endif
--
1.7.4.1
Hi Bill,
I tested this series on da850evm from commit
60124de319dc2800c0f75f44bf84471a8de0dbc5 of
git://git.billgatliff.com/pwm.git.
With the following commands I was able to observe the production of a
100Hz 50% output on a GPIO (specifically GPIO #125 which is GPIO7[13]
on the SoC and J15[13] on the baseboard for other da850 users).
mount config /config -t configfs
mkdir /config/gpio_pwm/125
echo 1 > /sys/class/pwm/gpio_pwm\:125/export
echo 10000000 > /sys/class/pwm/gpio_pwm\:125/period_ns
echo 5000000 > /sys/class/pwm/gpio_pwm\:125/duty_ns
echo 1 > /sys/class/pwm/gpio_pwm\:125/run
I noticed that the following command did not stop the pwm output.
echo 0 > /sys/class/pwm/gpio_pwm\:125/run
But the following command did (and I did not need to echo 1 >
/sys/class/pwm/gpio_pwm\:125/unexport first)
rm -rf /config/gpio_pwm/125
The observations from my testing above are repeated in context below:
On Thu, Mar 31, 2011 at 11:59 PM, Bill Gatliff <[email protected]> wrote:
> Emulates a PWM device using a GPIO pin and an hrtimer. ?Subject
> to CPU, scheduler and hardware limitations, can support many
> PWM outputs, e.g. as many as you have GPIO pins available for.
>
> On a 200 MHz ARM9 processor, a PWM frequency of 100 Hz can be attained
> with this code so long as the duty cycle remains between about 20-80%.
> At higher or lower duty cycles, the transition events may arrive too
> close for the scheduler and CPU to reliably service.
>
> This driver supports creation of new GPIO+hrtimer PWM devices via
> configfs:
>
> ? # mount config /config -t configfs
> ? # mkdir /config/gpio-pwm/<gpio number>
minor: I observed that the configfs directory was 'gpio_pwm' not 'gpio-pwm.'
> The new PWM device will appear as /sys/class/pwm/gpio-pwm.<gpio number>.
>
> Caveats:
> ? * The GPIO pin number must be valid, not already in use
> ? * The output state of the GPIO pin is configured when the PWM starts
> ? ? running i.e. not immediately upon request, because the polarity of
> ? ? the inactive state of the pin isn't known until the pwm device's
> ? ? 'polarity' attribute is configured
> ? * After creating and binding the pwm device, you must then request
> ? ? it by writing to /sys/class/pwm/gpio-pwm.<gpio number>/export
>
> Unbind and destroy the pwm device by first stopping and unexporting
> the pwm device under sysfs as usual; then do:
I observed that
# echo 0 > /sys/class/pwm/gpio_pwm\:125/run
did not stop the pwm output and that
# echo 1 > /sys/class/pwm/gpio_pwm\:125/unexport
was not required before rm -rf'ing the /config directory:
> ? # rm -rf /config/gpio-pwm/<gpio number>
> Signed-off-by: Bill Gatliff <[email protected]>
Overall this is a really easy to user userspace interface -- it was a
pleasure to setup and test.
Tested-by: Ben Gardiner <[email protected]>
Best Regards,
Ben Gardiner
---
Nanometrics Inc.
http://www.nanometrics.ca
Guys:
Anyone have any comment on this patch series? Is it finally ready for Linus?
Thanks!
b.g.
On Thu, Mar 31, 2011 at 10:59 PM, Bill Gatliff <[email protected]> wrote:
> This patch series contains the ninth attempt at implementation of a
> generic PWM device interface framework. ?Think gpiolib, but for
> devices and pseudo-devices that generate pulse-wave-modulated outputs.
>
> Compared to the previous version, this patch series:
>
> ?* Fixes an unbalanced get_device()/put_device()
>
> A git tree containing these patches may be found here:
>
> ? ?http://git.billgatliff.com/pwm.git
>
>
> Regards,
>
>
> b.g.
>
> Bill Gatliff (3):
> ?PWM: Implement a generic PWM framework
> ?PWM: GPIO+hrtimer device emulation
> ?PWM: Atmel PWMC driver
>
> ?Documentation/pwm.txt ? ?| ?276 ++++++++++++++++++++++
> ?MAINTAINERS ? ? ? ? ? ? ?| ? ?8 +
> ?drivers/Kconfig ? ? ? ? ?| ? ?2 +
> ?drivers/Makefile ? ? ? ? | ? ?2 +
> ?drivers/pwm/Kconfig ? ? ?| ? 29 +++
> ?drivers/pwm/Makefile ? ? | ? ?7 +
> ?drivers/pwm/atmel-pwmc.c | ?452 ++++++++++++++++++++++++++++++++++++
> ?drivers/pwm/gpio-pwm.c ? | ?332 ++++++++++++++++++++++++++
> ?drivers/pwm/pwm.c ? ? ? ?| ?580 ++++++++++++++++++++++++++++++++++++++++++++++
> ?include/linux/pwm/pwm.h ?| ?143 ++++++++++++
> ?10 files changed, 1831 insertions(+), 0 deletions(-)
> ?create mode 100644 Documentation/pwm.txt
> ?create mode 100644 drivers/pwm/Kconfig
> ?create mode 100644 drivers/pwm/Makefile
> ?create mode 100644 drivers/pwm/atmel-pwmc.c
> ?create mode 100644 drivers/pwm/gpio-pwm.c
> ?create mode 100644 drivers/pwm/pwm.c
> ?create mode 100644 include/linux/pwm/pwm.h
>
> --
> 1.7.4.1
>
>
--
Bill Gatliff
[email protected]
On Thursday, April 14, 2011 8:13 AM, Bill Gatliff wrote:
>
> Guys:
>
>
> Anyone have any comment on this patch series? Is it finally ready for Linus?
>
Bill,
I looked at a previous release quite a while ago to see how the ep93xx pwm driver
could use it. I'll try to look at this release in the next couple days and provide
some feedback.
Regards,
Hartley-
Hi Bill,
Comments below...
[cc'ing Greg & Kay regarding the use of device class (comment near the bottom)]
On Thu, Mar 31, 2011 at 9:59 PM, Bill Gatliff <[email protected]> wrote:
> Updates the existing PWM-related functions to support multiple
> and/or hotplugged PWM devices, and adds a sysfs interface.
> Moves the code to drivers/pwm.
>
> For now, this new code can exist alongside the current PWM
> implementations; the existing implementations will be migrated
> to this new framework as time permits. ?Eventually, the current
> PWM implementation will be deprecated and then expunged.
>
> Signed-off-by: Bill Gatliff <[email protected]>
> ---
> ?Documentation/pwm.txt ? | ?276 ++++++++++++++++++++++
> ?MAINTAINERS ? ? ? ? ? ? | ? ?8 +
> ?drivers/Kconfig ? ? ? ? | ? ?2 +
> ?drivers/Makefile ? ? ? ?| ? ?2 +
> ?drivers/pwm/Kconfig ? ? | ? 10 +
> ?drivers/pwm/Makefile ? ?| ? ?4 +
> ?drivers/pwm/pwm.c ? ? ? | ?580 +++++++++++++++++++++++++++++++++++++++++++++++
> ?include/linux/pwm/pwm.h | ?140 ++++++++++++
> ?8 files changed, 1022 insertions(+), 0 deletions(-)
> ?create mode 100644 Documentation/pwm.txt
> ?create mode 100644 drivers/pwm/Kconfig
> ?create mode 100644 drivers/pwm/Makefile
> ?create mode 100644 drivers/pwm/pwm.c
> ?create mode 100644 include/linux/pwm/pwm.h
>
> diff --git a/Documentation/pwm.txt b/Documentation/pwm.txt
> new file mode 100644
> index 0000000..6a0c95d
> --- /dev/null
> +++ b/Documentation/pwm.txt
> @@ -0,0 +1,276 @@
> + ? ? ? ? ? ? ? ? ? ? ? Generic PWM Device API
> +
> + ? ? ? ? ? ? ? ? ? ? ? ? ?February 7, 2011
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ?Bill Gatliff
> + ? ? ? ? ? ? ? ? ? ? ? ?<[email protected]>
> +
> +
> +
> +The code in drivers/pwm and include/linux/pwm/ implements an API for
> +applications involving pulse-width-modulation signals. ?This document
> +describes how the API implementation facilitates both PWM-generating
> +devices, and users of those devices.
Good documentation!
> +
> +
> +Motivation
> +
> +The primary goals for implementing the "generic PWM API" are to
> +consolidate the various PWM implementations within a consistent and
> +redundancy-reducing framework, and to facilitate the use of
> +hotpluggable PWM devices.
> +
> +Previous PWM-related implementations within the Linux kernel achieved
> +their consistency via cut-and-paste, but did not need to (and didn't)
> +facilitate more than one PWM-generating device within the system---
> +hotplug or otherwise. ?The Generic PWM Device API might be most
> +appropriately viewed as an update to those implementations, rather
> +than a complete rewrite.
> +
> +
> +Challenges
> +
> +One of the difficulties in implementing a generic PWM framework is the
> +fact that pulse-width-modulation applications involve real-world
> +signals, which often must be carefully managed to prevent destruction
> +of hardware that is linked to those signals. ?A DC motor that
> +experiences a brief interruption in the PWM signal controlling it
> +might destructively overheat; it could suddenly change speed, losing
> +synchronization with a sensor; it could even suddenly change direction
> +or torque, breaking the mechanical device connected to it.
> +
> +(A generic PWM device framework is not directly responsible for
> +preventing the above scenarios: that responsibility lies with the
> +hardware designer, and the application and driver authors. ?But it
> +must to the greatest extent possible make it easy to avoid such
> +problems).
> +
> +A generic PWM device framework must accommodate the substantial
> +differences between available PWM-generating hardware devices, without
> +becoming sub-optimal for any of them.
> +
> +Finally, a generic PWM device framework must be relatively
> +lightweight, computationally speaking. ?Some PWM users demand
> +high-speed outputs, plus the ability to regulate those outputs
> +quickly. ?A device framework must be able to "keep up" with such
> +hardware, while still leaving time to do real work.
> +
> +The Generic PWM Device API is an attempt to meet all of the above
> +requirements. ?At its initial publication, the API was already in use
> +managing small DC motors, sensors and solenoids through a
> +custom-designed, optically-isolated H-bridge driver.
> +
> +
> +Functional Overview
> +
> +The Generic PWM Device API framework is implemented in
> +include/linux/pwm/pwm.h and drivers/pwm/pwm.c. ?The functions therein
> +use information from pwm_device and pwm_config structures to invoke
> +services in PWM peripheral device drivers. ?Consult
> +drivers/pwm/atmel-pwmc.c for an example driver for the Atmel PWMC
> +peripheral.
> +
> +There are two classes of adopters of the PWM framework:
> +
> + ?Users -- those wishing to employ the API merely to produce PWM
> + ?signals; once they have identified the appropriate physical output
> + ?on the platform in question, they don't care about the details of
> + ?the underlying hardware
> +
> + ?Driver authors -- those wishing to bind devices that can generate
> + ?PWM signals to the Generic PWM Device API, so that the services of
> + ?those devices become available to users. Assuming the hardware can
> + ?support the needs of a user, driver authors don't care about the
> + ?details of the user's application
> +
> +Generally speaking, users will first invoke pwm_request() to obtain a
> +handle to a PWM device. ?They will then pass that handle to functions
> +like pwm_duty_ns() and pwm_period_ns() to set the duty cycle and
> +period of the PWM signal, respectively. ?They will also invoke
> +pwm_start() and pwm_stop() to turn the signal on and off.
> +
> +The Generic PWM API framework also provides a sysfs interface to PWM
> +devices, which is adequate for basic application needs and testing.
> +
> +Driver authors fill out a pwm_device_ops structure, which describes
> +the capabilities of the PWM hardware being utilized. ?They then invoke
> +pwm_register() (usually from within their device's probe() handler) to
> +make the PWM API aware of their device. ?The framework will call back
> +to the methods described in the pwm_device_ops structure as users
> +begin to configure and utilize the hardware.
> +
> +Many PWM-capable peripherals provide two, three, or more channels of
> +PWM output. ?The driver author calls pwm_register() once for each
> +channel they wish to be supported by the Generic PWM API.
> +
> +Note that PWM signals can be produced by a variety of peripherals,
> +beyond the true PWM peripherals offered by many system-on-chip
> +devices. ?Other possibilities include timer/counters with
> +compare-match capabilities, carefully-programmed synchronous serial
> +ports (e.g. SPI), and GPIO pins driven by kernel interval timers.
> +With a proper pwm_device structure, these devices and pseudo-devices
> +can be accommodated by the Generic PWM Device API framework.
> +
> +The following paragraphs describe the basic functions provided by the
> +Generic PWM API framework. ?See the kerneldoc in drivers/pwm/pwm.c for
> +the most detailed documentation.
> +
> +
> +Using the API to Generate PWM Signals -- Basic Kernel Functions
> +
> +pwm_request() -- Returns a pwm_device pointer, which is subsequently
> +passed to the other user-related PWM functions. ?Once requested, a PWM
> +channel is marked as in-use and subsequent requests prior to
> +pwm_release() will fail.
> +
> +The names used to refer to PWM devices are defined by driver authors.
> +Typically they are platform device bus identifiers, and this
> +convention is encouraged for consistency.
> +
> +pwm_release() -- Marks a PWM channel as no longer in use. ?The PWM
> +device is stopped before it is released by the API.
> +
> +pwm_period_ns() -- Specifies the PWM signal's period, in nanoseconds.
> +
> +pwm_duty_ns() -- Specifies the PWM signal's active duration, in nanoseconds.
> +
> +pwm_duty_percent() -- Specifies the PWM signal's active duration, as a
> +percentage of the current period of the signal. ?NOTE: this value is
> +not recalculated if the period of the signal is subsequently changed.
> +
> +pwm_start(), pwm_stop() -- Turns the PWM signal on and off. ?Except
> +where stated otherwise by a driver author, signals are stopped at the
> +end of the current period, at which time the output is set to its
> +inactive state.
> +
> +pwm_polarity() -- Defines whether the PWM signal output's active
> +region is "1" or "0". ?A 10% duty-cycle, polarity=1 signal will
> +conventionally be at 5V (or 3.3V, or 1000V, or whatever the platform
> +hardware does) for 10% of the period. ?The same configuration of a
> +polarity=0 signal will be at 5V (or 3.3V, or ...) for 90% of the
> +period.
API looks mostly sane, but more comments on it below at the actual declaration.
> +
> +
> +Using the Sysfs Interface to Generate PWM Signals from Userspace
> +
> +The Generic PWM API provides the following attributes under
> +/sys/class/pwm/<device>/ to allow user applications to control
> +and/or monitor PWM signal generation. ?Except for the 'export'
> +attribute, all attributes are read-only if the PWM device is not
> +exported to userspace.
> +
> +export (rw) -- write a label to this attribute to request that the PWM
> +device be exported to userspace; returns the length of the label on
> +success (for compatibilty with echo/cat), or -EBUSY if the device is
> +already in use by the kernel or has already been exported to
> +userspace. Read from this attribute to obtain the label of the current
> +PWM device owner, if any.
> +
> +unexport (w) -- write a non-null string to this attribute to release
> +the PWM device; the device then becomes available for reexport and/or
> +requests. ?Returns -EBUSY if the device is not currently exported,
> +-EINVAL if the device is not currently in use, or the length of the
> +string on success.
> +
> +polarity (rw) -- write an ascii '1' to set active high, or a '0' for
> +active low. ?Read to obtain the current polarity.
> +
> +period_ns (rw) -- write an ascii decimal number to set the period of
> +the PWM device, in nanoseconds. ?Value written must not be less than
> +duty_ns or -EINVAL is returned. ?Read to determine the current period
> +of the PWM device, which might be slightly different than the value
> +requested due to hardware limitations.
> +
> +duty_ns (rw) -- write an ascii decimal number to set the duration of
> +the active portion of the PWM period, in nanoseconds; value written
> +must not exceed period_ns. ?Read to obtain current duty_ns, which may
> +be slightly different than the value requested due to hardware
> +limitations.
> +
> +tick_hz (r) -- indicates the base tick rate of the underlying
> +hardware, in nanoseconds. ?Returns '0' if the rate is not yet known,
> +which might be the case if the device has not been requested yet (some
> +drivers don't initialize this value until the hardware is requested,
> +because the value is dynamic).
> +
> +run (rw) -- write '1' to start PWM signal generation, '0' to stop.
> +Read to determine whether the PWM device is running or not.
I'm not convinced that a sysfs interface is the right thing to do.
The more I look at gpio, the more I wish it didn't have the sysfs
mechanism. sysfs has abi stability issues and it's difficult to
ensure it isn't racy when using it to control more than one thing.
I'd prefer the sysfs code to be split into a separate .c file and a
separate patch so it can be reviewed as a separate piece.
Need to be particularly careful about it since this creates a new
user-space ABI which must be preserved for all time. It cannot be
taken lightly.
> +
> +
> +Using the API to Generate PWM Signals -- Advanced Functions
> +
> +pwm_config() -- Passes a pwm_config structure to the associated device
> +driver. ?This function is invoked by pwm_start(), pwm_duty_ns(),
> +etc. and is one of two main entry points to the PWM driver for the
> +hardware being used. ?The configuration change is guaranteed atomic if
> +multiple configuration changes are specified by the config structure.
> +This function might sleep, depending on what the device driver has to
> +do to satisfy the request. ?All PWM device drivers must support this
> +entry point.
> +
> +pwm_config_nosleep() -- Passes a pwm_config structure to the
> +associated device driver. ?If the driver must sleep in order to
> +implement the requested configuration change, -EWOULDBLOCK is
> +returned. ?Users may call this function from interrupt handlers, timer
> +handlers, and other interrupt contexts, but must confine their
> +configuration changes to only those that the driver can implement
> +without sleeping. ?This is the other main entry point into the PWM
> +hardware driver, but not all device drivers support this entry point.
> +
> +pwm_synchronize(), pwm_unsynchronize() -- "Synchronizes" two or more
> +PWM channels, if the underlying hardware permits. ?(If it doesn't, the
> +framework facilitates emulating this capability but it is not yet
> +implemented). ?Synchronized channels will start and stop
> +simultaneously when any single channel in the group is started or
> +stopped. ?Use pwm_unsynchronize(..., NULL) to completely detach a
> +channel from any other synchronized channels. ?By default, all PWM
> +channels are unsynchronized.
> +
> +
> +Implementing a PWM Device API Driver -- Functions for Driver Authors
> +
> +
> +request -- (optional) Invoked each time a user requests a channel.
> +Use to turn on clocks, clean up register states, etc. ?The framework
> +takes care of device locking/unlocking; you will see only successful
> +requests.
> +
> +release -- (optional) Invoked each time a user relinquishes a channel.
> +The framework will have already stopped, unsynchronized and un-handled
> +the channel. ?Use to turn off clocks, etc. as necessary.
> +
> +config -- Invoked to change the device configuration, always from a
> +sleep-compatible context. ?All the changes indicated must be performed
> +atomically, ideally synchronized to an end-of-period event (so that
> +you avoid short or long output pulses). ?You may sleep, etc. as
> +necessary within this function.
> +
> +config_nosleep -- (optional) Invoked to change device configuration
> +from within a context that is not allowed to sleep. ?If you cannot
> +perform the requested configuration changes without sleeping, return
> +-EWOULDBLOCK.
> +
> +
> +FAQs and Additional Notes
> +
> +The Atmel PWMC pwm_config() function tries to satisfy the user's
> +configuration request by first invoking pwm_config_nosleep(). ?If that
> +operation fails, then the PWM peripheral is brought to a synchronized
> +stop, the configuration changes are made, and the device is restarted.
> +
> +The Atmel PWMC's use of pwm_config_nosleep() from pwm_config()
> +minimizes redundant code between the two functions, and relieves the
> +pwm_config() function of the need to explicitly test whether a
> +requested configuration change can be carried out while the PWM device
> +is in its current mode.
> +
> +PWM API driver authors are encouraged to adopt the Atmel PWMC's
> +pwm_config()-vs.-pwm_config_nosleep() strategy in implementations for
> +other devices as well.
> +
> +
> +Acknowledgements
> +
> +The author expresses his gratitude to the countless developers who
> +have reviewed and submitted feedback on the various versions of the
> +Generic PWM Device API code, and those who have submitted drivers and
> +applications that use the framework. ?You know who you are. ?;)
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 6b4b9cd..fe55958 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -5051,6 +5051,14 @@ S: ? ? ? Maintained
> ?F: ? ? Documentation/video4linux/README.pvrusb2
> ?F: ? ? drivers/media/video/pvrusb2/
>
> +PWM DEVICE API
> +M: ? ? Bill Gatliff <[email protected]>
> +L: ? ? [email protected]
> +T: ? ? git git://git.billgatliff.com/pwm.git
> +S: ? ? Maintained
> +F: ? ? Documentation/pwm.txt
> +F: ? ? drivers/pwm/
> +
> ?PXA2xx/PXA3xx SUPPORT
> ?M: ? ? Eric Miao <[email protected]>
> ?M: ? ? Russell King <[email protected]>
> diff --git a/drivers/Kconfig b/drivers/Kconfig
> index 177c7d1..bc75da5 100644
> --- a/drivers/Kconfig
> +++ b/drivers/Kconfig
> @@ -56,6 +56,8 @@ source "drivers/pps/Kconfig"
>
> ?source "drivers/gpio/Kconfig"
>
> +source "drivers/pwm/Kconfig"
> +
> ?source "drivers/w1/Kconfig"
>
> ?source "drivers/power/Kconfig"
> diff --git a/drivers/Makefile b/drivers/Makefile
> index 3f135b6..132a823 100644
> --- a/drivers/Makefile
> +++ b/drivers/Makefile
> @@ -6,6 +6,8 @@
> ?#
>
> ?obj-y ? ? ? ? ? ? ? ? ? ? ? ? ?+= gpio/
> +obj-$(CONFIG_GENERIC_PWM) ? ? ?+= pwm/
> +
> ?obj-$(CONFIG_PCI) ? ? ? ? ? ? ?+= pci/
> ?obj-$(CONFIG_PARISC) ? ? ? ? ? += parisc/
> ?obj-$(CONFIG_RAPIDIO) ? ? ? ? ?+= rapidio/
> diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
> new file mode 100644
> index 0000000..bc550f7
> --- /dev/null
> +++ b/drivers/pwm/Kconfig
> @@ -0,0 +1,10 @@
> +#
> +# PWM infrastructure and devices
> +#
> +
> +menuconfig GENERIC_PWM
> + ? ? ? tristate "PWM Support"
> + ? ? ? help
> + ? ? ? ? Enables PWM device support implemented via a generic
> + ? ? ? ? framework. ?If unsure, say N.
> +
> diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
> new file mode 100644
> index 0000000..7baa201
> --- /dev/null
> +++ b/drivers/pwm/Makefile
> @@ -0,0 +1,4 @@
> +#
> +# Makefile for pwm devices
> +#
> +obj-$(CONFIG_GENERIC_PWM) := pwm.o
> diff --git a/drivers/pwm/pwm.c b/drivers/pwm/pwm.c
> new file mode 100644
> index 0000000..9a08fea
> --- /dev/null
> +++ b/drivers/pwm/pwm.c
> @@ -0,0 +1,580 @@
> +/*
> + * PWM API implementation
> + *
> + * Copyright (C) 2011 Bill Gatliff <[email protected]>
> + * Copyright (C) 2011 Arun Murthy <[email protected]>
> + *
> + * This program is free software; you may redistribute and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the GNU
> + * General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
> + * USA
> + */
> +
> +#include <linux/module.h>
> +#include <linux/kernel.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/device.h>
> +#include <linux/fs.h>
> +#include <linux/sched.h>
> +#include <linux/pwm/pwm.h>
> +
> +static const char *REQUEST_SYSFS = "sysfs";
> +static struct class pwm_class;
> +
> +void pwm_set_drvdata(struct pwm_device *p, void *data)
> +{
> + ? ? ? dev_set_drvdata(&p->dev, data);
> +}
> +EXPORT_SYMBOL(pwm_set_drvdata);
> +
> +void *pwm_get_drvdata(const struct pwm_device *p)
> +{
> + ? ? ? return dev_get_drvdata(&p->dev);
> +}
> +EXPORT_SYMBOL(pwm_get_drvdata);
Are the set/get drvdata hooks really needed? Wouldn't a driver
registering pwm_devices simply wrap the structure with its own private
data? drvdata is typically only needed when the device registration
code is separate from the device driver code.
> +
> +static inline struct pwm_device *to_pwm_device(struct device *dev)
> +{
> + ? ? ? return container_of(dev, struct pwm_device, dev);
> +}
> +
> +static int pwm_match_name(struct device *dev, void *name)
> +{
> + ? ? ? return !strcmp(name, dev_name(dev));
> +}
> +
> +static int __pwm_request(struct pwm_device *p, const char *label)
> +{
> + ? ? ? int ret;
> +
> + ? ? ? if (!try_module_get(p->ops->owner))
> + ? ? ? ? ? ? ? return -ENODEV;
> +
> + ? ? ? ret = test_and_set_bit(PWM_FLAG_REQUESTED, &p->flags);
> + ? ? ? if (ret) {
> + ? ? ? ? ? ? ? ret = -EBUSY;
> + ? ? ? ? ? ? ? goto err_flag_requested;
> + ? ? ? }
> +
> + ? ? ? p->label = label;
> +
> + ? ? ? if (p->ops->request) {
> + ? ? ? ? ? ? ? ret = p->ops->request(p);
> + ? ? ? ? ? ? ? if (ret)
> + ? ? ? ? ? ? ? ? ? ? ? goto err_request_ops;
> +
> + ? ? ? }
> +
> + ? ? ? return 0;
> +
> +err_request_ops:
> + ? ? ? clear_bit(PWM_FLAG_REQUESTED, &p->flags);
> +
> +err_flag_requested:
> + ? ? ? module_put(p->ops->owner);
> + ? ? ? return ret;
> +}
> +
> +/**
> + * pwm_request - request a PWM device by name
Nit: kerneldoc format has () after the function name.
> + *
> + * @name: name of PWM device
> + * @label: label that identifies requestor
> + *
> + * The @name format is driver-specific, but is typically of the form
> + * "<bus_id>:<chan>". ?For example, "atmel_pwmc:1" identifies the
> + * second ATMEL PWMC peripheral channel.
> + *
> + * Returns a pointer to the requested PWM device on success, -EINVAL
> + * otherwise.
> + */
> +struct pwm_device *pwm_request(const char *name, const char *label)
> +{
So, the last time I actually was able to look at these patches was
almost a year ago. At that time I had two major concerns. First, I
don't at all think this should be a new subsystem. I know you
disagree, but I strongly think that pwm management is sufficiently
similar to gpio management that it needs to be the same subsystem.
All of the things that need to be done for request, release and
enumeration are essentially the same, and conceptually they I think
they need to be managed within the same namespace.
Second, I deeply dislike the model of matching devices by name
(string). My opinion is it is too easy to break, and it depends on
the having control over how a device is actually going to get named
(which may be true for the current users, but it won't be true for pwm
devices on add-in or hot plugged devices). Basically, in order to be
dynamic-registration friendly, the API needs to assume that any device
names/ids are dynamically assigned by the kernel. A better mechanism
is something like a direct pointer to the pwm instance, or an explicit
reference like a phandle in a device tree (required for powerpc).
It may be fine to have a lookup-by-name mechanism on top of the api,
but it should not be the primary interface for referencing a specific
device.
> + ? ? ? struct device *d;
> + ? ? ? struct pwm_device *p;
> + ? ? ? int ret;
> +
> + ? ? ? d = class_find_device(&pwm_class, NULL, (char*)name, pwm_match_name);
> + ? ? ? if (!d)
> + ? ? ? ? ? ? ? return ERR_PTR(-EINVAL);
> +
> + ? ? ? p = to_pwm_device(d);
> + ? ? ? ret = __pwm_request(p, label);
> + ? ? ? if (ret) {
> + ? ? ? ? ? ? ? put_device(d);
> + ? ? ? ? ? ? ? return ERR_PTR(ret);
> + ? ? ? }
> +
> + ? ? ? return p;
> +}
> +EXPORT_SYMBOL(pwm_request);
EXPORT_SYMBOL_GPL()
> +static struct class pwm_class = {
> + ? ? ? .name ? ? ? ? ? = "pwm",
> + ? ? ? .owner ? ? ? ? ?= THIS_MODULE,
> + ? ? ? .dev_attrs ? ? ?= pwm_dev_attrs,
> +};
>From my understanding, class is deprecated. I believe you should be
using bus_type directly now. Check with Greg and Kay.
> +
> +static void __pwm_release(struct device *dev)
> +{
> + ? ? ? struct pwm_device *p = container_of(dev, struct pwm_device, dev);
> + ? ? ? kfree(p);
> +}
> +
> +/**
> + * pwm_register - registers a PWM device
> + *
> + * @ops: PWM device operations
> + * @parent: reference to parent device, if any
> + * @fmt: printf-style format specifier for device name
> + */
> +struct pwm_device *pwm_register(const struct pwm_device_ops *ops,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? struct device *parent, const char *fmt, ...)
> +{
> + ? ? ? struct pwm_device *p;
> + ? ? ? int ret;
> + ? ? ? va_list vargs;
> +
> + ? ? ? if (!ops || !ops->config)
> + ? ? ? ? ? ? ? return ERR_PTR(-EINVAL);
> +
> + ? ? ? p = kzalloc(sizeof(*p), GFP_KERNEL);
> + ? ? ? if (!p)
> + ? ? ? ? ? ? ? return ERR_PTR(-ENOMEM);
I'd rather see the caller responsible for allocating the pwm_devices
so that it can wrap is with its own structure as needed.
> +
> + ? ? ? p->ops = ops;
> +
> + ? ? ? p->dev.class = &pwm_class;
> + ? ? ? p->dev.parent = parent;
> + ? ? ? p->dev.release = __pwm_release;
> +
> + ? ? ? va_start(vargs, fmt);
> + ? ? ? ret = kobject_set_name_vargs(&p->dev.kobj, fmt, vargs);
> +
> + ? ? ? ret = device_register(&p->dev);
> + ? ? ? if (ret)
> + ? ? ? ? ? ? ? goto err;
> +
> + ? ? ? return p;
> +
> +err:
> + ? ? ? put_device(&p->dev);
> + ? ? ? return ERR_PTR(ret);
> +}
> +EXPORT_SYMBOL(pwm_register);
> +
> +void pwm_unregister(struct pwm_device *p)
> +{
> + ? ? ? device_unregister(&p->dev);
> +}
> +EXPORT_SYMBOL(pwm_unregister);
> +
> +static int __init pwm_init(void)
> +{
> + ? ? ? return class_register(&pwm_class);
> +}
> +
> +static void __exit pwm_exit(void)
> +{
> + ? ? ? class_unregister(&pwm_class);
> +}
> +
> +postcore_initcall(pwm_init);
> +module_exit(pwm_exit);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("Bill Gatliff <[email protected]>");
> +MODULE_DESCRIPTION("Generic PWM device API implementation");
> diff --git a/include/linux/pwm/pwm.h b/include/linux/pwm/pwm.h
> new file mode 100644
> index 0000000..64707a7
> --- /dev/null
> +++ b/include/linux/pwm/pwm.h
> @@ -0,0 +1,140 @@
> +/*
> + * Copyright (C) 2011 Bill Gatliff <[email protected]>
> + * Copyright (C) 2011 Arun Murthy <[email protected]>
> + *
> + * This program is free software; you may redistribute and/or modify
> + * it under the terms of the GNU General Public License version 2, as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ?See the GNU
> + * General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
> + * USA
> + */
> +#ifndef __LINUX_PWM_H
> +#define __LINUX_PWM_H
> +
> +#include <linux/device.h>
> +
> +enum {
> + ? ? ? PWM_FLAG_REQUESTED ? ? ?= 0,
> + ? ? ? PWM_FLAG_STOP ? ? ? ? ? = 1,
> + ? ? ? PWM_FLAG_RUNNING ? ? ? ?= 2,
> + ? ? ? PWM_FLAG_EXPORTED ? ? ? = 3,
> +};
> +
> +enum {
> + ? ? ? PWM_CONFIG_DUTY_TICKS ? = 0,
> + ? ? ? PWM_CONFIG_PERIOD_TICKS = 1,
> + ? ? ? PWM_CONFIG_POLARITY ? ? = 2,
> + ? ? ? PWM_CONFIG_START ? ? ? ?= 3,
> + ? ? ? PWM_CONFIG_STOP ? ? ? ? = 4,
> +};
> +
> +struct pwm_config;
> +struct pwm_device;
> +
> +struct pwm_device_ops {
> + ? ? ? struct module *owner;
> +
> + ? ? ? int ? ? (*request) ? ? ? ? ? ? ?(struct pwm_device *p);
> + ? ? ? void ? ?(*release) ? ? ? ? ? ? ?(struct pwm_device *p);
> + ? ? ? int ? ? (*config) ? ? ? ? ? ? ? (struct pwm_device *p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct pwm_config *c);
> + ? ? ? int ? ? (*config_nosleep) ? ? ? (struct pwm_device *p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct pwm_config *c);
> + ? ? ? int ? ? (*synchronize) ? ? ? ? ?(struct pwm_device *p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct pwm_device *to_p);
> + ? ? ? int ? ? (*unsynchronize) ? ? ? ?(struct pwm_device *p,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?struct pwm_device *from_p);
> +};
> +
> +/**
> + * struct pwm_config - configuration data for a PWM device
> + *
> + * @config_mask: which fields are valid
> + * @duty_ticks: requested duty cycle, in ticks
> + * @period_ticks: requested period, in ticks
> + * @polarity: active high (1), or active low (0)
> + */
> +struct pwm_config {
> + ? ? ? unsigned long ? config_mask;
> + ? ? ? unsigned long ? duty_ticks;
> + ? ? ? unsigned long ? period_ticks;
> + ? ? ? int ? ? ? ? ? ? polarity;
> +};
> +
> +/**
> + * struct pwm_device - represents a PWM device
> + *
> + * @dev: device model reference
> + * @ops: operations supported by the PWM device
> + * @label: requestor of the PWM device, or NULL
> + * @flags: PWM device state, see FLAG_*
> + * @tick_hz: base tick rate of PWM device, in HZ
> + * @polarity: active high (1), or active low (0)
> + * @period_ticks: PWM device's current period, in ticks
> + * @duty_ticks: duration of PWM device's active cycle, in ticks
> + */
> +struct pwm_device {
> + ? ? ? struct device ? dev;
> + ? ? ? const struct pwm_device_ops *ops;
> + ? ? ? const char ? ? ?*label;
> + ? ? ? unsigned long ? flags;
> + ? ? ? unsigned long ? tick_hz;
> + ? ? ? int ? ? ? ? ? ? polarity;
> + ? ? ? unsigned long ? period_ticks;
> + ? ? ? unsigned long ? duty_ticks;
> +};
> +
> +struct pwm_device *pwm_request(const char *name, const char *label);
> +void pwm_release(struct pwm_device *p);
Missing 'extern' in front of all the forward declarations.
> +
> +static inline int pwm_is_requested(const struct pwm_device *p)
> +{
> + ? ? ? return test_bit(PWM_FLAG_REQUESTED, &p->flags);
> +}
> +
> +static inline int pwm_is_running(const struct pwm_device *p)
> +{
> + ? ? ? return test_bit(PWM_FLAG_RUNNING, &p->flags);
> +}
> +
> +static inline int pwm_is_exported(const struct pwm_device *p)
> +{
> + ? ? ? return test_bit(PWM_FLAG_EXPORTED, &p->flags);
> +}
> +
> +struct pwm_device *pwm_register(const struct pwm_device_ops *ops, struct device *parent,
> + ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? const char *fmt, ...);
> +void pwm_unregister(struct pwm_device *p);
> +
> +void pwm_set_drvdata(struct pwm_device *p, void *data);
> +void *pwm_get_drvdata(const struct pwm_device *p);
> +
> +int pwm_set(struct pwm_device *p, unsigned long period_ns,
> + ? ? ? ? ? unsigned long duty_ns, int polarity);
> +
> +int pwm_set_period_ns(struct pwm_device *p, unsigned long period_ns);
> +unsigned long pwm_get_period_ns(struct pwm_device *p);
> +
> +int pwm_set_duty_ns(struct pwm_device *p, unsigned long duty_ns);
> +unsigned long pwm_get_duty_ns(struct pwm_device *p);
> +
> +int pwm_set_polarity(struct pwm_device *p, int polarity);
> +
> +int pwm_start(struct pwm_device *p);
> +int pwm_stop(struct pwm_device *p);
> +
> +int pwm_config_nosleep(struct pwm_device *p, struct pwm_config *c);
> +int pwm_config(struct pwm_device *p, struct pwm_config *c);
> +
> +int pwm_synchronize(struct pwm_device *p, struct pwm_device *to_p);
> +int pwm_unsynchronize(struct pwm_device *p, struct pwm_device *from_p);
> +
> +#endif
> --
> 1.7.4.1
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-embedded" in
> the body of a message to [email protected]
> More majordomo info at ?http://vger.kernel.org/majordomo-info.html
>
--
Grant Likely, B.Sc., P.Eng.
Secret Lab Technologies Ltd.
On Thu, Apr 14, 2011 at 01:49:27PM -0600, Grant Likely wrote:
> > +static struct class pwm_class = {
> > + ? ? ? .name ? ? ? ? ? = "pwm",
> > + ? ? ? .owner ? ? ? ? ?= THIS_MODULE,
> > + ? ? ? .dev_attrs ? ? ?= pwm_dev_attrs,
> > +};
>
> >From my understanding, class is deprecated. I believe you should be
> using bus_type directly now. Check with Greg and Kay.
Yes, that is correct, please don't create new classes if at all
possible. And this code looks like it is fine to use a bus_type.
thanks,
greg k-h
On Thu, Mar 31, 2011 at 23:59, Bill Gatliff wrote:
> This patch series contains the ninth attempt at implementation of a
> generic PWM device interface framework. Think gpiolib, but for
> devices and pseudo-devices that generate pulse-wave-modulated outputs.
i was made aware of the existing code in linux/pwm.h. seems that this
framework should absorb that since there are already drivers built on
top of it (i see a backlight, led, and input driver), and we dont want
two frameworks doing exactly the same thing.
-mike