Ansify some remaining function definitions in the kernel.
[dragonfly.git] / sys / dev / atm / hfa / fore_vcm.c
1 /*
2  *
3  * ===================================
4  * HARP  |  Host ATM Research Platform
5  * ===================================
6  *
7  *
8  * This Host ATM Research Platform ("HARP") file (the "Software") is
9  * made available by Network Computing Services, Inc. ("NetworkCS")
10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
11  * support of any kind.
12  *
13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
17  * In no event shall NetworkCS be responsible for any damages, including
18  * but not limited to consequential damages, arising from or relating to
19  * any use of the Software or related support.
20  *
21  * Copyright 1994-1998 Network Computing Services, Inc.
22  *
23  * Copies of this Software may be made, however, the above copyright
24  * notice must be reproduced on all copies.
25  *
26  *      @(#) $FreeBSD: src/sys/dev/hfa/fore_vcm.c,v 1.4 1999/08/28 00:41:53 peter Exp $
27  *      @(#) $DragonFly: src/sys/dev/atm/hfa/fore_vcm.c,v 1.4 2008/03/01 22:03:13 swildner Exp $
28  */
29
30 /*
31  * FORE Systems 200-Series Adapter Support
32  * ---------------------------------------
33  *
34  * Virtual Channel Management
35  *
36  */
37
38 #include "fore_include.h"
39
40 /*
41  * VCC Stack Instantiation
42  * 
43  * This function is called via the common driver code during a device VCC
44  * stack instantiation.  The common code has already validated some of
45  * the request so we just need to check a few more Fore-specific details.
46  *
47  * Called at splnet.
48  *
49  * Arguments:
50  *      cup     pointer to device common unit
51  *      cvp     pointer to common VCC entry
52  *
53  * Returns:
54  *      0       instantiation successful
55  *      err     instantiation failed - reason indicated
56  *
57  */
58 int
59 fore_instvcc(Cmn_unit *cup, Cmn_vcc *cvp)
60 {
61         Fore_vcc        *fvp = (Fore_vcc *)cvp;
62         Atm_attributes  *ap = &fvp->fv_connvc->cvc_attr;
63
64         /*
65          * Validate requested AAL
66          */
67         switch (ap->aal.type) {
68
69         case ATM_AAL0:
70                 fvp->fv_aal = FORE_AAL_0;
71                 break;
72
73         case ATM_AAL3_4:
74                 fvp->fv_aal = FORE_AAL_4;
75                 if ((ap->aal.v.aal4.forward_max_SDU_size > FORE_IFF_MTU) ||
76                     (ap->aal.v.aal4.backward_max_SDU_size > FORE_IFF_MTU))
77                         return (EINVAL);
78                 break;
79
80         case ATM_AAL5:
81                 fvp->fv_aal = FORE_AAL_5;
82                 if ((ap->aal.v.aal5.forward_max_SDU_size > FORE_IFF_MTU) ||
83                     (ap->aal.v.aal5.backward_max_SDU_size > FORE_IFF_MTU))
84                         return (EINVAL);
85                 break;
86
87         default:
88                 return (EINVAL);
89         }
90
91         return (0);
92 }
93
94
95 /*
96  * Open a VCC
97  * 
98  * This function is called via the common driver code after receiving a
99  * stack *_INIT command.  The common code has already validated most of
100  * the request so we just need to check a few more Fore-specific details.
101  * Then we just issue the command to the CP.  Note that we can't wait around
102  * for the CP to process the command, so we return success for now and abort
103  * the connection if the command later fails.
104  *
105  * Called at splimp.
106  *
107  * Arguments:
108  *      cup     pointer to device common unit
109  *      cvp     pointer to common VCC entry
110  *
111  * Returns:
112  *      0       open successful
113  *      else    open failed
114  *
115  */
116 int
117 fore_openvcc(Cmn_unit *cup, Cmn_vcc *cvp)
118 {
119         Fore_unit       *fup = (Fore_unit *)cup;
120         Fore_vcc        *fvp = (Fore_vcc *)cvp;
121         H_cmd_queue     *hcp;
122         Cmd_queue       *cqp;
123         struct vccb     *vcp;
124
125         vcp = fvp->fv_connvc->cvc_vcc;
126
127         ATM_DEBUG4("fore_openvcc: fup=%p, fvp=%p, vcc=(%d,%d)\n", 
128                 fup, fvp, vcp->vc_vpi, vcp->vc_vci);
129
130         /*
131          * Validate the VPI and VCI values
132          */
133         if ((vcp->vc_vpi > fup->fu_pif.pif_maxvpi) ||
134             (vcp->vc_vci > fup->fu_pif.pif_maxvci)) {
135                 return (1);
136         }
137
138         /*
139          * Only need to tell the CP about incoming VCCs
140          */
141         if ((vcp->vc_type & VCC_IN) == 0) {
142                 DEVICE_LOCK((Cmn_unit *)fup);
143                 fup->fu_open_vcc++;
144                 fvp->fv_state = CVS_ACTIVE;
145                 DEVICE_UNLOCK((Cmn_unit *)fup);
146                 return (0);
147         }
148
149         /*
150          * Queue command at end of command queue
151          */
152         hcp = fup->fu_cmd_tail;
153         if ((*hcp->hcq_status) & QSTAT_FREE) {
154
155                 /*
156                  * Queue entry available, so set our view of things up
157                  */
158                 hcp->hcq_code = CMD_ACT_VCCIN;
159                 hcp->hcq_arg = fvp;
160                 fup->fu_cmd_tail = hcp->hcq_next;
161                 fvp->fv_flags |= FVF_ACTCMD;
162
163                 /*
164                  * Now set the CP-resident queue entry - the CP will grab
165                  * the command when the op-code is set.
166                  */
167                 cqp = hcp->hcq_cpelem;
168                 (*hcp->hcq_status) = QSTAT_PENDING;
169                 cqp->cmdq_act.act_vccid = CP_WRITE(vcp->vc_vci);
170                 if (fvp->fv_aal == FORE_AAL_0)
171                         cqp->cmdq_act.act_batch = CP_WRITE(1);
172                 cqp->cmdq_act.act_spec = CP_WRITE(
173                         ACT_SET_SPEC(BUF_STRAT_1, fvp->fv_aal,
174                                 CMD_ACT_VCCIN | CMD_INTR_REQ));
175         } else {
176                 /*
177                  * Command queue full
178                  */
179                 fup->fu_stats->st_drv.drv_cm_full++;
180                 return (1);
181         }
182
183         return (0);
184 }
185
186
187 /*
188  * Close a VCC
189  * 
190  * This function is called via the common driver code after receiving a
191  * stack *_TERM command.  The common code has already validated most of
192  * the request so we just need to check a few more Fore-specific details.
193  * Then we just issue the command to the CP.  Note that we can't wait around
194  * for the CP to process the command, so we return success for now and whine
195  * if the command later fails.
196  *
197  * Called at splimp.
198  *
199  * Arguments:
200  *      cup     pointer to device common unit
201  *      cvp     pointer to common VCC entry
202  *
203  * Returns:
204  *      0       close successful
205  *      else    close failed
206  *
207  */
208 int
209 fore_closevcc(Cmn_unit *cup, Cmn_vcc *cvp)
210 {
211         Fore_unit       *fup = (Fore_unit *)cup;
212         Fore_vcc        *fvp = (Fore_vcc *)cvp;
213         H_xmit_queue    *hxp;
214         H_cmd_queue     *hcp;
215         Cmd_queue       *cqp;
216         struct vccb     *vcp;
217         int             i, err = 0;
218
219         vcp = fvp->fv_connvc->cvc_vcc;
220
221         ATM_DEBUG4("fore_closevcc: fup=%p, fvp=%p, vcc=(%d,%d)\n", 
222                 fup, fvp, vcp->vc_vpi, vcp->vc_vci);
223
224         DEVICE_LOCK((Cmn_unit *)fup);
225
226         /*
227          * Clear any references to this VCC in our transmit queue
228          */
229         for (hxp = fup->fu_xmit_head, i = 0;
230              (*hxp->hxq_status != QSTAT_FREE) && (i < XMIT_QUELEN);
231              hxp = hxp->hxq_next, i++) {
232                 if (hxp->hxq_vcc == fvp) {
233                         hxp->hxq_vcc = NULL;
234                 }
235         }
236
237         /*
238          * Clear any references to this VCC in our command queue
239          */
240         for (hcp = fup->fu_cmd_head, i = 0;
241              (*hcp->hcq_status != QSTAT_FREE) && (i < CMD_QUELEN);
242              hcp = hcp->hcq_next, i++) {
243                 switch (hcp->hcq_code) {
244
245                 case CMD_ACT_VCCIN:
246                 case CMD_ACT_VCCOUT:
247                         if (hcp->hcq_arg == fvp) {
248                                 hcp->hcq_arg = NULL;
249                         }
250                         break;
251                 }
252         }
253
254         /*
255          * If this VCC has been previously activated, then we need to tell
256          * the CP to deactivate it.
257          */
258         if (fvp->fv_flags & FVF_ACTCMD) {
259
260                 /*
261                  * Queue command at end of command queue
262                  */
263                 hcp = fup->fu_cmd_tail;
264                 if ((*hcp->hcq_status) & QSTAT_FREE) {
265
266                         /*
267                          * Queue entry available, so set our view of things up
268                          */
269                         hcp->hcq_code = CMD_DACT_VCCIN;
270                         hcp->hcq_arg = fvp;
271                         fup->fu_cmd_tail = hcp->hcq_next;
272
273                         /*
274                          * Now set the CP-resident queue entry - the CP will 
275                          * grab the command when the op-code is set.
276                          */
277                         cqp = hcp->hcq_cpelem;
278                         (*hcp->hcq_status) = QSTAT_PENDING;
279                         cqp->cmdq_dact.dact_vccid = CP_WRITE(vcp->vc_vci);
280                         cqp->cmdq_dact.dact_cmd =
281                                 CP_WRITE(CMD_DACT_VCCIN|CMD_INTR_REQ);
282                 } else {
283                         /*
284                          * Command queue full
285                          *
286                          * If we get here, we'll be getting out-of-sync with
287                          * the CP because we can't (for now at least) do
288                          * anything about close errors in the common code.
289                          * This won't be too bad, since we'll just toss any
290                          * PDUs received from the VCC and the sigmgr's will
291                          * always get open failures when trying to use this
292                          * (vpi,vci)...oh, well...always gotta have that one
293                          * last bug to fix! XXX
294                          */
295                         fup->fu_stats->st_drv.drv_cm_full++;
296                         err = 1;
297                 }
298         }
299
300         /*
301          * Finish up...
302          */
303         if (fvp->fv_state == CVS_ACTIVE)
304                 fup->fu_open_vcc--;
305
306         DEVICE_UNLOCK((Cmn_unit *)fup);
307
308         return (err);
309 }
310