1// SPDX-License-Identifier: GPL-2.0
2/*
3 * dpll_core.c - DPLL subsystem kernel-space interface implementation.
4 *
5 * Copyright (c) 2023 Meta Platforms, Inc. and affiliates
6 * Copyright (c) 2023 Intel Corporation.
7 */
8
9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10
11#include <linux/device.h>
12#include <linux/err.h>
13#include <linux/slab.h>
14#include <linux/string.h>
15
16#include "dpll_core.h"
17#include "dpll_netlink.h"
18
19/* Mutex lock to protect DPLL subsystem devices and pins */
20DEFINE_MUTEX(dpll_lock);
21
22DEFINE_XARRAY_FLAGS(dpll_device_xa, XA_FLAGS_ALLOC);
23DEFINE_XARRAY_FLAGS(dpll_pin_xa, XA_FLAGS_ALLOC);
24
25static u32 dpll_device_xa_id;
26static u32 dpll_pin_xa_id;
27
28#define ASSERT_DPLL_REGISTERED(d) \
29 WARN_ON_ONCE(!xa_get_mark(&dpll_device_xa, (d)->id, DPLL_REGISTERED))
30#define ASSERT_DPLL_NOT_REGISTERED(d) \
31 WARN_ON_ONCE(xa_get_mark(&dpll_device_xa, (d)->id, DPLL_REGISTERED))
32#define ASSERT_DPLL_PIN_REGISTERED(p) \
33 WARN_ON_ONCE(!xa_get_mark(&dpll_pin_xa, (p)->id, DPLL_REGISTERED))
34
35struct dpll_device_registration {
36 struct list_head list;
37 const struct dpll_device_ops *ops;
38 void *priv;
39};
40
41struct dpll_pin_registration {
42 struct list_head list;
43 const struct dpll_pin_ops *ops;
44 void *priv;
45 void *cookie;
46};
47
48struct dpll_device *dpll_device_get_by_id(int id)
49{
50 if (xa_get_mark(&dpll_device_xa, index: id, DPLL_REGISTERED))
51 return xa_load(&dpll_device_xa, index: id);
52
53 return NULL;
54}
55
56static struct dpll_pin_registration *
57dpll_pin_registration_find(struct dpll_pin_ref *ref,
58 const struct dpll_pin_ops *ops, void *priv,
59 void *cookie)
60{
61 struct dpll_pin_registration *reg;
62
63 list_for_each_entry(reg, &ref->registration_list, list) {
64 if (reg->ops == ops && reg->priv == priv &&
65 reg->cookie == cookie)
66 return reg;
67 }
68 return NULL;
69}
70
71static int
72dpll_xa_ref_pin_add(struct xarray *xa_pins, struct dpll_pin *pin,
73 const struct dpll_pin_ops *ops, void *priv,
74 void *cookie)
75{
76 struct dpll_pin_registration *reg;
77 struct dpll_pin_ref *ref;
78 bool ref_exists = false;
79 unsigned long i;
80 int ret;
81
82 xa_for_each(xa_pins, i, ref) {
83 if (ref->pin != pin)
84 continue;
85 reg = dpll_pin_registration_find(ref, ops, priv, cookie);
86 if (reg)
87 return -EEXIST;
88 ref_exists = true;
89 break;
90 }
91
92 if (!ref_exists) {
93 ref = kzalloc(sizeof(*ref), GFP_KERNEL);
94 if (!ref)
95 return -ENOMEM;
96 ref->pin = pin;
97 INIT_LIST_HEAD(list: &ref->registration_list);
98 ret = xa_insert(xa: xa_pins, index: pin->pin_idx, entry: ref, GFP_KERNEL);
99 if (ret) {
100 kfree(objp: ref);
101 return ret;
102 }
103 refcount_set(r: &ref->refcount, n: 1);
104 }
105
106 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
107 if (!reg) {
108 if (!ref_exists) {
109 xa_erase(xa_pins, index: pin->pin_idx);
110 kfree(objp: ref);
111 }
112 return -ENOMEM;
113 }
114 reg->ops = ops;
115 reg->priv = priv;
116 reg->cookie = cookie;
117 if (ref_exists)
118 refcount_inc(r: &ref->refcount);
119 list_add_tail(new: &reg->list, head: &ref->registration_list);
120
121 return 0;
122}
123
124static int dpll_xa_ref_pin_del(struct xarray *xa_pins, struct dpll_pin *pin,
125 const struct dpll_pin_ops *ops, void *priv,
126 void *cookie)
127{
128 struct dpll_pin_registration *reg;
129 struct dpll_pin_ref *ref;
130 unsigned long i;
131
132 xa_for_each(xa_pins, i, ref) {
133 if (ref->pin != pin)
134 continue;
135 reg = dpll_pin_registration_find(ref, ops, priv, cookie);
136 if (WARN_ON(!reg))
137 return -EINVAL;
138 list_del(entry: &reg->list);
139 kfree(objp: reg);
140 if (refcount_dec_and_test(r: &ref->refcount)) {
141 xa_erase(xa_pins, index: i);
142 WARN_ON(!list_empty(&ref->registration_list));
143 kfree(objp: ref);
144 }
145 return 0;
146 }
147
148 return -EINVAL;
149}
150
151static int
152dpll_xa_ref_dpll_add(struct xarray *xa_dplls, struct dpll_device *dpll,
153 const struct dpll_pin_ops *ops, void *priv, void *cookie)
154{
155 struct dpll_pin_registration *reg;
156 struct dpll_pin_ref *ref;
157 bool ref_exists = false;
158 unsigned long i;
159 int ret;
160
161 xa_for_each(xa_dplls, i, ref) {
162 if (ref->dpll != dpll)
163 continue;
164 reg = dpll_pin_registration_find(ref, ops, priv, cookie);
165 if (reg)
166 return -EEXIST;
167 ref_exists = true;
168 break;
169 }
170
171 if (!ref_exists) {
172 ref = kzalloc(sizeof(*ref), GFP_KERNEL);
173 if (!ref)
174 return -ENOMEM;
175 ref->dpll = dpll;
176 INIT_LIST_HEAD(list: &ref->registration_list);
177 ret = xa_insert(xa: xa_dplls, index: dpll->id, entry: ref, GFP_KERNEL);
178 if (ret) {
179 kfree(objp: ref);
180 return ret;
181 }
182 refcount_set(r: &ref->refcount, n: 1);
183 }
184
185 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
186 if (!reg) {
187 if (!ref_exists) {
188 xa_erase(xa_dplls, index: dpll->id);
189 kfree(objp: ref);
190 }
191 return -ENOMEM;
192 }
193 reg->ops = ops;
194 reg->priv = priv;
195 reg->cookie = cookie;
196 if (ref_exists)
197 refcount_inc(r: &ref->refcount);
198 list_add_tail(new: &reg->list, head: &ref->registration_list);
199
200 return 0;
201}
202
203static void
204dpll_xa_ref_dpll_del(struct xarray *xa_dplls, struct dpll_device *dpll,
205 const struct dpll_pin_ops *ops, void *priv, void *cookie)
206{
207 struct dpll_pin_registration *reg;
208 struct dpll_pin_ref *ref;
209 unsigned long i;
210
211 xa_for_each(xa_dplls, i, ref) {
212 if (ref->dpll != dpll)
213 continue;
214 reg = dpll_pin_registration_find(ref, ops, priv, cookie);
215 if (WARN_ON(!reg))
216 return;
217 list_del(entry: &reg->list);
218 kfree(objp: reg);
219 if (refcount_dec_and_test(r: &ref->refcount)) {
220 xa_erase(xa_dplls, index: i);
221 WARN_ON(!list_empty(&ref->registration_list));
222 kfree(objp: ref);
223 }
224 return;
225 }
226}
227
228struct dpll_pin_ref *dpll_xa_ref_dpll_first(struct xarray *xa_refs)
229{
230 struct dpll_pin_ref *ref;
231 unsigned long i = 0;
232
233 ref = xa_find(xa: xa_refs, index: &i, ULONG_MAX, XA_PRESENT);
234 WARN_ON(!ref);
235 return ref;
236}
237
238static struct dpll_device *
239dpll_device_alloc(const u64 clock_id, u32 device_idx, struct module *module)
240{
241 struct dpll_device *dpll;
242 int ret;
243
244 dpll = kzalloc(sizeof(*dpll), GFP_KERNEL);
245 if (!dpll)
246 return ERR_PTR(error: -ENOMEM);
247 refcount_set(r: &dpll->refcount, n: 1);
248 INIT_LIST_HEAD(list: &dpll->registration_list);
249 dpll->device_idx = device_idx;
250 dpll->clock_id = clock_id;
251 dpll->module = module;
252 ret = xa_alloc_cyclic(xa: &dpll_device_xa, id: &dpll->id, entry: dpll, xa_limit_32b,
253 next: &dpll_device_xa_id, GFP_KERNEL);
254 if (ret < 0) {
255 kfree(objp: dpll);
256 return ERR_PTR(error: ret);
257 }
258 xa_init_flags(xa: &dpll->pin_refs, XA_FLAGS_ALLOC);
259
260 return dpll;
261}
262
263/**
264 * dpll_device_get - find existing or create new dpll device
265 * @clock_id: clock_id of creator
266 * @device_idx: idx given by device driver
267 * @module: reference to registering module
268 *
269 * Get existing object of a dpll device, unique for given arguments.
270 * Create new if doesn't exist yet.
271 *
272 * Context: Acquires a lock (dpll_lock)
273 * Return:
274 * * valid dpll_device struct pointer if succeeded
275 * * ERR_PTR(X) - error
276 */
277struct dpll_device *
278dpll_device_get(u64 clock_id, u32 device_idx, struct module *module)
279{
280 struct dpll_device *dpll, *ret = NULL;
281 unsigned long index;
282
283 mutex_lock(&dpll_lock);
284 xa_for_each(&dpll_device_xa, index, dpll) {
285 if (dpll->clock_id == clock_id &&
286 dpll->device_idx == device_idx &&
287 dpll->module == module) {
288 ret = dpll;
289 refcount_inc(r: &ret->refcount);
290 break;
291 }
292 }
293 if (!ret)
294 ret = dpll_device_alloc(clock_id, device_idx, module);
295 mutex_unlock(lock: &dpll_lock);
296
297 return ret;
298}
299EXPORT_SYMBOL_GPL(dpll_device_get);
300
301/**
302 * dpll_device_put - decrease the refcount and free memory if possible
303 * @dpll: dpll_device struct pointer
304 *
305 * Context: Acquires a lock (dpll_lock)
306 * Drop reference for a dpll device, if all references are gone, delete
307 * dpll device object.
308 */
309void dpll_device_put(struct dpll_device *dpll)
310{
311 mutex_lock(&dpll_lock);
312 if (refcount_dec_and_test(r: &dpll->refcount)) {
313 ASSERT_DPLL_NOT_REGISTERED(dpll);
314 WARN_ON_ONCE(!xa_empty(&dpll->pin_refs));
315 xa_destroy(&dpll->pin_refs);
316 xa_erase(&dpll_device_xa, index: dpll->id);
317 WARN_ON(!list_empty(&dpll->registration_list));
318 kfree(objp: dpll);
319 }
320 mutex_unlock(lock: &dpll_lock);
321}
322EXPORT_SYMBOL_GPL(dpll_device_put);
323
324static struct dpll_device_registration *
325dpll_device_registration_find(struct dpll_device *dpll,
326 const struct dpll_device_ops *ops, void *priv)
327{
328 struct dpll_device_registration *reg;
329
330 list_for_each_entry(reg, &dpll->registration_list, list) {
331 if (reg->ops == ops && reg->priv == priv)
332 return reg;
333 }
334 return NULL;
335}
336
337/**
338 * dpll_device_register - register the dpll device in the subsystem
339 * @dpll: pointer to a dpll
340 * @type: type of a dpll
341 * @ops: ops for a dpll device
342 * @priv: pointer to private information of owner
343 *
344 * Make dpll device available for user space.
345 *
346 * Context: Acquires a lock (dpll_lock)
347 * Return:
348 * * 0 on success
349 * * negative - error value
350 */
351int dpll_device_register(struct dpll_device *dpll, enum dpll_type type,
352 const struct dpll_device_ops *ops, void *priv)
353{
354 struct dpll_device_registration *reg;
355 bool first_registration = false;
356
357 if (WARN_ON(!ops))
358 return -EINVAL;
359 if (WARN_ON(!ops->mode_get))
360 return -EINVAL;
361 if (WARN_ON(!ops->lock_status_get))
362 return -EINVAL;
363 if (WARN_ON(type < DPLL_TYPE_PPS || type > DPLL_TYPE_MAX))
364 return -EINVAL;
365
366 mutex_lock(&dpll_lock);
367 reg = dpll_device_registration_find(dpll, ops, priv);
368 if (reg) {
369 mutex_unlock(lock: &dpll_lock);
370 return -EEXIST;
371 }
372
373 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
374 if (!reg) {
375 mutex_unlock(lock: &dpll_lock);
376 return -ENOMEM;
377 }
378 reg->ops = ops;
379 reg->priv = priv;
380 dpll->type = type;
381 first_registration = list_empty(head: &dpll->registration_list);
382 list_add_tail(new: &reg->list, head: &dpll->registration_list);
383 if (!first_registration) {
384 mutex_unlock(lock: &dpll_lock);
385 return 0;
386 }
387
388 xa_set_mark(&dpll_device_xa, index: dpll->id, DPLL_REGISTERED);
389 dpll_device_create_ntf(dpll);
390 mutex_unlock(lock: &dpll_lock);
391
392 return 0;
393}
394EXPORT_SYMBOL_GPL(dpll_device_register);
395
396/**
397 * dpll_device_unregister - unregister dpll device
398 * @dpll: registered dpll pointer
399 * @ops: ops for a dpll device
400 * @priv: pointer to private information of owner
401 *
402 * Unregister device, make it unavailable for userspace.
403 * Note: It does not free the memory
404 * Context: Acquires a lock (dpll_lock)
405 */
406void dpll_device_unregister(struct dpll_device *dpll,
407 const struct dpll_device_ops *ops, void *priv)
408{
409 struct dpll_device_registration *reg;
410
411 mutex_lock(&dpll_lock);
412 ASSERT_DPLL_REGISTERED(dpll);
413 dpll_device_delete_ntf(dpll);
414 reg = dpll_device_registration_find(dpll, ops, priv);
415 if (WARN_ON(!reg)) {
416 mutex_unlock(lock: &dpll_lock);
417 return;
418 }
419 list_del(entry: &reg->list);
420 kfree(objp: reg);
421
422 if (!list_empty(head: &dpll->registration_list)) {
423 mutex_unlock(lock: &dpll_lock);
424 return;
425 }
426 xa_clear_mark(&dpll_device_xa, index: dpll->id, DPLL_REGISTERED);
427 mutex_unlock(lock: &dpll_lock);
428}
429EXPORT_SYMBOL_GPL(dpll_device_unregister);
430
431static void dpll_pin_prop_free(struct dpll_pin_properties *prop)
432{
433 kfree(objp: prop->package_label);
434 kfree(objp: prop->panel_label);
435 kfree(objp: prop->board_label);
436 kfree(objp: prop->freq_supported);
437}
438
439static int dpll_pin_prop_dup(const struct dpll_pin_properties *src,
440 struct dpll_pin_properties *dst)
441{
442 if (WARN_ON(src->freq_supported && !src->freq_supported_num))
443 return -EINVAL;
444
445 memcpy(dst, src, sizeof(*dst));
446 if (src->freq_supported) {
447 size_t freq_size = src->freq_supported_num *
448 sizeof(*src->freq_supported);
449 dst->freq_supported = kmemdup(src->freq_supported,
450 freq_size, GFP_KERNEL);
451 if (!dst->freq_supported)
452 return -ENOMEM;
453 }
454 if (src->board_label) {
455 dst->board_label = kstrdup(s: src->board_label, GFP_KERNEL);
456 if (!dst->board_label)
457 goto err_board_label;
458 }
459 if (src->panel_label) {
460 dst->panel_label = kstrdup(s: src->panel_label, GFP_KERNEL);
461 if (!dst->panel_label)
462 goto err_panel_label;
463 }
464 if (src->package_label) {
465 dst->package_label = kstrdup(s: src->package_label, GFP_KERNEL);
466 if (!dst->package_label)
467 goto err_package_label;
468 }
469
470 return 0;
471
472err_package_label:
473 kfree(objp: dst->panel_label);
474err_panel_label:
475 kfree(objp: dst->board_label);
476err_board_label:
477 kfree(objp: dst->freq_supported);
478 return -ENOMEM;
479}
480
481static struct dpll_pin *
482dpll_pin_alloc(u64 clock_id, u32 pin_idx, struct module *module,
483 const struct dpll_pin_properties *prop)
484{
485 struct dpll_pin *pin;
486 int ret;
487
488 pin = kzalloc(sizeof(*pin), GFP_KERNEL);
489 if (!pin)
490 return ERR_PTR(error: -ENOMEM);
491 pin->pin_idx = pin_idx;
492 pin->clock_id = clock_id;
493 pin->module = module;
494 if (WARN_ON(prop->type < DPLL_PIN_TYPE_MUX ||
495 prop->type > DPLL_PIN_TYPE_MAX)) {
496 ret = -EINVAL;
497 goto err_pin_prop;
498 }
499 ret = dpll_pin_prop_dup(src: prop, dst: &pin->prop);
500 if (ret)
501 goto err_pin_prop;
502 refcount_set(r: &pin->refcount, n: 1);
503 xa_init_flags(xa: &pin->dpll_refs, XA_FLAGS_ALLOC);
504 xa_init_flags(xa: &pin->parent_refs, XA_FLAGS_ALLOC);
505 xa_init_flags(xa: &pin->ref_sync_pins, XA_FLAGS_ALLOC);
506 ret = xa_alloc_cyclic(xa: &dpll_pin_xa, id: &pin->id, entry: pin, xa_limit_32b,
507 next: &dpll_pin_xa_id, GFP_KERNEL);
508 if (ret < 0)
509 goto err_xa_alloc;
510 return pin;
511err_xa_alloc:
512 xa_destroy(&pin->dpll_refs);
513 xa_destroy(&pin->parent_refs);
514 xa_destroy(&pin->ref_sync_pins);
515 dpll_pin_prop_free(prop: &pin->prop);
516err_pin_prop:
517 kfree(objp: pin);
518 return ERR_PTR(error: ret);
519}
520
521static void dpll_netdev_pin_assign(struct net_device *dev, struct dpll_pin *dpll_pin)
522{
523 rtnl_lock();
524 rcu_assign_pointer(dev->dpll_pin, dpll_pin);
525 rtnl_unlock();
526}
527
528void dpll_netdev_pin_set(struct net_device *dev, struct dpll_pin *dpll_pin)
529{
530 WARN_ON(!dpll_pin);
531 dpll_netdev_pin_assign(dev, dpll_pin);
532}
533EXPORT_SYMBOL(dpll_netdev_pin_set);
534
535void dpll_netdev_pin_clear(struct net_device *dev)
536{
537 dpll_netdev_pin_assign(dev, NULL);
538}
539EXPORT_SYMBOL(dpll_netdev_pin_clear);
540
541/**
542 * dpll_pin_get - find existing or create new dpll pin
543 * @clock_id: clock_id of creator
544 * @pin_idx: idx given by dev driver
545 * @module: reference to registering module
546 * @prop: dpll pin properties
547 *
548 * Get existing object of a pin (unique for given arguments) or create new
549 * if doesn't exist yet.
550 *
551 * Context: Acquires a lock (dpll_lock)
552 * Return:
553 * * valid allocated dpll_pin struct pointer if succeeded
554 * * ERR_PTR(X) - error
555 */
556struct dpll_pin *
557dpll_pin_get(u64 clock_id, u32 pin_idx, struct module *module,
558 const struct dpll_pin_properties *prop)
559{
560 struct dpll_pin *pos, *ret = NULL;
561 unsigned long i;
562
563 mutex_lock(&dpll_lock);
564 xa_for_each(&dpll_pin_xa, i, pos) {
565 if (pos->clock_id == clock_id &&
566 pos->pin_idx == pin_idx &&
567 pos->module == module) {
568 ret = pos;
569 refcount_inc(r: &ret->refcount);
570 break;
571 }
572 }
573 if (!ret)
574 ret = dpll_pin_alloc(clock_id, pin_idx, module, prop);
575 mutex_unlock(lock: &dpll_lock);
576
577 return ret;
578}
579EXPORT_SYMBOL_GPL(dpll_pin_get);
580
581/**
582 * dpll_pin_put - decrease the refcount and free memory if possible
583 * @pin: pointer to a pin to be put
584 *
585 * Drop reference for a pin, if all references are gone, delete pin object.
586 *
587 * Context: Acquires a lock (dpll_lock)
588 */
589void dpll_pin_put(struct dpll_pin *pin)
590{
591 mutex_lock(&dpll_lock);
592 if (refcount_dec_and_test(r: &pin->refcount)) {
593 xa_erase(&dpll_pin_xa, index: pin->id);
594 xa_destroy(&pin->dpll_refs);
595 xa_destroy(&pin->parent_refs);
596 xa_destroy(&pin->ref_sync_pins);
597 dpll_pin_prop_free(prop: &pin->prop);
598 kfree_rcu(pin, rcu);
599 }
600 mutex_unlock(lock: &dpll_lock);
601}
602EXPORT_SYMBOL_GPL(dpll_pin_put);
603
604static int
605__dpll_pin_register(struct dpll_device *dpll, struct dpll_pin *pin,
606 const struct dpll_pin_ops *ops, void *priv, void *cookie)
607{
608 int ret;
609
610 ret = dpll_xa_ref_pin_add(xa_pins: &dpll->pin_refs, pin, ops, priv, cookie);
611 if (ret)
612 return ret;
613 ret = dpll_xa_ref_dpll_add(xa_dplls: &pin->dpll_refs, dpll, ops, priv, cookie);
614 if (ret)
615 goto ref_pin_del;
616 xa_set_mark(&dpll_pin_xa, index: pin->id, DPLL_REGISTERED);
617 dpll_pin_create_ntf(pin);
618
619 return ret;
620
621ref_pin_del:
622 dpll_xa_ref_pin_del(xa_pins: &dpll->pin_refs, pin, ops, priv, cookie);
623 return ret;
624}
625
626/**
627 * dpll_pin_register - register the dpll pin in the subsystem
628 * @dpll: pointer to a dpll
629 * @pin: pointer to a dpll pin
630 * @ops: ops for a dpll pin ops
631 * @priv: pointer to private information of owner
632 *
633 * Context: Acquires a lock (dpll_lock)
634 * Return:
635 * * 0 on success
636 * * negative - error value
637 */
638int
639dpll_pin_register(struct dpll_device *dpll, struct dpll_pin *pin,
640 const struct dpll_pin_ops *ops, void *priv)
641{
642 int ret;
643
644 if (WARN_ON(!ops) ||
645 WARN_ON(!ops->state_on_dpll_get) ||
646 WARN_ON(!ops->direction_get))
647 return -EINVAL;
648
649 mutex_lock(&dpll_lock);
650 if (WARN_ON(!(dpll->module == pin->module &&
651 dpll->clock_id == pin->clock_id)))
652 ret = -EINVAL;
653 else
654 ret = __dpll_pin_register(dpll, pin, ops, priv, NULL);
655 mutex_unlock(lock: &dpll_lock);
656
657 return ret;
658}
659EXPORT_SYMBOL_GPL(dpll_pin_register);
660
661static void dpll_pin_ref_sync_pair_del(u32 ref_sync_pin_id)
662{
663 struct dpll_pin *pin, *ref_sync_pin;
664 unsigned long i;
665
666 xa_for_each(&dpll_pin_xa, i, pin) {
667 ref_sync_pin = xa_load(&pin->ref_sync_pins, index: ref_sync_pin_id);
668 if (ref_sync_pin) {
669 xa_erase(&pin->ref_sync_pins, index: ref_sync_pin_id);
670 __dpll_pin_change_ntf(pin);
671 }
672 }
673}
674
675static void
676__dpll_pin_unregister(struct dpll_device *dpll, struct dpll_pin *pin,
677 const struct dpll_pin_ops *ops, void *priv, void *cookie)
678{
679 ASSERT_DPLL_PIN_REGISTERED(pin);
680 dpll_pin_ref_sync_pair_del(ref_sync_pin_id: pin->id);
681 dpll_xa_ref_pin_del(xa_pins: &dpll->pin_refs, pin, ops, priv, cookie);
682 dpll_xa_ref_dpll_del(xa_dplls: &pin->dpll_refs, dpll, ops, priv, cookie);
683 if (xa_empty(xa: &pin->dpll_refs))
684 xa_clear_mark(&dpll_pin_xa, index: pin->id, DPLL_REGISTERED);
685}
686
687/**
688 * dpll_pin_unregister - unregister dpll pin from dpll device
689 * @dpll: registered dpll pointer
690 * @pin: pointer to a pin
691 * @ops: ops for a dpll pin
692 * @priv: pointer to private information of owner
693 *
694 * Note: It does not free the memory
695 * Context: Acquires a lock (dpll_lock)
696 */
697void dpll_pin_unregister(struct dpll_device *dpll, struct dpll_pin *pin,
698 const struct dpll_pin_ops *ops, void *priv)
699{
700 if (WARN_ON(xa_empty(&dpll->pin_refs)))
701 return;
702 if (WARN_ON(!xa_empty(&pin->parent_refs)))
703 return;
704
705 mutex_lock(&dpll_lock);
706 dpll_pin_delete_ntf(pin);
707 __dpll_pin_unregister(dpll, pin, ops, priv, NULL);
708 mutex_unlock(lock: &dpll_lock);
709}
710EXPORT_SYMBOL_GPL(dpll_pin_unregister);
711
712/**
713 * dpll_pin_on_pin_register - register a pin with a parent pin
714 * @parent: pointer to a parent pin
715 * @pin: pointer to a pin
716 * @ops: ops for a dpll pin
717 * @priv: pointer to private information of owner
718 *
719 * Register a pin with a parent pin, create references between them and
720 * between newly registered pin and dplls connected with a parent pin.
721 *
722 * Context: Acquires a lock (dpll_lock)
723 * Return:
724 * * 0 on success
725 * * negative - error value
726 */
727int dpll_pin_on_pin_register(struct dpll_pin *parent, struct dpll_pin *pin,
728 const struct dpll_pin_ops *ops, void *priv)
729{
730 struct dpll_pin_ref *ref;
731 unsigned long i, stop;
732 int ret;
733
734 if (WARN_ON(parent->prop.type != DPLL_PIN_TYPE_MUX))
735 return -EINVAL;
736
737 if (WARN_ON(!ops) ||
738 WARN_ON(!ops->state_on_pin_get) ||
739 WARN_ON(!ops->direction_get))
740 return -EINVAL;
741
742 mutex_lock(&dpll_lock);
743 ret = dpll_xa_ref_pin_add(xa_pins: &pin->parent_refs, pin: parent, ops, priv, cookie: pin);
744 if (ret)
745 goto unlock;
746 refcount_inc(r: &pin->refcount);
747 xa_for_each(&parent->dpll_refs, i, ref) {
748 ret = __dpll_pin_register(dpll: ref->dpll, pin, ops, priv, cookie: parent);
749 if (ret) {
750 stop = i;
751 goto dpll_unregister;
752 }
753 dpll_pin_create_ntf(pin);
754 }
755 mutex_unlock(lock: &dpll_lock);
756
757 return ret;
758
759dpll_unregister:
760 xa_for_each(&parent->dpll_refs, i, ref)
761 if (i < stop) {
762 __dpll_pin_unregister(dpll: ref->dpll, pin, ops, priv,
763 cookie: parent);
764 dpll_pin_delete_ntf(pin);
765 }
766 refcount_dec(r: &pin->refcount);
767 dpll_xa_ref_pin_del(xa_pins: &pin->parent_refs, pin: parent, ops, priv, cookie: pin);
768unlock:
769 mutex_unlock(lock: &dpll_lock);
770 return ret;
771}
772EXPORT_SYMBOL_GPL(dpll_pin_on_pin_register);
773
774/**
775 * dpll_pin_on_pin_unregister - unregister dpll pin from a parent pin
776 * @parent: pointer to a parent pin
777 * @pin: pointer to a pin
778 * @ops: ops for a dpll pin
779 * @priv: pointer to private information of owner
780 *
781 * Context: Acquires a lock (dpll_lock)
782 * Note: It does not free the memory
783 */
784void dpll_pin_on_pin_unregister(struct dpll_pin *parent, struct dpll_pin *pin,
785 const struct dpll_pin_ops *ops, void *priv)
786{
787 struct dpll_pin_ref *ref;
788 unsigned long i;
789
790 mutex_lock(&dpll_lock);
791 dpll_pin_delete_ntf(pin);
792 dpll_xa_ref_pin_del(xa_pins: &pin->parent_refs, pin: parent, ops, priv, cookie: pin);
793 refcount_dec(r: &pin->refcount);
794 xa_for_each(&pin->dpll_refs, i, ref)
795 __dpll_pin_unregister(dpll: ref->dpll, pin, ops, priv, cookie: parent);
796 mutex_unlock(lock: &dpll_lock);
797}
798EXPORT_SYMBOL_GPL(dpll_pin_on_pin_unregister);
799
800/**
801 * dpll_pin_ref_sync_pair_add - create a reference sync signal pin pair
802 * @pin: pin which produces the base frequency
803 * @ref_sync_pin: pin which produces the sync signal
804 *
805 * Once pins are paired, the user-space configuration of reference sync pair
806 * is possible.
807 * Context: Acquires a lock (dpll_lock)
808 * Return:
809 * * 0 on success
810 * * negative - error value
811 */
812int dpll_pin_ref_sync_pair_add(struct dpll_pin *pin,
813 struct dpll_pin *ref_sync_pin)
814{
815 int ret;
816
817 mutex_lock(&dpll_lock);
818 ret = xa_insert(xa: &pin->ref_sync_pins, index: ref_sync_pin->id,
819 entry: ref_sync_pin, GFP_KERNEL);
820 __dpll_pin_change_ntf(pin);
821 mutex_unlock(lock: &dpll_lock);
822
823 return ret;
824}
825EXPORT_SYMBOL_GPL(dpll_pin_ref_sync_pair_add);
826
827static struct dpll_device_registration *
828dpll_device_registration_first(struct dpll_device *dpll)
829{
830 struct dpll_device_registration *reg;
831
832 reg = list_first_entry_or_null((struct list_head *)&dpll->registration_list,
833 struct dpll_device_registration, list);
834 WARN_ON(!reg);
835 return reg;
836}
837
838void *dpll_priv(struct dpll_device *dpll)
839{
840 struct dpll_device_registration *reg;
841
842 reg = dpll_device_registration_first(dpll);
843 return reg->priv;
844}
845
846const struct dpll_device_ops *dpll_device_ops(struct dpll_device *dpll)
847{
848 struct dpll_device_registration *reg;
849
850 reg = dpll_device_registration_first(dpll);
851 return reg->ops;
852}
853
854static struct dpll_pin_registration *
855dpll_pin_registration_first(struct dpll_pin_ref *ref)
856{
857 struct dpll_pin_registration *reg;
858
859 reg = list_first_entry_or_null(&ref->registration_list,
860 struct dpll_pin_registration, list);
861 WARN_ON(!reg);
862 return reg;
863}
864
865void *dpll_pin_on_dpll_priv(struct dpll_device *dpll,
866 struct dpll_pin *pin)
867{
868 struct dpll_pin_registration *reg;
869 struct dpll_pin_ref *ref;
870
871 ref = xa_load(&dpll->pin_refs, index: pin->pin_idx);
872 if (!ref)
873 return NULL;
874 reg = dpll_pin_registration_first(ref);
875 return reg->priv;
876}
877
878void *dpll_pin_on_pin_priv(struct dpll_pin *parent,
879 struct dpll_pin *pin)
880{
881 struct dpll_pin_registration *reg;
882 struct dpll_pin_ref *ref;
883
884 ref = xa_load(&pin->parent_refs, index: parent->pin_idx);
885 if (!ref)
886 return NULL;
887 reg = dpll_pin_registration_first(ref);
888 return reg->priv;
889}
890
891const struct dpll_pin_ops *dpll_pin_ops(struct dpll_pin_ref *ref)
892{
893 struct dpll_pin_registration *reg;
894
895 reg = dpll_pin_registration_first(ref);
896 return reg->ops;
897}
898
899static int __init dpll_init(void)
900{
901 int ret;
902
903 ret = genl_register_family(family: &dpll_nl_family);
904 if (ret)
905 goto error;
906
907 return 0;
908
909error:
910 mutex_destroy(lock: &dpll_lock);
911 return ret;
912}
913
914static void __exit dpll_exit(void)
915{
916 genl_unregister_family(family: &dpll_nl_family);
917 mutex_destroy(lock: &dpll_lock);
918}
919
920subsys_initcall(dpll_init);
921module_exit(dpll_exit);
922

source code of linux/drivers/dpll/dpll_core.c