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