1/*
2 * drivers/pwm/pwm.c
3 *
4 * Copyright (C) 2010 Bill Gatliff <bgat@billgatliff.com>
5 *
6 * This program is free software; you may redistribute and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18 * USA
19 */
20
21#include <linux/kernel.h>
22#include <linux/module.h>
23#include <linux/init.h>
24#include <linux/device.h>
25#include <linux/spinlock.h>
26#include <linux/fs.h>
27#include <linux/completion.h>
28#include <linux/workqueue.h>
29#include <linux/list.h>
30#include <linux/sched.h>
31#include <linux/slab.h>    /*kcalloc, kfree since 2.6.34 */
32#include <linux/pwm/pwm.h>
33
34static int __pwm_create_sysfs(struct pwm_device *pwm);
35
36static const char *REQUEST_SYSFS = "sysfs";
37static LIST_HEAD(pwm_device_list);
38static DEFINE_MUTEX(device_list_mutex);
39static struct class pwm_class;
40static struct workqueue_struct *pwm_handler_workqueue;
41
42int pwm_register(struct pwm_device *pwm)
43{
44	struct pwm_channel *p;
45	int wchan;
46	int ret;
47
48	spin_lock_init(&pwm->list_lock);
49
50	p = kcalloc(pwm->nchan, sizeof(*p), GFP_KERNEL);
51	if (!p)
52		return -ENOMEM;
53
54	for (wchan = 0; wchan < pwm->nchan; wchan++) {
55		spin_lock_init(&p[wchan].lock);
56		init_completion(&p[wchan].complete);
57		p[wchan].chan = wchan;
58		p[wchan].pwm = pwm;
59	}
60
61	pwm->channels = p;
62
63	mutex_lock(&device_list_mutex);
64
65	list_add_tail(&pwm->list, &pwm_device_list);
66	ret = __pwm_create_sysfs(pwm);
67	if (ret) {
68		mutex_unlock(&device_list_mutex);
69		goto err_create_sysfs;
70	}
71
72	mutex_unlock(&device_list_mutex);
73
74	dev_info(pwm->dev, "%d channel%s\n", pwm->nchan,
75		 pwm->nchan > 1 ? "s" : "");
76	return 0;
77
78err_create_sysfs:
79	kfree(p);
80
81	return ret;
82}
83EXPORT_SYMBOL(pwm_register);
84
85static int __match_device(struct device *dev, void *data)
86{
87	return dev_get_drvdata(dev) == data;
88}
89
90int pwm_unregister(struct pwm_device *pwm)
91{
92	int wchan;
93	struct device *dev;
94
95	mutex_lock(&device_list_mutex);
96
97	for (wchan = 0; wchan < pwm->nchan; wchan++) {
98	  if (pwm->channels[wchan].flags & BIT(FLAG_REQUESTED)) {
99			mutex_unlock(&device_list_mutex);
100			return -EBUSY;
101		}
102	}
103
104	for (wchan = 0; wchan < pwm->nchan; wchan++) {
105		dev = class_find_device(&pwm_class, NULL,
106					&pwm->channels[wchan],
107					__match_device);
108		if (dev) {
109			put_device(dev);
110			device_unregister(dev);
111		}
112	}
113
114	kfree(pwm->channels);
115	list_del(&pwm->list);
116	mutex_unlock(&device_list_mutex);
117
118	return 0;
119}
120EXPORT_SYMBOL(pwm_unregister);
121
122static struct pwm_device *
123__pwm_find_device(const char *bus_id)
124{
125	struct pwm_device *p;
126
127	list_for_each_entry(p, &pwm_device_list, list) {
128		if (!strcmp(bus_id, p->bus_id))
129			return p;
130	}
131	return NULL;
132}
133
134static int
135__pwm_request_channel(struct pwm_channel *p,
136		      const char *requester)
137{
138	int ret;
139
140	if (test_and_set_bit(FLAG_REQUESTED, &p->flags))
141		return -EBUSY;
142
143	if (p->pwm->request) {
144		ret = p->pwm->request(p);
145		if (ret) {
146			clear_bit(FLAG_REQUESTED, &p->flags);
147			return ret;
148		}
149	}
150
151	p->requester = requester;
152	if (!strcmp(requester, REQUEST_SYSFS))
153		p->pid = current->pid;
154
155	return 0;
156}
157
158struct pwm_channel *
159pwm_request(const char *bus_id,
160	    int chan,
161	    const char *requester)
162{
163	struct pwm_device *p;
164	int ret;
165
166	mutex_lock(&device_list_mutex);
167
168	p = __pwm_find_device(bus_id);
169	if (!p || chan >= p->nchan)
170		goto err_no_device;
171
172	if (!try_module_get(p->owner))
173		goto err_module_get_failed;
174
175	ret = __pwm_request_channel(&p->channels[chan], requester);
176	if (ret)
177		goto err_request_failed;
178
179	mutex_unlock(&device_list_mutex);
180	return &p->channels[chan];
181
182err_request_failed:
183	module_put(p->owner);
184err_module_get_failed:
185err_no_device:
186	mutex_unlock(&device_list_mutex);
187	return NULL;
188}
189EXPORT_SYMBOL(pwm_request);
190
191void pwm_free(struct pwm_channel *p)
192{
193	mutex_lock(&device_list_mutex);
194
195	if (!test_and_clear_bit(FLAG_REQUESTED, &p->flags))
196		goto done;
197
198	pwm_stop(p);
199	pwm_unsynchronize(p, NULL);
200	pwm_set_handler(p, NULL, NULL);
201
202	if (p->pwm->free)
203		p->pwm->free(p);
204	module_put(p->pwm->owner);
205done:
206	mutex_unlock(&device_list_mutex);
207}
208EXPORT_SYMBOL(pwm_free);
209
210unsigned long pwm_ns_to_ticks(struct pwm_channel *p,
211			      unsigned long nsecs)
212{
213	unsigned long long ticks;
214
215	ticks = nsecs;
216	ticks *= p->tick_hz;
217	do_div(ticks, 1000000000);
218	return ticks;
219}
220EXPORT_SYMBOL(pwm_ns_to_ticks);
221
222unsigned long pwm_ticks_to_ns(struct pwm_channel *p,
223			      unsigned long ticks)
224{
225	unsigned long long ns;
226
227	if (!p->tick_hz)
228		return 0;
229
230	ns = ticks;
231	ns *= 1000000000UL;
232	do_div(ns, p->tick_hz);
233	return ns;
234}
235EXPORT_SYMBOL(pwm_ticks_to_ns);
236
237static void
238pwm_config_ns_to_ticks(struct pwm_channel *p,
239		       struct pwm_channel_config *c)
240{
241	if (c->config_mask & PWM_CONFIG_PERIOD_NS) {
242		c->period_ticks = pwm_ns_to_ticks(p, c->period_ns);
243		c->config_mask &= ~PWM_CONFIG_PERIOD_NS;
244		c->config_mask |= PWM_CONFIG_PERIOD_TICKS;
245	}
246
247	if (c->config_mask & PWM_CONFIG_DUTY_NS) {
248		c->duty_ticks = pwm_ns_to_ticks(p, c->duty_ns);
249		c->config_mask &= ~PWM_CONFIG_DUTY_NS;
250		c->config_mask |= PWM_CONFIG_DUTY_TICKS;
251	}
252}
253
254static void
255pwm_config_percent_to_ticks(struct pwm_channel *p,
256			    struct pwm_channel_config *c)
257{
258	if (c->config_mask & PWM_CONFIG_DUTY_PERCENT) {
259		if (c->config_mask & PWM_CONFIG_PERIOD_TICKS)
260			c->duty_ticks = c->period_ticks;
261		else
262			c->duty_ticks = p->period_ticks;
263
264		c->duty_ticks *= c->duty_percent;
265		c->duty_ticks /= 100;
266		c->config_mask &= ~PWM_CONFIG_DUTY_PERCENT;
267		c->config_mask |= PWM_CONFIG_DUTY_TICKS;
268	}
269}
270
271int pwm_config_nosleep(struct pwm_channel *p,
272		       struct pwm_channel_config *c)
273{
274	if (!p->pwm->config_nosleep)
275		return -EINVAL;
276
277	pwm_config_ns_to_ticks(p, c);
278	pwm_config_percent_to_ticks(p, c);
279
280	return p->pwm->config_nosleep(p, c);
281}
282EXPORT_SYMBOL(pwm_config_nosleep);
283
284int pwm_config(struct pwm_channel *p,
285	       struct pwm_channel_config *c)
286{
287	int ret = 0;
288
289	if (unlikely(!p->pwm->config))
290		return -EINVAL;
291
292	pwm_config_ns_to_ticks(p, c);
293	pwm_config_percent_to_ticks(p, c);
294
295	switch (c->config_mask & (PWM_CONFIG_PERIOD_TICKS
296				  | PWM_CONFIG_DUTY_TICKS)) {
297	case PWM_CONFIG_PERIOD_TICKS:
298		if (p->duty_ticks > c->period_ticks) {
299			ret = -EINVAL;
300			goto err;
301		}
302		break;
303	case PWM_CONFIG_DUTY_TICKS:
304		if (p->period_ticks < c->duty_ticks) {
305			ret = -EINVAL;
306			goto err;
307		}
308		break;
309	case PWM_CONFIG_DUTY_TICKS | PWM_CONFIG_PERIOD_TICKS:
310		if (c->duty_ticks > c->period_ticks) {
311			ret = -EINVAL;
312			goto err;
313		}
314		break;
315	default:
316		break;
317	}
318
319err:
320	dev_dbg(p->pwm->dev, "%s: config_mask %d period_ticks %lu duty_ticks %lu"
321		" polarity %d duty_ns %lu period_ns %lu duty_percent %d\n",
322		__func__, c->config_mask, c->period_ticks, c->duty_ticks,
323		c->polarity, c->duty_ns, c->period_ns, c->duty_percent);
324
325	if (ret)
326		return ret;
327	return p->pwm->config(p, c);
328}
329EXPORT_SYMBOL(pwm_config);
330
331int pwm_set_period_ns(struct pwm_channel *p,
332		      unsigned long period_ns)
333{
334	struct pwm_channel_config c = {
335		.config_mask = PWM_CONFIG_PERIOD_TICKS,
336		.period_ticks = pwm_ns_to_ticks(p, period_ns),
337	};
338
339	return pwm_config(p, &c);
340}
341EXPORT_SYMBOL(pwm_set_period_ns);
342
343unsigned long pwm_get_period_ns(struct pwm_channel *p)
344{
345	return pwm_ticks_to_ns(p, p->period_ticks);
346}
347EXPORT_SYMBOL(pwm_get_period_ns);
348
349int pwm_set_duty_ns(struct pwm_channel *p,
350		    unsigned long duty_ns)
351{
352	struct pwm_channel_config c = {
353		.config_mask = PWM_CONFIG_DUTY_TICKS,
354		.duty_ticks = pwm_ns_to_ticks(p, duty_ns),
355	};
356	return pwm_config(p, &c);
357}
358EXPORT_SYMBOL(pwm_set_duty_ns);
359
360unsigned long pwm_get_duty_ns(struct pwm_channel *p)
361{
362	return pwm_ticks_to_ns(p, p->duty_ticks);
363}
364EXPORT_SYMBOL(pwm_get_duty_ns);
365
366int pwm_set_duty_percent(struct pwm_channel *p,
367			 int percent)
368{
369	struct pwm_channel_config c = {
370		.config_mask = PWM_CONFIG_DUTY_PERCENT,
371		.duty_percent = percent,
372	};
373	return pwm_config(p, &c);
374}
375EXPORT_SYMBOL(pwm_set_duty_percent);
376
377int pwm_set_polarity(struct pwm_channel *p,
378		     int active_high)
379{
380	struct pwm_channel_config c = {
381		.config_mask = PWM_CONFIG_POLARITY,
382		.polarity = active_high,
383	};
384	return pwm_config(p, &c);
385}
386EXPORT_SYMBOL(pwm_set_polarity);
387
388int pwm_start(struct pwm_channel *p)
389{
390	struct pwm_channel_config c = {
391		.config_mask = PWM_CONFIG_START,
392	};
393	return pwm_config(p, &c);
394}
395EXPORT_SYMBOL(pwm_start);
396
397int pwm_stop(struct pwm_channel *p)
398{
399	struct pwm_channel_config c = {
400		.config_mask = PWM_CONFIG_STOP,
401	};
402	return pwm_config(p, &c);
403}
404EXPORT_SYMBOL(pwm_stop);
405
406int pwm_synchronize(struct pwm_channel *p,
407		    struct pwm_channel *to_p)
408{
409	if (p->pwm != to_p->pwm) {
410		/* TODO: support cross-device synchronization */
411		return -EINVAL;
412	}
413
414	if (!p->pwm->synchronize)
415		return -EINVAL;
416
417	return p->pwm->synchronize(p, to_p);
418}
419EXPORT_SYMBOL(pwm_synchronize);
420
421int pwm_unsynchronize(struct pwm_channel *p,
422		      struct pwm_channel *from_p)
423{
424	if (from_p && (p->pwm != from_p->pwm)) {
425		/* TODO: support cross-device synchronization */
426		return -EINVAL;
427	}
428
429	if (!p->pwm->unsynchronize)
430		return -EINVAL;
431
432	return p->pwm->unsynchronize(p, from_p);
433}
434EXPORT_SYMBOL(pwm_unsynchronize);
435
436static void pwm_handler(struct work_struct *w)
437{
438	struct pwm_channel *p = container_of(w, struct pwm_channel,
439					     handler_work);
440	if (p->handler && p->handler(p, p->handler_data))
441		pwm_stop(p);
442}
443
444static void __pwm_callback(struct pwm_channel *p)
445{
446	queue_work(pwm_handler_workqueue, &p->handler_work);
447	dev_dbg(p->pwm->dev, "handler %p scheduled with data %p\n",
448		p->handler, p->handler_data);
449}
450
451int pwm_set_handler(struct pwm_channel *p,
452		    pwm_handler_t handler,
453		    void *data)
454{
455	if (p->pwm->set_callback) {
456		p->handler_data = data;
457		p->handler = handler;
458		INIT_WORK(&p->handler_work, pwm_handler);
459		return p->pwm->set_callback(p, handler ? __pwm_callback : NULL);
460	}
461	return -EINVAL;
462}
463EXPORT_SYMBOL(pwm_set_handler);
464
465static ssize_t pwm_run_store(struct device *dev,
466			     struct device_attribute *attr,
467			     const char *buf,
468			     size_t len)
469{
470	struct pwm_channel *p = dev_get_drvdata(dev);
471	if (sysfs_streq(buf, "1"))
472		pwm_start(p);
473	else if (sysfs_streq(buf, "0"))
474		pwm_stop(p);
475	return len;
476}
477static DEVICE_ATTR(run, 0200, NULL, pwm_run_store);
478
479static ssize_t pwm_duty_ns_show(struct device *dev,
480				struct device_attribute *attr,
481				char *buf)
482{
483	struct pwm_channel *p = dev_get_drvdata(dev);
484	return sprintf(buf, "%lu\n", pwm_get_duty_ns(p));
485}
486
487static ssize_t pwm_duty_ns_store(struct device *dev,
488				 struct device_attribute *attr,
489				 const char *buf,
490				 size_t len)
491{
492	unsigned long duty_ns;
493	struct pwm_channel *p = dev_get_drvdata(dev);
494
495	if (1 == sscanf(buf, "%lu", &duty_ns))
496		pwm_set_duty_ns(p, duty_ns);
497	return len;
498}
499static DEVICE_ATTR(duty_ns, 0644, pwm_duty_ns_show, pwm_duty_ns_store);
500
501static ssize_t pwm_period_ns_show(struct device *dev,
502				  struct device_attribute *attr,
503				  char *buf)
504{
505	struct pwm_channel *p = dev_get_drvdata(dev);
506	return sprintf(buf, "%lu\n", pwm_get_period_ns(p));
507}
508
509static ssize_t pwm_period_ns_store(struct device *dev,
510				   struct device_attribute *attr,
511				   const char *buf,
512				   size_t len)
513{
514	unsigned long period_ns;
515	struct pwm_channel *p = dev_get_drvdata(dev);
516
517	if (1 == sscanf(buf, "%lu", &period_ns))
518		pwm_set_period_ns(p, period_ns);
519	return len;
520}
521static DEVICE_ATTR(period_ns, 0644, pwm_period_ns_show, pwm_period_ns_store);
522
523static ssize_t pwm_polarity_show(struct device *dev,
524				 struct device_attribute *attr,
525				 char *buf)
526{
527	struct pwm_channel *p = dev_get_drvdata(dev);
528	return sprintf(buf, "%d\n", p->active_high ? 1 : 0);
529}
530
531static ssize_t pwm_polarity_store(struct device *dev,
532				  struct device_attribute *attr,
533				  const char *buf,
534				  size_t len)
535{
536	int polarity;
537	struct pwm_channel *p = dev_get_drvdata(dev);
538
539	if (1 == sscanf(buf, "%d", &polarity))
540		pwm_set_polarity(p, polarity);
541	return len;
542}
543static DEVICE_ATTR(polarity, 0644, pwm_polarity_show, pwm_polarity_store);
544
545static ssize_t pwm_request_show(struct device *dev,
546				struct device_attribute *attr,
547				char *buf)
548{
549	struct pwm_channel *p = dev_get_drvdata(dev);
550	mutex_lock(&device_list_mutex);
551	__pwm_request_channel(p, REQUEST_SYSFS);
552	mutex_unlock(&device_list_mutex);
553
554	if (p->pid)
555		return sprintf(buf, "%s %d\n", p->requester, p->pid);
556	else
557		return sprintf(buf, "%s\n", p->requester);
558}
559
560static ssize_t pwm_request_store(struct device *dev,
561				 struct device_attribute *attr,
562				 const char *buf,
563				 size_t len)
564{
565	struct pwm_channel *p = dev_get_drvdata(dev);
566	pwm_free(p);
567	return len;
568}
569static DEVICE_ATTR(request, 0644, pwm_request_show, pwm_request_store);
570
571static const struct attribute *pwm_attrs[] =
572{
573	&dev_attr_run.attr,
574	&dev_attr_polarity.attr,
575	&dev_attr_duty_ns.attr,
576	&dev_attr_period_ns.attr,
577	&dev_attr_request.attr,
578	NULL,
579};
580
581static const struct attribute_group pwm_device_attr_group = {
582	.attrs = (struct attribute **)pwm_attrs,
583};
584
585static int __pwm_create_sysfs(struct pwm_device *pwm)
586{
587	int ret = 0;
588	struct device *dev;
589	int wchan;
590
591	for (wchan = 0; wchan < pwm->nchan; wchan++) {
592		dev = device_create(&pwm_class, pwm->dev, MKDEV(0, 0),
593				    pwm->channels + wchan,
594				    "%s:%d", pwm->bus_id, wchan);
595		if (!dev)
596			goto err_dev_create;
597		ret = sysfs_create_group(&dev->kobj, &pwm_device_attr_group);
598		if (ret)
599			goto err_dev_create;
600	}
601
602	return ret;
603
604err_dev_create:
605	for (wchan = 0; wchan < pwm->nchan; wchan++) {
606		dev = class_find_device(&pwm_class, NULL,
607					&pwm->channels[wchan],
608					__match_device);
609		if (dev) {
610			put_device(dev);
611			device_unregister(dev);
612		}
613	}
614
615	return ret;
616}
617
618static struct class_attribute pwm_class_attrs[] = {
619	__ATTR_NULL,
620};
621
622static struct class pwm_class = {
623	.name = "pwm",
624	.owner = THIS_MODULE,
625
626	.class_attrs = pwm_class_attrs,
627};
628
629static int __init pwm_init(void)
630{
631	int ret;
632
633	/* TODO: how to deal with devices that register very early? */
634	pr_err("%s\n", __func__);
635	ret = class_register(&pwm_class);
636	if (ret < 0)
637		return ret;
638
639	pwm_handler_workqueue = create_workqueue("pwmd");
640
641	return 0;
642}
643postcore_initcall(pwm_init);
644