Root/drivers/pwm/core.c

1/*
2 * Generic pwmlib implementation
3 *
4 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de>
5 * Copyright (C) 2011-2012 Avionic Design GmbH
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; see the file COPYING. If not, write to
19 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22#include <linux/module.h>
23#include <linux/pwm.h>
24#include <linux/radix-tree.h>
25#include <linux/list.h>
26#include <linux/mutex.h>
27#include <linux/err.h>
28#include <linux/slab.h>
29#include <linux/device.h>
30#include <linux/debugfs.h>
31#include <linux/seq_file.h>
32
33#define MAX_PWMS 1024
34
35static DEFINE_MUTEX(pwm_lookup_lock);
36static LIST_HEAD(pwm_lookup_list);
37static DEFINE_MUTEX(pwm_lock);
38static LIST_HEAD(pwm_chips);
39static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
40static RADIX_TREE(pwm_tree, GFP_KERNEL);
41
42static struct pwm_device *pwm_to_device(unsigned int pwm)
43{
44    return radix_tree_lookup(&pwm_tree, pwm);
45}
46
47static int alloc_pwms(int pwm, unsigned int count)
48{
49    unsigned int from = 0;
50    unsigned int start;
51
52    if (pwm >= MAX_PWMS)
53        return -EINVAL;
54
55    if (pwm >= 0)
56        from = pwm;
57
58    start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from,
59                       count, 0);
60
61    if (pwm >= 0 && start != pwm)
62        return -EEXIST;
63
64    if (start + count > MAX_PWMS)
65        return -ENOSPC;
66
67    return start;
68}
69
70static void free_pwms(struct pwm_chip *chip)
71{
72    unsigned int i;
73
74    for (i = 0; i < chip->npwm; i++) {
75        struct pwm_device *pwm = &chip->pwms[i];
76        radix_tree_delete(&pwm_tree, pwm->pwm);
77    }
78
79    bitmap_clear(allocated_pwms, chip->base, chip->npwm);
80
81    kfree(chip->pwms);
82    chip->pwms = NULL;
83}
84
85static struct pwm_chip *pwmchip_find_by_name(const char *name)
86{
87    struct pwm_chip *chip;
88
89    if (!name)
90        return NULL;
91
92    mutex_lock(&pwm_lock);
93
94    list_for_each_entry(chip, &pwm_chips, list) {
95        const char *chip_name = dev_name(chip->dev);
96
97        if (chip_name && strcmp(chip_name, name) == 0) {
98            mutex_unlock(&pwm_lock);
99            return chip;
100        }
101    }
102
103    mutex_unlock(&pwm_lock);
104
105    return NULL;
106}
107
108static int pwm_device_request(struct pwm_device *pwm, const char *label)
109{
110    int err;
111
112    if (test_bit(PWMF_REQUESTED, &pwm->flags))
113        return -EBUSY;
114
115    if (!try_module_get(pwm->chip->ops->owner))
116        return -ENODEV;
117
118    if (pwm->chip->ops->request) {
119        err = pwm->chip->ops->request(pwm->chip, pwm);
120        if (err) {
121            module_put(pwm->chip->ops->owner);
122            return err;
123        }
124    }
125
126    set_bit(PWMF_REQUESTED, &pwm->flags);
127    pwm->label = label;
128
129    return 0;
130}
131
132static struct pwm_device *
133of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
134{
135    struct pwm_device *pwm;
136
137    if (pc->of_pwm_n_cells < 2)
138        return ERR_PTR(-EINVAL);
139
140    if (args->args[0] >= pc->npwm)
141        return ERR_PTR(-EINVAL);
142
143    pwm = pwm_request_from_chip(pc, args->args[0], NULL);
144    if (IS_ERR(pwm))
145        return pwm;
146
147    pwm_set_period(pwm, args->args[1]);
148
149    return pwm;
150}
151
152static void of_pwmchip_add(struct pwm_chip *chip)
153{
154    if (!chip->dev || !chip->dev->of_node)
155        return;
156
157    if (!chip->of_xlate) {
158        chip->of_xlate = of_pwm_simple_xlate;
159        chip->of_pwm_n_cells = 2;
160    }
161
162    of_node_get(chip->dev->of_node);
163}
164
165static void of_pwmchip_remove(struct pwm_chip *chip)
166{
167    if (chip->dev && chip->dev->of_node)
168        of_node_put(chip->dev->of_node);
169}
170
171/**
172 * pwm_set_chip_data() - set private chip data for a PWM
173 * @pwm: PWM device
174 * @data: pointer to chip-specific data
175 */
176int pwm_set_chip_data(struct pwm_device *pwm, void *data)
177{
178    if (!pwm)
179        return -EINVAL;
180
181    pwm->chip_data = data;
182
183    return 0;
184}
185
186/**
187 * pwm_get_chip_data() - get private chip data for a PWM
188 * @pwm: PWM device
189 */
190void *pwm_get_chip_data(struct pwm_device *pwm)
191{
192    return pwm ? pwm->chip_data : NULL;
193}
194
195/**
196 * pwmchip_add() - register a new PWM chip
197 * @chip: the PWM chip to add
198 *
199 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
200 * will be used.
201 */
202int pwmchip_add(struct pwm_chip *chip)
203{
204    struct pwm_device *pwm;
205    unsigned int i;
206    int ret;
207
208    if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
209        !chip->ops->enable || !chip->ops->disable)
210        return -EINVAL;
211
212    mutex_lock(&pwm_lock);
213
214    ret = alloc_pwms(chip->base, chip->npwm);
215    if (ret < 0)
216        goto out;
217
218    chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL);
219    if (!chip->pwms) {
220        ret = -ENOMEM;
221        goto out;
222    }
223
224    chip->base = ret;
225
226    for (i = 0; i < chip->npwm; i++) {
227        pwm = &chip->pwms[i];
228
229        pwm->chip = chip;
230        pwm->pwm = chip->base + i;
231        pwm->hwpwm = i;
232
233        radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
234    }
235
236    bitmap_set(allocated_pwms, chip->base, chip->npwm);
237
238    INIT_LIST_HEAD(&chip->list);
239    list_add(&chip->list, &pwm_chips);
240
241    ret = 0;
242
243    if (IS_ENABLED(CONFIG_OF))
244        of_pwmchip_add(chip);
245
246out:
247    mutex_unlock(&pwm_lock);
248    return ret;
249}
250EXPORT_SYMBOL_GPL(pwmchip_add);
251
252/**
253 * pwmchip_remove() - remove a PWM chip
254 * @chip: the PWM chip to remove
255 *
256 * Removes a PWM chip. This function may return busy if the PWM chip provides
257 * a PWM device that is still requested.
258 */
259int pwmchip_remove(struct pwm_chip *chip)
260{
261    unsigned int i;
262    int ret = 0;
263
264    mutex_lock(&pwm_lock);
265
266    for (i = 0; i < chip->npwm; i++) {
267        struct pwm_device *pwm = &chip->pwms[i];
268
269        if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
270            ret = -EBUSY;
271            goto out;
272        }
273    }
274
275    list_del_init(&chip->list);
276
277    if (IS_ENABLED(CONFIG_OF))
278        of_pwmchip_remove(chip);
279
280    free_pwms(chip);
281
282out:
283    mutex_unlock(&pwm_lock);
284    return ret;
285}
286EXPORT_SYMBOL_GPL(pwmchip_remove);
287
288/**
289 * pwm_request() - request a PWM device
290 * @pwm_id: global PWM device index
291 * @label: PWM device label
292 *
293 * This function is deprecated, use pwm_get() instead.
294 */
295struct pwm_device *pwm_request(int pwm, const char *label)
296{
297    struct pwm_device *dev;
298    int err;
299
300    if (pwm < 0 || pwm >= MAX_PWMS)
301        return ERR_PTR(-EINVAL);
302
303    mutex_lock(&pwm_lock);
304
305    dev = pwm_to_device(pwm);
306    if (!dev) {
307        dev = ERR_PTR(-EPROBE_DEFER);
308        goto out;
309    }
310
311    err = pwm_device_request(dev, label);
312    if (err < 0)
313        dev = ERR_PTR(err);
314
315out:
316    mutex_unlock(&pwm_lock);
317
318    return dev;
319}
320EXPORT_SYMBOL_GPL(pwm_request);
321
322/**
323 * pwm_request_from_chip() - request a PWM device relative to a PWM chip
324 * @chip: PWM chip
325 * @index: per-chip index of the PWM to request
326 * @label: a literal description string of this PWM
327 *
328 * Returns the PWM at the given index of the given PWM chip. A negative error
329 * code is returned if the index is not valid for the specified PWM chip or
330 * if the PWM device cannot be requested.
331 */
332struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
333                     unsigned int index,
334                     const char *label)
335{
336    struct pwm_device *pwm;
337    int err;
338
339    if (!chip || index >= chip->npwm)
340        return ERR_PTR(-EINVAL);
341
342    mutex_lock(&pwm_lock);
343    pwm = &chip->pwms[index];
344
345    err = pwm_device_request(pwm, label);
346    if (err < 0)
347        pwm = ERR_PTR(err);
348
349    mutex_unlock(&pwm_lock);
350    return pwm;
351}
352EXPORT_SYMBOL_GPL(pwm_request_from_chip);
353
354/**
355 * pwm_free() - free a PWM device
356 * @pwm: PWM device
357 *
358 * This function is deprecated, use pwm_put() instead.
359 */
360void pwm_free(struct pwm_device *pwm)
361{
362    pwm_put(pwm);
363}
364EXPORT_SYMBOL_GPL(pwm_free);
365
366/**
367 * pwm_config() - change a PWM device configuration
368 * @pwm: PWM device
369 * @duty_ns: "on" time (in nanoseconds)
370 * @period_ns: duration (in nanoseconds) of one cycle
371 */
372int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
373{
374    if (!pwm || period_ns == 0 || duty_ns > period_ns)
375        return -EINVAL;
376
377    return pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns);
378}
379EXPORT_SYMBOL_GPL(pwm_config);
380
381/**
382 * pwm_enable() - start a PWM output toggling
383 * @pwm: PWM device
384 */
385int pwm_enable(struct pwm_device *pwm)
386{
387    if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags))
388        return pwm->chip->ops->enable(pwm->chip, pwm);
389
390    return pwm ? 0 : -EINVAL;
391}
392EXPORT_SYMBOL_GPL(pwm_enable);
393
394/**
395 * pwm_disable() - stop a PWM output toggling
396 * @pwm: PWM device
397 */
398void pwm_disable(struct pwm_device *pwm)
399{
400    if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags))
401        pwm->chip->ops->disable(pwm->chip, pwm);
402}
403EXPORT_SYMBOL_GPL(pwm_disable);
404
405static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
406{
407    struct pwm_chip *chip;
408
409    mutex_lock(&pwm_lock);
410
411    list_for_each_entry(chip, &pwm_chips, list)
412        if (chip->dev && chip->dev->of_node == np) {
413            mutex_unlock(&pwm_lock);
414            return chip;
415        }
416
417    mutex_unlock(&pwm_lock);
418
419    return ERR_PTR(-EPROBE_DEFER);
420}
421
422/**
423 * of_pwm_request() - request a PWM via the PWM framework
424 * @np: device node to get the PWM from
425 * @con_id: consumer name
426 *
427 * Returns the PWM device parsed from the phandle and index specified in the
428 * "pwms" property of a device tree node or a negative error-code on failure.
429 * Values parsed from the device tree are stored in the returned PWM device
430 * object.
431 *
432 * If con_id is NULL, the first PWM device listed in the "pwms" property will
433 * be requested. Otherwise the "pwm-names" property is used to do a reverse
434 * lookup of the PWM index. This also means that the "pwm-names" property
435 * becomes mandatory for devices that look up the PWM device via the con_id
436 * parameter.
437 */
438static struct pwm_device *of_pwm_request(struct device_node *np,
439                     const char *con_id)
440{
441    struct pwm_device *pwm = NULL;
442    struct of_phandle_args args;
443    struct pwm_chip *pc;
444    int index = 0;
445    int err;
446
447    if (con_id) {
448        index = of_property_match_string(np, "pwm-names", con_id);
449        if (index < 0)
450            return ERR_PTR(index);
451    }
452
453    err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
454                     &args);
455    if (err) {
456        pr_debug("%s(): can't parse \"pwms\" property\n", __func__);
457        return ERR_PTR(err);
458    }
459
460    pc = of_node_to_pwmchip(args.np);
461    if (IS_ERR(pc)) {
462        pr_debug("%s(): PWM chip not found\n", __func__);
463        pwm = ERR_CAST(pc);
464        goto put;
465    }
466
467    if (args.args_count != pc->of_pwm_n_cells) {
468        pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name,
469             args.np->full_name);
470        pwm = ERR_PTR(-EINVAL);
471        goto put;
472    }
473
474    pwm = pc->of_xlate(pc, &args);
475    if (IS_ERR(pwm))
476        goto put;
477
478    /*
479     * If a consumer name was not given, try to look it up from the
480     * "pwm-names" property if it exists. Otherwise use the name of
481     * the user device node.
482     */
483    if (!con_id) {
484        err = of_property_read_string_index(np, "pwm-names", index,
485                            &con_id);
486        if (err < 0)
487            con_id = np->name;
488    }
489
490    pwm->label = con_id;
491
492put:
493    of_node_put(args.np);
494
495    return pwm;
496}
497
498/**
499 * pwm_add_table() - register PWM device consumers
500 * @table: array of consumers to register
501 * @num: number of consumers in table
502 */
503void __init pwm_add_table(struct pwm_lookup *table, size_t num)
504{
505    mutex_lock(&pwm_lookup_lock);
506
507    while (num--) {
508        list_add_tail(&table->list, &pwm_lookup_list);
509        table++;
510    }
511
512    mutex_unlock(&pwm_lookup_lock);
513}
514
515/**
516 * pwm_get() - look up and request a PWM device
517 * @dev: device for PWM consumer
518 * @con_id: consumer name
519 *
520 * Lookup is first attempted using DT. If the device was not instantiated from
521 * a device tree, a PWM chip and a relative index is looked up via a table
522 * supplied by board setup code (see pwm_add_table()).
523 *
524 * Once a PWM chip has been found the specified PWM device will be requested
525 * and is ready to be used.
526 */
527struct pwm_device *pwm_get(struct device *dev, const char *con_id)
528{
529    struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
530    const char *dev_id = dev ? dev_name(dev) : NULL;
531    struct pwm_chip *chip = NULL;
532    unsigned int index = 0;
533    unsigned int best = 0;
534    struct pwm_lookup *p;
535    unsigned int match;
536
537    /* look up via DT first */
538    if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
539        return of_pwm_request(dev->of_node, con_id);
540
541    /*
542     * We look up the provider in the static table typically provided by
543     * board setup code. We first try to lookup the consumer device by
544     * name. If the consumer device was passed in as NULL or if no match
545     * was found, we try to find the consumer by directly looking it up
546     * by name.
547     *
548     * If a match is found, the provider PWM chip is looked up by name
549     * and a PWM device is requested using the PWM device per-chip index.
550     *
551     * The lookup algorithm was shamelessly taken from the clock
552     * framework:
553     *
554     * We do slightly fuzzy matching here:
555     * An entry with a NULL ID is assumed to be a wildcard.
556     * If an entry has a device ID, it must match
557     * If an entry has a connection ID, it must match
558     * Then we take the most specific entry - with the following order
559     * of precedence: dev+con > dev only > con only.
560     */
561    mutex_lock(&pwm_lookup_lock);
562
563    list_for_each_entry(p, &pwm_lookup_list, list) {
564        match = 0;
565
566        if (p->dev_id) {
567            if (!dev_id || strcmp(p->dev_id, dev_id))
568                continue;
569
570            match += 2;
571        }
572
573        if (p->con_id) {
574            if (!con_id || strcmp(p->con_id, con_id))
575                continue;
576
577            match += 1;
578        }
579
580        if (match > best) {
581            chip = pwmchip_find_by_name(p->provider);
582            index = p->index;
583
584            if (match != 3)
585                best = match;
586            else
587                break;
588        }
589    }
590
591    if (chip)
592        pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id);
593
594    mutex_unlock(&pwm_lookup_lock);
595
596    return pwm;
597}
598EXPORT_SYMBOL_GPL(pwm_get);
599
600/**
601 * pwm_put() - release a PWM device
602 * @pwm: PWM device
603 */
604void pwm_put(struct pwm_device *pwm)
605{
606    if (!pwm)
607        return;
608
609    mutex_lock(&pwm_lock);
610
611    if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
612        pr_warn("PWM device already freed\n");
613        goto out;
614    }
615
616    if (pwm->chip->ops->free)
617        pwm->chip->ops->free(pwm->chip, pwm);
618
619    pwm->label = NULL;
620
621    module_put(pwm->chip->ops->owner);
622out:
623    mutex_unlock(&pwm_lock);
624}
625EXPORT_SYMBOL_GPL(pwm_put);
626
627#ifdef CONFIG_DEBUG_FS
628static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
629{
630    unsigned int i;
631
632    for (i = 0; i < chip->npwm; i++) {
633        struct pwm_device *pwm = &chip->pwms[i];
634
635        seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
636
637        if (test_bit(PWMF_REQUESTED, &pwm->flags))
638            seq_printf(s, " requested");
639
640        if (test_bit(PWMF_ENABLED, &pwm->flags))
641            seq_printf(s, " enabled");
642
643        seq_printf(s, "\n");
644    }
645}
646
647static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
648{
649    mutex_lock(&pwm_lock);
650    s->private = "";
651
652    return seq_list_start(&pwm_chips, *pos);
653}
654
655static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
656{
657    s->private = "\n";
658
659    return seq_list_next(v, &pwm_chips, pos);
660}
661
662static void pwm_seq_stop(struct seq_file *s, void *v)
663{
664    mutex_unlock(&pwm_lock);
665}
666
667static int pwm_seq_show(struct seq_file *s, void *v)
668{
669    struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
670
671    seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
672           chip->dev->bus ? chip->dev->bus->name : "no-bus",
673           dev_name(chip->dev), chip->npwm,
674           (chip->npwm != 1) ? "s" : "");
675
676    if (chip->ops->dbg_show)
677        chip->ops->dbg_show(chip, s);
678    else
679        pwm_dbg_show(chip, s);
680
681    return 0;
682}
683
684static const struct seq_operations pwm_seq_ops = {
685    .start = pwm_seq_start,
686    .next = pwm_seq_next,
687    .stop = pwm_seq_stop,
688    .show = pwm_seq_show,
689};
690
691static int pwm_seq_open(struct inode *inode, struct file *file)
692{
693    return seq_open(file, &pwm_seq_ops);
694}
695
696static const struct file_operations pwm_debugfs_ops = {
697    .owner = THIS_MODULE,
698    .open = pwm_seq_open,
699    .read = seq_read,
700    .llseek = seq_lseek,
701    .release = seq_release,
702};
703
704static int __init pwm_debugfs_init(void)
705{
706    debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
707                &pwm_debugfs_ops);
708
709    return 0;
710}
711
712subsys_initcall(pwm_debugfs_init);
713#endif /* CONFIG_DEBUG_FS */
714

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive