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