drivers/scsi/st.c

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