| blob | 0f13bef975f51634fac1f367134a670d95437109 |
1 /*
4 Copyright (C) 1996 Digi International.
6 For technical support please email digiLinux@dgii.com or
7 call Digi tech support at (612) 912-3456
9 Much of this design and code came from epca.c which was
10 copyright (C) 1994, 1995 Troy De Jongh, and subsquently
11 modified by David Nugent, Christoph Lameter, Mike McLagan.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 --------------------------------------------------------------------------- */
28 /* See README.epca for change history --DAT*/
31 #include <linux/config.h>
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/types.h>
35 #include <linux/init.h>
36 #include <linux/serial.h>
37 #include <linux/delay.h>
38 #include <linux/ctype.h>
39 #include <linux/tty.h>
40 #include <linux/tty_flip.h>
41 #include <linux/slab.h>
42 #include <linux/ioport.h>
43 #include <linux/interrupt.h>
44 #include <asm/uaccess.h>
45 #include <asm/io.h>
47 #ifdef CONFIG_PCI
48 #define ENABLE_PCI
51 #define putUser(arg1, arg2) put_user(arg1, (unsigned long __user *)arg2)
52 #define getUser(arg1, arg2) get_user(arg1, (unsigned __user *)arg2)
54 #ifdef ENABLE_PCI
55 #include <linux/pci.h>
64 #if BITS_PER_LONG != 32
65 # error FIXME: this driver only works on 32-bit platforms
66 #endif
68 /* ---------------------- Begin defines ------------------------ */
72 /* This major needs to be submitted to Linux to join the majors list */
77 #define MAXCARDS 7
78 #define epcaassert(x, msg) if (!(x)) epca_error(__LINE__, msg)
82 /* ----------------- Begin global definitions ------------------- */
91 /* -----------------------------------------------------------------------
92 MAXBOARDS is typically 12, but ISA and EISA cards are restricted to
93 7 below.
94 --------------------------------------------------------------------------*/
98 /* ------------- Begin structures used for driver registeration ---------- */
103 /* ------------------ Begin Digi specific structures -------------------- */
105 /* ------------------------------------------------------------------------
106 digi_channels represents an array of structures that keep track of
107 each channel of the Digi product. Information such as transmit and
108 receive pointers, termio data, and signal definitions (DTR, CTS, etc ...)
109 are stored here. This structure is NOT used to overlay the cards
110 physical channel structure.
111 -------------------------------------------------------------------------- */
115 /* ------------------------------------------------------------------------
116 card_ptr is an array used to hold the address of the
117 first channel structure of each card. This array will hold
118 the addresses of various channels located in digi_channels.
119 -------------------------------------------------------------------------- */
124 /* ---------------------- Begin function prototypes --------------------- */
126 /* ----------------------------------------------------------------------
127 Begin generic memory functions. These functions will be alias
128 (point at) more specific functions dependent on the board being
129 configured.
130 ----------------------------------------------------------------------- */
141 /* ---- Begin more 'specific' memory functions for cx_like products --- */
150 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
159 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
160 /* Note : pc64xe and pcxi share the same windowing routines */
169 /* - Begin 'specific' do nothing memory functions needed for some cards - */
180 /* ------------------- Begin declare functions ----------------------- */
224 #ifdef ENABLE_PCI
229 /* ------------------------------------------------------------------
230 Table of functions for each board to handle memory. Mantaining
231 parallelism is a *very* good idea here. The idea is for the
232 runtime code to blindly call these functions, not knowing/caring
233 about the underlying hardware. This stuff should contain no
234 conditionals; if more functionality is needed a different entry
235 should be established. These calls are the interface calls and
236 are the only functions that should be accessed. Anyone caught
237 making direct calls deserves what they get.
238 -------------------------------------------------------------------- */
241 {
243 }
246 {
248 }
251 {
253 }
256 {
258 }
261 {
263 }
266 {
268 }
270 {
272 }
275 {
277 }
279 /* ---------------------------------------------------------
280 PCXEM windowing is the same as that used in the PCXR
281 and CX series cards.
282 ------------------------------------------------------------ */
285 {
287 }
290 {
292 }
295 {
297 }
300 {
302 }
305 {
307 }
310 {
312 }
314 /* ----------------- Begin pcxe memory window stuff ------------------ */
317 {
319 }
322 {
326 }
329 {
331 }
334 {
336 }
339 {
341 }
344 {
347 }
349 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
352 {
354 }
357 {
359 }
362 {
364 }
367 {
369 }
372 {
374 }
377 {
379 }
382 {
384 }
387 {
389 }
392 /* ----------------------------------------------------------------------
393 Not all of the cards need specific memory windowing routines. Some
394 cards (Such as PCI) needs no windowing routines at all. We provide
395 these do nothing routines so that the same code base can be used.
396 The driver will ALWAYS call a windowing routine if it thinks it needs
397 to; regardless of the card. However, dependent on the card the routine
398 may or may not do anything.
399 ---------------------------------------------------------------------------*/
402 {
403 }
406 {
407 }
410 {
411 }
414 {
415 }
418 {
419 }
422 {
423 }
426 {
427 }
430 {
431 }
433 /* ----------------- Begin verifyChannel function ----------------------- */
437 /* --------------------------------------------------------------------
438 This routine basically provides a sanity check. It insures that
439 the channel returned is within the proper range of addresses as
440 well as properly initialized. If some bogus info gets passed in
441 through tty->driver_data this should catch it.
442 --------------------------------------------------------------------- */
450 {
453 }
457 /* Else return a NULL for invalid */
462 /* ------------------ Begin pc_sched_event ------------------------- */
468 /* ----------------------------------------------------------------------
469 We call this to schedule interrupt processing on some event. The
470 kernel sees our request and calls the related routine in OUR driver.
471 -------------------------------------------------------------------------*/
479 /* ------------------ Begin epca_error ------------------------- */
489 /* ------------------ Begin pc_close ------------------------- */
496 /* ---------------------------------------------------------
497 verifyChannel returns the channel from the tty struct
498 if it is valid. This serves as a sanity check.
499 ------------------------------------------------------------- */
508 {
511 }
513 /* Check to see if the channel is open more than once */
517 /* -------------------------------------------------------------
518 Return without doing anything. Someone might still be using
519 the channel.
520 ---------------------------------------------------------------- */
526 /* Port open only once go ahead with shutdown & reset */
529 {
531 }
533 /* ---------------------------------------------------------------
534 Let the rest of the driver know the channel is being closed.
535 This becomes important if an open is attempted before close
536 is finished.
537 ------------------------------------------------------------------ */
544 {
545 /* Setup an event to indicate when the transmit buffer empties */
548 }
563 {
566 }
573 ASYNC_CLOSING);
583 /* ------------------ Begin shutdown ------------------------- */
601 /* ------------------------------------------------------------------
602 In order for an event to be generated on the receipt of data the
603 idata flag must be set. Since we are shutting down, this is not
604 necessary clear this flag.
605 --------------------------------------------------------------------- */
612 /* ----------------------------------------------------------------
613 If we're a modem control device and HUPCL is on, drop RTS & DTR.
614 ------------------------------------------------------------------ */
617 {
620 }
624 /* ------------------------------------------------------------------
625 The channel has officialy been closed. The next time it is opened
626 it will have to reinitialized. Set a flag to indicate this.
627 ---------------------------------------------------------------------- */
629 /* Prevent future Digi programmed interrupts from coming active */
636 /* ------------------ Begin pc_hangup ------------------------- */
643 /* ---------------------------------------------------------
644 verifyChannel returns the channel from the tty struct
645 if it is valid. This serves as a sanity check.
646 ------------------------------------------------------------- */
671 /* ------------------ Begin pc_write ------------------------- */
689 /* ----------------------------------------------------------------
690 pc_write is primarily called directly by the kernel routine
691 tty_write (Though it can also be called by put_char) found in
692 tty_io.c. pc_write is passed a line discipline buffer where
693 the data to be written out is stored. The line discipline
694 implementation itself is done at the kernel level and is not
695 brought into the driver.
696 ------------------------------------------------------------------- */
698 /* ---------------------------------------------------------
699 verifyChannel returns the channel from the tty struct
700 if it is valid. This serves as a sanity check.
701 ------------------------------------------------------------- */
706 /* Make a pointer to the channel data structure found on the board. */
719 /* -----------------------------------------------------------------
720 Anding against size will wrap the pointer back to its beginning
721 position if it is necessary. This will only work if size is
722 a power of 2 which should always be the case. Size is determined
723 by the cards on board FEP/OS.
724 -------------------------------------------------------------------- */
726 /* head refers to the next empty location in which data may be stored */
730 /* tail refers to the next data byte to be transmitted */
734 /* Consider changing this to a do statement to make sure */
739 /* ------------------------------------------------------------------
740 Anding against size will wrap the pointer back to its beginning
741 position if it is necessary. This will only work if size is
742 a power of 2 which should always be the case. Size is determined
743 by the cards on board FEP/OS.
744 --------------------------------------------------------------------- */
748 /* -----------------------------------------------------------------
749 Two situations can affect how space in the transmit buffer
750 is calculated. You can have a situation where the transmit
751 in pointer (tin) head has wrapped around and actually has a
752 lower address than the transmit out pointer (tout) tail; or
753 the transmit in pointer (tin) head will not be wrapped around
754 yet, and have a higher address than the transmit out pointer
755 (tout) tail. Obviously space available in the transmit buffer
756 is calculated differently for each case.
758 Example 1:
760 Consider a 10 byte buffer where head is a pointer to the next
761 empty location in the buffer and tail is a pointer to the next
762 byte to transmit. In this example head will not have wrapped
763 around and therefore head > tail.
765 0 1 2 3 4 5 6 7 8 9
766 tail head
768 The above diagram shows that buffer locations 2,3,4,5 and 6 have
769 data to be transmitted, while head points at the next empty
770 location. To calculate how much space is available first we have
771 to determine if the head pointer (tin) has wrapped. To do this
772 compare the head pointer to the tail pointer, If head is equal
773 or greater than tail; then it has not wrapped; and the space may
774 be calculated by subtracting tail from head and then subtracting
775 that value from the buffers size. A one is subtracted from the
776 new value to indicate how much space is available between the
777 head pointer and end of buffer; as well as the space between the
778 beginning of the buffer and the tail. If the head is not greater
779 or equal to the tail this indicates that the head has wrapped
780 around to the beginning of the buffer. To calculate the space
781 available in this case simply subtract head from tail. This new
782 value minus one represents the space available betwwen the head
783 and tail pointers. In this example head (7) is greater than tail (2)
784 and therefore has not wrapped around. We find the space by first
785 subtracting tail from head (7-2=5). We then subtract this value
786 from the buffer size of ten and subtract one (10-5-1=4). The space
787 remaining is 4 bytes.
789 Example 2:
791 Consider a 10 byte buffer where head is a pointer to the next
792 empty location in the buffer and tail is a pointer to the next
793 byte to transmit. In this example head will wrapped around and
794 therefore head < tail.
796 0 1 2 3 4 5 6 7 8 9
797 head tail
799 The above diagram shows that buffer locations 7,8,9,0 and 1 have
800 data to be transmitted, while head points at the next empty
801 location. To find the space available we compare head to tail. If
802 head is not equal to, or greater than tail this indicates that head
803 has wrapped around. In this case head (2) is not equal to, or
804 greater than tail (7) and therefore has already wrapped around. To
805 calculate the available space between the two pointers we subtract
806 head from tail (7-2=5). We then subtract one from this new value
807 (5-1=4). We have 5 bytes empty remaining in the buffer. Unlike the
808 previous example these five bytes are located between the head and
809 tail pointers.
811 ----------------------------------------------------------------------- */
815 /* ----------------------------------------------------------------------
816 In this case bytesAvailable has been passed into pc_write and
817 represents the amount of data that needs to be written. dataLen
818 represents the amount of space available on the card. Whichever
819 value is smaller will be the amount actually written.
820 bytesAvailable will then take on this newly calculated value.
821 ---------------------------------------------------------------------- */
825 /* First we read the data in from the file system into a temp buffer */
832 /* ---------------------------------------------------------------
833 The below function reads data from user memory. This routine
834 can not be used in an interrupt routine. (Because it may
835 generate a page fault) It can only be called while we can the
836 user context is accessible.
838 The prototype is :
839 inline void copy_from_user(void * to, const void * from,
840 unsigned long count);
842 I also think (Check hackers guide) that optimization must
843 be turned ON. (Which sounds strange to me...)
845 Remember copy_from_user WILL generate a page fault if the
846 user memory being accessed has been swapped out. This can
847 cause this routine to temporarily sleep while this page
848 fault is occurring.
850 ----------------------------------------------------------------- */
853 bytesAvailable))
857 /* ------------------------------------------------------------------
858 Set buf to this address for the moment. tmp_buf was allocated in
859 post_fep_init.
860 --------------------------------------------------------------------- */
865 /* All data is now local */
880 /* If head >= tail, head has not wrapped around. */
884 /* ---------------------------------------------------------------
885 remain (much like dataLen above) represents the total amount of
886 space available on the card for data. Here dataLen represents
887 the space existing between the head pointer and the end of
888 buffer. This is important because a memcpy cannot be told to
889 automatically wrap around when it hits the buffer end.
890 ------------------------------------------------------------------ */
896 else
904 /* -------------------------------------------------------------------
905 Check the space on the card. If we have more data than
906 space; reduce the amount of data to fit the space.
907 ---------------------------------------------------------------------- */
915 /* -----------------------------------------------------------------
916 If head is not wrapped, the below will make sure the first
917 data copy fills to the end of card buffer.
918 ------------------------------------------------------------------- */
928 {
931 }
940 {
943 }
951 /* ------------------ Begin pc_put_char ------------------------- */
962 /* ------------------ Begin pc_write_room ------------------------- */
975 /* ---------------------------------------------------------
976 verifyChannel returns the channel from the tty struct
977 if it is valid. This serves as a sanity check.
978 ------------------------------------------------------------- */
981 {
992 /* Wrap tail if necessary */
999 {
1002 }
1005 }
1007 /* Return how much room is left on card */
1012 /* ------------------ Begin pc_chars_in_buffer ---------------------- */
1025 /* ---------------------------------------------------------
1026 verifyChannel returns the channel from the tty struct
1027 if it is valid. This serves as a sanity check.
1028 ------------------------------------------------------------- */
1044 else
1050 /* --------------------------------------------------------------
1051 The logic here is basically opposite of the above pc_write_room
1052 here we are finding the amount of bytes in the buffer filled.
1053 Not the amount of bytes empty.
1054 ------------------------------------------------------------------- */
1061 /* -------------------------------------------------------------
1062 Make it possible to wakeup anything waiting for output
1063 in tty_ioctl.c, etc.
1065 If not already set. Setup an event to indicate when the
1066 transmit buffer empties
1067 ----------------------------------------------------------------- */
1077 /* Return number of characters residing on card. */
1082 /* ------------------ Begin pc_flush_buffer ---------------------- */
1093 /* ---------------------------------------------------------
1094 verifyChannel returns the channel from the tty struct
1095 if it is valid. This serves as a sanity check.
1096 ------------------------------------------------------------- */
1109 /* Have FEP move tout pointer; effectively flushing transmit buffer */
1121 /* ------------------ Begin pc_flush_chars ---------------------- */
1128 /* ---------------------------------------------------------
1129 verifyChannel returns the channel from the tty struct
1130 if it is valid. This serves as a sanity check.
1131 ------------------------------------------------------------- */
1134 {
1140 /* ----------------------------------------------------------------
1141 If not already set and the transmitter is busy setup an event
1142 to indicate when the transmit empties.
1143 ------------------------------------------------------------------- */
1149 }
1153 /* ------------------ Begin block_til_ready ---------------------- */
1165 {
1168 else
1171 }
1173 /* -----------------------------------------------------------------
1174 If the device is in the middle of being closed, then block
1175 until it's done, and then try again.
1176 -------------------------------------------------------------------- */
1178 {
1183 else
1185 }
1188 {
1189 /* -----------------------------------------------------------------
1190 If non-blocking mode is set, then make the check up front
1191 and then exit.
1192 -------------------------------------------------------------------- */
1197 }
1203 /* Block waiting for the carrier detect and the line to become free */
1211 /* We dec count so that pc_close will know when to free things */
1226 {
1229 else
1232 }
1239 {
1242 }
1244 /* ---------------------------------------------------------------
1245 Allow someone else to be scheduled. We will occasionally go
1246 through this loop until one of the above conditions change.
1247 The below schedule call will allow other processes to enter and
1248 prevent this loop from hogging the cpu.
1249 ------------------------------------------------------------------ */
1272 /* ------------------ Begin pc_open ---------------------- */
1285 {
1289 }
1295 /* Check status of board configured in system. */
1297 /* -----------------------------------------------------------------
1298 I check to see if the epca_setup routine detected an user error.
1299 It might be better to put this in pc_init, but for the moment it
1300 goes here.
1301 ---------------------------------------------------------------------- */
1304 {
1312 printk(KERN_ERR "<Error> - pc_open: Invalid board memory address specified in LILO command\n");
1325 }
1328 {
1331 }
1334 {
1337 }
1339 /* ------------------------------------------------------------------
1340 Every time a channel is opened, increment a counter. This is
1341 necessary because we do not wish to flush and shutdown the channel
1342 until the last app holding the channel open, closes it.
1343 --------------------------------------------------------------------- */
1347 /* ----------------------------------------------------------------
1348 Set a kernel structures pointer to our local channel
1349 structure. This way we can get to it when passed only
1350 a tty struct.
1351 ------------------------------------------------------------------ */
1355 /* ----------------------------------------------------------------
1356 If this is the first time the channel has been opened, initialize
1357 the tty->termios struct otherwise let pc_close handle it.
1358 -------------------------------------------------------------------- */
1366 /* Save boards current modem status */
1369 /* ----------------------------------------------------------------
1370 Set receive head and tail ptrs to each other. This indicates
1371 no data available to read.
1372 ----------------------------------------------------------------- */
1376 /* Set the channels associated tty structure */
1379 /* -----------------------------------------------------------------
1380 The below routine generally sets up parity, baud, flow control
1381 issues, etc.... It effect both control flags and input flags.
1382 -------------------------------------------------------------------- */
1392 {
1394 }
1396 /* -------------------------------------------------------------
1397 Set this again in case a hangup set it to zero while this
1398 open() was waiting for the line...
1399 --------------------------------------------------------------- */
1406 /* Enable Digi Data events */
1416 #ifdef MODULE
1430 }
1433 #endif
1435 #ifdef ENABLE_PCI
1437 #endif
1439 #ifdef MODULE
1440 /* -------------------- Begin cleanup_module ---------------------- */
1443 {
1457 {
1461 }
1482 {
1486 }
1491 #ifdef ENABLE_PCI
1493 #endif
1497 }
1517 };
1520 {
1522 }
1527 };
1529 /* ------------------ Begin pc_init ---------------------- */
1534 /* ----------------------------------------------------------------
1535 pc_init is called by the operating system during boot up prior to
1536 any open calls being made. In the older versions of Linux (Prior
1537 to 2.0.0) an entry is made into tty_io.c. A pointer to the last
1538 memory location (from kernel space) used (kmem_start) is passed
1539 to pc_init. It is pc_inits responsibility to modify this value
1540 for any memory that the Digi driver might need and then return
1541 this value to the operating system. For example if the driver
1542 wishes to allocate 1K of kernel memory, pc_init would return
1543 (kmem_start + 1024). This memory (Between kmem_start and kmem_start
1544 + 1024) would then be available for use exclusively by the driver.
1545 In this case our driver does not allocate any of this kernel
1546 memory.
1547 ------------------------------------------------------------------*/
1549 ulong flags;
1554 #ifdef ENABLE_PCI
1568 }
1570 /* -----------------------------------------------------------------------
1571 If epca_setup has not been ran by LILO set num_cards to defaults; copy
1572 board structure defined by digiConfig into drivers board structure.
1573 Note : If LILO has ran epca_setup then epca_setup will handle defining
1574 num_cards as well as copying the data into the board structure.
1575 -------------------------------------------------------------------------- */
1585 /* -----------------------------------------------------------------
1586 Note : If lilo was used to configure the driver and the
1587 ignore epcaconfig option was choosen (digiepca=2) then
1588 nbdevs and num_cards will equal 0 at this point. This is
1589 okay; PCI cards will still be picked up if detected.
1590 --------------------------------------------------------------------- */
1592 /* -----------------------------------------------------------
1593 Set up interrupt, we will worry about memory allocation in
1594 post_fep_init.
1595 --------------------------------------------------------------- */
1600 #ifdef ENABLE_PCI
1602 /* ------------------------------------------------------------------
1603 NOTE : This code assumes that the number of ports found in
1604 the boards array is correct. This could be wrong if
1605 the card in question is PCI (And therefore has no ports
1606 entry in the boards structure.) The rest of the
1607 information will be valid for PCI because the beginning
1608 of pc_init scans for PCI and determines i/o and base
1609 memory addresses. I am not sure if it is possible to
1610 read the number of ports supported by the card prior to
1611 it being booted (Since that is the state it is in when
1612 pc_init is run). Because it is not possible to query the
1613 number of supported ports until after the card has booted;
1614 we are required to calculate the card_ptrs as the card is
1615 is initialized (Inside post_fep_init). The negative thing
1616 about this approach is that digiDload's call to GET_INFO
1617 will have a bad port value. (Since this is called prior
1618 to post_fep_init.)
1620 --------------------------------------------------------------------- */
1665 /* ------------------------------------------------------------------
1666 This is where the appropriate memory handlers for the hardware is
1667 set. Everything at runtime blindly jumps through these vectors.
1668 ---------------------------------------------------------------------- */
1670 /* defined in epcaconfig.h */
1731 /* ---------------------------------------------------------------
1732 Some cards need a memory segment to be defined for use in
1733 transmit and receive windowing operations. These boards
1734 are listed in the below switch. In the case of the XI the
1735 amount of memory on the board is variable so the memory_seg
1736 is also variable. This code determines what they segment
1737 should be.
1738 ----------------------------------------------------------------- */
1754 /* Is it a 64K board */
1758 /* Is it a 128K board */
1762 /* Is is a 256K board */
1766 /* Is it a 512K board */
1771 else
1772 {
1774 }
1787 /* -------------------------------------------------------------------
1788 Start up the poller to check for events on all enabled boards
1789 ---------------------------------------------------------------------- */
1801 /* ------------------ Begin post_fep_init ---------------------- */
1814 /* -------------------------------------------------------------
1815 This call is made by the user via. the ioctl call DIGI_INIT.
1816 It is responsible for setting up all the card specific stuff.
1817 ---------------------------------------------------------------- */
1820 /* -----------------------------------------------------------------
1821 If this is a PCI board, get the port info. Remember PCI cards
1822 do not have entries into the epcaconfig.h file, so we can't get
1823 the number of ports from it. Unfortunetly, this means that anyone
1824 doing a DIGI_GETINFO before the board has booted will get an invalid
1825 number of ports returned (It should return 0). Calls to DIGI_GETINFO
1826 after DIGI_INIT has been called will return the proper values.
1827 ------------------------------------------------------------------- */
1832 /* --------------------------------------------------------------------
1833 Below we use XEMPORTS as a memory offset regardless of which PCI
1834 card it is. This is because all of the supported PCI cards have
1835 the same memory offset for the channel data. This will have to be
1836 changed if we ever develop a PCI/XE card. NOTE : The FEP manual
1837 states that the port offset is 0xC22 as opposed to 0xC02. This is
1838 only true for PC/XE, and PC/XI cards; not for the XEM, or CX series.
1839 On the PCI cards the number of ports is determined by reading a
1840 ID PROM located in the box attached to the card. The card can then
1841 determine the index the id to determine the number of ports available.
1842 (FYI - The id should be located at 0x1ac (And may use up to 4 bytes
1843 if the box in question is a XEM or CX)).
1844 ------------------------------------------------------------------------ */
1857 else
1867 /*
1868 The below command is necessary because newer kernels (2.1.x and
1869 up) do not have a 1:1 virtual to physical mapping. The below
1870 call adjust for that.
1871 */
1875 /* -----------------------------------------------------------------
1876 The below assignment will set bc to point at the BEGINING of
1877 the cards channel structures. For 1 card there will be between
1878 8 and 64 of these structures.
1879 -------------------------------------------------------------------- */
1883 /* -------------------------------------------------------------------
1884 The below assignment will set gd to point at the BEGINING of
1885 global memory address 0xc00. The first data in that global
1886 memory actually starts at address 0xc1a. The command in
1887 pointer begins at 0xd10.
1888 ---------------------------------------------------------------------- */
1892 /* --------------------------------------------------------------------
1893 XEPORTS (address 0xc22) points at the number of channels the
1894 card supports. (For 64XE, XI, XEM, and XR use 0xc02)
1895 ----------------------------------------------------------------------- */
1906 /* --------------------------------------------------------------------
1907 Remember ch is the main drivers channels structure, while bc is
1908 the cards channel structure.
1909 ------------------------------------------------------------------------ */
1911 /* For every port on the card do ..... */
1924 /* ----------------------------------------------------------------
1925 Since some of the boards use different bitmaps for their
1926 control signals we cannot hard code these values and retain
1927 portability. We virtualize this data here.
1928 ------------------------------------------------------------------- */
1957 {
1961 }
1962 else
1963 {
1966 }
1974 {
1977 }
1985 /* Cover all the 2MEG cards */
1994 /* Cover all the 32K windowed cards */
1995 /* Mask equal to window size - 1 */
2027 /* Set transmitter low water mark */
2030 /* Set receiver low water mark */
2034 /* Set receiver high water mark */
2061 {
2067 }
2068 else
2084 /* --------------------- Begin epcapoll ------------------------ */
2095 /* -------------------------------------------------------------------
2096 This routine is called upon every timer interrupt. Even though
2097 the Digi series cards are capable of generating interrupts this
2098 method of non-looping polling is more efficient. This routine
2099 checks for card generated events (Such as receive data, are transmit
2100 buffer empty) and acts on those events.
2101 ----------------------------------------------------------------------- */
2115 /* -----------------------------------------------------------
2116 assertmemoff is not needed here; indeed it is an empty subroutine.
2117 It is being kept because future boards may need this as well as
2118 some legacy boards.
2119 ---------------------------------------------------------------- */
2125 /* ---------------------------------------------------------------
2126 In this case head and tail actually refer to the event queue not
2127 the transmit or receive queue.
2128 ------------------------------------------------------------------- */
2133 /* If head isn't equal to tail we have an event */
2147 /* --------------------- Begin doevent ------------------------ */
2161 /* -------------------------------------------------------------------
2162 This subroutine is called by epcapoll when an event is detected
2163 in the event queue. This routine responds to those events.
2164 --------------------------------------------------------------------- */
2180 /* Get the channel the event occurred on */
2183 /* Get the actual event code that occurred */
2186 /* ----------------------------------------------------------------
2187 The two assignments below get the current modem status (mstat)
2188 and the previous modem status (lstat). These are useful becuase
2189 an event could signal a change in modem signals itself.
2190 ------------------------------------------------------------------- */
2198 {
2203 }
2219 /* A modem signal change has been indicated */
2224 {
2227 else
2229 }
2240 /* A break has been indicated */
2250 else
2264 else
2268 /* This event is generated by setup_empty_event */
2286 next:
2291 else
2301 /* --------------------- Begin fepcmd ------------------------ */
2312 /* This is the routine in which commands may be passed to the card. */
2315 {
2317 }
2321 /* Remember head (As well as max) is just an offset not a base addr */
2324 /* cmdStart is a base address */
2327 /* ------------------------------------------------------------------
2328 We do the addition below because we do not want a max pointer
2329 relative to cmdStart. We want a max pointer that points at the
2330 physical end of the command queue.
2331 -------------------------------------------------------------------- */
2337 /*
2338 The below command is necessary because newer kernels (2.1.x and
2339 up) do not have a 1:1 virtual to physical mapping. The below
2340 call adjust for that.
2341 */
2346 {
2352 }
2355 {
2359 /* Below word_or_byte is bits to set */
2361 /* Below byte2 is bits to reset */
2364 }
2365 else
2366 {
2370 }
2380 count--;
2382 {
2385 }
2392 /* ----------------------------------------------------------
2393 Basically this will break when the FEP acknowledges the
2394 command by incrementing cmdTail (Making it equal to head).
2395 ------------------------------------------------------------- */
2404 /* ---------------------------------------------------------------------
2405 Digi products use fields in their channels structures that are very
2406 similar to the c_cflag and c_iflag fields typically found in UNIX
2407 termios structures. The below three routines allow mappings
2408 between these hardware "flags" and their respective Linux flags.
2409 ------------------------------------------------------------------------- */
2411 /* --------------------- Begin termios2digi_h -------------------- */
2419 {
2422 }
2449 /* --------------------- Begin termios2digi_i -------------------- */
2462 /* --------------------- Begin termios2digi_c -------------------- */
2469 #ifdef SPEED_HACK
2470 /* CL: HACK to force 115200 at 38400 and 57600 at 19200 Baud */
2480 /* -------------------------------------------------------------
2481 HUPCL bit is used by FEP to indicate fast baud
2482 table is to be used.
2483 ----------------------------------------------------------------- */
2490 /* -------------------------------------------------------------------
2491 CBAUD has bit position 0x1000 set these days to indicate Linux
2492 baud rate remap. Digi hardware can't handle the bit assignment.
2493 (We use a different bit assignment for high speed.). Clear this
2494 bit out.
2495 ---------------------------------------------------------------------- */
2498 /* -------------------------------------------------------------
2499 This gets a little confusing. The Digi cards have their own
2500 representation of c_cflags controling baud rate. For the most
2501 part this is identical to the Linux implementation. However;
2502 Digi supports one rate (76800) that Linux doesn't. This means
2503 that the c_cflag entry that would normally mean 76800 for Digi
2504 actually means 115200 under Linux. Without the below mapping,
2505 a stty 115200 would only drive the board at 76800. Since
2506 the rate 230400 is also found after 76800, the same problem afflicts
2507 us when we choose a rate of 230400. Without the below modificiation
2508 stty 230400 would actually give us 115200.
2510 There are two additional differences. The Linux value for CLOCAL
2511 (0x800; 0004000) has no meaning to the Digi hardware. Also in
2512 later releases of Linux; the CBAUD define has CBAUDEX (0x1000;
2513 0010000) ored into it (CBAUD = 0x100f as opposed to 0xf). CBAUDEX
2514 should be checked for a screened out prior to termios2digi_c
2515 returning. Since CLOCAL isn't used by the board this can be
2516 ignored as long as the returned value is used only by Digi hardware.
2517 ----------------------------------------------------------------- */
2520 {
2521 /* -------------------------------------------------------------
2522 The below code is trying to guarantee that only baud rates
2523 115200 and 230400 are remapped. We use exclusive or because
2524 the various baud rates share common bit positions and therefore
2525 can't be tested for easily.
2526 ----------------------------------------------------------------- */
2531 {
2533 }
2534 }
2540 /* --------------------- Begin epcaparam ----------------------- */
2564 /* Changing baud in mid-stream transmission can be wonderful */
2565 /* ---------------------------------------------------------------
2566 Flush current transmit buffer by setting cmdTail pointer (tout)
2567 to cmdHead pointer (tin). Hopefully the transmit buffer is empty.
2568 ----------------------------------------------------------------- */
2574 else
2577 /* -------------------------------------------------------------------
2578 c_cflags have changed but that change had nothing to do with BAUD.
2579 Propagate the change to the card.
2580 ---------------------------------------------------------------------- */
2585 {
2587 /* Set baud rate, char size, stop bits, parity */
2589 }
2592 /* ----------------------------------------------------------------
2593 If the user has not forced CLOCAL and if the device is not a
2594 CALLOUT device (Which is always CLOCAL) we set flags such that
2595 the driver will wait on carrier detect.
2596 ------------------------------------------------------------------- */
2602 else
2613 /* Check input mode flags */
2616 {
2619 /* ---------------------------------------------------------------
2620 Command sets channels iflag structure on the board. Such things
2621 as input soft flow control, handling of parity errors, and
2622 break handling are all set here.
2623 ------------------------------------------------------------------- */
2625 /* break handling, parity handling, input stripping, flow control chars */
2627 }
2629 /* ---------------------------------------------------------------
2630 Set the board mint value for this channel. This will cause hardware
2631 events to be generated each time the DCD signal (Described in mint)
2632 changes.
2633 ------------------------------------------------------------------- */
2645 {
2648 /* --------------------------------------------------------------
2649 Hard flow control has been selected but the board is not
2650 using it. Activate hard flow control now.
2651 ----------------------------------------------------------------- */
2654 }
2660 {
2663 /* --------------------------------------------------------------
2664 The below command sets the DTR and RTS mstat structure. If
2665 hard flow control is NOT active these changes will drive the
2666 output of the actual DTR and RTS lines. If hard flow control
2667 is active, the changes will be saved in the mstat structure and
2668 only asserted when hard flow control is turned off.
2669 ----------------------------------------------------------------- */
2671 /* First reset DTR & RTS; then set them */
2675 }
2678 {
2682 /* ------------------------------------------------------------
2683 The XON / XOFF characters have changed; propagate these
2684 changes to the card.
2685 --------------------------------------------------------------- */
2688 }
2691 {
2695 /* ---------------------------------------------------------------
2696 Similar to the above, this time the auxilarly XON / XOFF
2697 characters have changed; propagate these changes to the card.
2698 ------------------------------------------------------------------ */
2701 }
2705 /* --------------------- Begin receive_data ----------------------- */
2720 /* ---------------------------------------------------------------
2721 This routine is called by doint when a receive data event
2722 has taken place.
2723 ------------------------------------------------------------------- */
2737 {
2740 }
2744 /* ---------------------------------------------------------------------
2745 Get the head and tail pointers to the receiver queue. Wrap the
2746 head pointer if it has reached the end of the buffer.
2747 ------------------------------------------------------------------------ */
2758 /* ------------------------------------------------------------------
2759 If CREAD bit is off or device not open, set TX tail to head
2760 --------------------------------------------------------------------- */
2763 {
2766 }
2772 {
2775 }
2786 /* ---------------------------------------------------------------
2787 Even if head has wrapped around only report the amount of
2788 data to be equal to the size - tail. Remember memcpy can't
2789 automaticly wrap around the receive buffer.
2790 ----------------------------------------------------------------- */
2794 /* --------------------------------------------------------------
2795 Make sure we don't overflow the buffer
2796 ----------------------------------------------------------------- */
2804 /* ---------------------------------------------------------------
2805 Move data read from our card into the line disciplines buffer
2806 for translation if necessary.
2807 ------------------------------------------------------------------ */
2825 /* Must be called with global data */
2833 {
2870 {
2873 }
2883 /* ------------------------------------------------------------
2884 This call is made by the apps to complete the initilization
2885 of the board(s). This routine is responsible for setting
2886 the card to its initial state and setting the drivers control
2887 fields to the sutianle settings for the card in question.
2888 ---------------------------------------------------------------- */
2904 }
2905 /* --------------------- Begin pc_ioctl ----------------------- */
2908 {
2916 else
2917 {
2920 }
2948 }
2952 {
2959 }
2963 /*
2964 * I think this modemfake stuff is broken. It doesn't
2965 * correctly reflect the behaviour desired by the TIOCM*
2966 * ioctls. Therefore this is probably broken.
2967 */
2971 }
2975 }
2979 }
2983 }
2987 /* --------------------------------------------------------------
2988 The below routine generally sets up parity, baud, flow control
2989 issues, etc.... It effect both control flags and input flags.
2990 ------------------------------------------------------------------ */
2996 }
3002 digiflow_t dflow;
3013 else
3014 {
3017 }
3021 /* -------------------------------------------------------------------
3022 For POSIX compliance we need to add more ioctls. See tty_ioctl.c
3023 in /usr/src/linux/drivers/char for a good example. In particular
3024 think about adding TCSETAF, TCSETAW, TCSETA, TCSETSF, TCSETSW, TCSETS.
3025 ---------------------------------------------------------------------- */
3045 /* Setup an event to indicate when the transmit buffer empties */
3059 /* Setup an event to indicate when the transmit buffer empties */
3072 {
3081 }
3120 {
3121 /* Setup an event to indicate when the transmit buffer empties */
3125 }
3126 else
3127 {
3128 /* ldisc lock already held in ioctl */
3131 }
3133 /* Fall Thru */
3140 {
3143 }
3144 else
3145 {
3148 }
3153 /* -----------------------------------------------------------------
3154 The below routine generally sets up parity, baud, flow control
3155 issues, etc.... It effect both control flags and input flags.
3156 ------------------------------------------------------------------- */
3168 {
3171 }
3172 else
3173 {
3176 }
3187 {
3190 }
3191 else
3192 {
3195 }
3206 {
3210 }
3211 else
3212 {
3216 }
3236 /* --------------------- Begin pc_set_termios ----------------------- */
3244 /* ---------------------------------------------------------
3245 verifyChannel returns the channel from the tty struct
3246 if it is valid. This serves as a sanity check.
3247 ------------------------------------------------------------- */
3272 /* --------------------- Begin do_softint ----------------------- */
3280 /* Called in response to a modem change event */
3288 {
3297 }
3302 /* ------------------------------------------------------------
3303 pc_stop and pc_start provide software flow control to the
3304 routine and the pc_ioctl routine.
3305 ---------------------------------------------------------------- */
3307 /* --------------------- Begin pc_stop ----------------------- */
3315 /* ---------------------------------------------------------
3316 verifyChannel returns the channel from the tty struct
3317 if it is valid. This serves as a sanity check.
3318 ------------------------------------------------------------- */
3331 /* STOP transmitting now !! */
3346 /* --------------------- Begin pc_start ----------------------- */
3353 /* ---------------------------------------------------------
3354 verifyChannel returns the channel from the tty struct
3355 if it is valid. This serves as a sanity check.
3356 ------------------------------------------------------------- */
3366 /* Just in case output was resumed because of a change in Digi-flow */
3377 /* Okay, you can start transmitting again... */
3392 /* ------------------------------------------------------------------
3393 The below routines pc_throttle and pc_unthrottle are used
3394 to slow (And resume) the receipt of data into the kernels
3395 receive buffers. The exact occurrence of this depends on the
3396 size of the kernels receive buffer and what the 'watermarks'
3397 are set to for that buffer. See the n_ttys.c file for more
3398 details.
3399 ______________________________________________________________________ */
3400 /* --------------------- Begin throttle ----------------------- */
3408 /* ---------------------------------------------------------
3409 verifyChannel returns the channel from the tty struct
3410 if it is valid. This serves as a sanity check.
3411 ------------------------------------------------------------- */
3421 {
3427 }
3434 /* --------------------- Begin unthrottle ----------------------- */
3444 /* ---------------------------------------------------------
3445 verifyChannel returns the channel from the tty struct
3446 if it is valid. This serves as a sanity check.
3447 ------------------------------------------------------------- */
3453 /* Just in case output was resumed because of a change in Digi-flow */
3458 {
3466 }
3473 /* --------------------- Begin digi_send_break ----------------------- */
3484 /* --------------------------------------------------------------------
3485 Maybe I should send an infinite break here, schedule() for
3486 msec amount of time, and then stop the break. This way,
3487 the user can't screw up the FEP by causing digi_send_break()
3488 to be called (i.e. via an ioctl()) more than once in msec amount
3489 of time. Try this for now...
3490 ------------------------------------------------------------------------ */
3499 /* --------------------- Begin setup_empty_event ----------------------- */
3512 /* ------------------------------------------------------------------
3513 When set the iempty flag request a event to be generated when the
3514 transmit buffer is empty (If there is no BREAK in progress).
3515 --------------------------------------------------------------------- */
3523 /* --------------------- Begin get_termio ----------------------- */
3529 /* ---------------------- Begin epca_setup -------------------------- */
3538 /* ----------------------------------------------------------------------
3539 If this routine looks a little strange it is because it is only called
3540 if a LILO append command is given to boot the kernel with parameters.
3541 In this way, we can provide the user a method of changing his board
3542 configuration without rebuilding the kernel.
3543 ----------------------------------------------------------------------- */
3549 /* Assume the data is int first, later we can change it */
3550 /* I think that array position 0 of ints holds the number of args */
3558 /* ---------------------------------------------------------
3559 We check for 2 (As opposed to 1; because 2 is a flag
3560 instructing the driver to ignore epcaconfig.) For this
3561 reason we check for 2.
3562 ------------------------------------------------------------ */
3571 {
3576 }
3583 {
3588 }
3595 {
3600 }
3607 {
3612 }
3620 {
3625 }
3632 {
3633 printk(KERN_ERR "<Error> - epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
3637 }
3650 /* find the next comma or terminator */
3653 /* While string is not null, and a comma hasn't been found */
3655 temp++;
3659 else
3662 /* Set index to the number of args + 1 */
3666 {
3671 else
3674 else
3675 {
3680 }
3691 /* ---------------------------------------------------------------
3692 If the index incremented above refers to a legitamate board
3693 type set it here.
3694 ------------------------------------------------------------------*/
3698 else
3699 {
3704 }
3712 else
3715 else
3716 {
3721 }
3728 t2++;
3731 {
3736 }
3738 /* ------------------------------------------------------------
3739 There is not a man page for simple_strtoul but the code can be
3740 found in vsprintf.c. The first argument is the string to
3741 translate (To an unsigned long obviously), the second argument
3742 can be the address of any character variable or a NULL. If a
3743 variable is given, the end pointer of the string will be stored
3744 in that variable; if a NULL is given the end pointer will
3745 not be returned. The last argument is the base to use. If
3746 a 0 is indicated, the routine will attempt to determine the
3747 proper base by looking at the values prefix (A '0' for octal,
3748 a 'x' for hex, etc ... If a value is given it will use that
3749 value as the base.
3750 ---------------------------------------------------------------- */
3759 t2++;
3762 {
3767 }
3776 t2++;
3779 {
3784 }
3793 }
3800 {
3803 }
3805 /* I should REALLY validate the stuff here */
3807 /* Copies our local copy of board into boards */
3811 /* Does this get called once per lilo arg are what ? */
3817 num_cards++;
3823 #ifdef ENABLE_PCI
3824 /* ------------------------ Begin init_PCI --------------------------- */
3828 brd_xem,
3829 brd_cx,
3830 brd_xrj,
3831 };
3834 /* indexed directly by epic_board_types enum */
3843 };
3848 {
3856 board_num++;
3866 }
3880 }
3887 }
3893 }
3900 }
3902 /* --------------------------------------------------------------
3903 I don't know what the below does, but the hardware guys say
3904 its required on everything except PLX (In this case XRJ).
3905 ---------------------------------------------------------------- */
3909 }
3913 err_out_free_memregion:
3915 err_out_free_iounmap:
3917 err_out_free_pciio:
3919 err_out:
3921 }
3930 };
3949 }