[net-next-2.6.git] / drivers / misc / ep93xx_pwm.c

/*
 *  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");
Commit	Line	Data
ef12379f HS	1	/*
	2	* Simple PWM driver for EP93XX
	3	*
	4	* (c) Copyright 2009 Matthieu Crapet <mcrapet@gmail.com>
	5	* (c) Copyright 2009 H Hartley Sweeten <hsweeten@visionengravers.com>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version
	10	* 2 of the License, or (at your option) any later version.
	11	*
	12	* EP9307 has only one channel:
	13	* - PWMOUT
	14	*
	15	* EP9301/02/12/15 have two channels:
	16	* - PWMOUT
	17	* - PWMOUT1 (alternate function for EGPIO14)
	18	*/
	19
	20	#include <linux/module.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/clk.h>
	23	#include <linux/err.h>
	24	#include <linux/io.h>
	25
	26	#include <mach/platform.h>
	27
	28	#define EP93XX_PWMx_TERM_COUNT 0x00
	29	#define EP93XX_PWMx_DUTY_CYCLE 0x04
	30	#define EP93XX_PWMx_ENABLE 0x08
	31	#define EP93XX_PWMx_INVERT 0x0C
	32
	33	#define EP93XX_PWM_MAX_COUNT 0xFFFF
	34
	35	struct ep93xx_pwm {
	36	void __iomem *mmio_base;
	37	struct clk *clk;
	38	u32 duty_percent;
	39	};
	40
	41	static inline void ep93xx_pwm_writel(struct ep93xx_pwm *pwm,
	42	unsigned int val, unsigned int off)
	43	{
	44	__raw_writel(val, pwm->mmio_base + off);
	45	}
	46
	47	static inline unsigned int ep93xx_pwm_readl(struct ep93xx_pwm *pwm,
	48	unsigned int off)
	49	{
	50	return __raw_readl(pwm->mmio_base + off);
	51	}
	52
	53	static inline void ep93xx_pwm_write_tc(struct ep93xx_pwm *pwm, u16 value)
	54	{
	55	ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_TERM_COUNT);
	56	}
	57
	58	static inline u16 ep93xx_pwm_read_tc(struct ep93xx_pwm *pwm)
	59	{
	60	return ep93xx_pwm_readl(pwm, EP93XX_PWMx_TERM_COUNT);
	61	}
	62
	63	static inline void ep93xx_pwm_write_dc(struct ep93xx_pwm *pwm, u16 value)
	64	{
65	ep93xx_pwm_writel(pwm, value, EP93XX_PWMx_DUTY_CYCLE);
66	}
67
68	static inline void ep93xx_pwm_enable(struct ep93xx_pwm *pwm)
69	{
70	ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_ENABLE);
71	}
72
73	static inline void ep93xx_pwm_disable(struct ep93xx_pwm *pwm)
74	{
75	ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_ENABLE);
76	}
77
78	static inline int ep93xx_pwm_is_enabled(struct ep93xx_pwm *pwm)
79	{
80	return ep93xx_pwm_readl(pwm, EP93XX_PWMx_ENABLE) & 0x1;
81	}
82
83	static inline void ep93xx_pwm_invert(struct ep93xx_pwm *pwm)
84	{
85	ep93xx_pwm_writel(pwm, 0x1, EP93XX_PWMx_INVERT);
86	}
87
88	static inline void ep93xx_pwm_normal(struct ep93xx_pwm *pwm)
89	{
90	ep93xx_pwm_writel(pwm, 0x0, EP93XX_PWMx_INVERT);
91	}
92
93	static inline int ep93xx_pwm_is_inverted(struct ep93xx_pwm *pwm)
94	{
95	return ep93xx_pwm_readl(pwm, EP93XX_PWMx_INVERT) & 0x1;
96	}
97
98	/*
99	* /sys/devices/platform/ep93xx-pwm.N
100	* /min_freq read-only minimum pwm output frequency
101	* /max_req read-only maximum pwm output frequency
102	* /freq read-write pwm output frequency (0 = disable output)
103	* /duty_percent read-write pwm duty cycle percent (1..99)
104	* /invert read-write invert pwm output
105	*/
106
107	static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
108	struct device_attribute attr, char buf)
109	{
110	struct platform_device *pdev = to_platform_device(dev);
111	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
112	unsigned long rate = clk_get_rate(pwm->clk);
113
114	return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
115	}
116
117	static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
118	struct device_attribute attr, char buf)
119	{
120	struct platform_device *pdev = to_platform_device(dev);
121	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
122	unsigned long rate = clk_get_rate(pwm->clk);
123
124	return sprintf(buf, "%ld\n", rate / 2);
125	}
126
127	static ssize_t ep93xx_pwm_get_freq(struct device *dev,
128	struct device_attribute attr, char buf)
129	{
130	struct platform_device *pdev = to_platform_device(dev);
131	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
132
133	if (ep93xx_pwm_is_enabled(pwm)) {
134	unsigned long rate = clk_get_rate(pwm->clk);
135	u16 term = ep93xx_pwm_read_tc(pwm);
136
137	return sprintf(buf, "%ld\n", rate / (term + 1));
138	} else {
139	return sprintf(buf, "disabled\n");
140	}
141	}
142
143	static ssize_t ep93xx_pwm_set_freq(struct device *dev,
144	struct device_attribute attr, const char buf, size_t count)
145	{
146	struct platform_device *pdev = to_platform_device(dev);
147	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
148	long val;
149	int err;
150
151	err = strict_strtol(buf, 10, &val);
152	if (err)
153	return -EINVAL;
154
155	if (val == 0) {
156	ep93xx_pwm_disable(pwm);
157	} else if (val <= (clk_get_rate(pwm->clk) / 2)) {
158	u32 term, duty;
159
160	val = (clk_get_rate(pwm->clk) / val) - 1;
161	if (val > EP93XX_PWM_MAX_COUNT)
162	val = EP93XX_PWM_MAX_COUNT;
163	if (val < 1)
164	val = 1;
165
166	term = ep93xx_pwm_read_tc(pwm);
167	duty = ((val + 1) * pwm->duty_percent / 100) - 1;
168
169	/* If pwm is running, order is important */
170	if (val > term) {
171	ep93xx_pwm_write_tc(pwm, val);
172	ep93xx_pwm_write_dc(pwm, duty);
173	} else {
174	ep93xx_pwm_write_dc(pwm, duty);
175	ep93xx_pwm_write_tc(pwm, val);
176	}
177
178	if (!ep93xx_pwm_is_enabled(pwm))
179	ep93xx_pwm_enable(pwm);
180	} else {
181	return -EINVAL;
182	}
183
184	return count;
185	}
186
187	static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
188	struct device_attribute attr, char buf)
189	{
190	struct platform_device *pdev = to_platform_device(dev);
191	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
192
193	return sprintf(buf, "%d\n", pwm->duty_percent);
194	}
195
196	static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
197	struct device_attribute attr, const char buf, size_t count)
198	{
199	struct platform_device *pdev = to_platform_device(dev);
200	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
201	long val;
202	int err;
203
204	err = strict_strtol(buf, 10, &val);
205	if (err)
206	return -EINVAL;
207
208	if (val > 0 && val < 100) {
209	u32 term = ep93xx_pwm_read_tc(pwm);
210	ep93xx_pwm_write_dc(pwm, ((term + 1) * val / 100) - 1);
211	pwm->duty_percent = val;
212	return count;
213	}
214
215	return -EINVAL;
216	}
217
218	static ssize_t ep93xx_pwm_get_invert(struct device *dev,
219	struct device_attribute attr, char buf)
220	{
221	struct platform_device *pdev = to_platform_device(dev);
222	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
223
224	return sprintf(buf, "%d\n", ep93xx_pwm_is_inverted(pwm));
225	}
226
227	static ssize_t ep93xx_pwm_set_invert(struct device *dev,
228	struct device_attribute attr, const char buf, size_t count)
229	{
230	struct platform_device *pdev = to_platform_device(dev);
231	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
232	long val;
233	int err;
234
235	err = strict_strtol(buf, 10, &val);
236	if (err)
237	return -EINVAL;
238
239	if (val == 0)
240	ep93xx_pwm_normal(pwm);
241	else if (val == 1)
242	ep93xx_pwm_invert(pwm);
243	else
244	return -EINVAL;
245
246	return count;
247	}
248
249	static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
250	static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
251	static DEVICE_ATTR(freq, S_IWUGO \| S_IRUGO,
252	ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
253	static DEVICE_ATTR(duty_percent, S_IWUGO \| S_IRUGO,
254	ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
255	static DEVICE_ATTR(invert, S_IWUGO \| S_IRUGO,
256	ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
257
258	static struct attribute *ep93xx_pwm_attrs[] = {
259	&dev_attr_min_freq.attr,
260	&dev_attr_max_freq.attr,
261	&dev_attr_freq.attr,
262	&dev_attr_duty_percent.attr,
263	&dev_attr_invert.attr,
264	NULL
265	};
266
267	static const struct attribute_group ep93xx_pwm_sysfs_files = {
268	.attrs = ep93xx_pwm_attrs,
269	};
270
271	static int __init ep93xx_pwm_probe(struct platform_device *pdev)
272	{
273	struct ep93xx_pwm *pwm;
274	struct resource *res;
275	int err;
276
277	err = ep93xx_pwm_acquire_gpio(pdev);
278	if (err)
279	return err;
280
281	pwm = kzalloc(sizeof(struct ep93xx_pwm), GFP_KERNEL);
282	if (!pwm) {
283	err = -ENOMEM;
284	goto fail_no_mem;
285	}
286
287	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
288	if (res == NULL) {
289	err = -ENXIO;
290	goto fail_no_mem_resource;
291	}
292
293	res = request_mem_region(res->start, resource_size(res), pdev->name);
294	if (res == NULL) {
295	err = -EBUSY;
296	goto fail_no_mem_resource;
297	}
298
299	pwm->mmio_base = ioremap(res->start, resource_size(res));
300	if (pwm->mmio_base == NULL) {
301	err = -ENXIO;
302	goto fail_no_ioremap;
303	}
304
305	err = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
306	if (err)
307	goto fail_no_sysfs;
308
309	pwm->clk = clk_get(&pdev->dev, "pwm_clk");
310	if (IS_ERR(pwm->clk)) {
311	err = PTR_ERR(pwm->clk);
312	goto fail_no_clk;
313	}
314
315	pwm->duty_percent = 50;
316
317	platform_set_drvdata(pdev, pwm);
318
319	/* disable pwm at startup. Avoids zero value. */
320	ep93xx_pwm_disable(pwm);
321	ep93xx_pwm_write_tc(pwm, EP93XX_PWM_MAX_COUNT);
322	ep93xx_pwm_write_dc(pwm, EP93XX_PWM_MAX_COUNT / 2);
323
324	clk_enable(pwm->clk);
325
326	return 0;
327
328	fail_no_clk:
329	sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
330	fail_no_sysfs:
331	iounmap(pwm->mmio_base);
332	fail_no_ioremap:
333	release_mem_region(res->start, resource_size(res));
334	fail_no_mem_resource:
335	kfree(pwm);
336	fail_no_mem:
337	ep93xx_pwm_release_gpio(pdev);
338	return err;
339	}
340
341	static int __exit ep93xx_pwm_remove(struct platform_device *pdev)
342	{
343	struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
344	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
345
346	ep93xx_pwm_disable(pwm);
347	clk_disable(pwm->clk);
348	clk_put(pwm->clk);
349	platform_set_drvdata(pdev, NULL);
350	sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
351	iounmap(pwm->mmio_base);
352	release_mem_region(res->start, resource_size(res));
353	kfree(pwm);
354	ep93xx_pwm_release_gpio(pdev);
355
356	return 0;
357	}
358
359	static struct platform_driver ep93xx_pwm_driver = {
360	.driver = {
361	.name = "ep93xx-pwm",
362	.owner = THIS_MODULE,
363	},
364	.remove = __exit_p(ep93xx_pwm_remove),
365	};
366
367	static int __init ep93xx_pwm_init(void)
368	{
369	return platform_driver_probe(&ep93xx_pwm_driver, ep93xx_pwm_probe);
370	}
371
372	static void __exit ep93xx_pwm_exit(void)
373	{
374	platform_driver_unregister(&ep93xx_pwm_driver);
375	}
376
377	module_init(ep93xx_pwm_init);
378	module_exit(ep93xx_pwm_exit);
379
380	MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
381	"H Hartley Sweeten <hsweeten@visionengravers.com>");
382	MODULE_DESCRIPTION("EP93xx PWM driver");
383	MODULE_LICENSE("GPL");
384	MODULE_ALIAS("platform:ep93xx-pwm");