/ - Diff - qemu - Greek Research and Technology Network's projects

     /* This should not be used by devices.  */
     ram_addr_t qemu_ram_addr_from_host(void *ptr);
     int cpu_register_io_memory(CPUReadMemoryFunc **mem_read,
                                CPUWriteMemoryFunc **mem_write,
     int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
                                CPUWriteMemoryFunc * const *mem_write,
                                void *opaque);
     void cpu_unregister_io_memory(int table_address);

     #define SUBPAGE_IDX(addr) ((addr) & ~TARGET_PAGE_MASK)
     typedef struct subpage_t {
         target_phys_addr_t base;
         CPUReadMemoryFunc **mem_read[TARGET_PAGE_SIZE][4];
         CPUWriteMemoryFunc **mem_write[TARGET_PAGE_SIZE][4];
         CPUReadMemoryFunc * const *mem_read[TARGET_PAGE_SIZE][4];
         CPUWriteMemoryFunc * const *mem_write[TARGET_PAGE_SIZE][4];
         void *opaque[TARGET_PAGE_SIZE][2][4];
         ram_addr_t region_offset[TARGET_PAGE_SIZE][2][4];
     } subpage_t;
-...
     #endif
+    }
     static CPUReadMemoryFunc *unassigned_mem_read[3] = {
     static CPUReadMemoryFunc * const unassigned_mem_read[3] = {
         unassigned_mem_readb,
         unassigned_mem_readw,
         unassigned_mem_readl,
     };
     static CPUWriteMemoryFunc *unassigned_mem_write[3] = {
     static CPUWriteMemoryFunc * const unassigned_mem_write[3] = {
         unassigned_mem_writeb,
         unassigned_mem_writew,
         unassigned_mem_writel,
-...
             tlb_set_dirty(cpu_single_env, cpu_single_env->mem_io_vaddr);
+    }
     static CPUReadMemoryFunc *error_mem_read[3] = {
     static CPUReadMemoryFunc * const error_mem_read[3] = {
         NULL, /* never used */
         NULL, /* never used */
         NULL, /* never used */
     };
     static CPUWriteMemoryFunc *notdirty_mem_write[3] = {
     static CPUWriteMemoryFunc * const notdirty_mem_write[3] = {
         notdirty_mem_writeb,
         notdirty_mem_writew,
         notdirty_mem_writel,
-...
         stl_phys(addr, val);
+    }
     static CPUReadMemoryFunc *watch_mem_read[3] = {
     static CPUReadMemoryFunc * const watch_mem_read[3] = {
         watch_mem_readb,
         watch_mem_readw,
         watch_mem_readl,
     };
     static CPUWriteMemoryFunc *watch_mem_write[3] = {
     static CPUWriteMemoryFunc * const watch_mem_write[3] = {
         watch_mem_writeb,
         watch_mem_writew,
         watch_mem_writel,
-...
         subpage_writelen(opaque, addr, value, 2);
+    }
     static CPUReadMemoryFunc *subpage_read[] = {
     static CPUReadMemoryFunc * const subpage_read[] = {
         &subpage_readb,
         &subpage_readw,
         &subpage_readl,
     };
     static CPUWriteMemoryFunc *subpage_write[] = {
     static CPUWriteMemoryFunc * const subpage_write[] = {
         &subpage_writeb,
         &subpage_writew,
         &subpage_writel,
-...
        value can be used with cpu_register_physical_memory(). (-1) is
        returned if error. */
     static int cpu_register_io_memory_fixed(int io_index,
                                             CPUReadMemoryFunc **mem_read,
                                             CPUWriteMemoryFunc **mem_write,
                                             CPUReadMemoryFunc * const *mem_read,
                                             CPUWriteMemoryFunc * const *mem_write,
                                             void *opaque)
+    {
         int i, subwidth = 0;
-...
         return (io_index << IO_MEM_SHIFT) | subwidth;
+    }
     int cpu_register_io_memory(CPUReadMemoryFunc **mem_read,
                                CPUWriteMemoryFunc **mem_write,
     int cpu_register_io_memory(CPUReadMemoryFunc * const *mem_read,
                                CPUWriteMemoryFunc * const *mem_write,
                                void *opaque)
+    {
         return cpu_register_io_memory_fixed(0, mem_read, mem_write, opaque);

         return val;
+    }
     static CPUWriteMemoryFunc *pci_apb_config_write[] = {
     static CPUWriteMemoryFunc * const pci_apb_config_write[] = {
         &pci_apb_config_writel,
         &pci_apb_config_writel,
         &pci_apb_config_writel,
     };
     static CPUReadMemoryFunc *pci_apb_config_read[] = {
     static CPUReadMemoryFunc * const pci_apb_config_read[] = {
         &pci_apb_config_readl,
         &pci_apb_config_readl,
         &pci_apb_config_readl,
-...
         return val;
+    }
     static CPUWriteMemoryFunc *apb_config_write[] = {
     static CPUWriteMemoryFunc * const apb_config_write[] = {
         &apb_config_writel,
         &apb_config_writel,
         &apb_config_writel,
     };
     static CPUReadMemoryFunc *apb_config_read[] = {
     static CPUReadMemoryFunc * const apb_config_read[] = {
         &apb_config_readl,
         &apb_config_readl,
         &apb_config_readl,
     };
     static CPUWriteMemoryFunc *pci_apb_write[] = {
     static CPUWriteMemoryFunc * const pci_apb_write[] = {
         &pci_host_data_writeb,
         &pci_host_data_writew,
         &pci_host_data_writel,
     };
     static CPUReadMemoryFunc *pci_apb_read[] = {
     static CPUReadMemoryFunc * const pci_apb_read[] = {
         &pci_host_data_readb,
         &pci_host_data_readw,
         &pci_host_data_readl,
-...
         return val;
+    }
     static CPUWriteMemoryFunc *pci_apb_iowrite[] = {
     static CPUWriteMemoryFunc * const pci_apb_iowrite[] = {
         &pci_apb_iowriteb,
         &pci_apb_iowritew,
         &pci_apb_iowritel,
     };
     static CPUReadMemoryFunc *pci_apb_ioread[] = {
     static CPUReadMemoryFunc * const pci_apb_ioread[] = {
         &pci_apb_ioreadb,
         &pci_apb_ioreadw,
         &pci_apb_ioreadl,

         cpu_synchronize_state(s->cpu_env, 1);
+    }
     static CPUReadMemoryFunc *apic_mem_read[3] = {
     static CPUReadMemoryFunc * const apic_mem_read[3] = {
         apic_mem_readb,
         apic_mem_readw,
         apic_mem_readl,
     };
     static CPUWriteMemoryFunc *apic_mem_write[3] = {
     static CPUWriteMemoryFunc * const apic_mem_write[3] = {
         apic_mem_writeb,
         apic_mem_writew,
         apic_mem_writel,

         gic_dist_writew(opaque, offset + 2, value >> 16);
+    }
     static CPUReadMemoryFunc *gic_dist_readfn[] = {
     static CPUReadMemoryFunc * const gic_dist_readfn[] = {
        gic_dist_readb,
        gic_dist_readw,
        gic_dist_readl
     };
     static CPUWriteMemoryFunc *gic_dist_writefn[] = {
     static CPUWriteMemoryFunc * const gic_dist_writefn[] = {
        gic_dist_writeb,
        gic_dist_writew,
        gic_dist_writel

+        }
+    }
     static CPUReadMemoryFunc *arm_sysctl_readfn[] = {
     static CPUReadMemoryFunc * const arm_sysctl_readfn[] = {
        arm_sysctl_read,
        arm_sysctl_read,
        arm_sysctl_read
     };
     static CPUWriteMemoryFunc *arm_sysctl_writefn[] = {
     static CPUWriteMemoryFunc * const arm_sysctl_writefn[] = {
        arm_sysctl_write,
        arm_sysctl_write,
        arm_sysctl_write

+        }
+    }
     static CPUReadMemoryFunc *sp804_readfn[] = {
     static CPUReadMemoryFunc * const sp804_readfn[] = {
        sp804_read,
        sp804_read,
        sp804_read
     };
     static CPUWriteMemoryFunc *sp804_writefn[] = {
     static CPUWriteMemoryFunc * const sp804_writefn[] = {
        sp804_write,
        sp804_write,
        sp804_write
-...
+    }
     static CPUReadMemoryFunc *icp_pit_readfn[] = {
     static CPUReadMemoryFunc * const icp_pit_readfn[] = {
        icp_pit_read,
        icp_pit_read,
        icp_pit_read
     };
     static CPUWriteMemoryFunc *icp_pit_writefn[] = {
     static CPUWriteMemoryFunc * const icp_pit_writefn[] = {
        icp_pit_write,
        icp_pit_write,
        icp_pit_write

         cpu_physical_memory_write(addr, (uint8_t *)&v, 4);
+    }
     static CPUReadMemoryFunc *bitband_readfn[] = {
     static CPUReadMemoryFunc * const bitband_readfn[] = {
        bitband_readb,
        bitband_readw,
        bitband_readl
     };
     static CPUWriteMemoryFunc *bitband_writefn[] = {
     static CPUWriteMemoryFunc * const bitband_writefn[] = {
        bitband_writeb,
        bitband_writew,
        bitband_writel

         s->rdy = rdy;
+    }
     static CPUReadMemoryFunc *nand_read[] = {
     static CPUReadMemoryFunc * const nand_read[] = {
         &nand_readl,
         &nand_readl,
         &nand_readl,
     };
     static CPUWriteMemoryFunc *nand_write[] = {
     static CPUWriteMemoryFunc * const nand_write[] = {
         &nand_writel,
         &nand_writel,
         &nand_writel,
-...
+        }
+    }
     static CPUReadMemoryFunc *gpio_read[] = {
     static CPUReadMemoryFunc * const gpio_read[] = {
         NULL, NULL,
         &gpio_readl,
     };
     static CPUWriteMemoryFunc *gpio_write[] = {
     static CPUWriteMemoryFunc * const gpio_write[] = {
         NULL, NULL,
         &gpio_writel,
     };

     #endif
+    }
     static CPUReadMemoryFunc *cirrus_vga_mem_read[3] = {
     static CPUReadMemoryFunc * const cirrus_vga_mem_read[3] = {
         cirrus_vga_mem_readb,
         cirrus_vga_mem_readw,
         cirrus_vga_mem_readl,
     };
     static CPUWriteMemoryFunc *cirrus_vga_mem_write[3] = {
     static CPUWriteMemoryFunc * const cirrus_vga_mem_write[3] = {
         cirrus_vga_mem_writeb,
         cirrus_vga_mem_writew,
         cirrus_vga_mem_writel,
-...
+    }
     static CPUReadMemoryFunc *cirrus_linear_read[3] = {
     static CPUReadMemoryFunc * const cirrus_linear_read[3] = {
         cirrus_linear_readb,
         cirrus_linear_readw,
         cirrus_linear_readl,
     };
     static CPUWriteMemoryFunc *cirrus_linear_write[3] = {
     static CPUWriteMemoryFunc * const cirrus_linear_write[3] = {
         cirrus_linear_writeb,
         cirrus_linear_writew,
         cirrus_linear_writel,
-...
+    }
     static CPUReadMemoryFunc *cirrus_linear_bitblt_read[3] = {
     static CPUReadMemoryFunc * const cirrus_linear_bitblt_read[3] = {
         cirrus_linear_bitblt_readb,
         cirrus_linear_bitblt_readw,
         cirrus_linear_bitblt_readl,
     };
     static CPUWriteMemoryFunc *cirrus_linear_bitblt_write[3] = {
     static CPUWriteMemoryFunc * const cirrus_linear_bitblt_write[3] = {
         cirrus_linear_bitblt_writeb,
         cirrus_linear_bitblt_writew,
         cirrus_linear_bitblt_writel,
-...
+    }
     static CPUReadMemoryFunc *cirrus_mmio_read[3] = {
     static CPUReadMemoryFunc * const cirrus_mmio_read[3] = {
         cirrus_mmio_readb,
         cirrus_mmio_readw,
         cirrus_mmio_readl,
     };
     static CPUWriteMemoryFunc *cirrus_mmio_write[3] = {
     static CPUWriteMemoryFunc * const cirrus_mmio_write[3] = {
         cirrus_mmio_writeb,
         cirrus_mmio_writew,
         cirrus_mmio_writel,

+        }
+    }
     static CPUReadMemoryFunc *cs_mem_read[3] = {
     static CPUReadMemoryFunc * const cs_mem_read[3] = {
         cs_mem_readl,
         cs_mem_readl,
         cs_mem_readl,
     };
     static CPUWriteMemoryFunc *cs_mem_write[3] = {
     static CPUWriteMemoryFunc * const cs_mem_write[3] = {
         cs_mem_writel,
         cs_mem_writel,
         cs_mem_writel,

         return 0;
+    }
     static CPUWriteMemoryFunc *cuda_write[] = {
     static CPUWriteMemoryFunc * const cuda_write[] = {
         &cuda_writeb,
         &cuda_writew,
         &cuda_writel,
     };
     static CPUReadMemoryFunc *cuda_read[] = {
     static CPUReadMemoryFunc * const cuda_read[] = {
         &cuda_readb,
         &cuda_readw,
         &cuda_readl,

         dp8393x_writew(opaque, addr + 2, (val >> 16) & 0xffff);
+    }
     static CPUReadMemoryFunc *dp8393x_read[3] = {
     static CPUReadMemoryFunc * const dp8393x_read[3] = {
         dp8393x_readb,
         dp8393x_readw,
         dp8393x_readl,
     };
     static CPUWriteMemoryFunc *dp8393x_write[3] = {
     static CPUWriteMemoryFunc * const dp8393x_write[3] = {
         dp8393x_writeb,
         dp8393x_writew,
         dp8393x_writel,

         nvram_writeb_protected(opaque, addr + 3, (val >> 24) & 0xff);
+    }
     static CPUReadMemoryFunc *nvram_read[] = {
     static CPUReadMemoryFunc * const nvram_read[] = {
         &nvram_readb,
         &nvram_readw,
         &nvram_readl,
     };
     static CPUWriteMemoryFunc *nvram_write[] = {
     static CPUWriteMemoryFunc * const nvram_write[] = {
         &nvram_writeb,
         &nvram_writew,
         &nvram_writel,
     };
     static CPUWriteMemoryFunc *nvram_write_protected[] = {
     static CPUWriteMemoryFunc * const nvram_write_protected[] = {
         &nvram_writeb_protected,
         &nvram_writew_protected,
         &nvram_writel_protected,

     /* PCI interface */
     static CPUWriteMemoryFunc *e1000_mmio_write[] = {
     static CPUWriteMemoryFunc * const e1000_mmio_write[] = {
         e1000_mmio_writeb,	e1000_mmio_writew,	e1000_mmio_writel
     };
     static CPUReadMemoryFunc *e1000_mmio_read[] = {
     static CPUReadMemoryFunc * const e1000_mmio_read[] = {
         e1000_mmio_readb,	e1000_mmio_readw,	e1000_mmio_readl
     };

         return ret;
+    }
     static CPUReadMemoryFunc *ecc_mem_read[3] = {
     static CPUReadMemoryFunc * const ecc_mem_read[3] = {
         NULL,
         NULL,
         ecc_mem_readl,
     };
     static CPUWriteMemoryFunc *ecc_mem_write[3] = {
     static CPUWriteMemoryFunc * const ecc_mem_write[3] = {
         NULL,
         NULL,
         ecc_mem_writel,
-...
         return ret;
+    }
     static CPUReadMemoryFunc *ecc_diag_mem_read[3] = {
     static CPUReadMemoryFunc * const ecc_diag_mem_read[3] = {
         ecc_diag_mem_readb,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *ecc_diag_mem_write[3] = {
     static CPUWriteMemoryFunc * const ecc_diag_mem_write[3] = {
         ecc_diag_mem_writeb,
         NULL,
         NULL,

         return eepro100_read4(s, addr);
+    }
     static CPUWriteMemoryFunc *pci_mmio_write[] = {
     static CPUWriteMemoryFunc * const pci_mmio_write[] = {
         pci_mmio_writeb,
         pci_mmio_writew,
         pci_mmio_writel
     };
     static CPUReadMemoryFunc *pci_mmio_read[] = {
     static CPUReadMemoryFunc * const pci_mmio_read[] = {
         pci_mmio_readb,
         pci_mmio_readw,
         pci_mmio_readl

             serial_receive_break(s);
+    }
     static CPUReadMemoryFunc *escc_mem_read[3] = {
     static CPUReadMemoryFunc * const escc_mem_read[3] = {
         escc_mem_readb,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *escc_mem_write[3] = {
     static CPUWriteMemoryFunc * const escc_mem_write[3] = {
         escc_mem_writeb,
         NULL,
         NULL,

         s->wregs[saddr] = val;
+    }
     static CPUReadMemoryFunc *esp_mem_read[3] = {
     static CPUReadMemoryFunc * const esp_mem_read[3] = {
         esp_mem_readb,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *esp_mem_write[3] = {
     static CPUWriteMemoryFunc * const esp_mem_write[3] = {
         esp_mem_writeb,
         NULL,
         esp_mem_writeb,

+            }
+    }
     static CPUReadMemoryFunc *dma_read[] = {
     static CPUReadMemoryFunc * const dma_read[] = {
     	&dma_rinvalid,
     	&dma_rinvalid,
     	&dma_readl,
     };
     static CPUWriteMemoryFunc *dma_write[] = {
     static CPUWriteMemoryFunc * const dma_write[] = {
     	&dma_winvalid,
     	&dma_winvalid,
     	&dma_writel,

     	eth->phy.link = !vc->link_down;
+    }
     static CPUReadMemoryFunc *eth_read[] = {
     static CPUReadMemoryFunc * const eth_read[] = {
     	NULL, NULL,
     	&eth_readl,
     };
     static CPUWriteMemoryFunc *eth_write[] = {
     static CPUWriteMemoryFunc * const eth_write[] = {
     	NULL, NULL,
     	&eth_writel,
     };

+        }
+    }
     static CPUReadMemoryFunc *pic_read[] = {
     static CPUReadMemoryFunc * const pic_read[] = {
         NULL, NULL,
         &pic_readl,
     };
     static CPUWriteMemoryFunc *pic_write[] = {
     static CPUWriteMemoryFunc * const pic_write[] = {
         NULL, NULL,
         &pic_writel,
     };

         ser_update_irq(s);
+    }
     static CPUReadMemoryFunc *ser_read[] = {
     static CPUReadMemoryFunc * const ser_read[] = {
         NULL, NULL,
         &ser_readl,
     };
     static CPUWriteMemoryFunc *ser_write[] = {
     static CPUWriteMemoryFunc * const ser_write[] = {
         NULL, NULL,
         &ser_writel,
     };

+        }
+    }
     static CPUReadMemoryFunc *timer_read[] = {
     static CPUReadMemoryFunc * const timer_read[] = {
         NULL, NULL,
         &timer_readl,
     };
     static CPUWriteMemoryFunc *timer_write[] = {
     static CPUWriteMemoryFunc * const timer_write[] = {
         NULL, NULL,
         &timer_writel,
     };

         fdctrl_write(opaque, (uint32_t)reg, value);
+    }
     static CPUReadMemoryFunc *fdctrl_mem_read[3] = {
     static CPUReadMemoryFunc * const fdctrl_mem_read[3] = {
         fdctrl_read_mem,
         fdctrl_read_mem,
         fdctrl_read_mem,
     };
     static CPUWriteMemoryFunc *fdctrl_mem_write[3] = {
     static CPUWriteMemoryFunc * const fdctrl_mem_write[3] = {
         fdctrl_write_mem,
         fdctrl_write_mem,
         fdctrl_write_mem,
     };
     static CPUReadMemoryFunc *fdctrl_mem_read_strict[3] = {
     static CPUReadMemoryFunc * const fdctrl_mem_read_strict[3] = {
         fdctrl_read_mem,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *fdctrl_mem_write_strict[3] = {
     static CPUWriteMemoryFunc * const fdctrl_mem_write_strict[3] = {
         fdctrl_write_mem,
         NULL,
         NULL,

         fw_cfg_select(opaque, (uint16_t)value);
+    }
     static CPUReadMemoryFunc *fw_cfg_ctl_mem_read[3] = {
     static CPUReadMemoryFunc * const fw_cfg_ctl_mem_read[3] = {
         NULL,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *fw_cfg_ctl_mem_write[3] = {
     static CPUWriteMemoryFunc * const fw_cfg_ctl_mem_write[3] = {
         NULL,
         fw_cfg_mem_writew,
         NULL,
     };
     static CPUReadMemoryFunc *fw_cfg_data_mem_read[3] = {
     static CPUReadMemoryFunc * const fw_cfg_data_mem_read[3] = {
         fw_cfg_mem_readb,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *fw_cfg_data_mem_write[3] = {
     static CPUWriteMemoryFunc * const fw_cfg_data_mem_write[3] = {
         fw_cfg_mem_writeb,
         NULL,
         NULL,

         g364fb_ctrl_writel(opaque, addr & ~0x3, val);
+    }
     static CPUReadMemoryFunc *g364fb_ctrl_read[3] = {
     static CPUReadMemoryFunc * const g364fb_ctrl_read[3] = {
         g364fb_ctrl_readb,
         g364fb_ctrl_readw,
         g364fb_ctrl_readl,
     };
     static CPUWriteMemoryFunc *g364fb_ctrl_write[3] = {
     static CPUWriteMemoryFunc * const g364fb_ctrl_write[3] = {
         g364fb_ctrl_writeb,
         g364fb_ctrl_writew,
         g364fb_ctrl_writel,

         return val;
+    }
     static CPUWriteMemoryFunc *pci_grackle_config_write[] = {
     static CPUWriteMemoryFunc * const pci_grackle_config_write[] = {
         &pci_grackle_config_writel,
         &pci_grackle_config_writel,
         &pci_grackle_config_writel,
     };
     static CPUReadMemoryFunc *pci_grackle_config_read[] = {
     static CPUReadMemoryFunc * const pci_grackle_config_read[] = {
         &pci_grackle_config_readl,
         &pci_grackle_config_readl,
         &pci_grackle_config_readl,
     };
     static CPUWriteMemoryFunc *pci_grackle_write[] = {
     static CPUWriteMemoryFunc * const pci_grackle_write[] = {
         &pci_host_data_writeb,
         &pci_host_data_writew,
         &pci_host_data_writel,
     };
     static CPUReadMemoryFunc *pci_grackle_read[] = {
     static CPUReadMemoryFunc * const pci_grackle_read[] = {
         &pci_host_data_readb,
         &pci_host_data_readw,
         &pci_host_data_readl,

         return val;
+    }
     static CPUWriteMemoryFunc *gt64120_write[] = {
     static CPUWriteMemoryFunc * const gt64120_write[] = {
         &gt64120_writel,
         &gt64120_writel,
         &gt64120_writel,
     };
     static CPUReadMemoryFunc *gt64120_read[] = {
     static CPUReadMemoryFunc * const gt64120_read[] = {
         &gt64120_readl,
         &gt64120_readl,
         &gt64120_readl,

         return value;
+    }
     static CPUWriteMemoryFunc *pic_write[] = {
     static CPUWriteMemoryFunc * const pic_write[] = {
         &pic_writel,
         &pic_writel,
         &pic_writel,
     };
     static CPUReadMemoryFunc *pic_read[] = {
     static CPUReadMemoryFunc * const pic_read[] = {
         &pic_readl,
         &pic_readl,
         &pic_readl,

+        }
+    }
     static CPUReadMemoryFunc *hpet_ram_read[] = {
     static CPUReadMemoryFunc * const hpet_ram_read[] = {
     #ifdef HPET_DEBUG
         hpet_ram_readb,
         hpet_ram_readw,
-...
         hpet_ram_readl,
     };
     static CPUWriteMemoryFunc *hpet_ram_write[] = {
     static CPUWriteMemoryFunc * const hpet_ram_write[] = {
     #ifdef HPET_DEBUG
         hpet_ram_writeb,
         hpet_ram_writew,

         return retval;
+    }
     static CPUWriteMemoryFunc *pmac_ide_write[] = {
     static CPUWriteMemoryFunc * const pmac_ide_write[] = {
         pmac_ide_writeb,
         pmac_ide_writew,
         pmac_ide_writel,
     };
     static CPUReadMemoryFunc *pmac_ide_read[] = {
     static CPUReadMemoryFunc * const pmac_ide_read[] = {
         pmac_ide_readb,
         pmac_ide_readw,
         pmac_ide_readl,
-...
             ide_data_writew(ide, 0, val);
+    }
     static CPUReadMemoryFunc *mmio_ide_reads[] = {
     static CPUReadMemoryFunc * const mmio_ide_reads[] = {
         mmio_ide_read,
         mmio_ide_read,
         mmio_ide_read,
     };
     static CPUWriteMemoryFunc *mmio_ide_writes[] = {
     static CPUWriteMemoryFunc * const mmio_ide_writes[] = {
         mmio_ide_write,
         mmio_ide_write,
         mmio_ide_write,
-...
         ide_cmd_write(ide, 0, val);
+    }
     static CPUReadMemoryFunc *mmio_ide_status[] = {
     static CPUReadMemoryFunc * const mmio_ide_status[] = {
         mmio_ide_status_read,
         mmio_ide_status_read,
         mmio_ide_status_read,
     };
     static CPUWriteMemoryFunc *mmio_ide_cmd[] = {
     static CPUWriteMemoryFunc * const mmio_ide_cmd[] = {
         mmio_ide_cmd_write,
         mmio_ide_cmd_write,
         mmio_ide_cmd_write,

     /* Integrator/CM control registers.  */
     static CPUReadMemoryFunc *integratorcm_readfn[] = {
     static CPUReadMemoryFunc * const integratorcm_readfn[] = {
        integratorcm_read,
        integratorcm_read,
        integratorcm_read
     };
     static CPUWriteMemoryFunc *integratorcm_writefn[] = {
     static CPUWriteMemoryFunc * const integratorcm_writefn[] = {
        integratorcm_write,
        integratorcm_write,
        integratorcm_write
-...
         icp_pic_update(s);
+    }
     static CPUReadMemoryFunc *icp_pic_readfn[] = {
     static CPUReadMemoryFunc * const icp_pic_readfn[] = {
        icp_pic_read,
        icp_pic_read,
        icp_pic_read
     };
     static CPUWriteMemoryFunc *icp_pic_writefn[] = {
     static CPUWriteMemoryFunc * const icp_pic_writefn[] = {
        icp_pic_write,
        icp_pic_write,
        icp_pic_write
-...
             hw_error("icp_control_write: Bad offset %x\n", (int)offset);
+        }
+    }
     static CPUReadMemoryFunc *icp_control_readfn[] = {
     static CPUReadMemoryFunc * const icp_control_readfn[] = {
        icp_control_read,
        icp_control_read,
        icp_control_read
     };
     static CPUWriteMemoryFunc *icp_control_writefn[] = {
     static CPUWriteMemoryFunc * const icp_control_writefn[] = {
        icp_control_write,
        icp_control_write,
        icp_control_write

             s->ioredtbl[i] = 1 << 16; /* mask LVT */
+    }
     static CPUReadMemoryFunc *ioapic_mem_read[3] = {
     static CPUReadMemoryFunc * const ioapic_mem_read[3] = {
         ioapic_mem_readl,
         ioapic_mem_readl,
         ioapic_mem_readl,
     };
     static CPUWriteMemoryFunc *ioapic_mem_write[3] = {
     static CPUWriteMemoryFunc * const ioapic_mem_write[3] = {
         ioapic_mem_writel,
         ioapic_mem_writel,
         ioapic_mem_writel,

+        }
+    }
     static CPUReadMemoryFunc *iommu_mem_read[3] = {
     static CPUReadMemoryFunc * const iommu_mem_read[3] = {
         NULL,
         NULL,
         iommu_mem_readl,
     };
     static CPUWriteMemoryFunc *iommu_mem_write[3] = {
     static CPUWriteMemoryFunc * const iommu_mem_write[3] = {
         NULL,
         NULL,
         iommu_mem_writel,

         return val;
+    }
     static CPUWriteMemoryFunc *isa_mmio_write[] = {
     static CPUWriteMemoryFunc * const isa_mmio_write[] = {
         &isa_mmio_writeb,
         &isa_mmio_writew,
         &isa_mmio_writel,
     };
     static CPUReadMemoryFunc *isa_mmio_read[] = {
     static CPUReadMemoryFunc * const isa_mmio_read[] = {
         &isa_mmio_readb,
         &isa_mmio_readw,
         &isa_mmio_readl,

     #endif
+    }
     static CPUReadMemoryFunc *led_read[3] = {
     static CPUReadMemoryFunc * const led_read[3] = {
         led_readb,
         led_readw,
         led_readl,
     };
     static CPUWriteMemoryFunc *led_write[3] = {
     static CPUWriteMemoryFunc * const led_write[3] = {
         led_writeb,
         led_writew,
         led_writel,

         return val;
+    }
     static CPUReadMemoryFunc *lsi_mmio_readfn[3] = {
     static CPUReadMemoryFunc * const lsi_mmio_readfn[3] = {
         lsi_mmio_readb,
         lsi_mmio_readw,
         lsi_mmio_readl,
     };
     static CPUWriteMemoryFunc *lsi_mmio_writefn[3] = {
     static CPUWriteMemoryFunc * const lsi_mmio_writefn[3] = {
         lsi_mmio_writeb,
         lsi_mmio_writew,
         lsi_mmio_writel,
-...
         return le32_to_cpu(s->script_ram[addr >> 2]);
+    }
     static CPUReadMemoryFunc *lsi_ram_readfn[3] = {
     static CPUReadMemoryFunc * const lsi_ram_readfn[3] = {
         lsi_ram_readb,
         lsi_ram_readw,
         lsi_ram_readl,
     };
     static CPUWriteMemoryFunc *lsi_ram_writefn[3] = {
     static CPUWriteMemoryFunc * const lsi_ram_writefn[3] = {
         lsi_ram_writeb,
         lsi_ram_writew,
         lsi_ram_writel,

         return retval;
+    }
     static CPUWriteMemoryFunc *nvram_write[] = {
     static CPUWriteMemoryFunc * const nvram_write[] = {
         &nvram_writeb,
         &nvram_writew,
         &nvram_writel,
     };
     static CPUReadMemoryFunc *nvram_read[] = {
     static CPUReadMemoryFunc * const nvram_read[] = {
         &nvram_readb,
         &nvram_readw,
         &nvram_readl,

         return value;
+    }
     static CPUWriteMemoryFunc *dbdma_write[] = {
     static CPUWriteMemoryFunc * const dbdma_write[] = {
         NULL,
         NULL,
         dbdma_writel,
     };
     static CPUReadMemoryFunc *dbdma_read[] = {
     static CPUReadMemoryFunc * const dbdma_read[] = {
         NULL,
         NULL,
         dbdma_readl,

         return value;
+    }
     static CPUWriteMemoryFunc *nvram_write[] = {
     static CPUWriteMemoryFunc * const nvram_write[] = {
         &macio_nvram_writeb,
         &macio_nvram_writeb,
         &macio_nvram_writeb,
     };
     static CPUReadMemoryFunc *nvram_read[] = {
     static CPUReadMemoryFunc * const nvram_read[] = {
         &macio_nvram_readb,
         &macio_nvram_readb,
         &macio_nvram_readb,

         s->irq_enable = 0;
+    }
     static CPUReadMemoryFunc *mv88w8618_audio_readfn[] = {
     static CPUReadMemoryFunc * const mv88w8618_audio_readfn[] = {
         mv88w8618_audio_read,
         mv88w8618_audio_read,
         mv88w8618_audio_read
     };
     static CPUWriteMemoryFunc *mv88w8618_audio_writefn[] = {
     static CPUWriteMemoryFunc * const mv88w8618_audio_writefn[] = {
         mv88w8618_audio_write,
         mv88w8618_audio_write,
         mv88w8618_audio_write

         cmos_ioport_write(s, addr >> s->it_shift, value);
+    }
     static CPUReadMemoryFunc *rtc_mm_read[] = {
     static CPUReadMemoryFunc * const rtc_mm_read[] = {
         &cmos_mm_readb,
         &cmos_mm_readw,
         &cmos_mm_readl,
     };
     static CPUWriteMemoryFunc *rtc_mm_write[] = {
     static CPUWriteMemoryFunc * const rtc_mm_write[] = {
         &cmos_mm_writeb,
         &cmos_mm_writew,
         &cmos_mm_writel,

         m5206_mbar_write(s, offset, value);
+    }
     static CPUReadMemoryFunc *m5206_mbar_readfn[] = {
     static CPUReadMemoryFunc * const m5206_mbar_readfn[] = {
        m5206_mbar_readb,
        m5206_mbar_readw,
        m5206_mbar_readl
     };
     static CPUWriteMemoryFunc *m5206_mbar_writefn[] = {
     static CPUWriteMemoryFunc * const m5206_mbar_writefn[] = {
        m5206_mbar_writeb,
        m5206_mbar_writew,
        m5206_mbar_writel

+        }
+    }
     static CPUReadMemoryFunc *m5208_timer_readfn[] = {
     static CPUReadMemoryFunc * const m5208_timer_readfn[] = {
        m5208_timer_read,
        m5208_timer_read,
        m5208_timer_read
     };
     static CPUWriteMemoryFunc *m5208_timer_writefn[] = {
     static CPUWriteMemoryFunc * const m5208_timer_writefn[] = {
        m5208_timer_write,
        m5208_timer_write,
        m5208_timer_write
-...
         hw_error("m5208_sys_write: Bad offset 0x%x\n", (int)addr);
+    }
     static CPUReadMemoryFunc *m5208_sys_readfn[] = {
     static CPUReadMemoryFunc * const m5208_sys_readfn[] = {
        m5208_sys_read,
        m5208_sys_read,
        m5208_sys_read
     };
     static CPUWriteMemoryFunc *m5208_sys_writefn[] = {
     static CPUWriteMemoryFunc * const m5208_sys_writefn[] = {
        m5208_sys_write,
        m5208_sys_write,
        m5208_sys_write

         return size;
+    }
     static CPUReadMemoryFunc *mcf_fec_readfn[] = {
     static CPUReadMemoryFunc * const mcf_fec_readfn[] = {
        mcf_fec_read,
        mcf_fec_read,
        mcf_fec_read
     };
     static CPUWriteMemoryFunc *mcf_fec_writefn[] = {
     static CPUWriteMemoryFunc * const mcf_fec_writefn[] = {
        mcf_fec_write,
        mcf_fec_write,
        mcf_fec_write

         s->active_vector = 24;
+    }
     static CPUReadMemoryFunc *mcf_intc_readfn[] = {
     static CPUReadMemoryFunc * const mcf_intc_readfn[] = {
        mcf_intc_read,
        mcf_intc_read,
        mcf_intc_read
     };
     static CPUWriteMemoryFunc *mcf_intc_writefn[] = {
     static CPUWriteMemoryFunc * const mcf_intc_writefn[] = {
        mcf_intc_write,
        mcf_intc_write,
        mcf_intc_write

+    }
     static CPUReadMemoryFunc *mcf_uart_readfn[] = {
     static CPUReadMemoryFunc * const mcf_uart_readfn[] = {
        mcf_uart_read,
        mcf_uart_read,
        mcf_uart_read
     };
     static CPUWriteMemoryFunc *mcf_uart_writefn[] = {
     static CPUWriteMemoryFunc * const mcf_uart_writefn[] = {
        mcf_uart_write,
        mcf_uart_write,
        mcf_uart_write

         cpu_outw(env, 0x71, val & 0xff);
+    }
     static CPUReadMemoryFunc *rtc_read[3] = {
     static CPUReadMemoryFunc * const rtc_read[3] = {
         rtc_readb,
         rtc_readb,
         rtc_readb,
     };
     static CPUWriteMemoryFunc *rtc_write[3] = {
     static CPUWriteMemoryFunc * const rtc_write[3] = {
         rtc_writeb,
         rtc_writeb,
         rtc_writeb,
-...
          * the current DMA acknowledge cycle is completed. */
+    }
     static CPUReadMemoryFunc *dma_dummy_read[3] = {
     static CPUReadMemoryFunc * const dma_dummy_read[3] = {
         NULL,
         NULL,
         NULL,
     };
     static CPUWriteMemoryFunc *dma_dummy_write[3] = {
     static CPUWriteMemoryFunc * const dma_dummy_write[3] = {
         dma_dummy_writeb,
         dma_dummy_writeb,
         dma_dummy_writeb,

+        }
+    }
     static CPUReadMemoryFunc *malta_fpga_read[] = {
     static CPUReadMemoryFunc * const malta_fpga_read[] = {
        malta_fpga_readl,
        malta_fpga_readl,
        malta_fpga_readl
     };
     static CPUWriteMemoryFunc *malta_fpga_write[] = {
     static CPUWriteMemoryFunc * const malta_fpga_write[] = {
        malta_fpga_writel,
        malta_fpga_writel,
        malta_fpga_writel

         return 0;
+    }
     static CPUWriteMemoryFunc *mips_qemu_write[] = {
     static CPUWriteMemoryFunc * const mips_qemu_write[] = {
         &mips_qemu_writel,
         &mips_qemu_writel,
         &mips_qemu_writel,
     };
     static CPUReadMemoryFunc *mips_qemu_read[] = {
     static CPUReadMemoryFunc * const mips_qemu_read[] = {
         &mips_qemu_readl,
         &mips_qemu_readl,
         &mips_qemu_readl,

         hw_error("mpcore_priv_read: Bad offset %x\n", (int)offset);
+    }
     static CPUReadMemoryFunc *mpcore_priv_readfn[] = {
     static CPUReadMemoryFunc * const mpcore_priv_readfn[] = {
        mpcore_priv_read,
        mpcore_priv_read,
        mpcore_priv_read
     };
     static CPUWriteMemoryFunc *mpcore_priv_writefn[] = {
     static CPUWriteMemoryFunc * const mpcore_priv_writefn[] = {
        mpcore_priv_write,
        mpcore_priv_write,
        mpcore_priv_write

         fprintf(stderr, "MSI-X: only dword write is allowed!\n");
+    }
     static CPUWriteMemoryFunc *msix_mmio_write[] = {
     static CPUWriteMemoryFunc * const msix_mmio_write[] = {
         msix_mmio_write_unallowed, msix_mmio_write_unallowed, msix_mmio_writel
     };
     static CPUReadMemoryFunc *msix_mmio_read[] = {
     static CPUReadMemoryFunc * const msix_mmio_read[] = {
         msix_mmio_read_unallowed, msix_mmio_read_unallowed, msix_mmio_readl
     };

+    	}
+    }
     static CPUReadMemoryFunc *mst_fpga_readfn[] = {
     static CPUReadMemoryFunc * const mst_fpga_readfn[] = {
     	mst_fpga_readb,
     	mst_fpga_readb,
     	mst_fpga_readb,
     };
     static CPUWriteMemoryFunc *mst_fpga_writefn[] = {
     static CPUWriteMemoryFunc * const mst_fpga_writefn[] = {
     	mst_fpga_writeb,
     	mst_fpga_writeb,
     	mst_fpga_writeb,

+        }
+    }
     static CPUReadMemoryFunc *mv88w8618_eth_readfn[] = {
     static CPUReadMemoryFunc * const mv88w8618_eth_readfn[] = {
         mv88w8618_eth_read,
         mv88w8618_eth_read,
         mv88w8618_eth_read
     };
     static CPUWriteMemoryFunc *mv88w8618_eth_writefn[] = {
     static CPUWriteMemoryFunc * const mv88w8618_eth_writefn[] = {
         mv88w8618_eth_write,
         mv88w8618_eth_write,
         mv88w8618_eth_write
-...
+        }
+    }
     static CPUReadMemoryFunc *musicpal_lcd_readfn[] = {
     static CPUReadMemoryFunc * const musicpal_lcd_readfn[] = {
         musicpal_lcd_read,
         musicpal_lcd_read,
         musicpal_lcd_read
     };
     static CPUWriteMemoryFunc *musicpal_lcd_writefn[] = {
     static CPUWriteMemoryFunc * const musicpal_lcd_writefn[] = {
         musicpal_lcd_write,
         musicpal_lcd_write,
         musicpal_lcd_write
-...
         s->enabled = 0;
+    }
     static CPUReadMemoryFunc *mv88w8618_pic_readfn[] = {
     static CPUReadMemoryFunc * const mv88w8618_pic_readfn[] = {

Archipelago » qemu

Revision d60efc6b