litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Mike Rapoport <mike@compulab.co.il>	2010-08-04 07:43:18 -0400
committer	Tony Lindgren <tony@atomide.com>	2010-08-04 07:43:18 -0400
commit	869fef41547db95df8523bf67845a21313709428 (patch)
tree	5d12824045f9ac8b94a6e2aabfdb7b8693bdf051 /arch/arm/mach-omap2/board-ldp.c
parent	c573bcf96a427923d09de0b247691165d9a96023 (diff)

omap3: introduce omap3_map_io

Most OMAP3-based boards use exactly the same code for .map_io method in the machine_desc structure. This patch introduces omap3_map_io and updates board-* files to use it as .map_io method. Signed-off-by: Mike Rapoport <mike@compulab.co.il> Signed-off-by: Tony Lindgren <tony@atomide.com>

Diffstat (limited to 'arch/arm/mach-omap2/board-ldp.c')

-rw-r--r--

arch/arm/mach-omap2/board-ldp.c

1 files changed, 1 insertions, 7 deletions

         ldp_vmmc1_supply.dev = mmc[0].dev;
 }
-static void __init omap_ldp_map_io(void)
-{
-        omap2_set_globals_3xxx();
-        omap34xx_map_common_io();
-}
 MACHINE_START(OMAP_LDP, "OMAP LDP board")
         .phys_io        = 0x48000000,
         .io_pg_offst    = ((0xfa000000) >> 18) & 0xfffc,
         .boot_params    = 0x80000100,
-        .map_io         = omap_ldp_map_io,
+        .map_io         = omap3_map_io,
         .reserve        = omap_reserve,
         .init_irq       = omap_ldp_init_irq,
         .init_machine   = omap_ldp_init,

/******************************************************************************* * * (c) 1999 by Computone Corporation * ******************************************************************************** * * * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport * serial I/O controllers. * * DESCRIPTION: High-level interface code for the device driver. Uses the * Extremely Low Level Interface Support (i2ellis.c). Provides an * interface to the standard loadware, to support drivers or * application code. (This is included source code, not a separate * compilation module.) * *******************************************************************************/ //------------------------------------------------------------------------------ // Note on Strategy: // Once the board has been initialized, it will interrupt us when: // 1) It has something in the fifo for us to read (incoming data, flow control // packets, or whatever). // 2) It has stripped whatever we have sent last time in the FIFO (and // consequently is ready for more). // // Note also that the buffer sizes declared in i2lib.h are VERY SMALL. This // worsens performance considerably, but is done so that a great many channels // might use only a little memory. //------------------------------------------------------------------------------ //------------------------------------------------------------------------------ // Revision History: // // 0.00 - 4/16/91 --- First Draft // 0.01 - 4/29/91 --- 1st beta release // 0.02 - 6/14/91 --- Changes to allow small model compilation // 0.03 - 6/17/91 MAG Break reporting protected from interrupts routines with // in-line asm added for moving data to/from ring buffers, // replacing a variety of methods used previously. // 0.04 - 6/21/91 MAG Initial flow-control packets not queued until // i2_enable_interrupts time. Former versions would enqueue // them at i2_init_channel time, before we knew how many // channels were supposed to exist! // 0.05 - 10/12/91 MAG Major changes: works through the ellis.c routines now; // supports new 16-bit protocol and expandable boards. // - 10/24/91 MAG Most changes in place and stable. // 0.06 - 2/20/92 MAG Format of CMD_HOTACK corrected: the command takes no // argument. // 0.07 -- 3/11/92 MAG Support added to store special packet types at interrupt // level (mostly responses to specific commands.) // 0.08 -- 3/30/92 MAG Support added for STAT_MODEM packet // 0.09 -- 6/24/93 MAG i2Link... needed to update number of boards BEFORE // turning on the interrupt. // 0.10 -- 6/25/93 MAG To avoid gruesome death from a bad board, we sanity check // some incoming. // // 1.1 - 12/25/96 AKM Linux version. // - 10/09/98 DMC Revised Linux version. //------------------------------------------------------------------------------ //************ //* Includes * //************ #include <linux/sched.h> #include "i2lib.h" //*********************** //* Function Prototypes * //*********************** static void i2QueueNeeds(i2eBordStrPtr, i2ChanStrPtr, int); static i2ChanStrPtr i2DeQueueNeeds(i2eBordStrPtr, int ); static void i2StripFifo(i2eBordStrPtr); static void i2StuffFifoBypass(i2eBordStrPtr); static void i2StuffFifoFlow(i2eBordStrPtr); static void i2StuffFifoInline(i2eBordStrPtr); static int i2RetryFlushOutput(i2ChanStrPtr); // Not a documented part of the library routines (careful...) but the Diagnostic // i2diag.c finds them useful to help the throughput in certain limited // single-threaded operations. static void iiSendPendingMail(i2eBordStrPtr); static void serviceOutgoingFifo(i2eBordStrPtr); // Functions defined in ip2.c as part of interrupt handling static void do_input(struct work_struct *); static void do_status(struct work_struct *); //*************** //* Debug Data * //*************** #ifdef DEBUG_FIFO unsigned char DBGBuf[0x4000]; unsigned short I = 0; static void WriteDBGBuf(char *s, unsigned char *src, unsigned short n ) { char *p = src; // XXX: We need a spin lock here if we ever use this again while (*s) { // copy label DBGBuf[I] = *s++; I = I++ & 0x3fff; } while (n--) { // copy data DBGBuf[I] = *p++; I = I++ & 0x3fff; } } static void fatality(i2eBordStrPtr pB ) { int i; for (i=0;i<sizeof(DBGBuf);i++) { if ((i%16) == 0) printk("\n%4x:",i); printk("%02x ",DBGBuf[i]); } printk("\n"); for (i=0;i<sizeof(DBGBuf);i++) { if ((i%16) == 0) printk("\n%4x:",i); if (DBGBuf[i] >= ' ' && DBGBuf[i] <= '~') { printk(" %c ",DBGBuf[i]); } else { printk(" . "); } } printk("\n"); printk("Last index %x\n",I); } #endif /* DEBUG_FIFO */ //******** //* Code * //******** static inline int i2Validate ( i2ChanStrPtr pCh ) { //ip2trace(pCh->port_index, ITRC_VERIFY,ITRC_ENTER,2,pCh->validity, // (CHANNEL_MAGIC | CHANNEL_SUPPORT)); return ((pCh->validity & (CHANNEL_MAGIC_BITS | CHANNEL_SUPPORT)) == (CHANNEL_MAGIC | CHANNEL_SUPPORT)); } //****************************************************************************** // Function: iiSendPendingMail(pB) // Parameters: Pointer to a board structure // Returns: Nothing // // Description: // If any outgoing mail bits are set and there is outgoing mailbox is empty, // send the mail and clear the bits. //****************************************************************************** static inline void iiSendPendingMail(i2eBordStrPtr pB) { if (pB->i2eOutMailWaiting && (!pB->i2eWaitingForEmptyFifo) ) { if (iiTrySendMail(pB, pB->i2eOutMailWaiting)) { /* If we were already waiting for fifo to empty, * or just sent MB_OUT_STUFFED, then we are * still waiting for it to empty, until we should * receive an MB_IN_STRIPPED from the board. */ pB->i2eWaitingForEmptyFifo |= (pB->i2eOutMailWaiting & MB_OUT_STUFFED); pB->i2eOutMailWaiting = 0; pB->SendPendingRetry = 0; } else { /* The only time we hit this area is when "iiTrySendMail" has failed. That only occurs when the outbound mailbox is still busy with the last message. We take a short breather to let the board catch up with itself and then try again. 16 Retries is the limit - then we got a borked board. /\/\|=mhw=|\/\/ */ if( ++pB->SendPendingRetry < 16 ) { init_timer( &(pB->SendPendingTimer) ); pB->SendPendingTimer.expires = jiffies + 1; pB->SendPendingTimer.function = (void*)(unsigned long)iiSendPendingMail; pB->SendPendingTimer.data = (unsigned long)pB; add_timer( &(pB->SendPendingTimer) ); } else { printk( KERN_ERR "IP2: iiSendPendingMail unable to queue outbound mail\n" ); } } } } //****************************************************************************** // Function: i2InitChannels(pB, nChannels, pCh) // Parameters: Pointer to Ellis Board structure // Number of channels to initialize // Pointer to first element in an array of channel structures // Returns: Success or failure // // Description: // // This function patches pointers, back-pointers, and initializes all the // elements in the channel structure array. // // This should be run after the board structure is initialized, through having // loaded the standard loadware (otherwise it complains). // // In any case, it must be done before any serious work begins initializing the // irq's or sending commands... // //****************************************************************************** static int i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh) { int index, stuffIndex; i2ChanStrPtr *ppCh; if (pB->i2eValid != I2E_MAGIC) { COMPLETE(pB, I2EE_BADMAGIC); } if (pB->i2eState != II_STATE_STDLOADED) { COMPLETE(pB, I2EE_BADSTATE); } LOCK_INIT(&pB->read_fifo_spinlock); LOCK_INIT(&pB->write_fifo_spinlock); LOCK_INIT(&pB->Dbuf_spinlock); LOCK_INIT(&pB->Bbuf_spinlock); LOCK_INIT(&pB->Fbuf_spinlock); // NO LOCK needed yet - this is init pB->i2eChannelPtr = pCh; pB->i2eChannelCnt = nChannels; pB->i2Fbuf_strip = pB->i2Fbuf_stuff = 0; pB->i2Dbuf_strip = pB->i2Dbuf_stuff = 0; pB->i2Bbuf_strip = pB->i2Bbuf_stuff = 0; pB->SendPendingRetry = 0; memset ( pCh, 0, sizeof (i2ChanStr) * nChannels ); for (index = stuffIndex = 0, ppCh = (i2ChanStrPtr *)(pB->i2Fbuf); nChannels && index < ABS_MOST_PORTS; index++) { if ( !(pB->i2eChannelMap[index >> 4] & (1 << (index & 0xf)) ) ) { continue; } LOCK_INIT(&pCh->Ibuf_spinlock); LOCK_INIT(&pCh->Obuf_spinlock); LOCK_INIT(&pCh->Cbuf_spinlock); LOCK_INIT(&pCh->Pbuf_spinlock); // NO LOCK needed yet - this is init // Set up validity flag according to support level if (pB->i2eGoodMap[index >> 4] & (1 << (index & 0xf)) ) { pCh->validity = CHANNEL_MAGIC | CHANNEL_SUPPORT; } else { pCh->validity = CHANNEL_MAGIC; } pCh->pMyBord = pB; /* Back-pointer */ // Prepare an outgoing flow-control packet to send as soon as the chance // occurs. if ( pCh->validity & CHANNEL_SUPPORT ) { pCh->infl.hd.i2sChannel = index; pCh->infl.hd.i2sCount = 5; pCh->infl.hd.i2sType = PTYPE_BYPASS; pCh->infl.fcmd = 37; pCh->infl.asof = 0; pCh->infl.room = IBUF_SIZE - 1; pCh->whenSendFlow = (IBUF_SIZE/5)*4; // when 80% full // The following is similar to calling i2QueueNeeds, except that this // is done in longhand, since we are setting up initial conditions on // many channels at once. pCh->channelNeeds = NEED_FLOW; // Since starting from scratch pCh->sinceLastFlow = 0; // No bytes received since last flow // control packet was queued stuffIndex++; *ppCh++ = pCh; // List this channel as needing // initial flow control packet sent } // Don't allow anything to be sent until the status packets come in from // the board. pCh->outfl.asof = 0; pCh->outfl.room = 0; // Initialize all the ring buffers pCh->Ibuf_stuff = pCh->Ibuf_strip = 0; pCh->Obuf_stuff = pCh->Obuf_strip = 0; pCh->Cbuf_stuff = pCh->Cbuf_strip = 0; memset( &pCh->icount, 0, sizeof (struct async_icount) ); pCh->hotKeyIn = HOT_CLEAR; pCh->channelOptions = 0; pCh->bookMarks = 0; init_waitqueue_head(&pCh->pBookmarkWait); init_waitqueue_head(&pCh->open_wait); init_waitqueue_head(&pCh->close_wait); init_waitqueue_head(&pCh->delta_msr_wait); // Set base and divisor so default custom rate is 9600 pCh->BaudBase = 921600; // MAX for ST654, changed after we get pCh->BaudDivisor = 96; // the boxids (UART types) later pCh->dataSetIn = 0; pCh->dataSetOut = 0; pCh->wopen = 0; pCh->throttled = 0; pCh->speed = CBR_9600; pCh->flags = 0; pCh->ClosingDelay = 5*HZ/10; pCh->ClosingWaitTime = 30*HZ; // Initialize task queue objects INIT_WORK(&pCh->tqueue_input, do_input); INIT_WORK(&pCh->tqueue_status, do_status); #ifdef IP2DEBUG_TRACE pCh->trace = ip2trace; #endif ++pCh; --nChannels; } // No need to check for wrap here; this is initialization. pB->i2Fbuf_stuff = stuffIndex; COMPLETE(pB, I2EE_GOOD); } //****************************************************************************** // Function: i2DeQueueNeeds(pB, type) // Parameters: Pointer to a board structure // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW // Returns: // Pointer to a channel structure // // Description: Returns pointer struct of next channel that needs service of // the type specified. Otherwise returns a NULL reference. // //****************************************************************************** static i2ChanStrPtr i2DeQueueNeeds(i2eBordStrPtr pB, int type) { unsigned short queueIndex; unsigned long flags; i2ChanStrPtr pCh = NULL; switch(type) { case NEED_INLINE: WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags); if ( pB->i2Dbuf_stuff != pB->i2Dbuf_strip) { queueIndex = pB->i2Dbuf_strip; pCh = pB->i2Dbuf[queueIndex]; queueIndex++; if (queueIndex >= CH_QUEUE_SIZE) { queueIndex = 0; } pB->i2Dbuf_strip = queueIndex; pCh->channelNeeds &= ~NEED_INLINE; } WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags); break; case NEED_BYPASS: WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags); if (pB->i2Bbuf_stuff != pB->i2Bbuf_strip) { queueIndex = pB->i2Bbuf_strip; pCh = pB->i2Bbuf[queueIndex]; queueIndex++; if (queueIndex >= CH_QUEUE_SIZE) { queueIndex = 0; } pB->i2Bbuf_strip = queueIndex; pCh->channelNeeds &= ~NEED_BYPASS; } WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags); break; case NEED_FLOW: WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags); if (pB->i2Fbuf_stuff != pB->i2Fbuf_strip) { queueIndex = pB->i2Fbuf_strip; pCh = pB->i2Fbuf[queueIndex]; queueIndex++; if (queueIndex >= CH_QUEUE_SIZE) { queueIndex = 0; } pB->i2Fbuf_strip = queueIndex; pCh->channelNeeds &= ~NEED_FLOW; } WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags); break; default: printk(KERN_ERR "i2DeQueueNeeds called with bad type:%x\n",type); break; } return pCh; } //****************************************************************************** // Function: i2QueueNeeds(pB, pCh, type) // Parameters: Pointer to a board structure // Pointer to a channel structure // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW // Returns: Nothing // // Description: // For each type of need selected, if the given channel is not already in the // queue, adds it, and sets the flag indicating it is in the queue. //****************************************************************************** static void i2QueueNeeds(i2eBordStrPtr pB, i2ChanStrPtr pCh, int type) { unsigned short queueIndex; unsigned long flags; // We turn off all the interrupts during this brief process, since the // interrupt-level code might want to put things on the queue as well. switch (type) { case NEED_INLINE: WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags); if ( !(pCh->channelNeeds & NEED_INLINE) ) { pCh->channelNeeds |= NEED_INLINE; queueIndex = pB->i2Dbuf_stuff; pB->i2Dbuf[queueIndex++] = pCh; if (queueIndex >= CH_QUEUE_SIZE) queueIndex = 0; pB->i2Dbuf_stuff = queueIndex; } WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags); break; case NEED_BYPASS: WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags); if ((type & NEED_BYPASS) && !(pCh->channelNeeds & NEED_BYPASS)) { pCh->channelNeeds |= NEED_BYPASS; queueIndex = pB->i2Bbuf_stuff; pB->i2Bbuf[queueIndex++] = pCh; if (queueIndex >= CH_QUEUE_SIZE) queueIndex = 0; pB->i2Bbuf_stuff = queueIndex; } WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags); break; case NEED_FLOW: WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags); if ((type & NEED_FLOW) && !(pCh->channelNeeds & NEED_FLOW)) { pCh->channelNeeds |= NEED_FLOW; queueIndex = pB->i2Fbuf_stuff; pB->i2Fbuf[queueIndex++] = pCh; if (queueIndex >= CH_QUEUE_SIZE) queueIndex = 0; pB->i2Fbuf_stuff = queueIndex; } WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags); break; case NEED_CREDIT: pCh->channelNeeds |= NEED_CREDIT; break; default: printk(KERN_ERR "i2QueueNeeds called with bad type:%x\n",type); break; } return; } //****************************************************************************** // Function: i2QueueCommands(type, pCh, timeout, nCommands, pCs,...) // Parameters: type - PTYPE_BYPASS or PTYPE_INLINE // pointer to the channel structure // maximum period to wait // number of commands (n) // n commands // Returns: Number of commands sent, or -1 for error // // get board lock before calling // // Description: // Queues up some commands to be sent to a channel. To send possibly several // bypass or inline commands to the given channel. The timeout parameter // indicates how many HUNDREDTHS OF SECONDS to wait until there is room: // 0 = return immediately if no room, -ive = wait forever, +ive = number of // 1/100 seconds to wait. Return values: // -1 Some kind of nasty error: bad channel structure or invalid arguments. // 0 No room to send all the commands // (+) Number of commands sent //****************************************************************************** static int i2QueueCommands(int type, i2ChanStrPtr pCh, int timeout, int nCommands, cmdSyntaxPtr pCs0,...) { int totalsize = 0; int blocksize; int lastended; cmdSyntaxPtr *ppCs; cmdSyntaxPtr pCs; int count; int flag; i2eBordStrPtr pB; unsigned short maxBlock; unsigned short maxBuff; short bufroom; unsigned short stuffIndex; unsigned char *pBuf; unsigned char *pInsert; unsigned char *pDest, *pSource; unsigned short channel; int cnt; unsigned long flags = 0; rwlock_t *lock_var_p = NULL; // Make sure the channel exists, otherwise do nothing if ( !i2Validate ( pCh ) ) { return -1; } ip2trace (CHANN, ITRC_QUEUE, ITRC_ENTER, 0 ); pB = pCh->pMyBord; // Board must also exist, and THE INTERRUPT COMMAND ALREADY SENT if (pB->i2eValid != I2E_MAGIC || pB->i2eUsingIrq == IRQ_UNDEFINED) { return -2; } // If the board has gone fatal, return bad, and also hit the trap routine if // it exists. if (pB->i2eFatal) { if ( pB->i2eFatalTrap ) { (*(pB)->i2eFatalTrap)(pB); } return -3; } // Set up some variables, Which buffers are we using? How big are they? switch(type) { case PTYPE_INLINE: flag = INL; maxBlock = MAX_OBUF_BLOCK; maxBuff = OBUF_SIZE; pBuf = pCh->Obuf; break; case PTYPE_BYPASS: flag = BYP; maxBlock = MAX_CBUF_BLOCK; maxBuff = CBUF_SIZE; pBuf = pCh->Cbuf; break; default: return -4; } // Determine the total size required for all the commands totalsize = blocksize = sizeof(i2CmdHeader); lastended = 0; ppCs = &pCs0; for ( count = nCommands; count; count--, ppCs++) { pCs = *ppCs; cnt = pCs->length; // Will a new block be needed for this one? // Two possible reasons: too // big or previous command has to be at the end of a packet. if ((blocksize + cnt > maxBlock) || lastended) { blocksize = sizeof(i2CmdHeader); totalsize += sizeof(i2CmdHeader); } totalsize += cnt; blocksize += cnt; // If this command had to end a block, then we will make sure to // account for it should there be any more blocks. lastended = pCs->flags & END; } for (;;) { // Make sure any pending flush commands go out before we add more data. if ( !( pCh->flush_flags && i2RetryFlushOutput( pCh ) ) ) { // How much room (this time through) ? switch(type) { case PTYPE_INLINE: lock_var_p = &pCh->Obuf_spinlock; WRITE_LOCK_IRQSAVE(lock_var_p,flags); stuffIndex = pCh->Obuf_stuff; bufroom = pCh->Obuf_strip - stuffIndex; break; case PTYPE_BYPASS: lock_var_p = &pCh->Cbuf_spinlock; WRITE_LOCK_IRQSAVE(lock_var_p,flags); stuffIndex = pCh->Cbuf_stuff; bufroom = pCh->Cbuf_strip - stuffIndex; break; default: return -5; } if (--bufroom < 0) { bufroom += maxBuff; } ip2trace (CHANN, ITRC_QUEUE, 2, 1, bufroom ); // Check for overflow if (totalsize <= bufroom) { // Normal Expected path - We still hold LOCK break; /* from for()- Enough room: goto proceed */ } } ip2trace (CHANN, ITRC_QUEUE, 3, 1, totalsize ); // Prepare to wait for buffers to empty WRITE_UNLOCK_IRQRESTORE(lock_var_p,flags); serviceOutgoingFifo(pB); // Dump what we got if (timeout == 0) { return 0; // Tired of waiting } if (timeout > 0) timeout--; // So negative values == forever if (!in_interrupt()) { schedule_timeout_interruptible(1); // short nap } else { // we cannot sched/sleep in interrrupt silly return 0; } if (signal_pending(current)) { return 0; // Wake up! Time to die!!! } ip2trace (CHANN, ITRC_QUEUE, 4, 0 ); } // end of for(;;) // At this point we have room and the lock - stick them in. channel = pCh->infl.hd.i2sChannel; pInsert = &pBuf[stuffIndex]; // Pointer to start of packet pDest = CMD_OF(pInsert); // Pointer to start of command // When we start counting, the block is the size of the header for (blocksize = sizeof(i2CmdHeader), count = nCommands, lastended = 0, ppCs = &pCs0; count; count--, ppCs++) { pCs = *ppCs; // Points to command protocol structure // If this is a bookmark request command, post the fact that a bookmark // request is pending. NOTE THIS TRICK ONLY WORKS BECAUSE CMD_BMARK_REQ // has no parameters! The more general solution would be to reference // pCs->cmd[0]. if (pCs == CMD_BMARK_REQ) { pCh->bookMarks++; ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks ); } cnt = pCs->length; // If this command would put us over the maximum block size or // if the last command had to be at the end of a block, we end // the existing block here and start a new one. if ((blocksize + cnt > maxBlock) || lastended) { ip2trace (CHANN, ITRC_QUEUE, 5, 0 ); PTYPE_OF(pInsert) = type; CHANNEL_OF(pInsert) = channel; // count here does not include the header CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader); stuffIndex += blocksize; if(stuffIndex >= maxBuff) { stuffIndex = 0; pInsert = pBuf; } pInsert = &pBuf[stuffIndex]; // Pointer to start of next pkt pDest = CMD_OF(pInsert); blocksize = sizeof(i2CmdHeader); } // Now we know there is room for this one in the current block blocksize += cnt; // Total bytes in this command pSource = pCs->cmd; // Copy the command into the buffer while (cnt--) { *pDest++ = *pSource++; } // If this command had to end a block, then we will make sure to account // for it should there be any more blocks. lastended = pCs->flags & END; } // end for // Clean up the final block by writing header, etc PTYPE_OF(pInsert) = type; CHANNEL_OF(pInsert) = channel; // count here does not include the header CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader); stuffIndex += blocksize; if(stuffIndex >= maxBuff) { stuffIndex = 0; pInsert = pBuf; } // Updates the index, and post the need for service. When adding these to // the queue of channels, we turn off the interrupt while doing so, // because at interrupt level we might want to push a channel back to the // end of the queue. switch(type) { case PTYPE_INLINE: pCh->Obuf_stuff = stuffIndex; // Store buffer pointer WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags); pB->debugInlineQueued++; // Add the channel pointer to list of channels needing service (first // come...), if it's not already there. i2QueueNeeds(pB, pCh, NEED_INLINE); break; case PTYPE_BYPASS: pCh->Cbuf_stuff = stuffIndex; // Store buffer pointer WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags); pB->debugBypassQueued++; // Add the channel pointer to list of channels needing service (first // come...), if it's not already there. i2QueueNeeds(pB, pCh, NEED_BYPASS); break; } ip2trace (CHANN, ITRC_QUEUE, ITRC_RETURN, 1, nCommands ); return nCommands; // Good status: number of commands sent } //****************************************************************************** // Function: i2GetStatus(pCh,resetBits) // Parameters: Pointer to a channel structure // Bit map of status bits to clear // Returns: Bit map of current status bits // // Description: // Returns the state of data set signals, and whether a break has been received, // (see i2lib.h for bit-mapped result). resetBits is a bit-map of any status // bits to be cleared: I2_BRK, I2_PAR, I2_FRA, I2_OVR,... These are cleared // AFTER the condition is passed. If pCh does not point to a valid channel, // returns -1 (which would be impossible otherwise. //****************************************************************************** static int i2GetStatus(i2ChanStrPtr pCh, int resetBits) { unsigned short status; i2eBordStrPtr pB; ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits ); // Make sure the channel exists, otherwise do nothing */ if ( !i2Validate ( pCh ) ) return -1; pB = pCh->pMyBord; status = pCh->dataSetIn; // Clear any specified error bits: but note that only actual error bits can // be cleared, regardless of the value passed. if (resetBits) { pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR)); pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI); } ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn ); return status; } //****************************************************************************** // Function: i2Input(pChpDest,count) // Parameters: Pointer to a channel structure // Pointer to data buffer // Number of bytes to read // Returns: Number of bytes read, or -1 for error // // Description: // Strips data from the input buffer and writes it to pDest. If there is a // collosal blunder, (invalid structure pointers or the like), returns -1. // Otherwise, returns the number of bytes read. //****************************************************************************** static int i2Input(i2ChanStrPtr pCh) { int amountToMove; unsigned short stripIndex; int count; unsigned long flags = 0; ip2trace (CHANN, ITRC_INPUT, ITRC_ENTER, 0); // Ensure channel structure seems real if ( !i2Validate( pCh ) ) { count = -1; goto i2Input_exit; } WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags); // initialize some accelerators and private copies stripIndex = pCh->Ibuf_strip; count = pCh->Ibuf_stuff - stripIndex; // If buffer is empty or requested data count was 0, (trivial case) return // without any further thought. if ( count == 0 ) { WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags); goto i2Input_exit; } // Adjust for buffer wrap if ( count < 0 ) { count += IBUF_SIZE; } // Don't give more than can be taken by the line discipline amountToMove = pCh->pTTY->receive_room; if (count > amountToMove) { count = amountToMove; } // How much could we copy without a wrap? amountToMove = IBUF_SIZE - stripIndex; if (amountToMove > count) { amountToMove = count; } // Move the first block pCh->pTTY->ldisc.receive_buf( pCh->pTTY, &(pCh->Ibuf[stripIndex]), NULL, amountToMove ); // If we needed to wrap, do the second data move if (count > amountToMove) { pCh->pTTY->ldisc.receive_buf( pCh->pTTY, pCh->Ibuf, NULL, count - amountToMove ); } // Bump and wrap the stripIndex all at once by the amount of data read. This // method is good regardless of whether the data was in one or two pieces. stripIndex += count; if (stripIndex >= IBUF_SIZE) { stripIndex -= IBUF_SIZE; } pCh->Ibuf_strip = stripIndex; // Update our flow control information and possibly queue ourselves to send // it, depending on how much data has been stripped since the last time a // packet was sent. pCh->infl.asof += count; if ((pCh->sinceLastFlow += count) >= pCh->whenSendFlow) { pCh->sinceLastFlow -= pCh->whenSendFlow; WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags); i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW); } else { WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags); } i2Input_exit: ip2trace (CHANN, ITRC_INPUT, ITRC_RETURN, 1, count); return count; } //****************************************************************************** // Function: i2InputFlush(pCh) // Parameters: Pointer to a channel structure // Returns: Number of bytes stripped, or -1 for error // // Description: // Strips any data from the input buffer. If there is a collosal blunder, // (invalid structure pointers or the like), returns -1. Otherwise, returns the // number of bytes stripped.


context:
space:
mode: