path: root/src/core/disk.c

#include <etherboot.h>
#include <disk.h>

#warning "disk.c is currently broken"
#if 0

#undef disk_disable

static int dummy(void *unused __unused)
{
	return (0);
}

static unsigned char disk_buffer[DISK_BUFFER_SIZE];
struct disk disk =
{
	{
		0,				/* dev.disable */
		{
			0,
			0,
			PCI_BUS_TYPE,
		},				/* dev.devid */
		0,				/* index */
		0,				/* type */
		PROBE_FIRST,			/* how_probe */
		PROBE_NONE,			/* to_probe */
		0,				/* failsafe */
		0,				/* type_index */
		{},				/* state */
	},
	(int (*)(struct disk *, sector_t ))dummy,		/* read */
	0 - 1, 		/* drive */
	0,		/* hw_sector_size */
	0,		/* sectors_per_read */
	0,		/* bytes */
	0,		/* sectors */
	0, 		/* sector */
	disk_buffer,	/* buffer */
	0,		/* priv */
	
	0,		/* disk_offset */
	0,		/* direction */
};


static int disk_read(
	struct disk *disk, unsigned char *buffer, sector_t sector)
{
	int result;
	sector_t base_sector;

	/* Note: I do not handle disk wrap around here! */

	/* Compute the start of the track cache */
	base_sector = sector;
	/* Support sectors_per_read > 1 only on small disks */
	if ((sizeof(sector_t) > sizeof(unsigned long)) &&
		(disk->sectors_per_read > 1)) {
		unsigned long offset;
		offset = ((unsigned long)sector) % disk->sectors_per_read;
		base_sector -= offset;
	}

	/* See if I need to update the track cache */
	if ((sector < disk->sector) ||
		sector >= disk->sector + (disk->bytes >> 9)) {
		twiddle();
		result = disk->read(disk, base_sector);
		if (result < 0)
			return result;
	}
	/* Service the request from the track cache */
	memcpy(buffer, disk->buffer + ((sector - base_sector)<<9), SECTOR_SIZE);
	return 0;
}
	
static int disk_read_sectors(
	struct disk *disk,
	unsigned char *buffer,
	sector_t base_sector, unsigned int sectors)
{
	sector_t sector = 0;
	unsigned long offset;
	int result = 0;

	for(offset = 0; offset < sectors; offset++) {
		sector = base_sector + offset;
		if (sector >= disk->sectors) {
			sector -= disk->sectors;
		}
		result = disk_read(disk, buffer + (offset << 9), sector);
		if (result < 0)
			break;
	}
	if (result < 0) {
		printf("disk read error at 0x%lx\n", sector);
	}
	return result;
}

static os_download_t probe_buffer(unsigned char *buffer, unsigned int len,
	int increment, unsigned int offset, unsigned int *roffset)
{
	os_download_t os_download;
	unsigned int end;
	end = 0;
	os_download = 0;
	if (increment > 0) {
		end = len - SECTOR_SIZE;
	}
	do {
		offset += increment;
		os_download = probe_image(buffer + offset, len - offset);
	} while(!os_download && (offset != end));
	*roffset = offset;
	return os_download;
}

static int load_image(
	struct disk *disk, 
	unsigned char *buffer, unsigned int buf_sectors,
	sector_t block, unsigned int offset,
	os_download_t os_download)
{
	sector_t skip_sectors;

	skip_sectors = 0;
	while(1) {
		skip_sectors = os_download(buffer + offset, 
			(buf_sectors << 9) - offset, 0);

		block += skip_sectors + buf_sectors;
		if (block >= disk->sectors) {
			block -= disk->sectors;
		}

		offset = 0;
		buf_sectors = 1;
		if (disk_read_sectors(disk, buffer, block, 1) < 0) {
			return 0;
		}
	}
	return -1;
}

int disk_probe(struct dev *dev)
{
	struct disk *disk = (struct disk *)dev;
	if (dev->how_probe == PROBE_NEXT) {
		disk->drive += 1;
	}
	return probe(dev);
}


int disk_load_configuration(struct dev *dev)
{
	/* Start with the very simplest possible disk configuration */
	struct disk *disk = (struct disk *)dev;
	disk->direction = (dev->failsafe)?-1:1;
	disk->disk_offset = 0;
	return 0;
}

int disk_load(struct dev *dev)
{
	struct disk *disk = (struct disk *)dev;
	/* 16K == 8K in either direction from the start of the disk */
	static unsigned char buffer[32*SECTOR_SIZE]; 
	os_download_t os_download;
	unsigned int offset;
	unsigned int len;
	unsigned int buf_sectors;
	volatile sector_t block;
	volatile int inc, increment;
	int i;
	int result;
	jmp_buf real_restart;


	printf("Searching for image...\n");
	result = 0;
	/* Only check for 16byte aligned images */
	increment = (disk->direction < 0)?-16:16;
	/* Load a buffer, and see if it contains the start of an image
	 * we can boot from disk.
	 */
	len = sizeof(buffer);
	buf_sectors = sizeof(buffer) / SECTOR_SIZE;
	inc = increment;
	block = (disk->disk_offset) >> 9;
	if (buf_sectors/2 > block) {
		block = (disk->sectors - (buf_sectors/2)) + block;
	}
	/* let probe buffer assume offset always needs to be incremented */
	offset = (len/2 + ((disk->disk_offset) & 0x1ff)) - inc;

	/* Catch longjmp so if this image fails to load, I start looking
	 * for the next image where I left off looking for this image.
	 */
	memcpy(&real_restart, &restart_etherboot, sizeof(jmp_buf));
	i = setjmp(restart_etherboot);
	if ((i != 0) && (i != -2)) {
		memcpy(&restart_etherboot, &real_restart, sizeof(jmp_buf));
		longjmp(restart_etherboot, i);
	}
	/* Read the canidate sectors into the buffer */
	if (disk_read_sectors(disk, buffer, block, buf_sectors) < 0) {
		result = -1;
		goto out;
	}
	if (inc == increment) {
		os_download = probe_buffer(buffer, len, inc, offset, &offset);
		if (os_download)
			goto load_image;
		inc = -inc;
	}
	os_download = probe_buffer(buffer, len, inc, offset, &offset);
	if (!os_download) {
		result = -1;
		goto out;
	}
 load_image:
	printf("Loading image...\n");
	result = load_image(disk, buffer, buf_sectors, block, offset, os_download);
 out:
	memcpy(&restart_etherboot, &real_restart, sizeof(jmp_buf));
	return result;
}

int url_file(const char *name,
	int (*fnc)(unsigned char *, unsigned int, unsigned int, int) __unused)
{
	unsigned int drive;
	unsigned long  disk_offset;
	int direction;
	int type;

	disk_offset = 0;
	direction = 1;
	if (memcmp(name, "disk", 4) == 0) {
		type = DISK_DRIVER;
		name += 4;
	}
	else if (memcmp(name, "floppy", 6) == 0) {
		type = FLOPPY_DRIVER;
		name += 6;
	}
	else {
		printf("Unknown device type\n");
		return 0;
	}
	drive = strtoul(name, &name, 10);
	if ((name[0] == '+') || (name[0] == '-')) {
		direction = (name[0] == '-')? -1 : 1;
		name++;
		disk_offset = strtoul(name, &name, 10);
	}
	if (name[0]) {
		printf("Junk '%s' at end of disk url\n", name);
		return 0;
	}
	memset(&disk, 0, sizeof(disk));
	disk.buffer = disk_buffer;
	disk.drive = 0;
	disk.dev.how_probe = PROBE_FIRST;
	disk.dev.type = type;
	do {
		disk_disable();
		disk.dev.how_probe = disk_probe(&disk.dev);
		if (disk.dev.how_probe == PROBE_FAILED) {
			printf("Not that many drives\n");
			return 0;
		}
	} while(disk.drive < drive);
	disk.direction = direction;
	disk.disk_offset = disk_offset;
	
	return disk_load(&disk.dev);
}

void disk_disable(void)
{
	disable(&disk.dev);
}


#endif