src/mess/machine/c2040.c
| r7881 | r7882 | |
| 238 | 238 | if (c2040->unit[c2040->drive].buffer_pos >= c2040->unit[c2040->drive].track_len) |
| 239 | 239 | { |
| 240 | 240 | /* loop to the start of the track */ |
| 241 | | c2040->unit[c2040->drive].buffer_pos = G64_DATA_START; |
| 241 | c2040->unit[c2040->drive].buffer_pos = 0; |
| 242 | 242 | } |
| 243 | 243 | } |
| 244 | 244 | |
| r7881 | r7882 | |
| 277 | 277 | static void read_current_track(c2040_t *c2040, int unit) |
| 278 | 278 | { |
| 279 | 279 | c2040->unit[unit].track_len = G64_BUFFER_SIZE; |
| 280 | | c2040->unit[unit].buffer_pos = G64_DATA_START; |
| 280 | c2040->unit[unit].buffer_pos = 0; |
| 281 | 281 | c2040->unit[unit].bit_pos = 7; |
| 282 | 282 | c2040->bit_count = 0; |
| 283 | 283 | |
| r7881 | r7882 | |
| 285 | 285 | floppy_drive_read_track_data_info_buffer(c2040->unit[unit].image, c2040->side, c2040->unit[unit].track_buffer, &c2040->unit[unit].track_len); |
| 286 | 286 | |
| 287 | 287 | /* extract track length */ |
| 288 | | c2040->unit[unit].track_len = G64_DATA_START + ((c2040->unit[unit].track_buffer[1] << 8) | c2040->unit[unit].track_buffer[0]); |
| 288 | c2040->unit[unit].track_len = floppy_drive_get_current_track_size(c2040->unit[unit].image, c2040->side); |
| 289 | 289 | } |
| 290 | 290 | |
| 291 | 291 | /*------------------------------------------------- |
src/mess/formats/d64_dsk.c
| r7881 | r7882 | |
| 10 | 10 | |
| 11 | 11 | TODO: |
| 12 | 12 | |
| 13 | - fix MAX_ERROR_SECTORS, it is too small for d80/d82 |
| 13 | 14 | - write to disk |
| 14 | 15 | - disk errors 24, 25, 26, 28, 74 |
| 15 | 16 | - variable gaps |
| r7881 | r7882 | |
| 26 | 27 | PARAMETERS |
| 27 | 28 | ***************************************************************************/ |
| 28 | 29 | |
| 29 | | #define LOG |
| 30 | #define LOG 1 |
| 30 | 31 | |
| 31 | 32 | #define MAX_HEADS 2 |
| 32 | 33 | #define MAX_TRACKS 84 |
| 33 | | #define MAX_ERROR_SECTORS 802 |
| 34 | #define MAX_ERROR_SECTORS 802 // TODO this is too small for .d80 files |
| 34 | 35 | #define SECTOR_SIZE 256 |
| 35 | 36 | #define SECTOR_SIZE_GCR 368 |
| 36 | 37 | |
| r7881 | r7882 | |
| 244 | 245 | } |
| 245 | 246 | |
| 246 | 247 | /*------------------------------------------------- |
| 248 | d64_get_track_size - returns the track size |
| 249 | -------------------------------------------------*/ |
| 250 | |
| 251 | static UINT32 d64_get_track_size(floppy_image *floppy, int head, int track) |
| 252 | { |
| 253 | struct d64dsk_tag *tag = get_tag(floppy); |
| 254 | |
| 255 | if (tag->track_offset[head][track] == INVALID_OFFSET) |
| 256 | return 0; |
| 257 | |
| 258 | /* determine number of sectors per track */ |
| 259 | int sectors_per_track = d64_get_sectors_per_track(floppy, head, track); |
| 260 | |
| 261 | /* allocate temporary GCR track data buffer */ |
| 262 | UINT32 track_length = sectors_per_track * SECTOR_SIZE_GCR; |
| 263 | |
| 264 | return track_length; |
| 265 | } |
| 266 | |
| 267 | /*------------------------------------------------- |
| 247 | 268 | get_sector_error_code - returns the error |
| 248 | 269 | code for the given sector |
| 249 | 270 | -------------------------------------------------*/ |
| r7881 | r7882 | |
| 251 | 272 | static int get_sector_error_code(floppy_image *floppy, int head, int dos_track, int sector) |
| 252 | 273 | { |
| 253 | 274 | struct d64dsk_tag *tag = get_tag(floppy); |
| 254 | | int sector_error = tag->error[tag->error_offset[head][dos_track] + sector]; |
| 255 | 275 | |
| 256 | | if (sector_error) |
| 276 | if (!tag->has_errors) |
| 277 | return ERROR_00; |
| 278 | |
| 279 | int sector_error = tag->error[tag->error_offset[head][dos_track] + sector]; // TODO index out of bounds!!! |
| 280 | |
| 281 | if (sector_error != ERROR_00) |
| 257 | 282 | { |
| 258 | 283 | logerror("D64 error %s head %u track %u sector %u\n", ERROR_CODE[sector_error], head, dos_track, sector); |
| 259 | 284 | } |
| r7881 | r7882 | |
| 371 | 396 | UINT8 *d64_track_data; |
| 372 | 397 | UINT16 gcr_track_size; |
| 373 | 398 | UINT8 *gcr_track_data; |
| 374 | | UINT64 gcr_pos = G64_DATA_START; |
| 375 | | //int error_offset = 0; |
| 399 | UINT64 gcr_pos = 0; |
| 376 | 400 | |
| 377 | 401 | /* determine logical track number */ |
| 378 | 402 | int dos_track = get_dos_track(track); |
| r7881 | r7882 | |
| 398 | 422 | |
| 399 | 423 | if (buflen < gcr_track_size) fatalerror("D64 track buffer too small: %u!\n", (UINT32)buflen); |
| 400 | 424 | |
| 401 | | /* prepend GCR track data buffer with GCR track size */ |
| 402 | | gcr_track_data[0] = gcr_track_size & 0xff; |
| 403 | | gcr_track_data[1] = gcr_track_size >> 8; |
| 404 | | |
| 405 | 425 | /* read D64 track data */ |
| 406 | 426 | floppy_image_read(floppy, d64_track_data, track_offset, d64_track_size); |
| 407 | 427 | |
| r7881 | r7882 | |
| 475 | 495 | UINT8 sector_checksum = d64_track_data[d64_pos]; |
| 476 | 496 | for (i = 1; i < 256; i++) |
| 477 | 497 | sector_checksum ^= d64_track_data[d64_pos + i]; |
| 478 | | |
| 498 | |
| 479 | 499 | if (sector_error == ERROR_23) |
| 480 | 500 | sector_checksum ^= 0xff; |
| 481 | 501 | |
| r7881 | r7882 | |
| 504 | 524 | for (i = 0; i < 14; i++) |
| 505 | 525 | gcr_track_data[gcr_pos + i] = 0x55; |
| 506 | 526 | gcr_pos += 14; |
| 507 | | |
| 508 | | //error_offset++; |
| 509 | 527 | } |
| 510 | 528 | |
| 511 | 529 | /* copy GCR track data to buffer */ |
| 512 | | memcpy(buffer, gcr_track_data, gcr_track_size + G64_DATA_START); |
| 530 | memcpy(buffer, gcr_track_data, gcr_track_size); |
| 513 | 531 | } |
| 514 | 532 | else /* half tracks */ |
| 515 | 533 | { |
| r7881 | r7882 | |
| 729 | 747 | if (LOG) |
| 730 | 748 | { |
| 731 | 749 | logerror("D64 head %u track %u data offset: %04x\n", head, track + 1, tag->track_offset[head][track]); |
| 732 | | logerror("D64 head %u track %u error offset: %04x\n", head, track + 1, tag->error_offset[head][track]); |
| 750 | if (has_errors) logerror("D64 head %u track %u error offset: %04x\n", head, track + 1, tag->error_offset[head][track]); |
| 733 | 751 | } |
| 734 | 752 | } |
| 735 | 753 | } |
| r7881 | r7882 | |
| 762 | 780 | if (LOG) |
| 763 | 781 | { |
| 764 | 782 | logerror("D64 head %u track %.1f data offset: %04x\n", head, get_dos_track(track), tag->track_offset[head][track]); |
| 765 | | logerror("D64 head %u track %.1f error offset: %04x\n", head, get_dos_track(track), tag->error_offset[head][track]); |
| 783 | if (has_errors) logerror("D64 head %u track %.1f error offset: %04x\n", head, get_dos_track(track), tag->error_offset[head][track]); |
| 766 | 784 | } |
| 767 | 785 | } |
| 768 | 786 | } |
| r7881 | r7882 | |
| 821 | 839 | callbacks->write_track = d64_write_track; |
| 822 | 840 | callbacks->get_heads_per_disk = d64_get_heads_per_disk; |
| 823 | 841 | callbacks->get_tracks_per_disk = d64_get_tracks_per_disk; |
| 842 | callbacks->get_track_size = d64_get_track_size; |
| 824 | 843 | |
| 825 | 844 | return FLOPPY_ERROR_SUCCESS; |
| 826 | 845 | } |
src/mess/formats/g64_dsk.c
| r7881 | r7882 | |
| 86 | 86 | the disk image for a given track |
| 87 | 87 | -------------------------------------------------*/ |
| 88 | 88 | |
| 89 | | static floperr_t get_track_offset(floppy_image *floppy, int track, UINT64 *offset) |
| 89 | static floperr_t get_track_offset(floppy_image *floppy, int head, int track, UINT64 *offset) |
| 90 | 90 | { |
| 91 | 91 | struct g64dsk_tag *tag = get_tag(floppy); |
| 92 | 92 | UINT64 offs = 0; |
| r7881 | r7882 | |
| 103 | 103 | } |
| 104 | 104 | |
| 105 | 105 | /*------------------------------------------------- |
| 106 | g64_get_track_size - returns the track size |
| 107 | -------------------------------------------------*/ |
| 108 | |
| 109 | static UINT32 g64_get_track_size(floppy_image *floppy, int head, int track) |
| 110 | { |
| 111 | /* get track offset */ |
| 112 | UINT64 track_offset; |
| 113 | floperr_t err = get_track_offset(floppy, head, track, &track_offset); |
| 114 | |
| 115 | if (err) |
| 116 | return 0; |
| 117 | |
| 118 | /* read track length */ |
| 119 | UINT8 size[2]; |
| 120 | floppy_image_read(floppy, &size, track_offset, 2); |
| 121 | UINT32 track_length = (size[1] << 8) | size[0]; |
| 122 | |
| 123 | return track_length; |
| 124 | } |
| 125 | |
| 126 | /*------------------------------------------------- |
| 106 | 127 | g64_read_track - reads a full track from the |
| 107 | 128 | disk image |
| 108 | 129 | -------------------------------------------------*/ |
| r7881 | r7882 | |
| 115 | 136 | UINT16 track_length = 0; |
| 116 | 137 | |
| 117 | 138 | /* get track offset */ |
| 118 | | err = get_track_offset(floppy, track, &track_offset); |
| 139 | err = get_track_offset(floppy, head, track, &track_offset); |
| 119 | 140 | |
| 120 | 141 | if (err) |
| 121 | 142 | return err; |
| 122 | 143 | |
| 123 | 144 | if (!head && track_offset) |
| 124 | 145 | { |
| 125 | | if (buflen < (tag->track_size + G64_DATA_START)) fatalerror("G64 track buffer too small: %u!\n", (UINT32)buflen); |
| 146 | if (buflen < tag->track_size) fatalerror("G64 track buffer too small: %u!\n", (UINT32)buflen); |
| 126 | 147 | |
| 127 | 148 | /* read track */ |
| 128 | | floppy_image_read(floppy, buffer, track_offset, tag->track_size + G64_DATA_START); |
| 149 | floppy_image_read(floppy, buffer, track_offset + 2, tag->track_size); |
| 129 | 150 | } |
| 130 | 151 | else |
| 131 | 152 | { |
| r7881 | r7882 | |
| 268 | 289 | callbacks->write_track = g64_write_track; |
| 269 | 290 | callbacks->get_heads_per_disk = g64_get_heads_per_disk; |
| 270 | 291 | callbacks->get_tracks_per_disk = g64_get_tracks_per_disk; |
| 292 | callbacks->get_track_size = g64_get_track_size; |
| 271 | 293 | |
| 272 | 294 | return FLOPPY_ERROR_SUCCESS; |
| 273 | 295 | } |