开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
specialix.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：62k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

specialix.c：源码内容
  1. /*
  2.  *      specialix.c  -- specialix IO8+ multiport serial driver.
  3.  *
  4.  *      Copyright (C) 1997  Roger Wolff (R.E.Wolff@BitWizard.nl)
  5.  *      Copyright (C) 1994-1996  Dmitry Gorodchanin (pgmdsg@ibi.com)
  6.  *
  7.  *      Specialix pays for the development and support of this driver.
  8.  *      Please DO contact io8-linux@specialix.co.uk if you require
  9.  *      support. But please read the documentation (specialix.txt)
  10.  *      first.
  11.  *
  12.  *      This driver was developped in the BitWizard linux device
  13.  *      driver service. If you require a linux device driver for your
  14.  *      product, please contact devices@BitWizard.nl for a quote.
  15.  *
  16.  *      This code is firmly based on the riscom/8 serial driver,
  17.  *      written by Dmitry Gorodchanin. The specialix IO8+ card
  18.  *      programming information was obtained from the CL-CD1865 Data
  19.  *      Book, and Specialix document number 6200059: IO8+ Hardware
  20.  *      Functional Specification.
  21.  *
  22.  *      This program is free software; you can redistribute it and/or
  23.  *      modify it under the terms of the GNU General Public License as
  24.  *      published by the Free Software Foundation; either version 2 of
  25.  *      the License, or (at your option) any later version.
  26.  *
  27.  *      This program is distributed in the hope that it will be
  28.  *      useful, but WITHOUT ANY WARRANTY; without even the implied
  29.  *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  30.  *      PURPOSE.  See the GNU General Public License for more details.
  31.  *
  32.  *      You should have received a copy of the GNU General Public
  33.  *      License along with this program; if not, write to the Free
  34.  *      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  35.  *      USA.
  36.  *
  37.  * Revision history:
  38.  *
  39.  * Revision 1.0:  April 1st 1997.
  40.  *                Initial release for alpha testing.
  41.  * Revision 1.1:  April 14th 1997. 
  42.  *                Incorporated Richard Hudsons suggestions, 
  43.  *                removed some debugging printk's.
  44.  * Revision 1.2:  April 15th 1997.
  45.  *                Ported to 2.1.x kernels.
  46.  * Revision 1.3:  April 17th 1997 
  47.  *                Backported to 2.0. (Compatibility macros). 
  48.  * Revision 1.4:  April 18th 1997
  49.  *                Fixed DTR/RTS bug that caused the card to indicate 
  50.  *                "don't send data" to a modem after the password prompt.  
  51.  *                Fixed bug for premature (fake) interrupts.
  52.  * Revision 1.5:  April 19th 1997
  53.  *                fixed a minor typo in the header file, cleanup a little. 
  54.  *                performance warnings are now MAXed at once per minute.
  55.  * Revision 1.6:  May 23 1997
  56.  *                Changed the specialix=... format to include interrupt.
  57.  * Revision 1.7:  May 27 1997
  58.  *                Made many more debug printk's a compile time option.
  59.  * Revision 1.8:  Jul 1  1997
  60.  *                port to linux-2.1.43 kernel.
  61.  * Revision 1.9:  Oct 9  1998
  62.  *                Added stuff for the IO8+/PCI version.
  63.  * Revision 1.10: Oct 22  1999 / Jan 21 2000. 
  64.  *                Added stuff for setserial. 
  65.  *                Nicolas Mailhot (Nicolas.Mailhot@email.enst.fr)
  66.  * 
  67.  */
  69. #define VERSION "1.10"
  72. /*
  73.  * There is a bunch of documentation about the card, jumpers, config
  74.  * settings, restrictions, cables, device names and numbers in
  75.  * ../../Documentation/specialix.txt 
  76.  */
  78. #include <linux/config.h>
  79. #include <linux/module.h>
  81. #include <asm/io.h>
  82. #include <linux/kernel.h>
  83. #include <linux/sched.h>
  84. #include <linux/ioport.h>
  85. #include <linux/interrupt.h>
  86. #include <linux/errno.h>
  87. #include <linux/tty.h>
  88. #include <linux/mm.h>
  89. #include <linux/serial.h>
  90. #include <linux/fcntl.h>
  91. #include <linux/major.h>
  92. #include <linux/delay.h>
  93. #include <linux/tqueue.h>
  94. #include <linux/version.h>
  95. #include <linux/pci.h>
  98. /* ************************************************************** */
  99. /* * This section can be removed when 2.0 becomes outdated....  * */
  100. /* ************************************************************** */
  102. #if LINUX_VERSION_CODE < 131328    /* Less than 2.1.0 */
  103. #define TWO_ZERO
  104. #else
  105. #if LINUX_VERSION_CODE < 131371   /* less than 2.1.43 */
  106. /* This has not been extensively tested yet. Sorry. */
  107. #warning "You're on your own between 2.1.0 and 2.1.43.... "
  108. #warning "Please use a recent kernel."
  109. #endif
  110. #endif
  113. #ifdef TWO_ZERO
  114. #define Get_user(a,b)         a = get_user(b)
  115. #define copy_from_user(a,b,c) memcpy_fromfs(a,b,c)
  116. #define copy_to_user(a,b,c)   memcpy_tofs(a,b,c)
  117. #define queue_task            queue_task_irq_off
  118. #else
  119. #define Get_user(a,b)         get_user(a,b)
  120. #endif
  122. /* ************************************************************** */
  123. /* *                End of compatibility section..              * */
  124. /* ************************************************************** */
  127. #ifndef TWO_ZERO
  128. #include <asm/uaccess.h>
  129. #endif
  131. #include "specialix_io8.h"
  132. #include "cd1865.h"
  136. /* Configurable options: */
  138. /* Am I paranoid or not ? ;-) */
  139. #define SPECIALIX_PARANOIA_CHECK
  141. /* Do I trust the IRQ from the card? (enabeling it doesn't seem to help)
  142.    When the IRQ routine leaves the chip in a state that is keeps on
  143.    requiring attention, the timer doesn't help either. */
  144. #undef SPECIALIX_TIMER
  146. /* 
  147.  * The following defines are mostly for testing purposes. But if you need
  148.  * some nice reporting in your syslog, you can define them also.
  149.  */
  150. #undef SX_REPORT_FIFO
  151. #undef SX_REPORT_OVERRUN
  155. #ifdef CONFIG_SPECIALIX_RTSCTS
  156. #define SX_CRTSCTS(bla) 1
  157. #else
  158. #define SX_CRTSCTS(tty) C_CRTSCTS(tty)
  159. #endif
  162. /* Used to be outb (0xff, 0x80); */
  163. #define short_pause() udelay (1)
  166. #define SPECIALIX_LEGAL_FLAGS 
  167. (ASYNC_HUP_NOTIFY   | ASYNC_SAK          | ASYNC_SPLIT_TERMIOS   | 
  168.  ASYNC_SPD_HI       | ASYNC_SPEED_VHI    | ASYNC_SESSION_LOCKOUT | 
  169.  ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
  171. #ifndef MIN
  172. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  173. #endif
  175. DECLARE_TASK_QUEUE(tq_specialix);
  177. #undef RS_EVENT_WRITE_WAKEUP
  178. #define RS_EVENT_WRITE_WAKEUP 0
  180. #define SPECIALIX_TYPE_NORMAL 1
  181. #define SPECIALIX_TYPE_CALLOUT 2
  183. static struct tty_driver specialix_driver, specialix_callout_driver;
  184. static int    specialix_refcount;
  185. static struct tty_struct * specialix_table[SX_NBOARD * SX_NPORT];
  186. static struct termios * specialix_termios[SX_NBOARD * SX_NPORT];
  187. static struct termios * specialix_termios_locked[SX_NBOARD * SX_NPORT];
  188. static unsigned char * tmp_buf;
  189. static DECLARE_MUTEX(tmp_buf_sem);
  191. static unsigned long baud_table[] =  {
  192. 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
  193. 9600, 19200, 38400, 57600, 115200, 0, 
  194. };
  196. static struct specialix_board sx_board[SX_NBOARD] =  {
  197. { 0, SX_IOBASE1,  9, },
  198. { 0, SX_IOBASE2, 11, },
  199. { 0, SX_IOBASE3, 12, },
  200. { 0, SX_IOBASE4, 15, },
  201. };
  203. static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
  206. #ifdef SPECIALIX_TIMER
  207. static struct timer_list missed_irq_timer;
  208. static void sx_interrupt(int irq, void * dev_id, struct pt_regs * regs);
  209. #endif
  213. static inline int sx_paranoia_check(struct specialix_port const * port,
  214.     kdev_t device, const char *routine)
  215. {
  216. #ifdef SPECIALIX_PARANOIA_CHECK
  217. static const char *badmagic =
  218. KERN_ERR "sx: Warning: bad specialix port magic number for device %s in %sn";
  219. static const char *badinfo =
  220. KERN_ERR "sx: Warning: null specialix port for device %s in %sn";
  221.  
  222. if (!port) {
  223. printk(badinfo, kdevname(device), routine);
  224. return 1;
  225. }
  226. if (port->magic != SPECIALIX_MAGIC) {
  227. printk(badmagic, kdevname(device), routine);
  228. return 1;
  229. }
  230. #endif
  231. return 0;
  232. }
  235. /*
  236.  * 
  237.  *  Service functions for specialix IO8+ driver.
  238.  * 
  239.  */
  241. /* Get board number from pointer */
  242. static inline int board_No (struct specialix_board * bp)
  243. {
  244. return bp - sx_board;
  245. }
  248. /* Get port number from pointer */
  249. static inline int port_No (struct specialix_port const * port)
  250. {
  251. return SX_PORT(port - sx_port); 
  252. }
  255. /* Get pointer to board from pointer to port */
  256. static inline struct specialix_board * port_Board(struct specialix_port const * port)
  257. {
  258. return &sx_board[SX_BOARD(port - sx_port)];
  259. }
  262. /* Input Byte from CL CD186x register */
  263. static inline unsigned char sx_in(struct specialix_board  * bp, unsigned short reg)
  264. {
  265. bp->reg = reg | 0x80;
  266. outb (reg | 0x80, bp->base + SX_ADDR_REG);
  267. return inb  (bp->base + SX_DATA_REG);
  268. }
  271. /* Output Byte to CL CD186x register */
  272. static inline void sx_out(struct specialix_board  * bp, unsigned short reg,
  273.   unsigned char val)
  274. {
  275. bp->reg = reg | 0x80;
  276. outb (reg | 0x80, bp->base + SX_ADDR_REG);
  277. outb (val, bp->base + SX_DATA_REG);
  278. }
  281. /* Input Byte from CL CD186x register */
  282. static inline unsigned char sx_in_off(struct specialix_board  * bp, unsigned short reg)
  283. {
  284. bp->reg = reg;
  285. outb (reg, bp->base + SX_ADDR_REG);
  286. return inb  (bp->base + SX_DATA_REG);
  287. }
  290. /* Output Byte to CL CD186x register */
  291. static inline void sx_out_off(struct specialix_board  * bp, unsigned short reg,
  292.   unsigned char val)
  293. {
  294. bp->reg = reg;
  295. outb (reg, bp->base + SX_ADDR_REG);
  296. outb (val, bp->base + SX_DATA_REG);
  297. }
  300. /* Wait for Channel Command Register ready */
  301. static inline void sx_wait_CCR(struct specialix_board  * bp)
  302. {
  303. unsigned long delay;
  305. for (delay = SX_CCR_TIMEOUT; delay; delay--) 
  306. if (!sx_in(bp, CD186x_CCR))
  307. return;
  309. printk(KERN_ERR "sx%d: Timeout waiting for CCR.n", board_No(bp));
  310. }
  313. /* Wait for Channel Command Register ready */
  314. static inline void sx_wait_CCR_off(struct specialix_board  * bp)
  315. {
  316. unsigned long delay;
  318. for (delay = SX_CCR_TIMEOUT; delay; delay--) 
  319. if (!sx_in_off(bp, CD186x_CCR))
  320. return;
  322. printk(KERN_ERR "sx%d: Timeout waiting for CCR.n", board_No(bp));
  323. }
  326. /*
  327.  *  specialix IO8+ IO range functions.
  328.  */
  330. static inline int sx_check_io_range(struct specialix_board * bp)
  331. {
  332. return check_region (bp->base, SX_IO_SPACE);
  333. }
  336. static inline void sx_request_io_range(struct specialix_board * bp)
  337. {
  338. request_region(bp->base, 
  339.                bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE,
  340.                "specialix IO8+" );
  341. }
  344. static inline void sx_release_io_range(struct specialix_board * bp)
  345. {
  346. release_region(bp->base, 
  347.                bp->flags&SX_BOARD_IS_PCI?SX_PCI_IO_SPACE:SX_IO_SPACE);
  348. }
  351. /* Must be called with enabled interrupts */
  352. /* Ugly. Very ugly. Don't use this for anything else than initialization 
  353.    code */
  354. static inline void sx_long_delay(unsigned long delay)
  355. {
  356. unsigned long i;
  358. for (i = jiffies + delay; time_after(i, jiffies); ) ;
  359. }
  363. /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
  364. int sx_set_irq ( struct specialix_board *bp)
  365. {
  366. int virq;
  367. int i;
  369. if (bp->flags & SX_BOARD_IS_PCI) 
  370. return 1;
  371. switch (bp->irq) {
  372. /* In the same order as in the docs... */
  373. case 15: virq = 0;break;
  374. case 12: virq = 1;break;
  375. case 11: virq = 2;break;
  376. case 9:  virq = 3;break;
  377. default: printk (KERN_ERR "Speclialix: cannot set irq to %d.n", bp->irq);
  378.          return 0;
  379. }
  381. for (i=0;i<2;i++) {
  382. sx_out(bp, CD186x_CAR, i);
  383. sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
  384. }
  385. return 1;
  386. }
  389. /* Reset and setup CD186x chip */
  390. static int sx_init_CD186x(struct specialix_board  * bp)
  391. {
  392. unsigned long flags;
  393. int scaler;
  394. int rv = 1;
  396. save_flags(flags); cli();
  398. sx_wait_CCR_off(bp);    /* Wait for CCR ready        */
  399. sx_out_off(bp, CD186x_CCR, CCR_HARDRESET);      /* Reset CD186x chip          */
  400. sti();
  401. sx_long_delay(HZ/20);                      /* Delay 0.05 sec            */
  402. cli();
  403. sx_out_off(bp, CD186x_GIVR, SX_ID);             /* Set ID for this chip      */
  404. sx_out_off(bp, CD186x_GICR, 0);                 /* Clear all bits            */
  405. sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT);      /* Prio for modem intr       */
  406. sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT);      /* Prio for transmitter intr */
  407. sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT);      /* Prio for receiver intr    */
  408. /* Set RegAckEn */
  409. sx_out_off(bp, CD186x_SRCR, sx_in (bp, CD186x_SRCR) | SRCR_REGACKEN);
  411. /* Setting up prescaler. We need 4 ticks per 1 ms */
  412. scaler =  SX_OSCFREQ/SPECIALIX_TPS;
  414. sx_out_off(bp, CD186x_PPRH, scaler >> 8);
  415. sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
  417. if (!sx_set_irq (bp)) {
  418. /* Figure out how to pass this along... */
  419. printk (KERN_ERR "Cannot set irq to %d.n", bp->irq);
  420. rv = 0;
  421. }
  423. restore_flags(flags);
  424. return rv;
  425. }
  428. int read_cross_byte (struct specialix_board *bp, int reg, int bit)
  429. {
  430. int i;
  431. int t;
  433. for (i=0, t=0;i<8;i++) {
  434. sx_out_off (bp, CD186x_CAR, i);
  435. if (sx_in_off (bp, reg) & bit) 
  436. t |= 1 << i;
  437. }
  438. return t;
  439. }
  442. #ifdef SPECIALIX_TIMER
  443. void missed_irq (unsigned long data)
  444. {
  445. if (sx_in ((struct specialix_board *)data, CD186x_SRSR) &  
  446.                                             (SRSR_RREQint |
  447.                                              SRSR_TREQint |
  448.                                              SRSR_MREQint)) {
  449. printk (KERN_INFO "Missed interrupt... Calling int from timer. n");
  450. sx_interrupt (((struct specialix_board *)data)->irq, 
  451.               NULL, NULL);
  452. }
  453. missed_irq_timer.expires = jiffies + HZ;
  454. add_timer (&missed_irq_timer);
  455. }
  456. #endif
  460. /* Main probing routine, also sets irq. */
  461. static int sx_probe(struct specialix_board *bp)
  462. {
  463. unsigned char val1, val2;
  464. #if 0
  465. int irqs = 0;
  466. int retries;
  467. #endif
  468. int rev;
  469. int chip;
  471. if (sx_check_io_range(bp)) 
  472. return 1;
  474. /* Are the I/O ports here ? */
  475. sx_out_off(bp, CD186x_PPRL, 0x5a);
  476. short_pause ();
  477. val1 = sx_in_off(bp, CD186x_PPRL);
  479. sx_out_off(bp, CD186x_PPRL, 0xa5);
  480. short_pause ();
  481. val2 = sx_in_off(bp, CD186x_PPRL);
  484. if ((val1 != 0x5a) || (val2 != 0xa5)) {
  485. printk(KERN_INFO "sx%d: specialix IO8+ Board at 0x%03x not found.n",
  486.        board_No(bp), bp->base);
  487. return 1;
  488. }
  490. /* Check the DSR lines that Specialix uses as board 
  491.    identification */
  492. val1 = read_cross_byte (bp, CD186x_MSVR, MSVR_DSR);
  493. val2 = read_cross_byte (bp, CD186x_MSVR, MSVR_RTS);
  494. #ifdef SPECIALIX_DEBUG
  495. printk (KERN_DEBUG "sx%d: DSR lines are: %02x, rts lines are: %02xn", 
  496.         board_No(bp),  val1, val2);
  497. #endif
  498. /* They managed to switch the bit order between the docs and
  499.    the IO8+ card. The new PCI card now conforms to old docs.
  500.    They changed the PCI docs to reflect the situation on the
  501.    old card. */
  502. val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
  503. if (val1 != val2) {
  504. printk(KERN_INFO "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).n",
  505.        board_No(bp), val2, bp->base, val1);
  506. return 1;
  507. }
  510. #if 0
  511. /* It's time to find IRQ for this board */
  512. for (retries = 0; retries < 5 && irqs <= 0; retries++) {
  513. irqs = probe_irq_on();
  514. sx_init_CD186x(bp);         /* Reset CD186x chip       */
  515. sx_out(bp, CD186x_CAR, 2);               /* Select port 2          */
  516. sx_wait_CCR(bp);
  517. sx_out(bp, CD186x_CCR, CCR_TXEN);        /* Enable transmitter     */
  518. sx_out(bp, CD186x_IER, IER_TXRDY);       /* Enable tx empty intr   */
  519. sx_long_delay(HZ/20);        
  520. irqs = probe_irq_off(irqs);
  522. #if SPECIALIX_DEBUG > 2
  523. printk (KERN_DEBUG "SRSR = %02x, ",  sx_in(bp, CD186x_SRSR));
  524. printk (           "TRAR = %02x, ",  sx_in(bp, CD186x_TRAR));
  525. printk (           "GIVR = %02x, ",  sx_in(bp, CD186x_GIVR));
  526. printk (           "GICR = %02x, ",  sx_in(bp, CD186x_GICR));
  527. printk (           "n");
  528. #endif
  529. /* Reset CD186x again      */
  530. if (!sx_init_CD186x(bp)) {
  531. /* Hmmm. This is dead code anyway. */
  532. }
  533. #if SPECIALIX_DEBUG > 2
  534. printk (KERN_DEBUG "val1 = %02x, val2 = %02x, val3 = %02x.n", 
  535.         val1, val2, val3); 
  536. #endif
  538. }
  540. #if 0
  541. if (irqs <= 0) {
  542. printk(KERN_ERR "sx%d: Can't find IRQ for specialix IO8+ board at 0x%03x.n",
  543.        board_No(bp), bp->base);
  544. return 1;
  545. }
  546. #endif
  547. printk (KERN_INFO "Started with irq=%d, but now have irq=%d.n", bp->irq, irqs);
  548. if (irqs > 0)
  549. bp->irq = irqs;
  550. #endif
  551. /* Reset CD186x again  */
  552. if (!sx_init_CD186x(bp)) {
  553. return -EIO;
  554. }
  556. sx_request_io_range(bp);
  557. bp->flags |= SX_BOARD_PRESENT;
  559. /* Chip           revcode   pkgtype
  560.                   GFRCR     SRCR bit 7
  561.    CD180 rev B    0x81      0
  562.    CD180 rev C    0x82      0
  563.    CD1864 rev A   0x82      1
  564.    CD1865 rev A   0x83      1  -- Do not use!!! Does not work. 
  565.    CD1865 rev B   0x84      1
  566.  -- Thanks to Gwen Wang, Cirrus Logic.
  567.  */
  569. switch (sx_in_off(bp, CD186x_GFRCR)) {
  570. case 0x82:chip = 1864;rev='A';break;
  571. case 0x83:chip = 1865;rev='A';break;
  572. case 0x84:chip = 1865;rev='B';break;
  573. case 0x85:chip = 1865;rev='C';break; /* Does not exist at this time */
  574. default:chip=-1;rev='x';
  575. }
  577. #if SPECIALIX_DEBUG > 2
  578. printk (KERN_DEBUG " GFCR = 0x%02xn", sx_in_off(bp, CD186x_GFRCR) );
  579. #endif
  581. #ifdef SPECIALIX_TIMER
  582. init_timer (&missed_irq_timer);
  583. missed_irq_timer.function = missed_irq;
  584. missed_irq_timer.data = (unsigned long) bp;
  585. missed_irq_timer.expires = jiffies + HZ;
  586. add_timer (&missed_irq_timer);
  587. #endif
  589. printk(KERN_INFO"sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.n",
  590.        board_No(bp),
  591.        bp->base, bp->irq,
  592.        chip, rev);
  594. return 0;
  595. }
  597. /* 
  598.  * 
  599.  *  Interrupt processing routines.
  600.  * */
  602. static inline void sx_mark_event(struct specialix_port * port, int event)
  603. {
  604. /* 
  605.  * I'm not quite happy with current scheme all serial
  606.  * drivers use their own BH routine.
  607.  * It seems this easily can be done with one BH routine
  608.  * serving for all serial drivers.
  609.  * For now I must introduce another one - SPECIALIX_BH.
  610.  * Still hope this will be changed in near future.
  611.  * -- Dmitry.
  612.  */
  613. set_bit(event, &port->event);
  614. queue_task(&port->tqueue, &tq_specialix);
  615. mark_bh(SPECIALIX_BH);
  616. }
  619. static inline struct specialix_port * sx_get_port(struct specialix_board * bp,
  620.        unsigned char const * what)
  621. {
  622. unsigned char channel;
  623. struct specialix_port * port;
  625. channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
  626. if (channel < CD186x_NCH) {
  627. port = &sx_port[board_No(bp) * SX_NPORT + channel];
  628. if (port->flags & ASYNC_INITIALIZED) {
  629. return port;
  630. }
  631. }
  632. printk(KERN_INFO "sx%d: %s interrupt from invalid port %dn", 
  633.        board_No(bp), what, channel);
  634. return NULL;
  635. }
  638. static inline void sx_receive_exc(struct specialix_board * bp)
  639. {
  640. struct specialix_port *port;
  641. struct tty_struct *tty;
  642. unsigned char status;
  643. unsigned char ch;
  645. if (!(port = sx_get_port(bp, "Receive")))
  646. return;
  648. tty = port->tty;
  649. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  650. printk(KERN_INFO "sx%d: port %d: Working around flip buffer overflow.n",
  651.        board_No(bp), port_No(port));
  652. return;
  653. }
  655. #ifdef SX_REPORT_OVERRUN
  656. status = sx_in(bp, CD186x_RCSR);
  657. if (status & RCSR_OE) {
  658. port->overrun++;
  659. #if SPECIALIX_DEBUG 
  660. printk(KERN_DEBUG "sx%d: port %d: Overrun. Total %ld overruns.n", 
  661.        board_No(bp), port_No(port), port->overrun);
  662. #endif
  663. }
  664. status &= port->mark_mask;
  665. #else
  666. status = sx_in(bp, CD186x_RCSR) & port->mark_mask;
  667. #endif
  668. ch = sx_in(bp, CD186x_RDR);
  669. if (!status) {
  670. return;
  671. }
  672. if (status & RCSR_TOUT) {
  673. printk(KERN_INFO "sx%d: port %d: Receiver timeout. Hardware problems ?n", 
  674.        board_No(bp), port_No(port));
  675. return;
  677. } else if (status & RCSR_BREAK) {
  678. #ifdef SPECIALIX_DEBUG
  679. printk(KERN_DEBUG "sx%d: port %d: Handling break...n",
  680.        board_No(bp), port_No(port));
  681. #endif
  682. *tty->flip.flag_buf_ptr++ = TTY_BREAK;
  683. if (port->flags & ASYNC_SAK)
  684. do_SAK(tty);
  686. } else if (status & RCSR_PE) 
  687. *tty->flip.flag_buf_ptr++ = TTY_PARITY;
  689. else if (status & RCSR_FE) 
  690. *tty->flip.flag_buf_ptr++ = TTY_FRAME;
  692. else if (status & RCSR_OE)
  693. *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
  695. else
  696. *tty->flip.flag_buf_ptr++ = 0;
  698. *tty->flip.char_buf_ptr++ = ch;
  699. tty->flip.count++;
  700. queue_task(&tty->flip.tqueue, &tq_timer);
  701. }
  704. static inline void sx_receive(struct specialix_board * bp)
  705. {
  706. struct specialix_port *port;
  707. struct tty_struct *tty;
  708. unsigned char count;
  710. if (!(port = sx_get_port(bp, "Receive")))
  711. return;
  713. tty = port->tty;
  715. count = sx_in(bp, CD186x_RDCR);
  717. #ifdef SX_REPORT_FIFO
  718. port->hits[count > 8 ? 9 : count]++;
  719. #endif
  721. while (count--) {
  722. if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
  723. printk(KERN_INFO "sx%d: port %d: Working around flip buffer overflow.n",
  724.        board_No(bp), port_No(port));
  725. break;
  726. }
  727. *tty->flip.char_buf_ptr++ = sx_in(bp, CD186x_RDR);
  728. *tty->flip.flag_buf_ptr++ = 0;
  729. tty->flip.count++;
  730. }
  731. queue_task(&tty->flip.tqueue, &tq_timer);
  732. }
  735. static inline void sx_transmit(struct specialix_board * bp)
  736. {
  737. struct specialix_port *port;
  738. struct tty_struct *tty;
  739. unsigned char count;
  742. if (!(port = sx_get_port(bp, "Transmit")))
  743. return;
  745. tty = port->tty;
  747. if (port->IER & IER_TXEMPTY) {
  748. /* FIFO drained */
  749. sx_out(bp, CD186x_CAR, port_No(port));
  750. port->IER &= ~IER_TXEMPTY;
  751. sx_out(bp, CD186x_IER, port->IER);
  752. return;
  753. }
  755. if ((port->xmit_cnt <= 0 && !port->break_length)
  756.     || tty->stopped || tty->hw_stopped) {
  757. sx_out(bp, CD186x_CAR, port_No(port));
  758. port->IER &= ~IER_TXRDY;
  759. sx_out(bp, CD186x_IER, port->IER);
  760. return;
  761. }
  763. if (port->break_length) {
  764. if (port->break_length > 0) {
  765. if (port->COR2 & COR2_ETC) {
  766. sx_out(bp, CD186x_TDR, CD186x_C_ESC);
  767. sx_out(bp, CD186x_TDR, CD186x_C_SBRK);
  768. port->COR2 &= ~COR2_ETC;
  769. }
  770. count = MIN(port->break_length, 0xff);
  771. sx_out(bp, CD186x_TDR, CD186x_C_ESC);
  772. sx_out(bp, CD186x_TDR, CD186x_C_DELAY);
  773. sx_out(bp, CD186x_TDR, count);
  774. if (!(port->break_length -= count))
  775. port->break_length--;
  776. } else {
  777. sx_out(bp, CD186x_TDR, CD186x_C_ESC);
  778. sx_out(bp, CD186x_TDR, CD186x_C_EBRK);
  779. sx_out(bp, CD186x_COR2, port->COR2);
  780. sx_wait_CCR(bp);
  781. sx_out(bp, CD186x_CCR, CCR_CORCHG2);
  782. port->break_length = 0;
  783. }
  784. return;
  785. }
  787. count = CD186x_NFIFO;
  788. do {
  789. sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
  790. port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
  791. if (--port->xmit_cnt <= 0)
  792. break;
  793. } while (--count > 0);
  795. if (port->xmit_cnt <= 0) {
  796. sx_out(bp, CD186x_CAR, port_No(port));
  797. port->IER &= ~IER_TXRDY;
  798. sx_out(bp, CD186x_IER, port->IER);
  799. }
  800. if (port->xmit_cnt <= port->wakeup_chars)
  801. sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  802. }
  805. static inline void sx_check_modem(struct specialix_board * bp)
  806. {
  807. struct specialix_port *port;
  808. struct tty_struct *tty;
  809. unsigned char mcr;
  811. #ifdef SPECIALIX_DEBUG
  812. printk (KERN_DEBUG "Modem intr. ");
  813. #endif
  814. if (!(port = sx_get_port(bp, "Modem")))
  815. return;
  817. tty = port->tty;
  819. mcr = sx_in(bp, CD186x_MCR);
  820. printk ("mcr = %02x.n", mcr);
  822. if ((mcr & MCR_CDCHG)) {
  823. #ifdef SPECIALIX_DEBUG 
  824. printk (KERN_DEBUG "CD just changed... ");
  825. #endif
  826. if (sx_in(bp, CD186x_MSVR) & MSVR_CD) {
  827. #ifdef SPECIALIX_DEBUG
  828. printk ( "Waking up guys in open.n");
  829. #endif
  830. wake_up_interruptible(&port->open_wait);
  831. }
  832. else if (!((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  833.            (port->flags & ASYNC_CALLOUT_NOHUP))) {
  834. #ifdef SPECIALIX_DEBUG
  835. printk ( "Sending HUP.n");
  836. #endif
  837. MOD_INC_USE_COUNT;
  838. if (schedule_task(&port->tqueue_hangup) == 0)
  839. MOD_DEC_USE_COUNT;
  840. } else {
  841. #ifdef SPECIALIX_DEBUG
  842. printk ( "Don't need to send HUP.n");
  843. #endif
  844. }
  845. }
  847. #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
  848. if (mcr & MCR_CTSCHG) {
  849. if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
  850. tty->hw_stopped = 0;
  851. port->IER |= IER_TXRDY;
  852. if (port->xmit_cnt <= port->wakeup_chars)
  853. sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  854. } else {
  855. tty->hw_stopped = 1;
  856. port->IER &= ~IER_TXRDY;
  857. }
  858. sx_out(bp, CD186x_IER, port->IER);
  859. }
  860. if (mcr & MCR_DSSXHG) {
  861. if (sx_in(bp, CD186x_MSVR) & MSVR_DSR) {
  862. tty->hw_stopped = 0;
  863. port->IER |= IER_TXRDY;
  864. if (port->xmit_cnt <= port->wakeup_chars)
  865. sx_mark_event(port, RS_EVENT_WRITE_WAKEUP);
  866. } else {
  867. tty->hw_stopped = 1;
  868. port->IER &= ~IER_TXRDY;
  869. }
  870. sx_out(bp, CD186x_IER, port->IER);
  871. }
  872. #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
  874. /* Clear change bits */
  875. sx_out(bp, CD186x_MCR, 0);
  876. }
  879. /* The main interrupt processing routine */
  880. static void sx_interrupt(int irq, void * dev_id, struct pt_regs * regs)
  881. {
  882. unsigned char status;
  883. unsigned char ack;
  884. struct specialix_board *bp;
  885. unsigned long loop = 0;
  886. int saved_reg;
  888. bp = dev_id;
  890. if (!bp || !(bp->flags & SX_BOARD_ACTIVE)) {
  891. #ifdef SPECIALIX_DEBUG 
  892. printk (KERN_DEBUG "sx: False interrupt. irq %d.n", irq);
  893. #endif
  894. return;
  895. }
  897. saved_reg = bp->reg;
  899. while ((++loop < 16) && (status = (sx_in(bp, CD186x_SRSR) &
  900.                                    (SRSR_RREQint |
  901.                             SRSR_TREQint |
  902.                                     SRSR_MREQint)))) {
  903. if (status & SRSR_RREQint) {
  904. ack = sx_in(bp, CD186x_RRAR);
  906. if (ack == (SX_ID | GIVR_IT_RCV))
  907. sx_receive(bp);
  908. else if (ack == (SX_ID | GIVR_IT_REXC))
  909. sx_receive_exc(bp);
  910. else
  911. printk(KERN_ERR "sx%d: Bad receive ack 0x%02x.n",
  912.        board_No(bp), ack);
  914. } else if (status & SRSR_TREQint) {
  915. ack = sx_in(bp, CD186x_TRAR);
  917. if (ack == (SX_ID | GIVR_IT_TX))
  918. sx_transmit(bp);
  919. else
  920. printk(KERN_ERR "sx%d: Bad transmit ack 0x%02x.n",
  921.        board_No(bp), ack);
  922. } else if (status & SRSR_MREQint) {
  923. ack = sx_in(bp, CD186x_MRAR);
  925. if (ack == (SX_ID | GIVR_IT_MODEM)) 
  926. sx_check_modem(bp);
  927. else
  928. printk(KERN_ERR "sx%d: Bad modem ack 0x%02x.n",
  929.        board_No(bp), ack);
  931. } 
  933. sx_out(bp, CD186x_EOIR, 0);   /* Mark end of interrupt */
  934. }
  935. bp->reg = saved_reg;
  936. outb (bp->reg, bp->base + SX_ADDR_REG);
  937. }
  940. /*
  941.  *  Routines for open & close processing.
  942.  */
  944. void turn_ints_off (struct specialix_board *bp)
  945. {
  946. if (bp->flags & SX_BOARD_IS_PCI) {
  947. /* This was intended for enabeling the interrupt on the
  948.  * PCI card. However it seems that it's already enabled
  949.  * and as PCI interrupts can be shared, there is no real
  950.  * reason to have to turn it off. */
  951. }
  952. (void) sx_in_off (bp, 0); /* Turn off interrupts. */
  953. }
  955. void turn_ints_on (struct specialix_board *bp)
  956. {
  957. if (bp->flags & SX_BOARD_IS_PCI) {
  958. /* play with the PCI chip. See comment above. */
  959. }
  960. (void) sx_in (bp, 0); /* Turn ON interrupts. */
  961. }
  964. /* Called with disabled interrupts */
  965. static inline int sx_setup_board(struct specialix_board * bp)
  966. {
  967. int error;
  969. if (bp->flags & SX_BOARD_ACTIVE) 
  970. return 0;
  972. if (bp->flags & SX_BOARD_IS_PCI)
  973. error = request_irq(bp->irq, sx_interrupt, SA_INTERRUPT | SA_SHIRQ, "specialix IO8+", bp);
  974. else
  975. error = request_irq(bp->irq, sx_interrupt, SA_INTERRUPT, "specialix IO8+", bp);
  977. if (error) 
  978. return error;
  980. turn_ints_on (bp);
  981. bp->flags |= SX_BOARD_ACTIVE;
  983. MOD_INC_USE_COUNT;
  984. return 0;
  985. }
  988. /* Called with disabled interrupts */
  989. static inline void sx_shutdown_board(struct specialix_board *bp)
  990. {
  991. if (!(bp->flags & SX_BOARD_ACTIVE))
  992. return;
  994. bp->flags &= ~SX_BOARD_ACTIVE;
  996. #if SPECIALIX_DEBUG > 2
  997. printk ("Freeing IRQ%d for board %d.n", bp->irq, board_No (bp));
  998. #endif
  999. free_irq(bp->irq, bp);
  1001. turn_ints_off (bp);
  1003. MOD_DEC_USE_COUNT;
  1004. }
  1007. /*
  1008.  * Setting up port characteristics. 
  1009.  * Must be called with disabled interrupts
  1010.  */
  1011. static void sx_change_speed(struct specialix_board *bp, struct specialix_port *port)
  1012. {
  1013. struct tty_struct *tty;
  1014. unsigned long baud;
  1015. long tmp;
  1016. unsigned char cor1 = 0, cor3 = 0;
  1017. unsigned char mcor1 = 0, mcor2 = 0;
  1018. static int again;
  1020. if (!(tty = port->tty) || !tty->termios)
  1021. return;
  1023. port->IER  = 0;
  1024. port->COR2 = 0;
  1025. /* Select port on the board */
  1026. sx_out(bp, CD186x_CAR, port_No(port));
  1028. /* The Specialix board doens't implement the RTS lines.
  1029.    They are used to set the IRQ level. Don't touch them. */
  1030. if (SX_CRTSCTS(tty))
  1031. port->MSVR = MSVR_DTR | (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
  1032. else
  1033. port->MSVR =  (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
  1034. #ifdef DEBUG_SPECIALIX
  1035. printk (KERN_DEBUG "sx: got MSVR=%02x.n", port->MSVR);
  1036. #endif
  1037. baud = C_BAUD(tty);
  1039. if (baud & CBAUDEX) {
  1040. baud &= ~CBAUDEX;
  1041. if (baud < 1 || baud > 2) 
  1042. port->tty->termios->c_cflag &= ~CBAUDEX;
  1043. else
  1044. baud += 15;
  1045. }
  1046. if (baud == 15) {
  1047. if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  1048. baud ++;
  1049. if ((port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  1050. baud += 2;
  1051. }
  1054. if (!baud_table[baud]) {
  1055. /* Drop DTR & exit */
  1056. #ifdef SPECIALIX_DEBUG
  1057. printk (KERN_DEBUG "Dropping DTR...  Hmm....n");
  1058. #endif
  1059. if (!SX_CRTSCTS (tty)) {
  1060. port -> MSVR &= ~ MSVR_DTR;
  1061. sx_out(bp, CD186x_MSVR, port->MSVR );
  1062. } 
  1063. #ifdef DEBUG_SPECIALIX
  1064. else
  1065. printk (KERN_DEBUG "Can't drop DTR: no DTR.n");
  1066. #endif
  1067. return;
  1068. } else {
  1069. /* Set DTR on */
  1070. if (!SX_CRTSCTS (tty)) {
  1071. port ->MSVR |= MSVR_DTR;
  1072. }
  1073. }
  1075. /*
  1076.  * Now we must calculate some speed depended things 
  1077.  */
  1079. /* Set baud rate for port */
  1080. tmp = port->custom_divisor ;
  1081. if ( tmp )
  1082. printk (KERN_INFO "sx%d: Using custom baud rate divisor %ld. n"
  1083.                   "This is an untested option, please be carefull.n",
  1084.                   port_No (port), tmp);
  1085. else
  1086. tmp = (((SX_OSCFREQ + baud_table[baud]/2) / baud_table[baud] +
  1087.          CD186x_TPC/2) / CD186x_TPC);
  1089. if ((tmp < 0x10) && time_before(again, jiffies)) { 
  1090. again = jiffies + HZ * 60;
  1091. /* Page 48 of version 2.0 of the CL-CD1865 databook */
  1092. if (tmp >= 12) {
  1093. printk (KERN_INFO "sx%d: Baud rate divisor is %ld. n"
  1094.         "Performance degradation is possible.n"
  1095.         "Read specialix.txt for more info.n",
  1096.         port_No (port), tmp);
  1097. } else {
  1098. printk (KERN_INFO "sx%d: Baud rate divisor is %ld. n"
  1099.         "Warning: overstressing Cirrus chip. "
  1100.         "This might not work.n"
  1101.         "Read specialix.txt for more info.n", 
  1102.         port_No (port), tmp);
  1103. }
  1104. }
  1106. sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff); 
  1107. sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff); 
  1108. sx_out(bp, CD186x_RBPRL, tmp & 0xff); 
  1109. sx_out(bp, CD186x_TBPRL, tmp & 0xff);
  1111. if (port->custom_divisor) {
  1112. baud = (SX_OSCFREQ + port->custom_divisor/2) / port->custom_divisor;
  1113. baud = ( baud + 5 ) / 10;
  1114. } else 
  1115. baud = (baud_table[baud] + 5) / 10;   /* Estimated CPS */
  1117. /* Two timer ticks seems enough to wakeup something like SLIP driver */
  1118. tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
  1119. port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
  1120.       SERIAL_XMIT_SIZE - 1 : tmp);
  1122. /* Receiver timeout will be transmission time for 1.5 chars */
  1123. tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
  1124. tmp = (tmp > 0xff) ? 0xff : tmp;
  1125. sx_out(bp, CD186x_RTPR, tmp);
  1127. switch (C_CSIZE(tty)) {
  1128.  case CS5:
  1129. cor1 |= COR1_5BITS;
  1130. break;
  1131.  case CS6:
  1132. cor1 |= COR1_6BITS;
  1133. break;
  1134.  case CS7:
  1135. cor1 |= COR1_7BITS;
  1136. break;
  1137.  case CS8:
  1138. cor1 |= COR1_8BITS;
  1139. break;
  1140. }
  1142. if (C_CSTOPB(tty)) 
  1143. cor1 |= COR1_2SB;
  1145. cor1 |= COR1_IGNORE;
  1146. if (C_PARENB(tty)) {
  1147. cor1 |= COR1_NORMPAR;
  1148. if (C_PARODD(tty)) 
  1149. cor1 |= COR1_ODDP;
  1150. if (I_INPCK(tty)) 
  1151. cor1 &= ~COR1_IGNORE;
  1152. }
  1153. /* Set marking of some errors */
  1154. port->mark_mask = RCSR_OE | RCSR_TOUT;
  1155. if (I_INPCK(tty)) 
  1156. port->mark_mask |= RCSR_FE | RCSR_PE;
  1157. if (I_BRKINT(tty) || I_PARMRK(tty)) 
  1158. port->mark_mask |= RCSR_BREAK;
  1159. if (I_IGNPAR(tty)) 
  1160. port->mark_mask &= ~(RCSR_FE | RCSR_PE);
  1161. if (I_IGNBRK(tty)) {
  1162. port->mark_mask &= ~RCSR_BREAK;
  1163. if (I_IGNPAR(tty)) 
  1164. /* Real raw mode. Ignore all */
  1165. port->mark_mask &= ~RCSR_OE;
  1166. }
  1167. /* Enable Hardware Flow Control */
  1168. if (C_CRTSCTS(tty)) {
  1169. #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
  1170. port->IER |= IER_DSR | IER_CTS;
  1171. mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
  1172. mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
  1173. tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) & (MSVR_CTS|MSVR_DSR));
  1174. #else
  1175. port->COR2 |= COR2_CTSAE; 
  1176. #endif
  1177. }
  1178. /* Enable Software Flow Control. FIXME: I'm not sure about this */
  1179. /* Some people reported that it works, but I still doubt it */
  1180. if (I_IXON(tty)) {
  1181. port->COR2 |= COR2_TXIBE;
  1182. cor3 |= (COR3_FCT | COR3_SCDE);
  1183. if (I_IXANY(tty))
  1184. port->COR2 |= COR2_IXM;
  1185. sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
  1186. sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
  1187. sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
  1188. sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
  1189. }
  1190. if (!C_CLOCAL(tty)) {
  1191. /* Enable CD check */
  1192. port->IER |= IER_CD;
  1193. mcor1 |= MCOR1_CDZD;
  1194. mcor2 |= MCOR2_CDOD;
  1195. }
  1197. if (C_CREAD(tty)) 
  1198. /* Enable receiver */
  1199. port->IER |= IER_RXD;
  1201. /* Set input FIFO size (1-8 bytes) */
  1202. cor3 |= SPECIALIX_RXFIFO; 
  1203. /* Setting up CD186x channel registers */
  1204. sx_out(bp, CD186x_COR1, cor1);
  1205. sx_out(bp, CD186x_COR2, port->COR2);
  1206. sx_out(bp, CD186x_COR3, cor3);
  1207. /* Make CD186x know about registers change */
  1208. sx_wait_CCR(bp);
  1209. sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
  1210. /* Setting up modem option registers */
  1211. #ifdef DEBUG_SPECIALIX
  1212. printk ("Mcor1 = %02x, mcor2 = %02x.n", mcor1, mcor2);
  1213. #endif
  1214. sx_out(bp, CD186x_MCOR1, mcor1);
  1215. sx_out(bp, CD186x_MCOR2, mcor2);
  1216. /* Enable CD186x transmitter & receiver */
  1217. sx_wait_CCR(bp);
  1218. sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
  1219. /* Enable interrupts */
  1220. sx_out(bp, CD186x_IER, port->IER);
  1221. /* And finally set the modem lines... */
  1222. sx_out(bp, CD186x_MSVR, port->MSVR);
  1223. }
  1226. /* Must be called with interrupts enabled */
  1227. static int sx_setup_port(struct specialix_board *bp, struct specialix_port *port)
  1228. {
  1229. unsigned long flags;
  1231. if (port->flags & ASYNC_INITIALIZED)
  1232. return 0;
  1234. if (!port->xmit_buf) {
  1235. /* We may sleep in get_free_page() */
  1236. unsigned long tmp;
  1238. if (!(tmp = get_free_page(GFP_KERNEL)))
  1239. return -ENOMEM;
  1241. if (port->xmit_buf) {
  1242. free_page(tmp);
  1243. return -ERESTARTSYS;
  1244. }
  1245. port->xmit_buf = (unsigned char *) tmp;
  1246. }
  1248. save_flags(flags); cli();
  1250. if (port->tty) 
  1251. clear_bit(TTY_IO_ERROR, &port->tty->flags);
  1253. if (port->count == 1) 
  1254. bp->count++;
  1256. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  1257. sx_change_speed(bp, port);
  1258. port->flags |= ASYNC_INITIALIZED;
  1260. restore_flags(flags);
  1261. return 0;
  1262. }
  1265. /* Must be called with interrupts disabled */
  1266. static void sx_shutdown_port(struct specialix_board *bp, struct specialix_port *port)
  1267. {
  1268. struct tty_struct *tty;
  1270. if (!(port->flags & ASYNC_INITIALIZED)) 
  1271. return;
  1273. #ifdef SX_REPORT_OVERRUN
  1274. printk(KERN_INFO "sx%d: port %d: Total %ld overruns were detected.n",
  1275.        board_No(bp), port_No(port), port->overrun);
  1276. #endif
  1277. #ifdef SX_REPORT_FIFO
  1278. {
  1279. int i;
  1281. printk(KERN_INFO "sx%d: port %d: FIFO hits [ ",
  1282.        board_No(bp), port_No(port));
  1283. for (i = 0; i < 10; i++) {
  1284. printk("%ld ", port->hits[i]);
  1285. }
  1286. printk("].n");
  1287. }
  1288. #endif
  1289. if (port->xmit_buf) {
  1290. free_page((unsigned long) port->xmit_buf);
  1291. port->xmit_buf = NULL;
  1292. }
  1294. /* Select port */
  1295. sx_out(bp, CD186x_CAR, port_No(port));
  1297. if (!(tty = port->tty) || C_HUPCL(tty)) {
  1298. /* Drop DTR */
  1299. sx_out(bp, CD186x_MSVDTR, 0);
  1300. }
  1302. /* Reset port */
  1303. sx_wait_CCR(bp);
  1304. sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
  1305. /* Disable all interrupts from this port */
  1306. port->IER = 0;
  1307. sx_out(bp, CD186x_IER, port->IER);
  1309. if (tty)
  1310. set_bit(TTY_IO_ERROR, &tty->flags);
  1311. port->flags &= ~ASYNC_INITIALIZED;
  1313. if (--bp->count < 0) {
  1314. printk(KERN_ERR "sx%d: sx_shutdown_port: bad board count: %dn",
  1315.        board_No(bp), bp->count);
  1316. bp->count = 0;
  1317. }
  1319. /*
  1320.  * If this is the last opened port on the board
  1321.  * shutdown whole board
  1322.  */
  1323. if (!bp->count) 
  1324. sx_shutdown_board(bp);
  1325. }
  1328. static int block_til_ready(struct tty_struct *tty, struct file * filp,
  1329.                            struct specialix_port *port)
  1330. {
  1331. DECLARE_WAITQUEUE(wait,  current);
  1332. struct specialix_board *bp = port_Board(port);
  1333. int    retval;
  1334. int    do_clocal = 0;
  1335. int    CD;
  1337. /*
  1338.  * If the device is in the middle of being closed, then block
  1339.  * until it's done, and then try again.
  1340.  */
  1341. if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
  1342. interruptible_sleep_on(&port->close_wait);
  1343. if (port->flags & ASYNC_HUP_NOTIFY)
  1344. return -EAGAIN;
  1345. else
  1346. return -ERESTARTSYS;
  1347. }
  1349. /*
  1350.  * If this is a callout device, then just make sure the normal
  1351.  * device isn't being used.
  1352.  */
  1353. if (tty->driver.subtype == SPECIALIX_TYPE_CALLOUT) {
  1354. if (port->flags & ASYNC_NORMAL_ACTIVE)
  1355. return -EBUSY;
  1356. if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  1357.     (port->flags & ASYNC_SESSION_LOCKOUT) &&
  1358.     (port->session != current->session))
  1359. return -EBUSY;
  1360. if ((port->flags & ASYNC_CALLOUT_ACTIVE) &&
  1361.     (port->flags & ASYNC_PGRP_LOCKOUT) &&
  1362.     (port->pgrp != current->pgrp))
  1363. return -EBUSY;
  1364. port->flags |= ASYNC_CALLOUT_ACTIVE;
  1365. return 0;
  1366. }
  1368. /*
  1369.  * If non-blocking mode is set, or the port is not enabled,
  1370.  * then make the check up front and then exit.
  1371.  */
  1372. if ((filp->f_flags & O_NONBLOCK) ||
  1373.     (tty->flags & (1 << TTY_IO_ERROR))) {
  1374. if (port->flags & ASYNC_CALLOUT_ACTIVE)
  1375. return -EBUSY;
  1376. port->flags |= ASYNC_NORMAL_ACTIVE;
  1377. return 0;
  1378. }
  1380. if (port->flags & ASYNC_CALLOUT_ACTIVE) {
  1381. if (port->normal_termios.c_cflag & CLOCAL) 
  1382. do_clocal = 1;
  1383. } else {
  1384. if (C_CLOCAL(tty))
  1385. do_clocal = 1;
  1386. }
  1388. /*
  1389.  * Block waiting for the carrier detect and the line to become
  1390.  * free (i.e., not in use by the callout).  While we are in
  1391.  * this loop, info->count is dropped by one, so that
  1392.  * rs_close() knows when to free things.  We restore it upon
  1393.  * exit, either normal or abnormal.
  1394.  */
  1395. retval = 0;
  1396. add_wait_queue(&port->open_wait, &wait);
  1397. cli();
  1398. if (!tty_hung_up_p(filp))
  1399. port->count--;
  1400. sti();
  1401. port->blocked_open++;
  1402. while (1) {
  1403. cli();
  1404. sx_out(bp, CD186x_CAR, port_No(port));
  1405. CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
  1406. if (!(port->flags & ASYNC_CALLOUT_ACTIVE)) {
  1407. if (SX_CRTSCTS (tty)) {
  1408. /* Activate RTS */
  1409. port->MSVR |= MSVR_DTR;
  1410. sx_out (bp, CD186x_MSVR, port->MSVR);
  1411. } else {
  1412. /* Activate DTR */
  1413. port->MSVR |= MSVR_DTR;
  1414. sx_out (bp, CD186x_MSVR, port->MSVR);
  1415. } 
  1416. }
  1417. sti();
  1418. set_current_state(TASK_INTERRUPTIBLE);
  1419. if (tty_hung_up_p(filp) ||
  1420.     !(port->flags & ASYNC_INITIALIZED)) {
  1421. if (port->flags & ASYNC_HUP_NOTIFY)
  1422. retval = -EAGAIN;
  1423. else
  1424. retval = -ERESTARTSYS;
  1425. break;
  1426. }
  1427. if (!(port->flags & ASYNC_CALLOUT_ACTIVE) &&
  1428.     !(port->flags & ASYNC_CLOSING) &&
  1429.     (do_clocal || CD))
  1430. break;
  1431. if (signal_pending(current)) {
  1432. retval = -ERESTARTSYS;
  1433. break;
  1434. }
  1435. schedule();
  1436. }
  1437. current->state = TASK_RUNNING;
  1438. remove_wait_queue(&port->open_wait, &wait);
  1439. if (!tty_hung_up_p(filp))
  1440. port->count++;
  1441. port->blocked_open--;
  1442. if (retval)
  1443. return retval;
  1445. port->flags |= ASYNC_NORMAL_ACTIVE;
  1446. return 0;
  1447. }
  1450. static int sx_open(struct tty_struct * tty, struct file * filp)
  1451. {
  1452. int board;
  1453. int error;
  1454. struct specialix_port * port;
  1455. struct specialix_board * bp;
  1456. unsigned long flags;
  1458. board = SX_BOARD(MINOR(tty->device));
  1460. if (board > SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT))
  1461. return -ENODEV;
  1463. bp = &sx_board[board];
  1464. port = sx_port + board * SX_NPORT + SX_PORT(MINOR(tty->device));
  1466. #ifdef DEBUG_SPECIALIX
  1467. printk (KERN_DEBUG "Board = %d, bp = %p, port = %p, portno = %d.n", 
  1468.         board, bp, port, SX_PORT(MINOR(tty->device)));
  1469. #endif
  1471. if (sx_paranoia_check(port, tty->device, "sx_open"))
  1472. return -ENODEV;
  1474. if ((error = sx_setup_board(bp)))
  1475. return error;
  1477. port->count++;
  1478. tty->driver_data = port;
  1479. port->tty = tty;
  1481. if ((error = sx_setup_port(bp, port))) 
  1482. return error;
  1484. if ((error = block_til_ready(tty, filp, port)))
  1485. return error;
  1487. if ((port->count == 1) && (port->flags & ASYNC_SPLIT_TERMIOS)) {
  1488. if (tty->driver.subtype == SPECIALIX_TYPE_NORMAL)
  1489. *tty->termios = port->normal_termios;
  1490. else
  1491. *tty->termios = port->callout_termios;
  1492. save_flags(flags); cli();
  1493. sx_change_speed(bp, port);
  1494. restore_flags(flags);
  1495. }
  1497. port->session = current->session;
  1498. port->pgrp = current->pgrp;
  1499. return 0;
  1500. }
  1503. static void sx_close(struct tty_struct * tty, struct file * filp)
  1504. {
  1505. struct specialix_port *port = (struct specialix_port *) tty->driver_data;
  1506. struct specialix_board *bp;
  1507. unsigned long flags;
  1508. unsigned long timeout;
  1510. if (!port || sx_paranoia_check(port, tty->device, "close"))
  1511. return;
  1513. save_flags(flags); cli();
  1514. if (tty_hung_up_p(filp)) {
  1515. restore_flags(flags);
  1516. return;
  1517. }
  1519. bp = port_Board(port);
  1520. if ((tty->count == 1) && (port->count != 1)) {
  1521. printk(KERN_ERR "sx%d: sx_close: bad port count;"
  1522.        " tty->count is 1, port count is %dn",
  1523.        board_No(bp), port->count);
  1524. port->count = 1;
  1525. }
  1526. if (--port->count < 0) {
  1527. printk(KERN_ERR "sx%d: sx_close: bad port count for tty%d: %dn",
  1528.        board_No(bp), port_No(port), port->count);
  1529. port->count = 0;
  1530. }
  1531. if (port->count) {
  1532. restore_flags(flags);
  1533. return;
  1534. }
  1535. port->flags |= ASYNC_CLOSING;
  1536. /*
  1537.  * Save the termios structure, since this port may have
  1538.  * separate termios for callout and dialin.
  1539.  */
  1540. if (port->flags & ASYNC_NORMAL_ACTIVE)
  1541. port->normal_termios = *tty->termios;
  1542. if (port->flags & ASYNC_CALLOUT_ACTIVE)
  1543. port->callout_termios = *tty->termios;
  1544. /*
  1545.  * Now we wait for the transmit buffer to clear; and we notify 
  1546.  * the line discipline to only process XON/XOFF characters.
  1547.  */
  1548. tty->closing = 1;
  1549. if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
  1550. tty_wait_until_sent(tty, port->closing_wait);
  1551. /*
  1552.  * At this point we stop accepting input.  To do this, we
  1553.  * disable the receive line status interrupts, and tell the
  1554.  * interrupt driver to stop checking the data ready bit in the
  1555.  * line status register.
  1556.  */
  1557. port->IER &= ~IER_RXD;
  1558. if (port->flags & ASYNC_INITIALIZED) {
  1559. port->IER &= ~IER_TXRDY;
  1560. port->IER |= IER_TXEMPTY;
  1561. sx_out(bp, CD186x_CAR, port_No(port));
  1562. sx_out(bp, CD186x_IER, port->IER);
  1563. /*
  1564.  * Before we drop DTR, make sure the UART transmitter
  1565.  * has completely drained; this is especially
  1566.  * important if there is a transmit FIFO!
  1567.  */
  1568. timeout = jiffies+HZ;
  1569. while(port->IER & IER_TXEMPTY) {
  1570. current->state = TASK_INTERRUPTIBLE;
  1571.   schedule_timeout(port->timeout);
  1572. if (time_after(jiffies, timeout)) {
  1573. printk (KERN_INFO "Timeout waiting for closen");
  1574. break;
  1575. }
  1576. }
  1578. }
  1579. sx_shutdown_port(bp, port);
  1580. if (tty->driver.flush_buffer)
  1581. tty->driver.flush_buffer(tty);
  1582. if (tty->ldisc.flush_buffer)
  1583. tty->ldisc.flush_buffer(tty);
  1584. tty->closing = 0;
  1585. port->event = 0;
  1586. port->tty = 0;
  1587. if (port->blocked_open) {
  1588. if (port->close_delay) {
  1589. current->state = TASK_INTERRUPTIBLE;
  1590. schedule_timeout(port->close_delay);
  1591. }
  1592. wake_up_interruptible(&port->open_wait);
  1593. }
  1594. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE|
  1595.  ASYNC_CLOSING);
  1596. wake_up_interruptible(&port->close_wait);
  1597. restore_flags(flags);
  1598. }
  1601. static int sx_write(struct tty_struct * tty, int from_user, 
  1602.                     const unsigned char *buf, int count)
  1603. {
  1604. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1605. struct specialix_board *bp;
  1606. int c, total = 0;
  1607. unsigned long flags;
  1609. if (sx_paranoia_check(port, tty->device, "sx_write"))
  1610. return 0;
  1612. bp = port_Board(port);
  1614. if (!tty || !port->xmit_buf || !tmp_buf)
  1615. return 0;
  1617. save_flags(flags);
  1618. if (from_user) {
  1619. down(&tmp_buf_sem);
  1620. while (1) {
  1621. c = MIN(count, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1622.    SERIAL_XMIT_SIZE - port->xmit_head));
  1623. if (c <= 0)
  1624. break;
  1626. c -= copy_from_user(tmp_buf, buf, c);
  1627. if (!c) {
  1628. if (!total)
  1629. total = -EFAULT;
  1630. break;
  1631. }
  1633. cli();
  1634. c = MIN(c, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1635.        SERIAL_XMIT_SIZE - port->xmit_head));
  1636. memcpy(port->xmit_buf + port->xmit_head, tmp_buf, c);
  1637. port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  1638. port->xmit_cnt += c;
  1639. restore_flags(flags);
  1641. buf += c;
  1642. count -= c;
  1643. total += c;
  1644. }
  1645. up(&tmp_buf_sem);
  1646. } else {
  1647. while (1) {
  1648. cli();
  1649. c = MIN(count, MIN(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
  1650.    SERIAL_XMIT_SIZE - port->xmit_head));
  1651. if (c <= 0) {
  1652. restore_flags(flags);
  1653. break;
  1654. }
  1655. memcpy(port->xmit_buf + port->xmit_head, buf, c);
  1656. port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
  1657. port->xmit_cnt += c;
  1658. restore_flags(flags);
  1660. buf += c;
  1661. count -= c;
  1662. total += c;
  1663. }
  1664. }
  1666. cli();
  1667. if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
  1668.     !(port->IER & IER_TXRDY)) {
  1669. port->IER |= IER_TXRDY;
  1670. sx_out(bp, CD186x_CAR, port_No(port));
  1671. sx_out(bp, CD186x_IER, port->IER);
  1672. }
  1673. restore_flags(flags);
  1674. return total;
  1675. }
  1678. static void sx_put_char(struct tty_struct * tty, unsigned char ch)
  1679. {
  1680. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1681. unsigned long flags;
  1683. if (sx_paranoia_check(port, tty->device, "sx_put_char"))
  1684. return;
  1686. if (!tty || !port->xmit_buf)
  1687. return;
  1689. save_flags(flags); cli();
  1691. if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
  1692. restore_flags(flags);
  1693. return;
  1694. }
  1696. port->xmit_buf[port->xmit_head++] = ch;
  1697. port->xmit_head &= SERIAL_XMIT_SIZE - 1;
  1698. port->xmit_cnt++;
  1699. restore_flags(flags);
  1700. }
  1703. static void sx_flush_chars(struct tty_struct * tty)
  1704. {
  1705. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1706. unsigned long flags;
  1708. if (sx_paranoia_check(port, tty->device, "sx_flush_chars"))
  1709. return;
  1711. if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
  1712.     !port->xmit_buf)
  1713. return;
  1715. save_flags(flags); cli();
  1716. port->IER |= IER_TXRDY;
  1717. sx_out(port_Board(port), CD186x_CAR, port_No(port));
  1718. sx_out(port_Board(port), CD186x_IER, port->IER);
  1719. restore_flags(flags);
  1720. }
  1723. static int sx_write_room(struct tty_struct * tty)
  1724. {
  1725. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1726. int ret;
  1728. if (sx_paranoia_check(port, tty->device, "sx_write_room"))
  1729. return 0;
  1731. ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
  1732. if (ret < 0)
  1733. ret = 0;
  1734. return ret;
  1735. }
  1738. static int sx_chars_in_buffer(struct tty_struct *tty)
  1739. {
  1740. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1742. if (sx_paranoia_check(port, tty->device, "sx_chars_in_buffer"))
  1743. return 0;
  1745. return port->xmit_cnt;
  1746. }
  1749. static void sx_flush_buffer(struct tty_struct *tty)
  1750. {
  1751. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1752. unsigned long flags;
  1754. if (sx_paranoia_check(port, tty->device, "sx_flush_buffer"))
  1755. return;
  1757. save_flags(flags); cli();
  1758. port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
  1759. restore_flags(flags);
  1761. wake_up_interruptible(&tty->write_wait);
  1762. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  1763.     tty->ldisc.write_wakeup)
  1764. (tty->ldisc.write_wakeup)(tty);
  1765. }
  1768. static int sx_get_modem_info(struct specialix_port * port, unsigned int *value)
  1769. {
  1770. struct specialix_board * bp;
  1771. unsigned char status;
  1772. unsigned int result;
  1773. unsigned long flags;
  1775. bp = port_Board(port);
  1776. save_flags(flags); cli();
  1777. sx_out(bp, CD186x_CAR, port_No(port));
  1778. status = sx_in(bp, CD186x_MSVR);
  1779. restore_flags(flags);
  1780. #ifdef DEBUG_SPECIALIX
  1781. printk (KERN_DEBUG "Got msvr[%d] = %02x, car = %d.n", 
  1782. port_No(port), status, sx_in (bp, CD186x_CAR));
  1783. printk (KERN_DEBUG "sx_port = %p, port = %pn", sx_port, port);
  1784. #endif
  1785. if (SX_CRTSCTS(port->tty)) {
  1786. result  = /*   (status & MSVR_RTS) ? */ TIOCM_DTR /* : 0) */ 
  1787.           |   ((status & MSVR_DTR) ? TIOCM_RTS : 0)
  1788.           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
  1789.           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
  1790.           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
  1791. } else {
  1792. result  = /*   (status & MSVR_RTS) ? */ TIOCM_RTS /* : 0) */ 
  1793.           |   ((status & MSVR_DTR) ? TIOCM_DTR : 0)
  1794.           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
  1795.           |/* ((status & MSVR_DSR) ? */ TIOCM_DSR /* : 0) */
  1796.           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
  1797. }
  1798. put_user(result,(unsigned int *) value);
  1799. return 0;
  1800. }
  1803. static int sx_set_modem_info(struct specialix_port * port, unsigned int cmd,
  1804.                              unsigned int *value)
  1805. {
  1806. int error;
  1807. unsigned int arg;
  1808. unsigned long flags;
  1809. struct specialix_board *bp = port_Board(port);
  1811. error = verify_area(VERIFY_READ, value, sizeof(int));
  1812. if (error) 
  1813. return error;
  1815. Get_user(arg, (unsigned long *) value);
  1816. switch (cmd) {
  1817. case TIOCMBIS: 
  1818.    /* if (arg & TIOCM_RTS) 
  1819. port->MSVR |= MSVR_RTS; */
  1820.    /*   if (arg & TIOCM_DTR)
  1821. port->MSVR |= MSVR_DTR; */
  1823. if (SX_CRTSCTS(port->tty)) {
  1824. if (arg & TIOCM_RTS)
  1825. port->MSVR |= MSVR_DTR; 
  1826. } else {
  1827. if (arg & TIOCM_DTR)
  1828. port->MSVR |= MSVR_DTR; 
  1829. }      
  1830. break;
  1831. case TIOCMBIC:
  1832.   /* if (arg & TIOCM_RTS)
  1833. port->MSVR &= ~MSVR_RTS; */
  1834.   /*    if (arg & TIOCM_DTR)
  1835. port->MSVR &= ~MSVR_DTR; */
  1836. if (SX_CRTSCTS(port->tty)) {
  1837. if (arg & TIOCM_RTS)
  1838. port->MSVR &= ~MSVR_DTR;
  1839. } else {
  1840. if (arg & TIOCM_DTR)
  1841. port->MSVR &= ~MSVR_DTR;
  1842. }
  1843. break;
  1844. case TIOCMSET:
  1845.   /* port->MSVR = (arg & TIOCM_RTS) ? (port->MSVR | MSVR_RTS) : 
  1846.  (port->MSVR & ~MSVR_RTS); */
  1847.   /* port->MSVR = (arg & TIOCM_DTR) ? (port->MSVR | MSVR_DTR) : 
  1848.  (port->MSVR & ~MSVR_DTR); */
  1849. if (SX_CRTSCTS(port->tty)) {
  1850.    port->MSVR = (arg & TIOCM_RTS) ? 
  1851.                          (port->MSVR |  MSVR_DTR) : 
  1852.                          (port->MSVR & ~MSVR_DTR);
  1853. } else {
  1854. port->MSVR = (arg & TIOCM_DTR) ?
  1855.                          (port->MSVR |  MSVR_DTR):
  1856.                          (port->MSVR & ~MSVR_DTR);
  1857. }
  1858. break;
  1859. default:
  1860. return -EINVAL;
  1861. }
  1862. save_flags(flags); cli();
  1863. sx_out(bp, CD186x_CAR, port_No(port));
  1864. sx_out(bp, CD186x_MSVR, port->MSVR);
  1865. restore_flags(flags);
  1866. return 0;
  1867. }
  1870. static inline void sx_send_break(struct specialix_port * port, unsigned long length)
  1871. {
  1872. struct specialix_board *bp = port_Board(port);
  1873. unsigned long flags;
  1875. save_flags(flags); cli();
  1876. port->break_length = SPECIALIX_TPS / HZ * length;
  1877. port->COR2 |= COR2_ETC;
  1878. port->IER  |= IER_TXRDY;
  1879. sx_out(bp, CD186x_CAR, port_No(port));
  1880. sx_out(bp, CD186x_COR2, port->COR2);
  1881. sx_out(bp, CD186x_IER, port->IER);
  1882. sx_wait_CCR(bp);
  1883. sx_out(bp, CD186x_CCR, CCR_CORCHG2);
  1884. sx_wait_CCR(bp);
  1885. restore_flags(flags);
  1886. }
  1889. static inline int sx_set_serial_info(struct specialix_port * port,
  1890.                                      struct serial_struct * newinfo)
  1891. {
  1892. struct serial_struct tmp;
  1893. struct specialix_board *bp = port_Board(port);
  1894. int change_speed;
  1895. unsigned long flags;
  1896. int error;
  1898. error = verify_area(VERIFY_READ, (void *) newinfo, sizeof(tmp));
  1899. if (error)
  1900. return error;
  1902. if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
  1903. return -EFAULT;
  1905. #if 0
  1906. if ((tmp.irq != bp->irq) ||
  1907.     (tmp.port != bp->base) ||
  1908.     (tmp.type != PORT_CIRRUS) ||
  1909.     (tmp.baud_base != (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC) ||
  1910.     (tmp.custom_divisor != 0) ||
  1911.     (tmp.xmit_fifo_size != CD186x_NFIFO) ||
  1912.     (tmp.flags & ~SPECIALIX_LEGAL_FLAGS))
  1913. return -EINVAL;
  1914. #endif
  1916. change_speed = ((port->flags & ASYNC_SPD_MASK) !=
  1917. (tmp.flags & ASYNC_SPD_MASK));
  1918. change_speed |= (tmp.custom_divisor != port->custom_divisor);
  1920. if (!capable(CAP_SYS_ADMIN)) {
  1921. if ((tmp.close_delay != port->close_delay) ||
  1922.     (tmp.closing_wait != port->closing_wait) ||
  1923.     ((tmp.flags & ~ASYNC_USR_MASK) !=
  1924.      (port->flags & ~ASYNC_USR_MASK)))
  1925. return -EPERM;
  1926. port->flags = ((port->flags & ~ASYNC_USR_MASK) |
  1927.                   (tmp.flags & ASYNC_USR_MASK));
  1928. port->custom_divisor = tmp.custom_divisor;
  1929. } else {
  1930. port->flags = ((port->flags & ~ASYNC_FLAGS) |
  1931.                   (tmp.flags & ASYNC_FLAGS));
  1932. port->close_delay = tmp.close_delay;
  1933. port->closing_wait = tmp.closing_wait;
  1934. port->custom_divisor = tmp.custom_divisor;
  1935. }
  1936. if (change_speed) {
  1937. save_flags(flags); cli();
  1938. sx_change_speed(bp, port);
  1939. restore_flags(flags);
  1940. }
  1941. return 0;
  1942. }
  1945. static inline int sx_get_serial_info(struct specialix_port * port,
  1946.      struct serial_struct * retinfo)
  1947. {
  1948. struct serial_struct tmp;
  1949. struct specialix_board *bp = port_Board(port);
  1950. int error;
  1952. error = verify_area(VERIFY_WRITE, (void *) retinfo, sizeof(tmp));
  1953. if (error)
  1954. return error;
  1956. memset(&tmp, 0, sizeof(tmp));
  1957. tmp.type = PORT_CIRRUS;
  1958. tmp.line = port - sx_port;
  1959. tmp.port = bp->base;
  1960. tmp.irq  = bp->irq;
  1961. tmp.flags = port->flags;
  1962. tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
  1963. tmp.close_delay = port->close_delay * HZ/100;
  1964. tmp.closing_wait = port->closing_wait * HZ/100;
  1965. tmp.custom_divisor =  port->custom_divisor;
  1966. tmp.xmit_fifo_size = CD186x_NFIFO;
  1967. if (copy_to_user(retinfo, &tmp, sizeof(tmp)))
  1968. return -EFAULT;
  1969. return 0;
  1970. }
  1973. static int sx_ioctl(struct tty_struct * tty, struct file * filp, 
  1974.                     unsigned int cmd, unsigned long arg)
  1975. {
  1976. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  1977. int error;
  1978. int retval;
  1980. if (sx_paranoia_check(port, tty->device, "sx_ioctl"))
  1981. return -ENODEV;
  1983. switch (cmd) {
  1984.  case TCSBRK: /* SVID version: non-zero arg --> no break */
  1985. retval = tty_check_change(tty);
  1986. if (retval)
  1987. return retval;
  1988. tty_wait_until_sent(tty, 0);
  1989. if (!arg)
  1990. sx_send_break(port, HZ/4); /* 1/4 second */
  1991. return 0;
  1992.  case TCSBRKP: /* support for POSIX tcsendbreak() */
  1993. retval = tty_check_change(tty);
  1994. if (retval)
  1995. return retval;
  1996. tty_wait_until_sent(tty, 0);
  1997. sx_send_break(port, arg ? arg*(HZ/10) : HZ/4);
  1998. return 0;
  1999.  case TIOCGSOFTCAR:
  2000. error = verify_area(VERIFY_WRITE, (void *) arg, sizeof(long));
  2001. if (error)
  2002. return error;
  2003. put_user(C_CLOCAL(tty) ? 1 : 0,
  2004.          (unsigned long *) arg);
  2005. return 0;
  2006.  case TIOCSSOFTCAR:
  2007. Get_user(arg, (unsigned long *) arg);
  2008. tty->termios->c_cflag =
  2009. ((tty->termios->c_cflag & ~CLOCAL) |
  2010. (arg ? CLOCAL : 0));
  2011. return 0;
  2012.  case TIOCMGET:
  2013. error = verify_area(VERIFY_WRITE, (void *) arg,
  2014.                     sizeof(unsigned int));
  2015. if (error)
  2016. return error;
  2017. return sx_get_modem_info(port, (unsigned int *) arg);
  2018.  case TIOCMBIS:
  2019.  case TIOCMBIC:
  2020.  case TIOCMSET:
  2021. return sx_set_modem_info(port, cmd, (unsigned int *) arg);
  2022.  case TIOCGSERIAL:
  2023. return sx_get_serial_info(port, (struct serial_struct *) arg);
  2024.  case TIOCSSERIAL:
  2025. return sx_set_serial_info(port, (struct serial_struct *) arg);
  2026.  default:
  2027. return -ENOIOCTLCMD;
  2028. }
  2029. return 0;
  2030. }
  2033. static void sx_throttle(struct tty_struct * tty)
  2034. {
  2035. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2036. struct specialix_board *bp;
  2037. unsigned long flags;
  2039. if (sx_paranoia_check(port, tty->device, "sx_throttle"))
  2040. return;
  2042. bp = port_Board(port);
  2044. save_flags(flags); cli();
  2046. /* Use DTR instead of RTS ! */
  2047. if (SX_CRTSCTS (tty)) 
  2048. port->MSVR &= ~MSVR_DTR;
  2049. else {
  2050. /* Auch!!! I think the system shouldn't call this then. */
  2051. /* Or maybe we're supposed (allowed?) to do our side of hw
  2052.    handshake anyway, even when hardware handshake is off. 
  2053.    When you see this in your logs, please report.... */
  2054. printk (KERN_ERR "sx%d: Need to throttle, but can't (hardware hs is off)n",
  2055.                  port_No (port));
  2056. }
  2057. sx_out(bp, CD186x_CAR, port_No(port));
  2058. if (I_IXOFF(tty)) {
  2059. sx_wait_CCR(bp);
  2060. sx_out(bp, CD186x_CCR, CCR_SSCH2);
  2061. sx_wait_CCR(bp);
  2062. }
  2063. sx_out(bp, CD186x_MSVR, port->MSVR);
  2064. restore_flags(flags);
  2065. }
  2068. static void sx_unthrottle(struct tty_struct * tty)
  2069. {
  2070. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2071. struct specialix_board *bp;
  2072. unsigned long flags;
  2074. if (sx_paranoia_check(port, tty->device, "sx_unthrottle"))
  2075. return;
  2077. bp = port_Board(port);
  2079. save_flags(flags); cli();
  2080. /* XXXX Use DTR INSTEAD???? */
  2081. if (SX_CRTSCTS(tty)) {
  2082. port->MSVR |= MSVR_DTR;
  2083. } /* Else clause: see remark in "sx_throttle"... */
  2085. sx_out(bp, CD186x_CAR, port_No(port));
  2086. if (I_IXOFF(tty)) {
  2087. sx_wait_CCR(bp);
  2088. sx_out(bp, CD186x_CCR, CCR_SSCH1);
  2089. sx_wait_CCR(bp);
  2090. }
  2091. sx_out(bp, CD186x_MSVR, port->MSVR);
  2092. restore_flags(flags);
  2093. }
  2096. static void sx_stop(struct tty_struct * tty)
  2097. {
  2098. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2099. struct specialix_board *bp;
  2100. unsigned long flags;
  2102. if (sx_paranoia_check(port, tty->device, "sx_stop"))
  2103. return;
  2105. bp = port_Board(port);
  2107. save_flags(flags); cli();
  2108. port->IER &= ~IER_TXRDY;
  2109. sx_out(bp, CD186x_CAR, port_No(port));
  2110. sx_out(bp, CD186x_IER, port->IER);
  2111. restore_flags(flags);
  2112. }
  2115. static void sx_start(struct tty_struct * tty)
  2116. {
  2117. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2118. struct specialix_board *bp;
  2119. unsigned long flags;
  2121. if (sx_paranoia_check(port, tty->device, "sx_start"))
  2122. return;
  2124. bp = port_Board(port);
  2126. save_flags(flags); cli();
  2127. if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
  2128. port->IER |= IER_TXRDY;
  2129. sx_out(bp, CD186x_CAR, port_No(port));
  2130. sx_out(bp, CD186x_IER, port->IER);
  2131. }
  2132. restore_flags(flags);
  2133. }
  2136. /*
  2137.  * This routine is called from the scheduler tqueue when the interrupt
  2138.  * routine has signalled that a hangup has occurred.  The path of
  2139.  * hangup processing is:
  2140.  *
  2141.  *  serial interrupt routine -> (scheduler tqueue) ->
  2142.  *  do_sx_hangup() -> tty->hangup() -> sx_hangup()
  2143.  * 
  2144.  */
  2145. static void do_sx_hangup(void *private_)
  2146. {
  2147. struct specialix_port *port = (struct specialix_port *) private_;
  2148. struct tty_struct *tty;
  2150. tty = port->tty;
  2151. if (tty)
  2152. tty_hangup(tty); /* FIXME: module removal race here */
  2153. MOD_DEC_USE_COUNT;
  2154. }
  2157. static void sx_hangup(struct tty_struct * tty)
  2158. {
  2159. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2160. struct specialix_board *bp;
  2162. if (sx_paranoia_check(port, tty->device, "sx_hangup"))
  2163. return;
  2165. bp = port_Board(port);
  2167. sx_shutdown_port(bp, port);
  2168. port->event = 0;
  2169. port->count = 0;
  2170. port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE);
  2171. port->tty = 0;
  2172. wake_up_interruptible(&port->open_wait);
  2173. }
  2176. static void sx_set_termios(struct tty_struct * tty, struct termios * old_termios)
  2177. {
  2178. struct specialix_port *port = (struct specialix_port *)tty->driver_data;
  2179. unsigned long flags;
  2181. if (sx_paranoia_check(port, tty->device, "sx_set_termios"))
  2182. return;
  2184. if (tty->termios->c_cflag == old_termios->c_cflag &&
  2185.     tty->termios->c_iflag == old_termios->c_iflag)
  2186. return;
  2188. save_flags(flags); cli();
  2189. sx_change_speed(port_Board(port), port);
  2190. restore_flags(flags);
  2192. if ((old_termios->c_cflag & CRTSCTS) &&
  2193.     !(tty->termios->c_cflag & CRTSCTS)) {
  2194. tty->hw_stopped = 0;
  2195. sx_start(tty);
  2196. }
  2197. }
  2200. static void do_specialix_bh(void)
  2201. {
  2202.  run_task_queue(&tq_specialix);
  2203. }
  2206. static void do_softint(void *private_)
  2207. {
  2208. struct specialix_port *port = (struct specialix_port *) private_;
  2209. struct tty_struct *tty;
  2211. if(!(tty = port->tty)) 
  2212. return;
  2214. if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
  2215. if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
  2216.     tty->ldisc.write_wakeup)
  2217. (tty->ldisc.write_wakeup)(tty);
  2218. wake_up_interruptible(&tty->write_wait);
  2219. }
  2220. }
  2223. static int sx_init_drivers(void)
  2224. {
  2225. int error;
  2226. int i;
  2229. if (!(tmp_buf = (unsigned char *) get_free_page(GFP_KERNEL))) {
  2230. printk(KERN_ERR "sx: Couldn't get free page.n");
  2231. return 1;
  2232. }
  2233. init_bh(SPECIALIX_BH, do_specialix_bh);
  2234. memset(&specialix_driver, 0, sizeof(specialix_driver));
  2235. specialix_driver.magic = TTY_DRIVER_MAGIC;
  2236. specialix_driver.name = "ttyW";
  2237. specialix_driver.major = SPECIALIX_NORMAL_MAJOR;
  2238. specialix_driver.num = SX_NBOARD * SX_NPORT;
  2239. specialix_driver.type = TTY_DRIVER_TYPE_SERIAL;
  2240. specialix_driver.subtype = SPECIALIX_TYPE_NORMAL;
  2241. specialix_driver.init_termios = tty_std_termios;
  2242. specialix_driver.init_termios.c_cflag =
  2243. B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  2244. specialix_driver.flags = TTY_DRIVER_REAL_RAW;
  2245. specialix_driver.refcount = &specialix_refcount;
  2246. specialix_driver.table = specialix_table;
  2247. specialix_driver.termios = specialix_termios;
  2248. specialix_driver.termios_locked = specialix_termios_locked;
  2250. specialix_driver.open  = sx_open;
  2251. specialix_driver.close = sx_close;
  2252. specialix_driver.write = sx_write;
  2253. specialix_driver.put_char = sx_put_char;
  2254. specialix_driver.flush_chars = sx_flush_chars;
  2255. specialix_driver.write_room = sx_write_room;
  2256. specialix_driver.chars_in_buffer = sx_chars_in_buffer;
  2257. specialix_driver.flush_buffer = sx_flush_buffer;
  2258. specialix_driver.ioctl = sx_ioctl;
  2259. specialix_driver.throttle = sx_throttle;
  2260. specialix_driver.unthrottle = sx_unthrottle;
  2261. specialix_driver.set_termios = sx_set_termios;
  2262. specialix_driver.stop = sx_stop;
  2263. specialix_driver.start = sx_start;
  2264. specialix_driver.hangup = sx_hangup;
  2266. specialix_callout_driver = specialix_driver;
  2267. specialix_callout_driver.name = "cuw";
  2268. specialix_callout_driver.major = SPECIALIX_CALLOUT_MAJOR;
  2269. specialix_callout_driver.subtype = SPECIALIX_TYPE_CALLOUT;
  2271. if ((error = tty_register_driver(&specialix_driver))) {
  2272. free_page((unsigned long)tmp_buf);
  2273. printk(KERN_ERR "sx: Couldn't register specialix IO8+ driver, error = %dn",
  2274.        error);
  2275. return 1;
  2276. }
  2277. if ((error = tty_register_driver(&specialix_callout_driver))) {
  2278. free_page((unsigned long)tmp_buf);
  2279. tty_unregister_driver(&specialix_driver);
  2280. printk(KERN_ERR "sx: Couldn't register specialix IO8+ callout driver, error = %dn",
  2281.        error);
  2282. return 1;
  2283. }
  2285. memset(sx_port, 0, sizeof(sx_port));
  2286. for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
  2287. sx_port[i].callout_termios = specialix_callout_driver.init_termios;
  2288. sx_port[i].normal_termios  = specialix_driver.init_termios;
  2289. sx_port[i].magic = SPECIALIX_MAGIC;
  2290. sx_port[i].tqueue.routine = do_softint;
  2291. sx_port[i].tqueue.data = &sx_port[i];
  2292. sx_port[i].tqueue_hangup.routine = do_sx_hangup;
  2293. sx_port[i].tqueue_hangup.data = &sx_port[i];
  2294. sx_port[i].close_delay = 50 * HZ/100;
  2295. sx_port[i].closing_wait = 3000 * HZ/100;
  2296. init_waitqueue_head(&sx_port[i].open_wait);
  2297. init_waitqueue_head(&sx_port[i].close_wait);
  2298. }
  2300. return 0;
  2301. }
  2304. static void sx_release_drivers(void)
  2305. {
  2306. free_page((unsigned long)tmp_buf);
  2307. tty_unregister_driver(&specialix_driver);
  2308. tty_unregister_driver(&specialix_callout_driver);
  2309. }
  2312. #ifndef MODULE
  2313. /*
  2314.  * Called at boot time.
  2315.  * 
  2316.  * You can specify IO base for up to SX_NBOARD cards,
  2317.  * using line "specialix=0xiobase1,0xiobase2,.." at LILO prompt.
  2318.  * Note that there will be no probing at default
  2319.  * addresses in this case.
  2320.  *
  2321.  */ 
  2322. void specialix_setup(char *str, int * ints)
  2323. {
  2324. int i;
  2325.         
  2326. for (i=0;i<SX_NBOARD;i++) {
  2327. sx_board[i].base = 0;
  2328. }
  2330. for (i = 1; i <= ints[0]; i++) {
  2331. if (i&1)
  2332. sx_board[i/2].base = ints[i];
  2333. else
  2334. sx_board[i/2 -1].irq = ints[i];
  2335. }
  2336. }
  2337. #endif
  2339. /* 
  2340.  * This routine must be called by kernel at boot time 
  2341.  */
  2342. int specialix_init(void) 
  2343. {
  2344. int i;
  2345. int found = 0;
  2347. printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.n");
  2348. printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.n");
  2349. #ifdef CONFIG_SPECIALIX_RTSCTS
  2350. printk (KERN_INFO "sx: DTR/RTS pin is always RTS.n");
  2351. #else
  2352. printk (KERN_INFO "sx: DTR/RTS pin is RTS when CRTSCTS is on.n");
  2353. #endif
  2355. if (sx_init_drivers()) 
  2356. return -EIO;
  2358. for (i = 0; i < SX_NBOARD; i++) 
  2359. if (sx_board[i].base && !sx_probe(&sx_board[i]))
  2360. found++;
  2362. #ifdef CONFIG_PCI
  2363. if (pci_present()) {
  2364. struct pci_dev *pdev = NULL;
  2366. i=0;
  2367. while (i <= SX_NBOARD) {
  2368. if (sx_board[i].flags & SX_BOARD_PRESENT) {
  2369. i++;
  2370. continue;
  2371. }
  2372. pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX, 
  2373.                         PCI_DEVICE_ID_SPECIALIX_IO8, 
  2374.                         pdev);
  2375. if (!pdev) break;
  2377. if (pci_enable_device(pdev))
  2378. continue;
  2380. sx_board[i].irq = pdev->irq;
  2382. sx_board[i].base = pci_resource_start (pdev, 2);
  2384. sx_board[i].flags |= SX_BOARD_IS_PCI;
  2385. if (!sx_probe(&sx_board[i]))
  2386. found ++;
  2387. }
  2388. }
  2389. #endif
  2391. if (!found) {
  2392. sx_release_drivers();
  2393. printk(KERN_INFO "sx: No specialix IO8+ boards detected.n");
  2394. return -EIO;
  2395. }
  2397. return 0;
  2398. }
  2400. #ifdef MODULE
  2401. int iobase[SX_NBOARD]  = {0,};
  2403. int irq [SX_NBOARD] = {0,};
  2405. MODULE_PARM(iobase,"1-" __MODULE_STRING(SX_NBOARD) "i");
  2406. MODULE_PARM(irq,"1-" __MODULE_STRING(SX_NBOARD) "i");
  2408. /*
  2409.  * You can setup up to 4 boards.
  2410.  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
  2411.  * You should specify the IRQs too in that case "irq=....,...". 
  2412.  * 
  2413.  * More than 4 boards in one computer is not possible, as the card can
  2414.  * only use 4 different interrupts. 
  2415.  *
  2416.  */
  2417. int init_module(void) 
  2418. {
  2419. int i;
  2421. if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
  2422. for(i = 0; i < SX_NBOARD; i++) {
  2423. sx_board[i].base = iobase[i];
  2424. sx_board[i].irq = irq[i];
  2425. }
  2426. }
  2428. return specialix_init();
  2429. }
  2432. void cleanup_module(void)
  2433. {
  2434. int i;
  2436. sx_release_drivers();
  2437. for (i = 0; i < SX_NBOARD; i++)
  2438. if (sx_board[i].flags & SX_BOARD_PRESENT) 
  2439. sx_release_io_range(&sx_board[i]);
  2440. #ifdef SPECIALIX_TIMER
  2441. del_timer (&missed_irq_timer);
  2442. #endif
  2444. }
  2445. #endif /* MODULE */
  2447. MODULE_LICENSE("GPL");