1 /* Declarations for use by hardware emulation.  */

     2 #ifndef QEMU_HW_H

     3 #define QEMU_HW_H

     4 

     5 #include "qemu-common.h"

     6 #include "irq.h"

     7 

     8 /* VM Load/Save */

     9 

    10 /* This function writes a chunk of data to a file at the given position.

    11  * The pos argument can be ignored if the file is only being used for

    12  * streaming.  The handler should try to write all of the data it can.

    13  */

    14 typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,

    15                                     int64_t pos, int size);

    16 

    17 /* Read a chunk of data from a file at the given position.  The pos argument

    18  * can be ignored if the file is only be used for streaming.  The number of

    19  * bytes actually read should be returned.

    20  */

    21 typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,

    22                                     int64_t pos, int size);

    23 

    24 /* Close a file and return an error code */

    25 typedef int (QEMUFileCloseFunc)(void *opaque);

    26 

    27 /* Called to determine if the file has exceeded it's bandwidth allocation.  The

    28  * bandwidth capping is a soft limit, not a hard limit.

    29  */

    30 typedef int (QEMUFileRateLimit)(void *opaque);

    31 

    32 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,

    33                          QEMUFileGetBufferFunc *get_buffer,

    34                          QEMUFileCloseFunc *close,

    35                          QEMUFileRateLimit *rate_limit);

    36 QEMUFile *qemu_fopen(const char *filename, const char *mode);

    37 QEMUFile *qemu_fopen_socket(int fd);

    38 QEMUFile *qemu_popen(FILE *popen_file, const char *mode);

    39 QEMUFile *qemu_popen_cmd(const char *command, const char *mode);

    40 void qemu_fflush(QEMUFile *f);

    41 int qemu_fclose(QEMUFile *f);

    42 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);

    43 void qemu_put_byte(QEMUFile *f, int v);

    44 

    45 static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)

    46 {

    47     qemu_put_byte(f, (int)v);

    48 }

    49 

    50 #define qemu_put_sbyte qemu_put_byte

    51 

    52 void qemu_put_be16(QEMUFile *f, unsigned int v);

    53 void qemu_put_be32(QEMUFile *f, unsigned int v);

    54 void qemu_put_be64(QEMUFile *f, uint64_t v);

    55 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);

    56 int qemu_get_byte(QEMUFile *f);

    57 

    58 static inline unsigned int qemu_get_ubyte(QEMUFile *f)

    59 {

    60     return (unsigned int)qemu_get_byte(f);

    61 }

    62 

    63 #define qemu_get_sbyte qemu_get_byte

    64 

    65 unsigned int qemu_get_be16(QEMUFile *f);

    66 unsigned int qemu_get_be32(QEMUFile *f);

    67 uint64_t qemu_get_be64(QEMUFile *f);

    68 int qemu_file_rate_limit(QEMUFile *f);

    69 int qemu_file_has_error(QEMUFile *f);

    70 

    71 /* Try to send any outstanding data.  This function is useful when output is

    72  * halted due to rate limiting or EAGAIN errors occur as it can be used to

    73  * resume output. */

    74 void qemu_file_put_notify(QEMUFile *f);

    75 

    76 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)

    77 {

    78     qemu_put_be64(f, *pv);

    79 }

    80 

    81 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)

    82 {

    83     qemu_put_be32(f, *pv);

    84 }

    85 

    86 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)

    87 {

    88     qemu_put_be16(f, *pv);

    89 }

    90 

    91 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)

    92 {

    93     qemu_put_byte(f, *pv);

    94 }

    95 

    96 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)

    97 {

    98     *pv = qemu_get_be64(f);

    99 }

   100 

   101 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)

   102 {

   103     *pv = qemu_get_be32(f);

   104 }

   105 

   106 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)

   107 {

   108     *pv = qemu_get_be16(f);

   109 }

   110 

   111 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)

   112 {

   113     *pv = qemu_get_byte(f);

   114 }

   115 

   116 // Signed versions for type safety

   117 static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)

   118 {

   119     qemu_put_buffer(f, (const uint8_t *)buf, size);

   120 }

   121 

   122 static inline void qemu_put_sbe16(QEMUFile *f, int v)

   123 {

   124     qemu_put_be16(f, (unsigned int)v);

   125 }

   126 

   127 static inline void qemu_put_sbe32(QEMUFile *f, int v)

   128 {

   129     qemu_put_be32(f, (unsigned int)v);

   130 }

   131 

   132 static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)

   133 {

   134     qemu_put_be64(f, (uint64_t)v);

   135 }

   136 

   137 static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)

   138 {

   139     return qemu_get_buffer(f, (uint8_t *)buf, size);

   140 }

   141 

   142 static inline int qemu_get_sbe16(QEMUFile *f)

   143 {

   144     return (int)qemu_get_be16(f);

   145 }

   146 

   147 static inline int qemu_get_sbe32(QEMUFile *f)

   148 {

   149     return (int)qemu_get_be32(f);

   150 }

   151 

   152 static inline int64_t qemu_get_sbe64(QEMUFile *f)

   153 {

   154     return (int64_t)qemu_get_be64(f);

   155 }

   156 

   157 static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)

   158 {

   159     qemu_put_8s(f, (const uint8_t *)pv);

   160 }

   161 

   162 static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)

   163 {

   164     qemu_put_be16s(f, (const uint16_t *)pv);

   165 }

   166 

   167 static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)

   168 {

   169     qemu_put_be32s(f, (const uint32_t *)pv);

   170 }

   171 

   172 static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)

   173 {

   174     qemu_put_be64s(f, (const uint64_t *)pv);

   175 }

   176 

   177 static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)

   178 {

   179     qemu_get_8s(f, (uint8_t *)pv);

   180 }

   181 

   182 static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)

   183 {

   184     qemu_get_be16s(f, (uint16_t *)pv);

   185 }

   186 

   187 static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)

   188 {

   189     qemu_get_be32s(f, (uint32_t *)pv);

   190 }

   191 

   192 static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)

   193 {

   194     qemu_get_be64s(f, (uint64_t *)pv);

   195 }

   196 

   197 #ifdef NEED_CPU_H

   198 #if TARGET_LONG_BITS == 64

   199 #define qemu_put_betl qemu_put_be64

   200 #define qemu_get_betl qemu_get_be64

   201 #define qemu_put_betls qemu_put_be64s

   202 #define qemu_get_betls qemu_get_be64s

   203 #define qemu_put_sbetl qemu_put_sbe64

   204 #define qemu_get_sbetl qemu_get_sbe64

   205 #define qemu_put_sbetls qemu_put_sbe64s

   206 #define qemu_get_sbetls qemu_get_sbe64s

   207 #else

   208 #define qemu_put_betl qemu_put_be32

   209 #define qemu_get_betl qemu_get_be32

   210 #define qemu_put_betls qemu_put_be32s

   211 #define qemu_get_betls qemu_get_be32s

   212 #define qemu_put_sbetl qemu_put_sbe32

   213 #define qemu_get_sbetl qemu_get_sbe32

   214 #define qemu_put_sbetls qemu_put_sbe32s

   215 #define qemu_get_sbetls qemu_get_sbe32s

   216 #endif

   217 #endif

   218 

   219 int64_t qemu_ftell(QEMUFile *f);

   220 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);

   221 

   222 typedef void SaveStateHandler(QEMUFile *f, void *opaque);

   223 typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque);

   224 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);

   225 

   226 int register_savevm(const char *idstr,

   227                     int instance_id,

   228                     int version_id,

   229                     SaveStateHandler *save_state,

   230                     LoadStateHandler *load_state,

   231                     void *opaque);

   232 

   233 int register_savevm_live(const char *idstr,

   234                          int instance_id,

   235                          int version_id,

   236                          SaveLiveStateHandler *save_live_state,

   237                          SaveStateHandler *save_state,

   238                          LoadStateHandler *load_state,

   239                          void *opaque);

   240 

   241 typedef void QEMUResetHandler(void *opaque);

   242 

   243 void qemu_register_reset(QEMUResetHandler *func, void *opaque);

   244 

   245 /* handler to set the boot_device for a specific type of QEMUMachine */

   246 /* return 0 if success */

   247 typedef int QEMUBootSetHandler(void *opaque, const char *boot_device);

   248 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);

   249 

   250 /* These should really be in isa.h, but are here to make pc.h happy.  */

   251 typedef void (IOPortWriteFunc)(void *opaque, uint32_t address, uint32_t data);

   252 typedef uint32_t (IOPortReadFunc)(void *opaque, uint32_t address);

   253 

   254 #endif