err.no Git - linux-2.6/blob - drivers/scsi/osst.c

   1 /*
   2   SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
   3   file Documentation/scsi/st.txt for more information.
   4
   5   History:
   6
   7   OnStream SCSI Tape support (osst) cloned from st.c by
   8   Willem Riede (osst@riede.org) Feb 2000
   9   Fixes ... Kurt Garloff <garloff@suse.de> Mar 2000
  10
  11   Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
  12   Contribution and ideas from several people including (in alphabetical
  13   order) Klaus Ehrenfried, Wolfgang Denk, Steve Hirsch, Andreas Koppenh"ofer,
  14   Michael Leodolter, Eyal Lebedinsky, J"org Weule, and Eric Youngdale.
  15
  16   Copyright 1992 - 2002 Kai Makisara / 2000 - 2004 Willem Riede
  17          email osst@riede.org
  18
  19   $Header: /cvsroot/osst/Driver/osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $
  20
  21   Microscopic alterations - Rik Ling, 2000/12/21
  22   Last st.c sync: Tue Oct 15 22:01:04 2002 by makisara
  23   Some small formal changes - aeb, 950809
  24 */
  25
  26 static const char * cvsid = "$Id: osst.c,v 1.73 2005/01/01 21:13:34 wriede Exp $";
  27 static const char * osst_version = "0.99.3";
  28
  29 /* The "failure to reconnect" firmware bug */
  30 #define OSST_FW_NEED_POLL_MIN 10601 /*(107A)*/
  31 #define OSST_FW_NEED_POLL_MAX 10704 /*(108D)*/
  32 #define OSST_FW_NEED_POLL(x,d) ((x) >= OSST_FW_NEED_POLL_MIN && (x) <= OSST_FW_NEED_POLL_MAX && d->host->this_id != 7)
  33
  34 #include <linux/module.h>
  35
  36 #include <linux/fs.h>
  37 #include <linux/kernel.h>
  38 #include <linux/sched.h>
  39 #include <linux/proc_fs.h>
  40 #include <linux/mm.h>
  41 #include <linux/init.h>
  42 #include <linux/string.h>
  43 #include <linux/errno.h>
  44 #include <linux/mtio.h>
  45 #include <linux/ioctl.h>
  46 #include <linux/fcntl.h>
  47 #include <linux/spinlock.h>
  48 #include <linux/vmalloc.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/moduleparam.h>
  51 #include <linux/devfs_fs_kernel.h>
  52 #include <linux/delay.h>
  53 #include <asm/uaccess.h>
  54 #include <asm/dma.h>
  55 #include <asm/system.h>
  56
  57 /* The driver prints some debugging information on the console if DEBUG
  58    is defined and non-zero. */
  59 #define DEBUG 0
  60
  61 /* The message level for the debug messages is currently set to KERN_NOTICE
  62    so that people can easily see the messages. Later when the debugging messages
  63    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
  64 #define OSST_DEB_MSG  KERN_NOTICE
  65
  66 #include <scsi/scsi.h>
  67 #include <scsi/scsi_dbg.h>
  68 #include <scsi/scsi_device.h>
  69 #include <scsi/scsi_driver.h>
  70 #include <scsi/scsi_eh.h>
  71 #include <scsi/scsi_host.h>
  72 #include <scsi/scsi_ioctl.h>
  73 #include <scsi/scsi_request.h>
  74
  75 #define ST_KILOBYTE 1024
  76
  77 #include "st.h"
  78 #include "osst.h"
  79 #include "osst_options.h"
  80 #include "osst_detect.h"
  81
  82 static int max_dev = 0;
  83 static int write_threshold_kbs = 0;
  84 static int max_sg_segs = 0;
  85
  86 #ifdef MODULE
  87 MODULE_AUTHOR("Willem Riede");
  88 MODULE_DESCRIPTION("OnStream {DI-|FW-|SC-|USB}{30|50} Tape Driver");
  89 MODULE_LICENSE("GPL");
  90
  91 module_param(max_dev, int, 0444);
  92 MODULE_PARM_DESC(max_dev, "Maximum number of OnStream Tape Drives to attach (4)");
  93
  94 module_param(write_threshold_kbs, int, 0644);
  95 MODULE_PARM_DESC(write_threshold_kbs, "Asynchronous write threshold (KB; 32)");
  96
  97 module_param(max_sg_segs, int, 0644);
  98 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (9)");
  99 #else
 100 static struct osst_dev_parm {
 101        char   *name;
 102        int    *val;
 103 } parms[] __initdata = {
 104        { "max_dev",             &max_dev             },
 105        { "write_threshold_kbs", &write_threshold_kbs },
 106        { "max_sg_segs",         &max_sg_segs         }
 107 };
 108 #endif
 109
 110 static char *osst_formats[ST_NBR_MODES] ={"", "l", "m", "a"};
 111
 112 /* Some default definitions have been moved to osst_options.h */
 113 #define OSST_BUFFER_SIZE (OSST_BUFFER_BLOCKS * ST_KILOBYTE)
 114 #define OSST_WRITE_THRESHOLD (OSST_WRITE_THRESHOLD_BLOCKS * ST_KILOBYTE)
 115
 116 /* The buffer size should fit into the 24 bits for length in the
 117    6-byte SCSI read and write commands. */
 118 #if OSST_BUFFER_SIZE >= (2 << 24 - 1)
 119 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 120 #endif
 121
 122 #if DEBUG
 123 static int debugging = 1;
 124 /* uncomment define below to test error recovery */
 125 // #define OSST_INJECT_ERRORS 1
 126 #endif
 127
 128 /* Do not retry! The drive firmware already retries when appropriate,
 129    and when it tries to tell us something, we had better listen... */
 130 #define MAX_RETRIES 0
 131
 132 #define NO_TAPE  NOT_READY
 133
 134 #define OSST_WAIT_POSITION_COMPLETE   (HZ > 200 ? HZ / 200 : 1)
 135 #define OSST_WAIT_WRITE_COMPLETE      (HZ / 12)
 136 #define OSST_WAIT_LONG_WRITE_COMPLETE (HZ / 2)
 137
 138 #define OSST_TIMEOUT (200 * HZ)
 139 #define OSST_LONG_TIMEOUT (1800 * HZ)
 140
 141 #define TAPE_NR(x) (iminor(x) & ~(-1 << ST_MODE_SHIFT))
 142 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 143 #define TAPE_REWIND(x) ((iminor(x) & 0x80) == 0)
 144 #define TAPE_IS_RAW(x) (TAPE_MODE(x) & (ST_NBR_MODES >> 1))
 145
 146 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 147    24 bits) */
 148 #define SET_DENS_AND_BLK 0x10001
 149
 150 static int osst_buffer_size       = OSST_BUFFER_SIZE;
 151 static int osst_write_threshold   = OSST_WRITE_THRESHOLD;
 152 static int osst_max_sg_segs       = OSST_MAX_SG;
 153 static int osst_max_dev           = OSST_MAX_TAPES;
 154 static int osst_nr_dev;
 155
 156 static struct osst_tape **os_scsi_tapes = NULL;
 157 static DEFINE_RWLOCK(os_scsi_tapes_lock);
 158
 159 static int modes_defined = 0;
 160
 161 static struct osst_buffer *new_tape_buffer(int, int, int);
 162 static int enlarge_buffer(struct osst_buffer *, int);
 163 static void normalize_buffer(struct osst_buffer *);
 164 static int append_to_buffer(const char __user *, struct osst_buffer *, int);
 165 static int from_buffer(struct osst_buffer *, char __user *, int);
 166 static int osst_zero_buffer_tail(struct osst_buffer *);
 167 static int osst_copy_to_buffer(struct osst_buffer *, unsigned char *);
 168 static int osst_copy_from_buffer(struct osst_buffer *, unsigned char *);
 169
 170 static int osst_probe(struct device *);
 171 static int osst_remove(struct device *);
 172
 173 static struct scsi_driver osst_template = {
 174         .owner                  = THIS_MODULE,
 175         .gendrv = {
 176                 .name           =  "osst",
 177                 .probe          = osst_probe,
 178                 .remove         = osst_remove,
 179         }
 180 };
 181
 182 static int osst_int_ioctl(struct osst_tape *STp, struct scsi_request ** aSRpnt,
 183                             unsigned int cmd_in, unsigned long arg);
 184
 185 static int osst_set_frame_position(struct osst_tape *STp, struct scsi_request ** aSRpnt, int frame, int skip);
 186
 187 static int osst_get_frame_position(struct osst_tape *STp, struct scsi_request ** aSRpnt);
 188
 189 static int osst_flush_write_buffer(struct osst_tape *STp, struct scsi_request ** aSRpnt);
 190
 191 static int osst_write_error_recovery(struct osst_tape * STp, struct scsi_request ** aSRpnt, int pending);
 192
 193 static inline char *tape_name(struct osst_tape *tape)
 194 {
 195         return tape->drive->disk_name;
 196 }
 197 \f
 198 /* Routines that handle the interaction with mid-layer SCSI routines */
 199
 200 /* Convert the result to success code */
 201 static int osst_chk_result(struct osst_tape * STp, struct scsi_request * SRpnt)
 202 {
 203         char *name = tape_name(STp);
 204         int result = SRpnt->sr_result;
 205         unsigned char * sense = SRpnt->sr_sense_buffer, scode;
 206 #if DEBUG
 207         const char *stp;
 208 #endif
 209
 210         if (!result) {
 211                 sense[0] = 0;    /* We don't have sense data if this byte is zero */
 212                 return 0;
 213         }
 214         if ((driver_byte(result) & DRIVER_MASK) == DRIVER_SENSE)
 215                 scode = sense[2] & 0x0f;
 216         else {
 217                 sense[0] = 0;    /* We don't have sense data if this byte is zero */
 218                 scode = 0;
 219         }
 220 #if DEBUG
 221         if (debugging) {
 222                 printk(OSST_DEB_MSG "%s:D: Error: %x, cmd: %x %x %x %x %x %x Len: %d\n",
 223                    name, result,
 224                    SRpnt->sr_cmnd[0], SRpnt->sr_cmnd[1], SRpnt->sr_cmnd[2],
 225                    SRpnt->sr_cmnd[3], SRpnt->sr_cmnd[4], SRpnt->sr_cmnd[5],
 226                    SRpnt->sr_bufflen);
 227                 if (scode) printk(OSST_DEB_MSG "%s:D: Sense: %02x, ASC: %02x, ASCQ: %02x\n",
 228                                 name, scode, sense[12], sense[13]);
 229                 if (driver_byte(result) & DRIVER_SENSE)
 230                         scsi_print_req_sense("osst ", SRpnt);
 231         }
 232         else
 233 #endif
 234         if (!(driver_byte(result) & DRIVER_SENSE) ||
 235                 ((sense[0] & 0x70) == 0x70 &&
 236                  scode != NO_SENSE &&
 237                  scode != RECOVERED_ERROR &&
 238 /*               scode != UNIT_ATTENTION && */
 239                  scode != BLANK_CHECK &&
 240                  scode != VOLUME_OVERFLOW &&
 241                  SRpnt->sr_cmnd[0] != MODE_SENSE &&
 242                  SRpnt->sr_cmnd[0] != TEST_UNIT_READY)) { /* Abnormal conditions for tape */
 243                 if (driver_byte(result) & DRIVER_SENSE) {
 244                         printk(KERN_WARNING "%s:W: Command with sense data:\n", name);
 245                         scsi_print_req_sense("osst:", SRpnt);
 246                 }
 247                 else {
 248                         static  int     notyetprinted = 1;
 249
 250                         printk(KERN_WARNING
 251                              "%s:W: Warning %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
 252                              name, result, suggestion(result), driver_byte(result) & DRIVER_MASK,
 253                              host_byte(result));
 254                         if (notyetprinted) {
 255                                 notyetprinted = 0;
 256                                 printk(KERN_INFO
 257                                         "%s:I: This warning may be caused by your scsi controller,\n", name);
 258                                 printk(KERN_INFO
 259                                         "%s:I: it has been reported with some Buslogic cards.\n", name);
 260                         }
 261                 }
 262         }
 263         STp->pos_unknown |= STp->device->was_reset;
 264
 265         if ((sense[0] & 0x70) == 0x70 &&
 266              scode == RECOVERED_ERROR) {
 267                 STp->recover_count++;
 268                 STp->recover_erreg++;
 269 #if DEBUG
 270                 if (debugging) {
 271                         if (SRpnt->sr_cmnd[0] == READ_6)
 272                                 stp = "read";
 273                         else if (SRpnt->sr_cmnd[0] == WRITE_6)
 274                                 stp = "write";
 275                         else
 276                                 stp = "ioctl";
 277                         printk(OSST_DEB_MSG "%s:D: Recovered %s error (%d).\n", name, stp,
 278                                              STp->recover_count);
 279                 }
 280 #endif
 281                 if ((sense[2] & 0xe0) == 0)
 282                         return 0;
 283         }
 284         return (-EIO);
 285 }
 286
 287
 288 /* Wakeup from interrupt */
 289 static void osst_sleep_done (struct scsi_cmnd * SCpnt)
 290 {
 291         struct osst_tape * STp = container_of(SCpnt->request->rq_disk->private_data, struct osst_tape, driver);
 292
 293         if ((STp->buffer)->writing &&
 294             (SCpnt->sense_buffer[0] & 0x70) == 0x70 &&
 295             (SCpnt->sense_buffer[2] & 0x40)) {
 296                 /* EOM at write-behind, has all been written? */
 297                 if ((SCpnt->sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
 298                         STp->buffer->midlevel_result = SCpnt->result; /* Error */
 299                 else
 300                         STp->buffer->midlevel_result = INT_MAX;       /* OK */
 301         }
 302         else
 303                 STp->buffer->midlevel_result = SCpnt->result;
 304         SCpnt->request->rq_status = RQ_SCSI_DONE;
 305         STp->buffer->last_SRpnt = SCpnt->sc_request;
 306
 307 #if DEBUG
 308         STp->write_pending = 0;
 309 #endif
 310         complete(SCpnt->request->waiting);
 311 }
 312
 313
 314 /* Do the scsi command. Waits until command performed if do_wait is true.
 315    Otherwise osst_write_behind_check() is used to check that the command
 316    has finished. */
 317 static  struct scsi_request * osst_do_scsi(struct scsi_request *SRpnt, struct osst_tape *STp,
 318         unsigned char *cmd, int bytes, int direction, int timeout, int retries, int do_wait)
 319 {
 320         unsigned char *bp;
 321 #ifdef OSST_INJECT_ERRORS
 322         static   int   inject = 0;
 323         static   int   repeat = 0;
 324 #endif
 325         if (SRpnt == NULL) {
 326                 if ((SRpnt = scsi_allocate_request(STp->device, GFP_ATOMIC)) == NULL) {
 327                         printk(KERN_ERR "%s:E: Can't get SCSI request.\n", tape_name(STp));
 328                         if (signal_pending(current))
 329                                 (STp->buffer)->syscall_result = (-EINTR);
 330                         else
 331                                 (STp->buffer)->syscall_result = (-EBUSY);
 332                         return NULL;
 333                 }
 334         }
 335
 336         init_completion(&STp->wait);
 337         SRpnt->sr_use_sg = (bytes > (STp->buffer)->sg[0].length) ?
 338                                     (STp->buffer)->use_sg : 0;
 339         if (SRpnt->sr_use_sg) {
 340                 bp = (char *)&(STp->buffer->sg[0]);
 341                 if (STp->buffer->sg_segs < SRpnt->sr_use_sg)
 342                         SRpnt->sr_use_sg = STp->buffer->sg_segs;
 343         }
 344         else
 345                 bp = (STp->buffer)->b_data;
 346         SRpnt->sr_data_direction = direction;
 347         SRpnt->sr_cmd_len = 0;
 348         SRpnt->sr_request->waiting = &(STp->wait);
 349         SRpnt->sr_request->rq_status = RQ_SCSI_BUSY;
 350         SRpnt->sr_request->rq_disk = STp->drive;
 351
 352         scsi_do_req(SRpnt, (void *)cmd, bp, bytes, osst_sleep_done, timeout, retries);
 353
 354         if (do_wait) {
 355                 wait_for_completion(SRpnt->sr_request->waiting);
 356                 SRpnt->sr_request->waiting = NULL;
 357                 STp->buffer->syscall_result = osst_chk_result(STp, SRpnt);
 358 #ifdef OSST_INJECT_ERRORS
 359                 if (STp->buffer->syscall_result == 0 &&
 360                     cmd[0] == READ_6 &&
 361                     cmd[4] &&
 362                     ( (++ inject % 83) == 29  ||
 363                       (STp->first_frame_position == 240
 364                                  /* or STp->read_error_frame to fail again on the block calculated above */ &&
 365                                  ++repeat < 3))) {
 366                         printk(OSST_DEB_MSG "%s:D: Injecting read error\n", tape_name(STp));
 367                         STp->buffer->last_result_fatal = 1;
 368                 }
 369 #endif
 370         }
 371         return SRpnt;
 372 }
 373
 374
 375 /* Handle the write-behind checking (downs the semaphore) */
 376 static void osst_write_behind_check(struct osst_tape *STp)
 377 {
 378         struct osst_buffer * STbuffer;
 379
 380         STbuffer = STp->buffer;
 381
 382 #if DEBUG
 383         if (STp->write_pending)
 384                 STp->nbr_waits++;
 385         else
 386                 STp->nbr_finished++;
 387 #endif
 388         wait_for_completion(&(STp->wait));
 389         (STp->buffer)->last_SRpnt->sr_request->waiting = NULL;
 390
 391         STp->buffer->syscall_result = osst_chk_result(STp, STp->buffer->last_SRpnt);
 392
 393         if ((STp->buffer)->syscall_result)
 394                 (STp->buffer)->syscall_result =
 395                         osst_write_error_recovery(STp, &((STp->buffer)->last_SRpnt), 1);
 396         else
 397                 STp->first_frame_position++;
 398
 399         scsi_release_request((STp->buffer)->last_SRpnt);
 400
 401         if (STbuffer->writing < STbuffer->buffer_bytes)
 402                 printk(KERN_WARNING "osst :A: write_behind_check: something left in buffer!\n");
 403
 404         STbuffer->buffer_bytes -= STbuffer->writing;
 405         STbuffer->writing = 0;
 406
 407         return;
 408 }
 409
 410
 411 \f
 412 /* Onstream specific Routines */
 413 /*
 414  * Initialize the OnStream AUX
 415  */
 416 static void osst_init_aux(struct osst_tape * STp, int frame_type, int frame_seq_number,
 417                                          int logical_blk_num, int blk_sz, int blk_cnt)
 418 {
 419         os_aux_t       *aux = STp->buffer->aux;
 420         os_partition_t *par = &aux->partition;
 421         os_dat_t       *dat = &aux->dat;
 422
 423         if (STp->raw) return;
 424
 425         memset(aux, 0, sizeof(*aux));
 426         aux->format_id = htonl(0);
 427         memcpy(aux->application_sig, "LIN4", 4);
 428         aux->hdwr = htonl(0);
 429         aux->frame_type = frame_type;
 430
 431         switch (frame_type) {
 432           case  OS_FRAME_TYPE_HEADER:
 433                 aux->update_frame_cntr    = htonl(STp->update_frame_cntr);
 434                 par->partition_num        = OS_CONFIG_PARTITION;
 435                 par->par_desc_ver         = OS_PARTITION_VERSION;
 436                 par->wrt_pass_cntr        = htons(0xffff);
 437                 /* 0-4 = reserved, 5-9 = header, 2990-2994 = header, 2995-2999 = reserved */
 438                 par->first_frame_ppos     = htonl(0);
 439                 par->last_frame_ppos      = htonl(0xbb7);
 440                 aux->frame_seq_num        = htonl(0);
 441                 aux->logical_blk_num_high = htonl(0);
 442                 aux->logical_blk_num      = htonl(0);
 443                 aux->next_mark_ppos       = htonl(STp->first_mark_ppos);
 444                 break;
 445           case  OS_FRAME_TYPE_DATA:
 446           case  OS_FRAME_TYPE_MARKER:
 447                 dat->dat_sz = 8;
 448                 dat->reserved1 = 0;
 449                 dat->entry_cnt = 1;
 450                 dat->reserved3 = 0;
 451                 dat->dat_list[0].blk_sz   = htonl(blk_sz);
 452                 dat->dat_list[0].blk_cnt  = htons(blk_cnt);
 453                 dat->dat_list[0].flags    = frame_type==OS_FRAME_TYPE_MARKER?
 454                                                         OS_DAT_FLAGS_MARK:OS_DAT_FLAGS_DATA;
 455                 dat->dat_list[0].reserved = 0;
 456           case  OS_FRAME_TYPE_EOD:
 457                 aux->update_frame_cntr    = htonl(0);
 458                 par->partition_num        = OS_DATA_PARTITION;
 459                 par->par_desc_ver         = OS_PARTITION_VERSION;
 460                 par->wrt_pass_cntr        = htons(STp->wrt_pass_cntr);
 461                 par->first_frame_ppos     = htonl(STp->first_data_ppos);
 462                 par->last_frame_ppos      = htonl(STp->capacity);
 463                 aux->frame_seq_num        = htonl(frame_seq_number);
 464                 aux->logical_blk_num_high = htonl(0);
 465                 aux->logical_blk_num      = htonl(logical_blk_num);
 466                 break;
 467           default: ; /* probably FILL */
 468         }
 469         aux->filemark_cnt = ntohl(STp->filemark_cnt);
 470         aux->phys_fm = ntohl(0xffffffff);
 471         aux->last_mark_ppos = ntohl(STp->last_mark_ppos);
 472         aux->last_mark_lbn  = ntohl(STp->last_mark_lbn);
 473 }
 474
 475 /*
 476  * Verify that we have the correct tape frame
 477  */
 478 static int osst_verify_frame(struct osst_tape * STp, int frame_seq_number, int quiet)
 479 {
 480         char               * name = tape_name(STp);
 481         os_aux_t           * aux  = STp->buffer->aux;
 482         os_partition_t     * par  = &(aux->partition);
 483         struct st_partstat * STps = &(STp->ps[STp->partition]);
 484         int                  blk_cnt, blk_sz, i;
 485
 486         if (STp->raw) {
 487                 if (STp->buffer->syscall_result) {
 488                         for (i=0; i < STp->buffer->sg_segs; i++)
 489                                 memset(page_address(STp->buffer->sg[i].page),
 490                                        0, STp->buffer->sg[i].length);
 491                         strcpy(STp->buffer->b_data, "READ ERROR ON FRAME");
 492                 } else
 493                         STp->buffer->buffer_bytes = OS_FRAME_SIZE;
 494                 return 1;
 495         }
 496         if (STp->buffer->syscall_result) {
 497 #if DEBUG
 498                 printk(OSST_DEB_MSG "%s:D: Skipping frame, read error\n", name);
 499 #endif
 500                 return 0;
 501         }
 502         if (ntohl(aux->format_id) != 0) {
 503 #if DEBUG
 504                 printk(OSST_DEB_MSG "%s:D: Skipping frame, format_id %u\n", name, ntohl(aux->format_id));
 505 #endif
 506                 goto err_out;
 507         }
 508         if (memcmp(aux->application_sig, STp->application_sig, 4) != 0 &&
 509             (memcmp(aux->application_sig, "LIN3", 4) != 0 || STp->linux_media_version != 4)) {
 510 #if DEBUG
 511                 printk(OSST_DEB_MSG "%s:D: Skipping frame, incorrect application signature\n", name);
 512 #endif
 513                 goto err_out;
 514         }
 515         if (par->partition_num != OS_DATA_PARTITION) {
 516                 if (!STp->linux_media || STp->linux_media_version != 2) {
 517 #if DEBUG
 518                         printk(OSST_DEB_MSG "%s:D: Skipping frame, partition num %d\n",
 519                                             name, par->partition_num);
 520 #endif
 521                         goto err_out;
 522                 }
 523         }
 524         if (par->par_desc_ver != OS_PARTITION_VERSION) {
 525 #if DEBUG
 526                 printk(OSST_DEB_MSG "%s:D: Skipping frame, partition version %d\n", name, par->par_desc_ver);
 527 #endif
 528                 goto err_out;
 529         }
 530         if (ntohs(par->wrt_pass_cntr) != STp->wrt_pass_cntr) {
 531 #if DEBUG
 532                 printk(OSST_DEB_MSG "%s:D: Skipping frame, wrt_pass_cntr %d (expected %d)\n",
 533                                     name, ntohs(par->wrt_pass_cntr), STp->wrt_pass_cntr);
 534 #endif
 535                 goto err_out;
 536         }
 537         if (aux->frame_type != OS_FRAME_TYPE_DATA &&
 538             aux->frame_type != OS_FRAME_TYPE_EOD &&
 539             aux->frame_type != OS_FRAME_TYPE_MARKER) {
 540                 if (!quiet)
 541 #if DEBUG
 542                         printk(OSST_DEB_MSG "%s:D: Skipping frame, frame type %x\n", name, aux->frame_type);
 543 #endif
 544                 goto err_out;
 545         }
 546         if (aux->frame_type == OS_FRAME_TYPE_EOD &&
 547             STp->first_frame_position < STp->eod_frame_ppos) {
 548                 printk(KERN_INFO "%s:I: Skipping premature EOD frame %d\n", name,
 549                                  STp->first_frame_position);
 550                 goto err_out;
 551         }
 552         if (frame_seq_number != -1 && ntohl(aux->frame_seq_num) != frame_seq_number) {
 553                 if (!quiet)
 554 #if DEBUG
 555                         printk(OSST_DEB_MSG "%s:D: Skipping frame, sequence number %u (expected %d)\n",
 556                                             name, ntohl(aux->frame_seq_num), frame_seq_number);
 557 #endif
 558                 goto err_out;
 559         }
 560         if (aux->frame_type == OS_FRAME_TYPE_MARKER) {
 561                 STps->eof = ST_FM_HIT;
 562
 563                 i = ntohl(aux->filemark_cnt);
 564                 if (STp->header_cache != NULL && i < OS_FM_TAB_MAX && (i > STp->filemark_cnt ||
 565                     STp->first_frame_position - 1 != ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i]))) {
 566 #if DEBUG
 567                         printk(OSST_DEB_MSG "%s:D: %s filemark %d at frame pos %d\n", name,
 568                                   STp->header_cache->dat_fm_tab.fm_tab_ent[i] == 0?"Learned":"Corrected",
 569                                   i, STp->first_frame_position - 1);
 570 #endif
 571                         STp->header_cache->dat_fm_tab.fm_tab_ent[i] = htonl(STp->first_frame_position - 1);
 572                         if (i >= STp->filemark_cnt)
 573                                  STp->filemark_cnt = i+1;
 574                 }
 575         }
 576         if (aux->frame_type == OS_FRAME_TYPE_EOD) {
 577                 STps->eof = ST_EOD_1;
 578                 STp->frame_in_buffer = 1;
 579         }
 580         if (aux->frame_type == OS_FRAME_TYPE_DATA) {
 581                 blk_cnt = ntohs(aux->dat.dat_list[0].blk_cnt);
 582                 blk_sz  = ntohl(aux->dat.dat_list[0].blk_sz);
 583                 STp->buffer->buffer_bytes = blk_cnt * blk_sz;
 584                 STp->buffer->read_pointer = 0;
 585                 STp->frame_in_buffer = 1;
 586
 587                 /* See what block size was used to write file */
 588                 if (STp->block_size != blk_sz && blk_sz > 0) {
 589                         printk(KERN_INFO
 590                 "%s:I: File was written with block size %d%c, currently %d%c, adjusted to match.\n",
 591                                 name, blk_sz<1024?blk_sz:blk_sz/1024,blk_sz<1024?'b':'k',
 592                                 STp->block_size<1024?STp->block_size:STp->block_size/1024,
 593                                 STp->block_size<1024?'b':'k');
 594                         STp->block_size            = blk_sz;
 595                         STp->buffer->buffer_blocks = OS_DATA_SIZE / blk_sz;
 596                 }
 597                 STps->eof = ST_NOEOF;
 598         }
 599         STp->frame_seq_number = ntohl(aux->frame_seq_num);
 600         STp->logical_blk_num  = ntohl(aux->logical_blk_num);
 601         return 1;
 602
 603 err_out:
 604         if (STp->read_error_frame == 0)
 605                 STp->read_error_frame = STp->first_frame_position - 1;
 606         return 0;
 607 }
 608
 609 /*
 610  * Wait for the unit to become Ready
 611  */
 612 static int osst_wait_ready(struct osst_tape * STp, struct scsi_request ** aSRpnt,
 613                                  unsigned timeout, int initial_delay)
 614 {
 615         unsigned char           cmd[MAX_COMMAND_SIZE];
 616         struct scsi_request   * SRpnt;
 617         unsigned long           startwait = jiffies;
 618 #if DEBUG
 619         int                     dbg  = debugging;
 620         char                  * name = tape_name(STp);
 621
 622         printk(OSST_DEB_MSG "%s:D: Reached onstream wait ready\n", name);
 623 #endif
 624
 625         if (initial_delay > 0)
 626                 msleep(jiffies_to_msecs(initial_delay));
 627
 628         memset(cmd, 0, MAX_COMMAND_SIZE);
 629         cmd[0] = TEST_UNIT_READY;
 630
 631         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 632         *aSRpnt = SRpnt;
 633         if (!SRpnt) return (-EBUSY);
 634
 635         while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
 636                (( SRpnt->sr_sense_buffer[2]  == 2 && SRpnt->sr_sense_buffer[12] == 4    &&
 637                  (SRpnt->sr_sense_buffer[13] == 1 || SRpnt->sr_sense_buffer[13] == 8)    ) ||
 638                 ( SRpnt->sr_sense_buffer[2]  == 6 && SRpnt->sr_sense_buffer[12] == 0x28 &&
 639                   SRpnt->sr_sense_buffer[13] == 0                                        )  )) {
 640 #if DEBUG
 641             if (debugging) {
 642                 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait ready\n", name);
 643                 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
 644                 debugging = 0;
 645             }
 646 #endif
 647             msleep(100);
 648
 649             memset(cmd, 0, MAX_COMMAND_SIZE);
 650             cmd[0] = TEST_UNIT_READY;
 651
 652             SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 653         }
 654         *aSRpnt = SRpnt;
 655 #if DEBUG
 656         debugging = dbg;
 657 #endif
 658         if ( STp->buffer->syscall_result &&
 659              osst_write_error_recovery(STp, aSRpnt, 0) ) {
 660 #if DEBUG
 661             printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait ready\n", name);
 662             printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
 663                         STp->buffer->syscall_result, SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[2],
 664                         SRpnt->sr_sense_buffer[12], SRpnt->sr_sense_buffer[13]);
 665 #endif
 666             return (-EIO);
 667         }
 668 #if DEBUG
 669         printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait ready\n", name);
 670 #endif
 671         return 0;
 672 }
 673
 674 /*
 675  * Wait for a tape to be inserted in the unit
 676  */
 677 static int osst_wait_for_medium(struct osst_tape * STp, struct scsi_request ** aSRpnt, unsigned timeout)
 678 {
 679         unsigned char           cmd[MAX_COMMAND_SIZE];
 680         struct scsi_request   * SRpnt;
 681         unsigned long           startwait = jiffies;
 682 #if DEBUG
 683         int                     dbg = debugging;
 684         char                  * name = tape_name(STp);
 685
 686         printk(OSST_DEB_MSG "%s:D: Reached onstream wait for medium\n", name);
 687 #endif
 688
 689         memset(cmd, 0, MAX_COMMAND_SIZE);
 690         cmd[0] = TEST_UNIT_READY;
 691
 692         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 693         *aSRpnt = SRpnt;
 694         if (!SRpnt) return (-EBUSY);
 695
 696         while ( STp->buffer->syscall_result && time_before(jiffies, startwait + timeout*HZ) &&
 697                 SRpnt->sr_sense_buffer[2]  == 2 && SRpnt->sr_sense_buffer[12] == 0x3a       &&
 698                 SRpnt->sr_sense_buffer[13] == 0                                             ) {
 699 #if DEBUG
 700             if (debugging) {
 701                 printk(OSST_DEB_MSG "%s:D: Sleeping in onstream wait medium\n", name);
 702                 printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
 703                 debugging = 0;
 704             }
 705 #endif
 706             msleep(100);
 707
 708             memset(cmd, 0, MAX_COMMAND_SIZE);
 709             cmd[0] = TEST_UNIT_READY;
 710
 711             SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 712         }
 713         *aSRpnt = SRpnt;
 714 #if DEBUG
 715         debugging = dbg;
 716 #endif
 717         if ( STp->buffer->syscall_result     && SRpnt->sr_sense_buffer[2]  != 2 &&
 718              SRpnt->sr_sense_buffer[12] != 4 && SRpnt->sr_sense_buffer[13] == 1) {
 719 #if DEBUG
 720             printk(OSST_DEB_MSG "%s:D: Abnormal exit from onstream wait medium\n", name);
 721             printk(OSST_DEB_MSG "%s:D: Result = %d, Sense: 0=%02x, 2=%02x, 12=%02x, 13=%02x\n", name,
 722                         STp->buffer->syscall_result, SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[2],
 723                         SRpnt->sr_sense_buffer[12], SRpnt->sr_sense_buffer[13]);
 724 #endif
 725             return 0;
 726         }
 727 #if DEBUG
 728         printk(OSST_DEB_MSG "%s:D: Normal exit from onstream wait medium\n", name);
 729 #endif
 730         return 1;
 731 }
 732
 733 static int osst_position_tape_and_confirm(struct osst_tape * STp, struct scsi_request ** aSRpnt, int frame)
 734 {
 735         int     retval;
 736
 737         osst_wait_ready(STp, aSRpnt, 15 * 60, 0);                       /* TODO - can this catch a write error? */
 738         retval = osst_set_frame_position(STp, aSRpnt, frame, 0);
 739         if (retval) return (retval);
 740         osst_wait_ready(STp, aSRpnt, 15 * 60, OSST_WAIT_POSITION_COMPLETE);
 741         return (osst_get_frame_position(STp, aSRpnt));
 742 }
 743
 744 /*
 745  * Wait for write(s) to complete
 746  */
 747 static int osst_flush_drive_buffer(struct osst_tape * STp, struct scsi_request ** aSRpnt)
 748 {
 749         unsigned char           cmd[MAX_COMMAND_SIZE];
 750         struct scsi_request   * SRpnt;
 751         int                     result = 0;
 752         int                     delay  = OSST_WAIT_WRITE_COMPLETE;
 753 #if DEBUG
 754         char                  * name = tape_name(STp);
 755
 756         printk(OSST_DEB_MSG "%s:D: Reached onstream flush drive buffer (write filemark)\n", name);
 757 #endif
 758
 759         memset(cmd, 0, MAX_COMMAND_SIZE);
 760         cmd[0] = WRITE_FILEMARKS;
 761         cmd[1] = 1;
 762
 763         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 764         *aSRpnt = SRpnt;
 765         if (!SRpnt) return (-EBUSY);
 766         if (STp->buffer->syscall_result) {
 767                 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == 2 && SRpnt->sr_sense_buffer[12] == 4) {
 768                         if (SRpnt->sr_sense_buffer[13] == 8) {
 769                                 delay = OSST_WAIT_LONG_WRITE_COMPLETE;
 770                         }
 771                 } else
 772                         result = osst_write_error_recovery(STp, aSRpnt, 0);
 773         }
 774         result |= osst_wait_ready(STp, aSRpnt, 5 * 60, delay);
 775         STp->ps[STp->partition].rw = OS_WRITING_COMPLETE;
 776
 777         return (result);
 778 }
 779
 780 #define OSST_POLL_PER_SEC 10
 781 static int osst_wait_frame(struct osst_tape * STp, struct scsi_request ** aSRpnt, int curr, int minlast, int to)
 782 {
 783         unsigned long   startwait = jiffies;
 784         char          * name      = tape_name(STp);
 785 #if DEBUG
 786         char       notyetprinted  = 1;
 787 #endif
 788         if (minlast >= 0 && STp->ps[STp->partition].rw != ST_READING)
 789                 printk(KERN_ERR "%s:A: Waiting for frame without having initialized read!\n", name);
 790
 791         while (time_before (jiffies, startwait + to*HZ))
 792         {
 793                 int result;
 794                 result = osst_get_frame_position(STp, aSRpnt);
 795                 if (result == -EIO)
 796                         if ((result = osst_write_error_recovery(STp, aSRpnt, 0)) == 0)
 797                                 return 0;       /* successful recovery leaves drive ready for frame */
 798                 if (result < 0) break;
 799                 if (STp->first_frame_position == curr &&
 800                     ((minlast < 0 &&
 801                       (signed)STp->last_frame_position > (signed)curr + minlast) ||
 802                      (minlast >= 0 && STp->cur_frames > minlast)
 803                     ) && result >= 0)
 804                 {
 805 #if DEBUG
 806                         if (debugging || jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC)
 807                                 printk (OSST_DEB_MSG
 808                                         "%s:D: Succ wait f fr %i (>%i): %i-%i %i (%i): %3li.%li s\n",
 809                                         name, curr, curr+minlast, STp->first_frame_position,
 810                                         STp->last_frame_position, STp->cur_frames,
 811                                         result, (jiffies-startwait)/HZ,
 812                                         (((jiffies-startwait)%HZ)*10)/HZ);
 813 #endif
 814                         return 0;
 815                 }
 816 #if DEBUG
 817                 if (jiffies - startwait >= 2*HZ/OSST_POLL_PER_SEC && notyetprinted)
 818                 {
 819                         printk (OSST_DEB_MSG "%s:D: Wait for frame %i (>%i): %i-%i %i (%i)\n",
 820                                 name, curr, curr+minlast, STp->first_frame_position,
 821                                 STp->last_frame_position, STp->cur_frames, result);
 822                         notyetprinted--;
 823                 }
 824 #endif
 825                 msleep(1000 / OSST_POLL_PER_SEC);
 826         }
 827 #if DEBUG
 828         printk (OSST_DEB_MSG "%s:D: Fail wait f fr %i (>%i): %i-%i %i: %3li.%li s\n",
 829                 name, curr, curr+minlast, STp->first_frame_position,
 830                 STp->last_frame_position, STp->cur_frames,
 831                 (jiffies-startwait)/HZ, (((jiffies-startwait)%HZ)*10)/HZ);
 832 #endif
 833         return -EBUSY;
 834 }
 835
 836 static int osst_recover_wait_frame(struct osst_tape * STp, struct scsi_request ** aSRpnt, int writing)
 837 {
 838         struct scsi_request   * SRpnt;
 839         unsigned char           cmd[MAX_COMMAND_SIZE];
 840         unsigned long           startwait = jiffies;
 841         int                     retval    = 1;
 842         char                  * name      = tape_name(STp);
 843
 844         if (writing) {
 845                 char    mybuf[24];
 846                 char  * olddata = STp->buffer->b_data;
 847                 int     oldsize = STp->buffer->buffer_size;
 848
 849                 /* write zero fm then read pos - if shows write error, try to recover - if no progress, wait */
 850
 851                 memset(cmd, 0, MAX_COMMAND_SIZE);
 852                 cmd[0] = WRITE_FILEMARKS;
 853                 cmd[1] = 1;
 854                 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
 855                                                                 MAX_RETRIES, 1);
 856
 857                 while (retval && time_before (jiffies, startwait + 5*60*HZ)) {
 858
 859                         if (STp->buffer->syscall_result && (SRpnt->sr_sense_buffer[2] & 0x0f) != 2) {
 860
 861                                 /* some failure - not just not-ready */
 862                                 retval = osst_write_error_recovery(STp, aSRpnt, 0);
 863                                 break;
 864                         }
 865                         schedule_timeout_interruptible(HZ / OSST_POLL_PER_SEC);
 866
 867                         STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
 868                         memset(cmd, 0, MAX_COMMAND_SIZE);
 869                         cmd[0] = READ_POSITION;
 870
 871                         SRpnt = osst_do_scsi(SRpnt, STp, cmd, 20, DMA_FROM_DEVICE, STp->timeout,
 872                                                                                 MAX_RETRIES, 1);
 873
 874                         retval = ( STp->buffer->syscall_result || (STp->buffer)->b_data[15] > 25 );
 875                         STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
 876                 }
 877                 if (retval)
 878                         printk(KERN_ERR "%s:E: Device did not succeed to write buffered data\n", name);
 879         } else
 880                 /* TODO - figure out which error conditions can be handled */
 881                 if (STp->buffer->syscall_result)
 882                         printk(KERN_WARNING
 883                                 "%s:W: Recover_wait_frame(read) cannot handle %02x:%02x:%02x\n", name,
 884                                         (*aSRpnt)->sr_sense_buffer[ 2] & 0x0f,
 885                                         (*aSRpnt)->sr_sense_buffer[12],
 886                                         (*aSRpnt)->sr_sense_buffer[13]);
 887
 888         return retval;
 889 }
 890
 891 /*
 892  * Read the next OnStream tape frame at the current location
 893  */
 894 static int osst_read_frame(struct osst_tape * STp, struct scsi_request ** aSRpnt, int timeout)
 895 {
 896         unsigned char           cmd[MAX_COMMAND_SIZE];
 897         struct scsi_request   * SRpnt;
 898         int                     retval = 0;
 899 #if DEBUG
 900         os_aux_t              * aux    = STp->buffer->aux;
 901         char                  * name   = tape_name(STp);
 902 #endif
 903
 904         if (STp->poll)
 905                 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, 0, timeout))
 906                         retval = osst_recover_wait_frame(STp, aSRpnt, 0);
 907
 908         memset(cmd, 0, MAX_COMMAND_SIZE);
 909         cmd[0] = READ_6;
 910         cmd[1] = 1;
 911         cmd[4] = 1;
 912
 913 #if DEBUG
 914         if (debugging)
 915                 printk(OSST_DEB_MSG "%s:D: Reading frame from OnStream tape\n", name);
 916 #endif
 917         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
 918                                       STp->timeout, MAX_RETRIES, 1);
 919         *aSRpnt = SRpnt;
 920         if (!SRpnt)
 921                 return (-EBUSY);
 922
 923         if ((STp->buffer)->syscall_result) {
 924             retval = 1;
 925             if (STp->read_error_frame == 0) {
 926                 STp->read_error_frame = STp->first_frame_position;
 927 #if DEBUG
 928                 printk(OSST_DEB_MSG "%s:D: Recording read error at %d\n", name, STp->read_error_frame);
 929 #endif
 930             }
 931 #if DEBUG
 932             if (debugging)
 933                 printk(OSST_DEB_MSG "%s:D: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
 934                    name,
 935                    SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[1],
 936                    SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[3],
 937                    SRpnt->sr_sense_buffer[4], SRpnt->sr_sense_buffer[5],
 938                    SRpnt->sr_sense_buffer[6], SRpnt->sr_sense_buffer[7]);
 939 #endif
 940         }
 941         else
 942             STp->first_frame_position++;
 943 #if DEBUG
 944         if (debugging) {
 945            char sig[8]; int i;
 946            for (i=0;i<4;i++)
 947                    sig[i] = aux->application_sig[i]<32?'^':aux->application_sig[i];
 948            sig[4] = '\0';
 949            printk(OSST_DEB_MSG
 950                 "%s:D: AUX: %s UpdFrCt#%d Wpass#%d %s FrSeq#%d LogBlk#%d Qty=%d Sz=%d\n", name, sig,
 951                         ntohl(aux->update_frame_cntr), ntohs(aux->partition.wrt_pass_cntr),
 952                         aux->frame_type==1?"EOD":aux->frame_type==2?"MARK":
 953                         aux->frame_type==8?"HEADR":aux->frame_type==0x80?"DATA":"FILL",
 954                         ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
 955                         ntohs(aux->dat.dat_list[0].blk_cnt), ntohl(aux->dat.dat_list[0].blk_sz) );
 956            if (aux->frame_type==2)
 957                 printk(OSST_DEB_MSG "%s:D: mark_cnt=%d, last_mark_ppos=%d, last_mark_lbn=%d\n", name,
 958                         ntohl(aux->filemark_cnt), ntohl(aux->last_mark_ppos), ntohl(aux->last_mark_lbn));
 959            printk(OSST_DEB_MSG "%s:D: Exit read frame from OnStream tape with code %d\n", name, retval);
 960         }
 961 #endif
 962         return (retval);
 963 }
 964
 965 static int osst_initiate_read(struct osst_tape * STp, struct scsi_request ** aSRpnt)
 966 {
 967         struct st_partstat    * STps   = &(STp->ps[STp->partition]);
 968         struct scsi_request   * SRpnt  ;
 969         unsigned char           cmd[MAX_COMMAND_SIZE];
 970         int                     retval = 0;
 971         char                  * name   = tape_name(STp);
 972
 973         if (STps->rw != ST_READING) {         /* Initialize read operation */
 974                 if (STps->rw == ST_WRITING || STp->dirty) {
 975                         STp->write_type = OS_WRITE_DATA;
 976                         osst_flush_write_buffer(STp, aSRpnt);
 977                         osst_flush_drive_buffer(STp, aSRpnt);
 978                 }
 979                 STps->rw = ST_READING;
 980                 STp->frame_in_buffer = 0;
 981
 982                 /*
 983                  *      Issue a read 0 command to get the OnStream drive
 984                  *      read frames into its buffer.
 985                  */
 986                 memset(cmd, 0, MAX_COMMAND_SIZE);
 987                 cmd[0] = READ_6;
 988                 cmd[1] = 1;
 989
 990 #if DEBUG
 991                 printk(OSST_DEB_MSG "%s:D: Start Read Ahead on OnStream tape\n", name);
 992 #endif
 993                 SRpnt   = osst_do_scsi(*aSRpnt, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
 994                 *aSRpnt = SRpnt;
 995                 if ((retval = STp->buffer->syscall_result))
 996                         printk(KERN_WARNING "%s:W: Error starting read ahead\n", name);
 997         }
 998
 999         return retval;
1000 }
1001
1002 static int osst_get_logical_frame(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1003                                                 int frame_seq_number, int quiet)
1004 {
1005         struct st_partstat * STps  = &(STp->ps[STp->partition]);
1006         char               * name  = tape_name(STp);
1007         int                  cnt   = 0,
1008                              bad   = 0,
1009                              past  = 0,
1010                              x,
1011                              position;
1012
1013         /*
1014          * If we want just any frame (-1) and there is a frame in the buffer, return it
1015          */
1016         if (frame_seq_number == -1 && STp->frame_in_buffer) {
1017 #if DEBUG
1018                 printk(OSST_DEB_MSG "%s:D: Frame %d still in buffer\n", name, STp->frame_seq_number);
1019 #endif
1020                 return (STps->eof);
1021         }
1022         /*
1023          * Search and wait for the next logical tape frame
1024          */
1025         while (1) {
1026                 if (cnt++ > 400) {
1027                         printk(KERN_ERR "%s:E: Couldn't find logical frame %d, aborting\n",
1028                                             name, frame_seq_number);
1029                         if (STp->read_error_frame) {
1030                                 osst_set_frame_position(STp, aSRpnt, STp->read_error_frame, 0);
1031 #if DEBUG
1032                                 printk(OSST_DEB_MSG "%s:D: Repositioning tape to bad frame %d\n",
1033                                                     name, STp->read_error_frame);
1034 #endif
1035                                 STp->read_error_frame = 0;
1036                                 STp->abort_count++;
1037                         }
1038                         return (-EIO);
1039                 }
1040 #if DEBUG
1041                 if (debugging)
1042                         printk(OSST_DEB_MSG "%s:D: Looking for frame %d, attempt %d\n",
1043                                           name, frame_seq_number, cnt);
1044 #endif
1045                 if ( osst_initiate_read(STp, aSRpnt)
1046                 || ( (!STp->frame_in_buffer) && osst_read_frame(STp, aSRpnt, 30) ) ) {
1047                         if (STp->raw)
1048                                 return (-EIO);
1049                         position = osst_get_frame_position(STp, aSRpnt);
1050                         if (position >= 0xbae && position < 0xbb8)
1051                                 position = 0xbb8;
1052                         else if (position > STp->eod_frame_ppos || ++bad == 10) {
1053                                 position = STp->read_error_frame - 1;
1054                                 bad = 0;
1055                         }
1056                         else {
1057                                 position += 29;
1058                                 cnt      += 19;
1059                         }
1060 #if DEBUG
1061                         printk(OSST_DEB_MSG "%s:D: Bad frame detected, positioning tape to block %d\n",
1062                                          name, position);
1063 #endif
1064                         osst_set_frame_position(STp, aSRpnt, position, 0);
1065                         continue;
1066                 }
1067                 if (osst_verify_frame(STp, frame_seq_number, quiet))
1068                         break;
1069                 if (osst_verify_frame(STp, -1, quiet)) {
1070                         x = ntohl(STp->buffer->aux->frame_seq_num);
1071                         if (STp->fast_open) {
1072                                 printk(KERN_WARNING
1073                                        "%s:W: Found logical frame %d instead of %d after fast open\n",
1074                                        name, x, frame_seq_number);
1075                                 STp->header_ok = 0;
1076                                 STp->read_error_frame = 0;
1077                                 return (-EIO);
1078                         }
1079                         if (x > frame_seq_number) {
1080                                 if (++past > 3) {
1081                                         /* positioning backwards did not bring us to the desired frame */
1082                                         position = STp->read_error_frame - 1;
1083                                 }
1084                                 else {
1085                                         position = osst_get_frame_position(STp, aSRpnt)
1086                                                  + frame_seq_number - x - 1;
1087
1088                                         if (STp->first_frame_position >= 3000 && position < 3000)
1089                                                 position -= 10;
1090                                 }
1091 #if DEBUG
1092                                 printk(OSST_DEB_MSG
1093                                        "%s:D: Found logical frame %d while looking for %d: back up %d\n",
1094                                                 name, x, frame_seq_number,
1095                                                 STp->first_frame_position - position);
1096 #endif
1097                                 osst_set_frame_position(STp, aSRpnt, position, 0);
1098                                 cnt += 10;
1099                         }
1100                         else
1101                                 past = 0;
1102                 }
1103                 if (osst_get_frame_position(STp, aSRpnt) == 0xbaf) {
1104 #if DEBUG
1105                         printk(OSST_DEB_MSG "%s:D: Skipping config partition\n", name);
1106 #endif
1107                         osst_set_frame_position(STp, aSRpnt, 0xbb8, 0);
1108                         cnt--;
1109                 }
1110                 STp->frame_in_buffer = 0;
1111         }
1112         if (cnt > 1) {
1113                 STp->recover_count++;
1114                 STp->recover_erreg++;
1115                 printk(KERN_WARNING "%s:I: Don't worry, Read error at position %d recovered\n",
1116                                         name, STp->read_error_frame);
1117         }
1118         STp->read_count++;
1119
1120 #if DEBUG
1121         if (debugging || STps->eof)
1122                 printk(OSST_DEB_MSG
1123                         "%s:D: Exit get logical frame (%d=>%d) from OnStream tape with code %d\n",
1124                         name, frame_seq_number, STp->frame_seq_number, STps->eof);
1125 #endif
1126         STp->fast_open = 0;
1127         STp->read_error_frame = 0;
1128         return (STps->eof);
1129 }
1130
1131 static int osst_seek_logical_blk(struct osst_tape * STp, struct scsi_request ** aSRpnt, int logical_blk_num)
1132 {
1133         struct st_partstat * STps = &(STp->ps[STp->partition]);
1134         char               * name = tape_name(STp);
1135         int     retries    = 0;
1136         int     frame_seq_estimate, ppos_estimate, move;
1137
1138         if (logical_blk_num < 0) logical_blk_num = 0;
1139 #if DEBUG
1140         printk(OSST_DEB_MSG "%s:D: Seeking logical block %d (now at %d, size %d%c)\n",
1141                                 name, logical_blk_num, STp->logical_blk_num,
1142                                 STp->block_size<1024?STp->block_size:STp->block_size/1024,
1143                                 STp->block_size<1024?'b':'k');
1144 #endif
1145         /* Do we know where we are? */
1146         if (STps->drv_block >= 0) {
1147                 move                = logical_blk_num - STp->logical_blk_num;
1148                 if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
1149                 move               /= (OS_DATA_SIZE / STp->block_size);
1150                 frame_seq_estimate  = STp->frame_seq_number + move;
1151         } else
1152                 frame_seq_estimate  = logical_blk_num * STp->block_size / OS_DATA_SIZE;
1153
1154         if (frame_seq_estimate < 2980) ppos_estimate = frame_seq_estimate + 10;
1155         else                           ppos_estimate = frame_seq_estimate + 20;
1156         while (++retries < 10) {
1157            if (ppos_estimate > STp->eod_frame_ppos-2) {
1158                frame_seq_estimate += STp->eod_frame_ppos - 2 - ppos_estimate;
1159                ppos_estimate       = STp->eod_frame_ppos - 2;
1160            }
1161            if (frame_seq_estimate < 0) {
1162                frame_seq_estimate = 0;
1163                ppos_estimate      = 10;
1164            }
1165            osst_set_frame_position(STp, aSRpnt, ppos_estimate, 0);
1166            if (osst_get_logical_frame(STp, aSRpnt, frame_seq_estimate, 1) >= 0) {
1167               /* we've located the estimated frame, now does it have our block? */
1168               if (logical_blk_num <  STp->logical_blk_num ||
1169                   logical_blk_num >= STp->logical_blk_num + ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt)) {
1170                  if (STps->eof == ST_FM_HIT)
1171                     move = logical_blk_num < STp->logical_blk_num? -2 : 1;
1172                  else {
1173                     move                = logical_blk_num - STp->logical_blk_num;
1174                     if (move < 0) move -= (OS_DATA_SIZE / STp->block_size) - 1;
1175                     move               /= (OS_DATA_SIZE / STp->block_size);
1176                  }
1177                  if (!move) move = logical_blk_num > STp->logical_blk_num ? 1 : -1;
1178 #if DEBUG
1179                  printk(OSST_DEB_MSG
1180                         "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d) move %d\n",
1181                                 name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
1182                                 STp->logical_blk_num, logical_blk_num, move);
1183 #endif
1184                  frame_seq_estimate += move;
1185                  ppos_estimate      += move;
1186                  continue;
1187               } else {
1188                  STp->buffer->read_pointer  = (logical_blk_num - STp->logical_blk_num) * STp->block_size;
1189                  STp->buffer->buffer_bytes -= STp->buffer->read_pointer;
1190                  STp->logical_blk_num       =  logical_blk_num;
1191 #if DEBUG
1192                  printk(OSST_DEB_MSG
1193                         "%s:D: Seek success at ppos %d fsq %d in_buf %d, bytes %d, ptr %d*%d\n",
1194                                 name, ppos_estimate, STp->frame_seq_number, STp->frame_in_buffer,
1195                                 STp->buffer->buffer_bytes, STp->buffer->read_pointer / STp->block_size,
1196                                 STp->block_size);
1197 #endif
1198                  STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
1199                  if (STps->eof == ST_FM_HIT) {
1200                      STps->drv_file++;
1201                      STps->drv_block = 0;
1202                  } else {
1203                      STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
1204                                           STp->logical_blk_num -
1205                                              (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
1206                                         -1;
1207                  }
1208                  STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
1209                  return 0;
1210               }
1211            }
1212            if (osst_get_logical_frame(STp, aSRpnt, -1, 1) < 0)
1213               goto error;
1214            /* we are not yet at the estimated frame, adjust our estimate of its physical position */
1215 #if DEBUG
1216            printk(OSST_DEB_MSG "%s:D: Seek retry %d at ppos %d fsq %d (est %d) lbn %d (need %d)\n",
1217                            name, retries, ppos_estimate, STp->frame_seq_number, frame_seq_estimate,
1218                            STp->logical_blk_num, logical_blk_num);
1219 #endif
1220            if (frame_seq_estimate != STp->frame_seq_number)
1221               ppos_estimate += frame_seq_estimate - STp->frame_seq_number;
1222            else
1223               break;
1224         }
1225 error:
1226         printk(KERN_ERR "%s:E: Couldn't seek to logical block %d (at %d), %d retries\n",
1227                             name, logical_blk_num, STp->logical_blk_num, retries);
1228         return (-EIO);
1229 }
1230
1231 /* The values below are based on the OnStream frame payload size of 32K == 2**15,
1232  * that is, OSST_FRAME_SHIFT + OSST_SECTOR_SHIFT must be 15. With a minimum block
1233  * size of 512 bytes, we need to be able to resolve 32K/512 == 64 == 2**6 positions
1234  * inside each frame. Finaly, OSST_SECTOR_MASK == 2**OSST_FRAME_SHIFT - 1.
1235  */
1236 #define OSST_FRAME_SHIFT  6
1237 #define OSST_SECTOR_SHIFT 9
1238 #define OSST_SECTOR_MASK  0x03F
1239
1240 static int osst_get_sector(struct osst_tape * STp, struct scsi_request ** aSRpnt)
1241 {
1242         int     sector;
1243 #if DEBUG
1244         char  * name = tape_name(STp);
1245
1246         printk(OSST_DEB_MSG
1247                 "%s:D: Positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, %cptr %d, eof %d\n",
1248                 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
1249                 STp->ps[STp->partition].drv_file, STp->ps[STp->partition].drv_block,
1250                 STp->ps[STp->partition].rw == ST_WRITING?'w':'r',
1251                 STp->ps[STp->partition].rw == ST_WRITING?STp->buffer->buffer_bytes:
1252                 STp->buffer->read_pointer, STp->ps[STp->partition].eof);
1253 #endif
1254         /* do we know where we are inside a file? */
1255         if (STp->ps[STp->partition].drv_block >= 0) {
1256                 sector = (STp->frame_in_buffer ? STp->first_frame_position-1 :
1257                                 STp->first_frame_position) << OSST_FRAME_SHIFT;
1258                 if (STp->ps[STp->partition].rw == ST_WRITING)
1259                         sector |= (STp->buffer->buffer_bytes >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
1260                 else
1261                         sector |= (STp->buffer->read_pointer >> OSST_SECTOR_SHIFT) & OSST_SECTOR_MASK;
1262         } else {
1263                 sector = osst_get_frame_position(STp, aSRpnt);
1264                 if (sector > 0)
1265                         sector <<= OSST_FRAME_SHIFT;
1266         }
1267         return sector;
1268 }
1269
1270 static int osst_seek_sector(struct osst_tape * STp, struct scsi_request ** aSRpnt, int sector)
1271 {
1272         struct st_partstat * STps   = &(STp->ps[STp->partition]);
1273         int                  frame  = sector >> OSST_FRAME_SHIFT,
1274                              offset = (sector & OSST_SECTOR_MASK) << OSST_SECTOR_SHIFT,
1275                              r;
1276 #if DEBUG
1277         char          * name = tape_name(STp);
1278
1279         printk(OSST_DEB_MSG "%s:D: Seeking sector %d in frame %d at offset %d\n",
1280                                 name, sector, frame, offset);
1281 #endif
1282         if (frame < 0 || frame >= STp->capacity) return (-ENXIO);
1283
1284         if (frame <= STp->first_data_ppos) {
1285                 STp->frame_seq_number = STp->logical_blk_num = STps->drv_file = STps->drv_block = 0;
1286                 return (osst_set_frame_position(STp, aSRpnt, frame, 0));
1287         }
1288         r = osst_set_frame_position(STp, aSRpnt, offset?frame:frame-1, 0);
1289         if (r < 0) return r;
1290
1291         r = osst_get_logical_frame(STp, aSRpnt, -1, 1);
1292         if (r < 0) return r;
1293
1294         if (osst_get_frame_position(STp, aSRpnt) != (offset?frame+1:frame)) return (-EIO);
1295
1296         if (offset) {
1297                 STp->logical_blk_num      += offset / STp->block_size;
1298                 STp->buffer->read_pointer  = offset;
1299                 STp->buffer->buffer_bytes -= offset;
1300         } else {
1301                 STp->frame_seq_number++;
1302                 STp->frame_in_buffer       = 0;
1303                 STp->logical_blk_num      += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1304                 STp->buffer->buffer_bytes  = STp->buffer->read_pointer = 0;
1305         }
1306         STps->drv_file = ntohl(STp->buffer->aux->filemark_cnt);
1307         if (STps->eof == ST_FM_HIT) {
1308                 STps->drv_file++;
1309                 STps->drv_block = 0;
1310         } else {
1311                 STps->drv_block = ntohl(STp->buffer->aux->last_mark_lbn)?
1312                                     STp->logical_blk_num -
1313                                         (STps->drv_file ? ntohl(STp->buffer->aux->last_mark_lbn) + 1 : 0):
1314                                   -1;
1315         }
1316         STps->eof       = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_NOEOF;
1317 #if DEBUG
1318         printk(OSST_DEB_MSG
1319                 "%s:D: Now positioned at ppos %d, frame %d, lbn %d, file %d, blk %d, rptr %d, eof %d\n",
1320                 name, STp->first_frame_position, STp->frame_seq_number, STp->logical_blk_num,
1321                 STps->drv_file, STps->drv_block, STp->buffer->read_pointer, STps->eof);
1322 #endif
1323         return 0;
1324 }
1325
1326 /*
1327  * Read back the drive's internal buffer contents, as a part
1328  * of the write error recovery mechanism for old OnStream
1329  * firmware revisions.
1330  * Precondition for this function to work: all frames in the
1331  * drive's buffer must be of one type (DATA, MARK or EOD)!
1332  */
1333 static int osst_read_back_buffer_and_rewrite(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1334                                                 unsigned int frame, unsigned int skip, int pending)
1335 {
1336         struct scsi_request   * SRpnt = * aSRpnt;
1337         unsigned char         * buffer, * p;
1338         unsigned char           cmd[MAX_COMMAND_SIZE];
1339         int                     flag, new_frame, i;
1340         int                     nframes          = STp->cur_frames;
1341         int                     blks_per_frame   = ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1342         int                     frame_seq_number = ntohl(STp->buffer->aux->frame_seq_num)
1343                                                 - (nframes + pending - 1);
1344         int                     logical_blk_num  = ntohl(STp->buffer->aux->logical_blk_num)
1345                                                 - (nframes + pending - 1) * blks_per_frame;
1346         char                  * name             = tape_name(STp);
1347         unsigned long           startwait        = jiffies;
1348 #if DEBUG
1349         int                     dbg              = debugging;
1350 #endif
1351
1352         if ((buffer = (unsigned char *)vmalloc((nframes + 1) * OS_DATA_SIZE)) == NULL)
1353                 return (-EIO);
1354
1355         printk(KERN_INFO "%s:I: Reading back %d frames from drive buffer%s\n",
1356                          name, nframes, pending?" and one that was pending":"");
1357
1358         osst_copy_from_buffer(STp->buffer, (p = &buffer[nframes * OS_DATA_SIZE]));
1359 #if DEBUG
1360         if (pending && debugging)
1361                 printk(OSST_DEB_MSG "%s:D: Pending frame %d (lblk %d), data %02x %02x %02x %02x\n",
1362                                 name, frame_seq_number + nframes,
1363                                 logical_blk_num + nframes * blks_per_frame,
1364                                 p[0], p[1], p[2], p[3]);
1365 #endif
1366         for (i = 0, p = buffer; i < nframes; i++, p += OS_DATA_SIZE) {
1367
1368                 memset(cmd, 0, MAX_COMMAND_SIZE);
1369                 cmd[0] = 0x3C;          /* Buffer Read           */
1370                 cmd[1] = 6;             /* Retrieve Faulty Block */
1371                 cmd[7] = 32768 >> 8;
1372                 cmd[8] = 32768 & 0xff;
1373
1374                 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_FROM_DEVICE,
1375                                             STp->timeout, MAX_RETRIES, 1);
1376
1377                 if ((STp->buffer)->syscall_result || !SRpnt) {
1378                         printk(KERN_ERR "%s:E: Failed to read frame back from OnStream buffer\n", name);
1379                         vfree(buffer);
1380                         *aSRpnt = SRpnt;
1381                         return (-EIO);
1382                 }
1383                 osst_copy_from_buffer(STp->buffer, p);
1384 #if DEBUG
1385                 if (debugging)
1386                         printk(OSST_DEB_MSG "%s:D: Read back logical frame %d, data %02x %02x %02x %02x\n",
1387                                           name, frame_seq_number + i, p[0], p[1], p[2], p[3]);
1388 #endif
1389         }
1390         *aSRpnt = SRpnt;
1391         osst_get_frame_position(STp, aSRpnt);
1392
1393 #if DEBUG
1394         printk(OSST_DEB_MSG "%s:D: Frames left in buffer: %d\n", name, STp->cur_frames);
1395 #endif
1396         /* Write synchronously so we can be sure we're OK again and don't have to recover recursively */
1397         /* In the header we don't actually re-write the frames that fail, just the ones after them */
1398
1399         for (flag=1, new_frame=frame, p=buffer, i=0; i < nframes + pending; ) {
1400
1401                 if (flag) {
1402                         if (STp->write_type == OS_WRITE_HEADER) {
1403                                 i += skip;
1404                                 p += skip * OS_DATA_SIZE;
1405                         }
1406                         else if (new_frame < 2990 && new_frame+skip+nframes+pending >= 2990)
1407                                 new_frame = 3000-i;
1408                         else
1409                                 new_frame += skip;
1410 #if DEBUG
1411                         printk(OSST_DEB_MSG "%s:D: Position to frame %d, write fseq %d\n",
1412                                                 name, new_frame+i, frame_seq_number+i);
1413 #endif
1414                         osst_set_frame_position(STp, aSRpnt, new_frame + i, 0);
1415                         osst_wait_ready(STp, aSRpnt, 60, OSST_WAIT_POSITION_COMPLETE);
1416                         osst_get_frame_position(STp, aSRpnt);
1417                         SRpnt = * aSRpnt;
1418
1419                         if (new_frame > frame + 1000) {
1420                                 printk(KERN_ERR "%s:E: Failed to find writable tape media\n", name);
1421                                 vfree(buffer);
1422                                 return (-EIO);
1423                         }
1424                         if ( i >= nframes + pending ) break;
1425                         flag = 0;
1426                 }
1427                 osst_copy_to_buffer(STp->buffer, p);
1428                 /*
1429                  * IMPORTANT: for error recovery to work, _never_ queue frames with mixed frame type!
1430                  */
1431                 osst_init_aux(STp, STp->buffer->aux->frame_type, frame_seq_number+i,
1432                                 logical_blk_num + i*blks_per_frame,
1433                                 ntohl(STp->buffer->aux->dat.dat_list[0].blk_sz), blks_per_frame);
1434                 memset(cmd, 0, MAX_COMMAND_SIZE);
1435                 cmd[0] = WRITE_6;
1436                 cmd[1] = 1;
1437                 cmd[4] = 1;
1438
1439 #if DEBUG
1440                 if (debugging)
1441                         printk(OSST_DEB_MSG
1442                                 "%s:D: About to write frame %d, seq %d, lbn %d, data %02x %02x %02x %02x\n",
1443                                 name, new_frame+i, frame_seq_number+i, logical_blk_num + i*blks_per_frame,
1444                                 p[0], p[1], p[2], p[3]);
1445 #endif
1446                 SRpnt = osst_do_scsi(SRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
1447                                             STp->timeout, MAX_RETRIES, 1);
1448
1449                 if (STp->buffer->syscall_result)
1450                         flag = 1;
1451                 else {
1452                         p += OS_DATA_SIZE; i++;
1453
1454                         /* if we just sent the last frame, wait till all successfully written */
1455                         if ( i == nframes + pending ) {
1456 #if DEBUG
1457                                 printk(OSST_DEB_MSG "%s:D: Check re-write successful\n", name);
1458 #endif
1459                                 memset(cmd, 0, MAX_COMMAND_SIZE);
1460                                 cmd[0] = WRITE_FILEMARKS;
1461                                 cmd[1] = 1;
1462                                 SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
1463                                                             STp->timeout, MAX_RETRIES, 1);
1464 #if DEBUG
1465                                 if (debugging) {
1466                                         printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
1467                                         printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
1468                                         debugging = 0;
1469                                 }
1470 #endif
1471                                 flag = STp->buffer->syscall_result;
1472                                 while ( !flag && time_before(jiffies, startwait + 60*HZ) ) {
1473
1474                                         memset(cmd, 0, MAX_COMMAND_SIZE);
1475                                         cmd[0] = TEST_UNIT_READY;
1476
1477                                         SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE, STp->timeout,
1478                                                                                                 MAX_RETRIES, 1);
1479
1480                                         if (SRpnt->sr_sense_buffer[2] == 2 && SRpnt->sr_sense_buffer[12] == 4 &&
1481                                             (SRpnt->sr_sense_buffer[13] == 1 || SRpnt->sr_sense_buffer[13] == 8)) {
1482                                                 /* in the process of becoming ready */
1483                                                 msleep(100);
1484                                                 continue;
1485                                         }
1486                                         if (STp->buffer->syscall_result)
1487                                                 flag = 1;
1488                                         break;
1489                                 }
1490 #if DEBUG
1491                                 debugging = dbg;
1492                                 printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
1493 #endif
1494                         }
1495                 }
1496                 *aSRpnt = SRpnt;
1497                 if (flag) {
1498                         if ((SRpnt->sr_sense_buffer[ 2] & 0x0f) == 13 &&
1499                              SRpnt->sr_sense_buffer[12]         ==  0 &&
1500                              SRpnt->sr_sense_buffer[13]         ==  2) {
1501                                 printk(KERN_ERR "%s:E: Volume overflow in write error recovery\n", name);
1502                                 vfree(buffer);
1503                                 return (-EIO);                  /* hit end of tape = fail */
1504                         }
1505                         i = ((SRpnt->sr_sense_buffer[3] << 24) |
1506                              (SRpnt->sr_sense_buffer[4] << 16) |
1507                              (SRpnt->sr_sense_buffer[5] <<  8) |
1508                               SRpnt->sr_sense_buffer[6]        ) - new_frame;
1509                         p = &buffer[i * OS_DATA_SIZE];
1510 #if DEBUG
1511                         printk(OSST_DEB_MSG "%s:D: Additional write error at %d\n", name, new_frame+i);
1512 #endif
1513                         osst_get_frame_position(STp, aSRpnt);
1514 #if DEBUG
1515                         printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d, buffer = %d\n",
1516                                           name, STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
1517 #endif
1518                 }
1519         }
1520         if (flag) {
1521                 /* error recovery did not successfully complete */
1522                 printk(KERN_ERR "%s:D: Write error recovery failed in %s\n", name,
1523                                 STp->write_type == OS_WRITE_HEADER?"header":"body");
1524         }
1525         if (!pending)
1526                 osst_copy_to_buffer(STp->buffer, p);    /* so buffer content == at entry in all cases */
1527         vfree(buffer);
1528         return 0;
1529 }
1530
1531 static int osst_reposition_and_retry(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1532                                         unsigned int frame, unsigned int skip, int pending)
1533 {
1534         unsigned char           cmd[MAX_COMMAND_SIZE];
1535         struct scsi_request   * SRpnt;
1536         char                  * name      = tape_name(STp);
1537         int                     expected  = 0;
1538         int                     attempts  = 1000 / skip;
1539         int                     flag      = 1;
1540         unsigned long           startwait = jiffies;
1541 #if DEBUG
1542         int                     dbg       = debugging;
1543 #endif
1544
1545         while (attempts && time_before(jiffies, startwait + 60*HZ)) {
1546                 if (flag) {
1547 #if DEBUG
1548                         debugging = dbg;
1549 #endif
1550                         if (frame < 2990 && frame+skip+STp->cur_frames+pending >= 2990)
1551                                 frame = 3000-skip;
1552                         expected = frame+skip+STp->cur_frames+pending;
1553 #if DEBUG
1554                         printk(OSST_DEB_MSG "%s:D: Position to fppos %d, re-write from fseq %d\n",
1555                                           name, frame+skip, STp->frame_seq_number-STp->cur_frames-pending);
1556 #endif
1557                         osst_set_frame_position(STp, aSRpnt, frame + skip, 1);
1558                         flag = 0;
1559                         attempts--;
1560                         schedule_timeout_interruptible(msecs_to_jiffies(100));
1561                 }
1562                 if (osst_get_frame_position(STp, aSRpnt) < 0) {         /* additional write error */
1563 #if DEBUG
1564                         printk(OSST_DEB_MSG "%s:D: Addl error, host %d, tape %d, buffer %d\n",
1565                                           name, STp->first_frame_position,
1566                                           STp->last_frame_position, STp->cur_frames);
1567 #endif
1568                         frame = STp->last_frame_position;
1569                         flag = 1;
1570                         continue;
1571                 }
1572                 if (pending && STp->cur_frames < 50) {
1573
1574                         memset(cmd, 0, MAX_COMMAND_SIZE);
1575                         cmd[0] = WRITE_6;
1576                         cmd[1] = 1;
1577                         cmd[4] = 1;
1578 #if DEBUG
1579                         printk(OSST_DEB_MSG "%s:D: About to write pending fseq %d at fppos %d\n",
1580                                           name, STp->frame_seq_number-1, STp->first_frame_position);
1581 #endif
1582                         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE,
1583                                                       STp->timeout, MAX_RETRIES, 1);
1584                         *aSRpnt = SRpnt;
1585
1586                         if (STp->buffer->syscall_result) {              /* additional write error */
1587                                 if ((SRpnt->sr_sense_buffer[ 2] & 0x0f) == 13 &&
1588                                      SRpnt->sr_sense_buffer[12]         ==  0 &&
1589                                      SRpnt->sr_sense_buffer[13]         ==  2) {
1590                                         printk(KERN_ERR
1591                                                "%s:E: Volume overflow in write error recovery\n",
1592                                                name);
1593                                         break;                          /* hit end of tape = fail */
1594                                 }
1595                                 flag = 1;
1596                         }
1597                         else
1598                                 pending = 0;
1599
1600                         continue;
1601                 }
1602                 if (STp->cur_frames == 0) {
1603 #if DEBUG
1604                         debugging = dbg;
1605                         printk(OSST_DEB_MSG "%s:D: Wait re-write finished\n", name);
1606 #endif
1607                         if (STp->first_frame_position != expected) {
1608                                 printk(KERN_ERR "%s:A: Actual position %d - expected %d\n",
1609                                                 name, STp->first_frame_position, expected);
1610                                 return (-EIO);
1611                         }
1612                         return 0;
1613                 }
1614 #if DEBUG
1615                 if (debugging) {
1616                         printk(OSST_DEB_MSG "%s:D: Sleeping in re-write wait ready\n", name);
1617                         printk(OSST_DEB_MSG "%s:D: Turning off debugging for a while\n", name);
1618                         debugging = 0;
1619                 }
1620 #endif
1621                 schedule_timeout_interruptible(msecs_to_jiffies(100));
1622         }
1623         printk(KERN_ERR "%s:E: Failed to find valid tape media\n", name);
1624 #if DEBUG
1625         debugging = dbg;
1626 #endif
1627         return (-EIO);
1628 }
1629
1630 /*
1631  * Error recovery algorithm for the OnStream tape.
1632  */
1633
1634 static int osst_write_error_recovery(struct osst_tape * STp, struct scsi_request ** aSRpnt, int pending)
1635 {
1636         struct scsi_request * SRpnt  = * aSRpnt;
1637         struct st_partstat  * STps   = & STp->ps[STp->partition];
1638         char                * name   = tape_name(STp);
1639         int                   retval = 0;
1640         int                   rw_state;
1641         unsigned int          frame, skip;
1642
1643         rw_state = STps->rw;
1644
1645         if ((SRpnt->sr_sense_buffer[ 2] & 0x0f) != 3
1646           || SRpnt->sr_sense_buffer[12]         != 12
1647           || SRpnt->sr_sense_buffer[13]         != 0) {
1648 #if DEBUG
1649                 printk(OSST_DEB_MSG "%s:D: Write error recovery cannot handle %02x:%02x:%02x\n", name,
1650                         SRpnt->sr_sense_buffer[2], SRpnt->sr_sense_buffer[12], SRpnt->sr_sense_buffer[13]);
1651 #endif
1652                 return (-EIO);
1653         }
1654         frame = (SRpnt->sr_sense_buffer[3] << 24) |
1655                 (SRpnt->sr_sense_buffer[4] << 16) |
1656                 (SRpnt->sr_sense_buffer[5] <<  8) |
1657                  SRpnt->sr_sense_buffer[6];
1658         skip  =  SRpnt->sr_sense_buffer[9];
1659
1660 #if DEBUG
1661         printk(OSST_DEB_MSG "%s:D: Detected physical bad frame at %u, advised to skip %d\n", name, frame, skip);
1662 #endif
1663         osst_get_frame_position(STp, aSRpnt);
1664 #if DEBUG
1665         printk(OSST_DEB_MSG "%s:D: reported frame positions: host = %d, tape = %d\n",
1666                         name, STp->first_frame_position, STp->last_frame_position);
1667 #endif
1668         switch (STp->write_type) {
1669            case OS_WRITE_DATA:
1670            case OS_WRITE_EOD:
1671            case OS_WRITE_NEW_MARK:
1672                 printk(KERN_WARNING
1673                         "%s:I: Relocating %d buffered logical frames from position %u to %u\n",
1674                         name, STp->cur_frames, frame, (frame + skip > 3000 && frame < 3000)?3000:frame + skip);
1675                 if (STp->os_fw_rev >= 10600)
1676                         retval = osst_reposition_and_retry(STp, aSRpnt, frame, skip, pending);
1677                 else
1678                         retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, skip, pending);
1679                 printk(KERN_WARNING "%s:%s: %sWrite error%srecovered\n", name,
1680                                 retval?"E"    :"I",
1681                                 retval?""     :"Don't worry, ",
1682                                 retval?" not ":" ");
1683                 break;
1684            case OS_WRITE_LAST_MARK:
1685                 printk(KERN_ERR "%s:E: Bad frame in update last marker, fatal\n", name);
1686                 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
1687                 retval = -EIO;
1688                 break;
1689            case OS_WRITE_HEADER:
1690                 printk(KERN_WARNING "%s:I: Bad frame in header partition, skipped\n", name);
1691                 retval = osst_read_back_buffer_and_rewrite(STp, aSRpnt, frame, 1, pending);
1692                 break;
1693            default:
1694                 printk(KERN_INFO "%s:I: Bad frame in filler, ignored\n", name);
1695                 osst_set_frame_position(STp, aSRpnt, frame + STp->cur_frames + pending, 0);
1696         }
1697         osst_get_frame_position(STp, aSRpnt);
1698 #if DEBUG
1699         printk(OSST_DEB_MSG "%s:D: Positioning complete, cur_frames %d, pos %d, tape pos %d\n",
1700                         name, STp->cur_frames, STp->first_frame_position, STp->last_frame_position);
1701         printk(OSST_DEB_MSG "%s:D: next logical frame to write: %d\n", name, STp->logical_blk_num);
1702 #endif
1703         if (retval == 0) {
1704                 STp->recover_count++;
1705                 STp->recover_erreg++;
1706         } else
1707                 STp->abort_count++;
1708
1709         STps->rw = rw_state;
1710         return retval;
1711 }
1712
1713 static int osst_space_over_filemarks_backward(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1714                                                                  int mt_op, int mt_count)
1715 {
1716         char  * name = tape_name(STp);
1717         int     cnt;
1718         int     last_mark_ppos = -1;
1719
1720 #if DEBUG
1721         printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_backwards %d %d\n", name, mt_op, mt_count);
1722 #endif
1723         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1724 #if DEBUG
1725                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_bwd\n", name);
1726 #endif
1727                 return -EIO;
1728         }
1729         if (STp->linux_media_version >= 4) {
1730                 /*
1731                  * direct lookup in header filemark list
1732                  */
1733                 cnt = ntohl(STp->buffer->aux->filemark_cnt);
1734                 if (STp->header_ok                         &&
1735                     STp->header_cache != NULL              &&
1736                     (cnt - mt_count)  >= 0                 &&
1737                     (cnt - mt_count)   < OS_FM_TAB_MAX     &&
1738                     (cnt - mt_count)   < STp->filemark_cnt &&
1739                     STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] == STp->buffer->aux->last_mark_ppos)
1740
1741                         last_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt - mt_count]);
1742 #if DEBUG
1743                 if (STp->header_cache == NULL || (cnt - mt_count) < 0 || (cnt - mt_count) >= OS_FM_TAB_MAX)
1744                         printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
1745                                STp->header_cache == NULL?"lack of header cache":"count out of range");
1746                 else
1747                         printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
1748                                 name, cnt,
1749                                 ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1750                                  (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt-1] ==
1751                                          STp->buffer->aux->last_mark_ppos))?"match":"error",
1752                                mt_count, last_mark_ppos);
1753 #endif
1754                 if (last_mark_ppos > 10 && last_mark_ppos < STp->eod_frame_ppos) {
1755                         osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
1756                         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1757 #if DEBUG
1758                                 printk(OSST_DEB_MSG
1759                                         "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1760 #endif
1761                                 return (-EIO);
1762                         }
1763                         if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1764                                 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1765                                                  name, last_mark_ppos);
1766                                 return (-EIO);
1767                         }
1768                         goto found;
1769                 }
1770 #if DEBUG
1771                 printk(OSST_DEB_MSG "%s:D: Reverting to scan filemark backwards\n", name);
1772 #endif
1773         }
1774         cnt = 0;
1775         while (cnt != mt_count) {
1776                 last_mark_ppos = ntohl(STp->buffer->aux->last_mark_ppos);
1777                 if (last_mark_ppos == -1)
1778                         return (-EIO);
1779 #if DEBUG
1780                 printk(OSST_DEB_MSG "%s:D: Positioning to last mark at %d\n", name, last_mark_ppos);
1781 #endif
1782                 osst_position_tape_and_confirm(STp, aSRpnt, last_mark_ppos);
1783                 cnt++;
1784                 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1785 #if DEBUG
1786                         printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1787 #endif
1788                         return (-EIO);
1789                 }
1790                 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1791                         printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1792                                          name, last_mark_ppos);
1793                         return (-EIO);
1794                 }
1795         }
1796 found:
1797         if (mt_op == MTBSFM) {
1798                 STp->frame_seq_number++;
1799                 STp->frame_in_buffer      = 0;
1800                 STp->buffer->buffer_bytes = 0;
1801                 STp->buffer->read_pointer = 0;
1802                 STp->logical_blk_num     += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1803         }
1804         return 0;
1805 }
1806
1807 /*
1808  * ADRL 1.1 compatible "slow" space filemarks fwd version
1809  *
1810  * Just scans for the filemark sequentially.
1811  */
1812 static int osst_space_over_filemarks_forward_slow(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1813                                                                      int mt_op, int mt_count)
1814 {
1815         int     cnt = 0;
1816 #if DEBUG
1817         char  * name = tape_name(STp);
1818
1819         printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_slow %d %d\n", name, mt_op, mt_count);
1820 #endif
1821         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1822 #if DEBUG
1823                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
1824 #endif
1825                 return (-EIO);
1826         }
1827         while (1) {
1828                 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1829 #if DEBUG
1830                         printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n", name);
1831 #endif
1832                         return (-EIO);
1833                 }
1834                 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
1835                         cnt++;
1836                 if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
1837 #if DEBUG
1838                         printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
1839 #endif
1840                         if (STp->first_frame_position > STp->eod_frame_ppos+1) {
1841 #if DEBUG
1842                                 printk(OSST_DEB_MSG "%s:D: EOD position corrected (%d=>%d)\n",
1843                                                 name, STp->eod_frame_ppos, STp->first_frame_position-1);
1844 #endif
1845                                 STp->eod_frame_ppos = STp->first_frame_position-1;
1846                         }
1847                         return (-EIO);
1848                 }
1849                 if (cnt == mt_count)
1850                         break;
1851                 STp->frame_in_buffer = 0;
1852         }
1853         if (mt_op == MTFSF) {
1854                 STp->frame_seq_number++;
1855                 STp->frame_in_buffer      = 0;
1856                 STp->buffer->buffer_bytes = 0;
1857                 STp->buffer->read_pointer = 0;
1858                 STp->logical_blk_num     += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
1859         }
1860         return 0;
1861 }
1862
1863 /*
1864  * Fast linux specific version of OnStream FSF
1865  */
1866 static int osst_space_over_filemarks_forward_fast(struct osst_tape * STp, struct scsi_request ** aSRpnt,
1867                                                                      int mt_op, int mt_count)
1868 {
1869         char  * name = tape_name(STp);
1870         int     cnt  = 0,
1871                 next_mark_ppos = -1;
1872
1873 #if DEBUG
1874         printk(OSST_DEB_MSG "%s:D: Reached space_over_filemarks_forward_fast %d %d\n", name, mt_op, mt_count);
1875 #endif
1876         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1877 #if DEBUG
1878                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks_fwd\n", name);
1879 #endif
1880                 return (-EIO);
1881         }
1882
1883         if (STp->linux_media_version >= 4) {
1884                 /*
1885                  * direct lookup in header filemark list
1886                  */
1887                 cnt = ntohl(STp->buffer->aux->filemark_cnt) - 1;
1888                 if (STp->header_ok                         &&
1889                     STp->header_cache != NULL              &&
1890                     (cnt + mt_count)   < OS_FM_TAB_MAX     &&
1891                     (cnt + mt_count)   < STp->filemark_cnt &&
1892                     ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1893                      (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] == STp->buffer->aux->last_mark_ppos)))
1894
1895                         next_mark_ppos = ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[cnt + mt_count]);
1896 #if DEBUG
1897                 if (STp->header_cache == NULL || (cnt + mt_count) >= OS_FM_TAB_MAX)
1898                         printk(OSST_DEB_MSG "%s:D: Filemark lookup fail due to %s\n", name,
1899                                STp->header_cache == NULL?"lack of header cache":"count out of range");
1900                 else
1901                         printk(OSST_DEB_MSG "%s:D: Filemark lookup: prev mark %d (%s), skip %d to %d\n",
1902                                name, cnt,
1903                                ((cnt == -1 && ntohl(STp->buffer->aux->last_mark_ppos) == -1) ||
1904                                 (STp->header_cache->dat_fm_tab.fm_tab_ent[cnt] ==
1905                                          STp->buffer->aux->last_mark_ppos))?"match":"error",
1906                                mt_count, next_mark_ppos);
1907 #endif
1908                 if (next_mark_ppos <= 10 || next_mark_ppos > STp->eod_frame_ppos) {
1909 #if DEBUG
1910                         printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
1911 #endif
1912                         return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
1913                 } else {
1914                         osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
1915                         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1916 #if DEBUG
1917                                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
1918                                                  name);
1919 #endif
1920                                 return (-EIO);
1921                         }
1922                         if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1923                                 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1924                                                  name, next_mark_ppos);
1925                                 return (-EIO);
1926                         }
1927                         if (ntohl(STp->buffer->aux->filemark_cnt) != cnt + mt_count) {
1928                                 printk(KERN_WARNING "%s:W: Expected to find marker %d at ppos %d, not %d\n",
1929                                                  name, cnt+mt_count, next_mark_ppos,
1930                                                  ntohl(STp->buffer->aux->filemark_cnt));
1931                                 return (-EIO);
1932                         }
1933                 }
1934         } else {
1935                 /*
1936                  * Find nearest (usually previous) marker, then jump from marker to marker
1937                  */
1938                 while (1) {
1939                         if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER)
1940                                 break;
1941                         if (STp->buffer->aux->frame_type == OS_FRAME_TYPE_EOD) {
1942 #if DEBUG
1943                                 printk(OSST_DEB_MSG "%s:D: space_fwd: EOD reached\n", name);
1944 #endif
1945                                 return (-EIO);
1946                         }
1947                         if (ntohl(STp->buffer->aux->filemark_cnt) == 0) {
1948                                 if (STp->first_mark_ppos == -1) {
1949 #if DEBUG
1950                                         printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
1951 #endif
1952                                         return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count);
1953                                 }
1954                                 osst_position_tape_and_confirm(STp, aSRpnt, STp->first_mark_ppos);
1955                                 if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1956 #if DEBUG
1957                                         printk(OSST_DEB_MSG
1958                                                "%s:D: Couldn't get logical blk num in space_filemarks_fwd_fast\n",
1959                                                name);
1960 #endif
1961                                         return (-EIO);
1962                                 }
1963                                 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1964                                         printk(KERN_WARNING "%s:W: Expected to find filemark at %d\n",
1965                                                          name, STp->first_mark_ppos);
1966                                         return (-EIO);
1967                                 }
1968                         } else {
1969                                 if (osst_space_over_filemarks_backward(STp, aSRpnt, MTBSF, 1) < 0)
1970                                         return (-EIO);
1971                                 mt_count++;
1972                         }
1973                 }
1974                 cnt++;
1975                 while (cnt != mt_count) {
1976                         next_mark_ppos = ntohl(STp->buffer->aux->next_mark_ppos);
1977                         if (!next_mark_ppos || next_mark_ppos > STp->eod_frame_ppos) {
1978 #if DEBUG
1979                                 printk(OSST_DEB_MSG "%s:D: Reverting to slow filemark space\n", name);
1980 #endif
1981                                 return osst_space_over_filemarks_forward_slow(STp, aSRpnt, mt_op, mt_count - cnt);
1982                         }
1983 #if DEBUG
1984                         else printk(OSST_DEB_MSG "%s:D: Positioning to next mark at %d\n", name, next_mark_ppos);
1985 #endif
1986                         osst_position_tape_and_confirm(STp, aSRpnt, next_mark_ppos);
1987                         cnt++;
1988                         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
1989 #if DEBUG
1990                                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in space_filemarks\n",
1991                                                  name);
1992 #endif
1993                                 return (-EIO);
1994                         }
1995                         if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_MARKER) {
1996                                 printk(KERN_WARNING "%s:W: Expected to find marker at ppos %d, not found\n",
1997                                                  name, next_mark_ppos);
1998                                 return (-EIO);
1999                         }
2000                 }
2001         }
2002         if (mt_op == MTFSF) {
2003                 STp->frame_seq_number++;
2004                 STp->frame_in_buffer      = 0;
2005                 STp->buffer->buffer_bytes = 0;
2006                 STp->buffer->read_pointer = 0;
2007                 STp->logical_blk_num     += ntohs(STp->buffer->aux->dat.dat_list[0].blk_cnt);
2008         }
2009         return 0;
2010 }
2011
2012 /*
2013  * In debug mode, we want to see as many errors as possible
2014  * to test the error recovery mechanism.
2015  */
2016 #if DEBUG
2017 static void osst_set_retries(struct osst_tape * STp, struct scsi_request ** aSRpnt, int retries)
2018 {
2019         unsigned char           cmd[MAX_COMMAND_SIZE];
2020         struct scsi_request   * SRpnt  = * aSRpnt;
2021         char                  * name   = tape_name(STp);
2022
2023         memset(cmd, 0, MAX_COMMAND_SIZE);
2024         cmd[0] = MODE_SELECT;
2025         cmd[1] = 0x10;
2026         cmd[4] = NUMBER_RETRIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
2027
2028         (STp->buffer)->b_data[0] = cmd[4] - 1;
2029         (STp->buffer)->b_data[1] = 0;                   /* Medium Type - ignoring */
2030         (STp->buffer)->b_data[2] = 0;                   /* Reserved */
2031         (STp->buffer)->b_data[3] = 0;                   /* Block Descriptor Length */
2032         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = NUMBER_RETRIES_PAGE | (1 << 7);
2033         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 2;
2034         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 4;
2035         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = retries;
2036
2037         if (debugging)
2038             printk(OSST_DEB_MSG "%s:D: Setting number of retries on OnStream tape to %d\n", name, retries);
2039
2040         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2041         *aSRpnt = SRpnt;
2042
2043         if ((STp->buffer)->syscall_result)
2044             printk (KERN_ERR "%s:D: Couldn't set retries to %d\n", name, retries);
2045 }
2046 #endif
2047
2048
2049 static int osst_write_filemark(struct osst_tape * STp, struct scsi_request ** aSRpnt)
2050 {
2051         int     result;
2052         int     this_mark_ppos = STp->first_frame_position;
2053         int     this_mark_lbn  = STp->logical_blk_num;
2054 #if DEBUG
2055         char  * name = tape_name(STp);
2056 #endif
2057
2058         if (STp->raw) return 0;
2059
2060         STp->write_type = OS_WRITE_NEW_MARK;
2061 #if DEBUG
2062         printk(OSST_DEB_MSG "%s:D: Writing Filemark %i at fppos %d (fseq %d, lblk %d)\n",
2063                name, STp->filemark_cnt, this_mark_ppos, STp->frame_seq_number, this_mark_lbn);
2064 #endif
2065         STp->dirty = 1;
2066         result  = osst_flush_write_buffer(STp, aSRpnt);
2067         result |= osst_flush_drive_buffer(STp, aSRpnt);
2068         STp->last_mark_ppos = this_mark_ppos;
2069         STp->last_mark_lbn  = this_mark_lbn;
2070         if (STp->header_cache != NULL && STp->filemark_cnt < OS_FM_TAB_MAX)
2071                 STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt] = htonl(this_mark_ppos);
2072         if (STp->filemark_cnt++ == 0)
2073                 STp->first_mark_ppos = this_mark_ppos;
2074         return result;
2075 }
2076
2077 static int osst_write_eod(struct osst_tape * STp, struct scsi_request ** aSRpnt)
2078 {
2079         int     result;
2080 #if DEBUG
2081         char  * name = tape_name(STp);
2082 #endif
2083
2084         if (STp->raw) return 0;
2085
2086         STp->write_type = OS_WRITE_EOD;
2087         STp->eod_frame_ppos = STp->first_frame_position;
2088 #if DEBUG
2089         printk(OSST_DEB_MSG "%s:D: Writing EOD at fppos %d (fseq %d, lblk %d)\n", name,
2090                         STp->eod_frame_ppos, STp->frame_seq_number, STp->logical_blk_num);
2091 #endif
2092         STp->dirty = 1;
2093
2094         result  = osst_flush_write_buffer(STp, aSRpnt);
2095         result |= osst_flush_drive_buffer(STp, aSRpnt);
2096         STp->eod_frame_lfa = --(STp->frame_seq_number);
2097         return result;
2098 }
2099
2100 static int osst_write_filler(struct osst_tape * STp, struct scsi_request ** aSRpnt, int where, int count)
2101 {
2102         char * name = tape_name(STp);
2103
2104 #if DEBUG
2105         printk(OSST_DEB_MSG "%s:D: Reached onstream write filler group %d\n", name, where);
2106 #endif
2107         osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
2108         osst_set_frame_position(STp, aSRpnt, where, 0);
2109         STp->write_type = OS_WRITE_FILLER;
2110         while (count--) {
2111                 memcpy(STp->buffer->b_data, "Filler", 6);
2112                 STp->buffer->buffer_bytes = 6;
2113                 STp->dirty = 1;
2114                 if (osst_flush_write_buffer(STp, aSRpnt)) {
2115                         printk(KERN_INFO "%s:I: Couldn't write filler frame\n", name);
2116                         return (-EIO);
2117                 }
2118         }
2119 #if DEBUG
2120         printk(OSST_DEB_MSG "%s:D: Exiting onstream write filler group\n", name);
2121 #endif
2122         return osst_flush_drive_buffer(STp, aSRpnt);
2123 }
2124
2125 static int __osst_write_header(struct osst_tape * STp, struct scsi_request ** aSRpnt, int where, int count)
2126 {
2127         char * name = tape_name(STp);
2128         int     result;
2129
2130 #if DEBUG
2131         printk(OSST_DEB_MSG "%s:D: Reached onstream write header group %d\n", name, where);
2132 #endif
2133         osst_wait_ready(STp, aSRpnt, 60 * 5, 0);
2134         osst_set_frame_position(STp, aSRpnt, where, 0);
2135         STp->write_type = OS_WRITE_HEADER;
2136         while (count--) {
2137                 osst_copy_to_buffer(STp->buffer, (unsigned char *)STp->header_cache);
2138                 STp->buffer->buffer_bytes = sizeof(os_header_t);
2139                 STp->dirty = 1;
2140                 if (osst_flush_write_buffer(STp, aSRpnt)) {
2141                         printk(KERN_INFO "%s:I: Couldn't write header frame\n", name);
2142                         return (-EIO);
2143                 }
2144         }
2145         result = osst_flush_drive_buffer(STp, aSRpnt);
2146 #if DEBUG
2147         printk(OSST_DEB_MSG "%s:D: Write onstream header group %s\n", name, result?"failed":"done");
2148 #endif
2149         return result;
2150 }
2151
2152 static int osst_write_header(struct osst_tape * STp, struct scsi_request ** aSRpnt, int locate_eod)
2153 {
2154         os_header_t * header;
2155         int           result;
2156         char        * name = tape_name(STp);
2157
2158 #if DEBUG
2159         printk(OSST_DEB_MSG "%s:D: Writing tape header\n", name);
2160 #endif
2161         if (STp->raw) return 0;
2162
2163         if (STp->header_cache == NULL) {
2164                 if ((STp->header_cache = (os_header_t *)vmalloc(sizeof(os_header_t))) == NULL) {
2165                         printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
2166                         return (-ENOMEM);
2167                 }
2168                 memset(STp->header_cache, 0, sizeof(os_header_t));
2169 #if DEBUG
2170                 printk(OSST_DEB_MSG "%s:D: Allocated and cleared memory for header cache\n", name);
2171 #endif
2172         }
2173         if (STp->header_ok) STp->update_frame_cntr++;
2174         else                STp->update_frame_cntr = 0;
2175
2176         header = STp->header_cache;
2177         strcpy(header->ident_str, "ADR_SEQ");
2178         header->major_rev      = 1;
2179         header->minor_rev      = 4;
2180         header->ext_trk_tb_off = htons(17192);
2181         header->pt_par_num     = 1;
2182         header->partition[0].partition_num              = OS_DATA_PARTITION;
2183         header->partition[0].par_desc_ver               = OS_PARTITION_VERSION;
2184         header->partition[0].wrt_pass_cntr              = htons(STp->wrt_pass_cntr);
2185         header->partition[0].first_frame_ppos           = htonl(STp->first_data_ppos);
2186         header->partition[0].last_frame_ppos            = htonl(STp->capacity);
2187         header->partition[0].eod_frame_ppos             = htonl(STp->eod_frame_ppos);
2188         header->cfg_col_width                           = htonl(20);
2189         header->dat_col_width                           = htonl(1500);
2190         header->qfa_col_width                           = htonl(0);
2191         header->ext_track_tb.nr_stream_part             = 1;
2192         header->ext_track_tb.et_ent_sz                  = 32;
2193         header->ext_track_tb.dat_ext_trk_ey.et_part_num = 0;
2194         header->ext_track_tb.dat_ext_trk_ey.fmt         = 1;
2195         header->ext_track_tb.dat_ext_trk_ey.fm_tab_off  = htons(17736);
2196         header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi = 0;
2197         header->ext_track_tb.dat_ext_trk_ey.last_hlb    = htonl(STp->eod_frame_lfa);
2198         header->ext_track_tb.dat_ext_trk_ey.last_pp     = htonl(STp->eod_frame_ppos);
2199         header->dat_fm_tab.fm_part_num                  = 0;
2200         header->dat_fm_tab.fm_tab_ent_sz                = 4;
2201         header->dat_fm_tab.fm_tab_ent_cnt               = htons(STp->filemark_cnt<OS_FM_TAB_MAX?
2202                                                                 STp->filemark_cnt:OS_FM_TAB_MAX);
2203
2204         result  = __osst_write_header(STp, aSRpnt, 0xbae, 5);
2205         if (STp->update_frame_cntr == 0)
2206                     osst_write_filler(STp, aSRpnt, 0xbb3, 5);
2207         result &= __osst_write_header(STp, aSRpnt,     5, 5);
2208
2209         if (locate_eod) {
2210 #if DEBUG
2211                 printk(OSST_DEB_MSG "%s:D: Locating back to eod frame addr %d\n", name, STp->eod_frame_ppos);
2212 #endif
2213                 osst_set_frame_position(STp, aSRpnt, STp->eod_frame_ppos, 0);
2214         }
2215         if (result)
2216                 printk(KERN_ERR "%s:E: Write header failed\n", name);
2217         else {
2218                 memcpy(STp->application_sig, "LIN4", 4);
2219                 STp->linux_media         = 1;
2220                 STp->linux_media_version = 4;
2221                 STp->header_ok           = 1;
2222         }
2223         return result;
2224 }
2225
2226 static int osst_reset_header(struct osst_tape * STp, struct scsi_request ** aSRpnt)
2227 {
2228         if (STp->header_cache != NULL)
2229                 memset(STp->header_cache, 0, sizeof(os_header_t));
2230
2231         STp->logical_blk_num = STp->frame_seq_number = 0;
2232         STp->frame_in_buffer = 0;
2233         STp->eod_frame_ppos = STp->first_data_ppos = 0x0000000A;
2234         STp->filemark_cnt = 0;
2235         STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
2236         return osst_write_header(STp, aSRpnt, 1);
2237 }
2238
2239 static int __osst_analyze_headers(struct osst_tape * STp, struct scsi_request ** aSRpnt, int ppos)
2240 {
2241         char        * name = tape_name(STp);
2242         os_header_t * header;
2243         os_aux_t    * aux;
2244         char          id_string[8];
2245         int           linux_media_version,
2246                       update_frame_cntr;
2247
2248         if (STp->raw)
2249                 return 1;
2250
2251         if (ppos == 5 || ppos == 0xbae || STp->buffer->syscall_result) {
2252                 if (osst_set_frame_position(STp, aSRpnt, ppos, 0))
2253                         printk(KERN_WARNING "%s:W: Couldn't position tape\n", name);
2254                 osst_wait_ready(STp, aSRpnt, 60 * 15, 0);
2255                 if (osst_initiate_read (STp, aSRpnt)) {
2256                         printk(KERN_WARNING "%s:W: Couldn't initiate read\n", name);
2257                         return 0;
2258                 }
2259         }
2260         if (osst_read_frame(STp, aSRpnt, 180)) {
2261 #if DEBUG
2262                 printk(OSST_DEB_MSG "%s:D: Couldn't read header frame\n", name);
2263 #endif
2264                 return 0;
2265         }
2266         header = (os_header_t *) STp->buffer->b_data;   /* warning: only first segment addressable */
2267         aux = STp->buffer->aux;
2268         if (aux->frame_type != OS_FRAME_TYPE_HEADER) {
2269 #if DEBUG
2270                 printk(OSST_DEB_MSG "%s:D: Skipping non-header frame (%d)\n", name, ppos);
2271 #endif
2272                 return 0;
2273         }
2274         if (ntohl(aux->frame_seq_num)              != 0                   ||
2275             ntohl(aux->logical_blk_num)            != 0                   ||
2276                   aux->partition.partition_num     != OS_CONFIG_PARTITION ||
2277             ntohl(aux->partition.first_frame_ppos) != 0                   ||
2278             ntohl(aux->partition.last_frame_ppos)  != 0xbb7               ) {
2279 #if DEBUG
2280                 printk(OSST_DEB_MSG "%s:D: Invalid header frame (%d,%d,%d,%d,%d)\n", name,
2281                                 ntohl(aux->frame_seq_num), ntohl(aux->logical_blk_num),
2282                                 aux->partition.partition_num, ntohl(aux->partition.first_frame_ppos),
2283                                 ntohl(aux->partition.last_frame_ppos));
2284 #endif
2285                 return 0;
2286         }
2287         if (strncmp(header->ident_str, "ADR_SEQ", 7) != 0 &&
2288             strncmp(header->ident_str, "ADR-SEQ", 7) != 0) {
2289                 strlcpy(id_string, header->ident_str, 8);
2290 #if DEBUG
2291                 printk(OSST_DEB_MSG "%s:D: Invalid header identification string %s\n", name, id_string);
2292 #endif
2293                 return 0;
2294         }
2295         update_frame_cntr = ntohl(aux->update_frame_cntr);
2296         if (update_frame_cntr < STp->update_frame_cntr) {
2297 #if DEBUG
2298                 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with update_frame_counter %d<%d\n",
2299                                    name, ppos, update_frame_cntr, STp->update_frame_cntr);
2300 #endif
2301                 return 0;
2302         }
2303         if (header->major_rev != 1 || header->minor_rev != 4 ) {
2304 #if DEBUG
2305                 printk(OSST_DEB_MSG "%s:D: %s revision %d.%d detected (1.4 supported)\n",
2306                                  name, (header->major_rev != 1 || header->minor_rev < 2 ||
2307                                        header->minor_rev  > 4 )? "Invalid" : "Warning:",
2308                                  header->major_rev, header->minor_rev);
2309 #endif
2310                 if (header->major_rev != 1 || header->minor_rev < 2 || header->minor_rev > 4)
2311                         return 0;
2312         }
2313 #if DEBUG
2314         if (header->pt_par_num != 1)
2315                 printk(KERN_INFO "%s:W: %d partitions defined, only one supported\n",
2316                                  name, header->pt_par_num);
2317 #endif
2318         memcpy(id_string, aux->application_sig, 4);
2319         id_string[4] = 0;
2320         if (memcmp(id_string, "LIN", 3) == 0) {
2321                 STp->linux_media = 1;
2322                 linux_media_version = id_string[3] - '0';
2323                 if (linux_media_version != 4)
2324                         printk(KERN_INFO "%s:I: Linux media version %d detected (current 4)\n",
2325                                          name, linux_media_version);
2326         } else {
2327                 printk(KERN_WARNING "%s:W: Non Linux media detected (%s)\n", name, id_string);
2328                 return 0;
2329         }
2330         if (linux_media_version < STp->linux_media_version) {
2331 #if DEBUG
2332                 printk(OSST_DEB_MSG "%s:D: Skipping frame %d with linux_media_version %d\n",
2333                                   name, ppos, linux_media_version);
2334 #endif
2335                 return 0;
2336         }
2337         if (linux_media_version > STp->linux_media_version) {
2338 #if DEBUG
2339                 printk(OSST_DEB_MSG "%s:D: Frame %d sets linux_media_version to %d\n",
2340                                    name, ppos, linux_media_version);
2341 #endif
2342                 memcpy(STp->application_sig, id_string, 5);
2343                 STp->linux_media_version = linux_media_version;
2344                 STp->update_frame_cntr = -1;
2345         }
2346         if (update_frame_cntr > STp->update_frame_cntr) {
2347 #if DEBUG
2348                 printk(OSST_DEB_MSG "%s:D: Frame %d sets update_frame_counter to %d\n",
2349                                    name, ppos, update_frame_cntr);
2350 #endif
2351                 if (STp->header_cache == NULL) {
2352                         if ((STp->header_cache = (os_header_t *)vmalloc(sizeof(os_header_t))) == NULL) {
2353                                 printk(KERN_ERR "%s:E: Failed to allocate header cache\n", name);
2354                                 return 0;
2355                         }
2356 #if DEBUG
2357                         printk(OSST_DEB_MSG "%s:D: Allocated memory for header cache\n", name);
2358 #endif
2359                 }
2360                 osst_copy_from_buffer(STp->buffer, (unsigned char *)STp->header_cache);
2361                 header = STp->header_cache;     /* further accesses from cached (full) copy */
2362
2363                 STp->wrt_pass_cntr     = ntohs(header->partition[0].wrt_pass_cntr);
2364                 STp->first_data_ppos   = ntohl(header->partition[0].first_frame_ppos);
2365                 STp->eod_frame_ppos    = ntohl(header->partition[0].eod_frame_ppos);
2366                 STp->eod_frame_lfa     = ntohl(header->ext_track_tb.dat_ext_trk_ey.last_hlb);
2367                 STp->filemark_cnt      = ntohl(aux->filemark_cnt);
2368                 STp->first_mark_ppos   = ntohl(aux->next_mark_ppos);
2369                 STp->last_mark_ppos    = ntohl(aux->last_mark_ppos);
2370                 STp->last_mark_lbn     = ntohl(aux->last_mark_lbn);
2371                 STp->update_frame_cntr = update_frame_cntr;
2372 #if DEBUG
2373         printk(OSST_DEB_MSG "%s:D: Detected write pass %d, update frame counter %d, filemark counter %d\n",
2374                           name, STp->wrt_pass_cntr, STp->update_frame_cntr, STp->filemark_cnt);
2375         printk(OSST_DEB_MSG "%s:D: first data frame on tape = %d, last = %d, eod frame = %d\n", name,
2376                           STp->first_data_ppos,
2377                           ntohl(header->partition[0].last_frame_ppos),
2378                           ntohl(header->partition[0].eod_frame_ppos));
2379         printk(OSST_DEB_MSG "%s:D: first mark on tape = %d, last = %d, eod frame = %d\n",
2380                           name, STp->first_mark_ppos, STp->last_mark_ppos, STp->eod_frame_ppos);
2381 #endif
2382                 if (header->minor_rev < 4 && STp->linux_media_version == 4) {
2383 #if DEBUG
2384                         printk(OSST_DEB_MSG "%s:D: Moving filemark list to ADR 1.4 location\n", name);
2385 #endif
2386                         memcpy((void *)header->dat_fm_tab.fm_tab_ent,
2387                                (void *)header->old_filemark_list, sizeof(header->dat_fm_tab.fm_tab_ent));
2388                         memset((void *)header->old_filemark_list, 0, sizeof(header->old_filemark_list));
2389                 }
2390                 if (header->minor_rev == 4   &&
2391                     (header->ext_trk_tb_off                          != htons(17192)               ||
2392                      header->partition[0].partition_num              != OS_DATA_PARTITION          ||
2393                      header->partition[0].par_desc_ver               != OS_PARTITION_VERSION       ||
2394                      header->partition[0].last_frame_ppos            != htonl(STp->capacity)       ||
2395                      header->cfg_col_width                           != htonl(20)                  ||
2396                      header->dat_col_width                           != htonl(1500)                ||
2397                      header->qfa_col_width                           != htonl(0)                   ||
2398                      header->ext_track_tb.nr_stream_part             != 1                          ||
2399                      header->ext_track_tb.et_ent_sz                  != 32                         ||
2400                      header->ext_track_tb.dat_ext_trk_ey.et_part_num != OS_DATA_PARTITION          ||
2401                      header->ext_track_tb.dat_ext_trk_ey.fmt         != 1                          ||
2402                      header->ext_track_tb.dat_ext_trk_ey.fm_tab_off  != htons(17736)               ||
2403                      header->ext_track_tb.dat_ext_trk_ey.last_hlb_hi != 0                          ||
2404                      header->ext_track_tb.dat_ext_trk_ey.last_pp     != htonl(STp->eod_frame_ppos) ||
2405                      header->dat_fm_tab.fm_part_num                  != OS_DATA_PARTITION          ||
2406                      header->dat_fm_tab.fm_tab_ent_sz                != 4                          ||
2407                      header->dat_fm_tab.fm_tab_ent_cnt               !=
2408                              htons(STp->filemark_cnt<OS_FM_TAB_MAX?STp->filemark_cnt:OS_FM_TAB_MAX)))
2409                         printk(KERN_WARNING "%s:W: Failed consistency check ADR 1.4 format\n", name);
2410
2411         }
2412
2413         return 1;
2414 }
2415
2416 static int osst_analyze_headers(struct osst_tape * STp, struct scsi_request ** aSRpnt)
2417 {
2418         int     position, ppos;
2419         int     first, last;
2420         int     valid = 0;
2421         char  * name  = tape_name(STp);
2422
2423         position = osst_get_frame_position(STp, aSRpnt);
2424
2425         if (STp->raw) {
2426                 STp->header_ok = STp->linux_media = 1;
2427                 STp->linux_media_version = 0;
2428                 return 1;
2429         }
2430         STp->header_ok = STp->linux_media = STp->linux_media_version = 0;
2431         STp->wrt_pass_cntr = STp->update_frame_cntr = -1;
2432         STp->eod_frame_ppos = STp->first_data_ppos = -1;
2433         STp->first_mark_ppos = STp->last_mark_ppos = STp->last_mark_lbn = -1;
2434 #if DEBUG
2435         printk(OSST_DEB_MSG "%s:D: Reading header\n", name);
2436 #endif
2437
2438         /* optimization for speed - if we are positioned at ppos 10, read second group first  */
2439         /* TODO try the ADR 1.1 locations for the second group if we have no valid one yet... */
2440
2441         first = position==10?0xbae: 5;
2442         last  = position==10?0xbb3:10;
2443
2444         for (ppos = first; ppos < last; ppos++)
2445                 if (__osst_analyze_headers(STp, aSRpnt, ppos))
2446                         valid = 1;
2447
2448         first = position==10? 5:0xbae;
2449         last  = position==10?10:0xbb3;
2450
2451         for (ppos = first; ppos < last; ppos++)
2452                 if (__osst_analyze_headers(STp, aSRpnt, ppos))
2453                         valid = 1;
2454
2455         if (!valid) {
2456                 printk(KERN_ERR "%s:E: Failed to find valid ADRL header, new media?\n", name);
2457                 STp->eod_frame_ppos = STp->first_data_ppos = 0;
2458                 osst_set_frame_position(STp, aSRpnt, 10, 0);
2459                 return 0;
2460         }
2461         if (position <= STp->first_data_ppos) {
2462                 position = STp->first_data_ppos;
2463                 STp->ps[0].drv_file = STp->ps[0].drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
2464         }
2465         osst_set_frame_position(STp, aSRpnt, position, 0);
2466         STp->header_ok = 1;
2467
2468         return 1;
2469 }
2470
2471 static int osst_verify_position(struct osst_tape * STp, struct scsi_request ** aSRpnt)
2472 {
2473         int     frame_position  = STp->first_frame_position;
2474         int     frame_seq_numbr = STp->frame_seq_number;
2475         int     logical_blk_num = STp->logical_blk_num;
2476         int     halfway_frame   = STp->frame_in_buffer;
2477         int     read_pointer    = STp->buffer->read_pointer;
2478         int     prev_mark_ppos  = -1;
2479         int     actual_mark_ppos, i, n;
2480 #if DEBUG
2481         char  * name = tape_name(STp);
2482
2483         printk(OSST_DEB_MSG "%s:D: Verify that the tape is really the one we think before writing\n", name);
2484 #endif
2485         osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
2486         if (osst_get_logical_frame(STp, aSRpnt, -1, 0) < 0) {
2487 #if DEBUG
2488                 printk(OSST_DEB_MSG "%s:D: Couldn't get logical blk num in verify_position\n", name);
2489 #endif
2490                 return (-EIO);
2491         }
2492         if (STp->linux_media_version >= 4) {
2493                 for (i=0; i<STp->filemark_cnt; i++)
2494                         if ((n=ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[i])) < frame_position)
2495                                 prev_mark_ppos = n;
2496         } else
2497                 prev_mark_ppos = frame_position - 1;  /* usually - we don't really know */
2498         actual_mark_ppos = STp->buffer->aux->frame_type == OS_FRAME_TYPE_MARKER ?
2499                                 frame_position - 1 : ntohl(STp->buffer->aux->last_mark_ppos);
2500         if (frame_position  != STp->first_frame_position                   ||
2501             frame_seq_numbr != STp->frame_seq_number + (halfway_frame?0:1) ||
2502             prev_mark_ppos  != actual_mark_ppos                            ) {
2503 #if DEBUG
2504                 printk(OSST_DEB_MSG "%s:D: Block mismatch: fppos %d-%d, fseq %d-%d, mark %d-%d\n", name,
2505                                   STp->first_frame_position, frame_position,
2506                                   STp->frame_seq_number + (halfway_frame?0:1),
2507                                   frame_seq_numbr, actual_mark_ppos, prev_mark_ppos);
2508 #endif
2509                 return (-EIO);
2510         }
2511         if (halfway_frame) {
2512                 /* prepare buffer for append and rewrite on top of original */
2513                 osst_set_frame_position(STp, aSRpnt, frame_position - 1, 0);
2514                 STp->buffer->buffer_bytes  = read_pointer;
2515                 STp->ps[STp->partition].rw = ST_WRITING;
2516                 STp->dirty                 = 1;
2517         }
2518         STp->frame_in_buffer  = halfway_frame;
2519         STp->frame_seq_number = frame_seq_numbr;
2520         STp->logical_blk_num  = logical_blk_num;
2521         return 0;
2522 }
2523
2524 /* Acc. to OnStream, the vers. numbering is the following:
2525  * X.XX for released versions (X=digit),
2526  * XXXY for unreleased versions (Y=letter)
2527  * Ordering 1.05 < 106A < 106B < ...  < 106a < ... < 1.06
2528  * This fn makes monoton numbers out of this scheme ...
2529  */
2530 static unsigned int osst_parse_firmware_rev (const char * str)
2531 {
2532         if (str[1] == '.') {
2533                 return (str[0]-'0')*10000
2534                         +(str[2]-'0')*1000
2535                         +(str[3]-'0')*100;
2536         } else {
2537                 return (str[0]-'0')*10000
2538                         +(str[1]-'0')*1000
2539                         +(str[2]-'0')*100 - 100
2540                         +(str[3]-'@');
2541         }
2542 }
2543
2544 /*
2545  * Configure the OnStream SCII tape drive for default operation
2546  */
2547 static int osst_configure_onstream(struct osst_tape *STp, struct scsi_request ** aSRpnt)
2548 {
2549         unsigned char                  cmd[MAX_COMMAND_SIZE];
2550         char                         * name = tape_name(STp);
2551         struct scsi_request                 * SRpnt = * aSRpnt;
2552         osst_mode_parameter_header_t * header;
2553         osst_block_size_page_t       * bs;
2554         osst_capabilities_page_t     * cp;
2555         osst_tape_paramtr_page_t     * prm;
2556         int                            drive_buffer_size;
2557
2558         if (STp->ready != ST_READY) {
2559 #if DEBUG
2560             printk(OSST_DEB_MSG "%s:D: Not Ready\n", name);
2561 #endif
2562             return (-EIO);
2563         }
2564
2565         if (STp->os_fw_rev < 10600) {
2566             printk(KERN_INFO "%s:I: Old OnStream firmware revision detected (%s),\n", name, STp->device->rev);
2567             printk(KERN_INFO "%s:I: an upgrade to version 1.06 or above is recommended\n", name);
2568         }
2569
2570         /*
2571          * Configure 32.5KB (data+aux) frame size.
2572          * Get the current frame size from the block size mode page
2573          */
2574         memset(cmd, 0, MAX_COMMAND_SIZE);
2575         cmd[0] = MODE_SENSE;
2576         cmd[1] = 8;
2577         cmd[2] = BLOCK_SIZE_PAGE;
2578         cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
2579
2580         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2581         if (SRpnt == NULL) {
2582 #if DEBUG
2583             printk(OSST_DEB_MSG "osst :D: Busy\n");
2584 #endif
2585             return (-EBUSY);
2586         }
2587         *aSRpnt = SRpnt;
2588         if ((STp->buffer)->syscall_result != 0) {
2589             printk (KERN_ERR "%s:E: Can't get tape block size mode page\n", name);
2590             return (-EIO);
2591         }
2592
2593         header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2594         bs = (osst_block_size_page_t *) ((STp->buffer)->b_data + sizeof(osst_mode_parameter_header_t) + header->bdl);
2595
2596 #if DEBUG
2597         printk(OSST_DEB_MSG "%s:D: 32KB play back: %s\n",   name, bs->play32     ? "Yes" : "No");
2598         printk(OSST_DEB_MSG "%s:D: 32.5KB play back: %s\n", name, bs->play32_5   ? "Yes" : "No");
2599         printk(OSST_DEB_MSG "%s:D: 32KB record: %s\n",      name, bs->record32   ? "Yes" : "No");
2600         printk(OSST_DEB_MSG "%s:D: 32.5KB record: %s\n",    name, bs->record32_5 ? "Yes" : "No");
2601 #endif
2602
2603         /*
2604          * Configure default auto columns mode, 32.5KB transfer mode
2605          */
2606         bs->one = 1;
2607         bs->play32 = 0;
2608         bs->play32_5 = 1;
2609         bs->record32 = 0;
2610         bs->record32_5 = 1;
2611
2612         memset(cmd, 0, MAX_COMMAND_SIZE);
2613         cmd[0] = MODE_SELECT;
2614         cmd[1] = 0x10;
2615         cmd[4] = BLOCK_SIZE_PAGE_LENGTH + MODE_HEADER_LENGTH;
2616
2617         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2618         *aSRpnt = SRpnt;
2619         if ((STp->buffer)->syscall_result != 0) {
2620             printk (KERN_ERR "%s:E: Couldn't set tape block size mode page\n", name);
2621             return (-EIO);
2622         }
2623
2624 #if DEBUG
2625         printk(KERN_INFO "%s:D: Drive Block Size changed to 32.5K\n", name);
2626          /*
2627          * In debug mode, we want to see as many errors as possible
2628          * to test the error recovery mechanism.
2629          */
2630         osst_set_retries(STp, aSRpnt, 0);
2631         SRpnt = * aSRpnt;
2632 #endif
2633
2634         /*
2635          * Set vendor name to 'LIN4' for "Linux support version 4".
2636          */
2637
2638         memset(cmd, 0, MAX_COMMAND_SIZE);
2639         cmd[0] = MODE_SELECT;
2640         cmd[1] = 0x10;
2641         cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
2642
2643         header->mode_data_length = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH - 1;
2644         header->medium_type      = 0;   /* Medium Type - ignoring */
2645         header->dsp              = 0;   /* Reserved */
2646         header->bdl              = 0;   /* Block Descriptor Length */
2647
2648         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = VENDOR_IDENT_PAGE | (1 << 7);
2649         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 6;
2650         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 'L';
2651         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 'I';
2652         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 4] = 'N';
2653         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 5] = '4';
2654         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 6] = 0;
2655         (STp->buffer)->b_data[MODE_HEADER_LENGTH + 7] = 0;
2656
2657         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
2658         *aSRpnt = SRpnt;
2659
2660         if ((STp->buffer)->syscall_result != 0) {
2661             printk (KERN_ERR "%s:E: Couldn't set vendor name to %s\n", name,
2662                         (char *) ((STp->buffer)->b_data + MODE_HEADER_LENGTH + 2));
2663             return (-EIO);
2664         }
2665
2666         memset(cmd, 0, MAX_COMMAND_SIZE);
2667         cmd[0] = MODE_SENSE;
2668         cmd[1] = 8;
2669         cmd[2] = CAPABILITIES_PAGE;
2670         cmd[4] = CAPABILITIES_PAGE_LENGTH + MODE_HEADER_LENGTH;
2671
2672         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2673         *aSRpnt = SRpnt;
2674
2675         if ((STp->buffer)->syscall_result != 0) {
2676             printk (KERN_ERR "%s:E: Can't get capabilities page\n", name);
2677             return (-EIO);
2678         }
2679
2680         header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2681         cp     = (osst_capabilities_page_t    *) ((STp->buffer)->b_data +
2682                  sizeof(osst_mode_parameter_header_t) + header->bdl);
2683
2684         drive_buffer_size = ntohs(cp->buffer_size) / 2;
2685
2686         memset(cmd, 0, MAX_COMMAND_SIZE);
2687         cmd[0] = MODE_SENSE;
2688         cmd[1] = 8;
2689         cmd[2] = TAPE_PARAMTR_PAGE;
2690         cmd[4] = TAPE_PARAMTR_PAGE_LENGTH + MODE_HEADER_LENGTH;
2691
2692         SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
2693         *aSRpnt = SRpnt;
2694
2695         if ((STp->buffer)->syscall_result != 0) {
2696             printk (KERN_ERR "%s:E: Can't get tape parameter page\n", name);
2697             return (-EIO);
2698         }
2699
2700         header = (osst_mode_parameter_header_t *) (STp->buffer)->b_data;
2701         prm    = (osst_tape_paramtr_page_t    *) ((STp->buffer)->b_data +
2702                  sizeof(osst_mode_parameter_header_t) + header->bdl);
2703
2704         STp->density  = prm->density;
2705         STp->capacity = ntohs(prm->segtrk) * ntohs(prm->trks);
2706 #if DEBUG
2707         printk(OSST_DEB_MSG "%s:D: Density %d, tape length: %dMB, drive buffer size: %dKB\n",
2708                           name, STp->density, STp->capacity / 32, drive_buffer_size);
2709 #endif
2710
2711         return 0;
2712
2713 }
2714
2715
2716 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
2717    it messes up the block number). */
2718 static int cross_eof(struct osst_tape *STp, struct scsi_request ** aSRpnt, int forward)
2719 {
2720         int     result;
2721         char  * name = tape_name(STp);
2722
2723 #if DEBUG
2724         if (debugging)
2725                 printk(OSST_DEB_MSG "%s:D: Stepping over filemark %s.\n",
2726                                   name, forward ? "forward" : "backward");
2727 #endif
2728
2729         if (forward) {
2730            /* assumes that the filemark is already read by the drive, so this is low cost */
2731            result = osst_space_over_filemarks_forward_slow(STp, aSRpnt, MTFSF, 1);
2732         }
2733         else
2734            /* assumes this is only called if we just read the filemark! */
2735            result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - 1);
2736
2737         if (result < 0)
2738            printk(KERN_WARNING "%s:W: Stepping over filemark %s failed.\n",
2739                                 name, forward ? "forward" : "backward");
2740
2741         return result;
2742 }
2743
2744
2745 /* Get the tape position. */
2746
2747 static int osst_get_frame_position(struct osst_tape *STp, struct scsi_request ** aSRpnt)
2748 {
2749         unsigned char           scmd[MAX_COMMAND_SIZE];
2750         struct scsi_request   * SRpnt;
2751         int                     result = 0;
2752         char                  * name   = tape_name(STp);
2753
2754         /* KG: We want to be able to use it for checking Write Buffer availability
2755          *  and thus don't want to risk to overwrite anything. Exchange buffers ... */
2756         char            mybuf[24];
2757         char          * olddata = STp->buffer->b_data;
2758         int             oldsize = STp->buffer->buffer_size;
2759
2760         if (STp->ready != ST_READY) return (-EIO);
2761
2762         memset (scmd, 0, MAX_COMMAND_SIZE);
2763         scmd[0] = READ_POSITION;
2764
2765         STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
2766         SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
2767                                       STp->timeout, MAX_RETRIES, 1);
2768         if (!SRpnt) {
2769                 STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
2770                 return (-EBUSY);
2771         }
2772         *aSRpnt = SRpnt;
2773
2774         if (STp->buffer->syscall_result)
2775                 result = ((SRpnt->sr_sense_buffer[2] & 0x0f) == 3) ? -EIO : -EINVAL;    /* 3: Write Error */
2776
2777         if (result == -EINVAL)
2778                 printk(KERN_ERR "%s:E: Can't read tape position.\n", name);
2779         else {
2780                 if (result == -EIO) {   /* re-read position - this needs to preserve media errors */
2781                         unsigned char mysense[16];
2782                         memcpy (mysense, SRpnt->sr_sense_buffer, 16);
2783                         memset (scmd, 0, MAX_COMMAND_SIZE);
2784                         scmd[0] = READ_POSITION;
2785                         STp->buffer->b_data = mybuf; STp->buffer->buffer_size = 24;
2786                         SRpnt = osst_do_scsi(SRpnt, STp, scmd, 20, DMA_FROM_DEVICE,
2787                                                     STp->timeout, MAX_RETRIES, 1);
2788 #if DEBUG
2789                         printk(OSST_DEB_MSG "%s:D: Reread position, reason=[%02x:%02x:%02x], result=[%s%02x:%02x:%02x]\n",
2790                                         name, mysense[2], mysense[12], mysense[13], STp->buffer->syscall_result?"":"ok:",
2791                                         SRpnt->sr_sense_buffer[2],SRpnt->sr_sense_buffer[12],SRpnt->sr_sense_buffer[13]);
2792 #endif
2793                         if (!STp->buffer->syscall_result)
2794                                 memcpy (SRpnt->sr_sense_buffer, mysense, 16);
2795                         else
2796                                 printk(KERN_WARNING "%s:W: Double error in get position\n", name);
2797                 }
2798                 STp->first_frame_position = ((STp->buffer)->b_data[4] << 24)
2799                                           + ((STp->buffer)->b_data[5] << 16)
2800                                           + ((STp->buffer)->b_data[6] << 8)
2801                                           +  (STp->buffer)->b_data[7];
2802                 STp->last_frame_position  = ((STp->buffer)->b_data[ 8] << 24)
2803                                           + ((STp->buffer)->b_data[ 9] << 16)
2804                                           + ((STp->buffer)->b_data[10] <<  8)
2805                                           +  (STp->buffer)->b_data[11];
2806                 STp->cur_frames           =  (STp->buffer)->b_data[15];
2807 #if DEBUG
2808                 if (debugging) {
2809                         printk(OSST_DEB_MSG "%s:D: Drive Positions: host %d, tape %d%s, buffer %d\n", name,
2810                                             STp->first_frame_position, STp->last_frame_position,
2811                                             ((STp->buffer)->b_data[0]&0x80)?" (BOP)":
2812                                             ((STp->buffer)->b_data[0]&0x40)?" (EOP)":"",
2813                                             STp->cur_frames);
2814                 }
2815 #endif
2816                 if (STp->cur_frames == 0 && STp->first_frame_position != STp->last_frame_position) {
2817 #if DEBUG
2818                         printk(OSST_DEB_MSG "%s:D: Correcting read position %d, %d, %d\n", name,
2819                                         STp->first_frame_position, STp->last_frame_position, STp->cur_frames);
2820 #endif
2821                         STp->first_frame_position = STp->last_frame_position;
2822                 }
2823         }
2824         STp->buffer->b_data = olddata; STp->buffer->buffer_size = oldsize;
2825
2826         return (result == 0 ? STp->first_frame_position : result);
2827 }
2828
2829
2830 /* Set the tape block */
2831 static int osst_set_frame_position(struct osst_tape *STp, struct scsi_request ** aSRpnt, int ppos, int skip)
2832 {
2833         unsigned char           scmd[MAX_COMMAND_SIZE];
2834         struct scsi_request   * SRpnt;
2835         struct st_partstat    * STps;
2836         int                     result = 0;
2837         int                     pp     = (ppos == 3000 && !skip)? 0 : ppos;
2838         char                  * name   = tape_name(STp);
2839
2840         if (STp->ready != ST_READY) return (-EIO);
2841
2842         STps = &(STp->ps[STp->partition]);
2843
2844         if (ppos < 0 || ppos > STp->capacity) {
2845                 printk(KERN_WARNING "%s:W: Reposition request %d out of range\n", name, ppos);
2846                 pp = ppos = ppos < 0 ? 0 : (STp->capacity - 1);
2847                 result = (-EINVAL);
2848         }
2849
2850         do {
2851 #if DEBUG
2852                 if (debugging)
2853                         printk(OSST_DEB_MSG "%s:D: Setting ppos to %d.\n", name, pp);
2854 #endif
2855                 memset (scmd, 0, MAX_COMMAND_SIZE);
2856                 scmd[0] = SEEK_10;
2857                 scmd[1] = 1;
2858                 scmd[3] = (pp >> 24);
2859                 scmd[4] = (pp >> 16);
2860                 scmd[5] = (pp >> 8);
2861                 scmd[6] =  pp;
2862                 if (skip)
2863                         scmd[9] = 0x80;
2864
2865                 SRpnt = osst_do_scsi(*aSRpnt, STp, scmd, 0, DMA_NONE, STp->long_timeout,
2866                                                                 MAX_RETRIES, 1);
2867                 if (!SRpnt)
2868                         return (-EBUSY);
2869                 *aSRpnt  = SRpnt;
2870
2871                 if ((STp->buffer)->syscall_result != 0) {
2872 #if DEBUG
2873                         printk(OSST_DEB_MSG "%s:D: SEEK command from %d to %d failed.\n",
2874                                         name, STp->first_frame_position, pp);
2875 #endif
2876                         result = (-EIO);
2877                 }
2878                 if (pp != ppos)
2879                         osst_wait_ready(STp, aSRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
2880         } while ((pp != ppos) && (pp = ppos));
2881         STp->first_frame_position = STp->last_frame_position = ppos;
2882         STps->eof = ST_NOEOF;
2883         STps->at_sm = 0;
2884         STps->rw = ST_IDLE;
2885         STp->frame_in_buffer = 0;
2886         return result;
2887 }
2888
2889 static int osst_write_trailer(struct osst_tape *STp, struct scsi_request ** aSRpnt, int leave_at_EOT)
2890 {
2891         struct st_partstat * STps = &(STp->ps[STp->partition]);
2892         int result = 0;
2893
2894         if (STp->write_type != OS_WRITE_NEW_MARK) {
2895                 /* true unless the user wrote the filemark for us */
2896                 result = osst_flush_drive_buffer(STp, aSRpnt);
2897                 if (result < 0) goto out;
2898                 result = osst_write_filemark(STp, aSRpnt);
2899                 if (result < 0) goto out;
2900
2901                 if (STps->drv_file >= 0)
2902                         STps->drv_file++ ;
2903                 STps->drv_block = 0;
2904         }
2905         result = osst_write_eod(STp, aSRpnt);
2906         osst_write_header(STp, aSRpnt, leave_at_EOT);
2907
2908         STps->eof = ST_FM;
2909 out:
2910         return result;
2911 }
2912 \f
2913 /* osst versions of st functions - augmented and stripped to suit OnStream only */
2914
2915 /* Flush the write buffer (never need to write if variable blocksize). */
2916 static int osst_flush_write_buffer(struct osst_tape *STp, struct scsi_request ** aSRpnt)
2917 {
2918         int                     offset, transfer, blks = 0;
2919         int                     result = 0;
2920         unsigned char           cmd[MAX_COMMAND_SIZE];
2921         struct scsi_request   * SRpnt = *aSRpnt;
2922         struct st_partstat    * STps;
2923         char                  * name = tape_name(STp);
2924
2925         if ((STp->buffer)->writing) {
2926                 if (SRpnt == (STp->buffer)->last_SRpnt)
2927 #if DEBUG
2928                         { printk(OSST_DEB_MSG
2929          "%s:D: aSRpnt points to scsi_request that write_behind_check will release -- cleared\n", name);
2930 #endif
2931                         *aSRpnt = SRpnt = NULL;
2932 #if DEBUG
2933                         } else if (SRpnt)
2934                                 printk(OSST_DEB_MSG
2935          "%s:D: aSRpnt does not point to scsi_request that write_behind_check will release -- strange\n", name);
2936 #endif
2937                 osst_write_behind_check(STp);
2938                 if ((STp->buffer)->syscall_result) {
2939 #if DEBUG
2940                         if (debugging)
2941                                 printk(OSST_DEB_MSG "%s:D: Async write error (flush) %x.\n",
2942                                        name, (STp->buffer)->midlevel_result);
2943 #endif
2944                         if ((STp->buffer)->midlevel_result == INT_MAX)
2945                                 return (-ENOSPC);
2946                         return (-EIO);
2947                 }
2948         }
2949
2950         result = 0;
2951         if (STp->dirty == 1) {
2952
2953                 STp->write_count++;
2954                 STps     = &(STp->ps[STp->partition]);
2955                 STps->rw = ST_WRITING;
2956                 offset   = STp->buffer->buffer_bytes;
2957                 blks     = (offset + STp->block_size - 1) / STp->block_size;
2958                 transfer = OS_FRAME_SIZE;
2959
2960                 if (offset < OS_DATA_SIZE)
2961                         osst_zero_buffer_tail(STp->buffer);
2962
2963                 if (STp->poll)
2964                         if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -50, 120))
2965                                 result = osst_recover_wait_frame(STp, aSRpnt, 1);
2966
2967                 memset(cmd, 0, MAX_COMMAND_SIZE);
2968                 cmd[0] = WRITE_6;
2969                 cmd[1] = 1;
2970                 cmd[4] = 1;
2971
2972                 switch  (STp->write_type) {
2973                    case OS_WRITE_DATA:
2974 #if DEBUG
2975                         if (debugging)
2976                                 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n",
2977                                         name, blks, STp->frame_seq_number,
2978                                         STp->logical_blk_num - blks, STp->logical_blk_num - 1);
2979 #endif
2980                         osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
2981                                       STp->logical_blk_num - blks, STp->block_size, blks);
2982                         break;
2983                    case OS_WRITE_EOD:
2984                         osst_init_aux(STp, OS_FRAME_TYPE_EOD, STp->frame_seq_number++,
2985                                       STp->logical_blk_num, 0, 0);
2986                         break;
2987                    case OS_WRITE_NEW_MARK:
2988                         osst_init_aux(STp, OS_FRAME_TYPE_MARKER, STp->frame_seq_number++,
2989                                       STp->logical_blk_num++, 0, blks=1);
2990                         break;
2991                    case OS_WRITE_HEADER:
2992                         osst_init_aux(STp, OS_FRAME_TYPE_HEADER, 0, 0, 0, blks=0);
2993                         break;
2994                 default: /* probably FILLER */
2995                         osst_init_aux(STp, OS_FRAME_TYPE_FILL, 0, 0, 0, 0);
2996                 }
2997 #if DEBUG
2998                 if (debugging)
2999                         printk(OSST_DEB_MSG "%s:D: Flushing %d bytes, Transfering %d bytes in %d lblocks.\n",
3000                                                  name, offset, transfer, blks);
3001 #endif
3002
3003                 SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
3004                                               STp->timeout, MAX_RETRIES, 1);
3005                 *aSRpnt = SRpnt;
3006                 if (!SRpnt)
3007                         return (-EBUSY);
3008
3009                 if ((STp->buffer)->syscall_result != 0) {
3010 #if DEBUG
3011                         printk(OSST_DEB_MSG
3012                                 "%s:D: write sense [0]=0x%02x [2]=%02x [12]=%02x [13]=%02x\n",
3013                                 name, SRpnt->sr_sense_buffer[0], SRpnt->sr_sense_buffer[2],
3014                                 SRpnt->sr_sense_buffer[12], SRpnt->sr_sense_buffer[13]);
3015 #endif
3016                         if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
3017                             (SRpnt->sr_sense_buffer[2] & 0x40) && /* FIXME - SC-30 drive doesn't assert EOM bit */
3018                             (SRpnt->sr_sense_buffer[2] & 0x0f) == NO_SENSE) {
3019                                 STp->dirty = 0;
3020                                 (STp->buffer)->buffer_bytes = 0;
3021                                 result = (-ENOSPC);
3022                         }
3023                         else {
3024                                 if (osst_write_error_recovery(STp, aSRpnt, 1)) {
3025                                         printk(KERN_ERR "%s:E: Error on flush write.\n", name);
3026                                         result = (-EIO);
3027                                 }
3028                         }
3029                         STps->drv_block = (-1);         /* FIXME - even if write recovery succeeds? */
3030                 }
3031                 else {
3032                         STp->first_frame_position++;
3033                         STp->dirty = 0;
3034                         (STp->buffer)->buffer_bytes = 0;
3035                 }
3036         }
3037 #if DEBUG
3038         printk(OSST_DEB_MSG "%s:D: Exit flush write buffer with code %d\n", name, result);
3039 #endif
3040         return result;
3041 }
3042
3043
3044 /* Flush the tape buffer. The tape will be positioned correctly unless
3045    seek_next is true. */
3046 static int osst_flush_buffer(struct osst_tape * STp, struct scsi_request ** aSRpnt, int seek_next)
3047 {
3048         struct st_partstat * STps;
3049         int    backspace = 0, result = 0;
3050 #if DEBUG
3051         char * name = tape_name(STp);
3052 #endif
3053
3054         /*
3055          * If there was a bus reset, block further access
3056          * to this device.
3057          */
3058         if( STp->pos_unknown)
3059                 return (-EIO);
3060
3061         if (STp->ready != ST_READY)
3062                 return 0;
3063
3064         STps = &(STp->ps[STp->partition]);
3065         if (STps->rw == ST_WRITING || STp->dirty) {     /* Writing */
3066                 STp->write_type = OS_WRITE_DATA;
3067                 return osst_flush_write_buffer(STp, aSRpnt);
3068         }
3069         if (STp->block_size == 0)
3070                 return 0;
3071
3072 #if DEBUG
3073         printk(OSST_DEB_MSG "%s:D: Reached flush (read) buffer\n", name);
3074 #endif
3075
3076         if (!STp->can_bsr) {
3077                 backspace = ((STp->buffer)->buffer_bytes + (STp->buffer)->read_pointer) / STp->block_size -
3078                             ((STp->buffer)->read_pointer + STp->block_size - 1        ) / STp->block_size ;
3079                 (STp->buffer)->buffer_bytes = 0;
3080                 (STp->buffer)->read_pointer = 0;
3081                 STp->frame_in_buffer = 0;               /* FIXME is this relevant w. OSST? */
3082         }
3083
3084         if (!seek_next) {
3085                 if (STps->eof == ST_FM_HIT) {
3086                         result = cross_eof(STp, aSRpnt, 0); /* Back over the EOF hit */
3087                         if (!result)
3088                                 STps->eof = ST_NOEOF;
3089                         else {
3090                                 if (STps->drv_file >= 0)
3091                                         STps->drv_file++;
3092                                 STps->drv_block = 0;
3093                         }
3094                 }
3095                 if (!result && backspace > 0)   /* TODO -- design and run a test case for this */
3096                         result = osst_seek_logical_blk(STp, aSRpnt, STp->logical_blk_num - backspace);
3097         }
3098         else if (STps->eof == ST_FM_HIT) {
3099                 if (STps->drv_file >= 0)
3100                         STps->drv_file++;
3101                 STps->drv_block = 0;
3102                 STps->eof = ST_NOEOF;
3103         }
3104
3105         return result;
3106 }
3107
3108 static int osst_write_frame(struct osst_tape * STp, struct scsi_request ** aSRpnt, int synchronous)
3109 {
3110         unsigned char           cmd[MAX_COMMAND_SIZE];
3111         struct scsi_request   * SRpnt;
3112         int                     blks;
3113 #if DEBUG
3114         char                  * name = tape_name(STp);
3115 #endif
3116
3117         if ((!STp-> raw) && (STp->first_frame_position == 0xbae)) { /* _must_ preserve buffer! */
3118 #if DEBUG
3119                 printk(OSST_DEB_MSG "%s:D: Reaching config partition.\n", name);
3120 #endif
3121                 if (osst_flush_drive_buffer(STp, aSRpnt) < 0) {
3122                         return (-EIO);
3123                 }
3124                 /* error recovery may have bumped us past the header partition */
3125                 if (osst_get_frame_position(STp, aSRpnt) < 0xbb8) {
3126 #if DEBUG
3127                         printk(OSST_DEB_MSG "%s:D: Skipping over config partition.\n", name);
3128 #endif
3129                 osst_position_tape_and_confirm(STp, aSRpnt, 0xbb8);
3130                 }
3131         }
3132
3133         if (STp->poll)
3134                 if (osst_wait_frame (STp, aSRpnt, STp->first_frame_position, -48, 120))
3135                         if (osst_recover_wait_frame(STp, aSRpnt, 1))
3136                                 return (-EIO);
3137
3138 //      osst_build_stats(STp, &SRpnt);
3139
3140         STp->ps[STp->partition].rw = ST_WRITING;
3141         STp->write_type            = OS_WRITE_DATA;
3142
3143         memset(cmd, 0, MAX_COMMAND_SIZE);
3144         cmd[0]   = WRITE_6;
3145         cmd[1]   = 1;
3146         cmd[4]   = 1;                                           /* one frame at a time... */
3147         blks     = STp->buffer->buffer_bytes / STp->block_size;
3148 #if DEBUG
3149         if (debugging)
3150                 printk(OSST_DEB_MSG "%s:D: Writing %d blocks to frame %d, lblks %d-%d\n", name, blks,
3151                         STp->frame_seq_number, STp->logical_blk_num - blks, STp->logical_blk_num - 1);
3152 #endif
3153         osst_init_aux(STp, OS_FRAME_TYPE_DATA, STp->frame_seq_number++,
3154                       STp->logical_blk_num - blks, STp->block_size, blks);
3155
3156 #if DEBUG
3157         if (!synchronous)
3158                 STp->write_pending = 1;
3159 #endif
3160         SRpnt = osst_do_scsi(*aSRpnt, STp, cmd, OS_FRAME_SIZE, DMA_TO_DEVICE, STp->timeout,
3161                                                                         MAX_RETRIES, synchronous);
3162         if (!SRpnt)
3163                 return (-EBUSY);
3164         *aSRpnt = SRpnt;
3165
3166         if (synchronous) {
3167                 if (STp->buffer->syscall_result != 0) {
3168 #if DEBUG
3169                         if (debugging)
3170                                 printk(OSST_DEB_MSG "%s:D: Error on write:\n", name);
3171 #endif
3172                         if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
3173                             (SRpnt->sr_sense_buffer[2] & 0x40)) {
3174                                 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == VOLUME_OVERFLOW)
3175                                         return (-ENOSPC);
3176                         }
3177                         else {
3178                                 if (osst_write_error_recovery(STp, aSRpnt, 1))
3179                                         return (-EIO);
3180                         }
3181                 }
3182                 else
3183                         STp->first_frame_position++;
3184         }
3185
3186         STp->write_count++;
3187
3188         return 0;
3189 }
3190
3191 /* Lock or unlock the drive door. Don't use when struct scsi_request allocated. */
3192 static int do_door_lock(struct osst_tape * STp, int do_lock)
3193 {
3194         int retval, cmd;
3195
3196         cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
3197 #if DEBUG
3198         printk(OSST_DEB_MSG "%s:D: %socking drive door.\n", tape_name(STp), do_lock ? "L" : "Unl");
3199 #endif
3200         retval = scsi_ioctl(STp->device, cmd, NULL);
3201         if (!retval) {
3202                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
3203         }
3204         else {
3205                 STp->door_locked = ST_LOCK_FAILS;
3206         }
3207         return retval;
3208 }
3209
3210 /* Set the internal state after reset */
3211 static void reset_state(struct osst_tape *STp)
3212 {
3213         int i;
3214         struct st_partstat *STps;
3215
3216         STp->pos_unknown = 0;
3217         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3218                 STps = &(STp->ps[i]);
3219                 STps->rw = ST_IDLE;
3220                 STps->eof = ST_NOEOF;
3221                 STps->at_sm = 0;
3222                 STps->last_block_valid = 0;
3223                 STps->drv_block = -1;
3224                 STps->drv_file = -1;
3225         }
3226 }
3227
3228 \f
3229 /* Entry points to osst */
3230
3231 /* Write command */
3232 static ssize_t osst_write(struct file * filp, const char __user * buf, size_t count, loff_t *ppos)
3233 {
3234         ssize_t               total, retval = 0;
3235         ssize_t               i, do_count, blks, transfer;
3236         int                   write_threshold;
3237         int                   doing_write = 0;
3238         const char   __user * b_point;
3239         struct scsi_request * SRpnt = NULL;
3240         struct st_modedef   * STm;
3241         struct st_partstat  * STps;
3242         struct osst_tape    * STp  = filp->private_data;
3243         char                * name = tape_name(STp);
3244
3245
3246         if (down_interruptible(&STp->lock))
3247                 return (-ERESTARTSYS);
3248
3249         /*
3250          * If we are in the middle of error recovery, don't let anyone
3251          * else try and use this device.  Also, if error recovery fails, it
3252          * may try and take the device offline, in which case all further
3253          * access to the device is prohibited.
3254          */
3255         if( !scsi_block_when_processing_errors(STp->device) ) {
3256                 retval = (-ENXIO);
3257                 goto out;
3258         }
3259
3260         if (STp->ready != ST_READY) {
3261                 if (STp->ready == ST_NO_TAPE)
3262                         retval = (-ENOMEDIUM);
3263                 else
3264                         retval = (-EIO);
3265                 goto out;
3266         }
3267         STm = &(STp->modes[STp->current_mode]);
3268         if (!STm->defined) {
3269                 retval = (-ENXIO);
3270                 goto out;
3271         }
3272         if (count == 0)
3273                 goto out;
3274
3275         /*
3276          * If there was a bus reset, block further access
3277          * to this device.
3278          */
3279         if (STp->pos_unknown) {
3280                 retval = (-EIO);
3281                 goto out;
3282         }
3283
3284 #if DEBUG
3285         if (!STp->in_use) {
3286                 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
3287                 retval = (-EIO);
3288                 goto out;
3289         }
3290 #endif
3291
3292         if (STp->write_prot) {
3293                 retval = (-EACCES);
3294                 goto out;
3295         }
3296
3297         /* Write must be integral number of blocks */
3298         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
3299                 printk(KERN_ERR "%s:E: Write (%Zd bytes) not multiple of tape block size (%d%c).\n",
3300                                        name, count, STp->block_size<1024?
3301                                        STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
3302                 retval = (-EINVAL);
3303                 goto out;
3304         }
3305
3306         if (STp->first_frame_position >= STp->capacity - OSST_EOM_RESERVE) {
3307                 printk(KERN_ERR "%s:E: Write truncated at EOM early warning (frame %d).\n",
3308                                        name, STp->first_frame_position);
3309                 retval = (-ENOSPC);
3310                 goto out;
3311         }
3312
3313         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
3314                 STp->door_locked = ST_LOCKED_AUTO;
3315
3316         STps = &(STp->ps[STp->partition]);
3317
3318         if (STps->rw == ST_READING) {
3319 #if DEBUG
3320                 printk(OSST_DEB_MSG "%s:D: Switching from read to write at file %d, block %d\n", name,
3321                                         STps->drv_file, STps->drv_block);
3322 #endif
3323                 retval = osst_flush_buffer(STp, &SRpnt, 0);
3324                 if (retval)
3325                         goto out;
3326                 STps->rw = ST_IDLE;
3327         }
3328         if (STps->rw != ST_WRITING) {
3329                 /* Are we totally rewriting this tape? */
3330                 if (!STp->header_ok ||
3331                     (STp->first_frame_position == STp->first_data_ppos && STps->drv_block < 0) ||
3332                     (STps->drv_file == 0 && STps->drv_block == 0)) {
3333                         STp->wrt_pass_cntr++;
3334 #if DEBUG
3335                         printk(OSST_DEB_MSG "%s:D: Allocating next write pass counter: %d\n",
3336                                                   name, STp->wrt_pass_cntr);
3337 #endif
3338                         osst_reset_header(STp, &SRpnt);
3339                         STps->drv_file = STps->drv_block = 0;
3340                 }
3341                 /* Do we know where we'll be writing on the tape? */
3342                 else {
3343                         if ((STp->fast_open && osst_verify_position(STp, &SRpnt)) ||
3344                                         STps->drv_file < 0 || STps->drv_block < 0) {
3345                                 if (STp->first_frame_position == STp->eod_frame_ppos) { /* at EOD */
3346                                         STps->drv_file = STp->filemark_cnt;
3347                                         STps->drv_block = 0;
3348                                 }
3349                                 else {
3350                                         /* We have no idea where the tape is positioned - give up */
3351 #if DEBUG
3352                                         printk(OSST_DEB_MSG
3353                                                 "%s:D: Cannot write at indeterminate position.\n", name);
3354 #endif
3355                                         retval = (-EIO);
3356                                         goto out;
3357                                 }
3358                         }
3359                         if ((STps->drv_file + STps->drv_block) > 0 && STps->drv_file < STp->filemark_cnt) {
3360                                 STp->filemark_cnt = STps->drv_file;
3361                                 STp->last_mark_ppos =
3362                                         ntohl(STp->header_cache->dat_fm_tab.fm_tab_ent[STp->filemark_cnt-1]);
3363                                 printk(KERN_WARNING
3364                                         "%s:W: Overwriting file %d with old write pass counter %d\n",
3365                                                 name, STps->drv_file, STp->wrt_pass_cntr);
3366                                 printk(KERN_WARNING
3367                                         "%s:W: may lead to stale data being accepted on reading back!\n",
3368                                                 name);
3369 #if DEBUG
3370                                 printk(OSST_DEB_MSG
3371                                   "%s:D: resetting filemark count to %d and last mark ppos,lbn to %d,%d\n",
3372                                         name, STp->filemark_cnt, STp->last_mark_ppos, STp->last_mark_lbn);
3373 #endif
3374                         }
3375                 }
3376                 STp->fast_open = 0;
3377         }
3378         if (!STp->header_ok) {
3379 #if DEBUG
3380                 printk(OSST_DEB_MSG "%s:D: Write cannot proceed without valid headers\n", name);
3381 #endif
3382                 retval = (-EIO);
3383                 goto out;
3384         }
3385
3386         if ((STp->buffer)->writing) {
3387 if (SRpnt) printk(KERN_ERR "%s:A: Not supposed to have SRpnt at line %d\n", name, __LINE__);
3388                 osst_write_behind_check(STp);
3389                 if ((STp->buffer)->syscall_result) {
3390 #if DEBUG
3391                 if (debugging)
3392                         printk(OSST_DEB_MSG "%s:D: Async write error (write) %x.\n", name,
3393                                                  (STp->buffer)->midlevel_result);
3394 #endif
3395                 if ((STp->buffer)->midlevel_result == INT_MAX)
3396                         STps->eof = ST_EOM_OK;
3397                 else
3398                         STps->eof = ST_EOM_ERROR;
3399                 }
3400         }
3401         if (STps->eof == ST_EOM_OK) {
3402                 retval = (-ENOSPC);
3403                 goto out;
3404         }
3405         else if (STps->eof == ST_EOM_ERROR) {
3406                 retval = (-EIO);
3407                 goto out;
3408         }
3409
3410         /* Check the buffer readability in cases where copy_user might catch
3411                  the problems after some tape movement. */
3412         if ((copy_from_user(&i, buf, 1) != 0 ||
3413              copy_from_user(&i, buf + count - 1, 1) != 0)) {
3414                 retval = (-EFAULT);
3415                 goto out;
3416         }
3417
3418         if (!STm->do_buffer_writes) {
3419                 write_threshold = 1;
3420         }
3421         else
3422                 write_threshold = (STp->buffer)->buffer_blocks * STp->block_size;
3423         if (!STm->do_async_writes)
3424                 write_threshold--;
3425
3426         total = count;
3427 #if DEBUG
3428         if (debugging)
3429                 printk(OSST_DEB_MSG "%s:D: Writing %d bytes to file %d block %d lblk %d fseq %d fppos %d\n",
3430                                 name, count, STps->drv_file, STps->drv_block,
3431                                 STp->logical_blk_num, STp->frame_seq_number, STp->first_frame_position);
3432 #endif
3433         b_point = buf;
3434         while ((STp->buffer)->buffer_bytes + count > write_threshold)
3435         {
3436                 doing_write = 1;
3437                 do_count = (STp->buffer)->buffer_blocks * STp->block_size -
3438                            (STp->buffer)->buffer_bytes;
3439                 if (do_count > count)
3440                         do_count = count;
3441
3442                 i = append_to_buffer(b_point, STp->buffer, do_count);
3443                 if (i) {
3444                         retval = i;
3445                         goto out;
3446                 }
3447
3448                 blks = do_count / STp->block_size;
3449                 STp->logical_blk_num += blks;  /* logical_blk_num is incremented as data is moved from user */
3450
3451                 i = osst_write_frame(STp, &SRpnt, 1);
3452
3453                 if (i == (-ENOSPC)) {
3454                         transfer = STp->buffer->writing;        /* FIXME -- check this logic */
3455                         if (transfer <= do_count) {
3456                                 filp->f_pos += do_count - transfer;
3457                                 count -= do_count - transfer;
3458                                 if (STps->drv_block >= 0) {
3459                                         STps->drv_block += (do_count - transfer) / STp->block_size;
3460                                 }
3461                                 STps->eof = ST_EOM_OK;
3462                                 retval = (-ENOSPC);             /* EOM within current request */
3463 #if DEBUG
3464                                 if (debugging)
3465                                       printk(OSST_DEB_MSG "%s:D: EOM with %d bytes unwritten.\n",
3466                                                              name, transfer);
3467 #endif
3468                         }
3469                         else {
3470                                 STps->eof = ST_EOM_ERROR;
3471                                 STps->drv_block = (-1);         /* Too cautious? */
3472                                 retval = (-EIO);                /* EOM for old data */
3473 #if DEBUG
3474                                 if (debugging)
3475                                       printk(OSST_DEB_MSG "%s:D: EOM with lost data.\n", name);
3476 #endif
3477                         }
3478                 }
3479                 else
3480                         retval = i;
3481
3482                 if (retval < 0) {
3483                         if (SRpnt != NULL) {
3484                                 scsi_release_request(SRpnt);
3485                                 SRpnt = NULL;
3486                         }
3487                         STp->buffer->buffer_bytes = 0;
3488                         STp->dirty = 0;
3489                         if (count < total)
3490                                 retval = total - count;
3491                         goto out;
3492                 }
3493
3494                 filp->f_pos += do_count;
3495                 b_point += do_count;
3496                 count -= do_count;
3497                 if (STps->drv_block >= 0) {
3498                         STps->drv_block += blks;
3499                 }
3500                 STp->buffer->buffer_bytes = 0;
3501                 STp->dirty = 0;
3502         }  /* end while write threshold exceeded */
3503
3504         if (count != 0) {
3505                 STp->dirty = 1;
3506                 i = append_to_buffer(b_point, STp->buffer, count);
3507                 if (i) {
3508                         retval = i;
3509                         goto out;
3510                 }
3511                 blks = count / STp->block_size;
3512                 STp->logical_blk_num += blks;
3513                 if (STps->drv_block >= 0) {
3514                         STps->drv_block += blks;
3515                 }
3516                 filp->f_pos += count;
3517                 count = 0;
3518         }
3519
3520         if (doing_write && (STp->buffer)->syscall_result != 0) {
3521                 retval = (STp->buffer)->syscall_result;
3522                 goto out;
3523         }
3524
3525         if (STm->do_async_writes && ((STp->buffer)->buffer_bytes >= STp->write_threshold)) {
3526                 /* Schedule an asynchronous write */
3527                 (STp->buffer)->writing = ((STp->buffer)->buffer_bytes /
3528                                            STp->block_size) * STp->block_size;
3529                 STp->dirty = !((STp->buffer)->writing ==
3530                                           (STp->buffer)->buffer_bytes);
3531
3532                 i = osst_write_frame(STp, &SRpnt, 0);
3533                 if (i < 0) {
3534                         retval = (-EIO);
3535                         goto out;
3536                 }
3537                 SRpnt = NULL;                   /* Prevent releasing this request! */
3538         }
3539         STps->at_sm &= (total == 0);
3540         if (total > 0)
3541                 STps->eof = ST_NOEOF;
3542
3543         retval = total;
3544
3545 out:
3546         if (SRpnt != NULL) scsi_release_request(SRpnt);
3547
3548         up(&STp->lock);
3549
3550         return retval;
3551 }
3552
3553
3554 /* Read command */
3555 static ssize_t osst_read(struct file * filp, char __user * buf, size_t count, loff_t *ppos)
3556 {
3557         ssize_t               total, retval = 0;
3558         ssize_t               i, transfer;
3559         int                   special;
3560         struct st_modedef   * STm;
3561         struct st_partstat  * STps;
3562         struct scsi_request * SRpnt = NULL;
3563         struct osst_tape    * STp   = filp->private_data;
3564         char                * name  = tape_name(STp);
3565
3566
3567         if (down_interruptible(&STp->lock))
3568                 return (-ERESTARTSYS);
3569
3570         /*
3571          * If we are in the middle of error recovery, don't let anyone
3572          * else try and use this device.  Also, if error recovery fails, it
3573          * may try and take the device offline, in which case all further
3574          * access to the device is prohibited.
3575          */
3576         if( !scsi_block_when_processing_errors(STp->device) ) {
3577                 retval = (-ENXIO);
3578                 goto out;
3579         }
3580
3581         if (STp->ready != ST_READY) {
3582                 if (STp->ready == ST_NO_TAPE)
3583                         retval = (-ENOMEDIUM);
3584                 else
3585                         retval = (-EIO);
3586                 goto out;
3587         }
3588         STm = &(STp->modes[STp->current_mode]);
3589         if (!STm->defined) {
3590                 retval = (-ENXIO);
3591                 goto out;
3592         }
3593 #if DEBUG
3594         if (!STp->in_use) {
3595                 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
3596                 retval = (-EIO);
3597                 goto out;
3598         }
3599 #endif
3600         /* Must have initialized medium */
3601         if (!STp->header_ok) {
3602                 retval = (-EIO);
3603                 goto out;
3604         }
3605
3606         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED && !do_door_lock(STp, 1))
3607                 STp->door_locked = ST_LOCKED_AUTO;
3608
3609         STps = &(STp->ps[STp->partition]);
3610         if (STps->rw == ST_WRITING) {
3611                 retval = osst_flush_buffer(STp, &SRpnt, 0);
3612                 if (retval)
3613                         goto out;
3614                 STps->rw = ST_IDLE;
3615                 /* FIXME -- this may leave the tape without EOD and up2date headers */
3616         }
3617
3618         if ((count % STp->block_size) != 0) {
3619                 printk(KERN_WARNING
3620                     "%s:W: Read (%Zd bytes) not multiple of tape block size (%d%c).\n", name, count,
3621                     STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k');
3622         }
3623
3624 #if DEBUG
3625         if (debugging && STps->eof != ST_NOEOF)
3626                 printk(OSST_DEB_MSG "%s:D: EOF/EOM flag up (%d). Bytes %d\n", name,
3627                                      STps->eof, (STp->buffer)->buffer_bytes);
3628 #endif
3629         if ((STp->buffer)->buffer_bytes == 0 &&
3630              STps->eof >= ST_EOD_1) {
3631                 if (STps->eof < ST_EOD) {
3632                         STps->eof += 1;
3633                         retval = 0;
3634                         goto out;
3635                 }
3636                 retval = (-EIO);  /* EOM or Blank Check */
3637                 goto out;
3638         }
3639
3640         /* Check the buffer writability before any tape movement. Don't alter
3641                  buffer data. */
3642         if (copy_from_user(&i, buf, 1)             != 0 ||
3643             copy_to_user  (buf, &i, 1)             != 0 ||
3644             copy_from_user(&i, buf + count - 1, 1) != 0 ||
3645             copy_to_user  (buf + count - 1, &i, 1) != 0) {
3646                 retval = (-EFAULT);
3647                 goto out;
3648         }
3649
3650         /* Loop until enough data in buffer or a special condition found */
3651         for (total = 0, special = 0; total < count - STp->block_size + 1 && !special; ) {
3652
3653                 /* Get new data if the buffer is empty */
3654                 if ((STp->buffer)->buffer_bytes == 0) {
3655                         if (STps->eof == ST_FM_HIT)
3656                                 break;
3657                         special = osst_get_logical_frame(STp, &SRpnt, STp->frame_seq_number, 0);
3658                         if (special < 0) {                      /* No need to continue read */
3659                                 STp->frame_in_buffer = 0;
3660                                 retval = special;
3661                                 goto out;
3662                         }
3663                 }
3664
3665                 /* Move the data from driver buffer to user buffer */
3666                 if ((STp->buffer)->buffer_bytes > 0) {
3667 #if DEBUG
3668                         if (debugging && STps->eof != ST_NOEOF)
3669                             printk(OSST_DEB_MSG "%s:D: EOF up (%d). Left %d, needed %d.\n", name,
3670                                                  STps->eof, (STp->buffer)->buffer_bytes, count - total);
3671 #endif
3672                         /* force multiple of block size, note block_size may have been adjusted */
3673                         transfer = (((STp->buffer)->buffer_bytes < count - total ?
3674                                      (STp->buffer)->buffer_bytes : count - total)/
3675                                         STp->block_size) * STp->block_size;
3676
3677                         if (transfer == 0) {
3678                                 printk(KERN_WARNING
3679                                   "%s:W: Nothing can be transfered, requested %Zd, tape block size (%d%c).\n",
3680                                         name, count, STp->block_size < 1024?
3681                                         STp->block_size:STp->block_size/1024,
3682                                         STp->block_size<1024?'b':'k');
3683                                 break;
3684                         }
3685                         i = from_buffer(STp->buffer, buf, transfer);
3686                         if (i)  {
3687                                 retval = i;
3688                                 goto out;
3689                         }
3690                         STp->logical_blk_num += transfer / STp->block_size;
3691                         STps->drv_block      += transfer / STp->block_size;
3692                         filp->f_pos          += transfer;
3693                         buf                  += transfer;
3694                         total                += transfer;
3695                 }
3696
3697                 if ((STp->buffer)->buffer_bytes == 0) {
3698 #if DEBUG
3699                         if (debugging)
3700                                 printk(OSST_DEB_MSG "%s:D: Finished with frame %d\n",
3701                                                 name, STp->frame_seq_number);
3702 #endif
3703                         STp->frame_in_buffer = 0;
3704                         STp->frame_seq_number++;              /* frame to look for next time */
3705                 }
3706         } /* for (total = 0, special = 0; total < count && !special; ) */
3707
3708         /* Change the eof state if no data from tape or buffer */
3709         if (total == 0) {
3710                 if (STps->eof == ST_FM_HIT) {
3711                         STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD_2:ST_FM;
3712                         STps->drv_block = 0;
3713                         if (STps->drv_file >= 0)
3714                                 STps->drv_file++;
3715                 }
3716                 else if (STps->eof == ST_EOD_1) {
3717                         STps->eof = ST_EOD_2;
3718                         if (STps->drv_block > 0 && STps->drv_file >= 0)
3719                                 STps->drv_file++;
3720                         STps->drv_block = 0;
3721                 }
3722                 else if (STps->eof == ST_EOD_2)
3723                         STps->eof = ST_EOD;
3724         }
3725         else if (STps->eof == ST_FM)
3726                 STps->eof = ST_NOEOF;
3727
3728         retval = total;
3729
3730 out:
3731         if (SRpnt != NULL) scsi_release_request(SRpnt);
3732
3733         up(&STp->lock);
3734
3735         return retval;
3736 }
3737
3738
3739 /* Set the driver options */
3740 static void osst_log_options(struct osst_tape *STp, struct st_modedef *STm, char *name)
3741 {
3742   printk(KERN_INFO
3743 "%s:I: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
3744          name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
3745          STm->do_read_ahead);
3746   printk(KERN_INFO
3747 "%s:I:    can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
3748          name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
3749   printk(KERN_INFO
3750 "%s:I:    defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
3751          name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
3752          STp->scsi2_logical);
3753   printk(KERN_INFO
3754 "%s:I:    sysv: %d\n", name, STm->sysv);
3755 #if DEBUG
3756   printk(KERN_INFO
3757          "%s:D:    debugging: %d\n",
3758          name, debugging);
3759 #endif
3760 }
3761
3762
3763 static int osst_set_options(struct osst_tape *STp, long options)
3764 {
3765         int                 value;
3766         long                code;
3767         struct st_modedef * STm;
3768         char              * name = tape_name(STp);
3769
3770         STm = &(STp->modes[STp->current_mode]);
3771         if (!STm->defined) {
3772                 memcpy(STm, &(STp->modes[0]), sizeof(*STm));
3773                 modes_defined = 1;
3774 #if DEBUG
3775                 if (debugging)
3776                         printk(OSST_DEB_MSG "%s:D: Initialized mode %d definition from mode 0\n",
3777                                              name, STp->current_mode);
3778 #endif
3779         }
3780
3781         code = options & MT_ST_OPTIONS;
3782         if (code == MT_ST_BOOLEANS) {
3783                 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
3784                 STm->do_async_writes  = (options & MT_ST_ASYNC_WRITES) != 0;
3785                 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
3786                 STm->do_read_ahead    = (options & MT_ST_READ_AHEAD) != 0;
3787                 STp->two_fm           = (options & MT_ST_TWO_FM) != 0;
3788                 STp->fast_mteom       = (options & MT_ST_FAST_MTEOM) != 0;
3789                 STp->do_auto_lock     = (options & MT_ST_AUTO_LOCK) != 0;
3790                 STp->can_bsr          = (options & MT_ST_CAN_BSR) != 0;
3791                 STp->omit_blklims     = (options & MT_ST_NO_BLKLIMS) != 0;
3792                 if ((STp->device)->scsi_level >= SCSI_2)
3793                         STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
3794                 STp->scsi2_logical    = (options & MT_ST_SCSI2LOGICAL) != 0;
3795                 STm->sysv             = (options & MT_ST_SYSV) != 0;
3796 #if DEBUG
3797                 debugging = (options & MT_ST_DEBUGGING) != 0;
3798 #endif
3799                 osst_log_options(STp, STm, name);
3800         }
3801         else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
3802                 value = (code == MT_ST_SETBOOLEANS);
3803                 if ((options & MT_ST_BUFFER_WRITES) != 0)
3804                         STm->do_buffer_writes = value;
3805                 if ((options & MT_ST_ASYNC_WRITES) != 0)
3806                         STm->do_async_writes = value;
3807                 if ((options & MT_ST_DEF_WRITES) != 0)
3808                         STm->defaults_for_writes = value;
3809                 if ((options & MT_ST_READ_AHEAD) != 0)
3810                         STm->do_read_ahead = value;
3811                 if ((options & MT_ST_TWO_FM) != 0)
3812                         STp->two_fm = value;
3813                 if ((options & MT_ST_FAST_MTEOM) != 0)
3814                         STp->fast_mteom = value;
3815                 if ((options & MT_ST_AUTO_LOCK) != 0)
3816                         STp->do_auto_lock = value;
3817                 if ((options & MT_ST_CAN_BSR) != 0)
3818                         STp->can_bsr = value;
3819                 if ((options & MT_ST_NO_BLKLIMS) != 0)
3820                         STp->omit_blklims = value;
3821                 if ((STp->device)->scsi_level >= SCSI_2 &&
3822                     (options & MT_ST_CAN_PARTITIONS) != 0)
3823                         STp->can_partitions = value;
3824                 if ((options & MT_ST_SCSI2LOGICAL) != 0)
3825                         STp->scsi2_logical = value;
3826                 if ((options & MT_ST_SYSV) != 0)
3827                         STm->sysv = value;
3828 #if DEBUG
3829                 if ((options & MT_ST_DEBUGGING) != 0)
3830                         debugging = value;
3831 #endif
3832                 osst_log_options(STp, STm, name);
3833         }
3834         else if (code == MT_ST_WRITE_THRESHOLD) {
3835                 value = (options & ~MT_ST_OPTIONS) * ST_KILOBYTE;
3836                 if (value < 1 || value > osst_buffer_size) {
3837                         printk(KERN_WARNING "%s:W: Write threshold %d too small or too large.\n",
3838                                              name, value);
3839                         return (-EIO);
3840                 }
3841                 STp->write_threshold = value;
3842                 printk(KERN_INFO "%s:I: Write threshold set to %d bytes.\n",
3843                                   name, value);
3844         }
3845         else if (code == MT_ST_DEF_BLKSIZE) {
3846                 value = (options & ~MT_ST_OPTIONS);
3847                 if (value == ~MT_ST_OPTIONS) {
3848                         STm->default_blksize = (-1);
3849                         printk(KERN_INFO "%s:I: Default block size disabled.\n", name);
3850                 }
3851                 else {
3852                         if (value < 512 || value > OS_DATA_SIZE || OS_DATA_SIZE % value) {
3853                                 printk(KERN_WARNING "%s:W: Default block size cannot be set to %d.\n",
3854                                                          name, value);
3855                                 return (-EINVAL);
3856                         }
3857                         STm->default_blksize = value;
3858                         printk(KERN_INFO "%s:I: Default block size set to %d bytes.\n",
3859                                           name, STm->default_blksize);
3860                 }
3861         }
3862         else if (code == MT_ST_TIMEOUTS) {
3863                 value = (options & ~MT_ST_OPTIONS);
3864                 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
3865                         STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
3866                         printk(KERN_INFO "%s:I: Long timeout set to %d seconds.\n", name,
3867                                              (value & ~MT_ST_SET_LONG_TIMEOUT));
3868                 }
3869                 else {
3870                         STp->timeout = value * HZ;
3871                         printk(KERN_INFO "%s:I: Normal timeout set to %d seconds.\n", name, value);
3872                 }
3873         }
3874         else if (code == MT_ST_DEF_OPTIONS) {
3875                 code = (options & ~MT_ST_CLEAR_DEFAULT);
3876                 value = (options & MT_ST_CLEAR_DEFAULT);
3877                 if (code == MT_ST_DEF_DENSITY) {
3878                         if (value == MT_ST_CLEAR_DEFAULT) {
3879                                 STm->default_density = (-1);
3880                                 printk(KERN_INFO "%s:I: Density default disabled.\n", name);
3881                         }
3882                         else {
3883                                 STm->default_density = value & 0xff;
3884                                 printk(KERN_INFO "%s:I: Density default set to %x\n",
3885                                                   name, STm->default_density);
3886                         }
3887                 }
3888                 else if (code == MT_ST_DEF_DRVBUFFER) {
3889                         if (value == MT_ST_CLEAR_DEFAULT) {
3890                                 STp->default_drvbuffer = 0xff;
3891                                 printk(KERN_INFO "%s:I: Drive buffer default disabled.\n", name);
3892                         }
3893                         else {
3894                                 STp->default_drvbuffer = value & 7;
3895                                 printk(KERN_INFO "%s:I: Drive buffer default set to %x\n",
3896                                                   name, STp->default_drvbuffer);
3897                         }
3898                 }
3899                 else if (code == MT_ST_DEF_COMPRESSION) {
3900                         if (value == MT_ST_CLEAR_DEFAULT) {
3901                                 STm->default_compression = ST_DONT_TOUCH;
3902                                 printk(KERN_INFO "%s:I: Compression default disabled.\n", name);
3903                         }
3904                         else {
3905                                 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
3906                                 printk(KERN_INFO "%s:I: Compression default set to %x\n",
3907                                                   name, (value & 1));
3908                         }
3909                 }
3910         }
3911         else
3912                 return (-EIO);
3913
3914         return 0;
3915 }
3916
3917
3918 /* Internal ioctl function */
3919 static int osst_int_ioctl(struct osst_tape * STp, struct scsi_request ** aSRpnt,
3920                              unsigned int cmd_in, unsigned long arg)
3921 {
3922         int                     timeout;
3923         long                    ltmp;
3924         int                     i, ioctl_result;
3925         int                     chg_eof = 1;
3926         unsigned char           cmd[MAX_COMMAND_SIZE];
3927         struct scsi_request   * SRpnt = * aSRpnt;
3928         struct st_partstat    * STps;
3929         int                     fileno, blkno, at_sm, frame_seq_numbr, logical_blk_num;
3930         int                     datalen = 0, direction = DMA_NONE;
3931         char                  * name = tape_name(STp);
3932
3933         if (STp->ready != ST_READY && cmd_in != MTLOAD) {
3934                 if (STp->ready == ST_NO_TAPE)
3935                         return (-ENOMEDIUM);
3936                 else
3937                         return (-EIO);
3938         }
3939         timeout = STp->long_timeout;
3940         STps = &(STp->ps[STp->partition]);
3941         fileno = STps->drv_file;
3942         blkno = STps->drv_block;
3943         at_sm = STps->at_sm;
3944         frame_seq_numbr = STp->frame_seq_number;
3945         logical_blk_num = STp->logical_blk_num;
3946
3947         memset(cmd, 0, MAX_COMMAND_SIZE);
3948         switch (cmd_in) {
3949          case MTFSFM:
3950                 chg_eof = 0; /* Changed from the FSF after this */
3951          case MTFSF:
3952                 if (STp->raw)
3953                    return (-EIO);
3954                 if (STp->linux_media)
3955                    ioctl_result = osst_space_over_filemarks_forward_fast(STp, &SRpnt, cmd_in, arg);
3956                 else
3957                    ioctl_result = osst_space_over_filemarks_forward_slow(STp, &SRpnt, cmd_in, arg);
3958                 if (fileno >= 0)
3959                    fileno += arg;
3960                 blkno = 0;
3961                 at_sm &= (arg == 0);
3962                 goto os_bypass;
3963
3964          case MTBSF:
3965                 chg_eof = 0; /* Changed from the FSF after this */
3966          case MTBSFM:
3967                 if (STp->raw)
3968                    return (-EIO);
3969                 ioctl_result = osst_space_over_filemarks_backward(STp, &SRpnt, cmd_in, arg);
3970                 if (fileno >= 0)
3971                    fileno -= arg;
3972                 blkno = (-1);  /* We can't know the block number */
3973                 at_sm &= (arg == 0);
3974                 goto os_bypass;
3975
3976          case MTFSR:
3977          case MTBSR:
3978 #if DEBUG
3979                 if (debugging)
3980                    printk(OSST_DEB_MSG "%s:D: Skipping %lu blocks %s from logical block %d\n",
3981                                 name, arg, cmd_in==MTFSR?"forward":"backward", logical_blk_num);
3982 #endif
3983                 if (cmd_in == MTFSR) {
3984                    logical_blk_num += arg;
3985                    if (blkno >= 0) blkno += arg;
3986                 }
3987                 else {
3988                    logical_blk_num -= arg;
3989                    if (blkno >= 0) blkno -= arg;
3990                 }
3991                 ioctl_result = osst_seek_logical_blk(STp, &SRpnt, logical_blk_num);
3992                 fileno = STps->drv_file;
3993                 blkno  = STps->drv_block;
3994                 at_sm &= (arg == 0);
3995                 goto os_bypass;
3996
3997          case MTFSS:
3998                 cmd[0] = SPACE;
3999                 cmd[1] = 0x04; /* Space Setmarks */   /* FIXME -- OS can't do this? */
4000                 cmd[2] = (arg >> 16);
4001                 cmd[3] = (arg >> 8);
4002                 cmd[4] = arg;
4003 #if DEBUG
4004                 if (debugging)
4005                         printk(OSST_DEB_MSG "%s:D: Spacing tape forward %d setmarks.\n", name,
4006                 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
4007 #endif
4008                 if (arg != 0) {
4009                         blkno = fileno = (-1);
4010                         at_sm = 1;
4011                 }
4012                 break;
4013          case MTBSS:
4014                 cmd[0] = SPACE;
4015                 cmd[1] = 0x04; /* Space Setmarks */   /* FIXME -- OS can't do this? */
4016                 ltmp = (-arg);
4017                 cmd[2] = (ltmp >> 16);
4018                 cmd[3] = (ltmp >> 8);
4019                 cmd[4] = ltmp;
4020 #if DEBUG
4021                 if (debugging) {
4022                         if (cmd[2] & 0x80)
4023                            ltmp = 0xff000000;
4024                         ltmp = ltmp | (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
4025                         printk(OSST_DEB_MSG "%s:D: Spacing tape backward %ld setmarks.\n",
4026                                                 name, (-ltmp));
4027                  }
4028 #endif
4029                  if (arg != 0) {
4030                         blkno = fileno = (-1);
4031                         at_sm = 1;
4032                  }
4033                  break;
4034          case MTWEOF:
4035                  if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
4036                         STp->write_type = OS_WRITE_DATA;
4037                         ioctl_result = osst_flush_write_buffer(STp, &SRpnt);
4038                  } else
4039                         ioctl_result = 0;
4040 #if DEBUG
4041                  if (debugging)
4042                            printk(OSST_DEB_MSG "%s:D: Writing %ld filemark(s).\n", name, arg);
4043 #endif
4044                  for (i=0; i<arg; i++)
4045                         ioctl_result |= osst_write_filemark(STp, &SRpnt);
4046                  if (fileno >= 0) fileno += arg;
4047                  if (blkno  >= 0) blkno   = 0;
4048                  goto os_bypass;
4049
4050          case MTWSM:
4051                  if (STp->write_prot)
4052                         return (-EACCES);
4053                  if (!STp->raw)
4054                         return 0;
4055                  cmd[0] = WRITE_FILEMARKS;   /* FIXME -- need OS version */
4056                  if (cmd_in == MTWSM)
4057                          cmd[1] = 2;
4058                  cmd[2] = (arg >> 16);
4059                  cmd[3] = (arg >> 8);
4060                  cmd[4] = arg;
4061                  timeout = STp->timeout;
4062 #if DEBUG
4063                  if (debugging)
4064                            printk(OSST_DEB_MSG "%s:D: Writing %d setmark(s).\n", name,
4065                                   cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
4066 #endif
4067                  if (fileno >= 0)
4068                         fileno += arg;
4069                  blkno = 0;
4070                  at_sm = (cmd_in == MTWSM);
4071                  break;
4072          case MTOFFL:
4073          case MTLOAD:
4074          case MTUNLOAD:
4075          case MTRETEN:
4076                  cmd[0] = START_STOP;
4077                  cmd[1] = 1;                    /* Don't wait for completion */
4078                  if (cmd_in == MTLOAD) {
4079                      if (STp->ready == ST_NO_TAPE)
4080                          cmd[4] = 4;            /* open tray */
4081                       else
4082                          cmd[4] = 1;            /* load */
4083                  }
4084                  if (cmd_in == MTRETEN)
4085                          cmd[4] = 3;            /* retension then mount */
4086                  if (cmd_in == MTOFFL)
4087                          cmd[4] = 4;            /* rewind then eject */
4088                  timeout = STp->timeout;
4089 #if DEBUG
4090                  if (debugging) {
4091                          switch (cmd_in) {
4092                                  case MTUNLOAD:
4093                                          printk(OSST_DEB_MSG "%s:D: Unloading tape.\n", name);
4094                                          break;
4095                                  case MTLOAD:
4096                                          printk(OSST_DEB_MSG "%s:D: Loading tape.\n", name);
4097                                          break;
4098                                  case MTRETEN:
4099                                          printk(OSST_DEB_MSG "%s:D: Retensioning tape.\n", name);
4100                                          break;
4101                                  case MTOFFL:
4102                                          printk(OSST_DEB_MSG "%s:D: Ejecting tape.\n", name);
4103                                          break;
4104                          }
4105                  }
4106 #endif
4107        fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
4108                  break;
4109          case MTNOP:
4110 #if DEBUG
4111                  if (debugging)
4112                          printk(OSST_DEB_MSG "%s:D: No-op on tape.\n", name);
4113 #endif
4114                  return 0;  /* Should do something ? */
4115                  break;
4116          case MTEOM:
4117 #if DEBUG
4118                 if (debugging)
4119                    printk(OSST_DEB_MSG "%s:D: Spacing to end of recorded medium.\n", name);
4120 #endif
4121                 if ((osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0) ||
4122                             (osst_get_logical_frame(STp, &SRpnt, -1, 0)               < 0)) {
4123                    ioctl_result = -EIO;
4124                    goto os_bypass;
4125                 }
4126                 if (STp->buffer->aux->frame_type != OS_FRAME_TYPE_EOD) {
4127 #if DEBUG
4128                    printk(OSST_DEB_MSG "%s:D: No EOD frame found where expected.\n", name);
4129 #endif
4130                    ioctl_result = -EIO;
4131                    goto os_bypass;
4132                 }
4133                 ioctl_result = osst_set_frame_position(STp, &SRpnt, STp->eod_frame_ppos, 0);
4134                 fileno = STp->filemark_cnt;
4135                 blkno  = at_sm = 0;
4136                 goto os_bypass;
4137
4138          case MTERASE:
4139                 if (STp->write_prot)
4140                    return (-EACCES);
4141                 ioctl_result = osst_reset_header(STp, &SRpnt);
4142                 i = osst_write_eod(STp, &SRpnt);
4143                 if (i < ioctl_result) ioctl_result = i;
4144                 i = osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos);
4145                 if (i < ioctl_result) ioctl_result = i;
4146                 fileno = blkno = at_sm = 0 ;
4147                 goto os_bypass;
4148
4149          case MTREW:
4150                 cmd[0] = REZERO_UNIT; /* rewind */
4151                 cmd[1] = 1;
4152 #if DEBUG
4153                 if (debugging)
4154                    printk(OSST_DEB_MSG "%s:D: Rewinding tape, Immed=%d.\n", name, cmd[1]);
4155 #endif
4156                 fileno = blkno = at_sm = frame_seq_numbr = logical_blk_num = 0 ;
4157                 break;
4158
4159          case MTSETBLK:           /* Set block length */
4160                  if ((STps->drv_block == 0 )                      &&
4161                      !STp->dirty                                  &&
4162                      ((STp->buffer)->buffer_bytes == 0)           &&
4163                      ((arg & MT_ST_BLKSIZE_MASK) >= 512 )         &&
4164                      ((arg & MT_ST_BLKSIZE_MASK) <= OS_DATA_SIZE) &&
4165                      !(OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK))  ) {
4166                          /*
4167                           * Only allowed to change the block size if you opened the
4168                           * device at the beginning of a file before writing anything.
4169                           * Note, that when reading, changing block_size is futile,
4170                           * as the size used when writing overrides it.
4171                           */
4172                          STp->block_size = (arg & MT_ST_BLKSIZE_MASK);
4173                          printk(KERN_INFO "%s:I: Block size set to %d bytes.\n",
4174                                            name, STp->block_size);
4175                          return 0;
4176                  }
4177          case MTSETDENSITY:       /* Set tape density */
4178          case MTSETDRVBUFFER:     /* Set drive buffering */
4179          case SET_DENS_AND_BLK:   /* Set density and block size */
4180                  chg_eof = 0;
4181                  if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
4182                          return (-EIO);       /* Not allowed if data in buffer */
4183                  if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
4184                      (arg & MT_ST_BLKSIZE_MASK) != 0                    &&
4185                      (arg & MT_ST_BLKSIZE_MASK) != STp->block_size       ) {
4186                          printk(KERN_WARNING "%s:W: Illegal to set block size to %d%s.\n",
4187                                                 name, (int)(arg & MT_ST_BLKSIZE_MASK),
4188                                                 (OS_DATA_SIZE % (arg & MT_ST_BLKSIZE_MASK))?"":" now");
4189                          return (-EINVAL);
4190                  }
4191                  return 0;  /* FIXME silently ignore if block size didn't change */
4192
4193          default:
4194                 return (-ENOSYS);
4195         }
4196
4197         SRpnt = osst_do_scsi(SRpnt, STp, cmd, datalen, direction, timeout, MAX_RETRIES, 1);
4198
4199         ioctl_result = (STp->buffer)->syscall_result;
4200
4201         if (!SRpnt) {
4202 #if DEBUG
4203                 printk(OSST_DEB_MSG "%s:D: Couldn't exec scsi cmd for IOCTL\n", name);
4204 #endif
4205                 return ioctl_result;
4206         }
4207
4208         if (!ioctl_result) {  /* SCSI command successful */
4209                 STp->frame_seq_number = frame_seq_numbr;
4210                 STp->logical_blk_num  = logical_blk_num;
4211         }
4212
4213 os_bypass:
4214 #if DEBUG
4215         if (debugging)
4216                 printk(OSST_DEB_MSG "%s:D: IOCTL (%d) Result=%d\n", name, cmd_in, ioctl_result);
4217 #endif
4218
4219         if (!ioctl_result) {                            /* success */
4220
4221                 if (cmd_in == MTFSFM) {
4222                          fileno--;
4223                          blkno--;
4224                 }
4225                 if (cmd_in == MTBSFM) {
4226                          fileno++;
4227                          blkno++;
4228                 }
4229                 STps->drv_block = blkno;
4230                 STps->drv_file = fileno;
4231                 STps->at_sm = at_sm;
4232
4233                 if (cmd_in == MTEOM)
4234                         STps->eof = ST_EOD;
4235                 else if ((cmd_in == MTFSFM || cmd_in == MTBSF) && STps->eof == ST_FM_HIT) {
4236                         ioctl_result = osst_seek_logical_blk(STp, &SRpnt, STp->logical_blk_num-1);
4237                         STps->drv_block++;
4238                         STp->logical_blk_num++;
4239                         STp->frame_seq_number++;
4240                         STp->frame_in_buffer = 0;
4241                         STp->buffer->read_pointer = 0;
4242                 }
4243                 else if (cmd_in == MTFSF)
4244                         STps->eof = (STp->first_frame_position >= STp->eod_frame_ppos)?ST_EOD:ST_FM;
4245                 else if (chg_eof)
4246                         STps->eof = ST_NOEOF;
4247
4248                 if (cmd_in == MTOFFL || cmd_in == MTUNLOAD)
4249                         STp->rew_at_close = 0;
4250                 else if (cmd_in == MTLOAD) {
4251                         for (i=0; i < ST_NBR_PARTITIONS; i++) {
4252                             STp->ps[i].rw = ST_IDLE;
4253                             STp->ps[i].last_block_valid = 0;/* FIXME - where else is this field maintained? */
4254                         }
4255                         STp->partition = 0;
4256                 }
4257
4258                 if (cmd_in == MTREW) {
4259                         ioctl_result = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
4260                         if (ioctl_result > 0)
4261                                 ioctl_result = 0;
4262                 }
4263
4264         } else if (cmd_in == MTBSF || cmd_in == MTBSFM ) {
4265                 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos) < 0)
4266                         STps->drv_file = STps->drv_block = -1;
4267                 else
4268                         STps->drv_file = STps->drv_block = 0;
4269                 STps->eof = ST_NOEOF;
4270         } else if (cmd_in == MTFSF || cmd_in == MTFSFM) {
4271                 if (osst_position_tape_and_confirm(STp, &SRpnt, STp->eod_frame_ppos) < 0)
4272                         STps->drv_file = STps->drv_block = -1;
4273                 else {
4274                         STps->drv_file  = STp->filemark_cnt;
4275                         STps->drv_block = 0;
4276                 }
4277                 STps->eof = ST_EOD;
4278         } else if (cmd_in == MTBSR || cmd_in == MTFSR || cmd_in == MTWEOF || cmd_in == MTEOM) {
4279                 STps->drv_file = STps->drv_block = (-1);
4280                 STps->eof = ST_NOEOF;
4281                 STp->header_ok = 0;
4282         } else if (cmd_in == MTERASE) {
4283                 STp->header_ok = 0;
4284         } else if (SRpnt) {  /* SCSI command was not completely successful. */
4285                 if (SRpnt->sr_sense_buffer[2] & 0x40) {
4286                         STps->eof = ST_EOM_OK;
4287                         STps->drv_block = 0;
4288                 }
4289                 if (chg_eof)
4290                         STps->eof = ST_NOEOF;
4291
4292                 if ((SRpnt->sr_sense_buffer[2] & 0x0f) == BLANK_CHECK)
4293                         STps->eof = ST_EOD;
4294
4295                 if (cmd_in == MTLOAD && osst_wait_for_medium(STp, &SRpnt, 60))
4296                         ioctl_result = osst_wait_ready(STp, &SRpnt, 5 * 60, OSST_WAIT_POSITION_COMPLETE);
4297         }
4298         *aSRpnt = SRpnt;
4299
4300         return ioctl_result;
4301 }
4302
4303
4304 /* Open the device */
4305 static int os_scsi_tape_open(struct inode * inode, struct file * filp)
4306 {
4307         unsigned short        flags;
4308         int                   i, b_size, new_session = 0, retval = 0;
4309         unsigned char         cmd[MAX_COMMAND_SIZE];
4310         struct scsi_request * SRpnt = NULL;
4311         struct osst_tape    * STp;
4312         struct st_modedef   * STm;
4313         struct st_partstat  * STps;
4314         char                * name;
4315         int                   dev  = TAPE_NR(inode);
4316         int                   mode = TAPE_MODE(inode);
4317
4318         /*
4319          * We really want to do nonseekable_open(inode, filp); here, but some
4320          * versions of tar incorrectly call lseek on tapes and bail out if that
4321          * fails.  So we disallow pread() and pwrite(), but permit lseeks.
4322          */
4323         filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
4324
4325         write_lock(&os_scsi_tapes_lock);
4326         if (dev >= osst_max_dev || os_scsi_tapes == NULL ||
4327             (STp = os_scsi_tapes[dev]) == NULL || !STp->device) {
4328                 write_unlock(&os_scsi_tapes_lock);
4329                 return (-ENXIO);
4330         }
4331
4332         name = tape_name(STp);
4333
4334         if (STp->in_use) {
4335                 write_unlock(&os_scsi_tapes_lock);
4336 #if DEBUG
4337                 printk(OSST_DEB_MSG "%s:D: Device already in use.\n", name);
4338 #endif
4339                 return (-EBUSY);
4340         }
4341         if (scsi_device_get(STp->device)) {
4342                 write_unlock(&os_scsi_tapes_lock);
4343 #if DEBUG
4344                 printk(OSST_DEB_MSG "%s:D: Failed scsi_device_get.\n", name);
4345 #endif
4346                 return (-ENXIO);
4347         }
4348         filp->private_data = STp;
4349         STp->in_use = 1;
4350         write_unlock(&os_scsi_tapes_lock);
4351         STp->rew_at_close = TAPE_REWIND(inode);
4352
4353         if( !scsi_block_when_processing_errors(STp->device) ) {
4354                 return -ENXIO;
4355         }
4356
4357         if (mode != STp->current_mode) {
4358 #if DEBUG
4359                 if (debugging)
4360                         printk(OSST_DEB_MSG "%s:D: Mode change from %d to %d.\n",
4361                                                name, STp->current_mode, mode);
4362 #endif
4363                 new_session = 1;
4364                 STp->current_mode = mode;
4365         }
4366         STm = &(STp->modes[STp->current_mode]);
4367
4368         flags = filp->f_flags;
4369         STp->write_prot = ((flags & O_ACCMODE) == O_RDONLY);
4370
4371         STp->raw = TAPE_IS_RAW(inode);
4372         if (STp->raw)
4373                 STp->header_ok = 0;
4374
4375         /* Allocate data segments for this device's tape buffer */
4376         if (!enlarge_buffer(STp->buffer, STp->restr_dma)) {
4377                 printk(KERN_ERR "%s:E: Unable to allocate memory segments for tape buffer.\n", name);
4378                 retval = (-EOVERFLOW);
4379                 goto err_out;
4380         }
4381         if (STp->buffer->buffer_size >= OS_FRAME_SIZE) {
4382                 for (i = 0, b_size = 0;
4383                      (i < STp->buffer->sg_segs) && ((b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE);
4384                      b_size += STp->buffer->sg[i++].length);
4385                 STp->buffer->aux = (os_aux_t *) (page_address(STp->buffer->sg[i].page) + OS_DATA_SIZE - b_size);
4386 #if DEBUG
4387                 printk(OSST_DEB_MSG "%s:D: b_data points to %p in segment 0 at %p\n", name,
4388                         STp->buffer->b_data, page_address(STp->buffer->sg[0].page));
4389                 printk(OSST_DEB_MSG "%s:D: AUX points to %p in segment %d at %p\n", name,
4390                          STp->buffer->aux, i, page_address(STp->buffer->sg[i].page));
4391 #endif
4392         } else {
4393                 STp->buffer->aux = NULL; /* this had better never happen! */
4394                 printk(KERN_NOTICE "%s:A: Framesize %d too large for buffer.\n", name, OS_FRAME_SIZE);
4395                 retval = (-EIO);
4396                 goto err_out;
4397         }
4398         STp->buffer->writing = 0;
4399         STp->buffer->syscall_result = 0;
4400         STp->dirty = 0;
4401         for (i=0; i < ST_NBR_PARTITIONS; i++) {
4402                 STps = &(STp->ps[i]);
4403                 STps->rw = ST_IDLE;
4404         }
4405         STp->ready = ST_READY;
4406 #if DEBUG
4407         STp->nbr_waits = STp->nbr_finished = 0;
4408 #endif
4409
4410         memset (cmd, 0, MAX_COMMAND_SIZE);
4411         cmd[0] = TEST_UNIT_READY;
4412
4413         SRpnt = osst_do_scsi(NULL, STp, cmd, 0, DMA_NONE, STp->timeout, MAX_RETRIES, 1);
4414         if (!SRpnt) {
4415                 retval = (STp->buffer)->syscall_result;         /* FIXME - valid? */
4416                 goto err_out;
4417         }
4418         if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70      &&
4419             (SRpnt->sr_sense_buffer[2] & 0x0f) == NOT_READY &&
4420              SRpnt->sr_sense_buffer[12]        == 4         ) {
4421 #if DEBUG
4422                 printk(OSST_DEB_MSG "%s:D: Unit not ready, cause %x\n", name, SRpnt->sr_sense_buffer[13]);
4423 #endif
4424                 if (filp->f_flags & O_NONBLOCK) {
4425                         retval = -EAGAIN;
4426                         goto err_out;
4427                 }
4428                 if (SRpnt->sr_sense_buffer[13] == 2) {  /* initialize command required (LOAD) */
4429                         memset (cmd, 0, MAX_COMMAND_SIZE);
4430                         cmd[0] = START_STOP;
4431                         cmd[1] = 1;
4432                         cmd[4] = 1;
4433                         SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4434                                              STp->timeout, MAX_RETRIES, 1);
4435                 }
4436                 osst_wait_ready(STp, &SRpnt, (SRpnt->sr_sense_buffer[13]==1?15:3) * 60, 0);
4437         }
4438         if ((SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
4439             (SRpnt->sr_sense_buffer[2] & 0x0f) == UNIT_ATTENTION) { /* New media? */
4440 #if DEBUG
4441                 printk(OSST_DEB_MSG "%s:D: Unit wants attention\n", name);
4442 #endif
4443                 STp->header_ok = 0;
4444
4445                 for (i=0; i < 10; i++) {
4446
4447                         memset (cmd, 0, MAX_COMMAND_SIZE);
4448                         cmd[0] = TEST_UNIT_READY;
4449
4450                         SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4451                                              STp->timeout, MAX_RETRIES, 1);
4452                         if ((SRpnt->sr_sense_buffer[0] & 0x70) != 0x70 ||
4453                             (SRpnt->sr_sense_buffer[2] & 0x0f) != UNIT_ATTENTION)
4454                                 break;
4455                 }
4456
4457                 STp->pos_unknown = 0;
4458                 STp->partition = STp->new_partition = 0;
4459                 if (STp->can_partitions)
4460                         STp->nbr_partitions = 1;  /* This guess will be updated later if necessary */
4461                 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4462                         STps = &(STp->ps[i]);
4463                         STps->rw = ST_IDLE;             /* FIXME - seems to be redundant... */
4464                         STps->eof = ST_NOEOF;
4465                         STps->at_sm = 0;
4466                         STps->last_block_valid = 0;
4467                         STps->drv_block = 0;
4468                         STps->drv_file = 0 ;
4469                 }
4470                 new_session = 1;
4471                 STp->recover_count = 0;
4472                 STp->abort_count = 0;
4473         }
4474         /*
4475          * if we have valid headers from before, and the drive/tape seem untouched,
4476          * open without reconfiguring and re-reading the headers
4477          */
4478         if (!STp->buffer->syscall_result && STp->header_ok &&
4479             !SRpnt->sr_result && SRpnt->sr_sense_buffer[0] == 0) {
4480
4481                 memset(cmd, 0, MAX_COMMAND_SIZE);
4482                 cmd[0] = MODE_SENSE;
4483                 cmd[1] = 8;
4484                 cmd[2] = VENDOR_IDENT_PAGE;
4485                 cmd[4] = VENDOR_IDENT_PAGE_LENGTH + MODE_HEADER_LENGTH;
4486
4487                 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE, STp->timeout, 0, 1);
4488
4489                 if (STp->buffer->syscall_result                     ||
4490                     STp->buffer->b_data[MODE_HEADER_LENGTH + 2] != 'L' ||
4491                     STp->buffer->b_data[MODE_HEADER_LENGTH + 3] != 'I' ||
4492                     STp->buffer->b_data[MODE_HEADER_LENGTH + 4] != 'N' ||
4493                     STp->buffer->b_data[MODE_HEADER_LENGTH + 5] != '4'  ) {
4494 #if DEBUG
4495                         printk(OSST_DEB_MSG "%s:D: Signature was changed to %c%c%c%c\n", name,
4496                           STp->buffer->b_data[MODE_HEADER_LENGTH + 2],
4497                           STp->buffer->b_data[MODE_HEADER_LENGTH + 3],
4498                           STp->buffer->b_data[MODE_HEADER_LENGTH + 4],
4499                           STp->buffer->b_data[MODE_HEADER_LENGTH + 5]);
4500 #endif
4501                         STp->header_ok = 0;
4502                 }
4503                 i = STp->first_frame_position;
4504                 if (STp->header_ok && i == osst_get_frame_position(STp, &SRpnt)) {
4505                         if (STp->door_locked == ST_UNLOCKED) {
4506                                 if (do_door_lock(STp, 1))
4507                                         printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
4508                                 else
4509                                         STp->door_locked = ST_LOCKED_AUTO;
4510                         }
4511                         if (!STp->frame_in_buffer) {
4512                                 STp->block_size = (STm->default_blksize > 0) ?
4513                                                         STm->default_blksize : OS_DATA_SIZE;
4514                                 STp->buffer->buffer_bytes = STp->buffer->read_pointer = 0;
4515                         }
4516                         STp->buffer->buffer_blocks = OS_DATA_SIZE / STp->block_size;
4517                         STp->fast_open = 1;
4518                         scsi_release_request(SRpnt);
4519                         return 0;
4520                 }
4521 #if DEBUG
4522                 if (i != STp->first_frame_position)
4523                         printk(OSST_DEB_MSG "%s:D: Tape position changed from %d to %d\n",
4524                                                 name, i, STp->first_frame_position);
4525 #endif
4526                 STp->header_ok = 0;
4527         }
4528         STp->fast_open = 0;
4529
4530         if ((STp->buffer)->syscall_result != 0 &&   /* in all error conditions except no medium */
4531             (SRpnt->sr_sense_buffer[2] != 2 || SRpnt->sr_sense_buffer[12] != 0x3A) ) {
4532
4533                 memset(cmd, 0, MAX_COMMAND_SIZE);
4534                 cmd[0] = MODE_SELECT;
4535                 cmd[1] = 0x10;
4536                 cmd[4] = 4 + MODE_HEADER_LENGTH;
4537
4538                 (STp->buffer)->b_data[0] = cmd[4] - 1;
4539                 (STp->buffer)->b_data[1] = 0;                   /* Medium Type - ignoring */
4540                 (STp->buffer)->b_data[2] = 0;                   /* Reserved */
4541                 (STp->buffer)->b_data[3] = 0;                   /* Block Descriptor Length */
4542                 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 0] = 0x3f;
4543                 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 1] = 1;
4544                 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 2] = 2;
4545                 (STp->buffer)->b_data[MODE_HEADER_LENGTH + 3] = 3;
4546
4547 #if DEBUG
4548                 printk(OSST_DEB_MSG "%s:D: Applying soft reset\n", name);
4549 #endif
4550                 SRpnt = osst_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE, STp->timeout, 0, 1);
4551
4552                 STp->header_ok = 0;
4553
4554                 for (i=0; i < 10; i++) {
4555
4556                         memset (cmd, 0, MAX_COMMAND_SIZE);
4557                         cmd[0] = TEST_UNIT_READY;
4558
4559                         SRpnt = osst_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
4560                                                     STp->timeout, MAX_RETRIES, 1);
4561                         if ((SRpnt->sr_sense_buffer[0] & 0x70) != 0x70 ||
4562                             (SRpnt->sr_sense_buffer[2] & 0x0f) == NOT_READY)
4563                         break;
4564
4565                         if ((SRpnt->sr_sense_buffer[2] & 0x0f) == UNIT_ATTENTION) {
4566                                 STp->pos_unknown = 0;
4567                                 STp->partition = STp->new_partition = 0;
4568                                 if (STp->can_partitions)
4569                                         STp->nbr_partitions = 1;  /* This guess will be updated later if necessary */
4570                                 for (i=0; i < ST_NBR_PARTITIONS; i++) {
4571                                         STps = &(STp->ps[i]);
4572                                         STps->rw = ST_IDLE;
4573                                         STps->eof = ST_NOEOF;
4574                                         STps->at_sm = 0;
4575                                         STps->last_block_valid = 0;
4576                                         STps->drv_block = 0;
4577                                         STps->drv_file = 0 ;
4578                                 }
4579                                 new_session = 1;
4580                         }
4581                 }
4582         }
4583
4584         if (osst_wait_ready(STp, &SRpnt, 15 * 60, 0))           /* FIXME - not allowed with NOBLOCK */
4585                  printk(KERN_INFO "%s:I: Device did not become Ready in open\n", name);
4586
4587         if ((STp->buffer)->syscall_result != 0) {
4588                 if ((STp->device)->scsi_level >= SCSI_2 &&
4589                     (SRpnt->sr_sense_buffer[0] & 0x70) == 0x70 &&
4590                     (SRpnt->sr_sense_buffer[2] & 0x0f) == NOT_READY &&
4591                      SRpnt->sr_sense_buffer[12] == 0x3a) { /* Check ASC */
4592                         STp->ready = ST_NO_TAPE;
4593                 } else
4594                         STp->ready = ST_NOT_READY;
4595                 scsi_release_request(SRpnt);
4596                 SRpnt = NULL;
4597                 STp->density = 0;       /* Clear the erroneous "residue" */
4598                 STp->write_prot = 0;
4599                 STp->block_size = 0;
4600                 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
4601                 STp->partition = STp->new_partition = 0;
4602                 STp->door_locked = ST_UNLOCKED;
4603                 return 0;
4604         }
4605
4606         osst_configure_onstream(STp, &SRpnt);
4607
4608         STp->block_size = STp->raw ? OS_FRAME_SIZE : (
4609                              (STm->default_blksize > 0) ? STm->default_blksize : OS_DATA_SIZE);
4610         STp->buffer->buffer_blocks = STp->raw ? 1 : OS_DATA_SIZE / STp->block_size;
4611         STp->buffer->buffer_bytes  =
4612         STp->buffer->read_pointer  =
4613         STp->frame_in_buffer       = 0;
4614
4615 #if DEBUG
4616         if (debugging)
4617                 printk(OSST_DEB_MSG "%s:D: Block size: %d, frame size: %d, buffer size: %d (%d blocks).\n",
4618                      name, STp->block_size, OS_FRAME_SIZE, (STp->buffer)->buffer_size,
4619                      (STp->buffer)->buffer_blocks);
4620 #endif
4621
4622         if (STp->drv_write_prot) {
4623                 STp->write_prot = 1;
4624 #if DEBUG
4625                 if (debugging)
4626                         printk(OSST_DEB_MSG "%s:D: Write protected\n", name);
4627 #endif
4628                 if ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR) {
4629                         retval = (-EROFS);
4630                         goto err_out;
4631                 }
4632         }
4633
4634         if (new_session) {  /* Change the drive parameters for the new mode */
4635 #if DEBUG
4636                 if (debugging)
4637         printk(OSST_DEB_MSG "%s:D: New Session\n", name);
4638 #endif
4639                 STp->density_changed = STp->blksize_changed = 0;
4640                 STp->compression_changed = 0;
4641         }
4642
4643         /*
4644          * properly position the tape and check the ADR headers
4645          */
4646         if (STp->door_locked == ST_UNLOCKED) {
4647                  if (do_door_lock(STp, 1))
4648                         printk(KERN_INFO "%s:I: Can't lock drive door\n", name);
4649                  else
4650                         STp->door_locked = ST_LOCKED_AUTO;
4651         }
4652
4653         osst_analyze_headers(STp, &SRpnt);
4654
4655         scsi_release_request(SRpnt);
4656         SRpnt = NULL;
4657
4658         return 0;
4659
4660 err_out:
4661         if (SRpnt != NULL)
4662                 scsi_release_request(SRpnt);
4663         normalize_buffer(STp->buffer);
4664         STp->header_ok = 0;
4665         STp->in_use = 0;
4666         scsi_device_put(STp->device);
4667
4668         return retval;
4669 }
4670
4671
4672 /* Flush the tape buffer before close */
4673 static int os_scsi_tape_flush(struct file * filp)
4674 {
4675         int                   result = 0, result2;
4676         struct osst_tape    * STp    = filp->private_data;
4677         struct st_modedef   * STm    = &(STp->modes[STp->current_mode]);
4678         struct st_partstat  * STps   = &(STp->ps[STp->partition]);
4679         struct scsi_request * SRpnt  = NULL;
4680         char                * name   = tape_name(STp);
4681
4682         if (file_count(filp) > 1)
4683                 return 0;
4684
4685         if ((STps->rw == ST_WRITING || STp->dirty) && !STp->pos_unknown) {
4686                 STp->write_type = OS_WRITE_DATA;
4687                 result = osst_flush_write_buffer(STp, &SRpnt);
4688                 if (result != 0 && result != (-ENOSPC))
4689                         goto out;
4690         }
4691         if ( STps->rw >= ST_WRITING && !STp->pos_unknown) {
4692
4693 #if DEBUG
4694                 if (debugging) {
4695                         printk(OSST_DEB_MSG "%s:D: File length %ld bytes.\n",
4696                                                name, (long)(filp->f_pos));
4697                         printk(OSST_DEB_MSG "%s:D: Async write waits %d, finished %d.\n",
4698                                                name, STp->nbr_waits, STp->nbr_finished);
4699                 }
4700 #endif
4701                 result = osst_write_trailer(STp, &SRpnt, !(STp->rew_at_close));
4702 #if DEBUG
4703                 if (debugging)
4704                         printk(OSST_DEB_MSG "%s:D: Buffer flushed, %d EOF(s) written\n",
4705                                                name, 1+STp->two_fm);
4706 #endif
4707         }
4708         else if (!STp->rew_at_close) {
4709                 STps = &(STp->ps[STp->partition]);
4710                 if (!STm->sysv || STps->rw != ST_READING) {
4711                         if (STp->can_bsr)
4712                                 result = osst_flush_buffer(STp, &SRpnt, 0); /* this is the default path */
4713                         else if (STps->eof == ST_FM_HIT) {
4714                                 result = cross_eof(STp, &SRpnt, 0);
4715                                         if (result) {
4716                                                 if (STps->drv_file >= 0)
4717                                                         STps->drv_file++;
4718                                                 STps->drv_block = 0;
4719                                                 STps->eof = ST_FM;
4720                                         }
4721                                         else
4722                                                 STps->eof = ST_NOEOF;
4723                         }
4724                 }
4725                 else if ((STps->eof == ST_NOEOF &&
4726                           !(result = cross_eof(STp, &SRpnt, 1))) ||
4727                          STps->eof == ST_FM_HIT) {
4728                         if (STps->drv_file >= 0)
4729                                 STps->drv_file++;
4730                         STps->drv_block = 0;
4731                         STps->eof = ST_FM;
4732                 }
4733         }
4734
4735 out:
4736         if (STp->rew_at_close) {
4737                 result2 = osst_position_tape_and_confirm(STp, &SRpnt, STp->first_data_ppos);
4738                 STps->drv_file = STps->drv_block = STp->frame_seq_number = STp->logical_blk_num = 0;
4739                 if (result == 0 && result2 < 0)
4740                         result = result2;
4741         }
4742         if (SRpnt) scsi_release_request(SRpnt);
4743
4744         if (STp->abort_count || STp->recover_count) {
4745                 printk(KERN_INFO "%s:I:", name);
4746                 if (STp->abort_count)
4747                         printk(" %d unrecovered errors", STp->abort_count);
4748                 if (STp->recover_count)
4749                         printk(" %d recovered errors", STp->recover_count);
4750                 if (STp->write_count)
4751                         printk(" in %d frames written", STp->write_count);
4752                 if (STp->read_count)
4753                         printk(" in %d frames read", STp->read_count);
4754                 printk("\n");
4755                 STp->recover_count = 0;
4756                 STp->abort_count   = 0;
4757         }
4758         STp->write_count = 0;
4759         STp->read_count  = 0;
4760
4761         return result;
4762 }
4763
4764
4765 /* Close the device and release it */
4766 static int os_scsi_tape_close(struct inode * inode, struct file * filp)
4767 {
4768         int                   result = 0;
4769         struct osst_tape    * STp    = filp->private_data;
4770
4771         if (STp->door_locked == ST_LOCKED_AUTO)
4772                 do_door_lock(STp, 0);
4773
4774         if (STp->raw)
4775                 STp->header_ok = 0;
4776
4777         normalize_buffer(STp->buffer);
4778         write_lock(&os_scsi_tapes_lock);
4779         STp->in_use = 0;
4780         write_unlock(&os_scsi_tapes_lock);
4781
4782         scsi_device_put(STp->device);
4783
4784         return result;
4785 }
4786
4787
4788 /* The ioctl command */
4789 static int osst_ioctl(struct inode * inode,struct file * file,
4790          unsigned int cmd_in, unsigned long arg)
4791 {
4792         int                   i, cmd_nr, cmd_type, retval = 0;
4793         unsigned int          blk;
4794         struct st_modedef   * STm;
4795         struct st_partstat  * STps;
4796         struct scsi_request * SRpnt = NULL;
4797         struct osst_tape    * STp   = file->private_data;
4798         char                * name  = tape_name(STp);
4799         void        __user  * p     = (void __user *)arg;
4800
4801         if (down_interruptible(&STp->lock))
4802                 return -ERESTARTSYS;
4803
4804 #if DEBUG
4805         if (debugging && !STp->in_use) {
4806                 printk(OSST_DEB_MSG "%s:D: Incorrect device.\n", name);
4807                 retval = (-EIO);
4808                 goto out;
4809         }
4810 #endif
4811         STm = &(STp->modes[STp->current_mode]);
4812         STps = &(STp->ps[STp->partition]);
4813
4814         /*
4815          * If we are in the middle of error recovery, don't let anyone
4816          * else try and use this device.  Also, if error recovery fails, it
4817          * may try and take the device offline, in which case all further
4818          * access to the device is prohibited.
4819          */
4820         if( !scsi_block_when_processing_errors(STp->device) ) {
4821                 retval = (-ENXIO);
4822                 goto out;
4823         }
4824
4825         cmd_type = _IOC_TYPE(cmd_in);
4826         cmd_nr   = _IOC_NR(cmd_in);
4827 #if DEBUG
4828         printk(OSST_DEB_MSG "%s:D: Ioctl %d,%d in %s mode\n", name,
4829                             cmd_type, cmd_nr, STp->raw?"raw":"normal");
4830 #endif
4831         if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
4832                 struct mtop mtc;
4833                 int    auto_weof = 0;
4834
4835                 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
4836                         retval = (-EINVAL);
4837                         goto out;
4838                 }
4839
4840                 i = copy_from_user((char *) &mtc, p, sizeof(struct mtop));
4841                 if (i) {
4842                         retval = (-EFAULT);
4843                         goto out;
4844                 }
4845
4846                 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
4847                         printk(KERN_WARNING "%s:W: MTSETDRVBUFFER only allowed for root.\n", name);
4848                         retval = (-EPERM);
4849                         goto out;
4850                 }
4851
4852                 if (!STm->defined && (mtc.mt_op != MTSETDRVBUFFER && (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
4853                         retval = (-ENXIO);
4854                         goto out;
4855                 }
4856
4857                 if (!STp->pos_unknown) {
4858
4859                         if (STps->eof == ST_FM_HIT) {
4860                                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM|| mtc.mt_op == MTEOM) {
4861                                         mtc.mt_count -= 1;
4862                                         if (STps->drv_file >= 0)
4863                                                 STps->drv_file += 1;
4864                                 }
4865                                 else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
4866                                         mtc.mt_count += 1;
4867                                         if (STps->drv_file >= 0)
4868                                                 STps->drv_file += 1;
4869                                 }
4870                         }
4871
4872                         if (mtc.mt_op == MTSEEK) {
4873                                 /* Old position must be restored if partition will be changed */
4874                                 i = !STp->can_partitions || (STp->new_partition != STp->partition);
4875                         }
4876                         else {
4877                                 i = mtc.mt_op == MTREW   || mtc.mt_op == MTOFFL ||
4878                                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM  ||
4879                                     mtc.mt_op == MTLOCK  || mtc.mt_op == MTLOAD ||
4880                                     mtc.mt_op == MTFSF   || mtc.mt_op == MTFSFM ||
4881                                     mtc.mt_op == MTBSF   || mtc.mt_op == MTBSFM ||
4882                                     mtc.mt_op == MTCOMPRESSION;
4883                         }
4884                         i = osst_flush_buffer(STp, &SRpnt, i);
4885                         if (i < 0) {
4886                                 retval = i;
4887                                 goto out;
4888                         }
4889                 }
4890                 else {
4891                         /*
4892                          * If there was a bus reset, block further access
4893                          * to this device.  If the user wants to rewind the tape,
4894                          * then reset the flag and allow access again.
4895                          */
4896                         if(mtc.mt_op != MTREW   &&
4897                            mtc.mt_op != MTOFFL  &&
4898                            mtc.mt_op != MTRETEN &&
4899                            mtc.mt_op != MTERASE &&
4900                            mtc.mt_op != MTSEEK  &&
4901                            mtc.mt_op != MTEOM)   {
4902                                 retval = (-EIO);
4903                                 goto out;
4904                         }
4905                         reset_state(STp);
4906                         /* remove this when the midlevel properly clears was_reset */
4907                         STp->device->was_reset = 0;
4908                 }
4909
4910                 if (mtc.mt_op != MTCOMPRESSION  && mtc.mt_op != MTLOCK         &&
4911                     mtc.mt_op != MTNOP          && mtc.mt_op != MTSETBLK       &&
4912                     mtc.mt_op != MTSETDENSITY   && mtc.mt_op != MTSETDRVBUFFER &&
4913                     mtc.mt_op != MTMKPART       && mtc.mt_op != MTSETPART      &&
4914                     mtc.mt_op != MTWEOF         && mtc.mt_op != MTWSM           ) {
4915
4916                         /*
4917                          * The user tells us to move to another position on the tape.
4918                          * If we were appending to the tape content, that would leave
4919                          * the tape without proper end, in that case write EOD and
4920                          * update the header to reflect its position.
4921                          */
4922 #if DEBUG
4923                         printk(KERN_WARNING "%s:D: auto_weod %s at ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n", name,
4924                                         STps->rw >= ST_WRITING ? "write" : STps->rw == ST_READING ? "read" : "idle",
4925                                         STp->first_frame_position, STp->eod_frame_ppos, STp->frame_seq_number,
4926                                         STp->logical_blk_num, STps->drv_file, STps->drv_block );
4927 #endif
4928                         if (STps->rw >= ST_WRITING && STp->first_frame_position >= STp->eod_frame_ppos) {
4929                                 auto_weof = ((STp->write_type != OS_WRITE_NEW_MARK) &&
4930                                                         !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
4931                                 i = osst_write_trailer(STp, &SRpnt,
4932                                                         !(mtc.mt_op == MTREW || mtc.mt_op == MTOFFL));
4933 #if DEBUG
4934                                 printk(KERN_WARNING "%s:D: post trailer xeof=%d,ffp=%d,efp=%d,fsn=%d,lbn=%d,fn=%d,bn=%d\n",
4935                                                 name, auto_weof, STp->first_frame_position, STp->eod_frame_ppos,
4936                                                 STp->frame_seq_number, STp->logical_blk_num, STps->drv_file, STps->drv_block );
4937 #endif
4938                                 if (i < 0) {
4939                                         retval = i;
4940                                         goto out;
4941                                 }
4942                         }
4943                         STps->rw = ST_IDLE;
4944                 }
4945
4946                 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
4947                         do_door_lock(STp, 0);  /* Ignore result! */
4948
4949                 if (mtc.mt_op == MTSETDRVBUFFER &&
4950                    (mtc.mt_count & MT_ST_OPTIONS) != 0) {
4951                         retval = osst_set_options(STp, mtc.mt_count);
4952                         goto out;
4953                 }
4954
4955                 if (mtc.mt_op == MTSETPART) {
4956                         if (mtc.mt_count >= STp->nbr_partitions)
4957                                 retval = -EINVAL;
4958                         else {
4959                                 STp->new_partition = mtc.mt_count;
4960                                 retval = 0;
4961                         }
4962                         goto out;
4963                 }
4964
4965                 if (mtc.mt_op == MTMKPART) {
4966                         if (!STp->can_partitions) {
4967                                 retval = (-EINVAL);
4968                                 goto out;
4969                         }
4970                         if ((i = osst_int_ioctl(STp, &SRpnt, MTREW, 0)) < 0 /*||
4971                             (i = partition_tape(inode, mtc.mt_count)) < 0*/) {
4972                                 retval = i;
4973                                 goto out;
4974                         }
4975                         for (i=0; i < ST_NBR_PARTITIONS; i++) {
4976                                 STp->ps[i].rw = ST_IDLE;
4977                                 STp->ps[i].at_sm = 0;
4978                                 STp->ps[i].last_block_valid = 0;
4979                         }
4980                         STp->partition = STp->new_partition = 0;
4981                         STp->nbr_partitions = 1;  /* Bad guess ?-) */
4982                         STps->drv_block = STps->drv_file = 0;
4983                         retval = 0;
4984                         goto out;
4985                 }
4986
4987                 if (mtc.mt_op == MTSEEK) {
4988                         if (STp->raw)
4989                                 i = osst_set_frame_position(STp, &SRpnt, mtc.mt_count, 0);
4990                         else
4991                                 i = osst_seek_sector(STp, &SRpnt, mtc.mt_count);
4992                         if (!STp->can_partitions)
4993                                 STp->ps[0].rw = ST_IDLE;
4994                         retval = i;
4995                         goto out;
4996                 }
4997
4998                 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
4999                         retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
5000                         goto out;
5001                 }
5002
5003                 if (auto_weof)
5004                         cross_eof(STp, &SRpnt, 0);
5005
5006                 if (mtc.mt_op == MTCOMPRESSION)
5007                         retval = -EINVAL;       /* OnStream drives don't have compression hardware */
5008                 else
5009                         /* MTBSF MTBSFM MTBSR MTBSS MTEOM MTERASE MTFSF MTFSFB MTFSR MTFSS
5010                          * MTLOAD MTOFFL MTRESET MTRETEN MTREW MTUNLOAD MTWEOF MTWSM */
5011                         retval = osst_int_ioctl(STp, &SRpnt, mtc.mt_op, mtc.mt_count);
5012                 goto out;
5013         }
5014
5015         if (!STm->defined) {
5016                 retval = (-ENXIO);
5017                 goto out;
5018         }
5019
5020         if ((i = osst_flush_buffer(STp, &SRpnt, 0)) < 0) {
5021                 retval = i;
5022                 goto out;
5023         }
5024
5025         if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
5026                 struct mtget mt_status;
5027
5028                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
5029                          retval = (-EINVAL);
5030                          goto out;
5031                 }
5032
5033                 mt_status.mt_type = MT_ISONSTREAM_SC;
5034                 mt_status.mt_erreg = STp->recover_erreg << MT_ST_SOFTERR_SHIFT;
5035                 mt_status.mt_dsreg =
5036                         ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
5037                         ((STp->density    << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
5038                 mt_status.mt_blkno = STps->drv_block;
5039                 mt_status.mt_fileno = STps->drv_file;
5040                 if (STp->block_size != 0) {
5041                         if (STps->rw == ST_WRITING)
5042                                 mt_status.mt_blkno += (STp->buffer)->buffer_bytes / STp->block_size;
5043                         else if (STps->rw == ST_READING)
5044                                 mt_status.mt_blkno -= ((STp->buffer)->buffer_bytes +
5045                                                         STp->block_size - 1) / STp->block_size;
5046                 }
5047
5048                 mt_status.mt_gstat = 0;
5049                 if (STp->drv_write_prot)
5050                         mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
5051                 if (mt_status.mt_blkno == 0) {
5052                         if (mt_status.mt_fileno == 0)
5053                                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
5054                         else
5055                                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
5056                 }
5057                 mt_status.mt_resid = STp->partition;
5058                 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
5059                         mt_status.mt_gstat |= GMT_EOT(0xffffffff);
5060                 else if (STps->eof >= ST_EOM_OK)
5061                         mt_status.mt_gstat |= GMT_EOD(0xffffffff);
5062                 if (STp->density == 1)
5063                         mt_status.mt_gstat |= GMT_D_800(0xffffffff);
5064                 else if (STp->density == 2)
5065                         mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
5066                 else if (STp->density == 3)
5067                         mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
5068                 if (STp->ready == ST_READY)
5069                         mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
5070                 if (STp->ready == ST_NO_TAPE)
5071                         mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
5072                 if (STps->at_sm)
5073                         mt_status.mt_gstat |= GMT_SM(0xffffffff);
5074                 if (STm->do_async_writes || (STm->do_buffer_writes && STp->block_size != 0) ||
5075                     STp->drv_buffer != 0)
5076                         mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
5077
5078                 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
5079                 if (i) {
5080                         retval = (-EFAULT);
5081                         goto out;
5082                 }
5083
5084                 STp->recover_erreg = 0;  /* Clear after read */
5085                 retval = 0;
5086                 goto out;
5087         } /* End of MTIOCGET */
5088
5089         if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
5090                 struct mtpos mt_pos;
5091
5092                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
5093                         retval = (-EINVAL);
5094                         goto out;
5095                 }
5096                 if (STp->raw)
5097                         blk = osst_get_frame_position(STp, &SRpnt);
5098                 else
5099                         blk = osst_get_sector(STp, &SRpnt);
5100                 if (blk < 0) {
5101                         retval = blk;
5102                         goto out;
5103                 }
5104                 mt_pos.mt_blkno = blk;
5105                 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
5106                 if (i)
5107                         retval = -EFAULT;
5108                 goto out;
5109         }
5110         if (SRpnt) scsi_release_request(SRpnt);
5111
5112         up(&STp->lock);
5113
5114         return scsi_ioctl(STp->device, cmd_in, p);
5115
5116 out:
5117         if (SRpnt) scsi_release_request(SRpnt);
5118
5119         up(&STp->lock);
5120
5121         return retval;
5122 }
5123
5124 #ifdef CONFIG_COMPAT
5125 static long osst_compat_ioctl(struct file * file, unsigned int cmd_in, unsigned long arg)
5126 {
5127         struct osst_tape *STp = file->private_data;
5128         struct scsi_device *sdev = STp->device;
5129         int ret = -ENOIOCTLCMD;
5130         if (sdev->host->hostt->compat_ioctl) {
5131
5132                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd_in, (void __user *)arg);
5133
5134         }
5135         return ret;
5136 }
5137 #endif
5138
5139
5140 \f
5141 /* Memory handling routines */
5142
5143 /* Try to allocate a new tape buffer skeleton. Caller must not hold os_scsi_tapes_lock */
5144 static struct osst_buffer * new_tape_buffer( int from_initialization, int need_dma, int max_sg )
5145 {
5146         int i;
5147         gfp_t priority;
5148         struct osst_buffer *tb;
5149
5150         if (from_initialization)
5151                 priority = GFP_ATOMIC;
5152         else
5153                 priority = GFP_KERNEL;
5154
5155         i = sizeof(struct osst_buffer) + (osst_max_sg_segs - 1) * sizeof(struct scatterlist);
5156         tb = (struct osst_buffer *)kmalloc(i, priority);
5157         if (!tb) {
5158                 printk(KERN_NOTICE "osst :I: Can't allocate new tape buffer.\n");
5159                 return NULL;
5160         }
5161         memset(tb, 0, i);
5162         tb->sg_segs = tb->orig_sg_segs = 0;
5163         tb->use_sg = max_sg;
5164         tb->in_use = 1;
5165         tb->dma = need_dma;
5166         tb->buffer_size = 0;
5167 #if DEBUG
5168         if (debugging)
5169                 printk(OSST_DEB_MSG
5170                         "osst :D: Allocated tape buffer skeleton (%d bytes, %d segments, dma: %d).\n",
5171                            i, max_sg, need_dma);
5172 #endif
5173         return tb;
5174 }
5175
5176 /* Try to allocate a temporary (while a user has the device open) enlarged tape buffer */
5177 static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
5178 {
5179         int segs, nbr, max_segs, b_size, order, got;
5180         gfp_t priority;
5181
5182         if (STbuffer->buffer_size >= OS_FRAME_SIZE)
5183                 return 1;
5184
5185         if (STbuffer->sg_segs) {
5186                 printk(KERN_WARNING "osst :A: Buffer not previously normalized.\n");
5187                 normalize_buffer(STbuffer);
5188         }
5189         /* See how many segments we can use -- need at least two */
5190         nbr = max_segs = STbuffer->use_sg;
5191         if (nbr <= 2)
5192                 return 0;
5193
5194         priority = GFP_KERNEL /* | __GFP_NOWARN */;
5195         if (need_dma)
5196                 priority |= GFP_DMA;
5197
5198         /* Try to allocate the first segment up to OS_DATA_SIZE and the others
5199            big enough to reach the goal (code assumes no segments in place) */
5200         for (b_size = OS_DATA_SIZE, order = OSST_FIRST_ORDER; b_size >= PAGE_SIZE; order--, b_size /= 2) {
5201                 STbuffer->sg[0].page = alloc_pages(priority, order);
5202                 STbuffer->sg[0].offset = 0;
5203                 if (STbuffer->sg[0].page != NULL) {
5204                     STbuffer->sg[0].length = b_size;
5205                     STbuffer->b_data = page_address(STbuffer->sg[0].page);
5206                     break;
5207                 }
5208         }
5209         if (STbuffer->sg[0].page == NULL) {
5210                 printk(KERN_NOTICE "osst :I: Can't allocate tape buffer main segment.\n");
5211                 return 0;
5212         }
5213         /* Got initial segment of 'bsize,order', continue with same size if possible, except for AUX */
5214         for (segs=STbuffer->sg_segs=1, got=b_size;
5215              segs < max_segs && got < OS_FRAME_SIZE; ) {
5216                 STbuffer->sg[segs].page =
5217                                 alloc_pages(priority, (OS_FRAME_SIZE - got <= PAGE_SIZE) ? 0 : order);
5218                 STbuffer->sg[segs].offset = 0;
5219                 if (STbuffer->sg[segs].page == NULL) {
5220                         if (OS_FRAME_SIZE - got <= (max_segs - segs) * b_size / 2 && order) {
5221                                 b_size /= 2;  /* Large enough for the rest of the buffers */
5222                                 order--;
5223                                 continue;
5224                         }
5225                         printk(KERN_WARNING "osst :W: Failed to enlarge buffer to %d bytes.\n",
5226                                                 OS_FRAME_SIZE);
5227 #if DEBUG
5228                         STbuffer->buffer_size = got;
5229 #endif
5230                         normalize_buffer(STbuffer);
5231                         return 0;
5232                 }
5233                 STbuffer->sg[segs].length = (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size;
5234                 got += STbuffer->sg[segs].length;
5235                 STbuffer->buffer_size = got;
5236                 STbuffer->sg_segs = ++segs;
5237         }
5238 #if DEBUG
5239         if (debugging) {
5240                 printk(OSST_DEB_MSG
5241                            "osst :D: Expanded tape buffer (%d bytes, %d->%d segments, dma: %d, at: %p).\n",
5242                            got, STbuffer->orig_sg_segs, STbuffer->sg_segs, need_dma, STbuffer->b_data);
5243                 printk(OSST_DEB_MSG
5244                            "osst :D: segment sizes: first %d at %p, last %d bytes at %p.\n",
5245                            STbuffer->sg[0].length, page_address(STbuffer->sg[0].page),
5246                            STbuffer->sg[segs-1].length, page_address(STbuffer->sg[segs-1].page));
5247         }
5248 #endif
5249
5250         return 1;
5251 }
5252
5253
5254 /* Release the segments */
5255 static void normalize_buffer(struct osst_buffer *STbuffer)
5256 {
5257   int i, order, b_size;
5258
5259         for (i=0; i < STbuffer->sg_segs; i++) {
5260
5261                 for (b_size = PAGE_SIZE, order = 0;
5262                      b_size < STbuffer->sg[i].length;
5263                      b_size *= 2, order++);
5264
5265                 __free_pages(STbuffer->sg[i].page, order);
5266                 STbuffer->buffer_size -= STbuffer->sg[i].length;
5267         }
5268 #if DEBUG
5269         if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs)
5270                 printk(OSST_DEB_MSG "osst :D: Buffer at %p normalized to %d bytes (segs %d).\n",
5271                              STbuffer->b_data, STbuffer->buffer_size, STbuffer->sg_segs);
5272 #endif
5273         STbuffer->sg_segs = STbuffer->orig_sg_segs = 0;
5274 }
5275
5276
5277 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
5278    negative error code. */
5279 static int append_to_buffer(const char __user *ubp, struct osst_buffer *st_bp, int do_count)
5280 {
5281         int i, cnt, res, offset;
5282
5283         for (i=0, offset=st_bp->buffer_bytes;
5284              i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5285         offset -= st_bp->sg[i].length;
5286         if (i == st_bp->sg_segs) {  /* Should never happen */
5287                 printk(KERN_WARNING "osst :A: Append_to_buffer offset overflow.\n");
5288                 return (-EIO);
5289         }
5290         for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
5291                 cnt = st_bp->sg[i].length - offset < do_count ?
5292                       st_bp->sg[i].length - offset : do_count;
5293                 res = copy_from_user(page_address(st_bp->sg[i].page) + offset, ubp, cnt);
5294                 if (res)
5295                         return (-EFAULT);
5296                 do_count -= cnt;
5297                 st_bp->buffer_bytes += cnt;
5298                 ubp += cnt;
5299                 offset = 0;
5300         }
5301         if (do_count) {  /* Should never happen */
5302                 printk(KERN_WARNING "osst :A: Append_to_buffer overflow (left %d).\n",
5303                        do_count);
5304                 return (-EIO);
5305         }
5306         return 0;
5307 }
5308
5309
5310 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
5311    negative error code. */
5312 static int from_buffer(struct osst_buffer *st_bp, char __user *ubp, int do_count)
5313 {
5314         int i, cnt, res, offset;
5315
5316         for (i=0, offset=st_bp->read_pointer;
5317              i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5318                 offset -= st_bp->sg[i].length;
5319         if (i == st_bp->sg_segs) {  /* Should never happen */
5320                 printk(KERN_WARNING "osst :A: From_buffer offset overflow.\n");
5321                 return (-EIO);
5322         }
5323         for ( ; i < st_bp->sg_segs && do_count > 0; i++) {
5324                 cnt = st_bp->sg[i].length - offset < do_count ?
5325                       st_bp->sg[i].length - offset : do_count;
5326                 res = copy_to_user(ubp, page_address(st_bp->sg[i].page) + offset, cnt);
5327                 if (res)
5328                         return (-EFAULT);
5329                 do_count -= cnt;
5330                 st_bp->buffer_bytes -= cnt;
5331                 st_bp->read_pointer += cnt;
5332                 ubp += cnt;
5333                 offset = 0;
5334         }
5335         if (do_count) {  /* Should never happen */
5336                 printk(KERN_WARNING "osst :A: From_buffer overflow (left %d).\n", do_count);
5337                 return (-EIO);
5338         }
5339         return 0;
5340 }
5341
5342 /* Sets the tail of the buffer after fill point to zero.
5343    Returns zero (success) or negative error code.        */
5344 static int osst_zero_buffer_tail(struct osst_buffer *st_bp)
5345 {
5346         int     i, offset, do_count, cnt;
5347
5348         for (i = 0, offset = st_bp->buffer_bytes;
5349              i < st_bp->sg_segs && offset >= st_bp->sg[i].length; i++)
5350                 offset -= st_bp->sg[i].length;
5351         if (i == st_bp->sg_segs) {  /* Should never happen */
5352                 printk(KERN_WARNING "osst :A: Zero_buffer offset overflow.\n");
5353                 return (-EIO);
5354         }
5355         for (do_count = OS_DATA_SIZE - st_bp->buffer_bytes;
5356              i < st_bp->sg_segs && do_count > 0; i++) {
5357                 cnt = st_bp->sg[i].length - offset < do_count ?
5358                       st_bp->sg[i].length - offset : do_count ;
5359                 memset(page_address(st_bp->sg[i].page) + offset, 0, cnt);
5360                 do_count -= cnt;
5361                 offset = 0;
5362         }
5363         if (do_count) {  /* Should never happen */
5364                 printk(KERN_WARNING "osst :A: Zero_buffer overflow (left %d).\n", do_count);
5365                 return (-EIO);
5366         }
5367         return 0;
5368 }
5369
5370 /* Copy a osst 32K chunk of memory into the buffer.
5371    Returns zero (success) or negative error code.  */
5372 static int osst_copy_to_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
5373 {
5374         int     i, cnt, do_count = OS_DATA_SIZE;
5375
5376         for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
5377                 cnt = st_bp->sg[i].length < do_count ?
5378                       st_bp->sg[i].length : do_count ;
5379                 memcpy(page_address(st_bp->sg[i].page), ptr, cnt);
5380                 do_count -= cnt;
5381                 ptr      += cnt;
5382         }
5383         if (do_count || i != st_bp->sg_segs-1) {  /* Should never happen */
5384                 printk(KERN_WARNING "osst :A: Copy_to_buffer overflow (left %d at sg %d).\n",
5385                                          do_count, i);
5386                 return (-EIO);
5387         }
5388         return 0;
5389 }
5390
5391 /* Copy a osst 32K chunk of memory from the buffer.
5392    Returns zero (success) or negative error code.  */
5393 static int osst_copy_from_buffer(struct osst_buffer *st_bp, unsigned char *ptr)
5394 {
5395         int     i, cnt, do_count = OS_DATA_SIZE;
5396
5397         for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) {
5398                 cnt = st_bp->sg[i].length < do_count ?
5399                       st_bp->sg[i].length : do_count ;
5400                 memcpy(ptr, page_address(st_bp->sg[i].page), cnt);
5401                 do_count -= cnt;
5402                 ptr      += cnt;
5403         }
5404         if (do_count || i != st_bp->sg_segs-1) {  /* Should never happen */
5405                 printk(KERN_WARNING "osst :A: Copy_from_buffer overflow (left %d at sg %d).\n",
5406                                          do_count, i);
5407                 return (-EIO);
5408         }
5409         return 0;
5410 }
5411
5412 \f
5413 /* Module housekeeping */
5414
5415 static void validate_options (void)
5416 {
5417   if (max_dev > 0)
5418                 osst_max_dev = max_dev;
5419   if (write_threshold_kbs > 0)
5420                 osst_write_threshold = write_threshold_kbs * ST_KILOBYTE;
5421   if (osst_write_threshold > osst_buffer_size)
5422                 osst_write_threshold = osst_buffer_size;
5423   if (max_sg_segs >= OSST_FIRST_SG)
5424                 osst_max_sg_segs = max_sg_segs;
5425 #if DEBUG
5426   printk(OSST_DEB_MSG "osst :D: max tapes %d, write threshold %d, max s/g segs %d.\n",
5427                            osst_max_dev, osst_write_threshold, osst_max_sg_segs);
5428 #endif
5429 }
5430
5431 #ifndef MODULE
5432 /* Set the boot options. Syntax: osst=xxx,yyy,...
5433    where xxx is write threshold in 1024 byte blocks,
5434    and   yyy is number of s/g segments to use. */
5435 static int __init osst_setup (char *str)
5436 {
5437   int i, ints[5];
5438   char *stp;
5439
5440   stp = get_options(str, ARRAY_SIZE(ints), ints);
5441
5442   if (ints[0] > 0) {
5443         for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
5444                   *parms[i].val = ints[i + 1];
5445   } else {
5446         while (stp != NULL) {
5447                 for (i = 0; i < ARRAY_SIZE(parms); i++) {
5448                         int len = strlen(parms[i].name);
5449                         if (!strncmp(stp, parms[i].name, len) &&
5450                             (*(stp + len) == ':' || *(stp + len) == '=')) {
5451                                 *parms[i].val =
5452                                         simple_strtoul(stp + len + 1, NULL, 0);
5453                                 break;
5454                         }
5455                 }
5456                 if (i >= sizeof(parms) / sizeof(struct osst_dev_parm))
5457                         printk(KERN_INFO "osst :I: Illegal parameter in '%s'\n",
5458                                stp);
5459                 stp = strchr(stp, ',');
5460                 if (stp)
5461                         stp++;
5462         }
5463   }
5464
5465   return 1;
5466 }
5467
5468 __setup("osst=", osst_setup);
5469
5470 #endif
5471
5472 static struct file_operations osst_fops = {
5473         .owner =        THIS_MODULE,
5474         .read =         osst_read,
5475         .write =        osst_write,
5476         .ioctl =        osst_ioctl,
5477 #ifdef CONFIG_COMPAT
5478         .compat_ioctl = osst_compat_ioctl,
5479 #endif
5480         .open =         os_scsi_tape_open,
5481         .flush =        os_scsi_tape_flush,
5482         .release =      os_scsi_tape_close,
5483 };
5484
5485 static int osst_supports(struct scsi_device * SDp)
5486 {
5487         struct  osst_support_data {
5488                 char *vendor;
5489                 char *model;
5490                 char *rev;
5491                 char *driver_hint; /* Name of the correct driver, NULL if unknown */
5492         };
5493
5494 static  struct  osst_support_data support_list[] = {
5495                 /* {"XXX", "Yy-", "", NULL},  example */
5496                 SIGS_FROM_OSST,
5497                 {NULL, }};
5498
5499         struct  osst_support_data *rp;
5500
5501         /* We are willing to drive OnStream SC-x0 as well as the
5502          *       * IDE, ParPort, FireWire, USB variants, if accessible by
5503          *               * emulation layer (ide-scsi, usb-storage, ...) */
5504
5505         for (rp=&(support_list[0]); rp->vendor != NULL; rp++)
5506                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
5507                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
5508                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev)))
5509                         return 1;
5510         return 0;
5511 }
5512
5513 /*
5514  * sysfs support for osst driver parameter information
5515  */
5516
5517 static ssize_t osst_version_show(struct device_driver *ddd, char *buf)
5518 {
5519         return snprintf(buf, PAGE_SIZE, "%s\n", osst_version);
5520 }
5521
5522 static DRIVER_ATTR(version, S_IRUGO, osst_version_show, NULL);
5523
5524 static void osst_create_driverfs_files(struct device_driver *driverfs)
5525 {
5526         driver_create_file(driverfs, &driver_attr_version);
5527 }
5528
5529 static void osst_remove_driverfs_files(struct device_driver *driverfs)
5530 {
5531         driver_remove_file(driverfs, &driver_attr_version);
5532 }
5533
5534 /*
5535  * sysfs support for accessing ADR header information
5536  */
5537
5538 static ssize_t osst_adr_rev_show(struct class_device *class_dev, char *buf)
5539 {
5540         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5541         ssize_t l = 0;
5542
5543         if (STp && STp->header_ok && STp->linux_media)
5544                 l = snprintf(buf, PAGE_SIZE, "%d.%d\n", STp->header_cache->major_rev, STp->header_cache->minor_rev);
5545         return l;
5546 }
5547
5548 CLASS_DEVICE_ATTR(ADR_rev, S_IRUGO, osst_adr_rev_show, NULL);
5549
5550 static ssize_t osst_linux_media_version_show(struct class_device *class_dev, char *buf)
5551 {
5552         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5553         ssize_t l = 0;
5554
5555         if (STp && STp->header_ok && STp->linux_media)
5556                 l = snprintf(buf, PAGE_SIZE, "LIN%d\n", STp->linux_media_version);
5557         return l;
5558 }
5559
5560 CLASS_DEVICE_ATTR(media_version, S_IRUGO, osst_linux_media_version_show, NULL);
5561
5562 static ssize_t osst_capacity_show(struct class_device *class_dev, char *buf)
5563 {
5564         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5565         ssize_t l = 0;
5566
5567         if (STp && STp->header_ok && STp->linux_media)
5568                 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->capacity);
5569         return l;
5570 }
5571
5572 CLASS_DEVICE_ATTR(capacity, S_IRUGO, osst_capacity_show, NULL);
5573
5574 static ssize_t osst_first_data_ppos_show(struct class_device *class_dev, char *buf)
5575 {
5576         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5577         ssize_t l = 0;
5578
5579         if (STp && STp->header_ok && STp->linux_media)
5580                 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->first_data_ppos);
5581         return l;
5582 }
5583
5584 CLASS_DEVICE_ATTR(BOT_frame, S_IRUGO, osst_first_data_ppos_show, NULL);
5585
5586 static ssize_t osst_eod_frame_ppos_show(struct class_device *class_dev, char *buf)
5587 {
5588         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5589         ssize_t l = 0;
5590
5591         if (STp && STp->header_ok && STp->linux_media)
5592                 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->eod_frame_ppos);
5593         return l;
5594 }
5595
5596 CLASS_DEVICE_ATTR(EOD_frame, S_IRUGO, osst_eod_frame_ppos_show, NULL);
5597
5598 static ssize_t osst_filemark_cnt_show(struct class_device *class_dev, char *buf)
5599 {
5600         struct osst_tape * STp = (struct osst_tape *) class_get_devdata (class_dev);
5601         ssize_t l = 0;
5602
5603         if (STp && STp->header_ok && STp->linux_media)
5604                 l = snprintf(buf, PAGE_SIZE, "%d\n", STp->filemark_cnt);
5605         return l;
5606 }
5607
5608 CLASS_DEVICE_ATTR(file_count, S_IRUGO, osst_filemark_cnt_show, NULL);
5609
5610 static struct class *osst_sysfs_class;
5611
5612 static int osst_sysfs_valid = 0;
5613
5614 static void osst_sysfs_init(void)
5615 {
5616         osst_sysfs_class = class_create(THIS_MODULE, "onstream_tape");
5617         if ( IS_ERR(osst_sysfs_class) )
5618                 printk(KERN_WARNING "osst :W: Unable to register sysfs class\n");
5619         else
5620                 osst_sysfs_valid = 1;
5621 }
5622
5623 static void osst_sysfs_add(dev_t dev, struct device *device, struct osst_tape * STp, char * name)
5624 {
5625         struct class_device *osst_class_member;
5626
5627         if (!osst_sysfs_valid) return;
5628
5629         osst_class_member = class_device_create(osst_sysfs_class, NULL, dev, device, "%s", name);
5630         if (IS_ERR(osst_class_member)) {
5631                 printk(KERN_WARNING "osst :W: Unable to add sysfs class member %s\n", name);
5632                 return;
5633         }
5634         class_set_devdata(osst_class_member, STp);
5635         class_device_create_file(osst_class_member, &class_device_attr_ADR_rev);
5636         class_device_create_file(osst_class_member, &class_device_attr_media_version);
5637         class_device_create_file(osst_class_member, &class_device_attr_capacity);
5638         class_device_create_file(osst_class_member, &class_device_attr_BOT_frame);
5639         class_device_create_file(osst_class_member, &class_device_attr_EOD_frame);
5640         class_device_create_file(osst_class_member, &class_device_attr_file_count);
5641 }
5642
5643 static void osst_sysfs_destroy(dev_t dev)
5644 {
5645         if (!osst_sysfs_valid) return;
5646
5647         class_device_destroy(osst_sysfs_class, dev);
5648 }
5649
5650 static void osst_sysfs_cleanup(void)
5651 {
5652         if (osst_sysfs_valid) {
5653                 class_destroy(osst_sysfs_class);
5654                 osst_sysfs_valid = 0;
5655         }
5656 }
5657
5658 /*
5659  * osst startup / cleanup code
5660  */
5661
5662 static int osst_probe(struct device *dev)
5663 {
5664         struct scsi_device * SDp = to_scsi_device(dev);
5665         struct osst_tape   * tpnt;
5666         struct st_modedef  * STm;
5667         struct st_partstat * STps;
5668         struct osst_buffer * buffer;
5669         struct gendisk     * drive;
5670         int                  i, mode, dev_num;
5671
5672         if (SDp->type != TYPE_TAPE || !osst_supports(SDp))
5673                 return -ENODEV;
5674
5675         drive = alloc_disk(1);
5676         if (!drive) {
5677                 printk(KERN_ERR "osst :E: Out of memory. Device not attached.\n");
5678                 return -ENODEV;
5679         }
5680
5681         /* if this is the first attach, build the infrastructure */
5682         write_lock(&os_scsi_tapes_lock);
5683         if (os_scsi_tapes == NULL) {
5684                 os_scsi_tapes =
5685                         (struct osst_tape **)kmalloc(osst_max_dev * sizeof(struct osst_tape *),
5686                                    GFP_ATOMIC);
5687                 if (os_scsi_tapes == NULL) {
5688                         write_unlock(&os_scsi_tapes_lock);
5689                         printk(KERN_ERR "osst :E: Unable to allocate array for OnStream SCSI tapes.\n");
5690                         goto out_put_disk;
5691                 }
5692                 for (i=0; i < osst_max_dev; ++i) os_scsi_tapes[i] = NULL;
5693         }
5694
5695         if (osst_nr_dev >= osst_max_dev) {
5696                 write_unlock(&os_scsi_tapes_lock);
5697                 printk(KERN_ERR "osst :E: Too many tape devices (max. %d).\n", osst_max_dev);
5698                 goto out_put_disk;
5699         }
5700
5701         /* find a free minor number */
5702         for (i=0; os_scsi_tapes[i] && i<osst_max_dev; i++);
5703         if(i >= osst_max_dev) panic ("Scsi_devices corrupt (osst)");
5704         dev_num = i;
5705
5706         /* allocate a struct osst_tape for this device */
5707         tpnt = (struct osst_tape *)kmalloc(sizeof(struct osst_tape), GFP_ATOMIC);
5708         if (tpnt == NULL) {
5709                 write_unlock(&os_scsi_tapes_lock);
5710                 printk(KERN_ERR "osst :E: Can't allocate device descriptor, device not attached.\n");
5711                 goto out_put_disk;
5712         }
5713         memset(tpnt, 0, sizeof(struct osst_tape));
5714
5715         /* allocate a buffer for this device */
5716         i = SDp->host->sg_tablesize;
5717         if (osst_max_sg_segs < i)
5718                 i = osst_max_sg_segs;
5719         buffer = new_tape_buffer(1, SDp->host->unchecked_isa_dma, i);
5720         if (buffer == NULL) {
5721                 write_unlock(&os_scsi_tapes_lock);
5722                 printk(KERN_ERR "osst :E: Unable to allocate a tape buffer, device not attached.\n");
5723                 kfree(tpnt);
5724                 goto out_put_disk;
5725         }
5726         os_scsi_tapes[dev_num] = tpnt;
5727         tpnt->buffer = buffer;
5728         tpnt->device = SDp;
5729         drive->private_data = &tpnt->driver;
5730         sprintf(drive->disk_name, "osst%d", dev_num);
5731         tpnt->driver = &osst_template;
5732         tpnt->drive = drive;
5733         tpnt->in_use = 0;
5734         tpnt->capacity = 0xfffff;
5735         tpnt->dirty = 0;
5736         tpnt->drv_buffer = 1;  /* Try buffering if no mode sense */
5737         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
5738         tpnt->density = 0;
5739         tpnt->do_auto_lock = OSST_AUTO_LOCK;
5740         tpnt->can_bsr = OSST_IN_FILE_POS;
5741         tpnt->can_partitions = 0;
5742         tpnt->two_fm = OSST_TWO_FM;
5743         tpnt->fast_mteom = OSST_FAST_MTEOM;
5744         tpnt->scsi2_logical = OSST_SCSI2LOGICAL; /* FIXME */
5745         tpnt->write_threshold = osst_write_threshold;
5746         tpnt->default_drvbuffer = 0xff; /* No forced buffering */
5747         tpnt->partition = 0;
5748         tpnt->new_partition = 0;
5749         tpnt->nbr_partitions = 0;
5750         tpnt->min_block = 512;
5751         tpnt->max_block = OS_DATA_SIZE;
5752         tpnt->timeout = OSST_TIMEOUT;
5753         tpnt->long_timeout = OSST_LONG_TIMEOUT;
5754
5755         /* Recognize OnStream tapes */
5756         /* We don't need to test for OnStream, as this has been done in detect () */
5757         tpnt->os_fw_rev = osst_parse_firmware_rev (SDp->rev);
5758         tpnt->omit_blklims = 1;
5759
5760         tpnt->poll = (strncmp(SDp->model, "DI-", 3) == 0) ||
5761                      (strncmp(SDp->model, "FW-", 3) == 0) || OSST_FW_NEED_POLL(tpnt->os_fw_rev,SDp);
5762         tpnt->frame_in_buffer = 0;
5763         tpnt->header_ok = 0;
5764         tpnt->linux_media = 0;
5765         tpnt->header_cache = NULL;
5766
5767         for (i=0; i < ST_NBR_MODES; i++) {
5768                 STm = &(tpnt->modes[i]);
5769                 STm->defined = 0;
5770                 STm->sysv = OSST_SYSV;
5771                 STm->defaults_for_writes = 0;
5772                 STm->do_async_writes = OSST_ASYNC_WRITES;
5773                 STm->do_buffer_writes = OSST_BUFFER_WRITES;
5774                 STm->do_read_ahead = OSST_READ_AHEAD;
5775                 STm->default_compression = ST_DONT_TOUCH;
5776                 STm->default_blksize = 512;
5777                 STm->default_density = (-1);  /* No forced density */
5778         }
5779
5780         for (i=0; i < ST_NBR_PARTITIONS; i++) {
5781                 STps = &(tpnt->ps[i]);
5782                 STps->rw = ST_IDLE;
5783                 STps->eof = ST_NOEOF;
5784                 STps->at_sm = 0;
5785                 STps->last_block_valid = 0;
5786                 STps->drv_block = (-1);
5787                 STps->drv_file = (-1);
5788         }
5789
5790         tpnt->current_mode = 0;
5791         tpnt->modes[0].defined = 1;
5792         tpnt->modes[2].defined = 1;
5793         tpnt->density_changed = tpnt->compression_changed = tpnt->blksize_changed = 0;
5794
5795         init_MUTEX(&tpnt->lock);
5796         osst_nr_dev++;
5797         write_unlock(&os_scsi_tapes_lock);
5798         {
5799                 char name[8];
5800                 /*  Rewind entry  */
5801                 osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num), dev, tpnt, tape_name(tpnt));
5802                 /*  No-rewind entry  */
5803                 snprintf(name, 8, "%s%s", "n", tape_name(tpnt));
5804                 osst_sysfs_add(MKDEV(OSST_MAJOR, dev_num + 128), dev, tpnt, name);
5805         }
5806         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
5807                 /*  Rewind entry  */
5808                 devfs_mk_cdev(MKDEV(OSST_MAJOR, dev_num + (mode << 5)),
5809                                 S_IFCHR | S_IRUGO | S_IWUGO,
5810                                 "%s/ot%s", SDp->devfs_name, osst_formats[mode]);
5811
5812                 /*  No-rewind entry  */
5813                 devfs_mk_cdev(MKDEV(OSST_MAJOR, dev_num + (mode << 5) + 128),
5814                                 S_IFCHR | S_IRUGO | S_IWUGO,
5815                                 "%s/ot%sn", SDp->devfs_name, osst_formats[mode]);
5816         }
5817         drive->number = devfs_register_tape(SDp->devfs_name);
5818
5819         sdev_printk(KERN_INFO, SDp,
5820                 "osst :I: Attached OnStream %.5s tape as %s\n",
5821                 SDp->model, tape_name(tpnt));
5822
5823         return 0;
5824
5825 out_put_disk:
5826         put_disk(drive);
5827         return -ENODEV;
5828 };
5829
5830 static int osst_remove(struct device *dev)
5831 {
5832         struct scsi_device * SDp = to_scsi_device(dev);
5833         struct osst_tape * tpnt;
5834         int i, mode;
5835
5836         if ((SDp->type != TYPE_TAPE) || (osst_nr_dev <= 0))
5837                 return 0;
5838
5839         write_lock(&os_scsi_tapes_lock);
5840         for(i=0; i < osst_max_dev; i++) {
5841                 if((tpnt = os_scsi_tapes[i]) && (tpnt->device == SDp)) {
5842                         osst_sysfs_destroy(MKDEV(OSST_MAJOR, i));
5843                         osst_sysfs_destroy(MKDEV(OSST_MAJOR, i+128));
5844                         tpnt->device = NULL;
5845                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
5846                                 devfs_remove("%s/ot%s", SDp->devfs_name, osst_formats[mode]);
5847                                 devfs_remove("%s/ot%sn", SDp->devfs_name, osst_formats[mode]);
5848                         }
5849                         devfs_unregister_tape(tpnt->drive->number);
5850                         put_disk(tpnt->drive);
5851                         os_scsi_tapes[i] = NULL;
5852                         osst_nr_dev--;
5853                         write_unlock(&os_scsi_tapes_lock);
5854                         vfree(tpnt->header_cache);
5855                         if (tpnt->buffer) {
5856                                 normalize_buffer(tpnt->buffer);
5857                                 kfree(tpnt->buffer);
5858                         }
5859                         kfree(tpnt);
5860                         return 0;
5861                 }
5862         }
5863         write_unlock(&os_scsi_tapes_lock);
5864         return 0;
5865 }
5866
5867 static int __init init_osst(void)
5868 {
5869         printk(KERN_INFO "osst :I: Tape driver with OnStream support version %s\nosst :I: %s\n", osst_version, cvsid);
5870
5871         validate_options();
5872         osst_sysfs_init();
5873
5874         if ((register_chrdev(OSST_MAJOR,"osst", &osst_fops) < 0) || scsi_register_driver(&osst_template.gendrv)) {
5875                 printk(KERN_ERR "osst :E: Unable to register major %d for OnStream tapes\n", OSST_MAJOR);
5876                 osst_sysfs_cleanup();
5877                 return 1;
5878         }
5879         osst_create_driverfs_files(&osst_template.gendrv);
5880
5881         return 0;
5882 }
5883
5884 static void __exit exit_osst (void)
5885 {
5886         int i;
5887         struct osst_tape * STp;
5888
5889         osst_remove_driverfs_files(&osst_template.gendrv);
5890         scsi_unregister_driver(&osst_template.gendrv);
5891         unregister_chrdev(OSST_MAJOR, "osst");
5892         osst_sysfs_cleanup();
5893
5894         if (os_scsi_tapes) {
5895                 for (i=0; i < osst_max_dev; ++i) {
5896                         if (!(STp = os_scsi_tapes[i])) continue;
5897                         /* This is defensive, supposed to happen during detach */
5898                         vfree(STp->header_cache);
5899                         if (STp->buffer) {
5900                                 normalize_buffer(STp->buffer);
5901                                 kfree(STp->buffer);
5902                         }
5903                         put_disk(STp->drive);
5904                         kfree(STp);
5905                 }
5906                 kfree(os_scsi_tapes);
5907         }
5908         printk(KERN_INFO "osst :I: Unloaded.\n");
5909 }
5910
5911 module_init(init_osst);
5912 module_exit(exit_osst);