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

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