return -1;    		if (tjoutp(dev, 0x25, 0xc9))			return -1;	*/	if (InitProSlic(dev)) {			printk("tjusb: Failed to initialize proslic\n");			return -1;		}	case TJ_KEYPAD:		set_aux_ctrl(p, TJ_AUX0, 1);		set_aux_ctrl(p, TJ_AUX1, 1);		set_aux_ctrl(p, TJ_AUX2, 1);		set_aux_ctrl(p, TJ_AUX3, 1);	}	if (usb_set_interface(dev, 0, 1)) {		printk("tjusb: Unable to setup USB interface 0 to altsetting 1\n");		return -1;	}	return 0; }/** *	tjusb_delete */static inline void tjusb_delete (struct usb_tj *dev){	minor_table[dev->minor] = NULL;	if (dev->bulk_in_buffer != NULL)		kfree (dev->bulk_in_buffer);	if (dev->bulk_out_buffer != NULL)		kfree (dev->bulk_out_buffer);	if (dev->write_urb != NULL)		usb_free_urb (dev->write_urb);	kfree (dev);}/** *	tjusb_open */static int tjusb_open (struct inode *inode, struct file *file){	struct usb_tj *dev = NULL;	int subminor;	int retval = 0;		subminor = MINOR (inode->i_rdev) - USB_TJ_MINOR_BASE;	if ((subminor < 0) ||	    (subminor >= MAX_DEVICES)) {		return -ENODEV;	}	/* Increment our usage count for the module.	 * This is redundant here, because "struct file_operations"	 * has an "owner" field. This line is included here soley as	 * a reference for drivers using lesser structures... ;-)	 */	MOD_INC_USE_COUNT;	/* lock our minor table and get our local data for this minor */	down (&minor_table_mutex);	dev = minor_table[subminor];	if (dev == NULL) {		up (&minor_table_mutex);		MOD_DEC_USE_COUNT;		return -ENODEV;	}	/* lock this device */	down (&dev->sem);	/* unlock the minor table */	up (&minor_table_mutex);	/* increment our usage count for the driver */	++dev->open_count;	/* save our object in the file's private structure */	file->private_data = dev;	/* unlock this device */	up (&dev->sem);	return retval;}/** *	tjusb_release */static int tjusb_release (struct inode *inode, struct file *file){	struct usb_tj *dev;	int retval = 0;	dev = (struct usb_tj *)file->private_data;	if (dev == NULL) {		printk(" - object is NULL\n");		return -ENODEV;	}	if(debug) printk(" - minor %d\n", dev->minor);	/* lock our minor table */	down (&minor_table_mutex);	/* lock our device */	down (&dev->sem);	if (dev->open_count <= 0) {		if (debug) printk(" - device not opened");		retval = -ENODEV;		goto exit_not_opened;	}	if (dev->udev == NULL) {		/* the device was unplugged before the file was released */		up (&dev->sem);		tjusb_delete (dev);		up (&minor_table_mutex);		MOD_DEC_USE_COUNT;		return 0;	}	/* decrement our usage count for the device */	--dev->open_count;	if (dev->open_count <= 0) {		/* shutdown any bulk writes that might be going on */		usb_unlink_urb (dev->write_urb);		dev->open_count = 0;	}	/* decrement our usage count for the module */	MOD_DEC_USE_COUNT;exit_not_opened:	up (&dev->sem);	up (&minor_table_mutex);	return retval;}/** *	tjusb_read */static ssize_t tjusb_read (struct file *file, char *buffer, size_t count, loff_t *ppos){	struct usb_tj *dev;	int retval = 0;	dev = (struct usb_tj *)file->private_data;		if(debug) printk(" - minor %d, count = %d", dev->minor, count);	/* lock this object */	down (&dev->sem);	/* verify that the device wasn't unplugged */	if (dev->udev == NULL) {		up (&dev->sem);		return -ENODEV;	}		/* do an immediate bulk read to get data from the device */	retval = usb_bulk_msg (dev->udev,			       usb_rcvbulkpipe (dev->udev, 						dev->bulk_in_endpointAddr),			       dev->bulk_in_buffer, dev->bulk_in_size,			       &count, HZ*10);	/* if the read was successful, copy the data to userspace */	if (!retval) {		if (copy_to_user (buffer, dev->bulk_in_buffer, count))			retval = -EFAULT;		else			retval = count;	}		/* unlock the device */	up (&dev->sem);	return retval;}/** *	tjusb_write */static ssize_t tjusb_write (struct file *file, const char *buffer, size_t count, loff_t *ppos){	struct usb_tj *dev;	ssize_t bytes_written = 0;	int retval = 0;	dev = (struct usb_tj *)file->private_data;	if(debug) printk(" - minor %d, count = %d\n", dev->minor, count);	/* lock this object */	down (&dev->sem);	/* verify that the device wasn't unplugged */	if (dev->udev == NULL) {		retval = -ENODEV;		goto exit;	}	/* verify that we actually have some data to write */	if (count == 0) {	if (debug) printk(" write request of 0 bytes\n");		goto exit;	}	/* see if we are already in the middle of a write */	if (dev->write_urb->status == -EINPROGRESS) {		if(debug) printk(" - already writing\n");		goto exit;	}	/* we can only write as much as 1 urb will hold */	bytes_written = (count > dev->bulk_out_size) ? 				dev->bulk_out_size : count;	/* copy the data from userspace into our urb */	if (copy_from_user(dev->write_urb->transfer_buffer, buffer, 			   bytes_written)) {		retval = -EFAULT;		goto exit;	}	/* set up our urb */	FILL_BULK_URB(dev->write_urb, dev->udev, 		      usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),		      dev->write_urb->transfer_buffer, bytes_written,		      tjusb_write_bulk_callback, dev);	/* send the data out the bulk port */	retval = usb_submit_urb(dev->write_urb);	if (retval) {		if(debug) printk(" - failed submitting write urb, error %d\n",		    retval);	} else {		retval = bytes_written;	}exit:	/* unlock the device */	up (&dev->sem);	return retval;}/** *	tjusb_ioctl */static int tjusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){	struct usb_tj *dev;	struct tj560_regs tg;	struct proslic_regs psg;	unsigned char data[TJ_MAX_REGS];	unsigned short indata = 0;	int retval = 0;        int i;	dev = (struct usb_tj *)file->private_data;	/* lock this object */	down (&dev->sem);	/* verify that the device wasn't unplugged */	if (dev->udev == NULL) {		up (&dev->sem);		retval= -ENODEV;		goto exit;	}	if(debug) printk(" - minor %d, cmd 0x%.4x, arg %ld\n", 	    dev->minor, cmd, arg);        memset(data,0,sizeof(data));	/* process the ioctl cmd */	/* default is we did not understand this ioctl call */	retval = -ENOTTY;        switch(cmd){		case TJ_RD_REG:	 	        if(copy_from_user(&tg,(struct tj560_regs *) arg, sizeof(tg))){		                retval= -EFAULT;				break;			}	                if(!Tjusb_ReadTjRegs(dev->udev, tg.index, data,tg.len)){				for(i=0; i< TJ_MAX_REGS; i++){					tg.data[i] = data[i];				}				copy_to_user((struct tj560_regs *)arg, &tg, sizeof(tg));		                retval = 0;			}else retval = -1;			break;		case TJ_WR_REG:	 	        if(copy_from_user(&tg,(struct tj560_regs *) arg, sizeof(tg))){		                retval = -EFAULT;				break;			}	                if(!Tjusb_WriteTjRegs(dev->udev, tg.index, tg.data,tg.len)){		        	retval = 0;			}else retval = -1;			break;		case TJ_RDPS_DREG:			if(dev->devclass !=TJ_PROSLIC){				retval = -ENODEV;				break;			}	 	        if(copy_from_user(&psg,(struct proslic_regs *) arg, sizeof(psg))){		                retval = -EFAULT;				break;			}	                if(!readProSlicDirectReg(dev->udev, psg.address, data)){				psg.data = data[0];				copy_to_user((struct proslic_regs *)arg, &psg, sizeof(psg));		                retval = 0;			}else retval = -1;			break;		case TJ_WRPS_DREG:			if(dev->devclass !=TJ_PROSLIC){			       	retval = -ENODEV;				break;			}	 	        if(copy_from_user(&psg,(struct proslic_regs *) arg, sizeof(psg))){		                retval = -EFAULT;				break;			}	                if(!writeProSlicDirectReg(dev->udev, psg.address, psg.data)){		                retval = 0;			}else retval = -1;			break;		case TJ_RDPS_IDREG:			if(dev->devclass !=TJ_PROSLIC){			       	retval = -ENODEV;				break;			}	 	        if(copy_from_user(&psg,(struct proslic_regs *) arg, sizeof(psg))){		                retval = -EFAULT;				break;			}			if(!readProSlicInDirectReg(dev->udev,psg.address, &indata)){				psg.indata = indata;				copy_to_user((struct proslic_regs *)arg, &psg, sizeof(psg));		                retval = 0;			}else retval = -1;			break;		case TJ_WRPS_IDREG:			if(dev->devclass !=TJ_PROSLIC){			       	retval = -ENODEV;				break;			}	 	        if(copy_from_user(&psg,(struct proslic_regs *) arg, sizeof(psg))){		                retval = -EFAULT;				break;			}			if(!writeProSlicInDirectReg(dev->udev, psg.address, psg.indata)){		                retval = 0;			}else retval = -1;	}	/* unlock the device */exit:	up (&dev->sem);        return retval ;	}/** *	tjusb_write_bulk_callback */static void tjusb_write_bulk_callback (struct urb *urb){	struct usb_tj *dev = (struct usb_tj *)urb->context;	if (debug) printk(" - minor %d", dev->minor);	if ((urb->status != -ENOENT) && 	    (urb->status != -ECONNRESET)) {        if (debug) printk(" - nonzero write bulk status received: %d\n",		    urb->status);		return;	}	return;}/** *	tjusb_probe * *	Called by the usb core when a new device is connected that it thinks *	this driver might be interested in. */static void * tjusb_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id){	struct usb_tj *dev = NULL;	struct usb_interface *interface;	int minor;	char name[10];		/* See if the device offered us matches what we can accept */	if ((udev->descriptor.idVendor != USB_TJ_VENDOR_ID) ||	    ((udev->descriptor.idProduct & 0xc000) == 0x4000) ||	    ((udev->descriptor.idProduct & 0xc000) == 0xc000)){		return NULL;	}	/* See if the device is proslic type */	if ((udev->descriptor.idVendor == USB_TJ_VENDOR_ID) && 	    ((udev->descriptor.idProduct & 0xfff0) == 0x8310)){	}	/* select a "subminor" number (part of a minor number) */	down (&minor_table_mutex);	for (minor = 0; minor < MAX_DEVICES; ++minor) {		if (minor_table[minor] == NULL)			break;	}	if (minor >= MAX_DEVICES) {		info ("Too many devices plugged in, can not handle this device.");		goto exit;	}	/* allocate memory for our device state and intialize it */	dev = kmalloc (sizeof(struct usb_tj), GFP_KERNEL);	if (dev == NULL) {		err ("Out of memory");		goto exit;	}	memset (dev, 0x00, sizeof (*dev));	minor_table[minor] = dev;	interface = &udev->actconfig->interface[ifnum];	init_MUTEX (&dev->sem);	dev->udev = udev;	dev->interface = interface;	dev->minor = minor;	/* See if the device is proslic type */	dev->devclass = TJ_KEYPAD;	if((udev->descriptor.idProduct & 0xfff0) == 0x8310)		dev->devclass = TJ_PROSLIC;	if (init_hardware(dev)) {		printk("tjusb: Hardware intialization failed.\n");		goto exit;	}	/* initialize the devfs node for this device and register it */	sprintf(name, "tjusb%d", dev->minor);		dev->devfs = devfs_register (usb_devfs_handle, name,				     DEVFS_FL_DEFAULT, USB_MAJOR,				     USB_TJ_MINOR_BASE + dev->minor,				     S_IFCHR | S_IRUSR | S_IWUSR | 				     S_IRGRP | S_IWGRP | S_IROTH, 				     &tjusb_fops, NULL);	/* let the user know what node this device is now attached to */	info ("Tigerjet USB device now attached to USB tjusb%d", dev->minor);exit:	up (&minor_table_mutex);	return dev;}/** *	tjusb_disconnect * *	Called by the usb core when the device is removed from the system. */static void tjusb_disconnect(struct usb_device *udev, void *ptr){	struct usb_tj *dev;	int minor;	dev = (struct usb_tj *)ptr;		down (&minor_table_mutex);	down (&dev->sem);			minor = dev->minor;	/* remove our devfs node */	devfs_unregister(dev->devfs);	/* if the device is not opened, then we clean up right now */	if (!dev->open_count) {		up (&dev->sem);		tjusb_delete (dev);	} else {		dev->udev = NULL;		up (&dev->sem);	}	info("Tigerjet USB device #%d now disconnected", minor);	up (&minor_table_mutex);}/** *	usb_tj_init */static int __init usb_tj_init(void){	int result;	/* register this driver with the USB subsystem */	result = usb_register(&tjusb_driver);	if (result < 0) {		err("usb_register failed for the "__FILE__" driver. Error number %d",		    result);		return -1;	}	info(DRIVER_DESC " " DRIVER_VERSION);	return 0;}/** *	usb_tj_exit */static void __exit usb_tj_exit(void){	/* deregister this driver with the USB subsystem */	usb_deregister(&tjusb_driver);}module_init (usb_tj_init);module_exit (usb_tj_exit);MODULE_AUTHOR(DRIVER_AUTHOR);MODULE_DESCRIPTION(DRIVER_DESC);MODULE_LICENSE("GPL");