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