878 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * dpll_core.c - DPLL subsystem kernel-space interface implementation.4 *5 * Copyright (c) 2023 Meta Platforms, Inc. and affiliates6 * Copyright (c) 2023 Intel Corporation.7 */8 9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt10 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, id, DPLL_REGISTERED))51 return xa_load(&dpll_device_xa, 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 int72dpll_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 refcount_inc(&ref->refcount);88 return 0;89 }90 ref_exists = true;91 break;92 }93 94 if (!ref_exists) {95 ref = kzalloc(sizeof(*ref), GFP_KERNEL);96 if (!ref)97 return -ENOMEM;98 ref->pin = pin;99 INIT_LIST_HEAD(&ref->registration_list);100 ret = xa_insert(xa_pins, pin->pin_idx, ref, GFP_KERNEL);101 if (ret) {102 kfree(ref);103 return ret;104 }105 refcount_set(&ref->refcount, 1);106 }107 108 reg = kzalloc(sizeof(*reg), GFP_KERNEL);109 if (!reg) {110 if (!ref_exists) {111 xa_erase(xa_pins, pin->pin_idx);112 kfree(ref);113 }114 return -ENOMEM;115 }116 reg->ops = ops;117 reg->priv = priv;118 reg->cookie = cookie;119 if (ref_exists)120 refcount_inc(&ref->refcount);121 list_add_tail(®->list, &ref->registration_list);122 123 return 0;124}125 126static int dpll_xa_ref_pin_del(struct xarray *xa_pins, struct dpll_pin *pin,127 const struct dpll_pin_ops *ops, void *priv,128 void *cookie)129{130 struct dpll_pin_registration *reg;131 struct dpll_pin_ref *ref;132 unsigned long i;133 134 xa_for_each(xa_pins, i, ref) {135 if (ref->pin != pin)136 continue;137 reg = dpll_pin_registration_find(ref, ops, priv, cookie);138 if (WARN_ON(!reg))139 return -EINVAL;140 list_del(®->list);141 kfree(reg);142 if (refcount_dec_and_test(&ref->refcount)) {143 xa_erase(xa_pins, i);144 WARN_ON(!list_empty(&ref->registration_list));145 kfree(ref);146 }147 return 0;148 }149 150 return -EINVAL;151}152 153static int154dpll_xa_ref_dpll_add(struct xarray *xa_dplls, struct dpll_device *dpll,155 const struct dpll_pin_ops *ops, void *priv, void *cookie)156{157 struct dpll_pin_registration *reg;158 struct dpll_pin_ref *ref;159 bool ref_exists = false;160 unsigned long i;161 int ret;162 163 xa_for_each(xa_dplls, i, ref) {164 if (ref->dpll != dpll)165 continue;166 reg = dpll_pin_registration_find(ref, ops, priv, cookie);167 if (reg) {168 refcount_inc(&ref->refcount);169 return 0;170 }171 ref_exists = true;172 break;173 }174 175 if (!ref_exists) {176 ref = kzalloc(sizeof(*ref), GFP_KERNEL);177 if (!ref)178 return -ENOMEM;179 ref->dpll = dpll;180 INIT_LIST_HEAD(&ref->registration_list);181 ret = xa_insert(xa_dplls, dpll->id, ref, GFP_KERNEL);182 if (ret) {183 kfree(ref);184 return ret;185 }186 refcount_set(&ref->refcount, 1);187 }188 189 reg = kzalloc(sizeof(*reg), GFP_KERNEL);190 if (!reg) {191 if (!ref_exists) {192 xa_erase(xa_dplls, dpll->id);193 kfree(ref);194 }195 return -ENOMEM;196 }197 reg->ops = ops;198 reg->priv = priv;199 reg->cookie = cookie;200 if (ref_exists)201 refcount_inc(&ref->refcount);202 list_add_tail(®->list, &ref->registration_list);203 204 return 0;205}206 207static void208dpll_xa_ref_dpll_del(struct xarray *xa_dplls, struct dpll_device *dpll,209 const struct dpll_pin_ops *ops, void *priv, void *cookie)210{211 struct dpll_pin_registration *reg;212 struct dpll_pin_ref *ref;213 unsigned long i;214 215 xa_for_each(xa_dplls, i, ref) {216 if (ref->dpll != dpll)217 continue;218 reg = dpll_pin_registration_find(ref, ops, priv, cookie);219 if (WARN_ON(!reg))220 return;221 list_del(®->list);222 kfree(reg);223 if (refcount_dec_and_test(&ref->refcount)) {224 xa_erase(xa_dplls, i);225 WARN_ON(!list_empty(&ref->registration_list));226 kfree(ref);227 }228 return;229 }230}231 232struct dpll_pin_ref *dpll_xa_ref_dpll_first(struct xarray *xa_refs)233{234 struct dpll_pin_ref *ref;235 unsigned long i = 0;236 237 ref = xa_find(xa_refs, &i, ULONG_MAX, XA_PRESENT);238 WARN_ON(!ref);239 return ref;240}241 242static struct dpll_device *243dpll_device_alloc(const u64 clock_id, u32 device_idx, struct module *module)244{245 struct dpll_device *dpll;246 int ret;247 248 dpll = kzalloc(sizeof(*dpll), GFP_KERNEL);249 if (!dpll)250 return ERR_PTR(-ENOMEM);251 refcount_set(&dpll->refcount, 1);252 INIT_LIST_HEAD(&dpll->registration_list);253 dpll->device_idx = device_idx;254 dpll->clock_id = clock_id;255 dpll->module = module;256 ret = xa_alloc_cyclic(&dpll_device_xa, &dpll->id, dpll, xa_limit_32b,257 &dpll_device_xa_id, GFP_KERNEL);258 if (ret < 0) {259 kfree(dpll);260 return ERR_PTR(ret);261 }262 xa_init_flags(&dpll->pin_refs, XA_FLAGS_ALLOC);263 264 return dpll;265}266 267/**268 * dpll_device_get - find existing or create new dpll device269 * @clock_id: clock_id of creator270 * @device_idx: idx given by device driver271 * @module: reference to registering module272 *273 * Get existing object of a dpll device, unique for given arguments.274 * Create new if doesn't exist yet.275 *276 * Context: Acquires a lock (dpll_lock)277 * Return:278 * * valid dpll_device struct pointer if succeeded279 * * ERR_PTR(X) - error280 */281struct dpll_device *282dpll_device_get(u64 clock_id, u32 device_idx, struct module *module)283{284 struct dpll_device *dpll, *ret = NULL;285 unsigned long index;286 287 mutex_lock(&dpll_lock);288 xa_for_each(&dpll_device_xa, index, dpll) {289 if (dpll->clock_id == clock_id &&290 dpll->device_idx == device_idx &&291 dpll->module == module) {292 ret = dpll;293 refcount_inc(&ret->refcount);294 break;295 }296 }297 if (!ret)298 ret = dpll_device_alloc(clock_id, device_idx, module);299 mutex_unlock(&dpll_lock);300 301 return ret;302}303EXPORT_SYMBOL_GPL(dpll_device_get);304 305/**306 * dpll_device_put - decrease the refcount and free memory if possible307 * @dpll: dpll_device struct pointer308 *309 * Context: Acquires a lock (dpll_lock)310 * Drop reference for a dpll device, if all references are gone, delete311 * dpll device object.312 */313void dpll_device_put(struct dpll_device *dpll)314{315 mutex_lock(&dpll_lock);316 if (refcount_dec_and_test(&dpll->refcount)) {317 ASSERT_DPLL_NOT_REGISTERED(dpll);318 WARN_ON_ONCE(!xa_empty(&dpll->pin_refs));319 xa_destroy(&dpll->pin_refs);320 xa_erase(&dpll_device_xa, dpll->id);321 WARN_ON(!list_empty(&dpll->registration_list));322 kfree(dpll);323 }324 mutex_unlock(&dpll_lock);325}326EXPORT_SYMBOL_GPL(dpll_device_put);327 328static struct dpll_device_registration *329dpll_device_registration_find(struct dpll_device *dpll,330 const struct dpll_device_ops *ops, void *priv)331{332 struct dpll_device_registration *reg;333 334 list_for_each_entry(reg, &dpll->registration_list, list) {335 if (reg->ops == ops && reg->priv == priv)336 return reg;337 }338 return NULL;339}340 341/**342 * dpll_device_register - register the dpll device in the subsystem343 * @dpll: pointer to a dpll344 * @type: type of a dpll345 * @ops: ops for a dpll device346 * @priv: pointer to private information of owner347 *348 * Make dpll device available for user space.349 *350 * Context: Acquires a lock (dpll_lock)351 * Return:352 * * 0 on success353 * * negative - error value354 */355int dpll_device_register(struct dpll_device *dpll, enum dpll_type type,356 const struct dpll_device_ops *ops, void *priv)357{358 struct dpll_device_registration *reg;359 bool first_registration = false;360 361 if (WARN_ON(!ops))362 return -EINVAL;363 if (WARN_ON(!ops->mode_get))364 return -EINVAL;365 if (WARN_ON(!ops->lock_status_get))366 return -EINVAL;367 if (WARN_ON(type < DPLL_TYPE_PPS || type > DPLL_TYPE_MAX))368 return -EINVAL;369 370 mutex_lock(&dpll_lock);371 reg = dpll_device_registration_find(dpll, ops, priv);372 if (reg) {373 mutex_unlock(&dpll_lock);374 return -EEXIST;375 }376 377 reg = kzalloc(sizeof(*reg), GFP_KERNEL);378 if (!reg) {379 mutex_unlock(&dpll_lock);380 return -ENOMEM;381 }382 reg->ops = ops;383 reg->priv = priv;384 dpll->type = type;385 first_registration = list_empty(&dpll->registration_list);386 list_add_tail(®->list, &dpll->registration_list);387 if (!first_registration) {388 mutex_unlock(&dpll_lock);389 return 0;390 }391 392 xa_set_mark(&dpll_device_xa, dpll->id, DPLL_REGISTERED);393 dpll_device_create_ntf(dpll);394 mutex_unlock(&dpll_lock);395 396 return 0;397}398EXPORT_SYMBOL_GPL(dpll_device_register);399 400/**401 * dpll_device_unregister - unregister dpll device402 * @dpll: registered dpll pointer403 * @ops: ops for a dpll device404 * @priv: pointer to private information of owner405 *406 * Unregister device, make it unavailable for userspace.407 * Note: It does not free the memory408 * Context: Acquires a lock (dpll_lock)409 */410void dpll_device_unregister(struct dpll_device *dpll,411 const struct dpll_device_ops *ops, void *priv)412{413 struct dpll_device_registration *reg;414 415 mutex_lock(&dpll_lock);416 ASSERT_DPLL_REGISTERED(dpll);417 dpll_device_delete_ntf(dpll);418 reg = dpll_device_registration_find(dpll, ops, priv);419 if (WARN_ON(!reg)) {420 mutex_unlock(&dpll_lock);421 return;422 }423 list_del(®->list);424 kfree(reg);425 426 if (!list_empty(&dpll->registration_list)) {427 mutex_unlock(&dpll_lock);428 return;429 }430 xa_clear_mark(&dpll_device_xa, dpll->id, DPLL_REGISTERED);431 mutex_unlock(&dpll_lock);432}433EXPORT_SYMBOL_GPL(dpll_device_unregister);434 435static void dpll_pin_prop_free(struct dpll_pin_properties *prop)436{437 kfree(prop->package_label);438 kfree(prop->panel_label);439 kfree(prop->board_label);440 kfree(prop->freq_supported);441}442 443static int dpll_pin_prop_dup(const struct dpll_pin_properties *src,444 struct dpll_pin_properties *dst)445{446 memcpy(dst, src, sizeof(*dst));447 if (src->freq_supported && src->freq_supported_num) {448 size_t freq_size = src->freq_supported_num *449 sizeof(*src->freq_supported);450 dst->freq_supported = kmemdup(src->freq_supported,451 freq_size, GFP_KERNEL);452 if (!dst->freq_supported)453 return -ENOMEM;454 }455 if (src->board_label) {456 dst->board_label = kstrdup(src->board_label, GFP_KERNEL);457 if (!dst->board_label)458 goto err_board_label;459 }460 if (src->panel_label) {461 dst->panel_label = kstrdup(src->panel_label, GFP_KERNEL);462 if (!dst->panel_label)463 goto err_panel_label;464 }465 if (src->package_label) {466 dst->package_label = kstrdup(src->package_label, GFP_KERNEL);467 if (!dst->package_label)468 goto err_package_label;469 }470 471 return 0;472 473err_package_label:474 kfree(dst->panel_label);475err_panel_label:476 kfree(dst->board_label);477err_board_label:478 kfree(dst->freq_supported);479 return -ENOMEM;480}481 482static struct dpll_pin *483dpll_pin_alloc(u64 clock_id, u32 pin_idx, struct module *module,484 const struct dpll_pin_properties *prop)485{486 struct dpll_pin *pin;487 int ret;488 489 pin = kzalloc(sizeof(*pin), GFP_KERNEL);490 if (!pin)491 return ERR_PTR(-ENOMEM);492 pin->pin_idx = pin_idx;493 pin->clock_id = clock_id;494 pin->module = module;495 if (WARN_ON(prop->type < DPLL_PIN_TYPE_MUX ||496 prop->type > DPLL_PIN_TYPE_MAX)) {497 ret = -EINVAL;498 goto err_pin_prop;499 }500 ret = dpll_pin_prop_dup(prop, &pin->prop);501 if (ret)502 goto err_pin_prop;503 refcount_set(&pin->refcount, 1);504 xa_init_flags(&pin->dpll_refs, XA_FLAGS_ALLOC);505 xa_init_flags(&pin->parent_refs, XA_FLAGS_ALLOC);506 ret = xa_alloc_cyclic(&dpll_pin_xa, &pin->id, pin, xa_limit_32b,507 &dpll_pin_xa_id, GFP_KERNEL);508 if (ret)509 goto err_xa_alloc;510 return pin;511err_xa_alloc:512 xa_destroy(&pin->dpll_refs);513 xa_destroy(&pin->parent_refs);514 dpll_pin_prop_free(&pin->prop);515err_pin_prop:516 kfree(pin);517 return ERR_PTR(ret);518}519 520static void dpll_netdev_pin_assign(struct net_device *dev, struct dpll_pin *dpll_pin)521{522 rtnl_lock();523 rcu_assign_pointer(dev->dpll_pin, dpll_pin);524 rtnl_unlock();525}526 527void dpll_netdev_pin_set(struct net_device *dev, struct dpll_pin *dpll_pin)528{529 WARN_ON(!dpll_pin);530 dpll_netdev_pin_assign(dev, dpll_pin);531}532EXPORT_SYMBOL(dpll_netdev_pin_set);533 534void dpll_netdev_pin_clear(struct net_device *dev)535{536 dpll_netdev_pin_assign(dev, NULL);537}538EXPORT_SYMBOL(dpll_netdev_pin_clear);539 540/**541 * dpll_pin_get - find existing or create new dpll pin542 * @clock_id: clock_id of creator543 * @pin_idx: idx given by dev driver544 * @module: reference to registering module545 * @prop: dpll pin properties546 *547 * Get existing object of a pin (unique for given arguments) or create new548 * if doesn't exist yet.549 *550 * Context: Acquires a lock (dpll_lock)551 * Return:552 * * valid allocated dpll_pin struct pointer if succeeded553 * * ERR_PTR(X) - error554 */555struct dpll_pin *556dpll_pin_get(u64 clock_id, u32 pin_idx, struct module *module,557 const struct dpll_pin_properties *prop)558{559 struct dpll_pin *pos, *ret = NULL;560 unsigned long i;561 562 mutex_lock(&dpll_lock);563 xa_for_each(&dpll_pin_xa, i, pos) {564 if (pos->clock_id == clock_id &&565 pos->pin_idx == pin_idx &&566 pos->module == module) {567 ret = pos;568 refcount_inc(&ret->refcount);569 break;570 }571 }572 if (!ret)573 ret = dpll_pin_alloc(clock_id, pin_idx, module, prop);574 mutex_unlock(&dpll_lock);575 576 return ret;577}578EXPORT_SYMBOL_GPL(dpll_pin_get);579 580/**581 * dpll_pin_put - decrease the refcount and free memory if possible582 * @pin: pointer to a pin to be put583 *584 * Drop reference for a pin, if all references are gone, delete pin object.585 *586 * Context: Acquires a lock (dpll_lock)587 */588void dpll_pin_put(struct dpll_pin *pin)589{590 mutex_lock(&dpll_lock);591 if (refcount_dec_and_test(&pin->refcount)) {592 xa_erase(&dpll_pin_xa, pin->id);593 xa_destroy(&pin->dpll_refs);594 xa_destroy(&pin->parent_refs);595 dpll_pin_prop_free(&pin->prop);596 kfree_rcu(pin, rcu);597 }598 mutex_unlock(&dpll_lock);599}600EXPORT_SYMBOL_GPL(dpll_pin_put);601 602static int603__dpll_pin_register(struct dpll_device *dpll, struct dpll_pin *pin,604 const struct dpll_pin_ops *ops, void *priv, void *cookie)605{606 int ret;607 608 ret = dpll_xa_ref_pin_add(&dpll->pin_refs, pin, ops, priv, cookie);609 if (ret)610 return ret;611 ret = dpll_xa_ref_dpll_add(&pin->dpll_refs, dpll, ops, priv, cookie);612 if (ret)613 goto ref_pin_del;614 xa_set_mark(&dpll_pin_xa, pin->id, DPLL_REGISTERED);615 dpll_pin_create_ntf(pin);616 617 return ret;618 619ref_pin_del:620 dpll_xa_ref_pin_del(&dpll->pin_refs, pin, ops, priv, cookie);621 return ret;622}623 624/**625 * dpll_pin_register - register the dpll pin in the subsystem626 * @dpll: pointer to a dpll627 * @pin: pointer to a dpll pin628 * @ops: ops for a dpll pin ops629 * @priv: pointer to private information of owner630 *631 * Context: Acquires a lock (dpll_lock)632 * Return:633 * * 0 on success634 * * negative - error value635 */636int637dpll_pin_register(struct dpll_device *dpll, struct dpll_pin *pin,638 const struct dpll_pin_ops *ops, void *priv)639{640 int ret;641 642 if (WARN_ON(!ops) ||643 WARN_ON(!ops->state_on_dpll_get) ||644 WARN_ON(!ops->direction_get))645 return -EINVAL;646 647 mutex_lock(&dpll_lock);648 if (WARN_ON(!(dpll->module == pin->module &&649 dpll->clock_id == pin->clock_id)))650 ret = -EINVAL;651 else652 ret = __dpll_pin_register(dpll, pin, ops, priv, NULL);653 mutex_unlock(&dpll_lock);654 655 return ret;656}657EXPORT_SYMBOL_GPL(dpll_pin_register);658 659static void660__dpll_pin_unregister(struct dpll_device *dpll, struct dpll_pin *pin,661 const struct dpll_pin_ops *ops, void *priv, void *cookie)662{663 ASSERT_DPLL_PIN_REGISTERED(pin);664 dpll_xa_ref_pin_del(&dpll->pin_refs, pin, ops, priv, cookie);665 dpll_xa_ref_dpll_del(&pin->dpll_refs, dpll, ops, priv, cookie);666 if (xa_empty(&pin->dpll_refs))667 xa_clear_mark(&dpll_pin_xa, pin->id, DPLL_REGISTERED);668}669 670/**671 * dpll_pin_unregister - unregister dpll pin from dpll device672 * @dpll: registered dpll pointer673 * @pin: pointer to a pin674 * @ops: ops for a dpll pin675 * @priv: pointer to private information of owner676 *677 * Note: It does not free the memory678 * Context: Acquires a lock (dpll_lock)679 */680void dpll_pin_unregister(struct dpll_device *dpll, struct dpll_pin *pin,681 const struct dpll_pin_ops *ops, void *priv)682{683 if (WARN_ON(xa_empty(&dpll->pin_refs)))684 return;685 if (WARN_ON(!xa_empty(&pin->parent_refs)))686 return;687 688 mutex_lock(&dpll_lock);689 dpll_pin_delete_ntf(pin);690 __dpll_pin_unregister(dpll, pin, ops, priv, NULL);691 mutex_unlock(&dpll_lock);692}693EXPORT_SYMBOL_GPL(dpll_pin_unregister);694 695/**696 * dpll_pin_on_pin_register - register a pin with a parent pin697 * @parent: pointer to a parent pin698 * @pin: pointer to a pin699 * @ops: ops for a dpll pin700 * @priv: pointer to private information of owner701 *702 * Register a pin with a parent pin, create references between them and703 * between newly registered pin and dplls connected with a parent pin.704 *705 * Context: Acquires a lock (dpll_lock)706 * Return:707 * * 0 on success708 * * negative - error value709 */710int dpll_pin_on_pin_register(struct dpll_pin *parent, struct dpll_pin *pin,711 const struct dpll_pin_ops *ops, void *priv)712{713 struct dpll_pin_ref *ref;714 unsigned long i, stop;715 int ret;716 717 if (WARN_ON(parent->prop.type != DPLL_PIN_TYPE_MUX))718 return -EINVAL;719 720 if (WARN_ON(!ops) ||721 WARN_ON(!ops->state_on_pin_get) ||722 WARN_ON(!ops->direction_get))723 return -EINVAL;724 725 mutex_lock(&dpll_lock);726 ret = dpll_xa_ref_pin_add(&pin->parent_refs, parent, ops, priv, pin);727 if (ret)728 goto unlock;729 refcount_inc(&pin->refcount);730 xa_for_each(&parent->dpll_refs, i, ref) {731 ret = __dpll_pin_register(ref->dpll, pin, ops, priv, parent);732 if (ret) {733 stop = i;734 goto dpll_unregister;735 }736 dpll_pin_create_ntf(pin);737 }738 mutex_unlock(&dpll_lock);739 740 return ret;741 742dpll_unregister:743 xa_for_each(&parent->dpll_refs, i, ref)744 if (i < stop) {745 __dpll_pin_unregister(ref->dpll, pin, ops, priv,746 parent);747 dpll_pin_delete_ntf(pin);748 }749 refcount_dec(&pin->refcount);750 dpll_xa_ref_pin_del(&pin->parent_refs, parent, ops, priv, pin);751unlock:752 mutex_unlock(&dpll_lock);753 return ret;754}755EXPORT_SYMBOL_GPL(dpll_pin_on_pin_register);756 757/**758 * dpll_pin_on_pin_unregister - unregister dpll pin from a parent pin759 * @parent: pointer to a parent pin760 * @pin: pointer to a pin761 * @ops: ops for a dpll pin762 * @priv: pointer to private information of owner763 *764 * Context: Acquires a lock (dpll_lock)765 * Note: It does not free the memory766 */767void dpll_pin_on_pin_unregister(struct dpll_pin *parent, struct dpll_pin *pin,768 const struct dpll_pin_ops *ops, void *priv)769{770 struct dpll_pin_ref *ref;771 unsigned long i;772 773 mutex_lock(&dpll_lock);774 dpll_pin_delete_ntf(pin);775 dpll_xa_ref_pin_del(&pin->parent_refs, parent, ops, priv, pin);776 refcount_dec(&pin->refcount);777 xa_for_each(&pin->dpll_refs, i, ref)778 __dpll_pin_unregister(ref->dpll, pin, ops, priv, parent);779 mutex_unlock(&dpll_lock);780}781EXPORT_SYMBOL_GPL(dpll_pin_on_pin_unregister);782 783static struct dpll_device_registration *784dpll_device_registration_first(struct dpll_device *dpll)785{786 struct dpll_device_registration *reg;787 788 reg = list_first_entry_or_null((struct list_head *)&dpll->registration_list,789 struct dpll_device_registration, list);790 WARN_ON(!reg);791 return reg;792}793 794void *dpll_priv(struct dpll_device *dpll)795{796 struct dpll_device_registration *reg;797 798 reg = dpll_device_registration_first(dpll);799 return reg->priv;800}801 802const struct dpll_device_ops *dpll_device_ops(struct dpll_device *dpll)803{804 struct dpll_device_registration *reg;805 806 reg = dpll_device_registration_first(dpll);807 return reg->ops;808}809 810static struct dpll_pin_registration *811dpll_pin_registration_first(struct dpll_pin_ref *ref)812{813 struct dpll_pin_registration *reg;814 815 reg = list_first_entry_or_null(&ref->registration_list,816 struct dpll_pin_registration, list);817 WARN_ON(!reg);818 return reg;819}820 821void *dpll_pin_on_dpll_priv(struct dpll_device *dpll,822 struct dpll_pin *pin)823{824 struct dpll_pin_registration *reg;825 struct dpll_pin_ref *ref;826 827 ref = xa_load(&dpll->pin_refs, pin->pin_idx);828 if (!ref)829 return NULL;830 reg = dpll_pin_registration_first(ref);831 return reg->priv;832}833 834void *dpll_pin_on_pin_priv(struct dpll_pin *parent,835 struct dpll_pin *pin)836{837 struct dpll_pin_registration *reg;838 struct dpll_pin_ref *ref;839 840 ref = xa_load(&pin->parent_refs, parent->pin_idx);841 if (!ref)842 return NULL;843 reg = dpll_pin_registration_first(ref);844 return reg->priv;845}846 847const struct dpll_pin_ops *dpll_pin_ops(struct dpll_pin_ref *ref)848{849 struct dpll_pin_registration *reg;850 851 reg = dpll_pin_registration_first(ref);852 return reg->ops;853}854 855static int __init dpll_init(void)856{857 int ret;858 859 ret = genl_register_family(&dpll_nl_family);860 if (ret)861 goto error;862 863 return 0;864 865error:866 mutex_destroy(&dpll_lock);867 return ret;868}869 870static void __exit dpll_exit(void)871{872 genl_unregister_family(&dpll_nl_family);873 mutex_destroy(&dpll_lock);874}875 876subsys_initcall(dpll_init);877module_exit(dpll_exit);878