1 files changed, 171 insertions, 0 deletions
diff --git a/sys/mips/include/queue.h b/sys/mips/include/queue.h
new file mode 100644
index 0000000..d992332
--- /dev/null
+++ b/sys/mips/include/queue.h
@@ -0,0 +1,171 @@
+/*-
+ * Copyright (c) 1996-1997, 2001, 2005, Juniper Networks, Inc.
+ * All rights reserved.
+ * Jim Hayes, November 1996
+ *
+ * queue.h - Description of uKernel queues, for the Juniper Kernel
+ *
+ *	JNPR: queue.h,v 1.1 2006/08/07 05:38:57 katta
+ * $FreeBSD$
+ *
+ */
+
+#ifndef __QUEUE_H__
+#define	__QUEUE_H__
+
+/*---------------------------------------------------------------------------
+ * QUEUE MANAGEMENT DOCUMENTATION
+ */
+
+/*
+   --------
+   Q_INIT()
+   --------
+
+   void q_init(void)
+
+   Initialize the queue management system for the microkernel.
+   This initializes the debugging flags and sets up accounting.
+
+   ---------
+   Q_ALLOC()
+   ---------
+
+   queue_t *q_alloc()
+
+   Allocates a queue from kernel memory, and initializes it for you.
+
+   The default initialization provides a queue that is unbounded.
+
+   If you want to be bounded with special features, use q_control
+   after initialization.
+
+   q_alloc() returns NULL in the face of peril or low memory.
+
+   --------
+   Q_FREE()
+   --------
+
+   void *q_free(queue_t *queue_pointer)
+
+   Returns a queue to kernel memory, and frees the queue contents
+   for you using free() and complains (with a traceback) that you
+   tried to kill of a non-empty queue.
+
+   If any threads are waiting on the queue, wake them up.
+
+   -----------
+   Q_CONTROL()
+   -----------
+   void q_control(queue_t *queue_pointer, queue_size_t max_queue_size);
+
+   For now, allows you to limit queue growth.
+
+   ----------------
+   Q_DEQUEUE_WAIT() ** MAY CAUSE THREAD TO BLOCK/CANNOT BE CALLED FROM ISRs **
+   ----------------
+
+   void *q_dequeue_wait(queue_t *queue_pointer, wakeup_mask_t *mask)
+
+   Removes and returns a pointer to the next message in the specified
+   queue.  If the queue is empty, the calling thread goes to sleep
+   until something is queued to the queue.  If this call returns NULL,
+   then an extraordinary event requires this thread's attention--
+   check errno in this case.
+
+   ---------
+   Q_DEQUEUE	 ** CAN BE CALLED FROM ISRs **
+   ---------
+
+   void *q_dequeue(queue_t *queue_pointer)
+
+   Just like q_dequeue_wait(), but instead of blocking, return NULL.
+
+   -----------
+   Q_ENQUEUE()		   ** CAN BE CALLED FROM ISRs **
+   -----------
+
+   boolean q_enqueue(queue_t *queue_pointer, void *element_pointer)
+
+   Add the element to the end of the named queue.  If the add fails
+   because a limit has been reached, return TRUE.  Otherwise return
+   FALSE if everything went OK.
+
+   ----------
+   Q_URGENT()
+   ----------
+
+   boolean q_urgent(queue_t *queue_pointer, void *element_pointer)
+
+   Same as q_enqueue(), except this element will be placed at the top
+   of the queue, and will be picked off at the next q_dequeue_wait()
+   operation.
+
+   --------
+   Q_PEEK()		   ** CAN BE CALLED FROM ISRs **
+   --------
+
+   void *q_peek(queue_t *queue_pointer)
+
+   Returns a pointer to the top element of the queue without actually
+   dequeuing it.  Returns NULL of the queue is empty.
+
+   This routine will never block.
+
+   ----------
+   Q_DELETE()
+   ----------
+
+   void q_delete(queue_t *queue_pointer, void *element_pointer)
+
+   Delete the element_pointer from the queue, if it exists.  This
+   isn't speedy, and isn't meant for tasks requiring performance.
+   It's primary use is to pull something off the queue when you know
+   in the common case that it's gonna be at or near the top of the
+   list.  (I.e. waking a thread from a wake list when extraordinary
+   conditions exist, and you have to pluck it from the middle of the
+   list.)
+
+   This routine does not block or return anything.
+
+   --------
+   Q_SIZE()
+   --------
+
+   queue_size_t q_size(queue_t *queue_pointer)
+
+   Returns the number of elements in the queue.
+
+   ------------
+   Q_MAX_SIZE()
+   ------------
+
+   queue_size_t q_max_size(queue_t *queue_pointer);
+
+   Returns the maximum size of this queue, or 0 if this queue is
+   unbounded.
+
+*/
+
+/*-------------------------------------------------------------------------
+ * Basic queue management structures.
+ */
+
+/*
+ * Typedefs
+ */
+
+typedef u_int32_t queue_size_t;
+
+/*
+ * Prototypes
+ */
+
+void		 q_init(void);
+queue_t		*q_alloc(void);
+void		*q_peek(queue_t *queue);
+void		*q_dequeue(queue_t *queue);
+boolean		 q_enqueue(queue_t *queue, void *item);
+boolean		 q_urgent(queue_t *queue, void *item);
+
+#endif /* __QUEUE_H__ */