SAFE public projects git trees. - safe/jmp/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 Driver");
  90 MODULE_LICENSE("GPL");
  91
  92 /* Set 'perm' (4th argument) to 0 to disable module_param's definition
  93  * of sysfs parameters (which module_param doesn't yet support).
  94  * Sysfs parameters defined explicitly later.
  95  */
  96 module_param_named(buffer_kbs, buffer_kbs, int, 0);
  97 MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
  98 module_param_named(max_sg_segs, max_sg_segs, int, 0);
  99 MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
 100 module_param_named(try_direct_io, try_direct_io, int, 0);
 101 MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
 102
 103 /* Extra parameters for testing */
 104 module_param_named(try_rdio, try_rdio, int, 0);
 105 MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
 106 module_param_named(try_wdio, try_wdio, int, 0);
 107 MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
 108
 109 #ifndef MODULE
 110 static int write_threshold_kbs;  /* retained for compatibility */
 111 static struct st_dev_parm {
 112         char *name;
 113         int *val;
 114 } parms[] __initdata = {
 115         {
 116                 "buffer_kbs", &buffer_kbs
 117         },
 118         {       /* Retained for compatibility with 2.4 */
 119                 "write_threshold_kbs", &write_threshold_kbs
 120         },
 121         {
 122                 "max_sg_segs", NULL
 123         },
 124         {
 125                 "try_direct_io", &try_direct_io
 126         }
 127 };
 128 #endif
 129
 130 /* Restrict the number of modes so that names for all are assigned */
 131 #if ST_NBR_MODES > 16
 132 #error "Maximum number of modes is 16"
 133 #endif
 134 /* Bit reversed order to get same names for same minors with all
 135    mode counts */
 136 static const char *st_formats[] = {
 137         "",  "r", "k", "s", "l", "t", "o", "u",
 138         "m", "v", "p", "x", "a", "y", "q", "z"};
 139
 140 /* The default definitions have been moved to st_options.h */
 141
 142 #define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
 143
 144 /* The buffer size should fit into the 24 bits for length in the
 145    6-byte SCSI read and write commands. */
 146 #if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
 147 #error "Buffer size should not exceed (2 << 24 - 1) bytes!"
 148 #endif
 149
 150 static int debugging = DEBUG;
 151
 152 #define MAX_RETRIES 0
 153 #define MAX_WRITE_RETRIES 0
 154 #define MAX_READY_RETRIES 0
 155 #define NO_TAPE  NOT_READY
 156
 157 #define ST_TIMEOUT (900 * HZ)
 158 #define ST_LONG_TIMEOUT (14000 * HZ)
 159
 160 /* Remove mode bits and auto-rewind bit (7) */
 161 #define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
 162     (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
 163 #define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
 164
 165 /* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
 166 #define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
 167   (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
 168
 169 /* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
 170    24 bits) */
 171 #define SET_DENS_AND_BLK 0x10001
 172
 173 static DEFINE_RWLOCK(st_dev_arr_lock);
 174
 175 static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
 176 static int st_max_sg_segs = ST_MAX_SG;
 177
 178 static struct scsi_tape **scsi_tapes = NULL;
 179
 180 static int modes_defined;
 181
 182 static struct st_buffer *new_tape_buffer(int, int, int);
 183 static int enlarge_buffer(struct st_buffer *, int, int);
 184 static void normalize_buffer(struct st_buffer *);
 185 static int append_to_buffer(const char __user *, struct st_buffer *, int);
 186 static int from_buffer(struct st_buffer *, char __user *, int);
 187 static void move_buffer_data(struct st_buffer *, int);
 188 static void buf_to_sg(struct st_buffer *, unsigned int);
 189
 190 static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
 191                               unsigned long, size_t, int);
 192 static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
 193
 194 static int st_probe(struct device *);
 195 static int st_remove(struct device *);
 196
 197 static void do_create_driverfs_files(void);
 198 static void do_remove_driverfs_files(void);
 199 static void do_create_class_files(struct scsi_tape *, int, int);
 200
 201 static struct scsi_driver st_template = {
 202         .owner                  = THIS_MODULE,
 203         .gendrv = {
 204                 .name           = "st",
 205                 .probe          = st_probe,
 206                 .remove         = st_remove,
 207         },
 208 };
 209
 210 static int st_compression(struct scsi_tape *, int);
 211
 212 static int find_partition(struct scsi_tape *);
 213 static int switch_partition(struct scsi_tape *);
 214
 215 static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
 216
 217 static void scsi_tape_release(struct kref *);
 218
 219 #define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
 220
 221 static DEFINE_MUTEX(st_ref_mutex);
 222
 223 \f
 224 #include "osst_detect.h"
 225 #ifndef SIGS_FROM_OSST
 226 #define SIGS_FROM_OSST \
 227         {"OnStream", "SC-", "", "osst"}, \
 228         {"OnStream", "DI-", "", "osst"}, \
 229         {"OnStream", "DP-", "", "osst"}, \
 230         {"OnStream", "USB", "", "osst"}, \
 231         {"OnStream", "FW-", "", "osst"}
 232 #endif
 233
 234 static struct scsi_tape *scsi_tape_get(int dev)
 235 {
 236         struct scsi_tape *STp = NULL;
 237
 238         mutex_lock(&st_ref_mutex);
 239         write_lock(&st_dev_arr_lock);
 240
 241         if (dev < st_dev_max && scsi_tapes != NULL)
 242                 STp = scsi_tapes[dev];
 243         if (!STp) goto out;
 244
 245         kref_get(&STp->kref);
 246
 247         if (!STp->device)
 248                 goto out_put;
 249
 250         if (scsi_device_get(STp->device))
 251                 goto out_put;
 252
 253         goto out;
 254
 255 out_put:
 256         kref_put(&STp->kref, scsi_tape_release);
 257         STp = NULL;
 258 out:
 259         write_unlock(&st_dev_arr_lock);
 260         mutex_unlock(&st_ref_mutex);
 261         return STp;
 262 }
 263
 264 static void scsi_tape_put(struct scsi_tape *STp)
 265 {
 266         struct scsi_device *sdev = STp->device;
 267
 268         mutex_lock(&st_ref_mutex);
 269         kref_put(&STp->kref, scsi_tape_release);
 270         scsi_device_put(sdev);
 271         mutex_unlock(&st_ref_mutex);
 272 }
 273
 274 struct st_reject_data {
 275         char *vendor;
 276         char *model;
 277         char *rev;
 278         char *driver_hint; /* Name of the correct driver, NULL if unknown */
 279 };
 280
 281 static struct st_reject_data reject_list[] = {
 282         /* {"XXX", "Yy-", "", NULL},  example */
 283         SIGS_FROM_OSST,
 284         {NULL, }};
 285
 286 /* If the device signature is on the list of incompatible drives, the
 287    function returns a pointer to the name of the correct driver (if known) */
 288 static char * st_incompatible(struct scsi_device* SDp)
 289 {
 290         struct st_reject_data *rp;
 291
 292         for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
 293                 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
 294                     !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
 295                     !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
 296                         if (rp->driver_hint)
 297                                 return rp->driver_hint;
 298                         else
 299                                 return "unknown";
 300                 }
 301         return NULL;
 302 }
 303 \f
 304
 305 static inline char *tape_name(struct scsi_tape *tape)
 306 {
 307         return tape->disk->disk_name;
 308 }
 309
 310
 311 static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
 312 {
 313         const u8 *ucp;
 314         const u8 *sense = SRpnt->sense;
 315
 316         s->have_sense = scsi_normalize_sense(SRpnt->sense,
 317                                 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
 318         s->flags = 0;
 319
 320         if (s->have_sense) {
 321                 s->deferred = 0;
 322                 s->remainder_valid =
 323                         scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
 324                 switch (sense[0] & 0x7f) {
 325                 case 0x71:
 326                         s->deferred = 1;
 327                 case 0x70:
 328                         s->fixed_format = 1;
 329                         s->flags = sense[2] & 0xe0;
 330                         break;
 331                 case 0x73:
 332                         s->deferred = 1;
 333                 case 0x72:
 334                         s->fixed_format = 0;
 335                         ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
 336                         s->flags = ucp ? (ucp[3] & 0xe0) : 0;
 337                         break;
 338                 }
 339         }
 340 }
 341
 342
 343 /* Convert the result to success code */
 344 static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
 345 {
 346         int result = SRpnt->result;
 347         u8 scode;
 348         DEB(const char *stp;)
 349         char *name = tape_name(STp);
 350         struct st_cmdstatus *cmdstatp;
 351
 352         if (!result)
 353                 return 0;
 354
 355         cmdstatp = &STp->buffer->cmdstat;
 356         st_analyze_sense(SRpnt, cmdstatp);
 357
 358         if (cmdstatp->have_sense)
 359                 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
 360         else
 361                 scode = 0;
 362
 363         DEB(
 364         if (debugging) {
 365                 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
 366                        name, result,
 367                        SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
 368                        SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
 369                 if (cmdstatp->have_sense)
 370                          __scsi_print_sense("st", SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
 371         } ) /* end DEB */
 372         if (!debugging) { /* Abnormal conditions for tape */
 373                 if (!cmdstatp->have_sense)
 374                         printk(KERN_WARNING
 375                                "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
 376                                name, result, suggestion(result),
 377                                driver_byte(result) & DRIVER_MASK, host_byte(result));
 378                 else if (cmdstatp->have_sense &&
 379                          scode != NO_SENSE &&
 380                          scode != RECOVERED_ERROR &&
 381                          /* scode != UNIT_ATTENTION && */
 382                          scode != BLANK_CHECK &&
 383                          scode != VOLUME_OVERFLOW &&
 384                          SRpnt->cmd[0] != MODE_SENSE &&
 385                          SRpnt->cmd[0] != TEST_UNIT_READY) {
 386                                 printk(KERN_WARNING "%s: Error with sense data: ", name);
 387                                 __scsi_print_sense("st", SRpnt->sense,
 388                                                    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)
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 succesfully 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->in_use = 1;
3602         tb->dma = need_dma;
3603         tb->buffer_size = got;
3604
3605         return tb;
3606 }
3607
3608
3609 /* Try to allocate enough space in the tape buffer */
3610 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3611 {
3612         int segs, nbr, max_segs, b_size, order, got;
3613         gfp_t priority;
3614
3615         if (new_size <= STbuffer->buffer_size)
3616                 return 1;
3617
3618         if (STbuffer->buffer_size <= PAGE_SIZE)
3619                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3620
3621         max_segs = STbuffer->use_sg;
3622         nbr = max_segs - STbuffer->frp_segs;
3623         if (nbr <= 0)
3624                 return 0;
3625
3626         priority = GFP_KERNEL | __GFP_NOWARN;
3627         if (need_dma)
3628                 priority |= GFP_DMA;
3629         for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3630              b_size < new_size - STbuffer->buffer_size;
3631              order++, b_size *= 2)
3632                 ;  /* empty */
3633
3634         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3635              segs < max_segs && got < new_size;) {
3636                 STbuffer->frp[segs].page = alloc_pages(priority, order);
3637                 if (STbuffer->frp[segs].page == NULL) {
3638                         if (new_size - got <= (max_segs - segs) * b_size / 2) {
3639                                 b_size /= 2; /* Large enough for the rest of the buffers */
3640                                 order--;
3641                                 continue;
3642                         }
3643                         DEB(STbuffer->buffer_size = got);
3644                         normalize_buffer(STbuffer);
3645                         return 0;
3646                 }
3647                 STbuffer->frp[segs].length = b_size;
3648                 STbuffer->frp_segs += 1;
3649                 got += b_size;
3650                 STbuffer->buffer_size = got;
3651                 segs++;
3652         }
3653         STbuffer->b_data = page_address(STbuffer->frp[0].page);
3654
3655         return 1;
3656 }
3657
3658
3659 /* Release the extra buffer */
3660 static void normalize_buffer(struct st_buffer * STbuffer)
3661 {
3662         int i, order;
3663
3664         for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3665                 order = get_order(STbuffer->frp[i].length);
3666                 __free_pages(STbuffer->frp[i].page, order);
3667                 STbuffer->buffer_size -= STbuffer->frp[i].length;
3668         }
3669         STbuffer->frp_segs = STbuffer->orig_frp_segs;
3670         STbuffer->frp_sg_current = 0;
3671         STbuffer->sg_segs = 0;
3672 }
3673
3674
3675 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3676    negative error code. */
3677 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3678 {
3679         int i, cnt, res, offset;
3680
3681         for (i = 0, offset = st_bp->buffer_bytes;
3682              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3683                 offset -= st_bp->frp[i].length;
3684         if (i == st_bp->frp_segs) {     /* Should never happen */
3685                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3686                 return (-EIO);
3687         }
3688         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3689                 cnt = st_bp->frp[i].length - offset < do_count ?
3690                     st_bp->frp[i].length - offset : do_count;
3691                 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3692                 if (res)
3693                         return (-EFAULT);
3694                 do_count -= cnt;
3695                 st_bp->buffer_bytes += cnt;
3696                 ubp += cnt;
3697                 offset = 0;
3698         }
3699         if (do_count) /* Should never happen */
3700                 return (-EIO);
3701
3702         return 0;
3703 }
3704
3705
3706 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3707    negative error code. */
3708 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3709 {
3710         int i, cnt, res, offset;
3711
3712         for (i = 0, offset = st_bp->read_pointer;
3713              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3714                 offset -= st_bp->frp[i].length;
3715         if (i == st_bp->frp_segs) {     /* Should never happen */
3716                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3717                 return (-EIO);
3718         }
3719         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3720                 cnt = st_bp->frp[i].length - offset < do_count ?
3721                     st_bp->frp[i].length - offset : do_count;
3722                 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3723                 if (res)
3724                         return (-EFAULT);
3725                 do_count -= cnt;
3726                 st_bp->buffer_bytes -= cnt;
3727                 st_bp->read_pointer += cnt;
3728                 ubp += cnt;
3729                 offset = 0;
3730         }
3731         if (do_count) /* Should never happen */
3732                 return (-EIO);
3733
3734         return 0;
3735 }
3736
3737
3738 /* Move data towards start of buffer */
3739 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3740 {
3741         int src_seg, dst_seg, src_offset = 0, dst_offset;
3742         int count, total;
3743
3744         if (offset == 0)
3745                 return;
3746
3747         total=st_bp->buffer_bytes - offset;
3748         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3749                 src_offset = offset;
3750                 if (src_offset < st_bp->frp[src_seg].length)
3751                         break;
3752                 offset -= st_bp->frp[src_seg].length;
3753         }
3754
3755         st_bp->buffer_bytes = st_bp->read_pointer = total;
3756         for (dst_seg=dst_offset=0; total > 0; ) {
3757                 count = min(st_bp->frp[dst_seg].length - dst_offset,
3758                             st_bp->frp[src_seg].length - src_offset);
3759                 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3760                         page_address(st_bp->frp[src_seg].page) + src_offset, count);
3761                 src_offset += count;
3762                 if (src_offset >= st_bp->frp[src_seg].length) {
3763                         src_seg++;
3764                         src_offset = 0;
3765                 }
3766                 dst_offset += count;
3767                 if (dst_offset >= st_bp->frp[dst_seg].length) {
3768                         dst_seg++;
3769                         dst_offset = 0;
3770                 }
3771                 total -= count;
3772         }
3773 }
3774
3775
3776 /* Fill the s/g list up to the length required for this transfer */
3777 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3778 {
3779         int i;
3780         unsigned int count;
3781         struct scatterlist *sg;
3782         struct st_buf_fragment *frp;
3783
3784         if (length == STbp->frp_sg_current)
3785                 return;   /* work already done */
3786
3787         sg = &(STbp->sg[0]);
3788         frp = STbp->frp;
3789         for (i=count=0; count < length; i++) {
3790                 sg[i].page = frp[i].page;
3791                 if (length - count > frp[i].length)
3792                         sg[i].length = frp[i].length;
3793                 else
3794                         sg[i].length = length - count;
3795                 count += sg[i].length;
3796                 sg[i].offset = 0;
3797         }
3798         STbp->sg_segs = i;
3799         STbp->frp_sg_current = length;
3800 }
3801
3802
3803 /* Validate the options from command line or module parameters */
3804 static void validate_options(void)
3805 {
3806         if (buffer_kbs > 0)
3807                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3808         if (max_sg_segs >= ST_FIRST_SG)
3809                 st_max_sg_segs = max_sg_segs;
3810 }
3811
3812 #ifndef MODULE
3813 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3814  */
3815 static int __init st_setup(char *str)
3816 {
3817         int i, len, ints[5];
3818         char *stp;
3819
3820         stp = get_options(str, ARRAY_SIZE(ints), ints);
3821
3822         if (ints[0] > 0) {
3823                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3824                         if (parms[i].val)
3825                                 *parms[i].val = ints[i + 1];
3826         } else {
3827                 while (stp != NULL) {
3828                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3829                                 len = strlen(parms[i].name);
3830                                 if (!strncmp(stp, parms[i].name, len) &&
3831                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3832                                         if (parms[i].val)
3833                                                 *parms[i].val =
3834                                                         simple_strtoul(stp + len + 1, NULL, 0);
3835                                         else
3836                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3837                                                        parms[i].name);
3838                                         break;
3839                                 }
3840                         }
3841                         if (i >= sizeof(parms) / sizeof(struct st_dev_parm))
3842                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3843                                         stp);
3844                         stp = strchr(stp, ',');
3845                         if (stp)
3846                                 stp++;
3847                 }
3848         }
3849
3850         validate_options();
3851
3852         return 1;
3853 }
3854
3855 __setup("st=", st_setup);
3856
3857 #endif
3858
3859 static struct file_operations st_fops =
3860 {
3861         .owner =        THIS_MODULE,
3862         .read =         st_read,
3863         .write =        st_write,
3864         .ioctl =        st_ioctl,
3865 #ifdef CONFIG_COMPAT
3866         .compat_ioctl = st_compat_ioctl,
3867 #endif
3868         .open =         st_open,
3869         .flush =        st_flush,
3870         .release =      st_release,
3871 };
3872
3873 static int st_probe(struct device *dev)
3874 {
3875         struct scsi_device *SDp = to_scsi_device(dev);
3876         struct gendisk *disk = NULL;
3877         struct cdev *cdev = NULL;
3878         struct scsi_tape *tpnt = NULL;
3879         struct st_modedef *STm;
3880         struct st_partstat *STps;
3881         struct st_buffer *buffer;
3882         int i, j, mode, dev_num, error;
3883         char *stp;
3884
3885         if (SDp->type != TYPE_TAPE)
3886                 return -ENODEV;
3887         if ((stp = st_incompatible(SDp))) {
3888                 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3889                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3890                 return -ENODEV;
3891         }
3892
3893         i = min(SDp->request_queue->max_hw_segments,
3894                 SDp->request_queue->max_phys_segments);
3895         if (st_max_sg_segs < i)
3896                 i = st_max_sg_segs;
3897         buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3898         if (buffer == NULL) {
3899                 printk(KERN_ERR
3900                        "st: Can't allocate new tape buffer. Device not attached.\n");
3901                 goto out;
3902         }
3903
3904         disk = alloc_disk(1);
3905         if (!disk) {
3906                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3907                 goto out_buffer_free;
3908         }
3909
3910         write_lock(&st_dev_arr_lock);
3911         if (st_nr_dev >= st_dev_max) {
3912                 struct scsi_tape **tmp_da;
3913                 int tmp_dev_max;
3914
3915                 tmp_dev_max = max(st_nr_dev * 2, 8);
3916                 if (tmp_dev_max > ST_MAX_TAPES)
3917                         tmp_dev_max = ST_MAX_TAPES;
3918                 if (tmp_dev_max <= st_nr_dev) {
3919                         write_unlock(&st_dev_arr_lock);
3920                         printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3921                                ST_MAX_TAPES);
3922                         goto out_put_disk;
3923                 }
3924
3925                 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
3926                 if (tmp_da == NULL) {
3927                         write_unlock(&st_dev_arr_lock);
3928                         printk(KERN_ERR "st: Can't extend device array.\n");
3929                         goto out_put_disk;
3930                 }
3931
3932                 if (scsi_tapes != NULL) {
3933                         memcpy(tmp_da, scsi_tapes,
3934                                st_dev_max * sizeof(struct scsi_tape *));
3935                         kfree(scsi_tapes);
3936                 }
3937                 scsi_tapes = tmp_da;
3938
3939                 st_dev_max = tmp_dev_max;
3940         }
3941
3942         for (i = 0; i < st_dev_max; i++)
3943                 if (scsi_tapes[i] == NULL)
3944                         break;
3945         if (i >= st_dev_max)
3946                 panic("scsi_devices corrupt (st)");
3947
3948         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
3949         if (tpnt == NULL) {
3950                 write_unlock(&st_dev_arr_lock);
3951                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3952                 goto out_put_disk;
3953         }
3954         kref_init(&tpnt->kref);
3955         tpnt->disk = disk;
3956         sprintf(disk->disk_name, "st%d", i);
3957         disk->private_data = &tpnt->driver;
3958         disk->queue = SDp->request_queue;
3959         tpnt->driver = &st_template;
3960         scsi_tapes[i] = tpnt;
3961         dev_num = i;
3962
3963         tpnt->device = SDp;
3964         if (SDp->scsi_level <= 2)
3965                 tpnt->tape_type = MT_ISSCSI1;
3966         else
3967                 tpnt->tape_type = MT_ISSCSI2;
3968
3969         tpnt->buffer = buffer;
3970         tpnt->buffer->last_SRpnt = NULL;
3971
3972         tpnt->inited = 0;
3973         tpnt->dirty = 0;
3974         tpnt->in_use = 0;
3975         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
3976         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
3977         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
3978         tpnt->density = 0;
3979         tpnt->do_auto_lock = ST_AUTO_LOCK;
3980         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
3981         tpnt->can_partitions = 0;
3982         tpnt->two_fm = ST_TWO_FM;
3983         tpnt->fast_mteom = ST_FAST_MTEOM;
3984         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
3985         tpnt->immediate = ST_NOWAIT;
3986         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
3987         tpnt->partition = 0;
3988         tpnt->new_partition = 0;
3989         tpnt->nbr_partitions = 0;
3990         tpnt->device->timeout = ST_TIMEOUT;
3991         tpnt->long_timeout = ST_LONG_TIMEOUT;
3992         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
3993
3994         for (i = 0; i < ST_NBR_MODES; i++) {
3995                 STm = &(tpnt->modes[i]);
3996                 STm->defined = 0;
3997                 STm->sysv = ST_SYSV;
3998                 STm->defaults_for_writes = 0;
3999                 STm->do_async_writes = ST_ASYNC_WRITES;
4000                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4001                 STm->do_read_ahead = ST_READ_AHEAD;
4002                 STm->default_compression = ST_DONT_TOUCH;
4003                 STm->default_blksize = (-1);    /* No forced size */
4004                 STm->default_density = (-1);    /* No forced density */
4005         }
4006
4007         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4008                 STps = &(tpnt->ps[i]);
4009                 STps->rw = ST_IDLE;
4010                 STps->eof = ST_NOEOF;
4011                 STps->at_sm = 0;
4012                 STps->last_block_valid = 0;
4013                 STps->drv_block = (-1);
4014                 STps->drv_file = (-1);
4015         }
4016
4017         tpnt->current_mode = 0;
4018         tpnt->modes[0].defined = 1;
4019
4020         tpnt->density_changed = tpnt->compression_changed =
4021             tpnt->blksize_changed = 0;
4022         init_MUTEX(&tpnt->lock);
4023
4024         st_nr_dev++;
4025         write_unlock(&st_dev_arr_lock);
4026
4027         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4028                 STm = &(tpnt->modes[mode]);
4029                 for (j=0; j < 2; j++) {
4030                         cdev = cdev_alloc();
4031                         if (!cdev) {
4032                                 printk(KERN_ERR
4033                                        "st%d: out of memory. Device not attached.\n",
4034                                        dev_num);
4035                                 goto out_free_tape;
4036                         }
4037                         cdev->owner = THIS_MODULE;
4038                         cdev->ops = &st_fops;
4039
4040                         error = cdev_add(cdev,
4041                                          MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4042                                          1);
4043                         if (error) {
4044                                 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4045                                        dev_num, j ? "non" : "auto", mode);
4046                                 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4047                                 goto out_free_tape;
4048                         }
4049                         STm->cdevs[j] = cdev;
4050
4051                 }
4052                 do_create_class_files(tpnt, dev_num, mode);
4053         }
4054
4055         sdev_printk(KERN_WARNING, SDp,
4056                     "Attached scsi tape %s", tape_name(tpnt));
4057         printk(KERN_WARNING "%s: try direct i/o: %s (alignment %d B)\n",
4058                tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4059                queue_dma_alignment(SDp->request_queue) + 1);
4060
4061         return 0;
4062
4063 out_free_tape:
4064         for (mode=0; mode < ST_NBR_MODES; mode++) {
4065                 STm = &(tpnt->modes[mode]);
4066                 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4067                                   "tape");
4068                 for (j=0; j < 2; j++) {
4069                         if (STm->cdevs[j]) {
4070                                 if (cdev == STm->cdevs[j])
4071                                         cdev = NULL;
4072                                 class_device_destroy(st_sysfs_class,
4073                                                      MKDEV(SCSI_TAPE_MAJOR,
4074                                                            TAPE_MINOR(i, mode, j)));
4075                                 cdev_del(STm->cdevs[j]);
4076                         }
4077                 }
4078         }
4079         if (cdev)
4080                 cdev_del(cdev);
4081         write_lock(&st_dev_arr_lock);
4082         scsi_tapes[dev_num] = NULL;
4083         st_nr_dev--;
4084         write_unlock(&st_dev_arr_lock);
4085 out_put_disk:
4086         put_disk(disk);
4087         kfree(tpnt);
4088 out_buffer_free:
4089         kfree(buffer);
4090 out:
4091         return -ENODEV;
4092 };
4093
4094
4095 static int st_remove(struct device *dev)
4096 {
4097         struct scsi_device *SDp = to_scsi_device(dev);
4098         struct scsi_tape *tpnt;
4099         int i, j, mode;
4100
4101         write_lock(&st_dev_arr_lock);
4102         for (i = 0; i < st_dev_max; i++) {
4103                 tpnt = scsi_tapes[i];
4104                 if (tpnt != NULL && tpnt->device == SDp) {
4105                         scsi_tapes[i] = NULL;
4106                         st_nr_dev--;
4107                         write_unlock(&st_dev_arr_lock);
4108                         sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4109                                           "tape");
4110                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4111                                 for (j=0; j < 2; j++) {
4112                                         class_device_destroy(st_sysfs_class,
4113                                                              MKDEV(SCSI_TAPE_MAJOR,
4114                                                                    TAPE_MINOR(i, mode, j)));
4115                                         cdev_del(tpnt->modes[mode].cdevs[j]);
4116                                         tpnt->modes[mode].cdevs[j] = NULL;
4117                                 }
4118                         }
4119
4120                         mutex_lock(&st_ref_mutex);
4121                         kref_put(&tpnt->kref, scsi_tape_release);
4122                         mutex_unlock(&st_ref_mutex);
4123                         return 0;
4124                 }
4125         }
4126
4127         write_unlock(&st_dev_arr_lock);
4128         return 0;
4129 }
4130
4131 /**
4132  *      scsi_tape_release - Called to free the Scsi_Tape structure
4133  *      @kref: pointer to embedded kref
4134  *
4135  *      st_ref_mutex must be held entering this routine.  Because it is
4136  *      called on last put, you should always use the scsi_tape_get()
4137  *      scsi_tape_put() helpers which manipulate the semaphore directly
4138  *      and never do a direct kref_put().
4139  **/
4140 static void scsi_tape_release(struct kref *kref)
4141 {
4142         struct scsi_tape *tpnt = to_scsi_tape(kref);
4143         struct gendisk *disk = tpnt->disk;
4144
4145         tpnt->device = NULL;
4146
4147         if (tpnt->buffer) {
4148                 tpnt->buffer->orig_frp_segs = 0;
4149                 normalize_buffer(tpnt->buffer);
4150                 kfree(tpnt->buffer);
4151         }
4152
4153         disk->private_data = NULL;
4154         put_disk(disk);
4155         kfree(tpnt);
4156         return;
4157 }
4158
4159 static int __init init_st(void)
4160 {
4161         validate_options();
4162
4163         printk(KERN_INFO
4164                 "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4165                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4166
4167         st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4168         if (IS_ERR(st_sysfs_class)) {
4169                 st_sysfs_class = NULL;
4170                 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4171                 return 1;
4172         }
4173
4174         if (!register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4175                                     ST_MAX_TAPE_ENTRIES, "st")) {
4176                 if (scsi_register_driver(&st_template.gendrv) == 0) {
4177                         do_create_driverfs_files();
4178                         return 0;
4179                 }
4180                 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4181                                          ST_MAX_TAPE_ENTRIES);
4182         }
4183         class_destroy(st_sysfs_class);
4184
4185         printk(KERN_ERR "Unable to get major %d for SCSI tapes\n", SCSI_TAPE_MAJOR);
4186         return 1;
4187 }
4188
4189 static void __exit exit_st(void)
4190 {
4191         do_remove_driverfs_files();
4192         scsi_unregister_driver(&st_template.gendrv);
4193         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4194                                  ST_MAX_TAPE_ENTRIES);
4195         class_destroy(st_sysfs_class);
4196         kfree(scsi_tapes);
4197         printk(KERN_INFO "st: Unloaded.\n");
4198 }
4199
4200 module_init(init_st);
4201 module_exit(exit_st);
4202
4203
4204 /* The sysfs driver interface. Read-only at the moment */
4205 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4206 {
4207         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4208 }
4209 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4210
4211 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4212 {
4213         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4214 }
4215 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4216
4217 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4218 {
4219         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4220 }
4221 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4222
4223 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4224 {
4225         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4226 }
4227 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4228
4229 static void do_create_driverfs_files(void)
4230 {
4231         struct device_driver *driverfs = &st_template.gendrv;
4232
4233         driver_create_file(driverfs, &driver_attr_try_direct_io);
4234         driver_create_file(driverfs, &driver_attr_fixed_buffer_size);
4235         driver_create_file(driverfs, &driver_attr_max_sg_segs);
4236         driver_create_file(driverfs, &driver_attr_version);
4237 }
4238
4239 static void do_remove_driverfs_files(void)
4240 {
4241         struct device_driver *driverfs = &st_template.gendrv;
4242
4243         driver_remove_file(driverfs, &driver_attr_version);
4244         driver_remove_file(driverfs, &driver_attr_max_sg_segs);
4245         driver_remove_file(driverfs, &driver_attr_fixed_buffer_size);
4246         driver_remove_file(driverfs, &driver_attr_try_direct_io);
4247 }
4248
4249
4250 /* The sysfs simple class interface */
4251 static ssize_t st_defined_show(struct class_device *class_dev, char *buf)
4252 {
4253         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4254         ssize_t l = 0;
4255
4256         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4257         return l;
4258 }
4259
4260 CLASS_DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4261
4262 static ssize_t st_defblk_show(struct class_device *class_dev, char *buf)
4263 {
4264         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4265         ssize_t l = 0;
4266
4267         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4268         return l;
4269 }
4270
4271 CLASS_DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4272
4273 static ssize_t st_defdensity_show(struct class_device *class_dev, char *buf)
4274 {
4275         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4276         ssize_t l = 0;
4277         char *fmt;
4278
4279         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4280         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4281         return l;
4282 }
4283
4284 CLASS_DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4285
4286 static ssize_t st_defcompression_show(struct class_device *class_dev, char *buf)
4287 {
4288         struct st_modedef *STm = (struct st_modedef *)class_get_devdata(class_dev);
4289         ssize_t l = 0;
4290
4291         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4292         return l;
4293 }
4294
4295 CLASS_DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4296
4297 static void do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4298 {
4299         int i, rew, error;
4300         char name[10];
4301         struct class_device *st_class_member;
4302
4303         if (!st_sysfs_class)
4304                 return;
4305
4306         for (rew=0; rew < 2; rew++) {
4307                 /* Make sure that the minor numbers corresponding to the four
4308                    first modes always get the same names */
4309                 i = mode << (4 - ST_NBR_MODE_BITS);
4310                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4311                          STp->disk->disk_name, st_formats[i]);
4312                 st_class_member =
4313                         class_device_create(st_sysfs_class, NULL,
4314                                             MKDEV(SCSI_TAPE_MAJOR,
4315                                                   TAPE_MINOR(dev_num, mode, rew)),
4316                                             &STp->device->sdev_gendev, "%s", name);
4317                 if (IS_ERR(st_class_member)) {
4318                         printk(KERN_WARNING "st%d: class_device_create failed\n",
4319                                dev_num);
4320                         goto out;
4321                 }
4322                 class_set_devdata(st_class_member, &STp->modes[mode]);
4323
4324                 class_device_create_file(st_class_member,
4325                                          &class_device_attr_defined);
4326                 class_device_create_file(st_class_member,
4327                                          &class_device_attr_default_blksize);
4328                 class_device_create_file(st_class_member,
4329                                          &class_device_attr_default_density);
4330                 class_device_create_file(st_class_member,
4331                                          &class_device_attr_default_compression);
4332                 if (mode == 0 && rew == 0) {
4333                         error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4334                                                   &st_class_member->kobj,
4335                                                   "tape");
4336                         if (error) {
4337                                 printk(KERN_ERR
4338                                        "st%d: Can't create sysfs link from SCSI device.\n",
4339                                        dev_num);
4340                         }
4341                 }
4342         }
4343  out:
4344         return;
4345 }
4346
4347 /* The following functions may be useful for a larger audience. */
4348 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4349                               unsigned long uaddr, size_t count, int rw)
4350 {
4351         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4352         unsigned long start = uaddr >> PAGE_SHIFT;
4353         const int nr_pages = end - start;
4354         int res, i, j;
4355         struct page **pages;
4356
4357         /* User attempted Overflow! */
4358         if ((uaddr + count) < uaddr)
4359                 return -EINVAL;
4360
4361         /* Too big */
4362         if (nr_pages > max_pages)
4363                 return -ENOMEM;
4364
4365         /* Hmm? */
4366         if (count == 0)
4367                 return 0;
4368
4369         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4370                 return -ENOMEM;
4371
4372         /* Try to fault in all of the necessary pages */
4373         down_read(&current->mm->mmap_sem);
4374         /* rw==READ means read from drive, write into memory area */
4375         res = get_user_pages(
4376                 current,
4377                 current->mm,
4378                 uaddr,
4379                 nr_pages,
4380                 rw == READ,
4381                 0, /* don't force */
4382                 pages,
4383                 NULL);
4384         up_read(&current->mm->mmap_sem);
4385
4386         /* Errors and no page mapped should return here */
4387         if (res < nr_pages)
4388                 goto out_unmap;
4389
4390         for (i=0; i < nr_pages; i++) {
4391                 /* FIXME: flush superflous for rw==READ,
4392                  * probably wrong function for rw==WRITE
4393                  */
4394                 flush_dcache_page(pages[i]);
4395         }
4396
4397         /* Populate the scatter/gather list */
4398         sgl[0].page = pages[0];
4399         sgl[0].offset = uaddr & ~PAGE_MASK;
4400         if (nr_pages > 1) {
4401                 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4402                 count -= sgl[0].length;
4403                 for (i=1; i < nr_pages ; i++) {
4404                         sgl[i].offset = 0;
4405                         sgl[i].page = pages[i];
4406                         sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
4407                         count -= PAGE_SIZE;
4408                 }
4409         }
4410         else {
4411                 sgl[0].length = count;
4412         }
4413
4414         kfree(pages);
4415         return nr_pages;
4416
4417  out_unmap:
4418         if (res > 0) {
4419                 for (j=0; j < res; j++)
4420                         page_cache_release(pages[j]);
4421                 res = 0;
4422         }
4423         kfree(pages);
4424         return res;
4425 }
4426
4427
4428 /* And unmap them... */
4429 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4430                                 int dirtied)
4431 {
4432         int i;
4433
4434         for (i=0; i < nr_pages; i++) {
4435                 struct page *page = sgl[i].page;
4436
4437                 if (dirtied)
4438                         SetPageDirty(page);
4439                 /* FIXME: cache flush missing for rw==READ
4440                  * FIXME: call the correct reference counting function
4441                  */
4442                 page_cache_release(page);
4443         }
4444
4445         return 0;
4446 }