stk11xx-sysfs.c

Go to the documentation of this file.

 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/version.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/kref.h>
#include <linux/device.h>
#include <linux/mm.h>
 
 
#include <linux/usb.h>
#include <media/v4l2-common.h>
#include <media/v4l2-ioctl.h>
 
#include "stk11xx.h"
 
 
extern const struct stk11xx_coord stk11xx_image_sizes[STK11XX_NBR_SIZES];
 
 
static ssize_t show_release(struct device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr, char *buf)
{
    int width, height;
    char *pixelfmt = NULL;
 
    struct video_device *vdev = to_video_device(class);
    struct usb_stk11xx *dev = video_get_drvdata(vdev);
 
    char *palette_rgb24 = "RGB24 - RGB-8-8-8 - 24 bits";
    char *palette_rgb32 = "RGB32 - RGB-8-8-8-8 - 32 bits";
    char *palette_bgr24 = "BGR24 - BGR-8-8-8 - 24 bits";
    char *palette_bgr32 = "BGR32 - BGR-8-8-8-8 - 32 bits";
    char *palette_uyvy = "UYVY - YUV 4:2:2 - 16 bits";
    char *palette_yuyv = "YUYV - YUV 4:2:2 - 16 bits";
 
 
    switch (dev->vsettings.palette) {
        case STK11XX_PALETTE_RGB24:
            pixelfmt = palette_rgb24;
            break;
 
        case STK11XX_PALETTE_RGB32:
            pixelfmt = palette_rgb32;
            break;
 
        case STK11XX_PALETTE_BGR24:
            pixelfmt = palette_bgr24;
            break;
 
        case STK11XX_PALETTE_BGR32:
            pixelfmt = palette_bgr32;
            break;
 
        case STK11XX_PALETTE_UYVY:
            pixelfmt = palette_uyvy;
            break;
 
        case STK11XX_PALETTE_YUYV:
            pixelfmt = palette_yuyv;
            break;
    }
 
    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_720x576:
            width = stk11xx_image_sizes[STK11XX_720x576].x;
            height = stk11xx_image_sizes[STK11XX_720x576].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"
            "%s\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,
            pixelfmt,
            0xFFFF & dev->vsettings.brightness,
            0xFFFF & dev->vsettings.contrast,
            0xFFFF & dev->vsettings.whiteness,
            0xFFFF & dev->vsettings.colour);
}
 
 
static ssize_t show_fps(struct device *class, struct device_attribute *attr, 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.fps);
}
 
 
static ssize_t show_brightness(struct device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr, 
        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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr,
        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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr,
        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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr,
        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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr,
        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 device *class, struct device_attribute *attr, 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 device *class, struct device_attribute *attr, 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 DEVICE_ATTR(release, S_IRUGO, show_release, NULL);                                           
static DEVICE_ATTR(videostatus, S_IRUGO, show_videostatus, NULL);                                   
static DEVICE_ATTR(informations, S_IRUGO, show_informations, NULL);                                 
static DEVICE_ATTR(fps, S_IRUGO, show_fps, NULL);                                                   
static DEVICE_ATTR(brightness, S_IRUGO | S_IWUGO, show_brightness, store_brightness);               
static DEVICE_ATTR(contrast, S_IRUGO | S_IWUGO, show_contrast, store_contrast);                     
static DEVICE_ATTR(whitebalance, S_IRUGO | S_IWUGO, show_whitebalance, store_whitebalance);         
static DEVICE_ATTR(colour, S_IRUGO | S_IWUGO, show_colour, store_colour);                           
static DEVICE_ATTR(hflip, S_IRUGO | S_IWUGO, show_hflip, store_hflip);                              
static DEVICE_ATTR(vflip, S_IRUGO | S_IWUGO, show_vflip, store_vflip);                              
int stk11xx_create_sysfs_files(struct video_device *vdev)
{
    int ret;
 
    ret = device_create_file(&vdev->dev, &dev_attr_release);
    ret = device_create_file(&vdev->dev, &dev_attr_videostatus);
    ret = device_create_file(&vdev->dev, &dev_attr_informations);
    ret = device_create_file(&vdev->dev, &dev_attr_fps);
    ret = device_create_file(&vdev->dev, &dev_attr_brightness);
    ret = device_create_file(&vdev->dev, &dev_attr_contrast);
    ret = device_create_file(&vdev->dev, &dev_attr_whitebalance);
    ret = device_create_file(&vdev->dev, &dev_attr_colour);
    ret = device_create_file(&vdev->dev, &dev_attr_hflip);
    ret = device_create_file(&vdev->dev, &dev_attr_vflip);
 
    return ret;
}
 
 
void stk11xx_remove_sysfs_files(struct video_device *vdev)
{
    device_remove_file(&vdev->dev, &dev_attr_release);
    device_remove_file(&vdev->dev, &dev_attr_videostatus);
    device_remove_file(&vdev->dev, &dev_attr_informations);
    device_remove_file(&vdev->dev, &dev_attr_fps);
    device_remove_file(&vdev->dev, &dev_attr_brightness);
    device_remove_file(&vdev->dev, &dev_attr_contrast);
    device_remove_file(&vdev->dev, &dev_attr_whitebalance);
    device_remove_file(&vdev->dev, &dev_attr_colour);
    device_remove_file(&vdev->dev, &dev_attr_hflip);
    device_remove_file(&vdev->dev, &dev_attr_vflip);
}