drivers/extcon/devres.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * drivers/extcon/devres.c - EXTCON device's resource management
   4  *
   5  * Copyright (C) 2016 Samsung Electronics
   6  * Author: Chanwoo Choi <cw00.choi@samsung.com>
   7  */
   8
   9 #include "extcon.h"
  10
  11 static int devm_extcon_dev_match(struct device *dev, void *res, void *data)
  12 {
  13         struct extcon_dev **r = res;
  14
  15         if (WARN_ON(!r || !*r))
  16                 return 0;
  17
  18         return *r == data;
  19 }
  20
  21 static void devm_extcon_dev_release(struct device *dev, void *res)
  22 {
  23         extcon_dev_free(*(struct extcon_dev **)res);
  24 }
  25
  26
  27 static void devm_extcon_dev_unreg(struct device *dev, void *res)
  28 {
  29         extcon_dev_unregister(*(struct extcon_dev **)res);
  30 }
  31
  32 struct extcon_dev_notifier_devres {
  33         struct extcon_dev *edev;
  34         unsigned int id;
  35         struct notifier_block *nb;
  36 };
  37
  38 static void devm_extcon_dev_notifier_unreg(struct device *dev, void *res)
  39 {
  40         struct extcon_dev_notifier_devres *this = res;
  41
  42         extcon_unregister_notifier(this->edev, this->id, this->nb);
  43 }
  44
  45 static void devm_extcon_dev_notifier_all_unreg(struct device *dev, void *res)
  46 {
  47         struct extcon_dev_notifier_devres *this = res;
  48
  49         extcon_unregister_notifier_all(this->edev, this->nb);
  50 }
  51
  52 /**
  53  * devm_extcon_dev_allocate - Allocate managed extcon device
  54  * @dev:                the device owning the extcon device being created
  55  * @supported_cable:    the array of the supported external connectors
  56  *                      ending with EXTCON_NONE.
  57  *
  58  * This function manages automatically the memory of extcon device using device
  59  * resource management and simplify the control of freeing the memory of extcon
  60  * device.
  61  *
  62  * Returns the pointer memory of allocated extcon_dev if success
  63  * or ERR_PTR(err) if fail
  64  */
  65 struct extcon_dev *devm_extcon_dev_allocate(struct device *dev,
  66                                         const unsigned int *supported_cable)
  67 {
  68         struct extcon_dev **ptr, *edev;
  69
  70         ptr = devres_alloc(devm_extcon_dev_release, sizeof(*ptr), GFP_KERNEL);
  71         if (!ptr)
  72                 return ERR_PTR(-ENOMEM);
  73
  74         edev = extcon_dev_allocate(supported_cable);
  75         if (IS_ERR(edev)) {
  76                 devres_free(ptr);
  77                 return edev;
  78         }
  79
  80         edev->dev.parent = dev;
  81
  82         *ptr = edev;
  83         devres_add(dev, ptr);
  84
  85         return edev;
  86 }
  87 EXPORT_SYMBOL_GPL(devm_extcon_dev_allocate);
  88
  89 /**
  90  * devm_extcon_dev_free() - Resource-managed extcon_dev_unregister()
  91  * @dev:        the device owning the extcon device being created
  92  * @edev:       the extcon device to be freed
  93  *
  94  * Free the memory that is allocated with devm_extcon_dev_allocate()
  95  * function.
  96  */
  97 void devm_extcon_dev_free(struct device *dev, struct extcon_dev *edev)
  98 {
  99         WARN_ON(devres_release(dev, devm_extcon_dev_release,
 100                                devm_extcon_dev_match, edev));
 101 }
 102 EXPORT_SYMBOL_GPL(devm_extcon_dev_free);
 103
 104 /**
 105  * devm_extcon_dev_register() - Resource-managed extcon_dev_register()
 106  * @dev:        the device owning the extcon device being created
 107  * @edev:       the extcon device to be registered
 108  *
 109  * this function, that extcon device is automatically unregistered on driver
 110  * detach. Internally this function calls extcon_dev_register() function.
 111  * To get more information, refer that function.
 112  *
 113  * If extcon device is registered with this function and the device needs to be
 114  * unregistered separately, devm_extcon_dev_unregister() should be used.
 115  *
 116  * Returns 0 if success or negaive error number if failure.
 117  */
 118 int devm_extcon_dev_register(struct device *dev, struct extcon_dev *edev)
 119 {
 120         struct extcon_dev **ptr;
 121         int ret;
 122
 123         ptr = devres_alloc(devm_extcon_dev_unreg, sizeof(*ptr), GFP_KERNEL);
 124         if (!ptr)
 125                 return -ENOMEM;
 126
 127         ret = extcon_dev_register(edev);
 128         if (ret) {
 129                 devres_free(ptr);
 130                 return ret;
 131         }
 132
 133         *ptr = edev;
 134         devres_add(dev, ptr);
 135
 136         return 0;
 137 }
 138 EXPORT_SYMBOL_GPL(devm_extcon_dev_register);
 139
 140 /**
 141  * devm_extcon_dev_unregister() - Resource-managed extcon_dev_unregister()
 142  * @dev:        the device owning the extcon device being created
 143  * @edev:       the extcon device to unregistered
 144  *
 145  * Unregister extcon device that is registered with devm_extcon_dev_register()
 146  * function.
 147  */
 148 void devm_extcon_dev_unregister(struct device *dev, struct extcon_dev *edev)
 149 {
 150         WARN_ON(devres_release(dev, devm_extcon_dev_unreg,
 151                                devm_extcon_dev_match, edev));
 152 }
 153 EXPORT_SYMBOL_GPL(devm_extcon_dev_unregister);
 154
 155 /**
 156  * devm_extcon_register_notifier() - Resource-managed extcon_register_notifier()
 157  * @dev:        the device owning the extcon device being created
 158  * @edev:       the extcon device
 159  * @id:         the unique id among the extcon enumeration
 160  * @nb:         a notifier block to be registered
 161  *
 162  * This function manages automatically the notifier of extcon device using
 163  * device resource management and simplify the control of unregistering
 164  * the notifier of extcon device.
 165  *
 166  * Note that the second parameter given to the callback of nb (val) is
 167  * "old_state", not the current state. The current state can be retrieved
 168  * by looking at the third pameter (edev pointer)'s state value.
 169  *
 170  * Returns 0 if success or negaive error number if failure.
 171  */
 172 int devm_extcon_register_notifier(struct device *dev, struct extcon_dev *edev,
 173                                 unsigned int id, struct notifier_block *nb)
 174 {
 175         struct extcon_dev_notifier_devres *ptr;
 176         int ret;
 177
 178         ptr = devres_alloc(devm_extcon_dev_notifier_unreg, sizeof(*ptr),
 179                                 GFP_KERNEL);
 180         if (!ptr)
 181                 return -ENOMEM;
 182
 183         ret = extcon_register_notifier(edev, id, nb);
 184         if (ret) {
 185                 devres_free(ptr);
 186                 return ret;
 187         }
 188
 189         ptr->edev = edev;
 190         ptr->id = id;
 191         ptr->nb = nb;
 192         devres_add(dev, ptr);
 193
 194         return 0;
 195 }
 196 EXPORT_SYMBOL(devm_extcon_register_notifier);
 197
 198 /**
 199  * devm_extcon_unregister_notifier()
 200  *                      - Resource-managed extcon_unregister_notifier()
 201  * @dev:        the device owning the extcon device being created
 202  * @edev:       the extcon device
 203  * @id:         the unique id among the extcon enumeration
 204  * @nb:         a notifier block to be registered
 205  */
 206 void devm_extcon_unregister_notifier(struct device *dev,
 207                                 struct extcon_dev *edev, unsigned int id,
 208                                 struct notifier_block *nb)
 209 {
 210         WARN_ON(devres_release(dev, devm_extcon_dev_notifier_unreg,
 211                                devm_extcon_dev_match, edev));
 212 }
 213 EXPORT_SYMBOL(devm_extcon_unregister_notifier);
 214
 215 /**
 216  * devm_extcon_register_notifier_all()
 217  *              - Resource-managed extcon_register_notifier_all()
 218  * @dev:        the device owning the extcon device being created
 219  * @edev:       the extcon device
 220  * @nb:         a notifier block to be registered
 221  *
 222  * This function manages automatically the notifier of extcon device using
 223  * device resource management and simplify the control of unregistering
 224  * the notifier of extcon device. To get more information, refer that function.
 225  *
 226  * Returns 0 if success or negaive error number if failure.
 227  */
 228 int devm_extcon_register_notifier_all(struct device *dev, struct extcon_dev *edev,
 229                                 struct notifier_block *nb)
 230 {
 231         struct extcon_dev_notifier_devres *ptr;
 232         int ret;
 233
 234         ptr = devres_alloc(devm_extcon_dev_notifier_all_unreg, sizeof(*ptr),
 235                                 GFP_KERNEL);
 236         if (!ptr)
 237                 return -ENOMEM;
 238
 239         ret = extcon_register_notifier_all(edev, nb);
 240         if (ret) {
 241                 devres_free(ptr);
 242                 return ret;
 243         }
 244
 245         ptr->edev = edev;
 246         ptr->nb = nb;
 247         devres_add(dev, ptr);
 248
 249         return 0;
 250 }
 251 EXPORT_SYMBOL(devm_extcon_register_notifier_all);
 252
 253 /**
 254  * devm_extcon_unregister_notifier_all()
 255  *              - Resource-managed extcon_unregister_notifier_all()
 256  * @dev:        the device owning the extcon device being created
 257  * @edev:       the extcon device
 258  * @nb:         a notifier block to be registered
 259  */
 260 void devm_extcon_unregister_notifier_all(struct device *dev,
 261                                 struct extcon_dev *edev,
 262                                 struct notifier_block *nb)
 263 {
 264         WARN_ON(devres_release(dev, devm_extcon_dev_notifier_all_unreg,
 265                                devm_extcon_dev_match, edev));
 266 }
 267 EXPORT_SYMBOL(devm_extcon_unregister_notifier_all);