airsensor.c

/************************************************************************/
/* Kerneltreiber fuer den Luftqualitaetsstick                           */
/* Im Rahmen der Veranstaltung Embedded Systems bei Juergen Quade       */
/* Copyright (c) 2017 Florian Scholz                                    */
/*                                                                      */
/* This program is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or    */
/* (at your option) any later version.                                  */
/*                                                                      */
/* This program is distributed in the hope that it will be useful,      */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         */
/* GNU General Public License for more details.                         */
/*                                                                      */
/************************************************************************/
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/usb.h>
#include <linux/slab.h>
#include <asm/uaccess.h>

#define USB_VENDOR_ID 0x03eb
#define USB_DEVICE_ID 0x2013

struct usb_device *dev;
static DEFINE_MUTEX( ulock );

static short airsensorfs_read_sensor_value( void );

static ssize_t airsensorfs_read( struct file *instanz, char *buffer,
    size_t count, loff_t *ofs )
{
    char pbuf[20];

    short value;

    value = airsensorfs_read_sensor_value();
    int cnt = snprintf(pbuf, count, "%d\n", value);


    count -= copy_to_user(buffer,pbuf,cnt);
    *ofs += count;
    return count;
}


static short airsensorfs_read_sensor_value() {
    char buf[1000];
    int rcvd_bytes, retval;
    short value;
    memcpy(buf, "\x40\x68\x2a\x54\x52\x0a\x40\x40\x40\x40\x40\x40\x40\x40\x40\x40", 0x0000010);
    mutex_lock(&ulock);
    retval = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x2), buf, 0x10, &rcvd_bytes, 1000);
    if(retval != 0)
    {
        printk("airsensorfs: couldn't send write request inital\n");
    }

    retval = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x81), buf, 0x10, &rcvd_bytes, 1000);
    if(retval != 0)
    {
        printk("airsensorfs: failed to read data\n");
    }


    retval = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x81), buf, 0x10, &rcvd_bytes, 1000);
    if(retval != 0)
    {
        printk("airsensorfs: failed to read remaining data\n");
    }
    mutex_unlock(&ulock);
    memcpy(&value, buf+2,2);

    return value;
}

static int airsensorfs_open( struct inode *devicefile, struct file *instanz )
{
    return 0;
}

static struct file_operations usb_fops = {
    .owner = THIS_MODULE,
    .open  = airsensorfs_open,
    .read  = airsensorfs_read,
};

static struct usb_device_id usbid [] = {
    { USB_DEVICE(USB_VENDOR_ID, USB_DEVICE_ID), },
    { }                 /* Terminating entry */
};

struct usb_class_driver class_descr = {
    .name = "airsensorfs",
    .fops = &usb_fops,
    .minor_base = 16,
};

static int airsensorfs_probe(struct usb_interface *interface,
    const struct usb_device_id *id)
{
    dev = interface_to_usbdev(interface);
    printk("airsensorfs driver by florian scholz: 0x%4.4x|0x%4.4x, if=%p\n", dev->descriptor.idVendor,
        dev->descriptor.idProduct, interface );
    if (dev->descriptor.idVendor==USB_VENDOR_ID
        && dev->descriptor.idProduct==USB_DEVICE_ID) {
        if (usb_register_dev( interface, &class_descr )) {
            return -EIO;
        }
        printk("got minor= %d\n", interface->minor );



        char buf[1000];
        int rcvd_bytes;
        int retval = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x81), buf, 0x10, &rcvd_bytes, 1000);
        if(retval != 0)
        {
            printk("airsensorfs: failed to read remaining data\n");

            return 0;
        }

    }


    return -ENODEV;
}

static void airsensorfs_disconnect( struct usb_interface *iface )
{
    mutex_lock( &ulock );
    usb_deregister_dev( iface, &class_descr );
    mutex_unlock( &ulock );
}

static struct usb_driver airsensorfs = {
    .name= "airsensorfs",
    .id_table= usbid,
    .probe= airsensorfs_probe,
    .disconnect= airsensorfs_disconnect,
};

static int __init airsensorfs_init(void)
{
    if (usb_register(&airsensorfs) ) {
        printk("airsensorfs: unable to register usb driver\n");
        return -EIO;
    }
    else
    {
        printk("airsensorfs: registered usb driver\n");
    }
    return 0;
}

static void __exit airsensorfs_exit(void)
{
    usb_deregister(&airsensorfs);
}

module_init(airsensorfs_init);
module_exit(airsensorfs_exit);
MODULE_LICENSE( "GPL" );