usbtouchscreen.c

for linux touch screen source code

	usb_free_urb(usbtouch->irq);
	usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
	kfree(usbtouch);
}







static int proc_control(struct usb_device *dev, void *arg)
{
	struct usbdevfs_ctrltransfer ctrl;
	unsigned int tmo;
	unsigned char *tbuf;
	int i, ii;
    char msrbuf[MR_LEN] ;
//    char cmd_version[]="D1_rfwver" ;
//    char cmd_version[]="D1_rfwvereopt123" ;

    if(1)pr_info( "usbtch:    proc_control,enter\n");

    memset(msrbuf, 0, sizeof(msrbuf));
	if (copy_from_user(msrbuf, (void *)arg, sizeof(msrbuf)))
		return -EFAULT;

//    memcpy(msrbuf, cmd_version, sizeof(cmd_version));

    if(1)pr_info( "usbtch:    proc_control,i/p msrbuf=%s\n",msrbuf);



//    Dump( msrbuf, sizeof(msrbuf));

//hua	if ((ret = check_ctrlrecip(ps, ctrl.requesttype, ctrl.index)))
//hua		return ret;

//	if (ctrl.length > PAGE_SIZE)
//		return -EINVAL;

//	if (!(tbuf = (unsigned char *)__get_free_page(GFP_KERNEL)))
//		return -ENOMEM;


//    return 0;

//	if (ctrl.requesttype & 0x80) {
//		if (ctrl.length && !access_ok(VERIFY_WRITE, ctrl.data, ctrl.length)) {
//			free_page((unsigned long)tbuf);
//			return -EINVAL;
//		}
//		i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
//				       ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
//		if ((i > 0) && ctrl.length) {
//			if (copy_to_user(ctrl.data, tbuf, ctrl.length)) {
//				free_page((unsigned long)tbuf);
//				return -EFAULT;
//			}
//		}
//	} else {
//		if (ctrl.length) {
//			if (copy_from_user(tbuf, ctrl.data, ctrl.length)) {
//				free_page((unsigned long)tbuf);
//				return -EFAULT;
//			}
//		}
//		i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
//				       ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);
//	}

//		i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.request, ctrl.requesttype,
//				       ctrl.value, ctrl.index, tbuf, ctrl.length, tmo);

      tbuf 		= msrbuf;

       ii= strlen(msrbuf);

      ctrl.bRequestType  = 0x21;
      ctrl.bRequest     	= 0x09; //set report
      ctrl.wValue 		= 0x0300;
      ctrl.wIndex    	= 0 ;
      ctrl.wLength     	= 0x10;
      ctrl.timeout      = 2000;
      ctrl.data 		= tbuf;

        tmo = (ctrl.timeout * HZ + 999) / 1000;

//    Dump( (char*)&ctrl, sizeof(ctrl));

		i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, ctrl.bRequestType,
				       ctrl.wValue, ctrl.wIndex, tbuf, ctrl.wLength, tmo);

//	free_page((unsigned long)tbuf);

	if (i<0) {
		if(1)pr_info(KERN_DEBUG "usbtch: usbdevfs: USBDEVFS_CONTROL failed dev %d rqt %u rq %u len %u ret %d\n",
		       dev->devnum, ctrl.bRequestType, ctrl.bRequest, ctrl.wLength, i);
	}

    if(1)pr_info( "usbtch:    proc_control,status=%x, send msrbuf=(%s)\n",i, msrbuf);

//------------------------

	mdelay (500);

    memset(msrbuf, 0, sizeof(msrbuf));
       ii= ii+2;

      ctrl.bRequestType  = 0xa1;
      ctrl.bRequest     	= 0x01; //get report
      ctrl.wValue 		= 0x0300;
      ctrl.wIndex    	= 0 ;
      ctrl.wLength     	= 0x10;
      ctrl.timeout      = 2000;
      ctrl.data 		= tbuf;

        tmo = (ctrl.timeout * HZ + 999) / 1000;


//    Dump( (char*)&ctrl, sizeof(ctrl));

//		i = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), ctrl.bRequest, ctrl.bRequestType,
//				       ctrl.wValue, ctrl.wIndex, tbuf, ctrl.wLength, tmo);
//
////	free_page((unsigned long)tbuf);
//
//	if (i<0) {
//		if(1)pr_info(KERN_DEBUG "usbtch: usbdevfs: USBDEVFS_CONTROL failed dev %d rqt %u rq %u len %u ret %d\n",
//		       dev->devnum, ctrl.bRequestType, ctrl.bRequest, ctrl.wLength, i);
//	}
//
//    if(1)pr_info( "usbtch:    proc_control,status=%x, recv msrbuf=(%s)\n",i, msrbuf);
//    copy_to_user((void *)arg, msrbuf, MR_LEN);

//    if(1)pr_info( "usbtch:    proc_control,exit\n");

	return i;
}


#define to_skel_dev(d) container_of(d, struct usbtouch_usb, kref)

//// skel_delete() to  skel_release()  are reference to:
////  \\Fedora7\public\usr\src\redhat\BUILD\kernel-2.6.21\linux-2.6.21.i686\drivers\usb\usb-skeleton.c
static struct usb_driver usbtouchusb_driver;

static void skel_delete(struct kref *kref)
{
	struct usbtouch_usb *dev = to_skel_dev(kref);

	usb_put_dev(dev->udev);
//	kfree(dev->bulk_in_buffer);
	kfree(dev);
}

static int skel_open(struct inode *inode, struct file *file)
{
	struct usbtouch_usb *dev;
	struct usb_interface *interface;
	int subminor;
	int retval = 0;

	subminor = iminor(inode);
	if(1)pr_info("usbtch: %s entered, minor=%x\n", __FUNCTION__, subminor);

	interface = usb_find_interface(&usbtouchusb_driver, subminor);
	if (!interface) {
		err ("%s - error, can't find device for minor %d",
		     __FUNCTION__, subminor);
		retval = -ENODEV;
		goto exit;
	}

	dev = usb_get_intfdata(interface);
	if (!dev) {
		retval = -ENODEV;
		goto exit;
	}

	/* increment our usage count for the device */
	kref_get(&dev->kref);

	/* prevent the device from being autosuspended */
//	retval = usb_autopm_get_interface(interface);
//	if (retval) {
//		kref_put(&dev->kref, skel_delete);
//		goto exit;
//	}

	/* save our object in the file's private structure */
	file->private_data = dev;

exit:
	if(1)pr_info("usbtch: %s exit, minor=%x\n", __FUNCTION__, subminor);

//		retval = -ENODEV;

	return retval;
}

static int skel_release(struct inode *inode, struct file *file)
{
	struct usbtouch_usb *dev;

	if(1)pr_info("usbtch: %s entered, \n", __FUNCTION__);

	dev = (struct usbtouch_usb *)file->private_data;
	if (dev == NULL)
		return -ENODEV;

	/* allow the device to be autosuspended */
	mutex_lock(&dev->io_mutex);
	if (dev->interface)
		usb_autopm_put_interface(dev->interface);
	mutex_unlock(&dev->io_mutex);

	/* decrement the count on our device */
	kref_put(&dev->kref, skel_delete);

	if(1)pr_info("usbtch: %s exit, \n", __FUNCTION__);

	return 0;
}


static int
ioctl_usbtch(struct inode *inode, struct file *file,
	      unsigned int cmd, unsigned long arg)
{
	struct usbtouch_usb *mdev;
	int ret = -ENOIOCTLCMD;
	struct usb_device *dev;

	if(1)pr_info("%s\n", __FUNCTION__);

	mdev = (struct usbtouch_usb*) file->private_data;
    dev = mdev->udev;

//    if(1)pr_info( "usbtch:    ioctl_usbtch,enter,dev=%x, cmd=%x\n",dev,cmd);
//    if(1)pr_info( "usbtch:    ioctl_usbtch,enter, mdev=%x, dev=%x, cmd=%x\n",mdev,dev,cmd);
//    return 0;

//    	down (&mdev->mutex);
//
//    	if (!mdev->usbdev) {
//    		up (&mdev->mutex);
//    		return -EIO;
//    	}


	switch (cmd)
	{
		case USBMSR_WRITE_REPORT:
		{
//			if(1)pr_info(" ioctl_usbtch(%x): USBMSR_WRITE_REPORT\n", 0x1111);
			ret = proc_control(dev, (void *)arg);
			if (ret >= 0)
				inode->i_mtime = CURRENT_TIME;
			break;
		}
		case USBMSR_WRITE_ENVIRONMENT:
		{
			//if(1)pr_info("ioctl_usbtch(%d): USBMSR_WRITE_ENVIRONMENT\n", scr_minor);
//			ret = proc_control_env(dev, (void *)arg);
			if (ret >= 0)
			     ;
				//inode->i_mtime = CURRENT_TIME;
			break;
		}
		case IOCTL_NRC2000_STATUS:
		{
//			struct usb_kbd_data *scr;
//			struct usb_device *dev;
//			scr = file->private_data;
//			put_user(scr->statusdata,(unsigned long *)arg);
//			ret = 4;
//			if (ret >= 0)
//				inode->i_mtime = CURRENT_TIME;
			break;
		}
		default:
			if(1)pr_info("ioctl_usbtch(%d): unknown code\n", 0x9999);
			return -ENOIOCTLCMD;
	}

//  	up (&mdev->mutex);
	return ret;

}


static ssize_t
read_nrc2000(struct file * file, char * buffer,
             size_t count, loff_t *ppos)
{
//static int indx = 0;
//char ibuf[][5] = {{ 0,      1,      0,     1,      0} ,
//                  { 0,      1,      0,  0xff,   0xf} ,
//                  { 0,   0xff,    0xf,  0xff,   0xf} ,
//                  { 0,   0xff,    0xf,      1,   0}};

	struct usbtouch_usb *scr;

//    if(1)pr_info( "usbtch:    read_nrc2000,enter\n");


    scr = file->private_data;
	if (!scr->present)
	{	return -ENODEV;
	}


	mutex_lock(&scr->io_mutex);


//    if (copy_to_user(buffer, scr->input, 5))
    if (scr->dataSave[4] || scr->dataSave[3] )
    {
        int ii;


//        if(1)pr_info( "usbtch:  %s", __FUNCTION__);
        for ( ii = 0 ; ii < 5 ; ii++ )
        {
            if(1)pr_info(" %x",scr->data[ii]);
        }
        if(1)pr_info("\n");

        copy_to_user(buffer, scr->dataSave, 5);
        scr->dataSave[4] = 0;
        scr->dataSave[3] = 0;
//        if(1)pr_info( "usbtch:    read_nrc2000,exit, with data\n");

    	mutex_unlock(&scr->io_mutex);

        return 5;
    }
//    else
//        interruptible_sleep_on(&scr->rd_wait_q);

//    if(1)pr_info( "usbtch:    read_nrc2000,exit, no data\n");

	mutex_unlock(&scr->io_mutex);

    return 0;
}


static int utchdrv_open(struct inode * inode, struct file * file)
{
	struct usbtouch_usb *mdev = NULL;
//	struct usb_interface *interface;
	int subminor;
	int retval = 0;


//	return 0;

	int scr_minor;

    scr_minor = 0;
    mdev = p_scr_table[scr_minor];


	subminor = iminor(inode);   //inode of utchdrv, usbtch0  are diff, so this line will fault
	subminor = scr_minor;       //force always

	if(1)pr_info("%s entered, minor=%x\n", __FUNCTION__, subminor);

	/* prevent disconnects */
	down (&disconnect_sem);

//	interface = usb_find_interface (&usbtch_driver, subminor);
//	if (!interface) {
//		err ("%s - error, can't find device for minor %d",
//		     __FUNCTION__, subminor);
//		retval = -ENODEV;
//		goto exit_no_device;
//	}
//
//	mdev = usb_get_intfdata(interface);
	if (!mdev) {
		retval = -ENODEV;
		goto exit_no_device;
	}



//	if(1)pr_info("%s usbtch=%x, mdev->sopen=%x\n", __FUNCTION__, mdev, mdev->sopen);

//	return 0;

	/* lock this device */
//	down (&mdev->sem);

	/* increment our usage count for the driver */
	++mdev->sopen;

	/* save our object in the file's private structure */
//	if(mdev->sopen == 1)
    	file->private_data = mdev;

	/* unlock this device */
//	up (&mdev->sem);

exit_no_device:
	up (&disconnect_sem);
	return retval;


}


static int
utchdrv_close(struct inode * inode, struct file * file)
{
	struct usbtouch_usb *mdev;
	int retval = 0;

	if(1)pr_info("%s entered\n", __FUNCTION__);

//	return 0;

    {
    	mdev = (struct usbtouch_usb *)file->private_data;
    	if (mdev == NULL) {
    		if(1)pr_info("%s - object is NULL\n", __FUNCTION__);
    		return -ENODEV;
    	}

    	if(1)pr_info("%s - minor %d\n", __FUNCTION__, mdev->minor);

//    	if(1)pr_info("%s - minor %d\n", __FUNCTION__, mdev->minor);

    	/* lock our device */
//    	down (&mdev->sem);

    	if (mdev->sopen <= 0) {
    		if(1)pr_info ("%s - device not opened", __FUNCTION__);
    		retval = -ENODEV;
    		goto exit_not_opened;
    	}


//    	/* wait for any bulk writes that might be going on to finish up */
//    	if (atomic_read (&mdev->write_busy))
//    		wait_for_completion (&mdev->write_finished);

    	--mdev->sopen;

//    	if (!mdev->present && !mdev->sopen) {
//    		/* the device was unplugged before the file was released */
//    		up (&mdev->sem);
//    		skel_delete (mdev);
//    		return 0;
//    	}

    exit_not_opened:
//    	up (&mdev->sem);

    	return retval;

}


}



static struct file_operations tchdrv_fops = {
	owner:		THIS_MODULE,
//	ioctl:		ioctl_usbtch,
//	open:		skel_open,
//	release:	skel_release,

	ioctl:		ioctl_usbtch,
	open:		utchdrv_open,
	release:	utchdrv_close,
};


static struct file_operations usb_nrc2000_fops = {
	read:		read_nrc2000,
//	write:		write_nrc2000,
	.ioctl =	ioctl_usbtch,
	.open =		skel_open,
	.release =	skel_release,
};



    //hsu, add
static struct usb_class_driver usbtch_class =
{
//	.name =		"usb/usbtch%d",
	.name =		"usbtch%d",

	.fops =		&usb_nrc2000_fops,
//	.mode =		S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,

    .minor_base =		SCR_BASE_MNR,
};










MODULE_DEVICE_TABLE(usb, usbtouch_devices);

static struct usb_driver usbtouch_driver = {
	.name		= "usbtouchscreen",     //org
//	.name		= "usbtch",     //posiflex

	.probe		= usbtouch_probe,
	.disconnect	= usbtouch_disconnect,
	.id_table	= usbtouch_devices,

    .ioctl =		ioctl_usbtch,

};

static int __init usbtouch_init(void)
{

	if(1)pr_info("%s - called", __FUNCTION__);

//    if(1)pr_info("Posiflex USB TouchScreen driver ver 2.60 %s - called\n", __FUNCTION__);
    if(1)pr_info("Posiflex USB TouchScreen driver ver 2.73 %s - called\n", __FUNCTION__);

    my_major = register_chrdev( 211,"utchdrv",&tchdrv_fops);


	return usb_register(&usbtouch_driver);
}



static void __exit usbtouch_cleanup(void)
{
	usb_deregister(&usbtouch_driver);
}

module_init(usbtouch_init);
module_exit(usbtouch_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

MODULE_ALIAS("touchkitusb");
MODULE_ALIAS("itusbtouch");
MODULE_ALIAS("usbtouchusb");


//aft add   register_chrdev( 211,"utchdrv"....      );  usbtouch_init failed with -17