Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Generic Framer framework.
4 *
5 * Copyright 2023 CS GROUP France
6 *
7 * Author: Herve Codina <herve.codina@bootlin.com>
8 */
9
10#include <linux/device.h>
11#include <linux/framer/framer.h>
12#include <linux/framer/framer-provider.h>
13#include <linux/idr.h>
14#include <linux/module.h>
15#include <linux/notifier.h>
16#include <linux/of.h>
17#include <linux/pm_runtime.h>
18#include <linux/regulator/consumer.h>
19#include <linux/slab.h>
20
21static struct class *framer_class;
22static DEFINE_MUTEX(framer_provider_mutex);
23static LIST_HEAD(framer_provider_list);
24static DEFINE_IDA(framer_ida);
25
26#define dev_to_framer(a) (container_of((a), struct framer, dev))
27
28int framer_pm_runtime_get(struct framer *framer)
29{
30 int ret;
31
32 if (!pm_runtime_enabled(&framer->dev))
33 return -EOPNOTSUPP;
34
35 ret = pm_runtime_get(&framer->dev);
36 if (ret < 0 && ret != -EINPROGRESS)
37 pm_runtime_put_noidle(&framer->dev);
38
39 return ret;
40}
41EXPORT_SYMBOL_GPL(framer_pm_runtime_get);
42
43int framer_pm_runtime_get_sync(struct framer *framer)
44{
45 int ret;
46
47 if (!pm_runtime_enabled(&framer->dev))
48 return -EOPNOTSUPP;
49
50 ret = pm_runtime_get_sync(&framer->dev);
51 if (ret < 0)
52 pm_runtime_put_sync(&framer->dev);
53
54 return ret;
55}
56EXPORT_SYMBOL_GPL(framer_pm_runtime_get_sync);
57
58int framer_pm_runtime_put(struct framer *framer)
59{
60 if (!pm_runtime_enabled(&framer->dev))
61 return -EOPNOTSUPP;
62
63 return pm_runtime_put(&framer->dev);
64}
65EXPORT_SYMBOL_GPL(framer_pm_runtime_put);
66
67int framer_pm_runtime_put_sync(struct framer *framer)
68{
69 if (!pm_runtime_enabled(&framer->dev))
70 return -EOPNOTSUPP;
71
72 return pm_runtime_put_sync(&framer->dev);
73}
74EXPORT_SYMBOL_GPL(framer_pm_runtime_put_sync);
75
76/**
77 * framer_init - framer internal initialization before framer operation
78 * @framer: the framer returned by framer_get()
79 *
80 * Used to allow framer's driver to perform framer internal initialization,
81 * such as PLL block powering, clock initialization or anything that's
82 * is required by the framer to perform the start of operation.
83 * Must be called before framer_power_on().
84 *
85 * Return: %0 if successful, a negative error code otherwise
86 */
87int framer_init(struct framer *framer)
88{
89 bool start_polling = false;
90 int ret;
91
92 ret = framer_pm_runtime_get_sync(framer);
93 if (ret < 0 && ret != -EOPNOTSUPP)
94 return ret;
95 ret = 0; /* Override possible ret == -EOPNOTSUPP */
96
97 mutex_lock(&framer->mutex);
98 if (framer->power_count > framer->init_count)
99 dev_warn(&framer->dev, "framer_power_on was called before framer init\n");
100
101 if (framer->init_count == 0) {
102 if (framer->ops->init) {
103 ret = framer->ops->init(framer);
104 if (ret < 0) {
105 dev_err(&framer->dev, "framer init failed --> %d\n", ret);
106 goto out;
107 }
108 }
109 if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS)
110 start_polling = true;
111 }
112 ++framer->init_count;
113
114out:
115 mutex_unlock(&framer->mutex);
116
117 if (!ret && start_polling) {
118 ret = framer_get_status(framer, &framer->prev_status);
119 if (ret < 0) {
120 dev_warn(&framer->dev, "framer get status failed --> %d\n", ret);
121 /* Will be retried on polling_work */
122 ret = 0;
123 }
124 queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);
125 }
126
127 framer_pm_runtime_put(framer);
128 return ret;
129}
130EXPORT_SYMBOL_GPL(framer_init);
131
132/**
133 * framer_exit - Framer internal un-initialization
134 * @framer: the framer returned by framer_get()
135 *
136 * Must be called after framer_power_off().
137 */
138int framer_exit(struct framer *framer)
139{
140 int ret;
141
142 ret = framer_pm_runtime_get_sync(framer);
143 if (ret < 0 && ret != -EOPNOTSUPP)
144 return ret;
145 ret = 0; /* Override possible ret == -EOPNOTSUPP */
146
147 mutex_lock(&framer->mutex);
148 --framer->init_count;
149 if (framer->init_count == 0) {
150 if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS) {
151 mutex_unlock(&framer->mutex);
152 cancel_delayed_work_sync(&framer->polling_work);
153 mutex_lock(&framer->mutex);
154 }
155
156 if (framer->ops->exit)
157 framer->ops->exit(framer);
158 }
159
160 mutex_unlock(&framer->mutex);
161 framer_pm_runtime_put(framer);
162 return ret;
163}
164EXPORT_SYMBOL_GPL(framer_exit);
165
166/**
167 * framer_power_on - Enable the framer and enter proper operation
168 * @framer: the framer returned by framer_get()
169 *
170 * Must be called after framer_init().
171 *
172 * Return: %0 if successful, a negative error code otherwise
173 */
174int framer_power_on(struct framer *framer)
175{
176 int ret;
177
178 if (framer->pwr) {
179 ret = regulator_enable(framer->pwr);
180 if (ret)
181 return ret;
182 }
183
184 ret = framer_pm_runtime_get_sync(framer);
185 if (ret < 0 && ret != -EOPNOTSUPP)
186 goto err_pm_sync;
187
188 mutex_lock(&framer->mutex);
189 if (framer->power_count == 0 && framer->ops->power_on) {
190 ret = framer->ops->power_on(framer);
191 if (ret < 0) {
192 dev_err(&framer->dev, "framer poweron failed --> %d\n", ret);
193 goto err_pwr_on;
194 }
195 }
196 ++framer->power_count;
197 mutex_unlock(&framer->mutex);
198 return 0;
199
200err_pwr_on:
201 mutex_unlock(&framer->mutex);
202 framer_pm_runtime_put_sync(framer);
203err_pm_sync:
204 if (framer->pwr)
205 regulator_disable(framer->pwr);
206 return ret;
207}
208EXPORT_SYMBOL_GPL(framer_power_on);
209
210/**
211 * framer_power_off - Disable the framer.
212 * @framer: the framer returned by framer_get()
213 *
214 * Must be called before framer_exit().
215 *
216 * Return: %0 if successful, a negative error code otherwise
217 */
218int framer_power_off(struct framer *framer)
219{
220 int ret;
221
222 mutex_lock(&framer->mutex);
223 if (framer->power_count == 1 && framer->ops->power_off) {
224 ret = framer->ops->power_off(framer);
225 if (ret < 0) {
226 dev_err(&framer->dev, "framer poweroff failed --> %d\n", ret);
227 mutex_unlock(&framer->mutex);
228 return ret;
229 }
230 }
231 --framer->power_count;
232 mutex_unlock(&framer->mutex);
233 framer_pm_runtime_put(framer);
234
235 if (framer->pwr)
236 regulator_disable(framer->pwr);
237
238 return 0;
239}
240EXPORT_SYMBOL_GPL(framer_power_off);
241
242/**
243 * framer_get_status() - Gets the framer status
244 * @framer: the framer returned by framer_get()
245 * @status: the status to retrieve
246 *
247 * Used to get the framer status. framer_init() must have been called
248 * on the framer.
249 *
250 * Return: %0 if successful, a negative error code otherwise
251 */
252int framer_get_status(struct framer *framer, struct framer_status *status)
253{
254 int ret;
255
256 if (!framer->ops->get_status)
257 return -EOPNOTSUPP;
258
259 /* Be sure to have known values (struct padding and future extensions) */
260 memset(status, 0, sizeof(*status));
261
262 mutex_lock(&framer->mutex);
263 ret = framer->ops->get_status(framer, status);
264 mutex_unlock(&framer->mutex);
265
266 return ret;
267}
268EXPORT_SYMBOL_GPL(framer_get_status);
269
270/**
271 * framer_set_config() - Sets the framer configuration
272 * @framer: the framer returned by framer_get()
273 * @config: the configuration to set
274 *
275 * Used to set the framer configuration. framer_init() must have been called
276 * on the framer.
277 *
278 * Return: %0 if successful, a negative error code otherwise
279 */
280int framer_set_config(struct framer *framer, const struct framer_config *config)
281{
282 int ret;
283
284 if (!framer->ops->set_config)
285 return -EOPNOTSUPP;
286
287 mutex_lock(&framer->mutex);
288 ret = framer->ops->set_config(framer, config);
289 mutex_unlock(&framer->mutex);
290
291 return ret;
292}
293EXPORT_SYMBOL_GPL(framer_set_config);
294
295/**
296 * framer_get_config() - Gets the framer configuration
297 * @framer: the framer returned by framer_get()
298 * @config: the configuration to retrieve
299 *
300 * Used to get the framer configuration. framer_init() must have been called
301 * on the framer.
302 *
303 * Return: %0 if successful, a negative error code otherwise
304 */
305int framer_get_config(struct framer *framer, struct framer_config *config)
306{
307 int ret;
308
309 if (!framer->ops->get_config)
310 return -EOPNOTSUPP;
311
312 mutex_lock(&framer->mutex);
313 ret = framer->ops->get_config(framer, config);
314 mutex_unlock(&framer->mutex);
315
316 return ret;
317}
318EXPORT_SYMBOL_GPL(framer_get_config);
319
320static void framer_polling_work(struct work_struct *work)
321{
322 struct framer *framer = container_of(work, struct framer, polling_work.work);
323 struct framer_status status;
324 int ret;
325
326 ret = framer_get_status(framer, &status);
327 if (ret) {
328 dev_err(&framer->dev, "polling, get status failed (%d)\n", ret);
329 goto end;
330 }
331 if (memcmp(&framer->prev_status, &status, sizeof(status))) {
332 blocking_notifier_call_chain(&framer->notifier_list,
333 FRAMER_EVENT_STATUS, NULL);
334 memcpy(&framer->prev_status, &status, sizeof(status));
335 }
336
337end:
338 /* Re-schedule task in 1 sec */
339 queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);
340}
341
342/**
343 * framer_notifier_register() - Registers a notifier
344 * @framer: the framer returned by framer_get()
345 * @nb: the notifier block to register
346 *
347 * Used to register a notifier block on framer events. framer_init() must have
348 * been called on the framer.
349 * The available framer events are present in enum framer_events.
350 *
351 * Return: %0 if successful, a negative error code otherwise
352 */
353int framer_notifier_register(struct framer *framer, struct notifier_block *nb)
354{
355 return blocking_notifier_chain_register(&framer->notifier_list, nb);
356}
357EXPORT_SYMBOL_GPL(framer_notifier_register);
358
359/**
360 * framer_notifier_unregister() - Unregisters a notifier
361 * @framer: the framer returned by framer_get()
362 * @nb: the notifier block to unregister
363 *
364 * Used to unregister a notifier block. framer_init() must have
365 * been called on the framer.
366 *
367 * Return: %0 if successful, a negative error code otherwise
368 */
369int framer_notifier_unregister(struct framer *framer, struct notifier_block *nb)
370{
371 return blocking_notifier_chain_unregister(&framer->notifier_list, nb);
372}
373EXPORT_SYMBOL_GPL(framer_notifier_unregister);
374
375static struct framer_provider *framer_provider_of_lookup(const struct device_node *node)
376{
377 struct framer_provider *framer_provider;
378
379 list_for_each_entry(framer_provider, &framer_provider_list, list) {
380 if (device_match_of_node(framer_provider->dev, node))
381 return framer_provider;
382 }
383
384 return ERR_PTR(-EPROBE_DEFER);
385}
386
387static struct framer *framer_of_get_from_provider(struct of_phandle_args *args)
388{
389 struct framer_provider *framer_provider;
390 struct framer *framer;
391
392 mutex_lock(&framer_provider_mutex);
393 framer_provider = framer_provider_of_lookup(args->np);
394 if (IS_ERR(framer_provider) || !try_module_get(framer_provider->owner)) {
395 framer = ERR_PTR(-EPROBE_DEFER);
396 goto end;
397 }
398
399 framer = framer_provider->of_xlate(framer_provider->dev, args);
400
401 module_put(framer_provider->owner);
402
403end:
404 mutex_unlock(&framer_provider_mutex);
405
406 return framer;
407}
408
409static struct framer *framer_of_get_byphandle(struct device_node *np, const char *propname,
410 int index)
411{
412 struct of_phandle_args args;
413 struct framer *framer;
414 int ret;
415
416 ret = of_parse_phandle_with_optional_args(np, propname, "#framer-cells", index, &args);
417 if (ret)
418 return ERR_PTR(-ENODEV);
419
420 if (!of_device_is_available(args.np)) {
421 framer = ERR_PTR(-ENODEV);
422 goto out_node_put;
423 }
424
425 framer = framer_of_get_from_provider(&args);
426
427out_node_put:
428 of_node_put(args.np);
429
430 return framer;
431}
432
433static struct framer *framer_of_get_byparent(struct device_node *np, int index)
434{
435 struct of_phandle_args args;
436 struct framer *framer;
437
438 args.np = of_get_parent(np);
439 args.args_count = 1;
440 args.args[0] = index;
441
442 while (args.np) {
443 framer = framer_of_get_from_provider(&args);
444 if (IS_ERR(framer) && PTR_ERR(framer) != -EPROBE_DEFER) {
445 args.np = of_get_next_parent(args.np);
446 continue;
447 }
448 of_node_put(args.np);
449 return framer;
450 }
451
452 return ERR_PTR(-ENODEV);
453}
454
455/**
456 * framer_get() - lookup and obtain a reference to a framer.
457 * @dev: device that requests the framer
458 * @con_id: name of the framer from device's point of view
459 *
460 * Returns the framer driver, after getting a refcount to it; or
461 * -ENODEV if there is no such framer. The caller is responsible for
462 * calling framer_put() to release that count.
463 */
464struct framer *framer_get(struct device *dev, const char *con_id)
465{
466 struct framer *framer = ERR_PTR(-ENODEV);
467 struct device_link *link;
468 int ret;
469
470 if (dev->of_node) {
471 if (con_id)
472 framer = framer_of_get_byphandle(dev->of_node, con_id, 0);
473 else
474 framer = framer_of_get_byparent(dev->of_node, 0);
475 }
476
477 if (IS_ERR(framer))
478 return framer;
479
480 get_device(&framer->dev);
481
482 if (!try_module_get(framer->ops->owner)) {
483 ret = -EPROBE_DEFER;
484 goto err_put_device;
485 }
486
487 link = device_link_add(dev, &framer->dev, DL_FLAG_STATELESS);
488 if (!link) {
489 dev_err(dev, "failed to create device_link to %s\n", dev_name(&framer->dev));
490 ret = -EPROBE_DEFER;
491 goto err_module_put;
492 }
493
494 return framer;
495
496err_module_put:
497 module_put(framer->ops->owner);
498err_put_device:
499 put_device(&framer->dev);
500 return ERR_PTR(ret);
501}
502EXPORT_SYMBOL_GPL(framer_get);
503
504/**
505 * framer_put() - release the framer
506 * @dev: device that wants to release this framer
507 * @framer: the framer returned by framer_get()
508 *
509 * Releases a refcount the caller received from framer_get().
510 */
511void framer_put(struct device *dev, struct framer *framer)
512{
513 device_link_remove(dev, &framer->dev);
514
515 module_put(framer->ops->owner);
516 put_device(&framer->dev);
517}
518EXPORT_SYMBOL_GPL(framer_put);
519
520static void devm_framer_put(struct device *dev, void *res)
521{
522 struct framer *framer = *(struct framer **)res;
523
524 framer_put(dev, framer);
525}
526
527/**
528 * devm_framer_get() - lookup and obtain a reference to a framer.
529 * @dev: device that requests this framer
530 * @con_id: name of the framer from device's point of view
531 *
532 * Gets the framer using framer_get(), and associates a device with it using
533 * devres. On driver detach, framer_put() function is invoked on the devres
534 * data, then, devres data is freed.
535 */
536struct framer *devm_framer_get(struct device *dev, const char *con_id)
537{
538 struct framer **ptr, *framer;
539
540 ptr = devres_alloc(devm_framer_put, sizeof(*ptr), GFP_KERNEL);
541 if (!ptr)
542 return ERR_PTR(-ENOMEM);
543
544 framer = framer_get(dev, con_id);
545 if (!IS_ERR(framer)) {
546 *ptr = framer;
547 devres_add(dev, ptr);
548 } else {
549 devres_free(ptr);
550 return framer;
551 }
552
553 return framer;
554}
555EXPORT_SYMBOL_GPL(devm_framer_get);
556
557/**
558 * devm_framer_optional_get() - lookup and obtain a reference to an optional
559 * framer.
560 * @dev: device that requests this framer
561 * @con_id: name of the framer from device's point of view
562 *
563 * Same as devm_framer_get() except that if the framer does not exist, it is not
564 * considered an error and -ENODEV will not be returned. Instead the NULL framer
565 * is returned.
566 */
567struct framer *devm_framer_optional_get(struct device *dev, const char *con_id)
568{
569 struct framer *framer = devm_framer_get(dev, con_id);
570
571 if (PTR_ERR(framer) == -ENODEV)
572 framer = NULL;
573
574 return framer;
575}
576EXPORT_SYMBOL_GPL(devm_framer_optional_get);
577
578static void framer_notify_status_work(struct work_struct *work)
579{
580 struct framer *framer = container_of(work, struct framer, notify_status_work);
581
582 blocking_notifier_call_chain(&framer->notifier_list, FRAMER_EVENT_STATUS, NULL);
583}
584
585void framer_notify_status_change(struct framer *framer)
586{
587 /* Can be called from atomic context -> just schedule a task to call
588 * blocking notifiers
589 */
590 queue_work(system_power_efficient_wq, &framer->notify_status_work);
591}
592EXPORT_SYMBOL_GPL(framer_notify_status_change);
593
594/**
595 * framer_create() - create a new framer
596 * @dev: device that is creating the new framer
597 * @node: device node of the framer. default to dev->of_node.
598 * @ops: function pointers for performing framer operations
599 *
600 * Called to create a framer using framer framework.
601 */
602struct framer *framer_create(struct device *dev, struct device_node *node,
603 const struct framer_ops *ops)
604{
605 struct framer *framer;
606 int ret;
607 int id;
608
609 /* get_status() is mandatory if the provider ask for polling status */
610 if (WARN_ON((ops->flags & FRAMER_FLAG_POLL_STATUS) && !ops->get_status))
611 return ERR_PTR(-EINVAL);
612
613 framer = kzalloc(sizeof(*framer), GFP_KERNEL);
614 if (!framer)
615 return ERR_PTR(-ENOMEM);
616
617 id = ida_alloc(&framer_ida, GFP_KERNEL);
618 if (id < 0) {
619 dev_err(dev, "unable to get id\n");
620 ret = id;
621 goto free_framer;
622 }
623
624 device_initialize(&framer->dev);
625 mutex_init(&framer->mutex);
626 INIT_WORK(&framer->notify_status_work, framer_notify_status_work);
627 INIT_DELAYED_WORK(&framer->polling_work, framer_polling_work);
628 BLOCKING_INIT_NOTIFIER_HEAD(&framer->notifier_list);
629
630 framer->dev.class = framer_class;
631 framer->dev.parent = dev;
632 framer->dev.of_node = node ? node : dev->of_node;
633 framer->id = id;
634 framer->ops = ops;
635
636 ret = dev_set_name(&framer->dev, "framer-%s.%d", dev_name(dev), id);
637 if (ret)
638 goto put_dev;
639
640 /* framer-supply */
641 framer->pwr = regulator_get_optional(&framer->dev, "framer");
642 if (IS_ERR(framer->pwr)) {
643 ret = PTR_ERR(framer->pwr);
644 if (ret == -EPROBE_DEFER)
645 goto put_dev;
646
647 framer->pwr = NULL;
648 }
649
650 ret = device_add(&framer->dev);
651 if (ret)
652 goto put_dev;
653
654 if (pm_runtime_enabled(dev)) {
655 pm_runtime_enable(&framer->dev);
656 pm_runtime_no_callbacks(&framer->dev);
657 }
658
659 return framer;
660
661put_dev:
662 put_device(&framer->dev); /* calls framer_release() which frees resources */
663 return ERR_PTR(ret);
664
665free_framer:
666 kfree(framer);
667 return ERR_PTR(ret);
668}
669EXPORT_SYMBOL_GPL(framer_create);
670
671/**
672 * framer_destroy() - destroy the framer
673 * @framer: the framer to be destroyed
674 *
675 * Called to destroy the framer.
676 */
677void framer_destroy(struct framer *framer)
678{
679 /* polling_work should already be stopped but if framer_exit() was not
680 * called (bug), here it's the last time to do that ...
681 */
682 cancel_delayed_work_sync(&framer->polling_work);
683 cancel_work_sync(&framer->notify_status_work);
684 pm_runtime_disable(&framer->dev);
685 device_unregister(&framer->dev); /* calls framer_release() which frees resources */
686}
687EXPORT_SYMBOL_GPL(framer_destroy);
688
689static void devm_framer_destroy(struct device *dev, void *res)
690{
691 struct framer *framer = *(struct framer **)res;
692
693 framer_destroy(framer);
694}
695
696/**
697 * devm_framer_create() - create a new framer
698 * @dev: device that is creating the new framer
699 * @node: device node of the framer
700 * @ops: function pointers for performing framer operations
701 *
702 * Creates a new framer device adding it to the framer class.
703 * While at that, it also associates the device with the framer using devres.
704 * On driver detach, release function is invoked on the devres data,
705 * then, devres data is freed.
706 */
707struct framer *devm_framer_create(struct device *dev, struct device_node *node,
708 const struct framer_ops *ops)
709{
710 struct framer **ptr, *framer;
711
712 ptr = devres_alloc(devm_framer_destroy, sizeof(*ptr), GFP_KERNEL);
713 if (!ptr)
714 return ERR_PTR(-ENOMEM);
715
716 framer = framer_create(dev, node, ops);
717 if (!IS_ERR(framer)) {
718 *ptr = framer;
719 devres_add(dev, ptr);
720 } else {
721 devres_free(ptr);
722 }
723
724 return framer;
725}
726EXPORT_SYMBOL_GPL(devm_framer_create);
727
728/**
729 * framer_provider_simple_of_xlate() - returns the framer instance from framer provider
730 * @dev: the framer provider device
731 * @args: of_phandle_args (not used here)
732 *
733 * Intended to be used by framer provider for the common case where #framer-cells is
734 * 0. For other cases where #framer-cells is greater than '0', the framer provider
735 * should provide a custom of_xlate function that reads the *args* and returns
736 * the appropriate framer.
737 */
738struct framer *framer_provider_simple_of_xlate(struct device *dev, struct of_phandle_args *args)
739{
740 struct class_dev_iter iter;
741 struct framer *framer;
742
743 class_dev_iter_init(&iter, framer_class, NULL, NULL);
744 while ((dev = class_dev_iter_next(&iter))) {
745 framer = dev_to_framer(dev);
746 if (args->np != framer->dev.of_node)
747 continue;
748
749 class_dev_iter_exit(&iter);
750 return framer;
751 }
752
753 class_dev_iter_exit(&iter);
754 return ERR_PTR(-ENODEV);
755}
756EXPORT_SYMBOL_GPL(framer_provider_simple_of_xlate);
757
758/**
759 * __framer_provider_of_register() - create/register framer provider with the framework
760 * @dev: struct device of the framer provider
761 * @owner: the module owner containing of_xlate
762 * @of_xlate: function pointer to obtain framer instance from framer provider
763 *
764 * Creates struct framer_provider from dev and of_xlate function pointer.
765 * This is used in the case of dt boot for finding the framer instance from
766 * framer provider.
767 */
768struct framer_provider *
769__framer_provider_of_register(struct device *dev, struct module *owner,
770 struct framer *(*of_xlate)(struct device *dev,
771 struct of_phandle_args *args))
772{
773 struct framer_provider *framer_provider;
774
775 framer_provider = kzalloc(sizeof(*framer_provider), GFP_KERNEL);
776 if (!framer_provider)
777 return ERR_PTR(-ENOMEM);
778
779 framer_provider->dev = dev;
780 framer_provider->owner = owner;
781 framer_provider->of_xlate = of_xlate;
782
783 of_node_get(framer_provider->dev->of_node);
784
785 mutex_lock(&framer_provider_mutex);
786 list_add_tail(&framer_provider->list, &framer_provider_list);
787 mutex_unlock(&framer_provider_mutex);
788
789 return framer_provider;
790}
791EXPORT_SYMBOL_GPL(__framer_provider_of_register);
792
793/**
794 * framer_provider_of_unregister() - unregister framer provider from the framework
795 * @framer_provider: framer provider returned by framer_provider_of_register()
796 *
797 * Removes the framer_provider created using framer_provider_of_register().
798 */
799void framer_provider_of_unregister(struct framer_provider *framer_provider)
800{
801 mutex_lock(&framer_provider_mutex);
802 list_del(&framer_provider->list);
803 mutex_unlock(&framer_provider_mutex);
804
805 of_node_put(framer_provider->dev->of_node);
806 kfree(framer_provider);
807}
808EXPORT_SYMBOL_GPL(framer_provider_of_unregister);
809
810static void devm_framer_provider_of_unregister(struct device *dev, void *res)
811{
812 struct framer_provider *framer_provider = *(struct framer_provider **)res;
813
814 framer_provider_of_unregister(framer_provider);
815}
816
817/**
818 * __devm_framer_provider_of_register() - create/register framer provider with
819 * the framework
820 * @dev: struct device of the framer provider
821 * @owner: the module owner containing of_xlate
822 * @of_xlate: function pointer to obtain framer instance from framer provider
823 *
824 * Creates struct framer_provider from dev and of_xlate function pointer.
825 * This is used in the case of dt boot for finding the framer instance from
826 * framer provider. While at that, it also associates the device with the
827 * framer provider using devres. On driver detach, release function is invoked
828 * on the devres data, then, devres data is freed.
829 */
830struct framer_provider *
831__devm_framer_provider_of_register(struct device *dev, struct module *owner,
832 struct framer *(*of_xlate)(struct device *dev,
833 struct of_phandle_args *args))
834{
835 struct framer_provider **ptr, *framer_provider;
836
837 ptr = devres_alloc(devm_framer_provider_of_unregister, sizeof(*ptr), GFP_KERNEL);
838 if (!ptr)
839 return ERR_PTR(-ENOMEM);
840
841 framer_provider = __framer_provider_of_register(dev, owner, of_xlate);
842 if (!IS_ERR(framer_provider)) {
843 *ptr = framer_provider;
844 devres_add(dev, ptr);
845 } else {
846 devres_free(ptr);
847 }
848
849 return framer_provider;
850}
851EXPORT_SYMBOL_GPL(__devm_framer_provider_of_register);
852
853/**
854 * framer_release() - release the framer
855 * @dev: the dev member within framer
856 *
857 * When the last reference to the device is removed, it is called
858 * from the embedded kobject as release method.
859 */
860static void framer_release(struct device *dev)
861{
862 struct framer *framer;
863
864 framer = dev_to_framer(dev);
865 regulator_put(framer->pwr);
866 ida_free(&framer_ida, framer->id);
867 kfree(framer);
868}
869
870static int __init framer_core_init(void)
871{
872 framer_class = class_create("framer");
873 if (IS_ERR(framer_class)) {
874 pr_err("failed to create framer class (%pe)\n", framer_class);
875 return PTR_ERR(framer_class);
876 }
877
878 framer_class->dev_release = framer_release;
879
880 return 0;
881}
882device_initcall(framer_core_init);
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Generic Framer framework.
4 *
5 * Copyright 2023 CS GROUP France
6 *
7 * Author: Herve Codina <herve.codina@bootlin.com>
8 */
9
10#include <linux/device.h>
11#include <linux/framer/framer.h>
12#include <linux/framer/framer-provider.h>
13#include <linux/idr.h>
14#include <linux/module.h>
15#include <linux/notifier.h>
16#include <linux/of.h>
17#include <linux/pm_runtime.h>
18#include <linux/regulator/consumer.h>
19#include <linux/slab.h>
20
21static void framer_release(struct device *dev);
22static const struct class framer_class = {
23 .name = "framer",
24 .dev_release = framer_release,
25};
26
27static DEFINE_MUTEX(framer_provider_mutex);
28static LIST_HEAD(framer_provider_list);
29static DEFINE_IDA(framer_ida);
30
31#define dev_to_framer(a) (container_of((a), struct framer, dev))
32
33int framer_pm_runtime_get(struct framer *framer)
34{
35 int ret;
36
37 if (!pm_runtime_enabled(&framer->dev))
38 return -EOPNOTSUPP;
39
40 ret = pm_runtime_get(&framer->dev);
41 if (ret < 0 && ret != -EINPROGRESS)
42 pm_runtime_put_noidle(&framer->dev);
43
44 return ret;
45}
46EXPORT_SYMBOL_GPL(framer_pm_runtime_get);
47
48int framer_pm_runtime_get_sync(struct framer *framer)
49{
50 int ret;
51
52 if (!pm_runtime_enabled(&framer->dev))
53 return -EOPNOTSUPP;
54
55 ret = pm_runtime_get_sync(&framer->dev);
56 if (ret < 0)
57 pm_runtime_put_sync(&framer->dev);
58
59 return ret;
60}
61EXPORT_SYMBOL_GPL(framer_pm_runtime_get_sync);
62
63int framer_pm_runtime_put(struct framer *framer)
64{
65 if (!pm_runtime_enabled(&framer->dev))
66 return -EOPNOTSUPP;
67
68 return pm_runtime_put(&framer->dev);
69}
70EXPORT_SYMBOL_GPL(framer_pm_runtime_put);
71
72int framer_pm_runtime_put_sync(struct framer *framer)
73{
74 if (!pm_runtime_enabled(&framer->dev))
75 return -EOPNOTSUPP;
76
77 return pm_runtime_put_sync(&framer->dev);
78}
79EXPORT_SYMBOL_GPL(framer_pm_runtime_put_sync);
80
81/**
82 * framer_init - framer internal initialization before framer operation
83 * @framer: the framer returned by framer_get()
84 *
85 * Used to allow framer's driver to perform framer internal initialization,
86 * such as PLL block powering, clock initialization or anything that's
87 * is required by the framer to perform the start of operation.
88 * Must be called before framer_power_on().
89 *
90 * Return: %0 if successful, a negative error code otherwise
91 */
92int framer_init(struct framer *framer)
93{
94 bool start_polling = false;
95 int ret;
96
97 ret = framer_pm_runtime_get_sync(framer);
98 if (ret < 0 && ret != -EOPNOTSUPP)
99 return ret;
100 ret = 0; /* Override possible ret == -EOPNOTSUPP */
101
102 mutex_lock(&framer->mutex);
103 if (framer->power_count > framer->init_count)
104 dev_warn(&framer->dev, "framer_power_on was called before framer init\n");
105
106 if (framer->init_count == 0) {
107 if (framer->ops->init) {
108 ret = framer->ops->init(framer);
109 if (ret < 0) {
110 dev_err(&framer->dev, "framer init failed --> %d\n", ret);
111 goto out;
112 }
113 }
114 if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS)
115 start_polling = true;
116 }
117 ++framer->init_count;
118
119out:
120 mutex_unlock(&framer->mutex);
121
122 if (!ret && start_polling) {
123 ret = framer_get_status(framer, &framer->prev_status);
124 if (ret < 0) {
125 dev_warn(&framer->dev, "framer get status failed --> %d\n", ret);
126 /* Will be retried on polling_work */
127 ret = 0;
128 }
129 queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);
130 }
131
132 framer_pm_runtime_put(framer);
133 return ret;
134}
135EXPORT_SYMBOL_GPL(framer_init);
136
137/**
138 * framer_exit - Framer internal un-initialization
139 * @framer: the framer returned by framer_get()
140 *
141 * Must be called after framer_power_off().
142 */
143int framer_exit(struct framer *framer)
144{
145 int ret;
146
147 ret = framer_pm_runtime_get_sync(framer);
148 if (ret < 0 && ret != -EOPNOTSUPP)
149 return ret;
150 ret = 0; /* Override possible ret == -EOPNOTSUPP */
151
152 mutex_lock(&framer->mutex);
153 --framer->init_count;
154 if (framer->init_count == 0) {
155 if (framer->ops->flags & FRAMER_FLAG_POLL_STATUS) {
156 mutex_unlock(&framer->mutex);
157 cancel_delayed_work_sync(&framer->polling_work);
158 mutex_lock(&framer->mutex);
159 }
160
161 if (framer->ops->exit)
162 framer->ops->exit(framer);
163 }
164
165 mutex_unlock(&framer->mutex);
166 framer_pm_runtime_put(framer);
167 return ret;
168}
169EXPORT_SYMBOL_GPL(framer_exit);
170
171/**
172 * framer_power_on - Enable the framer and enter proper operation
173 * @framer: the framer returned by framer_get()
174 *
175 * Must be called after framer_init().
176 *
177 * Return: %0 if successful, a negative error code otherwise
178 */
179int framer_power_on(struct framer *framer)
180{
181 int ret;
182
183 if (framer->pwr) {
184 ret = regulator_enable(framer->pwr);
185 if (ret)
186 return ret;
187 }
188
189 ret = framer_pm_runtime_get_sync(framer);
190 if (ret < 0 && ret != -EOPNOTSUPP)
191 goto err_pm_sync;
192
193 mutex_lock(&framer->mutex);
194 if (framer->power_count == 0 && framer->ops->power_on) {
195 ret = framer->ops->power_on(framer);
196 if (ret < 0) {
197 dev_err(&framer->dev, "framer poweron failed --> %d\n", ret);
198 goto err_pwr_on;
199 }
200 }
201 ++framer->power_count;
202 mutex_unlock(&framer->mutex);
203 return 0;
204
205err_pwr_on:
206 mutex_unlock(&framer->mutex);
207 framer_pm_runtime_put_sync(framer);
208err_pm_sync:
209 if (framer->pwr)
210 regulator_disable(framer->pwr);
211 return ret;
212}
213EXPORT_SYMBOL_GPL(framer_power_on);
214
215/**
216 * framer_power_off - Disable the framer.
217 * @framer: the framer returned by framer_get()
218 *
219 * Must be called before framer_exit().
220 *
221 * Return: %0 if successful, a negative error code otherwise
222 */
223int framer_power_off(struct framer *framer)
224{
225 int ret;
226
227 mutex_lock(&framer->mutex);
228 if (framer->power_count == 1 && framer->ops->power_off) {
229 ret = framer->ops->power_off(framer);
230 if (ret < 0) {
231 dev_err(&framer->dev, "framer poweroff failed --> %d\n", ret);
232 mutex_unlock(&framer->mutex);
233 return ret;
234 }
235 }
236 --framer->power_count;
237 mutex_unlock(&framer->mutex);
238 framer_pm_runtime_put(framer);
239
240 if (framer->pwr)
241 regulator_disable(framer->pwr);
242
243 return 0;
244}
245EXPORT_SYMBOL_GPL(framer_power_off);
246
247/**
248 * framer_get_status() - Gets the framer status
249 * @framer: the framer returned by framer_get()
250 * @status: the status to retrieve
251 *
252 * Used to get the framer status. framer_init() must have been called
253 * on the framer.
254 *
255 * Return: %0 if successful, a negative error code otherwise
256 */
257int framer_get_status(struct framer *framer, struct framer_status *status)
258{
259 int ret;
260
261 if (!framer->ops->get_status)
262 return -EOPNOTSUPP;
263
264 /* Be sure to have known values (struct padding and future extensions) */
265 memset(status, 0, sizeof(*status));
266
267 mutex_lock(&framer->mutex);
268 ret = framer->ops->get_status(framer, status);
269 mutex_unlock(&framer->mutex);
270
271 return ret;
272}
273EXPORT_SYMBOL_GPL(framer_get_status);
274
275/**
276 * framer_set_config() - Sets the framer configuration
277 * @framer: the framer returned by framer_get()
278 * @config: the configuration to set
279 *
280 * Used to set the framer configuration. framer_init() must have been called
281 * on the framer.
282 *
283 * Return: %0 if successful, a negative error code otherwise
284 */
285int framer_set_config(struct framer *framer, const struct framer_config *config)
286{
287 int ret;
288
289 if (!framer->ops->set_config)
290 return -EOPNOTSUPP;
291
292 mutex_lock(&framer->mutex);
293 ret = framer->ops->set_config(framer, config);
294 mutex_unlock(&framer->mutex);
295
296 return ret;
297}
298EXPORT_SYMBOL_GPL(framer_set_config);
299
300/**
301 * framer_get_config() - Gets the framer configuration
302 * @framer: the framer returned by framer_get()
303 * @config: the configuration to retrieve
304 *
305 * Used to get the framer configuration. framer_init() must have been called
306 * on the framer.
307 *
308 * Return: %0 if successful, a negative error code otherwise
309 */
310int framer_get_config(struct framer *framer, struct framer_config *config)
311{
312 int ret;
313
314 if (!framer->ops->get_config)
315 return -EOPNOTSUPP;
316
317 mutex_lock(&framer->mutex);
318 ret = framer->ops->get_config(framer, config);
319 mutex_unlock(&framer->mutex);
320
321 return ret;
322}
323EXPORT_SYMBOL_GPL(framer_get_config);
324
325static void framer_polling_work(struct work_struct *work)
326{
327 struct framer *framer = container_of(work, struct framer, polling_work.work);
328 struct framer_status status;
329 int ret;
330
331 ret = framer_get_status(framer, &status);
332 if (ret) {
333 dev_err(&framer->dev, "polling, get status failed (%d)\n", ret);
334 goto end;
335 }
336 if (memcmp(&framer->prev_status, &status, sizeof(status))) {
337 blocking_notifier_call_chain(&framer->notifier_list,
338 FRAMER_EVENT_STATUS, NULL);
339 memcpy(&framer->prev_status, &status, sizeof(status));
340 }
341
342end:
343 /* Re-schedule task in 1 sec */
344 queue_delayed_work(system_power_efficient_wq, &framer->polling_work, 1 * HZ);
345}
346
347/**
348 * framer_notifier_register() - Registers a notifier
349 * @framer: the framer returned by framer_get()
350 * @nb: the notifier block to register
351 *
352 * Used to register a notifier block on framer events. framer_init() must have
353 * been called on the framer.
354 * The available framer events are present in enum framer_events.
355 *
356 * Return: %0 if successful, a negative error code otherwise
357 */
358int framer_notifier_register(struct framer *framer, struct notifier_block *nb)
359{
360 return blocking_notifier_chain_register(&framer->notifier_list, nb);
361}
362EXPORT_SYMBOL_GPL(framer_notifier_register);
363
364/**
365 * framer_notifier_unregister() - Unregisters a notifier
366 * @framer: the framer returned by framer_get()
367 * @nb: the notifier block to unregister
368 *
369 * Used to unregister a notifier block. framer_init() must have
370 * been called on the framer.
371 *
372 * Return: %0 if successful, a negative error code otherwise
373 */
374int framer_notifier_unregister(struct framer *framer, struct notifier_block *nb)
375{
376 return blocking_notifier_chain_unregister(&framer->notifier_list, nb);
377}
378EXPORT_SYMBOL_GPL(framer_notifier_unregister);
379
380static struct framer_provider *framer_provider_of_lookup(const struct device_node *node)
381{
382 struct framer_provider *framer_provider;
383
384 list_for_each_entry(framer_provider, &framer_provider_list, list) {
385 if (device_match_of_node(framer_provider->dev, node))
386 return framer_provider;
387 }
388
389 return ERR_PTR(-EPROBE_DEFER);
390}
391
392static struct framer *framer_of_get_from_provider(const struct of_phandle_args *args)
393{
394 struct framer_provider *framer_provider;
395 struct framer *framer;
396
397 mutex_lock(&framer_provider_mutex);
398 framer_provider = framer_provider_of_lookup(args->np);
399 if (IS_ERR(framer_provider) || !try_module_get(framer_provider->owner)) {
400 framer = ERR_PTR(-EPROBE_DEFER);
401 goto end;
402 }
403
404 framer = framer_provider->of_xlate(framer_provider->dev, args);
405
406 module_put(framer_provider->owner);
407
408end:
409 mutex_unlock(&framer_provider_mutex);
410
411 return framer;
412}
413
414static struct framer *framer_of_get_byphandle(struct device_node *np, const char *propname,
415 int index)
416{
417 struct of_phandle_args args;
418 struct framer *framer;
419 int ret;
420
421 ret = of_parse_phandle_with_optional_args(np, propname, "#framer-cells", index, &args);
422 if (ret)
423 return ERR_PTR(-ENODEV);
424
425 if (!of_device_is_available(args.np)) {
426 framer = ERR_PTR(-ENODEV);
427 goto out_node_put;
428 }
429
430 framer = framer_of_get_from_provider(&args);
431
432out_node_put:
433 of_node_put(args.np);
434
435 return framer;
436}
437
438static struct framer *framer_of_get_byparent(struct device_node *np, int index)
439{
440 struct of_phandle_args args;
441 struct framer *framer;
442
443 args.np = of_get_parent(np);
444 args.args_count = 1;
445 args.args[0] = index;
446
447 while (args.np) {
448 framer = framer_of_get_from_provider(&args);
449 if (IS_ERR(framer) && PTR_ERR(framer) != -EPROBE_DEFER) {
450 args.np = of_get_next_parent(args.np);
451 continue;
452 }
453 of_node_put(args.np);
454 return framer;
455 }
456
457 return ERR_PTR(-ENODEV);
458}
459
460/**
461 * framer_get() - lookup and obtain a reference to a framer.
462 * @dev: device that requests the framer
463 * @con_id: name of the framer from device's point of view
464 *
465 * Returns the framer driver, after getting a refcount to it; or
466 * -ENODEV if there is no such framer. The caller is responsible for
467 * calling framer_put() to release that count.
468 */
469struct framer *framer_get(struct device *dev, const char *con_id)
470{
471 struct framer *framer = ERR_PTR(-ENODEV);
472 struct device_link *link;
473 int ret;
474
475 if (dev->of_node) {
476 if (con_id)
477 framer = framer_of_get_byphandle(dev->of_node, con_id, 0);
478 else
479 framer = framer_of_get_byparent(dev->of_node, 0);
480 }
481
482 if (IS_ERR(framer))
483 return framer;
484
485 get_device(&framer->dev);
486
487 if (!try_module_get(framer->ops->owner)) {
488 ret = -EPROBE_DEFER;
489 goto err_put_device;
490 }
491
492 link = device_link_add(dev, &framer->dev, DL_FLAG_STATELESS);
493 if (!link) {
494 dev_err(dev, "failed to create device_link to %s\n", dev_name(&framer->dev));
495 ret = -EPROBE_DEFER;
496 goto err_module_put;
497 }
498
499 return framer;
500
501err_module_put:
502 module_put(framer->ops->owner);
503err_put_device:
504 put_device(&framer->dev);
505 return ERR_PTR(ret);
506}
507EXPORT_SYMBOL_GPL(framer_get);
508
509/**
510 * framer_put() - release the framer
511 * @dev: device that wants to release this framer
512 * @framer: the framer returned by framer_get()
513 *
514 * Releases a refcount the caller received from framer_get().
515 */
516void framer_put(struct device *dev, struct framer *framer)
517{
518 device_link_remove(dev, &framer->dev);
519
520 module_put(framer->ops->owner);
521 put_device(&framer->dev);
522}
523EXPORT_SYMBOL_GPL(framer_put);
524
525static void devm_framer_put(struct device *dev, void *res)
526{
527 struct framer *framer = *(struct framer **)res;
528
529 framer_put(dev, framer);
530}
531
532/**
533 * devm_framer_get() - lookup and obtain a reference to a framer.
534 * @dev: device that requests this framer
535 * @con_id: name of the framer from device's point of view
536 *
537 * Gets the framer using framer_get(), and associates a device with it using
538 * devres. On driver detach, framer_put() function is invoked on the devres
539 * data, then, devres data is freed.
540 */
541struct framer *devm_framer_get(struct device *dev, const char *con_id)
542{
543 struct framer **ptr, *framer;
544
545 ptr = devres_alloc(devm_framer_put, sizeof(*ptr), GFP_KERNEL);
546 if (!ptr)
547 return ERR_PTR(-ENOMEM);
548
549 framer = framer_get(dev, con_id);
550 if (!IS_ERR(framer)) {
551 *ptr = framer;
552 devres_add(dev, ptr);
553 } else {
554 devres_free(ptr);
555 return framer;
556 }
557
558 return framer;
559}
560EXPORT_SYMBOL_GPL(devm_framer_get);
561
562/**
563 * devm_framer_optional_get() - lookup and obtain a reference to an optional
564 * framer.
565 * @dev: device that requests this framer
566 * @con_id: name of the framer from device's point of view
567 *
568 * Same as devm_framer_get() except that if the framer does not exist, it is not
569 * considered an error and -ENODEV will not be returned. Instead the NULL framer
570 * is returned.
571 */
572struct framer *devm_framer_optional_get(struct device *dev, const char *con_id)
573{
574 struct framer *framer = devm_framer_get(dev, con_id);
575
576 if (PTR_ERR(framer) == -ENODEV)
577 framer = NULL;
578
579 return framer;
580}
581EXPORT_SYMBOL_GPL(devm_framer_optional_get);
582
583static void framer_notify_status_work(struct work_struct *work)
584{
585 struct framer *framer = container_of(work, struct framer, notify_status_work);
586
587 blocking_notifier_call_chain(&framer->notifier_list, FRAMER_EVENT_STATUS, NULL);
588}
589
590void framer_notify_status_change(struct framer *framer)
591{
592 /* Can be called from atomic context -> just schedule a task to call
593 * blocking notifiers
594 */
595 queue_work(system_power_efficient_wq, &framer->notify_status_work);
596}
597EXPORT_SYMBOL_GPL(framer_notify_status_change);
598
599/**
600 * framer_create() - create a new framer
601 * @dev: device that is creating the new framer
602 * @node: device node of the framer. default to dev->of_node.
603 * @ops: function pointers for performing framer operations
604 *
605 * Called to create a framer using framer framework.
606 */
607struct framer *framer_create(struct device *dev, struct device_node *node,
608 const struct framer_ops *ops)
609{
610 struct framer *framer;
611 int ret;
612 int id;
613
614 /* get_status() is mandatory if the provider ask for polling status */
615 if (WARN_ON((ops->flags & FRAMER_FLAG_POLL_STATUS) && !ops->get_status))
616 return ERR_PTR(-EINVAL);
617
618 framer = kzalloc(sizeof(*framer), GFP_KERNEL);
619 if (!framer)
620 return ERR_PTR(-ENOMEM);
621
622 id = ida_alloc(&framer_ida, GFP_KERNEL);
623 if (id < 0) {
624 dev_err(dev, "unable to get id\n");
625 ret = id;
626 goto free_framer;
627 }
628
629 device_initialize(&framer->dev);
630 mutex_init(&framer->mutex);
631 INIT_WORK(&framer->notify_status_work, framer_notify_status_work);
632 INIT_DELAYED_WORK(&framer->polling_work, framer_polling_work);
633 BLOCKING_INIT_NOTIFIER_HEAD(&framer->notifier_list);
634
635 framer->dev.class = &framer_class;
636 framer->dev.parent = dev;
637 framer->dev.of_node = node ? node : dev->of_node;
638 framer->id = id;
639 framer->ops = ops;
640
641 ret = dev_set_name(&framer->dev, "framer-%s.%d", dev_name(dev), id);
642 if (ret)
643 goto put_dev;
644
645 /* framer-supply */
646 framer->pwr = regulator_get_optional(&framer->dev, "framer");
647 if (IS_ERR(framer->pwr)) {
648 ret = PTR_ERR(framer->pwr);
649 if (ret == -EPROBE_DEFER)
650 goto put_dev;
651
652 framer->pwr = NULL;
653 }
654
655 ret = device_add(&framer->dev);
656 if (ret)
657 goto put_dev;
658
659 if (pm_runtime_enabled(dev)) {
660 pm_runtime_enable(&framer->dev);
661 pm_runtime_no_callbacks(&framer->dev);
662 }
663
664 return framer;
665
666put_dev:
667 put_device(&framer->dev); /* calls framer_release() which frees resources */
668 return ERR_PTR(ret);
669
670free_framer:
671 kfree(framer);
672 return ERR_PTR(ret);
673}
674EXPORT_SYMBOL_GPL(framer_create);
675
676/**
677 * framer_destroy() - destroy the framer
678 * @framer: the framer to be destroyed
679 *
680 * Called to destroy the framer.
681 */
682void framer_destroy(struct framer *framer)
683{
684 /* polling_work should already be stopped but if framer_exit() was not
685 * called (bug), here it's the last time to do that ...
686 */
687 cancel_delayed_work_sync(&framer->polling_work);
688 cancel_work_sync(&framer->notify_status_work);
689 pm_runtime_disable(&framer->dev);
690 device_unregister(&framer->dev); /* calls framer_release() which frees resources */
691}
692EXPORT_SYMBOL_GPL(framer_destroy);
693
694static void devm_framer_destroy(struct device *dev, void *res)
695{
696 struct framer *framer = *(struct framer **)res;
697
698 framer_destroy(framer);
699}
700
701/**
702 * devm_framer_create() - create a new framer
703 * @dev: device that is creating the new framer
704 * @node: device node of the framer
705 * @ops: function pointers for performing framer operations
706 *
707 * Creates a new framer device adding it to the framer class.
708 * While at that, it also associates the device with the framer using devres.
709 * On driver detach, release function is invoked on the devres data,
710 * then, devres data is freed.
711 */
712struct framer *devm_framer_create(struct device *dev, struct device_node *node,
713 const struct framer_ops *ops)
714{
715 struct framer **ptr, *framer;
716
717 ptr = devres_alloc(devm_framer_destroy, sizeof(*ptr), GFP_KERNEL);
718 if (!ptr)
719 return ERR_PTR(-ENOMEM);
720
721 framer = framer_create(dev, node, ops);
722 if (!IS_ERR(framer)) {
723 *ptr = framer;
724 devres_add(dev, ptr);
725 } else {
726 devres_free(ptr);
727 }
728
729 return framer;
730}
731EXPORT_SYMBOL_GPL(devm_framer_create);
732
733/**
734 * framer_provider_simple_of_xlate() - returns the framer instance from framer provider
735 * @dev: the framer provider device
736 * @args: of_phandle_args (not used here)
737 *
738 * Intended to be used by framer provider for the common case where #framer-cells is
739 * 0. For other cases where #framer-cells is greater than '0', the framer provider
740 * should provide a custom of_xlate function that reads the *args* and returns
741 * the appropriate framer.
742 */
743struct framer *framer_provider_simple_of_xlate(struct device *dev,
744 const struct of_phandle_args *args)
745{
746 struct class_dev_iter iter;
747 struct framer *framer;
748
749 class_dev_iter_init(&iter, &framer_class, NULL, NULL);
750 while ((dev = class_dev_iter_next(&iter))) {
751 framer = dev_to_framer(dev);
752 if (args->np != framer->dev.of_node)
753 continue;
754
755 class_dev_iter_exit(&iter);
756 return framer;
757 }
758
759 class_dev_iter_exit(&iter);
760 return ERR_PTR(-ENODEV);
761}
762EXPORT_SYMBOL_GPL(framer_provider_simple_of_xlate);
763
764/**
765 * __framer_provider_of_register() - create/register framer provider with the framework
766 * @dev: struct device of the framer provider
767 * @owner: the module owner containing of_xlate
768 * @of_xlate: function pointer to obtain framer instance from framer provider
769 *
770 * Creates struct framer_provider from dev and of_xlate function pointer.
771 * This is used in the case of dt boot for finding the framer instance from
772 * framer provider.
773 */
774struct framer_provider *
775__framer_provider_of_register(struct device *dev, struct module *owner,
776 struct framer *(*of_xlate)(struct device *dev,
777 const struct of_phandle_args *args))
778{
779 struct framer_provider *framer_provider;
780
781 framer_provider = kzalloc(sizeof(*framer_provider), GFP_KERNEL);
782 if (!framer_provider)
783 return ERR_PTR(-ENOMEM);
784
785 framer_provider->dev = dev;
786 framer_provider->owner = owner;
787 framer_provider->of_xlate = of_xlate;
788
789 of_node_get(framer_provider->dev->of_node);
790
791 mutex_lock(&framer_provider_mutex);
792 list_add_tail(&framer_provider->list, &framer_provider_list);
793 mutex_unlock(&framer_provider_mutex);
794
795 return framer_provider;
796}
797EXPORT_SYMBOL_GPL(__framer_provider_of_register);
798
799/**
800 * framer_provider_of_unregister() - unregister framer provider from the framework
801 * @framer_provider: framer provider returned by framer_provider_of_register()
802 *
803 * Removes the framer_provider created using framer_provider_of_register().
804 */
805void framer_provider_of_unregister(struct framer_provider *framer_provider)
806{
807 mutex_lock(&framer_provider_mutex);
808 list_del(&framer_provider->list);
809 mutex_unlock(&framer_provider_mutex);
810
811 of_node_put(framer_provider->dev->of_node);
812 kfree(framer_provider);
813}
814EXPORT_SYMBOL_GPL(framer_provider_of_unregister);
815
816static void devm_framer_provider_of_unregister(struct device *dev, void *res)
817{
818 struct framer_provider *framer_provider = *(struct framer_provider **)res;
819
820 framer_provider_of_unregister(framer_provider);
821}
822
823/**
824 * __devm_framer_provider_of_register() - create/register framer provider with
825 * the framework
826 * @dev: struct device of the framer provider
827 * @owner: the module owner containing of_xlate
828 * @of_xlate: function pointer to obtain framer instance from framer provider
829 *
830 * Creates struct framer_provider from dev and of_xlate function pointer.
831 * This is used in the case of dt boot for finding the framer instance from
832 * framer provider. While at that, it also associates the device with the
833 * framer provider using devres. On driver detach, release function is invoked
834 * on the devres data, then, devres data is freed.
835 */
836struct framer_provider *
837__devm_framer_provider_of_register(struct device *dev, struct module *owner,
838 struct framer *(*of_xlate)(struct device *dev,
839 const struct of_phandle_args *args))
840{
841 struct framer_provider **ptr, *framer_provider;
842
843 ptr = devres_alloc(devm_framer_provider_of_unregister, sizeof(*ptr), GFP_KERNEL);
844 if (!ptr)
845 return ERR_PTR(-ENOMEM);
846
847 framer_provider = __framer_provider_of_register(dev, owner, of_xlate);
848 if (!IS_ERR(framer_provider)) {
849 *ptr = framer_provider;
850 devres_add(dev, ptr);
851 } else {
852 devres_free(ptr);
853 }
854
855 return framer_provider;
856}
857EXPORT_SYMBOL_GPL(__devm_framer_provider_of_register);
858
859/**
860 * framer_release() - release the framer
861 * @dev: the dev member within framer
862 *
863 * When the last reference to the device is removed, it is called
864 * from the embedded kobject as release method.
865 */
866static void framer_release(struct device *dev)
867{
868 struct framer *framer;
869
870 framer = dev_to_framer(dev);
871 regulator_put(framer->pwr);
872 ida_free(&framer_ida, framer->id);
873 kfree(framer);
874}
875
876static int __init framer_core_init(void)
877{
878 return class_register(&framer_class);
879}
880device_initcall(framer_core_init);