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