initial commit
[freebsd-arm:freebsd-arm.git] / amd64 / include / bus.h
1 /*-
2  * Copyright (c) KATO Takenori, 1999.
3  *
4  * All rights reserved.  Unpublished rights reserved under the copyright
5  * laws of Japan.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer as
13  *    the first lines of this file unmodified.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. The name of the author may not be used to endorse or promote products
18  *    derived from this software without specific prior written permission.
19  * 
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  * $FreeBSD$
32  */
33
34 /*      $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $    */
35
36 /*-
37  * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
38  * All rights reserved.
39  *
40  * This code is derived from software contributed to The NetBSD Foundation
41  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
42  * NASA Ames Research Center.
43  *
44  * Redistribution and use in source and binary forms, with or without
45  * modification, are permitted provided that the following conditions
46  * are met:
47  * 1. Redistributions of source code must retain the above copyright
48  *    notice, this list of conditions and the following disclaimer.
49  * 2. Redistributions in binary form must reproduce the above copyright
50  *    notice, this list of conditions and the following disclaimer in the
51  *    documentation and/or other materials provided with the distribution.
52  * 3. All advertising materials mentioning features or use of this software
53  *    must display the following acknowledgement:
54  *      This product includes software developed by the NetBSD
55  *      Foundation, Inc. and its contributors.
56  * 4. Neither the name of The NetBSD Foundation nor the names of its
57  *    contributors may be used to endorse or promote products derived
58  *    from this software without specific prior written permission.
59  *
60  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
61  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
62  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
63  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
64  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
65  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
66  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
67  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
68  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
69  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
70  * POSSIBILITY OF SUCH DAMAGE.
71  */
72
73 /*-
74  * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
75  * Copyright (c) 1996 Christopher G. Demetriou.  All rights reserved.
76  *
77  * Redistribution and use in source and binary forms, with or without
78  * modification, are permitted provided that the following conditions
79  * are met:
80  * 1. Redistributions of source code must retain the above copyright
81  *    notice, this list of conditions and the following disclaimer.
82  * 2. Redistributions in binary form must reproduce the above copyright
83  *    notice, this list of conditions and the following disclaimer in the
84  *    documentation and/or other materials provided with the distribution.
85  * 3. All advertising materials mentioning features or use of this software
86  *    must display the following acknowledgement:
87  *      This product includes software developed by Christopher G. Demetriou
88  *      for the NetBSD Project.
89  * 4. The name of the author may not be used to endorse or promote products
90  *    derived from this software without specific prior written permission
91  *
92  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
93  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
94  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
95  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
96  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
97  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
98  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
99  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
100  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
101  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
102  */
103
104 #ifndef _AMD64_BUS_H_
105 #define _AMD64_BUS_H_
106
107 #include <machine/_bus.h>
108 #include <machine/cpufunc.h>
109
110 /*
111  * Values for the amd64 bus space tag, not to be used directly by MI code.
112  */
113 #define AMD64_BUS_SPACE_IO      0       /* space is i/o space */
114 #define AMD64_BUS_SPACE_MEM     1       /* space is mem space */
115
116 #define BUS_SPACE_MAXSIZE_24BIT 0xFFFFFF
117 #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
118 #define BUS_SPACE_MAXSIZE       0xFFFFFFFF
119 #define BUS_SPACE_MAXADDR_24BIT 0xFFFFFF
120 #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF
121 #define BUS_SPACE_MAXADDR       0xFFFFFFFFFFFFFFFFULL
122
123 #define BUS_SPACE_UNRESTRICTED  (~0)
124
125 /*
126  * Map a region of device bus space into CPU virtual address space.
127  */
128
129 static __inline int bus_space_map(bus_space_tag_t t, bus_addr_t addr,
130                                   bus_size_t size, int flags,
131                                   bus_space_handle_t *bshp);
132
133 static __inline int
134 bus_space_map(bus_space_tag_t t __unused, bus_addr_t addr,
135               bus_size_t size __unused, int flags __unused,
136               bus_space_handle_t *bshp)
137 {
138
139         *bshp = addr;
140         return (0);
141 }
142
143 /*
144  * Unmap a region of device bus space.
145  */
146
147 static __inline void bus_space_unmap(bus_space_tag_t t, bus_space_handle_t bsh,
148                                      bus_size_t size);
149
150 static __inline void
151 bus_space_unmap(bus_space_tag_t t __unused, bus_space_handle_t bsh __unused,
152                 bus_size_t size __unused)
153 {
154 }
155
156 /*
157  * Get a new handle for a subregion of an already-mapped area of bus space.
158  */
159
160 static __inline int bus_space_subregion(bus_space_tag_t t,
161                                         bus_space_handle_t bsh,
162                                         bus_size_t offset, bus_size_t size,
163                                         bus_space_handle_t *nbshp);
164
165 static __inline int
166 bus_space_subregion(bus_space_tag_t t __unused, bus_space_handle_t bsh,
167                     bus_size_t offset, bus_size_t size __unused,
168                     bus_space_handle_t *nbshp)
169 {
170
171         *nbshp = bsh + offset;
172         return (0);
173 }
174
175 /*
176  * Allocate a region of memory that is accessible to devices in bus space.
177  */
178
179 int     bus_space_alloc(bus_space_tag_t t, bus_addr_t rstart,
180                         bus_addr_t rend, bus_size_t size, bus_size_t align,
181                         bus_size_t boundary, int flags, bus_addr_t *addrp,
182                         bus_space_handle_t *bshp);
183
184 /*
185  * Free a region of bus space accessible memory.
186  */
187
188 static __inline void bus_space_free(bus_space_tag_t t, bus_space_handle_t bsh,
189                                     bus_size_t size);
190
191 static __inline void
192 bus_space_free(bus_space_tag_t t __unused, bus_space_handle_t bsh __unused,
193                bus_size_t size __unused)
194 {
195 }
196
197
198 /*
199  * Read a 1, 2, 4, or 8 byte quantity from bus space
200  * described by tag/handle/offset.
201  */
202 static __inline u_int8_t bus_space_read_1(bus_space_tag_t tag,
203                                           bus_space_handle_t handle,
204                                           bus_size_t offset);
205
206 static __inline u_int16_t bus_space_read_2(bus_space_tag_t tag,
207                                            bus_space_handle_t handle,
208                                            bus_size_t offset);
209
210 static __inline u_int32_t bus_space_read_4(bus_space_tag_t tag,
211                                            bus_space_handle_t handle,
212                                            bus_size_t offset);
213
214 static __inline u_int8_t
215 bus_space_read_1(bus_space_tag_t tag, bus_space_handle_t handle,
216                  bus_size_t offset)
217 {
218
219         if (tag == AMD64_BUS_SPACE_IO)
220                 return (inb(handle + offset));
221         return (*(volatile u_int8_t *)(handle + offset));
222 }
223
224 static __inline u_int16_t
225 bus_space_read_2(bus_space_tag_t tag, bus_space_handle_t handle,
226                  bus_size_t offset)
227 {
228
229         if (tag == AMD64_BUS_SPACE_IO)
230                 return (inw(handle + offset));
231         return (*(volatile u_int16_t *)(handle + offset));
232 }
233
234 static __inline u_int32_t
235 bus_space_read_4(bus_space_tag_t tag, bus_space_handle_t handle,
236                  bus_size_t offset)
237 {
238
239         if (tag == AMD64_BUS_SPACE_IO)
240                 return (inl(handle + offset));
241         return (*(volatile u_int32_t *)(handle + offset));
242 }
243
244 #if 0   /* Cause a link error for bus_space_read_8 */
245 #define bus_space_read_8(t, h, o)       !!! bus_space_read_8 unimplemented !!!
246 #endif
247
248 /*
249  * Read `count' 1, 2, 4, or 8 byte quantities from bus space
250  * described by tag/handle/offset and copy into buffer provided.
251  */
252 static __inline void bus_space_read_multi_1(bus_space_tag_t tag,
253                                             bus_space_handle_t bsh,
254                                             bus_size_t offset, u_int8_t *addr,
255                                             size_t count);
256
257 static __inline void bus_space_read_multi_2(bus_space_tag_t tag,
258                                             bus_space_handle_t bsh,
259                                             bus_size_t offset, u_int16_t *addr,
260                                             size_t count);
261
262 static __inline void bus_space_read_multi_4(bus_space_tag_t tag,
263                                             bus_space_handle_t bsh,
264                                             bus_size_t offset, u_int32_t *addr,
265                                             size_t count);
266
267 static __inline void
268 bus_space_read_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
269                        bus_size_t offset, u_int8_t *addr, size_t count)
270 {
271
272         if (tag == AMD64_BUS_SPACE_IO)
273                 insb(bsh + offset, addr, count);
274         else {
275 #ifdef __GNUCLIKE_ASM
276                 __asm __volatile("                              \n\
277                         cld                                     \n\
278                 1:      movb (%2),%%al                          \n\
279                         stosb                                   \n\
280                         loop 1b"                                :
281                     "=D" (addr), "=c" (count)                   :
282                     "r" (bsh + offset), "0" (addr), "1" (count) :
283                     "%eax", "memory");
284 #endif
285         }
286 }
287
288 static __inline void
289 bus_space_read_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
290                        bus_size_t offset, u_int16_t *addr, size_t count)
291 {
292
293         if (tag == AMD64_BUS_SPACE_IO)
294                 insw(bsh + offset, addr, count);
295         else {
296 #ifdef __GNUCLIKE_ASM
297                 __asm __volatile("                              \n\
298                         cld                                     \n\
299                 1:      movw (%2),%%ax                          \n\
300                         stosw                                   \n\
301                         loop 1b"                                :
302                     "=D" (addr), "=c" (count)                   :
303                     "r" (bsh + offset), "0" (addr), "1" (count) :
304                     "%eax", "memory");
305 #endif
306         }
307 }
308
309 static __inline void
310 bus_space_read_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
311                        bus_size_t offset, u_int32_t *addr, size_t count)
312 {
313
314         if (tag == AMD64_BUS_SPACE_IO)
315                 insl(bsh + offset, addr, count);
316         else {
317 #ifdef __GNUCLIKE_ASM
318                 __asm __volatile("                              \n\
319                         cld                                     \n\
320                 1:      movl (%2),%%eax                         \n\
321                         stosl                                   \n\
322                         loop 1b"                                :
323                     "=D" (addr), "=c" (count)                   :
324                     "r" (bsh + offset), "0" (addr), "1" (count) :
325                     "%eax", "memory");
326 #endif
327         }
328 }
329
330 #if 0   /* Cause a link error for bus_space_read_multi_8 */
331 #define bus_space_read_multi_8  !!! bus_space_read_multi_8 unimplemented !!!
332 #endif
333
334 /*
335  * Read `count' 1, 2, 4, or 8 byte quantities from bus space
336  * described by tag/handle and starting at `offset' and copy into
337  * buffer provided.
338  */
339 static __inline void bus_space_read_region_1(bus_space_tag_t tag,
340                                              bus_space_handle_t bsh,
341                                              bus_size_t offset, u_int8_t *addr,
342                                              size_t count);
343
344 static __inline void bus_space_read_region_2(bus_space_tag_t tag,
345                                              bus_space_handle_t bsh,
346                                              bus_size_t offset, u_int16_t *addr,
347                                              size_t count);
348
349 static __inline void bus_space_read_region_4(bus_space_tag_t tag,
350                                              bus_space_handle_t bsh,
351                                              bus_size_t offset, u_int32_t *addr,
352                                              size_t count);
353
354
355 static __inline void
356 bus_space_read_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
357                         bus_size_t offset, u_int8_t *addr, size_t count)
358 {
359
360         if (tag == AMD64_BUS_SPACE_IO) {
361                 int _port_ = bsh + offset;
362 #ifdef __GNUCLIKE_ASM
363                 __asm __volatile("                              \n\
364                         cld                                     \n\
365                 1:      inb %w2,%%al                            \n\
366                         stosb                                   \n\
367                         incl %2                                 \n\
368                         loop 1b"                                :
369                     "=D" (addr), "=c" (count), "=d" (_port_)    :
370                     "0" (addr), "1" (count), "2" (_port_)       :
371                     "%eax", "memory", "cc");
372 #endif
373         } else {
374                 bus_space_handle_t _port_ = bsh + offset;
375 #ifdef __GNUCLIKE_ASM
376                 __asm __volatile("                              \n\
377                         cld                                     \n\
378                         repne                                   \n\
379                         movsb"                                  :
380                     "=D" (addr), "=c" (count), "=S" (_port_)    :
381                     "0" (addr), "1" (count), "2" (_port_)       :
382                     "memory", "cc");
383 #endif
384         }
385 }
386
387 static __inline void
388 bus_space_read_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
389                         bus_size_t offset, u_int16_t *addr, size_t count)
390 {
391
392         if (tag == AMD64_BUS_SPACE_IO) {
393                 int _port_ = bsh + offset;
394 #ifdef __GNUCLIKE_ASM
395                 __asm __volatile("                              \n\
396                         cld                                     \n\
397                 1:      inw %w2,%%ax                            \n\
398                         stosw                                   \n\
399                         addl $2,%2                              \n\
400                         loop 1b"                                :
401                     "=D" (addr), "=c" (count), "=d" (_port_)    :
402                     "0" (addr), "1" (count), "2" (_port_)       :
403                     "%eax", "memory", "cc");
404 #endif
405         } else {
406                 bus_space_handle_t _port_ = bsh + offset;
407 #ifdef __GNUCLIKE_ASM
408                 __asm __volatile("                              \n\
409                         cld                                     \n\
410                         repne                                   \n\
411                         movsw"                                  :
412                     "=D" (addr), "=c" (count), "=S" (_port_)    :
413                     "0" (addr), "1" (count), "2" (_port_)       :
414                     "memory", "cc");
415 #endif
416         }
417 }
418
419 static __inline void
420 bus_space_read_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
421                         bus_size_t offset, u_int32_t *addr, size_t count)
422 {
423
424         if (tag == AMD64_BUS_SPACE_IO) {
425                 int _port_ = bsh + offset;
426 #ifdef __GNUCLIKE_ASM
427                 __asm __volatile("                              \n\
428                         cld                                     \n\
429                 1:      inl %w2,%%eax                           \n\
430                         stosl                                   \n\
431                         addl $4,%2                              \n\
432                         loop 1b"                                :
433                     "=D" (addr), "=c" (count), "=d" (_port_)    :
434                     "0" (addr), "1" (count), "2" (_port_)       :
435                     "%eax", "memory", "cc");
436 #endif
437         } else {
438                 bus_space_handle_t _port_ = bsh + offset;
439 #ifdef __GNUCLIKE_ASM
440                 __asm __volatile("                              \n\
441                         cld                                     \n\
442                         repne                                   \n\
443                         movsl"                                  :
444                     "=D" (addr), "=c" (count), "=S" (_port_)    :
445                     "0" (addr), "1" (count), "2" (_port_)       :
446                     "memory", "cc");
447 #endif
448         }
449 }
450
451 #if 0   /* Cause a link error for bus_space_read_region_8 */
452 #define bus_space_read_region_8 !!! bus_space_read_region_8 unimplemented !!!
453 #endif
454
455 /*
456  * Write the 1, 2, 4, or 8 byte value `value' to bus space
457  * described by tag/handle/offset.
458  */
459
460 static __inline void bus_space_write_1(bus_space_tag_t tag,
461                                        bus_space_handle_t bsh,
462                                        bus_size_t offset, u_int8_t value);
463
464 static __inline void bus_space_write_2(bus_space_tag_t tag,
465                                        bus_space_handle_t bsh,
466                                        bus_size_t offset, u_int16_t value);
467
468 static __inline void bus_space_write_4(bus_space_tag_t tag,
469                                        bus_space_handle_t bsh,
470                                        bus_size_t offset, u_int32_t value);
471
472 static __inline void
473 bus_space_write_1(bus_space_tag_t tag, bus_space_handle_t bsh,
474                        bus_size_t offset, u_int8_t value)
475 {
476
477         if (tag == AMD64_BUS_SPACE_IO)
478                 outb(bsh + offset, value);
479         else
480                 *(volatile u_int8_t *)(bsh + offset) = value;
481 }
482
483 static __inline void
484 bus_space_write_2(bus_space_tag_t tag, bus_space_handle_t bsh,
485                        bus_size_t offset, u_int16_t value)
486 {
487
488         if (tag == AMD64_BUS_SPACE_IO)
489                 outw(bsh + offset, value);
490         else
491                 *(volatile u_int16_t *)(bsh + offset) = value;
492 }
493
494 static __inline void
495 bus_space_write_4(bus_space_tag_t tag, bus_space_handle_t bsh,
496                        bus_size_t offset, u_int32_t value)
497 {
498
499         if (tag == AMD64_BUS_SPACE_IO)
500                 outl(bsh + offset, value);
501         else
502                 *(volatile u_int32_t *)(bsh + offset) = value;
503 }
504
505 #if 0   /* Cause a link error for bus_space_write_8 */
506 #define bus_space_write_8       !!! bus_space_write_8 not implemented !!!
507 #endif
508
509 /*
510  * Write `count' 1, 2, 4, or 8 byte quantities from the buffer
511  * provided to bus space described by tag/handle/offset.
512  */
513
514 static __inline void bus_space_write_multi_1(bus_space_tag_t tag,
515                                              bus_space_handle_t bsh,
516                                              bus_size_t offset,
517                                              const u_int8_t *addr,
518                                              size_t count);
519 static __inline void bus_space_write_multi_2(bus_space_tag_t tag,
520                                              bus_space_handle_t bsh,
521                                              bus_size_t offset,
522                                              const u_int16_t *addr,
523                                              size_t count);
524
525 static __inline void bus_space_write_multi_4(bus_space_tag_t tag,
526                                              bus_space_handle_t bsh,
527                                              bus_size_t offset,
528                                              const u_int32_t *addr,
529                                              size_t count);
530
531 static __inline void
532 bus_space_write_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
533                         bus_size_t offset, const u_int8_t *addr, size_t count)
534 {
535
536         if (tag == AMD64_BUS_SPACE_IO)
537                 outsb(bsh + offset, addr, count);
538         else {
539 #ifdef __GNUCLIKE_ASM
540                 __asm __volatile("                              \n\
541                         cld                                     \n\
542                 1:      lodsb                                   \n\
543                         movb %%al,(%2)                          \n\
544                         loop 1b"                                :
545                     "=S" (addr), "=c" (count)                   :
546                     "r" (bsh + offset), "0" (addr), "1" (count) :
547                     "%eax", "memory", "cc");
548 #endif
549         }
550 }
551
552 static __inline void
553 bus_space_write_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
554                         bus_size_t offset, const u_int16_t *addr, size_t count)
555 {
556
557         if (tag == AMD64_BUS_SPACE_IO)
558                 outsw(bsh + offset, addr, count);
559         else {
560 #ifdef __GNUCLIKE_ASM
561                 __asm __volatile("                              \n\
562                         cld                                     \n\
563                 1:      lodsw                                   \n\
564                         movw %%ax,(%2)                          \n\
565                         loop 1b"                                :
566                     "=S" (addr), "=c" (count)                   :
567                     "r" (bsh + offset), "0" (addr), "1" (count) :
568                     "%eax", "memory", "cc");
569 #endif
570         }
571 }
572
573 static __inline void
574 bus_space_write_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
575                         bus_size_t offset, const u_int32_t *addr, size_t count)
576 {
577
578         if (tag == AMD64_BUS_SPACE_IO)
579                 outsl(bsh + offset, addr, count);
580         else {
581 #ifdef __GNUCLIKE_ASM
582                 __asm __volatile("                              \n\
583                         cld                                     \n\
584                 1:      lodsl                                   \n\
585                         movl %%eax,(%2)                         \n\
586                         loop 1b"                                :
587                     "=S" (addr), "=c" (count)                   :
588                     "r" (bsh + offset), "0" (addr), "1" (count) :
589                     "%eax", "memory", "cc");
590 #endif
591         }
592 }
593
594 #if 0   /* Cause a link error for bus_space_write_multi_8 */
595 #define bus_space_write_multi_8(t, h, o, a, c)                          \
596                         !!! bus_space_write_multi_8 unimplemented !!!
597 #endif
598
599 /*
600  * Write `count' 1, 2, 4, or 8 byte quantities from the buffer provided
601  * to bus space described by tag/handle starting at `offset'.
602  */
603
604 static __inline void bus_space_write_region_1(bus_space_tag_t tag,
605                                               bus_space_handle_t bsh,
606                                               bus_size_t offset,
607                                               const u_int8_t *addr,
608                                               size_t count);
609 static __inline void bus_space_write_region_2(bus_space_tag_t tag,
610                                               bus_space_handle_t bsh,
611                                               bus_size_t offset,
612                                               const u_int16_t *addr,
613                                               size_t count);
614 static __inline void bus_space_write_region_4(bus_space_tag_t tag,
615                                               bus_space_handle_t bsh,
616                                               bus_size_t offset,
617                                               const u_int32_t *addr,
618                                               size_t count);
619
620 static __inline void
621 bus_space_write_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
622                          bus_size_t offset, const u_int8_t *addr, size_t count)
623 {
624
625         if (tag == AMD64_BUS_SPACE_IO) {
626                 int _port_ = bsh + offset;
627 #ifdef __GNUCLIKE_ASM
628                 __asm __volatile("                              \n\
629                         cld                                     \n\
630                 1:      lodsb                                   \n\
631                         outb %%al,%w0                           \n\
632                         incl %0                                 \n\
633                         loop 1b"                                :
634                     "=d" (_port_), "=S" (addr), "=c" (count)    :
635                     "0" (_port_), "1" (addr), "2" (count)       :
636                     "%eax", "memory", "cc");
637 #endif
638         } else {
639                 bus_space_handle_t _port_ = bsh + offset;
640 #ifdef __GNUCLIKE_ASM
641                 __asm __volatile("                              \n\
642                         cld                                     \n\
643                         repne                                   \n\
644                         movsb"                                  :
645                     "=D" (_port_), "=S" (addr), "=c" (count)    :
646                     "0" (_port_), "1" (addr), "2" (count)       :
647                     "memory", "cc");
648 #endif
649         }
650 }
651
652 static __inline void
653 bus_space_write_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
654                          bus_size_t offset, const u_int16_t *addr, size_t count)
655 {
656
657         if (tag == AMD64_BUS_SPACE_IO) {
658                 int _port_ = bsh + offset;
659 #ifdef __GNUCLIKE_ASM
660                 __asm __volatile("                              \n\
661                         cld                                     \n\
662                 1:      lodsw                                   \n\
663                         outw %%ax,%w0                           \n\
664                         addl $2,%0                              \n\
665                         loop 1b"                                :
666                     "=d" (_port_), "=S" (addr), "=c" (count)    :
667                     "0" (_port_), "1" (addr), "2" (count)       :
668                     "%eax", "memory", "cc");
669 #endif
670         } else {
671                 bus_space_handle_t _port_ = bsh + offset;
672 #ifdef __GNUCLIKE_ASM
673                 __asm __volatile("                              \n\
674                         cld                                     \n\
675                         repne                                   \n\
676                         movsw"                                  :
677                     "=D" (_port_), "=S" (addr), "=c" (count)    :
678                     "0" (_port_), "1" (addr), "2" (count)       :
679                     "memory", "cc");
680 #endif
681         }
682 }
683
684 static __inline void
685 bus_space_write_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
686                          bus_size_t offset, const u_int32_t *addr, size_t count)
687 {
688
689         if (tag == AMD64_BUS_SPACE_IO) {
690                 int _port_ = bsh + offset;
691 #ifdef __GNUCLIKE_ASM
692                 __asm __volatile("                              \n\
693                         cld                                     \n\
694                 1:      lodsl                                   \n\
695                         outl %%eax,%w0                          \n\
696                         addl $4,%0                              \n\
697                         loop 1b"                                :
698                     "=d" (_port_), "=S" (addr), "=c" (count)    :
699                     "0" (_port_), "1" (addr), "2" (count)       :
700                     "%eax", "memory", "cc");
701 #endif
702         } else {
703                 bus_space_handle_t _port_ = bsh + offset;
704 #ifdef __GNUCLIKE_ASM
705                 __asm __volatile("                              \n\
706                         cld                                     \n\
707                         repne                                   \n\
708                         movsl"                                  :
709                     "=D" (_port_), "=S" (addr), "=c" (count)    :
710                     "0" (_port_), "1" (addr), "2" (count)       :
711                     "memory", "cc");
712 #endif
713         }
714 }
715
716 #if 0   /* Cause a link error for bus_space_write_region_8 */
717 #define bus_space_write_region_8                                        \
718                         !!! bus_space_write_region_8 unimplemented !!!
719 #endif
720
721 /*
722  * Write the 1, 2, 4, or 8 byte value `val' to bus space described
723  * by tag/handle/offset `count' times.
724  */
725
726 static __inline void bus_space_set_multi_1(bus_space_tag_t tag,
727                                            bus_space_handle_t bsh,
728                                            bus_size_t offset,
729                                            u_int8_t value, size_t count);
730 static __inline void bus_space_set_multi_2(bus_space_tag_t tag,
731                                            bus_space_handle_t bsh,
732                                            bus_size_t offset,
733                                            u_int16_t value, size_t count);
734 static __inline void bus_space_set_multi_4(bus_space_tag_t tag,
735                                            bus_space_handle_t bsh,
736                                            bus_size_t offset,
737                                            u_int32_t value, size_t count);
738
739 static __inline void
740 bus_space_set_multi_1(bus_space_tag_t tag, bus_space_handle_t bsh,
741                       bus_size_t offset, u_int8_t value, size_t count)
742 {
743         bus_space_handle_t addr = bsh + offset;
744
745         if (tag == AMD64_BUS_SPACE_IO)
746                 while (count--)
747                         outb(addr, value);
748         else
749                 while (count--)
750                         *(volatile u_int8_t *)(addr) = value;
751 }
752
753 static __inline void
754 bus_space_set_multi_2(bus_space_tag_t tag, bus_space_handle_t bsh,
755                      bus_size_t offset, u_int16_t value, size_t count)
756 {
757         bus_space_handle_t addr = bsh + offset;
758
759         if (tag == AMD64_BUS_SPACE_IO)
760                 while (count--)
761                         outw(addr, value);
762         else
763                 while (count--)
764                         *(volatile u_int16_t *)(addr) = value;
765 }
766
767 static __inline void
768 bus_space_set_multi_4(bus_space_tag_t tag, bus_space_handle_t bsh,
769                       bus_size_t offset, u_int32_t value, size_t count)
770 {
771         bus_space_handle_t addr = bsh + offset;
772
773         if (tag == AMD64_BUS_SPACE_IO)
774                 while (count--)
775                         outl(addr, value);
776         else
777                 while (count--)
778                         *(volatile u_int32_t *)(addr) = value;
779 }
780
781 #if 0   /* Cause a link error for bus_space_set_multi_8 */
782 #define bus_space_set_multi_8 !!! bus_space_set_multi_8 unimplemented !!!
783 #endif
784
785 /*
786  * Write `count' 1, 2, 4, or 8 byte value `val' to bus space described
787  * by tag/handle starting at `offset'.
788  */
789
790 static __inline void bus_space_set_region_1(bus_space_tag_t tag,
791                                             bus_space_handle_t bsh,
792                                             bus_size_t offset, u_int8_t value,
793                                             size_t count);
794 static __inline void bus_space_set_region_2(bus_space_tag_t tag,
795                                             bus_space_handle_t bsh,
796                                             bus_size_t offset, u_int16_t value,
797                                             size_t count);
798 static __inline void bus_space_set_region_4(bus_space_tag_t tag,
799                                             bus_space_handle_t bsh,
800                                             bus_size_t offset, u_int32_t value,
801                                             size_t count);
802
803 static __inline void
804 bus_space_set_region_1(bus_space_tag_t tag, bus_space_handle_t bsh,
805                        bus_size_t offset, u_int8_t value, size_t count)
806 {
807         bus_space_handle_t addr = bsh + offset;
808
809         if (tag == AMD64_BUS_SPACE_IO)
810                 for (; count != 0; count--, addr++)
811                         outb(addr, value);
812         else
813                 for (; count != 0; count--, addr++)
814                         *(volatile u_int8_t *)(addr) = value;
815 }
816
817 static __inline void
818 bus_space_set_region_2(bus_space_tag_t tag, bus_space_handle_t bsh,
819                        bus_size_t offset, u_int16_t value, size_t count)
820 {
821         bus_space_handle_t addr = bsh + offset;
822
823         if (tag == AMD64_BUS_SPACE_IO)
824                 for (; count != 0; count--, addr += 2)
825                         outw(addr, value);
826         else
827                 for (; count != 0; count--, addr += 2)
828                         *(volatile u_int16_t *)(addr) = value;
829 }
830
831 static __inline void
832 bus_space_set_region_4(bus_space_tag_t tag, bus_space_handle_t bsh,
833                        bus_size_t offset, u_int32_t value, size_t count)
834 {
835         bus_space_handle_t addr = bsh + offset;
836
837         if (tag == AMD64_BUS_SPACE_IO)
838                 for (; count != 0; count--, addr += 4)
839                         outl(addr, value);
840         else
841                 for (; count != 0; count--, addr += 4)
842                         *(volatile u_int32_t *)(addr) = value;
843 }
844
845 #if 0   /* Cause a link error for bus_space_set_region_8 */
846 #define bus_space_set_region_8  !!! bus_space_set_region_8 unimplemented !!!
847 #endif
848
849 /*
850  * Copy `count' 1, 2, 4, or 8 byte values from bus space starting
851  * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2.
852  */
853
854 static __inline void bus_space_copy_region_1(bus_space_tag_t tag,
855                                              bus_space_handle_t bsh1,
856                                              bus_size_t off1,
857                                              bus_space_handle_t bsh2,
858                                              bus_size_t off2, size_t count);
859
860 static __inline void bus_space_copy_region_2(bus_space_tag_t tag,
861                                              bus_space_handle_t bsh1,
862                                              bus_size_t off1,
863                                              bus_space_handle_t bsh2,
864                                              bus_size_t off2, size_t count);
865
866 static __inline void bus_space_copy_region_4(bus_space_tag_t tag,
867                                              bus_space_handle_t bsh1,
868                                              bus_size_t off1,
869                                              bus_space_handle_t bsh2,
870                                              bus_size_t off2, size_t count);
871
872 static __inline void
873 bus_space_copy_region_1(bus_space_tag_t tag, bus_space_handle_t bsh1,
874                         bus_size_t off1, bus_space_handle_t bsh2,
875                         bus_size_t off2, size_t count)
876 {
877         bus_space_handle_t addr1 = bsh1 + off1;
878         bus_space_handle_t addr2 = bsh2 + off2;
879
880         if (tag == AMD64_BUS_SPACE_IO) {
881                 if (addr1 >= addr2) {
882                         /* src after dest: copy forward */
883                         for (; count != 0; count--, addr1++, addr2++)
884                                 outb(addr2, inb(addr1));
885                 } else {
886                         /* dest after src: copy backwards */
887                         for (addr1 += (count - 1), addr2 += (count - 1);
888                             count != 0; count--, addr1--, addr2--)
889                                 outb(addr2, inb(addr1));
890                 }
891         } else {
892                 if (addr1 >= addr2) {
893                         /* src after dest: copy forward */
894                         for (; count != 0; count--, addr1++, addr2++)
895                                 *(volatile u_int8_t *)(addr2) =
896                                     *(volatile u_int8_t *)(addr1);
897                 } else {
898                         /* dest after src: copy backwards */
899                         for (addr1 += (count - 1), addr2 += (count - 1);
900                             count != 0; count--, addr1--, addr2--)
901                                 *(volatile u_int8_t *)(addr2) =
902                                     *(volatile u_int8_t *)(addr1);
903                 }
904         }
905 }
906
907 static __inline void
908 bus_space_copy_region_2(bus_space_tag_t tag, bus_space_handle_t bsh1,
909                         bus_size_t off1, bus_space_handle_t bsh2,
910                         bus_size_t off2, size_t count)
911 {
912         bus_space_handle_t addr1 = bsh1 + off1;
913         bus_space_handle_t addr2 = bsh2 + off2;
914
915         if (tag == AMD64_BUS_SPACE_IO) {
916                 if (addr1 >= addr2) {
917                         /* src after dest: copy forward */
918                         for (; count != 0; count--, addr1 += 2, addr2 += 2)
919                                 outw(addr2, inw(addr1));
920                 } else {
921                         /* dest after src: copy backwards */
922                         for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1);
923                             count != 0; count--, addr1 -= 2, addr2 -= 2)
924                                 outw(addr2, inw(addr1));
925                 }
926         } else {
927                 if (addr1 >= addr2) {
928                         /* src after dest: copy forward */
929                         for (; count != 0; count--, addr1 += 2, addr2 += 2)
930                                 *(volatile u_int16_t *)(addr2) =
931                                     *(volatile u_int16_t *)(addr1);
932                 } else {
933                         /* dest after src: copy backwards */
934                         for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1);
935                             count != 0; count--, addr1 -= 2, addr2 -= 2)
936                                 *(volatile u_int16_t *)(addr2) =
937                                     *(volatile u_int16_t *)(addr1);
938                 }
939         }
940 }
941
942 static __inline void
943 bus_space_copy_region_4(bus_space_tag_t tag, bus_space_handle_t bsh1,
944                         bus_size_t off1, bus_space_handle_t bsh2,
945                         bus_size_t off2, size_t count)
946 {
947         bus_space_handle_t addr1 = bsh1 + off1;
948         bus_space_handle_t addr2 = bsh2 + off2;
949
950         if (tag == AMD64_BUS_SPACE_IO) {
951                 if (addr1 >= addr2) {
952                         /* src after dest: copy forward */
953                         for (; count != 0; count--, addr1 += 4, addr2 += 4)
954                                 outl(addr2, inl(addr1));
955                 } else {
956                         /* dest after src: copy backwards */
957                         for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1);
958                             count != 0; count--, addr1 -= 4, addr2 -= 4)
959                                 outl(addr2, inl(addr1));
960                 }
961         } else {
962                 if (addr1 >= addr2) {
963                         /* src after dest: copy forward */
964                         for (; count != 0; count--, addr1 += 4, addr2 += 4)
965                                 *(volatile u_int32_t *)(addr2) =
966                                     *(volatile u_int32_t *)(addr1);
967                 } else {
968                         /* dest after src: copy backwards */
969                         for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1);
970                             count != 0; count--, addr1 -= 4, addr2 -= 4)
971                                 *(volatile u_int32_t *)(addr2) =
972                                     *(volatile u_int32_t *)(addr1);
973                 }
974         }
975 }
976
977 #if 0   /* Cause a link error for bus_space_copy_8 */
978 #define bus_space_copy_region_8 !!! bus_space_copy_region_8 unimplemented !!!
979 #endif
980
981 /*
982  * Bus read/write barrier methods.
983  *
984  *      void bus_space_barrier(bus_space_tag_t tag, bus_space_handle_t bsh,
985  *                             bus_size_t offset, bus_size_t len, int flags);
986  *
987  *
988  * Note that BUS_SPACE_BARRIER_WRITE doesn't do anything other than
989  * prevent reordering by the compiler; all Intel x86 processors currently
990  * retire operations outside the CPU in program order.
991  */
992 #define BUS_SPACE_BARRIER_READ  0x01            /* force read barrier */
993 #define BUS_SPACE_BARRIER_WRITE 0x02            /* force write barrier */
994
995 static __inline void
996 bus_space_barrier(bus_space_tag_t tag __unused, bus_space_handle_t bsh __unused,
997                   bus_size_t offset __unused, bus_size_t len __unused, int flags)
998 {
999 #ifdef __GNUCLIKE_ASM
1000         if (flags & BUS_SPACE_BARRIER_READ)
1001                 __asm __volatile("lock; addl $0,0(%%rsp)" : : : "memory");
1002         else
1003                 __asm __volatile("" : : : "memory");
1004 #endif
1005 }
1006
1007 #ifdef BUS_SPACE_NO_LEGACY
1008 #undef inb
1009 #undef outb
1010 #define inb(a) compiler_error
1011 #define inw(a) compiler_error
1012 #define inl(a) compiler_error
1013 #define outb(a, b) compiler_error
1014 #define outw(a, b) compiler_error
1015 #define outl(a, b) compiler_error
1016 #endif
1017
1018 #include <machine/bus_dma.h>
1019
1020 /*
1021  * Stream accesses are the same as normal accesses on amd64; there are no
1022  * supported bus systems with an endianess different from the host one.
1023  */
1024 #define bus_space_read_stream_1(t, h, o)        bus_space_read_1((t), (h), (o))
1025 #define bus_space_read_stream_2(t, h, o)        bus_space_read_2((t), (h), (o))
1026 #define bus_space_read_stream_4(t, h, o)        bus_space_read_4((t), (h), (o))
1027
1028 #define bus_space_read_multi_stream_1(t, h, o, a, c) \
1029         bus_space_read_multi_1((t), (h), (o), (a), (c))
1030 #define bus_space_read_multi_stream_2(t, h, o, a, c) \
1031         bus_space_read_multi_2((t), (h), (o), (a), (c))
1032 #define bus_space_read_multi_stream_4(t, h, o, a, c) \
1033         bus_space_read_multi_4((t), (h), (o), (a), (c))
1034
1035 #define bus_space_write_stream_1(t, h, o, v) \
1036         bus_space_write_1((t), (h), (o), (v))
1037 #define bus_space_write_stream_2(t, h, o, v) \
1038         bus_space_write_2((t), (h), (o), (v))
1039 #define bus_space_write_stream_4(t, h, o, v) \
1040         bus_space_write_4((t), (h), (o), (v))
1041
1042 #define bus_space_write_multi_stream_1(t, h, o, a, c) \
1043         bus_space_write_multi_1((t), (h), (o), (a), (c))
1044 #define bus_space_write_multi_stream_2(t, h, o, a, c) \
1045         bus_space_write_multi_2((t), (h), (o), (a), (c))
1046 #define bus_space_write_multi_stream_4(t, h, o, a, c) \
1047         bus_space_write_multi_4((t), (h), (o), (a), (c))
1048
1049 #define bus_space_set_multi_stream_1(t, h, o, v, c) \
1050         bus_space_set_multi_1((t), (h), (o), (v), (c))
1051 #define bus_space_set_multi_stream_2(t, h, o, v, c) \
1052         bus_space_set_multi_2((t), (h), (o), (v), (c))
1053 #define bus_space_set_multi_stream_4(t, h, o, v, c) \
1054         bus_space_set_multi_4((t), (h), (o), (v), (c))
1055
1056 #define bus_space_read_region_stream_1(t, h, o, a, c) \
1057         bus_space_read_region_1((t), (h), (o), (a), (c))
1058 #define bus_space_read_region_stream_2(t, h, o, a, c) \
1059         bus_space_read_region_2((t), (h), (o), (a), (c))
1060 #define bus_space_read_region_stream_4(t, h, o, a, c) \
1061         bus_space_read_region_4((t), (h), (o), (a), (c))
1062
1063 #define bus_space_write_region_stream_1(t, h, o, a, c) \
1064         bus_space_write_region_1((t), (h), (o), (a), (c))
1065 #define bus_space_write_region_stream_2(t, h, o, a, c) \
1066         bus_space_write_region_2((t), (h), (o), (a), (c))
1067 #define bus_space_write_region_stream_4(t, h, o, a, c) \
1068         bus_space_write_region_4((t), (h), (o), (a), (c))
1069
1070 #define bus_space_set_region_stream_1(t, h, o, v, c) \
1071         bus_space_set_region_1((t), (h), (o), (v), (c))
1072 #define bus_space_set_region_stream_2(t, h, o, v, c) \
1073         bus_space_set_region_2((t), (h), (o), (v), (c))
1074 #define bus_space_set_region_stream_4(t, h, o, v, c) \
1075         bus_space_set_region_4((t), (h), (o), (v), (c))
1076
1077 #define bus_space_copy_region_stream_1(t, h1, o1, h2, o2, c) \
1078         bus_space_copy_region_1((t), (h1), (o1), (h2), (o2), (c))
1079 #define bus_space_copy_region_stream_2(t, h1, o1, h2, o2, c) \
1080         bus_space_copy_region_2((t), (h1), (o1), (h2), (o2), (c))
1081 #define bus_space_copy_region_stream_4(t, h1, o1, h2, o2, c) \
1082         bus_space_copy_region_4((t), (h1), (o1), (h2), (o2), (c))
1083
1084 #endif /* _AMD64_BUS_H_ */