Print this page
NEX-1890 update oce from source provided by Emulex
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/fibre-channel/fca/oce/oce_utils.c
+++ new/usr/src/uts/common/io/fibre-channel/fca/oce/oce_utils.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
|
↓ open down ↓ |
11 lines elided |
↑ open up ↑ |
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 -/* Copyright © 2003-2011 Emulex. All rights reserved. */
22 +/*
23 + * Copyright (c) 2009-2012 Emulex. All rights reserved.
24 + * Use is subject to license terms.
25 + */
23 26
27 +
28 +
24 29 /*
25 30 * Source file containing the implementation of the driver
26 31 * helper functions
27 32 */
28 33
29 34 #include <oce_impl.h>
30 35
31 -static void oce_list_del_node(OCE_LIST_NODE_T *prev_node,
32 - OCE_LIST_NODE_T *next_node);
33 -static void oce_list_remove(OCE_LIST_NODE_T *list_node);
34 -static void oce_list_insert_node(OCE_LIST_NODE_T *list_node,
35 - OCE_LIST_NODE_T *prev_node, OCE_LIST_NODE_T *next_node);
36 36 /*
37 37 * function to breakup a block of memory into pages and return the address
38 38 * in an array
39 39 *
40 40 * dbuf - pointer to structure describing DMA-able memory
41 41 * pa_list - [OUT] pointer to an array to return the PA of pages
42 42 * list_size - number of entries in pa_list
43 43 */
44 44 void
45 45 oce_page_list(oce_dma_buf_t *dbuf,
46 46 struct phys_addr *pa_list, int list_size)
47 47 {
48 48 int i = 0;
49 49 uint64_t paddr = 0;
50 50
51 51 ASSERT(dbuf != NULL);
52 52 ASSERT(pa_list != NULL);
53 53
54 - paddr = DBUF_PA(dbuf);
54 + paddr = DBUF_PA(*dbuf);
55 55 for (i = 0; i < list_size; i++) {
56 56 pa_list[i].lo = ADDR_LO(paddr);
57 57 pa_list[i].hi = ADDR_HI(paddr);
58 58 paddr += PAGE_4K;
59 59 }
60 60 } /* oce_page_list */
61 61
62 62 void
63 -oce_list_link_init(OCE_LIST_NODE_T *list_node)
64 -{
65 - list_node->next = NULL;
66 - list_node->prev = NULL;
67 -}
68 -
69 -static inline void
70 -oce_list_insert_node(OCE_LIST_NODE_T *list_node, OCE_LIST_NODE_T *prev_node,
71 - OCE_LIST_NODE_T *next_node)
72 -{
73 - next_node->prev = list_node;
74 - list_node->next = next_node;
75 - list_node->prev = prev_node;
76 - prev_node->next = list_node;
77 -}
78 -
79 -static inline void
80 -oce_list_del_node(OCE_LIST_NODE_T *prev_node, OCE_LIST_NODE_T *next_node)
81 -{
82 - next_node->prev = prev_node;
83 - prev_node->next = next_node;
84 -}
85 -
86 -static inline void
87 -oce_list_remove(OCE_LIST_NODE_T *list_node)
88 -{
89 - oce_list_del_node(list_node->prev, list_node->next);
90 - list_node->next = list_node->prev = NULL;
91 -}
92 -
93 -void
94 -oce_list_create(OCE_LIST_T *list_hdr, void *arg)
95 -{
96 - list_hdr->head.next = list_hdr->head.prev = &list_hdr->head;
97 - mutex_init(&list_hdr->list_lock, NULL, MUTEX_DRIVER, arg);
98 - list_hdr->nitems = 0;
99 -}
100 -
101 -void
102 -oce_list_destroy(OCE_LIST_T *list_hdr)
103 -{
104 - ASSERT(list_hdr->nitems == 0);
105 - list_hdr->head.next = list_hdr->head.prev = NULL;
106 - mutex_destroy(&list_hdr->list_lock);
107 -
108 -}
109 -
110 -void
111 -oce_list_insert_tail(OCE_LIST_T *list_hdr, OCE_LIST_NODE_T *list_node)
112 -{
113 - OCE_LIST_NODE_T *head = &list_hdr->head;
114 -
115 - ASSERT(list_hdr != NULL);
116 - ASSERT(list_node != NULL);
117 -
118 - mutex_enter(&list_hdr->list_lock);
119 - oce_list_insert_node(list_node, head->prev, head);
120 - list_hdr->nitems++;
121 - mutex_exit(&list_hdr->list_lock);
122 -}
123 -
124 -void
125 -oce_list_insert_head(OCE_LIST_T *list_hdr, OCE_LIST_NODE_T *list_node)
126 -{
127 - OCE_LIST_NODE_T *head = &list_hdr->head;
128 -
129 - ASSERT(list_hdr != NULL);
130 - ASSERT(list_node != NULL);
131 -
132 - mutex_enter(&list_hdr->list_lock);
133 - oce_list_insert_node(list_node, head, head->next);
134 - list_hdr->nitems++;
135 - mutex_exit(&list_hdr->list_lock);
136 -}
137 -
138 -void *
139 -oce_list_remove_tail(OCE_LIST_T *list_hdr)
140 -{
141 - OCE_LIST_NODE_T *list_node;
142 -
143 - if (list_hdr == NULL) {
144 - return (NULL);
145 - }
146 -
147 - mutex_enter(&list_hdr->list_lock);
148 -
149 - if (list_hdr->nitems <= 0) {
150 - mutex_exit(&list_hdr->list_lock);
151 - return (NULL);
152 - }
153 -
154 - list_node = list_hdr->head.prev;
155 - oce_list_remove(list_node);
156 - list_hdr->nitems--;
157 - mutex_exit(&list_hdr->list_lock);
158 - return (list_node);
159 -}
160 -
161 -void *
162 -oce_list_remove_head(OCE_LIST_T *list_hdr)
163 -{
164 - OCE_LIST_NODE_T *list_node;
165 -
166 - if (list_hdr == NULL) {
167 - return (NULL);
168 - }
169 -
170 - mutex_enter(&list_hdr->list_lock);
171 -
172 - if (list_hdr->nitems <= 0) {
173 - mutex_exit(&list_hdr->list_lock);
174 - return (NULL);
175 - }
176 -
177 - list_node = list_hdr->head.next;
178 -
179 - if (list_node != NULL) {
180 - oce_list_remove(list_node);
181 - list_hdr->nitems--;
182 - }
183 -
184 - mutex_exit(&list_hdr->list_lock);
185 - return (list_node);
186 -}
187 -
188 -boolean_t
189 -oce_list_is_empty(OCE_LIST_T *list_hdr)
190 -{
191 - if (list_hdr == NULL)
192 - return (B_TRUE);
193 - else
194 - return (list_hdr->nitems <= 0);
195 -}
196 -
197 -int
198 -oce_list_items_avail(OCE_LIST_T *list_hdr)
199 -{
200 - if (list_hdr == NULL)
201 - return (0);
202 - else
203 - return (list_hdr->nitems);
204 -}
205 -
206 -void
207 -oce_list_remove_node(OCE_LIST_T *list_hdr, OCE_LIST_NODE_T *list_node)
208 -{
209 - mutex_enter(&list_hdr->list_lock);
210 - oce_list_remove(list_node);
211 - mutex_exit(&list_hdr->list_lock);
212 -}
213 -
214 -void
215 63 oce_gen_hkey(char *hkey, int key_size)
216 64 {
217 65 int i;
218 66 int nkeys = key_size/sizeof (uint32_t);
219 67 for (i = 0; i < nkeys; i++) {
220 68 (void) random_get_pseudo_bytes(
221 69 (uint8_t *)&hkey[i * sizeof (uint32_t)],
222 70 sizeof (uint32_t));
223 71 }
224 72 }
225 73
226 74 int
227 75 oce_atomic_reserve(uint32_t *count_p, uint32_t n)
228 76 {
229 77 uint32_t oldval;
230 78 uint32_t newval;
231 79
232 80 /*
233 81 * ATOMICALLY
|
↓ open down ↓ |
9 lines elided |
↑ open up ↑ |
234 82 */
235 83 do {
236 84 oldval = *count_p;
237 85 if (oldval < n)
238 86 return (-1);
239 87 newval = oldval - n;
240 88
241 89 } while (atomic_cas_32(count_p, oldval, newval) != oldval);
242 90
243 91 return (newval);
92 +}
93 +
94 +
95 +/*
96 + * function to insert vtag to packet
97 + *
98 + * mp - mblk pointer
99 + * vlan_tag - tag to be inserted
100 + *
101 + * return none
102 + */
103 +void
104 +oce_insert_vtag(mblk_t *mp, uint16_t vlan_tag)
105 +{
106 + struct ether_vlan_header *evh;
107 + (void) memmove(mp->b_rptr - VTAG_SIZE,
108 + mp->b_rptr, 2 * ETHERADDRL);
109 + mp->b_rptr -= VTAG_SIZE;
110 + evh = (struct ether_vlan_header *)(void *)mp->b_rptr;
111 + evh->ether_tpid = htons(VLAN_TPID);
112 + evh->ether_tci = htons(vlan_tag);
113 +}
114 +
115 +/*
116 + * function to strip vtag from packet
117 + *
118 + * mp - mblk pointer
119 + *
120 + * return none
121 + */
122 +
123 +void
124 +oce_remove_vtag(mblk_t *mp)
125 +{
126 + (void) memmove(mp->b_rptr + VTAG_SIZE, mp->b_rptr,
127 + ETHERADDRL * 2);
128 + mp->b_rptr += VTAG_SIZE;
244 129 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX