sys/netproto/atm/uni/sscop_sigaa.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/netatm/uni/sscop_sigaa.c,v 1.4 2000/01/17 20:49:52 mks Exp $
  27  *      @(#) $DragonFly: src/sys/netproto/atm/uni/sscop_sigaa.c,v 1.4 2003/08/07 21:54:34 dillon Exp $
  28  */
  29
  30 /*
  31  * ATM Forum UNI Support
  32  * ---------------------
  33  *
  34  * SSCOP Common - Process AA-signals (SAP_SSCOP)
  35  *
  36  */
  37
  38 #include <netproto/atm/kern_include.h>
  39
  40 #include "sscop.h"
  41 #include "sscop_misc.h"
  42 #include "sscop_var.h"
  43
  44 /*
  45  * SSCOP_ESTABLISH_REQ / SOS_IDLE Command Processor
  46  *
  47  * Arguments:
  48  *      sop     pointer to sscop connection block
  49  *      arg1    pointer to buffer containing SSCOP-UU data
  50  *      arg2    buffer release parameter
  51  *
  52  * Returns:
  53  *      none
  54  *
  55  */
  56 void
  57 sscop_estreq_idle(sop, arg1, arg2)
  58         struct sscop    *sop;
  59         int             arg1;
  60         int             arg2;
  61 {
  62
  63         /*
  64          * We don't support SSCOP-UU data
  65          */
  66         if (arg1 != SSCOP_UU_NULL)
  67                 KB_FREEALL((KBuffer *)arg1);
  68
  69         /*
  70          * We currently only support BR=YES
  71          */
  72         if (arg2 != SSCOP_BR_YES) {
  73                 sscop_abort(sop, "sscop: BR != YES\n");
  74                 return;
  75         }
  76
  77         /*
  78          * Initialize receiver window
  79          */
  80         SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin);
  81
  82         /*
  83          * Send first BGN PDU
  84          */
  85         sop->so_connctl = 1;
  86         SEQ_INCR(sop->so_sendconn, 1);
  87         (void) sscop_send_bgn(sop, SSCOP_SOURCE_USER);
  88
  89         /*
  90          * Reset transmitter state
  91          */
  92         if (sop->so_vers == SSCOP_VERS_Q2110)
  93                 q2110_clear_xmit(sop);
  94         else
  95                 qsaal1_reset_xmit(sop);
  96
  97         /*
  98          * Set retransmit timer
  99          */
 100         sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc;
 101
 102         /*
 103          * Wait for BGAK
 104          */
 105         sop->so_state = SOS_OUTCONN;
 106
 107         return;
 108 }
 109
 110
 111 /*
 112  * SSCOP_ESTABLISH_RSP / SOS_INCONN Command Processor
 113  *
 114  * Arguments:
 115  *      sop     pointer to sscop connection block
 116  *      arg1    pointer to buffer containing SSCOP-UU data
 117  *      arg2    buffer release parameter
 118  *
 119  * Returns:
 120  *      none
 121  *
 122  */
 123 void
 124 sscop_estrsp_inconn(sop, arg1, arg2)
 125         struct sscop    *sop;
 126         int             arg1;
 127         int             arg2;
 128 {
 129
 130         /*
 131          * We don't support SSCOP-UU data
 132          */
 133         if (arg1 != SSCOP_UU_NULL)
 134                 KB_FREEALL((KBuffer *)arg1);
 135
 136         /*
 137          * We currently only support BR=YES
 138          */
 139         if (arg2 != SSCOP_BR_YES) {
 140                 sscop_abort(sop, "sscop: BR != YES\n");
 141                 return;
 142         }
 143
 144         if (sop->so_vers == SSCOP_VERS_Q2110) {
 145                 /*
 146                  * Clear transmitter buffers
 147                  */
 148                 q2110_clear_xmit(sop);
 149
 150                 /*
 151                  * Initialize state variables
 152                  */
 153                 SEQ_SET(sop->so_rcvmax, sop->so_parm.sp_rcvwin);
 154                 q2110_init_state(sop);
 155         } else {
 156                 /*
 157                  * Reset transmitter state
 158                  */
 159                 qsaal1_reset_xmit(sop);
 160         }
 161
 162         /*
 163          * Send BGAK PDU
 164          */
 165         (void) sscop_send_bgak(sop);
 166
 167         /*
 168          * Start polling timer
 169          */
 170         sop->so_timer[SSCOP_T_POLL] = sop->so_parm.sp_timepoll;
 171
 172         /*
 173          * Start lost poll/stat timer
 174          */
 175         sop->so_timer[SSCOP_T_NORESP] = sop->so_parm.sp_timeresp;
 176
 177         /*
 178          * OK, we're ready for data
 179          */
 180         sop->so_state = SOS_READY;
 181
 182         /*
 183          * See if transmit queues need servicing
 184          */
 185         if (sop->so_flags & SOF_XMITSRVC)
 186                 sscop_service_xmit(sop);
 187
 188         return;
 189 }
 190
 191
 192 /*
 193  * SSCOP_RELEASE_REQ / SOS_OUTCONN Command Processor
 194  *
 195  * Arguments:
 196  *      sop     pointer to sscop connection block
 197  *      arg1    pointer to buffer containing SSCOP-UU data
 198  *      arg2    unused
 199  *
 200  * Returns:
 201  *      none
 202  *
 203  */
 204 void
 205 sscop_relreq_outconn(sop, arg1, arg2)
 206         struct sscop    *sop;
 207         int             arg1;
 208         int             arg2;
 209 {
 210
 211         /*
 212          * We don't support SSCOP-UU data
 213          */
 214         if (arg1 != SSCOP_UU_NULL)
 215                 KB_FREEALL((KBuffer *)arg1);
 216
 217         /*
 218          * Stop retransmit timer
 219          */
 220         sop->so_timer[SSCOP_T_CC] = 0;
 221
 222         /*
 223          * Clear reestablishment flag
 224          */
 225         sop->so_flags &= ~SOF_REESTAB;
 226
 227         /*
 228          * Send first END PDU
 229          */
 230         sop->so_connctl = 1;
 231         (void) sscop_send_end(sop, SSCOP_SOURCE_USER);
 232
 233         if (sop->so_vers == SSCOP_VERS_QSAAL)
 234                 /*
 235                  * Clear connection data
 236                  */
 237                 qsaal1_clear_connection(sop);
 238
 239         /*
 240          * Set retransmit timer
 241          */
 242         sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc;
 243
 244         /*
 245          * Wait for ENDAK
 246          */
 247         sop->so_state = SOS_OUTDISC;
 248
 249         return;
 250 }
 251
 252
 253 /*
 254  * SSCOP_RELEASE_REQ / SOS_INCONN Command Processor
 255  *
 256  * Arguments:
 257  *      sop     pointer to sscop connection block
 258  *      arg1    pointer to buffer containing SSCOP-UU data
 259  *      arg2    unused
 260  *
 261  * Returns:
 262  *      none
 263  *
 264  */
 265 void
 266 sscop_relreq_inconn(sop, arg1, arg2)
 267         struct sscop    *sop;
 268         int             arg1;
 269         int             arg2;
 270 {
 271
 272         /*
 273          * We don't support SSCOP-UU data
 274          */
 275         if (arg1 != SSCOP_UU_NULL)
 276                 KB_FREEALL((KBuffer *)arg1);
 277
 278         /*
 279          * Return a BGREJ PDU
 280          */
 281         (void) sscop_send_bgrej(sop);
 282
 283         /*
 284          * Back to IDLE state
 285          */
 286         sop->so_state = SOS_IDLE;
 287
 288         return;
 289 }
 290
 291
 292 /*
 293  * SSCOP_RELEASE_REQ / SOS_READY Command Processor
 294  *
 295  * Arguments:
 296  *      sop     pointer to sscop connection block
 297  *      arg1    pointer to buffer containing SSCOP-UU data
 298  *      arg2    unused
 299  *
 300  * Returns:
 301  *      none
 302  *
 303  */
 304 void
 305 sscop_relreq_ready(sop, arg1, arg2)
 306         struct sscop    *sop;
 307         int             arg1;
 308         int             arg2;
 309 {
 310
 311         /*
 312          * We don't support SSCOP-UU data
 313          */
 314         if (arg1 != SSCOP_UU_NULL)
 315                 KB_FREEALL((KBuffer *)arg1);
 316
 317         /*
 318          * Stop data transfer timers
 319          */
 320         sop->so_timer[SSCOP_T_POLL] = 0;
 321         sop->so_timer[SSCOP_T_NORESP] = 0;
 322         sop->so_timer[SSCOP_T_IDLE] = 0;
 323         sop->so_flags &= ~SOF_KEEPALIVE;
 324
 325         /*
 326          * Send first END PDU
 327          */
 328         sop->so_connctl = 1;
 329         (void) sscop_send_end(sop, SSCOP_SOURCE_USER);
 330
 331         if (sop->so_vers == SSCOP_VERS_Q2110) {
 332                 /*
 333                  * Clear out appropriate queues
 334                  */
 335                 if (sop->so_state == SOS_READY)
 336                         q2110_prep_retrieve(sop);
 337                 else
 338                         sscop_rcvr_drain(sop);
 339         } else {
 340                 /*
 341                  * Clear connection data
 342                  */
 343                 qsaal1_clear_connection(sop);
 344         }
 345
 346         /*
 347          * Set retransmit timer
 348          */
 349         sop->so_timer[SSCOP_T_CC] = sop->so_parm.sp_timecc;
 350
 351         /*
 352          * Wait for ENDAK
 353          */
 354         sop->so_state = SOS_OUTDISC;
 355
 356         return;
 357 }
 358
 359
 360 /*
 361  * SSCOP_DATA_REQ / SOS_READY Command Processor
 362  *
 363  * Arguments:
 364  *      sop     pointer to sscop connection block
 365  *      arg1    pointer to buffer containing assured user data
 366  *      arg2    unused
 367  *
 368  * Returns:
 369  *      none
 370  *
 371  */
 372 void
 373 sscop_datreq_ready(sop, arg1, arg2)
 374         struct sscop    *sop;
 375         int             arg1;
 376         int             arg2;
 377 {
 378         KBuffer         *m = (KBuffer *)arg1;
 379
 380         /*
 381          * We must have a buffer (even if it contains no data)
 382          */
 383         if (m == NULL) {
 384                 sscop_abort(sop, "sscop_datreq_ready: no buffer\n");
 385                 return;
 386         }
 387
 388         /*
 389          * Place data at end of transmission queue
 390          */
 391         KB_QNEXT(m) = NULL;
 392         if (sop->so_xmit_hd == NULL)
 393                 sop->so_xmit_hd = m;
 394         else
 395                 KB_QNEXT(sop->so_xmit_tl) = m;
 396         sop->so_xmit_tl = m;
 397
 398         /*
 399          * Service the transmit queues
 400          */
 401         sscop_service_xmit(sop);
 402
 403         return;
 404 }
 405
 406
 407 /*
 408  * SSCOP_UNITDATA_REQ / SOS_* Command Processor
 409  *
 410  * Arguments:
 411  *      sop     pointer to sscop connection block
 412  *      arg1    pointer to buffer containing unassured user data
 413  *      arg2    unused
 414  *
 415  * Returns:
 416  *      none
 417  *
 418  */
 419 void
 420 sscop_udtreq_all(sop, arg1, arg2)
 421         struct sscop    *sop;
 422         int             arg1;
 423         int             arg2;
 424 {
 425         KBuffer         *m = (KBuffer *)arg1;
 426
 427         /*
 428          * We must have a buffer (even if it contains no data)
 429          */
 430         if (m == NULL) {
 431                 sscop_abort(sop, "sscop_udtreq_all: no buffer\n");
 432                 return;
 433         }
 434
 435         /*
 436          * Send the data in a UD PDU
 437          */
 438         (void) sscop_send_ud(sop, m);
 439
 440         return;
 441 }
 442