*
*/
-static const struct usb_device_id skel_table[] = {
+static const struct usb_device_id lpvo_table[] = {
{ } /* Terminating entry */
};
-MODULE_DEVICE_TABLE(usb, skel_table);
+MODULE_DEVICE_TABLE(usb, lpvo_table);
/*
* *** Diagnostics and Debug ***
static int assigned_usb_minors; /* mask of filled slots */
static struct mutex minors_lock; /* operations on usb_minors are to be protected */
-/*
- * usb-skeleton prototypes
- */
-
-struct usb_skel;
-static ssize_t skel_do_write(struct usb_skel *, const char *, size_t);
-static ssize_t skel_do_read(struct usb_skel *, char *, size_t);
-static int skel_do_open(struct gpib_board *, int);
-static int skel_do_release(struct gpib_board *);
+struct lpvo;
+static ssize_t lpvo_do_write(struct lpvo *, const char *, size_t);
+static ssize_t lpvo_do_read(struct lpvo *, char *, size_t);
+static int lpvo_do_open(struct gpib_board *, int);
+static int lpvo_do_release(struct gpib_board *);
/*
* usec_diff : take difference in MICROsec between two 'timespec'
static int write_loop(void *dev, char *msg, int leng)
{
- return skel_do_write(dev, msg, leng);
+ return lpvo_do_write(dev, msg, leng);
}
/**
if (retval < 0)
return retval;
- nchar = skel_do_read(GPIB_DEV, buffer, 64);
+ nchar = lpvo_do_read(GPIB_DEV, buffer, 64);
if (nchar < 0) {
dev_err(board->gpib_dev, " return from read: %d\n", nchar);
return b->inbuf[b->last - b->nchar--];
}
ktime_get_real_ts64 (&before);
- b->nchar = skel_do_read(GPIB_DEV, b->inbuf, INBUF_SIZE);
+ b->nchar = lpvo_do_read(GPIB_DEV, b->inbuf, INBUF_SIZE);
b->last = b->nchar;
ktime_get_real_ts64 (&after);
if (!board->private_data)
return -ENOMEM;
- retval = skel_do_open(board, usb_minors[j]);
+ retval = lpvo_do_open(board, usb_minors[j]);
- DIA_LOG(1, "Skel open: %d\n", retval);
+ DIA_LOG(1, "lpvo open: %d\n", retval);
if (retval) {
- dev_err(board->gpib_dev, "skel open failed.\n");
+ dev_err(board->gpib_dev, "lpvo open failed.\n");
kfree(board->private_data);
board->private_data = NULL;
return -ENODEV;
write_loop(GPIB_DEV, USB_GPIB_OFF, strlen(USB_GPIB_OFF));
msleep(100);
DIA_LOG(1, "%s", "GPIB off\n");
- retval = skel_do_release(board);
- DIA_LOG(1, "skel release -> %d\n", retval);
+ retval = lpvo_do_release(board);
+ DIA_LOG(1, "lpvo release -> %d\n", retval);
}
kfree(board->private_data);
board->private_data = NULL;
if (retval < 0)
return retval;
- retval = skel_do_read(GPIB_DEV, inbuf, 1);
- retval += skel_do_read(GPIB_DEV, inbuf + 1, 1);
+ retval = lpvo_do_read(GPIB_DEV, inbuf, 1);
+ retval += lpvo_do_read(GPIB_DEV, inbuf + 1, 1);
ktime_get_real_ts64 (&after);
* written by Greg Kroah-Hartman and available in the kernel tree. *
* *
* Functions skel_open() and skel_release() have been rewritten and named *
- * skel_do_open() and skel_do_release() to process the attach and detach *
+ * lpvo_do_open() and lpvo_do_release() to process the attach and detach *
* requests coming from gpib_config. *
* *
- * Functions skel_read() and skel_write() have been split into a *
- * skel_do_read() and skel_do_write(), that cover the kernel stuff of read *
- * and write operations, and the original skel_read() and skel_write(), *
+ * Functions lpvo_read() and lpvo_write() have been split into a *
+ * lpvo_do_read() and lpvo_do_write(), that cover the kernel stuff of read *
+ * and write operations, and the original lpvo_read() and lpvo_write(), *
* that handle communication with user space and call their _do_ companion. *
* *
* Only the _do_ versions are used by the lpvo_usb_gpib driver; other ones *
#include <linux/mutex.h>
/* Get a minor range for your devices from the usb maintainer */
-#define USB_SKEL_MINOR_BASE 192
+#define USB_LPVO_MINOR_BASE 192
/* private defines */
#define USER_DEVICE 1 /* compile for device(s) in user space */
/* Structure to hold all of our device specific stuff */
-struct usb_skel {
+struct lpvo {
struct usb_device *udev; /* the usb device for this device */
struct usb_interface *interface; /* the interface for this device */
struct semaphore limit_sem; /* limiting the number of writes in progress */
wait_queue_head_t bulk_in_wait; /* to wait for an ongoing read */
};
-#define to_skel_dev(d) container_of(d, struct usb_skel, kref)
+#define to_lpvo_dev(d) container_of(d, struct lpvo, kref)
-static struct usb_driver skel_driver;
-static void skel_draw_down(struct usb_skel *dev);
+static struct usb_driver lpvo_driver;
+static void lpvo_draw_down(struct lpvo *dev);
-static void skel_delete(struct kref *kref)
+static void lpvo_delete(struct kref *kref)
{
- struct usb_skel *dev = to_skel_dev(kref);
+ struct lpvo *dev = to_lpvo_dev(kref);
usb_free_urb(dev->bulk_in_urb);
usb_put_dev(dev->udev);
}
/*
- * skel_do_open() - to be called by usb_gpib_attach
+ * lpvo_do_open() - to be called by usb_gpib_attach
*/
-static int skel_do_open(struct gpib_board *board, int subminor)
+static int lpvo_do_open(struct gpib_board *board, int subminor)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
struct usb_interface *interface;
int retval = 0;
- interface = usb_find_interface(&skel_driver, subminor);
+ interface = usb_find_interface(&lpvo_driver, subminor);
if (!interface) {
dev_err(board->gpib_dev, "can't find device for minor %d\n", subminor);
retval = -ENODEV;
}
/*
- * skel_do_release() - to be called by usb_gpib_detach
+ * lpvo_do_release() - to be called by usb_gpib_detach
*/
-static int skel_do_release(struct gpib_board *board)
+static int lpvo_do_release(struct gpib_board *board)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
dev = GPIB_DEV;
if (!dev)
mutex_unlock(&dev->io_mutex);
/* decrement the count on our device */
- kref_put(&dev->kref, skel_delete);
+ kref_put(&dev->kref, lpvo_delete);
return 0;
}
* read functions
*/
-static void skel_read_bulk_callback(struct urb *urb)
+static void lpvo_read_bulk_callback(struct urb *urb)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
unsigned long flags;
dev = urb->context;
wake_up_interruptible(&dev->bulk_in_wait);
}
-static int skel_do_read_io(struct usb_skel *dev, size_t count)
+static int lpvo_do_read_io(struct lpvo *dev, size_t count)
{
int rv;
dev->bulk_in_endpoint_addr),
dev->bulk_in_buffer,
min(dev->bulk_in_size, count),
- skel_read_bulk_callback,
+ lpvo_read_bulk_callback,
dev);
/* tell everybody to leave the URB alone */
spin_lock_irq(&dev->err_lock);
}
/*
- * skel_do_read() - read operations from lpvo_usb_gpib
+ * lpvo_do_read() - read operations from lpvo_usb_gpib
*/
-static ssize_t skel_do_read(struct usb_skel *dev, char *buffer, size_t count)
+static ssize_t lpvo_do_read(struct lpvo *dev, char *buffer, size_t count)
{
int rv;
bool ongoing_io;
* it seems that requests for less than dev->bulk_in_size
* are not accepted
*/
- rv = skel_do_read_io(dev, dev->bulk_in_size);
+ rv = lpvo_do_read_io(dev, dev->bulk_in_size);
if (rv < 0)
goto exit;
else
* asked for by the lpvo_usb_gpib layer.
*/
// if (available < count)
-// skel_do_read_io(dev, dev->bulk_in_size);
+// lpvo_do_read_io(dev, dev->bulk_in_size);
} else {
/* no data in the buffer */
- rv = skel_do_read_io(dev, dev->bulk_in_size);
+ rv = lpvo_do_read_io(dev, dev->bulk_in_size);
if (rv < 0)
goto exit;
else
* write functions
*/
-static void skel_write_bulk_callback(struct urb *urb)
+static void lpvo_write_bulk_callback(struct urb *urb)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
unsigned long flags;
dev = urb->context;
}
/*
- * skel_do_write() - write operations from lpvo_usb_gpib
+ * lpvo_do_write() - write operations from lpvo_usb_gpib
*/
-static ssize_t skel_do_write(struct usb_skel *dev, const char *buffer, size_t count)
+static ssize_t lpvo_do_write(struct lpvo *dev, const char *buffer, size_t count)
{
int retval = 0;
struct urb *urb = NULL;
/* initialize the urb properly */
usb_fill_bulk_urb(urb, dev->udev,
usb_sndbulkpipe(dev->udev, dev->bulk_out_endpoint_addr),
- buf, writesize, skel_write_bulk_callback, dev);
+ buf, writesize, lpvo_write_bulk_callback, dev);
urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
usb_anchor_urb(urb, &dev->submitted);
#if USER_DEVICE /* conditional compilation of user space device */
-static int skel_flush(struct file *file, fl_owner_t id)
+static int lpvo_flush(struct file *file, fl_owner_t id)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
int res;
dev = file->private_data;
/* wait for io to stop */
mutex_lock(&dev->io_mutex);
- skel_draw_down(dev);
+ lpvo_draw_down(dev);
/* read out errors, leave subsequent opens a clean slate */
spin_lock_irq(&dev->err_lock);
return res;
}
-static int skel_open(struct inode *inode, struct file *file)
+static int lpvo_open(struct inode *inode, struct file *file)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
struct usb_interface *interface;
int subminor;
int retval = 0;
subminor = iminor(inode);
- interface = usb_find_interface(&skel_driver, subminor);
+ interface = usb_find_interface(&lpvo_driver, subminor);
if (!interface) {
pr_err("can't find device for minor %d\n", subminor);
retval = -ENODEV;
return retval;
}
-static int skel_release(struct inode *inode, struct file *file)
+static int lpvo_release(struct inode *inode, struct file *file)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
dev = file->private_data;
if (!dev)
mutex_unlock(&dev->io_mutex);
/* decrement the count on our device */
- kref_put(&dev->kref, skel_delete);
+ kref_put(&dev->kref, lpvo_delete);
return 0;
}
* user space access to read function
*/
-static ssize_t skel_read(struct file *file, char __user *buffer, size_t count,
+static ssize_t lpvo_read(struct file *file, char __user *buffer, size_t count,
loff_t *ppos)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
char *buf;
ssize_t rv;
if (!buf)
return -ENOMEM;
- rv = skel_do_read(dev, buf, count);
+ rv = lpvo_do_read(dev, buf, count);
if (rv > 0) {
if (copy_to_user(buffer, buf, rv)) {
* user space access to write function
*/
-static ssize_t skel_write(struct file *file, const char __user *user_buffer,
+static ssize_t lpvo_write(struct file *file, const char __user *user_buffer,
size_t count, loff_t *ppos)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
char *buf;
ssize_t rv;
return -EFAULT;
}
- rv = skel_do_write(dev, buf, count);
+ rv = lpvo_do_write(dev, buf, count);
kfree(buf);
return rv;
}
#endif
-static const struct file_operations skel_fops = {
+static const struct file_operations lpvo_fops = {
.owner = THIS_MODULE,
#if USER_DEVICE
- .read = skel_read,
- .write = skel_write,
- .open = skel_open,
- .release = skel_release,
- .flush = skel_flush,
+ .read = lpvo_read,
+ .write = lpvo_write,
+ .open = lpvo_open,
+ .release = lpvo_release,
+ .flush = lpvo_flush,
.llseek = noop_llseek,
#endif
};
* and to have the device registered with the driver core
*/
#if USER_DEVICE
-static struct usb_class_driver skel_class = {
+static struct usb_class_driver lpvo_class = {
.name = "lpvo_raw%d",
- .fops = &skel_fops,
- .minor_base = USB_SKEL_MINOR_BASE,
+ .fops = &lpvo_fops,
+ .minor_base = USB_LPVO_MINOR_BASE,
};
#endif
-static int skel_probe(struct usb_interface *interface,
+static int lpvo_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
struct usb_endpoint_descriptor *bulk_in, *bulk_out;
int retval;
char *device_path;
#if USER_DEVICE
/* we can register the device now, as it is ready */
- retval = usb_register_dev(interface, &skel_class);
+ retval = usb_register_dev(interface, &lpvo_class);
if (retval) {
/* something prevented us from registering this driver */
dev_err(&interface->dev,
error:
/* this frees allocated memory */
- kref_put(&dev->kref, skel_delete);
+ kref_put(&dev->kref, lpvo_delete);
return retval;
}
-static void skel_disconnect(struct usb_interface *interface)
+static void lpvo_disconnect(struct usb_interface *interface)
{
- struct usb_skel *dev;
+ struct lpvo *dev;
int minor = interface->minor;
usb_gpib_exit_module(minor); /* first, disactivate the lpvo */
#if USER_DEVICE
/* give back our minor */
- usb_deregister_dev(interface, &skel_class);
+ usb_deregister_dev(interface, &lpvo_class);
#endif
/* prevent more I/O from starting */
usb_kill_anchored_urbs(&dev->submitted);
/* decrement our usage count */
- kref_put(&dev->kref, skel_delete);
+ kref_put(&dev->kref, lpvo_delete);
}
-static void skel_draw_down(struct usb_skel *dev)
+static void lpvo_draw_down(struct lpvo *dev)
{
int time;
usb_kill_urb(dev->bulk_in_urb);
}
-static int skel_suspend(struct usb_interface *intf, pm_message_t message)
+static int lpvo_suspend(struct usb_interface *intf, pm_message_t message)
{
- struct usb_skel *dev = usb_get_intfdata(intf);
+ struct lpvo *dev = usb_get_intfdata(intf);
if (!dev)
return 0;
- skel_draw_down(dev);
+ lpvo_draw_down(dev);
return 0;
}
-static int skel_resume(struct usb_interface *intf)
+static int lpvo_resume(struct usb_interface *intf)
{
return 0;
}
-static int skel_pre_reset(struct usb_interface *intf)
+static int lpvo_pre_reset(struct usb_interface *intf)
{
- struct usb_skel *dev = usb_get_intfdata(intf);
+ struct lpvo *dev = usb_get_intfdata(intf);
mutex_lock(&dev->io_mutex);
- skel_draw_down(dev);
+ lpvo_draw_down(dev);
return 0;
}
-static int skel_post_reset(struct usb_interface *intf)
+static int lpvo_post_reset(struct usb_interface *intf)
{
- struct usb_skel *dev = usb_get_intfdata(intf);
+ struct lpvo *dev = usb_get_intfdata(intf);
/* we are sure no URBs are active - no locking needed */
dev->errors = -EPIPE;
return 0;
}
-static struct usb_driver skel_driver = {
+static struct usb_driver lpvo_driver = {
.name = NAME,
- .probe = skel_probe,
- .disconnect = skel_disconnect,
- .suspend = skel_suspend,
- .resume = skel_resume,
- .pre_reset = skel_pre_reset,
- .post_reset = skel_post_reset,
- .id_table = skel_table,
+ .probe = lpvo_probe,
+ .disconnect = lpvo_disconnect,
+ .suspend = lpvo_suspend,
+ .resume = lpvo_resume,
+ .pre_reset = lpvo_pre_reset,
+ .post_reset = lpvo_post_reset,
+ .id_table = lpvo_table,
.supports_autosuspend = 1,
};
-module_usb_driver(skel_driver);
+module_usb_driver(lpvo_driver);
projects / thirdparty / linux.git / commitdiff
