Commit | Line | Data |
---|---|---|
a09e091a JB |
1 | /* |
2 | * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany. | |
3 | * | |
4 | * Permission to use, copy, modify, distribute, and sell this software and its | |
5 | * documentation for any purpose is hereby granted without fee, provided that | |
6 | * the above copyright notice appear in all copies and that both that | |
7 | * copyright notice and this permission notice appear in supporting | |
8 | * documentation, and that the name of Thomas Roell not be used in | |
9 | * advertising or publicity pertaining to distribution of the software without | |
10 | * specific, written prior permission. Thomas Roell makes no representations | |
11 | * about the suitability of this software for any purpose. It is provided | |
12 | * "as is" without express or implied warranty. | |
13 | * | |
14 | * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, | |
15 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO | |
16 | * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR | |
17 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, | |
18 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER | |
19 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR | |
20 | * PERFORMANCE OF THIS SOFTWARE. | |
21 | * | |
22 | */ | |
23 | /* | |
24 | * Copyright (c) 1994-2003 by The XFree86 Project, Inc. | |
25 | * | |
26 | * Permission is hereby granted, free of charge, to any person obtaining a | |
27 | * copy of this software and associated documentation files (the "Software"), | |
28 | * to deal in the Software without restriction, including without limitation | |
29 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
30 | * and/or sell copies of the Software, and to permit persons to whom the | |
31 | * Software is furnished to do so, subject to the following conditions: | |
32 | * | |
33 | * The above copyright notice and this permission notice shall be included in | |
34 | * all copies or substantial portions of the Software. | |
35 | * | |
36 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
37 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
38 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
39 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
40 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
41 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
42 | * OTHER DEALINGS IN THE SOFTWARE. | |
43 | * | |
44 | * Except as contained in this notice, the name of the copyright holder(s) | |
45 | * and author(s) shall not be used in advertising or otherwise to promote | |
46 | * the sale, use or other dealings in this Software without prior written | |
47 | * authorization from the copyright holder(s) and author(s). | |
48 | */ | |
49 | ||
50 | #ifndef _COMPILER_H | |
51 | ||
52 | #define _COMPILER_H | |
53 | ||
54 | #if defined(__SUNPRO_C) | |
55 | #define DO_PROTOTYPES | |
56 | #endif | |
57 | ||
58 | /* Map Sun compiler platform defines to gcc-style used in the code */ | |
59 | #if defined(__amd64) && !defined(__amd64__) | |
60 | #define __amd64__ | |
61 | #endif | |
62 | #if defined(__i386) && !defined(__i386__) | |
63 | #define __i386__ | |
64 | #endif | |
65 | #if defined(__sparc) && !defined(__sparc__) | |
66 | #define __sparc__ | |
67 | #endif | |
68 | #if defined(__sparcv9) && !defined(__sparc64__) | |
69 | #define __sparc64__ | |
70 | #endif | |
71 | ||
72 | #ifndef _X_EXPORT | |
73 | #include <X11/Xfuncproto.h> | |
74 | #endif | |
75 | ||
76 | #include <pixman.h> /* for uint*_t types */ | |
77 | ||
78 | /* Allow drivers to use the GCC-supported __inline__ and/or __inline. */ | |
79 | #ifndef __inline__ | |
80 | #if defined(__GNUC__) | |
81 | /* gcc has __inline__ */ | |
82 | #elif defined(__HIGHC__) | |
83 | #define __inline__ _Inline | |
84 | #else | |
85 | #define __inline__ /**/ | |
86 | #endif | |
87 | #endif /* __inline__ */ | |
88 | #ifndef __inline | |
89 | #if defined(__GNUC__) | |
90 | /* gcc has __inline */ | |
91 | #elif defined(__HIGHC__) | |
92 | #define __inline _Inline | |
93 | #else | |
94 | #define __inline /**/ | |
95 | #endif | |
96 | #endif /* __inline */ | |
97 | /* Support gcc's __FUNCTION__ for people using other compilers */ | |
98 | #if !defined(__GNUC__) && !defined(__FUNCTION__) | |
99 | #define __FUNCTION__ __func__ /* C99 */ | |
100 | #endif | |
101 | #if defined(NO_INLINE) || defined(DO_PROTOTYPES) | |
102 | #if !defined(__arm__) | |
103 | #if !defined(__sparc__) && !defined(__sparc) && !defined(__arm32__) && !defined(__nds32__) \ | |
104 | && !(defined(__alpha__) && defined(linux)) \ | |
105 | && !(defined(__ia64__) && defined(linux)) \ | |
106 | ||
107 | extern _X_EXPORT void outb(unsigned short, unsigned char); | |
108 | extern _X_EXPORT void outw(unsigned short, unsigned short); | |
109 | extern _X_EXPORT void outl(unsigned short, unsigned int); | |
110 | extern _X_EXPORT unsigned int inb(unsigned short); | |
111 | extern _X_EXPORT unsigned int inw(unsigned short); | |
112 | extern _X_EXPORT unsigned int inl(unsigned short); | |
113 | ||
114 | #else /* __sparc__, __arm32__, __alpha__, __nds32__ */ | |
115 | extern _X_EXPORT void outb(unsigned long, unsigned char); | |
116 | extern _X_EXPORT void outw(unsigned long, unsigned short); | |
117 | extern _X_EXPORT void outl(unsigned long, unsigned int); | |
118 | extern _X_EXPORT unsigned int inb(unsigned long); | |
119 | extern _X_EXPORT unsigned int inw(unsigned long); | |
120 | extern _X_EXPORT unsigned int inl(unsigned long); | |
121 | ||
122 | #ifdef __SUNPRO_C | |
123 | extern _X_EXPORT unsigned char xf86ReadMmio8 (void *, unsigned long); | |
124 | extern _X_EXPORT unsigned short xf86ReadMmio16Be (void *, unsigned long); | |
125 | extern _X_EXPORT unsigned short xf86ReadMmio16Le (void *, unsigned long); | |
126 | extern _X_EXPORT unsigned int xf86ReadMmio32Be (void *, unsigned long); | |
127 | extern _X_EXPORT unsigned int xf86ReadMmio32Le (void *, unsigned long); | |
128 | extern _X_EXPORT void xf86WriteMmio8 (void *, unsigned long, unsigned int); | |
129 | extern _X_EXPORT void xf86WriteMmio16Be (void *, unsigned long, unsigned int); | |
130 | extern _X_EXPORT void xf86WriteMmio16Le (void *, unsigned long, unsigned int); | |
131 | extern _X_EXPORT void xf86WriteMmio32Be (void *, unsigned long, unsigned int); | |
132 | extern _X_EXPORT void xf86WriteMmio32Le (void *, unsigned long, unsigned int); | |
133 | extern _X_EXPORT void xf86WriteMmio8NB (void *, unsigned long, unsigned int); | |
134 | extern _X_EXPORT void xf86WriteMmio16BeNB (void *, unsigned long, unsigned int); | |
135 | extern _X_EXPORT void xf86WriteMmio16LeNB (void *, unsigned long, unsigned int); | |
136 | extern _X_EXPORT void xf86WriteMmio32BeNB (void *, unsigned long, unsigned int); | |
137 | extern _X_EXPORT void xf86WriteMmio32LeNB (void *, unsigned long, unsigned int); | |
138 | #endif /* _SUNPRO_C */ | |
139 | #endif /* __sparc__, __arm32__, __alpha__, __nds32__ */ | |
140 | #endif /* __arm__ */ | |
141 | ||
142 | #if defined(__powerpc__) && !defined(__OpenBSD__) | |
143 | extern unsigned long ldq_u(unsigned long *); | |
144 | extern unsigned long ldl_u(unsigned int *); | |
145 | extern unsigned long ldw_u(unsigned short *); | |
146 | extern void stq_u(unsigned long, unsigned long *); | |
147 | extern void stl_u(unsigned long, unsigned int *); | |
148 | extern void stw_u(unsigned long, unsigned short *); | |
149 | extern void mem_barrier(void); | |
150 | extern void write_mem_barrier(void); | |
151 | extern void stl_brx(unsigned long, volatile unsigned char *, int); | |
152 | extern void stw_brx(unsigned short, volatile unsigned char *, int); | |
153 | extern unsigned long ldl_brx(volatile unsigned char *, int); | |
154 | extern unsigned short ldw_brx(volatile unsigned char *, int); | |
155 | #endif /* __powerpc__ && !__OpenBSD */ | |
156 | ||
157 | #endif /* NO_INLINE || DO_PROTOTYPES */ | |
158 | ||
159 | #ifndef NO_INLINE | |
160 | #ifdef __GNUC__ | |
161 | #ifdef __i386__ | |
162 | ||
163 | #ifdef __SSE__ | |
164 | #define write_mem_barrier() __asm__ __volatile__ ("sfence" : : : "memory") | |
165 | #else | |
166 | #define write_mem_barrier() __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory") | |
167 | #endif | |
168 | ||
169 | #ifdef __SSE2__ | |
170 | #define mem_barrier() __asm__ __volatile__ ("mfence" : : : "memory") | |
171 | #else | |
172 | #define mem_barrier() __asm__ __volatile__ ("lock; addl $0,0(%%esp)" : : : "memory") | |
173 | #endif | |
174 | ||
175 | #elif defined __alpha__ | |
176 | ||
177 | #define mem_barrier() __asm__ __volatile__ ("mb" : : : "memory") | |
178 | #define write_mem_barrier() __asm__ __volatile__ ("wmb" : : : "memory") | |
179 | ||
180 | #elif defined __amd64__ | |
181 | ||
182 | #define mem_barrier() __asm__ __volatile__ ("mfence" : : : "memory") | |
183 | #define write_mem_barrier() __asm__ __volatile__ ("sfence" : : : "memory") | |
184 | ||
185 | #elif defined __ia64__ | |
186 | ||
187 | #ifndef __INTEL_COMPILER | |
188 | #define mem_barrier() __asm__ __volatile__ ("mf" : : : "memory") | |
189 | #define write_mem_barrier() __asm__ __volatile__ ("mf" : : : "memory") | |
190 | #else | |
191 | #include "ia64intrin.h" | |
192 | #define mem_barrier() __mf() | |
193 | #define write_mem_barrier() __mf() | |
194 | #endif | |
195 | ||
196 | #elif defined __mips__ | |
197 | /* Note: sync instruction requires MIPS II instruction set */ | |
198 | #define mem_barrier() \ | |
199 | __asm__ __volatile__( \ | |
200 | ".set push\n\t" \ | |
201 | ".set noreorder\n\t" \ | |
202 | ".set mips2\n\t" \ | |
203 | "sync\n\t" \ | |
204 | ".set pop" \ | |
205 | : /* no output */ \ | |
206 | : /* no input */ \ | |
207 | : "memory") | |
208 | #define write_mem_barrier() mem_barrier() | |
209 | ||
210 | #elif defined __powerpc__ | |
211 | ||
212 | #if defined(linux) && defined(__powerpc64__) | |
213 | #include <linux/version.h> | |
214 | #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0) | |
215 | #include <asm/memory.h> | |
216 | #endif | |
217 | #endif /* defined(linux) && defined(__powerpc64__) */ | |
218 | ||
219 | #ifndef eieio /* We deal with arch-specific eieio() routines above... */ | |
220 | #define eieio() __asm__ __volatile__ ("eieio" ::: "memory") | |
221 | #endif /* eieio */ | |
222 | #define mem_barrier() eieio() | |
223 | #define write_mem_barrier() eieio() | |
224 | ||
225 | #elif defined __sparc__ | |
226 | ||
227 | #define barrier() __asm__ __volatile__ (".word 0x8143e00a" : : : "memory") | |
228 | #define mem_barrier() /* XXX: nop for now */ | |
229 | #define write_mem_barrier() /* XXX: nop for now */ | |
230 | #endif | |
231 | #endif /* __GNUC__ */ | |
232 | #endif /* NO_INLINE */ | |
233 | ||
234 | #ifndef mem_barrier | |
235 | #define mem_barrier() /* NOP */ | |
236 | #endif | |
237 | ||
238 | #ifndef write_mem_barrier | |
239 | #define write_mem_barrier() /* NOP */ | |
240 | #endif | |
241 | ||
242 | #ifndef NO_INLINE | |
243 | #ifdef __GNUC__ | |
244 | ||
245 | /* Define some packed structures to use with unaligned accesses */ | |
246 | ||
247 | struct __una_u64 { | |
248 | uint64_t x __attribute__ ((packed)); | |
249 | }; | |
250 | struct __una_u32 { | |
251 | uint32_t x __attribute__ ((packed)); | |
252 | }; | |
253 | struct __una_u16 { | |
254 | uint16_t x __attribute__ ((packed)); | |
255 | }; | |
256 | ||
257 | /* Elemental unaligned loads */ | |
258 | ||
259 | static __inline__ uint64_t | |
260 | ldq_u(uint64_t * p) | |
261 | { | |
262 | const struct __una_u64 *ptr = (const struct __una_u64 *) p; | |
263 | ||
264 | return ptr->x; | |
265 | } | |
266 | ||
267 | static __inline__ uint32_t | |
268 | ldl_u(uint32_t * p) | |
269 | { | |
270 | const struct __una_u32 *ptr = (const struct __una_u32 *) p; | |
271 | ||
272 | return ptr->x; | |
273 | } | |
274 | ||
275 | static __inline__ uint16_t | |
276 | ldw_u(uint16_t * p) | |
277 | { | |
278 | const struct __una_u16 *ptr = (const struct __una_u16 *) p; | |
279 | ||
280 | return ptr->x; | |
281 | } | |
282 | ||
283 | /* Elemental unaligned stores */ | |
284 | ||
285 | static __inline__ void | |
286 | stq_u(uint64_t val, uint64_t * p) | |
287 | { | |
288 | struct __una_u64 *ptr = (struct __una_u64 *) p; | |
289 | ||
290 | ptr->x = val; | |
291 | } | |
292 | ||
293 | static __inline__ void | |
294 | stl_u(uint32_t val, uint32_t * p) | |
295 | { | |
296 | struct __una_u32 *ptr = (struct __una_u32 *) p; | |
297 | ||
298 | ptr->x = val; | |
299 | } | |
300 | ||
301 | static __inline__ void | |
302 | stw_u(uint16_t val, uint16_t * p) | |
303 | { | |
304 | struct __una_u16 *ptr = (struct __una_u16 *) p; | |
305 | ||
306 | ptr->x = val; | |
307 | } | |
308 | #else /* !__GNUC__ */ | |
309 | ||
310 | #include <string.h> /* needed for memmove */ | |
311 | ||
312 | static __inline__ uint64_t | |
313 | ldq_u(uint64_t * p) | |
314 | { | |
315 | uint64_t ret; | |
316 | ||
317 | memmove(&ret, p, sizeof(*p)); | |
318 | return ret; | |
319 | } | |
320 | ||
321 | static __inline__ uint32_t | |
322 | ldl_u(uint32_t * p) | |
323 | { | |
324 | uint32_t ret; | |
325 | ||
326 | memmove(&ret, p, sizeof(*p)); | |
327 | return ret; | |
328 | } | |
329 | ||
330 | static __inline__ uint16_t | |
331 | ldw_u(uint16_t * p) | |
332 | { | |
333 | uint16_t ret; | |
334 | ||
335 | memmove(&ret, p, sizeof(*p)); | |
336 | return ret; | |
337 | } | |
338 | ||
339 | static __inline__ void | |
340 | stq_u(uint64_t val, uint64_t * p) | |
341 | { | |
342 | uint64_t tmp = val; | |
343 | ||
344 | memmove(p, &tmp, sizeof(*p)); | |
345 | } | |
346 | ||
347 | static __inline__ void | |
348 | stl_u(uint32_t val, uint32_t * p) | |
349 | { | |
350 | uint32_t tmp = val; | |
351 | ||
352 | memmove(p, &tmp, sizeof(*p)); | |
353 | } | |
354 | ||
355 | static __inline__ void | |
356 | stw_u(uint16_t val, uint16_t * p) | |
357 | { | |
358 | uint16_t tmp = val; | |
359 | ||
360 | memmove(p, &tmp, sizeof(*p)); | |
361 | } | |
362 | ||
363 | #endif /* __GNUC__ */ | |
364 | #endif /* NO_INLINE */ | |
365 | ||
366 | #ifndef NO_INLINE | |
367 | #ifdef __GNUC__ | |
368 | #if (defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)) && (defined(__alpha__)) | |
369 | ||
370 | #ifdef linux | |
371 | /* for Linux on Alpha, we use the LIBC _inx/_outx routines */ | |
372 | /* note that the appropriate setup via "ioperm" needs to be done */ | |
373 | /* *before* any inx/outx is done. */ | |
374 | ||
375 | extern _X_EXPORT void _outb(unsigned char val, unsigned long port); | |
376 | extern _X_EXPORT void _outw(unsigned short val, unsigned long port); | |
377 | extern _X_EXPORT void _outl(unsigned int val, unsigned long port); | |
378 | extern _X_EXPORT unsigned int _inb(unsigned long port); | |
379 | extern _X_EXPORT unsigned int _inw(unsigned long port); | |
380 | extern _X_EXPORT unsigned int _inl(unsigned long port); | |
381 | ||
382 | static __inline__ void | |
383 | outb(unsigned long port, unsigned char val) | |
384 | { | |
385 | _outb(val, port); | |
386 | } | |
387 | ||
388 | static __inline__ void | |
389 | outw(unsigned long port, unsigned short val) | |
390 | { | |
391 | _outw(val, port); | |
392 | } | |
393 | ||
394 | static __inline__ void | |
395 | outl(unsigned long port, unsigned int val) | |
396 | { | |
397 | _outl(val, port); | |
398 | } | |
399 | ||
400 | static __inline__ unsigned int | |
401 | inb(unsigned long port) | |
402 | { | |
403 | return _inb(port); | |
404 | } | |
405 | ||
406 | static __inline__ unsigned int | |
407 | inw(unsigned long port) | |
408 | { | |
409 | return _inw(port); | |
410 | } | |
411 | ||
412 | static __inline__ unsigned int | |
413 | inl(unsigned long port) | |
414 | { | |
415 | return _inl(port); | |
416 | } | |
417 | ||
418 | #endif /* linux */ | |
419 | ||
420 | #if (defined(__FreeBSD__) || defined(__OpenBSD__)) \ | |
421 | && !defined(DO_PROTOTYPES) | |
422 | ||
423 | /* for FreeBSD and OpenBSD on Alpha, we use the libio (resp. libalpha) */ | |
424 | /* inx/outx routines */ | |
425 | /* note that the appropriate setup via "ioperm" needs to be done */ | |
426 | /* *before* any inx/outx is done. */ | |
427 | ||
428 | extern _X_EXPORT void outb(unsigned int port, unsigned char val); | |
429 | extern _X_EXPORT void outw(unsigned int port, unsigned short val); | |
430 | extern _X_EXPORT void outl(unsigned int port, unsigned int val); | |
431 | extern _X_EXPORT unsigned char inb(unsigned int port); | |
432 | extern _X_EXPORT unsigned short inw(unsigned int port); | |
433 | extern _X_EXPORT unsigned int inl(unsigned int port); | |
434 | ||
435 | #endif /* (__FreeBSD__ || __OpenBSD__ ) && !DO_PROTOTYPES */ | |
436 | ||
437 | #if defined(__NetBSD__) | |
438 | #include <machine/pio.h> | |
439 | #endif /* __NetBSD__ */ | |
440 | ||
441 | #elif (defined(linux) || defined(__FreeBSD__)) && defined(__amd64__) | |
442 | ||
443 | #include <inttypes.h> | |
444 | ||
445 | static __inline__ void | |
446 | outb(unsigned short port, unsigned char val) | |
447 | { | |
448 | __asm__ __volatile__("outb %0,%1"::"a"(val), "d"(port)); | |
449 | } | |
450 | ||
451 | static __inline__ void | |
452 | outw(unsigned short port, unsigned short val) | |
453 | { | |
454 | __asm__ __volatile__("outw %0,%1"::"a"(val), "d"(port)); | |
455 | } | |
456 | ||
457 | static __inline__ void | |
458 | outl(unsigned short port, unsigned int val) | |
459 | { | |
460 | __asm__ __volatile__("outl %0,%1"::"a"(val), "d"(port)); | |
461 | } | |
462 | ||
463 | static __inline__ unsigned int | |
464 | inb(unsigned short port) | |
465 | { | |
466 | unsigned char ret; | |
467 | __asm__ __volatile__("inb %1,%0":"=a"(ret):"d"(port)); | |
468 | ||
469 | return ret; | |
470 | } | |
471 | ||
472 | static __inline__ unsigned int | |
473 | inw(unsigned short port) | |
474 | { | |
475 | unsigned short ret; | |
476 | __asm__ __volatile__("inw %1,%0":"=a"(ret):"d"(port)); | |
477 | ||
478 | return ret; | |
479 | } | |
480 | ||
481 | static __inline__ unsigned int | |
482 | inl(unsigned short port) | |
483 | { | |
484 | unsigned int ret; | |
485 | __asm__ __volatile__("inl %1,%0":"=a"(ret):"d"(port)); | |
486 | ||
487 | return ret; | |
488 | } | |
489 | ||
490 | #elif (defined(linux) || defined(sun) || defined(__OpenBSD__) || defined(__FreeBSD__)) && defined(__sparc__) | |
491 | ||
492 | #ifndef ASI_PL | |
493 | #define ASI_PL 0x88 | |
494 | #endif | |
495 | ||
496 | static __inline__ void | |
497 | outb(unsigned long port, unsigned char val) | |
498 | { | |
499 | __asm__ __volatile__("stba %0, [%1] %2": /* No outputs */ | |
500 | :"r"(val), "r"(port), "i"(ASI_PL)); | |
501 | ||
502 | barrier(); | |
503 | } | |
504 | ||
505 | static __inline__ void | |
506 | outw(unsigned long port, unsigned short val) | |
507 | { | |
508 | __asm__ __volatile__("stha %0, [%1] %2": /* No outputs */ | |
509 | :"r"(val), "r"(port), "i"(ASI_PL)); | |
510 | ||
511 | barrier(); | |
512 | } | |
513 | ||
514 | static __inline__ void | |
515 | outl(unsigned long port, unsigned int val) | |
516 | { | |
517 | __asm__ __volatile__("sta %0, [%1] %2": /* No outputs */ | |
518 | :"r"(val), "r"(port), "i"(ASI_PL)); | |
519 | ||
520 | barrier(); | |
521 | } | |
522 | ||
523 | static __inline__ unsigned int | |
524 | inb(unsigned long port) | |
525 | { | |
526 | unsigned int ret; | |
527 | __asm__ __volatile__("lduba [%1] %2, %0":"=r"(ret) | |
528 | :"r"(port), "i"(ASI_PL)); | |
529 | ||
530 | return ret; | |
531 | } | |
532 | ||
533 | static __inline__ unsigned int | |
534 | inw(unsigned long port) | |
535 | { | |
536 | unsigned int ret; | |
537 | __asm__ __volatile__("lduha [%1] %2, %0":"=r"(ret) | |
538 | :"r"(port), "i"(ASI_PL)); | |
539 | ||
540 | return ret; | |
541 | } | |
542 | ||
543 | static __inline__ unsigned int | |
544 | inl(unsigned long port) | |
545 | { | |
546 | unsigned int ret; | |
547 | __asm__ __volatile__("lda [%1] %2, %0":"=r"(ret) | |
548 | :"r"(port), "i"(ASI_PL)); | |
549 | ||
550 | return ret; | |
551 | } | |
552 | ||
553 | static __inline__ unsigned char | |
554 | xf86ReadMmio8(__volatile__ void *base, const unsigned long offset) | |
555 | { | |
556 | unsigned long addr = ((unsigned long) base) + offset; | |
557 | unsigned char ret; | |
558 | ||
559 | __asm__ __volatile__("lduba [%1] %2, %0":"=r"(ret) | |
560 | :"r"(addr), "i"(ASI_PL)); | |
561 | ||
562 | return ret; | |
563 | } | |
564 | ||
565 | static __inline__ unsigned short | |
566 | xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset) | |
567 | { | |
568 | unsigned long addr = ((unsigned long) base) + offset; | |
569 | unsigned short ret; | |
570 | ||
571 | __asm__ __volatile__("lduh [%1], %0":"=r"(ret) | |
572 | :"r"(addr)); | |
573 | ||
574 | return ret; | |
575 | } | |
576 | ||
577 | static __inline__ unsigned short | |
578 | xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset) | |
579 | { | |
580 | unsigned long addr = ((unsigned long) base) + offset; | |
581 | unsigned short ret; | |
582 | ||
583 | __asm__ __volatile__("lduha [%1] %2, %0":"=r"(ret) | |
584 | :"r"(addr), "i"(ASI_PL)); | |
585 | ||
586 | return ret; | |
587 | } | |
588 | ||
589 | static __inline__ unsigned int | |
590 | xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset) | |
591 | { | |
592 | unsigned long addr = ((unsigned long) base) + offset; | |
593 | unsigned int ret; | |
594 | ||
595 | __asm__ __volatile__("ld [%1], %0":"=r"(ret) | |
596 | :"r"(addr)); | |
597 | ||
598 | return ret; | |
599 | } | |
600 | ||
601 | static __inline__ unsigned int | |
602 | xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset) | |
603 | { | |
604 | unsigned long addr = ((unsigned long) base) + offset; | |
605 | unsigned int ret; | |
606 | ||
607 | __asm__ __volatile__("lda [%1] %2, %0":"=r"(ret) | |
608 | :"r"(addr), "i"(ASI_PL)); | |
609 | ||
610 | return ret; | |
611 | } | |
612 | ||
613 | static __inline__ void | |
614 | xf86WriteMmio8(__volatile__ void *base, const unsigned long offset, | |
615 | const unsigned int val) | |
616 | { | |
617 | unsigned long addr = ((unsigned long) base) + offset; | |
618 | ||
619 | __asm__ __volatile__("stba %0, [%1] %2": /* No outputs */ | |
620 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
621 | ||
622 | barrier(); | |
623 | } | |
624 | ||
625 | static __inline__ void | |
626 | xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset, | |
627 | const unsigned int val) | |
628 | { | |
629 | unsigned long addr = ((unsigned long) base) + offset; | |
630 | ||
631 | __asm__ __volatile__("sth %0, [%1]": /* No outputs */ | |
632 | :"r"(val), "r"(addr)); | |
633 | ||
634 | barrier(); | |
635 | } | |
636 | ||
637 | static __inline__ void | |
638 | xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset, | |
639 | const unsigned int val) | |
640 | { | |
641 | unsigned long addr = ((unsigned long) base) + offset; | |
642 | ||
643 | __asm__ __volatile__("stha %0, [%1] %2": /* No outputs */ | |
644 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
645 | ||
646 | barrier(); | |
647 | } | |
648 | ||
649 | static __inline__ void | |
650 | xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset, | |
651 | const unsigned int val) | |
652 | { | |
653 | unsigned long addr = ((unsigned long) base) + offset; | |
654 | ||
655 | __asm__ __volatile__("st %0, [%1]": /* No outputs */ | |
656 | :"r"(val), "r"(addr)); | |
657 | ||
658 | barrier(); | |
659 | } | |
660 | ||
661 | static __inline__ void | |
662 | xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset, | |
663 | const unsigned int val) | |
664 | { | |
665 | unsigned long addr = ((unsigned long) base) + offset; | |
666 | ||
667 | __asm__ __volatile__("sta %0, [%1] %2": /* No outputs */ | |
668 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
669 | ||
670 | barrier(); | |
671 | } | |
672 | ||
673 | static __inline__ void | |
674 | xf86WriteMmio8NB(__volatile__ void *base, const unsigned long offset, | |
675 | const unsigned int val) | |
676 | { | |
677 | unsigned long addr = ((unsigned long) base) + offset; | |
678 | ||
679 | __asm__ __volatile__("stba %0, [%1] %2": /* No outputs */ | |
680 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
681 | } | |
682 | ||
683 | static __inline__ void | |
684 | xf86WriteMmio16BeNB(__volatile__ void *base, const unsigned long offset, | |
685 | const unsigned int val) | |
686 | { | |
687 | unsigned long addr = ((unsigned long) base) + offset; | |
688 | ||
689 | __asm__ __volatile__("sth %0, [%1]": /* No outputs */ | |
690 | :"r"(val), "r"(addr)); | |
691 | } | |
692 | ||
693 | static __inline__ void | |
694 | xf86WriteMmio16LeNB(__volatile__ void *base, const unsigned long offset, | |
695 | const unsigned int val) | |
696 | { | |
697 | unsigned long addr = ((unsigned long) base) + offset; | |
698 | ||
699 | __asm__ __volatile__("stha %0, [%1] %2": /* No outputs */ | |
700 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
701 | } | |
702 | ||
703 | static __inline__ void | |
704 | xf86WriteMmio32BeNB(__volatile__ void *base, const unsigned long offset, | |
705 | const unsigned int val) | |
706 | { | |
707 | unsigned long addr = ((unsigned long) base) + offset; | |
708 | ||
709 | __asm__ __volatile__("st %0, [%1]": /* No outputs */ | |
710 | :"r"(val), "r"(addr)); | |
711 | } | |
712 | ||
713 | static __inline__ void | |
714 | xf86WriteMmio32LeNB(__volatile__ void *base, const unsigned long offset, | |
715 | const unsigned int val) | |
716 | { | |
717 | unsigned long addr = ((unsigned long) base) + offset; | |
718 | ||
719 | __asm__ __volatile__("sta %0, [%1] %2": /* No outputs */ | |
720 | :"r"(val), "r"(addr), "i"(ASI_PL)); | |
721 | } | |
722 | ||
723 | #elif defined(__mips__) || (defined(__arm32__) && !defined(__linux__)) | |
724 | #ifdef __arm32__ | |
725 | #define PORT_SIZE long | |
726 | #else | |
727 | #define PORT_SIZE short | |
728 | #endif | |
729 | ||
730 | _X_EXPORT unsigned int IOPortBase; /* Memory mapped I/O port area */ | |
731 | ||
732 | static __inline__ void | |
733 | outb(unsigned PORT_SIZE port, unsigned char val) | |
734 | { | |
735 | *(volatile unsigned char *) (((unsigned PORT_SIZE) (port)) + IOPortBase) = | |
736 | val; | |
737 | } | |
738 | ||
739 | static __inline__ void | |
740 | outw(unsigned PORT_SIZE port, unsigned short val) | |
741 | { | |
742 | *(volatile unsigned short *) (((unsigned PORT_SIZE) (port)) + IOPortBase) = | |
743 | val; | |
744 | } | |
745 | ||
746 | static __inline__ void | |
747 | outl(unsigned PORT_SIZE port, unsigned int val) | |
748 | { | |
749 | *(volatile unsigned int *) (((unsigned PORT_SIZE) (port)) + IOPortBase) = | |
750 | val; | |
751 | } | |
752 | ||
753 | static __inline__ unsigned int | |
754 | inb(unsigned PORT_SIZE port) | |
755 | { | |
756 | return *(volatile unsigned char *) (((unsigned PORT_SIZE) (port)) + | |
757 | IOPortBase); | |
758 | } | |
759 | ||
760 | static __inline__ unsigned int | |
761 | inw(unsigned PORT_SIZE port) | |
762 | { | |
763 | return *(volatile unsigned short *) (((unsigned PORT_SIZE) (port)) + | |
764 | IOPortBase); | |
765 | } | |
766 | ||
767 | static __inline__ unsigned int | |
768 | inl(unsigned PORT_SIZE port) | |
769 | { | |
770 | return *(volatile unsigned int *) (((unsigned PORT_SIZE) (port)) + | |
771 | IOPortBase); | |
772 | } | |
773 | ||
774 | #if defined(__mips__) | |
775 | #ifdef linux /* don't mess with other OSs */ | |
776 | #if X_BYTE_ORDER == X_BIG_ENDIAN | |
777 | static __inline__ unsigned int | |
778 | xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset) | |
779 | { | |
780 | unsigned long addr = ((unsigned long) base) + offset; | |
781 | unsigned int ret; | |
782 | ||
783 | __asm__ __volatile__("lw %0, 0(%1)":"=r"(ret) | |
784 | :"r"(addr)); | |
785 | ||
786 | return ret; | |
787 | } | |
788 | ||
789 | static __inline__ void | |
790 | xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset, | |
791 | const unsigned int val) | |
792 | { | |
793 | unsigned long addr = ((unsigned long) base) + offset; | |
794 | ||
795 | __asm__ __volatile__("sw %0, 0(%1)": /* No outputs */ | |
796 | :"r"(val), "r"(addr)); | |
797 | } | |
798 | #endif | |
799 | #endif /* !linux */ | |
800 | #endif /* __mips__ */ | |
801 | ||
802 | #elif (defined(linux) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)) && defined(__powerpc__) | |
803 | ||
804 | #ifndef MAP_FAILED | |
805 | #define MAP_FAILED ((void *)-1) | |
806 | #endif | |
807 | ||
808 | extern _X_EXPORT volatile unsigned char *ioBase; | |
809 | ||
810 | static __inline__ unsigned char | |
811 | xf86ReadMmio8(__volatile__ void *base, const unsigned long offset) | |
812 | { | |
813 | register unsigned char val; | |
814 | __asm__ __volatile__("lbzx %0,%1,%2\n\t" "eieio":"=r"(val) | |
815 | :"b"(base), "r"(offset), | |
816 | "m"(*((volatile unsigned char *) base + offset))); | |
817 | return val; | |
818 | } | |
819 | ||
820 | static __inline__ unsigned short | |
821 | xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset) | |
822 | { | |
823 | register unsigned short val; | |
824 | __asm__ __volatile__("lhzx %0,%1,%2\n\t" "eieio":"=r"(val) | |
825 | :"b"(base), "r"(offset), | |
826 | "m"(*((volatile unsigned char *) base + offset))); | |
827 | return val; | |
828 | } | |
829 | ||
830 | static __inline__ unsigned short | |
831 | xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset) | |
832 | { | |
833 | register unsigned short val; | |
834 | __asm__ __volatile__("lhbrx %0,%1,%2\n\t" "eieio":"=r"(val) | |
835 | :"b"(base), "r"(offset), | |
836 | "m"(*((volatile unsigned char *) base + offset))); | |
837 | return val; | |
838 | } | |
839 | ||
840 | static __inline__ unsigned int | |
841 | xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset) | |
842 | { | |
843 | register unsigned int val; | |
844 | __asm__ __volatile__("lwzx %0,%1,%2\n\t" "eieio":"=r"(val) | |
845 | :"b"(base), "r"(offset), | |
846 | "m"(*((volatile unsigned char *) base + offset))); | |
847 | return val; | |
848 | } | |
849 | ||
850 | static __inline__ unsigned int | |
851 | xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset) | |
852 | { | |
853 | register unsigned int val; | |
854 | __asm__ __volatile__("lwbrx %0,%1,%2\n\t" "eieio":"=r"(val) | |
855 | :"b"(base), "r"(offset), | |
856 | "m"(*((volatile unsigned char *) base + offset))); | |
857 | return val; | |
858 | } | |
859 | ||
860 | static __inline__ void | |
861 | xf86WriteMmioNB8(__volatile__ void *base, const unsigned long offset, | |
862 | const unsigned char val) | |
863 | { | |
864 | __asm__ | |
865 | __volatile__("stbx %1,%2,%3\n\t":"=m" | |
866 | (*((volatile unsigned char *) base + offset)) | |
867 | :"r"(val), "b"(base), "r"(offset)); | |
868 | } | |
869 | ||
870 | static __inline__ void | |
871 | xf86WriteMmioNB16Le(__volatile__ void *base, const unsigned long offset, | |
872 | const unsigned short val) | |
873 | { | |
874 | __asm__ | |
875 | __volatile__("sthbrx %1,%2,%3\n\t":"=m" | |
876 | (*((volatile unsigned char *) base + offset)) | |
877 | :"r"(val), "b"(base), "r"(offset)); | |
878 | } | |
879 | ||
880 | static __inline__ void | |
881 | xf86WriteMmioNB16Be(__volatile__ void *base, const unsigned long offset, | |
882 | const unsigned short val) | |
883 | { | |
884 | __asm__ | |
885 | __volatile__("sthx %1,%2,%3\n\t":"=m" | |
886 | (*((volatile unsigned char *) base + offset)) | |
887 | :"r"(val), "b"(base), "r"(offset)); | |
888 | } | |
889 | ||
890 | static __inline__ void | |
891 | xf86WriteMmioNB32Le(__volatile__ void *base, const unsigned long offset, | |
892 | const unsigned int val) | |
893 | { | |
894 | __asm__ | |
895 | __volatile__("stwbrx %1,%2,%3\n\t":"=m" | |
896 | (*((volatile unsigned char *) base + offset)) | |
897 | :"r"(val), "b"(base), "r"(offset)); | |
898 | } | |
899 | ||
900 | static __inline__ void | |
901 | xf86WriteMmioNB32Be(__volatile__ void *base, const unsigned long offset, | |
902 | const unsigned int val) | |
903 | { | |
904 | __asm__ | |
905 | __volatile__("stwx %1,%2,%3\n\t":"=m" | |
906 | (*((volatile unsigned char *) base + offset)) | |
907 | :"r"(val), "b"(base), "r"(offset)); | |
908 | } | |
909 | ||
910 | static __inline__ void | |
911 | xf86WriteMmio8(__volatile__ void *base, const unsigned long offset, | |
912 | const unsigned char val) | |
913 | { | |
914 | xf86WriteMmioNB8(base, offset, val); | |
915 | eieio(); | |
916 | } | |
917 | ||
918 | static __inline__ void | |
919 | xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset, | |
920 | const unsigned short val) | |
921 | { | |
922 | xf86WriteMmioNB16Le(base, offset, val); | |
923 | eieio(); | |
924 | } | |
925 | ||
926 | static __inline__ void | |
927 | xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset, | |
928 | const unsigned short val) | |
929 | { | |
930 | xf86WriteMmioNB16Be(base, offset, val); | |
931 | eieio(); | |
932 | } | |
933 | ||
934 | static __inline__ void | |
935 | xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset, | |
936 | const unsigned int val) | |
937 | { | |
938 | xf86WriteMmioNB32Le(base, offset, val); | |
939 | eieio(); | |
940 | } | |
941 | ||
942 | static __inline__ void | |
943 | xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset, | |
944 | const unsigned int val) | |
945 | { | |
946 | xf86WriteMmioNB32Be(base, offset, val); | |
947 | eieio(); | |
948 | } | |
949 | ||
950 | static __inline__ void | |
951 | outb(unsigned short port, unsigned char value) | |
952 | { | |
953 | if (ioBase == MAP_FAILED) | |
954 | return; | |
955 | xf86WriteMmio8((void *) ioBase, port, value); | |
956 | } | |
957 | ||
958 | static __inline__ void | |
959 | outw(unsigned short port, unsigned short value) | |
960 | { | |
961 | if (ioBase == MAP_FAILED) | |
962 | return; | |
963 | xf86WriteMmio16Le((void *) ioBase, port, value); | |
964 | } | |
965 | ||
966 | static __inline__ void | |
967 | outl(unsigned short port, unsigned int value) | |
968 | { | |
969 | if (ioBase == MAP_FAILED) | |
970 | return; | |
971 | xf86WriteMmio32Le((void *) ioBase, port, value); | |
972 | } | |
973 | ||
974 | static __inline__ unsigned int | |
975 | inb(unsigned short port) | |
976 | { | |
977 | if (ioBase == MAP_FAILED) | |
978 | return 0; | |
979 | return xf86ReadMmio8((void *) ioBase, port); | |
980 | } | |
981 | ||
982 | static __inline__ unsigned int | |
983 | inw(unsigned short port) | |
984 | { | |
985 | if (ioBase == MAP_FAILED) | |
986 | return 0; | |
987 | return xf86ReadMmio16Le((void *) ioBase, port); | |
988 | } | |
989 | ||
990 | static __inline__ unsigned int | |
991 | inl(unsigned short port) | |
992 | { | |
993 | if (ioBase == MAP_FAILED) | |
994 | return 0; | |
995 | return xf86ReadMmio32Le((void *) ioBase, port); | |
996 | } | |
997 | ||
998 | #elif defined(__arm__) && defined(__linux__) | |
999 | ||
1000 | /* for Linux on ARM, we use the LIBC inx/outx routines */ | |
1001 | /* note that the appropriate setup via "ioperm" needs to be done */ | |
1002 | /* *before* any inx/outx is done. */ | |
1003 | ||
1004 | #include <sys/io.h> | |
1005 | ||
1006 | static __inline__ void | |
1007 | xf_outb(unsigned short port, unsigned char val) | |
1008 | { | |
1009 | outb(val, port); | |
1010 | } | |
1011 | ||
1012 | static __inline__ void | |
1013 | xf_outw(unsigned short port, unsigned short val) | |
1014 | { | |
1015 | outw(val, port); | |
1016 | } | |
1017 | ||
1018 | static __inline__ void | |
1019 | xf_outl(unsigned short port, unsigned int val) | |
1020 | { | |
1021 | outl(val, port); | |
1022 | } | |
1023 | ||
1024 | #define outb xf_outb | |
1025 | #define outw xf_outw | |
1026 | #define outl xf_outl | |
1027 | ||
1028 | #elif defined(__nds32__) | |
1029 | ||
1030 | /* | |
1031 | * Assume all port access are aligned. We need to revise this implementation | |
1032 | * if there is unaligned port access. For ldq_u, ldl_u, ldw_u, stq_u, stl_u and | |
1033 | * stw_u, they are assumed unaligned. | |
1034 | */ | |
1035 | ||
1036 | #define barrier() /* no barrier */ | |
1037 | ||
1038 | #define PORT_SIZE long | |
1039 | ||
1040 | static __inline__ unsigned char | |
1041 | xf86ReadMmio8(__volatile__ void *base, const unsigned long offset) | |
1042 | { | |
1043 | return *(volatile unsigned char *) ((unsigned char *) base + offset); | |
1044 | } | |
1045 | ||
1046 | static __inline__ void | |
1047 | xf86WriteMmio8(__volatile__ void *base, const unsigned long offset, | |
1048 | const unsigned int val) | |
1049 | { | |
1050 | *(volatile unsigned char *) ((unsigned char *) base + offset) = val; | |
1051 | barrier(); | |
1052 | } | |
1053 | ||
1054 | static __inline__ void | |
1055 | xf86WriteMmio8NB(__volatile__ void *base, const unsigned long offset, | |
1056 | const unsigned int val) | |
1057 | { | |
1058 | *(volatile unsigned char *) ((unsigned char *) base + offset) = val; | |
1059 | } | |
1060 | ||
1061 | static __inline__ unsigned short | |
1062 | xf86ReadMmio16Swap(__volatile__ void *base, const unsigned long offset) | |
1063 | { | |
1064 | unsigned long addr = ((unsigned long) base) + offset; | |
1065 | unsigned short ret; | |
1066 | ||
1067 | __asm__ __volatile__("lhi %0, [%1];\n\t" "wsbh %0, %0;\n\t":"=r"(ret) | |
1068 | :"r"(addr)); | |
1069 | ||
1070 | return ret; | |
1071 | } | |
1072 | ||
1073 | static __inline__ unsigned short | |
1074 | xf86ReadMmio16(__volatile__ void *base, const unsigned long offset) | |
1075 | { | |
1076 | return *(volatile unsigned short *) ((char *) base + offset); | |
1077 | } | |
1078 | ||
1079 | static __inline__ void | |
1080 | xf86WriteMmio16Swap(__volatile__ void *base, const unsigned long offset, | |
1081 | const unsigned int val) | |
1082 | { | |
1083 | unsigned long addr = ((unsigned long) base) + offset; | |
1084 | ||
1085 | __asm__ __volatile__("wsbh %0, %0;\n\t" "shi %0, [%1];\n\t": /* No outputs */ | |
1086 | :"r"(val), "r"(addr)); | |
1087 | ||
1088 | barrier(); | |
1089 | } | |
1090 | ||
1091 | static __inline__ void | |
1092 | xf86WriteMmio16(__volatile__ void *base, const unsigned long offset, | |
1093 | const unsigned int val) | |
1094 | { | |
1095 | *(volatile unsigned short *) ((unsigned char *) base + offset) = val; | |
1096 | barrier(); | |
1097 | } | |
1098 | ||
1099 | static __inline__ void | |
1100 | xf86WriteMmio16SwapNB(__volatile__ void *base, const unsigned long offset, | |
1101 | const unsigned int val) | |
1102 | { | |
1103 | unsigned long addr = ((unsigned long) base) + offset; | |
1104 | ||
1105 | __asm__ __volatile__("wsbh %0, %0;\n\t" "shi %0, [%1];\n\t": /* No outputs */ | |
1106 | :"r"(val), "r"(addr)); | |
1107 | } | |
1108 | ||
1109 | static __inline__ void | |
1110 | xf86WriteMmio16NB(__volatile__ void *base, const unsigned long offset, | |
1111 | const unsigned int val) | |
1112 | { | |
1113 | *(volatile unsigned short *) ((unsigned char *) base + offset) = val; | |
1114 | } | |
1115 | ||
1116 | static __inline__ unsigned int | |
1117 | xf86ReadMmio32Swap(__volatile__ void *base, const unsigned long offset) | |
1118 | { | |
1119 | unsigned long addr = ((unsigned long) base) + offset; | |
1120 | unsigned int ret; | |
1121 | ||
1122 | __asm__ __volatile__("lwi %0, [%1];\n\t" | |
1123 | "wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t":"=r"(ret) | |
1124 | :"r"(addr)); | |
1125 | ||
1126 | return ret; | |
1127 | } | |
1128 | ||
1129 | static __inline__ unsigned int | |
1130 | xf86ReadMmio32(__volatile__ void *base, const unsigned long offset) | |
1131 | { | |
1132 | return *(volatile unsigned int *) ((unsigned char *) base + offset); | |
1133 | } | |
1134 | ||
1135 | static __inline__ void | |
1136 | xf86WriteMmio32Swap(__volatile__ void *base, const unsigned long offset, | |
1137 | const unsigned int val) | |
1138 | { | |
1139 | unsigned long addr = ((unsigned long) base) + offset; | |
1140 | ||
1141 | __asm__ __volatile__("wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t" "swi %0, [%1];\n\t": /* No outputs */ | |
1142 | :"r"(val), "r"(addr)); | |
1143 | ||
1144 | barrier(); | |
1145 | } | |
1146 | ||
1147 | static __inline__ void | |
1148 | xf86WriteMmio32(__volatile__ void *base, const unsigned long offset, | |
1149 | const unsigned int val) | |
1150 | { | |
1151 | *(volatile unsigned int *) ((unsigned char *) base + offset) = val; | |
1152 | barrier(); | |
1153 | } | |
1154 | ||
1155 | static __inline__ void | |
1156 | xf86WriteMmio32SwapNB(__volatile__ void *base, const unsigned long offset, | |
1157 | const unsigned int val) | |
1158 | { | |
1159 | unsigned long addr = ((unsigned long) base) + offset; | |
1160 | ||
1161 | __asm__ __volatile__("wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t" "swi %0, [%1];\n\t": /* No outputs */ | |
1162 | :"r"(val), "r"(addr)); | |
1163 | } | |
1164 | ||
1165 | static __inline__ void | |
1166 | xf86WriteMmio32NB(__volatile__ void *base, const unsigned long offset, | |
1167 | const unsigned int val) | |
1168 | { | |
1169 | *(volatile unsigned int *) ((unsigned char *) base + offset) = val; | |
1170 | } | |
1171 | ||
1172 | #if defined(NDS32_MMIO_SWAP) | |
1173 | static __inline__ void | |
1174 | outb(unsigned PORT_SIZE port, unsigned char val) | |
1175 | { | |
1176 | xf86WriteMmio8(IOPortBase, port, val); | |
1177 | } | |
1178 | ||
1179 | static __inline__ void | |
1180 | outw(unsigned PORT_SIZE port, unsigned short val) | |
1181 | { | |
1182 | xf86WriteMmio16Swap(IOPortBase, port, val); | |
1183 | } | |
1184 | ||
1185 | static __inline__ void | |
1186 | outl(unsigned PORT_SIZE port, unsigned int val) | |
1187 | { | |
1188 | xf86WriteMmio32Swap(IOPortBase, port, val); | |
1189 | } | |
1190 | ||
1191 | static __inline__ unsigned int | |
1192 | inb(unsigned PORT_SIZE port) | |
1193 | { | |
1194 | return xf86ReadMmio8(IOPortBase, port); | |
1195 | } | |
1196 | ||
1197 | static __inline__ unsigned int | |
1198 | inw(unsigned PORT_SIZE port) | |
1199 | { | |
1200 | return xf86ReadMmio16Swap(IOPortBase, port); | |
1201 | } | |
1202 | ||
1203 | static __inline__ unsigned int | |
1204 | inl(unsigned PORT_SIZE port) | |
1205 | { | |
1206 | return xf86ReadMmio32Swap(IOPortBase, port); | |
1207 | } | |
1208 | ||
1209 | static __inline__ unsigned long | |
1210 | ldq_u(unsigned long *p) | |
1211 | { | |
1212 | unsigned long addr = (unsigned long) p; | |
1213 | unsigned int ret; | |
1214 | ||
1215 | __asm__ __volatile__("lmw.bi %0, [%1], %0, 0;\n\t" | |
1216 | "wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t":"=r"(ret) | |
1217 | :"r"(addr)); | |
1218 | ||
1219 | return ret; | |
1220 | } | |
1221 | ||
1222 | static __inline__ unsigned long | |
1223 | ldl_u(unsigned int *p) | |
1224 | { | |
1225 | unsigned long addr = (unsigned long) p; | |
1226 | unsigned int ret; | |
1227 | ||
1228 | __asm__ __volatile__("lmw.bi %0, [%1], %0, 0;\n\t" | |
1229 | "wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t":"=r"(ret) | |
1230 | :"r"(addr)); | |
1231 | ||
1232 | return ret; | |
1233 | } | |
1234 | ||
1235 | static __inline__ void | |
1236 | stq_u(unsigned long val, unsigned long *p) | |
1237 | { | |
1238 | unsigned long addr = (unsigned long) p; | |
1239 | ||
1240 | __asm__ __volatile__("wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t" "smw.bi %0, [%1], %0, 0;\n\t": /* No outputs */ | |
1241 | :"r"(val), "r"(addr)); | |
1242 | } | |
1243 | ||
1244 | static __inline__ void | |
1245 | stl_u(unsigned long val, unsigned int *p) | |
1246 | { | |
1247 | unsigned long addr = (unsigned long) p; | |
1248 | ||
1249 | __asm__ __volatile__("wsbh %0, %0;\n\t" "rotri %0, %0, 16;\n\t" "smw.bi %0, [%1], %0, 0;\n\t": /* No outputs */ | |
1250 | :"r"(val), "r"(addr)); | |
1251 | } | |
1252 | ||
1253 | #else /* !NDS32_MMIO_SWAP */ | |
1254 | static __inline__ void | |
1255 | outb(unsigned PORT_SIZE port, unsigned char val) | |
1256 | { | |
1257 | *(volatile unsigned char *) (((unsigned PORT_SIZE) (port))) = val; | |
1258 | barrier(); | |
1259 | } | |
1260 | ||
1261 | static __inline__ void | |
1262 | outw(unsigned PORT_SIZE port, unsigned short val) | |
1263 | { | |
1264 | *(volatile unsigned short *) (((unsigned PORT_SIZE) (port))) = val; | |
1265 | barrier(); | |
1266 | } | |
1267 | ||
1268 | static __inline__ void | |
1269 | outl(unsigned PORT_SIZE port, unsigned int val) | |
1270 | { | |
1271 | *(volatile unsigned int *) (((unsigned PORT_SIZE) (port))) = val; | |
1272 | barrier(); | |
1273 | } | |
1274 | ||
1275 | static __inline__ unsigned int | |
1276 | inb(unsigned PORT_SIZE port) | |
1277 | { | |
1278 | return *(volatile unsigned char *) (((unsigned PORT_SIZE) (port))); | |
1279 | } | |
1280 | ||
1281 | static __inline__ unsigned int | |
1282 | inw(unsigned PORT_SIZE port) | |
1283 | { | |
1284 | return *(volatile unsigned short *) (((unsigned PORT_SIZE) (port))); | |
1285 | } | |
1286 | ||
1287 | static __inline__ unsigned int | |
1288 | inl(unsigned PORT_SIZE port) | |
1289 | { | |
1290 | return *(volatile unsigned int *) (((unsigned PORT_SIZE) (port))); | |
1291 | } | |
1292 | ||
1293 | static __inline__ unsigned long | |
1294 | ldq_u(unsigned long *p) | |
1295 | { | |
1296 | unsigned long addr = (unsigned long) p; | |
1297 | unsigned int ret; | |
1298 | ||
1299 | __asm__ __volatile__("lmw.bi %0, [%1], %0, 0;\n\t":"=r"(ret) | |
1300 | :"r"(addr)); | |
1301 | ||
1302 | return ret; | |
1303 | } | |
1304 | ||
1305 | static __inline__ unsigned long | |
1306 | ldl_u(unsigned int *p) | |
1307 | { | |
1308 | unsigned long addr = (unsigned long) p; | |
1309 | unsigned int ret; | |
1310 | ||
1311 | __asm__ __volatile__("lmw.bi %0, [%1], %0, 0;\n\t":"=r"(ret) | |
1312 | :"r"(addr)); | |
1313 | ||
1314 | return ret; | |
1315 | } | |
1316 | ||
1317 | static __inline__ void | |
1318 | stq_u(unsigned long val, unsigned long *p) | |
1319 | { | |
1320 | unsigned long addr = (unsigned long) p; | |
1321 | ||
1322 | __asm__ __volatile__("smw.bi %0, [%1], %0, 0;\n\t": /* No outputs */ | |
1323 | :"r"(val), "r"(addr)); | |
1324 | } | |
1325 | ||
1326 | static __inline__ void | |
1327 | stl_u(unsigned long val, unsigned int *p) | |
1328 | { | |
1329 | unsigned long addr = (unsigned long) p; | |
1330 | ||
1331 | __asm__ __volatile__("smw.bi %0, [%1], %0, 0;\n\t": /* No outputs */ | |
1332 | :"r"(val), "r"(addr)); | |
1333 | } | |
1334 | #endif /* NDS32_MMIO_SWAP */ | |
1335 | ||
1336 | #if (((X_BYTE_ORDER == X_BIG_ENDIAN) && !defined(NDS32_MMIO_SWAP)) || ((X_BYTE_ORDER != X_BIG_ENDIAN) && defined(NDS32_MMIO_SWAP))) | |
1337 | #define ldw_u(p) ((*(unsigned char *)(p)) << 8 | \ | |
1338 | (*((unsigned char *)(p)+1))) | |
1339 | #define stw_u(v,p) (*(unsigned char *)(p)) = ((v) >> 8); \ | |
1340 | (*((unsigned char *)(p)+1)) = (v) | |
1341 | #else | |
1342 | #define ldw_u(p) ((*(unsigned char *)(p)) | \ | |
1343 | (*((unsigned char *)(p)+1)<<8)) | |
1344 | #define stw_u(v,p) (*(unsigned char *)(p)) = (v); \ | |
1345 | (*((unsigned char *)(p)+1)) = ((v) >> 8) | |
1346 | #endif | |
1347 | ||
1348 | #define mem_barrier() /* XXX: nop for now */ | |
1349 | #define write_mem_barrier() /* XXX: nop for now */ | |
1350 | ||
1351 | #else /* ix86 */ | |
1352 | ||
1353 | #if !defined(__SUNPRO_C) | |
1354 | #if !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__) && !defined(__s390__) && !defined(__m32r__) && !defined(__aarch64__) | |
1355 | #ifdef GCCUSESGAS | |
1356 | ||
1357 | /* | |
1358 | * If gcc uses gas rather than the native assembler, the syntax of these | |
1359 | * inlines has to be different. DHD | |
1360 | */ | |
1361 | ||
1362 | static __inline__ void | |
1363 | outb(unsigned short port, unsigned char val) | |
1364 | { | |
1365 | __asm__ __volatile__("outb %0,%1"::"a"(val), "d"(port)); | |
1366 | } | |
1367 | ||
1368 | static __inline__ void | |
1369 | outw(unsigned short port, unsigned short val) | |
1370 | { | |
1371 | __asm__ __volatile__("outw %0,%1"::"a"(val), "d"(port)); | |
1372 | } | |
1373 | ||
1374 | static __inline__ void | |
1375 | outl(unsigned short port, unsigned int val) | |
1376 | { | |
1377 | __asm__ __volatile__("outl %0,%1"::"a"(val), "d"(port)); | |
1378 | } | |
1379 | ||
1380 | static __inline__ unsigned int | |
1381 | inb(unsigned short port) | |
1382 | { | |
1383 | unsigned char ret; | |
1384 | __asm__ __volatile__("inb %1,%0":"=a"(ret):"d"(port)); | |
1385 | ||
1386 | return ret; | |
1387 | } | |
1388 | ||
1389 | static __inline__ unsigned int | |
1390 | inw(unsigned short port) | |
1391 | { | |
1392 | unsigned short ret; | |
1393 | __asm__ __volatile__("inw %1,%0":"=a"(ret):"d"(port)); | |
1394 | ||
1395 | return ret; | |
1396 | } | |
1397 | ||
1398 | static __inline__ unsigned int | |
1399 | inl(unsigned short port) | |
1400 | { | |
1401 | unsigned int ret; | |
1402 | __asm__ __volatile__("inl %1,%0":"=a"(ret):"d"(port)); | |
1403 | ||
1404 | return ret; | |
1405 | } | |
1406 | ||
1407 | #else /* GCCUSESGAS */ | |
1408 | ||
1409 | static __inline__ void | |
1410 | outb(unsigned short port, unsigned char val) | |
1411 | { | |
1412 | __asm__ __volatile__("out%B0 (%1)"::"a"(val), "d"(port)); | |
1413 | } | |
1414 | ||
1415 | static __inline__ void | |
1416 | outw(unsigned short port, unsigned short val) | |
1417 | { | |
1418 | __asm__ __volatile__("out%W0 (%1)"::"a"(val), "d"(port)); | |
1419 | } | |
1420 | ||
1421 | static __inline__ void | |
1422 | outl(unsigned short port, unsigned int val) | |
1423 | { | |
1424 | __asm__ __volatile__("out%L0 (%1)"::"a"(val), "d"(port)); | |
1425 | } | |
1426 | ||
1427 | static __inline__ unsigned int | |
1428 | inb(unsigned short port) | |
1429 | { | |
1430 | unsigned char ret; | |
1431 | __asm__ __volatile__("in%B0 (%1)":"=a"(ret):"d"(port)); | |
1432 | ||
1433 | return ret; | |
1434 | } | |
1435 | ||
1436 | static __inline__ unsigned int | |
1437 | inw(unsigned short port) | |
1438 | { | |
1439 | unsigned short ret; | |
1440 | __asm__ __volatile__("in%W0 (%1)":"=a"(ret):"d"(port)); | |
1441 | ||
1442 | return ret; | |
1443 | } | |
1444 | ||
1445 | static __inline__ unsigned int | |
1446 | inl(unsigned short port) | |
1447 | { | |
1448 | unsigned int ret; | |
1449 | __asm__ __volatile__("in%L0 (%1)":"=a"(ret):"d"(port)); | |
1450 | ||
1451 | return ret; | |
1452 | } | |
1453 | ||
1454 | #endif /* GCCUSESGAS */ | |
1455 | ||
1456 | #else /* !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__) && !defined(__m32r__) */ | |
1457 | ||
1458 | static __inline__ void | |
1459 | outb(unsigned short port, unsigned char val) | |
1460 | { | |
1461 | } | |
1462 | ||
1463 | static __inline__ void | |
1464 | outw(unsigned short port, unsigned short val) | |
1465 | { | |
1466 | } | |
1467 | ||
1468 | static __inline__ void | |
1469 | outl(unsigned short port, unsigned int val) | |
1470 | { | |
1471 | } | |
1472 | ||
1473 | static __inline__ unsigned int | |
1474 | inb(unsigned short port) | |
1475 | { | |
1476 | return 0; | |
1477 | } | |
1478 | ||
1479 | static __inline__ unsigned int | |
1480 | inw(unsigned short port) | |
1481 | { | |
1482 | return 0; | |
1483 | } | |
1484 | ||
1485 | static __inline__ unsigned int | |
1486 | inl(unsigned short port) | |
1487 | { | |
1488 | return 0; | |
1489 | } | |
1490 | ||
1491 | #endif /* FAKEIT */ | |
1492 | #endif /* __SUNPRO_C */ | |
1493 | ||
1494 | #endif /* ix86 */ | |
1495 | ||
1496 | #else /* !GNUC */ | |
1497 | #if defined(__STDC__) && (__STDC__ == 1) | |
1498 | #ifndef asm | |
1499 | #define asm __asm | |
1500 | #endif | |
1501 | #endif | |
1502 | #if !defined(__SUNPRO_C) | |
1503 | #include <sys/inline.h> | |
1504 | #endif | |
1505 | #if !defined(__HIGHC__) && !defined(__SUNPRO_C) || \ | |
1506 | defined(__USLC__) | |
1507 | #pragma asm partial_optimization outl | |
1508 | #pragma asm partial_optimization outw | |
1509 | #pragma asm partial_optimization outb | |
1510 | #pragma asm partial_optimization inl | |
1511 | #pragma asm partial_optimization inw | |
1512 | #pragma asm partial_optimization inb | |
1513 | #endif | |
1514 | #endif /* __GNUC__ */ | |
1515 | ||
1516 | #endif /* NO_INLINE */ | |
1517 | ||
1518 | #ifdef __alpha__ | |
1519 | /* entry points for Mmio memory access routines */ | |
1520 | extern _X_EXPORT int (*xf86ReadMmio8) (void *, unsigned long); | |
1521 | extern _X_EXPORT int (*xf86ReadMmio16) (void *, unsigned long); | |
1522 | ||
1523 | #ifndef STANDALONE_MMIO | |
1524 | extern _X_EXPORT int (*xf86ReadMmio32) (void *, unsigned long); | |
1525 | #else | |
1526 | /* Some DRI 3D drivers need MMIO_IN32. */ | |
1527 | static __inline__ int | |
1528 | xf86ReadMmio32(void *Base, unsigned long Offset) | |
1529 | { | |
1530 | mem_barrier(); | |
1531 | return *(volatile unsigned int *) ((unsigned long) Base + (Offset)); | |
1532 | } | |
1533 | #endif | |
1534 | extern _X_EXPORT void (*xf86WriteMmio8) (int, void *, unsigned long); | |
1535 | extern _X_EXPORT void (*xf86WriteMmio16) (int, void *, unsigned long); | |
1536 | extern _X_EXPORT void (*xf86WriteMmio32) (int, void *, unsigned long); | |
1537 | extern _X_EXPORT void (*xf86WriteMmioNB8) (int, void *, unsigned long); | |
1538 | extern _X_EXPORT void (*xf86WriteMmioNB16) (int, void *, unsigned long); | |
1539 | extern _X_EXPORT void (*xf86WriteMmioNB32) (int, void *, unsigned long); | |
1540 | extern _X_EXPORT void xf86SlowBCopyFromBus(unsigned char *, unsigned char *, | |
1541 | int); | |
1542 | extern _X_EXPORT void xf86SlowBCopyToBus(unsigned char *, unsigned char *, int); | |
1543 | ||
1544 | /* Some macros to hide the system dependencies for MMIO accesses */ | |
1545 | /* Changed to kill noise generated by gcc's -Wcast-align */ | |
1546 | #define MMIO_IN8(base, offset) (*xf86ReadMmio8)(base, offset) | |
1547 | #define MMIO_IN16(base, offset) (*xf86ReadMmio16)(base, offset) | |
1548 | #ifndef STANDALONE_MMIO | |
1549 | #define MMIO_IN32(base, offset) (*xf86ReadMmio32)(base, offset) | |
1550 | #else | |
1551 | #define MMIO_IN32(base, offset) xf86ReadMmio32(base, offset) | |
1552 | #endif | |
1553 | ||
1554 | #define MMIO_OUT32(base, offset, val) \ | |
1555 | do { \ | |
1556 | write_mem_barrier(); \ | |
1557 | *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val); \ | |
1558 | } while (0) | |
1559 | #define MMIO_ONB32(base, offset, val) \ | |
1560 | *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val) | |
1561 | ||
1562 | #define MMIO_OUT8(base, offset, val) \ | |
1563 | (*xf86WriteMmio8)((CARD8)(val), base, offset) | |
1564 | #define MMIO_OUT16(base, offset, val) \ | |
1565 | (*xf86WriteMmio16)((CARD16)(val), base, offset) | |
1566 | #define MMIO_ONB8(base, offset, val) \ | |
1567 | (*xf86WriteMmioNB8)((CARD8)(val), base, offset) | |
1568 | #define MMIO_ONB16(base, offset, val) \ | |
1569 | (*xf86WriteMmioNB16)((CARD16)(val), base, offset) | |
1570 | #define MMIO_MOVE32(base, offset, val) \ | |
1571 | MMIO_OUT32(base, offset, val) | |
1572 | ||
1573 | #elif defined(__powerpc__) | |
1574 | /* | |
1575 | * we provide byteswapping and no byteswapping functions here | |
1576 | * with byteswapping as default, | |
1577 | * drivers that don't need byteswapping should define PPC_MMIO_IS_BE | |
1578 | */ | |
1579 | #define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset) | |
1580 | #define MMIO_OUT8(base, offset, val) \ | |
1581 | xf86WriteMmio8(base, offset, (CARD8)(val)) | |
1582 | #define MMIO_ONB8(base, offset, val) \ | |
1583 | xf86WriteMmioNB8(base, offset, (CARD8)(val)) | |
1584 | ||
1585 | #if defined(PPC_MMIO_IS_BE) /* No byteswapping */ | |
1586 | #define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset) | |
1587 | #define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset) | |
1588 | #define MMIO_OUT16(base, offset, val) \ | |
1589 | xf86WriteMmio16Be(base, offset, (CARD16)(val)) | |
1590 | #define MMIO_OUT32(base, offset, val) \ | |
1591 | xf86WriteMmio32Be(base, offset, (CARD32)(val)) | |
1592 | #define MMIO_ONB16(base, offset, val) \ | |
1593 | xf86WriteMmioNB16Be(base, offset, (CARD16)(val)) | |
1594 | #define MMIO_ONB32(base, offset, val) \ | |
1595 | xf86WriteMmioNB32Be(base, offset, (CARD32)(val)) | |
1596 | #else /* byteswapping is the default */ | |
1597 | #define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset) | |
1598 | #define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset) | |
1599 | #define MMIO_OUT16(base, offset, val) \ | |
1600 | xf86WriteMmio16Le(base, offset, (CARD16)(val)) | |
1601 | #define MMIO_OUT32(base, offset, val) \ | |
1602 | xf86WriteMmio32Le(base, offset, (CARD32)(val)) | |
1603 | #define MMIO_ONB16(base, offset, val) \ | |
1604 | xf86WriteMmioNB16Le(base, offset, (CARD16)(val)) | |
1605 | #define MMIO_ONB32(base, offset, val) \ | |
1606 | xf86WriteMmioNB32Le(base, offset, (CARD32)(val)) | |
1607 | #endif | |
1608 | ||
1609 | #define MMIO_MOVE32(base, offset, val) \ | |
1610 | xf86WriteMmio32Be(base, offset, (CARD32)(val)) | |
1611 | ||
1612 | #elif defined(__sparc__) || defined(sparc) || defined(__sparc) | |
1613 | /* | |
1614 | * Like powerpc, we provide byteswapping and no byteswapping functions | |
1615 | * here with byteswapping as default, drivers that don't need byteswapping | |
1616 | * should define SPARC_MMIO_IS_BE (perhaps create a generic macro so that we | |
1617 | * do not need to use PPC_MMIO_IS_BE and the sparc one in all the same places | |
1618 | * of drivers?). | |
1619 | */ | |
1620 | #define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset) | |
1621 | #define MMIO_OUT8(base, offset, val) \ | |
1622 | xf86WriteMmio8(base, offset, (CARD8)(val)) | |
1623 | #define MMIO_ONB8(base, offset, val) \ | |
1624 | xf86WriteMmio8NB(base, offset, (CARD8)(val)) | |
1625 | ||
1626 | #if defined(SPARC_MMIO_IS_BE) /* No byteswapping */ | |
1627 | #define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset) | |
1628 | #define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset) | |
1629 | #define MMIO_OUT16(base, offset, val) \ | |
1630 | xf86WriteMmio16Be(base, offset, (CARD16)(val)) | |
1631 | #define MMIO_OUT32(base, offset, val) \ | |
1632 | xf86WriteMmio32Be(base, offset, (CARD32)(val)) | |
1633 | #define MMIO_ONB16(base, offset, val) \ | |
1634 | xf86WriteMmio16BeNB(base, offset, (CARD16)(val)) | |
1635 | #define MMIO_ONB32(base, offset, val) \ | |
1636 | xf86WriteMmio32BeNB(base, offset, (CARD32)(val)) | |
1637 | #else /* byteswapping is the default */ | |
1638 | #define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset) | |
1639 | #define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset) | |
1640 | #define MMIO_OUT16(base, offset, val) \ | |
1641 | xf86WriteMmio16Le(base, offset, (CARD16)(val)) | |
1642 | #define MMIO_OUT32(base, offset, val) \ | |
1643 | xf86WriteMmio32Le(base, offset, (CARD32)(val)) | |
1644 | #define MMIO_ONB16(base, offset, val) \ | |
1645 | xf86WriteMmio16LeNB(base, offset, (CARD16)(val)) | |
1646 | #define MMIO_ONB32(base, offset, val) \ | |
1647 | xf86WriteMmio32LeNB(base, offset, (CARD32)(val)) | |
1648 | #endif | |
1649 | ||
1650 | #define MMIO_MOVE32(base, offset, val) \ | |
1651 | xf86WriteMmio32Be(base, offset, (CARD32)(val)) | |
1652 | ||
1653 | #elif defined(__nds32__) | |
1654 | /* | |
1655 | * we provide byteswapping and no byteswapping functions here | |
1656 | * with no byteswapping as default; when endianness of CPU core | |
1657 | * and I/O devices don't match, byte swapping is necessary | |
1658 | * drivers that need byteswapping should define NDS32_MMIO_SWAP | |
1659 | */ | |
1660 | #define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset) | |
1661 | #define MMIO_OUT8(base, offset, val) \ | |
1662 | xf86WriteMmio8(base, offset, (CARD8)(val)) | |
1663 | #define MMIO_ONB8(base, offset, val) \ | |
1664 | xf86WriteMmioNB8(base, offset, (CARD8)(val)) | |
1665 | ||
1666 | #if defined(NDS32_MMIO_SWAP) /* byteswapping */ | |
1667 | #define MMIO_IN16(base, offset) xf86ReadMmio16Swap(base, offset) | |
1668 | #define MMIO_IN32(base, offset) xf86ReadMmio32Swap(base, offset) | |
1669 | #define MMIO_OUT16(base, offset, val) \ | |
1670 | xf86WriteMmio16Swap(base, offset, (CARD16)(val)) | |
1671 | #define MMIO_OUT32(base, offset, val) \ | |
1672 | xf86WriteMmio32Swap(base, offset, (CARD32)(val)) | |
1673 | #define MMIO_ONB16(base, offset, val) \ | |
1674 | xf86WriteMmioNB16Swap(base, offset, (CARD16)(val)) | |
1675 | #define MMIO_ONB32(base, offset, val) \ | |
1676 | xf86WriteMmioNB32Swap(base, offset, (CARD32)(val)) | |
1677 | #else /* no byteswapping is the default */ | |
1678 | #define MMIO_IN16(base, offset) xf86ReadMmio16(base, offset) | |
1679 | #define MMIO_IN32(base, offset) xf86ReadMmio32(base, offset) | |
1680 | #define MMIO_OUT16(base, offset, val) \ | |
1681 | xf86WriteMmio16(base, offset, (CARD16)(val)) | |
1682 | #define MMIO_OUT32(base, offset, val) \ | |
1683 | xf86WriteMmio32(base, offset, (CARD32)(val)) | |
1684 | #define MMIO_ONB16(base, offset, val) \ | |
1685 | xf86WriteMmioNB16(base, offset, (CARD16)(val)) | |
1686 | #define MMIO_ONB32(base, offset, val) \ | |
1687 | xf86WriteMmioNB32(base, offset, (CARD32)(val)) | |
1688 | #endif | |
1689 | ||
1690 | #define MMIO_MOVE32(base, offset, val) \ | |
1691 | xf86WriteMmio32(base, offset, (CARD32)(val)) | |
1692 | ||
1693 | #ifdef N1213_HC /* for NDS32 N1213 hardcore */ | |
1694 | static __inline__ void | |
1695 | nds32_flush_icache(char *addr) | |
1696 | { | |
1697 | __asm__ volatile ("isync %0;" | |
1698 | "msync;" | |
1699 | "isb;" | |
1700 | "cctl %0,L1I_VA_INVAL;" "isb;"::"r" (addr):"memory"); | |
1701 | } | |
1702 | #else | |
1703 | static __inline__ void | |
1704 | nds32_flush_icache(char *addr) | |
1705 | { | |
1706 | __asm__ volatile ("isync %0;" "isb;"::"r" (addr):"memory"); | |
1707 | } | |
1708 | #endif | |
1709 | ||
1710 | #else /* !__alpha__ && !__powerpc__ && !__sparc__ */ | |
1711 | ||
1712 | #define MMIO_IN8(base, offset) \ | |
1713 | *(volatile CARD8 *)(((CARD8*)(base)) + (offset)) | |
1714 | #define MMIO_IN16(base, offset) \ | |
1715 | *(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset)) | |
1716 | #define MMIO_IN32(base, offset) \ | |
1717 | *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) | |
1718 | #define MMIO_OUT8(base, offset, val) \ | |
1719 | *(volatile CARD8 *)(((CARD8*)(base)) + (offset)) = (val) | |
1720 | #define MMIO_OUT16(base, offset, val) \ | |
1721 | *(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset)) = (val) | |
1722 | #define MMIO_OUT32(base, offset, val) \ | |
1723 | *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val) | |
1724 | #define MMIO_ONB8(base, offset, val) MMIO_OUT8(base, offset, val) | |
1725 | #define MMIO_ONB16(base, offset, val) MMIO_OUT16(base, offset, val) | |
1726 | #define MMIO_ONB32(base, offset, val) MMIO_OUT32(base, offset, val) | |
1727 | ||
1728 | #define MMIO_MOVE32(base, offset, val) MMIO_OUT32(base, offset, val) | |
1729 | ||
1730 | #endif /* __alpha__ */ | |
1731 | ||
1732 | /* | |
1733 | * With Intel, the version in os-support/misc/SlowBcopy.s is used. | |
1734 | * This avoids port I/O during the copy (which causes problems with | |
1735 | * some hardware). | |
1736 | */ | |
1737 | #ifdef __alpha__ | |
1738 | #define slowbcopy_tobus(src,dst,count) xf86SlowBCopyToBus(src,dst,count) | |
1739 | #define slowbcopy_frombus(src,dst,count) xf86SlowBCopyFromBus(src,dst,count) | |
1740 | #else /* __alpha__ */ | |
1741 | #define slowbcopy_tobus(src,dst,count) xf86SlowBcopy(src,dst,count) | |
1742 | #define slowbcopy_frombus(src,dst,count) xf86SlowBcopy(src,dst,count) | |
1743 | #endif /* __alpha__ */ | |
1744 | ||
1745 | #endif /* _COMPILER_H */ |