1 /*
2 * Copyright (c) 2012-2013, Texas Instruments Incorporated
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 * */
32 /*
33 * ======== List.c ========
34 * Implementation of functions specified in List.xdc.
35 */
37 #include <xdc/std.h>
39 #include <ti/sysbios/hal/Hwi.h>
41 #include "package/internal/List.xdc.h"
43 /*
44 *************************************************************************
45 * Instance functions
46 *************************************************************************
47 */
49 /*
50 * ======== List_Instance_init ========
51 */
52 Void List_Instance_init(List_Object *obj, const List_Params *params)
53 {
54 obj->elem.next = obj->elem.prev = &(obj->elem);
55 }
57 /*
58 * ======== List_empty ========
59 * No thread-safety is needed since this API does not modify
60 * any of the contents.
61 */
62 Bool List_empty(List_Object *obj)
63 {
64 return (obj->elem.next == &(obj->elem));
65 }
67 /*
68 * ======== List_get ========
69 */
70 Ptr List_get(List_Object *obj)
71 {
72 List_Elem *elem;
73 UInt key;
75 key = Hwi_disable();
77 elem = List_dequeue(obj);
79 Hwi_restore(key);
81 return (elem);
82 }
84 /*
85 * ======== List_put ========
86 */
87 Void List_put(List_Object *obj, List_Elem *elem)
88 {
89 UInt key;
91 key = Hwi_disable();
93 List_enqueue(obj, elem);
95 Hwi_restore(key);
96 }
98 /*
99 * ======== List_putHead ========
100 */
101 Void List_putHead(List_Object *obj, List_Elem *elem)
102 {
103 UInt key;
105 key = Hwi_disable();
107 List_enqueueHead(obj, elem);
109 Hwi_restore(key);
110 }
112 /*
113 * ======== List_insert ========
114 */
115 Void List_insert(List_Object *obj, List_Elem *newElem, List_Elem *curElem)
116 {
117 List_enqueue((List_Object *)curElem, newElem);
118 }
120 /*
121 * ======== List_next ========
122 */
123 Ptr List_next(List_Object *obj, List_Elem *elem)
124 {
125 List_Elem *retElem; /* returned elem */
127 /* elem == NULL -> start at the head */
128 if (elem == NULL) {
129 retElem = obj->elem.next;
130 }
131 else {
132 retElem = elem->next;
133 }
135 if (retElem == (List_Elem *)obj) {
136 retElem = NULL;
137 }
139 return (retElem);
140 }
142 /*
143 * ======== List_prev ========
144 */
145 Ptr List_prev(List_Object *obj, List_Elem *elem)
146 {
147 List_Elem *retElem; /* returned elem */
149 /* elem == NULL -> start at the tail */
150 if (elem == NULL) {
151 retElem = obj->elem.prev;
152 }
153 else {
154 retElem = elem->prev;
155 }
157 if (retElem == (List_Elem *)obj) {
158 retElem = NULL;
159 }
161 return (retElem);
162 }
164 /*
165 * ======== List_remove ========
166 */
167 Void List_remove(List_Object *obj, List_Elem *elem)
168 {
169 elem->prev->next = elem->next;
170 elem->next->prev = elem->prev;
171 }
173 /*
174 * ======== List_dequeue ========
175 */
176 Ptr List_dequeue(List_Object *obj)
177 {
178 List_Elem *elem;
180 elem = obj->elem.next;
182 /* See if the List was empty */
183 if (elem == (List_Elem *)obj) {
184 elem = NULL;
185 }
186 else {
187 obj->elem.next = elem->next;
188 elem->next->prev = &(obj->elem);
189 }
191 return (elem);
192 }
194 /*
195 * ======== List_enqueue ========
196 */
197 Void List_enqueue(List_Object *obj, List_Elem *elem)
198 {
199 elem->next = &(obj->elem);
200 elem->prev = obj->elem.prev;
201 obj->elem.prev->next = elem;
202 obj->elem.prev = elem;
203 }
205 /*
206 * ======== List_enqueueHead ========
207 */
208 Void List_enqueueHead(List_Object *obj, List_Elem *elem)
209 {
210 elem->next = obj->elem.next;
211 elem->prev = &(obj->elem);
212 obj->elem.next->prev = elem;
213 obj->elem.next = elem;
214 }
216 /*
217 *************************************************************************
218 * Module functions
219 *************************************************************************
220 */
222 /*
223 * ======== List_elemClear ========
224 */
226 Void List_elemClear(List_Elem *elem)
227 {
228 elem->next = elem->prev = elem;
229 }