xref: /aosp_15_r20/external/mtools/xdf_io.c (revision d5c9a868b113e0ec0db2f27bc2ce8a253e77c4b0)

/*  Copyright 1994,1996-2003,2005,2007,2009 Alain Knaff.
 *  This file is part of mtools.
 *
 *  Mtools is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Mtools is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Mtools.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Io to an xdf disk
 *
 * written by:
 *
 * Alain L. Knaff
 * [email protected]
 *
 */


#include "sysincludes.h"
#ifdef OS_linux
#include "msdos.h"
#include "mtools.h"
#include "devices.h"
#include "xdf_io.h"

/* Algorithms can't be patented */

typedef struct sector_map {
	unsigned int head:1;
	unsigned int size:7;
} sector_map_t;


static struct {
  unsigned char track_size;
  unsigned int track0_size:7;
  unsigned int rootskip:1;
  unsigned char rate;
  sector_map_t map[9];
} xdf_table[]= {
  {
    19, 16, 0, 0,
    {	{0,3},	{0,6},	{1,2},	{0,2},	{1,6},	{1,3},	{0,0} }
  },
  {
    23, 19, 0, 0,
    {	{0,3},	{0,4},	{1,6},	{0,2},	{1,2},	{0,6},	{1,4},	{1,3},	{0,0} }
  },
  {
    46, 37, 1, 0x43,
    {	{0,3},	{0,4},	{0,5},	{0,7},	{1,3},	{1,4},	{1,5},	{1,7},	{0,0} }
  },
  {
    24, 20, 1, 0,
    {	{0,5},	{1,6},	{0,6},	{1, 5} }
  },
  {
    48, 41, 1, 0,
    {	{0,6},	{1,7},	{0,7},	{1, 6} }
  }
};

#define NUMBER(x) (sizeof(x)/sizeof(x[0]))

typedef struct {
	unsigned char begin; /* where it begins */
	unsigned char end;
	unsigned char sector;
	unsigned char sizecode;

	unsigned int dirty:1;
	unsigned int phantom:2;
	unsigned int valid:1;
	unsigned int head:1;
} TrackMap_t;



typedef struct Xdf_t {
	struct Stream_t head;

	int fd;
	char *buffer;

	bool track_valid;
	uint8_t current_track;

	sector_map_t *map;

	uint32_t track_size;
	int track0_size;
	uint16_t sector_size;
	uint8_t FatSize;
	uint16_t RootDirSize;
	TrackMap_t *track_map;

	unsigned char last_sector;
	unsigned char rate;

	unsigned int stretch:1;
	unsigned int rootskip:1;
	signed  int drive:4;
} Xdf_t;

typedef struct {
	unsigned char head;
	unsigned char sector;
	unsigned char ptr;
} Compactify_t;


static int analyze_reply(RawRequest_t *raw_cmd, int do_print)
{
	int ret, bytes, newbytes;

	bytes = 0;
	while(1) {
		ret = analyze_one_reply(raw_cmd, &newbytes, do_print);
		bytes += newbytes;
		switch(ret) {
			case 0:
				return bytes;
			case 1:
				raw_cmd++;
				break;
			case -1:
				if(bytes)
					return bytes;
				else
					return 0;
		}
	}
}



static int send_cmd(int fd, RawRequest_t *raw_cmd, int nr,
		    const char *message, int retries)
{
	int j;
	int ret=-1;

	if(!nr)
		return 0;
	for (j=0; j< retries; j++){
		switch(send_one_cmd(fd, raw_cmd, message)) {
			case -1:
				return -1;
			case 1:
				j++;
				continue;
			case 0:
				break;
		}
		if((ret=analyze_reply(raw_cmd, j)) > 0)
			return ret; /* ok */
	}
	if(j > 1 && j == retries) {
		fprintf(stderr,"Too many errors, giving up\n");
		return 0;
	}
	return -1;
}



#define REC (This->track_map[ptr])
#define END(x) (This->track_map[(x)].end)
#define BEGIN(x) (This->track_map[(x)].begin)

static int add_to_request(Xdf_t *This, unsigned char ptr,
			  RawRequest_t *request, int *nr,
			  int direction, Compactify_t *compactify)
{
#if 0
	if(direction == MT_WRITE) {
		printf("writing %d: %u %d %d %d [%02x]\n",
		       ptr, This->current_track,
		       REC.head, REC.sector, REC.sizecode,
		       *(This->buffer + ptr * This->sector_size));
	} else
			printf(" load %d.%u\n", This->current_track, ptr);
#endif
	if(REC.phantom) {
		if(direction== MT_READ)
			memset(This->buffer + ptr * This->sector_size, 0,
			       128u << REC.sizecode);
		return 0;
	}

	if(*nr &&
	   RR_SIZECODE(request+(*nr)-1) == REC.sizecode &&
	   compactify->head == REC.head &&
	   compactify->ptr + 1 == ptr &&
	   compactify->sector +1 == REC.sector) {
		RR_SETSIZECODE(request+(*nr)-1, REC.sizecode);
	} else {
		if(*nr)
			RR_SETCONT(request+(*nr)-1);
		RR_INIT(request+(*nr));
		RR_SETDRIVE(request+(*nr), This->drive);
		RR_SETRATE(request+(*nr), This->rate);
		RR_SETTRACK(request+(*nr), This->current_track);
		RR_SETPTRACK(request+(*nr),
			     This->current_track << This->stretch);
		RR_SETHEAD(request+(*nr), REC.head);
		RR_SETSECTOR(request+(*nr), REC.sector);
		RR_SETSIZECODE(request+(*nr), REC.sizecode);
		RR_SETDIRECTION(request+(*nr), direction);
		RR_SETDATA(request+(*nr),
			   (caddr_t) This->buffer + ptr * This->sector_size);
		(*nr)++;
	}
	compactify->ptr = ptr;
	compactify->head = REC.head;
	compactify->sector = REC.sector;
	return 0;
}


static void add_to_request_if_invalid(Xdf_t *This, unsigned char ptr,
				     RawRequest_t *request, int *nr,
				     Compactify_t *compactify)
{
	if(!REC.valid)
		add_to_request(This, ptr, request, nr, MT_READ, compactify);

}


static void adjust_bounds(Xdf_t *This, uint32_t ibegin, uint32_t iend,
			  uint8_t *begin, uint8_t *end)
{
	/* translates begin and end from byte to sectors */
	*begin = (uint8_t) (ibegin / This->sector_size);
	*end = (uint8_t) ((iend + This->sector_size - 1) / This->sector_size);
}


static __inline__ int try_flush_dirty(Xdf_t *This)
{
	unsigned char ptr;
	int nr, bytes;
	RawRequest_t requests[100];
	Compactify_t compactify;

	if(!This->track_valid)
		return 0;

	nr = 0;
	for(ptr=0; ptr < This->last_sector; ptr=REC.end)
		if(REC.dirty)
			add_to_request(This, ptr,
				       requests, &nr,
				       MT_WRITE, &compactify);
#if 1
	bytes = send_cmd(This->fd,requests, nr, "writing", 4);
	if(bytes < 0)
		return bytes;
#else
	bytes = 0xffffff;
#endif
	for(ptr=0; ptr < This->last_sector; ptr=REC.end)
		if(REC.dirty) {
			if(bytes >= REC.end - REC.begin) {
				bytes -= REC.end - REC.begin;
				REC.dirty = 0;
			} else
				return 1;
		}
	return 0;
}



static int flush_dirty(Xdf_t *This)
{
	int ret;

	while((ret = try_flush_dirty(This))) {
		if(ret < 0)
			return ret;
	}
	return 0;
}


static ssize_t load_data(Xdf_t *This, uint32_t ibegin, uint32_t iend,
			 int retries)
{
	unsigned char ptr;
	int nr, bytes;
	RawRequest_t requests[100];
	Compactify_t compactify;
	unsigned char begin, end;
	adjust_bounds(This, ibegin, iend, &begin, &end);

	ptr = begin;
	nr = 0;
	for(ptr=REC.begin; ptr < end ; ptr = REC.end)
		add_to_request_if_invalid(This, ptr, requests, &nr,
					  &compactify);
	bytes = send_cmd(This->fd,requests, nr, "reading", retries);
	if(bytes < 0)
		return bytes;
	ptr = begin;
	for(ptr=REC.begin; ptr < end ; ptr = REC.end) {
		if(!REC.valid) {
			if(bytes >= REC.end - REC.begin) {
				bytes -= REC.end - REC.begin;
				REC.valid = 1;
			} else if(ptr > begin)
				return ptr * This->sector_size;
			else
				return -1;
		}
	}
	return end * This->sector_size;
}

static void mark_dirty(Xdf_t *This, uint32_t ibegin, uint32_t iend)
{
	int ptr;
	unsigned char begin, end;

	adjust_bounds(This, ibegin, iend, &begin, &end);

	ptr = begin;
	for(ptr=REC.begin; ptr < end ; ptr = REC.end) {
		REC.valid = 1;
		if(!REC.phantom)
			REC.dirty = 1;
	}
}


static ssize_t load_bounds(Xdf_t *This, uint32_t begin, uint32_t end)
{
	unsigned char lbegin, lend;

	adjust_bounds(This, begin, end, &lbegin, &lend);

	if(begin != BEGIN(lbegin) * This->sector_size &&
	   end != BEGIN(lend) * This->sector_size &&
	   lend < END(END(lbegin)))
		/* contiguous end & begin, load them in one go */
		return load_data(This, begin, end, 4);

	if(begin != BEGIN(lbegin) * This->sector_size) {
		ssize_t ret = load_data(This, begin, begin, 4);
		if(ret < 0)
			return ret;
	}

	if(end != BEGIN(lend) * This->sector_size) {
		ssize_t ret = load_data(This, end, end, 4);
		if(ret < 0)
			return BEGIN(lend) * This->sector_size;
	}
	return lend * This->sector_size;
}

/* Fill out a map that is just sufficient to read boot sector */
static void fill_boot(Xdf_t *This)
{
	uint8_t ptr=0;

	REC.head = 0;
	REC.sector = 129;
	REC.phantom = 0;

	REC.begin = ptr;
	REC.end = ptr+1;

	REC.sizecode = 2;

	REC.valid = 0;
	REC.dirty = 0;
	This->last_sector=1;
	This->current_track=0;
}


static uint8_t fill_t0(Xdf_t *This, uint8_t ptr, unsigned int size,
		       uint8_t *sector, uint8_t *head)
{
	unsigned int n;

	for(n = 0; n < size; ptr++,n++) {
		REC.head = *head;
		REC.sector = *sector + 129;
		REC.phantom = 0;
		(*sector)++;
		if(!*head && *sector >= This->track0_size - 8) {
			*sector = 0;
			*head = 1;
		}
	}
	return ptr;
}


static uint8_t fill_phantoms(Xdf_t *This, uint8_t ptr, uint8_t size)
{
	unsigned int n;

	for(n = 0; n < size; ptr++,n++)
		REC.phantom = 1;
	return ptr;
}

static int decompose(Xdf_t *This, mt_off_t iwhere, size_t len,
		     uint32_t *begin, uint32_t *end, uint8_t boot)
{
	uint8_t ptr;
	sector_map_t *map;
	uint8_t lbegin, lend;
	uint32_t track_size = This->track_size * 1024;

	smt_off_t track = (smt_off_t) iwhere / track_size;
	uint32_t where = (smt_off_t) iwhere % track_size;

	*begin = where;
	if(where + len > track_size)
		*end = track_size;
	else
		*end = (uint32_t) (where + len);

	if(This->current_track == track && !boot)
		/* already OK, return immediately */
		return 0;
	if(!boot)
		flush_dirty(This);
	if(track >= 80)
		return -1;
	This->current_track = (uint8_t) track;
	This->track_valid = true;

	if(track) {
		for(ptr=0, map=This->map; map->size; map++) {
			/* iterate through all sectors */
			lbegin = ptr;
			lend = ptr +
				(uint8_t) ((128u<<map->size)/This->sector_size);
			for( ; ptr < lend ; ptr++) {
				REC.begin = lbegin;
				REC.end = lend;

				REC.head = map->head;
				REC.sector = map->size + 128;
				REC.sizecode = map->size;

				REC.valid = 0;
				REC.dirty = 0;
				REC.phantom = 0;
			}
		}
		REC.begin = REC.end = ptr;
	} else {
		uint8_t sector, head;

		head = 0;
		sector = 0;

		for(ptr=boot; ptr < 2 * This->track_size; ptr++) {
			REC.begin = ptr;
			REC.end = ptr+1;

			REC.sizecode = 2;

			REC.valid = 0;
			REC.dirty = 0;
		}

		/* boot & 1st fat */
		ptr=fill_t0(This, 0, 1 + This->FatSize, &sector, &head);

		/* second fat */
		ptr=fill_phantoms(This, ptr, This->FatSize);

		/* root dir */
		ptr=fill_t0(This, ptr, This->RootDirSize, &sector, &head);

		/* "bad sectors" at the beginning of the fs */
		ptr=fill_phantoms(This, ptr, 5);

		if(This->rootskip)
			sector++;

		/* beginning of the file system */
		ptr = fill_t0(This, ptr,
			      (This->track_size - This->FatSize) * 2 -
			      This->RootDirSize - 6,
			      &sector, &head);
	}
	This->last_sector = ptr;
	return 0;
}


static ssize_t xdf_pread(Stream_t *Stream, char *buf,
			 mt_off_t where, size_t len)
{
	uint32_t begin, end;
	ssize_t ret;
	DeclareThis(Xdf_t);

	if(decompose(This, truncBytes32(where), len, &begin, &end, 0) < 0)
		/* Read beyond end of device */
		return 0;
	ret = load_data(This, begin, end, 4);
	if(ret < 0 || (size_t) ret < begin)
		return -1;
	maximize(len, (size_t) ret - begin);
	memcpy(buf, This->buffer + begin, len);
	return (ssize_t) (end - begin);
}

static ssize_t xdf_pwrite(Stream_t *Stream, char *buf,
			  mt_off_t where, size_t len)
{
	uint32_t begin, end;
	ssize_t len2;
	DeclareThis(Xdf_t);

	if(decompose(This, truncBytes32(where), len, &begin, &end, 0) < 0) {
		/* Write beyond end of device */
		errno = EFBIG;
		return -1;
	}

	len2 = load_bounds(This, begin, end);
	if(len2 < 0)
		return -1;
	maximize(end, (uint32_t)len2);
	len2 -= begin;
	maximize(len, (size_t) len2);
	memcpy(This->buffer + begin, buf, len);
	mark_dirty(This, begin, end);
	return (ssize_t) (end - begin);
}

static int xdf_flush(Stream_t *Stream)
{
	DeclareThis(Xdf_t);

	return flush_dirty(This);
}

static int xdf_free(Stream_t *Stream)
{
	DeclareThis(Xdf_t);
	Free(This->track_map);
	Free(This->buffer);
	return close(This->fd);
}


static int check_geom(Xdf_t *This, struct device *dev)
{
	unsigned int sect;

	if (!IS_MFORMAT_ONLY(dev)) {
	    if(compare(dev->sectors, 19) &&
	       compare(dev->sectors, 23) &&
	       compare(dev->sectors, 24) &&
	       compare(dev->sectors, 46) &&
	       compare(dev->sectors, 48))
		return 1;

	    /* check against contradictory info from configuration file */
	    if(compare(dev->heads, 2))
		return 1;
	}

	/* check against info from boot */
	if(This) {
		sect = This->track_size;
		if((sect != 19 && sect != 23 && sect != 24 &&
		    sect != 46 && sect != 48) ||
		   (!IS_MFORMAT_ONLY(dev) && compare(dev->sectors, sect)))
			return 1;
	}
	return 0;
}

static void set_geom(Xdf_t *This, struct device *dev)
{
	/* fill in config info to be returned to user */
	dev->heads = 2;
	dev->use_2m = 0xff;
	dev->sectors = (uint16_t) This->track_size;
	dev->tracks = 80;
}

static int config_geom(Stream_t *Stream UNUSEDP, struct device *dev,
		       struct device *orig_dev UNUSEDP)
{
	DeclareThis(Xdf_t);
	if(check_geom(This, dev))
		return 1;
	set_geom(This, dev);
	return 0;
}

static Class_t XdfClass = {
	0,
	0,
	xdf_pread,
	xdf_pwrite,
	xdf_flush,
	xdf_free,
	config_geom,
	0, /* get_data */
	0, /* pre-allocate */
	0, /* get_dosConvert */
	0 /* discard */
};

Stream_t *XdfOpen(struct device *dev, const char *name,
		  int mode, char *errmsg, struct xdf_info *info)
{
	Xdf_t *This;
	uint32_t begin, end;
	union bootsector *boot;
	unsigned int type;
	uint16_t fatSize;

	if(dev && ((!SHOULD_USE_XDF(dev) && !getenv("MTOOLS_USE_XDF")) ||
		   check_geom(NULL, dev)))
		return NULL;

	This = New(Xdf_t);
	if (!This)
		return NULL;
	init_head(&This->head, &XdfClass, NULL);

	This->sector_size = 512;
	This->stretch = 0;

	precmd(dev);
	This->fd = open(name,
			((mode | dev->mode) & ~O_ACCMODE) |
			O_EXCL | O_NDELAY | O_RDWR);
	if(This->fd < 0) {
#ifdef HAVE_SNPRINTF
		snprintf(errmsg,199,"xdf floppy: open: \"%s\"", strerror(errno));
#else
		sprintf(errmsg,"xdf floppy: open: \"%s\"", strerror(errno));
#endif
		goto exit_0;
	}
	closeExec(This->fd);

	This->drive = GET_DRIVE(This->fd);
	if(This->drive < 0)
		goto exit_1;

	/* allocate buffer */
	This->buffer = (char *) malloc(96 * 512);
	if (!This->buffer)
		goto exit_1;

	This->track_valid = false;
	This->track_map = (TrackMap_t *)
		calloc(96, sizeof(TrackMap_t));
	if(!This->track_map)
		goto exit_2;

	/* lock the device on writes */
	if (lock_dev(This->fd, mode == O_RDWR, dev)) {
#ifdef HAVE_SNPRINTF
		snprintf(errmsg,199,"xdf floppy: device \"%s\" busy:",
			dev->name);
#else
		sprintf(errmsg,"xdf floppy: device \"%s\" busy:",
			dev->name);
#endif
		goto exit_3;
	}

	/* Before reading the boot sector, assume dummy values suitable
	 * for reading just the boot sector */
	fill_boot(This);
	This->rate = 0;
	if (load_data(This, 0, 1, 4) < 0 ) {
		This->rate = 0x43;
		if(load_data(This, 0, 1, 4) < 0)
			goto exit_3;
	}

	boot = (union bootsector *) This->buffer;

	fatSize = WORD(fatlen);
	if(fatSize > UINT8_MAX) {
		fprintf(stderr, "Fat size %d too large\n", fatSize);
		exit(1);
	}
	This->FatSize = (uint8_t) fatSize;
	This->RootDirSize = WORD(dirents)/16;
	This->track_size = WORD(nsect);
	for(type=0; type < NUMBER(xdf_table); type++) {
		if(xdf_table[type].track_size == This->track_size) {
			This->map = xdf_table[type].map;
			This->track0_size = xdf_table[type].track0_size;
			This->rootskip = xdf_table[type].rootskip;
			This->rate = xdf_table[type].rate;
			break;
		}
	}
	if(type == NUMBER(xdf_table))
		goto exit_3;

	if(info) {
		info->RootDirSize = This->RootDirSize;
		info->FatSize = This->FatSize;
		info->BadSectors = 5;
	}
	decompose(This, 0, 512, &begin, &end, 1);

	if(dev)
		set_geom(This, dev);
	return &This->head;

exit_3:
	Free(This->track_map);
exit_2:
	Free(This->buffer);
exit_1:
	close(This->fd);
exit_0:
	Free(This);
	return NULL;
}

#endif

/* Algorithms can't be patented */