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