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 ||
2284                                 value >= SCSI_SENSE_BUFFERSIZE))
2285                         return (-EINVAL);
2286                 STp->cln_mode = value;
2287                 STp->cln_sense_mask = (options >> 8) & 0xff;
2288                 STp->cln_sense_value = (options >> 16) & 0xff;
2289                 printk(KERN_INFO
2290                        "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2291                        name, value, STp->cln_sense_mask, STp->cln_sense_value);
2292         } else if (code == MT_ST_DEF_OPTIONS) {
2293                 code = (options & ~MT_ST_CLEAR_DEFAULT);
2294                 value = (options & MT_ST_CLEAR_DEFAULT);
2295                 if (code == MT_ST_DEF_DENSITY) {
2296                         if (value == MT_ST_CLEAR_DEFAULT) {
2297                                 STm->default_density = (-1);
2298                                 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2299                                        name));
2300                         } else {
2301                                 STm->default_density = value & 0xff;
2302                                 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2303                                        name, STm->default_density));
2304                                 if (STp->ready == ST_READY) {
2305                                         STp->density_changed = 0;
2306                                         set_mode_densblk(STp, STm);
2307                                 }
2308                         }
2309                 } else if (code == MT_ST_DEF_DRVBUFFER) {
2310                         if (value == MT_ST_CLEAR_DEFAULT) {
2311                                 STp->default_drvbuffer = 0xff;
2312                                 DEBC( printk(KERN_INFO
2313                                        "%s: Drive buffer default disabled.\n", name));
2314                         } else {
2315                                 STp->default_drvbuffer = value & 7;
2316                                 DEBC( printk(KERN_INFO
2317                                        "%s: Drive buffer default set to %x\n",
2318                                        name, STp->default_drvbuffer));
2319                                 if (STp->ready == ST_READY)
2320                                         st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2321                         }
2322                 } else if (code == MT_ST_DEF_COMPRESSION) {
2323                         if (value == MT_ST_CLEAR_DEFAULT) {
2324                                 STm->default_compression = ST_DONT_TOUCH;
2325                                 DEBC( printk(KERN_INFO
2326                                        "%s: Compression default disabled.\n", name));
2327                         } else {
2328                                 if ((value & 0xff00) != 0) {
2329                                         STp->c_algo = (value & 0xff00) >> 8;
2330                                         DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2331                                                name, STp->c_algo));
2332                                 }
2333                                 if ((value & 0xff) != 0xff) {
2334                                         STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2335                                         DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2336                                                name, (value & 1)));
2337                                         if (STp->ready == ST_READY) {
2338                                                 STp->compression_changed = 0;
2339                                                 st_compression(STp, (STm->default_compression == ST_YES));
2340                                         }
2341                                 }
2342                         }
2343                 }
2344         } else
2345                 return (-EIO);
2346
2347         return 0;
2348 }
2349 \f
2350 #define MODE_HEADER_LENGTH  4
2351
2352 /* Mode header and page byte offsets */
2353 #define MH_OFF_DATA_LENGTH     0
2354 #define MH_OFF_MEDIUM_TYPE     1
2355 #define MH_OFF_DEV_SPECIFIC    2
2356 #define MH_OFF_BDESCS_LENGTH   3
2357 #define MP_OFF_PAGE_NBR        0
2358 #define MP_OFF_PAGE_LENGTH     1
2359
2360 /* Mode header and page bit masks */
2361 #define MH_BIT_WP              0x80
2362 #define MP_MSK_PAGE_NBR        0x3f
2363
2364 /* Don't return block descriptors */
2365 #define MODE_SENSE_OMIT_BDESCS 0x08
2366
2367 #define MODE_SELECT_PAGE_FORMAT 0x10
2368
2369 /* Read a mode page into the tape buffer. The block descriptors are included
2370    if incl_block_descs is true. The page control is ored to the page number
2371    parameter, if necessary. */
2372 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2373 {
2374         unsigned char cmd[MAX_COMMAND_SIZE];
2375         struct st_request *SRpnt;
2376
2377         memset(cmd, 0, MAX_COMMAND_SIZE);
2378         cmd[0] = MODE_SENSE;
2379         if (omit_block_descs)
2380                 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2381         cmd[2] = page;
2382         cmd[4] = 255;
2383
2384         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2385                            STp->device->request_queue->rq_timeout, 0, 1);
2386         if (SRpnt == NULL)
2387                 return (STp->buffer)->syscall_result;
2388
2389         st_release_request(SRpnt);
2390
2391         return STp->buffer->syscall_result;
2392 }
2393
2394
2395 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2396    in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2397 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2398 {
2399         int pgo;
2400         unsigned char cmd[MAX_COMMAND_SIZE];
2401         struct st_request *SRpnt;
2402         int timeout;
2403
2404         memset(cmd, 0, MAX_COMMAND_SIZE);
2405         cmd[0] = MODE_SELECT;
2406         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2407         pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2408         cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2409
2410         /* Clear reserved fields */
2411         (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2412         (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2413         (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2414         (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2415
2416         timeout = slow ?
2417                 STp->long_timeout : STp->device->request_queue->rq_timeout;
2418         SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2419                            timeout, 0, 1);
2420         if (SRpnt == NULL)
2421                 return (STp->buffer)->syscall_result;
2422
2423         st_release_request(SRpnt);
2424
2425         return STp->buffer->syscall_result;
2426 }
2427
2428
2429 #define COMPRESSION_PAGE        0x0f
2430 #define COMPRESSION_PAGE_LENGTH 16
2431
2432 #define CP_OFF_DCE_DCC          2
2433 #define CP_OFF_C_ALGO           7
2434
2435 #define DCE_MASK  0x80
2436 #define DCC_MASK  0x40
2437 #define RED_MASK  0x60
2438
2439
2440 /* Control the compression with mode page 15. Algorithm not changed if zero.
2441
2442    The block descriptors are read and written because Sony SDT-7000 does not
2443    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2444    Including block descriptors should not cause any harm to other drives. */
2445
2446 static int st_compression(struct scsi_tape * STp, int state)
2447 {
2448         int retval;
2449         int mpoffs;  /* Offset to mode page start */
2450         unsigned char *b_data = (STp->buffer)->b_data;
2451         DEB( char *name = tape_name(STp); )
2452
2453         if (STp->ready != ST_READY)
2454                 return (-EIO);
2455
2456         /* Read the current page contents */
2457         retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2458         if (retval) {
2459                 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2460                             name));
2461                 return (-EIO);
2462         }
2463
2464         mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2465         DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2466                     (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2467
2468         /* Check if compression can be changed */
2469         if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2470                 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2471                 return (-EIO);
2472         }
2473
2474         /* Do the change */
2475         if (state) {
2476                 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2477                 if (STp->c_algo != 0)
2478                         b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2479         }
2480         else {
2481                 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2482                 if (STp->c_algo != 0)
2483                         b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2484         }
2485
2486         retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2487         if (retval) {
2488                 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2489                 return (-EIO);
2490         }
2491         DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2492                        name, state));
2493
2494         STp->compression_changed = 1;
2495         return 0;
2496 }
2497
2498
2499 /* Process the load and unload commands (does unload if the load code is zero) */
2500 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2501 {
2502         int retval = (-EIO), timeout;
2503         DEB( char *name = tape_name(STp); )
2504         unsigned char cmd[MAX_COMMAND_SIZE];
2505         struct st_partstat *STps;
2506         struct st_request *SRpnt;
2507
2508         if (STp->ready != ST_READY && !load_code) {
2509                 if (STp->ready == ST_NO_TAPE)
2510                         return (-ENOMEDIUM);
2511                 else
2512                         return (-EIO);
2513         }
2514
2515         memset(cmd, 0, MAX_COMMAND_SIZE);
2516         cmd[0] = START_STOP;
2517         if (load_code)
2518                 cmd[4] |= 1;
2519         /*
2520          * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2521          */
2522         if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2523             && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2524                 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2525                             name, (cmd[4]) ? "" : "un",
2526                             load_code - MT_ST_HPLOADER_OFFSET));
2527                 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2528         }
2529         if (STp->immediate) {
2530                 cmd[1] = 1;     /* Don't wait for completion */
2531                 timeout = STp->device->request_queue->rq_timeout;
2532         }
2533         else
2534                 timeout = STp->long_timeout;
2535
2536         DEBC(
2537                 if (!load_code)
2538                 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2539                 else
2540                 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2541                 );
2542
2543         SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2544                            timeout, MAX_RETRIES, 1);
2545         if (!SRpnt)
2546                 return (STp->buffer)->syscall_result;
2547
2548         retval = (STp->buffer)->syscall_result;
2549         st_release_request(SRpnt);
2550
2551         if (!retval) {  /* SCSI command successful */
2552
2553                 if (!load_code) {
2554                         STp->rew_at_close = 0;
2555                         STp->ready = ST_NO_TAPE;
2556                 }
2557                 else {
2558                         STp->rew_at_close = STp->autorew_dev;
2559                         retval = check_tape(STp, filp);
2560                         if (retval > 0)
2561                                 retval = 0;
2562                 }
2563         }
2564         else {
2565                 STps = &(STp->ps[STp->partition]);
2566                 STps->drv_file = STps->drv_block = (-1);
2567         }
2568
2569         return retval;
2570 }
2571 \f
2572 #if DEBUG
2573 #define ST_DEB_FORWARD  0
2574 #define ST_DEB_BACKWARD 1
2575 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2576 {
2577         s32 sc;
2578
2579         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2580         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2581         if (direction)
2582                 sc = -sc;
2583         printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2584                direction ? "backward" : "forward", sc, units);
2585 }
2586 #endif
2587
2588
2589 /* Internal ioctl function */
2590 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2591 {
2592         int timeout;
2593         long ltmp;
2594         int ioctl_result;
2595         int chg_eof = 1;
2596         unsigned char cmd[MAX_COMMAND_SIZE];
2597         struct st_request *SRpnt;
2598         struct st_partstat *STps;
2599         int fileno, blkno, at_sm, undone;
2600         int datalen = 0, direction = DMA_NONE;
2601         char *name = tape_name(STp);
2602
2603         WARN_ON(STp->buffer->do_dio != 0);
2604         if (STp->ready != ST_READY) {
2605                 if (STp->ready == ST_NO_TAPE)
2606                         return (-ENOMEDIUM);
2607                 else
2608                         return (-EIO);
2609         }
2610         timeout = STp->long_timeout;
2611         STps = &(STp->ps[STp->partition]);
2612         fileno = STps->drv_file;
2613         blkno = STps->drv_block;
2614         at_sm = STps->at_sm;
2615
2616         memset(cmd, 0, MAX_COMMAND_SIZE);
2617         switch (cmd_in) {
2618         case MTFSFM:
2619                 chg_eof = 0;    /* Changed from the FSF after this */
2620         case MTFSF:
2621                 cmd[0] = SPACE;
2622                 cmd[1] = 0x01;  /* Space FileMarks */
2623                 cmd[2] = (arg >> 16);
2624                 cmd[3] = (arg >> 8);
2625                 cmd[4] = arg;
2626                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2627                 if (fileno >= 0)
2628                         fileno += arg;
2629                 blkno = 0;
2630                 at_sm &= (arg == 0);
2631                 break;
2632         case MTBSFM:
2633                 chg_eof = 0;    /* Changed from the FSF after this */
2634         case MTBSF:
2635                 cmd[0] = SPACE;
2636                 cmd[1] = 0x01;  /* Space FileMarks */
2637                 ltmp = (-arg);
2638                 cmd[2] = (ltmp >> 16);
2639                 cmd[3] = (ltmp >> 8);
2640                 cmd[4] = ltmp;
2641                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2642                 if (fileno >= 0)
2643                         fileno -= arg;
2644                 blkno = (-1);   /* We can't know the block number */
2645                 at_sm &= (arg == 0);
2646                 break;
2647         case MTFSR:
2648                 cmd[0] = SPACE;
2649                 cmd[1] = 0x00;  /* Space Blocks */
2650                 cmd[2] = (arg >> 16);
2651                 cmd[3] = (arg >> 8);
2652                 cmd[4] = arg;
2653                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2654                 if (blkno >= 0)
2655                         blkno += arg;
2656                 at_sm &= (arg == 0);
2657                 break;
2658         case MTBSR:
2659                 cmd[0] = SPACE;
2660                 cmd[1] = 0x00;  /* Space Blocks */
2661                 ltmp = (-arg);
2662                 cmd[2] = (ltmp >> 16);
2663                 cmd[3] = (ltmp >> 8);
2664                 cmd[4] = ltmp;
2665                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2666                 if (blkno >= 0)
2667                         blkno -= arg;
2668                 at_sm &= (arg == 0);
2669                 break;
2670         case MTFSS:
2671                 cmd[0] = SPACE;
2672                 cmd[1] = 0x04;  /* Space Setmarks */
2673                 cmd[2] = (arg >> 16);
2674                 cmd[3] = (arg >> 8);
2675                 cmd[4] = arg;
2676                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2677                 if (arg != 0) {
2678                         blkno = fileno = (-1);
2679                         at_sm = 1;
2680                 }
2681                 break;
2682         case MTBSS:
2683                 cmd[0] = SPACE;
2684                 cmd[1] = 0x04;  /* Space Setmarks */
2685                 ltmp = (-arg);
2686                 cmd[2] = (ltmp >> 16);
2687                 cmd[3] = (ltmp >> 8);
2688                 cmd[4] = ltmp;
2689                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2690                 if (arg != 0) {
2691                         blkno = fileno = (-1);
2692                         at_sm = 1;
2693                 }
2694                 break;
2695         case MTWEOF:
2696         case MTWSM:
2697                 if (STp->write_prot)
2698                         return (-EACCES);
2699                 cmd[0] = WRITE_FILEMARKS;
2700                 if (cmd_in == MTWSM)
2701                         cmd[1] = 2;
2702                 cmd[2] = (arg >> 16);
2703                 cmd[3] = (arg >> 8);
2704                 cmd[4] = arg;
2705                 timeout = STp->device->request_queue->rq_timeout;
2706                 DEBC(
2707                      if (cmd_in == MTWEOF)
2708                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2709                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2710                      else
2711                                 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2712                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2713                 )
2714                 if (fileno >= 0)
2715                         fileno += arg;
2716                 blkno = 0;
2717                 at_sm = (cmd_in == MTWSM);
2718                 break;
2719         case MTREW:
2720                 cmd[0] = REZERO_UNIT;
2721                 if (STp->immediate) {
2722                         cmd[1] = 1;     /* Don't wait for completion */
2723                         timeout = STp->device->request_queue->rq_timeout;
2724                 }
2725                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2726                 fileno = blkno = at_sm = 0;
2727                 break;
2728         case MTNOP:
2729                 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2730                 return 0;       /* Should do something ? */
2731                 break;
2732         case MTRETEN:
2733                 cmd[0] = START_STOP;
2734                 if (STp->immediate) {
2735                         cmd[1] = 1;     /* Don't wait for completion */
2736                         timeout = STp->device->request_queue->rq_timeout;
2737                 }
2738                 cmd[4] = 3;
2739                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2740                 fileno = blkno = at_sm = 0;
2741                 break;
2742         case MTEOM:
2743                 if (!STp->fast_mteom) {
2744                         /* space to the end of tape */
2745                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2746                         fileno = STps->drv_file;
2747                         if (STps->eof >= ST_EOD_1)
2748                                 return 0;
2749                         /* The next lines would hide the number of spaced FileMarks
2750                            That's why I inserted the previous lines. I had no luck
2751                            with detecting EOM with FSF, so we go now to EOM.
2752                            Joerg Weule */
2753                 } else
2754                         fileno = (-1);
2755                 cmd[0] = SPACE;
2756                 cmd[1] = 3;
2757                 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2758                             name));
2759                 blkno = -1;
2760                 at_sm = 0;
2761                 break;
2762         case MTERASE:
2763                 if (STp->write_prot)
2764                         return (-EACCES);
2765                 cmd[0] = ERASE;
2766                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2767                 if (STp->immediate) {
2768                         cmd[1] |= 2;    /* Don't wait for completion */
2769                         timeout = STp->device->request_queue->rq_timeout;
2770                 }
2771                 else
2772                         timeout = STp->long_timeout * 8;
2773
2774                 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2775                 fileno = blkno = at_sm = 0;
2776                 break;
2777         case MTSETBLK:          /* Set block length */
2778         case MTSETDENSITY:      /* Set tape density */
2779         case MTSETDRVBUFFER:    /* Set drive buffering */
2780         case SET_DENS_AND_BLK:  /* Set density and block size */
2781                 chg_eof = 0;
2782                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2783                         return (-EIO);  /* Not allowed if data in buffer */
2784                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2785                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2786                     STp->max_block > 0 &&
2787                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2788                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2789                         printk(KERN_WARNING "%s: Illegal block size.\n", name);
2790                         return (-EINVAL);
2791                 }
2792                 cmd[0] = MODE_SELECT;
2793                 if ((STp->use_pf & USE_PF))
2794                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2795                 cmd[4] = datalen = 12;
2796                 direction = DMA_TO_DEVICE;
2797
2798                 memset((STp->buffer)->b_data, 0, 12);
2799                 if (cmd_in == MTSETDRVBUFFER)
2800                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2801                 else
2802                         (STp->buffer)->b_data[2] =
2803                             STp->drv_buffer << 4;
2804                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2805                 if (cmd_in == MTSETDENSITY) {
2806                         (STp->buffer)->b_data[4] = arg;
2807                         STp->density_changed = 1;       /* At least we tried ;-) */
2808                 } else if (cmd_in == SET_DENS_AND_BLK)
2809                         (STp->buffer)->b_data[4] = arg >> 24;
2810                 else
2811                         (STp->buffer)->b_data[4] = STp->density;
2812                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2813                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2814                         if (cmd_in == MTSETBLK)
2815                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2816                 } else
2817                         ltmp = STp->block_size;
2818                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2819                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2820                 (STp->buffer)->b_data[11] = ltmp;
2821                 timeout = STp->device->request_queue->rq_timeout;
2822                 DEBC(
2823                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2824                                 printk(ST_DEB_MSG
2825                                        "%s: Setting block size to %d bytes.\n", name,
2826                                        (STp->buffer)->b_data[9] * 65536 +
2827                                        (STp->buffer)->b_data[10] * 256 +
2828                                        (STp->buffer)->b_data[11]);
2829                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2830                                 printk(ST_DEB_MSG
2831                                        "%s: Setting density code to %x.\n", name,
2832                                        (STp->buffer)->b_data[4]);
2833                         if (cmd_in == MTSETDRVBUFFER)
2834                                 printk(ST_DEB_MSG
2835                                        "%s: Setting drive buffer code to %d.\n", name,
2836                                     ((STp->buffer)->b_data[2] >> 4) & 7);
2837                 )
2838                 break;
2839         default:
2840                 return (-ENOSYS);
2841         }
2842
2843         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2844                            timeout, MAX_RETRIES, 1);
2845         if (!SRpnt)
2846                 return (STp->buffer)->syscall_result;
2847
2848         ioctl_result = (STp->buffer)->syscall_result;
2849
2850         if (!ioctl_result) {    /* SCSI command successful */
2851                 st_release_request(SRpnt);
2852                 SRpnt = NULL;
2853                 STps->drv_block = blkno;
2854                 STps->drv_file = fileno;
2855                 STps->at_sm = at_sm;
2856
2857                 if (cmd_in == MTBSFM)
2858                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2859                 else if (cmd_in == MTFSFM)
2860                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2861
2862                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2863                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2864                         if (STp->block_size != 0) {
2865                                 (STp->buffer)->buffer_blocks =
2866                                     (STp->buffer)->buffer_size / STp->block_size;
2867                         }
2868                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2869                         if (cmd_in == SET_DENS_AND_BLK)
2870                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2871                 } else if (cmd_in == MTSETDRVBUFFER)
2872                         STp->drv_buffer = (arg & 7);
2873                 else if (cmd_in == MTSETDENSITY)
2874                         STp->density = arg;
2875
2876                 if (cmd_in == MTEOM)
2877                         STps->eof = ST_EOD;
2878                 else if (cmd_in == MTFSF)
2879                         STps->eof = ST_FM;
2880                 else if (chg_eof)
2881                         STps->eof = ST_NOEOF;
2882
2883                 if (cmd_in == MTWEOF)
2884                         STps->rw = ST_IDLE;
2885         } else { /* SCSI command was not completely successful. Don't return
2886                     from this block without releasing the SCSI command block! */
2887                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2888
2889                 if (cmdstatp->flags & SENSE_EOM) {
2890                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2891                             cmd_in != MTBSR && cmd_in != MTBSS)
2892                                 STps->eof = ST_EOM_OK;
2893                         STps->drv_block = 0;
2894                 }
2895
2896                 if (cmdstatp->remainder_valid)
2897                         undone = (int)cmdstatp->uremainder64;
2898                 else
2899                         undone = 0;
2900
2901                 if (cmd_in == MTWEOF &&
2902                     cmdstatp->have_sense &&
2903                     (cmdstatp->flags & SENSE_EOM)) {
2904                         if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2905                             cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2906                                 ioctl_result = 0;       /* EOF(s) written successfully at EOM */
2907                                 STps->eof = ST_NOEOF;
2908                         } else {  /* Writing EOF(s) failed */
2909                                 if (fileno >= 0)
2910                                         fileno -= undone;
2911                                 if (undone < arg)
2912                                         STps->eof = ST_NOEOF;
2913                         }
2914                         STps->drv_file = fileno;
2915                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2916                         if (fileno >= 0)
2917                                 STps->drv_file = fileno - undone;
2918                         else
2919                                 STps->drv_file = fileno;
2920                         STps->drv_block = -1;
2921                         STps->eof = ST_NOEOF;
2922                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2923                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2924                                 undone = (-undone);
2925                         if (STps->drv_file >= 0)
2926                                 STps->drv_file = fileno + undone;
2927                         STps->drv_block = 0;
2928                         STps->eof = ST_NOEOF;
2929                 } else if (cmd_in == MTFSR) {
2930                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2931                                 if (STps->drv_file >= 0)
2932                                         STps->drv_file++;
2933                                 STps->drv_block = 0;
2934                                 STps->eof = ST_FM;
2935                         } else {
2936                                 if (blkno >= undone)
2937                                         STps->drv_block = blkno - undone;
2938                                 else
2939                                         STps->drv_block = (-1);
2940                                 STps->eof = ST_NOEOF;
2941                         }
2942                 } else if (cmd_in == MTBSR) {
2943                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2944                                 STps->drv_file--;
2945                                 STps->drv_block = (-1);
2946                         } else {
2947                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2948                                         undone = (-undone);
2949                                 if (STps->drv_block >= 0)
2950                                         STps->drv_block = blkno + undone;
2951                         }
2952                         STps->eof = ST_NOEOF;
2953                 } else if (cmd_in == MTEOM) {
2954                         STps->drv_file = (-1);
2955                         STps->drv_block = (-1);
2956                         STps->eof = ST_EOD;
2957                 } else if (cmd_in == MTSETBLK ||
2958                            cmd_in == MTSETDENSITY ||
2959                            cmd_in == MTSETDRVBUFFER ||
2960                            cmd_in == SET_DENS_AND_BLK) {
2961                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2962                             !(STp->use_pf & PF_TESTED)) {
2963                                 /* Try the other possible state of Page Format if not
2964                                    already tried */
2965                                 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2966                                 st_release_request(SRpnt);
2967                                 SRpnt = NULL;
2968                                 return st_int_ioctl(STp, cmd_in, arg);
2969                         }
2970                 } else if (chg_eof)
2971                         STps->eof = ST_NOEOF;
2972
2973                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2974                         STps->eof = ST_EOD;
2975
2976                 st_release_request(SRpnt);
2977                 SRpnt = NULL;
2978         }
2979
2980         return ioctl_result;
2981 }
2982 \f
2983
2984 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2985    structure. */
2986
2987 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2988                         int logical)
2989 {
2990         int result;
2991         unsigned char scmd[MAX_COMMAND_SIZE];
2992         struct st_request *SRpnt;
2993         DEB( char *name = tape_name(STp); )
2994
2995         if (STp->ready != ST_READY)
2996                 return (-EIO);
2997
2998         memset(scmd, 0, MAX_COMMAND_SIZE);
2999         if ((STp->device)->scsi_level < SCSI_2) {
3000                 scmd[0] = QFA_REQUEST_BLOCK;
3001                 scmd[4] = 3;
3002         } else {
3003                 scmd[0] = READ_POSITION;
3004                 if (!logical && !STp->scsi2_logical)
3005                         scmd[1] = 1;
3006         }
3007         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3008                            STp->device->request_queue->rq_timeout,
3009                            MAX_READY_RETRIES, 1);
3010         if (!SRpnt)
3011                 return (STp->buffer)->syscall_result;
3012
3013         if ((STp->buffer)->syscall_result != 0 ||
3014             (STp->device->scsi_level >= SCSI_2 &&
3015              ((STp->buffer)->b_data[0] & 4) != 0)) {
3016                 *block = *partition = 0;
3017                 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3018                 result = (-EIO);
3019         } else {
3020                 result = 0;
3021                 if ((STp->device)->scsi_level < SCSI_2) {
3022                         *block = ((STp->buffer)->b_data[0] << 16)
3023                             + ((STp->buffer)->b_data[1] << 8)
3024                             + (STp->buffer)->b_data[2];
3025                         *partition = 0;
3026                 } else {
3027                         *block = ((STp->buffer)->b_data[4] << 24)
3028                             + ((STp->buffer)->b_data[5] << 16)
3029                             + ((STp->buffer)->b_data[6] << 8)
3030                             + (STp->buffer)->b_data[7];
3031                         *partition = (STp->buffer)->b_data[1];
3032                         if (((STp->buffer)->b_data[0] & 0x80) &&
3033                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
3034                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3035                 }
3036                 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3037                             *block, *partition));
3038         }
3039         st_release_request(SRpnt);
3040         SRpnt = NULL;
3041
3042         return result;
3043 }
3044
3045
3046 /* Set the tape block and partition. Negative partition means that only the
3047    block should be set in vendor specific way. */
3048 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3049                         int logical)
3050 {
3051         struct st_partstat *STps;
3052         int result, p;
3053         unsigned int blk;
3054         int timeout;
3055         unsigned char scmd[MAX_COMMAND_SIZE];
3056         struct st_request *SRpnt;
3057         DEB( char *name = tape_name(STp); )
3058
3059         if (STp->ready != ST_READY)
3060                 return (-EIO);
3061         timeout = STp->long_timeout;
3062         STps = &(STp->ps[STp->partition]);
3063
3064         DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3065                     name, block, partition));
3066         DEB(if (partition < 0)
3067                 return (-EIO); )
3068
3069         /* Update the location at the partition we are leaving */
3070         if ((!STp->can_partitions && partition != 0) ||
3071             partition >= ST_NBR_PARTITIONS)
3072                 return (-EINVAL);
3073         if (partition != STp->partition) {
3074                 if (get_location(STp, &blk, &p, 1))
3075                         STps->last_block_valid = 0;
3076                 else {
3077                         STps->last_block_valid = 1;
3078                         STps->last_block_visited = blk;
3079                         DEBC(printk(ST_DEB_MSG
3080                                     "%s: Visited block %d for partition %d saved.\n",
3081                                     name, blk, STp->partition));
3082                 }
3083         }
3084
3085         memset(scmd, 0, MAX_COMMAND_SIZE);
3086         if ((STp->device)->scsi_level < SCSI_2) {
3087                 scmd[0] = QFA_SEEK_BLOCK;
3088                 scmd[2] = (block >> 16);
3089                 scmd[3] = (block >> 8);
3090                 scmd[4] = block;
3091                 scmd[5] = 0;
3092         } else {
3093                 scmd[0] = SEEK_10;
3094                 scmd[3] = (block >> 24);
3095                 scmd[4] = (block >> 16);
3096                 scmd[5] = (block >> 8);
3097                 scmd[6] = block;
3098                 if (!logical && !STp->scsi2_logical)
3099                         scmd[1] = 4;
3100                 if (STp->partition != partition) {
3101                         scmd[1] |= 2;
3102                         scmd[8] = partition;
3103                         DEBC(printk(ST_DEB_MSG
3104                                     "%s: Trying to change partition from %d to %d\n",
3105                                     name, STp->partition, partition));
3106                 }
3107         }
3108         if (STp->immediate) {
3109                 scmd[1] |= 1;           /* Don't wait for completion */
3110                 timeout = STp->device->request_queue->rq_timeout;
3111         }
3112
3113         SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3114                            timeout, MAX_READY_RETRIES, 1);
3115         if (!SRpnt)
3116                 return (STp->buffer)->syscall_result;
3117
3118         STps->drv_block = STps->drv_file = (-1);
3119         STps->eof = ST_NOEOF;
3120         if ((STp->buffer)->syscall_result != 0) {
3121                 result = (-EIO);
3122                 if (STp->can_partitions &&
3123                     (STp->device)->scsi_level >= SCSI_2 &&
3124                     (p = find_partition(STp)) >= 0)
3125                         STp->partition = p;
3126         } else {
3127                 if (STp->can_partitions) {
3128                         STp->partition = partition;
3129                         STps = &(STp->ps[partition]);
3130                         if (!STps->last_block_valid ||
3131                             STps->last_block_visited != block) {
3132                                 STps->at_sm = 0;
3133                                 STps->rw = ST_IDLE;
3134                         }
3135                 } else
3136                         STps->at_sm = 0;
3137                 if (block == 0)
3138                         STps->drv_block = STps->drv_file = 0;
3139                 result = 0;
3140         }
3141
3142         st_release_request(SRpnt);
3143         SRpnt = NULL;
3144
3145         return result;
3146 }
3147
3148
3149 /* Find the current partition number for the drive status. Called from open and
3150    returns either partition number of negative error code. */
3151 static int find_partition(struct scsi_tape *STp)
3152 {
3153         int i, partition;
3154         unsigned int block;
3155
3156         if ((i = get_location(STp, &block, &partition, 1)) < 0)
3157                 return i;
3158         if (partition >= ST_NBR_PARTITIONS)
3159                 return (-EIO);
3160         return partition;
3161 }
3162
3163
3164 /* Change the partition if necessary */
3165 static int switch_partition(struct scsi_tape *STp)
3166 {
3167         struct st_partstat *STps;
3168
3169         if (STp->partition == STp->new_partition)
3170                 return 0;
3171         STps = &(STp->ps[STp->new_partition]);
3172         if (!STps->last_block_valid)
3173                 STps->last_block_visited = 0;
3174         return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3175 }
3176 \f
3177 /* Functions for reading and writing the medium partition mode page. */
3178
3179 #define PART_PAGE   0x11
3180 #define PART_PAGE_FIXED_LENGTH 8
3181
3182 #define PP_OFF_MAX_ADD_PARTS   2
3183 #define PP_OFF_NBR_ADD_PARTS   3
3184 #define PP_OFF_FLAGS           4
3185 #define PP_OFF_PART_UNITS      6
3186 #define PP_OFF_RESERVED        7
3187
3188 #define PP_BIT_IDP             0x20
3189 #define PP_MSK_PSUM_MB         0x10
3190
3191 /* Get the number of partitions on the tape. As a side effect reads the
3192    mode page into the tape buffer. */
3193 static int nbr_partitions(struct scsi_tape *STp)
3194 {
3195         int result;
3196         DEB( char *name = tape_name(STp); )
3197
3198         if (STp->ready != ST_READY)
3199                 return (-EIO);
3200
3201         result = read_mode_page(STp, PART_PAGE, 1);
3202
3203         if (result) {
3204                 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3205                             name));
3206                 result = (-EIO);
3207         } else {
3208                 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3209                                               PP_OFF_NBR_ADD_PARTS] + 1;
3210                 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3211         }
3212
3213         return result;
3214 }
3215
3216
3217 /* Partition the tape into two partitions if size > 0 or one partition if
3218    size == 0.
3219
3220    The block descriptors are read and written because Sony SDT-7000 does not
3221    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3222
3223    My HP C1533A drive returns only one partition size field. This is used to
3224    set the size of partition 1. There is no size field for the default partition.
3225    Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3226    used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3227    The following algorithm is used to accommodate both drives: if the number of
3228    partition size fields is greater than the maximum number of additional partitions
3229    in the mode page, the second field is used. Otherwise the first field is used.
3230
3231    For Seagate DDS drives the page length must be 8 when no partitions is defined
3232    and 10 when 1 partition is defined (information from Eric Lee Green). This is
3233    is acceptable also to some other old drives and enforced if the first partition
3234    size field is used for the first additional partition size.
3235  */
3236 static int partition_tape(struct scsi_tape *STp, int size)
3237 {
3238         char *name = tape_name(STp);
3239         int result;
3240         int pgo, psd_cnt, psdo;
3241         unsigned char *bp;
3242
3243         result = read_mode_page(STp, PART_PAGE, 0);
3244         if (result) {
3245                 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3246                 return result;
3247         }
3248         /* The mode page is in the buffer. Let's modify it and write it. */
3249         bp = (STp->buffer)->b_data;
3250         pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3251         DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3252                     name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3253
3254         psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3255         psdo = pgo + PART_PAGE_FIXED_LENGTH;
3256         if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3257                 bp[psdo] = bp[psdo + 1] = 0xff;  /* Rest of the tape */
3258                 psdo += 2;
3259         }
3260         memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3261
3262         DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3263                     psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3264                     bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3265
3266         if (size <= 0) {
3267                 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3268                 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3269                     bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3270                 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3271                             name));
3272         } else {
3273                 bp[psdo] = (size >> 8) & 0xff;
3274                 bp[psdo + 1] = size & 0xff;
3275                 bp[pgo + 3] = 1;
3276                 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3277                     bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3278                 DEBC(printk(ST_DEB_MSG
3279                             "%s: Formatting tape with two partitions (1 = %d MB).\n",
3280                             name, size));
3281         }
3282         bp[pgo + PP_OFF_PART_UNITS] = 0;
3283         bp[pgo + PP_OFF_RESERVED] = 0;
3284         bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3285
3286         result = write_mode_page(STp, PART_PAGE, 1);
3287         if (result) {
3288                 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3289                 result = (-EIO);
3290         }
3291
3292         return result;
3293 }
3294 \f
3295
3296
3297 /* The ioctl command */
3298 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3299 {
3300         int i, cmd_nr, cmd_type, bt;
3301         int retval = 0;
3302         unsigned int blk;
3303         struct scsi_tape *STp = file->private_data;
3304         struct st_modedef *STm;
3305         struct st_partstat *STps;
3306         char *name = tape_name(STp);
3307         void __user *p = (void __user *)arg;
3308
3309         if (mutex_lock_interruptible(&STp->lock))
3310                 return -ERESTARTSYS;
3311
3312         DEB(
3313         if (debugging && !STp->in_use) {
3314                 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3315                 retval = (-EIO);
3316                 goto out;
3317         } ) /* end DEB */
3318
3319         STm = &(STp->modes[STp->current_mode]);
3320         STps = &(STp->ps[STp->partition]);
3321
3322         /*
3323          * If we are in the middle of error recovery, don't let anyone
3324          * else try and use this device.  Also, if error recovery fails, it
3325          * may try and take the device offline, in which case all further
3326          * access to the device is prohibited.
3327          */
3328         retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3329                                         file->f_flags & O_NDELAY);
3330         if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3331                 goto out;
3332         retval = 0;
3333
3334         cmd_type = _IOC_TYPE(cmd_in);
3335         cmd_nr = _IOC_NR(cmd_in);
3336
3337         if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3338                 struct mtop mtc;
3339
3340                 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3341                         retval = (-EINVAL);
3342                         goto out;
3343                 }
3344
3345                 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3346                 if (i) {
3347                         retval = (-EFAULT);
3348                         goto out;
3349                 }
3350
3351                 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3352                         printk(KERN_WARNING
3353                                "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3354                         retval = (-EPERM);
3355                         goto out;
3356                 }
3357                 if (!STm->defined &&
3358                     (mtc.mt_op != MTSETDRVBUFFER &&
3359                      (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3360                         retval = (-ENXIO);
3361                         goto out;
3362                 }
3363
3364                 if (!STp->pos_unknown) {
3365
3366                         if (STps->eof == ST_FM_HIT) {
3367                                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3368                                     mtc.mt_op == MTEOM) {
3369                                         mtc.mt_count -= 1;
3370                                         if (STps->drv_file >= 0)
3371                                                 STps->drv_file += 1;
3372                                 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3373                                         mtc.mt_count += 1;
3374                                         if (STps->drv_file >= 0)
3375                                                 STps->drv_file += 1;
3376                                 }
3377                         }
3378
3379                         if (mtc.mt_op == MTSEEK) {
3380                                 /* Old position must be restored if partition will be
3381                                    changed */
3382                                 i = !STp->can_partitions ||
3383                                     (STp->new_partition != STp->partition);
3384                         } else {
3385                                 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3386                                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3387                                     mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3388                                     mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3389                                     mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3390                                     mtc.mt_op == MTCOMPRESSION;
3391                         }
3392                         i = flush_buffer(STp, i);
3393                         if (i < 0) {
3394                                 retval = i;
3395                                 goto out;
3396                         }
3397                         if (STps->rw == ST_WRITING &&
3398                             (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3399                              mtc.mt_op == MTSEEK ||
3400                              mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3401                                 i = st_int_ioctl(STp, MTWEOF, 1);
3402                                 if (i < 0) {
3403                                         retval = i;
3404                                         goto out;
3405                                 }
3406                                 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3407                                         mtc.mt_count++;
3408                                 STps->rw = ST_IDLE;
3409                              }
3410
3411                 } else {
3412                         /*
3413                          * If there was a bus reset, block further access
3414                          * to this device.  If the user wants to rewind the tape,
3415                          * then reset the flag and allow access again.
3416                          */
3417                         if (mtc.mt_op != MTREW &&
3418                             mtc.mt_op != MTOFFL &&
3419                             mtc.mt_op != MTRETEN &&
3420                             mtc.mt_op != MTERASE &&
3421                             mtc.mt_op != MTSEEK &&
3422                             mtc.mt_op != MTEOM) {
3423                                 retval = (-EIO);
3424                                 goto out;
3425                         }
3426                         reset_state(STp);
3427                         /* remove this when the midlevel properly clears was_reset */
3428                         STp->device->was_reset = 0;
3429                 }
3430
3431                 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3432                     mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3433                     mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3434                         STps->rw = ST_IDLE;     /* Prevent automatic WEOF and fsf */
3435
3436                 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3437                         do_door_lock(STp, 0);   /* Ignore result! */
3438
3439                 if (mtc.mt_op == MTSETDRVBUFFER &&
3440                     (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3441                         retval = st_set_options(STp, mtc.mt_count);
3442                         goto out;
3443                 }
3444
3445                 if (mtc.mt_op == MTSETPART) {
3446                         if (!STp->can_partitions ||
3447                             mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3448                                 retval = (-EINVAL);
3449                                 goto out;
3450                         }
3451                         if (mtc.mt_count >= STp->nbr_partitions &&
3452                             (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3453                                 retval = (-EIO);
3454                                 goto out;
3455                         }
3456                         if (mtc.mt_count >= STp->nbr_partitions) {
3457                                 retval = (-EINVAL);
3458                                 goto out;
3459                         }
3460                         STp->new_partition = mtc.mt_count;
3461                         retval = 0;
3462                         goto out;
3463                 }
3464
3465                 if (mtc.mt_op == MTMKPART) {
3466                         if (!STp->can_partitions) {
3467                                 retval = (-EINVAL);
3468                                 goto out;
3469                         }
3470                         if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3471                             (i = partition_tape(STp, mtc.mt_count)) < 0) {
3472                                 retval = i;
3473                                 goto out;
3474                         }
3475                         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3476                                 STp->ps[i].rw = ST_IDLE;
3477                                 STp->ps[i].at_sm = 0;
3478                                 STp->ps[i].last_block_valid = 0;
3479                         }
3480                         STp->partition = STp->new_partition = 0;
3481                         STp->nbr_partitions = 1;        /* Bad guess ?-) */
3482                         STps->drv_block = STps->drv_file = 0;
3483                         retval = 0;
3484                         goto out;
3485                 }
3486
3487                 if (mtc.mt_op == MTSEEK) {
3488                         i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3489                         if (!STp->can_partitions)
3490                                 STp->ps[0].rw = ST_IDLE;
3491                         retval = i;
3492                         goto out;
3493                 }
3494
3495                 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3496                         retval = do_load_unload(STp, file, 0);
3497                         goto out;
3498                 }
3499
3500                 if (mtc.mt_op == MTLOAD) {
3501                         retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3502                         goto out;
3503                 }
3504
3505                 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3506                         retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3507                         goto out;
3508                 }
3509
3510                 if (STp->can_partitions && STp->ready == ST_READY &&
3511                     (i = switch_partition(STp)) < 0) {
3512                         retval = i;
3513                         goto out;
3514                 }
3515
3516                 if (mtc.mt_op == MTCOMPRESSION)
3517                         retval = st_compression(STp, (mtc.mt_count & 1));
3518                 else
3519                         retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3520                 goto out;
3521         }
3522         if (!STm->defined) {
3523                 retval = (-ENXIO);
3524                 goto out;
3525         }
3526
3527         if ((i = flush_buffer(STp, 0)) < 0) {
3528                 retval = i;
3529                 goto out;
3530         }
3531         if (STp->can_partitions &&
3532             (i = switch_partition(STp)) < 0) {
3533                 retval = i;
3534                 goto out;
3535         }
3536
3537         if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3538                 struct mtget mt_status;
3539
3540                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3541                          retval = (-EINVAL);
3542                          goto out;
3543                 }
3544
3545                 mt_status.mt_type = STp->tape_type;
3546                 mt_status.mt_dsreg =
3547                     ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3548                     ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3549                 mt_status.mt_blkno = STps->drv_block;
3550                 mt_status.mt_fileno = STps->drv_file;
3551                 if (STp->block_size != 0) {
3552                         if (STps->rw == ST_WRITING)
3553                                 mt_status.mt_blkno +=
3554                                     (STp->buffer)->buffer_bytes / STp->block_size;
3555                         else if (STps->rw == ST_READING)
3556                                 mt_status.mt_blkno -=
3557                                         ((STp->buffer)->buffer_bytes +
3558                                          STp->block_size - 1) / STp->block_size;
3559                 }
3560
3561                 mt_status.mt_gstat = 0;
3562                 if (STp->drv_write_prot)
3563                         mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3564                 if (mt_status.mt_blkno == 0) {
3565                         if (mt_status.mt_fileno == 0)
3566                                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3567                         else
3568                                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3569                 }
3570                 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3571                 mt_status.mt_resid = STp->partition;
3572                 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3573                         mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3574                 else if (STps->eof >= ST_EOM_OK)
3575                         mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3576                 if (STp->density == 1)
3577                         mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3578                 else if (STp->density == 2)
3579                         mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3580                 else if (STp->density == 3)
3581                         mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3582                 if (STp->ready == ST_READY)
3583                         mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3584                 if (STp->ready == ST_NO_TAPE)
3585                         mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3586                 if (STps->at_sm)
3587                         mt_status.mt_gstat |= GMT_SM(0xffffffff);
3588                 if (STm->do_async_writes ||
3589                     (STm->do_buffer_writes && STp->block_size != 0) ||
3590                     STp->drv_buffer != 0)
3591                         mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3592                 if (STp->cleaning_req)
3593                         mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3594
3595                 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3596                 if (i) {
3597                         retval = (-EFAULT);
3598                         goto out;
3599                 }
3600
3601                 STp->recover_reg = 0;           /* Clear after read */
3602                 retval = 0;
3603                 goto out;
3604         }                       /* End of MTIOCGET */
3605         if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3606                 struct mtpos mt_pos;
3607                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3608                          retval = (-EINVAL);
3609                          goto out;
3610                 }
3611                 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3612                         retval = i;
3613                         goto out;
3614                 }
3615                 mt_pos.mt_blkno = blk;
3616                 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3617                 if (i)
3618                         retval = (-EFAULT);
3619                 goto out;
3620         }
3621         mutex_unlock(&STp->lock);
3622         switch (cmd_in) {
3623                 case SCSI_IOCTL_GET_IDLUN:
3624                 case SCSI_IOCTL_GET_BUS_NUMBER:
3625                         break;
3626                 default:
3627                         if ((cmd_in == SG_IO ||
3628                              cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3629                              cmd_in == CDROM_SEND_PACKET) &&
3630                             !capable(CAP_SYS_RAWIO))
3631                                 i = -EPERM;
3632                         else
3633                                 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3634                                                    file->f_mode, cmd_in, p);
3635                         if (i != -ENOTTY)
3636                                 return i;
3637                         break;
3638         }
3639         retval = scsi_ioctl(STp->device, cmd_in, p);
3640         if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3641                 STp->rew_at_close = 0;
3642                 STp->ready = ST_NO_TAPE;
3643         }
3644         return retval;
3645
3646  out:
3647         mutex_unlock(&STp->lock);
3648         return retval;
3649 }
3650
3651 #ifdef CONFIG_COMPAT
3652 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3653 {
3654         struct scsi_tape *STp = file->private_data;
3655         struct scsi_device *sdev = STp->device;
3656         int ret = -ENOIOCTLCMD;
3657         if (sdev->host->hostt->compat_ioctl) {
3658
3659                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3660
3661         }
3662         return ret;
3663 }
3664 #endif
3665
3666 \f
3667
3668 /* Try to allocate a new tape buffer. Calling function must not hold
3669    dev_arr_lock. */
3670 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3671 {
3672         struct st_buffer *tb;
3673
3674         tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3675         if (!tb) {
3676                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3677                 return NULL;
3678         }
3679         tb->frp_segs = 0;
3680         tb->use_sg = max_sg;
3681         tb->dma = need_dma;
3682         tb->buffer_size = 0;
3683
3684         tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3685                                      GFP_ATOMIC);
3686         if (!tb->reserved_pages) {
3687                 kfree(tb);
3688                 return NULL;
3689         }
3690
3691         return tb;
3692 }
3693
3694
3695 /* Try to allocate enough space in the tape buffer */
3696 #define ST_MAX_ORDER 6
3697
3698 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3699 {
3700         int segs, nbr, max_segs, b_size, order, got;
3701         gfp_t priority;
3702
3703         if (new_size <= STbuffer->buffer_size)
3704                 return 1;
3705
3706         if (STbuffer->buffer_size <= PAGE_SIZE)
3707                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3708
3709         max_segs = STbuffer->use_sg;
3710         nbr = max_segs - STbuffer->frp_segs;
3711         if (nbr <= 0)
3712                 return 0;
3713
3714         priority = GFP_KERNEL | __GFP_NOWARN;
3715         if (need_dma)
3716                 priority |= GFP_DMA;
3717
3718         if (STbuffer->cleared)
3719                 priority |= __GFP_ZERO;
3720
3721         if (STbuffer->frp_segs) {
3722                 order = STbuffer->map_data.page_order;
3723                 b_size = PAGE_SIZE << order;
3724         } else {
3725                 for (b_size = PAGE_SIZE, order = 0;
3726                      order < ST_MAX_ORDER && b_size < new_size;
3727                      order++, b_size *= 2)
3728                         ;  /* empty */
3729         }
3730         if (max_segs * (PAGE_SIZE << order) < new_size) {
3731                 if (order == ST_MAX_ORDER)
3732                         return 0;
3733                 normalize_buffer(STbuffer);
3734                 return enlarge_buffer(STbuffer, new_size, need_dma);
3735         }
3736
3737         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3738              segs < max_segs && got < new_size;) {
3739                 struct page *page;
3740
3741                 page = alloc_pages(priority, order);
3742                 if (!page) {
3743                         DEB(STbuffer->buffer_size = got);
3744                         normalize_buffer(STbuffer);
3745                         return 0;
3746                 }
3747
3748                 STbuffer->frp_segs += 1;
3749                 got += b_size;
3750                 STbuffer->buffer_size = got;
3751                 STbuffer->reserved_pages[segs] = page;
3752                 segs++;
3753         }
3754         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3755         STbuffer->map_data.page_order = order;
3756
3757         return 1;
3758 }
3759
3760
3761 /* Make sure that no data from previous user is in the internal buffer */
3762 static void clear_buffer(struct st_buffer * st_bp)
3763 {
3764         int i;
3765
3766         for (i=0; i < st_bp->frp_segs; i++)
3767                 memset(page_address(st_bp->reserved_pages[i]), 0,
3768                        PAGE_SIZE << st_bp->map_data.page_order);
3769         st_bp->cleared = 1;
3770 }
3771
3772
3773 /* Release the extra buffer */
3774 static void normalize_buffer(struct st_buffer * STbuffer)
3775 {
3776         int i, order = STbuffer->map_data.page_order;
3777
3778         for (i = 0; i < STbuffer->frp_segs; i++) {
3779                 __free_pages(STbuffer->reserved_pages[i], order);
3780                 STbuffer->buffer_size -= (PAGE_SIZE << order);
3781         }
3782         STbuffer->frp_segs = 0;
3783         STbuffer->sg_segs = 0;
3784         STbuffer->map_data.page_order = 0;
3785         STbuffer->map_data.offset = 0;
3786 }
3787
3788
3789 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3790    negative error code. */
3791 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3792 {
3793         int i, cnt, res, offset;
3794         int length = PAGE_SIZE << st_bp->map_data.page_order;
3795
3796         for (i = 0, offset = st_bp->buffer_bytes;
3797              i < st_bp->frp_segs && offset >= length; i++)
3798                 offset -= length;
3799         if (i == st_bp->frp_segs) {     /* Should never happen */
3800                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3801                 return (-EIO);
3802         }
3803         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3804                 struct page *page = st_bp->reserved_pages[i];
3805                 cnt = length - offset < do_count ? length - offset : do_count;
3806                 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3807                 if (res)
3808                         return (-EFAULT);
3809                 do_count -= cnt;
3810                 st_bp->buffer_bytes += cnt;
3811                 ubp += cnt;
3812                 offset = 0;
3813         }
3814         if (do_count) /* Should never happen */
3815                 return (-EIO);
3816
3817         return 0;
3818 }
3819
3820
3821 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3822    negative error code. */
3823 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3824 {
3825         int i, cnt, res, offset;
3826         int length = PAGE_SIZE << st_bp->map_data.page_order;
3827
3828         for (i = 0, offset = st_bp->read_pointer;
3829              i < st_bp->frp_segs && offset >= length; i++)
3830                 offset -= length;
3831         if (i == st_bp->frp_segs) {     /* Should never happen */
3832                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3833                 return (-EIO);
3834         }
3835         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3836                 struct page *page = st_bp->reserved_pages[i];
3837                 cnt = length - offset < do_count ? length - offset : do_count;
3838                 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3839                 if (res)
3840                         return (-EFAULT);
3841                 do_count -= cnt;
3842                 st_bp->buffer_bytes -= cnt;
3843                 st_bp->read_pointer += cnt;
3844                 ubp += cnt;
3845                 offset = 0;
3846         }
3847         if (do_count) /* Should never happen */
3848                 return (-EIO);
3849
3850         return 0;
3851 }
3852
3853
3854 /* Move data towards start of buffer */
3855 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3856 {
3857         int src_seg, dst_seg, src_offset = 0, dst_offset;
3858         int count, total;
3859         int length = PAGE_SIZE << st_bp->map_data.page_order;
3860
3861         if (offset == 0)
3862                 return;
3863
3864         total=st_bp->buffer_bytes - offset;
3865         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3866                 src_offset = offset;
3867                 if (src_offset < length)
3868                         break;
3869                 offset -= length;
3870         }
3871
3872         st_bp->buffer_bytes = st_bp->read_pointer = total;
3873         for (dst_seg=dst_offset=0; total > 0; ) {
3874                 struct page *dpage = st_bp->reserved_pages[dst_seg];
3875                 struct page *spage = st_bp->reserved_pages[src_seg];
3876
3877                 count = min(length - dst_offset, length - src_offset);
3878                 memmove(page_address(dpage) + dst_offset,
3879                         page_address(spage) + src_offset, count);
3880                 src_offset += count;
3881                 if (src_offset >= length) {
3882                         src_seg++;
3883                         src_offset = 0;
3884                 }
3885                 dst_offset += count;
3886                 if (dst_offset >= length) {
3887                         dst_seg++;
3888                         dst_offset = 0;
3889                 }
3890                 total -= count;
3891         }
3892 }
3893
3894 /* Validate the options from command line or module parameters */
3895 static void validate_options(void)
3896 {
3897         if (buffer_kbs > 0)
3898                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3899         if (max_sg_segs >= ST_FIRST_SG)
3900                 st_max_sg_segs = max_sg_segs;
3901 }
3902
3903 #ifndef MODULE
3904 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3905  */
3906 static int __init st_setup(char *str)
3907 {
3908         int i, len, ints[5];
3909         char *stp;
3910
3911         stp = get_options(str, ARRAY_SIZE(ints), ints);
3912
3913         if (ints[0] > 0) {
3914                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3915                         if (parms[i].val)
3916                                 *parms[i].val = ints[i + 1];
3917         } else {
3918                 while (stp != NULL) {
3919                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3920                                 len = strlen(parms[i].name);
3921                                 if (!strncmp(stp, parms[i].name, len) &&
3922                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3923                                         if (parms[i].val)
3924                                                 *parms[i].val =
3925                                                         simple_strtoul(stp + len + 1, NULL, 0);
3926                                         else
3927                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3928                                                        parms[i].name);
3929                                         break;
3930                                 }
3931                         }
3932                         if (i >= ARRAY_SIZE(parms))
3933                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3934                                         stp);
3935                         stp = strchr(stp, ',');
3936                         if (stp)
3937                                 stp++;
3938                 }
3939         }
3940
3941         validate_options();
3942
3943         return 1;
3944 }
3945
3946 __setup("st=", st_setup);
3947
3948 #endif
3949
3950 static const struct file_operations st_fops =
3951 {
3952         .owner =        THIS_MODULE,
3953         .read =         st_read,
3954         .write =        st_write,
3955         .unlocked_ioctl = st_ioctl,
3956 #ifdef CONFIG_COMPAT
3957         .compat_ioctl = st_compat_ioctl,
3958 #endif
3959         .open =         st_open,
3960         .flush =        st_flush,
3961         .release =      st_release,
3962 };
3963
3964 static int st_probe(struct device *dev)
3965 {
3966         struct scsi_device *SDp = to_scsi_device(dev);
3967         struct gendisk *disk = NULL;
3968         struct cdev *cdev = NULL;
3969         struct scsi_tape *tpnt = NULL;
3970         struct st_modedef *STm;
3971         struct st_partstat *STps;
3972         struct st_buffer *buffer;
3973         int i, j, mode, dev_num, error;
3974         char *stp;
3975
3976         if (SDp->type != TYPE_TAPE)
3977                 return -ENODEV;
3978         if ((stp = st_incompatible(SDp))) {
3979                 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3980                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3981                 return -ENODEV;
3982         }
3983
3984         i = min(queue_max_hw_segments(SDp->request_queue),
3985                 queue_max_phys_segments(SDp->request_queue));
3986         if (st_max_sg_segs < i)
3987                 i = st_max_sg_segs;
3988         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
3989         if (buffer == NULL) {
3990                 printk(KERN_ERR
3991                        "st: Can't allocate new tape buffer. Device not attached.\n");
3992                 goto out;
3993         }
3994
3995         disk = alloc_disk(1);
3996         if (!disk) {
3997                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3998                 goto out_buffer_free;
3999         }
4000
4001         write_lock(&st_dev_arr_lock);
4002         if (st_nr_dev >= st_dev_max) {
4003                 struct scsi_tape **tmp_da;
4004                 int tmp_dev_max;
4005
4006                 tmp_dev_max = max(st_nr_dev * 2, 8);
4007                 if (tmp_dev_max > ST_MAX_TAPES)
4008                         tmp_dev_max = ST_MAX_TAPES;
4009                 if (tmp_dev_max <= st_nr_dev) {
4010                         write_unlock(&st_dev_arr_lock);
4011                         printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4012                                ST_MAX_TAPES);
4013                         goto out_put_disk;
4014                 }
4015
4016                 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4017                 if (tmp_da == NULL) {
4018                         write_unlock(&st_dev_arr_lock);
4019                         printk(KERN_ERR "st: Can't extend device array.\n");
4020                         goto out_put_disk;
4021                 }
4022
4023                 if (scsi_tapes != NULL) {
4024                         memcpy(tmp_da, scsi_tapes,
4025                                st_dev_max * sizeof(struct scsi_tape *));
4026                         kfree(scsi_tapes);
4027                 }
4028                 scsi_tapes = tmp_da;
4029
4030                 st_dev_max = tmp_dev_max;
4031         }
4032
4033         for (i = 0; i < st_dev_max; i++)
4034                 if (scsi_tapes[i] == NULL)
4035                         break;
4036         if (i >= st_dev_max)
4037                 panic("scsi_devices corrupt (st)");
4038
4039         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4040         if (tpnt == NULL) {
4041                 write_unlock(&st_dev_arr_lock);
4042                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4043                 goto out_put_disk;
4044         }
4045         kref_init(&tpnt->kref);
4046         tpnt->disk = disk;
4047         sprintf(disk->disk_name, "st%d", i);
4048         disk->private_data = &tpnt->driver;
4049         disk->queue = SDp->request_queue;
4050         tpnt->driver = &st_template;
4051         scsi_tapes[i] = tpnt;
4052         dev_num = i;
4053
4054         tpnt->device = SDp;
4055         if (SDp->scsi_level <= 2)
4056                 tpnt->tape_type = MT_ISSCSI1;
4057         else
4058                 tpnt->tape_type = MT_ISSCSI2;
4059
4060         tpnt->buffer = buffer;
4061         tpnt->buffer->last_SRpnt = NULL;
4062
4063         tpnt->inited = 0;
4064         tpnt->dirty = 0;
4065         tpnt->in_use = 0;
4066         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4067         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4068         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4069         tpnt->density = 0;
4070         tpnt->do_auto_lock = ST_AUTO_LOCK;
4071         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4072         tpnt->can_partitions = 0;
4073         tpnt->two_fm = ST_TWO_FM;
4074         tpnt->fast_mteom = ST_FAST_MTEOM;
4075         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4076         tpnt->sili = ST_SILI;
4077         tpnt->immediate = ST_NOWAIT;
4078         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
4079         tpnt->partition = 0;
4080         tpnt->new_partition = 0;
4081         tpnt->nbr_partitions = 0;
4082         blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4083         tpnt->long_timeout = ST_LONG_TIMEOUT;
4084         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4085
4086         for (i = 0; i < ST_NBR_MODES; i++) {
4087                 STm = &(tpnt->modes[i]);
4088                 STm->defined = 0;
4089                 STm->sysv = ST_SYSV;
4090                 STm->defaults_for_writes = 0;
4091                 STm->do_async_writes = ST_ASYNC_WRITES;
4092                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4093                 STm->do_read_ahead = ST_READ_AHEAD;
4094                 STm->default_compression = ST_DONT_TOUCH;
4095                 STm->default_blksize = (-1);    /* No forced size */
4096                 STm->default_density = (-1);    /* No forced density */
4097         }
4098
4099         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4100                 STps = &(tpnt->ps[i]);
4101                 STps->rw = ST_IDLE;
4102                 STps->eof = ST_NOEOF;
4103                 STps->at_sm = 0;
4104                 STps->last_block_valid = 0;
4105                 STps->drv_block = (-1);
4106                 STps->drv_file = (-1);
4107         }
4108
4109         tpnt->current_mode = 0;
4110         tpnt->modes[0].defined = 1;
4111
4112         tpnt->density_changed = tpnt->compression_changed =
4113             tpnt->blksize_changed = 0;
4114         mutex_init(&tpnt->lock);
4115
4116         st_nr_dev++;
4117         write_unlock(&st_dev_arr_lock);
4118
4119         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4120                 STm = &(tpnt->modes[mode]);
4121                 for (j=0; j < 2; j++) {
4122                         cdev = cdev_alloc();
4123                         if (!cdev) {
4124                                 printk(KERN_ERR
4125                                        "st%d: out of memory. Device not attached.\n",
4126                                        dev_num);
4127                                 goto out_free_tape;
4128                         }
4129                         cdev->owner = THIS_MODULE;
4130                         cdev->ops = &st_fops;
4131
4132                         error = cdev_add(cdev,
4133                                          MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4134                                          1);
4135                         if (error) {
4136                                 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4137                                        dev_num, j ? "non" : "auto", mode);
4138                                 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4139                                 goto out_free_tape;
4140                         }
4141                         STm->cdevs[j] = cdev;
4142
4143                 }
4144                 error = do_create_class_files(tpnt, dev_num, mode);
4145                 if (error)
4146                         goto out_free_tape;
4147         }
4148
4149         sdev_printk(KERN_NOTICE, SDp,
4150                     "Attached scsi tape %s\n", tape_name(tpnt));
4151         sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4152                     tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4153                     queue_dma_alignment(SDp->request_queue) + 1);
4154
4155         return 0;
4156
4157 out_free_tape:
4158         for (mode=0; mode < ST_NBR_MODES; mode++) {
4159                 STm = &(tpnt->modes[mode]);
4160                 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4161                                   "tape");
4162                 for (j=0; j < 2; j++) {
4163                         if (STm->cdevs[j]) {
4164                                 if (cdev == STm->cdevs[j])
4165                                         cdev = NULL;
4166                                         device_destroy(st_sysfs_class,
4167                                                        MKDEV(SCSI_TAPE_MAJOR,
4168                                                              TAPE_MINOR(i, mode, j)));
4169                                 cdev_del(STm->cdevs[j]);
4170                         }
4171                 }
4172         }
4173         if (cdev)
4174                 cdev_del(cdev);
4175         write_lock(&st_dev_arr_lock);
4176         scsi_tapes[dev_num] = NULL;
4177         st_nr_dev--;
4178         write_unlock(&st_dev_arr_lock);
4179 out_put_disk:
4180         put_disk(disk);
4181         kfree(tpnt);
4182 out_buffer_free:
4183         kfree(buffer);
4184 out:
4185         return -ENODEV;
4186 };
4187
4188
4189 static int st_remove(struct device *dev)
4190 {
4191         struct scsi_device *SDp = to_scsi_device(dev);
4192         struct scsi_tape *tpnt;
4193         int i, j, mode;
4194
4195         write_lock(&st_dev_arr_lock);
4196         for (i = 0; i < st_dev_max; i++) {
4197                 tpnt = scsi_tapes[i];
4198                 if (tpnt != NULL && tpnt->device == SDp) {
4199                         scsi_tapes[i] = NULL;
4200                         st_nr_dev--;
4201                         write_unlock(&st_dev_arr_lock);
4202                         sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4203                                           "tape");
4204                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4205                                 for (j=0; j < 2; j++) {
4206                                         device_destroy(st_sysfs_class,
4207                                                        MKDEV(SCSI_TAPE_MAJOR,
4208                                                              TAPE_MINOR(i, mode, j)));
4209                                         cdev_del(tpnt->modes[mode].cdevs[j]);
4210                                         tpnt->modes[mode].cdevs[j] = NULL;
4211                                 }
4212                         }
4213
4214                         mutex_lock(&st_ref_mutex);
4215                         kref_put(&tpnt->kref, scsi_tape_release);
4216                         mutex_unlock(&st_ref_mutex);
4217                         return 0;
4218                 }
4219         }
4220
4221         write_unlock(&st_dev_arr_lock);
4222         return 0;
4223 }
4224
4225 /**
4226  *      scsi_tape_release - Called to free the Scsi_Tape structure
4227  *      @kref: pointer to embedded kref
4228  *
4229  *      st_ref_mutex must be held entering this routine.  Because it is
4230  *      called on last put, you should always use the scsi_tape_get()
4231  *      scsi_tape_put() helpers which manipulate the semaphore directly
4232  *      and never do a direct kref_put().
4233  **/
4234 static void scsi_tape_release(struct kref *kref)
4235 {
4236         struct scsi_tape *tpnt = to_scsi_tape(kref);
4237         struct gendisk *disk = tpnt->disk;
4238
4239         tpnt->device = NULL;
4240
4241         if (tpnt->buffer) {
4242                 normalize_buffer(tpnt->buffer);
4243                 kfree(tpnt->buffer->reserved_pages);
4244                 kfree(tpnt->buffer);
4245         }
4246
4247         disk->private_data = NULL;
4248         put_disk(disk);
4249         kfree(tpnt);
4250         return;
4251 }
4252
4253 static int __init init_st(void)
4254 {
4255         int err;
4256
4257         validate_options();
4258
4259         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4260                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4261
4262         st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4263         if (IS_ERR(st_sysfs_class)) {
4264                 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4265                 return PTR_ERR(st_sysfs_class);
4266         }
4267
4268         err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4269                                      ST_MAX_TAPE_ENTRIES, "st");
4270         if (err) {
4271                 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4272                        SCSI_TAPE_MAJOR);
4273                 goto err_class;
4274         }
4275
4276         err = scsi_register_driver(&st_template.gendrv);
4277         if (err)
4278                 goto err_chrdev;
4279
4280         err = do_create_sysfs_files();
4281         if (err)
4282                 goto err_scsidrv;
4283
4284         return 0;
4285
4286 err_scsidrv:
4287         scsi_unregister_driver(&st_template.gendrv);
4288 err_chrdev:
4289         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4290                                  ST_MAX_TAPE_ENTRIES);
4291 err_class:
4292         class_destroy(st_sysfs_class);
4293         return err;
4294 }
4295
4296 static void __exit exit_st(void)
4297 {
4298         do_remove_sysfs_files();
4299         scsi_unregister_driver(&st_template.gendrv);
4300         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4301                                  ST_MAX_TAPE_ENTRIES);
4302         class_destroy(st_sysfs_class);
4303         kfree(scsi_tapes);
4304         printk(KERN_INFO "st: Unloaded.\n");
4305 }
4306
4307 module_init(init_st);
4308 module_exit(exit_st);
4309
4310
4311 /* The sysfs driver interface. Read-only at the moment */
4312 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4313 {
4314         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4315 }
4316 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4317
4318 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4319 {
4320         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4321 }
4322 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4323
4324 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4325 {
4326         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4327 }
4328 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4329
4330 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4331 {
4332         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4333 }
4334 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4335
4336 static int do_create_sysfs_files(void)
4337 {
4338         struct device_driver *sysfs = &st_template.gendrv;
4339         int err;
4340
4341         err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4342         if (err)
4343                 return err;
4344         err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4345         if (err)
4346                 goto err_try_direct_io;
4347         err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4348         if (err)
4349                 goto err_attr_fixed_buf;
4350         err = driver_create_file(sysfs, &driver_attr_version);
4351         if (err)
4352                 goto err_attr_max_sg;
4353
4354         return 0;
4355
4356 err_attr_max_sg:
4357         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4358 err_attr_fixed_buf:
4359         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4360 err_try_direct_io:
4361         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4362         return err;
4363 }
4364
4365 static void do_remove_sysfs_files(void)
4366 {
4367         struct device_driver *sysfs = &st_template.gendrv;
4368
4369         driver_remove_file(sysfs, &driver_attr_version);
4370         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4371         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4372         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4373 }
4374
4375
4376 /* The sysfs simple class interface */
4377 static ssize_t
4378 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4379 {
4380         struct st_modedef *STm = dev_get_drvdata(dev);
4381         ssize_t l = 0;
4382
4383         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4384         return l;
4385 }
4386
4387 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4388
4389 static ssize_t
4390 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4391 {
4392         struct st_modedef *STm = dev_get_drvdata(dev);
4393         ssize_t l = 0;
4394
4395         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4396         return l;
4397 }
4398
4399 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4400
4401 static ssize_t
4402 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4403 {
4404         struct st_modedef *STm = dev_get_drvdata(dev);
4405         ssize_t l = 0;
4406         char *fmt;
4407
4408         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4409         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4410         return l;
4411 }
4412
4413 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4414
4415 static ssize_t
4416 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4417                        char *buf)
4418 {
4419         struct st_modedef *STm = dev_get_drvdata(dev);
4420         ssize_t l = 0;
4421
4422         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4423         return l;
4424 }
4425
4426 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4427
4428 static ssize_t
4429 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4430 {
4431         struct st_modedef *STm = dev_get_drvdata(dev);
4432         struct scsi_tape *STp;
4433         int i, j, options;
4434         ssize_t l = 0;
4435
4436         for (i=0; i < st_dev_max; i++) {
4437                 for (j=0; j < ST_NBR_MODES; j++)
4438                         if (&scsi_tapes[i]->modes[j] == STm)
4439                                 break;
4440                 if (j < ST_NBR_MODES)
4441                         break;
4442         }
4443         if (i == st_dev_max)
4444                 return 0;  /* should never happen */
4445
4446         STp = scsi_tapes[i];
4447
4448         options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4449         options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4450         options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4451         DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4452         options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4453         options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4454         options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4455         options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4456         options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4457         options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4458         options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4459         options |= STm->sysv ? MT_ST_SYSV : 0;
4460         options |= STp->immediate ? MT_ST_NOWAIT : 0;
4461         options |= STp->sili ? MT_ST_SILI : 0;
4462
4463         l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4464         return l;
4465 }
4466
4467 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4468
4469 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4470 {
4471         int i, rew, error;
4472         char name[10];
4473         struct device *st_class_member;
4474
4475         for (rew=0; rew < 2; rew++) {
4476                 /* Make sure that the minor numbers corresponding to the four
4477                    first modes always get the same names */
4478                 i = mode << (4 - ST_NBR_MODE_BITS);
4479                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4480                          STp->disk->disk_name, st_formats[i]);
4481                 st_class_member =
4482                         device_create(st_sysfs_class, &STp->device->sdev_gendev,
4483                                       MKDEV(SCSI_TAPE_MAJOR,
4484                                             TAPE_MINOR(dev_num, mode, rew)),
4485                                       &STp->modes[mode], "%s", name);
4486                 if (IS_ERR(st_class_member)) {
4487                         printk(KERN_WARNING "st%d: device_create failed\n",
4488                                dev_num);
4489                         error = PTR_ERR(st_class_member);
4490                         goto out;
4491                 }
4492
4493                 error = device_create_file(st_class_member,
4494                                            &dev_attr_defined);
4495                 if (error) goto out;
4496                 error = device_create_file(st_class_member,
4497                                            &dev_attr_default_blksize);
4498                 if (error) goto out;
4499                 error = device_create_file(st_class_member,
4500                                            &dev_attr_default_density);
4501                 if (error) goto out;
4502                 error = device_create_file(st_class_member,
4503                                            &dev_attr_default_compression);
4504                 if (error) goto out;
4505                 error = device_create_file(st_class_member,
4506                                            &dev_attr_options);
4507                 if (error) goto out;
4508
4509                 if (mode == 0 && rew == 0) {
4510                         error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4511                                                   &st_class_member->kobj,
4512                                                   "tape");
4513                         if (error) {
4514                                 printk(KERN_ERR
4515                                        "st%d: Can't create sysfs link from SCSI device.\n",
4516                                        dev_num);
4517                                 goto out;
4518                         }
4519                 }
4520         }
4521
4522         return 0;
4523
4524 out:
4525         return error;
4526 }
4527
4528 /* The following functions may be useful for a larger audience. */
4529 static int sgl_map_user_pages(struct st_buffer *STbp,
4530                               const unsigned int max_pages, unsigned long uaddr,
4531                               size_t count, int rw)
4532 {
4533         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4534         unsigned long start = uaddr >> PAGE_SHIFT;
4535         const int nr_pages = end - start;
4536         int res, i, j;
4537         struct page **pages;
4538         struct rq_map_data *mdata = &STbp->map_data;
4539
4540         /* User attempted Overflow! */
4541         if ((uaddr + count) < uaddr)
4542                 return -EINVAL;
4543
4544         /* Too big */
4545         if (nr_pages > max_pages)
4546                 return -ENOMEM;
4547
4548         /* Hmm? */
4549         if (count == 0)
4550                 return 0;
4551
4552         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4553                 return -ENOMEM;
4554
4555         /* Try to fault in all of the necessary pages */
4556         down_read(&current->mm->mmap_sem);
4557         /* rw==READ means read from drive, write into memory area */
4558         res = get_user_pages(
4559                 current,
4560                 current->mm,
4561                 uaddr,
4562                 nr_pages,
4563                 rw == READ,
4564                 0, /* don't force */
4565                 pages,
4566                 NULL);
4567         up_read(&current->mm->mmap_sem);
4568
4569         /* Errors and no page mapped should return here */
4570         if (res < nr_pages)
4571                 goto out_unmap;
4572
4573         for (i=0; i < nr_pages; i++) {
4574                 /* FIXME: flush superflous for rw==READ,
4575                  * probably wrong function for rw==WRITE
4576                  */
4577                 flush_dcache_page(pages[i]);
4578         }
4579
4580         mdata->offset = uaddr & ~PAGE_MASK;
4581         mdata->page_order = 0;
4582         STbp->mapped_pages = pages;
4583
4584         return nr_pages;
4585  out_unmap:
4586         if (res > 0) {
4587                 for (j=0; j < res; j++)
4588                         page_cache_release(pages[j]);
4589                 res = 0;
4590         }
4591         kfree(pages);
4592         return res;
4593 }
4594
4595
4596 /* And unmap them... */
4597 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4598                                 const unsigned int nr_pages, int dirtied)
4599 {
4600         int i;
4601
4602         for (i=0; i < nr_pages; i++) {
4603                 struct page *page = STbp->mapped_pages[i];
4604
4605                 if (dirtied)
4606                         SetPageDirty(page);
4607                 /* FIXME: cache flush missing for rw==READ
4608                  * FIXME: call the correct reference counting function
4609                  */
4610                 page_cache_release(page);
4611         }
4612         kfree(STbp->mapped_pages);
4613         STbp->mapped_pages = NULL;
4614
4615         return 0;
4616 }