git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/st.c

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