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_allocate_request(STp);
2519         if (!SRpnt)
2520                 return STp->buffer->syscall_result;
2521
2522         retval = st_scsi_kern_execute(SRpnt, cmd, DMA_NONE, NULL, 0, timeout,
2523                                       MAX_RETRIES);
2524         if (retval)
2525                 goto out;
2526
2527         retval = (STp->buffer)->syscall_result;
2528
2529         if (!retval) {  /* SCSI command successful */
2530
2531                 if (!load_code) {
2532                         STp->rew_at_close = 0;
2533                         STp->ready = ST_NO_TAPE;
2534                 }
2535                 else {
2536                         STp->rew_at_close = STp->autorew_dev;
2537                         retval = check_tape(STp, filp);
2538                         if (retval > 0)
2539                                 retval = 0;
2540                 }
2541         }
2542         else {
2543                 STps = &(STp->ps[STp->partition]);
2544                 STps->drv_file = STps->drv_block = (-1);
2545         }
2546 out:
2547         st_release_request(SRpnt);
2548
2549         return retval;
2550 }
2551 \f
2552 #if DEBUG
2553 #define ST_DEB_FORWARD  0
2554 #define ST_DEB_BACKWARD 1
2555 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2556 {
2557         s32 sc;
2558
2559         sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2560         sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2561         if (direction)
2562                 sc = -sc;
2563         printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2564                direction ? "backward" : "forward", sc, units);
2565 }
2566 #endif
2567
2568
2569 /* Internal ioctl function */
2570 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2571 {
2572         int timeout;
2573         long ltmp;
2574         int ioctl_result;
2575         int chg_eof = 1;
2576         unsigned char cmd[MAX_COMMAND_SIZE];
2577         struct st_request *SRpnt;
2578         struct st_partstat *STps;
2579         int fileno, blkno, at_sm, undone;
2580         int datalen = 0, direction = DMA_NONE;
2581         char *name = tape_name(STp);
2582
2583         WARN_ON(STp->buffer->do_dio != 0);
2584         if (STp->ready != ST_READY) {
2585                 if (STp->ready == ST_NO_TAPE)
2586                         return (-ENOMEDIUM);
2587                 else
2588                         return (-EIO);
2589         }
2590         timeout = STp->long_timeout;
2591         STps = &(STp->ps[STp->partition]);
2592         fileno = STps->drv_file;
2593         blkno = STps->drv_block;
2594         at_sm = STps->at_sm;
2595
2596         memset(cmd, 0, MAX_COMMAND_SIZE);
2597         switch (cmd_in) {
2598         case MTFSFM:
2599                 chg_eof = 0;    /* Changed from the FSF after this */
2600         case MTFSF:
2601                 cmd[0] = SPACE;
2602                 cmd[1] = 0x01;  /* Space FileMarks */
2603                 cmd[2] = (arg >> 16);
2604                 cmd[3] = (arg >> 8);
2605                 cmd[4] = arg;
2606                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2607                 if (fileno >= 0)
2608                         fileno += arg;
2609                 blkno = 0;
2610                 at_sm &= (arg == 0);
2611                 break;
2612         case MTBSFM:
2613                 chg_eof = 0;    /* Changed from the FSF after this */
2614         case MTBSF:
2615                 cmd[0] = SPACE;
2616                 cmd[1] = 0x01;  /* Space FileMarks */
2617                 ltmp = (-arg);
2618                 cmd[2] = (ltmp >> 16);
2619                 cmd[3] = (ltmp >> 8);
2620                 cmd[4] = ltmp;
2621                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2622                 if (fileno >= 0)
2623                         fileno -= arg;
2624                 blkno = (-1);   /* We can't know the block number */
2625                 at_sm &= (arg == 0);
2626                 break;
2627         case MTFSR:
2628                 cmd[0] = SPACE;
2629                 cmd[1] = 0x00;  /* Space Blocks */
2630                 cmd[2] = (arg >> 16);
2631                 cmd[3] = (arg >> 8);
2632                 cmd[4] = arg;
2633                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2634                 if (blkno >= 0)
2635                         blkno += arg;
2636                 at_sm &= (arg == 0);
2637                 break;
2638         case MTBSR:
2639                 cmd[0] = SPACE;
2640                 cmd[1] = 0x00;  /* Space Blocks */
2641                 ltmp = (-arg);
2642                 cmd[2] = (ltmp >> 16);
2643                 cmd[3] = (ltmp >> 8);
2644                 cmd[4] = ltmp;
2645                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2646                 if (blkno >= 0)
2647                         blkno -= arg;
2648                 at_sm &= (arg == 0);
2649                 break;
2650         case MTFSS:
2651                 cmd[0] = SPACE;
2652                 cmd[1] = 0x04;  /* Space Setmarks */
2653                 cmd[2] = (arg >> 16);
2654                 cmd[3] = (arg >> 8);
2655                 cmd[4] = arg;
2656                 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2657                 if (arg != 0) {
2658                         blkno = fileno = (-1);
2659                         at_sm = 1;
2660                 }
2661                 break;
2662         case MTBSS:
2663                 cmd[0] = SPACE;
2664                 cmd[1] = 0x04;  /* Space Setmarks */
2665                 ltmp = (-arg);
2666                 cmd[2] = (ltmp >> 16);
2667                 cmd[3] = (ltmp >> 8);
2668                 cmd[4] = ltmp;
2669                 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2670                 if (arg != 0) {
2671                         blkno = fileno = (-1);
2672                         at_sm = 1;
2673                 }
2674                 break;
2675         case MTWEOF:
2676         case MTWSM:
2677                 if (STp->write_prot)
2678                         return (-EACCES);
2679                 cmd[0] = WRITE_FILEMARKS;
2680                 if (cmd_in == MTWSM)
2681                         cmd[1] = 2;
2682                 cmd[2] = (arg >> 16);
2683                 cmd[3] = (arg >> 8);
2684                 cmd[4] = arg;
2685                 timeout = STp->device->request_queue->rq_timeout;
2686                 DEBC(
2687                      if (cmd_in == MTWEOF)
2688                                printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2689                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2690                      else
2691                                 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2692                                  cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2693                 )
2694                 if (fileno >= 0)
2695                         fileno += arg;
2696                 blkno = 0;
2697                 at_sm = (cmd_in == MTWSM);
2698                 break;
2699         case MTREW:
2700                 cmd[0] = REZERO_UNIT;
2701                 if (STp->immediate) {
2702                         cmd[1] = 1;     /* Don't wait for completion */
2703                         timeout = STp->device->request_queue->rq_timeout;
2704                 }
2705                 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2706                 fileno = blkno = at_sm = 0;
2707                 break;
2708         case MTNOP:
2709                 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2710                 return 0;       /* Should do something ? */
2711                 break;
2712         case MTRETEN:
2713                 cmd[0] = START_STOP;
2714                 if (STp->immediate) {
2715                         cmd[1] = 1;     /* Don't wait for completion */
2716                         timeout = STp->device->request_queue->rq_timeout;
2717                 }
2718                 cmd[4] = 3;
2719                 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2720                 fileno = blkno = at_sm = 0;
2721                 break;
2722         case MTEOM:
2723                 if (!STp->fast_mteom) {
2724                         /* space to the end of tape */
2725                         ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2726                         fileno = STps->drv_file;
2727                         if (STps->eof >= ST_EOD_1)
2728                                 return 0;
2729                         /* The next lines would hide the number of spaced FileMarks
2730                            That's why I inserted the previous lines. I had no luck
2731                            with detecting EOM with FSF, so we go now to EOM.
2732                            Joerg Weule */
2733                 } else
2734                         fileno = (-1);
2735                 cmd[0] = SPACE;
2736                 cmd[1] = 3;
2737                 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2738                             name));
2739                 blkno = -1;
2740                 at_sm = 0;
2741                 break;
2742         case MTERASE:
2743                 if (STp->write_prot)
2744                         return (-EACCES);
2745                 cmd[0] = ERASE;
2746                 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2747                 if (STp->immediate) {
2748                         cmd[1] |= 2;    /* Don't wait for completion */
2749                         timeout = STp->device->request_queue->rq_timeout;
2750                 }
2751                 else
2752                         timeout = STp->long_timeout * 8;
2753
2754                 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2755                 fileno = blkno = at_sm = 0;
2756                 break;
2757         case MTSETBLK:          /* Set block length */
2758         case MTSETDENSITY:      /* Set tape density */
2759         case MTSETDRVBUFFER:    /* Set drive buffering */
2760         case SET_DENS_AND_BLK:  /* Set density and block size */
2761                 chg_eof = 0;
2762                 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2763                         return (-EIO);  /* Not allowed if data in buffer */
2764                 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2765                     (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2766                     STp->max_block > 0 &&
2767                     ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2768                      (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2769                         printk(KERN_WARNING "%s: Illegal block size.\n", name);
2770                         return (-EINVAL);
2771                 }
2772                 cmd[0] = MODE_SELECT;
2773                 if ((STp->use_pf & USE_PF))
2774                         cmd[1] = MODE_SELECT_PAGE_FORMAT;
2775                 cmd[4] = datalen = 12;
2776                 direction = DMA_TO_DEVICE;
2777
2778                 memset((STp->buffer)->b_data, 0, 12);
2779                 if (cmd_in == MTSETDRVBUFFER)
2780                         (STp->buffer)->b_data[2] = (arg & 7) << 4;
2781                 else
2782                         (STp->buffer)->b_data[2] =
2783                             STp->drv_buffer << 4;
2784                 (STp->buffer)->b_data[3] = 8;   /* block descriptor length */
2785                 if (cmd_in == MTSETDENSITY) {
2786                         (STp->buffer)->b_data[4] = arg;
2787                         STp->density_changed = 1;       /* At least we tried ;-) */
2788                 } else if (cmd_in == SET_DENS_AND_BLK)
2789                         (STp->buffer)->b_data[4] = arg >> 24;
2790                 else
2791                         (STp->buffer)->b_data[4] = STp->density;
2792                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2793                         ltmp = arg & MT_ST_BLKSIZE_MASK;
2794                         if (cmd_in == MTSETBLK)
2795                                 STp->blksize_changed = 1; /* At least we tried ;-) */
2796                 } else
2797                         ltmp = STp->block_size;
2798                 (STp->buffer)->b_data[9] = (ltmp >> 16);
2799                 (STp->buffer)->b_data[10] = (ltmp >> 8);
2800                 (STp->buffer)->b_data[11] = ltmp;
2801                 timeout = STp->device->request_queue->rq_timeout;
2802                 DEBC(
2803                         if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2804                                 printk(ST_DEB_MSG
2805                                        "%s: Setting block size to %d bytes.\n", name,
2806                                        (STp->buffer)->b_data[9] * 65536 +
2807                                        (STp->buffer)->b_data[10] * 256 +
2808                                        (STp->buffer)->b_data[11]);
2809                         if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2810                                 printk(ST_DEB_MSG
2811                                        "%s: Setting density code to %x.\n", name,
2812                                        (STp->buffer)->b_data[4]);
2813                         if (cmd_in == MTSETDRVBUFFER)
2814                                 printk(ST_DEB_MSG
2815                                        "%s: Setting drive buffer code to %d.\n", name,
2816                                     ((STp->buffer)->b_data[2] >> 4) & 7);
2817                 )
2818                 break;
2819         default:
2820                 return (-ENOSYS);
2821         }
2822
2823         SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2824                            timeout, MAX_RETRIES, 1);
2825         if (!SRpnt)
2826                 return (STp->buffer)->syscall_result;
2827
2828         ioctl_result = (STp->buffer)->syscall_result;
2829
2830         if (!ioctl_result) {    /* SCSI command successful */
2831                 st_release_request(SRpnt);
2832                 SRpnt = NULL;
2833                 STps->drv_block = blkno;
2834                 STps->drv_file = fileno;
2835                 STps->at_sm = at_sm;
2836
2837                 if (cmd_in == MTBSFM)
2838                         ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2839                 else if (cmd_in == MTFSFM)
2840                         ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2841
2842                 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2843                         int old_block_size = STp->block_size;
2844                         STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2845                         if (STp->block_size != 0) {
2846                                 if (old_block_size == 0)
2847                                         normalize_buffer(STp->buffer);
2848                                 (STp->buffer)->buffer_blocks =
2849                                     (STp->buffer)->buffer_size / STp->block_size;
2850                         }
2851                         (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2852                         if (cmd_in == SET_DENS_AND_BLK)
2853                                 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2854                 } else if (cmd_in == MTSETDRVBUFFER)
2855                         STp->drv_buffer = (arg & 7);
2856                 else if (cmd_in == MTSETDENSITY)
2857                         STp->density = arg;
2858
2859                 if (cmd_in == MTEOM)
2860                         STps->eof = ST_EOD;
2861                 else if (cmd_in == MTFSF)
2862                         STps->eof = ST_FM;
2863                 else if (chg_eof)
2864                         STps->eof = ST_NOEOF;
2865
2866                 if (cmd_in == MTWEOF)
2867                         STps->rw = ST_IDLE;
2868         } else { /* SCSI command was not completely successful. Don't return
2869                     from this block without releasing the SCSI command block! */
2870                 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2871
2872                 if (cmdstatp->flags & SENSE_EOM) {
2873                         if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2874                             cmd_in != MTBSR && cmd_in != MTBSS)
2875                                 STps->eof = ST_EOM_OK;
2876                         STps->drv_block = 0;
2877                 }
2878
2879                 if (cmdstatp->remainder_valid)
2880                         undone = (int)cmdstatp->uremainder64;
2881                 else
2882                         undone = 0;
2883
2884                 if (cmd_in == MTWEOF &&
2885                     cmdstatp->have_sense &&
2886                     (cmdstatp->flags & SENSE_EOM)) {
2887                         if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2888                             cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2889                                 ioctl_result = 0;       /* EOF(s) written successfully at EOM */
2890                                 STps->eof = ST_NOEOF;
2891                         } else {  /* Writing EOF(s) failed */
2892                                 if (fileno >= 0)
2893                                         fileno -= undone;
2894                                 if (undone < arg)
2895                                         STps->eof = ST_NOEOF;
2896                         }
2897                         STps->drv_file = fileno;
2898                 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2899                         if (fileno >= 0)
2900                                 STps->drv_file = fileno - undone;
2901                         else
2902                                 STps->drv_file = fileno;
2903                         STps->drv_block = -1;
2904                         STps->eof = ST_NOEOF;
2905                 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2906                         if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2907                                 undone = (-undone);
2908                         if (STps->drv_file >= 0)
2909                                 STps->drv_file = fileno + undone;
2910                         STps->drv_block = 0;
2911                         STps->eof = ST_NOEOF;
2912                 } else if (cmd_in == MTFSR) {
2913                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2914                                 if (STps->drv_file >= 0)
2915                                         STps->drv_file++;
2916                                 STps->drv_block = 0;
2917                                 STps->eof = ST_FM;
2918                         } else {
2919                                 if (blkno >= undone)
2920                                         STps->drv_block = blkno - undone;
2921                                 else
2922                                         STps->drv_block = (-1);
2923                                 STps->eof = ST_NOEOF;
2924                         }
2925                 } else if (cmd_in == MTBSR) {
2926                         if (cmdstatp->flags & SENSE_FMK) {      /* Hit filemark */
2927                                 STps->drv_file--;
2928                                 STps->drv_block = (-1);
2929                         } else {
2930                                 if (arg > 0 && undone < 0)  /* Some drives get this wrong */
2931                                         undone = (-undone);
2932                                 if (STps->drv_block >= 0)
2933                                         STps->drv_block = blkno + undone;
2934                         }
2935                         STps->eof = ST_NOEOF;
2936                 } else if (cmd_in == MTEOM) {
2937                         STps->drv_file = (-1);
2938                         STps->drv_block = (-1);
2939                         STps->eof = ST_EOD;
2940                 } else if (cmd_in == MTSETBLK ||
2941                            cmd_in == MTSETDENSITY ||
2942                            cmd_in == MTSETDRVBUFFER ||
2943                            cmd_in == SET_DENS_AND_BLK) {
2944                         if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2945                             !(STp->use_pf & PF_TESTED)) {
2946                                 /* Try the other possible state of Page Format if not
2947                                    already tried */
2948                                 STp->use_pf = !STp->use_pf | PF_TESTED;
2949                                 st_release_request(SRpnt);
2950                                 SRpnt = NULL;
2951                                 return st_int_ioctl(STp, cmd_in, arg);
2952                         }
2953                 } else if (chg_eof)
2954                         STps->eof = ST_NOEOF;
2955
2956                 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2957                         STps->eof = ST_EOD;
2958
2959                 st_release_request(SRpnt);
2960                 SRpnt = NULL;
2961         }
2962
2963         return ioctl_result;
2964 }
2965 \f
2966
2967 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2968    structure. */
2969
2970 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2971                         int logical)
2972 {
2973         int result;
2974         unsigned char scmd[MAX_COMMAND_SIZE];
2975         struct st_request *SRpnt;
2976         DEB( char *name = tape_name(STp); )
2977
2978         if (STp->ready != ST_READY)
2979                 return (-EIO);
2980
2981         memset(scmd, 0, MAX_COMMAND_SIZE);
2982         if ((STp->device)->scsi_level < SCSI_2) {
2983                 scmd[0] = QFA_REQUEST_BLOCK;
2984                 scmd[4] = 3;
2985         } else {
2986                 scmd[0] = READ_POSITION;
2987                 if (!logical && !STp->scsi2_logical)
2988                         scmd[1] = 1;
2989         }
2990         SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2991                            STp->device->request_queue->rq_timeout,
2992                            MAX_READY_RETRIES, 1);
2993         if (!SRpnt)
2994                 return (STp->buffer)->syscall_result;
2995
2996         if ((STp->buffer)->syscall_result != 0 ||
2997             (STp->device->scsi_level >= SCSI_2 &&
2998              ((STp->buffer)->b_data[0] & 4) != 0)) {
2999                 *block = *partition = 0;
3000                 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3001                 result = (-EIO);
3002         } else {
3003                 result = 0;
3004                 if ((STp->device)->scsi_level < SCSI_2) {
3005                         *block = ((STp->buffer)->b_data[0] << 16)
3006                             + ((STp->buffer)->b_data[1] << 8)
3007                             + (STp->buffer)->b_data[2];
3008                         *partition = 0;
3009                 } else {
3010                         *block = ((STp->buffer)->b_data[4] << 24)
3011                             + ((STp->buffer)->b_data[5] << 16)
3012                             + ((STp->buffer)->b_data[6] << 8)
3013                             + (STp->buffer)->b_data[7];
3014                         *partition = (STp->buffer)->b_data[1];
3015                         if (((STp->buffer)->b_data[0] & 0x80) &&
3016                             (STp->buffer)->b_data[1] == 0)      /* BOP of partition 0 */
3017                                 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3018                 }
3019                 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3020                             *block, *partition));
3021         }
3022         st_release_request(SRpnt);
3023         SRpnt = NULL;
3024
3025         return result;
3026 }
3027
3028
3029 /* Set the tape block and partition. Negative partition means that only the
3030    block should be set in vendor specific way. */
3031 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3032                         int logical)
3033 {
3034         struct st_partstat *STps;
3035         int result, p;
3036         unsigned int blk;
3037         int timeout;
3038         unsigned char scmd[MAX_COMMAND_SIZE];
3039         struct st_request *SRpnt;
3040         DEB( char *name = tape_name(STp); )
3041
3042         if (STp->ready != ST_READY)
3043                 return (-EIO);
3044         timeout = STp->long_timeout;
3045         STps = &(STp->ps[STp->partition]);
3046
3047         DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3048                     name, block, partition));
3049         DEB(if (partition < 0)
3050                 return (-EIO); )
3051
3052         /* Update the location at the partition we are leaving */
3053         if ((!STp->can_partitions && partition != 0) ||
3054             partition >= ST_NBR_PARTITIONS)
3055                 return (-EINVAL);
3056         if (partition != STp->partition) {
3057                 if (get_location(STp, &blk, &p, 1))
3058                         STps->last_block_valid = 0;
3059                 else {
3060                         STps->last_block_valid = 1;
3061                         STps->last_block_visited = blk;
3062                         DEBC(printk(ST_DEB_MSG
3063                                     "%s: Visited block %d for partition %d saved.\n",
3064                                     name, blk, STp->partition));
3065                 }
3066         }
3067
3068         memset(scmd, 0, MAX_COMMAND_SIZE);
3069         if ((STp->device)->scsi_level < SCSI_2) {
3070                 scmd[0] = QFA_SEEK_BLOCK;
3071                 scmd[2] = (block >> 16);
3072                 scmd[3] = (block >> 8);
3073                 scmd[4] = block;
3074                 scmd[5] = 0;
3075         } else {
3076                 scmd[0] = SEEK_10;
3077                 scmd[3] = (block >> 24);
3078                 scmd[4] = (block >> 16);
3079                 scmd[5] = (block >> 8);
3080                 scmd[6] = block;
3081                 if (!logical && !STp->scsi2_logical)
3082                         scmd[1] = 4;
3083                 if (STp->partition != partition) {
3084                         scmd[1] |= 2;
3085                         scmd[8] = partition;
3086                         DEBC(printk(ST_DEB_MSG
3087                                     "%s: Trying to change partition from %d to %d\n",
3088                                     name, STp->partition, partition));
3089                 }
3090         }
3091         if (STp->immediate) {
3092                 scmd[1] |= 1;           /* Don't wait for completion */
3093                 timeout = STp->device->request_queue->rq_timeout;
3094         }
3095
3096         SRpnt = st_allocate_request(STp);
3097         if (!SRpnt)
3098                 return STp->buffer->syscall_result;
3099
3100         result = st_scsi_kern_execute(SRpnt, scmd, DMA_NONE, NULL, 0,
3101                                       timeout, MAX_READY_RETRIES);
3102         if (result)
3103                 goto out;
3104
3105         STps->drv_block = STps->drv_file = (-1);
3106         STps->eof = ST_NOEOF;
3107         if ((STp->buffer)->syscall_result != 0) {
3108                 result = (-EIO);
3109                 if (STp->can_partitions &&
3110                     (STp->device)->scsi_level >= SCSI_2 &&
3111                     (p = find_partition(STp)) >= 0)
3112                         STp->partition = p;
3113         } else {
3114                 if (STp->can_partitions) {
3115                         STp->partition = partition;
3116                         STps = &(STp->ps[partition]);
3117                         if (!STps->last_block_valid ||
3118                             STps->last_block_visited != block) {
3119                                 STps->at_sm = 0;
3120                                 STps->rw = ST_IDLE;
3121                         }
3122                 } else
3123                         STps->at_sm = 0;
3124                 if (block == 0)
3125                         STps->drv_block = STps->drv_file = 0;
3126                 result = 0;
3127         }
3128 out:
3129         st_release_request(SRpnt);
3130         SRpnt = NULL;
3131
3132         return result;
3133 }
3134
3135
3136 /* Find the current partition number for the drive status. Called from open and
3137    returns either partition number of negative error code. */
3138 static int find_partition(struct scsi_tape *STp)
3139 {
3140         int i, partition;
3141         unsigned int block;
3142
3143         if ((i = get_location(STp, &block, &partition, 1)) < 0)
3144                 return i;
3145         if (partition >= ST_NBR_PARTITIONS)
3146                 return (-EIO);
3147         return partition;
3148 }
3149
3150
3151 /* Change the partition if necessary */
3152 static int switch_partition(struct scsi_tape *STp)
3153 {
3154         struct st_partstat *STps;
3155
3156         if (STp->partition == STp->new_partition)
3157                 return 0;
3158         STps = &(STp->ps[STp->new_partition]);
3159         if (!STps->last_block_valid)
3160                 STps->last_block_visited = 0;
3161         return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3162 }
3163 \f
3164 /* Functions for reading and writing the medium partition mode page. */
3165
3166 #define PART_PAGE   0x11
3167 #define PART_PAGE_FIXED_LENGTH 8
3168
3169 #define PP_OFF_MAX_ADD_PARTS   2
3170 #define PP_OFF_NBR_ADD_PARTS   3
3171 #define PP_OFF_FLAGS           4
3172 #define PP_OFF_PART_UNITS      6
3173 #define PP_OFF_RESERVED        7
3174
3175 #define PP_BIT_IDP             0x20
3176 #define PP_MSK_PSUM_MB         0x10
3177
3178 /* Get the number of partitions on the tape. As a side effect reads the
3179    mode page into the tape buffer. */
3180 static int nbr_partitions(struct scsi_tape *STp)
3181 {
3182         int result;
3183         DEB( char *name = tape_name(STp); )
3184
3185         if (STp->ready != ST_READY)
3186                 return (-EIO);
3187
3188         result = read_mode_page(STp, PART_PAGE, 1);
3189
3190         if (result) {
3191                 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3192                             name));
3193                 result = (-EIO);
3194         } else {
3195                 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3196                                               PP_OFF_NBR_ADD_PARTS] + 1;
3197                 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3198         }
3199
3200         return result;
3201 }
3202
3203
3204 /* Partition the tape into two partitions if size > 0 or one partition if
3205    size == 0.
3206
3207    The block descriptors are read and written because Sony SDT-7000 does not
3208    work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3209
3210    My HP C1533A drive returns only one partition size field. This is used to
3211    set the size of partition 1. There is no size field for the default partition.
3212    Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3213    used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3214    The following algorithm is used to accommodate both drives: if the number of
3215    partition size fields is greater than the maximum number of additional partitions
3216    in the mode page, the second field is used. Otherwise the first field is used.
3217
3218    For Seagate DDS drives the page length must be 8 when no partitions is defined
3219    and 10 when 1 partition is defined (information from Eric Lee Green). This is
3220    is acceptable also to some other old drives and enforced if the first partition
3221    size field is used for the first additional partition size.
3222  */
3223 static int partition_tape(struct scsi_tape *STp, int size)
3224 {
3225         char *name = tape_name(STp);
3226         int result;
3227         int pgo, psd_cnt, psdo;
3228         unsigned char *bp;
3229
3230         result = read_mode_page(STp, PART_PAGE, 0);
3231         if (result) {
3232                 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3233                 return result;
3234         }
3235         /* The mode page is in the buffer. Let's modify it and write it. */
3236         bp = (STp->buffer)->b_data;
3237         pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3238         DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3239                     name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3240
3241         psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3242         psdo = pgo + PART_PAGE_FIXED_LENGTH;
3243         if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3244                 bp[psdo] = bp[psdo + 1] = 0xff;  /* Rest of the tape */
3245                 psdo += 2;
3246         }
3247         memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3248
3249         DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3250                     psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3251                     bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3252
3253         if (size <= 0) {
3254                 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3255                 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3256                     bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3257                 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3258                             name));
3259         } else {
3260                 bp[psdo] = (size >> 8) & 0xff;
3261                 bp[psdo + 1] = size & 0xff;
3262                 bp[pgo + 3] = 1;
3263                 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3264                     bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3265                 DEBC(printk(ST_DEB_MSG
3266                             "%s: Formatting tape with two partitions (1 = %d MB).\n",
3267                             name, size));
3268         }
3269         bp[pgo + PP_OFF_PART_UNITS] = 0;
3270         bp[pgo + PP_OFF_RESERVED] = 0;
3271         bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3272
3273         result = write_mode_page(STp, PART_PAGE, 1);
3274         if (result) {
3275                 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3276                 result = (-EIO);
3277         }
3278
3279         return result;
3280 }
3281 \f
3282
3283
3284 /* The ioctl command */
3285 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3286 {
3287         int i, cmd_nr, cmd_type, bt;
3288         int retval = 0;
3289         unsigned int blk;
3290         struct scsi_tape *STp = file->private_data;
3291         struct st_modedef *STm;
3292         struct st_partstat *STps;
3293         char *name = tape_name(STp);
3294         void __user *p = (void __user *)arg;
3295
3296         if (mutex_lock_interruptible(&STp->lock))
3297                 return -ERESTARTSYS;
3298
3299         DEB(
3300         if (debugging && !STp->in_use) {
3301                 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3302                 retval = (-EIO);
3303                 goto out;
3304         } ) /* end DEB */
3305
3306         STm = &(STp->modes[STp->current_mode]);
3307         STps = &(STp->ps[STp->partition]);
3308
3309         /*
3310          * If we are in the middle of error recovery, don't let anyone
3311          * else try and use this device.  Also, if error recovery fails, it
3312          * may try and take the device offline, in which case all further
3313          * access to the device is prohibited.
3314          */
3315         retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3316                                         file->f_flags & O_NDELAY);
3317         if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3318                 goto out;
3319         retval = 0;
3320
3321         cmd_type = _IOC_TYPE(cmd_in);
3322         cmd_nr = _IOC_NR(cmd_in);
3323
3324         if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3325                 struct mtop mtc;
3326
3327                 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3328                         retval = (-EINVAL);
3329                         goto out;
3330                 }
3331
3332                 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3333                 if (i) {
3334                         retval = (-EFAULT);
3335                         goto out;
3336                 }
3337
3338                 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3339                         printk(KERN_WARNING
3340                                "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3341                         retval = (-EPERM);
3342                         goto out;
3343                 }
3344                 if (!STm->defined &&
3345                     (mtc.mt_op != MTSETDRVBUFFER &&
3346                      (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3347                         retval = (-ENXIO);
3348                         goto out;
3349                 }
3350
3351                 if (!STp->pos_unknown) {
3352
3353                         if (STps->eof == ST_FM_HIT) {
3354                                 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3355                                     mtc.mt_op == MTEOM) {
3356                                         mtc.mt_count -= 1;
3357                                         if (STps->drv_file >= 0)
3358                                                 STps->drv_file += 1;
3359                                 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3360                                         mtc.mt_count += 1;
3361                                         if (STps->drv_file >= 0)
3362                                                 STps->drv_file += 1;
3363                                 }
3364                         }
3365
3366                         if (mtc.mt_op == MTSEEK) {
3367                                 /* Old position must be restored if partition will be
3368                                    changed */
3369                                 i = !STp->can_partitions ||
3370                                     (STp->new_partition != STp->partition);
3371                         } else {
3372                                 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3373                                     mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3374                                     mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3375                                     mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3376                                     mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3377                                     mtc.mt_op == MTCOMPRESSION;
3378                         }
3379                         i = flush_buffer(STp, i);
3380                         if (i < 0) {
3381                                 retval = i;
3382                                 goto out;
3383                         }
3384                         if (STps->rw == ST_WRITING &&
3385                             (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3386                              mtc.mt_op == MTSEEK ||
3387                              mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3388                                 i = st_int_ioctl(STp, MTWEOF, 1);
3389                                 if (i < 0) {
3390                                         retval = i;
3391                                         goto out;
3392                                 }
3393                                 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3394                                         mtc.mt_count++;
3395                                 STps->rw = ST_IDLE;
3396                              }
3397
3398                 } else {
3399                         /*
3400                          * If there was a bus reset, block further access
3401                          * to this device.  If the user wants to rewind the tape,
3402                          * then reset the flag and allow access again.
3403                          */
3404                         if (mtc.mt_op != MTREW &&
3405                             mtc.mt_op != MTOFFL &&
3406                             mtc.mt_op != MTRETEN &&
3407                             mtc.mt_op != MTERASE &&
3408                             mtc.mt_op != MTSEEK &&
3409                             mtc.mt_op != MTEOM) {
3410                                 retval = (-EIO);
3411                                 goto out;
3412                         }
3413                         reset_state(STp);
3414                         /* remove this when the midlevel properly clears was_reset */
3415                         STp->device->was_reset = 0;
3416                 }
3417
3418                 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3419                     mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3420                     mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3421                         STps->rw = ST_IDLE;     /* Prevent automatic WEOF and fsf */
3422
3423                 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3424                         do_door_lock(STp, 0);   /* Ignore result! */
3425
3426                 if (mtc.mt_op == MTSETDRVBUFFER &&
3427                     (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3428                         retval = st_set_options(STp, mtc.mt_count);
3429                         goto out;
3430                 }
3431
3432                 if (mtc.mt_op == MTSETPART) {
3433                         if (!STp->can_partitions ||
3434                             mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3435                                 retval = (-EINVAL);
3436                                 goto out;
3437                         }
3438                         if (mtc.mt_count >= STp->nbr_partitions &&
3439                             (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3440                                 retval = (-EIO);
3441                                 goto out;
3442                         }
3443                         if (mtc.mt_count >= STp->nbr_partitions) {
3444                                 retval = (-EINVAL);
3445                                 goto out;
3446                         }
3447                         STp->new_partition = mtc.mt_count;
3448                         retval = 0;
3449                         goto out;
3450                 }
3451
3452                 if (mtc.mt_op == MTMKPART) {
3453                         if (!STp->can_partitions) {
3454                                 retval = (-EINVAL);
3455                                 goto out;
3456                         }
3457                         if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3458                             (i = partition_tape(STp, mtc.mt_count)) < 0) {
3459                                 retval = i;
3460                                 goto out;
3461                         }
3462                         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3463                                 STp->ps[i].rw = ST_IDLE;
3464                                 STp->ps[i].at_sm = 0;
3465                                 STp->ps[i].last_block_valid = 0;
3466                         }
3467                         STp->partition = STp->new_partition = 0;
3468                         STp->nbr_partitions = 1;        /* Bad guess ?-) */
3469                         STps->drv_block = STps->drv_file = 0;
3470                         retval = 0;
3471                         goto out;
3472                 }
3473
3474                 if (mtc.mt_op == MTSEEK) {
3475                         i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3476                         if (!STp->can_partitions)
3477                                 STp->ps[0].rw = ST_IDLE;
3478                         retval = i;
3479                         goto out;
3480                 }
3481
3482                 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3483                         retval = do_load_unload(STp, file, 0);
3484                         goto out;
3485                 }
3486
3487                 if (mtc.mt_op == MTLOAD) {
3488                         retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3489                         goto out;
3490                 }
3491
3492                 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3493                         retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3494                         goto out;
3495                 }
3496
3497                 if (STp->can_partitions && STp->ready == ST_READY &&
3498                     (i = switch_partition(STp)) < 0) {
3499                         retval = i;
3500                         goto out;
3501                 }
3502
3503                 if (mtc.mt_op == MTCOMPRESSION)
3504                         retval = st_compression(STp, (mtc.mt_count & 1));
3505                 else
3506                         retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3507                 goto out;
3508         }
3509         if (!STm->defined) {
3510                 retval = (-ENXIO);
3511                 goto out;
3512         }
3513
3514         if ((i = flush_buffer(STp, 0)) < 0) {
3515                 retval = i;
3516                 goto out;
3517         }
3518         if (STp->can_partitions &&
3519             (i = switch_partition(STp)) < 0) {
3520                 retval = i;
3521                 goto out;
3522         }
3523
3524         if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3525                 struct mtget mt_status;
3526
3527                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3528                          retval = (-EINVAL);
3529                          goto out;
3530                 }
3531
3532                 mt_status.mt_type = STp->tape_type;
3533                 mt_status.mt_dsreg =
3534                     ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3535                     ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3536                 mt_status.mt_blkno = STps->drv_block;
3537                 mt_status.mt_fileno = STps->drv_file;
3538                 if (STp->block_size != 0) {
3539                         if (STps->rw == ST_WRITING)
3540                                 mt_status.mt_blkno +=
3541                                     (STp->buffer)->buffer_bytes / STp->block_size;
3542                         else if (STps->rw == ST_READING)
3543                                 mt_status.mt_blkno -=
3544                                         ((STp->buffer)->buffer_bytes +
3545                                          STp->block_size - 1) / STp->block_size;
3546                 }
3547
3548                 mt_status.mt_gstat = 0;
3549                 if (STp->drv_write_prot)
3550                         mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3551                 if (mt_status.mt_blkno == 0) {
3552                         if (mt_status.mt_fileno == 0)
3553                                 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3554                         else
3555                                 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3556                 }
3557                 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3558                 mt_status.mt_resid = STp->partition;
3559                 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3560                         mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3561                 else if (STps->eof >= ST_EOM_OK)
3562                         mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3563                 if (STp->density == 1)
3564                         mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3565                 else if (STp->density == 2)
3566                         mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3567                 else if (STp->density == 3)
3568                         mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3569                 if (STp->ready == ST_READY)
3570                         mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3571                 if (STp->ready == ST_NO_TAPE)
3572                         mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3573                 if (STps->at_sm)
3574                         mt_status.mt_gstat |= GMT_SM(0xffffffff);
3575                 if (STm->do_async_writes ||
3576                     (STm->do_buffer_writes && STp->block_size != 0) ||
3577                     STp->drv_buffer != 0)
3578                         mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3579                 if (STp->cleaning_req)
3580                         mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3581
3582                 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3583                 if (i) {
3584                         retval = (-EFAULT);
3585                         goto out;
3586                 }
3587
3588                 STp->recover_reg = 0;           /* Clear after read */
3589                 retval = 0;
3590                 goto out;
3591         }                       /* End of MTIOCGET */
3592         if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3593                 struct mtpos mt_pos;
3594                 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3595                          retval = (-EINVAL);
3596                          goto out;
3597                 }
3598                 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3599                         retval = i;
3600                         goto out;
3601                 }
3602                 mt_pos.mt_blkno = blk;
3603                 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3604                 if (i)
3605                         retval = (-EFAULT);
3606                 goto out;
3607         }
3608         mutex_unlock(&STp->lock);
3609         switch (cmd_in) {
3610                 case SCSI_IOCTL_GET_IDLUN:
3611                 case SCSI_IOCTL_GET_BUS_NUMBER:
3612                         break;
3613                 default:
3614                         if ((cmd_in == SG_IO ||
3615                              cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3616                              cmd_in == CDROM_SEND_PACKET) &&
3617                             !capable(CAP_SYS_RAWIO))
3618                                 i = -EPERM;
3619                         else
3620                                 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3621                                                    file->f_mode, cmd_in, p);
3622                         if (i != -ENOTTY)
3623                                 return i;
3624                         break;
3625         }
3626         retval = scsi_ioctl(STp->device, cmd_in, p);
3627         if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3628                 STp->rew_at_close = 0;
3629                 STp->ready = ST_NO_TAPE;
3630         }
3631         return retval;
3632
3633  out:
3634         mutex_unlock(&STp->lock);
3635         return retval;
3636 }
3637
3638 #ifdef CONFIG_COMPAT
3639 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3640 {
3641         struct scsi_tape *STp = file->private_data;
3642         struct scsi_device *sdev = STp->device;
3643         int ret = -ENOIOCTLCMD;
3644         if (sdev->host->hostt->compat_ioctl) {
3645
3646                 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3647
3648         }
3649         return ret;
3650 }
3651 #endif
3652
3653 \f
3654
3655 /* Try to allocate a new tape buffer. Calling function must not hold
3656    dev_arr_lock. */
3657 static struct st_buffer *
3658  new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3659 {
3660         int i, got = 0;
3661         gfp_t priority;
3662         struct st_buffer *tb;
3663
3664         if (from_initialization)
3665                 priority = GFP_ATOMIC;
3666         else
3667                 priority = GFP_KERNEL;
3668
3669         i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3670                 max_sg * sizeof(struct st_buf_fragment);
3671         tb = kzalloc(i, priority);
3672         if (!tb) {
3673                 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3674                 return NULL;
3675         }
3676         tb->frp_segs = tb->orig_frp_segs = 0;
3677         tb->use_sg = max_sg;
3678         tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3679
3680         tb->dma = need_dma;
3681         tb->buffer_size = got;
3682         sg_init_table(tb->sg, max_sg);
3683
3684         return tb;
3685 }
3686
3687
3688 /* Try to allocate enough space in the tape buffer */
3689 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3690 {
3691         int segs, nbr, max_segs, b_size, order, got;
3692         gfp_t priority;
3693
3694         if (new_size <= STbuffer->buffer_size)
3695                 return 1;
3696
3697         if (STbuffer->buffer_size <= PAGE_SIZE)
3698                 normalize_buffer(STbuffer);  /* Avoid extra segment */
3699
3700         max_segs = STbuffer->use_sg;
3701         nbr = max_segs - STbuffer->frp_segs;
3702         if (nbr <= 0)
3703                 return 0;
3704
3705         priority = GFP_KERNEL | __GFP_NOWARN;
3706         if (need_dma)
3707                 priority |= GFP_DMA;
3708         for (b_size = PAGE_SIZE, order=0; order <= 6 &&
3709              b_size < new_size - STbuffer->buffer_size;
3710              order++, b_size *= 2)
3711                 ;  /* empty */
3712
3713         for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3714              segs < max_segs && got < new_size;) {
3715                 STbuffer->frp[segs].page = alloc_pages(priority, order);
3716                 if (STbuffer->frp[segs].page == NULL) {
3717                         if (new_size - got <= (max_segs - segs) * b_size / 2) {
3718                                 b_size /= 2; /* Large enough for the rest of the buffers */
3719                                 order--;
3720                                 continue;
3721                         }
3722                         DEB(STbuffer->buffer_size = got);
3723                         normalize_buffer(STbuffer);
3724                         return 0;
3725                 }
3726                 STbuffer->frp[segs].length = b_size;
3727                 STbuffer->frp_segs += 1;
3728                 got += b_size;
3729                 STbuffer->buffer_size = got;
3730                 if (STbuffer->cleared)
3731                         memset(page_address(STbuffer->frp[segs].page), 0, b_size);
3732                 segs++;
3733         }
3734         STbuffer->b_data = page_address(STbuffer->frp[0].page);
3735
3736         return 1;
3737 }
3738
3739
3740 /* Make sure that no data from previous user is in the internal buffer */
3741 static void clear_buffer(struct st_buffer * st_bp)
3742 {
3743         int i;
3744
3745         for (i=0; i < st_bp->frp_segs; i++)
3746                 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3747         st_bp->cleared = 1;
3748 }
3749
3750
3751 /* Release the extra buffer */
3752 static void normalize_buffer(struct st_buffer * STbuffer)
3753 {
3754         int i, order;
3755
3756         for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3757                 order = get_order(STbuffer->frp[i].length);
3758                 __free_pages(STbuffer->frp[i].page, order);
3759                 STbuffer->buffer_size -= STbuffer->frp[i].length;
3760         }
3761         STbuffer->frp_segs = STbuffer->orig_frp_segs;
3762         STbuffer->frp_sg_current = 0;
3763         STbuffer->sg_segs = 0;
3764 }
3765
3766
3767 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3768    negative error code. */
3769 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3770 {
3771         int i, cnt, res, offset;
3772
3773         for (i = 0, offset = st_bp->buffer_bytes;
3774              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3775                 offset -= st_bp->frp[i].length;
3776         if (i == st_bp->frp_segs) {     /* Should never happen */
3777                 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3778                 return (-EIO);
3779         }
3780         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3781                 cnt = st_bp->frp[i].length - offset < do_count ?
3782                     st_bp->frp[i].length - offset : do_count;
3783                 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3784                 if (res)
3785                         return (-EFAULT);
3786                 do_count -= cnt;
3787                 st_bp->buffer_bytes += cnt;
3788                 ubp += cnt;
3789                 offset = 0;
3790         }
3791         if (do_count) /* Should never happen */
3792                 return (-EIO);
3793
3794         return 0;
3795 }
3796
3797
3798 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3799    negative error code. */
3800 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3801 {
3802         int i, cnt, res, offset;
3803
3804         for (i = 0, offset = st_bp->read_pointer;
3805              i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3806                 offset -= st_bp->frp[i].length;
3807         if (i == st_bp->frp_segs) {     /* Should never happen */
3808                 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3809                 return (-EIO);
3810         }
3811         for (; i < st_bp->frp_segs && do_count > 0; i++) {
3812                 cnt = st_bp->frp[i].length - offset < do_count ?
3813                     st_bp->frp[i].length - offset : do_count;
3814                 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3815                 if (res)
3816                         return (-EFAULT);
3817                 do_count -= cnt;
3818                 st_bp->buffer_bytes -= cnt;
3819                 st_bp->read_pointer += cnt;
3820                 ubp += cnt;
3821                 offset = 0;
3822         }
3823         if (do_count) /* Should never happen */
3824                 return (-EIO);
3825
3826         return 0;
3827 }
3828
3829
3830 /* Move data towards start of buffer */
3831 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3832 {
3833         int src_seg, dst_seg, src_offset = 0, dst_offset;
3834         int count, total;
3835
3836         if (offset == 0)
3837                 return;
3838
3839         total=st_bp->buffer_bytes - offset;
3840         for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3841                 src_offset = offset;
3842                 if (src_offset < st_bp->frp[src_seg].length)
3843                         break;
3844                 offset -= st_bp->frp[src_seg].length;
3845         }
3846
3847         st_bp->buffer_bytes = st_bp->read_pointer = total;
3848         for (dst_seg=dst_offset=0; total > 0; ) {
3849                 count = min(st_bp->frp[dst_seg].length - dst_offset,
3850                             st_bp->frp[src_seg].length - src_offset);
3851                 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3852                         page_address(st_bp->frp[src_seg].page) + src_offset, count);
3853                 src_offset += count;
3854                 if (src_offset >= st_bp->frp[src_seg].length) {
3855                         src_seg++;
3856                         src_offset = 0;
3857                 }
3858                 dst_offset += count;
3859                 if (dst_offset >= st_bp->frp[dst_seg].length) {
3860                         dst_seg++;
3861                         dst_offset = 0;
3862                 }
3863                 total -= count;
3864         }
3865 }
3866
3867
3868 /* Fill the s/g list up to the length required for this transfer */
3869 static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3870 {
3871         int i;
3872         unsigned int count;
3873         struct scatterlist *sg;
3874         struct st_buf_fragment *frp;
3875
3876         if (length == STbp->frp_sg_current)
3877                 return;   /* work already done */
3878
3879         sg = &(STbp->sg[0]);
3880         frp = STbp->frp;
3881         for (i=count=0; count < length; i++) {
3882                 if (length - count > frp[i].length)
3883                         sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
3884                 else
3885                         sg_set_page(&sg[i], frp[i].page, length - count, 0);
3886                 count += sg[i].length;
3887         }
3888         STbp->sg_segs = i;
3889         STbp->frp_sg_current = length;
3890 }
3891
3892
3893 /* Validate the options from command line or module parameters */
3894 static void validate_options(void)
3895 {
3896         if (buffer_kbs > 0)
3897                 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3898         if (max_sg_segs >= ST_FIRST_SG)
3899                 st_max_sg_segs = max_sg_segs;
3900 }
3901
3902 #ifndef MODULE
3903 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3904  */
3905 static int __init st_setup(char *str)
3906 {
3907         int i, len, ints[5];
3908         char *stp;
3909
3910         stp = get_options(str, ARRAY_SIZE(ints), ints);
3911
3912         if (ints[0] > 0) {
3913                 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3914                         if (parms[i].val)
3915                                 *parms[i].val = ints[i + 1];
3916         } else {
3917                 while (stp != NULL) {
3918                         for (i = 0; i < ARRAY_SIZE(parms); i++) {
3919                                 len = strlen(parms[i].name);
3920                                 if (!strncmp(stp, parms[i].name, len) &&
3921                                     (*(stp + len) == ':' || *(stp + len) == '=')) {
3922                                         if (parms[i].val)
3923                                                 *parms[i].val =
3924                                                         simple_strtoul(stp + len + 1, NULL, 0);
3925                                         else
3926                                                 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3927                                                        parms[i].name);
3928                                         break;
3929                                 }
3930                         }
3931                         if (i >= ARRAY_SIZE(parms))
3932                                  printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3933                                         stp);
3934                         stp = strchr(stp, ',');
3935                         if (stp)
3936                                 stp++;
3937                 }
3938         }
3939
3940         validate_options();
3941
3942         return 1;
3943 }
3944
3945 __setup("st=", st_setup);
3946
3947 #endif
3948
3949 static const struct file_operations st_fops =
3950 {
3951         .owner =        THIS_MODULE,
3952         .read =         st_read,
3953         .write =        st_write,
3954         .unlocked_ioctl = st_ioctl,
3955 #ifdef CONFIG_COMPAT
3956         .compat_ioctl = st_compat_ioctl,
3957 #endif
3958         .open =         st_open,
3959         .flush =        st_flush,
3960         .release =      st_release,
3961 };
3962
3963 static int st_probe(struct device *dev)
3964 {
3965         struct scsi_device *SDp = to_scsi_device(dev);
3966         struct gendisk *disk = NULL;
3967         struct cdev *cdev = NULL;
3968         struct scsi_tape *tpnt = NULL;
3969         struct st_modedef *STm;
3970         struct st_partstat *STps;
3971         struct st_buffer *buffer;
3972         int i, j, mode, dev_num, error;
3973         char *stp;
3974
3975         if (SDp->type != TYPE_TAPE)
3976                 return -ENODEV;
3977         if ((stp = st_incompatible(SDp))) {
3978                 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3979                 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3980                 return -ENODEV;
3981         }
3982
3983         i = min(SDp->request_queue->max_hw_segments,
3984                 SDp->request_queue->max_phys_segments);
3985         if (st_max_sg_segs < i)
3986                 i = st_max_sg_segs;
3987         buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3988         if (buffer == NULL) {
3989                 printk(KERN_ERR
3990                        "st: Can't allocate new tape buffer. Device not attached.\n");
3991                 goto out;
3992         }
3993
3994         disk = alloc_disk(1);
3995         if (!disk) {
3996                 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3997                 goto out_buffer_free;
3998         }
3999
4000         write_lock(&st_dev_arr_lock);
4001         if (st_nr_dev >= st_dev_max) {
4002                 struct scsi_tape **tmp_da;
4003                 int tmp_dev_max;
4004
4005                 tmp_dev_max = max(st_nr_dev * 2, 8);
4006                 if (tmp_dev_max > ST_MAX_TAPES)
4007                         tmp_dev_max = ST_MAX_TAPES;
4008                 if (tmp_dev_max <= st_nr_dev) {
4009                         write_unlock(&st_dev_arr_lock);
4010                         printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4011                                ST_MAX_TAPES);
4012                         goto out_put_disk;
4013                 }
4014
4015                 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4016                 if (tmp_da == NULL) {
4017                         write_unlock(&st_dev_arr_lock);
4018                         printk(KERN_ERR "st: Can't extend device array.\n");
4019                         goto out_put_disk;
4020                 }
4021
4022                 if (scsi_tapes != NULL) {
4023                         memcpy(tmp_da, scsi_tapes,
4024                                st_dev_max * sizeof(struct scsi_tape *));
4025                         kfree(scsi_tapes);
4026                 }
4027                 scsi_tapes = tmp_da;
4028
4029                 st_dev_max = tmp_dev_max;
4030         }
4031
4032         for (i = 0; i < st_dev_max; i++)
4033                 if (scsi_tapes[i] == NULL)
4034                         break;
4035         if (i >= st_dev_max)
4036                 panic("scsi_devices corrupt (st)");
4037
4038         tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4039         if (tpnt == NULL) {
4040                 write_unlock(&st_dev_arr_lock);
4041                 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4042                 goto out_put_disk;
4043         }
4044         kref_init(&tpnt->kref);
4045         tpnt->disk = disk;
4046         sprintf(disk->disk_name, "st%d", i);
4047         disk->private_data = &tpnt->driver;
4048         disk->queue = SDp->request_queue;
4049         tpnt->driver = &st_template;
4050         scsi_tapes[i] = tpnt;
4051         dev_num = i;
4052
4053         tpnt->device = SDp;
4054         if (SDp->scsi_level <= 2)
4055                 tpnt->tape_type = MT_ISSCSI1;
4056         else
4057                 tpnt->tape_type = MT_ISSCSI2;
4058
4059         tpnt->buffer = buffer;
4060         tpnt->buffer->last_SRpnt = NULL;
4061
4062         tpnt->inited = 0;
4063         tpnt->dirty = 0;
4064         tpnt->in_use = 0;
4065         tpnt->drv_buffer = 1;   /* Try buffering if no mode sense */
4066         tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4067         tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4068         tpnt->density = 0;
4069         tpnt->do_auto_lock = ST_AUTO_LOCK;
4070         tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4071         tpnt->can_partitions = 0;
4072         tpnt->two_fm = ST_TWO_FM;
4073         tpnt->fast_mteom = ST_FAST_MTEOM;
4074         tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4075         tpnt->sili = ST_SILI;
4076         tpnt->immediate = ST_NOWAIT;
4077         tpnt->default_drvbuffer = 0xff;         /* No forced buffering */
4078         tpnt->partition = 0;
4079         tpnt->new_partition = 0;
4080         tpnt->nbr_partitions = 0;
4081         blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4082         tpnt->long_timeout = ST_LONG_TIMEOUT;
4083         tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4084
4085         for (i = 0; i < ST_NBR_MODES; i++) {
4086                 STm = &(tpnt->modes[i]);
4087                 STm->defined = 0;
4088                 STm->sysv = ST_SYSV;
4089                 STm->defaults_for_writes = 0;
4090                 STm->do_async_writes = ST_ASYNC_WRITES;
4091                 STm->do_buffer_writes = ST_BUFFER_WRITES;
4092                 STm->do_read_ahead = ST_READ_AHEAD;
4093                 STm->default_compression = ST_DONT_TOUCH;
4094                 STm->default_blksize = (-1);    /* No forced size */
4095                 STm->default_density = (-1);    /* No forced density */
4096         }
4097
4098         for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4099                 STps = &(tpnt->ps[i]);
4100                 STps->rw = ST_IDLE;
4101                 STps->eof = ST_NOEOF;
4102                 STps->at_sm = 0;
4103                 STps->last_block_valid = 0;
4104                 STps->drv_block = (-1);
4105                 STps->drv_file = (-1);
4106         }
4107
4108         tpnt->current_mode = 0;
4109         tpnt->modes[0].defined = 1;
4110
4111         tpnt->density_changed = tpnt->compression_changed =
4112             tpnt->blksize_changed = 0;
4113         mutex_init(&tpnt->lock);
4114
4115         st_nr_dev++;
4116         write_unlock(&st_dev_arr_lock);
4117
4118         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4119                 STm = &(tpnt->modes[mode]);
4120                 for (j=0; j < 2; j++) {
4121                         cdev = cdev_alloc();
4122                         if (!cdev) {
4123                                 printk(KERN_ERR
4124                                        "st%d: out of memory. Device not attached.\n",
4125                                        dev_num);
4126                                 goto out_free_tape;
4127                         }
4128                         cdev->owner = THIS_MODULE;
4129                         cdev->ops = &st_fops;
4130
4131                         error = cdev_add(cdev,
4132                                          MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4133                                          1);
4134                         if (error) {
4135                                 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4136                                        dev_num, j ? "non" : "auto", mode);
4137                                 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4138                                 goto out_free_tape;
4139                         }
4140                         STm->cdevs[j] = cdev;
4141
4142                 }
4143                 error = do_create_class_files(tpnt, dev_num, mode);
4144                 if (error)
4145                         goto out_free_tape;
4146         }
4147
4148         sdev_printk(KERN_NOTICE, SDp,
4149                     "Attached scsi tape %s\n", tape_name(tpnt));
4150         sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4151                     tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4152                     queue_dma_alignment(SDp->request_queue) + 1);
4153
4154         return 0;
4155
4156 out_free_tape:
4157         for (mode=0; mode < ST_NBR_MODES; mode++) {
4158                 STm = &(tpnt->modes[mode]);
4159                 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4160                                   "tape");
4161                 for (j=0; j < 2; j++) {
4162                         if (STm->cdevs[j]) {
4163                                 if (cdev == STm->cdevs[j])
4164                                         cdev = NULL;
4165                                         device_destroy(st_sysfs_class,
4166                                                        MKDEV(SCSI_TAPE_MAJOR,
4167                                                              TAPE_MINOR(i, mode, j)));
4168                                 cdev_del(STm->cdevs[j]);
4169                         }
4170                 }
4171         }
4172         if (cdev)
4173                 cdev_del(cdev);
4174         write_lock(&st_dev_arr_lock);
4175         scsi_tapes[dev_num] = NULL;
4176         st_nr_dev--;
4177         write_unlock(&st_dev_arr_lock);
4178 out_put_disk:
4179         put_disk(disk);
4180         kfree(tpnt);
4181 out_buffer_free:
4182         kfree(buffer);
4183 out:
4184         return -ENODEV;
4185 };
4186
4187
4188 static int st_remove(struct device *dev)
4189 {
4190         struct scsi_device *SDp = to_scsi_device(dev);
4191         struct scsi_tape *tpnt;
4192         int i, j, mode;
4193
4194         write_lock(&st_dev_arr_lock);
4195         for (i = 0; i < st_dev_max; i++) {
4196                 tpnt = scsi_tapes[i];
4197                 if (tpnt != NULL && tpnt->device == SDp) {
4198                         scsi_tapes[i] = NULL;
4199                         st_nr_dev--;
4200                         write_unlock(&st_dev_arr_lock);
4201                         sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4202                                           "tape");
4203                         for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4204                                 for (j=0; j < 2; j++) {
4205                                         device_destroy(st_sysfs_class,
4206                                                        MKDEV(SCSI_TAPE_MAJOR,
4207                                                              TAPE_MINOR(i, mode, j)));
4208                                         cdev_del(tpnt->modes[mode].cdevs[j]);
4209                                         tpnt->modes[mode].cdevs[j] = NULL;
4210                                 }
4211                         }
4212
4213                         mutex_lock(&st_ref_mutex);
4214                         kref_put(&tpnt->kref, scsi_tape_release);
4215                         mutex_unlock(&st_ref_mutex);
4216                         return 0;
4217                 }
4218         }
4219
4220         write_unlock(&st_dev_arr_lock);
4221         return 0;
4222 }
4223
4224 /**
4225  *      scsi_tape_release - Called to free the Scsi_Tape structure
4226  *      @kref: pointer to embedded kref
4227  *
4228  *      st_ref_mutex must be held entering this routine.  Because it is
4229  *      called on last put, you should always use the scsi_tape_get()
4230  *      scsi_tape_put() helpers which manipulate the semaphore directly
4231  *      and never do a direct kref_put().
4232  **/
4233 static void scsi_tape_release(struct kref *kref)
4234 {
4235         struct scsi_tape *tpnt = to_scsi_tape(kref);
4236         struct gendisk *disk = tpnt->disk;
4237
4238         tpnt->device = NULL;
4239
4240         if (tpnt->buffer) {
4241                 tpnt->buffer->orig_frp_segs = 0;
4242                 normalize_buffer(tpnt->buffer);
4243                 kfree(tpnt->buffer);
4244         }
4245
4246         disk->private_data = NULL;
4247         put_disk(disk);
4248         kfree(tpnt);
4249         return;
4250 }
4251
4252 static int __init init_st(void)
4253 {
4254         int err;
4255
4256         validate_options();
4257
4258         printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4259                 verstr, st_fixed_buffer_size, st_max_sg_segs);
4260
4261         st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
4262         if (IS_ERR(st_sysfs_class)) {
4263                 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
4264                 return PTR_ERR(st_sysfs_class);
4265         }
4266
4267         err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4268                                      ST_MAX_TAPE_ENTRIES, "st");
4269         if (err) {
4270                 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4271                        SCSI_TAPE_MAJOR);
4272                 goto err_class;
4273         }
4274
4275         err = scsi_register_driver(&st_template.gendrv);
4276         if (err)
4277                 goto err_chrdev;
4278
4279         err = do_create_sysfs_files();
4280         if (err)
4281                 goto err_scsidrv;
4282
4283         return 0;
4284
4285 err_scsidrv:
4286         scsi_unregister_driver(&st_template.gendrv);
4287 err_chrdev:
4288         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4289                                  ST_MAX_TAPE_ENTRIES);
4290 err_class:
4291         class_destroy(st_sysfs_class);
4292         return err;
4293 }
4294
4295 static void __exit exit_st(void)
4296 {
4297         do_remove_sysfs_files();
4298         scsi_unregister_driver(&st_template.gendrv);
4299         unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4300                                  ST_MAX_TAPE_ENTRIES);
4301         class_destroy(st_sysfs_class);
4302         kfree(scsi_tapes);
4303         printk(KERN_INFO "st: Unloaded.\n");
4304 }
4305
4306 module_init(init_st);
4307 module_exit(exit_st);
4308
4309
4310 /* The sysfs driver interface. Read-only at the moment */
4311 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4312 {
4313         return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4314 }
4315 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4316
4317 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4318 {
4319         return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4320 }
4321 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4322
4323 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4324 {
4325         return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4326 }
4327 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4328
4329 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4330 {
4331         return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4332 }
4333 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4334
4335 static int do_create_sysfs_files(void)
4336 {
4337         struct device_driver *sysfs = &st_template.gendrv;
4338         int err;
4339
4340         err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4341         if (err)
4342                 return err;
4343         err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4344         if (err)
4345                 goto err_try_direct_io;
4346         err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4347         if (err)
4348                 goto err_attr_fixed_buf;
4349         err = driver_create_file(sysfs, &driver_attr_version);
4350         if (err)
4351                 goto err_attr_max_sg;
4352
4353         return 0;
4354
4355 err_attr_max_sg:
4356         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4357 err_attr_fixed_buf:
4358         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4359 err_try_direct_io:
4360         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4361         return err;
4362 }
4363
4364 static void do_remove_sysfs_files(void)
4365 {
4366         struct device_driver *sysfs = &st_template.gendrv;
4367
4368         driver_remove_file(sysfs, &driver_attr_version);
4369         driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4370         driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4371         driver_remove_file(sysfs, &driver_attr_try_direct_io);
4372 }
4373
4374
4375 /* The sysfs simple class interface */
4376 static ssize_t
4377 st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4378 {
4379         struct st_modedef *STm = dev_get_drvdata(dev);
4380         ssize_t l = 0;
4381
4382         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4383         return l;
4384 }
4385
4386 DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
4387
4388 static ssize_t
4389 st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
4390 {
4391         struct st_modedef *STm = dev_get_drvdata(dev);
4392         ssize_t l = 0;
4393
4394         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4395         return l;
4396 }
4397
4398 DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
4399
4400 static ssize_t
4401 st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
4402 {
4403         struct st_modedef *STm = dev_get_drvdata(dev);
4404         ssize_t l = 0;
4405         char *fmt;
4406
4407         fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4408         l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4409         return l;
4410 }
4411
4412 DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
4413
4414 static ssize_t
4415 st_defcompression_show(struct device *dev, struct device_attribute *attr,
4416                        char *buf)
4417 {
4418         struct st_modedef *STm = dev_get_drvdata(dev);
4419         ssize_t l = 0;
4420
4421         l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4422         return l;
4423 }
4424
4425 DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
4426
4427 static ssize_t
4428 st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
4429 {
4430         struct st_modedef *STm = dev_get_drvdata(dev);
4431         struct scsi_tape *STp;
4432         int i, j, options;
4433         ssize_t l = 0;
4434
4435         for (i=0; i < st_dev_max; i++) {
4436                 for (j=0; j < ST_NBR_MODES; j++)
4437                         if (&scsi_tapes[i]->modes[j] == STm)
4438                                 break;
4439                 if (j < ST_NBR_MODES)
4440                         break;
4441         }
4442         if (i == st_dev_max)
4443                 return 0;  /* should never happen */
4444
4445         STp = scsi_tapes[i];
4446
4447         options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4448         options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4449         options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4450         DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4451         options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4452         options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4453         options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4454         options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4455         options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4456         options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4457         options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4458         options |= STm->sysv ? MT_ST_SYSV : 0;
4459         options |= STp->immediate ? MT_ST_NOWAIT : 0;
4460         options |= STp->sili ? MT_ST_SILI : 0;
4461
4462         l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4463         return l;
4464 }
4465
4466 DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
4467
4468 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4469 {
4470         int i, rew, error;
4471         char name[10];
4472         struct device *st_class_member;
4473
4474         for (rew=0; rew < 2; rew++) {
4475                 /* Make sure that the minor numbers corresponding to the four
4476                    first modes always get the same names */
4477                 i = mode << (4 - ST_NBR_MODE_BITS);
4478                 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4479                          STp->disk->disk_name, st_formats[i]);
4480                 st_class_member =
4481                         device_create(st_sysfs_class, &STp->device->sdev_gendev,
4482                                       MKDEV(SCSI_TAPE_MAJOR,
4483                                             TAPE_MINOR(dev_num, mode, rew)),
4484                                       &STp->modes[mode], "%s", name);
4485                 if (IS_ERR(st_class_member)) {
4486                         printk(KERN_WARNING "st%d: device_create failed\n",
4487                                dev_num);
4488                         error = PTR_ERR(st_class_member);
4489                         goto out;
4490                 }
4491
4492                 error = device_create_file(st_class_member,
4493                                            &dev_attr_defined);
4494                 if (error) goto out;
4495                 error = device_create_file(st_class_member,
4496                                            &dev_attr_default_blksize);
4497                 if (error) goto out;
4498                 error = device_create_file(st_class_member,
4499                                            &dev_attr_default_density);
4500                 if (error) goto out;
4501                 error = device_create_file(st_class_member,
4502                                            &dev_attr_default_compression);
4503                 if (error) goto out;
4504                 error = device_create_file(st_class_member,
4505                                            &dev_attr_options);
4506                 if (error) goto out;
4507
4508                 if (mode == 0 && rew == 0) {
4509                         error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4510                                                   &st_class_member->kobj,
4511                                                   "tape");
4512                         if (error) {
4513                                 printk(KERN_ERR
4514                                        "st%d: Can't create sysfs link from SCSI device.\n",
4515                                        dev_num);
4516                                 goto out;
4517                         }
4518                 }
4519         }
4520
4521         return 0;
4522
4523 out:
4524         return error;
4525 }
4526
4527 /* The following functions may be useful for a larger audience. */
4528 static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4529                               unsigned long uaddr, size_t count, int rw)
4530 {
4531         unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4532         unsigned long start = uaddr >> PAGE_SHIFT;
4533         const int nr_pages = end - start;
4534         int res, i, j;
4535         struct page **pages;
4536
4537         /* User attempted Overflow! */
4538         if ((uaddr + count) < uaddr)
4539                 return -EINVAL;
4540
4541         /* Too big */
4542         if (nr_pages > max_pages)
4543                 return -ENOMEM;
4544
4545         /* Hmm? */
4546         if (count == 0)
4547                 return 0;
4548
4549         if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4550                 return -ENOMEM;
4551
4552         /* Try to fault in all of the necessary pages */
4553         down_read(&current->mm->mmap_sem);
4554         /* rw==READ means read from drive, write into memory area */
4555         res = get_user_pages(
4556                 current,
4557                 current->mm,
4558                 uaddr,
4559                 nr_pages,
4560                 rw == READ,
4561                 0, /* don't force */
4562                 pages,
4563                 NULL);
4564         up_read(&current->mm->mmap_sem);
4565
4566         /* Errors and no page mapped should return here */
4567         if (res < nr_pages)
4568                 goto out_unmap;
4569
4570         for (i=0; i < nr_pages; i++) {
4571                 /* FIXME: flush superflous for rw==READ,
4572                  * probably wrong function for rw==WRITE
4573                  */
4574                 flush_dcache_page(pages[i]);
4575         }
4576
4577         /* Populate the scatter/gather list */
4578         sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
4579         if (nr_pages > 1) {
4580                 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4581                 count -= sgl[0].length;
4582                 for (i=1; i < nr_pages ; i++) {
4583                         sg_set_page(&sgl[i], pages[i],
4584                                     count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
4585                         count -= PAGE_SIZE;
4586                 }
4587         }
4588         else {
4589                 sgl[0].length = count;
4590         }
4591
4592         kfree(pages);
4593         return nr_pages;
4594
4595  out_unmap:
4596         if (res > 0) {
4597                 for (j=0; j < res; j++)
4598                         page_cache_release(pages[j]);
4599                 res = 0;
4600         }
4601         kfree(pages);
4602         return res;
4603 }
4604
4605
4606 /* And unmap them... */
4607 static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4608                                 int dirtied)
4609 {
4610         int i;
4611
4612         for (i=0; i < nr_pages; i++) {
4613                 struct page *page = sg_page(&sgl[i]);
4614
4615                 if (dirtied)
4616                         SetPageDirty(page);
4617                 /* FIXME: cache flush missing for rw==READ
4618                  * FIXME: call the correct reference counting function
4619                  */
4620                 page_cache_release(page);
4621         }
4622
4623         return 0;
4624 }