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