4 * This driver supports USB CDC WCM Device Management.
6 * Copyright (c) 2007-2009 Oliver Neukum
8 * Some code taken from cdc-acm.c
10 * Released under the GPLv2.
12 * Many thanks to Carl Nordbeck
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/mutex.h>
19 #include <linux/uaccess.h>
20 #include <linux/bitops.h>
21 #include <linux/poll.h>
22 #include <linux/usb.h>
23 #include <linux/usb/cdc.h>
24 #include <asm/byteorder.h>
25 #include <asm/unaligned.h>
30 #define DRIVER_VERSION "v0.03"
31 #define DRIVER_AUTHOR "Oliver Neukum"
32 #define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
34 static const struct usb_device_id wdm_ids
[] = {
36 .match_flags
= USB_DEVICE_ID_MATCH_INT_CLASS
|
37 USB_DEVICE_ID_MATCH_INT_SUBCLASS
,
38 .bInterfaceClass
= USB_CLASS_COMM
,
39 .bInterfaceSubClass
= USB_CDC_SUBCLASS_DMM
44 MODULE_DEVICE_TABLE (usb
, wdm_ids
);
46 #define WDM_MINOR_BASE 176
50 #define WDM_DISCONNECTING 2
53 #define WDM_INT_STALL 5
54 #define WDM_POLL_RUNNING 6
55 #define WDM_RESPONDING 7
56 #define WDM_SUSPENDING 8
61 static DEFINE_MUTEX(wdm_mutex
);
63 /* --- method tables --- */
66 u8
*inbuf
; /* buffer for response */
67 u8
*outbuf
; /* buffer for command */
68 u8
*sbuf
; /* buffer for status */
69 u8
*ubuf
; /* buffer for copy to user space */
74 struct usb_interface
*intf
;
75 struct usb_ctrlrequest
*orq
;
76 struct usb_ctrlrequest
*irq
;
93 wait_queue_head_t wait
;
94 struct work_struct rxwork
;
99 static struct usb_driver wdm_driver
;
101 /* --- callbacks --- */
102 static void wdm_out_callback(struct urb
*urb
)
104 struct wdm_device
*desc
;
106 spin_lock(&desc
->iuspin
);
107 desc
->werr
= urb
->status
;
108 spin_unlock(&desc
->iuspin
);
109 clear_bit(WDM_IN_USE
, &desc
->flags
);
111 wake_up(&desc
->wait
);
114 static void wdm_in_callback(struct urb
*urb
)
116 struct wdm_device
*desc
= urb
->context
;
117 int status
= urb
->status
;
119 spin_lock(&desc
->iuspin
);
120 clear_bit(WDM_RESPONDING
, &desc
->flags
);
125 dev_dbg(&desc
->intf
->dev
,
126 "nonzero urb status received: -ENOENT");
129 dev_dbg(&desc
->intf
->dev
,
130 "nonzero urb status received: -ECONNRESET");
133 dev_dbg(&desc
->intf
->dev
,
134 "nonzero urb status received: -ESHUTDOWN");
137 dev_err(&desc
->intf
->dev
,
138 "nonzero urb status received: -EPIPE\n");
141 dev_err(&desc
->intf
->dev
,
142 "Unexpected error %d\n", status
);
148 desc
->reslength
= urb
->actual_length
;
149 memmove(desc
->ubuf
+ desc
->length
, desc
->inbuf
, desc
->reslength
);
150 desc
->length
+= desc
->reslength
;
152 wake_up(&desc
->wait
);
154 set_bit(WDM_READ
, &desc
->flags
);
155 spin_unlock(&desc
->iuspin
);
158 static void wdm_int_callback(struct urb
*urb
)
161 int status
= urb
->status
;
162 struct wdm_device
*desc
;
163 struct usb_ctrlrequest
*req
;
164 struct usb_cdc_notification
*dr
;
168 dr
= (struct usb_cdc_notification
*)desc
->sbuf
;
177 set_bit(WDM_INT_STALL
, &desc
->flags
);
178 dev_err(&desc
->intf
->dev
, "Stall on int endpoint\n");
179 goto sw
; /* halt is cleared in work */
181 dev_err(&desc
->intf
->dev
,
182 "nonzero urb status received: %d\n", status
);
187 if (urb
->actual_length
< sizeof(struct usb_cdc_notification
)) {
188 dev_err(&desc
->intf
->dev
, "wdm_int_callback - %d bytes\n",
193 switch (dr
->bNotificationType
) {
194 case USB_CDC_NOTIFY_RESPONSE_AVAILABLE
:
195 dev_dbg(&desc
->intf
->dev
,
196 "NOTIFY_RESPONSE_AVAILABLE received: index %d len %d",
197 dr
->wIndex
, dr
->wLength
);
200 case USB_CDC_NOTIFY_NETWORK_CONNECTION
:
202 dev_dbg(&desc
->intf
->dev
,
203 "NOTIFY_NETWORK_CONNECTION %s network",
204 dr
->wValue
? "connected to" : "disconnected from");
207 clear_bit(WDM_POLL_RUNNING
, &desc
->flags
);
208 dev_err(&desc
->intf
->dev
,
209 "unknown notification %d received: index %d len %d\n",
210 dr
->bNotificationType
, dr
->wIndex
, dr
->wLength
);
214 req
->bRequestType
= (USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
);
215 req
->bRequest
= USB_CDC_GET_ENCAPSULATED_RESPONSE
;
217 req
->wIndex
= desc
->inum
;
218 req
->wLength
= cpu_to_le16(desc
->wMaxCommand
);
220 usb_fill_control_urb(
222 interface_to_usbdev(desc
->intf
),
223 /* using common endpoint 0 */
224 usb_rcvctrlpipe(interface_to_usbdev(desc
->intf
), 0),
225 (unsigned char *)req
,
231 desc
->response
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
232 spin_lock(&desc
->iuspin
);
233 clear_bit(WDM_READ
, &desc
->flags
);
234 set_bit(WDM_RESPONDING
, &desc
->flags
);
235 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
)
236 && !test_bit(WDM_SUSPENDING
, &desc
->flags
)) {
237 rv
= usb_submit_urb(desc
->response
, GFP_ATOMIC
);
238 dev_dbg(&desc
->intf
->dev
, "%s: usb_submit_urb %d",
241 spin_unlock(&desc
->iuspin
);
243 clear_bit(WDM_RESPONDING
, &desc
->flags
);
248 rv
= schedule_work(&desc
->rxwork
);
250 dev_err(&desc
->intf
->dev
,
251 "Cannot schedule work\n");
255 rv
= usb_submit_urb(urb
, GFP_ATOMIC
);
257 dev_err(&desc
->intf
->dev
,
258 "%s - usb_submit_urb failed with result %d\n",
263 static void kill_urbs(struct wdm_device
*desc
)
265 /* the order here is essential */
266 usb_kill_urb(desc
->command
);
267 usb_kill_urb(desc
->validity
);
268 usb_kill_urb(desc
->response
);
271 static void free_urbs(struct wdm_device
*desc
)
273 usb_free_urb(desc
->validity
);
274 usb_free_urb(desc
->response
);
275 usb_free_urb(desc
->command
);
278 static void cleanup(struct wdm_device
*desc
)
280 usb_free_coherent(interface_to_usbdev(desc
->intf
),
281 desc
->wMaxPacketSize
,
283 desc
->validity
->transfer_dma
);
284 usb_free_coherent(interface_to_usbdev(desc
->intf
),
285 desc
->bMaxPacketSize0
,
287 desc
->response
->transfer_dma
);
295 static ssize_t wdm_write
296 (struct file
*file
, const char __user
*buffer
, size_t count
, loff_t
*ppos
)
299 int rv
= -EMSGSIZE
, r
, we
;
300 struct wdm_device
*desc
= file
->private_data
;
301 struct usb_ctrlrequest
*req
;
303 if (count
> desc
->wMaxCommand
)
304 count
= desc
->wMaxCommand
;
306 spin_lock_irq(&desc
->iuspin
);
309 spin_unlock_irq(&desc
->iuspin
);
313 desc
->outbuf
= buf
= kmalloc(count
, GFP_KERNEL
);
319 r
= copy_from_user(buf
, buffer
, count
);
326 /* concurrent writes and disconnect */
327 r
= mutex_lock_interruptible(&desc
->wlock
);
334 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
340 r
= usb_autopm_get_interface(desc
->intf
);
346 if (!(file
->f_flags
& O_NONBLOCK
))
347 r
= wait_event_interruptible(desc
->wait
, !test_bit(WDM_IN_USE
,
350 if (test_bit(WDM_IN_USE
, &desc
->flags
))
358 usb_fill_control_urb(
360 interface_to_usbdev(desc
->intf
),
361 /* using common endpoint 0 */
362 usb_sndctrlpipe(interface_to_usbdev(desc
->intf
), 0),
363 (unsigned char *)req
,
370 req
->bRequestType
= (USB_DIR_OUT
| USB_TYPE_CLASS
|
371 USB_RECIP_INTERFACE
);
372 req
->bRequest
= USB_CDC_SEND_ENCAPSULATED_COMMAND
;
374 req
->wIndex
= desc
->inum
;
375 req
->wLength
= cpu_to_le16(count
);
376 set_bit(WDM_IN_USE
, &desc
->flags
);
378 rv
= usb_submit_urb(desc
->command
, GFP_KERNEL
);
381 clear_bit(WDM_IN_USE
, &desc
->flags
);
382 dev_err(&desc
->intf
->dev
, "Tx URB error: %d\n", rv
);
384 dev_dbg(&desc
->intf
->dev
, "Tx URB has been submitted index=%d",
388 usb_autopm_put_interface(desc
->intf
);
390 mutex_unlock(&desc
->wlock
);
392 return rv
< 0 ? rv
: count
;
395 static ssize_t wdm_read
396 (struct file
*file
, char __user
*buffer
, size_t count
, loff_t
*ppos
)
400 struct wdm_device
*desc
= file
->private_data
;
403 rv
= mutex_lock_interruptible(&desc
->rlock
); /*concurrent reads */
407 if (desc
->length
== 0) {
410 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
415 if (file
->f_flags
& O_NONBLOCK
) {
416 if (!test_bit(WDM_READ
, &desc
->flags
)) {
417 rv
= cntr
? cntr
: -EAGAIN
;
422 rv
= wait_event_interruptible(desc
->wait
,
423 test_bit(WDM_READ
, &desc
->flags
));
426 /* may have happened while we slept */
427 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
431 usb_mark_last_busy(interface_to_usbdev(desc
->intf
));
437 spin_lock_irq(&desc
->iuspin
);
439 if (desc
->rerr
) { /* read completed, error happened */
441 spin_unlock_irq(&desc
->iuspin
);
446 * recheck whether we've lost the race
447 * against the completion handler
449 if (!test_bit(WDM_READ
, &desc
->flags
)) { /* lost race */
450 spin_unlock_irq(&desc
->iuspin
);
453 if (!desc
->reslength
) { /* zero length read */
454 spin_unlock_irq(&desc
->iuspin
);
457 clear_bit(WDM_READ
, &desc
->flags
);
458 spin_unlock_irq(&desc
->iuspin
);
461 cntr
= count
> desc
->length
? desc
->length
: count
;
462 rv
= copy_to_user(buffer
, desc
->ubuf
, cntr
);
468 for (i
= 0; i
< desc
->length
- cntr
; i
++)
469 desc
->ubuf
[i
] = desc
->ubuf
[i
+ cntr
];
471 spin_lock_irq(&desc
->iuspin
);
472 desc
->length
-= cntr
;
473 spin_unlock_irq(&desc
->iuspin
);
474 /* in case we had outstanding data */
476 clear_bit(WDM_READ
, &desc
->flags
);
480 mutex_unlock(&desc
->rlock
);
484 static int wdm_flush(struct file
*file
, fl_owner_t id
)
486 struct wdm_device
*desc
= file
->private_data
;
488 wait_event(desc
->wait
, !test_bit(WDM_IN_USE
, &desc
->flags
));
490 dev_err(&desc
->intf
->dev
, "Error in flush path: %d\n",
496 static unsigned int wdm_poll(struct file
*file
, struct poll_table_struct
*wait
)
498 struct wdm_device
*desc
= file
->private_data
;
500 unsigned int mask
= 0;
502 spin_lock_irqsave(&desc
->iuspin
, flags
);
503 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
505 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
508 if (test_bit(WDM_READ
, &desc
->flags
))
509 mask
= POLLIN
| POLLRDNORM
;
510 if (desc
->rerr
|| desc
->werr
)
512 if (!test_bit(WDM_IN_USE
, &desc
->flags
))
513 mask
|= POLLOUT
| POLLWRNORM
;
514 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
516 poll_wait(file
, &desc
->wait
, wait
);
522 static int wdm_open(struct inode
*inode
, struct file
*file
)
524 int minor
= iminor(inode
);
526 struct usb_interface
*intf
;
527 struct wdm_device
*desc
;
529 mutex_lock(&wdm_mutex
);
530 intf
= usb_find_interface(&wdm_driver
, minor
);
534 desc
= usb_get_intfdata(intf
);
535 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
))
537 file
->private_data
= desc
;
539 rv
= usb_autopm_get_interface(desc
->intf
);
541 dev_err(&desc
->intf
->dev
, "Error autopm - %d\n", rv
);
544 intf
->needs_remote_wakeup
= 1;
546 /* using write lock to protect desc->count */
547 mutex_lock(&desc
->wlock
);
548 if (!desc
->count
++) {
551 rv
= usb_submit_urb(desc
->validity
, GFP_KERNEL
);
554 dev_err(&desc
->intf
->dev
,
555 "Error submitting int urb - %d\n", rv
);
560 mutex_unlock(&desc
->wlock
);
561 usb_autopm_put_interface(desc
->intf
);
563 mutex_unlock(&wdm_mutex
);
567 static int wdm_release(struct inode
*inode
, struct file
*file
)
569 struct wdm_device
*desc
= file
->private_data
;
571 mutex_lock(&wdm_mutex
);
573 /* using write lock to protect desc->count */
574 mutex_lock(&desc
->wlock
);
576 mutex_unlock(&desc
->wlock
);
579 dev_dbg(&desc
->intf
->dev
, "wdm_release: cleanup");
581 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
))
582 desc
->intf
->needs_remote_wakeup
= 0;
584 mutex_unlock(&wdm_mutex
);
588 static const struct file_operations wdm_fops
= {
589 .owner
= THIS_MODULE
,
594 .release
= wdm_release
,
596 .llseek
= noop_llseek
,
599 static struct usb_class_driver wdm_class
= {
602 .minor_base
= WDM_MINOR_BASE
,
605 /* --- error handling --- */
606 static void wdm_rxwork(struct work_struct
*work
)
608 struct wdm_device
*desc
= container_of(work
, struct wdm_device
, rxwork
);
612 spin_lock_irqsave(&desc
->iuspin
, flags
);
613 if (test_bit(WDM_DISCONNECTING
, &desc
->flags
)) {
614 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
616 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
617 rv
= usb_submit_urb(desc
->response
, GFP_KERNEL
);
618 if (rv
< 0 && rv
!= -EPERM
) {
619 spin_lock_irqsave(&desc
->iuspin
, flags
);
620 if (!test_bit(WDM_DISCONNECTING
, &desc
->flags
))
621 schedule_work(&desc
->rxwork
);
622 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
627 /* --- hotplug --- */
629 static int wdm_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
632 struct usb_device
*udev
= interface_to_usbdev(intf
);
633 struct wdm_device
*desc
;
634 struct usb_host_interface
*iface
;
635 struct usb_endpoint_descriptor
*ep
;
636 struct usb_cdc_dmm_desc
*dmhd
;
637 u8
*buffer
= intf
->altsetting
->extra
;
638 int buflen
= intf
->altsetting
->extralen
;
645 if (buffer
[1] != USB_DT_CS_INTERFACE
) {
646 dev_err(&intf
->dev
, "skipping garbage\n");
650 switch (buffer
[2]) {
651 case USB_CDC_HEADER_TYPE
:
653 case USB_CDC_DMM_TYPE
:
654 dmhd
= (struct usb_cdc_dmm_desc
*)buffer
;
655 maxcom
= le16_to_cpu(dmhd
->wMaxCommand
);
657 "Finding maximum buffer length: %d", maxcom
);
661 "Ignoring extra header, type %d, length %d\n",
662 buffer
[2], buffer
[0]);
671 desc
= kzalloc(sizeof(struct wdm_device
), GFP_KERNEL
);
674 mutex_init(&desc
->rlock
);
675 mutex_init(&desc
->wlock
);
676 spin_lock_init(&desc
->iuspin
);
677 init_waitqueue_head(&desc
->wait
);
678 desc
->wMaxCommand
= maxcom
;
679 /* this will be expanded and needed in hardware endianness */
680 desc
->inum
= cpu_to_le16((u16
)intf
->cur_altsetting
->desc
.bInterfaceNumber
);
682 INIT_WORK(&desc
->rxwork
, wdm_rxwork
);
685 iface
= intf
->cur_altsetting
;
686 if (iface
->desc
.bNumEndpoints
!= 1)
688 ep
= &iface
->endpoint
[0].desc
;
689 if (!ep
|| !usb_endpoint_is_int_in(ep
))
692 desc
->wMaxPacketSize
= usb_endpoint_maxp(ep
);
693 desc
->bMaxPacketSize0
= udev
->descriptor
.bMaxPacketSize0
;
695 desc
->orq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
698 desc
->irq
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
702 desc
->validity
= usb_alloc_urb(0, GFP_KERNEL
);
706 desc
->response
= usb_alloc_urb(0, GFP_KERNEL
);
710 desc
->command
= usb_alloc_urb(0, GFP_KERNEL
);
714 desc
->ubuf
= kmalloc(desc
->wMaxCommand
, GFP_KERNEL
);
718 desc
->sbuf
= usb_alloc_coherent(interface_to_usbdev(intf
),
719 desc
->wMaxPacketSize
,
721 &desc
->validity
->transfer_dma
);
725 desc
->inbuf
= usb_alloc_coherent(interface_to_usbdev(intf
),
726 desc
->bMaxPacketSize0
,
728 &desc
->response
->transfer_dma
);
734 interface_to_usbdev(intf
),
735 usb_rcvintpipe(interface_to_usbdev(intf
), ep
->bEndpointAddress
),
737 desc
->wMaxPacketSize
,
742 desc
->validity
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
744 usb_set_intfdata(intf
, desc
);
745 rv
= usb_register_dev(intf
, &wdm_class
);
749 dev_info(&intf
->dev
, "cdc-wdm%d: USB WDM device\n",
750 intf
->minor
- WDM_MINOR_BASE
);
754 usb_set_intfdata(intf
, NULL
);
755 usb_free_coherent(interface_to_usbdev(desc
->intf
),
756 desc
->bMaxPacketSize0
,
758 desc
->response
->transfer_dma
);
760 usb_free_coherent(interface_to_usbdev(desc
->intf
),
761 desc
->wMaxPacketSize
,
763 desc
->validity
->transfer_dma
);
773 static void wdm_disconnect(struct usb_interface
*intf
)
775 struct wdm_device
*desc
;
778 usb_deregister_dev(intf
, &wdm_class
);
779 mutex_lock(&wdm_mutex
);
780 desc
= usb_get_intfdata(intf
);
782 /* the spinlock makes sure no new urbs are generated in the callbacks */
783 spin_lock_irqsave(&desc
->iuspin
, flags
);
784 set_bit(WDM_DISCONNECTING
, &desc
->flags
);
785 set_bit(WDM_READ
, &desc
->flags
);
786 /* to terminate pending flushes */
787 clear_bit(WDM_IN_USE
, &desc
->flags
);
788 spin_unlock_irqrestore(&desc
->iuspin
, flags
);
789 mutex_lock(&desc
->rlock
);
790 mutex_lock(&desc
->wlock
);
792 cancel_work_sync(&desc
->rxwork
);
793 mutex_unlock(&desc
->wlock
);
794 mutex_unlock(&desc
->rlock
);
795 wake_up_all(&desc
->wait
);
798 mutex_unlock(&wdm_mutex
);
802 static int wdm_suspend(struct usb_interface
*intf
, pm_message_t message
)
804 struct wdm_device
*desc
= usb_get_intfdata(intf
);
807 dev_dbg(&desc
->intf
->dev
, "wdm%d_suspend\n", intf
->minor
);
809 /* if this is an autosuspend the caller does the locking */
810 if (!PMSG_IS_AUTO(message
)) {
811 mutex_lock(&desc
->rlock
);
812 mutex_lock(&desc
->wlock
);
814 spin_lock_irq(&desc
->iuspin
);
816 if (PMSG_IS_AUTO(message
) &&
817 (test_bit(WDM_IN_USE
, &desc
->flags
)
818 || test_bit(WDM_RESPONDING
, &desc
->flags
))) {
819 spin_unlock_irq(&desc
->iuspin
);
823 set_bit(WDM_SUSPENDING
, &desc
->flags
);
824 spin_unlock_irq(&desc
->iuspin
);
825 /* callback submits work - order is essential */
827 cancel_work_sync(&desc
->rxwork
);
829 if (!PMSG_IS_AUTO(message
)) {
830 mutex_unlock(&desc
->wlock
);
831 mutex_unlock(&desc
->rlock
);
838 static int recover_from_urb_loss(struct wdm_device
*desc
)
843 rv
= usb_submit_urb(desc
->validity
, GFP_NOIO
);
845 dev_err(&desc
->intf
->dev
,
846 "Error resume submitting int urb - %d\n", rv
);
852 static int wdm_resume(struct usb_interface
*intf
)
854 struct wdm_device
*desc
= usb_get_intfdata(intf
);
857 dev_dbg(&desc
->intf
->dev
, "wdm%d_resume\n", intf
->minor
);
859 clear_bit(WDM_SUSPENDING
, &desc
->flags
);
860 rv
= recover_from_urb_loss(desc
);
866 static int wdm_pre_reset(struct usb_interface
*intf
)
868 struct wdm_device
*desc
= usb_get_intfdata(intf
);
870 mutex_lock(&desc
->rlock
);
871 mutex_lock(&desc
->wlock
);
875 * we notify everybody using poll of
876 * an exceptional situation
877 * must be done before recovery lest a spontaneous
878 * message from the device is lost
880 spin_lock_irq(&desc
->iuspin
);
882 spin_unlock_irq(&desc
->iuspin
);
883 wake_up_all(&desc
->wait
);
887 static int wdm_post_reset(struct usb_interface
*intf
)
889 struct wdm_device
*desc
= usb_get_intfdata(intf
);
892 rv
= recover_from_urb_loss(desc
);
893 mutex_unlock(&desc
->wlock
);
894 mutex_unlock(&desc
->rlock
);
898 static struct usb_driver wdm_driver
= {
901 .disconnect
= wdm_disconnect
,
903 .suspend
= wdm_suspend
,
904 .resume
= wdm_resume
,
905 .reset_resume
= wdm_resume
,
907 .pre_reset
= wdm_pre_reset
,
908 .post_reset
= wdm_post_reset
,
910 .supports_autosuspend
= 1,
913 /* --- low level module stuff --- */
915 static int __init
wdm_init(void)
919 rv
= usb_register(&wdm_driver
);
924 static void __exit
wdm_exit(void)
926 usb_deregister(&wdm_driver
);
929 module_init(wdm_init
);
930 module_exit(wdm_exit
);
932 MODULE_AUTHOR(DRIVER_AUTHOR
);
933 MODULE_DESCRIPTION(DRIVER_DESC
);
934 MODULE_LICENSE("GPL");