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