Print this page
5042 stop using deprecated atomic functions
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/xge/drv/xge_osdep.h
+++ new/usr/src/uts/common/io/xge/drv/xge_osdep.h
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.
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 22 /*
23 23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 24 * Use is subject to license terms.
25 25 */
26 26
27 27 /*
28 28 * Copyright (c) 2002-2005 Neterion, Inc.
29 29 * All right Reserved.
30 30 *
31 31 * FileName : xge_osdep.h
32 32 *
33 33 * Description: OSPAL - Solaris
34 34 *
35 35 */
36 36
37 37 #ifndef _SYS_XGE_OSDEP_H
38 38 #define _SYS_XGE_OSDEP_H
39 39
40 40 #include <sys/ddi.h>
41 41 #include <sys/sunddi.h>
42 42 #include <sys/varargs.h>
43 43 #include <sys/atomic.h>
44 44 #include <sys/policy.h>
45 45 #include <sys/int_fmtio.h>
46 46 #include <sys/thread.h>
47 47 #include <sys/cpuvar.h>
48 48
49 49 #include <inet/common.h>
50 50 #include <inet/ip.h>
51 51 #include <inet/mi.h>
52 52 #include <inet/nd.h>
53 53
54 54 #ifdef __cplusplus
55 55 extern "C" {
56 56 #endif
57 57
58 58 /* ------------------------- includes and defines ------------------------- */
59 59
60 60 #define XGE_HAL_TX_MULTI_POST_IRQ 1
61 61 #define XGE_HAL_TX_MULTI_RESERVE_IRQ 1
62 62 #define XGE_HAL_TX_MULTI_FREE_IRQ 1
63 63 #define XGE_HAL_DMA_DTR_CONSISTENT 1
64 64 #define XGE_HAL_DMA_STATS_STREAMING 1
65 65
66 66 #if defined(__sparc)
67 67 #define XGE_OS_DMA_REQUIRES_SYNC 1
68 68 #endif
69 69
70 70 #define XGE_HAL_ALIGN_XMIT 1
71 71
72 72 #ifdef _BIG_ENDIAN
73 73 #define XGE_OS_HOST_BIG_ENDIAN 1
74 74 #else
75 75 #define XGE_OS_HOST_LITTLE_ENDIAN 1
76 76 #endif
77 77
78 78 #if defined(__sparc)
79 79 #define XGE_OS_HOST_PAGE_SIZE 8192
80 80 #else
81 81 #define XGE_OS_HOST_PAGE_SIZE 4096
82 82 #endif
83 83
84 84 #if defined(_LP64)
85 85 #define XGE_OS_PLATFORM_64BIT 1
86 86 #else
87 87 #define XGE_OS_PLATFORM_32BIT 1
88 88 #endif
89 89
90 90 #define XGE_OS_HAS_SNPRINTF 1
91 91
92 92 /* LRO defines */
93 93 #define XGE_LL_IP_FAST_CSUM(hdr, len) 0 /* ip_ocsum(hdr, len>>1, 0); */
94 94
95 95 /* ---------------------- fixed size primitive types ----------------------- */
96 96
97 97 #define u8 uint8_t
98 98 #define u16 uint16_t
99 99 #define u32 uint32_t
100 100 #define u64 uint64_t
101 101 typedef u64 dma_addr_t;
102 102 #define ulong_t ulong_t
103 103 #define ptrdiff_t ptrdiff_t
104 104 typedef kmutex_t spinlock_t;
105 105 typedef dev_info_t *pci_dev_h;
106 106 typedef ddi_acc_handle_t pci_reg_h;
107 107 typedef ddi_acc_handle_t pci_cfg_h;
108 108 typedef uint_t pci_irq_h;
109 109 typedef ddi_dma_handle_t pci_dma_h;
110 110 typedef ddi_acc_handle_t pci_dma_acc_h;
111 111
112 112 /* LRO types */
113 113 #define OS_NETSTACK_BUF mblk_t *
114 114 #define OS_LL_HEADER uint8_t *
115 115 #define OS_IP_HEADER uint8_t *
116 116 #define OS_TL_HEADER uint8_t *
117 117
118 118 /* -------------------------- "libc" functionality ------------------------- */
119 119
120 120 #define xge_os_strlcpy (void) strlcpy
121 121 #define xge_os_strlen strlen
122 122 #define xge_os_snprintf snprintf
123 123 #define xge_os_memzero(addr, size) bzero(addr, size)
124 124 #define xge_os_memcpy(dst, src, size) bcopy(src, dst, size)
125 125 #define xge_os_memcmp(src1, src2, size) bcmp(src1, src2, size)
126 126 #define xge_os_ntohl ntohl
127 127 #define xge_os_htons htons
128 128 #define xge_os_ntohs ntohs
129 129
130 130 #ifdef __GNUC__
131 131 #define xge_os_printf(fmt...) cmn_err(CE_CONT, fmt)
132 132 #define xge_os_sprintf(buf, fmt...) strlen(sprintf(buf, fmt))
133 133 #else
134 134 #define xge_os_vaprintf(fmt) { \
135 135 va_list va; \
136 136 va_start(va, fmt); \
137 137 vcmn_err(CE_CONT, fmt, va); \
138 138 va_end(va); \
139 139 }
140 140
141 141 static inline void xge_os_printf(char *fmt, ...) {
142 142 xge_os_vaprintf(fmt);
143 143 }
144 144
145 145 #define xge_os_vasprintf(buf, fmt) { \
146 146 va_list va; \
147 147 va_start(va, fmt); \
148 148 (void) vsprintf(buf, fmt, va); \
149 149 va_end(va); \
150 150 }
151 151
152 152 static inline int xge_os_sprintf(char *buf, char *fmt, ...) {
153 153 xge_os_vasprintf(buf, fmt);
154 154 return (strlen(buf));
155 155 }
156 156 #endif
157 157
158 158 #define xge_os_timestamp(buf) { \
159 159 todinfo_t todinfo = utc_to_tod(ddi_get_time()); \
160 160 (void) xge_os_sprintf(buf, "%02d/%02d/%02d.%02d:%02d:%02d: ", \
161 161 todinfo.tod_day, todinfo.tod_month, \
162 162 (1970 + todinfo.tod_year - 70), \
163 163 todinfo.tod_hour, todinfo.tod_min, todinfo.tod_sec); \
164 164 }
165 165
166 166 #define xge_os_println xge_os_printf
167 167
168 168 /* -------------------- synchronization primitives ------------------------- */
169 169
170 170 #define xge_os_spin_lock_init(lockp, ctxh) \
171 171 mutex_init(lockp, NULL, MUTEX_DRIVER, NULL)
172 172 #define xge_os_spin_lock_init_irq(lockp, irqh) \
173 173 mutex_init(lockp, NULL, MUTEX_DRIVER, DDI_INTR_PRI(irqh))
174 174 #define xge_os_spin_lock_destroy(lockp, cthx) \
175 175 (cthx = cthx, mutex_destroy(lockp))
176 176 #define xge_os_spin_lock_destroy_irq(lockp, cthx) \
177 177 (cthx = cthx, mutex_destroy(lockp))
178 178 #define xge_os_spin_lock(lockp) mutex_enter(lockp)
179 179 #define xge_os_spin_unlock(lockp) mutex_exit(lockp)
180 180 #define xge_os_spin_lock_irq(lockp, flags) (flags = flags, mutex_enter(lockp))
|
↓ open down ↓ |
180 lines elided |
↑ open up ↑ |
181 181 #define xge_os_spin_unlock_irq(lockp, flags) mutex_exit(lockp)
182 182
183 183 /* x86 arch will never re-order writes, Sparc can */
184 184 #define xge_os_wmb() membar_producer()
185 185
186 186 #define xge_os_udelay(us) drv_usecwait(us)
187 187 #define xge_os_mdelay(ms) drv_usecwait(ms * 1000)
188 188
189 189 #define xge_os_cmpxchg(targetp, cmp, newval) \
190 190 sizeof (*(targetp)) == 4 ? \
191 - cas32((uint32_t *)targetp, cmp, newval) : \
192 - cas64((uint64_t *)targetp, cmp, newval)
191 + atomic_cas_32((uint32_t *)targetp, cmp, newval) : \
192 + atomic_cas_64((uint64_t *)targetp, cmp, newval)
193 193
194 194 /* ------------------------- misc primitives ------------------------------- */
195 195
196 196 #define xge_os_unlikely(x) (x)
197 197 #define xge_os_prefetch(a) (a = a)
198 198 #define xge_os_prefetchw
199 199 #ifdef __GNUC__
200 200 #define xge_os_bug(fmt...) cmn_err(CE_PANIC, fmt)
201 201 #else
202 202 static inline void xge_os_bug(char *fmt, ...) {
203 203 va_list ap;
204 204
205 205 va_start(ap, fmt);
206 206 vcmn_err(CE_PANIC, fmt, ap);
207 207 va_end(ap);
208 208 }
209 209 #endif
210 210
211 211 /* -------------------------- compiler stuffs ------------------------------ */
212 212
213 213 #if defined(__i386)
214 214 #define __xge_os_cacheline_size 64 /* L1-cache line size: x86_64 */
215 215 #else
216 216 #define __xge_os_cacheline_size 64 /* L1-cache line size: sparcv9 */
217 217 #endif
218 218
219 219 #ifdef __GNUC__
220 220 #define __xge_os_attr_cacheline_aligned \
221 221 __attribute__((__aligned__(__xge_os_cacheline_size)))
222 222 #else
223 223 #define __xge_os_attr_cacheline_aligned
224 224 #endif
225 225
226 226 /* ---------------------- memory primitives -------------------------------- */
227 227
228 228 static inline void *__xge_os_malloc(pci_dev_h pdev, unsigned long size,
229 229 char *file, int line)
230 230 {
231 231 void *vaddr = kmem_alloc(size, KM_SLEEP);
232 232
233 233 XGE_OS_MEMORY_CHECK_MALLOC(vaddr, size, file, line);
234 234 return (vaddr);
235 235 }
236 236
237 237 static inline void xge_os_free(pci_dev_h pdev, const void *vaddr,
238 238 unsigned long size)
239 239 {
240 240 XGE_OS_MEMORY_CHECK_FREE(vaddr, size);
241 241 kmem_free((void*)vaddr, size);
242 242 }
243 243
244 244 #define xge_os_malloc(pdev, size) \
245 245 __xge_os_malloc(pdev, size, __FILE__, __LINE__)
246 246
247 247 static inline void *__xge_os_dma_malloc(pci_dev_h pdev, unsigned long size,
248 248 int dma_flags, pci_dma_h *p_dmah, pci_dma_acc_h *p_dma_acch, char *file,
249 249 int line)
250 250 {
251 251 void *vaddr;
252 252 int ret;
253 253 size_t real_size;
254 254 extern ddi_device_acc_attr_t *p_xge_dev_attr;
255 255 extern struct ddi_dma_attr *p_hal_dma_attr;
256 256
257 257 ret = ddi_dma_alloc_handle(pdev, p_hal_dma_attr,
258 258 DDI_DMA_DONTWAIT, 0, p_dmah);
259 259 if (ret != DDI_SUCCESS) {
260 260 return (NULL);
261 261 }
262 262
263 263 ret = ddi_dma_mem_alloc(*p_dmah, size, p_xge_dev_attr,
264 264 (dma_flags & XGE_OS_DMA_CONSISTENT ?
265 265 DDI_DMA_CONSISTENT : DDI_DMA_STREAMING), DDI_DMA_DONTWAIT, 0,
266 266 (caddr_t *)&vaddr, &real_size, p_dma_acch);
267 267 if (ret != DDI_SUCCESS) {
268 268 ddi_dma_free_handle(p_dmah);
269 269 return (NULL);
270 270 }
271 271
272 272 if (size > real_size) {
273 273 ddi_dma_mem_free(p_dma_acch);
274 274 ddi_dma_free_handle(p_dmah);
275 275 return (NULL);
276 276 }
277 277
278 278 XGE_OS_MEMORY_CHECK_MALLOC(vaddr, size, file, line);
279 279
280 280 return (vaddr);
281 281 }
282 282
283 283 #define xge_os_dma_malloc(pdev, size, dma_flags, p_dmah, p_dma_acch) \
284 284 __xge_os_dma_malloc(pdev, size, dma_flags, p_dmah, p_dma_acch, \
285 285 __FILE__, __LINE__)
286 286
287 287 static inline void xge_os_dma_free(pci_dev_h pdev, const void *vaddr, int size,
288 288 pci_dma_acc_h *p_dma_acch, pci_dma_h *p_dmah)
289 289 {
290 290 XGE_OS_MEMORY_CHECK_FREE(vaddr, 0);
291 291 ddi_dma_mem_free(p_dma_acch);
292 292 ddi_dma_free_handle(p_dmah);
293 293 }
294 294
295 295
296 296 /* --------------------------- pci primitives ------------------------------ */
297 297
298 298 #define xge_os_pci_read8(pdev, cfgh, where, val) \
299 299 (*(val) = pci_config_get8(cfgh, where))
300 300
301 301 #define xge_os_pci_write8(pdev, cfgh, where, val) \
302 302 pci_config_put8(cfgh, where, val)
303 303
304 304 #define xge_os_pci_read16(pdev, cfgh, where, val) \
305 305 (*(val) = pci_config_get16(cfgh, where))
306 306
307 307 #define xge_os_pci_write16(pdev, cfgh, where, val) \
308 308 pci_config_put16(cfgh, where, val)
309 309
310 310 #define xge_os_pci_read32(pdev, cfgh, where, val) \
311 311 (*(val) = pci_config_get32(cfgh, where))
312 312
313 313 #define xge_os_pci_write32(pdev, cfgh, where, val) \
314 314 pci_config_put32(cfgh, where, val)
315 315
316 316 /* --------------------------- io primitives ------------------------------- */
317 317
318 318 #define xge_os_pio_mem_read8(pdev, regh, addr) \
319 319 (ddi_get8(regh, (uint8_t *)(addr)))
320 320
321 321 #define xge_os_pio_mem_write8(pdev, regh, val, addr) \
322 322 (ddi_put8(regh, (uint8_t *)(addr), val))
323 323
324 324 #define xge_os_pio_mem_read16(pdev, regh, addr) \
325 325 (ddi_get16(regh, (uint16_t *)(addr)))
326 326
327 327 #define xge_os_pio_mem_write16(pdev, regh, val, addr) \
328 328 (ddi_put16(regh, (uint16_t *)(addr), val))
329 329
330 330 #define xge_os_pio_mem_read32(pdev, regh, addr) \
331 331 (ddi_get32(regh, (uint32_t *)(addr)))
332 332
333 333 #define xge_os_pio_mem_write32(pdev, regh, val, addr) \
334 334 (ddi_put32(regh, (uint32_t *)(addr), val))
335 335
336 336 #define xge_os_pio_mem_read64(pdev, regh, addr) \
337 337 (ddi_get64(regh, (uint64_t *)(addr)))
338 338
339 339 #define xge_os_pio_mem_write64(pdev, regh, val, addr) \
340 340 (ddi_put64(regh, (uint64_t *)(addr), val))
341 341
342 342 #define xge_os_flush_bridge xge_os_pio_mem_read64
343 343
344 344 /* --------------------------- dma primitives ----------------------------- */
345 345
346 346 #define XGE_OS_DMA_DIR_TODEVICE DDI_DMA_SYNC_FORDEV
347 347 #define XGE_OS_DMA_DIR_FROMDEVICE DDI_DMA_SYNC_FORKERNEL
348 348 #define XGE_OS_DMA_DIR_BIDIRECTIONAL -1
349 349 #if defined(__x86)
350 350 #define XGE_OS_DMA_USES_IOMMU 0
351 351 #else
352 352 #define XGE_OS_DMA_USES_IOMMU 1
353 353 #endif
354 354
355 355 #define XGE_OS_INVALID_DMA_ADDR ((dma_addr_t)0)
356 356
357 357 static inline dma_addr_t xge_os_dma_map(pci_dev_h pdev, pci_dma_h dmah,
358 358 void *vaddr, size_t size, int dir, int dma_flags) {
359 359 int ret;
360 360 uint_t flags;
361 361 uint_t ncookies;
362 362 ddi_dma_cookie_t dma_cookie;
363 363
364 364 switch (dir) {
365 365 case XGE_OS_DMA_DIR_TODEVICE:
366 366 flags = DDI_DMA_WRITE;
367 367 break;
368 368 case XGE_OS_DMA_DIR_FROMDEVICE:
369 369 flags = DDI_DMA_READ;
370 370 break;
371 371 case XGE_OS_DMA_DIR_BIDIRECTIONAL:
372 372 flags = DDI_DMA_RDWR;
373 373 break;
374 374 default:
375 375 return (0);
376 376 }
377 377
378 378 flags |= (dma_flags & XGE_OS_DMA_CONSISTENT) ?
379 379 DDI_DMA_CONSISTENT : DDI_DMA_STREAMING;
380 380
381 381 ret = ddi_dma_addr_bind_handle(dmah, NULL, vaddr, size, flags,
382 382 DDI_DMA_SLEEP, 0, &dma_cookie, &ncookies);
383 383 if (ret != DDI_SUCCESS) {
384 384 return (0);
385 385 }
386 386
387 387 if (ncookies != 1 || dma_cookie.dmac_size < size) {
388 388 (void) ddi_dma_unbind_handle(dmah);
389 389 return (0);
390 390 }
391 391
392 392 return (dma_cookie.dmac_laddress);
393 393 }
394 394
395 395 static inline void xge_os_dma_unmap(pci_dev_h pdev, pci_dma_h dmah,
396 396 dma_addr_t dma_addr, size_t size, int dir)
397 397 {
398 398 (void) ddi_dma_unbind_handle(dmah);
399 399 }
400 400
401 401 static inline void xge_os_dma_sync(pci_dev_h pdev, pci_dma_h dmah,
402 402 dma_addr_t dma_addr, u64 dma_offset, size_t length, int dir)
403 403 {
404 404 (void) ddi_dma_sync(dmah, dma_offset, length, dir);
405 405 }
406 406
407 407 #ifdef __cplusplus
408 408 }
409 409 #endif
410 410
411 411 #endif /* _SYS_XGE_OSDEP_H */
|
↓ open down ↓ |
209 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX