drivers/media/v4l2-core/v4l2-common.c

   1 /*
   2  *      Video for Linux Two
   3  *
   4  *      A generic video device interface for the LINUX operating system
   5  *      using a set of device structures/vectors for low level operations.
   6  *
   7  *      This file replaces the videodev.c file that comes with the
   8  *      regular kernel distribution.
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  *
  15  * Author:      Bill Dirks <bill@thedirks.org>
  16  *              based on code by Alan Cox, <alan@cymru.net>
  17  *
  18  */
  19
  20 /*
  21  * Video capture interface for Linux
  22  *
  23  *      A generic video device interface for the LINUX operating system
  24  *      using a set of device structures/vectors for low level operations.
  25  *
  26  *              This program is free software; you can redistribute it and/or
  27  *              modify it under the terms of the GNU General Public License
  28  *              as published by the Free Software Foundation; either version
  29  *              2 of the License, or (at your option) any later version.
  30  *
  31  * Author:      Alan Cox, <alan@lxorguk.ukuu.org.uk>
  32  *
  33  * Fixes:
  34  */
  35
  36 /*
  37  * Video4linux 1/2 integration by Justin Schoeman
  38  * <justin@suntiger.ee.up.ac.za>
  39  * 2.4 PROCFS support ported from 2.4 kernels by
  40  *  Iñaki García Etxebarria <garetxe@euskalnet.net>
  41  * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
  42  * 2.4 devfs support ported from 2.4 kernels by
  43  *  Dan Merillat <dan@merillat.org>
  44  * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
  45  */
  46
  47 #include <linux/module.h>
  48 #include <linux/types.h>
  49 #include <linux/kernel.h>
  50 #include <linux/mm.h>
  51 #include <linux/string.h>
  52 #include <linux/errno.h>
  53 #include <linux/i2c.h>
  54 #if defined(CONFIG_SPI)
  55 #include <linux/spi/spi.h>
  56 #endif
  57 #include <linux/uaccess.h>
  58 #include <asm/pgtable.h>
  59 #include <asm/io.h>
  60 #include <asm/div64.h>
  61 #include <media/v4l2-common.h>
  62 #include <media/v4l2-device.h>
  63 #include <media/v4l2-ctrls.h>
  64
  65 #include <linux/videodev2.h>
  66
  67 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  68 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  69 MODULE_LICENSE("GPL");
  70
  71 /*
  72  *
  73  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  74  *
  75  */
  76
  77 /*
  78  *  Video Standard Operations (contributed by Michael Schimek)
  79  */
  80
  81 /* Helper functions for control handling                             */
  82
  83 /* Fill in a struct v4l2_queryctrl */
  84 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 _min, s32 _max, s32 _step, s32 _def)
  85 {
  86         const char *name;
  87         s64 min = _min;
  88         s64 max = _max;
  89         u64 step = _step;
  90         s64 def = _def;
  91
  92         v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
  93                        &min, &max, &step, &def, &qctrl->flags);
  94
  95         if (name == NULL)
  96                 return -EINVAL;
  97
  98         qctrl->minimum = min;
  99         qctrl->maximum = max;
 100         qctrl->step = step;
 101         qctrl->default_value = def;
 102         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 103         strlcpy(qctrl->name, name, sizeof(qctrl->name));
 104         return 0;
 105 }
 106 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 107
 108 /* I2C Helper functions */
 109
 110 #if IS_ENABLED(CONFIG_I2C)
 111
 112 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
 113                 const struct v4l2_subdev_ops *ops)
 114 {
 115         v4l2_subdev_init(sd, ops);
 116         sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
 117         /* the owner is the same as the i2c_client's driver owner */
 118         sd->owner = client->dev.driver->owner;
 119         sd->dev = &client->dev;
 120         /* i2c_client and v4l2_subdev point to one another */
 121         v4l2_set_subdevdata(sd, client);
 122         i2c_set_clientdata(client, sd);
 123         /* initialize name */
 124         snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
 125                 client->dev.driver->name, i2c_adapter_id(client->adapter),
 126                 client->addr);
 127 }
 128 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
 129
 130 /* Load an i2c sub-device. */
 131 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
 132                 struct i2c_adapter *adapter, struct i2c_board_info *info,
 133                 const unsigned short *probe_addrs)
 134 {
 135         struct v4l2_subdev *sd = NULL;
 136         struct i2c_client *client;
 137
 138         BUG_ON(!v4l2_dev);
 139
 140         request_module(I2C_MODULE_PREFIX "%s", info->type);
 141
 142         /* Create the i2c client */
 143         if (info->addr == 0 && probe_addrs)
 144                 client = i2c_new_probed_device(adapter, info, probe_addrs,
 145                                                NULL);
 146         else
 147                 client = i2c_new_device(adapter, info);
 148
 149         /* Note: by loading the module first we are certain that c->driver
 150            will be set if the driver was found. If the module was not loaded
 151            first, then the i2c core tries to delay-load the module for us,
 152            and then c->driver is still NULL until the module is finally
 153            loaded. This delay-load mechanism doesn't work if other drivers
 154            want to use the i2c device, so explicitly loading the module
 155            is the best alternative. */
 156         if (client == NULL || client->dev.driver == NULL)
 157                 goto error;
 158
 159         /* Lock the module so we can safely get the v4l2_subdev pointer */
 160         if (!try_module_get(client->dev.driver->owner))
 161                 goto error;
 162         sd = i2c_get_clientdata(client);
 163
 164         /* Register with the v4l2_device which increases the module's
 165            use count as well. */
 166         if (v4l2_device_register_subdev(v4l2_dev, sd))
 167                 sd = NULL;
 168         /* Decrease the module use count to match the first try_module_get. */
 169         module_put(client->dev.driver->owner);
 170
 171 error:
 172         /* If we have a client but no subdev, then something went wrong and
 173            we must unregister the client. */
 174         if (client && sd == NULL)
 175                 i2c_unregister_device(client);
 176         return sd;
 177 }
 178 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
 179
 180 struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
 181                 struct i2c_adapter *adapter, const char *client_type,
 182                 u8 addr, const unsigned short *probe_addrs)
 183 {
 184         struct i2c_board_info info;
 185
 186         /* Setup the i2c board info with the device type and
 187            the device address. */
 188         memset(&info, 0, sizeof(info));
 189         strlcpy(info.type, client_type, sizeof(info.type));
 190         info.addr = addr;
 191
 192         return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
 193 }
 194 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
 195
 196 /* Return i2c client address of v4l2_subdev. */
 197 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
 198 {
 199         struct i2c_client *client = v4l2_get_subdevdata(sd);
 200
 201         return client ? client->addr : I2C_CLIENT_END;
 202 }
 203 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
 204
 205 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
 206    addresses are unknown. */
 207 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
 208 {
 209         static const unsigned short radio_addrs[] = {
 210 #if IS_ENABLED(CONFIG_MEDIA_TUNER_TEA5761)
 211                 0x10,
 212 #endif
 213                 0x60,
 214                 I2C_CLIENT_END
 215         };
 216         static const unsigned short demod_addrs[] = {
 217                 0x42, 0x43, 0x4a, 0x4b,
 218                 I2C_CLIENT_END
 219         };
 220         static const unsigned short tv_addrs[] = {
 221                 0x42, 0x43, 0x4a, 0x4b,         /* tda8290 */
 222                 0x60, 0x61, 0x62, 0x63, 0x64,
 223                 I2C_CLIENT_END
 224         };
 225
 226         switch (type) {
 227         case ADDRS_RADIO:
 228                 return radio_addrs;
 229         case ADDRS_DEMOD:
 230                 return demod_addrs;
 231         case ADDRS_TV:
 232                 return tv_addrs;
 233         case ADDRS_TV_WITH_DEMOD:
 234                 return tv_addrs + 4;
 235         }
 236         return NULL;
 237 }
 238 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
 239
 240 #endif /* defined(CONFIG_I2C) */
 241
 242 #if defined(CONFIG_SPI)
 243
 244 /* Load an spi sub-device. */
 245
 246 void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,
 247                 const struct v4l2_subdev_ops *ops)
 248 {
 249         v4l2_subdev_init(sd, ops);
 250         sd->flags |= V4L2_SUBDEV_FL_IS_SPI;
 251         /* the owner is the same as the spi_device's driver owner */
 252         sd->owner = spi->dev.driver->owner;
 253         sd->dev = &spi->dev;
 254         /* spi_device and v4l2_subdev point to one another */
 255         v4l2_set_subdevdata(sd, spi);
 256         spi_set_drvdata(spi, sd);
 257         /* initialize name */
 258         strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
 259 }
 260 EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);
 261
 262 struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
 263                 struct spi_master *master, struct spi_board_info *info)
 264 {
 265         struct v4l2_subdev *sd = NULL;
 266         struct spi_device *spi = NULL;
 267
 268         BUG_ON(!v4l2_dev);
 269
 270         if (info->modalias[0])
 271                 request_module(info->modalias);
 272
 273         spi = spi_new_device(master, info);
 274
 275         if (spi == NULL || spi->dev.driver == NULL)
 276                 goto error;
 277
 278         if (!try_module_get(spi->dev.driver->owner))
 279                 goto error;
 280
 281         sd = spi_get_drvdata(spi);
 282
 283         /* Register with the v4l2_device which increases the module's
 284            use count as well. */
 285         if (v4l2_device_register_subdev(v4l2_dev, sd))
 286                 sd = NULL;
 287
 288         /* Decrease the module use count to match the first try_module_get. */
 289         module_put(spi->dev.driver->owner);
 290
 291 error:
 292         /* If we have a client but no subdev, then something went wrong and
 293            we must unregister the client. */
 294         if (!sd)
 295                 spi_unregister_device(spi);
 296
 297         return sd;
 298 }
 299 EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);
 300
 301 #endif /* defined(CONFIG_SPI) */
 302
 303 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
 304  * and max don't have to be aligned, but there must be at least one valid
 305  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
 306  * of 16 between 17 and 31.  */
 307 static unsigned int clamp_align(unsigned int x, unsigned int min,
 308                                 unsigned int max, unsigned int align)
 309 {
 310         /* Bits that must be zero to be aligned */
 311         unsigned int mask = ~((1 << align) - 1);
 312
 313         /* Clamp to aligned min and max */
 314         x = clamp(x, (min + ~mask) & mask, max & mask);
 315
 316         /* Round to nearest aligned value */
 317         if (align)
 318                 x = (x + (1 << (align - 1))) & mask;
 319
 320         return x;
 321 }
 322
 323 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
 324                            unsigned int walign,
 325                            u32 *h, unsigned int hmin, unsigned int hmax,
 326                            unsigned int halign, unsigned int salign)
 327 {
 328         *w = clamp_align(*w, wmin, wmax, walign);
 329         *h = clamp_align(*h, hmin, hmax, halign);
 330
 331         /* Usually we don't need to align the size and are done now. */
 332         if (!salign)
 333                 return;
 334
 335         /* How much alignment do we have? */
 336         walign = __ffs(*w);
 337         halign = __ffs(*h);
 338         /* Enough to satisfy the image alignment? */
 339         if (walign + halign < salign) {
 340                 /* Max walign where there is still a valid width */
 341                 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
 342                 /* Max halign where there is still a valid height */
 343                 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
 344
 345                 /* up the smaller alignment until we have enough */
 346                 do {
 347                         if (halign >= hmaxa ||
 348                             (walign <= halign && walign < wmaxa)) {
 349                                 *w = clamp_align(*w, wmin, wmax, walign + 1);
 350                                 walign = __ffs(*w);
 351                         } else {
 352                                 *h = clamp_align(*h, hmin, hmax, halign + 1);
 353                                 halign = __ffs(*h);
 354                         }
 355                 } while (halign + walign < salign);
 356         }
 357 }
 358 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
 359
 360 const void *
 361 __v4l2_find_nearest_size(const void *array, size_t array_size,
 362                          size_t entry_size, size_t width_offset,
 363                          size_t height_offset, s32 width, s32 height)
 364 {
 365         u32 error, min_error = U32_MAX;
 366         const void *best = NULL;
 367         unsigned int i;
 368
 369         if (!array)
 370                 return NULL;
 371
 372         for (i = 0; i < array_size; i++, array += entry_size) {
 373                 const u32 *entry_width = array + width_offset;
 374                 const u32 *entry_height = array + height_offset;
 375
 376                 error = abs(*entry_width - width) + abs(*entry_height - height);
 377                 if (error > min_error)
 378                         continue;
 379
 380                 min_error = error;
 381                 best = array;
 382                 if (!error)
 383                         break;
 384         }
 385
 386         return best;
 387 }
 388 EXPORT_SYMBOL_GPL(__v4l2_find_nearest_size);
 389
 390 void v4l2_get_timestamp(struct timeval *tv)
 391 {
 392         struct timespec ts;
 393
 394         ktime_get_ts(&ts);
 395         tv->tv_sec = ts.tv_sec;
 396         tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
 397 }
 398 EXPORT_SYMBOL_GPL(v4l2_get_timestamp);
 399
 400 int v4l2_g_parm_cap(struct video_device *vdev,
 401                     struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 402 {
 403         struct v4l2_subdev_frame_interval ival = { 0 };
 404         int ret;
 405
 406         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 407             a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 408                 return -EINVAL;
 409
 410         if (vdev->device_caps & V4L2_CAP_READWRITE)
 411                 a->parm.capture.readbuffers = 2;
 412         if (v4l2_subdev_has_op(sd, video, g_frame_interval))
 413                 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 414         ret = v4l2_subdev_call(sd, video, g_frame_interval, &ival);
 415         if (!ret)
 416                 a->parm.capture.timeperframe = ival.interval;
 417         return ret;
 418 }
 419 EXPORT_SYMBOL_GPL(v4l2_g_parm_cap);
 420
 421 int v4l2_s_parm_cap(struct video_device *vdev,
 422                     struct v4l2_subdev *sd, struct v4l2_streamparm *a)
 423 {
 424         struct v4l2_subdev_frame_interval ival = {
 425                 .interval = a->parm.capture.timeperframe
 426         };
 427         int ret;
 428
 429         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 430             a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
 431                 return -EINVAL;
 432
 433         memset(&a->parm, 0, sizeof(a->parm));
 434         if (vdev->device_caps & V4L2_CAP_READWRITE)
 435                 a->parm.capture.readbuffers = 2;
 436         else
 437                 a->parm.capture.readbuffers = 0;
 438
 439         if (v4l2_subdev_has_op(sd, video, g_frame_interval))
 440                 a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 441         ret = v4l2_subdev_call(sd, video, s_frame_interval, &ival);
 442         if (!ret)
 443                 a->parm.capture.timeperframe = ival.interval;
 444         return ret;
 445 }
 446 EXPORT_SYMBOL_GPL(v4l2_s_parm_cap);