sys/mips/mips/bus_space_generic.c

   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 }