Linux0.96c/kernel/blk_drv/scsi/scsi.c
/*
* scsi.c Copyright (C) 1992 Drew Eckhardt
* generic mid-level SCSI driver by
* Drew Eckhardt
*
* <drew@colorado.edu>
*/
#include <linux/config.h>
#ifdef CONFIG_SCSI
#include <asm/system.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include "scsi.h"
#include "hosts.h"
#ifdef CONFIG_BLK_DEV_SD
#include "sd.h"
#endif
#ifdef CONFIG_BLK_DEV_ST
#include "st.h"
#endif
/*
static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/scsi.c,v 1.1 1992/04/24 18:01:50 root Exp root $";
*/
#define INTERNAL_ERROR (printk ("Internal error in file %s, line %s.\n", __FILE__, __LINE__), panic(""))
static void scsi_done (int host, int result);
static void update_timeout (void);
static int time_start;
static int time_elapsed;
/*
global variables :
NR_SCSI_DEVICES is the number of SCSI devices we have detected,
scsi_devices an array of these specifing the address for each
(host, id, LUN)
*/
int NR_SCSI_DEVICES=0;
Scsi_Device scsi_devices[MAX_SCSI_DEVICE];
#define SENSE_LENGTH 255
/*
As the scsi do command functions are inteligent, and may need to
redo a command, we need to keep track of the last command
executed on each one.
*/
#define WAS_RESET 0x01
#define WAS_TIMEDOUT 0x02
#define WAS_SENSE 0x04
#define IS_RESETTING 0x08
static Scsi_Cmnd last_cmnd[MAX_SCSI_HOSTS];
static int last_reset[MAX_SCSI_HOSTS];
/*
This is the number of clock ticks we should wait before we time out
and abort the command. This is for where the scsi.c module generates
the command, not where it originates from a higher level, in which
case the timeout is specified there.
ABORT_TIMEOUT and RESET_TIMEOUT are the timeouts for RESET and ABORT
respectively.
*/
#ifdef DEBUG
#define SCSI_TIMEOUT 500
#else
#define SCSI_TIMEOUT 100
#endif
#ifdef DEBUG
#define SENSE_TIMEOUT SCSI_TIMEOUT
#define ABORT_TIMEOUT SCSI_TIMEOUT
#define RESET_TIMEOUT SCSI_TIMEOUT
#else
#define SENSE_TIMEOUT 50
#define RESET_TIMEOUT 50
#define ABORT_TIMEOUT 50
#define MIN_RESET_DELAY 25
#endif
/*
As the actual SCSI command runs in the background, we must set up a
flag that tells scan_scsis() when the result it has is valid.
scan_scsis can set the_result to -1, and watch for it to become the
actual return code for that call. the scan_scsis_done function() is
our user specified completion function that is passed on to the
scsi_do_cmd() function.
*/
static int the_result;
static unsigned char sense_buffer[SENSE_LENGTH];
static void scan_scsis_done (int host, int result)
{
#ifdef DEBUG
printk ("scan_scsis_done(%d, %06x\n\r", host, result);
#endif
the_result = result;
}
/*
Detecting SCSI devices :
We scan all present host adapter's busses, from ID 0 to ID 6.
We use the INQUIRY command, determine device type, and pass the ID /
lun address of all sequential devices to the tape driver, all random
devices to the disk driver.
*/
static void scan_scsis (void)
{
int host_nr , dev, lun, type, maxed;
static unsigned char scsi_cmd [12];
static unsigned char scsi_result [256];
for (host_nr = 0; host_nr < MAX_SCSI_HOSTS; ++host_nr)
if (scsi_hosts[host_nr].present)
{
for (dev = 0; dev < 7; ++dev)
if (scsi_hosts[host_nr].this_id != dev)
#ifdef MULTI_LUN
for (lun = 0; lun < 8; ++lun)
{
#else
{
lun = 0;
#endif
/* Build an INQUIRY command block. */
scsi_cmd[0] = INQUIRY;
scsi_cmd[1] = (lun << 5) & 0xe0;
scsi_cmd[2] = 0;
scsi_cmd[3] = 0;
scsi_cmd[4] = 255;
scsi_cmd[5] = 0;
the_result = -1;
#ifdef DEBUG
memset ((void *) scsi_result , 0, 255);
#endif
scsi_do_cmd (host_nr, dev, (void *) scsi_cmd, (void *)
scsi_result, 256, scan_scsis_done,
SCSI_TIMEOUT, sense_buffer, 3);
/* Wait for valid result */
while (the_result < 0);
if (!the_result)
{
scsi_devices[NR_SCSI_DEVICES].
host_no = host_nr;
scsi_devices[NR_SCSI_DEVICES].
id = dev;
scsi_devices[NR_SCSI_DEVICES].
lun = lun;
scsi_devices[NR_SCSI_DEVICES].
removable = (0x80 &
scsi_result[1]) >> 7;
/*
Currently, all sequential devices are assumed to be tapes,
all random devices disk, with the appropriate read only
flags set for ROM / WORM treated as RO.
*/
switch (type = scsi_result[0])
{
case TYPE_TAPE:
case TYPE_DISK:
scsi_devices[NR_SCSI_DEVICES].writeable = 1;
break;
case TYPE_WORM:
case TYPE_ROM:
scsi_devices[NR_SCSI_DEVICES].writeable = 0;
break;
default:
type = -1;
}
scsi_devices[NR_SCSI_DEVICES].random = (type == TYPE_TAPE) ? 0 : 1;
maxed = 0;
switch (type)
{
case -1:
break;
case TYPE_TAPE:
printk("Detected scsi tape at host %d, ID %d, lun %d \n", host_nr, dev, lun);
#ifdef CONFIG_BLK_DEV_ST
if (!(maxed = (NR_ST == MAX_ST)))
scsi_tapes[NR_ST].device = &scsi_devices[NR_SCSI_DEVICES];
#endif
default:
printk("Detected scsi disk at host %d, ID %d, lun %d \n", host_nr, dev, lun);
#ifdef CONFIG_BLK_DEV_SD
if (!(maxed = (NR_SD >= MAX_SD)))
rscsi_disks[NR_SD].device = &scsi_devices[NR_SCSI_DEVICES];
#endif
}
if (maxed)
{
printk ("Already have detected maximum number of SCSI %ss Unable to \n"
"add drive at SCSI host %s, ID %d, LUN %d\n\r", (type == TYPE_TAPE) ?
"tape" : "disk", scsi_hosts[host_nr].name,
dev, lun);
type = -1;
break;
}
else if (type != -1)
{
if (type == TYPE_TAPE)
#ifdef CONFIG_BLK_DEV_ST
++NR_ST;
#else
;
#endif
else
#ifdef CONFIG_BLK_DEV_SD
++NR_SD;
#else
;
#endif
}
++NR_SCSI_DEVICES;
} /* if result == DID_OK ends */
} /* for lun ends */
} /* if present */
printk("Detected "
#ifdef CONFIG_BLK_DEV_SD
"%d disk%s "
#endif
#ifdef CONFIG_BLK_DEV_ST
"%d tape%s "
#endif
"total.\n",
#ifdef CONFIG_BLK_DEV_SD
NR_SD, (NR_SD != 1) ? "s" : ""
#ifdef CONFIG_BLK_DEV_ST
,
#endif
#endif
#ifdef CONFIG_BLK_DEV_ST
NR_ST, (NR_ST != 1) ? "s" : ""
#endif
);
} /* scan_scsis ends */
/*
We handle the timeout differently if it happens when a reset,
abort, etc are in process.
*/
static unsigned char internal_timeout[MAX_SCSI_HOSTS];
/* Flag bits for the internal_timeout array */
#define NORMAL_TIMEOUT 0
#define IN_ABORT 1
#define IN_RESET 2
/*
This is our time out function, called when the timer expires for a
given host adapter. It will attempt to abort the currently executing
command, that failing perform a kernel panic.
*/
static void scsi_times_out (int host)
{
switch (internal_timeout[host] & (IN_ABORT | IN_RESET))
{
case NORMAL_TIMEOUT:
printk("SCSI host %d timed out - aborting command \r\n",
host);
if (!scsi_abort (host, DID_TIME_OUT))
return;
case IN_ABORT:
printk("SCSI host %d abort() timed out - reseting \r\n",
host);
if (!scsi_reset (host))
return;
case IN_RESET:
case (IN_ABORT | IN_RESET):
printk("Unable to reset scsi host %d\r\n",host);
panic("");
default:
INTERNAL_ERROR;
}
}
/*
This is inline because we have stack problemes if we recurse to deeply.
*/
static void internal_cmnd (int host, unsigned char target, const void *cmnd ,
void *buffer, unsigned bufflen, void (*done)(int,int))
{
int temp;
#ifdef DEBUG_DELAY
int clock;
#endif
if ((host < 0) || (host > MAX_SCSI_HOSTS))
panic ("Host number in internal_cmnd() is out of range.\n");
/*
We will wait MIN_RESET_DELAY clock ticks after the last reset so
we can avoid the drive not being ready.
*/
temp = last_reset[host];
while (jiffies < temp);
host_timeout[host] = last_cmnd[host].timeout_per_command;
update_timeout();
/*
We will use a queued command if possible, otherwise we will emulate the
queing and calling of completion function ourselves.
*/
#ifdef DEBUG
printk("internal_cmnd (host = %d, target = %d, command = %08x, buffer = %08x, \n"
"bufflen = %d, done = %08x)\n", host, target, cmnd, buffer, bufflen, done);
#endif
if (scsi_hosts[host].can_queue)
{
#ifdef DEBUG
printk("queuecommand : routine at %08x\n",
scsi_hosts[host].queuecommand);
#endif
scsi_hosts[host].queuecommand (target, cmnd, buffer, bufflen,
done);
}
else
{
#ifdef DEBUG
printk("command() : routine at %08x\n", scsi_hosts[host].command);
#endif
temp=scsi_hosts[host].command (target, cmnd, buffer, bufflen);
#ifdef DEBUG_DELAY
clock = jiffies + 400;
while (jiffies < clock);
printk("done(host = %d, result = %04x) : routine at %08x\n", host, temp, done);
#endif
done(host, temp);
}
#ifdef DEBUG
printk("leaving internal_cmnd()\n");
#endif
}
static void scsi_request_sense (int host, unsigned char target,
unsigned char lun)
{
cli();
host_timeout[host] = SENSE_TIMEOUT;
update_timeout();
last_cmnd[host].flags |= WAS_SENSE;
sti();
last_cmnd[host].sense_cmnd[1] = lun << 5;
internal_cmnd (host, target, (void *) last_cmnd[host].sense_cmnd,
(void *) last_cmnd[host].sense_buffer, SENSE_LENGTH,
scsi_done);
}
/*
scsi_do_cmd sends all the commands out to the low-level driver. It
handles the specifics required for each low level driver - ie queued
or non queud. It also prevents conflicts when different high level
drivers go for the same host at the same time.
*/
void scsi_do_cmd (int host, unsigned char target, const void *cmnd ,
void *buffer, unsigned bufflen, void (*done)(int,int),
int timeout, unsigned char *sense_buffer, int retries
)
{
int ok = 0;
#ifdef DEBUG
int i;
printk ("scsi_do_cmd (host = %d, target = %d, buffer =%08x, "
"bufflen = %d, done = %08x, timeout = %d, retries = %d)\n"
"command : " , host, target, buffer, bufflen, done, timeout, retries);
for (i = 0; i < 10; ++i)
printk ("%02x ", ((unsigned char *) cmnd)[i]);
printk("\n");
#endif
if ((host >= MAX_SCSI_HOSTS) || !scsi_hosts[host].present)
{
printk ("Invalid or not present host number. %d\n", host);
panic("");
}
/*
We must prevent reentrancy to the lowlevel host driver. This prevents
it - we enter a loop until the host we want to talk to is not busy.
Race conditions are prevented, as interrupts are disabled inbetween the
time we check for the host being not busy, and the time we mark it busy
ourselves.
*/
do {
cli();
if (host_busy[host])
{
sti();
#ifdef DEBUG
printk("Host %d is busy.\n" );
#endif
while (host_busy[host]);
#ifdef DEBUG
printk("Host %d is no longer busy.");
#endif
}
else
{
host_busy[host] = 1;
ok = 1;
sti();
}
} while (!ok);
/*
Our own function scsi_done (which marks the host as not busy, disables
the timeout counter, etc) will be called by us or by the
scsi_hosts[host].queuecommand() function needs to also call
the completion function for the high level driver.
*/
memcpy ((void *) last_cmnd[host].cmnd , (void *) cmnd, 10);
last_cmnd[host].host = host;
last_cmnd[host].target = target;
last_cmnd[host].lun = (last_cmnd[host].cmnd[1] >> 5);
last_cmnd[host].bufflen = bufflen;
last_cmnd[host].buffer = buffer;
last_cmnd[host].sense_buffer = sense_buffer;
last_cmnd[host].flags=0;
last_cmnd[host].retries=0;
last_cmnd[host].allowed=retries;
last_cmnd[host].done = done;
last_cmnd[host].timeout_per_command = timeout;
/* Start the timer ticking. */
internal_timeout[host] = 0;
internal_cmnd (host, target, cmnd , buffer, bufflen, scsi_done);
#ifdef DEBUG
printk ("Leaving scsi_do_cmd()\n");
#endif
}
/*
The scsi_done() function disables the timeout timer for the scsi host,
marks the host as not busy, and calls the user specified completion
function for that host's current command.
*/
static void reset (int host)
{
#ifdef DEBUG
printk("reset(%d)\n", host);
#endif
last_cmnd[host].flags |= (WAS_RESET | IS_RESETTING);
scsi_reset(host);
#ifdef DEBUG
printk("performing request sense\n");
#endif
scsi_request_sense (host, last_cmnd[host].target, last_cmnd[host].lun);
}
static int check_sense (int host)
{
if (((sense_buffer[0] & 0x70) >> 4) == 7)
switch (sense_buffer[2] & 0xf)
{
case NO_SENSE:
case RECOVERED_ERROR:
return 0;
case ABORTED_COMMAND:
case NOT_READY:
case UNIT_ATTENTION:
return SUGGEST_RETRY;
/* these three are not supported */
case COPY_ABORTED:
case VOLUME_OVERFLOW:
case MISCOMPARE:
case MEDIUM_ERROR:
return SUGGEST_REMAP;
case BLANK_CHECK:
case DATA_PROTECT:
case HARDWARE_ERROR:
case ILLEGAL_REQUEST:
default:
return SUGGEST_ABORT;
}
else
return SUGGEST_RETRY;
}
static void scsi_done (int host, int result)
{
int status=0;
int exit=0;
int checked;
int oldto;
oldto = host_timeout[host];
host_timeout[host] = 0;
update_timeout();
#define FINISHED 0
#define MAYREDO 1
#define REDO 3
#ifdef DEBUG
printk("In scsi_done(host = %d, result = %06x)\n", host, result);
#endif
if (host > MAX_SCSI_HOSTS || host < 0)
{
host_timeout[host] = 0;
update_timeout();
panic("scsi_done() called with invalid host number.\n");
}
switch (host_byte(result))
{
case DID_OK:
if (last_cmnd[host].flags & IS_RESETTING)
{
last_cmnd[host].flags &= ~IS_RESETTING;
status = REDO;
break;
}
if (status_byte(result) && (last_cmnd[host].flags &
WAS_SENSE))
{
last_cmnd[host].flags &= ~WAS_SENSE;
cli();
internal_timeout[host] &= ~SENSE_TIMEOUT;
sti();
if (!(last_cmnd[host].flags & WAS_RESET))
reset(host);
else
{
exit = (DRIVER_HARD | SUGGEST_ABORT);
status = FINISHED;
}
}
else switch(msg_byte(result))
{
case COMMAND_COMPLETE:
switch (status_byte(result))
{
case GOOD:
if (last_cmnd[host].flags & WAS_SENSE)
{
#ifdef DEBUG
printk ("In scsi_done, GOOD status, COMMAND COMPLETE, parsing sense information.\n");
#endif
last_cmnd[host].flags &= ~WAS_SENSE;
cli();
internal_timeout[host] &= ~SENSE_TIMEOUT;
sti();
switch (checked = check_sense(host))
{
case 0:
#ifdef DEBUG
printk("NO SENSE. status = REDO\n");
#endif
host_timeout[host] = oldto;
update_timeout();
status = REDO;
break;
case SUGGEST_REMAP:
case SUGGEST_RETRY:
#ifdef DEBUG
printk("SENSE SUGGEST REMAP or SUGGEST RETRY - status = MAYREDO\n");
#endif
status = MAYREDO;
exit = SUGGEST_RETRY;
break;
case SUGGEST_ABORT:
#ifdef DEBUG
printk("SENSE SUGGEST ABORT - status = FINISHED");
#endif
status = FINISHED;
exit = DRIVER_SENSE;
break;
default:
printk ("Internal error %s %s \n", __FILE__,
__LINE__);
}
}
else
{
#ifdef DEBUG
printk("COMMAND COMPLETE message returned, status = FINISHED. \n");
#endif
exit = DRIVER_OK;
status = FINISHED;
}
break;
case CHECK_CONDITION:
#ifdef DEBUG
printk("CHECK CONDITION message returned, performing request sense.\n");
#endif
scsi_request_sense (host, last_cmnd[host].target, last_cmnd[host].lun);
break;
case CONDITION_GOOD:
case INTERMEDIATE_GOOD:
case INTERMEDIATE_C_GOOD:
#ifdef DEBUG
printk("CONDITION GOOD, INTERMEDIATE GOOD, or INTERMEDIATE CONDITION GOOD recieved and ignored. \n");
#endif
break;
case BUSY:
#ifdef DEBUG
printk("BUSY message returned, performing REDO");
#endif
host_timeout[host] = oldto;
update_timeout();
status = REDO;
break;
case RESERVATION_CONFLICT:
reset(host);
exit = DRIVER_SOFT | SUGGEST_ABORT;
status = MAYREDO;
break;
default:
printk ("Internal error %s %s \n"
"status byte = %d \n", __FILE__,
__LINE__, status_byte(result));
}
break;
default:
panic ("unsupported message byte recieved.");
}
break;
case DID_TIME_OUT:
#ifdef DEBUG
printk("Host returned DID_TIME_OUT - ");
#endif
if (last_cmnd[host].flags & WAS_TIMEDOUT)
{
#ifdef DEBUG
printk("Aborting\n");
#endif
exit = (DRIVER_TIMEOUT | SUGGEST_ABORT);
}
else
{
#ifdef DEBUG
printk ("Retrying.\n");
#endif
last_cmnd[host].flags |= WAS_TIMEDOUT;
status = REDO;
}
break;
case DID_BUS_BUSY:
case DID_PARITY:
status = REDO;
break;
case DID_NO_CONNECT:
#ifdef DEBUG
printk("Couldn't connect.\n");
#endif
exit = (DRIVER_HARD | SUGGEST_ABORT);
break;
case DID_ERROR:
status = MAYREDO;
exit = (DRIVER_HARD | SUGGEST_ABORT);
break;
case DID_BAD_TARGET:
case DID_ABORT:
exit = (DRIVER_INVALID | SUGGEST_ABORT);
break;
default :
exit = (DRIVER_ERROR | SUGGEST_DIE);
}
switch (status)
{
case FINISHED:
break;
case MAYREDO:
#ifdef DEBUG
printk("In MAYREDO, allowing %d retries, have %d\n\r",
last_cmnd[host].allowed, last_cmnd[host].retries);
#endif
if ((++last_cmnd[host].retries) < last_cmnd[host].allowed)
{
if ((last_cmnd[host].retries >= (last_cmnd[host].allowed >> 1))
&& !(last_cmnd[host].flags & WAS_RESET))
reset(host);
break;
}
else
{
status = FINISHED;
break;
}
/* fall through to REDO */
case REDO:
if (last_cmnd[host].flags & WAS_SENSE)
scsi_request_sense (host, last_cmnd[host].target,
last_cmnd[host].lun);
else
internal_cmnd (host, last_cmnd[host].target,
last_cmnd[host].cmnd,
last_cmnd[host].buffer,
last_cmnd[host].bufflen, scsi_done);
break;
default:
INTERNAL_ERROR;
}
if (status == FINISHED)
{
#ifdef DEBUG
printk("Calling done function - at address %08x\n", last_cmnd[host].done);
#endif
last_cmnd[host].done (host, (result | ((exit & 0xff) << 24)));
host_busy[host] = 0;
}
#undef FINISHED
#undef REDO
#undef MAYREDO
}
/*
The scsi_abort function interfaces with the abort() function of the host
we are aborting, and causes the current command to not complete. The
caller should deal with any error messages or status returned on the
next call.
This will not be called rentrantly for a given host.
*/
/*
Since we're nice guys and specified that abort() and reset()
can be non-reentrant. The internal_timeout flags are used for
this.
*/
int scsi_abort (int host, int why)
{
int temp, oldto;
while(1)
{
cli();
if (internal_timeout[host] & IN_ABORT)
{
sti();
while (internal_timeout[host] & IN_ABORT);
}
else
{
internal_timeout[host] |= IN_ABORT;
host_timeout[host] = ABORT_TIMEOUT;
update_timeout();
oldto = host_timeout[host];
sti();
if (!host_busy[host] || !scsi_hosts[host].abort(why))
temp = 0;
else
temp = 1;
cli();
internal_timeout[host] &= ~IN_ABORT;
host_timeout[host]=oldto;
update_timeout();
sti();
return temp;
}
}
}
int scsi_reset (int host)
{
int temp, oldto;
while (1) {
cli();
if (internal_timeout[host] & IN_RESET)
{
sti();
while (internal_timeout[host] & IN_RESET);
}
else
{
oldto = host_timeout[host];
host_timeout[host] = RESET_TIMEOUT;
update_timeout();
internal_timeout[host] |= IN_RESET;
if (host_busy[host])
{
sti();
if (!(last_cmnd[host].flags & IS_RESETTING) && !(internal_timeout[host] & IN_ABORT))
scsi_abort(host, DID_RESET);
temp = scsi_hosts[host].reset();
}
else
{
host_busy[host]=1;
sti();
temp = scsi_hosts[host].reset();
last_reset[host] = jiffies;
host_busy[host]=0;
}
cli();
host_timeout[host] = oldto;
update_timeout();
internal_timeout[host] &= ~IN_RESET;
sti();
return temp;
}
}
}
static void scsi_main_timeout(void)
{
/*
We must not enter update_timeout with a timeout condition still pending.
*/
int i, timed_out;
do {
cli();
/*
Find all timers such that they have 0 or negative (shouldn't happen)
time remaining on them.
*/
for (i = timed_out = 0; i < MAX_SCSI_HOSTS; ++i)
if (host_timeout[i] != 0 && host_timeout[i] <= time_elapsed)
{
sti();
host_timeout[i] = 0;
scsi_times_out(i);
++timed_out;
}
update_timeout();
} while (timed_out);
sti();
}
/*
These are used to keep track of things.
*/
static int time_start, time_elapsed;
/*
The strategy is to cause the timer code to call scsi_times_out()
when the soonest timeout is pending.
*/
static void update_timeout(void)
{
int i, least, used;
cli();
/*
Figure out how much time has passed since the last time the timeouts
were updated
*/
used = (time_start) ? (jiffies - time_start) : 0;
/*
Find out what is due to timeout soonest, and adjust all timeouts for
the amount of time that has passed since the last time we called
update_timeout.
*/
for (i = 0, least = 0xffffffff; i < MAX_SCSI_HOSTS; ++i)
if (host_timeout[i] > 0 && (host_timeout[i] -= used) < least)
least = host_timeout[i];
/*
If something is due to timeout again, then we will set the next timeout
interrupt to occur. Otherwise, timeouts are disabled.
*/
if (least != 0xffffffff)
{
time_start = jiffies;
timer_table[SCSI_TIMER].expires = (time_elapsed = least) + jiffies;
timer_active |= 1 << SCSI_TIMER;
}
else
{
timer_table[SCSI_TIMER].expires = time_start = time_elapsed = 0;
timer_active &= ~(1 << SCSI_TIMER);
}
sti();
}
/*
scsi_dev_init() is our initialization routine, which inturn calls host
initialization, bus scanning, and sd/st initialization routines. It
should be called from main().
*/
static unsigned char generic_sense[6] = {REQUEST_SENSE, 0,0,0, 255, 0};
void scsi_dev_init (void)
{
int i;
#ifdef FOO_ON_YOU
return;
#endif
timer_table[SCSI_TIMER].fn = scsi_main_timeout;
timer_table[SCSI_TIMER].expires = 0;
scsi_init(); /* initialize all hosts */
/*
Set up sense command in each host structure.
*/
for (i = 0; i < MAX_SCSI_HOSTS; ++i)
{
memcpy ((void *) last_cmnd[i].sense_cmnd, (void *) generic_sense,
6);
last_reset[i] = 0;
}
scan_scsis(); /* scan for scsi devices */
#ifdef CONFIG_BLK_DEV_SD
sd_init(); /* init scsi disks */
#endif
#ifdef CONFIG_BLK_DEV_ST
st_init(); /* init scsi tapes */
#endif
}
#endif