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