| blob | bad355100825d569834065a8b6e41aa3d0a2a44b |
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
46 #include <linux/kernel.h>
47 #include <linux/module.h>
48 #include <linux/pci.h>
50 #include <linux/slab.h>
51 #include <linux/uaccess.h>
52 #include <linux/sched.h>
55 #include <linux/ctype.h>
56 #include <linux/tty.h>
57 #include <linux/tty_flip.h>
58 #include <linux/serial_reg.h>
61 #include <linux/string.h>
62 #include <linux/device.h>
63 #include <linux/kdev_t.h>
64 #include <linux/firmware.h>
68 /*
69 * File operations permitted on Control/Management major.
70 */
73 };
85 /*
86 * Poller stuff
87 */
93 /*
94 SUPPORTED PRODUCTS
96 Card Model Number of Ports Interface
97 ----------------------------------------------------------------
98 Acceleport Xem 4 - 64 (EIA232 & EIA422)
99 Acceleport Xr 4 & 8 (EIA232)
100 Acceleport Xr 920 4 & 8 (EIA232)
101 Acceleport C/X 8 - 128 (EIA232)
102 Acceleport EPC/X 8 - 224 (EIA232)
103 Acceleport Xr/422 4 & 8 (EIA422)
104 Acceleport 2r/920 2 (EIA232)
105 Acceleport 4r/920 4 (EIA232)
106 Acceleport 8r/920 8 (EIA232)
108 IBM 8-Port Asynchronous PCI Adapter (EIA232)
109 IBM 128-Port Asynchronous PCI Adapter (EIA232 & EIA422)
110 */
129 };
132 /*
133 * A generic list of Product names, PCI Vendor ID, and PCI Device ID.
134 */
136 uint config_type;
138 uint maxports;
139 uint dpatype;
140 };
159 };
167 };
169 /*
170 * Firmware - BIOS, FEP, and CONC filenames
171 */
189 };
191 /*
192 * Default transparent print information.
193 */
204 };
206 /*
207 * Define a local default termios struct. All ports will be created
208 * with this termios initially.
209 *
210 * This defines a raw port at 9600 baud, 8 data bits, no parity,
211 * 1 stop bit.
212 */
221 };
223 /*
224 * Our needed internal static variables from dgap_parse.c
225 */
227 #define MAXCWORD 200
233 };
245 };
287 };
289 /*
290 * get a word from the input stream, also keep track of current line number.
291 * words are separated by whitespace.
292 */
294 {
299 /* If no word found, return null */
303 /* Mark new location for our buffer */
307 /* Eat any extra spaces/tabs/newlines that might be present */
313 }
316 }
319 /*
320 * Get a token from the input file; return 0 if end of file is reached
321 */
323 {
335 }
342 }
343 }
344 }
347 }
349 /*
350 * dgap_checknode: see if all the necessary info has been supplied for a node
351 * before creating the next node.
352 */
354 {
360 }
367 }
371 }
375 }
382 }
386 }
388 }
390 }
392 /*
393 * Given a board pointer, returns whether we should use interrupts or not.
394 */
396 {
404 /*
405 * check for pcxr types.
406 */
408 }
409 }
411 /* If not found, then don't turn on interrupts. */
413 }
415 /*
416 * Given a board pointer, returns whether we turn on altpin or not.
417 */
419 {
427 /*
428 * check for pcxr types.
429 */
431 }
432 }
434 /* If not found, then don't turn on interrupts. */
436 }
438 /*
439 * Given a specific type of board, if found, detached link and
440 * returns the first occurrence in the list.
441 */
443 {
467 /*
468 * Keep walking thru the list till we
469 * find the next board.
470 */
478 /*
479 * Mark the end of our 1 board
480 * chain of configs.
481 */
484 /*
485 * Link the "next" board to the
486 * previous board, effectively
487 * "unlinking" our board from
488 * the main config.
489 */
493 }
494 /*
495 * It must be the last board in the list.
496 */
499 }
501 }
503 /*
504 * Given a board pointer, walks the config link, counting up
505 * all ports user specified should be on the board.
506 * (This does NOT mean they are all actually present right now tho)
507 */
509 {
519 /*
520 * check for pcxr types.
521 */
531 }
532 }
534 }
537 {
546 }
552 ptr++;
554 ptr++;
557 /*
558 * Because the EPC/con concentrators can have EM modules
559 * hanging off of them, we have to walk ahead in the
560 * list and keep adding the number of ports on each EM
561 * to the config. UGH!
562 */
567 ptr++;
571 ptr++;
574 }
576 ptr++;
579 ptr++;
580 }
583 ptr++;
585 }
586 }
590 }
592 /*
593 * Parse a configuration file read into memory as a string.
594 */
596 {
605 /* perhaps we are adding to an existing list? */
609 /* file must start with a BEGIN */
614 }
615 }
626 }
656 }
666 }
671 }
677 }
685 }
690 }
696 }
702 }
708 }
716 }
721 }
731 }
736 }
747 }
751 }
758 }
762 }
769 }
773 }
778 }
786 }
801 }
810 }
814 }
821 }
825 }
832 }
836 }
841 }
859 }
881 }
894 }
899 }
909 linecnt++;
918 }
930 else
938 }
950 }
959 }
960 }
971 else
979 }
991 }
995 }
1004 }
1008 }
1015 }
1019 }
1024 }
1033 }
1037 }
1054 }
1076 }
1080 }
1098 }
1102 }
1119 }
1123 }
1141 }
1145 }
1163 }
1167 }
1185 }
1189 }
1207 }
1211 }
1229 }
1233 }
1251 }
1255 }
1257 }
1258 }
1259 }
1262 {
1273 }
1301 }
1306 }
1307 }
1309 /*
1310 * Retrives the current custom baud rate from FEP memory,
1311 * and returns it back to the user.
1312 * Returns 0 on error.
1313 */
1315 {
1317 ulong offset;
1333 /*
1334 * Go get from fep mem, what the fep
1335 * believes the custom baud rate is.
1336 */
1341 }
1343 /*
1344 * Remap PCI memory.
1345 */
1347 {
1367 err_remap_port:
1369 err_remap_mem:
1371 err_req_mem:
1375 }
1378 {
1383 }
1385 /*
1386 * dgap_parity_scan()
1387 *
1388 * Convert the FEP5 way of reporting parity errors and breaks into
1389 * the Linux line discipline way.
1390 */
1393 {
1410 /* reset to sanity and fall through */
1414 /* No FF seen yet */
1416 /* delete this character from stream */
1422 }
1426 /* first FF seen */
1428 /* doubled ff, transform to single ff */
1434 /* save value examination in next state */
1437 }
1441 /* third character of ff sequence */
1452 }
1453 }
1457 }
1458 }
1460 }
1462 /*=======================================================================
1463 *
1464 * dgap_input - Process received data.
1465 *
1466 * ch - Pointer to channel structure.
1467 *
1468 *=======================================================================*/
1471 {
1476 uint rmask;
1477 uint head;
1478 uint tail;
1480 ulong lock_flags;
1481 ulong lock_flags2;
1486 u8 tmpchar;
1505 /*
1506 * Figure the number of characters in the buffer.
1507 * Exit immediately if none.
1508 */
1524 }
1526 /*
1527 * If the device is not open, or CREAD is off, flush
1528 * input data and return immediately.
1529 */
1540 }
1542 /*
1543 * If we are throttled, simply don't read any data.
1544 */
1550 }
1552 /*
1553 * Ignore oruns.
1554 */
1559 }
1561 /* Decide how much data we can send into the tty layer */
1564 /* Chop down the length, if needed */
1570 #ifdef TTY_DONT_FLIP
1571 /*
1572 * If the DONT_FLIP flag is on, don't flush our buffer, and act
1573 * like the ld doesn't have any space to put the data right now.
1574 */
1577 #endif
1579 /*
1580 * If we were unable to get a reference to the ld,
1581 * don't flush our buffer, and act like the ld doesn't
1582 * have any space to put the data right now.
1583 */
1587 /*
1588 * If ld doesn't have a pointer to a receive_buf function,
1589 * flush the data, then act like the ld doesn't have any
1590 * space to put the data right now.
1591 */
1595 }
1596 }
1605 }
1610 /*
1611 * n now contains the most amount of data we can copy,
1612 * bounded either by our buffer size or the amount
1613 * of data the card actually has pending...
1614 */
1628 /* Flip queue if needed */
1630 }
1636 /*
1637 * If we are completely raw, we don't need to go through a lot
1638 * of the tty layers that exist.
1639 * In this case, we take the shortest and fastest route we
1640 * can to relay the data to the user.
1641 *
1642 * On the other hand, if we are not raw, we need to go through
1643 * the tty layer, which has its API more well defined.
1644 */
1655 }
1660 /* Tell the tty layer its okay to "eat" the data now */
1665 }
1671 {
1689 }
1692 }
1694 /************************************************************************
1695 * Determines when CARRIER changes state and takes appropriate
1696 * action.
1697 ************************************************************************/
1699 {
1713 /* Make sure altpin is always set correctly */
1720 }
1731 /*
1732 * Test for a VIRTUAL carrier transition to HIGH.
1733 */
1735 /*
1736 * When carrier rises, wake any threads waiting
1737 * for carrier in the open routine.
1738 */
1742 }
1744 /*
1745 * Test for a PHYSICAL carrier transition to HIGH.
1746 */
1748 /*
1749 * When carrier rises, wake any threads waiting
1750 * for carrier in the open routine.
1751 */
1755 }
1757 /*
1758 * Test for a PHYSICAL transition to low, so long as we aren't
1759 * currently ignoring physical transitions (which is what "virtual
1760 * carrier" indicates).
1761 *
1762 * The transition of the virtual carrier to low really doesn't
1763 * matter... it really only means "ignore carrier state", not
1764 * "make pretend that carrier is there".
1765 */
1769 /*
1770 * When carrier drops:
1771 *
1772 * Drop carrier on all open units.
1773 *
1774 * Flush queues, waking up any task waiting in the
1775 * line discipline.
1776 *
1777 * Send a hangup to the control terminal.
1778 *
1779 * Enable all select calls.
1780 */
1789 }
1791 /*
1792 * Make sure that our cached values reflect the current reality.
1793 */
1796 else
1801 else
1803 }
1805 /*=======================================================================
1806 *
1807 * dgap_event - FEP to host event processing routine.
1808 *
1809 * bd - Board of current event.
1810 *
1811 *=======================================================================*/
1813 {
1815 ulong lock_flags;
1816 ulong lock_flags2;
1821 uint head;
1822 uint tail;
1837 }
1841 /* Get our head and tail */
1845 /*
1846 * Forget it if pointers out of range.
1847 */
1851 /* Let go of board lock */
1854 }
1856 /*
1857 * Loop to process all the events in the buffer.
1858 */
1860 /*
1861 * Get interrupt information.
1862 */
1871 /*
1872 * Make sure the interrupt is valid.
1873 */
1885 /*
1886 * If we have made it here, the event was valid.
1887 * Lock down the channel.
1888 */
1896 }
1898 /*
1899 * Process received data.
1900 */
1902 /*
1903 * ALL LOCKS *MUST* BE DROPPED BEFORE CALLING INPUT!
1904 * input could send some data to ld, which in turn
1905 * could do a callback to one of our other functions.
1906 */
1917 else
1923 wake_up_interruptible
1925 }
1926 }
1928 /*
1929 * Process Modem change signals.
1930 */
1934 }
1936 /*
1937 * Process break.
1938 */
1941 /* A break has been indicated */
1943 tty_buffer_request_room
1948 }
1949 }
1951 /*
1952 * Process Transmit low.
1953 */
1962 }
1963 }
1965 /*
1966 * Process Transmit empty.
1967 */
1976 }
1977 }
1981 next:
1983 }
1989 }
1991 /*
1992 * Our board poller function.
1993 */
1995 {
1997 ulong lock_flags;
2011 /*
2012 * If board is ready, parse deeper to see if there is anything to do.
2013 */
2020 }
2024 }
2031 /* Get our head and tail */
2035 /*
2036 * If there is an event pending. Go service it.
2037 */
2042 }
2044 out:
2045 /*
2046 * If board is doing interrupts, ACK the interrupt.
2047 */
2053 }
2056 }
2058 /*
2059 * dgap_found_board()
2060 *
2061 * A board has been found, init it.
2062 */
2065 {
2071 /* get the board structure and prep it */
2076 /* store the info for the board we've found */
2100 /* store which card & revision we have */
2108 /* get the PCI Base Address Registers */
2110 /* Xr Jupiter and EPC use BAR 2 */
2114 }
2115 /* Everyone else uses BAR 0 */
2119 }
2124 }
2128 else
2131 /*
2132 * On the PCI boards, there is no IO space allocated
2133 * The I/O registers will be in the first 3 bytes of the
2134 * upper 2MB of the 4MB memory space. The board memory
2135 * will be mapped into the low 2MB of the 4MB memory space
2136 */
2140 /*
2141 * Special initialization for non-PLX boards
2142 */
2149 /* Limit burst length to 2 doubleword transactions */
2152 /*
2153 * Enable IO and mem if not already done.
2154 * This was needed for support on Itanium.
2155 */
2159 }
2161 /* init our poll helper tasklet */
2174 free_brd:
2178 }
2180 /*
2181 * dgap_intr()
2182 *
2183 * Driver interrupt handler.
2184 */
2186 {
2192 /*
2193 * Check to make sure its for us.
2194 */
2200 /*
2201 * Schedule tasklet to run at a better time.
2202 */
2205 }
2207 /*****************************************************************************
2208 *
2209 * Function:
2210 *
2211 * dgap_poll_handler
2212 *
2213 * Author:
2214 *
2215 * Scott H Kilau
2216 *
2217 * Parameters:
2218 *
2219 * dummy -- ignored
2220 *
2221 * Return Values:
2222 *
2223 * none
2224 *
2225 * Description:
2226 *
2227 * As each timer expires, it determines (a) whether the "transmit"
2228 * waiter needs to be woken up, and (b) whether the poller needs to
2229 * be rescheduled.
2230 *
2231 ******************************************************************************/
2234 {
2238 ulong new_time;
2240 dgap_poll_counter++;
2242 /*
2243 * Do not start the board state machine until
2244 * driver tells us its up and running, and has
2245 * everything it needs.
2246 */
2250 /*
2251 * If we have just 1 board, or the system is not SMP,
2252 * then use the typical old style poller.
2253 * Otherwise, use our new tasklet based poller, which should
2254 * speed things up for multiple boards.
2255 */
2263 /* Call the real board poller directly */
2265 }
2267 /*
2268 * Go thru each board, kicking off a
2269 * tasklet for each if needed
2270 */
2274 /*
2275 * Attempt to grab the board lock.
2276 *
2277 * If we can't get it, no big deal, the next poll
2278 * will get it. Basically, I just really don't want
2279 * to spin in here, because I want to kick off my
2280 * tasklets as fast as I can, and then get out the
2281 * poller.
2282 */
2286 /*
2287 * If board is in a failed state, don't bother
2288 * scheduling a tasklet
2289 */
2293 }
2295 /* Schedule a poll helper task */
2299 /*
2300 * Can't do DGAP_UNLOCK here, as we don't have
2301 * lock_flags because we did a trylock above.
2302 */
2304 }
2305 }
2307 schedule_poller:
2309 /*
2310 * Schedule ourself back at the nominal wakeup interval.
2311 */
2318 dgap_poll_time =
2320 }
2329 }
2331 /*=======================================================================
2332 *
2333 * dgap_cmdb - Sends a 2 byte command to the FEP.
2334 *
2335 * ch - Pointer to channel structure.
2336 * cmd - Command to be sent.
2337 * byte1 - Integer containing first byte to be sent.
2338 * byte2 - Integer containing second byte to be sent.
2339 * ncmds - Wait until ncmds or fewer cmds are left
2340 * in the cmd buffer before returning.
2341 *
2342 *=======================================================================*/
2345 {
2348 uint count;
2349 uint n;
2350 u16 head;
2351 u16 tail;
2356 /*
2357 * Check if board is still alive.
2358 */
2362 /*
2363 * Make sure the pointers are in range before
2364 * writing to the FEP memory.
2365 */
2374 /*
2375 * Forget it if pointers out of range.
2376 */
2380 }
2382 /*
2383 * Put the data in the circular command buffer.
2384 */
2394 /*
2395 * Wait if necessary before updating the head
2396 * pointer to limit the number of outstanding
2397 * commands to the FEP. If the time spent waiting
2398 * is outlandish, declare the FEP dead.
2399 */
2412 }
2414 }
2415 }
2417 /*=======================================================================
2418 *
2419 * dgap_cmdw - Sends a 1 word command to the FEP.
2420 *
2421 * ch - Pointer to channel structure.
2422 * cmd - Command to be sent.
2423 * word - Integer containing word to be sent.
2424 * ncmds - Wait until ncmds or fewer cmds are left
2425 * in the cmd buffer before returning.
2426 *
2427 *=======================================================================*/
2429 {
2432 uint count;
2433 uint n;
2434 u16 head;
2435 u16 tail;
2440 /*
2441 * Check if board is still alive.
2442 */
2446 /*
2447 * Make sure the pointers are in range before
2448 * writing to the FEP memory.
2449 */
2457 /*
2458 * Forget it if pointers out of range.
2459 */
2463 }
2465 /*
2466 * Put the data in the circular command buffer.
2467 */
2476 /*
2477 * Wait if necessary before updating the head
2478 * pointer to limit the number of outstanding
2479 * commands to the FEP. If the time spent waiting
2480 * is outlandish, declare the FEP dead.
2481 */
2494 }
2496 }
2497 }
2499 /*=======================================================================
2500 *
2501 * dgap_cmdw_ext - Sends a extended word command to the FEP.
2502 *
2503 * ch - Pointer to channel structure.
2504 * cmd - Command to be sent.
2505 * word - Integer containing word to be sent.
2506 * ncmds - Wait until ncmds or fewer cmds are left
2507 * in the cmd buffer before returning.
2508 *
2509 *=======================================================================*/
2511 {
2514 uint count;
2515 uint n;
2516 u16 head;
2517 u16 tail;
2522 /*
2523 * Check if board is still alive.
2524 */
2528 /*
2529 * Make sure the pointers are in range before
2530 * writing to the FEP memory.
2531 */
2539 /*
2540 * Forget it if pointers out of range.
2541 */
2545 }
2547 /*
2548 * Put the data in the circular command buffer.
2549 */
2551 /* Write an FF to tell the FEP that we want an extended command */
2557 /*
2558 * If the second part of the command won't fit,
2559 * put it at the beginning of the circular buffer.
2560 */
2563 else
2570 /*
2571 * Wait if necessary before updating the head
2572 * pointer to limit the number of outstanding
2573 * commands to the FEP. If the time spent waiting
2574 * is outlandish, declare the FEP dead.
2575 */
2588 }
2590 }
2591 }
2593 /*=======================================================================
2594 *
2595 * dgap_wmove - Write data to FEP buffer.
2596 *
2597 * ch - Pointer to channel structure.
2598 * buf - Pointer to characters to be moved.
2599 * cnt - Number of characters to move.
2600 *
2601 *=======================================================================*/
2603 {
2607 u16 head;
2612 /*
2613 * Check parameters.
2614 */
2618 /*
2619 * If pointers are out of range, just return.
2620 */
2625 /*
2626 * If the write wraps over the top of the circular buffer,
2627 * move the portion up to the wrap point, and reset the
2628 * pointers to the bottom.
2629 */
2638 }
2640 /*
2641 * Move rest of data.
2642 */
2649 }
2651 /*
2652 * Calls the firmware to reset this channel.
2653 */
2655 {
2658 /*
2659 * Now that the channel is reset, we need to make sure
2660 * all the current settings get reapplied to the port
2661 * in the firmware.
2662 *
2663 * So we will set the driver's cache of firmware
2664 * settings all to 0, and then call param.
2665 */
2675 }
2677 /*=======================================================================
2678 *
2679 * dgap_param - Set Digi parameters.
2680 *
2681 * struct tty_struct * - TTY for port.
2682 *
2683 *=======================================================================*/
2685 {
2686 u16 head;
2687 u16 cflag;
2688 u16 iflag;
2689 u8 mval;
2690 u8 hflow;
2692 /*
2693 * If baud rate is zero, flush queues, and set mval to drop DTR.
2694 */
2696 /* flush rx */
2700 /* flush tx */
2706 /* Drop RTS and DTR */
2712 /*
2713 * Tell the fep to do the command
2714 */
2718 /*
2719 * Now go get from fep mem, what the fep
2720 * believes the custom baud rate is.
2721 */
2725 /* Handle transition from B0 */
2729 }
2733 /*
2734 * Set baud rate, character size, and parity.
2735 */
2763 };
2765 /*
2766 * Only use the TXPrint baud rate if the
2767 * terminal unit is NOT open
2768 */
2772 else
2786 else
2794 /*
2795 * CBAUD has bit position 0x1000 set these days to
2796 * indicate Linux baud rate remap.
2797 * We use a different bit assignment for high speed.
2798 * Clear this bit out while grabbing the parts of
2799 * "cflag" we want.
2800 */
2804 /*
2805 * HUPCL bit is used by FEP to indicate fast baud
2806 * table is to be used.
2807 */
2814 /*
2815 * The below code is trying to guarantee that only
2816 * baud rates 115200, 230400, 460800, 921600 are
2817 * remapped. We use exclusive or because the various
2818 * baud rates share common bit positions and therefore
2819 * can't be tested for easily.
2820 */
2824 /*
2825 * Map high speed requests to index
2826 * into FEP's baud table
2827 */
2832 #ifdef B76800
2836 #endif
2846 #ifdef B921600
2850 #endif
2853 }
2857 }
2864 /*
2865 * Okay to have channel and board
2866 * locks held calling this
2867 */
2869 }
2871 /* Handle transition from B0 */
2875 }
2877 }
2879 /*
2880 * Get input flags.
2881 */
2889 }
2891 /*
2892 * Only the IBM Xr card can switch between
2893 * 232 and 422 modes on the fly
2894 */
2898 else
2900 }
2908 /* Okay to have channel and board locks held calling this */
2910 }
2912 /*
2913 * Select hardware handshaking.
2914 */
2933 /* Okay to have channel and board locks held calling this */
2935 }
2937 /*
2938 * Set RTS and/or DTR Toggle if needed,
2939 * but only if product is FEP5+ based.
2940 */
2950 }
2952 /*
2953 * Set modem control lines.
2954 */
2961 /* Okay to have channel and board locks held calling this */
2963 }
2965 /*
2966 * Read modem signals, and then call carrier function.
2967 */
2971 /*
2972 * Set the start and stop characters.
2973 */
2979 /* Okay to have channel and board locks held calling this */
2981 }
2983 /*
2984 * Set the Auxiliary start and stop characters.
2985 */
2991 /* Okay to have channel and board locks held calling this */
2993 }
2996 }
2998 /*
2999 * dgap_block_til_ready()
3000 *
3001 * Wait for DCD, if needed.
3002 */
3005 {
3008 ulong lock_flags;
3009 uint old_flags;
3024 /* Loop forever */
3028 /*
3029 * If board has failed somehow during our sleep,
3030 * bail with error.
3031 */
3035 }
3037 /* If tty was hung up, break out of loop and set error. */
3041 }
3043 /*
3044 * If either unit is in the middle of the fragile part of close,
3045 * we just cannot touch the channel safely.
3046 * Go back to sleep, knowing that when the channel can be
3047 * touched safely, the close routine will signal the
3048 * ch_wait_flags to wake us back up.
3049 */
3051 UN_CLOSING)) {
3052 /*
3053 * Our conditions to leave cleanly and happily:
3054 * 1) NONBLOCKING on the tty is set.
3055 * 2) CLOCAL is set.
3056 * 3) DCD (fake or real) is active.
3057 */
3072 }
3074 /*
3075 * If there is a signal pending, the user probably
3076 * interrupted (ctrl-c) us.
3077 * Leave loop with error set.
3078 */
3082 }
3084 /*
3085 * Store the flags before we let go of channel lock
3086 */
3089 else
3092 /*
3093 * Let go of channel lock before calling schedule.
3094 * Our poller will get any FEP events and wake us up when DCD
3095 * eventually goes active.
3096 */
3100 /*
3101 * Wait for something in the flags to change
3102 * from the current value.
3103 */
3111 }
3113 /*
3114 * We got woken up for some reason.
3115 * Before looping around, grab our channel lock.
3116 */
3118 }
3125 }
3127 /*
3128 * dgap_tty_flush_buffer()
3129 *
3130 * Flush Tx buffer (make in == out)
3131 */
3133 {
3137 ulong lock_flags;
3138 ulong lock_flags2;
3139 u16 head;
3166 }
3170 }
3177 }
3179 /*
3180 * dgap_tty_hangup()
3181 *
3182 * Hangup the port. Like a close, but don't wait for output to drain.
3183 */
3185 {
3205 /* flush the transmit queues */
3207 }
3209 /*
3210 * dgap_tty_chars_in_buffer()
3211 *
3212 * Return number of characters that have not been transmitted yet.
3213 *
3214 * This routine is used by the line discipline to determine if there
3215 * is data waiting to be transmitted/drained/flushed or not.
3216 */
3218 {
3223 u8 tbusy;
3224 uint chars;
3253 /* Get Transmit queue pointers */
3257 /* Get tbusy flag */
3260 /* Get Command queue pointers */
3267 /*
3268 * The only way we know for sure if there is no pending
3269 * data left to be transferred, is if:
3270 * 1) Transmit head and tail are equal (empty).
3271 * 2) Command queue head and tail are equal (empty).
3272 * 3) The "TBUSY" flag is 0. (Transmitter not busy).
3273 */
3280 else
3282 /*
3283 * Fudge factor here.
3284 * If chars is zero, we know that the command queue had
3285 * something in it or tbusy was set. Because we cannot
3286 * be sure if there is still some data to be transmitted,
3287 * lets lie, and tell ld we have 1 byte left.
3288 */
3290 /*
3291 * If TBUSY is still set, and our tx buffers are empty,
3292 * force the firmware to send me another wakeup after
3293 * TBUSY has been cleared.
3294 */
3300 lock_flags);
3301 }
3303 }
3304 }
3307 }
3310 {
3333 /* Loop until data is drained */
3340 /* Set flag waiting for drain */
3346 /* Go to sleep till we get woken up */
3349 /* If ret is non-zero, user ctrl-c'ed us */
3352 }
3359 }
3361 /*
3362 * dgap_maxcps_room
3363 *
3364 * Reduces bytes_available to the max number of characters
3365 * that can be sent currently given the maxcps value, and
3366 * returns the new bytes_available. This only affects printer
3367 * output.
3368 */
3371 {
3372 /*
3373 * If its not the Transparent print device, return
3374 * the full data amount.
3375 */
3387 /* buffer is empty */
3391 /* still room in the buffer */
3395 /* no room in the buffer */
3397 }
3400 }
3403 }
3406 {
3423 }
3424 }
3429 }
3430 }
3431 }
3433 /*
3434 * dgap_tty_write_room()
3435 *
3436 * Return space available in Tx buffer
3437 */
3439 {
3472 /* Limit printer to maxcps */
3475 /*
3476 * If we are printer device, leave space for
3477 * possibly both the on and off strings.
3478 */
3486 }
3491 /*
3492 * Schedule FEP to wake us up if needed.
3493 *
3494 * TODO: This might be overkill...
3495 * Do we really need to schedule callbacks from the FEP
3496 * in every case? Can we get smarter based on ret?
3497 */
3502 }
3504 /*
3505 * dgap_tty_write()
3506 *
3507 * Take data from the user or kernel and send it out to the FEP.
3508 * In here exists all the Transparent Print magic as well.
3509 */
3512 {
3519 ulong lock_flags;
3541 /* Get our space available for the channel from the board */
3550 /*
3551 * Limit printer output to maxcps overall, with bursts allowed
3552 * up to bufsize characters.
3553 */
3556 /*
3557 * Take minimum of what the user wants to send, and the
3558 * space available in the FEP buffer.
3559 */
3562 /*
3563 * Bail if no space left.
3564 */
3569 }
3571 /*
3572 * Output the printer ON string, if we are in terminal mode, but
3573 * need to be in printer mode.
3574 */
3580 }
3582 /*
3583 * On the other hand, output the printer OFF string, if we are
3584 * currently in printer mode, but need to output to the terminal.
3585 */
3591 }
3595 /*
3596 * If the write wraps over the top of the circular buffer,
3597 * move the portion up to the wrap point, and reset the
3598 * pointers to the bottom.
3599 */
3610 }
3613 /*
3614 * Move rest of data.
3615 */
3621 }
3627 }
3631 /*
3632 * If this is the print device, and the
3633 * printer is still on, we need to turn it
3634 * off before going idle. If the buffer is
3635 * non-empty, wait until it goes empty.
3636 * Otherwise turn it off right now.
3637 */
3649 }
3650 }
3652 /* Update printer buffer empty time. */
3656 }
3661 }
3663 /*
3664 * dgap_tty_put_char()
3665 *
3666 * Put a character into ch->ch_buf
3667 *
3668 * - used by the line discipline for OPOST processing
3669 */
3671 {
3672 /*
3673 * Simply call tty_write.
3674 */
3677 }
3679 /*
3680 * Return modem signals to ld.
3681 */
3683 {
3687 u8 mstat;
3688 ulong lock_flags;
3704 /* Append any outbound signals that might be pending... */
3725 }
3727 /*
3728 * dgap_tty_tiocmset()
3729 *
3730 * Set modem signals, called by ld.
3731 */
3734 {
3738 ulong lock_flags;
3739 ulong lock_flags2;
3762 }
3767 }
3772 }
3777 }
3785 }
3787 /*
3788 * dgap_tty_send_break()
3789 *
3790 * Send a Break, called by ld.
3791 */
3793 {
3797 ulong lock_flags;
3798 ulong lock_flags2;
3825 }
3829 #if 0
3831 #endif
3838 }
3840 /*
3841 * dgap_tty_wait_until_sent()
3842 *
3843 * wait until data has been transmitted, called by ld.
3844 */
3846 {
3848 }
3850 /*
3851 * dgap_send_xchar()
3852 *
3853 * send a high priority character, called by ld.
3854 */
3856 {
3860 ulong lock_flags;
3861 ulong lock_flags2;
3881 /*
3882 * This is technically what we should do.
3883 * However, the NIST tests specifically want
3884 * to see each XON or XOFF character that it
3885 * sends, so lets just send each character
3886 * by hand...
3887 */
3888 #if 0
3893 else
3895 #else
3897 #endif
3901 }
3903 /*
3904 * Return modem signals to ld.
3905 */
3907 {
3909 u8 mstat;
3910 ulong lock_flags;
3915 /* Append any outbound signals that might be pending... */
3936 }
3938 /*
3939 * dgap_set_modem_info()
3940 *
3941 * Set modem signals, called by ld.
3942 */
3946 {
3949 ulong lock_flags;
3950 ulong lock_flags2;
3961 }
3966 }
3974 }
3979 }
3988 else
3993 else
4000 }
4011 }
4013 /*
4014 * dgap_tty_digigeta()
4015 *
4016 * Ioctl to get the information for ditty.
4017 *
4018 *
4019 *
4020 */
4023 {
4025 ulong lock_flags;
4040 }
4042 /*
4043 * dgap_tty_digiseta()
4044 *
4045 * Ioctl to set the information for ditty.
4046 *
4047 *
4048 *
4049 */
4052 {
4092 }
4094 /*
4095 * dgap_tty_digigetedelay()
4096 *
4097 * Ioctl to get the current edelay setting.
4098 *
4099 *
4100 *
4101 */
4103 {
4107 ulong lock_flags;
4133 }
4135 /*
4136 * dgap_tty_digisetedelay()
4137 *
4138 * Ioctl to set the EDELAY setting
4139 *
4140 */
4143 {
4145 ulong lock_flags;
4146 ulong lock_flags2;
4162 }
4164 /*
4165 * dgap_tty_digigetcustombaud()
4166 *
4167 * Ioctl to get the current custom baud rate setting.
4168 */
4171 {
4173 ulong lock_flags;
4188 }
4190 /*
4191 * dgap_tty_digisetcustombaud()
4192 *
4193 * Ioctl to set the custom baud rate setting
4194 */
4197 {
4198 uint new_rate;
4199 ulong lock_flags;
4200 ulong lock_flags2;
4215 }
4218 }
4220 /*
4221 * dgap_set_termios()
4222 */
4225 {
4262 }
4265 {
4269 ulong lock_flags;
4270 ulong lock_flags2;
4291 #if 1
4293 #endif
4297 }
4300 {
4304 ulong lock_flags;
4305 ulong lock_flags2;
4327 #if 1
4329 #endif
4333 }
4336 {
4347 }
4350 }
4352 /************************************************************************
4353 *
4354 * TTY Entry points and helper functions
4355 *
4356 ************************************************************************/
4358 /*
4359 * dgap_tty_open()
4360 *
4361 */
4363 {
4368 uint major;
4369 uint minor;
4371 ulong lock_flags;
4372 ulong lock_flags2;
4373 u16 head;
4382 /*
4383 * If board is not yet up to a state of READY, go to
4384 * sleep waiting for it to happen or they cancel the open.
4385 */
4394 /* The wait above should guarantee this cannot happen */
4398 }
4400 /* If opened device is greater than our number of ports, bail. */
4404 }
4410 }
4412 /* Grab channel lock */
4415 /* Figure out our type */
4426 }
4428 /* Store our unit into driver_data, so we always have it available. */
4431 /*
4432 * Error if channel info pointer is NULL.
4433 */
4439 }
4441 /*
4442 * Initialize tty's
4443 */
4445 /* Store important variables. */
4448 /* Maybe do something here to the TTY struct as well? */
4449 }
4451 /*
4452 * Initialize if neither terminal or printer is open.
4453 */
4458 /*
4459 * Flush input queue.
4460 */
4475 /* TODO: flush our TTY struct here? */
4476 }
4479 /*
4480 * Run param in case we changed anything
4481 */
4484 /*
4485 * follow protocol for opening port
4486 */
4496 /* No going back now, increment our unit and channel counters */
4504 }
4506 /*
4507 * dgap_tty_close()
4508 *
4509 */
4511 {
4515 ulong lock_flags;
4534 /*
4535 * Determine if this is the last close or not - and if we agree about
4536 * which type of close it is with the Line Discipline
4537 */
4539 /*
4540 * Uh, oh. tty->count is 1, which means that the tty
4541 * structure will be freed. un_open_count should always
4542 * be one in these conditions. If it's greater than
4543 * one, we've got real problems, since it means the
4544 * serial port won't be shutdown.
4545 */
4547 }
4557 }
4559 /* OK, its the last close on the unit */
4565 /*
4566 * Only officially close channel if count is 0 and
4567 * DIGI_PRINTER bit is not set.
4568 */
4575 /* wait for output to drain */
4576 /* This will also return if we take an interrupt */
4587 /*
4588 * If we have HUPCL set, lower DTR and RTS
4589 */
4594 /*
4595 * Go to sleep to ensure RTS/DTR
4596 * have been dropped for modems to see it.
4597 */
4599 lock_flags);
4601 /* .25 second delay for dropping RTS/DTR */
4605 }
4610 }
4612 /*
4613 * turn off print device when closing print device.
4614 */
4619 }
4629 }
4632 {
4636 ulong lock_flags;
4637 ulong lock_flags2;
4661 }
4664 {
4668 ulong lock_flags;
4669 ulong lock_flags2;
4693 }
4695 /*
4696 * dgap_tty_flush_chars()
4697 *
4698 * Flush the cook buffer
4699 *
4700 * Note to self, and any other poor souls who venture here:
4701 *
4702 * flush in this case DOES NOT mean dispose of the data.
4703 * instead, it means "stop buffering and send it if you
4704 * haven't already." Just guess how I figured that out... SRW 2-Jun-98
4705 *
4706 * It is also always called in interrupt context - JAR 8-Sept-99
4707 */
4709 {
4713 ulong lock_flags;
4714 ulong lock_flags2;
4734 /* TODO: Do something here */
4738 }
4740 /*****************************************************************************
4741 *
4742 * The IOCTL function and all of its helpers
4743 *
4744 *****************************************************************************/
4746 /*
4747 * dgap_tty_ioctl()
4748 *
4749 * The usual assortment of ioctl's
4750 */
4753 {
4758 u16 head;
4785 }
4788 /* Here are all the standard ioctl's that we MUST implement */
4790 /*
4791 * TCSBRK is SVID version: non-zero arg --> no break
4792 * this behaviour is exploited by tcdrain().
4793 *
4794 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
4795 * between 0.25 and 0.5 seconds so we'll ask for something
4796 * in the middle: 0.375 seconds.
4797 */
4821 /* support for POSIX tcsendbreak()
4823 * According to POSIX.1 spec (7.2.2.1.2) breaks should be
4824 * between 0.25 and 0.5 seconds so we'll ask for something
4825 * in the middle: 0.375 seconds.
4826 */
4848 /*
4849 * FEP5 doesn't support turning on a break unconditionally.
4850 * The FEP5 device will stop sending a break automatically
4851 * after the specified time value that was sent when turning on
4852 * the break.
4853 */
4875 /*
4876 * FEP5 doesn't support turning off a break unconditionally.
4877 * The FEP5 device will stop sending a break automatically
4878 * after the specified time value that was sent when turning on
4879 * the break.
4880 */
4923 /*
4924 * Here are any additional ioctl's that we want to implement
4925 */
4928 /*
4929 * The linux tty driver doesn't have a flush
4930 * input routine for the driver, assuming all backed
4931 * up data is in the line disc. buffers. However,
4932 * we all know that's not the case. Here, we
4933 * act on the ioctl, but then lie and say we didn't
4934 * so the line discipline will process the flush
4935 * also.
4936 */
4942 }
4949 }
4950 }
4953 /* pretend we didn't recognize this IOCTL */
4958 }
4967 }
4971 }
4975 /* Can't hold any locks when calling tty_wakeup! */
4980 /* pretend we didn't recognize this IOCTL */
4985 /*
4986 * The linux tty driver doesn't have a flush
4987 * input routine for the driver, assuming all backed
4988 * up data is in the line disc. buffers. However,
4989 * we all know that's not the case. Here, we
4990 * act on the ioctl, but then lie and say we didn't
4991 * so the line discipline will process the flush
4992 * also.
4993 */
4995 /* flush rx */
4999 }
5001 /* now wait for all the output to drain */
5008 /* pretend we didn't recognize this */
5019 /* pretend we didn't recognize this */
5023 /*
5024 * The Linux Line Discipline (LD) would do this for us if we
5025 * let it, but we have the special firmware options to do this
5026 * the "right way" regardless of hardware or software flow
5027 * control so we'll do it outselves instead of letting the LD
5028 * do it.
5029 */
5035 }
5051 /* Make the ld do it */
5056 /* Make the ld do it */
5062 }
5065 /* get information for ditty */
5073 /* set information for ditty */
5084 /* fall thru */
5123 }
5124 }
5147 };
5149 /************************************************************************
5150 *
5151 * TTY Initialization/Cleanup Functions
5152 *
5153 ************************************************************************/
5155 /*
5156 * dgap_tty_register()
5157 *
5158 * Init the tty subsystem for this board.
5159 */
5161 {
5165 TTY_DRIVER_REAL_RAW |
5166 TTY_DRIVER_DYNAMIC_DEV |
5167 TTY_DRIVER_HARDWARE_BREAK);
5182 /*
5183 * Entry points for driver. Called by the kernel from
5184 * tty_io.c and n_tty.c.
5185 */
5188 /*
5189 * If we're doing transparent print, we have to do all of the above
5190 * again, separately so we don't get the LD confused about what major
5191 * we are when we get into the dgap_tty_open() routine.
5192 */
5194 TTY_DRIVER_REAL_RAW |
5195 TTY_DRIVER_DYNAMIC_DEV |
5196 TTY_DRIVER_HARDWARE_BREAK);
5200 }
5213 /*
5214 * Entry points for driver. Called by the kernel from
5215 * tty_io.c and n_tty.c.
5216 */
5219 /* Register tty devices */
5224 /* Register Transparent Print devices */
5231 unregister_serial_drv:
5233 free_print_drv:
5235 free_serial_drv:
5239 }
5242 {
5247 }
5250 {
5251 /*
5252 * allocate flip buffer for board.
5253 */
5262 }
5265 }
5268 {
5271 }
5274 {
5285 }
5290 {
5303 }
5305 }
5311 {
5324 }
5326 }
5332 {
5358 else
5361 }
5363 }
5369 {
5383 }
5389 {
5403 }
5409 {
5423 }
5429 {
5443 }
5449 {
5463 }
5469 {
5483 }
5489 {
5503 }
5509 {
5530 }
5536 {
5556 }
5562 {
5589 }
5591 }
5597 {
5617 }
5623 {
5643 }
5649 {
5669 }
5675 {
5695 }
5701 {
5721 }
5727 {
5747 }
5753 {
5773 }
5779 {
5818 else
5820 }
5839 }
5840 }
5853 }
5856 }
5869 }
5872 }
5873 }
5877 }
5892 NULL
5893 };
5896 /* this function creates the sys files that will export each signal status
5897 * to sysfs each value will be put in a separate filename
5898 */
5900 {
5912 }
5914 /* removes all the sys files created for that port */
5916 {
5927 }
5929 /*
5930 * Copies the BIOS code from the user to the board,
5931 * and starts the BIOS running.
5932 */
5934 {
5936 uint offset;
5944 /*
5945 * clear POST area
5946 */
5950 /*
5951 * Download bios
5952 */
5959 /* Clear the reset, and change states. */
5961 }
5963 /*
5964 * Checks to see if the BIOS completed running on the card.
5965 */
5967 {
5969 u16 word;
5970 u16 err1;
5971 u16 err2;
5979 /*
5980 * It can take 5-6 seconds for a board to
5981 * pass the bios self test and post results.
5982 * Give it 10 seconds.
5983 */
5986 /* Check to see if BIOS thinks board is good. (GD). */
5992 }
5994 /* Gave up on board after too long of time taken */
6003 }
6005 /*
6006 * Copies the FEP code from the user to the board,
6007 * and starts the FEP running.
6008 */
6010 {
6012 uint offset;
6019 /*
6020 * Download FEP
6021 */
6025 /*
6026 * If board is a concentrator product, we need to give
6027 * it its config string describing how the concentrators look.
6028 */
6037 /* Write string to board memory */
6043 }
6044 }
6048 }
6050 /*
6051 * Waits for the FEP to report thats its ready for us to use.
6052 */
6054 {
6056 u16 word;
6057 u16 err1;
6058 u16 err2;
6066 /*
6067 * It can take 2-3 seconds for the FEP to
6068 * be up and running. Give it 5 secs.
6069 */
6072 /* Check to see if FEP is up and running now. */
6074 /*
6075 * Check to see if the board can support FEP5+ commands.
6076 */
6082 }
6086 }
6088 /* Gave up on board after too long of time taken */
6098 }
6100 /*
6101 * Physically forces the FEP5 card to reset itself.
6102 */
6104 {
6105 u8 check;
6106 u32 check1;
6107 u32 check2;
6114 /* FEPRST does not vary among supported boards */
6122 }
6129 }
6131 /*
6132 * Make sure there really is memory out there.
6133 */
6146 }
6147 }
6149 #ifdef DIGI_CONCENTRATORS_SUPPORTED
6150 /*
6151 * Sends a concentrator image into the FEP5 board.
6152 */
6154 {
6156 u16 offset;
6168 /* Tell card we have data for it */
6172 }
6173 #endif
6175 #define EXPANSION_ROM_SIZE (64 * 1024)
6176 #define FEP5_ROM_MAGIC (0xFEFFFFFF)
6179 {
6180 u32 magic;
6181 u32 base_offset;
6182 u16 rom_offset;
6183 u16 vpd_offset;
6184 u16 image_length;
6185 u16 i;
6186 u8 byte1;
6187 u8 byte2;
6189 /*
6190 * Poke the magic number at the PCI Rom Address location.
6191 * If VPD is supported, the value read from that address
6192 * will be non-zero.
6193 */
6198 /* VPD not supported, bail */
6202 /*
6203 * To get to the OTPROM memory, we have to send the boards base
6204 * address or'ed with 1 into the PCI Rom Address location.
6205 */
6213 /*
6214 * If the board correctly swapped to the OTPROM memory,
6215 * the first 2 bytes (header) should be 0x55, 0xAA
6216 */
6220 /*
6221 * We have to run through all the OTPROM memory looking
6222 * for the VPD offset.
6223 */
6225 /*
6226 * Lots of magic numbers here.
6227 *
6228 * The VPD offset is located inside the ROM Data
6229 * Structure.
6230 *
6231 * We also have to remember the length of each
6232 * ROM Data Structure, so we can "hop" to the next
6233 * entry if the VPD isn't in the current
6234 * ROM Data Structure.
6235 */
6243 /* Found the VPD entry */
6247 /* We didn't find a VPD entry, go to next ROM entry. */
6253 /*
6254 * If the new ROM offset doesn't have 0x55, 0xAA
6255 * as its header, we have run out of ROM.
6256 */
6259 }
6261 /*
6262 * If we have a VPD offset, then mark the board
6263 * as having a valid VPD, and copy VPDSIZE (512) bytes of
6264 * that VPD to the buffer we have in our board structure.
6265 */
6271 }
6272 }
6273 }
6275 /*
6276 * We MUST poke the magic number at the PCI Rom Address location again.
6277 * This makes the card report the regular board memory back to us,
6278 * rather than the OTPROM memory.
6279 */
6282 }
6286 {
6288 }
6293 {
6295 }
6300 {
6302 }
6308 {
6310 }
6314 {
6316 }
6320 {
6324 }
6326 dgap_driver_pollrate_store);
6330 {
6341 }
6344 {
6352 }
6357 };
6360 {
6368 }
6371 {
6373 }
6375 /*
6376 * Create pr and tty device entries
6377 */
6379 {
6385 GFP_KERNEL);
6390 GFP_KERNEL);
6394 }
6399 }
6412 }
6424 }
6428 }
6433 unregister_ttys:
6439 }
6444 }
6445 i--;
6446 }
6451 }
6456 free_serial_ports:
6461 }
6463 /*
6464 * dgap_cleanup_tty()
6465 *
6466 * Uninitialize the TTY portion of this driver. Free all memory and
6467 * resources.
6468 */
6470 {
6479 }
6489 }
6493 }
6496 {
6502 /*
6503 * Set up our interrupt handler if we are set to do interrupts.
6504 */
6510 }
6512 }
6515 {
6518 }
6522 {
6538 }
6544 }
6549 /*
6550 * preserve dgap_config_buf
6551 * as dgap_parsefile would
6552 * otherwise alter it.
6553 */
6559 }
6561 }
6563 /*
6564 * Match this board to a config the user created for us.
6565 */
6569 /*
6570 * Because the 4 port Xr products share the same PCI ID
6571 * as the 8 port Xr products, if we receive a NULL config
6572 * back, and this is a PAPORT8 board, retry with a
6573 * PAPORT4 attempt as well.
6574 */
6582 }
6591 }
6595 /* Wait for BIOS to test board... */
6599 }
6608 }
6612 /* Wait for FEP to load on board... */
6616 }
6618 #ifdef DIGI_CONCENTRATORS_SUPPORTED
6619 /*
6620 * If this is a CX or EPCX, we need to see if the firmware
6621 * is requesting a concentrator image from us.
6622 */
6625 /* Nonzero if FEP is requesting concentrator image. */
6628 }
6637 }
6638 /* Put concentrator firmware loading code here */
6644 }
6645 #endif
6648 }
6650 /*
6651 * dgap_tty_init()
6652 *
6653 * Init the tty subsystem. Called once per board after board has been
6654 * downloaded and init'ed.
6655 */
6657 {
6660 uint true_count;
6662 u8 modem;
6668 /*
6669 * Initialize board structure elements.
6670 */
6694 }
6698 /* If no ports, don't bother going any further */
6703 }
6704 }
6706 /*
6707 * Allocate channel memory that might not have been allocated
6708 * when the driver was first loaded.
6709 */
6716 }
6717 }
6727 /* Set up channel variables */
6731 /* Store all our magic numbers */
6750 /*
6751 * Set up digi dsr and dcd bits based on altpin flag.
6752 */
6760 }
6771 /*
6772 * Set queue water marks, interrupt mask,
6773 * and general tty parameters.
6774 */
6791 /* Turn on all modem interrupts for now */
6795 /*
6796 * Set edelay to 0 if interrupts are turned on,
6797 * otherwise set edelay to the usual 100.
6798 */
6801 else
6805 }
6809 free_chan:
6813 }
6815 }
6817 /*
6818 * dgap_tty_free()
6819 *
6820 * Free the channles which are allocated in dgap_tty_init().
6821 */
6823 {
6828 }
6831 {
6862 /*
6863 * Do tty device initialization.
6864 */
6880 tty_free:
6882 free_irq:
6884 unregister_tty:
6886 free_flipbuf:
6888 cleanup_brd:
6894 }
6896 /*
6897 * dgap_cleanup_board()
6898 *
6899 * Free all the memory associated with a board
6900 */
6902 {
6914 /* Free all allocated channels structs */
6924 }
6927 {
6941 }
6944 {
6953 }
6956 }
6963 };
6965 /*
6966 * Start of driver.
6967 */
6969 {
6978 /*
6979 * Register our base character device into the kernel.
6980 */
6982 /*
6983 * Register management/dpa devices
6984 */
6993 }
7001 }
7003 /* Start the poller */
7015 failed_device:
7017 failed_class:
7020 }
7022 /************************************************************************
7023 *
7024 * Driver load/unload functions
7025 *
7026 ************************************************************************/
7028 /*
7029 * init_module()
7030 *
7031 * Module load. This is where it all starts.
7032 */
7034 {
7047 }
7057 err_unregister:
7060 }
7062 /*
7063 * dgap_cleanup_module()
7064 *
7065 * Module unload. This is where it all ends.
7066 */
7068 {
7071 }