| blob | 170d6f3e42218214bf869e15163d253aa4c98a82 |
1 /*
2 * Copyright 2003 Digi International (www.digi.com)
3 * Scott H Kilau <Scott_Kilau at digi dot com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
12 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
13 * PURPOSE. See the GNU General Public License for more details.
14 *
15 */
17 /*
18 * In the original out of kernel Digi dgap driver, firmware
19 * loading was done via user land to driver handshaking.
20 *
21 * For cards that support a concentrator (port expander),
22 * I believe the concentrator its self told the card which
23 * concentrator is actually attached and then that info
24 * was used to tell user land which concentrator firmware
25 * image was to be downloaded. I think even the BIOS or
26 * FEP images required could change with the connection
27 * of a particular concentrator.
28 *
29 * Since I have no access to any of these cards or
30 * concentrators, I cannot put the correct concentrator
31 * firmware file names into the firmware_info structure
32 * as is now done for the BIOS and FEP images.
33 *
34 * I think, but am not certain, that the cards supporting
35 * concentrators will function without them. So support
36 * of these cards has been left in this driver.
37 *
38 * In order to fully support those cards, they would
39 * either have to be acquired for dissection or maybe
40 * Digi International could provide some assistance.
41 */
42 #undef DIGI_CONCENTRATORS_SUPPORTED
44 #include <linux/kernel.h>
45 #include <linux/module.h>
46 #include <linux/pci.h>
48 #include <linux/slab.h>
49 #include <linux/uaccess.h>
50 #include <linux/sched.h>
53 #include <linux/ctype.h>
54 #include <linux/tty.h>
55 #include <linux/tty_flip.h>
56 #include <linux/serial_reg.h>
59 #include <linux/string.h>
60 #include <linux/device.h>
61 #include <linux/kdev_t.h>
62 #include <linux/firmware.h>
131 /*
132 * Our function prototypes from dgap_fep5
133 */
148 /*
149 * Function prototypes from dgap_parse.c.
150 */
157 /*
158 * Function prototypes from dgap_sysfs.h
159 */
175 /*
176 * Function prototypes from dgap_parse.h
177 */
188 #ifdef DIGI_CONCENTRATORS_SUPPORTED
190 #endif
205 /*
206 * File operations permitted on Control/Management major.
207 */
210 };
225 /*
226 * Poller stuff
227 */
233 /*
234 SUPPORTED PRODUCTS
236 Card Model Number of Ports Interface
237 ----------------------------------------------------------------
238 Acceleport Xem 4 - 64 (EIA232 & EIA422)
239 Acceleport Xr 4 & 8 (EIA232)
240 Acceleport Xr 920 4 & 8 (EIA232)
241 Acceleport C/X 8 - 128 (EIA232)
242 Acceleport EPC/X 8 - 224 (EIA232)
243 Acceleport Xr/422 4 & 8 (EIA422)
244 Acceleport 2r/920 2 (EIA232)
245 Acceleport 4r/920 4 (EIA232)
246 Acceleport 8r/920 8 (EIA232)
248 IBM 8-Port Asynchronous PCI Adapter (EIA232)
249 IBM 128-Port Asynchronous PCI Adapter (EIA232 & EIA422)
250 */
269 };
272 /*
273 * A generic list of Product names, PCI Vendor ID, and PCI Device ID.
274 */
276 uint config_type;
278 uint maxports;
279 uint dpatype;
280 };
299 };
306 };
314 };
316 /*
317 * Firmware - BIOS, FEP, and CONC filenames
318 */
336 };
338 /*
339 * Default transparent print information.
340 */
351 };
353 /*
354 * Define a local default termios struct. All ports will be created
355 * with this termios initially.
356 *
357 * This defines a raw port at 9600 baud, 8 data bits, no parity,
358 * 1 stop bit.
359 */
368 };
391 };
393 /*
394 * Our needed internal static variables from dgap_parse.c
395 */
397 #define MAXCWORD 200
403 };
454 };
456 /************************************************************************
457 *
458 * Driver load/unload functions
459 *
460 ************************************************************************/
462 /*
463 * init_module()
464 *
465 * Module load. This is where it all starts.
466 */
468 {
489 err_cleanup:
494 }
497 /*
498 * Start of driver.
499 */
501 {
506 /*
507 * make sure that the globals are
508 * init'd before we do anything else
509 */
516 /*
517 * Register our base character device into the kernel.
518 */
520 /*
521 * Register management/dpa devices
522 */
531 }
539 }
541 /* Start the poller */
554 failed_device:
556 failed_class:
559 }
561 /*
562 * Register pci driver, and return how many boards we have.
563 */
565 {
567 }
570 {
584 dgap_numboards++;
586 }
589 {
591 }
594 {
595 /* Do Nothing */
596 }
598 /*
599 * dgap_cleanup_module()
600 *
601 * Module unload. This is where it all ends.
602 */
604 {
606 ulong lock_flags;
612 /* Turn off poller right away. */
625 }
629 }
631 /*
632 * dgap_cleanup_board()
633 *
634 * Free all the memory associated with a board
635 */
637 {
652 }
658 }
660 /* Free all allocated channels structs */
670 }
672 /*
673 * dgap_found_board()
674 *
675 * A board has been found, init it.
676 */
678 {
683 /* get the board structure and prep it */
690 /* store the info for the board we've found */
716 /* store which card & revision we have */
724 /* get the PCI Base Address Registers */
726 /* Xr Jupiter and EPC use BAR 2 */
730 }
731 /* Everyone else uses BAR 0 */
735 }
742 else
745 /*
746 * On the PCI boards, there is no IO space allocated
747 * The I/O registers will be in the first 3 bytes of the
748 * upper 2MB of the 4MB memory space. The board memory
749 * will be mapped into the low 2MB of the 4MB memory space
750 */
754 /*
755 * Special initialization for non-PLX boards
756 */
763 /* Limit burst length to 2 doubleword transactions */
766 /*
767 * Enable IO and mem if not already done.
768 * This was needed for support on Itanium.
769 */
773 }
775 /* init our poll helper tasklet */
787 }
791 {
799 /*
800 * Set up our interrupt handler if we are set to do interrupts.
801 */
808 else
812 }
815 }
818 {
834 }
840 }
845 /*
846 * preserve dgap_config_buf
847 * as dgap_parsefile would
848 * otherwise alter it.
849 */
855 }
857 }
862 /*
863 * Match this board to a config the user created for us.
864 */
868 /*
869 * Because the 4 port Xr products share the same PCI ID
870 * as the 8 port Xr products, if we receive a NULL config
871 * back, and this is a PAPORT8 board, retry with a
872 * PAPORT4 attempt as well.
873 */
881 }
898 }
902 /* Wait for BIOS to test board... */
906 }
915 }
919 /* Wait for FEP to load on board... */
923 }
925 #ifdef DIGI_CONCENTRATORS_SUPPORTED
926 /*
927 * If this is a CX or EPCX, we need to see if the firmware
928 * is requesting a concentrator image from us.
929 */
932 /* Nonzero if FEP is requesting concentrator image. */
935 }
944 }
945 /* Put concentrator firmware loading code here */
951 }
952 #endif
953 /*
954 * Do tty device initialization.
955 */
960 }
970 }
972 /*
973 * Remap PCI memory.
974 */
976 {
987 }
994 }
1002 }
1005 }
1007 /*****************************************************************************
1008 *
1009 * Function:
1010 *
1011 * dgap_poll_handler
1012 *
1013 * Author:
1014 *
1015 * Scott H Kilau
1016 *
1017 * Parameters:
1018 *
1019 * dummy -- ignored
1020 *
1021 * Return Values:
1022 *
1023 * none
1024 *
1025 * Description:
1026 *
1027 * As each timer expires, it determines (a) whether the "transmit"
1028 * waiter needs to be woken up, and (b) whether the poller needs to
1029 * be rescheduled.
1030 *
1031 ******************************************************************************/
1034 {
1038 ulong new_time;
1040 dgap_poll_counter++;
1042 /*
1043 * Do not start the board state machine until
1044 * driver tells us its up and running, and has
1045 * everything it needs.
1046 */
1050 /*
1051 * If we have just 1 board, or the system is not SMP,
1052 * then use the typical old style poller.
1053 * Otherwise, use our new tasklet based poller, which should
1054 * speed things up for multiple boards.
1055 */
1064 /* Call the real board poller directly */
1066 }
1068 /*
1069 * Go thru each board, kicking off a
1070 * tasklet for each if needed
1071 */
1075 /*
1076 * Attempt to grab the board lock.
1077 *
1078 * If we can't get it, no big deal, the next poll
1079 * will get it. Basically, I just really don't want
1080 * to spin in here, because I want to kick off my
1081 * tasklets as fast as I can, and then get out the
1082 * poller.
1083 */
1087 /*
1088 * If board is in a failed state, don't bother
1089 * scheduling a tasklet
1090 */
1094 }
1096 /* Schedule a poll helper task */
1100 /*
1101 * Can't do DGAP_UNLOCK here, as we don't have
1102 * lock_flags because we did a trylock above.
1103 */
1105 }
1106 }
1108 schedule_poller:
1110 /*
1111 * Schedule ourself back at the nominal wakeup interval.
1112 */
1119 dgap_poll_time =
1121 }
1130 }
1132 /*
1133 * dgap_intr()
1134 *
1135 * Driver interrupt handler.
1136 */
1138 {
1144 /*
1145 * Check to make sure its for us.
1146 */
1152 /*
1153 * Schedule tasklet to run at a better time.
1154 */
1157 }
1159 /*
1160 * dgap_init_globals()
1161 *
1162 * This is where we initialize the globals from the static insmod
1163 * configuration variables. These are declared near the head of
1164 * this file.
1165 */
1167 {
1176 }
1178 /************************************************************************
1179 *
1180 * Utility functions
1181 *
1182 ************************************************************************/
1184 /*
1185 * dgap_ms_sleep()
1186 *
1187 * Put the driver to sleep for x ms's
1188 *
1189 * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
1190 */
1192 {
1196 }
1198 /************************************************************************
1199 *
1200 * TTY Initialization/Cleanup Functions
1201 *
1202 ************************************************************************/
1204 /*
1205 * dgap_tty_register()
1206 *
1207 * Init the tty subsystem for this board.
1208 */
1210 {
1228 TTY_DRIVER_DYNAMIC_DEV |
1229 TTY_DRIVER_HARDWARE_BREAK);
1231 /* The kernel wants space to store pointers to tty_structs */
1237 }
1239 /*
1240 * Entry points for driver. Called by the kernel from
1241 * tty_io.c and n_tty.c.
1242 */
1245 /*
1246 * If we're doing transparent print, we have to do all of the above
1247 * again, separately so we don't get the LD confused about what major
1248 * we are when we get into the dgap_tty_open() routine.
1249 */
1254 }
1267 TTY_DRIVER_DYNAMIC_DEV |
1268 TTY_DRIVER_HARDWARE_BREAK);
1270 /* The kernel wants space to store pointers to tty_structs */
1276 }
1278 /*
1279 * Entry points for driver. Called by the kernel from
1280 * tty_io.c and n_tty.c.
1281 */
1284 /* Register tty devices */
1289 /* Register Transparent Print devices */
1304 unregister_serial_drv:
1306 free_print_drv:
1308 free_serial_drv:
1312 }
1314 /*
1315 * dgap_tty_init()
1316 *
1317 * Init the tty subsystem. Called once per board after board has been
1318 * downloaded and init'ed.
1319 */
1321 {
1324 uint true_count;
1326 u8 modem;
1334 /*
1335 * Initialize board structure elements.
1336 */
1366 /* If no ports, don't bother going any further */
1371 }
1372 }
1374 /*
1375 * Allocate channel memory that might not have been allocated
1376 * when the driver was first loaded.
1377 */
1384 }
1385 }
1395 /* Set up channel variables */
1403 /* Store all our magic numbers */
1422 /*
1423 * Set up digi dsr and dcd bits based on altpin flag.
1424 */
1432 }
1443 /* .25 second delay */
1446 /*
1447 * Set queue water marks, interrupt mask,
1448 * and general tty parameters.
1449 */
1466 /* Turn on all modem interrupts for now */
1470 /*
1471 * Set edelay to 0 if interrupts are turned on,
1472 * otherwise set edelay to the usual 100.
1473 */
1476 else
1480 }
1483 }
1485 /*
1486 * dgap_tty_uninit()
1487 *
1488 * Uninitialize the TTY portion of this driver. Free all memory and
1489 * resources.
1490 */
1492 {
1504 }
1509 }
1519 }
1524 }
1525 }
1527 /*=======================================================================
1528 *
1529 * dgap_input - Process received data.
1530 *
1531 * ch - Pointer to channel structure.
1532 *
1533 *=======================================================================*/
1536 {
1541 uint rmask;
1542 uint head;
1543 uint tail;
1545 ulong lock_flags;
1546 ulong lock_flags2;
1551 u8 tmpchar;
1570 /*
1571 * Figure the number of characters in the buffer.
1572 * Exit immediately if none.
1573 */
1589 }
1591 /*
1592 * If the device is not open, or CREAD is off, flush
1593 * input data and return immediately.
1594 */
1606 }
1608 /*
1609 * If we are throttled, simply don't read any data.
1610 */
1616 }
1618 /*
1619 * Ignore oruns.
1620 */
1625 }
1627 /* Decide how much data we can send into the tty layer */
1630 /* Chop down the length, if needed */
1636 #ifdef TTY_DONT_FLIP
1637 /*
1638 * If the DONT_FLIP flag is on, don't flush our buffer, and act
1639 * like the ld doesn't have any space to put the data right now.
1640 */
1643 #endif
1645 /*
1646 * If we were unable to get a reference to the ld,
1647 * don't flush our buffer, and act like the ld doesn't
1648 * have any space to put the data right now.
1649 */
1653 /*
1654 * If ld doesn't have a pointer to a receive_buf function,
1655 * flush the data, then act like the ld doesn't have any
1656 * space to put the data right now.
1657 */
1661 }
1662 }
1671 }
1676 /*
1677 * n now contains the most amount of data we can copy,
1678 * bounded either by our buffer size or the amount
1679 * of data the card actually has pending...
1680 */
1695 /* Flip queue if needed */
1697 }
1703 /*
1704 * If we are completely raw, we don't need to go through a lot
1705 * of the tty layers that exist.
1706 * In this case, we take the shortest and fastest route we
1707 * can to relay the data to the user.
1708 *
1709 * On the other hand, if we are not raw, we need to go through
1710 * the tty layer, which has its API more well defined.
1711 */
1722 }
1727 /* Tell the tty layer its okay to "eat" the data now */
1733 }
1735 /************************************************************************
1736 * Determines when CARRIER changes state and takes appropriate
1737 * action.
1738 ************************************************************************/
1740 {
1754 /* Make sure altpin is always set correctly */
1761 }
1772 /*
1773 * Test for a VIRTUAL carrier transition to HIGH.
1774 */
1777 /*
1778 * When carrier rises, wake any threads waiting
1779 * for carrier in the open routine.
1780 */
1784 }
1786 /*
1787 * Test for a PHYSICAL carrier transition to HIGH.
1788 */
1791 /*
1792 * When carrier rises, wake any threads waiting
1793 * for carrier in the open routine.
1794 */
1798 }
1800 /*
1801 * Test for a PHYSICAL transition to low, so long as we aren't
1802 * currently ignoring physical transitions (which is what "virtual
1803 * carrier" indicates).
1804 *
1805 * The transition of the virtual carrier to low really doesn't
1806 * matter... it really only means "ignore carrier state", not
1807 * "make pretend that carrier is there".
1808 */
1813 /*
1814 * When carrier drops:
1815 *
1816 * Drop carrier on all open units.
1817 *
1818 * Flush queues, waking up any task waiting in the
1819 * line discipline.
1820 *
1821 * Send a hangup to the control terminal.
1822 *
1823 * Enable all select calls.
1824 */
1833 }
1835 /*
1836 * Make sure that our cached values reflect the current reality.
1837 */
1840 else
1845 else
1847 }
1849 /************************************************************************
1850 *
1851 * TTY Entry points and helper functions
1852 *
1853 ************************************************************************/
1855 /*
1856 * dgap_tty_open()
1857 *
1858 */
1860 {
1865 uint major;
1866 uint minor;
1868 ulong lock_flags;
1869 ulong lock_flags2;
1870 u16 head;
1878 /* Get board pointer from our array of majors we have allocated */
1883 /*
1884 * If board is not yet up to a state of READY, go to
1885 * sleep waiting for it to happen or they cancel the open.
1886 */
1895 /* The wait above should guarantee this cannot happen */
1899 }
1901 /* If opened device is greater than our number of ports, bail. */
1905 }
1911 }
1913 /* Grab channel lock */
1916 /* Figure out our type */
1927 }
1929 /* Store our unit into driver_data, so we always have it available. */
1932 /*
1933 * Error if channel info pointer is NULL.
1934 */
1940 }
1942 /*
1943 * Initialize tty's
1944 */
1946 /* Store important variables. */
1949 /* Maybe do something here to the TTY struct as well? */
1950 }
1952 /*
1953 * Initialize if neither terminal or printer is open.
1954 */
1960 /*
1961 * Flush input queue.
1962 */
1977 /* TODO: flush our TTY struct here? */
1978 }
1981 /*
1982 * Run param in case we changed anything
1983 */
1986 /*
1987 * follow protocol for opening port
1988 */
1998 /* No going back now, increment our unit and channel counters */
2006 }
2008 /*
2009 * dgap_block_til_ready()
2010 *
2011 * Wait for DCD, if needed.
2012 */
2015 {
2018 ulong lock_flags;
2019 uint old_flags;
2034 /* Loop forever */
2039 /*
2040 * If board has failed somehow during our sleep,
2041 * bail with error.
2042 */
2046 }
2048 /* If tty was hung up, break out of loop and set error. */
2052 }
2054 /*
2055 * If either unit is in the middle of the fragile part of close,
2056 * we just cannot touch the channel safely.
2057 * Go back to sleep, knowing that when the channel can be
2058 * touched safely, the close routine will signal the
2059 * ch_wait_flags to wake us back up.
2060 */
2062 UN_CLOSING)) {
2064 /*
2065 * Our conditions to leave cleanly and happily:
2066 * 1) NONBLOCKING on the tty is set.
2067 * 2) CLOCAL is set.
2068 * 3) DCD (fake or real) is active.
2069 */
2084 }
2086 /*
2087 * If there is a signal pending, the user probably
2088 * interrupted (ctrl-c) us.
2089 * Leave loop with error set.
2090 */
2094 }
2096 /*
2097 * Store the flags before we let go of channel lock
2098 */
2101 else
2104 /*
2105 * Let go of channel lock before calling schedule.
2106 * Our poller will get any FEP events and wake us up when DCD
2107 * eventually goes active.
2108 */
2112 /*
2113 * Wait for something in the flags to change
2114 * from the current value.
2115 */
2123 }
2125 /*
2126 * We got woken up for some reason.
2127 * Before looping around, grab our channel lock.
2128 */
2130 }
2140 }
2142 /*
2143 * dgap_tty_hangup()
2144 *
2145 * Hangup the port. Like a close, but don't wait for output to drain.
2146 */
2148 {
2168 /* flush the transmit queues */
2170 }
2172 /*
2173 * dgap_tty_close()
2174 *
2175 */
2177 {
2182 ulong lock_flags;
2203 /*
2204 * Determine if this is the last close or not - and if we agree about
2205 * which type of close it is with the Line Discipline
2206 */
2208 /*
2209 * Uh, oh. tty->count is 1, which means that the tty
2210 * structure will be freed. un_open_count should always
2211 * be one in these conditions. If it's greater than
2212 * one, we've got real problems, since it means the
2213 * serial port won't be shutdown.
2214 */
2216 }
2226 }
2228 /* OK, its the last close on the unit */
2234 /*
2235 * Only officially close channel if count is 0 and
2236 * DIGI_PRINTER bit is not set.
2237 */
2245 /* wait for output to drain */
2246 /* This will also return if we take an interrupt */
2257 /*
2258 * If we have HUPCL set, lower DTR and RTS
2259 */
2264 /*
2265 * Go to sleep to ensure RTS/DTR
2266 * have been dropped for modems to see it.
2267 */
2270 lock_flags);
2273 }
2274 }
2280 }
2282 /*
2283 * turn off print device when closing print device.
2284 */
2289 }
2299 }
2301 /*
2302 * dgap_tty_chars_in_buffer()
2303 *
2304 * Return number of characters that have not been transmitted yet.
2305 *
2306 * This routine is used by the line discipline to determine if there
2307 * is data waiting to be transmitted/drained/flushed or not.
2308 */
2310 {
2315 u8 tbusy;
2316 uint chars;
2345 /* Get Transmit queue pointers */
2349 /* Get tbusy flag */
2352 /* Get Command queue pointers */
2359 /*
2360 * The only way we know for sure if there is no pending
2361 * data left to be transferred, is if:
2362 * 1) Transmit head and tail are equal (empty).
2363 * 2) Command queue head and tail are equal (empty).
2364 * 3) The "TBUSY" flag is 0. (Transmitter not busy).
2365 */
2372 else
2374 /*
2375 * Fudge factor here.
2376 * If chars is zero, we know that the command queue had
2377 * something in it or tbusy was set. Because we cannot
2378 * be sure if there is still some data to be transmitted,
2379 * lets lie, and tell ld we have 1 byte left.
2380 */
2382 /*
2383 * If TBUSY is still set, and our tx buffers are empty,
2384 * force the firmware to send me another wakeup after
2385 * TBUSY has been cleared.
2386 */
2392 lock_flags);
2393 }
2395 }
2396 }
2399 }
2402 {
2425 /* Loop until data is drained */
2433 /* Set flag waiting for drain */
2439 /* Go to sleep till we get woken up */
2442 /* If ret is non-zero, user ctrl-c'ed us */
2445 }
2452 }
2454 /*
2455 * dgap_maxcps_room
2456 *
2457 * Reduces bytes_available to the max number of characters
2458 * that can be sent currently given the maxcps value, and
2459 * returns the new bytes_available. This only affects printer
2460 * output.
2461 */
2463 {
2478 /*
2479 * If its not the Transparent print device, return
2480 * the full data amount.
2481 */
2493 /* buffer is empty */
2497 /* still room in the buffer */
2501 /* no room in the buffer */
2503 }
2506 }
2509 }
2512 {
2529 }
2530 }
2535 }
2536 }
2537 }
2539 /*
2540 * dgap_tty_write_room()
2541 *
2542 * Return space available in Tx buffer
2543 */
2545 {
2578 /* Limit printer to maxcps */
2581 /*
2582 * If we are printer device, leave space for
2583 * possibly both the on and off strings.
2584 */
2592 }
2597 /*
2598 * Schedule FEP to wake us up if needed.
2599 *
2600 * TODO: This might be overkill...
2601 * Do we really need to schedule callbacks from the FEP
2602 * in every case? Can we get smarter based on ret?
2603 */
2608 }
2610 /*
2611 * dgap_tty_put_char()
2612 *
2613 * Put a character into ch->ch_buf
2614 *
2615 * - used by the line discipline for OPOST processing
2616 */
2618 {
2619 /*
2620 * Simply call tty_write.
2621 */
2624 }
2626 /*
2627 * dgap_tty_write()
2628 *
2629 * Take data from the user or kernel and send it out to the FEP.
2630 * In here exists all the Transparent Print magic as well.
2631 */
2634 {
2642 ulong lock_flags;
2662 /*
2663 * Store original amount of characters passed in.
2664 * This helps to figure out if we should ask the FEP
2665 * to send us an event when it has more space available.
2666 */
2671 /* Get our space available for the channel from the board */
2680 /*
2681 * Limit printer output to maxcps overall, with bursts allowed
2682 * up to bufsize characters.
2683 */
2686 /*
2687 * Take minimum of what the user wants to send, and the
2688 * space available in the FEP buffer.
2689 */
2692 /*
2693 * Bail if no space left.
2694 */
2699 }
2701 /*
2702 * Output the printer ON string, if we are in terminal mode, but
2703 * need to be in printer mode.
2704 */
2710 }
2712 /*
2713 * On the other hand, output the printer OFF string, if we are
2714 * currently in printer mode, but need to output to the terminal.
2715 */
2721 }
2725 /*
2726 * If the write wraps over the top of the circular buffer,
2727 * move the portion up to the wrap point, and reset the
2728 * pointers to the bottom.
2729 */
2740 }
2744 /*
2745 * Move rest of data.
2746 */
2753 }
2759 }
2763 /*
2764 * If this is the print device, and the
2765 * printer is still on, we need to turn it
2766 * off before going idle. If the buffer is
2767 * non-empty, wait until it goes empty.
2768 * Otherwise turn it off right now.
2769 */
2781 }
2782 }
2784 /* Update printer buffer empty time. */
2788 }
2793 }
2795 /*
2796 * Return modem signals to ld.
2797 */
2799 {
2803 u8 mstat;
2804 ulong lock_flags;
2820 /* Append any outbound signals that might be pending... */
2841 }
2843 /*
2844 * dgap_tty_tiocmset()
2845 *
2846 * Set modem signals, called by ld.
2847 */
2850 {
2854 ulong lock_flags;
2855 ulong lock_flags2;
2878 }
2883 }
2888 }
2893 }
2901 }
2903 /*
2904 * dgap_tty_send_break()
2905 *
2906 * Send a Break, called by ld.
2907 */
2909 {
2913 ulong lock_flags;
2914 ulong lock_flags2;
2941 }
2945 #if 0
2947 #endif
2954 }
2956 /*
2957 * dgap_tty_wait_until_sent()
2958 *
2959 * wait until data has been transmitted, called by ld.
2960 */
2962 {
2964 }
2966 /*
2967 * dgap_send_xchar()
2968 *
2969 * send a high priority character, called by ld.
2970 */
2972 {
2976 ulong lock_flags;
2977 ulong lock_flags2;
2997 /*
2998 * This is technically what we should do.
2999 * However, the NIST tests specifically want
3000 * to see each XON or XOFF character that it
3001 * sends, so lets just send each character
3002 * by hand...
3003 */
3004 #if 0
3009 else
3011 #else
3013 #endif
3019 }
3021 /*
3022 * Return modem signals to ld.
3023 */
3025 {
3027 u8 mstat;
3028 ulong lock_flags;
3037 /* Append any outbound signals that might be pending... */
3060 }
3062 /*
3063 * dgap_set_modem_info()
3064 *
3065 * Set modem signals, called by ld.
3066 */
3069 {
3075 ulong lock_flags;
3076 ulong lock_flags2;
3102 }
3107 }
3115 }
3120 }
3129 else
3134 else
3141 }
3152 }
3154 /*
3155 * dgap_tty_digigeta()
3156 *
3157 * Ioctl to get the information for ditty.
3158 *
3159 *
3160 *
3161 */
3164 {
3168 ulong lock_flags;
3194 }
3196 /*
3197 * dgap_tty_digiseta()
3198 *
3199 * Ioctl to set the information for ditty.
3200 *
3201 *
3202 *
3203 */
3206 {
3264 }
3266 /*
3267 * dgap_tty_digigetedelay()
3268 *
3269 * Ioctl to get the current edelay setting.
3270 *
3271 *
3272 *
3273 */
3275 {
3279 ulong lock_flags;
3305 }
3307 /*
3308 * dgap_tty_digisetedelay()
3309 *
3310 * Ioctl to set the EDELAY setting
3311 *
3312 */
3314 {
3319 ulong lock_flags;
3320 ulong lock_flags2;
3351 }
3353 /*
3354 * dgap_tty_digigetcustombaud()
3355 *
3356 * Ioctl to get the current custom baud rate setting.
3357 */
3360 {
3364 ulong lock_flags;
3390 }
3392 /*
3393 * dgap_tty_digisetcustombaud()
3394 *
3395 * Ioctl to set the custom baud rate setting
3396 */
3399 {
3403 uint new_rate;
3404 ulong lock_flags;
3405 ulong lock_flags2;
3437 }
3440 }
3442 /*
3443 * dgap_set_termios()
3444 */
3447 {
3484 }
3487 {
3491 ulong lock_flags;
3492 ulong lock_flags2;
3513 #if 1
3515 #endif
3520 }
3523 {
3527 ulong lock_flags;
3528 ulong lock_flags2;
3550 #if 1
3552 #endif
3556 }
3559 {
3563 ulong lock_flags;
3564 ulong lock_flags2;
3588 }
3591 {
3595 ulong lock_flags;
3596 ulong lock_flags2;
3620 }
3622 /*
3623 * dgap_tty_flush_chars()
3624 *
3625 * Flush the cook buffer
3626 *
3627 * Note to self, and any other poor souls who venture here:
3628 *
3629 * flush in this case DOES NOT mean dispose of the data.
3630 * instead, it means "stop buffering and send it if you
3631 * haven't already." Just guess how I figured that out... SRW 2-Jun-98
3632 *
3633 * It is also always called in interrupt context - JAR 8-Sept-99
3634 */
3636 {
3640 ulong lock_flags;
3641 ulong lock_flags2;
3661 /* TODO: Do something here */
3665 }
3667 /*
3668 * dgap_tty_flush_buffer()
3669 *
3670 * Flush Tx buffer (make in == out)
3671 */
3673 {
3677 ulong lock_flags;
3678 ulong lock_flags2;
3679 u16 head;
3706 }
3710 }
3717 }
3719 /*****************************************************************************
3720 *
3721 * The IOCTL function and all of its helpers
3722 *
3723 *****************************************************************************/
3725 /*
3726 * dgap_tty_ioctl()
3727 *
3728 * The usual assortment of ioctl's
3729 */
3732 {
3737 u16 head;
3764 }
3768 /* Here are all the standard ioctl's that we MUST implement */
3771 /*
3772 * TCSBRK is SVID version: non-zero arg --> no break
3773 * this behaviour is exploited by tcdrain().
3774 *
3775 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
3776 * between 0.25 and 0.5 seconds so we'll ask for something
3777 * in the middle: 0.375 seconds.
3778 */
3802 /* support for POSIX tcsendbreak()
3804 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
3805 * between 0.25 and 0.5 seconds so we'll ask for something
3806 * in the middle: 0.375 seconds.
3807 */
3829 /*
3830 * FEP5 doesn't support turning on a break unconditionally.
3831 * The FEP5 device will stop sending a break automatically
3832 * after the specified time value that was sent when turning on
3833 * the break.
3834 */
3856 /*
3857 * FEP5 doesn't support turning off a break unconditionally.
3858 * The FEP5 device will stop sending a break automatically
3859 * after the specified time value that was sent when turning on
3860 * the break.
3861 */
3905 /*
3906 * Here are any additional ioctl's that we want to implement
3907 */
3910 /*
3911 * The linux tty driver doesn't have a flush
3912 * input routine for the driver, assuming all backed
3913 * up data is in the line disc. buffers. However,
3914 * we all know that's not the case. Here, we
3915 * act on the ioctl, but then lie and say we didn't
3916 * so the line discipline will process the flush
3917 * also.
3918 */
3924 }
3931 }
3932 }
3935 /* pretend we didn't recognize this IOCTL */
3940 }
3949 }
3953 }
3957 /* Can't hold any locks when calling tty_wakeup! */
3962 /* pretend we didn't recognize this IOCTL */
3967 /*
3968 * The linux tty driver doesn't have a flush
3969 * input routine for the driver, assuming all backed
3970 * up data is in the line disc. buffers. However,
3971 * we all know that's not the case. Here, we
3972 * act on the ioctl, but then lie and say we didn't
3973 * so the line discipline will process the flush
3974 * also.
3975 */
3977 /* flush rx */
3981 }
3983 /* now wait for all the output to drain */
3990 /* pretend we didn't recognize this */
4001 /* pretend we didn't recognize this */
4005 /*
4006 * The Linux Line Discipline (LD) would do this for us if we
4007 * let it, but we have the special firmware options to do this
4008 * the "right way" regardless of hardware or software flow
4009 * control so we'll do it outselves instead of letting the LD
4010 * do it.
4011 */
4017 }
4034 /* Make the ld do it */
4039 /* Make the ld do it */
4045 }
4048 /* get information for ditty */
4056 /* set information for ditty */
4068 /* fall thru */
4107 }
4108 }
4111 {
4112 /*
4113 * Initialize KME waitqueues...
4114 */
4117 /*
4118 * allocate flip buffer for board.
4119 */
4128 }
4131 }
4133 /*
4134 * Create pr and tty device entries
4135 */
4137 {
4142 GFP_KERNEL);
4147 GFP_KERNEL);
4151 }
4156 }
4176 }
4180 }
4182 /*
4183 * Copies the BIOS code from the user to the board,
4184 * and starts the BIOS running.
4185 */
4187 {
4189 uint offset;
4197 /*
4198 * clear POST area
4199 */
4203 /*
4204 * Download bios
4205 */
4212 /* Clear the reset, and change states. */
4214 }
4216 /*
4217 * Checks to see if the BIOS completed running on the card.
4218 */
4220 {
4222 u16 word;
4223 u16 err1;
4224 u16 err2;
4232 /*
4233 * It can take 5-6 seconds for a board to
4234 * pass the bios self test and post results.
4235 * Give it 10 seconds.
4236 */
4239 /* Check to see if BIOS thinks board is good. (GD). */
4245 }
4247 /* Gave up on board after too long of time taken */
4256 }
4258 /*
4259 * Copies the FEP code from the user to the board,
4260 * and starts the FEP running.
4261 */
4263 {
4265 uint offset;
4272 /*
4273 * Download FEP
4274 */
4278 /*
4279 * If board is a concentrator product, we need to give
4280 * it its config string describing how the concentrators look.
4281 */
4290 /* Write string to board memory */
4296 }
4297 }
4302 }
4304 /*
4305 * Waits for the FEP to report thats its ready for us to use.
4306 */
4308 {
4310 u16 word;
4311 u16 err1;
4312 u16 err2;
4320 /*
4321 * It can take 2-3 seconds for the FEP to
4322 * be up and running. Give it 5 secs.
4323 */
4326 /* Check to see if FEP is up and running now. */
4328 /*
4329 * Check to see if the board can support FEP5+ commands.
4330 */
4336 }
4340 }
4342 /* Gave up on board after too long of time taken */
4351 }
4353 /*
4354 * Physically forces the FEP5 card to reset itself.
4355 */
4357 {
4358 u8 check;
4359 u32 check1;
4360 u32 check2;
4367 /* FEPRST does not vary among supported boards */
4376 }
4382 }
4384 /*
4385 * Make sure there really is memory out there.
4386 */
4398 }
4399 }
4401 #ifdef DIGI_CONCENTRATORS_SUPPORTED
4402 /*
4403 * Sends a concentrator image into the FEP5 board.
4404 */
4406 {
4408 u16 offset;
4420 /* Tell card we have data for it */
4424 }
4425 #endif
4427 #define EXPANSION_ROM_SIZE (64 * 1024)
4428 #define FEP5_ROM_MAGIC (0xFEFFFFFF)
4431 {
4432 u32 magic;
4433 u32 base_offset;
4434 u16 rom_offset;
4435 u16 vpd_offset;
4436 u16 image_length;
4437 u16 i;
4438 u8 byte1;
4439 u8 byte2;
4441 /*
4442 * Poke the magic number at the PCI Rom Address location.
4443 * If VPD is supported, the value read from that address
4444 * will be non-zero.
4445 */
4450 /* VPD not supported, bail */
4454 /*
4455 * To get to the OTPROM memory, we have to send the boards base
4456 * address or'ed with 1 into the PCI Rom Address location.
4457 */
4465 /*
4466 * If the board correctly swapped to the OTPROM memory,
4467 * the first 2 bytes (header) should be 0x55, 0xAA
4468 */
4473 /*
4474 * We have to run through all the OTPROM memory looking
4475 * for the VPD offset.
4476 */
4479 /*
4480 * Lots of magic numbers here.
4481 *
4482 * The VPD offset is located inside the ROM Data
4483 * Structure.
4484 *
4485 * We also have to remember the length of each
4486 * ROM Data Structure, so we can "hop" to the next
4487 * entry if the VPD isn't in the current
4488 * ROM Data Structure.
4489 */
4497 /* Found the VPD entry */
4501 /* We didn't find a VPD entry, go to next ROM entry. */
4507 /*
4508 * If the new ROM offset doesn't have 0x55, 0xAA
4509 * as its header, we have run out of ROM.
4510 */
4513 }
4515 /*
4516 * If we have a VPD offset, then mark the board
4517 * as having a valid VPD, and copy VPDSIZE (512) bytes of
4518 * that VPD to the buffer we have in our board structure.
4519 */
4525 }
4526 }
4527 }
4529 /*
4530 * We MUST poke the magic number at the PCI Rom Address location again.
4531 * This makes the card report the regular board memory back to us,
4532 * rather than the OTPROM memory.
4533 */
4536 }
4538 /*
4539 * Our board poller function.
4540 */
4542 {
4544 ulong lock_flags;
4558 /*
4559 * If board is ready, parse deeper to see if there is anything to do.
4560 */
4568 }
4572 }
4579 /* Get our head and tail */
4583 /*
4584 * If there is an event pending. Go service it.
4585 */
4590 }
4592 out:
4593 /*
4594 * If board is doing interrupts, ACK the interrupt.
4595 */
4601 }
4604 }
4606 /*=======================================================================
4607 *
4608 * dgap_cmdb - Sends a 2 byte command to the FEP.
4609 *
4610 * ch - Pointer to channel structure.
4611 * cmd - Command to be sent.
4612 * byte1 - Integer containing first byte to be sent.
4613 * byte2 - Integer containing second byte to be sent.
4614 * ncmds - Wait until ncmds or fewer cmds are left
4615 * in the cmd buffer before returning.
4616 *
4617 *=======================================================================*/
4620 {
4623 uint count;
4624 uint n;
4625 u16 head;
4626 u16 tail;
4631 /*
4632 * Check if board is still alive.
4633 */
4637 /*
4638 * Make sure the pointers are in range before
4639 * writing to the FEP memory.
4640 */
4649 /*
4650 * Forget it if pointers out of range.
4651 */
4655 }
4657 /*
4658 * Put the data in the circular command buffer.
4659 */
4669 /*
4670 * Wait if necessary before updating the head
4671 * pointer to limit the number of outstanding
4672 * commands to the FEP. If the time spent waiting
4673 * is outlandish, declare the FEP dead.
4674 */
4688 }
4690 }
4691 }
4693 /*=======================================================================
4694 *
4695 * dgap_cmdw - Sends a 1 word command to the FEP.
4696 *
4697 * ch - Pointer to channel structure.
4698 * cmd - Command to be sent.
4699 * word - Integer containing word to be sent.
4700 * ncmds - Wait until ncmds or fewer cmds are left
4701 * in the cmd buffer before returning.
4702 *
4703 *=======================================================================*/
4705 {
4708 uint count;
4709 uint n;
4710 u16 head;
4711 u16 tail;
4716 /*
4717 * Check if board is still alive.
4718 */
4722 /*
4723 * Make sure the pointers are in range before
4724 * writing to the FEP memory.
4725 */
4733 /*
4734 * Forget it if pointers out of range.
4735 */
4739 }
4741 /*
4742 * Put the data in the circular command buffer.
4743 */
4752 /*
4753 * Wait if necessary before updating the head
4754 * pointer to limit the number of outstanding
4755 * commands to the FEP. If the time spent waiting
4756 * is outlandish, declare the FEP dead.
4757 */
4771 }
4773 }
4774 }
4776 /*=======================================================================
4777 *
4778 * dgap_cmdw_ext - Sends a extended word command to the FEP.
4779 *
4780 * ch - Pointer to channel structure.
4781 * cmd - Command to be sent.
4782 * word - Integer containing word to be sent.
4783 * ncmds - Wait until ncmds or fewer cmds are left
4784 * in the cmd buffer before returning.
4785 *
4786 *=======================================================================*/
4788 {
4791 uint count;
4792 uint n;
4793 u16 head;
4794 u16 tail;
4799 /*
4800 * Check if board is still alive.
4801 */
4805 /*
4806 * Make sure the pointers are in range before
4807 * writing to the FEP memory.
4808 */
4816 /*
4817 * Forget it if pointers out of range.
4818 */
4822 }
4824 /*
4825 * Put the data in the circular command buffer.
4826 */
4828 /* Write an FF to tell the FEP that we want an extended command */
4834 /*
4835 * If the second part of the command won't fit,
4836 * put it at the beginning of the circular buffer.
4837 */
4840 else
4847 /*
4848 * Wait if necessary before updating the head
4849 * pointer to limit the number of outstanding
4850 * commands to the FEP. If the time spent waiting
4851 * is outlandish, declare the FEP dead.
4852 */
4866 }
4868 }
4869 }
4871 /*=======================================================================
4872 *
4873 * dgap_wmove - Write data to FEP buffer.
4874 *
4875 * ch - Pointer to channel structure.
4876 * buf - Poiter to characters to be moved.
4877 * cnt - Number of characters to move.
4878 *
4879 *=======================================================================*/
4881 {
4885 u16 head;
4890 /*
4891 * Check parameters.
4892 */
4896 /*
4897 * If pointers are out of range, just return.
4898 */
4903 /*
4904 * If the write wraps over the top of the circular buffer,
4905 * move the portion up to the wrap point, and reset the
4906 * pointers to the bottom.
4907 */
4916 }
4918 /*
4919 * Move rest of data.
4920 */
4927 }
4929 /*
4930 * Retrives the current custom baud rate from FEP memory,
4931 * and returns it back to the user.
4932 * Returns 0 on error.
4933 */
4935 {
4937 ulong offset;
4938 uint value;
4954 /*
4955 * Go get from fep mem, what the fep
4956 * believes the custom baud rate is.
4957 */
4963 }
4965 /*
4966 * Calls the firmware to reset this channel.
4967 */
4969 {
4972 /*
4973 * Now that the channel is reset, we need to make sure
4974 * all the current settings get reapplied to the port
4975 * in the firmware.
4976 *
4977 * So we will set the driver's cache of firmware
4978 * settings all to 0, and then call param.
4979 */
4989 }
4991 /*=======================================================================
4992 *
4993 * dgap_param - Set Digi parameters.
4994 *
4995 * struct tty_struct * - TTY for port.
4996 *
4997 *=======================================================================*/
4999 {
5005 u16 head;
5006 u16 cflag;
5007 u16 iflag;
5008 u8 mval;
5009 u8 hflow;
5032 /*
5033 * If baud rate is zero, flush queues, and set mval to drop DTR.
5034 */
5037 /* flush rx */
5041 /* flush tx */
5047 /* Drop RTS and DTR */
5053 /*
5054 * Tell the fep to do the command
5055 */
5059 /*
5060 * Now go get from fep mem, what the fep
5061 * believes the custom baud rate is.
5062 */
5066 /* Handle transition from B0 */
5070 }
5074 /*
5075 * Set baud rate, character size, and parity.
5076 */
5104 };
5106 /*
5107 * Only use the TXPrint baud rate if the
5108 * terminal unit is NOT open
5109 */
5113 else
5127 else
5135 /*
5136 * CBAUD has bit position 0x1000 set these days to
5137 * indicate Linux baud rate remap.
5138 * We use a different bit assignment for high speed.
5139 * Clear this bit out while grabbing the parts of
5140 * "cflag" we want.
5141 */
5145 /*
5146 * HUPCL bit is used by FEP to indicate fast baud
5147 * table is to be used.
5148 */
5155 /*
5156 * The below code is trying to guarantee that only
5157 * baud rates 115200, 230400, 460800, 921600 are
5158 * remapped. We use exclusive or because the various
5159 * baud rates share common bit positions and therefore
5160 * can't be tested for easily.
5161 */
5165 /*
5166 * Map high speed requests to index
5167 * into FEP's baud table
5168 */
5173 #ifdef B76800
5177 #endif
5187 #ifdef B921600
5191 #endif
5194 }
5198 }
5205 /*
5206 * Okay to have channel and board
5207 * locks held calling this
5208 */
5210 }
5212 /* Handle transition from B0 */
5216 }
5218 }
5220 /*
5221 * Get input flags.
5222 */
5230 }
5232 /*
5233 * Only the IBM Xr card can switch between
5234 * 232 and 422 modes on the fly
5235 */
5239 else
5241 }
5249 /* Okay to have channel and board locks held calling this */
5251 }
5253 /*
5254 * Select hardware handshaking.
5255 */
5274 /* Okay to have channel and board locks held calling this */
5276 }
5278 /*
5279 * Set RTS and/or DTR Toggle if needed,
5280 * but only if product is FEP5+ based.
5281 */
5290 }
5292 /*
5293 * Set modem control lines.
5294 */
5301 /* Okay to have channel and board locks held calling this */
5303 }
5305 /*
5306 * Read modem signals, and then call carrier function.
5307 */
5311 /*
5312 * Set the start and stop characters.
5313 */
5319 /* Okay to have channel and board locks held calling this */
5321 }
5323 /*
5324 * Set the Auxiliary start and stop characters.
5325 */
5331 /* Okay to have channel and board locks held calling this */
5333 }
5336 }
5338 /*
5339 * dgap_parity_scan()
5340 *
5341 * Convert the FEP5 way of reporting parity errors and breaks into
5342 * the Linux line discipline way.
5343 */
5346 {
5363 /* reset to sanity and fall through */
5367 /* No FF seen yet */
5369 /* delete this character from stream */
5375 }
5379 /* first FF seen */
5381 /* doubled ff, transform to single ff */
5387 /* save value examination in next state */
5390 }
5394 /* third character of ff sequence */
5406 }
5407 }
5411 }
5412 }
5414 }
5420 {
5438 }
5441 }
5443 /*=======================================================================
5444 *
5445 * dgap_event - FEP to host event processing routine.
5446 *
5447 * bd - Board of current event.
5448 *
5449 *=======================================================================*/
5451 {
5453 ulong lock_flags;
5454 ulong lock_flags2;
5459 uint head;
5460 uint tail;
5476 }
5480 /* Get our head and tail */
5484 /*
5485 * Forget it if pointers out of range.
5486 */
5490 /* Let go of board lock */
5493 }
5495 /*
5496 * Loop to process all the events in the buffer.
5497 */
5500 /*
5501 * Get interrupt information.
5502 */
5511 /*
5512 * Make sure the interrupt is valid.
5513 */
5525 /*
5526 * If we have made it here, the event was valid.
5527 * Lock down the channel.
5528 */
5536 }
5538 /*
5539 * Process received data.
5540 */
5543 /*
5544 * ALL LOCKS *MUST* BE DROPPED BEFORE CALLING INPUT!
5545 * input could send some data to ld, which in turn
5546 * could do a callback to one of our other functions.
5547 */
5558 else
5564 wake_up_interruptible
5566 }
5567 }
5569 /*
5570 * Process Modem change signals.
5571 */
5575 }
5577 /*
5578 * Process break.
5579 */
5583 /* A break has been indicated */
5585 tty_buffer_request_room
5590 }
5591 }
5593 /*
5594 * Process Transmit low.
5595 */
5604 }
5605 }
5607 /*
5608 * Process Transmit empty.
5609 */
5618 }
5619 }
5623 next:
5625 }
5631 }
5634 {
5636 }
5641 {
5643 }
5648 {
5650 }
5656 {
5658 }
5662 {
5664 }
5668 {
5672 }
5674 dgap_driver_pollrate_store);
5677 {
5688 }
5691 {
5698 }
5701 {
5712 }
5717 {
5730 }
5732 }
5738 {
5751 }
5753 }
5759 {
5785 else
5788 }
5790 }
5796 {
5810 }
5816 {
5830 }
5836 {
5850 }
5856 {
5870 }
5876 {
5890 }
5896 {
5910 }
5916 {
5930 }
5933 /* this function creates the sys files that will export each signal status
5934 * to sysfs each value will be put in a separate filename
5935 */
5937 {
5949 }
5951 /* removes all the sys files created for that port */
5953 {
5964 }
5969 {
5990 }
5996 {
6016 }
6022 {
6049 }
6051 }
6057 {
6077 }
6083 {
6103 }
6109 {
6129 }
6135 {
6155 }
6161 {
6181 }
6187 {
6207 }
6213 {
6233 }
6239 {
6280 else
6282 }
6300 }
6301 }
6315 }
6318 }
6332 }
6336 }
6337 }
6341 }
6356 NULL
6357 };
6362 };
6365 {
6374 }
6377 {
6379 }
6381 /*
6382 * Parse a configuration file read into memory as a string.
6383 */
6385 {
6394 /* perhaps we are adding to an existing list? */
6398 /* file must start with a BEGIN */
6403 }
6404 }
6411 }
6432 }
6445 }
6454 }
6463 }
6472 }
6481 }
6490 }
6503 }
6516 }
6527 }
6532 }
6537 }
6545 }
6550 }
6555 }
6563 }
6568 }
6573 }
6579 }
6584 }
6592 }
6597 }
6606 }
6611 }
6621 }
6625 }
6632 }
6636 }
6643 }
6647 }
6652 }
6660 }
6673 }
6682 }
6686 }
6693 }
6697 }
6704 }
6708 }
6713 }
6723 }
6729 }
6734 }
6744 }
6750 }
6755 }
6764 }
6769 }
6774 }
6778 linecnt++;
6787 }
6792 }
6797 else
6806 }
6815 }
6826 }
6835 }
6836 }
6841 }
6845 else
6854 }
6863 }
6874 }
6877 }
6886 }
6890 }
6897 }
6901 }
6906 }
6915 }
6918 }
6927 }
6933 }
6938 }
6948 }
6954 }
6958 }
6968 }
6974 }
6978 }
6988 }
6994 }
6998 }
7008 }
7014 }
7018 }
7028 }
7034 }
7038 }
7048 }
7054 }
7058 }
7068 }
7074 }
7078 }
7088 }
7094 }
7098 }
7108 }
7114 }
7118 }
7120 }
7121 }
7122 }
7124 /*
7125 * dgap_sindex: much like index(), but it looks for a match of any character in
7126 * the group, and returns that position. If the first character is a ^, then
7127 * this will match the first occurrence not in that group.
7128 */
7130 {
7137 group++;
7142 }
7145 }
7151 }
7152 }
7153 }
7156 }
7158 /*
7159 * Get a token from the input file; return 0 if end of file is reached
7160 */
7162 {
7172 }
7181 }
7182 }
7184 }
7185 }
7187 /*
7188 * get a word from the input stream, also keep track of current line number.
7189 * words are separated by whitespace.
7190 */
7192 {
7197 /* If no word found, return null */
7201 /* Mark new location for our buffer */
7205 /* Eat any extra spaces/tabs/newlines that might be present */
7211 }
7214 }
7216 /*
7217 * print an error message, giving the line number in the file where
7218 * the error occurred.
7219 */
7221 {
7223 }
7225 /*
7226 * allocate a new configuration node of type t
7227 */
7229 {
7236 }
7238 }
7240 /*
7241 * dgap_checknode: see if all the necessary info has been supplied for a node
7242 * before creating the next node.
7243 */
7245 {
7251 }
7259 }
7266 }
7270 }
7274 }
7278 }
7285 }
7289 }
7293 }
7295 }
7297 }
7299 /*
7300 * Given a board pointer, returns whether we should use interrupts or not.
7301 */
7303 {
7311 /*
7312 * check for pcxr types.
7313 */
7315 }
7316 }
7318 /* If not found, then don't turn on interrupts. */
7320 }
7322 /*
7323 * Given a board pointer, returns whether we turn on altpin or not.
7324 */
7326 {
7334 /*
7335 * check for pcxr types.
7336 */
7338 }
7339 }
7341 /* If not found, then don't turn on interrupts. */
7343 }
7345 /*
7346 * Given a specific type of board, if found, detached link and
7347 * returns the first occurrence in the list.
7348 */
7350 {
7374 /*
7375 * Keep walking thru the list till we
7376 * find the next board.
7377 */
7385 /*
7386 * Mark the end of our 1 board
7387 * chain of configs.
7388 */
7391 /*
7392 * Link the "next" board to the
7393 * previous board, effectively
7394 * "unlinking" our board from
7395 * the main config.
7396 */
7400 }
7401 /*
7402 * It must be the last board in the list.
7403 */
7406 }
7408 }
7410 /*
7411 * Given a board pointer, walks the config link, counting up
7412 * all ports user specified should be on the board.
7413 * (This does NOT mean they are all actually present right now tho)
7414 */
7416 {
7427 /*
7428 * check for pcxr types.
7429 */
7439 }
7440 }
7442 }
7445 {
7454 }
7461 ptr++;
7463 ptr++;
7466 /*
7467 * Because the EPC/con concentrators can have EM modules
7468 * hanging off of them, we have to walk ahead in the
7469 * list and keep adding the number of ports on each EM
7470 * to the config. UGH!
7471 */
7476 ptr++;
7480 ptr++;
7483 }
7485 ptr++;
7488 ptr++;
7489 }
7492 ptr++;
7494 }
7495 }
7499 }