/*
 *  mousek.c, sample code for USB drivers, heavily based on usbmouse.c
 *	
 *	Copyright (c) 2016 Kush Kumar Sharma
 *  Copyright (c) 2000 Alessandro Rubini <rubini@gnu.org>
 *  Copyright (c) 1999 Vojtech Pavlik <vojtech@suse.cz>
 *
 */

/*
 * 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.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifndef __KERNEL__
#  define __KERNEL__
#endif
#ifndef MODULE
#  define MODULE
#endif

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/usb/input.h>
#include <linux/hid.h>

/* usb stuff */
#include <linux/input.h>
#include <linux/usb.h>

/* miscdevice stuff */
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>

/*
 * Version Information
 */
#define DRIVER_VERSION "v0.1"
#define DRIVER_AUTHOR "Kush Kumar Sharma"
#define DRIVER_DESC "Mouse driver"
#define DRIVER_LICENSE "GPL"

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE(DRIVER_LICENSE);

#define DEVICE_NAME "mousek"
int Major;

struct mousek_device {
    signed char data[3];     /* use a three-byte protocol */
    struct urb urb;          /* USB Request block, to get USB data*/
    struct input_dev *idev;   /* input device, to push out input  data */
    int x, y;                /* keep track of the position of this device */
};

static struct mousek_device *mouse;

int mousek_open(struct inode *inode, struct file *filp)
{
    /* announce yourself */
    printk(KERN_INFO "mousek: faking an USB mouse via the misc device\n");
    
	return 0; /* Ok */
}    

int mousek_release(struct inode *inode, struct file *filp)
{

    printk(KERN_INFO "mousek: closing misc device\n");
    	
	return 0;
}

ssize_t mousek_read(struct file *filp,   /* see include/linux/fs.h   */
                           char *buffer,        /* buffer to fill with data */
                           size_t length,       /* length of the buffer     */
                           loff_t * offset)
{
    printk(KERN_INFO "mousek: Restricted. That is okay but do not repeat this mistake.\n");
    return 0;
}


ssize_t mousek_write(struct file *filp, const char *buf, size_t count,
		    loff_t *offp)
{
    static char localbuf[16];
    int i;

    /* accept 16 bytes at a time, at most */
    if (count >16) count=16;
    copy_from_user(localbuf, buf, count);

 
	struct input_dev *dev = mouse->idev;

    /* scan written data */
    for (i=0; i<count; i++) {
	mouse->data[1] = mouse->data[2] = 0;
	switch (localbuf[i]) {
	    case 'u': case 'U': /* up */
		mouse->data[2] = -10;
		break;
	    case 'd': case 'D': /* down */
		mouse->data[2] = 10;
		break;
	    case 'l': case 'L': /* left */
		mouse->data[1] = -10;
		break;
	    case 'r': case 'R': /* right */
		mouse->data[1] = 10;
		break;
	    default:
		continue;
	}
	input_report_key(dev, BTN_RIGHT, 1);
	input_report_key(dev, BTN_RIGHT, 0);

	input_report_key(dev, KEY_UP, 1); /* keypress */
	input_report_key(dev, KEY_UP, 0); /* release */
	
	input_report_rel(dev, REL_X, 30);
	input_report_rel(dev, REL_Y, 30);

	printk(KERN_ALERT "mousek: Control actions of %s received %d %d",localbuf, mouse->data[1], mouse->data[2]);
	

    }
	

	//input_report_rel(mouse->idev, REL_WHEEL, data[3]);
	
	input_sync(dev);
	
    return count;
}


struct file_operations mousek_fops = {
	write:    mousek_write,
	read:     mousek_read,
	open:     mousek_open,
	release:  mousek_release,
};


int init_module(void)
{
    int retval;
	
	Major = register_chrdev(0, DEVICE_NAME, &mousek_fops);
	if (Major < 0) {
	  printk(KERN_ALERT "Registering char device failed with %d\n", Major);
	  return Major;
	}
	
	struct input_dev *input_dev;

    /* allocate and zero a new data structure for the new device */
    mouse = kmalloc(sizeof(struct mousek_device), GFP_KERNEL);
    if (!mouse) return -ENOMEM; /* failure */
    memset(mouse, 0, sizeof(*mouse));

	input_dev = input_allocate_device();
	if (!input_dev) {
		printk(KERN_ERR "mousek.c: Not enough memory\n");
		retval = -ENOMEM;
		//goto err_free_irq;
	}
	//updating struct
	mouse->idev = input_dev;
    	
	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
    set_bit(103, input_dev->keybit); /* Up    */

	input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
	input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);

	retval = input_register_device(input_dev);
	if (retval) {
		printk(KERN_ERR "mousek: Failed to register device\n");
		goto err_free_dev;
	}

	
	printk(KERN_INFO "I was assigned major number %d. To talk to\n", Major);
	printk(KERN_INFO "the driver, create a dev file with\n");   
    printk(KERN_INFO "'mknod /dev/%s c %d 0'.\n", DEVICE_NAME, Major);
	printk(KERN_INFO "Try various minor numbers. Try to cat and echo to\n");
	printk(KERN_INFO "the device file.\n");
	printk(KERN_INFO "Remove the device file and module when done.\n");
	
	
return 0;

err_free_dev:
	input_free_device(mouse->idev);
	kfree(mouse);

return retval;
}

void cleanup_module(void)
{

	if(!mouse) return;
	
	input_unregister_device(mouse->idev);
	kfree(mouse);	
	unregister_chrdev(Major, DEVICE_NAME);
    
	printk(KERN_ALERT "Uninstalled. Delete device from dev.");
	
	

}