src/mess/devices/flopdrv.c
| r5706 | r5707 | |
| 4 | 4 | |
| 5 | 5 | The functions are emulated and a disk image is used. |
| 6 | 6 | |
| 7 | | Disk image operation: |
| 8 | | - set disk image functions using floppy_drive_set_disk_image_interface |
| 9 | | |
| 10 | 7 | Real disk operation: |
| 11 | 8 | - set unit id |
| 12 | 9 | |
| r5706 | r5707 | |
| 18 | 15 | #include "driver.h" |
| 19 | 16 | #include "flopdrv.h" |
| 20 | 17 | |
| 21 | | |
| 22 | 18 | #define VERBOSE 0 |
| 23 | 19 | #define LOG(x) do { if (VERBOSE) logerror x; } while (0) |
| 20 | |
| 21 | /*************************************************************************** |
| 22 | CONSTANTS |
| 23 | ***************************************************************************/ |
| 24 | |
| 24 | 25 | #define FLOPDRVTAG "flopdrv" |
| 26 | #define LOG_FLOPPY 0 |
| 25 | 27 | |
| 26 | | static struct floppy_drive *get_drive(const device_config *img) |
| 28 | /*************************************************************************** |
| 29 | TYPE DEFINITIONS |
| 30 | ***************************************************************************/ |
| 31 | |
| 32 | typedef struct _floppy_drive floppy_drive; |
| 33 | struct _floppy_drive |
| 27 | 34 | { |
| 35 | /* flags */ |
| 36 | int flags; |
| 37 | /* maximum track allowed */ |
| 38 | int max_track; |
| 39 | /* num sides */ |
| 40 | int num_sides; |
| 41 | /* current track - this may or may not relate to the present cylinder number |
| 42 | stored by the fdc */ |
| 43 | int current_track; |
| 44 | |
| 45 | /* index pulse timer */ |
| 46 | void *index_timer; |
| 47 | /* index pulse callback */ |
| 48 | void (*index_pulse_callback)(const device_config *controller,const device_config *image, int state); |
| 49 | /* rotation per minute => gives index pulse frequency */ |
| 50 | float rpm; |
| 51 | /* current index pulse value */ |
| 52 | int index; |
| 53 | |
| 54 | void (*ready_state_change_callback)(const device_config *controller,const device_config *img, int state); |
| 55 | |
| 56 | int id_index; |
| 57 | |
| 58 | const device_config *controller; |
| 59 | |
| 60 | floppy_image *floppy; |
| 61 | int track; |
| 62 | void (*load_proc)(const device_config *image); |
| 63 | void (*unload_proc)(const device_config *image); |
| 64 | int (*tracktranslate_proc)(const device_config *image, floppy_image *floppy, int physical_track); |
| 65 | }; |
| 66 | |
| 67 | |
| 68 | typedef struct _floppy_error_map floppy_error_map; |
| 69 | struct _floppy_error_map |
| 70 | { |
| 71 | floperr_t ferr; |
| 72 | image_error_t ierr; |
| 73 | const char *message; |
| 74 | }; |
| 75 | |
| 76 | |
| 77 | |
| 78 | /*************************************************************************** |
| 79 | GLOBAL VARIABLES |
| 80 | ***************************************************************************/ |
| 81 | |
| 82 | static const floppy_error_map errmap[] = |
| 83 | { |
| 84 | { FLOPPY_ERROR_SUCCESS, IMAGE_ERROR_SUCCESS }, |
| 85 | { FLOPPY_ERROR_INTERNAL, IMAGE_ERROR_INTERNAL }, |
| 86 | { FLOPPY_ERROR_UNSUPPORTED, IMAGE_ERROR_UNSUPPORTED }, |
| 87 | { FLOPPY_ERROR_OUTOFMEMORY, IMAGE_ERROR_OUTOFMEMORY }, |
| 88 | { FLOPPY_ERROR_INVALIDIMAGE, IMAGE_ERROR_INVALIDIMAGE } |
| 89 | }; |
| 90 | |
| 91 | /*************************************************************************** |
| 92 | IMPLEMENTATION |
| 93 | ***************************************************************************/ |
| 94 | |
| 95 | static floppy_drive *get_drive(const device_config *img) |
| 96 | { |
| 28 | 97 | return image_lookuptag(img, FLOPDRVTAG); |
| 29 | 98 | } |
| 30 | 99 | |
| 100 | floppy_image *flopimg_get_image(const device_config *image) |
| 101 | { |
| 102 | return get_drive(image)->floppy; |
| 103 | } |
| 104 | |
| 105 | |
| 106 | |
| 107 | static void flopimg_seek_callback(const device_config *image, int physical_track) |
| 108 | { |
| 109 | floppy_drive *flopimg; |
| 110 | |
| 111 | flopimg = get_drive(image); |
| 112 | if (!flopimg || !flopimg->floppy) |
| 113 | return; |
| 114 | |
| 115 | /* translate the track number if necessary */ |
| 116 | if (flopimg->tracktranslate_proc) |
| 117 | physical_track = flopimg->tracktranslate_proc(image, flopimg->floppy, physical_track); |
| 118 | |
| 119 | flopimg->track = physical_track; |
| 120 | } |
| 121 | |
| 122 | |
| 123 | |
| 124 | static int flopimg_get_sectors_per_track(const device_config *image, int side) |
| 125 | { |
| 126 | floppy_drive *flopimg; |
| 127 | floperr_t err; |
| 128 | int sector_count; |
| 129 | |
| 130 | flopimg = get_drive(image); |
| 131 | if (!flopimg || !flopimg->floppy) |
| 132 | return 0; |
| 133 | |
| 134 | err = floppy_get_sector_count(flopimg->floppy, side, flopimg->track, §or_count); |
| 135 | if (err) |
| 136 | return 0; |
| 137 | return sector_count; |
| 138 | } |
| 139 | |
| 140 | |
| 141 | |
| 142 | static void flopimg_get_id_callback(const device_config *image, chrn_id *id, int id_index, int side) |
| 143 | { |
| 144 | floppy_drive *flopimg; |
| 145 | int cylinder, sector, N; |
| 146 | unsigned long flags; |
| 147 | UINT32 sector_length; |
| 148 | |
| 149 | flopimg = get_drive(image); |
| 150 | if (!flopimg || !flopimg->floppy) |
| 151 | return; |
| 152 | |
| 153 | floppy_get_indexed_sector_info(flopimg->floppy, side, flopimg->track, id_index, &cylinder, &side, §or, §or_length, &flags); |
| 154 | |
| 155 | N = compute_log2(sector_length); |
| 156 | |
| 157 | id->C = cylinder; |
| 158 | id->H = side; |
| 159 | id->R = sector; |
| 160 | id->data_id = id_index; |
| 161 | id->flags = flags; |
| 162 | id->N = ((N >= 7) && (N <= 10)) ? N - 7 : 0; |
| 163 | } |
| 164 | |
| 165 | |
| 166 | |
| 167 | static void log_readwrite(const char *name, int head, int track, int sector, const char *buf, int length) |
| 168 | { |
| 169 | char membuf[1024]; |
| 170 | int i; |
| 171 | for (i = 0; i < length; i++) |
| 172 | sprintf(membuf + i*2, "%02x", (int) (UINT8) buf[i]); |
| 173 | logerror("%s: head=%i track=%i sector=%i buffer='%s'\n", name, head, track, sector, membuf); |
| 174 | } |
| 175 | |
| 176 | /* ----------------------------------------------------------------------- */ |
| 177 | |
| 178 | static int image_fseek_thunk(void *file, INT64 offset, int whence) |
| 179 | { |
| 180 | return image_fseek((const device_config *) file, offset, whence); |
| 181 | } |
| 182 | |
| 183 | static size_t image_fread_thunk(void *file, void *buffer, size_t length) |
| 184 | { |
| 185 | return image_fread((const device_config *) file, buffer, length); |
| 186 | } |
| 187 | |
| 188 | static size_t image_fwrite_thunk(void *file, const void *buffer, size_t length) |
| 189 | { |
| 190 | return image_fwrite((const device_config *) file, buffer, length); |
| 191 | } |
| 192 | |
| 193 | static UINT64 image_fsize_thunk(void *file) |
| 194 | { |
| 195 | return image_length((const device_config *) file); |
| 196 | } |
| 197 | |
| 198 | /* ----------------------------------------------------------------------- */ |
| 199 | |
| 200 | const struct io_procs mess_ioprocs = |
| 201 | { |
| 202 | NULL, |
| 203 | image_fseek_thunk, |
| 204 | image_fread_thunk, |
| 205 | image_fwrite_thunk, |
| 206 | image_fsize_thunk |
| 207 | }; |
| 208 | |
| 209 | /************************************* |
| 210 | * |
| 211 | * Hacks for specific systems |
| 212 | * |
| 213 | *************************************/ |
| 214 | |
| 215 | void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image)) |
| 216 | { |
| 217 | floppy_drive *flopimg = get_drive(image); |
| 218 | flopimg->load_proc = proc; |
| 219 | } |
| 220 | |
| 221 | void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image)) |
| 222 | { |
| 223 | floppy_drive *flopimg = get_drive(image); |
| 224 | flopimg->unload_proc = proc; |
| 225 | } |
| 226 | |
| 227 | |
| 228 | |
| 229 | void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track)) |
| 230 | { |
| 231 | floppy_drive *flopimg = get_drive(image); |
| 232 | flopimg->tracktranslate_proc = proc; |
| 233 | } |
| 234 | |
| 31 | 235 | static TIMER_CALLBACK(floppy_drive_index_callback); |
| 32 | 236 | |
| 33 | 237 | /* this is called on device init */ |
| 34 | | void floppy_drive_init(const device_config *img, const floppy_interface *iface) |
| 238 | void floppy_drive_init(const device_config *img) |
| 35 | 239 | { |
| 36 | | struct floppy_drive *pDrive; |
| 240 | floppy_drive *pDrive; |
| 37 | 241 | |
| 38 | 242 | assert(image_slotexists(img)); |
| 39 | 243 | |
| 40 | | pDrive = image_alloctag(img, FLOPDRVTAG, sizeof(struct floppy_drive)); |
| 244 | pDrive = image_alloctag(img, FLOPDRVTAG, sizeof(floppy_drive)); |
| 41 | 245 | |
| 42 | 246 | /* initialise flags */ |
| 43 | 247 | pDrive->flags = 0; |
| r5706 | r5707 | |
| 58 | 262 | pDrive->rpm = 300; |
| 59 | 263 | |
| 60 | 264 | pDrive->controller = NULL; |
| 61 | | |
| 62 | | floppy_drive_set_disk_image_interface(img, iface); |
| 63 | 265 | } |
| 64 | 266 | |
| 65 | 267 | |
| r5706 | r5707 | |
| 67 | 269 | /* index pulses at rpm/60 Hz, and stays high 1/20th of time */ |
| 68 | 270 | static void floppy_drive_index_func(const device_config *img) |
| 69 | 271 | { |
| 70 | | struct floppy_drive *pDrive = get_drive(img); |
| 272 | floppy_drive *pDrive = get_drive(img); |
| 71 | 273 | |
| 72 | 274 | double ms = 1000. / (pDrive->rpm / 60.); |
| 73 | 275 | |
| r5706 | r5707 | |
| 99 | 301 | /* set the callback for the index pulse */ |
| 100 | 302 | void floppy_drive_set_index_pulse_callback(const device_config *img, void (*callback)(const device_config *controller,const device_config *image, int state)) |
| 101 | 303 | { |
| 102 | | struct floppy_drive *pDrive = get_drive(img); |
| 304 | floppy_drive *pDrive = get_drive(img); |
| 103 | 305 | pDrive->index_pulse_callback = callback; |
| 104 | 306 | } |
| 105 | 307 | |
| 106 | 308 | |
| 107 | 309 | void floppy_drive_set_ready_state_change_callback(const device_config *img, void (*callback)(const device_config *controller,const device_config *img, int state)) |
| 108 | 310 | { |
| 109 | | struct floppy_drive *pDrive = get_drive(img); |
| 311 | floppy_drive *pDrive = get_drive(img); |
| 110 | 312 | pDrive->ready_state_change_callback = callback; |
| 111 | 313 | } |
| 112 | 314 | |
| r5706 | r5707 | |
| 136 | 338 | return floppy_drive_get_flag_state(img,0x0ff); |
| 137 | 339 | } |
| 138 | 340 | |
| 139 | | /* set interface for image interface */ |
| 140 | | void floppy_drive_set_disk_image_interface(const device_config *img, const floppy_interface *iface) |
| 141 | | { |
| 142 | | struct floppy_drive *pDrive = get_drive(img); |
| 143 | | if (iface) |
| 144 | | memcpy(&pDrive->interface_, iface, sizeof(floppy_interface)); |
| 145 | | else |
| 146 | | memset(&pDrive->interface_, 0, sizeof(floppy_interface)); |
| 147 | | } |
| 148 | 341 | |
| 149 | 342 | /* set flag state */ |
| 150 | 343 | void floppy_drive_set_flag_state(const device_config *img, int flag, int state) |
| 151 | 344 | { |
| 152 | | struct floppy_drive *drv = get_drive(img); |
| 345 | floppy_drive *drv = get_drive(img); |
| 153 | 346 | int prev_state; |
| 154 | 347 | int new_state; |
| 155 | 348 | |
| r5706 | r5707 | |
| 208 | 401 | /* if timer already setup remove it */ |
| 209 | 402 | if (image_slotexists(img)) |
| 210 | 403 | { |
| 211 | | struct floppy_drive *pDrive = get_drive(img); |
| 404 | floppy_drive *pDrive = get_drive(img); |
| 212 | 405 | |
| 213 | 406 | pDrive->index = 0; |
| 214 | 407 | if (new_motor_state) |
| r5706 | r5707 | |
| 271 | 464 | /* get flag state */ |
| 272 | 465 | int floppy_drive_get_flag_state(const device_config *img, int flag) |
| 273 | 466 | { |
| 274 | | struct floppy_drive *drv = get_drive(img); |
| 467 | floppy_drive *drv = get_drive(img); |
| 275 | 468 | int drive_flags; |
| 276 | 469 | int flags; |
| 277 | 470 | |
| r5706 | r5707 | |
| 333 | 526 | |
| 334 | 527 | void floppy_drive_set_geometry_absolute(const device_config *img, int tracks, int sides) |
| 335 | 528 | { |
| 336 | | struct floppy_drive *pDrive = get_drive(img); |
| 529 | floppy_drive *pDrive = get_drive(img); |
| 337 | 530 | pDrive->max_track = tracks; |
| 338 | 531 | pDrive->num_sides = sides; |
| 339 | 532 | } |
| 340 | 533 | |
| 341 | 534 | void floppy_drive_seek(const device_config *img, signed int signed_tracks) |
| 342 | 535 | { |
| 343 | | struct floppy_drive *pDrive; |
| 536 | floppy_drive *pDrive; |
| 344 | 537 | |
| 345 | 538 | pDrive = get_drive(img); |
| 346 | 539 | |
| r5706 | r5707 | |
| 368 | 561 | } |
| 369 | 562 | |
| 370 | 563 | /* inform disk image of step operation so it can cache information */ |
| 371 | | if (image_exists(img) && pDrive->interface_.seek_callback) |
| 372 | | pDrive->interface_.seek_callback(img, pDrive->current_track); |
| 564 | if (image_exists(img)) |
| 565 | flopimg_seek_callback(img, pDrive->current_track); |
| 373 | 566 | |
| 374 | 567 | pDrive->id_index = 0; |
| 375 | 568 | } |
| r5706 | r5707 | |
| 378 | 571 | /* this is not accurate. But it will do for now */ |
| 379 | 572 | int floppy_drive_get_next_id(const device_config *img, int side, chrn_id *id) |
| 380 | 573 | { |
| 381 | | struct floppy_drive *pDrive; |
| 574 | floppy_drive *pDrive; |
| 382 | 575 | int spt; |
| 383 | 576 | |
| 384 | 577 | pDrive = get_drive(img); |
| 385 | 578 | |
| 386 | 579 | /* get sectors per track */ |
| 387 | | spt = 0; |
| 388 | | if (pDrive->interface_.get_sectors_per_track) |
| 389 | | spt = pDrive->interface_.get_sectors_per_track(img, side); |
| 580 | spt = flopimg_get_sectors_per_track(img, side); |
| 390 | 581 | |
| 391 | 582 | /* set index */ |
| 392 | 583 | if ((pDrive->id_index==(spt-1)) || (spt==0)) |
| r5706 | r5707 | |
| 401 | 592 | /* get id */ |
| 402 | 593 | if (spt!=0) |
| 403 | 594 | { |
| 404 | | if (pDrive->interface_.get_id_callback) |
| 405 | | pDrive->interface_.get_id_callback(img, id, pDrive->id_index, side); |
| 595 | flopimg_get_id_callback(img, id, pDrive->id_index, side); |
| 406 | 596 | } |
| 407 | 597 | |
| 408 | 598 | pDrive->id_index++; |
| r5706 | r5707 | |
| 416 | 606 | |
| 417 | 607 | int floppy_drive_get_current_track(const device_config *img) |
| 418 | 608 | { |
| 419 | | struct floppy_drive *drv = get_drive(img); |
| 609 | floppy_drive *drv = get_drive(img); |
| 420 | 610 | return drv->current_track; |
| 421 | 611 | } |
| 422 | 612 | |
| 423 | 613 | void floppy_drive_read_track_data_info_buffer(const device_config *img, int side, void *ptr, int *length ) |
| 424 | 614 | { |
| 615 | floppy_drive *flopimg; |
| 425 | 616 | if (image_exists(img)) |
| 426 | | { |
| 427 | | struct floppy_drive *drv = get_drive(img); |
| 428 | | if (drv->interface_.read_track_data_info_buffer) |
| 429 | | drv->interface_.read_track_data_info_buffer(img, side, ptr, length); |
| 617 | { |
| 618 | flopimg = get_drive(img); |
| 619 | if (!flopimg || !flopimg->floppy) |
| 620 | return; |
| 621 | |
| 622 | floppy_read_track_data(flopimg->floppy, side, flopimg->track, ptr, *length); |
| 430 | 623 | } |
| 431 | 624 | } |
| 432 | 625 | |
| 433 | 626 | void floppy_drive_write_track_data_info_buffer(const device_config *img, int side, const void *ptr, int *length ) |
| 434 | 627 | { |
| 628 | floppy_drive *flopimg; |
| 435 | 629 | if (image_exists(img)) |
| 436 | 630 | { |
| 437 | | struct floppy_drive *drv = get_drive(img); |
| 438 | | if (drv->interface_.write_track_data_info_buffer) |
| 439 | | drv->interface_.write_track_data_info_buffer(img, side, ptr, length); |
| 631 | flopimg = get_drive(img); |
| 632 | if (!flopimg || !flopimg->floppy) |
| 633 | return; |
| 634 | |
| 635 | floppy_write_track_data(flopimg->floppy, side, flopimg->track, ptr, *length); |
| 440 | 636 | } |
| 441 | 637 | } |
| 442 | 638 | |
| r5706 | r5707 | |
| 444 | 640 | { |
| 445 | 641 | if (image_exists(img)) |
| 446 | 642 | { |
| 447 | | struct floppy_drive *drv = get_drive(img); |
| 448 | | if (drv->interface_.format_sector) |
| 449 | | drv->interface_.format_sector(img, side, sector_index,c, h, r, n, filler); |
| 643 | /* if (drv->interface_.format_sector) |
| 644 | drv->interface_.format_sector(img, side, sector_index,c, h, r, n, filler);*/ |
| 450 | 645 | } |
| 451 | 646 | } |
| 452 | 647 | |
| 453 | | void floppy_drive_read_sector_data(const device_config *img, int side, int index1, void *pBuffer, int length) |
| 648 | void floppy_drive_read_sector_data(const device_config *img, int side, int index1, void *ptr, int length) |
| 454 | 649 | { |
| 650 | floppy_drive *flopimg; |
| 455 | 651 | if (image_exists(img)) |
| 456 | 652 | { |
| 457 | | struct floppy_drive *drv = get_drive(img); |
| 458 | | if (drv->interface_.read_sector_data_into_buffer) |
| 459 | | drv->interface_.read_sector_data_into_buffer(img, side, index1, pBuffer,length); |
| 653 | flopimg = get_drive(img); |
| 654 | if (!flopimg || !flopimg->floppy) |
| 655 | return; |
| 656 | |
| 657 | floppy_read_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length); |
| 658 | |
| 659 | if (LOG_FLOPPY) |
| 660 | log_readwrite("sector_read", side, flopimg->track, index1, ptr, length); |
| 661 | |
| 460 | 662 | } |
| 461 | 663 | } |
| 462 | 664 | |
| 463 | | void floppy_drive_write_sector_data(const device_config *img, int side, int index1, const void *pBuffer,int length, int ddam) |
| 665 | void floppy_drive_write_sector_data(const device_config *img, int side, int index1, const void *ptr,int length, int ddam) |
| 464 | 666 | { |
| 667 | floppy_drive *flopimg; |
| 465 | 668 | if (image_exists(img)) |
| 466 | | { |
| 467 | | struct floppy_drive *drv = get_drive(img); |
| 468 | | if (drv->interface_.write_sector_data_from_buffer) |
| 469 | | drv->interface_.write_sector_data_from_buffer(img, side, index1, pBuffer,length,ddam); |
| 669 | { |
| 670 | flopimg = get_drive(img); |
| 671 | if (!flopimg || !flopimg->floppy) |
| 672 | return; |
| 673 | |
| 674 | if (LOG_FLOPPY) |
| 675 | log_readwrite("sector_write", side, flopimg->track, index1, ptr, length); |
| 676 | |
| 677 | floppy_write_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length, ddam); |
| 470 | 678 | } |
| 471 | 679 | } |
| 472 | 680 | |
| r5706 | r5707 | |
| 509 | 717 | |
| 510 | 718 | void floppy_drive_set_rpm(const device_config *img, float rpm) |
| 511 | 719 | { |
| 512 | | struct floppy_drive *drv = get_drive(img); |
| 720 | floppy_drive *drv = get_drive(img); |
| 513 | 721 | drv->rpm = rpm; |
| 514 | 722 | } |
| 515 | 723 | |
| 516 | 724 | void floppy_drive_set_controller(const device_config *img, const device_config *controller) |
| 517 | 725 | { |
| 518 | | struct floppy_drive *drv = get_drive(img); |
| 726 | floppy_drive *drv = get_drive(img); |
| 519 | 727 | drv->controller = controller; |
| 520 | 728 | } |
| 521 | 729 | |
| 522 | | |
| 523 | | |
| 524 | | /*************************************************************************** |
| 525 | | CONSTANTS |
| 526 | | ***************************************************************************/ |
| 527 | | |
| 528 | | #define FLOPPY_TAG "floptag" |
| 529 | | #define LOG_FLOPPY 0 |
| 530 | | |
| 531 | | |
| 532 | | |
| 533 | | /*************************************************************************** |
| 534 | | TYPE DEFINITIONS |
| 535 | | ***************************************************************************/ |
| 536 | | |
| 537 | | typedef struct _mess_flopimg mess_flopimg; |
| 538 | | struct _mess_flopimg |
| 539 | | { |
| 540 | | floppy_image *floppy; |
| 541 | | int track; |
| 542 | | void (*load_proc)(const device_config *image); |
| 543 | | void (*unload_proc)(const device_config *image); |
| 544 | | int (*tracktranslate_proc)(const device_config *image, floppy_image *floppy, int physical_track); |
| 545 | | }; |
| 546 | | |
| 547 | | |
| 548 | | |
| 549 | | typedef struct _floppy_error_map floppy_error_map; |
| 550 | | struct _floppy_error_map |
| 551 | | { |
| 552 | | floperr_t ferr; |
| 553 | | image_error_t ierr; |
| 554 | | const char *message; |
| 555 | | }; |
| 556 | | |
| 557 | | |
| 558 | | |
| 559 | | /*************************************************************************** |
| 560 | | GLOBAL VARIABLES |
| 561 | | ***************************************************************************/ |
| 562 | | |
| 563 | | static const floppy_error_map errmap[] = |
| 564 | | { |
| 565 | | { FLOPPY_ERROR_SUCCESS, IMAGE_ERROR_SUCCESS }, |
| 566 | | { FLOPPY_ERROR_INTERNAL, IMAGE_ERROR_INTERNAL }, |
| 567 | | { FLOPPY_ERROR_UNSUPPORTED, IMAGE_ERROR_UNSUPPORTED }, |
| 568 | | { FLOPPY_ERROR_OUTOFMEMORY, IMAGE_ERROR_OUTOFMEMORY }, |
| 569 | | { FLOPPY_ERROR_INVALIDIMAGE, IMAGE_ERROR_INVALIDIMAGE } |
| 570 | | }; |
| 571 | | |
| 572 | | /*************************************************************************** |
| 573 | | IMPLEMENTATION |
| 574 | | ***************************************************************************/ |
| 575 | | |
| 576 | | static mess_flopimg *get_flopimg(const device_config *image) |
| 577 | | { |
| 578 | | return (mess_flopimg *) image_lookuptag(image, FLOPPY_TAG); |
| 579 | | } |
| 580 | | |
| 581 | | |
| 582 | | |
| 583 | | floppy_image *flopimg_get_image(const device_config *image) |
| 584 | | { |
| 585 | | return get_flopimg(image)->floppy; |
| 586 | | } |
| 587 | | |
| 588 | | |
| 589 | | |
| 590 | | static void flopimg_seek_callback(const device_config *image, int physical_track) |
| 591 | | { |
| 592 | | mess_flopimg *flopimg; |
| 593 | | |
| 594 | | flopimg = get_flopimg(image); |
| 595 | | if (!flopimg || !flopimg->floppy) |
| 596 | | return; |
| 597 | | |
| 598 | | /* translate the track number if necessary */ |
| 599 | | if (flopimg->tracktranslate_proc) |
| 600 | | physical_track = flopimg->tracktranslate_proc(image, flopimg->floppy, physical_track); |
| 601 | | |
| 602 | | flopimg->track = physical_track; |
| 603 | | } |
| 604 | | |
| 605 | | |
| 606 | | |
| 607 | | static int flopimg_get_sectors_per_track(const device_config *image, int side) |
| 608 | | { |
| 609 | | mess_flopimg *flopimg; |
| 610 | | floperr_t err; |
| 611 | | int sector_count; |
| 612 | | |
| 613 | | flopimg = get_flopimg(image); |
| 614 | | if (!flopimg || !flopimg->floppy) |
| 615 | | return 0; |
| 616 | | |
| 617 | | err = floppy_get_sector_count(flopimg->floppy, side, flopimg->track, §or_count); |
| 618 | | if (err) |
| 619 | | return 0; |
| 620 | | return sector_count; |
| 621 | | } |
| 622 | | |
| 623 | | |
| 624 | | |
| 625 | | static void flopimg_get_id_callback(const device_config *image, chrn_id *id, int id_index, int side) |
| 626 | | { |
| 627 | | mess_flopimg *flopimg; |
| 628 | | int cylinder, sector, N; |
| 629 | | unsigned long flags; |
| 630 | | UINT32 sector_length; |
| 631 | | |
| 632 | | flopimg = get_flopimg(image); |
| 633 | | if (!flopimg || !flopimg->floppy) |
| 634 | | return; |
| 635 | | |
| 636 | | floppy_get_indexed_sector_info(flopimg->floppy, side, flopimg->track, id_index, &cylinder, &side, §or, §or_length, &flags); |
| 637 | | |
| 638 | | N = compute_log2(sector_length); |
| 639 | | |
| 640 | | id->C = cylinder; |
| 641 | | id->H = side; |
| 642 | | id->R = sector; |
| 643 | | id->data_id = id_index; |
| 644 | | id->flags = flags; |
| 645 | | id->N = ((N >= 7) && (N <= 10)) ? N - 7 : 0; |
| 646 | | } |
| 647 | | |
| 648 | | |
| 649 | | |
| 650 | | static void log_readwrite(const char *name, int head, int track, int sector, const char *buf, int length) |
| 651 | | { |
| 652 | | char membuf[1024]; |
| 653 | | int i; |
| 654 | | for (i = 0; i < length; i++) |
| 655 | | sprintf(membuf + i*2, "%02x", (int) (UINT8) buf[i]); |
| 656 | | logerror("%s: head=%i track=%i sector=%i buffer='%s'\n", name, head, track, sector, membuf); |
| 657 | | } |
| 658 | | |
| 659 | | |
| 660 | | |
| 661 | | static void flopimg_read_sector_data_into_buffer(const device_config *image, int side, int index1, char *ptr, int length) |
| 662 | | { |
| 663 | | mess_flopimg *flopimg; |
| 664 | | |
| 665 | | flopimg = get_flopimg(image); |
| 666 | | if (!flopimg || !flopimg->floppy) |
| 667 | | return; |
| 668 | | |
| 669 | | floppy_read_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length); |
| 670 | | |
| 671 | | if (LOG_FLOPPY) |
| 672 | | log_readwrite("sector_read", side, flopimg->track, index1, ptr, length); |
| 673 | | } |
| 674 | | |
| 675 | | |
| 676 | | |
| 677 | | static void flopimg_write_sector_data_from_buffer(const device_config *image, int side, int index1, const char *ptr, int length, int ddam) |
| 678 | | { |
| 679 | | mess_flopimg *flopimg; |
| 680 | | |
| 681 | | flopimg = get_flopimg(image); |
| 682 | | if (!flopimg || !flopimg->floppy) |
| 683 | | return; |
| 684 | | |
| 685 | | if (LOG_FLOPPY) |
| 686 | | log_readwrite("sector_write", side, flopimg->track, index1, ptr, length); |
| 687 | | |
| 688 | | floppy_write_indexed_sector(flopimg->floppy, side, flopimg->track, index1, 0, ptr, length, ddam); |
| 689 | | } |
| 690 | | |
| 691 | | |
| 692 | | |
| 693 | | static void flopimg_read_track_data_info_buffer(const device_config *image, int side, void *ptr, int *length) |
| 694 | | { |
| 695 | | mess_flopimg *flopimg; |
| 696 | | |
| 697 | | flopimg = get_flopimg(image); |
| 698 | | if (!flopimg || !flopimg->floppy) |
| 699 | | return; |
| 700 | | |
| 701 | | floppy_read_track_data(flopimg->floppy, side, flopimg->track, ptr, *length); |
| 702 | | } |
| 703 | | |
| 704 | | |
| 705 | | |
| 706 | | static void flopimg_write_track_data_info_buffer(const device_config *image, int side, const void *ptr, int *length) |
| 707 | | { |
| 708 | | mess_flopimg *flopimg; |
| 709 | | |
| 710 | | flopimg = get_flopimg(image); |
| 711 | | if (!flopimg || !flopimg->floppy) |
| 712 | | return; |
| 713 | | |
| 714 | | floppy_write_track_data(flopimg->floppy, side, flopimg->track, ptr, *length); |
| 715 | | } |
| 716 | | |
| 717 | | |
| 718 | | |
| 719 | | static const floppy_interface mess_floppy_interface = |
| 720 | | { |
| 721 | | flopimg_seek_callback, |
| 722 | | flopimg_get_sectors_per_track, |
| 723 | | flopimg_get_id_callback, |
| 724 | | flopimg_read_sector_data_into_buffer, |
| 725 | | flopimg_write_sector_data_from_buffer, |
| 726 | | flopimg_read_track_data_info_buffer, |
| 727 | | flopimg_write_track_data_info_buffer, |
| 728 | | NULL |
| 729 | | }; |
| 730 | | |
| 731 | 730 | /* ----------------------------------------------------------------------- */ |
| 732 | 731 | |
| 733 | | static int image_fseek_thunk(void *file, INT64 offset, int whence) |
| 734 | | { |
| 735 | | return image_fseek((const device_config *) file, offset, whence); |
| 736 | | } |
| 737 | 732 | |
| 738 | | static size_t image_fread_thunk(void *file, void *buffer, size_t length) |
| 739 | | { |
| 740 | | return image_fread((const device_config *) file, buffer, length); |
| 741 | | } |
| 742 | | |
| 743 | | static size_t image_fwrite_thunk(void *file, const void *buffer, size_t length) |
| 744 | | { |
| 745 | | return image_fwrite((const device_config *) file, buffer, length); |
| 746 | | } |
| 747 | | |
| 748 | | static UINT64 image_fsize_thunk(void *file) |
| 749 | | { |
| 750 | | return image_length((const device_config *) file); |
| 751 | | } |
| 752 | | |
| 753 | | /* ----------------------------------------------------------------------- */ |
| 754 | | |
| 755 | | const struct io_procs mess_ioprocs = |
| 756 | | { |
| 757 | | NULL, |
| 758 | | image_fseek_thunk, |
| 759 | | image_fread_thunk, |
| 760 | | image_fwrite_thunk, |
| 761 | | image_fsize_thunk |
| 762 | | }; |
| 763 | | |
| 764 | | |
| 765 | | |
| 766 | | |
| 767 | | /* ----------------------------------------------------------------------- */ |
| 768 | | |
| 769 | | |
| 770 | 733 | static DEVICE_START( floppy ) |
| 771 | 734 | { |
| 772 | | image_alloctag(device, FLOPPY_TAG, sizeof(mess_flopimg)); |
| 773 | | floppy_drive_init(device, &mess_floppy_interface); |
| 735 | floppy_drive_init(device); |
| 774 | 736 | } |
| 775 | 737 | |
| 776 | 738 | |
| r5706 | r5707 | |
| 778 | 740 | static int internal_floppy_device_load(const device_config *image, int create_format, option_resolution *create_args) |
| 779 | 741 | { |
| 780 | 742 | floperr_t err; |
| 781 | | mess_flopimg *flopimg; |
| 743 | floppy_drive *flopimg; |
| 782 | 744 | const mess_device_class *devclass; |
| 783 | 745 | const struct FloppyFormat *floppy_options; |
| 784 | 746 | int floppy_flags, i; |
| r5706 | r5707 | |
| 786 | 748 | int keep_geometry = 0; |
| 787 | 749 | |
| 788 | 750 | /* look up instance data */ |
| 789 | | flopimg = get_flopimg(image); |
| 751 | flopimg = get_drive(image); |
| 790 | 752 | |
| 791 | 753 | /* figure out the floppy options */ |
| 792 | 754 | devclass = mess_devclass_from_core_device(image); |
| r5706 | r5707 | |
| 843 | 805 | |
| 844 | 806 | static DEVICE_IMAGE_LOAD( floppy ) |
| 845 | 807 | { |
| 846 | | mess_flopimg *flopimg; |
| 808 | floppy_drive *flopimg; |
| 847 | 809 | int retVal = internal_floppy_device_load(image, -1, NULL); |
| 848 | | flopimg = image_lookuptag(image, FLOPPY_TAG); |
| 810 | flopimg = get_drive(image); |
| 849 | 811 | if (retVal==INIT_PASS) { |
| 850 | 812 | /* if we have one of our hacky unload procs, call it */ |
| 851 | 813 | if (flopimg->load_proc) |
| r5706 | r5707 | |
| 865 | 827 | |
| 866 | 828 | static DEVICE_IMAGE_UNLOAD( floppy ) |
| 867 | 829 | { |
| 868 | | mess_flopimg *flopimg; |
| 869 | | flopimg = image_lookuptag(image, FLOPPY_TAG); |
| 870 | | |
| 871 | | /* if we have one of our hacky unload procs, call it */ |
| 830 | floppy_drive *flopimg = get_drive(image); |
| 872 | 831 | if (flopimg->unload_proc) |
| 873 | 832 | flopimg->unload_proc(image); |
| 874 | 833 | |
| r5706 | r5707 | |
| 880 | 839 | |
| 881 | 840 | /************************************* |
| 882 | 841 | * |
| 883 | | * Hacks for specific systems |
| 884 | | * |
| 885 | | *************************************/ |
| 886 | | |
| 887 | | void floppy_install_load_proc(const device_config *image, void (*proc)(const device_config *image)) |
| 888 | | { |
| 889 | | mess_flopimg *flopimg; |
| 890 | | flopimg = image_lookuptag(image, FLOPPY_TAG); |
| 891 | | flopimg->load_proc = proc; |
| 892 | | } |
| 893 | | |
| 894 | | void floppy_install_unload_proc(const device_config *image, void (*proc)(const device_config *image)) |
| 895 | | { |
| 896 | | mess_flopimg *flopimg; |
| 897 | | flopimg = image_lookuptag(image, FLOPPY_TAG); |
| 898 | | flopimg->unload_proc = proc; |
| 899 | | } |
| 900 | | |
| 901 | | |
| 902 | | |
| 903 | | void floppy_install_tracktranslate_proc(const device_config *image, int (*proc)(const device_config *image, floppy_image *floppy, int physical_track)) |
| 904 | | { |
| 905 | | mess_flopimg *flopimg; |
| 906 | | flopimg = image_lookuptag(image, FLOPPY_TAG); |
| 907 | | flopimg->tracktranslate_proc = proc; |
| 908 | | } |
| 909 | | |
| 910 | | /************************************* |
| 911 | | * |
| 912 | 842 | * Device specification function |
| 913 | 843 | * |
| 914 | 844 | *************************************/ |