1 /* 2 USB Driver layer for GSM modems 3 4 Copyright (C) 2005 Matthias Urlichs <smurf@smurf.noris.de> 5 6 This driver is free software; you can redistribute it and/or modify 7 it under the terms of Version 2 of the GNU General Public License as 8 published by the Free Software Foundation. 9 10 Portions copied from the Keyspan driver by Hugh Blemings <hugh@blemings.org> 11 12 History: see the git log. 13 14 Work sponsored by: Sigos GmbH, Germany <info@sigos.de> 15 16 This driver exists because the "normal" serial driver doesn't work too well 17 with GSM modems. Issues: 18 - data loss -- one single Receive URB is not nearly enough 19 - controlling the baud rate doesn't make sense 20 */ 21 22 #define DRIVER_AUTHOR "Matthias Urlichs <smurf@smurf.noris.de>" 23 #define DRIVER_DESC "USB Driver for GSM modems" 24 25 #include <linux/kernel.h> 26 #include <linux/jiffies.h> 27 #include <linux/errno.h> 28 #include <linux/slab.h> 29 #include <linux/tty.h> 30 #include <linux/tty_flip.h> 31 #include <linux/module.h> 32 #include <linux/bitops.h> 33 #include <linux/uaccess.h> 34 #include <linux/usb.h> 35 #include <linux/usb/serial.h> 36 #include <linux/serial.h> 37 #include "usb-wwan.h" 38 39 /* 40 * Generate DTR/RTS signals on the port using the SET_CONTROL_LINE_STATE request 41 * in CDC ACM. 42 */ 43 static int usb_wwan_send_setup(struct usb_serial_port *port) 44 { 45 struct usb_serial *serial = port->serial; 46 struct usb_wwan_port_private *portdata; 47 int val = 0; 48 int ifnum; 49 int res; 50 51 portdata = usb_get_serial_port_data(port); 52 53 if (portdata->dtr_state) 54 val |= 0x01; 55 if (portdata->rts_state) 56 val |= 0x02; 57 58 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; 59 60 res = usb_autopm_get_interface(serial->interface); 61 if (res) 62 return res; 63 64 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 65 0x22, 0x21, val, ifnum, NULL, 0, 66 USB_CTRL_SET_TIMEOUT); 67 68 usb_autopm_put_interface(port->serial->interface); 69 70 return res; 71 } 72 73 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on) 74 { 75 struct usb_wwan_port_private *portdata; 76 struct usb_wwan_intf_private *intfdata; 77 78 intfdata = usb_get_serial_data(port->serial); 79 80 if (!intfdata->use_send_setup) 81 return; 82 83 portdata = usb_get_serial_port_data(port); 84 /* FIXME: locking */ 85 portdata->rts_state = on; 86 portdata->dtr_state = on; 87 88 usb_wwan_send_setup(port); 89 } 90 EXPORT_SYMBOL(usb_wwan_dtr_rts); 91 92 int usb_wwan_tiocmget(struct tty_struct *tty) 93 { 94 struct usb_serial_port *port = tty->driver_data; 95 unsigned int value; 96 struct usb_wwan_port_private *portdata; 97 98 portdata = usb_get_serial_port_data(port); 99 100 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 101 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 102 ((portdata->cts_state) ? TIOCM_CTS : 0) | 103 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 104 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 105 ((portdata->ri_state) ? TIOCM_RNG : 0); 106 107 return value; 108 } 109 EXPORT_SYMBOL(usb_wwan_tiocmget); 110 111 int usb_wwan_tiocmset(struct tty_struct *tty, 112 unsigned int set, unsigned int clear) 113 { 114 struct usb_serial_port *port = tty->driver_data; 115 struct usb_wwan_port_private *portdata; 116 struct usb_wwan_intf_private *intfdata; 117 118 portdata = usb_get_serial_port_data(port); 119 intfdata = usb_get_serial_data(port->serial); 120 121 if (!intfdata->use_send_setup) 122 return -EINVAL; 123 124 /* FIXME: what locks portdata fields ? */ 125 if (set & TIOCM_RTS) 126 portdata->rts_state = 1; 127 if (set & TIOCM_DTR) 128 portdata->dtr_state = 1; 129 130 if (clear & TIOCM_RTS) 131 portdata->rts_state = 0; 132 if (clear & TIOCM_DTR) 133 portdata->dtr_state = 0; 134 return usb_wwan_send_setup(port); 135 } 136 EXPORT_SYMBOL(usb_wwan_tiocmset); 137 138 static int get_serial_info(struct usb_serial_port *port, 139 struct serial_struct __user *retinfo) 140 { 141 struct serial_struct tmp; 142 143 memset(&tmp, 0, sizeof(tmp)); 144 tmp.line = port->minor; 145 tmp.port = port->port_number; 146 tmp.baud_base = tty_get_baud_rate(port->port.tty); 147 tmp.close_delay = port->port.close_delay / 10; 148 tmp.closing_wait = port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 149 ASYNC_CLOSING_WAIT_NONE : 150 port->port.closing_wait / 10; 151 152 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 153 return -EFAULT; 154 return 0; 155 } 156 157 static int set_serial_info(struct usb_serial_port *port, 158 struct serial_struct __user *newinfo) 159 { 160 struct serial_struct new_serial; 161 unsigned int closing_wait, close_delay; 162 int retval = 0; 163 164 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial))) 165 return -EFAULT; 166 167 close_delay = new_serial.close_delay * 10; 168 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 169 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10; 170 171 mutex_lock(&port->port.mutex); 172 173 if (!capable(CAP_SYS_ADMIN)) { 174 if ((close_delay != port->port.close_delay) || 175 (closing_wait != port->port.closing_wait)) 176 retval = -EPERM; 177 else 178 retval = -EOPNOTSUPP; 179 } else { 180 port->port.close_delay = close_delay; 181 port->port.closing_wait = closing_wait; 182 } 183 184 mutex_unlock(&port->port.mutex); 185 return retval; 186 } 187 188 int usb_wwan_ioctl(struct tty_struct *tty, 189 unsigned int cmd, unsigned long arg) 190 { 191 struct usb_serial_port *port = tty->driver_data; 192 193 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd); 194 195 switch (cmd) { 196 case TIOCGSERIAL: 197 return get_serial_info(port, 198 (struct serial_struct __user *) arg); 199 case TIOCSSERIAL: 200 return set_serial_info(port, 201 (struct serial_struct __user *) arg); 202 default: 203 break; 204 } 205 206 dev_dbg(&port->dev, "%s arg not supported\n", __func__); 207 208 return -ENOIOCTLCMD; 209 } 210 EXPORT_SYMBOL(usb_wwan_ioctl); 211 212 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port, 213 const unsigned char *buf, int count) 214 { 215 struct usb_wwan_port_private *portdata; 216 struct usb_wwan_intf_private *intfdata; 217 int i; 218 int left, todo; 219 struct urb *this_urb = NULL; /* spurious */ 220 int err; 221 unsigned long flags; 222 223 portdata = usb_get_serial_port_data(port); 224 intfdata = usb_get_serial_data(port->serial); 225 226 dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count); 227 228 i = 0; 229 left = count; 230 for (i = 0; left > 0 && i < N_OUT_URB; i++) { 231 todo = left; 232 if (todo > OUT_BUFLEN) 233 todo = OUT_BUFLEN; 234 235 this_urb = portdata->out_urbs[i]; 236 if (test_and_set_bit(i, &portdata->out_busy)) { 237 if (time_before(jiffies, 238 portdata->tx_start_time[i] + 10 * HZ)) 239 continue; 240 usb_unlink_urb(this_urb); 241 continue; 242 } 243 dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__, 244 usb_pipeendpoint(this_urb->pipe), i); 245 246 err = usb_autopm_get_interface_async(port->serial->interface); 247 if (err < 0) { 248 clear_bit(i, &portdata->out_busy); 249 break; 250 } 251 252 /* send the data */ 253 memcpy(this_urb->transfer_buffer, buf, todo); 254 this_urb->transfer_buffer_length = todo; 255 256 spin_lock_irqsave(&intfdata->susp_lock, flags); 257 if (intfdata->suspended) { 258 usb_anchor_urb(this_urb, &portdata->delayed); 259 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 260 } else { 261 intfdata->in_flight++; 262 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 263 err = usb_submit_urb(this_urb, GFP_ATOMIC); 264 if (err) { 265 dev_err(&port->dev, 266 "%s: submit urb %d failed: %d\n", 267 __func__, i, err); 268 clear_bit(i, &portdata->out_busy); 269 spin_lock_irqsave(&intfdata->susp_lock, flags); 270 intfdata->in_flight--; 271 spin_unlock_irqrestore(&intfdata->susp_lock, 272 flags); 273 usb_autopm_put_interface_async(port->serial->interface); 274 break; 275 } 276 } 277 278 portdata->tx_start_time[i] = jiffies; 279 buf += todo; 280 left -= todo; 281 } 282 283 count -= left; 284 dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count); 285 return count; 286 } 287 EXPORT_SYMBOL(usb_wwan_write); 288 289 static void usb_wwan_indat_callback(struct urb *urb) 290 { 291 int err; 292 int endpoint; 293 struct usb_serial_port *port; 294 struct device *dev; 295 unsigned char *data = urb->transfer_buffer; 296 int status = urb->status; 297 298 endpoint = usb_pipeendpoint(urb->pipe); 299 port = urb->context; 300 dev = &port->dev; 301 302 if (status) { 303 dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n", 304 __func__, status, endpoint); 305 } else { 306 if (urb->actual_length) { 307 tty_insert_flip_string(&port->port, data, 308 urb->actual_length); 309 tty_flip_buffer_push(&port->port); 310 } else 311 dev_dbg(dev, "%s: empty read urb received\n", __func__); 312 } 313 /* Resubmit urb so we continue receiving */ 314 err = usb_submit_urb(urb, GFP_ATOMIC); 315 if (err) { 316 if (err != -EPERM && err != -ENODEV) { 317 dev_err(dev, "%s: resubmit read urb failed. (%d)\n", 318 __func__, err); 319 /* busy also in error unless we are killed */ 320 usb_mark_last_busy(port->serial->dev); 321 } 322 } else { 323 usb_mark_last_busy(port->serial->dev); 324 } 325 } 326 327 static void usb_wwan_outdat_callback(struct urb *urb) 328 { 329 struct usb_serial_port *port; 330 struct usb_wwan_port_private *portdata; 331 struct usb_wwan_intf_private *intfdata; 332 int i; 333 334 port = urb->context; 335 intfdata = usb_get_serial_data(port->serial); 336 337 usb_serial_port_softint(port); 338 usb_autopm_put_interface_async(port->serial->interface); 339 portdata = usb_get_serial_port_data(port); 340 spin_lock(&intfdata->susp_lock); 341 intfdata->in_flight--; 342 spin_unlock(&intfdata->susp_lock); 343 344 for (i = 0; i < N_OUT_URB; ++i) { 345 if (portdata->out_urbs[i] == urb) { 346 smp_mb__before_atomic(); 347 clear_bit(i, &portdata->out_busy); 348 break; 349 } 350 } 351 } 352 353 int usb_wwan_write_room(struct tty_struct *tty) 354 { 355 struct usb_serial_port *port = tty->driver_data; 356 struct usb_wwan_port_private *portdata; 357 int i; 358 int data_len = 0; 359 struct urb *this_urb; 360 361 portdata = usb_get_serial_port_data(port); 362 363 for (i = 0; i < N_OUT_URB; i++) { 364 this_urb = portdata->out_urbs[i]; 365 if (this_urb && !test_bit(i, &portdata->out_busy)) 366 data_len += OUT_BUFLEN; 367 } 368 369 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 370 return data_len; 371 } 372 EXPORT_SYMBOL(usb_wwan_write_room); 373 374 int usb_wwan_chars_in_buffer(struct tty_struct *tty) 375 { 376 struct usb_serial_port *port = tty->driver_data; 377 struct usb_wwan_port_private *portdata; 378 int i; 379 int data_len = 0; 380 struct urb *this_urb; 381 382 portdata = usb_get_serial_port_data(port); 383 384 for (i = 0; i < N_OUT_URB; i++) { 385 this_urb = portdata->out_urbs[i]; 386 /* FIXME: This locking is insufficient as this_urb may 387 go unused during the test */ 388 if (this_urb && test_bit(i, &portdata->out_busy)) 389 data_len += this_urb->transfer_buffer_length; 390 } 391 dev_dbg(&port->dev, "%s: %d\n", __func__, data_len); 392 return data_len; 393 } 394 EXPORT_SYMBOL(usb_wwan_chars_in_buffer); 395 396 int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port) 397 { 398 struct usb_wwan_port_private *portdata; 399 struct usb_wwan_intf_private *intfdata; 400 struct usb_serial *serial = port->serial; 401 int i, err; 402 struct urb *urb; 403 404 portdata = usb_get_serial_port_data(port); 405 intfdata = usb_get_serial_data(serial); 406 407 if (port->interrupt_in_urb) { 408 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 409 if (err) { 410 dev_err(&port->dev, "%s: submit int urb failed: %d\n", 411 __func__, err); 412 } 413 } 414 415 /* Start reading from the IN endpoint */ 416 for (i = 0; i < N_IN_URB; i++) { 417 urb = portdata->in_urbs[i]; 418 if (!urb) 419 continue; 420 err = usb_submit_urb(urb, GFP_KERNEL); 421 if (err) { 422 dev_err(&port->dev, 423 "%s: submit read urb %d failed: %d\n", 424 __func__, i, err); 425 } 426 } 427 428 spin_lock_irq(&intfdata->susp_lock); 429 if (++intfdata->open_ports == 1) 430 serial->interface->needs_remote_wakeup = 1; 431 spin_unlock_irq(&intfdata->susp_lock); 432 /* this balances a get in the generic USB serial code */ 433 usb_autopm_put_interface(serial->interface); 434 435 return 0; 436 } 437 EXPORT_SYMBOL(usb_wwan_open); 438 439 static void unbusy_queued_urb(struct urb *urb, 440 struct usb_wwan_port_private *portdata) 441 { 442 int i; 443 444 for (i = 0; i < N_OUT_URB; i++) { 445 if (urb == portdata->out_urbs[i]) { 446 clear_bit(i, &portdata->out_busy); 447 break; 448 } 449 } 450 } 451 452 void usb_wwan_close(struct usb_serial_port *port) 453 { 454 int i; 455 struct usb_serial *serial = port->serial; 456 struct usb_wwan_port_private *portdata; 457 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 458 struct urb *urb; 459 460 portdata = usb_get_serial_port_data(port); 461 462 /* 463 * Need to take susp_lock to make sure port is not already being 464 * resumed, but no need to hold it due to initialized 465 */ 466 spin_lock_irq(&intfdata->susp_lock); 467 if (--intfdata->open_ports == 0) 468 serial->interface->needs_remote_wakeup = 0; 469 spin_unlock_irq(&intfdata->susp_lock); 470 471 for (;;) { 472 urb = usb_get_from_anchor(&portdata->delayed); 473 if (!urb) 474 break; 475 unbusy_queued_urb(urb, portdata); 476 usb_autopm_put_interface_async(serial->interface); 477 } 478 479 for (i = 0; i < N_IN_URB; i++) 480 usb_kill_urb(portdata->in_urbs[i]); 481 for (i = 0; i < N_OUT_URB; i++) 482 usb_kill_urb(portdata->out_urbs[i]); 483 usb_kill_urb(port->interrupt_in_urb); 484 485 usb_autopm_get_interface_no_resume(serial->interface); 486 } 487 EXPORT_SYMBOL(usb_wwan_close); 488 489 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port, 490 int endpoint, 491 int dir, void *ctx, char *buf, int len, 492 void (*callback) (struct urb *)) 493 { 494 struct usb_serial *serial = port->serial; 495 struct urb *urb; 496 497 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */ 498 if (!urb) 499 return NULL; 500 501 usb_fill_bulk_urb(urb, serial->dev, 502 usb_sndbulkpipe(serial->dev, endpoint) | dir, 503 buf, len, callback, ctx); 504 505 return urb; 506 } 507 508 int usb_wwan_port_probe(struct usb_serial_port *port) 509 { 510 struct usb_wwan_port_private *portdata; 511 struct urb *urb; 512 u8 *buffer; 513 int i; 514 515 if (!port->bulk_in_size || !port->bulk_out_size) 516 return -ENODEV; 517 518 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 519 if (!portdata) 520 return -ENOMEM; 521 522 init_usb_anchor(&portdata->delayed); 523 524 for (i = 0; i < N_IN_URB; i++) { 525 buffer = (u8 *)__get_free_page(GFP_KERNEL); 526 if (!buffer) 527 goto bail_out_error; 528 portdata->in_buffer[i] = buffer; 529 530 urb = usb_wwan_setup_urb(port, port->bulk_in_endpointAddress, 531 USB_DIR_IN, port, 532 buffer, IN_BUFLEN, 533 usb_wwan_indat_callback); 534 portdata->in_urbs[i] = urb; 535 } 536 537 for (i = 0; i < N_OUT_URB; i++) { 538 buffer = kmalloc(OUT_BUFLEN, GFP_KERNEL); 539 if (!buffer) 540 goto bail_out_error2; 541 portdata->out_buffer[i] = buffer; 542 543 urb = usb_wwan_setup_urb(port, port->bulk_out_endpointAddress, 544 USB_DIR_OUT, port, 545 buffer, OUT_BUFLEN, 546 usb_wwan_outdat_callback); 547 portdata->out_urbs[i] = urb; 548 } 549 550 usb_set_serial_port_data(port, portdata); 551 552 return 0; 553 554 bail_out_error2: 555 for (i = 0; i < N_OUT_URB; i++) { 556 usb_free_urb(portdata->out_urbs[i]); 557 kfree(portdata->out_buffer[i]); 558 } 559 bail_out_error: 560 for (i = 0; i < N_IN_URB; i++) { 561 usb_free_urb(portdata->in_urbs[i]); 562 free_page((unsigned long)portdata->in_buffer[i]); 563 } 564 kfree(portdata); 565 566 return -ENOMEM; 567 } 568 EXPORT_SYMBOL_GPL(usb_wwan_port_probe); 569 570 int usb_wwan_port_remove(struct usb_serial_port *port) 571 { 572 int i; 573 struct usb_wwan_port_private *portdata; 574 575 portdata = usb_get_serial_port_data(port); 576 usb_set_serial_port_data(port, NULL); 577 578 for (i = 0; i < N_IN_URB; i++) { 579 usb_free_urb(portdata->in_urbs[i]); 580 free_page((unsigned long)portdata->in_buffer[i]); 581 } 582 for (i = 0; i < N_OUT_URB; i++) { 583 usb_free_urb(portdata->out_urbs[i]); 584 kfree(portdata->out_buffer[i]); 585 } 586 587 kfree(portdata); 588 589 return 0; 590 } 591 EXPORT_SYMBOL(usb_wwan_port_remove); 592 593 #ifdef CONFIG_PM 594 static void stop_urbs(struct usb_serial *serial) 595 { 596 int i, j; 597 struct usb_serial_port *port; 598 struct usb_wwan_port_private *portdata; 599 600 for (i = 0; i < serial->num_ports; ++i) { 601 port = serial->port[i]; 602 portdata = usb_get_serial_port_data(port); 603 if (!portdata) 604 continue; 605 for (j = 0; j < N_IN_URB; j++) 606 usb_kill_urb(portdata->in_urbs[j]); 607 for (j = 0; j < N_OUT_URB; j++) 608 usb_kill_urb(portdata->out_urbs[j]); 609 usb_kill_urb(port->interrupt_in_urb); 610 } 611 } 612 613 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message) 614 { 615 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 616 617 spin_lock_irq(&intfdata->susp_lock); 618 if (PMSG_IS_AUTO(message)) { 619 if (intfdata->in_flight) { 620 spin_unlock_irq(&intfdata->susp_lock); 621 return -EBUSY; 622 } 623 } 624 intfdata->suspended = 1; 625 spin_unlock_irq(&intfdata->susp_lock); 626 627 stop_urbs(serial); 628 629 return 0; 630 } 631 EXPORT_SYMBOL(usb_wwan_suspend); 632 633 /* Caller must hold susp_lock. */ 634 static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port) 635 { 636 struct usb_serial *serial = port->serial; 637 struct usb_wwan_intf_private *data = usb_get_serial_data(serial); 638 struct usb_wwan_port_private *portdata; 639 struct urb *urb; 640 int err_count = 0; 641 int err; 642 643 portdata = usb_get_serial_port_data(port); 644 645 for (;;) { 646 urb = usb_get_from_anchor(&portdata->delayed); 647 if (!urb) 648 break; 649 650 err = usb_submit_urb(urb, GFP_ATOMIC); 651 if (err) { 652 dev_err(&port->dev, "%s: submit urb failed: %d\n", 653 __func__, err); 654 err_count++; 655 unbusy_queued_urb(urb, portdata); 656 usb_autopm_put_interface_async(serial->interface); 657 continue; 658 } 659 data->in_flight++; 660 } 661 662 if (err_count) 663 return -EIO; 664 665 return 0; 666 } 667 668 int usb_wwan_resume(struct usb_serial *serial) 669 { 670 int i, j; 671 struct usb_serial_port *port; 672 struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial); 673 struct usb_wwan_port_private *portdata; 674 struct urb *urb; 675 int err; 676 int err_count = 0; 677 678 spin_lock_irq(&intfdata->susp_lock); 679 for (i = 0; i < serial->num_ports; i++) { 680 port = serial->port[i]; 681 682 if (!tty_port_initialized(&port->port)) 683 continue; 684 685 portdata = usb_get_serial_port_data(port); 686 687 if (port->interrupt_in_urb) { 688 err = usb_submit_urb(port->interrupt_in_urb, 689 GFP_ATOMIC); 690 if (err) { 691 dev_err(&port->dev, 692 "%s: submit int urb failed: %d\n", 693 __func__, err); 694 err_count++; 695 } 696 } 697 698 err = usb_wwan_submit_delayed_urbs(port); 699 if (err) 700 err_count++; 701 702 for (j = 0; j < N_IN_URB; j++) { 703 urb = portdata->in_urbs[j]; 704 err = usb_submit_urb(urb, GFP_ATOMIC); 705 if (err < 0) { 706 dev_err(&port->dev, 707 "%s: submit read urb %d failed: %d\n", 708 __func__, i, err); 709 err_count++; 710 } 711 } 712 } 713 intfdata->suspended = 0; 714 spin_unlock_irq(&intfdata->susp_lock); 715 716 if (err_count) 717 return -EIO; 718 719 return 0; 720 } 721 EXPORT_SYMBOL(usb_wwan_resume); 722 #endif 723 724 MODULE_AUTHOR(DRIVER_AUTHOR); 725 MODULE_DESCRIPTION(DRIVER_DESC); 726 MODULE_LICENSE("GPL"); 727