drivers/scsi/st.c

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