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 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 */
![[BACK]](/icons//back.gif){kind=icon}
Return to i4b_rbch.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / net / i4b / driver