kernel/drivers/media/v4l2-core/v4l2-async.c

   1 /*
   2  * V4L2 asynchronous subdevice registration API
   3  *
   4  * Copyright (C) 2012-2013, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/device.h>
  12 #include <linux/err.h>
  13 #include <linux/i2c.h>
  14 #include <linux/list.h>
  15 #include <linux/module.h>
  16 #include <linux/mutex.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/slab.h>
  19 #include <linux/types.h>
  20
  21 #include <media/v4l2-async.h>
  22 #include <media/v4l2-device.h>
  23 #include <media/v4l2-subdev.h>
  24
  25 static bool match_i2c(struct device *dev, struct v4l2_async_subdev *asd)
  26 {
  27 #if IS_ENABLED(CONFIG_I2C)
  28         struct i2c_client *client = i2c_verify_client(dev);
  29         return client &&
  30                 asd->match.i2c.adapter_id == client->adapter->nr &&
  31                 asd->match.i2c.address == client->addr;
  32 #else
  33         return false;
  34 #endif
  35 }
  36
  37 static bool match_devname(struct device *dev, struct v4l2_async_subdev *asd)
  38 {
  39         return !strcmp(asd->match.device_name.name, dev_name(dev));
  40 }
  41
  42 static bool match_of(struct device *dev, struct v4l2_async_subdev *asd)
  43 {
  44         return dev->of_node == asd->match.of.node;
  45 }
  46
  47 static LIST_HEAD(subdev_list);
  48 static LIST_HEAD(notifier_list);
  49 static DEFINE_MUTEX(list_lock);
  50
  51 static struct v4l2_async_subdev *v4l2_async_belongs(struct v4l2_async_notifier *notifier,
  52                                                     struct v4l2_subdev *sd)
  53 {
  54         struct v4l2_async_subdev *asd;
  55         bool (*match)(struct device *, struct v4l2_async_subdev *);
  56
  57         list_for_each_entry(asd, &notifier->waiting, list) {
  58                 /* bus_type has been verified valid before */
  59                 switch (asd->match_type) {
  60                 case V4L2_ASYNC_MATCH_CUSTOM:
  61                         match = asd->match.custom.match;
  62                         if (!match)
  63                                 /* Match always */
  64                                 return asd;
  65                         break;
  66                 case V4L2_ASYNC_MATCH_DEVNAME:
  67                         match = match_devname;
  68                         break;
  69                 case V4L2_ASYNC_MATCH_I2C:
  70                         match = match_i2c;
  71                         break;
  72                 case V4L2_ASYNC_MATCH_OF:
  73                         match = match_of;
  74                         break;
  75                 default:
  76                         /* Cannot happen, unless someone breaks us */
  77                         WARN_ON(true);
  78                         return NULL;
  79                 }
  80
  81                 /* match cannot be NULL here */
  82                 if (match(sd->dev, asd))
  83                         return asd;
  84         }
  85
  86         return NULL;
  87 }
  88
  89 static int v4l2_async_test_notify(struct v4l2_async_notifier *notifier,
  90                                   struct v4l2_subdev *sd,
  91                                   struct v4l2_async_subdev *asd)
  92 {
  93         int ret;
  94
  95         /* Remove from the waiting list */
  96         list_del(&asd->list);
  97         sd->asd = asd;
  98         sd->notifier = notifier;
  99
 100         if (notifier->bound) {
 101                 ret = notifier->bound(notifier, sd, asd);
 102                 if (ret < 0)
 103                         return ret;
 104         }
 105         /* Move from the global subdevice list to notifier's done */
 106         list_move(&sd->async_list, &notifier->done);
 107
 108         ret = v4l2_device_register_subdev(notifier->v4l2_dev, sd);
 109         if (ret < 0) {
 110                 if (notifier->unbind)
 111                         notifier->unbind(notifier, sd, asd);
 112                 return ret;
 113         }
 114
 115         if (list_empty(&notifier->waiting) && notifier->complete)
 116                 return notifier->complete(notifier);
 117
 118         return 0;
 119 }
 120
 121 static void v4l2_async_cleanup(struct v4l2_subdev *sd)
 122 {
 123         v4l2_device_unregister_subdev(sd);
 124         /* Subdevice driver will reprobe and put the subdev back onto the list */
 125         list_del_init(&sd->async_list);
 126         sd->asd = NULL;
 127         sd->dev = NULL;
 128 }
 129
 130 int v4l2_async_notifier_register(struct v4l2_device *v4l2_dev,
 131                                  struct v4l2_async_notifier *notifier)
 132 {
 133         struct v4l2_subdev *sd, *tmp;
 134         struct v4l2_async_subdev *asd;
 135         int i;
 136
 137         if (!notifier->num_subdevs || notifier->num_subdevs > V4L2_MAX_SUBDEVS)
 138                 return -EINVAL;
 139
 140         notifier->v4l2_dev = v4l2_dev;
 141         INIT_LIST_HEAD(&notifier->waiting);
 142         INIT_LIST_HEAD(&notifier->done);
 143
 144         for (i = 0; i < notifier->num_subdevs; i++) {
 145                 asd = notifier->subdevs[i];
 146
 147                 switch (asd->match_type) {
 148                 case V4L2_ASYNC_MATCH_CUSTOM:
 149                 case V4L2_ASYNC_MATCH_DEVNAME:
 150                 case V4L2_ASYNC_MATCH_I2C:
 151                 case V4L2_ASYNC_MATCH_OF:
 152                         break;
 153                 default:
 154                         dev_err(notifier->v4l2_dev ? notifier->v4l2_dev->dev : NULL,
 155                                 "Invalid match type %u on %p\n",
 156                                 asd->match_type, asd);
 157                         return -EINVAL;
 158                 }
 159                 list_add_tail(&asd->list, &notifier->waiting);
 160         }
 161
 162         mutex_lock(&list_lock);
 163
 164         /* Keep also completed notifiers on the list */
 165         list_add(&notifier->list, &notifier_list);
 166
 167         list_for_each_entry_safe(sd, tmp, &subdev_list, async_list) {
 168                 int ret;
 169
 170                 asd = v4l2_async_belongs(notifier, sd);
 171                 if (!asd)
 172                         continue;
 173
 174                 ret = v4l2_async_test_notify(notifier, sd, asd);
 175                 if (ret < 0) {
 176                         mutex_unlock(&list_lock);
 177                         return ret;
 178                 }
 179         }
 180
 181         mutex_unlock(&list_lock);
 182
 183         return 0;
 184 }
 185 EXPORT_SYMBOL(v4l2_async_notifier_register);
 186
 187 void v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier)
 188 {
 189         struct v4l2_subdev *sd, *tmp;
 190         unsigned int notif_n_subdev = notifier->num_subdevs;
 191         unsigned int n_subdev = min(notif_n_subdev, V4L2_MAX_SUBDEVS);
 192         struct device **dev;
 193         int i = 0;
 194
 195         if (!notifier->v4l2_dev)
 196                 return;
 197
 198         dev = kmalloc(n_subdev * sizeof(*dev), GFP_KERNEL);
 199         if (!dev) {
 200                 dev_err(notifier->v4l2_dev->dev,
 201                         "Failed to allocate device cache!\n");
 202         }
 203
 204         mutex_lock(&list_lock);
 205
 206         list_del(&notifier->list);
 207
 208         list_for_each_entry_safe(sd, tmp, &notifier->done, async_list) {
 209                 struct device *d;
 210
 211                 d = get_device(sd->dev);
 212
 213                 v4l2_async_cleanup(sd);
 214
 215                 /* If we handled USB devices, we'd have to lock the parent too */
 216                 device_release_driver(d);
 217
 218                 if (notifier->unbind)
 219                         notifier->unbind(notifier, sd, sd->asd);
 220
 221                 /*
 222                  * Store device at the device cache, in order to call
 223                  * put_device() on the final step
 224                  */
 225                 if (dev)
 226                         dev[i++] = d;
 227                 else
 228                         put_device(d);
 229         }
 230
 231         mutex_unlock(&list_lock);
 232
 233         /*
 234          * Call device_attach() to reprobe devices
 235          *
 236          * NOTE: If dev allocation fails, i is 0, and the whole loop won't be
 237          * executed.
 238          */
 239         while (i--) {
 240                 struct device *d = dev[i];
 241
 242                 if (d && device_attach(d) < 0) {
 243                         const char *name = "(none)";
 244                         int lock = device_trylock(d);
 245
 246                         if (lock && d->driver)
 247                                 name = d->driver->name;
 248                         dev_err(d, "Failed to re-probe to %s\n", name);
 249                         if (lock)
 250                                 device_unlock(d);
 251                 }
 252                 put_device(d);
 253         }
 254         kfree(dev);
 255
 256         notifier->v4l2_dev = NULL;
 257
 258         /*
 259          * Don't care about the waiting list, it is initialised and populated
 260          * upon notifier registration.
 261          */
 262 }
 263 EXPORT_SYMBOL(v4l2_async_notifier_unregister);
 264
 265 int v4l2_async_register_subdev(struct v4l2_subdev *sd)
 266 {
 267         struct v4l2_async_notifier *notifier;
 268
 269         mutex_lock(&list_lock);
 270
 271         INIT_LIST_HEAD(&sd->async_list);
 272
 273         list_for_each_entry(notifier, &notifier_list, list) {
 274                 struct v4l2_async_subdev *asd = v4l2_async_belongs(notifier, sd);
 275                 if (asd) {
 276                         int ret = v4l2_async_test_notify(notifier, sd, asd);
 277                         mutex_unlock(&list_lock);
 278                         return ret;
 279                 }
 280         }
 281
 282         /* None matched, wait for hot-plugging */
 283         list_add(&sd->async_list, &subdev_list);
 284
 285         mutex_unlock(&list_lock);
 286
 287         return 0;
 288 }
 289 EXPORT_SYMBOL(v4l2_async_register_subdev);
 290
 291 void v4l2_async_unregister_subdev(struct v4l2_subdev *sd)
 292 {
 293         struct v4l2_async_notifier *notifier = sd->notifier;
 294
 295         if (!sd->asd) {
 296                 if (!list_empty(&sd->async_list))
 297                         v4l2_async_cleanup(sd);
 298                 return;
 299         }
 300
 301         mutex_lock(&list_lock);
 302
 303         list_add(&sd->asd->list, &notifier->waiting);
 304
 305         v4l2_async_cleanup(sd);
 306
 307         if (notifier->unbind)
 308                 notifier->unbind(notifier, sd, sd->asd);
 309
 310         mutex_unlock(&list_lock);
 311 }
 312 EXPORT_SYMBOL(v4l2_async_unregister_subdev);