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 an 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[0]) 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 /** 601 * v4l_match_dv_timings - check if two timings match 602 * @t1 - compare this v4l2_dv_timings struct... 603 * @t2 - with this struct. 604 * @pclock_delta - the allowed pixelclock deviation. 605 * 606 * Compare t1 with t2 with a given margin of error for the pixelclock. 607 */ 608 bool v4l_match_dv_timings(const struct v4l2_dv_timings *t1, 609 const struct v4l2_dv_timings *t2, 610 unsigned pclock_delta) 611 { 612 if (t1->type != t2->type || t1->type != V4L2_DV_BT_656_1120) 613 return false; 614 if (t1->bt.width == t2->bt.width && 615 t1->bt.height == t2->bt.height && 616 t1->bt.interlaced == t2->bt.interlaced && 617 t1->bt.polarities == t2->bt.polarities && 618 t1->bt.pixelclock >= t2->bt.pixelclock - pclock_delta && 619 t1->bt.pixelclock <= t2->bt.pixelclock + pclock_delta && 620 t1->bt.hfrontporch == t2->bt.hfrontporch && 621 t1->bt.vfrontporch == t2->bt.vfrontporch && 622 t1->bt.vsync == t2->bt.vsync && 623 t1->bt.vbackporch == t2->bt.vbackporch && 624 (!t1->bt.interlaced || 625 (t1->bt.il_vfrontporch == t2->bt.il_vfrontporch && 626 t1->bt.il_vsync == t2->bt.il_vsync && 627 t1->bt.il_vbackporch == t2->bt.il_vbackporch))) 628 return true; 629 return false; 630 } 631 EXPORT_SYMBOL_GPL(v4l_match_dv_timings); 632 633 /* 634 * CVT defines 635 * Based on Coordinated Video Timings Standard 636 * version 1.1 September 10, 2003 637 */ 638 639 #define CVT_PXL_CLK_GRAN 250000 /* pixel clock granularity */ 640 641 /* Normal blanking */ 642 #define CVT_MIN_V_BPORCH 7 /* lines */ 643 #define CVT_MIN_V_PORCH_RND 3 /* lines */ 644 #define CVT_MIN_VSYNC_BP 550 /* min time of vsync + back porch (us) */ 645 646 /* Normal blanking for CVT uses GTF to calculate horizontal blanking */ 647 #define CVT_CELL_GRAN 8 /* character cell granularity */ 648 #define CVT_M 600 /* blanking formula gradient */ 649 #define CVT_C 40 /* blanking formula offset */ 650 #define CVT_K 128 /* blanking formula scaling factor */ 651 #define CVT_J 20 /* blanking formula scaling factor */ 652 #define CVT_C_PRIME (((CVT_C - CVT_J) * CVT_K / 256) + CVT_J) 653 #define CVT_M_PRIME (CVT_K * CVT_M / 256) 654 655 /* Reduced Blanking */ 656 #define CVT_RB_MIN_V_BPORCH 7 /* lines */ 657 #define CVT_RB_V_FPORCH 3 /* lines */ 658 #define CVT_RB_MIN_V_BLANK 460 /* us */ 659 #define CVT_RB_H_SYNC 32 /* pixels */ 660 #define CVT_RB_H_BPORCH 80 /* pixels */ 661 #define CVT_RB_H_BLANK 160 /* pixels */ 662 663 /** v4l2_detect_cvt - detect if the given timings follow the CVT standard 664 * @frame_height - the total height of the frame (including blanking) in lines. 665 * @hfreq - the horizontal frequency in Hz. 666 * @vsync - the height of the vertical sync in lines. 667 * @polarities - the horizontal and vertical polarities (same as struct 668 * v4l2_bt_timings polarities). 669 * @fmt - the resulting timings. 670 * 671 * This function will attempt to detect if the given values correspond to a 672 * valid CVT format. If so, then it will return true, and fmt will be filled 673 * in with the found CVT timings. 674 */ 675 bool v4l2_detect_cvt(unsigned frame_height, unsigned hfreq, unsigned vsync, 676 u32 polarities, struct v4l2_dv_timings *fmt) 677 { 678 int v_fp, v_bp, h_fp, h_bp, hsync; 679 int frame_width, image_height, image_width; 680 bool reduced_blanking; 681 unsigned pix_clk; 682 683 if (vsync < 4 || vsync > 7) 684 return false; 685 686 if (polarities == V4L2_DV_VSYNC_POS_POL) 687 reduced_blanking = false; 688 else if (polarities == V4L2_DV_HSYNC_POS_POL) 689 reduced_blanking = true; 690 else 691 return false; 692 693 /* Vertical */ 694 if (reduced_blanking) { 695 v_fp = CVT_RB_V_FPORCH; 696 v_bp = (CVT_RB_MIN_V_BLANK * hfreq + 999999) / 1000000; 697 v_bp -= vsync + v_fp; 698 699 if (v_bp < CVT_RB_MIN_V_BPORCH) 700 v_bp = CVT_RB_MIN_V_BPORCH; 701 } else { 702 v_fp = CVT_MIN_V_PORCH_RND; 703 v_bp = (CVT_MIN_VSYNC_BP * hfreq + 999999) / 1000000 - vsync; 704 705 if (v_bp < CVT_MIN_V_BPORCH) 706 v_bp = CVT_MIN_V_BPORCH; 707 } 708 image_height = (frame_height - v_fp - vsync - v_bp + 1) & ~0x1; 709 710 /* Aspect ratio based on vsync */ 711 switch (vsync) { 712 case 4: 713 image_width = (image_height * 4) / 3; 714 break; 715 case 5: 716 image_width = (image_height * 16) / 9; 717 break; 718 case 6: 719 image_width = (image_height * 16) / 10; 720 break; 721 case 7: 722 /* special case */ 723 if (image_height == 1024) 724 image_width = (image_height * 5) / 4; 725 else if (image_height == 768) 726 image_width = (image_height * 15) / 9; 727 else 728 return false; 729 break; 730 default: 731 return false; 732 } 733 734 image_width = image_width & ~7; 735 736 /* Horizontal */ 737 if (reduced_blanking) { 738 pix_clk = (image_width + CVT_RB_H_BLANK) * hfreq; 739 pix_clk = (pix_clk / CVT_PXL_CLK_GRAN) * CVT_PXL_CLK_GRAN; 740 741 h_bp = CVT_RB_H_BPORCH; 742 hsync = CVT_RB_H_SYNC; 743 h_fp = CVT_RB_H_BLANK - h_bp - hsync; 744 745 frame_width = image_width + CVT_RB_H_BLANK; 746 } else { 747 int h_blank; 748 unsigned ideal_duty_cycle = CVT_C_PRIME - (CVT_M_PRIME * 1000) / hfreq; 749 750 h_blank = (image_width * ideal_duty_cycle + (100 - ideal_duty_cycle) / 2) / 751 (100 - ideal_duty_cycle); 752 h_blank = h_blank - h_blank % (2 * CVT_CELL_GRAN); 753 754 if (h_blank * 100 / image_width < 20) { 755 h_blank = image_width / 5; 756 h_blank = (h_blank + 0x7) & ~0x7; 757 } 758 759 pix_clk = (image_width + h_blank) * hfreq; 760 pix_clk = (pix_clk / CVT_PXL_CLK_GRAN) * CVT_PXL_CLK_GRAN; 761 762 h_bp = h_blank / 2; 763 frame_width = image_width + h_blank; 764 765 hsync = (frame_width * 8 + 50) / 100; 766 hsync = hsync - hsync % CVT_CELL_GRAN; 767 h_fp = h_blank - hsync - h_bp; 768 } 769 770 fmt->bt.polarities = polarities; 771 fmt->bt.width = image_width; 772 fmt->bt.height = image_height; 773 fmt->bt.hfrontporch = h_fp; 774 fmt->bt.vfrontporch = v_fp; 775 fmt->bt.hsync = hsync; 776 fmt->bt.vsync = vsync; 777 fmt->bt.hbackporch = frame_width - image_width - h_fp - hsync; 778 fmt->bt.vbackporch = frame_height - image_height - v_fp - vsync; 779 fmt->bt.pixelclock = pix_clk; 780 fmt->bt.standards = V4L2_DV_BT_STD_CVT; 781 if (reduced_blanking) 782 fmt->bt.flags |= V4L2_DV_FL_REDUCED_BLANKING; 783 return true; 784 } 785 EXPORT_SYMBOL_GPL(v4l2_detect_cvt); 786 787 /* 788 * GTF defines 789 * Based on Generalized Timing Formula Standard 790 * Version 1.1 September 2, 1999 791 */ 792 793 #define GTF_PXL_CLK_GRAN 250000 /* pixel clock granularity */ 794 795 #define GTF_MIN_VSYNC_BP 550 /* min time of vsync + back porch (us) */ 796 #define GTF_V_FP 1 /* vertical front porch (lines) */ 797 #define GTF_CELL_GRAN 8 /* character cell granularity */ 798 799 /* Default */ 800 #define GTF_D_M 600 /* blanking formula gradient */ 801 #define GTF_D_C 40 /* blanking formula offset */ 802 #define GTF_D_K 128 /* blanking formula scaling factor */ 803 #define GTF_D_J 20 /* blanking formula scaling factor */ 804 #define GTF_D_C_PRIME ((((GTF_D_C - GTF_D_J) * GTF_D_K) / 256) + GTF_D_J) 805 #define GTF_D_M_PRIME ((GTF_D_K * GTF_D_M) / 256) 806 807 /* Secondary */ 808 #define GTF_S_M 3600 /* blanking formula gradient */ 809 #define GTF_S_C 40 /* blanking formula offset */ 810 #define GTF_S_K 128 /* blanking formula scaling factor */ 811 #define GTF_S_J 35 /* blanking formula scaling factor */ 812 #define GTF_S_C_PRIME ((((GTF_S_C - GTF_S_J) * GTF_S_K) / 256) + GTF_S_J) 813 #define GTF_S_M_PRIME ((GTF_S_K * GTF_S_M) / 256) 814 815 /** v4l2_detect_gtf - detect if the given timings follow the GTF standard 816 * @frame_height - the total height of the frame (including blanking) in lines. 817 * @hfreq - the horizontal frequency in Hz. 818 * @vsync - the height of the vertical sync in lines. 819 * @polarities - the horizontal and vertical polarities (same as struct 820 * v4l2_bt_timings polarities). 821 * @aspect - preferred aspect ratio. GTF has no method of determining the 822 * aspect ratio in order to derive the image width from the 823 * image height, so it has to be passed explicitly. Usually 824 * the native screen aspect ratio is used for this. If it 825 * is not filled in correctly, then 16:9 will be assumed. 826 * @fmt - the resulting timings. 827 * 828 * This function will attempt to detect if the given values correspond to a 829 * valid GTF format. If so, then it will return true, and fmt will be filled 830 * in with the found GTF timings. 831 */ 832 bool v4l2_detect_gtf(unsigned frame_height, 833 unsigned hfreq, 834 unsigned vsync, 835 u32 polarities, 836 struct v4l2_fract aspect, 837 struct v4l2_dv_timings *fmt) 838 { 839 int pix_clk; 840 int v_fp, v_bp, h_fp, h_bp, hsync; 841 int frame_width, image_height, image_width; 842 bool default_gtf; 843 int h_blank; 844 845 if (vsync != 3) 846 return false; 847 848 if (polarities == V4L2_DV_VSYNC_POS_POL) 849 default_gtf = true; 850 else if (polarities == V4L2_DV_HSYNC_POS_POL) 851 default_gtf = false; 852 else 853 return false; 854 855 /* Vertical */ 856 v_fp = GTF_V_FP; 857 v_bp = (GTF_MIN_VSYNC_BP * hfreq + 999999) / 1000000 - vsync; 858 image_height = (frame_height - v_fp - vsync - v_bp + 1) & ~0x1; 859 860 if (aspect.numerator == 0 || aspect.denominator == 0) { 861 aspect.numerator = 16; 862 aspect.denominator = 9; 863 } 864 image_width = ((image_height * aspect.numerator) / aspect.denominator); 865 866 /* Horizontal */ 867 if (default_gtf) 868 h_blank = ((image_width * GTF_D_C_PRIME * hfreq) - 869 (image_width * GTF_D_M_PRIME * 1000) + 870 (hfreq * (100 - GTF_D_C_PRIME) + GTF_D_M_PRIME * 1000) / 2) / 871 (hfreq * (100 - GTF_D_C_PRIME) + GTF_D_M_PRIME * 1000); 872 else 873 h_blank = ((image_width * GTF_S_C_PRIME * hfreq) - 874 (image_width * GTF_S_M_PRIME * 1000) + 875 (hfreq * (100 - GTF_S_C_PRIME) + GTF_S_M_PRIME * 1000) / 2) / 876 (hfreq * (100 - GTF_S_C_PRIME) + GTF_S_M_PRIME * 1000); 877 878 h_blank = h_blank - h_blank % (2 * GTF_CELL_GRAN); 879 frame_width = image_width + h_blank; 880 881 pix_clk = (image_width + h_blank) * hfreq; 882 pix_clk = pix_clk / GTF_PXL_CLK_GRAN * GTF_PXL_CLK_GRAN; 883 884 hsync = (frame_width * 8 + 50) / 100; 885 hsync = hsync - hsync % GTF_CELL_GRAN; 886 887 h_fp = h_blank / 2 - hsync; 888 h_bp = h_blank / 2; 889 890 fmt->bt.polarities = polarities; 891 fmt->bt.width = image_width; 892 fmt->bt.height = image_height; 893 fmt->bt.hfrontporch = h_fp; 894 fmt->bt.vfrontporch = v_fp; 895 fmt->bt.hsync = hsync; 896 fmt->bt.vsync = vsync; 897 fmt->bt.hbackporch = frame_width - image_width - h_fp - hsync; 898 fmt->bt.vbackporch = frame_height - image_height - v_fp - vsync; 899 fmt->bt.pixelclock = pix_clk; 900 fmt->bt.standards = V4L2_DV_BT_STD_GTF; 901 if (!default_gtf) 902 fmt->bt.flags |= V4L2_DV_FL_REDUCED_BLANKING; 903 return true; 904 } 905 EXPORT_SYMBOL_GPL(v4l2_detect_gtf); 906 907 /** v4l2_calc_aspect_ratio - calculate the aspect ratio based on bytes 908 * 0x15 and 0x16 from the EDID. 909 * @hor_landscape - byte 0x15 from the EDID. 910 * @vert_portrait - byte 0x16 from the EDID. 911 * 912 * Determines the aspect ratio from the EDID. 913 * See VESA Enhanced EDID standard, release A, rev 2, section 3.6.2: 914 * "Horizontal and Vertical Screen Size or Aspect Ratio" 915 */ 916 struct v4l2_fract v4l2_calc_aspect_ratio(u8 hor_landscape, u8 vert_portrait) 917 { 918 struct v4l2_fract aspect = { 16, 9 }; 919 u32 tmp; 920 u8 ratio; 921 922 /* Nothing filled in, fallback to 16:9 */ 923 if (!hor_landscape && !vert_portrait) 924 return aspect; 925 /* Both filled in, so they are interpreted as the screen size in cm */ 926 if (hor_landscape && vert_portrait) { 927 aspect.numerator = hor_landscape; 928 aspect.denominator = vert_portrait; 929 return aspect; 930 } 931 /* Only one is filled in, so interpret them as a ratio: 932 (val + 99) / 100 */ 933 ratio = hor_landscape | vert_portrait; 934 /* Change some rounded values into the exact aspect ratio */ 935 if (ratio == 79) { 936 aspect.numerator = 16; 937 aspect.denominator = 9; 938 } else if (ratio == 34) { 939 aspect.numerator = 4; 940 aspect.numerator = 3; 941 } else if (ratio == 68) { 942 aspect.numerator = 15; 943 aspect.numerator = 9; 944 } else { 945 aspect.numerator = hor_landscape + 99; 946 aspect.denominator = 100; 947 } 948 if (hor_landscape) 949 return aspect; 950 /* The aspect ratio is for portrait, so swap numerator and denominator */ 951 tmp = aspect.denominator; 952 aspect.denominator = aspect.numerator; 953 aspect.numerator = tmp; 954 return aspect; 955 } 956 EXPORT_SYMBOL_GPL(v4l2_calc_aspect_ratio); 957 958 const struct v4l2_frmsize_discrete *v4l2_find_nearest_format( 959 const struct v4l2_discrete_probe *probe, 960 s32 width, s32 height) 961 { 962 int i; 963 u32 error, min_error = UINT_MAX; 964 const struct v4l2_frmsize_discrete *size, *best = NULL; 965 966 if (!probe) 967 return best; 968 969 for (i = 0, size = probe->sizes; i < probe->num_sizes; i++, size++) { 970 error = abs(size->width - width) + abs(size->height - height); 971 if (error < min_error) { 972 min_error = error; 973 best = size; 974 } 975 if (!error) 976 break; 977 } 978 979 return best; 980 } 981 EXPORT_SYMBOL_GPL(v4l2_find_nearest_format); 982