stk11xx-sysfs.c

Go to the documentation of this file.

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/kref.h>
#include <linux/device.h>

#include <linux/usb.h>
#include <media/v4l2-common.h>

#include "stk11xx.h"


extern const struct stk11xx_coord stk11xx_image_sizes[STK11XX_NBR_SIZES];


static ssize_t show_release(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%d\n", dev->release);
}


static ssize_t show_videostatus(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf,
            "Nbr ISOC errors    : %d\n"
            "Nbr dropped frames : %d\n"
            "Nbr dumped frames  : %d\n",
            dev->visoc_errors,
            dev->vframes_error,
            dev->vframes_dumped);
}


static ssize_t show_informations(struct class_device *class, char *buf)
{
    int width, height;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);


    switch (dev->resolution) {
        case STK11XX_80x60:
        case STK11XX_128x96:
        case STK11XX_160x120:
        case STK11XX_213x160:
        case STK11XX_320x240:
        case STK11XX_640x480:
            width = stk11xx_image_sizes[STK11XX_640x480].x;
            height = stk11xx_image_sizes[STK11XX_640x480].y;
            break;

        case STK11XX_800x600:
        case STK11XX_1024x768:
        case STK11XX_1280x1024:
            width = stk11xx_image_sizes[STK11XX_1280x1024].x;
            height = stk11xx_image_sizes[STK11XX_1280x1024].y;
            break;

        default:
            width = 0;
            height = 0;
    }

    return sprintf(buf,
            "Asked resolution  : %dx%d\n"
            "Driver resolution : %dx%d\n"
            "Webcam resolution : %dx%d\n"
            "\n"
            "Brightness        : 0x%X\n"
            "Contrast          : 0x%X\n"
            "Whiteness         : 0x%X\n"
            "Colour            : 0x%X\n",
            dev->view.x, dev->view.y,
            stk11xx_image_sizes[dev->resolution].x, stk11xx_image_sizes[dev->resolution].y,
            width, height,
            0xFFFF & dev->vsettings.brightness,
            0xFFFF & dev->vsettings.contrast,
            0xFFFF & dev->vsettings.whiteness,
            0xFFFF & dev->vsettings.colour);
}


static ssize_t show_brightness(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%X\n", dev->vsettings.brightness);
}


static ssize_t store_brightness(struct class_device *class, const char *buf, size_t count)
{
    char *endp;
    unsigned long value;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    value = simple_strtoul(buf, &endp, 16);

    dev->vsettings.brightness = (int) value;

    dev_stk11xx_set_camera_quality(dev);

    return strlen(buf);
}

static ssize_t show_contrast(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%X\n", dev->vsettings.contrast);
}


static ssize_t store_contrast(struct class_device *class, const char *buf, size_t count)
{
    char *endp;
    unsigned long value;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    value = simple_strtoul(buf, &endp, 16);

    dev->vsettings.contrast = (int) value;

    dev_stk11xx_set_camera_quality(dev);

    return strlen(buf);
}


static ssize_t show_whitebalance(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%X\n", dev->vsettings.whiteness);
}


static ssize_t store_whitebalance(struct class_device *class, const char *buf, size_t count)
{
    char *endp;
    unsigned long value;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    value = simple_strtoul(buf, &endp, 16);

    dev->vsettings.whiteness = (int) value;

    dev_stk11xx_set_camera_quality(dev);

    return strlen(buf);
}


static ssize_t show_colour(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%X\n", dev->vsettings.colour);
}


static ssize_t store_colour(struct class_device *class, const char *buf, size_t count)
{
    char *endp;
    unsigned long value;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    value = simple_strtoul(buf, &endp, 16);

    dev->vsettings.colour = (int) value;

    dev_stk11xx_set_camera_quality(dev);

    return strlen(buf);
}


static ssize_t show_hflip(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%d\n", dev->vsettings.hflip);
}


static ssize_t store_hflip(struct class_device *class, const char *buf, size_t count)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    if (strncmp(buf, "1", 1) == 0)
        dev->vsettings.hflip = 1;
    else if (strncmp(buf, "0", 1) == 0)
        dev->vsettings.hflip = 0;
    else
        return -EINVAL;

    return strlen(buf);
}


static ssize_t show_vflip(struct class_device *class, char *buf)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    return sprintf(buf, "%d\n", dev->vsettings.vflip);
}


static ssize_t store_vflip(struct class_device *class, const char *buf, size_t count)
{
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    if (strncmp(buf, "1", 1) == 0)
        dev->vsettings.vflip = 1;
    else if (strncmp(buf, "0", 1) == 0)
        dev->vsettings.vflip = 0;
    else
        return -EINVAL;

    return strlen(buf);
}




static ssize_t runtest(struct class_device *class, const char *buf, size_t count)
{
    char *endp;
    unsigned long value;

    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);

    value = simple_strtoul(buf, &endp, 16);

    switch (value) {
        case 1:
            dev_stk11xx_set_camera_quality(dev);
            STK_INFO("1 run\n");
            break;

        case 2:
            dev_stk11xx_set_camera_fps(dev);
            STK_INFO("2 run\n");
            break;

        case 3:
            dev_stk11xx_camera_settings(dev);
            STK_INFO("3 run\n");
            break;
    }

    return strlen(buf);
}



static CLASS_DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                     
static CLASS_DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                             
static CLASS_DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                           
static CLASS_DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);         
static CLASS_DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);               
static CLASS_DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);   
static CLASS_DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                             
static CLASS_DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                        
static CLASS_DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                        
static CLASS_DEVICE_ATTR(test, S_IRUGO | S_IWUGO, NULL, runtest);


int stk11xx_create_sysfs_files(struct video_device *vdev)
{
    int ret;

    ret = video_device_create_file(vdev, &class_device_attr_release);
    ret = video_device_create_file(vdev, &class_device_attr_videostatus);
    ret = video_device_create_file(vdev, &class_device_attr_informations);
    ret = video_device_create_file(vdev, &class_device_attr_brightness);
    ret = video_device_create_file(vdev, &class_device_attr_contrast);
    ret = video_device_create_file(vdev, &class_device_attr_whitebalance);
    ret = video_device_create_file(vdev, &class_device_attr_colour);
    ret = video_device_create_file(vdev, &class_device_attr_hflip);
    ret = video_device_create_file(vdev, &class_device_attr_vflip);
    ret = video_device_create_file(vdev, &class_device_attr_test);

    return ret;
}


void stk11xx_remove_sysfs_files(struct video_device *vdev)
{
    video_device_remove_file(vdev, &class_device_attr_release);
    video_device_remove_file(vdev, &class_device_attr_videostatus);
    video_device_remove_file(vdev, &class_device_attr_informations);
    video_device_remove_file(vdev, &class_device_attr_brightness);
    video_device_remove_file(vdev, &class_device_attr_contrast);
    video_device_remove_file(vdev, &class_device_attr_whitebalance);
    video_device_remove_file(vdev, &class_device_attr_colour);
    video_device_remove_file(vdev, &class_device_attr_hflip);
    video_device_remove_file(vdev, &class_device_attr_vflip);
    video_device_remove_file(vdev, &class_device_attr_test);
}

---