本文整理汇总了C++中cpu_physical_memory_write函数的典型用法代码示例。如果您正苦于以下问题：C++ cpu_physical_memory_write函数的具体用法？C++ cpu_physical_memory_write怎么用？C++ cpu_physical_memory_write使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了cpu_physical_memory_write函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: spapr_finalize_fdt
static void spapr_finalize_fdt(sPAPREnvironment *spapr,
target_phys_addr_t fdt_addr,
target_phys_addr_t rtas_addr,
target_phys_addr_t rtas_size)
{
int ret;
void *fdt;
fdt = qemu_malloc(FDT_MAX_SIZE);
/* open out the base tree into a temp buffer for the final tweaks */
_FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE)));
ret = spapr_populate_vdevice(spapr->vio_bus, fdt);
if (ret < 0) {
fprintf(stderr, "couldn't setup vio devices in fdt\n");
exit(1);
}
/* RTAS */
ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size);
if (ret < 0) {
fprintf(stderr, "Couldn't set up RTAS device tree properties\n");
}
_FDT((fdt_pack(fdt)));
cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt));
qemu_free(fdt);
}示例2: labx_load_device_tree
static int labx_load_device_tree(hwaddr addr,
uint32_t ramsize,
hwaddr initrd_base,
hwaddr initrd_size,
const char *kernel_cmdline)
{
int fdt_size;
void *fdt;
int r;
fdt = get_device_tree(&fdt_size);
if (!fdt) {
return 0;
}
if (kernel_cmdline && strlen(kernel_cmdline)) {
r = qemu_devtree_setprop_string(fdt, "/chosen", "bootargs",
kernel_cmdline);
if (r < 0) {
fprintf(stderr, "couldn't set /chosen/bootargs\n");
}
}
cpu_physical_memory_write(addr, (void *)fdt, fdt_size);
return fdt_size;
}示例3: snprintf
static void *bamboo_load_device_tree(target_phys_addr_t addr,
uint32_t ramsize,
target_phys_addr_t initrd_base,
target_phys_addr_t initrd_size,
const char *kernel_cmdline)
{
void *fdt = NULL;
#ifdef HAVE_FDT
uint32_t mem_reg_property[] = { 0, 0, ramsize };
char *path;
int fdt_size;
int pathlen;
int ret;
pathlen = snprintf(NULL, 0, "%s/%s", bios_dir, BINARY_DEVICE_TREE_FILE) + 1;
path = qemu_malloc(pathlen);
snprintf(path, pathlen, "%s/%s", bios_dir, BINARY_DEVICE_TREE_FILE);
fdt = load_device_tree(path, &fdt_size);
free(path);
if (fdt == NULL)
goto out;
/* Manipulate device tree in memory. */
ret = qemu_devtree_setprop(fdt, "/memory", "reg", mem_reg_property,
sizeof(mem_reg_property));
if (ret < 0)
fprintf(stderr, "couldn't set /memory/reg\n");
ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-start",
initrd_base);
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/linux,initrd-start\n");
ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-end",
(initrd_base + initrd_size));
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/linux,initrd-end\n");
ret = qemu_devtree_setprop_string(fdt, "/chosen", "bootargs",
kernel_cmdline);
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/bootargs\n");
if (kvm_enabled())
kvmppc_fdt_update(fdt);
cpu_physical_memory_write (addr, (void *)fdt, fdt_size);
out:
#endif
return fdt;
}示例4: channel_store_d
static void channel_store_d(struct fs_dma_ctrl *ctrl, int c)
{
hwaddr addr = channel_reg(ctrl, c, RW_SAVED_DATA);
/* Encode and store. FIXME: handle endianness. */
D(printf("%s ch=%d addr=" TARGET_FMT_plx "\n", __func__, c, addr));
cpu_physical_memory_write (addr,
(void *) &ctrl->channels[c].current_d,
sizeof ctrl->channels[c].current_d);
}示例5: channel_store_d
static void channel_store_d(struct fs_dma_ctrl *ctrl, int c)
{
target_phys_addr_t addr = channel_reg(ctrl, c, RW_SAVED_DATA);
/* Load and decode. FIXME: handle endianness. */
D(printf("%s addr=%x\n", __func__, addr));
cpu_physical_memory_write (addr,
(void *) &ctrl->channels[c].current_d,
sizeof ctrl->channels[c].current_d);
}示例6: qemu_find_file
static void *bamboo_load_device_tree(target_phys_addr_t addr,
uint32_t ramsize,
target_phys_addr_t initrd_base,
target_phys_addr_t initrd_size,
const char *kernel_cmdline)
{
void *fdt = NULL;
#ifdef HAVE_FDT
uint32_t mem_reg_property[] = { 0, 0, ramsize };
char *filename;
int fdt_size;
int ret;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (!filename) {
goto out;
}
fdt = load_device_tree(filename, &fdt_size);
qemu_free(filename);
if (fdt == NULL) {
goto out;
}
/* Manipulate device tree in memory. */
ret = qemu_devtree_setprop(fdt, "/memory", "reg", mem_reg_property,
sizeof(mem_reg_property));
if (ret < 0)
fprintf(stderr, "couldn't set /memory/reg\n");
ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-start",
initrd_base);
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/linux,initrd-start\n");
ret = qemu_devtree_setprop_cell(fdt, "/chosen", "linux,initrd-end",
(initrd_base + initrd_size));
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/linux,initrd-end\n");
ret = qemu_devtree_setprop_string(fdt, "/chosen", "bootargs",
kernel_cmdline);
if (ret < 0)
fprintf(stderr, "couldn't set /chosen/bootargs\n");
if (kvm_enabled())
kvmppc_fdt_update(fdt);
cpu_physical_memory_write (addr, (void *)fdt, fdt_size);
out:
#endif
return fdt;
}示例7: channel_store_c
static void channel_store_c(struct fs_dma_ctrl *ctrl, int c)
{
target_phys_addr_t addr = channel_reg(ctrl, c, RW_GROUP_DOWN);
/* Encode and store. FIXME: handle endianness. */
D(printf("%s ch=%d addr=" TARGET_FMT_plx "\n", __func__, c, addr));
D(dump_d(c, &ctrl->channels[c].current_d));
cpu_physical_memory_write (addr,
(void *) &ctrl->channels[c].current_c,
sizeof ctrl->channels[c].current_c);
}示例8: sysparm_st
static inline int sysparm_st(target_ulong addr, target_ulong len,
const void *val, uint16_t vallen)
{
hwaddr phys = ppc64_phys_to_real(addr);
if (len < 2) {
return RTAS_OUT_SYSPARM_PARAM_ERROR;
}
stw_be_phys(&address_space_memory, phys, vallen);
cpu_physical_memory_write(phys + 2, val, MIN(len - 2, vallen));
return RTAS_OUT_SUCCESS;
}示例9: xilinx_load_device_tree
static int xilinx_load_device_tree(hwaddr addr,
uint32_t ramsize,
hwaddr initrd_base,
hwaddr initrd_size,
const char *kernel_cmdline)
{
char *path;
int fdt_size;
void *fdt = NULL;
int r;
const char *dtb_filename;
dtb_filename = qemu_opt_get(qemu_get_machine_opts(), "dtb");
if (dtb_filename) {
fdt = load_device_tree(dtb_filename, &fdt_size);
if (!fdt) {
error_report("Error while loading device tree file '%s'",
dtb_filename);
}
} else {
/* Try the local "ppc.dtb" override. */
fdt = load_device_tree("ppc.dtb", &fdt_size);
if (!fdt) {
path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (path) {
fdt = load_device_tree(path, &fdt_size);
g_free(path);
}
}
}
if (!fdt) {
return 0;
}
r = qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-start",
initrd_base);
if (r < 0) {
error_report("couldn't set /chosen/linux,initrd-start");
}
r = qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-end",
(initrd_base + initrd_size));
if (r < 0) {
error_report("couldn't set /chosen/linux,initrd-end");
}
r = qemu_fdt_setprop_string(fdt, "/chosen", "bootargs", kernel_cmdline);
if (r < 0)
fprintf(stderr, "couldn't set /chosen/bootargs\n");
cpu_physical_memory_write(addr, fdt, fdt_size);
return fdt_size;
}示例10: put_words
/* Put an array of words in to main memory */
static inline int put_words(OHCIState *ohci,
uint32_t addr, uint16_t *buf, int num)
{
int i;
addr += ohci->localmem_base;
for (i = 0; i < num; i++, buf++, addr += sizeof(*buf)) {
uint16_t tmp = cpu_to_le16(*buf);
cpu_physical_memory_write(addr, &tmp, sizeof(tmp));
}
return 1;
}示例11: pdc_start_transfer
static int pdc_start_transfer(void *opaque,
target_phys_addr_t tx,
unsigned int *tx_len,
target_phys_addr_t rx,
unsigned int *rx_len,
int last_transfer)
{
SPIState *s = opaque;
unsigned int i;
unsigned int tlen;
DPRINTF("pdc: start transfer, last trans %d\n", last_transfer);
#if 1
if (tx_len == NULL) {
DPRINTF("ignore only read request\n");
return -1;
}
#endif
tlen = *tx_len;
if (rx_len != NULL) {
tlen = *rx_len > tlen ? *rx_len : tlen;
}
/* suppose that transfer 8 bit,
TODO: fix this, extract right value from csr
*/
s->spi_control->set_chipselect(s->spi_control->opaque, 1);
for (i = 0; i < tlen; ++i) {
DPRINTF("pdc: transfering\n");
uint8_t tmp = 0;
if (tx_len != NULL && *tx_len > 0) {
cpu_physical_memory_read(tx, &tmp, 1);
++tx;
--*tx_len;
}
tmp = s->spi_control->txrx_callback(s->spi_control->opaque, tmp, 8);
s->rdr = tmp;
if (rx_len != NULL && *rx_len > 0) {
cpu_physical_memory_write(rx, &tmp, 1);
++rx;
--*rx_len;
}
}
if (last_transfer) {
s->spi_control->set_chipselect(s->spi_control->opaque, 0);
}
return 0;
}示例12: petalogix_load_device_tree
static int petalogix_load_device_tree(target_phys_addr_t addr,
uint32_t ramsize,
target_phys_addr_t initrd_base,
target_phys_addr_t initrd_size,
const char *kernel_cmdline)
{
#ifdef HAVE_FDT
void *fdt;
int r;
#endif
char *path;
int fdt_size;
#ifdef HAVE_FDT
/* Try the local "mb.dtb" override. */
fdt = load_device_tree("mb.dtb", &fdt_size);
if (!fdt) {
path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (path) {
fdt = load_device_tree(path, &fdt_size);
qemu_free(path);
}
if (!fdt)
return 0;
}
r = qemu_devtree_setprop_string(fdt, "/chosen", "bootargs", kernel_cmdline);
if (r < 0)
fprintf(stderr, "couldn't set /chosen/bootargs\n");
cpu_physical_memory_write (addr, (void *)fdt, fdt_size);
#else
/* We lack libfdt so we cannot manipulate the fdt. Just pass on the blob
to the kernel. */
fdt_size = load_image_targphys("mb.dtb", addr, 0x10000);
if (fdt_size < 0) {
path = qemu_find_file(QEMU_FILE_TYPE_BIOS, BINARY_DEVICE_TREE_FILE);
if (path) {
fdt_size = load_image_targphys(path, addr, 0x10000);
qemu_free(path);
}
}
if (kernel_cmdline) {
fprintf(stderr,
"Warning: missing libfdt, cannot pass cmdline to kernel!\n");
}
#endif
return fdt_size;
}示例13: bcm2708_vc_fb
static void bcm2708_vc_fb(struct bcm2708_vc *_vc,
int _chan, uint32_t _msg)
{
target_phys_addr_t dma = _msg &~ (0xc << 28);
cpu_physical_memory_read(dma, &_vc->fb, sizeof(_vc->fb));
// TODO: much better calculations.
int pitch;
switch(_vc->fb.bpp)
{
case 8:
pitch = _vc->fb.xres;
_vc->fb_bpp = BPP_8;
break;
case 16:
pitch = _vc->fb.xres << 1;
_vc->fb_bpp = BPP_16_565;
break;
case 32:
pitch = _vc->fb.xres << 2;
_vc->fb_bpp = BPP_32;
break;
default:
pitch = _vc->fb.xres << 1;
_vc->fb_bpp = BPP_16_565;
break;
}
target_phys_addr_t fbsz = pitch*_vc->fb.yres;
target_phys_addr_t addr = 128*1024*1024; // Currently hard-coded in kernel?
_vc->fb_invalidate = 1;
_vc->fb.pitch = pitch;
_vc->fb.base = addr;
_vc->fb.screen_size = fbsz;
qemu_console_resize(_vc->disp, _vc->fb.xres, _vc->fb.yres);
#ifdef DEBUG_FB
printf("fb mapped to 0x%08x (%p).\n", addr, _vc->disp);
#endif
cpu_physical_memory_write(dma, &_vc->fb, sizeof(_vc->fb));
bcm2708_vc_send(_vc, _chan, 0);
}示例14: nand_dev_write
/* I/O write */
static void nand_dev_write(void *opaque, target_phys_addr_t offset, uint32_t value)
{
nand_dev_controller_state *s = (nand_dev_controller_state *)opaque;
switch (offset) {
case NAND_DEV:
s->dev = value;
if(s->dev >= nand_dev_count) {
cpu_abort(cpu_single_env, "nand_dev_write: Bad dev %x\n", value);
}
break;
case NAND_ADDR_HIGH:
s->addr_high = value;
break;
case NAND_ADDR_LOW:
s->addr_low = value;
break;
case NAND_BATCH_ADDR_LOW:
s->batch_addr_low = value;
break;
case NAND_BATCH_ADDR_HIGH:
s->batch_addr_high = value;
break;
case NAND_TRANSFER_SIZE:
s->transfer_size = value;
break;
case NAND_DATA:
s->data = value;
break;
case NAND_COMMAND:
s->result = nand_dev_do_cmd(s, value);
if (value == NAND_CMD_WRITE_BATCH || value == NAND_CMD_READ_BATCH ||
value == NAND_CMD_ERASE_BATCH) {
struct batch_data bd;
uint64_t bd_addr = ((uint64_t)s->batch_addr_high << 32) | s->batch_addr_low;
bd.result = s->result;
cpu_physical_memory_write(bd_addr, (void*)&bd, sizeof(struct batch_data));
}
break;
default:
cpu_abort(cpu_single_env, "nand_dev_write: Bad offset %x\n", offset);
break;
}
}示例15: goldfish_audio_buff_recv
static int
goldfish_audio_buff_recv( struct goldfish_audio_buff* b, int avail, struct goldfish_audio_state* s )
{
int missing = b->length - b->offset;
int avail2 = (avail > missing) ? missing : avail;
int read;
read = AUD_read(s->voicein, b->data + b->offset, avail2 );
if (read == 0)
return 0;
if (avail2 > 0)
D("%s: AUD_read(%d) returned %d", __FUNCTION__, avail2, read);
cpu_physical_memory_write( b->address + b->offset, b->data, read );
b->offset += read;
return read;
}