Attachment #10074 for bug #20341




#include <machine/resource.h>

#include <isa/sioreg.h>
#include <isa/siovar.h>

#ifdef COM_ESP
#include <isa/ic/esp.h>

	"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_int	flags;		/* Copy isa device flags */
	u_char	state;		/* miscellaneous flag bits */
	bool_t  active_out;	/* nonzero if the callout device is open */
	u_char	cfcr_image;	/* copy of value written to CFCR */
#ifdef COM_ESP
	bool_t	esp;		/* is this unit a hayes esp board? */
#endif
	u_char	extra_state;	/* more flag bits, separate for order trick */
	u_char	fifo_image;	/* copy of value written to FIFO */
	bool_t	hasfifo;	/* nonzero for 16550 UARTs */
	bool_t	st16650a;	/* Is a Startech 16650A or RTS/CTS compat */
	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 */
	int	unit;		/* unit	number */
	int	dtr_wait;	/* time to hold DTR down on close (* 1/hz) */
	u_int	tx_fifo_size;
	u_int	wopeners;	/* # processes waiting for DCD in open() */

	/*
	 * 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	hotchar;	/* ldisc-specific char to be handled ASAP */
	u_char	*ibuf;		/* start of input buffer */
	u_char	*ibufend;	/* end of input buffer */
	u_char	*ibufold;	/* old input buffer, to be freed */
	u_char	*ihighwater;	/* threshold in input buffer */
	u_char	*iptr;		/* next free spot in input buffer */
	int	ibufsize;	/* size of ibuf (not include error bytes) */
	int	ierroff;	/* offset of error bytes in ibuf */

	struct lbq	obufq;	/* head of queue of output buffers */
	struct lbq	obufs[2];	/* output buffers */

	Port_t	data_port;	/* i/o ports */
#ifdef COM_ESP
	Port_t	esp_port;
#endif
	Port_t	int_id_port;
	Port_t	iobase;
	Port_t	modem_ctl_port;
	Port_t	line_status_port;
	Port_t	modem_status_port;
	Port_t	intr_ctl_port;	/* Ports of IIR register */

	struct tty	*tp;	/* cross reference */

	/* Initial state. */
	struct termios	it_in;	/* should be in struct tty */
	struct termios	it_out;

	/* Lock state. */
	struct termios	lt_in;	/* should be in struct tty */
	struct termios	lt_out;

	bool_t	do_timestamp;
	bool_t	do_dcd_timestamp;
	struct timeval	timestamp;
	struct timeval	dcd_timestamp;
	struct	pps_state pps;

	u_long	bytes_in;	/* statistics */
	u_long	bytes_out;
	u_int	delta_error_counts[CE_NTYPES];
	u_long	error_counts[CE_NTYPES];

	struct resource *irqres;
	struct resource *ioportres;
	void *cookie;

	/*
	 * Data area for output buffers.  Someday we should build the output
	 * buffer queue without copying data.
	 */
	u_char	obuf1[256];
	u_char	obuf2[256];
};

#ifdef COM_ESP
static	int	espattach	__P((struct com_s *com, Port_t esp_port));
#endif

static	timeout_t siodtrwakeup;
static	void	comhardclose	__P((struct com_s *com));
static	void	sioinput	__P((struct com_s *com));
static	void	siointr1	__P((struct com_s *com));
static	void	siointr		__P((void *arg));
static	int	commctl		__P((struct com_s *com, int bits, int how));
static	int	comparam	__P((struct tty *tp, struct termios *t));


/* table and macro for fast conversion from a unit number to its com struct */
static	devclass_t	sio_devclass;
static	struct com_s	*p_com_addr[SIO_MAXUNITS];
#define	com_addr(unit)	(p_com_addr[unit])

static device_method_t sio_isa_methods[] = {
	/* Device interface */

	return (sioattach(dev));
}

int
sio_attach_unit(com, unit, iobase, flags, no_irq)
	device_t	dev;
{
	struct com_s	*com;
	int		unit;
	Port_t		iobase;
	u_int		flags;
	bool_t		no_irq;
{
#ifdef COM_ESP
	Port_t		*espp;
#endif
	if (unit >= SIO_MAXUNITS)
		return ENXIO;
	u_int		flags;
	int		rid;
	struct resource *port;
	int		ret;

	rid = 0;
	port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
				  0, ~0, IO_COMSIZE, RF_ACTIVE);
	if (!port)
		return (ENXIO);

	iobase = rman_get_start(port);
	unit = device_get_unit(dev);
	com = device_get_softc(dev);
	flags = device_get_flags(dev);

	if (unit >= sio_numunits)
		sio_numunits = unit + 1;
	/*

	 */
	bzero(com, sizeof *com);
	com->unit = unit;
	com->ioportres = port;
	com->cfcr_image = CFCR_8BITS;
	com->dtr_wait = 3 * hz;
	com->loses_outints = COM_LOSESOUTINTS(flags) != 0;
	com->no_irq = no_irq;
	com->tx_fifo_size = 1;
	com->obufs[0].l_head = com->obuf1;
	com->obufs[1].l_head = com->obuf2;

		com->it_in.c_ispeed = com->it_in.c_ospeed = TTYDEF_SPEED;
	if (siosetwater(com, com->it_in.c_ispeed) != 0) {
		enable_intr();
		/*
		 * 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);
	}
	enable_intr();


#ifdef COM_MULTIPORT
	if (COM_ISMULTIPORT(flags)) {
		device_t masterdev;

		com->multiport = TRUE;
		printf(" (multiport");
		if (unit == COM_MPMASTER(flags))
			printf(" master");
		printf(")");
		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);
	 }
#endif /* COM_MULTIPORT */
	if (unit == comconsole)

		printf(" with a bogus IIR_TXRDY register");
	printf("\n");

	com_addr(unit) = com;

	if (!sio_registered) {
		register_swi(SWI_TTY, siopoll);
		sio_registered = TRUE;

	com->pps.ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
	pps_init(&com->pps);

	return (0);
}

static int
sioattach(dev)
	device_t	dev;
{
	int		rid, ret, no_irq;
	struct resource *port;
	struct com_s	*com;
	Port_t		iobase;
	u_int		flags;

	rid = 0;
	port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
				  0, ~0, IO_COMSIZE, RF_ACTIVE);
	if (!port)
		return (ENXIO);

	iobase = rman_get_start(port);
	com = device_get_softc(dev);
	flags = device_get_flags(dev);

#ifdef COM_MULTIPORT
	if (COM_ISMULTIPORT(flags)) {
		device_t masterdev;

		masterdev = devclass_get_device(sio_devclass,
		    COM_MPMASTER(flags));
		no_irq = (masterdev == NULL || bus_get_resource(masterdev,
		    SYS_RES_IRQ, 0, NULL, NULL) != 0);
	 } else
#endif /* COM_MULTIPORT */
	no_irq = bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0;

	ret = sio_attach_unit(com, device_get_unit(dev), iobase, flags, no_irq);
	if (ret != 0) {
		/* 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 ret;
	}

	rid = 0;
	com->irqres = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0ul, ~0ul, 1,
	    RF_ACTIVE);

		if (ret)
			device_printf(dev, "could not activate interrupt\n");
	}
	com->ioportres = port;
	return 0;
}

static int

#endif /* COM_MULTIPORT */
}

void
siointr1(com)
	struct com_s	*com;
{




/*
 * Serial driver for non-intelligent PCI multiport adapters.
 * Implements the probe, attach and interrupt dispatcher,
 * and uses sio.c for the most part of work.
 * The PCI ports get unit numbers _after_ the ISA sio ports.
 * Option COM_MULTIPORT is not necessary.
 *
 * Copyright (C) 2000 Cronyx Engineering Ltd.
 * Author: Serge Vakulenko <vak@cronyx.ru>
 *
 * Supports:
 *	Cronyx Omega-PCI adapter, by Serge Vakulenko <vak@cronyx.ru>
 *
 * This software is distributed with NO WARRANTIES, not even the implied
 * warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Authors grant any other persons or organisations permission to use
 * or modify this software as long as this message is kept with the software,
 * all derivative works or modified versions.
 */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/timepps.h>
#include <sys/tty.h>
#include <vm/vm.h>
#include <vm/pmap.h>
#include <machine/bus.h>
#ifndef SMP
#include <machine/lock.h>
#endif
#include <machine/resource.h>
#include <sys/bus.h>
#include <sys/rman.h>
#include <pci/pcivar.h>
#if __FreeBSD_version >= 400000
#include <isa/siovar.h>
#include <isa/sioreg.h>
#else
#include <sys/malloc.h>
#include <sys/interrupt.h>
#include <i386/isa/siovar.h>
#include <i386/isa/sioreg.h>
#endif
#include <isa/ic/ns16550.h>

#include "sio.h"

#define MAXCHAN		8

#ifndef __i386__
#define disable_intr()
#define enable_intr()
#endif

#ifdef SMP
#define disable_intr()	COM_DISABLE_INTR()
#define enable_intr()	COM_ENABLE_INTR()
#endif /* SMP */

typedef struct _sio_pci_t {
	int		nchan;
	int		fifo_size;
	int		base_reg;
	int		hw_rts_cts;
	Port_t		iobase;
	Port_t		iostep;
	struct resource	*res;
	struct resource	*irq;
	void		*intrhand;
	struct com_s	com [MAXCHAN];
} sio_pci_t;

static void sio_pci_intr	__P((void *arg));

static int sio_pci_numunits = NSIO;

#if __FreeBSD_version >= 400000
/*
 * FreeBSD version 4.x
 */
static int sio_pci_probe	__P((device_t));
static int sio_pci_attach	__P((device_t));

static devclass_t siopci_devclass;

static device_method_t sio_pci_methods[] = {
	/* Device interface */
	DEVMETHOD(device_probe,		sio_pci_probe),
	DEVMETHOD(device_attach,	sio_pci_attach),
	{ 0, 0 }
};

static driver_t sio_pci_driver = {
	"siopci",
	sio_pci_methods,
	sizeof(sio_pci_t)
};
DRIVER_MODULE(sio_pci, pci, sio_pci_driver, siopci_devclass, 0, 0);

#else
/*
 * FreeBSD version 3.x
 */
static const char *sio_pci_probe	__P((pcici_t, pcidi_t));
static void sio_pci_attach		__P((pcici_t, int));

static u_long sio_pci_count;

static struct pci_device sio_pci_device = {
        "siopci",
        sio_pci_probe,
        sio_pci_attach,
        &sio_pci_count,
        NULL
};
DATA_SET(pcidevice_set, sio_pci_device);

#endif /* __FreeBSD_version >= 400000 */

#if __FreeBSD_version >= 400000
static int
sio_pci_probe(dev)
	device_t	dev;
{
	u_long device_id = pci_get_vendor(dev) | pci_get_device(dev) << 16;
#else
static const char *
sio_pci_probe(config_id, device_id)
	pcici_t config_id;
	pcidi_t device_id;
{
#endif
	const char *desc = 0;

	if (device_id == 0xc00110b5)
		desc = "Cronyx-Omega-PCI Serial Adapter";
#ifdef notyet
	/* Add your device here. */
	else if (device_id == 0xXXXXXXXX)
		desc = "XXX";
#endif

#if __FreeBSD_version >= 400000
	if (! desc)
		return ENXIO;
	device_set_desc(dev, desc);
	return 0;
#else
	return desc;
#endif
}

#if __FreeBSD_version >= 400000
static int
sio_pci_attach(dev)
	device_t	dev;
{
	u_long		device_id = pci_get_vendor(dev) |
				    pci_get_device(dev) << 16;
	sio_pci_t	*d = device_get_softc(dev);
	int		rid;
#define PCI_READ_CONFIG(reg) pci_read_config(dev, reg, 4)
#else
static void
sio_pci_attach(config_id, unit)
	pcici_t config_id;
	int unit;
{
	u_long device_id = config_id->vendor | config_id->device << 16;
	sio_pci_t	*d = malloc(sizeof *d, M_DEVBUF, M_WAITOK);
#define PCI_READ_CONFIG(reg) pci_conf_read(config_id, reg)
#endif
	struct com_s	*com;
	int		s, err = 0;

	bzero((char*)d, sizeof(*d));
	s = splimp();

	/* Default values. */
	d->nchan = 8;			/* channels per adapter */
	d->iostep = 8;			/* addresses per channel */
	d->base_reg = 0x18;		/* pci register: base addr2 */

	/* Device dependent values. */
	if (device_id == 0xc00110b5) {
		d->fifo_size = 64;	/* fifo size in bytes */
		d->hw_rts_cts = 1;	/* hardware rts/cts support */
	}
#ifdef notyet
	else if (device_id == 0xXXXXXXXX) {
		/* Add your device here. */
	}
#endif

#if __FreeBSD_version >= 400000
	/* Allocate i/o region. */
	rid = d->base_reg;
	d->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1,
		RF_ACTIVE);
	if (! d->res) {
		printf("sio%d: couldn't map ports/memory\n", sio_pci_numunits);
		err = ENXIO;
		goto fail;
	}

	/* Allocate interrupt. */
	rid = 0;
	d->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
		RF_SHAREABLE | RF_ACTIVE);
	if (! d->irq) {
		printf("sio%d: couldn't map interrupt\n", sio_pci_numunits);
		err = ENXIO;
		goto fail;
	}

	/* Register the interrupt handler. */
	err = bus_setup_intr(dev, d->irq, INTR_TYPE_TTY | INTR_TYPE_FAST,
		sio_pci_intr, d, &d->intrhand);
#else
	err = ! pci_map_int_right(config_id, sio_pci_intr, d, &tty_imask,
		INTR_FAST);
#endif
	if (err) {
		printf("sio%d: couldn't set up irq\n", sio_pci_numunits);
#if __FreeBSD_version >= 400000
fail:		if (d->res)
			bus_release_resource(dev, SYS_RES_IOPORT,
				d->base_reg, d->res);
		if (d->irq)
			bus_release_resource(dev, SYS_RES_IRQ, 0, d->irq);
#endif
		goto done;
	}

	/* Attach sio ports. */
	d->iobase = PCI_READ_CONFIG (d->base_reg) & ~3;
	for (com=d->com; com<d->com+d->nchan; ++com) {
		com->iobase = d->iobase + (com - d->com) * d->iostep;

		/* Interrupt enable, do it _before_ sio_attach_unit. */
		outb(com->iobase + com_mcr, MCR_IENABLE);

		if (sio_attach_unit(com, sio_pci_numunits++, com->iobase,
		    d->fifo_size << 24, 0) != 0)
			printf("sio%d: cannot attach\n", sio_pci_numunits);

		/* Must do this _after_ sio_attach_unit. */
		com->st16650a = d->hw_rts_cts;
	}
done:
	splx (s);
#if __FreeBSD_version >= 400000
	return err;
#endif
}

static void
sio_pci_intr(arg)
	void		*arg;
{
	sio_pci_t	*d = arg;
	struct com_s	*com;
	bool_t		possibly_more_intrs;

	disable_intr();
	do {
		possibly_more_intrs = FALSE;
		for (com=d->com; com<d->com+d->nchan; ++com) {
			if ((inb(com->int_id_port) & IIR_IMASK) != IIR_NOPEND) {
				siointr1(com);
				possibly_more_intrs = TRUE;
			}
		}
	} while (possibly_more_intrs);
	enable_intr();
}

Lines 389-394 Link Here

(-)conf/files.i386 (+1 lines)
389	isa/ppc.c optional ppc	389	isa/ppc.c optional ppc
390	isa/psm.c optional psm	390	isa/psm.c optional psm
391	isa/sio.c optional sio	391	isa/sio.c optional sio
		392	pci/sio_pci.c optional sio pci
392	isa/syscons_isa.c optional sc	393	isa/syscons_isa.c optional sc
393	isa/vga_isa.c optional vga	394	isa/vga_isa.c optional vga
394	kern/subr_diskmbr.c standard	395	kern/subr_diskmbr.c standard

Return to bug 20341

Lines 82-87 Link Here

(-)isa/sio.c (-147 / +62 lines)
82	#include <machine/resource.h>	82	#include <machine/resource.h>
83		83
84	#include <isa/sioreg.h>	84	#include <isa/sioreg.h>
		85	#include <isa/siovar.h>
85		86
86	#ifdef COM_ESP	87	#ifdef COM_ESP
87	#include <isa/ic/esp.h>	88	#include <isa/ic/esp.h>
Lines 167-279 Link Here
167	"tty-level buffer overflow",	168	"tty-level buffer overflow",
168	};	169	};
169		170
170	#define CE_NTYPES 3
171	#define CE_RECORD(com, errnum) (++(com)->delta_error_counts[errnum])	171	#define CE_RECORD(com, errnum) (++(com)->delta_error_counts[errnum])
172		172
173	/* types. XXX - should be elsewhere */
174	typedef u_int Port_t; /* hardware port */
175	typedef u_char bool_t; /* boolean */
176
177	/* queue of linear buffers */
178	struct lbq {
179	u_char l_head; / next char to process */
180	u_char l_tail; / one past the last char to process */
181	struct lbq l_next; / next in queue */
182	bool_t l_queued; /* nonzero if queued */
183	};
184
185	/* com device structure */
186	struct com_s {
187	u_int flags; /* Copy isa device flags */
188	u_char state; /* miscellaneous flag bits */
189	bool_t active_out; /* nonzero if the callout device is open */
190	u_char cfcr_image; /* copy of value written to CFCR */
191	#ifdef COM_ESP
192	bool_t esp; /* is this unit a hayes esp board? */
193	#endif
194	u_char extra_state; /* more flag bits, separate for order trick */
195	u_char fifo_image; /* copy of value written to FIFO */
196	bool_t hasfifo; /* nonzero for 16550 UARTs */
197	bool_t st16650a; /* Is a Startech 16650A or RTS/CTS compat */
198	bool_t loses_outints; /* nonzero if device loses output interrupts */
199	u_char mcr_image; /* copy of value written to MCR */
200	#ifdef COM_MULTIPORT
201	bool_t multiport; /* is this unit part of a multiport device? */
202	#endif /* COM_MULTIPORT */
203	bool_t no_irq; /* nonzero if irq is not attached */
204	bool_t gone; /* hardware disappeared */
205	bool_t poll; /* nonzero if polling is required */
206	bool_t poll_output; /* nonzero if polling for output is required */
207	int unit; /* unit number */
208	int dtr_wait; /* time to hold DTR down on close (* 1/hz) */
209	u_int tx_fifo_size;
210	u_int wopeners; /* # processes waiting for DCD in open() */
211
212	/*
213	* The high level of the driver never reads status registers directly
214	* because there would be too many side effects to handle conveniently.
215	* Instead, it reads copies of the registers stored here by the
216	* interrupt handler.
217	*/
218	u_char last_modem_status; /* last MSR read by intr handler */
219	u_char prev_modem_status; /* last MSR handled by high level */
220
221	u_char hotchar; /* ldisc-specific char to be handled ASAP */
222	u_char ibuf; / start of input buffer */
223	u_char ibufend; / end of input buffer */
224	u_char ibufold; / old input buffer, to be freed */
225	u_char ihighwater; / threshold in input buffer */
226	u_char iptr; / next free spot in input buffer */
227	int ibufsize; /* size of ibuf (not include error bytes) */
228	int ierroff; /* offset of error bytes in ibuf */
229
230	struct lbq obufq; /* head of queue of output buffers */
231	struct lbq obufs[2]; /* output buffers */
232
233	Port_t data_port; /* i/o ports */
234	#ifdef COM_ESP
235	Port_t esp_port;
236	#endif
237	Port_t int_id_port;
238	Port_t iobase;
239	Port_t modem_ctl_port;
240	Port_t line_status_port;
241	Port_t modem_status_port;
242	Port_t intr_ctl_port; /* Ports of IIR register */
243
244	struct tty tp; / cross reference */
245
246	/* Initial state. */
247	struct termios it_in; /* should be in struct tty */
248	struct termios it_out;
249
250	/* Lock state. */
251	struct termios lt_in; /* should be in struct tty */
252	struct termios lt_out;
253
254	bool_t do_timestamp;
255	bool_t do_dcd_timestamp;
256	struct timeval timestamp;
257	struct timeval dcd_timestamp;
258	struct pps_state pps;
259
260	u_long bytes_in; /* statistics */
261	u_long bytes_out;
262	u_int delta_error_counts[CE_NTYPES];
263	u_long error_counts[CE_NTYPES];
264
265	struct resource *irqres;
266	struct resource *ioportres;
267	void *cookie;
268
269	/*
270	* Data area for output buffers. Someday we should build the output
271	* buffer queue without copying data.
272	*/
273	u_char obuf1[256];
274	u_char obuf2[256];
275	};
276
277	#ifdef COM_ESP	173	#ifdef COM_ESP
278	static int espattach __P((struct com_s *com, Port_t esp_port));	174	static int espattach __P((struct com_s *com, Port_t esp_port));
279	#endif	175	#endif
Lines 284-290 Link Here
284	static timeout_t siodtrwakeup;	180	static timeout_t siodtrwakeup;
285	static void comhardclose __P((struct com_s *com));	181	static void comhardclose __P((struct com_s *com));
286	static void sioinput __P((struct com_s *com));	182	static void sioinput __P((struct com_s *com));
287	static void siointr1 __P((struct com_s *com));
288	static void siointr __P((void *arg));	183	static void siointr __P((void *arg));
289	static int commctl __P((struct com_s *com, int bits, int how));	184	static int commctl __P((struct com_s *com, int bits, int how));
290	static int comparam __P((struct tty tp, struct termios t));	185	static int comparam __P((struct tty tp, struct termios t));
Lines 309-316 Link Here
309		204
310	/* table and macro for fast conversion from a unit number to its com struct */	205	/* table and macro for fast conversion from a unit number to its com struct */
311	static devclass_t sio_devclass;	206	static devclass_t sio_devclass;
312	#define com_addr(unit) ((struct com_s *) \	207	static struct com_s *p_com_addr[SIO_MAXUNITS];
313	devclass_get_softc(sio_devclass, unit))	208	#define com_addr(unit) (p_com_addr[unit])
314		209
315	static device_method_t sio_isa_methods[] = {	210	static device_method_t sio_isa_methods[] = {
316	/* Device interface */	211	/* Device interface */
Lines 969-1000 Link Here
969	return (sioattach(dev));	864	return (sioattach(dev));
970	}	865	}
971		866
972	static int	867	int
973	sioattach(dev)	868	sio_attach_unit(com, unit, iobase, flags, no_irq)
974	device_t dev;
975	{
976	struct com_s *com;	869	struct com_s *com;
		870	int unit;
		871	Port_t iobase;
		872	u_int flags;
		873	bool_t no_irq;
		874	{
977	#ifdef COM_ESP	875	#ifdef COM_ESP
978	Port_t *espp;	876	Port_t *espp;
979	#endif	877	#endif
980	Port_t iobase;	878	if (unit >= SIO_MAXUNITS)
981	int unit;	879	return ENXIO;
982	u_int flags;
983	int rid;
984	struct resource *port;
985	int ret;
986
987	rid = 0;
988	port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
989	0, ~0, IO_COMSIZE, RF_ACTIVE);
990	if (!port)
991	return (ENXIO);
992
993	iobase = rman_get_start(port);
994	unit = device_get_unit(dev);
995	com = device_get_softc(dev);
996	flags = device_get_flags(dev);
997
998	if (unit >= sio_numunits)	880	if (unit >= sio_numunits)
999	sio_numunits = unit + 1;	881	sio_numunits = unit + 1;
1000	/*	882	/*
Lines 1011-1021 Link Here
1011	*/	893	*/
1012	bzero(com, sizeof *com);	894	bzero(com, sizeof *com);
1013	com->unit = unit;	895	com->unit = unit;
1014	com->ioportres = port;
1015	com->cfcr_image = CFCR_8BITS;	896	com->cfcr_image = CFCR_8BITS;
1016	com->dtr_wait = 3 * hz;	897	com->dtr_wait = 3 * hz;
1017	com->loses_outints = COM_LOSESOUTINTS(flags) != 0;	898	com->loses_outints = COM_LOSESOUTINTS(flags) != 0;
1018	com->no_irq = bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0;	899	com->no_irq = no_irq;
1019	com->tx_fifo_size = 1;	900	com->tx_fifo_size = 1;
1020	com->obufs[0].l_head = com->obuf1;	901	com->obufs[0].l_head = com->obuf1;
1021	com->obufs[1].l_head = com->obuf2;	902	com->obufs[1].l_head = com->obuf2;
Lines 1052-1063 Link Here
1052	com->it_in.c_ispeed = com->it_in.c_ospeed = TTYDEF_SPEED;	933	com->it_in.c_ispeed = com->it_in.c_ospeed = TTYDEF_SPEED;
1053	if (siosetwater(com, com->it_in.c_ispeed) != 0) {	934	if (siosetwater(com, com->it_in.c_ispeed) != 0) {
1054	enable_intr();	935	enable_intr();
1055	/*
1056	* Leave i/o resources allocated if this is a `cn'-level
1057	* console, so that other devices can't snarf them.
1058	*/
1059	if (iobase != siocniobase)
1060	bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
1061	return (ENOMEM);	936	return (ENOMEM);
1062	}	937	}
1063	enable_intr();	938	enable_intr();
Lines 1164-1180 Link Here
1164		1039
1165	#ifdef COM_MULTIPORT	1040	#ifdef COM_MULTIPORT
1166	if (COM_ISMULTIPORT(flags)) {	1041	if (COM_ISMULTIPORT(flags)) {
1167	device_t masterdev;
1168
1169	com->multiport = TRUE;	1042	com->multiport = TRUE;
1170	printf(" (multiport");	1043	printf(" (multiport");
1171	if (unit == COM_MPMASTER(flags))	1044	if (unit == COM_MPMASTER(flags))
1172	printf(" master");	1045	printf(" master");
1173	printf(")");	1046	printf(")");
1174	masterdev = devclass_get_device(sio_devclass,
1175	COM_MPMASTER(flags));
1176	com->no_irq = (masterdev == NULL \|\| bus_get_resource(masterdev,
1177	SYS_RES_IRQ, 0, NULL, NULL) != 0);
1178	}	1047	}
1179	#endif /* COM_MULTIPORT */	1048	#endif /* COM_MULTIPORT */
1180	if (unit == comconsole)	1049	if (unit == comconsole)
Lines 1183-1188 Link Here
1183	printf(" with a bogus IIR_TXRDY register");	1052	printf(" with a bogus IIR_TXRDY register");
1184	printf("\n");	1053	printf("\n");
1185		1054
		1055	com_addr(unit) = com;
		1056
1186	if (!sio_registered) {	1057	if (!sio_registered) {
1187	register_swi(SWI_TTY, siopoll);	1058	register_swi(SWI_TTY, siopoll);
1188	sio_registered = TRUE;	1059	sio_registered = TRUE;
Lines 1203-1208 Link Here
1203	com->pps.ppscap = PPS_CAPTUREASSERT \| PPS_CAPTURECLEAR;	1074	com->pps.ppscap = PPS_CAPTUREASSERT \| PPS_CAPTURECLEAR;
1204	pps_init(&com->pps);	1075	pps_init(&com->pps);
1205		1076
		1077	return (0);
		1078	}
		1079
		1080	static int
		1081	sioattach(dev)
		1082	device_t dev;
		1083	{
		1084	int rid, ret, no_irq;
		1085	struct resource *port;
		1086	struct com_s *com;
		1087	Port_t iobase;
		1088	u_int flags;
		1089
		1090	rid = 0;
		1091	port = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid,
		1092	0, ~0, IO_COMSIZE, RF_ACTIVE);
		1093	if (!port)
		1094	return (ENXIO);
		1095
		1096	iobase = rman_get_start(port);
		1097	com = device_get_softc(dev);
		1098	flags = device_get_flags(dev);
		1099
		1100	#ifdef COM_MULTIPORT
		1101	if (COM_ISMULTIPORT(flags)) {
		1102	device_t masterdev;
		1103
		1104	masterdev = devclass_get_device(sio_devclass,
		1105	COM_MPMASTER(flags));
		1106	no_irq = (masterdev == NULL \|\| bus_get_resource(masterdev,
		1107	SYS_RES_IRQ, 0, NULL, NULL) != 0);
		1108	} else
		1109	#endif /* COM_MULTIPORT */
		1110	no_irq = bus_get_resource(dev, SYS_RES_IRQ, 0, NULL, NULL) != 0;
		1111
		1112	ret = sio_attach_unit(com, device_get_unit(dev), iobase, flags, no_irq);
		1113	if (ret != 0) {
		1114	/* Leave i/o resources allocated if this is a `cn'-level
		1115	* console, so that other devices can't snarf them. */
		1116	if (iobase != siocniobase)
		1117	bus_release_resource(dev, SYS_RES_IOPORT, rid, port);
		1118	return ret;
		1119	}
		1120
1206	rid = 0;	1121	rid = 0;
1207	com->irqres = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0ul, ~0ul, 1,	1122	com->irqres = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0ul, ~0ul, 1,
1208	RF_ACTIVE);	1123	RF_ACTIVE);
Lines 1220-1227 Link Here
1220	if (ret)	1135	if (ret)
1221	device_printf(dev, "could not activate interrupt\n");	1136	device_printf(dev, "could not activate interrupt\n");
1222	}	1137	}
1223		1138	com->ioportres = port;
1224	return (0);	1139	return 0;
1225	}	1140	}
1226		1141
1227	static int	1142	static int
Lines 1713-1719 Link Here
1713	#endif /* COM_MULTIPORT */	1628	#endif /* COM_MULTIPORT */
1714	}	1629	}
1715		1630
1716	static void	1631	void
1717	siointr1(com)	1632	siointr1(com)
1718	struct com_s *com;	1633	struct com_s *com;
1719	{	1634	{

Added Link Here

(-)pci/sio_pci.c (+277 lines)
1	/*
2	* Serial driver for non-intelligent PCI multiport adapters.
3	* Implements the probe, attach and interrupt dispatcher,
4	* and uses sio.c for the most part of work.
5	* The PCI ports get unit numbers _after_ the ISA sio ports.
6	* Option COM_MULTIPORT is not necessary.
7	*
8	* Copyright (C) 2000 Cronyx Engineering Ltd.
9	* Author: Serge Vakulenko <vak@cronyx.ru>
10	*
11	* Supports:
12	* Cronyx Omega-PCI adapter, by Serge Vakulenko <vak@cronyx.ru>
13	*
14	* This software is distributed with NO WARRANTIES, not even the implied
15	* warranties for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16	*
17	* Authors grant any other persons or organisations permission to use
18	* or modify this software as long as this message is kept with the software,
19	* all derivative works or modified versions.
20	*/
21	#include <sys/param.h>
22	#include <sys/systm.h>
23	#include <sys/kernel.h>
24	#include <sys/timepps.h>
25	#include <sys/tty.h>
26	#include <vm/vm.h>
27	#include <vm/pmap.h>
28	#include <machine/bus.h>
29	#ifndef SMP
30	#include <machine/lock.h>
31	#endif
32	#include <machine/resource.h>
33	#include <sys/bus.h>
34	#include <sys/rman.h>
35	#include <pci/pcivar.h>
36	#if __FreeBSD_version >= 400000
37	#include <isa/siovar.h>
38	#include <isa/sioreg.h>
39	#else
40	#include <sys/malloc.h>
41	#include <sys/interrupt.h>
42	#include <i386/isa/siovar.h>
43	#include <i386/isa/sioreg.h>
44	#endif
45	#include <isa/ic/ns16550.h>
46
47	#include "sio.h"
48
49	#define MAXCHAN 8
50
51	#ifndef __i386__
52	#define disable_intr()
53	#define enable_intr()
54	#endif
55
56	#ifdef SMP
57	#define disable_intr() COM_DISABLE_INTR()
58	#define enable_intr() COM_ENABLE_INTR()
59	#endif /* SMP */
60
61	typedef struct _sio_pci_t {
62	int nchan;
63	int fifo_size;
64	int base_reg;
65	int hw_rts_cts;
66	Port_t iobase;
67	Port_t iostep;
68	struct resource *res;
69	struct resource *irq;
70	void *intrhand;
71	struct com_s com [MAXCHAN];
72	} sio_pci_t;
73
74	static void sio_pci_intr __P((void *arg));
75
76	static int sio_pci_numunits = NSIO;
77
78	#if __FreeBSD_version >= 400000
79	/*
80	* FreeBSD version 4.x
81	*/
82	static int sio_pci_probe __P((device_t));
83	static int sio_pci_attach __P((device_t));
84
85	static devclass_t siopci_devclass;
86
87	static device_method_t sio_pci_methods[] = {
88	/* Device interface */
89	DEVMETHOD(device_probe, sio_pci_probe),
90	DEVMETHOD(device_attach, sio_pci_attach),
91	{ 0, 0 }
92	};
93
94	static driver_t sio_pci_driver = {
95	"siopci",
96	sio_pci_methods,
97	sizeof(sio_pci_t)
98	};
99	DRIVER_MODULE(sio_pci, pci, sio_pci_driver, siopci_devclass, 0, 0);
100
101	#else
102	/*
103	* FreeBSD version 3.x
104	*/
105	static const char *sio_pci_probe __P((pcici_t, pcidi_t));
106	static void sio_pci_attach __P((pcici_t, int));
107
108	static u_long sio_pci_count;
109
110	static struct pci_device sio_pci_device = {
111	"siopci",
112	sio_pci_probe,
113	sio_pci_attach,
114	&sio_pci_count,
115	NULL
116	};
117	DATA_SET(pcidevice_set, sio_pci_device);
118
119	#endif /* __FreeBSD_version >= 400000 */
120
121	#if __FreeBSD_version >= 400000
122	static int
123	sio_pci_probe(dev)
124	device_t dev;
125	{
126	u_long device_id = pci_get_vendor(dev) \| pci_get_device(dev) << 16;
127	#else
128	static const char *
129	sio_pci_probe(config_id, device_id)
130	pcici_t config_id;
131	pcidi_t device_id;
132	{
133	#endif
134	const char *desc = 0;
135
136	if (device_id == 0xc00110b5)
137	desc = "Cronyx-Omega-PCI Serial Adapter";
138	#ifdef notyet
139	/* Add your device here. */
140	else if (device_id == 0xXXXXXXXX)
141	desc = "XXX";
142	#endif
143
144	#if __FreeBSD_version >= 400000
145	if (! desc)
146	return ENXIO;
147	device_set_desc(dev, desc);
148	return 0;
149	#else
150	return desc;
151	#endif
152	}
153
154	#if __FreeBSD_version >= 400000
155	static int
156	sio_pci_attach(dev)
157	device_t dev;
158	{
159	u_long device_id = pci_get_vendor(dev) \|
160	pci_get_device(dev) << 16;
161	sio_pci_t *d = device_get_softc(dev);
162	int rid;
163	#define PCI_READ_CONFIG(reg) pci_read_config(dev, reg, 4)
164	#else
165	static void
166	sio_pci_attach(config_id, unit)
167	pcici_t config_id;
168	int unit;
169	{
170	u_long device_id = config_id->vendor \| config_id->device << 16;
171	sio_pci_t d = malloc(sizeof d, M_DEVBUF, M_WAITOK);
172	#define PCI_READ_CONFIG(reg) pci_conf_read(config_id, reg)
173	#endif
174	struct com_s *com;
175	int s, err = 0;
176
177	bzero((char)d, sizeof(d));
178	s = splimp();
179
180	/* Default values. */
181	d->nchan = 8; /* channels per adapter */
182	d->iostep = 8; /* addresses per channel */
183	d->base_reg = 0x18; /* pci register: base addr2 */
184
185	/* Device dependent values. */
186	if (device_id == 0xc00110b5) {
187	d->fifo_size = 64; /* fifo size in bytes */
188	d->hw_rts_cts = 1; /* hardware rts/cts support */
189	}
190	#ifdef notyet
191	else if (device_id == 0xXXXXXXXX) {
192	/* Add your device here. */
193	}
194	#endif
195
196	#if __FreeBSD_version >= 400000
197	/* Allocate i/o region. */
198	rid = d->base_reg;
199	d->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &rid, 0, ~0, 1,
200	RF_ACTIVE);
201	if (! d->res) {
202	printf("sio%d: couldn't map ports/memory\n", sio_pci_numunits);
203	err = ENXIO;
204	goto fail;
205	}
206
207	/* Allocate interrupt. */
208	rid = 0;
209	d->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
210	RF_SHAREABLE \| RF_ACTIVE);
211	if (! d->irq) {
212	printf("sio%d: couldn't map interrupt\n", sio_pci_numunits);
213	err = ENXIO;
214	goto fail;
215	}
216
217	/* Register the interrupt handler. */
218	err = bus_setup_intr(dev, d->irq, INTR_TYPE_TTY \| INTR_TYPE_FAST,
219	sio_pci_intr, d, &d->intrhand);
220	#else
221	err = ! pci_map_int_right(config_id, sio_pci_intr, d, &tty_imask,
222	INTR_FAST);
223	#endif
224	if (err) {
225	printf("sio%d: couldn't set up irq\n", sio_pci_numunits);
226	#if __FreeBSD_version >= 400000
227	fail: if (d->res)
228	bus_release_resource(dev, SYS_RES_IOPORT,
229	d->base_reg, d->res);
230	if (d->irq)
231	bus_release_resource(dev, SYS_RES_IRQ, 0, d->irq);
232	#endif
233	goto done;
234	}
235
236	/* Attach sio ports. */
237	d->iobase = PCI_READ_CONFIG (d->base_reg) & ~3;
238	for (com=d->com; com<d->com+d->nchan; ++com) {
239	com->iobase = d->iobase + (com - d->com) * d->iostep;
240
241	/* Interrupt enable, do it _before_ sio_attach_unit. */
242	outb(com->iobase + com_mcr, MCR_IENABLE);
243
244	if (sio_attach_unit(com, sio_pci_numunits++, com->iobase,
245	d->fifo_size << 24, 0) != 0)
246	printf("sio%d: cannot attach\n", sio_pci_numunits);
247
248	/* Must do this _after_ sio_attach_unit. */
249	com->st16650a = d->hw_rts_cts;
250	}
251	done:
252	splx (s);
253	#if __FreeBSD_version >= 400000
254	return err;
255	#endif
256	}
257
258	static void
259	sio_pci_intr(arg)
260	void *arg;
261	{
262	sio_pci_t *d = arg;
263	struct com_s *com;
264	bool_t possibly_more_intrs;
265
266	disable_intr();
267	do {
268	possibly_more_intrs = FALSE;
269	for (com=d->com; com<d->com+d->nchan; ++com) {
270	if ((inb(com->int_id_port) & IIR_IMASK) != IIR_NOPEND) {
271	siointr1(com);
272	possibly_more_intrs = TRUE;
273	}
274	}
275	} while (possibly_more_intrs);
276	enable_intr();
277	}