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