Lines Matching defs:pCh
68 i2Validate ( i2ChanStrPtr pCh )
70 //ip2trace(pCh->port_index, ITRC_VERIFY,ITRC_ENTER,2,pCh->validity,
72 return ((pCh->validity & (CHANNEL_MAGIC_BITS | CHANNEL_SUPPORT))
128 // Function: i2InitChannels(pB, nChannels, pCh)
147 i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh)
167 pB->i2eChannelPtr = pCh;
176 memset ( pCh, 0, sizeof (i2ChanStr) * nChannels );
185 rwlock_init(&pCh->Ibuf_spinlock);
186 rwlock_init(&pCh->Obuf_spinlock);
187 rwlock_init(&pCh->Cbuf_spinlock);
188 rwlock_init(&pCh->Pbuf_spinlock);
192 pCh->validity = CHANNEL_MAGIC | CHANNEL_SUPPORT;
194 pCh->validity = CHANNEL_MAGIC;
196 pCh->pMyBord = pB; /* Back-pointer */
200 if ( pCh->validity & CHANNEL_SUPPORT ) {
201 pCh->infl.hd.i2sChannel = index;
202 pCh->infl.hd.i2sCount = 5;
203 pCh->infl.hd.i2sType = PTYPE_BYPASS;
204 pCh->infl.fcmd = 37;
205 pCh->infl.asof = 0;
206 pCh->infl.room = IBUF_SIZE - 1;
208 pCh->whenSendFlow = (IBUF_SIZE/5)*4; // when 80% full
213 pCh->channelNeeds = NEED_FLOW; // Since starting from scratch
214 pCh->sinceLastFlow = 0; // No bytes received since last flow
217 *ppCh++ = pCh; // List this channel as needing
224 pCh->outfl.asof = 0;
225 pCh->outfl.room = 0;
229 pCh->Ibuf_stuff = pCh->Ibuf_strip = 0;
230 pCh->Obuf_stuff = pCh->Obuf_strip = 0;
231 pCh->Cbuf_stuff = pCh->Cbuf_strip = 0;
233 memset( &pCh->icount, 0, sizeof (struct async_icount) );
234 pCh->hotKeyIn = HOT_CLEAR;
235 pCh->channelOptions = 0;
236 pCh->bookMarks = 0;
237 init_waitqueue_head(&pCh->pBookmarkWait);
239 init_waitqueue_head(&pCh->open_wait);
240 init_waitqueue_head(&pCh->close_wait);
241 init_waitqueue_head(&pCh->delta_msr_wait);
244 pCh->BaudBase = 921600; // MAX for ST654, changed after we get
245 pCh->BaudDivisor = 96; // the boxids (UART types) later
247 pCh->dataSetIn = 0;
248 pCh->dataSetOut = 0;
250 pCh->wopen = 0;
251 pCh->throttled = 0;
253 pCh->speed = CBR_9600;
255 pCh->flags = 0;
257 pCh->ClosingDelay = 5*HZ/10;
258 pCh->ClosingWaitTime = 30*HZ;
261 INIT_WORK(&pCh->tqueue_input, do_input);
262 INIT_WORK(&pCh->tqueue_status, do_status);
265 pCh->trace = ip2trace;
268 ++pCh;
294 i2ChanStrPtr pCh = NULL;
304 pCh = pB->i2Dbuf[queueIndex];
310 pCh->channelNeeds &= ~NEED_INLINE;
321 pCh = pB->i2Bbuf[queueIndex];
327 pCh->channelNeeds &= ~NEED_BYPASS;
338 pCh = pB->i2Fbuf[queueIndex];
344 pCh->channelNeeds &= ~NEED_FLOW;
352 return pCh;
356 // Function: i2QueueNeeds(pB, pCh, type)
367 i2QueueNeeds(i2eBordStrPtr pB, i2ChanStrPtr pCh, int type)
380 if ( !(pCh->channelNeeds & NEED_INLINE) )
382 pCh->channelNeeds |= NEED_INLINE;
384 pB->i2Dbuf[queueIndex++] = pCh;
395 if ((type & NEED_BYPASS) && !(pCh->channelNeeds & NEED_BYPASS))
397 pCh->channelNeeds |= NEED_BYPASS;
399 pB->i2Bbuf[queueIndex++] = pCh;
410 if ((type & NEED_FLOW) && !(pCh->channelNeeds & NEED_FLOW))
412 pCh->channelNeeds |= NEED_FLOW;
414 pB->i2Fbuf[queueIndex++] = pCh;
423 pCh->channelNeeds |= NEED_CREDIT;
433 // Function: i2QueueCommands(type, pCh, timeout, nCommands, pCs,...)
454 i2QueueCommands(int type, i2ChanStrPtr pCh, int timeout, int nCommands,
479 if ( !i2Validate ( pCh ) ) {
485 pB = pCh->pMyBord;
505 pBuf = pCh->Obuf;
511 pBuf = pCh->Cbuf;
540 if ( !( pCh->flush_flags && i2RetryFlushOutput( pCh ) ) ) {
544 lock_var_p = &pCh->Obuf_spinlock;
546 stuffIndex = pCh->Obuf_stuff;
547 bufroom = pCh->Obuf_strip - stuffIndex;
550 lock_var_p = &pCh->Cbuf_spinlock;
552 stuffIndex = pCh->Cbuf_stuff;
553 bufroom = pCh->Cbuf_strip - stuffIndex;
598 channel = pCh->infl.hd.i2sChannel;
615 pCh->bookMarks++;
617 ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks );
671 pCh->Obuf_stuff = stuffIndex; // Store buffer pointer
672 write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
677 i2QueueNeeds(pB, pCh, NEED_INLINE);
681 pCh->Cbuf_stuff = stuffIndex; // Store buffer pointer
682 write_unlock_irqrestore(&pCh->Cbuf_spinlock, flags);
687 i2QueueNeeds(pB, pCh, NEED_BYPASS);
697 // Function: i2GetStatus(pCh,resetBits)
706 // AFTER the condition is passed. If pCh does not point to a valid channel,
710 i2GetStatus(i2ChanStrPtr pCh, int resetBits)
715 ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits );
718 if ( !i2Validate ( pCh ) )
721 pB = pCh->pMyBord;
723 status = pCh->dataSetIn;
729 pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR));
730 pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI);
733 ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn );
751 i2Input(i2ChanStrPtr pCh)
761 if ( !i2Validate( pCh ) ) {
765 write_lock_irqsave(&pCh->Ibuf_spinlock, flags);
768 stripIndex = pCh->Ibuf_strip;
770 count = pCh->Ibuf_stuff - stripIndex;
775 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
783 amountToMove = pCh->pTTY->receive_room;
794 pCh->pTTY->ldisc->ops->receive_buf( pCh->pTTY,
795 &(pCh->Ibuf[stripIndex]), NULL, amountToMove );
798 pCh->pTTY->ldisc->ops->receive_buf( pCh->pTTY,
799 pCh->Ibuf, NULL, count - amountToMove );
807 pCh->Ibuf_strip = stripIndex;
812 pCh->infl.asof += count;
814 if ((pCh->sinceLastFlow += count) >= pCh->whenSendFlow) {
815 pCh->sinceLastFlow -= pCh->whenSendFlow;
816 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
817 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
819 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
830 // Function: i2InputFlush(pCh)
840 i2InputFlush(i2ChanStrPtr pCh)
846 if ( !i2Validate ( pCh ) )
851 write_lock_irqsave(&pCh->Ibuf_spinlock, flags);
852 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
860 pCh->Ibuf_strip = pCh->Ibuf_stuff;
867 pCh->infl.asof += count;
869 if ( (pCh->sinceLastFlow += count) >= pCh->whenSendFlow )
871 pCh->sinceLastFlow -= pCh->whenSendFlow;
872 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
873 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
875 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
884 // Function: i2InputAvailable(pCh)
895 // Function: i2Output(pCh, pSource, count)
905 // room for all the data? If pCh->channelOptions & CO_NBLOCK_WRITE is set, then
912 i2Output(i2ChanStrPtr pCh, const char *pSource, int count)
927 if ( !i2Validate ( pCh ) )
931 pB = pCh->pMyBord;
932 channel = pCh->infl.hd.i2sChannel;
946 read_lock_irqsave(&pCh->Obuf_spinlock, flags);
947 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
948 read_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
973 if ( !(pCh->flush_flags && i2RetryFlushOutput(pCh) )
976 write_lock_irqsave(&pCh->Obuf_spinlock, flags);
977 stuffIndex = pCh->Obuf_stuff;
981 pInsert = &(pCh->Obuf[stuffIndex]);
994 pCh->Obuf_char_count += amountToMove;
1001 pCh->Obuf_stuff = stuffIndex;
1003 write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
1019 i2QueueNeeds(pB, pCh, NEED_INLINE);
1053 } else if ( pCh->channelNeeds & NEED_CREDIT ) {
1078 i2QueueNeeds(pB, pCh, NEED_INLINE);
1095 // Function: i2FlushOutput(pCh)
1105 i2FlushOutput(i2ChanStrPtr pCh)
1108 ip2trace (CHANN, ITRC_FLUSH, 1, 1, pCh->flush_flags );
1110 if (pCh->flush_flags)
1113 if ( 1 != i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1114 pCh->flush_flags = STARTFL_FLAG; // Failed - flag for later
1118 } else if ( 1 != i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL) ) {
1119 pCh->flush_flags = STOPFL_FLAG; // Failed - flag for later
1126 i2RetryFlushOutput(i2ChanStrPtr pCh)
1128 int old_flags = pCh->flush_flags;
1132 pCh->flush_flags = 0; // Clear flag so we can avoid recursion
1136 if ( 1 == i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1146 if (1 == i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL)) {
1152 pCh->flush_flags = old_flags;
1160 // Function: i2DrainOutput(pCh,timeout)
1172 i2ChanStrPtr pCh = (i2ChanStrPtr)d;
1174 ip2trace (CHANN, ITRC_DRAIN, 10, 1, pCh->BookmarkTimer.expires );
1176 pCh->BookmarkTimer.expires = 0;
1177 wake_up_interruptible( &pCh->pBookmarkWait );
1181 i2DrainOutput(i2ChanStrPtr pCh, int timeout)
1186 ip2trace (CHANN, ITRC_DRAIN, ITRC_ENTER, 1, pCh->BookmarkTimer.expires);
1188 pB = pCh->pMyBord;
1197 if ((timeout > 0) && (pCh->BookmarkTimer.expires == 0 )) {
1199 setup_timer(&pCh->BookmarkTimer, i2DrainWakeup,
1200 (unsigned long)pCh);
1202 ip2trace (CHANN, ITRC_DRAIN, 1, 1, pCh->BookmarkTimer.expires );
1204 mod_timer(&pCh->BookmarkTimer, jiffies + timeout);
1207 i2QueueCommands( PTYPE_INLINE, pCh, -1, 1, CMD_BMARK_REQ );
1210 add_wait_queue(&(pCh->pBookmarkWait), &wait);
1219 remove_wait_queue(&(pCh->pBookmarkWait), &wait);
1222 if ((timeout > 0) && pCh->BookmarkTimer.expires &&
1223 time_before(jiffies, pCh->BookmarkTimer.expires)) {
1224 del_timer( &(pCh->BookmarkTimer) );
1225 pCh->BookmarkTimer.expires = 0;
1227 ip2trace (CHANN, ITRC_DRAIN, 3, 1, pCh->BookmarkTimer.expires );
1230 ip2trace (CHANN, ITRC_DRAIN, ITRC_RETURN, 1, pCh->BookmarkTimer.expires );
1235 // Function: i2OutputFree(pCh)
1244 i2OutputFree(i2ChanStrPtr pCh)
1250 if ( !i2Validate ( pCh ) ) {
1253 read_lock_irqsave(&pCh->Obuf_spinlock, flags);
1254 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
1255 read_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
1269 i2ChanStrPtr pCh;
1273 pCh = tp->driver_data;
1285 i2ChanStrPtr *pCh;
1287 pCh = (i2ChanStrPtr *) pB->i2eChannelPtr;
1293 if (pCh[i*16+j] == NULL)
1295 (pCh[i*16+j])->BaudBase = 921600; // MAX for ST654
1296 (pCh[i*16+j])->BaudDivisor = 96;
1300 if (pCh[i*16+j] == NULL)
1302 (pCh[i*16+j])->BaudBase = 115200; // MAX for CD1400
1303 (pCh[i*16+j])->BaudDivisor = 12;
1353 i2ChanStrPtr pCh;
1397 (NULL==(pCh = ((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])))
1414 pCh->hotKeyIn = iiReadWord(pB) & 0xff;
1417 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_HOTACK);
1423 write_lock_irqsave(&pCh->Ibuf_spinlock, cflags);
1425 stuffIndex = pCh->Ibuf_stuff;
1434 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1435 pCh->icount.rx += amountToRead;
1448 pCh->Ibuf[0] = pCh->Ibuf[IBUF_SIZE];
1459 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1460 pCh->icount.rx += amountToRead;
1465 pCh->Ibuf_stuff = stuffIndex;
1466 write_unlock_irqrestore(&pCh->Ibuf_spinlock, cflags);
1471 schedule_work(&pCh->tqueue_input);
1473 do_input(&pCh->tqueue_input);
1504 (pCh = (((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])) != NULL
1513 if ( !(pCh->dataSetIn & I2_CTS) )
1515 pCh->dataSetIn |= I2_DCTS;
1516 pCh->icount.cts++;
1519 pCh->dataSetIn |= I2_CTS;
1523 if ( pCh->dataSetIn & I2_CTS )
1525 pCh->dataSetIn |= I2_DCTS;
1526 pCh->icount.cts++;
1529 pCh->dataSetIn &= ~I2_CTS;
1533 ip2trace (channel, ITRC_MODEM, 1, 1, pCh->dataSetIn );
1535 if ( !(pCh->dataSetIn & I2_DCD) )
1538 pCh->dataSetIn |= I2_DDCD;
1539 pCh->icount.dcd++;
1542 pCh->dataSetIn |= I2_DCD;
1544 ip2trace (channel, ITRC_MODEM, 3, 1, pCh->dataSetIn );
1548 ip2trace (channel, ITRC_MODEM, 4, 1, pCh->dataSetIn );
1549 if ( pCh->dataSetIn & I2_DCD )
1552 pCh->dataSetIn |= I2_DDCD;
1553 pCh->icount.dcd++;
1556 pCh->dataSetIn &= ~I2_DCD;
1558 ip2trace (channel, ITRC_MODEM, 6, 1, pCh->dataSetIn );
1562 if ( !(pCh->dataSetIn & I2_DSR) )
1564 pCh->dataSetIn |= I2_DDSR;
1565 pCh->icount.dsr++;
1568 pCh->dataSetIn |= I2_DSR;
1572 if ( pCh->dataSetIn & I2_DSR )
1574 pCh->dataSetIn |= I2_DDSR;
1575 pCh->icount.dsr++;
1578 pCh->dataSetIn &= ~I2_DSR;
1582 if ( !(pCh->dataSetIn & I2_RI) )
1584 pCh->dataSetIn |= I2_DRI;
1585 pCh->icount.rng++;
1588 pCh->dataSetIn |= I2_RI ;
1593 //if ( pCh->dataSetIn & I2_RI )
1595 // pCh->dataSetIn |= I2_DRI;
1596 // pCh->icount.rng++;
1599 pCh->dataSetIn &= ~I2_RI ;
1603 pCh->dataSetIn |= I2_BRK;
1604 pCh->icount.brk++;
1610 pCh->bookMarks--;
1611 if (pCh->bookMarks <= 0 ) {
1612 pCh->bookMarks = 0;
1613 wake_up_interruptible( &pCh->pBookmarkWait );
1615 ip2trace (channel, ITRC_DRAIN, 20, 1, pCh->BookmarkTimer.expires );
1622 pCh->outfl.room =
1624 (pCh->outfl.asof - ((flowStatPtr)pc)->asof);
1626 ip2trace (channel, ITRC_STFLW, 1, 1, pCh->outfl.room );
1628 if (pCh->channelNeeds & NEED_CREDIT)
1630 ip2trace (channel, ITRC_STFLW, 2, 1, pCh->channelNeeds);
1632 pCh->channelNeeds &= ~NEED_CREDIT;
1633 i2QueueNeeds(pB, pCh, NEED_INLINE);
1634 if ( pCh->pTTY )
1635 ip2_owake(pCh->pTTY);
1638 ip2trace (channel, ITRC_STFLW, 3, 1, pCh->channelNeeds);
1648 pCh->channelStatus = *((debugStatPtr)pc);
1654 pCh->channelTcount = *((cntStatPtr)pc);
1660 pCh->channelRcount = *((cntStatPtr)pc);
1671 i2QueueCommands (PTYPE_INLINE, pCh, 0, 1, CMD_HW_TEST);
1672 pCh->channelFail = *((failStatPtr)pc);
1684 pCh->dataSetIn |= I2_PAR;
1685 pCh->icount.parity++;
1688 pCh->dataSetIn |= I2_FRA;
1689 pCh->icount.frame++;
1692 pCh->dataSetIn |= I2_OVR;
1693 pCh->icount.overrun++;
1699 pCh->dataSetIn = (pCh->dataSetIn
1702 wake_up_interruptible ( &pCh->dss_now_wait );
1709 schedule_work(&pCh->tqueue_status);
1711 do_status(&pCh->tqueue_status);
1789 i2ChanStrPtr pCh;
1802 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_BYPASS))))
1804 write_lock_irqsave(&pCh->Cbuf_spinlock, flags);
1805 stripIndex = pCh->Cbuf_strip;
1809 while (stripIndex != pCh->Cbuf_stuff) {
1810 pRemove = &(pCh->Cbuf[stripIndex]);
1817 i2QueueNeeds(pB, pCh, NEED_BYPASS); // Put back on queue
1830 pRemove = pCh->Cbuf;
1835 pCh->Cbuf_strip = stripIndex;
1836 write_unlock_irqrestore(&pCh->Cbuf_spinlock, flags);
1859 i2ChanStrPtr pCh;
1867 while ( (NULL != (pCh = i2DeQueueNeeds(pB,NEED_FLOW)))) {
1871 if ( 0 == i2Write2Fifo(pB,(unsigned char *)&(pCh->infl),paddedSize,0)) {
1875 WriteDBGBuf("FLOW",(unsigned char *) &(pCh->infl), paddedSize);
1896 i2ChanStrPtr pCh;
1914 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_INLINE))) )
1916 write_lock_irqsave(&pCh->Obuf_spinlock, flags);
1917 stripIndex = pCh->Obuf_strip;
1919 ip2trace (CHANN, ITRC_SICMD, 3, 2, stripIndex, pCh->Obuf_stuff );
1923 while ( --bailout2 && stripIndex != pCh->Obuf_stuff) {
1924 pRemove = &(pCh->Obuf[stripIndex]);
1946 ip2trace (CHANN, ITRC_SICMD, 5, 2, pCh->outfl.room, flowsize );
1948 if (pCh->outfl.room <= flowsize) {
1950 i2QueueNeeds(pB, pCh, NEED_CREDIT);
1958 i2QueueNeeds(pB, pCh, NEED_INLINE);
1966 pCh->icount.tx += flowsize;
1968 pCh->outfl.room -= flowsize;
1969 pCh->outfl.asof += flowsize;
1971 pCh->Obuf_char_count -= DATA_COUNT_OF(pRemove);
1976 ip2trace (CHANN, ITRC_SICMD, 6, 2, stripIndex, pCh->Obuf_strip);
1980 pRemove = pCh->Obuf;
1991 pCh->Obuf_strip = stripIndex;
1992 write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
1998 if ( pCh->pTTY ) {
1999 ip2_owake(pCh->pTTY);