Sneed-Group/gems-kernel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
gems-kernel/source/THIRDPARTY/linux-old/drivers/scsi/st.c

1476 lines
39 KiB
C
Raw Normal View History

GEMS Kernel is going to be better than ever... WOO HOO!
2024-06-03 11:16:15 -05:00
/*
SCSI Tape Driver for Linux
Version 0.02 for Linux 0.98.4 and Eric Youngdale's new scsi driver
History:
Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
Contribution and ideas from several people including Eric Youngdale and
Wolfgang Denk.
Features:
- support for different block sizes and internal buffering
- support for fixed and variable block size (within buffer limit;
blocksize set to zero)
- *nix-style ioctl with codes from mtio.h from the QIC-02 driver by
Hennus Bergman (command MTSETBLK added)
- character device
- rewind and non-rewind devices
- capability to handle several tape drives simultaneously
- one buffer if one drive, two buffers if more than one drive (limits the
number of simultaneously open drives to two)
- write behind
- seek and tell (Tandberg compatible and SCSI-2)
Devices:
Autorewind devices have minor numbers equal to the tape numbers (0 > ).
Nonrewind device has the minor number equal to tape number + 128.
Problems:
The end of media detection works correctly in writing only if the drive
writes the buffer contents after the early-warning mark. If you want to
be sure that EOM is reported correctly, you should uncomment the line
defining ST_NO_DELAYED_WRITES. Note that when delayed writes are disabled
each write byte count must be an integral number of blocks.
Copyright 1992, 1993 Kai Makisara
email makisara@vtinsx.ins.vtt.fi or Kai.Makisara@vtt.fi
Last modified: Thu Nov 25 21:49:02 1993 by root@kai.home
*/
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/mtio.h>
#include <linux/ioctl.h>
#include <linux/fcntl.h>
#include <asm/segment.h>
#include <asm/system.h>
#define MAJOR_NR SCSI_TAPE_MAJOR
#include "../block/blk.h"
#include "scsi.h"
#include "scsi_ioctl.h"
#include "st.h"
#include "constants.h"
/* Uncomment the following if you want the rewind, etc. commands return
before command completion. */
/* #define ST_NOWAIT */
/* Uncomment the following if you want the tape to be positioned correctly
within file after close (the tape is positioned correctly with respect
to the filemarks even wihout ST_IN_FILE_POS defined */
/* #define ST_IN_FILE_POS */
/* Uncomment the following if you want recovered write errors to be
fatal. */
/* #define ST_RECOVERED_WRITE_FATAL */
/* Uncomment the following if you want all data from a write command to
be written to tape before the command returns. Disables write-behind. */
/* #define ST_NO_DELAYED_WRITES */
/* Number of ST_BLOCK_SIZE blocks in the buffers */
#define ST_BUFFER_BLOCKS 64
/* Write-behind can be disabled by setting ST_WRITE_THRESHOLD_BLOCKS equal
to or larger than ST_BUFFER_BLOCKS */
#define ST_WRITE_THRESHOLD_BLOCKS 60
#define ST_BLOCK_SIZE 512
#define ST_BUFFER_SIZE (ST_BUFFER_BLOCKS * ST_BLOCK_SIZE)
#define ST_WRITE_THRESHOLD (ST_WRITE_THRESHOLD_BLOCKS * ST_BLOCK_SIZE)
#ifdef ST_NO_DELAYED_WRITES
#undef ST_WRITE_THRESHOLD_BLOCKS
#define ST_WRITE_THRESHOLD_BLOCKS ST_BUFFER_BLOCKS
#endif
/* The buffer size should fit into the 24 bits reserved for length in the
6-byte SCSI read and write commands. */
#if ST_BUFFER_SIZE >= (2 << 24 - 1)
#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
#endif
/* #define DEBUG */
#define MAX_RETRIES 0
#define MAX_READY_RETRIES 5
#define NO_TAPE NOT_READY
#define ST_TIMEOUT 9000
#define ST_LONG_TIMEOUT 200000
static int st_nbr_buffers;
static ST_buffer *st_buffers[2];
static Scsi_Tape * scsi_tapes;
int NR_ST=0;
int MAX_ST=0;
static int st_int_ioctl(struct inode * inode,struct file * file,
unsigned int cmd_in, unsigned long arg);
/* Convert the result to success code */
static int
st_chk_result(Scsi_Cmnd * SCpnt)
{
int dev = SCpnt->request.dev;
int result = SCpnt->result;
unsigned char * sense = SCpnt->sense_buffer;
char *stp;
if (!result && SCpnt->sense_buffer[0] == 0)
return 0;
#ifdef DEBUG
printk("st%d: Error: %x\n", dev, result);
print_sense("st", SCpnt);
#endif
/* if ((sense[0] & 0x70) == 0x70 &&
((sense[2] & 0x80) ))
return 0; */
if ((sense[0] & 0x70) == 0x70 &&
sense[2] == RECOVERED_ERROR
#ifdef ST_RECOVERED_WRITE_FATAL
&& SCpnt->cmnd[0] != WRITE_6
&& SCpnt->cmnd[0] != WRITE_FILEMARKS
#endif
) {
scsi_tapes[dev].recover_count++;
if (SCpnt->cmnd[0] == READ_6)
stp = "read";
else if (SCpnt->cmnd[0] == WRITE_6)
stp = "write";
else
stp = "ioctl";
printk("st%d: Recovered %s error (%d).\n", dev, stp,
scsi_tapes[dev].recover_count);
return 0;
}
return (-EIO);
}
/* Wakeup from interrupt */
static void
st_sleep_done (Scsi_Cmnd * SCpnt)
{
int st_nbr, remainder;
Scsi_Tape * STp;
if ((st_nbr = SCpnt->request.dev) < NR_ST && st_nbr >= 0) {
STp = &(scsi_tapes[st_nbr]);
if ((STp->buffer)->writing &&
(SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
(SCpnt->sense_buffer[2] & 0x40)) {
/* EOM at write-behind, has all been written? */
if ((SCpnt->sense_buffer[0] & 0x80) != 0)
remainder = (SCpnt->sense_buffer[3] << 24) |
(SCpnt->sense_buffer[4] << 16) |
(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
else
remainder = 0;
if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW ||
remainder > 0)
(STp->buffer)->last_result = SCpnt->result; /* Error */
else
(STp->buffer)->last_result = INT_MAX; /* OK */
}
else
(STp->buffer)->last_result = SCpnt->result;
(STp->buffer)->last_result_fatal = st_chk_result(SCpnt);
if ((STp->buffer)->writing)
SCpnt->request.dev = -1;
else
SCpnt->request.dev = 0xffff;
if ((STp->buffer)->writing <= 0)
wake_up( &(STp->waiting) );
}
#ifdef DEBUG
else
printk("st?: Illegal interrupt device %x\n", st_nbr);
#endif
}
#if ST_WRITE_THRESHOLD_BLOCKS < ST_BUFFER_BLOCKS
/* Handle the write-behind checking */
static void
write_behind_check(int dev)
{
Scsi_Tape * STp;
ST_buffer * STbuffer;
STp = &(scsi_tapes[dev]);
STbuffer = STp->buffer;
cli();
if (STbuffer->last_result < 0) {
STbuffer->writing = (- STbuffer->writing);
sleep_on( &(STp->waiting) );
STbuffer->writing = (- STbuffer->writing);
}
sti();
if (STbuffer->writing < STbuffer->buffer_bytes)
memcpy(STbuffer->b_data,
STbuffer->b_data + STbuffer->writing,
STbuffer->buffer_bytes - STbuffer->writing);
STbuffer->buffer_bytes -= STbuffer->writing;
STbuffer->writing = 0;
return;
}
#endif
/* Flush the write buffer (never need to write if variable blocksize). */
static int
flush_write_buffer(int dev)
{
int offset, transfer, blks;
int result;
unsigned char cmd[10];
Scsi_Cmnd *SCpnt;
Scsi_Tape *STp = &(scsi_tapes[dev]);
#if ST_WRITE_THRESHOLD_BLOCKS < ST_BUFFER_BLOCKS
if ((STp->buffer)->writing) {
write_behind_check(dev);
if ((STp->buffer)->last_result_fatal) {
#ifdef DEBUG
printk("st%d: Async write error %x.\n", dev,
(STp->buffer)->last_result);
#endif
if ((STp->buffer)->last_result == INT_MAX)
return (-ENOSPC);
return (-EIO);
}
}
#endif
result = 0;
if (STp->dirty == 1) {
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
offset = (STp->buffer)->buffer_bytes;
transfer = ((offset + STp->block_size - 1) /
STp->block_size) * STp->block_size;
#ifdef DEBUG
printk("st%d: Flushing %d bytes.\n", dev, transfer);
#endif
memset((STp->buffer)->b_data + offset, 0, transfer - offset);
SCpnt->sense_buffer[0] = 0;
memset(cmd, 0, 10);
cmd[0] = WRITE_6;
cmd[1] = 1;
blks = transfer / STp->block_size;
cmd[2] = blks >> 16;
cmd[3] = blks >> 8;
cmd[4] = blks;
SCpnt->request.dev = dev;
scsi_do_cmd (SCpnt,
(void *) cmd, (STp->buffer)->b_data, transfer,
st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((STp->buffer)->last_result_fatal != 0) {
printk("st%d: Error on flush.\n", dev);
if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
(SCpnt->sense_buffer[2] & 0x40) &&
(SCpnt->sense_buffer[2] & 0x0f) != VOLUME_OVERFLOW) {
STp->dirty = 0;
(STp->buffer)->buffer_bytes = 0;
result = (-ENOSPC);
}
else
result = (-EIO);
}
else {
STp->dirty = 0;
(STp->buffer)->buffer_bytes = 0;
}
SCpnt->request.dev = -1; /* Mark as not busy */
}
return result;
}
/* Flush the tape buffer. The tape will be positioned correctly unless
seek_next is true. */
static int
flush_buffer(struct inode * inode, struct file * filp, int seek_next)
{
int dev;
int backspace, result;
Scsi_Tape * STp;
ST_buffer * STbuffer;
dev = MINOR(inode->i_rdev) & 127;
STp = &(scsi_tapes[dev]);
STbuffer = STp->buffer;
if (STp->rw == ST_WRITING) /* Writing */
return flush_write_buffer(dev);
if (STp->block_size == 0)
return 0;
backspace = ((STp->buffer)->buffer_bytes +
(STp->buffer)->read_pointer) / STp->block_size -
((STp->buffer)->read_pointer + STp->block_size - 1) /
STp->block_size;
(STp->buffer)->buffer_bytes = 0;
(STp->buffer)->read_pointer = 0;
result = 0;
if (!seek_next) {
if ((STp->eof == ST_FM) && !STp->eof_hit) {
result = st_int_ioctl(inode, filp, MTBSF, 1); /* Back over the EOF hit */
if (!result) {
STp->eof = ST_NOEOF;
STp->eof_hit = 0;
}
}
if (!result && backspace > 0)
result = st_int_ioctl(inode, filp, MTBSR, backspace);
}
return result;
}
/* Open the device */
static int
scsi_tape_open(struct inode * inode, struct file * filp)
{
int dev;
unsigned short flags;
int i;
unsigned char cmd[10];
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
dev = MINOR(inode->i_rdev) & 127;
if (dev >= NR_ST)
return (-ENODEV);
STp = &(scsi_tapes[dev]);
if (STp->in_use) {
printk("st%d: Device already in use.\n", dev);
return (-EBUSY);
}
/* Allocate buffer for this user */
for (i=0; i < st_nbr_buffers; i++)
if (!st_buffers[i]->in_use)
break;
if (i >= st_nbr_buffers) {
printk("st%d: No free buffers.\n", dev);
return (-EBUSY);
}
STp->buffer = st_buffers[i];
(STp->buffer)->in_use = 1;
(STp->buffer)->writing = 0;
STp->in_use = 1;
flags = filp->f_flags;
STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
STp->dirty = 0;
STp->rw = ST_IDLE;
STp->eof = ST_NOEOF;
STp->eof_hit = 0;
STp->recover_count = 0;
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
if (!SCpnt) {
printk("st%d: Tape request not allocated", dev);
return (-EBUSY);
}
SCpnt->sense_buffer[0]=0;
memset ((void *) &cmd[0], 0, 10);
cmd[0] = TEST_UNIT_READY;
SCpnt->request.dev = dev;
scsi_do_cmd(SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_LONG_TIMEOUT,
MAX_READY_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
(SCpnt->sense_buffer[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
SCpnt->sense_buffer[0]=0;
memset ((void *) &cmd[0], 0, 10);
cmd[0] = TEST_UNIT_READY;
SCpnt->request.dev = dev;
scsi_do_cmd(SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_LONG_TIMEOUT,
MAX_READY_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
}
if ((STp->buffer)->last_result_fatal != 0) {
if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
(SCpnt->sense_buffer[2] & 0x0f) == NO_TAPE)
printk("st%d: No tape.\n", dev);
else
printk("st%d: Error %x.\n", dev, SCpnt->result);
(STp->buffer)->in_use = 0;
STp->in_use = 0;
SCpnt->request.dev = -1; /* Mark as not busy */
return (-EIO);
}
SCpnt->sense_buffer[0]=0;
memset ((void *) &cmd[0], 0, 10);
cmd[0] = READ_BLOCK_LIMITS;
SCpnt->request.dev = dev;
scsi_do_cmd(SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if (!SCpnt->result && !SCpnt->sense_buffer[0]) {
STp->max_block = ((STp->buffer)->b_data[1] << 16) |
((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
STp->min_block = ((STp->buffer)->b_data[4] << 8) |
(STp->buffer)->b_data[5];
#ifdef DEBUG
printk("st%d: Block limits %d - %d bytes.\n", dev, STp->min_block,
STp->max_block);
#endif
}
else {
STp->min_block = STp->max_block = (-1);
#ifdef DEBUG
printk("st%d: Can't read block limits.\n", dev);
#endif
}
SCpnt->sense_buffer[0]=0;
memset ((void *) &cmd[0], 0, 10);
cmd[0] = MODE_SENSE;
cmd[4] = 12;
SCpnt->request.dev = dev;
scsi_do_cmd(SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((STp->buffer)->last_result_fatal != 0) {
#ifdef DEBUG
printk("st%d: No Mode Sense.\n", dev);
#endif
(STp->buffer)->b_data[2] =
(STp->buffer)->b_data[3] = 0;
}
SCpnt->request.dev = -1; /* Mark as not busy */
#ifdef DEBUG
printk("st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", dev,
(STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
(STp->buffer)->b_data[2], (STp->buffer)->b_data[3]);
#endif
if ((STp->buffer)->b_data[3] >= 8) {
STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
STp->density = (STp->buffer)->b_data[4];
STp->block_size = (STp->buffer)->b_data[9] * 65536 +
(STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
#ifdef DEBUG
printk(
"st%d: Density %x, tape length: %x, blocksize: %d, drv buffer: %d\n",
dev, STp->density, (STp->buffer)->b_data[5] * 65536 +
(STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
STp->block_size, STp->drv_buffer);
#endif
if (STp->block_size > ST_BUFFER_SIZE) {
printk("st%d: Blocksize %d too large for buffer.\n", dev,
STp->block_size);
(STp->buffer)->in_use = 0;
STp->in_use = 0;
return (-EIO);
}
}
else
STp->block_size = ST_BLOCK_SIZE;
if (STp->block_size > 0) {
(STp->buffer)->buffer_blocks = ST_BUFFER_SIZE / STp->block_size;
(STp->buffer)->buffer_size =
(STp->buffer)->buffer_blocks * STp->block_size;
}
else {
(STp->buffer)->buffer_blocks = 1;
(STp->buffer)->buffer_size = ST_BUFFER_SIZE;
}
(STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
#ifdef DEBUG
printk("st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev,
STp->block_size, (STp->buffer)->buffer_size,
(STp->buffer)->buffer_blocks);
#endif
if ((STp->buffer)->b_data[2] & 0x80) {
STp->write_prot = 1;
#ifdef DEBUG
printk( "st%d: Write protected\n", dev);
#endif
}
return 0;
}
/* Close the device*/
static void
scsi_tape_close(struct inode * inode, struct file * filp)
{
int dev;
int result;
int rewind;
static unsigned char cmd[10];
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
dev = MINOR(inode->i_rdev);
rewind = (dev & 0x80) == 0;
dev = dev & 127;
STp = &(scsi_tapes[dev]);
if ( STp->rw == ST_WRITING) {
result = flush_write_buffer(dev);
#ifdef DEBUG
printk("st%d: File length %d bytes.\n", dev, filp->f_pos);
#endif
if (result == 0 || result == (-ENOSPC)) {
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt->sense_buffer[0] = 0;
memset(cmd, 0, 10);
cmd[0] = WRITE_FILEMARKS;
cmd[4] = 1;
SCpnt->request.dev = dev;
scsi_do_cmd( SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((STp->buffer)->last_result_fatal != 0)
printk("st%d: Error on write filemark.\n", dev);
SCpnt->request.dev = -1; /* Mark as not busy */
}
#ifdef DEBUG
printk("st%d: Buffer flushed, EOF written\n", dev);
#endif
}
else if (!rewind) {
#ifndef ST_IN_FILE_POS
if ((STp->eof == ST_FM) && !STp->eof_hit)
st_int_ioctl(inode, filp, MTBSF, 1); /* Back over the EOF hit */
#else
flush_buffer(inode, filp, 0);
#endif
}
if (rewind)
st_int_ioctl(inode, filp, MTREW, 1);
(STp->buffer)->in_use = 0;
STp->in_use = 0;
return;
}
/* Write command */
static int
st_write(struct inode * inode, struct file * filp, char * buf, int count)
{
int dev;
int total, do_count, blks, retval, transfer;
int write_threshold;
static unsigned char cmd[10];
char *b_point;
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
dev = MINOR(inode->i_rdev) & 127;
STp = &(scsi_tapes[dev]);
#ifdef DEBUG
if (!STp->in_use) {
printk("st%d: Incorrect device.\n", dev);
return (-EIO);
}
#endif
if (STp->write_prot)
return (-EACCES);
if (STp->block_size == 0 && count > ST_BUFFER_SIZE)
return (-EOVERFLOW);
if (STp->rw == ST_READING) {
retval = flush_buffer(inode, filp, 0);
if (retval)
return retval;
STp->rw = ST_WRITING;
}
#if ST_WRITE_THRESHOLD_BLOCKS < ST_BUFFER_BLOCKS
if ((STp->buffer)->writing) {
write_behind_check(dev);
if ((STp->buffer)->last_result_fatal) {
#ifdef DEBUG
printk("st%d: Async write error %x.\n", dev,
(STp->buffer)->last_result);
#endif
if ((STp->buffer)->last_result == INT_MAX) {
retval = (-ENOSPC); /* All has been written */
STp->eof = ST_EOM_OK;
}
else
retval = (-EIO);
return retval;
}
}
#endif
if (STp->eof == ST_EOM_OK)
return (-ENOSPC);
else if (STp->eof == ST_EOM_ERROR)
return (-EIO);
#ifdef ST_NO_DELAYED_WRITES
if (STp->block_size != 0 && (count % STp->block_size) != 0)
return (-EIO); /* Write must be integral number of blocks */
write_threshold = 1;
#else
write_threshold = (STp->buffer)->buffer_size;
#endif
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
total = count;
memset(cmd, 0, 10);
cmd[0] = WRITE_6;
cmd[1] = (STp->block_size != 0);
STp->rw = ST_WRITING;
b_point = buf;
while(
#if ST_WRITE_THRESHOLD_BLOCKS < ST_BUFFER_BLOCKS
STp->block_size != 0 &&
((STp->buffer)->buffer_bytes + count) >
write_threshold)
#else
(STp->block_size == 0 && count > 0) ||
((STp->buffer)->buffer_bytes + count) >=
write_threshold)
#endif
{
if (STp->block_size == 0)
do_count = count;
else {
do_count = (STp->buffer)->buffer_size - (STp->buffer)->buffer_bytes;
if (do_count > count)
do_count = count;
}
memcpy_fromfs((STp->buffer)->b_data +
(STp->buffer)->buffer_bytes, b_point, do_count);
if (STp->block_size == 0)
blks = do_count;
else
blks = ((STp->buffer)->buffer_bytes + do_count) /
STp->block_size;
cmd[2] = blks >> 16;
cmd[3] = blks >> 8;
cmd[4] = blks;
SCpnt->sense_buffer[0] = 0;
SCpnt->request.dev = dev;
scsi_do_cmd (SCpnt,
(void *) cmd, (STp->buffer)->b_data,
(STp->buffer)->buffer_size,
st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((STp->buffer)->last_result_fatal != 0) {
#ifdef DEBUG
printk("st%d: Error on write:\n", dev);
#endif
if ((SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
(SCpnt->sense_buffer[2] & 0x40)) {
if (STp->block_size != 0 && (SCpnt->sense_buffer[0] & 0x80) != 0)
transfer = (SCpnt->sense_buffer[3] << 24) |
(SCpnt->sense_buffer[4] << 16) |
(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
else if (STp->block_size == 0 &&
(SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
transfer = do_count;
else
transfer = 0;
if (STp->block_size != 0)
transfer *= STp->block_size;
if (transfer <= do_count) {
filp->f_pos += do_count - transfer;
count -= do_count - transfer;
STp->eof = ST_EOM_OK;
retval = (-ENOSPC); /* EOM within current request */
#ifdef DEBUG
printk("st%d: EOM with %d bytes unwritten.\n",
dev, transfer);
#endif
}
else {
STp->eof = ST_EOM_ERROR;
retval = (-EIO); /* EOM for old data */
#ifdef DEBUG
printk("st%d: EOM with lost data.\n", dev);
#endif
}
}
else
retval = (-EIO);
SCpnt->request.dev = -1; /* Mark as not busy */
(STp->buffer)->buffer_bytes = 0;
STp->dirty = 0;
if (count < total)
return total - count;
else
return retval;
}
filp->f_pos += do_count;
b_point += do_count;
count -= do_count;
(STp->buffer)->buffer_bytes = 0;
STp->dirty = 0;
}
if (count != 0) {
STp->dirty = 1;
memcpy_fromfs((STp->buffer)->b_data +
(STp->buffer)->buffer_bytes,b_point,count);
filp->f_pos += count;
(STp->buffer)->buffer_bytes += count;
count = 0;
}
if ((STp->buffer)->last_result_fatal != 0) {
SCpnt->request.dev = -1;
return (STp->buffer)->last_result_fatal;
}
#if ST_WRITE_THRESHOLD_BLOCKS < ST_BUFFER_BLOCKS
if ((STp->buffer)->buffer_bytes >= ST_WRITE_THRESHOLD ||
STp->block_size == 0) {
/* Schedule an asynchronous write */
if (STp->block_size == 0)
(STp->buffer)->writing = (STp->buffer)->buffer_bytes;
else
(STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
STp->block_size) * STp->block_size;
STp->dirty = 0;
if (STp->block_size == 0)
blks = (STp->buffer)->writing;
else
blks = (STp->buffer)->writing / STp->block_size;
cmd[2] = blks >> 16;
cmd[3] = blks >> 8;
cmd[4] = blks;
SCpnt->result = (STp->buffer)->last_result = -1;
SCpnt->sense_buffer[0] = 0;
SCpnt->request.dev = dev;
scsi_do_cmd (SCpnt,
(void *) cmd, (STp->buffer)->b_data,
(STp->buffer)->writing,
st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
}
else
#endif
SCpnt->request.dev = -1; /* Mark as not busy */
return( total);
}
/* Read command */
static int
st_read(struct inode * inode, struct file * filp, char * buf, int count)
{
int dev;
int total;
int transfer, blks, bytes;
static unsigned char cmd[10];
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
dev = MINOR(inode->i_rdev) & 127;
STp = &(scsi_tapes[dev]);
#ifdef DEBUG
if (!STp->in_use) {
printk("st%d: Incorrect device.\n", dev);
return (-EIO);
}
#endif
if (STp->block_size == 0 && count > ST_BUFFER_SIZE)
return (-EOVERFLOW);
if (STp->rw == ST_WRITING) {
transfer = flush_buffer(inode, filp, 0);
if (transfer)
return transfer;
STp->rw = ST_READING;
}
#ifdef DEBUG
if (STp->eof != ST_NOEOF)
printk("st%d: EOF flag up. Bytes %d\n", dev,
(STp->buffer)->buffer_bytes);
#endif
if (((STp->buffer)->buffer_bytes == 0) &&
STp->eof == ST_EOM_OK) /* EOM or Blank Check */
return (-EIO);
STp->rw = ST_READING;
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
for (total = 0; total < count; ) {
if ((STp->buffer)->buffer_bytes == 0 &&
STp->eof == ST_NOEOF) {
memset(cmd, 0, 10);
cmd[0] = READ_6;
cmd[1] = (STp->block_size != 0);
if (STp->block_size == 0)
blks = bytes = count;
else {
blks = (STp->buffer)->buffer_blocks;
bytes = blks * STp->block_size;
}
cmd[2] = blks >> 16;
cmd[3] = blks >> 8;
cmd[4] = blks;
SCpnt->sense_buffer[0] = 0;
SCpnt->request.dev = dev;
scsi_do_cmd (SCpnt,
(void *) cmd, (STp->buffer)->b_data,
(STp->buffer)->buffer_size,
st_sleep_done, ST_TIMEOUT, MAX_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
(STp->buffer)->read_pointer = 0;
STp->eof_hit = 0;
if ((STp->buffer)->last_result_fatal) {
#ifdef DEBUG
printk("st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", dev,
SCpnt->sense_buffer[0], SCpnt->sense_buffer[1],
SCpnt->sense_buffer[2], SCpnt->sense_buffer[3],
SCpnt->sense_buffer[4], SCpnt->sense_buffer[5],
SCpnt->sense_buffer[6], SCpnt->sense_buffer[7]);
#endif
if ((SCpnt->sense_buffer[0] & 0x70) == 0x70) { /* extended sense */
if ((SCpnt->sense_buffer[2] & 0xe0) != 0) { /* EOF, EOM, or ILI */
if ((SCpnt->sense_buffer[0] & 0x80) != 0)
transfer = (SCpnt->sense_buffer[3] << 24) |
(SCpnt->sense_buffer[4] << 16) |
(SCpnt->sense_buffer[5] << 8) | SCpnt->sense_buffer[6];
else
transfer = 0;
if (STp->block_size == 0 &&
(SCpnt->sense_buffer[2] & 0x0f) == MEDIUM_ERROR)
transfer = bytes;
if (SCpnt->sense_buffer[2] & 0x20) {
if (STp->block_size == 0) {
if (transfer <= 0)
transfer = 0;
(STp->buffer)->buffer_bytes = count - transfer;
}
else {
printk("st%d: Incorrect block size.\n", dev);
SCpnt->request.dev = -1; /* Mark as not busy */
return (-EIO);
}
}
else if (SCpnt->sense_buffer[2] & 0x40) {
STp->eof = ST_EOM_OK;
if (STp->block_size == 0)
(STp->buffer)->buffer_bytes = count - transfer;
else
(STp->buffer)->buffer_bytes =
((STp->buffer)->buffer_blocks - transfer) *
STp->block_size;
#ifdef DEBUG
printk("st%d: EOM detected (%d bytes read).\n", dev,
(STp->buffer)->buffer_bytes);
#endif
}
else if (SCpnt->sense_buffer[2] & 0x80) {
STp->eof = ST_FM;
if (STp->block_size == 0)
(STp->buffer)->buffer_bytes = 0;
else
(STp->buffer)->buffer_bytes =
((STp->buffer)->buffer_blocks - transfer) *
STp->block_size;
#ifdef DEBUG
printk(
"st%d: EOF detected (%d bytes read, transferred %d bytes).\n",
dev, (STp->buffer)->buffer_bytes, total);
#endif
} /* end of EOF, EOM, ILI test */
}
else { /* nonzero sense key */
#ifdef DEBUG
printk("st%d: Tape error while reading.\n", dev);
#endif
SCpnt->request.dev = -1;
if (total)
return total;
else
return -EIO;
}
}
else {
transfer = (STp->buffer)->last_result_fatal;
SCpnt->request.dev = -1; /* Mark as not busy */
return transfer;
}
}
else /* Read successful */
(STp->buffer)->buffer_bytes = bytes;
} /* if ((STp->buffer)->buffer_bytes == 0 &&
STp->eof == ST_NOEOF) */
if ((STp->buffer)->buffer_bytes > 0) {
#ifdef DEBUG
if (STp->eof != ST_NOEOF)
printk("st%d: EOF up. Left %d, needed %d.\n", dev,
(STp->buffer)->buffer_bytes, count - total);
#endif
transfer = (STp->buffer)->buffer_bytes < count - total ?
(STp->buffer)->buffer_bytes : count - total;
memcpy_tofs(buf, (STp->buffer)->b_data +
(STp->buffer)->read_pointer,transfer);
filp->f_pos += transfer;
buf += transfer;
total += transfer;
(STp->buffer)->buffer_bytes -= transfer;
(STp->buffer)->read_pointer += transfer;
}
else if (STp->eof != ST_NOEOF) {
STp->eof_hit = 1;
SCpnt->request.dev = -1; /* Mark as not busy */
if (total == 0 && STp->eof == ST_FM)
STp->eof = 0;
if (total == 0 && STp->eof == ST_EOM_OK)
return (-EIO); /* ST_EOM_ERROR not used in read */
return total;
}
if (STp->block_size == 0)
count = total; /* Read only one variable length block */
} /* for (total = 0; total < count; ) */
SCpnt->request.dev = -1; /* Mark as not busy */
return total;
}
/* Internal ioctl function */
static int
st_int_ioctl(struct inode * inode,struct file * file,
unsigned int cmd_in, unsigned long arg)
{
int dev = MINOR(inode->i_rdev);
int timeout = ST_LONG_TIMEOUT;
long ltmp;
int ioctl_result;
unsigned char cmd[10];
Scsi_Cmnd * SCpnt;
Scsi_Tape * STp;
dev = dev & 127;
STp = &(scsi_tapes[dev]);
memset(cmd, 0, 10);
switch (cmd_in) {
case MTFSF:
case MTFSFM:
cmd[0] = SPACE;
cmd[1] = 0x01; /* Space FileMarks */
cmd[2] = (arg >> 16);
cmd[3] = (arg >> 8);
cmd[4] = arg;
#ifdef DEBUG
printk("st%d: Spacing tape forward over %d filemarks.\n", dev,
cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
#endif
break;
case MTBSF:
case MTBSFM:
cmd[0] = SPACE;
cmd[1] = 0x01; /* Space FileMarks */
ltmp = (-arg);
cmd[2] = (ltmp >> 16);
cmd[3] = (ltmp >> 8);
cmd[4] = ltmp;
#ifdef DEBUG
if (cmd[2] & 0x80)
ltmp = 0xff000000;
ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
printk("st%d: Spacing tape backward over %d filemarks.\n", dev, (-ltmp));
#endif
break;
case MTFSR:
cmd[0] = SPACE;
cmd[1] = 0x00; /* Space Blocks */
cmd[2] = (arg >> 16);
cmd[3] = (arg >> 8);
cmd[4] = arg;
#ifdef DEBUG
printk("st%d: Spacing tape forward %d blocks.\n", dev,
cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
#endif
break;
case MTBSR:
cmd[0] = SPACE;
cmd[1] = 0x00; /* Space Blocks */
ltmp = (-arg);
cmd[2] = (ltmp >> 16);
cmd[3] = (ltmp >> 8);
cmd[4] = ltmp;
#ifdef DEBUG
if (cmd[2] & 0x80)
ltmp = 0xff000000;
ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
printk("st%d: Spacing tape backward %d blocks.\n", dev, (-ltmp));
#endif
break;
case MTWEOF:
if (STp->write_prot)
return (-EACCES);
cmd[0] = WRITE_FILEMARKS;
cmd[2] = (arg >> 16);
cmd[3] = (arg >> 8);
cmd[4] = arg;
timeout = ST_TIMEOUT;
#ifdef DEBUG
printk("st%d: Writing %d filemarks.\n", dev,
cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
#endif
break;
case MTREW:
cmd[0] = REZERO_UNIT;
#ifdef ST_NOWAIT
cmd[1] = 1; /* Don't wait for completion */
timeout = ST_TIMEOUT;
#endif
#ifdef DEBUG
printk("st%d: Rewinding tape.\n", dev);
#endif
break;
case MTOFFL:
cmd[0] = START_STOP;
#ifdef ST_NOWAIT
cmd[1] = 1; /* Don't wait for completion */
timeout = ST_TIMEOUT;
#endif
#ifdef DEBUG
printk("st%d: Unloading tape.\n", dev);
#endif
break;
case MTNOP:
#ifdef DEBUG
printk("st%d: No op on tape.\n", dev);
#endif
return 0; /* Should do something ? */
break;
case MTRETEN:
cmd[0] = START_STOP;
#ifdef ST_NOWAIT
cmd[1] = 1; /* Don't wait for completion */
timeout = ST_TIMEOUT;
#endif
cmd[4] = 3;
#ifdef DEBUG
printk("st%d: Retensioning tape.\n", dev);
#endif
break;
case MTEOM:
cmd[0] = SPACE;
cmd[1] = 3;
#ifdef DEBUG
printk("st%d: Spacing to end of recorded medium.\n", dev);
#endif
break;
case MTERASE:
if (STp->write_prot)
return (-EACCES);
cmd[0] = ERASE;
cmd[1] = 1; /* To the end of tape */
#ifdef DEBUG
printk("st%d: Erasing tape.\n", dev);
#endif
break;
case MTSEEK:
if ((STp->device)->scsi_level < SCSI_2) {
cmd[0] = QFA_SEEK_BLOCK;
cmd[2] = (arg >> 16);
cmd[3] = (arg >> 8);
cmd[4] = arg;
cmd[5] = 0;
}
else {
cmd[0] = SEEK_10;
cmd[1] = 4;
cmd[3] = (arg >> 24);
cmd[4] = (arg >> 16);
cmd[5] = (arg >> 8);
cmd[6] = arg;
}
#ifdef ST_NOWAIT
cmd[1] |= 1; /* Don't wait for completion */
timeout = ST_TIMEOUT;
#endif
#ifdef DEBUG
printk("st%d: Seeking tape to block %d.\n", dev, arg);
#endif
break;
case MTSETBLK: /* Set block length */
case MTSETDENSITY: /* Set tape density */
case MTSETDRVBUFFER: /* Set drive buffering */
if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
return (-EIO); /* Not allowed if data in buffer */
if (cmd_in == MTSETBLK &&
arg != 0 &&
(arg < STp->min_block || arg > STp->max_block ||
arg > ST_BUFFER_SIZE)) {
printk("st%d: Illegal block size.\n", dev);
return (-EINVAL);
}
cmd[0] = MODE_SELECT;
cmd[4] = 12;
memset((STp->buffer)->b_data, 0, 12);
if (cmd_in == MTSETDRVBUFFER)
(STp->buffer)->b_data[2] = (arg & 7) << 4;
else
(STp->buffer)->b_data[2] =
STp->drv_buffer << 4;
(STp->buffer)->b_data[3] = 8; /* block descriptor length */
if (cmd_in == MTSETDENSITY)
(STp->buffer)->b_data[4] = arg;
else
(STp->buffer)->b_data[4] = STp->density;
if (cmd_in == MTSETBLK)
ltmp = arg;
else
ltmp = STp->block_size;
(STp->buffer)->b_data[9] = (ltmp >> 16);
(STp->buffer)->b_data[10] = (ltmp >> 8);
(STp->buffer)->b_data[11] = ltmp;
timeout = ST_TIMEOUT;
#ifdef DEBUG
if (cmd_in == MTSETBLK)
printk("st%d: Setting block size to %d bytes.\n", dev,
(STp->buffer)->b_data[9] * 65536 +
(STp->buffer)->b_data[10] * 256 +
(STp->buffer)->b_data[11]);
else if (cmd_in == MTSETDENSITY)
printk("st%d: Setting density code to %x.\n", dev,
(STp->buffer)->b_data[4]);
else
printk("st%d: Setting drive buffer code to %d.\n", dev,
((STp->buffer)->b_data[2] >> 4) & 7);
#endif
break;
default:
printk("st%d: Unknown st_ioctl command %x.\n", dev, cmd_in);
return (-ENOSYS);
}
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt->sense_buffer[0] = 0;
SCpnt->request.dev = dev;
scsi_do_cmd(SCpnt,
(void *) cmd, (void *) (STp->buffer)->b_data, ST_BLOCK_SIZE,
st_sleep_done, timeout, MAX_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
ioctl_result = (STp->buffer)->last_result_fatal;
SCpnt->request.dev = -1; /* Mark as not busy */
if (!ioctl_result) {
if (cmd_in == MTBSFM)
ioctl_result = st_int_ioctl(inode, file, MTFSF, 1);
else if (cmd_in == MTFSFM)
ioctl_result = st_int_ioctl(inode, file, MTBSF, 1);
else if (cmd_in == MTSETBLK) {
STp->block_size = arg;
if (arg != 0) {
(STp->buffer)->buffer_blocks =
ST_BUFFER_SIZE / STp->block_size;
(STp->buffer)->buffer_size =
(STp->buffer)->buffer_blocks * STp->block_size;
}
else {
(STp->buffer)->buffer_blocks = 1;
(STp->buffer)->buffer_size = ST_BUFFER_SIZE;
}
(STp->buffer)->buffer_bytes =
(STp->buffer)->read_pointer = 0;
}
else if (cmd_in == MTSETDRVBUFFER)
STp->drv_buffer = arg;
else if (cmd_in == MTSETDENSITY)
STp->density = arg;
if (cmd_in == MTEOM || cmd_in == MTWEOF) {
STp->eof = ST_EOM_OK;
STp->eof_hit = 0;
}
else if (cmd_in != MTSETBLK && cmd_in != MTNOP) {
STp->eof = ST_NOEOF;
STp->eof_hit = 0;
}
}
return ioctl_result ;
}
/* The ioctl command */
static int
st_ioctl(struct inode * inode,struct file * file,
unsigned int cmd_in, unsigned long arg)
{
int dev = MINOR(inode->i_rdev);
int i, cmd, result;
struct mtop mtc;
struct mtpos mt_pos;
unsigned char scmd[10];
Scsi_Cmnd *SCpnt;
Scsi_Tape *STp;
dev = dev & 127;
STp = &(scsi_tapes[dev]);
#ifdef DEBUG
if (!STp->in_use) {
printk("st%d: Incorrect device.\n", dev);
return (-EIO);
}
#endif
cmd = cmd_in & IOCCMD_MASK;
if (cmd == (MTIOCTOP & IOCCMD_MASK)) {
if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(mtc))
return (-EINVAL);
i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(mtc));
if (i)
return i;
memcpy_fromfs((char *) &mtc, (char *)arg, sizeof(struct mtop));
i = flush_buffer(inode, file, mtc.mt_op == MTSEEK ||
mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM);
if (i < 0)
return i;
return st_int_ioctl(inode, file, mtc.mt_op, mtc.mt_count);
}
else if (cmd == (MTIOCGET & IOCCMD_MASK)) {
if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtget))
return (-EINVAL);
i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtget));
if (i)
return i;
memcpy_tofs((char *)arg, (char *)(STp->buffer)->mt_status,
sizeof(struct mtget));
return 0;
}
else if (cmd == (MTIOCPOS & IOCCMD_MASK)) {
#ifdef DEBUG
printk("st%d: get tape position.\n", dev);
#endif
if (((cmd_in & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtpos))
return (-EINVAL);
i = flush_buffer(inode, file, 0);
if (i < 0)
return i;
i = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct mtpos));
if (i)
return i;
SCpnt = allocate_device(NULL, (STp->device)->index, 1);
SCpnt->sense_buffer[0]=0;
memset (scmd, 0, 10);
if ((STp->device)->scsi_level < SCSI_2) {
scmd[0] = QFA_REQUEST_BLOCK;
scmd[4] = 3;
}
else {
scmd[0] = READ_POSITION;
scmd[1] = 1;
}
SCpnt->request.dev = dev;
SCpnt->sense_buffer[0] = 0;
scsi_do_cmd(SCpnt,
(void *) scmd, (void *) (STp->buffer)->b_data,
ST_BLOCK_SIZE, st_sleep_done, ST_TIMEOUT, MAX_READY_RETRIES);
if (SCpnt->request.dev == dev) sleep_on( &(STp->waiting) );
if ((STp->buffer)->last_result_fatal != 0) {
mt_pos.mt_blkno = (-1);
#ifdef DEBUG
printk("st%d: Can't read tape position.\n", dev);
#endif
result = (-EIO);
}
else {
result = 0;
if ((STp->device)->scsi_level < SCSI_2)
mt_pos.mt_blkno = ((STp->buffer)->b_data[0] << 16)
+ ((STp->buffer)->b_data[1] << 8)
+ (STp->buffer)->b_data[2];
else
mt_pos.mt_blkno = ((STp->buffer)->b_data[4] << 24)
+ ((STp->buffer)->b_data[5] << 16)
+ ((STp->buffer)->b_data[6] << 8)
+ (STp->buffer)->b_data[7];
}
SCpnt->request.dev = -1; /* Mark as not busy */
memcpy_tofs((char *)arg, (char *) (&mt_pos), sizeof(struct mtpos));
return result;
}
else
return scsi_ioctl(STp->device, cmd_in, (void *) arg);
}
static struct file_operations st_fops = {
NULL, /* lseek - default */
st_read, /* read - general block-dev read */
st_write, /* write - general block-dev write */
NULL, /* readdir - bad */
NULL, /* select */
st_ioctl, /* ioctl */
NULL, /* mmap */
scsi_tape_open, /* open */
scsi_tape_close, /* release */
NULL /* fsync */
};
void st_attach(Scsi_Device * SDp){
scsi_tapes[NR_ST++].device = SDp;
if(NR_ST > MAX_ST) panic ("scsi_devices corrupt (st)");
};
unsigned long st_init1(unsigned long mem_start, unsigned long mem_end){
scsi_tapes = (Scsi_Tape *) mem_start;
mem_start += MAX_ST * sizeof(Scsi_Tape);
return mem_start;
};
/* Driver initialization */
unsigned long st_init(unsigned long mem_start, unsigned long mem_end)
{
int i;
if (register_chrdev(MAJOR_NR,"st",&st_fops)) {
printk("Unable to get major %d for SCSI tapes\n",MAJOR_NR);
return mem_start;
}
if (NR_ST == 0) return mem_start;
#ifdef DEBUG
printk("st: Init tape.\n");
#endif
for (i=0; i < NR_ST; ++i) {
scsi_tapes[i].capacity = 0xfffff;
scsi_tapes[i].dirty = 0;
scsi_tapes[i].rw = ST_IDLE;
scsi_tapes[i].eof = ST_NOEOF;
scsi_tapes[i].waiting = NULL;
scsi_tapes[i].in_use = 0;
scsi_tapes[i].drv_buffer = 1; /* Try buffering if no mode sense */
scsi_tapes[i].density = 0;
}
/* Allocate the buffers */
if (NR_ST == 1)
st_nbr_buffers = 1;
else
st_nbr_buffers = 2;
for (i=0; i < st_nbr_buffers; i++) {
st_buffers[i] = (ST_buffer *) mem_start;
#ifdef DEBUG
printk("st: Buffer address: %p\n", st_buffers[i]);
#endif
mem_start += sizeof(ST_buffer) - 1 + ST_BUFFER_BLOCKS * ST_BLOCK_SIZE;
st_buffers[i]->mt_status = (struct mtget *) mem_start;
mem_start += sizeof(struct mtget);
st_buffers[i]->in_use = 0;
st_buffers[i]->writing = 0;
/* "generic" status */
memset((void *) st_buffers[i]->mt_status, 0, sizeof(struct mtget));
st_buffers[i]->mt_status->mt_type = MT_ISSCSI1;
}
return mem_start;
}
Reference in a new issue Copy permalink