1996-06-14 10:04:54 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 1991 The Regents of the University of California.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1996-06-14 10:04:54 +00:00
|
|
|
* from: @(#)com.c 7.5 (Berkeley) 5/16/91
|
1999-04-19 11:11:01 +00:00
|
|
|
* from: i386/isa sio.c,v 1.234
|
1996-06-14 10:04:54 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "opt_comconsole.h"
|
1997-12-16 17:40:42 +00:00
|
|
|
#include "opt_compat.h"
|
2004-07-10 22:29:41 +00:00
|
|
|
#include "opt_gdb.h"
|
|
|
|
#include "opt_kdb.h"
|
1999-05-10 09:14:40 +00:00
|
|
|
#include "opt_sio.h"
|
1997-09-20 05:28:02 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* Serial driver, based on 386BSD-0.1 com driver.
|
|
|
|
* Mostly rewritten to use pseudo-DMA.
|
|
|
|
* Works for National Semiconductor NS8250-NS16550AF UARTs.
|
|
|
|
* COM driver, based on HP dca driver.
|
|
|
|
*
|
2005-09-30 13:17:54 +00:00
|
|
|
* Changes for PC Card integration:
|
|
|
|
* - Added PC Card driver table and handlers
|
1996-06-14 10:04:54 +00:00
|
|
|
*/
|
|
|
|
/*===============================================================
|
|
|
|
* 386BSD(98),FreeBSD-1.1x(98) com driver.
|
|
|
|
* -----
|
|
|
|
* modified for PC9801 by M.Ishii
|
|
|
|
* Kyoto University Microcomputer Club (KMC)
|
|
|
|
* Chou "TEFUTEFU" Hirotomi
|
|
|
|
* Kyoto Univ. the faculty of medicine
|
|
|
|
*===============================================================
|
|
|
|
* FreeBSD-2.0.1(98) sio driver.
|
|
|
|
* -----
|
|
|
|
* modified for pc98 Internal i8251 and MICRO CORE MC16550II
|
|
|
|
* T.Koike(hfc01340@niftyserve.or.jp)
|
|
|
|
* implement kernel device configuration
|
|
|
|
* aizu@orient.center.nitech.ac.jp
|
|
|
|
*
|
|
|
|
* Notes.
|
|
|
|
* -----
|
|
|
|
* PC98 localization based on 386BSD(98) com driver. Using its PC98 local
|
|
|
|
* functions.
|
|
|
|
* This driver is under debugging,has bugs.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* modified for AIWA B98-01
|
|
|
|
* by T.Hatanou <hatanou@yasuda.comm.waseda.ac.jp> last update: 15 Sep.1995
|
|
|
|
*/
|
1999-01-03 05:03:47 +00:00
|
|
|
/*
|
|
|
|
* Modified by Y.Takahashi of Kogakuin University.
|
|
|
|
*/
|
1999-12-06 00:23:38 +00:00
|
|
|
/*
|
|
|
|
* modified for 8251(FIFO) by Seigo TANIMURA <tanimura@FreeBSD.org>
|
|
|
|
*/
|
1999-01-03 05:03:47 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2001-05-02 14:02:16 +00:00
|
|
|
#include <sys/bus.h>
|
1996-06-14 10:04:54 +00:00
|
|
|
#include <sys/conf.h>
|
1997-03-23 03:49:00 +00:00
|
|
|
#include <sys/fcntl.h>
|
1998-08-13 07:36:40 +00:00
|
|
|
#include <sys/interrupt.h>
|
2004-07-10 22:29:41 +00:00
|
|
|
#include <sys/kdb.h>
|
1996-06-14 10:04:54 +00:00
|
|
|
#include <sys/kernel.h>
|
2003-04-29 13:36:06 +00:00
|
|
|
#include <sys/limits.h>
|
2001-05-02 14:02:16 +00:00
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/module.h>
|
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/reboot.h>
|
2004-06-26 04:00:46 +00:00
|
|
|
#include <sys/serial.h>
|
1997-06-04 10:27:53 +00:00
|
|
|
#include <sys/sysctl.h>
|
2001-05-02 14:02:16 +00:00
|
|
|
#include <sys/syslog.h>
|
|
|
|
#include <sys/tty.h>
|
1999-04-18 14:42:20 +00:00
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <sys/rman.h>
|
1999-04-01 13:44:15 +00:00
|
|
|
#include <sys/timepps.h>
|
2002-04-06 06:19:10 +00:00
|
|
|
#include <sys/uio.h>
|
2003-08-28 11:20:54 +00:00
|
|
|
#include <sys/cons.h>
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
#include <isa/isavar.h>
|
|
|
|
|
|
|
|
#include <machine/resource.h>
|
|
|
|
|
2001-10-22 02:48:38 +00:00
|
|
|
#include <dev/sio/sioreg.h>
|
2001-11-26 12:29:53 +00:00
|
|
|
#include <dev/sio/siovar.h>
|
|
|
|
|
|
|
|
#ifdef PC98
|
2005-05-10 12:02:18 +00:00
|
|
|
#include <pc98/cbus/cbus.h>
|
2001-11-26 12:29:53 +00:00
|
|
|
#include <pc98/pc98/pc98_machdep.h>
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#ifdef COM_ESP
|
2001-06-10 04:28:39 +00:00
|
|
|
#include <dev/ic/esp.h>
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
2001-06-10 04:28:39 +00:00
|
|
|
#include <dev/ic/ns16550.h>
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
2001-06-10 04:28:39 +00:00
|
|
|
#include <dev/ic/i8251.h>
|
2008-09-07 04:35:04 +00:00
|
|
|
#include <dev/ic/i8255.h>
|
2001-06-10 04:28:39 +00:00
|
|
|
#include <dev/ic/rsa.h>
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#define LOTS_OF_EVENTS 64 /* helps separate urgent events from input */
|
|
|
|
|
2004-05-01 06:53:38 +00:00
|
|
|
/*
|
|
|
|
* Meaning of flags:
|
|
|
|
*
|
|
|
|
* 0x00000001 shared IRQs
|
|
|
|
* 0x00000002 disable FIFO
|
|
|
|
* 0x00000008 recover sooner from lost output interrupts
|
|
|
|
* 0x00000010 device is potential system console
|
|
|
|
* 0x00000020 device is forced to become system console
|
|
|
|
* 0x00000040 device is reserved for low-level IO
|
|
|
|
* 0x00000080 use this port for remote kernel debugging
|
|
|
|
* 0x0000??00 minor number of master port
|
|
|
|
* 0x00010000 PPS timestamping on CTS instead of DCD
|
|
|
|
* 0x00080000 IIR_TXRDY bug
|
|
|
|
* 0x00400000 If no comconsole found then mark as a comconsole
|
|
|
|
* 0x1?000000 interface type
|
|
|
|
*/
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef COM_MULTIPORT
|
|
|
|
/* checks in flags for multiport and which is multiport "master chip"
|
|
|
|
* for a given card
|
|
|
|
*/
|
1999-04-18 14:42:20 +00:00
|
|
|
#define COM_ISMULTIPORT(flags) ((flags) & 0x01)
|
|
|
|
#define COM_MPMASTER(flags) (((flags) >> 8) & 0x0ff)
|
2004-05-01 06:53:38 +00:00
|
|
|
#ifndef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
#define COM_NOTAST4(flags) ((flags) & 0x04)
|
2004-05-01 06:53:38 +00:00
|
|
|
#endif
|
2002-09-29 11:41:48 +00:00
|
|
|
#else
|
|
|
|
#define COM_ISMULTIPORT(flags) (0)
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* COM_MULTIPORT */
|
|
|
|
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_C_IIR_TXRDYBUG 0x80000
|
1999-04-18 14:42:20 +00:00
|
|
|
#define COM_CONSOLE(flags) ((flags) & 0x10)
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_DEBUGGER(flags) ((flags) & 0x80)
|
2004-05-01 06:53:38 +00:00
|
|
|
#ifndef PC98
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_FIFOSIZE(flags) (((flags) & 0xff000000) >> 24)
|
2004-05-01 06:53:38 +00:00
|
|
|
#endif
|
1999-04-18 14:42:20 +00:00
|
|
|
#define COM_FORCECONSOLE(flags) ((flags) & 0x20)
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_IIR_TXRDYBUG(flags) ((flags) & COM_C_IIR_TXRDYBUG)
|
1999-04-18 14:42:20 +00:00
|
|
|
#define COM_LLCONSOLE(flags) ((flags) & 0x40)
|
|
|
|
#define COM_LOSESOUTINTS(flags) ((flags) & 0x08)
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_NOFIFO(flags) ((flags) & 0x02)
|
2004-05-01 06:53:38 +00:00
|
|
|
#ifndef PC98
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_NOSCR(flags) ((flags) & 0x100000)
|
2004-05-01 06:53:38 +00:00
|
|
|
#endif
|
2003-03-09 10:15:11 +00:00
|
|
|
#define COM_PPSCTS(flags) ((flags) & 0x10000)
|
2004-05-01 06:53:38 +00:00
|
|
|
#ifndef PC98
|
2003-10-05 11:55:14 +00:00
|
|
|
#define COM_ST16650A(flags) ((flags) & 0x20000)
|
|
|
|
#define COM_TI16754(flags) ((flags) & 0x200000)
|
2004-05-01 06:53:38 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
#define sio_getreg(com, off) \
|
|
|
|
(bus_space_read_1((com)->bst, (com)->bsh, (off)))
|
|
|
|
#define sio_setreg(com, off, value) \
|
|
|
|
(bus_space_write_1((com)->bst, (com)->bsh, (off), (value)))
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* com state bits.
|
|
|
|
* (CS_BUSY | CS_TTGO) and (CS_BUSY | CS_TTGO | CS_ODEVREADY) must be higher
|
|
|
|
* than the other bits so that they can be tested as a group without masking
|
|
|
|
* off the low bits.
|
|
|
|
*
|
|
|
|
* The following com and tty flags correspond closely:
|
|
|
|
* CS_BUSY = TS_BUSY (maintained by comstart(), siopoll() and
|
1999-09-25 16:21:39 +00:00
|
|
|
* comstop())
|
1996-06-14 10:04:54 +00:00
|
|
|
* CS_TTGO = ~TS_TTSTOP (maintained by comparam() and comstart())
|
|
|
|
* CS_CTS_OFLOW = CCTS_OFLOW (maintained by comparam())
|
|
|
|
* CS_RTS_IFLOW = CRTS_IFLOW (maintained by comparam())
|
|
|
|
* TS_FLUSH is not used.
|
|
|
|
* XXX I think TIOCSETA doesn't clear TS_TTSTOP when it clears IXON.
|
|
|
|
* XXX CS_*FLOW should be CF_*FLOW in com->flags (control flags not state).
|
|
|
|
*/
|
|
|
|
#define CS_BUSY 0x80 /* output in progress */
|
|
|
|
#define CS_TTGO 0x40 /* output not stopped by XOFF */
|
|
|
|
#define CS_ODEVREADY 0x20 /* external device h/w ready (CTS) */
|
|
|
|
#define CS_CHECKMSR 1 /* check of MSR scheduled */
|
|
|
|
#define CS_CTS_OFLOW 2 /* use CTS output flow control */
|
|
|
|
#define CS_ODONE 4 /* output completed */
|
|
|
|
#define CS_RTS_IFLOW 8 /* use RTS input flow control */
|
1997-04-19 14:54:32 +00:00
|
|
|
#define CSE_BUSYCHECK 1 /* siobusycheck() scheduled */
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
static char const * const error_desc[] = {
|
|
|
|
#define CE_OVERRUN 0
|
|
|
|
"silo overflow",
|
|
|
|
#define CE_INTERRUPT_BUF_OVERFLOW 1
|
|
|
|
"interrupt-level buffer overflow",
|
|
|
|
#define CE_TTY_BUF_OVERFLOW 2
|
|
|
|
"tty-level buffer overflow",
|
|
|
|
};
|
|
|
|
|
|
|
|
#define CE_NTYPES 3
|
|
|
|
#define CE_RECORD(com, errnum) (++(com)->delta_error_counts[errnum])
|
|
|
|
|
|
|
|
/* types. XXX - should be elsewhere */
|
|
|
|
typedef u_int Port_t; /* hardware port */
|
|
|
|
typedef u_char bool_t; /* boolean */
|
|
|
|
|
|
|
|
/* queue of linear buffers */
|
|
|
|
struct lbq {
|
|
|
|
u_char *l_head; /* next char to process */
|
|
|
|
u_char *l_tail; /* one past the last char to process */
|
|
|
|
struct lbq *l_next; /* next in queue */
|
|
|
|
bool_t l_queued; /* nonzero if queued */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* com device structure */
|
|
|
|
struct com_s {
|
|
|
|
u_char state; /* miscellaneous flag bits */
|
|
|
|
u_char cfcr_image; /* copy of value written to CFCR */
|
|
|
|
#ifdef COM_ESP
|
|
|
|
bool_t esp; /* is this unit a hayes esp board? */
|
|
|
|
#endif
|
1997-04-19 14:54:32 +00:00
|
|
|
u_char extra_state; /* more flag bits, separate for order trick */
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char fifo_image; /* copy of value written to FIFO */
|
|
|
|
bool_t hasfifo; /* nonzero for 16550 UARTs */
|
|
|
|
bool_t loses_outints; /* nonzero if device loses output interrupts */
|
|
|
|
u_char mcr_image; /* copy of value written to MCR */
|
|
|
|
#ifdef COM_MULTIPORT
|
|
|
|
bool_t multiport; /* is this unit part of a multiport device? */
|
|
|
|
#endif /* COM_MULTIPORT */
|
|
|
|
bool_t no_irq; /* nonzero if irq is not attached */
|
|
|
|
bool_t gone; /* hardware disappeared */
|
|
|
|
bool_t poll; /* nonzero if polling is required */
|
|
|
|
bool_t poll_output; /* nonzero if polling for output is required */
|
2003-10-05 11:55:14 +00:00
|
|
|
bool_t st16650a; /* nonzero if Startech 16650A compatible */
|
1996-06-14 10:04:54 +00:00
|
|
|
int unit; /* unit number */
|
2003-10-05 11:55:14 +00:00
|
|
|
u_int flags; /* copy of device flags */
|
1996-06-14 10:04:54 +00:00
|
|
|
u_int tx_fifo_size;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The high level of the driver never reads status registers directly
|
|
|
|
* because there would be too many side effects to handle conveniently.
|
|
|
|
* Instead, it reads copies of the registers stored here by the
|
|
|
|
* interrupt handler.
|
|
|
|
*/
|
|
|
|
u_char last_modem_status; /* last MSR read by intr handler */
|
|
|
|
u_char prev_modem_status; /* last MSR handled by high level */
|
|
|
|
|
|
|
|
u_char *ibuf; /* start of input buffer */
|
|
|
|
u_char *ibufend; /* end of input buffer */
|
1999-02-05 11:37:40 +00:00
|
|
|
u_char *ibufold; /* old input buffer, to be freed */
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char *ihighwater; /* threshold in input buffer */
|
|
|
|
u_char *iptr; /* next free spot in input buffer */
|
1999-02-05 11:37:40 +00:00
|
|
|
int ibufsize; /* size of ibuf (not include error bytes) */
|
|
|
|
int ierroff; /* offset of error bytes in ibuf */
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
struct lbq obufq; /* head of queue of output buffers */
|
|
|
|
struct lbq obufs[2]; /* output buffers */
|
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
bus_space_tag_t bst;
|
|
|
|
bus_space_handle_t bsh;
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
|
|
|
Port_t cmd_port;
|
|
|
|
Port_t sts_port;
|
|
|
|
Port_t in_modem_port;
|
|
|
|
Port_t intr_ctrl_port;
|
2003-01-01 18:49:04 +00:00
|
|
|
Port_t rsabase; /* Iobase address of an I/O-DATA RSA board. */
|
1996-06-14 10:04:54 +00:00
|
|
|
int intr_enable;
|
|
|
|
int pc98_prev_modem_status;
|
|
|
|
int pc98_modem_delta;
|
|
|
|
int modem_car_chg_timer;
|
|
|
|
int pc98_prev_siocmd;
|
|
|
|
int pc98_prev_siomod;
|
|
|
|
int modem_checking;
|
|
|
|
int pc98_if_type;
|
1999-12-06 00:23:38 +00:00
|
|
|
|
|
|
|
bool_t pc98_8251fifo;
|
|
|
|
bool_t pc98_8251fifo_enable;
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* PC98 */
|
|
|
|
Port_t data_port; /* i/o ports */
|
|
|
|
#ifdef COM_ESP
|
|
|
|
Port_t esp_port;
|
|
|
|
#endif
|
2003-10-05 11:55:14 +00:00
|
|
|
Port_t int_ctl_port;
|
1996-06-14 10:04:54 +00:00
|
|
|
Port_t int_id_port;
|
|
|
|
Port_t modem_ctl_port;
|
|
|
|
Port_t line_status_port;
|
|
|
|
Port_t modem_status_port;
|
|
|
|
|
|
|
|
struct tty *tp; /* cross reference */
|
|
|
|
|
1999-04-01 13:44:15 +00:00
|
|
|
struct pps_state pps;
|
2003-03-09 10:15:11 +00:00
|
|
|
int pps_bit;
|
2003-08-28 11:20:54 +00:00
|
|
|
#ifdef ALT_BREAK_TO_DEBUGGER
|
|
|
|
int alt_brk_state;
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
u_long bytes_in; /* statistics */
|
|
|
|
u_long bytes_out;
|
|
|
|
u_int delta_error_counts[CE_NTYPES];
|
|
|
|
u_long error_counts[CE_NTYPES];
|
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
u_long rclk;
|
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
struct resource *irqres;
|
|
|
|
struct resource *ioportres;
|
2003-08-02 09:41:31 +00:00
|
|
|
int ioportrid;
|
|
|
|
void *cookie;
|
1999-09-12 13:44:54 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
/*
|
|
|
|
* Data area for output buffers. Someday we should build the output
|
|
|
|
* buffer queue without copying data.
|
|
|
|
*/
|
1999-02-05 11:37:40 +00:00
|
|
|
#ifdef PC98
|
|
|
|
int obufsize;
|
1999-01-03 05:03:47 +00:00
|
|
|
u_char *obuf1;
|
|
|
|
u_char *obuf2;
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char obuf1[256];
|
|
|
|
u_char obuf2[256];
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef COM_ESP
|
2002-03-20 12:22:31 +00:00
|
|
|
static int espattach(struct com_s *com, Port_t esp_port);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-04-18 14:42:20 +00:00
|
|
|
|
2004-07-01 09:32:32 +00:00
|
|
|
static void combreak(struct tty *tp, int sig);
|
1996-12-04 04:36:59 +00:00
|
|
|
static timeout_t siobusycheck;
|
2002-03-20 12:22:31 +00:00
|
|
|
static u_int siodivisor(u_long rclk, speed_t speed);
|
2004-10-15 08:22:37 +00:00
|
|
|
static void comclose(struct tty *tp);
|
|
|
|
static int comopen(struct tty *tp, struct cdev *dev);
|
2002-03-20 12:22:31 +00:00
|
|
|
static void sioinput(struct com_s *com);
|
|
|
|
static void siointr1(struct com_s *com);
|
2007-02-23 12:19:07 +00:00
|
|
|
static int siointr(void *arg);
|
2004-06-26 04:00:46 +00:00
|
|
|
static int commodem(struct tty *tp, int sigon, int sigoff);
|
2002-03-20 12:22:31 +00:00
|
|
|
static int comparam(struct tty *tp, struct termios *t);
|
|
|
|
static void siopoll(void *);
|
|
|
|
static void siosettimeout(void);
|
|
|
|
static int siosetwater(struct com_s *com, speed_t speed);
|
|
|
|
static void comstart(struct tty *tp);
|
|
|
|
static void comstop(struct tty *tp, int rw);
|
1996-06-14 10:04:54 +00:00
|
|
|
static timeout_t comwakeup;
|
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
char sio_driver_name[] = "sio";
|
2001-01-27 13:02:06 +00:00
|
|
|
static struct mtx sio_lock;
|
|
|
|
static int sio_inited;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/* table and macro for fast conversion from a unit number to its com struct */
|
2001-11-26 12:29:53 +00:00
|
|
|
devclass_t sio_devclass;
|
1999-04-18 14:42:20 +00:00
|
|
|
#define com_addr(unit) ((struct com_s *) \
|
2001-11-26 12:29:53 +00:00
|
|
|
devclass_get_softc(sio_devclass, unit)) /* XXX */
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
int comconsole = -1;
|
1997-06-06 13:09:55 +00:00
|
|
|
static volatile speed_t comdefaultrate = CONSPEED;
|
2002-01-31 08:26:45 +00:00
|
|
|
static u_long comdefaultrclk = DEFAULT_RCLK;
|
|
|
|
SYSCTL_ULONG(_machdep, OID_AUTO, conrclk, CTLFLAG_RW, &comdefaultrclk, 0, "");
|
2002-06-18 21:30:37 +00:00
|
|
|
static speed_t gdbdefaultrate = GDBSPEED;
|
|
|
|
SYSCTL_UINT(_machdep, OID_AUTO, gdbspeed, CTLFLAG_RW,
|
|
|
|
&gdbdefaultrate, GDBSPEED, "");
|
1996-06-14 10:04:54 +00:00
|
|
|
static u_int com_events; /* input chars + weighted output completions */
|
1997-04-05 15:04:32 +00:00
|
|
|
static Port_t siocniobase;
|
2002-06-19 13:20:20 +00:00
|
|
|
static int siocnunit = -1;
|
2001-02-13 09:55:20 +00:00
|
|
|
static void *sio_slow_ih;
|
|
|
|
static void *sio_fast_ih;
|
1996-06-14 10:04:54 +00:00
|
|
|
static int sio_timeout;
|
|
|
|
static int sio_timeouts_until_log;
|
1997-09-22 12:23:49 +00:00
|
|
|
static struct callout_handle sio_timeout_handle
|
|
|
|
= CALLOUT_HANDLE_INITIALIZER(&sio_timeout_handle);
|
1999-11-18 12:22:09 +00:00
|
|
|
static int sio_numunits;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
struct siodev {
|
|
|
|
short if_type;
|
|
|
|
short irq;
|
|
|
|
Port_t cmd, sts, ctrl, mod;
|
1999-01-03 05:03:47 +00:00
|
|
|
};
|
1996-06-14 10:04:54 +00:00
|
|
|
static int sysclock;
|
1999-01-03 05:03:47 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#define COM_INT_DISABLE {int previpri; previpri=spltty();
|
|
|
|
#define COM_INT_ENABLE splx(previpri);}
|
|
|
|
#define IEN_TxFLAG IEN_Tx
|
|
|
|
|
|
|
|
#define COM_CARRIER_DETECT_EMULATE 0
|
|
|
|
#define PC98_CHECK_MODEM_INTERVAL (hz/10)
|
|
|
|
#define DCD_OFF_TOLERANCE 2
|
|
|
|
#define DCD_ON_RECOGNITION 2
|
1999-11-18 12:22:09 +00:00
|
|
|
#define IS_8251(if_type) (!(if_type & 0x10))
|
1999-01-03 05:03:47 +00:00
|
|
|
#define COM1_EXT_CLOCK 0x40000
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-06-16 09:47:26 +00:00
|
|
|
static void commint(struct cdev *dev);
|
2002-03-20 12:22:31 +00:00
|
|
|
static void com_tiocm_bis(struct com_s *com, int msr);
|
|
|
|
static void com_tiocm_bic(struct com_s *com, int msr);
|
|
|
|
static int com_tiocm_get(struct com_s *com);
|
|
|
|
static int com_tiocm_get_delta(struct com_s *com);
|
2004-06-16 09:47:26 +00:00
|
|
|
static void pc98_msrint_start(struct cdev *dev);
|
2002-03-20 12:22:31 +00:00
|
|
|
static void com_cflag_and_speed_set(struct com_s *com, int cflag, int speed);
|
|
|
|
static int pc98_ttspeedtab(struct com_s *com, int speed, u_int *divisor);
|
|
|
|
static int pc98_get_modem_status(struct com_s *com);
|
1996-06-14 10:04:54 +00:00
|
|
|
static timeout_t pc98_check_msr;
|
2002-03-20 12:22:31 +00:00
|
|
|
static void pc98_set_baud_rate(struct com_s *com, u_int count);
|
|
|
|
static void pc98_i8251_reset(struct com_s *com, int mode, int command);
|
|
|
|
static void pc98_disable_i8251_interrupt(struct com_s *com, int mod);
|
|
|
|
static void pc98_enable_i8251_interrupt(struct com_s *com, int mod);
|
|
|
|
static int pc98_check_i8251_interrupt(struct com_s *com);
|
|
|
|
static int pc98_i8251_get_cmd(struct com_s *com);
|
|
|
|
static int pc98_i8251_get_mod(struct com_s *com);
|
|
|
|
static void pc98_i8251_set_cmd(struct com_s *com, int x);
|
|
|
|
static void pc98_i8251_or_cmd(struct com_s *com, int x);
|
|
|
|
static void pc98_i8251_clear_cmd(struct com_s *com, int x);
|
|
|
|
static void pc98_i8251_clear_or_cmd(struct com_s *com, int clr, int x);
|
|
|
|
static int pc98_check_if_type(device_t dev, struct siodev *iod);
|
|
|
|
static int pc98_check_8251vfast(void);
|
|
|
|
static int pc98_check_8251fifo(void);
|
|
|
|
static void pc98_check_sysclock(void);
|
|
|
|
static void pc98_set_ioport(struct com_s *com);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#define com_int_Tx_disable(com) \
|
|
|
|
pc98_disable_i8251_interrupt(com,IEN_Tx|IEN_TxEMP)
|
|
|
|
#define com_int_Tx_enable(com) \
|
|
|
|
pc98_enable_i8251_interrupt(com,IEN_TxFLAG)
|
|
|
|
#define com_int_Rx_disable(com) \
|
|
|
|
pc98_disable_i8251_interrupt(com,IEN_Rx)
|
|
|
|
#define com_int_Rx_enable(com) \
|
|
|
|
pc98_enable_i8251_interrupt(com,IEN_Rx)
|
|
|
|
#define com_int_TxRx_disable(com) \
|
|
|
|
pc98_disable_i8251_interrupt(com,IEN_Tx|IEN_TxEMP|IEN_Rx)
|
|
|
|
#define com_int_TxRx_enable(com) \
|
|
|
|
pc98_enable_i8251_interrupt(com,IEN_TxFLAG|IEN_Rx)
|
|
|
|
#define com_send_break_on(com) \
|
2004-06-26 04:00:46 +00:00
|
|
|
(IS_8251((com)->pc98_if_type) ? \
|
|
|
|
pc98_i8251_or_cmd((com), CMD8251_SBRK) : \
|
|
|
|
sio_setreg((com), com_cfcr, (com)->cfcr_image |= CFCR_SBREAK))
|
1996-06-14 10:04:54 +00:00
|
|
|
#define com_send_break_off(com) \
|
2004-06-26 04:00:46 +00:00
|
|
|
(IS_8251((com)->pc98_if_type) ? \
|
|
|
|
pc98_i8251_clear_cmd((com), CMD8251_SBRK) : \
|
|
|
|
sio_setreg((com), com_cfcr, (com)->cfcr_image &= ~CFCR_SBREAK))
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
static struct speedtab pc98speedtab[] = { /* internal RS232C interface */
|
1999-02-02 17:26:03 +00:00
|
|
|
{ 0, 0, },
|
|
|
|
{ 50, 50, },
|
|
|
|
{ 75, 75, },
|
|
|
|
{ 150, 150, },
|
|
|
|
{ 200, 200, },
|
|
|
|
{ 300, 300, },
|
|
|
|
{ 600, 600, },
|
|
|
|
{ 1200, 1200, },
|
|
|
|
{ 2400, 2400, },
|
|
|
|
{ 4800, 4800, },
|
|
|
|
{ 9600, 9600, },
|
|
|
|
{ 19200, 19200, },
|
|
|
|
{ 38400, 38400, },
|
|
|
|
{ 51200, 51200, },
|
|
|
|
{ 76800, 76800, },
|
|
|
|
{ 20800, 20800, },
|
|
|
|
{ 31200, 31200, },
|
|
|
|
{ 41600, 41600, },
|
|
|
|
{ 62400, 62400, },
|
|
|
|
{ -1, -1 }
|
1996-06-14 10:04:54 +00:00
|
|
|
};
|
1999-01-03 05:03:47 +00:00
|
|
|
static struct speedtab pc98fast_speedtab[] = {
|
2002-01-31 08:26:45 +00:00
|
|
|
{ 9600, 0x80 | (DEFAULT_RCLK / (16 * (9600))), },
|
|
|
|
{ 19200, 0x80 | (DEFAULT_RCLK / (16 * (19200))), },
|
|
|
|
{ 38400, 0x80 | (DEFAULT_RCLK / (16 * (38400))), },
|
|
|
|
{ 57600, 0x80 | (DEFAULT_RCLK / (16 * (57600))), },
|
|
|
|
{ 115200, 0x80 | (DEFAULT_RCLK / (16 * (115200))), },
|
1999-02-02 17:26:03 +00:00
|
|
|
{ -1, -1 }
|
1999-01-03 05:03:47 +00:00
|
|
|
};
|
|
|
|
static struct speedtab comspeedtab_pio9032b[] = {
|
1999-02-02 17:26:03 +00:00
|
|
|
{ 300, 6, },
|
|
|
|
{ 600, 5, },
|
|
|
|
{ 1200, 4, },
|
|
|
|
{ 2400, 3, },
|
|
|
|
{ 4800, 2, },
|
|
|
|
{ 9600, 1, },
|
|
|
|
{ 19200, 0, },
|
|
|
|
{ 38400, 7, },
|
|
|
|
{ -1, -1 }
|
1996-06-14 10:04:54 +00:00
|
|
|
};
|
1999-01-03 05:03:47 +00:00
|
|
|
static struct speedtab comspeedtab_b98_01[] = {
|
1999-02-02 17:26:03 +00:00
|
|
|
{ 75, 11, },
|
|
|
|
{ 150, 10, },
|
|
|
|
{ 300, 9, },
|
|
|
|
{ 600, 8, },
|
|
|
|
{ 1200, 7, },
|
|
|
|
{ 2400, 6, },
|
|
|
|
{ 4800, 5, },
|
|
|
|
{ 9600, 4, },
|
|
|
|
{ 19200, 3, },
|
|
|
|
{ 38400, 2, },
|
|
|
|
{ 76800, 1, },
|
|
|
|
{ 153600, 0, },
|
|
|
|
{ -1, -1 }
|
1996-06-14 10:04:54 +00:00
|
|
|
};
|
2002-01-31 08:26:45 +00:00
|
|
|
static struct speedtab comspeedtab_ind[] = {
|
1999-02-02 17:26:03 +00:00
|
|
|
{ 300, 1536, },
|
|
|
|
{ 600, 768, },
|
|
|
|
{ 1200, 384, },
|
|
|
|
{ 2400, 192, },
|
|
|
|
{ 4800, 96, },
|
|
|
|
{ 9600, 48, },
|
|
|
|
{ 19200, 24, },
|
|
|
|
{ 38400, 12, },
|
|
|
|
{ 57600, 8, },
|
|
|
|
{ 115200, 4, },
|
|
|
|
{ 153600, 3, },
|
|
|
|
{ 230400, 2, },
|
|
|
|
{ 460800, 1, },
|
|
|
|
{ -1, -1 }
|
1999-01-03 05:03:47 +00:00
|
|
|
};
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
struct {
|
|
|
|
char *name;
|
|
|
|
short port_table[7];
|
|
|
|
short irr_mask;
|
|
|
|
struct speedtab *speedtab;
|
|
|
|
short check_irq;
|
|
|
|
} if_8251_type[] = {
|
|
|
|
/* COM_IF_INTERNAL */
|
|
|
|
{ " (internal)", {0x30, 0x32, 0x32, 0x33, 0x35, -1, -1},
|
|
|
|
-1, pc98speedtab, 1 },
|
|
|
|
/* COM_IF_PC9861K_1 */
|
|
|
|
{ " (PC9861K)", {0xb1, 0xb3, 0xb3, 0xb0, 0xb0, -1, -1},
|
|
|
|
3, NULL, 1 },
|
|
|
|
/* COM_IF_PC9861K_2 */
|
|
|
|
{ " (PC9861K)", {0xb9, 0xbb, 0xbb, 0xb2, 0xb2, -1, -1},
|
|
|
|
3, NULL, 1 },
|
|
|
|
/* COM_IF_IND_SS_1 */
|
|
|
|
{ " (IND-SS)", {0xb1, 0xb3, 0xb3, 0xb0, 0xb0, 0xb3, -1},
|
2002-01-31 08:26:45 +00:00
|
|
|
3, comspeedtab_ind, 1 },
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_IND_SS_2 */
|
|
|
|
{ " (IND-SS)", {0xb9, 0xbb, 0xbb, 0xb2, 0xb2, 0xbb, -1},
|
2002-01-31 08:26:45 +00:00
|
|
|
3, comspeedtab_ind, 1 },
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_PIO9032B_1 */
|
|
|
|
{ " (PIO9032B)", {0xb1, 0xb3, 0xb3, 0xb0, 0xb0, 0xb8, -1},
|
|
|
|
7, comspeedtab_pio9032b, 1 },
|
|
|
|
/* COM_IF_PIO9032B_2 */
|
|
|
|
{ " (PIO9032B)", {0xb9, 0xbb, 0xbb, 0xb2, 0xb2, 0xba, -1},
|
|
|
|
7, comspeedtab_pio9032b, 1 },
|
|
|
|
/* COM_IF_B98_01_1 */
|
|
|
|
{ " (B98-01)", {0xb1, 0xb3, 0xb3, 0xb0, 0xb0, 0xd1, 0xd3},
|
|
|
|
7, comspeedtab_b98_01, 0 },
|
|
|
|
/* COM_IF_B98_01_2 */
|
|
|
|
{ " (B98-01)", {0xb9, 0xbb, 0xbb, 0xb2, 0xb2, 0xd5, 0xd7},
|
|
|
|
7, comspeedtab_b98_01, 0 },
|
|
|
|
};
|
|
|
|
#define PC98SIO_data_port(type) (if_8251_type[type].port_table[0])
|
|
|
|
#define PC98SIO_cmd_port(type) (if_8251_type[type].port_table[1])
|
|
|
|
#define PC98SIO_sts_port(type) (if_8251_type[type].port_table[2])
|
|
|
|
#define PC98SIO_in_modem_port(type) (if_8251_type[type].port_table[3])
|
|
|
|
#define PC98SIO_intr_ctrl_port(type) (if_8251_type[type].port_table[4])
|
|
|
|
#define PC98SIO_baud_rate_port(type) (if_8251_type[type].port_table[5])
|
|
|
|
#define PC98SIO_func_port(type) (if_8251_type[type].port_table[6])
|
|
|
|
|
1999-12-06 00:23:38 +00:00
|
|
|
#define I8251F_data 0x130
|
|
|
|
#define I8251F_lsr 0x132
|
|
|
|
#define I8251F_msr 0x134
|
|
|
|
#define I8251F_iir 0x136
|
|
|
|
#define I8251F_fcr 0x138
|
|
|
|
#define I8251F_div 0x13a
|
|
|
|
|
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
static bus_addr_t port_table_0[] =
|
|
|
|
{0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007};
|
|
|
|
static bus_addr_t port_table_1[] =
|
|
|
|
{0x000, 0x002, 0x004, 0x006, 0x008, 0x00a, 0x00c, 0x00e};
|
|
|
|
static bus_addr_t port_table_8[] =
|
|
|
|
{0x000, 0x100, 0x200, 0x300, 0x400, 0x500, 0x600, 0x700};
|
2000-06-21 11:21:14 +00:00
|
|
|
static bus_addr_t port_table_rsa[] = {
|
|
|
|
0x008, 0x009, 0x00a, 0x00b, 0x00c, 0x00d, 0x00e, 0x00f,
|
|
|
|
0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007
|
|
|
|
};
|
2000-05-12 12:38:25 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
struct {
|
2000-05-12 12:38:25 +00:00
|
|
|
char *name;
|
|
|
|
short irr_read;
|
|
|
|
short irr_write;
|
2000-06-21 11:21:14 +00:00
|
|
|
bus_addr_t *iat;
|
|
|
|
bus_size_t iatsz;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_long rclk;
|
1999-01-03 05:03:47 +00:00
|
|
|
} if_16550a_type[] = {
|
|
|
|
/* COM_IF_RSA98 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (RSA-98)", -1, -1, port_table_0, IO_COMSIZE, DEFAULT_RCLK},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_NS16550 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{"", -1, -1, port_table_0, IO_COMSIZE, DEFAULT_RCLK},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_SECOND_CCU */
|
2002-01-31 08:26:45 +00:00
|
|
|
{"", -1, -1, port_table_0, IO_COMSIZE, DEFAULT_RCLK},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_MC16550II */
|
2000-06-21 11:21:14 +00:00
|
|
|
{" (MC16550II)", -1, 0x1000, port_table_8, IO_COMSIZE,
|
2002-01-31 08:26:45 +00:00
|
|
|
DEFAULT_RCLK * 4},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_MCRS98 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (MC-RS98)", -1, 0x1000, port_table_8, IO_COMSIZE, DEFAULT_RCLK * 4},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_RSB3000 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (RSB-3000)", 0xbf, -1, port_table_1, IO_COMSIZE, DEFAULT_RCLK * 10},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_RSB384 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (RSB-384)", 0xbf, -1, port_table_1, IO_COMSIZE, DEFAULT_RCLK * 10},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_MODEM_CARD */
|
2002-01-31 08:26:45 +00:00
|
|
|
{"", -1, -1, port_table_0, IO_COMSIZE, DEFAULT_RCLK},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_RSA98III */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (RSA-98III)", -1, -1, port_table_rsa, 16, DEFAULT_RCLK * 8},
|
1999-01-03 05:03:47 +00:00
|
|
|
/* COM_IF_ESP98 */
|
2002-01-31 08:26:45 +00:00
|
|
|
{" (ESP98)", -1, -1, port_table_1, IO_COMSIZE, DEFAULT_RCLK * 4},
|
1999-01-03 05:03:47 +00:00
|
|
|
};
|
|
|
|
#endif /* PC98 */
|
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
#ifdef GDB
|
|
|
|
static Port_t siogdbiobase = 0;
|
|
|
|
#endif
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef COM_ESP
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-01-03 15:57:02 +00:00
|
|
|
|
|
|
|
/* XXX configure this properly. */
|
2001-11-26 12:29:53 +00:00
|
|
|
/* XXX quite broken for new-bus. */
|
1999-01-03 05:03:47 +00:00
|
|
|
static Port_t likely_com_ports[] = { 0, 0xb0, 0xb1, 0 };
|
|
|
|
static Port_t likely_esp_ports[] = { 0xc0d0, 0 };
|
1999-01-03 15:57:02 +00:00
|
|
|
|
|
|
|
#define ESP98_CMD1 (ESP_CMD1 * 0x100)
|
|
|
|
#define ESP98_CMD2 (ESP_CMD2 * 0x100)
|
|
|
|
#define ESP98_STATUS1 (ESP_STATUS1 * 0x100)
|
|
|
|
#define ESP98_STATUS2 (ESP_STATUS2 * 0x100)
|
|
|
|
|
|
|
|
#else /* PC98 */
|
|
|
|
|
|
|
|
/* XXX configure this properly. */
|
1996-06-14 10:04:54 +00:00
|
|
|
static Port_t likely_com_ports[] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, };
|
|
|
|
static Port_t likely_esp_ports[] = { 0x140, 0x180, 0x280, 0 };
|
1999-01-03 15:57:02 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif /* PC98 */
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
|
1997-06-04 10:27:53 +00:00
|
|
|
/*
|
|
|
|
* handle sysctl read/write requests for console speed
|
|
|
|
*
|
|
|
|
* In addition to setting comdefaultrate for I/O through /dev/console,
|
|
|
|
* also set the initial and lock values for the /dev/ttyXX device
|
|
|
|
* if there is one associated with the console. Finally, if the /dev/tty
|
|
|
|
* device has already been open, change the speed on the open running port
|
|
|
|
* itself.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
sysctl_machdep_comdefaultrate(SYSCTL_HANDLER_ARGS)
|
1997-06-04 10:27:53 +00:00
|
|
|
{
|
|
|
|
int error, s;
|
|
|
|
speed_t newspeed;
|
|
|
|
struct com_s *com;
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
newspeed = comdefaultrate;
|
|
|
|
|
|
|
|
error = sysctl_handle_opaque(oidp, &newspeed, sizeof newspeed, req);
|
|
|
|
if (error || !req->newptr)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
comdefaultrate = newspeed;
|
|
|
|
|
|
|
|
if (comconsole < 0) /* serial console not selected? */
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
com = com_addr(comconsole);
|
2000-03-12 13:14:51 +00:00
|
|
|
if (com == NULL)
|
1997-06-04 10:27:53 +00:00
|
|
|
return (ENXIO);
|
2004-09-20 14:01:38 +00:00
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
tp = com->tp;
|
|
|
|
if (tp == NULL)
|
|
|
|
return (ENXIO);
|
1997-06-04 10:27:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* set the initial and lock rates for /dev/ttydXX and /dev/cuaXX
|
|
|
|
* (note, the lock rates really are boolean -- if non-zero, disallow
|
|
|
|
* speed changes)
|
|
|
|
*/
|
2004-09-17 10:59:17 +00:00
|
|
|
tp->t_init_in.c_ispeed = tp->t_init_in.c_ospeed =
|
|
|
|
tp->t_lock_in.c_ispeed = tp->t_lock_in.c_ospeed =
|
|
|
|
tp->t_init_out.c_ispeed = tp->t_init_out.c_ospeed =
|
|
|
|
tp->t_lock_out.c_ispeed = tp->t_lock_out.c_ospeed = comdefaultrate;
|
1997-06-04 10:27:53 +00:00
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
if (tp->t_state & TS_ISOPEN) {
|
1997-06-04 10:27:53 +00:00
|
|
|
tp->t_termios.c_ispeed =
|
|
|
|
tp->t_termios.c_ospeed = comdefaultrate;
|
|
|
|
s = spltty();
|
|
|
|
error = comparam(tp, &tp->t_termios);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_machdep, OID_AUTO, conspeed, CTLTYPE_INT | CTLFLAG_RW,
|
|
|
|
0, 0, sysctl_machdep_comdefaultrate, "I", "");
|
2005-12-18 11:16:31 +00:00
|
|
|
TUNABLE_INT("machdep.conspeed", __DEVOLATILE(int *, &comdefaultrate));
|
1997-06-04 10:27:53 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
2001-11-26 12:29:53 +00:00
|
|
|
* Unload the driver and clear the table.
|
|
|
|
* XXX this is mostly wrong.
|
1996-06-14 10:04:54 +00:00
|
|
|
* XXX TODO:
|
|
|
|
* This is usually called when the card is ejected, but
|
2002-10-14 10:10:09 +00:00
|
|
|
* can be caused by a kldunload of a controller driver.
|
1996-06-14 10:04:54 +00:00
|
|
|
* The idea is to reset the driver's view of the device
|
|
|
|
* and ensure that any driver entry points such as
|
|
|
|
* read and write do not hang.
|
|
|
|
*/
|
2001-11-26 12:29:53 +00:00
|
|
|
int
|
2004-10-15 08:22:37 +00:00
|
|
|
siodetach(device_t dev)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
|
1999-11-03 09:02:23 +00:00
|
|
|
com = (struct com_s *) device_get_softc(dev);
|
2000-03-12 13:14:51 +00:00
|
|
|
if (com == NULL) {
|
1999-11-03 09:02:23 +00:00
|
|
|
device_printf(dev, "NULL com in siounload\n");
|
1999-12-10 14:03:47 +00:00
|
|
|
return (0);
|
1998-06-24 13:37:23 +00:00
|
|
|
}
|
2003-10-05 11:55:14 +00:00
|
|
|
com->gone = TRUE;
|
2004-07-24 15:13:42 +00:00
|
|
|
if (com->tp)
|
2004-10-15 08:22:37 +00:00
|
|
|
ttyfree(com->tp);
|
1999-12-10 14:03:47 +00:00
|
|
|
if (com->irqres) {
|
|
|
|
bus_teardown_intr(dev, com->irqres, com->cookie);
|
|
|
|
bus_release_resource(dev, SYS_RES_IRQ, 0, com->irqres);
|
|
|
|
}
|
|
|
|
if (com->ioportres)
|
2003-08-02 09:41:31 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, com->ioportrid,
|
|
|
|
com->ioportres);
|
2004-10-15 08:22:37 +00:00
|
|
|
if (com->ibuf != NULL)
|
|
|
|
free(com->ibuf, M_DEVBUF);
|
2002-03-10 07:22:42 +00:00
|
|
|
#ifdef PC98
|
2004-10-15 08:22:37 +00:00
|
|
|
if (com->obuf1 != NULL)
|
|
|
|
free(com->obuf1, M_DEVBUF);
|
2002-03-10 07:22:42 +00:00
|
|
|
#endif
|
2004-10-15 08:22:37 +00:00
|
|
|
|
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
1999-12-01 13:40:03 +00:00
|
|
|
return (0);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2000-04-01 11:27:31 +00:00
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
int
|
2002-01-31 08:26:45 +00:00
|
|
|
sioprobe(dev, xrid, rclk, noprobe)
|
1999-04-18 14:42:20 +00:00
|
|
|
device_t dev;
|
2000-04-01 11:27:31 +00:00
|
|
|
int xrid;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_long rclk;
|
2001-11-26 12:29:53 +00:00
|
|
|
int noprobe;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-11-18 12:22:09 +00:00
|
|
|
#if 0
|
1996-06-14 10:04:54 +00:00
|
|
|
static bool_t already_init;
|
1999-11-18 12:22:09 +00:00
|
|
|
device_t xdev;
|
|
|
|
#endif
|
2000-05-12 12:38:25 +00:00
|
|
|
struct com_s *com;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_int divisor;
|
1996-06-14 10:04:54 +00:00
|
|
|
bool_t failures[10];
|
|
|
|
int fn;
|
1999-04-18 14:42:20 +00:00
|
|
|
device_t idev;
|
1996-06-14 10:04:54 +00:00
|
|
|
Port_t iobase;
|
1998-06-01 12:40:24 +00:00
|
|
|
intrmask_t irqmap[4];
|
|
|
|
intrmask_t irqs;
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char mcr_image;
|
|
|
|
int result;
|
1999-12-07 09:29:15 +00:00
|
|
|
u_long xirq;
|
1999-09-07 11:17:09 +00:00
|
|
|
u_int flags = device_get_flags(dev);
|
1999-09-12 13:44:54 +00:00
|
|
|
int rid;
|
|
|
|
struct resource *port;
|
1998-01-16 11:20:22 +00:00
|
|
|
#ifdef PC98
|
1996-06-14 10:04:54 +00:00
|
|
|
int tmp;
|
1999-01-03 05:03:47 +00:00
|
|
|
struct siodev iod;
|
2000-05-12 12:38:25 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
iod.if_type = GET_IFTYPE(flags);
|
|
|
|
if ((iod.if_type < 0 || iod.if_type > COM_IF_END1) &&
|
|
|
|
(iod.if_type < 0x10 || iod.if_type > COM_IF_END2))
|
2001-01-27 13:02:06 +00:00
|
|
|
return ENXIO;
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
|
2000-04-01 11:27:31 +00:00
|
|
|
rid = xrid;
|
1999-09-12 13:44:54 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
if (IS_8251(iod.if_type)) {
|
2004-03-17 17:50:55 +00:00
|
|
|
port = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
|
|
|
|
RF_ACTIVE);
|
2001-02-25 08:55:07 +00:00
|
|
|
} else if (iod.if_type == COM_IF_MODEM_CARD ||
|
|
|
|
iod.if_type == COM_IF_RSA98III ||
|
2000-06-21 11:21:14 +00:00
|
|
|
isa_get_vendorid(dev)) {
|
|
|
|
port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[iod.if_type & 0x0f].iatsz, RF_ACTIVE);
|
2000-05-12 12:38:25 +00:00
|
|
|
} else {
|
|
|
|
port = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[iod.if_type & 0x0f].iat,
|
|
|
|
if_16550a_type[iod.if_type & 0x0f].iatsz, RF_ACTIVE);
|
2000-05-12 12:38:25 +00:00
|
|
|
}
|
1999-09-12 13:44:54 +00:00
|
|
|
#else
|
|
|
|
port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
|
|
|
|
0, ~0, IO_COMSIZE, RF_ACTIVE);
|
|
|
|
#endif
|
|
|
|
if (!port)
|
2000-03-12 13:14:51 +00:00
|
|
|
return (ENXIO);
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(iod.if_type)) {
|
|
|
|
if (isa_load_resourcev(port,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[iod.if_type & 0x0f].iat,
|
|
|
|
if_16550a_type[iod.if_type & 0x0f].iatsz) != 0) {
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
|
|
|
return ENXIO;
|
2000-05-12 12:38:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
com = malloc(sizeof(*com), M_DEVBUF, M_NOWAIT | M_ZERO);
|
2004-01-21 16:12:29 +00:00
|
|
|
if (com == NULL) {
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
return (ENOMEM);
|
2004-01-21 16:12:29 +00:00
|
|
|
}
|
2001-11-26 12:29:53 +00:00
|
|
|
device_set_softc(dev, com);
|
2000-05-12 12:38:25 +00:00
|
|
|
com->bst = rman_get_bustag(port);
|
|
|
|
com->bsh = rman_get_bushandle(port);
|
2002-01-31 08:26:45 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(iod.if_type) && rclk == 0)
|
|
|
|
rclk = if_16550a_type[iod.if_type & 0x0f].rclk;
|
|
|
|
#else
|
|
|
|
if (rclk == 0)
|
|
|
|
rclk = DEFAULT_RCLK;
|
|
|
|
#endif
|
|
|
|
com->rclk = rclk;
|
1999-09-12 13:44:54 +00:00
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
while (sio_inited != 2)
|
|
|
|
if (atomic_cmpset_int(&sio_inited, 0, 1)) {
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&sio_lock, sio_driver_name, NULL,
|
|
|
|
(comconsole != -1) ?
|
2001-11-26 12:29:53 +00:00
|
|
|
MTX_SPIN | MTX_QUIET : MTX_SPIN);
|
|
|
|
atomic_store_rel_int(&sio_inited, 2);
|
|
|
|
}
|
2001-01-27 13:02:06 +00:00
|
|
|
|
1999-11-18 12:22:09 +00:00
|
|
|
#if 0
|
|
|
|
/*
|
|
|
|
* XXX this is broken - when we are first called, there are no
|
|
|
|
* previously configured IO ports. We could hard code
|
|
|
|
* 0x3f8, 0x2f8, 0x3e8, 0x2e8 etc but that's probably worse.
|
|
|
|
* This code has been doing nothing since the conversion since
|
|
|
|
* "count" is zero the first time around.
|
|
|
|
*/
|
1996-06-14 10:04:54 +00:00
|
|
|
if (!already_init) {
|
|
|
|
/*
|
|
|
|
* Turn off MCR_IENABLE for all likely serial ports. An unused
|
|
|
|
* port with its MCR_IENABLE gate open will inhibit interrupts
|
|
|
|
* from any used port that shares the interrupt vector.
|
|
|
|
* XXX the gate enable is elsewhere for some multiports.
|
|
|
|
*/
|
1999-04-18 14:42:20 +00:00
|
|
|
device_t *devs;
|
1999-11-18 12:22:09 +00:00
|
|
|
int count, i, xioport;
|
|
|
|
#ifdef PC98
|
|
|
|
int xiftype;
|
|
|
|
#endif
|
1999-04-18 14:42:20 +00:00
|
|
|
|
|
|
|
devclass_get_devices(sio_devclass, &devs, &count);
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
xdev = devs[i];
|
1999-11-18 12:22:09 +00:00
|
|
|
xioport = bus_get_resource_start(xdev, SYS_RES_IOPORT, 0);
|
|
|
|
xiftype = GET_IFTYPE(device_get_flags(xdev));
|
|
|
|
if (device_is_enabled(xdev) && xioport > 0) {
|
|
|
|
if (IS_8251(xiftype))
|
2000-05-12 12:38:25 +00:00
|
|
|
outb((xioport & 0xff00) | PC98SIO_cmd_port(xiftype & 0x0f), 0xf2);
|
|
|
|
else
|
2000-06-21 11:21:14 +00:00
|
|
|
outb(xioport + if_16550a_type[xiftype & 0x0f].iat[com_mcr], 0);
|
1999-09-12 13:44:54 +00:00
|
|
|
}
|
1999-04-18 14:42:20 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#else
|
1999-04-18 14:42:20 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
xdev = devs[i];
|
1999-12-07 09:29:15 +00:00
|
|
|
if (device_is_enabled(xdev) &&
|
|
|
|
bus_get_resource(xdev, SYS_RES_IOPORT, 0, &xioport,
|
|
|
|
NULL) == 0)
|
1999-11-18 12:22:09 +00:00
|
|
|
outb(xioport + com_mcr, 0);
|
1999-04-18 14:42:20 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1999-04-18 14:42:20 +00:00
|
|
|
free(devs, M_TEMP);
|
1996-06-14 10:04:54 +00:00
|
|
|
already_init = TRUE;
|
|
|
|
}
|
1999-11-18 12:22:09 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
if (COM_LLCONSOLE(flags)) {
|
|
|
|
printf("sio%d: reserved for low-level i/o\n",
|
|
|
|
device_get_unit(dev));
|
2000-01-29 04:47:22 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
1999-04-18 14:42:20 +00:00
|
|
|
return (ENXIO);
|
1998-01-16 11:20:22 +00:00
|
|
|
}
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
1998-01-22 03:52:55 +00:00
|
|
|
DELAY(10);
|
1999-01-03 05:03:47 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* If the port is i8251 UART (internal, B98_01)
|
|
|
|
*/
|
2000-04-22 15:12:52 +00:00
|
|
|
if (pc98_check_if_type(dev, &iod) == -1) {
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
2000-03-12 13:14:51 +00:00
|
|
|
return (ENXIO);
|
2000-04-22 15:12:52 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
if (iod.irq > 0)
|
1999-11-29 13:20:47 +00:00
|
|
|
bus_set_resource(dev, SYS_RES_IRQ, 0, iod.irq, 1);
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(iod.if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(iod.cmd, 0);
|
|
|
|
DELAY(10);
|
|
|
|
outb(iod.cmd, 0);
|
|
|
|
DELAY(10);
|
|
|
|
outb(iod.cmd, 0);
|
|
|
|
DELAY(10);
|
|
|
|
outb(iod.cmd, CMD8251_RESET);
|
|
|
|
DELAY(1000); /* for a while...*/
|
|
|
|
outb(iod.cmd, 0xf2); /* MODE (dummy) */
|
|
|
|
DELAY(10);
|
|
|
|
outb(iod.cmd, 0x01); /* CMD (dummy) */
|
|
|
|
DELAY(1000); /* for a while...*/
|
|
|
|
if (( inb(iod.sts) & STS8251_TxEMP ) == 0 ) {
|
2000-03-12 13:14:51 +00:00
|
|
|
result = (ENXIO);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
if (if_8251_type[iod.if_type & 0x0f].check_irq) {
|
|
|
|
COM_INT_DISABLE
|
|
|
|
tmp = ( inb( iod.ctrl ) & ~(IEN_Rx|IEN_TxEMP|IEN_Tx));
|
|
|
|
outb( iod.ctrl, tmp|IEN_TxEMP );
|
|
|
|
DELAY(10);
|
1999-04-19 16:10:40 +00:00
|
|
|
result = isa_irq_pending() ? 0 : ENXIO;
|
1999-01-03 05:03:47 +00:00
|
|
|
outb( iod.ctrl, tmp );
|
|
|
|
COM_INT_ENABLE
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* B98_01 doesn't activate TxEMP interrupt line
|
|
|
|
* when being reset, so we can't check irq pending.
|
|
|
|
*/
|
1999-04-19 16:10:40 +00:00
|
|
|
result = 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-09-12 13:44:54 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
if (result) {
|
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
|
|
|
}
|
1999-04-19 16:10:40 +00:00
|
|
|
return result;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#endif /* PC98 */
|
|
|
|
/*
|
|
|
|
* If the device is on a multiport card and has an AST/4
|
|
|
|
* compatible interrupt control register, initialize this
|
|
|
|
* register and prepare to leave MCR_IENABLE clear in the mcr.
|
|
|
|
* Otherwise, prepare to set MCR_IENABLE in the mcr.
|
|
|
|
* Point idev to the device struct giving the correct id_irq.
|
|
|
|
* This is the struct for the master device if there is one.
|
|
|
|
*/
|
|
|
|
idev = dev;
|
|
|
|
mcr_image = MCR_IENABLE;
|
|
|
|
#ifdef COM_MULTIPORT
|
2000-02-17 15:09:12 +00:00
|
|
|
if (COM_ISMULTIPORT(flags)) {
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifndef PC98
|
1999-12-07 09:29:15 +00:00
|
|
|
Port_t xiobase;
|
|
|
|
u_long io;
|
2000-05-12 12:38:25 +00:00
|
|
|
#endif
|
1999-12-07 09:29:15 +00:00
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
idev = devclass_get_device(sio_devclass, COM_MPMASTER(flags));
|
1996-06-14 10:04:54 +00:00
|
|
|
if (idev == NULL) {
|
|
|
|
printf("sio%d: master device %d not configured\n",
|
1999-04-18 14:42:20 +00:00
|
|
|
device_get_unit(dev), COM_MPMASTER(flags));
|
1998-06-05 08:31:01 +00:00
|
|
|
idev = dev;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#ifndef PC98
|
2000-02-17 15:09:12 +00:00
|
|
|
if (!COM_NOTAST4(flags)) {
|
|
|
|
if (bus_get_resource(idev, SYS_RES_IOPORT, 0, &io,
|
|
|
|
NULL) == 0) {
|
|
|
|
xiobase = io;
|
|
|
|
if (bus_get_resource(idev, SYS_RES_IRQ, 0,
|
|
|
|
NULL, NULL) == 0)
|
|
|
|
outb(xiobase + com_scr, 0x80);
|
|
|
|
else
|
|
|
|
outb(xiobase + com_scr, 0);
|
|
|
|
}
|
|
|
|
mcr_image = 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-11-29 13:20:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#endif /* COM_MULTIPORT */
|
1999-12-07 09:29:15 +00:00
|
|
|
if (bus_get_resource(idev, SYS_RES_IRQ, 0, NULL, NULL) != 0)
|
1996-06-14 10:04:54 +00:00
|
|
|
mcr_image = 0;
|
|
|
|
|
1999-11-18 12:22:09 +00:00
|
|
|
bzero(failures, sizeof failures);
|
|
|
|
iobase = rman_get_start(port);
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
1999-11-18 12:22:09 +00:00
|
|
|
if (iod.if_type == COM_IF_RSA98III) {
|
|
|
|
mcr_image = 0;
|
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
outb(iobase + rsa_msr, 0x04);
|
|
|
|
outb(iobase + rsa_frr, 0x00);
|
|
|
|
if ((inb(iobase + rsa_srr) & 0x36) != 0x36) {
|
2000-04-22 15:12:52 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
2000-04-22 15:12:52 +00:00
|
|
|
return (ENXIO);
|
|
|
|
}
|
2000-05-12 12:38:25 +00:00
|
|
|
outb(iobase + rsa_ier, 0x00);
|
|
|
|
outb(iobase + rsa_frr, 0x00);
|
|
|
|
outb(iobase + rsa_tivsr, 0x00);
|
|
|
|
outb(iobase + rsa_tcr, 0x00);
|
1999-11-18 12:22:09 +00:00
|
|
|
}
|
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
tmp = if_16550a_type[iod.if_type & 0x0f].irr_write;
|
|
|
|
if (tmp != -1) {
|
|
|
|
/* MC16550II */
|
2000-05-12 12:38:25 +00:00
|
|
|
int irqout;
|
1999-04-18 14:42:20 +00:00
|
|
|
switch (isa_get_irq(idev)) {
|
|
|
|
case 3: irqout = 4; break;
|
|
|
|
case 5: irqout = 5; break;
|
|
|
|
case 6: irqout = 6; break;
|
|
|
|
case 12: irqout = 7; break;
|
1999-01-03 05:03:47 +00:00
|
|
|
default:
|
1999-04-18 14:42:20 +00:00
|
|
|
printf("sio%d: irq configuration error\n",
|
|
|
|
device_get_unit(dev));
|
2000-04-22 15:12:52 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2001-11-26 12:29:53 +00:00
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
2000-04-22 15:12:52 +00:00
|
|
|
return (ENXIO);
|
1999-01-03 05:03:47 +00:00
|
|
|
}
|
2000-05-12 12:38:25 +00:00
|
|
|
outb((iobase & 0x00ff) | tmp, irqout);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't want to get actual interrupts, just masked ones.
|
|
|
|
* Interrupts from this line should already be masked in the ICU,
|
|
|
|
* but mask them in the processor as well in case there are some
|
|
|
|
* (misconfigured) shared interrupts.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
/* EXTRA DELAY? */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the speed and the word size and wait long enough to
|
|
|
|
* drain the maximum of 16 bytes of junk in device output queues.
|
|
|
|
* The speed is undefined after a master reset and must be set
|
|
|
|
* before relying on anything related to output. There may be
|
|
|
|
* junk after a (very fast) soft reboot and (apparently) after
|
|
|
|
* master reset.
|
|
|
|
* XXX what about the UART bug avoided by waiting in comparam()?
|
|
|
|
* We don't want to to wait long enough to drain at 2 bps.
|
|
|
|
*/
|
1997-04-05 15:04:32 +00:00
|
|
|
if (iobase == siocniobase)
|
|
|
|
DELAY((16 + 1) * 1000000 / (comdefaultrate / 10));
|
|
|
|
else {
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_cfcr, CFCR_DLAB | CFCR_8BITS);
|
2002-01-31 08:26:45 +00:00
|
|
|
divisor = siodivisor(rclk, SIO_TEST_SPEED);
|
|
|
|
sio_setreg(com, com_dlbl, divisor & 0xff);
|
|
|
|
sio_setreg(com, com_dlbh, divisor >> 8);
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_cfcr, CFCR_8BITS);
|
1997-06-04 10:27:53 +00:00
|
|
|
DELAY((16 + 1) * 1000000 / (SIO_TEST_SPEED / 10));
|
1997-04-05 15:04:32 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
2007-10-12 06:03:46 +00:00
|
|
|
* Enable the interrupt gate and disable device interrupts. This
|
1996-06-14 10:04:54 +00:00
|
|
|
* should leave the device driving the interrupt line low and
|
|
|
|
* guarantee an edge trigger if an interrupt can be generated.
|
|
|
|
*/
|
|
|
|
/* EXTRA DELAY? */
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_mcr, mcr_image);
|
|
|
|
sio_setreg(com, com_ier, 0);
|
1998-06-01 12:40:24 +00:00
|
|
|
DELAY(1000); /* XXX */
|
|
|
|
irqmap[0] = isa_irq_pending();
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to set loopback mode so that we can send a null byte
|
|
|
|
* without annoying any external device.
|
|
|
|
*/
|
|
|
|
/* EXTRA DELAY? */
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_mcr, mcr_image | MCR_LOOPBACK);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to generate an output interrupt. On 8250's, setting
|
|
|
|
* IER_ETXRDY generates an interrupt independent of the current
|
|
|
|
* setting and independent of whether the THR is empty. On 16450's,
|
|
|
|
* setting IER_ETXRDY generates an interrupt independent of the
|
|
|
|
* current setting. On 16550A's, setting IER_ETXRDY only
|
|
|
|
* generates an interrupt when IER_ETXRDY is not already set.
|
|
|
|
*/
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_ier, IER_ETXRDY);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
if (iod.if_type == COM_IF_RSA98III)
|
2000-05-12 12:38:25 +00:00
|
|
|
outb(iobase + rsa_ier, 0x04);
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* On some 16x50 incompatibles, setting IER_ETXRDY doesn't generate
|
|
|
|
* an interrupt. They'd better generate one for actually doing
|
|
|
|
* output. Loopback may be broken on the same incompatibles but
|
|
|
|
* it's unlikely to do more than allow the null byte out.
|
|
|
|
*/
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_data, 0);
|
2003-10-05 11:55:14 +00:00
|
|
|
if (iobase == siocniobase)
|
|
|
|
DELAY((1 + 2) * 1000000 / (comdefaultrate / 10));
|
|
|
|
else
|
|
|
|
DELAY((1 + 2) * 1000000 / (SIO_TEST_SPEED / 10));
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Turn off loopback mode so that the interrupt gate works again
|
|
|
|
* (MCR_IENABLE was hidden). This should leave the device driving
|
|
|
|
* an interrupt line high. It doesn't matter if the interrupt
|
|
|
|
* line oscillates while we are not looking at it, since interrupts
|
|
|
|
* are disabled.
|
|
|
|
*/
|
|
|
|
/* EXTRA DELAY? */
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_mcr, mcr_image);
|
2002-03-25 13:41:06 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It seems my Xircom CBEM56G Cardbus modem wants to be reset
|
|
|
|
* to 8 bits *again*, or else probe test 0 will fail.
|
|
|
|
* gwk@sgi.com, 4/19/2001
|
|
|
|
*/
|
|
|
|
sio_setreg(com, com_cfcr, CFCR_8BITS);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
/*
|
2003-10-05 11:55:14 +00:00
|
|
|
* Some PCMCIA cards (Palido 321s, DC-1S, ...) have the "TXRDY bug",
|
|
|
|
* so we probe for a buggy IIR_TXRDY implementation even in the
|
|
|
|
* noprobe case. We don't probe for it in the !noprobe case because
|
|
|
|
* noprobe is always set for PCMCIA cards and the problem is not
|
|
|
|
* known to affect any other cards.
|
1998-01-08 10:50:06 +00:00
|
|
|
*/
|
2001-11-26 12:29:53 +00:00
|
|
|
if (noprobe) {
|
2003-10-05 11:55:14 +00:00
|
|
|
/* Read IIR a few times. */
|
1999-11-18 12:22:09 +00:00
|
|
|
for (fn = 0; fn < 2; fn ++) {
|
|
|
|
DELAY(10000);
|
2000-05-12 12:38:25 +00:00
|
|
|
failures[6] = sio_getreg(com, com_iir);
|
1999-11-18 12:22:09 +00:00
|
|
|
}
|
2003-10-05 11:55:14 +00:00
|
|
|
|
|
|
|
/* IIR_TXRDY should be clear. Is it? */
|
1999-11-18 12:22:09 +00:00
|
|
|
result = 0;
|
|
|
|
if (failures[6] & IIR_TXRDY) {
|
2003-10-05 11:55:14 +00:00
|
|
|
/*
|
|
|
|
* No. We seem to have the bug. Does our fix for
|
|
|
|
* it work?
|
|
|
|
*/
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_ier, 0);
|
|
|
|
if (sio_getreg(com, com_iir) & IIR_NOPEND) {
|
2003-10-05 11:55:14 +00:00
|
|
|
/* Yes. We discovered the TXRDY bug! */
|
1999-11-18 12:22:09 +00:00
|
|
|
SET_FLAG(dev, COM_C_IIR_TXRDYBUG);
|
|
|
|
} else {
|
2003-10-05 11:55:14 +00:00
|
|
|
/* No. Just fail. XXX */
|
1999-11-18 12:22:09 +00:00
|
|
|
result = ENXIO;
|
2001-09-16 05:33:07 +00:00
|
|
|
sio_setreg(com, com_mcr, 0);
|
1999-11-18 12:22:09 +00:00
|
|
|
}
|
1998-01-08 10:50:06 +00:00
|
|
|
} else {
|
2003-10-05 11:55:14 +00:00
|
|
|
/* Yes. No bug. */
|
1999-11-18 12:22:09 +00:00
|
|
|
CLR_FLAG(dev, COM_C_IIR_TXRDYBUG);
|
1998-01-08 10:50:06 +00:00
|
|
|
}
|
2001-09-16 05:33:07 +00:00
|
|
|
sio_setreg(com, com_ier, 0);
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_cfcr, CFCR_8BITS);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1999-11-18 12:22:09 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2004-05-06 13:16:45 +00:00
|
|
|
if (iobase == siocniobase)
|
2001-11-26 12:29:53 +00:00
|
|
|
result = 0;
|
|
|
|
if (result != 0) {
|
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
|
|
|
}
|
|
|
|
return (result);
|
1999-11-18 12:22:09 +00:00
|
|
|
}
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* Check that
|
|
|
|
* o the CFCR, IER and MCR in UART hold the values written to them
|
|
|
|
* (the values happen to be all distinct - this is good for
|
|
|
|
* avoiding false positive tests from bus echoes).
|
|
|
|
* o an output interrupt is generated and its vector is correct.
|
|
|
|
* o the interrupt goes away when the IIR in the UART is read.
|
|
|
|
*/
|
|
|
|
/* EXTRA DELAY? */
|
2000-05-12 12:38:25 +00:00
|
|
|
failures[0] = sio_getreg(com, com_cfcr) - CFCR_8BITS;
|
|
|
|
failures[1] = sio_getreg(com, com_ier) - IER_ETXRDY;
|
|
|
|
failures[2] = sio_getreg(com, com_mcr) - mcr_image;
|
1996-07-23 07:46:59 +00:00
|
|
|
DELAY(10000); /* Some internal modems need this time */
|
1998-06-01 12:40:24 +00:00
|
|
|
irqmap[1] = isa_irq_pending();
|
2000-05-12 12:38:25 +00:00
|
|
|
failures[4] = (sio_getreg(com, com_iir) & IIR_IMASK) - IIR_TXRDY;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
if (iod.if_type == COM_IF_RSA98III)
|
2000-05-12 12:38:25 +00:00
|
|
|
inb(iobase + rsa_srr);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
DELAY(1000); /* XXX */
|
1998-06-01 12:40:24 +00:00
|
|
|
irqmap[2] = isa_irq_pending();
|
2000-05-12 12:38:25 +00:00
|
|
|
failures[6] = (sio_getreg(com, com_iir) & IIR_IMASK) - IIR_NOPEND;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
if (iod.if_type == COM_IF_RSA98III)
|
2000-05-12 12:38:25 +00:00
|
|
|
inb(iobase + rsa_srr);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Turn off all device interrupts and check that they go off properly.
|
|
|
|
* Leave MCR_IENABLE alone. For ports without a master port, it gates
|
|
|
|
* the OUT2 output of the UART to
|
|
|
|
* the ICU input. Closing the gate would give a floating ICU input
|
1999-04-19 11:11:01 +00:00
|
|
|
* (unless there is another device driving it) and spurious interrupts.
|
1996-06-14 10:04:54 +00:00
|
|
|
* (On the system that this was first tested on, the input floats high
|
|
|
|
* and gives a (masked) interrupt as soon as the gate is closed.)
|
|
|
|
*/
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_ier, 0);
|
|
|
|
sio_setreg(com, com_cfcr, CFCR_8BITS); /* dummy to avoid bus echo */
|
|
|
|
failures[7] = sio_getreg(com, com_ier);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
if (iod.if_type == COM_IF_RSA98III)
|
2000-05-12 12:38:25 +00:00
|
|
|
outb(iobase + rsa_ier, 0x00);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
DELAY(1000); /* XXX */
|
1998-06-01 12:40:24 +00:00
|
|
|
irqmap[3] = isa_irq_pending();
|
2000-05-12 12:38:25 +00:00
|
|
|
failures[9] = (sio_getreg(com, com_iir) & IIR_IMASK) - IIR_NOPEND;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (iod.if_type == COM_IF_RSA98III) {
|
2000-05-12 12:38:25 +00:00
|
|
|
inb(iobase + rsa_srr);
|
|
|
|
outb(iobase + rsa_frr, 0x00);
|
1999-01-03 05:03:47 +00:00
|
|
|
}
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1998-06-05 08:31:01 +00:00
|
|
|
irqs = irqmap[1] & ~irqmap[0];
|
1999-12-07 09:29:15 +00:00
|
|
|
if (bus_get_resource(idev, SYS_RES_IRQ, 0, &xirq, NULL) == 0 &&
|
2002-01-18 03:30:22 +00:00
|
|
|
((1 << xirq) & irqs) == 0) {
|
1998-06-01 12:40:24 +00:00
|
|
|
printf(
|
1999-12-07 09:29:15 +00:00
|
|
|
"sio%d: configured irq %ld not in bitmap of probed irqs %#x\n",
|
1999-11-18 12:22:09 +00:00
|
|
|
device_get_unit(dev), xirq, irqs);
|
2002-01-18 03:30:22 +00:00
|
|
|
printf(
|
|
|
|
"sio%d: port may not be enabled\n",
|
|
|
|
device_get_unit(dev));
|
|
|
|
}
|
1998-06-01 12:40:24 +00:00
|
|
|
if (bootverbose)
|
1998-06-05 08:31:01 +00:00
|
|
|
printf("sio%d: irq maps: %#x %#x %#x %#x\n",
|
1999-04-18 14:42:20 +00:00
|
|
|
device_get_unit(dev),
|
|
|
|
irqmap[0], irqmap[1], irqmap[2], irqmap[3]);
|
1998-06-01 12:40:24 +00:00
|
|
|
|
2004-05-06 13:16:45 +00:00
|
|
|
result = 0;
|
|
|
|
for (fn = 0; fn < sizeof failures; ++fn)
|
1996-06-14 10:04:54 +00:00
|
|
|
if (failures[fn]) {
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_mcr, 0);
|
1999-04-18 14:42:20 +00:00
|
|
|
result = ENXIO;
|
1998-06-01 12:40:24 +00:00
|
|
|
if (bootverbose) {
|
|
|
|
printf("sio%d: probe failed test(s):",
|
1999-04-18 14:42:20 +00:00
|
|
|
device_get_unit(dev));
|
1998-06-01 12:40:24 +00:00
|
|
|
for (fn = 0; fn < sizeof failures; ++fn)
|
|
|
|
if (failures[fn])
|
|
|
|
printf(" %d", fn);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
break;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-09-12 13:44:54 +00:00
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2004-05-06 13:16:45 +00:00
|
|
|
if (iobase == siocniobase)
|
2001-11-26 12:29:53 +00:00
|
|
|
result = 0;
|
|
|
|
if (result != 0) {
|
|
|
|
device_set_softc(dev, NULL);
|
|
|
|
free(com, M_DEVBUF);
|
|
|
|
}
|
|
|
|
return (result);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef COM_ESP
|
|
|
|
static int
|
1999-05-10 09:14:40 +00:00
|
|
|
espattach(com, esp_port)
|
1996-06-14 10:04:54 +00:00
|
|
|
struct com_s *com;
|
|
|
|
Port_t esp_port;
|
|
|
|
{
|
|
|
|
u_char dips;
|
|
|
|
u_char val;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the ESP-specific I/O port to see if we're an ESP
|
|
|
|
* card. If not, return failure immediately.
|
|
|
|
*/
|
|
|
|
if ((inb(esp_port) & 0xf3) == 0) {
|
|
|
|
printf(" port 0x%x is not an ESP board?\n", esp_port);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've got something that claims to be a Hayes ESP card.
|
|
|
|
* Let's hope so.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Get the dip-switch configuration */
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(esp_port + ESP98_CMD1, ESP_GETDIPS);
|
|
|
|
dips = inb(esp_port + ESP98_STATUS1);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(esp_port + ESP_CMD1, ESP_GETDIPS);
|
|
|
|
dips = inb(esp_port + ESP_STATUS1);
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Bits 0,1 of dips say which COM port we are.
|
|
|
|
*/
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
if ((rman_get_start(com->ioportres) & 0xff) ==
|
|
|
|
likely_com_ports[dips & 0x03])
|
1999-01-03 05:03:47 +00:00
|
|
|
#else
|
2000-05-12 12:38:25 +00:00
|
|
|
if (rman_get_start(com->ioportres) == likely_com_ports[dips & 0x03])
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
printf(" : ESP");
|
|
|
|
else {
|
|
|
|
printf(" esp_port has com %d\n", dips & 0x03);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for ESP version 2.0 or later: bits 4,5,6 = 010.
|
|
|
|
*/
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(esp_port + ESP98_CMD1, ESP_GETTEST);
|
|
|
|
val = inb(esp_port + ESP98_STATUS1); /* clear reg 1 */
|
|
|
|
val = inb(esp_port + ESP98_STATUS2);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(esp_port + ESP_CMD1, ESP_GETTEST);
|
|
|
|
val = inb(esp_port + ESP_STATUS1); /* clear reg 1 */
|
|
|
|
val = inb(esp_port + ESP_STATUS2);
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if ((val & 0x70) < 0x20) {
|
|
|
|
printf("-old (%o)", val & 0x70);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for ability to emulate 16550: bit 7 == 1
|
|
|
|
*/
|
|
|
|
if ((dips & 0x80) == 0) {
|
|
|
|
printf(" slave");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Okay, we seem to be a Hayes ESP card. Whee.
|
|
|
|
*/
|
|
|
|
com->esp = TRUE;
|
|
|
|
com->esp_port = esp_port;
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
#endif /* COM_ESP */
|
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
int
|
2002-01-31 08:26:45 +00:00
|
|
|
sioattach(dev, xrid, rclk)
|
1999-04-18 14:42:20 +00:00
|
|
|
device_t dev;
|
2000-04-01 11:27:31 +00:00
|
|
|
int xrid;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_long rclk;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
#ifdef COM_ESP
|
|
|
|
Port_t *espp;
|
|
|
|
#endif
|
|
|
|
Port_t iobase;
|
|
|
|
int unit;
|
1999-11-18 12:22:09 +00:00
|
|
|
u_int flags;
|
1999-09-12 13:44:54 +00:00
|
|
|
int rid;
|
|
|
|
struct resource *port;
|
1999-11-18 12:22:09 +00:00
|
|
|
int ret;
|
2004-10-15 08:22:37 +00:00
|
|
|
int error;
|
2004-09-17 10:59:17 +00:00
|
|
|
struct tty *tp;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-04-18 14:42:20 +00:00
|
|
|
u_char *obuf;
|
1999-02-05 11:37:40 +00:00
|
|
|
u_long obufsize;
|
2000-05-12 12:38:25 +00:00
|
|
|
int if_type = GET_IFTYPE(device_get_flags(dev));
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2000-04-01 11:27:31 +00:00
|
|
|
rid = xrid;
|
1999-09-12 13:44:54 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
if (IS_8251(if_type)) {
|
2004-03-17 17:50:55 +00:00
|
|
|
port = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
|
|
|
|
RF_ACTIVE);
|
2001-02-25 08:55:07 +00:00
|
|
|
} else if (if_type == COM_IF_MODEM_CARD ||
|
|
|
|
if_type == COM_IF_RSA98III ||
|
2000-06-21 11:21:14 +00:00
|
|
|
isa_get_vendorid(dev)) {
|
|
|
|
port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[if_type & 0x0f].iatsz, RF_ACTIVE);
|
2000-05-12 12:38:25 +00:00
|
|
|
} else {
|
|
|
|
port = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[if_type & 0x0f].iat,
|
|
|
|
if_16550a_type[if_type & 0x0f].iatsz, RF_ACTIVE);
|
2000-05-12 12:38:25 +00:00
|
|
|
}
|
1999-09-12 13:44:54 +00:00
|
|
|
#else
|
|
|
|
port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
|
|
|
|
0, ~0, IO_COMSIZE, RF_ACTIVE);
|
|
|
|
#endif
|
|
|
|
if (!port)
|
2000-03-12 13:14:51 +00:00
|
|
|
return (ENXIO);
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(if_type)) {
|
|
|
|
if (isa_load_resourcev(port,
|
2001-01-27 13:02:06 +00:00
|
|
|
if_16550a_type[if_type & 0x0f].iat,
|
|
|
|
if_16550a_type[if_type & 0x0f].iatsz) != 0) {
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
|
|
|
return ENXIO;
|
2000-05-12 12:38:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
1999-09-12 13:44:54 +00:00
|
|
|
|
|
|
|
iobase = rman_get_start(port);
|
1999-04-18 14:42:20 +00:00
|
|
|
unit = device_get_unit(dev);
|
|
|
|
com = device_get_softc(dev);
|
1999-11-18 12:22:09 +00:00
|
|
|
flags = device_get_flags(dev);
|
|
|
|
|
|
|
|
if (unit >= sio_numunits)
|
|
|
|
sio_numunits = unit + 1;
|
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
#ifdef PC98
|
1999-02-05 11:37:40 +00:00
|
|
|
obufsize = 256;
|
2000-05-12 12:38:25 +00:00
|
|
|
if (if_type == COM_IF_RSA98III)
|
1999-02-05 11:37:40 +00:00
|
|
|
obufsize = 2048;
|
2000-04-22 15:12:52 +00:00
|
|
|
if ((obuf = malloc(obufsize * 2, M_DEVBUF, M_NOWAIT)) == NULL) {
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
2000-01-24 08:20:54 +00:00
|
|
|
return ENXIO;
|
2000-04-22 15:12:52 +00:00
|
|
|
}
|
1999-04-18 14:42:20 +00:00
|
|
|
bzero(obuf, obufsize * 2);
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* sioprobe() has initialized the device registers as follows:
|
|
|
|
* o cfcr = CFCR_8BITS.
|
|
|
|
* It is most important that CFCR_DLAB is off, so that the
|
|
|
|
* data port is not hidden when we enable interrupts.
|
|
|
|
* o ier = 0.
|
|
|
|
* Interrupts are only enabled when the line is open.
|
|
|
|
* o mcr = MCR_IENABLE, or 0 if the port has AST/4 compatible
|
|
|
|
* interrupt control register or the config specifies no irq.
|
|
|
|
* Keeping MCR_DTR and MCR_RTS off might stop the external
|
|
|
|
* device from sending before we are ready.
|
|
|
|
*/
|
|
|
|
bzero(com, sizeof *com);
|
|
|
|
com->unit = unit;
|
1999-09-12 13:44:54 +00:00
|
|
|
com->ioportres = port;
|
2003-08-02 09:41:31 +00:00
|
|
|
com->ioportrid = rid;
|
2000-05-12 12:38:25 +00:00
|
|
|
com->bst = rman_get_bustag(port);
|
|
|
|
com->bsh = rman_get_bushandle(port);
|
1996-06-14 10:04:54 +00:00
|
|
|
com->cfcr_image = CFCR_8BITS;
|
1999-04-18 14:42:20 +00:00
|
|
|
com->loses_outints = COM_LOSESOUTINTS(flags) != 0;
|
2000-02-17 15:09:12 +00:00
|
|
|
com->no_irq = bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
com->tx_fifo_size = 1;
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
|
|
|
com->obufsize = obufsize;
|
|
|
|
com->obuf1 = obuf;
|
|
|
|
com->obuf2 = obuf + obufsize;
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
com->obufs[0].l_head = com->obuf1;
|
|
|
|
com->obufs[1].l_head = com->obuf2;
|
|
|
|
|
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
com->pc98_if_type = if_type;
|
|
|
|
|
|
|
|
if (IS_8251(if_type)) {
|
|
|
|
pc98_set_ioport(com);
|
1999-12-06 00:23:38 +00:00
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
if (if_type == COM_IF_INTERNAL && pc98_check_8251fifo()) {
|
|
|
|
com->pc98_8251fifo = 1;
|
|
|
|
com->pc98_8251fifo_enable = 0;
|
|
|
|
}
|
|
|
|
} else {
|
2000-06-21 11:21:14 +00:00
|
|
|
bus_addr_t *iat = if_16550a_type[if_type & 0x0f].iat;
|
1999-12-06 00:23:38 +00:00
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
com->data_port = iobase + iat[com_data];
|
2003-10-05 11:55:14 +00:00
|
|
|
com->int_ctl_port = iobase + iat[com_ier];
|
2000-05-12 12:38:25 +00:00
|
|
|
com->int_id_port = iobase + iat[com_iir];
|
|
|
|
com->modem_ctl_port = iobase + iat[com_mcr];
|
1999-01-03 05:03:47 +00:00
|
|
|
com->mcr_image = inb(com->modem_ctl_port);
|
2000-05-12 12:38:25 +00:00
|
|
|
com->line_status_port = iobase + iat[com_lsr];
|
|
|
|
com->modem_status_port = iobase + iat[com_msr];
|
1999-12-06 00:23:38 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#else /* not PC98 */
|
|
|
|
com->data_port = iobase + com_data;
|
2003-10-05 11:55:14 +00:00
|
|
|
com->int_ctl_port = iobase + com_ier;
|
1996-06-14 10:04:54 +00:00
|
|
|
com->int_id_port = iobase + com_iir;
|
|
|
|
com->modem_ctl_port = iobase + com_mcr;
|
|
|
|
com->mcr_image = inb(com->modem_ctl_port);
|
|
|
|
com->line_status_port = iobase + com_lsr;
|
|
|
|
com->modem_status_port = iobase + com_msr;
|
|
|
|
#endif
|
2004-10-15 08:22:37 +00:00
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
tp = com->tp = ttyalloc();
|
|
|
|
tp->t_oproc = comstart;
|
|
|
|
tp->t_param = comparam;
|
|
|
|
tp->t_stop = comstop;
|
|
|
|
tp->t_modem = commodem;
|
|
|
|
tp->t_break = combreak;
|
2004-10-15 08:22:37 +00:00
|
|
|
tp->t_close = comclose;
|
|
|
|
tp->t_open = comopen;
|
2004-09-17 10:59:17 +00:00
|
|
|
tp->t_sc = com;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(if_type) && rclk == 0)
|
|
|
|
rclk = if_16550a_type[if_type & 0x0f].rclk;
|
|
|
|
#else
|
|
|
|
if (rclk == 0)
|
|
|
|
rclk = DEFAULT_RCLK;
|
|
|
|
#endif
|
|
|
|
com->rclk = rclk;
|
|
|
|
|
2004-10-15 08:22:37 +00:00
|
|
|
if (unit == comconsole)
|
|
|
|
ttyconsolemode(tp, comdefaultrate);
|
|
|
|
error = siosetwater(com, tp->t_init_in.c_ispeed);
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
|
|
|
if (error) {
|
2000-01-29 04:47:22 +00:00
|
|
|
/*
|
|
|
|
* Leave i/o resources allocated if this is a `cn'-level
|
|
|
|
* console, so that other devices can't snarf them.
|
|
|
|
*/
|
|
|
|
if (iobase != siocniobase)
|
|
|
|
bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
|
|
|
|
return (ENOMEM);
|
1999-02-05 11:37:40 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/* attempt to determine UART type */
|
|
|
|
printf("sio%d: type", unit);
|
|
|
|
|
|
|
|
#ifndef PC98
|
2002-09-29 11:41:48 +00:00
|
|
|
if (!COM_ISMULTIPORT(flags) &&
|
|
|
|
!COM_IIR_TXRDYBUG(flags) && !COM_NOSCR(flags)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char scr;
|
|
|
|
u_char scr1;
|
|
|
|
u_char scr2;
|
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
scr = sio_getreg(com, com_scr);
|
|
|
|
sio_setreg(com, com_scr, 0xa5);
|
|
|
|
scr1 = sio_getreg(com, com_scr);
|
|
|
|
sio_setreg(com, com_scr, 0x5a);
|
|
|
|
scr2 = sio_getreg(com, com_scr);
|
|
|
|
sio_setreg(com, com_scr, scr);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (scr1 != 0xa5 || scr2 != 0x5a) {
|
2002-01-18 03:30:22 +00:00
|
|
|
printf(" 8250 or not responding");
|
1996-06-14 10:04:54 +00:00
|
|
|
goto determined_type;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* !PC98 */
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo && !COM_NOFIFO(flags))
|
|
|
|
com->tx_fifo_size = 16;
|
1999-01-03 05:03:47 +00:00
|
|
|
com_int_TxRx_disable( com );
|
2004-09-17 10:59:17 +00:00
|
|
|
com_cflag_and_speed_set( com, tp->t_init_in.c_cflag, comdefaultrate );
|
1999-01-03 05:03:47 +00:00
|
|
|
com_tiocm_bic( com, TIOCM_DTR|TIOCM_RTS|TIOCM_LE );
|
|
|
|
com_send_break_off( com );
|
1999-12-06 00:23:38 +00:00
|
|
|
|
|
|
|
if (com->pc98_if_type == COM_IF_INTERNAL) {
|
|
|
|
printf(" (internal%s%s)",
|
|
|
|
com->pc98_8251fifo ? " fifo" : "",
|
|
|
|
PC98SIO_baud_rate_port(com->pc98_if_type) != -1 ?
|
|
|
|
" v-fast" : "");
|
|
|
|
} else {
|
|
|
|
printf(" 8251%s", if_8251_type[com->pc98_if_type & 0x0f].name);
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
} else {
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif /* PC98 */
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo, FIFO_ENABLE | FIFO_RX_HIGH);
|
1996-06-14 10:04:54 +00:00
|
|
|
DELAY(100);
|
|
|
|
switch (inb(com->int_id_port) & IIR_FIFO_MASK) {
|
|
|
|
case FIFO_RX_LOW:
|
|
|
|
printf(" 16450");
|
|
|
|
break;
|
|
|
|
case FIFO_RX_MEDL:
|
|
|
|
printf(" 16450?");
|
|
|
|
break;
|
|
|
|
case FIFO_RX_MEDH:
|
|
|
|
printf(" 16550?");
|
|
|
|
break;
|
|
|
|
case FIFO_RX_HIGH:
|
1999-04-18 14:42:20 +00:00
|
|
|
if (COM_NOFIFO(flags)) {
|
1997-05-19 12:39:42 +00:00
|
|
|
printf(" 16550A fifo disabled");
|
2003-10-05 11:55:14 +00:00
|
|
|
break;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2003-10-05 11:55:14 +00:00
|
|
|
com->hasfifo = TRUE;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III) {
|
|
|
|
com->tx_fifo_size = 2048;
|
2000-05-12 12:38:25 +00:00
|
|
|
com->rsabase = iobase;
|
1999-01-03 05:03:47 +00:00
|
|
|
outb(com->rsabase + rsa_ier, 0x00);
|
|
|
|
outb(com->rsabase + rsa_frr, 0x00);
|
|
|
|
}
|
2003-10-05 11:55:14 +00:00
|
|
|
#else
|
|
|
|
if (COM_ST16650A(flags)) {
|
|
|
|
printf(" ST16650A");
|
|
|
|
com->st16650a = TRUE;
|
|
|
|
com->tx_fifo_size = 32;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (COM_TI16754(flags)) {
|
|
|
|
printf(" TI16754");
|
|
|
|
com->tx_fifo_size = 64;
|
|
|
|
break;
|
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
2003-10-05 11:55:14 +00:00
|
|
|
printf(" 16550A");
|
1997-06-02 10:51:34 +00:00
|
|
|
#ifdef COM_ESP
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_ESP98)
|
|
|
|
#endif
|
1997-06-02 10:51:34 +00:00
|
|
|
for (espp = likely_esp_ports; *espp != 0; espp++)
|
1999-05-10 09:14:40 +00:00
|
|
|
if (espattach(com, *espp)) {
|
1997-06-02 10:51:34 +00:00
|
|
|
com->tx_fifo_size = 1024;
|
|
|
|
break;
|
|
|
|
}
|
2003-12-26 03:06:11 +00:00
|
|
|
if (com->esp)
|
2003-10-05 11:55:14 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef PC98
|
|
|
|
com->tx_fifo_size = 16;
|
|
|
|
#else
|
|
|
|
com->tx_fifo_size = COM_FIFOSIZE(flags);
|
|
|
|
if (com->tx_fifo_size == 0)
|
|
|
|
com->tx_fifo_size = 16;
|
|
|
|
else
|
|
|
|
printf(" lookalike with %u bytes FIFO",
|
|
|
|
com->tx_fifo_size);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
}
|
1997-06-02 10:51:34 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSB3000) {
|
|
|
|
/* Set RSB-2000/3000 Extended Buffer mode. */
|
|
|
|
u_char lcr;
|
2000-05-12 12:38:25 +00:00
|
|
|
lcr = sio_getreg(com, com_cfcr);
|
|
|
|
sio_setreg(com, com_cfcr, lcr | CFCR_DLAB);
|
|
|
|
sio_setreg(com, com_emr, EMR_EXBUFF | EMR_EFMODE);
|
|
|
|
sio_setreg(com, com_cfcr, lcr);
|
1999-01-03 05:03:47 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef COM_ESP
|
2003-12-26 03:06:11 +00:00
|
|
|
if (com->esp) {
|
1997-01-30 10:48:06 +00:00
|
|
|
/*
|
|
|
|
* Set 16550 compatibility mode.
|
|
|
|
* We don't use the ESP_MODE_SCALE bit to increase the
|
|
|
|
* fifo trigger levels because we can't handle large
|
|
|
|
* bursts of input.
|
|
|
|
* XXX flow control should be set in comparam(), not here.
|
|
|
|
*/
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(com->esp_port + ESP98_CMD1, ESP_SETMODE);
|
|
|
|
outb(com->esp_port + ESP98_CMD2, ESP_MODE_RTS | ESP_MODE_FIFO);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->esp_port + ESP_CMD1, ESP_SETMODE);
|
1997-01-30 10:48:06 +00:00
|
|
|
outb(com->esp_port + ESP_CMD2, ESP_MODE_RTS | ESP_MODE_FIFO);
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/* Set RTS/CTS flow control. */
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(com->esp_port + ESP98_CMD1, ESP_SETFLOWTYPE);
|
|
|
|
outb(com->esp_port + ESP98_CMD2, ESP_FLOW_RTS);
|
|
|
|
outb(com->esp_port + ESP98_CMD2, ESP_FLOW_CTS);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->esp_port + ESP_CMD1, ESP_SETFLOWTYPE);
|
|
|
|
outb(com->esp_port + ESP_CMD2, ESP_FLOW_RTS);
|
|
|
|
outb(com->esp_port + ESP_CMD2, ESP_FLOW_CTS);
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/* Set flow-control levels. */
|
1999-01-03 15:57:02 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(com->esp_port + ESP98_CMD1, ESP_SETRXFLOW);
|
|
|
|
outb(com->esp_port + ESP98_CMD2, HIBYTE(768));
|
|
|
|
outb(com->esp_port + ESP98_CMD2, LOBYTE(768));
|
|
|
|
outb(com->esp_port + ESP98_CMD2, HIBYTE(512));
|
|
|
|
outb(com->esp_port + ESP98_CMD2, LOBYTE(512));
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->esp_port + ESP_CMD1, ESP_SETRXFLOW);
|
|
|
|
outb(com->esp_port + ESP_CMD2, HIBYTE(768));
|
|
|
|
outb(com->esp_port + ESP_CMD2, LOBYTE(768));
|
|
|
|
outb(com->esp_port + ESP_CMD2, HIBYTE(512));
|
|
|
|
outb(com->esp_port + ESP_CMD2, LOBYTE(512));
|
1999-01-03 15:57:02 +00:00
|
|
|
#endif
|
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
/* Set UART clock prescaler. */
|
1999-01-03 15:57:02 +00:00
|
|
|
outb(com->esp_port + ESP98_CMD1, ESP_SETCLOCK);
|
|
|
|
outb(com->esp_port + ESP98_CMD2, 2); /* 4 times */
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#endif /* COM_ESP */
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo, 0);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
printf("%s", if_16550a_type[com->pc98_if_type & 0x0f].name);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
determined_type: ;
|
1999-01-28 11:24:36 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#ifdef COM_MULTIPORT
|
1999-04-18 14:42:20 +00:00
|
|
|
if (COM_ISMULTIPORT(flags)) {
|
1999-11-18 12:22:09 +00:00
|
|
|
device_t masterdev;
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
com->multiport = TRUE;
|
|
|
|
printf(" (multiport");
|
1999-04-18 14:42:20 +00:00
|
|
|
if (unit == COM_MPMASTER(flags))
|
1996-06-14 10:04:54 +00:00
|
|
|
printf(" master");
|
|
|
|
printf(")");
|
2000-02-17 15:09:12 +00:00
|
|
|
masterdev = devclass_get_device(sio_devclass,
|
|
|
|
COM_MPMASTER(flags));
|
|
|
|
com->no_irq = (masterdev == NULL || bus_get_resource(masterdev,
|
|
|
|
SYS_RES_IRQ, 0, NULL, NULL) != 0);
|
1999-02-05 11:37:40 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* COM_MULTIPORT */
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
1997-06-04 10:27:53 +00:00
|
|
|
if (unit == comconsole)
|
|
|
|
printf(", console");
|
1999-11-18 12:22:09 +00:00
|
|
|
if (COM_IIR_TXRDYBUG(flags))
|
2003-10-05 11:55:14 +00:00
|
|
|
printf(" with a buggy IIR_TXRDY implementation");
|
1996-06-14 10:04:54 +00:00
|
|
|
printf("\n");
|
|
|
|
|
2000-10-25 05:19:40 +00:00
|
|
|
if (sio_fast_ih == NULL) {
|
2005-10-26 06:44:59 +00:00
|
|
|
swi_add(&tty_intr_event, "sio", siopoll, NULL, SWI_TTY, 0,
|
2001-02-13 09:55:20 +00:00
|
|
|
&sio_fast_ih);
|
2005-10-26 06:44:59 +00:00
|
|
|
swi_add(&clk_intr_event, "sio", siopoll, NULL, SWI_CLOCK, 0,
|
2001-02-13 09:55:20 +00:00
|
|
|
&sio_slow_ih);
|
1998-08-28 12:44:49 +00:00
|
|
|
}
|
2004-10-15 08:22:37 +00:00
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
com->flags = flags;
|
1999-04-01 13:44:15 +00:00
|
|
|
com->pps.ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
|
2004-10-15 08:22:37 +00:00
|
|
|
tp->t_pps = &com->pps;
|
2003-03-09 10:15:11 +00:00
|
|
|
|
|
|
|
if (COM_PPSCTS(flags))
|
|
|
|
com->pps_bit = MSR_CTS;
|
|
|
|
else
|
|
|
|
com->pps_bit = MSR_DCD;
|
1999-04-01 13:44:15 +00:00
|
|
|
pps_init(&com->pps);
|
1999-04-18 14:42:20 +00:00
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
rid = 0;
|
2004-09-20 14:01:38 +00:00
|
|
|
com->irqres = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE);
|
1999-11-18 12:22:09 +00:00
|
|
|
if (com->irqres) {
|
2006-02-22 18:16:26 +00:00
|
|
|
ret = bus_setup_intr(dev, com->irqres,
|
2007-02-23 12:19:07 +00:00
|
|
|
INTR_TYPE_TTY,
|
|
|
|
siointr, NULL, com, &com->cookie);
|
1999-12-07 09:29:15 +00:00
|
|
|
if (ret) {
|
2006-02-22 18:16:26 +00:00
|
|
|
ret = bus_setup_intr(dev,
|
1999-12-07 09:29:15 +00:00
|
|
|
com->irqres, INTR_TYPE_TTY,
|
2007-02-23 12:19:07 +00:00
|
|
|
NULL, (driver_intr_t *)siointr,
|
|
|
|
com, &com->cookie);
|
1999-12-07 09:29:15 +00:00
|
|
|
if (ret == 0)
|
2001-09-16 05:33:07 +00:00
|
|
|
device_printf(dev, "unable to activate interrupt in fast mode - using normal mode\n");
|
1999-12-07 09:29:15 +00:00
|
|
|
}
|
1999-11-18 12:22:09 +00:00
|
|
|
if (ret)
|
|
|
|
device_printf(dev, "could not activate interrupt\n");
|
2004-07-10 22:29:41 +00:00
|
|
|
#if defined(KDB) && (defined(BREAK_TO_DEBUGGER) || \
|
2001-09-16 05:33:07 +00:00
|
|
|
defined(ALT_BREAK_TO_DEBUGGER))
|
|
|
|
/*
|
|
|
|
* Enable interrupts for early break-to-debugger support
|
|
|
|
* on the console.
|
|
|
|
*/
|
|
|
|
if (ret == 0 && unit == comconsole)
|
|
|
|
outb(siocniobase + com_ier, IER_ERXRDY | IER_ERLS |
|
|
|
|
IER_EMSC);
|
|
|
|
#endif
|
1999-11-18 12:22:09 +00:00
|
|
|
}
|
1999-04-18 14:42:20 +00:00
|
|
|
|
2004-10-15 08:22:37 +00:00
|
|
|
/* We're ready, open the doors... */
|
2005-10-16 20:22:56 +00:00
|
|
|
ttycreate(tp, TS_CALLOUT, "d%r", unit);
|
2004-10-15 08:22:37 +00:00
|
|
|
|
1999-04-18 14:42:20 +00:00
|
|
|
return (0);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
2004-06-22 12:12:10 +00:00
|
|
|
static int
|
2004-10-15 08:22:37 +00:00
|
|
|
comopen(struct tty *tp, struct cdev *dev)
|
2004-06-22 12:12:10 +00:00
|
|
|
{
|
|
|
|
struct com_s *com;
|
2004-10-15 08:22:37 +00:00
|
|
|
int i;
|
2004-06-22 12:12:10 +00:00
|
|
|
|
2004-10-13 08:27:20 +00:00
|
|
|
com = tp->t_sc;
|
|
|
|
com->poll = com->no_irq;
|
|
|
|
com->poll_output = com->loses_outints;
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
com_tiocm_bis(com, TIOCM_DTR|TIOCM_RTS);
|
|
|
|
pc98_msrint_start(dev);
|
|
|
|
if (com->pc98_8251fifo) {
|
2004-10-15 08:22:37 +00:00
|
|
|
com->pc98_8251fifo_enable = 1;
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr,
|
|
|
|
FIFO_ENABLE | FIFO_XMT_RST | FIFO_RCV_RST);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2004-10-13 08:27:20 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
2004-10-13 08:27:20 +00:00
|
|
|
if (com->hasfifo) {
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
2004-10-13 08:27:20 +00:00
|
|
|
* (Re)enable and drain fifos.
|
|
|
|
*
|
|
|
|
* Certain SMC chips cause problems if the fifos
|
|
|
|
* are enabled while input is ready. Turn off the
|
|
|
|
* fifo if necessary to clear the input. We test
|
|
|
|
* the input ready bit after enabling the fifos
|
|
|
|
* since we've already enabled them in comparam()
|
|
|
|
* and to handle races between enabling and fresh
|
|
|
|
* input.
|
1996-06-14 10:04:54 +00:00
|
|
|
*/
|
2004-10-13 08:27:20 +00:00
|
|
|
for (i = 0; i < 500; i++) {
|
|
|
|
sio_setreg(com, com_fifo,
|
2008-09-07 04:35:04 +00:00
|
|
|
FIFO_RCV_RST | FIFO_XMT_RST | com->fifo_image);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
outb(com->rsabase + rsa_frr , 0x00);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
2004-10-13 08:27:20 +00:00
|
|
|
/*
|
|
|
|
* XXX the delays are for superstitious
|
|
|
|
* historical reasons. It must be less than
|
|
|
|
* the character time at the maximum
|
|
|
|
* supported speed (87 usec at 115200 bps
|
|
|
|
* 8N1). Otherwise we might loop endlessly
|
|
|
|
* if data is streaming in. We used to use
|
|
|
|
* delays of 100. That usually worked
|
|
|
|
* because DELAY(100) used to usually delay
|
|
|
|
* for about 85 usec instead of 100.
|
|
|
|
*/
|
|
|
|
DELAY(50);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III ?
|
|
|
|
!(inb(com->rsabase + rsa_srr) & 0x08) :
|
|
|
|
!(inb(com->line_status_port) & LSR_RXRDY))
|
|
|
|
break;
|
1999-01-03 05:03:47 +00:00
|
|
|
#else
|
2004-10-13 08:27:20 +00:00
|
|
|
if (!(inb(com->line_status_port) & LSR_RXRDY))
|
|
|
|
break;
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
2004-10-13 08:27:20 +00:00
|
|
|
sio_setreg(com, com_fifo, 0);
|
|
|
|
DELAY(50);
|
|
|
|
(void) inb(com->data_port);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2004-10-15 08:22:37 +00:00
|
|
|
if (i == 500)
|
2004-10-13 08:27:20 +00:00
|
|
|
return (EIO);
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-10-13 08:27:20 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
2004-10-15 08:22:37 +00:00
|
|
|
com_tiocm_bis(com, TIOCM_LE);
|
|
|
|
com->pc98_prev_modem_status = pc98_get_modem_status(com);
|
|
|
|
com_int_Rx_enable(com);
|
2004-10-13 08:27:20 +00:00
|
|
|
} else {
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
2004-10-13 08:27:20 +00:00
|
|
|
(void) inb(com->line_status_port);
|
|
|
|
(void) inb(com->data_port);
|
|
|
|
com->prev_modem_status = com->last_modem_status
|
|
|
|
= inb(com->modem_status_port);
|
|
|
|
outb(com->int_ctl_port,
|
|
|
|
IER_ERXRDY | IER_ERLS | IER_EMSC
|
|
|
|
| (COM_IIR_TXRDYBUG(com->flags) ? 0 : IER_ETXRDY));
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III) {
|
|
|
|
outb(com->rsabase + rsa_ier, 0x1d);
|
|
|
|
outb(com->int_ctl_port, IER_ERLS | IER_EMSC);
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
2004-10-13 08:27:20 +00:00
|
|
|
#endif
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
siosettimeout();
|
2004-10-15 08:22:37 +00:00
|
|
|
/* XXX: should be generic ? */
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
2004-10-13 08:27:20 +00:00
|
|
|
if ((IS_8251(com->pc98_if_type) &&
|
2004-10-15 08:22:37 +00:00
|
|
|
(pc98_get_modem_status(com) & TIOCM_CAR)) ||
|
2004-10-13 08:27:20 +00:00
|
|
|
(!IS_8251(com->pc98_if_type) &&
|
2004-10-15 08:22:37 +00:00
|
|
|
(com->prev_modem_status & MSR_DCD)) ||
|
2004-10-13 08:27:20 +00:00
|
|
|
ISCALLOUT(dev))
|
|
|
|
ttyld_modem(tp, 1);
|
|
|
|
#else
|
|
|
|
if (com->prev_modem_status & MSR_DCD || ISCALLOUT(dev))
|
|
|
|
ttyld_modem(tp, 1);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-10-15 08:22:37 +00:00
|
|
|
comclose(tp)
|
|
|
|
struct tty *tp;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
2004-10-15 08:22:37 +00:00
|
|
|
int s;
|
2004-10-13 08:27:20 +00:00
|
|
|
struct com_s *com;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
s = spltty();
|
2004-10-15 08:22:37 +00:00
|
|
|
com = tp->t_sc;
|
1996-06-14 10:04:54 +00:00
|
|
|
com->poll = FALSE;
|
|
|
|
com->poll_output = FALSE;
|
|
|
|
#ifdef PC98
|
2004-06-26 04:00:46 +00:00
|
|
|
com_send_break_off(com);
|
|
|
|
#else
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_cfcr, com->cfcr_image &= ~CFCR_SBREAK);
|
2004-06-26 04:00:46 +00:00
|
|
|
#endif
|
2001-09-16 05:33:07 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
#if defined(KDB) && (defined(BREAK_TO_DEBUGGER) || \
|
2001-09-16 05:33:07 +00:00
|
|
|
defined(ALT_BREAK_TO_DEBUGGER))
|
|
|
|
/*
|
|
|
|
* Leave interrupts enabled and don't clear DTR if this is the
|
|
|
|
* console. This allows us to detect break-to-debugger events
|
|
|
|
* while the console device is closed.
|
|
|
|
*/
|
|
|
|
if (com->unit != comconsole)
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
#ifdef PC98
|
2001-09-16 05:33:07 +00:00
|
|
|
int tmp;
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
1996-06-14 10:04:54 +00:00
|
|
|
com_int_TxRx_disable(com);
|
|
|
|
else
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_ier, 0);
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
1999-01-03 05:03:47 +00:00
|
|
|
outb(com->rsabase + rsa_ier, 0x00);
|
|
|
|
if (IS_8251(com->pc98_if_type))
|
1996-06-14 10:04:54 +00:00
|
|
|
tmp = pc98_get_modem_status(com) & TIOCM_CAR;
|
|
|
|
else
|
|
|
|
tmp = com->prev_modem_status & MSR_DCD;
|
2001-09-16 05:33:07 +00:00
|
|
|
#else
|
|
|
|
sio_setreg(com, com_ier, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
if (tp->t_cflag & HUPCL
|
|
|
|
/*
|
|
|
|
* XXX we will miss any carrier drop between here and the
|
|
|
|
* next open. Perhaps we should watch DCD even when the
|
|
|
|
* port is closed; it is not sufficient to check it at
|
|
|
|
* the next open because it might go up and down while
|
|
|
|
* we're not watching.
|
|
|
|
*/
|
2004-10-13 08:27:20 +00:00
|
|
|
|| (!tp->t_actout
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
&& !(tmp)
|
1996-06-14 10:04:54 +00:00
|
|
|
#else
|
1999-05-09 05:00:54 +00:00
|
|
|
&& !(com->prev_modem_status & MSR_DCD)
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
2004-09-17 10:59:17 +00:00
|
|
|
&& !(tp->t_init_in.c_cflag & CLOCAL))
|
1996-06-14 10:04:54 +00:00
|
|
|
|| !(tp->t_state & TS_ISOPEN)) {
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
|
|
|
com_tiocm_bic(com, TIOCM_DTR|TIOCM_RTS|TIOCM_LE);
|
1996-06-14 10:04:54 +00:00
|
|
|
else
|
|
|
|
#endif
|
2004-06-26 04:00:46 +00:00
|
|
|
(void)commodem(tp, 0, SER_DTR);
|
2004-07-11 15:18:39 +00:00
|
|
|
ttydtrwaitstart(tp);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#ifdef PC98
|
|
|
|
else {
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
2000-05-12 12:38:25 +00:00
|
|
|
com_tiocm_bic(com, TIOCM_LE);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
1999-12-06 00:23:38 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_8251fifo) {
|
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_XMT_RST | FIFO_RCV_RST);
|
1999-12-06 00:23:38 +00:00
|
|
|
com->pc98_8251fifo_enable = 0;
|
|
|
|
}
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if (com->hasfifo) {
|
|
|
|
/*
|
|
|
|
* Disable fifos so that they are off after controlled
|
|
|
|
* reboots. Some BIOSes fail to detect 16550s when the
|
|
|
|
* fifos are enabled.
|
|
|
|
*/
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2004-10-13 08:27:20 +00:00
|
|
|
tp->t_actout = FALSE;
|
|
|
|
wakeup(&tp->t_actout);
|
1996-06-14 10:04:54 +00:00
|
|
|
wakeup(TSA_CARR_ON(tp)); /* restart any wopeners */
|
2004-10-15 08:22:37 +00:00
|
|
|
siosettimeout();
|
1996-06-14 10:04:54 +00:00
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
1996-12-04 04:36:59 +00:00
|
|
|
static void
|
|
|
|
siobusycheck(chan)
|
|
|
|
void *chan;
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
com = (struct com_s *)chan;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear TS_BUSY if low-level output is complete.
|
|
|
|
* spl locking is sufficient because siointr1() does not set CS_BUSY.
|
1997-04-19 14:54:32 +00:00
|
|
|
* If siointr1() clears CS_BUSY after we look at it, then we'll get
|
1996-12-04 04:36:59 +00:00
|
|
|
* called again. Reading the line status port outside of siointr1()
|
|
|
|
* is safe because CS_BUSY is clear so there are no output interrupts
|
|
|
|
* to lose.
|
|
|
|
*/
|
|
|
|
s = spltty();
|
|
|
|
if (com->state & CS_BUSY)
|
1997-04-19 14:54:32 +00:00
|
|
|
com->extra_state &= ~CSE_BUSYCHECK; /* False alarm. */
|
1997-03-06 15:07:04 +00:00
|
|
|
#ifdef PC98
|
1999-02-02 17:26:03 +00:00
|
|
|
else if ((IS_8251(com->pc98_if_type) &&
|
1999-12-06 00:23:38 +00:00
|
|
|
((com->pc98_8251fifo_enable &&
|
2008-09-07 04:35:04 +00:00
|
|
|
(inb(I8251F_lsr) & (FLSR_TxRDY | FLSR_TxEMP))
|
|
|
|
== (FLSR_TxRDY | FLSR_TxEMP)) ||
|
1999-12-06 00:23:38 +00:00
|
|
|
(!com->pc98_8251fifo_enable &&
|
|
|
|
(inb(com->sts_port) & (STS8251_TxRDY | STS8251_TxEMP))
|
|
|
|
== (STS8251_TxRDY | STS8251_TxEMP)))) ||
|
|
|
|
((inb(com->line_status_port) & (LSR_TSRE | LSR_TXRDY))
|
|
|
|
== (LSR_TSRE | LSR_TXRDY))) {
|
1997-03-06 15:07:04 +00:00
|
|
|
#else
|
1996-12-04 04:36:59 +00:00
|
|
|
else if ((inb(com->line_status_port) & (LSR_TSRE | LSR_TXRDY))
|
|
|
|
== (LSR_TSRE | LSR_TXRDY)) {
|
1997-03-06 15:07:04 +00:00
|
|
|
#endif
|
1996-12-04 04:36:59 +00:00
|
|
|
com->tp->t_state &= ~TS_BUSY;
|
|
|
|
ttwwakeup(com->tp);
|
1997-04-19 14:54:32 +00:00
|
|
|
com->extra_state &= ~CSE_BUSYCHECK;
|
1996-12-04 04:36:59 +00:00
|
|
|
} else
|
|
|
|
timeout(siobusycheck, com, hz / 100);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
static u_int
|
|
|
|
siodivisor(rclk, speed)
|
|
|
|
u_long rclk;
|
|
|
|
speed_t speed;
|
|
|
|
{
|
|
|
|
long actual_speed;
|
|
|
|
u_int divisor;
|
|
|
|
int error;
|
|
|
|
|
2003-10-05 11:55:14 +00:00
|
|
|
if (speed == 0)
|
|
|
|
return (0);
|
|
|
|
#if UINT_MAX > (ULONG_MAX - 1) / 8
|
|
|
|
if (speed > (ULONG_MAX - 1) / 8)
|
2002-01-31 08:26:45 +00:00
|
|
|
return (0);
|
2003-10-05 11:55:14 +00:00
|
|
|
#endif
|
2002-01-31 08:26:45 +00:00
|
|
|
divisor = (rclk / (8UL * speed) + 1) / 2;
|
|
|
|
if (divisor == 0 || divisor >= 65536)
|
|
|
|
return (0);
|
|
|
|
actual_speed = rclk / (16UL * divisor);
|
|
|
|
|
|
|
|
/* 10 times error in percent: */
|
|
|
|
error = ((actual_speed - (long)speed) * 2000 / (long)speed + 1) / 2;
|
|
|
|
|
|
|
|
/* 3.0% maximum error tolerance: */
|
|
|
|
if (error < -30 || error > 30)
|
|
|
|
return (0);
|
|
|
|
|
|
|
|
return (divisor);
|
|
|
|
}
|
|
|
|
|
2000-09-07 13:34:45 +00:00
|
|
|
/*
|
2001-01-27 13:02:06 +00:00
|
|
|
* Call this function with the sio_lock mutex held. It will return with the
|
|
|
|
* lock still held.
|
2000-09-07 13:34:45 +00:00
|
|
|
*/
|
1999-02-05 11:37:40 +00:00
|
|
|
static void
|
|
|
|
sioinput(com)
|
|
|
|
struct com_s *com;
|
|
|
|
{
|
|
|
|
u_char *buf;
|
|
|
|
int incc;
|
|
|
|
u_char line_status;
|
|
|
|
int recv_data;
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
buf = com->ibuf;
|
|
|
|
tp = com->tp;
|
|
|
|
if (!(tp->t_state & TS_ISOPEN) || !(tp->t_cflag & CREAD)) {
|
|
|
|
com_events -= (com->iptr - com->ibuf);
|
|
|
|
com->iptr = com->ibuf;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
|
|
|
|
/*
|
|
|
|
* Avoid the grotesquely inefficient lineswitch routine
|
|
|
|
* (ttyinput) in "raw" mode. It usually takes about 450
|
|
|
|
* instructions (that's without canonical processing or echo!).
|
|
|
|
* slinput is reasonably fast (usually 40 instructions plus
|
|
|
|
* call overhead).
|
|
|
|
*/
|
|
|
|
do {
|
2000-09-07 13:34:45 +00:00
|
|
|
/*
|
|
|
|
* This may look odd, but it is using save-and-enable
|
|
|
|
* semantics instead of the save-and-disable semantics
|
|
|
|
* that are used everywhere else.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
incc = com->iptr - buf;
|
|
|
|
if (tp->t_rawq.c_cc + incc > tp->t_ihiwat
|
|
|
|
&& (com->state & CS_RTS_IFLOW
|
|
|
|
|| tp->t_iflag & IXOFF)
|
|
|
|
&& !(tp->t_state & TS_TBLOCK))
|
|
|
|
ttyblock(tp);
|
|
|
|
com->delta_error_counts[CE_TTY_BUF_OVERFLOW]
|
|
|
|
+= b_to_q((char *)buf, incc, &tp->t_rawq);
|
|
|
|
buf += incc;
|
|
|
|
tk_nin += incc;
|
|
|
|
tk_rawcc += incc;
|
|
|
|
tp->t_rawcc += incc;
|
|
|
|
ttwakeup(tp);
|
|
|
|
if (tp->t_state & TS_TTSTOP
|
|
|
|
&& (tp->t_iflag & IXANY
|
|
|
|
|| tp->t_cc[VSTART] == tp->t_cc[VSTOP])) {
|
|
|
|
tp->t_state &= ~TS_TTSTOP;
|
|
|
|
tp->t_lflag &= ~FLUSHO;
|
|
|
|
comstart(tp);
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
} while (buf < com->iptr);
|
|
|
|
} else {
|
|
|
|
do {
|
2000-09-07 13:34:45 +00:00
|
|
|
/*
|
|
|
|
* This may look odd, but it is using save-and-enable
|
|
|
|
* semantics instead of the save-and-disable semantics
|
|
|
|
* that are used everywhere else.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
line_status = buf[com->ierroff];
|
|
|
|
recv_data = *buf++;
|
|
|
|
if (line_status
|
|
|
|
& (LSR_BI | LSR_FE | LSR_OE | LSR_PE)) {
|
|
|
|
if (line_status & LSR_BI)
|
|
|
|
recv_data |= TTY_BI;
|
|
|
|
if (line_status & LSR_FE)
|
|
|
|
recv_data |= TTY_FE;
|
|
|
|
if (line_status & LSR_OE)
|
|
|
|
recv_data |= TTY_OE;
|
|
|
|
if (line_status & LSR_PE)
|
|
|
|
recv_data |= TTY_PE;
|
|
|
|
}
|
2004-06-04 16:02:56 +00:00
|
|
|
ttyld_rint(tp, recv_data);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
} while (buf < com->iptr);
|
|
|
|
}
|
|
|
|
com_events -= (com->iptr - com->ibuf);
|
|
|
|
com->iptr = com->ibuf;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is now room for another low-level buffer full of input,
|
|
|
|
* so enable RTS if it is now disabled and there is room in the
|
|
|
|
* high-level buffer.
|
|
|
|
*/
|
|
|
|
#ifdef PC98
|
1999-11-29 13:20:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
if ((com->state & CS_RTS_IFLOW) &&
|
|
|
|
!(com_tiocm_get(com) & TIOCM_RTS) &&
|
|
|
|
!(tp->t_state & TS_TBLOCK))
|
1999-02-05 11:37:40 +00:00
|
|
|
com_tiocm_bis(com, TIOCM_RTS);
|
1999-11-29 13:20:47 +00:00
|
|
|
} else {
|
|
|
|
if ((com->state & CS_RTS_IFLOW) &&
|
|
|
|
!(com->mcr_image & MCR_RTS) &&
|
|
|
|
!(tp->t_state & TS_TBLOCK))
|
1999-02-05 11:37:40 +00:00
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
1999-11-29 13:20:47 +00:00
|
|
|
}
|
1999-02-05 11:37:40 +00:00
|
|
|
#else
|
|
|
|
if ((com->state & CS_RTS_IFLOW) && !(com->mcr_image & MCR_RTS) &&
|
|
|
|
!(tp->t_state & TS_TBLOCK))
|
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2007-02-23 12:19:07 +00:00
|
|
|
static int
|
1999-04-18 14:42:20 +00:00
|
|
|
siointr(arg)
|
|
|
|
void *arg;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-05-10 09:14:40 +00:00
|
|
|
struct com_s *com;
|
2002-10-10 14:14:29 +00:00
|
|
|
#if defined(PC98) && defined(COM_MULTIPORT)
|
1999-01-03 05:03:47 +00:00
|
|
|
u_char rsa_buf_status;
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2001-01-27 13:02:06 +00:00
|
|
|
#ifndef COM_MULTIPORT
|
|
|
|
com = (struct com_s *)arg;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
2001-01-27 13:02:06 +00:00
|
|
|
siointr1(com);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
2001-01-27 13:02:06 +00:00
|
|
|
#else /* COM_MULTIPORT */
|
|
|
|
bool_t possibly_more_intrs;
|
|
|
|
int unit;
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* Loop until there is no activity on any port. This is necessary
|
|
|
|
* to get an interrupt edge more than to avoid another interrupt.
|
|
|
|
* If the IRQ signal is just an OR of the IRQ signals from several
|
|
|
|
* devices, then the edge from one may be lost because another is
|
|
|
|
* on.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
do {
|
|
|
|
possibly_more_intrs = FALSE;
|
1999-11-18 12:22:09 +00:00
|
|
|
for (unit = 0; unit < sio_numunits; ++unit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
com = com_addr(unit);
|
1997-08-30 15:47:49 +00:00
|
|
|
/*
|
1997-09-01 10:45:02 +00:00
|
|
|
* XXX COM_LOCK();
|
1997-08-30 15:47:49 +00:00
|
|
|
* would it work here, or be counter-productive?
|
|
|
|
*/
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com != NULL
|
|
|
|
&& !com->gone
|
2000-05-12 12:38:25 +00:00
|
|
|
&& IS_8251(com->pc98_if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
siointr1(com);
|
2000-05-12 12:38:25 +00:00
|
|
|
} else if (com != NULL
|
1999-01-03 05:03:47 +00:00
|
|
|
&& !com->gone
|
|
|
|
&& com->pc98_if_type == COM_IF_RSA98III) {
|
2000-05-12 12:38:25 +00:00
|
|
|
rsa_buf_status =
|
|
|
|
inb(com->rsabase + rsa_srr) & 0xc9;
|
|
|
|
if ((rsa_buf_status & 0xc8)
|
|
|
|
|| !(rsa_buf_status & 0x01)) {
|
|
|
|
siointr1(com);
|
|
|
|
if (rsa_buf_status !=
|
|
|
|
(inb(com->rsabase + rsa_srr) & 0xc9))
|
|
|
|
possibly_more_intrs = TRUE;
|
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
} else
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if (com != NULL
|
|
|
|
&& !com->gone
|
|
|
|
&& (inb(com->int_id_port) & IIR_IMASK)
|
|
|
|
!= IIR_NOPEND) {
|
|
|
|
siointr1(com);
|
|
|
|
possibly_more_intrs = TRUE;
|
|
|
|
}
|
1997-09-01 10:45:02 +00:00
|
|
|
/* XXX COM_UNLOCK(); */
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
} while (possibly_more_intrs);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* COM_MULTIPORT */
|
2007-02-23 12:19:07 +00:00
|
|
|
return (FILTER_HANDLED);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
2003-11-17 23:13:08 +00:00
|
|
|
static struct timespec siots[8];
|
2002-04-06 06:19:10 +00:00
|
|
|
static int siotso;
|
|
|
|
static int volatile siotsunit = -1;
|
|
|
|
|
|
|
|
static int
|
|
|
|
sysctl_siots(SYSCTL_HANDLER_ARGS)
|
|
|
|
{
|
|
|
|
char buf[128];
|
|
|
|
long long delta;
|
|
|
|
size_t len;
|
2003-11-17 23:13:08 +00:00
|
|
|
int error, i, tso;
|
2002-04-06 06:19:10 +00:00
|
|
|
|
2003-11-17 23:13:08 +00:00
|
|
|
for (i = 1, tso = siotso; i < tso; i++) {
|
2002-04-06 06:19:10 +00:00
|
|
|
delta = (long long)(siots[i].tv_sec - siots[i - 1].tv_sec) *
|
|
|
|
1000000000 +
|
|
|
|
(siots[i].tv_nsec - siots[i - 1].tv_nsec);
|
|
|
|
len = sprintf(buf, "%lld\n", delta);
|
|
|
|
if (delta >= 110000)
|
|
|
|
len += sprintf(buf + len - 1, ": *** %ld.%09ld\n",
|
2003-11-17 23:13:08 +00:00
|
|
|
(long)siots[i].tv_sec, siots[i].tv_nsec) - 1;
|
|
|
|
if (i == tso - 1)
|
2002-04-06 06:19:10 +00:00
|
|
|
buf[len - 1] = '\0';
|
|
|
|
error = SYSCTL_OUT(req, buf, len);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
SYSCTL_PROC(_machdep, OID_AUTO, siots, CTLTYPE_STRING | CTLFLAG_RD,
|
|
|
|
0, 0, sysctl_siots, "A", "sio timestamps");
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
static void
|
|
|
|
siointr1(com)
|
|
|
|
struct com_s *com;
|
|
|
|
{
|
2003-10-05 11:55:14 +00:00
|
|
|
u_char int_ctl;
|
|
|
|
u_char int_ctl_new;
|
1996-06-14 10:04:54 +00:00
|
|
|
u_char line_status;
|
|
|
|
u_char modem_status;
|
|
|
|
u_char *ioptr;
|
|
|
|
u_char recv_data;
|
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
u_char tmp = 0;
|
1999-01-03 05:03:47 +00:00
|
|
|
u_char rsa_buf_status = 0;
|
2000-05-12 12:38:25 +00:00
|
|
|
int rsa_tx_fifo_size = 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* PC98 */
|
2008-05-04 23:29:38 +00:00
|
|
|
#if defined(KDB) && defined(ALT_BREAK_TO_DEBUGGER)
|
|
|
|
int kdb_brk;
|
|
|
|
|
|
|
|
again:
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2003-10-05 11:55:14 +00:00
|
|
|
if (COM_IIR_TXRDYBUG(com->flags)) {
|
|
|
|
int_ctl = inb(com->int_ctl_port);
|
|
|
|
int_ctl_new = int_ctl;
|
|
|
|
} else {
|
|
|
|
int_ctl = 0;
|
|
|
|
int_ctl_new = 0;
|
|
|
|
}
|
1998-01-08 10:50:06 +00:00
|
|
|
|
1998-02-15 11:18:47 +00:00
|
|
|
while (!com->gone) {
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
|
|
|
status_read:;
|
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
tmp = inb(I8251F_lsr);
|
|
|
|
else
|
|
|
|
tmp = inb(com->sts_port);
|
1996-06-14 10:04:54 +00:00
|
|
|
more_intr:
|
|
|
|
line_status = 0;
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable) {
|
2008-09-07 04:35:04 +00:00
|
|
|
if (tmp & FLSR_TxRDY) line_status |= LSR_TXRDY;
|
|
|
|
if (tmp & FLSR_RxRDY) line_status |= LSR_RXRDY;
|
|
|
|
if (tmp & FLSR_TxEMP) line_status |= LSR_TSRE;
|
|
|
|
if (tmp & FLSR_PE) line_status |= LSR_PE;
|
|
|
|
if (tmp & FLSR_OE) line_status |= LSR_OE;
|
|
|
|
if (tmp & FLSR_BI) line_status |= LSR_BI;
|
1999-12-06 00:23:38 +00:00
|
|
|
} else {
|
|
|
|
if (tmp & STS8251_TxRDY) line_status |= LSR_TXRDY;
|
|
|
|
if (tmp & STS8251_RxRDY) line_status |= LSR_RXRDY;
|
|
|
|
if (tmp & STS8251_TxEMP) line_status |= LSR_TSRE;
|
|
|
|
if (tmp & STS8251_PE) line_status |= LSR_PE;
|
|
|
|
if (tmp & STS8251_OE) line_status |= LSR_OE;
|
|
|
|
if (tmp & STS8251_FE) line_status |= LSR_FE;
|
2008-09-07 04:35:04 +00:00
|
|
|
if (tmp & STS8251_BI) line_status |= LSR_BI;
|
1999-12-06 00:23:38 +00:00
|
|
|
}
|
1999-05-05 01:53:43 +00:00
|
|
|
} else {
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* PC98 */
|
1999-04-01 13:44:15 +00:00
|
|
|
if (com->pps.ppsparam.mode & PPS_CAPTUREBOTH) {
|
|
|
|
modem_status = inb(com->modem_status_port);
|
2003-03-09 10:15:11 +00:00
|
|
|
if ((modem_status ^ com->last_modem_status) &
|
|
|
|
com->pps_bit) {
|
2002-04-26 20:24:28 +00:00
|
|
|
pps_capture(&com->pps);
|
2003-03-09 10:15:11 +00:00
|
|
|
pps_event(&com->pps,
|
|
|
|
(modem_status & com->pps_bit) ?
|
1999-09-12 13:44:54 +00:00
|
|
|
PPS_CAPTUREASSERT : PPS_CAPTURECLEAR);
|
1999-04-01 13:44:15 +00:00
|
|
|
}
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
line_status = inb(com->line_status_port);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
1999-05-05 01:53:43 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
rsa_buf_status = inb(com->rsabase + rsa_srr);
|
|
|
|
#endif /* PC98 */
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/* input event? (check first to help avoid overruns) */
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifndef PC98
|
1996-06-14 10:04:54 +00:00
|
|
|
while (line_status & LSR_RCV_MASK) {
|
1999-01-03 05:03:47 +00:00
|
|
|
#else
|
|
|
|
while ((line_status & LSR_RCV_MASK)
|
|
|
|
|| (com->pc98_if_type == COM_IF_RSA98III
|
|
|
|
&& (rsa_buf_status & 0x08))) {
|
|
|
|
#endif /* PC98 */
|
1996-06-14 10:04:54 +00:00
|
|
|
/* break/unnattached error bits or real input? */
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable) {
|
|
|
|
recv_data = inb(I8251F_data);
|
2008-09-07 04:35:04 +00:00
|
|
|
if (tmp &
|
|
|
|
(FLSR_PE | FLSR_OE | FLSR_BI)) {
|
1999-12-06 00:23:38 +00:00
|
|
|
pc98_i8251_or_cmd(com, CMD8251_ER);
|
|
|
|
recv_data = 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
recv_data = inb(com->data_port);
|
|
|
|
if (tmp & (STS8251_PE | STS8251_OE |
|
2008-09-07 04:35:04 +00:00
|
|
|
STS8251_FE | STS8251_BI)) {
|
1999-12-06 00:23:38 +00:00
|
|
|
pc98_i8251_or_cmd(com, CMD8251_ER);
|
1996-06-14 10:04:54 +00:00
|
|
|
recv_data = 0;
|
1999-12-06 00:23:38 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2000-05-12 12:38:25 +00:00
|
|
|
} else if (com->pc98_if_type == COM_IF_RSA98III) {
|
1999-12-06 00:23:38 +00:00
|
|
|
if (!(rsa_buf_status & 0x08))
|
|
|
|
recv_data = 0;
|
|
|
|
else
|
|
|
|
recv_data = inb(com->data_port);
|
1999-01-03 05:03:47 +00:00
|
|
|
} else
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if (!(line_status & LSR_RXRDY))
|
|
|
|
recv_data = 0;
|
|
|
|
else
|
|
|
|
recv_data = inb(com->data_port);
|
2004-07-10 22:29:41 +00:00
|
|
|
#ifdef KDB
|
2003-08-28 11:20:54 +00:00
|
|
|
#ifdef ALT_BREAK_TO_DEBUGGER
|
|
|
|
if (com->unit == comconsole &&
|
2008-05-04 23:29:38 +00:00
|
|
|
(kdb_brk = kdb_alt_break(recv_data,
|
|
|
|
&com->alt_brk_state)) != 0) {
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
|
|
|
switch (kdb_brk) {
|
|
|
|
case KDB_REQ_DEBUGGER:
|
|
|
|
kdb_enter(KDB_WHY_BREAK,
|
|
|
|
"Break sequence on console");
|
|
|
|
break;
|
|
|
|
case KDB_REQ_PANIC:
|
|
|
|
kdb_panic("panic on console");
|
|
|
|
break;
|
|
|
|
case KDB_REQ_REBOOT:
|
|
|
|
kdb_reboot();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mtx_lock_spin(&sio_lock);
|
|
|
|
goto again;
|
|
|
|
}
|
2003-08-28 11:20:54 +00:00
|
|
|
#endif /* ALT_BREAK_TO_DEBUGGER */
|
2004-07-10 22:29:41 +00:00
|
|
|
#endif /* KDB */
|
1996-12-04 04:36:59 +00:00
|
|
|
if (line_status & (LSR_BI | LSR_FE | LSR_PE)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
1996-12-04 04:36:59 +00:00
|
|
|
* Don't store BI if IGNBRK or FE/PE if IGNPAR.
|
|
|
|
* Otherwise, push the work to a higher level
|
|
|
|
* (to handle PARMRK) if we're bypassing.
|
|
|
|
* Otherwise, convert BI/FE and PE+INPCK to 0.
|
|
|
|
*
|
|
|
|
* This makes bypassing work right in the
|
|
|
|
* usual "raw" case (IGNBRK set, and IGNPAR
|
|
|
|
* and INPCK clear).
|
|
|
|
*
|
|
|
|
* Note: BI together with FE/PE means just BI.
|
|
|
|
*/
|
|
|
|
if (line_status & LSR_BI) {
|
2004-07-10 22:29:41 +00:00
|
|
|
#if defined(KDB) && defined(BREAK_TO_DEBUGGER)
|
1996-12-04 04:36:59 +00:00
|
|
|
if (com->unit == comconsole) {
|
2007-12-25 17:52:02 +00:00
|
|
|
kdb_enter(KDB_WHY_BREAK,
|
|
|
|
"Line break on console");
|
1996-12-04 04:36:59 +00:00
|
|
|
goto cont;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (com->tp == NULL
|
|
|
|
|| com->tp->t_iflag & IGNBRK)
|
|
|
|
goto cont;
|
|
|
|
} else {
|
|
|
|
if (com->tp == NULL
|
|
|
|
|| com->tp->t_iflag & IGNPAR)
|
|
|
|
goto cont;
|
|
|
|
}
|
|
|
|
if (com->tp->t_state & TS_CAN_BYPASS_L_RINT
|
|
|
|
&& (line_status & (LSR_BI | LSR_FE)
|
|
|
|
|| com->tp->t_iflag & INPCK))
|
1996-06-14 10:04:54 +00:00
|
|
|
recv_data = 0;
|
|
|
|
}
|
|
|
|
++com->bytes_in;
|
2004-06-28 13:28:20 +00:00
|
|
|
if (com->tp != NULL &&
|
|
|
|
com->tp->t_hotchar != 0 && recv_data == com->tp->t_hotchar)
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(sio_fast_ih, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
ioptr = com->iptr;
|
|
|
|
if (ioptr >= com->ibufend)
|
|
|
|
CE_RECORD(com, CE_INTERRUPT_BUF_OVERFLOW);
|
|
|
|
else {
|
2004-10-15 08:22:37 +00:00
|
|
|
if (com->tp != NULL && com->tp->t_do_timestamp)
|
|
|
|
microtime(&com->tp->t_timestamp);
|
1996-06-14 10:04:54 +00:00
|
|
|
++com_events;
|
2001-02-13 09:55:20 +00:00
|
|
|
swi_sched(sio_slow_ih, SWI_DELAY);
|
1996-06-14 10:04:54 +00:00
|
|
|
#if 0 /* for testing input latency vs efficiency */
|
|
|
|
if (com->iptr - com->ibuf == 8)
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(sio_fast_ih, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
ioptr[0] = recv_data;
|
1999-02-05 11:37:40 +00:00
|
|
|
ioptr[com->ierroff] = line_status;
|
1996-06-14 10:04:54 +00:00
|
|
|
com->iptr = ++ioptr;
|
|
|
|
if (ioptr == com->ihighwater
|
|
|
|
&& com->state & CS_RTS_IFLOW)
|
|
|
|
#ifdef PC98
|
1999-11-29 13:20:47 +00:00
|
|
|
IS_8251(com->pc98_if_type) ?
|
|
|
|
com_tiocm_bic(com, TIOCM_RTS) :
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
outb(com->modem_ctl_port,
|
|
|
|
com->mcr_image &= ~MCR_RTS);
|
|
|
|
if (line_status & LSR_OE)
|
|
|
|
CE_RECORD(com, CE_OVERRUN);
|
|
|
|
}
|
|
|
|
cont:
|
2003-11-17 23:13:08 +00:00
|
|
|
if (line_status & LSR_TXRDY
|
|
|
|
&& com->state >= (CS_BUSY | CS_TTGO | CS_ODEVREADY))
|
|
|
|
goto txrdy;
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* "& 0x7F" is to avoid the gcc-1.40 generating a slow
|
|
|
|
* jump from the top of the loop to here
|
|
|
|
*/
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
1996-06-14 10:04:54 +00:00
|
|
|
goto status_read;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
line_status = inb(com->line_status_port) & 0x7F;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
rsa_buf_status = inb(com->rsabase + rsa_srr);
|
|
|
|
#endif /* PC98 */
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* modem status change? (always check before doing output) */
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (!IS_8251(com->pc98_if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
modem_status = inb(com->modem_status_port);
|
|
|
|
if (modem_status != com->last_modem_status) {
|
|
|
|
/*
|
|
|
|
* Schedule high level to handle DCD changes. Note
|
|
|
|
* that we don't use the delta bits anywhere. Some
|
|
|
|
* UARTs mess them up, and it's easy to remember the
|
|
|
|
* previous bits and calculate the delta.
|
|
|
|
*/
|
|
|
|
com->last_modem_status = modem_status;
|
|
|
|
if (!(com->state & CS_CHECKMSR)) {
|
|
|
|
com_events += LOTS_OF_EVENTS;
|
|
|
|
com->state |= CS_CHECKMSR;
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(sio_fast_ih, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* handle CTS change immediately for crisp flow ctl */
|
|
|
|
if (com->state & CS_CTS_OFLOW) {
|
|
|
|
if (modem_status & MSR_CTS)
|
|
|
|
com->state |= CS_ODEVREADY;
|
|
|
|
else
|
|
|
|
com->state &= ~CS_ODEVREADY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2003-11-17 23:13:08 +00:00
|
|
|
txrdy:
|
1996-06-14 10:04:54 +00:00
|
|
|
/* output queued and everything ready? */
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifndef PC98
|
1996-06-14 10:04:54 +00:00
|
|
|
if (line_status & LSR_TXRDY
|
|
|
|
&& com->state >= (CS_BUSY | CS_TTGO | CS_ODEVREADY)) {
|
1999-01-03 05:03:47 +00:00
|
|
|
#else
|
|
|
|
if (((com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
? (rsa_buf_status & 0x02)
|
|
|
|
: (line_status & LSR_TXRDY))
|
|
|
|
&& com->state >= (CS_BUSY | CS_TTGO | CS_ODEVREADY)) {
|
|
|
|
#endif
|
1999-12-06 00:23:38 +00:00
|
|
|
#ifdef PC98
|
|
|
|
Port_t tmp_data_port;
|
|
|
|
|
|
|
|
if (IS_8251(com->pc98_if_type) &&
|
|
|
|
com->pc98_8251fifo_enable)
|
|
|
|
tmp_data_port = I8251F_data;
|
|
|
|
else
|
|
|
|
tmp_data_port = com->data_port;
|
|
|
|
#endif
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
ioptr = com->obufq.l_head;
|
2002-04-06 06:19:10 +00:00
|
|
|
if (com->tx_fifo_size > 1 && com->unit != siotsunit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
u_int ocount;
|
|
|
|
|
|
|
|
ocount = com->obufq.l_tail - ioptr;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III) {
|
|
|
|
rsa_buf_status = inb(com->rsabase + rsa_srr);
|
|
|
|
rsa_tx_fifo_size = 1024;
|
|
|
|
if (!(rsa_buf_status & 0x01))
|
1999-12-06 00:23:38 +00:00
|
|
|
rsa_tx_fifo_size = 2048;
|
1999-01-03 05:03:47 +00:00
|
|
|
if (ocount > rsa_tx_fifo_size)
|
1999-12-06 00:23:38 +00:00
|
|
|
ocount = rsa_tx_fifo_size;
|
1999-01-03 05:03:47 +00:00
|
|
|
} else
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if (ocount > com->tx_fifo_size)
|
|
|
|
ocount = com->tx_fifo_size;
|
|
|
|
com->bytes_out += ocount;
|
|
|
|
do
|
1999-12-06 00:23:38 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(tmp_data_port, *ioptr++);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->data_port, *ioptr++);
|
1999-12-06 00:23:38 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
while (--ocount != 0);
|
|
|
|
} else {
|
1999-12-06 00:23:38 +00:00
|
|
|
#ifdef PC98
|
|
|
|
outb(tmp_data_port, *ioptr++);
|
|
|
|
#else
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->data_port, *ioptr++);
|
1999-12-06 00:23:38 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
++com->bytes_out;
|
2003-11-17 23:13:08 +00:00
|
|
|
if (com->unit == siotsunit
|
|
|
|
&& siotso < sizeof siots / sizeof siots[0])
|
|
|
|
nanouptime(&siots[siotso++]);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
|
|
|
if (!(pc98_check_i8251_interrupt(com) & IEN_TxFLAG))
|
2000-05-12 12:38:25 +00:00
|
|
|
com_int_Tx_enable(com);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
com->obufq.l_head = ioptr;
|
2003-10-05 11:55:14 +00:00
|
|
|
if (COM_IIR_TXRDYBUG(com->flags))
|
1998-01-08 10:50:06 +00:00
|
|
|
int_ctl_new = int_ctl | IER_ETXRDY;
|
1996-06-14 10:04:54 +00:00
|
|
|
if (ioptr >= com->obufq.l_tail) {
|
|
|
|
struct lbq *qp;
|
1996-07-23 07:46:59 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
qp = com->obufq.l_next;
|
|
|
|
qp->l_queued = FALSE;
|
|
|
|
qp = qp->l_next;
|
|
|
|
if (qp != NULL) {
|
|
|
|
com->obufq.l_head = qp->l_head;
|
|
|
|
com->obufq.l_tail = qp->l_tail;
|
|
|
|
com->obufq.l_next = qp;
|
|
|
|
} else {
|
|
|
|
/* output just completed */
|
2003-10-05 11:55:14 +00:00
|
|
|
if (COM_IIR_TXRDYBUG(com->flags))
|
|
|
|
int_ctl_new = int_ctl
|
|
|
|
& ~IER_ETXRDY;
|
1996-06-14 10:04:54 +00:00
|
|
|
com->state &= ~CS_BUSY;
|
1996-07-23 07:46:59 +00:00
|
|
|
#if defined(PC98)
|
2000-05-12 12:38:25 +00:00
|
|
|
if (IS_8251(com->pc98_if_type) &&
|
|
|
|
pc98_check_i8251_interrupt(com) & IEN_TxFLAG)
|
1999-01-03 05:03:47 +00:00
|
|
|
com_int_Tx_disable(com);
|
1996-07-23 07:46:59 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
if (!(com->state & CS_ODONE)) {
|
|
|
|
com_events += LOTS_OF_EVENTS;
|
|
|
|
com->state |= CS_ODONE;
|
2000-10-25 05:19:40 +00:00
|
|
|
/* handle at high level ASAP */
|
Change the preemption code for software interrupt thread schedules and
mutex releases to not require flags for the cases when preemption is
not allowed:
The purpose of the MTX_NOSWITCH and SWI_NOSWITCH flags is to prevent
switching to a higher priority thread on mutex releease and swi schedule,
respectively when that switch is not safe. Now that the critical section
API maintains a per-thread nesting count, the kernel can easily check
whether or not it should switch without relying on flags from the
programmer. This fixes a few bugs in that all current callers of
swi_sched() used SWI_NOSWITCH, when in fact, only the ones called from
fast interrupt handlers and the swi_sched of softclock needed this flag.
Note that to ensure that swi_sched()'s in clock and fast interrupt
handlers do not switch, these handlers have to be explicitly wrapped
in critical_enter/exit pairs. Presently, just wrapping the handlers is
sufficient, but in the future with the fully preemptive kernel, the
interrupt must be EOI'd before critical_exit() is called. (critical_exit()
can switch due to a deferred preemption in a fully preemptive kernel.)
I've tested the changes to the interrupt code on i386 and alpha. I have
not tested ia64, but the interrupt code is almost identical to the alpha
code, so I expect it will work fine. PowerPC and ARM do not yet have
interrupt code in the tree so they shouldn't be broken. Sparc64 is
broken, but that's been ok'd by jake and tmm who will be fixing the
interrupt code for sparc64 shortly.
Reviewed by: peter
Tested on: i386, alpha
2002-01-05 08:47:13 +00:00
|
|
|
swi_sched(sio_fast_ih, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
1999-02-05 11:37:40 +00:00
|
|
|
#ifdef PC98
|
2003-10-05 11:55:14 +00:00
|
|
|
if (COM_IIR_TXRDYBUG(com->flags)
|
|
|
|
&& int_ctl != int_ctl_new) {
|
1999-01-03 05:03:47 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III) {
|
1999-11-18 12:22:09 +00:00
|
|
|
int_ctl_new &= ~(IER_ETXRDY | IER_ERXRDY);
|
2003-10-05 11:55:14 +00:00
|
|
|
outb(com->int_ctl_port, int_ctl_new);
|
1999-11-18 12:22:09 +00:00
|
|
|
outb(com->rsabase + rsa_ier, 0x1d);
|
1999-01-03 05:03:47 +00:00
|
|
|
} else
|
2003-10-05 11:55:14 +00:00
|
|
|
outb(com->int_ctl_port, int_ctl_new);
|
1998-01-08 10:50:06 +00:00
|
|
|
}
|
2003-10-05 11:55:14 +00:00
|
|
|
#else
|
|
|
|
if (COM_IIR_TXRDYBUG(com->flags)
|
|
|
|
&& int_ctl != int_ctl_new)
|
|
|
|
outb(com->int_ctl_port, int_ctl_new);
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#ifdef PC98
|
|
|
|
else if (line_status & LSR_TXRDY) {
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
2000-05-12 12:38:25 +00:00
|
|
|
if (pc98_check_i8251_interrupt(com) & IEN_TxFLAG)
|
1999-01-03 05:03:47 +00:00
|
|
|
com_int_Tx_disable(com);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-12-06 00:23:38 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
if (com->pc98_8251fifo_enable) {
|
2008-09-07 04:35:04 +00:00
|
|
|
if ((tmp = inb(I8251F_lsr)) & FLSR_RxRDY)
|
1999-12-06 00:23:38 +00:00
|
|
|
goto more_intr;
|
|
|
|
} else {
|
|
|
|
if ((tmp = inb(com->sts_port)) & STS8251_RxRDY)
|
|
|
|
goto more_intr;
|
|
|
|
}
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* finished? */
|
|
|
|
#ifndef COM_MULTIPORT
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
1996-06-14 10:04:54 +00:00
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
if ((inb(com->int_id_port) & IIR_IMASK) == IIR_NOPEND)
|
|
|
|
#endif /* COM_MULTIPORT */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-09-07 13:34:45 +00:00
|
|
|
/* software interrupt handler for SWI_TTY */
|
1998-08-13 07:36:40 +00:00
|
|
|
static void
|
2000-10-25 20:21:42 +00:00
|
|
|
siopoll(void *dummy)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
if (com_events == 0)
|
|
|
|
return;
|
|
|
|
repeat:
|
1999-11-18 12:22:09 +00:00
|
|
|
for (unit = 0; unit < sio_numunits; ++unit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
struct com_s *com;
|
|
|
|
int incc;
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
com = com_addr(unit);
|
|
|
|
if (com == NULL)
|
|
|
|
continue;
|
|
|
|
tp = com->tp;
|
1998-06-17 09:27:15 +00:00
|
|
|
if (tp == NULL || com->gone) {
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
1998-06-17 09:27:15 +00:00
|
|
|
* Discard any events related to never-opened or
|
|
|
|
* going-away devices.
|
1996-06-14 10:04:54 +00:00
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
incc = com->iptr - com->ibuf;
|
|
|
|
com->iptr = com->ibuf;
|
|
|
|
if (com->state & CS_CHECKMSR) {
|
|
|
|
incc += LOTS_OF_EVENTS;
|
|
|
|
com->state &= ~CS_CHECKMSR;
|
|
|
|
}
|
|
|
|
com_events -= incc;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
continue;
|
|
|
|
}
|
1999-02-05 11:37:40 +00:00
|
|
|
if (com->iptr != com->ibuf) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
sioinput(com);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
if (com->state & CS_CHECKMSR) {
|
|
|
|
u_char delta_modem_status;
|
|
|
|
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (!IS_8251(com->pc98_if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
delta_modem_status = com->last_modem_status
|
|
|
|
^ com->prev_modem_status;
|
|
|
|
com->prev_modem_status = com->last_modem_status;
|
|
|
|
com_events -= LOTS_OF_EVENTS;
|
|
|
|
com->state &= ~CS_CHECKMSR;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (delta_modem_status & MSR_DCD)
|
2004-06-04 20:04:52 +00:00
|
|
|
ttyld_modem(tp,
|
|
|
|
com->prev_modem_status & MSR_DCD);
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
if (com->state & CS_ODONE) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
com_events -= LOTS_OF_EVENTS;
|
|
|
|
com->state &= ~CS_ODONE;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1997-04-19 14:54:32 +00:00
|
|
|
if (!(com->state & CS_BUSY)
|
|
|
|
&& !(com->extra_state & CSE_BUSYCHECK)) {
|
1996-12-04 04:36:59 +00:00
|
|
|
timeout(siobusycheck, com, hz / 100);
|
1997-04-19 14:54:32 +00:00
|
|
|
com->extra_state |= CSE_BUSYCHECK;
|
|
|
|
}
|
2004-06-04 16:02:56 +00:00
|
|
|
ttyld_start(tp);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
if (com_events == 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (com_events >= LOTS_OF_EVENTS)
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
2004-07-01 09:32:32 +00:00
|
|
|
static void
|
2004-06-26 04:00:46 +00:00
|
|
|
combreak(tp, sig)
|
|
|
|
struct tty *tp;
|
|
|
|
int sig;
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = tp->t_sc;
|
2004-06-26 04:00:46 +00:00
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
if (sig)
|
|
|
|
com_send_break_on(com);
|
|
|
|
else
|
|
|
|
com_send_break_off(com);
|
|
|
|
#else
|
|
|
|
if (sig)
|
|
|
|
sio_setreg(com, com_cfcr, com->cfcr_image |= CFCR_SBREAK);
|
|
|
|
else
|
|
|
|
sio_setreg(com, com_cfcr, com->cfcr_image &= ~CFCR_SBREAK);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
static int
|
|
|
|
comparam(tp, t)
|
|
|
|
struct tty *tp;
|
|
|
|
struct termios *t;
|
|
|
|
{
|
|
|
|
u_int cfcr;
|
|
|
|
int cflag;
|
|
|
|
struct com_s *com;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_int divisor;
|
1996-10-09 21:47:16 +00:00
|
|
|
u_char dlbh;
|
|
|
|
u_char dlbl;
|
2003-10-05 11:55:14 +00:00
|
|
|
u_char efr_flowbits;
|
1996-06-14 10:04:54 +00:00
|
|
|
int s;
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
u_char param = 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = tp->t_sc;
|
2002-01-31 08:26:45 +00:00
|
|
|
if (com == NULL)
|
|
|
|
return (ENODEV);
|
2000-05-12 12:38:25 +00:00
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
cfcr = 0;
|
2002-01-31 08:26:45 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
2002-03-08 12:12:46 +00:00
|
|
|
if (pc98_ttspeedtab(com, t->c_ospeed, &divisor) != 0)
|
2002-01-31 08:26:45 +00:00
|
|
|
return (EINVAL);
|
1999-01-03 05:03:47 +00:00
|
|
|
} else {
|
2002-01-31 08:26:45 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
/* check requested parameters */
|
2003-10-05 11:55:14 +00:00
|
|
|
if (t->c_ispeed != (t->c_ospeed != 0 ? t->c_ospeed : tp->t_ospeed))
|
|
|
|
return (EINVAL);
|
|
|
|
divisor = siodivisor(com->rclk, t->c_ispeed);
|
|
|
|
if (divisor == 0)
|
|
|
|
return (EINVAL);
|
2002-01-31 08:26:45 +00:00
|
|
|
#ifdef PC98
|
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
/* parameters are OK, convert them to the com struct and the device */
|
1996-06-14 10:04:54 +00:00
|
|
|
s = spltty();
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
2003-10-05 11:55:14 +00:00
|
|
|
if (t->c_ospeed == 0)
|
2000-05-12 12:38:25 +00:00
|
|
|
com_tiocm_bic(com, TIOCM_DTR|TIOCM_RTS|TIOCM_LE);
|
1997-12-29 16:08:48 +00:00
|
|
|
else
|
2000-05-12 12:38:25 +00:00
|
|
|
com_tiocm_bis(com, TIOCM_DTR|TIOCM_RTS|TIOCM_LE);
|
|
|
|
} else
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
2003-10-05 11:55:14 +00:00
|
|
|
if (t->c_ospeed == 0)
|
2004-06-26 04:00:46 +00:00
|
|
|
(void)commodem(tp, 0, SER_DTR); /* hang up line */
|
1996-06-14 10:04:54 +00:00
|
|
|
else
|
2004-06-26 04:00:46 +00:00
|
|
|
(void)commodem(tp, SER_DTR, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
cflag = t->c_cflag;
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (!IS_8251(com->pc98_if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
case CS5:
|
|
|
|
cfcr = CFCR_5BITS;
|
|
|
|
break;
|
|
|
|
case CS6:
|
|
|
|
cfcr = CFCR_6BITS;
|
|
|
|
break;
|
|
|
|
case CS7:
|
|
|
|
cfcr = CFCR_7BITS;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
cfcr = CFCR_8BITS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (cflag & PARENB) {
|
|
|
|
cfcr |= CFCR_PENAB;
|
|
|
|
if (!(cflag & PARODD))
|
|
|
|
cfcr |= CFCR_PEVEN;
|
|
|
|
}
|
|
|
|
if (cflag & CSTOPB)
|
|
|
|
cfcr |= CFCR_STOPB;
|
|
|
|
|
2003-10-05 11:55:14 +00:00
|
|
|
if (com->hasfifo) {
|
1996-06-14 10:04:54 +00:00
|
|
|
/*
|
|
|
|
* Use a fifo trigger level low enough so that the input
|
|
|
|
* latency from the fifo is less than about 16 msec and
|
|
|
|
* the total latency is less than about 30 msec. These
|
|
|
|
* latencies are reasonable for humans. Serial comms
|
|
|
|
* protocols shouldn't expect anything better since modem
|
|
|
|
* latencies are larger.
|
2002-01-06 09:54:50 +00:00
|
|
|
*
|
2003-10-05 11:55:14 +00:00
|
|
|
* The fifo trigger level cannot be set at RX_HIGH for high
|
|
|
|
* speed connections without further work on reducing
|
|
|
|
* interrupt disablement times in other parts of the system,
|
|
|
|
* without producing silo overflow errors.
|
1996-06-14 10:04:54 +00:00
|
|
|
*/
|
2002-04-06 06:19:10 +00:00
|
|
|
com->fifo_image = com->unit == siotsunit ? 0
|
2003-10-05 11:55:14 +00:00
|
|
|
: t->c_ispeed <= 4800
|
2002-01-06 09:54:50 +00:00
|
|
|
? FIFO_ENABLE : FIFO_ENABLE | FIFO_RX_MEDH;
|
1997-01-30 10:48:06 +00:00
|
|
|
#ifdef COM_ESP
|
|
|
|
/*
|
|
|
|
* The Hayes ESP card needs the fifo DMA mode bit set
|
|
|
|
* in compatibility mode. If not, it will interrupt
|
|
|
|
* for each character received.
|
|
|
|
*/
|
|
|
|
if (com->esp)
|
|
|
|
com->fifo_image |= FIFO_DMA_MODE;
|
|
|
|
#endif
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo, com->fifo_image);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-09-08 11:54:13 +00:00
|
|
|
/*
|
|
|
|
* This returns with interrupts disabled so that we can complete
|
|
|
|
* the speed change atomically. Keeping interrupts disabled is
|
|
|
|
* especially important while com_data is hidden.
|
|
|
|
*/
|
1999-02-05 11:37:40 +00:00
|
|
|
(void) siosetwater(com, t->c_ispeed);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
2000-05-12 12:38:25 +00:00
|
|
|
com_cflag_and_speed_set(com, cflag, t->c_ospeed);
|
1999-01-03 05:03:47 +00:00
|
|
|
else {
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
2003-10-05 11:55:14 +00:00
|
|
|
sio_setreg(com, com_cfcr, cfcr | CFCR_DLAB);
|
|
|
|
/*
|
|
|
|
* Only set the divisor registers if they would change, since on
|
|
|
|
* some 16550 incompatibles (UMC8669F), setting them while input
|
|
|
|
* is arriving loses sync until data stops arriving.
|
|
|
|
*/
|
|
|
|
dlbl = divisor & 0xFF;
|
|
|
|
if (sio_getreg(com, com_dlbl) != dlbl)
|
|
|
|
sio_setreg(com, com_dlbl, dlbl);
|
|
|
|
dlbh = divisor >> 8;
|
|
|
|
if (sio_getreg(com, com_dlbh) != dlbh)
|
|
|
|
sio_setreg(com, com_dlbh, dlbh);
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-01-03 05:03:47 +00:00
|
|
|
|
2003-10-05 11:55:14 +00:00
|
|
|
efr_flowbits = 0;
|
1998-01-16 11:20:22 +00:00
|
|
|
|
|
|
|
if (cflag & CRTS_IFLOW) {
|
1996-12-04 04:21:30 +00:00
|
|
|
com->state |= CS_RTS_IFLOW;
|
2003-10-05 11:55:14 +00:00
|
|
|
efr_flowbits |= EFR_AUTORTS;
|
1996-12-04 04:21:30 +00:00
|
|
|
/*
|
|
|
|
* If CS_RTS_IFLOW just changed from off to on, the change
|
|
|
|
* needs to be propagated to MCR_RTS. This isn't urgent,
|
|
|
|
* so do it later by calling comstart() instead of repeating
|
|
|
|
* a lot of code from comstart() here.
|
|
|
|
*/
|
|
|
|
} else if (com->state & CS_RTS_IFLOW) {
|
1996-06-14 10:04:54 +00:00
|
|
|
com->state &= ~CS_RTS_IFLOW;
|
1996-12-04 04:21:30 +00:00
|
|
|
/*
|
|
|
|
* CS_RTS_IFLOW just changed from on to off. Force MCR_RTS
|
|
|
|
* on here, since comstart() won't do it later.
|
|
|
|
*/
|
1997-03-06 15:07:04 +00:00
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type))
|
1997-03-06 15:07:04 +00:00
|
|
|
com_tiocm_bis(com, TIOCM_RTS);
|
|
|
|
else
|
2000-05-12 12:38:25 +00:00
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
|
|
|
#else
|
1996-12-04 04:21:30 +00:00
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
2000-05-12 12:38:25 +00:00
|
|
|
#endif
|
1996-12-04 04:21:30 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up state to handle output flow control.
|
|
|
|
* XXX - worth handling MDMBUF (DCD) flow control at the lowest level?
|
|
|
|
* Now has 10+ msec latency, while CTS flow has 50- usec latency.
|
|
|
|
*/
|
|
|
|
com->state |= CS_ODEVREADY;
|
|
|
|
com->state &= ~CS_CTS_OFLOW;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III) {
|
|
|
|
param = inb(com->rsabase + rsa_msr);
|
|
|
|
outb(com->rsabase + rsa_msr, param & 0x14);
|
|
|
|
}
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
if (cflag & CCTS_OFLOW) {
|
|
|
|
com->state |= CS_CTS_OFLOW;
|
2003-10-05 11:55:14 +00:00
|
|
|
efr_flowbits |= EFR_AUTOCTS;
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef PC98
|
1999-01-03 05:03:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
1996-06-14 10:04:54 +00:00
|
|
|
if (!(pc98_get_modem_status(com) & TIOCM_CTS))
|
|
|
|
com->state &= ~CS_ODEVREADY;
|
2003-10-05 11:55:14 +00:00
|
|
|
} else if (com->pc98_if_type == COM_IF_RSA98III) {
|
|
|
|
/* Set automatic flow control mode */
|
|
|
|
outb(com->rsabase + rsa_msr, param | 0x08);
|
|
|
|
} else
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
|
|
|
if (!(com->last_modem_status & MSR_CTS))
|
1998-01-16 11:20:22 +00:00
|
|
|
com->state &= ~CS_ODEVREADY;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1997-07-17 10:35:43 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
if (!IS_8251(com->pc98_if_type))
|
2003-10-05 11:55:14 +00:00
|
|
|
sio_setreg(com, com_cfcr, com->cfcr_image = cfcr);
|
|
|
|
#else
|
|
|
|
if (com->st16650a) {
|
|
|
|
sio_setreg(com, com_lcr, LCR_EFR_ENABLE);
|
|
|
|
sio_setreg(com, com_efr,
|
|
|
|
(sio_getreg(com, com_efr)
|
|
|
|
& ~(EFR_AUTOCTS | EFR_AUTORTS)) | efr_flowbits);
|
|
|
|
}
|
|
|
|
sio_setreg(com, com_cfcr, com->cfcr_image = cfcr);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1997-07-17 10:35:43 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/* XXX shouldn't call functions while intrs are disabled. */
|
2004-06-26 09:20:07 +00:00
|
|
|
ttyldoptim(tp);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
splx(s);
|
1996-12-04 04:21:30 +00:00
|
|
|
comstart(tp);
|
1999-02-05 11:37:40 +00:00
|
|
|
if (com->ibufold != NULL) {
|
|
|
|
free(com->ibufold, M_DEVBUF);
|
|
|
|
com->ibufold = NULL;
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2000-09-08 11:54:13 +00:00
|
|
|
/*
|
2001-01-27 13:02:06 +00:00
|
|
|
* This function must be called with the sio_lock mutex released and will
|
|
|
|
* return with it obtained.
|
2000-09-08 11:54:13 +00:00
|
|
|
*/
|
1999-02-05 11:37:40 +00:00
|
|
|
static int
|
|
|
|
siosetwater(com, speed)
|
|
|
|
struct com_s *com;
|
|
|
|
speed_t speed;
|
|
|
|
{
|
|
|
|
int cp4ticks;
|
|
|
|
u_char *ibuf;
|
|
|
|
int ibufsize;
|
|
|
|
struct tty *tp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make the buffer size large enough to handle a softtty interrupt
|
|
|
|
* latency of about 2 ticks without loss of throughput or data
|
|
|
|
* (about 3 ticks if input flow control is not used or not honoured,
|
|
|
|
* but a bit less for CS5-CS7 modes).
|
|
|
|
*/
|
|
|
|
cp4ticks = speed / 10 / hz * 4;
|
|
|
|
for (ibufsize = 128; ibufsize < cp4ticks;)
|
|
|
|
ibufsize <<= 1;
|
|
|
|
#ifdef PC98
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
ibufsize = 2048;
|
|
|
|
#endif
|
2000-09-08 11:54:13 +00:00
|
|
|
if (ibufsize == com->ibufsize) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
return (0);
|
2000-09-08 11:54:13 +00:00
|
|
|
}
|
1999-02-05 11:37:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate input buffer. The extra factor of 2 in the size is
|
|
|
|
* to allow for an error byte for each input byte.
|
|
|
|
*/
|
|
|
|
ibuf = malloc(2 * ibufsize, M_DEVBUF, M_NOWAIT);
|
2000-09-08 11:54:13 +00:00
|
|
|
if (ibuf == NULL) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
return (ENOMEM);
|
2000-09-08 11:54:13 +00:00
|
|
|
}
|
1999-02-05 11:37:40 +00:00
|
|
|
|
|
|
|
/* Initialize non-critical variables. */
|
|
|
|
com->ibufold = com->ibuf;
|
|
|
|
com->ibufsize = ibufsize;
|
|
|
|
tp = com->tp;
|
|
|
|
if (tp != NULL) {
|
|
|
|
tp->t_ififosize = 2 * ibufsize;
|
|
|
|
tp->t_ispeedwat = (speed_t)-1;
|
|
|
|
tp->t_ospeedwat = (speed_t)-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read current input buffer, if any. Continue with interrupts
|
|
|
|
* disabled.
|
|
|
|
*/
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1999-02-05 11:37:40 +00:00
|
|
|
if (com->iptr != com->ibuf)
|
|
|
|
sioinput(com);
|
|
|
|
|
|
|
|
/*-
|
|
|
|
* Initialize critical variables, including input buffer watermarks.
|
|
|
|
* The external device is asked to stop sending when the buffer
|
|
|
|
* exactly reaches high water, or when the high level requests it.
|
|
|
|
* The high level is notified immediately (rather than at a later
|
|
|
|
* clock tick) when this watermark is reached.
|
|
|
|
* The buffer size is chosen so the watermark should almost never
|
|
|
|
* be reached.
|
|
|
|
* The low watermark is invisibly 0 since the buffer is always
|
|
|
|
* emptied all at once.
|
|
|
|
*/
|
|
|
|
com->iptr = com->ibuf = ibuf;
|
|
|
|
com->ibufend = ibuf + ibufsize;
|
|
|
|
com->ierroff = ibufsize;
|
|
|
|
com->ihighwater = ibuf + 3 * ibufsize / 4;
|
1996-06-14 10:04:54 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
comstart(tp)
|
|
|
|
struct tty *tp;
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
int s;
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = tp->t_sc;
|
2000-03-12 13:14:51 +00:00
|
|
|
if (com == NULL)
|
|
|
|
return;
|
1996-06-14 10:04:54 +00:00
|
|
|
s = spltty();
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (tp->t_state & TS_TTSTOP)
|
|
|
|
com->state &= ~CS_TTGO;
|
|
|
|
else
|
|
|
|
com->state |= CS_TTGO;
|
|
|
|
if (tp->t_state & TS_TBLOCK) {
|
|
|
|
#ifdef PC98
|
1999-11-29 13:20:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
if ((com_tiocm_get(com) & TIOCM_RTS) &&
|
|
|
|
(com->state & CS_RTS_IFLOW))
|
|
|
|
com_tiocm_bic(com, TIOCM_RTS);
|
|
|
|
} else {
|
|
|
|
if ((com->mcr_image & MCR_RTS) &&
|
|
|
|
(com->state & CS_RTS_IFLOW))
|
|
|
|
outb(com->modem_ctl_port, com->mcr_image &= ~MCR_RTS);
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#else
|
|
|
|
if (com->mcr_image & MCR_RTS && com->state & CS_RTS_IFLOW)
|
|
|
|
outb(com->modem_ctl_port, com->mcr_image &= ~MCR_RTS);
|
1999-11-29 13:20:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
} else {
|
|
|
|
#ifdef PC98
|
1999-11-29 13:20:47 +00:00
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
if (!(com_tiocm_get(com) & TIOCM_RTS) &&
|
|
|
|
com->iptr < com->ihighwater &&
|
|
|
|
com->state & CS_RTS_IFLOW)
|
|
|
|
com_tiocm_bis(com, TIOCM_RTS);
|
|
|
|
} else {
|
|
|
|
if (!(com->mcr_image & MCR_RTS) &&
|
|
|
|
com->iptr < com->ihighwater &&
|
|
|
|
com->state & CS_RTS_IFLOW)
|
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#else
|
1996-12-04 04:21:30 +00:00
|
|
|
if (!(com->mcr_image & MCR_RTS) && com->iptr < com->ihighwater
|
|
|
|
&& com->state & CS_RTS_IFLOW)
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->modem_ctl_port, com->mcr_image |= MCR_RTS);
|
1999-11-29 13:20:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
|
1997-12-29 16:08:48 +00:00
|
|
|
ttwwakeup(tp);
|
1996-06-14 10:04:54 +00:00
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (tp->t_outq.c_cc != 0) {
|
|
|
|
struct lbq *qp;
|
|
|
|
struct lbq *next;
|
|
|
|
|
|
|
|
if (!com->obufs[0].l_queued) {
|
|
|
|
com->obufs[0].l_tail
|
|
|
|
= com->obuf1 + q_to_b(&tp->t_outq, com->obuf1,
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
1999-02-05 11:37:40 +00:00
|
|
|
com->obufsize);
|
2000-05-12 12:38:25 +00:00
|
|
|
#else
|
|
|
|
sizeof com->obuf1);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
com->obufs[0].l_next = NULL;
|
|
|
|
com->obufs[0].l_queued = TRUE;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (com->state & CS_BUSY) {
|
|
|
|
qp = com->obufq.l_next;
|
|
|
|
while ((next = qp->l_next) != NULL)
|
|
|
|
qp = next;
|
|
|
|
qp->l_next = &com->obufs[0];
|
|
|
|
} else {
|
|
|
|
com->obufq.l_head = com->obufs[0].l_head;
|
|
|
|
com->obufq.l_tail = com->obufs[0].l_tail;
|
|
|
|
com->obufq.l_next = &com->obufs[0];
|
|
|
|
com->state |= CS_BUSY;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
if (tp->t_outq.c_cc != 0 && !com->obufs[1].l_queued) {
|
|
|
|
com->obufs[1].l_tail
|
|
|
|
= com->obuf2 + q_to_b(&tp->t_outq, com->obuf2,
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
1999-02-05 11:37:40 +00:00
|
|
|
com->obufsize);
|
2000-05-12 12:38:25 +00:00
|
|
|
#else
|
|
|
|
sizeof com->obuf2);
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
com->obufs[1].l_next = NULL;
|
|
|
|
com->obufs[1].l_queued = TRUE;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (com->state & CS_BUSY) {
|
|
|
|
qp = com->obufq.l_next;
|
|
|
|
while ((next = qp->l_next) != NULL)
|
|
|
|
qp = next;
|
|
|
|
qp->l_next = &com->obufs[1];
|
|
|
|
} else {
|
|
|
|
com->obufq.l_head = com->obufs[1].l_head;
|
|
|
|
com->obufq.l_tail = com->obufs[1].l_tail;
|
|
|
|
com->obufq.l_next = &com->obufs[1];
|
|
|
|
com->state |= CS_BUSY;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
tp->t_state |= TS_BUSY;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (com->state >= (CS_BUSY | CS_TTGO))
|
|
|
|
siointr1(com); /* fake interrupt to start output */
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
ttwwakeup(tp);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
1999-09-25 16:21:39 +00:00
|
|
|
comstop(tp, rw)
|
1996-06-14 10:04:54 +00:00
|
|
|
struct tty *tp;
|
|
|
|
int rw;
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
|
|
|
int rsa98_tmp = 0;
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = tp->t_sc;
|
2000-03-12 13:14:51 +00:00
|
|
|
if (com == NULL || com->gone)
|
1996-06-14 10:04:54 +00:00
|
|
|
return;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (rw & FWRITE) {
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(com->pc98_if_type)) {
|
|
|
|
#endif
|
1996-12-04 04:36:59 +00:00
|
|
|
if (com->hasfifo)
|
1997-01-30 10:48:06 +00:00
|
|
|
#ifdef COM_ESP
|
|
|
|
/* XXX avoid h/w bug. */
|
|
|
|
if (!com->esp)
|
|
|
|
#endif
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo,
|
|
|
|
FIFO_XMT_RST | com->fifo_image);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
for (rsa98_tmp = 0; rsa98_tmp < 2048; rsa98_tmp++)
|
|
|
|
sio_setreg(com, com_fifo,
|
|
|
|
FIFO_XMT_RST | com->fifo_image);
|
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
com->obufs[0].l_queued = FALSE;
|
|
|
|
com->obufs[1].l_queued = FALSE;
|
|
|
|
if (com->state & CS_ODONE)
|
|
|
|
com_events -= LOTS_OF_EVENTS;
|
|
|
|
com->state &= ~(CS_ODONE | CS_BUSY);
|
|
|
|
com->tp->t_state &= ~TS_BUSY;
|
|
|
|
}
|
|
|
|
if (rw & FREAD) {
|
2000-05-12 12:38:25 +00:00
|
|
|
#ifdef PC98
|
|
|
|
if (!IS_8251(com->pc98_if_type)) {
|
|
|
|
if (com->pc98_if_type == COM_IF_RSA98III)
|
|
|
|
for (rsa98_tmp = 0; rsa98_tmp < 2048; rsa98_tmp++)
|
|
|
|
sio_getreg(com, com_data);
|
|
|
|
#endif
|
1996-12-04 04:36:59 +00:00
|
|
|
if (com->hasfifo)
|
1997-01-30 10:48:06 +00:00
|
|
|
#ifdef COM_ESP
|
|
|
|
/* XXX avoid h/w bug. */
|
|
|
|
if (!com->esp)
|
|
|
|
#endif
|
2000-05-12 12:38:25 +00:00
|
|
|
sio_setreg(com, com_fifo,
|
|
|
|
FIFO_RCV_RST | com->fifo_image);
|
1999-01-03 05:03:47 +00:00
|
|
|
#ifdef PC98
|
2000-05-12 12:38:25 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
com_events -= (com->iptr - com->ibuf);
|
|
|
|
com->iptr = com->ibuf;
|
|
|
|
}
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
comstart(tp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2004-10-15 08:22:37 +00:00
|
|
|
commodem(struct tty *tp, int sigon, int sigoff)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
2004-06-26 04:00:46 +00:00
|
|
|
struct com_s *com;
|
|
|
|
int bitand, bitor, msr;
|
|
|
|
#ifdef PC98
|
|
|
|
int clr, set;
|
|
|
|
#endif
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = tp->t_sc;
|
2004-06-26 04:00:46 +00:00
|
|
|
if (com->gone)
|
|
|
|
return(0);
|
|
|
|
if (sigon != 0 || sigoff != 0) {
|
|
|
|
#ifdef PC98
|
|
|
|
if (IS_8251(com->pc98_if_type)) {
|
|
|
|
bitand = bitor = 0;
|
|
|
|
clr = set = 0;
|
|
|
|
if (sigoff & SER_DTR) {
|
|
|
|
bitand |= TIOCM_DTR;
|
|
|
|
clr |= CMD8251_DTR;
|
|
|
|
}
|
|
|
|
if (sigoff & SER_RTS) {
|
|
|
|
bitand |= TIOCM_RTS;
|
|
|
|
clr |= CMD8251_RxEN | CMD8251_RTS;
|
|
|
|
}
|
|
|
|
if (sigon & SER_DTR) {
|
|
|
|
bitor |= TIOCM_DTR;
|
|
|
|
set |= CMD8251_TxEN | CMD8251_RxEN |
|
|
|
|
CMD8251_DTR;
|
|
|
|
}
|
|
|
|
if (sigon & SER_RTS) {
|
|
|
|
bitor |= TIOCM_RTS;
|
|
|
|
set |= CMD8251_TxEN | CMD8251_RxEN |
|
|
|
|
CMD8251_RTS;
|
|
|
|
}
|
|
|
|
bitand = ~bitand;
|
|
|
|
mtx_lock_spin(&sio_lock);
|
|
|
|
com->pc98_prev_modem_status &= bitand;
|
|
|
|
com->pc98_prev_modem_status |= bitor;
|
|
|
|
pc98_i8251_clear_or_cmd(com, clr, set);
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
|
|
|
return (0);
|
|
|
|
} else {
|
|
|
|
#endif
|
|
|
|
bitand = bitor = 0;
|
|
|
|
if (sigoff & SER_DTR)
|
|
|
|
bitand |= MCR_DTR;
|
|
|
|
if (sigoff & SER_RTS)
|
|
|
|
bitand |= MCR_RTS;
|
|
|
|
if (sigon & SER_DTR)
|
|
|
|
bitor |= MCR_DTR;
|
|
|
|
if (sigon & SER_RTS)
|
|
|
|
bitor |= MCR_RTS;
|
|
|
|
bitand = ~bitand;
|
|
|
|
mtx_lock_spin(&sio_lock);
|
|
|
|
com->mcr_image &= bitand;
|
|
|
|
com->mcr_image |= bitor;
|
|
|
|
outb(com->modem_ctl_port, com->mcr_image);
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
|
|
|
return (0);
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
#ifdef PC98
|
|
|
|
if (IS_8251(com->pc98_if_type))
|
|
|
|
return (com_tiocm_get(com));
|
|
|
|
else {
|
|
|
|
#endif
|
|
|
|
bitor = 0;
|
|
|
|
if (com->mcr_image & MCR_DTR)
|
|
|
|
bitor |= SER_DTR;
|
|
|
|
if (com->mcr_image & MCR_RTS)
|
|
|
|
bitor |= SER_RTS;
|
1996-06-14 10:04:54 +00:00
|
|
|
msr = com->prev_modem_status;
|
|
|
|
if (msr & MSR_CTS)
|
2004-06-26 04:00:46 +00:00
|
|
|
bitor |= SER_CTS;
|
1996-06-14 10:04:54 +00:00
|
|
|
if (msr & MSR_DCD)
|
2004-06-26 04:00:46 +00:00
|
|
|
bitor |= SER_DCD;
|
1996-06-14 10:04:54 +00:00
|
|
|
if (msr & MSR_DSR)
|
2004-06-26 04:00:46 +00:00
|
|
|
bitor |= SER_DSR;
|
|
|
|
if (msr & MSR_DSR)
|
|
|
|
bitor |= SER_DSR;
|
1996-06-14 10:04:54 +00:00
|
|
|
if (msr & (MSR_RI | MSR_TERI))
|
2004-06-26 04:00:46 +00:00
|
|
|
bitor |= SER_RI;
|
|
|
|
return (bitor);
|
|
|
|
#ifdef PC98
|
|
|
|
}
|
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
siosettimeout()
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
bool_t someopen;
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set our timeout period to 1 second if no polled devices are open.
|
|
|
|
* Otherwise set it to max(1/200, 1/hz).
|
|
|
|
* Enable timeouts iff some device is open.
|
|
|
|
*/
|
1997-09-22 12:23:49 +00:00
|
|
|
untimeout(comwakeup, (void *)NULL, sio_timeout_handle);
|
1996-06-14 10:04:54 +00:00
|
|
|
sio_timeout = hz;
|
|
|
|
someopen = FALSE;
|
1999-11-18 12:22:09 +00:00
|
|
|
for (unit = 0; unit < sio_numunits; ++unit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
com = com_addr(unit);
|
|
|
|
if (com != NULL && com->tp != NULL
|
|
|
|
&& com->tp->t_state & TS_ISOPEN && !com->gone) {
|
|
|
|
someopen = TRUE;
|
|
|
|
if (com->poll || com->poll_output) {
|
|
|
|
sio_timeout = hz > 200 ? hz / 200 : 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (someopen) {
|
|
|
|
sio_timeouts_until_log = hz / sio_timeout;
|
1997-09-22 12:23:49 +00:00
|
|
|
sio_timeout_handle = timeout(comwakeup, (void *)NULL,
|
|
|
|
sio_timeout);
|
1996-06-14 10:04:54 +00:00
|
|
|
} else {
|
|
|
|
/* Flush error messages, if any. */
|
|
|
|
sio_timeouts_until_log = 1;
|
|
|
|
comwakeup((void *)NULL);
|
1997-09-22 12:23:49 +00:00
|
|
|
untimeout(comwakeup, (void *)NULL, sio_timeout_handle);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
comwakeup(chan)
|
|
|
|
void *chan;
|
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
int unit;
|
|
|
|
|
1997-09-22 12:23:49 +00:00
|
|
|
sio_timeout_handle = timeout(comwakeup, (void *)NULL, sio_timeout);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Recover from lost output interrupts.
|
|
|
|
* Poll any lines that don't use interrupts.
|
|
|
|
*/
|
1999-11-18 12:22:09 +00:00
|
|
|
for (unit = 0; unit < sio_numunits; ++unit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
com = com_addr(unit);
|
|
|
|
if (com != NULL && !com->gone
|
|
|
|
&& (com->state >= (CS_BUSY | CS_TTGO) || com->poll)) {
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
siointr1(com);
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for and log errors, but not too often.
|
|
|
|
*/
|
|
|
|
if (--sio_timeouts_until_log > 0)
|
|
|
|
return;
|
|
|
|
sio_timeouts_until_log = hz / sio_timeout;
|
1999-11-18 12:22:09 +00:00
|
|
|
for (unit = 0; unit < sio_numunits; ++unit) {
|
1996-06-14 10:04:54 +00:00
|
|
|
int errnum;
|
|
|
|
|
|
|
|
com = com_addr(unit);
|
|
|
|
if (com == NULL)
|
|
|
|
continue;
|
|
|
|
if (com->gone)
|
|
|
|
continue;
|
|
|
|
for (errnum = 0; errnum < CE_NTYPES; ++errnum) {
|
|
|
|
u_int delta;
|
|
|
|
u_long total;
|
|
|
|
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_lock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
delta = com->delta_error_counts[errnum];
|
|
|
|
com->delta_error_counts[errnum] = 0;
|
Change and clean the mutex lock interface.
mtx_enter(lock, type) becomes:
mtx_lock(lock) for sleep locks (MTX_DEF-initialized locks)
mtx_lock_spin(lock) for spin locks (MTX_SPIN-initialized)
similarily, for releasing a lock, we now have:
mtx_unlock(lock) for MTX_DEF and mtx_unlock_spin(lock) for MTX_SPIN.
We change the caller interface for the two different types of locks
because the semantics are entirely different for each case, and this
makes it explicitly clear and, at the same time, it rids us of the
extra `type' argument.
The enter->lock and exit->unlock change has been made with the idea
that we're "locking data" and not "entering locked code" in mind.
Further, remove all additional "flags" previously passed to the
lock acquire/release routines with the exception of two:
MTX_QUIET and MTX_NOSWITCH
The functionality of these flags is preserved and they can be passed
to the lock/unlock routines by calling the corresponding wrappers:
mtx_{lock, unlock}_flags(lock, flag(s)) and
mtx_{lock, unlock}_spin_flags(lock, flag(s)) for MTX_DEF and MTX_SPIN
locks, respectively.
Re-inline some lock acq/rel code; in the sleep lock case, we only
inline the _obtain_lock()s in order to ensure that the inlined code
fits into a cache line. In the spin lock case, we inline recursion and
actually only perform a function call if we need to spin. This change
has been made with the idea that we generally tend to avoid spin locks
and that also the spin locks that we do have and are heavily used
(i.e. sched_lock) do recurse, and therefore in an effort to reduce
function call overhead for some architectures (such as alpha), we
inline recursion for this case.
Create a new malloc type for the witness code and retire from using
the M_DEV type. The new type is called M_WITNESS and is only declared
if WITNESS is enabled.
Begin cleaning up some machdep/mutex.h code - specifically updated the
"optimized" inlined code in alpha/mutex.h and wrote MTX_LOCK_SPIN
and MTX_UNLOCK_SPIN asm macros for the i386/mutex.h as we presently
need those.
Finally, caught up to the interface changes in all sys code.
Contributors: jake, jhb, jasone (in no particular order)
2001-02-09 06:11:45 +00:00
|
|
|
mtx_unlock_spin(&sio_lock);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (delta == 0)
|
|
|
|
continue;
|
|
|
|
total = com->error_counts[errnum] += delta;
|
|
|
|
log(LOG_ERR, "sio%d: %u more %s%s (total %lu)\n",
|
|
|
|
unit, delta, error_desc[errnum],
|
|
|
|
delta == 1 ? "" : "s", total);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
/* commint is called when modem control line changes */
|
|
|
|
static void
|
2004-06-16 09:47:26 +00:00
|
|
|
commint(struct cdev *dev)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
register struct tty *tp;
|
|
|
|
int stat,delta;
|
|
|
|
struct com_s *com;
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = dev->si_drv1;
|
1996-06-14 10:04:54 +00:00
|
|
|
tp = com->tp;
|
|
|
|
|
|
|
|
stat = com_tiocm_get(com);
|
|
|
|
delta = com_tiocm_get_delta(com);
|
|
|
|
|
|
|
|
if (com->state & CS_CTS_OFLOW) {
|
|
|
|
if (stat & TIOCM_CTS)
|
|
|
|
com->state |= CS_ODEVREADY;
|
|
|
|
else
|
|
|
|
com->state &= ~CS_ODEVREADY;
|
|
|
|
}
|
2004-10-13 08:27:20 +00:00
|
|
|
if ((delta & TIOCM_CAR) && (ISCALLOUT(dev)) == 0) {
|
1996-06-14 10:04:54 +00:00
|
|
|
if (stat & TIOCM_CAR )
|
2004-06-04 16:02:56 +00:00
|
|
|
(void)ttyld_modem(tp, 1);
|
|
|
|
else if (ttyld_modem(tp, 0) == 0) {
|
1996-06-14 10:04:54 +00:00
|
|
|
/* negate DTR, RTS */
|
|
|
|
com_tiocm_bic(com, (tp->t_cflag & HUPCL) ?
|
|
|
|
TIOCM_DTR|TIOCM_RTS|TIOCM_LE : TIOCM_LE );
|
|
|
|
/* disable IENABLE */
|
|
|
|
com_int_TxRx_disable( com );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Following are all routines needed for SIO to act as console
|
|
|
|
*/
|
|
|
|
struct siocnstate {
|
|
|
|
u_char dlbl;
|
|
|
|
u_char dlbh;
|
|
|
|
u_char ier;
|
|
|
|
u_char cfcr;
|
|
|
|
u_char mcr;
|
|
|
|
};
|
|
|
|
|
2003-09-26 19:35:50 +00:00
|
|
|
/*
|
|
|
|
* This is a function in order to not replicate "ttyd%d" more
|
|
|
|
* places than absolutely necessary.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
siocnset(struct consdev *cd, int unit)
|
|
|
|
{
|
|
|
|
|
|
|
|
cd->cn_unit = unit;
|
|
|
|
sprintf(cd->cn_name, "ttyd%d", unit);
|
|
|
|
}
|
|
|
|
|
2002-03-20 12:22:31 +00:00
|
|
|
static speed_t siocngetspeed(Port_t, u_long rclk);
|
|
|
|
static void siocnclose(struct siocnstate *sp, Port_t iobase);
|
|
|
|
static void siocnopen(struct siocnstate *sp, Port_t iobase, int speed);
|
|
|
|
static void siocntxwait(Port_t iobase);
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2006-05-26 13:33:28 +00:00
|
|
|
static cn_probe_t sio_cnprobe;
|
|
|
|
static cn_init_t sio_cninit;
|
|
|
|
static cn_term_t sio_cnterm;
|
|
|
|
static cn_getc_t sio_cngetc;
|
|
|
|
static cn_putc_t sio_cnputc;
|
1999-01-08 16:09:23 +00:00
|
|
|
|
2006-05-26 13:33:28 +00:00
|
|
|
CONSOLE_DRIVER(sio);
|
1999-04-18 14:42:20 +00:00
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
static void
|
1999-04-18 14:42:20 +00:00
|
|
|
siocntxwait(iobase)
|
|
|
|
Port_t iobase;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
int timo;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for any pending transmission to finish. Required to avoid
|
|
|
|
* the UART lockup bug when the speed is changed, and for normal
|
|
|
|
* transmits.
|
|
|
|
*/
|
|
|
|
timo = 100000;
|
1999-04-18 14:42:20 +00:00
|
|
|
while ((inb(iobase + com_lsr) & (LSR_TSRE | LSR_TXRDY))
|
1996-06-14 10:04:54 +00:00
|
|
|
!= (LSR_TSRE | LSR_TXRDY) && --timo != 0)
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
1997-06-04 10:27:53 +00:00
|
|
|
/*
|
|
|
|
* Read the serial port specified and try to figure out what speed
|
|
|
|
* it's currently running at. We're assuming the serial port has
|
|
|
|
* been initialized and is basicly idle. This routine is only intended
|
|
|
|
* to be run at system startup.
|
|
|
|
*
|
|
|
|
* If the value read from the serial port doesn't make sense, return 0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static speed_t
|
2002-01-31 08:26:45 +00:00
|
|
|
siocngetspeed(iobase, rclk)
|
|
|
|
Port_t iobase;
|
|
|
|
u_long rclk;
|
1997-06-04 10:27:53 +00:00
|
|
|
{
|
2002-01-31 08:26:45 +00:00
|
|
|
u_int divisor;
|
1997-06-04 10:27:53 +00:00
|
|
|
u_char dlbh;
|
|
|
|
u_char dlbl;
|
|
|
|
u_char cfcr;
|
|
|
|
|
|
|
|
cfcr = inb(iobase + com_cfcr);
|
|
|
|
outb(iobase + com_cfcr, CFCR_DLAB | cfcr);
|
|
|
|
|
|
|
|
dlbl = inb(iobase + com_dlbl);
|
|
|
|
dlbh = inb(iobase + com_dlbh);
|
|
|
|
|
|
|
|
outb(iobase + com_cfcr, cfcr);
|
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
divisor = dlbh << 8 | dlbl;
|
1997-06-04 10:27:53 +00:00
|
|
|
|
2002-01-31 08:26:45 +00:00
|
|
|
/* XXX there should be more sanity checking. */
|
|
|
|
if (divisor == 0)
|
|
|
|
return (CONSPEED);
|
|
|
|
return (rclk / (16UL * divisor));
|
1997-06-04 10:27:53 +00:00
|
|
|
}
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
static void
|
1999-04-18 14:42:20 +00:00
|
|
|
siocnopen(sp, iobase, speed)
|
1996-06-14 10:04:54 +00:00
|
|
|
struct siocnstate *sp;
|
1999-04-18 14:42:20 +00:00
|
|
|
Port_t iobase;
|
|
|
|
int speed;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
2002-01-31 08:26:45 +00:00
|
|
|
u_int divisor;
|
1996-10-09 21:47:16 +00:00
|
|
|
u_char dlbh;
|
|
|
|
u_char dlbl;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Save all the device control registers except the fifo register
|
1996-12-04 04:36:59 +00:00
|
|
|
* and set our default ones (cs8 -parenb speed=comdefaultrate).
|
1996-06-14 10:04:54 +00:00
|
|
|
* We can't save the fifo register since it is read-only.
|
|
|
|
*/
|
|
|
|
sp->ier = inb(iobase + com_ier);
|
|
|
|
outb(iobase + com_ier, 0); /* spltty() doesn't stop siointr() */
|
1999-04-18 14:42:20 +00:00
|
|
|
siocntxwait(iobase);
|
1996-06-14 10:04:54 +00:00
|
|
|
sp->cfcr = inb(iobase + com_cfcr);
|
1996-10-09 21:47:16 +00:00
|
|
|
outb(iobase + com_cfcr, CFCR_DLAB | CFCR_8BITS);
|
1996-06-14 10:04:54 +00:00
|
|
|
sp->dlbl = inb(iobase + com_dlbl);
|
|
|
|
sp->dlbh = inb(iobase + com_dlbh);
|
1996-10-09 21:47:16 +00:00
|
|
|
/*
|
|
|
|
* Only set the divisor registers if they would change, since on
|
|
|
|
* some 16550 incompatibles (Startech), setting them clears the
|
|
|
|
* data input register. This also reduces the effects of the
|
|
|
|
* UMC8669F bug.
|
|
|
|
*/
|
2002-01-31 08:26:45 +00:00
|
|
|
divisor = siodivisor(comdefaultrclk, speed);
|
1996-10-09 21:47:16 +00:00
|
|
|
dlbl = divisor & 0xFF;
|
|
|
|
if (sp->dlbl != dlbl)
|
|
|
|
outb(iobase + com_dlbl, dlbl);
|
2002-01-31 08:26:45 +00:00
|
|
|
dlbh = divisor >> 8;
|
1996-10-09 21:47:16 +00:00
|
|
|
if (sp->dlbh != dlbh)
|
|
|
|
outb(iobase + com_dlbh, dlbh);
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(iobase + com_cfcr, CFCR_8BITS);
|
|
|
|
sp->mcr = inb(iobase + com_mcr);
|
|
|
|
/*
|
|
|
|
* We don't want interrupts, but must be careful not to "disable"
|
|
|
|
* them by clearing the MCR_IENABLE bit, since that might cause
|
|
|
|
* an interrupt by floating the IRQ line.
|
|
|
|
*/
|
|
|
|
outb(iobase + com_mcr, (sp->mcr & MCR_IENABLE) | MCR_DTR | MCR_RTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
1999-04-18 14:42:20 +00:00
|
|
|
siocnclose(sp, iobase)
|
1996-06-14 10:04:54 +00:00
|
|
|
struct siocnstate *sp;
|
1999-04-18 14:42:20 +00:00
|
|
|
Port_t iobase;
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Restore the device control registers.
|
|
|
|
*/
|
1999-04-18 14:42:20 +00:00
|
|
|
siocntxwait(iobase);
|
1996-10-09 21:47:16 +00:00
|
|
|
outb(iobase + com_cfcr, CFCR_DLAB | CFCR_8BITS);
|
|
|
|
if (sp->dlbl != inb(iobase + com_dlbl))
|
|
|
|
outb(iobase + com_dlbl, sp->dlbl);
|
|
|
|
if (sp->dlbh != inb(iobase + com_dlbh))
|
|
|
|
outb(iobase + com_dlbh, sp->dlbh);
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(iobase + com_cfcr, sp->cfcr);
|
|
|
|
/*
|
|
|
|
* XXX damp oscillations of MCR_DTR and MCR_RTS by not restoring them.
|
|
|
|
*/
|
|
|
|
outb(iobase + com_mcr, sp->mcr | MCR_DTR | MCR_RTS);
|
|
|
|
outb(iobase + com_ier, sp->ier);
|
|
|
|
}
|
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
static void
|
2006-05-26 13:33:28 +00:00
|
|
|
sio_cnprobe(cp)
|
1996-06-14 10:04:54 +00:00
|
|
|
struct consdev *cp;
|
|
|
|
{
|
1997-12-29 16:08:48 +00:00
|
|
|
speed_t boot_speed;
|
|
|
|
u_char cfcr;
|
2002-01-31 08:26:45 +00:00
|
|
|
u_int divisor;
|
2004-05-06 13:16:45 +00:00
|
|
|
int s, unit;
|
1997-04-05 15:04:32 +00:00
|
|
|
struct siocnstate sp;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1997-04-05 15:04:32 +00:00
|
|
|
/*
|
|
|
|
* Find our first enabled console, if any. If it is a high-level
|
|
|
|
* console device, then initialize it and return successfully.
|
|
|
|
* If it is a low-level console device, then initialize it and
|
|
|
|
* return unsuccessfully. It must be initialized in both cases
|
|
|
|
* for early use by console drivers and debuggers. Initializing
|
|
|
|
* the hardware is not necessary in all cases, since the i/o
|
|
|
|
* routines initialize it on the fly, but it is necessary if
|
|
|
|
* input might arrive while the hardware is switched back to an
|
|
|
|
* uninitialized state. We can't handle multiple console devices
|
|
|
|
* yet because our low-level routines don't take a device arg.
|
|
|
|
* We trust the user to set the console flags properly so that we
|
|
|
|
* don't need to probe.
|
|
|
|
*/
|
|
|
|
cp->cn_pri = CN_DEAD;
|
1999-04-18 14:42:20 +00:00
|
|
|
|
2004-05-06 13:16:45 +00:00
|
|
|
for (unit = 0; unit < 16; unit++) { /* XXX need to know how many */
|
|
|
|
int flags;
|
2003-10-05 11:55:14 +00:00
|
|
|
|
2004-05-06 13:16:45 +00:00
|
|
|
if (resource_disabled("sio", unit))
|
|
|
|
continue;
|
|
|
|
if (resource_int_value("sio", unit, "flags", &flags))
|
|
|
|
continue;
|
|
|
|
if (COM_CONSOLE(flags) || COM_DEBUGGER(flags)) {
|
|
|
|
int port;
|
|
|
|
Port_t iobase;
|
2004-05-01 06:46:10 +00:00
|
|
|
|
2004-05-06 13:16:45 +00:00
|
|
|
if (resource_int_value("sio", unit, "port", &port))
|
|
|
|
continue;
|
|
|
|
iobase = port;
|
|
|
|
s = spltty();
|
2008-02-29 05:09:15 +00:00
|
|
|
if ((boothowto & RB_SERIAL) && COM_CONSOLE(flags)) {
|
2004-05-06 13:16:45 +00:00
|
|
|
boot_speed =
|
|
|
|
siocngetspeed(iobase, comdefaultrclk);
|
|
|
|
if (boot_speed)
|
|
|
|
comdefaultrate = boot_speed;
|
1997-06-04 10:27:53 +00:00
|
|
|
}
|
1997-12-29 16:08:48 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize the divisor latch. We can't rely on
|
|
|
|
* siocnopen() to do this the first time, since it
|
|
|
|
* avoids writing to the latch if the latch appears
|
|
|
|
* to have the correct value. Also, if we didn't
|
|
|
|
* just read the speed from the hardware, then we
|
|
|
|
* need to set the speed in hardware so that
|
|
|
|
* switching it later is null.
|
|
|
|
*/
|
2004-05-06 13:16:45 +00:00
|
|
|
cfcr = inb(iobase + com_cfcr);
|
|
|
|
outb(iobase + com_cfcr, CFCR_DLAB | cfcr);
|
|
|
|
divisor = siodivisor(comdefaultrclk, comdefaultrate);
|
|
|
|
outb(iobase + com_dlbl, divisor & 0xff);
|
|
|
|
outb(iobase + com_dlbh, divisor >> 8);
|
|
|
|
outb(iobase + com_cfcr, cfcr);
|
|
|
|
|
|
|
|
siocnopen(&sp, iobase, comdefaultrate);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
if (COM_CONSOLE(flags) && !COM_LLCONSOLE(flags)) {
|
|
|
|
siocnset(cp, unit);
|
|
|
|
cp->cn_pri = COM_FORCECONSOLE(flags)
|
|
|
|
|| boothowto & RB_SERIAL
|
|
|
|
? CN_REMOTE : CN_NORMAL;
|
|
|
|
siocniobase = iobase;
|
|
|
|
siocnunit = unit;
|
|
|
|
}
|
2004-07-10 22:29:41 +00:00
|
|
|
#ifdef GDB
|
|
|
|
if (COM_DEBUGGER(flags))
|
2004-05-06 13:16:45 +00:00
|
|
|
siogdbiobase = iobase;
|
1999-05-09 05:00:54 +00:00
|
|
|
#endif
|
1997-04-05 15:04:32 +00:00
|
|
|
}
|
1999-04-18 14:42:20 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
2000-09-22 12:56:55 +00:00
|
|
|
static void
|
2006-05-26 13:33:28 +00:00
|
|
|
sio_cninit(cp)
|
2000-09-22 12:56:55 +00:00
|
|
|
struct consdev *cp;
|
|
|
|
{
|
2003-09-26 19:35:50 +00:00
|
|
|
comconsole = cp->cn_unit;
|
2000-09-22 12:56:55 +00:00
|
|
|
}
|
|
|
|
|
2001-11-26 12:29:53 +00:00
|
|
|
static void
|
2006-05-26 13:33:28 +00:00
|
|
|
sio_cnterm(cp)
|
2001-11-26 12:29:53 +00:00
|
|
|
struct consdev *cp;
|
|
|
|
{
|
|
|
|
comconsole = -1;
|
|
|
|
}
|
|
|
|
|
1999-09-12 13:44:54 +00:00
|
|
|
static int
|
2006-05-26 13:33:28 +00:00
|
|
|
sio_cngetc(struct consdev *cd)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
int c;
|
|
|
|
Port_t iobase;
|
|
|
|
int s;
|
|
|
|
struct siocnstate sp;
|
2002-06-18 21:30:37 +00:00
|
|
|
speed_t speed;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
if (cd != NULL && cd->cn_unit == siocnunit) {
|
1999-05-09 05:00:54 +00:00
|
|
|
iobase = siocniobase;
|
2002-06-18 21:30:37 +00:00
|
|
|
speed = comdefaultrate;
|
|
|
|
} else {
|
2004-07-10 22:29:41 +00:00
|
|
|
#ifdef GDB
|
2002-06-18 21:30:37 +00:00
|
|
|
iobase = siogdbiobase;
|
|
|
|
speed = gdbdefaultrate;
|
2004-07-10 22:29:41 +00:00
|
|
|
#else
|
|
|
|
return (-1);
|
|
|
|
#endif
|
2002-06-18 21:30:37 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
s = spltty();
|
2002-06-18 21:30:37 +00:00
|
|
|
siocnopen(&sp, iobase, speed);
|
1996-06-14 10:04:54 +00:00
|
|
|
if (inb(iobase + com_lsr) & LSR_RXRDY)
|
|
|
|
c = inb(iobase + com_data);
|
|
|
|
else
|
1996-10-09 21:47:16 +00:00
|
|
|
c = -1;
|
1999-04-18 14:42:20 +00:00
|
|
|
siocnclose(&sp, iobase);
|
1996-06-14 10:04:54 +00:00
|
|
|
splx(s);
|
|
|
|
return (c);
|
|
|
|
}
|
|
|
|
|
2002-09-29 11:41:48 +00:00
|
|
|
static void
|
2006-05-26 13:33:28 +00:00
|
|
|
sio_cnputc(struct consdev *cd, int c)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
2002-01-06 09:54:50 +00:00
|
|
|
int need_unlock;
|
1996-06-14 10:04:54 +00:00
|
|
|
int s;
|
|
|
|
struct siocnstate sp;
|
1999-05-09 05:00:54 +00:00
|
|
|
Port_t iobase;
|
2002-06-19 13:20:20 +00:00
|
|
|
speed_t speed;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
if (cd != NULL && cd->cn_unit == siocnunit) {
|
1999-05-09 05:00:54 +00:00
|
|
|
iobase = siocniobase;
|
2002-06-18 21:30:37 +00:00
|
|
|
speed = comdefaultrate;
|
|
|
|
} else {
|
2004-07-10 22:29:41 +00:00
|
|
|
#ifdef GDB
|
2002-06-18 21:30:37 +00:00
|
|
|
iobase = siogdbiobase;
|
|
|
|
speed = gdbdefaultrate;
|
2004-07-10 22:29:41 +00:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
#endif
|
2002-06-18 21:30:37 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
s = spltty();
|
2002-01-06 09:54:50 +00:00
|
|
|
need_unlock = 0;
|
2005-02-11 03:41:34 +00:00
|
|
|
if (!kdb_active && sio_inited == 2 && !mtx_owned(&sio_lock)) {
|
|
|
|
mtx_lock_spin(&sio_lock);
|
|
|
|
need_unlock = 1;
|
2002-01-06 09:54:50 +00:00
|
|
|
}
|
2002-06-18 21:30:37 +00:00
|
|
|
siocnopen(&sp, iobase, speed);
|
1999-05-09 05:00:54 +00:00
|
|
|
siocntxwait(iobase);
|
|
|
|
outb(iobase + com_data, c);
|
|
|
|
siocnclose(&sp, iobase);
|
2005-02-11 03:41:34 +00:00
|
|
|
if (need_unlock)
|
|
|
|
mtx_unlock_spin(&sio_lock);
|
1999-04-18 14:42:20 +00:00
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
/*
|
|
|
|
* Remote gdb(1) support.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if defined(GDB)
|
|
|
|
|
|
|
|
#include <gdb/gdb.h>
|
|
|
|
|
|
|
|
static gdb_probe_f siogdbprobe;
|
|
|
|
static gdb_init_f siogdbinit;
|
|
|
|
static gdb_term_f siogdbterm;
|
|
|
|
static gdb_getc_f siogdbgetc;
|
|
|
|
static gdb_putc_f siogdbputc;
|
|
|
|
|
2006-05-26 13:33:28 +00:00
|
|
|
GDB_DBGPORT(sio, siogdbprobe, siogdbinit, siogdbterm, siogdbgetc, siogdbputc);
|
2004-07-10 22:29:41 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
siogdbprobe(void)
|
1999-04-18 14:42:20 +00:00
|
|
|
{
|
2004-07-10 22:29:41 +00:00
|
|
|
return ((siogdbiobase != 0) ? 0 : -1);
|
|
|
|
}
|
1999-04-18 14:42:20 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
static void
|
|
|
|
siogdbinit(void)
|
|
|
|
{
|
|
|
|
}
|
2002-06-19 13:20:20 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
static void
|
|
|
|
siogdbterm(void)
|
|
|
|
{
|
1999-04-18 14:42:20 +00:00
|
|
|
}
|
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
static void
|
|
|
|
siogdbputc(int c)
|
1999-04-18 14:42:20 +00:00
|
|
|
{
|
2006-05-27 04:40:41 +00:00
|
|
|
sio_cnputc(NULL, c);
|
2004-07-10 22:29:41 +00:00
|
|
|
}
|
2002-06-19 13:20:20 +00:00
|
|
|
|
2004-07-10 22:29:41 +00:00
|
|
|
static int
|
|
|
|
siogdbgetc(void)
|
|
|
|
{
|
2006-05-27 04:40:41 +00:00
|
|
|
return (sio_cngetc(NULL));
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
2004-07-10 22:29:41 +00:00
|
|
|
|
1999-04-19 11:11:01 +00:00
|
|
|
#endif
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
#ifdef PC98
|
|
|
|
/*
|
|
|
|
* pc98 local function
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
com_tiocm_bis(struct com_s *com, int msr)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
int tmp = 0;
|
|
|
|
|
|
|
|
s=spltty();
|
|
|
|
com->pc98_prev_modem_status |= ( msr & (TIOCM_LE|TIOCM_DTR|TIOCM_RTS) );
|
|
|
|
tmp |= CMD8251_TxEN|CMD8251_RxEN;
|
|
|
|
if ( msr & TIOCM_DTR ) tmp |= CMD8251_DTR;
|
|
|
|
if ( msr & TIOCM_RTS ) tmp |= CMD8251_RTS;
|
|
|
|
|
|
|
|
pc98_i8251_or_cmd( com, tmp );
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
com_tiocm_bic(struct com_s *com, int msr)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
int tmp = msr;
|
|
|
|
|
|
|
|
s=spltty();
|
|
|
|
com->pc98_prev_modem_status &= ~( msr & (TIOCM_LE|TIOCM_DTR|TIOCM_RTS) );
|
|
|
|
if ( msr & TIOCM_DTR ) tmp |= CMD8251_DTR;
|
|
|
|
if ( msr & TIOCM_RTS ) tmp |= CMD8251_RTS;
|
|
|
|
|
|
|
|
pc98_i8251_clear_cmd( com, tmp );
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
com_tiocm_get(struct com_s *com)
|
|
|
|
{
|
|
|
|
return( com->pc98_prev_modem_status );
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
com_tiocm_get_delta(struct com_s *com)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
tmp = com->pc98_modem_delta;
|
|
|
|
com->pc98_modem_delta = 0;
|
|
|
|
return( tmp );
|
|
|
|
}
|
|
|
|
|
|
|
|
/* convert to TIOCM_?? ( ioctl.h ) */
|
|
|
|
static int
|
|
|
|
pc98_get_modem_status(struct com_s *com)
|
|
|
|
{
|
|
|
|
register int msr;
|
|
|
|
|
|
|
|
msr = com->pc98_prev_modem_status
|
|
|
|
& ~(TIOCM_CAR|TIOCM_RI|TIOCM_DSR|TIOCM_CTS);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable) {
|
|
|
|
int stat2;
|
|
|
|
|
|
|
|
stat2 = inb(I8251F_msr);
|
2008-09-07 04:35:04 +00:00
|
|
|
if ( stat2 & MSR_DCD ) msr |= TIOCM_CAR;
|
|
|
|
if ( stat2 & MSR_RI ) msr |= TIOCM_RI;
|
|
|
|
if ( stat2 & MSR_DSR ) msr |= TIOCM_DSR;
|
|
|
|
if ( stat2 & MSR_CTS ) msr |= TIOCM_CTS;
|
1996-06-14 10:04:54 +00:00
|
|
|
#if COM_CARRIER_DETECT_EMULATE
|
1999-12-06 00:23:38 +00:00
|
|
|
if ( msr & (TIOCM_DSR|TIOCM_CTS) ) {
|
|
|
|
msr |= TIOCM_CAR;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
int stat, stat2;
|
|
|
|
|
|
|
|
stat = inb(com->sts_port);
|
|
|
|
stat2 = inb(com->in_modem_port);
|
|
|
|
if ( !(stat2 & CICSCD_CD) ) msr |= TIOCM_CAR;
|
|
|
|
if ( !(stat2 & CICSCD_CI) ) msr |= TIOCM_RI;
|
|
|
|
if ( stat & STS8251_DSR ) msr |= TIOCM_DSR;
|
|
|
|
if ( !(stat2 & CICSCD_CS) ) msr |= TIOCM_CTS;
|
|
|
|
#if COM_CARRIER_DETECT_EMULATE
|
|
|
|
if ( msr & (TIOCM_DSR|TIOCM_CTS) ) {
|
|
|
|
msr |= TIOCM_CAR;
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-12-06 00:23:38 +00:00
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
return(msr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_check_msr(void* chan)
|
|
|
|
{
|
|
|
|
int msr, delta;
|
|
|
|
int s;
|
|
|
|
register struct tty *tp;
|
|
|
|
struct com_s *com;
|
2004-06-16 09:47:26 +00:00
|
|
|
struct cdev *dev;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2004-06-16 09:47:26 +00:00
|
|
|
dev=(struct cdev *)chan;
|
2004-09-17 10:59:17 +00:00
|
|
|
com = dev->si_drv1;
|
|
|
|
tp = dev->si_tty;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
s = spltty();
|
|
|
|
msr = pc98_get_modem_status(com);
|
|
|
|
/* make change flag */
|
|
|
|
delta = msr ^ com->pc98_prev_modem_status;
|
|
|
|
if ( delta & TIOCM_CAR ) {
|
|
|
|
if ( com->modem_car_chg_timer ) {
|
|
|
|
if ( -- com->modem_car_chg_timer )
|
|
|
|
msr ^= TIOCM_CAR;
|
|
|
|
} else {
|
1999-02-02 17:26:03 +00:00
|
|
|
if ((com->modem_car_chg_timer = (msr & TIOCM_CAR) ?
|
|
|
|
DCD_ON_RECOGNITION : DCD_OFF_TOLERANCE) != 0)
|
1996-06-14 10:04:54 +00:00
|
|
|
msr ^= TIOCM_CAR;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
com->modem_car_chg_timer = 0;
|
|
|
|
delta = ( msr ^ com->pc98_prev_modem_status ) &
|
|
|
|
(TIOCM_CAR|TIOCM_RI|TIOCM_DSR|TIOCM_CTS);
|
|
|
|
com->pc98_prev_modem_status = msr;
|
|
|
|
delta = ( com->pc98_modem_delta |= delta );
|
|
|
|
splx(s);
|
|
|
|
if ( com->modem_checking || (tp->t_state & (TS_ISOPEN)) ) {
|
|
|
|
if ( delta ) {
|
|
|
|
commint(dev);
|
|
|
|
}
|
|
|
|
timeout(pc98_check_msr, (caddr_t)dev,
|
|
|
|
PC98_CHECK_MODEM_INTERVAL);
|
|
|
|
} else {
|
|
|
|
com->modem_checking = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-06-16 09:47:26 +00:00
|
|
|
pc98_msrint_start(struct cdev *dev)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
|
|
|
struct com_s *com;
|
|
|
|
int s = spltty();
|
|
|
|
|
2004-09-17 10:59:17 +00:00
|
|
|
com = dev->si_drv1;
|
1996-06-14 10:04:54 +00:00
|
|
|
/* modem control line check routine envoke interval is 1/10 sec */
|
|
|
|
if ( com->modem_checking == 0 ) {
|
|
|
|
com->pc98_prev_modem_status = pc98_get_modem_status(com);
|
|
|
|
com->pc98_modem_delta = 0;
|
|
|
|
timeout(pc98_check_msr, (caddr_t)dev,
|
|
|
|
PC98_CHECK_MODEM_INTERVAL);
|
|
|
|
com->modem_checking = 1;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_disable_i8251_interrupt(struct com_s *com, int mod)
|
|
|
|
{
|
|
|
|
/* disable interrupt */
|
|
|
|
register int tmp;
|
|
|
|
|
|
|
|
mod |= ~(IEN_Tx|IEN_TxEMP|IEN_Rx);
|
|
|
|
COM_INT_DISABLE
|
|
|
|
tmp = inb( com->intr_ctrl_port ) & ~(IEN_Tx|IEN_TxEMP|IEN_Rx);
|
|
|
|
outb( com->intr_ctrl_port, (com->intr_enable&=~mod) | tmp );
|
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_enable_i8251_interrupt(struct com_s *com, int mod)
|
|
|
|
{
|
|
|
|
register int tmp;
|
|
|
|
|
|
|
|
COM_INT_DISABLE
|
|
|
|
tmp = inb( com->intr_ctrl_port ) & ~(IEN_Tx|IEN_TxEMP|IEN_Rx);
|
|
|
|
outb( com->intr_ctrl_port, (com->intr_enable|=mod) | tmp );
|
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pc98_check_i8251_interrupt(struct com_s *com)
|
|
|
|
{
|
|
|
|
return ( com->intr_enable & 0x07 );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_i8251_clear_cmd(struct com_s *com, int x)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
COM_INT_DISABLE
|
|
|
|
tmp = com->pc98_prev_siocmd & ~(x);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
outb(I8251F_fcr, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->cmd_port, tmp);
|
|
|
|
com->pc98_prev_siocmd = tmp & ~(CMD8251_ER|CMD8251_RESET|CMD8251_EH);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_ENABLE);
|
1996-06-14 10:04:54 +00:00
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_i8251_or_cmd(struct com_s *com, int x)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
COM_INT_DISABLE
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
outb(I8251F_fcr, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
tmp = com->pc98_prev_siocmd | (x);
|
|
|
|
outb(com->cmd_port, tmp);
|
|
|
|
com->pc98_prev_siocmd = tmp & ~(CMD8251_ER|CMD8251_RESET|CMD8251_EH);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_ENABLE);
|
1996-06-14 10:04:54 +00:00
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_i8251_set_cmd(struct com_s *com, int x)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
COM_INT_DISABLE
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
outb(I8251F_fcr, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
tmp = (x);
|
|
|
|
outb(com->cmd_port, tmp);
|
|
|
|
com->pc98_prev_siocmd = tmp & ~(CMD8251_ER|CMD8251_RESET|CMD8251_EH);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_ENABLE);
|
1996-06-14 10:04:54 +00:00
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_i8251_clear_or_cmd(struct com_s *com, int clr, int x)
|
|
|
|
{
|
|
|
|
int tmp;
|
|
|
|
COM_INT_DISABLE
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
outb(I8251F_fcr, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
tmp = com->pc98_prev_siocmd & ~(clr);
|
|
|
|
tmp |= (x);
|
|
|
|
outb(com->cmd_port, tmp);
|
|
|
|
com->pc98_prev_siocmd = tmp & ~(CMD8251_ER|CMD8251_RESET|CMD8251_EH);
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_ENABLE);
|
1996-06-14 10:04:54 +00:00
|
|
|
COM_INT_ENABLE
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pc98_i8251_get_cmd(struct com_s *com)
|
|
|
|
{
|
|
|
|
return com->pc98_prev_siocmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
pc98_i8251_get_mod(struct com_s *com)
|
|
|
|
{
|
|
|
|
return com->pc98_prev_siomod;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_i8251_reset(struct com_s *com, int mode, int command)
|
|
|
|
{
|
1999-12-06 00:23:38 +00:00
|
|
|
if (com->pc98_8251fifo_enable)
|
|
|
|
outb(I8251F_fcr, 0);
|
1996-06-14 10:04:54 +00:00
|
|
|
outb(com->cmd_port, 0); /* dummy */
|
|
|
|
DELAY(2);
|
|
|
|
outb(com->cmd_port, 0); /* dummy */
|
|
|
|
DELAY(2);
|
|
|
|
outb(com->cmd_port, 0); /* dummy */
|
|
|
|
DELAY(2);
|
|
|
|
outb(com->cmd_port, CMD8251_RESET); /* internal reset */
|
|
|
|
DELAY(2);
|
|
|
|
outb(com->cmd_port, mode ); /* mode register */
|
|
|
|
com->pc98_prev_siomod = mode;
|
|
|
|
DELAY(2);
|
|
|
|
pc98_i8251_set_cmd( com, (command|CMD8251_ER) );
|
1999-12-06 00:23:38 +00:00
|
|
|
DELAY(10);
|
|
|
|
if (com->pc98_8251fifo_enable)
|
2008-09-07 04:35:04 +00:00
|
|
|
outb(I8251F_fcr, FIFO_ENABLE | FIFO_XMT_RST | FIFO_RCV_RST);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
pc98_check_sysclock(void)
|
|
|
|
{
|
|
|
|
/* get system clock from port */
|
|
|
|
if ( pc98_machine_type & M_8M ) {
|
|
|
|
/* 8 MHz system & H98 */
|
|
|
|
sysclock = 8;
|
|
|
|
} else {
|
|
|
|
/* 5 MHz system */
|
|
|
|
sysclock = 5;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
com_cflag_and_speed_set( struct com_s *com, int cflag, int speed)
|
|
|
|
{
|
2002-03-08 12:12:46 +00:00
|
|
|
int cfcr=0;
|
1996-07-23 07:46:59 +00:00
|
|
|
int previnterrupt;
|
2005-09-14 12:39:06 +00:00
|
|
|
int tmp;
|
2002-03-08 12:12:46 +00:00
|
|
|
u_int count;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2002-03-08 12:12:46 +00:00
|
|
|
if (pc98_ttspeedtab(com, speed, &count) != 0)
|
|
|
|
return;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
previnterrupt = pc98_check_i8251_interrupt(com);
|
|
|
|
pc98_disable_i8251_interrupt( com, IEN_Tx|IEN_TxEMP|IEN_Rx );
|
|
|
|
|
|
|
|
switch ( cflag&CSIZE ) {
|
|
|
|
case CS5:
|
|
|
|
cfcr = MOD8251_5BITS; break;
|
|
|
|
case CS6:
|
|
|
|
cfcr = MOD8251_6BITS; break;
|
|
|
|
case CS7:
|
|
|
|
cfcr = MOD8251_7BITS; break;
|
|
|
|
case CS8:
|
|
|
|
cfcr = MOD8251_8BITS; break;
|
|
|
|
}
|
|
|
|
if ( cflag&PARENB ) {
|
|
|
|
if ( cflag&PARODD )
|
2008-09-07 04:35:04 +00:00
|
|
|
cfcr |= MOD8251_PENAB;
|
1996-06-14 10:04:54 +00:00
|
|
|
else
|
2008-09-07 04:35:04 +00:00
|
|
|
cfcr |= MOD8251_PENAB | MOD8251_PEVEN;
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
if ( cflag&CSTOPB )
|
|
|
|
cfcr |= MOD8251_STOP2;
|
|
|
|
else
|
|
|
|
cfcr |= MOD8251_STOP1;
|
|
|
|
|
|
|
|
if ( count & 0x10000 )
|
2008-09-07 04:35:04 +00:00
|
|
|
cfcr |= MOD8251_CLKx1;
|
1996-06-14 10:04:54 +00:00
|
|
|
else
|
2008-09-07 04:35:04 +00:00
|
|
|
cfcr |= MOD8251_CLKx16;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
2005-09-14 12:39:06 +00:00
|
|
|
while (!((tmp = inb(com->sts_port)) & STS8251_TxEMP))
|
|
|
|
;
|
|
|
|
|
1996-06-14 10:04:54 +00:00
|
|
|
/* set baud rate from ospeed */
|
|
|
|
pc98_set_baud_rate( com, count );
|
|
|
|
|
|
|
|
if ( cfcr != pc98_i8251_get_mod(com) )
|
|
|
|
pc98_i8251_reset(com, cfcr, pc98_i8251_get_cmd(com) );
|
|
|
|
|
|
|
|
pc98_enable_i8251_interrupt( com, previnterrupt );
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2002-03-08 12:12:46 +00:00
|
|
|
pc98_ttspeedtab(struct com_s *com, int speed, u_int *divisor)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-01-03 05:03:47 +00:00
|
|
|
int if_type, effect_sp, count = -1, mod;
|
|
|
|
|
|
|
|
if_type = com->pc98_if_type & 0x0f;
|
|
|
|
|
|
|
|
switch (com->pc98_if_type) {
|
|
|
|
case COM_IF_INTERNAL:
|
|
|
|
if (PC98SIO_baud_rate_port(if_type) != -1) {
|
|
|
|
count = ttspeedtab(speed, if_8251_type[if_type].speedtab);
|
|
|
|
if (count > 0) {
|
|
|
|
count |= COM1_EXT_CLOCK;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* for *1CLK asynchronous! mode, TEFUTEFU */
|
|
|
|
mod = (sysclock == 5) ? 2457600 : 1996800;
|
|
|
|
effect_sp = ttspeedtab( speed, pc98speedtab );
|
|
|
|
if ( effect_sp < 0 ) /* XXX */
|
|
|
|
effect_sp = ttspeedtab( (speed - 1), pc98speedtab );
|
|
|
|
if ( effect_sp <= 0 )
|
|
|
|
return effect_sp;
|
|
|
|
if ( effect_sp == speed )
|
|
|
|
mod /= 16;
|
|
|
|
if ( mod % effect_sp )
|
|
|
|
return(-1);
|
|
|
|
count = mod / effect_sp;
|
|
|
|
if ( count > 65535 )
|
|
|
|
return(-1);
|
|
|
|
if ( effect_sp != speed )
|
|
|
|
count |= 0x10000;
|
|
|
|
break;
|
|
|
|
case COM_IF_PC9861K_1:
|
|
|
|
case COM_IF_PC9861K_2:
|
|
|
|
count = 1;
|
|
|
|
break;
|
|
|
|
case COM_IF_IND_SS_1:
|
|
|
|
case COM_IF_IND_SS_2:
|
|
|
|
case COM_IF_PIO9032B_1:
|
|
|
|
case COM_IF_PIO9032B_2:
|
|
|
|
count = ttspeedtab( speed, if_8251_type[if_type].speedtab );
|
|
|
|
break;
|
|
|
|
case COM_IF_B98_01_1:
|
|
|
|
case COM_IF_B98_01_2:
|
|
|
|
count = ttspeedtab( speed, if_8251_type[if_type].speedtab );
|
|
|
|
#ifdef B98_01_OLD
|
|
|
|
if (count == 0 || count == 1) {
|
|
|
|
count += 4;
|
|
|
|
count |= 0x20000; /* x1 mode for 76800 and 153600 */
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-01-03 05:03:47 +00:00
|
|
|
break;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
|
2002-03-08 12:12:46 +00:00
|
|
|
if (count < 0)
|
|
|
|
return count;
|
|
|
|
|
|
|
|
*divisor = (u_int) count;
|
|
|
|
return 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2002-03-08 12:12:46 +00:00
|
|
|
pc98_set_baud_rate( struct com_s *com, u_int count )
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-01-03 05:03:47 +00:00
|
|
|
int if_type, io, s;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
if_type = com->pc98_if_type & 0x0f;
|
2000-05-12 12:38:25 +00:00
|
|
|
io = rman_get_start(com->ioportres) & 0xff00;
|
1999-01-03 05:03:47 +00:00
|
|
|
|
|
|
|
switch (com->pc98_if_type) {
|
|
|
|
case COM_IF_INTERNAL:
|
|
|
|
if (PC98SIO_baud_rate_port(if_type) != -1) {
|
|
|
|
if (count & COM1_EXT_CLOCK) {
|
|
|
|
outb((Port_t)PC98SIO_baud_rate_port(if_type), count & 0xff);
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
outb((Port_t)PC98SIO_baud_rate_port(if_type), 0x09);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-08 12:12:46 +00:00
|
|
|
if (count == 0)
|
1999-01-03 05:03:47 +00:00
|
|
|
return;
|
2002-03-08 12:12:46 +00:00
|
|
|
|
1999-01-03 05:03:47 +00:00
|
|
|
/* set i8253 */
|
|
|
|
s = splclock();
|
|
|
|
if (count != 3)
|
1996-06-14 10:04:54 +00:00
|
|
|
outb( 0x77, 0xb6 );
|
1999-01-03 05:03:47 +00:00
|
|
|
else
|
|
|
|
outb( 0x77, 0xb4 );
|
|
|
|
outb( 0x5f, 0);
|
|
|
|
outb( 0x75, count & 0xff );
|
|
|
|
outb( 0x5f, 0);
|
|
|
|
outb( 0x75, (count >> 8) & 0xff );
|
|
|
|
splx(s);
|
|
|
|
break;
|
|
|
|
case COM_IF_IND_SS_1:
|
|
|
|
case COM_IF_IND_SS_2:
|
|
|
|
outb(io | PC98SIO_intr_ctrl_port(if_type), 0);
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), 0);
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), 0xc0);
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), (count >> 8) | 0x80);
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), count & 0xff);
|
|
|
|
break;
|
|
|
|
case COM_IF_PIO9032B_1:
|
|
|
|
case COM_IF_PIO9032B_2:
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), count);
|
|
|
|
break;
|
|
|
|
case COM_IF_B98_01_1:
|
|
|
|
case COM_IF_B98_01_2:
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), count & 0x0f);
|
1996-06-14 10:04:54 +00:00
|
|
|
#ifdef B98_01_OLD
|
1999-01-03 05:03:47 +00:00
|
|
|
/*
|
|
|
|
* Some old B98_01 board should be controlled
|
|
|
|
* in different way, but this hasn't been tested yet.
|
|
|
|
*/
|
|
|
|
outb(io | PC98SIO_func_port(if_type),
|
|
|
|
(count & 0x20000) ? 0xf0 : 0xf2);
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-01-03 05:03:47 +00:00
|
|
|
break;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
static int
|
1999-04-18 14:42:20 +00:00
|
|
|
pc98_check_if_type(device_t dev, struct siodev *iod)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-01-03 05:03:47 +00:00
|
|
|
int irr, io, if_type, tmp;
|
1996-06-14 10:04:54 +00:00
|
|
|
static short irq_tab[2][8] = {
|
|
|
|
{ 3, 5, 6, 9, 10, 12, 13, -1},
|
|
|
|
{ 3, 10, 12, 13, 5, 6, 9, -1}
|
|
|
|
};
|
1999-01-03 05:03:47 +00:00
|
|
|
|
2000-05-12 12:38:25 +00:00
|
|
|
if_type = iod->if_type & 0x0f;
|
1996-06-14 10:04:54 +00:00
|
|
|
iod->irq = 0;
|
1999-04-18 14:42:20 +00:00
|
|
|
io = isa_get_port(dev) & 0xff00;
|
1999-01-03 05:03:47 +00:00
|
|
|
|
|
|
|
if (IS_8251(iod->if_type)) {
|
|
|
|
if (PC98SIO_func_port(if_type) != -1) {
|
|
|
|
outb(io | PC98SIO_func_port(if_type), 0xf2);
|
|
|
|
tmp = ttspeedtab(9600, if_8251_type[if_type].speedtab);
|
|
|
|
if (tmp != -1 && PC98SIO_baud_rate_port(if_type) != -1)
|
|
|
|
outb(io | PC98SIO_baud_rate_port(if_type), tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
iod->cmd = io | PC98SIO_cmd_port(if_type);
|
|
|
|
iod->sts = io | PC98SIO_sts_port(if_type);
|
|
|
|
iod->mod = io | PC98SIO_in_modem_port(if_type);
|
|
|
|
iod->ctrl = io | PC98SIO_intr_ctrl_port(if_type);
|
|
|
|
|
|
|
|
if (iod->if_type == COM_IF_INTERNAL) {
|
|
|
|
iod->irq = 4;
|
|
|
|
|
1999-12-06 00:23:38 +00:00
|
|
|
if (pc98_check_8251vfast()) {
|
|
|
|
PC98SIO_baud_rate_port(if_type) = I8251F_div;
|
1999-01-03 05:03:47 +00:00
|
|
|
if_8251_type[if_type].speedtab = pc98fast_speedtab;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
tmp = inb( iod->mod ) & if_8251_type[if_type].irr_mask;
|
1999-04-18 14:42:20 +00:00
|
|
|
if ((isa_get_port(dev) & 0xff) == IO_COM2)
|
1999-01-03 05:03:47 +00:00
|
|
|
iod->irq = irq_tab[0][tmp];
|
|
|
|
else
|
|
|
|
iod->irq = irq_tab[1][tmp];
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
irr = if_16550a_type[if_type].irr_read;
|
|
|
|
#ifdef COM_MULTIPORT
|
1999-09-07 11:17:09 +00:00
|
|
|
if (!COM_ISMULTIPORT(device_get_flags(dev)) ||
|
|
|
|
device_get_unit(dev) == COM_MPMASTER(device_get_flags(dev)))
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif
|
1999-01-03 05:03:47 +00:00
|
|
|
if (irr != -1) {
|
|
|
|
tmp = inb(io | irr);
|
1999-04-18 14:42:20 +00:00
|
|
|
if (isa_get_port(dev) & 0x01) /* XXX depend on RSB-384 */
|
1999-01-03 05:03:47 +00:00
|
|
|
iod->irq = irq_tab[1][tmp >> 3];
|
|
|
|
else
|
|
|
|
iod->irq = irq_tab[0][tmp & 0x07];
|
|
|
|
}
|
2007-07-11 22:25:38 +00:00
|
|
|
iod->cmd = 0;
|
|
|
|
iod->sts = 0;
|
|
|
|
iod->mod = 0;
|
|
|
|
iod->ctrl = 0;
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-01-03 05:03:47 +00:00
|
|
|
if ( iod->irq == -1 ) return -1;
|
1996-06-14 10:04:54 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2000-05-12 12:38:25 +00:00
|
|
|
static void
|
1999-12-06 00:23:38 +00:00
|
|
|
pc98_set_ioport(struct com_s *com)
|
1996-06-14 10:04:54 +00:00
|
|
|
{
|
1999-12-06 00:23:38 +00:00
|
|
|
int if_type = com->pc98_if_type & 0x0f;
|
2000-05-12 12:38:25 +00:00
|
|
|
Port_t io = rman_get_start(com->ioportres) & 0xff00;
|
|
|
|
|
|
|
|
pc98_check_sysclock();
|
|
|
|
com->data_port = io | PC98SIO_data_port(if_type);
|
|
|
|
com->cmd_port = io | PC98SIO_cmd_port(if_type);
|
|
|
|
com->sts_port = io | PC98SIO_sts_port(if_type);
|
|
|
|
com->in_modem_port = io | PC98SIO_in_modem_port(if_type);
|
|
|
|
com->intr_ctrl_port = io | PC98SIO_intr_ctrl_port(if_type);
|
1996-06-14 10:04:54 +00:00
|
|
|
}
|
1999-12-06 00:23:38 +00:00
|
|
|
static int
|
|
|
|
pc98_check_8251vfast(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
outb(I8251F_div, 0x8c);
|
|
|
|
DELAY(10);
|
|
|
|
for (i = 0; i < 100; i++) {
|
|
|
|
if ((inb(I8251F_div) & 0x80) != 0) {
|
|
|
|
i = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
DELAY(1);
|
|
|
|
}
|
|
|
|
outb(I8251F_div, 0);
|
|
|
|
DELAY(10);
|
|
|
|
for (; i < 100; i++) {
|
|
|
|
if ((inb(I8251F_div) & 0x80) == 0)
|
|
|
|
return 1;
|
|
|
|
DELAY(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static int
|
|
|
|
pc98_check_8251fifo(void)
|
|
|
|
{
|
|
|
|
u_char tmp1, tmp2;
|
|
|
|
|
|
|
|
tmp1 = inb(I8251F_iir);
|
|
|
|
DELAY(10);
|
|
|
|
tmp2 = inb(I8251F_iir);
|
|
|
|
if (((tmp1 ^ tmp2) & 0x40) != 0 && ((tmp1 | tmp2) & 0x20) == 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
1996-06-14 10:04:54 +00:00
|
|
|
#endif /* PC98 defined */
|