FreeBSD/Linux Kernel Cross Reference
sys/ia64/include/bus.h
1 /*-
2 * Copyright (c) 2009 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /* $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $ */
28
29 /*-
30 * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
31 * All rights reserved.
32 *
33 * This code is derived from software contributed to The NetBSD Foundation
34 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
35 * NASA Ames Research Center.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed by the NetBSD
48 * Foundation, Inc. and its contributors.
49 * 4. Neither the name of The NetBSD Foundation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
54 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63 * POSSIBILITY OF SUCH DAMAGE.
64 */
65
66 /*-
67 * Copyright (c) 1996 Charles M. Hannum. All rights reserved.
68 * Copyright (c) 1996 Christopher G. Demetriou. All rights reserved.
69 *
70 * Redistribution and use in source and binary forms, with or without
71 * modification, are permitted provided that the following conditions
72 * are met:
73 * 1. Redistributions of source code must retain the above copyright
74 * notice, this list of conditions and the following disclaimer.
75 * 2. Redistributions in binary form must reproduce the above copyright
76 * notice, this list of conditions and the following disclaimer in the
77 * documentation and/or other materials provided with the distribution.
78 * 3. All advertising materials mentioning features or use of this software
79 * must display the following acknowledgement:
80 * This product includes software developed by Christopher G. Demetriou
81 * for the NetBSD Project.
82 * 4. The name of the author may not be used to endorse or promote products
83 * derived from this software without specific prior written permission
84 *
85 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
86 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
87 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
88 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
89 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
90 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
91 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
92 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
93 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
94 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
95 */
96 /* $FreeBSD: head/sys/ia64/include/bus.h 203883 2010-02-14 16:56:24Z marcel $ */
97
98 #ifndef _MACHINE_BUS_H_
99 #define _MACHINE_BUS_H_
100
101 #include <machine/_bus.h>
102 #include <machine/cpufunc.h>
103
104 /*
105 * I/O port reads with ia32 semantics.
106 */
107 #define inb bus_space_read_io_1
108 #define inw bus_space_read_io_2
109 #define inl bus_space_read_io_4
110
111 #define outb bus_space_write_io_1
112 #define outw bus_space_write_io_2
113 #define outl bus_space_write_io_4
114
115 /*
116 * Values for the ia64 bus space tag, not to be used directly by MI code.
117 */
118 #define IA64_BUS_SPACE_IO 0 /* space is i/o space */
119 #define IA64_BUS_SPACE_MEM 1 /* space is mem space */
120
121 #define BUS_SPACE_BARRIER_READ 0x01 /* force read barrier */
122 #define BUS_SPACE_BARRIER_WRITE 0x02 /* force write barrier */
123
124 #define BUS_SPACE_MAXSIZE_24BIT 0xFFFFFF
125 #define BUS_SPACE_MAXSIZE_32BIT 0xFFFFFFFF
126 #define BUS_SPACE_MAXSIZE 0xFFFFFFFFFFFFFFFF
127 #define BUS_SPACE_MAXADDR_24BIT 0xFFFFFF
128 #define BUS_SPACE_MAXADDR_32BIT 0xFFFFFFFF
129 #define BUS_SPACE_MAXADDR 0xFFFFFFFFFFFFFFFF
130
131 #define BUS_SPACE_UNRESTRICTED (~0)
132
133
134 /*
135 * Map and unmap a region of device bus space into CPU virtual address space.
136 */
137 int
138 bus_space_map(bus_space_tag_t, bus_addr_t, bus_size_t, int,
139 bus_space_handle_t *);
140
141 void
142 bus_space_unmap(bus_space_tag_t, bus_space_handle_t, bus_size_t size);
143
144 /*
145 * Get a new handle for a subregion of an already-mapped area of bus space.
146 */
147 static __inline int
148 bus_space_subregion(bus_space_tag_t bst, bus_space_handle_t bsh,
149 bus_size_t ofs, bus_size_t size __unused, bus_space_handle_t *nbshp)
150 {
151 *nbshp = bsh + ofs;
152 return (0);
153 }
154
155
156 /*
157 * Allocate a region of memory that is accessible to devices in bus space.
158 */
159 int
160 bus_space_alloc(bus_space_tag_t bst, bus_addr_t rstart, bus_addr_t rend,
161 bus_size_t size, bus_size_t align, bus_size_t boundary, int flags,
162 bus_addr_t *addrp, bus_space_handle_t *bshp);
163
164
165 /*
166 * Free a region of bus space accessible memory.
167 */
168 void
169 bus_space_free(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t size);
170
171
172 /*
173 * Bus read/write barrier method.
174 */
175 static __inline void
176 bus_space_barrier(bus_space_tag_t bst __unused, bus_space_handle_t bsh __unused,
177 bus_size_t ofs __unused, bus_size_t size __unused, int flags __unused)
178 {
179 ia64_mf_a();
180 ia64_mf();
181 }
182
183
184 /*
185 * Read 1 unit of data from bus space described by the tag, handle and ofs
186 * tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
187 * data is returned.
188 */
189 uint8_t bus_space_read_io_1(u_long);
190 uint16_t bus_space_read_io_2(u_long);
191 uint32_t bus_space_read_io_4(u_long);
192 uint64_t bus_space_read_io_8(u_long);
193
194 static __inline uint8_t
195 bus_space_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
196 {
197 uint8_t val;
198
199 val = (__predict_false(bst == IA64_BUS_SPACE_IO))
200 ? bus_space_read_io_1(bsh + ofs)
201 : ia64_ld1((void *)(bsh + ofs));
202 return (val);
203 }
204
205 static __inline uint16_t
206 bus_space_read_2(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
207 {
208 uint16_t val;
209
210 val = (__predict_false(bst == IA64_BUS_SPACE_IO))
211 ? bus_space_read_io_2(bsh + ofs)
212 : ia64_ld2((void *)(bsh + ofs));
213 return (val);
214 }
215
216 static __inline uint32_t
217 bus_space_read_4(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
218 {
219 uint32_t val;
220
221 val = (__predict_false(bst == IA64_BUS_SPACE_IO))
222 ? bus_space_read_io_4(bsh + ofs)
223 : ia64_ld4((void *)(bsh + ofs));
224 return (val);
225 }
226
227 static __inline uint64_t
228 bus_space_read_8(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs)
229 {
230 uint64_t val;
231
232 val = (__predict_false(bst == IA64_BUS_SPACE_IO))
233 ? bus_space_read_io_8(bsh + ofs)
234 : ia64_ld8((void *)(bsh + ofs));
235 return (val);
236 }
237
238
239 /*
240 * Write 1 unit of data to bus space described by the tag, handle and ofs
241 * tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
242 * data is passed by value.
243 */
244 void bus_space_write_io_1(u_long, uint8_t);
245 void bus_space_write_io_2(u_long, uint16_t);
246 void bus_space_write_io_4(u_long, uint32_t);
247 void bus_space_write_io_8(u_long, uint64_t);
248
249 static __inline void
250 bus_space_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
251 uint8_t val)
252 {
253
254 if (__predict_false(bst == IA64_BUS_SPACE_IO))
255 bus_space_write_io_1(bsh + ofs, val);
256 else
257 ia64_st1((void *)(bsh + ofs), val);
258 }
259
260 static __inline void
261 bus_space_write_2(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
262 uint16_t val)
263 {
264
265 if (__predict_false(bst == IA64_BUS_SPACE_IO))
266 bus_space_write_io_2(bsh + ofs, val);
267 else
268 ia64_st2((void *)(bsh + ofs), val);
269 }
270
271 static __inline void
272 bus_space_write_4(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
273 uint32_t val)
274 {
275
276 if (__predict_false(bst == IA64_BUS_SPACE_IO))
277 bus_space_write_io_4(bsh + ofs, val);
278 else
279 ia64_st4((void *)(bsh + ofs), val);
280 }
281
282 static __inline void
283 bus_space_write_8(bus_space_tag_t bst, bus_space_handle_t bsh, bus_size_t ofs,
284 uint64_t val)
285 {
286
287 if (__predict_false(bst == IA64_BUS_SPACE_IO))
288 bus_space_write_io_8(bsh + ofs, val);
289 else
290 ia64_st8((void *)(bsh + ofs), val);
291 }
292
293
294 /*
295 * Read count units of data from bus space described by the tag, handle and
296 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
297 * data is returned in the buffer passed by reference.
298 */
299 void bus_space_read_multi_io_1(u_long, uint8_t *, size_t);
300 void bus_space_read_multi_io_2(u_long, uint16_t *, size_t);
301 void bus_space_read_multi_io_4(u_long, uint32_t *, size_t);
302 void bus_space_read_multi_io_8(u_long, uint64_t *, size_t);
303
304 static __inline void
305 bus_space_read_multi_1(bus_space_tag_t bst, bus_space_handle_t bsh,
306 bus_size_t ofs, uint8_t *bufp, size_t count)
307 {
308
309 if (__predict_false(bst == IA64_BUS_SPACE_IO))
310 bus_space_read_multi_io_1(bsh + ofs, bufp, count);
311 else {
312 while (count-- > 0)
313 *bufp++ = ia64_ld1((void *)(bsh + ofs));
314 }
315 }
316
317 static __inline void
318 bus_space_read_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh,
319 bus_size_t ofs, uint16_t *bufp, size_t count)
320 {
321
322 if (__predict_false(bst == IA64_BUS_SPACE_IO))
323 bus_space_read_multi_io_2(bsh + ofs, bufp, count);
324 else {
325 while (count-- > 0)
326 *bufp++ = ia64_ld2((void *)(bsh + ofs));
327 }
328 }
329
330 static __inline void
331 bus_space_read_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh,
332 bus_size_t ofs, uint32_t *bufp, size_t count)
333 {
334
335 if (__predict_false(bst == IA64_BUS_SPACE_IO))
336 bus_space_read_multi_io_4(bsh + ofs, bufp, count);
337 else {
338 while (count-- > 0)
339 *bufp++ = ia64_ld4((void *)(bsh + ofs));
340 }
341 }
342
343 static __inline void
344 bus_space_read_multi_8(bus_space_tag_t bst, bus_space_handle_t bsh,
345 bus_size_t ofs, uint64_t *bufp, size_t count)
346 {
347
348 if (__predict_false(bst == IA64_BUS_SPACE_IO))
349 bus_space_read_multi_io_8(bsh + ofs, bufp, count);
350 else {
351 while (count-- > 0)
352 *bufp++ = ia64_ld8((void *)(bsh + ofs));
353 }
354 }
355
356
357 /*
358 * Write count units of data to bus space described by the tag, handle and
359 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
360 * data is read from the buffer passed by reference.
361 */
362 void bus_space_write_multi_io_1(u_long, const uint8_t *, size_t);
363 void bus_space_write_multi_io_2(u_long, const uint16_t *, size_t);
364 void bus_space_write_multi_io_4(u_long, const uint32_t *, size_t);
365 void bus_space_write_multi_io_8(u_long, const uint64_t *, size_t);
366
367 static __inline void
368 bus_space_write_multi_1(bus_space_tag_t bst, bus_space_handle_t bsh,
369 bus_size_t ofs, const uint8_t *bufp, size_t count)
370 {
371
372 if (__predict_false(bst == IA64_BUS_SPACE_IO))
373 bus_space_write_multi_io_1(bsh + ofs, bufp, count);
374 else {
375 while (count-- > 0)
376 ia64_st1((void *)(bsh + ofs), *bufp++);
377 }
378 }
379
380 static __inline void
381 bus_space_write_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh,
382 bus_size_t ofs, const uint16_t *bufp, size_t count)
383 {
384
385 if (__predict_false(bst == IA64_BUS_SPACE_IO))
386 bus_space_write_multi_io_2(bsh + ofs, bufp, count);
387 else {
388 while (count-- > 0)
389 ia64_st2((void *)(bsh + ofs), *bufp++);
390 }
391 }
392
393 static __inline void
394 bus_space_write_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh,
395 bus_size_t ofs, const uint32_t *bufp, size_t count)
396 {
397
398 if (__predict_false(bst == IA64_BUS_SPACE_IO))
399 bus_space_write_multi_io_4(bsh + ofs, bufp, count);
400 else {
401 while (count-- > 0)
402 ia64_st4((void *)(bsh + ofs), *bufp++);
403 }
404 }
405
406 static __inline void
407 bus_space_write_multi_8(bus_space_tag_t bst, bus_space_handle_t bsh,
408 bus_size_t ofs, const uint64_t *bufp, size_t count)
409 {
410
411 if (__predict_false(bst == IA64_BUS_SPACE_IO))
412 bus_space_write_multi_io_8(bsh + ofs, bufp, count);
413 else {
414 while (count-- > 0)
415 ia64_st8((void *)(bsh + ofs), *bufp++);
416 }
417 }
418
419
420 /*
421 * Read count units of data from bus space described by the tag, handle and
422 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
423 * data is written to the buffer passed by reference and read from successive
424 * bus space addresses. Access is unordered.
425 */
426 void bus_space_read_region_io_1(u_long, uint8_t *, size_t);
427 void bus_space_read_region_io_2(u_long, uint16_t *, size_t);
428 void bus_space_read_region_io_4(u_long, uint32_t *, size_t);
429 void bus_space_read_region_io_8(u_long, uint64_t *, size_t);
430
431 static __inline void
432 bus_space_read_region_1(bus_space_tag_t bst, bus_space_handle_t bsh,
433 bus_size_t ofs, uint8_t *bufp, size_t count)
434 {
435
436 if (__predict_false(bst == IA64_BUS_SPACE_IO))
437 bus_space_read_region_io_1(bsh + ofs, bufp, count);
438 else {
439 uint8_t *bsp = (void *)(bsh + ofs);
440 while (count-- > 0)
441 *bufp++ = ia64_ld1(bsp++);
442 }
443 }
444
445 static __inline void
446 bus_space_read_region_2(bus_space_tag_t bst, bus_space_handle_t bsh,
447 bus_size_t ofs, uint16_t *bufp, size_t count)
448 {
449
450 if (__predict_false(bst == IA64_BUS_SPACE_IO))
451 bus_space_read_region_io_2(bsh + ofs, bufp, count);
452 else {
453 uint16_t *bsp = (void *)(bsh + ofs);
454 while (count-- > 0)
455 *bufp++ = ia64_ld2(bsp++);
456 }
457 }
458
459 static __inline void
460 bus_space_read_region_4(bus_space_tag_t bst, bus_space_handle_t bsh,
461 bus_size_t ofs, uint32_t *bufp, size_t count)
462 {
463
464 if (__predict_false(bst == IA64_BUS_SPACE_IO))
465 bus_space_read_region_io_4(bsh + ofs, bufp, count);
466 else {
467 uint32_t *bsp = (void *)(bsh + ofs);
468 while (count-- > 0)
469 *bufp++ = ia64_ld4(bsp++);
470 }
471 }
472
473 static __inline void
474 bus_space_read_region_8(bus_space_tag_t bst, bus_space_handle_t bsh,
475 bus_size_t ofs, uint64_t *bufp, size_t count)
476 {
477
478 if (__predict_false(bst == IA64_BUS_SPACE_IO))
479 bus_space_read_region_io_8(bsh + ofs, bufp, count);
480 else {
481 uint64_t *bsp = (void *)(bsh + ofs);
482 while (count-- > 0)
483 *bufp++ = ia64_ld8(bsp++);
484 }
485 }
486
487
488 /*
489 * Write count units of data from bus space described by the tag, handle and
490 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
491 * data is read from the buffer passed by reference and written to successive
492 * bus space addresses. Access is unordered.
493 */
494 void bus_space_write_region_io_1(u_long, const uint8_t *, size_t);
495 void bus_space_write_region_io_2(u_long, const uint16_t *, size_t);
496 void bus_space_write_region_io_4(u_long, const uint32_t *, size_t);
497 void bus_space_write_region_io_8(u_long, const uint64_t *, size_t);
498
499 static __inline void
500 bus_space_write_region_1(bus_space_tag_t bst, bus_space_handle_t bsh,
501 bus_size_t ofs, const uint8_t *bufp, size_t count)
502 {
503
504 if (__predict_false(bst == IA64_BUS_SPACE_IO))
505 bus_space_write_region_io_1(bsh + ofs, bufp, count);
506 else {
507 uint8_t *bsp = (void *)(bsh + ofs);
508 while (count-- > 0)
509 ia64_st1(bsp++, *bufp++);
510 }
511 }
512
513 static __inline void
514 bus_space_write_region_2(bus_space_tag_t bst, bus_space_handle_t bsh,
515 bus_size_t ofs, const uint16_t *bufp, size_t count)
516 {
517
518 if (__predict_false(bst == IA64_BUS_SPACE_IO))
519 bus_space_write_region_io_2(bsh + ofs, bufp, count);
520 else {
521 uint16_t *bsp = (void *)(bsh + ofs);
522 while (count-- > 0)
523 ia64_st2(bsp++, *bufp++);
524 }
525 }
526
527 static __inline void
528 bus_space_write_region_4(bus_space_tag_t bst, bus_space_handle_t bsh,
529 bus_size_t ofs, const uint32_t *bufp, size_t count)
530 {
531
532 if (__predict_false(bst == IA64_BUS_SPACE_IO))
533 bus_space_write_region_io_4(bsh + ofs, bufp, count);
534 else {
535 uint32_t *bsp = (void *)(bsh + ofs);
536 while (count-- > 0)
537 ia64_st4(bsp++, *bufp++);
538 }
539 }
540
541 static __inline void
542 bus_space_write_region_8(bus_space_tag_t bst, bus_space_handle_t bsh,
543 bus_size_t ofs, const uint64_t *bufp, size_t count)
544 {
545
546 if (__predict_false(bst == IA64_BUS_SPACE_IO))
547 bus_space_write_region_io_8(bsh + ofs, bufp, count);
548 else {
549 uint64_t *bsp = (void *)(bsh + ofs);
550 while (count-- > 0)
551 ia64_st8(bsp++, *bufp++);
552 }
553 }
554
555
556 /*
557 * Write count units of data from bus space described by the tag, handle and
558 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
559 * data is passed by value. Writes are unordered.
560 */
561 static __inline void
562 bus_space_set_multi_1(bus_space_tag_t bst, bus_space_handle_t bsh,
563 bus_size_t ofs, uint8_t val, size_t count)
564 {
565
566 while (count-- > 0)
567 bus_space_write_1(bst, bsh, ofs, val);
568 }
569
570 static __inline void
571 bus_space_set_multi_2(bus_space_tag_t bst, bus_space_handle_t bsh,
572 bus_size_t ofs, uint16_t val, size_t count)
573 {
574
575 while (count-- > 0)
576 bus_space_write_2(bst, bsh, ofs, val);
577 }
578
579 static __inline void
580 bus_space_set_multi_4(bus_space_tag_t bst, bus_space_handle_t bsh,
581 bus_size_t ofs, uint32_t val, size_t count)
582 {
583
584 while (count-- > 0)
585 bus_space_write_4(bst, bsh, ofs, val);
586 }
587
588 static __inline void
589 bus_space_set_multi_8(bus_space_tag_t bst, bus_space_handle_t bsh,
590 bus_size_t ofs, uint64_t val, size_t count)
591 {
592
593 while (count-- > 0)
594 bus_space_write_8(bst, bsh, ofs, val);
595 }
596
597
598 /*
599 * Write count units of data from bus space described by the tag, handle and
600 * ofs tuple. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes. The
601 * data is passed by value and written to successive bus space addresses.
602 * Writes are unordered.
603 */
604 void bus_space_set_region_io_1(u_long, uint8_t, size_t);
605 void bus_space_set_region_io_2(u_long, uint16_t, size_t);
606 void bus_space_set_region_io_4(u_long, uint32_t, size_t);
607 void bus_space_set_region_io_8(u_long, uint64_t, size_t);
608
609 static __inline void
610 bus_space_set_region_1(bus_space_tag_t bst, bus_space_handle_t bsh,
611 bus_size_t ofs, uint8_t val, size_t count)
612 {
613
614 if (__predict_false(bst == IA64_BUS_SPACE_IO))
615 bus_space_set_region_io_1(bsh + ofs, val, count);
616 else {
617 uint8_t *bsp = (void *)(bsh + ofs);
618 while (count-- > 0)
619 ia64_st1(bsp++, val);
620 }
621 }
622
623 static __inline void
624 bus_space_set_region_2(bus_space_tag_t bst, bus_space_handle_t bsh,
625 bus_size_t ofs, uint16_t val, size_t count)
626 {
627
628 if (__predict_false(bst == IA64_BUS_SPACE_IO))
629 bus_space_set_region_io_2(bsh + ofs, val, count);
630 else {
631 uint16_t *bsp = (void *)(bsh + ofs);
632 while (count-- > 0)
633 ia64_st2(bsp++, val);
634 }
635 }
636
637 static __inline void
638 bus_space_set_region_4(bus_space_tag_t bst, bus_space_handle_t bsh,
639 bus_size_t ofs, uint32_t val, size_t count)
640 {
641
642 if (__predict_false(bst == IA64_BUS_SPACE_IO))
643 bus_space_set_region_io_4(bsh + ofs, val, count);
644 else {
645 uint32_t *bsp = (void *)(bsh + ofs);
646 while (count-- > 0)
647 ia64_st4(bsp++, val);
648 }
649 }
650
651 static __inline void
652 bus_space_set_region_8(bus_space_tag_t bst, bus_space_handle_t bsh,
653 bus_size_t ofs, uint64_t val, size_t count)
654 {
655
656 if (__predict_false(bst == IA64_BUS_SPACE_IO))
657 bus_space_set_region_io_4(bsh + ofs, val, count);
658 else {
659 uint64_t *bsp = (void *)(bsh + ofs);
660 while (count-- > 0)
661 ia64_st8(bsp++, val);
662 }
663 }
664
665
666 /*
667 * Copy count units of data from bus space described by the tag and the first
668 * handle and ofs pair to bus space described by the tag and the second handle
669 * and ofs pair. A unit of data can be 1 byte, 2 bytes, 4 bytes or 8 bytes.
670 * The data is read from successive bus space addresses and also written to
671 * successive bus space addresses. Both reads and writes are unordered.
672 */
673 void bus_space_copy_region_io_1(u_long, u_long, size_t);
674 void bus_space_copy_region_io_2(u_long, u_long, size_t);
675 void bus_space_copy_region_io_4(u_long, u_long, size_t);
676 void bus_space_copy_region_io_8(u_long, u_long, size_t);
677
678 static __inline void
679 bus_space_copy_region_1(bus_space_tag_t bst, bus_space_handle_t sbsh,
680 bus_size_t sofs, bus_space_handle_t dbsh, bus_size_t dofs, size_t count)
681 {
682 uint8_t *dst, *src;
683
684 if (__predict_false(bst == IA64_BUS_SPACE_IO)) {
685 bus_space_copy_region_io_1(sbsh + sofs, dbsh + dofs, count);
686 return;
687 }
688
689 src = (void *)(sbsh + sofs);
690 dst = (void *)(dbsh + dofs);
691 if (src < dst) {
692 src += count - 1;
693 dst += count - 1;
694 while (count-- > 0)
695 ia64_st1(dst--, ia64_ld1(src--));
696 } else {
697 while (count-- > 0)
698 ia64_st1(dst++, ia64_ld1(src++));
699 }
700 }
701
702 static __inline void
703 bus_space_copy_region_2(bus_space_tag_t bst, bus_space_handle_t sbsh,
704 bus_size_t sofs, bus_space_handle_t dbsh, bus_size_t dofs, size_t count)
705 {
706 uint16_t *dst, *src;
707
708 if (__predict_false(bst == IA64_BUS_SPACE_IO)) {
709 bus_space_copy_region_io_2(sbsh + sofs, dbsh + dofs, count);
710 return;
711 }
712
713 src = (void *)(sbsh + sofs);
714 dst = (void *)(dbsh + dofs);
715 if (src < dst) {
716 src += count - 1;
717 dst += count - 1;
718 while (count-- > 0)
719 ia64_st2(dst--, ia64_ld2(src--));
720 } else {
721 while (count-- > 0)
722 ia64_st2(dst++, ia64_ld2(src++));
723 }
724 }
725
726 static __inline void
727 bus_space_copy_region_4(bus_space_tag_t bst, bus_space_handle_t sbsh,
728 bus_size_t sofs, bus_space_handle_t dbsh, bus_size_t dofs, size_t count)
729 {
730 uint32_t *dst, *src;
731
732 if (__predict_false(bst == IA64_BUS_SPACE_IO)) {
733 bus_space_copy_region_io_4(sbsh + sofs, dbsh + dofs, count);
734 return;
735 }
736
737 src = (void *)(sbsh + sofs);
738 dst = (void *)(dbsh + dofs);
739 if (src < dst) {
740 src += count - 1;
741 dst += count - 1;
742 while (count-- > 0)
743 ia64_st4(dst--, ia64_ld4(src--));
744 } else {
745 while (count-- > 0)
746 ia64_st4(dst++, ia64_ld4(src++));
747 }
748 }
749
750 static __inline void
751 bus_space_copy_region_8(bus_space_tag_t bst, bus_space_handle_t sbsh,
752 bus_size_t sofs, bus_space_handle_t dbsh, bus_size_t dofs, size_t count)
753 {
754 uint64_t *dst, *src;
755
756 if (__predict_false(bst == IA64_BUS_SPACE_IO)) {
757 bus_space_copy_region_io_8(sbsh + sofs, dbsh + dofs, count);
758 return;
759 }
760
761 src = (void *)(sbsh + sofs);
762 dst = (void *)(dbsh + dofs);
763 if (src < dst) {
764 src += count - 1;
765 dst += count - 1;
766 while (count-- > 0)
767 ia64_st8(dst--, ia64_ld8(src--));
768 } else {
769 while (count-- > 0)
770 ia64_st8(dst++, ia64_ld8(src++));
771 }
772 }
773
774
775 /*
776 * Stream accesses are the same as normal accesses on ia64; there are no
777 * supported bus systems with an endianess different from the host one.
778 */
779
780 #define bus_space_read_stream_1 bus_space_read_1
781 #define bus_space_read_stream_2 bus_space_read_2
782 #define bus_space_read_stream_4 bus_space_read_4
783 #define bus_space_read_stream_8 bus_space_read_8
784
785 #define bus_space_write_stream_1 bus_space_write_1
786 #define bus_space_write_stream_2 bus_space_write_2
787 #define bus_space_write_stream_4 bus_space_write_4
788 #define bus_space_write_stream_8 bus_space_write_8
789
790 #define bus_space_read_multi_stream_1 bus_space_read_multi_1
791 #define bus_space_read_multi_stream_2 bus_space_read_multi_2
792 #define bus_space_read_multi_stream_4 bus_space_read_multi_4
793 #define bus_space_read_multi_stream_8 bus_space_read_multi_8
794
795 #define bus_space_write_multi_stream_1 bus_space_write_multi_1
796 #define bus_space_write_multi_stream_2 bus_space_write_multi_2
797 #define bus_space_write_multi_stream_4 bus_space_write_multi_4
798 #define bus_space_write_multi_stream_8 bus_space_write_multi_8
799
800 #define bus_space_read_region_stream_1 bus_space_read_region_1
801 #define bus_space_read_region_stream_2 bus_space_read_region_2
802 #define bus_space_read_region_stream_4 bus_space_read_region_4
803 #define bus_space_read_region_stream_8 bus_space_read_region_8
804
805 #define bus_space_write_region_stream_1 bus_space_write_region_1
806 #define bus_space_write_region_stream_2 bus_space_write_region_2
807 #define bus_space_write_region_stream_4 bus_space_write_region_4
808 #define bus_space_write_region_stream_8 bus_space_write_region_8
809
810 #define bus_space_set_multi_stream_1 bus_space_set_multi_1
811 #define bus_space_set_multi_stream_2 bus_space_set_multi_2
812 #define bus_space_set_multi_stream_4 bus_space_set_multi_4
813 #define bus_space_set_multi_stream_8 bus_space_set_multi_8
814
815 #define bus_space_set_region_stream_1 bus_space_set_region_1
816 #define bus_space_set_region_stream_2 bus_space_set_region_2
817 #define bus_space_set_region_stream_4 bus_space_set_region_4
818 #define bus_space_set_region_stream_8 bus_space_set_region_8
819
820 #define bus_space_copy_region_stream_1 bus_space_copy_region_1
821 #define bus_space_copy_region_stream_2 bus_space_copy_region_2
822 #define bus_space_copy_region_stream_4 bus_space_copy_region_4
823 #define bus_space_copy_region_stream_8 bus_space_copy_region_8
824
825 #include <machine/bus_dma.h>
826
827 #endif /* _MACHINE_BUS_H_ */
Cache object: 8f1e692fe4c75ab60d2e9f3c4de2f2f2
|