290 lines
6.4 KiB
C
290 lines
6.4 KiB
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
|