pdisk/dist/SCSI_media.c

/*
 * SCSI_media.c -
 *
 * Written by Eryk Vershen
 */

/*
 * Copyright 1997,1998 by Apple Computer, Inc.
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */


// for printf() & sprintf()
#include <stdio.h>
// for malloc() & free()
#include <stdlib.h>
#include "DoSCSICommand.h"
#include "SCSI_media.h"
#include "util.h"


/*
 * Defines
 */
#define DriverRefNumToSCSI(x)  ((int16_t) (~(x) - 32))


/*
 * Types
 */
typedef struct SCSI_media *SCSI_MEDIA;

struct SCSI_media {
    struct media    m;
    long            bus;
    long            id;
};

struct bus_entry {
    long    bus;
    long    sort_value;
    long    max_id;
    long    master_id;
};

struct SCSI_manager {
    long        exists;
    long        kind;
    long        bus_count;
    struct bus_entry *bus_list;
};

typedef struct SCSI_media_iterator *SCSI_MEDIA_ITERATOR;

struct SCSI_media_iterator {
    struct media_iterator   m;
    long                    bus_index;
    long                    bus;
    long                    id;
};

struct linux_order_cache {
    struct cache_item *first;
    struct cache_item *last;
    long next_disk;
    long next_cdrom;
    long loaded;
};

struct cache_item {
    struct cache_item *next;
    long bus;
    long id;
    long value;
    long is_cdrom;
    long unsure;
};


/*
 * Global Constants
 */
enum {
    kNoDevice = 0x00FF
};

enum {
    kRequiredSCSIinquiryLength = 36
};


/*
 * Global Variables
 */
static long scsi_inited = 0;
static struct SCSI_manager scsi_mgr;
static struct linux_order_cache linux_order;


/*
 * Forward declarations
 */
int AsyncSCSIPresent(void);
void scsi_init(void);
SCSI_MEDIA new_scsi_media(void);
long read_scsi_media(MEDIA m, long long offset, uint32_t count, void *address);
long write_scsi_media(MEDIA m, long long offset, uint32_t count, void *address);
long close_scsi_media(MEDIA m);
long os_reload_scsi_media(MEDIA m);
long compute_id(long bus, long device);
int SCSI_ReadBlock(UInt32 id, UInt32 bus, UInt32 block_size, UInt32 block, UInt8 *address);
int SCSI_WriteBlock(UInt32 id, UInt32 bus, UInt32 block_size, UInt32 block, UInt8 *address);
int DoTestUnitReady(UInt8 targetID, int bus);
int DoReadCapacity(UInt32 id, UInt32 bus, UInt32 *blockCount, UInt32 *blockSize);
SCSI_MEDIA_ITERATOR new_scsi_iterator(void);
void reset_scsi_iterator(MEDIA_ITERATOR m);
char *step_scsi_iterator(MEDIA_ITERATOR m);
void delete_scsi_iterator(MEDIA_ITERATOR m);
void fill_bus_entry(struct bus_entry *entry, long bus);
/*long get_bus_sort_value(long bus);*/
int bus_entry_compare(const void* a, const void* b);
int DoInquiry(UInt32 id, UInt32 bus, UInt32 *devType);
void probe_all(void);
void probe_scsi_device(long bus, long id, int unsure);
long lookup_scsi_device(long bus, long id, int *is_cdrom, int *unsure);
long lookup_scsi_index(long index, int is_cdrom, long *bus, long *id);
void add_to_cache(long bus, long id, int is_cdrom, int unsure);
void init_linux_cache(void);
void clear_linux_cache(void);
void mark_linux_cache_loaded(void);
int linux_cache_loaded(void);


/*
 * Routines
 */
int
AsyncSCSIPresent(void)
{
    return (TrapAvailable(_SCSIAtomic));
}


void
scsi_init(void)
{
    int i;
    int old_scsi;

    if (scsi_inited != 0) {
	return;
    }
    scsi_inited = 1;

    scsi_mgr.exists = 1;
    scsi_mgr.kind = allocate_media_kind();

    if (AsyncSCSIPresent()) {
	AllocatePB();

	scsi_mgr.bus_count = gSCSIHiBusID + 1;
	old_scsi = 0;
    } else {
	scsi_mgr.bus_count = 1;
	old_scsi = 1;
    }

    scsi_mgr.bus_list = (struct bus_entry *)
	    calloc(scsi_mgr.bus_count, sizeof(struct bus_entry));

    if (scsi_mgr.bus_list == 0) {
	scsi_mgr.bus_count = 0;
    } else {
	for (i = 0; i < scsi_mgr.bus_count; i++) {
	    if (old_scsi) {
		scsi_mgr.bus_list[i].bus = 0xFF;
	    } else {
		scsi_mgr.bus_list[i].bus = i;
	    }
	    fill_bus_entry(&scsi_mgr.bus_list[i], i);
	}
	qsort((void *)scsi_mgr.bus_list,    /* address of array */
		scsi_mgr.bus_count,         /* number of elements */
		sizeof(struct bus_entry),   /* size of element */
		bus_entry_compare);         /* element comparison routine */
    }

    init_linux_cache();
}

void
fill_bus_entry(struct bus_entry *entry, long bus)
{
    OSErr           status;
    SCSIBusInquiryPB    pb;
    long len;
    long result;
    long x, y;

    if (!AsyncSCSIPresent()) {
    	entry->sort_value = 0;
	entry->max_id = 7;
	entry->master_id = 7;
	return;
    }
    len = sizeof(SCSIBusInquiryPB);
    clear_memory((Ptr) &pb, len);
    pb.scsiPBLength = len;
    pb.scsiFunctionCode = SCSIBusInquiry;
    pb.scsiDevice.bus = bus;
    status = SCSIAction((SCSI_PB *) &pb);
    if (status != noErr) {
	result = 6;
    } else {
	switch (pb.scsiHBAslotType) {
	case scsiMotherboardBus:    x = 0; break;
	case scsiPDSBus:            x = 1; break;
	case scsiNuBus:             x = 2; break;
	case scsiPCIBus:            x = 3; break;
	case scsiFireWireBridgeBus: x = 4; break;
	case scsiPCMCIABus:         x = 5; break;
	default:                    x = 7 + pb.scsiHBAslotType; break;
	};

	switch (pb.scsiFeatureFlags & scsiBusInternalExternalMask) {
	case scsiBusInternal:                   y = 0; break;
	case scsiBusInternalExternal:           y = 1; break;
	case scsiBusExternal:                   y = 2; break;
	default:
	case scsiBusInternalExternalUnknown:    y = 3; break;
	};
	result = x * 4 + y;
    }
    entry->sort_value = result;
    entry->max_id = pb.scsiMaxLUN;
    entry->master_id = pb.scsiInitiatorID;
}


int
bus_entry_compare(const void* a, const void* b)
{
    long result;

    const struct bus_entry *x = (const struct bus_entry *) a;
    const struct bus_entry *y = (const struct bus_entry *) b;

    result = x->sort_value - y->sort_value;
    if (result == 0) {
	result = x->bus - y->bus;
    }
    return result;
}


SCSI_MEDIA
new_scsi_media(void)
{
    return (SCSI_MEDIA) new_media(sizeof(struct SCSI_media));
}


MEDIA
open_old_scsi_as_media(long device)
{
    return open_scsi_as_media(kOriginalSCSIBusAdaptor, device);
}


MEDIA
open_scsi_as_media(long bus, long device)
{
    SCSI_MEDIA  a;
    UInt32 blockCount;
    UInt32 blockSize;

    if (scsi_inited == 0) {
	scsi_init();
    }

    if (scsi_mgr.exists == 0) {
	return 0;
    }

    a = 0;
    if (DoTestUnitReady(device, bus) > 0) {
	if (DoReadCapacity(device, bus, &blockCount, &blockSize) != 0) {
	    a = new_scsi_media();
	    if (a != 0) {
		a->m.kind = scsi_mgr.kind;
		a->m.grain = blockSize;
		a->m.size_in_bytes = ((long long)blockCount) * blockSize;
		a->m.do_read = read_scsi_media;
		a->m.do_write = write_scsi_media;
		a->m.do_close = close_scsi_media;
		a->m.do_os_reload = os_reload_scsi_media;
		a->bus = bus;
		a->id = device;
	    }
	}
    }
    return (MEDIA) a;
}


long
read_scsi_media(MEDIA m, long long offset, uint32_t count, void *address)
{
    SCSI_MEDIA a;
    long rtn_value;
    long block;
    long block_count;
    long block_size;
    uint8_t *buffer;
    int i;

    block = (long) offset;
//printf("scsi %d count %d\n", block, count);
    a = (SCSI_MEDIA) m;
    rtn_value = 0;
    if (a == 0) {
	/* no media */
    } else if (a->m.kind != scsi_mgr.kind) {
	/* wrong kind - XXX need to error here - this is an internal problem */
    } else if (count <= 0 || count % a->m.grain != 0) {
	/* can't handle size */
    } else if (offset < 0 || offset % a->m.grain != 0) {
	/* can't handle offset */
    } else if (offset + count > a->m.size_in_bytes) {
	/* check for offset (and offset+count) too large */
    } else {
	/* XXX do a read on the physical device */
	block_size = a->m.grain;
	block = offset / block_size;
	block_count = count / block_size;
	buffer = address;
	rtn_value = 1;
	for (i = 0; i < block_count; i++) {
	    if (SCSI_ReadBlock(a->id, a->bus, block_size, block, buffer) == 0) {
		rtn_value = 0;
		break;
	    }
	    buffer += block_size;
	    block += 1;
	}
    }
    return rtn_value;
}


long
write_scsi_media(MEDIA m, long long offset, uint32_t count, void *address)
{
    SCSI_MEDIA a;
    long rtn_value;
    long block;
    long block_count;
    long block_size;
    uint8_t *buffer;
    int i;

    a = (SCSI_MEDIA) m;
    rtn_value = 0;
    if (a == 0) {
	/* no media */
    } else if (a->m.kind != scsi_mgr.kind) {
	/* XXX need to error here - this is an internal problem */
    } else if (count <= 0 || count % a->m.grain != 0) {
	/* can't handle size */
    } else if (offset < 0 || offset % a->m.grain != 0) {
	/* can't handle offset */
    } else if (offset + count > a->m.size_in_bytes) {
	/* check for offset (and offset+count) too large */
    } else {
	/* XXX do a write on the physical device */
	block_size = a->m.grain;
	block = offset / block_size;
	block_count = count / block_size;
	buffer = address;
	rtn_value = 1;
	for (i = 0; i < block_count; i++) {
	    if (SCSI_WriteBlock(a->id, a->bus, block_size, block, buffer) == 0) {
		rtn_value = 0;
		break;
	    }
	    buffer += block_size;
	    block += 1;
	}
    }
    return rtn_value;
}


long
close_scsi_media(MEDIA m)
{
    SCSI_MEDIA a;

    a = (SCSI_MEDIA) m;
    if (a == 0) {
	return 0;
    } else if (a->m.kind != scsi_mgr.kind) {
	/* XXX need to error here - this is an internal problem */
	return 0;
    }
    /* XXX nothing to do - I think? */
    return 1;
}


long
os_reload_scsi_media(MEDIA m)
{
    printf("Reboot your system so the partition table will be reread.\n");
    return 1;
}


#pragma mark -


int
DoTestUnitReady(UInt8 targetID, int bus)
{
    OSErr                   status;
    Str255                  errorText;
    char*       msg;
    static const SCSI_6_Byte_Command gTestUnitReadyCommand = {
	kScsiCmdTestUnitReady, 0, 0, 0, 0, 0
    };
    SCSI_Sense_Data         senseData;
    DeviceIdent scsiDevice;
    int rtn_value;

    scsiDevice.diReserved = 0;
    scsiDevice.bus = bus;
    scsiDevice.targetID = targetID;
    scsiDevice.LUN = 0;

    status = DoSCSICommand(
		scsiDevice,
		"\pTest Unit Ready",
		(SCSI_CommandPtr) &gTestUnitReadyCommand,
		NULL,
		0,
		scsiDirectionNone,
		NULL,
		&senseData,
		errorText
		);
    if (status == scsiNonZeroStatus) {
	rtn_value = -1;
    } else if (status != noErr) {
	rtn_value = 0;
    } else {
	rtn_value = 1;
    }
    return rtn_value;
}


int
SCSI_ReadBlock(UInt32 id, UInt32 bus, UInt32 block_size, UInt32 block, UInt8 *address)
{
    OSErr                   status;
    Str255                  errorText;
    char*       msg;
    static SCSI_10_Byte_Command gReadCommand = {
	kScsiCmdRead10, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    SCSI_Sense_Data         senseData;
    DeviceIdent scsiDevice;
    int rtn_value;
    long count;

//printf("scsi read %d:%d block %d size %d\n", bus, id, block, block_size);
    scsiDevice.diReserved = 0;
    scsiDevice.bus = bus;
    scsiDevice.targetID = id;
    scsiDevice.LUN = 0;

    gReadCommand.lbn4 = (block >> 24) & 0xFF;
    gReadCommand.lbn3 = (block >> 16) & 0xFF;
    gReadCommand.lbn2 = (block >> 8) & 0xFF;
    gReadCommand.lbn1 = block & 0xFF;

    count = 1;
    gReadCommand.len2 = (count >> 8) & 0xFF;
    gReadCommand.len1 = count & 0xFF;

    status = DoSCSICommand(
		scsiDevice,
		"\pRead",
		(SCSI_CommandPtr) &gReadCommand,
		(Ptr) address,
		count * block_size,
		scsiDirectionIn,
		NULL,
		&senseData,
		errorText
	);
    if (status == noErr) {
	rtn_value = 1;
    } else {
	rtn_value = 0;
    }
    return rtn_value;
}


int
SCSI_WriteBlock(UInt32 id, UInt32 bus, UInt32 block_size, UInt32 block, UInt8 *address)
{
    OSErr                   status;
    Str255                  errorText;
    char*       msg;
    static SCSI_10_Byte_Command gWriteCommand = {
	kScsiCmdWrite10, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    SCSI_Sense_Data         senseData;
    DeviceIdent scsiDevice;
    int rtn_value;
    long count;

    scsiDevice.diReserved = 0;
    scsiDevice.bus = bus;
    scsiDevice.targetID = id;
    scsiDevice.LUN = 0;

    gWriteCommand.lbn4 = (block >> 24) & 0xFF;
    gWriteCommand.lbn3 = (block >> 16) & 0xFF;
    gWriteCommand.lbn2 = (block >> 8) & 0xFF;
    gWriteCommand.lbn1 = block & 0xFF;

    count = 1;
    gWriteCommand.len2 = (count >> 8) & 0xFF;
    gWriteCommand.len1 = count & 0xFF;

    status = DoSCSICommand(
		scsiDevice,
		"\pWrite",
		(SCSI_CommandPtr) &gWriteCommand,
		(Ptr) address,
		count * block_size,
		scsiDirectionOut,
		NULL,
		&senseData,
		errorText
	);
    if (status == noErr) {
	rtn_value = 1;
    } else {
	rtn_value = 0;
    }
    return rtn_value;
}


int
DoReadCapacity(UInt32 id, UInt32 bus, UInt32 *blockCount, UInt32 *blockSize)
{
    OSErr       status;
    Str255      errorText;
    static const SCSI_10_Byte_Command gCapacityCommand = {
	kScsiCmdReadCapacity, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    SCSI_Sense_Data senseData;
    DeviceIdent     scsiDevice;
    SCSI_Capacity_Data  capacityData;
    UInt32      temp;
    int rtn_value;

    scsiDevice.diReserved = 0;
    scsiDevice.bus = bus;
    scsiDevice.targetID = id;
    scsiDevice.LUN = 0;

    CLEAR(capacityData);

    status = DoSCSICommand(
		scsiDevice,
		"\pRead Capacity",
		(SCSI_CommandPtr) &gCapacityCommand,
		(Ptr) &capacityData,
		sizeof (SCSI_Capacity_Data),
		scsiDirectionIn,
		NULL,
		&senseData,
		errorText
		);

    if (status == noErr) {
	temp = capacityData.lbn4;
	temp = (temp << 8) | capacityData.lbn3;
	temp = (temp << 8) | capacityData.lbn2;
	temp = (temp << 8) | capacityData.lbn1;
	*blockCount = temp;

	temp = capacityData.len4;
	temp = (temp << 8) | capacityData.len3;
	temp = (temp << 8) | capacityData.len2;
	temp = (temp << 8) | capacityData.len1;
	*blockSize = temp;

	rtn_value = 1;
    } else {
	rtn_value = 0;
    }
    return rtn_value;
}


int
DoInquiry(UInt32 id, UInt32 bus, UInt32 *devType)
{
    OSErr       status;
    Str255      errorText;
    static const SCSI_6_Byte_Command gInquiryCommand = {
	kScsiCmdInquiry, 0, 0, 0, kRequiredSCSIinquiryLength, 0
    };
    SCSI_Sense_Data senseData;
    DeviceIdent     scsiDevice;
    SCSI_Inquiry_Data  inquiryData;
    UInt32      temp;
    int rtn_value;

    scsiDevice.diReserved = 0;
    scsiDevice.bus = bus;
    scsiDevice.targetID = id;
    scsiDevice.LUN = 0;

    CLEAR(inquiryData);

    status = DoSCSICommand(
		scsiDevice,
		"\pInquiry",
		(SCSI_CommandPtr) &gInquiryCommand,
		(Ptr) &inquiryData,
		kRequiredSCSIinquiryLength,
		scsiDirectionIn,
		NULL,
		&senseData,
		errorText
		);

    if (status == noErr) {
	*devType = inquiryData.devType & kScsiDevTypeMask;
	rtn_value = 1;
    } else {
	rtn_value = 0;
    }
    return rtn_value;
}


MEDIA
SCSI_FindDevice(long dRefNum)
{
    SCSIDriverPB            pb;
    OSErr                   status;
    short                   targetID;

    status = nsvErr;
    if (AsyncSCSIPresent()) {
	clear_memory((Ptr) &pb, sizeof pb);

	pb.scsiPBLength = sizeof (SCSIDriverPB);
	pb.scsiCompletion = NULL;
	pb.scsiFlags = 0;
	pb.scsiFunctionCode = SCSILookupRefNumXref;
	pb.scsiDevice.bus = kNoDevice;  /* was *((long *) &pb.scsiDevice) = 0xFFFFFFFFL; */

	do {
	    status = SCSIAction((SCSI_PB *) &pb);

	    if (status != noErr) {
		break;
	    } else if (pb.scsiDriver == dRefNum
		    && pb.scsiDevice.bus != kNoDevice) {
		return open_scsi_as_media(pb.scsiDevice.bus, pb.scsiDevice.targetID);

	    } else {
		pb.scsiDevice = pb.scsiNextDevice;
	    }
	}
	while (pb.scsiDevice.bus != kNoDevice);
    }
    if (status == nsvErr) {
	/*
	 * The asynchronous SCSI Manager is missing or the
	 * driver didn't register with the SCSI Manager.*/
	targetID = DriverRefNumToSCSI(dRefNum);
	if (targetID >= 0 && targetID <= 6) {
	    return open_old_scsi_as_media(targetID);
	}
    }
     return 0;
}


#pragma mark -


SCSI_MEDIA_ITERATOR
new_scsi_iterator(void)
{
    return (SCSI_MEDIA_ITERATOR) new_media_iterator(sizeof(struct SCSI_media_iterator));
}


MEDIA_ITERATOR
create_scsi_iterator(void)
{
    SCSI_MEDIA_ITERATOR a;

    if (scsi_inited == 0) {
	scsi_init();
    }

    if (scsi_mgr.exists == 0) {
	return 0;
    }

    a = new_scsi_iterator();
    if (a != 0) {
	a->m.kind = scsi_mgr.kind;
	a->m.state = kInit;
	a->m.do_reset = reset_scsi_iterator;
	a->m.do_step = step_scsi_iterator;
	a->m.do_delete = delete_scsi_iterator;
	a->bus_index = 0;
	a->bus = 0;
	a->id = 0;
    }

    return (MEDIA_ITERATOR) a;
}


void
reset_scsi_iterator(MEDIA_ITERATOR m)
{
    SCSI_MEDIA_ITERATOR a;

    a = (SCSI_MEDIA_ITERATOR) m;
    if (a == 0) {
	/* no media */
    } else if (a->m.kind != scsi_mgr.kind) {
	/* wrong kind - XXX need to error here - this is an internal problem */
    } else if (a->m.state != kInit) {
	a->m.state = kReset;
    }
}


char *
step_scsi_iterator(MEDIA_ITERATOR m)
{
    SCSI_MEDIA_ITERATOR a;
    char *result;

    a = (SCSI_MEDIA_ITERATOR) m;
    if (a == 0) {
	/* no media */
    } else if (a->m.kind != scsi_mgr.kind) {
	/* wrong kind - XXX need to error here - this is an internal problem */
    } else {
	switch (a->m.state) {
	case kInit:
	    /* find # of buses - done in AllocatePB() out of scsi_init() */
	    a->m.state = kReset;
	    /* fall through to reset */
	case kReset:
	    a->bus_index = 0 /* first bus id */;
	    a->bus = scsi_mgr.bus_list[a->bus_index].bus;
	    a->id = 0 /* first device id */;
	    a->m.state = kIterating;
	    clear_linux_cache();
	    /* fall through to iterate */
	case kIterating:
	    while (1) {
		if (a->bus_index >= scsi_mgr.bus_count /* max bus id */) {
		    break;
		}
		if (a->id == scsi_mgr.bus_list[a->bus_index].master_id) {
		    /* next id */
		    a->id += 1;
		}
		if (a->id > scsi_mgr.bus_list[a->bus_index].max_id) {
		    a->bus_index += 1;
		    a->bus = scsi_mgr.bus_list[a->bus_index].bus;
		    a->id = 0 /* first device id */;
		    continue;   /* try again */
		}
		/* generate result */
		result = (char *) malloc(20);
		if (result != NULL) {
		    if (a->bus == 0xFF) {
			snprintf(result, 20, "/dev/scsi%c", '0'+a->id);
			probe_scsi_device(a->bus, a->id, 1);
		    } else {
			// insure bus number in range
			if (a->bus > 9) {
			    free(result);
			    result = NULL;
			    break;
			}
			snprintf(result, 20, "/dev/scsi%c.%c",
			    '0'+a->bus, '0'+a->id);
			/* only probe out of iterate; so always added in order. */
			probe_scsi_device(a->bus, a->id, 0);
		    }
		}

		a->id += 1; /* next id */
		return result;
	    }
	    a->m.state = kEnd;
	    /* fall through to end */
	case kEnd:
	    mark_linux_cache_loaded();
	default:
	    break;
	}
    }
    return 0 /* no entry */;
}


void
delete_scsi_iterator(MEDIA_ITERATOR m)
{
    return;
}


#pragma mark -


MEDIA
open_linux_scsi_as_media(long index, int is_cdrom)
{
    MEDIA m;
    long bus;
    long id;

    if (lookup_scsi_index(index, is_cdrom, &bus, &id) > 0) {
	m = open_scsi_as_media(bus, id);
    } else {
	m = 0;
    }

    return m;
}


char *
linux_old_scsi_name(long id)
{
    linux_scsi_name(kOriginalSCSIBusAdaptor, id);
}


char *
linux_scsi_name(long bus, long id)
{
    char *result = 0;
    long value;
    int is_cdrom;
    int unsure;
    char *suffix;

    /* name is sda, sdb, sdc, ...
     * in order by buses and ids, but only count responding devices ...
     */
    if ((value = lookup_scsi_device(bus, id, &is_cdrom, &unsure)) >= 0) {
	result = (char *) malloc(20);
	if (result != NULL) {
	    if (unsure) {
		suffix = " ?";
	    } else {
		suffix = "";
	    }
	    if (is_cdrom) {
		if (value > 9) {
		    // too many CD's, give up
		    free(result); result = NULL;
		} else {
		    snprintf(result, 20, "/dev/scd%c%s", '0' + value, suffix);
		}
	    } else {
		if (value < 26) {
		    snprintf(result, 20, "/dev/sd%c%s", 'a' + value, suffix);
		} else {
		    snprintf(result, 20, "/dev/sd%c%c%s",
			    'a' + value / 26, 'a' + value % 26, suffix);
		}
	    }
	}
    }
    return result;
}


void
probe_all(void)
{
    MEDIA_ITERATOR iter;
    char *name;

    iter = create_scsi_iterator();
    if (iter == 0) {
	return;
    }

    printf("finding devices ");
    fflush(stdout);
    while ((name = step_media_iterator(iter)) != 0) {
    	/* step does the probe for us */
	printf(".");
	fflush(stdout);
	free(name);
    }
    delete_media_iterator(iter);
    printf("\n");
    fflush(stdout);
}


void
probe_scsi_device(long bus, long id, int unsure)
{
    UInt32 devType;

    if (DoInquiry(id, bus, &devType)) {
    	if (devType == kScsiDevTypeDirect
    		|| devType == kScsiDevTypeOptical) {
    	    add_to_cache(bus, id, 0, unsure);
    	} else if (devType == kScsiDevTypeCDROM
		|| devType == kScsiDevTypeWorm) {
    	    add_to_cache(bus, id, 1, unsure);
    	}
    }
}


long
lookup_scsi_device(long bus, long id, int *is_cdrom, int *unsure)
{
    /* walk down list looking for bus and id ?
     *
     * only probe out of iterate (so always add in order)
     * reset list if we reset the iterate
     */
    struct cache_item *item;
    struct cache_item *next;
    long result = -1;
    int count = 0;

    if (scsi_inited == 0) {
	scsi_init();
    }

    while (1) {
    	count++;
	for (item = linux_order.first; item != NULL; item = item->next) {
	    if (item->bus == bus && item->id == id) {
		result = item->value;
		*is_cdrom = item->is_cdrom;
		*unsure = item->unsure;
		break;
	    }
	}
	if (count < 2 && result < 0) {
	    probe_all();
	} else {
	    break;
	}
    };

    return result;
}


/*
 * This has the same structure as lookup_scsi_device() except we are
 * matching on the value & type rather than the bus & id.
 */
long
lookup_scsi_index(long index, int is_cdrom, long *bus, long *id)
{
    struct cache_item *item;
    struct cache_item *next;
    long result = 0;
    int count = 0;

    if (scsi_inited == 0) {
	scsi_init();
    }

    while (1) {
    	count++;
	for (item = linux_order.first; item != NULL; item = item->next) {
	    if (item->value == index && item->is_cdrom == is_cdrom
		    && item->unsure == 0) {
		result = 1;
		*bus = item->bus;
		*id = item->id;
		break;
	    }
	}
	if (count < 2 && result == 0 && !linux_cache_loaded()) {
	    probe_all();
	} else {
	    break;
	}
    };

    return result;
}


void
add_to_cache(long bus, long id, int is_cdrom, int unsure)
{
    struct cache_item *item;

    item = malloc(sizeof(struct cache_item));
    if (item == NULL) {
	return;
    } else {
	item->bus = bus;
	item->id = id;
	item->is_cdrom = is_cdrom;
	item->unsure = unsure;
	if (is_cdrom) {
	    item->value = linux_order.next_cdrom;
	    linux_order.next_cdrom++;
	} else {
	    item->value = linux_order.next_disk;
	    linux_order.next_disk++;
	}
	item->next = 0;
    }
    if (linux_order.first == NULL) {
	linux_order.first = item;
	linux_order.last = item;
    } else {
	linux_order.last->next = item;
	linux_order.last = item;
    }
}


void
init_linux_cache(void)
{
    linux_order.first = NULL;
    clear_linux_cache();
}


void
clear_linux_cache(void)
{
    struct cache_item *item;
    struct cache_item *next;

    for (item = linux_order.first; item != NULL; item = next) {
	next = item->next;
	free(item);
    }
    /* back to starting value */
    linux_order.first = NULL;
    linux_order.last = NULL;
    linux_order.next_disk = 0;
    linux_order.next_cdrom = 0;
    linux_order.loaded = 0;
}


void
mark_linux_cache_loaded(void)
{
    linux_order.loaded = 1;
}


int
linux_cache_loaded(void)
{
    return linux_order.loaded;
}