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/idr.h>
  41 #include <linux/delay.h>
  42 #include <linux/mutex.h>
  43
  44 #include <asm/uaccess.h>
  45 #include <asm/dma.h>
  46
  47 #include <scsi/scsi.h>
  48 #include <scsi/scsi_dbg.h>
  49 #include <scsi/scsi_device.h>
  50 #include <scsi/scsi_driver.h>
  51 #include <scsi/scsi_eh.h>
  52 #include <scsi/scsi_host.h>
  53 #include <scsi/scsi_ioctl.h>
  54 #include <scsi/sg.h>
  55
  56
  57 /* The driver prints some debugging information on the console if DEBUG
  58    is defined and non-zero. */
  59 #define DEBUG 0
  60
  61 #if DEBUG
  62 /* The message level for the debug messages is currently set to KERN_NOTICE
  63    so that people can easily see the messages. Later when the debugging messages
  64    in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
  65 #define ST_DEB_MSG  KERN_NOTICE
  66 #define DEB(a) a
  67 #define DEBC(a) if (debugging) { a ; }
  68 #else
  69 #define DEB(a)
  70 #define DEBC(a)
  71 #endif
  72
  73 #define ST_KILOBYTE 1024
  74
  75 #include "st_options.h"
  76 #include "st.h"
  77
  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 struct class st_sysfs_class;
  85 static const struct attribute_group *st_dev_groups[];
  86
  87 MODULE_AUTHOR("Kai Makisara");
  88 MODULE_DESCRIPTION("SCSI tape (st) driver");
  89 MODULE_LICENSE("GPL");
  90 MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
  91 MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
  92
  93 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
  94  * of sysfs parameters (which module_param doesn't yet support).
  95  * Sysfs parameters defined explicitly later.
  96  */
  97 module_param_named(buffer_kbs, buffer_kbs, int, 0);
  98 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
  99 module_param_named(max_sg_segs, max_sg_segs, int, 0);
 100 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 101 module_param_named(try_direct_io, try_direct_io, int, 0);
 102 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
 103
 104 /* Extra parameters for testing */
 105 module_param_named(try_rdio, try_rdio, int, 0);
 106 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
 107 module_param_named(try_wdio, try_wdio, int, 0);
 108 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
 109
 110 #ifndef MODULE
 111 static int write_threshold_kbs;  /* retained for compatibility */
 112 static struct st_dev_parm {
 113         char *name;
 114         int *val;
 115 } parms[] __initdata = {
 116         {
 117                 "buffer_kbs", &buffer_kbs
 118         },
 119         {       /* Retained for compatibility with 2.4 */
 120                 "write_threshold_kbs", &write_threshold_kbs
 121         },
 122         {
 123                 "max_sg_segs", NULL
 124         },
 125         {
 126                 "try_direct_io", &try_direct_io
 127         }
 128 };
 129 #endif
 130
 131 /* Restrict the number of modes so that names for all are assigned */
 132 #if ST_NBR_MODES > 16
 133 #error "Maximum number of modes is 16"
 134 #endif
 135 /* Bit reversed order to get same names for same minors with all
 136    mode counts */
 137 static const char *st_formats[] = {
 138         "",  "r", "k", "s", "l", "t", "o", "u",
 139         "m", "v", "p", "x", "a", "y", "q", "z"};
 140
 141 /* The default definitions have been moved to st_options.h */
 142
 143 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
 144
 145 /* The buffer size should fit into the 24 bits for length in the
 146    6-byte SCSI read and write commands. */
 147 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
 148 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 149 #endif
 150
 151 static int debugging = DEBUG;
 152
 153 #define MAX_RETRIES 0
 154 #define MAX_WRITE_RETRIES 0
 155 #define MAX_READY_RETRIES 0
 156 #define NO_TAPE  NOT_READY
 157
 158 #define ST_TIMEOUT (900 * HZ)
 159 #define ST_LONG_TIMEOUT (14000 * HZ)
 160
 161 /* Remove mode bits and auto-rewind bit (7) */
 162 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
 163     (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
 164 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 165
 166 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
 167 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
 168   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
 169
 170 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 171    24 bits) */
 172 #define SET_DENS_AND_BLK 0x10001
 173
 174 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
 175 static int st_max_sg_segs = ST_MAX_SG;
 176
 177 static int modes_defined;
 178
 179 static int enlarge_buffer(struct st_buffer *, int, int);
 180 static void clear_buffer(struct st_buffer *);
 181 static void normalize_buffer(struct st_buffer *);
 182 static int append_to_buffer(const char __user *, struct st_buffer *, int);
 183 static int from_buffer(struct st_buffer *, char __user *, int);
 184 static void move_buffer_data(struct st_buffer *, int);
 185
 186 static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
 187                               unsigned long, size_t, int);
 188 static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
 189
 190 static int st_probe(struct device *);
 191 static int st_remove(struct device *);
 192
 193 static int do_create_sysfs_files(void);
 194 static void do_remove_sysfs_files(void);
 195
 196 static struct scsi_driver st_template = {
 197         .owner                  = THIS_MODULE,
 198         .gendrv = {
 199                 .name           = "st",
 200                 .probe          = st_probe,
 201                 .remove         = st_remove,
 202         },
 203 };
 204
 205 static int st_compression(struct scsi_tape *, int);
 206
 207 static int find_partition(struct scsi_tape *);
 208 static int switch_partition(struct scsi_tape *);
 209
 210 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
 211
 212 static void scsi_tape_release(struct kref *);
 213
 214 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 215
 216 static DEFINE_MUTEX(st_ref_mutex);
 217 static DEFINE_SPINLOCK(st_index_lock);
 218 static DEFINE_SPINLOCK(st_use_lock);
 219 static DEFINE_IDR(st_index_idr);
 220
 221
 222 \f
 223 #include "osst_detect.h"
 224 #ifndef SIGS_FROM_OSST
 225 #define SIGS_FROM_OSST \
 226         {"OnStream", "SC-", "", "osst"}, \
 227         {"OnStream", "DI-", "", "osst"}, \
 228         {"OnStream", "DP-", "", "osst"}, \
 229         {"OnStream", "USB", "", "osst"}, \
 230         {"OnStream", "FW-", "", "osst"}
 231 #endif
 232
 233 static struct scsi_tape *scsi_tape_get(int dev)
 234 {
 235         struct scsi_tape *STp = NULL;
 236
 237         mutex_lock(&st_ref_mutex);
 238         spin_lock(&st_index_lock);
 239
 240         STp = idr_find(&st_index_idr, dev);
 241         if (!STp) goto out;
 242
 243         kref_get(&STp->kref);
 244
 245         if (!STp->device)
 246                 goto out_put;
 247
 248         if (scsi_device_get(STp->device))
 249                 goto out_put;
 250
 251         goto out;
 252
 253 out_put:
 254         kref_put(&STp->kref, scsi_tape_release);
 255         STp = NULL;
 256 out:
 257         spin_unlock(&st_index_lock);
 258         mutex_unlock(&st_ref_mutex);
 259         return STp;
 260 }
 261
 262 static void scsi_tape_put(struct scsi_tape *STp)
 263 {
 264         struct scsi_device *sdev = STp->device;
 265
 266         mutex_lock(&st_ref_mutex);
 267         kref_put(&STp->kref, scsi_tape_release);
 268         scsi_device_put(sdev);
 269         mutex_unlock(&st_ref_mutex);
 270 }
 271
 272 struct st_reject_data {
 273         char *vendor;
 274         char *model;
 275         char *rev;
 276         char *driver_hint; /* Name of the correct driver, NULL if unknown */
 277 };
 278
 279 static struct st_reject_data reject_list[] = {
 280         /* {"XXX", "Yy-", "", NULL},  example */
 281         SIGS_FROM_OSST,
 282         {NULL, }};
 283
 284 /* If the device signature is on the list of incompatible drives, the
 285    function returns a pointer to the name of the correct driver (if known) */
 286 static char * st_incompatible(struct scsi_device* SDp)
 287 {
 288         struct st_reject_data *rp;
 289
 290         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
 291                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
 292                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
 293                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
 294                         if (rp->driver_hint)
 295                                 return rp->driver_hint;
 296                         else
 297                                 return "unknown";
 298                 }
 299         return NULL;
 300 }
 301 \f
 302
 303 static inline char *tape_name(struct scsi_tape *tape)
 304 {
 305         return tape->disk->disk_name;
 306 }
 307
 308
 309 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
 310 {
 311         const u8 *ucp;
 312         const u8 *sense = SRpnt->sense;
 313
 314         s->have_sense = scsi_normalize_sense(SRpnt->sense,
 315                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
 316         s->flags = 0;
 317
 318         if (s->have_sense) {
 319                 s->deferred = 0;
 320                 s->remainder_valid =
 321                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
 322                 switch (sense[0] & 0x7f) {
 323                 case 0x71:
 324                         s->deferred = 1;
 325                 case 0x70:
 326                         s->fixed_format = 1;
 327                         s->flags = sense[2] & 0xe0;
 328                         break;
 329                 case 0x73:
 330                         s->deferred = 1;
 331                 case 0x72:
 332                         s->fixed_format = 0;
 333                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
 334                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
 335                         break;
 336                 }
 337         }
 338 }
 339
 340
 341 /* Convert the result to success code */
 342 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
 343 {
 344         int result = SRpnt->result;
 345         u8 scode;
 346         DEB(const char *stp;)
 347         char *name = tape_name(STp);
 348         struct st_cmdstatus *cmdstatp;
 349
 350         if (!result)
 351                 return 0;
 352
 353         cmdstatp = &STp->buffer->cmdstat;
 354         st_analyze_sense(SRpnt, cmdstatp);
 355
 356         if (cmdstatp->have_sense)
 357                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
 358         else
 359                 scode = 0;
 360
 361         DEB(
 362         if (debugging) {
 363                 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
 364                        name, result,
 365                        SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
 366                        SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
 367                 if (cmdstatp->have_sense)
 368                          __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 369         } ) /* end DEB */
 370         if (!debugging) { /* Abnormal conditions for tape */
 371                 if (!cmdstatp->have_sense)
 372                         printk(KERN_WARNING
 373                                "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
 374                                name, result, driver_byte(result),
 375                                host_byte(result));
 376                 else if (cmdstatp->have_sense &&
 377                          scode != NO_SENSE &&
 378                          scode != RECOVERED_ERROR &&
 379                          /* scode != UNIT_ATTENTION && */
 380                          scode != BLANK_CHECK &&
 381                          scode != VOLUME_OVERFLOW &&
 382                          SRpnt->cmd[0] != MODE_SENSE &&
 383                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 384
 385                         __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 386                 }
 387         }
 388
 389         if (cmdstatp->fixed_format &&
 390             STp->cln_mode >= EXTENDED_SENSE_START) {  /* Only fixed format sense */
 391                 if (STp->cln_sense_value)
 392                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 393                                                STp->cln_sense_mask) == STp->cln_sense_value);
 394                 else
 395                         STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
 396                                                STp->cln_sense_mask) != 0);
 397         }
 398         if (cmdstatp->have_sense &&
 399             cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
 400                 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
 401
 402         STp->pos_unknown |= STp->device->was_reset;
 403
 404         if (cmdstatp->have_sense &&
 405             scode == RECOVERED_ERROR
 406 #if ST_RECOVERED_WRITE_FATAL
 407             && SRpnt->cmd[0] != WRITE_6
 408             && SRpnt->cmd[0] != WRITE_FILEMARKS
 409 #endif
 410             ) {
 411                 STp->recover_count++;
 412                 STp->recover_reg++;
 413
 414                 DEB(
 415                 if (debugging) {
 416                         if (SRpnt->cmd[0] == READ_6)
 417                                 stp = "read";
 418                         else if (SRpnt->cmd[0] == WRITE_6)
 419                                 stp = "write";
 420                         else
 421                                 stp = "ioctl";
 422                         printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
 423                                STp->recover_count);
 424                 } ) /* end DEB */
 425
 426                 if (cmdstatp->flags == 0)
 427                         return 0;
 428         }
 429         return (-EIO);
 430 }
 431
 432 static struct st_request *st_allocate_request(struct scsi_tape *stp)
 433 {
 434         struct st_request *streq;
 435
 436         streq = kzalloc(sizeof(*streq), GFP_KERNEL);
 437         if (streq)
 438                 streq->stp = stp;
 439         else {
 440                 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
 441                             tape_name(stp)););
 442                 if (signal_pending(current))
 443                         stp->buffer->syscall_result = -EINTR;
 444                 else
 445                         stp->buffer->syscall_result = -EBUSY;
 446         }
 447
 448         return streq;
 449 }
 450
 451 static void st_release_request(struct st_request *streq)
 452 {
 453         kfree(streq);
 454 }
 455
 456 static void st_scsi_execute_end(struct request *req, int uptodate)
 457 {
 458         struct st_request *SRpnt = req->end_io_data;
 459         struct scsi_tape *STp = SRpnt->stp;
 460         struct bio *tmp;
 461
 462         STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
 463         STp->buffer->cmdstat.residual = req->resid_len;
 464
 465         tmp = SRpnt->bio;
 466         if (SRpnt->waiting)
 467                 complete(SRpnt->waiting);
 468
 469         blk_rq_unmap_user(tmp);
 470         __blk_put_request(req->q, req);
 471 }
 472
 473 static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 474                            int data_direction, void *buffer, unsigned bufflen,
 475                            int timeout, int retries)
 476 {
 477         struct request *req;
 478         struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
 479         int err = 0;
 480         int write = (data_direction == DMA_TO_DEVICE);
 481
 482         req = blk_get_request(SRpnt->stp->device->request_queue, write,
 483                               GFP_KERNEL);
 484         if (!req)
 485                 return DRIVER_ERROR << 24;
 486
 487         req->cmd_type = REQ_TYPE_BLOCK_PC;
 488         req->cmd_flags |= REQ_QUIET;
 489
 490         mdata->null_mapped = 1;
 491
 492         if (bufflen) {
 493                 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
 494                                       GFP_KERNEL);
 495                 if (err) {
 496                         blk_put_request(req);
 497                         return DRIVER_ERROR << 24;
 498                 }
 499         }
 500
 501         SRpnt->bio = req->bio;
 502         req->cmd_len = COMMAND_SIZE(cmd[0]);
 503         memset(req->cmd, 0, BLK_MAX_CDB);
 504         memcpy(req->cmd, cmd, req->cmd_len);
 505         req->sense = SRpnt->sense;
 506         req->sense_len = 0;
 507         req->timeout = timeout;
 508         req->retries = retries;
 509         req->end_io_data = SRpnt;
 510
 511         blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
 512         return 0;
 513 }
 514
 515 /* Do the scsi command. Waits until command performed if do_wait is true.
 516    Otherwise write_behind_check() is used to check that the command
 517    has finished. */
 518 static struct st_request *
 519 st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
 520            int bytes, int direction, int timeout, int retries, int do_wait)
 521 {
 522         struct completion *waiting;
 523         struct rq_map_data *mdata = &STp->buffer->map_data;
 524         int ret;
 525
 526         /* if async, make sure there's no command outstanding */
 527         if (!do_wait && ((STp->buffer)->last_SRpnt)) {
 528                 printk(KERN_ERR "%s: Async command already active.\n",
 529                        tape_name(STp));
 530                 if (signal_pending(current))
 531                         (STp->buffer)->syscall_result = (-EINTR);
 532                 else
 533                         (STp->buffer)->syscall_result = (-EBUSY);
 534                 return NULL;
 535         }
 536
 537         if (!SRpnt) {
 538                 SRpnt = st_allocate_request(STp);
 539                 if (!SRpnt)
 540                         return NULL;
 541         }
 542
 543         /* If async IO, set last_SRpnt. This ptr tells write_behind_check
 544            which IO is outstanding. It's nulled out when the IO completes. */
 545         if (!do_wait)
 546                 (STp->buffer)->last_SRpnt = SRpnt;
 547
 548         waiting = &STp->wait;
 549         init_completion(waiting);
 550         SRpnt->waiting = waiting;
 551
 552         if (STp->buffer->do_dio) {
 553                 mdata->page_order = 0;
 554                 mdata->nr_entries = STp->buffer->sg_segs;
 555                 mdata->pages = STp->buffer->mapped_pages;
 556         } else {
 557                 mdata->page_order = STp->buffer->reserved_page_order;
 558                 mdata->nr_entries =
 559                         DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
 560                 mdata->pages = STp->buffer->reserved_pages;
 561                 mdata->offset = 0;
 562         }
 563
 564         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
 565         STp->buffer->cmdstat.have_sense = 0;
 566         STp->buffer->syscall_result = 0;
 567
 568         ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
 569                               retries);
 570         if (ret) {
 571                 /* could not allocate the buffer or request was too large */
 572                 (STp->buffer)->syscall_result = (-EBUSY);
 573                 (STp->buffer)->last_SRpnt = NULL;
 574         } else if (do_wait) {
 575                 wait_for_completion(waiting);
 576                 SRpnt->waiting = NULL;
 577                 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 578         }
 579
 580         return SRpnt;
 581 }
 582
 583
 584 /* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
 585    write has been correct but EOM early warning reached, -EIO if write ended in
 586    error or zero if write successful. Asynchronous writes are used only in
 587    variable block mode. */
 588 static int write_behind_check(struct scsi_tape * STp)
 589 {
 590         int retval = 0;
 591         struct st_buffer *STbuffer;
 592         struct st_partstat *STps;
 593         struct st_cmdstatus *cmdstatp;
 594         struct st_request *SRpnt;
 595
 596         STbuffer = STp->buffer;
 597         if (!STbuffer->writing)
 598                 return 0;
 599
 600         DEB(
 601         if (STp->write_pending)
 602                 STp->nbr_waits++;
 603         else
 604                 STp->nbr_finished++;
 605         ) /* end DEB */
 606
 607         wait_for_completion(&(STp->wait));
 608         SRpnt = STbuffer->last_SRpnt;
 609         STbuffer->last_SRpnt = NULL;
 610         SRpnt->waiting = NULL;
 611
 612         (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
 613         st_release_request(SRpnt);
 614
 615         STbuffer->buffer_bytes -= STbuffer->writing;
 616         STps = &(STp->ps[STp->partition]);
 617         if (STps->drv_block >= 0) {
 618                 if (STp->block_size == 0)
 619                         STps->drv_block++;
 620                 else
 621                         STps->drv_block += STbuffer->writing / STp->block_size;
 622         }
 623
 624         cmdstatp = &STbuffer->cmdstat;
 625         if (STbuffer->syscall_result) {
 626                 retval = -EIO;
 627                 if (cmdstatp->have_sense && !cmdstatp->deferred &&
 628                     (cmdstatp->flags & SENSE_EOM) &&
 629                     (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 630                      cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
 631                         /* EOM at write-behind, has all data been written? */
 632                         if (!cmdstatp->remainder_valid ||
 633                             cmdstatp->uremainder64 == 0)
 634                                 retval = -ENOSPC;
 635                 }
 636                 if (retval == -EIO)
 637                         STps->drv_block = -1;
 638         }
 639         STbuffer->writing = 0;
 640
 641         DEB(if (debugging && retval)
 642             printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
 643                    tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
 644
 645         return retval;
 646 }
 647
 648
 649 /* Step over EOF if it has been inadvertently crossed (ioctl not used because
 650    it messes up the block number). */
 651 static int cross_eof(struct scsi_tape * STp, int forward)
 652 {
 653         struct st_request *SRpnt;
 654         unsigned char cmd[MAX_COMMAND_SIZE];
 655
 656         cmd[0] = SPACE;
 657         cmd[1] = 0x01;          /* Space FileMarks */
 658         if (forward) {
 659                 cmd[2] = cmd[3] = 0;
 660                 cmd[4] = 1;
 661         } else
 662                 cmd[2] = cmd[3] = cmd[4] = 0xff;        /* -1 filemarks */
 663         cmd[5] = 0;
 664
 665         DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
 666                    tape_name(STp), forward ? "forward" : "backward"));
 667
 668         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
 669                            STp->device->request_queue->rq_timeout,
 670                            MAX_RETRIES, 1);
 671         if (!SRpnt)
 672                 return (STp->buffer)->syscall_result;
 673
 674         st_release_request(SRpnt);
 675         SRpnt = NULL;
 676
 677         if ((STp->buffer)->cmdstat.midlevel_result != 0)
 678                 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
 679                    tape_name(STp), forward ? "forward" : "backward");
 680
 681         return (STp->buffer)->syscall_result;
 682 }
 683
 684
 685 /* Flush the write buffer (never need to write if variable blocksize). */
 686 static int st_flush_write_buffer(struct scsi_tape * STp)
 687 {
 688         int transfer, blks;
 689         int result;
 690         unsigned char cmd[MAX_COMMAND_SIZE];
 691         struct st_request *SRpnt;
 692         struct st_partstat *STps;
 693
 694         result = write_behind_check(STp);
 695         if (result)
 696                 return result;
 697
 698         result = 0;
 699         if (STp->dirty == 1) {
 700
 701                 transfer = STp->buffer->buffer_bytes;
 702                 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
 703                                tape_name(STp), transfer));
 704
 705                 memset(cmd, 0, MAX_COMMAND_SIZE);
 706                 cmd[0] = WRITE_6;
 707                 cmd[1] = 1;
 708                 blks = transfer / STp->block_size;
 709                 cmd[2] = blks >> 16;
 710                 cmd[3] = blks >> 8;
 711                 cmd[4] = blks;
 712
 713                 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
 714                                    STp->device->request_queue->rq_timeout,
 715                                    MAX_WRITE_RETRIES, 1);
 716                 if (!SRpnt)
 717                         return (STp->buffer)->syscall_result;
 718
 719                 STps = &(STp->ps[STp->partition]);
 720                 if ((STp->buffer)->syscall_result != 0) {
 721                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 722
 723                         if (cmdstatp->have_sense && !cmdstatp->deferred &&
 724                             (cmdstatp->flags & SENSE_EOM) &&
 725                             (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
 726                              cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
 727                             (!cmdstatp->remainder_valid ||
 728                              cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
 729                                 STp->dirty = 0;
 730                                 (STp->buffer)->buffer_bytes = 0;
 731                                 if (STps->drv_block >= 0)
 732                                         STps->drv_block += blks;
 733                                 result = (-ENOSPC);
 734                         } else {
 735                                 printk(KERN_ERR "%s: Error on flush.\n",
 736                                        tape_name(STp));
 737                                 STps->drv_block = (-1);
 738                                 result = (-EIO);
 739                         }
 740                 } else {
 741                         if (STps->drv_block >= 0)
 742                                 STps->drv_block += blks;
 743                         STp->dirty = 0;
 744                         (STp->buffer)->buffer_bytes = 0;
 745                 }
 746                 st_release_request(SRpnt);
 747                 SRpnt = NULL;
 748         }
 749         return result;
 750 }
 751
 752
 753 /* Flush the tape buffer. The tape will be positioned correctly unless
 754    seek_next is true. */
 755 static int flush_buffer(struct scsi_tape *STp, int seek_next)
 756 {
 757         int backspace, result;
 758         struct st_buffer *STbuffer;
 759         struct st_partstat *STps;
 760
 761         STbuffer = STp->buffer;
 762
 763         /*
 764          * If there was a bus reset, block further access
 765          * to this device.
 766          */
 767         if (STp->pos_unknown)
 768                 return (-EIO);
 769
 770         if (STp->ready != ST_READY)
 771                 return 0;
 772         STps = &(STp->ps[STp->partition]);
 773         if (STps->rw == ST_WRITING)     /* Writing */
 774                 return st_flush_write_buffer(STp);
 775
 776         if (STp->block_size == 0)
 777                 return 0;
 778
 779         backspace = ((STp->buffer)->buffer_bytes +
 780                      (STp->buffer)->read_pointer) / STp->block_size -
 781             ((STp->buffer)->read_pointer + STp->block_size - 1) /
 782             STp->block_size;
 783         (STp->buffer)->buffer_bytes = 0;
 784         (STp->buffer)->read_pointer = 0;
 785         result = 0;
 786         if (!seek_next) {
 787                 if (STps->eof == ST_FM_HIT) {
 788                         result = cross_eof(STp, 0);     /* Back over the EOF hit */
 789                         if (!result)
 790                                 STps->eof = ST_NOEOF;
 791                         else {
 792                                 if (STps->drv_file >= 0)
 793                                         STps->drv_file++;
 794                                 STps->drv_block = 0;
 795                         }
 796                 }
 797                 if (!result && backspace > 0)
 798                         result = st_int_ioctl(STp, MTBSR, backspace);
 799         } else if (STps->eof == ST_FM_HIT) {
 800                 if (STps->drv_file >= 0)
 801                         STps->drv_file++;
 802                 STps->drv_block = 0;
 803                 STps->eof = ST_NOEOF;
 804         }
 805         return result;
 806
 807 }
 808 \f
 809 /* Set the mode parameters */
 810 static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
 811 {
 812         int set_it = 0;
 813         unsigned long arg;
 814         char *name = tape_name(STp);
 815
 816         if (!STp->density_changed &&
 817             STm->default_density >= 0 &&
 818             STm->default_density != STp->density) {
 819                 arg = STm->default_density;
 820                 set_it = 1;
 821         } else
 822                 arg = STp->density;
 823         arg <<= MT_ST_DENSITY_SHIFT;
 824         if (!STp->blksize_changed &&
 825             STm->default_blksize >= 0 &&
 826             STm->default_blksize != STp->block_size) {
 827                 arg |= STm->default_blksize;
 828                 set_it = 1;
 829         } else
 830                 arg |= STp->block_size;
 831         if (set_it &&
 832             st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
 833                 printk(KERN_WARNING
 834                        "%s: Can't set default block size to %d bytes and density %x.\n",
 835                        name, STm->default_blksize, STm->default_density);
 836                 if (modes_defined)
 837                         return (-EINVAL);
 838         }
 839         return 0;
 840 }
 841
 842
 843 /* Lock or unlock the drive door. Don't use when st_request allocated. */
 844 static int do_door_lock(struct scsi_tape * STp, int do_lock)
 845 {
 846         int retval, cmd;
 847         DEB(char *name = tape_name(STp);)
 848
 849
 850         cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
 851         DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
 852                     do_lock ? "L" : "Unl"));
 853         retval = scsi_ioctl(STp->device, cmd, NULL);
 854         if (!retval) {
 855                 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
 856         }
 857         else {
 858                 STp->door_locked = ST_LOCK_FAILS;
 859         }
 860         return retval;
 861 }
 862
 863
 864 /* Set the internal state after reset */
 865 static void reset_state(struct scsi_tape *STp)
 866 {
 867         int i;
 868         struct st_partstat *STps;
 869
 870         STp->pos_unknown = 0;
 871         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
 872                 STps = &(STp->ps[i]);
 873                 STps->rw = ST_IDLE;
 874                 STps->eof = ST_NOEOF;
 875                 STps->at_sm = 0;
 876                 STps->last_block_valid = 0;
 877                 STps->drv_block = -1;
 878                 STps->drv_file = -1;
 879         }
 880         if (STp->can_partitions) {
 881                 STp->partition = find_partition(STp);
 882                 if (STp->partition < 0)
 883                         STp->partition = 0;
 884                 STp->new_partition = STp->partition;
 885         }
 886 }
 887 \f
 888 /* Test if the drive is ready. Returns either one of the codes below or a negative system
 889    error code. */
 890 #define CHKRES_READY       0
 891 #define CHKRES_NEW_SESSION 1
 892 #define CHKRES_NOT_READY   2
 893 #define CHKRES_NO_TAPE     3
 894
 895 #define MAX_ATTENTIONS    10
 896
 897 static int test_ready(struct scsi_tape *STp, int do_wait)
 898 {
 899         int attentions, waits, max_wait, scode;
 900         int retval = CHKRES_READY, new_session = 0;
 901         unsigned char cmd[MAX_COMMAND_SIZE];
 902         struct st_request *SRpnt = NULL;
 903         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
 904
 905         max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
 906
 907         for (attentions=waits=0; ; ) {
 908                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
 909                 cmd[0] = TEST_UNIT_READY;
 910                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
 911                                    STp->long_timeout, MAX_READY_RETRIES, 1);
 912
 913                 if (!SRpnt) {
 914                         retval = (STp->buffer)->syscall_result;
 915                         break;
 916                 }
 917
 918                 if (cmdstatp->have_sense) {
 919
 920                         scode = cmdstatp->sense_hdr.sense_key;
 921
 922                         if (scode == UNIT_ATTENTION) { /* New media? */
 923                                 new_session = 1;
 924                                 if (attentions < MAX_ATTENTIONS) {
 925                                         attentions++;
 926                                         continue;
 927                                 }
 928                                 else {
 929                                         retval = (-EIO);
 930                                         break;
 931                                 }
 932                         }
 933
 934                         if (scode == NOT_READY) {
 935                                 if (waits < max_wait) {
 936                                         if (msleep_interruptible(1000)) {
 937                                                 retval = (-EINTR);
 938                                                 break;
 939                                         }
 940                                         waits++;
 941                                         continue;
 942                                 }
 943                                 else {
 944                                         if ((STp->device)->scsi_level >= SCSI_2 &&
 945                                             cmdstatp->sense_hdr.asc == 0x3a)    /* Check ASC */
 946                                                 retval = CHKRES_NO_TAPE;
 947                                         else
 948                                                 retval = CHKRES_NOT_READY;
 949                                         break;
 950                                 }
 951                         }
 952                 }
 953
 954                 retval = (STp->buffer)->syscall_result;
 955                 if (!retval)
 956                         retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
 957                 break;
 958         }
 959
 960         if (SRpnt != NULL)
 961                 st_release_request(SRpnt);
 962         return retval;
 963 }
 964
 965
 966 /* See if the drive is ready and gather information about the tape. Return values:
 967    < 0   negative error code from errno.h
 968    0     drive ready
 969    1     drive not ready (possibly no tape)
 970 */
 971 static int check_tape(struct scsi_tape *STp, struct file *filp)
 972 {
 973         int i, retval, new_session = 0, do_wait;
 974         unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
 975         unsigned short st_flags = filp->f_flags;
 976         struct st_request *SRpnt = NULL;
 977         struct st_modedef *STm;
 978         struct st_partstat *STps;
 979         char *name = tape_name(STp);
 980         struct inode *inode = file_inode(filp);
 981         int mode = TAPE_MODE(inode);
 982
 983         STp->ready = ST_READY;
 984
 985         if (mode != STp->current_mode) {
 986                 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
 987                                name, STp->current_mode, mode));
 988                 new_session = 1;
 989                 STp->current_mode = mode;
 990         }
 991         STm = &(STp->modes[STp->current_mode]);
 992
 993         saved_cleaning = STp->cleaning_req;
 994         STp->cleaning_req = 0;
 995
 996         do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
 997         retval = test_ready(STp, do_wait);
 998
 999         if (retval < 0)
1000             goto err_out;
1001
1002         if (retval == CHKRES_NEW_SESSION) {
1003                 STp->pos_unknown = 0;
1004                 STp->partition = STp->new_partition = 0;
1005                 if (STp->can_partitions)
1006                         STp->nbr_partitions = 1; /* This guess will be updated later
1007                                                     if necessary */
1008                 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1009                         STps = &(STp->ps[i]);
1010                         STps->rw = ST_IDLE;
1011                         STps->eof = ST_NOEOF;
1012                         STps->at_sm = 0;
1013                         STps->last_block_valid = 0;
1014                         STps->drv_block = 0;
1015                         STps->drv_file = 0;
1016                 }
1017                 new_session = 1;
1018         }
1019         else {
1020                 STp->cleaning_req |= saved_cleaning;
1021
1022                 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1023                         if (retval == CHKRES_NO_TAPE)
1024                                 STp->ready = ST_NO_TAPE;
1025                         else
1026                                 STp->ready = ST_NOT_READY;
1027
1028                         STp->density = 0;       /* Clear the erroneous "residue" */
1029                         STp->write_prot = 0;
1030                         STp->block_size = 0;
1031                         STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1032                         STp->partition = STp->new_partition = 0;
1033                         STp->door_locked = ST_UNLOCKED;
1034                         return CHKRES_NOT_READY;
1035                 }
1036         }
1037
1038         if (STp->omit_blklims)
1039                 STp->min_block = STp->max_block = (-1);
1040         else {
1041                 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1042                 cmd[0] = READ_BLOCK_LIMITS;
1043
1044                 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1045                                    STp->device->request_queue->rq_timeout,
1046                                    MAX_READY_RETRIES, 1);
1047                 if (!SRpnt) {
1048                         retval = (STp->buffer)->syscall_result;
1049                         goto err_out;
1050                 }
1051
1052                 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1053                         STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1054                             ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1055                         STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1056                             (STp->buffer)->b_data[5];
1057                         if ( DEB( debugging || ) !STp->inited)
1058                                 printk(KERN_INFO
1059                                        "%s: Block limits %d - %d bytes.\n", name,
1060                                        STp->min_block, STp->max_block);
1061                 } else {
1062                         STp->min_block = STp->max_block = (-1);
1063                         DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1064                                        name));
1065                 }
1066         }
1067
1068         memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1069         cmd[0] = MODE_SENSE;
1070         cmd[4] = 12;
1071
1072         SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1073                            STp->device->request_queue->rq_timeout,
1074                            MAX_READY_RETRIES, 1);
1075         if (!SRpnt) {
1076                 retval = (STp->buffer)->syscall_result;
1077                 goto err_out;
1078         }
1079
1080         if ((STp->buffer)->syscall_result != 0) {
1081                 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1082                 STp->block_size = ST_DEFAULT_BLOCK;     /* Educated guess (?) */
1083                 (STp->buffer)->syscall_result = 0;      /* Prevent error propagation */
1084                 STp->drv_write_prot = 0;
1085         } else {
1086                 DEBC(printk(ST_DEB_MSG
1087                             "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1088                             name,
1089                             (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1090                             (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1091
1092                 if ((STp->buffer)->b_data[3] >= 8) {
1093                         STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1094                         STp->density = (STp->buffer)->b_data[4];
1095                         STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1096                             (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1097                         DEBC(printk(ST_DEB_MSG
1098                                     "%s: Density %x, tape length: %x, drv buffer: %d\n",
1099                                     name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1100                                     (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1101                                     STp->drv_buffer));
1102                 }
1103                 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1104                 if (!STp->drv_buffer && STp->immediate_filemark) {
1105                         printk(KERN_WARNING
1106                             "%s: non-buffered tape: disabling writing immediate filemarks\n",
1107                             name);
1108                         STp->immediate_filemark = 0;
1109                 }
1110         }
1111         st_release_request(SRpnt);
1112         SRpnt = NULL;
1113         STp->inited = 1;
1114
1115         if (STp->block_size > 0)
1116                 (STp->buffer)->buffer_blocks =
1117                         (STp->buffer)->buffer_size / STp->block_size;
1118         else
1119                 (STp->buffer)->buffer_blocks = 1;
1120         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1121
1122         DEBC(printk(ST_DEB_MSG
1123                        "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1124                        STp->block_size, (STp->buffer)->buffer_size,
1125                        (STp->buffer)->buffer_blocks));
1126
1127         if (STp->drv_write_prot) {
1128                 STp->write_prot = 1;
1129
1130                 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1131
1132                 if (do_wait &&
1133                     ((st_flags & O_ACCMODE) == O_WRONLY ||
1134                      (st_flags & O_ACCMODE) == O_RDWR)) {
1135                         retval = (-EROFS);
1136                         goto err_out;
1137                 }
1138         }
1139
1140         if (STp->can_partitions && STp->nbr_partitions < 1) {
1141                 /* This code is reached when the device is opened for the first time
1142                    after the driver has been initialized with tape in the drive and the
1143                    partition support has been enabled. */
1144                 DEBC(printk(ST_DEB_MSG
1145                             "%s: Updating partition number in status.\n", name));
1146                 if ((STp->partition = find_partition(STp)) < 0) {
1147                         retval = STp->partition;
1148                         goto err_out;
1149                 }
1150                 STp->new_partition = STp->partition;
1151                 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1152         }
1153
1154         if (new_session) {      /* Change the drive parameters for the new mode */
1155                 STp->density_changed = STp->blksize_changed = 0;
1156                 STp->compression_changed = 0;
1157                 if (!(STm->defaults_for_writes) &&
1158                     (retval = set_mode_densblk(STp, STm)) < 0)
1159                     goto err_out;
1160
1161                 if (STp->default_drvbuffer != 0xff) {
1162                         if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1163                                 printk(KERN_WARNING
1164                                        "%s: Can't set default drive buffering to %d.\n",
1165                                        name, STp->default_drvbuffer);
1166                 }
1167         }
1168
1169         return CHKRES_READY;
1170
1171  err_out:
1172         return retval;
1173 }
1174
1175
1176 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1177    module count. */
1178 static int st_open(struct inode *inode, struct file *filp)
1179 {
1180         int i, retval = (-EIO);
1181         int resumed = 0;
1182         struct scsi_tape *STp;
1183         struct st_partstat *STps;
1184         int dev = TAPE_NR(inode);
1185         char *name;
1186
1187         /*
1188          * We really want to do nonseekable_open(inode, filp); here, but some
1189          * versions of tar incorrectly call lseek on tapes and bail out if that
1190          * fails.  So we disallow pread() and pwrite(), but permit lseeks.
1191          */
1192         filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1193
1194         if (!(STp = scsi_tape_get(dev))) {
1195                 return -ENXIO;
1196         }
1197
1198         filp->private_data = STp;
1199         name = tape_name(STp);
1200
1201         spin_lock(&st_use_lock);
1202         if (STp->in_use) {
1203                 spin_unlock(&st_use_lock);
1204                 scsi_tape_put(STp);
1205                 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1206                 return (-EBUSY);
1207         }
1208
1209         STp->in_use = 1;
1210         spin_unlock(&st_use_lock);
1211         STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1212
1213         if (scsi_autopm_get_device(STp->device) < 0) {
1214                 retval = -EIO;
1215                 goto err_out;
1216         }
1217         resumed = 1;
1218         if (!scsi_block_when_processing_errors(STp->device)) {
1219                 retval = (-ENXIO);
1220                 goto err_out;
1221         }
1222
1223         /* See that we have at least a one page buffer available */
1224         if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1225                 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1226                        name);
1227                 retval = (-EOVERFLOW);
1228                 goto err_out;
1229         }
1230
1231         (STp->buffer)->cleared = 0;
1232         (STp->buffer)->writing = 0;
1233         (STp->buffer)->syscall_result = 0;
1234
1235         STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1236
1237         STp->dirty = 0;
1238         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1239                 STps = &(STp->ps[i]);
1240                 STps->rw = ST_IDLE;
1241         }
1242         STp->try_dio_now = STp->try_dio;
1243         STp->recover_count = 0;
1244         DEB( STp->nbr_waits = STp->nbr_finished = 0;
1245              STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1246
1247         retval = check_tape(STp, filp);
1248         if (retval < 0)
1249                 goto err_out;
1250         if ((filp->f_flags & O_NONBLOCK) == 0 &&
1251             retval != CHKRES_READY) {
1252                 if (STp->ready == NO_TAPE)
1253                         retval = (-ENOMEDIUM);
1254                 else
1255                         retval = (-EIO);
1256                 goto err_out;
1257         }
1258         return 0;
1259
1260  err_out:
1261         normalize_buffer(STp->buffer);
1262         spin_lock(&st_use_lock);
1263         STp->in_use = 0;
1264         spin_unlock(&st_use_lock);
1265         scsi_tape_put(STp);
1266         if (resumed)
1267                 scsi_autopm_put_device(STp->device);
1268         return retval;
1269
1270 }
1271 \f
1272
1273 /* Flush the tape buffer before close */
1274 static int st_flush(struct file *filp, fl_owner_t id)
1275 {
1276         int result = 0, result2;
1277         unsigned char cmd[MAX_COMMAND_SIZE];
1278         struct st_request *SRpnt;
1279         struct scsi_tape *STp = filp->private_data;
1280         struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1281         struct st_partstat *STps = &(STp->ps[STp->partition]);
1282         char *name = tape_name(STp);
1283
1284         if (file_count(filp) > 1)
1285                 return 0;
1286
1287         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1288                 result = st_flush_write_buffer(STp);
1289                 if (result != 0 && result != (-ENOSPC))
1290                         goto out;
1291         }
1292
1293         if (STp->can_partitions &&
1294             (result2 = switch_partition(STp)) < 0) {
1295                 DEBC(printk(ST_DEB_MSG
1296                                "%s: switch_partition at close failed.\n", name));
1297                 if (result == 0)
1298                         result = result2;
1299                 goto out;
1300         }
1301
1302         DEBC( if (STp->nbr_requests)
1303                 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1304                        name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1305
1306         if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1307                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1308
1309                 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1310                             name, STp->nbr_waits, STp->nbr_finished);
1311                 )
1312
1313                 memset(cmd, 0, MAX_COMMAND_SIZE);
1314                 cmd[0] = WRITE_FILEMARKS;
1315                 if (STp->immediate_filemark)
1316                         cmd[1] = 1;
1317                 cmd[4] = 1 + STp->two_fm;
1318
1319                 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1320                                    STp->device->request_queue->rq_timeout,
1321                                    MAX_WRITE_RETRIES, 1);
1322                 if (!SRpnt) {
1323                         result = (STp->buffer)->syscall_result;
1324                         goto out;
1325                 }
1326
1327                 if (STp->buffer->syscall_result == 0 ||
1328                     (cmdstatp->have_sense && !cmdstatp->deferred &&
1329                      (cmdstatp->flags & SENSE_EOM) &&
1330                      (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1331                       cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1332                      (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1333                         /* Write successful at EOM */
1334                         st_release_request(SRpnt);
1335                         SRpnt = NULL;
1336                         if (STps->drv_file >= 0)
1337                                 STps->drv_file++;
1338                         STps->drv_block = 0;
1339                         if (STp->two_fm)
1340                                 cross_eof(STp, 0);
1341                         STps->eof = ST_FM;
1342                 }
1343                 else { /* Write error */
1344                         st_release_request(SRpnt);
1345                         SRpnt = NULL;
1346                         printk(KERN_ERR "%s: Error on write filemark.\n", name);
1347                         if (result == 0)
1348                                 result = (-EIO);
1349                 }
1350
1351                 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1352                             name, cmd[4]));
1353         } else if (!STp->rew_at_close) {
1354                 STps = &(STp->ps[STp->partition]);
1355                 if (!STm->sysv || STps->rw != ST_READING) {
1356                         if (STp->can_bsr)
1357                                 result = flush_buffer(STp, 0);
1358                         else if (STps->eof == ST_FM_HIT) {
1359                                 result = cross_eof(STp, 0);
1360                                 if (result) {
1361                                         if (STps->drv_file >= 0)
1362                                                 STps->drv_file++;
1363                                         STps->drv_block = 0;
1364                                         STps->eof = ST_FM;
1365                                 } else
1366                                         STps->eof = ST_NOEOF;
1367                         }
1368                 } else if ((STps->eof == ST_NOEOF &&
1369                             !(result = cross_eof(STp, 1))) ||
1370                            STps->eof == ST_FM_HIT) {
1371                         if (STps->drv_file >= 0)
1372                                 STps->drv_file++;
1373                         STps->drv_block = 0;
1374                         STps->eof = ST_FM;
1375                 }
1376         }
1377
1378       out:
1379         if (STp->rew_at_close) {
1380                 result2 = st_int_ioctl(STp, MTREW, 1);
1381                 if (result == 0)
1382                         result = result2;
1383         }
1384         return result;
1385 }
1386
1387
1388 /* Close the device and release it. BKL is not needed: this is the only thread
1389    accessing this tape. */
1390 static int st_release(struct inode *inode, struct file *filp)
1391 {
1392         int result = 0;
1393         struct scsi_tape *STp = filp->private_data;
1394
1395         if (STp->door_locked == ST_LOCKED_AUTO)
1396                 do_door_lock(STp, 0);
1397
1398         normalize_buffer(STp->buffer);
1399         spin_lock(&st_use_lock);
1400         STp->in_use = 0;
1401         spin_unlock(&st_use_lock);
1402         scsi_autopm_put_device(STp->device);
1403         scsi_tape_put(STp);
1404
1405         return result;
1406 }
1407 \f
1408 /* The checks common to both reading and writing */
1409 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1410 {
1411         ssize_t retval = 0;
1412
1413         /*
1414          * If we are in the middle of error recovery, don't let anyone
1415          * else try and use this device.  Also, if error recovery fails, it
1416          * may try and take the device offline, in which case all further
1417          * access to the device is prohibited.
1418          */
1419         if (!scsi_block_when_processing_errors(STp->device)) {
1420                 retval = (-ENXIO);
1421                 goto out;
1422         }
1423
1424         if (STp->ready != ST_READY) {
1425                 if (STp->ready == ST_NO_TAPE)
1426                         retval = (-ENOMEDIUM);
1427                 else
1428                         retval = (-EIO);
1429                 goto out;
1430         }
1431
1432         if (! STp->modes[STp->current_mode].defined) {
1433                 retval = (-ENXIO);
1434                 goto out;
1435         }
1436
1437
1438         /*
1439          * If there was a bus reset, block further access
1440          * to this device.
1441          */
1442         if (STp->pos_unknown) {
1443                 retval = (-EIO);
1444                 goto out;
1445         }
1446
1447         if (count == 0)
1448                 goto out;
1449
1450         DEB(
1451         if (!STp->in_use) {
1452                 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1453                 retval = (-EIO);
1454                 goto out;
1455         } ) /* end DEB */
1456
1457         if (STp->can_partitions &&
1458             (retval = switch_partition(STp)) < 0)
1459                 goto out;
1460
1461         if (STp->block_size == 0 && STp->max_block > 0 &&
1462             (count < STp->min_block || count > STp->max_block)) {
1463                 retval = (-EINVAL);
1464                 goto out;
1465         }
1466
1467         if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1468             !do_door_lock(STp, 1))
1469                 STp->door_locked = ST_LOCKED_AUTO;
1470
1471  out:
1472         return retval;
1473 }
1474
1475
1476 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1477                            size_t count, int is_read)
1478 {
1479         int i, bufsize, retval = 0;
1480         struct st_buffer *STbp = STp->buffer;
1481
1482         if (is_read)
1483                 i = STp->try_dio_now && try_rdio;
1484         else
1485                 i = STp->try_dio_now && try_wdio;
1486
1487         if (i && ((unsigned long)buf & queue_dma_alignment(
1488                                         STp->device->request_queue)) == 0) {
1489                 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1490                                        count, (is_read ? READ : WRITE));
1491                 if (i > 0) {
1492                         STbp->do_dio = i;
1493                         STbp->buffer_bytes = 0;   /* can be used as transfer counter */
1494                 }
1495                 else
1496                         STbp->do_dio = 0;  /* fall back to buffering with any error */
1497                 STbp->sg_segs = STbp->do_dio;
1498                 DEB(
1499                      if (STbp->do_dio) {
1500                         STp->nbr_dio++;
1501                         STp->nbr_pages += STbp->do_dio;
1502                      }
1503                 )
1504         } else
1505                 STbp->do_dio = 0;
1506         DEB( STp->nbr_requests++; )
1507
1508         if (!STbp->do_dio) {
1509                 if (STp->block_size)
1510                         bufsize = STp->block_size > st_fixed_buffer_size ?
1511                                 STp->block_size : st_fixed_buffer_size;
1512                 else {
1513                         bufsize = count;
1514                         /* Make sure that data from previous user is not leaked even if
1515                            HBA does not return correct residual */
1516                         if (is_read && STp->sili && !STbp->cleared)
1517                                 clear_buffer(STbp);
1518                 }
1519
1520                 if (bufsize > STbp->buffer_size &&
1521                     !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1522                         printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1523                                tape_name(STp), bufsize);
1524                         retval = (-EOVERFLOW);
1525                         goto out;
1526                 }
1527                 if (STp->block_size)
1528                         STbp->buffer_blocks = bufsize / STp->block_size;
1529         }
1530
1531  out:
1532         return retval;
1533 }
1534
1535
1536 /* Can be called more than once after each setup_buffer() */
1537 static void release_buffering(struct scsi_tape *STp, int is_read)
1538 {
1539         struct st_buffer *STbp;
1540
1541         STbp = STp->buffer;
1542         if (STbp->do_dio) {
1543                 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1544                 STbp->do_dio = 0;
1545                 STbp->sg_segs = 0;
1546         }
1547 }
1548
1549
1550 /* Write command */
1551 static ssize_t
1552 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1553 {
1554         ssize_t total;
1555         ssize_t i, do_count, blks, transfer;
1556         ssize_t retval;
1557         int undone, retry_eot = 0, scode;
1558         int async_write;
1559         unsigned char cmd[MAX_COMMAND_SIZE];
1560         const char __user *b_point;
1561         struct st_request *SRpnt = NULL;
1562         struct scsi_tape *STp = filp->private_data;
1563         struct st_modedef *STm;
1564         struct st_partstat *STps;
1565         struct st_buffer *STbp;
1566         char *name = tape_name(STp);
1567
1568         if (mutex_lock_interruptible(&STp->lock))
1569                 return -ERESTARTSYS;
1570
1571         retval = rw_checks(STp, filp, count);
1572         if (retval || count == 0)
1573                 goto out;
1574
1575         /* Write must be integral number of blocks */
1576         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1577                 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1578                        name);
1579                 retval = (-EINVAL);
1580                 goto out;
1581         }
1582
1583         STm = &(STp->modes[STp->current_mode]);
1584         STps = &(STp->ps[STp->partition]);
1585
1586         if (STp->write_prot) {
1587                 retval = (-EACCES);
1588                 goto out;
1589         }
1590
1591
1592         if (STps->rw == ST_READING) {
1593                 retval = flush_buffer(STp, 0);
1594                 if (retval)
1595                         goto out;
1596                 STps->rw = ST_WRITING;
1597         } else if (STps->rw != ST_WRITING &&
1598                    STps->drv_file == 0 && STps->drv_block == 0) {
1599                 if ((retval = set_mode_densblk(STp, STm)) < 0)
1600                         goto out;
1601                 if (STm->default_compression != ST_DONT_TOUCH &&
1602                     !(STp->compression_changed)) {
1603                         if (st_compression(STp, (STm->default_compression == ST_YES))) {
1604                                 printk(KERN_WARNING "%s: Can't set default compression.\n",
1605                                        name);
1606                                 if (modes_defined) {
1607                                         retval = (-EINVAL);
1608                                         goto out;
1609                                 }
1610                         }
1611                 }
1612         }
1613
1614         STbp = STp->buffer;
1615         i = write_behind_check(STp);
1616         if (i) {
1617                 if (i == -ENOSPC)
1618                         STps->eof = ST_EOM_OK;
1619                 else
1620                         STps->eof = ST_EOM_ERROR;
1621         }
1622
1623         if (STps->eof == ST_EOM_OK) {
1624                 STps->eof = ST_EOD_1;  /* allow next write */
1625                 retval = (-ENOSPC);
1626                 goto out;
1627         }
1628         else if (STps->eof == ST_EOM_ERROR) {
1629                 retval = (-EIO);
1630                 goto out;
1631         }
1632
1633         /* Check the buffer readability in cases where copy_user might catch
1634            the problems after some tape movement. */
1635         if (STp->block_size != 0 &&
1636             !STbp->do_dio &&
1637             (copy_from_user(&i, buf, 1) != 0 ||
1638              copy_from_user(&i, buf + count - 1, 1) != 0)) {
1639                 retval = (-EFAULT);
1640                 goto out;
1641         }
1642
1643         retval = setup_buffering(STp, buf, count, 0);
1644         if (retval)
1645                 goto out;
1646
1647         total = count;
1648
1649         memset(cmd, 0, MAX_COMMAND_SIZE);
1650         cmd[0] = WRITE_6;
1651         cmd[1] = (STp->block_size != 0);
1652
1653         STps->rw = ST_WRITING;
1654
1655         b_point = buf;
1656         while (count > 0 && !retry_eot) {
1657
1658                 if (STbp->do_dio) {
1659                         do_count = count;
1660                 }
1661                 else {
1662                         if (STp->block_size == 0)
1663                                 do_count = count;
1664                         else {
1665                                 do_count = STbp->buffer_blocks * STp->block_size -
1666                                         STbp->buffer_bytes;
1667                                 if (do_count > count)
1668                                         do_count = count;
1669                         }
1670
1671                         i = append_to_buffer(b_point, STbp, do_count);
1672                         if (i) {
1673                                 retval = i;
1674                                 goto out;
1675                         }
1676                 }
1677                 count -= do_count;
1678                 b_point += do_count;
1679
1680                 async_write = STp->block_size == 0 && !STbp->do_dio &&
1681                         STm->do_async_writes && STps->eof < ST_EOM_OK;
1682
1683                 if (STp->block_size != 0 && STm->do_buffer_writes &&
1684                     !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1685                     STbp->buffer_bytes < STbp->buffer_size) {
1686                         STp->dirty = 1;
1687                         /* Don't write a buffer that is not full enough. */
1688                         if (!async_write && count == 0)
1689                                 break;
1690                 }
1691
1692         retry_write:
1693                 if (STp->block_size == 0)
1694                         blks = transfer = do_count;
1695                 else {
1696                         if (!STbp->do_dio)
1697                                 blks = STbp->buffer_bytes;
1698                         else
1699                                 blks = do_count;
1700                         blks /= STp->block_size;
1701                         transfer = blks * STp->block_size;
1702                 }
1703                 cmd[2] = blks >> 16;
1704                 cmd[3] = blks >> 8;
1705                 cmd[4] = blks;
1706
1707                 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1708                                    STp->device->request_queue->rq_timeout,
1709                                    MAX_WRITE_RETRIES, !async_write);
1710                 if (!SRpnt) {
1711                         retval = STbp->syscall_result;
1712                         goto out;
1713                 }
1714                 if (async_write && !STbp->syscall_result) {
1715                         STbp->writing = transfer;
1716                         STp->dirty = !(STbp->writing ==
1717                                        STbp->buffer_bytes);
1718                         SRpnt = NULL;  /* Prevent releasing this request! */
1719                         DEB( STp->write_pending = 1; )
1720                         break;
1721                 }
1722
1723                 if (STbp->syscall_result != 0) {
1724                         struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1725
1726                         DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1727                         if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1728                                 scode = cmdstatp->sense_hdr.sense_key;
1729                                 if (cmdstatp->remainder_valid)
1730                                         undone = (int)cmdstatp->uremainder64;
1731                                 else if (STp->block_size == 0 &&
1732                                          scode == VOLUME_OVERFLOW)
1733                                         undone = transfer;
1734                                 else
1735                                         undone = 0;
1736                                 if (STp->block_size != 0)
1737                                         undone *= STp->block_size;
1738                                 if (undone <= do_count) {
1739                                         /* Only data from this write is not written */
1740                                         count += undone;
1741                                         b_point -= undone;
1742                                         do_count -= undone;
1743                                         if (STp->block_size)
1744                                                 blks = (transfer - undone) / STp->block_size;
1745                                         STps->eof = ST_EOM_OK;
1746                                         /* Continue in fixed block mode if all written
1747                                            in this request but still something left to write
1748                                            (retval left to zero)
1749                                         */
1750                                         if (STp->block_size == 0 ||
1751                                             undone > 0 || count == 0)
1752                                                 retval = (-ENOSPC); /* EOM within current request */
1753                                         DEBC(printk(ST_DEB_MSG
1754                                                        "%s: EOM with %d bytes unwritten.\n",
1755                                                        name, (int)count));
1756                                 } else {
1757                                         /* EOT within data buffered earlier (possible only
1758                                            in fixed block mode without direct i/o) */
1759                                         if (!retry_eot && !cmdstatp->deferred &&
1760                                             (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1761                                                 move_buffer_data(STp->buffer, transfer - undone);
1762                                                 retry_eot = 1;
1763                                                 if (STps->drv_block >= 0) {
1764                                                         STps->drv_block += (transfer - undone) /
1765                                                                 STp->block_size;
1766                                                 }
1767                                                 STps->eof = ST_EOM_OK;
1768                                                 DEBC(printk(ST_DEB_MSG
1769                                                             "%s: Retry write of %d bytes at EOM.\n",
1770                                                             name, STp->buffer->buffer_bytes));
1771                                                 goto retry_write;
1772                                         }
1773                                         else {
1774                                                 /* Either error within data buffered by driver or
1775                                                    failed retry */
1776                                                 count -= do_count;
1777                                                 blks = do_count = 0;
1778                                                 STps->eof = ST_EOM_ERROR;
1779                                                 STps->drv_block = (-1); /* Too cautious? */
1780                                                 retval = (-EIO);        /* EOM for old data */
1781                                                 DEBC(printk(ST_DEB_MSG
1782                                                             "%s: EOM with lost data.\n",
1783                                                             name));
1784                                         }
1785                                 }
1786                         } else {
1787                                 count += do_count;
1788                                 STps->drv_block = (-1);         /* Too cautious? */
1789                                 retval = STbp->syscall_result;
1790                         }
1791
1792                 }
1793
1794                 if (STps->drv_block >= 0) {
1795                         if (STp->block_size == 0)
1796                                 STps->drv_block += (do_count > 0);
1797                         else
1798                                 STps->drv_block += blks;
1799                 }
1800
1801                 STbp->buffer_bytes = 0;
1802                 STp->dirty = 0;
1803
1804                 if (retval || retry_eot) {
1805                         if (count < total)
1806                                 retval = total - count;
1807                         goto out;
1808                 }
1809         }
1810
1811         if (STps->eof == ST_EOD_1)
1812                 STps->eof = ST_EOM_OK;
1813         else if (STps->eof != ST_EOM_OK)
1814                 STps->eof = ST_NOEOF;
1815         retval = total - count;
1816
1817  out:
1818         if (SRpnt != NULL)
1819                 st_release_request(SRpnt);
1820         release_buffering(STp, 0);
1821         mutex_unlock(&STp->lock);
1822
1823         return retval;
1824 }
1825 \f
1826 /* Read data from the tape. Returns zero in the normal case, one if the
1827    eof status has changed, and the negative error code in case of a
1828    fatal error. Otherwise updates the buffer and the eof state.
1829
1830    Does release user buffer mapping if it is set.
1831 */
1832 static long read_tape(struct scsi_tape *STp, long count,
1833                       struct st_request ** aSRpnt)
1834 {
1835         int transfer, blks, bytes;
1836         unsigned char cmd[MAX_COMMAND_SIZE];
1837         struct st_request *SRpnt;
1838         struct st_modedef *STm;
1839         struct st_partstat *STps;
1840         struct st_buffer *STbp;
1841         int retval = 0;
1842         char *name = tape_name(STp);
1843
1844         if (count == 0)
1845                 return 0;
1846
1847         STm = &(STp->modes[STp->current_mode]);
1848         STps = &(STp->ps[STp->partition]);
1849         if (STps->eof == ST_FM_HIT)
1850                 return 1;
1851         STbp = STp->buffer;
1852
1853         if (STp->block_size == 0)
1854                 blks = bytes = count;
1855         else {
1856                 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1857                         blks = (STp->buffer)->buffer_blocks;
1858                         bytes = blks * STp->block_size;
1859                 } else {
1860                         bytes = count;
1861                         if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1862                                 bytes = (STp->buffer)->buffer_size;
1863                         blks = bytes / STp->block_size;
1864                         bytes = blks * STp->block_size;
1865                 }
1866         }
1867
1868         memset(cmd, 0, MAX_COMMAND_SIZE);
1869         cmd[0] = READ_6;
1870         cmd[1] = (STp->block_size != 0);
1871         if (!cmd[1] && STp->sili)
1872                 cmd[1] |= 2;
1873         cmd[2] = blks >> 16;
1874         cmd[3] = blks >> 8;
1875         cmd[4] = blks;
1876
1877         SRpnt = *aSRpnt;
1878         SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1879                            STp->device->request_queue->rq_timeout,
1880                            MAX_RETRIES, 1);
1881         release_buffering(STp, 1);
1882         *aSRpnt = SRpnt;
1883         if (!SRpnt)
1884                 return STbp->syscall_result;
1885
1886         STbp->read_pointer = 0;
1887         STps->at_sm = 0;
1888
1889         /* Something to check */
1890         if (STbp->syscall_result) {
1891                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1892
1893                 retval = 1;
1894                 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1895                             name,
1896                             SRpnt->sense[0], SRpnt->sense[1],
1897                             SRpnt->sense[2], SRpnt->sense[3],
1898                             SRpnt->sense[4], SRpnt->sense[5],
1899                             SRpnt->sense[6], SRpnt->sense[7]));
1900                 if (cmdstatp->have_sense) {
1901
1902                         if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1903                                 cmdstatp->flags &= 0xcf;        /* No need for EOM in this case */
1904
1905                         if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1906                                 /* Compute the residual count */
1907                                 if (cmdstatp->remainder_valid)
1908                                         transfer = (int)cmdstatp->uremainder64;
1909                                 else
1910                                         transfer = 0;
1911                                 if (STp->block_size == 0 &&
1912                                     cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1913                                         transfer = bytes;
1914
1915                                 if (cmdstatp->flags & SENSE_ILI) {      /* ILI */
1916                                         if (STp->block_size == 0) {
1917                                                 if (transfer <= 0) {
1918                                                         if (transfer < 0)
1919                                                                 printk(KERN_NOTICE
1920                                                                        "%s: Failed to read %d byte block with %d byte transfer.\n",
1921                                                                        name, bytes - transfer, bytes);
1922                                                         if (STps->drv_block >= 0)
1923                                                                 STps->drv_block += 1;
1924                                                         STbp->buffer_bytes = 0;
1925                                                         return (-ENOMEM);
1926                                                 }
1927                                                 STbp->buffer_bytes = bytes - transfer;
1928                                         } else {
1929                                                 st_release_request(SRpnt);
1930                                                 SRpnt = *aSRpnt = NULL;
1931                                                 if (transfer == blks) { /* We did not get anything, error */
1932                                                         printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1933                                                         if (STps->drv_block >= 0)
1934                                                                 STps->drv_block += blks - transfer + 1;
1935                                                         st_int_ioctl(STp, MTBSR, 1);
1936                                                         return (-EIO);
1937                                                 }
1938                                                 /* We have some data, deliver it */
1939                                                 STbp->buffer_bytes = (blks - transfer) *
1940                                                     STp->block_size;
1941                                                 DEBC(printk(ST_DEB_MSG
1942                                                             "%s: ILI but enough data received %ld %d.\n",
1943                                                             name, count, STbp->buffer_bytes));
1944                                                 if (STps->drv_block >= 0)
1945                                                         STps->drv_block += 1;
1946                                                 if (st_int_ioctl(STp, MTBSR, 1))
1947                                                         return (-EIO);
1948                                         }
1949                                 } else if (cmdstatp->flags & SENSE_FMK) {       /* FM overrides EOM */
1950                                         if (STps->eof != ST_FM_HIT)
1951                                                 STps->eof = ST_FM_HIT;
1952                                         else
1953                                                 STps->eof = ST_EOD_2;
1954                                         if (STp->block_size == 0)
1955                                                 STbp->buffer_bytes = 0;
1956                                         else
1957                                                 STbp->buffer_bytes =
1958                                                     bytes - transfer * STp->block_size;
1959                                         DEBC(printk(ST_DEB_MSG
1960                                                     "%s: EOF detected (%d bytes read).\n",
1961                                                     name, STbp->buffer_bytes));
1962                                 } else if (cmdstatp->flags & SENSE_EOM) {
1963                                         if (STps->eof == ST_FM)
1964                                                 STps->eof = ST_EOD_1;
1965                                         else
1966                                                 STps->eof = ST_EOM_OK;
1967                                         if (STp->block_size == 0)
1968                                                 STbp->buffer_bytes = bytes - transfer;
1969                                         else
1970                                                 STbp->buffer_bytes =
1971                                                     bytes - transfer * STp->block_size;
1972
1973                                         DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1974                                                     name, STbp->buffer_bytes));
1975                                 }
1976                         }
1977                         /* end of EOF, EOM, ILI test */
1978                         else {  /* nonzero sense key */
1979                                 DEBC(printk(ST_DEB_MSG
1980                                             "%s: Tape error while reading.\n", name));
1981                                 STps->drv_block = (-1);
1982                                 if (STps->eof == ST_FM &&
1983                                     cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1984                                         DEBC(printk(ST_DEB_MSG
1985                                                     "%s: Zero returned for first BLANK CHECK after EOF.\n",
1986                                                     name));
1987                                         STps->eof = ST_EOD_2;   /* First BLANK_CHECK after FM */
1988                                 } else  /* Some other extended sense code */
1989                                         retval = (-EIO);
1990                         }
1991
1992                         if (STbp->buffer_bytes < 0)  /* Caused by bogus sense data */
1993                                 STbp->buffer_bytes = 0;
1994                 }
1995                 /* End of extended sense test */
1996                 else {          /* Non-extended sense */
1997                         retval = STbp->syscall_result;
1998                 }
1999
2000         }
2001         /* End of error handling */
2002         else {                  /* Read successful */
2003                 STbp->buffer_bytes = bytes;
2004                 if (STp->sili) /* In fixed block mode residual is always zero here */
2005                         STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2006         }
2007
2008         if (STps->drv_block >= 0) {
2009                 if (STp->block_size == 0)
2010                         STps->drv_block++;
2011                 else
2012                         STps->drv_block += STbp->buffer_bytes / STp->block_size;
2013         }
2014         return retval;
2015 }
2016 \f
2017
2018 /* Read command */
2019 static ssize_t
2020 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2021 {
2022         ssize_t total;
2023         ssize_t retval = 0;
2024         ssize_t i, transfer;
2025         int special, do_dio = 0;
2026         struct st_request *SRpnt = NULL;
2027         struct scsi_tape *STp = filp->private_data;
2028         struct st_modedef *STm;
2029         struct st_partstat *STps;
2030         struct st_buffer *STbp = STp->buffer;
2031         DEB( char *name = tape_name(STp); )
2032
2033         if (mutex_lock_interruptible(&STp->lock))
2034                 return -ERESTARTSYS;
2035
2036         retval = rw_checks(STp, filp, count);
2037         if (retval || count == 0)
2038                 goto out;
2039
2040         STm = &(STp->modes[STp->current_mode]);
2041         if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2042                 if (!STm->do_read_ahead) {
2043                         retval = (-EINVAL);     /* Read must be integral number of blocks */
2044                         goto out;
2045                 }
2046                 STp->try_dio_now = 0;  /* Direct i/o can't handle split blocks */
2047         }
2048
2049         STps = &(STp->ps[STp->partition]);
2050         if (STps->rw == ST_WRITING) {
2051                 retval = flush_buffer(STp, 0);
2052                 if (retval)
2053                         goto out;
2054                 STps->rw = ST_READING;
2055         }
2056         DEB(
2057         if (debugging && STps->eof != ST_NOEOF)
2058                 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2059                        STps->eof, STbp->buffer_bytes);
2060         ) /* end DEB */
2061
2062         retval = setup_buffering(STp, buf, count, 1);
2063         if (retval)
2064                 goto out;
2065         do_dio = STbp->do_dio;
2066
2067         if (STbp->buffer_bytes == 0 &&
2068             STps->eof >= ST_EOD_1) {
2069                 if (STps->eof < ST_EOD) {
2070                         STps->eof += 1;
2071                         retval = 0;
2072                         goto out;
2073                 }
2074                 retval = (-EIO);        /* EOM or Blank Check */
2075                 goto out;
2076         }
2077
2078         if (do_dio) {
2079                 /* Check the buffer writability before any tape movement. Don't alter
2080                    buffer data. */
2081                 if (copy_from_user(&i, buf, 1) != 0 ||
2082                     copy_to_user(buf, &i, 1) != 0 ||
2083                     copy_from_user(&i, buf + count - 1, 1) != 0 ||
2084                     copy_to_user(buf + count - 1, &i, 1) != 0) {
2085                         retval = (-EFAULT);
2086                         goto out;
2087                 }
2088         }
2089
2090         STps->rw = ST_READING;
2091
2092
2093         /* Loop until enough data in buffer or a special condition found */
2094         for (total = 0, special = 0; total < count && !special;) {
2095
2096                 /* Get new data if the buffer is empty */
2097                 if (STbp->buffer_bytes == 0) {
2098                         special = read_tape(STp, count - total, &SRpnt);
2099                         if (special < 0) {      /* No need to continue read */
2100                                 retval = special;
2101                                 goto out;
2102                         }
2103                 }
2104
2105                 /* Move the data from driver buffer to user buffer */
2106                 if (STbp->buffer_bytes > 0) {
2107                         DEB(
2108                         if (debugging && STps->eof != ST_NOEOF)
2109                                 printk(ST_DEB_MSG
2110                                        "%s: EOF up (%d). Left %d, needed %d.\n", name,
2111                                        STps->eof, STbp->buffer_bytes,
2112                                        (int)(count - total));
2113                         ) /* end DEB */
2114                         transfer = STbp->buffer_bytes < count - total ?
2115                             STbp->buffer_bytes : count - total;
2116                         if (!do_dio) {
2117                                 i = from_buffer(STbp, buf, transfer);
2118                                 if (i) {
2119                                         retval = i;
2120                                         goto out;
2121                                 }
2122                         }
2123                         buf += transfer;
2124                         total += transfer;
2125                 }
2126
2127                 if (STp->block_size == 0)
2128                         break;  /* Read only one variable length block */
2129
2130         }                       /* for (total = 0, special = 0;
2131                                    total < count && !special; ) */
2132
2133         /* Change the eof state if no data from tape or buffer */
2134         if (total == 0) {
2135                 if (STps->eof == ST_FM_HIT) {
2136                         STps->eof = ST_FM;
2137                         STps->drv_block = 0;
2138                         if (STps->drv_file >= 0)
2139                                 STps->drv_file++;
2140                 } else if (STps->eof == ST_EOD_1) {
2141                         STps->eof = ST_EOD_2;
2142                         STps->drv_block = 0;
2143                         if (STps->drv_file >= 0)
2144                                 STps->drv_file++;
2145                 } else if (STps->eof == ST_EOD_2)
2146                         STps->eof = ST_EOD;
2147         } else if (STps->eof == ST_FM)
2148                 STps->eof = ST_NOEOF;
2149         retval = total;
2150
2151  out:
2152         if (SRpnt != NULL) {
2153                 st_release_request(SRpnt);
2154                 SRpnt = NULL;
2155         }
2156         if (do_dio) {
2157                 release_buffering(STp, 1);
2158                 STbp->buffer_bytes = 0;
2159         }
2160         mutex_unlock(&STp->lock);
2161
2162         return retval;
2163 }
2164 \f
2165
2166
2167 DEB(
2168 /* Set the driver options */
2169 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2170 {
2171         if (debugging) {
2172                 printk(KERN_INFO
2173                        "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2174                        name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2175                        STm->do_read_ahead);
2176                 printk(KERN_INFO
2177                        "%s:    can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2178                        name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2179                 printk(KERN_INFO
2180                        "%s:    defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2181                        name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2182                        STp->scsi2_logical);
2183                 printk(KERN_INFO
2184                        "%s:    sysv: %d nowait: %d sili: %d nowait_filemark: %d\n",
2185                        name, STm->sysv, STp->immediate, STp->sili,
2186                        STp->immediate_filemark);
2187                 printk(KERN_INFO "%s:    debugging: %d\n",
2188                        name, debugging);
2189         }
2190 }
2191         )
2192
2193
2194 static int st_set_options(struct scsi_tape *STp, long options)
2195 {
2196         int value;
2197         long code;
2198         struct st_modedef *STm;
2199         char *name = tape_name(STp);
2200         struct cdev *cd0, *cd1;
2201         struct device *d0, *d1;
2202
2203         STm = &(STp->modes[STp->current_mode]);
2204         if (!STm->defined) {
2205                 cd0 = STm->cdevs[0];
2206                 cd1 = STm->cdevs[1];
2207                 d0  = STm->devs[0];
2208                 d1  = STm->devs[1];
2209                 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2210                 STm->cdevs[0] = cd0;
2211                 STm->cdevs[1] = cd1;
2212                 STm->devs[0]  = d0;
2213                 STm->devs[1]  = d1;
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, 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
3740         priority = GFP_KERNEL | __GFP_NOWARN;
3741         if (need_dma)
3742                 priority |= GFP_DMA;
3743
3744         if (STbuffer->cleared)
3745                 priority |= __GFP_ZERO;
3746
3747         if (STbuffer->frp_segs) {
3748                 order = STbuffer->reserved_page_order;
3749                 b_size = PAGE_SIZE << order;
3750         } else {
3751                 for (b_size = PAGE_SIZE, order = 0;
3752                      order < ST_MAX_ORDER &&
3753                              max_segs * (PAGE_SIZE << order) < new_size;
3754                      order++, b_size *= 2)
3755                         ;  /* empty */
3756                 STbuffer->reserved_page_order = order;
3757         }
3758         if (max_segs * (PAGE_SIZE << order) < new_size) {
3759                 if (order == ST_MAX_ORDER)
3760                         return 0;
3761                 normalize_buffer(STbuffer);
3762                 return enlarge_buffer(STbuffer, new_size, need_dma);
3763         }
3764
3765         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3766              segs < max_segs && got < new_size;) {
3767                 struct page *page;
3768
3769                 page = alloc_pages(priority, order);
3770                 if (!page) {
3771                         DEB(STbuffer->buffer_size = got);
3772                         normalize_buffer(STbuffer);
3773                         return 0;
3774                 }
3775
3776                 STbuffer->frp_segs += 1;
3777                 got += b_size;
3778                 STbuffer->buffer_size = got;
3779                 STbuffer->reserved_pages[segs] = page;
3780                 segs++;
3781         }
3782         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3783
3784         return 1;
3785 }
3786
3787
3788 /* Make sure that no data from previous user is in the internal buffer */
3789 static void clear_buffer(struct st_buffer * st_bp)
3790 {
3791         int i;
3792
3793         for (i=0; i < st_bp->frp_segs; i++)
3794                 memset(page_address(st_bp->reserved_pages[i]), 0,
3795                        PAGE_SIZE << st_bp->reserved_page_order);
3796         st_bp->cleared = 1;
3797 }
3798
3799
3800 /* Release the extra buffer */
3801 static void normalize_buffer(struct st_buffer * STbuffer)
3802 {
3803         int i, order = STbuffer->reserved_page_order;
3804
3805         for (i = 0; i < STbuffer->frp_segs; i++) {
3806                 __free_pages(STbuffer->reserved_pages[i], order);
3807                 STbuffer->buffer_size -= (PAGE_SIZE << order);
3808         }
3809         STbuffer->frp_segs = 0;
3810         STbuffer->sg_segs = 0;
3811         STbuffer->reserved_page_order = 0;
3812         STbuffer->map_data.offset = 0;
3813 }
3814
3815
3816 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3817    negative error code. */
3818 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3819 {
3820         int i, cnt, res, offset;
3821         int length = PAGE_SIZE << st_bp->reserved_page_order;
3822
3823         for (i = 0, offset = st_bp->buffer_bytes;
3824              i < st_bp->frp_segs && offset >= length; i++)
3825                 offset -= length;
3826         if (i == st_bp->frp_segs) {     /* Should never happen */
3827                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3828                 return (-EIO);
3829         }
3830         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3831                 struct page *page = st_bp->reserved_pages[i];
3832                 cnt = length - offset < do_count ? length - offset : do_count;
3833                 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3834                 if (res)
3835                         return (-EFAULT);
3836                 do_count -= cnt;
3837                 st_bp->buffer_bytes += cnt;
3838                 ubp += cnt;
3839                 offset = 0;
3840         }
3841         if (do_count) /* Should never happen */
3842                 return (-EIO);
3843
3844         return 0;
3845 }
3846
3847
3848 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3849    negative error code. */
3850 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3851 {
3852         int i, cnt, res, offset;
3853         int length = PAGE_SIZE << st_bp->reserved_page_order;
3854
3855         for (i = 0, offset = st_bp->read_pointer;
3856              i < st_bp->frp_segs && offset >= length; i++)
3857                 offset -= length;
3858         if (i == st_bp->frp_segs) {     /* Should never happen */
3859                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3860                 return (-EIO);
3861         }
3862         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3863                 struct page *page = st_bp->reserved_pages[i];
3864                 cnt = length - offset < do_count ? length - offset : do_count;
3865                 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3866                 if (res)
3867                         return (-EFAULT);
3868                 do_count -= cnt;
3869                 st_bp->buffer_bytes -= cnt;
3870                 st_bp->read_pointer += cnt;
3871                 ubp += cnt;
3872                 offset = 0;
3873         }
3874         if (do_count) /* Should never happen */
3875                 return (-EIO);
3876
3877         return 0;
3878 }
3879
3880
3881 /* Move data towards start of buffer */
3882 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3883 {
3884         int src_seg, dst_seg, src_offset = 0, dst_offset;
3885         int count, total;
3886         int length = PAGE_SIZE << st_bp->reserved_page_order;
3887
3888         if (offset == 0)
3889                 return;
3890
3891         total=st_bp->buffer_bytes - offset;
3892         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3893                 src_offset = offset;
3894                 if (src_offset < length)
3895                         break;
3896                 offset -= length;
3897         }
3898
3899         st_bp->buffer_bytes = st_bp->read_pointer = total;
3900         for (dst_seg=dst_offset=0; total > 0; ) {
3901                 struct page *dpage = st_bp->reserved_pages[dst_seg];
3902                 struct page *spage = st_bp->reserved_pages[src_seg];
3903
3904                 count = min(length - dst_offset, length - src_offset);
3905                 memmove(page_address(dpage) + dst_offset,
3906                         page_address(spage) + src_offset, count);
3907                 src_offset += count;
3908                 if (src_offset >= length) {
3909                         src_seg++;
3910                         src_offset = 0;
3911                 }
3912                 dst_offset += count;
3913                 if (dst_offset >= length) {
3914                         dst_seg++;
3915                         dst_offset = 0;
3916                 }
3917                 total -= count;
3918         }
3919 }
3920
3921 /* Validate the options from command line or module parameters */
3922 static void validate_options(void)
3923 {
3924         if (buffer_kbs > 0)
3925                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3926         if (max_sg_segs >= ST_FIRST_SG)
3927                 st_max_sg_segs = max_sg_segs;
3928 }
3929
3930 #ifndef MODULE
3931 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3932  */
3933 static int __init st_setup(char *str)
3934 {
3935         int i, len, ints[5];
3936         char *stp;
3937
3938         stp = get_options(str, ARRAY_SIZE(ints), ints);
3939
3940         if (ints[0] > 0) {
3941                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3942                         if (parms[i].val)
3943                                 *parms[i].val = ints[i + 1];
3944         } else {
3945                 while (stp != NULL) {
3946                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3947                                 len = strlen(parms[i].name);
3948                                 if (!strncmp(stp, parms[i].name, len) &&
3949                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3950                                         if (parms[i].val)
3951                                                 *parms[i].val =
3952                                                         simple_strtoul(stp + len + 1, NULL, 0);
3953                                         else
3954                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3955                                                        parms[i].name);
3956                                         break;
3957                                 }
3958                         }
3959                         if (i >= ARRAY_SIZE(parms))
3960                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3961                                         stp);
3962                         stp = strchr(stp, ',');
3963                         if (stp)
3964                                 stp++;
3965                 }
3966         }
3967
3968         validate_options();
3969
3970         return 1;
3971 }
3972
3973 __setup("st=", st_setup);
3974
3975 #endif
3976
3977 static const struct file_operations st_fops =
3978 {
3979         .owner =        THIS_MODULE,
3980         .read =         st_read,
3981         .write =        st_write,
3982         .unlocked_ioctl = st_ioctl,
3983 #ifdef CONFIG_COMPAT
3984         .compat_ioctl = st_compat_ioctl,
3985 #endif
3986         .open =         st_open,
3987         .flush =        st_flush,
3988         .release =      st_release,
3989         .llseek =       noop_llseek,
3990 };
3991
3992 static int create_one_cdev(struct scsi_tape *tape, int mode, int rew)
3993 {
3994         int i, error;
3995         dev_t cdev_devno;
3996         struct cdev *cdev;
3997         struct device *dev;
3998         struct st_modedef *STm = &(tape->modes[mode]);
3999         char name[10];
4000         int dev_num = tape->index;
4001
4002         cdev_devno = MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, rew));
4003
4004         cdev = cdev_alloc();
4005         if (!cdev) {
4006                 pr_err("st%d: out of memory. Device not attached.\n", dev_num);
4007                 error = -ENOMEM;
4008                 goto out;
4009         }
4010         cdev->owner = THIS_MODULE;
4011         cdev->ops = &st_fops;
4012
4013         error = cdev_add(cdev, cdev_devno, 1);
4014         if (error) {
4015                 pr_err("st%d: Can't add %s-rewind mode %d\n", dev_num,
4016                        rew ? "non" : "auto", mode);
4017                 pr_err("st%d: Device not attached.\n", dev_num);
4018                 goto out_free;
4019         }
4020         STm->cdevs[rew] = cdev;
4021
4022         i = mode << (4 - ST_NBR_MODE_BITS);
4023         snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4024                  tape->disk->disk_name, st_formats[i]);
4025
4026         dev = device_create(&st_sysfs_class, &tape->device->sdev_gendev,
4027                             cdev_devno, &tape->modes[mode], "%s", name);
4028         if (IS_ERR(dev)) {
4029                 pr_err("st%d: device_create failed\n", dev_num);
4030                 error = PTR_ERR(dev);
4031                 goto out_free;
4032         }
4033
4034         STm->devs[rew] = dev;
4035
4036         return 0;
4037 out_free:
4038         cdev_del(STm->cdevs[rew]);
4039         STm->cdevs[rew] = NULL;
4040 out:
4041         return error;
4042 }
4043
4044 static int create_cdevs(struct scsi_tape *tape)
4045 {
4046         int mode, error;
4047         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4048                 error = create_one_cdev(tape, mode, 0);
4049                 if (error)
4050                         return error;
4051                 error = create_one_cdev(tape, mode, 1);
4052                 if (error)
4053                         return error;
4054         }
4055
4056         return sysfs_create_link(&tape->device->sdev_gendev.kobj,
4057                                  &tape->modes[0].devs[0]->kobj, "tape");
4058 }
4059
4060 static void remove_cdevs(struct scsi_tape *tape)
4061 {
4062         int mode, rew;
4063         sysfs_remove_link(&tape->device->sdev_gendev.kobj, "tape");
4064         for (mode = 0; mode < ST_NBR_MODES; mode++) {
4065                 struct st_modedef *STm = &(tape->modes[mode]);
4066                 for (rew = 0; rew < 2; rew++) {
4067                         if (STm->cdevs[rew])
4068                                 cdev_del(STm->cdevs[rew]);
4069                         if (STm->devs[rew])
4070                                 device_unregister(STm->devs[rew]);
4071                 }
4072         }
4073 }
4074
4075 static int st_probe(struct device *dev)
4076 {
4077         struct scsi_device *SDp = to_scsi_device(dev);
4078         struct gendisk *disk = NULL;
4079         struct scsi_tape *tpnt = NULL;
4080         struct st_modedef *STm;
4081         struct st_partstat *STps;
4082         struct st_buffer *buffer;
4083         int i, error;
4084         char *stp;
4085
4086         if (SDp->type != TYPE_TAPE)
4087                 return -ENODEV;
4088         if ((stp = st_incompatible(SDp))) {
4089                 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4090                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4091                 return -ENODEV;
4092         }
4093
4094         i = queue_max_segments(SDp->request_queue);
4095         if (st_max_sg_segs < i)
4096                 i = st_max_sg_segs;
4097         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4098         if (buffer == NULL) {
4099                 printk(KERN_ERR
4100                        "st: Can't allocate new tape buffer. Device not attached.\n");
4101                 goto out;
4102         }
4103
4104         disk = alloc_disk(1);
4105         if (!disk) {
4106                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4107                 goto out_buffer_free;
4108         }
4109
4110         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4111         if (tpnt == NULL) {
4112                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4113                 goto out_put_disk;
4114         }
4115         kref_init(&tpnt->kref);
4116         tpnt->disk = disk;
4117         disk->private_data = &tpnt->driver;
4118         disk->queue = SDp->request_queue;
4119         /* SCSI tape doesn't register this gendisk via add_disk().  Manually
4120          * take queue reference that release_disk() expects. */
4121         if (!blk_get_queue(disk->queue))
4122                 goto out_put_disk;
4123         tpnt->driver = &st_template;
4124
4125         tpnt->device = SDp;
4126         if (SDp->scsi_level <= 2)
4127                 tpnt->tape_type = MT_ISSCSI1;
4128         else
4129                 tpnt->tape_type = MT_ISSCSI2;
4130
4131         tpnt->buffer = buffer;
4132         tpnt->buffer->last_SRpnt = NULL;
4133
4134         tpnt->inited = 0;
4135         tpnt->dirty = 0;
4136         tpnt->in_use = 0;
4137         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4138         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4139         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4140         tpnt->density = 0;
4141         tpnt->do_auto_lock = ST_AUTO_LOCK;
4142         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4143         tpnt->can_partitions = 0;
4144         tpnt->two_fm = ST_TWO_FM;
4145         tpnt->fast_mteom = ST_FAST_MTEOM;
4146         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4147         tpnt->sili = ST_SILI;
4148         tpnt->immediate = ST_NOWAIT;
4149         tpnt->immediate_filemark = 0;
4150         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
4151         tpnt->partition = 0;
4152         tpnt->new_partition = 0;
4153         tpnt->nbr_partitions = 0;
4154         blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4155         tpnt->long_timeout = ST_LONG_TIMEOUT;
4156         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4157
4158         for (i = 0; i < ST_NBR_MODES; i++) {
4159                 STm = &(tpnt->modes[i]);
4160                 STm->defined = 0;
4161                 STm->sysv = ST_SYSV;
4162                 STm->defaults_for_writes = 0;
4163                 STm->do_async_writes = ST_ASYNC_WRITES;
4164                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4165                 STm->do_read_ahead = ST_READ_AHEAD;
4166                 STm->default_compression = ST_DONT_TOUCH;
4167                 STm->default_blksize = (-1);    /* No forced size */
4168                 STm->default_density = (-1);    /* No forced density */
4169                 STm->tape = tpnt;
4170         }
4171
4172         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4173                 STps = &(tpnt->ps[i]);
4174                 STps->rw = ST_IDLE;
4175                 STps->eof = ST_NOEOF;
4176                 STps->at_sm = 0;
4177                 STps->last_block_valid = 0;
4178                 STps->drv_block = (-1);
4179                 STps->drv_file = (-1);
4180         }
4181
4182         tpnt->current_mode = 0;
4183         tpnt->modes[0].defined = 1;
4184
4185         tpnt->density_changed = tpnt->compression_changed =
4186             tpnt->blksize_changed = 0;
4187         mutex_init(&tpnt->lock);
4188
4189         idr_preload(GFP_KERNEL);
4190         spin_lock(&st_index_lock);
4191         error = idr_alloc(&st_index_idr, tpnt, 0, ST_MAX_TAPES + 1, GFP_NOWAIT);
4192         spin_unlock(&st_index_lock);
4193         idr_preload_end();
4194         if (error < 0) {
4195                 pr_warn("st: idr allocation failed: %d\n", error);
4196                 goto out_put_queue;
4197         }
4198         tpnt->index = error;
4199         sprintf(disk->disk_name, "st%d", tpnt->index);
4200
4201         dev_set_drvdata(dev, tpnt);
4202
4203
4204         error = create_cdevs(tpnt);
4205         if (error)
4206                 goto out_remove_devs;
4207         scsi_autopm_put_device(SDp);
4208
4209         sdev_printk(KERN_NOTICE, SDp,
4210                     "Attached scsi tape %s\n", tape_name(tpnt));
4211         sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4212                     tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4213                     queue_dma_alignment(SDp->request_queue) + 1);
4214
4215         return 0;
4216
4217 out_remove_devs:
4218         remove_cdevs(tpnt);
4219         spin_lock(&st_index_lock);
4220         idr_remove(&st_index_idr, tpnt->index);
4221         spin_unlock(&st_index_lock);
4222 out_put_queue:
4223         blk_put_queue(disk->queue);
4224 out_put_disk:
4225         put_disk(disk);
4226         kfree(tpnt);
4227 out_buffer_free:
4228         kfree(buffer);
4229 out:
4230         return -ENODEV;
4231 };
4232
4233
4234 static int st_remove(struct device *dev)
4235 {
4236         struct scsi_tape *tpnt = dev_get_drvdata(dev);
4237         int index = tpnt->index;
4238
4239         scsi_autopm_get_device(to_scsi_device(dev));
4240         remove_cdevs(tpnt);
4241
4242         mutex_lock(&st_ref_mutex);
4243         kref_put(&tpnt->kref, scsi_tape_release);
4244         mutex_unlock(&st_ref_mutex);
4245         spin_lock(&st_index_lock);
4246         idr_remove(&st_index_idr, index);
4247         spin_unlock(&st_index_lock);
4248         return 0;
4249 }
4250
4251 /**
4252  *      scsi_tape_release - Called to free the Scsi_Tape structure
4253  *      @kref: pointer to embedded kref
4254  *
4255  *      st_ref_mutex must be held entering this routine.  Because it is
4256  *      called on last put, you should always use the scsi_tape_get()
4257  *      scsi_tape_put() helpers which manipulate the semaphore directly
4258  *      and never do a direct kref_put().
4259  **/
4260 static void scsi_tape_release(struct kref *kref)
4261 {
4262         struct scsi_tape *tpnt = to_scsi_tape(kref);
4263         struct gendisk *disk = tpnt->disk;
4264
4265         tpnt->device = NULL;
4266
4267         if (tpnt->buffer) {
4268                 normalize_buffer(tpnt->buffer);
4269                 kfree(tpnt->buffer->reserved_pages);
4270                 kfree(tpnt->buffer);
4271         }
4272
4273         disk->private_data = NULL;
4274         put_disk(disk);
4275         kfree(tpnt);
4276         return;
4277 }
4278
4279 static struct class st_sysfs_class = {
4280         .name = "scsi_tape",
4281         .dev_groups = st_dev_groups,
4282 };
4283
4284 static int __init init_st(void)
4285 {
4286         int err;
4287
4288         validate_options();
4289
4290         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4291                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4292
4293         err = class_register(&st_sysfs_class);
4294         if (err) {
4295                 pr_err("Unable register sysfs class for SCSI tapes\n");
4296                 return err;
4297         }
4298
4299         err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4300                                      ST_MAX_TAPE_ENTRIES, "st");
4301         if (err) {
4302                 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4303                        SCSI_TAPE_MAJOR);
4304                 goto err_class;
4305         }
4306
4307         err = scsi_register_driver(&st_template.gendrv);
4308         if (err)
4309                 goto err_chrdev;
4310
4311         err = do_create_sysfs_files();
4312         if (err)
4313                 goto err_scsidrv;
4314
4315         return 0;
4316
4317 err_scsidrv:
4318         scsi_unregister_driver(&st_template.gendrv);
4319 err_chrdev:
4320         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4321                                  ST_MAX_TAPE_ENTRIES);
4322 err_class:
4323         class_unregister(&st_sysfs_class);
4324         return err;
4325 }
4326
4327 static void __exit exit_st(void)
4328 {
4329         do_remove_sysfs_files();
4330         scsi_unregister_driver(&st_template.gendrv);
4331         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4332                                  ST_MAX_TAPE_ENTRIES);
4333         class_unregister(&st_sysfs_class);
4334         printk(KERN_INFO "st: Unloaded.\n");
4335 }
4336
4337 module_init(init_st);
4338 module_exit(exit_st);
4339
4340
4341 /* The sysfs driver interface. Read-only at the moment */
4342 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4343 {
4344         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4345 }
4346 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4347
4348 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4349 {
4350         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4351 }
4352 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4353
4354 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4355 {
4356         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4357 }
4358 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4359
4360 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4361 {
4362         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4363 }
4364 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4365
4366 static int do_create_sysfs_files(void)
4367 {
4368         struct device_driver *sysfs = &st_template.gendrv;
4369         int err;
4370
4371         err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4372         if (err)
4373                 return err;
4374         err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4375         if (err)
4376                 goto err_try_direct_io;
4377         err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4378         if (err)
4379                 goto err_attr_fixed_buf;
4380         err = driver_create_file(sysfs, &driver_attr_version);
4381         if (err)
4382                 goto err_attr_max_sg;
4383
4384         return 0;
4385
4386 err_attr_max_sg:
4387         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4388 err_attr_fixed_buf:
4389         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4390 err_try_direct_io:
4391         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4392         return err;
4393 }
4394
4395 static void do_remove_sysfs_files(void)
4396 {
4397         struct device_driver *sysfs = &st_template.gendrv;
4398
4399         driver_remove_file(sysfs, &driver_attr_version);
4400         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4401         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4402         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4403 }
4404
4405 /* The sysfs simple class interface */
4406 static ssize_t
4407 defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4408 {
4409         struct st_modedef *STm = dev_get_drvdata(dev);
4410         ssize_t l = 0;
4411
4412         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4413         return l;
4414 }
4415 static DEVICE_ATTR_RO(defined);
4416
4417 static ssize_t
4418 default_blksize_show(struct device *dev, struct device_attribute *attr,
4419                      char *buf)
4420 {
4421         struct st_modedef *STm = dev_get_drvdata(dev);
4422         ssize_t l = 0;
4423
4424         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4425         return l;
4426 }
4427 static DEVICE_ATTR_RO(default_blksize);
4428
4429 static ssize_t
4430 default_density_show(struct device *dev, struct device_attribute *attr,
4431                      char *buf)
4432 {
4433         struct st_modedef *STm = dev_get_drvdata(dev);
4434         ssize_t l = 0;
4435         char *fmt;
4436
4437         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4438         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4439         return l;
4440 }
4441 static DEVICE_ATTR_RO(default_density);
4442
4443 static ssize_t
4444 default_compression_show(struct device *dev, struct device_attribute *attr,
4445                          char *buf)
4446 {
4447         struct st_modedef *STm = dev_get_drvdata(dev);
4448         ssize_t l = 0;
4449
4450         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4451         return l;
4452 }
4453 static DEVICE_ATTR_RO(default_compression);
4454
4455 static ssize_t
4456 options_show(struct device *dev, struct device_attribute *attr, char *buf)
4457 {
4458         struct st_modedef *STm = dev_get_drvdata(dev);
4459         struct scsi_tape *STp = STm->tape;
4460         int options;
4461         ssize_t l = 0;
4462
4463         options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4464         options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4465         options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4466         DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4467         options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4468         options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4469         options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4470         options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4471         options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4472         options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4473         options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4474         options |= STm->sysv ? MT_ST_SYSV : 0;
4475         options |= STp->immediate ? MT_ST_NOWAIT : 0;
4476         options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4477         options |= STp->sili ? MT_ST_SILI : 0;
4478
4479         l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4480         return l;
4481 }
4482 static DEVICE_ATTR_RO(options);
4483
4484 static struct attribute *st_dev_attrs[] = {
4485         &dev_attr_defined.attr,
4486         &dev_attr_default_blksize.attr,
4487         &dev_attr_default_density.attr,
4488         &dev_attr_default_compression.attr,
4489         &dev_attr_options.attr,
4490         NULL,
4491 };
4492 ATTRIBUTE_GROUPS(st_dev);
4493
4494 /* The following functions may be useful for a larger audience. */
4495 static int sgl_map_user_pages(struct st_buffer *STbp,
4496                               const unsigned int max_pages, unsigned long uaddr,
4497                               size_t count, int rw)
4498 {
4499         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4500         unsigned long start = uaddr >> PAGE_SHIFT;
4501         const int nr_pages = end - start;
4502         int res, i, j;
4503         struct page **pages;
4504         struct rq_map_data *mdata = &STbp->map_data;
4505
4506         /* User attempted Overflow! */
4507         if ((uaddr + count) < uaddr)
4508                 return -EINVAL;
4509
4510         /* Too big */
4511         if (nr_pages > max_pages)
4512                 return -ENOMEM;
4513
4514         /* Hmm? */
4515         if (count == 0)
4516                 return 0;
4517
4518         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4519                 return -ENOMEM;
4520
4521         /* Try to fault in all of the necessary pages */
4522         down_read(&current->mm->mmap_sem);
4523         /* rw==READ means read from drive, write into memory area */
4524         res = get_user_pages(
4525                 current,
4526                 current->mm,
4527                 uaddr,
4528                 nr_pages,
4529                 rw == READ,
4530                 0, /* don't force */
4531                 pages,
4532                 NULL);
4533         up_read(&current->mm->mmap_sem);
4534
4535         /* Errors and no page mapped should return here */
4536         if (res < nr_pages)
4537                 goto out_unmap;
4538
4539         for (i=0; i < nr_pages; i++) {
4540                 /* FIXME: flush superflous for rw==READ,
4541                  * probably wrong function for rw==WRITE
4542                  */
4543                 flush_dcache_page(pages[i]);
4544         }
4545
4546         mdata->offset = uaddr & ~PAGE_MASK;
4547         STbp->mapped_pages = pages;
4548
4549         return nr_pages;
4550  out_unmap:
4551         if (res > 0) {
4552                 for (j=0; j < res; j++)
4553                         page_cache_release(pages[j]);
4554                 res = 0;
4555         }
4556         kfree(pages);
4557         return res;
4558 }
4559
4560
4561 /* And unmap them... */
4562 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4563                                 const unsigned int nr_pages, int dirtied)
4564 {
4565         int i;
4566
4567         for (i=0; i < nr_pages; i++) {
4568                 struct page *page = STbp->mapped_pages[i];
4569
4570                 if (dirtied)
4571                         SetPageDirty(page);
4572                 /* FIXME: cache flush missing for rw==READ
4573                  * FIXME: call the correct reference counting function
4574                  */
4575                 page_cache_release(page);
4576         }
4577         kfree(STbp->mapped_pages);
4578         STbp->mapped_pages = NULL;
4579
4580         return 0;
4581 }