| blob | ad5afbc1e69447e7d22443416f6d68fd73dc78bb |
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 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 *
19 *
20 * NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE!
21 *
22 * This is shared code between Digi's CVS archive and the
23 * Linux Kernel sources.
24 * Changing the source just for reformatting needlessly breaks
25 * our CVS diff history.
26 *
27 * Send any bug fixes/changes to: Eng.Linux at digi dot com.
28 * Thank you.
29 *
30 */
32 /*
33 * In the original out of kernel Digi dgap driver, firmware
34 * loading was done via user land to driver handshaking.
35 *
36 * For cards that support a concentrator (port expander),
37 * I believe the concentrator its self told the card which
38 * concentrator is actually attached and then that info
39 * was used to tell user land which concentrator firmware
40 * image was to be downloaded. I think even the BIOS or
41 * FEP images required could change with the connection
42 * of a particular concentrator.
43 *
44 * Since I have no access to any of these cards or
45 * concentrators, I cannot put the correct concentrator
46 * firmware file names into the firmware_info structure
47 * as is now done for the BIOS and FEP images.
48 *
49 * I think, but am not certain, that the cards supporting
50 * concentrators will function without them. So support
51 * of these cards has been left in this driver.
52 *
53 * In order to fully support those cards, they would
54 * either have to be acquired for dissection or maybe
55 * Digi International could provide some assistance.
56 */
57 #undef DIGI_CONCENTRATORS_SUPPORTED
59 #include <linux/kernel.h>
60 #include <linux/module.h>
61 #include <linux/pci.h>
63 #include <linux/slab.h>
64 #include <linux/uaccess.h>
65 #include <linux/sched.h>
68 #include <linux/ctype.h>
69 #include <linux/tty.h>
70 #include <linux/tty_flip.h>
71 #include <linux/serial_reg.h>
74 #include <linux/string.h>
75 #include <linux/device.h>
76 #include <linux/kdev_t.h>
77 #include <linux/firmware.h>
81 #define init_MUTEX(sem) sema_init(sem, 1)
82 #define DECLARE_MUTEX(name) \
83 struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1)
90 /**************************************************************************
91 *
92 * protos for this file
93 *
94 */
108 /* Our function prototypes */
157 /*
158 * Our function prototypes from dgap_fep5
159 */
174 /*
175 * Function prototypes from dgap_parse.c.
176 */
184 /*
185 * Function prototypes from dgap_sysfs.h
186 */
202 /*
203 * Function prototypes from dgap_parse.h
204 */
216 #ifdef DIGI_CONCENTRATORS_SUPPORTED
218 #endif
229 /* Driver unload function */
234 /*
235 * File operations permitted on Control/Management major.
236 */
239 };
241 /*
242 * Globals
243 */
254 /*
255 * Static vars.
256 */
262 /*
263 * Poller stuff
264 */
270 /*
271 SUPPORTED PRODUCTS
273 Card Model Number of Ports Interface
274 ----------------------------------------------------------------
275 Acceleport Xem 4 - 64 (EIA232 & EIA422)
276 Acceleport Xr 4 & 8 (EIA232)
277 Acceleport Xr 920 4 & 8 (EIA232)
278 Acceleport C/X 8 - 128 (EIA232)
279 Acceleport EPC/X 8 - 224 (EIA232)
280 Acceleport Xr/422 4 & 8 (EIA422)
281 Acceleport 2r/920 2 (EIA232)
282 Acceleport 4r/920 4 (EIA232)
283 Acceleport 8r/920 8 (EIA232)
285 IBM 8-Port Asynchronous PCI Adapter (EIA232)
286 IBM 128-Port Asynchronous PCI Adapter (EIA232 & EIA422)
287 */
306 };
309 /*
310 * A generic list of Product names, PCI Vendor ID, and PCI Device ID.
311 */
313 uint config_type;
315 uint maxports;
316 uint dpatype;
317 };
336 };
343 };
351 };
353 /*
354 * Firmware - BIOS, FEP, and CONC filenames
355 */
373 };
379 "Driver Ready."
380 };
382 /*
383 * Default transparent print information.
384 */
395 };
397 /*
398 * Define a local default termios struct. All ports will be created
399 * with this termios initially.
400 *
401 * This defines a raw port at 9600 baud, 8 data bits, no parity,
402 * 1 stop bit.
403 */
412 };
435 };
437 /*
438 * Our needed internal static variables from dgap_parse.c
439 */
441 #define MAXCWORD 200
447 };
498 };
500 /************************************************************************
501 *
502 * Driver load/unload functions
503 *
504 ************************************************************************/
506 /*
507 * init_module()
508 *
509 * Module load. This is where it all starts.
510 */
512 {
535 err_cleanup:
540 }
543 /*
544 * Start of driver.
545 */
547 {
551 /*
552 * make sure that the globals are
553 * init'd before we do anything else
554 */
561 /*
562 * Register our base character device into the kernel.
563 */
565 /*
566 * Register management/dpa devices
567 */
577 /* Start the poller */
591 }
593 /*
594 * Register pci driver, and return how many boards we have.
595 */
597 {
599 }
601 /* returns count (>= 0), or negative on error */
603 {
606 /* wake up and enable device */
614 dgap_NumBoards++;
616 }
617 }
619 }
622 {
624 }
627 {
628 /* Do Nothing */
629 }
631 /*
632 * dgap_cleanup_module()
633 *
634 * Module unload. This is where it all ends.
635 */
637 {
639 ulong lock_flags;
645 /* Turn off poller right away. */
660 }
664 }
666 /*
667 * dgap_cleanup_board()
668 *
669 * Free all the memory associated with a board
670 */
672 {
687 }
693 }
695 /* Free all allocated channels structs */
705 }
707 /*
708 * dgap_found_board()
709 *
710 * A board has been found, init it.
711 */
713 {
718 /* get the board structure and prep it */
725 /* store the info for the board we've found */
752 /* store which card & revision we have */
760 /* get the PCI Base Address Registers */
762 /* Xr Jupiter and EPC use BAR 2 */
766 }
767 /* Everyone else uses BAR 0 */
771 }
778 else
781 /*
782 * On the PCI boards, there is no IO space allocated
783 * The I/O registers will be in the first 3 bytes of the
784 * upper 2MB of the 4MB memory space. The board memory
785 * will be mapped into the low 2MB of the 4MB memory space
786 */
790 /*
791 * Special initialization for non-PLX boards
792 */
799 /* Limit burst length to 2 doubleword transactions */
802 /*
803 * Enable IO and mem if not already done.
804 * This was needed for support on Itanium.
805 */
809 }
811 /* init our poll helper tasklet */
818 else
822 }
826 {
834 /*
835 * Set up our interrupt handler if we are set to do interrupts.
836 */
843 else
847 }
850 }
853 {
869 }
875 }
876 }
886 }
891 /*
892 * Match this board to a config the user created for us.
893 */
897 /*
898 * Because the 4 port Xr products share the same PCI ID
899 * as the 8 port Xr products, if we receive a NULL config
900 * back, and this is a PAPORT8 board, retry with a
901 * PAPORT4 attempt as well.
902 */
910 }
922 }
926 /* Wait for BIOS to test board... */
931 }
940 }
944 /* Wait for FEP to load on board... */
949 }
951 #ifdef DIGI_CONCENTRATORS_SUPPORTED
952 /*
953 * If this is a CX or EPCX, we need to see if the firmware
954 * is requesting a concentrator image from us.
955 */
958 /* Nonzero if FEP is requesting concentrator image. */
961 }
970 }
971 /* Put concentrator firmware loading code here */
977 }
978 #endif
979 /*
980 * Do tty device initialization.
981 */
986 }
996 }
998 /*
999 * Remap PCI memory.
1000 */
1002 {
1013 }
1020 }
1028 }
1031 }
1033 /*****************************************************************************
1034 *
1035 * Function:
1036 *
1037 * dgap_poll_handler
1038 *
1039 * Author:
1040 *
1041 * Scott H Kilau
1042 *
1043 * Parameters:
1044 *
1045 * dummy -- ignored
1046 *
1047 * Return Values:
1048 *
1049 * none
1050 *
1051 * Description:
1052 *
1053 * As each timer expires, it determines (a) whether the "transmit"
1054 * waiter needs to be woken up, and (b) whether the poller needs to
1055 * be rescheduled.
1056 *
1057 ******************************************************************************/
1060 {
1064 ulong new_time;
1066 dgap_poll_counter++;
1068 /*
1069 * Do not start the board state machine until
1070 * driver tells us its up and running, and has
1071 * everything it needs.
1072 */
1076 /*
1077 * If we have just 1 board, or the system is not SMP,
1078 * then use the typical old style poller.
1079 * Otherwise, use our new tasklet based poller, which should
1080 * speed things up for multiple boards.
1081 */
1090 /* Call the real board poller directly */
1092 }
1094 /*
1095 * Go thru each board, kicking off a
1096 * tasklet for each if needed
1097 */
1101 /*
1102 * Attempt to grab the board lock.
1103 *
1104 * If we can't get it, no big deal, the next poll
1105 * will get it. Basically, I just really don't want
1106 * to spin in here, because I want to kick off my
1107 * tasklets as fast as I can, and then get out the
1108 * poller.
1109 */
1113 /*
1114 * If board is in a failed state, don't bother
1115 * scheduling a tasklet
1116 */
1120 }
1122 /* Schedule a poll helper task */
1126 /*
1127 * Can't do DGAP_UNLOCK here, as we don't have
1128 * lock_flags because we did a trylock above.
1129 */
1131 }
1132 }
1134 schedule_poller:
1136 /*
1137 * Schedule ourself back at the nominal wakeup interval.
1138 */
1145 dgap_poll_time =
1147 }
1156 }
1158 /*
1159 * dgap_intr()
1160 *
1161 * Driver interrupt handler.
1162 */
1164 {
1170 /*
1171 * Check to make sure its for us.
1172 */
1178 /*
1179 * Schedule tasklet to run at a better time.
1180 */
1183 }
1185 /*
1186 * dgap_init_globals()
1187 *
1188 * This is where we initialize the globals from the static insmod
1189 * configuration variables. These are declared near the head of
1190 * this file.
1191 */
1193 {
1203 }
1205 /************************************************************************
1206 *
1207 * Utility functions
1208 *
1209 ************************************************************************/
1211 /*
1212 * dgap_ms_sleep()
1213 *
1214 * Put the driver to sleep for x ms's
1215 *
1216 * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
1217 */
1219 {
1223 }
1225 /************************************************************************
1226 *
1227 * TTY Initialization/Cleanup Functions
1228 *
1229 ************************************************************************/
1231 /*
1232 * dgap_tty_register()
1233 *
1234 * Init the tty subsystem for this board.
1235 */
1237 {
1252 TTY_DRIVER_DYNAMIC_DEV |
1253 TTY_DRIVER_HARDWARE_BREAK);
1255 /* The kernel wants space to store pointers to tty_structs */
1261 /*
1262 * Entry points for driver. Called by the kernel from
1263 * tty_io.c and n_tty.c.
1264 */
1267 /*
1268 * If we're doing transparent print, we have to do all of the above
1269 * again, separately so we don't get the LD confused about what major
1270 * we are when we get into the dgap_tty_open() routine.
1271 */
1284 TTY_DRIVER_DYNAMIC_DEV |
1285 TTY_DRIVER_HARDWARE_BREAK);
1287 /* The kernel wants space to store pointers to tty_structs */
1293 /*
1294 * Entry points for driver. Called by the kernel from
1295 * tty_io.c and n_tty.c.
1296 */
1300 /* Register tty devices */
1307 }
1310 /* Register Transparent Print devices */
1317 }
1320 }
1322 /*
1323 * dgap_tty_init()
1324 *
1325 * Init the tty subsystem. Called once per board after board has been
1326 * downloaded and init'ed.
1327 */
1329 {
1342 /*
1343 * Initialize board structure elements.
1344 */
1374 /* If no ports, don't bother going any further */
1379 }
1380 }
1382 /*
1383 * Allocate channel memory that might not have been allocated
1384 * when the driver was first loaded.
1385 */
1392 }
1393 }
1403 /* Set up channel variables */
1411 /* Store all our magic numbers */
1430 /*
1431 * Set up digi dsr and dcd bits based on altpin flag.
1432 */
1440 }
1451 /* .25 second delay */
1454 /*
1455 * Set queue water marks, interrupt mask,
1456 * and general tty parameters.
1457 */
1475 /* Turn on all modem interrupts for now */
1479 /*
1480 * Set edelay to 0 if interrupts are turned on,
1481 * otherwise set edelay to the usual 100.
1482 */
1485 else
1489 }
1492 }
1494 /*
1495 * dgap_tty_uninit()
1496 *
1497 * Uninitialize the TTY portion of this driver. Free all memory and
1498 * resources.
1499 */
1501 {
1513 }
1520 }
1530 }
1537 }
1538 }
1540 #define TMPBUFLEN (1024)
1541 /*
1542 * dgap_sniff - Dump data out to the "sniff" buffer if the
1543 * proc sniff file is opened...
1544 */
1547 {
1558 /* Leave if sniff not open */
1564 /* Create our header for data dump */
1573 buf++;
1575 }
1580 else
1585 }
1590 /*
1591 * Loop while data remains.
1592 */
1594 /*
1595 * Determine the amount of available space left in the
1596 * buffer. If there's none, wait until some appears.
1597 */
1599 SNIFF_MASK;
1601 /*
1602 * If there is no space left to write to in our sniff
1603 * buffer, we have no choice but to drop the data.
1604 * We *cannot* sleep here waiting for space, because
1605 * this function was probably called by the
1606 * interrupt/timer routines!
1607 */
1611 /*
1612 * Copy as much data as will fit.
1613 */
1627 }
1635 /*
1636 * Wakeup any thread waiting for data
1637 */
1641 }
1642 }
1644 /*
1645 * If the user sent us too much data to push into our tmpbuf,
1646 * we need to keep looping around on all the data.
1647 */
1651 }
1654 }
1656 /*=======================================================================
1657 *
1658 * dgap_input - Process received data.
1659 *
1660 * ch - Pointer to channel structure.
1661 *
1662 *=======================================================================*/
1665 {
1670 uint rmask;
1671 uint head;
1672 uint tail;
1674 ulong lock_flags;
1675 ulong lock_flags2;
1680 uchar tmpchar;
1699 /*
1700 * Figure the number of characters in the buffer.
1701 * Exit immediately if none.
1702 */
1718 }
1720 /*
1721 * If the device is not open, or CREAD is off, flush
1722 * input data and return immediately.
1723 */
1735 }
1737 /*
1738 * If we are throttled, simply don't read any data.
1739 */
1745 }
1747 /*
1748 * Ignore oruns.
1749 */
1754 }
1756 /* Decide how much data we can send into the tty layer */
1759 /* Chop down the length, if needed */
1765 #ifdef TTY_DONT_FLIP
1766 /*
1767 * If the DONT_FLIP flag is on, don't flush our buffer, and act
1768 * like the ld doesn't have any space to put the data right now.
1769 */
1772 #endif
1774 /*
1775 * If we were unable to get a reference to the ld,
1776 * don't flush our buffer, and act like the ld doesn't
1777 * have any space to put the data right now.
1778 */
1782 /*
1783 * If ld doesn't have a pointer to a receive_buf function,
1784 * flush the data, then act like the ld doesn't have any
1785 * space to put the data right now.
1786 */
1790 }
1791 }
1800 }
1805 /*
1806 * n now contains the most amount of data we can copy,
1807 * bounded either by our buffer size or the amount
1808 * of data the card actually has pending...
1809 */
1825 /* Flip queue if needed */
1827 }
1833 /*
1834 * If we are completely raw, we don't need to go through a lot
1835 * of the tty layers that exist.
1836 * In this case, we take the shortest and fastest route we
1837 * can to relay the data to the user.
1838 *
1839 * On the other hand, if we are not raw, we need to go through
1840 * the tty layer, which has its API more well defined.
1841 */
1852 }
1857 /* Tell the tty layer its okay to "eat" the data now */
1863 }
1865 /************************************************************************
1866 * Determines when CARRIER changes state and takes appropriate
1867 * action.
1868 ************************************************************************/
1870 {
1884 /* Make sure altpin is always set correctly */
1891 }
1902 /*
1903 * Test for a VIRTUAL carrier transition to HIGH.
1904 */
1907 /*
1908 * When carrier rises, wake any threads waiting
1909 * for carrier in the open routine.
1910 */
1914 }
1916 /*
1917 * Test for a PHYSICAL carrier transition to HIGH.
1918 */
1921 /*
1922 * When carrier rises, wake any threads waiting
1923 * for carrier in the open routine.
1924 */
1928 }
1930 /*
1931 * Test for a PHYSICAL transition to low, so long as we aren't
1932 * currently ignoring physical transitions (which is what "virtual
1933 * carrier" indicates).
1934 *
1935 * The transition of the virtual carrier to low really doesn't
1936 * matter... it really only means "ignore carrier state", not
1937 * "make pretend that carrier is there".
1938 */
1943 /*
1944 * When carrier drops:
1945 *
1946 * Drop carrier on all open units.
1947 *
1948 * Flush queues, waking up any task waiting in the
1949 * line discipline.
1950 *
1951 * Send a hangup to the control terminal.
1952 *
1953 * Enable all select calls.
1954 */
1963 }
1965 /*
1966 * Make sure that our cached values reflect the current reality.
1967 */
1970 else
1975 else
1977 }
1979 /************************************************************************
1980 *
1981 * TTY Entry points and helper functions
1982 *
1983 ************************************************************************/
1985 /*
1986 * dgap_tty_open()
1987 *
1988 */
1990 {
1998 ulong lock_flags;
1999 ulong lock_flags2;
2000 u16 head;
2010 /* Get board pointer from our array of majors we have allocated */
2015 /*
2016 * If board is not yet up to a state of READY, go to
2017 * sleep waiting for it to happen or they cancel the open.
2018 */
2027 /* The wait above should guarantee this cannot happen */
2031 }
2033 /* If opened device is greater than our number of ports, bail. */
2037 }
2043 }
2045 /* Grab channel lock */
2048 /* Figure out our type */
2059 }
2061 /* Store our unit into driver_data, so we always have it available. */
2064 /*
2065 * Error if channel info pointer is NULL.
2066 */
2072 }
2074 /*
2075 * Initialize tty's
2076 */
2078 /* Store important variables. */
2081 /* Maybe do something here to the TTY struct as well? */
2082 }
2084 /*
2085 * Initialize if neither terminal or printer is open.
2086 */
2092 /*
2093 * Flush input queue.
2094 */
2109 /* TODO: flush our TTY struct here? */
2110 }
2113 /*
2114 * Run param in case we changed anything
2115 */
2118 /*
2119 * follow protocol for opening port
2120 */
2130 /* No going back now, increment our unit and channel counters */
2138 }
2140 /*
2141 * dgap_block_til_ready()
2142 *
2143 * Wait for DCD, if needed.
2144 */
2147 {
2150 ulong lock_flags;
2166 /* Loop forever */
2171 /*
2172 * If board has failed somehow during our sleep,
2173 * bail with error.
2174 */
2178 }
2180 /* If tty was hung up, break out of loop and set error. */
2184 }
2186 /*
2187 * If either unit is in the middle of the fragile part of close,
2188 * we just cannot touch the channel safely.
2189 * Go back to sleep, knowing that when the channel can be
2190 * touched safely, the close routine will signal the
2191 * ch_wait_flags to wake us back up.
2192 */
2194 UN_CLOSING)) {
2196 /*
2197 * Our conditions to leave cleanly and happily:
2198 * 1) NONBLOCKING on the tty is set.
2199 * 2) CLOCAL is set.
2200 * 3) DCD (fake or real) is active.
2201 */
2216 }
2218 /*
2219 * If there is a signal pending, the user probably
2220 * interrupted (ctrl-c) us.
2221 * Leave loop with error set.
2222 */
2226 }
2228 /*
2229 * Store the flags before we let go of channel lock
2230 */
2233 else
2236 /*
2237 * Let go of channel lock before calling schedule.
2238 * Our poller will get any FEP events and wake us up when DCD
2239 * eventually goes active.
2240 */
2244 /*
2245 * Wait for something in the flags to change
2246 * from the current value.
2247 */
2255 }
2257 /*
2258 * We got woken up for some reason.
2259 * Before looping around, grab our channel lock.
2260 */
2262 }
2272 }
2274 /*
2275 * dgap_tty_hangup()
2276 *
2277 * Hangup the port. Like a close, but don't wait for output to drain.
2278 */
2280 {
2300 /* flush the transmit queues */
2303 }
2305 /*
2306 * dgap_tty_close()
2307 *
2308 */
2310 {
2315 ulong lock_flags;
2337 /*
2338 * Determine if this is the last close or not - and if we agree about
2339 * which type of close it is with the Line Discipline
2340 */
2342 /*
2343 * Uh, oh. tty->count is 1, which means that the tty
2344 * structure will be freed. un_open_count should always
2345 * be one in these conditions. If it's greater than
2346 * one, we've got real problems, since it means the
2347 * serial port won't be shutdown.
2348 */
2350 }
2360 }
2362 /* OK, its the last close on the unit */
2368 /*
2369 * Only officially close channel if count is 0 and
2370 * DIGI_PRINTER bit is not set.
2371 */
2379 /* wait for output to drain */
2380 /* This will also return if we take an interrupt */
2391 /*
2392 * If we have HUPCL set, lower DTR and RTS
2393 */
2398 /*
2399 * Go to sleep to ensure RTS/DTR
2400 * have been dropped for modems to see it.
2401 */
2406 }
2407 }
2413 }
2415 /*
2416 * turn off print device when closing print device.
2417 */
2422 }
2432 }
2434 /*
2435 * dgap_tty_chars_in_buffer()
2436 *
2437 * Return number of characters that have not been transmitted yet.
2438 *
2439 * This routine is used by the line discipline to determine if there
2440 * is data waiting to be transmitted/drained/flushed or not.
2441 */
2443 {
2448 uchar tbusy;
2478 /* Get Transmit queue pointers */
2482 /* Get tbusy flag */
2485 /* Get Command queue pointers */
2492 /*
2493 * The only way we know for sure if there is no pending
2494 * data left to be transferred, is if:
2495 * 1) Transmit head and tail are equal (empty).
2496 * 2) Command queue head and tail are equal (empty).
2497 * 3) The "TBUSY" flag is 0. (Transmitter not busy).
2498 */
2505 else
2507 /*
2508 * Fudge factor here.
2509 * If chars is zero, we know that the command queue had
2510 * something in it or tbusy was set. Because we cannot
2511 * be sure if there is still some data to be transmitted,
2512 * lets lie, and tell ld we have 1 byte left.
2513 */
2515 /*
2516 * If TBUSY is still set, and our tx buffers are empty,
2517 * force the firmware to send me another wakeup after
2518 * TBUSY has been cleared.
2519 */
2525 }
2527 }
2528 }
2531 }
2534 {
2559 /* Loop until data is drained */
2567 /* Set flag waiting for drain */
2573 /* Go to sleep till we get woken up */
2576 /* If ret is non-zero, user ctrl-c'ed us */
2579 }
2586 }
2588 /*
2589 * dgap_maxcps_room
2590 *
2591 * Reduces bytes_available to the max number of characters
2592 * that can be sent currently given the maxcps value, and
2593 * returns the new bytes_available. This only affects printer
2594 * output.
2595 */
2597 {
2612 /*
2613 * If its not the Transparent print device, return
2614 * the full data amount.
2615 */
2627 /* buffer is empty */
2631 /* still room in the buffer */
2635 /* no room in the buffer */
2637 }
2640 }
2643 }
2646 {
2663 }
2664 }
2669 }
2670 }
2671 }
2673 /*
2674 * dgap_tty_write_room()
2675 *
2676 * Return space available in Tx buffer
2677 */
2679 {
2712 /* Limit printer to maxcps */
2715 /*
2716 * If we are printer device, leave space for
2717 * possibly both the on and off strings.
2718 */
2726 }
2731 /*
2732 * Schedule FEP to wake us up if needed.
2733 *
2734 * TODO: This might be overkill...
2735 * Do we really need to schedule callbacks from the FEP
2736 * in every case? Can we get smarter based on ret?
2737 */
2742 }
2744 /*
2745 * dgap_tty_put_char()
2746 *
2747 * Put a character into ch->ch_buf
2748 *
2749 * - used by the line discipline for OPOST processing
2750 */
2752 {
2753 /*
2754 * Simply call tty_write.
2755 */
2758 }
2760 /*
2761 * dgap_tty_write()
2762 *
2763 * Take data from the user or kernel and send it out to the FEP.
2764 * In here exists all the Transparent Print magic as well.
2765 */
2768 {
2776 ulong lock_flags;
2796 /*
2797 * Store original amount of characters passed in.
2798 * This helps to figure out if we should ask the FEP
2799 * to send us an event when it has more space available.
2800 */
2805 /* Get our space available for the channel from the board */
2814 /*
2815 * Limit printer output to maxcps overall, with bursts allowed
2816 * up to bufsize characters.
2817 */
2820 /*
2821 * Take minimum of what the user wants to send, and the
2822 * space available in the FEP buffer.
2823 */
2826 /*
2827 * Bail if no space left.
2828 */
2833 }
2835 /*
2836 * Output the printer ON string, if we are in terminal mode, but
2837 * need to be in printer mode.
2838 */
2844 }
2846 /*
2847 * On the other hand, output the printer OFF string, if we are
2848 * currently in printer mode, but need to output to the terminal.
2849 */
2855 }
2857 /*
2858 * If there is nothing left to copy, or
2859 * I can't handle any more data, leave.
2860 */
2865 }
2869 /*
2870 * If the write wraps over the top of the circular buffer,
2871 * move the portion up to the wrap point, and reset the
2872 * pointers to the bottom.
2873 */
2882 remain);
2886 }
2890 /*
2891 * Move rest of data.
2892 */
2898 remain);
2902 }
2908 }
2912 /*
2913 * If this is the print device, and the
2914 * printer is still on, we need to turn it
2915 * off before going idle. If the buffer is
2916 * non-empty, wait until it goes empty.
2917 * Otherwise turn it off right now.
2918 */
2930 }
2931 }
2933 /* Update printer buffer empty time. */
2937 }
2942 }
2944 /*
2945 * Return modem signals to ld.
2946 */
2948 {
2953 ulong lock_flags;
2969 /* Append any outbound signals that might be pending... */
2990 }
2992 /*
2993 * dgap_tty_tiocmset()
2994 *
2995 * Set modem signals, called by ld.
2996 */
2999 {
3004 ulong lock_flags;
3005 ulong lock_flags2;
3028 }
3033 }
3038 }
3043 }
3051 }
3053 /*
3054 * dgap_tty_send_break()
3055 *
3056 * Send a Break, called by ld.
3057 */
3059 {
3064 ulong lock_flags;
3065 ulong lock_flags2;
3092 }
3096 #if 0
3098 #endif
3105 }
3107 /*
3108 * dgap_tty_wait_until_sent()
3109 *
3110 * wait until data has been transmitted, called by ld.
3111 */
3113 {
3115 }
3117 /*
3118 * dgap_send_xchar()
3119 *
3120 * send a high priority character, called by ld.
3121 */
3123 {
3127 ulong lock_flags;
3128 ulong lock_flags2;
3148 /*
3149 * This is technically what we should do.
3150 * However, the NIST tests specifically want
3151 * to see each XON or XOFF character that it
3152 * sends, so lets just send each character
3153 * by hand...
3154 */
3155 #if 0
3160 else
3162 #else
3164 #endif
3170 }
3172 /*
3173 * Return modem signals to ld.
3174 */
3176 {
3179 ulong lock_flags;
3188 /* Append any outbound signals that might be pending... */
3211 }
3213 /*
3214 * dgap_set_modem_info()
3215 *
3216 * Set modem signals, called by ld.
3217 */
3220 {
3226 ulong lock_flags;
3227 ulong lock_flags2;
3253 }
3258 }
3266 }
3271 }
3280 else
3285 else
3292 }
3303 }
3305 /*
3306 * dgap_tty_digigeta()
3307 *
3308 * Ioctl to get the information for ditty.
3309 *
3310 *
3311 *
3312 */
3315 {
3319 ulong lock_flags;
3345 }
3347 /*
3348 * dgap_tty_digiseta()
3349 *
3350 * Ioctl to set the information for ditty.
3351 *
3352 *
3353 *
3354 */
3357 {
3415 }
3417 /*
3418 * dgap_tty_digigetedelay()
3419 *
3420 * Ioctl to get the current edelay setting.
3421 *
3422 *
3423 *
3424 */
3426 {
3430 ulong lock_flags;
3456 }
3458 /*
3459 * dgap_tty_digisetedelay()
3460 *
3461 * Ioctl to set the EDELAY setting
3462 *
3463 */
3465 {
3470 ulong lock_flags;
3471 ulong lock_flags2;
3502 }
3504 /*
3505 * dgap_tty_digigetcustombaud()
3506 *
3507 * Ioctl to get the current custom baud rate setting.
3508 */
3511 {
3515 ulong lock_flags;
3541 }
3543 /*
3544 * dgap_tty_digisetcustombaud()
3545 *
3546 * Ioctl to set the custom baud rate setting
3547 */
3550 {
3554 uint new_rate;
3555 ulong lock_flags;
3556 ulong lock_flags2;
3588 }
3591 }
3593 /*
3594 * dgap_set_termios()
3595 */
3598 {
3635 }
3638 {
3642 ulong lock_flags;
3643 ulong lock_flags2;
3664 #if 1
3666 #endif
3671 }
3674 {
3678 ulong lock_flags;
3679 ulong lock_flags2;
3701 #if 1
3703 #endif
3707 }
3710 {
3714 ulong lock_flags;
3715 ulong lock_flags2;
3740 }
3743 {
3747 ulong lock_flags;
3748 ulong lock_flags2;
3773 }
3775 /*
3776 * dgap_tty_flush_chars()
3777 *
3778 * Flush the cook buffer
3779 *
3780 * Note to self, and any other poor souls who venture here:
3781 *
3782 * flush in this case DOES NOT mean dispose of the data.
3783 * instead, it means "stop buffering and send it if you
3784 * haven't already." Just guess how I figured that out... SRW 2-Jun-98
3785 *
3786 * It is also always called in interrupt context - JAR 8-Sept-99
3787 */
3789 {
3793 ulong lock_flags;
3794 ulong lock_flags2;
3814 /* TODO: Do something here */
3818 }
3820 /*
3821 * dgap_tty_flush_buffer()
3822 *
3823 * Flush Tx buffer (make in == out)
3824 */
3826 {
3830 ulong lock_flags;
3831 ulong lock_flags2;
3859 }
3863 }
3870 }
3872 /*****************************************************************************
3873 *
3874 * The IOCTL function and all of its helpers
3875 *
3876 *****************************************************************************/
3878 /*
3879 * dgap_tty_ioctl()
3880 *
3881 * The usual assortment of ioctl's
3882 */
3885 {
3917 }
3921 /* Here are all the standard ioctl's that we MUST implement */
3924 /*
3925 * TCSBRK is SVID version: non-zero arg --> no break
3926 * this behaviour is exploited by tcdrain().
3927 *
3928 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
3929 * between 0.25 and 0.5 seconds so we'll ask for something
3930 * in the middle: 0.375 seconds.
3931 */
3955 /* support for POSIX tcsendbreak()
3957 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
3958 * between 0.25 and 0.5 seconds so we'll ask for something
3959 * in the middle: 0.375 seconds.
3960 */
3982 /*
3983 * FEP5 doesn't support turning on a break unconditionally.
3984 * The FEP5 device will stop sending a break automatically
3985 * after the specified time value that was sent when turning on
3986 * the break.
3987 */
4009 /*
4010 * FEP5 doesn't support turning off a break unconditionally.
4011 * The FEP5 device will stop sending a break automatically
4012 * after the specified time value that was sent when turning on
4013 * the break.
4014 */
4058 /*
4059 * Here are any additional ioctl's that we want to implement
4060 */
4063 /*
4064 * The linux tty driver doesn't have a flush
4065 * input routine for the driver, assuming all backed
4066 * up data is in the line disc. buffers. However,
4067 * we all know that's not the case. Here, we
4068 * act on the ioctl, but then lie and say we didn't
4069 * so the line discipline will process the flush
4070 * also.
4071 */
4077 }
4084 }
4085 }
4095 }
4099 }
4103 /* Can't hold any locks when calling tty_wakeup! */
4109 }
4111 /* pretend we didn't recognize this IOCTL */
4119 /*
4120 * The linux tty driver doesn't have a flush
4121 * input routine for the driver, assuming all backed
4122 * up data is in the line disc. buffers. However,
4123 * we all know that's not the case. Here, we
4124 * act on the ioctl, but then lie and say we didn't
4125 * so the line discipline will process the flush
4126 * also.
4127 */
4129 /* flush rx */
4133 }
4135 /* now wait for all the output to drain */
4142 /* pretend we didn't recognize this */
4153 /* pretend we didn't recognize this */
4157 /*
4158 * The Linux Line Discipline (LD) would do this for us if we
4159 * let it, but we have the special firmware options to do this
4160 * the "right way" regardless of hardware or software flow
4161 * control so we'll do it outselves instead of letting the LD
4162 * do it.
4163 */
4169 }
4186 /* Make the ld do it */
4191 /* Make the ld do it */
4197 }
4200 /* get information for ditty */
4208 /* set information for ditty */
4220 /* fall thru */
4259 }
4260 }
4263 {
4264 /*
4265 * Initialize KME waitqueues...
4266 */
4269 /*
4270 * allocate flip buffer for board.
4271 */
4280 }
4283 }
4285 /*
4286 * Create pr and tty device entries
4287 */
4289 {
4294 GFP_KERNEL);
4301 GFP_KERNEL);
4305 }
4327 }
4331 }
4333 /*
4334 * Copies the BIOS code from the user to the board,
4335 * and starts the BIOS running.
4336 */
4338 {
4340 uint offset;
4348 /*
4349 * clear POST area
4350 */
4354 /*
4355 * Download bios
4356 */
4363 /* Clear the reset, and change states. */
4365 }
4367 /*
4368 * Checks to see if the BIOS completed running on the card.
4369 */
4371 {
4373 u16 word;
4374 u16 err1;
4375 u16 err2;
4383 /*
4384 * It can take 5-6 seconds for a board to
4385 * pass the bios self test and post results.
4386 * Give it 10 seconds.
4387 */
4390 /* Check to see if BIOS thinks board is good. (GD). */
4394 }
4398 }
4400 /* Gave up on board after too long of time taken */
4407 }
4409 /*
4410 * Copies the FEP code from the user to the board,
4411 * and starts the FEP running.
4412 */
4414 {
4416 uint offset;
4423 /*
4424 * Download FEP
4425 */
4429 /*
4430 * If board is a concentrator product, we need to give
4431 * it its config string describing how the concentrators look.
4432 */
4440 /* Write string to board memory */
4446 }
4447 }
4452 }
4454 /*
4455 * Waits for the FEP to report thats its ready for us to use.
4456 */
4458 {
4460 u16 word;
4461 u16 err1;
4462 u16 err2;
4470 /*
4471 * It can take 2-3 seconds for the FEP to
4472 * be up and running. Give it 5 secs.
4473 */
4476 /* Check to see if FEP is up and running now. */
4479 /*
4480 * Check to see if the board can support FEP5+ commands.
4481 */
4487 }
4491 }
4493 /* Gave up on board after too long of time taken */
4500 }
4502 /*
4503 * Physically forces the FEP5 card to reset itself.
4504 */
4506 {
4507 uchar check;
4508 u32 check1;
4509 u32 check2;
4516 /* FEPRST does not vary among supported boards */
4525 }
4531 }
4533 /*
4534 * Make sure there really is memory out there.
4535 */
4547 }
4551 }
4553 #ifdef DIGI_CONCENTRATORS_SUPPORTED
4554 /*
4555 * Sends a concentrator image into the FEP5 board.
4556 */
4558 {
4572 /* Tell card we have data for it */
4576 }
4577 #endif
4579 #define EXPANSION_ROM_SIZE (64 * 1024)
4580 #define FEP5_ROM_MAGIC (0xFEFFFFFF)
4583 {
4584 u32 magic;
4585 u32 base_offset;
4586 u16 rom_offset;
4587 u16 vpd_offset;
4588 u16 image_length;
4589 u16 i;
4590 uchar byte1;
4591 uchar byte2;
4593 /*
4594 * Poke the magic number at the PCI Rom Address location.
4595 * If VPD is supported, the value read from that address
4596 * will be non-zero.
4597 */
4602 /* VPD not supported, bail */
4606 /*
4607 * To get to the OTPROM memory, we have to send the boards base
4608 * address or'ed with 1 into the PCI Rom Address location.
4609 */
4617 /*
4618 * If the board correctly swapped to the OTPROM memory,
4619 * the first 2 bytes (header) should be 0x55, 0xAA
4620 */
4625 /*
4626 * We have to run through all the OTPROM memory looking
4627 * for the VPD offset.
4628 */
4631 /*
4632 * Lots of magic numbers here.
4633 *
4634 * The VPD offset is located inside the ROM Data
4635 * Structure.
4636 *
4637 * We also have to remember the length of each
4638 * ROM Data Structure, so we can "hop" to the next
4639 * entry if the VPD isn't in the current
4640 * ROM Data Structure.
4641 */
4649 /* Found the VPD entry */
4653 /* We didn't find a VPD entry, go to next ROM entry. */
4659 /*
4660 * If the new ROM offset doesn't have 0x55, 0xAA
4661 * as its header, we have run out of ROM.
4662 */
4665 }
4667 /*
4668 * If we have a VPD offset, then mark the board
4669 * as having a valid VPD, and copy VPDSIZE (512) bytes of
4670 * that VPD to the buffer we have in our board structure.
4671 */
4677 }
4678 }
4679 }
4681 /*
4682 * We MUST poke the magic number at the PCI Rom Address location again.
4683 * This makes the card report the regular board memory back to us,
4684 * rather than the OTPROM memory.
4685 */
4688 }
4690 /*
4691 * Our board poller function.
4692 */
4694 {
4696 ulong lock_flags;
4697 ulong lock_flags2;
4711 /*
4712 * If board is ready, parse deeper to see if there is anything to do.
4713 */
4721 }
4725 }
4732 /* Get our head and tail */
4736 /*
4737 * If there is an event pending. Go service it.
4738 */
4743 }
4745 out:
4746 /*
4747 * If board is doing interrupts, ACK the interrupt.
4748 */
4754 }
4756 /* Our state machine to get the board up and running */
4758 /* Reset board */
4761 /* Get VPD info */
4765 }
4767 /* Move to next state */
4772 /*
4773 * Match this board to a config the user created for us.
4774 */
4778 /*
4779 * Because the 4 port Xr products share the same PCI ID
4780 * as the 8 port Xr products, if we receive a NULL config
4781 * back, and this is a PAPORT8 board, retry with a
4782 * PAPORT4 attempt as well.
4783 */
4788 /*
4789 * Register the ttys (if any) into the kernel.
4790 */
4793 else
4795 }
4797 /* Move to next state */
4801 /* Move to next state */
4803 /*
4804 * Signal downloader, its got some work to do.
4805 */
4810 }
4812 }
4814 /* Move to next state */
4818 /* Move to next state */
4820 /*
4821 * Signal downloader, its got some work to do.
4822 */
4827 }
4829 }
4831 /* Wait for BIOS to test board... */
4835 /* Move to next state */
4839 /*
4840 * Signal downloader, its got some work to do.
4841 */
4846 }
4848 }
4850 /* Wait for FEP to load on board... */
4854 /* Move to next state */
4857 /*
4858 * Do tty device initialization.
4859 */
4869 /*
4870 * Signal downloader, its got some work to do.
4871 */
4876 }
4878 }
4879 }
4881 /* Move to next state */
4887 /*
4888 * If user requested the board to run in interrupt mode,
4889 * go and set it up on the board.
4890 */
4893 /*
4894 * Tell the board to poll the UARTS as fast as possible.
4895 */
4898 }
4900 /* Wake up anyone waiting for board state to change to ready */
4902 }
4905 }
4907 /*=======================================================================
4908 *
4909 * dgap_cmdb - Sends a 2 byte command to the FEP.
4910 *
4911 * ch - Pointer to channel structure.
4912 * cmd - Command to be sent.
4913 * byte1 - Integer containing first byte to be sent.
4914 * byte2 - Integer containing second byte to be sent.
4915 * ncmds - Wait until ncmds or fewer cmds are left
4916 * in the cmd buffer before returning.
4917 *
4918 *=======================================================================*/
4921 {
4924 uint count;
4925 uint n;
4926 u16 head;
4927 u16 tail;
4932 /*
4933 * Check if board is still alive.
4934 */
4938 /*
4939 * Make sure the pointers are in range before
4940 * writing to the FEP memory.
4941 */
4950 /*
4951 * Forget it if pointers out of range.
4952 */
4956 }
4958 /*
4959 * Put the data in the circular command buffer.
4960 */
4970 /*
4971 * Wait if necessary before updating the head
4972 * pointer to limit the number of outstanding
4973 * commands to the FEP. If the time spent waiting
4974 * is outlandish, declare the FEP dead.
4975 */
4989 }
4991 }
4992 }
4994 /*=======================================================================
4995 *
4996 * dgap_cmdw - Sends a 1 word command to the FEP.
4997 *
4998 * ch - Pointer to channel structure.
4999 * cmd - Command to be sent.
5000 * word - Integer containing word to be sent.
5001 * ncmds - Wait until ncmds or fewer cmds are left
5002 * in the cmd buffer before returning.
5003 *
5004 *=======================================================================*/
5006 {
5009 uint count;
5010 uint n;
5011 u16 head;
5012 u16 tail;
5017 /*
5018 * Check if board is still alive.
5019 */
5023 /*
5024 * Make sure the pointers are in range before
5025 * writing to the FEP memory.
5026 */
5034 /*
5035 * Forget it if pointers out of range.
5036 */
5040 }
5042 /*
5043 * Put the data in the circular command buffer.
5044 */
5053 /*
5054 * Wait if necessary before updating the head
5055 * pointer to limit the number of outstanding
5056 * commands to the FEP. If the time spent waiting
5057 * is outlandish, declare the FEP dead.
5058 */
5072 }
5074 }
5075 }
5077 /*=======================================================================
5078 *
5079 * dgap_cmdw_ext - Sends a extended word command to the FEP.
5080 *
5081 * ch - Pointer to channel structure.
5082 * cmd - Command to be sent.
5083 * word - Integer containing word to be sent.
5084 * ncmds - Wait until ncmds or fewer cmds are left
5085 * in the cmd buffer before returning.
5086 *
5087 *=======================================================================*/
5089 {
5092 uint count;
5093 uint n;
5094 u16 head;
5095 u16 tail;
5100 /*
5101 * Check if board is still alive.
5102 */
5106 /*
5107 * Make sure the pointers are in range before
5108 * writing to the FEP memory.
5109 */
5117 /*
5118 * Forget it if pointers out of range.
5119 */
5123 }
5125 /*
5126 * Put the data in the circular command buffer.
5127 */
5129 /* Write an FF to tell the FEP that we want an extended command */
5135 /*
5136 * If the second part of the command won't fit,
5137 * put it at the beginning of the circular buffer.
5138 */
5141 else
5148 /*
5149 * Wait if necessary before updating the head
5150 * pointer to limit the number of outstanding
5151 * commands to the FEP. If the time spent waiting
5152 * is outlandish, declare the FEP dead.
5153 */
5167 }
5169 }
5170 }
5172 /*=======================================================================
5173 *
5174 * dgap_wmove - Write data to FEP buffer.
5175 *
5176 * ch - Pointer to channel structure.
5177 * buf - Poiter to characters to be moved.
5178 * cnt - Number of characters to move.
5179 *
5180 *=======================================================================*/
5182 {
5186 u16 head;
5191 /*
5192 * Check parameters.
5193 */
5197 /*
5198 * If pointers are out of range, just return.
5199 */
5204 /*
5205 * If the write wraps over the top of the circular buffer,
5206 * move the portion up to the wrap point, and reset the
5207 * pointers to the bottom.
5208 */
5217 }
5219 /*
5220 * Move rest of data.
5221 */
5228 }
5230 /*
5231 * Retrives the current custom baud rate from FEP memory,
5232 * and returns it back to the user.
5233 * Returns 0 on error.
5234 */
5236 {
5255 /*
5256 * Go get from fep mem, what the fep
5257 * believes the custom baud rate is.
5258 */
5264 }
5266 /*
5267 * Calls the firmware to reset this channel.
5268 */
5270 {
5273 /*
5274 * Now that the channel is reset, we need to make sure
5275 * all the current settings get reapplied to the port
5276 * in the firmware.
5277 *
5278 * So we will set the driver's cache of firmware
5279 * settings all to 0, and then call param.
5280 */
5290 }
5292 /*=======================================================================
5293 *
5294 * dgap_param - Set Digi parameters.
5295 *
5296 * struct tty_struct * - TTY for port.
5297 *
5298 *=======================================================================*/
5300 {
5306 u16 head;
5307 u16 cflag;
5308 u16 iflag;
5309 uchar mval;
5310 uchar hflow;
5333 /*
5334 * If baud rate is zero, flush queues, and set mval to drop DTR.
5335 */
5338 /* flush rx */
5342 /* flush tx */
5348 /* Drop RTS and DTR */
5354 /*
5355 * Tell the fep to do the command
5356 */
5360 /*
5361 * Now go get from fep mem, what the fep
5362 * believes the custom baud rate is.
5363 */
5367 /* Handle transition from B0 */
5371 }
5375 /*
5376 * Set baud rate, character size, and parity.
5377 */
5405 };
5407 /*
5408 * Only use the TXPrint baud rate if the
5409 * terminal unit is NOT open
5410 */
5414 else
5428 else
5436 /*
5437 * CBAUD has bit position 0x1000 set these days to
5438 * indicate Linux baud rate remap.
5439 * We use a different bit assignment for high speed.
5440 * Clear this bit out while grabbing the parts of
5441 * "cflag" we want.
5442 */
5446 /*
5447 * HUPCL bit is used by FEP to indicate fast baud
5448 * table is to be used.
5449 */
5456 /*
5457 * The below code is trying to guarantee that only
5458 * baud rates 115200, 230400, 460800, 921600 are
5459 * remapped. We use exclusive or because the various
5460 * baud rates share common bit positions and therefore
5461 * can't be tested for easily.
5462 */
5466 /*
5467 * Map high speed requests to index
5468 * into FEP's baud table
5469 */
5474 #ifdef B76800
5478 #endif
5488 #ifdef B921600
5492 #endif
5495 }
5499 }
5506 /*
5507 * Okay to have channel and board
5508 * locks held calling this
5509 */
5511 }
5513 /* Handle transition from B0 */
5517 }
5519 }
5521 /*
5522 * Get input flags.
5523 */
5531 }
5533 /*
5534 * Only the IBM Xr card can switch between
5535 * 232 and 422 modes on the fly
5536 */
5540 else
5542 }
5550 /* Okay to have channel and board locks held calling this */
5552 }
5554 /*
5555 * Select hardware handshaking.
5556 */
5575 /* Okay to have channel and board locks held calling this */
5577 }
5580 /*
5581 * Set RTS and/or DTR Toggle if needed,
5582 * but only if product is FEP5+ based.
5583 */
5592 }
5594 /*
5595 * Set modem control lines.
5596 */
5603 /* Okay to have channel and board locks held calling this */
5605 }
5607 /*
5608 * Read modem signals, and then call carrier function.
5609 */
5613 /*
5614 * Set the start and stop characters.
5615 */
5621 /* Okay to have channel and board locks held calling this */
5623 }
5625 /*
5626 * Set the Auxiliary start and stop characters.
5627 */
5633 /* Okay to have channel and board locks held calling this */
5635 }
5638 }
5640 /*
5641 * dgap_parity_scan()
5642 *
5643 * Convert the FEP5 way of reporting parity errors and breaks into
5644 * the Linux line discipline way.
5645 */
5648 {
5665 /* reset to sanity and fall through */
5669 /* No FF seen yet */
5671 /* delete this character from stream */
5677 }
5681 /* first FF seen */
5683 /* doubled ff, transform to single ff */
5689 /* save value examination in next state */
5692 }
5696 /* third character of ff sequence */
5708 }
5709 }
5713 }
5714 }
5716 }
5718 /*=======================================================================
5719 *
5720 * dgap_event - FEP to host event processing routine.
5721 *
5722 * bd - Board of current event.
5723 *
5724 *=======================================================================*/
5726 {
5728 ulong lock_flags;
5729 ulong lock_flags2;
5734 uint head;
5735 uint tail;
5751 }
5755 /* Get our head and tail */
5759 /*
5760 * Forget it if pointers out of range.
5761 */
5765 /* Let go of board lock */
5768 }
5770 /*
5771 * Loop to process all the events in the buffer.
5772 */
5775 /*
5776 * Get interrupt information.
5777 */
5786 /*
5787 * Make sure the interrupt is valid.
5788 */
5800 /*
5801 * If we have made it here, the event was valid.
5802 * Lock down the channel.
5803 */
5811 }
5813 /*
5814 * Process received data.
5815 */
5818 /*
5819 * ALL LOCKS *MUST* BE DROPPED BEFORE CALLING INPUT!
5820 * input could send some data to ld, which in turn
5821 * could do a callback to one of our other functions.
5822 */
5833 else
5840 }
5841 }
5843 /*
5844 * Process Modem change signals.
5845 */
5849 }
5851 /*
5852 * Process break.
5853 */
5857 /* A break has been indicated */
5862 }
5863 }
5865 /*
5866 * Process Transmit low.
5867 */
5882 }
5885 }
5886 }
5899 }
5902 }
5903 }
5908 }
5909 }
5911 /*
5912 * Process Transmit empty.
5913 */
5927 }
5930 }
5931 }
5944 }
5947 }
5948 }
5954 }
5955 }
5959 next:
5961 }
5967 }
5970 {
5972 }
5977 {
5979 }
5984 {
5986 }
5991 {
5993 }
5998 {
6000 }
6004 {
6006 }
6008 static ssize_t dgap_driver_pollrate_store(struct device_driver *ddp, const char *buf, size_t count)
6009 {
6013 }
6014 static DRIVER_ATTR(pollrate, (S_IRUSR | S_IWUSR), dgap_driver_pollrate_show, dgap_driver_pollrate_store);
6017 {
6029 }
6032 {
6040 }
6043 {
6054 }
6056 static ssize_t dgap_ports_state_show(struct device *p, struct device_attribute *attr, char *buf)
6057 {
6070 }
6072 }
6075 static ssize_t dgap_ports_baud_show(struct device *p, struct device_attribute *attr, char *buf)
6076 {
6088 }
6090 }
6093 static ssize_t dgap_ports_msignals_show(struct device *p, struct device_attribute *attr, char *buf)
6094 {
6113 else
6116 }
6118 }
6121 static ssize_t dgap_ports_iflag_show(struct device *p, struct device_attribute *attr, char *buf)
6122 {
6135 }
6138 static ssize_t dgap_ports_cflag_show(struct device *p, struct device_attribute *attr, char *buf)
6139 {
6152 }
6155 static ssize_t dgap_ports_oflag_show(struct device *p, struct device_attribute *attr, char *buf)
6156 {
6169 }
6172 static ssize_t dgap_ports_lflag_show(struct device *p, struct device_attribute *attr, char *buf)
6173 {
6186 }
6189 static ssize_t dgap_ports_digi_flag_show(struct device *p, struct device_attribute *attr, char *buf)
6190 {
6203 }
6206 static ssize_t dgap_ports_rxcount_show(struct device *p, struct device_attribute *attr, char *buf)
6207 {
6220 }
6223 static ssize_t dgap_ports_txcount_show(struct device *p, struct device_attribute *attr, char *buf)
6224 {
6237 }
6240 /* this function creates the sys files that will export each signal status
6241 * to sysfs each value will be put in a separate filename
6242 */
6244 {
6256 }
6258 /* removes all the sys files created for that port */
6260 {
6271 }
6274 {
6294 }
6298 {
6318 }
6321 static ssize_t dgap_tty_msignals_show(struct device *d, struct device_attribute *attr, char *buf)
6322 {
6349 }
6351 }
6355 {
6375 }
6379 {
6399 }
6403 {
6423 }
6427 {
6447 }
6450 static ssize_t dgap_tty_digi_flag_show(struct device *d, struct device_attribute *attr, char *buf)
6451 {
6471 }
6474 static ssize_t dgap_tty_rxcount_show(struct device *d, struct device_attribute *attr, char *buf)
6475 {
6495 }
6498 static ssize_t dgap_tty_txcount_show(struct device *d, struct device_attribute *attr, char *buf)
6499 {
6519 }
6523 {
6562 else
6564 }
6579 }
6580 }
6591 }
6594 }
6604 }
6608 }
6609 }
6614 }
6629 NULL
6630 };
6635 };
6638 {
6647 }
6650 {
6652 }
6654 /*
6655 * Parse a configuration file read into memory as a string.
6656 */
6658 {
6667 /* perhaps we are adding to an existing list? */
6671 /* file must start with a BEGIN */
6676 }
6677 }
6684 }
6705 }
6718 }
6727 }
6736 }
6745 }
6754 }
6763 }
6776 }
6789 }
6800 }
6805 }
6811 }
6819 }
6824 }
6830 }
6838 }
6843 }
6849 }
6855 }
6861 }
6869 }
6874 }
6883 }
6888 }
6898 }
6903 }
6910 }
6915 }
6922 }
6927 }
6932 }
6940 }
6953 }
6962 }
6967 }
6974 }
6979 }
6986 }
6991 }
6996 }
7006 }
7012 }
7017 }
7027 }
7033 }
7038 }
7047 }
7052 }
7057 }
7061 linecnt++;
7070 }
7075 }
7080 else
7089 }
7098 }
7109 }
7118 }
7119 }
7124 }
7128 else
7137 }
7146 }
7157 }
7160 }
7169 }
7174 }
7181 }
7186 }
7191 }
7200 }
7203 }
7212 }
7218 }
7223 }
7233 }
7239 }
7244 }
7254 }
7260 }
7265 }
7275 }
7281 }
7286 }
7296 }
7302 }
7307 }
7317 }
7323 }
7328 }
7338 }
7344 }
7349 }
7359 }
7365 }
7370 }
7380 }
7386 }
7391 }
7401 }
7407 }
7412 }
7414 }
7415 }
7416 }
7418 /*
7419 * dgap_sindex: much like index(), but it looks for a match of any character in
7420 * the group, and returns that position. If the first character is a ^, then
7421 * this will match the first occurrence not in that group.
7422 */
7424 {
7431 group++;
7436 }
7439 }
7445 }
7446 }
7447 }
7450 }
7452 /*
7453 * Get a token from the input file; return 0 if end of file is reached
7454 */
7456 {
7466 }
7475 }
7476 }
7478 }
7479 }
7481 /*
7482 * get a word from the input stream, also keep track of current line number.
7483 * words are separated by whitespace.
7484 */
7486 {
7491 /* If no word found, return null */
7495 /* Mark new location for our buffer */
7499 /* Eat any extra spaces/tabs/newlines that might be present */
7503 }
7506 }
7508 /*
7509 * print an error message, giving the line number in the file where
7510 * the error occurred.
7511 */
7513 {
7515 }
7517 /*
7518 * allocate a new configuration node of type t
7519 */
7521 {
7528 }
7530 }
7532 /*
7533 * dgap_checknode: see if all the necessary info has been supplied for a node
7534 * before creating the next node.
7535 */
7537 {
7543 }
7551 }
7558 }
7562 }
7566 }
7570 }
7577 }
7581 }
7585 }
7587 }
7589 }
7591 /*
7592 * save a string somewhere
7593 */
7595 {
7602 }
7604 /*
7605 * Given a board pointer, returns whether we should use interrupts or not.
7606 */
7608 {
7617 /*
7618 * check for pcxr types.
7619 */
7623 }
7624 }
7626 /* If not found, then don't turn on interrupts. */
7628 }
7630 /*
7631 * Given a board pointer, returns whether we turn on altpin or not.
7632 */
7634 {
7643 /*
7644 * check for pcxr types.
7645 */
7649 }
7650 }
7652 /* If not found, then don't turn on interrupts. */
7654 }
7656 /*
7657 * Given a specific type of board, if found, detached link and
7658 * returns the first occurrence in the list.
7659 */
7661 {
7682 /*
7683 * Keep walking thru the list till we find the next board.
7684 */
7690 /*
7691 * Mark the end of our 1 board chain of configs.
7692 */
7695 /*
7696 * Link the "next" board to the previous board,
7697 * effectively "unlinking" our board from the main config.
7698 */
7702 }
7703 }
7704 /*
7705 * It must be the last board in the list.
7706 */
7709 }
7710 }
7711 }
7713 }
7715 /*
7716 * Given a board pointer, walks the config link, counting up
7717 * all ports user specified should be on the board.
7718 * (This does NOT mean they are all actually present right now tho)
7719 */
7721 {
7732 /*
7733 * check for pcxr types.
7734 */
7744 }
7745 }
7747 }
7750 {
7759 }
7766 ptr++;
7768 ptr++;
7771 /*
7772 * Because the EPC/con concentrators can have EM modules
7773 * hanging off of them, we have to walk ahead in the list
7774 * and keep adding the number of ports on each EM to the config.
7775 * UGH!
7776 */
7781 ptr++;
7785 ptr++;
7788 }
7790 ptr++;
7793 ptr++;
7794 }
7797 ptr++;
7799 }
7800 }
7804 }