The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Cache object: 1baa73974e3f7a8a2b00b523b887e355


[ 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.