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