lib_queue.c

Go to the documentation of this file.

/*  *********************************************************************
    *  Broadcom Common Firmware Environment (CFE)
    *  
    *  Queue Management routines        File: lib_queue.c
    *  
    *  Routines to manage doubly-linked queues.
    *  
    *  Author:  Mitch Lichtenberg
    *  
    *********************************************************************  
    *
    *  Copyright 2000,2001,2002,2003
    *  Broadcom Corporation. All rights reserved.
    *  
    *  This software is furnished under license and may be used and 
    *  copied only in accordance with the following terms and 
    *  conditions.  Subject to these conditions, you may download, 
    *  copy, install, use, modify and distribute modified or unmodified 
    *  copies of this software in source and/or binary form.  No title 
    *  or ownership is transferred hereby.
    *  
    *  1) Any source code used, modified or distributed must reproduce 
    *     and retain this copyright notice and list of conditions 
    *     as they appear in the source file.
    *  
    *  2) No right is granted to use any trade name, trademark, or 
    *     logo of Broadcom Corporation.  The "Broadcom Corporation" 
    *     name may not be used to endorse or promote products derived 
    *     from this software without the prior written permission of 
    *     Broadcom Corporation.
    *  
    *  3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR
    *     IMPLIED WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED
    *     WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
    *     PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT 
    *     SHALL BROADCOM BE LIABLE FOR ANY DAMAGES WHATSOEVER, AND IN 
    *     PARTICULAR, BROADCOM SHALL NOT BE LIABLE FOR DIRECT, INDIRECT,
    *     INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
    *     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
    *     GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
    *     BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 
    *     OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 
    *     TORT (INCLUDING NEGLIGENCE OR OTHERWISE), EVEN IF ADVISED OF 
    *     THE POSSIBILITY OF SUCH DAMAGE.
    ********************************************************************* */
 
 
#include "lib_types.h"
#include "lib_queue.h"
 
 
/*  *********************************************************************
    *  Q_ENQUEUE(qb,item)   
    *               
    *  Add item to a queue
    *               
    *  Input Parameters:    
    *      qb - queue block 
    *      item - item to add   
    *               
    *  Return Value:        
    *      Nothing.     
    ********************************************************************* */
 
void q_enqueue(queue_t *qb,queue_t *item)
{
    qb->q_prev->q_next = item;
    item->q_next = qb;
    item->q_prev = qb->q_prev;
    qb->q_prev = item;
}
 
 
/*  *********************************************************************
    *  Q_DEQUEUE(element)   
    *               
    *  Remove an element from the queue
    *                   
    *  Input Parameters:        
    *      element - element to remove  
    *                   
    *  Return Value:            
    *      Nothing.         
    ********************************************************************* */
 
void q_dequeue(queue_t *item)
{
    item->q_prev->q_next = item->q_next;
    item->q_next->q_prev = item->q_prev;
}
 
 
/*  *********************************************************************
    *  Q_DEQNEXT(qb)
    *
    *  Dequeue next element from the specified queue
    * 
    *  Input Parameters:    
    *      qb - queue block 
    *               
    *  Return Value:        
    *      next element, or NULL
    ********************************************************************* */
 
queue_t *q_deqnext(queue_t *qb)
{
    if (qb->q_next == qb) {
    return NULL;
    }
 
    qb = qb->q_next;
 
    qb->q_prev->q_next = qb->q_next;
    qb->q_next->q_prev = qb->q_prev;
 
    return qb;
}
 
 
/*  *********************************************************************
    *  Q_MAP(qb)
    * 
    *  "Map" a queue, calling the specified function for each
    *  element in the queue
    *  
    *  If the function returns nonzero, q_map will terminate.
    *  
    *  Input Parameters:        
    *      qb - queue block     
    *      fn - function pointer    
    *      a,b - parameters for the function
    *  
    *  Return Value:    
    *      return value from function, or zero if entire queue 
    *      was mapped.  
    ********************************************************************* */
 
int q_map(queue_t *qb, int (*func)(queue_t *,unsigned int,unsigned int),
      unsigned int a,unsigned int b)
{
    queue_t *qe;
    queue_t *nextq;
    int res;
 
    qe = qb;
 
    qe = qb->q_next;
 
    while (qe != qb) {
    nextq = qe->q_next;
    if ((res = (*func)(qe,a,b))) return res;
    qe = nextq;
    }
 
    return 0;
}
 
 
 
 
 
/*  *********************************************************************
    *  Q_COUNT(qb)                          *
    *                                   *
    *  Counts the elements on a queue (not interlocked)         *
    *                                   *
    *  Input Parameters:                        *
    *      qb - queue block                     *
    *                                   *
    *  Return Value:                            *
    *      number of elements                       *
    ********************************************************************* */
int q_count(queue_t *qb)
{
    queue_t *qe;
    int res = 0;
 
    qe = qb;
 
    while (qe->q_next != qb) {
    qe = qe->q_next;
    res++;
    }
 
    return res;
}
 
 
 
 
/*  *********************************************************************
    *  Q_FIND(qb,item)
    *  
    *  Determines if a particular element is on a queue.
    *               
    *  Input Parameters:    
    *      qb - queue block
    *      item - queue element 
    *       
    *  Return Value:
    *      0 - not on queue        
    *      >0 - position on queue  
    ********************************************************************* */
int q_find(queue_t *qb,queue_t *item)
{
    queue_t *q;
    int res = 1;
 
    q = qb->q_next;
 
    while (q != item) {
    if (q == qb) return 0;
    q = q->q_next;
    res++;
    }
 
    return res;
}