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