drivers/scsi/st.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    Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
   7    Contribution and ideas from several people including (in alphabetical
   8    order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
   9    Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
  10    Michael Schaefer, J"org Weule, and Eric Youngdale.
  11
  12    Copyright 1992 - 2010 Kai Makisara
  13    email Kai.Makisara@kolumbus.fi
  14
  15    Some small formal changes - aeb, 950809
  16
  17    Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
  18  */
  19
  20 static const char *verstr = "20101219";
  21
  22 #include <linux/module.h>
  23
  24 #include <linux/fs.h>
  25 #include <linux/kernel.h>
  26 #include <linux/sched.h>
  27 #include <linux/mm.h>
  28 #include <linux/init.h>
  29 #include <linux/string.h>
  30 #include <linux/slab.h>
  31 #include <linux/errno.h>
  32 #include <linux/mtio.h>
  33 #include <linux/cdrom.h>
  34 #include <linux/ioctl.h>
  35 #include <linux/fcntl.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/blkdev.h>
  38 #include <linux/moduleparam.h>
  39 #include <linux/cdev.h>
  40 #include <linux/delay.h>
  41 #include <linux/mutex.h>
  42
  43 #include <asm/uaccess.h>
  44 #include <asm/dma.h>
  45
  46 #include <scsi/scsi.h>
  47 #include <scsi/scsi_dbg.h>
  48 #include <scsi/scsi_device.h>
  49 #include <scsi/scsi_driver.h>
  50 #include <scsi/scsi_eh.h>
  51 #include <scsi/scsi_host.h>
  52 #include <scsi/scsi_ioctl.h>
  53 #include <scsi/sg.h>
  54
  55
  56 /* The driver prints some debugging information on the console if DEBUG
  57    is defined and non-zero. */
  58 #define DEBUG 0
  59
  60 #if DEBUG
  61 /* The message level for the debug messages is currently set to KERN_NOTICE
  62    so that people can easily see the messages. Later when the debugging messages
  63    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
  64 #define ST_DEB_MSG  KERN_NOTICE
  65 #define DEB(a) a
  66 #define DEBC(a) if (debugging) { a ; }
  67 #else
  68 #define DEB(a)
  69 #define DEBC(a)
  70 #endif
  71
  72 #define ST_KILOBYTE 1024
  73
  74 #include "st_options.h"
  75 #include "st.h"
  76
  77 static DEFINE_MUTEX(st_mutex);
  78 static int buffer_kbs;
  79 static int max_sg_segs;
  80 static int try_direct_io = TRY_DIRECT_IO;
  81 static int try_rdio = 1;
  82 static int try_wdio = 1;
  83
  84 static int st_dev_max;
  85 static int st_nr_dev;
  86
  87 static struct class *st_sysfs_class;
  88
  89 MODULE_AUTHOR("Kai Makisara");
  90 MODULE_DESCRIPTION("SCSI tape (st) driver");
  91 MODULE_LICENSE("GPL");
  92 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
  93 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
  94
  95 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
  96  * of sysfs parameters (which module_param doesn't yet support).
  97  * Sysfs parameters defined explicitly later.
  98  */
  99 module_param_named(buffer_kbs, buffer_kbs, int, 0);
 100 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
 101 module_param_named(max_sg_segs, max_sg_segs, int, 0);
 102 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 103 module_param_named(try_direct_io, try_direct_io, int, 0);
 104 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
 105
 106 /* Extra parameters for testing */
 107 module_param_named(try_rdio, try_rdio, int, 0);
 108 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
 109 module_param_named(try_wdio, try_wdio, int, 0);
 110 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
 111
 112 #ifndef MODULE
 113 static int write_threshold_kbs;  /* retained for compatibility */
 114 static struct st_dev_parm {
 115         char *name;
 116         int *val;
 117 } parms[] __initdata = {
 118         {
 119                 "buffer_kbs", &buffer_kbs
 120         },
 121         {       /* Retained for compatibility with 2.4 */
 122                 "write_threshold_kbs", &write_threshold_kbs
 123         },
 124         {
 125                 "max_sg_segs", NULL
 126         },
 127         {
 128                 "try_direct_io", &try_direct_io
 129         }
 130 };
 131 #endif
 132
 133 /* Restrict the number of modes so that names for all are assigned */
 134 #if ST_NBR_MODES > 16
 135 #error "Maximum number of modes is 16"
 136 #endif
 137 /* Bit reversed order to get same names for same minors with all
 138    mode counts */
 139 static const char *st_formats[] = {
 140         "",  "r", "k", "s", "l", "t", "o", "u",
 141         "m", "v", "p", "x", "a", "y", "q", "z"};
 142
 143 /* The default definitions have been moved to st_options.h */
 144
 145 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
 146
 147 /* The buffer size should fit into the 24 bits for length in the
 148    6-byte SCSI read and write commands. */
 149 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
 150 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 151 #endif
 152
 153 static int debugging = DEBUG;
 154
 155 #define MAX_RETRIES 0
 156 #define MAX_WRITE_RETRIES 0
 157 #define MAX_READY_RETRIES 0
 158 #define NO_TAPE  NOT_READY
 159
 160 #define ST_TIMEOUT (900 * HZ)
 161 #define ST_LONG_TIMEOUT (14000 * HZ)
 162
 163 /* Remove mode bits and auto-rewind bit (7) */
 164 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
 165     (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
 166 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 167
 168 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
 169 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
 170   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
 171
 172 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 173    24 bits) */
 174 #define SET_DENS_AND_BLK 0x10001
 175
 176 static DEFINE_RWLOCK(st_dev_arr_lock);
 177
 178 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
 179 static int st_max_sg_segs = ST_MAX_SG;
 180
 181 static struct scsi_tape **scsi_tapes = NULL;
 182
 183 static int modes_defined;
 184
 185 static int enlarge_buffer(struct st_buffer *, int, int);
 186 static void clear_buffer(struct st_buffer *);
 187 static void normalize_buffer(struct st_buffer *);
 188 static int append_to_buffer(const char __user *, struct st_buffer *, int);
 189 static int from_buffer(struct st_buffer *, char __user *, int);
 190 static void move_buffer_data(struct st_buffer *, int);
 191
 192 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
 193                               unsigned long, size_t, int);
 194 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
 195
 196 static int st_probe(struct device *);
 197 static int st_remove(struct device *);
 198
 199 static int do_create_sysfs_files(void);
 200 static void do_remove_sysfs_files(void);
 201 static int do_create_class_files(struct scsi_tape *, int, int);
 202
 203 static struct scsi_driver st_template = {
 204         .owner                  = THIS_MODULE,
 205         .gendrv = {
 206                 .name           = "st",
 207                 .probe          = st_probe,
 208                 .remove         = st_remove,
 209         },
 210 };
 211
 212 static int st_compression(struct scsi_tape *, int);
 213
 214 static int find_partition(struct scsi_tape *);
 215 static int switch_partition(struct scsi_tape *);
 216
 217 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
 218
 219 static void scsi_tape_release(struct kref *);
 220
 221 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 222
 223 static DEFINE_MUTEX(st_ref_mutex);
 224
 225 \f
 226 #include "osst_detect.h"
 227 #ifndef SIGS_FROM_OSST
 228 #define SIGS_FROM_OSST \
 229         {"OnStream", "SC-", "", "osst"}, \
 230         {"OnStream", "DI-", "", "osst"}, \
 231         {"OnStream", "DP-", "", "osst"}, \
 232         {"OnStream", "USB", "", "osst"}, \
 233         {"OnStream", "FW-", "", "osst"}
 234 #endif
 235
 236 static struct scsi_tape *scsi_tape_get(int dev)
 237 {
 238         struct scsi_tape *STp = NULL;
 239
 240         mutex_lock(&st_ref_mutex);
 241         write_lock(&st_dev_arr_lock);
 242
 243         if (dev < st_dev_max && scsi_tapes != NULL)
 244                 STp = scsi_tapes[dev];
 245         if (!STp) goto out;
 246
 247         kref_get(&STp->kref);
 248
 249         if (!STp->device)
 250                 goto out_put;
 251
 252         if (scsi_device_get(STp->device))
 253                 goto out_put;
 254
 255         goto out;
 256
 257 out_put:
 258         kref_put(&STp->kref, scsi_tape_release);
 259         STp = NULL;
 260 out:
 261         write_unlock(&st_dev_arr_lock);
 262         mutex_unlock(&st_ref_mutex);
 263         return STp;
 264 }
 265
 266 static void scsi_tape_put(struct scsi_tape *STp)
 267 {
 268         struct scsi_device *sdev = STp->device;
 269
 270         mutex_lock(&st_ref_mutex);
 271         kref_put(&STp->kref, scsi_tape_release);
 272         scsi_device_put(sdev);
 273         mutex_unlock(&st_ref_mutex);
 274 }
 275
 276 struct st_reject_data {
 277         char *vendor;
 278         char *model;
 279         char *rev;
 280         char *driver_hint; /* Name of the correct driver, NULL if unknown */
 281 };
 282
 283 static struct st_reject_data reject_list[] = {
 284         /* {"XXX", "Yy-", "", NULL},  example */
 285         SIGS_FROM_OSST,
 286         {NULL, }};
 287
 288 /* If the device signature is on the list of incompatible drives, the
 289    function returns a pointer to the name of the correct driver (if known) */
 290 static char * st_incompatible(struct scsi_device* SDp)
 291 {
 292         struct st_reject_data *rp;
 293
 294         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
 295                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
 296                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
 297                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
 298                         if (rp->driver_hint)
 299                                 return rp->driver_hint;
 300                         else
 301                                 return "unknown";
 302                 }
 303         return NULL;
 304 }
 305 \f
 306
 307 static inline char *tape_name(struct scsi_tape *tape)
 308 {
 309         return tape->disk->disk_name;
 310 }
 311
 312
 313 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
 314 {
 315         const u8 *ucp;
 316         const u8 *sense = SRpnt->sense;
 317
 318         s->have_sense = scsi_normalize_sense(SRpnt->sense,
 319                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
 320         s->flags = 0;
 321
 322         if (s->have_sense) {
 323                 s->deferred = 0;
 324                 s->remainder_valid =
 325                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
 326                 switch (sense[0] & 0x7f) {
 327                 case 0x71:
 328                         s->deferred = 1;
 329                 case 0x70:
 330                         s->fixed_format = 1;
 331                         s->flags = sense[2] & 0xe0;
 332                         break;
 333                 case 0x73:
 334                         s->deferred = 1;
 335                 case 0x72:
 336                         s->fixed_format = 0;
 337                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
 338                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
 339                         break;
 340                 }
 341         }
 342 }
 343
 344
 345 /* Convert the result to success code */
 346 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
 347 {
 348         int result = SRpnt->result;
 349         u8 scode;
 350         DEB(const char *stp;)
 351         char *name = tape_name(STp);
 352         struct st_cmdstatus *cmdstatp;
 353
 354         if (!result)
 355                 return 0;
 356
 357         cmdstatp = &STp->buffer->cmdstat;
 358         st_analyze_sense(SRpnt, cmdstatp);
 359
 360         if (cmdstatp->have_sense)
 361                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
 362         else
 363                 scode = 0;
 364
 365         DEB(
 366         if (debugging) {
 367                 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
 368                        name, result,
 369                        SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
 370                        SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
 371                 if (cmdstatp->have_sense)
 372                          __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 373         } ) /* end DEB */
 374         if (!debugging) { /* Abnormal conditions for tape */
 375                 if (!cmdstatp->have_sense)
 376                         printk(KERN_WARNING
 377                                "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
 378                                name, result, driver_byte(result),
 379                                host_byte(result));
 380                 else if (cmdstatp->have_sense &&
 381                          scode != NO_SENSE &&
 382                          scode != RECOVERED_ERROR &&
 383                          /* scode != UNIT_ATTENTION && */
 384                          scode != BLANK_CHECK &&
 385                          scode != VOLUME_OVERFLOW &&
 386                          SRpnt->cmd[0] != MODE_SENSE &&
 387                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 388
 389                         __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 390                 }
 391         }
 392
 393         if (cmdstatp->fixed_format &&
 394             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
 395                 if (STp->cln_sense_value)
 396                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 397                                                STp->cln_sense_mask) == STp->cln_sense_value);
 398                 else
 399                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 400                                                STp->cln_sense_mask) != 0);
 401         }
 402         if (cmdstatp->have_sense &&
 403             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
 404                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
 405
 406         STp->pos_unknown |= STp->device->was_reset;
 407
 408         if (cmdstatp->have_sense &&
 409             scode == RECOVERED_ERROR
 410 #if ST_RECOVERED_WRITE_FATAL
 411             && SRpnt->cmd[0] != WRITE_6
 412             && SRpnt->cmd[0] != WRITE_FILEMARKS
 413 #endif
 414             ) {
 415                 STp->recover_count++;
 416                 STp->recover_reg++;
 417
 418                 DEB(
 419                 if (debugging) {
 420                         if (SRpnt->cmd[0] == READ_6)
 421                                 stp = "read";
 422                         else if (SRpnt->cmd[0] == WRITE_6)
 423                                 stp = "write";
 424                         else
 425                                 stp = "ioctl";
 426                         printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
 427                                STp->recover_count);
 428                 } ) /* end DEB */
 429
 430                 if (cmdstatp->flags == 0)
 431                         return 0;
 432         }
 433         return (-EIO);
 434 }
 435
 436 static struct st_request *st_allocate_request(struct scsi_tape *stp)
 437 {
 438         struct st_request *streq;
 439
 440         streq = kzalloc(sizeof(*streq), GFP_KERNEL);
 441         if (streq)
 442                 streq->stp = stp;
 443         else {
 444                 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
 445                             tape_name(stp)););
 446                 if (signal_pending(current))
 447                         stp->buffer->syscall_result = -EINTR;
 448                 else
 449                         stp->buffer->syscall_result = -EBUSY;
 450         }
 451
 452         return streq;
 453 }
 454
 455 static void st_release_request(struct st_request *streq)
 456 {
 457         kfree(streq);
 458 }
 459
 460 static void st_scsi_execute_end(struct request *req, int uptodate)
 461 {
 462         struct st_request *SRpnt = req->end_io_data;
 463         struct scsi_tape *STp = SRpnt->stp;
 464         struct bio *tmp;
 465
 466         STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
 467         STp->buffer->cmdstat.residual = req->resid_len;
 468
 469         tmp = SRpnt->bio;
 470         if (SRpnt->waiting)
 471                 complete(SRpnt->waiting);
 472
 473         blk_rq_unmap_user(tmp);
 474         __blk_put_request(req->q, req);
 475 }
 476
 477 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 478                            int data_direction, void *buffer, unsigned bufflen,
 479                            int timeout, int retries)
 480 {
 481         struct request *req;
 482         struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
 483         int err = 0;
 484         int write = (data_direction == DMA_TO_DEVICE);
 485
 486         req = blk_get_request(SRpnt->stp->device->request_queue, write,
 487                               GFP_KERNEL);
 488         if (!req)
 489                 return DRIVER_ERROR << 24;
 490
 491         req->cmd_type = REQ_TYPE_BLOCK_PC;
 492         req->cmd_flags |= REQ_QUIET;
 493
 494         mdata->null_mapped = 1;
 495
 496         if (bufflen) {
 497                 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
 498                                       GFP_KERNEL);
 499                 if (err) {
 500                         blk_put_request(req);
 501                         return DRIVER_ERROR << 24;
 502                 }
 503         }
 504
 505         SRpnt->bio = req->bio;
 506         req->cmd_len = COMMAND_SIZE(cmd[0]);
 507         memset(req->cmd, 0, BLK_MAX_CDB);
 508         memcpy(req->cmd, cmd, req->cmd_len);
 509         req->sense = SRpnt->sense;
 510         req->sense_len = 0;
 511         req->timeout = timeout;
 512         req->retries = retries;
 513         req->end_io_data = SRpnt;
 514
 515         blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
 516         return 0;
 517 }
 518
 519 /* Do the scsi command. Waits until command performed if do_wait is true.
 520    Otherwise write_behind_check() is used to check that the command
 521    has finished. */
 522 static struct st_request *
 523 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
 524            int bytes, int direction, int timeout, int retries, int do_wait)
 525 {
 526         struct completion *waiting;
 527         struct rq_map_data *mdata = &STp->buffer->map_data;
 528         int ret;
 529
 530         /* if async, make sure there's no command outstanding */
 531         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
 532                 printk(KERN_ERR "%s: Async command already active.\n",
 533                        tape_name(STp));
 534                 if (signal_pending(current))
 535                         (STp->buffer)->syscall_result = (-EINTR);
 536                 else
 537                         (STp->buffer)->syscall_result = (-EBUSY);
 538                 return NULL;
 539         }
 540
 541         if (!SRpnt) {
 542                 SRpnt = st_allocate_request(STp);
 543                 if (!SRpnt)
 544                         return NULL;
 545         }
 546
 547         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
 548            which IO is outstanding. It's nulled out when the IO completes. */
 549         if (!do_wait)
 550                 (STp->buffer)->last_SRpnt = SRpnt;
 551
 552         waiting = &STp->wait;
 553         init_completion(waiting);
 554         SRpnt->waiting = waiting;
 555
 556         if (STp->buffer->do_dio) {
 557                 mdata->page_order = 0;
 558                 mdata->nr_entries = STp->buffer->sg_segs;
 559                 mdata->pages = STp->buffer->mapped_pages;
 560         } else {
 561                 mdata->page_order = STp->buffer->reserved_page_order;
 562                 mdata->nr_entries =
 563                         DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
 564                 mdata->pages = STp->buffer->reserved_pages;
 565                 mdata->offset = 0;
 566         }
 567
 568         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
 569         STp->buffer->cmdstat.have_sense = 0;
 570         STp->buffer->syscall_result = 0;
 571
 572         ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
 573                               retries);
 574         if (ret) {
 575                 /* could not allocate the buffer or request was too large */
 576                 (STp->buffer)->syscall_result = (-EBUSY);
 577                 (STp->buffer)->last_SRpnt = NULL;
 578         } else if (do_wait) {
 579                 wait_for_completion(waiting);
 580                 SRpnt->waiting = NULL;
 581                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 582         }
 583
 584         return SRpnt;
 585 }
 586
 587
 588 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
 589    write has been correct but EOM early warning reached, -EIO if write ended in
 590    error or zero if write successful. Asynchronous writes are used only in
 591    variable block mode. */
 592 static int write_behind_check(struct scsi_tape * STp)
 593 {
 594         int retval = 0;
 595         struct st_buffer *STbuffer;
 596         struct st_partstat *STps;
 597         struct st_cmdstatus *cmdstatp;
 598         struct st_request *SRpnt;
 599
 600         STbuffer = STp->buffer;
 601         if (!STbuffer->writing)
 602                 return 0;
 603
 604         DEB(
 605         if (STp->write_pending)
 606                 STp->nbr_waits++;
 607         else
 608                 STp->nbr_finished++;
 609         ) /* end DEB */
 610
 611         wait_for_completion(&(STp->wait));
 612         SRpnt = STbuffer->last_SRpnt;
 613         STbuffer->last_SRpnt = NULL;
 614         SRpnt->waiting = NULL;
 615
 616         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 617         st_release_request(SRpnt);
 618
 619         STbuffer->buffer_bytes -= STbuffer->writing;
 620         STps = &(STp->ps[STp->partition]);
 621         if (STps->drv_block >= 0) {
 622                 if (STp->block_size == 0)
 623                         STps->drv_block++;
 624                 else
 625                         STps->drv_block += STbuffer->writing / STp->block_size;
 626         }
 627
 628         cmdstatp = &STbuffer->cmdstat;
 629         if (STbuffer->syscall_result) {
 630                 retval = -EIO;
 631                 if (cmdstatp->have_sense && !cmdstatp->deferred &&
 632                     (cmdstatp->flags & SENSE_EOM) &&
 633                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 634                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
 635                         /* EOM at write-behind, has all data been written? */
 636                         if (!cmdstatp->remainder_valid ||
 637                             cmdstatp->uremainder64 == 0)
 638                                 retval = -ENOSPC;
 639                 }
 640                 if (retval == -EIO)
 641                         STps->drv_block = -1;
 642         }
 643         STbuffer->writing = 0;
 644
 645         DEB(if (debugging && retval)
 646             printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
 647                    tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
 648
 649         return retval;
 650 }
 651
 652
 653 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
 654    it messes up the block number). */
 655 static int cross_eof(struct scsi_tape * STp, int forward)
 656 {
 657         struct st_request *SRpnt;
 658         unsigned char cmd[MAX_COMMAND_SIZE];
 659
 660         cmd[0] = SPACE;
 661         cmd[1] = 0x01;          /* Space FileMarks */
 662         if (forward) {
 663                 cmd[2] = cmd[3] = 0;
 664                 cmd[4] = 1;
 665         } else
 666                 cmd[2] = cmd[3] = cmd[4] = 0xff;        /* -1 filemarks */
 667         cmd[5] = 0;
 668
 669         DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
 670                    tape_name(STp), forward ? "forward" : "backward"));
 671
 672         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
 673                            STp->device->request_queue->rq_timeout,
 674                            MAX_RETRIES, 1);
 675         if (!SRpnt)
 676                 return (STp->buffer)->syscall_result;
 677
 678         st_release_request(SRpnt);
 679         SRpnt = NULL;
 680
 681         if ((STp->buffer)->cmdstat.midlevel_result != 0)
 682                 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
 683                    tape_name(STp), forward ? "forward" : "backward");
 684
 685         return (STp->buffer)->syscall_result;
 686 }
 687
 688
 689 /* Flush the write buffer (never need to write if variable blocksize). */
 690 static int st_flush_write_buffer(struct scsi_tape * STp)
 691 {
 692         int transfer, blks;
 693         int result;
 694         unsigned char cmd[MAX_COMMAND_SIZE];
 695         struct st_request *SRpnt;
 696         struct st_partstat *STps;
 697
 698         result = write_behind_check(STp);
 699         if (result)
 700                 return result;
 701
 702         result = 0;
 703         if (STp->dirty == 1) {
 704
 705                 transfer = STp->buffer->buffer_bytes;
 706                 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
 707                                tape_name(STp), transfer));
 708
 709                 memset(cmd, 0, MAX_COMMAND_SIZE);
 710                 cmd[0] = WRITE_6;
 711                 cmd[1] = 1;
 712                 blks = transfer / STp->block_size;
 713                 cmd[2] = blks >> 16;
 714                 cmd[3] = blks >> 8;
 715                 cmd[4] = blks;
 716
 717                 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
 718                                    STp->device->request_queue->rq_timeout,
 719                                    MAX_WRITE_RETRIES, 1);
 720                 if (!SRpnt)
 721                         return (STp->buffer)->syscall_result;
 722
 723                 STps = &(STp->ps[STp->partition]);
 724                 if ((STp->buffer)->syscall_result != 0) {
 725                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 726
 727                         if (cmdstatp->have_sense && !cmdstatp->deferred &&
 728                             (cmdstatp->flags & SENSE_EOM) &&
 729                             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 730                              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
 731                             (!cmdstatp->remainder_valid ||
 732                              cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
 733                                 STp->dirty = 0;
 734                                 (STp->buffer)->buffer_bytes = 0;
 735                                 if (STps->drv_block >= 0)
 736                                         STps->drv_block += blks;
 737                                 result = (-ENOSPC);
 738                         } else {
 739                                 printk(KERN_ERR "%s: Error on flush.\n",
 740                                        tape_name(STp));
 741                                 STps->drv_block = (-1);
 742                                 result = (-EIO);
 743                         }
 744                 } else {
 745                         if (STps->drv_block >= 0)
 746                                 STps->drv_block += blks;
 747                         STp->dirty = 0;
 748                         (STp->buffer)->buffer_bytes = 0;
 749                 }
 750                 st_release_request(SRpnt);
 751                 SRpnt = NULL;
 752         }
 753         return result;
 754 }
 755
 756
 757 /* Flush the tape buffer. The tape will be positioned correctly unless
 758    seek_next is true. */
 759 static int flush_buffer(struct scsi_tape *STp, int seek_next)
 760 {
 761         int backspace, result;
 762         struct st_buffer *STbuffer;
 763         struct st_partstat *STps;
 764
 765         STbuffer = STp->buffer;
 766
 767         /*
 768          * If there was a bus reset, block further access
 769          * to this device.
 770          */
 771         if (STp->pos_unknown)
 772                 return (-EIO);
 773
 774         if (STp->ready != ST_READY)
 775                 return 0;
 776         STps = &(STp->ps[STp->partition]);
 777         if (STps->rw == ST_WRITING)     /* Writing */
 778                 return st_flush_write_buffer(STp);
 779
 780         if (STp->block_size == 0)
 781                 return 0;
 782
 783         backspace = ((STp->buffer)->buffer_bytes +
 784                      (STp->buffer)->read_pointer) / STp->block_size -
 785             ((STp->buffer)->read_pointer + STp->block_size - 1) /
 786             STp->block_size;
 787         (STp->buffer)->buffer_bytes = 0;
 788         (STp->buffer)->read_pointer = 0;
 789         result = 0;
 790         if (!seek_next) {
 791                 if (STps->eof == ST_FM_HIT) {
 792                         result = cross_eof(STp, 0);     /* Back over the EOF hit */
 793                         if (!result)
 794                                 STps->eof = ST_NOEOF;
 795                         else {
 796                                 if (STps->drv_file >= 0)
 797                                         STps->drv_file++;
 798                                 STps->drv_block = 0;
 799                         }
 800                 }
 801                 if (!result && backspace > 0)
 802                         result = st_int_ioctl(STp, MTBSR, backspace);
 803         } else if (STps->eof == ST_FM_HIT) {
 804                 if (STps->drv_file >= 0)
 805                         STps->drv_file++;
 806                 STps->drv_block = 0;
 807                 STps->eof = ST_NOEOF;
 808         }
 809         return result;
 810
 811 }
 812 \f
 813 /* Set the mode parameters */
 814 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
 815 {
 816         int set_it = 0;
 817         unsigned long arg;
 818         char *name = tape_name(STp);
 819
 820         if (!STp->density_changed &&
 821             STm->default_density >= 0 &&
 822             STm->default_density != STp->density) {
 823                 arg = STm->default_density;
 824                 set_it = 1;
 825         } else
 826                 arg = STp->density;
 827         arg <<= MT_ST_DENSITY_SHIFT;
 828         if (!STp->blksize_changed &&
 829             STm->default_blksize >= 0 &&
 830             STm->default_blksize != STp->block_size) {
 831                 arg |= STm->default_blksize;
 832                 set_it = 1;
 833         } else
 834                 arg |= STp->block_size;
 835         if (set_it &&
 836             st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
 837                 printk(KERN_WARNING
 838                        "%s: Can't set default block size to %d bytes and density %x.\n",
 839                        name, STm->default_blksize, STm->default_density);
 840                 if (modes_defined)
 841                         return (-EINVAL);
 842         }
 843         return 0;
 844 }
 845
 846
 847 /* Lock or unlock the drive door. Don't use when st_request allocated. */
 848 static int do_door_lock(struct scsi_tape * STp, int do_lock)
 849 {
 850         int retval, cmd;
 851         DEB(char *name = tape_name(STp);)
 852
 853
 854         cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
 855         DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
 856                     do_lock ? "L" : "Unl"));
 857         retval = scsi_ioctl(STp->device, cmd, NULL);
 858         if (!retval) {
 859                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
 860         }
 861         else {
 862                 STp->door_locked = ST_LOCK_FAILS;
 863         }
 864         return retval;
 865 }
 866
 867
 868 /* Set the internal state after reset */
 869 static void reset_state(struct scsi_tape *STp)
 870 {
 871         int i;
 872         struct st_partstat *STps;
 873
 874         STp->pos_unknown = 0;
 875         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
 876                 STps = &(STp->ps[i]);
 877                 STps->rw = ST_IDLE;
 878                 STps->eof = ST_NOEOF;
 879                 STps->at_sm = 0;
 880                 STps->last_block_valid = 0;
 881                 STps->drv_block = -1;
 882                 STps->drv_file = -1;
 883         }
 884         if (STp->can_partitions) {
 885                 STp->partition = find_partition(STp);
 886                 if (STp->partition < 0)
 887                         STp->partition = 0;
 888                 STp->new_partition = STp->partition;
 889         }
 890 }
 891 \f
 892 /* Test if the drive is ready. Returns either one of the codes below or a negative system
 893    error code. */
 894 #define CHKRES_READY       0
 895 #define CHKRES_NEW_SESSION 1
 896 #define CHKRES_NOT_READY   2
 897 #define CHKRES_NO_TAPE     3
 898
 899 #define MAX_ATTENTIONS    10
 900
 901 static int test_ready(struct scsi_tape *STp, int do_wait)
 902 {
 903         int attentions, waits, max_wait, scode;
 904         int retval = CHKRES_READY, new_session = 0;
 905         unsigned char cmd[MAX_COMMAND_SIZE];
 906         struct st_request *SRpnt = NULL;
 907         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 908
 909         max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
 910
 911         for (attentions=waits=0; ; ) {
 912                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
 913                 cmd[0] = TEST_UNIT_READY;
 914                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
 915                                    STp->long_timeout, MAX_READY_RETRIES, 1);
 916
 917                 if (!SRpnt) {
 918                         retval = (STp->buffer)->syscall_result;
 919                         break;
 920                 }
 921
 922                 if (cmdstatp->have_sense) {
 923
 924                         scode = cmdstatp->sense_hdr.sense_key;
 925
 926                         if (scode == UNIT_ATTENTION) { /* New media? */
 927                                 new_session = 1;
 928                                 if (attentions < MAX_ATTENTIONS) {
 929                                         attentions++;
 930                                         continue;
 931                                 }
 932                                 else {
 933                                         retval = (-EIO);
 934                                         break;
 935                                 }
 936                         }
 937
 938                         if (scode == NOT_READY) {
 939                                 if (waits < max_wait) {
 940                                         if (msleep_interruptible(1000)) {
 941                                                 retval = (-EINTR);
 942                                                 break;
 943                                         }
 944                                         waits++;
 945                                         continue;
 946                                 }
 947                                 else {
 948                                         if ((STp->device)->scsi_level >= SCSI_2 &&
 949                                             cmdstatp->sense_hdr.asc == 0x3a)    /* Check ASC */
 950                                                 retval = CHKRES_NO_TAPE;
 951                                         else
 952                                                 retval = CHKRES_NOT_READY;
 953                                         break;
 954                                 }
 955                         }
 956                 }
 957
 958                 retval = (STp->buffer)->syscall_result;
 959                 if (!retval)
 960                         retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
 961                 break;
 962         }
 963
 964         if (SRpnt != NULL)
 965                 st_release_request(SRpnt);
 966         return retval;
 967 }
 968
 969
 970 /* See if the drive is ready and gather information about the tape. Return values:
 971    < 0   negative error code from errno.h
 972    0     drive ready
 973    1     drive not ready (possibly no tape)
 974 */
 975 static int check_tape(struct scsi_tape *STp, struct file *filp)
 976 {
 977         int i, retval, new_session = 0, do_wait;
 978         unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
 979         unsigned short st_flags = filp->f_flags;
 980         struct st_request *SRpnt = NULL;
 981         struct st_modedef *STm;
 982         struct st_partstat *STps;
 983         char *name = tape_name(STp);
 984         struct inode *inode = filp->f_path.dentry->d_inode;
 985         int mode = TAPE_MODE(inode);
 986
 987         STp->ready = ST_READY;
 988
 989         if (mode != STp->current_mode) {
 990                 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
 991                                name, STp->current_mode, mode));
 992                 new_session = 1;
 993                 STp->current_mode = mode;
 994         }
 995         STm = &(STp->modes[STp->current_mode]);
 996
 997         saved_cleaning = STp->cleaning_req;
 998         STp->cleaning_req = 0;
 999
1000         do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
1001         retval = test_ready(STp, do_wait);
1002
1003         if (retval < 0)
1004             goto err_out;
1005
1006         if (retval == CHKRES_NEW_SESSION) {
1007                 STp->pos_unknown = 0;
1008                 STp->partition = STp->new_partition = 0;
1009                 if (STp->can_partitions)
1010                         STp->nbr_partitions = 1; /* This guess will be updated later
1011                                                     if necessary */
1012                 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1013                         STps = &(STp->ps[i]);
1014                         STps->rw = ST_IDLE;
1015                         STps->eof = ST_NOEOF;
1016                         STps->at_sm = 0;
1017                         STps->last_block_valid = 0;
1018                         STps->drv_block = 0;
1019                         STps->drv_file = 0;
1020                 }
1021                 new_session = 1;
1022         }
1023         else {
1024                 STp->cleaning_req |= saved_cleaning;
1025
1026                 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1027                         if (retval == CHKRES_NO_TAPE)
1028                                 STp->ready = ST_NO_TAPE;
1029                         else
1030                                 STp->ready = ST_NOT_READY;
1031
1032                         STp->density = 0;       /* Clear the erroneous "residue" */
1033                         STp->write_prot = 0;
1034                         STp->block_size = 0;
1035                         STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1036                         STp->partition = STp->new_partition = 0;
1037                         STp->door_locked = ST_UNLOCKED;
1038                         return CHKRES_NOT_READY;
1039                 }
1040         }
1041
1042         if (STp->omit_blklims)
1043                 STp->min_block = STp->max_block = (-1);
1044         else {
1045                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1046                 cmd[0] = READ_BLOCK_LIMITS;
1047
1048                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1049                                    STp->device->request_queue->rq_timeout,
1050                                    MAX_READY_RETRIES, 1);
1051                 if (!SRpnt) {
1052                         retval = (STp->buffer)->syscall_result;
1053                         goto err_out;
1054                 }
1055
1056                 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1057                         STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1058                             ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1059                         STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1060                             (STp->buffer)->b_data[5];
1061                         if ( DEB( debugging || ) !STp->inited)
1062                                 printk(KERN_INFO
1063                                        "%s: Block limits %d - %d bytes.\n", name,
1064                                        STp->min_block, STp->max_block);
1065                 } else {
1066                         STp->min_block = STp->max_block = (-1);
1067                         DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1068                                        name));
1069                 }
1070         }
1071
1072         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1073         cmd[0] = MODE_SENSE;
1074         cmd[4] = 12;
1075
1076         SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1077                            STp->device->request_queue->rq_timeout,
1078                            MAX_READY_RETRIES, 1);
1079         if (!SRpnt) {
1080                 retval = (STp->buffer)->syscall_result;
1081                 goto err_out;
1082         }
1083
1084         if ((STp->buffer)->syscall_result != 0) {
1085                 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1086                 STp->block_size = ST_DEFAULT_BLOCK;     /* Educated guess (?) */
1087                 (STp->buffer)->syscall_result = 0;      /* Prevent error propagation */
1088                 STp->drv_write_prot = 0;
1089         } else {
1090                 DEBC(printk(ST_DEB_MSG
1091                             "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1092                             name,
1093                             (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1094                             (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1095
1096                 if ((STp->buffer)->b_data[3] >= 8) {
1097                         STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1098                         STp->density = (STp->buffer)->b_data[4];
1099                         STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1100                             (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1101                         DEBC(printk(ST_DEB_MSG
1102                                     "%s: Density %x, tape length: %x, drv buffer: %d\n",
1103                                     name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1104                                     (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1105                                     STp->drv_buffer));
1106                 }
1107                 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1108                 if (!STp->drv_buffer && STp->immediate_filemark) {
1109                         printk(KERN_WARNING
1110                             "%s: non-buffered tape: disabling writing immediate filemarks\n",
1111                             name);
1112                         STp->immediate_filemark = 0;
1113                 }
1114         }
1115         st_release_request(SRpnt);
1116         SRpnt = NULL;
1117         STp->inited = 1;
1118
1119         if (STp->block_size > 0)
1120                 (STp->buffer)->buffer_blocks =
1121                         (STp->buffer)->buffer_size / STp->block_size;
1122         else
1123                 (STp->buffer)->buffer_blocks = 1;
1124         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1125
1126         DEBC(printk(ST_DEB_MSG
1127                        "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1128                        STp->block_size, (STp->buffer)->buffer_size,
1129                        (STp->buffer)->buffer_blocks));
1130
1131         if (STp->drv_write_prot) {
1132                 STp->write_prot = 1;
1133
1134                 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1135
1136                 if (do_wait &&
1137                     ((st_flags & O_ACCMODE) == O_WRONLY ||
1138                      (st_flags & O_ACCMODE) == O_RDWR)) {
1139                         retval = (-EROFS);
1140                         goto err_out;
1141                 }
1142         }
1143
1144         if (STp->can_partitions && STp->nbr_partitions < 1) {
1145                 /* This code is reached when the device is opened for the first time
1146                    after the driver has been initialized with tape in the drive and the
1147                    partition support has been enabled. */
1148                 DEBC(printk(ST_DEB_MSG
1149                             "%s: Updating partition number in status.\n", name));
1150                 if ((STp->partition = find_partition(STp)) < 0) {
1151                         retval = STp->partition;
1152                         goto err_out;
1153                 }
1154                 STp->new_partition = STp->partition;
1155                 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1156         }
1157
1158         if (new_session) {      /* Change the drive parameters for the new mode */
1159                 STp->density_changed = STp->blksize_changed = 0;
1160                 STp->compression_changed = 0;
1161                 if (!(STm->defaults_for_writes) &&
1162                     (retval = set_mode_densblk(STp, STm)) < 0)
1163                     goto err_out;
1164
1165                 if (STp->default_drvbuffer != 0xff) {
1166                         if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1167                                 printk(KERN_WARNING
1168                                        "%s: Can't set default drive buffering to %d.\n",
1169                                        name, STp->default_drvbuffer);
1170                 }
1171         }
1172
1173         return CHKRES_READY;
1174
1175  err_out:
1176         return retval;
1177 }
1178
1179
1180 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1181    module count. */
1182 static int st_open(struct inode *inode, struct file *filp)
1183 {
1184         int i, retval = (-EIO);
1185         int resumed = 0;
1186         struct scsi_tape *STp;
1187         struct st_partstat *STps;
1188         int dev = TAPE_NR(inode);
1189         char *name;
1190
1191         mutex_lock(&st_mutex);
1192         /*
1193          * We really want to do nonseekable_open(inode, filp); here, but some
1194          * versions of tar incorrectly call lseek on tapes and bail out if that
1195          * fails.  So we disallow pread() and pwrite(), but permit lseeks.
1196          */
1197         filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1198
1199         if (!(STp = scsi_tape_get(dev))) {
1200                 mutex_unlock(&st_mutex);
1201                 return -ENXIO;
1202         }
1203
1204         write_lock(&st_dev_arr_lock);
1205         filp->private_data = STp;
1206         name = tape_name(STp);
1207
1208         if (STp->in_use) {
1209                 write_unlock(&st_dev_arr_lock);
1210                 scsi_tape_put(STp);
1211                 mutex_unlock(&st_mutex);
1212                 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1213                 return (-EBUSY);
1214         }
1215
1216         STp->in_use = 1;
1217         write_unlock(&st_dev_arr_lock);
1218         STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1219
1220         if (scsi_autopm_get_device(STp->device) < 0) {
1221                 retval = -EIO;
1222                 goto err_out;
1223         }
1224         resumed = 1;
1225         if (!scsi_block_when_processing_errors(STp->device)) {
1226                 retval = (-ENXIO);
1227                 goto err_out;
1228         }
1229
1230         /* See that we have at least a one page buffer available */
1231         if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1232                 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1233                        name);
1234                 retval = (-EOVERFLOW);
1235                 goto err_out;
1236         }
1237
1238         (STp->buffer)->cleared = 0;
1239         (STp->buffer)->writing = 0;
1240         (STp->buffer)->syscall_result = 0;
1241
1242         STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1243
1244         STp->dirty = 0;
1245         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1246                 STps = &(STp->ps[i]);
1247                 STps->rw = ST_IDLE;
1248         }
1249         STp->try_dio_now = STp->try_dio;
1250         STp->recover_count = 0;
1251         DEB( STp->nbr_waits = STp->nbr_finished = 0;
1252              STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1253
1254         retval = check_tape(STp, filp);
1255         if (retval < 0)
1256                 goto err_out;
1257         if ((filp->f_flags & O_NONBLOCK) == 0 &&
1258             retval != CHKRES_READY) {
1259                 if (STp->ready == NO_TAPE)
1260                         retval = (-ENOMEDIUM);
1261                 else
1262                         retval = (-EIO);
1263                 goto err_out;
1264         }
1265         mutex_unlock(&st_mutex);
1266         return 0;
1267
1268  err_out:
1269         normalize_buffer(STp->buffer);
1270         STp->in_use = 0;
1271         scsi_tape_put(STp);
1272         if (resumed)
1273                 scsi_autopm_put_device(STp->device);
1274         mutex_unlock(&st_mutex);
1275         return retval;
1276
1277 }
1278 \f
1279
1280 /* Flush the tape buffer before close */
1281 static int st_flush(struct file *filp, fl_owner_t id)
1282 {
1283         int result = 0, result2;
1284         unsigned char cmd[MAX_COMMAND_SIZE];
1285         struct st_request *SRpnt;
1286         struct scsi_tape *STp = filp->private_data;
1287         struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1288         struct st_partstat *STps = &(STp->ps[STp->partition]);
1289         char *name = tape_name(STp);
1290
1291         if (file_count(filp) > 1)
1292                 return 0;
1293
1294         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1295                 result = st_flush_write_buffer(STp);
1296                 if (result != 0 && result != (-ENOSPC))
1297                         goto out;
1298         }
1299
1300         if (STp->can_partitions &&
1301             (result2 = switch_partition(STp)) < 0) {
1302                 DEBC(printk(ST_DEB_MSG
1303                                "%s: switch_partition at close failed.\n", name));
1304                 if (result == 0)
1305                         result = result2;
1306                 goto out;
1307         }
1308
1309         DEBC( if (STp->nbr_requests)
1310                 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1311                        name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1312
1313         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1314                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1315
1316                 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1317                             name, STp->nbr_waits, STp->nbr_finished);
1318                 )
1319
1320                 memset(cmd, 0, MAX_COMMAND_SIZE);
1321                 cmd[0] = WRITE_FILEMARKS;
1322                 if (STp->immediate_filemark)
1323                         cmd[1] = 1;
1324                 cmd[4] = 1 + STp->two_fm;
1325
1326                 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1327                                    STp->device->request_queue->rq_timeout,
1328                                    MAX_WRITE_RETRIES, 1);
1329                 if (!SRpnt) {
1330                         result = (STp->buffer)->syscall_result;
1331                         goto out;
1332                 }
1333
1334                 if (STp->buffer->syscall_result == 0 ||
1335                     (cmdstatp->have_sense && !cmdstatp->deferred &&
1336                      (cmdstatp->flags & SENSE_EOM) &&
1337                      (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1338                       cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1339                      (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1340                         /* Write successful at EOM */
1341                         st_release_request(SRpnt);
1342                         SRpnt = NULL;
1343                         if (STps->drv_file >= 0)
1344                                 STps->drv_file++;
1345                         STps->drv_block = 0;
1346                         if (STp->two_fm)
1347                                 cross_eof(STp, 0);
1348                         STps->eof = ST_FM;
1349                 }
1350                 else { /* Write error */
1351                         st_release_request(SRpnt);
1352                         SRpnt = NULL;
1353                         printk(KERN_ERR "%s: Error on write filemark.\n", name);
1354                         if (result == 0)
1355                                 result = (-EIO);
1356                 }
1357
1358                 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1359                             name, cmd[4]));
1360         } else if (!STp->rew_at_close) {
1361                 STps = &(STp->ps[STp->partition]);
1362                 if (!STm->sysv || STps->rw != ST_READING) {
1363                         if (STp->can_bsr)
1364                                 result = flush_buffer(STp, 0);
1365                         else if (STps->eof == ST_FM_HIT) {
1366                                 result = cross_eof(STp, 0);
1367                                 if (result) {
1368                                         if (STps->drv_file >= 0)
1369                                                 STps->drv_file++;
1370                                         STps->drv_block = 0;
1371                                         STps->eof = ST_FM;
1372                                 } else
1373                                         STps->eof = ST_NOEOF;
1374                         }
1375                 } else if ((STps->eof == ST_NOEOF &&
1376                             !(result = cross_eof(STp, 1))) ||
1377                            STps->eof == ST_FM_HIT) {
1378                         if (STps->drv_file >= 0)
1379                                 STps->drv_file++;
1380                         STps->drv_block = 0;
1381                         STps->eof = ST_FM;
1382                 }
1383         }
1384
1385       out:
1386         if (STp->rew_at_close) {
1387                 result2 = st_int_ioctl(STp, MTREW, 1);
1388                 if (result == 0)
1389                         result = result2;
1390         }
1391         return result;
1392 }
1393
1394
1395 /* Close the device and release it. BKL is not needed: this is the only thread
1396    accessing this tape. */
1397 static int st_release(struct inode *inode, struct file *filp)
1398 {
1399         int result = 0;
1400         struct scsi_tape *STp = filp->private_data;
1401
1402         if (STp->door_locked == ST_LOCKED_AUTO)
1403                 do_door_lock(STp, 0);
1404
1405         normalize_buffer(STp->buffer);
1406         write_lock(&st_dev_arr_lock);
1407         STp->in_use = 0;
1408         write_unlock(&st_dev_arr_lock);
1409         scsi_autopm_put_device(STp->device);
1410         scsi_tape_put(STp);
1411
1412         return result;
1413 }
1414 \f
1415 /* The checks common to both reading and writing */
1416 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1417 {
1418         ssize_t retval = 0;
1419
1420         /*
1421          * If we are in the middle of error recovery, don't let anyone
1422          * else try and use this device.  Also, if error recovery fails, it
1423          * may try and take the device offline, in which case all further
1424          * access to the device is prohibited.
1425          */
1426         if (!scsi_block_when_processing_errors(STp->device)) {
1427                 retval = (-ENXIO);
1428                 goto out;
1429         }
1430
1431         if (STp->ready != ST_READY) {
1432                 if (STp->ready == ST_NO_TAPE)
1433                         retval = (-ENOMEDIUM);
1434                 else
1435                         retval = (-EIO);
1436                 goto out;
1437         }
1438
1439         if (! STp->modes[STp->current_mode].defined) {
1440                 retval = (-ENXIO);
1441                 goto out;
1442         }
1443
1444
1445         /*
1446          * If there was a bus reset, block further access
1447          * to this device.
1448          */
1449         if (STp->pos_unknown) {
1450                 retval = (-EIO);
1451                 goto out;
1452         }
1453
1454         if (count == 0)
1455                 goto out;
1456
1457         DEB(
1458         if (!STp->in_use) {
1459                 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1460                 retval = (-EIO);
1461                 goto out;
1462         } ) /* end DEB */
1463
1464         if (STp->can_partitions &&
1465             (retval = switch_partition(STp)) < 0)
1466                 goto out;
1467
1468         if (STp->block_size == 0 && STp->max_block > 0 &&
1469             (count < STp->min_block || count > STp->max_block)) {
1470                 retval = (-EINVAL);
1471                 goto out;
1472         }
1473
1474         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1475             !do_door_lock(STp, 1))
1476                 STp->door_locked = ST_LOCKED_AUTO;
1477
1478  out:
1479         return retval;
1480 }
1481
1482
1483 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1484                            size_t count, int is_read)
1485 {
1486         int i, bufsize, retval = 0;
1487         struct st_buffer *STbp = STp->buffer;
1488
1489         if (is_read)
1490                 i = STp->try_dio_now && try_rdio;
1491         else
1492                 i = STp->try_dio_now && try_wdio;
1493
1494         if (i && ((unsigned long)buf & queue_dma_alignment(
1495                                         STp->device->request_queue)) == 0) {
1496                 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1497                                        count, (is_read ? READ : WRITE));
1498                 if (i > 0) {
1499                         STbp->do_dio = i;
1500                         STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1501                 }
1502                 else
1503                         STbp->do_dio = 0;  /* fall back to buffering with any error */
1504                 STbp->sg_segs = STbp->do_dio;
1505                 DEB(
1506                      if (STbp->do_dio) {
1507                         STp->nbr_dio++;
1508                         STp->nbr_pages += STbp->do_dio;
1509                      }
1510                 )
1511         } else
1512                 STbp->do_dio = 0;
1513         DEB( STp->nbr_requests++; )
1514
1515         if (!STbp->do_dio) {
1516                 if (STp->block_size)
1517                         bufsize = STp->block_size > st_fixed_buffer_size ?
1518                                 STp->block_size : st_fixed_buffer_size;
1519                 else {
1520                         bufsize = count;
1521                         /* Make sure that data from previous user is not leaked even if
1522                            HBA does not return correct residual */
1523                         if (is_read && STp->sili && !STbp->cleared)
1524                                 clear_buffer(STbp);
1525                 }
1526
1527                 if (bufsize > STbp->buffer_size &&
1528                     !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1529                         printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1530                                tape_name(STp), bufsize);
1531                         retval = (-EOVERFLOW);
1532                         goto out;
1533                 }
1534                 if (STp->block_size)
1535                         STbp->buffer_blocks = bufsize / STp->block_size;
1536         }
1537
1538  out:
1539         return retval;
1540 }
1541
1542
1543 /* Can be called more than once after each setup_buffer() */
1544 static void release_buffering(struct scsi_tape *STp, int is_read)
1545 {
1546         struct st_buffer *STbp;
1547
1548         STbp = STp->buffer;
1549         if (STbp->do_dio) {
1550                 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1551                 STbp->do_dio = 0;
1552                 STbp->sg_segs = 0;
1553         }
1554 }
1555
1556
1557 /* Write command */
1558 static ssize_t
1559 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1560 {
1561         ssize_t total;
1562         ssize_t i, do_count, blks, transfer;
1563         ssize_t retval;
1564         int undone, retry_eot = 0, scode;
1565         int async_write;
1566         unsigned char cmd[MAX_COMMAND_SIZE];
1567         const char __user *b_point;
1568         struct st_request *SRpnt = NULL;
1569         struct scsi_tape *STp = filp->private_data;
1570         struct st_modedef *STm;
1571         struct st_partstat *STps;
1572         struct st_buffer *STbp;
1573         char *name = tape_name(STp);
1574
1575         if (mutex_lock_interruptible(&STp->lock))
1576                 return -ERESTARTSYS;
1577
1578         retval = rw_checks(STp, filp, count);
1579         if (retval || count == 0)
1580                 goto out;
1581
1582         /* Write must be integral number of blocks */
1583         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1584                 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1585                        name);
1586                 retval = (-EINVAL);
1587                 goto out;
1588         }
1589
1590         STm = &(STp->modes[STp->current_mode]);
1591         STps = &(STp->ps[STp->partition]);
1592
1593         if (STp->write_prot) {
1594                 retval = (-EACCES);
1595                 goto out;
1596         }
1597
1598
1599         if (STps->rw == ST_READING) {
1600                 retval = flush_buffer(STp, 0);
1601                 if (retval)
1602                         goto out;
1603                 STps->rw = ST_WRITING;
1604         } else if (STps->rw != ST_WRITING &&
1605                    STps->drv_file == 0 && STps->drv_block == 0) {
1606                 if ((retval = set_mode_densblk(STp, STm)) < 0)
1607                         goto out;
1608                 if (STm->default_compression != ST_DONT_TOUCH &&
1609                     !(STp->compression_changed)) {
1610                         if (st_compression(STp, (STm->default_compression == ST_YES))) {
1611                                 printk(KERN_WARNING "%s: Can't set default compression.\n",
1612                                        name);
1613                                 if (modes_defined) {
1614                                         retval = (-EINVAL);
1615                                         goto out;
1616                                 }
1617                         }
1618                 }
1619         }
1620
1621         STbp = STp->buffer;
1622         i = write_behind_check(STp);
1623         if (i) {
1624                 if (i == -ENOSPC)
1625                         STps->eof = ST_EOM_OK;
1626                 else
1627                         STps->eof = ST_EOM_ERROR;
1628         }
1629
1630         if (STps->eof == ST_EOM_OK) {
1631                 STps->eof = ST_EOD_1;  /* allow next write */
1632                 retval = (-ENOSPC);
1633                 goto out;
1634         }
1635         else if (STps->eof == ST_EOM_ERROR) {
1636                 retval = (-EIO);
1637                 goto out;
1638         }
1639
1640         /* Check the buffer readability in cases where copy_user might catch
1641            the problems after some tape movement. */
1642         if (STp->block_size != 0 &&
1643             !STbp->do_dio &&
1644             (copy_from_user(&i, buf, 1) != 0 ||
1645              copy_from_user(&i, buf + count - 1, 1) != 0)) {
1646                 retval = (-EFAULT);
1647                 goto out;
1648         }
1649
1650         retval = setup_buffering(STp, buf, count, 0);
1651         if (retval)
1652                 goto out;
1653
1654         total = count;
1655
1656         memset(cmd, 0, MAX_COMMAND_SIZE);
1657         cmd[0] = WRITE_6;
1658         cmd[1] = (STp->block_size != 0);
1659
1660         STps->rw = ST_WRITING;
1661
1662         b_point = buf;
1663         while (count > 0 && !retry_eot) {
1664
1665                 if (STbp->do_dio) {
1666                         do_count = count;
1667                 }
1668                 else {
1669                         if (STp->block_size == 0)
1670                                 do_count = count;
1671                         else {
1672                                 do_count = STbp->buffer_blocks * STp->block_size -
1673                                         STbp->buffer_bytes;
1674                                 if (do_count > count)
1675                                         do_count = count;
1676                         }
1677
1678                         i = append_to_buffer(b_point, STbp, do_count);
1679                         if (i) {
1680                                 retval = i;
1681                                 goto out;
1682                         }
1683                 }
1684                 count -= do_count;
1685                 b_point += do_count;
1686
1687                 async_write = STp->block_size == 0 && !STbp->do_dio &&
1688                         STm->do_async_writes && STps->eof < ST_EOM_OK;
1689
1690                 if (STp->block_size != 0 && STm->do_buffer_writes &&
1691                     !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1692                     STbp->buffer_bytes < STbp->buffer_size) {
1693                         STp->dirty = 1;
1694                         /* Don't write a buffer that is not full enough. */
1695                         if (!async_write && count == 0)
1696                                 break;
1697                 }
1698
1699         retry_write:
1700                 if (STp->block_size == 0)
1701                         blks = transfer = do_count;
1702                 else {
1703                         if (!STbp->do_dio)
1704                                 blks = STbp->buffer_bytes;
1705                         else
1706                                 blks = do_count;
1707                         blks /= STp->block_size;
1708                         transfer = blks * STp->block_size;
1709                 }
1710                 cmd[2] = blks >> 16;
1711                 cmd[3] = blks >> 8;
1712                 cmd[4] = blks;
1713
1714                 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1715                                    STp->device->request_queue->rq_timeout,
1716                                    MAX_WRITE_RETRIES, !async_write);
1717                 if (!SRpnt) {
1718                         retval = STbp->syscall_result;
1719                         goto out;
1720                 }
1721                 if (async_write && !STbp->syscall_result) {
1722                         STbp->writing = transfer;
1723                         STp->dirty = !(STbp->writing ==
1724                                        STbp->buffer_bytes);
1725                         SRpnt = NULL;  /* Prevent releasing this request! */
1726                         DEB( STp->write_pending = 1; )
1727                         break;
1728                 }
1729
1730                 if (STbp->syscall_result != 0) {
1731                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1732
1733                         DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1734                         if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1735                                 scode = cmdstatp->sense_hdr.sense_key;
1736                                 if (cmdstatp->remainder_valid)
1737                                         undone = (int)cmdstatp->uremainder64;
1738                                 else if (STp->block_size == 0 &&
1739                                          scode == VOLUME_OVERFLOW)
1740                                         undone = transfer;
1741                                 else
1742                                         undone = 0;
1743                                 if (STp->block_size != 0)
1744                                         undone *= STp->block_size;
1745                                 if (undone <= do_count) {
1746                                         /* Only data from this write is not written */
1747                                         count += undone;
1748                                         b_point -= undone;
1749                                         do_count -= undone;
1750                                         if (STp->block_size)
1751                                                 blks = (transfer - undone) / STp->block_size;
1752                                         STps->eof = ST_EOM_OK;
1753                                         /* Continue in fixed block mode if all written
1754                                            in this request but still something left to write
1755                                            (retval left to zero)
1756                                         */
1757                                         if (STp->block_size == 0 ||
1758                                             undone > 0 || count == 0)
1759                                                 retval = (-ENOSPC); /* EOM within current request */
1760                                         DEBC(printk(ST_DEB_MSG
1761                                                        "%s: EOM with %d bytes unwritten.\n",
1762                                                        name, (int)count));
1763                                 } else {
1764                                         /* EOT within data buffered earlier (possible only
1765                                            in fixed block mode without direct i/o) */
1766                                         if (!retry_eot && !cmdstatp->deferred &&
1767                                             (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1768                                                 move_buffer_data(STp->buffer, transfer - undone);
1769                                                 retry_eot = 1;
1770                                                 if (STps->drv_block >= 0) {
1771                                                         STps->drv_block += (transfer - undone) /
1772                                                                 STp->block_size;
1773                                                 }
1774                                                 STps->eof = ST_EOM_OK;
1775                                                 DEBC(printk(ST_DEB_MSG
1776                                                             "%s: Retry write of %d bytes at EOM.\n",
1777                                                             name, STp->buffer->buffer_bytes));
1778                                                 goto retry_write;
1779                                         }
1780                                         else {
1781                                                 /* Either error within data buffered by driver or
1782                                                    failed retry */
1783                                                 count -= do_count;
1784                                                 blks = do_count = 0;
1785                                                 STps->eof = ST_EOM_ERROR;
1786                                                 STps->drv_block = (-1); /* Too cautious? */
1787                                                 retval = (-EIO);        /* EOM for old data */
1788                                                 DEBC(printk(ST_DEB_MSG
1789                                                             "%s: EOM with lost data.\n",
1790                                                             name));
1791                                         }
1792                                 }
1793                         } else {
1794                                 count += do_count;
1795                                 STps->drv_block = (-1);         /* Too cautious? */
1796                                 retval = STbp->syscall_result;
1797                         }
1798
1799                 }
1800
1801                 if (STps->drv_block >= 0) {
1802                         if (STp->block_size == 0)
1803                                 STps->drv_block += (do_count > 0);
1804                         else
1805                                 STps->drv_block += blks;
1806                 }
1807
1808                 STbp->buffer_bytes = 0;
1809                 STp->dirty = 0;
1810
1811                 if (retval || retry_eot) {
1812                         if (count < total)
1813                                 retval = total - count;
1814                         goto out;
1815                 }
1816         }
1817
1818         if (STps->eof == ST_EOD_1)
1819                 STps->eof = ST_EOM_OK;
1820         else if (STps->eof != ST_EOM_OK)
1821                 STps->eof = ST_NOEOF;
1822         retval = total - count;
1823
1824  out:
1825         if (SRpnt != NULL)
1826                 st_release_request(SRpnt);
1827         release_buffering(STp, 0);
1828         mutex_unlock(&STp->lock);
1829
1830         return retval;
1831 }
1832 \f
1833 /* Read data from the tape. Returns zero in the normal case, one if the
1834    eof status has changed, and the negative error code in case of a
1835    fatal error. Otherwise updates the buffer and the eof state.
1836
1837    Does release user buffer mapping if it is set.
1838 */
1839 static long read_tape(struct scsi_tape *STp, long count,
1840                       struct st_request ** aSRpnt)
1841 {
1842         int transfer, blks, bytes;
1843         unsigned char cmd[MAX_COMMAND_SIZE];
1844         struct st_request *SRpnt;
1845         struct st_modedef *STm;
1846         struct st_partstat *STps;
1847         struct st_buffer *STbp;
1848         int retval = 0;
1849         char *name = tape_name(STp);
1850
1851         if (count == 0)
1852                 return 0;
1853
1854         STm = &(STp->modes[STp->current_mode]);
1855         STps = &(STp->ps[STp->partition]);
1856         if (STps->eof == ST_FM_HIT)
1857                 return 1;
1858         STbp = STp->buffer;
1859
1860         if (STp->block_size == 0)
1861                 blks = bytes = count;
1862         else {
1863                 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1864                         blks = (STp->buffer)->buffer_blocks;
1865                         bytes = blks * STp->block_size;
1866                 } else {
1867                         bytes = count;
1868                         if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1869                                 bytes = (STp->buffer)->buffer_size;
1870                         blks = bytes / STp->block_size;
1871                         bytes = blks * STp->block_size;
1872                 }
1873         }
1874
1875         memset(cmd, 0, MAX_COMMAND_SIZE);
1876         cmd[0] = READ_6;
1877         cmd[1] = (STp->block_size != 0);
1878         if (!cmd[1] && STp->sili)
1879                 cmd[1] |= 2;
1880         cmd[2] = blks >> 16;
1881         cmd[3] = blks >> 8;
1882         cmd[4] = blks;
1883
1884         SRpnt = *aSRpnt;
1885         SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1886                            STp->device->request_queue->rq_timeout,
1887                            MAX_RETRIES, 1);
1888         release_buffering(STp, 1);
1889         *aSRpnt = SRpnt;
1890         if (!SRpnt)
1891                 return STbp->syscall_result;
1892
1893         STbp->read_pointer = 0;
1894         STps->at_sm = 0;
1895
1896         /* Something to check */
1897         if (STbp->syscall_result) {
1898                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1899
1900                 retval = 1;
1901                 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1902                             name,
1903                             SRpnt->sense[0], SRpnt->sense[1],
1904                             SRpnt->sense[2], SRpnt->sense[3],
1905                             SRpnt->sense[4], SRpnt->sense[5],
1906                             SRpnt->sense[6], SRpnt->sense[7]));
1907                 if (cmdstatp->have_sense) {
1908
1909                         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1910                                 cmdstatp->flags &= 0xcf;        /* No need for EOM in this case */
1911
1912                         if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1913                                 /* Compute the residual count */
1914                                 if (cmdstatp->remainder_valid)
1915                                         transfer = (int)cmdstatp->uremainder64;
1916                                 else
1917                                         transfer = 0;
1918                                 if (STp->block_size == 0 &&
1919                                     cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1920                                         transfer = bytes;
1921
1922                                 if (cmdstatp->flags & SENSE_ILI) {      /* ILI */
1923                                         if (STp->block_size == 0) {
1924                                                 if (transfer <= 0) {
1925                                                         if (transfer < 0)
1926                                                                 printk(KERN_NOTICE
1927                                                                        "%s: Failed to read %d byte block with %d byte transfer.\n",
1928                                                                        name, bytes - transfer, bytes);
1929                                                         if (STps->drv_block >= 0)
1930                                                                 STps->drv_block += 1;
1931                                                         STbp->buffer_bytes = 0;
1932                                                         return (-ENOMEM);
1933                                                 }
1934                                                 STbp->buffer_bytes = bytes - transfer;
1935                                         } else {
1936                                                 st_release_request(SRpnt);
1937                                                 SRpnt = *aSRpnt = NULL;
1938                                                 if (transfer == blks) { /* We did not get anything, error */
1939                                                         printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1940                                                         if (STps->drv_block >= 0)
1941                                                                 STps->drv_block += blks - transfer + 1;
1942                                                         st_int_ioctl(STp, MTBSR, 1);
1943                                                         return (-EIO);
1944                                                 }
1945                                                 /* We have some data, deliver it */
1946                                                 STbp->buffer_bytes = (blks - transfer) *
1947                                                     STp->block_size;
1948                                                 DEBC(printk(ST_DEB_MSG
1949                                                             "%s: ILI but enough data received %ld %d.\n",
1950                                                             name, count, STbp->buffer_bytes));
1951                                                 if (STps->drv_block >= 0)
1952                                                         STps->drv_block += 1;
1953                                                 if (st_int_ioctl(STp, MTBSR, 1))
1954                                                         return (-EIO);
1955                                         }
1956                                 } else if (cmdstatp->flags & SENSE_FMK) {       /* FM overrides EOM */
1957                                         if (STps->eof != ST_FM_HIT)
1958                                                 STps->eof = ST_FM_HIT;
1959                                         else
1960                                                 STps->eof = ST_EOD_2;
1961                                         if (STp->block_size == 0)
1962                                                 STbp->buffer_bytes = 0;
1963                                         else
1964                                                 STbp->buffer_bytes =
1965                                                     bytes - transfer * STp->block_size;
1966                                         DEBC(printk(ST_DEB_MSG
1967                                                     "%s: EOF detected (%d bytes read).\n",
1968                                                     name, STbp->buffer_bytes));
1969                                 } else if (cmdstatp->flags & SENSE_EOM) {
1970                                         if (STps->eof == ST_FM)
1971                                                 STps->eof = ST_EOD_1;
1972                                         else
1973                                                 STps->eof = ST_EOM_OK;
1974                                         if (STp->block_size == 0)
1975                                                 STbp->buffer_bytes = bytes - transfer;
1976                                         else
1977                                                 STbp->buffer_bytes =
1978                                                     bytes - transfer * STp->block_size;
1979
1980                                         DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1981                                                     name, STbp->buffer_bytes));
1982                                 }
1983                         }
1984                         /* end of EOF, EOM, ILI test */
1985                         else {  /* nonzero sense key */
1986                                 DEBC(printk(ST_DEB_MSG
1987                                             "%s: Tape error while reading.\n", name));
1988                                 STps->drv_block = (-1);
1989                                 if (STps->eof == ST_FM &&
1990                                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1991                                         DEBC(printk(ST_DEB_MSG
1992                                                     "%s: Zero returned for first BLANK CHECK after EOF.\n",
1993                                                     name));
1994                                         STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
1995                                 } else  /* Some other extended sense code */
1996                                         retval = (-EIO);
1997                         }
1998
1999                         if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
2000                                 STbp->buffer_bytes = 0;
2001                 }
2002                 /* End of extended sense test */
2003                 else {          /* Non-extended sense */
2004                         retval = STbp->syscall_result;
2005                 }
2006
2007         }
2008         /* End of error handling */
2009         else {                  /* Read successful */
2010                 STbp->buffer_bytes = bytes;
2011                 if (STp->sili) /* In fixed block mode residual is always zero here */
2012                         STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2013         }
2014
2015         if (STps->drv_block >= 0) {
2016                 if (STp->block_size == 0)
2017                         STps->drv_block++;
2018                 else
2019                         STps->drv_block += STbp->buffer_bytes / STp->block_size;
2020         }
2021         return retval;
2022 }
2023 \f
2024
2025 /* Read command */
2026 static ssize_t
2027 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2028 {
2029         ssize_t total;
2030         ssize_t retval = 0;
2031         ssize_t i, transfer;
2032         int special, do_dio = 0;
2033         struct st_request *SRpnt = NULL;
2034         struct scsi_tape *STp = filp->private_data;
2035         struct st_modedef *STm;
2036         struct st_partstat *STps;
2037         struct st_buffer *STbp = STp->buffer;
2038         DEB( char *name = tape_name(STp); )
2039
2040         if (mutex_lock_interruptible(&STp->lock))
2041                 return -ERESTARTSYS;
2042
2043         retval = rw_checks(STp, filp, count);
2044         if (retval || count == 0)
2045                 goto out;
2046
2047         STm = &(STp->modes[STp->current_mode]);
2048         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2049                 if (!STm->do_read_ahead) {
2050                         retval = (-EINVAL);     /* Read must be integral number of blocks */
2051                         goto out;
2052                 }
2053                 STp->try_dio_now = 0;  /* Direct i/o can't handle split blocks */
2054         }
2055
2056         STps = &(STp->ps[STp->partition]);
2057         if (STps->rw == ST_WRITING) {
2058                 retval = flush_buffer(STp, 0);
2059                 if (retval)
2060                         goto out;
2061                 STps->rw = ST_READING;
2062         }
2063         DEB(
2064         if (debugging && STps->eof != ST_NOEOF)
2065                 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2066                        STps->eof, STbp->buffer_bytes);
2067         ) /* end DEB */
2068
2069         retval = setup_buffering(STp, buf, count, 1);
2070         if (retval)
2071                 goto out;
2072         do_dio = STbp->do_dio;
2073
2074         if (STbp->buffer_bytes == 0 &&
2075             STps->eof >= ST_EOD_1) {
2076                 if (STps->eof < ST_EOD) {
2077                         STps->eof += 1;
2078                         retval = 0;
2079                         goto out;
2080                 }
2081                 retval = (-EIO);        /* EOM or Blank Check */
2082                 goto out;
2083         }
2084
2085         if (do_dio) {
2086                 /* Check the buffer writability before any tape movement. Don't alter
2087                    buffer data. */
2088                 if (copy_from_user(&i, buf, 1) != 0 ||
2089                     copy_to_user(buf, &i, 1) != 0 ||
2090                     copy_from_user(&i, buf + count - 1, 1) != 0 ||
2091                     copy_to_user(buf + count - 1, &i, 1) != 0) {
2092                         retval = (-EFAULT);
2093                         goto out;
2094                 }
2095         }
2096
2097         STps->rw = ST_READING;
2098
2099
2100         /* Loop until enough data in buffer or a special condition found */
2101         for (total = 0, special = 0; total < count && !special;) {
2102
2103                 /* Get new data if the buffer is empty */
2104                 if (STbp->buffer_bytes == 0) {
2105                         special = read_tape(STp, count - total, &SRpnt);
2106                         if (special < 0) {      /* No need to continue read */
2107                                 retval = special;
2108                                 goto out;
2109                         }
2110                 }
2111
2112                 /* Move the data from driver buffer to user buffer */
2113                 if (STbp->buffer_bytes > 0) {
2114                         DEB(
2115                         if (debugging && STps->eof != ST_NOEOF)
2116                                 printk(ST_DEB_MSG
2117                                        "%s: EOF up (%d). Left %d, needed %d.\n", name,
2118                                        STps->eof, STbp->buffer_bytes,
2119                                        (int)(count - total));
2120                         ) /* end DEB */
2121                         transfer = STbp->buffer_bytes < count - total ?
2122                             STbp->buffer_bytes : count - total;
2123                         if (!do_dio) {
2124                                 i = from_buffer(STbp, buf, transfer);
2125                                 if (i) {
2126                                         retval = i;
2127                                         goto out;
2128                                 }
2129                         }
2130                         buf += transfer;
2131                         total += transfer;
2132                 }
2133
2134                 if (STp->block_size == 0)
2135                         break;  /* Read only one variable length block */
2136
2137         }                       /* for (total = 0, special = 0;
2138                                    total < count && !special; ) */
2139
2140         /* Change the eof state if no data from tape or buffer */
2141         if (total == 0) {
2142                 if (STps->eof == ST_FM_HIT) {
2143                         STps->eof = ST_FM;
2144                         STps->drv_block = 0;
2145                         if (STps->drv_file >= 0)
2146                                 STps->drv_file++;
2147                 } else if (STps->eof == ST_EOD_1) {
2148                         STps->eof = ST_EOD_2;
2149                         STps->drv_block = 0;
2150                         if (STps->drv_file >= 0)
2151                                 STps->drv_file++;
2152                 } else if (STps->eof == ST_EOD_2)
2153                         STps->eof = ST_EOD;
2154         } else if (STps->eof == ST_FM)
2155                 STps->eof = ST_NOEOF;
2156         retval = total;
2157
2158  out:
2159         if (SRpnt != NULL) {
2160                 st_release_request(SRpnt);
2161                 SRpnt = NULL;
2162         }
2163         if (do_dio) {
2164                 release_buffering(STp, 1);
2165                 STbp->buffer_bytes = 0;
2166         }
2167         mutex_unlock(&STp->lock);
2168
2169         return retval;
2170 }
2171 \f
2172
2173
2174 DEB(
2175 /* Set the driver options */
2176 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2177 {
2178         if (debugging) {
2179                 printk(KERN_INFO
2180                        "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2181                        name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2182                        STm->do_read_ahead);
2183                 printk(KERN_INFO
2184                        "%s:    can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2185                        name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2186                 printk(KERN_INFO
2187                        "%s:    defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2188                        name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2189                        STp->scsi2_logical);
2190                 printk(KERN_INFO
2191                        "%s:    sysv: %d nowait: %d sili: %d nowait_filemark: %d\n",
2192                        name, STm->sysv, STp->immediate, STp->sili,
2193                        STp->immediate_filemark);
2194                 printk(KERN_INFO "%s:    debugging: %d\n",
2195                        name, debugging);
2196         }
2197 }
2198         )
2199
2200
2201 static int st_set_options(struct scsi_tape *STp, long options)
2202 {
2203         int value;
2204         long code;
2205         struct st_modedef *STm;
2206         char *name = tape_name(STp);
2207         struct cdev *cd0, *cd1;
2208
2209         STm = &(STp->modes[STp->current_mode]);
2210         if (!STm->defined) {
2211                 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2212                 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2213                 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2214                 modes_defined = 1;
2215                 DEBC(printk(ST_DEB_MSG
2216                             "%s: Initialized mode %d definition from mode 0\n",
2217                             name, STp->current_mode));
2218         }
2219
2220         code = options & MT_ST_OPTIONS;
2221         if (code == MT_ST_BOOLEANS) {
2222                 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2223                 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2224                 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2225                 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2226                 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2227                 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2228                 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2229                 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2230                 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2231                 if ((STp->device)->scsi_level >= SCSI_2)
2232                         STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2233                 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2234                 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2235                 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
2236                 STm->sysv = (options & MT_ST_SYSV) != 0;
2237                 STp->sili = (options & MT_ST_SILI) != 0;
2238                 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2239                      st_log_options(STp, STm, name); )
2240         } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2241                 value = (code == MT_ST_SETBOOLEANS);
2242                 if ((options & MT_ST_BUFFER_WRITES) != 0)
2243                         STm->do_buffer_writes = value;
2244                 if ((options & MT_ST_ASYNC_WRITES) != 0)
2245                         STm->do_async_writes = value;
2246                 if ((options & MT_ST_DEF_WRITES) != 0)
2247                         STm->defaults_for_writes = value;
2248                 if ((options & MT_ST_READ_AHEAD) != 0)
2249                         STm->do_read_ahead = value;
2250                 if ((options & MT_ST_TWO_FM) != 0)
2251                         STp->two_fm = value;
2252                 if ((options & MT_ST_FAST_MTEOM) != 0)
2253                         STp->fast_mteom = value;
2254                 if ((options & MT_ST_AUTO_LOCK) != 0)
2255                         STp->do_auto_lock = value;
2256                 if ((options & MT_ST_CAN_BSR) != 0)
2257                         STp->can_bsr = value;
2258                 if ((options & MT_ST_NO_BLKLIMS) != 0)
2259                         STp->omit_blklims = value;
2260                 if ((STp->device)->scsi_level >= SCSI_2 &&
2261                     (options & MT_ST_CAN_PARTITIONS) != 0)
2262                         STp->can_partitions = value;
2263                 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2264                         STp->scsi2_logical = value;
2265                 if ((options & MT_ST_NOWAIT) != 0)
2266                         STp->immediate = value;
2267                 if ((options & MT_ST_NOWAIT_EOF) != 0)
2268                         STp->immediate_filemark = value;
2269                 if ((options & MT_ST_SYSV) != 0)
2270                         STm->sysv = value;
2271                 if ((options & MT_ST_SILI) != 0)
2272                         STp->sili = value;
2273                 DEB(
2274                 if ((options & MT_ST_DEBUGGING) != 0)
2275                         debugging = value;
2276                         st_log_options(STp, STm, name); )
2277         } else if (code == MT_ST_WRITE_THRESHOLD) {
2278                 /* Retained for compatibility */
2279         } else if (code == MT_ST_DEF_BLKSIZE) {
2280                 value = (options & ~MT_ST_OPTIONS);
2281                 if (value == ~MT_ST_OPTIONS) {
2282                         STm->default_blksize = (-1);
2283                         DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2284                 } else {
2285                         STm->default_blksize = value;
2286                         DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2287                                name, STm->default_blksize));
2288                         if (STp->ready == ST_READY) {
2289                                 STp->blksize_changed = 0;
2290                                 set_mode_densblk(STp, STm);
2291                         }
2292                 }
2293         } else if (code == MT_ST_TIMEOUTS) {
2294                 value = (options & ~MT_ST_OPTIONS);
2295                 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2296                         STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2297                         DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2298                                (value & ~MT_ST_SET_LONG_TIMEOUT)));
2299                 } else {
2300                         blk_queue_rq_timeout(STp->device->request_queue,
2301                                              value * HZ);
2302                         DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2303                                 name, value) );
2304                 }
2305         } else if (code == MT_ST_SET_CLN) {
2306                 value = (options & ~MT_ST_OPTIONS) & 0xff;
2307                 if (value != 0 &&
2308                         (value < EXTENDED_SENSE_START ||
2309                                 value >= SCSI_SENSE_BUFFERSIZE))
2310                         return (-EINVAL);
2311                 STp->cln_mode = value;
2312                 STp->cln_sense_mask = (options >> 8) & 0xff;
2313                 STp->cln_sense_value = (options >> 16) & 0xff;
2314                 printk(KERN_INFO
2315                        "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2316                        name, value, STp->cln_sense_mask, STp->cln_sense_value);
2317         } else if (code == MT_ST_DEF_OPTIONS) {
2318                 code = (options & ~MT_ST_CLEAR_DEFAULT);
2319                 value = (options & MT_ST_CLEAR_DEFAULT);
2320                 if (code == MT_ST_DEF_DENSITY) {
2321                         if (value == MT_ST_CLEAR_DEFAULT) {
2322                                 STm->default_density = (-1);
2323                                 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2324                                        name));
2325                         } else {
2326                                 STm->default_density = value & 0xff;
2327                                 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2328                                        name, STm->default_density));
2329                                 if (STp->ready == ST_READY) {
2330                                         STp->density_changed = 0;
2331                                         set_mode_densblk(STp, STm);
2332                                 }
2333                         }
2334                 } else if (code == MT_ST_DEF_DRVBUFFER) {
2335                         if (value == MT_ST_CLEAR_DEFAULT) {
2336                                 STp->default_drvbuffer = 0xff;
2337                                 DEBC( printk(KERN_INFO
2338                                        "%s: Drive buffer default disabled.\n", name));
2339                         } else {
2340                                 STp->default_drvbuffer = value & 7;
2341                                 DEBC( printk(KERN_INFO
2342                                        "%s: Drive buffer default set to %x\n",
2343                                        name, STp->default_drvbuffer));
2344                                 if (STp->ready == ST_READY)
2345                                         st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2346                         }
2347                 } else if (code == MT_ST_DEF_COMPRESSION) {
2348                         if (value == MT_ST_CLEAR_DEFAULT) {
2349                                 STm->default_compression = ST_DONT_TOUCH;
2350                                 DEBC( printk(KERN_INFO
2351                                        "%s: Compression default disabled.\n", name));
2352                         } else {
2353                                 if ((value & 0xff00) != 0) {
2354                                         STp->c_algo = (value & 0xff00) >> 8;
2355                                         DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2356                                                name, STp->c_algo));
2357                                 }
2358                                 if ((value & 0xff) != 0xff) {
2359                                         STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2360                                         DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2361                                                name, (value & 1)));
2362                                         if (STp->ready == ST_READY) {
2363                                                 STp->compression_changed = 0;
2364                                                 st_compression(STp, (STm->default_compression == ST_YES));
2365                                         }
2366                                 }
2367                         }
2368                 }
2369         } else
2370                 return (-EIO);
2371
2372         return 0;
2373 }
2374 \f
2375 #define MODE_HEADER_LENGTH  4
2376
2377 /* Mode header and page byte offsets */
2378 #define MH_OFF_DATA_LENGTH     0
2379 #define MH_OFF_MEDIUM_TYPE     1
2380 #define MH_OFF_DEV_SPECIFIC    2
2381 #define MH_OFF_BDESCS_LENGTH   3
2382 #define MP_OFF_PAGE_NBR        0
2383 #define MP_OFF_PAGE_LENGTH     1
2384
2385 /* Mode header and page bit masks */
2386 #define MH_BIT_WP              0x80
2387 #define MP_MSK_PAGE_NBR        0x3f
2388
2389 /* Don't return block descriptors */
2390 #define MODE_SENSE_OMIT_BDESCS 0x08
2391
2392 #define MODE_SELECT_PAGE_FORMAT 0x10
2393
2394 /* Read a mode page into the tape buffer. The block descriptors are included
2395    if incl_block_descs is true. The page control is ored to the page number
2396    parameter, if necessary. */
2397 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2398 {
2399         unsigned char cmd[MAX_COMMAND_SIZE];
2400         struct st_request *SRpnt;
2401
2402         memset(cmd, 0, MAX_COMMAND_SIZE);
2403         cmd[0] = MODE_SENSE;
2404         if (omit_block_descs)
2405                 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2406         cmd[2] = page;
2407         cmd[4] = 255;
2408
2409         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2410                            STp->device->request_queue->rq_timeout, 0, 1);
2411         if (SRpnt == NULL)
2412                 return (STp->buffer)->syscall_result;
2413
2414         st_release_request(SRpnt);
2415
2416         return STp->buffer->syscall_result;
2417 }
2418
2419
2420 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2421    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2422 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2423 {
2424         int pgo;
2425         unsigned char cmd[MAX_COMMAND_SIZE];
2426         struct st_request *SRpnt;
2427         int timeout;
2428
2429         memset(cmd, 0, MAX_COMMAND_SIZE);
2430         cmd[0] = MODE_SELECT;
2431         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2432         pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2433         cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2434
2435         /* Clear reserved fields */
2436         (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2437         (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2438         (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2439         (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2440
2441         timeout = slow ?
2442                 STp->long_timeout : STp->device->request_queue->rq_timeout;
2443         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2444                            timeout, 0, 1);
2445         if (SRpnt == NULL)
2446                 return (STp->buffer)->syscall_result;
2447
2448         st_release_request(SRpnt);
2449
2450         return STp->buffer->syscall_result;
2451 }
2452
2453
2454 #define COMPRESSION_PAGE        0x0f
2455 #define COMPRESSION_PAGE_LENGTH 16
2456
2457 #define CP_OFF_DCE_DCC          2
2458 #define CP_OFF_C_ALGO           7
2459
2460 #define DCE_MASK  0x80
2461 #define DCC_MASK  0x40
2462 #define RED_MASK  0x60
2463
2464
2465 /* Control the compression with mode page 15. Algorithm not changed if zero.
2466
2467    The block descriptors are read and written because Sony SDT-7000 does not
2468    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2469    Including block descriptors should not cause any harm to other drives. */
2470
2471 static int st_compression(struct scsi_tape * STp, int state)
2472 {
2473         int retval;
2474         int mpoffs;  /* Offset to mode page start */
2475         unsigned char *b_data = (STp->buffer)->b_data;
2476         DEB( char *name = tape_name(STp); )
2477
2478         if (STp->ready != ST_READY)
2479                 return (-EIO);
2480
2481         /* Read the current page contents */
2482         retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2483         if (retval) {
2484                 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2485                             name));
2486                 return (-EIO);
2487         }
2488
2489         mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2490         DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2491                     (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2492
2493         /* Check if compression can be changed */
2494         if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2495                 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2496                 return (-EIO);
2497         }
2498
2499         /* Do the change */
2500         if (state) {
2501                 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2502                 if (STp->c_algo != 0)
2503                         b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2504         }
2505         else {
2506                 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2507                 if (STp->c_algo != 0)
2508                         b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2509         }
2510
2511         retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2512         if (retval) {
2513                 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2514                 return (-EIO);
2515         }
2516         DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2517                        name, state));
2518
2519         STp->compression_changed = 1;
2520         return 0;
2521 }
2522
2523
2524 /* Process the load and unload commands (does unload if the load code is zero) */
2525 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2526 {
2527         int retval = (-EIO), timeout;
2528         DEB( char *name = tape_name(STp); )
2529         unsigned char cmd[MAX_COMMAND_SIZE];
2530         struct st_partstat *STps;
2531         struct st_request *SRpnt;
2532
2533         if (STp->ready != ST_READY && !load_code) {
2534                 if (STp->ready == ST_NO_TAPE)
2535                         return (-ENOMEDIUM);
2536                 else
2537                         return (-EIO);
2538         }
2539
2540         memset(cmd, 0, MAX_COMMAND_SIZE);
2541         cmd[0] = START_STOP;
2542         if (load_code)
2543                 cmd[4] |= 1;
2544         /*
2545          * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2546          */
2547         if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2548             && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2549                 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2550                             name, (cmd[4]) ? "" : "un",
2551                             load_code - MT_ST_HPLOADER_OFFSET));
2552                 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2553         }
2554         if (STp->immediate) {
2555                 cmd[1] = 1;     /* Don't wait for completion */
2556                 timeout = STp->device->request_queue->rq_timeout;
2557         }
2558         else
2559                 timeout = STp->long_timeout;
2560
2561         DEBC(
2562                 if (!load_code)
2563                 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2564                 else
2565                 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2566                 );
2567
2568         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2569                            timeout, MAX_RETRIES, 1);
2570         if (!SRpnt)
2571                 return (STp->buffer)->syscall_result;
2572
2573         retval = (STp->buffer)->syscall_result;
2574         st_release_request(SRpnt);
2575
2576         if (!retval) {  /* SCSI command successful */
2577
2578                 if (!load_code) {
2579                         STp->rew_at_close = 0;
2580                         STp->ready = ST_NO_TAPE;
2581                 }
2582                 else {
2583                         STp->rew_at_close = STp->autorew_dev;
2584                         retval = check_tape(STp, filp);
2585                         if (retval > 0)
2586                                 retval = 0;
2587                 }
2588         }
2589         else {
2590                 STps = &(STp->ps[STp->partition]);
2591                 STps->drv_file = STps->drv_block = (-1);
2592         }
2593
2594         return retval;
2595 }
2596 \f
2597 #if DEBUG
2598 #define ST_DEB_FORWARD  0
2599 #define ST_DEB_BACKWARD 1
2600 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2601 {
2602         s32 sc;
2603
2604         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2605         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2606         if (direction)
2607                 sc = -sc;
2608         printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2609                direction ? "backward" : "forward", sc, units);
2610 }
2611 #endif
2612
2613
2614 /* Internal ioctl function */
2615 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2616 {
2617         int timeout;
2618         long ltmp;
2619         int ioctl_result;
2620         int chg_eof = 1;
2621         unsigned char cmd[MAX_COMMAND_SIZE];
2622         struct st_request *SRpnt;
2623         struct st_partstat *STps;
2624         int fileno, blkno, at_sm, undone;
2625         int datalen = 0, direction = DMA_NONE;
2626         char *name = tape_name(STp);
2627
2628         WARN_ON(STp->buffer->do_dio != 0);
2629         if (STp->ready != ST_READY) {
2630                 if (STp->ready == ST_NO_TAPE)
2631                         return (-ENOMEDIUM);
2632                 else
2633                         return (-EIO);
2634         }
2635         timeout = STp->long_timeout;
2636         STps = &(STp->ps[STp->partition]);
2637         fileno = STps->drv_file;
2638         blkno = STps->drv_block;
2639         at_sm = STps->at_sm;
2640
2641         memset(cmd, 0, MAX_COMMAND_SIZE);
2642         switch (cmd_in) {
2643         case MTFSFM:
2644                 chg_eof = 0;    /* Changed from the FSF after this */
2645         case MTFSF:
2646                 cmd[0] = SPACE;
2647                 cmd[1] = 0x01;  /* Space FileMarks */
2648                 cmd[2] = (arg >> 16);
2649                 cmd[3] = (arg >> 8);
2650                 cmd[4] = arg;
2651                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2652                 if (fileno >= 0)
2653                         fileno += arg;
2654                 blkno = 0;
2655                 at_sm &= (arg == 0);
2656                 break;
2657         case MTBSFM:
2658                 chg_eof = 0;    /* Changed from the FSF after this */
2659         case MTBSF:
2660                 cmd[0] = SPACE;
2661                 cmd[1] = 0x01;  /* Space FileMarks */
2662                 ltmp = (-arg);
2663                 cmd[2] = (ltmp >> 16);
2664                 cmd[3] = (ltmp >> 8);
2665                 cmd[4] = ltmp;
2666                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2667                 if (fileno >= 0)
2668                         fileno -= arg;
2669                 blkno = (-1);   /* We can't know the block number */
2670                 at_sm &= (arg == 0);
2671                 break;
2672         case MTFSR:
2673                 cmd[0] = SPACE;
2674                 cmd[1] = 0x00;  /* Space Blocks */
2675                 cmd[2] = (arg >> 16);
2676                 cmd[3] = (arg >> 8);
2677                 cmd[4] = arg;
2678                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2679                 if (blkno >= 0)
2680                         blkno += arg;
2681                 at_sm &= (arg == 0);
2682                 break;
2683         case MTBSR:
2684                 cmd[0] = SPACE;
2685                 cmd[1] = 0x00;  /* Space Blocks */
2686                 ltmp = (-arg);
2687                 cmd[2] = (ltmp >> 16);
2688                 cmd[3] = (ltmp >> 8);
2689                 cmd[4] = ltmp;
2690                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2691                 if (blkno >= 0)
2692                         blkno -= arg;
2693                 at_sm &= (arg == 0);
2694                 break;
2695         case MTFSS:
2696                 cmd[0] = SPACE;
2697                 cmd[1] = 0x04;  /* Space Setmarks */
2698                 cmd[2] = (arg >> 16);
2699                 cmd[3] = (arg >> 8);
2700                 cmd[4] = arg;
2701                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2702                 if (arg != 0) {
2703                         blkno = fileno = (-1);
2704                         at_sm = 1;
2705                 }
2706                 break;
2707         case MTBSS:
2708                 cmd[0] = SPACE;
2709                 cmd[1] = 0x04;  /* Space Setmarks */
2710                 ltmp = (-arg);
2711                 cmd[2] = (ltmp >> 16);
2712                 cmd[3] = (ltmp >> 8);
2713                 cmd[4] = ltmp;
2714                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2715                 if (arg != 0) {
2716                         blkno = fileno = (-1);
2717                         at_sm = 1;
2718                 }
2719                 break;
2720         case MTWEOF:
2721         case MTWEOFI:
2722         case MTWSM:
2723                 if (STp->write_prot)
2724                         return (-EACCES);
2725                 cmd[0] = WRITE_FILEMARKS;
2726                 if (cmd_in == MTWSM)
2727                         cmd[1] = 2;
2728                 if (cmd_in == MTWEOFI ||
2729                     (cmd_in == MTWEOF && STp->immediate_filemark))
2730                         cmd[1] |= 1;
2731                 cmd[2] = (arg >> 16);
2732                 cmd[3] = (arg >> 8);
2733                 cmd[4] = arg;
2734                 timeout = STp->device->request_queue->rq_timeout;
2735                 DEBC(
2736                      if (cmd_in != MTWSM)
2737                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2738                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2739                      else
2740                                 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2741                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2742                 )
2743                 if (fileno >= 0)
2744                         fileno += arg;
2745                 blkno = 0;
2746                 at_sm = (cmd_in == MTWSM);
2747                 break;
2748         case MTREW:
2749                 cmd[0] = REZERO_UNIT;
2750                 if (STp->immediate) {
2751                         cmd[1] = 1;     /* Don't wait for completion */
2752                         timeout = STp->device->request_queue->rq_timeout;
2753                 }
2754                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2755                 fileno = blkno = at_sm = 0;
2756                 break;
2757         case MTNOP:
2758                 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2759                 return 0;       /* Should do something ? */
2760                 break;
2761         case MTRETEN:
2762                 cmd[0] = START_STOP;
2763                 if (STp->immediate) {
2764                         cmd[1] = 1;     /* Don't wait for completion */
2765                         timeout = STp->device->request_queue->rq_timeout;
2766                 }
2767                 cmd[4] = 3;
2768                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2769                 fileno = blkno = at_sm = 0;
2770                 break;
2771         case MTEOM:
2772                 if (!STp->fast_mteom) {
2773                         /* space to the end of tape */
2774                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2775                         fileno = STps->drv_file;
2776                         if (STps->eof >= ST_EOD_1)
2777                                 return 0;
2778                         /* The next lines would hide the number of spaced FileMarks
2779                            That's why I inserted the previous lines. I had no luck
2780                            with detecting EOM with FSF, so we go now to EOM.
2781                            Joerg Weule */
2782                 } else
2783                         fileno = (-1);
2784                 cmd[0] = SPACE;
2785                 cmd[1] = 3;
2786                 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2787                             name));
2788                 blkno = -1;
2789                 at_sm = 0;
2790                 break;
2791         case MTERASE:
2792                 if (STp->write_prot)
2793                         return (-EACCES);
2794                 cmd[0] = ERASE;
2795                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2796                 if (STp->immediate) {
2797                         cmd[1] |= 2;    /* Don't wait for completion */
2798                         timeout = STp->device->request_queue->rq_timeout;
2799                 }
2800                 else
2801                         timeout = STp->long_timeout * 8;
2802
2803                 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2804                 fileno = blkno = at_sm = 0;
2805                 break;
2806         case MTSETBLK:          /* Set block length */
2807         case MTSETDENSITY:      /* Set tape density */
2808         case MTSETDRVBUFFER:    /* Set drive buffering */
2809         case SET_DENS_AND_BLK:  /* Set density and block size */
2810                 chg_eof = 0;
2811                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2812                         return (-EIO);  /* Not allowed if data in buffer */
2813                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2814                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2815                     STp->max_block > 0 &&
2816                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2817                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2818                         printk(KERN_WARNING "%s: Illegal block size.\n", name);
2819                         return (-EINVAL);
2820                 }
2821                 cmd[0] = MODE_SELECT;
2822                 if ((STp->use_pf & USE_PF))
2823                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2824                 cmd[4] = datalen = 12;
2825                 direction = DMA_TO_DEVICE;
2826
2827                 memset((STp->buffer)->b_data, 0, 12);
2828                 if (cmd_in == MTSETDRVBUFFER)
2829                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2830                 else
2831                         (STp->buffer)->b_data[2] =
2832                             STp->drv_buffer << 4;
2833                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2834                 if (cmd_in == MTSETDENSITY) {
2835                         (STp->buffer)->b_data[4] = arg;
2836                         STp->density_changed = 1;       /* At least we tried ;-) */
2837                 } else if (cmd_in == SET_DENS_AND_BLK)
2838                         (STp->buffer)->b_data[4] = arg >> 24;
2839                 else
2840                         (STp->buffer)->b_data[4] = STp->density;
2841                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2842                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2843                         if (cmd_in == MTSETBLK)
2844                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2845                 } else
2846                         ltmp = STp->block_size;
2847                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2848                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2849                 (STp->buffer)->b_data[11] = ltmp;
2850                 timeout = STp->device->request_queue->rq_timeout;
2851                 DEBC(
2852                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2853                                 printk(ST_DEB_MSG
2854                                        "%s: Setting block size to %d bytes.\n", name,
2855                                        (STp->buffer)->b_data[9] * 65536 +
2856                                        (STp->buffer)->b_data[10] * 256 +
2857                                        (STp->buffer)->b_data[11]);
2858                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2859                                 printk(ST_DEB_MSG
2860                                        "%s: Setting density code to %x.\n", name,
2861                                        (STp->buffer)->b_data[4]);
2862                         if (cmd_in == MTSETDRVBUFFER)
2863                                 printk(ST_DEB_MSG
2864                                        "%s: Setting drive buffer code to %d.\n", name,
2865                                     ((STp->buffer)->b_data[2] >> 4) & 7);
2866                 )
2867                 break;
2868         default:
2869                 return (-ENOSYS);
2870         }
2871
2872         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2873                            timeout, MAX_RETRIES, 1);
2874         if (!SRpnt)
2875                 return (STp->buffer)->syscall_result;
2876
2877         ioctl_result = (STp->buffer)->syscall_result;
2878
2879         if (!ioctl_result) {    /* SCSI command successful */
2880                 st_release_request(SRpnt);
2881                 SRpnt = NULL;
2882                 STps->drv_block = blkno;
2883                 STps->drv_file = fileno;
2884                 STps->at_sm = at_sm;
2885
2886                 if (cmd_in == MTBSFM)
2887                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2888                 else if (cmd_in == MTFSFM)
2889                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2890
2891                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2892                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2893                         if (STp->block_size != 0) {
2894                                 (STp->buffer)->buffer_blocks =
2895                                     (STp->buffer)->buffer_size / STp->block_size;
2896                         }
2897                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2898                         if (cmd_in == SET_DENS_AND_BLK)
2899                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2900                 } else if (cmd_in == MTSETDRVBUFFER)
2901                         STp->drv_buffer = (arg & 7);
2902                 else if (cmd_in == MTSETDENSITY)
2903                         STp->density = arg;
2904
2905                 if (cmd_in == MTEOM)
2906                         STps->eof = ST_EOD;
2907                 else if (cmd_in == MTFSF)
2908                         STps->eof = ST_FM;
2909                 else if (chg_eof)
2910                         STps->eof = ST_NOEOF;
2911
2912                 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2913                         STps->rw = ST_IDLE;  /* prevent automatic WEOF at close */
2914         } else { /* SCSI command was not completely successful. Don't return
2915                     from this block without releasing the SCSI command block! */
2916                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2917
2918                 if (cmdstatp->flags & SENSE_EOM) {
2919                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2920                             cmd_in != MTBSR && cmd_in != MTBSS)
2921                                 STps->eof = ST_EOM_OK;
2922                         STps->drv_block = 0;
2923                 }
2924
2925                 if (cmdstatp->remainder_valid)
2926                         undone = (int)cmdstatp->uremainder64;
2927                 else
2928                         undone = 0;
2929
2930                 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
2931                     cmdstatp->have_sense &&
2932                     (cmdstatp->flags & SENSE_EOM)) {
2933                         if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2934                             cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2935                                 ioctl_result = 0;       /* EOF(s) written successfully at EOM */
2936                                 STps->eof = ST_NOEOF;
2937                         } else {  /* Writing EOF(s) failed */
2938                                 if (fileno >= 0)
2939                                         fileno -= undone;
2940                                 if (undone < arg)
2941                                         STps->eof = ST_NOEOF;
2942                         }
2943                         STps->drv_file = fileno;
2944                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2945                         if (fileno >= 0)
2946                                 STps->drv_file = fileno - undone;
2947                         else
2948                                 STps->drv_file = fileno;
2949                         STps->drv_block = -1;
2950                         STps->eof = ST_NOEOF;
2951                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2952                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2953                                 undone = (-undone);
2954                         if (STps->drv_file >= 0)
2955                                 STps->drv_file = fileno + undone;
2956                         STps->drv_block = 0;
2957                         STps->eof = ST_NOEOF;
2958                 } else if (cmd_in == MTFSR) {
2959                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2960                                 if (STps->drv_file >= 0)
2961                                         STps->drv_file++;
2962                                 STps->drv_block = 0;
2963                                 STps->eof = ST_FM;
2964                         } else {
2965                                 if (blkno >= undone)
2966                                         STps->drv_block = blkno - undone;
2967                                 else
2968                                         STps->drv_block = (-1);
2969                                 STps->eof = ST_NOEOF;
2970                         }
2971                 } else if (cmd_in == MTBSR) {
2972                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2973                                 STps->drv_file--;
2974                                 STps->drv_block = (-1);
2975                         } else {
2976                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2977                                         undone = (-undone);
2978                                 if (STps->drv_block >= 0)
2979                                         STps->drv_block = blkno + undone;
2980                         }
2981                         STps->eof = ST_NOEOF;
2982                 } else if (cmd_in == MTEOM) {
2983                         STps->drv_file = (-1);
2984                         STps->drv_block = (-1);
2985                         STps->eof = ST_EOD;
2986                 } else if (cmd_in == MTSETBLK ||
2987                            cmd_in == MTSETDENSITY ||
2988                            cmd_in == MTSETDRVBUFFER ||
2989                            cmd_in == SET_DENS_AND_BLK) {
2990                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2991                             !(STp->use_pf & PF_TESTED)) {
2992                                 /* Try the other possible state of Page Format if not
2993                                    already tried */
2994                                 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2995                                 st_release_request(SRpnt);
2996                                 SRpnt = NULL;
2997                                 return st_int_ioctl(STp, cmd_in, arg);
2998                         }
2999                 } else if (chg_eof)
3000                         STps->eof = ST_NOEOF;
3001
3002                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3003                         STps->eof = ST_EOD;
3004
3005                 st_release_request(SRpnt);
3006                 SRpnt = NULL;
3007         }
3008
3009         return ioctl_result;
3010 }
3011 \f
3012
3013 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3014    structure. */
3015
3016 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3017                         int logical)
3018 {
3019         int result;
3020         unsigned char scmd[MAX_COMMAND_SIZE];
3021         struct st_request *SRpnt;
3022         DEB( char *name = tape_name(STp); )
3023
3024         if (STp->ready != ST_READY)
3025                 return (-EIO);
3026
3027         memset(scmd, 0, MAX_COMMAND_SIZE);
3028         if ((STp->device)->scsi_level < SCSI_2) {
3029                 scmd[0] = QFA_REQUEST_BLOCK;
3030                 scmd[4] = 3;
3031         } else {
3032                 scmd[0] = READ_POSITION;
3033                 if (!logical && !STp->scsi2_logical)
3034                         scmd[1] = 1;
3035         }
3036         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3037                            STp->device->request_queue->rq_timeout,
3038                            MAX_READY_RETRIES, 1);
3039         if (!SRpnt)
3040                 return (STp->buffer)->syscall_result;
3041
3042         if ((STp->buffer)->syscall_result != 0 ||
3043             (STp->device->scsi_level >= SCSI_2 &&
3044              ((STp->buffer)->b_data[0] & 4) != 0)) {
3045                 *block = *partition = 0;
3046                 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3047                 result = (-EIO);
3048         } else {
3049                 result = 0;
3050                 if ((STp->device)->scsi_level < SCSI_2) {
3051                         *block = ((STp->buffer)->b_data[0] << 16)
3052                             + ((STp->buffer)->b_data[1] << 8)
3053                             + (STp->buffer)->b_data[2];
3054                         *partition = 0;
3055                 } else {
3056                         *block = ((STp->buffer)->b_data[4] << 24)
3057                             + ((STp->buffer)->b_data[5] << 16)
3058                             + ((STp->buffer)->b_data[6] << 8)
3059                             + (STp->buffer)->b_data[7];
3060                         *partition = (STp->buffer)->b_data[1];
3061                         if (((STp->buffer)->b_data[0] & 0x80) &&
3062                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
3063                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3064                 }
3065                 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3066                             *block, *partition));
3067         }
3068         st_release_request(SRpnt);
3069         SRpnt = NULL;
3070
3071         return result;
3072 }
3073
3074
3075 /* Set the tape block and partition. Negative partition means that only the
3076    block should be set in vendor specific way. */
3077 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3078                         int logical)
3079 {
3080         struct st_partstat *STps;
3081         int result, p;
3082         unsigned int blk;
3083         int timeout;
3084         unsigned char scmd[MAX_COMMAND_SIZE];
3085         struct st_request *SRpnt;
3086         DEB( char *name = tape_name(STp); )
3087
3088         if (STp->ready != ST_READY)
3089                 return (-EIO);
3090         timeout = STp->long_timeout;
3091         STps = &(STp->ps[STp->partition]);
3092
3093         DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3094                     name, block, partition));
3095         DEB(if (partition < 0)
3096                 return (-EIO); )
3097
3098         /* Update the location at the partition we are leaving */
3099         if ((!STp->can_partitions && partition != 0) ||
3100             partition >= ST_NBR_PARTITIONS)
3101                 return (-EINVAL);
3102         if (partition != STp->partition) {
3103                 if (get_location(STp, &blk, &p, 1))
3104                         STps->last_block_valid = 0;
3105                 else {
3106                         STps->last_block_valid = 1;
3107                         STps->last_block_visited = blk;
3108                         DEBC(printk(ST_DEB_MSG
3109                                     "%s: Visited block %d for partition %d saved.\n",
3110                                     name, blk, STp->partition));
3111                 }
3112         }
3113
3114         memset(scmd, 0, MAX_COMMAND_SIZE);
3115         if ((STp->device)->scsi_level < SCSI_2) {
3116                 scmd[0] = QFA_SEEK_BLOCK;
3117                 scmd[2] = (block >> 16);
3118                 scmd[3] = (block >> 8);
3119                 scmd[4] = block;
3120                 scmd[5] = 0;
3121         } else {
3122                 scmd[0] = SEEK_10;
3123                 scmd[3] = (block >> 24);
3124                 scmd[4] = (block >> 16);
3125                 scmd[5] = (block >> 8);
3126                 scmd[6] = block;
3127                 if (!logical && !STp->scsi2_logical)
3128                         scmd[1] = 4;
3129                 if (STp->partition != partition) {
3130                         scmd[1] |= 2;
3131                         scmd[8] = partition;
3132                         DEBC(printk(ST_DEB_MSG
3133                                     "%s: Trying to change partition from %d to %d\n",
3134                                     name, STp->partition, partition));
3135                 }
3136         }
3137         if (STp->immediate) {
3138                 scmd[1] |= 1;           /* Don't wait for completion */
3139                 timeout = STp->device->request_queue->rq_timeout;
3140         }
3141
3142         SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3143                            timeout, MAX_READY_RETRIES, 1);
3144         if (!SRpnt)
3145                 return (STp->buffer)->syscall_result;
3146
3147         STps->drv_block = STps->drv_file = (-1);
3148         STps->eof = ST_NOEOF;
3149         if ((STp->buffer)->syscall_result != 0) {
3150                 result = (-EIO);
3151                 if (STp->can_partitions &&
3152                     (STp->device)->scsi_level >= SCSI_2 &&
3153                     (p = find_partition(STp)) >= 0)
3154                         STp->partition = p;
3155         } else {
3156                 if (STp->can_partitions) {
3157                         STp->partition = partition;
3158                         STps = &(STp->ps[partition]);
3159                         if (!STps->last_block_valid ||
3160                             STps->last_block_visited != block) {
3161                                 STps->at_sm = 0;
3162                                 STps->rw = ST_IDLE;
3163                         }
3164                 } else
3165                         STps->at_sm = 0;
3166                 if (block == 0)
3167                         STps->drv_block = STps->drv_file = 0;
3168                 result = 0;
3169         }
3170
3171         st_release_request(SRpnt);
3172         SRpnt = NULL;
3173
3174         return result;
3175 }
3176
3177
3178 /* Find the current partition number for the drive status. Called from open and
3179    returns either partition number of negative error code. */
3180 static int find_partition(struct scsi_tape *STp)
3181 {
3182         int i, partition;
3183         unsigned int block;
3184
3185         if ((i = get_location(STp, &block, &partition, 1)) < 0)
3186                 return i;
3187         if (partition >= ST_NBR_PARTITIONS)
3188                 return (-EIO);
3189         return partition;
3190 }
3191
3192
3193 /* Change the partition if necessary */
3194 static int switch_partition(struct scsi_tape *STp)
3195 {
3196         struct st_partstat *STps;
3197
3198         if (STp->partition == STp->new_partition)
3199                 return 0;
3200         STps = &(STp->ps[STp->new_partition]);
3201         if (!STps->last_block_valid)
3202                 STps->last_block_visited = 0;
3203         return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3204 }
3205 \f
3206 /* Functions for reading and writing the medium partition mode page. */
3207
3208 #define PART_PAGE   0x11
3209 #define PART_PAGE_FIXED_LENGTH 8
3210
3211 #define PP_OFF_MAX_ADD_PARTS   2
3212 #define PP_OFF_NBR_ADD_PARTS   3
3213 #define PP_OFF_FLAGS           4
3214 #define PP_OFF_PART_UNITS      6
3215 #define PP_OFF_RESERVED        7
3216
3217 #define PP_BIT_IDP             0x20
3218 #define PP_MSK_PSUM_MB         0x10
3219
3220 /* Get the number of partitions on the tape. As a side effect reads the
3221    mode page into the tape buffer. */
3222 static int nbr_partitions(struct scsi_tape *STp)
3223 {
3224         int result;
3225         DEB( char *name = tape_name(STp); )
3226
3227         if (STp->ready != ST_READY)
3228                 return (-EIO);
3229
3230         result = read_mode_page(STp, PART_PAGE, 1);
3231
3232         if (result) {
3233                 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3234                             name));
3235                 result = (-EIO);
3236         } else {
3237                 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3238                                               PP_OFF_NBR_ADD_PARTS] + 1;
3239                 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3240         }
3241
3242         return result;
3243 }
3244
3245
3246 /* Partition the tape into two partitions if size > 0 or one partition if
3247    size == 0.
3248
3249    The block descriptors are read and written because Sony SDT-7000 does not
3250    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3251
3252    My HP C1533A drive returns only one partition size field. This is used to
3253    set the size of partition 1. There is no size field for the default partition.
3254    Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3255    used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3256    The following algorithm is used to accommodate both drives: if the number of
3257    partition size fields is greater than the maximum number of additional partitions
3258    in the mode page, the second field is used. Otherwise the first field is used.
3259
3260    For Seagate DDS drives the page length must be 8 when no partitions is defined
3261    and 10 when 1 partition is defined (information from Eric Lee Green). This is
3262    is acceptable also to some other old drives and enforced if the first partition
3263    size field is used for the first additional partition size.
3264  */
3265 static int partition_tape(struct scsi_tape *STp, int size)
3266 {
3267         char *name = tape_name(STp);
3268         int result;
3269         int pgo, psd_cnt, psdo;
3270         unsigned char *bp;
3271
3272         result = read_mode_page(STp, PART_PAGE, 0);
3273         if (result) {
3274                 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3275                 return result;
3276         }
3277         /* The mode page is in the buffer. Let's modify it and write it. */
3278         bp = (STp->buffer)->b_data;
3279         pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3280         DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3281                     name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3282
3283         psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3284         psdo = pgo + PART_PAGE_FIXED_LENGTH;
3285         if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3286                 bp[psdo] = bp[psdo + 1] = 0xff;  /* Rest of the tape */
3287                 psdo += 2;
3288         }
3289         memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3290
3291         DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3292                     psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3293                     bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3294
3295         if (size <= 0) {
3296                 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3297                 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3298                     bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3299                 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3300                             name));
3301         } else {
3302                 bp[psdo] = (size >> 8) & 0xff;
3303                 bp[psdo + 1] = size & 0xff;
3304                 bp[pgo + 3] = 1;
3305                 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3306                     bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3307                 DEBC(printk(ST_DEB_MSG
3308                             "%s: Formatting tape with two partitions (1 = %d MB).\n",
3309                             name, size));
3310         }
3311         bp[pgo + PP_OFF_PART_UNITS] = 0;
3312         bp[pgo + PP_OFF_RESERVED] = 0;
3313         bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3314
3315         result = write_mode_page(STp, PART_PAGE, 1);
3316         if (result) {
3317                 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3318                 result = (-EIO);
3319         }
3320
3321         return result;
3322 }
3323 \f
3324
3325
3326 /* The ioctl command */
3327 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3328 {
3329         int i, cmd_nr, cmd_type, bt;
3330         int retval = 0;
3331         unsigned int blk;
3332         struct scsi_tape *STp = file->private_data;
3333         struct st_modedef *STm;
3334         struct st_partstat *STps;
3335         char *name = tape_name(STp);
3336         void __user *p = (void __user *)arg;
3337
3338         if (mutex_lock_interruptible(&STp->lock))
3339                 return -ERESTARTSYS;
3340
3341         DEB(
3342         if (debugging && !STp->in_use) {
3343                 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3344                 retval = (-EIO);
3345                 goto out;
3346         } ) /* end DEB */
3347
3348         STm = &(STp->modes[STp->current_mode]);
3349         STps = &(STp->ps[STp->partition]);
3350
3351         /*
3352          * If we are in the middle of error recovery, don't let anyone
3353          * else try and use this device.  Also, if error recovery fails, it
3354          * may try and take the device offline, in which case all further
3355          * access to the device is prohibited.
3356          */
3357         retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3358                                         file->f_flags & O_NDELAY);
3359         if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3360                 goto out;
3361         retval = 0;
3362
3363         cmd_type = _IOC_TYPE(cmd_in);
3364         cmd_nr = _IOC_NR(cmd_in);
3365
3366         if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3367                 struct mtop mtc;
3368
3369                 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3370                         retval = (-EINVAL);
3371                         goto out;
3372                 }
3373
3374                 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3375                 if (i) {
3376                         retval = (-EFAULT);
3377                         goto out;
3378                 }
3379
3380                 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3381                         printk(KERN_WARNING
3382                                "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3383                         retval = (-EPERM);
3384                         goto out;
3385                 }
3386                 if (!STm->defined &&
3387                     (mtc.mt_op != MTSETDRVBUFFER &&
3388                      (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3389                         retval = (-ENXIO);
3390                         goto out;
3391                 }
3392
3393                 if (!STp->pos_unknown) {
3394
3395                         if (STps->eof == ST_FM_HIT) {
3396                                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3397                                     mtc.mt_op == MTEOM) {
3398                                         mtc.mt_count -= 1;
3399                                         if (STps->drv_file >= 0)
3400                                                 STps->drv_file += 1;
3401                                 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3402                                         mtc.mt_count += 1;
3403                                         if (STps->drv_file >= 0)
3404                                                 STps->drv_file += 1;
3405                                 }
3406                         }
3407
3408                         if (mtc.mt_op == MTSEEK) {
3409                                 /* Old position must be restored if partition will be
3410                                    changed */
3411                                 i = !STp->can_partitions ||
3412                                     (STp->new_partition != STp->partition);
3413                         } else {
3414                                 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3415                                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3416                                     mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3417                                     mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3418                                     mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3419                                     mtc.mt_op == MTCOMPRESSION;
3420                         }
3421                         i = flush_buffer(STp, i);
3422                         if (i < 0) {
3423                                 retval = i;
3424                                 goto out;
3425                         }
3426                         if (STps->rw == ST_WRITING &&
3427                             (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3428                              mtc.mt_op == MTSEEK ||
3429                              mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3430                                 i = st_int_ioctl(STp, MTWEOF, 1);
3431                                 if (i < 0) {
3432                                         retval = i;
3433                                         goto out;
3434                                 }
3435                                 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3436                                         mtc.mt_count++;
3437                                 STps->rw = ST_IDLE;
3438                              }
3439
3440                 } else {
3441                         /*
3442                          * If there was a bus reset, block further access
3443                          * to this device.  If the user wants to rewind the tape,
3444                          * then reset the flag and allow access again.
3445                          */
3446                         if (mtc.mt_op != MTREW &&
3447                             mtc.mt_op != MTOFFL &&
3448                             mtc.mt_op != MTRETEN &&
3449                             mtc.mt_op != MTERASE &&
3450                             mtc.mt_op != MTSEEK &&
3451                             mtc.mt_op != MTEOM) {
3452                                 retval = (-EIO);
3453                                 goto out;
3454                         }
3455                         reset_state(STp);
3456                         /* remove this when the midlevel properly clears was_reset */
3457                         STp->device->was_reset = 0;
3458                 }
3459
3460                 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3461                     mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3462                     mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3463                         STps->rw = ST_IDLE;     /* Prevent automatic WEOF and fsf */
3464
3465                 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3466                         do_door_lock(STp, 0);   /* Ignore result! */
3467
3468                 if (mtc.mt_op == MTSETDRVBUFFER &&
3469                     (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3470                         retval = st_set_options(STp, mtc.mt_count);
3471                         goto out;
3472                 }
3473
3474                 if (mtc.mt_op == MTSETPART) {
3475                         if (!STp->can_partitions ||
3476                             mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3477                                 retval = (-EINVAL);
3478                                 goto out;
3479                         }
3480                         if (mtc.mt_count >= STp->nbr_partitions &&
3481                             (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3482                                 retval = (-EIO);
3483                                 goto out;
3484                         }
3485                         if (mtc.mt_count >= STp->nbr_partitions) {
3486                                 retval = (-EINVAL);
3487                                 goto out;
3488                         }
3489                         STp->new_partition = mtc.mt_count;
3490                         retval = 0;
3491                         goto out;
3492                 }
3493
3494                 if (mtc.mt_op == MTMKPART) {
3495                         if (!STp->can_partitions) {
3496                                 retval = (-EINVAL);
3497                                 goto out;
3498                         }
3499                         if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3500                             (i = partition_tape(STp, mtc.mt_count)) < 0) {
3501                                 retval = i;
3502                                 goto out;
3503                         }
3504                         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3505                                 STp->ps[i].rw = ST_IDLE;
3506                                 STp->ps[i].at_sm = 0;
3507                                 STp->ps[i].last_block_valid = 0;
3508                         }
3509                         STp->partition = STp->new_partition = 0;
3510                         STp->nbr_partitions = 1;        /* Bad guess ?-) */
3511                         STps->drv_block = STps->drv_file = 0;
3512                         retval = 0;
3513                         goto out;
3514                 }
3515
3516                 if (mtc.mt_op == MTSEEK) {
3517                         i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3518                         if (!STp->can_partitions)
3519                                 STp->ps[0].rw = ST_IDLE;
3520                         retval = i;
3521                         goto out;
3522                 }
3523
3524                 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3525                         retval = do_load_unload(STp, file, 0);
3526                         goto out;
3527                 }
3528
3529                 if (mtc.mt_op == MTLOAD) {
3530                         retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3531                         goto out;
3532                 }
3533
3534                 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3535                         retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3536                         goto out;
3537                 }
3538
3539                 if (STp->can_partitions && STp->ready == ST_READY &&
3540                     (i = switch_partition(STp)) < 0) {
3541                         retval = i;
3542                         goto out;
3543                 }
3544
3545                 if (mtc.mt_op == MTCOMPRESSION)
3546                         retval = st_compression(STp, (mtc.mt_count & 1));
3547                 else
3548                         retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3549                 goto out;
3550         }
3551         if (!STm->defined) {
3552                 retval = (-ENXIO);
3553                 goto out;
3554         }
3555
3556         if ((i = flush_buffer(STp, 0)) < 0) {
3557                 retval = i;
3558                 goto out;
3559         }
3560         if (STp->can_partitions &&
3561             (i = switch_partition(STp)) < 0) {
3562                 retval = i;
3563                 goto out;
3564         }
3565
3566         if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3567                 struct mtget mt_status;
3568
3569                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3570                          retval = (-EINVAL);
3571                          goto out;
3572                 }
3573
3574                 mt_status.mt_type = STp->tape_type;
3575                 mt_status.mt_dsreg =
3576                     ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3577                     ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3578                 mt_status.mt_blkno = STps->drv_block;
3579                 mt_status.mt_fileno = STps->drv_file;
3580                 if (STp->block_size != 0) {
3581                         if (STps->rw == ST_WRITING)
3582                                 mt_status.mt_blkno +=
3583                                     (STp->buffer)->buffer_bytes / STp->block_size;
3584                         else if (STps->rw == ST_READING)
3585                                 mt_status.mt_blkno -=
3586                                         ((STp->buffer)->buffer_bytes +
3587                                          STp->block_size - 1) / STp->block_size;
3588                 }
3589
3590                 mt_status.mt_gstat = 0;
3591                 if (STp->drv_write_prot)
3592                         mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3593                 if (mt_status.mt_blkno == 0) {
3594                         if (mt_status.mt_fileno == 0)
3595                                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3596                         else
3597                                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3598                 }
3599                 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3600                 mt_status.mt_resid = STp->partition;
3601                 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3602                         mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3603                 else if (STps->eof >= ST_EOM_OK)
3604                         mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3605                 if (STp->density == 1)
3606                         mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3607                 else if (STp->density == 2)
3608                         mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3609                 else if (STp->density == 3)
3610                         mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3611                 if (STp->ready == ST_READY)
3612                         mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3613                 if (STp->ready == ST_NO_TAPE)
3614                         mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3615                 if (STps->at_sm)
3616                         mt_status.mt_gstat |= GMT_SM(0xffffffff);
3617                 if (STm->do_async_writes ||
3618                     (STm->do_buffer_writes && STp->block_size != 0) ||
3619                     STp->drv_buffer != 0)
3620                         mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3621                 if (STp->cleaning_req)
3622                         mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3623
3624                 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3625                 if (i) {
3626                         retval = (-EFAULT);
3627                         goto out;
3628                 }
3629
3630                 STp->recover_reg = 0;           /* Clear after read */
3631                 retval = 0;
3632                 goto out;
3633         }                       /* End of MTIOCGET */
3634         if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3635                 struct mtpos mt_pos;
3636                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3637                          retval = (-EINVAL);
3638                          goto out;
3639                 }
3640                 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3641                         retval = i;
3642                         goto out;
3643                 }
3644                 mt_pos.mt_blkno = blk;
3645                 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3646                 if (i)
3647                         retval = (-EFAULT);
3648                 goto out;
3649         }
3650         mutex_unlock(&STp->lock);
3651         switch (cmd_in) {
3652                 case SCSI_IOCTL_GET_IDLUN:
3653                 case SCSI_IOCTL_GET_BUS_NUMBER:
3654                         break;
3655                 default:
3656                         if ((cmd_in == SG_IO ||
3657                              cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3658                              cmd_in == CDROM_SEND_PACKET) &&
3659                             !capable(CAP_SYS_RAWIO))
3660                                 i = -EPERM;
3661                         else
3662                                 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3663                                                    file->f_mode, cmd_in, p);
3664                         if (i != -ENOTTY)
3665                                 return i;
3666                         break;
3667         }
3668         retval = scsi_ioctl(STp->device, cmd_in, p);
3669         if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3670                 STp->rew_at_close = 0;
3671                 STp->ready = ST_NO_TAPE;
3672         }
3673         return retval;
3674
3675  out:
3676         mutex_unlock(&STp->lock);
3677         return retval;
3678 }
3679
3680 #ifdef CONFIG_COMPAT
3681 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3682 {
3683         struct scsi_tape *STp = file->private_data;
3684         struct scsi_device *sdev = STp->device;
3685         int ret = -ENOIOCTLCMD;
3686         if (sdev->host->hostt->compat_ioctl) {
3687
3688                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3689
3690         }
3691         return ret;
3692 }
3693 #endif
3694
3695 \f
3696
3697 /* Try to allocate a new tape buffer. Calling function must not hold
3698    dev_arr_lock. */
3699 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3700 {
3701         struct st_buffer *tb;
3702
3703         tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3704         if (!tb) {
3705                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3706                 return NULL;
3707         }
3708         tb->frp_segs = 0;
3709         tb->use_sg = max_sg;
3710         tb->dma = need_dma;
3711         tb->buffer_size = 0;
3712
3713         tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3714                                      GFP_ATOMIC);
3715         if (!tb->reserved_pages) {
3716                 kfree(tb);
3717                 return NULL;
3718         }
3719
3720         return tb;
3721 }
3722
3723
3724 /* Try to allocate enough space in the tape buffer */
3725 #define ST_MAX_ORDER 6
3726
3727 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3728 {
3729         int segs, nbr, max_segs, b_size, order, got;
3730         gfp_t priority;
3731
3732         if (new_size <= STbuffer->buffer_size)
3733                 return 1;
3734
3735         if (STbuffer->buffer_size <= PAGE_SIZE)
3736                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3737
3738         max_segs = STbuffer->use_sg;
3739         nbr = max_segs - STbuffer->frp_segs;
3740         if (nbr <= 0)
3741                 return 0;
3742
3743         priority = GFP_KERNEL | __GFP_NOWARN;
3744         if (need_dma)
3745                 priority |= GFP_DMA;
3746
3747         if (STbuffer->cleared)
3748                 priority |= __GFP_ZERO;
3749
3750         if (STbuffer->frp_segs) {
3751                 order = STbuffer->reserved_page_order;
3752                 b_size = PAGE_SIZE << order;
3753         } else {
3754                 for (b_size = PAGE_SIZE, order = 0;
3755                      order < ST_MAX_ORDER &&
3756                              max_segs * (PAGE_SIZE << order) < new_size;
3757                      order++, b_size *= 2)
3758                         ;  /* empty */
3759                 STbuffer->reserved_page_order = order;
3760         }
3761         if (max_segs * (PAGE_SIZE << order) < new_size) {
3762                 if (order == ST_MAX_ORDER)
3763                         return 0;
3764                 normalize_buffer(STbuffer);
3765                 return enlarge_buffer(STbuffer, new_size, need_dma);
3766         }
3767
3768         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3769              segs < max_segs && got < new_size;) {
3770                 struct page *page;
3771
3772                 page = alloc_pages(priority, order);
3773                 if (!page) {
3774                         DEB(STbuffer->buffer_size = got);
3775                         normalize_buffer(STbuffer);
3776                         return 0;
3777                 }
3778
3779                 STbuffer->frp_segs += 1;
3780                 got += b_size;
3781                 STbuffer->buffer_size = got;
3782                 STbuffer->reserved_pages[segs] = page;
3783                 segs++;
3784         }
3785         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3786
3787         return 1;
3788 }
3789
3790
3791 /* Make sure that no data from previous user is in the internal buffer */
3792 static void clear_buffer(struct st_buffer * st_bp)
3793 {
3794         int i;
3795
3796         for (i=0; i < st_bp->frp_segs; i++)
3797                 memset(page_address(st_bp->reserved_pages[i]), 0,
3798                        PAGE_SIZE << st_bp->reserved_page_order);
3799         st_bp->cleared = 1;
3800 }
3801
3802
3803 /* Release the extra buffer */
3804 static void normalize_buffer(struct st_buffer * STbuffer)
3805 {
3806         int i, order = STbuffer->reserved_page_order;
3807
3808         for (i = 0; i < STbuffer->frp_segs; i++) {
3809                 __free_pages(STbuffer->reserved_pages[i], order);
3810                 STbuffer->buffer_size -= (PAGE_SIZE << order);
3811         }
3812         STbuffer->frp_segs = 0;
3813         STbuffer->sg_segs = 0;
3814         STbuffer->reserved_page_order = 0;
3815         STbuffer->map_data.offset = 0;
3816 }
3817
3818
3819 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3820    negative error code. */
3821 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3822 {
3823         int i, cnt, res, offset;
3824         int length = PAGE_SIZE << st_bp->reserved_page_order;
3825
3826         for (i = 0, offset = st_bp->buffer_bytes;
3827              i < st_bp->frp_segs && offset >= length; i++)
3828                 offset -= length;
3829         if (i == st_bp->frp_segs) {     /* Should never happen */
3830                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3831                 return (-EIO);
3832         }
3833         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3834                 struct page *page = st_bp->reserved_pages[i];
3835                 cnt = length - offset < do_count ? length - offset : do_count;
3836                 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3837                 if (res)
3838                         return (-EFAULT);
3839                 do_count -= cnt;
3840                 st_bp->buffer_bytes += cnt;
3841                 ubp += cnt;
3842                 offset = 0;
3843         }
3844         if (do_count) /* Should never happen */
3845                 return (-EIO);
3846
3847         return 0;
3848 }
3849
3850
3851 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3852    negative error code. */
3853 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3854 {
3855         int i, cnt, res, offset;
3856         int length = PAGE_SIZE << st_bp->reserved_page_order;
3857
3858         for (i = 0, offset = st_bp->read_pointer;
3859              i < st_bp->frp_segs && offset >= length; i++)
3860                 offset -= length;
3861         if (i == st_bp->frp_segs) {     /* Should never happen */
3862                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3863                 return (-EIO);
3864         }
3865         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3866                 struct page *page = st_bp->reserved_pages[i];
3867                 cnt = length - offset < do_count ? length - offset : do_count;
3868                 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3869                 if (res)
3870                         return (-EFAULT);
3871                 do_count -= cnt;
3872                 st_bp->buffer_bytes -= cnt;
3873                 st_bp->read_pointer += cnt;
3874                 ubp += cnt;
3875                 offset = 0;
3876         }
3877         if (do_count) /* Should never happen */
3878                 return (-EIO);
3879
3880         return 0;
3881 }
3882
3883
3884 /* Move data towards start of buffer */
3885 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3886 {
3887         int src_seg, dst_seg, src_offset = 0, dst_offset;
3888         int count, total;
3889         int length = PAGE_SIZE << st_bp->reserved_page_order;
3890
3891         if (offset == 0)
3892                 return;
3893
3894         total=st_bp->buffer_bytes - offset;
3895         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3896                 src_offset = offset;
3897                 if (src_offset < length)
3898                         break;
3899                 offset -= length;
3900         }
3901
3902         st_bp->buffer_bytes = st_bp->read_pointer = total;
3903         for (dst_seg=dst_offset=0; total > 0; ) {
3904                 struct page *dpage = st_bp->reserved_pages[dst_seg];
3905                 struct page *spage = st_bp->reserved_pages[src_seg];
3906
3907                 count = min(length - dst_offset, length - src_offset);
3908                 memmove(page_address(dpage) + dst_offset,
3909                         page_address(spage) + src_offset, count);
3910                 src_offset += count;
3911                 if (src_offset >= length) {
3912                         src_seg++;
3913                         src_offset = 0;
3914                 }
3915                 dst_offset += count;
3916                 if (dst_offset >= length) {
3917                         dst_seg++;
3918                         dst_offset = 0;
3919                 }
3920                 total -= count;
3921         }
3922 }
3923
3924 /* Validate the options from command line or module parameters */
3925 static void validate_options(void)
3926 {
3927         if (buffer_kbs > 0)
3928                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3929         if (max_sg_segs >= ST_FIRST_SG)
3930                 st_max_sg_segs = max_sg_segs;
3931 }
3932
3933 #ifndef MODULE
3934 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3935  */
3936 static int __init st_setup(char *str)
3937 {
3938         int i, len, ints[5];
3939         char *stp;
3940
3941         stp = get_options(str, ARRAY_SIZE(ints), ints);
3942
3943         if (ints[0] > 0) {
3944                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3945                         if (parms[i].val)
3946                                 *parms[i].val = ints[i + 1];
3947         } else {
3948                 while (stp != NULL) {
3949                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3950                                 len = strlen(parms[i].name);
3951                                 if (!strncmp(stp, parms[i].name, len) &&
3952                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3953                                         if (parms[i].val)
3954                                                 *parms[i].val =
3955                                                         simple_strtoul(stp + len + 1, NULL, 0);
3956                                         else
3957                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3958                                                        parms[i].name);
3959                                         break;
3960                                 }
3961                         }
3962                         if (i >= ARRAY_SIZE(parms))
3963                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3964                                         stp);
3965                         stp = strchr(stp, ',');
3966                         if (stp)
3967                                 stp++;
3968                 }
3969         }
3970
3971         validate_options();
3972
3973         return 1;
3974 }
3975
3976 __setup("st=", st_setup);
3977
3978 #endif
3979
3980 static const struct file_operations st_fops =
3981 {
3982         .owner =        THIS_MODULE,
3983         .read =         st_read,
3984         .write =        st_write,
3985         .unlocked_ioctl = st_ioctl,
3986 #ifdef CONFIG_COMPAT
3987         .compat_ioctl = st_compat_ioctl,
3988 #endif
3989         .open =         st_open,
3990         .flush =        st_flush,
3991         .release =      st_release,
3992         .llseek =       noop_llseek,
3993 };
3994
3995 static int st_probe(struct device *dev)
3996 {
3997         struct scsi_device *SDp = to_scsi_device(dev);
3998         struct gendisk *disk = NULL;
3999         struct cdev *cdev = NULL;
4000         struct scsi_tape *tpnt = NULL;
4001         struct st_modedef *STm;
4002         struct st_partstat *STps;
4003         struct st_buffer *buffer;
4004         int i, j, mode, dev_num, error;
4005         char *stp;
4006
4007         if (SDp->type != TYPE_TAPE)
4008                 return -ENODEV;
4009         if ((stp = st_incompatible(SDp))) {
4010                 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4011                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4012                 return -ENODEV;
4013         }
4014
4015         i = queue_max_segments(SDp->request_queue);
4016         if (st_max_sg_segs < i)
4017                 i = st_max_sg_segs;
4018         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4019         if (buffer == NULL) {
4020                 printk(KERN_ERR
4021                        "st: Can't allocate new tape buffer. Device not attached.\n");
4022                 goto out;
4023         }
4024
4025         disk = alloc_disk(1);
4026         if (!disk) {
4027                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4028                 goto out_buffer_free;
4029         }
4030
4031         write_lock(&st_dev_arr_lock);
4032         if (st_nr_dev >= st_dev_max) {
4033                 struct scsi_tape **tmp_da;
4034                 int tmp_dev_max;
4035
4036                 tmp_dev_max = max(st_nr_dev * 2, 8);
4037                 if (tmp_dev_max > ST_MAX_TAPES)
4038                         tmp_dev_max = ST_MAX_TAPES;
4039                 if (tmp_dev_max <= st_nr_dev) {
4040                         write_unlock(&st_dev_arr_lock);
4041                         printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4042                                ST_MAX_TAPES);
4043                         goto out_put_disk;
4044                 }
4045
4046                 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4047                 if (tmp_da == NULL) {
4048                         write_unlock(&st_dev_arr_lock);
4049                         printk(KERN_ERR "st: Can't extend device array.\n");
4050                         goto out_put_disk;
4051                 }
4052
4053                 if (scsi_tapes != NULL) {
4054                         memcpy(tmp_da, scsi_tapes,
4055                                st_dev_max * sizeof(struct scsi_tape *));
4056                         kfree(scsi_tapes);
4057                 }
4058                 scsi_tapes = tmp_da;
4059
4060                 st_dev_max = tmp_dev_max;
4061         }
4062
4063         for (i = 0; i < st_dev_max; i++)
4064                 if (scsi_tapes[i] == NULL)
4065                         break;
4066         if (i >= st_dev_max)
4067                 panic("scsi_devices corrupt (st)");
4068
4069         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4070         if (tpnt == NULL) {
4071                 write_unlock(&st_dev_arr_lock);
4072                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4073                 goto out_put_disk;
4074         }
4075         kref_init(&tpnt->kref);
4076         tpnt->disk = disk;
4077         sprintf(disk->disk_name, "st%d", i);
4078         disk->private_data = &tpnt->driver;
4079         disk->queue = SDp->request_queue;
4080         tpnt->driver = &st_template;
4081         scsi_tapes[i] = tpnt;
4082         dev_num = i;
4083
4084         tpnt->device = SDp;
4085         if (SDp->scsi_level <= 2)
4086                 tpnt->tape_type = MT_ISSCSI1;
4087         else
4088                 tpnt->tape_type = MT_ISSCSI2;
4089
4090         tpnt->buffer = buffer;
4091         tpnt->buffer->last_SRpnt = NULL;
4092
4093         tpnt->inited = 0;
4094         tpnt->dirty = 0;
4095         tpnt->in_use = 0;
4096         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4097         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4098         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4099         tpnt->density = 0;
4100         tpnt->do_auto_lock = ST_AUTO_LOCK;
4101         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4102         tpnt->can_partitions = 0;
4103         tpnt->two_fm = ST_TWO_FM;
4104         tpnt->fast_mteom = ST_FAST_MTEOM;
4105         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4106         tpnt->sili = ST_SILI;
4107         tpnt->immediate = ST_NOWAIT;
4108         tpnt->immediate_filemark = 0;
4109         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
4110         tpnt->partition = 0;
4111         tpnt->new_partition = 0;
4112         tpnt->nbr_partitions = 0;
4113         blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4114         tpnt->long_timeout = ST_LONG_TIMEOUT;
4115         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4116
4117         for (i = 0; i < ST_NBR_MODES; i++) {
4118                 STm = &(tpnt->modes[i]);
4119                 STm->defined = 0;
4120                 STm->sysv = ST_SYSV;
4121                 STm->defaults_for_writes = 0;
4122                 STm->do_async_writes = ST_ASYNC_WRITES;
4123                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4124                 STm->do_read_ahead = ST_READ_AHEAD;
4125                 STm->default_compression = ST_DONT_TOUCH;
4126                 STm->default_blksize = (-1);    /* No forced size */
4127                 STm->default_density = (-1);    /* No forced density */
4128         }
4129
4130         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4131                 STps = &(tpnt->ps[i]);
4132                 STps->rw = ST_IDLE;
4133                 STps->eof = ST_NOEOF;
4134                 STps->at_sm = 0;
4135                 STps->last_block_valid = 0;
4136                 STps->drv_block = (-1);
4137                 STps->drv_file = (-1);
4138         }
4139
4140         tpnt->current_mode = 0;
4141         tpnt->modes[0].defined = 1;
4142
4143         tpnt->density_changed = tpnt->compression_changed =
4144             tpnt->blksize_changed = 0;
4145         mutex_init(&tpnt->lock);
4146
4147         st_nr_dev++;
4148         write_unlock(&st_dev_arr_lock);
4149
4150         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4151                 STm = &(tpnt->modes[mode]);
4152                 for (j=0; j < 2; j++) {
4153                         cdev = cdev_alloc();
4154                         if (!cdev) {
4155                                 printk(KERN_ERR
4156                                        "st%d: out of memory. Device not attached.\n",
4157                                        dev_num);
4158                                 goto out_free_tape;
4159                         }
4160                         cdev->owner = THIS_MODULE;
4161                         cdev->ops = &st_fops;
4162
4163                         error = cdev_add(cdev,
4164                                          MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4165                                          1);
4166                         if (error) {
4167                                 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4168                                        dev_num, j ? "non" : "auto", mode);
4169                                 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4170                                 goto out_free_tape;
4171                         }
4172                         STm->cdevs[j] = cdev;
4173
4174                 }
4175                 error = do_create_class_files(tpnt, dev_num, mode);
4176                 if (error)
4177                         goto out_free_tape;
4178         }
4179         scsi_autopm_put_device(SDp);
4180
4181         sdev_printk(KERN_NOTICE, SDp,
4182                     "Attached scsi tape %s\n", tape_name(tpnt));
4183         sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4184                     tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4185                     queue_dma_alignment(SDp->request_queue) + 1);
4186
4187         return 0;
4188
4189 out_free_tape:
4190         for (mode=0; mode < ST_NBR_MODES; mode++) {
4191                 STm = &(tpnt->modes[mode]);
4192                 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4193                                   "tape");
4194                 for (j=0; j < 2; j++) {
4195                         if (STm->cdevs[j]) {
4196                                 if (cdev == STm->cdevs[j])
4197                                         cdev = NULL;
4198                                         device_destroy(st_sysfs_class,
4199                                                        MKDEV(SCSI_TAPE_MAJOR,
4200                                                              TAPE_MINOR(i, mode, j)));
4201                                 cdev_del(STm->cdevs[j]);
4202                         }
4203                 }
4204         }
4205         if (cdev)
4206                 cdev_del(cdev);
4207         write_lock(&st_dev_arr_lock);
4208         scsi_tapes[dev_num] = NULL;
4209         st_nr_dev--;
4210         write_unlock(&st_dev_arr_lock);
4211 out_put_disk:
4212         put_disk(disk);
4213         kfree(tpnt);
4214 out_buffer_free:
4215         kfree(buffer);
4216 out:
4217         return -ENODEV;
4218 };
4219
4220
4221 static int st_remove(struct device *dev)
4222 {
4223         struct scsi_device *SDp = to_scsi_device(dev);
4224         struct scsi_tape *tpnt;
4225         int i, j, mode;
4226
4227         scsi_autopm_get_device(SDp);
4228         write_lock(&st_dev_arr_lock);
4229         for (i = 0; i < st_dev_max; i++) {
4230                 tpnt = scsi_tapes[i];
4231                 if (tpnt != NULL && tpnt->device == SDp) {
4232                         scsi_tapes[i] = NULL;
4233                         st_nr_dev--;
4234                         write_unlock(&st_dev_arr_lock);
4235                         sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4236                                           "tape");
4237                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4238                                 for (j=0; j < 2; j++) {
4239                                         device_destroy(st_sysfs_class,
4240                                                        MKDEV(SCSI_TAPE_MAJOR,
4241                                                              TAPE_MINOR(i, mode, j)));
4242                                         cdev_del(tpnt->modes[mode].cdevs[j]);
4243                                         tpnt->modes[mode].cdevs[j] = NULL;
4244                                 }
4245                         }
4246
4247                         mutex_lock(&st_ref_mutex);
4248                         kref_put(&tpnt->kref, scsi_tape_release);
4249                         mutex_unlock(&st_ref_mutex);
4250                         return 0;
4251                 }
4252         }
4253
4254         write_unlock(&st_dev_arr_lock);
4255         return 0;
4256 }
4257
4258 /**
4259  *      scsi_tape_release - Called to free the Scsi_Tape structure
4260  *      @kref: pointer to embedded kref
4261  *
4262  *      st_ref_mutex must be held entering this routine.  Because it is
4263  *      called on last put, you should always use the scsi_tape_get()
4264  *      scsi_tape_put() helpers which manipulate the semaphore directly
4265  *      and never do a direct kref_put().
4266  **/
4267 static void scsi_tape_release(struct kref *kref)
4268 {
4269         struct scsi_tape *tpnt = to_scsi_tape(kref);
4270         struct gendisk *disk = tpnt->disk;
4271
4272         tpnt->device = NULL;
4273
4274         if (tpnt->buffer) {
4275                 normalize_buffer(tpnt->buffer);
4276                 kfree(tpnt->buffer->reserved_pages);
4277                 kfree(tpnt->buffer);
4278         }
4279
4280         disk->private_data = NULL;
4281         put_disk(disk);
4282         kfree(tpnt);
4283         return;
4284 }
4285
4286 static int __init init_st(void)
4287 {
4288         int err;
4289
4290         validate_options();
4291
4292         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4293                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4294
4295         st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4296         if (IS_ERR(st_sysfs_class)) {
4297                 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4298                 return PTR_ERR(st_sysfs_class);
4299         }
4300
4301         err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4302                                      ST_MAX_TAPE_ENTRIES, "st");
4303         if (err) {
4304                 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4305                        SCSI_TAPE_MAJOR);
4306                 goto err_class;
4307         }
4308
4309         err = scsi_register_driver(&st_template.gendrv);
4310         if (err)
4311                 goto err_chrdev;
4312
4313         err = do_create_sysfs_files();
4314         if (err)
4315                 goto err_scsidrv;
4316
4317         return 0;
4318
4319 err_scsidrv:
4320         scsi_unregister_driver(&st_template.gendrv);
4321 err_chrdev:
4322         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4323                                  ST_MAX_TAPE_ENTRIES);
4324 err_class:
4325         class_destroy(st_sysfs_class);
4326         return err;
4327 }
4328
4329 static void __exit exit_st(void)
4330 {
4331         do_remove_sysfs_files();
4332         scsi_unregister_driver(&st_template.gendrv);
4333         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4334                                  ST_MAX_TAPE_ENTRIES);
4335         class_destroy(st_sysfs_class);
4336         kfree(scsi_tapes);
4337         printk(KERN_INFO "st: Unloaded.\n");
4338 }
4339
4340 module_init(init_st);
4341 module_exit(exit_st);
4342
4343
4344 /* The sysfs driver interface. Read-only at the moment */
4345 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4346 {
4347         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4348 }
4349 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4350
4351 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4352 {
4353         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4354 }
4355 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4356
4357 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4358 {
4359         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4360 }
4361 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4362
4363 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4364 {
4365         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4366 }
4367 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4368
4369 static int do_create_sysfs_files(void)
4370 {
4371         struct device_driver *sysfs = &st_template.gendrv;
4372         int err;
4373
4374         err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4375         if (err)
4376                 return err;
4377         err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4378         if (err)
4379                 goto err_try_direct_io;
4380         err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4381         if (err)
4382                 goto err_attr_fixed_buf;
4383         err = driver_create_file(sysfs, &driver_attr_version);
4384         if (err)
4385                 goto err_attr_max_sg;
4386
4387         return 0;
4388
4389 err_attr_max_sg:
4390         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4391 err_attr_fixed_buf:
4392         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4393 err_try_direct_io:
4394         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4395         return err;
4396 }
4397
4398 static void do_remove_sysfs_files(void)
4399 {
4400         struct device_driver *sysfs = &st_template.gendrv;
4401
4402         driver_remove_file(sysfs, &driver_attr_version);
4403         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4404         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4405         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4406 }
4407
4408
4409 /* The sysfs simple class interface */
4410 static ssize_t
4411 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4412 {
4413         struct st_modedef *STm = dev_get_drvdata(dev);
4414         ssize_t l = 0;
4415
4416         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4417         return l;
4418 }
4419
4420 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4421
4422 static ssize_t
4423 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4424 {
4425         struct st_modedef *STm = dev_get_drvdata(dev);
4426         ssize_t l = 0;
4427
4428         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4429         return l;
4430 }
4431
4432 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4433
4434 static ssize_t
4435 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4436 {
4437         struct st_modedef *STm = dev_get_drvdata(dev);
4438         ssize_t l = 0;
4439         char *fmt;
4440
4441         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4442         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4443         return l;
4444 }
4445
4446 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4447
4448 static ssize_t
4449 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4450                        char *buf)
4451 {
4452         struct st_modedef *STm = dev_get_drvdata(dev);
4453         ssize_t l = 0;
4454
4455         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4456         return l;
4457 }
4458
4459 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4460
4461 static ssize_t
4462 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4463 {
4464         struct st_modedef *STm = dev_get_drvdata(dev);
4465         struct scsi_tape *STp;
4466         int i, j, options;
4467         ssize_t l = 0;
4468
4469         for (i=0; i < st_dev_max; i++) {
4470                 for (j=0; j < ST_NBR_MODES; j++)
4471                         if (&scsi_tapes[i]->modes[j] == STm)
4472                                 break;
4473                 if (j < ST_NBR_MODES)
4474                         break;
4475         }
4476         if (i == st_dev_max)
4477                 return 0;  /* should never happen */
4478
4479         STp = scsi_tapes[i];
4480
4481         options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4482         options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4483         options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4484         DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4485         options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4486         options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4487         options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4488         options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4489         options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4490         options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4491         options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4492         options |= STm->sysv ? MT_ST_SYSV : 0;
4493         options |= STp->immediate ? MT_ST_NOWAIT : 0;
4494         options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4495         options |= STp->sili ? MT_ST_SILI : 0;
4496
4497         l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4498         return l;
4499 }
4500
4501 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4502
4503 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4504 {
4505         int i, rew, error;
4506         char name[10];
4507         struct device *st_class_member;
4508
4509         for (rew=0; rew < 2; rew++) {
4510                 /* Make sure that the minor numbers corresponding to the four
4511                    first modes always get the same names */
4512                 i = mode << (4 - ST_NBR_MODE_BITS);
4513                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4514                          STp->disk->disk_name, st_formats[i]);
4515                 st_class_member =
4516                         device_create(st_sysfs_class, &STp->device->sdev_gendev,
4517                                       MKDEV(SCSI_TAPE_MAJOR,
4518                                             TAPE_MINOR(dev_num, mode, rew)),
4519                                       &STp->modes[mode], "%s", name);
4520                 if (IS_ERR(st_class_member)) {
4521                         printk(KERN_WARNING "st%d: device_create failed\n",
4522                                dev_num);
4523                         error = PTR_ERR(st_class_member);
4524                         goto out;
4525                 }
4526
4527                 error = device_create_file(st_class_member,
4528                                            &dev_attr_defined);
4529                 if (error) goto out;
4530                 error = device_create_file(st_class_member,
4531                                            &dev_attr_default_blksize);
4532                 if (error) goto out;
4533                 error = device_create_file(st_class_member,
4534                                            &dev_attr_default_density);
4535                 if (error) goto out;
4536                 error = device_create_file(st_class_member,
4537                                            &dev_attr_default_compression);
4538                 if (error) goto out;
4539                 error = device_create_file(st_class_member,
4540                                            &dev_attr_options);
4541                 if (error) goto out;
4542
4543                 if (mode == 0 && rew == 0) {
4544                         error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4545                                                   &st_class_member->kobj,
4546                                                   "tape");
4547                         if (error) {
4548                                 printk(KERN_ERR
4549                                        "st%d: Can't create sysfs link from SCSI device.\n",
4550                                        dev_num);
4551                                 goto out;
4552                         }
4553                 }
4554         }
4555
4556         return 0;
4557
4558 out:
4559         return error;
4560 }
4561
4562 /* The following functions may be useful for a larger audience. */
4563 static int sgl_map_user_pages(struct st_buffer *STbp,
4564                               const unsigned int max_pages, unsigned long uaddr,
4565                               size_t count, int rw)
4566 {
4567         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4568         unsigned long start = uaddr >> PAGE_SHIFT;
4569         const int nr_pages = end - start;
4570         int res, i, j;
4571         struct page **pages;
4572         struct rq_map_data *mdata = &STbp->map_data;
4573
4574         /* User attempted Overflow! */
4575         if ((uaddr + count) < uaddr)
4576                 return -EINVAL;
4577
4578         /* Too big */
4579         if (nr_pages > max_pages)
4580                 return -ENOMEM;
4581
4582         /* Hmm? */
4583         if (count == 0)
4584                 return 0;
4585
4586         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4587                 return -ENOMEM;
4588
4589         /* Try to fault in all of the necessary pages */
4590         down_read(&current->mm->mmap_sem);
4591         /* rw==READ means read from drive, write into memory area */
4592         res = get_user_pages(
4593                 current,
4594                 current->mm,
4595                 uaddr,
4596                 nr_pages,
4597                 rw == READ,
4598                 0, /* don't force */
4599                 pages,
4600                 NULL);
4601         up_read(&current->mm->mmap_sem);
4602
4603         /* Errors and no page mapped should return here */
4604         if (res < nr_pages)
4605                 goto out_unmap;
4606
4607         for (i=0; i < nr_pages; i++) {
4608                 /* FIXME: flush superflous for rw==READ,
4609                  * probably wrong function for rw==WRITE
4610                  */
4611                 flush_dcache_page(pages[i]);
4612         }
4613
4614         mdata->offset = uaddr & ~PAGE_MASK;
4615         STbp->mapped_pages = pages;
4616
4617         return nr_pages;
4618  out_unmap:
4619         if (res > 0) {
4620                 for (j=0; j < res; j++)
4621                         page_cache_release(pages[j]);
4622                 res = 0;
4623         }
4624         kfree(pages);
4625         return res;
4626 }
4627
4628
4629 /* And unmap them... */
4630 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4631                                 const unsigned int nr_pages, int dirtied)
4632 {
4633         int i;
4634
4635         for (i=0; i < nr_pages; i++) {
4636                 struct page *page = STbp->mapped_pages[i];
4637
4638                 if (dirtied)
4639                         SetPageDirty(page);
4640                 /* FIXME: cache flush missing for rw==READ
4641                  * FIXME: call the correct reference counting function
4642                  */
4643                 page_cache_release(page);
4644         }
4645         kfree(STbp->mapped_pages);
4646         STbp->mapped_pages = NULL;
4647
4648         return 0;
4649 }