![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to disk.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1.1.2 root 1: /*
1.1 root 2: * UAE - The Un*x Amiga Emulator
1.1.1.2 root 3: *
1.1 root 4: * Floppy disk emulation
5: *
1.1.1.11 root 6: * Copyright 1995 Hannu Rummukainen
7: * Copyright 1995-2001 Bernd Schmidt
8: * Copyright 2000, 2001 Toni Wilen
9: *
10: * High Density Drive Handling by Dr. Adil Temel (C) 2001 [[email protected]]
11: *
1.1 root 12: */
13:
1.1.1.2 root 14: #include <stdio.h>
15:
1.1 root 16: #include "sysconfig.h"
17: #include "sysdeps.h"
18:
19: #include "config.h"
20: #include "options.h"
1.1.1.12 root 21: #include "threaddep/thread.h"
1.1 root 22: #include "memory.h"
23: #include "events.h"
24: #include "custom.h"
25: #include "ersatz.h"
26: #include "disk.h"
27: #include "gui.h"
28: #include "zfile.h"
1.1.1.2 root 29: #include "autoconf.h"
30: #include "newcpu.h"
31: #include "xwin.h"
32: #include "osemu.h"
33: #include "execlib.h"
1.1.1.11 root 34: #include "savestate.h"
1.1.1.2 root 35:
1.1.1.7 root 36: /* writable track length with normal 2us bitcell/300RPM motor */
1.1.1.13! root 37: #define FLOPPY_WRITE_LEN (12650 / 2)
! 38: /* This works out to 341 */
! 39: #define FLOPPY_GAP_LEN (FLOPPY_WRITE_LEN - 11 * 544)
1.1.1.7 root 40: /* (cycles/bitcell) << 8, normal = ((2us/280ns)<<8) = ~1830 */
41: #define NORMAL_FLOPPY_SPEED 1830
42:
43: static int floppy_speed = NORMAL_FLOPPY_SPEED;
44:
45: #undef DISK_DEBUG
1.1.1.11 root 46: #undef DEBUG_DRIVE_ID
1.1.1.7 root 47:
48: /* UAE-1ADF (ADF_EXT2)
49: * W reserved
50: * W number of tracks (default 2*80=160)
51: *
52: * W reserved
53: * W type, 0=normal AmigaDOS track, 1 = raw MFM
54: * L available space for track in bytes
55: * L track length in bits
56: */
1.1 root 57:
1.1.1.11 root 58: static int side, direction, writing;
1.1.1.12 root 59: static uae_u8 selected = 15, disabled;
1.1 root 60:
1.1.1.11 root 61: static uae_u8 *writebuffer[544 * 22];
1.1.1.7 root 62:
63: typedef enum { TRACK_AMIGADOS, TRACK_RAW, TRACK_RAW1 } image_tracktype;
1.1 root 64: typedef struct {
1.1.1.3 root 65: uae_u16 len;
66: uae_u32 offs;
1.1.1.7 root 67: int bitlen;
68: unsigned int sync;
69: image_tracktype type;
1.1 root 70: } trackid;
71:
1.1.1.2 root 72: #define MAX_TRACKS 328
73:
1.1.1.11 root 74: #define DRIVE_ID_NONE 0xFFFFFFFF
75: #define DRIVE_ID_35DD 0x00000000
76: #define DRIVE_ID_35HD 0xAAAAAAAA
77: #define DRIVE_ID_525DD 0x55555555 /* 40 track 5.25 drive , kickstart does not recognize this */
78:
1.1.1.7 root 79: typedef enum { ADF_NORMAL, ADF_EXT1, ADF_EXT2 } drive_filetype;
1.1 root 80: typedef struct {
81: FILE *diskfile;
82: drive_filetype filetype;
1.1.1.2 root 83: trackid trackdata[MAX_TRACKS];
1.1.1.7 root 84: int buffered_cyl, buffered_side;
85: int cyl;
1.1 root 86: int motoroff;
1.1.1.7 root 87: int state;
1.1 root 88: int wrprot;
1.1.1.11 root 89: uae_u16 bigmfmbuf[0x8000];
1.1 root 90: int mfmpos;
1.1.1.7 root 91: int tracklen;
92: int trackspeed;
93: int dmalen;
94: int num_tracks, num_secs;
1.1.1.3 root 95: int dskchange;
96: int dskchange_time;
1.1.1.10 root 97: int dskready;
98: int dskready_time;
1.1.1.11 root 99: int steplimit;
100: int ddhd; /* 1=DD 2=HD */
101: int drive_id_scnt; /* drive id shift counter */
102: unsigned long drive_id; /* drive id to be reported */
1.1.1.12 root 103: char newname[256]; /* storage space for new filename during eject delay */
1.1 root 104: } drive;
105:
1.1.1.11 root 106: static drive floppy[4];
107:
108: /* Keeps track of whether the Amiga program seems to be using the data coming
109: in from the disk; if this remains 0 for several seconds, we stop calling
110: disk_doupdate_read, even if the motor is still on. This is a rather large
111: performance win. This contains the number of frames since we last accessed
112: the disk. */
113: static int disk_data_used;
114:
115: #ifdef DEBUG_DRIVE_ID
116: static char *drive_id_name(drive *drv)
117: {
118: switch(drv->drive_id)
119: {
120: case DRIVE_ID_35HD : return "3.5HD";
121: case DRIVE_ID_525DD: return "5.25DD";
122: case DRIVE_ID_35DD : return "3.5DD";
123: }
124: return "UNKNOWN";
125: }
126: #endif
127:
128: /* Simulate exact behaviour of an A3000T 3.5 HD disk drive.
129: * The drive reports to be a 3.5 DD drive whenever there is no
130: * disk or a 3.5 DD disk is inserted. Only 3.5 HD drive id is reported
131: * when a real 3.5 HD disk is inserted. -Adil
132: */
133: static void drive_settype_id(drive *drv)
134: {
135: if (!drv->diskfile || drv->num_secs == 11) {
136: /* Double density */
137: drv->drive_id = DRIVE_ID_35DD;
138: drv->ddhd = 1;
139: } else {
140: /* High density */
141: drv->drive_id = DRIVE_ID_35HD;
142: drv->ddhd = 2;
143: }
144: drv->drive_id_scnt = 0;
145: #ifdef DEBUG_DRIVE_ID
146: write_log("drive_settype_id: DF%d: set to %s\n",drv-floppy, drive_id_name(drv));
147: #endif
148: }
1.1 root 149:
1.1.1.7 root 150: /* code for track display */
1.1.1.8 root 151: static void update_drive_gui (int num)
1.1.1.7 root 152: {
1.1.1.8 root 153: drive *drv = floppy + num;
154:
1.1.1.7 root 155: if (drv->state == gui_data.drive_motor[num]
156: && drv->cyl == gui_data.drive_track[num]
157: && ((writing && gui_data.drive_writing[num])
158: || (!writing && !gui_data.drive_writing[num]))) {
159: return;
160: }
161: gui_data.drive_motor[num] = drv->state;
162: gui_data.drive_track[num] = drv->cyl;
163: if (!gui_data.drive_writing[num])
164: gui_data.drive_writing[num] = writing;
1.1.1.8 root 165: gui_ledstate &= ~(2 << num);
166: if (drv->state)
167: gui_ledstate |= 2 << num;
1.1.1.7 root 168: gui_led (num + 1, gui_data.drive_motor[num]);
169: }
170:
171: static void drive_fill_bigbuf (drive * drv);
1.1 root 172:
1.1.1.3 root 173: FILE *DISK_validate_filename (const char *fname, int leave_open, int *wrprot)
1.1 root 174: {
1.1.1.4 root 175: FILE *f = zfile_open (fname, "r+b");
1.1.1.3 root 176: if (f) {
177: if (wrprot)
178: *wrprot = 0;
1.1 root 179: } else {
1.1.1.3 root 180: if (wrprot)
181: *wrprot = 1;
1.1.1.4 root 182: f = zfile_open (fname, "rb");
1.1 root 183: }
1.1.1.3 root 184: if (!leave_open)
1.1.1.4 root 185: zfile_close (f);
1.1.1.3 root 186: return f;
187: }
188:
1.1.1.7 root 189: static int drive_insert (drive * drv, int dnum, const char *fname)
1.1.1.3 root 190: {
1.1.1.7 root 191: unsigned char buffer[2 + 2 + 4 + 4];
192: trackid *tid;
1.1.1.3 root 193:
194: drv->diskfile = DISK_validate_filename (fname, 1, &drv->wrprot);
1.1.1.6 root 195: if (drv->diskfile == 0) {
1.1.1.7 root 196: drv->tracklen = FLOPPY_WRITE_LEN * 2 * 8;
197: drv->trackspeed = floppy_speed;
1.1.1.3 root 198: return 0;
1.1.1.6 root 199: }
1.1.1.3 root 200: strncpy (currprefs.df[dnum], fname, 255);
201: currprefs.df[dnum][255] = 0;
202: strncpy (changed_prefs.df[dnum], fname, 255);
203: changed_prefs.df[dnum][255] = 0;
1.1.1.7 root 204: gui_filename (dnum, fname);
1.1.1.3 root 205:
1.1.1.7 root 206: fread (buffer, sizeof (char), 8, drv->diskfile);
207: if (strncmp ((char *) buffer, "UAE-1ADF", 8) == 0) {
208: int offs;
209: int i;
210:
211: fread (buffer, 1, 4, drv->diskfile);
212: drv->num_tracks = buffer[2] * 256 + buffer[3];
213: drv->filetype = ADF_EXT2;
214: drv->num_secs = 11;
1.1.1.10 root 215: offs = 8 + 2 + 2 + drv->num_tracks * (2 + 2 + 4 + 4);
1.1.1.7 root 216:
217: for (i = 0; i < drv->num_tracks; i++) {
218: tid = &drv->trackdata[i];
219: fread (buffer, 2 + 2 + 4 + 4, 1, drv->diskfile);
220: tid->type = buffer[2] * 256 + buffer[3];
221: tid->len = buffer[5] * 65536 + buffer[6] * 256 + buffer[7];
222: tid->bitlen = buffer[9] * 65536 + buffer[10] * 256 + buffer[11];
223: tid->offs = offs;
224: if (tid->type == TRACK_AMIGADOS) {
225: if (tid->len > 20000)
226: drv->num_secs = 22;
227: }
228: offs += tid->len;
229: }
230: } else if (strncmp ((char *) buffer, "UAE--ADF", 8) == 0) {
231: int offs = 160 * 4 + 8;
1.1 root 232: int i;
1.1.1.3 root 233:
234: drv->filetype = ADF_EXT1;
1.1.1.2 root 235: drv->num_tracks = 160;
236: drv->num_secs = 11;
1.1.1.3 root 237:
1.1.1.7 root 238: drv->wrprot = 1; /* write to adf_ext1 not implemented */
239: for (i = 0; i < 160; i++) {
240: tid = &drv->trackdata[i];
241: fread (buffer, 4, 1, drv->diskfile);
242: tid->sync = buffer[0] * 256 + buffer[1];
243: tid->len = buffer[2] * 256 + buffer[3];
244: tid->offs = offs;
245: if (tid->sync == 0) {
246: tid->type = TRACK_AMIGADOS;
247: tid->bitlen = 0;
248: } else {
249: tid->type = TRACK_RAW1;
250: tid->bitlen = tid->len * 8;
251: }
252: offs += tid->len;
1.1 root 253: }
254: } else {
1.1.1.7 root 255: int i;
1.1.1.3 root 256:
257: drv->filetype = ADF_NORMAL;
1.1.1.2 root 258:
1.1.1.7 root 259: fseek (drv->diskfile, 0, SEEK_END);
1.1.1.4 root 260: i = ftell (drv->diskfile);
1.1.1.7 root 261: fseek (drv->diskfile, 0, SEEK_SET);
1.1.1.3 root 262:
1.1.1.2 root 263: /* High-density disk? */
1.1.1.7 root 264: if (i >= 160 * 22 * 512)
265: drv->num_tracks = i / (512 * (drv->num_secs = 22));
1.1.1.2 root 266: else
1.1.1.7 root 267: drv->num_tracks = i / (512 * (drv->num_secs = 11));
1.1.1.3 root 268:
1.1.1.2 root 269: if (drv->num_tracks > MAX_TRACKS)
1.1.1.3 root 270: write_log ("Your diskfile is too big!\n");
1.1.1.7 root 271: for (i = 0; i < drv->num_tracks; i++) {
272: tid = &drv->trackdata[i];
273: tid->type = TRACK_AMIGADOS;
274: tid->len = 512 * drv->num_secs;
275: tid->bitlen = 0;
276: tid->offs = i * 512 * drv->num_secs;
1.1 root 277: }
278: }
1.1.1.11 root 279: drive_settype_id(drv); /* Set DD or HD drive */
1.1.1.7 root 280: drv->buffered_side = 2; /* will force read */
1.1.1.6 root 281: drive_fill_bigbuf (drv);
1.1.1.3 root 282: return 1;
1.1 root 283: }
284:
1.1.1.7 root 285: static int drive_empty (drive * drv)
1.1.1.2 root 286: {
1.1.1.3 root 287: return drv->diskfile == 0;
1.1.1.2 root 288: }
289:
1.1.1.7 root 290: static void drive_step (drive * drv)
1.1 root 291: {
1.1.1.11 root 292: if (drv->steplimit)
293: return;
294: /* A1200's floppy drive needs at least 30 raster lines between steps
295: * but we'll use very small value for better compatibility with faster CPU emulation
296: * (stupid trackloaders with CPU delay loops)
297: */
298: drv->steplimit = 2;
1.1.1.12 root 299: if (!drive_empty (drv))
300: drv->dskchange = 0;
1.1 root 301: if (direction) {
1.1.1.7 root 302: if (drv->cyl)
303: drv->cyl--;
1.1.1.11 root 304: /* else
305: write_log("program tried to step beyond track zero\n");
306: "no-click" programs does that
307: */
308: } else {
1.1.1.7 root 309: if (drv->cyl < 83)
310: drv->cyl++;
1.1.1.11 root 311: else
312: write_log("program tried to step over track 83\n");
1.1 root 313: }
314:
1.1.1.7 root 315: #if 0 && defined DISK_DEBUG
316: write_log ("track %d\n", drv->cyl);
317: #endif
318: }
1.1 root 319:
1.1.1.7 root 320: static int drive_track0 (drive * drv)
1.1 root 321: {
1.1.1.3 root 322: return drv->cyl == 0;
1.1 root 323: }
324:
1.1.1.7 root 325: static int drive_writeprotected (drive * drv)
1.1 root 326: {
1.1.1.3 root 327: return drv->wrprot || drv->diskfile == NULL;
1.1 root 328: }
329:
1.1.1.7 root 330: static int drive_running (drive * drv)
1.1 root 331: {
1.1.1.3 root 332: return !drv->motoroff;
1.1 root 333: }
334:
1.1.1.7 root 335: static void drive_motor (drive * drv, int off)
1.1 root 336: {
1.1.1.12 root 337: /* A value of 5 works out to a guaranteed delay of 1/2 of a second
1.1.1.10 root 338: Higher values are dangerous, e.g. a value of 8 breaks the RSI
339: demo. */
1.1.1.11 root 340: if (drv->motoroff && !off) {
1.1.1.12 root 341: drv->dskready_time = 5;
1.1.1.11 root 342: disk_data_used = 0;
343: drv->drive_id_scnt = 0; /* Reset id shift reg counter */
344: #ifdef DEBUG_DRIVE_ID
345: write_log("drive_motor: Selected DF%d: reset id shift reg.\n",drv-floppy);
346: #endif
347: }
1.1 root 348: drv->motoroff = off;
1.1.1.10 root 349: if (drv->motoroff) {
350: drv->dskready = 0;
351: drv->dskready_time = 0;
352: }
1.1 root 353: }
354:
1.1.1.7 root 355: static void read_floppy_data (drive * drv, int track, int offset, unsigned char *dst, int len)
356: {
357: trackid *ti;
358:
359: ti = &drv->trackdata[track];
360: fseek (drv->diskfile, ti->offs + offset, SEEK_SET);
361: fread (dst, 1, len, drv->diskfile);
362: }
363:
364: /* Megalomania does not like zero MFM words... */
365: static void mfmcode (uae_u16 * mfm, int words)
366: {
1.1.1.8 root 367: uae_u32 lastword = 0;
1.1.1.7 root 368:
369: while (words--) {
1.1.1.8 root 370: uae_u32 v = *mfm;
371: uae_u32 lv = (lastword << 16) | v;
372: uae_u32 nlv = 0x55555555 & ~lv;
373: uae_u32 mfmbits = (nlv << 1) & (nlv >> 1);
374:
375: *mfm++ = v | mfmbits;
376: lastword = v;
1.1.1.7 root 377: }
378: }
379:
380: static void drive_fill_bigbuf (drive * drv)
1.1 root 381: {
1.1.1.7 root 382: int tr = drv->cyl * 2 + side;
383: trackid *ti = drv->trackdata + tr;
1.1.1.3 root 384:
1.1.1.7 root 385: if (!drv->diskfile || tr >= drv->num_tracks) {
1.1.1.11 root 386: drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 2 * 8;
1.1.1.7 root 387: drv->trackspeed = floppy_speed;
1.1.1.11 root 388: memset (drv->bigmfmbuf, 0xaa, FLOPPY_WRITE_LEN * 2 * drv->ddhd);
1.1.1.2 root 389: return;
390: }
1.1.1.3 root 391: if (drv->buffered_cyl == drv->cyl && drv->buffered_side == side)
392: return;
393:
1.1.1.7 root 394: if (ti->type == TRACK_AMIGADOS) {
1.1 root 395: /* Normal AmigaDOS format track */
1.1.1.7 root 396: int sec;
397: drv->tracklen = (drv->num_secs * 544 + FLOPPY_GAP_LEN) * 2 * 8;
398: memset (drv->bigmfmbuf, 0xaa, FLOPPY_GAP_LEN * 2);
1.1.1.2 root 399:
400: for (sec = 0; sec < drv->num_secs; sec++) {
1.1.1.3 root 401: uae_u8 secbuf[544];
1.1 root 402: int i;
1.1.1.7 root 403: uae_u16 *mfmbuf = drv->bigmfmbuf + 544 * sec + FLOPPY_GAP_LEN;
404: uae_u32 deven, dodd;
405: uae_u32 hck = 0, dck = 0;
1.1.1.3 root 406:
1.1 root 407: secbuf[0] = secbuf[1] = 0x00;
408: secbuf[2] = secbuf[3] = 0xa1;
409: secbuf[4] = 0xff;
410: secbuf[5] = tr;
411: secbuf[6] = sec;
1.1.1.7 root 412: secbuf[7] = drv->num_secs - sec;
1.1 root 413:
1.1.1.7 root 414: for (i = 8; i < 24; i++)
1.1 root 415: secbuf[i] = 0;
1.1.1.3 root 416:
1.1.1.7 root 417: read_floppy_data (drv, tr, sec * 512, &secbuf[32], 512);
1.1.1.3 root 418:
1.1 root 419: mfmbuf[0] = mfmbuf[1] = 0xaaaa;
420: mfmbuf[2] = mfmbuf[3] = 0x4489;
1.1.1.3 root 421:
422: deven = ((secbuf[4] << 24) | (secbuf[5] << 16)
1.1 root 423: | (secbuf[6] << 8) | (secbuf[7]));
424: dodd = deven >> 1;
1.1.1.7 root 425: deven &= 0x55555555;
426: dodd &= 0x55555555;
1.1.1.3 root 427:
1.1 root 428: mfmbuf[4] = dodd >> 16;
429: mfmbuf[5] = dodd;
1.1.1.7 root 430: mfmbuf[6] = deven >> 16;
1.1 root 431: mfmbuf[7] = deven;
1.1.1.3 root 432:
1.1 root 433: for (i = 8; i < 48; i++)
1.1.1.6 root 434: mfmbuf[i] = 0xaaaa;
1.1.1.7 root 435: for (i = 0; i < 512; i += 4) {
436: deven = ((secbuf[i + 32] << 24) | (secbuf[i + 33] << 16)
437: | (secbuf[i + 34] << 8) | (secbuf[i + 35]));
1.1 root 438: dodd = deven >> 1;
1.1.1.7 root 439: deven &= 0x55555555;
440: dodd &= 0x55555555;
441: mfmbuf[(i >> 1) + 32] = dodd >> 16;
442: mfmbuf[(i >> 1) + 33] = dodd;
443: mfmbuf[(i >> 1) + 256 + 32] = deven >> 16;
444: mfmbuf[(i >> 1) + 256 + 33] = deven;
445: }
446:
447: for (i = 4; i < 24; i += 2)
448: hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
449:
450: deven = dodd = hck;
451: dodd >>= 1;
452: mfmbuf[24] = dodd >> 16;
453: mfmbuf[25] = dodd;
454: mfmbuf[26] = deven >> 16;
455: mfmbuf[27] = deven;
456:
457: for (i = 32; i < 544; i += 2)
458: dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
459:
460: deven = dodd = dck;
461: dodd >>= 1;
462: mfmbuf[28] = dodd >> 16;
463: mfmbuf[29] = dodd;
464: mfmbuf[30] = deven >> 16;
465: mfmbuf[31] = deven;
466: mfmcode (mfmbuf + 4, 544 - 4);
1.1 root 467: }
1.1.1.7 root 468: #ifdef DISK_DEBUG
469: write_log ("amigados read track %d\n", tr);
470: #endif
1.1 root 471: } else {
472: int i;
1.1.1.7 root 473: int base_offset = ti->type == TRACK_RAW ? 0 : 1;
474: drv->tracklen = ti->bitlen + 16 * base_offset;
475: drv->bigmfmbuf[0] = ti->sync;
1.1.1.10 root 476: read_floppy_data (drv, tr, 0, (char *) (drv->bigmfmbuf + base_offset), (ti->bitlen + 7) / 8);
477: for (i = base_offset; i < (drv->tracklen + 15) / 16; i++) {
1.1.1.7 root 478: uae_u16 *mfm = drv->bigmfmbuf + i;
479: uae_u8 *data = (uae_u8 *) mfm;
480: *mfm = 256 * *data + *(data + 1);
1.1 root 481: }
1.1.1.7 root 482: #if 0 && defined DISK_DEBUG
483: write_log ("rawtrack %d\n", tr);
484: #endif
1.1 root 485: }
1.1.1.3 root 486: drv->buffered_side = side;
487: drv->buffered_cyl = drv->cyl;
1.1.1.7 root 488: drv->trackspeed = floppy_speed * drv->tracklen / (2 * 8 * FLOPPY_WRITE_LEN);
1.1 root 489: }
490:
1.1.1.7 root 491: /* Update ADF_EXT2 track header */
492: static void diskfile_update (drive * drv, int len, uae_u8 type)
1.1 root 493: {
1.1.1.7 root 494: trackid *ti;
495: int track;
496: uae_u8 buf[2 + 2 + 4 + 4], *zerobuf;
1.1.1.3 root 497:
1.1.1.7 root 498: if (drv->filetype != ADF_EXT2)
499: return;
1.1.1.6 root 500:
1.1.1.7 root 501: track = drv->cyl * 2 + side;
502: ti = &drv->trackdata[track];
503: ti->bitlen = len;
504: fseek (drv->diskfile, 8 + 4 + (2 + 2 + 4 + 4) * track, SEEK_SET);
505: memset (buf, 0, sizeof buf);
506: ti->type = type;
507: buf[3] = ti->type;
508: do_put_mem_long ((uae_u32 *) (buf + 4), ti->len);
509: do_put_mem_long ((uae_u32 *) (buf + 8), ti->bitlen);
510: fwrite (buf, sizeof (buf), 1, drv->diskfile);
511: if (ti->len > (len + 7) / 8) {
512: zerobuf = malloc (ti->len);
513: memset (zerobuf, 0, ti->len);
514: fseek (drv->diskfile, ti->offs, SEEK_SET);
515: fwrite (zerobuf, 1, ti->len, drv->diskfile);
516: free (zerobuf);
517: }
518: #ifdef DISK_DEBUG
519: write_log ("track %d, raw track length %d written (total size %d)\n", track, (ti->bitlen + 7) / 8, ti->len);
520: #endif
1.1 root 521: }
522:
523: #define MFMMASK 0x55555555
1.1.1.7 root 524: static uae_u32 getmfmlong (uae_u16 * mbuf)
1.1 root 525: {
526: return ((*mbuf << 16) | *(mbuf + 1)) & MFMMASK;
527: }
528:
1.1.1.7 root 529: static int drive_write_adf_amigados (drive * drv)
1.1 root 530: {
531: int i, secwritten = 0;
1.1.1.11 root 532: int fwlen = FLOPPY_WRITE_LEN * drv->ddhd;
533: int length = 2 * fwlen;
534: int drvsec= drv->num_secs;
1.1.1.3 root 535: uae_u32 odd, even, chksum, id, dlong;
1.1.1.7 root 536: uae_u8 *secdata;
1.1.1.3 root 537: uae_u8 secbuf[544];
1.1.1.7 root 538: uae_u16 *mbuf = drv->bigmfmbuf;
1.1.1.3 root 539: uae_u16 *mend = mbuf + length;
1.1.1.11 root 540: char sectable[22];
1.1.1.7 root 541: memset (sectable, 0, sizeof (sectable));
1.1.1.11 root 542: memcpy (mbuf + fwlen, mbuf, fwlen * sizeof (uae_u16));
1.1 root 543: mend -= (4 + 16 + 8 + 512);
1.1.1.11 root 544: while (secwritten < drvsec) {
1.1 root 545: int trackoffs;
1.1.1.3 root 546:
1.1 root 547: do {
548: while (*mbuf++ != 0x4489) {
1.1.1.4 root 549: if (mbuf >= mend)
1.1.1.7 root 550: return 1;
1.1 root 551: }
552: } while (*mbuf++ != 0x4489);
1.1.1.3 root 553:
1.1.1.4 root 554: odd = getmfmlong (mbuf);
555: even = getmfmlong (mbuf + 2);
1.1.1.3 root 556: mbuf += 4;
1.1 root 557: id = (odd << 1) | even;
1.1.1.3 root 558:
1.1 root 559: trackoffs = (id & 0xff00) >> 8;
1.1.1.11 root 560: if (trackoffs + 1 > drvsec) {
1.1.1.7 root 561: if (drv->filetype == ADF_EXT2)
562: return 2;
1.1.1.5 root 563: write_log ("Disk write: weird sector number %d\n", trackoffs);
1.1 root 564: continue;
565: }
566: chksum = odd ^ even;
1.1.1.4 root 567: for (i = 0; i < 4; i++) {
1.1.1.7 root 568: odd = getmfmlong (mbuf);
569: even = getmfmlong (mbuf + 8);
1.1 root 570: mbuf += 2;
1.1.1.3 root 571:
1.1 root 572: dlong = (odd << 1) | even;
1.1.1.7 root 573: if (dlong) {
574: if (drv->filetype == ADF_EXT2)
575: return 6;
1.1.1.4 root 576: secwritten = -200;
1.1.1.7 root 577: }
1.1 root 578: chksum ^= odd ^ even;
1.1.1.7 root 579: } /* could check here if the label is nonstandard */
1.1 root 580: mbuf += 8;
1.1.1.7 root 581: odd = getmfmlong (mbuf);
582: even = getmfmlong (mbuf + 2);
583: mbuf += 4;
584: if (((odd << 1) | even) != chksum || ((id & 0x00ff0000) >> 16) != drv->cyl * 2 + side) {
585: if (drv->filetype == ADF_EXT2)
586: return 3;
587: write_log ("Disk write: checksum error on sector %d header\n", trackoffs);
1.1 root 588: continue;
589: }
1.1.1.7 root 590: odd = getmfmlong (mbuf);
591: even = getmfmlong (mbuf + 2);
592: mbuf += 4;
1.1 root 593: chksum = (odd << 1) | even;
594: secdata = secbuf + 32;
1.1.1.7 root 595: for (i = 0; i < 128; i++) {
596: odd = getmfmlong (mbuf);
597: even = getmfmlong (mbuf + 256);
598: mbuf += 2;
1.1 root 599: dlong = (odd << 1) | even;
1.1.1.7 root 600: *secdata++ = dlong >> 24;
601: *secdata++ = dlong >> 16;
602: *secdata++ = dlong >> 8;
603: *secdata++ = dlong;
1.1 root 604: chksum ^= odd ^ even;
605: }
606: mbuf += 256;
607: if (chksum) {
1.1.1.7 root 608: if (drv->filetype == ADF_EXT2)
609: return 4;
610: write_log ("Disk write: sector %d, data checksum error\n", trackoffs);
1.1 root 611: continue;
612: }
1.1.1.7 root 613: sectable[trackoffs] = 1;
1.1 root 614: secwritten++;
1.1.1.7 root 615: memcpy (writebuffer + trackoffs * 512, secbuf + 32, 512);
1.1 root 616: }
1.1.1.7 root 617: if (drv->filetype == ADF_EXT2 && (secwritten == 0 || secwritten < 0))
618: return 5;
1.1.1.3 root 619: if (secwritten == 0)
620: write_log ("Disk write in unsupported format\n");
1.1 root 621: if (secwritten < 0)
1.1.1.3 root 622: write_log ("Disk write: sector labels ignored\n");
1.1.1.7 root 623:
1.1.1.11 root 624: diskfile_update (drv, drvsec * 512 * 8, TRACK_AMIGADOS);
625: for (i = 0; i < drvsec; i++) {
1.1.1.7 root 626: fseek (drv->diskfile, drv->trackdata[drv->cyl * 2 + side].offs + i * 512, SEEK_SET);
627: fwrite (writebuffer + i * 512, sizeof (uae_u8), 512, drv->diskfile);
628: }
629:
630: return 0;
1.1 root 631: }
632:
1.1.1.7 root 633: /* write raw track to disk file */
634: static int drive_write_ext2 (drive * drv)
635: {
636: trackid *ti;
637: int len, track, i;
1.1 root 638:
1.1.1.7 root 639: track = drv->cyl * 2 + side;
640: ti = &drv->trackdata[track];
641: len = (drv->tracklen + 7) / 8;
642: if (len > ti->len) {
643: write_log ("disk raw write: image file's track %d is too small (%d < %d)!\n", track, ti->len, len);
644: return 0;
645: }
646: diskfile_update (drv, drv->tracklen, TRACK_RAW);
647: for (i = 0; i < drv->trackdata[track].len / 2; i++) {
648: uae_u16 *mfm = drv->bigmfmbuf + i;
649: uae_u8 *data = (uae_u8 *) mfm;
650: *mfm = 256 * *data + *(data + 1);
651: }
652: fseek (drv->diskfile, ti->offs, SEEK_SET);
653: fwrite (drv->bigmfmbuf, 1, len, drv->diskfile);
654: return 1;
655: }
656:
657: static void drive_write_data (drive * drv)
1.1 root 658: {
1.1.1.7 root 659: int ret;
660: if (drive_writeprotected (drv))
661: return;
662: switch (drv->filetype) {
663: case ADF_NORMAL:
664: drive_write_adf_amigados (drv);
665: break;
666: case ADF_EXT1:
667: write_log ("writing to ADF_EXT1 not supported\n");
668: return;
669: case ADF_EXT2:
670: ret = drive_write_adf_amigados (drv);
671: if (ret) {
672: /*write_log("not an amigados track (error %d), writing as raw track\n",ret); */
673: drive_write_ext2 (drv);
674: }
675: break;
676: }
677: drv->buffered_side = 2; /* will force read */
678: }
679:
680: static void drive_eject (drive * drv)
681: {
682: if (!drive_empty (drv))
1.1.1.4 root 683: zfile_close (drv->diskfile);
1.1 root 684: drv->diskfile = 0;
1.1.1.12 root 685: drv->dskchange = 1;
1.1.1.11 root 686: drive_settype_id(drv); /* Back to 35 DD */
1.1.1.12 root 687: #ifdef DISK_DEBUG
688: write_log ("eject drive %d\n", drv - &floppy[0]);
689: #endif
1.1 root 690: }
691:
1.1.1.3 root 692: /* We use this function if we have no Kickstart ROM.
1.1 root 693: * No error checking - we trust our luck. */
1.1.1.3 root 694: void DISK_ersatz_read (int tr, int sec, uaecptr dest)
1.1 root 695: {
1.1.1.7 root 696: uae_u8 *dptr = get_real_address (dest);
697: fseek (floppy[0].diskfile, floppy[0].trackdata[tr].offs + sec * 512, SEEK_SET);
1.1.1.3 root 698: fread (dptr, 1, 512, floppy[0].diskfile);
1.1 root 699: }
700:
1.1.1.4 root 701: void disk_eject (int num)
1.1 root 702: {
1.1.1.7 root 703: gui_filename (num, "");
704: drive_eject (floppy + num);
1.1.1.3 root 705: *currprefs.df[num] = *changed_prefs.df[num] = 0;
1.1.1.12 root 706: floppy[num].newname[0] = 0;
1.1 root 707: }
708:
1.1.1.4 root 709: void disk_insert (int num, const char *name)
1.1 root 710: {
1.1.1.12 root 711: drive *drv = floppy + num;
712: if (name[0] == 0) {
713: disk_eject (num);
714: } else if (!drive_empty(drv) || drv->dskchange_time > 0) {
715: drive_eject (drv);
716: /* set dskchange_time, disk_insert() will be
717: * called from DISK_check_change() after 1 second delay
718: * this makes sure that all programs detect disk change correctly
719: */
720: strcpy (drv->newname, name);
721: drv->dskchange_time = 10; /* 1 second disk change delay */
722: } else {
723: /* no delayed insert if drive is already empty */
724: drive_insert (drv, num, name);
725: }
1.1 root 726: }
727:
1.1.1.3 root 728: void DISK_check_change (void)
729: {
730: int i;
731:
732: for (i = 0; i < 4; i++) {
1.1.1.12 root 733: drive *drv = floppy + i;
734: if (strcmp (currprefs.df[i], changed_prefs.df[i])) {
735: strcpy (currprefs.df[i], changed_prefs.df[i]);
736: disk_insert (i, currprefs.df[i]);
737: }
738: /* emulate drive motor turn on time */
739: if (drv->dskready_time) {
740: drv->dskready_time--;
741: if (drv->dskready_time == 0)
742: drv->dskready = 1;
743: }
744: /* delay until new disk image is inserted */
745: if (drv->dskchange_time) {
746: drv->dskchange_time--;
747: if (drv->dskchange_time == 0) {
748: drive_insert (drv, i, drv->newname);
749: #ifdef DISK_DEBUG
750: write_log ("delayed insert, drive %d, image '%s'\n", i, drv->newname);
751: #endif
752: drv->newname[0] = 0;
1.1.1.3 root 753: }
754: }
755: }
756: }
757:
1.1.1.4 root 758: int disk_empty (int num)
1.1 root 759: {
1.1.1.4 root 760: return drive_empty (floppy + num);
1.1 root 761: }
762:
1.1.1.11 root 763: static int step;
1.1.1.10 root 764:
1.1.1.4 root 765: void DISK_select (uae_u8 data)
1.1 root 766: {
1.1.1.11 root 767: int step_pulse, lastselected;
1.1 root 768: int dr;
1.1.1.11 root 769: static uae_u8 prevdata;
1.1.1.3 root 770:
1.1.1.10 root 771: lastselected = selected;
1.1 root 772: selected = (data >> 3) & 15;
1.1.1.12 root 773: selected |= disabled;
774: if (selected != lastselected)
775: disk_data_used = 1;
1.1.1.3 root 776: side = 1 - ((data >> 2) & 1);
777:
1.1 root 778: direction = (data >> 1) & 1;
779: step_pulse = data & 1;
780: if (step != step_pulse) {
781: step = step_pulse;
1.1.1.11 root 782: if (step) {
1.1.1.7 root 783: for (dr = 0; dr < 4; dr++) {
1.1 root 784: if (!(selected & (1 << dr))) {
1.1.1.4 root 785: drive_step (floppy + dr);
1.1 root 786: }
787: }
788: }
789: }
1.1.1.7 root 790: for (dr = 0; dr < 4; dr++) {
1.1.1.11 root 791: /* motor on/off workings tested with small assembler code on real Amiga 1200. */
792: /* motor flipflop is set only when drive select goes from high to low */
793: if (!(selected & (1 << dr)) && (lastselected & (1 << dr)) ) {
794: if (floppy[dr].motoroff) {
1.1.1.12 root 795: /* motor off: if motor bit = 0 in prevdata or data -> turn motor on */
1.1.1.11 root 796: if ((prevdata & 0x80) == 0 || (data & 0x80) == 0)
797: drive_motor (floppy + dr, 0);
798: } else {
799: /* motor on: if motor bit = 1 in prevdata only (motor flag state in data has no effect)
800: -> turn motor off */
801: if (prevdata & 0x80)
802: drive_motor (floppy + dr, 1);
803: }
1.1 root 804: }
805: }
806: for (dr = 0; dr < 4; dr++) {
1.1.1.7 root 807: floppy[dr].state = (!(selected & (1 << dr))) | !floppy[dr].motoroff;
1.1.1.8 root 808: update_drive_gui (dr);
1.1 root 809: }
1.1.1.11 root 810: prevdata = data;
1.1 root 811: }
812:
1.1.1.4 root 813: uae_u8 DISK_status (void)
1.1 root 814: {
1.1.1.3 root 815: uae_u8 st = 0x3c;
1.1 root 816: int dr;
1.1.1.3 root 817:
1.1.1.7 root 818: for (dr = 0; dr < 4; dr++) {
1.1.1.3 root 819: drive *drv = floppy + dr;
1.1 root 820: if (!(selected & (1 << dr))) {
1.1.1.7 root 821: if (drive_running (drv)) {
1.1.1.11 root 822: if (drv->dskready)
1.1.1.7 root 823: st &= ~0x20;
1.1.1.12 root 824: } else {
1.1.1.11 root 825: /* report drive ID */
826: if (drv->drive_id & (1L << (31 - drv->drive_id_scnt)))
827: st |= 0x20;
828: else
829: st &= ~0x20;
830: #ifdef DEBUG_DRIVE_ID
831: write_log("DISK_status: sel %d id %s [0x%08lx, bit #%02d: %d]\n",
832: dr,drive_id_name(drv), drv->drive_id << drv->drive_id_scnt, 31 - drv->drive_id_scnt, st & 0x20 ? 1:0);
1.1.1.12 root 833: #endif
1.1.1.11 root 834: /* Left shift id reg bit should be done with each LH transition of drv_sel */
835: drv->drive_id_scnt++;
836: drv->drive_id_scnt &= 31;
1.1 root 837: }
1.1.1.12 root 838: if (drive_track0 (drv))
1.1.1.7 root 839: st &= ~0x10;
1.1.1.12 root 840: if (drive_writeprotected (drv))
1.1.1.7 root 841: st &= ~8;
1.1.1.12 root 842: if (drv->dskchange)
843: st &= ~4;
844: }
1.1 root 845: }
846: return st;
847: }
848:
1.1.1.7 root 849: #define MAX_DISK_WORDS_PER_LINE 50 /* depends on floppy_speed */
850:
851: #define DISK_INDEXSYNC 1
852: #define DISK_WORDSYNC 2
853:
854: static uae_u16 dskbytr_tab[MAX_DISK_WORDS_PER_LINE * 2 + 1];
855: static uae_u8 dskbytr_cycle[MAX_DISK_WORDS_PER_LINE * 2 + 1];
1.1.1.11 root 856: static short wordsync_cycle[MAX_DISK_WORDS_PER_LINE * 2 + 1];
1.1.1.7 root 857: static uae_u32 dma_tab[MAX_DISK_WORDS_PER_LINE + 1];
858: static uae_u8 disk_sync[MAXHPOS];
859: static int disk_sync_cycle;
860: static int dskdmaen, dsklength;
861: static uae_u16 dsksync;
862: static uae_u32 dskpt;
863:
864: static void disk_dmafinished (void)
865: {
866: INTREQ (0x8002);
1.1.1.12 root 867: dskdmaen = 1; /* surprise, it isn't set to zero! */
1.1.1.11 root 868: #ifdef DISK_DEBUG
1.1.1.12 root 869: write_log("disk dma finished %08.8X\n", dskpt);
1.1.1.11 root 870: #endif
871: }
1.1.1.7 root 872:
873: static void disk_events (int last)
874: {
875: eventtab[ev_disk].active = 0;
1.1.1.11 root 876: for (disk_sync_cycle = last; disk_sync_cycle < maxhpos; disk_sync_cycle++) {
1.1.1.7 root 877: if (disk_sync[disk_sync_cycle]) {
1.1.1.10 root 878: eventtab[ev_disk].oldcycles = get_cycles ();
879: eventtab[ev_disk].evtime = get_cycles () + (disk_sync_cycle - last) * CYCLE_UNIT;
1.1.1.7 root 880: eventtab[ev_disk].active = 1;
881: events_schedule ();
882: return;
1.1 root 883: }
884: }
885: }
886:
1.1.1.7 root 887: extern void cia_diskindex (void);
1.1.1.3 root 888:
1.1.1.7 root 889: void DISK_handler (void)
890: {
891: eventtab[ev_disk].active = 0;
1.1.1.11 root 892: if (disk_sync[disk_sync_cycle] & DISK_WORDSYNC)
1.1.1.7 root 893: INTREQ (0x9000);
1.1.1.11 root 894: if (disk_sync[disk_sync_cycle] & DISK_INDEXSYNC)
1.1.1.7 root 895: cia_diskindex ();
896: disk_sync[disk_sync_cycle] = 0;
897: disk_events (disk_sync_cycle);
898: }
1.1.1.3 root 899:
1.1.1.12 root 900: static int dma_enable, bitoffset;
901: static uae_u32 word;
1.1 root 902:
1.1.1.7 root 903: /* Always carried through to the next line. */
904: static int disk_hpos;
1.1.1.2 root 905:
1.1.1.7 root 906: /* emulate disk write dma for full horizontal line */
907: static void disk_doupdate_write (drive * drv)
908: {
909: int hpos = disk_hpos;
1.1.1.11 root 910: while (hpos < (maxhpos << 8)) {
1.1.1.7 root 911: drv->mfmpos++;
912: drv->mfmpos %= drv->tracklen;
913: if (!drv->mfmpos) {
914: disk_sync[hpos >> 8] |= DISK_INDEXSYNC;
915: disk_events (0);
916: }
917: if ((dmacon & 0x210) == 0x210 && dskdmaen == 3) {
918: bitoffset++;
919: bitoffset &= 15;
920: if (!bitoffset) {
921: drv->bigmfmbuf[drv->mfmpos >> 4] = get_word (dskpt);
922: dskpt += 2;
923: dsklength--;
924: if (dsklength == 0) {
925: disk_dmafinished ();
926: drive_write_data (drv);
927: }
1.1 root 928: }
929: }
1.1.1.7 root 930: hpos += drv->trackspeed;
1.1 root 931: }
1.1.1.11 root 932: disk_hpos = hpos - (maxhpos << 8);
1.1 root 933: }
934:
1.1.1.7 root 935: /* get one bit from MFM bit stream */
1.1.1.12 root 936: static uae_u32 getonebit (uae_u16 * mfmbuf, int mfmpos, uae_u32 word)
1.1 root 937: {
1.1.1.7 root 938: uae_u16 *buf;
1.1 root 939:
1.1.1.7 root 940: buf = &mfmbuf[mfmpos >> 4];
941: word <<= 1;
942: word |= (buf[0] & (1 << (15 - (mfmpos & 15)))) ? 1 : 0;
943: return word;
1.1 root 944: }
945:
1.1.1.11 root 946: #define WORDSYNC_CYCLES 7 /* (~7 * 280ns = 2us) */
947:
1.1.1.7 root 948: /* emulate disk read dma for full horizontal line */
949: static void disk_doupdate_read (drive * drv)
950: {
951: int hpos = disk_hpos;
1.1.1.12 root 952: int is_sync = 0;
1.1.1.11 root 953: int j = 0, k = 1, l = 0;
1.1.1.12 root 954: uae_u16 synccheck;
1.1.1.11 root 955: static int dskbytr_last = 0, wordsync_last = -1;
1.1.1.7 root 956:
1.1.1.11 root 957: dskbytr_tab[0] = dskbytr_tab[dskbytr_last];
958:
959: if (wordsync_last >= 0 && maxhpos - wordsync_cycle[wordsync_last] < WORDSYNC_CYCLES)
960: wordsync_cycle[l++] = (maxhpos - wordsync_cycle[wordsync_last]) - WORDSYNC_CYCLES;
961: wordsync_last = -1;
962:
963: while (hpos < (maxhpos << 8)) {
964: if (drv->dskready)
965: word = getonebit (drv->bigmfmbuf, drv->mfmpos, word);
966: else
967: word <<= 1;
1.1.1.7 root 968: drv->mfmpos++;
969: drv->mfmpos %= drv->tracklen;
1.1.1.12 root 970: if (!drv->mfmpos) {
1.1.1.7 root 971: disk_sync[hpos >> 8] |= DISK_INDEXSYNC;
972: is_sync = 1;
973: }
1.1.1.12 root 974: if (bitoffset == 31 && dma_enable) {
975: dma_tab[j++] = (word >> 16) & 0xffff;
1.1.1.7 root 976: if (j == MAX_DISK_WORDS_PER_LINE - 1) {
977: write_log ("Bug: Disk DMA buffer overflow!\n");
978: j--;
979: }
980: }
1.1.1.12 root 981: if (bitoffset == 15 || bitoffset == 23 || bitoffset == 31) {
982: dskbytr_tab[k] = (word >> 8) & 0xff;
1.1.1.11 root 983: dskbytr_tab[k] |= 0x8000;
984: dskbytr_last = k;
1.1.1.7 root 985: dskbytr_cycle[k++] = hpos >> 8;
986: }
1.1.1.12 root 987: synccheck = (word >> 8) & 0xffff;
988: if (synccheck == dsksync) {
989: if (adkcon & 0x400) {
990: if (bitoffset != 23 || !dma_enable)
991: bitoffset = 7;
992: dma_enable = 1;
993: }
994: wordsync_last = l;
995: wordsync_cycle[l++] = hpos >> 8;
996: disk_sync[hpos >> 8] |= DISK_WORDSYNC;
997: is_sync = 1;
998: }
1.1.1.11 root 999: bitoffset++;
1.1.1.12 root 1000: if (bitoffset == 32) bitoffset = 16;
1.1.1.7 root 1001: hpos += drv->trackspeed;
1002: }
1003: dma_tab[j] = 0xffffffff;
1.1.1.11 root 1004: dskbytr_cycle[k] = 255;
1005: wordsync_cycle[l] = 255;
1.1.1.7 root 1006: if (is_sync)
1007: disk_events (0);
1008:
1.1.1.11 root 1009: disk_hpos = hpos - (maxhpos << 8);
1.1.1.7 root 1010: }
1011:
1012: /* disk DMA fetch happens on real Amiga at the beginning of next horizontal line
1013: (cycles 9, 11 and 13 according to hardware manual) We transfer all DMA'd
1014: data at cycle 0. I don't think any program cares about this small difference.
1.1.1.12 root 1015:
1016: We must handle dsklength = 0 because some copy protections use it to detect
1017: wordsync without transferring any data.
1.1.1.7 root 1018: */
1019: static void dodmafetch (void)
1.1 root 1020: {
1.1.1.7 root 1021: int i;
1022:
1023: i = 0;
1024: while (dma_tab[i] != 0xffffffff && dskdmaen == 2 && (dmacon & 0x210) == 0x210) {
1.1.1.12 root 1025: if (dsklength > 0) {
1026: put_word (dskpt, dma_tab[i++]);
1027: dskpt += 2;
1028: dsklength--;
1029: }
1.1.1.7 root 1030: if (dsklength == 0) {
1031: disk_dmafinished ();
1032: break;
1033: }
1034: }
1035: dma_tab[0] = 0xffffffff;
1.1 root 1036: }
1037:
1.1.1.7 root 1038: static void DISK_start (void)
1.1.1.6 root 1039: {
1040: int dr;
1.1.1.7 root 1041:
1.1.1.6 root 1042: for (dr = 0; dr < 4; dr++) {
1.1.1.7 root 1043: drive *drv = &floppy[dr];
1044: if (!(selected & (1 << dr))) {
1045: int tr = drv->cyl * 2 + side;
1046: trackid *ti = drv->trackdata + tr;
1047:
1048: if (dskdmaen == 3) {
1.1.1.11 root 1049: drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 8 * 2;
1.1.1.7 root 1050: drv->trackspeed = floppy_speed;
1051: }
1052: /* Ugh. A nasty hack. Assume ADF_EXT1 tracks are always read
1053: from the start. */
1054: if (ti->type == TRACK_RAW1)
1.1.1.12 root 1055: drv->mfmpos = 0;
1.1.1.6 root 1056: }
1057: }
1.1.1.12 root 1058: dma_enable = (adkcon & 0x400) ? 0 : 1;
1.1.1.7 root 1059: word = 0;
1060: bitoffset = 0;
1061: dma_tab[0] = 0xffffffff;
1.1.1.6 root 1062: }
1063:
1.1.1.7 root 1064: static int linecounter;
1065:
1066: void DISK_update (void)
1.1 root 1067: {
1068: int dr;
1.1.1.7 root 1069:
1.1.1.6 root 1070: for (dr = 0; dr < 4; dr++) {
1.1.1.7 root 1071: drive *drv = &floppy[dr];
1.1.1.11 root 1072: if (drv->steplimit)
1073: drv->steplimit--;
1.1.1.7 root 1074: }
1075: if (linecounter) {
1076: linecounter--;
1077: if (! linecounter)
1078: disk_dmafinished ();
1079: return;
1080: }
1081:
1082: dodmafetch ();
1083:
1084: for (dr = 0; dr < 4; dr++) {
1085: drive *drv = &floppy[dr];
1086: if (drv->motoroff)
1087: continue;
1088: if (selected & (1 << dr)) {
1.1.1.11 root 1089: drv->mfmpos += (maxhpos << 8) / drv->trackspeed;
1.1.1.7 root 1090: drv->mfmpos %= drv->tracklen;
1091: continue;
1.1 root 1092: }
1.1.1.11 root 1093: drive_fill_bigbuf (drv);
1094: drv->mfmpos %= drv->tracklen;
1095: if (dskdmaen > 1)
1096: disk_data_used = 0;
1097:
1.1.1.7 root 1098: if (dskdmaen == 3)
1099: disk_doupdate_write (drv);
1.1.1.12 root 1100: else if (1 || disk_data_used < MAXVPOS * 50 * 2) {
1.1.1.11 root 1101: disk_data_used++;
1.1.1.7 root 1102: disk_doupdate_read (drv);
1.1.1.11 root 1103: }
1.1.1.7 root 1104: return;
1.1 root 1105: }
1106: }
1.1.1.6 root 1107:
1.1.1.7 root 1108: void DSKLEN (uae_u16 v, int hpos)
1.1.1.6 root 1109: {
1.1.1.7 root 1110: if (v & 0x8000) {
1111: dskdmaen = dskdmaen == 1 ? 2 : 1;
1112: } else {
1113: /* Megalomania does this */
1114: #if 0
1115: if (dskdmaen == 2)
1116: write_log ("warning: Disk read DMA aborted, %d words left\n", dsklength);
1117: #endif
1118: if (dskdmaen == 3)
1119: write_log ("warning: Disk write DMA aborted, %d words left\n", dsklength);
1120: dskdmaen = 0;
1121: }
1.1.1.12 root 1122: dsklength = v & 0x3ffe;
1.1.1.7 root 1123: if (dskdmaen <= 1)
1124: return;
1125: if (v & 0x4000)
1126: dskdmaen = 3;
1127: #ifdef DISK_DEBUG
1128: {
1129: int dr;
1130: for (dr = 0; dr < 4; dr++) {
1131: drive *drv = &floppy[dr];
1132: if (drv->motoroff)
1133: continue;
1134: if ((selected & (1 << dr)) == 0)
1135: break;
1136: }
1137: if (dr == 4)
1138: write_log ("disk DMA started, but no drive ready!\n");
1139: else
1140: write_log ("disk %s DMA started for %d words (%08.8X) sync=%04.4X track %d\n",
1141: dskdmaen == 3 ? "write" : "read", dsklength, dskpt,
1142: (adkcon & 0x400) ? dsksync : 0xffff,
1143: floppy[dr].cyl * 2 + side);
1144: }
1145: #endif
1146: /* Megalomania does not work if DSKLEN write is delayed to next horizontal line,
1147: also it seems some copy protections require this fix */
1148: DISK_start ();
1.1.1.6 root 1149:
1.1.1.7 root 1150: /* Try to make floppy access from Kickstart faster. */
1151: if (dskdmaen != 2)
1152: return;
1153: {
1154: int dr;
1155: uaecptr pc = m68k_getpc ();
1156: if ((pc & 0xF80000) != 0xF80000)
1157: return;
1158: for (dr = 0; dr < 4; dr++) {
1159: drive *drv = &floppy[dr];
1160: if (drv->motoroff)
1161: continue;
1162: if ((selected & (1 << dr)) == 0) {
1163: int pos = drv->mfmpos & ~15;
1164: int i;
1165:
1.1.1.11 root 1166: drive_fill_bigbuf (drv);
1.1.1.7 root 1167: if (adkcon & 0x400) {
1168: for (i = 0; i < drv->tracklen; i += 16) {
1169: pos += 16;
1170: pos %= drv->tracklen;
1.1.1.11 root 1171: if (drv->bigmfmbuf[pos >> 4] == dsksync) {
1172: /* must skip first disk sync marker */
1.1.1.12 root 1173: pos += 16;
1.1.1.11 root 1174: pos %= drv->tracklen;
1.1.1.7 root 1175: break;
1.1.1.11 root 1176: }
1.1.1.7 root 1177: }
1178: if (i >= drv->tracklen)
1179: return;
1180: }
1181: while (dsklength-- > 0) {
1182: put_word (dskpt, drv->bigmfmbuf[pos >> 4]);
1183: dskpt += 2;
1184: pos += 16;
1185: pos %= drv->tracklen;
1.1.1.6 root 1186: }
1.1.1.7 root 1187: INTREQ (0x9000);
1188: linecounter = 2;
1189: dskdmaen = 0;
1190: return;
1.1.1.6 root 1191: }
1192: }
1.1.1.7 root 1193: }
1.1.1.6 root 1194: }
1195:
1.1.1.11 root 1196: /* this is very unoptimized. DSKBYTR is used very rarely, so it should not matter. */
1.1.1.7 root 1197:
1198: uae_u16 DSKBYTR (int hpos)
1.1.1.6 root 1199: {
1.1.1.7 root 1200: uae_u16 v;
1201: int i;
1202:
1203: i = 0;
1.1.1.11 root 1204: while (hpos > dskbytr_cycle[i + 1])
1.1.1.7 root 1205: i++;
1206: v = dskbytr_tab[i];
1207: dskbytr_tab[i] &= ~0x8000;
1.1.1.11 root 1208: if (wordsync_cycle[0] != 255) {
1209: i = 0;
1.1.1.12 root 1210: while (hpos < wordsync_cycle[i])
1211: i++;
1212: if (hpos - wordsync_cycle[i] <= WORDSYNC_CYCLES)
1.1.1.11 root 1213: v |= 0x1000;
1214: }
1.1.1.7 root 1215: if (dskdmaen && (dmacon & 0x210) == 0x210)
1216: v |= 0x4000;
1217: if (dskdmaen == 3)
1218: v |= 0x2000;
1.1.1.11 root 1219:
1220: disk_data_used = 0;
1221:
1.1.1.7 root 1222: return v;
1223: }
1224:
1.1.1.11 root 1225: /* not a real hardware register */
1.1.1.7 root 1226: uae_u16 DSKDATR (int hpos)
1227: {
1.1.1.11 root 1228: return 0;
1.1.1.7 root 1229: }
1230:
1231: void DSKSYNC (uae_u16 v)
1232: {
1233: dsksync = v;
1234: }
1235:
1236: void DSKDAT (uae_u16 v)
1237: {
1238: static int count = 0;
1239: if (count < 5) {
1240: count++;
1241: write_log ("DSKDAT written. Not good.");
1242: if (count == 5)
1243: write_log ("(further messages suppressed)");
1244:
1245: write_log ("\n");
1.1.1.6 root 1246: }
1247: }
1.1.1.7 root 1248: void DSKPTH (uae_u16 v)
1249: {
1250: dskpt = (dskpt & 0xffff) | ((uae_u32) v << 16);
1251: }
1.1.1.6 root 1252:
1.1.1.7 root 1253: void DSKPTL (uae_u16 v)
1.1.1.6 root 1254: {
1.1.1.7 root 1255: dskpt = (dskpt & ~0xffff) | (v);
1.1.1.6 root 1256: }
1257:
1.1.1.7 root 1258: void DISK_init (void)
1259: {
1.1.1.11 root 1260: int dr;
1.1.1.7 root 1261:
1262: dma_tab[0] = 0xffffffff;
1.1.1.11 root 1263: dskbytr_cycle[0] = 0;
1264: dskbytr_cycle[1] = 255;
1265: wordsync_cycle[0] = 255;
1.1.1.7 root 1266:
1.1.1.11 root 1267: for (dr = 0; dr < 4; dr++) {
1268: drive *drv = &floppy[dr];
1.1.1.12 root 1269: /* reset all drive types to 3.5 DD */
1.1.1.11 root 1270: drive_settype_id (drv);
1271: if (!drive_insert (drv, dr, currprefs.df[dr]))
1272: disk_eject (dr);
1.1.1.8 root 1273: }
1.1.1.7 root 1274: if (disk_empty (0))
1275: write_log ("No disk in drive 0.\n");
1276: }
1277:
1.1.1.8 root 1278: void DISK_reset (void)
1279: {
1280: int i;
1.1.1.13! root 1281:
! 1282: if (savestate_state)
! 1283: return;
! 1284:
1.1.1.8 root 1285: disk_hpos = 0;
1.1.1.11 root 1286: disk_data_used = 0;
1.1.1.12 root 1287: disabled = 0;
1.1.1.8 root 1288: for (i = 0; i < 4; i++) {
1.1.1.12 root 1289: if (i >= currprefs.nr_floppies) {
1290: disabled |= 1 << i;
1291: floppy[i].motoroff = 1;
1292: }
1.1.1.8 root 1293: }
1294: }
1295:
1.1.1.7 root 1296: void dumpdisk (void)
1297: {
1298: int i;
1299: for (i = 0; i < 4; i++) {
1300: drive *drv = &floppy[i];
1301: printf ("Drive %d: motor %s cylinder %2d selected %d\n", i, drv->motoroff ? "off" : " on", drv->cyl, selected & (1 << i));
1302: }
1303: }
1.1.1.11 root 1304:
1305: /* Disk save/restore code */
1306:
1307: void DISK_save_custom (uae_u32 *pdskpt, uae_u16 *pdsklength, uae_u16 *pdsksync, uae_u16 *pdskdatr, uae_u16 *pdskbytr)
1308: {
1309: if(pdskpt) *pdskpt = dskpt;
1310: if(pdsklength) *pdsklength = dsklength;
1311: if(pdsksync) *pdsksync = dsksync;
1312: if(pdskdatr) *pdskdatr = 0;
1313: if(pdskbytr) *pdskbytr = dskbytr_tab[0];
1314: }
1315:
1316: void DISK_restore_custom (uae_u32 pdskpt, uae_u16 pdsklength, uae_u16 pdskdatr, uae_u16 pdskbytr)
1317: {
1318: dskpt = pdskpt;
1319: dsklength = pdsklength;
1320: dskbytr_tab[0] = pdskbytr;
1321: }
1322:
1323: uae_u8 *restore_disk(int num,uae_u8 *src)
1324: {
1325: drive *drv;
1.1.1.13! root 1326: int state;
1.1.1.11 root 1327:
1328: drv = &floppy[num];
1.1.1.13! root 1329: disabled &= ~(1 << num);
1.1.1.11 root 1330: drv->drive_id = restore_u32 ();
1.1.1.13! root 1331: state = restore_u8 ();
! 1332: if (state & 2)
! 1333: disabled |= 1 << num;
! 1334: else
! 1335: drv->motoroff = (state & 1) ? 0 : 1;
1.1.1.11 root 1336: drv->cyl = restore_u8 ();
1337: drv->dskready = restore_u8 ();
1338: drv->drive_id_scnt = restore_u8 ();
1339: drv->mfmpos = restore_u32 ();
1340: restore_u32 ();
1341: strncpy(currprefs.df[num],src,255);
1342: src+=strlen(src)+1;
1343:
1344: return src;
1345: }
1346:
1347: uae_u8 *save_disk(int num,int *len)
1348: {
1349: uae_u8 *dstbak,*dst;
1350: drive *drv;
1351:
1352: drv = &floppy[num];
1353: dstbak = dst = malloc (2+1+1+1+1+4+4+256);
1354: save_u32 (drv->drive_id); /* drive type ID */
1.1.1.13! root 1355: save_u8 ((drv->motoroff ? 0:1) | ((disabled & (1 << num)) ? 2 : 0)); /* state */
1.1.1.11 root 1356: save_u8 (drv->cyl); /* cylinder */
1357: save_u8 (drv->dskready); /* dskready */
1358: save_u8 (drv->drive_id_scnt); /* id mode position */
1359: save_u32 (drv->mfmpos); /* disk position */
1360: save_u32 (0); /* CRC of disk image */
1361: strcpy (dst, currprefs.df[num]);/* image name */
1362: dst += strlen(dst) + 1;
1363:
1364: *len = dst - dstbak;
1365: return dstbak;
1366: }
1367:
1368: /* internal floppy controller variables */
1369:
1370: uae_u8 *restore_floppy(uae_u8 *src)
1371: {
1372: word = restore_u16();
1373: bitoffset = restore_u8();
1.1.1.12 root 1374: dma_enable = restore_u8();
1.1.1.11 root 1375: disk_hpos = restore_u8();
1376: dskdmaen = restore_u8();
1.1.1.12 root 1377: word |= restore_u16() << 16;
1.1.1.11 root 1378:
1379: return src;
1380: }
1381:
1382: uae_u8 *save_floppy(int *len)
1383: {
1384: uae_u8 *dstbak, *dst;
1385:
1386: /* flush dma buffer before saving */
1387: dodmafetch();
1388:
1.1.1.12 root 1389: dstbak = dst = malloc(2+1+1+1+1+2);
1390: save_u16 (word); /* current fifo (low word) */
1.1.1.11 root 1391: save_u8 (bitoffset); /* dma bit offset */
1.1.1.12 root 1392: save_u8 (dma_enable); /* disk sync found */
1.1.1.11 root 1393: save_u8 (disk_hpos); /* next bit read position */
1394: save_u8 (dskdmaen); /* dma status */
1.1.1.12 root 1395: save_u16 (word >> 16); /* current fifo (high word) */
1.1.1.11 root 1396:
1397: *len = dst - dstbak;
1398: return dstbak;
1399: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.