drivers/scsi/st.c

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