Bug

1 2 #include <linux/kernel.h> 3 bool ldv_is_err(const void *ptr); 4 bool ldv_is_err_or_null(const void *ptr); 5 void* ldv_err_ptr(long error); 6 long ldv_ptr_err(const void *ptr); 7 8 9 // Provide model function prototypes before their usage. 10 11 void *ldv_create_class(void); 12 int ldv_register_class(void); 13 void ldv_unregister_class(void); 14 15 int ldv_register_chrdev_region(void); 16 void ldv_unregister_chrdev_region(void); 17 18 int ldv_register_usb_gadget(void); 19 void ldv_unregister_usb_gadget(void); 20 21 /* 22 * Copyright 2003 Digi International (www.digi.com) 23 * Scott H Kilau <Scott_Kilau at digi dot com> 24 * 25 * This program is free software; you can redistribute it and/or modify 26 * it under the terms of the GNU General Public License as published by 27 * the Free Software Foundation; either version 2, or (at your option) 28 * any later version. 29 * 30 * This program is distributed in the hope that it will be useful, 31 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the 32 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 33 * PURPOSE. See the GNU General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software 37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 38 * 39 * 40 * NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE! 41 * 42 * This is shared code between Digi's CVS archive and the 43 * Linux Kernel sources. 44 * Changing the source just for reformatting needlessly breaks 45 * our CVS diff history. 46 * 47 * Send any bug fixes/changes to: Eng.Linux at digi dot com. 48 * Thank you. 49 * 50 */ 51 52 53 #include <linux/kernel.h> 54 #include <linux/module.h> 55 #include <linux/pci.h> 56 #include <linux/slab.h> 57 #include <linux/sched.h> 58 #include "dgnc_driver.h" 59 #include "dgnc_pci.h" 60 #include "dpacompat.h" 61 #include "dgnc_mgmt.h" 62 #include "dgnc_tty.h" 63 #include "dgnc_cls.h" 64 #include "dgnc_neo.h" 65 #include "dgnc_sysfs.h" 66 67 MODULE_LICENSE("GPL"); 68 MODULE_AUTHOR("Digi International, http://www.digi.com"); 69 MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line"); 70 MODULE_SUPPORTED_DEVICE("dgnc"); 71 72 /* 73 * insmod command line overrideable parameters 74 * 75 * NOTE: we use a set of macros to create the variables, which allows 76 * us to specify the variable type, name, initial value, and description. 77 */ 78 PARM_INT(debug, 0x00, 0644, "Driver debugging level"); 79 PARM_INT(rawreadok, 1, 0644, "Bypass flip buffers on input"); 80 PARM_INT(trcbuf_size, 0x100000, 0644, "Debugging trace buffer size."); 81 82 /************************************************************************** 83 * 84 * protos for this file 85 * 86 */ 87 static int dgnc_start(void); 88 static int dgnc_finalize_board_init(struct dgnc_board *brd); 89 static void dgnc_init_globals(void); 90 static int dgnc_found_board(struct pci_dev *pdev, int id); 91 static void dgnc_cleanup_board(struct dgnc_board *brd); 92 static void dgnc_poll_handler(ulong dummy); 93 static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); 94 static void dgnc_do_remap(struct dgnc_board *brd); 95 96 /* 97 * File operations permitted on Control/Management major. 98 */ 99 static const struct file_operations dgnc_BoardFops = { 100 .owner = THIS_MODULE, 101 .unlocked_ioctl = dgnc_mgmt_ioctl, 102 .open = dgnc_mgmt_open, 103 .release = dgnc_mgmt_close 104 }; 105 106 107 /* 108 * Globals 109 */ 110 uint dgnc_NumBoards; 111 struct dgnc_board *dgnc_Board[MAXBOARDS]; 112 DEFINE_SPINLOCK(dgnc_global_lock); 113 uint dgnc_Major; 114 int dgnc_poll_tick = 20; /* Poll interval - 20 ms */ 115 116 /* 117 * Static vars. 118 */ 119 static struct class *dgnc_class; 120 121 /* 122 * Poller stuff 123 */ 124 static DEFINE_SPINLOCK(dgnc_poll_lock); /* Poll scheduling lock */ 125 static ulong dgnc_poll_time; /* Time of next poll */ 126 static uint dgnc_poll_stop; /* Used to tell poller to stop */ 127 static struct timer_list dgnc_poll_timer; 128 129 130 static struct pci_device_id dgnc_pci_tbl[] = { 131 { DIGI_VID, PCI_DEVICE_CLASSIC_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 132 { DIGI_VID, PCI_DEVICE_CLASSIC_4_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 133 { DIGI_VID, PCI_DEVICE_CLASSIC_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 }, 134 { DIGI_VID, PCI_DEVICE_CLASSIC_8_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 }, 135 {0,} /* 0 terminated list. */ 136 }; 137 MODULE_DEVICE_TABLE(pci, dgnc_pci_tbl); 138 139 struct board_id { 140 unsigned char *name; 141 uint maxports; 142 unsigned int is_pci_express; 143 }; 144 145 static struct board_id dgnc_Ids[] = { 146 { PCI_DEVICE_CLASSIC_4_PCI_NAME, 4, 0 }, 147 { PCI_DEVICE_CLASSIC_4_422_PCI_NAME, 4, 0 }, 148 { PCI_DEVICE_CLASSIC_8_PCI_NAME, 8, 0 }, 149 { PCI_DEVICE_CLASSIC_8_422_PCI_NAME, 8, 0 }, 150 { PCI_DEVICE_NEO_4_PCI_NAME, 4, 0 }, 151 { PCI_DEVICE_NEO_8_PCI_NAME, 8, 0 }, 152 { PCI_DEVICE_NEO_2DB9_PCI_NAME, 2, 0 }, 153 { PCI_DEVICE_NEO_2DB9PRI_PCI_NAME, 2, 0 }, 154 { PCI_DEVICE_NEO_2RJ45_PCI_NAME, 2, 0 }, 155 { PCI_DEVICE_NEO_2RJ45PRI_PCI_NAME, 2, 0 }, 156 { PCI_DEVICE_NEO_1_422_PCI_NAME, 1, 0 }, 157 { PCI_DEVICE_NEO_1_422_485_PCI_NAME, 1, 0 }, 158 { PCI_DEVICE_NEO_2_422_485_PCI_NAME, 2, 0 }, 159 { PCI_DEVICE_NEO_EXPRESS_8_PCI_NAME, 8, 1 }, 160 { PCI_DEVICE_NEO_EXPRESS_4_PCI_NAME, 4, 1 }, 161 { PCI_DEVICE_NEO_EXPRESS_4RJ45_PCI_NAME, 4, 1 }, 162 { PCI_DEVICE_NEO_EXPRESS_8RJ45_PCI_NAME, 8, 1 }, 163 { NULL, 0, 0 } 164 }; 165 166 static struct pci_driver dgnc_driver = { 167 .name = "dgnc", 168 .probe = dgnc_init_one, 169 .id_table = dgnc_pci_tbl, 170 }; 171 172 173 char *dgnc_state_text[] = { 174 "Board Failed", 175 "Board Found", 176 "Board READY", 177 }; 178 179 180 /************************************************************************ 181 * 182 * Driver load/unload functions 183 * 184 ************************************************************************/ 185 186 /* 187 * dgnc_cleanup_module() 188 * 189 * Module unload. This is where it all ends. 190 */ 191 static void dgnc_cleanup_module(void) 192 { 193 int i; 194 unsigned long flags; 195 196 spin_lock_irqsave(&dgnc_poll_lock, flags); 197 dgnc_poll_stop = 1; 198 spin_unlock_irqrestore(&dgnc_poll_lock, flags); 199 200 /* Turn off poller right away. */ 201 del_timer_sync(&dgnc_poll_timer); 202 203 dgnc_remove_driver_sysfiles(&dgnc_driver); 204 205 device_destroy(dgnc_class, MKDEV(dgnc_Major, 0)); 206 class_destroy(dgnc_class); 207 unregister_chrdev(dgnc_Major, "dgnc"); 208 209 for (i = 0; i < dgnc_NumBoards; ++i) { 210 dgnc_remove_ports_sysfiles(dgnc_Board[i]); 211 dgnc_tty_uninit(dgnc_Board[i]); 212 dgnc_cleanup_board(dgnc_Board[i]); 213 } 214 215 dgnc_tty_post_uninit(); 216 217 if (dgnc_NumBoards) 218 pci_unregister_driver(&dgnc_driver); 219 } 220 221 /* 222 * init_module() 223 * 224 * Module load. This is where it all starts. 225 */ 226 static int __init dgnc_init_module(void) 227 { 228 int rc = 0; 229 230 APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART)); 231 232 /* 233 * Initialize global stuff 234 */ 235 rc = dgnc_start(); 236 237 if (rc < 0) 238 return rc; 239 240 /* 241 * Find and configure all the cards 242 */ 243 rc = pci_register_driver(&dgnc_driver); 244 245 /* 246 * If something went wrong in the scan, bail out of driver. 247 */ 248 if (rc < 0) { 249 /* Only unregister the pci driver if it was actually registered. */ 250 if (dgnc_NumBoards) 251 pci_unregister_driver(&dgnc_driver); 252 else 253 pr_warn("WARNING: dgnc driver load failed. No Digi Neo or Classic boards found.\n"); 254 255 dgnc_cleanup_module(); 256 } else { 257 dgnc_create_driver_sysfiles(&dgnc_driver); 258 } 259 260 return rc; 261 } 262 263 module_init(dgnc_init_module); 264 module_exit(dgnc_cleanup_module); 265 266 /* 267 * Start of driver. 268 */ 269 static int dgnc_start(void) 270 { 271 int rc = 0; 272 unsigned long flags; 273 274 /* make sure that the globals are init'd before we do anything else */ 275 dgnc_init_globals(); 276 277 APR(("For the tools package or updated drivers please visit http://www.digi.com\n")); 278 279 /* 280 * Register our base character device into the kernel. 281 * This allows the download daemon to connect to the downld device 282 * before any of the boards are init'ed. 283 * 284 * Register management/dpa devices 285 */ 286 rc = register_chrdev(0, "dgnc", &dgnc_BoardFops); 287 if (rc <= 0) { 288 APR(("Can't register dgnc driver device (%d)\n", rc)); 289 return -ENXIO; 290 } 291 dgnc_Major = rc; 292 293 dgnc_class = class_create(THIS_MODULE, "dgnc_mgmt"); 294 device_create(dgnc_class, NULL, 295 MKDEV(dgnc_Major, 0), 296 NULL, "dgnc_mgmt"); 297 298 /* 299 * Init any global tty stuff. 300 */ 301 rc = dgnc_tty_preinit(); 302 303 if (rc < 0) { 304 APR(("tty preinit - not enough memory (%d)\n", rc)); 305 return rc; 306 } 307 308 /* Start the poller */ 309 spin_lock_irqsave(&dgnc_poll_lock, flags); 310 init_timer(&dgnc_poll_timer); 311 dgnc_poll_timer.function = dgnc_poll_handler; 312 dgnc_poll_timer.data = 0; 313 dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick); 314 dgnc_poll_timer.expires = dgnc_poll_time; 315 spin_unlock_irqrestore(&dgnc_poll_lock, flags); 316 317 add_timer(&dgnc_poll_timer); 318 319 return rc; 320 } 321 322 /* returns count (>= 0), or negative on error */ 323 static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 324 { 325 int rc; 326 327 /* wake up and enable device */ 328 rc = pci_enable_device(pdev); 329 330 if (rc < 0) { 331 rc = -EIO; 332 } else { 333 rc = dgnc_found_board(pdev, ent->driver_data); 334 if (rc == 0) 335 dgnc_NumBoards++; 336 } 337 return rc; 338 } 339 340 /* 341 * dgnc_cleanup_board() 342 * 343 * Free all the memory associated with a board 344 */ 345 static void dgnc_cleanup_board(struct dgnc_board *brd) 346 { 347 int i = 0; 348 349 if (!brd || brd->magic != DGNC_BOARD_MAGIC) 350 return; 351 352 switch (brd->device) { 353 case PCI_DEVICE_CLASSIC_4_DID: 354 case PCI_DEVICE_CLASSIC_8_DID: 355 case PCI_DEVICE_CLASSIC_4_422_DID: 356 case PCI_DEVICE_CLASSIC_8_422_DID: 357 358 /* Tell card not to interrupt anymore. */ 359 outb(0, brd->iobase + 0x4c); 360 break; 361 362 default: 363 break; 364 } 365 366 if (brd->irq) 367 free_irq(brd->irq, brd); 368 369 tasklet_kill(&brd->helper_tasklet); 370 371 if (brd->re_map_membase) { 372 iounmap(brd->re_map_membase); 373 brd->re_map_membase = NULL; 374 } 375 376 if (brd->msgbuf_head) { 377 unsigned long flags; 378 379 spin_lock_irqsave(&dgnc_global_lock, flags); 380 brd->msgbuf = NULL; 381 printk("%s", brd->msgbuf_head); 382 kfree(brd->msgbuf_head); 383 brd->msgbuf_head = NULL; 384 spin_unlock_irqrestore(&dgnc_global_lock, flags); 385 } 386 387 /* Free all allocated channels structs */ 388 for (i = 0; i < MAXPORTS ; i++) { 389 if (brd->channels[i]) { 390 kfree(brd->channels[i]->ch_rqueue); 391 kfree(brd->channels[i]->ch_equeue); 392 kfree(brd->channels[i]->ch_wqueue); 393 kfree(brd->channels[i]); 394 brd->channels[i] = NULL; 395 } 396 } 397 398 kfree(brd->flipbuf); 399 400 dgnc_Board[brd->boardnum] = NULL; 401 402 kfree(brd); 403 } 404 405 406 /* 407 * dgnc_found_board() 408 * 409 * A board has been found, init it. 410 */ 411 static int dgnc_found_board(struct pci_dev *pdev, int id) 412 { 413 struct dgnc_board *brd; 414 unsigned int pci_irq; 415 int i = 0; 416 int rc = 0; 417 unsigned long flags; 418 419 /* get the board structure and prep it */ 420 dgnc_Board[dgnc_NumBoards] = kzalloc(sizeof(*brd), GFP_KERNEL); 421 brd = dgnc_Board[dgnc_NumBoards]; 422 423 if (!brd) 424 return -ENOMEM; 425 426 /* make a temporary message buffer for the boot messages */ 427 brd->msgbuf_head = kzalloc(sizeof(u8) * 8192, GFP_KERNEL); 428 brd->msgbuf = brd->msgbuf_head; 429 430 if (!brd->msgbuf) { 431 kfree(brd); 432 return -ENOMEM; 433 } 434 435 /* store the info for the board we've found */ 436 brd->magic = DGNC_BOARD_MAGIC; 437 brd->boardnum = dgnc_NumBoards; 438 brd->vendor = dgnc_pci_tbl[id].vendor; 439 brd->device = dgnc_pci_tbl[id].device; 440 brd->pdev = pdev; 441 brd->pci_bus = pdev->bus->number; 442 brd->pci_slot = PCI_SLOT(pdev->devfn); 443 brd->name = dgnc_Ids[id].name; 444 brd->maxports = dgnc_Ids[id].maxports; 445 if (dgnc_Ids[i].is_pci_express) 446 brd->bd_flags |= BD_IS_PCI_EXPRESS; 447 brd->dpastatus = BD_NOFEP; 448 init_waitqueue_head(&brd->state_wait); 449 450 spin_lock_init(&brd->bd_lock); 451 spin_lock_init(&brd->bd_intr_lock); 452 453 brd->state = BOARD_FOUND; 454 455 for (i = 0; i < MAXPORTS; i++) 456 brd->channels[i] = NULL; 457 458 /* store which card & revision we have */ 459 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor); 460 pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice); 461 pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev); 462 463 pci_irq = pdev->irq; 464 brd->irq = pci_irq; 465 466 467 switch (brd->device) { 468 469 case PCI_DEVICE_CLASSIC_4_DID: 470 case PCI_DEVICE_CLASSIC_8_DID: 471 case PCI_DEVICE_CLASSIC_4_422_DID: 472 case PCI_DEVICE_CLASSIC_8_422_DID: 473 474 brd->dpatype = T_CLASSIC | T_PCIBUS; 475 476 /* 477 * For PCI ClassicBoards 478 * PCI Local Address (i.e. "resource" number) space 479 * 0 PLX Memory Mapped Config 480 * 1 PLX I/O Mapped Config 481 * 2 I/O Mapped UARTs and Status 482 * 3 Memory Mapped VPD 483 * 4 Memory Mapped UARTs and Status 484 */ 485 486 487 /* get the PCI Base Address Registers */ 488 brd->membase = pci_resource_start(pdev, 4); 489 490 if (!brd->membase) { 491 APR(("card has no PCI IO resources, failing board.\n")); 492 return -ENODEV; 493 } 494 495 brd->membase_end = pci_resource_end(pdev, 4); 496 497 if (brd->membase & 1) 498 brd->membase &= ~3; 499 else 500 brd->membase &= ~15; 501 502 brd->iobase = pci_resource_start(pdev, 1); 503 brd->iobase_end = pci_resource_end(pdev, 1); 504 brd->iobase = ((unsigned int) (brd->iobase)) & 0xFFFE; 505 506 /* Assign the board_ops struct */ 507 brd->bd_ops = &dgnc_cls_ops; 508 509 brd->bd_uart_offset = 0x8; 510 brd->bd_dividend = 921600; 511 512 dgnc_do_remap(brd); 513 514 /* Get and store the board VPD, if it exists */ 515 brd->bd_ops->vpd(brd); 516 517 /* 518 * Enable Local Interrupt 1 (0x1), 519 * Local Interrupt 1 Polarity Active high (0x2), 520 * Enable PCI interrupt (0x40) 521 */ 522 outb(0x43, brd->iobase + 0x4c); 523 524 break; 525 526 527 case PCI_DEVICE_NEO_4_DID: 528 case PCI_DEVICE_NEO_8_DID: 529 case PCI_DEVICE_NEO_2DB9_DID: 530 case PCI_DEVICE_NEO_2DB9PRI_DID: 531 case PCI_DEVICE_NEO_2RJ45_DID: 532 case PCI_DEVICE_NEO_2RJ45PRI_DID: 533 case PCI_DEVICE_NEO_1_422_DID: 534 case PCI_DEVICE_NEO_1_422_485_DID: 535 case PCI_DEVICE_NEO_2_422_485_DID: 536 case PCI_DEVICE_NEO_EXPRESS_8_DID: 537 case PCI_DEVICE_NEO_EXPRESS_4_DID: 538 case PCI_DEVICE_NEO_EXPRESS_4RJ45_DID: 539 case PCI_DEVICE_NEO_EXPRESS_8RJ45_DID: 540 541 /* 542 * This chip is set up 100% when we get to it. 543 * No need to enable global interrupts or anything. 544 */ 545 if (brd->bd_flags & BD_IS_PCI_EXPRESS) 546 brd->dpatype = T_NEO_EXPRESS | T_PCIBUS; 547 else 548 brd->dpatype = T_NEO | T_PCIBUS; 549 550 /* get the PCI Base Address Registers */ 551 brd->membase = pci_resource_start(pdev, 0); 552 brd->membase_end = pci_resource_end(pdev, 0); 553 554 if (brd->membase & 1) 555 brd->membase &= ~3; 556 else 557 brd->membase &= ~15; 558 559 /* Assign the board_ops struct */ 560 brd->bd_ops = &dgnc_neo_ops; 561 562 brd->bd_uart_offset = 0x200; 563 brd->bd_dividend = 921600; 564 565 dgnc_do_remap(brd); 566 567 if (brd->re_map_membase) { 568 569 /* After remap is complete, we need to read and store the dvid */ 570 brd->dvid = readb(brd->re_map_membase + 0x8D); 571 572 /* Get and store the board VPD, if it exists */ 573 brd->bd_ops->vpd(brd); 574 } 575 break; 576 577 default: 578 APR(("Did not find any compatible Neo or Classic PCI boards in system.\n")); 579 return -ENXIO; 580 581 } 582 583 /* 584 * Do tty device initialization. 585 */ 586 587 rc = dgnc_tty_register(brd); 588 if (rc < 0) { 589 dgnc_tty_uninit(brd); 590 APR(("Can't register tty devices (%d)\n", rc)); 591 brd->state = BOARD_FAILED; 592 brd->dpastatus = BD_NOFEP; 593 goto failed; 594 } 595 596 rc = dgnc_finalize_board_init(brd); 597 if (rc < 0) { 598 APR(("Can't finalize board init (%d)\n", rc)); 599 brd->state = BOARD_FAILED; 600 brd->dpastatus = BD_NOFEP; 601 602 goto failed; 603 } 604 605 rc = dgnc_tty_init(brd); 606 if (rc < 0) { 607 dgnc_tty_uninit(brd); 608 APR(("Can't init tty devices (%d)\n", rc)); 609 brd->state = BOARD_FAILED; 610 brd->dpastatus = BD_NOFEP; 611 612 goto failed; 613 } 614 615 brd->state = BOARD_READY; 616 brd->dpastatus = BD_RUNNING; 617 618 dgnc_create_ports_sysfiles(brd); 619 620 /* init our poll helper tasklet */ 621 tasklet_init(&brd->helper_tasklet, brd->bd_ops->tasklet, (unsigned long) brd); 622 623 spin_lock_irqsave(&dgnc_global_lock, flags); 624 brd->msgbuf = NULL; 625 printk("%s", brd->msgbuf_head); 626 kfree(brd->msgbuf_head); 627 brd->msgbuf_head = NULL; 628 spin_unlock_irqrestore(&dgnc_global_lock, flags); 629 630 /* 631 * allocate flip buffer for board. 632 * 633 * Okay to malloc with GFP_KERNEL, we are not at interrupt 634 * context, and there are no locks held. 635 */ 636 brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL); 637 638 wake_up_interruptible(&brd->state_wait); 639 640 return 0; 641 642 failed: 643 644 return -ENXIO; 645 646 } 647 648 649 static int dgnc_finalize_board_init(struct dgnc_board *brd) 650 { 651 int rc = 0; 652 653 if (!brd || brd->magic != DGNC_BOARD_MAGIC) 654 return -ENODEV; 655 656 if (brd->irq) { 657 rc = request_irq(brd->irq, brd->bd_ops->intr, 658 IRQF_SHARED, "DGNC", brd); 659 660 if (rc) { 661 dev_err(&brd->pdev->dev, 662 "Failed to hook IRQ %d\n", brd->irq); 663 brd->state = BOARD_FAILED; 664 brd->dpastatus = BD_NOFEP; 665 rc = -ENODEV; 666 } 667 } 668 return rc; 669 } 670 671 /* 672 * Remap PCI memory. 673 */ 674 static void dgnc_do_remap(struct dgnc_board *brd) 675 { 676 677 if (!brd || brd->magic != DGNC_BOARD_MAGIC) 678 return; 679 680 brd->re_map_membase = ioremap(brd->membase, 0x1000); 681 } 682 683 684 /***************************************************************************** 685 * 686 * Function: 687 * 688 * dgnc_poll_handler 689 * 690 * Author: 691 * 692 * Scott H Kilau 693 * 694 * Parameters: 695 * 696 * dummy -- ignored 697 * 698 * Return Values: 699 * 700 * none 701 * 702 * Description: 703 * 704 * As each timer expires, it determines (a) whether the "transmit" 705 * waiter needs to be woken up, and (b) whether the poller needs to 706 * be rescheduled. 707 * 708 ******************************************************************************/ 709 710 static void dgnc_poll_handler(ulong dummy) 711 { 712 struct dgnc_board *brd; 713 unsigned long flags; 714 int i; 715 unsigned long new_time; 716 717 /* Go thru each board, kicking off a tasklet for each if needed */ 718 for (i = 0; i < dgnc_NumBoards; i++) { 719 brd = dgnc_Board[i]; 720 721 spin_lock_irqsave(&brd->bd_lock, flags); 722 723 /* If board is in a failed state, don't bother scheduling a tasklet */ 724 if (brd->state == BOARD_FAILED) { 725 spin_unlock_irqrestore(&brd->bd_lock, flags); 726 continue; 727 } 728 729 /* Schedule a poll helper task */ 730 tasklet_schedule(&brd->helper_tasklet); 731 732 spin_unlock_irqrestore(&brd->bd_lock, flags); 733 } 734 735 /* 736 * Schedule ourself back at the nominal wakeup interval. 737 */ 738 spin_lock_irqsave(&dgnc_poll_lock, flags); 739 dgnc_poll_time += dgnc_jiffies_from_ms(dgnc_poll_tick); 740 741 new_time = dgnc_poll_time - jiffies; 742 743 if ((ulong) new_time >= 2 * dgnc_poll_tick) 744 dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick); 745 746 init_timer(&dgnc_poll_timer); 747 dgnc_poll_timer.function = dgnc_poll_handler; 748 dgnc_poll_timer.data = 0; 749 dgnc_poll_timer.expires = dgnc_poll_time; 750 spin_unlock_irqrestore(&dgnc_poll_lock, flags); 751 752 if (!dgnc_poll_stop) 753 add_timer(&dgnc_poll_timer); 754 } 755 756 /* 757 * dgnc_init_globals() 758 * 759 * This is where we initialize the globals from the static insmod 760 * configuration variables. These are declared near the head of 761 * this file. 762 */ 763 static void dgnc_init_globals(void) 764 { 765 int i = 0; 766 767 dgnc_rawreadok = rawreadok; 768 dgnc_trcbuf_size = trcbuf_size; 769 dgnc_debug = debug; 770 dgnc_NumBoards = 0; 771 772 for (i = 0; i < MAXBOARDS; i++) 773 dgnc_Board[i] = NULL; 774 775 init_timer(&dgnc_poll_timer); 776 } 777 778 779 780 781 782 783 /* LDV_COMMENT_BEGIN_MAIN */ 784 #ifdef LDV_MAIN1_sequence_infinite_withcheck_stateful 785 786 /*###########################################################################*/ 787 788 /*############## Driver Environment Generator 0.2 output ####################*/ 789 790 /*###########################################################################*/ 791 792 793 794 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 795 void ldv_check_final_state(void); 796 797 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 798 void ldv_check_return_value(int res); 799 800 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 801 void ldv_check_return_value_probe(int res); 802 803 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 804 void ldv_initialize(void); 805 806 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 807 void ldv_handler_precall(void); 808 809 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 810 int nondet_int(void); 811 812 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 813 int LDV_IN_INTERRUPT; 814 815 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 816 void ldv_main1_sequence_infinite_withcheck_stateful(void) { 817 818 819 820 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 821 /*============================= VARIABLE DECLARATION PART =============================*/ 822 /** STRUCT: struct type: pci_driver, struct name: dgnc_driver **/ 823 /* content: static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)*/ 824 /* LDV_COMMENT_END_PREP */ 825 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_init_one" */ 826 struct pci_dev * var_group1; 827 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_init_one" */ 828 const struct pci_device_id * var_dgnc_init_one_3_p1; 829 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "dgnc_init_one" */ 830 static int res_dgnc_init_one_3; 831 832 833 834 835 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 836 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 837 /*============================= VARIABLE INITIALIZING PART =============================*/ 838 LDV_IN_INTERRUPT=1; 839 840 841 842 843 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 844 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 845 /*============================= FUNCTION CALL SECTION =============================*/ 846 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 847 ldv_initialize(); 848 849 /** INIT: init_type: ST_MODULE_INIT **/ 850 /* content: static int __init dgnc_init_module(void)*/ 851 /* LDV_COMMENT_END_PREP */ 852 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver init function after driver loading to kernel. This function declared as "MODULE_INIT(function name)". */ 853 ldv_handler_precall(); 854 if(dgnc_init_module()) 855 goto ldv_final; 856 int ldv_s_dgnc_driver_pci_driver = 0; 857 858 859 while( nondet_int() 860 || !(ldv_s_dgnc_driver_pci_driver == 0) 861 ) { 862 863 switch(nondet_int()) { 864 865 case 0: { 866 867 /** STRUCT: struct type: pci_driver, struct name: dgnc_driver **/ 868 if(ldv_s_dgnc_driver_pci_driver==0) { 869 870 /* content: static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)*/ 871 /* LDV_COMMENT_END_PREP */ 872 /* LDV_COMMENT_FUNCTION_CALL Function from field "probe" from driver structure with callbacks "dgnc_driver". Standart function test for correct return result. */ 873 res_dgnc_init_one_3 = dgnc_init_one( var_group1, var_dgnc_init_one_3_p1); 874 ldv_check_return_value(res_dgnc_init_one_3); 875 ldv_check_return_value_probe(res_dgnc_init_one_3); 876 if(res_dgnc_init_one_3) 877 goto ldv_module_exit; 878 ldv_s_dgnc_driver_pci_driver=0; 879 880 } 881 882 } 883 884 break; 885 default: break; 886 887 } 888 889 } 890 891 ldv_module_exit: 892 893 /** INIT: init_type: ST_MODULE_EXIT **/ 894 /* content: static void dgnc_cleanup_module(void)*/ 895 /* LDV_COMMENT_END_PREP */ 896 /* LDV_COMMENT_FUNCTION_CALL Kernel calls driver release function before driver will be uploaded from kernel. This function declared as "MODULE_EXIT(function name)". */ 897 ldv_handler_precall(); 898 dgnc_cleanup_module(); 899 900 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 901 ldv_final: ldv_check_final_state(); 902 903 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 904 return; 905 906 } 907 #endif 908 909 /* LDV_COMMENT_END_MAIN */

1 2 #include <linux/kernel.h> 3 bool ldv_is_err(const void *ptr); 4 bool ldv_is_err_or_null(const void *ptr); 5 void* ldv_err_ptr(long error); 6 long ldv_ptr_err(const void *ptr); 7 8 9 // Provide model function prototypes before their usage. 10 11 void *ldv_create_class(void); 12 int ldv_register_class(void); 13 void ldv_unregister_class(void); 14 15 int ldv_register_chrdev_region(void); 16 void ldv_unregister_chrdev_region(void); 17 18 int ldv_register_usb_gadget(void); 19 void ldv_unregister_usb_gadget(void); 20 21 /* 22 * Copyright 2003 Digi International (www.digi.com) 23 * Scott H Kilau <Scott_Kilau at digi dot com> 24 * 25 * This program is free software; you can redistribute it and/or modify 26 * it under the terms of the GNU General Public License as published by 27 * the Free Software Foundation; either version 2, or (at your option) 28 * any later version. 29 * 30 * This program is distributed in the hope that it will be useful, 31 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the 32 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 33 * PURPOSE. See the GNU General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software 37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 38 * 39 * 40 * NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE! 41 * 42 * This is shared code between Digi's CVS archive and the 43 * Linux Kernel sources. 44 * Changing the source just for reformatting needlessly breaks 45 * our CVS diff history. 46 * 47 * Send any bug fixes/changes to: Eng.Linux at digi dot com. 48 * Thank you. 49 */ 50 51 /************************************************************************ 52 * 53 * This file implements the tty driver functionality for the 54 * Neo and ClassicBoard PCI based product lines. 55 * 56 ************************************************************************ 57 * 58 */ 59 60 #include <linux/kernel.h> 61 #include <linux/sched.h> /* For jiffies, task states */ 62 #include <linux/interrupt.h> /* For tasklet and interrupt structs/defines */ 63 #include <linux/module.h> 64 #include <linux/ctype.h> 65 #include <linux/tty.h> 66 #include <linux/tty_flip.h> 67 #include <linux/serial_reg.h> 68 #include <linux/slab.h> 69 #include <linux/delay.h> /* For udelay */ 70 #include <linux/uaccess.h> /* For copy_from_user/copy_to_user */ 71 #include <linux/pci.h> 72 73 #include "dgnc_driver.h" 74 #include "dgnc_tty.h" 75 #include "dgnc_types.h" 76 #include "dgnc_neo.h" 77 #include "dgnc_cls.h" 78 #include "dpacompat.h" 79 #include "dgnc_sysfs.h" 80 #include "dgnc_utils.h" 81 82 #define init_MUTEX(sem) sema_init(sem, 1) 83 #define DECLARE_MUTEX(name) \ 84 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 85 86 /* 87 * internal variables 88 */ 89 static struct dgnc_board *dgnc_BoardsByMajor[256]; 90 static unsigned char *dgnc_TmpWriteBuf; 91 static DECLARE_MUTEX(dgnc_TmpWriteSem); 92 93 /* 94 * Default transparent print information. 95 */ 96 static struct digi_t dgnc_digi_init = { 97 .digi_flags = DIGI_COOK, /* Flags */ 98 .digi_maxcps = 100, /* Max CPS */ 99 .digi_maxchar = 50, /* Max chars in print queue */ 100 .digi_bufsize = 100, /* Printer buffer size */ 101 .digi_onlen = 4, /* size of printer on string */ 102 .digi_offlen = 4, /* size of printer off string */ 103 .digi_onstr = "\033[5i", /* ANSI printer on string ] */ 104 .digi_offstr = "\033[4i", /* ANSI printer off string ] */ 105 .digi_term = "ansi" /* default terminal type */ 106 }; 107 108 109 /* 110 * Define a local default termios struct. All ports will be created 111 * with this termios initially. 112 * 113 * This defines a raw port at 9600 baud, 8 data bits, no parity, 114 * 1 stop bit. 115 */ 116 static struct ktermios DgncDefaultTermios = { 117 .c_iflag = (DEFAULT_IFLAGS), /* iflags */ 118 .c_oflag = (DEFAULT_OFLAGS), /* oflags */ 119 .c_cflag = (DEFAULT_CFLAGS), /* cflags */ 120 .c_lflag = (DEFAULT_LFLAGS), /* lflags */ 121 .c_cc = INIT_C_CC, 122 .c_line = 0, 123 }; 124 125 126 /* Our function prototypes */ 127 static int dgnc_tty_open(struct tty_struct *tty, struct file *file); 128 static void dgnc_tty_close(struct tty_struct *tty, struct file *file); 129 static int dgnc_block_til_ready(struct tty_struct *tty, struct file *file, struct channel_t *ch); 130 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg); 131 static int dgnc_tty_digigeta(struct tty_struct *tty, struct digi_t __user *retinfo); 132 static int dgnc_tty_digiseta(struct tty_struct *tty, struct digi_t __user *new_info); 133 static int dgnc_tty_write_room(struct tty_struct *tty); 134 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c); 135 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty); 136 static void dgnc_tty_start(struct tty_struct *tty); 137 static void dgnc_tty_stop(struct tty_struct *tty); 138 static void dgnc_tty_throttle(struct tty_struct *tty); 139 static void dgnc_tty_unthrottle(struct tty_struct *tty); 140 static void dgnc_tty_flush_chars(struct tty_struct *tty); 141 static void dgnc_tty_flush_buffer(struct tty_struct *tty); 142 static void dgnc_tty_hangup(struct tty_struct *tty); 143 static int dgnc_set_modem_info(struct tty_struct *tty, unsigned int command, unsigned int __user *value); 144 static int dgnc_get_modem_info(struct channel_t *ch, unsigned int __user *value); 145 static int dgnc_tty_tiocmget(struct tty_struct *tty); 146 static int dgnc_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear); 147 static int dgnc_tty_send_break(struct tty_struct *tty, int msec); 148 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout); 149 static int dgnc_tty_write(struct tty_struct *tty, const unsigned char *buf, int count); 150 static void dgnc_tty_set_termios(struct tty_struct *tty, struct ktermios *old_termios); 151 static void dgnc_tty_send_xchar(struct tty_struct *tty, char ch); 152 153 154 static const struct tty_operations dgnc_tty_ops = { 155 .open = dgnc_tty_open, 156 .close = dgnc_tty_close, 157 .write = dgnc_tty_write, 158 .write_room = dgnc_tty_write_room, 159 .flush_buffer = dgnc_tty_flush_buffer, 160 .chars_in_buffer = dgnc_tty_chars_in_buffer, 161 .flush_chars = dgnc_tty_flush_chars, 162 .ioctl = dgnc_tty_ioctl, 163 .set_termios = dgnc_tty_set_termios, 164 .stop = dgnc_tty_stop, 165 .start = dgnc_tty_start, 166 .throttle = dgnc_tty_throttle, 167 .unthrottle = dgnc_tty_unthrottle, 168 .hangup = dgnc_tty_hangup, 169 .put_char = dgnc_tty_put_char, 170 .tiocmget = dgnc_tty_tiocmget, 171 .tiocmset = dgnc_tty_tiocmset, 172 .break_ctl = dgnc_tty_send_break, 173 .wait_until_sent = dgnc_tty_wait_until_sent, 174 .send_xchar = dgnc_tty_send_xchar 175 }; 176 177 /************************************************************************ 178 * 179 * TTY Initialization/Cleanup Functions 180 * 181 ************************************************************************/ 182 183 /* 184 * dgnc_tty_preinit() 185 * 186 * Initialize any global tty related data before we download any boards. 187 */ 188 int dgnc_tty_preinit(void) 189 { 190 /* 191 * Allocate a buffer for doing the copy from user space to 192 * kernel space in dgnc_write(). We only use one buffer and 193 * control access to it with a semaphore. If we are paging, we 194 * are already in trouble so one buffer won't hurt much anyway. 195 * 196 * We are okay to sleep in the malloc, as this routine 197 * is only called during module load, (not in interrupt context), 198 * and with no locks held. 199 */ 200 dgnc_TmpWriteBuf = kmalloc(WRITEBUFLEN, GFP_KERNEL); 201 202 if (!dgnc_TmpWriteBuf) 203 return -ENOMEM; 204 205 return 0; 206 } 207 208 209 /* 210 * dgnc_tty_register() 211 * 212 * Init the tty subsystem for this board. 213 */ 214 int dgnc_tty_register(struct dgnc_board *brd) 215 { 216 int rc = 0; 217 218 brd->SerialDriver.magic = TTY_DRIVER_MAGIC; 219 220 snprintf(brd->SerialName, MAXTTYNAMELEN, "tty_dgnc_%d_", brd->boardnum); 221 222 brd->SerialDriver.name = brd->SerialName; 223 brd->SerialDriver.name_base = 0; 224 brd->SerialDriver.major = 0; 225 brd->SerialDriver.minor_start = 0; 226 brd->SerialDriver.num = brd->maxports; 227 brd->SerialDriver.type = TTY_DRIVER_TYPE_SERIAL; 228 brd->SerialDriver.subtype = SERIAL_TYPE_NORMAL; 229 brd->SerialDriver.init_termios = DgncDefaultTermios; 230 brd->SerialDriver.driver_name = DRVSTR; 231 brd->SerialDriver.flags = (TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK); 232 233 /* 234 * The kernel wants space to store pointers to 235 * tty_struct's and termios's. 236 */ 237 brd->SerialDriver.ttys = kcalloc(brd->maxports, sizeof(*brd->SerialDriver.ttys), GFP_KERNEL); 238 if (!brd->SerialDriver.ttys) 239 return -ENOMEM; 240 241 kref_init(&brd->SerialDriver.kref); 242 brd->SerialDriver.termios = kcalloc(brd->maxports, sizeof(*brd->SerialDriver.termios), GFP_KERNEL); 243 if (!brd->SerialDriver.termios) 244 return -ENOMEM; 245 246 /* 247 * Entry points for driver. Called by the kernel from 248 * tty_io.c and n_tty.c. 249 */ 250 tty_set_operations(&brd->SerialDriver, &dgnc_tty_ops); 251 252 if (!brd->dgnc_Major_Serial_Registered) { 253 /* Register tty devices */ 254 rc = tty_register_driver(&brd->SerialDriver); 255 if (rc < 0) { 256 APR(("Can't register tty device (%d)\n", rc)); 257 return rc; 258 } 259 brd->dgnc_Major_Serial_Registered = TRUE; 260 } 261 262 /* 263 * If we're doing transparent print, we have to do all of the above 264 * again, separately so we don't get the LD confused about what major 265 * we are when we get into the dgnc_tty_open() routine. 266 */ 267 brd->PrintDriver.magic = TTY_DRIVER_MAGIC; 268 snprintf(brd->PrintName, MAXTTYNAMELEN, "pr_dgnc_%d_", brd->boardnum); 269 270 brd->PrintDriver.name = brd->PrintName; 271 brd->PrintDriver.name_base = 0; 272 brd->PrintDriver.major = brd->SerialDriver.major; 273 brd->PrintDriver.minor_start = 0x80; 274 brd->PrintDriver.num = brd->maxports; 275 brd->PrintDriver.type = TTY_DRIVER_TYPE_SERIAL; 276 brd->PrintDriver.subtype = SERIAL_TYPE_NORMAL; 277 brd->PrintDriver.init_termios = DgncDefaultTermios; 278 brd->PrintDriver.driver_name = DRVSTR; 279 brd->PrintDriver.flags = (TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK); 280 281 /* 282 * The kernel wants space to store pointers to 283 * tty_struct's and termios's. Must be separated from 284 * the Serial Driver so we don't get confused 285 */ 286 brd->PrintDriver.ttys = kcalloc(brd->maxports, sizeof(*brd->PrintDriver.ttys), GFP_KERNEL); 287 if (!brd->PrintDriver.ttys) 288 return -ENOMEM; 289 kref_init(&brd->PrintDriver.kref); 290 brd->PrintDriver.termios = kcalloc(brd->maxports, sizeof(*brd->PrintDriver.termios), GFP_KERNEL); 291 if (!brd->PrintDriver.termios) 292 return -ENOMEM; 293 294 /* 295 * Entry points for driver. Called by the kernel from 296 * tty_io.c and n_tty.c. 297 */ 298 tty_set_operations(&brd->PrintDriver, &dgnc_tty_ops); 299 300 if (!brd->dgnc_Major_TransparentPrint_Registered) { 301 /* Register Transparent Print devices */ 302 rc = tty_register_driver(&brd->PrintDriver); 303 if (rc < 0) { 304 APR(("Can't register Transparent Print device (%d)\n", rc)); 305 return rc; 306 } 307 brd->dgnc_Major_TransparentPrint_Registered = TRUE; 308 } 309 310 dgnc_BoardsByMajor[brd->SerialDriver.major] = brd; 311 brd->dgnc_Serial_Major = brd->SerialDriver.major; 312 brd->dgnc_TransparentPrint_Major = brd->PrintDriver.major; 313 314 return rc; 315 } 316 317 318 /* 319 * dgnc_tty_init() 320 * 321 * Init the tty subsystem. Called once per board after board has been 322 * downloaded and init'ed. 323 */ 324 int dgnc_tty_init(struct dgnc_board *brd) 325 { 326 int i; 327 void __iomem *vaddr; 328 struct channel_t *ch; 329 330 if (!brd) 331 return -ENXIO; 332 333 /* 334 * Initialize board structure elements. 335 */ 336 337 vaddr = brd->re_map_membase; 338 339 brd->nasync = brd->maxports; 340 341 /* 342 * Allocate channel memory that might not have been allocated 343 * when the driver was first loaded. 344 */ 345 for (i = 0; i < brd->nasync; i++) { 346 if (!brd->channels[i]) { 347 348 /* 349 * Okay to malloc with GFP_KERNEL, we are not at 350 * interrupt context, and there are no locks held. 351 */ 352 brd->channels[i] = kzalloc(sizeof(*brd->channels[i]), GFP_KERNEL); 353 } 354 } 355 356 ch = brd->channels[0]; 357 vaddr = brd->re_map_membase; 358 359 /* Set up channel variables */ 360 for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) { 361 362 if (!brd->channels[i]) 363 continue; 364 365 spin_lock_init(&ch->ch_lock); 366 367 /* Store all our magic numbers */ 368 ch->magic = DGNC_CHANNEL_MAGIC; 369 ch->ch_tun.magic = DGNC_UNIT_MAGIC; 370 ch->ch_tun.un_ch = ch; 371 ch->ch_tun.un_type = DGNC_SERIAL; 372 ch->ch_tun.un_dev = i; 373 374 ch->ch_pun.magic = DGNC_UNIT_MAGIC; 375 ch->ch_pun.un_ch = ch; 376 ch->ch_pun.un_type = DGNC_PRINT; 377 ch->ch_pun.un_dev = i + 128; 378 379 if (brd->bd_uart_offset == 0x200) 380 ch->ch_neo_uart = vaddr + (brd->bd_uart_offset * i); 381 else 382 ch->ch_cls_uart = vaddr + (brd->bd_uart_offset * i); 383 384 ch->ch_bd = brd; 385 ch->ch_portnum = i; 386 ch->ch_digi = dgnc_digi_init; 387 388 /* .25 second delay */ 389 ch->ch_close_delay = 250; 390 391 init_waitqueue_head(&ch->ch_flags_wait); 392 init_waitqueue_head(&ch->ch_tun.un_flags_wait); 393 init_waitqueue_head(&ch->ch_pun.un_flags_wait); 394 init_waitqueue_head(&ch->ch_sniff_wait); 395 396 { 397 struct device *classp; 398 399 classp = tty_register_device(&brd->SerialDriver, i, 400 &(ch->ch_bd->pdev->dev)); 401 ch->ch_tun.un_sysfs = classp; 402 dgnc_create_tty_sysfs(&ch->ch_tun, classp); 403 404 classp = tty_register_device(&brd->PrintDriver, i, 405 &(ch->ch_bd->pdev->dev)); 406 ch->ch_pun.un_sysfs = classp; 407 dgnc_create_tty_sysfs(&ch->ch_pun, classp); 408 } 409 410 } 411 412 return 0; 413 } 414 415 416 /* 417 * dgnc_tty_post_uninit() 418 * 419 * UnInitialize any global tty related data. 420 */ 421 void dgnc_tty_post_uninit(void) 422 { 423 kfree(dgnc_TmpWriteBuf); 424 dgnc_TmpWriteBuf = NULL; 425 } 426 427 428 /* 429 * dgnc_tty_uninit() 430 * 431 * Uninitialize the TTY portion of this driver. Free all memory and 432 * resources. 433 */ 434 void dgnc_tty_uninit(struct dgnc_board *brd) 435 { 436 int i = 0; 437 438 if (brd->dgnc_Major_Serial_Registered) { 439 dgnc_BoardsByMajor[brd->SerialDriver.major] = NULL; 440 brd->dgnc_Serial_Major = 0; 441 for (i = 0; i < brd->nasync; i++) { 442 dgnc_remove_tty_sysfs(brd->channels[i]->ch_tun.un_sysfs); 443 tty_unregister_device(&brd->SerialDriver, i); 444 } 445 tty_unregister_driver(&brd->SerialDriver); 446 brd->dgnc_Major_Serial_Registered = FALSE; 447 } 448 449 if (brd->dgnc_Major_TransparentPrint_Registered) { 450 dgnc_BoardsByMajor[brd->PrintDriver.major] = NULL; 451 brd->dgnc_TransparentPrint_Major = 0; 452 for (i = 0; i < brd->nasync; i++) { 453 dgnc_remove_tty_sysfs(brd->channels[i]->ch_pun.un_sysfs); 454 tty_unregister_device(&brd->PrintDriver, i); 455 } 456 tty_unregister_driver(&brd->PrintDriver); 457 brd->dgnc_Major_TransparentPrint_Registered = FALSE; 458 } 459 460 kfree(brd->SerialDriver.ttys); 461 brd->SerialDriver.ttys = NULL; 462 kfree(brd->PrintDriver.ttys); 463 brd->PrintDriver.ttys = NULL; 464 } 465 466 467 #define TMPBUFLEN (1024) 468 469 /* 470 * dgnc_sniff - Dump data out to the "sniff" buffer if the 471 * proc sniff file is opened... 472 */ 473 void dgnc_sniff_nowait_nolock(struct channel_t *ch, unsigned char *text, unsigned char *buf, int len) 474 { 475 struct timeval tv; 476 int n; 477 int r; 478 int nbuf; 479 int i; 480 int tmpbuflen; 481 char *tmpbuf; 482 char *p; 483 int too_much_data; 484 485 tmpbuf = kzalloc(TMPBUFLEN, GFP_ATOMIC); 486 if (!tmpbuf) 487 return; 488 p = tmpbuf; 489 490 /* Leave if sniff not open */ 491 if (!(ch->ch_sniff_flags & SNIFF_OPEN)) 492 goto exit; 493 494 do_gettimeofday(&tv); 495 496 /* Create our header for data dump */ 497 p += sprintf(p, "<%ld %ld><%s><", tv.tv_sec, tv.tv_usec, text); 498 tmpbuflen = p - tmpbuf; 499 500 do { 501 too_much_data = 0; 502 503 for (i = 0; i < len && tmpbuflen < (TMPBUFLEN - 4); i++) { 504 p += sprintf(p, "%02x ", *buf); 505 buf++; 506 tmpbuflen = p - tmpbuf; 507 } 508 509 if (tmpbuflen < (TMPBUFLEN - 4)) { 510 if (i > 0) 511 p += sprintf(p - 1, "%s\n", ">"); 512 else 513 p += sprintf(p, "%s\n", ">"); 514 } else { 515 too_much_data = 1; 516 len -= i; 517 } 518 519 nbuf = strlen(tmpbuf); 520 p = tmpbuf; 521 522 /* 523 * Loop while data remains. 524 */ 525 while (nbuf > 0 && ch->ch_sniff_buf) { 526 /* 527 * Determine the amount of available space left in the 528 * buffer. If there's none, wait until some appears. 529 */ 530 n = (ch->ch_sniff_out - ch->ch_sniff_in - 1) & SNIFF_MASK; 531 532 /* 533 * If there is no space left to write to in our sniff buffer, 534 * we have no choice but to drop the data. 535 * We *cannot* sleep here waiting for space, because this 536 * function was probably called by the interrupt/timer routines! 537 */ 538 if (n == 0) 539 goto exit; 540 541 /* 542 * Copy as much data as will fit. 543 */ 544 545 if (n > nbuf) 546 n = nbuf; 547 548 r = SNIFF_MAX - ch->ch_sniff_in; 549 550 if (r <= n) { 551 memcpy(ch->ch_sniff_buf + ch->ch_sniff_in, p, r); 552 553 n -= r; 554 ch->ch_sniff_in = 0; 555 p += r; 556 nbuf -= r; 557 } 558 559 memcpy(ch->ch_sniff_buf + ch->ch_sniff_in, p, n); 560 561 ch->ch_sniff_in += n; 562 p += n; 563 nbuf -= n; 564 565 /* 566 * Wakeup any thread waiting for data 567 */ 568 if (ch->ch_sniff_flags & SNIFF_WAIT_DATA) { 569 ch->ch_sniff_flags &= ~SNIFF_WAIT_DATA; 570 wake_up_interruptible(&ch->ch_sniff_wait); 571 } 572 } 573 574 /* 575 * If the user sent us too much data to push into our tmpbuf, 576 * we need to keep looping around on all the data. 577 */ 578 if (too_much_data) { 579 p = tmpbuf; 580 tmpbuflen = 0; 581 } 582 583 } while (too_much_data); 584 585 exit: 586 kfree(tmpbuf); 587 } 588 589 590 /*======================================================================= 591 * 592 * dgnc_wmove - Write data to transmit queue. 593 * 594 * ch - Pointer to channel structure. 595 * buf - Poiter to characters to be moved. 596 * n - Number of characters to move. 597 * 598 *=======================================================================*/ 599 static void dgnc_wmove(struct channel_t *ch, char *buf, uint n) 600 { 601 int remain; 602 uint head; 603 604 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 605 return; 606 607 head = ch->ch_w_head & WQUEUEMASK; 608 609 /* 610 * If the write wraps over the top of the circular buffer, 611 * move the portion up to the wrap point, and reset the 612 * pointers to the bottom. 613 */ 614 remain = WQUEUESIZE - head; 615 616 if (n >= remain) { 617 n -= remain; 618 memcpy(ch->ch_wqueue + head, buf, remain); 619 head = 0; 620 buf += remain; 621 } 622 623 if (n > 0) { 624 /* 625 * Move rest of data. 626 */ 627 remain = n; 628 memcpy(ch->ch_wqueue + head, buf, remain); 629 head += remain; 630 } 631 632 head &= WQUEUEMASK; 633 ch->ch_w_head = head; 634 } 635 636 637 638 639 /*======================================================================= 640 * 641 * dgnc_input - Process received data. 642 * 643 * ch - Pointer to channel structure. 644 * 645 *=======================================================================*/ 646 void dgnc_input(struct channel_t *ch) 647 { 648 struct dgnc_board *bd; 649 struct tty_struct *tp; 650 struct tty_ldisc *ld; 651 uint rmask; 652 ushort head; 653 ushort tail; 654 int data_len; 655 unsigned long flags; 656 int flip_len; 657 int len = 0; 658 int n = 0; 659 int s = 0; 660 int i = 0; 661 662 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 663 return; 664 665 tp = ch->ch_tun.un_tty; 666 667 bd = ch->ch_bd; 668 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 669 return; 670 671 spin_lock_irqsave(&ch->ch_lock, flags); 672 673 /* 674 * Figure the number of characters in the buffer. 675 * Exit immediately if none. 676 */ 677 rmask = RQUEUEMASK; 678 head = ch->ch_r_head & rmask; 679 tail = ch->ch_r_tail & rmask; 680 data_len = (head - tail) & rmask; 681 682 if (data_len == 0) { 683 spin_unlock_irqrestore(&ch->ch_lock, flags); 684 return; 685 } 686 687 /* 688 * If the device is not open, or CREAD is off, 689 * flush input data and return immediately. 690 */ 691 if (!tp || (tp->magic != TTY_MAGIC) || !(ch->ch_tun.un_flags & UN_ISOPEN) || 692 !(tp->termios.c_cflag & CREAD) || (ch->ch_tun.un_flags & UN_CLOSING)) { 693 694 ch->ch_r_head = tail; 695 696 /* Force queue flow control to be released, if needed */ 697 dgnc_check_queue_flow_control(ch); 698 699 spin_unlock_irqrestore(&ch->ch_lock, flags); 700 return; 701 } 702 703 /* 704 * If we are throttled, simply don't read any data. 705 */ 706 if (ch->ch_flags & CH_FORCED_STOPI) { 707 spin_unlock_irqrestore(&ch->ch_lock, flags); 708 return; 709 } 710 711 flip_len = TTY_FLIPBUF_SIZE; 712 713 /* Chop down the length, if needed */ 714 len = min(data_len, flip_len); 715 len = min(len, (N_TTY_BUF_SIZE - 1)); 716 717 ld = tty_ldisc_ref(tp); 718 719 #ifdef TTY_DONT_FLIP 720 /* 721 * If the DONT_FLIP flag is on, don't flush our buffer, and act 722 * like the ld doesn't have any space to put the data right now. 723 */ 724 if (test_bit(TTY_DONT_FLIP, &tp->flags)) 725 len = 0; 726 #endif 727 728 /* 729 * If we were unable to get a reference to the ld, 730 * don't flush our buffer, and act like the ld doesn't 731 * have any space to put the data right now. 732 */ 733 if (!ld) { 734 len = 0; 735 } else { 736 /* 737 * If ld doesn't have a pointer to a receive_buf function, 738 * flush the data, then act like the ld doesn't have any 739 * space to put the data right now. 740 */ 741 if (!ld->ops->receive_buf) { 742 ch->ch_r_head = ch->ch_r_tail; 743 len = 0; 744 } 745 } 746 747 if (len <= 0) { 748 spin_unlock_irqrestore(&ch->ch_lock, flags); 749 if (ld) 750 tty_ldisc_deref(ld); 751 return; 752 } 753 754 /* 755 * The tty layer in the kernel has changed in 2.6.16+. 756 * 757 * The flip buffers in the tty structure are no longer exposed, 758 * and probably will be going away eventually. 759 * 760 * If we are completely raw, we don't need to go through a lot 761 * of the tty layers that exist. 762 * In this case, we take the shortest and fastest route we 763 * can to relay the data to the user. 764 * 765 * On the other hand, if we are not raw, we need to go through 766 * the new 2.6.16+ tty layer, which has its API more well defined. 767 */ 768 len = tty_buffer_request_room(tp->port, len); 769 n = len; 770 771 /* 772 * n now contains the most amount of data we can copy, 773 * bounded either by how much the Linux tty layer can handle, 774 * or the amount of data the card actually has pending... 775 */ 776 while (n) { 777 s = ((head >= tail) ? head : RQUEUESIZE) - tail; 778 s = min(s, n); 779 780 if (s <= 0) 781 break; 782 783 /* 784 * If conditions are such that ld needs to see all 785 * UART errors, we will have to walk each character 786 * and error byte and send them to the buffer one at 787 * a time. 788 */ 789 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) { 790 for (i = 0; i < s; i++) { 791 if (*(ch->ch_equeue + tail + i) & UART_LSR_BI) 792 tty_insert_flip_char(tp->port, *(ch->ch_rqueue + tail + i), TTY_BREAK); 793 else if (*(ch->ch_equeue + tail + i) & UART_LSR_PE) 794 tty_insert_flip_char(tp->port, *(ch->ch_rqueue + tail + i), TTY_PARITY); 795 else if (*(ch->ch_equeue + tail + i) & UART_LSR_FE) 796 tty_insert_flip_char(tp->port, *(ch->ch_rqueue + tail + i), TTY_FRAME); 797 else 798 tty_insert_flip_char(tp->port, *(ch->ch_rqueue + tail + i), TTY_NORMAL); 799 } 800 } else { 801 tty_insert_flip_string(tp->port, ch->ch_rqueue + tail, s); 802 } 803 804 dgnc_sniff_nowait_nolock(ch, "USER READ", ch->ch_rqueue + tail, s); 805 806 tail += s; 807 n -= s; 808 /* Flip queue if needed */ 809 tail &= rmask; 810 } 811 812 ch->ch_r_tail = tail & rmask; 813 ch->ch_e_tail = tail & rmask; 814 dgnc_check_queue_flow_control(ch); 815 spin_unlock_irqrestore(&ch->ch_lock, flags); 816 817 /* Tell the tty layer its okay to "eat" the data now */ 818 tty_flip_buffer_push(tp->port); 819 820 if (ld) 821 tty_ldisc_deref(ld); 822 } 823 824 825 /************************************************************************ 826 * Determines when CARRIER changes state and takes appropriate 827 * action. 828 ************************************************************************/ 829 void dgnc_carrier(struct channel_t *ch) 830 { 831 struct dgnc_board *bd; 832 833 int virt_carrier = 0; 834 int phys_carrier = 0; 835 836 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 837 return; 838 839 bd = ch->ch_bd; 840 841 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 842 return; 843 844 if (ch->ch_mistat & UART_MSR_DCD) 845 phys_carrier = 1; 846 847 if (ch->ch_digi.digi_flags & DIGI_FORCEDCD) 848 virt_carrier = 1; 849 850 if (ch->ch_c_cflag & CLOCAL) 851 virt_carrier = 1; 852 853 /* 854 * Test for a VIRTUAL carrier transition to HIGH. 855 */ 856 if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) { 857 858 /* 859 * When carrier rises, wake any threads waiting 860 * for carrier in the open routine. 861 */ 862 863 if (waitqueue_active(&(ch->ch_flags_wait))) 864 wake_up_interruptible(&ch->ch_flags_wait); 865 } 866 867 /* 868 * Test for a PHYSICAL carrier transition to HIGH. 869 */ 870 if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) { 871 872 /* 873 * When carrier rises, wake any threads waiting 874 * for carrier in the open routine. 875 */ 876 877 if (waitqueue_active(&(ch->ch_flags_wait))) 878 wake_up_interruptible(&ch->ch_flags_wait); 879 } 880 881 /* 882 * Test for a PHYSICAL transition to low, so long as we aren't 883 * currently ignoring physical transitions (which is what "virtual 884 * carrier" indicates). 885 * 886 * The transition of the virtual carrier to low really doesn't 887 * matter... it really only means "ignore carrier state", not 888 * "make pretend that carrier is there". 889 */ 890 if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0) && 891 (phys_carrier == 0)) { 892 893 /* 894 * When carrier drops: 895 * 896 * Drop carrier on all open units. 897 * 898 * Flush queues, waking up any task waiting in the 899 * line discipline. 900 * 901 * Send a hangup to the control terminal. 902 * 903 * Enable all select calls. 904 */ 905 if (waitqueue_active(&(ch->ch_flags_wait))) 906 wake_up_interruptible(&ch->ch_flags_wait); 907 908 if (ch->ch_tun.un_open_count > 0) 909 tty_hangup(ch->ch_tun.un_tty); 910 911 if (ch->ch_pun.un_open_count > 0) 912 tty_hangup(ch->ch_pun.un_tty); 913 } 914 915 /* 916 * Make sure that our cached values reflect the current reality. 917 */ 918 if (virt_carrier == 1) 919 ch->ch_flags |= CH_FCAR; 920 else 921 ch->ch_flags &= ~CH_FCAR; 922 923 if (phys_carrier == 1) 924 ch->ch_flags |= CH_CD; 925 else 926 ch->ch_flags &= ~CH_CD; 927 } 928 929 /* 930 * Assign the custom baud rate to the channel structure 931 */ 932 static void dgnc_set_custom_speed(struct channel_t *ch, uint newrate) 933 { 934 int testdiv; 935 int testrate_high; 936 int testrate_low; 937 int deltahigh; 938 int deltalow; 939 940 if (newrate <= 0) { 941 ch->ch_custom_speed = 0; 942 return; 943 } 944 945 /* 946 * Since the divisor is stored in a 16-bit integer, we make sure 947 * we don't allow any rates smaller than a 16-bit integer would allow. 948 * And of course, rates above the dividend won't fly. 949 */ 950 if (newrate && newrate < ((ch->ch_bd->bd_dividend / 0xFFFF) + 1)) 951 newrate = ((ch->ch_bd->bd_dividend / 0xFFFF) + 1); 952 953 if (newrate && newrate > ch->ch_bd->bd_dividend) 954 newrate = ch->ch_bd->bd_dividend; 955 956 if (newrate > 0) { 957 testdiv = ch->ch_bd->bd_dividend / newrate; 958 959 /* 960 * If we try to figure out what rate the board would use 961 * with the test divisor, it will be either equal or higher 962 * than the requested baud rate. If we then determine the 963 * rate with a divisor one higher, we will get the next lower 964 * supported rate below the requested. 965 */ 966 testrate_high = ch->ch_bd->bd_dividend / testdiv; 967 testrate_low = ch->ch_bd->bd_dividend / (testdiv + 1); 968 969 /* 970 * If the rate for the requested divisor is correct, just 971 * use it and be done. 972 */ 973 if (testrate_high != newrate) { 974 /* 975 * Otherwise, pick the rate that is closer (i.e. whichever rate 976 * has a smaller delta). 977 */ 978 deltahigh = testrate_high - newrate; 979 deltalow = newrate - testrate_low; 980 981 if (deltahigh < deltalow) 982 newrate = testrate_high; 983 else 984 newrate = testrate_low; 985 } 986 } 987 988 ch->ch_custom_speed = newrate; 989 } 990 991 992 void dgnc_check_queue_flow_control(struct channel_t *ch) 993 { 994 int qleft = 0; 995 996 /* Store how much space we have left in the queue */ 997 qleft = ch->ch_r_tail - ch->ch_r_head - 1; 998 if (qleft < 0) 999 qleft += RQUEUEMASK + 1; 1000 1001 /* 1002 * Check to see if we should enforce flow control on our queue because 1003 * the ld (or user) isn't reading data out of our queue fast enuf. 1004 * 1005 * NOTE: This is done based on what the current flow control of the 1006 * port is set for. 1007 * 1008 * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt. 1009 * This will cause the UART's FIFO to back up, and force 1010 * the RTS signal to be dropped. 1011 * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to 1012 * the other side, in hopes it will stop sending data to us. 1013 * 3) NONE - Nothing we can do. We will simply drop any extra data 1014 * that gets sent into us when the queue fills up. 1015 */ 1016 if (qleft < 256) { 1017 /* HWFLOW */ 1018 if (ch->ch_digi.digi_flags & CTSPACE || ch->ch_c_cflag & CRTSCTS) { 1019 if (!(ch->ch_flags & CH_RECEIVER_OFF)) { 1020 ch->ch_bd->bd_ops->disable_receiver(ch); 1021 ch->ch_flags |= (CH_RECEIVER_OFF); 1022 } 1023 } 1024 /* SWFLOW */ 1025 else if (ch->ch_c_iflag & IXOFF) { 1026 if (ch->ch_stops_sent <= MAX_STOPS_SENT) { 1027 ch->ch_bd->bd_ops->send_stop_character(ch); 1028 ch->ch_stops_sent++; 1029 } 1030 } 1031 /* No FLOW */ 1032 else { 1033 /* Empty... Can't do anything about the impending overflow... */ 1034 } 1035 } 1036 1037 /* 1038 * Check to see if we should unenforce flow control because 1039 * ld (or user) finally read enuf data out of our queue. 1040 * 1041 * NOTE: This is done based on what the current flow control of the 1042 * port is set for. 1043 * 1044 * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt. 1045 * This will cause the UART's FIFO to raise RTS back up, 1046 * which will allow the other side to start sending data again. 1047 * 2) SWFLOW (IXOFF) - Send a start character to 1048 * the other side, so it will start sending data to us again. 1049 * 3) NONE - Do nothing. Since we didn't do anything to turn off the 1050 * other side, we don't need to do anything now. 1051 */ 1052 if (qleft > (RQUEUESIZE / 2)) { 1053 /* HWFLOW */ 1054 if (ch->ch_digi.digi_flags & RTSPACE || ch->ch_c_cflag & CRTSCTS) { 1055 if (ch->ch_flags & CH_RECEIVER_OFF) { 1056 ch->ch_bd->bd_ops->enable_receiver(ch); 1057 ch->ch_flags &= ~(CH_RECEIVER_OFF); 1058 } 1059 } 1060 /* SWFLOW */ 1061 else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) { 1062 ch->ch_stops_sent = 0; 1063 ch->ch_bd->bd_ops->send_start_character(ch); 1064 } 1065 /* No FLOW */ 1066 else { 1067 /* Nothing needed. */ 1068 } 1069 } 1070 } 1071 1072 1073 void dgnc_wakeup_writes(struct channel_t *ch) 1074 { 1075 int qlen = 0; 1076 unsigned long flags; 1077 1078 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1079 return; 1080 1081 spin_lock_irqsave(&ch->ch_lock, flags); 1082 1083 /* 1084 * If channel now has space, wake up anyone waiting on the condition. 1085 */ 1086 qlen = ch->ch_w_head - ch->ch_w_tail; 1087 if (qlen < 0) 1088 qlen += WQUEUESIZE; 1089 1090 if (qlen >= (WQUEUESIZE - 256)) { 1091 spin_unlock_irqrestore(&ch->ch_lock, flags); 1092 return; 1093 } 1094 1095 if (ch->ch_tun.un_flags & UN_ISOPEN) { 1096 if ((ch->ch_tun.un_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && 1097 ch->ch_tun.un_tty->ldisc->ops->write_wakeup) { 1098 spin_unlock_irqrestore(&ch->ch_lock, flags); 1099 (ch->ch_tun.un_tty->ldisc->ops->write_wakeup)(ch->ch_tun.un_tty); 1100 spin_lock_irqsave(&ch->ch_lock, flags); 1101 } 1102 1103 wake_up_interruptible(&ch->ch_tun.un_tty->write_wait); 1104 1105 /* 1106 * If unit is set to wait until empty, check to make sure 1107 * the queue AND FIFO are both empty. 1108 */ 1109 if (ch->ch_tun.un_flags & UN_EMPTY) { 1110 if ((qlen == 0) && (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0)) { 1111 ch->ch_tun.un_flags &= ~(UN_EMPTY); 1112 1113 /* 1114 * If RTS Toggle mode is on, whenever 1115 * the queue and UART is empty, keep RTS low. 1116 */ 1117 if (ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) { 1118 ch->ch_mostat &= ~(UART_MCR_RTS); 1119 ch->ch_bd->bd_ops->assert_modem_signals(ch); 1120 } 1121 1122 /* 1123 * If DTR Toggle mode is on, whenever 1124 * the queue and UART is empty, keep DTR low. 1125 */ 1126 if (ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) { 1127 ch->ch_mostat &= ~(UART_MCR_DTR); 1128 ch->ch_bd->bd_ops->assert_modem_signals(ch); 1129 } 1130 } 1131 } 1132 1133 wake_up_interruptible(&ch->ch_tun.un_flags_wait); 1134 } 1135 1136 if (ch->ch_pun.un_flags & UN_ISOPEN) { 1137 if ((ch->ch_pun.un_tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && 1138 ch->ch_pun.un_tty->ldisc->ops->write_wakeup) { 1139 spin_unlock_irqrestore(&ch->ch_lock, flags); 1140 (ch->ch_pun.un_tty->ldisc->ops->write_wakeup)(ch->ch_pun.un_tty); 1141 spin_lock_irqsave(&ch->ch_lock, flags); 1142 } 1143 1144 wake_up_interruptible(&ch->ch_pun.un_tty->write_wait); 1145 1146 /* 1147 * If unit is set to wait until empty, check to make sure 1148 * the queue AND FIFO are both empty. 1149 */ 1150 if (ch->ch_pun.un_flags & UN_EMPTY) { 1151 if ((qlen == 0) && (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0)) 1152 ch->ch_pun.un_flags &= ~(UN_EMPTY); 1153 } 1154 1155 wake_up_interruptible(&ch->ch_pun.un_flags_wait); 1156 } 1157 1158 spin_unlock_irqrestore(&ch->ch_lock, flags); 1159 } 1160 1161 1162 1163 /************************************************************************ 1164 * 1165 * TTY Entry points and helper functions 1166 * 1167 ************************************************************************/ 1168 1169 /* 1170 * dgnc_tty_open() 1171 * 1172 */ 1173 static int dgnc_tty_open(struct tty_struct *tty, struct file *file) 1174 { 1175 struct dgnc_board *brd; 1176 struct channel_t *ch; 1177 struct un_t *un; 1178 uint major = 0; 1179 uint minor = 0; 1180 int rc = 0; 1181 unsigned long flags; 1182 1183 rc = 0; 1184 1185 major = MAJOR(tty_devnum(tty)); 1186 minor = MINOR(tty_devnum(tty)); 1187 1188 if (major > 255) 1189 return -ENXIO; 1190 1191 /* Get board pointer from our array of majors we have allocated */ 1192 brd = dgnc_BoardsByMajor[major]; 1193 if (!brd) 1194 return -ENXIO; 1195 1196 /* 1197 * If board is not yet up to a state of READY, go to 1198 * sleep waiting for it to happen or they cancel the open. 1199 */ 1200 rc = wait_event_interruptible(brd->state_wait, 1201 (brd->state & BOARD_READY)); 1202 1203 if (rc) 1204 return rc; 1205 1206 spin_lock_irqsave(&brd->bd_lock, flags); 1207 1208 /* If opened device is greater than our number of ports, bail. */ 1209 if (PORT_NUM(minor) > brd->nasync) { 1210 spin_unlock_irqrestore(&brd->bd_lock, flags); 1211 return -ENXIO; 1212 } 1213 1214 ch = brd->channels[PORT_NUM(minor)]; 1215 if (!ch) { 1216 spin_unlock_irqrestore(&brd->bd_lock, flags); 1217 return -ENXIO; 1218 } 1219 1220 /* Drop board lock */ 1221 spin_unlock_irqrestore(&brd->bd_lock, flags); 1222 1223 /* Grab channel lock */ 1224 spin_lock_irqsave(&ch->ch_lock, flags); 1225 1226 /* Figure out our type */ 1227 if (!IS_PRINT(minor)) { 1228 un = &brd->channels[PORT_NUM(minor)]->ch_tun; 1229 un->un_type = DGNC_SERIAL; 1230 } else if (IS_PRINT(minor)) { 1231 un = &brd->channels[PORT_NUM(minor)]->ch_pun; 1232 un->un_type = DGNC_PRINT; 1233 } else { 1234 spin_unlock_irqrestore(&ch->ch_lock, flags); 1235 return -ENXIO; 1236 } 1237 1238 /* 1239 * If the port is still in a previous open, and in a state 1240 * where we simply cannot safely keep going, wait until the 1241 * state clears. 1242 */ 1243 spin_unlock_irqrestore(&ch->ch_lock, flags); 1244 1245 rc = wait_event_interruptible(ch->ch_flags_wait, ((ch->ch_flags & CH_OPENING) == 0)); 1246 1247 /* If ret is non-zero, user ctrl-c'ed us */ 1248 if (rc) 1249 return -EINTR; 1250 1251 /* 1252 * If either unit is in the middle of the fragile part of close, 1253 * we just cannot touch the channel safely. 1254 * Go to sleep, knowing that when the channel can be 1255 * touched safely, the close routine will signal the 1256 * ch_flags_wait to wake us back up. 1257 */ 1258 rc = wait_event_interruptible(ch->ch_flags_wait, 1259 (((ch->ch_tun.un_flags | ch->ch_pun.un_flags) & UN_CLOSING) == 0)); 1260 1261 /* If ret is non-zero, user ctrl-c'ed us */ 1262 if (rc) 1263 return -EINTR; 1264 1265 spin_lock_irqsave(&ch->ch_lock, flags); 1266 1267 1268 /* Store our unit into driver_data, so we always have it available. */ 1269 tty->driver_data = un; 1270 1271 1272 /* 1273 * Initialize tty's 1274 */ 1275 if (!(un->un_flags & UN_ISOPEN)) { 1276 /* Store important variables. */ 1277 un->un_tty = tty; 1278 1279 /* Maybe do something here to the TTY struct as well? */ 1280 } 1281 1282 1283 /* 1284 * Allocate channel buffers for read/write/error. 1285 * Set flag, so we don't get trounced on. 1286 */ 1287 ch->ch_flags |= (CH_OPENING); 1288 1289 /* Drop locks, as malloc with GFP_KERNEL can sleep */ 1290 spin_unlock_irqrestore(&ch->ch_lock, flags); 1291 1292 if (!ch->ch_rqueue) 1293 ch->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL); 1294 if (!ch->ch_equeue) 1295 ch->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL); 1296 if (!ch->ch_wqueue) 1297 ch->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL); 1298 1299 spin_lock_irqsave(&ch->ch_lock, flags); 1300 1301 ch->ch_flags &= ~(CH_OPENING); 1302 wake_up_interruptible(&ch->ch_flags_wait); 1303 1304 /* 1305 * Initialize if neither terminal or printer is open. 1306 */ 1307 if (!((ch->ch_tun.un_flags | ch->ch_pun.un_flags) & UN_ISOPEN)) { 1308 1309 /* 1310 * Flush input queues. 1311 */ 1312 ch->ch_r_head = 0; 1313 ch->ch_r_tail = 0; 1314 ch->ch_e_head = 0; 1315 ch->ch_e_tail = 0; 1316 ch->ch_w_head = 0; 1317 ch->ch_w_tail = 0; 1318 1319 brd->bd_ops->flush_uart_write(ch); 1320 brd->bd_ops->flush_uart_read(ch); 1321 1322 ch->ch_flags = 0; 1323 ch->ch_cached_lsr = 0; 1324 ch->ch_stop_sending_break = 0; 1325 ch->ch_stops_sent = 0; 1326 1327 ch->ch_c_cflag = tty->termios.c_cflag; 1328 ch->ch_c_iflag = tty->termios.c_iflag; 1329 ch->ch_c_oflag = tty->termios.c_oflag; 1330 ch->ch_c_lflag = tty->termios.c_lflag; 1331 ch->ch_startc = tty->termios.c_cc[VSTART]; 1332 ch->ch_stopc = tty->termios.c_cc[VSTOP]; 1333 1334 /* 1335 * Bring up RTS and DTR... 1336 * Also handle RTS or DTR toggle if set. 1337 */ 1338 if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE)) 1339 ch->ch_mostat |= (UART_MCR_RTS); 1340 if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE)) 1341 ch->ch_mostat |= (UART_MCR_DTR); 1342 1343 /* Tell UART to init itself */ 1344 brd->bd_ops->uart_init(ch); 1345 } 1346 1347 /* 1348 * Run param in case we changed anything 1349 */ 1350 brd->bd_ops->param(tty); 1351 1352 dgnc_carrier(ch); 1353 1354 /* 1355 * follow protocol for opening port 1356 */ 1357 1358 spin_unlock_irqrestore(&ch->ch_lock, flags); 1359 1360 rc = dgnc_block_til_ready(tty, file, ch); 1361 1362 /* No going back now, increment our unit and channel counters */ 1363 spin_lock_irqsave(&ch->ch_lock, flags); 1364 ch->ch_open_count++; 1365 un->un_open_count++; 1366 un->un_flags |= (UN_ISOPEN); 1367 spin_unlock_irqrestore(&ch->ch_lock, flags); 1368 1369 return rc; 1370 } 1371 1372 1373 /* 1374 * dgnc_block_til_ready() 1375 * 1376 * Wait for DCD, if needed. 1377 */ 1378 static int dgnc_block_til_ready(struct tty_struct *tty, struct file *file, struct channel_t *ch) 1379 { 1380 int retval = 0; 1381 struct un_t *un = NULL; 1382 unsigned long flags; 1383 uint old_flags = 0; 1384 int sleep_on_un_flags = 0; 1385 1386 if (!tty || tty->magic != TTY_MAGIC || !file || !ch || ch->magic != DGNC_CHANNEL_MAGIC) 1387 return -ENXIO; 1388 1389 un = tty->driver_data; 1390 if (!un || un->magic != DGNC_UNIT_MAGIC) 1391 return -ENXIO; 1392 1393 spin_lock_irqsave(&ch->ch_lock, flags); 1394 1395 ch->ch_wopen++; 1396 1397 /* Loop forever */ 1398 while (1) { 1399 1400 sleep_on_un_flags = 0; 1401 1402 /* 1403 * If board has failed somehow during our sleep, bail with error. 1404 */ 1405 if (ch->ch_bd->state == BOARD_FAILED) { 1406 retval = -ENXIO; 1407 break; 1408 } 1409 1410 /* If tty was hung up, break out of loop and set error. */ 1411 if (tty_hung_up_p(file)) { 1412 retval = -EAGAIN; 1413 break; 1414 } 1415 1416 /* 1417 * If either unit is in the middle of the fragile part of close, 1418 * we just cannot touch the channel safely. 1419 * Go back to sleep, knowing that when the channel can be 1420 * touched safely, the close routine will signal the 1421 * ch_wait_flags to wake us back up. 1422 */ 1423 if (!((ch->ch_tun.un_flags | ch->ch_pun.un_flags) & UN_CLOSING)) { 1424 1425 /* 1426 * Our conditions to leave cleanly and happily: 1427 * 1) NONBLOCKING on the tty is set. 1428 * 2) CLOCAL is set. 1429 * 3) DCD (fake or real) is active. 1430 */ 1431 1432 if (file->f_flags & O_NONBLOCK) 1433 break; 1434 1435 if (tty->flags & (1 << TTY_IO_ERROR)) { 1436 retval = -EIO; 1437 break; 1438 } 1439 1440 if (ch->ch_flags & CH_CD) 1441 break; 1442 1443 if (ch->ch_flags & CH_FCAR) 1444 break; 1445 } else { 1446 sleep_on_un_flags = 1; 1447 } 1448 1449 /* 1450 * If there is a signal pending, the user probably 1451 * interrupted (ctrl-c) us. 1452 * Leave loop with error set. 1453 */ 1454 if (signal_pending(current)) { 1455 retval = -ERESTARTSYS; 1456 break; 1457 } 1458 1459 /* 1460 * Store the flags before we let go of channel lock 1461 */ 1462 if (sleep_on_un_flags) 1463 old_flags = ch->ch_tun.un_flags | ch->ch_pun.un_flags; 1464 else 1465 old_flags = ch->ch_flags; 1466 1467 /* 1468 * Let go of channel lock before calling schedule. 1469 * Our poller will get any FEP events and wake us up when DCD 1470 * eventually goes active. 1471 */ 1472 1473 spin_unlock_irqrestore(&ch->ch_lock, flags); 1474 1475 /* 1476 * Wait for something in the flags to change from the current value. 1477 */ 1478 if (sleep_on_un_flags) 1479 retval = wait_event_interruptible(un->un_flags_wait, 1480 (old_flags != (ch->ch_tun.un_flags | ch->ch_pun.un_flags))); 1481 else 1482 retval = wait_event_interruptible(ch->ch_flags_wait, 1483 (old_flags != ch->ch_flags)); 1484 1485 /* 1486 * We got woken up for some reason. 1487 * Before looping around, grab our channel lock. 1488 */ 1489 spin_lock_irqsave(&ch->ch_lock, flags); 1490 } 1491 1492 ch->ch_wopen--; 1493 1494 spin_unlock_irqrestore(&ch->ch_lock, flags); 1495 1496 if (retval) 1497 return retval; 1498 1499 return 0; 1500 } 1501 1502 1503 /* 1504 * dgnc_tty_hangup() 1505 * 1506 * Hangup the port. Like a close, but don't wait for output to drain. 1507 */ 1508 static void dgnc_tty_hangup(struct tty_struct *tty) 1509 { 1510 struct un_t *un; 1511 1512 if (!tty || tty->magic != TTY_MAGIC) 1513 return; 1514 1515 un = tty->driver_data; 1516 if (!un || un->magic != DGNC_UNIT_MAGIC) 1517 return; 1518 1519 /* flush the transmit queues */ 1520 dgnc_tty_flush_buffer(tty); 1521 1522 } 1523 1524 1525 /* 1526 * dgnc_tty_close() 1527 * 1528 */ 1529 static void dgnc_tty_close(struct tty_struct *tty, struct file *file) 1530 { 1531 struct ktermios *ts; 1532 struct dgnc_board *bd; 1533 struct channel_t *ch; 1534 struct un_t *un; 1535 unsigned long flags; 1536 int rc = 0; 1537 1538 if (!tty || tty->magic != TTY_MAGIC) 1539 return; 1540 1541 un = tty->driver_data; 1542 if (!un || un->magic != DGNC_UNIT_MAGIC) 1543 return; 1544 1545 ch = un->un_ch; 1546 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1547 return; 1548 1549 bd = ch->ch_bd; 1550 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 1551 return; 1552 1553 ts = &tty->termios; 1554 1555 spin_lock_irqsave(&ch->ch_lock, flags); 1556 1557 /* 1558 * Determine if this is the last close or not - and if we agree about 1559 * which type of close it is with the Line Discipline 1560 */ 1561 if ((tty->count == 1) && (un->un_open_count != 1)) { 1562 /* 1563 * Uh, oh. tty->count is 1, which means that the tty 1564 * structure will be freed. un_open_count should always 1565 * be one in these conditions. If it's greater than 1566 * one, we've got real problems, since it means the 1567 * serial port won't be shutdown. 1568 */ 1569 APR(("tty->count is 1, un open count is %d\n", un->un_open_count)); 1570 un->un_open_count = 1; 1571 } 1572 1573 if (un->un_open_count) 1574 un->un_open_count--; 1575 else 1576 APR(("bad serial port open count of %d\n", un->un_open_count)); 1577 1578 ch->ch_open_count--; 1579 1580 if (ch->ch_open_count && un->un_open_count) { 1581 spin_unlock_irqrestore(&ch->ch_lock, flags); 1582 return; 1583 } 1584 1585 /* OK, its the last close on the unit */ 1586 un->un_flags |= UN_CLOSING; 1587 1588 tty->closing = 1; 1589 1590 1591 /* 1592 * Only officially close channel if count is 0 and 1593 * DIGI_PRINTER bit is not set. 1594 */ 1595 if ((ch->ch_open_count == 0) && !(ch->ch_digi.digi_flags & DIGI_PRINTER)) { 1596 1597 ch->ch_flags &= ~(CH_STOPI | CH_FORCED_STOPI); 1598 1599 /* 1600 * turn off print device when closing print device. 1601 */ 1602 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) { 1603 dgnc_wmove(ch, ch->ch_digi.digi_offstr, 1604 (int) ch->ch_digi.digi_offlen); 1605 ch->ch_flags &= ~CH_PRON; 1606 } 1607 1608 spin_unlock_irqrestore(&ch->ch_lock, flags); 1609 /* wait for output to drain */ 1610 /* This will also return if we take an interrupt */ 1611 1612 rc = bd->bd_ops->drain(tty, 0); 1613 1614 dgnc_tty_flush_buffer(tty); 1615 tty_ldisc_flush(tty); 1616 1617 spin_lock_irqsave(&ch->ch_lock, flags); 1618 1619 tty->closing = 0; 1620 1621 /* 1622 * If we have HUPCL set, lower DTR and RTS 1623 */ 1624 if (ch->ch_c_cflag & HUPCL) { 1625 1626 /* Drop RTS/DTR */ 1627 ch->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS); 1628 bd->bd_ops->assert_modem_signals(ch); 1629 1630 /* 1631 * Go to sleep to ensure RTS/DTR 1632 * have been dropped for modems to see it. 1633 */ 1634 if (ch->ch_close_delay) { 1635 spin_unlock_irqrestore(&ch->ch_lock, 1636 flags); 1637 dgnc_ms_sleep(ch->ch_close_delay); 1638 spin_lock_irqsave(&ch->ch_lock, flags); 1639 } 1640 } 1641 1642 ch->ch_old_baud = 0; 1643 1644 /* Turn off UART interrupts for this port */ 1645 ch->ch_bd->bd_ops->uart_off(ch); 1646 } else { 1647 /* 1648 * turn off print device when closing print device. 1649 */ 1650 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) { 1651 dgnc_wmove(ch, ch->ch_digi.digi_offstr, 1652 (int) ch->ch_digi.digi_offlen); 1653 ch->ch_flags &= ~CH_PRON; 1654 } 1655 } 1656 1657 un->un_tty = NULL; 1658 un->un_flags &= ~(UN_ISOPEN | UN_CLOSING); 1659 1660 wake_up_interruptible(&ch->ch_flags_wait); 1661 wake_up_interruptible(&un->un_flags_wait); 1662 1663 spin_unlock_irqrestore(&ch->ch_lock, flags); 1664 } 1665 1666 1667 /* 1668 * dgnc_tty_chars_in_buffer() 1669 * 1670 * Return number of characters that have not been transmitted yet. 1671 * 1672 * This routine is used by the line discipline to determine if there 1673 * is data waiting to be transmitted/drained/flushed or not. 1674 */ 1675 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty) 1676 { 1677 struct channel_t *ch = NULL; 1678 struct un_t *un = NULL; 1679 ushort thead; 1680 ushort ttail; 1681 uint tmask; 1682 uint chars = 0; 1683 unsigned long flags; 1684 1685 if (tty == NULL) 1686 return 0; 1687 1688 un = tty->driver_data; 1689 if (!un || un->magic != DGNC_UNIT_MAGIC) 1690 return 0; 1691 1692 ch = un->un_ch; 1693 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1694 return 0; 1695 1696 spin_lock_irqsave(&ch->ch_lock, flags); 1697 1698 tmask = WQUEUEMASK; 1699 thead = ch->ch_w_head & tmask; 1700 ttail = ch->ch_w_tail & tmask; 1701 1702 spin_unlock_irqrestore(&ch->ch_lock, flags); 1703 1704 if (ttail == thead) { 1705 chars = 0; 1706 } else { 1707 if (thead >= ttail) 1708 chars = thead - ttail; 1709 else 1710 chars = thead - ttail + WQUEUESIZE; 1711 } 1712 1713 return chars; 1714 } 1715 1716 1717 /* 1718 * dgnc_maxcps_room 1719 * 1720 * Reduces bytes_available to the max number of characters 1721 * that can be sent currently given the maxcps value, and 1722 * returns the new bytes_available. This only affects printer 1723 * output. 1724 */ 1725 static int dgnc_maxcps_room(struct tty_struct *tty, int bytes_available) 1726 { 1727 struct channel_t *ch = NULL; 1728 struct un_t *un = NULL; 1729 1730 if (!tty) 1731 return bytes_available; 1732 1733 un = tty->driver_data; 1734 if (!un || un->magic != DGNC_UNIT_MAGIC) 1735 return bytes_available; 1736 1737 ch = un->un_ch; 1738 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1739 return bytes_available; 1740 1741 /* 1742 * If its not the Transparent print device, return 1743 * the full data amount. 1744 */ 1745 if (un->un_type != DGNC_PRINT) 1746 return bytes_available; 1747 1748 if (ch->ch_digi.digi_maxcps > 0 && ch->ch_digi.digi_bufsize > 0) { 1749 int cps_limit = 0; 1750 unsigned long current_time = jiffies; 1751 unsigned long buffer_time = current_time + 1752 (HZ * ch->ch_digi.digi_bufsize) / ch->ch_digi.digi_maxcps; 1753 1754 if (ch->ch_cpstime < current_time) { 1755 /* buffer is empty */ 1756 ch->ch_cpstime = current_time; /* reset ch_cpstime */ 1757 cps_limit = ch->ch_digi.digi_bufsize; 1758 } else if (ch->ch_cpstime < buffer_time) { 1759 /* still room in the buffer */ 1760 cps_limit = ((buffer_time - ch->ch_cpstime) * ch->ch_digi.digi_maxcps) / HZ; 1761 } else { 1762 /* no room in the buffer */ 1763 cps_limit = 0; 1764 } 1765 1766 bytes_available = min(cps_limit, bytes_available); 1767 } 1768 1769 return bytes_available; 1770 } 1771 1772 1773 /* 1774 * dgnc_tty_write_room() 1775 * 1776 * Return space available in Tx buffer 1777 */ 1778 static int dgnc_tty_write_room(struct tty_struct *tty) 1779 { 1780 struct channel_t *ch = NULL; 1781 struct un_t *un = NULL; 1782 ushort head; 1783 ushort tail; 1784 ushort tmask; 1785 int ret = 0; 1786 unsigned long flags; 1787 1788 if (tty == NULL || dgnc_TmpWriteBuf == NULL) 1789 return 0; 1790 1791 un = tty->driver_data; 1792 if (!un || un->magic != DGNC_UNIT_MAGIC) 1793 return 0; 1794 1795 ch = un->un_ch; 1796 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1797 return 0; 1798 1799 spin_lock_irqsave(&ch->ch_lock, flags); 1800 1801 tmask = WQUEUEMASK; 1802 head = (ch->ch_w_head) & tmask; 1803 tail = (ch->ch_w_tail) & tmask; 1804 1805 ret = tail - head - 1; 1806 if (ret < 0) 1807 ret += WQUEUESIZE; 1808 1809 /* Limit printer to maxcps */ 1810 ret = dgnc_maxcps_room(tty, ret); 1811 1812 /* 1813 * If we are printer device, leave space for 1814 * possibly both the on and off strings. 1815 */ 1816 if (un->un_type == DGNC_PRINT) { 1817 if (!(ch->ch_flags & CH_PRON)) 1818 ret -= ch->ch_digi.digi_onlen; 1819 ret -= ch->ch_digi.digi_offlen; 1820 } else { 1821 if (ch->ch_flags & CH_PRON) 1822 ret -= ch->ch_digi.digi_offlen; 1823 } 1824 1825 if (ret < 0) 1826 ret = 0; 1827 1828 spin_unlock_irqrestore(&ch->ch_lock, flags); 1829 1830 return ret; 1831 } 1832 1833 1834 /* 1835 * dgnc_tty_put_char() 1836 * 1837 * Put a character into ch->ch_buf 1838 * 1839 * - used by the line discipline for OPOST processing 1840 */ 1841 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c) 1842 { 1843 /* 1844 * Simply call tty_write. 1845 */ 1846 dgnc_tty_write(tty, &c, 1); 1847 return 1; 1848 } 1849 1850 1851 /* 1852 * dgnc_tty_write() 1853 * 1854 * Take data from the user or kernel and send it out to the FEP. 1855 * In here exists all the Transparent Print magic as well. 1856 */ 1857 static int dgnc_tty_write(struct tty_struct *tty, 1858 const unsigned char *buf, int count) 1859 { 1860 struct channel_t *ch = NULL; 1861 struct un_t *un = NULL; 1862 int bufcount = 0, n = 0; 1863 int orig_count = 0; 1864 unsigned long flags; 1865 ushort head; 1866 ushort tail; 1867 ushort tmask; 1868 uint remain; 1869 int from_user = 0; 1870 1871 if (tty == NULL || dgnc_TmpWriteBuf == NULL) 1872 return 0; 1873 1874 un = tty->driver_data; 1875 if (!un || un->magic != DGNC_UNIT_MAGIC) 1876 return 0; 1877 1878 ch = un->un_ch; 1879 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 1880 return 0; 1881 1882 if (!count) 1883 return 0; 1884 1885 /* 1886 * Store original amount of characters passed in. 1887 * This helps to figure out if we should ask the FEP 1888 * to send us an event when it has more space available. 1889 */ 1890 orig_count = count; 1891 1892 spin_lock_irqsave(&ch->ch_lock, flags); 1893 1894 /* Get our space available for the channel from the board */ 1895 tmask = WQUEUEMASK; 1896 head = (ch->ch_w_head) & tmask; 1897 tail = (ch->ch_w_tail) & tmask; 1898 1899 bufcount = tail - head - 1; 1900 if (bufcount < 0) 1901 bufcount += WQUEUESIZE; 1902 1903 /* 1904 * Limit printer output to maxcps overall, with bursts allowed 1905 * up to bufsize characters. 1906 */ 1907 bufcount = dgnc_maxcps_room(tty, bufcount); 1908 1909 /* 1910 * Take minimum of what the user wants to send, and the 1911 * space available in the FEP buffer. 1912 */ 1913 count = min(count, bufcount); 1914 1915 /* 1916 * Bail if no space left. 1917 */ 1918 if (count <= 0) { 1919 spin_unlock_irqrestore(&ch->ch_lock, flags); 1920 return 0; 1921 } 1922 1923 /* 1924 * Output the printer ON string, if we are in terminal mode, but 1925 * need to be in printer mode. 1926 */ 1927 if ((un->un_type == DGNC_PRINT) && !(ch->ch_flags & CH_PRON)) { 1928 dgnc_wmove(ch, ch->ch_digi.digi_onstr, 1929 (int) ch->ch_digi.digi_onlen); 1930 head = (ch->ch_w_head) & tmask; 1931 ch->ch_flags |= CH_PRON; 1932 } 1933 1934 /* 1935 * On the other hand, output the printer OFF string, if we are 1936 * currently in printer mode, but need to output to the terminal. 1937 */ 1938 if ((un->un_type != DGNC_PRINT) && (ch->ch_flags & CH_PRON)) { 1939 dgnc_wmove(ch, ch->ch_digi.digi_offstr, 1940 (int) ch->ch_digi.digi_offlen); 1941 head = (ch->ch_w_head) & tmask; 1942 ch->ch_flags &= ~CH_PRON; 1943 } 1944 1945 /* 1946 * If there is nothing left to copy, or I can't handle any more data, leave. 1947 */ 1948 if (count <= 0) { 1949 spin_unlock_irqrestore(&ch->ch_lock, flags); 1950 return 0; 1951 } 1952 1953 if (from_user) { 1954 1955 count = min(count, WRITEBUFLEN); 1956 1957 spin_unlock_irqrestore(&ch->ch_lock, flags); 1958 1959 /* 1960 * If data is coming from user space, copy it into a temporary 1961 * buffer so we don't get swapped out while doing the copy to 1962 * the board. 1963 */ 1964 /* we're allowed to block if it's from_user */ 1965 if (down_interruptible(&dgnc_TmpWriteSem)) 1966 return -EINTR; 1967 1968 /* 1969 * copy_from_user() returns the number 1970 * of bytes that could *NOT* be copied. 1971 */ 1972 count -= copy_from_user(dgnc_TmpWriteBuf, (const unsigned char __user *) buf, count); 1973 1974 if (!count) { 1975 up(&dgnc_TmpWriteSem); 1976 return -EFAULT; 1977 } 1978 1979 spin_lock_irqsave(&ch->ch_lock, flags); 1980 1981 buf = dgnc_TmpWriteBuf; 1982 1983 } 1984 1985 n = count; 1986 1987 /* 1988 * If the write wraps over the top of the circular buffer, 1989 * move the portion up to the wrap point, and reset the 1990 * pointers to the bottom. 1991 */ 1992 remain = WQUEUESIZE - head; 1993 1994 if (n >= remain) { 1995 n -= remain; 1996 memcpy(ch->ch_wqueue + head, buf, remain); 1997 dgnc_sniff_nowait_nolock(ch, "USER WRITE", ch->ch_wqueue + head, remain); 1998 head = 0; 1999 buf += remain; 2000 } 2001 2002 if (n > 0) { 2003 /* 2004 * Move rest of data. 2005 */ 2006 remain = n; 2007 memcpy(ch->ch_wqueue + head, buf, remain); 2008 dgnc_sniff_nowait_nolock(ch, "USER WRITE", ch->ch_wqueue + head, remain); 2009 head += remain; 2010 } 2011 2012 if (count) { 2013 head &= tmask; 2014 ch->ch_w_head = head; 2015 } 2016 2017 /* Update printer buffer empty time. */ 2018 if ((un->un_type == DGNC_PRINT) && (ch->ch_digi.digi_maxcps > 0) 2019 && (ch->ch_digi.digi_bufsize > 0)) { 2020 ch->ch_cpstime += (HZ * count) / ch->ch_digi.digi_maxcps; 2021 } 2022 2023 if (from_user) { 2024 spin_unlock_irqrestore(&ch->ch_lock, flags); 2025 up(&dgnc_TmpWriteSem); 2026 } else { 2027 spin_unlock_irqrestore(&ch->ch_lock, flags); 2028 } 2029 2030 if (count) { 2031 /* 2032 * Channel lock is grabbed and then released 2033 * inside this routine. 2034 */ 2035 ch->ch_bd->bd_ops->copy_data_from_queue_to_uart(ch); 2036 } 2037 2038 return count; 2039 } 2040 2041 2042 /* 2043 * Return modem signals to ld. 2044 */ 2045 2046 static int dgnc_tty_tiocmget(struct tty_struct *tty) 2047 { 2048 struct channel_t *ch; 2049 struct un_t *un; 2050 int result = -EIO; 2051 unsigned char mstat = 0; 2052 unsigned long flags; 2053 2054 if (!tty || tty->magic != TTY_MAGIC) 2055 return result; 2056 2057 un = tty->driver_data; 2058 if (!un || un->magic != DGNC_UNIT_MAGIC) 2059 return result; 2060 2061 ch = un->un_ch; 2062 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2063 return result; 2064 2065 spin_lock_irqsave(&ch->ch_lock, flags); 2066 2067 mstat = (ch->ch_mostat | ch->ch_mistat); 2068 2069 spin_unlock_irqrestore(&ch->ch_lock, flags); 2070 2071 result = 0; 2072 2073 if (mstat & UART_MCR_DTR) 2074 result |= TIOCM_DTR; 2075 if (mstat & UART_MCR_RTS) 2076 result |= TIOCM_RTS; 2077 if (mstat & UART_MSR_CTS) 2078 result |= TIOCM_CTS; 2079 if (mstat & UART_MSR_DSR) 2080 result |= TIOCM_DSR; 2081 if (mstat & UART_MSR_RI) 2082 result |= TIOCM_RI; 2083 if (mstat & UART_MSR_DCD) 2084 result |= TIOCM_CD; 2085 2086 return result; 2087 } 2088 2089 2090 /* 2091 * dgnc_tty_tiocmset() 2092 * 2093 * Set modem signals, called by ld. 2094 */ 2095 2096 static int dgnc_tty_tiocmset(struct tty_struct *tty, 2097 unsigned int set, unsigned int clear) 2098 { 2099 struct dgnc_board *bd; 2100 struct channel_t *ch; 2101 struct un_t *un; 2102 int ret = -EIO; 2103 unsigned long flags; 2104 2105 if (!tty || tty->magic != TTY_MAGIC) 2106 return ret; 2107 2108 un = tty->driver_data; 2109 if (!un || un->magic != DGNC_UNIT_MAGIC) 2110 return ret; 2111 2112 ch = un->un_ch; 2113 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2114 return ret; 2115 2116 bd = ch->ch_bd; 2117 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2118 return ret; 2119 2120 spin_lock_irqsave(&ch->ch_lock, flags); 2121 2122 if (set & TIOCM_RTS) 2123 ch->ch_mostat |= UART_MCR_RTS; 2124 2125 if (set & TIOCM_DTR) 2126 ch->ch_mostat |= UART_MCR_DTR; 2127 2128 if (clear & TIOCM_RTS) 2129 ch->ch_mostat &= ~(UART_MCR_RTS); 2130 2131 if (clear & TIOCM_DTR) 2132 ch->ch_mostat &= ~(UART_MCR_DTR); 2133 2134 ch->ch_bd->bd_ops->assert_modem_signals(ch); 2135 2136 spin_unlock_irqrestore(&ch->ch_lock, flags); 2137 2138 return 0; 2139 } 2140 2141 2142 /* 2143 * dgnc_tty_send_break() 2144 * 2145 * Send a Break, called by ld. 2146 */ 2147 static int dgnc_tty_send_break(struct tty_struct *tty, int msec) 2148 { 2149 struct dgnc_board *bd; 2150 struct channel_t *ch; 2151 struct un_t *un; 2152 int ret = -EIO; 2153 unsigned long flags; 2154 2155 if (!tty || tty->magic != TTY_MAGIC) 2156 return ret; 2157 2158 un = tty->driver_data; 2159 if (!un || un->magic != DGNC_UNIT_MAGIC) 2160 return ret; 2161 2162 ch = un->un_ch; 2163 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2164 return ret; 2165 2166 bd = ch->ch_bd; 2167 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2168 return ret; 2169 2170 switch (msec) { 2171 case -1: 2172 msec = 0xFFFF; 2173 break; 2174 case 0: 2175 msec = 0; 2176 break; 2177 default: 2178 break; 2179 } 2180 2181 spin_lock_irqsave(&ch->ch_lock, flags); 2182 2183 ch->ch_bd->bd_ops->send_break(ch, msec); 2184 2185 spin_unlock_irqrestore(&ch->ch_lock, flags); 2186 2187 return 0; 2188 2189 } 2190 2191 2192 /* 2193 * dgnc_tty_wait_until_sent() 2194 * 2195 * wait until data has been transmitted, called by ld. 2196 */ 2197 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout) 2198 { 2199 struct dgnc_board *bd; 2200 struct channel_t *ch; 2201 struct un_t *un; 2202 int rc; 2203 2204 if (!tty || tty->magic != TTY_MAGIC) 2205 return; 2206 2207 un = tty->driver_data; 2208 if (!un || un->magic != DGNC_UNIT_MAGIC) 2209 return; 2210 2211 ch = un->un_ch; 2212 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2213 return; 2214 2215 bd = ch->ch_bd; 2216 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2217 return; 2218 2219 rc = bd->bd_ops->drain(tty, 0); 2220 } 2221 2222 2223 /* 2224 * dgnc_send_xchar() 2225 * 2226 * send a high priority character, called by ld. 2227 */ 2228 static void dgnc_tty_send_xchar(struct tty_struct *tty, char c) 2229 { 2230 struct dgnc_board *bd; 2231 struct channel_t *ch; 2232 struct un_t *un; 2233 unsigned long flags; 2234 2235 if (!tty || tty->magic != TTY_MAGIC) 2236 return; 2237 2238 un = tty->driver_data; 2239 if (!un || un->magic != DGNC_UNIT_MAGIC) 2240 return; 2241 2242 ch = un->un_ch; 2243 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2244 return; 2245 2246 bd = ch->ch_bd; 2247 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2248 return; 2249 2250 dev_dbg(tty->dev, "dgnc_tty_send_xchar start\n"); 2251 2252 spin_lock_irqsave(&ch->ch_lock, flags); 2253 bd->bd_ops->send_immediate_char(ch, c); 2254 spin_unlock_irqrestore(&ch->ch_lock, flags); 2255 2256 dev_dbg(tty->dev, "dgnc_tty_send_xchar finish\n"); 2257 } 2258 2259 2260 2261 2262 /* 2263 * Return modem signals to ld. 2264 */ 2265 static inline int dgnc_get_mstat(struct channel_t *ch) 2266 { 2267 unsigned char mstat; 2268 int result = -EIO; 2269 unsigned long flags; 2270 2271 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2272 return -ENXIO; 2273 2274 spin_lock_irqsave(&ch->ch_lock, flags); 2275 2276 mstat = (ch->ch_mostat | ch->ch_mistat); 2277 2278 spin_unlock_irqrestore(&ch->ch_lock, flags); 2279 2280 result = 0; 2281 2282 if (mstat & UART_MCR_DTR) 2283 result |= TIOCM_DTR; 2284 if (mstat & UART_MCR_RTS) 2285 result |= TIOCM_RTS; 2286 if (mstat & UART_MSR_CTS) 2287 result |= TIOCM_CTS; 2288 if (mstat & UART_MSR_DSR) 2289 result |= TIOCM_DSR; 2290 if (mstat & UART_MSR_RI) 2291 result |= TIOCM_RI; 2292 if (mstat & UART_MSR_DCD) 2293 result |= TIOCM_CD; 2294 2295 return result; 2296 } 2297 2298 2299 2300 /* 2301 * Return modem signals to ld. 2302 */ 2303 static int dgnc_get_modem_info(struct channel_t *ch, unsigned int __user *value) 2304 { 2305 int result; 2306 2307 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2308 return -ENXIO; 2309 2310 result = dgnc_get_mstat(ch); 2311 2312 if (result < 0) 2313 return -ENXIO; 2314 2315 return put_user(result, value); 2316 } 2317 2318 2319 /* 2320 * dgnc_set_modem_info() 2321 * 2322 * Set modem signals, called by ld. 2323 */ 2324 static int dgnc_set_modem_info(struct tty_struct *tty, unsigned int command, unsigned int __user *value) 2325 { 2326 struct dgnc_board *bd; 2327 struct channel_t *ch; 2328 struct un_t *un; 2329 int ret = -ENXIO; 2330 unsigned int arg = 0; 2331 unsigned long flags; 2332 2333 if (!tty || tty->magic != TTY_MAGIC) 2334 return ret; 2335 2336 un = tty->driver_data; 2337 if (!un || un->magic != DGNC_UNIT_MAGIC) 2338 return ret; 2339 2340 ch = un->un_ch; 2341 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2342 return ret; 2343 2344 bd = ch->ch_bd; 2345 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2346 return ret; 2347 2348 ret = 0; 2349 2350 ret = get_user(arg, value); 2351 if (ret) 2352 return ret; 2353 2354 switch (command) { 2355 case TIOCMBIS: 2356 if (arg & TIOCM_RTS) 2357 ch->ch_mostat |= UART_MCR_RTS; 2358 2359 if (arg & TIOCM_DTR) 2360 ch->ch_mostat |= UART_MCR_DTR; 2361 2362 break; 2363 2364 case TIOCMBIC: 2365 if (arg & TIOCM_RTS) 2366 ch->ch_mostat &= ~(UART_MCR_RTS); 2367 2368 if (arg & TIOCM_DTR) 2369 ch->ch_mostat &= ~(UART_MCR_DTR); 2370 2371 break; 2372 2373 case TIOCMSET: 2374 2375 if (arg & TIOCM_RTS) 2376 ch->ch_mostat |= UART_MCR_RTS; 2377 else 2378 ch->ch_mostat &= ~(UART_MCR_RTS); 2379 2380 if (arg & TIOCM_DTR) 2381 ch->ch_mostat |= UART_MCR_DTR; 2382 else 2383 ch->ch_mostat &= ~(UART_MCR_DTR); 2384 2385 break; 2386 2387 default: 2388 return -EINVAL; 2389 } 2390 2391 spin_lock_irqsave(&ch->ch_lock, flags); 2392 2393 ch->ch_bd->bd_ops->assert_modem_signals(ch); 2394 2395 spin_unlock_irqrestore(&ch->ch_lock, flags); 2396 2397 return 0; 2398 } 2399 2400 2401 /* 2402 * dgnc_tty_digigeta() 2403 * 2404 * Ioctl to get the information for ditty. 2405 * 2406 * 2407 * 2408 */ 2409 static int dgnc_tty_digigeta(struct tty_struct *tty, struct digi_t __user *retinfo) 2410 { 2411 struct channel_t *ch; 2412 struct un_t *un; 2413 struct digi_t tmp; 2414 unsigned long flags; 2415 2416 if (!retinfo) 2417 return -EFAULT; 2418 2419 if (!tty || tty->magic != TTY_MAGIC) 2420 return -EFAULT; 2421 2422 un = tty->driver_data; 2423 if (!un || un->magic != DGNC_UNIT_MAGIC) 2424 return -EFAULT; 2425 2426 ch = un->un_ch; 2427 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2428 return -EFAULT; 2429 2430 memset(&tmp, 0, sizeof(tmp)); 2431 2432 spin_lock_irqsave(&ch->ch_lock, flags); 2433 memcpy(&tmp, &ch->ch_digi, sizeof(tmp)); 2434 spin_unlock_irqrestore(&ch->ch_lock, flags); 2435 2436 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 2437 return -EFAULT; 2438 2439 return 0; 2440 } 2441 2442 2443 /* 2444 * dgnc_tty_digiseta() 2445 * 2446 * Ioctl to set the information for ditty. 2447 * 2448 * 2449 * 2450 */ 2451 static int dgnc_tty_digiseta(struct tty_struct *tty, struct digi_t __user *new_info) 2452 { 2453 struct dgnc_board *bd; 2454 struct channel_t *ch; 2455 struct un_t *un; 2456 struct digi_t new_digi; 2457 unsigned long flags; 2458 2459 if (!tty || tty->magic != TTY_MAGIC) 2460 return -EFAULT; 2461 2462 un = tty->driver_data; 2463 if (!un || un->magic != DGNC_UNIT_MAGIC) 2464 return -EFAULT; 2465 2466 ch = un->un_ch; 2467 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2468 return -EFAULT; 2469 2470 bd = ch->ch_bd; 2471 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2472 return -EFAULT; 2473 2474 if (copy_from_user(&new_digi, new_info, sizeof(new_digi))) 2475 return -EFAULT; 2476 2477 spin_lock_irqsave(&ch->ch_lock, flags); 2478 2479 /* 2480 * Handle transistions to and from RTS Toggle. 2481 */ 2482 if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) && (new_digi.digi_flags & DIGI_RTS_TOGGLE)) 2483 ch->ch_mostat &= ~(UART_MCR_RTS); 2484 if ((ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) && !(new_digi.digi_flags & DIGI_RTS_TOGGLE)) 2485 ch->ch_mostat |= (UART_MCR_RTS); 2486 2487 /* 2488 * Handle transistions to and from DTR Toggle. 2489 */ 2490 if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) && (new_digi.digi_flags & DIGI_DTR_TOGGLE)) 2491 ch->ch_mostat &= ~(UART_MCR_DTR); 2492 if ((ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) && !(new_digi.digi_flags & DIGI_DTR_TOGGLE)) 2493 ch->ch_mostat |= (UART_MCR_DTR); 2494 2495 memcpy(&ch->ch_digi, &new_digi, sizeof(new_digi)); 2496 2497 if (ch->ch_digi.digi_maxcps < 1) 2498 ch->ch_digi.digi_maxcps = 1; 2499 2500 if (ch->ch_digi.digi_maxcps > 10000) 2501 ch->ch_digi.digi_maxcps = 10000; 2502 2503 if (ch->ch_digi.digi_bufsize < 10) 2504 ch->ch_digi.digi_bufsize = 10; 2505 2506 if (ch->ch_digi.digi_maxchar < 1) 2507 ch->ch_digi.digi_maxchar = 1; 2508 2509 if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize) 2510 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize; 2511 2512 if (ch->ch_digi.digi_onlen > DIGI_PLEN) 2513 ch->ch_digi.digi_onlen = DIGI_PLEN; 2514 2515 if (ch->ch_digi.digi_offlen > DIGI_PLEN) 2516 ch->ch_digi.digi_offlen = DIGI_PLEN; 2517 2518 ch->ch_bd->bd_ops->param(tty); 2519 2520 spin_unlock_irqrestore(&ch->ch_lock, flags); 2521 2522 return 0; 2523 } 2524 2525 2526 /* 2527 * dgnc_set_termios() 2528 */ 2529 static void dgnc_tty_set_termios(struct tty_struct *tty, struct ktermios *old_termios) 2530 { 2531 struct dgnc_board *bd; 2532 struct channel_t *ch; 2533 struct un_t *un; 2534 unsigned long flags; 2535 2536 if (!tty || tty->magic != TTY_MAGIC) 2537 return; 2538 2539 un = tty->driver_data; 2540 if (!un || un->magic != DGNC_UNIT_MAGIC) 2541 return; 2542 2543 ch = un->un_ch; 2544 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2545 return; 2546 2547 bd = ch->ch_bd; 2548 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2549 return; 2550 2551 spin_lock_irqsave(&ch->ch_lock, flags); 2552 2553 ch->ch_c_cflag = tty->termios.c_cflag; 2554 ch->ch_c_iflag = tty->termios.c_iflag; 2555 ch->ch_c_oflag = tty->termios.c_oflag; 2556 ch->ch_c_lflag = tty->termios.c_lflag; 2557 ch->ch_startc = tty->termios.c_cc[VSTART]; 2558 ch->ch_stopc = tty->termios.c_cc[VSTOP]; 2559 2560 ch->ch_bd->bd_ops->param(tty); 2561 dgnc_carrier(ch); 2562 2563 spin_unlock_irqrestore(&ch->ch_lock, flags); 2564 } 2565 2566 2567 static void dgnc_tty_throttle(struct tty_struct *tty) 2568 { 2569 struct channel_t *ch; 2570 struct un_t *un; 2571 unsigned long flags; 2572 2573 if (!tty || tty->magic != TTY_MAGIC) 2574 return; 2575 2576 un = tty->driver_data; 2577 if (!un || un->magic != DGNC_UNIT_MAGIC) 2578 return; 2579 2580 ch = un->un_ch; 2581 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2582 return; 2583 2584 spin_lock_irqsave(&ch->ch_lock, flags); 2585 2586 ch->ch_flags |= (CH_FORCED_STOPI); 2587 2588 spin_unlock_irqrestore(&ch->ch_lock, flags); 2589 } 2590 2591 2592 static void dgnc_tty_unthrottle(struct tty_struct *tty) 2593 { 2594 struct channel_t *ch; 2595 struct un_t *un; 2596 unsigned long flags; 2597 2598 if (!tty || tty->magic != TTY_MAGIC) 2599 return; 2600 2601 un = tty->driver_data; 2602 if (!un || un->magic != DGNC_UNIT_MAGIC) 2603 return; 2604 2605 ch = un->un_ch; 2606 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2607 return; 2608 2609 spin_lock_irqsave(&ch->ch_lock, flags); 2610 2611 ch->ch_flags &= ~(CH_FORCED_STOPI); 2612 2613 spin_unlock_irqrestore(&ch->ch_lock, flags); 2614 } 2615 2616 2617 static void dgnc_tty_start(struct tty_struct *tty) 2618 { 2619 struct dgnc_board *bd; 2620 struct channel_t *ch; 2621 struct un_t *un; 2622 unsigned long flags; 2623 2624 if (!tty || tty->magic != TTY_MAGIC) 2625 return; 2626 2627 un = tty->driver_data; 2628 if (!un || un->magic != DGNC_UNIT_MAGIC) 2629 return; 2630 2631 ch = un->un_ch; 2632 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2633 return; 2634 2635 bd = ch->ch_bd; 2636 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2637 return; 2638 2639 spin_lock_irqsave(&ch->ch_lock, flags); 2640 2641 ch->ch_flags &= ~(CH_FORCED_STOP); 2642 2643 spin_unlock_irqrestore(&ch->ch_lock, flags); 2644 } 2645 2646 2647 static void dgnc_tty_stop(struct tty_struct *tty) 2648 { 2649 struct dgnc_board *bd; 2650 struct channel_t *ch; 2651 struct un_t *un; 2652 unsigned long flags; 2653 2654 if (!tty || tty->magic != TTY_MAGIC) 2655 return; 2656 2657 un = tty->driver_data; 2658 if (!un || un->magic != DGNC_UNIT_MAGIC) 2659 return; 2660 2661 ch = un->un_ch; 2662 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2663 return; 2664 2665 bd = ch->ch_bd; 2666 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2667 return; 2668 2669 spin_lock_irqsave(&ch->ch_lock, flags); 2670 2671 ch->ch_flags |= (CH_FORCED_STOP); 2672 2673 spin_unlock_irqrestore(&ch->ch_lock, flags); 2674 } 2675 2676 2677 /* 2678 * dgnc_tty_flush_chars() 2679 * 2680 * Flush the cook buffer 2681 * 2682 * Note to self, and any other poor souls who venture here: 2683 * 2684 * flush in this case DOES NOT mean dispose of the data. 2685 * instead, it means "stop buffering and send it if you 2686 * haven't already." Just guess how I figured that out... SRW 2-Jun-98 2687 * 2688 * It is also always called in interrupt context - JAR 8-Sept-99 2689 */ 2690 static void dgnc_tty_flush_chars(struct tty_struct *tty) 2691 { 2692 struct dgnc_board *bd; 2693 struct channel_t *ch; 2694 struct un_t *un; 2695 unsigned long flags; 2696 2697 if (!tty || tty->magic != TTY_MAGIC) 2698 return; 2699 2700 un = tty->driver_data; 2701 if (!un || un->magic != DGNC_UNIT_MAGIC) 2702 return; 2703 2704 ch = un->un_ch; 2705 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2706 return; 2707 2708 bd = ch->ch_bd; 2709 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2710 return; 2711 2712 spin_lock_irqsave(&ch->ch_lock, flags); 2713 2714 /* Do something maybe here */ 2715 2716 spin_unlock_irqrestore(&ch->ch_lock, flags); 2717 } 2718 2719 2720 2721 /* 2722 * dgnc_tty_flush_buffer() 2723 * 2724 * Flush Tx buffer (make in == out) 2725 */ 2726 static void dgnc_tty_flush_buffer(struct tty_struct *tty) 2727 { 2728 struct channel_t *ch; 2729 struct un_t *un; 2730 unsigned long flags; 2731 2732 if (!tty || tty->magic != TTY_MAGIC) 2733 return; 2734 2735 un = tty->driver_data; 2736 if (!un || un->magic != DGNC_UNIT_MAGIC) 2737 return; 2738 2739 ch = un->un_ch; 2740 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2741 return; 2742 2743 spin_lock_irqsave(&ch->ch_lock, flags); 2744 2745 ch->ch_flags &= ~CH_STOP; 2746 2747 /* Flush our write queue */ 2748 ch->ch_w_head = ch->ch_w_tail; 2749 2750 /* Flush UARTs transmit FIFO */ 2751 ch->ch_bd->bd_ops->flush_uart_write(ch); 2752 2753 if (ch->ch_tun.un_flags & (UN_LOW|UN_EMPTY)) { 2754 ch->ch_tun.un_flags &= ~(UN_LOW|UN_EMPTY); 2755 wake_up_interruptible(&ch->ch_tun.un_flags_wait); 2756 } 2757 if (ch->ch_pun.un_flags & (UN_LOW|UN_EMPTY)) { 2758 ch->ch_pun.un_flags &= ~(UN_LOW|UN_EMPTY); 2759 wake_up_interruptible(&ch->ch_pun.un_flags_wait); 2760 } 2761 2762 spin_unlock_irqrestore(&ch->ch_lock, flags); 2763 } 2764 2765 2766 2767 /***************************************************************************** 2768 * 2769 * The IOCTL function and all of its helpers 2770 * 2771 *****************************************************************************/ 2772 2773 /* 2774 * dgnc_tty_ioctl() 2775 * 2776 * The usual assortment of ioctl's 2777 */ 2778 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd, 2779 unsigned long arg) 2780 { 2781 struct dgnc_board *bd; 2782 struct channel_t *ch; 2783 struct un_t *un; 2784 int rc; 2785 unsigned long flags; 2786 void __user *uarg = (void __user *) arg; 2787 2788 if (!tty || tty->magic != TTY_MAGIC) 2789 return -ENODEV; 2790 2791 un = tty->driver_data; 2792 if (!un || un->magic != DGNC_UNIT_MAGIC) 2793 return -ENODEV; 2794 2795 ch = un->un_ch; 2796 if (!ch || ch->magic != DGNC_CHANNEL_MAGIC) 2797 return -ENODEV; 2798 2799 bd = ch->ch_bd; 2800 if (!bd || bd->magic != DGNC_BOARD_MAGIC) 2801 return -ENODEV; 2802 2803 spin_lock_irqsave(&ch->ch_lock, flags); 2804 2805 if (un->un_open_count <= 0) { 2806 spin_unlock_irqrestore(&ch->ch_lock, flags); 2807 return -EIO; 2808 } 2809 2810 switch (cmd) { 2811 2812 /* Here are all the standard ioctl's that we MUST implement */ 2813 2814 case TCSBRK: 2815 /* 2816 * TCSBRK is SVID version: non-zero arg --> no break 2817 * this behaviour is exploited by tcdrain(). 2818 * 2819 * According to POSIX.1 spec (7.2.2.1.2) breaks should be 2820 * between 0.25 and 0.5 seconds so we'll ask for something 2821 * in the middle: 0.375 seconds. 2822 */ 2823 rc = tty_check_change(tty); 2824 spin_unlock_irqrestore(&ch->ch_lock, flags); 2825 if (rc) 2826 return rc; 2827 2828 rc = ch->ch_bd->bd_ops->drain(tty, 0); 2829 2830 if (rc) 2831 return -EINTR; 2832 2833 spin_lock_irqsave(&ch->ch_lock, flags); 2834 2835 if (((cmd == TCSBRK) && (!arg)) || (cmd == TCSBRKP)) 2836 ch->ch_bd->bd_ops->send_break(ch, 250); 2837 2838 spin_unlock_irqrestore(&ch->ch_lock, flags); 2839 2840 return 0; 2841 2842 2843 case TCSBRKP: 2844 /* support for POSIX tcsendbreak() 2845 * According to POSIX.1 spec (7.2.2.1.2) breaks should be 2846 * between 0.25 and 0.5 seconds so we'll ask for something 2847 * in the middle: 0.375 seconds. 2848 */ 2849 rc = tty_check_change(tty); 2850 spin_unlock_irqrestore(&ch->ch_lock, flags); 2851 if (rc) 2852 return rc; 2853 2854 rc = ch->ch_bd->bd_ops->drain(tty, 0); 2855 if (rc) 2856 return -EINTR; 2857 2858 spin_lock_irqsave(&ch->ch_lock, flags); 2859 2860 ch->ch_bd->bd_ops->send_break(ch, 250); 2861 2862 spin_unlock_irqrestore(&ch->ch_lock, flags); 2863 2864 return 0; 2865 2866 case TIOCSBRK: 2867 rc = tty_check_change(tty); 2868 spin_unlock_irqrestore(&ch->ch_lock, flags); 2869 if (rc) 2870 return rc; 2871 2872 rc = ch->ch_bd->bd_ops->drain(tty, 0); 2873 if (rc) 2874 return -EINTR; 2875 2876 spin_lock_irqsave(&ch->ch_lock, flags); 2877 2878 ch->ch_bd->bd_ops->send_break(ch, 250); 2879 2880 spin_unlock_irqrestore(&ch->ch_lock, flags); 2881 2882 return 0; 2883 2884 case TIOCCBRK: 2885 /* Do Nothing */ 2886 spin_unlock_irqrestore(&ch->ch_lock, flags); 2887 return 0; 2888 2889 case TIOCGSOFTCAR: 2890 2891 spin_unlock_irqrestore(&ch->ch_lock, flags); 2892 2893 rc = put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *) arg); 2894 return rc; 2895 2896 case TIOCSSOFTCAR: 2897 2898 spin_unlock_irqrestore(&ch->ch_lock, flags); 2899 rc = get_user(arg, (unsigned long __user *) arg); 2900 if (rc) 2901 return rc; 2902 2903 spin_lock_irqsave(&ch->ch_lock, flags); 2904 tty->termios.c_cflag = ((tty->termios.c_cflag & ~CLOCAL) | (arg ? CLOCAL : 0)); 2905 ch->ch_bd->bd_ops->param(tty); 2906 spin_unlock_irqrestore(&ch->ch_lock, flags); 2907 2908 return 0; 2909 2910 case TIOCMGET: 2911 spin_unlock_irqrestore(&ch->ch_lock, flags); 2912 return dgnc_get_modem_info(ch, uarg); 2913 2914 case TIOCMBIS: 2915 case TIOCMBIC: 2916 case TIOCMSET: 2917 spin_unlock_irqrestore(&ch->ch_lock, flags); 2918 return dgnc_set_modem_info(tty, cmd, uarg); 2919 2920 /* 2921 * Here are any additional ioctl's that we want to implement 2922 */ 2923 2924 case TCFLSH: 2925 /* 2926 * The linux tty driver doesn't have a flush 2927 * input routine for the driver, assuming all backed 2928 * up data is in the line disc. buffers. However, 2929 * we all know that's not the case. Here, we 2930 * act on the ioctl, but then lie and say we didn't 2931 * so the line discipline will process the flush 2932 * also. 2933 */ 2934 rc = tty_check_change(tty); 2935 if (rc) { 2936 spin_unlock_irqrestore(&ch->ch_lock, flags); 2937 return rc; 2938 } 2939 2940 if ((arg == TCIFLUSH) || (arg == TCIOFLUSH)) { 2941 ch->ch_r_head = ch->ch_r_tail; 2942 ch->ch_bd->bd_ops->flush_uart_read(ch); 2943 /* Force queue flow control to be released, if needed */ 2944 dgnc_check_queue_flow_control(ch); 2945 } 2946 2947 if ((arg == TCOFLUSH) || (arg == TCIOFLUSH)) { 2948 if (!(un->un_type == DGNC_PRINT)) { 2949 ch->ch_w_head = ch->ch_w_tail; 2950 ch->ch_bd->bd_ops->flush_uart_write(ch); 2951 2952 if (ch->ch_tun.un_flags & (UN_LOW|UN_EMPTY)) { 2953 ch->ch_tun.un_flags &= ~(UN_LOW|UN_EMPTY); 2954 wake_up_interruptible(&ch->ch_tun.un_flags_wait); 2955 } 2956 2957 if (ch->ch_pun.un_flags & (UN_LOW|UN_EMPTY)) { 2958 ch->ch_pun.un_flags &= ~(UN_LOW|UN_EMPTY); 2959 wake_up_interruptible(&ch->ch_pun.un_flags_wait); 2960 } 2961 2962 } 2963 } 2964 2965 /* pretend we didn't recognize this IOCTL */ 2966 spin_unlock_irqrestore(&ch->ch_lock, flags); 2967 return -ENOIOCTLCMD; 2968 case TCSETSF: 2969 case TCSETSW: 2970 /* 2971 * The linux tty driver doesn't have a flush 2972 * input routine for the driver, assuming all backed 2973 * up data is in the line disc. buffers. However, 2974 * we all know that's not the case. Here, we 2975 * act on the ioctl, but then lie and say we didn't 2976 * so the line discipline will process the flush 2977 * also. 2978 */ 2979 if (cmd == TCSETSF) { 2980 /* flush rx */ 2981 ch->ch_flags &= ~CH_STOP; 2982 ch->ch_r_head = ch->ch_r_tail; 2983 ch->ch_bd->bd_ops->flush_uart_read(ch); 2984 /* Force queue flow control to be released, if needed */ 2985 dgnc_check_queue_flow_control(ch); 2986 } 2987 2988 /* now wait for all the output to drain */ 2989 spin_unlock_irqrestore(&ch->ch_lock, flags); 2990 rc = ch->ch_bd->bd_ops->drain(tty, 0); 2991 if (rc) 2992 return -EINTR; 2993 2994 /* pretend we didn't recognize this */ 2995 return -ENOIOCTLCMD; 2996 2997 case TCSETAW: 2998 2999 spin_unlock_irqrestore(&ch->ch_lock, flags); 3000 rc = ch->ch_bd->bd_ops->drain(tty, 0); 3001 if (rc) 3002 return -EINTR; 3003 3004 /* pretend we didn't recognize this */ 3005 return -ENOIOCTLCMD; 3006 3007 case TCXONC: 3008 spin_unlock_irqrestore(&ch->ch_lock, flags); 3009 /* Make the ld do it */ 3010 return -ENOIOCTLCMD; 3011 3012 case DIGI_GETA: 3013 /* get information for ditty */ 3014 spin_unlock_irqrestore(&ch->ch_lock, flags); 3015 return dgnc_tty_digigeta(tty, uarg); 3016 3017 case DIGI_SETAW: 3018 case DIGI_SETAF: 3019 3020 /* set information for ditty */ 3021 if (cmd == (DIGI_SETAW)) { 3022 3023 spin_unlock_irqrestore(&ch->ch_lock, flags); 3024 rc = ch->ch_bd->bd_ops->drain(tty, 0); 3025 3026 if (rc) 3027 return -EINTR; 3028 3029 spin_lock_irqsave(&ch->ch_lock, flags); 3030 } else { 3031 tty_ldisc_flush(tty); 3032 } 3033 /* fall thru */ 3034 3035 case DIGI_SETA: 3036 spin_unlock_irqrestore(&ch->ch_lock, flags); 3037 return dgnc_tty_digiseta(tty, uarg); 3038 3039 case DIGI_LOOPBACK: 3040 { 3041 uint loopback = 0; 3042 /* Let go of locks when accessing user space, could sleep */ 3043 spin_unlock_irqrestore(&ch->ch_lock, flags); 3044 rc = get_user(loopback, (unsigned int __user *) arg); 3045 if (rc) 3046 return rc; 3047 spin_lock_irqsave(&ch->ch_lock, flags); 3048 3049 /* Enable/disable internal loopback for this port */ 3050 if (loopback) 3051 ch->ch_flags |= CH_LOOPBACK; 3052 else 3053 ch->ch_flags &= ~(CH_LOOPBACK); 3054 3055 ch->ch_bd->bd_ops->param(tty); 3056 spin_unlock_irqrestore(&ch->ch_lock, flags); 3057 return 0; 3058 } 3059 3060 case DIGI_GETCUSTOMBAUD: 3061 spin_unlock_irqrestore(&ch->ch_lock, flags); 3062 rc = put_user(ch->ch_custom_speed, (unsigned int __user *) arg); 3063 return rc; 3064 3065 case DIGI_SETCUSTOMBAUD: 3066 { 3067 int new_rate; 3068 /* Let go of locks when accessing user space, could sleep */ 3069 spin_unlock_irqrestore(&ch->ch_lock, flags); 3070 rc = get_user(new_rate, (int __user *) arg); 3071 if (rc) 3072 return rc; 3073 spin_lock_irqsave(&ch->ch_lock, flags); 3074 dgnc_set_custom_speed(ch, new_rate); 3075 ch->ch_bd->bd_ops->param(tty); 3076 spin_unlock_irqrestore(&ch->ch_lock, flags); 3077 return 0; 3078 } 3079 3080 /* 3081 * This ioctl allows insertion of a character into the front 3082 * of any pending data to be transmitted. 3083 * 3084 * This ioctl is to satify the "Send Character Immediate" 3085 * call that the RealPort protocol spec requires. 3086 */ 3087 case DIGI_REALPORT_SENDIMMEDIATE: 3088 { 3089 unsigned char c; 3090 3091 spin_unlock_irqrestore(&ch->ch_lock, flags); 3092 rc = get_user(c, (unsigned char __user *) arg); 3093 if (rc) 3094 return rc; 3095 spin_lock_irqsave(&ch->ch_lock, flags); 3096 ch->ch_bd->bd_ops->send_immediate_char(ch, c); 3097 spin_unlock_irqrestore(&ch->ch_lock, flags); 3098 return 0; 3099 } 3100 3101 /* 3102 * This ioctl returns all the current counts for the port. 3103 * 3104 * This ioctl is to satify the "Line Error Counters" 3105 * call that the RealPort protocol spec requires. 3106 */ 3107 case DIGI_REALPORT_GETCOUNTERS: 3108 { 3109 struct digi_getcounter buf; 3110 3111 buf.norun = ch->ch_err_overrun; 3112 buf.noflow = 0; /* The driver doesn't keep this stat */ 3113 buf.nframe = ch->ch_err_frame; 3114 buf.nparity = ch->ch_err_parity; 3115 buf.nbreak = ch->ch_err_break; 3116 buf.rbytes = ch->ch_rxcount; 3117 buf.tbytes = ch->ch_txcount; 3118 3119 spin_unlock_irqrestore(&ch->ch_lock, flags); 3120 3121 if (copy_to_user(uarg, &buf, sizeof(buf))) 3122 return -EFAULT; 3123 3124 return 0; 3125 } 3126 3127 /* 3128 * This ioctl returns all current events. 3129 * 3130 * This ioctl is to satify the "Event Reporting" 3131 * call that the RealPort protocol spec requires. 3132 */ 3133 case DIGI_REALPORT_GETEVENTS: 3134 { 3135 unsigned int events = 0; 3136 3137 /* NOTE: MORE EVENTS NEEDS TO BE ADDED HERE */ 3138 if (ch->ch_flags & CH_BREAK_SENDING) 3139 events |= EV_TXB; 3140 if ((ch->ch_flags & CH_STOP) || (ch->ch_flags & CH_FORCED_STOP)) 3141 events |= (EV_OPU | EV_OPS); 3142 3143 if ((ch->ch_flags & CH_STOPI) || (ch->ch_flags & CH_FORCED_STOPI)) 3144 events |= (EV_IPU | EV_IPS); 3145 3146 spin_unlock_irqrestore(&ch->ch_lock, flags); 3147 rc = put_user(events, (unsigned int __user *) arg); 3148 return rc; 3149 } 3150 3151 /* 3152 * This ioctl returns TOUT and TIN counters based 3153 * upon the values passed in by the RealPort Server. 3154 * It also passes back whether the UART Transmitter is 3155 * empty as well. 3156 */ 3157 case DIGI_REALPORT_GETBUFFERS: 3158 { 3159 struct digi_getbuffer buf; 3160 int tdist; 3161 int count; 3162 3163 spin_unlock_irqrestore(&ch->ch_lock, flags); 3164 3165 /* 3166 * Get data from user first. 3167 */ 3168 if (copy_from_user(&buf, uarg, sizeof(buf))) 3169 return -EFAULT; 3170 3171 spin_lock_irqsave(&ch->ch_lock, flags); 3172 3173 /* 3174 * Figure out how much data is in our RX and TX queues. 3175 */ 3176 buf.rxbuf = (ch->ch_r_head - ch->ch_r_tail) & RQUEUEMASK; 3177 buf.txbuf = (ch->ch_w_head - ch->ch_w_tail) & WQUEUEMASK; 3178 3179 /* 3180 * Is the UART empty? Add that value to whats in our TX queue. 3181 */ 3182 count = buf.txbuf + ch->ch_bd->bd_ops->get_uart_bytes_left(ch); 3183 3184 /* 3185 * Figure out how much data the RealPort Server believes should 3186 * be in our TX queue. 3187 */ 3188 tdist = (buf.tIn - buf.tOut) & 0xffff; 3189 3190 /* 3191 * If we have more data than the RealPort Server believes we 3192 * should have, reduce our count to its amount. 3193 * 3194 * This count difference CAN happen because the Linux LD can 3195 * insert more characters into our queue for OPOST processing 3196 * that the RealPort Server doesn't know about. 3197 */ 3198 if (buf.txbuf > tdist) 3199 buf.txbuf = tdist; 3200 3201 /* 3202 * Report whether our queue and UART TX are completely empty. 3203 */ 3204 if (count) 3205 buf.txdone = 0; 3206 else 3207 buf.txdone = 1; 3208 3209 spin_unlock_irqrestore(&ch->ch_lock, flags); 3210 3211 if (copy_to_user(uarg, &buf, sizeof(buf))) 3212 return -EFAULT; 3213 3214 return 0; 3215 } 3216 default: 3217 spin_unlock_irqrestore(&ch->ch_lock, flags); 3218 3219 return -ENOIOCTLCMD; 3220 } 3221 } 3222 3223 3224 3225 3226 3227 /* LDV_COMMENT_BEGIN_MAIN */ 3228 #ifdef LDV_MAIN4_sequence_infinite_withcheck_stateful 3229 3230 /*###########################################################################*/ 3231 3232 /*############## Driver Environment Generator 0.2 output ####################*/ 3233 3234 /*###########################################################################*/ 3235 3236 3237 3238 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test if all kernel resources are correctly released by driver before driver will be unloaded. */ 3239 void ldv_check_final_state(void); 3240 3241 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result. */ 3242 void ldv_check_return_value(int res); 3243 3244 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Test correct return result of probe() function. */ 3245 void ldv_check_return_value_probe(int res); 3246 3247 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Initializes the model. */ 3248 void ldv_initialize(void); 3249 3250 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Reinitializes the model between distinct model function calls. */ 3251 void ldv_handler_precall(void); 3252 3253 /* LDV_COMMENT_FUNCTION_DECLARE_LDV Special function for LDV verifier. Returns arbitrary interger value. */ 3254 int nondet_int(void); 3255 3256 /* LDV_COMMENT_VAR_DECLARE_LDV Special variable for LDV verifier. */ 3257 int LDV_IN_INTERRUPT; 3258 3259 /* LDV_COMMENT_FUNCTION_MAIN Main function for LDV verifier. */ 3260 void ldv_main4_sequence_infinite_withcheck_stateful(void) { 3261 3262 3263 3264 /* LDV_COMMENT_BEGIN_VARIABLE_DECLARATION_PART */ 3265 /*============================= VARIABLE DECLARATION PART =============================*/ 3266 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3267 /* content: static int dgnc_tty_open(struct tty_struct *tty, struct file *file)*/ 3268 /* LDV_COMMENT_BEGIN_PREP */ 3269 #define init_MUTEX(sem) sema_init(sem, 1) 3270 #define DECLARE_MUTEX(name) \ 3271 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3272 #define TMPBUFLEN (1024) 3273 #ifdef TTY_DONT_FLIP 3274 #endif 3275 /* LDV_COMMENT_END_PREP */ 3276 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_open" */ 3277 struct tty_struct * var_group1; 3278 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_open" */ 3279 struct file * var_group2; 3280 /* LDV_COMMENT_VAR_DECLARE Variable declaration for test return result from function call "dgnc_tty_open" */ 3281 static int res_dgnc_tty_open_12; 3282 /* content: static void dgnc_tty_close(struct tty_struct *tty, struct file *file)*/ 3283 /* LDV_COMMENT_BEGIN_PREP */ 3284 #define init_MUTEX(sem) sema_init(sem, 1) 3285 #define DECLARE_MUTEX(name) \ 3286 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3287 #define TMPBUFLEN (1024) 3288 #ifdef TTY_DONT_FLIP 3289 #endif 3290 /* LDV_COMMENT_END_PREP */ 3291 /* content: static int dgnc_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)*/ 3292 /* LDV_COMMENT_BEGIN_PREP */ 3293 #define init_MUTEX(sem) sema_init(sem, 1) 3294 #define DECLARE_MUTEX(name) \ 3295 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3296 #define TMPBUFLEN (1024) 3297 #ifdef TTY_DONT_FLIP 3298 #endif 3299 /* LDV_COMMENT_END_PREP */ 3300 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_write" */ 3301 const unsigned char * var_dgnc_tty_write_20_p1; 3302 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_write" */ 3303 int var_dgnc_tty_write_20_p2; 3304 /* content: static int dgnc_tty_write_room(struct tty_struct *tty)*/ 3305 /* LDV_COMMENT_BEGIN_PREP */ 3306 #define init_MUTEX(sem) sema_init(sem, 1) 3307 #define DECLARE_MUTEX(name) \ 3308 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3309 #define TMPBUFLEN (1024) 3310 #ifdef TTY_DONT_FLIP 3311 #endif 3312 /* LDV_COMMENT_END_PREP */ 3313 /* content: static void dgnc_tty_flush_buffer(struct tty_struct *tty)*/ 3314 /* LDV_COMMENT_BEGIN_PREP */ 3315 #define init_MUTEX(sem) sema_init(sem, 1) 3316 #define DECLARE_MUTEX(name) \ 3317 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3318 #define TMPBUFLEN (1024) 3319 #ifdef TTY_DONT_FLIP 3320 #endif 3321 /* LDV_COMMENT_END_PREP */ 3322 /* content: static int dgnc_tty_chars_in_buffer(struct tty_struct *tty)*/ 3323 /* LDV_COMMENT_BEGIN_PREP */ 3324 #define init_MUTEX(sem) sema_init(sem, 1) 3325 #define DECLARE_MUTEX(name) \ 3326 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3327 #define TMPBUFLEN (1024) 3328 #ifdef TTY_DONT_FLIP 3329 #endif 3330 /* LDV_COMMENT_END_PREP */ 3331 /* content: static void dgnc_tty_flush_chars(struct tty_struct *tty)*/ 3332 /* LDV_COMMENT_BEGIN_PREP */ 3333 #define init_MUTEX(sem) sema_init(sem, 1) 3334 #define DECLARE_MUTEX(name) \ 3335 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3336 #define TMPBUFLEN (1024) 3337 #ifdef TTY_DONT_FLIP 3338 #endif 3339 /* LDV_COMMENT_END_PREP */ 3340 /* content: static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)*/ 3341 /* LDV_COMMENT_BEGIN_PREP */ 3342 #define init_MUTEX(sem) sema_init(sem, 1) 3343 #define DECLARE_MUTEX(name) \ 3344 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3345 #define TMPBUFLEN (1024) 3346 #ifdef TTY_DONT_FLIP 3347 #endif 3348 /* LDV_COMMENT_END_PREP */ 3349 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_ioctl" */ 3350 unsigned int var_dgnc_tty_ioctl_38_p1; 3351 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_ioctl" */ 3352 unsigned long var_dgnc_tty_ioctl_38_p2; 3353 /* content: static void dgnc_tty_set_termios(struct tty_struct *tty, struct ktermios *old_termios)*/ 3354 /* LDV_COMMENT_BEGIN_PREP */ 3355 #define init_MUTEX(sem) sema_init(sem, 1) 3356 #define DECLARE_MUTEX(name) \ 3357 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3358 #define TMPBUFLEN (1024) 3359 #ifdef TTY_DONT_FLIP 3360 #endif 3361 /* LDV_COMMENT_END_PREP */ 3362 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_set_termios" */ 3363 struct ktermios * var_group3; 3364 /* content: static void dgnc_tty_stop(struct tty_struct *tty)*/ 3365 /* LDV_COMMENT_BEGIN_PREP */ 3366 #define init_MUTEX(sem) sema_init(sem, 1) 3367 #define DECLARE_MUTEX(name) \ 3368 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3369 #define TMPBUFLEN (1024) 3370 #ifdef TTY_DONT_FLIP 3371 #endif 3372 /* LDV_COMMENT_END_PREP */ 3373 /* content: static void dgnc_tty_start(struct tty_struct *tty)*/ 3374 /* LDV_COMMENT_BEGIN_PREP */ 3375 #define init_MUTEX(sem) sema_init(sem, 1) 3376 #define DECLARE_MUTEX(name) \ 3377 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3378 #define TMPBUFLEN (1024) 3379 #ifdef TTY_DONT_FLIP 3380 #endif 3381 /* LDV_COMMENT_END_PREP */ 3382 /* content: static void dgnc_tty_throttle(struct tty_struct *tty)*/ 3383 /* LDV_COMMENT_BEGIN_PREP */ 3384 #define init_MUTEX(sem) sema_init(sem, 1) 3385 #define DECLARE_MUTEX(name) \ 3386 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3387 #define TMPBUFLEN (1024) 3388 #ifdef TTY_DONT_FLIP 3389 #endif 3390 /* LDV_COMMENT_END_PREP */ 3391 /* content: static void dgnc_tty_unthrottle(struct tty_struct *tty)*/ 3392 /* LDV_COMMENT_BEGIN_PREP */ 3393 #define init_MUTEX(sem) sema_init(sem, 1) 3394 #define DECLARE_MUTEX(name) \ 3395 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3396 #define TMPBUFLEN (1024) 3397 #ifdef TTY_DONT_FLIP 3398 #endif 3399 /* LDV_COMMENT_END_PREP */ 3400 /* content: static void dgnc_tty_hangup(struct tty_struct *tty)*/ 3401 /* LDV_COMMENT_BEGIN_PREP */ 3402 #define init_MUTEX(sem) sema_init(sem, 1) 3403 #define DECLARE_MUTEX(name) \ 3404 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3405 #define TMPBUFLEN (1024) 3406 #ifdef TTY_DONT_FLIP 3407 #endif 3408 /* LDV_COMMENT_END_PREP */ 3409 /* content: static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c)*/ 3410 /* LDV_COMMENT_BEGIN_PREP */ 3411 #define init_MUTEX(sem) sema_init(sem, 1) 3412 #define DECLARE_MUTEX(name) \ 3413 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3414 #define TMPBUFLEN (1024) 3415 #ifdef TTY_DONT_FLIP 3416 #endif 3417 /* LDV_COMMENT_END_PREP */ 3418 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_put_char" */ 3419 unsigned char var_dgnc_tty_put_char_19_p1; 3420 /* content: static int dgnc_tty_tiocmget(struct tty_struct *tty)*/ 3421 /* LDV_COMMENT_BEGIN_PREP */ 3422 #define init_MUTEX(sem) sema_init(sem, 1) 3423 #define DECLARE_MUTEX(name) \ 3424 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3425 #define TMPBUFLEN (1024) 3426 #ifdef TTY_DONT_FLIP 3427 #endif 3428 /* LDV_COMMENT_END_PREP */ 3429 /* content: static int dgnc_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)*/ 3430 /* LDV_COMMENT_BEGIN_PREP */ 3431 #define init_MUTEX(sem) sema_init(sem, 1) 3432 #define DECLARE_MUTEX(name) \ 3433 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3434 #define TMPBUFLEN (1024) 3435 #ifdef TTY_DONT_FLIP 3436 #endif 3437 /* LDV_COMMENT_END_PREP */ 3438 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_tiocmset" */ 3439 unsigned int var_dgnc_tty_tiocmset_22_p1; 3440 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_tiocmset" */ 3441 unsigned int var_dgnc_tty_tiocmset_22_p2; 3442 /* content: static int dgnc_tty_send_break(struct tty_struct *tty, int msec)*/ 3443 /* LDV_COMMENT_BEGIN_PREP */ 3444 #define init_MUTEX(sem) sema_init(sem, 1) 3445 #define DECLARE_MUTEX(name) \ 3446 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3447 #define TMPBUFLEN (1024) 3448 #ifdef TTY_DONT_FLIP 3449 #endif 3450 /* LDV_COMMENT_END_PREP */ 3451 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_send_break" */ 3452 int var_dgnc_tty_send_break_23_p1; 3453 /* content: static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout)*/ 3454 /* LDV_COMMENT_BEGIN_PREP */ 3455 #define init_MUTEX(sem) sema_init(sem, 1) 3456 #define DECLARE_MUTEX(name) \ 3457 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3458 #define TMPBUFLEN (1024) 3459 #ifdef TTY_DONT_FLIP 3460 #endif 3461 /* LDV_COMMENT_END_PREP */ 3462 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_wait_until_sent" */ 3463 int var_dgnc_tty_wait_until_sent_24_p1; 3464 /* content: static void dgnc_tty_send_xchar(struct tty_struct *tty, char c)*/ 3465 /* LDV_COMMENT_BEGIN_PREP */ 3466 #define init_MUTEX(sem) sema_init(sem, 1) 3467 #define DECLARE_MUTEX(name) \ 3468 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3469 #define TMPBUFLEN (1024) 3470 #ifdef TTY_DONT_FLIP 3471 #endif 3472 /* LDV_COMMENT_END_PREP */ 3473 /* LDV_COMMENT_VAR_DECLARE Variable declaration for function "dgnc_tty_send_xchar" */ 3474 char var_dgnc_tty_send_xchar_25_p1; 3475 3476 3477 3478 3479 /* LDV_COMMENT_END_VARIABLE_DECLARATION_PART */ 3480 /* LDV_COMMENT_BEGIN_VARIABLE_INITIALIZING_PART */ 3481 /*============================= VARIABLE INITIALIZING PART =============================*/ 3482 LDV_IN_INTERRUPT=1; 3483 3484 3485 3486 3487 /* LDV_COMMENT_END_VARIABLE_INITIALIZING_PART */ 3488 /* LDV_COMMENT_BEGIN_FUNCTION_CALL_SECTION */ 3489 /*============================= FUNCTION CALL SECTION =============================*/ 3490 /* LDV_COMMENT_FUNCTION_CALL Initialize LDV model. */ 3491 ldv_initialize(); 3492 int ldv_s_dgnc_tty_ops_tty_operations = 0; 3493 3494 3495 3496 while( nondet_int() 3497 || !(ldv_s_dgnc_tty_ops_tty_operations == 0) 3498 ) { 3499 3500 switch(nondet_int()) { 3501 3502 case 0: { 3503 3504 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3505 if(ldv_s_dgnc_tty_ops_tty_operations==0) { 3506 3507 /* content: static int dgnc_tty_open(struct tty_struct *tty, struct file *file)*/ 3508 /* LDV_COMMENT_BEGIN_PREP */ 3509 #define init_MUTEX(sem) sema_init(sem, 1) 3510 #define DECLARE_MUTEX(name) \ 3511 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3512 #define TMPBUFLEN (1024) 3513 #ifdef TTY_DONT_FLIP 3514 #endif 3515 /* LDV_COMMENT_END_PREP */ 3516 /* LDV_COMMENT_FUNCTION_CALL Function from field "open" from driver structure with callbacks "dgnc_tty_ops". Standart function test for correct return result. */ 3517 ldv_handler_precall(); 3518 res_dgnc_tty_open_12 = dgnc_tty_open( var_group1, var_group2); 3519 ldv_check_return_value(res_dgnc_tty_open_12); 3520 if(res_dgnc_tty_open_12) 3521 goto ldv_module_exit; 3522 ldv_s_dgnc_tty_ops_tty_operations++; 3523 3524 } 3525 3526 } 3527 3528 break; 3529 case 1: { 3530 3531 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3532 if(ldv_s_dgnc_tty_ops_tty_operations==1) { 3533 3534 /* content: static void dgnc_tty_close(struct tty_struct *tty, struct file *file)*/ 3535 /* LDV_COMMENT_BEGIN_PREP */ 3536 #define init_MUTEX(sem) sema_init(sem, 1) 3537 #define DECLARE_MUTEX(name) \ 3538 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3539 #define TMPBUFLEN (1024) 3540 #ifdef TTY_DONT_FLIP 3541 #endif 3542 /* LDV_COMMENT_END_PREP */ 3543 /* LDV_COMMENT_FUNCTION_CALL Function from field "close" from driver structure with callbacks "dgnc_tty_ops" */ 3544 ldv_handler_precall(); 3545 dgnc_tty_close( var_group1, var_group2); 3546 ldv_s_dgnc_tty_ops_tty_operations=0; 3547 3548 } 3549 3550 } 3551 3552 break; 3553 case 2: { 3554 3555 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3556 3557 3558 /* content: static int dgnc_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)*/ 3559 /* LDV_COMMENT_BEGIN_PREP */ 3560 #define init_MUTEX(sem) sema_init(sem, 1) 3561 #define DECLARE_MUTEX(name) \ 3562 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3563 #define TMPBUFLEN (1024) 3564 #ifdef TTY_DONT_FLIP 3565 #endif 3566 /* LDV_COMMENT_END_PREP */ 3567 /* LDV_COMMENT_FUNCTION_CALL Function from field "write" from driver structure with callbacks "dgnc_tty_ops" */ 3568 ldv_handler_precall(); 3569 dgnc_tty_write( var_group1, var_dgnc_tty_write_20_p1, var_dgnc_tty_write_20_p2); 3570 3571 3572 3573 3574 } 3575 3576 break; 3577 case 3: { 3578 3579 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3580 3581 3582 /* content: static int dgnc_tty_write_room(struct tty_struct *tty)*/ 3583 /* LDV_COMMENT_BEGIN_PREP */ 3584 #define init_MUTEX(sem) sema_init(sem, 1) 3585 #define DECLARE_MUTEX(name) \ 3586 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3587 #define TMPBUFLEN (1024) 3588 #ifdef TTY_DONT_FLIP 3589 #endif 3590 /* LDV_COMMENT_END_PREP */ 3591 /* LDV_COMMENT_FUNCTION_CALL Function from field "write_room" from driver structure with callbacks "dgnc_tty_ops" */ 3592 ldv_handler_precall(); 3593 dgnc_tty_write_room( var_group1); 3594 3595 3596 3597 3598 } 3599 3600 break; 3601 case 4: { 3602 3603 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3604 3605 3606 /* content: static void dgnc_tty_flush_buffer(struct tty_struct *tty)*/ 3607 /* LDV_COMMENT_BEGIN_PREP */ 3608 #define init_MUTEX(sem) sema_init(sem, 1) 3609 #define DECLARE_MUTEX(name) \ 3610 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3611 #define TMPBUFLEN (1024) 3612 #ifdef TTY_DONT_FLIP 3613 #endif 3614 /* LDV_COMMENT_END_PREP */ 3615 /* LDV_COMMENT_FUNCTION_CALL Function from field "flush_buffer" from driver structure with callbacks "dgnc_tty_ops" */ 3616 ldv_handler_precall(); 3617 dgnc_tty_flush_buffer( var_group1); 3618 3619 3620 3621 3622 } 3623 3624 break; 3625 case 5: { 3626 3627 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3628 3629 3630 /* content: static int dgnc_tty_chars_in_buffer(struct tty_struct *tty)*/ 3631 /* LDV_COMMENT_BEGIN_PREP */ 3632 #define init_MUTEX(sem) sema_init(sem, 1) 3633 #define DECLARE_MUTEX(name) \ 3634 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3635 #define TMPBUFLEN (1024) 3636 #ifdef TTY_DONT_FLIP 3637 #endif 3638 /* LDV_COMMENT_END_PREP */ 3639 /* LDV_COMMENT_FUNCTION_CALL Function from field "chars_in_buffer" from driver structure with callbacks "dgnc_tty_ops" */ 3640 ldv_handler_precall(); 3641 dgnc_tty_chars_in_buffer( var_group1); 3642 3643 3644 3645 3646 } 3647 3648 break; 3649 case 6: { 3650 3651 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3652 3653 3654 /* content: static void dgnc_tty_flush_chars(struct tty_struct *tty)*/ 3655 /* LDV_COMMENT_BEGIN_PREP */ 3656 #define init_MUTEX(sem) sema_init(sem, 1) 3657 #define DECLARE_MUTEX(name) \ 3658 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3659 #define TMPBUFLEN (1024) 3660 #ifdef TTY_DONT_FLIP 3661 #endif 3662 /* LDV_COMMENT_END_PREP */ 3663 /* LDV_COMMENT_FUNCTION_CALL Function from field "flush_chars" from driver structure with callbacks "dgnc_tty_ops" */ 3664 ldv_handler_precall(); 3665 dgnc_tty_flush_chars( var_group1); 3666 3667 3668 3669 3670 } 3671 3672 break; 3673 case 7: { 3674 3675 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3676 3677 3678 /* content: static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)*/ 3679 /* LDV_COMMENT_BEGIN_PREP */ 3680 #define init_MUTEX(sem) sema_init(sem, 1) 3681 #define DECLARE_MUTEX(name) \ 3682 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3683 #define TMPBUFLEN (1024) 3684 #ifdef TTY_DONT_FLIP 3685 #endif 3686 /* LDV_COMMENT_END_PREP */ 3687 /* LDV_COMMENT_FUNCTION_CALL Function from field "ioctl" from driver structure with callbacks "dgnc_tty_ops" */ 3688 ldv_handler_precall(); 3689 dgnc_tty_ioctl( var_group1, var_dgnc_tty_ioctl_38_p1, var_dgnc_tty_ioctl_38_p2); 3690 3691 3692 3693 3694 } 3695 3696 break; 3697 case 8: { 3698 3699 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3700 3701 3702 /* content: static void dgnc_tty_set_termios(struct tty_struct *tty, struct ktermios *old_termios)*/ 3703 /* LDV_COMMENT_BEGIN_PREP */ 3704 #define init_MUTEX(sem) sema_init(sem, 1) 3705 #define DECLARE_MUTEX(name) \ 3706 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3707 #define TMPBUFLEN (1024) 3708 #ifdef TTY_DONT_FLIP 3709 #endif 3710 /* LDV_COMMENT_END_PREP */ 3711 /* LDV_COMMENT_FUNCTION_CALL Function from field "set_termios" from driver structure with callbacks "dgnc_tty_ops" */ 3712 ldv_handler_precall(); 3713 dgnc_tty_set_termios( var_group1, var_group3); 3714 3715 3716 3717 3718 } 3719 3720 break; 3721 case 9: { 3722 3723 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3724 3725 3726 /* content: static void dgnc_tty_stop(struct tty_struct *tty)*/ 3727 /* LDV_COMMENT_BEGIN_PREP */ 3728 #define init_MUTEX(sem) sema_init(sem, 1) 3729 #define DECLARE_MUTEX(name) \ 3730 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3731 #define TMPBUFLEN (1024) 3732 #ifdef TTY_DONT_FLIP 3733 #endif 3734 /* LDV_COMMENT_END_PREP */ 3735 /* LDV_COMMENT_FUNCTION_CALL Function from field "stop" from driver structure with callbacks "dgnc_tty_ops" */ 3736 ldv_handler_precall(); 3737 dgnc_tty_stop( var_group1); 3738 3739 3740 3741 3742 } 3743 3744 break; 3745 case 10: { 3746 3747 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3748 3749 3750 /* content: static void dgnc_tty_start(struct tty_struct *tty)*/ 3751 /* LDV_COMMENT_BEGIN_PREP */ 3752 #define init_MUTEX(sem) sema_init(sem, 1) 3753 #define DECLARE_MUTEX(name) \ 3754 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3755 #define TMPBUFLEN (1024) 3756 #ifdef TTY_DONT_FLIP 3757 #endif 3758 /* LDV_COMMENT_END_PREP */ 3759 /* LDV_COMMENT_FUNCTION_CALL Function from field "start" from driver structure with callbacks "dgnc_tty_ops" */ 3760 ldv_handler_precall(); 3761 dgnc_tty_start( var_group1); 3762 3763 3764 3765 3766 } 3767 3768 break; 3769 case 11: { 3770 3771 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3772 3773 3774 /* content: static void dgnc_tty_throttle(struct tty_struct *tty)*/ 3775 /* LDV_COMMENT_BEGIN_PREP */ 3776 #define init_MUTEX(sem) sema_init(sem, 1) 3777 #define DECLARE_MUTEX(name) \ 3778 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3779 #define TMPBUFLEN (1024) 3780 #ifdef TTY_DONT_FLIP 3781 #endif 3782 /* LDV_COMMENT_END_PREP */ 3783 /* LDV_COMMENT_FUNCTION_CALL Function from field "throttle" from driver structure with callbacks "dgnc_tty_ops" */ 3784 ldv_handler_precall(); 3785 dgnc_tty_throttle( var_group1); 3786 3787 3788 3789 3790 } 3791 3792 break; 3793 case 12: { 3794 3795 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3796 3797 3798 /* content: static void dgnc_tty_unthrottle(struct tty_struct *tty)*/ 3799 /* LDV_COMMENT_BEGIN_PREP */ 3800 #define init_MUTEX(sem) sema_init(sem, 1) 3801 #define DECLARE_MUTEX(name) \ 3802 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3803 #define TMPBUFLEN (1024) 3804 #ifdef TTY_DONT_FLIP 3805 #endif 3806 /* LDV_COMMENT_END_PREP */ 3807 /* LDV_COMMENT_FUNCTION_CALL Function from field "unthrottle" from driver structure with callbacks "dgnc_tty_ops" */ 3808 ldv_handler_precall(); 3809 dgnc_tty_unthrottle( var_group1); 3810 3811 3812 3813 3814 } 3815 3816 break; 3817 case 13: { 3818 3819 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3820 3821 3822 /* content: static void dgnc_tty_hangup(struct tty_struct *tty)*/ 3823 /* LDV_COMMENT_BEGIN_PREP */ 3824 #define init_MUTEX(sem) sema_init(sem, 1) 3825 #define DECLARE_MUTEX(name) \ 3826 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3827 #define TMPBUFLEN (1024) 3828 #ifdef TTY_DONT_FLIP 3829 #endif 3830 /* LDV_COMMENT_END_PREP */ 3831 /* LDV_COMMENT_FUNCTION_CALL Function from field "hangup" from driver structure with callbacks "dgnc_tty_ops" */ 3832 ldv_handler_precall(); 3833 dgnc_tty_hangup( var_group1); 3834 3835 3836 3837 3838 } 3839 3840 break; 3841 case 14: { 3842 3843 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3844 3845 3846 /* content: static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c)*/ 3847 /* LDV_COMMENT_BEGIN_PREP */ 3848 #define init_MUTEX(sem) sema_init(sem, 1) 3849 #define DECLARE_MUTEX(name) \ 3850 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3851 #define TMPBUFLEN (1024) 3852 #ifdef TTY_DONT_FLIP 3853 #endif 3854 /* LDV_COMMENT_END_PREP */ 3855 /* LDV_COMMENT_FUNCTION_CALL Function from field "put_char" from driver structure with callbacks "dgnc_tty_ops" */ 3856 ldv_handler_precall(); 3857 dgnc_tty_put_char( var_group1, var_dgnc_tty_put_char_19_p1); 3858 3859 3860 3861 3862 } 3863 3864 break; 3865 case 15: { 3866 3867 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3868 3869 3870 /* content: static int dgnc_tty_tiocmget(struct tty_struct *tty)*/ 3871 /* LDV_COMMENT_BEGIN_PREP */ 3872 #define init_MUTEX(sem) sema_init(sem, 1) 3873 #define DECLARE_MUTEX(name) \ 3874 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3875 #define TMPBUFLEN (1024) 3876 #ifdef TTY_DONT_FLIP 3877 #endif 3878 /* LDV_COMMENT_END_PREP */ 3879 /* LDV_COMMENT_FUNCTION_CALL Function from field "tiocmget" from driver structure with callbacks "dgnc_tty_ops" */ 3880 ldv_handler_precall(); 3881 dgnc_tty_tiocmget( var_group1); 3882 3883 3884 3885 3886 } 3887 3888 break; 3889 case 16: { 3890 3891 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3892 3893 3894 /* content: static int dgnc_tty_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)*/ 3895 /* LDV_COMMENT_BEGIN_PREP */ 3896 #define init_MUTEX(sem) sema_init(sem, 1) 3897 #define DECLARE_MUTEX(name) \ 3898 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3899 #define TMPBUFLEN (1024) 3900 #ifdef TTY_DONT_FLIP 3901 #endif 3902 /* LDV_COMMENT_END_PREP */ 3903 /* LDV_COMMENT_FUNCTION_CALL Function from field "tiocmset" from driver structure with callbacks "dgnc_tty_ops" */ 3904 ldv_handler_precall(); 3905 dgnc_tty_tiocmset( var_group1, var_dgnc_tty_tiocmset_22_p1, var_dgnc_tty_tiocmset_22_p2); 3906 3907 3908 3909 3910 } 3911 3912 break; 3913 case 17: { 3914 3915 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3916 3917 3918 /* content: static int dgnc_tty_send_break(struct tty_struct *tty, int msec)*/ 3919 /* LDV_COMMENT_BEGIN_PREP */ 3920 #define init_MUTEX(sem) sema_init(sem, 1) 3921 #define DECLARE_MUTEX(name) \ 3922 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3923 #define TMPBUFLEN (1024) 3924 #ifdef TTY_DONT_FLIP 3925 #endif 3926 /* LDV_COMMENT_END_PREP */ 3927 /* LDV_COMMENT_FUNCTION_CALL Function from field "break_ctl" from driver structure with callbacks "dgnc_tty_ops" */ 3928 ldv_handler_precall(); 3929 dgnc_tty_send_break( var_group1, var_dgnc_tty_send_break_23_p1); 3930 3931 3932 3933 3934 } 3935 3936 break; 3937 case 18: { 3938 3939 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3940 3941 3942 /* content: static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout)*/ 3943 /* LDV_COMMENT_BEGIN_PREP */ 3944 #define init_MUTEX(sem) sema_init(sem, 1) 3945 #define DECLARE_MUTEX(name) \ 3946 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3947 #define TMPBUFLEN (1024) 3948 #ifdef TTY_DONT_FLIP 3949 #endif 3950 /* LDV_COMMENT_END_PREP */ 3951 /* LDV_COMMENT_FUNCTION_CALL Function from field "wait_until_sent" from driver structure with callbacks "dgnc_tty_ops" */ 3952 ldv_handler_precall(); 3953 dgnc_tty_wait_until_sent( var_group1, var_dgnc_tty_wait_until_sent_24_p1); 3954 3955 3956 3957 3958 } 3959 3960 break; 3961 case 19: { 3962 3963 /** STRUCT: struct type: tty_operations, struct name: dgnc_tty_ops **/ 3964 3965 3966 /* content: static void dgnc_tty_send_xchar(struct tty_struct *tty, char c)*/ 3967 /* LDV_COMMENT_BEGIN_PREP */ 3968 #define init_MUTEX(sem) sema_init(sem, 1) 3969 #define DECLARE_MUTEX(name) \ 3970 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1) 3971 #define TMPBUFLEN (1024) 3972 #ifdef TTY_DONT_FLIP 3973 #endif 3974 /* LDV_COMMENT_END_PREP */ 3975 /* LDV_COMMENT_FUNCTION_CALL Function from field "send_xchar" from driver structure with callbacks "dgnc_tty_ops" */ 3976 ldv_handler_precall(); 3977 dgnc_tty_send_xchar( var_group1, var_dgnc_tty_send_xchar_25_p1); 3978 3979 3980 3981 3982 } 3983 3984 break; 3985 default: break; 3986 3987 } 3988 3989 } 3990 3991 ldv_module_exit: 3992 3993 /* LDV_COMMENT_FUNCTION_CALL Checks that all resources and locks are correctly released before the driver will be unloaded. */ 3994 ldv_final: ldv_check_final_state(); 3995 3996 /* LDV_COMMENT_END_FUNCTION_CALL_SECTION */ 3997 return; 3998 3999 } 4000 #endif 4001 4002 /* LDV_COMMENT_END_MAIN */