Statistics
| Branch: | Revision:

root / hw / hw.h @ 1ad2134f

History | View | Annotate | Download (7.3 kB)

1 87ecb68b pbrook
/* Declarations for use by hardware emulation.  */
2 87ecb68b pbrook
#ifndef QEMU_HW_H
3 87ecb68b pbrook
#define QEMU_HW_H
4 87ecb68b pbrook
5 87ecb68b pbrook
#include "qemu-common.h"
6 1ad2134f Paul Brook
7 1ad2134f Paul Brook
#if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H)
8 1ad2134f Paul Brook
#include "targphys.h"
9 1ad2134f Paul Brook
#include "poison.h"
10 1ad2134f Paul Brook
#include "cpu-common.h"
11 1ad2134f Paul Brook
#endif
12 1ad2134f Paul Brook
13 87ecb68b pbrook
#include "irq.h"
14 87ecb68b pbrook
15 87ecb68b pbrook
/* VM Load/Save */
16 87ecb68b pbrook
17 5dafc53f aliguori
/* This function writes a chunk of data to a file at the given position.
18 5dafc53f aliguori
 * The pos argument can be ignored if the file is only being used for
19 5dafc53f aliguori
 * streaming.  The handler should try to write all of the data it can.
20 5dafc53f aliguori
 */
21 871d2f07 aliguori
typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
22 871d2f07 aliguori
                                    int64_t pos, int size);
23 5dafc53f aliguori
24 5dafc53f aliguori
/* Read a chunk of data from a file at the given position.  The pos argument
25 5dafc53f aliguori
 * can be ignored if the file is only be used for streaming.  The number of
26 5dafc53f aliguori
 * bytes actually read should be returned.
27 5dafc53f aliguori
 */
28 5dafc53f aliguori
typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
29 5dafc53f aliguori
                                    int64_t pos, int size);
30 5dafc53f aliguori
31 5dafc53f aliguori
/* Close a file and return an error code */
32 5dafc53f aliguori
typedef int (QEMUFileCloseFunc)(void *opaque);
33 5dafc53f aliguori
34 5dafc53f aliguori
/* Called to determine if the file has exceeded it's bandwidth allocation.  The
35 5dafc53f aliguori
 * bandwidth capping is a soft limit, not a hard limit.
36 5dafc53f aliguori
 */
37 5dafc53f aliguori
typedef int (QEMUFileRateLimit)(void *opaque);
38 5dafc53f aliguori
39 5dafc53f aliguori
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
40 5dafc53f aliguori
                         QEMUFileGetBufferFunc *get_buffer,
41 5dafc53f aliguori
                         QEMUFileCloseFunc *close,
42 5dafc53f aliguori
                         QEMUFileRateLimit *rate_limit);
43 87ecb68b pbrook
QEMUFile *qemu_fopen(const char *filename, const char *mode);
44 c1d36665 aliguori
QEMUFile *qemu_fopen_socket(int fd);
45 065e2813 aliguori
QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
46 065e2813 aliguori
QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
47 87ecb68b pbrook
void qemu_fflush(QEMUFile *f);
48 5dafc53f aliguori
int qemu_fclose(QEMUFile *f);
49 2ca83a8d blueswir1
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
50 2ca83a8d blueswir1
void qemu_put_byte(QEMUFile *f, int v);
51 b6c4f71f blueswir1
52 b6c4f71f blueswir1
static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
53 b6c4f71f blueswir1
{
54 b6c4f71f blueswir1
    qemu_put_byte(f, (int)v);
55 b6c4f71f blueswir1
}
56 b6c4f71f blueswir1
57 b6c4f71f blueswir1
#define qemu_put_sbyte qemu_put_byte
58 b6c4f71f blueswir1
59 2ca83a8d blueswir1
void qemu_put_be16(QEMUFile *f, unsigned int v);
60 2ca83a8d blueswir1
void qemu_put_be32(QEMUFile *f, unsigned int v);
61 87ecb68b pbrook
void qemu_put_be64(QEMUFile *f, uint64_t v);
62 2ca83a8d blueswir1
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
63 2ca83a8d blueswir1
int qemu_get_byte(QEMUFile *f);
64 b6c4f71f blueswir1
65 b6c4f71f blueswir1
static inline unsigned int qemu_get_ubyte(QEMUFile *f)
66 b6c4f71f blueswir1
{
67 b6c4f71f blueswir1
    return (unsigned int)qemu_get_byte(f);
68 b6c4f71f blueswir1
}
69 b6c4f71f blueswir1
70 b6c4f71f blueswir1
#define qemu_get_sbyte qemu_get_byte
71 b6c4f71f blueswir1
72 2ca83a8d blueswir1
unsigned int qemu_get_be16(QEMUFile *f);
73 2ca83a8d blueswir1
unsigned int qemu_get_be32(QEMUFile *f);
74 87ecb68b pbrook
uint64_t qemu_get_be64(QEMUFile *f);
75 5dafc53f aliguori
int qemu_file_rate_limit(QEMUFile *f);
76 871d2f07 aliguori
int qemu_file_has_error(QEMUFile *f);
77 4dabe248 aliguori
void qemu_file_set_error(QEMUFile *f);
78 5dafc53f aliguori
79 5dafc53f aliguori
/* Try to send any outstanding data.  This function is useful when output is
80 5dafc53f aliguori
 * halted due to rate limiting or EAGAIN errors occur as it can be used to
81 5dafc53f aliguori
 * resume output. */
82 5dafc53f aliguori
void qemu_file_put_notify(QEMUFile *f);
83 87ecb68b pbrook
84 87ecb68b pbrook
static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
85 87ecb68b pbrook
{
86 87ecb68b pbrook
    qemu_put_be64(f, *pv);
87 87ecb68b pbrook
}
88 87ecb68b pbrook
89 87ecb68b pbrook
static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
90 87ecb68b pbrook
{
91 87ecb68b pbrook
    qemu_put_be32(f, *pv);
92 87ecb68b pbrook
}
93 87ecb68b pbrook
94 87ecb68b pbrook
static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
95 87ecb68b pbrook
{
96 87ecb68b pbrook
    qemu_put_be16(f, *pv);
97 87ecb68b pbrook
}
98 87ecb68b pbrook
99 87ecb68b pbrook
static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
100 87ecb68b pbrook
{
101 87ecb68b pbrook
    qemu_put_byte(f, *pv);
102 87ecb68b pbrook
}
103 87ecb68b pbrook
104 87ecb68b pbrook
static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
105 87ecb68b pbrook
{
106 87ecb68b pbrook
    *pv = qemu_get_be64(f);
107 87ecb68b pbrook
}
108 87ecb68b pbrook
109 87ecb68b pbrook
static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
110 87ecb68b pbrook
{
111 87ecb68b pbrook
    *pv = qemu_get_be32(f);
112 87ecb68b pbrook
}
113 87ecb68b pbrook
114 87ecb68b pbrook
static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
115 87ecb68b pbrook
{
116 87ecb68b pbrook
    *pv = qemu_get_be16(f);
117 87ecb68b pbrook
}
118 87ecb68b pbrook
119 87ecb68b pbrook
static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
120 87ecb68b pbrook
{
121 87ecb68b pbrook
    *pv = qemu_get_byte(f);
122 87ecb68b pbrook
}
123 87ecb68b pbrook
124 b6c4f71f blueswir1
// Signed versions for type safety
125 b6c4f71f blueswir1
static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
126 b6c4f71f blueswir1
{
127 b6c4f71f blueswir1
    qemu_put_buffer(f, (const uint8_t *)buf, size);
128 b6c4f71f blueswir1
}
129 b6c4f71f blueswir1
130 b6c4f71f blueswir1
static inline void qemu_put_sbe16(QEMUFile *f, int v)
131 b6c4f71f blueswir1
{
132 b6c4f71f blueswir1
    qemu_put_be16(f, (unsigned int)v);
133 b6c4f71f blueswir1
}
134 b6c4f71f blueswir1
135 b6c4f71f blueswir1
static inline void qemu_put_sbe32(QEMUFile *f, int v)
136 b6c4f71f blueswir1
{
137 b6c4f71f blueswir1
    qemu_put_be32(f, (unsigned int)v);
138 b6c4f71f blueswir1
}
139 b6c4f71f blueswir1
140 b6c4f71f blueswir1
static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
141 b6c4f71f blueswir1
{
142 b6c4f71f blueswir1
    qemu_put_be64(f, (uint64_t)v);
143 b6c4f71f blueswir1
}
144 b6c4f71f blueswir1
145 b6c4f71f blueswir1
static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
146 b6c4f71f blueswir1
{
147 b6c4f71f blueswir1
    return qemu_get_buffer(f, (uint8_t *)buf, size);
148 b6c4f71f blueswir1
}
149 b6c4f71f blueswir1
150 b6c4f71f blueswir1
static inline int qemu_get_sbe16(QEMUFile *f)
151 b6c4f71f blueswir1
{
152 b6c4f71f blueswir1
    return (int)qemu_get_be16(f);
153 b6c4f71f blueswir1
}
154 b6c4f71f blueswir1
155 b6c4f71f blueswir1
static inline int qemu_get_sbe32(QEMUFile *f)
156 b6c4f71f blueswir1
{
157 b6c4f71f blueswir1
    return (int)qemu_get_be32(f);
158 b6c4f71f blueswir1
}
159 b6c4f71f blueswir1
160 b6c4f71f blueswir1
static inline int64_t qemu_get_sbe64(QEMUFile *f)
161 b6c4f71f blueswir1
{
162 b6c4f71f blueswir1
    return (int64_t)qemu_get_be64(f);
163 b6c4f71f blueswir1
}
164 b6c4f71f blueswir1
165 b6c4f71f blueswir1
static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
166 b6c4f71f blueswir1
{
167 b6c4f71f blueswir1
    qemu_put_8s(f, (const uint8_t *)pv);
168 b6c4f71f blueswir1
}
169 b6c4f71f blueswir1
170 b6c4f71f blueswir1
static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
171 b6c4f71f blueswir1
{
172 b6c4f71f blueswir1
    qemu_put_be16s(f, (const uint16_t *)pv);
173 b6c4f71f blueswir1
}
174 b6c4f71f blueswir1
175 b6c4f71f blueswir1
static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
176 b6c4f71f blueswir1
{
177 b6c4f71f blueswir1
    qemu_put_be32s(f, (const uint32_t *)pv);
178 b6c4f71f blueswir1
}
179 b6c4f71f blueswir1
180 b6c4f71f blueswir1
static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
181 b6c4f71f blueswir1
{
182 b6c4f71f blueswir1
    qemu_put_be64s(f, (const uint64_t *)pv);
183 b6c4f71f blueswir1
}
184 b6c4f71f blueswir1
185 b6c4f71f blueswir1
static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
186 b6c4f71f blueswir1
{
187 b6c4f71f blueswir1
    qemu_get_8s(f, (uint8_t *)pv);
188 b6c4f71f blueswir1
}
189 b6c4f71f blueswir1
190 b6c4f71f blueswir1
static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
191 b6c4f71f blueswir1
{
192 b6c4f71f blueswir1
    qemu_get_be16s(f, (uint16_t *)pv);
193 b6c4f71f blueswir1
}
194 b6c4f71f blueswir1
195 b6c4f71f blueswir1
static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
196 b6c4f71f blueswir1
{
197 b6c4f71f blueswir1
    qemu_get_be32s(f, (uint32_t *)pv);
198 b6c4f71f blueswir1
}
199 b6c4f71f blueswir1
200 b6c4f71f blueswir1
static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
201 b6c4f71f blueswir1
{
202 b6c4f71f blueswir1
    qemu_get_be64s(f, (uint64_t *)pv);
203 b6c4f71f blueswir1
}
204 b6c4f71f blueswir1
205 87ecb68b pbrook
#ifdef NEED_CPU_H
206 87ecb68b pbrook
#if TARGET_LONG_BITS == 64
207 87ecb68b pbrook
#define qemu_put_betl qemu_put_be64
208 87ecb68b pbrook
#define qemu_get_betl qemu_get_be64
209 87ecb68b pbrook
#define qemu_put_betls qemu_put_be64s
210 87ecb68b pbrook
#define qemu_get_betls qemu_get_be64s
211 b6c4f71f blueswir1
#define qemu_put_sbetl qemu_put_sbe64
212 b6c4f71f blueswir1
#define qemu_get_sbetl qemu_get_sbe64
213 b6c4f71f blueswir1
#define qemu_put_sbetls qemu_put_sbe64s
214 b6c4f71f blueswir1
#define qemu_get_sbetls qemu_get_sbe64s
215 87ecb68b pbrook
#else
216 87ecb68b pbrook
#define qemu_put_betl qemu_put_be32
217 87ecb68b pbrook
#define qemu_get_betl qemu_get_be32
218 87ecb68b pbrook
#define qemu_put_betls qemu_put_be32s
219 87ecb68b pbrook
#define qemu_get_betls qemu_get_be32s
220 b6c4f71f blueswir1
#define qemu_put_sbetl qemu_put_sbe32
221 b6c4f71f blueswir1
#define qemu_get_sbetl qemu_get_sbe32
222 b6c4f71f blueswir1
#define qemu_put_sbetls qemu_put_sbe32s
223 b6c4f71f blueswir1
#define qemu_get_sbetls qemu_get_sbe32s
224 87ecb68b pbrook
#endif
225 87ecb68b pbrook
#endif
226 87ecb68b pbrook
227 87ecb68b pbrook
int64_t qemu_ftell(QEMUFile *f);
228 87ecb68b pbrook
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
229 87ecb68b pbrook
230 87ecb68b pbrook
typedef void SaveStateHandler(QEMUFile *f, void *opaque);
231 9366f418 aliguori
typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque);
232 87ecb68b pbrook
typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
233 87ecb68b pbrook
234 87ecb68b pbrook
int register_savevm(const char *idstr,
235 87ecb68b pbrook
                    int instance_id,
236 87ecb68b pbrook
                    int version_id,
237 87ecb68b pbrook
                    SaveStateHandler *save_state,
238 87ecb68b pbrook
                    LoadStateHandler *load_state,
239 87ecb68b pbrook
                    void *opaque);
240 87ecb68b pbrook
241 9366f418 aliguori
int register_savevm_live(const char *idstr,
242 9366f418 aliguori
                         int instance_id,
243 9366f418 aliguori
                         int version_id,
244 9366f418 aliguori
                         SaveLiveStateHandler *save_live_state,
245 9366f418 aliguori
                         SaveStateHandler *save_state,
246 9366f418 aliguori
                         LoadStateHandler *load_state,
247 9366f418 aliguori
                         void *opaque);
248 9366f418 aliguori
249 41bd13af aliguori
void unregister_savevm(const char *idstr, void *opaque);
250 41bd13af aliguori
251 87ecb68b pbrook
typedef void QEMUResetHandler(void *opaque);
252 87ecb68b pbrook
253 87ecb68b pbrook
void qemu_register_reset(QEMUResetHandler *func, void *opaque);
254 87ecb68b pbrook
255 0ecdffbb aurel32
/* handler to set the boot_device for a specific type of QEMUMachine */
256 0ecdffbb aurel32
/* return 0 if success */
257 3b4366de blueswir1
typedef int QEMUBootSetHandler(void *opaque, const char *boot_device);
258 3b4366de blueswir1
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
259 0ecdffbb aurel32
260 87ecb68b pbrook
/* These should really be in isa.h, but are here to make pc.h happy.  */
261 87ecb68b pbrook
typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);
262 87ecb68b pbrook
typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);
263 87ecb68b pbrook
264 87ecb68b pbrook
#endif