drivers/media/video/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 <asm/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 #include <media/v4l2-chip-ident.h>
  65
  66 #include <linux/videodev2.h>
  67
  68 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
  69 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
  70 MODULE_LICENSE("GPL");
  71
  72 /*
  73  *
  74  *      V 4 L 2   D R I V E R   H E L P E R   A P I
  75  *
  76  */
  77
  78 /*
  79  *  Video Standard Operations (contributed by Michael Schimek)
  80  */
  81
  82 /* Helper functions for control handling                             */
  83
  84 /* Check for correctness of the ctrl's value based on the data from
  85    struct v4l2_queryctrl and the available menu items. Note that
  86    menu_items may be NULL, in that case it is ignored. */
  87 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
  88                 const char * const *menu_items)
  89 {
  90         if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
  91                 return -EINVAL;
  92         if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
  93                 return -EBUSY;
  94         if (qctrl->type == V4L2_CTRL_TYPE_STRING)
  95                 return 0;
  96         if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
  97             qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
  98             qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
  99                 return 0;
 100         if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
 101                 return -ERANGE;
 102         if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
 103                 if (menu_items[ctrl->value] == NULL ||
 104                     menu_items[ctrl->value][0] == '\0')
 105                         return -EINVAL;
 106         }
 107         if (qctrl->type == V4L2_CTRL_TYPE_BITMASK &&
 108                         (ctrl->value & ~qctrl->maximum))
 109                 return -ERANGE;
 110         return 0;
 111 }
 112 EXPORT_SYMBOL(v4l2_ctrl_check);
 113
 114 /* Fill in a struct v4l2_queryctrl */
 115 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
 116 {
 117         const char *name;
 118
 119         v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
 120                        &min, &max, &step, &def, &qctrl->flags);
 121
 122         if (name == NULL)
 123                 return -EINVAL;
 124
 125         qctrl->minimum = min;
 126         qctrl->maximum = max;
 127         qctrl->step = step;
 128         qctrl->default_value = def;
 129         qctrl->reserved[0] = qctrl->reserved[1] = 0;
 130         strlcpy(qctrl->name, name, sizeof(qctrl->name));
 131         return 0;
 132 }
 133 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
 134
 135 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
 136    the menu. The qctrl pointer may be NULL, in which case it is ignored.
 137    If menu_items is NULL, then the menu items are retrieved using
 138    v4l2_ctrl_get_menu. */
 139 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
 140                const char * const *menu_items)
 141 {
 142         int i;
 143
 144         qmenu->reserved = 0;
 145         if (menu_items == NULL)
 146                 menu_items = v4l2_ctrl_get_menu(qmenu->id);
 147         if (menu_items == NULL ||
 148             (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
 149                 return -EINVAL;
 150         for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
 151         if (menu_items[i] == NULL || menu_items[i][0] == '\0')
 152                 return -EINVAL;
 153         strlcpy(qmenu->name, menu_items[qmenu->index], sizeof(qmenu->name));
 154         return 0;
 155 }
 156 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
 157
 158 /* Fill in a struct v4l2_querymenu based on the specified array of valid
 159    menu items (terminated by V4L2_CTRL_MENU_IDS_END).
 160    Use this if there are 'holes' in the list of valid menu items. */
 161 int v4l2_ctrl_query_menu_valid_items(struct v4l2_querymenu *qmenu, const u32 *ids)
 162 {
 163         const char * const *menu_items = v4l2_ctrl_get_menu(qmenu->id);
 164
 165         qmenu->reserved = 0;
 166         if (menu_items == NULL || ids == NULL)
 167                 return -EINVAL;
 168         while (*ids != V4L2_CTRL_MENU_IDS_END) {
 169                 if (*ids++ == qmenu->index) {
 170                         strlcpy(qmenu->name, menu_items[qmenu->index],
 171                                         sizeof(qmenu->name));
 172                         return 0;
 173                 }
 174         }
 175         return -EINVAL;
 176 }
 177 EXPORT_SYMBOL(v4l2_ctrl_query_menu_valid_items);
 178
 179 /* ctrl_classes points to an array of u32 pointers, the last element is
 180    a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
 181    Each array must be sorted low to high and belong to the same control
 182    class. The array of u32 pointers must also be sorted, from low class IDs
 183    to high class IDs.
 184
 185    This function returns the first ID that follows after the given ID.
 186    When no more controls are available 0 is returned. */
 187 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
 188 {
 189         u32 ctrl_class = V4L2_CTRL_ID2CLASS(id);
 190         const u32 *pctrl;
 191
 192         if (ctrl_classes == NULL)
 193                 return 0;
 194
 195         /* if no query is desired, then check if the ID is part of ctrl_classes */
 196         if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0) {
 197                 /* find class */
 198                 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) != ctrl_class)
 199                         ctrl_classes++;
 200                 if (*ctrl_classes == NULL)
 201                         return 0;
 202                 pctrl = *ctrl_classes;
 203                 /* find control ID */
 204                 while (*pctrl && *pctrl != id) pctrl++;
 205                 return *pctrl ? id : 0;
 206         }
 207         id &= V4L2_CTRL_ID_MASK;
 208         id++;   /* select next control */
 209         /* find first class that matches (or is greater than) the class of
 210            the ID */
 211         while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
 212                 ctrl_classes++;
 213         /* no more classes */
 214         if (*ctrl_classes == NULL)
 215                 return 0;
 216         pctrl = *ctrl_classes;
 217         /* find first ctrl within the class that is >= ID */
 218         while (*pctrl && *pctrl < id) pctrl++;
 219         if (*pctrl)
 220                 return *pctrl;
 221         /* we are at the end of the controls of the current class. */
 222         /* continue with next class if available */
 223         ctrl_classes++;
 224         if (*ctrl_classes == NULL)
 225                 return 0;
 226         return **ctrl_classes;
 227 }
 228 EXPORT_SYMBOL(v4l2_ctrl_next);
 229
 230 int v4l2_chip_match_host(const struct v4l2_dbg_match *match)
 231 {
 232         switch (match->type) {
 233         case V4L2_CHIP_MATCH_HOST:
 234                 return match->addr == 0;
 235         default:
 236                 return 0;
 237         }
 238 }
 239 EXPORT_SYMBOL(v4l2_chip_match_host);
 240
 241 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE))
 242 int v4l2_chip_match_i2c_client(struct i2c_client *c, const struct v4l2_dbg_match *match)
 243 {
 244         int len;
 245
 246         if (c == NULL || match == NULL)
 247                 return 0;
 248
 249         switch (match->type) {
 250         case V4L2_CHIP_MATCH_I2C_DRIVER:
 251                 if (c->driver == NULL || c->driver->driver.name == NULL)
 252                         return 0;
 253                 len = strlen(c->driver->driver.name);
 254                 /* legacy drivers have a ' suffix, don't try to match that */
 255                 if (len && c->driver->driver.name[len - 1] == '\'')
 256                         len--;
 257                 return len && !strncmp(c->driver->driver.name, match->name, len);
 258         case V4L2_CHIP_MATCH_I2C_ADDR:
 259                 return c->addr == match->addr;
 260         default:
 261                 return 0;
 262         }
 263 }
 264 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
 265
 266 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_dbg_chip_ident *chip,
 267                 u32 ident, u32 revision)
 268 {
 269         if (!v4l2_chip_match_i2c_client(c, &chip->match))
 270                 return 0;
 271         if (chip->ident == V4L2_IDENT_NONE) {
 272                 chip->ident = ident;
 273                 chip->revision = revision;
 274         }
 275         else {
 276                 chip->ident = V4L2_IDENT_AMBIGUOUS;
 277                 chip->revision = 0;
 278         }
 279         return 0;
 280 }
 281 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
 282
 283 /* ----------------------------------------------------------------- */
 284
 285 /* I2C Helper functions */
 286
 287
 288 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
 289                 const struct v4l2_subdev_ops *ops)
 290 {
 291         v4l2_subdev_init(sd, ops);
 292         sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
 293         /* the owner is the same as the i2c_client's driver owner */
 294         sd->owner = client->driver->driver.owner;
 295         /* i2c_client and v4l2_subdev point to one another */
 296         v4l2_set_subdevdata(sd, client);
 297         i2c_set_clientdata(client, sd);
 298         /* initialize name */
 299         snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
 300                 client->driver->driver.name, i2c_adapter_id(client->adapter),
 301                 client->addr);
 302 }
 303 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
 304
 305
 306
 307 /* Load an i2c sub-device. */
 308 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
 309                 struct i2c_adapter *adapter, struct i2c_board_info *info,
 310                 const unsigned short *probe_addrs)
 311 {
 312         struct v4l2_subdev *sd = NULL;
 313         struct i2c_client *client;
 314
 315         BUG_ON(!v4l2_dev);
 316
 317         request_module(I2C_MODULE_PREFIX "%s", info->type);
 318
 319         /* Create the i2c client */
 320         if (info->addr == 0 && probe_addrs)
 321                 client = i2c_new_probed_device(adapter, info, probe_addrs,
 322                                                NULL);
 323         else
 324                 client = i2c_new_device(adapter, info);
 325
 326         /* Note: by loading the module first we are certain that c->driver
 327            will be set if the driver was found. If the module was not loaded
 328            first, then the i2c core tries to delay-load the module for us,
 329            and then c->driver is still NULL until the module is finally
 330            loaded. This delay-load mechanism doesn't work if other drivers
 331            want to use the i2c device, so explicitly loading the module
 332            is the best alternative. */
 333         if (client == NULL || client->driver == NULL)
 334                 goto error;
 335
 336         /* Lock the module so we can safely get the v4l2_subdev pointer */
 337         if (!try_module_get(client->driver->driver.owner))
 338                 goto error;
 339         sd = i2c_get_clientdata(client);
 340
 341         /* Register with the v4l2_device which increases the module's
 342            use count as well. */
 343         if (v4l2_device_register_subdev(v4l2_dev, sd))
 344                 sd = NULL;
 345         /* Decrease the module use count to match the first try_module_get. */
 346         module_put(client->driver->driver.owner);
 347
 348 error:
 349         /* If we have a client but no subdev, then something went wrong and
 350            we must unregister the client. */
 351         if (client && sd == NULL)
 352                 i2c_unregister_device(client);
 353         return sd;
 354 }
 355 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
 356
 357 struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
 358                 struct i2c_adapter *adapter, const char *client_type,
 359                 u8 addr, const unsigned short *probe_addrs)
 360 {
 361         struct i2c_board_info info;
 362
 363         /* Setup the i2c board info with the device type and
 364            the device address. */
 365         memset(&info, 0, sizeof(info));
 366         strlcpy(info.type, client_type, sizeof(info.type));
 367         info.addr = addr;
 368
 369         return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
 370 }
 371 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
 372
 373 /* Return i2c client address of v4l2_subdev. */
 374 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
 375 {
 376         struct i2c_client *client = v4l2_get_subdevdata(sd);
 377
 378         return client ? client->addr : I2C_CLIENT_END;
 379 }
 380 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
 381
 382 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
 383    addresses are unknown. */
 384 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
 385 {
 386         static const unsigned short radio_addrs[] = {
 387 #if defined(CONFIG_MEDIA_TUNER_TEA5761) || defined(CONFIG_MEDIA_TUNER_TEA5761_MODULE)
 388                 0x10,
 389 #endif
 390                 0x60,
 391                 I2C_CLIENT_END
 392         };
 393         static const unsigned short demod_addrs[] = {
 394                 0x42, 0x43, 0x4a, 0x4b,
 395                 I2C_CLIENT_END
 396         };
 397         static const unsigned short tv_addrs[] = {
 398                 0x42, 0x43, 0x4a, 0x4b,         /* tda8290 */
 399                 0x60, 0x61, 0x62, 0x63, 0x64,
 400                 I2C_CLIENT_END
 401         };
 402
 403         switch (type) {
 404         case ADDRS_RADIO:
 405                 return radio_addrs;
 406         case ADDRS_DEMOD:
 407                 return demod_addrs;
 408         case ADDRS_TV:
 409                 return tv_addrs;
 410         case ADDRS_TV_WITH_DEMOD:
 411                 return tv_addrs + 4;
 412         }
 413         return NULL;
 414 }
 415 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
 416
 417 #endif /* defined(CONFIG_I2C) */
 418
 419 #if defined(CONFIG_SPI)
 420
 421 /* Load a spi sub-device. */
 422
 423 void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,
 424                 const struct v4l2_subdev_ops *ops)
 425 {
 426         v4l2_subdev_init(sd, ops);
 427         sd->flags |= V4L2_SUBDEV_FL_IS_SPI;
 428         /* the owner is the same as the spi_device's driver owner */
 429         sd->owner = spi->dev.driver->owner;
 430         /* spi_device and v4l2_subdev point to one another */
 431         v4l2_set_subdevdata(sd, spi);
 432         spi_set_drvdata(spi, sd);
 433         /* initialize name */
 434         strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
 435 }
 436 EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);
 437
 438 struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
 439                 struct spi_master *master, struct spi_board_info *info)
 440 {
 441         struct v4l2_subdev *sd = NULL;
 442         struct spi_device *spi = NULL;
 443
 444         BUG_ON(!v4l2_dev);
 445
 446         if (info->modalias)
 447                 request_module(info->modalias);
 448
 449         spi = spi_new_device(master, info);
 450
 451         if (spi == NULL || spi->dev.driver == NULL)
 452                 goto error;
 453
 454         if (!try_module_get(spi->dev.driver->owner))
 455                 goto error;
 456
 457         sd = spi_get_drvdata(spi);
 458
 459         /* Register with the v4l2_device which increases the module's
 460            use count as well. */
 461         if (v4l2_device_register_subdev(v4l2_dev, sd))
 462                 sd = NULL;
 463
 464         /* Decrease the module use count to match the first try_module_get. */
 465         module_put(spi->dev.driver->owner);
 466
 467 error:
 468         /* If we have a client but no subdev, then something went wrong and
 469            we must unregister the client. */
 470         if (spi && sd == NULL)
 471                 spi_unregister_device(spi);
 472
 473         return sd;
 474 }
 475 EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);
 476
 477 #endif /* defined(CONFIG_SPI) */
 478
 479 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
 480  * and max don't have to be aligned, but there must be at least one valid
 481  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
 482  * of 16 between 17 and 31.  */
 483 static unsigned int clamp_align(unsigned int x, unsigned int min,
 484                                 unsigned int max, unsigned int align)
 485 {
 486         /* Bits that must be zero to be aligned */
 487         unsigned int mask = ~((1 << align) - 1);
 488
 489         /* Round to nearest aligned value */
 490         if (align)
 491                 x = (x + (1 << (align - 1))) & mask;
 492
 493         /* Clamp to aligned value of min and max */
 494         if (x < min)
 495                 x = (min + ~mask) & mask;
 496         else if (x > max)
 497                 x = max & mask;
 498
 499         return x;
 500 }
 501
 502 /* Bound an image to have a width between wmin and wmax, and height between
 503  * hmin and hmax, inclusive.  Additionally, the width will be a multiple of
 504  * 2^walign, the height will be a multiple of 2^halign, and the overall size
 505  * (width*height) will be a multiple of 2^salign.  The image may be shrunk
 506  * or enlarged to fit the alignment constraints.
 507  *
 508  * The width or height maximum must not be smaller than the corresponding
 509  * minimum.  The alignments must not be so high there are no possible image
 510  * sizes within the allowed bounds.  wmin and hmin must be at least 1
 511  * (don't use 0).  If you don't care about a certain alignment, specify 0,
 512  * as 2^0 is 1 and one byte alignment is equivalent to no alignment.  If
 513  * you only want to adjust downward, specify a maximum that's the same as
 514  * the initial value.
 515  */
 516 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
 517                            unsigned int walign,
 518                            u32 *h, unsigned int hmin, unsigned int hmax,
 519                            unsigned int halign, unsigned int salign)
 520 {
 521         *w = clamp_align(*w, wmin, wmax, walign);
 522         *h = clamp_align(*h, hmin, hmax, halign);
 523
 524         /* Usually we don't need to align the size and are done now. */
 525         if (!salign)
 526                 return;
 527
 528         /* How much alignment do we have? */
 529         walign = __ffs(*w);
 530         halign = __ffs(*h);
 531         /* Enough to satisfy the image alignment? */
 532         if (walign + halign < salign) {
 533                 /* Max walign where there is still a valid width */
 534                 unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
 535                 /* Max halign where there is still a valid height */
 536                 unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
 537
 538                 /* up the smaller alignment until we have enough */
 539                 do {
 540                         if (halign >= hmaxa ||
 541                             (walign <= halign && walign < wmaxa)) {
 542                                 *w = clamp_align(*w, wmin, wmax, walign + 1);
 543                                 walign = __ffs(*w);
 544                         } else {
 545                                 *h = clamp_align(*h, hmin, hmax, halign + 1);
 546                                 halign = __ffs(*h);
 547                         }
 548                 } while (halign + walign < salign);
 549         }
 550 }
 551 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
 552
 553 /**
 554  * v4l_fill_dv_preset_info - fill description of a digital video preset
 555  * @preset - preset value
 556  * @info - pointer to struct v4l2_dv_enum_preset
 557  *
 558  * drivers can use this helper function to fill description of dv preset
 559  * in info.
 560  */
 561 int v4l_fill_dv_preset_info(u32 preset, struct v4l2_dv_enum_preset *info)
 562 {
 563         static const struct v4l2_dv_preset_info {
 564                 u16 width;
 565                 u16 height;
 566                 const char *name;
 567         } dv_presets[] = {
 568                 { 0, 0, "Invalid" },            /* V4L2_DV_INVALID */
 569                 { 720,  480, "480p@59.94" },    /* V4L2_DV_480P59_94 */
 570                 { 720,  576, "576p@50" },       /* V4L2_DV_576P50 */
 571                 { 1280, 720, "720p@24" },       /* V4L2_DV_720P24 */
 572                 { 1280, 720, "720p@25" },       /* V4L2_DV_720P25 */
 573                 { 1280, 720, "720p@30" },       /* V4L2_DV_720P30 */
 574                 { 1280, 720, "720p@50" },       /* V4L2_DV_720P50 */
 575                 { 1280, 720, "720p@59.94" },    /* V4L2_DV_720P59_94 */
 576                 { 1280, 720, "720p@60" },       /* V4L2_DV_720P60 */
 577                 { 1920, 1080, "1080i@29.97" },  /* V4L2_DV_1080I29_97 */
 578                 { 1920, 1080, "1080i@30" },     /* V4L2_DV_1080I30 */
 579                 { 1920, 1080, "1080i@25" },     /* V4L2_DV_1080I25 */
 580                 { 1920, 1080, "1080i@50" },     /* V4L2_DV_1080I50 */
 581                 { 1920, 1080, "1080i@60" },     /* V4L2_DV_1080I60 */
 582                 { 1920, 1080, "1080p@24" },     /* V4L2_DV_1080P24 */
 583                 { 1920, 1080, "1080p@25" },     /* V4L2_DV_1080P25 */
 584                 { 1920, 1080, "1080p@30" },     /* V4L2_DV_1080P30 */
 585                 { 1920, 1080, "1080p@50" },     /* V4L2_DV_1080P50 */
 586                 { 1920, 1080, "1080p@60" },     /* V4L2_DV_1080P60 */
 587         };
 588
 589         if (info == NULL || preset >= ARRAY_SIZE(dv_presets))
 590                 return -EINVAL;
 591
 592         info->preset = preset;
 593         info->width = dv_presets[preset].width;
 594         info->height = dv_presets[preset].height;
 595         strlcpy(info->name, dv_presets[preset].name, sizeof(info->name));
 596         return 0;
 597 }
 598 EXPORT_SYMBOL_GPL(v4l_fill_dv_preset_info);
 599
 600 const struct v4l2_frmsize_discrete *v4l2_find_nearest_format(
 601                 const struct v4l2_discrete_probe *probe,
 602                 s32 width, s32 height)
 603 {
 604         int i;
 605         u32 error, min_error = UINT_MAX;
 606         const struct v4l2_frmsize_discrete *size, *best = NULL;
 607
 608         if (!probe)
 609                 return best;
 610
 611         for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) {
 612                 error = abs(size->width - width) + abs(size->height - height);
 613                 if (error < min_error) {
 614                         min_error = error;
 615                         best = size;
 616                 }
 617                 if (!error)
 618                         break;
 619         }
 620
 621         return best;
 622 }
 623 EXPORT_SYMBOL_GPL(v4l2_find_nearest_format);