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
 818 /**
 819  * @brief show_register adress
 820  *
 821  * @param class Class device
 822  *
 823  * @retval buf Adress of buffer with the 'register' value
 824  *
 825  * @returns Size of buffer
 826  */
 827 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 828 static ssize_t show_register(struct class_device *class, char *buf)
 829 #else
 830 static ssize_t show_register(struct device *class, struct device_attribute *attr, char *buf)
 831 #endif
 832 {
 833         __u8 buf1;
 834
 835         struct video_device *vdev = to_video_device(class);
 836         struct usb_microdia *dev = video_get_drvdata(vdev);
 837
 838         usb_microdia_control_read(dev, dev->vsettings.reg, &buf1, 1);
 839
 840         dev->vsettings.val = buf1;
 841
 842         return sprintf(buf, "0x%x = 0x%x\n",dev->vsettings.reg, dev->vsettings.val);
 843 }
 844
 845
 846 /**
 847  * @brief store_register
 848  *
 849  * @param class Class device
 850  * @param buf Buffer
 851  * @param count Counter
 852  *
 853  * @returns Size of buffer
 854  */
 855 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 856 static ssize_t store_register(struct class_device *class, const char *buf, size_t count)
 857 #else
 858 static ssize_t store_register(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
 859 #endif
 860 {
 861         char *endp;
 862         unsigned long value;
 863         __u8 buf1;
 864
 865         struct video_device *vdev = to_video_device(class);
 866         struct usb_microdia *dev = video_get_drvdata(vdev);
 867
 868         value = simple_strtoul(buf, &endp, 16);
 869
 870         dev->vsettings.val = (int) value;
 871         buf1 = dev->vsettings.val;
 872         usb_microdia_control_write(dev, dev->vsettings.reg, &buf1, 1);
 873
 874         return strlen(buf);
 875 }
 876
 877 /**
 878  * @brief show_adress
 879  *
 880  * @param class Class device
 881  *
 882  * @retval buf Buffer
 883  *
 884  * @returns Size of buffer
 885  */
 886 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 887 static ssize_t show_adress(struct class_device *class, char *buf)
 888 #else
 889 static ssize_t show_adress(struct device *class, struct device_attribute *attr, char *buf)
 890 #endif
 891 {
 892         struct video_device *vdev = to_video_device(class);
 893         struct usb_microdia *dev = video_get_drvdata(vdev);
 894
 895         return sprintf(buf, "0x%x\n", dev->vsettings.reg);
 896 }
 897
 898
 899 /**
 900  * @brief store_adress
 901  *
 902  * @param class Class device
 903  * @param buf Buffer
 904  * @param count Counter
 905  *
 906  * @returns Size of buffer
 907  */
 908 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 909 static ssize_t store_adress(struct class_device *class, const char *buf, size_t count)
 910 #else
 911 static ssize_t store_adress(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
 912 #endif
 913 {
 914         char *endp;
 915         unsigned long value;
 916
 917         struct video_device *vdev = to_video_device(class);
 918         struct usb_microdia *dev = video_get_drvdata(vdev);
 919
 920         value = simple_strtoul(buf, &endp, 16);
 921
 922         dev->vsettings.reg = (int) value;
 923
 924         return strlen(buf);
 925 }
 926
 927 /**
 928  * @brief show_i2cadr
 929  *
 930  * @param class Class device
 931  *
 932  * @retval buf Buffer
 933  *
 934  * @returns Size of buffer
 935  */
 936 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 937 static ssize_t show_i2cadr(struct class_device *class, char *buf)
 938 #else
 939 static ssize_t show_i2cadr(struct device *class, struct device_attribute *attr, char *buf)
 940 #endif
 941 {
 942         struct video_device *vdev = to_video_device(class);
 943         struct usb_microdia *dev = video_get_drvdata(vdev);
 944
 945         return sprintf(buf, "0x%x\n", dev->vsettings.i2creg);
 946 }
 947
 948
 949 /**
 950  * @brief store_i2cadr
 951  *
 952  * @param class Class device
 953  * @param buf Buffer
 954  * @param count Counter
 955  *
 956  * @returns Size of buffer
 957  */
 958 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 959 static ssize_t store_i2cadr(struct class_device *class, const char *buf, size_t count)
 960 #else
 961 static ssize_t store_i2cadr(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
 962 #endif
 963 {
 964         char *endp;
 965         unsigned long value;
 966
 967         struct video_device *vdev = to_video_device(class);
 968         struct usb_microdia *dev = video_get_drvdata(vdev);
 969
 970         value = simple_strtoul(buf, &endp, 16);
 971
 972         dev->vsettings.i2creg = (int) value;
 973
 974         return strlen(buf);
 975 }
 976
 977 /**
 978  * @brief show_i2creg adress
 979  *
 980  * @param class Class device
 981  *
 982  * @retval buf Buffer
 983  *
 984  * @returns Size of buffer
 985  */
 986 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 987 static ssize_t show_i2creg(struct class_device *class, char *buf)
 988 #else
 989 static ssize_t show_i2creg(struct device *class, struct device_attribute *attr, char *buf)
 990 #endif
 991 {
 992         __u8 buf1[8];
 993 //      __u8 sensor_slave_id = 0x30; /* slave ID currently hard coded !! */
 994         __u8 i2c_flags = SN9C20X_I2C_2WIRE;
 995
 996         struct video_device *vdev = to_video_device(class);
 997         struct usb_microdia *dev = video_get_drvdata(vdev);
 998
 999         sn9c20x_read_i2c_data(dev, dev->vsettings.i2cslave /*sensor_slave_id*/,
1000                          dev->vsettings.reg, dev->vsettings.i2creg, i2c_flags, buf1);
1001
1002         dev->vsettings.i2cval = buf1[0];
1003         return sprintf(buf, "I2C-register 0x%x = 0x%x 0x%x (%d)\n",
1004                                                                 dev->vsettings.i2creg,buf1[0],buf1[1],dev->vsettings.reg);
1005 //      return strlen(buf);
1006 }
1007
1008
1009 /**
1010  * @brief store_i2creg
1011  *
1012  * @param class Class device
1013  * @param buf Buffer
1014  * @param count Counter
1015  *
1016  * @returns Size of buffer
1017  */
1018 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1019 static ssize_t store_i2creg(struct class_device *class, const char *buf, size_t count)
1020 #else
1021 static ssize_t store_i2creg(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
1022 #endif
1023 {
1024         char *endp;
1025         unsigned long value;
1026
1027         __u8 buf1[5];
1028 //      __u8 sensor_slave_id = 0x30; /* slave ID currently hard coded !! */
1029         __u8 i2c_flags = SN9C20X_I2C_2WIRE;
1030
1031         struct video_device *vdev = to_video_device(class);
1032         struct usb_microdia *dev = video_get_drvdata(vdev);
1033
1034         value = simple_strtoul(buf, &endp, 16);
1035
1036         dev->vsettings.i2cval = (int) value;
1037         buf1[0] = ((dev->vsettings.i2cval & 0xff00) >> 8);
1038         buf1[1] = (dev->vsettings.i2cval & 0xFF);
1039         buf1[2] = 0;
1040         buf1[3] = 0;
1041         buf1[4] = 0;
1042
1043         sn9c20x_write_i2c_data(dev,dev->vsettings.i2cslave /*sensor_slave_id*/,
1044                         dev->vsettings.reg, dev->vsettings.i2creg, i2c_flags, buf1);
1045 //      sprintf(buf, "store_i2creg: set I2C-reg. 0x%x to 0x%x 0x%x (%d)\n",
1046 //                                              dev->vsettings.i2creg,buf1[0],buf1[1],dev->vsettings.reg);
1047         return strlen(buf);
1048 }
1049
1050
1051 /**
1052  * @brief store_i2c_slave_adr
1053  *
1054  * @param class Class device
1055  * @param buf Buffer
1056  * @param count Counter
1057  *
1058  * @returns Size of buffer
1059  */
1060 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1061 static ssize_t store_i2c_slave_adr(struct class_device *class, const char *buf, size_t count)
1062 #else
1063 static ssize_t store_i2c_slave_adr(struct device *class, struct device_attribute *attr, const char *buf, size_t count)
1064 #endif
1065 {
1066         char *endp;
1067         unsigned long value;
1068
1069         struct video_device *vdev = to_video_device(class);
1070         struct usb_microdia *dev = video_get_drvdata(vdev);
1071
1072         value = simple_strtoul(buf, &endp, 16);
1073
1074         dev->vsettings.i2cslave = (int) value;
1075
1076         return strlen(buf);
1077 }
1078
1079
1080 /**
1081  * @brief show_i2c_slave_adr
1082  *
1083  * @param class Class device
1084  *
1085  * @retval buf Buffer
1086  *
1087  * @returns Size of buffer
1088  */
1089 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1090 static ssize_t show_i2c_slave_adr(struct class_device *class, char *buf)
1091 #else
1092 static ssize_t show_i2c_slave_adr(struct device *class, struct device_attribute *attr, char *buf)
1093 #endif
1094 {
1095         struct video_device *vdev = to_video_device(class);
1096         struct usb_microdia *dev = video_get_drvdata(vdev);
1097
1098         return sprintf(buf, "0x%x\n", dev->vsettings.i2cslave);
1099 }
1100
1101
1102
1103
1104 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1105 static CLASS_DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                                                         /**< Release value */
1106 static CLASS_DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                                         /**< Video status */
1107 static CLASS_DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                                       /**< Informations */
1108 static CLASS_DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                                                         /**< FPS value */
1109 static CLASS_DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);                     /**< Brightness value */
1110 static CLASS_DEVICE_ATTR(rgb_gain, S_IRUGO | S_IWUGO, show_rgb_gain, store_rgb_gain);                   /**< RGB Gain */
1111 static CLASS_DEVICE_ATTR(exposure, S_IRUGO | S_IWUGO, show_exposure, store_exposure);                   /**< Brightness exposure */
1112 static CLASS_DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                           /**< Contrast value */
1113 static CLASS_DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);       /**< Whitebalance value */
1114 static CLASS_DEVICE_ATTR(sharpness, S_IRUGO | S_IWUGO, show_sharpness, store_sharpness);                /**< Sharpness value */
1115 //static CLASS_DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                                               /**< Hue value */
1116 static CLASS_DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                                            /**< Horizontal flip value */
1117 static CLASS_DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                                            /**< Vertical flip value */
1118 static CLASS_DEVICE_ATTR(auto_exposure, S_IRUGO | S_IWUGO, show_autoexposure, store_autoexposure);                      /**< Automatic exposure control value */
1119 static CLASS_DEVICE_ATTR(auto_whitebalance, S_IRUGO | S_IWUGO, show_autowhitebalance, store_autowhitebalance);          /**< Automatic whitebalance control value */
1120 static CLASS_DEVICE_ATTR(adr, S_IRUGO | S_IWUGO, show_adress, store_adress);                            /**< Register adress */
1121 static CLASS_DEVICE_ATTR(reg, S_IRUGO | S_IWUGO, show_register, store_register);                                /**< Register value */
1122 static CLASS_DEVICE_ATTR(i2cadr, S_IRUGO | S_IWUGO, show_i2cadr, store_i2cadr);                         /**< I2C Register adress */
1123 static CLASS_DEVICE_ATTR(i2creg, S_IRUGO | S_IWUGO, show_i2creg, store_i2creg);                         /**< I2C Register value */
1124 static CLASS_DEVICE_ATTR(i2cslave, S_IRUGO | S_IWUGO, show_i2c_slave_adr, store_i2c_slave_adr);                         /**< I2C Slave adress */
1125 #else
1126 static DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                                                                       /**< Release value */
1127 static DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                                                       /**< Video status */
1128 static DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                                                     /**< Informations */
1129 static DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                                                                       /**< FPS value */
1130 static DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);                           /**< Brightness value */
1131 static DEVICE_ATTR(rgb_gain, S_IRUGO | S_IWUGO, show_rgb_gain, store_rgb_gain);                         /**< RGB Gain */
1132 static DEVICE_ATTR(exposure, S_IRUGO | S_IWUGO, show_exposure, store_exposure);                         /**< Exposure value */
1133 static DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                                         /**< Contrast value */
1134 static DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);                     /**< Whitebalance value */
1135 static DEVICE_ATTR(sharpness, S_IRUGO | S_IWUGO, show_sharpness, store_sharpness);                      /**< Sharpness value */
1136 //static DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                                                     /**< Hue value */
1137 static DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                                                  /**< Horizontal flip value */
1138 static DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                                                  /**< Vertical flip value */
1139 static DEVICE_ATTR(auto_exposure, S_IRUGO | S_IWUGO, show_autoexposure, store_autoexposure);                            /**< Automatic exposure control value */
1140 static DEVICE_ATTR(auto_whitebalance, S_IRUGO | S_IWUGO, show_autowhitebalance, store_autowhitebalance);                /**< Automatic whitebalance control value */
1141 static DEVICE_ATTR(adr, S_IRUGO | S_IWUGO, show_adress, store_adress);                                          /**< Register adress */
1142 static DEVICE_ATTR(reg, S_IRUGO | S_IWUGO, show_register, store_register);                                              /**< Register value */
1143 static DEVICE_ATTR(i2cadr, S_IRUGO | S_IWUGO, show_i2cadr, store_i2cadr);                                               /**< I2C Register adress */
1144 static DEVICE_ATTR(i2creg, S_IRUGO | S_IWUGO, show_i2creg, store_i2creg);                                               /**< I2C Register value */
1145 static DEVICE_ATTR(i2cslave, S_IRUGO | S_IWUGO, show_i2c_slave_adr, store_i2c_slave_adr);                                               /**< I2C Slave adress */
1146 #endif
1147
1148
1149 /**
1150  * @brief Create the 'sys' entries.
1151  *
1152  * This function permits to create all the entries in the 'sys' filesystem.
1153  *
1154  * @param vdev Video device structure
1155  *
1156  * @returns 0 if all is OK
1157  */
1158 int microdia_create_sysfs_files(struct video_device *vdev)
1159 {
1160         int ret;
1161
1162 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1163         ret = video_device_create_file(vdev, &class_device_attr_release);
1164         ret = video_device_create_file(vdev, &class_device_attr_videostatus);
1165         ret = video_device_create_file(vdev, &class_device_attr_informations);
1166         ret = video_device_create_file(vdev, &class_device_attr_fps);
1167         ret = video_device_create_file(vdev, &class_device_attr_brightness);
1168         ret = video_device_create_file(vdev, &class_device_attr_rgb_gain);
1169         ret = video_device_create_file(vdev, &class_device_attr_exposure);
1170         ret = video_device_create_file(vdev, &class_device_attr_contrast);
1171         ret = video_device_create_file(vdev, &class_device_attr_whitebalance);
1172         ret = video_device_create_file(vdev, &class_device_attr_sharpness);
1173         /*ret = video_device_create_file(vdev, &class_device_attr_colour);*/
1174         ret = video_device_create_file(vdev, &class_device_attr_hflip);
1175         ret = video_device_create_file(vdev, &class_device_attr_vflip);
1176         ret = video_device_create_file(vdev, &class_device_attr_auto_exposure);
1177         ret = video_device_create_file(vdev, &class_device_attr_auto_whitebalance);
1178         ret = video_device_create_file(vdev, &class_device_attr_reg);
1179         ret = video_device_create_file(vdev, &class_device_attr_adr);
1180         ret = video_device_create_file(vdev, &class_device_attr_i2creg);
1181         ret = video_device_create_file(vdev, &class_device_attr_i2cadr);
1182         ret = video_device_create_file(vdev, &class_device_attr_i2cslave);
1183 #else
1184         ret = video_device_create_file(vdev, &dev_attr_release);
1185         ret = video_device_create_file(vdev, &dev_attr_videostatus);
1186         ret = video_device_create_file(vdev, &dev_attr_informations);
1187         ret = video_device_create_file(vdev, &dev_attr_fps);
1188         ret = video_device_create_file(vdev, &dev_attr_brightness);
1189         ret = video_device_create_file(vdev, &dev_attr_rgb_gain);
1190         ret = video_device_create_file(vdev, &dev_attr_exposure);
1191         ret = video_device_create_file(vdev, &dev_attr_contrast);
1192         ret = video_device_create_file(vdev, &dev_attr_whitebalance);
1193         ret = video_device_create_file(vdev, &dev_attr_sharpness);
1194         /*ret = video_device_create_file(vdev, &dev_attr_colour);*/
1195         ret = video_device_create_file(vdev, &dev_attr_hflip);
1196         ret = video_device_create_file(vdev, &dev_attr_vflip);
1197         ret = video_device_create_file(vdev, &dev_attr_auto_exposure);
1198         ret = video_device_create_file(vdev, &dev_attr_auto_whitebalance);
1199         ret = video_device_create_file(vdev, &dev_attr_reg);
1200         ret = video_device_create_file(vdev, &dev_attr_adr);
1201         ret = video_device_create_file(vdev, &dev_attr_i2creg);
1202         ret = video_device_create_file(vdev, &dev_attr_i2cadr);
1203         ret = video_device_create_file(vdev, &dev_attr_i2cslave);
1204 #endif
1205         return ret;
1206 }
1207
1208
1209 /**
1210  * @brief Remove the 'sys' entries.
1211  *
1212  * This function permits to remove all the entries in the 'sys' filesystem.
1213  *
1214  * @param vdev Video device structure
1215  *
1216  * @returns 0 if all is OK
1217  */
1218 void microdia_remove_sysfs_files(struct video_device *vdev)
1219 {
1220 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
1221         video_device_remove_file(vdev, &class_device_attr_release);
1222         video_device_remove_file(vdev, &class_device_attr_videostatus);
1223         video_device_remove_file(vdev, &class_device_attr_informations);
1224         video_device_remove_file(vdev, &class_device_attr_fps);
1225         video_device_remove_file(vdev, &class_device_attr_brightness);
1226         video_device_remove_file(vdev, &class_device_attr_exposure);
1227         video_device_remove_file(vdev, &class_device_attr_rgb_gain);
1228         video_device_remove_file(vdev, &class_device_attr_contrast);
1229         video_device_remove_file(vdev, &class_device_attr_whitebalance);
1230         video_device_remove_file(vdev, &class_device_attr_sharpness);
1231         /*video_device_remove_file(vdev, &class_device_attr_colour);*/
1232         video_device_remove_file(vdev, &class_device_attr_hflip);
1233         video_device_remove_file(vdev, &class_device_attr_vflip);
1234         video_device_remove_file(vdev, &class_device_attr_auto_exposure);
1235         video_device_remove_file(vdev, &class_device_attr_auto_whitebalance);
1236         video_device_remove_file(vdev, &class_device_attr_reg);
1237         video_device_remove_file(vdev, &class_device_attr_adr);
1238         video_device_remove_file(vdev, &class_device_attr_i2creg);
1239         video_device_remove_file(vdev, &class_device_attr_i2cadr);
1240         video_device_remove_file(vdev, &class_device_attr_i2cslave);
1241 #else
1242         video_device_remove_file(vdev, &dev_attr_release);
1243         video_device_remove_file(vdev, &dev_attr_videostatus);
1244         video_device_remove_file(vdev, &dev_attr_informations);
1245         video_device_remove_file(vdev, &dev_attr_fps);
1246         video_device_remove_file(vdev, &dev_attr_brightness);
1247         video_device_remove_file(vdev, &dev_attr_rgb_gain);
1248         video_device_remove_file(vdev, &dev_attr_exposure);
1249         video_device_remove_file(vdev, &dev_attr_contrast);
1250         video_device_remove_file(vdev, &dev_attr_whitebalance);
1251         video_device_remove_file(vdev, &dev_attr_sharpness);
1252         /*video_device_remove_file(vdev, &dev_attr_colour);*/
1253         video_device_remove_file(vdev, &dev_attr_hflip);
1254         video_device_remove_file(vdev, &dev_attr_vflip);
1255         video_device_remove_file(vdev, &dev_attr_auto_exposure);
1256         video_device_remove_file(vdev, &dev_attr_auto_whitebalance);
1257         video_device_remove_file(vdev, &dev_attr_reg);
1258         video_device_remove_file(vdev, &dev_attr_adr);
1259         video_device_remove_file(vdev, &dev_attr_i2creg);
1260         video_device_remove_file(vdev, &dev_attr_i2cadr);
1261         video_device_remove_file(vdev, &dev_attr_i2cslave);
1262 #endif
1263 }
1264