blob: 903138b18842d5fb94cdc88316419702f7e0ae8c [file] [log] [blame]
Sascha Hauer0c2498f2011-01-28 09:40:40 +01001/*
2 * Generic pwmlib implementation
3 *
4 * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de>
Thierry Redingf051c462011-12-14 11:12:23 +01005 * Copyright (C) 2011-2012 Avionic Design GmbH
Sascha Hauer0c2498f2011-01-28 09:40:40 +01006 *
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>
Thierry Redingf051c462011-12-14 11:12:23 +010024#include <linux/radix-tree.h>
Sascha Hauer0c2498f2011-01-28 09:40:40 +010025#include <linux/list.h>
26#include <linux/mutex.h>
27#include <linux/err.h>
28#include <linux/slab.h>
29#include <linux/device.h>
Thierry Reding62099ab2012-03-26 09:31:48 +020030#include <linux/debugfs.h>
31#include <linux/seq_file.h>
Sascha Hauer0c2498f2011-01-28 09:40:40 +010032
Thierry Redingf051c462011-12-14 11:12:23 +010033#define MAX_PWMS 1024
Sascha Hauer0c2498f2011-01-28 09:40:40 +010034
Philip, Avinash83af2402012-11-21 13:10:44 +053035/* flags in the third cell of the DT PWM specifier */
36#define PWM_SPEC_POLARITY (1 << 0)
37
Thierry Reding8138d2d2012-03-26 08:42:48 +020038static DEFINE_MUTEX(pwm_lookup_lock);
39static LIST_HEAD(pwm_lookup_list);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010040static DEFINE_MUTEX(pwm_lock);
Thierry Redingf051c462011-12-14 11:12:23 +010041static LIST_HEAD(pwm_chips);
42static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
43static RADIX_TREE(pwm_tree, GFP_KERNEL);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010044
Thierry Redingf051c462011-12-14 11:12:23 +010045static struct pwm_device *pwm_to_device(unsigned int pwm)
Sascha Hauer0c2498f2011-01-28 09:40:40 +010046{
Thierry Redingf051c462011-12-14 11:12:23 +010047 return radix_tree_lookup(&pwm_tree, pwm);
48}
Sascha Hauer0c2498f2011-01-28 09:40:40 +010049
Thierry Redingf051c462011-12-14 11:12:23 +010050static int alloc_pwms(int pwm, unsigned int count)
51{
52 unsigned int from = 0;
53 unsigned int start;
54
55 if (pwm >= MAX_PWMS)
56 return -EINVAL;
57
58 if (pwm >= 0)
59 from = pwm;
60
61 start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from,
62 count, 0);
63
64 if (pwm >= 0 && start != pwm)
65 return -EEXIST;
66
67 if (start + count > MAX_PWMS)
68 return -ENOSPC;
69
70 return start;
71}
72
73static void free_pwms(struct pwm_chip *chip)
74{
75 unsigned int i;
76
77 for (i = 0; i < chip->npwm; i++) {
78 struct pwm_device *pwm = &chip->pwms[i];
79 radix_tree_delete(&pwm_tree, pwm->pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +010080 }
81
Thierry Redingf051c462011-12-14 11:12:23 +010082 bitmap_clear(allocated_pwms, chip->base, chip->npwm);
83
84 kfree(chip->pwms);
85 chip->pwms = NULL;
86}
87
Thierry Reding8138d2d2012-03-26 08:42:48 +020088static struct pwm_chip *pwmchip_find_by_name(const char *name)
89{
90 struct pwm_chip *chip;
91
92 if (!name)
93 return NULL;
94
95 mutex_lock(&pwm_lock);
96
97 list_for_each_entry(chip, &pwm_chips, list) {
98 const char *chip_name = dev_name(chip->dev);
99
100 if (chip_name && strcmp(chip_name, name) == 0) {
101 mutex_unlock(&pwm_lock);
102 return chip;
103 }
104 }
105
106 mutex_unlock(&pwm_lock);
107
108 return NULL;
109}
110
Thierry Redingf051c462011-12-14 11:12:23 +0100111static int pwm_device_request(struct pwm_device *pwm, const char *label)
112{
113 int err;
114
115 if (test_bit(PWMF_REQUESTED, &pwm->flags))
116 return -EBUSY;
117
118 if (!try_module_get(pwm->chip->ops->owner))
119 return -ENODEV;
120
121 if (pwm->chip->ops->request) {
122 err = pwm->chip->ops->request(pwm->chip, pwm);
123 if (err) {
124 module_put(pwm->chip->ops->owner);
125 return err;
126 }
127 }
128
129 set_bit(PWMF_REQUESTED, &pwm->flags);
130 pwm->label = label;
131
132 return 0;
133}
134
Philip, Avinash83af2402012-11-21 13:10:44 +0530135struct pwm_device *
136of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args)
137{
138 struct pwm_device *pwm;
139
140 if (pc->of_pwm_n_cells < 3)
141 return ERR_PTR(-EINVAL);
142
143 if (args->args[0] >= pc->npwm)
144 return ERR_PTR(-EINVAL);
145
146 pwm = pwm_request_from_chip(pc, args->args[0], NULL);
147 if (IS_ERR(pwm))
148 return pwm;
149
150 pwm_set_period(pwm, args->args[1]);
151
152 if (args->args[2] & PWM_SPEC_POLARITY)
153 pwm_set_polarity(pwm, PWM_POLARITY_INVERSED);
154 else
155 pwm_set_polarity(pwm, PWM_POLARITY_NORMAL);
156
157 return pwm;
158}
Thierry Reding417328c2012-11-28 15:12:07 +0100159EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
Philip, Avinash83af2402012-11-21 13:10:44 +0530160
Sachin Kamate50d3522012-08-10 16:41:13 +0530161static struct pwm_device *
162of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
Thierry Reding7299ab72011-12-14 11:10:32 +0100163{
164 struct pwm_device *pwm;
165
166 if (pc->of_pwm_n_cells < 2)
167 return ERR_PTR(-EINVAL);
168
169 if (args->args[0] >= pc->npwm)
170 return ERR_PTR(-EINVAL);
171
172 pwm = pwm_request_from_chip(pc, args->args[0], NULL);
173 if (IS_ERR(pwm))
174 return pwm;
175
176 pwm_set_period(pwm, args->args[1]);
177
178 return pwm;
179}
180
Sachin Kamatdfeb86e2012-08-02 12:32:42 +0530181static void of_pwmchip_add(struct pwm_chip *chip)
Thierry Reding7299ab72011-12-14 11:10:32 +0100182{
183 if (!chip->dev || !chip->dev->of_node)
184 return;
185
186 if (!chip->of_xlate) {
187 chip->of_xlate = of_pwm_simple_xlate;
188 chip->of_pwm_n_cells = 2;
189 }
190
191 of_node_get(chip->dev->of_node);
192}
193
Sachin Kamatdfeb86e2012-08-02 12:32:42 +0530194static void of_pwmchip_remove(struct pwm_chip *chip)
Thierry Reding7299ab72011-12-14 11:10:32 +0100195{
196 if (chip->dev && chip->dev->of_node)
197 of_node_put(chip->dev->of_node);
198}
199
Thierry Redingf051c462011-12-14 11:12:23 +0100200/**
201 * pwm_set_chip_data() - set private chip data for a PWM
202 * @pwm: PWM device
203 * @data: pointer to chip-specific data
204 */
205int pwm_set_chip_data(struct pwm_device *pwm, void *data)
206{
207 if (!pwm)
208 return -EINVAL;
209
210 pwm->chip_data = data;
211
212 return 0;
213}
214
215/**
216 * pwm_get_chip_data() - get private chip data for a PWM
217 * @pwm: PWM device
218 */
219void *pwm_get_chip_data(struct pwm_device *pwm)
220{
221 return pwm ? pwm->chip_data : NULL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100222}
223
224/**
225 * pwmchip_add() - register a new PWM chip
226 * @chip: the PWM chip to add
Thierry Redingf051c462011-12-14 11:12:23 +0100227 *
228 * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
229 * will be used.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100230 */
231int pwmchip_add(struct pwm_chip *chip)
232{
233 struct pwm_device *pwm;
Thierry Redingf051c462011-12-14 11:12:23 +0100234 unsigned int i;
235 int ret;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100236
Thierry Redingf051c462011-12-14 11:12:23 +0100237 if (!chip || !chip->dev || !chip->ops || !chip->ops->config ||
238 !chip->ops->enable || !chip->ops->disable)
239 return -EINVAL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100240
241 mutex_lock(&pwm_lock);
242
Thierry Redingf051c462011-12-14 11:12:23 +0100243 ret = alloc_pwms(chip->base, chip->npwm);
244 if (ret < 0)
245 goto out;
246
247 chip->pwms = kzalloc(chip->npwm * sizeof(*pwm), GFP_KERNEL);
248 if (!chip->pwms) {
249 ret = -ENOMEM;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100250 goto out;
251 }
252
Thierry Redingf051c462011-12-14 11:12:23 +0100253 chip->base = ret;
254
255 for (i = 0; i < chip->npwm; i++) {
256 pwm = &chip->pwms[i];
257
258 pwm->chip = chip;
259 pwm->pwm = chip->base + i;
260 pwm->hwpwm = i;
261
262 radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
263 }
264
265 bitmap_set(allocated_pwms, chip->base, chip->npwm);
266
267 INIT_LIST_HEAD(&chip->list);
268 list_add(&chip->list, &pwm_chips);
269
270 ret = 0;
271
Thierry Reding7299ab72011-12-14 11:10:32 +0100272 if (IS_ENABLED(CONFIG_OF))
273 of_pwmchip_add(chip);
274
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100275out:
276 mutex_unlock(&pwm_lock);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100277 return ret;
278}
279EXPORT_SYMBOL_GPL(pwmchip_add);
280
281/**
282 * pwmchip_remove() - remove a PWM chip
283 * @chip: the PWM chip to remove
284 *
285 * Removes a PWM chip. This function may return busy if the PWM chip provides
286 * a PWM device that is still requested.
287 */
288int pwmchip_remove(struct pwm_chip *chip)
289{
Thierry Redingf051c462011-12-14 11:12:23 +0100290 unsigned int i;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100291 int ret = 0;
292
293 mutex_lock(&pwm_lock);
294
Thierry Redingf051c462011-12-14 11:12:23 +0100295 for (i = 0; i < chip->npwm; i++) {
296 struct pwm_device *pwm = &chip->pwms[i];
297
298 if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
299 ret = -EBUSY;
300 goto out;
301 }
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100302 }
303
Thierry Redingf051c462011-12-14 11:12:23 +0100304 list_del_init(&chip->list);
Thierry Reding7299ab72011-12-14 11:10:32 +0100305
306 if (IS_ENABLED(CONFIG_OF))
307 of_pwmchip_remove(chip);
308
Thierry Redingf051c462011-12-14 11:12:23 +0100309 free_pwms(chip);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100310
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100311out:
312 mutex_unlock(&pwm_lock);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100313 return ret;
314}
315EXPORT_SYMBOL_GPL(pwmchip_remove);
316
317/**
318 * pwm_request() - request a PWM device
319 * @pwm_id: global PWM device index
320 * @label: PWM device label
Thierry Reding8138d2d2012-03-26 08:42:48 +0200321 *
322 * This function is deprecated, use pwm_get() instead.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100323 */
Thierry Redingf051c462011-12-14 11:12:23 +0100324struct pwm_device *pwm_request(int pwm, const char *label)
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100325{
Thierry Redingf051c462011-12-14 11:12:23 +0100326 struct pwm_device *dev;
327 int err;
328
329 if (pwm < 0 || pwm >= MAX_PWMS)
330 return ERR_PTR(-EINVAL);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100331
332 mutex_lock(&pwm_lock);
333
Thierry Redingf051c462011-12-14 11:12:23 +0100334 dev = pwm_to_device(pwm);
335 if (!dev) {
336 dev = ERR_PTR(-EPROBE_DEFER);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100337 goto out;
338 }
339
Thierry Redingf051c462011-12-14 11:12:23 +0100340 err = pwm_device_request(dev, label);
341 if (err < 0)
342 dev = ERR_PTR(err);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100343
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100344out:
345 mutex_unlock(&pwm_lock);
346
Thierry Redingf051c462011-12-14 11:12:23 +0100347 return dev;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100348}
349EXPORT_SYMBOL_GPL(pwm_request);
350
351/**
Thierry Redingf051c462011-12-14 11:12:23 +0100352 * pwm_request_from_chip() - request a PWM device relative to a PWM chip
353 * @chip: PWM chip
354 * @index: per-chip index of the PWM to request
355 * @label: a literal description string of this PWM
356 *
357 * Returns the PWM at the given index of the given PWM chip. A negative error
358 * code is returned if the index is not valid for the specified PWM chip or
359 * if the PWM device cannot be requested.
360 */
361struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
362 unsigned int index,
363 const char *label)
364{
365 struct pwm_device *pwm;
366 int err;
367
368 if (!chip || index >= chip->npwm)
369 return ERR_PTR(-EINVAL);
370
371 mutex_lock(&pwm_lock);
372 pwm = &chip->pwms[index];
373
374 err = pwm_device_request(pwm, label);
375 if (err < 0)
376 pwm = ERR_PTR(err);
377
378 mutex_unlock(&pwm_lock);
379 return pwm;
380}
381EXPORT_SYMBOL_GPL(pwm_request_from_chip);
382
383/**
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100384 * pwm_free() - free a PWM device
385 * @pwm: PWM device
Thierry Reding8138d2d2012-03-26 08:42:48 +0200386 *
387 * This function is deprecated, use pwm_put() instead.
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100388 */
389void pwm_free(struct pwm_device *pwm)
390{
Thierry Reding8138d2d2012-03-26 08:42:48 +0200391 pwm_put(pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100392}
393EXPORT_SYMBOL_GPL(pwm_free);
394
395/**
396 * pwm_config() - change a PWM device configuration
397 * @pwm: PWM device
398 * @duty_ns: "on" time (in nanoseconds)
399 * @period_ns: duration (in nanoseconds) of one cycle
400 */
401int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
402{
Thierry Redingc2d476a2012-09-02 22:13:40 +0200403 if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns)
Thierry Redingf051c462011-12-14 11:12:23 +0100404 return -EINVAL;
405
406 return pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100407}
408EXPORT_SYMBOL_GPL(pwm_config);
409
410/**
Philip, Avinash0aa08692012-07-24 19:35:32 +0530411 * pwm_set_polarity() - configure the polarity of a PWM signal
412 * @pwm: PWM device
413 * @polarity: new polarity of the PWM signal
414 *
415 * Note that the polarity cannot be configured while the PWM device is enabled
416 */
417int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity)
418{
419 if (!pwm || !pwm->chip->ops)
420 return -EINVAL;
421
422 if (!pwm->chip->ops->set_polarity)
423 return -ENOSYS;
424
425 if (test_bit(PWMF_ENABLED, &pwm->flags))
426 return -EBUSY;
427
428 return pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity);
429}
430EXPORT_SYMBOL_GPL(pwm_set_polarity);
431
432/**
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100433 * pwm_enable() - start a PWM output toggling
434 * @pwm: PWM device
435 */
436int pwm_enable(struct pwm_device *pwm)
437{
Thierry Redingf051c462011-12-14 11:12:23 +0100438 if (pwm && !test_and_set_bit(PWMF_ENABLED, &pwm->flags))
439 return pwm->chip->ops->enable(pwm->chip, pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100440
Thierry Redingf051c462011-12-14 11:12:23 +0100441 return pwm ? 0 : -EINVAL;
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100442}
443EXPORT_SYMBOL_GPL(pwm_enable);
444
445/**
446 * pwm_disable() - stop a PWM output toggling
447 * @pwm: PWM device
448 */
449void pwm_disable(struct pwm_device *pwm)
450{
Thierry Redingf051c462011-12-14 11:12:23 +0100451 if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags))
452 pwm->chip->ops->disable(pwm->chip, pwm);
Sascha Hauer0c2498f2011-01-28 09:40:40 +0100453}
454EXPORT_SYMBOL_GPL(pwm_disable);
Thierry Reding62099ab2012-03-26 09:31:48 +0200455
Thierry Reding7299ab72011-12-14 11:10:32 +0100456static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
457{
458 struct pwm_chip *chip;
459
460 mutex_lock(&pwm_lock);
461
462 list_for_each_entry(chip, &pwm_chips, list)
463 if (chip->dev && chip->dev->of_node == np) {
464 mutex_unlock(&pwm_lock);
465 return chip;
466 }
467
468 mutex_unlock(&pwm_lock);
469
470 return ERR_PTR(-EPROBE_DEFER);
471}
472
473/**
474 * of_pwm_request() - request a PWM via the PWM framework
475 * @np: device node to get the PWM from
476 * @con_id: consumer name
477 *
478 * Returns the PWM device parsed from the phandle and index specified in the
479 * "pwms" property of a device tree node or a negative error-code on failure.
480 * Values parsed from the device tree are stored in the returned PWM device
481 * object.
482 *
483 * If con_id is NULL, the first PWM device listed in the "pwms" property will
484 * be requested. Otherwise the "pwm-names" property is used to do a reverse
485 * lookup of the PWM index. This also means that the "pwm-names" property
486 * becomes mandatory for devices that look up the PWM device via the con_id
487 * parameter.
488 */
489static struct pwm_device *of_pwm_request(struct device_node *np,
490 const char *con_id)
491{
492 struct pwm_device *pwm = NULL;
493 struct of_phandle_args args;
494 struct pwm_chip *pc;
495 int index = 0;
496 int err;
497
498 if (con_id) {
499 index = of_property_match_string(np, "pwm-names", con_id);
500 if (index < 0)
501 return ERR_PTR(index);
502 }
503
504 err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
505 &args);
506 if (err) {
507 pr_debug("%s(): can't parse \"pwms\" property\n", __func__);
508 return ERR_PTR(err);
509 }
510
511 pc = of_node_to_pwmchip(args.np);
512 if (IS_ERR(pc)) {
513 pr_debug("%s(): PWM chip not found\n", __func__);
514 pwm = ERR_CAST(pc);
515 goto put;
516 }
517
518 if (args.args_count != pc->of_pwm_n_cells) {
519 pr_debug("%s: wrong #pwm-cells for %s\n", np->full_name,
520 args.np->full_name);
521 pwm = ERR_PTR(-EINVAL);
522 goto put;
523 }
524
525 pwm = pc->of_xlate(pc, &args);
526 if (IS_ERR(pwm))
527 goto put;
528
529 /*
530 * If a consumer name was not given, try to look it up from the
531 * "pwm-names" property if it exists. Otherwise use the name of
532 * the user device node.
533 */
534 if (!con_id) {
535 err = of_property_read_string_index(np, "pwm-names", index,
536 &con_id);
537 if (err < 0)
538 con_id = np->name;
539 }
540
541 pwm->label = con_id;
542
543put:
544 of_node_put(args.np);
545
546 return pwm;
547}
548
Thierry Reding8138d2d2012-03-26 08:42:48 +0200549/**
550 * pwm_add_table() - register PWM device consumers
551 * @table: array of consumers to register
552 * @num: number of consumers in table
553 */
554void __init pwm_add_table(struct pwm_lookup *table, size_t num)
555{
556 mutex_lock(&pwm_lookup_lock);
557
558 while (num--) {
559 list_add_tail(&table->list, &pwm_lookup_list);
560 table++;
561 }
562
563 mutex_unlock(&pwm_lookup_lock);
564}
565
566/**
567 * pwm_get() - look up and request a PWM device
568 * @dev: device for PWM consumer
569 * @con_id: consumer name
570 *
Thierry Reding7299ab72011-12-14 11:10:32 +0100571 * Lookup is first attempted using DT. If the device was not instantiated from
572 * a device tree, a PWM chip and a relative index is looked up via a table
573 * supplied by board setup code (see pwm_add_table()).
Thierry Reding8138d2d2012-03-26 08:42:48 +0200574 *
575 * Once a PWM chip has been found the specified PWM device will be requested
576 * and is ready to be used.
577 */
578struct pwm_device *pwm_get(struct device *dev, const char *con_id)
579{
580 struct pwm_device *pwm = ERR_PTR(-EPROBE_DEFER);
Sachin Kamate50d3522012-08-10 16:41:13 +0530581 const char *dev_id = dev ? dev_name(dev) : NULL;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200582 struct pwm_chip *chip = NULL;
Thierry Redingd295b122012-07-11 08:05:05 +0200583 unsigned int index = 0;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200584 unsigned int best = 0;
585 struct pwm_lookup *p;
Thierry Reding8138d2d2012-03-26 08:42:48 +0200586 unsigned int match;
587
Thierry Reding7299ab72011-12-14 11:10:32 +0100588 /* look up via DT first */
589 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
590 return of_pwm_request(dev->of_node, con_id);
591
Thierry Reding8138d2d2012-03-26 08:42:48 +0200592 /*
593 * We look up the provider in the static table typically provided by
594 * board setup code. We first try to lookup the consumer device by
595 * name. If the consumer device was passed in as NULL or if no match
596 * was found, we try to find the consumer by directly looking it up
597 * by name.
598 *
599 * If a match is found, the provider PWM chip is looked up by name
600 * and a PWM device is requested using the PWM device per-chip index.
601 *
602 * The lookup algorithm was shamelessly taken from the clock
603 * framework:
604 *
605 * We do slightly fuzzy matching here:
606 * An entry with a NULL ID is assumed to be a wildcard.
607 * If an entry has a device ID, it must match
608 * If an entry has a connection ID, it must match
609 * Then we take the most specific entry - with the following order
610 * of precedence: dev+con > dev only > con only.
611 */
612 mutex_lock(&pwm_lookup_lock);
613
614 list_for_each_entry(p, &pwm_lookup_list, list) {
615 match = 0;
616
617 if (p->dev_id) {
618 if (!dev_id || strcmp(p->dev_id, dev_id))
619 continue;
620
621 match += 2;
622 }
623
624 if (p->con_id) {
625 if (!con_id || strcmp(p->con_id, con_id))
626 continue;
627
628 match += 1;
629 }
630
631 if (match > best) {
632 chip = pwmchip_find_by_name(p->provider);
633 index = p->index;
634
635 if (match != 3)
636 best = match;
637 else
638 break;
639 }
640 }
641
642 if (chip)
643 pwm = pwm_request_from_chip(chip, index, con_id ?: dev_id);
644
645 mutex_unlock(&pwm_lookup_lock);
646
647 return pwm;
648}
649EXPORT_SYMBOL_GPL(pwm_get);
650
651/**
652 * pwm_put() - release a PWM device
653 * @pwm: PWM device
654 */
655void pwm_put(struct pwm_device *pwm)
656{
657 if (!pwm)
658 return;
659
660 mutex_lock(&pwm_lock);
661
662 if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
Sachin Kamate50d3522012-08-10 16:41:13 +0530663 pr_warn("PWM device already freed\n");
Thierry Reding8138d2d2012-03-26 08:42:48 +0200664 goto out;
665 }
666
667 if (pwm->chip->ops->free)
668 pwm->chip->ops->free(pwm->chip, pwm);
669
670 pwm->label = NULL;
671
672 module_put(pwm->chip->ops->owner);
673out:
674 mutex_unlock(&pwm_lock);
675}
676EXPORT_SYMBOL_GPL(pwm_put);
677
Alexandre Courbot63543162012-08-01 19:20:58 +0900678static void devm_pwm_release(struct device *dev, void *res)
679{
680 pwm_put(*(struct pwm_device **)res);
681}
682
683/**
684 * devm_pwm_get() - resource managed pwm_get()
685 * @dev: device for PWM consumer
686 * @con_id: consumer name
687 *
688 * This function performs like pwm_get() but the acquired PWM device will
689 * automatically be released on driver detach.
690 */
691struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
692{
693 struct pwm_device **ptr, *pwm;
694
695 ptr = devres_alloc(devm_pwm_release, sizeof(**ptr), GFP_KERNEL);
696 if (!ptr)
697 return ERR_PTR(-ENOMEM);
698
699 pwm = pwm_get(dev, con_id);
700 if (!IS_ERR(pwm)) {
701 *ptr = pwm;
702 devres_add(dev, ptr);
703 } else {
704 devres_free(ptr);
705 }
706
707 return pwm;
708}
709EXPORT_SYMBOL_GPL(devm_pwm_get);
710
711static int devm_pwm_match(struct device *dev, void *res, void *data)
712{
713 struct pwm_device **p = res;
714
715 if (WARN_ON(!p || !*p))
716 return 0;
717
718 return *p == data;
719}
720
721/**
722 * devm_pwm_put() - resource managed pwm_put()
723 * @dev: device for PWM consumer
724 * @pwm: PWM device
725 *
726 * Release a PWM previously allocated using devm_pwm_get(). Calling this
727 * function is usually not needed because devm-allocated resources are
728 * automatically released on driver detach.
729 */
730void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
731{
732 WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm));
733}
734EXPORT_SYMBOL_GPL(devm_pwm_put);
735
Thierry Reding62099ab2012-03-26 09:31:48 +0200736#ifdef CONFIG_DEBUG_FS
737static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
738{
739 unsigned int i;
740
741 for (i = 0; i < chip->npwm; i++) {
742 struct pwm_device *pwm = &chip->pwms[i];
743
744 seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
745
746 if (test_bit(PWMF_REQUESTED, &pwm->flags))
747 seq_printf(s, " requested");
748
749 if (test_bit(PWMF_ENABLED, &pwm->flags))
750 seq_printf(s, " enabled");
751
752 seq_printf(s, "\n");
753 }
754}
755
756static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
757{
758 mutex_lock(&pwm_lock);
759 s->private = "";
760
761 return seq_list_start(&pwm_chips, *pos);
762}
763
764static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
765{
766 s->private = "\n";
767
768 return seq_list_next(v, &pwm_chips, pos);
769}
770
771static void pwm_seq_stop(struct seq_file *s, void *v)
772{
773 mutex_unlock(&pwm_lock);
774}
775
776static int pwm_seq_show(struct seq_file *s, void *v)
777{
778 struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
779
780 seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
781 chip->dev->bus ? chip->dev->bus->name : "no-bus",
782 dev_name(chip->dev), chip->npwm,
783 (chip->npwm != 1) ? "s" : "");
784
785 if (chip->ops->dbg_show)
786 chip->ops->dbg_show(chip, s);
787 else
788 pwm_dbg_show(chip, s);
789
790 return 0;
791}
792
793static const struct seq_operations pwm_seq_ops = {
794 .start = pwm_seq_start,
795 .next = pwm_seq_next,
796 .stop = pwm_seq_stop,
797 .show = pwm_seq_show,
798};
799
800static int pwm_seq_open(struct inode *inode, struct file *file)
801{
802 return seq_open(file, &pwm_seq_ops);
803}
804
805static const struct file_operations pwm_debugfs_ops = {
806 .owner = THIS_MODULE,
807 .open = pwm_seq_open,
808 .read = seq_read,
809 .llseek = seq_lseek,
810 .release = seq_release,
811};
812
813static int __init pwm_debugfs_init(void)
814{
815 debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
816 &pwm_debugfs_ops);
817
818 return 0;
819}
820
821subsys_initcall(pwm_debugfs_init);
822#endif /* CONFIG_DEBUG_FS */