File:  [DragonFly] / src / sys / net / i4b / driver / i4b_rbch.c
Revision 1.11: download - view: text, annotated - select for diffs
Wed May 19 22:52:59 2004 UTC (9 years, 11 months ago) by dillon
Branches: MAIN
CVS tags: HEAD, DragonFly_Snap13Sep2004, DragonFly_1_0_REL, DragonFly_1_0_RC1, DragonFly_1_0A_REL
Device layer rollup commit.

* cdevsw_add() is now required.  cdevsw_add() and cdevsw_remove() may specify
  a mask/match indicating the range of supported minor numbers.  Multiple
  cdevsw_add()'s using the same major number, but distinctly different
  ranges, may be issued.  All devices that failed to call cdevsw_add() before
  now do.

* cdevsw_remove() now automatically marks all devices within its supported
  range as being destroyed.

* vnode->v_rdev is no longer resolved when the vnode is created.  Instead,
  only v_udev (a newly added field) is resolved.  v_rdev is resolved when
  the vnode is opened and cleared on the last close.

* A great deal of code was making rather dubious assumptions with regards
  to the validity of devices associated with vnodes, primarily due to
  the persistence of a device structure due to being indexed by (major, minor)
  instead of by (cdevsw, major, minor).  In particular, if you run a program
  which connects to a USB device and then you pull the USB device and plug
  it back in, the vnode subsystem will continue to believe that the device
  is open when, in fact, it isn't (because it was destroyed and recreated).

  In particular, note that all the VFS mount procedures now check devices
  via v_udev instead of v_rdev prior to calling VOP_OPEN(), since v_rdev
  is NULL prior to the first open.

* The disk layer's device interaction has been rewritten.  The disk layer
  (i.e. the slice and disklabel management layer) no longer overloads
  its data onto the device structure representing the underlying physical
  disk.  Instead, the disk layer uses the new cdevsw_add() functionality
  to register its own cdevsw using the underlying device's major number,
  and simply does NOT register the underlying device's cdevsw.  No
  confusion is created because the device hash is now based on
  (cdevsw,major,minor) rather then (major,minor).

  NOTE: This also means that underlying raw disk devices may use the entire
  device minor number instead of having to reserve the bits used by the disk
  layer, and also means that can we (theoretically) stack a fully
  disklabel-supported 'disk' on top of any block device.

* The new reference counting scheme prevents this by associating a device
  with a cdevsw and disconnecting the device from its cdevsw when the cdevsw
  is removed.  Additionally, all udev2dev() lookups run through the cdevsw
  mask/match and only successfully find devices still associated with an
  active cdevsw.

* Major work on MFS:  MFS no longer shortcuts vnode and device creation.  It
  now creates a real vnode and a real device and implements real open and
  close VOPs.  Additionally, due to the disk layer changes, MFS is no longer
  limited to 255 mounts.  The new limit is 16 million.  Since MFS creates a
  real device node, mount_mfs will now create a real /dev/mfs<PID> device
  that can be read from userland (e.g. so you can dump an MFS filesystem).

* BUF AND DEVICE STRATEGY changes.  The struct buf contains a b_dev field.
  In order to properly handle stacked devices we now require that the b_dev
  field be initialized before the device strategy routine is called.  This
  required some additional work in various VFS implementations.  To enforce
  this requirement, biodone() now sets b_dev to NODEV.  The new disk layer
  will adjust b_dev before forwarding a request to the actual physical
  device.

* A bug in the ISO CD boot sequence which resulted in a panic has been fixed.

Testing by: lots of people, but David Rhodus found the most aggregious bugs.

    1: /*
    2:  * Copyright (c) 1997, 2001 Hellmuth Michaelis. All rights reserved.
    3:  *
    4:  * Redistribution and use in source and binary forms, with or without
    5:  * modification, are permitted provided that the following conditions
    6:  * are met:
    7:  * 1. Redistributions of source code must retain the above copyright
    8:  *    notice, this list of conditions and the following disclaimer.
    9:  * 2. Redistributions in binary form must reproduce the above copyright
   10:  *    notice, this list of conditions and the following disclaimer in the
   11:  *    documentation and/or other materials provided with the distribution.
   12:  *
   13:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   14:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   15:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   16:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   17:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   18:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   19:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   20:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   21:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   22:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   23:  * SUCH DAMAGE.
   24:  *
   25:  *---------------------------------------------------------------------------
   26:  *
   27:  *	i4b_rbch.c - device driver for raw B channel data
   28:  *	---------------------------------------------------
   29:  *
   30:  * $FreeBSD: src/sys/i4b/driver/i4b_rbch.c,v 1.10.2.3 2001/08/12 16:22:48 hm Exp $
   31:  * $DragonFly: src/sys/net/i4b/driver/i4b_rbch.c,v 1.11 2004/05/19 22:52:59 dillon Exp $
   32:  *
   33:  *	last edit-date: [Sat Aug 11 18:06:57 2001]
   34:  *
   35:  *---------------------------------------------------------------------------*/
   36: 
   37: #include "use_i4brbch.h"
   38: 
   39: #if NI4BRBCH > 0
   40: 
   41: #include <sys/param.h>
   42: #include <sys/systm.h>
   43: 
   44: #include <sys/conf.h>
   45: #include <sys/uio.h>
   46: #include <sys/kernel.h>
   47: #include <sys/mbuf.h>
   48: #include <sys/socket.h>
   49: #include <net/if.h>
   50: #include <sys/tty.h>
   51: 
   52: #if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
   53: #include <sys/callout.h>
   54: #endif
   55: 
   56: #if defined (__NetBSD__) || defined (__OpenBSD__)
   57: extern cc_t ttydefchars;
   58: #define termioschars(t) memcpy((t)->c_cc, &ttydefchars, sizeof((t)->c_cc))
   59: #endif
   60: 
   61: #if defined(__DragonFly__) || defined(__FreeBSD__)
   62: 
   63: #ifdef DEVFS
   64: #include <sys/devfsext.h>
   65: #endif
   66: 
   67: #endif /* __FreeBSD__ */
   68: 
   69: #ifdef __NetBSD__
   70: #include <sys/filio.h>
   71: #endif
   72: 
   73: #if defined(__DragonFly__) || defined(__FreeBSD__)
   74: #include <net/i4b/include/machine/i4b_ioctl.h>
   75: #include <net/i4b/include/machine/i4b_rbch_ioctl.h>
   76: #include <net/i4b/include/machine/i4b_debug.h>
   77: #else
   78: #include <i4b/i4b_ioctl.h>
   79: #include <i4b/i4b_rbch_ioctl.h>
   80: #include <i4b/i4b_debug.h>
   81: #endif
   82: 
   83: #include "../include/i4b_global.h"
   84: #include "../include/i4b_mbuf.h"
   85: #include "../include/i4b_l3l4.h"
   86: #include "../layer4/i4b_l4.h"
   87: 
   88: #ifdef __bsdi__
   89: #include <sys/device.h>
   90: #endif
   91: 
   92: #ifdef OS_USES_POLL
   93: #include <sys/ioccom.h>
   94: #include <sys/poll.h>
   95: #else
   96: #include <sys/fcntl.h>
   97: #include <sys/ioctl.h>
   98: #endif
   99: 
  100: #if defined(__DragonFly__) || defined(__FreeBSD__)
  101: #include <sys/filio.h>
  102: #endif
  103: 
  104: static drvr_link_t rbch_drvr_linktab[NI4BRBCH];
  105: static isdn_link_t *isdn_linktab[NI4BRBCH];
  106: 
  107: #define I4BRBCHACCT		1 	/* enable accounting messages */
  108: #define	I4BRBCHACCTINTVL	2	/* accounting msg interval in secs */
  109: 
  110: static struct rbch_softc {
  111: 
  112: 	int sc_unit;			/* unit number 		*/
  113: 
  114: 	int sc_devstate;		/* state of driver	*/
  115: #define ST_IDLE		0x00
  116: #define ST_CONNECTED	0x01
  117: #define ST_ISOPEN	0x02
  118: #define ST_RDWAITDATA	0x04
  119: #define ST_WRWAITEMPTY	0x08
  120: #define ST_NOBLOCK	0x10
  121: 
  122: 	int sc_bprot;			/* B-ch protocol used	*/
  123: 
  124: 	call_desc_t *sc_cd;		/* Call Descriptor */
  125: 
  126: 	struct termios it_in;
  127: 
  128: 	struct ifqueue sc_hdlcq;	/* hdlc read queue	*/
  129: #define I4BRBCHMAXQLEN	10
  130: 
  131: 	struct selinfo selp;		/* select / poll	*/
  132: 
  133: #if I4BRBCHACCT
  134: #if defined(__DragonFly__) || defined(__FreeBSD__)
  135: 	struct callout_handle sc_callout;
  136: #endif	
  137: #if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
  138: 	struct callout	sc_callout;
  139: #endif
  140: 
  141: 	int		sc_iinb;	/* isdn driver # of inbytes	*/
  142: 	int		sc_ioutb;	/* isdn driver # of outbytes	*/
  143: 	int		sc_linb;	/* last # of bytes rx'd		*/
  144: 	int		sc_loutb;	/* last # of bytes tx'd 	*/
  145: 	int		sc_fn;		/* flag, first null acct	*/
  146: #endif	
  147: } rbch_softc[NI4BRBCH];
  148: 
  149: static void rbch_rx_data_rdy(int unit);
  150: static void rbch_tx_queue_empty(int unit);
  151: static void rbch_connect(int unit, void *cdp);
  152: static void rbch_disconnect(int unit, void *cdp);
  153: static void rbch_init_linktab(int unit);
  154: static void rbch_clrq(int unit);
  155: 
  156: #if !defined(__DragonFly__) && !defined(__FreeBSD__)
  157: #define PDEVSTATIC	/* - not static - */
  158: #define IOCTL_CMD_T	u_long
  159: void i4brbchattach (void);
  160: int i4brbchopen (dev_t dev, int flag, int fmt, struct proc *p);
  161: int i4brbchclose (dev_t dev, int flag, int fmt, struct proc *p);
  162: int i4brbchread (dev_t dev, struct uio *uio, int ioflag);
  163: int i4brbchwrite (dev_t dev, struct uio *uio, int ioflag);
  164: int i4brbchioctl (dev_t dev, IOCTL_CMD_T cmd, caddr_t arg, int flag, struct proc* pr);
  165: #ifdef OS_USES_POLL
  166: int i4brbchpoll (dev_t dev, int events, struct proc *p);
  167: #else
  168: PDEVSTATIC int i4brbchselect (dev_t dev, int rw, struct proc *p);
  169: #endif
  170: #endif
  171: 
  172: #if defined(__DragonFly__) || (BSD > 199306 && defined(__FreeBSD__))
  173: #define PDEVSTATIC	static
  174: #define IOCTL_CMD_T	u_long
  175: 
  176: PDEVSTATIC d_open_t i4brbchopen;
  177: PDEVSTATIC d_close_t i4brbchclose;
  178: PDEVSTATIC d_read_t i4brbchread;
  179: PDEVSTATIC d_read_t i4brbchwrite;
  180: PDEVSTATIC d_ioctl_t i4brbchioctl;
  181: 
  182: #ifdef OS_USES_POLL
  183: PDEVSTATIC d_poll_t i4brbchpoll;
  184: #define POLLFIELD	i4brbchpoll
  185: #else
  186: PDEVSTATIC d_select_t i4brbchselect;
  187: #define POLLFIELD	i4brbchselect
  188: #endif
  189: 
  190: #define CDEV_MAJOR 57
  191: 
  192: static struct cdevsw i4brbch_cdevsw = {
  193: 	/* name */      "i4brbch",
  194: 	/* maj */       CDEV_MAJOR,
  195: 	/* flags */     0,
  196: 	/* port */	NULL,
  197: 	/* clone */	NULL,
  198: 
  199: 	/* open */      i4brbchopen,
  200: 	/* close */     i4brbchclose,
  201: 	/* read */      i4brbchread,
  202: 	/* write */     i4brbchwrite,
  203: 	/* ioctl */     i4brbchioctl,
  204: 	/* poll */      POLLFIELD,
  205: 	/* mmap */      nommap,
  206: 	/* strategy */  nostrategy,
  207: 	/* dump */      nodump,
  208: 	/* psize */     nopsize
  209: };
  210: 
  211: static void i4brbchattach(void *);
  212: PSEUDO_SET(i4brbchattach, i4b_rbch);
  213: 
  214: /*===========================================================================*
  215:  *			DEVICE DRIVER ROUTINES
  216:  *===========================================================================*/
  217: 
  218: /*---------------------------------------------------------------------------*
  219:  *	initialization at kernel load time
  220:  *---------------------------------------------------------------------------*/
  221: static void
  222: i4brbchinit(void *unused)
  223: {
  224: 	cdevsw_add(&i4brbch_cdevsw, 0, 0);
  225: }
  226: 
  227: SYSINIT(i4brbchdev, SI_SUB_DRIVERS,
  228: 	SI_ORDER_MIDDLE+CDEV_MAJOR, &i4brbchinit, NULL);
  229: 
  230: #endif /* BSD > 199306 && defined(__FreeBSD__) */
  231: 
  232: #ifdef __bsdi__
  233: int i4brbchmatch(struct device *parent, struct cfdata *cf, void *aux);
  234: void dummy_i4brbchattach(struct device*, struct device *, void *);
  235: 
  236: #define CDEV_MAJOR 61
  237: 
  238: static struct cfdriver i4brbchcd =
  239: 	{ NULL, "i4brbch", i4brbchmatch, dummy_i4brbchattach, DV_DULL,
  240: 	  sizeof(struct cfdriver) };
  241: struct devsw i4brbchsw = 
  242: 	{ &i4brbchcd,
  243: 	  i4brbchopen,	i4brbchclose,	i4brbchread,	i4brbchwrite,
  244: 	  i4brbchioctl,	seltrue,	nommap,		nostrat,
  245: 	  nodump,	nopsize,	0,		nostop
  246: };
  247: 
  248: int
  249: i4brbchmatch(struct device *parent, struct cfdata *cf, void *aux)
  250: {
  251: 	printf("i4brbchmatch: aux=0x%x\n", aux);
  252: 	return 1;
  253: }
  254: void
  255: dummy_i4brbchattach(struct device *parent, struct device *self, void *aux)
  256: {
  257: 	printf("dummy_i4brbchattach: aux=0x%x\n", aux);
  258: }
  259: #endif /* __bsdi__ */
  260: 
  261: /*---------------------------------------------------------------------------*
  262:  *	interface attach routine
  263:  *---------------------------------------------------------------------------*/
  264: PDEVSTATIC void
  265: #if defined(__DragonFly__) || defined(__FreeBSD__)
  266: i4brbchattach(void *dummy)
  267: #else
  268: i4brbchattach()
  269: #endif
  270: {
  271: 	int i;
  272: 
  273: #ifndef HACK_NO_PSEUDO_ATTACH_MSG
  274: 	printf("i4brbch: %d raw B channel access device(s) attached\n", NI4BRBCH);
  275: #endif
  276: 	
  277: 	for(i=0; i < NI4BRBCH; i++)
  278: 	{
  279: #if defined(__DragonFly__) || defined(__FreeBSD__)
  280: 		make_dev(&i4brbch_cdevsw, i,
  281: 			UID_ROOT, GID_WHEEL, 0600, "i4brbch%d", i);
  282: #endif
  283: 
  284: #if I4BRBCHACCT
  285: #if defined(__DragonFly__) || defined(__FreeBSD__)
  286: 		callout_handle_init(&rbch_softc[i].sc_callout);
  287: #endif
  288: #if defined(__NetBSD__) && __NetBSD_Version__ >= 104230000
  289: 		callout_init(&rbch_softc[i].sc_callout);
  290: #endif
  291: 		rbch_softc[i].sc_fn = 1;
  292: #endif
  293: 		rbch_softc[i].sc_unit = i;
  294: 		rbch_softc[i].sc_devstate = ST_IDLE;
  295: 		rbch_softc[i].sc_hdlcq.ifq_maxlen = I4BRBCHMAXQLEN;
  296: #if defined(__FreeBSD__) && __FreeBSD__ > 4
  297: 		mtx_init(&rbch_softc[i].sc_hdlcq.ifq_mtx, "i4b_rbch", MTX_DEF);
  298: #endif		
  299: 		rbch_softc[i].it_in.c_ispeed = rbch_softc[i].it_in.c_ospeed = 64000;
  300: 		termioschars(&rbch_softc[i].it_in);
  301: 		rbch_init_linktab(i);
  302: 	}
  303: }
  304: 
  305: /*---------------------------------------------------------------------------*
  306:  *	open rbch device
  307:  *---------------------------------------------------------------------------*/
  308: PDEVSTATIC int
  309: i4brbchopen(dev_t dev, int flag, int fmt, struct thread *td)
  310: {
  311: 	int unit = minor(dev);
  312: 	
  313: 	if(unit >= NI4BRBCH)
  314: 		return(ENXIO);
  315: 
  316: 	if(rbch_softc[unit].sc_devstate & ST_ISOPEN)
  317: 		return(EBUSY);
  318: 
  319: #if 0
  320: 	rbch_clrq(unit);
  321: #endif
  322: 	
  323: 	rbch_softc[unit].sc_devstate |= ST_ISOPEN;		
  324: 
  325: 	NDBGL4(L4_RBCHDBG, "unit %d, open", unit);	
  326: 
  327: 	return(0);
  328: }
  329: 
  330: /*---------------------------------------------------------------------------*
  331:  *	close rbch device
  332:  *---------------------------------------------------------------------------*/
  333: PDEVSTATIC int
  334: i4brbchclose(dev_t dev, int flag, int fmt, struct thread *td)
  335: {
  336: 	int unit = minor(dev);
  337: 	struct rbch_softc *sc = &rbch_softc[unit];
  338: 	
  339: 	if(sc->sc_devstate & ST_CONNECTED)
  340: 		i4b_l4_drvrdisc(BDRV_RBCH, unit);
  341: 
  342: 	sc->sc_devstate &= ~ST_ISOPEN;		
  343: 
  344: 	rbch_clrq(unit);
  345: 	
  346: 	NDBGL4(L4_RBCHDBG, "unit %d, closed", unit);
  347: 	
  348: 	return(0);
  349: }
  350: 
  351: /*---------------------------------------------------------------------------*
  352:  *	read from rbch device
  353:  *---------------------------------------------------------------------------*/
  354: PDEVSTATIC int
  355: i4brbchread(dev_t dev, struct uio *uio, int ioflag)
  356: {
  357: 	struct mbuf *m;
  358: 	int error = 0;
  359: 	int unit = minor(dev);
  360: 	struct ifqueue *iqp;
  361: 	struct rbch_softc *sc = &rbch_softc[unit];
  362: 
  363: 	CRIT_VAR;
  364: 	
  365: 	NDBGL4(L4_RBCHDBG, "unit %d, enter read", unit);
  366: 	
  367: 	CRIT_BEG;
  368: 	if(!(sc->sc_devstate & ST_ISOPEN))
  369: 	{
  370: 		CRIT_END;
  371: 		NDBGL4(L4_RBCHDBG, "unit %d, read while not open", unit);
  372: 		return(EIO);
  373: 	}
  374: 
  375: 	if((sc->sc_devstate & ST_NOBLOCK))
  376: 	{
  377: 		if(!(sc->sc_devstate & ST_CONNECTED)) {
  378: 			CRIT_END;
  379: 			return(EWOULDBLOCK);
  380: 		}
  381: 
  382: 		if(sc->sc_bprot == BPROT_RHDLC)
  383: 			iqp = &sc->sc_hdlcq;
  384: 		else
  385: 			iqp = isdn_linktab[unit]->rx_queue;	
  386: 
  387: 		if(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN)) {
  388: 			CRIT_END;
  389: 			return(EWOULDBLOCK);
  390: 	}
  391: 	}
  392: 	else
  393: 	{
  394: 		while(!(sc->sc_devstate & ST_CONNECTED))
  395: 		{
  396: 			NDBGL4(L4_RBCHDBG, "unit %d, wait read init", unit);
  397: 		
  398: 			if((error = tsleep((caddr_t) &rbch_softc[unit],
  399: 					       PCATCH, "rrrbch", 0 )) != 0)
  400: 			{
  401: 				CRIT_END;
  402: 				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep", unit, error);
  403: 				return(error);
  404: 			}
  405: 		}
  406: 
  407: 		if(sc->sc_bprot == BPROT_RHDLC)
  408: 			iqp = &sc->sc_hdlcq;
  409: 		else
  410: 			iqp = isdn_linktab[unit]->rx_queue;	
  411: 
  412: 		while(IF_QEMPTY(iqp) && (sc->sc_devstate & ST_ISOPEN))
  413: 		{
  414: 			sc->sc_devstate |= ST_RDWAITDATA;
  415: 		
  416: 			NDBGL4(L4_RBCHDBG, "unit %d, wait read data", unit);
  417: 		
  418: 			if((error = tsleep((caddr_t) &isdn_linktab[unit]->rx_queue,
  419: 					   PCATCH, "rrbch", 0 )) != 0)
  420: 			{
  421: 				CRIT_END;
  422: 				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep read", unit, error);
  423: 				sc->sc_devstate &= ~ST_RDWAITDATA;
  424: 				return(error);
  425: 			}
  426: 		}
  427: 	}
  428: 
  429: 	IF_DEQUEUE(iqp, m);
  430: 
  431: 	NDBGL4(L4_RBCHDBG, "unit %d, read %d bytes", unit, m->m_len);
  432: 	
  433: 	if(m && m->m_len)
  434: 	{
  435: 		error = uiomove(m->m_data, m->m_len, uio);
  436: 	}
  437: 	else
  438: 	{
  439: 		NDBGL4(L4_RBCHDBG, "unit %d, error %d uiomove", unit, error);
  440: 		error = EIO;
  441: 	}
  442: 		
  443: 	if(m)
  444: 		i4b_Bfreembuf(m);
  445: 
  446: 	CRIT_END;
  447: 
  448: 	return(error);
  449: }
  450: 
  451: /*---------------------------------------------------------------------------*
  452:  *	write to rbch device
  453:  *---------------------------------------------------------------------------*/
  454: PDEVSTATIC int
  455: i4brbchwrite(dev_t dev, struct uio * uio, int ioflag)
  456: {
  457: 	struct mbuf *m;
  458: 	int error = 0;
  459: 	int unit = minor(dev);
  460: 	struct rbch_softc *sc = &rbch_softc[unit];
  461: 
  462: 	CRIT_VAR;
  463: 	
  464: 	NDBGL4(L4_RBCHDBG, "unit %d, write", unit);	
  465: 
  466: 	CRIT_BEG;
  467: 	if(!(sc->sc_devstate & ST_ISOPEN))
  468: 	{
  469: 		NDBGL4(L4_RBCHDBG, "unit %d, write while not open", unit);
  470: 		CRIT_END;
  471: 		return(EIO);
  472: 	}
  473: 
  474: 	if((sc->sc_devstate & ST_NOBLOCK))
  475: 	{
  476: 		if(!(sc->sc_devstate & ST_CONNECTED)) {
  477: 			CRIT_END;
  478: 			return(EWOULDBLOCK);
  479: 		}
  480: 		if(_IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN)) {
  481: 			CRIT_END;
  482: 			return(EWOULDBLOCK);
  483: 	}
  484: 	}
  485: 	else
  486: 	{
  487: 		while(!(sc->sc_devstate & ST_CONNECTED))
  488: 		{
  489: 			NDBGL4(L4_RBCHDBG, "unit %d, write wait init", unit);
  490: 		
  491: 			error = tsleep((caddr_t) &rbch_softc[unit],
  492: 						   PCATCH, "wrrbch", 0 );
  493: 			if(error == ERESTART) {
  494: 				CRIT_END;
  495: 				return (ERESTART);
  496: 			}
  497: 			else if(error == EINTR)
  498: 			{
  499: 				CRIT_END;
  500: 				NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait init", unit);
  501: 				return(EINTR);
  502: 			}
  503: 			else if(error)
  504: 			{
  505: 				CRIT_END;
  506: 				NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep init", unit, error);
  507: 				return(error);
  508: 			}
  509: 			tsleep((caddr_t) &rbch_softc[unit], PCATCH, "xrbch", (hz*1));
  510: 		}
  511: 
  512: 		while(_IF_QFULL(isdn_linktab[unit]->tx_queue) && (sc->sc_devstate & ST_ISOPEN))
  513: 		{
  514: 			sc->sc_devstate |= ST_WRWAITEMPTY;
  515: 
  516: 			NDBGL4(L4_RBCHDBG, "unit %d, write queue full", unit);
  517: 		
  518: 			if ((error = tsleep((caddr_t) &isdn_linktab[unit]->tx_queue,
  519: 					    PCATCH, "wrbch", 0)) != 0) {
  520: 				sc->sc_devstate &= ~ST_WRWAITEMPTY;
  521: 				if(error == ERESTART)
  522: 				{
  523: 					CRIT_END;
  524: 					return(ERESTART);
  525: 				}
  526: 				else if(error == EINTR)
  527: 				{
  528: 					CRIT_END;
  529: 					NDBGL4(L4_RBCHDBG, "unit %d, EINTR during wait write", unit);
  530: 					return(error);
  531: 				}
  532: 				else if(error)
  533: 				{
  534: 					CRIT_END;
  535: 					NDBGL4(L4_RBCHDBG, "unit %d, error %d tsleep write", unit, error);
  536: 					return(error);
  537: 				}
  538: 			}
  539: 		}
  540: 	}
  541: 
  542: 	if(!(sc->sc_devstate & ST_ISOPEN))
  543: 	{
  544: 		NDBGL4(L4_RBCHDBG, "unit %d, not open anymore", unit);
  545: 		CRIT_END;
  546: 		return(EIO);
  547: 	}
  548: 
  549: 	if((m = i4b_Bgetmbuf(BCH_MAX_DATALEN)) != NULL)
  550: 	{
  551: 		m->m_len = min(BCH_MAX_DATALEN, uio->uio_resid);
  552: 
  553: 		NDBGL4(L4_RBCHDBG, "unit %d, write %d bytes", unit, m->m_len);
  554: 		
  555: 		error = uiomove(m->m_data, m->m_len, uio);
  556: 
  557: #if defined (__FreeBSD__) && __FreeBSD__ > 4		
  558: 		(void) IF_HANDOFF(isdn_linktab[unit]->tx_queue, m, NULL);
  559: #else
  560: 		if(IF_QFULL(isdn_linktab[unit]->tx_queue))
  561: 			m_freem(m);
  562: 		else
  563: 			IF_ENQUEUE(isdn_linktab[unit]->tx_queue, m);
  564: #endif
  565: 		(*isdn_linktab[unit]->bch_tx_start)(isdn_linktab[unit]->unit, isdn_linktab[unit]->channel);
  566: 	}
  567: 
  568: 	CRIT_END;
  569: 	
  570: 	return(error);
  571: }
  572: 
  573: /*---------------------------------------------------------------------------*
  574:  *	rbch device ioctl handlibg
  575:  *---------------------------------------------------------------------------*/
  576: PDEVSTATIC int
  577: i4brbchioctl(dev_t dev, IOCTL_CMD_T cmd, caddr_t data, int flag, struct thread *td)
  578: {
  579: 	int error = 0;
  580: 	int unit = minor(dev);
  581: 	struct rbch_softc *sc = &rbch_softc[unit];
  582: 	
  583: 	switch(cmd)
  584: 	{
  585: 		case FIOASYNC:	/* Set async mode */
  586: 			if (*(int *)data)
  587: 			{
  588: 				NDBGL4(L4_RBCHDBG, "unit %d, setting async mode", unit);
  589: 			}
  590: 			else
  591: 			{
  592: 				NDBGL4(L4_RBCHDBG, "unit %d, clearing async mode", unit);
  593: 			}
  594: 			break;
  595: 
  596: 		case FIONBIO:
  597: 			if (*(int *)data)
  598: 			{
  599: 				NDBGL4(L4_RBCHDBG, "unit %d, setting non-blocking mode", unit);
  600: 				sc->sc_devstate |= ST_NOBLOCK;
  601: 			}
  602: 			else
  603: 			{
  604: 				NDBGL4(L4_RBCHDBG, "unit %d, clearing non-blocking mode", unit);
  605: 				sc->sc_devstate &= ~ST_NOBLOCK;
  606: 			}
  607: 			break;
  608: 
  609: 		case TIOCCDTR:	/* Clear DTR */
  610: 			if(sc->sc_devstate & ST_CONNECTED)
  611: 			{
  612: 				NDBGL4(L4_RBCHDBG, "unit %d, disconnecting for DTR down", unit);
  613: 				i4b_l4_drvrdisc(BDRV_RBCH, unit);
  614: 			}
  615: 			break;
  616: 
  617: 		case I4B_RBCH_DIALOUT:
  618:                 {
  619: 			size_t l;
  620: 
  621: 			for (l = 0; l < TELNO_MAX && ((char *)data)[l]; l++)
  622: 				;
  623: 			if (l)
  624: 			{
  625: 				NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout to %s", unit, (char *)data);
  626: 				i4b_l4_dialoutnumber(BDRV_RBCH, unit, l, (char *)data);
  627: 				break;
  628: 			}
  629: 			/* fall through to SDTR */
  630: 		}
  631: 
  632: 		case TIOCSDTR:	/* Set DTR */
  633: 			NDBGL4(L4_RBCHDBG, "unit %d, attempting dialout (DTR)", unit);
  634: 			i4b_l4_dialout(BDRV_RBCH, unit);
  635: 			break;
  636: 
  637: 		case TIOCSETA:	/* Set termios struct */
  638: 			break;
  639: 
  640: 		case TIOCGETA:	/* Get termios struct */
  641: 			*(struct termios *)data = sc->it_in;
  642: 			break;
  643: 
  644: 		case TIOCMGET:
  645: 			*(int *)data = TIOCM_LE|TIOCM_DTR|TIOCM_RTS|TIOCM_CTS|TIOCM_DSR;
  646: 			if (sc->sc_devstate & ST_CONNECTED)
  647: 				*(int *)data |= TIOCM_CD;
  648: 			break;
  649: 
  650: 		case I4B_RBCH_VR_REQ:
  651:                 {
  652: 			msg_vr_req_t *mvr;
  653: 
  654: 			mvr = (msg_vr_req_t *)data;
  655: 
  656: 			mvr->version = VERSION;
  657: 			mvr->release = REL;
  658: 			mvr->step = STEP;			
  659: 			break;
  660: 		}
  661: 
  662: 		default:	/* Unknown stuff */
  663: 			NDBGL4(L4_RBCHDBG, "unit %d, ioctl, unknown cmd %lx", unit, (u_long)cmd);
  664: 			error = EINVAL;
  665: 			break;
  666: 	}
  667: 	return(error);
  668: }
  669: 
  670: #ifdef OS_USES_POLL
  671: 
  672: /*---------------------------------------------------------------------------*
  673:  *	device driver poll
  674:  *---------------------------------------------------------------------------*/
  675: PDEVSTATIC int
  676: i4brbchpoll(dev_t dev, int events, struct thread *td)
  677: {
  678: 	int revents = 0;	/* Events we found */
  679: 	int s;
  680: 	int unit = minor(dev);
  681: 	struct rbch_softc *sc = &rbch_softc[unit];
  682: 	
  683: 	/* We can't check for anything but IN or OUT */
  684: 
  685: 	s = splhigh();
  686: 
  687: 	if(!(sc->sc_devstate & ST_ISOPEN))
  688: 	{
  689: 		splx(s);
  690: 		return(POLLNVAL);
  691: 	}
  692: 
  693: 	/*
  694: 	 * Writes are OK if we are connected and the
  695:          * transmit queue can take them
  696: 	 */
  697: 	 
  698: 	if((events & (POLLOUT|POLLWRNORM)) &&
  699: 	   (sc->sc_devstate & ST_CONNECTED) &&
  700: 	   !_IF_QFULL(isdn_linktab[unit]->tx_queue))
  701: 	{
  702: 		revents |= (events & (POLLOUT|POLLWRNORM));
  703: 	}
  704: 	
  705: 	/* ... while reads are OK if we have any data */
  706: 
  707: 	if((events & (POLLIN|POLLRDNORM)) &&
  708: 	   (sc->sc_devstate & ST_CONNECTED))
  709: 	{
  710: 		struct ifqueue *iqp;
  711: 
  712: 		if(sc->sc_bprot == BPROT_RHDLC)
  713: 			iqp = &sc->sc_hdlcq;
  714: 		else
  715: 			iqp = isdn_linktab[unit]->rx_queue;	
  716: 
  717: 		if(!IF_QEMPTY(iqp))
  718: 			revents |= (events & (POLLIN|POLLRDNORM));
  719: 	}
  720: 		
  721: 	if(revents == 0)
  722: 		selrecord(td, &sc->selp);
  723: 
  724: 	splx(s);
  725: 	return(revents);
  726: }
  727: 
  728: #else /* OS_USES_POLL */
  729: 
  730: /*---------------------------------------------------------------------------*
  731:  *	device driver select
  732:  *---------------------------------------------------------------------------*/
  733: PDEVSTATIC int
  734: i4brbchselect(dev_t dev, int rw, struct thread *td)
  735: {
  736: 	int unit = minor(dev);
  737: 	struct rbch_softc *sc = &rbch_softc[unit];
  738:         int s;
  739: 
  740: 	s = splhigh();
  741: 
  742: 	if(!(sc->sc_devstate & ST_ISOPEN))
  743: 	{
  744: 		splx(s);
  745: 		NDBGL4(L4_RBCHDBG, "unit %d, not open anymore", unit);
  746: 		return(1);
  747: 	}
  748: 	
  749: 	if(sc->sc_devstate & ST_CONNECTED)
  750: 	{
  751: 		struct ifqueue *iqp;
  752: 
  753: 		switch(rw)
  754: 		{
  755: 			case FREAD:
  756: 				if(sc->sc_bprot == BPROT_RHDLC)
  757: 					iqp = &sc->sc_hdlcq;
  758: 				else
  759: 					iqp = isdn_linktab[unit]->rx_queue;	
  760: 
  761: 				if(!IF_QEMPTY(iqp))
  762: 				{
  763: 					splx(s);
  764: 					return(1);
  765: 				}
  766: 				break;
  767: 
  768: 			case FWRITE:
  769: 				if(!_IF_QFULL(isdn_linktab[unit]->rx_queue))
  770: 				{
  771: 					splx(s);
  772: 					return(1);
  773: 				}
  774: 				break;
  775: 
  776: 			default:
  777: 				splx(s);
  778: 				return 0;
  779: 		}
  780: 	}
  781: 	selrecord(p, &sc->selp);
  782: 	splx(s);
  783: 	return(0);
  784: }
  785: 
  786: #endif /* OS_USES_POLL */
  787: 
  788: #if I4BRBCHACCT
  789: /*---------------------------------------------------------------------------*
  790:  *	watchdog routine
  791:  *---------------------------------------------------------------------------*/
  792: static void
  793: rbch_timeout(struct rbch_softc *sc)
  794: {
  795: 	bchan_statistics_t bs;
  796: 	int unit = sc->sc_unit;
  797: 
  798: 	/* get # of bytes in and out from the HSCX driver */ 
  799: 	
  800: 	(*isdn_linktab[unit]->bch_stat)
  801: 		(isdn_linktab[unit]->unit, isdn_linktab[unit]->channel, &bs);
  802: 
  803: 	sc->sc_ioutb += bs.outbytes;
  804: 	sc->sc_iinb += bs.inbytes;
  805: 	
  806: 	if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn) 
  807: 	{
  808: 		int ri = (sc->sc_iinb - sc->sc_linb)/I4BRBCHACCTINTVL;
  809: 		int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BRBCHACCTINTVL;
  810: 
  811: 		if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
  812: 			sc->sc_fn = 0;
  813: 		else
  814: 			sc->sc_fn = 1;
  815: 			
  816: 		sc->sc_linb = sc->sc_iinb;
  817: 		sc->sc_loutb = sc->sc_ioutb;
  818: 
  819: 		i4b_l4_accounting(BDRV_RBCH, unit, ACCT_DURING,
  820: 			 sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_ioutb, sc->sc_iinb);
  821:  	}
  822: 	START_TIMER(sc->sc_callout, rbch_timeout, sc, I4BRBCHACCTINTVL*hz);
  823: }
  824: #endif /* I4BRBCHACCT */
  825: 
  826: /*===========================================================================*
  827:  *			ISDN INTERFACE ROUTINES
  828:  *===========================================================================*/
  829: 
  830: /*---------------------------------------------------------------------------*
  831:  *	this routine is called from L4 handler at connect time
  832:  *---------------------------------------------------------------------------*/
  833: static void
  834: rbch_connect(int unit, void *cdp)
  835: {
  836: 	call_desc_t *cd = (call_desc_t *)cdp;
  837: 	struct rbch_softc *sc = &rbch_softc[unit];
  838: 
  839: 	sc->sc_bprot = cd->bprot;
  840: 
  841: #if I4BRBCHACCT
  842: 	if(sc->sc_bprot == BPROT_RHDLC)
  843: 	{	
  844: 		sc->sc_iinb = 0;
  845: 		sc->sc_ioutb = 0;
  846: 		sc->sc_linb = 0;
  847: 		sc->sc_loutb = 0;
  848: 
  849: 		START_TIMER(sc->sc_callout, rbch_timeout, sc, I4BRBCHACCTINTVL*hz);
  850: 	}
  851: #endif		
  852: 	if(!(sc->sc_devstate & ST_CONNECTED))
  853: 	{
  854: 		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
  855: 		sc->sc_devstate |= ST_CONNECTED;
  856: 		sc->sc_cd = cdp;
  857: 		wakeup((caddr_t)sc);
  858: 	}
  859: }
  860: 
  861: /*---------------------------------------------------------------------------*
  862:  *	this routine is called from L4 handler at disconnect time
  863:  *---------------------------------------------------------------------------*/
  864: static void
  865: rbch_disconnect(int unit, void *cdp)
  866: {
  867: 	call_desc_t *cd = (call_desc_t *)cdp;
  868: 	struct rbch_softc *sc = &rbch_softc[unit];
  869: 
  870: 	CRIT_VAR;
  871: 	
  872:         if(cd != sc->sc_cd)
  873: 	{
  874: 		NDBGL4(L4_RBCHDBG, "rbch%d: channel %d not active",
  875: 			cd->driver_unit, cd->channelid);
  876: 		return;
  877: 	}
  878: 
  879: 	CRIT_BEG;
  880: 	
  881: 	NDBGL4(L4_RBCHDBG, "unit %d, disconnect", unit);
  882: 
  883: 	sc->sc_devstate &= ~ST_CONNECTED;
  884: 
  885: 	sc->sc_cd = NULL;
  886: 	
  887: #if I4BRBCHACCT
  888: 	i4b_l4_accounting(BDRV_RBCH, unit, ACCT_FINAL,
  889: 		 sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_ioutb, sc->sc_iinb);
  890: 
  891: 	STOP_TIMER(sc->sc_callout, rbch_timeout, sc);
  892: #endif		
  893: 	CRIT_END;
  894: }
  895: 	
  896: /*---------------------------------------------------------------------------*
  897:  *	feedback from daemon in case of dial problems
  898:  *---------------------------------------------------------------------------*/
  899: static void
  900: rbch_dialresponse(int unit, int status, cause_t cause)
  901: {
  902: }
  903: 	
  904: /*---------------------------------------------------------------------------*
  905:  *	interface up/down
  906:  *---------------------------------------------------------------------------*/
  907: static void
  908: rbch_updown(int unit, int updown)
  909: {
  910: }
  911: 	
  912: /*---------------------------------------------------------------------------*
  913:  *	this routine is called from the HSCX interrupt handler
  914:  *	when a new frame (mbuf) has been received and is to be put on
  915:  *	the rx queue.
  916:  *---------------------------------------------------------------------------*/
  917: static void
  918: rbch_rx_data_rdy(int unit)
  919: {
  920: 	if(rbch_softc[unit].sc_bprot == BPROT_RHDLC)
  921: 	{
  922: 		struct mbuf *m;
  923: 		
  924: 		if((m = *isdn_linktab[unit]->rx_mbuf) == NULL)
  925: 			return;
  926: 
  927: 		m->m_pkthdr.len = m->m_len;
  928: 
  929: #if defined (__FreeBSD__) && __FreeBSD__ > 4
  930: 		if (! IF_HANDOFF(&(rbch_softc[unit].sc_hdlcq), m, NULL))
  931: 		{
  932: 			NDBGL4(L4_RBCHDBG, "unit %d: hdlc rx queue full!", unit);
  933: 		}
  934: #else
  935:                 if(IF_QFULL(&(rbch_softc[unit].sc_hdlcq)))
  936: 		{
  937: 			NDBGL4(L4_RBCHDBG, "unit %d: hdlc rx queue full!", unit);
  938: 			m_freem(m);
  939: 		}			
  940: 		else
  941: 		{
  942: 			IF_ENQUEUE(&(rbch_softc[unit].sc_hdlcq), m);
  943: 		}
  944: #endif		
  945: 	}
  946: 
  947: 	if(rbch_softc[unit].sc_devstate & ST_RDWAITDATA)
  948: 	{
  949: 		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
  950: 		rbch_softc[unit].sc_devstate &= ~ST_RDWAITDATA;
  951: 		wakeup((caddr_t) &isdn_linktab[unit]->rx_queue);
  952: 	}
  953: 	else
  954: 	{
  955: 		NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
  956: 	}
  957: 	selwakeup(&rbch_softc[unit].selp);
  958: }
  959: 
  960: /*---------------------------------------------------------------------------*
  961:  *	this routine is called from the HSCX interrupt handler
  962:  *	when the last frame has been sent out and there is no
  963:  *	further frame (mbuf) in the tx queue.
  964:  *---------------------------------------------------------------------------*/
  965: static void
  966: rbch_tx_queue_empty(int unit)
  967: {
  968: 	if(rbch_softc[unit].sc_devstate & ST_WRWAITEMPTY)
  969: 	{
  970: 		NDBGL4(L4_RBCHDBG, "unit %d, wakeup", unit);
  971: 		rbch_softc[unit].sc_devstate &= ~ST_WRWAITEMPTY;
  972: 		wakeup((caddr_t) &isdn_linktab[unit]->tx_queue);
  973: 	}
  974: 	else
  975: 	{
  976: 		NDBGL4(L4_RBCHDBG, "unit %d, NO wakeup", unit);
  977: 	}
  978: 	selwakeup(&rbch_softc[unit].selp);
  979: }
  980: 
  981: /*---------------------------------------------------------------------------*
  982:  *	this routine is called from the HSCX interrupt handler
  983:  *	each time a packet is received or transmitted
  984:  *---------------------------------------------------------------------------*/
  985: static void
  986: rbch_activity(int unit, int rxtx)
  987: {
  988: 	if (rbch_softc[unit].sc_cd)
  989: 		rbch_softc[unit].sc_cd->last_active_time = SECOND;
  990: 	selwakeup(&rbch_softc[unit].selp);
  991: }
  992: 
  993: /*---------------------------------------------------------------------------*
  994:  *	clear an hdlc rx queue for a rbch unit
  995:  *---------------------------------------------------------------------------*/
  996: static void
  997: rbch_clrq(int unit)
  998: {
  999: 	CRIT_VAR;
 1000: 
 1001: #if defined (__FreeBSD__) && __FreeBSD__ > 4
 1002: 	CRIT_BEG;
 1003: 	IF_DRAIN(&rbch_softc[unit].sc_hdlcq);
 1004: 	CRIT_END;
 1005: #else
 1006: 	struct mbuf *m;
 1007:         for(;;)
 1008:         {
 1009:                 CRIT_BEG;
 1010:                 IF_DEQUEUE(&rbch_softc[unit].sc_hdlcq, m);
 1011:                 CRIT_END;
 1012: 
 1013:                 if(m)
 1014:                         m_freem(m);
 1015:                 else
 1016:                         break;
 1017:         }
 1018: #endif	
 1019: }
 1020: 				
 1021: /*---------------------------------------------------------------------------*
 1022:  *	return this drivers linktab address
 1023:  *---------------------------------------------------------------------------*/
 1024: drvr_link_t *
 1025: rbch_ret_linktab(int unit)
 1026: {
 1027: 	rbch_init_linktab(unit);
 1028: 	return(&rbch_drvr_linktab[unit]);
 1029: }
 1030: 
 1031: /*---------------------------------------------------------------------------*
 1032:  *	setup the isdn_linktab for this driver
 1033:  *---------------------------------------------------------------------------*/
 1034: void
 1035: rbch_set_linktab(int unit, isdn_link_t *ilt)
 1036: {
 1037: 	isdn_linktab[unit] = ilt;
 1038: }
 1039: 
 1040: /*---------------------------------------------------------------------------*
 1041:  *	initialize this drivers linktab
 1042:  *---------------------------------------------------------------------------*/
 1043: static void
 1044: rbch_init_linktab(int unit)
 1045: {
 1046: 	rbch_drvr_linktab[unit].unit = unit;
 1047: 	rbch_drvr_linktab[unit].bch_rx_data_ready = rbch_rx_data_rdy;
 1048: 	rbch_drvr_linktab[unit].bch_tx_queue_empty = rbch_tx_queue_empty;
 1049: 	rbch_drvr_linktab[unit].bch_activity = rbch_activity;	
 1050: 	rbch_drvr_linktab[unit].line_connected = rbch_connect;
 1051: 	rbch_drvr_linktab[unit].line_disconnected = rbch_disconnect;
 1052: 	rbch_drvr_linktab[unit].dial_response = rbch_dialresponse;
 1053: 	rbch_drvr_linktab[unit].updown_ind = rbch_updown;	
 1054: }
 1055: 
 1056: /*===========================================================================*/
 1057: 
 1058: #endif /* NI4BRBCH > 0 */