src/mess/devices/harddriv.c
| r2155 | r2156 | |
| 94 | 94 | * |
| 95 | 95 | *************************************/ |
| 96 | 96 | |
| 97 | | int device_init_mess_hd(mess_image *image) |
| 97 | DEVICE_INIT( mess_hd ) |
| 98 | 98 | { |
| 99 | 99 | struct mess_hd *hd; |
| 100 | 100 | |
| r2155 | r2156 | |
| 172 | 172 | |
| 173 | 173 | |
| 174 | 174 | |
| 175 | | int device_load_mess_hd(mess_image *image) |
| 175 | DEVICE_LOAD( mess_hd ) |
| 176 | 176 | { |
| 177 | 177 | return internal_load_mess_hd(image, NULL); |
| 178 | 178 | } |
| 179 | 179 | |
| 180 | 180 | |
| 181 | 181 | #ifdef UNUSED_FUNCTION |
| 182 | | static int device_create_mess_hd(mess_image *image, int create_format, option_resolution *create_args) |
| 182 | static DEVICE_CREATE( mess_hd ) |
| 183 | 183 | { |
| 184 | 184 | int err; |
| 185 | 185 | char metadata[256]; |
| r2155 | r2156 | |
| 216 | 216 | * |
| 217 | 217 | *************************************/ |
| 218 | 218 | |
| 219 | | void device_unload_mess_hd(mess_image *image) |
| 219 | DEVICE_UNLOAD( mess_hd ) |
| 220 | 220 | { |
| 221 | 221 | struct mess_hd *hd = get_drive(image); |
| 222 | 222 | assert(hd->hard_disk_handle); |
src/mess/devices/cassette.c
| r2155 | r2156 | |
| 229 | 229 | cassette device init/load/unload/specify |
| 230 | 230 | *********************************************************************/ |
| 231 | 231 | |
| 232 | | static int device_init_cassette(mess_image *image) |
| 232 | static DEVICE_INIT( cassette ) |
| 233 | 233 | { |
| 234 | 234 | const struct IODevice *dev; |
| 235 | 235 | |
| r2155 | r2156 | |
| 245 | 245 | |
| 246 | 246 | |
| 247 | 247 | |
| 248 | | static int device_load_cassette(mess_image *image) |
| 248 | static DEVICE_LOAD( cassette ) |
| 249 | 249 | { |
| 250 | 250 | casserr_t err; |
| 251 | 251 | int cassette_flags; |
| r2155 | r2156 | |
| 305 | 305 | |
| 306 | 306 | |
| 307 | 307 | |
| 308 | | static void device_unload_cassette(mess_image *image) |
| 308 | static DEVICE_UNLOAD( cassette ) |
| 309 | 309 | { |
| 310 | 310 | struct mess_cassetteimg *tag; |
| 311 | 311 | |
src/mess/devices/cartslot.c
| r2155 | r2156 | |
| 141 | 141 | |
| 142 | 142 | |
| 143 | 143 | |
| 144 | | static int device_init_cartslot_specified(mess_image *image) |
| 144 | static DEVICE_INIT( cartslot_specified ) |
| 145 | 145 | { |
| 146 | 146 | process_cartridge(image, NULL); |
| 147 | 147 | return 0; |
| 148 | 148 | } |
| 149 | 149 | |
| 150 | | static int device_load_cartslot_specified(mess_image *image) |
| 150 | static DEVICE_LOAD( cartslot_specified ) |
| 151 | 151 | { |
| 152 | 152 | return process_cartridge(image, image); |
| 153 | 153 | } |
| 154 | 154 | |
| 155 | | static void device_unload_cartslot_specified(mess_image *image) |
| 155 | static DEVICE_UNLOAD( cartslot_specified ) |
| 156 | 156 | { |
| 157 | 157 | process_cartridge(image, NULL); |
| 158 | 158 | } |
src/mess/devices/chd_cd.c
| r2155 | r2156 | |
| 96 | 96 | * |
| 97 | 97 | *************************************/ |
| 98 | 98 | |
| 99 | | static int device_init_mess_cd(mess_image *image) |
| 99 | static DEVICE_INIT( mess_cd ) |
| 100 | 100 | { |
| 101 | 101 | struct mess_cd *cd; |
| 102 | 102 | |
| r2155 | r2156 | |
| 114 | 114 | /************************************* |
| 115 | 115 | * |
| 116 | 116 | * device_load_mess_cd() |
| 117 | | * device_create_mess_cd() |
| 118 | 117 | * |
| 119 | | * Device load and create |
| 118 | * Device load |
| 120 | 119 | * |
| 121 | 120 | *************************************/ |
| 122 | 121 | |
| r2155 | r2156 | |
| 152 | 151 | |
| 153 | 152 | |
| 154 | 153 | |
| 155 | | static int device_load_mess_cd(mess_image *image) |
| 154 | static DEVICE_LOAD( mess_cd ) |
| 156 | 155 | { |
| 157 | 156 | return internal_load_mess_cd(image, NULL); |
| 158 | 157 | } |
| r2155 | r2156 | |
| 167 | 166 | * |
| 168 | 167 | *************************************/ |
| 169 | 168 | |
| 170 | | static void device_unload_mess_cd(mess_image *image) |
| 169 | static DEVICE_UNLOAD( mess_cd ) |
| 171 | 170 | { |
| 172 | 171 | struct mess_cd *cd = get_drive(image); |
| 173 | 172 | assert(cd->cdrom_handle); |
src/mess/devices/mflopimg.c
| r2155 | r2156 | |
| 257 | 257 | /* ----------------------------------------------------------------------- */ |
| 258 | 258 | |
| 259 | 259 | |
| 260 | | static int device_init_floppy(mess_image *image) |
| 260 | static DEVICE_INIT( floppy ) |
| 261 | 261 | { |
| 262 | 262 | if (!image_alloctag(image, FLOPPY_TAG, sizeof(mess_flopimg))) |
| 263 | 263 | return INIT_FAIL; |
| r2155 | r2156 | |
| 332 | 332 | |
| 333 | 333 | |
| 334 | 334 | |
| 335 | | static int device_load_floppy(mess_image *image) |
| 335 | static DEVICE_LOAD( floppy ) |
| 336 | 336 | { |
| 337 | 337 | return internal_floppy_device_load(image, -1, NULL); |
| 338 | 338 | } |
| 339 | 339 | |
| 340 | 340 | |
| 341 | 341 | |
| 342 | | static int device_create_floppy(mess_image *image, int create_format, option_resolution *create_args) |
| 342 | static DEVICE_CREATE( floppy ) |
| 343 | 343 | { |
| 344 | 344 | return internal_floppy_device_load(image, create_format, create_args); |
| 345 | 345 | } |
| 346 | 346 | |
| 347 | 347 | |
| 348 | 348 | |
| 349 | | static void device_unload_floppy(mess_image *image) |
| 349 | static DEVICE_UNLOAD( floppy ) |
| 350 | 350 | { |
| 351 | 351 | mess_flopimg *flopimg; |
| 352 | 352 | flopimg = image_lookuptag(image, FLOPPY_TAG); |
src/mess/devices/dsk.c
| r2155 | r2156 | |
| 71 | 71 | |
| 72 | 72 | |
| 73 | 73 | |
| 74 | | static int device_init_dsk_floppy(mess_image *image) |
| 74 | static DEVICE_INIT( dsk_floppy ) |
| 75 | 75 | { |
| 76 | 76 | return floppy_drive_init(image, NULL); |
| 77 | 77 | } |
| r2155 | r2156 | |
| 79 | 79 | |
| 80 | 80 | |
| 81 | 81 | /* load floppy */ |
| 82 | | static int device_load_dsk_floppy(mess_image *image) |
| 82 | static DEVICE_LOAD( dsk_floppy ) |
| 83 | 83 | { |
| 84 | 84 | int id = image_index_in_device(image); |
| 85 | 85 | dsk_drive *thedrive = &drives[id]; |
| r2155 | r2156 | |
| 122 | 122 | } |
| 123 | 123 | |
| 124 | 124 | |
| 125 | | static void device_unload_dsk_floppy(mess_image *image) |
| 125 | static DEVICE_UNLOAD( dsk_floppy ) |
| 126 | 126 | { |
| 127 | 127 | int id = image_index_in_device(image); |
| 128 | 128 | dsk_drive *thedrive = &drives[id]; |
src/mess/devices/appldriv.c
| r2155 | r2156 | |
| 276 | 276 | |
| 277 | 277 | /* ----------------------------------------------------------------------- */ |
| 278 | 278 | |
| 279 | | static int device_init_apple525_floppy(mess_image *image) |
| 279 | static DEVICE_INIT( apple525_floppy ) |
| 280 | 280 | { |
| 281 | 281 | device_init_handler parent_init; |
| 282 | 282 | |
| r2155 | r2156 | |
| 289 | 289 | |
| 290 | 290 | |
| 291 | 291 | |
| 292 | | static int device_load_apple525_floppy(mess_image *image) |
| 292 | static DEVICE_LOAD( apple525_floppy ) |
| 293 | 293 | { |
| 294 | 294 | int result; |
| 295 | 295 | device_load_handler parent_load; |
| r2155 | r2156 | |
| 304 | 304 | |
| 305 | 305 | |
| 306 | 306 | |
| 307 | | static void device_unload_apple525_floppy(mess_image *image) |
| 307 | static DEVICE_UNLOAD( apple525_floppy ) |
| 308 | 308 | { |
| 309 | 309 | device_unload_handler parent_unload; |
| 310 | 310 | |
src/mess/devices/basicdsk.c
| r2155 | r2156 | |
| 84 | 84 | return &basicdsk_drives[drive]; |
| 85 | 85 | } |
| 86 | 86 | |
| 87 | | int device_init_basicdsk_floppy(mess_image *image) |
| 87 | DEVICE_INIT( basicdsk_floppy ) |
| 88 | 88 | { |
| 89 | 89 | return floppy_drive_init(image, &basicdsk_floppy_interface); |
| 90 | 90 | } |
| 91 | 91 | |
| 92 | 92 | /* attempt to insert a disk into the drive specified with id */ |
| 93 | | int device_load_basicdsk_floppy(mess_image *image) |
| 93 | DEVICE_LOAD( basicdsk_floppy ) |
| 94 | 94 | { |
| 95 | 95 | basicdsk *w = get_basicdsk(image); |
| 96 | 96 | |
| r2155 | r2156 | |
| 109 | 109 | return INIT_PASS; |
| 110 | 110 | } |
| 111 | 111 | |
| 112 | | void device_unload_basicdsk_floppy(mess_image *image) |
| 112 | DEVICE_UNLOAD( basicdsk_floppy ) |
| 113 | 113 | { |
| 114 | 114 | basicdsk *w = get_basicdsk(image); |
| 115 | 115 | w->image_file = NULL; |
src/mess/machine/cbmserb.c
| r2155 | r2156 | |
| 103 | 103 | |
| 104 | 104 | |
| 105 | 105 | |
| 106 | | static int device_init_cbm_drive(mess_image *image) |
| 106 | static DEVICE_INIT( cbm_drive ) |
| 107 | 107 | { |
| 108 | 108 | int id = image_index_in_device(image); |
| 109 | 109 | if (id == 0) |
| r2155 | r2156 | |
| 111 | 111 | return INIT_PASS; |
| 112 | 112 | } |
| 113 | 113 | |
| 114 | | static void device_exit_cbm_drive(mess_image *image) |
| 114 | static DEVICE_EXIT( cbm_drive ) |
| 115 | 115 | { |
| 116 | 116 | int id = image_index_in_device(image); |
| 117 | 117 | if (id == 0) |
| r2155 | r2156 | |
| 121 | 121 | |
| 122 | 122 | |
| 123 | 123 | /* open an d64 image */ |
| 124 | | static int device_load_cbm_drive(mess_image *image) |
| 124 | static DEVICE_LOAD( cbm_drive ) |
| 125 | 125 | { |
| 126 | 126 | int id = image_index_in_device(image); |
| 127 | 127 | |
src/mess/drivers/apexc.c
| r2155 | r2156 | |
| 42 | 42 | /* |
| 43 | 43 | Open cylinder image and read RAM |
| 44 | 44 | */ |
| 45 | | static int device_load_apexc_cylinder(mess_image *image) |
| 45 | static DEVICE_LOAD( apexc_cylinder ) |
| 46 | 46 | { |
| 47 | 47 | /* open file */ |
| 48 | 48 | apexc_cylinder.fd = image; |
| r2155 | r2156 | |
| 72 | 72 | /* |
| 73 | 73 | Save RAM to cylinder image and close it |
| 74 | 74 | */ |
| 75 | | static void device_unload_apexc_cylinder(mess_image *image) |
| 75 | static DEVICE_UNLOAD( apexc_cylinder ) |
| 76 | 76 | { |
| 77 | 77 | if (apexc_cylinder.fd && apexc_cylinder.writable) |
| 78 | 78 | { /* save RAM contents */ |
| r2155 | r2156 | |
| 169 | 169 | |
| 170 | 170 | |
| 171 | 171 | |
| 172 | | static int device_init_apexc_tape(mess_image *image) |
| 172 | static DEVICE_INIT( apexc_tape ) |
| 173 | 173 | { |
| 174 | 174 | return INIT_PASS; |
| 175 | 175 | } |
| r2155 | r2156 | |
| 179 | 179 | /* |
| 180 | 180 | Open a tape image |
| 181 | 181 | */ |
| 182 | | static int device_load_apexc_tape(mess_image *image) |
| 182 | static DEVICE_LOAD( apexc_tape ) |
| 183 | 183 | { |
| 184 | 184 | int id = image_index_in_device(image); |
| 185 | 185 | tape *t = &apexc_tapes[id]; |
src/mess/drivers/tutor.c
| r2155 | r2156 | |
| 163 | 163 | return readinputport(offset); |
| 164 | 164 | } |
| 165 | 165 | |
| 166 | | static int device_load_tutor_cart(mess_image *image) |
| 166 | static DEVICE_LOAD( tutor_cart ) |
| 167 | 167 | { |
| 168 | 168 | image_fread(image, memory_region(REGION_CPU1) + cartridge_base, 0x6000); |
| 169 | 169 | return INIT_PASS; |
| 170 | 170 | } |
| 171 | 171 | |
| 172 | | static void device_unload_tutor_cart(mess_image *image) |
| 172 | static DEVICE_UNLOAD( tutor_cart ) |
| 173 | 173 | { |
| 174 | 174 | memset(memory_region(REGION_CPU1) + cartridge_base, 0, 0x6000); |
| 175 | 175 | } |