microdia-sysfs.c

   1 /**
   2  * @file microdia-sysfs.c
   3  * @author Nicolas VIVIEN
   4  * @date 2008-02-01
   5  * @version v0.0.0
   6  *
   7  * @brief Driver for Microdia USB video camera
   8  *
   9  * @note Copyright (C) Nicolas VIVIEN
  10  *
  11  * @par Licences
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/kernel.h>
  31 #include <linux/version.h>
  32 #include <linux/errno.h>
  33 #include <linux/slab.h>
  34 #include <linux/kref.h>
  35 #include <linux/device.h>
  36
  37 #include <linux/usb.h>
  38 #include <media/v4l2-common.h>
  39
  40 #include "microdia.h"
  41 #include "sn9c20x.h"
  42
  43 /**
  44  * @brief show_release
  45  *
  46  * @param class Class device
  47  *
  48  * @retval buf Adress of buffer with the 'release' value
  49  *
  50  * @returns Size of buffer
  51  */
  52 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
  53 static ssize_t show_release(struct class_device *class, char *buf)
  54 #else
  55 static ssize_t show_release(struct device *class, struct device_attribute *attr, char *buf)
  56 #endif
  57 {
  58         struct video_device *vdev = to_video_device(class);
  59         struct usb_microdia *dev = video_get_drvdata(vdev);
  60
  61         return sprintf(buf, "%d\n", dev->release);
  62 }
  63
  64
  65 /**
  66  * @brief show_videostatus
  67  *
  68  * @param class Class device
  69  *
  70  * @retval buf Adress of buffer with the 'videostatus' value
  71  *
  72  * @returns Size of buffer
  73  */
  74 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
  75 static ssize_t show_videostatus(struct class_device *class, char *buf)
  76 #else
  77 static ssize_t show_videostatus(struct device *class, struct device_attribute *attr, char *buf)
  78 #endif
  79 {
  80         struct video_device *vdev = to_video_device(class);
  81         struct usb_microdia *dev = video_get_drvdata(vdev);
  82
  83         return sprintf(buf,
  84                 "Overflow frames    : %d\n"
  85                 "Incomplete frames  : %d\n"
  86                 "Dropped frames     : %d\n",
  87                 dev->vframes_overflow,
  88                 dev->vframes_incomplete,
  89                 dev->vframes_dropped);
  90 }
  91
  92
  93 /**
  94  * @brief show_informations
  95  *
  96  * @param class Class device
  97  *
  98  * @retval buf Adress of buffer with the 'informations' value
  99  *
 100  * @returns Size of buffer
 101  */
 102 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 103 static ssize_t show_informations(struct class_device *class, char *buf)
 104 #else
 105 static ssize_t show_informations(struct device *class, struct device_attribute *attr, char *buf)
 106 #endif
 107 {
 108         char *pixelfmt = NULL;
 109
 110         struct video_device *vdev = to_video_device(class);
 111         struct usb_microdia *dev = video_get_drvdata(vdev);
 112
 113         char *palette_bgr24 = "BGR24 - BGR-8-8-8 - 24 bits";
 114         char *palette_rgb24 = "RGB24 - RGB-8-8-8 - 24 bits";
 115         char *palette_yuyv = "YUYV - YUV 4:2:2 - 16 bits";
 116         char *palette_i420 = "I420 - YUV 4:2:0 - 12 bits";
 117
 118
 119         switch (dev->vsettings.format.pixelformat) {
 120         case V4L2_PIX_FMT_BGR24:
 121                 pixelfmt = palette_bgr24;
 122                 break;
 123
 124         case V4L2_PIX_FMT_RGB24:
 125                 pixelfmt = palette_rgb24;
 126                 break;
 127
 128         case V4L2_PIX_FMT_YUYV:
 129                 pixelfmt = palette_yuyv;
 130                 break;
 131
 132         case V4L2_PIX_FMT_YUV420:
 133                 pixelfmt = palette_i420;
 134                 break;
 135         }
 136
 137         return sprintf(buf,
 138                         "Driver Resolution : %dx%d\n"
 139                         "\n"
 140                         "%s\n"
 141                         "\n"
 142                         "Brightness        : 0x%X\n"
 143                         "Contrast          : 0x%X\n"
 144                         "Whiteness         : 0x%X\n"
 145                         "Exposure          : 0x%X\n"
 146                         "Sharpness         : 0x%X\n"
 147                         "Horizontal flip   : %d\n"
 148                         "Vertical flip     : %d\n"
 149                         "Auto-exposure     : %d\n"
 150                         "Auto-whitebalance : %d\n",
 151                         dev->vsettings.format.width,
 152                         dev->vsettings.format.height,
 153                         pixelfmt,
 154                         0xFFFF & dev->vsettings.brightness,
 155                         0xFFFF & dev->vsettings.contrast,
 156                         0xFFFF & dev->vsettings.whiteness,
 157                         0xFFFF & dev->vsettings.exposure,
 158                         0x3F & dev->vsettings.sharpness,
 159                         dev->vsettings.hflip,
 160                         dev->vsettings.vflip,
 161                         dev->vsettings.auto_exposure,
 162                         dev->vsettings.auto_whitebalance);
 163 }
 164
 165
 166 /**
 167  * @brief show_fps
 168  *
 169  * @param class Class device
 170  *
 171  * @retval buf Adress of buffer with the 'fps' value
 172  *
 173  * @returns Size of buffer
 174  */
 175 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 176 static ssize_t show_fps(struct class_device *class, char *buf)
 177 #else
 178 static ssize_t show_fps(struct device *class, struct device_attribute *attr, char *buf)
 179 #endif
 180 {
 181         struct video_device *vdev = to_video_device(class);
 182         struct usb_microdia *dev = video_get_drvdata(vdev);
 183
 184         return sprintf(buf, "%d\n", dev->vsettings.fps);
 185 }
 186
 187 /**
 188  * @brief show_rgb_gain
 189  *
 190  * @param class Class device
 191  *
 192  * @retval buf Address of buffer with the 'rgb_gain' value
 193  *
 194  * @returns Size of buffer
 195  */
 196 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 197 static ssize_t show_rgb_gain(struct class_device *class, char *buf)
 198 #else
 199 static ssize_t show_rgb_gain(struct device *class,
 200         struct device_attribute *attr, char *buf)
 201 #endif
 202 {
 203         int rgb_gain = 0;
 204
 205         struct video_device *vdev = to_video_device(class);
 206         struct usb_microdia *dev = video_get_drvdata(vdev);
 207         rgb_gain |= dev->vsettings.rgb_gain[0] << 16;
 208         rgb_gain |= dev->vsettings.rgb_gain[1] << 8;
 209         rgb_gain |= dev->vsettings.rgb_gain[3];
 210         return sprintf(buf, "0x%06X\n", rgb_gain);
 211 }
 212
 213 /**
 214  * @brief store_exposure
 215  *
 216  * @param class Class device
 217  * @param buf Buffer
 218  * @param count Counter
 219  *
 220  * @returns Size of buffer
 221  */
 222 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 223 static ssize_t store_rgb_gain(struct class_device *class,
 224         const char *buf, size_t count)
 225 #else
 226 static ssize_t store_rgb_gain(struct device *class,
 227         struct device_attribute *attr, const char *buf, size_t count)
 228 #endif
 229 {
 230         char *endp;
 231         unsigned long rgb_gain;
 232
 233         struct video_device *vdev = to_video_device(class);
 234         struct usb_microdia *dev = video_get_drvdata(vdev);
 235
 236         rgb_gain = simple_strtoul(buf, &endp, 16);
 237
 238         dev->vsettings.rgb_gain[0] = (rgb_gain >> 16) & 0x7f;
 239         dev->vsettings.rgb_gain[1] = (rgb_gain >> 8) & 0x7f;
 240         dev->vsettings.rgb_gain[2] = (rgb_gain >> 8) & 0x7f;
 241         dev->vsettings.rgb_gain[3] = rgb_gain & 0x7f;
 242
 243         dev_microdia_camera_set_rgb_gain(dev);
 244
 245         return strlen(buf);
 246 }
 247
 248 /**
 249  * @brief show_exposure
 250  *
 251  * @param class Class device
 252  *
 253  * @retval buf Adress of buffer with the 'exposure' value
 254  *
 255  * @returns Size of buffer
 256  */
 257 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 258 static ssize_t show_exposure(struct class_device *class, char *buf)
 259 #else
 260 static ssize_t show_exposure(struct device *class, struct device_attribute *attr, char *buf)
 261 #endif
 262 {
 263         struct video_device *vdev = to_video_device(class);
 264         struct usb_microdia *dev = video_get_drvdata(vdev);
 265
 266         return sprintf(buf, "%X\n", dev->vsettings.exposure);
 267 }
 268
 269 /**
 270  * @brief store_exposure
 271  *
 272  * @param class Class device
 273  * @param buf Buffer
 274  * @param count Counter
 275  *
 276  * @returns Size of buffer
 277  */
 278 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 279 static ssize_t store_exposure(struct class_device *class, const char *buf, size_t count)
 280 #else
 281 static ssize_t store_exposure(struct device *class, struct device_attribute *attr,
 282                 const char *buf, size_t count)
 283 #endif
 284 {
 285         char *endp;
 286         unsigned long value;
 287
 288         struct video_device *vdev = to_video_device(class);
 289         struct usb_microdia *dev = video_get_drvdata(vdev);
 290
 291         value = simple_strtoul(buf, &endp, 16);
 292
 293         dev->vsettings.exposure = (int) value;
 294
 295         dev_microdia_camera_set_exposure(dev);
 296
 297         return strlen(buf);
 298 }
 299
 300 /**
 301  * @brief show_brightness
 302  *
 303  * @param class Class device
 304  *
 305  * @retval buf Adress of buffer with the 'brightness' value
 306  *
 307  * @returns Size of buffer
 308  */
 309 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 310 static ssize_t show_brightness(struct class_device *class, char *buf)
 311 #else
 312 static ssize_t show_brightness(struct device *class, struct device_attribute *attr, char *buf)
 313 #endif
 314 {
 315         struct video_device *vdev = to_video_device(class);
 316         struct usb_microdia *dev = video_get_drvdata(vdev);
 317
 318         return sprintf(buf, "%X\n", dev->vsettings.brightness);
 319 }
 320
 321 /**
 322  * @brief store_brightness
 323  *
 324  * @param class Class device
 325  * @param buf Buffer
 326  * @param count Counter
 327  *
 328  * @returns Size of buffer
 329  */
 330 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 331 static ssize_t store_brightness(struct class_device *class, const char *buf, size_t count)
 332 #else
 333 static ssize_t store_brightness(struct device *class, struct device_attribute *attr,
 334                 const char *buf, size_t count)
 335 #endif
 336 {
 337         char *endp;
 338         unsigned long value;
 339
 340         struct video_device *vdev = to_video_device(class);
 341         struct usb_microdia *dev = video_get_drvdata(vdev);
 342
 343         value = simple_strtoul(buf, &endp, 16);
 344
 345         dev->vsettings.brightness = (int) value;
 346
 347         dev_microdia_camera_set_brightness(dev);
 348
 349         return strlen(buf);
 350 }
 351
 352 /**
 353  * @brief show_contrast
 354  *
 355  * @param class Class device
 356  *
 357  * @retval buf Adress of buffer with the 'contrast' value
 358  *
 359  * @returns Size of buffer
 360  */
 361 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 362 static ssize_t show_contrast(struct class_device *class, char *buf)
 363 #else
 364 static ssize_t show_contrast(struct device *class, struct device_attribute *attr, char *buf)
 365 #endif
 366 {
 367         struct video_device *vdev = to_video_device(class);
 368         struct usb_microdia *dev = video_get_drvdata(vdev);
 369
 370         return sprintf(buf, "%X\n", dev->vsettings.contrast);
 371 }
 372
 373
 374 /**
 375  * @brief store_contrast
 376  *
 377  * @param class Class device
 378  * @param buf Buffer
 379  * @param count Counter
 380  *
 381  * @returns Size of buffer
 382  */
 383 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 384 static ssize_t store_contrast(struct class_device *class, const char *buf, size_t count)
 385 #else
 386 static ssize_t store_contrast(struct device *class, struct device_attribute *attr,
 387                 const char *buf, size_t count)
 388 #endif
 389 {
 390         char *endp;
 391         unsigned long value;
 392
 393         struct video_device *vdev = to_video_device(class);
 394         struct usb_microdia *dev = video_get_drvdata(vdev);
 395
 396         value = simple_strtoul(buf, &endp, 16);
 397
 398         dev->vsettings.contrast = (int) value;
 399
 400         dev_microdia_camera_set_contrast(dev);
 401 //      dev_microdia_set_camera_quality(dev);
 402
 403         return strlen(buf);
 404 }
 405
 406
 407 /**
 408  * @brief show_whitebalance
 409  *
 410  * @param class Class device
 411  *
 412  * @retval buf Adress of buffer with the 'whitebalance' value
 413  *
 414  * @returns Size of buffer
 415  */
 416 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 417 static ssize_t show_whitebalance(struct class_device *class, char *buf)
 418 #else
 419 static ssize_t show_whitebalance(struct device *class, struct device_attribute *attr, char *buf)
 420 #endif
 421 {
 422         struct video_device *vdev = to_video_device(class);
 423         struct usb_microdia *dev = video_get_drvdata(vdev);
 424
 425         return sprintf(buf, "%X\n", dev->vsettings.whiteness);
 426 }
 427
 428
 429 /**
 430  * @brief store_whitebalance
 431  *
 432  * @param class Class device
 433  * @param buf Buffer
 434  * @param count Counter
 435  *
 436  * @returns Size of buffer
 437  */
 438 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 439 static ssize_t store_whitebalance(struct class_device *class, const char *buf, size_t count)
 440 #else
 441 static ssize_t store_whitebalance(struct device *class, struct device_attribute *attr,
 442                 const char *buf, size_t count)
 443 #endif
 444 {
 445         char *endp;
 446         unsigned long value;
 447
 448         struct video_device *vdev = to_video_device(class);
 449         struct usb_microdia *dev = video_get_drvdata(vdev);
 450
 451         value = simple_strtoul(buf, &endp, 16);
 452
 453         dev->vsettings.whiteness = (int) value;
 454
 455         dev_microdia_camera_set_gamma(dev);
 456 //      dev_microdia_set_camera_quality(dev);
 457
 458         return strlen(buf);
 459 }
 460
 461
 462 /**
 463  * @brief show_colour
 464  *
 465  * @param class Class device
 466  *
 467  * @retval buf Adress of buffer with the 'colour' value
 468  *
 469  * @returns Size of buffer
 470  */
 471 /*#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 472 static ssize_t show_colour(struct class_device *class, char *buf)
 473 #else
 474 static ssize_t show_colour(struct device *class, struct device_attribute *attr, char *buf)
 475 #endif
 476 {
 477         struct video_device *vdev = to_video_device(class);
 478         struct usb_microdia *dev = video_get_drvdata(vdev);
 479
 480         return sprintf(buf, "%X\n", dev->vsettings.colour);
 481 }
 482 */
 483
 484 /**
 485  * @brief store_colour
 486  *
 487  * @param class Class device
 488  * @param buf Buffer
 489  * @param count Counter
 490  *
 491  * @returns Size of buffer
 492  */
 493 /*#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 494 static ssize_t store_colour(struct class_device *class, const char *buf, size_t count)
 495 #else
 496 static ssize_t store_colour(struct device *class, struct device_attribute *attr,
 497                 const char *buf, size_t count)
 498 #endif
 499 {
 500         char *endp;
 501         unsigned long value;
 502
 503         struct video_device *vdev = to_video_device(class);
 504         struct usb_microdia *dev = video_get_drvdata(vdev);
 505
 506         value = simple_strtoul(buf, &endp, 16);
 507
 508         dev->vsettings.colour = (int) value;
 509
 510 //      dev_microdia_set_camera_quality(dev);
 511
 512         return strlen(buf);
 513 }
 514 */
 515
 516
 517 /**
 518  * @brief show_sharpness
 519  *
 520  * @param class Class device
 521  *
 522  * @retval buf Adress of buffer with the 'sharpness' value
 523  *
 524  * @returns Size of buffer
 525  */
 526 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 527 static ssize_t show_sharpness(struct class_device *class, char *buf)
 528 #else
 529 static ssize_t show_sharpness(struct device *class, struct device_attribute *attr, char *buf)
 530 #endif
 531 {
 532         struct video_device *vdev = to_video_device(class);
 533         struct usb_microdia *dev = video_get_drvdata(vdev);
 534
 535         return sprintf(buf, "%X\n", dev->vsettings.sharpness);
 536 }
 537
 538 /**
 539  * @brief store_sharpness
 540  *
 541  * @param class Class device
 542  * @param buf Buffer
 543  * @param count Counter
 544  *
 545  * @returns Size of buffer
 546  */
 547 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 548 static ssize_t store_sharpness(struct class_device *class, const char *buf, size_t count)
 549 #else
 550 static ssize_t store_sharpness(struct device *class, struct device_attribute *attr,
 551                 const char *buf, size_t count)
 552 #endif
 553 {
 554         char *endp;
 555         unsigned long value;
 556
 557         struct video_device *vdev = to_video_device(class);
 558         struct usb_microdia *dev = video_get_drvdata(vdev);
 559
 560         value = simple_strtoul(buf, &endp, 16);
 561
 562         if (value < 0 || value > 0x3f)
 563                 return -EINVAL;
 564
 565         dev->vsettings.sharpness = (int) value;
 566
 567         dev_microdia_camera_set_sharpness(dev);
 568
 569         return strlen(buf);
 570 }
 571
 572
 573 /**
 574  * @brief show_hflip
 575  *
 576  * @param class Class device
 577  *
 578  * @retval buf Adress of buffer with the 'hflip' value
 579  *
 580  * @returns Size of buffer
 581  */
 582 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 583 static ssize_t show_hflip(struct class_device *class, char *buf)
 584 #else
 585 static ssize_t show_hflip(struct device *class, struct device_attribute *attr, char *buf)
 586 #endif
 587 {
 588         struct video_device *vdev = to_video_device(class);
 589         struct usb_microdia *dev = video_get_drvdata(vdev);
 590
 591         return sprintf(buf, "%d\n", dev->vsettings.hflip);
 592 }
 593
 594
 595 /**
 596  * @brief store_hflip
 597  *
 598  * @param class Class device
 599  * @param buf Buffer
 600  * @param count Counter
 601  *
 602  * @returns Size of buffer
 603  */
 604 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 605 static ssize_t store_hflip(struct class_device *class, const char *buf, size_t count)
 606 #else
 607 static ssize_t store_hflip(struct device *class, struct device_attribute *attr,
 608                 const char *buf, size_t count)
 609 #endif
 610 {
 611         struct video_device *vdev = to_video_device(class);
 612         struct usb_microdia *dev = video_get_drvdata(vdev);
 613
 614         if (strncmp(buf, "1", 1) == 0)
 615                 dev->vsettings.hflip = 1;
 616         else if (strncmp(buf, "0", 1) == 0)
 617                 dev->vsettings.hflip = 0;
 618         else
 619                 return -EINVAL;
 620
 621         dev_microdia_camera_set_hvflip(dev);
 622
 623         return strlen(buf);
 624 }
 625
 626
 627 /**
 628  * @brief show_vflip
 629  *
 630  * @param class Class device
 631  *
 632  * @retval buf Adress of buffer with the 'vflip' value
 633  *
 634  * @returns Size of buffer
 635  */
 636 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 637 static ssize_t show_vflip(struct class_device *class, char *buf)
 638 #else
 639 static ssize_t show_vflip(struct device *class, struct device_attribute *attr, char *buf)
 640 #endif
 641 {
 642         struct video_device *vdev = to_video_device(class);
 643         struct usb_microdia *dev = video_get_drvdata(vdev);
 644
 645         return sprintf(buf, "%d\n", dev->vsettings.vflip);
 646 }
 647
 648
 649 /**
 650  * @brief store_vflip
 651  *
 652  * @param class Class device
 653  * @param buf Buffer
 654  * @param count Counter
 655  *
 656  * @returns Size of buffer
 657  */
 658 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 659 static ssize_t store_vflip(struct class_device *class, const char *buf, size_t count)
 660 #else
 661 static ssize_t store_vflip(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
 662 #endif
 663 {
 664         struct video_device *vdev = to_video_device(class);
 665         struct usb_microdia *dev = video_get_drvdata(vdev);
 666
 667         if (strncmp(buf, "1", 1) == 0)
 668                 dev->vsettings.vflip = 1;
 669         else if (strncmp(buf, "0", 1) == 0)
 670                 dev->vsettings.vflip = 0;
 671         else
 672                 return -EINVAL;
 673
 674         dev_microdia_camera_set_hvflip(dev);
 675
 676         return strlen(buf);
 677 }
 678
 679
 680 /**
 681  * @brief show_autoexposure
 682  *
 683  * @param class Class device
 684  *
 685  * @retval buf Adress of buffer with the 'hflip' value
 686  *
 687  * @returns Size of buffer
 688  */
 689 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 690 static ssize_t show_autoexposure(struct class_device *class, char *buf)
 691 #else
 692 static ssize_t show_autoexposure(struct device *class, struct device_attribute *attr, char *buf)
 693 #endif
 694 {
 695         struct video_device *vdev = to_video_device(class);
 696         struct usb_microdia *dev = video_get_drvdata(vdev);
 697
 698         return sprintf(buf, "%d\n", dev->vsettings.auto_exposure);
 699 }
 700
 701
 702 /**
 703  * @brief store_autoexposure
 704  *
 705  * @param class Class device
 706  * @param buf Buffer
 707  * @param count Counter
 708  *
 709  * @returns Size of buffer
 710  */
 711 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 712 static ssize_t store_autoexposure(struct class_device *class, const char *buf, size_t count)
 713 #else
 714 static ssize_t store_autoexposure(struct device *class, struct device_attribute *attr,
 715                 const char *buf, size_t count)
 716 #endif
 717 {
 718         struct video_device *vdev = to_video_device(class);
 719         struct usb_microdia *dev = video_get_drvdata(vdev);
 720
 721         if (strncmp(buf, "1", 1) == 0)
 722                 dev->vsettings.auto_exposure = 1;
 723         else if (strncmp(buf, "0", 1) == 0)
 724                 dev->vsettings.auto_exposure = 0;
 725         else
 726                 return -EINVAL;
 727
 728         dev_microdia_camera_set_auto_exposure(dev);
 729
 730         return strlen(buf);
 731 }
 732
 733
 734 /**
 735  * @brief show_autowhitebalance
 736  *
 737  * @param class Class device
 738  *
 739  * @retval buf Adress of buffer with the 'vflip' value
 740  *
 741  * @returns Size of buffer
 742  */
 743 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 744 static ssize_t show_autowhitebalance(struct class_device *class, char *buf)
 745 #else
 746 static ssize_t show_autowhitebalance(struct device *class, struct device_attribute *attr, char *buf)
 747 #endif
 748 {
 749         struct video_device *vdev = to_video_device(class);
 750         struct usb_microdia *dev = video_get_drvdata(vdev);
 751
 752         return sprintf(buf, "%d\n", dev->vsettings.auto_whitebalance);
 753 }
 754
 755
 756 /**
 757  * @brief store_autowhitebalance
 758  *
 759  * @param class Class device
 760  * @param buf Buffer
 761  * @param count Counter
 762  *
 763  * @returns Size of buffer
 764  */
 765 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 766 static ssize_t store_autowhitebalance(struct class_device *class, const char *buf, size_t count)
 767 #else
 768 static ssize_t store_autowhitebalance(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
 769 #endif
 770 {
 771         struct video_device *vdev = to_video_device(class);
 772         struct usb_microdia *dev = video_get_drvdata(vdev);
 773
 774         if (strncmp(buf, "1", 1) == 0)
 775                 dev->vsettings.auto_whitebalance = 1;
 776         else if (strncmp(buf, "0", 1) == 0)
 777                 dev->vsettings.auto_whitebalance = 0;
 778         else
 779                 return -EINVAL;
 780
 781         dev_microdia_camera_set_auto_whitebalance(dev);
 782
 783         return strlen(buf);
 784 }
 785
 786 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 787 static CLASS_DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                                                         /**< Release value */
 788 static CLASS_DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                                         /**< Video status */
 789 static CLASS_DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                                       /**< Informations */
 790 static CLASS_DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                                                         /**< FPS value */
 791 static CLASS_DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);                     /**< Brightness value */
 792 static CLASS_DEVICE_ATTR(rgb_gain, S_IRUGO | S_IWUGO, show_rgb_gain, store_rgb_gain);                   /**< RGB Gain */
 793 static CLASS_DEVICE_ATTR(exposure, S_IRUGO | S_IWUGO, show_exposure, store_exposure);                   /**< Brightness exposure */
 794 static CLASS_DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                           /**< Contrast value */
 795 static CLASS_DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);       /**< Whitebalance value */
 796 static CLASS_DEVICE_ATTR(sharpness, S_IRUGO | S_IWUGO, show_sharpness, store_sharpness);                /**< Sharpness value */
 797 //static CLASS_DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                                               /**< Hue value */
 798 static CLASS_DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                                            /**< Horizontal flip value */
 799 static CLASS_DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                                            /**< Vertical flip value */
 800 static CLASS_DEVICE_ATTR(auto_exposure, S_IRUGO | S_IWUGO, show_autoexposure, store_autoexposure);                      /**< Automatic exposure control value */
 801 static CLASS_DEVICE_ATTR(auto_whitebalance, S_IRUGO | S_IWUGO, show_autowhitebalance, store_autowhitebalance);          /**< Automatic whitebalance control value */
 802 #else
 803 static DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                                                                       /**< Release value */
 804 static DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                                                       /**< Video status */
 805 static DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                                                     /**< Informations */
 806 static DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                                                                       /**< FPS value */
 807 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);                           /**< Brightness value */
 808 static DEVICE_ATTR(rgb_gain, S_IRUGO | S_IWUGO, show_rgb_gain, store_rgb_gain);                         /**< RGB Gain */
 809 static DEVICE_ATTR(exposure, S_IRUGO | S_IWUGO, show_exposure, store_exposure);                         /**< Exposure value */
 810 static DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                                         /**< Contrast value */
 811 static DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);                     /**< Whitebalance value */
 812 static DEVICE_ATTR(sharpness, S_IRUGO | S_IWUGO, show_sharpness, store_sharpness);                      /**< Sharpness value */
 813 //static DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                                                     /**< Hue value */
 814 static DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                                                  /**< Horizontal flip value */
 815 static DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                                                  /**< Vertical flip value */
 816 static DEVICE_ATTR(auto_exposure, S_IRUGO | S_IWUGO, show_autoexposure, store_autoexposure);                            /**< Automatic exposure control value */
 817 static DEVICE_ATTR(auto_whitebalance, S_IRUGO | S_IWUGO, show_autowhitebalance, store_autowhitebalance);                /**< Automatic whitebalance control value */
 818 #endif
 819
 820
 821 /**
 822  * @brief Create the 'sys' entries.
 823  *
 824  * This function permits to create all the entries in the 'sys' filesystem.
 825  *
 826  * @param vdev Video device structure
 827  *
 828  * @returns 0 if all is OK
 829  */
 830 int microdia_create_sysfs_files(struct video_device *vdev)
 831 {
 832         int ret;
 833
 834 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 835         ret = video_device_create_file(vdev, &class_device_attr_release);
 836         ret = video_device_create_file(vdev, &class_device_attr_videostatus);
 837         ret = video_device_create_file(vdev, &class_device_attr_informations);
 838         ret = video_device_create_file(vdev, &class_device_attr_fps);
 839         ret = video_device_create_file(vdev, &class_device_attr_brightness);
 840         ret = video_device_create_file(vdev, &class_device_attr_rgb_gain);
 841         ret = video_device_create_file(vdev, &class_device_attr_exposure);
 842         ret = video_device_create_file(vdev, &class_device_attr_contrast);
 843         ret = video_device_create_file(vdev, &class_device_attr_whitebalance);
 844         ret = video_device_create_file(vdev, &class_device_attr_sharpness);
 845         /*ret = video_device_create_file(vdev, &class_device_attr_colour);*/
 846         ret = video_device_create_file(vdev, &class_device_attr_hflip);
 847         ret = video_device_create_file(vdev, &class_device_attr_vflip);
 848         ret = video_device_create_file(vdev, &class_device_attr_auto_exposure);
 849         ret = video_device_create_file(vdev, &class_device_attr_auto_whitebalance);
 850 #else
 851         ret = video_device_create_file(vdev, &dev_attr_release);
 852         ret = video_device_create_file(vdev, &dev_attr_videostatus);
 853         ret = video_device_create_file(vdev, &dev_attr_informations);
 854         ret = video_device_create_file(vdev, &dev_attr_fps);
 855         ret = video_device_create_file(vdev, &dev_attr_brightness);
 856         ret = video_device_create_file(vdev, &dev_attr_rgb_gain);
 857         ret = video_device_create_file(vdev, &dev_attr_exposure);
 858         ret = video_device_create_file(vdev, &dev_attr_contrast);
 859         ret = video_device_create_file(vdev, &dev_attr_whitebalance);
 860         ret = video_device_create_file(vdev, &dev_attr_sharpness);
 861         /*ret = video_device_create_file(vdev, &dev_attr_colour);*/
 862         ret = video_device_create_file(vdev, &dev_attr_hflip);
 863         ret = video_device_create_file(vdev, &dev_attr_vflip);
 864         ret = video_device_create_file(vdev, &dev_attr_auto_exposure);
 865         ret = video_device_create_file(vdev, &dev_attr_auto_whitebalance);
 866 #endif
 867         return ret;
 868 }
 869
 870
 871 /**
 872  * @brief Remove the 'sys' entries.
 873  *
 874  * This function permits to remove all the entries in the 'sys' filesystem.
 875  *
 876  * @param vdev Video device structure
 877  *
 878  * @returns 0 if all is OK
 879  */
 880 void microdia_remove_sysfs_files(struct video_device *vdev)
 881 {
 882 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 883         video_device_remove_file(vdev, &class_device_attr_release);
 884         video_device_remove_file(vdev, &class_device_attr_videostatus);
 885         video_device_remove_file(vdev, &class_device_attr_informations);
 886         video_device_remove_file(vdev, &class_device_attr_fps);
 887         video_device_remove_file(vdev, &class_device_attr_brightness);
 888         video_device_remove_file(vdev, &class_device_attr_exposure);
 889         video_device_remove_file(vdev, &class_device_attr_rgb_gain);
 890         video_device_remove_file(vdev, &class_device_attr_contrast);
 891         video_device_remove_file(vdev, &class_device_attr_whitebalance);
 892         video_device_remove_file(vdev, &class_device_attr_sharpness);
 893         /*video_device_remove_file(vdev, &class_device_attr_colour);*/
 894         video_device_remove_file(vdev, &class_device_attr_hflip);
 895         video_device_remove_file(vdev, &class_device_attr_vflip);
 896         video_device_remove_file(vdev, &class_device_attr_auto_exposure);
 897         video_device_remove_file(vdev, &class_device_attr_auto_whitebalance);
 898 #else
 899         video_device_remove_file(vdev, &dev_attr_release);
 900         video_device_remove_file(vdev, &dev_attr_videostatus);
 901         video_device_remove_file(vdev, &dev_attr_informations);
 902         video_device_remove_file(vdev, &dev_attr_fps);
 903         video_device_remove_file(vdev, &dev_attr_brightness);
 904         video_device_remove_file(vdev, &dev_attr_rgb_gain);
 905         video_device_remove_file(vdev, &dev_attr_exposure);
 906         video_device_remove_file(vdev, &dev_attr_contrast);
 907         video_device_remove_file(vdev, &dev_attr_whitebalance);
 908         video_device_remove_file(vdev, &dev_attr_sharpness);
 909         /*video_device_remove_file(vdev, &dev_attr_colour);*/
 910         video_device_remove_file(vdev, &dev_attr_hflip);
 911         video_device_remove_file(vdev, &dev_attr_vflip);
 912         video_device_remove_file(vdev, &dev_attr_auto_exposure);
 913         video_device_remove_file(vdev, &dev_attr_auto_whitebalance);
 914 #endif
 915 }
 916