src/mess/devices/dsk.c
| r5671 | r5672 | |
| 1 | | /*************************************************************************** |
| 2 | | |
| 3 | | dsk.c |
| 4 | | |
| 5 | | CPCEMU standard and extended disk image support. |
| 6 | | Used on Amstrad CPC and Spectrum +3 drivers. |
| 7 | | |
| 8 | | KT - 27/2/00 - Moved Disk Image handling code into this file |
| 9 | | - Fixed a few bugs |
| 10 | | - Cleaned code up a bit |
| 11 | | ***************************************************************************/ |
| 12 | | |
| 13 | | #include "driver.h" |
| 14 | | #include "dsk.h" |
| 15 | | #include "flopdrv.h" |
| 16 | | |
| 17 | | |
| 18 | | /* disk image and extended disk image support code */ |
| 19 | | /* supports up to 84 tracks and 2 sides */ |
| 20 | | |
| 21 | | #define dsk_MAX_TRACKS 84 |
| 22 | | #define dsk_MAX_SIDES 2 |
| 23 | | #define dsk_NUM_DRIVES 4 |
| 24 | | #define dsk_SECTORS_PER_TRACK 20 |
| 25 | | |
| 26 | | typedef struct |
| 27 | | { |
| 28 | | unsigned char *data; /* the whole image data */ |
| 29 | | unsigned long track_offsets[dsk_MAX_TRACKS*dsk_MAX_SIDES]; /* offset within data for each track */ |
| 30 | | unsigned long sector_offsets[dsk_SECTORS_PER_TRACK]; /* offset within current track for sector data */ |
| 31 | | int current_track; /* current track */ |
| 32 | | int disk_image_type; /* image type: standard or extended */ |
| 33 | | } dsk_drive; |
| 34 | | |
| 35 | | static void dsk_disk_image_init(dsk_drive *); |
| 36 | | |
| 37 | | static void dsk_seek_callback(const device_config *img, int physical_track); |
| 38 | | static void dsk_get_id_callback(const device_config *img, struct chrn_id *id, int id_index, int side); |
| 39 | | static int dsk_get_sectors_per_track(const device_config *img, int side); |
| 40 | | |
| 41 | | static void dsk_write_sector_data_from_buffer(const device_config *img, int sector_index, int side, const char *ptr, int length, int ddam); |
| 42 | | static void dsk_read_sector_data_into_buffer(const device_config *img, int sector_index, int side, char *ptr, int length); |
| 43 | | |
| 44 | | static const floppy_interface dsk_floppy_interface = |
| 45 | | { |
| 46 | | dsk_seek_callback, |
| 47 | | dsk_get_sectors_per_track, |
| 48 | | dsk_get_id_callback, |
| 49 | | dsk_read_sector_data_into_buffer, |
| 50 | | dsk_write_sector_data_from_buffer, |
| 51 | | NULL, |
| 52 | | NULL |
| 53 | | }; |
| 54 | | |
| 55 | | static dsk_drive drives[dsk_NUM_DRIVES]; /* the drives */ |
| 56 | | |
| 57 | | static dsk_drive *get_drive(const device_config *img) |
| 58 | | { |
| 59 | | return &drives[image_index_in_device(img)]; |
| 60 | | } |
| 61 | | |
| 62 | | static int dsk_floppy_verify(UINT8 *diskimage_data) |
| 63 | | { |
| 64 | | if ( (memcmp(diskimage_data, "MV - CPC", 8)==0) || /* standard disk image? */ |
| 65 | | (memcmp(diskimage_data, "EXTENDED", 8)==0)) /* extended disk image? */ |
| 66 | | { |
| 67 | | return IMAGE_VERIFY_PASS; |
| 68 | | } |
| 69 | | return IMAGE_VERIFY_FAIL; |
| 70 | | } |
| 71 | | |
| 72 | | |
| 73 | | |
| 74 | | static DEVICE_START( dsk_floppy ) |
| 75 | | { |
| 76 | | floppy_drive_init(device, NULL); |
| 77 | | } |
| 78 | | |
| 79 | | |
| 80 | | |
| 81 | | /* load floppy */ |
| 82 | | static DEVICE_IMAGE_LOAD( dsk_floppy ) |
| 83 | | { |
| 84 | | int id = image_index_in_device(image); |
| 85 | | dsk_drive *thedrive = &drives[id]; |
| 86 | | |
| 87 | | /* load disk image */ |
| 88 | | thedrive->data = (unsigned char *) image_ptr(image); |
| 89 | | if (thedrive->data) |
| 90 | | { |
| 91 | | dsk_disk_image_init(thedrive); /* initialise dsk */ |
| 92 | | floppy_drive_set_disk_image_interface(image, &dsk_floppy_interface); |
| 93 | | if(dsk_floppy_verify(thedrive->data) == IMAGE_VERIFY_PASS) |
| 94 | | return INIT_PASS; |
| 95 | | else |
| 96 | | return INIT_PASS; |
| 97 | | } |
| 98 | | return INIT_PASS; |
| 99 | | } |
| 100 | | |
| 101 | | static int dsk_save(const device_config *img, unsigned char **ptr) |
| 102 | | { |
| 103 | | int datasize; |
| 104 | | unsigned char *data; |
| 105 | | |
| 106 | | /* get file size */ |
| 107 | | datasize = image_length(img); |
| 108 | | |
| 109 | | if (datasize!=0) |
| 110 | | { |
| 111 | | data = *ptr; |
| 112 | | if (data!=NULL) |
| 113 | | { |
| 114 | | image_fwrite(img, data, datasize); |
| 115 | | |
| 116 | | /* ok! */ |
| 117 | | return 1; |
| 118 | | } |
| 119 | | } |
| 120 | | |
| 121 | | return 0; |
| 122 | | } |
| 123 | | |
| 124 | | |
| 125 | | static DEVICE_IMAGE_UNLOAD( dsk_floppy ) |
| 126 | | { |
| 127 | | int id = image_index_in_device(image); |
| 128 | | dsk_drive *thedrive = &drives[id]; |
| 129 | | |
| 130 | | if (thedrive->data) |
| 131 | | dsk_save(image, &thedrive->data); |
| 132 | | thedrive->data = NULL; |
| 133 | | } |
| 134 | | |
| 135 | | |
| 136 | | |
| 137 | | static void dsk_dsk_init_track_offsets(dsk_drive *thedrive) |
| 138 | | { |
| 139 | | int track_offset; |
| 140 | | int i; |
| 141 | | int track_size; |
| 142 | | int tracks, sides; |
| 143 | | int skip, length,offs; |
| 144 | | unsigned char *file_loaded = thedrive->data; |
| 145 | | |
| 146 | | |
| 147 | | /* get size of each track from main header. Size of each |
| 148 | | track includes a 0x0100 byte header, and the actual sector data for |
| 149 | | all sectors on the track */ |
| 150 | | track_size = file_loaded[0x032] | (file_loaded[0x033]<<8); |
| 151 | | |
| 152 | | /* main header is 0x0100 in size */ |
| 153 | | track_offset = 0x0100; |
| 154 | | |
| 155 | | sides = file_loaded[0x031]; |
| 156 | | tracks = file_loaded[0x030]; |
| 157 | | |
| 158 | | |
| 159 | | /* single sided? */ |
| 160 | | if (sides==1) |
| 161 | | { |
| 162 | | skip = 2; |
| 163 | | length = tracks; |
| 164 | | } |
| 165 | | else |
| 166 | | { |
| 167 | | skip = 1; |
| 168 | | length = tracks*sides; |
| 169 | | } |
| 170 | | |
| 171 | | offs = 0; |
| 172 | | for (i=0; i<length; i++) |
| 173 | | { |
| 174 | | thedrive->track_offsets[offs] = track_offset; |
| 175 | | track_offset+=track_size; |
| 176 | | offs+=skip; |
| 177 | | } |
| 178 | | |
| 179 | | } |
| 180 | | |
| 181 | | static void dsk_dsk_init_sector_offsets(dsk_drive *thedrive,int track,int side) |
| 182 | | { |
| 183 | | int track_offset; |
| 184 | | |
| 185 | | side = side & 0x01; |
| 186 | | |
| 187 | | /* get offset to track header in image */ |
| 188 | | track_offset = thedrive->track_offsets[(track<<1) + side]; |
| 189 | | |
| 190 | | if (track_offset!=0) |
| 191 | | { |
| 192 | | int spt; |
| 193 | | int sector_offset; |
| 194 | | int sector_size; |
| 195 | | int i; |
| 196 | | |
| 197 | | unsigned char *track_header; |
| 198 | | |
| 199 | | track_header= &thedrive->data[track_offset]; |
| 200 | | |
| 201 | | /* sectors per track as specified in nec765 format command */ |
| 202 | | /* sectors on this track */ |
| 203 | | spt = track_header[0x015]; |
| 204 | | |
| 205 | | sector_size = (1<<(track_header[0x014]+7)); |
| 206 | | |
| 207 | | /* track header is 0x0100 bytes in size */ |
| 208 | | sector_offset = 0x0100; |
| 209 | | |
| 210 | | for (i=0; i<spt; i++) |
| 211 | | { |
| 212 | | thedrive->sector_offsets[i] = sector_offset; |
| 213 | | sector_offset+=sector_size; |
| 214 | | } |
| 215 | | } |
| 216 | | } |
| 217 | | |
| 218 | | static void dsk_extended_dsk_init_track_offsets(dsk_drive *thedrive) |
| 219 | | { |
| 220 | | int track_offset; |
| 221 | | int i; |
| 222 | | int track_size; |
| 223 | | int tracks, sides; |
| 224 | | int offs, skip, length; |
| 225 | | unsigned char *file_loaded = thedrive->data; |
| 226 | | |
| 227 | | sides = file_loaded[0x031]; |
| 228 | | tracks = file_loaded[0x030]; |
| 229 | | |
| 230 | | if (sides==1) |
| 231 | | { |
| 232 | | skip = 2; |
| 233 | | length = tracks; |
| 234 | | } |
| 235 | | else |
| 236 | | { |
| 237 | | skip = 1; |
| 238 | | length = tracks*sides; |
| 239 | | } |
| 240 | | |
| 241 | | /* main header is 0x0100 in size */ |
| 242 | | track_offset = 0x0100; |
| 243 | | offs = 0; |
| 244 | | for (i=0; i<length; i++) |
| 245 | | { |
| 246 | | int track_size_high_byte; |
| 247 | | |
| 248 | | /* track size is specified as a byte, and is multiplied |
| 249 | | by 256 to get size in bytes. If 0, track doesn't exist and |
| 250 | | is unformatted, otherwise it exists. Track size includes 0x0100 |
| 251 | | header */ |
| 252 | | track_size_high_byte = file_loaded[0x034 + i]; |
| 253 | | |
| 254 | | if (track_size_high_byte != 0) |
| 255 | | { |
| 256 | | /* formatted track */ |
| 257 | | track_size = track_size_high_byte<<8; |
| 258 | | |
| 259 | | thedrive->track_offsets[offs] = track_offset; |
| 260 | | track_offset+=track_size; |
| 261 | | } |
| 262 | | |
| 263 | | offs+=skip; |
| 264 | | } |
| 265 | | } |
| 266 | | |
| 267 | | |
| 268 | | static void dsk_extended_dsk_init_sector_offsets(dsk_drive *thedrive,int track,int side) |
| 269 | | { |
| 270 | | int track_offset; |
| 271 | | |
| 272 | | side = side & 0x01; |
| 273 | | |
| 274 | | /* get offset to track header in image */ |
| 275 | | track_offset = thedrive->track_offsets[(track<<1) + side]; |
| 276 | | |
| 277 | | if (track_offset!=0) |
| 278 | | { |
| 279 | | int spt; |
| 280 | | int sector_offset; |
| 281 | | int sector_size; |
| 282 | | int i; |
| 283 | | unsigned char *id_info; |
| 284 | | unsigned char *track_header; |
| 285 | | |
| 286 | | track_header= &thedrive->data[track_offset]; |
| 287 | | |
| 288 | | /* sectors per track as specified in nec765 format command */ |
| 289 | | /* sectors on this track */ |
| 290 | | spt = track_header[0x015]; |
| 291 | | |
| 292 | | id_info = track_header + 0x018; |
| 293 | | |
| 294 | | /* track header is 0x0100 bytes in size */ |
| 295 | | sector_offset = 0x0100; |
| 296 | | |
| 297 | | for (i=0; i<spt; i++) |
| 298 | | { |
| 299 | | sector_size = id_info[(i<<3) + 6] + (id_info[(i<<3) + 7]<<8); |
| 300 | | |
| 301 | | thedrive->sector_offsets[i] = sector_offset; |
| 302 | | sector_offset+=sector_size; |
| 303 | | } |
| 304 | | } |
| 305 | | } |
| 306 | | |
| 307 | | |
| 308 | | |
| 309 | | static void dsk_disk_image_init(dsk_drive *thedrive) |
| 310 | | { |
| 311 | | /*-----------------27/02/00 11:26------------------- |
| 312 | | clear offsets |
| 313 | | --------------------------------------------------*/ |
| 314 | | memset(&thedrive->track_offsets[0], 0, dsk_MAX_TRACKS*dsk_MAX_SIDES*sizeof(unsigned long)); |
| 315 | | memset(&thedrive->sector_offsets[0], 0, 20*sizeof(unsigned long)); |
| 316 | | |
| 317 | | if (memcmp(thedrive->data,"MV - CPC",8)==0) |
| 318 | | { |
| 319 | | thedrive->disk_image_type = 0; |
| 320 | | |
| 321 | | /* standard disk image */ |
| 322 | | dsk_dsk_init_track_offsets(thedrive); |
| 323 | | |
| 324 | | } |
| 325 | | else |
| 326 | | if (memcmp(thedrive->data,"EXTENDED",8)==0) |
| 327 | | { |
| 328 | | thedrive->disk_image_type = 1; |
| 329 | | |
| 330 | | /* extended disk image */ |
| 331 | | dsk_extended_dsk_init_track_offsets(thedrive); |
| 332 | | } |
| 333 | | } |
| 334 | | |
| 335 | | |
| 336 | | static void dsk_seek_callback(const device_config *img, int physical_track) |
| 337 | | { |
| 338 | | get_drive(img)->current_track = physical_track; |
| 339 | | } |
| 340 | | |
| 341 | | static int get_track_offset(const device_config *img, int side) |
| 342 | | { |
| 343 | | dsk_drive *thedrive = get_drive(img); |
| 344 | | side = side & 0x01; |
| 345 | | return thedrive->track_offsets[(thedrive->current_track<<1) + side]; |
| 346 | | } |
| 347 | | |
| 348 | | static unsigned char *get_floppy_data(const device_config *img) |
| 349 | | { |
| 350 | | return get_drive(img)->data; |
| 351 | | } |
| 352 | | |
| 353 | | static void dsk_get_id_callback(const device_config *img, chrn_id *id, int id_index, int side) |
| 354 | | { |
| 355 | | int id_offset; |
| 356 | | int track_offset; |
| 357 | | unsigned char *track_header; |
| 358 | | unsigned char *data; |
| 359 | | |
| 360 | | side = side & 0x01; |
| 361 | | |
| 362 | | /* get offset to track header in image */ |
| 363 | | track_offset = get_track_offset(img, side); |
| 364 | | |
| 365 | | /* track exists? */ |
| 366 | | if (track_offset==0) |
| 367 | | return; |
| 368 | | |
| 369 | | /* yes */ |
| 370 | | data = get_floppy_data(img); |
| 371 | | |
| 372 | | if (data==0) |
| 373 | | return; |
| 374 | | |
| 375 | | track_header = data + track_offset; |
| 376 | | |
| 377 | | id_offset = 0x018 + (id_index<<3); |
| 378 | | |
| 379 | | id->C = track_header[id_offset + 0]; |
| 380 | | id->H = track_header[id_offset + 1]; |
| 381 | | id->R = track_header[id_offset + 2]; |
| 382 | | id->N = track_header[id_offset + 3]; |
| 383 | | id->flags = 0; |
| 384 | | id->data_id = id_index; |
| 385 | | |
| 386 | | if (track_header[id_offset + 5] & 0x040) |
| 387 | | { |
| 388 | | id->flags |= ID_FLAG_DELETED_DATA; |
| 389 | | } |
| 390 | | |
| 391 | | |
| 392 | | |
| 393 | | |
| 394 | | // id->ST0 = track_header[id_offset + 4]; |
| 395 | | // id->ST1 = track_header[id_offset + 5]; |
| 396 | | |
| 397 | | } |
| 398 | | |
| 399 | | |
| 400 | | static void dsk_set_ddam(const device_config *img, int id_index, int side, int ddam) |
| 401 | | { |
| 402 | | int id_offset; |
| 403 | | int track_offset; |
| 404 | | unsigned char *track_header; |
| 405 | | unsigned char *data; |
| 406 | | |
| 407 | | side = side & 0x01; |
| 408 | | |
| 409 | | /* get offset to track header in image */ |
| 410 | | track_offset = get_track_offset(img, side); |
| 411 | | |
| 412 | | /* track exists? */ |
| 413 | | if (track_offset==0) |
| 414 | | return; |
| 415 | | |
| 416 | | /* yes */ |
| 417 | | data = get_floppy_data(img); |
| 418 | | |
| 419 | | if (data==0) |
| 420 | | return; |
| 421 | | |
| 422 | | track_header = data + track_offset; |
| 423 | | |
| 424 | | id_offset = 0x018 + (id_index<<3); |
| 425 | | |
| 426 | | track_header[id_offset + 5] &= ~0x040; |
| 427 | | |
| 428 | | if (ddam) |
| 429 | | { |
| 430 | | track_header[id_offset + 5] |= 0x040; |
| 431 | | } |
| 432 | | } |
| 433 | | |
| 434 | | |
| 435 | | static char * dsk_get_sector_ptr_callback(const device_config *img, int sector_index, int side) |
| 436 | | { |
| 437 | | int track_offset; |
| 438 | | int sector_offset; |
| 439 | | int track; |
| 440 | | dsk_drive *thedrive; |
| 441 | | unsigned char *data; |
| 442 | | |
| 443 | | side = side & 0x01; |
| 444 | | |
| 445 | | thedrive = get_drive(img); |
| 446 | | |
| 447 | | track = thedrive->current_track; |
| 448 | | |
| 449 | | /* offset to track header in image */ |
| 450 | | track_offset = get_track_offset(img, side); |
| 451 | | |
| 452 | | /* track exists? */ |
| 453 | | if (track_offset==0) |
| 454 | | return NULL; |
| 455 | | |
| 456 | | |
| 457 | | /* setup sector offsets */ |
| 458 | | switch (thedrive->disk_image_type) |
| 459 | | { |
| 460 | | case 0: |
| 461 | | dsk_dsk_init_sector_offsets(thedrive,track, side); |
| 462 | | break; |
| 463 | | |
| 464 | | |
| 465 | | case 1: |
| 466 | | dsk_extended_dsk_init_sector_offsets(thedrive, track, side); |
| 467 | | break; |
| 468 | | |
| 469 | | default: |
| 470 | | break; |
| 471 | | } |
| 472 | | |
| 473 | | sector_offset = thedrive->sector_offsets[sector_index]; |
| 474 | | |
| 475 | | data = get_floppy_data(img); |
| 476 | | |
| 477 | | if (data==0) |
| 478 | | return NULL; |
| 479 | | |
| 480 | | return (char *)(data + track_offset + sector_offset); |
| 481 | | } |
| 482 | | |
| 483 | | static void dsk_write_sector_data_from_buffer(const device_config *img, int side, int index1, const char *ptr, int length, int ddam) |
| 484 | | { |
| 485 | | char * pSectorData; |
| 486 | | |
| 487 | | pSectorData = dsk_get_sector_ptr_callback(img, index1, side); |
| 488 | | |
| 489 | | if (pSectorData!=NULL) |
| 490 | | { |
| 491 | | memcpy(pSectorData, ptr, length); |
| 492 | | } |
| 493 | | |
| 494 | | /* set ddam */ |
| 495 | | dsk_set_ddam(img, index1, side,ddam); |
| 496 | | } |
| 497 | | |
| 498 | | static void dsk_read_sector_data_into_buffer(const device_config *img, int side, int index1, char *ptr, int length) |
| 499 | | { |
| 500 | | char *pSectorData; |
| 501 | | |
| 502 | | pSectorData = dsk_get_sector_ptr_callback(img, index1, side); |
| 503 | | |
| 504 | | if (pSectorData!=NULL) |
| 505 | | memcpy(ptr, pSectorData, length); |
| 506 | | } |
| 507 | | |
| 508 | | static int dsk_get_sectors_per_track(const device_config *img, int side) |
| 509 | | { |
| 510 | | int track_offset; |
| 511 | | unsigned char *track_header; |
| 512 | | unsigned char *data; |
| 513 | | |
| 514 | | side = side & 0x01; |
| 515 | | |
| 516 | | /* get offset to track header in image */ |
| 517 | | track_offset = get_track_offset(img, side); |
| 518 | | |
| 519 | | /* track exists? */ |
| 520 | | if (track_offset==0) |
| 521 | | return 0; |
| 522 | | |
| 523 | | data = get_floppy_data(img); |
| 524 | | |
| 525 | | if (data==0) |
| 526 | | return 0; |
| 527 | | |
| 528 | | /* yes, get sectors per track */ |
| 529 | | track_header = data + track_offset; |
| 530 | | |
| 531 | | return track_header[0x015]; |
| 532 | | } |
| 533 | | |
| 534 | | |
| 535 | | |
| 536 | | void legacydsk_device_getinfo(const mess_device_class *devclass, UINT32 state, union devinfo *info) |
| 537 | | { |
| 538 | | switch(state) |
| 539 | | { |
| 540 | | /* --- the following bits of info are returned as 64-bit signed integers --- */ |
| 541 | | case MESS_DEVINFO_INT_TYPE: info->i = IO_FLOPPY; break; |
| 542 | | case MESS_DEVINFO_INT_READABLE: info->i = 1; break; |
| 543 | | case MESS_DEVINFO_INT_WRITEABLE: info->i = 1; break; |
| 544 | | case MESS_DEVINFO_INT_CREATABLE: info->i = 0; break; |
| 545 | | |
| 546 | | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| 547 | | case MESS_DEVINFO_PTR_START: info->start = DEVICE_START_NAME(dsk_floppy); break; |
| 548 | | case MESS_DEVINFO_PTR_LOAD: info->load = DEVICE_IMAGE_LOAD_NAME(dsk_floppy); break; |
| 549 | | case MESS_DEVINFO_PTR_UNLOAD: info->unload = DEVICE_IMAGE_UNLOAD_NAME(dsk_floppy); break; |
| 550 | | |
| 551 | | /* --- the following bits of info are returned as NULL-terminated strings --- */ |
| 552 | | case MESS_DEVINFO_STR_DEV_FILE: strcpy(info->s = device_temp_str(), __FILE__); break; |
| 553 | | case MESS_DEVINFO_STR_FILE_EXTENSIONS: strcpy(info->s = device_temp_str(), "dsk"); break; |
| 554 | | } |
| 555 | | } |
| 556 | | |
src/mess/formats/dsk_dsk.c
| r0 | r5672 | |
| 1 | /********************************************************************* |
| 2 | |
| 3 | formats/dsk_dsk.c |
| 4 | |
| 5 | DSK disk images |
| 6 | |
| 7 | *********************************************************************/ |
| 8 | |
| 9 | #include <string.h> |
| 10 | #include "driver.h" |
| 11 | #include "formats/dsk_dsk.h" |
| 12 | #include "devices/flopdrv.h" |
| 13 | |
| 14 | #define MV_CPC "MV - CPC" |
| 15 | #define EXTENDED "EXTENDED" |
| 16 | |
| 17 | #define dskDSK_TAG "dskdsktag" |
| 18 | |
| 19 | struct dskdsk_tag |
| 20 | { |
| 21 | int disk_image_type; /* image type: standard or extended */ |
| 22 | int heads; |
| 23 | int tracks; |
| 24 | int tracksize; |
| 25 | int sector_size; |
| 26 | }; |
| 27 | |
| 28 | |
| 29 | static struct dskdsk_tag *get_tag(floppy_image *floppy) |
| 30 | { |
| 31 | struct dskdsk_tag *tag; |
| 32 | tag = floppy_tag(floppy, dskDSK_TAG); |
| 33 | return tag; |
| 34 | } |
| 35 | |
| 36 | |
| 37 | |
| 38 | static FLOPPY_IDENTIFY(dsk_dsk_identify) |
| 39 | { |
| 40 | UINT8 header[8]; |
| 41 | |
| 42 | floppy_image_read(floppy, header, 0, 8); |
| 43 | if ( memcmp( header, MV_CPC, 8 ) ==0) { |
| 44 | *vote = 100; |
| 45 | } else |
| 46 | if ( memcmp( header, EXTENDED, 8 ) ==0) { |
| 47 | *vote = 100; |
| 48 | } else { |
| 49 | *vote = 0; |
| 50 | } |
| 51 | return FLOPPY_ERROR_SUCCESS; |
| 52 | } |
| 53 | |
| 54 | static int dsk_get_heads_per_disk(floppy_image *floppy) |
| 55 | { |
| 56 | return get_tag(floppy)->heads; |
| 57 | } |
| 58 | |
| 59 | static int dsk_get_tracks_per_disk(floppy_image *floppy) |
| 60 | { |
| 61 | return get_tag(floppy)->tracks; |
| 62 | } |
| 63 | |
| 64 | static UINT64 dsk_get_track_offset(floppy_image *floppy, int head, int track) |
| 65 | { |
| 66 | return 0x100 + get_tag(floppy)->tracksize * ((track * get_tag(floppy)->heads) + head); |
| 67 | } |
| 68 | |
| 69 | static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset) |
| 70 | { |
| 71 | UINT64 offs; |
| 72 | UINT64 track_offset; |
| 73 | UINT8 track_info[0x100]; |
| 74 | UINT8 sectors_per_track; |
| 75 | int i; |
| 76 | /* translate the sector to a raw sector */ |
| 77 | |
| 78 | if (!sector_is_index) |
| 79 | { |
| 80 | sector -= 1; |
| 81 | } |
| 82 | |
| 83 | /* check to see if we are out of range */ |
| 84 | if ((head < 0) || (head >= get_tag(floppy)->heads) || (track < 0) || (track >= get_tag(floppy)->tracks) |
| 85 | || (sector < 0) ) |
| 86 | return FLOPPY_ERROR_SEEKERROR; |
| 87 | |
| 88 | track_offset = dsk_get_track_offset(floppy, head, track); |
| 89 | |
| 90 | floppy_image_read(floppy, track_info, track_offset, 0x100); |
| 91 | |
| 92 | sectors_per_track = track_info[0x015]; |
| 93 | if (sector >= sectors_per_track) { |
| 94 | return FLOPPY_ERROR_SEEKERROR; |
| 95 | } |
| 96 | |
| 97 | if (get_tag(floppy)->disk_image_type==0) { |
| 98 | get_tag(floppy)->sector_size = (1<<(track_info[0x014]+7)); |
| 99 | offs = track_offset + 0x100 +sector * get_tag(floppy)->sector_size; |
| 100 | } else { |
| 101 | get_tag(floppy)->sector_size = track_info[0x18 + (sector<<3) + 6] + (track_info[0x18+(sector<<3) + 7]<<8); |
| 102 | offs = track_offset + 0x100; |
| 103 | for (i=0;i<sector;i++) { |
| 104 | offs += track_info[0x18 + (i<<3) + 6] + (track_info[0x18+(i<<3) + 7]<<8); |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | if (offset) |
| 109 | *offset = offs; |
| 110 | return FLOPPY_ERROR_SUCCESS; |
| 111 | } |
| 112 | |
| 113 | |
| 114 | |
| 115 | static floperr_t internal_dsk_read_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, void *buffer, size_t buflen) |
| 116 | { |
| 117 | UINT64 offset; |
| 118 | floperr_t err; |
| 119 | err = get_offset(floppy, head, track, sector, sector_is_index, &offset); |
| 120 | if (err) |
| 121 | return err; |
| 122 | floppy_image_read(floppy, buffer, offset, buflen); |
| 123 | return FLOPPY_ERROR_SUCCESS; |
| 124 | } |
| 125 | |
| 126 | |
| 127 | |
| 128 | static floperr_t internal_dsk_write_sector(floppy_image *floppy, int head, int track, int sector, int sector_is_index, const void *buffer, size_t buflen, int ddam) |
| 129 | { |
| 130 | UINT64 offset; |
| 131 | floperr_t err; |
| 132 | |
| 133 | err = get_offset(floppy, head, track, sector, sector_is_index, &offset); |
| 134 | if (err) |
| 135 | return err; |
| 136 | |
| 137 | floppy_image_write(floppy, buffer, offset, buflen); |
| 138 | return FLOPPY_ERROR_SUCCESS; |
| 139 | } |
| 140 | |
| 141 | |
| 142 | |
| 143 | static floperr_t dsk_read_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen) |
| 144 | { |
| 145 | return internal_dsk_read_sector(floppy, head, track, sector, FALSE, buffer, buflen); |
| 146 | } |
| 147 | |
| 148 | static floperr_t dsk_write_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam) |
| 149 | { |
| 150 | return internal_dsk_write_sector(floppy, head, track, sector, FALSE, buffer, buflen, ddam); |
| 151 | } |
| 152 | |
| 153 | static floperr_t dsk_read_indexed_sector(floppy_image *floppy, int head, int track, int sector, void *buffer, size_t buflen) |
| 154 | { |
| 155 | return internal_dsk_read_sector(floppy, head, track, sector, TRUE, buffer, buflen); |
| 156 | } |
| 157 | |
| 158 | static floperr_t dsk_write_indexed_sector(floppy_image *floppy, int head, int track, int sector, const void *buffer, size_t buflen, int ddam) |
| 159 | { |
| 160 | return internal_dsk_write_sector(floppy, head, track, sector, TRUE, buffer, buflen, ddam); |
| 161 | } |
| 162 | |
| 163 | static floperr_t dsk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length) |
| 164 | { |
| 165 | floperr_t err; |
| 166 | err = get_offset(floppy, head, track, sector, FALSE, NULL); |
| 167 | if (err) |
| 168 | return err; |
| 169 | |
| 170 | if (sector_length) { |
| 171 | *sector_length = get_tag(floppy)->sector_size; |
| 172 | } |
| 173 | return FLOPPY_ERROR_SUCCESS; |
| 174 | } |
| 175 | |
| 176 | static floperr_t dsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags) |
| 177 | { |
| 178 | floperr_t retVal; |
| 179 | UINT64 offset; |
| 180 | UINT8 sector_info[0x100]; |
| 181 | int pos; |
| 182 | |
| 183 | retVal = get_offset(floppy, head, track, sector_index+1, TRUE, NULL); |
| 184 | offset = dsk_get_track_offset(floppy,head,track); |
| 185 | pos = 0x18 + (sector_index << 3); |
| 186 | floppy_image_read(floppy, sector_info, offset, 0x100); |
| 187 | if (cylinder) |
| 188 | *cylinder = sector_info[pos + 0]; |
| 189 | if (side) |
| 190 | *side = sector_info[pos + 1]; |
| 191 | if (sector) |
| 192 | *sector = sector_info[pos + 2]; |
| 193 | if (sector_length) { |
| 194 | *sector_length = 1 << (sector_info[pos + 3] + 7); |
| 195 | } |
| 196 | if (flags) |
| 197 | *flags = (sector_info[pos + 5] & 0x40) ? ID_FLAG_DELETED_DATA : 0; |
| 198 | return retVal; |
| 199 | } |
| 200 | |
| 201 | |
| 202 | static FLOPPY_CONSTRUCT(dsk_dsk_construct) |
| 203 | { |
| 204 | struct FloppyCallbacks *callbacks; |
| 205 | struct dskdsk_tag *tag; |
| 206 | UINT8 header[0x100]; |
| 207 | |
| 208 | floppy_image_read(floppy, header, 0, 0x100); |
| 209 | |
| 210 | tag = (struct dskdsk_tag *) floppy_create_tag(floppy, dskDSK_TAG, sizeof(struct dskdsk_tag)); |
| 211 | if (!tag) |
| 212 | return FLOPPY_ERROR_OUTOFMEMORY; |
| 213 | |
| 214 | tag->heads = header[0x31]; |
| 215 | tag->tracks = header[0x30]; |
| 216 | |
| 217 | if ( memcmp( header, MV_CPC, 8 ) ==0) { |
| 218 | tag->disk_image_type = 0; |
| 219 | tag->tracksize = pick_integer_le(header, 0x32, 2); |
| 220 | } else { |
| 221 | tag->disk_image_type = 1; |
| 222 | tag->tracksize = header[0x34] << 8; |
| 223 | } |
| 224 | |
| 225 | callbacks = floppy_callbacks(floppy); |
| 226 | callbacks->read_sector = dsk_read_sector; |
| 227 | callbacks->write_sector = dsk_write_sector; |
| 228 | callbacks->read_indexed_sector = dsk_read_indexed_sector; |
| 229 | callbacks->write_indexed_sector = dsk_write_indexed_sector; |
| 230 | callbacks->get_sector_length = dsk_get_sector_length; |
| 231 | callbacks->get_heads_per_disk = dsk_get_heads_per_disk; |
| 232 | callbacks->get_tracks_per_disk = dsk_get_tracks_per_disk; |
| 233 | callbacks->get_indexed_sector_info = dsk_get_indexed_sector_info; |
| 234 | return FLOPPY_ERROR_SUCCESS; |
| 235 | } |
| 236 | /* ----------------------------------------------------------------------- */ |
| 237 | |
| 238 | FLOPPY_OPTIONS_START(dsk ) |
| 239 | FLOPPY_OPTION( dsk, "dsk", "DSK floppy disk image", dsk_dsk_identify, dsk_dsk_construct, NULL) |
| 240 | FLOPPY_OPTIONS_END |