tjusb.c

usb手柄电话usb驱动袁代码

			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");