Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * adutux - driver for ADU devices from Ontrak Control Systems
0004  * This is an experimental driver. Use at your own risk.
0005  * This driver is not supported by Ontrak Control Systems.
0006  *
0007  * Copyright (c) 2003 John Homppi (SCO, leave this notice here)
0008  *
0009  * derived from the Lego USB Tower driver 0.56:
0010  * Copyright (c) 2003 David Glance <davidgsf@sourceforge.net>
0011  *               2001 Juergen Stuber <stuber@loria.fr>
0012  * that was derived from USB Skeleton driver - 0.5
0013  * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com)
0014  *
0015  */
0016 
0017 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0018 
0019 #include <linux/kernel.h>
0020 #include <linux/sched/signal.h>
0021 #include <linux/errno.h>
0022 #include <linux/slab.h>
0023 #include <linux/module.h>
0024 #include <linux/usb.h>
0025 #include <linux/mutex.h>
0026 #include <linux/uaccess.h>
0027 
0028 #define DRIVER_AUTHOR "John Homppi"
0029 #define DRIVER_DESC "adutux (see www.ontrak.net)"
0030 
0031 /* Define these values to match your device */
0032 #define ADU_VENDOR_ID 0x0a07
0033 #define ADU_PRODUCT_ID 0x0064
0034 
0035 /* table of devices that work with this driver */
0036 static const struct usb_device_id device_table[] = {
0037     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID) },      /* ADU100 */
0038     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+20) },   /* ADU120 */
0039     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+30) },   /* ADU130 */
0040     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+100) },  /* ADU200 */
0041     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+108) },  /* ADU208 */
0042     { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+118) },  /* ADU218 */
0043     { } /* Terminating entry */
0044 };
0045 
0046 MODULE_DEVICE_TABLE(usb, device_table);
0047 
0048 #ifdef CONFIG_USB_DYNAMIC_MINORS
0049 #define ADU_MINOR_BASE  0
0050 #else
0051 #define ADU_MINOR_BASE  67
0052 #endif
0053 
0054 /* we can have up to this number of device plugged in at once */
0055 #define MAX_DEVICES 16
0056 
0057 #define COMMAND_TIMEOUT (2*HZ)
0058 
0059 /*
0060  * The locking scheme is a vanilla 3-lock:
0061  *   adu_device.buflock: A spinlock, covers what IRQs touch.
0062  *   adutux_mutex:       A Static lock to cover open_count. It would also cover
0063  *                       any globals, but we don't have them in 2.6.
0064  *   adu_device.mtx:     A mutex to hold across sleepers like copy_from_user.
0065  *                       It covers all of adu_device, except the open_count
0066  *                       and what .buflock covers.
0067  */
0068 
0069 /* Structure to hold all of our device specific stuff */
0070 struct adu_device {
0071     struct mutex        mtx;
0072     struct usb_device *udev; /* save off the usb device pointer */
0073     struct usb_interface *interface;
0074     unsigned int        minor; /* the starting minor number for this device */
0075     char            serial_number[8];
0076 
0077     int         open_count; /* number of times this port has been opened */
0078     unsigned long       disconnected:1;
0079 
0080     char        *read_buffer_primary;
0081     int         read_buffer_length;
0082     char        *read_buffer_secondary;
0083     int         secondary_head;
0084     int         secondary_tail;
0085     spinlock_t      buflock;
0086 
0087     wait_queue_head_t   read_wait;
0088     wait_queue_head_t   write_wait;
0089 
0090     char        *interrupt_in_buffer;
0091     struct usb_endpoint_descriptor *interrupt_in_endpoint;
0092     struct urb  *interrupt_in_urb;
0093     int         read_urb_finished;
0094 
0095     char        *interrupt_out_buffer;
0096     struct usb_endpoint_descriptor *interrupt_out_endpoint;
0097     struct urb  *interrupt_out_urb;
0098     int         out_urb_finished;
0099 };
0100 
0101 static DEFINE_MUTEX(adutux_mutex);
0102 
0103 static struct usb_driver adu_driver;
0104 
0105 static inline void adu_debug_data(struct device *dev, const char *function,
0106                   int size, const unsigned char *data)
0107 {
0108     dev_dbg(dev, "%s - length = %d, data = %*ph\n",
0109         function, size, size, data);
0110 }
0111 
0112 /*
0113  * adu_abort_transfers
0114  *      aborts transfers and frees associated data structures
0115  */
0116 static void adu_abort_transfers(struct adu_device *dev)
0117 {
0118     unsigned long flags;
0119 
0120     if (dev->disconnected)
0121         return;
0122 
0123     /* shutdown transfer */
0124 
0125     /* XXX Anchor these instead */
0126     spin_lock_irqsave(&dev->buflock, flags);
0127     if (!dev->read_urb_finished) {
0128         spin_unlock_irqrestore(&dev->buflock, flags);
0129         usb_kill_urb(dev->interrupt_in_urb);
0130     } else
0131         spin_unlock_irqrestore(&dev->buflock, flags);
0132 
0133     spin_lock_irqsave(&dev->buflock, flags);
0134     if (!dev->out_urb_finished) {
0135         spin_unlock_irqrestore(&dev->buflock, flags);
0136         wait_event_timeout(dev->write_wait, dev->out_urb_finished,
0137             COMMAND_TIMEOUT);
0138         usb_kill_urb(dev->interrupt_out_urb);
0139     } else
0140         spin_unlock_irqrestore(&dev->buflock, flags);
0141 }
0142 
0143 static void adu_delete(struct adu_device *dev)
0144 {
0145     /* free data structures */
0146     usb_free_urb(dev->interrupt_in_urb);
0147     usb_free_urb(dev->interrupt_out_urb);
0148     kfree(dev->read_buffer_primary);
0149     kfree(dev->read_buffer_secondary);
0150     kfree(dev->interrupt_in_buffer);
0151     kfree(dev->interrupt_out_buffer);
0152     usb_put_dev(dev->udev);
0153     kfree(dev);
0154 }
0155 
0156 static void adu_interrupt_in_callback(struct urb *urb)
0157 {
0158     struct adu_device *dev = urb->context;
0159     int status = urb->status;
0160     unsigned long flags;
0161 
0162     adu_debug_data(&dev->udev->dev, __func__,
0163                urb->actual_length, urb->transfer_buffer);
0164 
0165     spin_lock_irqsave(&dev->buflock, flags);
0166 
0167     if (status != 0) {
0168         if ((status != -ENOENT) && (status != -ECONNRESET) &&
0169             (status != -ESHUTDOWN)) {
0170             dev_dbg(&dev->udev->dev,
0171                 "%s : nonzero status received: %d\n",
0172                 __func__, status);
0173         }
0174         goto exit;
0175     }
0176 
0177     if (urb->actual_length > 0 && dev->interrupt_in_buffer[0] != 0x00) {
0178         if (dev->read_buffer_length <
0179             (4 * usb_endpoint_maxp(dev->interrupt_in_endpoint)) -
0180              (urb->actual_length)) {
0181             memcpy (dev->read_buffer_primary +
0182                 dev->read_buffer_length,
0183                 dev->interrupt_in_buffer, urb->actual_length);
0184 
0185             dev->read_buffer_length += urb->actual_length;
0186             dev_dbg(&dev->udev->dev, "%s reading  %d\n", __func__,
0187                 urb->actual_length);
0188         } else {
0189             dev_dbg(&dev->udev->dev, "%s : read_buffer overflow\n",
0190                 __func__);
0191         }
0192     }
0193 
0194 exit:
0195     dev->read_urb_finished = 1;
0196     spin_unlock_irqrestore(&dev->buflock, flags);
0197     /* always wake up so we recover from errors */
0198     wake_up_interruptible(&dev->read_wait);
0199 }
0200 
0201 static void adu_interrupt_out_callback(struct urb *urb)
0202 {
0203     struct adu_device *dev = urb->context;
0204     int status = urb->status;
0205     unsigned long flags;
0206 
0207     adu_debug_data(&dev->udev->dev, __func__,
0208                urb->actual_length, urb->transfer_buffer);
0209 
0210     if (status != 0) {
0211         if ((status != -ENOENT) &&
0212             (status != -ESHUTDOWN) &&
0213             (status != -ECONNRESET)) {
0214             dev_dbg(&dev->udev->dev,
0215                 "%s :nonzero status received: %d\n", __func__,
0216                 status);
0217         }
0218         return;
0219     }
0220 
0221     spin_lock_irqsave(&dev->buflock, flags);
0222     dev->out_urb_finished = 1;
0223     wake_up(&dev->write_wait);
0224     spin_unlock_irqrestore(&dev->buflock, flags);
0225 }
0226 
0227 static int adu_open(struct inode *inode, struct file *file)
0228 {
0229     struct adu_device *dev = NULL;
0230     struct usb_interface *interface;
0231     int subminor;
0232     int retval;
0233 
0234     subminor = iminor(inode);
0235 
0236     retval = mutex_lock_interruptible(&adutux_mutex);
0237     if (retval)
0238         goto exit_no_lock;
0239 
0240     interface = usb_find_interface(&adu_driver, subminor);
0241     if (!interface) {
0242         pr_err("%s - error, can't find device for minor %d\n",
0243                __func__, subminor);
0244         retval = -ENODEV;
0245         goto exit_no_device;
0246     }
0247 
0248     dev = usb_get_intfdata(interface);
0249     if (!dev) {
0250         retval = -ENODEV;
0251         goto exit_no_device;
0252     }
0253 
0254     /* check that nobody else is using the device */
0255     if (dev->open_count) {
0256         retval = -EBUSY;
0257         goto exit_no_device;
0258     }
0259 
0260     ++dev->open_count;
0261     dev_dbg(&dev->udev->dev, "%s: open count %d\n", __func__,
0262         dev->open_count);
0263 
0264     /* save device in the file's private structure */
0265     file->private_data = dev;
0266 
0267     /* initialize in direction */
0268     dev->read_buffer_length = 0;
0269 
0270     /* fixup first read by having urb waiting for it */
0271     usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
0272              usb_rcvintpipe(dev->udev,
0273                     dev->interrupt_in_endpoint->bEndpointAddress),
0274              dev->interrupt_in_buffer,
0275              usb_endpoint_maxp(dev->interrupt_in_endpoint),
0276              adu_interrupt_in_callback, dev,
0277              dev->interrupt_in_endpoint->bInterval);
0278     dev->read_urb_finished = 0;
0279     if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL))
0280         dev->read_urb_finished = 1;
0281     /* we ignore failure */
0282     /* end of fixup for first read */
0283 
0284     /* initialize out direction */
0285     dev->out_urb_finished = 1;
0286 
0287     retval = 0;
0288 
0289 exit_no_device:
0290     mutex_unlock(&adutux_mutex);
0291 exit_no_lock:
0292     return retval;
0293 }
0294 
0295 static void adu_release_internal(struct adu_device *dev)
0296 {
0297     /* decrement our usage count for the device */
0298     --dev->open_count;
0299     dev_dbg(&dev->udev->dev, "%s : open count %d\n", __func__,
0300         dev->open_count);
0301     if (dev->open_count <= 0) {
0302         adu_abort_transfers(dev);
0303         dev->open_count = 0;
0304     }
0305 }
0306 
0307 static int adu_release(struct inode *inode, struct file *file)
0308 {
0309     struct adu_device *dev;
0310     int retval = 0;
0311 
0312     if (file == NULL) {
0313         retval = -ENODEV;
0314         goto exit;
0315     }
0316 
0317     dev = file->private_data;
0318     if (dev == NULL) {
0319         retval = -ENODEV;
0320         goto exit;
0321     }
0322 
0323     mutex_lock(&adutux_mutex); /* not interruptible */
0324 
0325     if (dev->open_count <= 0) {
0326         dev_dbg(&dev->udev->dev, "%s : device not opened\n", __func__);
0327         retval = -ENODEV;
0328         goto unlock;
0329     }
0330 
0331     adu_release_internal(dev);
0332     if (dev->disconnected) {
0333         /* the device was unplugged before the file was released */
0334         if (!dev->open_count)   /* ... and we're the last user */
0335             adu_delete(dev);
0336     }
0337 unlock:
0338     mutex_unlock(&adutux_mutex);
0339 exit:
0340     return retval;
0341 }
0342 
0343 static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
0344             loff_t *ppos)
0345 {
0346     struct adu_device *dev;
0347     size_t bytes_read = 0;
0348     size_t bytes_to_read = count;
0349     int retval = 0;
0350     int timeout = 0;
0351     int should_submit = 0;
0352     unsigned long flags;
0353     DECLARE_WAITQUEUE(wait, current);
0354 
0355     dev = file->private_data;
0356     if (mutex_lock_interruptible(&dev->mtx))
0357         return -ERESTARTSYS;
0358 
0359     /* verify that the device wasn't unplugged */
0360     if (dev->disconnected) {
0361         retval = -ENODEV;
0362         pr_err("No device or device unplugged %d\n", retval);
0363         goto exit;
0364     }
0365 
0366     /* verify that some data was requested */
0367     if (count == 0) {
0368         dev_dbg(&dev->udev->dev, "%s : read request of 0 bytes\n",
0369             __func__);
0370         goto exit;
0371     }
0372 
0373     timeout = COMMAND_TIMEOUT;
0374     dev_dbg(&dev->udev->dev, "%s : about to start looping\n", __func__);
0375     while (bytes_to_read) {
0376         size_t data_in_secondary = dev->secondary_tail - dev->secondary_head;
0377         dev_dbg(&dev->udev->dev,
0378             "%s : while, data_in_secondary=%zu, status=%d\n",
0379             __func__, data_in_secondary,
0380             dev->interrupt_in_urb->status);
0381 
0382         if (data_in_secondary) {
0383             /* drain secondary buffer */
0384             size_t amount = min(bytes_to_read, data_in_secondary);
0385             if (copy_to_user(buffer, dev->read_buffer_secondary+dev->secondary_head, amount)) {
0386                 retval = -EFAULT;
0387                 goto exit;
0388             }
0389             dev->secondary_head += amount;
0390             bytes_read += amount;
0391             bytes_to_read -= amount;
0392         } else {
0393             /* we check the primary buffer */
0394             spin_lock_irqsave (&dev->buflock, flags);
0395             if (dev->read_buffer_length) {
0396                 /* we secure access to the primary */
0397                 dev_dbg(&dev->udev->dev,
0398                     "%s : swap, read_buffer_length = %d\n",
0399                     __func__, dev->read_buffer_length);
0400                 swap(dev->read_buffer_primary, dev->read_buffer_secondary);
0401                 dev->secondary_head = 0;
0402                 dev->secondary_tail = dev->read_buffer_length;
0403                 dev->read_buffer_length = 0;
0404                 spin_unlock_irqrestore(&dev->buflock, flags);
0405                 /* we have a free buffer so use it */
0406                 should_submit = 1;
0407             } else {
0408                 /* even the primary was empty - we may need to do IO */
0409                 if (!dev->read_urb_finished) {
0410                     /* somebody is doing IO */
0411                     spin_unlock_irqrestore(&dev->buflock, flags);
0412                     dev_dbg(&dev->udev->dev,
0413                         "%s : submitted already\n",
0414                         __func__);
0415                 } else {
0416                     /* we must initiate input */
0417                     dev_dbg(&dev->udev->dev,
0418                         "%s : initiate input\n",
0419                         __func__);
0420                     dev->read_urb_finished = 0;
0421                     spin_unlock_irqrestore(&dev->buflock, flags);
0422 
0423                     usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
0424                             usb_rcvintpipe(dev->udev,
0425                                 dev->interrupt_in_endpoint->bEndpointAddress),
0426                              dev->interrupt_in_buffer,
0427                              usb_endpoint_maxp(dev->interrupt_in_endpoint),
0428                              adu_interrupt_in_callback,
0429                              dev,
0430                              dev->interrupt_in_endpoint->bInterval);
0431                     retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
0432                     if (retval) {
0433                         dev->read_urb_finished = 1;
0434                         if (retval == -ENOMEM) {
0435                             retval = bytes_read ? bytes_read : -ENOMEM;
0436                         }
0437                         dev_dbg(&dev->udev->dev,
0438                             "%s : submit failed\n",
0439                             __func__);
0440                         goto exit;
0441                     }
0442                 }
0443 
0444                 /* we wait for I/O to complete */
0445                 set_current_state(TASK_INTERRUPTIBLE);
0446                 add_wait_queue(&dev->read_wait, &wait);
0447                 spin_lock_irqsave(&dev->buflock, flags);
0448                 if (!dev->read_urb_finished) {
0449                     spin_unlock_irqrestore(&dev->buflock, flags);
0450                     timeout = schedule_timeout(COMMAND_TIMEOUT);
0451                 } else {
0452                     spin_unlock_irqrestore(&dev->buflock, flags);
0453                     set_current_state(TASK_RUNNING);
0454                 }
0455                 remove_wait_queue(&dev->read_wait, &wait);
0456 
0457                 if (timeout <= 0) {
0458                     dev_dbg(&dev->udev->dev,
0459                         "%s : timeout\n", __func__);
0460                     retval = bytes_read ? bytes_read : -ETIMEDOUT;
0461                     goto exit;
0462                 }
0463 
0464                 if (signal_pending(current)) {
0465                     dev_dbg(&dev->udev->dev,
0466                         "%s : signal pending\n",
0467                         __func__);
0468                     retval = bytes_read ? bytes_read : -EINTR;
0469                     goto exit;
0470                 }
0471             }
0472         }
0473     }
0474 
0475     retval = bytes_read;
0476     /* if the primary buffer is empty then use it */
0477     spin_lock_irqsave(&dev->buflock, flags);
0478     if (should_submit && dev->read_urb_finished) {
0479         dev->read_urb_finished = 0;
0480         spin_unlock_irqrestore(&dev->buflock, flags);
0481         usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
0482                  usb_rcvintpipe(dev->udev,
0483                     dev->interrupt_in_endpoint->bEndpointAddress),
0484                 dev->interrupt_in_buffer,
0485                 usb_endpoint_maxp(dev->interrupt_in_endpoint),
0486                 adu_interrupt_in_callback,
0487                 dev,
0488                 dev->interrupt_in_endpoint->bInterval);
0489         if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL) != 0)
0490             dev->read_urb_finished = 1;
0491         /* we ignore failure */
0492     } else {
0493         spin_unlock_irqrestore(&dev->buflock, flags);
0494     }
0495 
0496 exit:
0497     /* unlock the device */
0498     mutex_unlock(&dev->mtx);
0499 
0500     return retval;
0501 }
0502 
0503 static ssize_t adu_write(struct file *file, const __user char *buffer,
0504              size_t count, loff_t *ppos)
0505 {
0506     DECLARE_WAITQUEUE(waita, current);
0507     struct adu_device *dev;
0508     size_t bytes_written = 0;
0509     size_t bytes_to_write;
0510     size_t buffer_size;
0511     unsigned long flags;
0512     int retval;
0513 
0514     dev = file->private_data;
0515 
0516     retval = mutex_lock_interruptible(&dev->mtx);
0517     if (retval)
0518         goto exit_nolock;
0519 
0520     /* verify that the device wasn't unplugged */
0521     if (dev->disconnected) {
0522         retval = -ENODEV;
0523         pr_err("No device or device unplugged %d\n", retval);
0524         goto exit;
0525     }
0526 
0527     /* verify that we actually have some data to write */
0528     if (count == 0) {
0529         dev_dbg(&dev->udev->dev, "%s : write request of 0 bytes\n",
0530             __func__);
0531         goto exit;
0532     }
0533 
0534     while (count > 0) {
0535         add_wait_queue(&dev->write_wait, &waita);
0536         set_current_state(TASK_INTERRUPTIBLE);
0537         spin_lock_irqsave(&dev->buflock, flags);
0538         if (!dev->out_urb_finished) {
0539             spin_unlock_irqrestore(&dev->buflock, flags);
0540 
0541             mutex_unlock(&dev->mtx);
0542             if (signal_pending(current)) {
0543                 dev_dbg(&dev->udev->dev, "%s : interrupted\n",
0544                     __func__);
0545                 set_current_state(TASK_RUNNING);
0546                 retval = -EINTR;
0547                 goto exit_onqueue;
0548             }
0549             if (schedule_timeout(COMMAND_TIMEOUT) == 0) {
0550                 dev_dbg(&dev->udev->dev,
0551                     "%s - command timed out.\n", __func__);
0552                 retval = -ETIMEDOUT;
0553                 goto exit_onqueue;
0554             }
0555             remove_wait_queue(&dev->write_wait, &waita);
0556             retval = mutex_lock_interruptible(&dev->mtx);
0557             if (retval) {
0558                 retval = bytes_written ? bytes_written : retval;
0559                 goto exit_nolock;
0560             }
0561 
0562             dev_dbg(&dev->udev->dev,
0563                 "%s : in progress, count = %zd\n",
0564                 __func__, count);
0565         } else {
0566             spin_unlock_irqrestore(&dev->buflock, flags);
0567             set_current_state(TASK_RUNNING);
0568             remove_wait_queue(&dev->write_wait, &waita);
0569             dev_dbg(&dev->udev->dev, "%s : sending, count = %zd\n",
0570                 __func__, count);
0571 
0572             /* write the data into interrupt_out_buffer from userspace */
0573             buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
0574             bytes_to_write = count > buffer_size ? buffer_size : count;
0575             dev_dbg(&dev->udev->dev,
0576                 "%s : buffer_size = %zd, count = %zd, bytes_to_write = %zd\n",
0577                 __func__, buffer_size, count, bytes_to_write);
0578 
0579             if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
0580                 retval = -EFAULT;
0581                 goto exit;
0582             }
0583 
0584             /* send off the urb */
0585             usb_fill_int_urb(
0586                 dev->interrupt_out_urb,
0587                 dev->udev,
0588                 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
0589                 dev->interrupt_out_buffer,
0590                 bytes_to_write,
0591                 adu_interrupt_out_callback,
0592                 dev,
0593                 dev->interrupt_out_endpoint->bInterval);
0594             dev->interrupt_out_urb->actual_length = bytes_to_write;
0595             dev->out_urb_finished = 0;
0596             retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
0597             if (retval < 0) {
0598                 dev->out_urb_finished = 1;
0599                 dev_err(&dev->udev->dev, "Couldn't submit "
0600                     "interrupt_out_urb %d\n", retval);
0601                 goto exit;
0602             }
0603 
0604             buffer += bytes_to_write;
0605             count -= bytes_to_write;
0606 
0607             bytes_written += bytes_to_write;
0608         }
0609     }
0610     mutex_unlock(&dev->mtx);
0611     return bytes_written;
0612 
0613 exit:
0614     mutex_unlock(&dev->mtx);
0615 exit_nolock:
0616     return retval;
0617 
0618 exit_onqueue:
0619     remove_wait_queue(&dev->write_wait, &waita);
0620     return retval;
0621 }
0622 
0623 /* file operations needed when we register this driver */
0624 static const struct file_operations adu_fops = {
0625     .owner = THIS_MODULE,
0626     .read  = adu_read,
0627     .write = adu_write,
0628     .open = adu_open,
0629     .release = adu_release,
0630     .llseek = noop_llseek,
0631 };
0632 
0633 /*
0634  * usb class driver info in order to get a minor number from the usb core,
0635  * and to have the device registered with devfs and the driver core
0636  */
0637 static struct usb_class_driver adu_class = {
0638     .name = "usb/adutux%d",
0639     .fops = &adu_fops,
0640     .minor_base = ADU_MINOR_BASE,
0641 };
0642 
0643 /*
0644  * adu_probe
0645  *
0646  * Called by the usb core when a new device is connected that it thinks
0647  * this driver might be interested in.
0648  */
0649 static int adu_probe(struct usb_interface *interface,
0650              const struct usb_device_id *id)
0651 {
0652     struct usb_device *udev = interface_to_usbdev(interface);
0653     struct adu_device *dev = NULL;
0654     int retval = -ENOMEM;
0655     int in_end_size;
0656     int out_end_size;
0657     int res;
0658 
0659     /* allocate memory for our device state and initialize it */
0660     dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
0661     if (!dev)
0662         return -ENOMEM;
0663 
0664     mutex_init(&dev->mtx);
0665     spin_lock_init(&dev->buflock);
0666     dev->udev = usb_get_dev(udev);
0667     init_waitqueue_head(&dev->read_wait);
0668     init_waitqueue_head(&dev->write_wait);
0669 
0670     res = usb_find_common_endpoints_reverse(interface->cur_altsetting,
0671             NULL, NULL,
0672             &dev->interrupt_in_endpoint,
0673             &dev->interrupt_out_endpoint);
0674     if (res) {
0675         dev_err(&interface->dev, "interrupt endpoints not found\n");
0676         retval = res;
0677         goto error;
0678     }
0679 
0680     in_end_size = usb_endpoint_maxp(dev->interrupt_in_endpoint);
0681     out_end_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
0682 
0683     dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL);
0684     if (!dev->read_buffer_primary)
0685         goto error;
0686 
0687     /* debug code prime the buffer */
0688     memset(dev->read_buffer_primary, 'a', in_end_size);
0689     memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size);
0690     memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size);
0691     memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size);
0692 
0693     dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL);
0694     if (!dev->read_buffer_secondary)
0695         goto error;
0696 
0697     /* debug code prime the buffer */
0698     memset(dev->read_buffer_secondary, 'e', in_end_size);
0699     memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size);
0700     memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size);
0701     memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size);
0702 
0703     dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL);
0704     if (!dev->interrupt_in_buffer)
0705         goto error;
0706 
0707     /* debug code prime the buffer */
0708     memset(dev->interrupt_in_buffer, 'i', in_end_size);
0709 
0710     dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
0711     if (!dev->interrupt_in_urb)
0712         goto error;
0713     dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL);
0714     if (!dev->interrupt_out_buffer)
0715         goto error;
0716     dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
0717     if (!dev->interrupt_out_urb)
0718         goto error;
0719 
0720     if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number,
0721             sizeof(dev->serial_number))) {
0722         dev_err(&interface->dev, "Could not retrieve serial number\n");
0723         retval = -EIO;
0724         goto error;
0725     }
0726     dev_dbg(&interface->dev, "serial_number=%s", dev->serial_number);
0727 
0728     /* we can register the device now, as it is ready */
0729     usb_set_intfdata(interface, dev);
0730 
0731     retval = usb_register_dev(interface, &adu_class);
0732 
0733     if (retval) {
0734         /* something prevented us from registering this driver */
0735         dev_err(&interface->dev, "Not able to get a minor for this device.\n");
0736         usb_set_intfdata(interface, NULL);
0737         goto error;
0738     }
0739 
0740     dev->minor = interface->minor;
0741 
0742     /* let the user know what node this device is now attached to */
0743     dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n",
0744          le16_to_cpu(udev->descriptor.idProduct), dev->serial_number,
0745          (dev->minor - ADU_MINOR_BASE));
0746 
0747     return 0;
0748 
0749 error:
0750     adu_delete(dev);
0751     return retval;
0752 }
0753 
0754 /*
0755  * adu_disconnect
0756  *
0757  * Called by the usb core when the device is removed from the system.
0758  */
0759 static void adu_disconnect(struct usb_interface *interface)
0760 {
0761     struct adu_device *dev;
0762 
0763     dev = usb_get_intfdata(interface);
0764 
0765     usb_deregister_dev(interface, &adu_class);
0766 
0767     usb_poison_urb(dev->interrupt_in_urb);
0768     usb_poison_urb(dev->interrupt_out_urb);
0769 
0770     mutex_lock(&adutux_mutex);
0771     usb_set_intfdata(interface, NULL);
0772 
0773     mutex_lock(&dev->mtx);  /* not interruptible */
0774     dev->disconnected = 1;
0775     mutex_unlock(&dev->mtx);
0776 
0777     /* if the device is not opened, then we clean up right now */
0778     if (!dev->open_count)
0779         adu_delete(dev);
0780 
0781     mutex_unlock(&adutux_mutex);
0782 }
0783 
0784 /* usb specific object needed to register this driver with the usb subsystem */
0785 static struct usb_driver adu_driver = {
0786     .name = "adutux",
0787     .probe = adu_probe,
0788     .disconnect = adu_disconnect,
0789     .id_table = device_table,
0790 };
0791 
0792 module_usb_driver(adu_driver);
0793 
0794 MODULE_AUTHOR(DRIVER_AUTHOR);
0795 MODULE_DESCRIPTION(DRIVER_DESC);
0796 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!