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