kernel/drivers/scsi/st.c

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