SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/st.c

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