sys/powerpc/powerpc/bus_machdep.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2006 Semihalf, Rafal Jaworowski <raj@semihalf.com>
   5  * Copyright (c) 1996, 1997, 1998 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  *
  21  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #define KTR_BE_IO       0
  38 #define KTR_LE_IO       0
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/bus.h>
  43 #include <sys/ktr.h>
  44 #include <vm/vm.h>
  45 #include <vm/pmap.h>
  46 #include <sys/endian.h>
  47
  48 #include <machine/bus.h>
  49 #include <machine/pio.h>
  50 #include <machine/md_var.h>
  51
  52 #define TODO panic("%s: not implemented", __func__)
  53
  54 #define MAX_EARLYBOOT_MAPPINGS  6
  55
  56 static struct {
  57         vm_offset_t virt;
  58         bus_addr_t addr;
  59         bus_size_t size;
  60         int flags;
  61 } earlyboot_mappings[MAX_EARLYBOOT_MAPPINGS];
  62 static int earlyboot_map_idx = 0;
  63
  64 void bs_remap_earlyboot(void);
  65
  66 static __inline void *
  67 __ppc_ba(bus_space_handle_t bsh, bus_size_t ofs)
  68 {
  69         return ((void *)(bsh + ofs));
  70 }
  71
  72 static int
  73 bs_gen_map(bus_addr_t addr, bus_size_t size, int flags,
  74     bus_space_handle_t *bshp)
  75 {
  76         vm_memattr_t ma;
  77
  78         /*
  79          * Record what we did if we haven't enabled the MMU yet. We
  80          * will need to remap it as soon as the MMU comes up.
  81          */
  82         if (!pmap_bootstrapped) {
  83                 KASSERT(earlyboot_map_idx < MAX_EARLYBOOT_MAPPINGS,
  84                     ("%s: too many early boot mapping requests", __func__));
  85                 earlyboot_mappings[earlyboot_map_idx].addr = addr;
  86                 earlyboot_mappings[earlyboot_map_idx].virt =
  87                     pmap_early_io_map(addr, size);
  88                 earlyboot_mappings[earlyboot_map_idx].size = size;
  89                 earlyboot_mappings[earlyboot_map_idx].flags = flags;
  90                 *bshp = earlyboot_mappings[earlyboot_map_idx].virt;
  91                 earlyboot_map_idx++;
  92         } else {
  93                 ma = VM_MEMATTR_DEFAULT;
  94                 switch (flags) {
  95                         case BUS_SPACE_MAP_CACHEABLE:
  96                                 ma = VM_MEMATTR_CACHEABLE;
  97                                 break;
  98                         case BUS_SPACE_MAP_PREFETCHABLE:
  99                                 ma = VM_MEMATTR_PREFETCHABLE;
 100                                 break;
 101                 }
 102                 *bshp = (bus_space_handle_t)pmap_mapdev_attr(addr, size, ma);
 103         }
 104
 105         return (0);
 106 }
 107
 108 void
 109 bs_remap_earlyboot(void)
 110 {
 111         vm_paddr_t pa, spa;
 112         vm_offset_t va;
 113         int i;
 114         vm_memattr_t ma;
 115
 116         for (i = 0; i < earlyboot_map_idx; i++) {
 117                 spa = earlyboot_mappings[i].addr;
 118
 119                 if (hw_direct_map &&
 120                    PHYS_TO_DMAP(spa) == earlyboot_mappings[i].virt &&
 121                    pmap_dev_direct_mapped(spa, earlyboot_mappings[i].size) == 0)
 122                         continue;
 123
 124                 ma = VM_MEMATTR_DEFAULT;
 125                 switch (earlyboot_mappings[i].flags) {
 126                         case BUS_SPACE_MAP_CACHEABLE:
 127                                 ma = VM_MEMATTR_CACHEABLE;
 128                                 break;
 129                         case BUS_SPACE_MAP_PREFETCHABLE:
 130                                 ma = VM_MEMATTR_PREFETCHABLE;
 131                                 break;
 132                 }
 133
 134                 pa = trunc_page(spa);
 135                 va = trunc_page(earlyboot_mappings[i].virt);
 136                 while (pa < spa + earlyboot_mappings[i].size) {
 137                         pmap_kenter_attr(va, pa, ma);
 138                         va += PAGE_SIZE;
 139                         pa += PAGE_SIZE;
 140                 }
 141         }
 142 }
 143
 144 static void
 145 bs_gen_unmap(bus_size_t size __unused)
 146 {
 147 }
 148
 149 static int
 150 bs_gen_subregion(bus_space_handle_t bsh, bus_size_t ofs,
 151     bus_size_t size __unused, bus_space_handle_t *nbshp)
 152 {
 153         *nbshp = bsh + ofs;
 154         return (0);
 155 }
 156
 157 static int
 158 bs_gen_alloc(bus_addr_t rstart __unused, bus_addr_t rend __unused,
 159     bus_size_t size __unused, bus_size_t alignment __unused,
 160     bus_size_t boundary __unused, int flags __unused,
 161     bus_addr_t *bpap __unused, bus_space_handle_t *bshp __unused)
 162 {
 163         TODO;
 164 }
 165
 166 static void
 167 bs_gen_free(bus_space_handle_t bsh __unused, bus_size_t size __unused)
 168 {
 169         TODO;
 170 }
 171
 172 static void
 173 bs_gen_barrier(bus_space_handle_t bsh __unused, bus_size_t ofs __unused,
 174     bus_size_t size __unused, int flags __unused)
 175 {
 176
 177         powerpc_iomb();
 178 }
 179
 180 /*
 181  * Big-endian access functions
 182  */
 183 static uint8_t
 184 bs_be_rs_1(bus_space_handle_t bsh, bus_size_t ofs)
 185 {
 186         volatile uint8_t *addr;
 187         uint8_t res;
 188
 189         addr = __ppc_ba(bsh, ofs);
 190         res = *addr;
 191         powerpc_iomb();
 192         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 193         return (res);
 194 }
 195
 196 static uint16_t
 197 bs_be_rs_2(bus_space_handle_t bsh, bus_size_t ofs)
 198 {
 199         volatile uint16_t *addr;
 200         uint16_t res;
 201
 202         addr = __ppc_ba(bsh, ofs);
 203         res = *addr;
 204         powerpc_iomb();
 205         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 206         return (res);
 207 }
 208
 209 static uint32_t
 210 bs_be_rs_4(bus_space_handle_t bsh, bus_size_t ofs)
 211 {
 212         volatile uint32_t *addr;
 213         uint32_t res;
 214
 215         addr = __ppc_ba(bsh, ofs);
 216         res = *addr;
 217         powerpc_iomb();
 218         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 219         return (res);
 220 }
 221
 222 static uint64_t
 223 bs_be_rs_8(bus_space_handle_t bsh, bus_size_t ofs)
 224 {
 225         volatile uint64_t *addr;
 226         uint64_t res;
 227
 228         addr = __ppc_ba(bsh, ofs);
 229         res = *addr;
 230         powerpc_iomb();
 231         return (res);
 232 }
 233
 234 static void
 235 bs_be_rm_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t *addr, size_t cnt)
 236 {
 237         ins8(__ppc_ba(bsh, ofs), addr, cnt);
 238 }
 239
 240 static void
 241 bs_be_rm_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t *addr, size_t cnt)
 242 {
 243         ins16(__ppc_ba(bsh, ofs), addr, cnt);
 244 }
 245
 246 static void
 247 bs_be_rm_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t *addr, size_t cnt)
 248 {
 249         ins32(__ppc_ba(bsh, ofs), addr, cnt);
 250 }
 251
 252 static void
 253 bs_be_rm_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t *addr, size_t cnt)
 254 {
 255         ins64(__ppc_ba(bsh, ofs), addr, cnt);
 256 }
 257
 258 static void
 259 bs_be_rr_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t *addr, size_t cnt)
 260 {
 261         volatile uint8_t *s = __ppc_ba(bsh, ofs);
 262
 263         while (cnt--)
 264                 *addr++ = *s++;
 265         powerpc_iomb();
 266 }
 267
 268 static void
 269 bs_be_rr_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t *addr, size_t cnt)
 270 {
 271         volatile uint16_t *s = __ppc_ba(bsh, ofs);
 272
 273         while (cnt--)
 274                 *addr++ = *s++;
 275         powerpc_iomb();
 276 }
 277
 278 static void
 279 bs_be_rr_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t *addr, size_t cnt)
 280 {
 281         volatile uint32_t *s = __ppc_ba(bsh, ofs);
 282
 283         while (cnt--)
 284                 *addr++ = *s++;
 285         powerpc_iomb();
 286 }
 287
 288 static void
 289 bs_be_rr_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t *addr, size_t cnt)
 290 {
 291         volatile uint64_t *s = __ppc_ba(bsh, ofs);
 292
 293         while (cnt--)
 294                 *addr++ = *s++;
 295         powerpc_iomb();
 296 }
 297
 298 static void
 299 bs_be_ws_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val)
 300 {
 301         volatile uint8_t *addr;
 302
 303         addr = __ppc_ba(bsh, ofs);
 304         *addr = val;
 305         powerpc_iomb();
 306         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 307 }
 308
 309 static void
 310 bs_be_ws_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val)
 311 {
 312         volatile uint16_t *addr;
 313
 314         addr = __ppc_ba(bsh, ofs);
 315         *addr = val;
 316         powerpc_iomb();
 317         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 318 }
 319
 320 static void
 321 bs_be_ws_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val)
 322 {
 323         volatile uint32_t *addr;
 324
 325         addr = __ppc_ba(bsh, ofs);
 326         *addr = val;
 327         powerpc_iomb();
 328         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 329 }
 330
 331 static void
 332 bs_be_ws_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val)
 333 {
 334         volatile uint64_t *addr;
 335
 336         addr = __ppc_ba(bsh, ofs);
 337         *addr = val;
 338         powerpc_iomb();
 339         CTR4(KTR_BE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 340 }
 341
 342 static void
 343 bs_be_wm_1(bus_space_handle_t bsh, bus_size_t ofs, const uint8_t *addr,
 344     bus_size_t cnt)
 345 {
 346         outsb(__ppc_ba(bsh, ofs), addr, cnt);
 347 }
 348
 349 static void
 350 bs_be_wm_2(bus_space_handle_t bsh, bus_size_t ofs, const uint16_t *addr,
 351     bus_size_t cnt)
 352 {
 353         outsw(__ppc_ba(bsh, ofs), addr, cnt);
 354 }
 355
 356 static void
 357 bs_be_wm_4(bus_space_handle_t bsh, bus_size_t ofs, const uint32_t *addr,
 358     bus_size_t cnt)
 359 {
 360         outsl(__ppc_ba(bsh, ofs), addr, cnt);
 361 }
 362
 363 static void
 364 bs_be_wm_8(bus_space_handle_t bsh, bus_size_t ofs, const uint64_t *addr,
 365     bus_size_t cnt)
 366 {
 367         outsll(__ppc_ba(bsh, ofs), addr, cnt);
 368 }
 369
 370 static void
 371 bs_be_wr_1(bus_space_handle_t bsh, bus_size_t ofs, const uint8_t *addr,
 372     size_t cnt)
 373 {
 374         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 375
 376         while (cnt--)
 377                 *d++ = *addr++;
 378         powerpc_iomb();
 379 }
 380
 381 static void
 382 bs_be_wr_2(bus_space_handle_t bsh, bus_size_t ofs, const uint16_t *addr,
 383     size_t cnt)
 384 {
 385         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 386
 387         while (cnt--)
 388                 *d++ = *addr++;
 389         powerpc_iomb();
 390 }
 391
 392 static void
 393 bs_be_wr_4(bus_space_handle_t bsh, bus_size_t ofs, const uint32_t *addr,
 394     size_t cnt)
 395 {
 396         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 397
 398         while (cnt--)
 399                 *d++ = *addr++;
 400         powerpc_iomb();
 401 }
 402
 403 static void
 404 bs_be_wr_8(bus_space_handle_t bsh, bus_size_t ofs, const uint64_t *addr,
 405     size_t cnt)
 406 {
 407         volatile uint64_t *d = __ppc_ba(bsh, ofs);
 408
 409         while (cnt--)
 410                 *d++ = *addr++;
 411         powerpc_iomb();
 412 }
 413
 414 static void
 415 bs_be_sm_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val, size_t cnt)
 416 {
 417         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 418
 419         while (cnt--)
 420                 *d = val;
 421         powerpc_iomb();
 422 }
 423
 424 static void
 425 bs_be_sm_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val, size_t cnt)
 426 {
 427         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 428
 429         while (cnt--)
 430                 *d = val;
 431         powerpc_iomb();
 432 }
 433
 434 static void
 435 bs_be_sm_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val, size_t cnt)
 436 {
 437         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 438
 439         while (cnt--)
 440                 *d = val;
 441         powerpc_iomb();
 442 }
 443
 444 static void
 445 bs_be_sm_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val, size_t cnt)
 446 {
 447         volatile uint64_t *d = __ppc_ba(bsh, ofs);
 448
 449         while (cnt--)
 450                 *d = val;
 451         powerpc_iomb();
 452 }
 453
 454 static void
 455 bs_be_sr_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val, size_t cnt)
 456 {
 457         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 458
 459         while (cnt--)
 460                 *d++ = val;
 461         powerpc_iomb();
 462 }
 463
 464 static void
 465 bs_be_sr_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val, size_t cnt)
 466 {
 467         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 468
 469         while (cnt--)
 470                 *d++ = val;
 471         powerpc_iomb();
 472 }
 473
 474 static void
 475 bs_be_sr_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val, size_t cnt)
 476 {
 477         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 478
 479         while (cnt--)
 480                 *d++ = val;
 481         powerpc_iomb();
 482 }
 483
 484 static void
 485 bs_be_sr_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val, size_t cnt)
 486 {
 487         volatile uint64_t *d = __ppc_ba(bsh, ofs);
 488
 489         while (cnt--)
 490                 *d++ = val;
 491         powerpc_iomb();
 492 }
 493
 494 /*
 495  * Little-endian access functions
 496  */
 497 static uint8_t
 498 bs_le_rs_1(bus_space_handle_t bsh, bus_size_t ofs)
 499 {
 500         volatile uint8_t *addr;
 501         uint8_t res;
 502
 503         addr = __ppc_ba(bsh, ofs);
 504         res = *addr;
 505         powerpc_iomb();
 506         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 507         return (res);
 508 }
 509
 510 static uint16_t
 511 bs_le_rs_2(bus_space_handle_t bsh, bus_size_t ofs)
 512 {
 513         volatile uint16_t *addr;
 514         uint16_t res;
 515
 516         addr = __ppc_ba(bsh, ofs);
 517         __asm __volatile("lhbrx %0, 0, %1" : "=r"(res) : "r"(addr));
 518         powerpc_iomb();
 519         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 520         return (res);
 521 }
 522
 523 static uint32_t
 524 bs_le_rs_4(bus_space_handle_t bsh, bus_size_t ofs)
 525 {
 526         volatile uint32_t *addr;
 527         uint32_t res;
 528
 529         addr = __ppc_ba(bsh, ofs);
 530         __asm __volatile("lwbrx %0, 0, %1" : "=r"(res) : "r"(addr));
 531         powerpc_iomb();
 532         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 533         return (res);
 534 }
 535
 536 static uint64_t
 537 bs_le_rs_8(bus_space_handle_t bsh, bus_size_t ofs)
 538 {
 539         volatile uint64_t *addr;
 540         uint64_t res;
 541
 542         addr = __ppc_ba(bsh, ofs);
 543         res = le64toh(*addr);
 544         powerpc_iomb();
 545         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x) = %#x", __func__, bsh, ofs, res);
 546         return (res);
 547 }
 548
 549 static void
 550 bs_le_rm_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t *addr, size_t cnt)
 551 {
 552         ins8(__ppc_ba(bsh, ofs), addr, cnt);
 553 }
 554
 555 static void
 556 bs_le_rm_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t *addr, size_t cnt)
 557 {
 558         ins16rb(__ppc_ba(bsh, ofs), addr, cnt);
 559 }
 560
 561 static void
 562 bs_le_rm_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t *addr, size_t cnt)
 563 {
 564         ins32rb(__ppc_ba(bsh, ofs), addr, cnt);
 565 }
 566
 567 static void
 568 bs_le_rm_8(bus_space_handle_t bshh, bus_size_t ofs, uint64_t *addr, size_t cnt)
 569 {
 570         TODO;
 571 }
 572
 573 static void
 574 bs_le_rr_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t *addr, size_t cnt)
 575 {
 576         volatile uint8_t *s = __ppc_ba(bsh, ofs);
 577
 578         while (cnt--)
 579                 *addr++ = *s++;
 580         powerpc_iomb();
 581 }
 582
 583 static void
 584 bs_le_rr_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t *addr, size_t cnt)
 585 {
 586         volatile uint16_t *s = __ppc_ba(bsh, ofs);
 587
 588         while (cnt--)
 589                 *addr++ = in16rb(s++);
 590         powerpc_iomb();
 591 }
 592
 593 static void
 594 bs_le_rr_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t *addr, size_t cnt)
 595 {
 596         volatile uint32_t *s = __ppc_ba(bsh, ofs);
 597
 598         while (cnt--)
 599                 *addr++ = in32rb(s++);
 600         powerpc_iomb();
 601 }
 602
 603 static void
 604 bs_le_rr_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t *addr, size_t cnt)
 605 {
 606         TODO;
 607 }
 608
 609 static void
 610 bs_le_ws_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val)
 611 {
 612         volatile uint8_t *addr;
 613
 614         addr = __ppc_ba(bsh, ofs);
 615         *addr = val;
 616         powerpc_iomb();
 617         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 618 }
 619
 620 static void
 621 bs_le_ws_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val)
 622 {
 623         volatile uint16_t *addr;
 624
 625         addr = __ppc_ba(bsh, ofs);
 626         __asm __volatile("sthbrx %0, 0, %1" :: "r"(val), "r"(addr));
 627         powerpc_iomb();
 628         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 629 }
 630
 631 static void
 632 bs_le_ws_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val)
 633 {
 634         volatile uint32_t *addr;
 635
 636         addr = __ppc_ba(bsh, ofs);
 637         __asm __volatile("stwbrx %0, 0, %1" :: "r"(val), "r"(addr));
 638         powerpc_iomb();
 639         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 640 }
 641
 642 static void
 643 bs_le_ws_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val)
 644 {
 645         volatile uint64_t *addr;
 646
 647         addr = __ppc_ba(bsh, ofs);
 648         *addr = htole64(val);
 649         powerpc_iomb();
 650         CTR4(KTR_LE_IO, "%s(bsh=%#x, ofs=%#x, val=%#x)", __func__, bsh, ofs, val);
 651 }
 652
 653 static void
 654 bs_le_wm_1(bus_space_handle_t bsh, bus_size_t ofs, const uint8_t *addr,
 655     bus_size_t cnt)
 656 {
 657         outs8(__ppc_ba(bsh, ofs), addr, cnt);
 658 }
 659
 660 static void
 661 bs_le_wm_2(bus_space_handle_t bsh, bus_size_t ofs, const uint16_t *addr,
 662     bus_size_t cnt)
 663 {
 664         outs16rb(__ppc_ba(bsh, ofs), addr, cnt);
 665 }
 666
 667 static void
 668 bs_le_wm_4(bus_space_handle_t bsh, bus_size_t ofs, const uint32_t *addr,
 669     bus_size_t cnt)
 670 {
 671         outs32rb(__ppc_ba(bsh, ofs), addr, cnt);
 672 }
 673
 674 static void
 675 bs_le_wm_8(bus_space_handle_t bsh, bus_size_t ofs, const uint64_t *addr,
 676     bus_size_t cnt)
 677 {
 678         TODO;
 679 }
 680
 681 static void
 682 bs_le_wr_1(bus_space_handle_t bsh, bus_size_t ofs, const uint8_t *addr,
 683     size_t cnt)
 684 {
 685         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 686
 687         while (cnt--)
 688                 *d++ = *addr++;
 689         powerpc_iomb();
 690 }
 691
 692 static void
 693 bs_le_wr_2(bus_space_handle_t bsh, bus_size_t ofs, const uint16_t *addr,
 694     size_t cnt)
 695 {
 696         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 697
 698         while (cnt--)
 699                 out16rb(d++, *addr++);
 700         powerpc_iomb();
 701 }
 702
 703 static void
 704 bs_le_wr_4(bus_space_handle_t bsh, bus_size_t ofs, const uint32_t *addr,
 705     size_t cnt)
 706 {
 707         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 708
 709         while (cnt--)
 710                 out32rb(d++, *addr++);
 711         powerpc_iomb();
 712 }
 713
 714 static void
 715 bs_le_wr_8(bus_space_handle_t bsh, bus_size_t ofs, const uint64_t *addr,
 716     size_t cnt)
 717 {
 718         TODO;
 719 }
 720
 721 static void
 722 bs_le_sm_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val, size_t cnt)
 723 {
 724         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 725
 726         while (cnt--)
 727                 *d = val;
 728         powerpc_iomb();
 729 }
 730
 731 static void
 732 bs_le_sm_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val, size_t cnt)
 733 {
 734         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 735
 736         while (cnt--)
 737                 out16rb(d, val);
 738         powerpc_iomb();
 739 }
 740
 741 static void
 742 bs_le_sm_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val, size_t cnt)
 743 {
 744         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 745
 746         while (cnt--)
 747                 out32rb(d, val);
 748         powerpc_iomb();
 749 }
 750
 751 static void
 752 bs_le_sm_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val, size_t cnt)
 753 {
 754         TODO;
 755 }
 756
 757 static void
 758 bs_le_sr_1(bus_space_handle_t bsh, bus_size_t ofs, uint8_t val, size_t cnt)
 759 {
 760         volatile uint8_t *d = __ppc_ba(bsh, ofs);
 761
 762         while (cnt--)
 763                 *d++ = val;
 764         powerpc_iomb();
 765 }
 766
 767 static void
 768 bs_le_sr_2(bus_space_handle_t bsh, bus_size_t ofs, uint16_t val, size_t cnt)
 769 {
 770         volatile uint16_t *d = __ppc_ba(bsh, ofs);
 771
 772         while (cnt--)
 773                 out16rb(d++, val);
 774         powerpc_iomb();
 775 }
 776
 777 static void
 778 bs_le_sr_4(bus_space_handle_t bsh, bus_size_t ofs, uint32_t val, size_t cnt)
 779 {
 780         volatile uint32_t *d = __ppc_ba(bsh, ofs);
 781
 782         while (cnt--)
 783                 out32rb(d++, val);
 784         powerpc_iomb();
 785 }
 786
 787 static void
 788 bs_le_sr_8(bus_space_handle_t bsh, bus_size_t ofs, uint64_t val, size_t cnt)
 789 {
 790         TODO;
 791 }
 792
 793 struct bus_space bs_be_tag = {
 794         /* mapping/unmapping */
 795         bs_gen_map,
 796         bs_gen_unmap,
 797         bs_gen_subregion,
 798
 799         /* allocation/deallocation */
 800         bs_gen_alloc,
 801         bs_gen_free,
 802
 803         /* barrier */
 804         bs_gen_barrier,
 805
 806         /* read (single) */
 807         bs_be_rs_1,
 808         bs_be_rs_2,
 809         bs_be_rs_4,
 810         bs_be_rs_8,
 811
 812         bs_be_rs_2,
 813         bs_be_rs_4,
 814         bs_be_rs_8,
 815
 816         /* read multiple */
 817         bs_be_rm_1,
 818         bs_be_rm_2,
 819         bs_be_rm_4,
 820         bs_be_rm_8,
 821
 822         bs_be_rm_2,
 823         bs_be_rm_4,
 824         bs_be_rm_8,
 825
 826         /* read region */
 827         bs_be_rr_1,
 828         bs_be_rr_2,
 829         bs_be_rr_4,
 830         bs_be_rr_8,
 831
 832         bs_be_rr_2,
 833         bs_be_rr_4,
 834         bs_be_rr_8,
 835
 836         /* write (single) */
 837         bs_be_ws_1,
 838         bs_be_ws_2,
 839         bs_be_ws_4,
 840         bs_be_ws_8,
 841
 842         bs_be_ws_2,
 843         bs_be_ws_4,
 844         bs_be_ws_8,
 845
 846         /* write multiple */
 847         bs_be_wm_1,
 848         bs_be_wm_2,
 849         bs_be_wm_4,
 850         bs_be_wm_8,
 851
 852         bs_be_wm_2,
 853         bs_be_wm_4,
 854         bs_be_wm_8,
 855
 856         /* write region */
 857         bs_be_wr_1,
 858         bs_be_wr_2,
 859         bs_be_wr_4,
 860         bs_be_wr_8,
 861
 862         bs_be_wr_2,
 863         bs_be_wr_4,
 864         bs_be_wr_8,
 865
 866         /* set multiple */
 867         bs_be_sm_1,
 868         bs_be_sm_2,
 869         bs_be_sm_4,
 870         bs_be_sm_8,
 871
 872         bs_be_sm_2,
 873         bs_be_sm_4,
 874         bs_be_sm_8,
 875
 876         /* set region */
 877         bs_be_sr_1,
 878         bs_be_sr_2,
 879         bs_be_sr_4,
 880         bs_be_sr_8,
 881
 882         bs_be_sr_2,
 883         bs_be_sr_4,
 884         bs_be_sr_8,
 885 };
 886
 887 struct bus_space bs_le_tag = {
 888         /* mapping/unmapping */
 889         bs_gen_map,
 890         bs_gen_unmap,
 891         bs_gen_subregion,
 892
 893         /* allocation/deallocation */
 894         bs_gen_alloc,
 895         bs_gen_free,
 896
 897         /* barrier */
 898         bs_gen_barrier,
 899
 900         /* read (single) */
 901         bs_le_rs_1,
 902         bs_le_rs_2,
 903         bs_le_rs_4,
 904         bs_le_rs_8,
 905
 906         bs_be_rs_2,
 907         bs_be_rs_4,
 908         bs_be_rs_8,
 909
 910         /* read multiple */
 911         bs_le_rm_1,
 912         bs_le_rm_2,
 913         bs_le_rm_4,
 914         bs_le_rm_8,
 915
 916         bs_be_rm_2,
 917         bs_be_rm_4,
 918         bs_be_rm_8,
 919
 920         /* read region */
 921         bs_le_rr_1,
 922         bs_le_rr_2,
 923         bs_le_rr_4,
 924         bs_le_rr_8,
 925
 926         bs_be_rr_2,
 927         bs_be_rr_4,
 928         bs_be_rr_8,
 929
 930         /* write (single) */
 931         bs_le_ws_1,
 932         bs_le_ws_2,
 933         bs_le_ws_4,
 934         bs_le_ws_8,
 935
 936         bs_be_ws_2,
 937         bs_be_ws_4,
 938         bs_be_ws_8,
 939
 940         /* write multiple */
 941         bs_le_wm_1,
 942         bs_le_wm_2,
 943         bs_le_wm_4,
 944         bs_le_wm_8,
 945
 946         bs_be_wm_2,
 947         bs_be_wm_4,
 948         bs_be_wm_8,
 949
 950         /* write region */
 951         bs_le_wr_1,
 952         bs_le_wr_2,
 953         bs_le_wr_4,
 954         bs_le_wr_8,
 955
 956         bs_be_wr_2,
 957         bs_be_wr_4,
 958         bs_be_wr_8,
 959
 960         /* set multiple */
 961         bs_le_sm_1,
 962         bs_le_sm_2,
 963         bs_le_sm_4,
 964         bs_le_sm_8,
 965
 966         bs_be_sm_2,
 967         bs_be_sm_4,
 968         bs_be_sm_8,
 969
 970         /* set region */
 971         bs_le_sr_1,
 972         bs_le_sr_2,
 973         bs_le_sr_4,
 974         bs_le_sr_8,
 975
 976         bs_be_sr_2,
 977         bs_be_sr_4,
 978         bs_be_sr_8,
 979 };