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