Return to sys_helper.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / target-alpha

Annotation of qemu/target-alpha/sys_helper.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *  Helpers for system instructions.
                      3:  *
                      4:  *  Copyright (c) 2007 Jocelyn Mayer
                      5:  *
                      6:  * This library is free software; you can redistribute it and/or
                      7:  * modify it under the terms of the GNU Lesser General Public
                      8:  * License as published by the Free Software Foundation; either
                      9:  * version 2 of the License, or (at your option) any later version.
                     10:  *
                     11:  * This library is distributed in the hope that it will be useful,
                     12:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     13:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     14:  * Lesser General Public License for more details.
                     15:  *
                     16:  * You should have received a copy of the GNU Lesser General Public
                     17:  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
                     18:  */
                     19: 
                     20: #include "cpu.h"
                     21: #include "helper.h"
                     22: #include "sysemu.h"
                     23: #include "qemu-timer.h"
                     24: 
                     25: 
                     26: uint64_t helper_load_pcc(CPUAlphaState *env)
                     27: {
                     28: #ifndef CONFIG_USER_ONLY
                     29:     /* In system mode we have access to a decent high-resolution clock.
                     30:        In order to make OS-level time accounting work with the RPCC,
                     31:        present it with a well-timed clock fixed at 250MHz.  */
                     32:     return (((uint64_t)env->pcc_ofs << 32)
                     33:             | (uint32_t)(qemu_get_clock_ns(vm_clock) >> 2));
                     34: #else
                     35:     /* In user-mode, vm_clock doesn't exist.  Just pass through the host cpu
                     36:        clock ticks.  Also, don't bother taking PCC_OFS into account.  */
                     37:     return (uint32_t)cpu_get_real_ticks();
                     38: #endif
                     39: }
                     40: 
                     41: /* PALcode support special instructions */
                     42: #ifndef CONFIG_USER_ONLY
                     43: void helper_hw_ret(CPUAlphaState *env, uint64_t a)
                     44: {
                     45:     env->pc = a & ~3;
                     46:     env->intr_flag = 0;
                     47:     env->lock_addr = -1;
                     48:     if ((a & 1) == 0) {
                     49:         env->pal_mode = 0;
                     50:         swap_shadow_regs(env);
                     51:     }
                     52: }
                     53: 
                     54: void helper_tbia(CPUAlphaState *env)
                     55: {
                     56:     tlb_flush(env, 1);
                     57: }
                     58: 
                     59: void helper_tbis(CPUAlphaState *env, uint64_t p)
                     60: {
                     61:     tlb_flush_page(env, p);
                     62: }
                     63: 
                     64: void helper_halt(uint64_t restart)
                     65: {
                     66:     if (restart) {
                     67:         qemu_system_reset_request();
                     68:     } else {
                     69:         qemu_system_shutdown_request();
                     70:     }
                     71: }
                     72: 
                     73: uint64_t helper_get_time(void)
                     74: {
                     75:     return qemu_get_clock_ns(rtc_clock);
                     76: }
                     77: 
                     78: void helper_set_alarm(CPUAlphaState *env, uint64_t expire)
                     79: {
                     80:     if (expire) {
                     81:         env->alarm_expire = expire;
                     82:         qemu_mod_timer(env->alarm_timer, expire);
                     83:     } else {
                     84:         qemu_del_timer(env->alarm_timer);
                     85:     }
                     86: }
                     87: #endif /* CONFIG_USER_ONLY */

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