/*

 * All Input is assumed to be going to RAM
 * All Output is assumed to be coming from either RAM or ROM
 *
 */

#include <stdio.h>
#include <stdlib.h>

#ifdef VMS
#include <unixio.h>
#include <file.h>
#else
#include <fcntl.h>
#ifndef AMIGA
#include <unistd.h>
#endif
#endif

#ifdef DJGPP
#include "djgpp.h"
#endif

static char *rcsid = "$Id: sio.c,v 1.9 1998/02/21 14:55:21 david Exp $";

#define FALSE   0
#define TRUE    1

#include "atari.h"
#include "cpu.h"
#include "sio.h"

#define	MAGIC1	0x96
#define	MAGIC2	0x02

#undef ORIGINAL_XFD_CODE		/* new code should support DD XFD images - PS */

struct ATR_Header {
	unsigned char magic1;
	unsigned char magic2;
	unsigned char seccountlo;
	unsigned char seccounthi;
	unsigned char secsizelo;
	unsigned char secsizehi;
	unsigned char hiseccountlo;
	unsigned char hiseccounthi;
	unsigned char gash[8];
};

typedef enum Format {
	XFD, ATR
} Format;

static Format format[MAX_DRIVES];
static int disk[MAX_DRIVES] =
{-1, -1, -1, -1, -1, -1, -1, -1};
static int sectorcount[MAX_DRIVES];
static int sectorsize[MAX_DRIVES];

static enum DriveStatus {
	Off,
	NoDisk,
	ReadOnly,
	ReadWrite
} drive_status[MAX_DRIVES];

char sio_status[256];
char sio_filename[MAX_DRIVES][FILENAME_LEN];

void SIO_Initialise(int *argc, char *argv[])
{
	int i;

	for (i = 0; i < MAX_DRIVES; i++)
		strcpy(sio_filename[i], "Empty");
}

int SIO_Mount(int diskno, char *filename)
{
	struct ATR_Header header;

	int fd;

	drive_status[diskno - 1] = ReadWrite;
	strcpy(sio_filename[diskno - 1], "Empty");

	fd = open(filename, O_RDWR, 0777);
	if (fd == -1) {
		fd = open(filename, O_RDONLY, 0777);
		drive_status[diskno - 1] = ReadOnly;
	}

	if (fd >= 0) {
		int status;

		status = read(fd, &header, sizeof(struct ATR_Header));
		if (status == -1) {
			close(fd);
			disk[diskno - 1] = -1;
			return FALSE;
		}

		strcpy(sio_filename[diskno - 1], filename);

		if ((header.magic1 == MAGIC1) && (header.magic2 == MAGIC2)) {
			sectorcount[diskno - 1] = header.hiseccounthi << 24 |
				header.hiseccountlo << 16 |
				header.seccounthi << 8 |
				header.seccountlo;

			sectorsize[diskno - 1] = header.secsizehi << 8 |
				header.secsizelo;

			sectorcount[diskno - 1] /= 8;
			if (sectorsize[diskno - 1] == 256) {
				sectorcount[diskno - 1] += 3;	/* Compensate for first 3 sectors */
				sectorcount[diskno - 1] /= 2;
			}

#ifdef DEBUG
			printf("ATR: sectorcount = %d, sectorsize = %d\n",
				   sectorcount[diskno - 1],
				   sectorsize[diskno - 1]);
#endif

			format[diskno - 1] = ATR;
		}
		else {
			ULONG file_length = lseek(fd, 0L, SEEK_END);
			format[diskno - 1] = XFD;
#ifndef ORIGINAL_XFD_CODE
			/* XFD might be of double density ! (PS) */
			sectorsize[diskno - 1] = (file_length > (1040 * 128)) ? 256 : 128;
			sectorcount[diskno - 1] = file_length / sectorsize[diskno - 1];
#endif
		}
	}
	else {
		drive_status[diskno - 1] = NoDisk;
	}

	disk[diskno - 1] = fd;

	return (disk[diskno - 1] != -1) ? TRUE : FALSE;
}

void SIO_Dismount(int diskno)
{
	if (disk[diskno - 1] != -1) {
		close(disk[diskno - 1]);
		disk[diskno - 1] = -1;
		drive_status[diskno - 1] = NoDisk;
		strcpy(sio_filename[diskno - 1], "Empty");
	}
}

void SIO_DisableDrive(int diskno)
{
	drive_status[diskno - 1] = Off;
	strcpy(sio_filename[diskno - 1], "Off");
}

void SeekSector(int dskno, int sector)
{
	int offset;

	sprintf(sio_status, "%d: %d", dskno + 1, sector);

	switch (format[dskno]) {
	case XFD:
#ifdef ORIGINAL_XFD_CODE		/* does not support double density XFD disks */
		offset = (sector - 1) * 128;
#else
		offset = (sector - 1) * sectorsize[dskno] + 0;
#endif
		break;

	case ATR:
		if (sector < 4)
			offset = (sector - 1) * 128 + 16;
		else
			offset = (sector - 1) * sectorsize[dskno] + 16;
/*
   offset = 3*128 + (sector-4) * sectorsize[dskno] + 16;
 */
		break;
	default:
		printf("Fatal Error in atari_sio.c\n");
		Atari800_Exit(FALSE);
		exit(1);
	}

	if (offset > lseek(disk[dskno], 0L, SEEK_END)) {
/*
   printf("Seek after end of file\n");
   Atari800_Exit(FALSE);
   exit(1);
 */
	}
	else
		lseek(disk[dskno], offset, SEEK_SET);
}

void SIO(void)
{
	/* UBYTE DDEVIC = memory[0x0300]; */
	UBYTE DUNIT = memory[0x0301];
	UBYTE DCOMND = memory[0x0302];
	/* UBYTE DSTATS = memory[0x0303]; */
	UBYTE DBUFLO = memory[0x0304];
	UBYTE DBUFHI = memory[0x0305];
	/* UBYTE DTIMLO = memory[0x0306]; */
	UBYTE DBYTLO = memory[0x0308];
	UBYTE DBYTHI = memory[0x0309];
	UBYTE DAUX1 = memory[0x030a];
	UBYTE DAUX2 = memory[0x030b];

	int sector;
	int buffer;
	int count;
	int i;

	if (drive_status[DUNIT - 1] != Off) {
		if (disk[DUNIT - 1] != -1) {
			int offset;

			sector = DAUX1 + DAUX2 * 256;
			buffer = DBUFLO + DBUFHI * 256;
			count = DBYTLO + DBYTHI * 256;

			switch (format[DUNIT - 1]) {
			case XFD:
#ifdef ORIGINAL_XFD_CODE
				offset = (sector - 1) * 128 + 0;
#else
				offset = (sector - 1) * sectorsize[DUNIT - 1] + 0;
#endif
				break;
			case ATR:
				if (sector < 4)
					offset = (sector - 1) * 128 + 16;
				else
					offset = (sector - 1) * sectorsize[DUNIT - 1] + 16;
/*
   offset = 3*128 + (sector-4) * sectorsize[DUNIT-1] + 16;
 */
				break;
			default:
				printf("Fatal Error in atari_sio.c\n");
				Atari800_Exit(FALSE);
				exit(1);
			}

			if (offset > lseek(disk[DUNIT - 1], 0L, SEEK_END)) {
/*
   printf("Seek after end of file\n");
   Atari800_Exit(FALSE);
   exit(1);
 */
			}
			else
				lseek(disk[DUNIT - 1], offset, SEEK_SET);

#ifdef DEBUG
			printf("SIO: DCOMND = %x, SECTOR = %d, BUFADR = %x, BUFLEN = %d\n",
				   DCOMND, sector, buffer, count);
#endif

			switch (DCOMND) {
			case 0x50:
			case 0x57:
				if (drive_status[DUNIT - 1] == ReadWrite) {
					write(disk[DUNIT - 1], &memory[buffer], count);
					regY = 1;
					ClrN;
				}
				else {
					regY = 146;
					SetN;
				}
				break;
			case 0x52:
				read(disk[DUNIT - 1], &memory[buffer], count);
				regY = 1;
				ClrN;
				break;
			case 0x21:			/* Single Density Format */
			case 0x22:			/* Duel Density Format */
			case 0x66:			/* US Doubler Format - I think! */
				regY = 1;
				ClrN;
				break;
/*
   Status Request from Atari 400/800 Technical Reference Notes

   DVSTAT + 0   Command Status
   DVSTAT + 1   Hardware Status
   DVSTAT + 2   Timeout
   DVSTAT + 3   Unused

   Command Status Bits

   Bit 0 = 1 indicates an invalid command frame was received
   Bit 1 = 1 indicates an invalid data frame was received
   Bit 2 = 1 indicates that a PUT operation was unsuccessful
   Bit 3 = 1 indicates that the diskete is write protected
   Bit 4 = 1 indicates active/standby

   plus

   Bit 5 = 1 indicates double density
   Bit 7 = 1 indicates duel density disk (1050 format)
 */
			case 0x53:			/* Get Status */
				for (i = 0; i < count; i++) {
					if (sectorsize[DUNIT - 1] == 256)
						memory[buffer + i] = 32 + 16;
					else
						memory[buffer + i] = 16;
				}
				regY = 1;
				ClrN;
				break;
			default:
				printf("SIO: DCOMND = %0x\n", DCOMND);
				regY = 146;
				SetN;
				break;
			}
		}
		else {
			regY = 146;
			SetN;
		}
	}
	else {
		regY = 138;
		SetN;
	}

	memory[0x0303] = regY;
}

static unsigned char cmd_frame[5];
static int ncmd = 0;
static int checksum = 0;

static unsigned char data[256];
static int offst;

static int buffer_offset;
static int buffer_size;

extern int DELAYED_SERIN_IRQ;
extern int DELAYED_SEROUT_IRQ;
extern int DELAYED_XMTDONE_IRQ;

typedef enum {
	SIO_Normal,
	SIO_Put
} SIO_State;

static SIO_State sio_state = SIO_Normal;

void Command_Frame(void)
{
	sio_state = SIO_Normal;

	switch (cmd_frame[1]) {
	case 'R':					/* Read */
#ifdef DEBUG
		printf("Read command\n");
#endif
		{
			int sector;
			int dskno;
			int i;

			dskno = cmd_frame[0] - 0x31;
			sector = cmd_frame[2] + cmd_frame[3] * 256;
#ifdef DEBUG
			printf("Sector: %d(%x)\n", sector, sector);
#endif
			SeekSector(dskno, sector);

			data[0] = 0x41;		/* ACK */
			data[1] = 0x43;		/* OPERATION COMPLETE */

			read(disk[dskno], &data[2], 128);
			checksum = 0;
			for (i = 2; i < 130; i++) {
				checksum += (unsigned char) data[i];
				while (checksum > 255)
					checksum = checksum - 255;
			}
			data[130] = checksum;

			buffer_offset = 0;
			buffer_size = 131;

			DELAYED_SEROUT_IRQ = 1;
			DELAYED_XMTDONE_IRQ = 3;
			DELAYED_SERIN_IRQ = 150;	/* BEFORE 7 */
		}
		break;
	case 'S':					/* Status */
#ifdef DEBUG
		printf("Status command\n");
#endif
		data[0] = 0x41;			/* ACK */
		data[1] = 0x43;			/* OPERATION COMPLETE */
		data[2] = 0x10;			/* 2ea */
		data[3] = 0x00;			/* 2eb */
		data[4] = 0x01;			/* 2ec */
		data[5] = 0x00;			/* 2ed */
		data[6] = 0x11;			/* Checksum */
		buffer_offset = 0;
		buffer_size = 7;

		DELAYED_SEROUT_IRQ = 1;
		DELAYED_XMTDONE_IRQ = 5;
		DELAYED_SERIN_IRQ = 150;
		break;
	case 'W':					/* Write with verify */
	case 'P':					/* Put without verify */
#ifdef DEBUG
		printf("Put or Write command\n");
#endif
		data[0] = 0x41;			/* ACK */
		buffer_offset = 0;
		buffer_size = 1;
		DELAYED_SEROUT_IRQ = 1;
		DELAYED_XMTDONE_IRQ = 3;
		DELAYED_SERIN_IRQ = 150;	/* BEFORE 7 */
		sio_state = SIO_Put;
		break;
	case '!':					/* Format */
		printf("Format command\n");
		break;
	case 'T':					/* Read Address */
		printf("Read Address command\n");
		break;
	case 'Q':					/* Read Spin */
		printf("Read Spin command\n");
		break;
	case 'U':					/* Motor On */
		printf("Motor On command\n");
		break;
	case 'V':					/* Verify Sector */
		printf("Verify Sector\n");
		break;
	default:
		printf("Unknown command: %02x\n", cmd_frame[1]);
		printf("Command frame: %02x %02x %02x %02x %02x\n",
			   cmd_frame[0], cmd_frame[1], cmd_frame[2],
			   cmd_frame[3], cmd_frame[4]);
		buffer_offset = 0;
		buffer_size = 0;
		DELAYED_XMTDONE_IRQ = 3;
		break;
	}
}

void SIO_SEROUT(unsigned char byte, int cmd)
{
	checksum += (unsigned char) byte;
	while (checksum > 255)
		checksum = checksum - 255;

#ifdef DEBUG
	printf("SIO_SEROUT: byte = %x, checksum = %x, cmd = %d\n",
		   byte, checksum, cmd);
#endif

	if (cmd) {
		cmd_frame[ncmd++] = byte;
		if (ncmd == 5) {
			Command_Frame();

			offst = 0;
			checksum = 0;
			ncmd = 0;
		}
		else {
			DELAYED_SEROUT_IRQ = 1;
		}

		if (cmd_frame[0] == 0)
			ncmd = 0;
	}
	else if (sio_state == SIO_Put) {
		data[buffer_offset++] = byte;
		if (buffer_offset == 130) {
			int sector;
			int dskno;
			int i;

			checksum = 0;

			for (i = 1; i < 129; i++) {
				checksum += (unsigned char) data[i];
				while (checksum > 255)
					checksum = checksum - 255;
			}

			if (checksum != data[129]) {
				printf("Direct SIO Write Error\n");
				printf("Calculated Checksum = %x\n", checksum);
				printf("Actual Checksum = %x\n", data[129]);
				exit(1);
			}

			dskno = cmd_frame[0] - 0x31;
			sector = cmd_frame[2] + cmd_frame[3] * 256;

#ifdef DEBUG
			printf("Sector: %d(%x)\n", sector, sector);
#endif

			SeekSector(dskno, sector);

			write(disk[dskno], &data[1], 128);
			data[buffer_offset] = 0x41;		/* ACK */
			data[buffer_offset + 1] = 0x43;		/* OPERATION COMPLETE */
			buffer_size = buffer_offset + 2;
			DELAYED_SEROUT_IRQ = 1;
			DELAYED_XMTDONE_IRQ = 3;
			DELAYED_SERIN_IRQ = 7;
			DELAYED_XMTDONE_IRQ = 5;
			DELAYED_SERIN_IRQ = 150;
		}
		else {
			DELAYED_SEROUT_IRQ = 4;
		}
	}
	else {
		DELAYED_SEROUT_IRQ = 1;
		ncmd = 0;
	}
}

int SIO_SERIN(void)
{
	int byte = 0;				/* initialise the value, just for sure */

	if (buffer_offset < buffer_size) {
		byte = (int) data[buffer_offset++];

#ifdef DEBUG
		printf("SERIN: byte = %x\n", byte);
#endif

		if (buffer_offset < buffer_size) {
#ifdef DEBUG
			printf("Setting SERIN Interrupt again\n");
#endif
			DELAYED_SERIN_IRQ = 3;
			DELAYED_SERIN_IRQ = 4;
		}
	}

	return byte;
}
