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

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