static unsigned hw_disk_io_read_buffer(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_disk_device *disk = device_data(me); unsigned nr_bytes_read; if (space != 0) device_error(me, "read - extended disk addressing unimplemented"); if (nr_bytes == 0) nr_bytes_read = 0; else if (fseek(disk->image, addr, SEEK_SET) < 0) nr_bytes_read = 0; else if (fread(dest, nr_bytes, 1, disk->image) != 1) nr_bytes_read = 0; else nr_bytes_read = nr_bytes; DTRACE(disk, ("io-read - address 0x%lx, nr-bytes-read %d, requested %d\n", (unsigned long) addr, (int)nr_bytes_read, (int)nr_bytes)); return nr_bytes_read; }
static void hw_disk_init_address(device *me) { hw_disk_device *disk = device_data(me); unsigned_word address; int space; const char *name; /* attach to the parent. Since the bus is logical, attach using just the unit-address (size must be zero) */ device_address_to_attach_address(device_parent(me), device_unit_address(me), &space, &address, me); device_attach_address(device_parent(me), attach_callback, space, address, 0/*size*/, access_read_write_exec, me); /* Tell the world we are a disk. */ device_add_string_property(me, "device_type", "block"); /* get the name of the file specifying the disk image */ disk->name_index = 0; disk->nr_names = device_find_string_array_property(me, "file", disk->name_index, &name); if (!disk->nr_names) device_error(me, "invalid file property"); /* is it a RO device? */ disk->read_only = (strcmp(device_name(me), "disk") != 0 && strcmp(device_name(me), "floppy") != 0 && device_find_property(me, "read-only") == NULL); /* now open it */ open_disk_image(me, disk, name); }
static int hw_disk_ioctl(device *me, cpu *processor, unsigned_word cia, device_ioctl_request request, va_list ap) { switch (request) { case device_ioctl_change_media: { hw_disk_device *disk = device_data(me); const char *name = va_arg(ap, const char *); if (name != NULL) { disk->name_index = -1; } else { disk->name_index = (disk->name_index + 1) % disk->nr_names; if (!device_find_string_array_property(me, "file", disk->name_index, &name)) device_error(me, "invalid file property"); } open_disk_image(me, disk, name); } break; default: device_error(me, "insupported ioctl request"); break; } return 0; }
static void hw_ide_init_address(device *me) { hw_ide_device *ide = device_data(me); int controller; int drive; /* zero some things */ for (controller = 0; controller < nr_ide_controllers; controller++) { memset(&ide->controller[controller], 0, sizeof(ide_controller)); for (drive = 0; drive < nr_ide_drives_per_controller; drive++) { ide->controller[controller].drive[drive].nr = drive; } ide->controller[controller].me = me; if (device_find_property(me, "ready-delay") != NULL) ide->controller[controller].ready_delay = device_find_integer_property(me, "ready-delay"); } /* attach this device to its parent */ generic_device_init_address(me); /* determine our own address map */ build_address_decoder(me, &ide->decoder); }
int sp_db_connect(sp_db *aThis) { if (aThis && !aThis->m_DB) { if (sqlite3_open( #if defined (WIN32) || defined (WIN64) "../test.sqlite" #else "/tmp/test.sqlite" #endif , &aThis->m_DB) == SQLITE_OK) { if ((SQLITE_OK != sqlite3_exec(aThis->m_DB, "CREATE TABLE IF NOT EXISTS \ devices (id INTEGER PRIMARY KEY AUTOINCREMENT, \ address CHAR(100) UNIQUE NOT NULL, type INTEGER NOT NULL)", 0, 0, 0)) || (SQLITE_OK != sqlite3_exec(aThis->m_DB, "CREATE TABLE IF NOT EXISTS \ device_data (id INTEGER PRIMARY KEY AUTOINCREMENT, \ did INTEGER NOT NULL, \ date INTEGER NOT NULL, state CHAR(255) NOT NULL)", 0, 0, 0))) { return 0; } return 1; } aThis->m_DB = 0; } return 0; }
static int hw_vm_ioctl(device *me, cpu *processor, unsigned_word cia, device_ioctl_request request, va_list ap) { /* While the caller is notified that the heap has grown by the requested amount, the heap is actually extended out to a page boundary. */ hw_vm_device *vm = (hw_vm_device*)device_data(me); switch (request) { case device_ioctl_break: { unsigned_word requested_break = va_arg(ap, unsigned_word); unsigned_word new_break = ALIGN_8(requested_break); unsigned_word old_break = vm->heap_bound; signed_word delta = new_break - old_break; if (delta > 0) vm->heap_bound = ALIGN_PAGE(new_break); break; } default: device_error(me, "Unsupported ioctl request"); break; } return 0; }
static unsigned hw_disk_io_write_buffer(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_disk_device *disk = device_data(me); unsigned nr_bytes_written; if (space != 0) device_error(me, "write - extended disk addressing unimplemented"); if (disk->read_only) nr_bytes_written = 0; else if (nr_bytes == 0) nr_bytes_written = 0; else if (fseek(disk->image, addr, SEEK_SET) < 0) nr_bytes_written = 0; else if (fwrite(source, nr_bytes, 1, disk->image) != 1) nr_bytes_written = 0; else nr_bytes_written = nr_bytes; DTRACE(disk, ("io-write - address 0x%lx, nr-bytes-written %d, requested %d\n", (unsigned long) addr, (int)nr_bytes_written, (int)nr_bytes)); return nr_bytes_written; }
static void make_write_ready(void *data) { device *me = (device*)data; hw_com_device *com = (hw_com_device*)device_data(me); com->output.ready = 1; update_com_interrupts(me, com); }
static device_instance * hw_pal_create_instance(device *me, const char *path, const char *args) { return device_create_instance_from(me, NULL, device_data(me), path, args, &hw_pal_instance_callbacks); }
static device_instance * hw_com_create_instance(device *me, const char *path, const char *args) { /* point an instance directly at the device */ return device_create_instance_from(me, NULL, device_data(me), path, args, &hw_com_instance_callbacks); }
static void hw_pal_attach_address(device *me, attach_type attach, int space, unsigned_word addr, unsigned nr_bytes, access_type access, device *client) { hw_pal_device *pal = (hw_pal_device*)device_data(me); pal->disk = client; }
int main(int argc, char *argv[]) { // setup command line arguments po::options_description options("options"); options.add_options() ("help", "show usage instructions") ("size", po::value<size_t>()->default_value(8192), "input size") ("trials", po::value<size_t>()->default_value(3), "number of trials to run") ("tune", "run tuning procedure") ; po::positional_options_description positional_options; positional_options.add("size", 1); // parse command line po::variables_map vm; po::store( po::command_line_parser(argc, argv) .options(options).positional(positional_options).run(), vm ); po::notify(vm); const size_t size = vm["size"].as<size_t>(); const size_t trials = vm["trials"].as<size_t>(); std::cout << "size: " << size << std::endl; // setup context and queue for the default device compute::device device = compute::system::default_device(); compute::context context(device); compute::command_queue queue(context, device); std::cout << "device: " << device.name() << std::endl; // create vector of random numbers on the host std::vector<int> host_data(size); std::generate(host_data.begin(), host_data.end(), rand_int); // create vector on the device and copy the data compute::vector<int> device_data( host_data.begin(), host_data.end(), queue ); // run tuning proceure (if requested) if(vm.count("tune")){ tune_accumulate(device_data, trials, queue); } // run benchmark double t = perf_accumulate(device_data, trials, queue); std::cout << "time: " << t / 1e6 << " ms" << std::endl; return 0; }
static unsigned hw_ide_io_write_buffer(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_ide_device *ide = (hw_ide_device *)device_data(me); int control_nr; int reg; ide_controller *controller; /* find the interface */ decode_address(me, &ide->decoder, space, addr, &control_nr, ®, is_write); controller = &ide->controller[control_nr]; /* process the access */ switch (reg) { case ide_data_reg: do_fifo_write(me, controller, source, nr_bytes); break; case ide_command_reg: do_command(me, controller, *(unsigned8*)source); break; case ide_control_reg: controller->reg[reg] = *(unsigned8*)source; /* possibly cancel interrupts */ if ((controller->reg[reg] & 0x02) == 0x02) clear_interrupt(me, controller); break; case ide_feature_reg: case ide_sector_count_reg: case ide_sector_number_reg: case ide_cylinder_reg0: case ide_cylinder_reg1: case ide_drive_head_reg: case ide_dma_command_reg: case ide_dma_status_reg: case ide_dma_prd_table_address_reg0: case ide_dma_prd_table_address_reg1: case ide_dma_prd_table_address_reg2: case ide_dma_prd_table_address_reg3: controller->reg[reg] = *(unsigned8*)source; break; default: device_error(me, "bus-error at 0x%lx", addr); break; } return nr_bytes; }
static unsigned hw_ide_io_read_buffer(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_ide_device *ide = (hw_ide_device *)device_data(me); int control_nr; int reg; ide_controller *controller; /* find the interface */ decode_address(me, &ide->decoder, space, addr, &control_nr, ®, is_read); controller = & ide->controller[control_nr]; /* process the transfer */ memset(dest, 0, nr_bytes); switch (reg) { case ide_data_reg: do_fifo_read(me, controller, dest, nr_bytes); break; case ide_status_reg: *(unsigned8*)dest = get_status(me, controller); clear_interrupt(me, controller); break; case ide_alternate_status_reg: *(unsigned8*)dest = get_status(me, controller); break; case ide_error_reg: case ide_sector_count_reg: case ide_sector_number_reg: case ide_cylinder_reg0: case ide_cylinder_reg1: case ide_drive_head_reg: case ide_control_reg: case ide_dma_command_reg: case ide_dma_status_reg: case ide_dma_prd_table_address_reg0: case ide_dma_prd_table_address_reg1: case ide_dma_prd_table_address_reg2: case ide_dma_prd_table_address_reg3: *(unsigned8*)dest = controller->reg[reg]; break; default: device_error(me, "bus-error at address 0x%lx", addr); break; } return nr_bytes; }
static void hw_nvram_init_address(device *me) { hw_nvram_device *nvram = (hw_nvram_device*)device_data(me); /* use the generic init code to attach this device to its parent bus */ generic_device_init_address(me); /* find the first non zero reg property and use that as the device size */ if (nvram->sizeof_memory == 0) { reg_property_spec reg; int reg_nr; for (reg_nr = 0; device_find_reg_array_property(me, "reg", reg_nr, ®); reg_nr++) { unsigned attach_size; if (device_size_to_attach_size(device_parent(me), ®.size, &attach_size, me)) { nvram->sizeof_memory = attach_size; break; } } if (nvram->sizeof_memory == 0) device_error(me, "reg property must contain a non-zero phys-addr:size tupple"); if (nvram->sizeof_memory < 8) device_error(me, "NVRAM must be at least 8 bytes in size"); } /* initialize the hw_nvram */ if (nvram->memory == NULL) { nvram->memory = zalloc(nvram->sizeof_memory); } else memset(nvram->memory, 0, nvram->sizeof_memory); if (device_find_property(me, "timezone") == NULL) nvram->timezone = 0; else nvram->timezone = device_find_integer_property(me, "timezone"); nvram->addr_year = nvram->sizeof_memory - 1; nvram->addr_month = nvram->sizeof_memory - 2; nvram->addr_date = nvram->sizeof_memory - 3; nvram->addr_day = nvram->sizeof_memory - 4; nvram->addr_hour = nvram->sizeof_memory - 5; nvram->addr_minutes = nvram->sizeof_memory - 6; nvram->addr_seconds = nvram->sizeof_memory - 7; nvram->addr_control = nvram->sizeof_memory - 8; }
static void hw_shm_init_data(device *me) { hw_shm_device *shm = (hw_shm_device*)device_data(me); const device_unit *d; reg_property_spec reg; int i; /* Obtain the Key Value */ if (device_find_property(me, "key") == NULL) error("shm_init_data() required key property is missing\n"); shm->key = (key_t) device_find_integer_property(me, "key"); DTRACE(shm, ("shm key (0x%08x)\n", shm->key) ); /* Figure out where this memory is in address space and how long it is */ if ( !device_find_reg_array_property(me, "reg", 0, ®) ) error("hw_shm_init_data() no address registered\n"); /* Determine the address and length being as paranoid as possible */ shm->physical_address = 0xffffffff; shm->sizeof_memory = 0xffffffff; for ( i=0 ; i<reg.address.nr_cells; i++ ) { if (reg.address.cells[0] == 0 && reg.size.cells[0] == 0) continue; if ( shm->physical_address != 0xffffffff ) device_error(me, "Only single celled address ranges supported\n"); shm->physical_address = reg.address.cells[i]; DTRACE(shm, ("shm physical_address=0x%x\n", shm->physical_address)); shm->sizeof_memory = reg.size.cells[i]; DTRACE(shm, ("shm length=0x%x\n", shm->sizeof_memory)); } if ( shm->physical_address == 0xffffffff ) device_error(me, "Address not specified\n" ); if ( shm->sizeof_memory == 0xffffffff ) device_error(me, "Length not specified\n" ); /* Now actually attach to or create the shared memory area */ shm->id = shmget(shm->key, shm->sizeof_memory, IPC_CREAT | 0660); if (shm->id == -1) error("hw_shm_init_data() shmget failed\n"); shm->shm_address = shmat(shm->id, (char *)0, SHM_RND); if (shm->shm_address == (void *)-1) error("hw_shm_init_data() shmat failed\n"); }
static unsigned hw_core_dma_read_buffer_callback(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes) { core *memory = (core*)device_data(me); return core_map_read_buffer(core_readable(memory), dest, addr, nr_bytes); }
static int hw_com_instance_write(device_instance *instance, const void *buf, unsigned_word len) { device *me = device_instance_device(instance); hw_com_device *com = device_data(me); if (com->output.file == NULL) return sim_io_write_stdout(buf, len); else { return fwrite(buf, 1, len, com->output.file); } }
static int hw_com_instance_read(device_instance *instance, void *buf, unsigned_word len) { device *me = device_instance_device(instance); hw_com_device *com = device_data(me); if (com->input.file == NULL) return sim_io_read_stdin(buf, len); else { return fread(buf, 1, len, com->input.file); } }
static device_instance * hw_eeprom_create_instance(device *me, const char *path, const char *args) { hw_eeprom_device *eeprom = device_data(me); hw_eeprom_instance *data = ZALLOC(hw_eeprom_instance); data->eeprom = eeprom; data->me = me; return device_create_instance_from(me, NULL, data, path, args, &hw_eeprom_instance_callbacks); }
static void hw_eeprom_init_data(device *me) { hw_eeprom_device *eeprom = (hw_eeprom_device*)device_data(me); /* have we any input or output files */ if (device_find_property(me, "input-file") != NULL) eeprom->input_file_name = device_find_string_property(me, "input-file"); if (device_find_property(me, "output-file") != NULL) eeprom->input_file_name = device_find_string_property(me, "output-file"); /* figure out the sectors in the eeprom */ if (eeprom->sectors == NULL) { eeprom->nr_sectors = device_find_integer_property(me, "nr-sectors"); eeprom->sizeof_sector = device_find_integer_property(me, "sector-size"); eeprom->sectors = zalloc(eeprom->nr_sectors); } else memset(eeprom->sectors, 0, eeprom->nr_sectors); /* initialize the eeprom */ if (eeprom->memory == NULL) { eeprom->sizeof_memory = eeprom->sizeof_sector * eeprom->nr_sectors; eeprom->memory = zalloc(eeprom->sizeof_memory); } else memset(eeprom->memory, 0, eeprom->sizeof_memory); if (eeprom->input_file_name != NULL) { int i; FILE *input_file = fopen(eeprom->input_file_name, "r"); if (input_file == NULL) { perror("eeprom"); device_error(me, "Failed to open input file %s\n", eeprom->input_file_name); } for (i = 0; i < eeprom->sizeof_memory; i++) { if (fread(&eeprom->memory[i], 1, 1, input_file) != 1) break; } fclose(input_file); } /* timing */ eeprom->byte_write_delay = device_find_integer_property(me, "byte-write-delay"); eeprom->sector_start_delay = device_find_integer_property(me, "sector-start-delay"); eeprom->erase_delay = device_find_integer_property(me, "erase-delay"); /* misc */ eeprom->manufacture_code = device_find_integer_property(me, "manufacture-code"); eeprom->device_code = device_find_integer_property(me, "device-code"); }
static void hw_sem_init_data(device *me) { hw_sem_device *sem = (hw_sem_device*)device_data(me); const device_unit *d; int status; union semun help; /* initialize the properties of the sem */ if (device_find_property(me, "key") == NULL) error("sem_init_data() required key property is missing\n"); if (device_find_property(me, "value") == NULL) error("sem_init_data() required value property is missing\n"); sem->key = (key_t) device_find_integer_property(me, "key"); DTRACE(sem, ("semaphore key (%d)\n", sem->key) ); sem->initial = (int) device_find_integer_property(me, "value"); DTRACE(sem, ("semaphore initial value (%d)\n", sem->initial) ); d = device_unit_address(me); sem->physical_address = d->cells[ d->nr_cells-1 ]; DTRACE(sem, ("semaphore physical_address=0x%x\n", sem->physical_address)); /* Now to initialize the semaphore */ if ( sem->initial != -1 ) { sem->id = semget(sem->key, 1, IPC_CREAT | 0660); if (sem->id == -1) error("hw_sem_init_data() semget failed\n"); help.val = sem->initial; status = semctl( sem->id, 0, SETVAL, help ); if (status == -1) error("hw_sem_init_data() semctl -- set value failed\n"); } else { sem->id = semget(sem->key, 1, 0660); if (sem->id == -1) error("hw_sem_init_data() semget failed\n"); } sem->count = semctl( sem->id, 0, GETVAL, help ); if (sem->count == -1) error("hw_sem_init_data() semctl -- get value failed\n"); DTRACE(sem, ("semaphore OS value (%d)\n", sem->count) ); }
static void hw_com_device_init_data(device *me) { hw_com_device *com = (hw_com_device*)device_data(me); /* clean up */ if (com->output.file != NULL) fclose(com->output.file); if (com->input.file != NULL) fclose(com->input.file); memset(com, 0, sizeof(hw_com_device)); /* the fifo speed */ com->output.delay = (device_find_property(me, "output-delay") != NULL ? device_find_integer_property(me, "output-delay") : 0); com->input.delay = (device_find_property(me, "input-delay") != NULL ? device_find_integer_property(me, "input-delay") : 0); /* the data source/sink */ if (device_find_property(me, "input-file") != NULL) { const char *input_file = device_find_string_property(me, "input-file"); com->input.file = fopen(input_file, "r"); if (com->input.file == NULL) device_error(me, "Problem opening input file %s\n", input_file); if (device_find_property(me, "input-buffering") != NULL) { const char *buffering = device_find_string_property(me, "input-buffering"); if (strcmp(buffering, "unbuffered") == 0) setbuf(com->input.file, NULL); } } if (device_find_property(me, "output-file") != NULL) { const char *output_file = device_find_string_property(me, "output-file"); com->output.file = fopen(output_file, "w"); if (com->output.file == NULL) device_error(me, "Problem opening output file %s\n", output_file); if (device_find_property(me, "output-buffering") != NULL) { const char *buffering = device_find_string_property(me, "output-buffering"); if (strcmp(buffering, "unbuffered") == 0) setbuf(com->output.file, NULL); } } /* ready from the start */ com->input.ready = 1; com->modem.carrier = 1; com->output.ready = 1; }
static unsigned hw_com_io_write_buffer_callback(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_com_device *com = device_data(me); int i; for (i = 0; i < nr_bytes; i++) { write_com(me, com, addr + i, ((char*)source)[i]); } return nr_bytes; }
static unsigned hw_com_io_read_buffer_callback(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_com_device *com = device_data(me); int i; for (i = 0; i < nr_bytes; i++) { read_com(me, com, addr + i, &((char*)dest)[i]); } return nr_bytes; }
static void hw_shm_attach_address_callback(device *me, attach_type attach, int space, unsigned_word addr, unsigned nr_bytes, access_type access, device *client) /*callback/default*/ { hw_shm_device *shm = (hw_shm_device*)device_data(me); if (space != 0) error("shm_attach_address_callback() invalid address space\n"); if (nr_bytes == 0) error("shm_attach_address_callback() invalid size\n"); }
static unsigned hw_core_dma_write_buffer_callback(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, int violate_read_only_section) { core *memory = (core*)device_data(me); core_map *map = (violate_read_only_section ? core_readable(memory) : core_writeable(memory)); return core_map_write_buffer(map, source, addr, nr_bytes); }
static unsigned hw_pal_io_read_buffer_callback(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_pal_device *hw_pal = (hw_pal_device*)device_data(me); unsigned_1 val; switch (addr & hw_pal_address_mask) { case hw_pal_cpu_nr_register: val = cpu_nr(processor); DTRACE(pal, ("read - cpu-nr %d\n", val)); break; case hw_pal_nr_cpu_register: val = tree_find_integer_property(me, "/openprom/options/smp"); DTRACE(pal, ("read - nr-cpu %d\n", val)); break; case hw_pal_read_fifo: val = hw_pal->input.buffer; DTRACE(pal, ("read - input-fifo %d\n", val)); break; case hw_pal_read_status: scan_hw_pal(hw_pal); val = hw_pal->input.status; DTRACE(pal, ("read - input-status %d\n", val)); break; case hw_pal_write_fifo: val = hw_pal->output.buffer; DTRACE(pal, ("read - output-fifo %d\n", val)); break; case hw_pal_write_status: val = hw_pal->output.status; DTRACE(pal, ("read - output-status %d\n", val)); break; default: val = 0; DTRACE(pal, ("read - ???\n")); } memset(dest, 0, nr_bytes); *(unsigned_1*)dest = val; return nr_bytes; }
static unsigned hw_eeprom_io_read_buffer(device *me, void *dest, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_eeprom_device *eeprom = (hw_eeprom_device*)device_data(me); int i; for (i = 0; i < nr_bytes; i++) { unsigned_word address = (addr + i) % eeprom->sizeof_memory; unsigned8 byte = read_byte(me, eeprom, address); ((unsigned8*)dest)[i] = byte; } return nr_bytes; }
static unsigned hw_eeprom_io_write_buffer(device *me, const void *source, int space, unsigned_word addr, unsigned nr_bytes, cpu *processor, unsigned_word cia) { hw_eeprom_device *eeprom = (hw_eeprom_device*)device_data(me); int i; for (i = 0; i < nr_bytes; i++) { unsigned_word address = (addr + i) % eeprom->sizeof_memory; unsigned8 byte = ((unsigned8*)source)[i]; write_byte(me, eeprom, address, byte); } return nr_bytes; }