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

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.