Device-LabJack

 view release on metacpan or  search on metacpan

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

	struct usb_endpoint_descriptor* interrupt_in_endpoint;
	struct urb*		interrupt_in_urb;
        int                     interrupt_in_interval;
        int                     interrupt_in_running;
        int                     interrupt_in_done;

	char*			interrupt_out_buffer;
	struct usb_endpoint_descriptor* interrupt_out_endpoint;
	struct urb*		interrupt_out_urb;
	int                     interrupt_out_interval;
        int                     interrupt_out_busy;

};

static ssize_t labjack_read(struct file *file, char *buffer, size_t count, loff_t *ppos);
static ssize_t labjack_read_feature(struct file *file, char *buffer, size_t count, loff_t *ppos);
static ssize_t labjack_write(struct file *file, const char *buffer, size_t count, loff_t *ppos);
static int labjack_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
static inline void labjack_delete(struct labjack_usb *dev);
static int labjack_open(struct inode *inode, struct file *file);
static int labjack_release(struct inode *inode, struct file *file);

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

		retval = -ENODEV;
		goto unlock_exit;
	}
	
	if (dev->udev == NULL) {
		up (&dev->sem); 
		labjack_delete (dev);
		goto exit;
	}

	if (dev->interrupt_out_busy) {
		wait_event_interruptible_timeout (dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);
	}
	labjack_abort_transfers (dev);
	dev->open_count = 0;

unlock_exit:
        up (&dev->sem);
	dbg(2," %s : leave, return value %d", __FUNCTION__, retval);

exit:
	dbg(2," %s : leave, return value %d", __FUNCTION__, retval);

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

    	        goto exit;
	}

	if (dev->interrupt_in_running) {
                dev->interrupt_in_running = 0;
                mb();
                if (dev->interrupt_in_urb != NULL && dev->udev) {
                        usb_unlink_urb (dev->interrupt_in_urb);
                }	
        }
  	if (dev->interrupt_out_busy) {
                if (dev->interrupt_out_urb != NULL && dev->udev) {
                        usb_unlink_urb (dev->interrupt_out_urb);
                }
	}

 exit:
	dbg(2," %s : leave", __FUNCTION__);
}

static void labjack_check_for_read_packet (struct labjack_usb *dev)

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

	dev = file->private_data;

	poll_wait(file, &dev->read_wait, wait);
	poll_wait(file, &dev->write_wait, wait);
	
	labjack_check_for_read_packet(dev);
	if (dev->read_packet_length > 0) {
                mask |= POLLIN | POLLRDNORM;
        }
        if (!dev->interrupt_out_busy) {
	        mask |= POLLOUT | POLLWRNORM;
        }
 
        dbg(2, "%s: leave, mask = %d", __FUNCTION__, mask);
        return mask;
}

static loff_t labjack_llseek (struct file *file, loff_t off, int whence)
{
        return -ESPIPE;         /* unseekable */

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

	        	retval = -EAGAIN;
           		goto unlock_exit;
        	}
        
        	retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
        	if (retval < 0) {
	        	goto unlock_exit;
        	}

    		if (read_timeout
	    	  && (dev->read_buffer_length || dev->interrupt_out_busy)) {
        		timeout = jiffies + read_timeout * HZ / 1000;
        	}

        	if (read_timeout && time_after (jiffies, timeout)) {
	        	retval = -ETIMEDOUT;
            		goto unlock_exit;
        	}
        	labjack_check_for_read_packet (dev);
	}

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

		retval = -ENODEV;
		err("No device or device unplugged %d", retval);
		goto unlock_exit;
	}

	if (count == 0) {
        dbg(1," %s : write request of 0 bytes", __FUNCTION__);
		goto unlock_exit;
	}
	
	while (dev->interrupt_out_busy) {
                if (file->f_flags & O_NONBLOCK) {
                        retval = -EAGAIN;
                        goto unlock_exit;
                }
                retval = wait_event_interruptible (dev->write_wait, !dev->interrupt_out_busy);
                if (retval) {
                        goto unlock_exit;
                }
        }
    
	bytes_to_write = min(count, write_buffer_size);
        dbg(4, "%s: count = %Zd, bytes_to_write = %Zd", __FUNCTION__, count, bytes_to_write);

        if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
                retval = -EFAULT;

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

        }

        usb_fill_int_urb(dev->interrupt_out_urb, dev->udev,
            usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
            dev->interrupt_out_buffer,
            bytes_to_write,
            labjack_interrupt_out_callback,
            dev,
            dev->interrupt_out_interval);

        dev->interrupt_out_busy = 1;
        wmb();
 
        retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
        if (retval) {
                dev->interrupt_out_busy = 0;
                err("Couldn't submit interrupt_out_urb %d", retval);
                goto unlock_exit;
	}
	retval = bytes_to_write;

unlock_exit:
	up (&dev->sem);

exit:
	dbg(2," %s : leave, return value %d", __FUNCTION__, retval);

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

	dbg(4," %s : enter, status %d", __FUNCTION__, urb->status);
	usb_labjack_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer);

	if (urb->status && !(urb->status == -ENOENT ||
	    urb->status == -ECONNRESET ||
        urb->status == -ESHUTDOWN)) {
            dbg(1, "%s - nonzero write bulk status received: %d",
	        __FUNCTION__, urb->status);
        }
	dev->interrupt_out_busy = 0;
   	wake_up_interruptible(&dev->write_wait);

	usb_labjack_debug_data(5,__FUNCTION__, urb->actual_length, urb->transfer_buffer);
	dbg(4," %s : leave, status %d", __FUNCTION__, urb->status);
}


static int labjack_probe (struct usb_interface *interface, const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(interface);

linux-labjack/driver/linux-2.6/labjack.c  view on Meta::CPAN

        dev->interrupt_in_buffer = NULL;
        dev->interrupt_in_endpoint = NULL;
        dev->interrupt_in_urb = NULL;
        dev->interrupt_in_running = 0;
        dev->interrupt_in_done = 0;

        dev->interrupt_out_buffer = NULL;
        dev->interrupt_out_endpoint = NULL;
        dev->interrupt_out_urb = NULL;
        dev->interrupt_out_busy = 0;

        iface_desc = &interface->altsetting[0];
    
	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
		endpoint = &iface_desc->endpoint[i].desc;

		if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&
		    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)) {
                        dev->interrupt_in_endpoint = endpoint;
		}

linux-labjack/driver/linux-2.6/patch/labjack_urb_kill.patch  view on Meta::CPAN

 
 #include <linux/config.h>
@@ -357,12 +359,12 @@
                 dev->interrupt_in_running = 0;
                 mb();
                 if (dev->interrupt_in_urb != NULL && dev->udev) {
-                        usb_unlink_urb (dev->interrupt_in_urb);
+                        usb_kill_urb (dev->interrupt_in_urb);
                 }	
         }
   	if (dev->interrupt_out_busy) {
                 if (dev->interrupt_out_urb != NULL && dev->udev) {
-                        usb_unlink_urb (dev->interrupt_out_urb);
+                        usb_kill_urb (dev->interrupt_out_urb);
                 }
 	}