Return to hw.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / SLOF / board-js2x / llfw

Annotation of qemu/roms/SLOF/board-js2x/llfw/hw.c, revision 1.1

1.1     ! root        1: /******************************************************************************
        !             2:  * Copyright (c) 2004, 2008 IBM Corporation
        !             3:  * All rights reserved.
        !             4:  * This program and the accompanying materials
        !             5:  * are made available under the terms of the BSD License
        !             6:  * which accompanies this distribution, and is available at
        !             7:  * http://www.opensource.org/licenses/bsd-license.php
        !             8:  *
        !             9:  * Contributors:
        !            10:  *     IBM Corporation - initial implementation
        !            11:  *****************************************************************************/
        !            12: 
        !            13: #include <cpu.h>
        !            14: #include <stdint.h>
        !            15: #include <hw.h>
        !            16: 
        !            17: uint16_t
        !            18: bswap16_load(uint64_t addr)
        !            19: {
        !            20:        unsigned int val;
        !            21:        set_ci();
        !            22:        asm volatile ("lhbrx %0, 0, %1":"=r" (val):"r"(addr));
        !            23:        clr_ci();
        !            24:        return val;
        !            25: }
        !            26: 
        !            27: uint32_t
        !            28: bswap32_load(uint64_t addr)
        !            29: {
        !            30:        unsigned int val;
        !            31:        set_ci();
        !            32:        asm volatile ("lwbrx %0, 0, %1":"=r" (val):"r"(addr));
        !            33:        clr_ci();
        !            34:        return val;
        !            35: }
        !            36: 
        !            37: void
        !            38: bswap16_store(uint64_t addr, uint16_t val)
        !            39: {
        !            40:        set_ci();
        !            41:        asm volatile ("sthbrx %0, 0, %1"::"r" (val), "r"(addr));
        !            42:        clr_ci();
        !            43: }
        !            44: 
        !            45: void
        !            46: bswap32_store(uint64_t addr, uint32_t val)
        !            47: {
        !            48:        set_ci();
        !            49:        asm volatile ("stwbrx %0, 0, %1"::"r" (val), "r"(addr));
        !            50:        clr_ci();
        !            51: }
        !            52: 
        !            53: uint8_t
        !            54: load8_ci(uint64_t addr)
        !            55: {
        !            56:        uint8_t val;
        !            57:        set_ci();
        !            58:        val = *(uint8_t *) addr;
        !            59:        clr_ci();
        !            60:        return val;
        !            61: }
        !            62: 
        !            63: uint16_t
        !            64: load16_ci(uint64_t addr)
        !            65: {
        !            66:        uint16_t val;
        !            67:        set_ci();
        !            68:        val = *(uint16_t *) addr;
        !            69:        clr_ci();
        !            70:        return val;
        !            71: }
        !            72: 
        !            73: uint32_t
        !            74: load32_ci(uint64_t addr)
        !            75: {
        !            76:        uint32_t val;
        !            77:        set_ci();
        !            78:        val = *(uint32_t *) addr;
        !            79:        clr_ci();
        !            80:        return val;
        !            81: }
        !            82: 
        !            83: uint64_t
        !            84: load64_ci(uint64_t addr)
        !            85: {
        !            86:        uint64_t val;
        !            87:        set_ci();
        !            88:        val = *(uint64_t *) addr;
        !            89:        clr_ci();
        !            90:        return val;
        !            91: }
        !            92: 
        !            93: 
        !            94: void
        !            95: store8_ci(uint64_t addr, uint8_t val)
        !            96: {
        !            97:        set_ci();
        !            98:        *(uint8_t *) addr = val;
        !            99:        clr_ci();
        !           100: }
        !           101: 
        !           102: void
        !           103: store16_ci(uint64_t addr, uint16_t val)
        !           104: {
        !           105:        set_ci();
        !           106:        *(uint16_t *) addr = val;
        !           107:        clr_ci();
        !           108: }
        !           109: 
        !           110: void
        !           111: store32_ci(uint64_t addr, uint32_t val)
        !           112: {
        !           113:        set_ci();
        !           114:        *(uint32_t *) addr = val;
        !           115:        clr_ci();
        !           116: }
        !           117: 
        !           118: void
        !           119: store64_ci(uint64_t addr, uint64_t val)
        !           120: {
        !           121:        set_ci();
        !           122:        *(uint64_t *) addr = val;
        !           123:        clr_ci();
        !           124: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.