Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/dist/pdisk/SCSI_media.c

1110 lines
24 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink