ARM: 5628/1: ep93xx: Introduce Pulse Width Modulator (PWM) driver
Hartley Sweeten [Wed, 29 Jul 2009 21:41:06 +0000 (22:41 +0100)]
The EP93xx features two PWMs (one on the EP9307) with the following
features:

  * Configurable dual output
  * Separate input clocks for each PWM output
  * 16-bit resolution
  * Programmable pulse width (duty cycle), interval (frequency), and
    polarity

This adds the necessary core support as well as the driver.  A sysfs
interface is provided to control the PWM outputs.

Signed-off-by: Matthieu Crapet <mcrapet@gmail.com>
Signed-off-by: H Hartley Sweeten <hsweeten@visionengravers.com>
Acked-by: Ryan Mallon <ryan@bluewatersys.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

arch/arm/mach-ep93xx/clock.c
arch/arm/mach-ep93xx/core.c
arch/arm/mach-ep93xx/include/mach/ep93xx-regs.h
arch/arm/mach-ep93xx/include/mach/platform.h
drivers/misc/Kconfig
drivers/misc/Makefile
drivers/misc/ep93xx_pwm.c [new file with mode: 0644]

index b6b5344..3dd0e2a 100644 (file)
@@ -72,6 +72,9 @@ static struct clk clk_keypad = {
        .enable_mask    = EP93XX_SYSCON_KEYTCHCLKDIV_KEN,
        .set_rate       = set_keytchclk_rate,
 };
+static struct clk clk_pwm = {
+       .rate           = EP93XX_EXT_CLK_RATE,
+};
 
 /* DMA Clocks */
 static struct clk clk_m2p0 = {
@@ -137,6 +140,7 @@ static struct clk_lookup clocks[] = {
        INIT_CK(NULL,                   "pll2",         &clk_pll2),
        INIT_CK("ep93xx-ohci",          NULL,           &clk_usb_host),
        INIT_CK("ep93xx-keypad",        NULL,           &clk_keypad),
+       INIT_CK(NULL,                   "pwm_clk",      &clk_pwm),
        INIT_CK(NULL,                   "m2p0",         &clk_m2p0),
        INIT_CK(NULL,                   "m2p1",         &clk_m2p1),
        INIT_CK(NULL,                   "m2p2",         &clk_m2p2),
index 2b58df0..4075529 100644 (file)
@@ -597,6 +597,91 @@ static struct platform_device ep93xx_leds = {
 };
 
 
+/*************************************************************************
+ * EP93xx pwm peripheral handling
+ *************************************************************************/
+static struct resource ep93xx_pwm0_resource[] = {
+       {
+               .start  = EP93XX_PWM_PHYS_BASE,
+               .end    = EP93XX_PWM_PHYS_BASE + 0x10 - 1,
+               .flags  = IORESOURCE_MEM,
+       },
+};
+
+static struct platform_device ep93xx_pwm0_device = {
+       .name           = "ep93xx-pwm",
+       .id             = 0,
+       .num_resources  = ARRAY_SIZE(ep93xx_pwm0_resource),
+       .resource       = ep93xx_pwm0_resource,
+};
+
+static struct resource ep93xx_pwm1_resource[] = {
+       {
+               .start  = EP93XX_PWM_PHYS_BASE + 0x20,
+               .end    = EP93XX_PWM_PHYS_BASE + 0x30 - 1,
+               .flags  = IORESOURCE_MEM,
+       },
+};
+
+static struct platform_device ep93xx_pwm1_device = {
+       .name           = "ep93xx-pwm",
+       .id             = 1,
+       .num_resources  = ARRAY_SIZE(ep93xx_pwm1_resource),
+       .resource       = ep93xx_pwm1_resource,
+};
+
+void __init ep93xx_register_pwm(int pwm0, int pwm1)
+{
+       if (pwm0)
+               platform_device_register(&ep93xx_pwm0_device);
+
+       /* NOTE: EP9307 does not have PWMOUT1 (pin EGPIO14) */
+       if (pwm1)
+               platform_device_register(&ep93xx_pwm1_device);
+}
+
+int ep93xx_pwm_acquire_gpio(struct platform_device *pdev)
+{
+       int err;
+
+       if (pdev->id == 0) {
+               err = 0;
+       } else if (pdev->id == 1) {
+               err = gpio_request(EP93XX_GPIO_LINE_EGPIO14,
+                                  dev_name(&pdev->dev));
+               if (err)
+                       return err;
+               err = gpio_direction_output(EP93XX_GPIO_LINE_EGPIO14, 0);
+               if (err)
+                       goto fail;
+
+               /* PWM 1 output on EGPIO[14] */
+               ep93xx_devcfg_set_bits(EP93XX_SYSCON_DEVCFG_PONG);
+       } else {
+               err = -ENODEV;
+       }
+
+       return err;
+
+fail:
+       gpio_free(EP93XX_GPIO_LINE_EGPIO14);
+       return err;
+}
+EXPORT_SYMBOL(ep93xx_pwm_acquire_gpio);
+
+void ep93xx_pwm_release_gpio(struct platform_device *pdev)
+{
+       if (pdev->id == 1) {
+               gpio_direction_input(EP93XX_GPIO_LINE_EGPIO14);
+               gpio_free(EP93XX_GPIO_LINE_EGPIO14);
+
+               /* EGPIO[14] used for GPIO */
+               ep93xx_devcfg_clear_bits(EP93XX_SYSCON_DEVCFG_PONG);
+       }
+}
+EXPORT_SYMBOL(ep93xx_pwm_release_gpio);
+
+
 extern void ep93xx_gpio_init(void);
 
 void __init ep93xx_init_devices(void)
index a11ae77..ea78e90 100644 (file)
 #define EP93XX_ADC_BASE                        EP93XX_APB_IOMEM(0x00100000)
 #define EP93XX_TOUCHSCREEN_BASE                EP93XX_APB_IOMEM(0x00100000)
 
+#define EP93XX_PWM_PHYS_BASE           (EP93XX_APB_PHYS_BASE + 0x00110000)
 #define EP93XX_PWM_BASE                        EP93XX_APB_IOMEM(0x00110000)
 
 #define EP93XX_RTC_PHYS_BASE           (EP93XX_APB_PHYS_BASE + 0x00120000)
index 0af0a3b..5f5fa65 100644 (file)
@@ -5,6 +5,7 @@
 #ifndef __ASSEMBLY__
 
 struct i2c_board_info;
+struct platform_device;
 
 struct ep93xx_eth_data
 {
@@ -32,6 +33,9 @@ static inline void ep93xx_devcfg_clear_bits(unsigned int bits)
 
 void ep93xx_register_eth(struct ep93xx_eth_data *data, int copy_addr);
 void ep93xx_register_i2c(struct i2c_board_info *devices, int num);
+void ep93xx_register_pwm(int pwm0, int pwm1);
+int ep93xx_pwm_acquire_gpio(struct platform_device *pdev);
+void ep93xx_pwm_release_gpio(struct platform_device *pdev);
 
 void ep93xx_init_devices(void);
 extern struct sys_timer ep93xx_timer;
index 68ab39d..df1f86b 100644 (file)
@@ -233,6 +233,19 @@ config ISL29003
          This driver can also be built as a module.  If so, the module
          will be called isl29003.
 
+config EP93XX_PWM
+       tristate "EP93xx PWM support"
+       depends on ARCH_EP93XX
+       help
+         This option enables device driver support for the PWM channels
+         on the Cirrus EP93xx processors.  The EP9307 chip only has one
+         PWM channel all the others have two, the second channel is an
+         alternate function of the EGPIO14 pin.  A sysfs interface is
+         provided to control the PWM channels.
+
+         To compile this driver as a module, choose M here: the module will
+         be called ep93xx_pwm.
+
 source "drivers/misc/c2port/Kconfig"
 source "drivers/misc/eeprom/Kconfig"
 source "drivers/misc/cb710/Kconfig"
index 36f733c..f982d2e 100644 (file)
@@ -19,6 +19,7 @@ obj-$(CONFIG_SGI_XP)          += sgi-xp/
 obj-$(CONFIG_SGI_GRU)          += sgi-gru/
 obj-$(CONFIG_HP_ILO)           += hpilo.o
 obj-$(CONFIG_ISL29003)         += isl29003.o
+obj-$(CONFIG_EP93XX_PWM)       += ep93xx_pwm.o
 obj-$(CONFIG_C2PORT)           += c2port/
 obj-y                          += eeprom/
 obj-y                          += cb710/
diff --git a/drivers/misc/ep93xx_pwm.c b/drivers/misc/ep93xx_pwm.c
new file mode 100644 (file)
index 0000000..ba46941
--- /dev/null
@@ -0,0 +1,384 @@
+/*
+ *  Simple PWM driver for EP93XX
+ *
+ *     (c) Copyright 2009  Matthieu Crapet <mcrapet@gmail.com>
+ *     (c) Copyright 2009  H Hartley Sweeten <hsweeten@visionengravers.com>
+ *
+ *     This program is free software; you can redistribute it and/or
+ *     modify it under the terms of the GNU General Public License
+ *     as published by the Free Software Foundation; either version
+ *     2 of the License, or (at your option) any later version.
+ *
+ *  EP9307 has only one channel:
+ *    - PWMOUT
+ *
+ *  EP9301/02/12/15 have two channels:
+ *    - PWMOUT
+ *    - PWMOUT1 (alternate function for EGPIO14)
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include <mach/platform.h>
+
+#define EP93XX_PWMx_TERM_COUNT 0x00
+#define EP93XX_PWMx_DUTY_CYCLE 0x04
+#define EP93XX_PWMx_ENABLE     0x08
+#define EP93XX_PWMx_INVERT     0x0C
+
+#define EP93XX_PWM_MAX_COUNT   0xFFFF
+
+struct ep93xx_pwm {
+       void __iomem    *mmio_base;
+       struct clk      *clk;
+       u32             duty_percent;
+};
+
+static inline void ep93xx_pwm_writel(struct ep93xx_pwm *pwm,
+               unsigned int val, unsigned int off)
+{
+       __raw_writel(val, pwm->mmio_base + off);
+}
+
+static inline unsigned int ep93xx_pwm_readl(struct ep93xx_pwm *pwm,
+               unsigned int off)
+{
+       return __raw_readl(pwm->mmio_base + off);
+}
+
+static inline void ep93xx_pwm_write_tc(struct ep93xx_pwm *pwm, u16 value)
+{
+       ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_TERM_COUNT);
+}
+
+static inline u16 ep93xx_pwm_read_tc(struct ep93xx_pwm *pwm)
+{
+       return ep93xx_pwm_readl(pwm, EP93XX_PWMx_TERM_COUNT);
+}
+
+static inline void ep93xx_pwm_write_dc(struct ep93xx_pwm *pwm, u16 value)
+{
+       ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_DUTY_CYCLE);
+}
+
+static inline void ep93xx_pwm_enable(struct ep93xx_pwm *pwm)
+{
+       ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_ENABLE);
+}
+
+static inline void ep93xx_pwm_disable(struct ep93xx_pwm *pwm)
+{
+       ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_ENABLE);
+}
+
+static inline int ep93xx_pwm_is_enabled(struct ep93xx_pwm *pwm)
+{
+       return ep93xx_pwm_readl(pwm, EP93XX_PWMx_ENABLE) & 0x1;
+}
+
+static inline void ep93xx_pwm_invert(struct ep93xx_pwm *pwm)
+{
+       ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_INVERT);
+}
+
+static inline void ep93xx_pwm_normal(struct ep93xx_pwm *pwm)
+{
+       ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_INVERT);
+}
+
+static inline int ep93xx_pwm_is_inverted(struct ep93xx_pwm *pwm)
+{
+       return ep93xx_pwm_readl(pwm, EP93XX_PWMx_INVERT) & 0x1;
+}
+
+/*
+ * /sys/devices/platform/ep93xx-pwm.N
+ *   /min_freq      read-only   minimum pwm output frequency
+ *   /max_req       read-only   maximum pwm output frequency
+ *   /freq          read-write  pwm output frequency (0 = disable output)
+ *   /duty_percent  read-write  pwm duty cycle percent (1..99)
+ *   /invert        read-write  invert pwm output
+ */
+
+static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       unsigned long rate = clk_get_rate(pwm->clk);
+
+       return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
+}
+
+static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       unsigned long rate = clk_get_rate(pwm->clk);
+
+       return sprintf(buf, "%ld\n", rate / 2);
+}
+
+static ssize_t ep93xx_pwm_get_freq(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+       if (ep93xx_pwm_is_enabled(pwm)) {
+               unsigned long rate = clk_get_rate(pwm->clk);
+               u16 term = ep93xx_pwm_read_tc(pwm);
+
+               return sprintf(buf, "%ld\n", rate / (term + 1));
+       } else {
+               return sprintf(buf, "disabled\n");
+       }
+}
+
+static ssize_t ep93xx_pwm_set_freq(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t count)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       long val;
+       int err;
+
+       err = strict_strtol(buf, 10, &val);
+       if (err)
+               return -EINVAL;
+
+       if (val == 0) {
+               ep93xx_pwm_disable(pwm);
+       } else if (val <= (clk_get_rate(pwm->clk) / 2)) {
+               u32 term, duty;
+
+               val = (clk_get_rate(pwm->clk) / val) - 1;
+               if (val > EP93XX_PWM_MAX_COUNT)
+                       val = EP93XX_PWM_MAX_COUNT;
+               if (val < 1)
+                       val = 1;
+
+               term = ep93xx_pwm_read_tc(pwm);
+               duty = ((val + 1) * pwm->duty_percent / 100) - 1;
+
+               /* If pwm is running, order is important */
+               if (val > term) {
+                       ep93xx_pwm_write_tc(pwm, val);
+                       ep93xx_pwm_write_dc(pwm, duty);
+               } else {
+                       ep93xx_pwm_write_dc(pwm, duty);
+                       ep93xx_pwm_write_tc(pwm, val);
+               }
+
+               if (!ep93xx_pwm_is_enabled(pwm))
+                       ep93xx_pwm_enable(pwm);
+       } else {
+               return -EINVAL;
+       }
+
+       return count;
+}
+
+static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+       return sprintf(buf, "%d\n", pwm->duty_percent);
+}
+
+static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t count)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       long val;
+       int err;
+
+       err = strict_strtol(buf, 10, &val);
+       if (err)
+               return -EINVAL;
+
+       if (val > 0 && val < 100) {
+               u32 term = ep93xx_pwm_read_tc(pwm);
+               ep93xx_pwm_write_dc(pwm, ((term + 1) * val / 100) - 1);
+               pwm->duty_percent = val;
+               return count;
+       }
+
+       return -EINVAL;
+}
+
+static ssize_t ep93xx_pwm_get_invert(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+
+       return sprintf(buf, "%d\n", ep93xx_pwm_is_inverted(pwm));
+}
+
+static ssize_t ep93xx_pwm_set_invert(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t count)
+{
+       struct platform_device *pdev = to_platform_device(dev);
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       long val;
+       int err;
+
+       err = strict_strtol(buf, 10, &val);
+       if (err)
+               return -EINVAL;
+
+       if (val == 0)
+               ep93xx_pwm_normal(pwm);
+       else if (val == 1)
+               ep93xx_pwm_invert(pwm);
+       else
+               return -EINVAL;
+
+       return count;
+}
+
+static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
+static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
+static DEVICE_ATTR(freq, S_IWUGO | S_IRUGO,
+                  ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
+static DEVICE_ATTR(duty_percent, S_IWUGO | S_IRUGO,
+                  ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
+static DEVICE_ATTR(invert, S_IWUGO | S_IRUGO,
+                  ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
+
+static struct attribute *ep93xx_pwm_attrs[] = {
+       &dev_attr_min_freq.attr,
+       &dev_attr_max_freq.attr,
+       &dev_attr_freq.attr,
+       &dev_attr_duty_percent.attr,
+       &dev_attr_invert.attr,
+       NULL
+};
+
+static const struct attribute_group ep93xx_pwm_sysfs_files = {
+       .attrs  = ep93xx_pwm_attrs,
+};
+
+static int __init ep93xx_pwm_probe(struct platform_device *pdev)
+{
+       struct ep93xx_pwm *pwm;
+       struct resource *res;
+       int err;
+
+       err = ep93xx_pwm_acquire_gpio(pdev);
+       if (err)
+               return err;
+
+       pwm = kzalloc(sizeof(struct ep93xx_pwm), GFP_KERNEL);
+       if (!pwm) {
+               err = -ENOMEM;
+               goto fail_no_mem;
+       }
+
+       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       if (res == NULL) {
+               err = -ENXIO;
+               goto fail_no_mem_resource;
+       }
+
+       res = request_mem_region(res->start, resource_size(res), pdev->name);
+       if (res == NULL) {
+               err = -EBUSY;
+               goto fail_no_mem_resource;
+       }
+
+       pwm->mmio_base = ioremap(res->start, resource_size(res));
+       if (pwm->mmio_base == NULL) {
+               err = -ENXIO;
+               goto fail_no_ioremap;
+       }
+
+       err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+       if (err)
+               goto fail_no_sysfs;
+
+       pwm->clk = clk_get(&pdev->dev, "pwm_clk");
+       if (IS_ERR(pwm->clk)) {
+               err = PTR_ERR(pwm->clk);
+               goto fail_no_clk;
+       }
+
+       pwm->duty_percent = 50;
+
+       platform_set_drvdata(pdev, pwm);
+
+       /* disable pwm at startup. Avoids zero value. */
+       ep93xx_pwm_disable(pwm);
+       ep93xx_pwm_write_tc(pwm, EP93XX_PWM_MAX_COUNT);
+       ep93xx_pwm_write_dc(pwm, EP93XX_PWM_MAX_COUNT / 2);
+
+       clk_enable(pwm->clk);
+
+       return 0;
+
+fail_no_clk:
+       sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+fail_no_sysfs:
+       iounmap(pwm->mmio_base);
+fail_no_ioremap:
+       release_mem_region(res->start, resource_size(res));
+fail_no_mem_resource:
+       kfree(pwm);
+fail_no_mem:
+       ep93xx_pwm_release_gpio(pdev);
+       return err;
+}
+
+static int __exit ep93xx_pwm_remove(struct platform_device *pdev)
+{
+       struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
+       struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+       ep93xx_pwm_disable(pwm);
+       clk_disable(pwm->clk);
+       clk_put(pwm->clk);
+       platform_set_drvdata(pdev, NULL);
+       sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
+       iounmap(pwm->mmio_base);
+       release_mem_region(res->start, resource_size(res));
+       kfree(pwm);
+       ep93xx_pwm_release_gpio(pdev);
+
+       return 0;
+}
+
+static struct platform_driver ep93xx_pwm_driver = {
+       .driver         = {
+               .name   = "ep93xx-pwm",
+               .owner  = THIS_MODULE,
+       },
+       .remove         = __exit_p(ep93xx_pwm_remove),
+};
+
+static int __init ep93xx_pwm_init(void)
+{
+       return platform_driver_probe(&ep93xx_pwm_driver, ep93xx_pwm_probe);
+}
+
+static void __exit ep93xx_pwm_exit(void)
+{
+       platform_driver_unregister(&ep93xx_pwm_driver);
+}
+
+module_init(ep93xx_pwm_init);
+module_exit(ep93xx_pwm_exit);
+
+MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
+             "H Hartley Sweeten <hsweeten@visionengravers.com>");
+MODULE_DESCRIPTION("EP93xx PWM driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ep93xx-pwm");