Lines Matching refs:dev
105 static inline void adu_debug_data(struct device *dev, const char *function,
108 dev_dbg(dev, "%s - length = %d, data = %*ph\n",
116 static void adu_abort_transfers(struct adu_device *dev)
120 if (dev->disconnected)
126 spin_lock_irqsave(&dev->buflock, flags);
127 if (!dev->read_urb_finished) {
128 spin_unlock_irqrestore(&dev->buflock, flags);
129 usb_kill_urb(dev->interrupt_in_urb);
131 spin_unlock_irqrestore(&dev->buflock, flags);
133 spin_lock_irqsave(&dev->buflock, flags);
134 if (!dev->out_urb_finished) {
135 spin_unlock_irqrestore(&dev->buflock, flags);
136 wait_event_timeout(dev->write_wait, dev->out_urb_finished,
138 usb_kill_urb(dev->interrupt_out_urb);
140 spin_unlock_irqrestore(&dev->buflock, flags);
143 static void adu_delete(struct adu_device *dev)
146 usb_free_urb(dev->interrupt_in_urb);
147 usb_free_urb(dev->interrupt_out_urb);
148 kfree(dev->read_buffer_primary);
149 kfree(dev->read_buffer_secondary);
150 kfree(dev->interrupt_in_buffer);
151 kfree(dev->interrupt_out_buffer);
152 usb_put_dev(dev->udev);
153 kfree(dev);
158 struct adu_device *dev = urb->context;
162 adu_debug_data(&dev->udev->dev, __func__,
165 spin_lock_irqsave(&dev->buflock, flags);
170 dev_dbg(&dev->udev->dev,
177 if (urb->actual_length > 0 && dev->interrupt_in_buffer[0] != 0x00) {
178 if (dev->read_buffer_length <
179 (4 * usb_endpoint_maxp(dev->interrupt_in_endpoint)) -
181 memcpy (dev->read_buffer_primary +
182 dev->read_buffer_length,
183 dev->interrupt_in_buffer, urb->actual_length);
185 dev->read_buffer_length += urb->actual_length;
186 dev_dbg(&dev->udev->dev, "%s reading %d\n", __func__,
189 dev_dbg(&dev->udev->dev, "%s : read_buffer overflow\n",
195 dev->read_urb_finished = 1;
196 spin_unlock_irqrestore(&dev->buflock, flags);
198 wake_up_interruptible(&dev->read_wait);
203 struct adu_device *dev = urb->context;
207 adu_debug_data(&dev->udev->dev, __func__,
214 dev_dbg(&dev->udev->dev,
221 spin_lock_irqsave(&dev->buflock, flags);
222 dev->out_urb_finished = 1;
223 wake_up(&dev->write_wait);
224 spin_unlock_irqrestore(&dev->buflock, flags);
229 struct adu_device *dev = NULL;
248 dev = usb_get_intfdata(interface);
249 if (!dev) {
255 if (dev->open_count) {
260 ++dev->open_count;
261 dev_dbg(&dev->udev->dev, "%s: open count %d\n", __func__,
262 dev->open_count);
265 file->private_data = dev;
268 dev->read_buffer_length = 0;
271 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
272 usb_rcvintpipe(dev->udev,
273 dev->interrupt_in_endpoint->bEndpointAddress),
274 dev->interrupt_in_buffer,
275 usb_endpoint_maxp(dev->interrupt_in_endpoint),
276 adu_interrupt_in_callback, dev,
277 dev->interrupt_in_endpoint->bInterval);
278 dev->read_urb_finished = 0;
279 if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL))
280 dev->read_urb_finished = 1;
285 dev->out_urb_finished = 1;
295 static void adu_release_internal(struct adu_device *dev)
298 --dev->open_count;
299 dev_dbg(&dev->udev->dev, "%s : open count %d\n", __func__,
300 dev->open_count);
301 if (dev->open_count <= 0) {
302 adu_abort_transfers(dev);
303 dev->open_count = 0;
309 struct adu_device *dev;
317 dev = file->private_data;
318 if (dev == NULL) {
325 if (dev->open_count <= 0) {
326 dev_dbg(&dev->udev->dev, "%s : device not opened\n", __func__);
331 adu_release_internal(dev);
332 if (dev->disconnected) {
334 if (!dev->open_count) /* ... and we're the last user */
335 adu_delete(dev);
346 struct adu_device *dev;
355 dev = file->private_data;
356 if (mutex_lock_interruptible(&dev->mtx))
360 if (dev->disconnected) {
368 dev_dbg(&dev->udev->dev, "%s : read request of 0 bytes\n",
374 dev_dbg(&dev->udev->dev, "%s : about to start looping\n", __func__);
376 size_t data_in_secondary = dev->secondary_tail - dev->secondary_head;
377 dev_dbg(&dev->udev->dev,
380 dev->interrupt_in_urb->status);
385 if (copy_to_user(buffer, dev->read_buffer_secondary+dev->secondary_head, amount)) {
389 dev->secondary_head += amount;
394 spin_lock_irqsave (&dev->buflock, flags);
395 if (dev->read_buffer_length) {
397 dev_dbg(&dev->udev->dev,
399 __func__, dev->read_buffer_length);
400 swap(dev->read_buffer_primary, dev->read_buffer_secondary);
401 dev->secondary_head = 0;
402 dev->secondary_tail = dev->read_buffer_length;
403 dev->read_buffer_length = 0;
404 spin_unlock_irqrestore(&dev->buflock, flags);
409 if (!dev->read_urb_finished) {
411 spin_unlock_irqrestore(&dev->buflock, flags);
412 dev_dbg(&dev->udev->dev,
417 dev_dbg(&dev->udev->dev,
420 dev->read_urb_finished = 0;
421 spin_unlock_irqrestore(&dev->buflock, flags);
423 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
424 usb_rcvintpipe(dev->udev,
425 dev->interrupt_in_endpoint->bEndpointAddress),
426 dev->interrupt_in_buffer,
427 usb_endpoint_maxp(dev->interrupt_in_endpoint),
429 dev,
430 dev->interrupt_in_endpoint->bInterval);
431 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
433 dev->read_urb_finished = 1;
437 dev_dbg(&dev->udev->dev,
446 add_wait_queue(&dev->read_wait, &wait);
447 spin_lock_irqsave(&dev->buflock, flags);
448 if (!dev->read_urb_finished) {
449 spin_unlock_irqrestore(&dev->buflock, flags);
452 spin_unlock_irqrestore(&dev->buflock, flags);
455 remove_wait_queue(&dev->read_wait, &wait);
458 dev_dbg(&dev->udev->dev,
465 dev_dbg(&dev->udev->dev,
477 spin_lock_irqsave(&dev->buflock, flags);
478 if (should_submit && dev->read_urb_finished) {
479 dev->read_urb_finished = 0;
480 spin_unlock_irqrestore(&dev->buflock, flags);
481 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
482 usb_rcvintpipe(dev->udev,
483 dev->interrupt_in_endpoint->bEndpointAddress),
484 dev->interrupt_in_buffer,
485 usb_endpoint_maxp(dev->interrupt_in_endpoint),
487 dev,
488 dev->interrupt_in_endpoint->bInterval);
489 if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL) != 0)
490 dev->read_urb_finished = 1;
493 spin_unlock_irqrestore(&dev->buflock, flags);
498 mutex_unlock(&dev->mtx);
507 struct adu_device *dev;
514 dev = file->private_data;
516 retval = mutex_lock_interruptible(&dev->mtx);
521 if (dev->disconnected) {
529 dev_dbg(&dev->udev->dev, "%s : write request of 0 bytes\n",
535 add_wait_queue(&dev->write_wait, &waita);
537 spin_lock_irqsave(&dev->buflock, flags);
538 if (!dev->out_urb_finished) {
539 spin_unlock_irqrestore(&dev->buflock, flags);
541 mutex_unlock(&dev->mtx);
543 dev_dbg(&dev->udev->dev, "%s : interrupted\n",
550 dev_dbg(&dev->udev->dev,
555 remove_wait_queue(&dev->write_wait, &waita);
556 retval = mutex_lock_interruptible(&dev->mtx);
562 dev_dbg(&dev->udev->dev,
566 spin_unlock_irqrestore(&dev->buflock, flags);
568 remove_wait_queue(&dev->write_wait, &waita);
569 dev_dbg(&dev->udev->dev, "%s : sending, count = %zd\n",
573 buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
575 dev_dbg(&dev->udev->dev,
579 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
586 dev->interrupt_out_urb,
587 dev->udev,
588 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
589 dev->interrupt_out_buffer,
592 dev,
593 dev->interrupt_out_endpoint->bInterval);
594 dev->interrupt_out_urb->actual_length = bytes_to_write;
595 dev->out_urb_finished = 0;
596 retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
598 dev->out_urb_finished = 1;
599 dev_err(&dev->udev->dev, "Couldn't submit "
610 mutex_unlock(&dev->mtx);
614 mutex_unlock(&dev->mtx);
619 remove_wait_queue(&dev->write_wait, &waita);
653 struct adu_device *dev = NULL;
660 dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
661 if (!dev)
664 mutex_init(&dev->mtx);
665 spin_lock_init(&dev->buflock);
666 dev->udev = usb_get_dev(udev);
667 init_waitqueue_head(&dev->read_wait);
668 init_waitqueue_head(&dev->write_wait);
672 &dev->interrupt_in_endpoint,
673 &dev->interrupt_out_endpoint);
675 dev_err(&interface->dev, "interrupt endpoints not found\n");
680 in_end_size = usb_endpoint_maxp(dev->interrupt_in_endpoint);
681 out_end_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
683 dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL);
684 if (!dev->read_buffer_primary)
688 memset(dev->read_buffer_primary, 'a', in_end_size);
689 memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size);
690 memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size);
691 memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size);
693 dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL);
694 if (!dev->read_buffer_secondary)
698 memset(dev->read_buffer_secondary, 'e', in_end_size);
699 memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size);
700 memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size);
701 memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size);
703 dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL);
704 if (!dev->interrupt_in_buffer)
708 memset(dev->interrupt_in_buffer, 'i', in_end_size);
710 dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
711 if (!dev->interrupt_in_urb)
713 dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL);
714 if (!dev->interrupt_out_buffer)
716 dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
717 if (!dev->interrupt_out_urb)
720 if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number,
721 sizeof(dev->serial_number))) {
722 dev_err(&interface->dev, "Could not retrieve serial number\n");
726 dev_dbg(&interface->dev, "serial_number=%s", dev->serial_number);
729 usb_set_intfdata(interface, dev);
735 dev_err(&interface->dev, "Not able to get a minor for this device.\n");
740 dev->minor = interface->minor;
743 dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n",
744 le16_to_cpu(udev->descriptor.idProduct), dev->serial_number,
745 (dev->minor - ADU_MINOR_BASE));
750 adu_delete(dev);
761 struct adu_device *dev;
763 dev = usb_get_intfdata(interface);
767 usb_poison_urb(dev->interrupt_in_urb);
768 usb_poison_urb(dev->interrupt_out_urb);
773 mutex_lock(&dev->mtx); /* not interruptible */
774 dev->disconnected = 1;
775 mutex_unlock(&dev->mtx);
778 if (!dev->open_count)
779 adu_delete(dev);