qemu-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Qemu-devel] [PULL 03/33] hw: use ld_p/st_p instead of ld_raw/st_raw


From: Paolo Bonzini
Subject: [Qemu-devel] [PULL 03/33] hw: use ld_p/st_p instead of ld_raw/st_raw
Date: Thu, 5 Jun 2014 16:21:53 +0200

The ld_raw and st_raw definitions are only needed in code that
must compile for both user-mode and softmmu emulation.  Device
models can use the equivalent ld_p/st_p which are simple
pointer accessors.

Reviewed-by: Peter Maydell <address@hidden>
Signed-off-by: Paolo Bonzini <address@hidden>
---
 hw/9pfs/virtio-9p-device.c     |   2 +-
 hw/arm/nseries.c               | 236 ++++++++++++++++++++---------------------
 hw/block/virtio-blk.c          |  12 +--
 hw/display/omap_lcd_template.h |  10 +-
 hw/display/sm501_template.h    |   6 +-
 hw/display/vga_template.h      |   4 +-
 hw/mips/mips_fulong2e.c        |  28 ++---
 hw/mips/mips_malta.c           | 176 +++++++++++++++---------------
 hw/scsi/vhost-scsi.c           |   4 +-
 hw/scsi/virtio-scsi.c          |  28 ++---
 10 files changed, 253 insertions(+), 253 deletions(-)

diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c
index 15a4983..653762a 100644
--- a/hw/9pfs/virtio-9p-device.c
+++ b/hw/9pfs/virtio-9p-device.c
@@ -34,7 +34,7 @@ static void virtio_9p_get_config(VirtIODevice *vdev, uint8_t 
*config)
 
     len = strlen(s->tag);
     cfg = g_malloc0(sizeof(struct virtio_9p_config) + len);
-    stw_raw(&cfg->tag_len, len);
+    stw_p(&cfg->tag_len, len);
     /* We don't copy the terminating null to config space */
     memcpy(cfg->tag, s->tag, len);
     memcpy(config, cfg, s->config_size);
diff --git a/hw/arm/nseries.c b/hw/arm/nseries.c
index 6174371..4f092d6 100644
--- a/hw/arm/nseries.c
+++ b/hw/arm/nseries.c
@@ -850,119 +850,119 @@ static void n800_setup_nolo_tags(void *sram_base)
 
     strcpy((void *) (p + 8), "F5");
 
-    stl_raw(p + 10, 0x04f70000);
+    stl_p(p + 10, 0x04f70000);
     strcpy((void *) (p + 9), "RX-34");
 
     /* RAM size in MB? */
-    stl_raw(p + 12, 0x80);
+    stl_p(p + 12, 0x80);
 
     /* Pointer to the list of tags */
-    stl_raw(p + 13, OMAP2_SRAM_BASE + 0x9000);
+    stl_p(p + 13, OMAP2_SRAM_BASE + 0x9000);
 
     /* The NOLO tags start here */
     p = sram_base + 0x9000;
 #define ADD_TAG(tag, len)                              \
-    stw_raw((uint16_t *) p + 0, tag);                  \
-    stw_raw((uint16_t *) p + 1, len); p++;             \
-    stl_raw(p++, OMAP2_SRAM_BASE | (((void *) v - sram_base) & 0xffff));
+    stw_p((uint16_t *) p + 0, tag);                    \
+    stw_p((uint16_t *) p + 1, len); p++;               \
+    stl_p(p++, OMAP2_SRAM_BASE | (((void *) v - sram_base) & 0xffff));
 
     /* OMAP STI console? Pin out settings? */
     ADD_TAG(0x6e01, 414);
     for (i = 0; i < ARRAY_SIZE(n800_pinout); i++) {
-        stl_raw(v++, n800_pinout[i]);
+        stl_p(v++, n800_pinout[i]);
     }
 
     /* Kernel memsize? */
     ADD_TAG(0x6e05, 1);
-    stl_raw(v++, 2);
+    stl_p(v++, 2);
 
     /* NOLO serial console */
     ADD_TAG(0x6e02, 4);
-    stl_raw(v++, XLDR_LL_UART);                /* UART number (1 - 3) */
+    stl_p(v++, XLDR_LL_UART);          /* UART number (1 - 3) */
 
 #if 0
     /* CBUS settings (Retu/AVilma) */
     ADD_TAG(0x6e03, 6);
-    stw_raw((uint16_t *) v + 0, 65);   /* CBUS GPIO0 */
-    stw_raw((uint16_t *) v + 1, 66);   /* CBUS GPIO1 */
-    stw_raw((uint16_t *) v + 2, 64);   /* CBUS GPIO2 */
+    stw_p((uint16_t *) v + 0, 65);     /* CBUS GPIO0 */
+    stw_p((uint16_t *) v + 1, 66);     /* CBUS GPIO1 */
+    stw_p((uint16_t *) v + 2, 64);     /* CBUS GPIO2 */
     v += 2;
 #endif
 
     /* Nokia ASIC BB5 (Retu/Tahvo) */
     ADD_TAG(0x6e0a, 4);
-    stw_raw((uint16_t *) v + 0, 111);  /* "Retu" interrupt GPIO */
-    stw_raw((uint16_t *) v + 1, 108);  /* "Tahvo" interrupt GPIO */
+    stw_p((uint16_t *) v + 0, 111);    /* "Retu" interrupt GPIO */
+    stw_p((uint16_t *) v + 1, 108);    /* "Tahvo" interrupt GPIO */
     v++;
 
     /* LCD console? */
     ADD_TAG(0x6e04, 4);
-    stw_raw((uint16_t *) v + 0, 30);   /* ??? */
-    stw_raw((uint16_t *) v + 1, 24);   /* ??? */
+    stw_p((uint16_t *) v + 0, 30);     /* ??? */
+    stw_p((uint16_t *) v + 1, 24);     /* ??? */
     v++;
 
 #if 0
     /* LCD settings */
     ADD_TAG(0x6e06, 2);
-    stw_raw((uint16_t *) (v++), 15);   /* ??? */
+    stw_p((uint16_t *) (v++), 15);     /* ??? */
 #endif
 
     /* I^2C (Menelaus) */
     ADD_TAG(0x6e07, 4);
-    stl_raw(v++, 0x00720000);          /* ??? */
+    stl_p(v++, 0x00720000);            /* ??? */
 
     /* Unknown */
     ADD_TAG(0x6e0b, 6);
-    stw_raw((uint16_t *) v + 0, 94);   /* ??? */
-    stw_raw((uint16_t *) v + 1, 23);   /* ??? */
-    stw_raw((uint16_t *) v + 2, 0);    /* ??? */
+    stw_p((uint16_t *) v + 0, 94);     /* ??? */
+    stw_p((uint16_t *) v + 1, 23);     /* ??? */
+    stw_p((uint16_t *) v + 2, 0);      /* ??? */
     v += 2;
 
     /* OMAP gpio switch info */
     ADD_TAG(0x6e0c, 80);
     strcpy((void *) v, "bat_cover");   v += 3;
-    stw_raw((uint16_t *) v + 0, 110);  /* GPIO num ??? */
-    stw_raw((uint16_t *) v + 1, 1);    /* GPIO num ??? */
+    stw_p((uint16_t *) v + 0, 110);    /* GPIO num ??? */
+    stw_p((uint16_t *) v + 1, 1);      /* GPIO num ??? */
     v += 2;
     strcpy((void *) v, "cam_act");     v += 3;
-    stw_raw((uint16_t *) v + 0, 95);   /* GPIO num ??? */
-    stw_raw((uint16_t *) v + 1, 32);   /* GPIO num ??? */
+    stw_p((uint16_t *) v + 0, 95);     /* GPIO num ??? */
+    stw_p((uint16_t *) v + 1, 32);     /* GPIO num ??? */
     v += 2;
     strcpy((void *) v, "cam_turn");    v += 3;
-    stw_raw((uint16_t *) v + 0, 12);   /* GPIO num ??? */
-    stw_raw((uint16_t *) v + 1, 33);   /* GPIO num ??? */
+    stw_p((uint16_t *) v + 0, 12);     /* GPIO num ??? */
+    stw_p((uint16_t *) v + 1, 33);     /* GPIO num ??? */
     v += 2;
     strcpy((void *) v, "headphone");   v += 3;
-    stw_raw((uint16_t *) v + 0, 107);  /* GPIO num ??? */
-    stw_raw((uint16_t *) v + 1, 17);   /* GPIO num ??? */
+    stw_p((uint16_t *) v + 0, 107);    /* GPIO num ??? */
+    stw_p((uint16_t *) v + 1, 17);     /* GPIO num ??? */
     v += 2;
 
     /* Bluetooth */
     ADD_TAG(0x6e0e, 12);
-    stl_raw(v++, 0x5c623d01);          /* ??? */
-    stl_raw(v++, 0x00000201);          /* ??? */
-    stl_raw(v++, 0x00000000);          /* ??? */
+    stl_p(v++, 0x5c623d01);            /* ??? */
+    stl_p(v++, 0x00000201);            /* ??? */
+    stl_p(v++, 0x00000000);            /* ??? */
 
     /* CX3110x WLAN settings */
     ADD_TAG(0x6e0f, 8);
-    stl_raw(v++, 0x00610025);          /* ??? */
-    stl_raw(v++, 0xffff0057);          /* ??? */
+    stl_p(v++, 0x00610025);            /* ??? */
+    stl_p(v++, 0xffff0057);            /* ??? */
 
     /* MMC host settings */
     ADD_TAG(0x6e10, 12);
-    stl_raw(v++, 0xffff000f);          /* ??? */
-    stl_raw(v++, 0xffffffff);          /* ??? */
-    stl_raw(v++, 0x00000060);          /* ??? */
+    stl_p(v++, 0xffff000f);            /* ??? */
+    stl_p(v++, 0xffffffff);            /* ??? */
+    stl_p(v++, 0x00000060);            /* ??? */
 
     /* OneNAND chip select */
     ADD_TAG(0x6e11, 10);
-    stl_raw(v++, 0x00000401);          /* ??? */
-    stl_raw(v++, 0x0002003a);          /* ??? */
-    stl_raw(v++, 0x00000002);          /* ??? */
+    stl_p(v++, 0x00000401);            /* ??? */
+    stl_p(v++, 0x0002003a);            /* ??? */
+    stl_p(v++, 0x00000002);            /* ??? */
 
     /* TEA5761 sensor settings */
     ADD_TAG(0x6e12, 2);
-    stl_raw(v++, 93);                  /* GPIO num ??? */
+    stl_p(v++, 93);                    /* GPIO num ??? */
 
 #if 0
     /* Unknown tag */
@@ -973,8 +973,8 @@ static void n800_setup_nolo_tags(void *sram_base)
 #endif
 
     /* End of the list */
-    stl_raw(p++, 0x00000000);
-    stl_raw(p++, 0x00000000);
+    stl_p(p++, 0x00000000);
+    stl_p(p++, 0x00000000);
 }
 
 /* This task is normally performed by the bootloader.  If we're loading
@@ -1137,112 +1137,112 @@ static int n8x0_atag_setup(void *p, int model)
 
     w = p;
 
-    stw_raw(w++, OMAP_TAG_UART);               /* u16 tag */
-    stw_raw(w++, 4);                           /* u16 len */
-    stw_raw(w++, (1 << 2) | (1 << 1) | (1 << 0)); /* uint enabled_uarts */
+    stw_p(w++, OMAP_TAG_UART);                 /* u16 tag */
+    stw_p(w++, 4);                             /* u16 len */
+    stw_p(w++, (1 << 2) | (1 << 1) | (1 << 0)); /* uint enabled_uarts */
     w++;
 
 #if 0
-    stw_raw(w++, OMAP_TAG_SERIAL_CONSOLE);     /* u16 tag */
-    stw_raw(w++, 4);                           /* u16 len */
-    stw_raw(w++, XLDR_LL_UART + 1);            /* u8 console_uart */
-    stw_raw(w++, 115200);                      /* u32 console_speed */
+    stw_p(w++, OMAP_TAG_SERIAL_CONSOLE);       /* u16 tag */
+    stw_p(w++, 4);                             /* u16 len */
+    stw_p(w++, XLDR_LL_UART + 1);              /* u8 console_uart */
+    stw_p(w++, 115200);                                /* u32 console_speed */
 #endif
 
-    stw_raw(w++, OMAP_TAG_LCD);                        /* u16 tag */
-    stw_raw(w++, 36);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_LCD);                  /* u16 tag */
+    stw_p(w++, 36);                            /* u16 len */
     strcpy((void *) w, "QEMU LCD panel");      /* char panel_name[16] */
     w += 8;
     strcpy((void *) w, "blizzard");            /* char ctrl_name[16] */
     w += 8;
-    stw_raw(w++, N810_BLIZZARD_RESET_GPIO);    /* TODO: n800 s16 nreset_gpio */
-    stw_raw(w++, 24);                          /* u8 data_lines */
-
-    stw_raw(w++, OMAP_TAG_CBUS);               /* u16 tag */
-    stw_raw(w++, 8);                           /* u16 len */
-    stw_raw(w++, N8X0_CBUS_CLK_GPIO);          /* s16 clk_gpio */
-    stw_raw(w++, N8X0_CBUS_DAT_GPIO);          /* s16 dat_gpio */
-    stw_raw(w++, N8X0_CBUS_SEL_GPIO);          /* s16 sel_gpio */
+    stw_p(w++, N810_BLIZZARD_RESET_GPIO);      /* TODO: n800 s16 nreset_gpio */
+    stw_p(w++, 24);                            /* u8 data_lines */
+
+    stw_p(w++, OMAP_TAG_CBUS);                 /* u16 tag */
+    stw_p(w++, 8);                             /* u16 len */
+    stw_p(w++, N8X0_CBUS_CLK_GPIO);            /* s16 clk_gpio */
+    stw_p(w++, N8X0_CBUS_DAT_GPIO);            /* s16 dat_gpio */
+    stw_p(w++, N8X0_CBUS_SEL_GPIO);            /* s16 sel_gpio */
     w++;
 
-    stw_raw(w++, OMAP_TAG_EM_ASIC_BB5);                /* u16 tag */
-    stw_raw(w++, 4);                           /* u16 len */
-    stw_raw(w++, N8X0_RETU_GPIO);              /* s16 retu_irq_gpio */
-    stw_raw(w++, N8X0_TAHVO_GPIO);             /* s16 tahvo_irq_gpio */
+    stw_p(w++, OMAP_TAG_EM_ASIC_BB5);          /* u16 tag */
+    stw_p(w++, 4);                             /* u16 len */
+    stw_p(w++, N8X0_RETU_GPIO);                        /* s16 retu_irq_gpio */
+    stw_p(w++, N8X0_TAHVO_GPIO);               /* s16 tahvo_irq_gpio */
 
     gpiosw = (model == 810) ? n810_gpiosw_info : n800_gpiosw_info;
     for (; gpiosw->name; gpiosw++) {
-        stw_raw(w++, OMAP_TAG_GPIO_SWITCH);    /* u16 tag */
-        stw_raw(w++, 20);                      /* u16 len */
+        stw_p(w++, OMAP_TAG_GPIO_SWITCH);      /* u16 tag */
+        stw_p(w++, 20);                                /* u16 len */
         strcpy((void *) w, gpiosw->name);      /* char name[12] */
         w += 6;
-        stw_raw(w++, gpiosw->line);            /* u16 gpio */
-        stw_raw(w++, gpiosw->type);
-        stw_raw(w++, 0);
-        stw_raw(w++, 0);
+        stw_p(w++, gpiosw->line);              /* u16 gpio */
+        stw_p(w++, gpiosw->type);
+        stw_p(w++, 0);
+        stw_p(w++, 0);
     }
 
-    stw_raw(w++, OMAP_TAG_NOKIA_BT);           /* u16 tag */
-    stw_raw(w++, 12);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_NOKIA_BT);             /* u16 tag */
+    stw_p(w++, 12);                            /* u16 len */
     b = (void *) w;
-    stb_raw(b++, 0x01);                                /* u8 chip_type (CSR) */
-    stb_raw(b++, N8X0_BT_WKUP_GPIO);           /* u8 bt_wakeup_gpio */
-    stb_raw(b++, N8X0_BT_HOST_WKUP_GPIO);      /* u8 host_wakeup_gpio */
-    stb_raw(b++, N8X0_BT_RESET_GPIO);          /* u8 reset_gpio */
-    stb_raw(b++, BT_UART + 1);                 /* u8 bt_uart */
+    stb_p(b++, 0x01);                          /* u8 chip_type (CSR) */
+    stb_p(b++, N8X0_BT_WKUP_GPIO);             /* u8 bt_wakeup_gpio */
+    stb_p(b++, N8X0_BT_HOST_WKUP_GPIO);                /* u8 host_wakeup_gpio 
*/
+    stb_p(b++, N8X0_BT_RESET_GPIO);            /* u8 reset_gpio */
+    stb_p(b++, BT_UART + 1);                   /* u8 bt_uart */
     memcpy(b, &n8x0_bd_addr, 6);               /* u8 bd_addr[6] */
     b += 6;
-    stb_raw(b++, 0x02);                                /* u8 bt_sysclk (38.4) 
*/
+    stb_p(b++, 0x02);                          /* u8 bt_sysclk (38.4) */
     w = (void *) b;
 
-    stw_raw(w++, OMAP_TAG_WLAN_CX3110X);       /* u16 tag */
-    stw_raw(w++, 8);                           /* u16 len */
-    stw_raw(w++, 0x25);                                /* u8 chip_type */
-    stw_raw(w++, N8X0_WLAN_PWR_GPIO);          /* s16 power_gpio */
-    stw_raw(w++, N8X0_WLAN_IRQ_GPIO);          /* s16 irq_gpio */
-    stw_raw(w++, -1);                          /* s16 spi_cs_gpio */
+    stw_p(w++, OMAP_TAG_WLAN_CX3110X);         /* u16 tag */
+    stw_p(w++, 8);                             /* u16 len */
+    stw_p(w++, 0x25);                          /* u8 chip_type */
+    stw_p(w++, N8X0_WLAN_PWR_GPIO);            /* s16 power_gpio */
+    stw_p(w++, N8X0_WLAN_IRQ_GPIO);            /* s16 irq_gpio */
+    stw_p(w++, -1);                            /* s16 spi_cs_gpio */
 
-    stw_raw(w++, OMAP_TAG_MMC);                        /* u16 tag */
-    stw_raw(w++, 16);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_MMC);                  /* u16 tag */
+    stw_p(w++, 16);                            /* u16 len */
     if (model == 810) {
-        stw_raw(w++, 0x23f);                   /* unsigned flags */
-        stw_raw(w++, -1);                      /* s16 power_pin */
-        stw_raw(w++, -1);                      /* s16 switch_pin */
-        stw_raw(w++, -1);                      /* s16 wp_pin */
-        stw_raw(w++, 0x240);                   /* unsigned flags */
-        stw_raw(w++, 0xc000);                  /* s16 power_pin */
-        stw_raw(w++, 0x0248);                  /* s16 switch_pin */
-        stw_raw(w++, 0xc000);                  /* s16 wp_pin */
+        stw_p(w++, 0x23f);                     /* unsigned flags */
+        stw_p(w++, -1);                                /* s16 power_pin */
+        stw_p(w++, -1);                                /* s16 switch_pin */
+        stw_p(w++, -1);                                /* s16 wp_pin */
+        stw_p(w++, 0x240);                     /* unsigned flags */
+        stw_p(w++, 0xc000);                    /* s16 power_pin */
+        stw_p(w++, 0x0248);                    /* s16 switch_pin */
+        stw_p(w++, 0xc000);                    /* s16 wp_pin */
     } else {
-        stw_raw(w++, 0xf);                     /* unsigned flags */
-        stw_raw(w++, -1);                      /* s16 power_pin */
-        stw_raw(w++, -1);                      /* s16 switch_pin */
-        stw_raw(w++, -1);                      /* s16 wp_pin */
-        stw_raw(w++, 0);                       /* unsigned flags */
-        stw_raw(w++, 0);                       /* s16 power_pin */
-        stw_raw(w++, 0);                       /* s16 switch_pin */
-        stw_raw(w++, 0);                       /* s16 wp_pin */
+        stw_p(w++, 0xf);                       /* unsigned flags */
+        stw_p(w++, -1);                                /* s16 power_pin */
+        stw_p(w++, -1);                                /* s16 switch_pin */
+        stw_p(w++, -1);                                /* s16 wp_pin */
+        stw_p(w++, 0);                         /* unsigned flags */
+        stw_p(w++, 0);                         /* s16 power_pin */
+        stw_p(w++, 0);                         /* s16 switch_pin */
+        stw_p(w++, 0);                         /* s16 wp_pin */
     }
 
-    stw_raw(w++, OMAP_TAG_TEA5761);            /* u16 tag */
-    stw_raw(w++, 4);                           /* u16 len */
-    stw_raw(w++, N8X0_TEA5761_CS_GPIO);                /* u16 enable_gpio */
+    stw_p(w++, OMAP_TAG_TEA5761);              /* u16 tag */
+    stw_p(w++, 4);                             /* u16 len */
+    stw_p(w++, N8X0_TEA5761_CS_GPIO);          /* u16 enable_gpio */
     w++;
 
     partition = (model == 810) ? n810_part_info : n800_part_info;
     for (; partition->name; partition++) {
-        stw_raw(w++, OMAP_TAG_PARTITION);      /* u16 tag */
-        stw_raw(w++, 28);                      /* u16 len */
+        stw_p(w++, OMAP_TAG_PARTITION);                /* u16 tag */
+        stw_p(w++, 28);                                /* u16 len */
         strcpy((void *) w, partition->name);   /* char name[16] */
         l = (void *) (w + 8);
-        stl_raw(l++, partition->size);         /* unsigned int size */
-        stl_raw(l++, partition->offset);       /* unsigned int offset */
-        stl_raw(l++, partition->mask);         /* unsigned int mask_flags */
+        stl_p(l++, partition->size);           /* unsigned int size */
+        stl_p(l++, partition->offset);         /* unsigned int offset */
+        stl_p(l++, partition->mask);           /* unsigned int mask_flags */
         w = (void *) l;
     }
 
-    stw_raw(w++, OMAP_TAG_BOOT_REASON);                /* u16 tag */
-    stw_raw(w++, 12);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_BOOT_REASON);          /* u16 tag */
+    stw_p(w++, 12);                            /* u16 len */
 #if 0
     strcpy((void *) w, "por");                 /* char reason_str[12] */
     strcpy((void *) w, "charger");             /* char reason_str[12] */
@@ -1260,15 +1260,15 @@ static int n8x0_atag_setup(void *p, int model)
     w += 6;
 
     tag = (model == 810) ? "RX-44" : "RX-34";
-    stw_raw(w++, OMAP_TAG_VERSION_STR);                /* u16 tag */
-    stw_raw(w++, 24);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_VERSION_STR);          /* u16 tag */
+    stw_p(w++, 24);                            /* u16 len */
     strcpy((void *) w, "product");             /* char component[12] */
     w += 6;
     strcpy((void *) w, tag);                   /* char version[12] */
     w += 6;
 
-    stw_raw(w++, OMAP_TAG_VERSION_STR);                /* u16 tag */
-    stw_raw(w++, 24);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_VERSION_STR);          /* u16 tag */
+    stw_p(w++, 24);                            /* u16 len */
     strcpy((void *) w, "hw-build");            /* char component[12] */
     w += 6;
     strcpy((void *) w, "QEMU ");
@@ -1276,8 +1276,8 @@ static int n8x0_atag_setup(void *p, int model)
     w += 6;
 
     tag = (model == 810) ? "1.1.10-qemu" : "1.1.6-qemu";
-    stw_raw(w++, OMAP_TAG_VERSION_STR);                /* u16 tag */
-    stw_raw(w++, 24);                          /* u16 len */
+    stw_p(w++, OMAP_TAG_VERSION_STR);          /* u16 tag */
+    stw_p(w++, 24);                            /* u16 len */
     strcpy((void *) w, "nolo");                        /* char component[12] */
     w += 6;
     strcpy((void *) w, tag);                   /* char version[12] */
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index 8a568e5..b1fc1de 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -487,12 +487,12 @@ static void virtio_blk_update_config(VirtIODevice *vdev, 
uint8_t *config)
 
     bdrv_get_geometry(s->bs, &capacity);
     memset(&blkcfg, 0, sizeof(blkcfg));
-    stq_raw(&blkcfg.capacity, capacity);
-    stl_raw(&blkcfg.seg_max, 128 - 2);
-    stw_raw(&blkcfg.cylinders, s->conf->cyls);
-    stl_raw(&blkcfg.blk_size, blk_size);
-    stw_raw(&blkcfg.min_io_size, s->conf->min_io_size / blk_size);
-    stw_raw(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size);
+    stq_p(&blkcfg.capacity, capacity);
+    stl_p(&blkcfg.seg_max, 128 - 2);
+    stw_p(&blkcfg.cylinders, s->conf->cyls);
+    stl_p(&blkcfg.blk_size, blk_size);
+    stw_p(&blkcfg.min_io_size, s->conf->min_io_size / blk_size);
+    stw_p(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size);
     blkcfg.heads = s->conf->heads;
     /*
      * We must ensure that the block device capacity is a multiple of
diff --git a/hw/display/omap_lcd_template.h b/hw/display/omap_lcd_template.h
index 2fb96f8..e5dd447 100644
--- a/hw/display/omap_lcd_template.h
+++ b/hw/display/omap_lcd_template.h
@@ -50,7 +50,7 @@ static void glue(draw_line2_, DEPTH)(void *opaque,
     uint8_t v, r, g, b;
 
     do {
-        v = ldub_raw((void *) s);
+        v = ldub_p((void *) s);
         r = (pal[v & 3] >> 4) & 0xf0;
         g = pal[v & 3] & 0xf0;
         b = (pal[v & 3] << 4) & 0xf0;
@@ -89,7 +89,7 @@ static void glue(draw_line4_, DEPTH)(void *opaque,
     uint8_t v, r, g, b;
 
     do {
-        v = ldub_raw((void *) s);
+        v = ldub_p((void *) s);
         r = (pal[v & 0xf] >> 4) & 0xf0;
         g = pal[v & 0xf] & 0xf0;
         b = (pal[v & 0xf] << 4) & 0xf0;
@@ -116,7 +116,7 @@ static void glue(draw_line8_, DEPTH)(void *opaque,
     uint8_t v, r, g, b;
 
     do {
-        v = ldub_raw((void *) s);
+        v = ldub_p((void *) s);
         r = (pal[v] >> 4) & 0xf0;
         g = pal[v] & 0xf0;
         b = (pal[v] << 4) & 0xf0;
@@ -136,7 +136,7 @@ static void glue(draw_line12_, DEPTH)(void *opaque,
     uint8_t r, g, b;
 
     do {
-        v = lduw_raw((void *) s);
+        v = lduw_p((void *) s);
         r = (v >> 4) & 0xf0;
         g = v & 0xf0;
         b = (v << 4) & 0xf0;
@@ -159,7 +159,7 @@ static void glue(draw_line16_, DEPTH)(void *opaque,
     uint8_t r, g, b;
 
     do {
-        v = lduw_raw((void *) s);
+        v = lduw_p((void *) s);
         r = (v >> 8) & 0xf8;
         g = (v >> 3) & 0xfc;
         b = (v << 3) & 0xf8;
diff --git a/hw/display/sm501_template.h b/hw/display/sm501_template.h
index d4cea9e..f33e499 100644
--- a/hw/display/sm501_template.h
+++ b/hw/display/sm501_template.h
@@ -47,7 +47,7 @@ static void glue(draw_line8_, PIXEL_NAME)(
 {
     uint8_t v, r, g, b;
     do {
-       v = ldub_raw(s);
+       v = ldub_p(s);
        r = (pal[v] >> 16) & 0xff;
        g = (pal[v] >>  8) & 0xff;
        b = (pal[v] >>  0) & 0xff;
@@ -64,7 +64,7 @@ static void glue(draw_line16_, PIXEL_NAME)(
     uint8_t r, g, b;
 
     do {
-       rgb565 = lduw_raw(s);
+       rgb565 = lduw_p(s);
        r = ((rgb565 >> 11) & 0x1f) << 3;
        g = ((rgb565 >>  5) & 0x3f) << 2;
        b = ((rgb565 >>  0) & 0x1f) << 3;
@@ -80,7 +80,7 @@ static void glue(draw_line32_, PIXEL_NAME)(
     uint8_t r, g, b;
 
     do {
-       ldub_raw(s);
+       ldub_p(s);
 #if defined(TARGET_WORDS_BIGENDIAN)
         r = s[1];
         g = s[2];
diff --git a/hw/display/vga_template.h b/hw/display/vga_template.h
index 6cfae56..90ec9c2 100644
--- a/hw/display/vga_template.h
+++ b/hw/display/vga_template.h
@@ -361,7 +361,7 @@ static void glue(vga_draw_line15_, 
PIXEL_NAME)(VGACommonState *s1, uint8_t *d,
 
     w = width;
     do {
-        v = lduw_raw((void *)s);
+        v = lduw_p((void *)s);
         r = (v >> 7) & 0xf8;
         g = (v >> 2) & 0xf8;
         b = (v << 3) & 0xf8;
@@ -386,7 +386,7 @@ static void glue(vga_draw_line16_, 
PIXEL_NAME)(VGACommonState *s1, uint8_t *d,
 
     w = width;
     do {
-        v = lduw_raw((void *)s);
+        v = lduw_p((void *)s);
         r = (v >> 8) & 0xf8;
         g = (v >> 3) & 0xfc;
         b = (v << 3) & 0xf8;
diff --git a/hw/mips/mips_fulong2e.c b/hw/mips/mips_fulong2e.c
index 5ad7a41..f7533ed 100644
--- a/hw/mips/mips_fulong2e.c
+++ b/hw/mips/mips_fulong2e.c
@@ -178,24 +178,24 @@ static void write_bootloader (CPUMIPSState *env, uint8_t 
*base, int64_t kernel_a
     /* Small bootloader */
     p = (uint32_t *) base;
 
-    stl_raw(p++, 0x0bf00010);                                      /* j 
0x1fc00040 */
-    stl_raw(p++, 0x00000000);                                      /* nop */
+    stl_p(p++, 0x0bf00010);                                      /* j 
0x1fc00040 */
+    stl_p(p++, 0x00000000);                                      /* nop */
 
     /* Second part of the bootloader */
     p = (uint32_t *) (base + 0x040);
 
-    stl_raw(p++, 0x3c040000);                                      /* lui a0, 
0 */
-    stl_raw(p++, 0x34840002);                                      /* ori a0, 
a0, 2 */
-    stl_raw(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));       /* lui a1, 
high(ENVP_ADDR) */
-    stl_raw(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));               /* ori a1, 
a0, low(ENVP_ADDR) */
-    stl_raw(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, 
high(ENVP_ADDR + 8) */
-    stl_raw(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));         /* ori a2, 
a2, low(ENVP_ADDR + 8) */
-    stl_raw(p++, 0x3c070000 | (loaderparams.ram_size >> 16));      /* lui a3, 
high(env->ram_size) */
-    stl_raw(p++, 0x34e70000 | (loaderparams.ram_size & 0xffff));   /* ori a3, 
a3, low(env->ram_size) */
-    stl_raw(p++, 0x3c1f0000 | ((kernel_addr >> 16) & 0xffff));     /* lui ra, 
high(kernel_addr) */;
-    stl_raw(p++, 0x37ff0000 | (kernel_addr & 0xffff));             /* ori ra, 
ra, low(kernel_addr) */
-    stl_raw(p++, 0x03e00008);                                      /* jr ra */
-    stl_raw(p++, 0x00000000);                                      /* nop */
+    stl_p(p++, 0x3c040000);                                      /* lui a0, 0 
*/
+    stl_p(p++, 0x34840002);                                      /* ori a0, 
a0, 2 */
+    stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));       /* lui a1, 
high(ENVP_ADDR) */
+    stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));               /* ori a1, 
a0, low(ENVP_ADDR) */
+    stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, 
high(ENVP_ADDR + 8) */
+    stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));         /* ori a2, 
a2, low(ENVP_ADDR + 8) */
+    stl_p(p++, 0x3c070000 | (loaderparams.ram_size >> 16));      /* lui a3, 
high(env->ram_size) */
+    stl_p(p++, 0x34e70000 | (loaderparams.ram_size & 0xffff));   /* ori a3, 
a3, low(env->ram_size) */
+    stl_p(p++, 0x3c1f0000 | ((kernel_addr >> 16) & 0xffff));     /* lui ra, 
high(kernel_addr) */;
+    stl_p(p++, 0x37ff0000 | (kernel_addr & 0xffff));             /* ori ra, 
ra, low(kernel_addr) */
+    stl_p(p++, 0x03e00008);                                      /* jr ra */
+    stl_p(p++, 0x00000000);                                      /* nop */
 }
 
 
diff --git a/hw/mips/mips_malta.c b/hw/mips/mips_malta.c
index 9fe775e..f4a7d47 100644
--- a/hw/mips/mips_malta.c
+++ b/hw/mips/mips_malta.c
@@ -609,136 +609,136 @@ static void write_bootloader (CPUMIPSState *env, 
uint8_t *base,
 
     /* Small bootloader */
     p = (uint32_t *)base;
-    stl_raw(p++, 0x0bf00160);                                      /* j 
0x1fc00580 */
-    stl_raw(p++, 0x00000000);                                      /* nop */
+    stl_p(p++, 0x0bf00160);                                      /* j 
0x1fc00580 */
+    stl_p(p++, 0x00000000);                                      /* nop */
 
     /* YAMON service vector */
-    stl_raw(base + 0x500, 0xbfc00580);      /* start: */
-    stl_raw(base + 0x504, 0xbfc0083c);      /* print_count: */
-    stl_raw(base + 0x520, 0xbfc00580);      /* start: */
-    stl_raw(base + 0x52c, 0xbfc00800);      /* flush_cache: */
-    stl_raw(base + 0x534, 0xbfc00808);      /* print: */
-    stl_raw(base + 0x538, 0xbfc00800);      /* reg_cpu_isr: */
-    stl_raw(base + 0x53c, 0xbfc00800);      /* unred_cpu_isr: */
-    stl_raw(base + 0x540, 0xbfc00800);      /* reg_ic_isr: */
-    stl_raw(base + 0x544, 0xbfc00800);      /* unred_ic_isr: */
-    stl_raw(base + 0x548, 0xbfc00800);      /* reg_esr: */
-    stl_raw(base + 0x54c, 0xbfc00800);      /* unreg_esr: */
-    stl_raw(base + 0x550, 0xbfc00800);      /* getchar: */
-    stl_raw(base + 0x554, 0xbfc00800);      /* syscon_read: */
+    stl_p(base + 0x500, 0xbfc00580);      /* start: */
+    stl_p(base + 0x504, 0xbfc0083c);      /* print_count: */
+    stl_p(base + 0x520, 0xbfc00580);      /* start: */
+    stl_p(base + 0x52c, 0xbfc00800);      /* flush_cache: */
+    stl_p(base + 0x534, 0xbfc00808);      /* print: */
+    stl_p(base + 0x538, 0xbfc00800);      /* reg_cpu_isr: */
+    stl_p(base + 0x53c, 0xbfc00800);      /* unred_cpu_isr: */
+    stl_p(base + 0x540, 0xbfc00800);      /* reg_ic_isr: */
+    stl_p(base + 0x544, 0xbfc00800);      /* unred_ic_isr: */
+    stl_p(base + 0x548, 0xbfc00800);      /* reg_esr: */
+    stl_p(base + 0x54c, 0xbfc00800);      /* unreg_esr: */
+    stl_p(base + 0x550, 0xbfc00800);      /* getchar: */
+    stl_p(base + 0x554, 0xbfc00800);      /* syscon_read: */
 
 
     /* Second part of the bootloader */
     p = (uint32_t *) (base + 0x580);
-    stl_raw(p++, 0x24040002);                                      /* addiu 
a0, zero, 2 */
-    stl_raw(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff)); /* lui sp, 
high(ENVP_ADDR) */
-    stl_raw(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff));        /* ori sp, 
sp, low(ENVP_ADDR) */
-    stl_raw(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));       /* lui a1, 
high(ENVP_ADDR) */
-    stl_raw(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));               /* ori a1, 
a1, low(ENVP_ADDR) */
-    stl_raw(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, 
high(ENVP_ADDR + 8) */
-    stl_raw(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));         /* ori a2, 
a2, low(ENVP_ADDR + 8) */
-    stl_raw(p++, 0x3c070000 | (loaderparams.ram_size >> 16));     /* lui a3, 
high(ram_size) */
-    stl_raw(p++, 0x34e70000 | (loaderparams.ram_size & 0xffff));  /* ori a3, 
a3, low(ram_size) */
+    stl_p(p++, 0x24040002);                                      /* addiu a0, 
zero, 2 */
+    stl_p(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff)); /* lui sp, 
high(ENVP_ADDR) */
+    stl_p(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff));        /* ori sp, 
sp, low(ENVP_ADDR) */
+    stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));       /* lui a1, 
high(ENVP_ADDR) */
+    stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));               /* ori a1, 
a1, low(ENVP_ADDR) */
+    stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, 
high(ENVP_ADDR + 8) */
+    stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));         /* ori a2, 
a2, low(ENVP_ADDR + 8) */
+    stl_p(p++, 0x3c070000 | (loaderparams.ram_size >> 16));     /* lui a3, 
high(ram_size) */
+    stl_p(p++, 0x34e70000 | (loaderparams.ram_size & 0xffff));  /* ori a3, a3, 
low(ram_size) */
 
     /* Load BAR registers as done by YAMON */
-    stl_raw(p++, 0x3c09b400);                                      /* lui t1, 
0xb400 */
+    stl_p(p++, 0x3c09b400);                                      /* lui t1, 
0xb400 */
 
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c08df00);                                      /* lui t0, 
0xdf00 */
+    stl_p(p++, 0x3c08df00);                                      /* lui t0, 
0xdf00 */
 #else
-    stl_raw(p++, 0x340800df);                                      /* ori t0, 
r0, 0x00df */
+    stl_p(p++, 0x340800df);                                      /* ori t0, 
r0, 0x00df */
 #endif
-    stl_raw(p++, 0xad280068);                                      /* sw t0, 
0x0068(t1) */
+    stl_p(p++, 0xad280068);                                      /* sw t0, 
0x0068(t1) */
 
-    stl_raw(p++, 0x3c09bbe0);                                      /* lui t1, 
0xbbe0 */
+    stl_p(p++, 0x3c09bbe0);                                      /* lui t1, 
0xbbe0 */
 
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c08c000);                                      /* lui t0, 
0xc000 */
+    stl_p(p++, 0x3c08c000);                                      /* lui t0, 
0xc000 */
 #else
-    stl_raw(p++, 0x340800c0);                                      /* ori t0, 
r0, 0x00c0 */
+    stl_p(p++, 0x340800c0);                                      /* ori t0, 
r0, 0x00c0 */
 #endif
-    stl_raw(p++, 0xad280048);                                      /* sw t0, 
0x0048(t1) */
+    stl_p(p++, 0xad280048);                                      /* sw t0, 
0x0048(t1) */
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c084000);                                      /* lui t0, 
0x4000 */
+    stl_p(p++, 0x3c084000);                                      /* lui t0, 
0x4000 */
 #else
-    stl_raw(p++, 0x34080040);                                      /* ori t0, 
r0, 0x0040 */
+    stl_p(p++, 0x34080040);                                      /* ori t0, 
r0, 0x0040 */
 #endif
-    stl_raw(p++, 0xad280050);                                      /* sw t0, 
0x0050(t1) */
+    stl_p(p++, 0xad280050);                                      /* sw t0, 
0x0050(t1) */
 
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c088000);                                      /* lui t0, 
0x8000 */
+    stl_p(p++, 0x3c088000);                                      /* lui t0, 
0x8000 */
 #else
-    stl_raw(p++, 0x34080080);                                      /* ori t0, 
r0, 0x0080 */
+    stl_p(p++, 0x34080080);                                      /* ori t0, 
r0, 0x0080 */
 #endif
-    stl_raw(p++, 0xad280058);                                      /* sw t0, 
0x0058(t1) */
+    stl_p(p++, 0xad280058);                                      /* sw t0, 
0x0058(t1) */
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c083f00);                                      /* lui t0, 
0x3f00 */
+    stl_p(p++, 0x3c083f00);                                      /* lui t0, 
0x3f00 */
 #else
-    stl_raw(p++, 0x3408003f);                                      /* ori t0, 
r0, 0x003f */
+    stl_p(p++, 0x3408003f);                                      /* ori t0, 
r0, 0x003f */
 #endif
-    stl_raw(p++, 0xad280060);                                      /* sw t0, 
0x0060(t1) */
+    stl_p(p++, 0xad280060);                                      /* sw t0, 
0x0060(t1) */
 
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c08c100);                                      /* lui t0, 
0xc100 */
+    stl_p(p++, 0x3c08c100);                                      /* lui t0, 
0xc100 */
 #else
-    stl_raw(p++, 0x340800c1);                                      /* ori t0, 
r0, 0x00c1 */
+    stl_p(p++, 0x340800c1);                                      /* ori t0, 
r0, 0x00c1 */
 #endif
-    stl_raw(p++, 0xad280080);                                      /* sw t0, 
0x0080(t1) */
+    stl_p(p++, 0xad280080);                                      /* sw t0, 
0x0080(t1) */
 #ifdef TARGET_WORDS_BIGENDIAN
-    stl_raw(p++, 0x3c085e00);                                      /* lui t0, 
0x5e00 */
+    stl_p(p++, 0x3c085e00);                                      /* lui t0, 
0x5e00 */
 #else
-    stl_raw(p++, 0x3408005e);                                      /* ori t0, 
r0, 0x005e */
+    stl_p(p++, 0x3408005e);                                      /* ori t0, 
r0, 0x005e */
 #endif
-    stl_raw(p++, 0xad280088);                                      /* sw t0, 
0x0088(t1) */
+    stl_p(p++, 0xad280088);                                      /* sw t0, 
0x0088(t1) */
 
     /* Jump to kernel code */
-    stl_raw(p++, 0x3c1f0000 | ((kernel_entry >> 16) & 0xffff));    /* lui ra, 
high(kernel_entry) */
-    stl_raw(p++, 0x37ff0000 | (kernel_entry & 0xffff));            /* ori ra, 
ra, low(kernel_entry) */
-    stl_raw(p++, 0x03e00008);                                      /* jr ra */
-    stl_raw(p++, 0x00000000);                                      /* nop */
+    stl_p(p++, 0x3c1f0000 | ((kernel_entry >> 16) & 0xffff));    /* lui ra, 
high(kernel_entry) */
+    stl_p(p++, 0x37ff0000 | (kernel_entry & 0xffff));            /* ori ra, 
ra, low(kernel_entry) */
+    stl_p(p++, 0x03e00008);                                      /* jr ra */
+    stl_p(p++, 0x00000000);                                      /* nop */
 
     /* YAMON subroutines */
     p = (uint32_t *) (base + 0x800);
-    stl_raw(p++, 0x03e00008);                                     /* jr ra */
-    stl_raw(p++, 0x24020000);                                     /* li v0,0 */
+    stl_p(p++, 0x03e00008);                                     /* jr ra */
+    stl_p(p++, 0x24020000);                                     /* li v0,0 */
    /* 808 YAMON print */
-    stl_raw(p++, 0x03e06821);                                     /* move 
t5,ra */
-    stl_raw(p++, 0x00805821);                                     /* move 
t3,a0 */
-    stl_raw(p++, 0x00a05021);                                     /* move 
t2,a1 */
-    stl_raw(p++, 0x91440000);                                     /* lbu 
a0,0(t2) */
-    stl_raw(p++, 0x254a0001);                                     /* addiu 
t2,t2,1 */
-    stl_raw(p++, 0x10800005);                                     /* beqz 
a0,834 */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x0ff0021c);                                     /* jal 870 */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x08000205);                                     /* j 814 */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x01a00008);                                     /* jr t5 */
-    stl_raw(p++, 0x01602021);                                     /* move 
a0,t3 */
+    stl_p(p++, 0x03e06821);                                     /* move t5,ra 
*/
+    stl_p(p++, 0x00805821);                                     /* move t3,a0 
*/
+    stl_p(p++, 0x00a05021);                                     /* move t2,a1 
*/
+    stl_p(p++, 0x91440000);                                     /* lbu 
a0,0(t2) */
+    stl_p(p++, 0x254a0001);                                     /* addiu 
t2,t2,1 */
+    stl_p(p++, 0x10800005);                                     /* beqz a0,834 
*/
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x0ff0021c);                                     /* jal 870 */
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x08000205);                                     /* j 814 */
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x01a00008);                                     /* jr t5 */
+    stl_p(p++, 0x01602021);                                     /* move a0,t3 
*/
     /* 0x83c YAMON print_count */
-    stl_raw(p++, 0x03e06821);                                     /* move 
t5,ra */
-    stl_raw(p++, 0x00805821);                                     /* move 
t3,a0 */
-    stl_raw(p++, 0x00a05021);                                     /* move 
t2,a1 */
-    stl_raw(p++, 0x00c06021);                                     /* move 
t4,a2 */
-    stl_raw(p++, 0x91440000);                                     /* lbu 
a0,0(t2) */
-    stl_raw(p++, 0x0ff0021c);                                     /* jal 870 */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x254a0001);                                     /* addiu 
t2,t2,1 */
-    stl_raw(p++, 0x258cffff);                                     /* addiu 
t4,t4,-1 */
-    stl_raw(p++, 0x1580fffa);                                     /* bnez 
t4,84c */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x01a00008);                                     /* jr t5 */
-    stl_raw(p++, 0x01602021);                                     /* move 
a0,t3 */
+    stl_p(p++, 0x03e06821);                                     /* move t5,ra 
*/
+    stl_p(p++, 0x00805821);                                     /* move t3,a0 
*/
+    stl_p(p++, 0x00a05021);                                     /* move t2,a1 
*/
+    stl_p(p++, 0x00c06021);                                     /* move t4,a2 
*/
+    stl_p(p++, 0x91440000);                                     /* lbu 
a0,0(t2) */
+    stl_p(p++, 0x0ff0021c);                                     /* jal 870 */
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x254a0001);                                     /* addiu 
t2,t2,1 */
+    stl_p(p++, 0x258cffff);                                     /* addiu 
t4,t4,-1 */
+    stl_p(p++, 0x1580fffa);                                     /* bnez t4,84c 
*/
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x01a00008);                                     /* jr t5 */
+    stl_p(p++, 0x01602021);                                     /* move a0,t3 
*/
     /* 0x870 */
-    stl_raw(p++, 0x3c08b800);                                     /* lui 
t0,0xb400 */
-    stl_raw(p++, 0x350803f8);                                     /* ori 
t0,t0,0x3f8 */
-    stl_raw(p++, 0x91090005);                                     /* lbu 
t1,5(t0) */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x31290040);                                     /* andi 
t1,t1,0x40 */
-    stl_raw(p++, 0x1120fffc);                                     /* beqz 
t1,878 <outch+0x8> */
-    stl_raw(p++, 0x00000000);                                     /* nop */
-    stl_raw(p++, 0x03e00008);                                     /* jr ra */
-    stl_raw(p++, 0xa1040000);                                     /* sb 
a0,0(t0) */
+    stl_p(p++, 0x3c08b800);                                     /* lui 
t0,0xb400 */
+    stl_p(p++, 0x350803f8);                                     /* ori 
t0,t0,0x3f8 */
+    stl_p(p++, 0x91090005);                                     /* lbu 
t1,5(t0) */
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x31290040);                                     /* andi 
t1,t1,0x40 */
+    stl_p(p++, 0x1120fffc);                                     /* beqz t1,878 
<outch+0x8> */
+    stl_p(p++, 0x00000000);                                     /* nop */
+    stl_p(p++, 0x03e00008);                                     /* jr ra */
+    stl_p(p++, 0xa1040000);                                     /* sb a0,0(t0) 
*/
 
 }
 
diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
index 3983a5b..668bafa 100644
--- a/hw/scsi/vhost-scsi.c
+++ b/hw/scsi/vhost-scsi.c
@@ -164,8 +164,8 @@ static void vhost_scsi_set_config(VirtIODevice *vdev,
     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 
-    if ((uint32_t) ldl_raw(&scsiconf->sense_size) != vs->sense_size ||
-        (uint32_t) ldl_raw(&scsiconf->cdb_size) != vs->cdb_size) {
+    if ((uint32_t) ldl_p(&scsiconf->sense_size) != vs->sense_size ||
+        (uint32_t) ldl_p(&scsiconf->cdb_size) != vs->cdb_size) {
         error_report("vhost-scsi does not support changing the sense data and 
CDB sizes");
         exit(1);
     }
diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
index 14261fb..b39880a 100644
--- a/hw/scsi/virtio-scsi.c
+++ b/hw/scsi/virtio-scsi.c
@@ -425,16 +425,16 @@ static void virtio_scsi_get_config(VirtIODevice *vdev,
     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
     VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(vdev);
 
-    stl_raw(&scsiconf->num_queues, s->conf.num_queues);
-    stl_raw(&scsiconf->seg_max, 128 - 2);
-    stl_raw(&scsiconf->max_sectors, s->conf.max_sectors);
-    stl_raw(&scsiconf->cmd_per_lun, s->conf.cmd_per_lun);
-    stl_raw(&scsiconf->event_info_size, sizeof(VirtIOSCSIEvent));
-    stl_raw(&scsiconf->sense_size, s->sense_size);
-    stl_raw(&scsiconf->cdb_size, s->cdb_size);
-    stw_raw(&scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL);
-    stw_raw(&scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET);
-    stl_raw(&scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN);
+    stl_p(&scsiconf->num_queues, s->conf.num_queues);
+    stl_p(&scsiconf->seg_max, 128 - 2);
+    stl_p(&scsiconf->max_sectors, s->conf.max_sectors);
+    stl_p(&scsiconf->cmd_per_lun, s->conf.cmd_per_lun);
+    stl_p(&scsiconf->event_info_size, sizeof(VirtIOSCSIEvent));
+    stl_p(&scsiconf->sense_size, s->sense_size);
+    stl_p(&scsiconf->cdb_size, s->cdb_size);
+    stw_p(&scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL);
+    stw_p(&scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET);
+    stl_p(&scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN);
 }
 
 static void virtio_scsi_set_config(VirtIODevice *vdev,
@@ -443,14 +443,14 @@ static void virtio_scsi_set_config(VirtIODevice *vdev,
     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 
-    if ((uint32_t) ldl_raw(&scsiconf->sense_size) >= 65536 ||
-        (uint32_t) ldl_raw(&scsiconf->cdb_size) >= 256) {
+    if ((uint32_t) ldl_p(&scsiconf->sense_size) >= 65536 ||
+        (uint32_t) ldl_p(&scsiconf->cdb_size) >= 256) {
         error_report("bad data written to virtio-scsi configuration space");
         exit(1);
     }
 
-    vs->sense_size = ldl_raw(&scsiconf->sense_size);
-    vs->cdb_size = ldl_raw(&scsiconf->cdb_size);
+    vs->sense_size = ldl_p(&scsiconf->sense_size);
+    vs->cdb_size = ldl_p(&scsiconf->cdb_size);
 }
 
 static uint32_t virtio_scsi_get_features(VirtIODevice *vdev,
-- 
1.8.3.1





reply via email to

[Prev in Thread] Current Thread [Next in Thread]