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