* Remove (void) casts for discarded return values.
[dragonfly.git] / sys / net / i4b / layer2 / i4b_l2.c
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_l2.c - ISDN layer 2 (Q.921)
28  *      -------------------------------
29  *
30  * $FreeBSD: src/sys/i4b/layer2/i4b_l2.c,v 1.6.2.1 2001/08/10 14:08:41 obrien Exp $
31  * $DragonFly: src/sys/net/i4b/layer2/i4b_l2.c,v 1.10 2006/01/14 11:05:18 swildner Exp $
32  *
33  *      last edit-date: [Fri Jan 12 16:43:31 2001]
34  *
35  *---------------------------------------------------------------------------*/
36
37 #include "use_i4bq921.h"
38 #if NI4BQ921 > 0
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/mbuf.h>
43 #include <sys/socket.h>
44 #include <sys/thread2.h>
45 #include <net/if.h>
46
47 #include <net/i4b/include/machine/i4b_debug.h>
48
49 #include "../include/i4b_l1l2.h"
50 #include "../include/i4b_l2l3.h"
51 #include "../include/i4b_mbuf.h"
52 #include "../include/i4b_global.h"
53
54 #include "i4b_l2.h"
55 #include "i4b_l2fsm.h"
56
57 int i4b_dl_establish_ind(int);
58 int i4b_dl_establish_cnf(int);
59 int i4b_dl_release_ind(int);
60 int i4b_dl_release_cnf(int);
61 int i4b_dl_data_ind(int, struct mbuf *);
62 int i4b_dl_unit_data_ind(int, struct mbuf *);
63
64 static int i4b_mdl_command_req(int, int, void *);
65
66 /* from layer 2 */
67
68 extern int i4b_mdl_status_ind(int, int, int);
69
70 /* this layers debug level */
71
72 unsigned int i4b_l2_debug = L2_DEBUG_DEFAULT;
73
74 struct i4b_l2l3_func i4b_l2l3_func = {
75
76         /* Layer 2 --> Layer 3 */
77         
78         (int (*)(int))                          i4b_dl_establish_ind,
79         (int (*)(int))                          i4b_dl_establish_cnf,
80         (int (*)(int))                          i4b_dl_release_ind,
81         (int (*)(int))                          i4b_dl_release_cnf,
82         (int (*)(int, struct mbuf *))           i4b_dl_data_ind,
83         (int (*)(int, struct mbuf *))           i4b_dl_unit_data_ind,
84
85         /* Layer 3 --> Layer 2 */
86
87         (int (*)(int))                          i4b_dl_establish_req,
88         (int (*)(int))                          i4b_dl_release_req,
89         (int (*)(int, struct mbuf *))           i4b_dl_data_req,
90         (int (*)(int, struct mbuf *))           i4b_dl_unit_data_req,
91
92         /* Layer 2 --> Layer 3 management */
93         
94         (int (*)(int, int, int))                i4b_mdl_status_ind,
95
96         /* Layer 3  --> Layer 2 management */
97         
98         (int (*)(int, int, void *))             i4b_mdl_command_req     
99 };
100
101 /*---------------------------------------------------------------------------*
102  *      DL_ESTABLISH_REQ from layer 3
103  *---------------------------------------------------------------------------*/
104 int
105 i4b_dl_establish_req(int unit)
106 {
107         l2_softc_t *l2sc = &l2_softc[unit];
108         
109         NDBGL2(L2_PRIM, "unit %d",unit);
110         i4b_l1_activate(l2sc);
111         i4b_next_l2state(l2sc, EV_DLESTRQ);
112         return(0);
113 }
114
115 /*---------------------------------------------------------------------------*
116  *      DL_RELEASE_REQ from layer 3
117  *---------------------------------------------------------------------------*/
118 int
119 i4b_dl_release_req(int unit)
120 {
121         l2_softc_t *l2sc = &l2_softc[unit];
122
123         NDBGL2(L2_PRIM, "unit %d",unit);        
124         i4b_next_l2state(l2sc, EV_DLRELRQ);
125         return(0);      
126 }
127
128 /*---------------------------------------------------------------------------*
129  *      DL UNIT DATA REQUEST from Layer 3
130  *---------------------------------------------------------------------------*/
131 int
132 i4b_dl_unit_data_req(int unit, struct mbuf *m)
133 {
134 #ifdef NOTDEF
135         NDBGL2(L2_PRIM, "unit %d",unit);
136 #endif
137         return(0);
138 }
139
140 /*---------------------------------------------------------------------------*
141  *      DL DATA REQUEST from Layer 3
142  *---------------------------------------------------------------------------*/
143 int
144 i4b_dl_data_req(int unit, struct mbuf *m)
145 {
146         l2_softc_t *l2sc = &l2_softc[unit];
147
148 #ifdef NOTDEF
149         NDBGL2(L2_PRIM, "unit %d",unit);
150 #endif
151         switch(l2sc->Q921_state)
152         {
153                 case ST_AW_EST:
154                 case ST_MULTIFR:
155                 case ST_TIMREC:
156                 
157                         if(IF_QFULL(&l2sc->i_queue))
158                         {
159                                 NDBGL2(L2_ERROR, "i_queue full!!");
160                                 i4b_Dfreembuf(m);
161                         }
162                         else
163                         {
164                                 CRIT_VAR;
165
166                                 CRIT_BEG;
167                                 IF_ENQUEUE(&l2sc->i_queue, m);
168                                 CRIT_END;
169
170                                 i4b_i_frame_queued_up(l2sc);
171                         }
172                         break;
173                         
174                 default:
175                         NDBGL2(L2_ERROR, "unit %d ERROR in state [%s], freeing mbuf", unit, i4b_print_l2state(l2sc));
176                         i4b_Dfreembuf(m);
177                         break;
178         }               
179         return(0);
180 }
181
182 /*---------------------------------------------------------------------------*
183  *      i4b_ph_activate_ind - link activation indication from layer 1
184  *---------------------------------------------------------------------------*/
185 int
186 i4b_ph_activate_ind(int unit)
187 {
188         l2_softc_t *l2sc = &l2_softc[unit];
189
190         NDBGL1(L1_PRIM, "unit %d",unit);
191         l2sc->ph_active = PH_ACTIVE;
192         return(0);
193 }
194
195 /*---------------------------------------------------------------------------*
196  *      i4b_ph_deactivate_ind - link deactivation indication from layer 1
197  *---------------------------------------------------------------------------*/
198 int
199 i4b_ph_deactivate_ind(int unit)
200 {
201         l2_softc_t *l2sc = &l2_softc[unit];
202
203         NDBGL1(L1_PRIM, "unit %d",unit);
204         l2sc->ph_active = PH_INACTIVE;
205         return(0);
206 }
207
208
209 /*---------------------------------------------------------------------------*
210  *      i4b_l2_unit_init - place layer 2 unit into known state
211  *---------------------------------------------------------------------------*/
212 static void
213 i4b_l2_unit_init(int unit)
214 {
215         l2_softc_t *l2sc = &l2_softc[unit];
216         CRIT_VAR;
217
218         CRIT_BEG;
219         l2sc->Q921_state = ST_TEI_UNAS;
220         l2sc->tei_valid = TEI_INVALID;
221         l2sc->vr = 0;
222         l2sc->vs = 0;
223         l2sc->va = 0;
224         l2sc->ack_pend = 0;
225         l2sc->rej_excpt = 0;
226         l2sc->peer_busy = 0;
227         l2sc->own_busy = 0;
228         l2sc->l3initiated = 0;
229
230         l2sc->rxd_CR = 0;
231         l2sc->rxd_PF = 0;
232         l2sc->rxd_NR = 0;
233         l2sc->RC = 0;
234         l2sc->iframe_sent = 0;
235                 
236         l2sc->postfsmfunc = NULL;
237
238         if(l2sc->ua_num != UA_EMPTY)
239         {
240                 i4b_Dfreembuf(l2sc->ua_frame);
241                 l2sc->ua_num = UA_EMPTY;
242                 l2sc->ua_frame = NULL;
243         }
244
245         i4b_T200_stop(l2sc);
246         i4b_T202_stop(l2sc);
247         i4b_T203_stop(l2sc);
248
249         CRIT_END;       
250 }
251
252 /*---------------------------------------------------------------------------*
253  *      i4b_mph_status_ind - status indication upward
254  *---------------------------------------------------------------------------*/
255 int
256 i4b_mph_status_ind(int unit, int status, int parm)
257 {
258         l2_softc_t *l2sc = &l2_softc[unit];
259         int sendup = 1;
260         CRIT_VAR;
261         
262         CRIT_BEG;
263
264         NDBGL1(L1_PRIM, "unit %d, status=%d, parm=%d", unit, status, parm);
265
266         switch(status)
267         {
268                 case STI_ATTACH:
269                         l2sc->unit = unit;
270                         l2sc->i_queue.ifq_maxlen = IQUEUE_MAXLEN;
271
272                         l2sc->ua_frame = NULL;
273                         bzero(&l2sc->stat, sizeof(lapdstat_t));                 
274                         i4b_l2_unit_init(unit);
275                         
276                         /* initialize the callout handles for timeout routines */
277                         callout_init(&l2sc->T200_timeout);
278                         callout_init(&l2sc->T202_timeout);
279                         callout_init(&l2sc->T203_timeout);
280                         callout_init(&l2sc->IFQU_timeout);
281
282                         break;
283
284                 case STI_L1STAT:        /* state of layer 1 */
285                         break;
286                 
287                 case STI_PDEACT:        /* Timer 4 expired */
288 /*XXX*/                 if((l2sc->Q921_state >= ST_AW_EST) &&
289                            (l2sc->Q921_state <= ST_TIMREC))
290                         {
291                                 NDBGL2(L2_ERROR, "unit %d, persistent deactivation!", unit);
292                                 i4b_l2_unit_init(unit);
293                         }
294                         else
295                         {
296                                 sendup = 0;
297                         }
298                         break;
299
300                 case STI_NOL1ACC:
301                         i4b_l2_unit_init(unit);
302                         NDBGL2(L2_ERROR, "unit %d, cannot access S0 bus!", unit);
303                         break;
304                         
305                 default:
306                         NDBGL2(L2_ERROR, "ERROR, unit %d, unknown status message!", unit);
307                         break;
308         }
309         
310         if(sendup)
311                 MDL_Status_Ind(unit, status, parm);  /* send up to layer 3 */
312
313         CRIT_END;
314         
315         return(0);
316 }
317
318 /*---------------------------------------------------------------------------*
319  *      MDL_COMMAND_REQ from layer 3
320  *---------------------------------------------------------------------------*/
321 int
322 i4b_mdl_command_req(int unit, int command, void * parm)
323 {
324         NDBGL2(L2_PRIM, "unit %d, command=%d, parm=%d", unit, command, (unsigned int)parm);
325
326         switch(command)
327         {
328                 case CMR_DOPEN:
329                         i4b_l2_unit_init(unit);
330                         break;
331         }               
332
333         MPH_Command_Req(unit, command, parm);
334         
335         return(0);
336 }
337
338 /*---------------------------------------------------------------------------*
339  *      i4b_ph_data_ind - process a rx'd frame got from layer 1
340  *---------------------------------------------------------------------------*/
341 int
342 i4b_ph_data_ind(int unit, struct mbuf *m)
343 {
344         l2_softc_t *l2sc = &l2_softc[unit];
345 #ifdef NOTDEF
346         NDBGL1(L1_PRIM, "unit %d", unit);
347 #endif
348         u_char *ptr = m->m_data;
349
350         if ( (*(ptr + OFF_CNTL) & 0x01) == 0 )
351         {
352                 if(m->m_len < 4)        /* 6 oct - 2 chksum oct */
353                 {
354                         l2sc->stat.err_rx_len++;
355                         NDBGL2(L2_ERROR, "ERROR, I-frame < 6 octetts!");
356                         i4b_Dfreembuf(m);
357                         return(0);
358                 }
359                 i4b_rxd_i_frame(unit, m);
360         }
361         else if ( (*(ptr + OFF_CNTL) & 0x03) == 0x01 )
362         {
363                 if(m->m_len < 4)        /* 6 oct - 2 chksum oct */
364                 {
365                         l2sc->stat.err_rx_len++;
366                         NDBGL2(L2_ERROR, "ERROR, S-frame < 6 octetts!");
367                         i4b_Dfreembuf(m);
368                         return(0);
369                 }
370                 i4b_rxd_s_frame(unit, m);
371         }
372         else if ( (*(ptr + OFF_CNTL) & 0x03) == 0x03 )
373         {
374                 if(m->m_len < 3)        /* 5 oct - 2 chksum oct */
375                 {
376                         l2sc->stat.err_rx_len++;
377                         NDBGL2(L2_ERROR, "ERROR, U-frame < 5 octetts!");
378                         i4b_Dfreembuf(m);
379                         return(0);
380                 }
381                 i4b_rxd_u_frame(unit, m);
382         }
383         else
384         {
385                 l2sc->stat.err_rx_badf++;
386                 NDBGL2(L2_ERROR, "ERROR, bad frame rx'd - ");
387                 i4b_print_frame(m->m_len, m->m_data);
388                 i4b_Dfreembuf(m);
389         }
390         return(0);
391 }
392
393 #endif /* NI4BQ921 > 0 */