stk11xx-sysfs.c

   1 /**
   2  * @file stk11xx-sysfs.c
   3  * @author Nicolas VIVIEN
   4  * @date 2006-10-23
   5  * @version v1.2.0
   6  *
   7  * @brief Driver for Syntek 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  * @par SubVersion
  28  *   $Date$
  29  *   $Revision$
  30  *   $Author$
  31  *   $HeadURL$
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/kernel.h>
  37 #include <linux/version.h>
  38 #include <linux/errno.h>
  39 #include <linux/slab.h>
  40 #include <linux/kref.h>
  41 #include <linux/device.h>
  42
  43 #include <linux/usb.h>
  44 #include <media/v4l2-common.h>
  45
  46 #include "stk11xx.h"
  47
  48
  49 extern const struct stk11xx_coord stk11xx_image_sizes[STK11XX_NBR_SIZES];
  50
  51
  52 /**
  53  * @brief show_release
  54  *
  55  * @param class Class device
  56  *
  57  * @retval buf Adress of buffer with the 'release' value
  58  *
  59  * @returns Size of buffer
  60  */
  61 static ssize_t show_release(struct class_device *class, char *buf)
  62 {
  63         struct video_device *vdev = to_video_device(class);
  64         struct usb_stk11xx *dev = video_get_drvdata(vdev);
  65
  66         return sprintf(buf, "%d\n", dev->release);
  67 }
  68
  69
  70 /**
  71  * @brief show_videostatus
  72  *
  73  * @param class Class device
  74  *
  75  * @retval buf Adress of buffer with the 'videostatus' value
  76  *
  77  * @returns Size of buffer
  78  */
  79 static ssize_t show_videostatus(struct class_device *class, char *buf)
  80 {
  81         struct video_device *vdev = to_video_device(class);
  82         struct usb_stk11xx *dev = video_get_drvdata(vdev);
  83
  84         return sprintf(buf,
  85                         "Nbr ISOC errors    : %d\n"
  86                         "Nbr dropped frames : %d\n"
  87                         "Nbr dumped frames  : %d\n",
  88                         dev->visoc_errors,
  89                         dev->vframes_error,
  90                         dev->vframes_dumped);
  91 }
  92
  93
  94 /**
  95  * @brief show_informations
  96  *
  97  * @param class Class device
  98  *
  99  * @retval buf Adress of buffer with the 'informations' value
 100  *
 101  * @returns Size of buffer
 102  */
 103 static ssize_t show_informations(struct class_device *class, char *buf)
 104 {
 105         int width, height;
 106         char *pixelfmt = NULL;
 107
 108         struct video_device *vdev = to_video_device(class);
 109         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 110
 111         char *palette_rgb24 = "RGB24 - RGB-8-8-8 - 24 bits";
 112         char *palette_rgb32 = "RGB32 - RGB-8-8-8-8 - 32 bits";
 113         char *palette_bgr24 = "BGR24 - BGR-8-8-8 - 24 bits";
 114         char *palette_bgr32 = "BGR32 - BGR-8-8-8-8 - 32 bits";
 115         char *palette_uyvy = "UYVY - YUV 4:2:2 - 16 bits";
 116         char *palette_yuyv = "YUYV - YUV 4:2:2 - 16 bits";
 117
 118
 119         switch (dev->vsettings.palette) {
 120                 case STK11XX_PALETTE_RGB24:
 121                         pixelfmt = palette_rgb24;
 122                         break;
 123
 124                 case STK11XX_PALETTE_RGB32:
 125                         pixelfmt = palette_rgb32;
 126                         break;
 127
 128                 case STK11XX_PALETTE_BGR24:
 129                         pixelfmt = palette_bgr24;
 130                         break;
 131
 132                 case STK11XX_PALETTE_BGR32:
 133                         pixelfmt = palette_bgr32;
 134                         break;
 135
 136                 case STK11XX_PALETTE_UYVY:
 137                         pixelfmt = palette_uyvy;
 138                         break;
 139
 140                 case STK11XX_PALETTE_YUYV:
 141                         pixelfmt = palette_yuyv;
 142                         break;
 143         }
 144
 145         switch (dev->resolution) {
 146                 case STK11XX_80x60:
 147                 case STK11XX_128x96:
 148                 case STK11XX_160x120:
 149                 case STK11XX_213x160:
 150                 case STK11XX_320x240:
 151                 case STK11XX_640x480:
 152                         width = stk11xx_image_sizes[STK11XX_640x480].x;
 153                         height = stk11xx_image_sizes[STK11XX_640x480].y;
 154                         break;
 155
 156                 case STK11XX_800x600:
 157                 case STK11XX_1024x768:
 158                 case STK11XX_1280x1024:
 159                         width = stk11xx_image_sizes[STK11XX_1280x1024].x;
 160                         height = stk11xx_image_sizes[STK11XX_1280x1024].y;
 161                         break;
 162
 163                 default:
 164                         width = 0;
 165                         height = 0;
 166         }
 167
 168         return sprintf(buf,
 169                         "Asked resolution  : %dx%d\n"
 170                         "Driver resolution : %dx%d\n"
 171                         "Webcam resolution : %dx%d\n"
 172                         "\n"
 173                         "%s\n"
 174                         "\n"
 175                         "Brightness        : 0x%X\n"
 176                         "Contrast          : 0x%X\n"
 177                         "Whiteness         : 0x%X\n"
 178                         "Colour            : 0x%X\n",
 179                         dev->view.x, dev->view.y,
 180                         stk11xx_image_sizes[dev->resolution].x, stk11xx_image_sizes[dev->resolution].y,
 181                         width, height,
 182                         pixelfmt,
 183                         0xFFFF & dev->vsettings.brightness,
 184                         0xFFFF & dev->vsettings.contrast,
 185                         0xFFFF & dev->vsettings.whiteness,
 186                         0xFFFF & dev->vsettings.colour);
 187 }
 188
 189
 190 /**
 191  * @brief show_fps
 192  *
 193  * @param class Class device
 194  *
 195  * @retval buf Adress of buffer with the 'fps' value
 196  *
 197  * @returns Size of buffer
 198  */
 199 static ssize_t show_fps(struct class_device *class, char *buf)
 200 {
 201         struct video_device *vdev = to_video_device(class);
 202         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 203
 204         return sprintf(buf, "%d\n", dev->vsettings.fps);
 205 }
 206
 207
 208 /**
 209  * @brief show_brightness
 210  *
 211  * @param class Class device
 212  *
 213  * @retval buf Adress of buffer with the 'brightness' value
 214  *
 215  * @returns Size of buffer
 216  */
 217 static ssize_t show_brightness(struct class_device *class, char *buf)
 218 {
 219         struct video_device *vdev = to_video_device(class);
 220         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 221
 222         return sprintf(buf, "%X\n", dev->vsettings.brightness);
 223 }
 224
 225
 226 /**
 227  * @brief store_brightness
 228  *
 229  * @param class Class device
 230  * @param buf Buffer
 231  * @param count Counter
 232  *
 233  * @returns Size of buffer
 234  */
 235 static ssize_t store_brightness(struct class_device *class, const char *buf, size_t count)
 236 {
 237         char *endp;
 238         unsigned long value;
 239
 240         struct video_device *vdev = to_video_device(class);
 241         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 242
 243         value = simple_strtoul(buf, &endp, 16);
 244
 245         dev->vsettings.brightness = (int) value;
 246
 247         dev_stk11xx_set_camera_quality(dev);
 248
 249         return strlen(buf);
 250 }
 251
 252 /**
 253  * @brief show_contrast
 254  *
 255  * @param class Class device
 256  *
 257  * @retval buf Adress of buffer with the 'contrast' value
 258  *
 259  * @returns Size of buffer
 260  */
 261 static ssize_t show_contrast(struct class_device *class, char *buf)
 262 {
 263         struct video_device *vdev = to_video_device(class);
 264         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 265
 266         return sprintf(buf, "%X\n", dev->vsettings.contrast);
 267 }
 268
 269
 270 /**
 271  * @brief store_contrast
 272  *
 273  * @param class Class device
 274  * @param buf Buffer
 275  * @param count Counter
 276  *
 277  * @returns Size of buffer
 278  */
 279 static ssize_t store_contrast(struct class_device *class, const char *buf, size_t count)
 280 {
 281         char *endp;
 282         unsigned long value;
 283
 284         struct video_device *vdev = to_video_device(class);
 285         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 286
 287         value = simple_strtoul(buf, &endp, 16);
 288
 289         dev->vsettings.contrast = (int) value;
 290
 291         dev_stk11xx_set_camera_quality(dev);
 292
 293         return strlen(buf);
 294 }
 295
 296
 297 /**
 298  * @brief show_whitebalance
 299  *
 300  * @param class Class device
 301  *
 302  * @retval buf Adress of buffer with the 'whitebalance' value
 303  *
 304  * @returns Size of buffer
 305  */
 306 static ssize_t show_whitebalance(struct class_device *class, char *buf)
 307 {
 308         struct video_device *vdev = to_video_device(class);
 309         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 310
 311         return sprintf(buf, "%X\n", dev->vsettings.whiteness);
 312 }
 313
 314
 315 /**
 316  * @brief store_whitebalance
 317  *
 318  * @param class Class device
 319  * @param buf Buffer
 320  * @param count Counter
 321  *
 322  * @returns Size of buffer
 323  */
 324 static ssize_t store_whitebalance(struct class_device *class, const char *buf, size_t count)
 325 {
 326         char *endp;
 327         unsigned long value;
 328
 329         struct video_device *vdev = to_video_device(class);
 330         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 331
 332         value = simple_strtoul(buf, &endp, 16);
 333
 334         dev->vsettings.whiteness = (int) value;
 335
 336         dev_stk11xx_set_camera_quality(dev);
 337
 338         return strlen(buf);
 339 }
 340
 341
 342 /**
 343  * @brief show_colour
 344  *
 345  * @param class Class device
 346  *
 347  * @retval buf Adress of buffer with the 'colour' value
 348  *
 349  * @returns Size of buffer
 350  */
 351 static ssize_t show_colour(struct class_device *class, char *buf)
 352 {
 353         struct video_device *vdev = to_video_device(class);
 354         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 355
 356         return sprintf(buf, "%X\n", dev->vsettings.colour);
 357 }
 358
 359
 360 /**
 361  * @brief store_colour
 362  *
 363  * @param class Class device
 364  * @param buf Buffer
 365  * @param count Counter
 366  *
 367  * @returns Size of buffer
 368  */
 369 static ssize_t store_colour(struct class_device *class, const char *buf, size_t count)
 370 {
 371         char *endp;
 372         unsigned long value;
 373
 374         struct video_device *vdev = to_video_device(class);
 375         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 376
 377         value = simple_strtoul(buf, &endp, 16);
 378
 379         dev->vsettings.colour = (int) value;
 380
 381         dev_stk11xx_set_camera_quality(dev);
 382
 383         return strlen(buf);
 384 }
 385
 386
 387 /**
 388  * @brief show_hflip
 389  *
 390  * @param class Class device
 391  *
 392  * @retval buf Adress of buffer with the 'hflip' value
 393  *
 394  * @returns Size of buffer
 395  */
 396 static ssize_t show_hflip(struct class_device *class, char *buf)
 397 {
 398         struct video_device *vdev = to_video_device(class);
 399         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 400
 401         return sprintf(buf, "%d\n", dev->vsettings.hflip);
 402 }
 403
 404
 405 /**
 406  * @brief store_hflip
 407  *
 408  * @param class Class device
 409  * @param buf Buffer
 410  * @param count Counter
 411  *
 412  * @returns Size of buffer
 413  */
 414 static ssize_t store_hflip(struct class_device *class, const char *buf, size_t count)
 415 {
 416         struct video_device *vdev = to_video_device(class);
 417         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 418
 419         if (strncmp(buf, "1", 1) == 0)
 420                 dev->vsettings.hflip = 1;
 421         else if (strncmp(buf, "0", 1) == 0)
 422                 dev->vsettings.hflip = 0;
 423         else
 424                 return -EINVAL;
 425
 426         return strlen(buf);
 427 }
 428
 429
 430 /**
 431  * @brief show_vflip
 432  *
 433  * @param class Class device
 434  *
 435  * @retval buf Adress of buffer with the 'vflip' value
 436  *
 437  * @returns Size of buffer
 438  */
 439 static ssize_t show_vflip(struct class_device *class, char *buf)
 440 {
 441         struct video_device *vdev = to_video_device(class);
 442         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 443
 444         return sprintf(buf, "%d\n", dev->vsettings.vflip);
 445 }
 446
 447
 448 /**
 449  * @brief store_vflip
 450  *
 451  * @param class Class device
 452  * @param buf Buffer
 453  * @param count Counter
 454  *
 455  * @returns Size of buffer
 456  */
 457 static ssize_t store_vflip(struct class_device *class, const char *buf, size_t count)
 458 {
 459         struct video_device *vdev = to_video_device(class);
 460         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 461
 462         if (strncmp(buf, "1", 1) == 0)
 463                 dev->vsettings.vflip = 1;
 464         else if (strncmp(buf, "0", 1) == 0)
 465                 dev->vsettings.vflip = 0;
 466         else
 467                 return -EINVAL;
 468
 469         return strlen(buf);
 470 }
 471
 472
 473
 474
 475 static ssize_t runtest(struct class_device *class, const char *buf, size_t count)
 476 {
 477         char *endp;
 478         unsigned long value;
 479
 480         struct video_device *vdev = to_video_device(class);
 481         struct usb_stk11xx *dev = video_get_drvdata(vdev);
 482
 483         value = simple_strtoul(buf, &endp, 16);
 484
 485         switch (value) {
 486                 case 1:
 487                         dev_stk11xx_set_camera_quality(dev);
 488                         STK_INFO("1 run\n");
 489                         break;
 490
 491                 case 2:
 492                         dev_stk11xx_set_camera_fps(dev);
 493                         STK_INFO("2 run\n");
 494                         break;
 495
 496                 case 3:
 497                         dev_stk11xx_camera_settings(dev);
 498                         STK_INFO("3 run\n");
 499                         break;
 500         }
 501
 502         return strlen(buf);
 503 }
 504
 505
 506
 507 static CLASS_DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                                                         /**< Release value */
 508 static CLASS_DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                                         /**< Video status */
 509 static CLASS_DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                                       /**< Informations */
 510 static CLASS_DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                                                         /**< FPS value */
 511 static CLASS_DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);                     /**< Brightness value */
 512 static CLASS_DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                           /**< Contrast value */
 513 static CLASS_DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);       /**< Whitebalance value */
 514 static CLASS_DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                                                         /**< Hue value */
 515 static CLASS_DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                                            /**< Horizontal filp value */
 516 static CLASS_DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                                            /**< Vertical filp value */
 517 static CLASS_DEVICE_ATTR(test, S_IRUGO | S_IWUGO, NULL, runtest);
 518
 519
 520 /**
 521  * @brief Create the 'sys' entries.
 522  *
 523  * This function permits to create all the entries in the 'sys' filesystem.
 524  *
 525  * @param vdev Video device structure
 526  *
 527  * @returns 0 if all is OK
 528  */
 529 int stk11xx_create_sysfs_files(struct video_device *vdev)
 530 {
 531         int ret;
 532
 533         ret = video_device_create_file(vdev, &class_device_attr_release);
 534         ret = video_device_create_file(vdev, &class_device_attr_videostatus);
 535         ret = video_device_create_file(vdev, &class_device_attr_informations);
 536         ret = video_device_create_file(vdev, &class_device_attr_fps);
 537         ret = video_device_create_file(vdev, &class_device_attr_brightness);
 538         ret = video_device_create_file(vdev, &class_device_attr_contrast);
 539         ret = video_device_create_file(vdev, &class_device_attr_whitebalance);
 540         ret = video_device_create_file(vdev, &class_device_attr_colour);
 541         ret = video_device_create_file(vdev, &class_device_attr_hflip);
 542         ret = video_device_create_file(vdev, &class_device_attr_vflip);
 543         ret = video_device_create_file(vdev, &class_device_attr_test);
 544
 545         return ret;
 546 }
 547
 548
 549 /**
 550  * @brief Remove the 'sys' entries.
 551  *
 552  * This function permits to remove all the entries in the 'sys' filesystem.
 553  *
 554  * @param vdev Video device structure
 555  *
 556  * @returns 0 if all is OK
 557  */
 558 void stk11xx_remove_sysfs_files(struct video_device *vdev)
 559 {
 560         video_device_remove_file(vdev, &class_device_attr_release);
 561         video_device_remove_file(vdev, &class_device_attr_videostatus);
 562         video_device_remove_file(vdev, &class_device_attr_informations);
 563         video_device_remove_file(vdev, &class_device_attr_fps);
 564         video_device_remove_file(vdev, &class_device_attr_brightness);
 565         video_device_remove_file(vdev, &class_device_attr_contrast);
 566         video_device_remove_file(vdev, &class_device_attr_whitebalance);
 567         video_device_remove_file(vdev, &class_device_attr_colour);
 568         video_device_remove_file(vdev, &class_device_attr_hflip);
 569         video_device_remove_file(vdev, &class_device_attr_vflip);
 570         video_device_remove_file(vdev, &class_device_attr_test);
 571 }
 572