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

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