Author: stepan Date: 2009-12-05 16:47:43 +0100 (Sat, 05 Dec 2009) New Revision: 88
Modified: trunk/qemu-0.11.0/serialice.c trunk/qemu-0.11.0/serialice.h Log: re-indent, this time correctly (no tabs) and preserve the indent line. Signed-off-by: Stefan Reinauer stepan@coresystems.de
Modified: trunk/qemu-0.11.0/serialice.c =================================================================== --- trunk/qemu-0.11.0/serialice.c 2009-12-05 15:02:29 UTC (rev 87) +++ trunk/qemu-0.11.0/serialice.c 2009-12-05 15:47:43 UTC (rev 88) @@ -22,6 +22,10 @@ * THE SOFTWARE. */
+/* Indented with: + * gnuindent -npro -kr -i4 -nut -bap -sob -l80 -ss -ncs serialice.* + */ + /* System includes */ #include <stdlib.h> #include <stdio.h> @@ -94,16 +98,16 @@ ram_addr_t phys;
if (n != 2) { - fprintf(stderr, - "ERROR: Not called as SerialICE_register_physical(<addr> <size>)\n"); - return 0; + fprintf(stderr, + "ERROR: Not called as SerialICE_register_physical(<addr> <size>)\n"); + return 0; }
addr = lua_tointeger(luastate, 1); size = lua_tointeger(luastate, 2);
printf("Registering physical memory at 0x%08x (0x%08x bytes)\n", addr, - size); + size); phys = qemu_ram_alloc(size); cpu_register_physical_memory(addr, size, phys);
@@ -171,25 +175,25 @@ const char *key = luaL_checkstring(L, 2); int ret = 1; if (strcmp(key, "eax") == 0) { - lua_pushinteger(L, EAX); + lua_pushinteger(L, EAX); } else if (strcmp(key, "ecx") == 0) { - lua_pushinteger(L, ECX); + lua_pushinteger(L, ECX); } else if (strcmp(key, "edx") == 0) { - lua_pushinteger(L, EDX); + lua_pushinteger(L, EDX); } else if (strcmp(key, "ebx") == 0) { - lua_pushinteger(L, EBX); + lua_pushinteger(L, EBX); } else if (strcmp(key, "esp") == 0) { - lua_pushinteger(L, ESP); + lua_pushinteger(L, ESP); } else if (strcmp(key, "ebp") == 0) { - lua_pushinteger(L, EBP); + lua_pushinteger(L, EBP); } else if (strcmp(key, "esi") == 0) { - lua_pushinteger(L, ESI); + lua_pushinteger(L, ESI); } else if (strcmp(key, "edi") == 0) { - lua_pushinteger(L, EDI); + lua_pushinteger(L, EDI); } else if (strcmp(key, "eip") == 0) { - lua_pushinteger(L, EIP); + lua_pushinteger(L, EIP); } else if (strcmp(key, "cs") == 0) { - lua_pushinteger(L, (CS >> 4)); + lua_pushinteger(L, (CS >> 4)); } else { lua_pushstring(L, "No such register."); lua_error(L); @@ -197,14 +201,15 @@ } return ret; } + #undef env
static int serialice_lua_registers(void) { const struct luaL_Reg registermt[] = { - {"__index", register_get}, - {"__newindex", register_set}, - {NULL, NULL} + {"__index", register_get}, + {"__newindex", register_set}, + {NULL, NULL} };
lua_newuserdata(L, sizeof(void *)); @@ -238,16 +243,16 @@ /* Load the script file */ status = luaL_loadfile(L, serialice_lua_script); if (status) { - fprintf(stderr, "Couldn't load SerialICE script: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Couldn't load SerialICE script: %s\n", + lua_tostring(L, -1)); + exit(1); }
/* Ask Lua to run our little script */ status = lua_pcall(L, 0, 1, 0); if (status) { - fprintf(stderr, "Failed to run script: %s\n", lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Failed to run script: %s\n", lua_tostring(L, -1)); + exit(1); } lua_pop(L, 1);
@@ -265,10 +270,10 @@ int error; char *errstring = NULL; error = luaL_loadbuffer(L, cmd, strlen(cmd), "line") - || lua_pcall(L, 0, 0, 0); + || lua_pcall(L, 0, 0, 0); if (error) { - errstring = strdup(lua_tostring(L, -1)); - lua_pop(L, 1); + errstring = strdup(lua_tostring(L, -1)); + lua_pop(L, 1); }
return errstring; @@ -279,13 +284,13 @@ int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_filter"); - lua_pushinteger(L, port); // port - lua_pushinteger(L, size); // datasize + lua_pushinteger(L, port); // port + lua_pushinteger(L, size); // datasize result = lua_pcall(L, 2, 2, 0); if (result) { - fprintf(stderr, "Failed to run function SerialICE_io_read_filter: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Failed to run function SerialICE_io_read_filter: %s\n", + lua_tostring(L, -1)); + exit(1); } *data = lua_tointeger(L, -1); ret = lua_toboolean(L, -2); @@ -299,16 +304,16 @@ int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_filter"); - lua_pushinteger(L, port); // port - lua_pushinteger(L, size); // datasize - lua_pushinteger(L, *data); // data + lua_pushinteger(L, port); // port + lua_pushinteger(L, size); // datasize + lua_pushinteger(L, *data); // data
result = lua_pcall(L, 3, 2, 0); if (result) { - fprintf(stderr, - "Failed to run function SerialICE_io_write_filter: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, + "Failed to run function SerialICE_io_write_filter: %s\n", + lua_tostring(L, -1)); + exit(1); } *data = lua_tointeger(L, -1); ret = lua_toboolean(L, -2); @@ -320,25 +325,25 @@ #define READ_FROM_QEMU (1 << 0) #define READ_FROM_SERIALICE (1 << 1) static int serialice_memory_read_filter(uint32_t addr, uint32_t * data, - int size) + int size) { int ret = 0, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_filter"); - lua_pushinteger(L, addr); // addr - lua_pushinteger(L, size); // datasize + lua_pushinteger(L, addr); // addr + lua_pushinteger(L, size); // datasize result = lua_pcall(L, 2, 3, 0); if (result) { - fprintf(stderr, - "Failed to run function SerialICE_memory_read_filter: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, + "Failed to run function SerialICE_memory_read_filter: %s\n", + lua_tostring(L, -1)); + exit(1); }
- *data = lua_tointeger(L, -1); // result + *data = lua_tointeger(L, -1); // result
- ret |= lua_toboolean(L, -2) ? READ_FROM_QEMU : 0; // to_qemu - ret |= lua_toboolean(L, -3) ? READ_FROM_SERIALICE : 0; // to_hw + ret |= lua_toboolean(L, -2) ? READ_FROM_QEMU : 0; // to_qemu + ret |= lua_toboolean(L, -3) ? READ_FROM_SERIALICE : 0; // to_hw
lua_pop(L, 3);
@@ -349,21 +354,21 @@ #define WRITE_TO_SERIALICE (1 << 1)
static int serialice_memory_write_filter(uint32_t addr, int size, - uint32_t * data) + uint32_t * data) { int ret = 0, result; int write_to_qemu, write_to_serialice;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_filter"); - lua_pushinteger(L, addr); // address - lua_pushinteger(L, size); // datasize - lua_pushinteger(L, *data); // data + lua_pushinteger(L, addr); // address + lua_pushinteger(L, size); // datasize + lua_pushinteger(L, *data); // data result = lua_pcall(L, 3, 3, 0); if (result) { - fprintf(stderr, - "Failed to run function SerialICE_memory_write_filter: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, + "Failed to run function SerialICE_memory_write_filter: %s\n", + lua_tostring(L, -1)); + exit(1); } *data = lua_tointeger(L, -1); write_to_qemu = lua_toboolean(L, -2); @@ -380,30 +385,30 @@ #define FILTER_WRITE 1
static int serialice_msr_filter(int flags, uint32_t addr, uint32_t * hi, - uint32_t * lo) + uint32_t * lo) { int ret, result;
if (flags & FILTER_WRITE) { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_filter"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_filter"); } else { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_filter"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_filter"); }
- lua_pushinteger(L, addr); // port - lua_pushinteger(L, *hi); // high - lua_pushinteger(L, *lo); // low + lua_pushinteger(L, addr); // port + lua_pushinteger(L, *hi); // high + lua_pushinteger(L, *lo); // low result = lua_pcall(L, 3, 3, 0); if (result) { - fprintf(stderr, - "Failed to run function SerialICE_msr_%s_filter: %s\n", - (flags & FILTER_WRITE)?"write":"read", lua_tostring(L, -1)); - exit(1); + fprintf(stderr, + "Failed to run function SerialICE_msr_%s_filter: %s\n", + (flags & FILTER_WRITE) ? "write" : "read", lua_tostring(L, -1)); + exit(1); } ret = lua_toboolean(L, -3); if (ret) { - *hi = lua_tointeger(L, -1); - *lo = lua_tointeger(L, -2); + *hi = lua_tointeger(L, -1); + *lo = lua_tointeger(L, -2); } lua_pop(L, 3);
@@ -411,33 +416,33 @@ }
static int serialice_cpuid_filter(uint32_t eax, uint32_t ecx, - cpuid_regs_t * regs) + cpuid_regs_t * regs) { int ret, result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_cpuid_filter");
- lua_pushinteger(L, eax); // eax before calling - lua_pushinteger(L, ecx); // ecx before calling + lua_pushinteger(L, eax); // eax before calling + lua_pushinteger(L, ecx); // ecx before calling // and the registers after calling cpuid - lua_pushinteger(L, regs->eax); // eax - lua_pushinteger(L, regs->ebx); // ebx - lua_pushinteger(L, regs->ecx); // ecx - lua_pushinteger(L, regs->edx); // edx + lua_pushinteger(L, regs->eax); // eax + lua_pushinteger(L, regs->ebx); // ebx + lua_pushinteger(L, regs->ecx); // ecx + lua_pushinteger(L, regs->edx); // edx result = lua_pcall(L, 6, 5, 0); if (result) { - fprintf(stderr, - "Failed to run function SerialICE_cpuid_filter: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, + "Failed to run function SerialICE_cpuid_filter: %s\n", + lua_tostring(L, -1)); + exit(1); }
ret = lua_toboolean(L, -5); if (ret) { - regs->eax = lua_tointeger(L, -4); - regs->ebx = lua_tointeger(L, -3); - regs->ecx = lua_tointeger(L, -2); - regs->edx = lua_tointeger(L, -1); + regs->eax = lua_tointeger(L, -4); + regs->ebx = lua_tointeger(L, -3); + regs->ecx = lua_tointeger(L, -2); + regs->edx = lua_tointeger(L, -1); } lua_pop(L, 5);
@@ -459,71 +464,71 @@ int result;
if ((flags & LOG_WRITE) && (flags & LOG_MEMORY)) { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_log"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_write_log"); } else if (!(flags & LOG_WRITE) && (flags & LOG_MEMORY)) { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_log"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_memory_read_log"); } else if ((flags & LOG_WRITE) && !(flags & LOG_MEMORY)) { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_log"); - } else { // if (!(flags & LOG_WRITE) && !(flags & LOG_MEMORY)) - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_log"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_write_log"); + } else { // if (!(flags & LOG_WRITE) && !(flags & LOG_MEMORY)) + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_io_read_log"); }
- lua_pushinteger(L, addr); // addr/port - lua_pushinteger(L, size); // datasize - lua_pushinteger(L, data); // data + lua_pushinteger(L, addr); // addr/port + lua_pushinteger(L, size); // datasize + lua_pushinteger(L, data); // data lua_pushboolean(L, ((flags & LOG_TARGET) != 0));
result = lua_pcall(L, 4, 0, 0); if (result) { - fprintf(stderr, "Failed to run function SerialICE_%s_%s_log: %s\n", - (flags & LOG_MEMORY) ? "memory" : "io", - (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Failed to run function SerialICE_%s_%s_log: %s\n", + (flags & LOG_MEMORY) ? "memory" : "io", + (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1)); + exit(1); } }
static void serialice_msr_log(int flags, uint32_t addr, uint32_t hi, - uint32_t lo, int filtered) + uint32_t lo, int filtered) { int result;
if (flags & LOG_WRITE) { - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_log"); - } else { // if (!(flags & LOG_WRITE)) - lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_log"); + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_write_log"); + } else { // if (!(flags & LOG_WRITE)) + lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_msr_read_log"); }
- lua_pushinteger(L, addr); // addr/port - lua_pushinteger(L, hi); // datasize - lua_pushinteger(L, lo); // data - lua_pushboolean(L, filtered); // data + lua_pushinteger(L, addr); // addr/port + lua_pushinteger(L, hi); // datasize + lua_pushinteger(L, lo); // data + lua_pushboolean(L, filtered); // data result = lua_pcall(L, 4, 0, 0); if (result) { - fprintf(stderr, "Failed to run function SerialICE_msr_%s_log: %s\n", - (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Failed to run function SerialICE_msr_%s_log: %s\n", + (flags & LOG_WRITE) ? "write" : "read", lua_tostring(L, -1)); + exit(1); } }
static void serialice_cpuid_log(uint32_t eax, uint32_t ecx, cpuid_regs_t res, - int filtered) + int filtered) { int result;
lua_getfield(L, LUA_GLOBALSINDEX, "SerialICE_cpuid_log");
- lua_pushinteger(L, eax); // input: eax - lua_pushinteger(L, ecx); // input: ecx - lua_pushinteger(L, res.eax); // output: eax - lua_pushinteger(L, res.ebx); // output: ebx - lua_pushinteger(L, res.ecx); // output: ecx - lua_pushinteger(L, res.edx); // output: edx - lua_pushboolean(L, filtered); // data + lua_pushinteger(L, eax); // input: eax + lua_pushinteger(L, ecx); // input: ecx + lua_pushinteger(L, res.eax); // output: eax + lua_pushinteger(L, res.ebx); // output: ebx + lua_pushinteger(L, res.ecx); // output: ecx + lua_pushinteger(L, res.edx); // output: edx + lua_pushboolean(L, filtered); // data result = lua_pcall(L, 7, 0, 0); if (result) { - fprintf(stderr, "Failed to run function SerialICE_cpuid_log: %s\n", - lua_tostring(L, -1)); - exit(1); + fprintf(stderr, "Failed to run function SerialICE_cpuid_log: %s\n", + lua_tostring(L, -1)); + exit(1); } }
@@ -536,29 +541,29 @@
while (1) { #ifdef WIN32 - int ret = 0; - ReadFile(state->fd, buf, nbyte - bytes_read, &ret, NULL); - if (!ret) { - break; - } + int ret = 0; + ReadFile(state->fd, buf, nbyte - bytes_read, &ret, NULL); + if (!ret) { + break; + } #else - int ret = read(state->fd, buf, nbyte - bytes_read); + int ret = read(state->fd, buf, nbyte - bytes_read);
- if (ret == -1 && errno == EINTR) { - continue; - } + if (ret == -1 && errno == EINTR) { + continue; + }
- if (ret == -1) { - break; - } + if (ret == -1) { + break; + } #endif
- bytes_read += ret; - buf += ret; + bytes_read += ret; + buf += ret;
- if (bytes_read >= (int)nbyte) { - break; - } + if (bytes_read >= (int)nbyte) { + break; + } }
return bytes_read; @@ -567,7 +572,7 @@ static int handshake_mode = 0;
static int serialice_write(SerialICEState * state, const void *buf, - size_t nbyte) + size_t nbyte) { char *buffer = (char *)buf; char c; @@ -575,21 +580,21 @@
for (i = 0; i < (int)nbyte; i++) { #ifdef WIN32 - int ret = 0; - while (ret == 0) { - WriteFile(state->fd, buffer + i, 1, &ret, NULL); - } - ret = 0; - while (ret == 0) { - ReadFile(state->fd, &c, 1, &ret, NULL); - } + int ret = 0; + while (ret == 0) { + WriteFile(state->fd, buffer + i, 1, &ret, NULL); + } + ret = 0; + while (ret == 0) { + ReadFile(state->fd, &c, 1, &ret, NULL); + } #else - while (write(state->fd, buffer + i, 1) != 1) ; - while (read(state->fd, &c, 1) != 1) ; + while (write(state->fd, buffer + i, 1) != 1) ; + while (read(state->fd, &c, 1) != 1) ; #endif - if (c != buffer[i] && !handshake_mode) { - printf("Readback error! %x/%x\n", c, buffer[i]); - } + if (c != buffer[i] && !handshake_mode) { + printf("Readback error! %x/%x\n", c, buffer[i]); + } }
return nbyte; @@ -603,18 +608,18 @@ l = serialice_read(s, buf, 3);
if (l == -1) { - perror("SerialICE: Could not read from target"); - exit(1); + perror("SerialICE: Could not read from target"); + exit(1); }
while (buf[0] != '\n' || buf[1] != '>' || buf[2] != ' ') { - buf[0] = buf[1]; - buf[1] = buf[2]; - l = serialice_read(s, buf + 2, 1); - if (l == -1) { - perror("SerialICE: Could not read from target"); - exit(1); - } + buf[0] = buf[1]; + buf[1] = buf[2]; + l = serialice_read(s, buf + 2, 1); + if (l == -1) { + perror("SerialICE: Could not read from target"); + exit(1); + } }
return 0; @@ -631,28 +636,28 @@
serialice_write(s, command, strlen(command));
- memset(s->buffer, 0, reply_len + 1); // clear enough of the buffer + memset(s->buffer, 0, reply_len + 1); // clear enough of the buffer
l = serialice_read(s, s->buffer, reply_len);
if (l == -1) { - perror("SerialICE: Could not read from target"); - exit(1); + perror("SerialICE: Could not read from target"); + exit(1); } // compensate for CR on the wire. Needed on Win32 if (s->buffer[0] == '\r') { - memmove(s->buffer, s->buffer + 1, reply_len); - serialice_read(s, s->buffer + reply_len - 1, 1); + memmove(s->buffer, s->buffer + 1, reply_len); + serialice_read(s, s->buffer + reply_len - 1, 1); }
if (l != reply_len) { - printf("SerialICE: command was not answered sufficiently: " - "(%d/%d bytes)\n'%s'\n", l, reply_len, s->buffer); - exit(1); + printf("SerialICE: command was not answered sufficiently: " + "(%d/%d bytes)\n'%s'\n", l, reply_len, s->buffer); + exit(1); } #if SERIALICE_DEBUG > 5 for (i = 0; i < reply_len; i++) { - printf("%02x ", s->buffer[i]); + printf("%02x ", s->buffer[i]); } printf("\n"); #endif @@ -671,7 +676,7 @@ serialice_read(s, s->buffer, 1); serialice_read(s, s->buffer, 1); while (s->buffer[len++] != '\n') { - serialice_read(s, s->buffer + len, 1); + serialice_read(s, s->buffer + len, 1); } s->buffer[len - 1] = '\0';
@@ -685,7 +690,7 @@ printf("SerialICE: Mainboard...: "); serialice_command("*mb", 32); while (len && s->buffer[len] == ' ') { - s->buffer[len--] = '\0'; + s->buffer[len--] = '\0'; } serialice_mainboard = strdup(s->buffer + 1); printf("%s\n", serialice_mainboard); @@ -697,7 +702,7 @@ uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) { - return data & 0xff; + return data & 0xff; }
sprintf(s->command, "*ri%04x.b", port); @@ -716,7 +721,7 @@ uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) { - return data & 0xffff; + return data & 0xffff; }
sprintf(s->command, "*ri%04x.w", port); @@ -735,7 +740,7 @@ uint32_t data;
if (serialice_io_read_filter(&data, port, 1)) { - return data; + return data; }
sprintf(s->command, "*ri%04x.l", port); @@ -755,7 +760,7 @@ serialice_log(LOG_WRITE | LOG_IO, data, port, 1);
if (serialice_io_write_filter(&filtered_data, port, 1)) { - return; + return; }
data = (uint8_t) filtered_data; @@ -770,7 +775,7 @@ serialice_log(LOG_WRITE | LOG_IO, data, port, 2);
if (serialice_io_write_filter(&filtered_data, port, 2)) { - return; + return; }
data = (uint16_t) filtered_data; @@ -785,7 +790,7 @@ serialice_log(LOG_WRITE | LOG_IO, data, port, 4);
if (serialice_io_write_filter(&filtered_data, port, 4)) { - return; + return; }
data = filtered_data; @@ -849,14 +854,14 @@
filtered = serialice_msr_filter(FILTER_READ, addr, &hi, &lo); if (!filtered) { - sprintf(s->command, "*rc%08x.%08x", addr, key); + sprintf(s->command, "*rc%08x.%08x", addr, key);
- // command read back: "\n00000000.00000000" (18 characters) - serialice_command(s->command, 18); + // command read back: "\n00000000.00000000" (18 characters) + serialice_command(s->command, 18);
- s->buffer[9] = 0; // . -> \0 - hi = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16); - lo = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16); + s->buffer[9] = 0; // . -> \0 + hi = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16); + lo = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16); }
ret = hi; @@ -879,8 +884,8 @@ filtered = serialice_msr_filter(FILTER_WRITE, addr, &hi, &lo);
if (!filtered) { - sprintf(s->command, "*wc%08x.%08x=%08x.%08x", addr, key, hi, lo); - serialice_command(s->command, 0); + sprintf(s->command, "*wc%08x.%08x=%08x.%08x", addr, key, hi, lo); + serialice_command(s->command, 0); }
serialice_msr_log(LOG_WRITE, addr, hi, lo, filtered); @@ -892,19 +897,19 @@ int filtered;
ret.eax = eax; - ret.ebx = 0; // either set by filter or by target + ret.ebx = 0; // either set by filter or by target ret.ecx = ecx; - ret.edx = 0; // either set by filter or by target + ret.edx = 0; // either set by filter or by target
sprintf(s->command, "*ci%08x.%08x", eax, ecx);
// command read back: "\n000006f2.00000000.00001234.12340324" // (36 characters) serialice_command(s->command, 36); - - s->buffer[9] = 0; // . -> \0 - s->buffer[18] = 0; // . -> \0 - s->buffer[27] = 0; // . -> \0 + + s->buffer[9] = 0; // . -> \0 + s->buffer[18] = 0; // . -> \0 + s->buffer[27] = 0; // . -> \0 ret.eax = (uint32_t) strtoul(s->buffer + 1, (char **)NULL, 16); ret.ebx = (uint32_t) strtoul(s->buffer + 10, (char **)NULL, 16); ret.ecx = (uint32_t) strtoul(s->buffer + 19, (char **)NULL, 16); @@ -924,13 +929,13 @@ { switch (size) { case 1: - return (uint32_t) serialice_readb(addr); + return (uint32_t) serialice_readb(addr); case 2: - return (uint32_t) serialice_readw(addr); + return (uint32_t) serialice_readw(addr); case 4: - return (uint32_t) serialice_readl(addr); + return (uint32_t) serialice_readl(addr); default: - printf("WARNING: unknown read access size %d @%08x\n", size, addr); + printf("WARNING: unknown read access size %d @%08x\n", size, addr); } return 0; } @@ -940,13 +945,13 @@ * of a load cycle */ void serialice_log_load(int caught, uint32_t addr, uint32_t result, - unsigned int data_size) + unsigned int data_size) { if (caught) { - serialice_log(LOG_READ | LOG_MEMORY | LOG_TARGET, result, addr, - data_size); + serialice_log(LOG_READ | LOG_MEMORY | LOG_TARGET, result, addr, + data_size); } else { - serialice_log(LOG_READ | LOG_MEMORY, result, addr, data_size); + serialice_log(LOG_READ | LOG_MEMORY, result, addr, data_size); } }
@@ -956,19 +961,19 @@ * @return 0: pass on to Qemu; 1: handled locally. */ int serialice_handle_load(uint32_t addr, uint32_t * result, - unsigned int data_size) + unsigned int data_size) { int source;
source = serialice_memory_read_filter(addr, result, data_size);
if (source & READ_FROM_SERIALICE) { - *result = serialice_load_wrapper(addr, data_size); - return 1; + *result = serialice_load_wrapper(addr, data_size); + return 1; }
if (source & READ_FROM_QEMU) { - return 0; + return 0; }
/* No source for load, so the source is the script */ @@ -979,31 +984,31 @@ // memory store handling
static void serialice_store_wrapper(uint32_t addr, unsigned int size, - uint32_t data) + uint32_t data) { switch (size) { case 1: - serialice_writeb((uint8_t) data, addr); - break; + serialice_writeb((uint8_t) data, addr); + break; case 2: - serialice_writew((uint16_t) data, addr); - break; + serialice_writew((uint16_t) data, addr); + break; case 4: - serialice_writel((uint32_t) data, addr); - break; + serialice_writel((uint32_t) data, addr); + break; default: - printf("WARNING: unknown write access size %d @%08x\n", size, addr); + printf("WARNING: unknown write access size %d @%08x\n", size, addr); } }
static void serialice_log_store(int caught, uint32_t addr, uint32_t val, - unsigned int data_size) + unsigned int data_size) { if (caught) { - serialice_log(LOG_WRITE | LOG_MEMORY | LOG_TARGET, val, addr, - data_size); + serialice_log(LOG_WRITE | LOG_MEMORY | LOG_TARGET, val, addr, + data_size); } else { - serialice_log(LOG_WRITE | LOG_MEMORY, val, addr, data_size); + serialice_log(LOG_WRITE | LOG_MEMORY, val, addr, data_size); } }
@@ -1026,7 +1031,7 @@ serialice_log_store(write_to_target, addr, filtered_data, data_size);
if (write_to_target) { - serialice_store_wrapper(addr, data_size, filtered_data); + serialice_store_wrapper(addr, data_size, filtered_data); }
return (write_to_qemu == 0); @@ -1040,7 +1045,7 @@ int bpp, linesize;
if (!screen_invalid) { - return; + return; }
dest = ds_get_data(s->ds); @@ -1051,17 +1056,17 @@ #if SERIALICE_BANNER int x, y; if (bpp == 4) { - for (y = 0; y < 240; y++) { - for (x = 0; x < 320; x++) { - int doff = (y * linesize) + (x * bpp); - int soff = (y * (320 * 3)) + (x * 3); - dest[doff + 0] = serialice_banner[soff + 2]; // blue - dest[doff + 1] = serialice_banner[soff + 1]; // green - dest[doff + 2] = serialice_banner[soff + 0]; // red - } - } + for (y = 0; y < 240; y++) { + for (x = 0; x < 320; x++) { + int doff = (y * linesize) + (x * bpp); + int soff = (y * (320 * 3)) + (x * 3); + dest[doff + 0] = serialice_banner[soff + 2]; // blue + dest[doff + 1] = serialice_banner[soff + 1]; // green + dest[doff + 2] = serialice_banner[soff + 0]; // red + } + } } else { - printf("Banner enabled and BPP = %d (line size = %d)\n", bpp, linesize); + printf("Banner enabled and BPP = %d (line size = %d)\n", bpp, linesize); } #endif
@@ -1082,28 +1087,28 @@ s = qemu_mallocz(sizeof(SerialICEState));
s->ds = graphic_console_init(serialice_refresh, serialice_invalidate, - NULL, NULL, s); + NULL, NULL, s); qemu_console_resize(s->ds, 320, 240);
printf("SerialICE: Open connection to target hardware...\n");
if (serialice_device == NULL) { - printf("You need to specify a serial device to use SerialICE.\n"); - exit(1); + printf("You need to specify a serial device to use SerialICE.\n"); + exit(1); } #ifdef WIN32 s->fd = CreateFile(serialice_device, GENERIC_READ | GENERIC_WRITE, - 0, NULL, OPEN_EXISTING, 0, NULL); + 0, NULL, OPEN_EXISTING, 0, NULL);
if (s->fd == INVALID_HANDLE_VALUE) { - perror("SerialICE: Could not connect to target TTY"); - exit(1); + perror("SerialICE: Could not connect to target TTY"); + exit(1); }
DCB dcb; if (!GetCommState(s->fd, &dcb)) { - perror("SerialICE: Could not load config for target TTY"); - exit(1); + perror("SerialICE: Could not load config for target TTY"); + exit(1); }
dcb.BaudRate = CBR_115200; @@ -1112,30 +1117,30 @@ dcb.StopBits = ONESTOPBIT;
if (!SetCommState(s->fd, &dcb)) { - perror("SerialICE: Could not store config for target TTY"); - exit(1); + perror("SerialICE: Could not store config for target TTY"); + exit(1); } #else s->fd = open(serialice_device, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (s->fd == -1) { - perror("SerialICE: Could not connect to target TTY"); - exit(1); + perror("SerialICE: Could not connect to target TTY"); + exit(1); }
if (ioctl(s->fd, TIOCEXCL) == -1) { - perror("SerialICE: TTY not exclusively available"); - exit(1); + perror("SerialICE: TTY not exclusively available"); + exit(1); }
if (fcntl(s->fd, F_SETFL, 0) == -1) { - perror("SerialICE: Could not switch to blocking I/O"); - exit(1); + perror("SerialICE: Could not switch to blocking I/O"); + exit(1); }
if (tcgetattr(s->fd, &options) == -1) { - perror("SerialICE: Could not get TTY attributes"); - exit(1); + perror("SerialICE: Could not get TTY attributes"); + exit(1); }
cfsetispeed(&options, B115200); @@ -1159,17 +1164,17 @@
printf("SerialICE: Waiting for handshake with target... ");
- handshake_mode = 1; // Readback errors are to be expected in this phase. + handshake_mode = 1; // Readback errors are to be expected in this phase.
/* Trigger a prompt */ serialice_write(s, "@", 1);
/* ... and wait for it to appear */ if (serialice_wait_prompt() == 0) { - printf("target alife!\n"); + printf("target alife!\n"); } else { - printf("target not ok!\n"); - exit(1); + printf("target not ok!\n"); + exit(1); }
/* Each serialice_command() waits for a prompt, so trigger one for the @@ -1177,7 +1182,7 @@ */ serialice_write(s, "@", 1);
- handshake_mode = 0; // from now on, warn about readback errors. + handshake_mode = 0; // from now on, warn about readback errors.
serialice_get_version();
@@ -1199,11 +1204,11 @@ }
static void pc_init_serialice(ram_addr_t ram_size, - const char *boot_device, - const char *kernel_filename, - const char *kernel_cmdline, - const char *initrd_filename, - const char *cpu_model) + const char *boot_device, + const char *kernel_filename, + const char *kernel_cmdline, + const char *initrd_filename, + const char *cpu_model) { char *filename; int ret, i, linux_boot; @@ -1212,26 +1217,26 @@ CPUState *env;
if (ram_size != (DEFAULT_RAM_SIZE * 1024 * 1024)) { - printf - ("Warning: Running SerialICE with non-default ram size is not supported.\n"); - exit(1); + printf + ("Warning: Running SerialICE with non-default ram size is not supported.\n"); + exit(1); }
linux_boot = (kernel_filename != NULL);
/* init CPUs */ if (cpu_model == NULL) { - //printf("Warning: Running SerialICE with generic CPU type might fail.\n"); + //printf("Warning: Running SerialICE with generic CPU type might fail.\n"); #ifdef TARGET_X86_64 - cpu_model = "qemu64"; + cpu_model = "qemu64"; #else - cpu_model = "qemu32"; + cpu_model = "qemu32"; #endif }
for (i = 0; i < smp_cpus; i++) { - env = cpu_init(cpu_model); - qemu_register_reset((QEMUResetHandler*)cpu_reset, env); + env = cpu_init(cpu_model); + qemu_register_reset((QEMUResetHandler *) cpu_reset, env); }
/* Must not happen before CPUs are initialized */ @@ -1239,42 +1244,41 @@
/* BIOS load */ if (bios_name == NULL) - bios_name = BIOS_FILENAME; + bios_name = BIOS_FILENAME; filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); if (filename) { - bios_size = get_image_size(filename); + bios_size = get_image_size(filename); } else { - bios_size = -1; + bios_size = -1; } if (bios_size <= 0 || (bios_size % 65536) != 0) { - goto bios_error; + goto bios_error; } bios_offset = qemu_ram_alloc(bios_size); ret = load_image(filename, qemu_get_ram_ptr(bios_offset)); if (ret != bios_size) { bios_error: - fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name); - exit(1); + fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name); + exit(1); } if (filename) { - qemu_free(filename); + qemu_free(filename); } /* map the last 128KB of the BIOS in ISA space */ isa_bios_size = bios_size; if (isa_bios_size > (128 * 1024)) - isa_bios_size = 128 * 1024; + isa_bios_size = 128 * 1024;
cpu_register_physical_memory(0x100000 - isa_bios_size, - isa_bios_size, - (bios_offset + bios_size - - isa_bios_size)); + isa_bios_size, + (bios_offset + bios_size - isa_bios_size));
/* map all the bios at the top of memory */ cpu_register_physical_memory((uint32_t) (-bios_size), bios_size, - bios_offset | IO_MEM_ROM); + bios_offset | IO_MEM_ROM); if (linux_boot) { - printf("Booting Linux in SerialICE mode is currently not supported.\n"); - exit(1); + printf("Booting Linux in SerialICE mode is currently not supported.\n"); + exit(1); }
}
Modified: trunk/qemu-0.11.0/serialice.h =================================================================== --- trunk/qemu-0.11.0/serialice.h 2009-12-05 15:02:29 UTC (rev 87) +++ trunk/qemu-0.11.0/serialice.h 2009-12-05 15:47:43 UTC (rev 88) @@ -65,9 +65,9 @@ cpuid_regs_t serialice_cpuid(uint32_t eax, uint32_t ecx);
int serialice_handle_load(uint32_t addr, uint32_t * result, - unsigned int data_size); + unsigned int data_size); void serialice_log_load(int caught, uint32_t addr, uint32_t result, - unsigned int data_size); + unsigned int data_size); int serialice_handle_store(uint32_t addr, uint32_t val, unsigned int data_size);
#endif