Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Generic pwmlib implementation
4 : : *
5 : : * Copyright (C) 2011 Sascha Hauer <s.hauer@pengutronix.de>
6 : : * Copyright (C) 2011-2012 Avionic Design GmbH
7 : : */
8 : :
9 : : #include <linux/acpi.h>
10 : : #include <linux/module.h>
11 : : #include <linux/pwm.h>
12 : : #include <linux/radix-tree.h>
13 : : #include <linux/list.h>
14 : : #include <linux/mutex.h>
15 : : #include <linux/err.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/device.h>
18 : : #include <linux/debugfs.h>
19 : : #include <linux/seq_file.h>
20 : :
21 : : #include <dt-bindings/pwm/pwm.h>
22 : :
23 : : #define MAX_PWMS 1024
24 : :
25 : : static DEFINE_MUTEX(pwm_lookup_lock);
26 : : static LIST_HEAD(pwm_lookup_list);
27 : : static DEFINE_MUTEX(pwm_lock);
28 : : static LIST_HEAD(pwm_chips);
29 : : static DECLARE_BITMAP(allocated_pwms, MAX_PWMS);
30 : : static RADIX_TREE(pwm_tree, GFP_KERNEL);
31 : :
32 : : static struct pwm_device *pwm_to_device(unsigned int pwm)
33 : : {
34 : 0 : return radix_tree_lookup(&pwm_tree, pwm);
35 : : }
36 : :
37 : 0 : static int alloc_pwms(int pwm, unsigned int count)
38 : : {
39 : : unsigned int from = 0;
40 : : unsigned int start;
41 : :
42 [ # # ]: 0 : if (pwm >= MAX_PWMS)
43 : : return -EINVAL;
44 : :
45 [ # # ]: 0 : if (pwm >= 0)
46 : 0 : from = pwm;
47 : :
48 : : start = bitmap_find_next_zero_area(allocated_pwms, MAX_PWMS, from,
49 : : count, 0);
50 : :
51 [ # # ]: 0 : if (pwm >= 0 && start != pwm)
52 : : return -EEXIST;
53 : :
54 [ # # ]: 0 : if (start + count > MAX_PWMS)
55 : : return -ENOSPC;
56 : :
57 : 0 : return start;
58 : : }
59 : :
60 : 0 : static void free_pwms(struct pwm_chip *chip)
61 : : {
62 : : unsigned int i;
63 : :
64 [ # # ]: 0 : for (i = 0; i < chip->npwm; i++) {
65 : 0 : struct pwm_device *pwm = &chip->pwms[i];
66 : :
67 : 0 : radix_tree_delete(&pwm_tree, pwm->pwm);
68 : : }
69 : :
70 : 0 : bitmap_clear(allocated_pwms, chip->base, chip->npwm);
71 : :
72 : 0 : kfree(chip->pwms);
73 : 0 : chip->pwms = NULL;
74 : 0 : }
75 : :
76 : 0 : static struct pwm_chip *pwmchip_find_by_name(const char *name)
77 : : {
78 : : struct pwm_chip *chip;
79 : :
80 [ # # ]: 0 : if (!name)
81 : : return NULL;
82 : :
83 : 0 : mutex_lock(&pwm_lock);
84 : :
85 [ # # ]: 0 : list_for_each_entry(chip, &pwm_chips, list) {
86 : 0 : const char *chip_name = dev_name(chip->dev);
87 : :
88 [ # # # # ]: 0 : if (chip_name && strcmp(chip_name, name) == 0) {
89 : 0 : mutex_unlock(&pwm_lock);
90 : 0 : return chip;
91 : : }
92 : : }
93 : :
94 : 0 : mutex_unlock(&pwm_lock);
95 : :
96 : 0 : return NULL;
97 : : }
98 : :
99 : 0 : static int pwm_device_request(struct pwm_device *pwm, const char *label)
100 : : {
101 : : int err;
102 : :
103 [ # # ]: 0 : if (test_bit(PWMF_REQUESTED, &pwm->flags))
104 : : return -EBUSY;
105 : :
106 [ # # ]: 0 : if (!try_module_get(pwm->chip->ops->owner))
107 : : return -ENODEV;
108 : :
109 [ # # ]: 0 : if (pwm->chip->ops->request) {
110 : 0 : err = pwm->chip->ops->request(pwm->chip, pwm);
111 [ # # ]: 0 : if (err) {
112 : 0 : module_put(pwm->chip->ops->owner);
113 : 0 : return err;
114 : : }
115 : : }
116 : :
117 : 0 : set_bit(PWMF_REQUESTED, &pwm->flags);
118 : 0 : pwm->label = label;
119 : :
120 : 0 : return 0;
121 : : }
122 : :
123 : : struct pwm_device *
124 : 0 : of_pwm_xlate_with_flags(struct pwm_chip *pc, const struct of_phandle_args *args)
125 : : {
126 : : struct pwm_device *pwm;
127 : :
128 : : /* check, whether the driver supports a third cell for flags */
129 [ # # ]: 0 : if (pc->of_pwm_n_cells < 3)
130 : : return ERR_PTR(-EINVAL);
131 : :
132 : : /* flags in the third cell are optional */
133 [ # # ]: 0 : if (args->args_count < 2)
134 : : return ERR_PTR(-EINVAL);
135 : :
136 [ # # ]: 0 : if (args->args[0] >= pc->npwm)
137 : : return ERR_PTR(-EINVAL);
138 : :
139 : 0 : pwm = pwm_request_from_chip(pc, args->args[0], NULL);
140 [ # # ]: 0 : if (IS_ERR(pwm))
141 : : return pwm;
142 : :
143 : 0 : pwm->args.period = args->args[1];
144 : 0 : pwm->args.polarity = PWM_POLARITY_NORMAL;
145 : :
146 [ # # # # ]: 0 : if (args->args_count > 2 && args->args[2] & PWM_POLARITY_INVERTED)
147 : 0 : pwm->args.polarity = PWM_POLARITY_INVERSED;
148 : :
149 : 0 : return pwm;
150 : : }
151 : : EXPORT_SYMBOL_GPL(of_pwm_xlate_with_flags);
152 : :
153 : : static struct pwm_device *
154 : 0 : of_pwm_simple_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
155 : : {
156 : : struct pwm_device *pwm;
157 : :
158 : : /* sanity check driver support */
159 [ # # ]: 0 : if (pc->of_pwm_n_cells < 2)
160 : : return ERR_PTR(-EINVAL);
161 : :
162 : : /* all cells are required */
163 [ # # ]: 0 : if (args->args_count != pc->of_pwm_n_cells)
164 : : return ERR_PTR(-EINVAL);
165 : :
166 [ # # ]: 0 : if (args->args[0] >= pc->npwm)
167 : : return ERR_PTR(-EINVAL);
168 : :
169 : 0 : pwm = pwm_request_from_chip(pc, args->args[0], NULL);
170 [ # # ]: 0 : if (IS_ERR(pwm))
171 : : return pwm;
172 : :
173 : 0 : pwm->args.period = args->args[1];
174 : :
175 : 0 : return pwm;
176 : : }
177 : :
178 : 0 : static void of_pwmchip_add(struct pwm_chip *chip)
179 : : {
180 [ # # # # ]: 0 : if (!chip->dev || !chip->dev->of_node)
181 : 0 : return;
182 : :
183 [ # # ]: 0 : if (!chip->of_xlate) {
184 : 0 : chip->of_xlate = of_pwm_simple_xlate;
185 : 0 : chip->of_pwm_n_cells = 2;
186 : : }
187 : :
188 : 0 : of_node_get(chip->dev->of_node);
189 : : }
190 : :
191 : : static void of_pwmchip_remove(struct pwm_chip *chip)
192 : : {
193 [ # # ]: 0 : if (chip->dev)
194 : 0 : of_node_put(chip->dev->of_node);
195 : : }
196 : :
197 : : /**
198 : : * pwm_set_chip_data() - set private chip data for a PWM
199 : : * @pwm: PWM device
200 : : * @data: pointer to chip-specific data
201 : : *
202 : : * Returns: 0 on success or a negative error code on failure.
203 : : */
204 : 0 : int pwm_set_chip_data(struct pwm_device *pwm, void *data)
205 : : {
206 [ # # # # ]: 0 : if (!pwm)
207 : : return -EINVAL;
208 : :
209 : 0 : pwm->chip_data = data;
210 : :
211 : 0 : return 0;
212 : : }
213 : : EXPORT_SYMBOL_GPL(pwm_set_chip_data);
214 : :
215 : : /**
216 : : * pwm_get_chip_data() - get private chip data for a PWM
217 : : * @pwm: PWM device
218 : : *
219 : : * Returns: A pointer to the chip-private data for the PWM device.
220 : : */
221 : 0 : void *pwm_get_chip_data(struct pwm_device *pwm)
222 : : {
223 [ # # ]: 0 : return pwm ? pwm->chip_data : NULL;
224 : : }
225 : : EXPORT_SYMBOL_GPL(pwm_get_chip_data);
226 : :
227 : : static bool pwm_ops_check(const struct pwm_ops *ops)
228 : : {
229 : : /* driver supports legacy, non-atomic operation */
230 [ # # # # : 0 : if (ops->config && ops->enable && ops->disable)
# # ]
231 : : return true;
232 : :
233 : : /* driver supports atomic operation */
234 [ # # ]: 0 : if (ops->apply)
235 : : return true;
236 : :
237 : : return false;
238 : : }
239 : :
240 : : /**
241 : : * pwmchip_add_with_polarity() - register a new PWM chip
242 : : * @chip: the PWM chip to add
243 : : * @polarity: initial polarity of PWM channels
244 : : *
245 : : * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
246 : : * will be used. The initial polarity for all channels is specified by the
247 : : * @polarity parameter.
248 : : *
249 : : * Returns: 0 on success or a negative error code on failure.
250 : : */
251 : 0 : int pwmchip_add_with_polarity(struct pwm_chip *chip,
252 : : enum pwm_polarity polarity)
253 : : {
254 : : struct pwm_device *pwm;
255 : : unsigned int i;
256 : : int ret;
257 : :
258 [ # # # # : 0 : if (!chip || !chip->dev || !chip->ops || !chip->npwm)
# # # # ]
259 : : return -EINVAL;
260 : :
261 [ # # ]: 0 : if (!pwm_ops_check(chip->ops))
262 : : return -EINVAL;
263 : :
264 : 0 : mutex_lock(&pwm_lock);
265 : :
266 : 0 : ret = alloc_pwms(chip->base, chip->npwm);
267 [ # # ]: 0 : if (ret < 0)
268 : : goto out;
269 : :
270 : 0 : chip->pwms = kcalloc(chip->npwm, sizeof(*pwm), GFP_KERNEL);
271 [ # # ]: 0 : if (!chip->pwms) {
272 : : ret = -ENOMEM;
273 : : goto out;
274 : : }
275 : :
276 : 0 : chip->base = ret;
277 : :
278 [ # # ]: 0 : for (i = 0; i < chip->npwm; i++) {
279 : 0 : pwm = &chip->pwms[i];
280 : :
281 : 0 : pwm->chip = chip;
282 : 0 : pwm->pwm = chip->base + i;
283 : 0 : pwm->hwpwm = i;
284 : 0 : pwm->state.polarity = polarity;
285 : :
286 [ # # ]: 0 : if (chip->ops->get_state)
287 : 0 : chip->ops->get_state(chip, pwm, &pwm->state);
288 : :
289 : 0 : radix_tree_insert(&pwm_tree, pwm->pwm, pwm);
290 : : }
291 : :
292 : 0 : bitmap_set(allocated_pwms, chip->base, chip->npwm);
293 : :
294 : 0 : INIT_LIST_HEAD(&chip->list);
295 : : list_add(&chip->list, &pwm_chips);
296 : :
297 : : ret = 0;
298 : :
299 : : if (IS_ENABLED(CONFIG_OF))
300 : 0 : of_pwmchip_add(chip);
301 : :
302 : : out:
303 : 0 : mutex_unlock(&pwm_lock);
304 : :
305 [ # # ]: 0 : if (!ret)
306 : 0 : pwmchip_sysfs_export(chip);
307 : :
308 : 0 : return ret;
309 : : }
310 : : EXPORT_SYMBOL_GPL(pwmchip_add_with_polarity);
311 : :
312 : : /**
313 : : * pwmchip_add() - register a new PWM chip
314 : : * @chip: the PWM chip to add
315 : : *
316 : : * Register a new PWM chip. If chip->base < 0 then a dynamically assigned base
317 : : * will be used. The initial polarity for all channels is normal.
318 : : *
319 : : * Returns: 0 on success or a negative error code on failure.
320 : : */
321 : 0 : int pwmchip_add(struct pwm_chip *chip)
322 : : {
323 : 0 : return pwmchip_add_with_polarity(chip, PWM_POLARITY_NORMAL);
324 : : }
325 : : EXPORT_SYMBOL_GPL(pwmchip_add);
326 : :
327 : : /**
328 : : * pwmchip_remove() - remove a PWM chip
329 : : * @chip: the PWM chip to remove
330 : : *
331 : : * Removes a PWM chip. This function may return busy if the PWM chip provides
332 : : * a PWM device that is still requested.
333 : : *
334 : : * Returns: 0 on success or a negative error code on failure.
335 : : */
336 : 0 : int pwmchip_remove(struct pwm_chip *chip)
337 : : {
338 : : unsigned int i;
339 : : int ret = 0;
340 : :
341 : 0 : pwmchip_sysfs_unexport(chip);
342 : :
343 : 0 : mutex_lock(&pwm_lock);
344 : :
345 [ # # ]: 0 : for (i = 0; i < chip->npwm; i++) {
346 : 0 : struct pwm_device *pwm = &chip->pwms[i];
347 : :
348 [ # # ]: 0 : if (test_bit(PWMF_REQUESTED, &pwm->flags)) {
349 : : ret = -EBUSY;
350 : : goto out;
351 : : }
352 : : }
353 : :
354 : 0 : list_del_init(&chip->list);
355 : :
356 : : if (IS_ENABLED(CONFIG_OF))
357 : : of_pwmchip_remove(chip);
358 : :
359 : 0 : free_pwms(chip);
360 : :
361 : : out:
362 : 0 : mutex_unlock(&pwm_lock);
363 : 0 : return ret;
364 : : }
365 : : EXPORT_SYMBOL_GPL(pwmchip_remove);
366 : :
367 : : /**
368 : : * pwm_request() - request a PWM device
369 : : * @pwm: global PWM device index
370 : : * @label: PWM device label
371 : : *
372 : : * This function is deprecated, use pwm_get() instead.
373 : : *
374 : : * Returns: A pointer to a PWM device or an ERR_PTR()-encoded error code on
375 : : * failure.
376 : : */
377 : 0 : struct pwm_device *pwm_request(int pwm, const char *label)
378 : : {
379 : : struct pwm_device *dev;
380 : : int err;
381 : :
382 [ # # ]: 0 : if (pwm < 0 || pwm >= MAX_PWMS)
383 : : return ERR_PTR(-EINVAL);
384 : :
385 : 0 : mutex_lock(&pwm_lock);
386 : :
387 : : dev = pwm_to_device(pwm);
388 [ # # ]: 0 : if (!dev) {
389 : : dev = ERR_PTR(-EPROBE_DEFER);
390 : : goto out;
391 : : }
392 : :
393 : 0 : err = pwm_device_request(dev, label);
394 [ # # ]: 0 : if (err < 0)
395 : : dev = ERR_PTR(err);
396 : :
397 : : out:
398 : 0 : mutex_unlock(&pwm_lock);
399 : :
400 : 0 : return dev;
401 : : }
402 : : EXPORT_SYMBOL_GPL(pwm_request);
403 : :
404 : : /**
405 : : * pwm_request_from_chip() - request a PWM device relative to a PWM chip
406 : : * @chip: PWM chip
407 : : * @index: per-chip index of the PWM to request
408 : : * @label: a literal description string of this PWM
409 : : *
410 : : * Returns: A pointer to the PWM device at the given index of the given PWM
411 : : * chip. A negative error code is returned if the index is not valid for the
412 : : * specified PWM chip or if the PWM device cannot be requested.
413 : : */
414 : 0 : struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
415 : : unsigned int index,
416 : : const char *label)
417 : : {
418 : : struct pwm_device *pwm;
419 : : int err;
420 : :
421 [ # # # # ]: 0 : if (!chip || index >= chip->npwm)
422 : : return ERR_PTR(-EINVAL);
423 : :
424 : 0 : mutex_lock(&pwm_lock);
425 : 0 : pwm = &chip->pwms[index];
426 : :
427 : 0 : err = pwm_device_request(pwm, label);
428 [ # # ]: 0 : if (err < 0)
429 : : pwm = ERR_PTR(err);
430 : :
431 : 0 : mutex_unlock(&pwm_lock);
432 : 0 : return pwm;
433 : : }
434 : : EXPORT_SYMBOL_GPL(pwm_request_from_chip);
435 : :
436 : : /**
437 : : * pwm_free() - free a PWM device
438 : : * @pwm: PWM device
439 : : *
440 : : * This function is deprecated, use pwm_put() instead.
441 : : */
442 : 0 : void pwm_free(struct pwm_device *pwm)
443 : : {
444 : 0 : pwm_put(pwm);
445 : 0 : }
446 : : EXPORT_SYMBOL_GPL(pwm_free);
447 : :
448 : : /**
449 : : * pwm_apply_state() - atomically apply a new state to a PWM device
450 : : * @pwm: PWM device
451 : : * @state: new state to apply
452 : : */
453 : 0 : int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
454 : : {
455 : : struct pwm_chip *chip;
456 : : int err;
457 : :
458 [ # # # # : 0 : if (!pwm || !state || !state->period ||
# # ]
459 : 0 : state->duty_cycle > state->period)
460 : : return -EINVAL;
461 : :
462 : 0 : chip = pwm->chip;
463 : :
464 [ # # # # ]: 0 : if (state->period == pwm->state.period &&
465 [ # # ]: 0 : state->duty_cycle == pwm->state.duty_cycle &&
466 [ # # ]: 0 : state->polarity == pwm->state.polarity &&
467 : 0 : state->enabled == pwm->state.enabled)
468 : : return 0;
469 : :
470 [ # # ]: 0 : if (chip->ops->apply) {
471 : 0 : err = chip->ops->apply(chip, pwm, state);
472 [ # # ]: 0 : if (err)
473 : : return err;
474 : :
475 : 0 : pwm->state = *state;
476 : : } else {
477 : : /*
478 : : * FIXME: restore the initial state in case of error.
479 : : */
480 [ # # ]: 0 : if (state->polarity != pwm->state.polarity) {
481 [ # # ]: 0 : if (!chip->ops->set_polarity)
482 : : return -ENOTSUPP;
483 : :
484 : : /*
485 : : * Changing the polarity of a running PWM is
486 : : * only allowed when the PWM driver implements
487 : : * ->apply().
488 : : */
489 [ # # ]: 0 : if (pwm->state.enabled) {
490 : 0 : chip->ops->disable(chip, pwm);
491 : 0 : pwm->state.enabled = false;
492 : : }
493 : :
494 : 0 : err = chip->ops->set_polarity(chip, pwm,
495 : : state->polarity);
496 [ # # ]: 0 : if (err)
497 : : return err;
498 : :
499 : 0 : pwm->state.polarity = state->polarity;
500 : : }
501 : :
502 [ # # # # ]: 0 : if (state->period != pwm->state.period ||
503 : 0 : state->duty_cycle != pwm->state.duty_cycle) {
504 : 0 : err = chip->ops->config(pwm->chip, pwm,
505 : 0 : state->duty_cycle,
506 : : state->period);
507 [ # # ]: 0 : if (err)
508 : : return err;
509 : :
510 : 0 : pwm->state.duty_cycle = state->duty_cycle;
511 : 0 : pwm->state.period = state->period;
512 : : }
513 : :
514 [ # # ]: 0 : if (state->enabled != pwm->state.enabled) {
515 [ # # ]: 0 : if (state->enabled) {
516 : 0 : err = chip->ops->enable(chip, pwm);
517 [ # # ]: 0 : if (err)
518 : : return err;
519 : : } else {
520 : 0 : chip->ops->disable(chip, pwm);
521 : : }
522 : :
523 : 0 : pwm->state.enabled = state->enabled;
524 : : }
525 : : }
526 : :
527 : : return 0;
528 : : }
529 : : EXPORT_SYMBOL_GPL(pwm_apply_state);
530 : :
531 : : /**
532 : : * pwm_capture() - capture and report a PWM signal
533 : : * @pwm: PWM device
534 : : * @result: structure to fill with capture result
535 : : * @timeout: time to wait, in milliseconds, before giving up on capture
536 : : *
537 : : * Returns: 0 on success or a negative error code on failure.
538 : : */
539 : 0 : int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
540 : : unsigned long timeout)
541 : : {
542 : : int err;
543 : :
544 [ # # # # ]: 0 : if (!pwm || !pwm->chip->ops)
545 : : return -EINVAL;
546 : :
547 [ # # ]: 0 : if (!pwm->chip->ops->capture)
548 : : return -ENOSYS;
549 : :
550 : 0 : mutex_lock(&pwm_lock);
551 : 0 : err = pwm->chip->ops->capture(pwm->chip, pwm, result, timeout);
552 : 0 : mutex_unlock(&pwm_lock);
553 : :
554 : 0 : return err;
555 : : }
556 : : EXPORT_SYMBOL_GPL(pwm_capture);
557 : :
558 : : /**
559 : : * pwm_adjust_config() - adjust the current PWM config to the PWM arguments
560 : : * @pwm: PWM device
561 : : *
562 : : * This function will adjust the PWM config to the PWM arguments provided
563 : : * by the DT or PWM lookup table. This is particularly useful to adapt
564 : : * the bootloader config to the Linux one.
565 : : */
566 : 0 : int pwm_adjust_config(struct pwm_device *pwm)
567 : : {
568 : : struct pwm_state state;
569 : : struct pwm_args pargs;
570 : :
571 : : pwm_get_args(pwm, &pargs);
572 : : pwm_get_state(pwm, &state);
573 : :
574 : : /*
575 : : * If the current period is zero it means that either the PWM driver
576 : : * does not support initial state retrieval or the PWM has not yet
577 : : * been configured.
578 : : *
579 : : * In either case, we setup the new period and polarity, and assign a
580 : : * duty cycle of 0.
581 : : */
582 [ # # ]: 0 : if (!state.period) {
583 : 0 : state.duty_cycle = 0;
584 : 0 : state.period = pargs.period;
585 : 0 : state.polarity = pargs.polarity;
586 : :
587 : 0 : return pwm_apply_state(pwm, &state);
588 : : }
589 : :
590 : : /*
591 : : * Adjust the PWM duty cycle/period based on the period value provided
592 : : * in PWM args.
593 : : */
594 [ # # ]: 0 : if (pargs.period != state.period) {
595 : 0 : u64 dutycycle = (u64)state.duty_cycle * pargs.period;
596 : :
597 [ # # # # : 0 : do_div(dutycycle, state.period);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
598 : 0 : state.duty_cycle = dutycycle;
599 : 0 : state.period = pargs.period;
600 : : }
601 : :
602 : : /*
603 : : * If the polarity changed, we should also change the duty cycle.
604 : : */
605 [ # # ]: 0 : if (pargs.polarity != state.polarity) {
606 : 0 : state.polarity = pargs.polarity;
607 : 0 : state.duty_cycle = state.period - state.duty_cycle;
608 : : }
609 : :
610 : 0 : return pwm_apply_state(pwm, &state);
611 : : }
612 : : EXPORT_SYMBOL_GPL(pwm_adjust_config);
613 : :
614 : 0 : static struct pwm_chip *of_node_to_pwmchip(struct device_node *np)
615 : : {
616 : : struct pwm_chip *chip;
617 : :
618 : 0 : mutex_lock(&pwm_lock);
619 : :
620 [ # # ]: 0 : list_for_each_entry(chip, &pwm_chips, list)
621 [ # # # # ]: 0 : if (chip->dev && chip->dev->of_node == np) {
622 : 0 : mutex_unlock(&pwm_lock);
623 : 0 : return chip;
624 : : }
625 : :
626 : 0 : mutex_unlock(&pwm_lock);
627 : :
628 : 0 : return ERR_PTR(-EPROBE_DEFER);
629 : : }
630 : :
631 : 0 : static struct device_link *pwm_device_link_add(struct device *dev,
632 : : struct pwm_device *pwm)
633 : : {
634 : : struct device_link *dl;
635 : :
636 [ # # ]: 0 : if (!dev) {
637 : : /*
638 : : * No device for the PWM consumer has been provided. It may
639 : : * impact the PM sequence ordering: the PWM supplier may get
640 : : * suspended before the consumer.
641 : : */
642 : 0 : dev_warn(pwm->chip->dev,
643 : : "No consumer device specified to create a link to\n");
644 : 0 : return NULL;
645 : : }
646 : :
647 : 0 : dl = device_link_add(dev, pwm->chip->dev, DL_FLAG_AUTOREMOVE_CONSUMER);
648 [ # # ]: 0 : if (!dl) {
649 : 0 : dev_err(dev, "failed to create device link to %s\n",
650 : : dev_name(pwm->chip->dev));
651 : 0 : return ERR_PTR(-EINVAL);
652 : : }
653 : :
654 : : return dl;
655 : : }
656 : :
657 : : /**
658 : : * of_pwm_get() - request a PWM via the PWM framework
659 : : * @dev: device for PWM consumer
660 : : * @np: device node to get the PWM from
661 : : * @con_id: consumer name
662 : : *
663 : : * Returns the PWM device parsed from the phandle and index specified in the
664 : : * "pwms" property of a device tree node or a negative error-code on failure.
665 : : * Values parsed from the device tree are stored in the returned PWM device
666 : : * object.
667 : : *
668 : : * If con_id is NULL, the first PWM device listed in the "pwms" property will
669 : : * be requested. Otherwise the "pwm-names" property is used to do a reverse
670 : : * lookup of the PWM index. This also means that the "pwm-names" property
671 : : * becomes mandatory for devices that look up the PWM device via the con_id
672 : : * parameter.
673 : : *
674 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
675 : : * error code on failure.
676 : : */
677 : 0 : struct pwm_device *of_pwm_get(struct device *dev, struct device_node *np,
678 : : const char *con_id)
679 : : {
680 : : struct pwm_device *pwm = NULL;
681 : : struct of_phandle_args args;
682 : : struct device_link *dl;
683 : : struct pwm_chip *pc;
684 : : int index = 0;
685 : : int err;
686 : :
687 [ # # ]: 0 : if (con_id) {
688 : 0 : index = of_property_match_string(np, "pwm-names", con_id);
689 [ # # ]: 0 : if (index < 0)
690 : 0 : return ERR_PTR(index);
691 : : }
692 : :
693 : 0 : err = of_parse_phandle_with_args(np, "pwms", "#pwm-cells", index,
694 : : &args);
695 [ # # ]: 0 : if (err) {
696 : 0 : pr_err("%s(): can't parse \"pwms\" property\n", __func__);
697 : 0 : return ERR_PTR(err);
698 : : }
699 : :
700 : 0 : pc = of_node_to_pwmchip(args.np);
701 [ # # ]: 0 : if (IS_ERR(pc)) {
702 [ # # ]: 0 : if (PTR_ERR(pc) != -EPROBE_DEFER)
703 : 0 : pr_err("%s(): PWM chip not found\n", __func__);
704 : :
705 : : pwm = ERR_CAST(pc);
706 : 0 : goto put;
707 : : }
708 : :
709 : 0 : pwm = pc->of_xlate(pc, &args);
710 [ # # ]: 0 : if (IS_ERR(pwm))
711 : : goto put;
712 : :
713 : 0 : dl = pwm_device_link_add(dev, pwm);
714 [ # # ]: 0 : if (IS_ERR(dl)) {
715 : : /* of_xlate ended up calling pwm_request_from_chip() */
716 : : pwm_free(pwm);
717 : : pwm = ERR_CAST(dl);
718 : 0 : goto put;
719 : : }
720 : :
721 : : /*
722 : : * If a consumer name was not given, try to look it up from the
723 : : * "pwm-names" property if it exists. Otherwise use the name of
724 : : * the user device node.
725 : : */
726 [ # # ]: 0 : if (!con_id) {
727 : : err = of_property_read_string_index(np, "pwm-names", index,
728 : : &con_id);
729 [ # # ]: 0 : if (err < 0)
730 : 0 : con_id = np->name;
731 : : }
732 : :
733 : 0 : pwm->label = con_id;
734 : :
735 : : put:
736 : 0 : of_node_put(args.np);
737 : :
738 : 0 : return pwm;
739 : : }
740 : : EXPORT_SYMBOL_GPL(of_pwm_get);
741 : :
742 : : #if IS_ENABLED(CONFIG_ACPI)
743 : : static struct pwm_chip *device_to_pwmchip(struct device *dev)
744 : : {
745 : : struct pwm_chip *chip;
746 : :
747 : : mutex_lock(&pwm_lock);
748 : :
749 : : list_for_each_entry(chip, &pwm_chips, list) {
750 : : struct acpi_device *adev = ACPI_COMPANION(chip->dev);
751 : :
752 : : if ((chip->dev == dev) || (adev && &adev->dev == dev)) {
753 : : mutex_unlock(&pwm_lock);
754 : : return chip;
755 : : }
756 : : }
757 : :
758 : : mutex_unlock(&pwm_lock);
759 : :
760 : : return ERR_PTR(-EPROBE_DEFER);
761 : : }
762 : : #endif
763 : :
764 : : /**
765 : : * acpi_pwm_get() - request a PWM via parsing "pwms" property in ACPI
766 : : * @fwnode: firmware node to get the "pwm" property from
767 : : *
768 : : * Returns the PWM device parsed from the fwnode and index specified in the
769 : : * "pwms" property or a negative error-code on failure.
770 : : * Values parsed from the device tree are stored in the returned PWM device
771 : : * object.
772 : : *
773 : : * This is analogous to of_pwm_get() except con_id is not yet supported.
774 : : * ACPI entries must look like
775 : : * Package () {"pwms", Package ()
776 : : * { <PWM device reference>, <PWM index>, <PWM period> [, <PWM flags>]}}
777 : : *
778 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
779 : : * error code on failure.
780 : : */
781 : : static struct pwm_device *acpi_pwm_get(struct fwnode_handle *fwnode)
782 : : {
783 : : struct pwm_device *pwm = ERR_PTR(-ENODEV);
784 : : #if IS_ENABLED(CONFIG_ACPI)
785 : : struct fwnode_reference_args args;
786 : : struct acpi_device *acpi;
787 : : struct pwm_chip *chip;
788 : : int ret;
789 : :
790 : : memset(&args, 0, sizeof(args));
791 : :
792 : : ret = __acpi_node_get_property_reference(fwnode, "pwms", 0, 3, &args);
793 : : if (ret < 0)
794 : : return ERR_PTR(ret);
795 : :
796 : : acpi = to_acpi_device_node(args.fwnode);
797 : : if (!acpi)
798 : : return ERR_PTR(-EINVAL);
799 : :
800 : : if (args.nargs < 2)
801 : : return ERR_PTR(-EPROTO);
802 : :
803 : : chip = device_to_pwmchip(&acpi->dev);
804 : : if (IS_ERR(chip))
805 : : return ERR_CAST(chip);
806 : :
807 : : pwm = pwm_request_from_chip(chip, args.args[0], NULL);
808 : : if (IS_ERR(pwm))
809 : : return pwm;
810 : :
811 : : pwm->args.period = args.args[1];
812 : : pwm->args.polarity = PWM_POLARITY_NORMAL;
813 : :
814 : : if (args.nargs > 2 && args.args[2] & PWM_POLARITY_INVERTED)
815 : : pwm->args.polarity = PWM_POLARITY_INVERSED;
816 : : #endif
817 : :
818 : : return pwm;
819 : : }
820 : :
821 : : /**
822 : : * pwm_add_table() - register PWM device consumers
823 : : * @table: array of consumers to register
824 : : * @num: number of consumers in table
825 : : */
826 : 0 : void pwm_add_table(struct pwm_lookup *table, size_t num)
827 : : {
828 : 0 : mutex_lock(&pwm_lookup_lock);
829 : :
830 [ # # ]: 0 : while (num--) {
831 : 0 : list_add_tail(&table->list, &pwm_lookup_list);
832 : 0 : table++;
833 : : }
834 : :
835 : 0 : mutex_unlock(&pwm_lookup_lock);
836 : 0 : }
837 : :
838 : : /**
839 : : * pwm_remove_table() - unregister PWM device consumers
840 : : * @table: array of consumers to unregister
841 : : * @num: number of consumers in table
842 : : */
843 : 0 : void pwm_remove_table(struct pwm_lookup *table, size_t num)
844 : : {
845 : 0 : mutex_lock(&pwm_lookup_lock);
846 : :
847 [ # # ]: 0 : while (num--) {
848 : : list_del(&table->list);
849 : 0 : table++;
850 : : }
851 : :
852 : 0 : mutex_unlock(&pwm_lookup_lock);
853 : 0 : }
854 : :
855 : : /**
856 : : * pwm_get() - look up and request a PWM device
857 : : * @dev: device for PWM consumer
858 : : * @con_id: consumer name
859 : : *
860 : : * Lookup is first attempted using DT. If the device was not instantiated from
861 : : * a device tree, a PWM chip and a relative index is looked up via a table
862 : : * supplied by board setup code (see pwm_add_table()).
863 : : *
864 : : * Once a PWM chip has been found the specified PWM device will be requested
865 : : * and is ready to be used.
866 : : *
867 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
868 : : * error code on failure.
869 : : */
870 : 0 : struct pwm_device *pwm_get(struct device *dev, const char *con_id)
871 : : {
872 [ # # ]: 0 : const char *dev_id = dev ? dev_name(dev) : NULL;
873 : : struct pwm_device *pwm;
874 : : struct pwm_chip *chip;
875 : : struct device_link *dl;
876 : : unsigned int best = 0;
877 : : struct pwm_lookup *p, *chosen = NULL;
878 : : unsigned int match;
879 : : int err;
880 : :
881 : : /* look up via DT first */
882 [ # # # # ]: 0 : if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
883 : 0 : return of_pwm_get(dev, dev->of_node, con_id);
884 : :
885 : : /* then lookup via ACPI */
886 : : if (dev && is_acpi_node(dev->fwnode)) {
887 : : pwm = acpi_pwm_get(dev->fwnode);
888 : : if (!IS_ERR(pwm) || PTR_ERR(pwm) != -ENOENT)
889 : : return pwm;
890 : : }
891 : :
892 : : /*
893 : : * We look up the provider in the static table typically provided by
894 : : * board setup code. We first try to lookup the consumer device by
895 : : * name. If the consumer device was passed in as NULL or if no match
896 : : * was found, we try to find the consumer by directly looking it up
897 : : * by name.
898 : : *
899 : : * If a match is found, the provider PWM chip is looked up by name
900 : : * and a PWM device is requested using the PWM device per-chip index.
901 : : *
902 : : * The lookup algorithm was shamelessly taken from the clock
903 : : * framework:
904 : : *
905 : : * We do slightly fuzzy matching here:
906 : : * An entry with a NULL ID is assumed to be a wildcard.
907 : : * If an entry has a device ID, it must match
908 : : * If an entry has a connection ID, it must match
909 : : * Then we take the most specific entry - with the following order
910 : : * of precedence: dev+con > dev only > con only.
911 : : */
912 : 0 : mutex_lock(&pwm_lookup_lock);
913 : :
914 [ # # ]: 0 : list_for_each_entry(p, &pwm_lookup_list, list) {
915 : : match = 0;
916 : :
917 [ # # ]: 0 : if (p->dev_id) {
918 [ # # # # ]: 0 : if (!dev_id || strcmp(p->dev_id, dev_id))
919 : 0 : continue;
920 : :
921 : : match += 2;
922 : : }
923 : :
924 [ # # ]: 0 : if (p->con_id) {
925 [ # # # # ]: 0 : if (!con_id || strcmp(p->con_id, con_id))
926 : 0 : continue;
927 : :
928 : 0 : match += 1;
929 : : }
930 : :
931 [ # # ]: 0 : if (match > best) {
932 : : chosen = p;
933 : :
934 [ # # ]: 0 : if (match != 3)
935 : : best = match;
936 : : else
937 : : break;
938 : : }
939 : : }
940 : :
941 : 0 : mutex_unlock(&pwm_lookup_lock);
942 : :
943 [ # # ]: 0 : if (!chosen)
944 : : return ERR_PTR(-ENODEV);
945 : :
946 : 0 : chip = pwmchip_find_by_name(chosen->provider);
947 : :
948 : : /*
949 : : * If the lookup entry specifies a module, load the module and retry
950 : : * the PWM chip lookup. This can be used to work around driver load
951 : : * ordering issues if driver's can't be made to properly support the
952 : : * deferred probe mechanism.
953 : : */
954 [ # # # # ]: 0 : if (!chip && chosen->module) {
955 : 0 : err = request_module(chosen->module);
956 [ # # ]: 0 : if (err == 0)
957 : 0 : chip = pwmchip_find_by_name(chosen->provider);
958 : : }
959 : :
960 [ # # ]: 0 : if (!chip)
961 : : return ERR_PTR(-EPROBE_DEFER);
962 : :
963 [ # # ]: 0 : pwm = pwm_request_from_chip(chip, chosen->index, con_id ?: dev_id);
964 [ # # ]: 0 : if (IS_ERR(pwm))
965 : : return pwm;
966 : :
967 : 0 : dl = pwm_device_link_add(dev, pwm);
968 [ # # ]: 0 : if (IS_ERR(dl)) {
969 : : pwm_free(pwm);
970 : 0 : return ERR_CAST(dl);
971 : : }
972 : :
973 : 0 : pwm->args.period = chosen->period;
974 : 0 : pwm->args.polarity = chosen->polarity;
975 : :
976 : 0 : return pwm;
977 : : }
978 : : EXPORT_SYMBOL_GPL(pwm_get);
979 : :
980 : : /**
981 : : * pwm_put() - release a PWM device
982 : : * @pwm: PWM device
983 : : */
984 : 0 : void pwm_put(struct pwm_device *pwm)
985 : : {
986 [ # # ]: 0 : if (!pwm)
987 : 0 : return;
988 : :
989 : 0 : mutex_lock(&pwm_lock);
990 : :
991 [ # # ]: 0 : if (!test_and_clear_bit(PWMF_REQUESTED, &pwm->flags)) {
992 : 0 : pr_warn("PWM device already freed\n");
993 : 0 : goto out;
994 : : }
995 : :
996 [ # # ]: 0 : if (pwm->chip->ops->free)
997 : 0 : pwm->chip->ops->free(pwm->chip, pwm);
998 : :
999 : : pwm_set_chip_data(pwm, NULL);
1000 : 0 : pwm->label = NULL;
1001 : :
1002 : 0 : module_put(pwm->chip->ops->owner);
1003 : : out:
1004 : 0 : mutex_unlock(&pwm_lock);
1005 : : }
1006 : : EXPORT_SYMBOL_GPL(pwm_put);
1007 : :
1008 : 0 : static void devm_pwm_release(struct device *dev, void *res)
1009 : : {
1010 : 0 : pwm_put(*(struct pwm_device **)res);
1011 : 0 : }
1012 : :
1013 : : /**
1014 : : * devm_pwm_get() - resource managed pwm_get()
1015 : : * @dev: device for PWM consumer
1016 : : * @con_id: consumer name
1017 : : *
1018 : : * This function performs like pwm_get() but the acquired PWM device will
1019 : : * automatically be released on driver detach.
1020 : : *
1021 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
1022 : : * error code on failure.
1023 : : */
1024 : 0 : struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id)
1025 : : {
1026 : : struct pwm_device **ptr, *pwm;
1027 : :
1028 : : ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
1029 [ # # ]: 0 : if (!ptr)
1030 : : return ERR_PTR(-ENOMEM);
1031 : :
1032 : 0 : pwm = pwm_get(dev, con_id);
1033 [ # # ]: 0 : if (!IS_ERR(pwm)) {
1034 : 0 : *ptr = pwm;
1035 : 0 : devres_add(dev, ptr);
1036 : : } else {
1037 : 0 : devres_free(ptr);
1038 : : }
1039 : :
1040 : 0 : return pwm;
1041 : : }
1042 : : EXPORT_SYMBOL_GPL(devm_pwm_get);
1043 : :
1044 : : /**
1045 : : * devm_of_pwm_get() - resource managed of_pwm_get()
1046 : : * @dev: device for PWM consumer
1047 : : * @np: device node to get the PWM from
1048 : : * @con_id: consumer name
1049 : : *
1050 : : * This function performs like of_pwm_get() but the acquired PWM device will
1051 : : * automatically be released on driver detach.
1052 : : *
1053 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
1054 : : * error code on failure.
1055 : : */
1056 : 0 : struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
1057 : : const char *con_id)
1058 : : {
1059 : : struct pwm_device **ptr, *pwm;
1060 : :
1061 : : ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
1062 [ # # ]: 0 : if (!ptr)
1063 : : return ERR_PTR(-ENOMEM);
1064 : :
1065 : 0 : pwm = of_pwm_get(dev, np, con_id);
1066 [ # # ]: 0 : if (!IS_ERR(pwm)) {
1067 : 0 : *ptr = pwm;
1068 : 0 : devres_add(dev, ptr);
1069 : : } else {
1070 : 0 : devres_free(ptr);
1071 : : }
1072 : :
1073 : 0 : return pwm;
1074 : : }
1075 : : EXPORT_SYMBOL_GPL(devm_of_pwm_get);
1076 : :
1077 : : /**
1078 : : * devm_fwnode_pwm_get() - request a resource managed PWM from firmware node
1079 : : * @dev: device for PWM consumer
1080 : : * @fwnode: firmware node to get the PWM from
1081 : : * @con_id: consumer name
1082 : : *
1083 : : * Returns the PWM device parsed from the firmware node. See of_pwm_get() and
1084 : : * acpi_pwm_get() for a detailed description.
1085 : : *
1086 : : * Returns: A pointer to the requested PWM device or an ERR_PTR()-encoded
1087 : : * error code on failure.
1088 : : */
1089 : 0 : struct pwm_device *devm_fwnode_pwm_get(struct device *dev,
1090 : : struct fwnode_handle *fwnode,
1091 : : const char *con_id)
1092 : : {
1093 : : struct pwm_device **ptr, *pwm = ERR_PTR(-ENODEV);
1094 : :
1095 : : ptr = devres_alloc(devm_pwm_release, sizeof(*ptr), GFP_KERNEL);
1096 [ # # ]: 0 : if (!ptr)
1097 : : return ERR_PTR(-ENOMEM);
1098 : :
1099 [ # # ]: 0 : if (is_of_node(fwnode))
1100 [ # # ]: 0 : pwm = of_pwm_get(dev, to_of_node(fwnode), con_id);
1101 : : else if (is_acpi_node(fwnode))
1102 : : pwm = acpi_pwm_get(fwnode);
1103 : :
1104 [ # # ]: 0 : if (!IS_ERR(pwm)) {
1105 : 0 : *ptr = pwm;
1106 : 0 : devres_add(dev, ptr);
1107 : : } else {
1108 : 0 : devres_free(ptr);
1109 : : }
1110 : :
1111 : 0 : return pwm;
1112 : : }
1113 : : EXPORT_SYMBOL_GPL(devm_fwnode_pwm_get);
1114 : :
1115 : 0 : static int devm_pwm_match(struct device *dev, void *res, void *data)
1116 : : {
1117 : : struct pwm_device **p = res;
1118 : :
1119 [ # # # # : 0 : if (WARN_ON(!p || !*p))
# # # # ]
1120 : : return 0;
1121 : :
1122 : 0 : return *p == data;
1123 : : }
1124 : :
1125 : : /**
1126 : : * devm_pwm_put() - resource managed pwm_put()
1127 : : * @dev: device for PWM consumer
1128 : : * @pwm: PWM device
1129 : : *
1130 : : * Release a PWM previously allocated using devm_pwm_get(). Calling this
1131 : : * function is usually not needed because devm-allocated resources are
1132 : : * automatically released on driver detach.
1133 : : */
1134 : 0 : void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
1135 : : {
1136 [ # # ]: 0 : WARN_ON(devres_release(dev, devm_pwm_release, devm_pwm_match, pwm));
1137 : 0 : }
1138 : : EXPORT_SYMBOL_GPL(devm_pwm_put);
1139 : :
1140 : : #ifdef CONFIG_DEBUG_FS
1141 : 0 : static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s)
1142 : : {
1143 : : unsigned int i;
1144 : :
1145 [ # # ]: 0 : for (i = 0; i < chip->npwm; i++) {
1146 : 0 : struct pwm_device *pwm = &chip->pwms[i];
1147 : : struct pwm_state state;
1148 : :
1149 : : pwm_get_state(pwm, &state);
1150 : :
1151 : 0 : seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label);
1152 : :
1153 [ # # ]: 0 : if (test_bit(PWMF_REQUESTED, &pwm->flags))
1154 : 0 : seq_puts(s, " requested");
1155 : :
1156 [ # # ]: 0 : if (state.enabled)
1157 : 0 : seq_puts(s, " enabled");
1158 : :
1159 : 0 : seq_printf(s, " period: %u ns", state.period);
1160 : 0 : seq_printf(s, " duty: %u ns", state.duty_cycle);
1161 [ # # ]: 0 : seq_printf(s, " polarity: %s",
1162 : : state.polarity ? "inverse" : "normal");
1163 : :
1164 : 0 : seq_puts(s, "\n");
1165 : : }
1166 : 0 : }
1167 : :
1168 : 0 : static void *pwm_seq_start(struct seq_file *s, loff_t *pos)
1169 : : {
1170 : 0 : mutex_lock(&pwm_lock);
1171 : 0 : s->private = "";
1172 : :
1173 : 0 : return seq_list_start(&pwm_chips, *pos);
1174 : : }
1175 : :
1176 : 0 : static void *pwm_seq_next(struct seq_file *s, void *v, loff_t *pos)
1177 : : {
1178 : 0 : s->private = "\n";
1179 : :
1180 : 0 : return seq_list_next(v, &pwm_chips, pos);
1181 : : }
1182 : :
1183 : 0 : static void pwm_seq_stop(struct seq_file *s, void *v)
1184 : : {
1185 : 0 : mutex_unlock(&pwm_lock);
1186 : 0 : }
1187 : :
1188 : 0 : static int pwm_seq_show(struct seq_file *s, void *v)
1189 : : {
1190 : 0 : struct pwm_chip *chip = list_entry(v, struct pwm_chip, list);
1191 : :
1192 [ # # # # ]: 0 : seq_printf(s, "%s%s/%s, %d PWM device%s\n", (char *)s->private,
1193 : 0 : chip->dev->bus ? chip->dev->bus->name : "no-bus",
1194 : : dev_name(chip->dev), chip->npwm,
1195 : 0 : (chip->npwm != 1) ? "s" : "");
1196 : :
1197 : 0 : pwm_dbg_show(chip, s);
1198 : :
1199 : 0 : return 0;
1200 : : }
1201 : :
1202 : : static const struct seq_operations pwm_seq_ops = {
1203 : : .start = pwm_seq_start,
1204 : : .next = pwm_seq_next,
1205 : : .stop = pwm_seq_stop,
1206 : : .show = pwm_seq_show,
1207 : : };
1208 : :
1209 : 0 : static int pwm_seq_open(struct inode *inode, struct file *file)
1210 : : {
1211 : 0 : return seq_open(file, &pwm_seq_ops);
1212 : : }
1213 : :
1214 : : static const struct file_operations pwm_debugfs_ops = {
1215 : : .owner = THIS_MODULE,
1216 : : .open = pwm_seq_open,
1217 : : .read = seq_read,
1218 : : .llseek = seq_lseek,
1219 : : .release = seq_release,
1220 : : };
1221 : :
1222 : 404 : static int __init pwm_debugfs_init(void)
1223 : : {
1224 : 404 : debugfs_create_file("pwm", S_IFREG | S_IRUGO, NULL, NULL,
1225 : : &pwm_debugfs_ops);
1226 : :
1227 : 404 : return 0;
1228 : : }
1229 : : subsys_initcall(pwm_debugfs_init);
1230 : : #endif /* CONFIG_DEBUG_FS */
|
