bus_machdep.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 };
Cache object: a6f140ca1fd0fd0bc27833f69f4d3458
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/powerpc/powerpc/bus_machdep.c

FreeBSD/Linux Kernel Cross Reference
sys/powerpc/powerpc/bus_machdep.c
