![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp_Control.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat|
Return to adsp_Control.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* ! 26: * Copyright (c) 1990, 1995-1998 Apple Computer, Inc. ! 27: * All Rights Reserved. ! 28: * ! 29: * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF APPLE COMPUTER, INC. ! 30: * The copyright notice above does not evidence any actual or ! 31: * intended publication of such source code. ! 32: */ ! 33: ! 34: #include <adsp_local.h> ! 35: ! 36: /* # of additional ticks to add to any timer that we're queuing up. For ! 37: * very short delays (1 and 2), the timer fires before the transmit ! 38: * even takes place */ ! 39: #define TX_DLY 2 ! 40: ! 41: int adsp_window = 1; ! 42: ! 43: /* ! 44: * CalcRecvWdw ! 45: * ! 46: * INPUTS: ! 47: * sp ADSP Stream ! 48: * OUTPUTS: ! 49: * # of bytes in avail in local receive queue ! 50: */ ! 51: int CalcRecvWdw(sp) /* (CCBPtr sp) */ ! 52: CCBPtr sp; ! 53: { ! 54: int bytes; ! 55: ! 56: bytes = calcRecvQ(sp); ! 57: bytes = sp->rbuflen - bytes; /* get what is left */ ! 58: ! 59: if (bytes <= 16) { /* %%% this should be zero */ ! 60: sp->rbufFull = 1; /* Save flag that our recv buf is full */ ! 61: return 0; ! 62: } ! 63: else ! 64: return ((bytes+bytes+bytes) >> 2) + 1; /* %%% */ ! 65: } ! 66: ! 67: calcRecvQ(sp) ! 68: CCBPtr sp; ! 69: { ! 70: int bytes = 0; ! 71: register gbuf_t *mb; ! 72: ! 73: if (sp->rData) { /* There is data in buffer */ ! 74: if (mb = sp->rbuf_mb) { ! 75: do { ! 76: bytes += gbuf_msgsize(mb); ! 77: mb = gbuf_next(mb); ! 78: } while (mb); ! 79: } ! 80: if (mb = sp->crbuf_mb) ! 81: bytes += gbuf_msgsize(mb); ! 82: } ! 83: ! 84: return bytes; ! 85: } ! 86: ! 87: /* ! 88: * CheckSend ! 89: * ! 90: * Check to see if the transmit PB is available and if there is anything ! 91: * to transmit. Start off any pending transmit. ! 92: * ! 93: * Normally called from the write completion routine ! 94: * ! 95: * INPUTS: ! 96: * sp Connection control block ! 97: * OUTPUTS: ! 98: * true if sent a packet ! 99: */ ! 100: void CheckSend(sp) /* (CCBPtr sp) */ ! 101: register CCBPtr sp; ! 102: { ! 103: int i; ! 104: int attnMsg; /* True if attention message */ ! 105: int s; ! 106: register gbuf_t *mp; /* send message block */ ! 107: #ifdef notdef ! 108: register gbuf_t *tmp; ! 109: u_char current; ! 110: #endif ! 111: char *dp; /* a data pointer */ ! 112: int use_attention_code; ! 113: int len; /* length used in allocd mblk */ ! 114: int datalen; /* amount of data attached to mblk */ ! 115: gbuf_t *mprev, *mlist = 0; ! 116: ! 117: top: ! 118: ! 119: if (sp->state == sClosed) ! 120: return; ! 121: ! 122: /* get a message block to hold DDP and ! 123: * ADSP headers + 2 bytes of attention ! 124: * code if necessary */ ! 125: if ((mp = gbuf_alloc(AT_WR_OFFSET + DDPL_FRAME_LEN + ADSP_FRAME_LEN + ADSP_OPEN_FRAME_LEN + 2, ! 126: PRI_LO)) == 0) { ! 127: if (mlist) ! 128: gbuf_freel(mlist); ! 129: return; /* can't get buffers... do nothing! */ ! 130: } ! 131: ATDISABLE(s, sp->lock); ! 132: sp->callSend = 0; /* Clear flag */ ! 133: use_attention_code = 0; ! 134: len = 0; ! 135: datalen = 0; ! 136: ! 137: gbuf_rinc(mp,AT_WR_OFFSET); ! 138: gbuf_wset(mp,DDPL_FRAME_LEN); /* leave room for DDP header */ ! 139: ! 140: if (sp->sendCtl) { ! 141: short mask; ! 142: ! 143: i = sp->sendCtl; /* get local copy bitmap of */ ! 144: /* which ctl packets to send. */ ! 145: attnMsg = 0; ! 146: ! 147: if (i & 0x1E) /* One of the open ctrl packets */ ! 148: { ! 149: ! 150: /* point past ADSP header (no attention) */ ! 151: dp = ((char *) gbuf_wptr(mp)) + ADSP_FRAME_LEN; ! 152: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->firstRtmtSeq)); ! 153: ! 154: UAS_ASSIGN(sp->of.version, netw(0x0100)); /* Fill in open connection parms */ ! 155: UAS_ASSIGN(sp->of.dstCID, sp->remCID); /* Destination CID */ ! 156: UAL_ASSIGN(sp->of.pktAttnRecvSeq, netdw(sp->attnRecvSeq)); ! 157: bcopy((caddr_t) &sp->of, (caddr_t) dp, ADSP_OPEN_FRAME_LEN); ! 158: len += ADSP_OPEN_FRAME_LEN; ! 159: ! 160: if (i & B_CTL_OREQ) { ! 161: UAS_ASSIGN(sp->f.CID, sp->locCID); ! 162: mask = B_CTL_OREQ; ! 163: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQ; ! 164: } else if (i & B_CTL_OACK) { ! 165: UAS_ASSIGN(sp->f.CID, sp->locCID); ! 166: mask = B_CTL_OACK; ! 167: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OACK; ! 168: } else if (i & B_CTL_OREQACK) { ! 169: UAS_ASSIGN(sp->f.CID, sp->locCID); ! 170: mask = B_CTL_OREQACK; ! 171: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_OREQACK; ! 172: } else /* Deny */ ! 173: { ! 174: UAS_ASSIGN(sp->f.CID, 0); ! 175: mask = B_CTL_ODENY; ! 176: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_ODENY; ! 177: UAL_ASSIGN(sp->f.pktFirstByteSeq, 0); ! 178: } ! 179: ! 180: if (i & (B_CTL_OREQ | B_CTL_OREQACK)) ! 181: /* Need to start up a timer for it */ ! 182: { ! 183: /* It's possible that we've received a duplicate ! 184: * open request. In this case, there will already be ! 185: * a timer queued up for the request+ack ! 186: * packet we sent the first time. So remove the timer ! 187: * and start another. ! 188: */ ! 189: RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer); ! 190: InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer, ! 191: sp->openInterval+1); ! 192: } ! 193: } else { ! 194: /* seq # of next byte to send */ ! 195: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq)); ! 196: ! 197: if (i & B_CTL_CLOSE) { ! 198: sp->state = sClosed; /* Now we're closed */ ! 199: mask = B_CTL_CLOSE; ! 200: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_CLOSE; ! 201: } else if (i & B_CTL_PROBE) { ! 202: mask = B_CTL_PROBE; ! 203: sp->f.descriptor = ! 204: ADSP_CONTROL_BIT | ADSP_CTL_PROBE | ADSP_ACK_REQ_BIT; ! 205: } else if (i & B_CTL_FRESET) { ! 206: mask = B_CTL_FRESET; ! 207: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET; ! 208: InsertTimerElem(&adspGlobal.fastTimers, ! 209: &sp->ResetTimer, sp->rtmtInterval+TX_DLY); ! 210: } else if (i & B_CTL_FRESETACK) { ! 211: mask = B_CTL_FRESETACK; ! 212: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_FRESET_ACK; ! 213: } ! 214: else if (i & B_CTL_RETRANSMIT) { ! 215: mask = B_CTL_RETRANSMIT; ! 216: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_CTL_RETRANSMIT; ! 217: } ! 218: else { ! 219: dPrintf(D_M_ADSP, D_L_ERROR, ("CheckSend: Control bit error\n")); ! 220: } ! 221: } /* non open control packet */ ! 222: ! 223: sp->sendCtl &= ~mask; ! 224: goto sendit; ! 225: } /* send control packet */ ! 226: ! 227: if (sp->sendAttnData) /* Send attn ready to go? */ ! 228: { ! 229: sp->sendAttnData = 0; /* Clear Flags */ ! 230: if (sp->sapb) { ! 231: sp->sendAttnAck = 0; /* This will also do an Attn Ack */ ! 232: ! 233: attnMsg = 1; ! 234: sp->f.descriptor = ADSP_ATTENTION_BIT | ADSP_ACK_REQ_BIT; ! 235: if (gbuf_cont(sp->sapb->mp)) { ! 236: gbuf_cont(mp) = gbuf_dupm(gbuf_cont(sp->sapb->mp)); ! 237: /* Major hack here. The ADSP Attn code is butted up against ! 238: * the end of the adsp packet header, and the length is ! 239: * increased by 2. (There is a pad field behind the adsp ! 240: * header in the CCB just for this purpose.) ! 241: */ ! 242: } ! 243: use_attention_code++; ! 244: ! 245: sp->f.data[0] = high(sp->sapb->u.attnParams.attnCode); ! 246: sp->f.data[1] = low(sp->sapb->u.attnParams.attnCode); ! 247: InsertTimerElem(&adspGlobal.fastTimers, &sp->AttnTimer, ! 248: sp->rtmtInterval+TX_DLY); ! 249: goto sendit; ! 250: } ! 251: } /* attn data */ ! 252: ! 253: if (sp->sendAttnAck) /* Send attn ack ready to go? */ ! 254: { ! 255: attnMsg = 1; ! 256: sp->f.descriptor = ADSP_CONTROL_BIT | ADSP_ATTENTION_BIT; ! 257: sp->sendAttnAck = 0; ! 258: goto sendit; ! 259: } /* attn ack */ ! 260: ! 261: if ((sp->state == sOpen || sp->state == sClosing) && /* Correct state */ ! 262: (!sp->waitingAck) && /* not waiting for an ACK */ ! 263: (sp->sData) && /* have data to send */ ! 264: (GTE(sp->sendWdwSeq,sp->sendSeq)) && /* he has room to accept it */ ! 265: (sp->pktSendCnt < sp->pktSendMax)) /* haven't sent too many pkts ! 266: * in a row. */ ! 267: { ! 268: attnMsg = 0; ! 269: if (datalen = attachData(sp, mp)) /* attach data to mp */ ! 270: goto sendit; /* if successful, sendit */ ! 271: } ! 272: ! 273: if (sp->sendDataAck) { ! 274: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq)); /* seq # of next byte */ ! 275: attnMsg = 0; ! 276: sp->f.descriptor = ADSP_CONTROL_BIT; ! 277: goto sendit; ! 278: } ! 279: ! 280: /* ! 281: * Nothing left to do... ! 282: */ ! 283: if (mp) ! 284: gbuf_freem(mp); ! 285: ATENABLE(s, sp->lock); ! 286: if (mlist) ! 287: adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP); ! 288: return; ! 289: ! 290: sendit: ! 291: ! 292: if (attnMsg) { ! 293: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->attnSendSeq)); ! 294: UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->attnRecvSeq)); ! 295: UAS_ASSIGN(sp->f.pktRecvWdw, 0); /* Always zero in attn pkt */ ! 296: } else { ! 297: sp->sendDataAck = 0; ! 298: UAL_ASSIGN(sp->f.pktNextRecvSeq, netdw(sp->recvSeq)); ! 299: UAS_ASSIGN(sp->f.pktRecvWdw, netw(CalcRecvWdw(sp))); ! 300: } ! 301: if (use_attention_code) { ! 302: bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN + 2); ! 303: len += ADSP_FRAME_LEN + 2; ! 304: } else { ! 305: bcopy((caddr_t) &sp->f, (caddr_t) gbuf_wptr(mp), ADSP_FRAME_LEN); ! 306: len += ADSP_FRAME_LEN; ! 307: } ! 308: gbuf_winc(mp,len); /* update mblk length */ ! 309: if (mlist) ! 310: gbuf_next(mprev) = mp; ! 311: else ! 312: mlist = mp; ! 313: mprev = mp; ! 314: ! 315: if (sp->state == sClosed) { /* must have sent a close advice */ ! 316: /* send header + data */ ! 317: ATENABLE(s, sp->lock); ! 318: adsp_sendddp(sp, mlist, 0, &sp->remoteAddress, DDP_ADSP); ! 319: DoClose(sp, 0, -1); /* complete close! */ ! 320: return; ! 321: } ! 322: ATENABLE(s, sp->lock); ! 323: if (sp->state == sClosing) /* See if we were waiting on this write */ ! 324: CheckOkToClose(sp); ! 325: goto top; ! 326: } ! 327: ! 328: /* ! 329: * completepb delivers a paramater block with all its appropriate fields ! 330: * set back to the user. ! 331: * ! 332: * The assumptions here are that the PB is not linked to any queue, ! 333: * that the fields including ioResult are set, and that the ! 334: * kernel is no longer interested in the mblks that may or ! 335: * maynot be linked to this pb. ! 336: */ ! 337: completepb(sp, pb) ! 338: register CCBPtr sp; ! 339: register struct adspcmd *pb; ! 340: { ! 341: if (sp->gref && (sp->gref->info == (caddr_t)sp->sp_mp)) { ! 342: if (gbuf_len(pb->mp) > sizeof(struct adspcmd)) ! 343: gbuf_wset(pb->mp,sizeof(struct adspcmd)); ! 344: SndMsgUp(sp->gref, pb->mp); ! 345: NotifyUser(sp); ! 346: } else ! 347: gbuf_freem(pb->mp); ! 348: } ! 349: ! 350: attachData(sp, mp) ! 351: register CCBPtr sp; ! 352: register gbuf_t *mp; ! 353: { ! 354: int seq; ! 355: int cnt; ! 356: char eom = 0; ! 357: int bsize; ! 358: int diff; ! 359: char sendAckReq; ! 360: int partial = 0; /* flag for a partial send */ ! 361: int tcnt = 0; ! 362: register gbuf_t *smp; /* send data message block */ ! 363: register gbuf_t *psmp; /* previous message block */ ! 364: ! 365: sendAckReq = 0; ! 366: ! 367: if (LT(sp->sendSeq, sp->firstRtmtSeq)) /* Sanity check on send seq */ ! 368: sp->sendSeq = sp->firstRtmtSeq; /* seq must be oldest in buffer. */ ! 369: ! 370: /* This test and assignment was necessary because the retry VBL could ! 371: * have fired and reset send Seq to first Rtmt Seq, and then an ! 372: * expected ACK comes in that bumps first Rtmt Seq up. Then we ! 373: * have the problem that send Seq is less than first Rtmt Seq. ! 374: * The easiest fix to this timing dilemma seems to be to reset ! 375: * sendSeq to first Rtmt Seq if we're sending the first packet. ! 376: */ ! 377: UAL_ASSIGN(sp->f.pktFirstByteSeq, netdw(sp->sendSeq)); ! 378: ! 379: if (smp = sp->sbuf_mb) /* Get oldest header */ ! 380: eom = 1; ! 381: else if (smp = sp->csbuf_mb) ! 382: eom = 0; ! 383: ! 384: if (smp == 0) { /* this shouldn't happen... */ ! 385: sp->sData = 0; ! 386: return 0; ! 387: } ! 388: /* ! 389: * Must find next byte to transmit ! 390: */ ! 391: seq = sp->firstRtmtSeq; /* Seq # of oldest in buffer */ ! 392: while ((diff = (sp->sendSeq - seq)) >= ((bsize = gbuf_msgsize(smp)) + eom)) { ! 393: seq += bsize + eom; /* update sequence # */ ! 394: if (gbuf_next(smp)) { /* if another send buffer */ ! 395: smp = gbuf_next(smp); ! 396: eom = 1; ! 397: } else if (smp == sp->csbuf_mb) { /* seen the current one? */ ! 398: smp = 0; ! 399: break; ! 400: } else if (sp->csbuf_mb) { /* look at it */ ! 401: smp = sp->csbuf_mb; ! 402: eom = 0; ! 403: } else { /* no more buffers */ ! 404: smp = 0; ! 405: break; ! 406: } ! 407: } /* while */ ! 408: ! 409: if (smp) { ! 410: if (gbuf_next(smp) == 0) /* last block */ ! 411: sendAckReq = 1; ! 412: cnt = bsize - diff; /* # of bytes in this block */ ! 413: } else ! 414: cnt = 0; ! 415: ! 416: /* ! 417: * Check to see if the number of bytes is less than the 'send ! 418: * Blocking' setting. If so, then we won't send this data unless ! 419: * we're flushing. So we set up a timer to force a flush later. ! 420: */ ! 421: if ((cnt < sp->sendBlocking) && !sp->writeFlush) { ! 422: InsertTimerElem(&adspGlobal.fastTimers, &sp->FlushTimer, ! 423: sp->sendInterval); ! 424: return 0; /* no data to send */ ! 425: } ! 426: ! 427: if (cnt > ADSP_MAX_DATA_LEN) { /* truncate to one packet */ ! 428: cnt = ADSP_MAX_DATA_LEN; ! 429: eom = 0; ! 430: sendAckReq = 0; /* Won't send ack because end of data */ ! 431: partial++; ! 432: } ! 433: ! 434: if (smp) { ! 435: /* trim extra bytes off the beginning of the "block" before the copy */ ! 436: while (diff) { ! 437: if (gbuf_len(smp) > diff) ! 438: break; ! 439: else ! 440: diff -= gbuf_len(smp); ! 441: smp = gbuf_cont(smp); ! 442: } ! 443: if((gbuf_cont(mp) = gbuf_dupm(smp)) == 0) /* copy the data */ ! 444: return 0; ! 445: smp = gbuf_cont(mp); /* use the new message blocks */ ! 446: gbuf_rinc(smp,diff); /* and get to the first byte of data to send */ ! 447: } ! 448: /* ! 449: * Check to see if this many bytes will close the other end's ! 450: * receive window. If so, we need to send an ack request along ! 451: * with this. sendWdwSeq is the seq # of the last byte that ! 452: * the remote has room for ! 453: */ ! 454: if ((diff = sp->sendWdwSeq + 1 - sp->sendSeq) <= cnt) { ! 455: if (diff < cnt) { /* Won't fit exactly */ ! 456: eom = 0; /* so can't send EOM */ ! 457: cnt = diff; ! 458: partial++; ! 459: } ! 460: sendAckReq = 1; /* Make him tell us new recv. window */ ! 461: sp->noXmitFlow = 1; /* Don't do flow control calc. */ ! 462: } ! 463: ! 464: /* trim extra bytes off the tail of the "block" after the copy */ ! 465: if (partial && smp) { ! 466: psmp = smp; ! 467: tcnt = cnt; ! 468: while (tcnt && smp) { /* while there are message blocks and data */ ! 469: if (tcnt >= gbuf_len(smp)) { ! 470: tcnt -= gbuf_len(smp); ! 471: if (tcnt) { ! 472: psmp = smp; ! 473: smp = gbuf_cont(smp); ! 474: } else { ! 475: if (psmp != smp) { /* not the first item on the list */ ! 476: gbuf_cont(psmp) = 0; ! 477: gbuf_freem(smp); ! 478: smp = psmp; ! 479: } else { ! 480: gbuf_freem(gbuf_cont(smp)); ! 481: gbuf_cont(smp) = 0; ! 482: } ! 483: break; ! 484: } ! 485: } else { ! 486: gbuf_wset(smp,tcnt); ! 487: if (gbuf_cont(smp)) { ! 488: gbuf_freem(gbuf_cont(smp)); ! 489: gbuf_cont(smp) = 0; ! 490: } ! 491: break; ! 492: } ! 493: } ! 494: } ! 495: ! 496: sp->sendSeq += cnt + eom; /* Update sendSeq field */ ! 497: ! 498: if (GT(sp->sendSeq, sp->maxSendSeq)) /* Keep track of >st ever sent */ ! 499: sp->maxSendSeq = sp->sendSeq; ! 500: ! 501: if (eom) ! 502: sp->f.descriptor = ADSP_EOM_BIT; ! 503: else ! 504: sp->f.descriptor = 0; ! 505: ! 506: if (sendAckReq || (++sp->pktSendCnt >= sp->pktSendMax)) { ! 507: /* Last packet in a series */ ! 508: sp->f.descriptor |= ADSP_ACK_REQ_BIT; /* We want an ack to this */ ! 509: sp->waitingAck = 1; /* Flag that we're waiting */ ! 510: sp->sendStamp = SysTicks(); /* Save time we sent request */ ! 511: sp->timerSeq = sp->sendSeq; /* Save seq # we want acked */ ! 512: InsertTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer, ! 513: sp->rtmtInterval+TX_DLY); ! 514: } ! 515: return cnt + eom; ! 516: } ! 517: ! 518: ! 519:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.