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