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