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