← Back to branch summary

~ubuntu-branches/ubuntu/vivid/qemu-linaro/vivid

« back to all changes in this revision

Viewing changes to xtensa-semi.c

  • Committer: Ricardo Salveti de Araujo
  • Date: 2012-09-20 18:39:31 UTC
  • mfrom: (12922.1.2 qemu-linaro)
  • Revision ID: ricardo.salveti@linaro.org-20120920183931-sp3cg6kpdl8dmwo9
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control:
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
xtensa-semi.c
1
 
/*
2
 
 * Copyright (c) 2011, Max Filippov, Open Source and Linux Lab.
3
 
 * All rights reserved.
4
 
 *
5
 
 * Redistribution and use in source and binary forms, with or without
6
 
 * modification, are permitted provided that the following conditions are met:
7
 
 *     * Redistributions of source code must retain the above copyright
8
 
 *       notice, this list of conditions and the following disclaimer.
9
 
 *     * Redistributions in binary form must reproduce the above copyright
10
 
 *       notice, this list of conditions and the following disclaimer in the
11
 
 *       documentation and/or other materials provided with the distribution.
12
 
 *     * Neither the name of the Open Source and Linux Lab nor the
13
 
 *       names of its contributors may be used to endorse or promote products
14
 
 *       derived from this software without specific prior written permission.
15
 
 *
16
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17
 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19
 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20
 
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21
 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22
 
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23
 
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24
 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25
 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
 
 */
27
 
 
28
 
#include <errno.h>
29
 
#include <unistd.h>
30
 
#include <string.h>
31
 
#include <stddef.h>
32
 
#include "cpu.h"
33
 
#include "dyngen-exec.h"
34
 
#include "helpers.h"
35
 
#include "qemu-log.h"
36
 
 
37
 
enum {
38
 
    TARGET_SYS_exit = 1,
39
 
    TARGET_SYS_read = 3,
40
 
    TARGET_SYS_write = 4,
41
 
    TARGET_SYS_open = 5,
42
 
    TARGET_SYS_close = 6,
43
 
    TARGET_SYS_lseek = 19,
44
 
    TARGET_SYS_select_one = 29,
45
 
 
46
 
    TARGET_SYS_argc = 1000,
47
 
    TARGET_SYS_argv_sz = 1001,
48
 
    TARGET_SYS_argv = 1002,
49
 
    TARGET_SYS_memset = 1004,
50
 
};
51
 
 
52
 
enum {
53
 
    SELECT_ONE_READ   = 1,
54
 
    SELECT_ONE_WRITE  = 2,
55
 
    SELECT_ONE_EXCEPT = 3,
56
 
};
57
 
 
58
 
void HELPER(simcall)(CPUState *env)
59
 
{
60
 
    uint32_t *regs = env->regs;
61
 
 
62
 
    switch (regs[2]) {
63
 
    case TARGET_SYS_exit:
64
 
        qemu_log("exit(%d) simcall\n", regs[3]);
65
 
        exit(regs[3]);
66
 
        break;
67
 
 
68
 
    case TARGET_SYS_read:
69
 
    case TARGET_SYS_write:
70
 
        {
71
 
            bool is_write = regs[2] == TARGET_SYS_write;
72
 
            uint32_t fd = regs[3];
73
 
            uint32_t vaddr = regs[4];
74
 
            uint32_t len = regs[5];
75
 
 
76
 
            while (len > 0) {
77
 
                target_phys_addr_t paddr =
78
 
                    cpu_get_phys_page_debug(env, vaddr);
79
 
                uint32_t page_left =
80
 
                    TARGET_PAGE_SIZE - (vaddr & (TARGET_PAGE_SIZE - 1));
81
 
                uint32_t io_sz = page_left < len ? page_left : len;
82
 
                target_phys_addr_t sz = io_sz;
83
 
                void *buf = cpu_physical_memory_map(paddr, &sz, is_write);
84
 
 
85
 
                if (buf) {
86
 
                    vaddr += io_sz;
87
 
                    len -= io_sz;
88
 
                    regs[2] = is_write ?
89
 
                        write(fd, buf, io_sz) :
90
 
                        read(fd, buf, io_sz);
91
 
                    regs[3] = errno;
92
 
                    cpu_physical_memory_unmap(buf, sz, is_write, sz);
93
 
                    if (regs[2] == -1) {
94
 
                        break;
95
 
                    }
96
 
                } else {
97
 
                    regs[2] = -1;
98
 
                    regs[3] = EINVAL;
99
 
                    break;
100
 
                }
101
 
            }
102
 
        }
103
 
        break;
104
 
 
105
 
    case TARGET_SYS_open:
106
 
        {
107
 
            char name[1024];
108
 
            int rc;
109
 
            int i;
110
 
 
111
 
            for (i = 0; i < ARRAY_SIZE(name); ++i) {
112
 
                rc = cpu_memory_rw_debug(
113
 
                        env, regs[3] + i, (uint8_t *)name + i, 1, 0);
114
 
                if (rc != 0 || name[i] == 0) {
115
 
                    break;
116
 
                }
117
 
            }
118
 
 
119
 
            if (rc == 0 && i < ARRAY_SIZE(name)) {
120
 
                regs[2] = open(name, regs[4], regs[5]);
121
 
                regs[3] = errno;
122
 
            } else {
123
 
                regs[2] = -1;
124
 
                regs[3] = EINVAL;
125
 
            }
126
 
        }
127
 
        break;
128
 
 
129
 
    case TARGET_SYS_close:
130
 
        if (regs[3] < 3) {
131
 
            regs[2] = regs[3] = 0;
132
 
        } else {
133
 
            regs[2] = close(regs[3]);
134
 
            regs[3] = errno;
135
 
        }
136
 
        break;
137
 
 
138
 
    case TARGET_SYS_lseek:
139
 
        regs[2] = lseek(regs[3], (off_t)(int32_t)regs[4], regs[5]);
140
 
        regs[3] = errno;
141
 
        break;
142
 
 
143
 
    case TARGET_SYS_select_one:
144
 
        {
145
 
            uint32_t fd = regs[3];
146
 
            uint32_t rq = regs[4];
147
 
            uint32_t target_tv = regs[5];
148
 
            uint32_t target_tvv[2];
149
 
 
150
 
            struct timeval tv = {0};
151
 
            fd_set fdset;
152
 
 
153
 
            FD_ZERO(&fdset);
154
 
            FD_SET(fd, &fdset);
155
 
 
156
 
            if (target_tv) {
157
 
                cpu_memory_rw_debug(env, target_tv,
158
 
                        (uint8_t *)target_tvv, sizeof(target_tvv), 0);
159
 
                tv.tv_sec = (int32_t)tswap32(target_tvv[0]);
160
 
                tv.tv_usec = (int32_t)tswap32(target_tvv[1]);
161
 
            }
162
 
            regs[2] = select(fd + 1,
163
 
                    rq == SELECT_ONE_READ   ? &fdset : NULL,
164
 
                    rq == SELECT_ONE_WRITE  ? &fdset : NULL,
165
 
                    rq == SELECT_ONE_EXCEPT ? &fdset : NULL,
166
 
                    target_tv ? &tv : NULL);
167
 
            regs[3] = errno;
168
 
        }
169
 
        break;
170
 
 
171
 
    case TARGET_SYS_argc:
172
 
        regs[2] = 1;
173
 
        regs[3] = 0;
174
 
        break;
175
 
 
176
 
    case TARGET_SYS_argv_sz:
177
 
        regs[2] = 128;
178
 
        regs[3] = 0;
179
 
        break;
180
 
 
181
 
    case TARGET_SYS_argv:
182
 
        {
183
 
            struct Argv {
184
 
                uint32_t argptr[2];
185
 
                char text[120];
186
 
            } argv = {
187
 
                {0, 0},
188
 
                "test"
189
 
            };
190
 
 
191
 
            argv.argptr[0] = tswap32(regs[3] + offsetof(struct Argv, text));
192
 
            cpu_memory_rw_debug(
193
 
                    env, regs[3], (uint8_t *)&argv, sizeof(argv), 1);
194
 
        }
195
 
        break;
196
 
 
197
 
    case TARGET_SYS_memset:
198
 
        {
199
 
            uint32_t base = regs[3];
200
 
            uint32_t sz = regs[5];
201
 
 
202
 
            while (sz) {
203
 
                target_phys_addr_t len = sz;
204
 
                void *buf = cpu_physical_memory_map(base, &len, 1);
205
 
 
206
 
                if (buf && len) {
207
 
                    memset(buf, regs[4], len);
208
 
                    cpu_physical_memory_unmap(buf, len, 1, len);
209
 
                } else {
210
 
                    len = 1;
211
 
                }
212
 
                base += len;
213
 
                sz -= len;
214
 
            }
215
 
            regs[2] = regs[3];
216
 
            regs[3] = 0;
217
 
        }
218
 
        break;
219
 
 
220
 
    default:
221
 
        qemu_log("%s(%d): not implemented\n", __func__, regs[2]);
222
 
        break;
223
 
    }
224
 
}