1 /* $NetBSD: bus.h,v 1.12 1997/10/01 08:25:15 fvdl Exp $ */
2 /*-
3 * $Id: bus.h,v 1.6 2007/08/09 11:23:32 katta Exp $
4 *
5 * SPDX-License-Identifier: BSD-2-Clause-NetBSD AND BSD-4-Clause
6 *
7 * Copyright (c) 1996, 1997 The NetBSD Foundation, Inc.
8 * All rights reserved.
9 *
10 * This code is derived from software contributed to The NetBSD Foundation
11 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
12 * NASA Ames Research Center.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
16 * are met:
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
27 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 * POSSIBILITY OF SUCH DAMAGE.
34 */
35
36 /*
37 * Copyright (c) 1996 Charles M. Hannum. All rights reserved.
38 * Copyright (c) 1996 Christopher G. Demetriou. All rights reserved.
39 *
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
42 * are met:
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 * 3. All advertising materials mentioning features or use of this software
49 * must display the following acknowledgement:
50 * This product includes software developed by Christopher G. Demetriou
51 * for the NetBSD Project.
52 * 4. The name of the author may not be used to endorse or promote products
53 * derived from this software without specific prior written permission
54 *
55 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
56 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
57 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
58 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
59 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
60 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
61 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
62 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
63 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
64 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
65 *
66 * from: src/sys/alpha/include/bus.h,v 1.5 1999/08/28 00:38:40 peter
67 * $FreeBSD$
68 */
69 #include <sys/cdefs.h>
70 __FBSDID("$FreeBSD$");
71
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/bus.h>
75 #include <sys/kernel.h>
76 #include <sys/malloc.h>
77 #include <sys/ktr.h>
78
79 #include <vm/vm.h>
80 #include <vm/pmap.h>
81 #include <vm/vm_kern.h>
82 #include <vm/vm_extern.h>
83
84 #include <machine/bus.h>
85 #include <machine/cache.h>
86
87 static struct bus_space generic_space = {
88 /* cookie */
89 .bs_cookie = (void *) 0,
90
91 /* mapping/unmapping */
92 .bs_map = generic_bs_map,
93 .bs_unmap = generic_bs_unmap,
94 .bs_subregion = generic_bs_subregion,
95
96 /* allocation/deallocation */
97 .bs_alloc = generic_bs_alloc,
98 .bs_free = generic_bs_free,
99
100 /* barrier */
101 .bs_barrier = generic_bs_barrier,
102
103 /* read (single) */
104 .bs_r_1 = generic_bs_r_1,
105 .bs_r_2 = generic_bs_r_2,
106 .bs_r_4 = generic_bs_r_4,
107 .bs_r_8 = generic_bs_r_8,
108
109 /* read multiple */
110 .bs_rm_1 = generic_bs_rm_1,
111 .bs_rm_2 = generic_bs_rm_2,
112 .bs_rm_4 = generic_bs_rm_4,
113 .bs_rm_8 = generic_bs_rm_8,
114
115 /* read region */
116 .bs_rr_1 = generic_bs_rr_1,
117 .bs_rr_2 = generic_bs_rr_2,
118 .bs_rr_4 = generic_bs_rr_4,
119 .bs_rr_8 = generic_bs_rr_8,
120
121 /* write (single) */
122 .bs_w_1 = generic_bs_w_1,
123 .bs_w_2 = generic_bs_w_2,
124 .bs_w_4 = generic_bs_w_4,
125 .bs_w_8 = generic_bs_w_8,
126
127 /* write multiple */
128 .bs_wm_1 = generic_bs_wm_1,
129 .bs_wm_2 = generic_bs_wm_2,
130 .bs_wm_4 = generic_bs_wm_4,
131 .bs_wm_8 = generic_bs_wm_8,
132
133 /* write region */
134 .bs_wr_1 = generic_bs_wr_1,
135 .bs_wr_2 = generic_bs_wr_2,
136 .bs_wr_4 = generic_bs_wr_4,
137 .bs_wr_8 = generic_bs_wr_8,
138
139 /* set multiple */
140 .bs_sm_1 = generic_bs_sm_1,
141 .bs_sm_2 = generic_bs_sm_2,
142 .bs_sm_4 = generic_bs_sm_4,
143 .bs_sm_8 = generic_bs_sm_8,
144
145 /* set region */
146 .bs_sr_1 = generic_bs_sr_1,
147 .bs_sr_2 = generic_bs_sr_2,
148 .bs_sr_4 = generic_bs_sr_4,
149 .bs_sr_8 = generic_bs_sr_8,
150
151 /* copy */
152 .bs_c_1 = generic_bs_c_1,
153 .bs_c_2 = generic_bs_c_2,
154 .bs_c_4 = generic_bs_c_4,
155 .bs_c_8 = generic_bs_c_8,
156
157 /* read (single) stream */
158 .bs_r_1_s = generic_bs_r_1,
159 .bs_r_2_s = generic_bs_r_2,
160 .bs_r_4_s = generic_bs_r_4,
161 .bs_r_8_s = generic_bs_r_8,
162
163 /* read multiple stream */
164 .bs_rm_1_s = generic_bs_rm_1,
165 .bs_rm_2_s = generic_bs_rm_2,
166 .bs_rm_4_s = generic_bs_rm_4,
167 .bs_rm_8_s = generic_bs_rm_8,
168
169 /* read region stream */
170 .bs_rr_1_s = generic_bs_rr_1,
171 .bs_rr_2_s = generic_bs_rr_2,
172 .bs_rr_4_s = generic_bs_rr_4,
173 .bs_rr_8_s = generic_bs_rr_8,
174
175 /* write (single) stream */
176 .bs_w_1_s = generic_bs_w_1,
177 .bs_w_2_s = generic_bs_w_2,
178 .bs_w_4_s = generic_bs_w_4,
179 .bs_w_8_s = generic_bs_w_8,
180
181 /* write multiple stream */
182 .bs_wm_1_s = generic_bs_wm_1,
183 .bs_wm_2_s = generic_bs_wm_2,
184 .bs_wm_4_s = generic_bs_wm_4,
185 .bs_wm_8_s = generic_bs_wm_8,
186
187 /* write region stream */
188 .bs_wr_1_s = generic_bs_wr_1,
189 .bs_wr_2_s = generic_bs_wr_2,
190 .bs_wr_4_s = generic_bs_wr_4,
191 .bs_wr_8_s = generic_bs_wr_8,
192 };
193
194 /* Ultra-gross kludge */
195 #if defined(CPU_CNMIPS) && (defined(__mips_n32) || defined(__mips_o32))
196 #include <contrib/octeon-sdk/cvmx.h>
197 #define rd8(a) cvmx_read64_uint8(a)
198 #define rd16(a) cvmx_read64_uint16(a)
199 #define rd32(a) cvmx_read64_uint32(a)
200 #define rd64(a) cvmx_read64_uint64(a)
201 #define wr8(a, v) cvmx_write64_uint8(a, v)
202 #define wr16(a, v) cvmx_write64_uint16(a, v)
203 #define wr32(a, v) cvmx_write64_uint32(a, v)
204 #define wr64(a, v) cvmx_write64_uint64(a, v)
205 #else
206 #define rd8(a) readb(a)
207 #define rd16(a) readw(a)
208 #define rd32(a) readl(a)
209 #ifdef readq
210 #define rd64(a) readq((a))
211 #endif
212 #define wr8(a, v) writeb(a, v)
213 #define wr16(a, v) writew(a, v)
214 #define wr32(a, v) writel(a, v)
215 #ifdef writeq
216 #define wr64(a, v) writeq(a, v)
217 #endif
218 #endif
219
220 /* generic bus_space tag */
221 bus_space_tag_t mips_bus_space_generic = &generic_space;
222
223 int
224 generic_bs_map(void *t __unused, bus_addr_t addr,
225 bus_size_t size, int flags __unused,
226 bus_space_handle_t *bshp)
227 {
228
229 *bshp = (bus_space_handle_t)pmap_mapdev((vm_paddr_t)addr,
230 (vm_size_t)size);
231 return (0);
232 }
233
234 void
235 generic_bs_unmap(void *t __unused, bus_space_handle_t bh,
236 bus_size_t size)
237 {
238
239 pmap_unmapdev((vm_offset_t)bh, (vm_size_t)size);
240 }
241
242 int
243 generic_bs_subregion(void *t __unused, bus_space_handle_t handle,
244 bus_size_t offset, bus_size_t size __unused,
245 bus_space_handle_t *bshp)
246 {
247
248 *bshp = handle + offset;
249 return (0);
250 }
251
252 int
253 generic_bs_alloc(void *t, bus_addr_t rstart, bus_addr_t rend,
254 bus_size_t size, bus_size_t alignment, bus_size_t boundary, int flags,
255 bus_addr_t *bpap, bus_space_handle_t *bshp)
256 {
257
258 panic("%s: not implemented", __func__);
259 }
260
261 void
262 generic_bs_free(void *t, bus_space_handle_t bsh, bus_size_t size)
263 {
264
265 panic("%s: not implemented", __func__);
266 }
267
268 uint8_t
269 generic_bs_r_1(void *t, bus_space_handle_t handle,
270 bus_size_t offset)
271 {
272
273 return (rd8(handle + offset));
274 }
275
276 uint16_t
277 generic_bs_r_2(void *t, bus_space_handle_t handle,
278 bus_size_t offset)
279 {
280
281 return (rd16(handle + offset));
282 }
283
284 uint32_t
285 generic_bs_r_4(void *t, bus_space_handle_t handle,
286 bus_size_t offset)
287 {
288
289 return (rd32(handle + offset));
290 }
291
292 uint64_t
293 generic_bs_r_8(void *t, bus_space_handle_t handle, bus_size_t offset)
294 {
295
296 #ifdef rd64
297 return(rd64(handle + offset));
298 #else
299 panic("%s: not implemented", __func__);
300 #endif
301 }
302
303 void
304 generic_bs_rm_1(void *t, bus_space_handle_t bsh,
305 bus_size_t offset, uint8_t *addr, size_t count)
306 {
307
308 while (count--)
309 *addr++ = rd8(bsh + offset);
310 }
311
312 void
313 generic_bs_rm_2(void *t, bus_space_handle_t bsh,
314 bus_size_t offset, uint16_t *addr, size_t count)
315 {
316 bus_addr_t baddr = bsh + offset;
317
318 while (count--)
319 *addr++ = rd16(baddr);
320 }
321
322 void
323 generic_bs_rm_4(void *t, bus_space_handle_t bsh,
324 bus_size_t offset, uint32_t *addr, size_t count)
325 {
326 bus_addr_t baddr = bsh + offset;
327
328 while (count--)
329 *addr++ = rd32(baddr);
330 }
331
332 void
333 generic_bs_rm_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
334 uint64_t *addr, size_t count)
335 {
336 #ifdef rd64
337 bus_addr_t baddr = bsh + offset;
338
339 while (count--)
340 *addr++ = rd64(baddr);
341 #else
342 panic("%s: not implemented", __func__);
343 #endif
344 }
345
346 /*
347 * Read `count' 1, 2, 4, or 8 byte quantities from bus space
348 * described by tag/handle and starting at `offset' and copy into
349 * buffer provided.
350 */
351 void
352 generic_bs_rr_1(void *t, bus_space_handle_t bsh,
353 bus_size_t offset, uint8_t *addr, size_t count)
354 {
355 bus_addr_t baddr = bsh + offset;
356
357 while (count--) {
358 *addr++ = rd8(baddr);
359 baddr += 1;
360 }
361 }
362
363 void
364 generic_bs_rr_2(void *t, bus_space_handle_t bsh,
365 bus_size_t offset, uint16_t *addr, size_t count)
366 {
367 bus_addr_t baddr = bsh + offset;
368
369 while (count--) {
370 *addr++ = rd16(baddr);
371 baddr += 2;
372 }
373 }
374
375 void
376 generic_bs_rr_4(void *t, bus_space_handle_t bsh,
377 bus_size_t offset, uint32_t *addr, size_t count)
378 {
379 bus_addr_t baddr = bsh + offset;
380
381 while (count--) {
382 *addr++ = rd32(baddr);
383 baddr += 4;
384 }
385 }
386
387 void
388 generic_bs_rr_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
389 uint64_t *addr, size_t count)
390 {
391 #ifdef rd64
392 bus_addr_t baddr = bsh + offset;
393
394 while (count--) {
395 *addr++ = rd64(baddr);
396 baddr += 8;
397 }
398 #else
399 panic("%s: not implemented", __func__);
400 #endif
401 }
402
403 /*
404 * Write the 1, 2, 4, or 8 byte value `value' to bus space
405 * described by tag/handle/offset.
406 */
407 void
408 generic_bs_w_1(void *t, bus_space_handle_t bsh,
409 bus_size_t offset, uint8_t value)
410 {
411
412 wr8(bsh + offset, value);
413 }
414
415 void
416 generic_bs_w_2(void *t, bus_space_handle_t bsh,
417 bus_size_t offset, uint16_t value)
418 {
419
420 wr16(bsh + offset, value);
421 }
422
423 void
424 generic_bs_w_4(void *t, bus_space_handle_t bsh,
425 bus_size_t offset, uint32_t value)
426 {
427
428 wr32(bsh + offset, value);
429 }
430
431 void
432 generic_bs_w_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
433 uint64_t value)
434 {
435
436 #ifdef wr64
437 wr64(bsh + offset, value);
438 #else
439 panic("%s: not implemented", __func__);
440 #endif
441 }
442
443 /*
444 * Write `count' 1, 2, 4, or 8 byte quantities from the buffer
445 * provided to bus space described by tag/handle/offset.
446 */
447 void
448 generic_bs_wm_1(void *t, bus_space_handle_t bsh,
449 bus_size_t offset, const uint8_t *addr, size_t count)
450 {
451 bus_addr_t baddr = bsh + offset;
452
453 while (count--)
454 wr8(baddr, *addr++);
455 }
456
457 void
458 generic_bs_wm_2(void *t, bus_space_handle_t bsh,
459 bus_size_t offset, const uint16_t *addr, size_t count)
460 {
461 bus_addr_t baddr = bsh + offset;
462
463 while (count--)
464 wr16(baddr, *addr++);
465 }
466
467 void
468 generic_bs_wm_4(void *t, bus_space_handle_t bsh,
469 bus_size_t offset, const uint32_t *addr, size_t count)
470 {
471 bus_addr_t baddr = bsh + offset;
472
473 while (count--)
474 wr32(baddr, *addr++);
475 }
476
477 void
478 generic_bs_wm_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
479 const uint64_t *addr, size_t count)
480 {
481 #ifdef wr64
482 bus_addr_t baddr = bsh + offset;
483
484 while (count--)
485 wr64(baddr, *addr++);
486 #else
487 panic("%s: not implemented", __func__);
488 #endif
489 }
490
491 /*
492 * Write `count' 1, 2, 4, or 8 byte quantities from the buffer provided
493 * to bus space described by tag/handle starting at `offset'.
494 */
495 void
496 generic_bs_wr_1(void *t, bus_space_handle_t bsh,
497 bus_size_t offset, const uint8_t *addr, size_t count)
498 {
499 bus_addr_t baddr = bsh + offset;
500
501 while (count--) {
502 wr8(baddr, *addr++);
503 baddr += 1;
504 }
505 }
506
507 void
508 generic_bs_wr_2(void *t, bus_space_handle_t bsh,
509 bus_size_t offset, const uint16_t *addr, size_t count)
510 {
511 bus_addr_t baddr = bsh + offset;
512
513 while (count--) {
514 wr16(baddr, *addr++);
515 baddr += 2;
516 }
517 }
518
519 void
520 generic_bs_wr_4(void *t, bus_space_handle_t bsh,
521 bus_size_t offset, const uint32_t *addr, size_t count)
522 {
523 bus_addr_t baddr = bsh + offset;
524
525 while (count--) {
526 wr32(baddr, *addr++);
527 baddr += 4;
528 }
529 }
530
531 void
532 generic_bs_wr_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
533 const uint64_t *addr, size_t count)
534 {
535 #ifdef wr64
536 bus_addr_t baddr = bsh + offset;
537
538 while (count--) {
539 wr64(baddr, *addr++);
540 baddr += 8;
541 }
542 #else
543 panic("%s: not implemented", __func__);
544 #endif
545 }
546
547 /*
548 * Write the 1, 2, 4, or 8 byte value `val' to bus space described
549 * by tag/handle/offset `count' times.
550 */
551 void
552 generic_bs_sm_1(void *t, bus_space_handle_t bsh,
553 bus_size_t offset, uint8_t value, size_t count)
554 {
555 bus_addr_t addr = bsh + offset;
556
557 while (count--)
558 wr8(addr, value);
559 }
560
561 void
562 generic_bs_sm_2(void *t, bus_space_handle_t bsh,
563 bus_size_t offset, uint16_t value, size_t count)
564 {
565 bus_addr_t addr = bsh + offset;
566
567 while (count--)
568 wr16(addr, value);
569 }
570
571 void
572 generic_bs_sm_4(void *t, bus_space_handle_t bsh,
573 bus_size_t offset, uint32_t value, size_t count)
574 {
575 bus_addr_t addr = bsh + offset;
576
577 while (count--)
578 wr32(addr, value);
579 }
580
581 void
582 generic_bs_sm_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
583 uint64_t value, size_t count)
584 {
585 #ifdef wr64
586 bus_addr_t addr = bsh + offset;
587
588 while (count--)
589 wr64(addr, value);
590 #else
591 panic("%s: not implemented", __func__);
592 #endif
593 }
594
595 /*
596 * Write `count' 1, 2, 4, or 8 byte value `val' to bus space described
597 * by tag/handle starting at `offset'.
598 */
599 void
600 generic_bs_sr_1(void *t, bus_space_handle_t bsh,
601 bus_size_t offset, uint8_t value, size_t count)
602 {
603 bus_addr_t addr = bsh + offset;
604
605 for (; count != 0; count--, addr++)
606 wr8(addr, value);
607 }
608
609 void
610 generic_bs_sr_2(void *t, bus_space_handle_t bsh,
611 bus_size_t offset, uint16_t value, size_t count)
612 {
613 bus_addr_t addr = bsh + offset;
614
615 for (; count != 0; count--, addr += 2)
616 wr16(addr, value);
617 }
618
619 void
620 generic_bs_sr_4(void *t, bus_space_handle_t bsh,
621 bus_size_t offset, uint32_t value, size_t count)
622 {
623 bus_addr_t addr = bsh + offset;
624
625 for (; count != 0; count--, addr += 4)
626 wr32(addr, value);
627 }
628
629 void
630 generic_bs_sr_8(void *t, bus_space_handle_t bsh, bus_size_t offset,
631 uint64_t value, size_t count)
632 {
633 #ifdef wr64
634 bus_addr_t addr = bsh + offset;
635
636 for (; count != 0; count--, addr += 8)
637 wr64(addr, value);
638 #else
639 panic("%s: not implemented", __func__);
640 #endif
641 }
642
643 /*
644 * Copy `count' 1, 2, 4, or 8 byte values from bus space starting
645 * at tag/bsh1/off1 to bus space starting at tag/bsh2/off2.
646 */
647 void
648 generic_bs_c_1(void *t, bus_space_handle_t bsh1,
649 bus_size_t off1, bus_space_handle_t bsh2,
650 bus_size_t off2, size_t count)
651 {
652 bus_addr_t addr1 = bsh1 + off1;
653 bus_addr_t addr2 = bsh2 + off2;
654
655 if (addr1 >= addr2) {
656 /* src after dest: copy forward */
657 for (; count != 0; count--, addr1++, addr2++)
658 wr8(addr2, rd8(addr1));
659 } else {
660 /* dest after src: copy backwards */
661 for (addr1 += (count - 1), addr2 += (count - 1);
662 count != 0; count--, addr1--, addr2--)
663 wr8(addr2, rd8(addr1));
664 }
665 }
666
667 void
668 generic_bs_c_2(void *t, bus_space_handle_t bsh1,
669 bus_size_t off1, bus_space_handle_t bsh2,
670 bus_size_t off2, size_t count)
671 {
672 bus_addr_t addr1 = bsh1 + off1;
673 bus_addr_t addr2 = bsh2 + off2;
674
675 if (addr1 >= addr2) {
676 /* src after dest: copy forward */
677 for (; count != 0; count--, addr1 += 2, addr2 += 2)
678 wr16(addr2, rd16(addr1));
679 } else {
680 /* dest after src: copy backwards */
681 for (addr1 += 2 * (count - 1), addr2 += 2 * (count - 1);
682 count != 0; count--, addr1 -= 2, addr2 -= 2)
683 wr16(addr2, rd16(addr1));
684 }
685 }
686
687 void
688 generic_bs_c_4(void *t, bus_space_handle_t bsh1,
689 bus_size_t off1, bus_space_handle_t bsh2,
690 bus_size_t off2, size_t count)
691 {
692 bus_addr_t addr1 = bsh1 + off1;
693 bus_addr_t addr2 = bsh2 + off2;
694
695 if (addr1 >= addr2) {
696 /* src after dest: copy forward */
697 for (; count != 0; count--, addr1 += 4, addr2 += 4)
698 wr32(addr2, rd32(addr1));
699 } else {
700 /* dest after src: copy backwards */
701 for (addr1 += 4 * (count - 1), addr2 += 4 * (count - 1);
702 count != 0; count--, addr1 -= 4, addr2 -= 4)
703 wr32(addr2, rd32(addr1));
704 }
705 }
706
707 void
708 generic_bs_c_8(void *t, bus_space_handle_t bsh1, bus_size_t off1,
709 bus_space_handle_t bsh2, bus_size_t off2, size_t count)
710 {
711 #if defined(rd64) && defined(wr64)
712 bus_addr_t addr1 = bsh1 + off1;
713 bus_addr_t addr2 = bsh2 + off2;
714
715 if (addr1 >= addr2) {
716 /* src after dest: copy forward */
717 for (; count != 0; count--, addr1 += 8, addr2 += 8)
718 wr64(addr2, rd64(addr1));
719 } else {
720 /* dest after src: copy backwards */
721 for (addr1 += 8 * (count - 1), addr2 += 8 * (count - 1);
722 count != 0; count--, addr1 -= 8, addr2 -= 8)
723 wr64(addr2, rd64(addr1));
724 }
725 #else
726 panic("%s: not implemented", __func__);
727 #endif
728 }
729
730 void
731 generic_bs_barrier(void *t __unused,
732 bus_space_handle_t bsh __unused,
733 bus_size_t offset __unused, bus_size_t len __unused,
734 int flags)
735 {
736 #if 0
737 if (flags & BUS_SPACE_BARRIER_WRITE)
738 mips_dcache_wbinv_all();
739 #endif
740 if (flags & BUS_SPACE_BARRIER_READ)
741 rmb();
742 if (flags & BUS_SPACE_BARRIER_WRITE)
743 wmb();
744 }
Cache object: 1baa73974e3f7a8a2b00b523b887e355
|